diff options
Diffstat (limited to 'pkg/sentry')
50 files changed, 4086 insertions, 4086 deletions
diff --git a/pkg/sentry/devices/memdev/memdev_state_autogen.go b/pkg/sentry/devices/memdev/memdev_state_autogen.go index 5064e0f59..88de3f2ea 100644 --- a/pkg/sentry/devices/memdev/memdev_state_autogen.go +++ b/pkg/sentry/devices/memdev/memdev_state_autogen.go @@ -25,11 +25,11 @@ func (f *fullDevice) afterLoad() {} func (f *fullDevice) StateLoad(stateSourceObject state.Source) { } -func (f *fullFD) StateTypeName() string { +func (fd *fullFD) StateTypeName() string { return "pkg/sentry/devices/memdev.fullFD" } -func (f *fullFD) StateFields() []string { +func (fd *fullFD) StateFields() []string { return []string{ "vfsfd", "FileDescriptionDefaultImpl", @@ -38,23 +38,23 @@ func (f *fullFD) StateFields() []string { } } -func (f *fullFD) beforeSave() {} +func (fd *fullFD) beforeSave() {} -func (f *fullFD) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.vfsfd) - stateSinkObject.Save(1, &f.FileDescriptionDefaultImpl) - stateSinkObject.Save(2, &f.DentryMetadataFileDescriptionImpl) - stateSinkObject.Save(3, &f.NoLockFD) +func (fd *fullFD) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.vfsfd) + stateSinkObject.Save(1, &fd.FileDescriptionDefaultImpl) + stateSinkObject.Save(2, &fd.DentryMetadataFileDescriptionImpl) + stateSinkObject.Save(3, &fd.NoLockFD) } -func (f *fullFD) afterLoad() {} +func (fd *fullFD) afterLoad() {} -func (f *fullFD) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.vfsfd) - stateSourceObject.Load(1, &f.FileDescriptionDefaultImpl) - stateSourceObject.Load(2, &f.DentryMetadataFileDescriptionImpl) - stateSourceObject.Load(3, &f.NoLockFD) +func (fd *fullFD) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.vfsfd) + stateSourceObject.Load(1, &fd.FileDescriptionDefaultImpl) + stateSourceObject.Load(2, &fd.DentryMetadataFileDescriptionImpl) + stateSourceObject.Load(3, &fd.NoLockFD) } func (n *nullDevice) StateTypeName() string { @@ -76,11 +76,11 @@ func (n *nullDevice) afterLoad() {} func (n *nullDevice) StateLoad(stateSourceObject state.Source) { } -func (n *nullFD) StateTypeName() string { +func (fd *nullFD) StateTypeName() string { return "pkg/sentry/devices/memdev.nullFD" } -func (n *nullFD) StateFields() []string { +func (fd *nullFD) StateFields() []string { return []string{ "vfsfd", "FileDescriptionDefaultImpl", @@ -89,23 +89,23 @@ func (n *nullFD) StateFields() []string { } } -func (n *nullFD) beforeSave() {} +func (fd *nullFD) beforeSave() {} -func (n *nullFD) StateSave(stateSinkObject state.Sink) { - n.beforeSave() - stateSinkObject.Save(0, &n.vfsfd) - stateSinkObject.Save(1, &n.FileDescriptionDefaultImpl) - stateSinkObject.Save(2, &n.DentryMetadataFileDescriptionImpl) - stateSinkObject.Save(3, &n.NoLockFD) +func (fd *nullFD) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.vfsfd) + stateSinkObject.Save(1, &fd.FileDescriptionDefaultImpl) + stateSinkObject.Save(2, &fd.DentryMetadataFileDescriptionImpl) + stateSinkObject.Save(3, &fd.NoLockFD) } -func (n *nullFD) afterLoad() {} +func (fd *nullFD) afterLoad() {} -func (n *nullFD) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &n.vfsfd) - stateSourceObject.Load(1, &n.FileDescriptionDefaultImpl) - stateSourceObject.Load(2, &n.DentryMetadataFileDescriptionImpl) - stateSourceObject.Load(3, &n.NoLockFD) +func (fd *nullFD) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.vfsfd) + stateSourceObject.Load(1, &fd.FileDescriptionDefaultImpl) + stateSourceObject.Load(2, &fd.DentryMetadataFileDescriptionImpl) + stateSourceObject.Load(3, &fd.NoLockFD) } func (r *randomDevice) StateTypeName() string { @@ -127,11 +127,11 @@ func (r *randomDevice) afterLoad() {} func (r *randomDevice) StateLoad(stateSourceObject state.Source) { } -func (r *randomFD) StateTypeName() string { +func (fd *randomFD) StateTypeName() string { return "pkg/sentry/devices/memdev.randomFD" } -func (r *randomFD) StateFields() []string { +func (fd *randomFD) StateFields() []string { return []string{ "vfsfd", "FileDescriptionDefaultImpl", @@ -141,25 +141,25 @@ func (r *randomFD) StateFields() []string { } } -func (r *randomFD) beforeSave() {} +func (fd *randomFD) beforeSave() {} -func (r *randomFD) StateSave(stateSinkObject state.Sink) { - r.beforeSave() - stateSinkObject.Save(0, &r.vfsfd) - stateSinkObject.Save(1, &r.FileDescriptionDefaultImpl) - stateSinkObject.Save(2, &r.DentryMetadataFileDescriptionImpl) - stateSinkObject.Save(3, &r.NoLockFD) - stateSinkObject.Save(4, &r.off) +func (fd *randomFD) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.vfsfd) + stateSinkObject.Save(1, &fd.FileDescriptionDefaultImpl) + stateSinkObject.Save(2, &fd.DentryMetadataFileDescriptionImpl) + stateSinkObject.Save(3, &fd.NoLockFD) + stateSinkObject.Save(4, &fd.off) } -func (r *randomFD) afterLoad() {} +func (fd *randomFD) afterLoad() {} -func (r *randomFD) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &r.vfsfd) - stateSourceObject.Load(1, &r.FileDescriptionDefaultImpl) - stateSourceObject.Load(2, &r.DentryMetadataFileDescriptionImpl) - stateSourceObject.Load(3, &r.NoLockFD) - stateSourceObject.Load(4, &r.off) +func (fd *randomFD) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.vfsfd) + stateSourceObject.Load(1, &fd.FileDescriptionDefaultImpl) + stateSourceObject.Load(2, &fd.DentryMetadataFileDescriptionImpl) + stateSourceObject.Load(3, &fd.NoLockFD) + stateSourceObject.Load(4, &fd.off) } func (z *zeroDevice) StateTypeName() string { @@ -181,11 +181,11 @@ func (z *zeroDevice) afterLoad() {} func (z *zeroDevice) StateLoad(stateSourceObject state.Source) { } -func (z *zeroFD) StateTypeName() string { +func (fd *zeroFD) StateTypeName() string { return "pkg/sentry/devices/memdev.zeroFD" } -func (z *zeroFD) StateFields() []string { +func (fd *zeroFD) StateFields() []string { return []string{ "vfsfd", "FileDescriptionDefaultImpl", @@ -194,23 +194,23 @@ func (z *zeroFD) StateFields() []string { } } -func (z *zeroFD) beforeSave() {} +func (fd *zeroFD) beforeSave() {} -func (z *zeroFD) StateSave(stateSinkObject state.Sink) { - z.beforeSave() - stateSinkObject.Save(0, &z.vfsfd) - stateSinkObject.Save(1, &z.FileDescriptionDefaultImpl) - stateSinkObject.Save(2, &z.DentryMetadataFileDescriptionImpl) - stateSinkObject.Save(3, &z.NoLockFD) +func (fd *zeroFD) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.vfsfd) + stateSinkObject.Save(1, &fd.FileDescriptionDefaultImpl) + stateSinkObject.Save(2, &fd.DentryMetadataFileDescriptionImpl) + stateSinkObject.Save(3, &fd.NoLockFD) } -func (z *zeroFD) afterLoad() {} +func (fd *zeroFD) afterLoad() {} -func (z *zeroFD) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &z.vfsfd) - stateSourceObject.Load(1, &z.FileDescriptionDefaultImpl) - stateSourceObject.Load(2, &z.DentryMetadataFileDescriptionImpl) - stateSourceObject.Load(3, &z.NoLockFD) +func (fd *zeroFD) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.vfsfd) + stateSourceObject.Load(1, &fd.FileDescriptionDefaultImpl) + stateSourceObject.Load(2, &fd.DentryMetadataFileDescriptionImpl) + stateSourceObject.Load(3, &fd.NoLockFD) } func init() { diff --git a/pkg/sentry/fs/dev/dev_state_autogen.go b/pkg/sentry/fs/dev/dev_state_autogen.go index 09e71c0c8..958ddf698 100644 --- a/pkg/sentry/fs/dev/dev_state_autogen.go +++ b/pkg/sentry/fs/dev/dev_state_autogen.go @@ -155,27 +155,27 @@ func (n *nullFileOperations) afterLoad() {} func (n *nullFileOperations) StateLoad(stateSourceObject state.Source) { } -func (z *zeroDevice) StateTypeName() string { +func (zd *zeroDevice) StateTypeName() string { return "pkg/sentry/fs/dev.zeroDevice" } -func (z *zeroDevice) StateFields() []string { +func (zd *zeroDevice) StateFields() []string { return []string{ "nullDevice", } } -func (z *zeroDevice) beforeSave() {} +func (zd *zeroDevice) beforeSave() {} -func (z *zeroDevice) StateSave(stateSinkObject state.Sink) { - z.beforeSave() - stateSinkObject.Save(0, &z.nullDevice) +func (zd *zeroDevice) StateSave(stateSinkObject state.Sink) { + zd.beforeSave() + stateSinkObject.Save(0, &zd.nullDevice) } -func (z *zeroDevice) afterLoad() {} +func (zd *zeroDevice) afterLoad() {} -func (z *zeroDevice) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &z.nullDevice) +func (zd *zeroDevice) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &zd.nullDevice) } func (z *zeroFileOperations) StateTypeName() string { diff --git a/pkg/sentry/fs/fs_state_autogen.go b/pkg/sentry/fs/fs_state_autogen.go index 95df2cad0..667495740 100644 --- a/pkg/sentry/fs/fs_state_autogen.go +++ b/pkg/sentry/fs/fs_state_autogen.go @@ -44,11 +44,11 @@ func (s *StableAttr) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(5, &s.DeviceFileMinor) } -func (u *UnstableAttr) StateTypeName() string { +func (ua *UnstableAttr) StateTypeName() string { return "pkg/sentry/fs.UnstableAttr" } -func (u *UnstableAttr) StateFields() []string { +func (ua *UnstableAttr) StateFields() []string { return []string{ "Size", "Usage", @@ -61,31 +61,31 @@ func (u *UnstableAttr) StateFields() []string { } } -func (u *UnstableAttr) beforeSave() {} +func (ua *UnstableAttr) beforeSave() {} -func (u *UnstableAttr) StateSave(stateSinkObject state.Sink) { - u.beforeSave() - stateSinkObject.Save(0, &u.Size) - stateSinkObject.Save(1, &u.Usage) - stateSinkObject.Save(2, &u.Perms) - stateSinkObject.Save(3, &u.Owner) - stateSinkObject.Save(4, &u.AccessTime) - stateSinkObject.Save(5, &u.ModificationTime) - stateSinkObject.Save(6, &u.StatusChangeTime) - stateSinkObject.Save(7, &u.Links) +func (ua *UnstableAttr) StateSave(stateSinkObject state.Sink) { + ua.beforeSave() + stateSinkObject.Save(0, &ua.Size) + stateSinkObject.Save(1, &ua.Usage) + stateSinkObject.Save(2, &ua.Perms) + stateSinkObject.Save(3, &ua.Owner) + stateSinkObject.Save(4, &ua.AccessTime) + stateSinkObject.Save(5, &ua.ModificationTime) + stateSinkObject.Save(6, &ua.StatusChangeTime) + stateSinkObject.Save(7, &ua.Links) } -func (u *UnstableAttr) afterLoad() {} +func (ua *UnstableAttr) afterLoad() {} -func (u *UnstableAttr) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &u.Size) - stateSourceObject.Load(1, &u.Usage) - stateSourceObject.Load(2, &u.Perms) - stateSourceObject.Load(3, &u.Owner) - stateSourceObject.Load(4, &u.AccessTime) - stateSourceObject.Load(5, &u.ModificationTime) - stateSourceObject.Load(6, &u.StatusChangeTime) - stateSourceObject.Load(7, &u.Links) +func (ua *UnstableAttr) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &ua.Size) + stateSourceObject.Load(1, &ua.Usage) + stateSourceObject.Load(2, &ua.Perms) + stateSourceObject.Load(3, &ua.Owner) + stateSourceObject.Load(4, &ua.AccessTime) + stateSourceObject.Load(5, &ua.ModificationTime) + stateSourceObject.Load(6, &ua.StatusChangeTime) + stateSourceObject.Load(7, &ua.Links) } func (a *AttrMask) StateTypeName() string { @@ -334,36 +334,36 @@ func (d *Dirent) StateLoad(stateSourceObject state.Source) { stateSourceObject.AfterLoad(d.afterLoad) } -func (d *DirentCache) StateTypeName() string { +func (c *DirentCache) StateTypeName() string { return "pkg/sentry/fs.DirentCache" } -func (d *DirentCache) StateFields() []string { +func (c *DirentCache) StateFields() []string { return []string{ "maxSize", "limit", } } -func (d *DirentCache) beforeSave() {} +func (c *DirentCache) beforeSave() {} -func (d *DirentCache) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - if !state.IsZeroValue(&d.currentSize) { - state.Failf("currentSize is %#v, expected zero", &d.currentSize) +func (c *DirentCache) StateSave(stateSinkObject state.Sink) { + c.beforeSave() + if !state.IsZeroValue(&c.currentSize) { + state.Failf("currentSize is %#v, expected zero", &c.currentSize) } - if !state.IsZeroValue(&d.list) { - state.Failf("list is %#v, expected zero", &d.list) + if !state.IsZeroValue(&c.list) { + state.Failf("list is %#v, expected zero", &c.list) } - stateSinkObject.Save(0, &d.maxSize) - stateSinkObject.Save(1, &d.limit) + stateSinkObject.Save(0, &c.maxSize) + stateSinkObject.Save(1, &c.limit) } -func (d *DirentCache) afterLoad() {} +func (c *DirentCache) afterLoad() {} -func (d *DirentCache) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.maxSize) - stateSourceObject.Load(1, &d.limit) +func (c *DirentCache) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &c.maxSize) + stateSourceObject.Load(1, &c.limit) } func (d *DirentCacheLimiter) StateTypeName() string { @@ -392,82 +392,82 @@ func (d *DirentCacheLimiter) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(0, &d.max) } -func (d *direntList) StateTypeName() string { +func (l *direntList) StateTypeName() string { return "pkg/sentry/fs.direntList" } -func (d *direntList) StateFields() []string { +func (l *direntList) StateFields() []string { return []string{ "head", "tail", } } -func (d *direntList) beforeSave() {} +func (l *direntList) beforeSave() {} -func (d *direntList) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - stateSinkObject.Save(0, &d.head) - stateSinkObject.Save(1, &d.tail) +func (l *direntList) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.head) + stateSinkObject.Save(1, &l.tail) } -func (d *direntList) afterLoad() {} +func (l *direntList) afterLoad() {} -func (d *direntList) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.head) - stateSourceObject.Load(1, &d.tail) +func (l *direntList) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.head) + stateSourceObject.Load(1, &l.tail) } -func (d *direntEntry) StateTypeName() string { +func (e *direntEntry) StateTypeName() string { return "pkg/sentry/fs.direntEntry" } -func (d *direntEntry) StateFields() []string { +func (e *direntEntry) StateFields() []string { return []string{ "next", "prev", } } -func (d *direntEntry) beforeSave() {} +func (e *direntEntry) beforeSave() {} -func (d *direntEntry) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - stateSinkObject.Save(0, &d.next) - stateSinkObject.Save(1, &d.prev) +func (e *direntEntry) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.next) + stateSinkObject.Save(1, &e.prev) } -func (d *direntEntry) afterLoad() {} +func (e *direntEntry) afterLoad() {} -func (d *direntEntry) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.next) - stateSourceObject.Load(1, &d.prev) +func (e *direntEntry) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.next) + stateSourceObject.Load(1, &e.prev) } -func (e *eventList) StateTypeName() string { +func (l *eventList) StateTypeName() string { return "pkg/sentry/fs.eventList" } -func (e *eventList) StateFields() []string { +func (l *eventList) StateFields() []string { return []string{ "head", "tail", } } -func (e *eventList) beforeSave() {} +func (l *eventList) beforeSave() {} -func (e *eventList) StateSave(stateSinkObject state.Sink) { - e.beforeSave() - stateSinkObject.Save(0, &e.head) - stateSinkObject.Save(1, &e.tail) +func (l *eventList) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.head) + stateSinkObject.Save(1, &l.tail) } -func (e *eventList) afterLoad() {} +func (l *eventList) afterLoad() {} -func (e *eventList) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &e.head) - stateSourceObject.Load(1, &e.tail) +func (l *eventList) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.head) + stateSourceObject.Load(1, &l.tail) } func (e *eventEntry) StateTypeName() string { @@ -534,11 +534,11 @@ func (f *File) StateLoad(stateSourceObject state.Source) { stateSourceObject.AfterLoad(f.afterLoad) } -func (o *overlayFileOperations) StateTypeName() string { +func (f *overlayFileOperations) StateTypeName() string { return "pkg/sentry/fs.overlayFileOperations" } -func (o *overlayFileOperations) StateFields() []string { +func (f *overlayFileOperations) StateFields() []string { return []string{ "upper", "lower", @@ -546,28 +546,28 @@ func (o *overlayFileOperations) StateFields() []string { } } -func (o *overlayFileOperations) beforeSave() {} +func (f *overlayFileOperations) beforeSave() {} -func (o *overlayFileOperations) StateSave(stateSinkObject state.Sink) { - o.beforeSave() - stateSinkObject.Save(0, &o.upper) - stateSinkObject.Save(1, &o.lower) - stateSinkObject.Save(2, &o.dirCursor) +func (f *overlayFileOperations) StateSave(stateSinkObject state.Sink) { + f.beforeSave() + stateSinkObject.Save(0, &f.upper) + stateSinkObject.Save(1, &f.lower) + stateSinkObject.Save(2, &f.dirCursor) } -func (o *overlayFileOperations) afterLoad() {} +func (f *overlayFileOperations) afterLoad() {} -func (o *overlayFileOperations) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &o.upper) - stateSourceObject.Load(1, &o.lower) - stateSourceObject.Load(2, &o.dirCursor) +func (f *overlayFileOperations) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &f.upper) + stateSourceObject.Load(1, &f.lower) + stateSourceObject.Load(2, &f.dirCursor) } -func (o *overlayMappingIdentity) StateTypeName() string { +func (omi *overlayMappingIdentity) StateTypeName() string { return "pkg/sentry/fs.overlayMappingIdentity" } -func (o *overlayMappingIdentity) StateFields() []string { +func (omi *overlayMappingIdentity) StateFields() []string { return []string{ "AtomicRefCount", "id", @@ -575,21 +575,21 @@ func (o *overlayMappingIdentity) StateFields() []string { } } -func (o *overlayMappingIdentity) beforeSave() {} +func (omi *overlayMappingIdentity) beforeSave() {} -func (o *overlayMappingIdentity) StateSave(stateSinkObject state.Sink) { - o.beforeSave() - stateSinkObject.Save(0, &o.AtomicRefCount) - stateSinkObject.Save(1, &o.id) - stateSinkObject.Save(2, &o.overlayFile) +func (omi *overlayMappingIdentity) StateSave(stateSinkObject state.Sink) { + omi.beforeSave() + stateSinkObject.Save(0, &omi.AtomicRefCount) + stateSinkObject.Save(1, &omi.id) + stateSinkObject.Save(2, &omi.overlayFile) } -func (o *overlayMappingIdentity) afterLoad() {} +func (omi *overlayMappingIdentity) afterLoad() {} -func (o *overlayMappingIdentity) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &o.AtomicRefCount) - stateSourceObject.Load(1, &o.id) - stateSourceObject.Load(2, &o.overlayFile) +func (omi *overlayMappingIdentity) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &omi.AtomicRefCount) + stateSourceObject.Load(1, &omi.id) + stateSourceObject.Load(2, &omi.overlayFile) } func (m *MountSourceFlags) StateTypeName() string { @@ -890,11 +890,11 @@ func (w *Watch) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(5, &w.pins) } -func (m *MountSource) StateTypeName() string { +func (msrc *MountSource) StateTypeName() string { return "pkg/sentry/fs.MountSource" } -func (m *MountSource) StateFields() []string { +func (msrc *MountSource) StateFields() []string { return []string{ "AtomicRefCount", "MountSourceOperations", @@ -905,34 +905,34 @@ func (m *MountSource) StateFields() []string { } } -func (m *MountSource) beforeSave() {} +func (msrc *MountSource) beforeSave() {} -func (m *MountSource) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.AtomicRefCount) - stateSinkObject.Save(1, &m.MountSourceOperations) - stateSinkObject.Save(2, &m.FilesystemType) - stateSinkObject.Save(3, &m.Flags) - stateSinkObject.Save(4, &m.fscache) - stateSinkObject.Save(5, &m.direntRefs) +func (msrc *MountSource) StateSave(stateSinkObject state.Sink) { + msrc.beforeSave() + stateSinkObject.Save(0, &msrc.AtomicRefCount) + stateSinkObject.Save(1, &msrc.MountSourceOperations) + stateSinkObject.Save(2, &msrc.FilesystemType) + stateSinkObject.Save(3, &msrc.Flags) + stateSinkObject.Save(4, &msrc.fscache) + stateSinkObject.Save(5, &msrc.direntRefs) } -func (m *MountSource) afterLoad() {} +func (msrc *MountSource) afterLoad() {} -func (m *MountSource) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.AtomicRefCount) - stateSourceObject.Load(1, &m.MountSourceOperations) - stateSourceObject.Load(2, &m.FilesystemType) - stateSourceObject.Load(3, &m.Flags) - stateSourceObject.Load(4, &m.fscache) - stateSourceObject.Load(5, &m.direntRefs) +func (msrc *MountSource) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &msrc.AtomicRefCount) + stateSourceObject.Load(1, &msrc.MountSourceOperations) + stateSourceObject.Load(2, &msrc.FilesystemType) + stateSourceObject.Load(3, &msrc.Flags) + stateSourceObject.Load(4, &msrc.fscache) + stateSourceObject.Load(5, &msrc.direntRefs) } -func (s *SimpleMountSourceOperations) StateTypeName() string { +func (smo *SimpleMountSourceOperations) StateTypeName() string { return "pkg/sentry/fs.SimpleMountSourceOperations" } -func (s *SimpleMountSourceOperations) StateFields() []string { +func (smo *SimpleMountSourceOperations) StateFields() []string { return []string{ "keep", "revalidate", @@ -940,21 +940,21 @@ func (s *SimpleMountSourceOperations) StateFields() []string { } } -func (s *SimpleMountSourceOperations) beforeSave() {} +func (smo *SimpleMountSourceOperations) beforeSave() {} -func (s *SimpleMountSourceOperations) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.keep) - stateSinkObject.Save(1, &s.revalidate) - stateSinkObject.Save(2, &s.cacheReaddir) +func (smo *SimpleMountSourceOperations) StateSave(stateSinkObject state.Sink) { + smo.beforeSave() + stateSinkObject.Save(0, &smo.keep) + stateSinkObject.Save(1, &smo.revalidate) + stateSinkObject.Save(2, &smo.cacheReaddir) } -func (s *SimpleMountSourceOperations) afterLoad() {} +func (smo *SimpleMountSourceOperations) afterLoad() {} -func (s *SimpleMountSourceOperations) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.keep) - stateSourceObject.Load(1, &s.revalidate) - stateSourceObject.Load(2, &s.cacheReaddir) +func (smo *SimpleMountSourceOperations) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &smo.keep) + stateSourceObject.Load(1, &smo.revalidate) + stateSourceObject.Load(2, &smo.cacheReaddir) } func (o *overlayMountSourceOperations) StateTypeName() string { @@ -983,23 +983,23 @@ func (o *overlayMountSourceOperations) StateLoad(stateSourceObject state.Source) stateSourceObject.Load(1, &o.lower) } -func (o *overlayFilesystem) StateTypeName() string { +func (ofs *overlayFilesystem) StateTypeName() string { return "pkg/sentry/fs.overlayFilesystem" } -func (o *overlayFilesystem) StateFields() []string { +func (ofs *overlayFilesystem) StateFields() []string { return []string{} } -func (o *overlayFilesystem) beforeSave() {} +func (ofs *overlayFilesystem) beforeSave() {} -func (o *overlayFilesystem) StateSave(stateSinkObject state.Sink) { - o.beforeSave() +func (ofs *overlayFilesystem) StateSave(stateSinkObject state.Sink) { + ofs.beforeSave() } -func (o *overlayFilesystem) afterLoad() {} +func (ofs *overlayFilesystem) afterLoad() {} -func (o *overlayFilesystem) StateLoad(stateSourceObject state.Source) { +func (ofs *overlayFilesystem) StateLoad(stateSourceObject state.Source) { } func (m *Mount) StateTypeName() string { @@ -1034,11 +1034,11 @@ func (m *Mount) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(3, &m.previous) } -func (m *MountNamespace) StateTypeName() string { +func (mns *MountNamespace) StateTypeName() string { return "pkg/sentry/fs.MountNamespace" } -func (m *MountNamespace) StateFields() []string { +func (mns *MountNamespace) StateFields() []string { return []string{ "AtomicRefCount", "userns", @@ -1048,25 +1048,25 @@ func (m *MountNamespace) StateFields() []string { } } -func (m *MountNamespace) beforeSave() {} +func (mns *MountNamespace) beforeSave() {} -func (m *MountNamespace) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.AtomicRefCount) - stateSinkObject.Save(1, &m.userns) - stateSinkObject.Save(2, &m.root) - stateSinkObject.Save(3, &m.mounts) - stateSinkObject.Save(4, &m.mountID) +func (mns *MountNamespace) StateSave(stateSinkObject state.Sink) { + mns.beforeSave() + stateSinkObject.Save(0, &mns.AtomicRefCount) + stateSinkObject.Save(1, &mns.userns) + stateSinkObject.Save(2, &mns.root) + stateSinkObject.Save(3, &mns.mounts) + stateSinkObject.Save(4, &mns.mountID) } -func (m *MountNamespace) afterLoad() {} +func (mns *MountNamespace) afterLoad() {} -func (m *MountNamespace) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.AtomicRefCount) - stateSourceObject.Load(1, &m.userns) - stateSourceObject.Load(2, &m.root) - stateSourceObject.Load(3, &m.mounts) - stateSourceObject.Load(4, &m.mountID) +func (mns *MountNamespace) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &mns.AtomicRefCount) + stateSourceObject.Load(1, &mns.userns) + stateSourceObject.Load(2, &mns.root) + stateSourceObject.Load(3, &mns.mounts) + stateSourceObject.Load(4, &mns.mountID) } func (o *overlayEntry) StateTypeName() string { diff --git a/pkg/sentry/fs/fsutil/fsutil_impl_state_autogen.go b/pkg/sentry/fs/fsutil/fsutil_impl_state_autogen.go index 4d90bd42f..cb6b2ca81 100644 --- a/pkg/sentry/fs/fsutil/fsutil_impl_state_autogen.go +++ b/pkg/sentry/fs/fsutil/fsutil_impl_state_autogen.go @@ -6,35 +6,35 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (d *DirtySet) StateTypeName() string { +func (s *DirtySet) StateTypeName() string { return "pkg/sentry/fs/fsutil.DirtySet" } -func (d *DirtySet) StateFields() []string { +func (s *DirtySet) StateFields() []string { return []string{ "root", } } -func (d *DirtySet) beforeSave() {} +func (s *DirtySet) beforeSave() {} -func (d *DirtySet) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - var rootValue *DirtySegmentDataSlices = d.saveRoot() +func (s *DirtySet) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + var rootValue *DirtySegmentDataSlices = s.saveRoot() stateSinkObject.SaveValue(0, rootValue) } -func (d *DirtySet) afterLoad() {} +func (s *DirtySet) afterLoad() {} -func (d *DirtySet) StateLoad(stateSourceObject state.Source) { - stateSourceObject.LoadValue(0, new(*DirtySegmentDataSlices), func(y interface{}) { d.loadRoot(y.(*DirtySegmentDataSlices)) }) +func (s *DirtySet) StateLoad(stateSourceObject state.Source) { + stateSourceObject.LoadValue(0, new(*DirtySegmentDataSlices), func(y interface{}) { s.loadRoot(y.(*DirtySegmentDataSlices)) }) } -func (d *Dirtynode) StateTypeName() string { +func (n *Dirtynode) StateTypeName() string { return "pkg/sentry/fs/fsutil.Dirtynode" } -func (d *Dirtynode) StateFields() []string { +func (n *Dirtynode) StateFields() []string { return []string{ "nrSegments", "parent", @@ -47,31 +47,31 @@ func (d *Dirtynode) StateFields() []string { } } -func (d *Dirtynode) beforeSave() {} +func (n *Dirtynode) beforeSave() {} -func (d *Dirtynode) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - stateSinkObject.Save(0, &d.nrSegments) - stateSinkObject.Save(1, &d.parent) - stateSinkObject.Save(2, &d.parentIndex) - stateSinkObject.Save(3, &d.hasChildren) - stateSinkObject.Save(4, &d.maxGap) - stateSinkObject.Save(5, &d.keys) - stateSinkObject.Save(6, &d.values) - stateSinkObject.Save(7, &d.children) +func (n *Dirtynode) StateSave(stateSinkObject state.Sink) { + n.beforeSave() + stateSinkObject.Save(0, &n.nrSegments) + stateSinkObject.Save(1, &n.parent) + stateSinkObject.Save(2, &n.parentIndex) + stateSinkObject.Save(3, &n.hasChildren) + stateSinkObject.Save(4, &n.maxGap) + stateSinkObject.Save(5, &n.keys) + stateSinkObject.Save(6, &n.values) + stateSinkObject.Save(7, &n.children) } -func (d *Dirtynode) afterLoad() {} +func (n *Dirtynode) afterLoad() {} -func (d *Dirtynode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.nrSegments) - stateSourceObject.Load(1, &d.parent) - stateSourceObject.Load(2, &d.parentIndex) - stateSourceObject.Load(3, &d.hasChildren) - stateSourceObject.Load(4, &d.maxGap) - stateSourceObject.Load(5, &d.keys) - stateSourceObject.Load(6, &d.values) - stateSourceObject.Load(7, &d.children) +func (n *Dirtynode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &n.nrSegments) + stateSourceObject.Load(1, &n.parent) + stateSourceObject.Load(2, &n.parentIndex) + stateSourceObject.Load(3, &n.hasChildren) + stateSourceObject.Load(4, &n.maxGap) + stateSourceObject.Load(5, &n.keys) + stateSourceObject.Load(6, &n.values) + stateSourceObject.Load(7, &n.children) } func (d *DirtySegmentDataSlices) StateTypeName() string { @@ -103,35 +103,35 @@ func (d *DirtySegmentDataSlices) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(2, &d.Values) } -func (f *FileRangeSet) StateTypeName() string { +func (s *FileRangeSet) StateTypeName() string { return "pkg/sentry/fs/fsutil.FileRangeSet" } -func (f *FileRangeSet) StateFields() []string { +func (s *FileRangeSet) StateFields() []string { return []string{ "root", } } -func (f *FileRangeSet) beforeSave() {} +func (s *FileRangeSet) beforeSave() {} -func (f *FileRangeSet) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - var rootValue *FileRangeSegmentDataSlices = f.saveRoot() +func (s *FileRangeSet) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + var rootValue *FileRangeSegmentDataSlices = s.saveRoot() stateSinkObject.SaveValue(0, rootValue) } -func (f *FileRangeSet) afterLoad() {} +func (s *FileRangeSet) afterLoad() {} -func (f *FileRangeSet) StateLoad(stateSourceObject state.Source) { - stateSourceObject.LoadValue(0, new(*FileRangeSegmentDataSlices), func(y interface{}) { f.loadRoot(y.(*FileRangeSegmentDataSlices)) }) +func (s *FileRangeSet) StateLoad(stateSourceObject state.Source) { + stateSourceObject.LoadValue(0, new(*FileRangeSegmentDataSlices), func(y interface{}) { s.loadRoot(y.(*FileRangeSegmentDataSlices)) }) } -func (f *FileRangenode) StateTypeName() string { +func (n *FileRangenode) StateTypeName() string { return "pkg/sentry/fs/fsutil.FileRangenode" } -func (f *FileRangenode) StateFields() []string { +func (n *FileRangenode) StateFields() []string { return []string{ "nrSegments", "parent", @@ -144,31 +144,31 @@ func (f *FileRangenode) StateFields() []string { } } -func (f *FileRangenode) beforeSave() {} +func (n *FileRangenode) beforeSave() {} -func (f *FileRangenode) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.nrSegments) - stateSinkObject.Save(1, &f.parent) - stateSinkObject.Save(2, &f.parentIndex) - stateSinkObject.Save(3, &f.hasChildren) - stateSinkObject.Save(4, &f.maxGap) - stateSinkObject.Save(5, &f.keys) - stateSinkObject.Save(6, &f.values) - stateSinkObject.Save(7, &f.children) +func (n *FileRangenode) StateSave(stateSinkObject state.Sink) { + n.beforeSave() + stateSinkObject.Save(0, &n.nrSegments) + stateSinkObject.Save(1, &n.parent) + stateSinkObject.Save(2, &n.parentIndex) + stateSinkObject.Save(3, &n.hasChildren) + stateSinkObject.Save(4, &n.maxGap) + stateSinkObject.Save(5, &n.keys) + stateSinkObject.Save(6, &n.values) + stateSinkObject.Save(7, &n.children) } -func (f *FileRangenode) afterLoad() {} +func (n *FileRangenode) afterLoad() {} -func (f *FileRangenode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.nrSegments) - stateSourceObject.Load(1, &f.parent) - stateSourceObject.Load(2, &f.parentIndex) - stateSourceObject.Load(3, &f.hasChildren) - stateSourceObject.Load(4, &f.maxGap) - stateSourceObject.Load(5, &f.keys) - stateSourceObject.Load(6, &f.values) - stateSourceObject.Load(7, &f.children) +func (n *FileRangenode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &n.nrSegments) + stateSourceObject.Load(1, &n.parent) + stateSourceObject.Load(2, &n.parentIndex) + stateSourceObject.Load(3, &n.hasChildren) + stateSourceObject.Load(4, &n.maxGap) + stateSourceObject.Load(5, &n.keys) + stateSourceObject.Load(6, &n.values) + stateSourceObject.Load(7, &n.children) } func (f *FileRangeSegmentDataSlices) StateTypeName() string { @@ -200,35 +200,35 @@ func (f *FileRangeSegmentDataSlices) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(2, &f.Values) } -func (f *FrameRefSet) StateTypeName() string { +func (s *FrameRefSet) StateTypeName() string { return "pkg/sentry/fs/fsutil.FrameRefSet" } -func (f *FrameRefSet) StateFields() []string { +func (s *FrameRefSet) StateFields() []string { return []string{ "root", } } -func (f *FrameRefSet) beforeSave() {} +func (s *FrameRefSet) beforeSave() {} -func (f *FrameRefSet) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - var rootValue *FrameRefSegmentDataSlices = f.saveRoot() +func (s *FrameRefSet) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + var rootValue *FrameRefSegmentDataSlices = s.saveRoot() stateSinkObject.SaveValue(0, rootValue) } -func (f *FrameRefSet) afterLoad() {} +func (s *FrameRefSet) afterLoad() {} -func (f *FrameRefSet) StateLoad(stateSourceObject state.Source) { - stateSourceObject.LoadValue(0, new(*FrameRefSegmentDataSlices), func(y interface{}) { f.loadRoot(y.(*FrameRefSegmentDataSlices)) }) +func (s *FrameRefSet) StateLoad(stateSourceObject state.Source) { + stateSourceObject.LoadValue(0, new(*FrameRefSegmentDataSlices), func(y interface{}) { s.loadRoot(y.(*FrameRefSegmentDataSlices)) }) } -func (f *FrameRefnode) StateTypeName() string { +func (n *FrameRefnode) StateTypeName() string { return "pkg/sentry/fs/fsutil.FrameRefnode" } -func (f *FrameRefnode) StateFields() []string { +func (n *FrameRefnode) StateFields() []string { return []string{ "nrSegments", "parent", @@ -241,31 +241,31 @@ func (f *FrameRefnode) StateFields() []string { } } -func (f *FrameRefnode) beforeSave() {} +func (n *FrameRefnode) beforeSave() {} -func (f *FrameRefnode) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.nrSegments) - stateSinkObject.Save(1, &f.parent) - stateSinkObject.Save(2, &f.parentIndex) - stateSinkObject.Save(3, &f.hasChildren) - stateSinkObject.Save(4, &f.maxGap) - stateSinkObject.Save(5, &f.keys) - stateSinkObject.Save(6, &f.values) - stateSinkObject.Save(7, &f.children) -} - -func (f *FrameRefnode) afterLoad() {} - -func (f *FrameRefnode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.nrSegments) - stateSourceObject.Load(1, &f.parent) - stateSourceObject.Load(2, &f.parentIndex) - stateSourceObject.Load(3, &f.hasChildren) - stateSourceObject.Load(4, &f.maxGap) - stateSourceObject.Load(5, &f.keys) - stateSourceObject.Load(6, &f.values) - stateSourceObject.Load(7, &f.children) +func (n *FrameRefnode) StateSave(stateSinkObject state.Sink) { + n.beforeSave() + stateSinkObject.Save(0, &n.nrSegments) + stateSinkObject.Save(1, &n.parent) + stateSinkObject.Save(2, &n.parentIndex) + stateSinkObject.Save(3, &n.hasChildren) + stateSinkObject.Save(4, &n.maxGap) + stateSinkObject.Save(5, &n.keys) + stateSinkObject.Save(6, &n.values) + stateSinkObject.Save(7, &n.children) +} + +func (n *FrameRefnode) afterLoad() {} + +func (n *FrameRefnode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &n.nrSegments) + stateSourceObject.Load(1, &n.parent) + stateSourceObject.Load(2, &n.parentIndex) + stateSourceObject.Load(3, &n.hasChildren) + stateSourceObject.Load(4, &n.maxGap) + stateSourceObject.Load(5, &n.keys) + stateSourceObject.Load(6, &n.values) + stateSourceObject.Load(7, &n.children) } func (f *FrameRefSegmentDataSlices) StateTypeName() string { diff --git a/pkg/sentry/fs/fsutil/fsutil_state_autogen.go b/pkg/sentry/fs/fsutil/fsutil_state_autogen.go index 43016f689..439ab9a65 100644 --- a/pkg/sentry/fs/fsutil/fsutil_state_autogen.go +++ b/pkg/sentry/fs/fsutil/fsutil_state_autogen.go @@ -29,30 +29,30 @@ func (d *DirtyInfo) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(0, &d.Keep) } -func (s *StaticDirFileOperations) StateTypeName() string { +func (sdfo *StaticDirFileOperations) StateTypeName() string { return "pkg/sentry/fs/fsutil.StaticDirFileOperations" } -func (s *StaticDirFileOperations) StateFields() []string { +func (sdfo *StaticDirFileOperations) StateFields() []string { return []string{ "dentryMap", "dirCursor", } } -func (s *StaticDirFileOperations) beforeSave() {} +func (sdfo *StaticDirFileOperations) beforeSave() {} -func (s *StaticDirFileOperations) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.dentryMap) - stateSinkObject.Save(1, &s.dirCursor) +func (sdfo *StaticDirFileOperations) StateSave(stateSinkObject state.Sink) { + sdfo.beforeSave() + stateSinkObject.Save(0, &sdfo.dentryMap) + stateSinkObject.Save(1, &sdfo.dirCursor) } -func (s *StaticDirFileOperations) afterLoad() {} +func (sdfo *StaticDirFileOperations) afterLoad() {} -func (s *StaticDirFileOperations) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.dentryMap) - stateSourceObject.Load(1, &s.dirCursor) +func (sdfo *StaticDirFileOperations) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &sdfo.dentryMap) + stateSourceObject.Load(1, &sdfo.dirCursor) } func (n *NoReadWriteFile) StateTypeName() string { @@ -74,49 +74,49 @@ func (n *NoReadWriteFile) afterLoad() {} func (n *NoReadWriteFile) StateLoad(stateSourceObject state.Source) { } -func (f *FileStaticContentReader) StateTypeName() string { +func (scr *FileStaticContentReader) StateTypeName() string { return "pkg/sentry/fs/fsutil.FileStaticContentReader" } -func (f *FileStaticContentReader) StateFields() []string { +func (scr *FileStaticContentReader) StateFields() []string { return []string{ "content", } } -func (f *FileStaticContentReader) beforeSave() {} +func (scr *FileStaticContentReader) beforeSave() {} -func (f *FileStaticContentReader) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.content) +func (scr *FileStaticContentReader) StateSave(stateSinkObject state.Sink) { + scr.beforeSave() + stateSinkObject.Save(0, &scr.content) } -func (f *FileStaticContentReader) afterLoad() {} +func (scr *FileStaticContentReader) afterLoad() {} -func (f *FileStaticContentReader) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.content) +func (scr *FileStaticContentReader) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &scr.content) } -func (h *HostFileMapper) StateTypeName() string { +func (f *HostFileMapper) StateTypeName() string { return "pkg/sentry/fs/fsutil.HostFileMapper" } -func (h *HostFileMapper) StateFields() []string { +func (f *HostFileMapper) StateFields() []string { return []string{ "refs", } } -func (h *HostFileMapper) beforeSave() {} +func (f *HostFileMapper) beforeSave() {} -func (h *HostFileMapper) StateSave(stateSinkObject state.Sink) { - h.beforeSave() - stateSinkObject.Save(0, &h.refs) +func (f *HostFileMapper) StateSave(stateSinkObject state.Sink) { + f.beforeSave() + stateSinkObject.Save(0, &f.refs) } -func (h *HostFileMapper) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &h.refs) - stateSourceObject.AfterLoad(h.afterLoad) +func (f *HostFileMapper) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &f.refs) + stateSourceObject.AfterLoad(f.afterLoad) } func (h *HostMappable) StateTypeName() string { diff --git a/pkg/sentry/fs/gofer/gofer_state_autogen.go b/pkg/sentry/fs/gofer/gofer_state_autogen.go index c3cad4ad5..d2eb67d58 100644 --- a/pkg/sentry/fs/gofer/gofer_state_autogen.go +++ b/pkg/sentry/fs/gofer/gofer_state_autogen.go @@ -6,30 +6,30 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (f *fifo) StateTypeName() string { +func (i *fifo) StateTypeName() string { return "pkg/sentry/fs/gofer.fifo" } -func (f *fifo) StateFields() []string { +func (i *fifo) StateFields() []string { return []string{ "InodeOperations", "fileIops", } } -func (f *fifo) beforeSave() {} +func (i *fifo) beforeSave() {} -func (f *fifo) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.InodeOperations) - stateSinkObject.Save(1, &f.fileIops) +func (i *fifo) StateSave(stateSinkObject state.Sink) { + i.beforeSave() + stateSinkObject.Save(0, &i.InodeOperations) + stateSinkObject.Save(1, &i.fileIops) } -func (f *fifo) afterLoad() {} +func (i *fifo) afterLoad() {} -func (f *fifo) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.InodeOperations) - stateSourceObject.Load(1, &f.fileIops) +func (i *fifo) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &i.InodeOperations) + stateSourceObject.Load(1, &i.fileIops) } func (f *fileOperations) StateTypeName() string { @@ -138,11 +138,11 @@ func (i *inodeFileState) StateLoad(stateSourceObject state.Source) { stateSourceObject.AfterLoad(i.afterLoad) } -func (o *overrideInfo) StateTypeName() string { +func (l *overrideInfo) StateTypeName() string { return "pkg/sentry/fs/gofer.overrideInfo" } -func (o *overrideInfo) StateFields() []string { +func (l *overrideInfo) StateFields() []string { return []string{ "dirent", "endpoint", @@ -150,44 +150,44 @@ func (o *overrideInfo) StateFields() []string { } } -func (o *overrideInfo) beforeSave() {} +func (l *overrideInfo) beforeSave() {} -func (o *overrideInfo) StateSave(stateSinkObject state.Sink) { - o.beforeSave() - stateSinkObject.Save(0, &o.dirent) - stateSinkObject.Save(1, &o.endpoint) - stateSinkObject.Save(2, &o.inode) +func (l *overrideInfo) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.dirent) + stateSinkObject.Save(1, &l.endpoint) + stateSinkObject.Save(2, &l.inode) } -func (o *overrideInfo) afterLoad() {} +func (l *overrideInfo) afterLoad() {} -func (o *overrideInfo) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &o.dirent) - stateSourceObject.Load(1, &o.endpoint) - stateSourceObject.Load(2, &o.inode) +func (l *overrideInfo) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.dirent) + stateSourceObject.Load(1, &l.endpoint) + stateSourceObject.Load(2, &l.inode) } -func (o *overrideMaps) StateTypeName() string { +func (e *overrideMaps) StateTypeName() string { return "pkg/sentry/fs/gofer.overrideMaps" } -func (o *overrideMaps) StateFields() []string { +func (e *overrideMaps) StateFields() []string { return []string{ "pathMap", } } -func (o *overrideMaps) beforeSave() {} +func (e *overrideMaps) beforeSave() {} -func (o *overrideMaps) StateSave(stateSinkObject state.Sink) { - o.beforeSave() - stateSinkObject.Save(0, &o.pathMap) +func (e *overrideMaps) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.pathMap) } -func (o *overrideMaps) afterLoad() {} +func (e *overrideMaps) afterLoad() {} -func (o *overrideMaps) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &o.pathMap) +func (e *overrideMaps) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.pathMap) } func (s *session) StateTypeName() string { diff --git a/pkg/sentry/fs/lock/lock_state_autogen.go b/pkg/sentry/fs/lock/lock_state_autogen.go index 2b307be59..707a7518f 100644 --- a/pkg/sentry/fs/lock/lock_state_autogen.go +++ b/pkg/sentry/fs/lock/lock_state_autogen.go @@ -58,61 +58,61 @@ func (l *Locks) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(0, &l.locks) } -func (l *LockRange) StateTypeName() string { +func (r *LockRange) StateTypeName() string { return "pkg/sentry/fs/lock.LockRange" } -func (l *LockRange) StateFields() []string { +func (r *LockRange) StateFields() []string { return []string{ "Start", "End", } } -func (l *LockRange) beforeSave() {} +func (r *LockRange) beforeSave() {} -func (l *LockRange) StateSave(stateSinkObject state.Sink) { - l.beforeSave() - stateSinkObject.Save(0, &l.Start) - stateSinkObject.Save(1, &l.End) +func (r *LockRange) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.Start) + stateSinkObject.Save(1, &r.End) } -func (l *LockRange) afterLoad() {} +func (r *LockRange) afterLoad() {} -func (l *LockRange) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &l.Start) - stateSourceObject.Load(1, &l.End) +func (r *LockRange) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.Start) + stateSourceObject.Load(1, &r.End) } -func (l *LockSet) StateTypeName() string { +func (s *LockSet) StateTypeName() string { return "pkg/sentry/fs/lock.LockSet" } -func (l *LockSet) StateFields() []string { +func (s *LockSet) StateFields() []string { return []string{ "root", } } -func (l *LockSet) beforeSave() {} +func (s *LockSet) beforeSave() {} -func (l *LockSet) StateSave(stateSinkObject state.Sink) { - l.beforeSave() - var rootValue *LockSegmentDataSlices = l.saveRoot() +func (s *LockSet) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + var rootValue *LockSegmentDataSlices = s.saveRoot() stateSinkObject.SaveValue(0, rootValue) } -func (l *LockSet) afterLoad() {} +func (s *LockSet) afterLoad() {} -func (l *LockSet) StateLoad(stateSourceObject state.Source) { - stateSourceObject.LoadValue(0, new(*LockSegmentDataSlices), func(y interface{}) { l.loadRoot(y.(*LockSegmentDataSlices)) }) +func (s *LockSet) StateLoad(stateSourceObject state.Source) { + stateSourceObject.LoadValue(0, new(*LockSegmentDataSlices), func(y interface{}) { s.loadRoot(y.(*LockSegmentDataSlices)) }) } -func (l *Locknode) StateTypeName() string { +func (n *Locknode) StateTypeName() string { return "pkg/sentry/fs/lock.Locknode" } -func (l *Locknode) StateFields() []string { +func (n *Locknode) StateFields() []string { return []string{ "nrSegments", "parent", @@ -125,31 +125,31 @@ func (l *Locknode) StateFields() []string { } } -func (l *Locknode) beforeSave() {} +func (n *Locknode) beforeSave() {} -func (l *Locknode) StateSave(stateSinkObject state.Sink) { - l.beforeSave() - stateSinkObject.Save(0, &l.nrSegments) - stateSinkObject.Save(1, &l.parent) - stateSinkObject.Save(2, &l.parentIndex) - stateSinkObject.Save(3, &l.hasChildren) - stateSinkObject.Save(4, &l.maxGap) - stateSinkObject.Save(5, &l.keys) - stateSinkObject.Save(6, &l.values) - stateSinkObject.Save(7, &l.children) -} - -func (l *Locknode) afterLoad() {} - -func (l *Locknode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &l.nrSegments) - stateSourceObject.Load(1, &l.parent) - stateSourceObject.Load(2, &l.parentIndex) - stateSourceObject.Load(3, &l.hasChildren) - stateSourceObject.Load(4, &l.maxGap) - stateSourceObject.Load(5, &l.keys) - stateSourceObject.Load(6, &l.values) - stateSourceObject.Load(7, &l.children) +func (n *Locknode) StateSave(stateSinkObject state.Sink) { + n.beforeSave() + stateSinkObject.Save(0, &n.nrSegments) + stateSinkObject.Save(1, &n.parent) + stateSinkObject.Save(2, &n.parentIndex) + stateSinkObject.Save(3, &n.hasChildren) + stateSinkObject.Save(4, &n.maxGap) + stateSinkObject.Save(5, &n.keys) + stateSinkObject.Save(6, &n.values) + stateSinkObject.Save(7, &n.children) +} + +func (n *Locknode) afterLoad() {} + +func (n *Locknode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &n.nrSegments) + stateSourceObject.Load(1, &n.parent) + stateSourceObject.Load(2, &n.parentIndex) + stateSourceObject.Load(3, &n.hasChildren) + stateSourceObject.Load(4, &n.maxGap) + stateSourceObject.Load(5, &n.keys) + stateSourceObject.Load(6, &n.values) + stateSourceObject.Load(7, &n.children) } func (l *LockSegmentDataSlices) StateTypeName() string { diff --git a/pkg/sentry/fs/proc/proc_state_autogen.go b/pkg/sentry/fs/proc/proc_state_autogen.go index ddb1f4e6e..d39cd1d2e 100644 --- a/pkg/sentry/fs/proc/proc_state_autogen.go +++ b/pkg/sentry/fs/proc/proc_state_autogen.go @@ -6,11 +6,11 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (e *execArgInode) StateTypeName() string { +func (i *execArgInode) StateTypeName() string { return "pkg/sentry/fs/proc.execArgInode" } -func (e *execArgInode) StateFields() []string { +func (i *execArgInode) StateFields() []string { return []string{ "SimpleFileInode", "arg", @@ -18,47 +18,47 @@ func (e *execArgInode) StateFields() []string { } } -func (e *execArgInode) beforeSave() {} +func (i *execArgInode) beforeSave() {} -func (e *execArgInode) StateSave(stateSinkObject state.Sink) { - e.beforeSave() - stateSinkObject.Save(0, &e.SimpleFileInode) - stateSinkObject.Save(1, &e.arg) - stateSinkObject.Save(2, &e.t) +func (i *execArgInode) StateSave(stateSinkObject state.Sink) { + i.beforeSave() + stateSinkObject.Save(0, &i.SimpleFileInode) + stateSinkObject.Save(1, &i.arg) + stateSinkObject.Save(2, &i.t) } -func (e *execArgInode) afterLoad() {} +func (i *execArgInode) afterLoad() {} -func (e *execArgInode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &e.SimpleFileInode) - stateSourceObject.Load(1, &e.arg) - stateSourceObject.Load(2, &e.t) +func (i *execArgInode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &i.SimpleFileInode) + stateSourceObject.Load(1, &i.arg) + stateSourceObject.Load(2, &i.t) } -func (e *execArgFile) StateTypeName() string { +func (f *execArgFile) StateTypeName() string { return "pkg/sentry/fs/proc.execArgFile" } -func (e *execArgFile) StateFields() []string { +func (f *execArgFile) StateFields() []string { return []string{ "arg", "t", } } -func (e *execArgFile) beforeSave() {} +func (f *execArgFile) beforeSave() {} -func (e *execArgFile) StateSave(stateSinkObject state.Sink) { - e.beforeSave() - stateSinkObject.Save(0, &e.arg) - stateSinkObject.Save(1, &e.t) +func (f *execArgFile) StateSave(stateSinkObject state.Sink) { + f.beforeSave() + stateSinkObject.Save(0, &f.arg) + stateSinkObject.Save(1, &f.t) } -func (e *execArgFile) afterLoad() {} +func (f *execArgFile) afterLoad() {} -func (e *execArgFile) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &e.arg) - stateSourceObject.Load(1, &e.t) +func (f *execArgFile) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &f.arg) + stateSourceObject.Load(1, &f.t) } func (f *fdDir) StateTypeName() string { @@ -113,30 +113,30 @@ func (f *fdDirFile) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &f.t) } -func (f *fdInfoDir) StateTypeName() string { +func (fdid *fdInfoDir) StateTypeName() string { return "pkg/sentry/fs/proc.fdInfoDir" } -func (f *fdInfoDir) StateFields() []string { +func (fdid *fdInfoDir) StateFields() []string { return []string{ "Dir", "t", } } -func (f *fdInfoDir) beforeSave() {} +func (fdid *fdInfoDir) beforeSave() {} -func (f *fdInfoDir) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.Dir) - stateSinkObject.Save(1, &f.t) +func (fdid *fdInfoDir) StateSave(stateSinkObject state.Sink) { + fdid.beforeSave() + stateSinkObject.Save(0, &fdid.Dir) + stateSinkObject.Save(1, &fdid.t) } -func (f *fdInfoDir) afterLoad() {} +func (fdid *fdInfoDir) afterLoad() {} -func (f *fdInfoDir) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.Dir) - stateSourceObject.Load(1, &f.t) +func (fdid *fdInfoDir) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fdid.Dir) + stateSourceObject.Load(1, &fdid.t) } func (f *filesystemsData) StateTypeName() string { @@ -177,30 +177,30 @@ func (f *filesystem) afterLoad() {} func (f *filesystem) StateLoad(stateSourceObject state.Source) { } -func (t *taskOwnedInodeOps) StateTypeName() string { +func (i *taskOwnedInodeOps) StateTypeName() string { return "pkg/sentry/fs/proc.taskOwnedInodeOps" } -func (t *taskOwnedInodeOps) StateFields() []string { +func (i *taskOwnedInodeOps) StateFields() []string { return []string{ "InodeOperations", "t", } } -func (t *taskOwnedInodeOps) beforeSave() {} +func (i *taskOwnedInodeOps) beforeSave() {} -func (t *taskOwnedInodeOps) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.InodeOperations) - stateSinkObject.Save(1, &t.t) +func (i *taskOwnedInodeOps) StateSave(stateSinkObject state.Sink) { + i.beforeSave() + stateSinkObject.Save(0, &i.InodeOperations) + stateSinkObject.Save(1, &i.t) } -func (t *taskOwnedInodeOps) afterLoad() {} +func (i *taskOwnedInodeOps) afterLoad() {} -func (t *taskOwnedInodeOps) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.InodeOperations) - stateSourceObject.Load(1, &t.t) +func (i *taskOwnedInodeOps) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &i.InodeOperations) + stateSourceObject.Load(1, &i.t) } func (s *staticFileInodeOps) StateTypeName() string { @@ -229,115 +229,115 @@ func (s *staticFileInodeOps) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &s.InodeStaticFileGetter) } -func (l *loadavgData) StateTypeName() string { +func (d *loadavgData) StateTypeName() string { return "pkg/sentry/fs/proc.loadavgData" } -func (l *loadavgData) StateFields() []string { +func (d *loadavgData) StateFields() []string { return []string{} } -func (l *loadavgData) beforeSave() {} +func (d *loadavgData) beforeSave() {} -func (l *loadavgData) StateSave(stateSinkObject state.Sink) { - l.beforeSave() +func (d *loadavgData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() } -func (l *loadavgData) afterLoad() {} +func (d *loadavgData) afterLoad() {} -func (l *loadavgData) StateLoad(stateSourceObject state.Source) { +func (d *loadavgData) StateLoad(stateSourceObject state.Source) { } -func (m *meminfoData) StateTypeName() string { +func (d *meminfoData) StateTypeName() string { return "pkg/sentry/fs/proc.meminfoData" } -func (m *meminfoData) StateFields() []string { +func (d *meminfoData) StateFields() []string { return []string{ "k", } } -func (m *meminfoData) beforeSave() {} +func (d *meminfoData) beforeSave() {} -func (m *meminfoData) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.k) +func (d *meminfoData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.k) } -func (m *meminfoData) afterLoad() {} +func (d *meminfoData) afterLoad() {} -func (m *meminfoData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.k) +func (d *meminfoData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.k) } -func (m *mountInfoFile) StateTypeName() string { +func (mif *mountInfoFile) StateTypeName() string { return "pkg/sentry/fs/proc.mountInfoFile" } -func (m *mountInfoFile) StateFields() []string { +func (mif *mountInfoFile) StateFields() []string { return []string{ "t", } } -func (m *mountInfoFile) beforeSave() {} +func (mif *mountInfoFile) beforeSave() {} -func (m *mountInfoFile) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.t) +func (mif *mountInfoFile) StateSave(stateSinkObject state.Sink) { + mif.beforeSave() + stateSinkObject.Save(0, &mif.t) } -func (m *mountInfoFile) afterLoad() {} +func (mif *mountInfoFile) afterLoad() {} -func (m *mountInfoFile) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.t) +func (mif *mountInfoFile) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &mif.t) } -func (m *mountsFile) StateTypeName() string { +func (mf *mountsFile) StateTypeName() string { return "pkg/sentry/fs/proc.mountsFile" } -func (m *mountsFile) StateFields() []string { +func (mf *mountsFile) StateFields() []string { return []string{ "t", } } -func (m *mountsFile) beforeSave() {} +func (mf *mountsFile) beforeSave() {} -func (m *mountsFile) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.t) +func (mf *mountsFile) StateSave(stateSinkObject state.Sink) { + mf.beforeSave() + stateSinkObject.Save(0, &mf.t) } -func (m *mountsFile) afterLoad() {} +func (mf *mountsFile) afterLoad() {} -func (m *mountsFile) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.t) +func (mf *mountsFile) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &mf.t) } -func (i *ifinet6) StateTypeName() string { +func (n *ifinet6) StateTypeName() string { return "pkg/sentry/fs/proc.ifinet6" } -func (i *ifinet6) StateFields() []string { +func (n *ifinet6) StateFields() []string { return []string{ "s", } } -func (i *ifinet6) beforeSave() {} +func (n *ifinet6) beforeSave() {} -func (i *ifinet6) StateSave(stateSinkObject state.Sink) { - i.beforeSave() - stateSinkObject.Save(0, &i.s) +func (n *ifinet6) StateSave(stateSinkObject state.Sink) { + n.beforeSave() + stateSinkObject.Save(0, &n.s) } -func (i *ifinet6) afterLoad() {} +func (n *ifinet6) afterLoad() {} -func (i *ifinet6) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &i.s) +func (n *ifinet6) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &n.s) } func (n *netDev) StateTypeName() string { @@ -559,53 +559,53 @@ func (s *self) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &s.pidns) } -func (t *threadSelf) StateTypeName() string { +func (s *threadSelf) StateTypeName() string { return "pkg/sentry/fs/proc.threadSelf" } -func (t *threadSelf) StateFields() []string { +func (s *threadSelf) StateFields() []string { return []string{ "Symlink", "pidns", } } -func (t *threadSelf) beforeSave() {} +func (s *threadSelf) beforeSave() {} -func (t *threadSelf) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.Symlink) - stateSinkObject.Save(1, &t.pidns) +func (s *threadSelf) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + stateSinkObject.Save(0, &s.Symlink) + stateSinkObject.Save(1, &s.pidns) } -func (t *threadSelf) afterLoad() {} +func (s *threadSelf) afterLoad() {} -func (t *threadSelf) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.Symlink) - stateSourceObject.Load(1, &t.pidns) +func (s *threadSelf) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &s.Symlink) + stateSourceObject.Load(1, &s.pidns) } -func (r *rootProcFile) StateTypeName() string { +func (rpf *rootProcFile) StateTypeName() string { return "pkg/sentry/fs/proc.rootProcFile" } -func (r *rootProcFile) StateFields() []string { +func (rpf *rootProcFile) StateFields() []string { return []string{ "iops", } } -func (r *rootProcFile) beforeSave() {} +func (rpf *rootProcFile) beforeSave() {} -func (r *rootProcFile) StateSave(stateSinkObject state.Sink) { - r.beforeSave() - stateSinkObject.Save(0, &r.iops) +func (rpf *rootProcFile) StateSave(stateSinkObject state.Sink) { + rpf.beforeSave() + stateSinkObject.Save(0, &rpf.iops) } -func (r *rootProcFile) afterLoad() {} +func (rpf *rootProcFile) afterLoad() {} -func (r *rootProcFile) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &r.iops) +func (rpf *rootProcFile) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &rpf.iops) } func (s *statData) StateTypeName() string { @@ -631,27 +631,27 @@ func (s *statData) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(0, &s.k) } -func (m *mmapMinAddrData) StateTypeName() string { +func (d *mmapMinAddrData) StateTypeName() string { return "pkg/sentry/fs/proc.mmapMinAddrData" } -func (m *mmapMinAddrData) StateFields() []string { +func (d *mmapMinAddrData) StateFields() []string { return []string{ "k", } } -func (m *mmapMinAddrData) beforeSave() {} +func (d *mmapMinAddrData) beforeSave() {} -func (m *mmapMinAddrData) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.k) +func (d *mmapMinAddrData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.k) } -func (m *mmapMinAddrData) afterLoad() {} +func (d *mmapMinAddrData) afterLoad() {} -func (m *mmapMinAddrData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.k) +func (d *mmapMinAddrData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.k) } func (o *overcommitMemory) StateTypeName() string { @@ -696,23 +696,23 @@ func (h *hostname) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(0, &h.SimpleFileInode) } -func (h *hostnameFile) StateTypeName() string { +func (hf *hostnameFile) StateTypeName() string { return "pkg/sentry/fs/proc.hostnameFile" } -func (h *hostnameFile) StateFields() []string { +func (hf *hostnameFile) StateFields() []string { return []string{} } -func (h *hostnameFile) beforeSave() {} +func (hf *hostnameFile) beforeSave() {} -func (h *hostnameFile) StateSave(stateSinkObject state.Sink) { - h.beforeSave() +func (hf *hostnameFile) StateSave(stateSinkObject state.Sink) { + hf.beforeSave() } -func (h *hostnameFile) afterLoad() {} +func (hf *hostnameFile) afterLoad() {} -func (h *hostnameFile) StateLoad(stateSourceObject state.Source) { +func (hf *hostnameFile) StateLoad(stateSourceObject state.Source) { } func (t *tcpMemInode) StateTypeName() string { @@ -744,34 +744,34 @@ func (t *tcpMemInode) StateLoad(stateSourceObject state.Source) { stateSourceObject.AfterLoad(t.afterLoad) } -func (t *tcpMemFile) StateTypeName() string { +func (f *tcpMemFile) StateTypeName() string { return "pkg/sentry/fs/proc.tcpMemFile" } -func (t *tcpMemFile) StateFields() []string { +func (f *tcpMemFile) StateFields() []string { return []string{ "tcpMemInode", } } -func (t *tcpMemFile) beforeSave() {} +func (f *tcpMemFile) beforeSave() {} -func (t *tcpMemFile) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.tcpMemInode) +func (f *tcpMemFile) StateSave(stateSinkObject state.Sink) { + f.beforeSave() + stateSinkObject.Save(0, &f.tcpMemInode) } -func (t *tcpMemFile) afterLoad() {} +func (f *tcpMemFile) afterLoad() {} -func (t *tcpMemFile) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.tcpMemInode) +func (f *tcpMemFile) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &f.tcpMemInode) } -func (t *tcpSack) StateTypeName() string { +func (s *tcpSack) StateTypeName() string { return "pkg/sentry/fs/proc.tcpSack" } -func (t *tcpSack) StateFields() []string { +func (s *tcpSack) StateFields() []string { return []string{ "SimpleFileInode", "stack", @@ -779,53 +779,53 @@ func (t *tcpSack) StateFields() []string { } } -func (t *tcpSack) beforeSave() {} +func (s *tcpSack) beforeSave() {} -func (t *tcpSack) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.SimpleFileInode) - stateSinkObject.Save(1, &t.stack) - stateSinkObject.Save(2, &t.enabled) +func (s *tcpSack) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + stateSinkObject.Save(0, &s.SimpleFileInode) + stateSinkObject.Save(1, &s.stack) + stateSinkObject.Save(2, &s.enabled) } -func (t *tcpSack) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.SimpleFileInode) - stateSourceObject.LoadWait(1, &t.stack) - stateSourceObject.Load(2, &t.enabled) - stateSourceObject.AfterLoad(t.afterLoad) +func (s *tcpSack) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &s.SimpleFileInode) + stateSourceObject.LoadWait(1, &s.stack) + stateSourceObject.Load(2, &s.enabled) + stateSourceObject.AfterLoad(s.afterLoad) } -func (t *tcpSackFile) StateTypeName() string { +func (f *tcpSackFile) StateTypeName() string { return "pkg/sentry/fs/proc.tcpSackFile" } -func (t *tcpSackFile) StateFields() []string { +func (f *tcpSackFile) StateFields() []string { return []string{ "tcpSack", "stack", } } -func (t *tcpSackFile) beforeSave() {} +func (f *tcpSackFile) beforeSave() {} -func (t *tcpSackFile) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.tcpSack) - stateSinkObject.Save(1, &t.stack) +func (f *tcpSackFile) StateSave(stateSinkObject state.Sink) { + f.beforeSave() + stateSinkObject.Save(0, &f.tcpSack) + stateSinkObject.Save(1, &f.stack) } -func (t *tcpSackFile) afterLoad() {} +func (f *tcpSackFile) afterLoad() {} -func (t *tcpSackFile) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.tcpSack) - stateSourceObject.LoadWait(1, &t.stack) +func (f *tcpSackFile) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &f.tcpSack) + stateSourceObject.LoadWait(1, &f.stack) } -func (t *tcpRecovery) StateTypeName() string { +func (r *tcpRecovery) StateTypeName() string { return "pkg/sentry/fs/proc.tcpRecovery" } -func (t *tcpRecovery) StateFields() []string { +func (r *tcpRecovery) StateFields() []string { return []string{ "SimpleFileInode", "stack", @@ -833,54 +833,54 @@ func (t *tcpRecovery) StateFields() []string { } } -func (t *tcpRecovery) beforeSave() {} +func (r *tcpRecovery) beforeSave() {} -func (t *tcpRecovery) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.SimpleFileInode) - stateSinkObject.Save(1, &t.stack) - stateSinkObject.Save(2, &t.recovery) +func (r *tcpRecovery) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.SimpleFileInode) + stateSinkObject.Save(1, &r.stack) + stateSinkObject.Save(2, &r.recovery) } -func (t *tcpRecovery) afterLoad() {} +func (r *tcpRecovery) afterLoad() {} -func (t *tcpRecovery) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.SimpleFileInode) - stateSourceObject.LoadWait(1, &t.stack) - stateSourceObject.Load(2, &t.recovery) +func (r *tcpRecovery) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.SimpleFileInode) + stateSourceObject.LoadWait(1, &r.stack) + stateSourceObject.Load(2, &r.recovery) } -func (t *tcpRecoveryFile) StateTypeName() string { +func (f *tcpRecoveryFile) StateTypeName() string { return "pkg/sentry/fs/proc.tcpRecoveryFile" } -func (t *tcpRecoveryFile) StateFields() []string { +func (f *tcpRecoveryFile) StateFields() []string { return []string{ "tcpRecovery", "stack", } } -func (t *tcpRecoveryFile) beforeSave() {} +func (f *tcpRecoveryFile) beforeSave() {} -func (t *tcpRecoveryFile) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.tcpRecovery) - stateSinkObject.Save(1, &t.stack) +func (f *tcpRecoveryFile) StateSave(stateSinkObject state.Sink) { + f.beforeSave() + stateSinkObject.Save(0, &f.tcpRecovery) + stateSinkObject.Save(1, &f.stack) } -func (t *tcpRecoveryFile) afterLoad() {} +func (f *tcpRecoveryFile) afterLoad() {} -func (t *tcpRecoveryFile) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.tcpRecovery) - stateSourceObject.LoadWait(1, &t.stack) +func (f *tcpRecoveryFile) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &f.tcpRecovery) + stateSourceObject.LoadWait(1, &f.stack) } -func (i *ipForwarding) StateTypeName() string { +func (ipf *ipForwarding) StateTypeName() string { return "pkg/sentry/fs/proc.ipForwarding" } -func (i *ipForwarding) StateFields() []string { +func (ipf *ipForwarding) StateFields() []string { return []string{ "SimpleFileInode", "stack", @@ -888,46 +888,46 @@ func (i *ipForwarding) StateFields() []string { } } -func (i *ipForwarding) beforeSave() {} +func (ipf *ipForwarding) beforeSave() {} -func (i *ipForwarding) StateSave(stateSinkObject state.Sink) { - i.beforeSave() - stateSinkObject.Save(0, &i.SimpleFileInode) - stateSinkObject.Save(1, &i.stack) - stateSinkObject.Save(2, &i.enabled) +func (ipf *ipForwarding) StateSave(stateSinkObject state.Sink) { + ipf.beforeSave() + stateSinkObject.Save(0, &ipf.SimpleFileInode) + stateSinkObject.Save(1, &ipf.stack) + stateSinkObject.Save(2, &ipf.enabled) } -func (i *ipForwarding) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &i.SimpleFileInode) - stateSourceObject.LoadWait(1, &i.stack) - stateSourceObject.Load(2, &i.enabled) - stateSourceObject.AfterLoad(i.afterLoad) +func (ipf *ipForwarding) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &ipf.SimpleFileInode) + stateSourceObject.LoadWait(1, &ipf.stack) + stateSourceObject.Load(2, &ipf.enabled) + stateSourceObject.AfterLoad(ipf.afterLoad) } -func (i *ipForwardingFile) StateTypeName() string { +func (f *ipForwardingFile) StateTypeName() string { return "pkg/sentry/fs/proc.ipForwardingFile" } -func (i *ipForwardingFile) StateFields() []string { +func (f *ipForwardingFile) StateFields() []string { return []string{ "ipf", "stack", } } -func (i *ipForwardingFile) beforeSave() {} +func (f *ipForwardingFile) beforeSave() {} -func (i *ipForwardingFile) StateSave(stateSinkObject state.Sink) { - i.beforeSave() - stateSinkObject.Save(0, &i.ipf) - stateSinkObject.Save(1, &i.stack) +func (f *ipForwardingFile) StateSave(stateSinkObject state.Sink) { + f.beforeSave() + stateSinkObject.Save(0, &f.ipf) + stateSinkObject.Save(1, &f.stack) } -func (i *ipForwardingFile) afterLoad() {} +func (f *ipForwardingFile) afterLoad() {} -func (i *ipForwardingFile) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &i.ipf) - stateSourceObject.LoadWait(1, &i.stack) +func (f *ipForwardingFile) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &f.ipf) + stateSourceObject.LoadWait(1, &f.stack) } func (t *taskDir) StateTypeName() string { @@ -985,30 +985,30 @@ func (s *subtasks) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(2, &s.p) } -func (s *subtasksFile) StateTypeName() string { +func (f *subtasksFile) StateTypeName() string { return "pkg/sentry/fs/proc.subtasksFile" } -func (s *subtasksFile) StateFields() []string { +func (f *subtasksFile) StateFields() []string { return []string{ "t", "pidns", } } -func (s *subtasksFile) beforeSave() {} +func (f *subtasksFile) beforeSave() {} -func (s *subtasksFile) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.t) - stateSinkObject.Save(1, &s.pidns) +func (f *subtasksFile) StateSave(stateSinkObject state.Sink) { + f.beforeSave() + stateSinkObject.Save(0, &f.t) + stateSinkObject.Save(1, &f.pidns) } -func (s *subtasksFile) afterLoad() {} +func (f *subtasksFile) afterLoad() {} -func (s *subtasksFile) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.t) - stateSourceObject.Load(1, &s.pidns) +func (f *subtasksFile) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &f.t) + stateSourceObject.Load(1, &f.pidns) } func (e *exe) StateTypeName() string { @@ -1037,30 +1037,30 @@ func (e *exe) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &e.t) } -func (c *cwd) StateTypeName() string { +func (e *cwd) StateTypeName() string { return "pkg/sentry/fs/proc.cwd" } -func (c *cwd) StateFields() []string { +func (e *cwd) StateFields() []string { return []string{ "Symlink", "t", } } -func (c *cwd) beforeSave() {} +func (e *cwd) beforeSave() {} -func (c *cwd) StateSave(stateSinkObject state.Sink) { - c.beforeSave() - stateSinkObject.Save(0, &c.Symlink) - stateSinkObject.Save(1, &c.t) +func (e *cwd) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.Symlink) + stateSinkObject.Save(1, &e.t) } -func (c *cwd) afterLoad() {} +func (e *cwd) afterLoad() {} -func (c *cwd) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &c.Symlink) - stateSourceObject.Load(1, &c.t) +func (e *cwd) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.Symlink) + stateSourceObject.Load(1, &e.t) } func (n *namespaceSymlink) StateTypeName() string { @@ -1089,57 +1089,57 @@ func (n *namespaceSymlink) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &n.t) } -func (m *mapsData) StateTypeName() string { +func (md *mapsData) StateTypeName() string { return "pkg/sentry/fs/proc.mapsData" } -func (m *mapsData) StateFields() []string { +func (md *mapsData) StateFields() []string { return []string{ "t", } } -func (m *mapsData) beforeSave() {} +func (md *mapsData) beforeSave() {} -func (m *mapsData) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.t) +func (md *mapsData) StateSave(stateSinkObject state.Sink) { + md.beforeSave() + stateSinkObject.Save(0, &md.t) } -func (m *mapsData) afterLoad() {} +func (md *mapsData) afterLoad() {} -func (m *mapsData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.t) +func (md *mapsData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &md.t) } -func (s *smapsData) StateTypeName() string { +func (sd *smapsData) StateTypeName() string { return "pkg/sentry/fs/proc.smapsData" } -func (s *smapsData) StateFields() []string { +func (sd *smapsData) StateFields() []string { return []string{ "t", } } -func (s *smapsData) beforeSave() {} +func (sd *smapsData) beforeSave() {} -func (s *smapsData) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.t) +func (sd *smapsData) StateSave(stateSinkObject state.Sink) { + sd.beforeSave() + stateSinkObject.Save(0, &sd.t) } -func (s *smapsData) afterLoad() {} +func (sd *smapsData) afterLoad() {} -func (s *smapsData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.t) +func (sd *smapsData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &sd.t) } -func (t *taskStatData) StateTypeName() string { +func (s *taskStatData) StateTypeName() string { return "pkg/sentry/fs/proc.taskStatData" } -func (t *taskStatData) StateFields() []string { +func (s *taskStatData) StateFields() []string { return []string{ "t", "tgstats", @@ -1147,21 +1147,21 @@ func (t *taskStatData) StateFields() []string { } } -func (t *taskStatData) beforeSave() {} +func (s *taskStatData) beforeSave() {} -func (t *taskStatData) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.t) - stateSinkObject.Save(1, &t.tgstats) - stateSinkObject.Save(2, &t.pidns) +func (s *taskStatData) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + stateSinkObject.Save(0, &s.t) + stateSinkObject.Save(1, &s.tgstats) + stateSinkObject.Save(2, &s.pidns) } -func (t *taskStatData) afterLoad() {} +func (s *taskStatData) afterLoad() {} -func (t *taskStatData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.t) - stateSourceObject.Load(1, &t.tgstats) - stateSourceObject.Load(2, &t.pidns) +func (s *taskStatData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &s.t) + stateSourceObject.Load(1, &s.tgstats) + stateSourceObject.Load(2, &s.pidns) } func (s *statmData) StateTypeName() string { @@ -1262,27 +1262,27 @@ func (c *comm) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &c.t) } -func (c *commFile) StateTypeName() string { +func (f *commFile) StateTypeName() string { return "pkg/sentry/fs/proc.commFile" } -func (c *commFile) StateFields() []string { +func (f *commFile) StateFields() []string { return []string{ "t", } } -func (c *commFile) beforeSave() {} +func (f *commFile) beforeSave() {} -func (c *commFile) StateSave(stateSinkObject state.Sink) { - c.beforeSave() - stateSinkObject.Save(0, &c.t) +func (f *commFile) StateSave(stateSinkObject state.Sink) { + f.beforeSave() + stateSinkObject.Save(0, &f.t) } -func (c *commFile) afterLoad() {} +func (f *commFile) afterLoad() {} -func (c *commFile) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &c.t) +func (f *commFile) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &f.t) } func (a *auxvec) StateTypeName() string { @@ -1311,27 +1311,27 @@ func (a *auxvec) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &a.t) } -func (a *auxvecFile) StateTypeName() string { +func (f *auxvecFile) StateTypeName() string { return "pkg/sentry/fs/proc.auxvecFile" } -func (a *auxvecFile) StateFields() []string { +func (f *auxvecFile) StateFields() []string { return []string{ "t", } } -func (a *auxvecFile) beforeSave() {} +func (f *auxvecFile) beforeSave() {} -func (a *auxvecFile) StateSave(stateSinkObject state.Sink) { - a.beforeSave() - stateSinkObject.Save(0, &a.t) +func (f *auxvecFile) StateSave(stateSinkObject state.Sink) { + f.beforeSave() + stateSinkObject.Save(0, &f.t) } -func (a *auxvecFile) afterLoad() {} +func (f *auxvecFile) afterLoad() {} -func (a *auxvecFile) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &a.t) +func (f *auxvecFile) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &f.t) } func (o *oomScoreAdj) StateTypeName() string { @@ -1360,34 +1360,34 @@ func (o *oomScoreAdj) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &o.t) } -func (o *oomScoreAdjFile) StateTypeName() string { +func (f *oomScoreAdjFile) StateTypeName() string { return "pkg/sentry/fs/proc.oomScoreAdjFile" } -func (o *oomScoreAdjFile) StateFields() []string { +func (f *oomScoreAdjFile) StateFields() []string { return []string{ "t", } } -func (o *oomScoreAdjFile) beforeSave() {} +func (f *oomScoreAdjFile) beforeSave() {} -func (o *oomScoreAdjFile) StateSave(stateSinkObject state.Sink) { - o.beforeSave() - stateSinkObject.Save(0, &o.t) +func (f *oomScoreAdjFile) StateSave(stateSinkObject state.Sink) { + f.beforeSave() + stateSinkObject.Save(0, &f.t) } -func (o *oomScoreAdjFile) afterLoad() {} +func (f *oomScoreAdjFile) afterLoad() {} -func (o *oomScoreAdjFile) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &o.t) +func (f *oomScoreAdjFile) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &f.t) } -func (i *idMapInodeOperations) StateTypeName() string { +func (imio *idMapInodeOperations) StateTypeName() string { return "pkg/sentry/fs/proc.idMapInodeOperations" } -func (i *idMapInodeOperations) StateFields() []string { +func (imio *idMapInodeOperations) StateFields() []string { return []string{ "InodeSimpleAttributes", "InodeSimpleExtendedAttributes", @@ -1396,46 +1396,46 @@ func (i *idMapInodeOperations) StateFields() []string { } } -func (i *idMapInodeOperations) beforeSave() {} +func (imio *idMapInodeOperations) beforeSave() {} -func (i *idMapInodeOperations) StateSave(stateSinkObject state.Sink) { - i.beforeSave() - stateSinkObject.Save(0, &i.InodeSimpleAttributes) - stateSinkObject.Save(1, &i.InodeSimpleExtendedAttributes) - stateSinkObject.Save(2, &i.t) - stateSinkObject.Save(3, &i.gids) +func (imio *idMapInodeOperations) StateSave(stateSinkObject state.Sink) { + imio.beforeSave() + stateSinkObject.Save(0, &imio.InodeSimpleAttributes) + stateSinkObject.Save(1, &imio.InodeSimpleExtendedAttributes) + stateSinkObject.Save(2, &imio.t) + stateSinkObject.Save(3, &imio.gids) } -func (i *idMapInodeOperations) afterLoad() {} +func (imio *idMapInodeOperations) afterLoad() {} -func (i *idMapInodeOperations) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &i.InodeSimpleAttributes) - stateSourceObject.Load(1, &i.InodeSimpleExtendedAttributes) - stateSourceObject.Load(2, &i.t) - stateSourceObject.Load(3, &i.gids) +func (imio *idMapInodeOperations) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &imio.InodeSimpleAttributes) + stateSourceObject.Load(1, &imio.InodeSimpleExtendedAttributes) + stateSourceObject.Load(2, &imio.t) + stateSourceObject.Load(3, &imio.gids) } -func (i *idMapFileOperations) StateTypeName() string { +func (imfo *idMapFileOperations) StateTypeName() string { return "pkg/sentry/fs/proc.idMapFileOperations" } -func (i *idMapFileOperations) StateFields() []string { +func (imfo *idMapFileOperations) StateFields() []string { return []string{ "iops", } } -func (i *idMapFileOperations) beforeSave() {} +func (imfo *idMapFileOperations) beforeSave() {} -func (i *idMapFileOperations) StateSave(stateSinkObject state.Sink) { - i.beforeSave() - stateSinkObject.Save(0, &i.iops) +func (imfo *idMapFileOperations) StateSave(stateSinkObject state.Sink) { + imfo.beforeSave() + stateSinkObject.Save(0, &imfo.iops) } -func (i *idMapFileOperations) afterLoad() {} +func (imfo *idMapFileOperations) afterLoad() {} -func (i *idMapFileOperations) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &i.iops) +func (imfo *idMapFileOperations) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &imfo.iops) } func (u *uptime) StateTypeName() string { @@ -1464,27 +1464,27 @@ func (u *uptime) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &u.startTime) } -func (u *uptimeFile) StateTypeName() string { +func (f *uptimeFile) StateTypeName() string { return "pkg/sentry/fs/proc.uptimeFile" } -func (u *uptimeFile) StateFields() []string { +func (f *uptimeFile) StateFields() []string { return []string{ "startTime", } } -func (u *uptimeFile) beforeSave() {} +func (f *uptimeFile) beforeSave() {} -func (u *uptimeFile) StateSave(stateSinkObject state.Sink) { - u.beforeSave() - stateSinkObject.Save(0, &u.startTime) +func (f *uptimeFile) StateSave(stateSinkObject state.Sink) { + f.beforeSave() + stateSinkObject.Save(0, &f.startTime) } -func (u *uptimeFile) afterLoad() {} +func (f *uptimeFile) afterLoad() {} -func (u *uptimeFile) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &u.startTime) +func (f *uptimeFile) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &f.startTime) } func (v *versionData) StateTypeName() string { diff --git a/pkg/sentry/fs/proc/seqfile/seqfile_state_autogen.go b/pkg/sentry/fs/proc/seqfile/seqfile_state_autogen.go index cc107af96..ab08bbaa3 100644 --- a/pkg/sentry/fs/proc/seqfile/seqfile_state_autogen.go +++ b/pkg/sentry/fs/proc/seqfile/seqfile_state_autogen.go @@ -70,27 +70,27 @@ func (s *SeqFile) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(5, &s.lastRead) } -func (s *seqFileOperations) StateTypeName() string { +func (sfo *seqFileOperations) StateTypeName() string { return "pkg/sentry/fs/proc/seqfile.seqFileOperations" } -func (s *seqFileOperations) StateFields() []string { +func (sfo *seqFileOperations) StateFields() []string { return []string{ "seqFile", } } -func (s *seqFileOperations) beforeSave() {} +func (sfo *seqFileOperations) beforeSave() {} -func (s *seqFileOperations) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.seqFile) +func (sfo *seqFileOperations) StateSave(stateSinkObject state.Sink) { + sfo.beforeSave() + stateSinkObject.Save(0, &sfo.seqFile) } -func (s *seqFileOperations) afterLoad() {} +func (sfo *seqFileOperations) afterLoad() {} -func (s *seqFileOperations) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.seqFile) +func (sfo *seqFileOperations) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &sfo.seqFile) } func init() { diff --git a/pkg/sentry/fs/ramfs/ramfs_state_autogen.go b/pkg/sentry/fs/ramfs/ramfs_state_autogen.go index e4943e646..482d5d391 100644 --- a/pkg/sentry/fs/ramfs/ramfs_state_autogen.go +++ b/pkg/sentry/fs/ramfs/ramfs_state_autogen.go @@ -38,30 +38,30 @@ func (d *Dir) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(3, &d.dentryMap) } -func (d *dirFileOperations) StateTypeName() string { +func (dfo *dirFileOperations) StateTypeName() string { return "pkg/sentry/fs/ramfs.dirFileOperations" } -func (d *dirFileOperations) StateFields() []string { +func (dfo *dirFileOperations) StateFields() []string { return []string{ "dirCursor", "dir", } } -func (d *dirFileOperations) beforeSave() {} +func (dfo *dirFileOperations) beforeSave() {} -func (d *dirFileOperations) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - stateSinkObject.Save(0, &d.dirCursor) - stateSinkObject.Save(1, &d.dir) +func (dfo *dirFileOperations) StateSave(stateSinkObject state.Sink) { + dfo.beforeSave() + stateSinkObject.Save(0, &dfo.dirCursor) + stateSinkObject.Save(1, &dfo.dir) } -func (d *dirFileOperations) afterLoad() {} +func (dfo *dirFileOperations) afterLoad() {} -func (d *dirFileOperations) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.dirCursor) - stateSourceObject.Load(1, &d.dir) +func (dfo *dirFileOperations) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &dfo.dirCursor) + stateSourceObject.Load(1, &dfo.dir) } func (s *Socket) StateTypeName() string { diff --git a/pkg/sentry/fs/tty/tty_state_autogen.go b/pkg/sentry/fs/tty/tty_state_autogen.go index c644ea9db..0d3785768 100644 --- a/pkg/sentry/fs/tty/tty_state_autogen.go +++ b/pkg/sentry/fs/tty/tty_state_autogen.go @@ -44,30 +44,30 @@ func (d *dirInodeOperations) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(5, &d.next) } -func (d *dirFileOperations) StateTypeName() string { +func (df *dirFileOperations) StateTypeName() string { return "pkg/sentry/fs/tty.dirFileOperations" } -func (d *dirFileOperations) StateFields() []string { +func (df *dirFileOperations) StateFields() []string { return []string{ "di", "dirCursor", } } -func (d *dirFileOperations) beforeSave() {} +func (df *dirFileOperations) beforeSave() {} -func (d *dirFileOperations) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - stateSinkObject.Save(0, &d.di) - stateSinkObject.Save(1, &d.dirCursor) +func (df *dirFileOperations) StateSave(stateSinkObject state.Sink) { + df.beforeSave() + stateSinkObject.Save(0, &df.di) + stateSinkObject.Save(1, &df.dirCursor) } -func (d *dirFileOperations) afterLoad() {} +func (df *dirFileOperations) afterLoad() {} -func (d *dirFileOperations) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.di) - stateSourceObject.Load(1, &d.dirCursor) +func (df *dirFileOperations) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &df.di) + stateSourceObject.Load(1, &df.dirCursor) } func (f *filesystem) StateTypeName() string { @@ -187,56 +187,56 @@ func (i *inputQueueTransformer) afterLoad() {} func (i *inputQueueTransformer) StateLoad(stateSourceObject state.Source) { } -func (m *masterInodeOperations) StateTypeName() string { +func (mi *masterInodeOperations) StateTypeName() string { return "pkg/sentry/fs/tty.masterInodeOperations" } -func (m *masterInodeOperations) StateFields() []string { +func (mi *masterInodeOperations) StateFields() []string { return []string{ "SimpleFileInode", "d", } } -func (m *masterInodeOperations) beforeSave() {} +func (mi *masterInodeOperations) beforeSave() {} -func (m *masterInodeOperations) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.SimpleFileInode) - stateSinkObject.Save(1, &m.d) +func (mi *masterInodeOperations) StateSave(stateSinkObject state.Sink) { + mi.beforeSave() + stateSinkObject.Save(0, &mi.SimpleFileInode) + stateSinkObject.Save(1, &mi.d) } -func (m *masterInodeOperations) afterLoad() {} +func (mi *masterInodeOperations) afterLoad() {} -func (m *masterInodeOperations) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.SimpleFileInode) - stateSourceObject.Load(1, &m.d) +func (mi *masterInodeOperations) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &mi.SimpleFileInode) + stateSourceObject.Load(1, &mi.d) } -func (m *masterFileOperations) StateTypeName() string { +func (mf *masterFileOperations) StateTypeName() string { return "pkg/sentry/fs/tty.masterFileOperations" } -func (m *masterFileOperations) StateFields() []string { +func (mf *masterFileOperations) StateFields() []string { return []string{ "d", "t", } } -func (m *masterFileOperations) beforeSave() {} +func (mf *masterFileOperations) beforeSave() {} -func (m *masterFileOperations) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.d) - stateSinkObject.Save(1, &m.t) +func (mf *masterFileOperations) StateSave(stateSinkObject state.Sink) { + mf.beforeSave() + stateSinkObject.Save(0, &mf.d) + stateSinkObject.Save(1, &mf.t) } -func (m *masterFileOperations) afterLoad() {} +func (mf *masterFileOperations) afterLoad() {} -func (m *masterFileOperations) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.d) - stateSourceObject.Load(1, &m.t) +func (mf *masterFileOperations) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &mf.d) + stateSourceObject.Load(1, &mf.t) } func (q *queue) StateTypeName() string { @@ -274,11 +274,11 @@ func (q *queue) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(4, &q.transformer) } -func (r *replicaInodeOperations) StateTypeName() string { +func (si *replicaInodeOperations) StateTypeName() string { return "pkg/sentry/fs/tty.replicaInodeOperations" } -func (r *replicaInodeOperations) StateFields() []string { +func (si *replicaInodeOperations) StateFields() []string { return []string{ "SimpleFileInode", "d", @@ -286,51 +286,51 @@ func (r *replicaInodeOperations) StateFields() []string { } } -func (r *replicaInodeOperations) beforeSave() {} +func (si *replicaInodeOperations) beforeSave() {} -func (r *replicaInodeOperations) StateSave(stateSinkObject state.Sink) { - r.beforeSave() - stateSinkObject.Save(0, &r.SimpleFileInode) - stateSinkObject.Save(1, &r.d) - stateSinkObject.Save(2, &r.t) +func (si *replicaInodeOperations) StateSave(stateSinkObject state.Sink) { + si.beforeSave() + stateSinkObject.Save(0, &si.SimpleFileInode) + stateSinkObject.Save(1, &si.d) + stateSinkObject.Save(2, &si.t) } -func (r *replicaInodeOperations) afterLoad() {} +func (si *replicaInodeOperations) afterLoad() {} -func (r *replicaInodeOperations) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &r.SimpleFileInode) - stateSourceObject.Load(1, &r.d) - stateSourceObject.Load(2, &r.t) +func (si *replicaInodeOperations) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &si.SimpleFileInode) + stateSourceObject.Load(1, &si.d) + stateSourceObject.Load(2, &si.t) } -func (r *replicaFileOperations) StateTypeName() string { +func (sf *replicaFileOperations) StateTypeName() string { return "pkg/sentry/fs/tty.replicaFileOperations" } -func (r *replicaFileOperations) StateFields() []string { +func (sf *replicaFileOperations) StateFields() []string { return []string{ "si", } } -func (r *replicaFileOperations) beforeSave() {} +func (sf *replicaFileOperations) beforeSave() {} -func (r *replicaFileOperations) StateSave(stateSinkObject state.Sink) { - r.beforeSave() - stateSinkObject.Save(0, &r.si) +func (sf *replicaFileOperations) StateSave(stateSinkObject state.Sink) { + sf.beforeSave() + stateSinkObject.Save(0, &sf.si) } -func (r *replicaFileOperations) afterLoad() {} +func (sf *replicaFileOperations) afterLoad() {} -func (r *replicaFileOperations) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &r.si) +func (sf *replicaFileOperations) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &sf.si) } -func (t *Terminal) StateTypeName() string { +func (tm *Terminal) StateTypeName() string { return "pkg/sentry/fs/tty.Terminal" } -func (t *Terminal) StateFields() []string { +func (tm *Terminal) StateFields() []string { return []string{ "AtomicRefCount", "n", @@ -341,27 +341,27 @@ func (t *Terminal) StateFields() []string { } } -func (t *Terminal) beforeSave() {} +func (tm *Terminal) beforeSave() {} -func (t *Terminal) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.AtomicRefCount) - stateSinkObject.Save(1, &t.n) - stateSinkObject.Save(2, &t.d) - stateSinkObject.Save(3, &t.ld) - stateSinkObject.Save(4, &t.masterKTTY) - stateSinkObject.Save(5, &t.replicaKTTY) +func (tm *Terminal) StateSave(stateSinkObject state.Sink) { + tm.beforeSave() + stateSinkObject.Save(0, &tm.AtomicRefCount) + stateSinkObject.Save(1, &tm.n) + stateSinkObject.Save(2, &tm.d) + stateSinkObject.Save(3, &tm.ld) + stateSinkObject.Save(4, &tm.masterKTTY) + stateSinkObject.Save(5, &tm.replicaKTTY) } -func (t *Terminal) afterLoad() {} +func (tm *Terminal) afterLoad() {} -func (t *Terminal) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.AtomicRefCount) - stateSourceObject.Load(1, &t.n) - stateSourceObject.Load(2, &t.d) - stateSourceObject.Load(3, &t.ld) - stateSourceObject.Load(4, &t.masterKTTY) - stateSourceObject.Load(5, &t.replicaKTTY) +func (tm *Terminal) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &tm.AtomicRefCount) + stateSourceObject.Load(1, &tm.n) + stateSourceObject.Load(2, &tm.d) + stateSourceObject.Load(3, &tm.ld) + stateSourceObject.Load(4, &tm.masterKTTY) + stateSourceObject.Load(5, &tm.replicaKTTY) } func init() { diff --git a/pkg/sentry/fsbridge/fsbridge_state_autogen.go b/pkg/sentry/fsbridge/fsbridge_state_autogen.go index 37696303d..a5d0364f0 100644 --- a/pkg/sentry/fsbridge/fsbridge_state_autogen.go +++ b/pkg/sentry/fsbridge/fsbridge_state_autogen.go @@ -29,11 +29,11 @@ func (f *fsFile) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(0, &f.file) } -func (f *fsLookup) StateTypeName() string { +func (l *fsLookup) StateTypeName() string { return "pkg/sentry/fsbridge.fsLookup" } -func (f *fsLookup) StateFields() []string { +func (l *fsLookup) StateFields() []string { return []string{ "mntns", "root", @@ -41,51 +41,51 @@ func (f *fsLookup) StateFields() []string { } } -func (f *fsLookup) beforeSave() {} +func (l *fsLookup) beforeSave() {} -func (f *fsLookup) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.mntns) - stateSinkObject.Save(1, &f.root) - stateSinkObject.Save(2, &f.workingDir) +func (l *fsLookup) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.mntns) + stateSinkObject.Save(1, &l.root) + stateSinkObject.Save(2, &l.workingDir) } -func (f *fsLookup) afterLoad() {} +func (l *fsLookup) afterLoad() {} -func (f *fsLookup) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.mntns) - stateSourceObject.Load(1, &f.root) - stateSourceObject.Load(2, &f.workingDir) +func (l *fsLookup) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.mntns) + stateSourceObject.Load(1, &l.root) + stateSourceObject.Load(2, &l.workingDir) } -func (v *VFSFile) StateTypeName() string { +func (f *VFSFile) StateTypeName() string { return "pkg/sentry/fsbridge.VFSFile" } -func (v *VFSFile) StateFields() []string { +func (f *VFSFile) StateFields() []string { return []string{ "file", } } -func (v *VFSFile) beforeSave() {} +func (f *VFSFile) beforeSave() {} -func (v *VFSFile) StateSave(stateSinkObject state.Sink) { - v.beforeSave() - stateSinkObject.Save(0, &v.file) +func (f *VFSFile) StateSave(stateSinkObject state.Sink) { + f.beforeSave() + stateSinkObject.Save(0, &f.file) } -func (v *VFSFile) afterLoad() {} +func (f *VFSFile) afterLoad() {} -func (v *VFSFile) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &v.file) +func (f *VFSFile) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &f.file) } -func (v *vfsLookup) StateTypeName() string { +func (l *vfsLookup) StateTypeName() string { return "pkg/sentry/fsbridge.vfsLookup" } -func (v *vfsLookup) StateFields() []string { +func (l *vfsLookup) StateFields() []string { return []string{ "mntns", "root", @@ -93,21 +93,21 @@ func (v *vfsLookup) StateFields() []string { } } -func (v *vfsLookup) beforeSave() {} +func (l *vfsLookup) beforeSave() {} -func (v *vfsLookup) StateSave(stateSinkObject state.Sink) { - v.beforeSave() - stateSinkObject.Save(0, &v.mntns) - stateSinkObject.Save(1, &v.root) - stateSinkObject.Save(2, &v.workingDir) +func (l *vfsLookup) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.mntns) + stateSinkObject.Save(1, &l.root) + stateSinkObject.Save(2, &l.workingDir) } -func (v *vfsLookup) afterLoad() {} +func (l *vfsLookup) afterLoad() {} -func (v *vfsLookup) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &v.mntns) - stateSourceObject.Load(1, &v.root) - stateSourceObject.Load(2, &v.workingDir) +func (l *vfsLookup) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.mntns) + stateSourceObject.Load(1, &l.root) + stateSourceObject.Load(2, &l.workingDir) } func init() { diff --git a/pkg/sentry/fsimpl/devpts/devpts_state_autogen.go b/pkg/sentry/fsimpl/devpts/devpts_state_autogen.go index d02c88a3b..d2c9ffa7d 100644 --- a/pkg/sentry/fsimpl/devpts/devpts_state_autogen.go +++ b/pkg/sentry/fsimpl/devpts/devpts_state_autogen.go @@ -6,56 +6,56 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (f *FilesystemType) StateTypeName() string { +func (fstype *FilesystemType) StateTypeName() string { return "pkg/sentry/fsimpl/devpts.FilesystemType" } -func (f *FilesystemType) StateFields() []string { +func (fstype *FilesystemType) StateFields() []string { return []string{} } -func (f *FilesystemType) beforeSave() {} +func (fstype *FilesystemType) beforeSave() {} -func (f *FilesystemType) StateSave(stateSinkObject state.Sink) { - f.beforeSave() +func (fstype *FilesystemType) StateSave(stateSinkObject state.Sink) { + fstype.beforeSave() } -func (f *FilesystemType) afterLoad() {} +func (fstype *FilesystemType) afterLoad() {} -func (f *FilesystemType) StateLoad(stateSourceObject state.Source) { +func (fstype *FilesystemType) StateLoad(stateSourceObject state.Source) { } -func (f *filesystem) StateTypeName() string { +func (fs *filesystem) StateTypeName() string { return "pkg/sentry/fsimpl/devpts.filesystem" } -func (f *filesystem) StateFields() []string { +func (fs *filesystem) StateFields() []string { return []string{ "Filesystem", "devMinor", } } -func (f *filesystem) beforeSave() {} +func (fs *filesystem) beforeSave() {} -func (f *filesystem) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.Filesystem) - stateSinkObject.Save(1, &f.devMinor) +func (fs *filesystem) StateSave(stateSinkObject state.Sink) { + fs.beforeSave() + stateSinkObject.Save(0, &fs.Filesystem) + stateSinkObject.Save(1, &fs.devMinor) } -func (f *filesystem) afterLoad() {} +func (fs *filesystem) afterLoad() {} -func (f *filesystem) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.Filesystem) - stateSourceObject.Load(1, &f.devMinor) +func (fs *filesystem) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fs.Filesystem) + stateSourceObject.Load(1, &fs.devMinor) } -func (r *rootInode) StateTypeName() string { +func (i *rootInode) StateTypeName() string { return "pkg/sentry/fsimpl/devpts.rootInode" } -func (r *rootInode) StateFields() []string { +func (i *rootInode) StateFields() []string { return []string{ "implStatFS", "AlwaysValid", @@ -73,41 +73,41 @@ func (r *rootInode) StateFields() []string { } } -func (r *rootInode) beforeSave() {} +func (i *rootInode) beforeSave() {} -func (r *rootInode) StateSave(stateSinkObject state.Sink) { - r.beforeSave() - stateSinkObject.Save(0, &r.implStatFS) - stateSinkObject.Save(1, &r.AlwaysValid) - stateSinkObject.Save(2, &r.InodeAttrs) - stateSinkObject.Save(3, &r.InodeDirectoryNoNewChildren) - stateSinkObject.Save(4, &r.InodeNotSymlink) - stateSinkObject.Save(5, &r.OrderedChildren) - stateSinkObject.Save(6, &r.rootInodeRefs) - stateSinkObject.Save(7, &r.locks) - stateSinkObject.Save(8, &r.dentry) - stateSinkObject.Save(9, &r.master) - stateSinkObject.Save(10, &r.root) - stateSinkObject.Save(11, &r.replicas) - stateSinkObject.Save(12, &r.nextIdx) -} - -func (r *rootInode) afterLoad() {} - -func (r *rootInode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &r.implStatFS) - stateSourceObject.Load(1, &r.AlwaysValid) - stateSourceObject.Load(2, &r.InodeAttrs) - stateSourceObject.Load(3, &r.InodeDirectoryNoNewChildren) - stateSourceObject.Load(4, &r.InodeNotSymlink) - stateSourceObject.Load(5, &r.OrderedChildren) - stateSourceObject.Load(6, &r.rootInodeRefs) - stateSourceObject.Load(7, &r.locks) - stateSourceObject.Load(8, &r.dentry) - stateSourceObject.Load(9, &r.master) - stateSourceObject.Load(10, &r.root) - stateSourceObject.Load(11, &r.replicas) - stateSourceObject.Load(12, &r.nextIdx) +func (i *rootInode) StateSave(stateSinkObject state.Sink) { + i.beforeSave() + stateSinkObject.Save(0, &i.implStatFS) + stateSinkObject.Save(1, &i.AlwaysValid) + stateSinkObject.Save(2, &i.InodeAttrs) + stateSinkObject.Save(3, &i.InodeDirectoryNoNewChildren) + stateSinkObject.Save(4, &i.InodeNotSymlink) + stateSinkObject.Save(5, &i.OrderedChildren) + stateSinkObject.Save(6, &i.rootInodeRefs) + stateSinkObject.Save(7, &i.locks) + stateSinkObject.Save(8, &i.dentry) + stateSinkObject.Save(9, &i.master) + stateSinkObject.Save(10, &i.root) + stateSinkObject.Save(11, &i.replicas) + stateSinkObject.Save(12, &i.nextIdx) +} + +func (i *rootInode) afterLoad() {} + +func (i *rootInode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &i.implStatFS) + stateSourceObject.Load(1, &i.AlwaysValid) + stateSourceObject.Load(2, &i.InodeAttrs) + stateSourceObject.Load(3, &i.InodeDirectoryNoNewChildren) + stateSourceObject.Load(4, &i.InodeNotSymlink) + stateSourceObject.Load(5, &i.OrderedChildren) + stateSourceObject.Load(6, &i.rootInodeRefs) + stateSourceObject.Load(7, &i.locks) + stateSourceObject.Load(8, &i.dentry) + stateSourceObject.Load(9, &i.master) + stateSourceObject.Load(10, &i.root) + stateSourceObject.Load(11, &i.replicas) + stateSourceObject.Load(12, &i.nextIdx) } func (i *implStatFS) StateTypeName() string { @@ -208,11 +208,11 @@ func (i *inputQueueTransformer) afterLoad() {} func (i *inputQueueTransformer) StateLoad(stateSourceObject state.Source) { } -func (m *masterInode) StateTypeName() string { +func (mi *masterInode) StateTypeName() string { return "pkg/sentry/fsimpl/devpts.masterInode" } -func (m *masterInode) StateFields() []string { +func (mi *masterInode) StateFields() []string { return []string{ "implStatFS", "InodeAttrs", @@ -225,38 +225,38 @@ func (m *masterInode) StateFields() []string { } } -func (m *masterInode) beforeSave() {} +func (mi *masterInode) beforeSave() {} -func (m *masterInode) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.implStatFS) - stateSinkObject.Save(1, &m.InodeAttrs) - stateSinkObject.Save(2, &m.InodeNoopRefCount) - stateSinkObject.Save(3, &m.InodeNotDirectory) - stateSinkObject.Save(4, &m.InodeNotSymlink) - stateSinkObject.Save(5, &m.locks) - stateSinkObject.Save(6, &m.dentry) - stateSinkObject.Save(7, &m.root) +func (mi *masterInode) StateSave(stateSinkObject state.Sink) { + mi.beforeSave() + stateSinkObject.Save(0, &mi.implStatFS) + stateSinkObject.Save(1, &mi.InodeAttrs) + stateSinkObject.Save(2, &mi.InodeNoopRefCount) + stateSinkObject.Save(3, &mi.InodeNotDirectory) + stateSinkObject.Save(4, &mi.InodeNotSymlink) + stateSinkObject.Save(5, &mi.locks) + stateSinkObject.Save(6, &mi.dentry) + stateSinkObject.Save(7, &mi.root) } -func (m *masterInode) afterLoad() {} +func (mi *masterInode) afterLoad() {} -func (m *masterInode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.implStatFS) - stateSourceObject.Load(1, &m.InodeAttrs) - stateSourceObject.Load(2, &m.InodeNoopRefCount) - stateSourceObject.Load(3, &m.InodeNotDirectory) - stateSourceObject.Load(4, &m.InodeNotSymlink) - stateSourceObject.Load(5, &m.locks) - stateSourceObject.Load(6, &m.dentry) - stateSourceObject.Load(7, &m.root) +func (mi *masterInode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &mi.implStatFS) + stateSourceObject.Load(1, &mi.InodeAttrs) + stateSourceObject.Load(2, &mi.InodeNoopRefCount) + stateSourceObject.Load(3, &mi.InodeNotDirectory) + stateSourceObject.Load(4, &mi.InodeNotSymlink) + stateSourceObject.Load(5, &mi.locks) + stateSourceObject.Load(6, &mi.dentry) + stateSourceObject.Load(7, &mi.root) } -func (m *masterFileDescription) StateTypeName() string { +func (mfd *masterFileDescription) StateTypeName() string { return "pkg/sentry/fsimpl/devpts.masterFileDescription" } -func (m *masterFileDescription) StateFields() []string { +func (mfd *masterFileDescription) StateFields() []string { return []string{ "vfsfd", "FileDescriptionDefaultImpl", @@ -266,25 +266,25 @@ func (m *masterFileDescription) StateFields() []string { } } -func (m *masterFileDescription) beforeSave() {} +func (mfd *masterFileDescription) beforeSave() {} -func (m *masterFileDescription) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.vfsfd) - stateSinkObject.Save(1, &m.FileDescriptionDefaultImpl) - stateSinkObject.Save(2, &m.LockFD) - stateSinkObject.Save(3, &m.inode) - stateSinkObject.Save(4, &m.t) +func (mfd *masterFileDescription) StateSave(stateSinkObject state.Sink) { + mfd.beforeSave() + stateSinkObject.Save(0, &mfd.vfsfd) + stateSinkObject.Save(1, &mfd.FileDescriptionDefaultImpl) + stateSinkObject.Save(2, &mfd.LockFD) + stateSinkObject.Save(3, &mfd.inode) + stateSinkObject.Save(4, &mfd.t) } -func (m *masterFileDescription) afterLoad() {} +func (mfd *masterFileDescription) afterLoad() {} -func (m *masterFileDescription) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.vfsfd) - stateSourceObject.Load(1, &m.FileDescriptionDefaultImpl) - stateSourceObject.Load(2, &m.LockFD) - stateSourceObject.Load(3, &m.inode) - stateSourceObject.Load(4, &m.t) +func (mfd *masterFileDescription) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &mfd.vfsfd) + stateSourceObject.Load(1, &mfd.FileDescriptionDefaultImpl) + stateSourceObject.Load(2, &mfd.LockFD) + stateSourceObject.Load(3, &mfd.inode) + stateSourceObject.Load(4, &mfd.t) } func (q *queue) StateTypeName() string { @@ -322,11 +322,11 @@ func (q *queue) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(4, &q.transformer) } -func (r *replicaInode) StateTypeName() string { +func (ri *replicaInode) StateTypeName() string { return "pkg/sentry/fsimpl/devpts.replicaInode" } -func (r *replicaInode) StateFields() []string { +func (ri *replicaInode) StateFields() []string { return []string{ "implStatFS", "InodeAttrs", @@ -340,40 +340,40 @@ func (r *replicaInode) StateFields() []string { } } -func (r *replicaInode) beforeSave() {} +func (ri *replicaInode) beforeSave() {} -func (r *replicaInode) StateSave(stateSinkObject state.Sink) { - r.beforeSave() - stateSinkObject.Save(0, &r.implStatFS) - stateSinkObject.Save(1, &r.InodeAttrs) - stateSinkObject.Save(2, &r.InodeNoopRefCount) - stateSinkObject.Save(3, &r.InodeNotDirectory) - stateSinkObject.Save(4, &r.InodeNotSymlink) - stateSinkObject.Save(5, &r.locks) - stateSinkObject.Save(6, &r.dentry) - stateSinkObject.Save(7, &r.root) - stateSinkObject.Save(8, &r.t) -} - -func (r *replicaInode) afterLoad() {} - -func (r *replicaInode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &r.implStatFS) - stateSourceObject.Load(1, &r.InodeAttrs) - stateSourceObject.Load(2, &r.InodeNoopRefCount) - stateSourceObject.Load(3, &r.InodeNotDirectory) - stateSourceObject.Load(4, &r.InodeNotSymlink) - stateSourceObject.Load(5, &r.locks) - stateSourceObject.Load(6, &r.dentry) - stateSourceObject.Load(7, &r.root) - stateSourceObject.Load(8, &r.t) -} - -func (r *replicaFileDescription) StateTypeName() string { +func (ri *replicaInode) StateSave(stateSinkObject state.Sink) { + ri.beforeSave() + stateSinkObject.Save(0, &ri.implStatFS) + stateSinkObject.Save(1, &ri.InodeAttrs) + stateSinkObject.Save(2, &ri.InodeNoopRefCount) + stateSinkObject.Save(3, &ri.InodeNotDirectory) + stateSinkObject.Save(4, &ri.InodeNotSymlink) + stateSinkObject.Save(5, &ri.locks) + stateSinkObject.Save(6, &ri.dentry) + stateSinkObject.Save(7, &ri.root) + stateSinkObject.Save(8, &ri.t) +} + +func (ri *replicaInode) afterLoad() {} + +func (ri *replicaInode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &ri.implStatFS) + stateSourceObject.Load(1, &ri.InodeAttrs) + stateSourceObject.Load(2, &ri.InodeNoopRefCount) + stateSourceObject.Load(3, &ri.InodeNotDirectory) + stateSourceObject.Load(4, &ri.InodeNotSymlink) + stateSourceObject.Load(5, &ri.locks) + stateSourceObject.Load(6, &ri.dentry) + stateSourceObject.Load(7, &ri.root) + stateSourceObject.Load(8, &ri.t) +} + +func (rfd *replicaFileDescription) StateTypeName() string { return "pkg/sentry/fsimpl/devpts.replicaFileDescription" } -func (r *replicaFileDescription) StateFields() []string { +func (rfd *replicaFileDescription) StateFields() []string { return []string{ "vfsfd", "FileDescriptionDefaultImpl", @@ -382,23 +382,23 @@ func (r *replicaFileDescription) StateFields() []string { } } -func (r *replicaFileDescription) beforeSave() {} +func (rfd *replicaFileDescription) beforeSave() {} -func (r *replicaFileDescription) StateSave(stateSinkObject state.Sink) { - r.beforeSave() - stateSinkObject.Save(0, &r.vfsfd) - stateSinkObject.Save(1, &r.FileDescriptionDefaultImpl) - stateSinkObject.Save(2, &r.LockFD) - stateSinkObject.Save(3, &r.inode) +func (rfd *replicaFileDescription) StateSave(stateSinkObject state.Sink) { + rfd.beforeSave() + stateSinkObject.Save(0, &rfd.vfsfd) + stateSinkObject.Save(1, &rfd.FileDescriptionDefaultImpl) + stateSinkObject.Save(2, &rfd.LockFD) + stateSinkObject.Save(3, &rfd.inode) } -func (r *replicaFileDescription) afterLoad() {} +func (rfd *replicaFileDescription) afterLoad() {} -func (r *replicaFileDescription) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &r.vfsfd) - stateSourceObject.Load(1, &r.FileDescriptionDefaultImpl) - stateSourceObject.Load(2, &r.LockFD) - stateSourceObject.Load(3, &r.inode) +func (rfd *replicaFileDescription) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &rfd.vfsfd) + stateSourceObject.Load(1, &rfd.FileDescriptionDefaultImpl) + stateSourceObject.Load(2, &rfd.LockFD) + stateSourceObject.Load(3, &rfd.inode) } func (r *rootInodeRefs) StateTypeName() string { @@ -424,11 +424,11 @@ func (r *rootInodeRefs) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(0, &r.refCount) } -func (t *Terminal) StateTypeName() string { +func (tm *Terminal) StateTypeName() string { return "pkg/sentry/fsimpl/devpts.Terminal" } -func (t *Terminal) StateFields() []string { +func (tm *Terminal) StateFields() []string { return []string{ "n", "ld", @@ -437,23 +437,23 @@ func (t *Terminal) StateFields() []string { } } -func (t *Terminal) beforeSave() {} +func (tm *Terminal) beforeSave() {} -func (t *Terminal) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.n) - stateSinkObject.Save(1, &t.ld) - stateSinkObject.Save(2, &t.masterKTTY) - stateSinkObject.Save(3, &t.replicaKTTY) +func (tm *Terminal) StateSave(stateSinkObject state.Sink) { + tm.beforeSave() + stateSinkObject.Save(0, &tm.n) + stateSinkObject.Save(1, &tm.ld) + stateSinkObject.Save(2, &tm.masterKTTY) + stateSinkObject.Save(3, &tm.replicaKTTY) } -func (t *Terminal) afterLoad() {} +func (tm *Terminal) afterLoad() {} -func (t *Terminal) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.n) - stateSourceObject.Load(1, &t.ld) - stateSourceObject.Load(2, &t.masterKTTY) - stateSourceObject.Load(3, &t.replicaKTTY) +func (tm *Terminal) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &tm.n) + stateSourceObject.Load(1, &tm.ld) + stateSourceObject.Load(2, &tm.masterKTTY) + stateSourceObject.Load(3, &tm.replicaKTTY) } func init() { diff --git a/pkg/sentry/fsimpl/devtmpfs/devtmpfs_state_autogen.go b/pkg/sentry/fsimpl/devtmpfs/devtmpfs_state_autogen.go index b9885df45..86033019a 100644 --- a/pkg/sentry/fsimpl/devtmpfs/devtmpfs_state_autogen.go +++ b/pkg/sentry/fsimpl/devtmpfs/devtmpfs_state_autogen.go @@ -6,11 +6,11 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (f *FilesystemType) StateTypeName() string { +func (fst *FilesystemType) StateTypeName() string { return "pkg/sentry/fsimpl/devtmpfs.FilesystemType" } -func (f *FilesystemType) StateFields() []string { +func (fst *FilesystemType) StateFields() []string { return []string{ "initErr", "fs", @@ -18,21 +18,21 @@ func (f *FilesystemType) StateFields() []string { } } -func (f *FilesystemType) beforeSave() {} +func (fst *FilesystemType) beforeSave() {} -func (f *FilesystemType) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.initErr) - stateSinkObject.Save(1, &f.fs) - stateSinkObject.Save(2, &f.root) +func (fst *FilesystemType) StateSave(stateSinkObject state.Sink) { + fst.beforeSave() + stateSinkObject.Save(0, &fst.initErr) + stateSinkObject.Save(1, &fst.fs) + stateSinkObject.Save(2, &fst.root) } -func (f *FilesystemType) afterLoad() {} +func (fst *FilesystemType) afterLoad() {} -func (f *FilesystemType) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.initErr) - stateSourceObject.Load(1, &f.fs) - stateSourceObject.Load(2, &f.root) +func (fst *FilesystemType) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fst.initErr) + stateSourceObject.Load(1, &fst.fs) + stateSourceObject.Load(2, &fst.root) } func init() { diff --git a/pkg/sentry/fsimpl/eventfd/eventfd_state_autogen.go b/pkg/sentry/fsimpl/eventfd/eventfd_state_autogen.go index 3de6bc3bb..1c19f900a 100644 --- a/pkg/sentry/fsimpl/eventfd/eventfd_state_autogen.go +++ b/pkg/sentry/fsimpl/eventfd/eventfd_state_autogen.go @@ -6,11 +6,11 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (e *EventFileDescription) StateTypeName() string { +func (efd *EventFileDescription) StateTypeName() string { return "pkg/sentry/fsimpl/eventfd.EventFileDescription" } -func (e *EventFileDescription) StateFields() []string { +func (efd *EventFileDescription) StateFields() []string { return []string{ "vfsfd", "FileDescriptionDefaultImpl", @@ -22,32 +22,32 @@ func (e *EventFileDescription) StateFields() []string { } } -func (e *EventFileDescription) beforeSave() {} +func (efd *EventFileDescription) beforeSave() {} -func (e *EventFileDescription) StateSave(stateSinkObject state.Sink) { - e.beforeSave() - if !state.IsZeroValue(&e.queue) { - state.Failf("queue is %#v, expected zero", &e.queue) +func (efd *EventFileDescription) StateSave(stateSinkObject state.Sink) { + efd.beforeSave() + if !state.IsZeroValue(&efd.queue) { + state.Failf("queue is %#v, expected zero", &efd.queue) } - stateSinkObject.Save(0, &e.vfsfd) - stateSinkObject.Save(1, &e.FileDescriptionDefaultImpl) - stateSinkObject.Save(2, &e.DentryMetadataFileDescriptionImpl) - stateSinkObject.Save(3, &e.NoLockFD) - stateSinkObject.Save(4, &e.val) - stateSinkObject.Save(5, &e.semMode) - stateSinkObject.Save(6, &e.hostfd) + stateSinkObject.Save(0, &efd.vfsfd) + stateSinkObject.Save(1, &efd.FileDescriptionDefaultImpl) + stateSinkObject.Save(2, &efd.DentryMetadataFileDescriptionImpl) + stateSinkObject.Save(3, &efd.NoLockFD) + stateSinkObject.Save(4, &efd.val) + stateSinkObject.Save(5, &efd.semMode) + stateSinkObject.Save(6, &efd.hostfd) } -func (e *EventFileDescription) afterLoad() {} +func (efd *EventFileDescription) afterLoad() {} -func (e *EventFileDescription) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &e.vfsfd) - stateSourceObject.Load(1, &e.FileDescriptionDefaultImpl) - stateSourceObject.Load(2, &e.DentryMetadataFileDescriptionImpl) - stateSourceObject.Load(3, &e.NoLockFD) - stateSourceObject.Load(4, &e.val) - stateSourceObject.Load(5, &e.semMode) - stateSourceObject.Load(6, &e.hostfd) +func (efd *EventFileDescription) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &efd.vfsfd) + stateSourceObject.Load(1, &efd.FileDescriptionDefaultImpl) + stateSourceObject.Load(2, &efd.DentryMetadataFileDescriptionImpl) + stateSourceObject.Load(3, &efd.NoLockFD) + stateSourceObject.Load(4, &efd.val) + stateSourceObject.Load(5, &efd.semMode) + stateSourceObject.Load(6, &efd.hostfd) } func init() { diff --git a/pkg/sentry/fsimpl/fuse/fuse_state_autogen.go b/pkg/sentry/fsimpl/fuse/fuse_state_autogen.go index fc0da410c..3c189317f 100644 --- a/pkg/sentry/fsimpl/fuse/fuse_state_autogen.go +++ b/pkg/sentry/fsimpl/fuse/fuse_state_autogen.go @@ -6,11 +6,11 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (c *connection) StateTypeName() string { +func (conn *connection) StateTypeName() string { return "pkg/sentry/fsimpl/fuse.connection" } -func (c *connection) StateFields() []string { +func (conn *connection) StateFields() []string { return []string{ "fd", "attributeVersion", @@ -37,60 +37,60 @@ func (c *connection) StateFields() []string { } } -func (c *connection) beforeSave() {} +func (conn *connection) beforeSave() {} -func (c *connection) StateSave(stateSinkObject state.Sink) { - c.beforeSave() - var initializedChanValue bool = c.saveInitializedChan() +func (conn *connection) StateSave(stateSinkObject state.Sink) { + conn.beforeSave() + var initializedChanValue bool = conn.saveInitializedChan() stateSinkObject.SaveValue(3, initializedChanValue) - stateSinkObject.Save(0, &c.fd) - stateSinkObject.Save(1, &c.attributeVersion) - stateSinkObject.Save(2, &c.initialized) - stateSinkObject.Save(4, &c.connected) - stateSinkObject.Save(5, &c.connInitError) - stateSinkObject.Save(6, &c.connInitSuccess) - stateSinkObject.Save(7, &c.aborted) - stateSinkObject.Save(8, &c.numWaiting) - stateSinkObject.Save(9, &c.asyncNum) - stateSinkObject.Save(10, &c.asyncCongestionThreshold) - stateSinkObject.Save(11, &c.asyncNumMax) - stateSinkObject.Save(12, &c.maxRead) - stateSinkObject.Save(13, &c.maxWrite) - stateSinkObject.Save(14, &c.maxPages) - stateSinkObject.Save(15, &c.minor) - stateSinkObject.Save(16, &c.atomicOTrunc) - stateSinkObject.Save(17, &c.asyncRead) - stateSinkObject.Save(18, &c.writebackCache) - stateSinkObject.Save(19, &c.bigWrites) - stateSinkObject.Save(20, &c.dontMask) - stateSinkObject.Save(21, &c.noOpen) -} - -func (c *connection) afterLoad() {} - -func (c *connection) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &c.fd) - stateSourceObject.Load(1, &c.attributeVersion) - stateSourceObject.Load(2, &c.initialized) - stateSourceObject.Load(4, &c.connected) - stateSourceObject.Load(5, &c.connInitError) - stateSourceObject.Load(6, &c.connInitSuccess) - stateSourceObject.Load(7, &c.aborted) - stateSourceObject.Load(8, &c.numWaiting) - stateSourceObject.Load(9, &c.asyncNum) - stateSourceObject.Load(10, &c.asyncCongestionThreshold) - stateSourceObject.Load(11, &c.asyncNumMax) - stateSourceObject.Load(12, &c.maxRead) - stateSourceObject.Load(13, &c.maxWrite) - stateSourceObject.Load(14, &c.maxPages) - stateSourceObject.Load(15, &c.minor) - stateSourceObject.Load(16, &c.atomicOTrunc) - stateSourceObject.Load(17, &c.asyncRead) - stateSourceObject.Load(18, &c.writebackCache) - stateSourceObject.Load(19, &c.bigWrites) - stateSourceObject.Load(20, &c.dontMask) - stateSourceObject.Load(21, &c.noOpen) - stateSourceObject.LoadValue(3, new(bool), func(y interface{}) { c.loadInitializedChan(y.(bool)) }) + stateSinkObject.Save(0, &conn.fd) + stateSinkObject.Save(1, &conn.attributeVersion) + stateSinkObject.Save(2, &conn.initialized) + stateSinkObject.Save(4, &conn.connected) + stateSinkObject.Save(5, &conn.connInitError) + stateSinkObject.Save(6, &conn.connInitSuccess) + stateSinkObject.Save(7, &conn.aborted) + stateSinkObject.Save(8, &conn.numWaiting) + stateSinkObject.Save(9, &conn.asyncNum) + stateSinkObject.Save(10, &conn.asyncCongestionThreshold) + stateSinkObject.Save(11, &conn.asyncNumMax) + stateSinkObject.Save(12, &conn.maxRead) + stateSinkObject.Save(13, &conn.maxWrite) + stateSinkObject.Save(14, &conn.maxPages) + stateSinkObject.Save(15, &conn.minor) + stateSinkObject.Save(16, &conn.atomicOTrunc) + stateSinkObject.Save(17, &conn.asyncRead) + stateSinkObject.Save(18, &conn.writebackCache) + stateSinkObject.Save(19, &conn.bigWrites) + stateSinkObject.Save(20, &conn.dontMask) + stateSinkObject.Save(21, &conn.noOpen) +} + +func (conn *connection) afterLoad() {} + +func (conn *connection) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &conn.fd) + stateSourceObject.Load(1, &conn.attributeVersion) + stateSourceObject.Load(2, &conn.initialized) + stateSourceObject.Load(4, &conn.connected) + stateSourceObject.Load(5, &conn.connInitError) + stateSourceObject.Load(6, &conn.connInitSuccess) + stateSourceObject.Load(7, &conn.aborted) + stateSourceObject.Load(8, &conn.numWaiting) + stateSourceObject.Load(9, &conn.asyncNum) + stateSourceObject.Load(10, &conn.asyncCongestionThreshold) + stateSourceObject.Load(11, &conn.asyncNumMax) + stateSourceObject.Load(12, &conn.maxRead) + stateSourceObject.Load(13, &conn.maxWrite) + stateSourceObject.Load(14, &conn.maxPages) + stateSourceObject.Load(15, &conn.minor) + stateSourceObject.Load(16, &conn.atomicOTrunc) + stateSourceObject.Load(17, &conn.asyncRead) + stateSourceObject.Load(18, &conn.writebackCache) + stateSourceObject.Load(19, &conn.bigWrites) + stateSourceObject.Load(20, &conn.dontMask) + stateSourceObject.Load(21, &conn.noOpen) + stateSourceObject.LoadValue(3, new(bool), func(y interface{}) { conn.loadInitializedChan(y.(bool)) }) } func (f *fuseDevice) StateTypeName() string { @@ -112,11 +112,11 @@ func (f *fuseDevice) afterLoad() {} func (f *fuseDevice) StateLoad(stateSourceObject state.Source) { } -func (d *DeviceFD) StateTypeName() string { +func (fd *DeviceFD) StateTypeName() string { return "pkg/sentry/fsimpl/fuse.DeviceFD" } -func (d *DeviceFD) StateFields() []string { +func (fd *DeviceFD) StateFields() []string { return []string{ "vfsfd", "FileDescriptionDefaultImpl", @@ -135,63 +135,63 @@ func (d *DeviceFD) StateFields() []string { } } -func (d *DeviceFD) beforeSave() {} +func (fd *DeviceFD) beforeSave() {} -func (d *DeviceFD) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - var fullQueueChValue int = d.saveFullQueueCh() +func (fd *DeviceFD) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + var fullQueueChValue int = fd.saveFullQueueCh() stateSinkObject.SaveValue(12, fullQueueChValue) - stateSinkObject.Save(0, &d.vfsfd) - stateSinkObject.Save(1, &d.FileDescriptionDefaultImpl) - stateSinkObject.Save(2, &d.DentryMetadataFileDescriptionImpl) - stateSinkObject.Save(3, &d.NoLockFD) - stateSinkObject.Save(4, &d.nextOpID) - stateSinkObject.Save(5, &d.queue) - stateSinkObject.Save(6, &d.numActiveRequests) - stateSinkObject.Save(7, &d.completions) - stateSinkObject.Save(8, &d.writeCursor) - stateSinkObject.Save(9, &d.writeBuf) - stateSinkObject.Save(10, &d.writeCursorFR) - stateSinkObject.Save(11, &d.waitQueue) - stateSinkObject.Save(13, &d.fs) -} - -func (d *DeviceFD) afterLoad() {} - -func (d *DeviceFD) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.vfsfd) - stateSourceObject.Load(1, &d.FileDescriptionDefaultImpl) - stateSourceObject.Load(2, &d.DentryMetadataFileDescriptionImpl) - stateSourceObject.Load(3, &d.NoLockFD) - stateSourceObject.Load(4, &d.nextOpID) - stateSourceObject.Load(5, &d.queue) - stateSourceObject.Load(6, &d.numActiveRequests) - stateSourceObject.Load(7, &d.completions) - stateSourceObject.Load(8, &d.writeCursor) - stateSourceObject.Load(9, &d.writeBuf) - stateSourceObject.Load(10, &d.writeCursorFR) - stateSourceObject.Load(11, &d.waitQueue) - stateSourceObject.Load(13, &d.fs) - stateSourceObject.LoadValue(12, new(int), func(y interface{}) { d.loadFullQueueCh(y.(int)) }) -} - -func (f *FilesystemType) StateTypeName() string { + stateSinkObject.Save(0, &fd.vfsfd) + stateSinkObject.Save(1, &fd.FileDescriptionDefaultImpl) + stateSinkObject.Save(2, &fd.DentryMetadataFileDescriptionImpl) + stateSinkObject.Save(3, &fd.NoLockFD) + stateSinkObject.Save(4, &fd.nextOpID) + stateSinkObject.Save(5, &fd.queue) + stateSinkObject.Save(6, &fd.numActiveRequests) + stateSinkObject.Save(7, &fd.completions) + stateSinkObject.Save(8, &fd.writeCursor) + stateSinkObject.Save(9, &fd.writeBuf) + stateSinkObject.Save(10, &fd.writeCursorFR) + stateSinkObject.Save(11, &fd.waitQueue) + stateSinkObject.Save(13, &fd.fs) +} + +func (fd *DeviceFD) afterLoad() {} + +func (fd *DeviceFD) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.vfsfd) + stateSourceObject.Load(1, &fd.FileDescriptionDefaultImpl) + stateSourceObject.Load(2, &fd.DentryMetadataFileDescriptionImpl) + stateSourceObject.Load(3, &fd.NoLockFD) + stateSourceObject.Load(4, &fd.nextOpID) + stateSourceObject.Load(5, &fd.queue) + stateSourceObject.Load(6, &fd.numActiveRequests) + stateSourceObject.Load(7, &fd.completions) + stateSourceObject.Load(8, &fd.writeCursor) + stateSourceObject.Load(9, &fd.writeBuf) + stateSourceObject.Load(10, &fd.writeCursorFR) + stateSourceObject.Load(11, &fd.waitQueue) + stateSourceObject.Load(13, &fd.fs) + stateSourceObject.LoadValue(12, new(int), func(y interface{}) { fd.loadFullQueueCh(y.(int)) }) +} + +func (fsType *FilesystemType) StateTypeName() string { return "pkg/sentry/fsimpl/fuse.FilesystemType" } -func (f *FilesystemType) StateFields() []string { +func (fsType *FilesystemType) StateFields() []string { return []string{} } -func (f *FilesystemType) beforeSave() {} +func (fsType *FilesystemType) beforeSave() {} -func (f *FilesystemType) StateSave(stateSinkObject state.Sink) { - f.beforeSave() +func (fsType *FilesystemType) StateSave(stateSinkObject state.Sink) { + fsType.beforeSave() } -func (f *FilesystemType) afterLoad() {} +func (fsType *FilesystemType) afterLoad() {} -func (f *FilesystemType) StateLoad(stateSourceObject state.Source) { +func (fsType *FilesystemType) StateLoad(stateSourceObject state.Source) { } func (f *filesystemOptions) StateTypeName() string { @@ -229,11 +229,11 @@ func (f *filesystemOptions) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(4, &f.maxRead) } -func (f *filesystem) StateTypeName() string { +func (fs *filesystem) StateTypeName() string { return "pkg/sentry/fsimpl/fuse.filesystem" } -func (f *filesystem) StateFields() []string { +func (fs *filesystem) StateFields() []string { return []string{ "Filesystem", "devMinor", @@ -243,25 +243,25 @@ func (f *filesystem) StateFields() []string { } } -func (f *filesystem) beforeSave() {} +func (fs *filesystem) beforeSave() {} -func (f *filesystem) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.Filesystem) - stateSinkObject.Save(1, &f.devMinor) - stateSinkObject.Save(2, &f.conn) - stateSinkObject.Save(3, &f.opts) - stateSinkObject.Save(4, &f.umounted) +func (fs *filesystem) StateSave(stateSinkObject state.Sink) { + fs.beforeSave() + stateSinkObject.Save(0, &fs.Filesystem) + stateSinkObject.Save(1, &fs.devMinor) + stateSinkObject.Save(2, &fs.conn) + stateSinkObject.Save(3, &fs.opts) + stateSinkObject.Save(4, &fs.umounted) } -func (f *filesystem) afterLoad() {} +func (fs *filesystem) afterLoad() {} -func (f *filesystem) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.Filesystem) - stateSourceObject.Load(1, &f.devMinor) - stateSourceObject.Load(2, &f.conn) - stateSourceObject.Load(3, &f.opts) - stateSourceObject.Load(4, &f.umounted) +func (fs *filesystem) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fs.Filesystem) + stateSourceObject.Load(1, &fs.devMinor) + stateSourceObject.Load(2, &fs.conn) + stateSourceObject.Load(3, &fs.opts) + stateSourceObject.Load(4, &fs.umounted) } func (i *inode) StateTypeName() string { @@ -332,79 +332,79 @@ func (i *inode) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(15, &i.link) } -func (i *inodeRefs) StateTypeName() string { +func (r *inodeRefs) StateTypeName() string { return "pkg/sentry/fsimpl/fuse.inodeRefs" } -func (i *inodeRefs) StateFields() []string { +func (r *inodeRefs) StateFields() []string { return []string{ "refCount", } } -func (i *inodeRefs) beforeSave() {} +func (r *inodeRefs) beforeSave() {} -func (i *inodeRefs) StateSave(stateSinkObject state.Sink) { - i.beforeSave() - stateSinkObject.Save(0, &i.refCount) +func (r *inodeRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (i *inodeRefs) afterLoad() {} +func (r *inodeRefs) afterLoad() {} -func (i *inodeRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &i.refCount) +func (r *inodeRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } -func (r *requestList) StateTypeName() string { +func (l *requestList) StateTypeName() string { return "pkg/sentry/fsimpl/fuse.requestList" } -func (r *requestList) StateFields() []string { +func (l *requestList) StateFields() []string { return []string{ "head", "tail", } } -func (r *requestList) beforeSave() {} +func (l *requestList) beforeSave() {} -func (r *requestList) StateSave(stateSinkObject state.Sink) { - r.beforeSave() - stateSinkObject.Save(0, &r.head) - stateSinkObject.Save(1, &r.tail) +func (l *requestList) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.head) + stateSinkObject.Save(1, &l.tail) } -func (r *requestList) afterLoad() {} +func (l *requestList) afterLoad() {} -func (r *requestList) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &r.head) - stateSourceObject.Load(1, &r.tail) +func (l *requestList) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.head) + stateSourceObject.Load(1, &l.tail) } -func (r *requestEntry) StateTypeName() string { +func (e *requestEntry) StateTypeName() string { return "pkg/sentry/fsimpl/fuse.requestEntry" } -func (r *requestEntry) StateFields() []string { +func (e *requestEntry) StateFields() []string { return []string{ "next", "prev", } } -func (r *requestEntry) beforeSave() {} +func (e *requestEntry) beforeSave() {} -func (r *requestEntry) StateSave(stateSinkObject state.Sink) { - r.beforeSave() - stateSinkObject.Save(0, &r.next) - stateSinkObject.Save(1, &r.prev) +func (e *requestEntry) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.next) + stateSinkObject.Save(1, &e.prev) } -func (r *requestEntry) afterLoad() {} +func (e *requestEntry) afterLoad() {} -func (r *requestEntry) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &r.next) - stateSourceObject.Load(1, &r.prev) +func (e *requestEntry) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.next) + stateSourceObject.Load(1, &e.prev) } func (r *Request) StateTypeName() string { diff --git a/pkg/sentry/fsimpl/gofer/gofer_state_autogen.go b/pkg/sentry/fsimpl/gofer/gofer_state_autogen.go index 1316e29e5..4d8560b53 100644 --- a/pkg/sentry/fsimpl/gofer/gofer_state_autogen.go +++ b/pkg/sentry/fsimpl/gofer/gofer_state_autogen.go @@ -6,63 +6,63 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (d *dentryList) StateTypeName() string { +func (l *dentryList) StateTypeName() string { return "pkg/sentry/fsimpl/gofer.dentryList" } -func (d *dentryList) StateFields() []string { +func (l *dentryList) StateFields() []string { return []string{ "head", "tail", } } -func (d *dentryList) beforeSave() {} +func (l *dentryList) beforeSave() {} -func (d *dentryList) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - stateSinkObject.Save(0, &d.head) - stateSinkObject.Save(1, &d.tail) +func (l *dentryList) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.head) + stateSinkObject.Save(1, &l.tail) } -func (d *dentryList) afterLoad() {} +func (l *dentryList) afterLoad() {} -func (d *dentryList) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.head) - stateSourceObject.Load(1, &d.tail) +func (l *dentryList) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.head) + stateSourceObject.Load(1, &l.tail) } -func (d *dentryEntry) StateTypeName() string { +func (e *dentryEntry) StateTypeName() string { return "pkg/sentry/fsimpl/gofer.dentryEntry" } -func (d *dentryEntry) StateFields() []string { +func (e *dentryEntry) StateFields() []string { return []string{ "next", "prev", } } -func (d *dentryEntry) beforeSave() {} +func (e *dentryEntry) beforeSave() {} -func (d *dentryEntry) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - stateSinkObject.Save(0, &d.next) - stateSinkObject.Save(1, &d.prev) +func (e *dentryEntry) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.next) + stateSinkObject.Save(1, &e.prev) } -func (d *dentryEntry) afterLoad() {} +func (e *dentryEntry) afterLoad() {} -func (d *dentryEntry) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.next) - stateSourceObject.Load(1, &d.prev) +func (e *dentryEntry) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.next) + stateSourceObject.Load(1, &e.prev) } -func (d *directoryFD) StateTypeName() string { +func (fd *directoryFD) StateTypeName() string { return "pkg/sentry/fsimpl/gofer.directoryFD" } -func (d *directoryFD) StateFields() []string { +func (fd *directoryFD) StateFields() []string { return []string{ "fileDescription", "DirectoryFileDescriptionDefaultImpl", @@ -71,49 +71,49 @@ func (d *directoryFD) StateFields() []string { } } -func (d *directoryFD) beforeSave() {} +func (fd *directoryFD) beforeSave() {} -func (d *directoryFD) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - stateSinkObject.Save(0, &d.fileDescription) - stateSinkObject.Save(1, &d.DirectoryFileDescriptionDefaultImpl) - stateSinkObject.Save(2, &d.off) - stateSinkObject.Save(3, &d.dirents) +func (fd *directoryFD) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.fileDescription) + stateSinkObject.Save(1, &fd.DirectoryFileDescriptionDefaultImpl) + stateSinkObject.Save(2, &fd.off) + stateSinkObject.Save(3, &fd.dirents) } -func (d *directoryFD) afterLoad() {} +func (fd *directoryFD) afterLoad() {} -func (d *directoryFD) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.fileDescription) - stateSourceObject.Load(1, &d.DirectoryFileDescriptionDefaultImpl) - stateSourceObject.Load(2, &d.off) - stateSourceObject.Load(3, &d.dirents) +func (fd *directoryFD) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.fileDescription) + stateSourceObject.Load(1, &fd.DirectoryFileDescriptionDefaultImpl) + stateSourceObject.Load(2, &fd.off) + stateSourceObject.Load(3, &fd.dirents) } -func (f *FilesystemType) StateTypeName() string { +func (fstype *FilesystemType) StateTypeName() string { return "pkg/sentry/fsimpl/gofer.FilesystemType" } -func (f *FilesystemType) StateFields() []string { +func (fstype *FilesystemType) StateFields() []string { return []string{} } -func (f *FilesystemType) beforeSave() {} +func (fstype *FilesystemType) beforeSave() {} -func (f *FilesystemType) StateSave(stateSinkObject state.Sink) { - f.beforeSave() +func (fstype *FilesystemType) StateSave(stateSinkObject state.Sink) { + fstype.beforeSave() } -func (f *FilesystemType) afterLoad() {} +func (fstype *FilesystemType) afterLoad() {} -func (f *FilesystemType) StateLoad(stateSourceObject state.Source) { +func (fstype *FilesystemType) StateLoad(stateSourceObject state.Source) { } -func (f *filesystem) StateTypeName() string { +func (fs *filesystem) StateTypeName() string { return "pkg/sentry/fsimpl/gofer.filesystem" } -func (f *filesystem) StateFields() []string { +func (fs *filesystem) StateFields() []string { return []string{ "vfsfs", "mfp", @@ -129,37 +129,37 @@ func (f *filesystem) StateFields() []string { } } -func (f *filesystem) beforeSave() {} +func (fs *filesystem) beforeSave() {} -func (f *filesystem) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.vfsfs) - stateSinkObject.Save(1, &f.mfp) - stateSinkObject.Save(2, &f.opts) - stateSinkObject.Save(3, &f.iopts) - stateSinkObject.Save(4, &f.clock) - stateSinkObject.Save(5, &f.devMinor) - stateSinkObject.Save(6, &f.cachedDentries) - stateSinkObject.Save(7, &f.cachedDentriesLen) - stateSinkObject.Save(8, &f.syncableDentries) - stateSinkObject.Save(9, &f.specialFileFDs) - stateSinkObject.Save(10, &f.syntheticSeq) -} - -func (f *filesystem) afterLoad() {} - -func (f *filesystem) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.vfsfs) - stateSourceObject.Load(1, &f.mfp) - stateSourceObject.Load(2, &f.opts) - stateSourceObject.Load(3, &f.iopts) - stateSourceObject.Load(4, &f.clock) - stateSourceObject.Load(5, &f.devMinor) - stateSourceObject.Load(6, &f.cachedDentries) - stateSourceObject.Load(7, &f.cachedDentriesLen) - stateSourceObject.Load(8, &f.syncableDentries) - stateSourceObject.Load(9, &f.specialFileFDs) - stateSourceObject.Load(10, &f.syntheticSeq) +func (fs *filesystem) StateSave(stateSinkObject state.Sink) { + fs.beforeSave() + stateSinkObject.Save(0, &fs.vfsfs) + stateSinkObject.Save(1, &fs.mfp) + stateSinkObject.Save(2, &fs.opts) + stateSinkObject.Save(3, &fs.iopts) + stateSinkObject.Save(4, &fs.clock) + stateSinkObject.Save(5, &fs.devMinor) + stateSinkObject.Save(6, &fs.cachedDentries) + stateSinkObject.Save(7, &fs.cachedDentriesLen) + stateSinkObject.Save(8, &fs.syncableDentries) + stateSinkObject.Save(9, &fs.specialFileFDs) + stateSinkObject.Save(10, &fs.syntheticSeq) +} + +func (fs *filesystem) afterLoad() {} + +func (fs *filesystem) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fs.vfsfs) + stateSourceObject.Load(1, &fs.mfp) + stateSourceObject.Load(2, &fs.opts) + stateSourceObject.Load(3, &fs.iopts) + stateSourceObject.Load(4, &fs.clock) + stateSourceObject.Load(5, &fs.devMinor) + stateSourceObject.Load(6, &fs.cachedDentries) + stateSourceObject.Load(7, &fs.cachedDentriesLen) + stateSourceObject.Load(8, &fs.syncableDentries) + stateSourceObject.Load(9, &fs.specialFileFDs) + stateSourceObject.Load(10, &fs.syntheticSeq) } func (i *inodeNumber) StateTypeName() string { @@ -385,11 +385,11 @@ func (d *dentry) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(34, &d.watches) } -func (f *fileDescription) StateTypeName() string { +func (fd *fileDescription) StateTypeName() string { return "pkg/sentry/fsimpl/gofer.fileDescription" } -func (f *fileDescription) StateFields() []string { +func (fd *fileDescription) StateFields() []string { return []string{ "vfsfd", "FileDescriptionDefaultImpl", @@ -397,47 +397,47 @@ func (f *fileDescription) StateFields() []string { } } -func (f *fileDescription) beforeSave() {} +func (fd *fileDescription) beforeSave() {} -func (f *fileDescription) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.vfsfd) - stateSinkObject.Save(1, &f.FileDescriptionDefaultImpl) - stateSinkObject.Save(2, &f.LockFD) +func (fd *fileDescription) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.vfsfd) + stateSinkObject.Save(1, &fd.FileDescriptionDefaultImpl) + stateSinkObject.Save(2, &fd.LockFD) } -func (f *fileDescription) afterLoad() {} +func (fd *fileDescription) afterLoad() {} -func (f *fileDescription) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.vfsfd) - stateSourceObject.Load(1, &f.FileDescriptionDefaultImpl) - stateSourceObject.Load(2, &f.LockFD) +func (fd *fileDescription) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.vfsfd) + stateSourceObject.Load(1, &fd.FileDescriptionDefaultImpl) + stateSourceObject.Load(2, &fd.LockFD) } -func (r *regularFileFD) StateTypeName() string { +func (fd *regularFileFD) StateTypeName() string { return "pkg/sentry/fsimpl/gofer.regularFileFD" } -func (r *regularFileFD) StateFields() []string { +func (fd *regularFileFD) StateFields() []string { return []string{ "fileDescription", "off", } } -func (r *regularFileFD) beforeSave() {} +func (fd *regularFileFD) beforeSave() {} -func (r *regularFileFD) StateSave(stateSinkObject state.Sink) { - r.beforeSave() - stateSinkObject.Save(0, &r.fileDescription) - stateSinkObject.Save(1, &r.off) +func (fd *regularFileFD) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.fileDescription) + stateSinkObject.Save(1, &fd.off) } -func (r *regularFileFD) afterLoad() {} +func (fd *regularFileFD) afterLoad() {} -func (r *regularFileFD) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &r.fileDescription) - stateSourceObject.Load(1, &r.off) +func (fd *regularFileFD) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.fileDescription) + stateSourceObject.Load(1, &fd.off) } func (d *dentryPlatformFile) StateTypeName() string { @@ -495,11 +495,11 @@ func (e *endpoint) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &e.path) } -func (s *specialFileFD) StateTypeName() string { +func (fd *specialFileFD) StateTypeName() string { return "pkg/sentry/fsimpl/gofer.specialFileFD" } -func (s *specialFileFD) StateFields() []string { +func (fd *specialFileFD) StateFields() []string { return []string{ "fileDescription", "isRegularFile", @@ -510,27 +510,27 @@ func (s *specialFileFD) StateFields() []string { } } -func (s *specialFileFD) beforeSave() {} +func (fd *specialFileFD) beforeSave() {} -func (s *specialFileFD) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.fileDescription) - stateSinkObject.Save(1, &s.isRegularFile) - stateSinkObject.Save(2, &s.seekable) - stateSinkObject.Save(3, &s.haveQueue) - stateSinkObject.Save(4, &s.queue) - stateSinkObject.Save(5, &s.off) +func (fd *specialFileFD) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.fileDescription) + stateSinkObject.Save(1, &fd.isRegularFile) + stateSinkObject.Save(2, &fd.seekable) + stateSinkObject.Save(3, &fd.haveQueue) + stateSinkObject.Save(4, &fd.queue) + stateSinkObject.Save(5, &fd.off) } -func (s *specialFileFD) afterLoad() {} +func (fd *specialFileFD) afterLoad() {} -func (s *specialFileFD) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.fileDescription) - stateSourceObject.Load(1, &s.isRegularFile) - stateSourceObject.Load(2, &s.seekable) - stateSourceObject.Load(3, &s.haveQueue) - stateSourceObject.Load(4, &s.queue) - stateSourceObject.Load(5, &s.off) +func (fd *specialFileFD) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.fileDescription) + stateSourceObject.Load(1, &fd.isRegularFile) + stateSourceObject.Load(2, &fd.seekable) + stateSourceObject.Load(3, &fd.haveQueue) + stateSourceObject.Load(4, &fd.queue) + stateSourceObject.Load(5, &fd.off) } func init() { diff --git a/pkg/sentry/fsimpl/host/host_state_autogen.go b/pkg/sentry/fsimpl/host/host_state_autogen.go index 76a2fdbdd..c18cef145 100644 --- a/pkg/sentry/fsimpl/host/host_state_autogen.go +++ b/pkg/sentry/fsimpl/host/host_state_autogen.go @@ -6,27 +6,27 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (c *ConnectedEndpointRefs) StateTypeName() string { +func (r *ConnectedEndpointRefs) StateTypeName() string { return "pkg/sentry/fsimpl/host.ConnectedEndpointRefs" } -func (c *ConnectedEndpointRefs) StateFields() []string { +func (r *ConnectedEndpointRefs) StateFields() []string { return []string{ "refCount", } } -func (c *ConnectedEndpointRefs) beforeSave() {} +func (r *ConnectedEndpointRefs) beforeSave() {} -func (c *ConnectedEndpointRefs) StateSave(stateSinkObject state.Sink) { - c.beforeSave() - stateSinkObject.Save(0, &c.refCount) +func (r *ConnectedEndpointRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (c *ConnectedEndpointRefs) afterLoad() {} +func (r *ConnectedEndpointRefs) afterLoad() {} -func (c *ConnectedEndpointRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &c.refCount) +func (r *ConnectedEndpointRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } func (f *filesystemType) StateTypeName() string { @@ -48,30 +48,30 @@ func (f *filesystemType) afterLoad() {} func (f *filesystemType) StateLoad(stateSourceObject state.Source) { } -func (f *filesystem) StateTypeName() string { +func (fs *filesystem) StateTypeName() string { return "pkg/sentry/fsimpl/host.filesystem" } -func (f *filesystem) StateFields() []string { +func (fs *filesystem) StateFields() []string { return []string{ "Filesystem", "devMinor", } } -func (f *filesystem) beforeSave() {} +func (fs *filesystem) beforeSave() {} -func (f *filesystem) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.Filesystem) - stateSinkObject.Save(1, &f.devMinor) +func (fs *filesystem) StateSave(stateSinkObject state.Sink) { + fs.beforeSave() + stateSinkObject.Save(0, &fs.Filesystem) + stateSinkObject.Save(1, &fs.devMinor) } -func (f *filesystem) afterLoad() {} +func (fs *filesystem) afterLoad() {} -func (f *filesystem) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.Filesystem) - stateSourceObject.Load(1, &f.devMinor) +func (fs *filesystem) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fs.Filesystem) + stateSourceObject.Load(1, &fs.devMinor) } func (i *inode) StateTypeName() string { @@ -171,27 +171,27 @@ func (f *fileDescription) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(4, &f.offset) } -func (i *inodeRefs) StateTypeName() string { +func (r *inodeRefs) StateTypeName() string { return "pkg/sentry/fsimpl/host.inodeRefs" } -func (i *inodeRefs) StateFields() []string { +func (r *inodeRefs) StateFields() []string { return []string{ "refCount", } } -func (i *inodeRefs) beforeSave() {} +func (r *inodeRefs) beforeSave() {} -func (i *inodeRefs) StateSave(stateSinkObject state.Sink) { - i.beforeSave() - stateSinkObject.Save(0, &i.refCount) +func (r *inodeRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (i *inodeRefs) afterLoad() {} +func (r *inodeRefs) afterLoad() {} -func (i *inodeRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &i.refCount) +func (r *inodeRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } func (i *inodePlatformFile) StateTypeName() string { diff --git a/pkg/sentry/fsimpl/kernfs/kernfs_state_autogen.go b/pkg/sentry/fsimpl/kernfs/kernfs_state_autogen.go index dc7a033ab..7d9420725 100644 --- a/pkg/sentry/fsimpl/kernfs/kernfs_state_autogen.go +++ b/pkg/sentry/fsimpl/kernfs/kernfs_state_autogen.go @@ -6,34 +6,34 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (d *DentryRefs) StateTypeName() string { +func (r *DentryRefs) StateTypeName() string { return "pkg/sentry/fsimpl/kernfs.DentryRefs" } -func (d *DentryRefs) StateFields() []string { +func (r *DentryRefs) StateFields() []string { return []string{ "refCount", } } -func (d *DentryRefs) beforeSave() {} +func (r *DentryRefs) beforeSave() {} -func (d *DentryRefs) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - stateSinkObject.Save(0, &d.refCount) +func (r *DentryRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (d *DentryRefs) afterLoad() {} +func (r *DentryRefs) afterLoad() {} -func (d *DentryRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.refCount) +func (r *DentryRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } -func (d *DynamicBytesFile) StateTypeName() string { +func (f *DynamicBytesFile) StateTypeName() string { return "pkg/sentry/fsimpl/kernfs.DynamicBytesFile" } -func (d *DynamicBytesFile) StateFields() []string { +func (f *DynamicBytesFile) StateFields() []string { return []string{ "InodeAttrs", "InodeNoStatFS", @@ -45,36 +45,36 @@ func (d *DynamicBytesFile) StateFields() []string { } } -func (d *DynamicBytesFile) beforeSave() {} +func (f *DynamicBytesFile) beforeSave() {} -func (d *DynamicBytesFile) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - stateSinkObject.Save(0, &d.InodeAttrs) - stateSinkObject.Save(1, &d.InodeNoStatFS) - stateSinkObject.Save(2, &d.InodeNoopRefCount) - stateSinkObject.Save(3, &d.InodeNotDirectory) - stateSinkObject.Save(4, &d.InodeNotSymlink) - stateSinkObject.Save(5, &d.locks) - stateSinkObject.Save(6, &d.data) +func (f *DynamicBytesFile) StateSave(stateSinkObject state.Sink) { + f.beforeSave() + stateSinkObject.Save(0, &f.InodeAttrs) + stateSinkObject.Save(1, &f.InodeNoStatFS) + stateSinkObject.Save(2, &f.InodeNoopRefCount) + stateSinkObject.Save(3, &f.InodeNotDirectory) + stateSinkObject.Save(4, &f.InodeNotSymlink) + stateSinkObject.Save(5, &f.locks) + stateSinkObject.Save(6, &f.data) } -func (d *DynamicBytesFile) afterLoad() {} +func (f *DynamicBytesFile) afterLoad() {} -func (d *DynamicBytesFile) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.InodeAttrs) - stateSourceObject.Load(1, &d.InodeNoStatFS) - stateSourceObject.Load(2, &d.InodeNoopRefCount) - stateSourceObject.Load(3, &d.InodeNotDirectory) - stateSourceObject.Load(4, &d.InodeNotSymlink) - stateSourceObject.Load(5, &d.locks) - stateSourceObject.Load(6, &d.data) +func (f *DynamicBytesFile) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &f.InodeAttrs) + stateSourceObject.Load(1, &f.InodeNoStatFS) + stateSourceObject.Load(2, &f.InodeNoopRefCount) + stateSourceObject.Load(3, &f.InodeNotDirectory) + stateSourceObject.Load(4, &f.InodeNotSymlink) + stateSourceObject.Load(5, &f.locks) + stateSourceObject.Load(6, &f.data) } -func (d *DynamicBytesFD) StateTypeName() string { +func (fd *DynamicBytesFD) StateTypeName() string { return "pkg/sentry/fsimpl/kernfs.DynamicBytesFD" } -func (d *DynamicBytesFD) StateFields() []string { +func (fd *DynamicBytesFD) StateFields() []string { return []string{ "FileDescriptionDefaultImpl", "DynamicBytesFileDescriptionImpl", @@ -84,25 +84,25 @@ func (d *DynamicBytesFD) StateFields() []string { } } -func (d *DynamicBytesFD) beforeSave() {} +func (fd *DynamicBytesFD) beforeSave() {} -func (d *DynamicBytesFD) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - stateSinkObject.Save(0, &d.FileDescriptionDefaultImpl) - stateSinkObject.Save(1, &d.DynamicBytesFileDescriptionImpl) - stateSinkObject.Save(2, &d.LockFD) - stateSinkObject.Save(3, &d.vfsfd) - stateSinkObject.Save(4, &d.inode) +func (fd *DynamicBytesFD) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.FileDescriptionDefaultImpl) + stateSinkObject.Save(1, &fd.DynamicBytesFileDescriptionImpl) + stateSinkObject.Save(2, &fd.LockFD) + stateSinkObject.Save(3, &fd.vfsfd) + stateSinkObject.Save(4, &fd.inode) } -func (d *DynamicBytesFD) afterLoad() {} +func (fd *DynamicBytesFD) afterLoad() {} -func (d *DynamicBytesFD) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.FileDescriptionDefaultImpl) - stateSourceObject.Load(1, &d.DynamicBytesFileDescriptionImpl) - stateSourceObject.Load(2, &d.LockFD) - stateSourceObject.Load(3, &d.vfsfd) - stateSourceObject.Load(4, &d.inode) +func (fd *DynamicBytesFD) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.FileDescriptionDefaultImpl) + stateSourceObject.Load(1, &fd.DynamicBytesFileDescriptionImpl) + stateSourceObject.Load(2, &fd.LockFD) + stateSourceObject.Load(3, &fd.vfsfd) + stateSourceObject.Load(4, &fd.inode) } func (s *SeekEndConfig) StateTypeName() string { @@ -136,11 +136,11 @@ func (g *GenericDirectoryFDOptions) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(0, &g.SeekEnd) } -func (g *GenericDirectoryFD) StateTypeName() string { +func (fd *GenericDirectoryFD) StateTypeName() string { return "pkg/sentry/fsimpl/kernfs.GenericDirectoryFD" } -func (g *GenericDirectoryFD) StateFields() []string { +func (fd *GenericDirectoryFD) StateFields() []string { return []string{ "FileDescriptionDefaultImpl", "DirectoryFileDescriptionDefaultImpl", @@ -152,29 +152,29 @@ func (g *GenericDirectoryFD) StateFields() []string { } } -func (g *GenericDirectoryFD) beforeSave() {} +func (fd *GenericDirectoryFD) beforeSave() {} -func (g *GenericDirectoryFD) StateSave(stateSinkObject state.Sink) { - g.beforeSave() - stateSinkObject.Save(0, &g.FileDescriptionDefaultImpl) - stateSinkObject.Save(1, &g.DirectoryFileDescriptionDefaultImpl) - stateSinkObject.Save(2, &g.LockFD) - stateSinkObject.Save(3, &g.seekEnd) - stateSinkObject.Save(4, &g.vfsfd) - stateSinkObject.Save(5, &g.children) - stateSinkObject.Save(6, &g.off) +func (fd *GenericDirectoryFD) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.FileDescriptionDefaultImpl) + stateSinkObject.Save(1, &fd.DirectoryFileDescriptionDefaultImpl) + stateSinkObject.Save(2, &fd.LockFD) + stateSinkObject.Save(3, &fd.seekEnd) + stateSinkObject.Save(4, &fd.vfsfd) + stateSinkObject.Save(5, &fd.children) + stateSinkObject.Save(6, &fd.off) } -func (g *GenericDirectoryFD) afterLoad() {} +func (fd *GenericDirectoryFD) afterLoad() {} -func (g *GenericDirectoryFD) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &g.FileDescriptionDefaultImpl) - stateSourceObject.Load(1, &g.DirectoryFileDescriptionDefaultImpl) - stateSourceObject.Load(2, &g.LockFD) - stateSourceObject.Load(3, &g.seekEnd) - stateSourceObject.Load(4, &g.vfsfd) - stateSourceObject.Load(5, &g.children) - stateSourceObject.Load(6, &g.off) +func (fd *GenericDirectoryFD) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.FileDescriptionDefaultImpl) + stateSourceObject.Load(1, &fd.DirectoryFileDescriptionDefaultImpl) + stateSourceObject.Load(2, &fd.LockFD) + stateSourceObject.Load(3, &fd.seekEnd) + stateSourceObject.Load(4, &fd.vfsfd) + stateSourceObject.Load(5, &fd.children) + stateSourceObject.Load(6, &fd.off) } func (i *InodeNoopRefCount) StateTypeName() string { @@ -272,11 +272,11 @@ func (i *InodeNotSymlink) afterLoad() {} func (i *InodeNotSymlink) StateLoad(stateSourceObject state.Source) { } -func (i *InodeAttrs) StateTypeName() string { +func (a *InodeAttrs) StateTypeName() string { return "pkg/sentry/fsimpl/kernfs.InodeAttrs" } -func (i *InodeAttrs) StateFields() []string { +func (a *InodeAttrs) StateFields() []string { return []string{ "devMajor", "devMinor", @@ -288,29 +288,29 @@ func (i *InodeAttrs) StateFields() []string { } } -func (i *InodeAttrs) beforeSave() {} +func (a *InodeAttrs) beforeSave() {} -func (i *InodeAttrs) StateSave(stateSinkObject state.Sink) { - i.beforeSave() - stateSinkObject.Save(0, &i.devMajor) - stateSinkObject.Save(1, &i.devMinor) - stateSinkObject.Save(2, &i.ino) - stateSinkObject.Save(3, &i.mode) - stateSinkObject.Save(4, &i.uid) - stateSinkObject.Save(5, &i.gid) - stateSinkObject.Save(6, &i.nlink) +func (a *InodeAttrs) StateSave(stateSinkObject state.Sink) { + a.beforeSave() + stateSinkObject.Save(0, &a.devMajor) + stateSinkObject.Save(1, &a.devMinor) + stateSinkObject.Save(2, &a.ino) + stateSinkObject.Save(3, &a.mode) + stateSinkObject.Save(4, &a.uid) + stateSinkObject.Save(5, &a.gid) + stateSinkObject.Save(6, &a.nlink) } -func (i *InodeAttrs) afterLoad() {} +func (a *InodeAttrs) afterLoad() {} -func (i *InodeAttrs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &i.devMajor) - stateSourceObject.Load(1, &i.devMinor) - stateSourceObject.Load(2, &i.ino) - stateSourceObject.Load(3, &i.mode) - stateSourceObject.Load(4, &i.uid) - stateSourceObject.Load(5, &i.gid) - stateSourceObject.Load(6, &i.nlink) +func (a *InodeAttrs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &a.devMajor) + stateSourceObject.Load(1, &a.devMinor) + stateSourceObject.Load(2, &a.ino) + stateSourceObject.Load(3, &a.mode) + stateSourceObject.Load(4, &a.uid) + stateSourceObject.Load(5, &a.gid) + stateSourceObject.Load(6, &a.nlink) } func (s *slot) StateTypeName() string { @@ -521,11 +521,11 @@ func (i *InodeNoStatFS) afterLoad() {} func (i *InodeNoStatFS) StateLoad(stateSourceObject state.Source) { } -func (f *Filesystem) StateTypeName() string { +func (fs *Filesystem) StateTypeName() string { return "pkg/sentry/fsimpl/kernfs.Filesystem" } -func (f *Filesystem) StateFields() []string { +func (fs *Filesystem) StateFields() []string { return []string{ "vfsfs", "droppedDentries", @@ -533,21 +533,21 @@ func (f *Filesystem) StateFields() []string { } } -func (f *Filesystem) beforeSave() {} +func (fs *Filesystem) beforeSave() {} -func (f *Filesystem) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.vfsfs) - stateSinkObject.Save(1, &f.droppedDentries) - stateSinkObject.Save(2, &f.nextInoMinusOne) +func (fs *Filesystem) StateSave(stateSinkObject state.Sink) { + fs.beforeSave() + stateSinkObject.Save(0, &fs.vfsfs) + stateSinkObject.Save(1, &fs.droppedDentries) + stateSinkObject.Save(2, &fs.nextInoMinusOne) } -func (f *Filesystem) afterLoad() {} +func (fs *Filesystem) afterLoad() {} -func (f *Filesystem) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.vfsfs) - stateSourceObject.Load(1, &f.droppedDentries) - stateSourceObject.Load(2, &f.nextInoMinusOne) +func (fs *Filesystem) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fs.vfsfs) + stateSourceObject.Load(1, &fs.droppedDentries) + stateSourceObject.Load(2, &fs.nextInoMinusOne) } func (d *Dentry) StateTypeName() string { @@ -591,79 +591,79 @@ func (d *Dentry) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(6, &d.inode) } -func (s *slotList) StateTypeName() string { +func (l *slotList) StateTypeName() string { return "pkg/sentry/fsimpl/kernfs.slotList" } -func (s *slotList) StateFields() []string { +func (l *slotList) StateFields() []string { return []string{ "head", "tail", } } -func (s *slotList) beforeSave() {} +func (l *slotList) beforeSave() {} -func (s *slotList) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.head) - stateSinkObject.Save(1, &s.tail) +func (l *slotList) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.head) + stateSinkObject.Save(1, &l.tail) } -func (s *slotList) afterLoad() {} +func (l *slotList) afterLoad() {} -func (s *slotList) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.head) - stateSourceObject.Load(1, &s.tail) +func (l *slotList) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.head) + stateSourceObject.Load(1, &l.tail) } -func (s *slotEntry) StateTypeName() string { +func (e *slotEntry) StateTypeName() string { return "pkg/sentry/fsimpl/kernfs.slotEntry" } -func (s *slotEntry) StateFields() []string { +func (e *slotEntry) StateFields() []string { return []string{ "next", "prev", } } -func (s *slotEntry) beforeSave() {} +func (e *slotEntry) beforeSave() {} -func (s *slotEntry) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.next) - stateSinkObject.Save(1, &s.prev) +func (e *slotEntry) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.next) + stateSinkObject.Save(1, &e.prev) } -func (s *slotEntry) afterLoad() {} +func (e *slotEntry) afterLoad() {} -func (s *slotEntry) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.next) - stateSourceObject.Load(1, &s.prev) +func (e *slotEntry) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.next) + stateSourceObject.Load(1, &e.prev) } -func (s *StaticDirectoryRefs) StateTypeName() string { +func (r *StaticDirectoryRefs) StateTypeName() string { return "pkg/sentry/fsimpl/kernfs.StaticDirectoryRefs" } -func (s *StaticDirectoryRefs) StateFields() []string { +func (r *StaticDirectoryRefs) StateFields() []string { return []string{ "refCount", } } -func (s *StaticDirectoryRefs) beforeSave() {} +func (r *StaticDirectoryRefs) beforeSave() {} -func (s *StaticDirectoryRefs) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.refCount) +func (r *StaticDirectoryRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (s *StaticDirectoryRefs) afterLoad() {} +func (r *StaticDirectoryRefs) afterLoad() {} -func (s *StaticDirectoryRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.refCount) +func (r *StaticDirectoryRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } func (s *StaticSymlink) StateTypeName() string { @@ -701,11 +701,11 @@ func (s *StaticSymlink) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(4, &s.target) } -func (s *syntheticDirectory) StateTypeName() string { +func (dir *syntheticDirectory) StateTypeName() string { return "pkg/sentry/fsimpl/kernfs.syntheticDirectory" } -func (s *syntheticDirectory) StateFields() []string { +func (dir *syntheticDirectory) StateFields() []string { return []string{ "InodeAttrs", "InodeNoStatFS", @@ -717,29 +717,29 @@ func (s *syntheticDirectory) StateFields() []string { } } -func (s *syntheticDirectory) beforeSave() {} +func (dir *syntheticDirectory) beforeSave() {} -func (s *syntheticDirectory) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.InodeAttrs) - stateSinkObject.Save(1, &s.InodeNoStatFS) - stateSinkObject.Save(2, &s.InodeNoopRefCount) - stateSinkObject.Save(3, &s.InodeNoDynamicLookup) - stateSinkObject.Save(4, &s.InodeNotSymlink) - stateSinkObject.Save(5, &s.OrderedChildren) - stateSinkObject.Save(6, &s.locks) +func (dir *syntheticDirectory) StateSave(stateSinkObject state.Sink) { + dir.beforeSave() + stateSinkObject.Save(0, &dir.InodeAttrs) + stateSinkObject.Save(1, &dir.InodeNoStatFS) + stateSinkObject.Save(2, &dir.InodeNoopRefCount) + stateSinkObject.Save(3, &dir.InodeNoDynamicLookup) + stateSinkObject.Save(4, &dir.InodeNotSymlink) + stateSinkObject.Save(5, &dir.OrderedChildren) + stateSinkObject.Save(6, &dir.locks) } -func (s *syntheticDirectory) afterLoad() {} +func (dir *syntheticDirectory) afterLoad() {} -func (s *syntheticDirectory) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.InodeAttrs) - stateSourceObject.Load(1, &s.InodeNoStatFS) - stateSourceObject.Load(2, &s.InodeNoopRefCount) - stateSourceObject.Load(3, &s.InodeNoDynamicLookup) - stateSourceObject.Load(4, &s.InodeNotSymlink) - stateSourceObject.Load(5, &s.OrderedChildren) - stateSourceObject.Load(6, &s.locks) +func (dir *syntheticDirectory) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &dir.InodeAttrs) + stateSourceObject.Load(1, &dir.InodeNoStatFS) + stateSourceObject.Load(2, &dir.InodeNoopRefCount) + stateSourceObject.Load(3, &dir.InodeNoDynamicLookup) + stateSourceObject.Load(4, &dir.InodeNotSymlink) + stateSourceObject.Load(5, &dir.OrderedChildren) + stateSourceObject.Load(6, &dir.locks) } func init() { diff --git a/pkg/sentry/fsimpl/overlay/overlay_state_autogen.go b/pkg/sentry/fsimpl/overlay/overlay_state_autogen.go index bf2f3fb30..dde862ba3 100644 --- a/pkg/sentry/fsimpl/overlay/overlay_state_autogen.go +++ b/pkg/sentry/fsimpl/overlay/overlay_state_autogen.go @@ -6,11 +6,11 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (d *directoryFD) StateTypeName() string { +func (fd *directoryFD) StateTypeName() string { return "pkg/sentry/fsimpl/overlay.directoryFD" } -func (d *directoryFD) StateFields() []string { +func (fd *directoryFD) StateFields() []string { return []string{ "fileDescription", "DirectoryFileDescriptionDefaultImpl", @@ -20,32 +20,32 @@ func (d *directoryFD) StateFields() []string { } } -func (d *directoryFD) beforeSave() {} +func (fd *directoryFD) beforeSave() {} -func (d *directoryFD) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - stateSinkObject.Save(0, &d.fileDescription) - stateSinkObject.Save(1, &d.DirectoryFileDescriptionDefaultImpl) - stateSinkObject.Save(2, &d.DentryMetadataFileDescriptionImpl) - stateSinkObject.Save(3, &d.off) - stateSinkObject.Save(4, &d.dirents) +func (fd *directoryFD) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.fileDescription) + stateSinkObject.Save(1, &fd.DirectoryFileDescriptionDefaultImpl) + stateSinkObject.Save(2, &fd.DentryMetadataFileDescriptionImpl) + stateSinkObject.Save(3, &fd.off) + stateSinkObject.Save(4, &fd.dirents) } -func (d *directoryFD) afterLoad() {} +func (fd *directoryFD) afterLoad() {} -func (d *directoryFD) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.fileDescription) - stateSourceObject.Load(1, &d.DirectoryFileDescriptionDefaultImpl) - stateSourceObject.Load(2, &d.DentryMetadataFileDescriptionImpl) - stateSourceObject.Load(3, &d.off) - stateSourceObject.Load(4, &d.dirents) +func (fd *directoryFD) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.fileDescription) + stateSourceObject.Load(1, &fd.DirectoryFileDescriptionDefaultImpl) + stateSourceObject.Load(2, &fd.DentryMetadataFileDescriptionImpl) + stateSourceObject.Load(3, &fd.off) + stateSourceObject.Load(4, &fd.dirents) } -func (n *nonDirectoryFD) StateTypeName() string { +func (fd *nonDirectoryFD) StateTypeName() string { return "pkg/sentry/fsimpl/overlay.nonDirectoryFD" } -func (n *nonDirectoryFD) StateFields() []string { +func (fd *nonDirectoryFD) StateFields() []string { return []string{ "fileDescription", "copiedUp", @@ -54,42 +54,42 @@ func (n *nonDirectoryFD) StateFields() []string { } } -func (n *nonDirectoryFD) beforeSave() {} +func (fd *nonDirectoryFD) beforeSave() {} -func (n *nonDirectoryFD) StateSave(stateSinkObject state.Sink) { - n.beforeSave() - stateSinkObject.Save(0, &n.fileDescription) - stateSinkObject.Save(1, &n.copiedUp) - stateSinkObject.Save(2, &n.cachedFD) - stateSinkObject.Save(3, &n.cachedFlags) +func (fd *nonDirectoryFD) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.fileDescription) + stateSinkObject.Save(1, &fd.copiedUp) + stateSinkObject.Save(2, &fd.cachedFD) + stateSinkObject.Save(3, &fd.cachedFlags) } -func (n *nonDirectoryFD) afterLoad() {} +func (fd *nonDirectoryFD) afterLoad() {} -func (n *nonDirectoryFD) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &n.fileDescription) - stateSourceObject.Load(1, &n.copiedUp) - stateSourceObject.Load(2, &n.cachedFD) - stateSourceObject.Load(3, &n.cachedFlags) +func (fd *nonDirectoryFD) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.fileDescription) + stateSourceObject.Load(1, &fd.copiedUp) + stateSourceObject.Load(2, &fd.cachedFD) + stateSourceObject.Load(3, &fd.cachedFlags) } -func (f *FilesystemType) StateTypeName() string { +func (fstype *FilesystemType) StateTypeName() string { return "pkg/sentry/fsimpl/overlay.FilesystemType" } -func (f *FilesystemType) StateFields() []string { +func (fstype *FilesystemType) StateFields() []string { return []string{} } -func (f *FilesystemType) beforeSave() {} +func (fstype *FilesystemType) beforeSave() {} -func (f *FilesystemType) StateSave(stateSinkObject state.Sink) { - f.beforeSave() +func (fstype *FilesystemType) StateSave(stateSinkObject state.Sink) { + fstype.beforeSave() } -func (f *FilesystemType) afterLoad() {} +func (fstype *FilesystemType) afterLoad() {} -func (f *FilesystemType) StateLoad(stateSourceObject state.Source) { +func (fstype *FilesystemType) StateLoad(stateSourceObject state.Source) { } func (f *FilesystemOptions) StateTypeName() string { @@ -118,11 +118,11 @@ func (f *FilesystemOptions) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &f.LowerRoots) } -func (f *filesystem) StateTypeName() string { +func (fs *filesystem) StateTypeName() string { return "pkg/sentry/fsimpl/overlay.filesystem" } -func (f *filesystem) StateFields() []string { +func (fs *filesystem) StateFields() []string { return []string{ "vfsfs", "opts", @@ -133,27 +133,27 @@ func (f *filesystem) StateFields() []string { } } -func (f *filesystem) beforeSave() {} +func (fs *filesystem) beforeSave() {} -func (f *filesystem) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.vfsfs) - stateSinkObject.Save(1, &f.opts) - stateSinkObject.Save(2, &f.creds) - stateSinkObject.Save(3, &f.dirDevMinor) - stateSinkObject.Save(4, &f.lowerDevMinors) - stateSinkObject.Save(5, &f.lastDirIno) +func (fs *filesystem) StateSave(stateSinkObject state.Sink) { + fs.beforeSave() + stateSinkObject.Save(0, &fs.vfsfs) + stateSinkObject.Save(1, &fs.opts) + stateSinkObject.Save(2, &fs.creds) + stateSinkObject.Save(3, &fs.dirDevMinor) + stateSinkObject.Save(4, &fs.lowerDevMinors) + stateSinkObject.Save(5, &fs.lastDirIno) } -func (f *filesystem) afterLoad() {} +func (fs *filesystem) afterLoad() {} -func (f *filesystem) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.vfsfs) - stateSourceObject.Load(1, &f.opts) - stateSourceObject.Load(2, &f.creds) - stateSourceObject.Load(3, &f.dirDevMinor) - stateSourceObject.Load(4, &f.lowerDevMinors) - stateSourceObject.Load(5, &f.lastDirIno) +func (fs *filesystem) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fs.vfsfs) + stateSourceObject.Load(1, &fs.opts) + stateSourceObject.Load(2, &fs.creds) + stateSourceObject.Load(3, &fs.dirDevMinor) + stateSourceObject.Load(4, &fs.lowerDevMinors) + stateSourceObject.Load(5, &fs.lastDirIno) } func (d *dentry) StateTypeName() string { @@ -248,11 +248,11 @@ func (d *dentry) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(23, &d.watches) } -func (f *fileDescription) StateTypeName() string { +func (fd *fileDescription) StateTypeName() string { return "pkg/sentry/fsimpl/overlay.fileDescription" } -func (f *fileDescription) StateFields() []string { +func (fd *fileDescription) StateFields() []string { return []string{ "vfsfd", "FileDescriptionDefaultImpl", @@ -260,21 +260,21 @@ func (f *fileDescription) StateFields() []string { } } -func (f *fileDescription) beforeSave() {} +func (fd *fileDescription) beforeSave() {} -func (f *fileDescription) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.vfsfd) - stateSinkObject.Save(1, &f.FileDescriptionDefaultImpl) - stateSinkObject.Save(2, &f.LockFD) +func (fd *fileDescription) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.vfsfd) + stateSinkObject.Save(1, &fd.FileDescriptionDefaultImpl) + stateSinkObject.Save(2, &fd.LockFD) } -func (f *fileDescription) afterLoad() {} +func (fd *fileDescription) afterLoad() {} -func (f *fileDescription) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.vfsfd) - stateSourceObject.Load(1, &f.FileDescriptionDefaultImpl) - stateSourceObject.Load(2, &f.LockFD) +func (fd *fileDescription) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.vfsfd) + stateSourceObject.Load(1, &fd.FileDescriptionDefaultImpl) + stateSourceObject.Load(2, &fd.LockFD) } func init() { diff --git a/pkg/sentry/fsimpl/pipefs/pipefs_state_autogen.go b/pkg/sentry/fsimpl/pipefs/pipefs_state_autogen.go index 384af5bf0..474f83cdf 100644 --- a/pkg/sentry/fsimpl/pipefs/pipefs_state_autogen.go +++ b/pkg/sentry/fsimpl/pipefs/pipefs_state_autogen.go @@ -25,30 +25,30 @@ func (f *filesystemType) afterLoad() {} func (f *filesystemType) StateLoad(stateSourceObject state.Source) { } -func (f *filesystem) StateTypeName() string { +func (fs *filesystem) StateTypeName() string { return "pkg/sentry/fsimpl/pipefs.filesystem" } -func (f *filesystem) StateFields() []string { +func (fs *filesystem) StateFields() []string { return []string{ "Filesystem", "devMinor", } } -func (f *filesystem) beforeSave() {} +func (fs *filesystem) beforeSave() {} -func (f *filesystem) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.Filesystem) - stateSinkObject.Save(1, &f.devMinor) +func (fs *filesystem) StateSave(stateSinkObject state.Sink) { + fs.beforeSave() + stateSinkObject.Save(0, &fs.Filesystem) + stateSinkObject.Save(1, &fs.devMinor) } -func (f *filesystem) afterLoad() {} +func (fs *filesystem) afterLoad() {} -func (f *filesystem) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.Filesystem) - stateSourceObject.Load(1, &f.devMinor) +func (fs *filesystem) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fs.Filesystem) + stateSourceObject.Load(1, &fs.devMinor) } func (i *inode) StateTypeName() string { diff --git a/pkg/sentry/fsimpl/proc/proc_state_autogen.go b/pkg/sentry/fsimpl/proc/proc_state_autogen.go index 72fc112e2..0bbbd5761 100644 --- a/pkg/sentry/fsimpl/proc/proc_state_autogen.go +++ b/pkg/sentry/fsimpl/proc/proc_state_autogen.go @@ -6,95 +6,95 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (f *fdDirInodeRefs) StateTypeName() string { +func (r *fdDirInodeRefs) StateTypeName() string { return "pkg/sentry/fsimpl/proc.fdDirInodeRefs" } -func (f *fdDirInodeRefs) StateFields() []string { +func (r *fdDirInodeRefs) StateFields() []string { return []string{ "refCount", } } -func (f *fdDirInodeRefs) beforeSave() {} +func (r *fdDirInodeRefs) beforeSave() {} -func (f *fdDirInodeRefs) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.refCount) +func (r *fdDirInodeRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (f *fdDirInodeRefs) afterLoad() {} +func (r *fdDirInodeRefs) afterLoad() {} -func (f *fdDirInodeRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.refCount) +func (r *fdDirInodeRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } -func (f *fdInfoDirInodeRefs) StateTypeName() string { +func (r *fdInfoDirInodeRefs) StateTypeName() string { return "pkg/sentry/fsimpl/proc.fdInfoDirInodeRefs" } -func (f *fdInfoDirInodeRefs) StateFields() []string { +func (r *fdInfoDirInodeRefs) StateFields() []string { return []string{ "refCount", } } -func (f *fdInfoDirInodeRefs) beforeSave() {} +func (r *fdInfoDirInodeRefs) beforeSave() {} -func (f *fdInfoDirInodeRefs) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.refCount) +func (r *fdInfoDirInodeRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (f *fdInfoDirInodeRefs) afterLoad() {} +func (r *fdInfoDirInodeRefs) afterLoad() {} -func (f *fdInfoDirInodeRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.refCount) +func (r *fdInfoDirInodeRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } -func (f *FilesystemType) StateTypeName() string { +func (ft *FilesystemType) StateTypeName() string { return "pkg/sentry/fsimpl/proc.FilesystemType" } -func (f *FilesystemType) StateFields() []string { +func (ft *FilesystemType) StateFields() []string { return []string{} } -func (f *FilesystemType) beforeSave() {} +func (ft *FilesystemType) beforeSave() {} -func (f *FilesystemType) StateSave(stateSinkObject state.Sink) { - f.beforeSave() +func (ft *FilesystemType) StateSave(stateSinkObject state.Sink) { + ft.beforeSave() } -func (f *FilesystemType) afterLoad() {} +func (ft *FilesystemType) afterLoad() {} -func (f *FilesystemType) StateLoad(stateSourceObject state.Source) { +func (ft *FilesystemType) StateLoad(stateSourceObject state.Source) { } -func (f *filesystem) StateTypeName() string { +func (fs *filesystem) StateTypeName() string { return "pkg/sentry/fsimpl/proc.filesystem" } -func (f *filesystem) StateFields() []string { +func (fs *filesystem) StateFields() []string { return []string{ "Filesystem", "devMinor", } } -func (f *filesystem) beforeSave() {} +func (fs *filesystem) beforeSave() {} -func (f *filesystem) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.Filesystem) - stateSinkObject.Save(1, &f.devMinor) +func (fs *filesystem) StateSave(stateSinkObject state.Sink) { + fs.beforeSave() + stateSinkObject.Save(0, &fs.Filesystem) + stateSinkObject.Save(1, &fs.devMinor) } -func (f *filesystem) afterLoad() {} +func (fs *filesystem) afterLoad() {} -func (f *filesystem) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.Filesystem) - stateSourceObject.Load(1, &f.devMinor) +func (fs *filesystem) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fs.Filesystem) + stateSourceObject.Load(1, &fs.devMinor) } func (s *staticFile) StateTypeName() string { @@ -165,11 +165,11 @@ func (i *implStatFS) afterLoad() {} func (i *implStatFS) StateLoad(stateSourceObject state.Source) { } -func (s *subtasksInode) StateTypeName() string { +func (i *subtasksInode) StateTypeName() string { return "pkg/sentry/fsimpl/proc.subtasksInode" } -func (s *subtasksInode) StateFields() []string { +func (i *subtasksInode) StateFields() []string { return []string{ "implStatFS", "AlwaysValid", @@ -186,95 +186,95 @@ func (s *subtasksInode) StateFields() []string { } } -func (s *subtasksInode) beforeSave() {} +func (i *subtasksInode) beforeSave() {} -func (s *subtasksInode) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.implStatFS) - stateSinkObject.Save(1, &s.AlwaysValid) - stateSinkObject.Save(2, &s.InodeAttrs) - stateSinkObject.Save(3, &s.InodeDirectoryNoNewChildren) - stateSinkObject.Save(4, &s.InodeNotSymlink) - stateSinkObject.Save(5, &s.OrderedChildren) - stateSinkObject.Save(6, &s.subtasksInodeRefs) - stateSinkObject.Save(7, &s.locks) - stateSinkObject.Save(8, &s.fs) - stateSinkObject.Save(9, &s.task) - stateSinkObject.Save(10, &s.pidns) - stateSinkObject.Save(11, &s.cgroupControllers) -} - -func (s *subtasksInode) afterLoad() {} - -func (s *subtasksInode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.implStatFS) - stateSourceObject.Load(1, &s.AlwaysValid) - stateSourceObject.Load(2, &s.InodeAttrs) - stateSourceObject.Load(3, &s.InodeDirectoryNoNewChildren) - stateSourceObject.Load(4, &s.InodeNotSymlink) - stateSourceObject.Load(5, &s.OrderedChildren) - stateSourceObject.Load(6, &s.subtasksInodeRefs) - stateSourceObject.Load(7, &s.locks) - stateSourceObject.Load(8, &s.fs) - stateSourceObject.Load(9, &s.task) - stateSourceObject.Load(10, &s.pidns) - stateSourceObject.Load(11, &s.cgroupControllers) -} - -func (s *subtasksFD) StateTypeName() string { +func (i *subtasksInode) StateSave(stateSinkObject state.Sink) { + i.beforeSave() + stateSinkObject.Save(0, &i.implStatFS) + stateSinkObject.Save(1, &i.AlwaysValid) + stateSinkObject.Save(2, &i.InodeAttrs) + stateSinkObject.Save(3, &i.InodeDirectoryNoNewChildren) + stateSinkObject.Save(4, &i.InodeNotSymlink) + stateSinkObject.Save(5, &i.OrderedChildren) + stateSinkObject.Save(6, &i.subtasksInodeRefs) + stateSinkObject.Save(7, &i.locks) + stateSinkObject.Save(8, &i.fs) + stateSinkObject.Save(9, &i.task) + stateSinkObject.Save(10, &i.pidns) + stateSinkObject.Save(11, &i.cgroupControllers) +} + +func (i *subtasksInode) afterLoad() {} + +func (i *subtasksInode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &i.implStatFS) + stateSourceObject.Load(1, &i.AlwaysValid) + stateSourceObject.Load(2, &i.InodeAttrs) + stateSourceObject.Load(3, &i.InodeDirectoryNoNewChildren) + stateSourceObject.Load(4, &i.InodeNotSymlink) + stateSourceObject.Load(5, &i.OrderedChildren) + stateSourceObject.Load(6, &i.subtasksInodeRefs) + stateSourceObject.Load(7, &i.locks) + stateSourceObject.Load(8, &i.fs) + stateSourceObject.Load(9, &i.task) + stateSourceObject.Load(10, &i.pidns) + stateSourceObject.Load(11, &i.cgroupControllers) +} + +func (fd *subtasksFD) StateTypeName() string { return "pkg/sentry/fsimpl/proc.subtasksFD" } -func (s *subtasksFD) StateFields() []string { +func (fd *subtasksFD) StateFields() []string { return []string{ "GenericDirectoryFD", "task", } } -func (s *subtasksFD) beforeSave() {} +func (fd *subtasksFD) beforeSave() {} -func (s *subtasksFD) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.GenericDirectoryFD) - stateSinkObject.Save(1, &s.task) +func (fd *subtasksFD) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.GenericDirectoryFD) + stateSinkObject.Save(1, &fd.task) } -func (s *subtasksFD) afterLoad() {} +func (fd *subtasksFD) afterLoad() {} -func (s *subtasksFD) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.GenericDirectoryFD) - stateSourceObject.Load(1, &s.task) +func (fd *subtasksFD) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.GenericDirectoryFD) + stateSourceObject.Load(1, &fd.task) } -func (s *subtasksInodeRefs) StateTypeName() string { +func (r *subtasksInodeRefs) StateTypeName() string { return "pkg/sentry/fsimpl/proc.subtasksInodeRefs" } -func (s *subtasksInodeRefs) StateFields() []string { +func (r *subtasksInodeRefs) StateFields() []string { return []string{ "refCount", } } -func (s *subtasksInodeRefs) beforeSave() {} +func (r *subtasksInodeRefs) beforeSave() {} -func (s *subtasksInodeRefs) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.refCount) +func (r *subtasksInodeRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (s *subtasksInodeRefs) afterLoad() {} +func (r *subtasksInodeRefs) afterLoad() {} -func (s *subtasksInodeRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.refCount) +func (r *subtasksInodeRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } -func (t *taskInode) StateTypeName() string { +func (i *taskInode) StateTypeName() string { return "pkg/sentry/fsimpl/proc.taskInode" } -func (t *taskInode) StateFields() []string { +func (i *taskInode) StateFields() []string { return []string{ "implStatFS", "InodeAttrs", @@ -288,66 +288,66 @@ func (t *taskInode) StateFields() []string { } } -func (t *taskInode) beforeSave() {} - -func (t *taskInode) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.implStatFS) - stateSinkObject.Save(1, &t.InodeAttrs) - stateSinkObject.Save(2, &t.InodeDirectoryNoNewChildren) - stateSinkObject.Save(3, &t.InodeNoDynamicLookup) - stateSinkObject.Save(4, &t.InodeNotSymlink) - stateSinkObject.Save(5, &t.OrderedChildren) - stateSinkObject.Save(6, &t.taskInodeRefs) - stateSinkObject.Save(7, &t.locks) - stateSinkObject.Save(8, &t.task) -} - -func (t *taskInode) afterLoad() {} - -func (t *taskInode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.implStatFS) - stateSourceObject.Load(1, &t.InodeAttrs) - stateSourceObject.Load(2, &t.InodeDirectoryNoNewChildren) - stateSourceObject.Load(3, &t.InodeNoDynamicLookup) - stateSourceObject.Load(4, &t.InodeNotSymlink) - stateSourceObject.Load(5, &t.OrderedChildren) - stateSourceObject.Load(6, &t.taskInodeRefs) - stateSourceObject.Load(7, &t.locks) - stateSourceObject.Load(8, &t.task) -} +func (i *taskInode) beforeSave() {} -func (t *taskOwnedInode) StateTypeName() string { +func (i *taskInode) StateSave(stateSinkObject state.Sink) { + i.beforeSave() + stateSinkObject.Save(0, &i.implStatFS) + stateSinkObject.Save(1, &i.InodeAttrs) + stateSinkObject.Save(2, &i.InodeDirectoryNoNewChildren) + stateSinkObject.Save(3, &i.InodeNoDynamicLookup) + stateSinkObject.Save(4, &i.InodeNotSymlink) + stateSinkObject.Save(5, &i.OrderedChildren) + stateSinkObject.Save(6, &i.taskInodeRefs) + stateSinkObject.Save(7, &i.locks) + stateSinkObject.Save(8, &i.task) +} + +func (i *taskInode) afterLoad() {} + +func (i *taskInode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &i.implStatFS) + stateSourceObject.Load(1, &i.InodeAttrs) + stateSourceObject.Load(2, &i.InodeDirectoryNoNewChildren) + stateSourceObject.Load(3, &i.InodeNoDynamicLookup) + stateSourceObject.Load(4, &i.InodeNotSymlink) + stateSourceObject.Load(5, &i.OrderedChildren) + stateSourceObject.Load(6, &i.taskInodeRefs) + stateSourceObject.Load(7, &i.locks) + stateSourceObject.Load(8, &i.task) +} + +func (i *taskOwnedInode) StateTypeName() string { return "pkg/sentry/fsimpl/proc.taskOwnedInode" } -func (t *taskOwnedInode) StateFields() []string { +func (i *taskOwnedInode) StateFields() []string { return []string{ "Inode", "owner", } } -func (t *taskOwnedInode) beforeSave() {} +func (i *taskOwnedInode) beforeSave() {} -func (t *taskOwnedInode) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.Inode) - stateSinkObject.Save(1, &t.owner) +func (i *taskOwnedInode) StateSave(stateSinkObject state.Sink) { + i.beforeSave() + stateSinkObject.Save(0, &i.Inode) + stateSinkObject.Save(1, &i.owner) } -func (t *taskOwnedInode) afterLoad() {} +func (i *taskOwnedInode) afterLoad() {} -func (t *taskOwnedInode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.Inode) - stateSourceObject.Load(1, &t.owner) +func (i *taskOwnedInode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &i.Inode) + stateSourceObject.Load(1, &i.owner) } -func (f *fdDir) StateTypeName() string { +func (i *fdDir) StateTypeName() string { return "pkg/sentry/fsimpl/proc.fdDir" } -func (f *fdDir) StateFields() []string { +func (i *fdDir) StateFields() []string { return []string{ "locks", "fs", @@ -356,30 +356,30 @@ func (f *fdDir) StateFields() []string { } } -func (f *fdDir) beforeSave() {} +func (i *fdDir) beforeSave() {} -func (f *fdDir) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.locks) - stateSinkObject.Save(1, &f.fs) - stateSinkObject.Save(2, &f.task) - stateSinkObject.Save(3, &f.produceSymlink) +func (i *fdDir) StateSave(stateSinkObject state.Sink) { + i.beforeSave() + stateSinkObject.Save(0, &i.locks) + stateSinkObject.Save(1, &i.fs) + stateSinkObject.Save(2, &i.task) + stateSinkObject.Save(3, &i.produceSymlink) } -func (f *fdDir) afterLoad() {} +func (i *fdDir) afterLoad() {} -func (f *fdDir) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.locks) - stateSourceObject.Load(1, &f.fs) - stateSourceObject.Load(2, &f.task) - stateSourceObject.Load(3, &f.produceSymlink) +func (i *fdDir) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &i.locks) + stateSourceObject.Load(1, &i.fs) + stateSourceObject.Load(2, &i.task) + stateSourceObject.Load(3, &i.produceSymlink) } -func (f *fdDirInode) StateTypeName() string { +func (i *fdDirInode) StateTypeName() string { return "pkg/sentry/fsimpl/proc.fdDirInode" } -func (f *fdDirInode) StateFields() []string { +func (i *fdDirInode) StateFields() []string { return []string{ "fdDir", "fdDirInodeRefs", @@ -392,38 +392,38 @@ func (f *fdDirInode) StateFields() []string { } } -func (f *fdDirInode) beforeSave() {} +func (i *fdDirInode) beforeSave() {} -func (f *fdDirInode) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.fdDir) - stateSinkObject.Save(1, &f.fdDirInodeRefs) - stateSinkObject.Save(2, &f.implStatFS) - stateSinkObject.Save(3, &f.AlwaysValid) - stateSinkObject.Save(4, &f.InodeAttrs) - stateSinkObject.Save(5, &f.InodeDirectoryNoNewChildren) - stateSinkObject.Save(6, &f.InodeNotSymlink) - stateSinkObject.Save(7, &f.OrderedChildren) -} - -func (f *fdDirInode) afterLoad() {} - -func (f *fdDirInode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.fdDir) - stateSourceObject.Load(1, &f.fdDirInodeRefs) - stateSourceObject.Load(2, &f.implStatFS) - stateSourceObject.Load(3, &f.AlwaysValid) - stateSourceObject.Load(4, &f.InodeAttrs) - stateSourceObject.Load(5, &f.InodeDirectoryNoNewChildren) - stateSourceObject.Load(6, &f.InodeNotSymlink) - stateSourceObject.Load(7, &f.OrderedChildren) -} - -func (f *fdSymlink) StateTypeName() string { +func (i *fdDirInode) StateSave(stateSinkObject state.Sink) { + i.beforeSave() + stateSinkObject.Save(0, &i.fdDir) + stateSinkObject.Save(1, &i.fdDirInodeRefs) + stateSinkObject.Save(2, &i.implStatFS) + stateSinkObject.Save(3, &i.AlwaysValid) + stateSinkObject.Save(4, &i.InodeAttrs) + stateSinkObject.Save(5, &i.InodeDirectoryNoNewChildren) + stateSinkObject.Save(6, &i.InodeNotSymlink) + stateSinkObject.Save(7, &i.OrderedChildren) +} + +func (i *fdDirInode) afterLoad() {} + +func (i *fdDirInode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &i.fdDir) + stateSourceObject.Load(1, &i.fdDirInodeRefs) + stateSourceObject.Load(2, &i.implStatFS) + stateSourceObject.Load(3, &i.AlwaysValid) + stateSourceObject.Load(4, &i.InodeAttrs) + stateSourceObject.Load(5, &i.InodeDirectoryNoNewChildren) + stateSourceObject.Load(6, &i.InodeNotSymlink) + stateSourceObject.Load(7, &i.OrderedChildren) +} + +func (s *fdSymlink) StateTypeName() string { return "pkg/sentry/fsimpl/proc.fdSymlink" } -func (f *fdSymlink) StateFields() []string { +func (s *fdSymlink) StateFields() []string { return []string{ "implStatFS", "InodeAttrs", @@ -434,34 +434,34 @@ func (f *fdSymlink) StateFields() []string { } } -func (f *fdSymlink) beforeSave() {} +func (s *fdSymlink) beforeSave() {} -func (f *fdSymlink) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.implStatFS) - stateSinkObject.Save(1, &f.InodeAttrs) - stateSinkObject.Save(2, &f.InodeNoopRefCount) - stateSinkObject.Save(3, &f.InodeSymlink) - stateSinkObject.Save(4, &f.task) - stateSinkObject.Save(5, &f.fd) +func (s *fdSymlink) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + stateSinkObject.Save(0, &s.implStatFS) + stateSinkObject.Save(1, &s.InodeAttrs) + stateSinkObject.Save(2, &s.InodeNoopRefCount) + stateSinkObject.Save(3, &s.InodeSymlink) + stateSinkObject.Save(4, &s.task) + stateSinkObject.Save(5, &s.fd) } -func (f *fdSymlink) afterLoad() {} +func (s *fdSymlink) afterLoad() {} -func (f *fdSymlink) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.implStatFS) - stateSourceObject.Load(1, &f.InodeAttrs) - stateSourceObject.Load(2, &f.InodeNoopRefCount) - stateSourceObject.Load(3, &f.InodeSymlink) - stateSourceObject.Load(4, &f.task) - stateSourceObject.Load(5, &f.fd) +func (s *fdSymlink) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &s.implStatFS) + stateSourceObject.Load(1, &s.InodeAttrs) + stateSourceObject.Load(2, &s.InodeNoopRefCount) + stateSourceObject.Load(3, &s.InodeSymlink) + stateSourceObject.Load(4, &s.task) + stateSourceObject.Load(5, &s.fd) } -func (f *fdInfoDirInode) StateTypeName() string { +func (i *fdInfoDirInode) StateTypeName() string { return "pkg/sentry/fsimpl/proc.fdInfoDirInode" } -func (f *fdInfoDirInode) StateFields() []string { +func (i *fdInfoDirInode) StateFields() []string { return []string{ "fdDir", "fdInfoDirInodeRefs", @@ -474,38 +474,38 @@ func (f *fdInfoDirInode) StateFields() []string { } } -func (f *fdInfoDirInode) beforeSave() {} - -func (f *fdInfoDirInode) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.fdDir) - stateSinkObject.Save(1, &f.fdInfoDirInodeRefs) - stateSinkObject.Save(2, &f.implStatFS) - stateSinkObject.Save(3, &f.AlwaysValid) - stateSinkObject.Save(4, &f.InodeAttrs) - stateSinkObject.Save(5, &f.InodeDirectoryNoNewChildren) - stateSinkObject.Save(6, &f.InodeNotSymlink) - stateSinkObject.Save(7, &f.OrderedChildren) -} +func (i *fdInfoDirInode) beforeSave() {} -func (f *fdInfoDirInode) afterLoad() {} - -func (f *fdInfoDirInode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.fdDir) - stateSourceObject.Load(1, &f.fdInfoDirInodeRefs) - stateSourceObject.Load(2, &f.implStatFS) - stateSourceObject.Load(3, &f.AlwaysValid) - stateSourceObject.Load(4, &f.InodeAttrs) - stateSourceObject.Load(5, &f.InodeDirectoryNoNewChildren) - stateSourceObject.Load(6, &f.InodeNotSymlink) - stateSourceObject.Load(7, &f.OrderedChildren) -} - -func (f *fdInfoData) StateTypeName() string { +func (i *fdInfoDirInode) StateSave(stateSinkObject state.Sink) { + i.beforeSave() + stateSinkObject.Save(0, &i.fdDir) + stateSinkObject.Save(1, &i.fdInfoDirInodeRefs) + stateSinkObject.Save(2, &i.implStatFS) + stateSinkObject.Save(3, &i.AlwaysValid) + stateSinkObject.Save(4, &i.InodeAttrs) + stateSinkObject.Save(5, &i.InodeDirectoryNoNewChildren) + stateSinkObject.Save(6, &i.InodeNotSymlink) + stateSinkObject.Save(7, &i.OrderedChildren) +} + +func (i *fdInfoDirInode) afterLoad() {} + +func (i *fdInfoDirInode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &i.fdDir) + stateSourceObject.Load(1, &i.fdInfoDirInodeRefs) + stateSourceObject.Load(2, &i.implStatFS) + stateSourceObject.Load(3, &i.AlwaysValid) + stateSourceObject.Load(4, &i.InodeAttrs) + stateSourceObject.Load(5, &i.InodeDirectoryNoNewChildren) + stateSourceObject.Load(6, &i.InodeNotSymlink) + stateSourceObject.Load(7, &i.OrderedChildren) +} + +func (d *fdInfoData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.fdInfoData" } -func (f *fdInfoData) StateFields() []string { +func (d *fdInfoData) StateFields() []string { return []string{ "DynamicBytesFile", "task", @@ -513,54 +513,54 @@ func (f *fdInfoData) StateFields() []string { } } -func (f *fdInfoData) beforeSave() {} +func (d *fdInfoData) beforeSave() {} -func (f *fdInfoData) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.DynamicBytesFile) - stateSinkObject.Save(1, &f.task) - stateSinkObject.Save(2, &f.fd) +func (d *fdInfoData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.DynamicBytesFile) + stateSinkObject.Save(1, &d.task) + stateSinkObject.Save(2, &d.fd) } -func (f *fdInfoData) afterLoad() {} +func (d *fdInfoData) afterLoad() {} -func (f *fdInfoData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.DynamicBytesFile) - stateSourceObject.Load(1, &f.task) - stateSourceObject.Load(2, &f.fd) +func (d *fdInfoData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.DynamicBytesFile) + stateSourceObject.Load(1, &d.task) + stateSourceObject.Load(2, &d.fd) } -func (a *auxvData) StateTypeName() string { +func (d *auxvData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.auxvData" } -func (a *auxvData) StateFields() []string { +func (d *auxvData) StateFields() []string { return []string{ "DynamicBytesFile", "task", } } -func (a *auxvData) beforeSave() {} +func (d *auxvData) beforeSave() {} -func (a *auxvData) StateSave(stateSinkObject state.Sink) { - a.beforeSave() - stateSinkObject.Save(0, &a.DynamicBytesFile) - stateSinkObject.Save(1, &a.task) +func (d *auxvData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.DynamicBytesFile) + stateSinkObject.Save(1, &d.task) } -func (a *auxvData) afterLoad() {} +func (d *auxvData) afterLoad() {} -func (a *auxvData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &a.DynamicBytesFile) - stateSourceObject.Load(1, &a.task) +func (d *auxvData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.DynamicBytesFile) + stateSourceObject.Load(1, &d.task) } -func (c *cmdlineData) StateTypeName() string { +func (d *cmdlineData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.cmdlineData" } -func (c *cmdlineData) StateFields() []string { +func (d *cmdlineData) StateFields() []string { return []string{ "DynamicBytesFile", "task", @@ -568,80 +568,80 @@ func (c *cmdlineData) StateFields() []string { } } -func (c *cmdlineData) beforeSave() {} +func (d *cmdlineData) beforeSave() {} -func (c *cmdlineData) StateSave(stateSinkObject state.Sink) { - c.beforeSave() - stateSinkObject.Save(0, &c.DynamicBytesFile) - stateSinkObject.Save(1, &c.task) - stateSinkObject.Save(2, &c.arg) +func (d *cmdlineData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.DynamicBytesFile) + stateSinkObject.Save(1, &d.task) + stateSinkObject.Save(2, &d.arg) } -func (c *cmdlineData) afterLoad() {} +func (d *cmdlineData) afterLoad() {} -func (c *cmdlineData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &c.DynamicBytesFile) - stateSourceObject.Load(1, &c.task) - stateSourceObject.Load(2, &c.arg) +func (d *cmdlineData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.DynamicBytesFile) + stateSourceObject.Load(1, &d.task) + stateSourceObject.Load(2, &d.arg) } -func (c *commInode) StateTypeName() string { +func (i *commInode) StateTypeName() string { return "pkg/sentry/fsimpl/proc.commInode" } -func (c *commInode) StateFields() []string { +func (i *commInode) StateFields() []string { return []string{ "DynamicBytesFile", "task", } } -func (c *commInode) beforeSave() {} +func (i *commInode) beforeSave() {} -func (c *commInode) StateSave(stateSinkObject state.Sink) { - c.beforeSave() - stateSinkObject.Save(0, &c.DynamicBytesFile) - stateSinkObject.Save(1, &c.task) +func (i *commInode) StateSave(stateSinkObject state.Sink) { + i.beforeSave() + stateSinkObject.Save(0, &i.DynamicBytesFile) + stateSinkObject.Save(1, &i.task) } -func (c *commInode) afterLoad() {} +func (i *commInode) afterLoad() {} -func (c *commInode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &c.DynamicBytesFile) - stateSourceObject.Load(1, &c.task) +func (i *commInode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &i.DynamicBytesFile) + stateSourceObject.Load(1, &i.task) } -func (c *commData) StateTypeName() string { +func (d *commData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.commData" } -func (c *commData) StateFields() []string { +func (d *commData) StateFields() []string { return []string{ "DynamicBytesFile", "task", } } -func (c *commData) beforeSave() {} +func (d *commData) beforeSave() {} -func (c *commData) StateSave(stateSinkObject state.Sink) { - c.beforeSave() - stateSinkObject.Save(0, &c.DynamicBytesFile) - stateSinkObject.Save(1, &c.task) +func (d *commData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.DynamicBytesFile) + stateSinkObject.Save(1, &d.task) } -func (c *commData) afterLoad() {} +func (d *commData) afterLoad() {} -func (c *commData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &c.DynamicBytesFile) - stateSourceObject.Load(1, &c.task) +func (d *commData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.DynamicBytesFile) + stateSourceObject.Load(1, &d.task) } -func (i *idMapData) StateTypeName() string { +func (d *idMapData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.idMapData" } -func (i *idMapData) StateFields() []string { +func (d *idMapData) StateFields() []string { return []string{ "DynamicBytesFile", "task", @@ -649,80 +649,80 @@ func (i *idMapData) StateFields() []string { } } -func (i *idMapData) beforeSave() {} +func (d *idMapData) beforeSave() {} -func (i *idMapData) StateSave(stateSinkObject state.Sink) { - i.beforeSave() - stateSinkObject.Save(0, &i.DynamicBytesFile) - stateSinkObject.Save(1, &i.task) - stateSinkObject.Save(2, &i.gids) +func (d *idMapData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.DynamicBytesFile) + stateSinkObject.Save(1, &d.task) + stateSinkObject.Save(2, &d.gids) } -func (i *idMapData) afterLoad() {} +func (d *idMapData) afterLoad() {} -func (i *idMapData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &i.DynamicBytesFile) - stateSourceObject.Load(1, &i.task) - stateSourceObject.Load(2, &i.gids) +func (d *idMapData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.DynamicBytesFile) + stateSourceObject.Load(1, &d.task) + stateSourceObject.Load(2, &d.gids) } -func (m *mapsData) StateTypeName() string { +func (d *mapsData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.mapsData" } -func (m *mapsData) StateFields() []string { +func (d *mapsData) StateFields() []string { return []string{ "DynamicBytesFile", "task", } } -func (m *mapsData) beforeSave() {} +func (d *mapsData) beforeSave() {} -func (m *mapsData) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.DynamicBytesFile) - stateSinkObject.Save(1, &m.task) +func (d *mapsData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.DynamicBytesFile) + stateSinkObject.Save(1, &d.task) } -func (m *mapsData) afterLoad() {} +func (d *mapsData) afterLoad() {} -func (m *mapsData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.DynamicBytesFile) - stateSourceObject.Load(1, &m.task) +func (d *mapsData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.DynamicBytesFile) + stateSourceObject.Load(1, &d.task) } -func (s *smapsData) StateTypeName() string { +func (d *smapsData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.smapsData" } -func (s *smapsData) StateFields() []string { +func (d *smapsData) StateFields() []string { return []string{ "DynamicBytesFile", "task", } } -func (s *smapsData) beforeSave() {} +func (d *smapsData) beforeSave() {} -func (s *smapsData) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.DynamicBytesFile) - stateSinkObject.Save(1, &s.task) +func (d *smapsData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.DynamicBytesFile) + stateSinkObject.Save(1, &d.task) } -func (s *smapsData) afterLoad() {} +func (d *smapsData) afterLoad() {} -func (s *smapsData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.DynamicBytesFile) - stateSourceObject.Load(1, &s.task) +func (d *smapsData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.DynamicBytesFile) + stateSourceObject.Load(1, &d.task) } -func (t *taskStatData) StateTypeName() string { +func (s *taskStatData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.taskStatData" } -func (t *taskStatData) StateFields() []string { +func (s *taskStatData) StateFields() []string { return []string{ "DynamicBytesFile", "task", @@ -731,23 +731,23 @@ func (t *taskStatData) StateFields() []string { } } -func (t *taskStatData) beforeSave() {} +func (s *taskStatData) beforeSave() {} -func (t *taskStatData) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.DynamicBytesFile) - stateSinkObject.Save(1, &t.task) - stateSinkObject.Save(2, &t.tgstats) - stateSinkObject.Save(3, &t.pidns) +func (s *taskStatData) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + stateSinkObject.Save(0, &s.DynamicBytesFile) + stateSinkObject.Save(1, &s.task) + stateSinkObject.Save(2, &s.tgstats) + stateSinkObject.Save(3, &s.pidns) } -func (t *taskStatData) afterLoad() {} +func (s *taskStatData) afterLoad() {} -func (t *taskStatData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.DynamicBytesFile) - stateSourceObject.Load(1, &t.task) - stateSourceObject.Load(2, &t.tgstats) - stateSourceObject.Load(3, &t.pidns) +func (s *taskStatData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &s.DynamicBytesFile) + stateSourceObject.Load(1, &s.task) + stateSourceObject.Load(2, &s.tgstats) + stateSourceObject.Load(3, &s.pidns) } func (s *statmData) StateTypeName() string { @@ -857,11 +857,11 @@ func (o *oomScoreAdj) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &o.task) } -func (e *exeSymlink) StateTypeName() string { +func (s *exeSymlink) StateTypeName() string { return "pkg/sentry/fsimpl/proc.exeSymlink" } -func (e *exeSymlink) StateFields() []string { +func (s *exeSymlink) StateFields() []string { return []string{ "implStatFS", "InodeAttrs", @@ -871,32 +871,32 @@ func (e *exeSymlink) StateFields() []string { } } -func (e *exeSymlink) beforeSave() {} +func (s *exeSymlink) beforeSave() {} -func (e *exeSymlink) StateSave(stateSinkObject state.Sink) { - e.beforeSave() - stateSinkObject.Save(0, &e.implStatFS) - stateSinkObject.Save(1, &e.InodeAttrs) - stateSinkObject.Save(2, &e.InodeNoopRefCount) - stateSinkObject.Save(3, &e.InodeSymlink) - stateSinkObject.Save(4, &e.task) +func (s *exeSymlink) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + stateSinkObject.Save(0, &s.implStatFS) + stateSinkObject.Save(1, &s.InodeAttrs) + stateSinkObject.Save(2, &s.InodeNoopRefCount) + stateSinkObject.Save(3, &s.InodeSymlink) + stateSinkObject.Save(4, &s.task) } -func (e *exeSymlink) afterLoad() {} +func (s *exeSymlink) afterLoad() {} -func (e *exeSymlink) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &e.implStatFS) - stateSourceObject.Load(1, &e.InodeAttrs) - stateSourceObject.Load(2, &e.InodeNoopRefCount) - stateSourceObject.Load(3, &e.InodeSymlink) - stateSourceObject.Load(4, &e.task) +func (s *exeSymlink) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &s.implStatFS) + stateSourceObject.Load(1, &s.InodeAttrs) + stateSourceObject.Load(2, &s.InodeNoopRefCount) + stateSourceObject.Load(3, &s.InodeSymlink) + stateSourceObject.Load(4, &s.task) } -func (c *cwdSymlink) StateTypeName() string { +func (s *cwdSymlink) StateTypeName() string { return "pkg/sentry/fsimpl/proc.cwdSymlink" } -func (c *cwdSymlink) StateFields() []string { +func (s *cwdSymlink) StateFields() []string { return []string{ "implStatFS", "InodeAttrs", @@ -906,110 +906,110 @@ func (c *cwdSymlink) StateFields() []string { } } -func (c *cwdSymlink) beforeSave() {} +func (s *cwdSymlink) beforeSave() {} -func (c *cwdSymlink) StateSave(stateSinkObject state.Sink) { - c.beforeSave() - stateSinkObject.Save(0, &c.implStatFS) - stateSinkObject.Save(1, &c.InodeAttrs) - stateSinkObject.Save(2, &c.InodeNoopRefCount) - stateSinkObject.Save(3, &c.InodeSymlink) - stateSinkObject.Save(4, &c.task) +func (s *cwdSymlink) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + stateSinkObject.Save(0, &s.implStatFS) + stateSinkObject.Save(1, &s.InodeAttrs) + stateSinkObject.Save(2, &s.InodeNoopRefCount) + stateSinkObject.Save(3, &s.InodeSymlink) + stateSinkObject.Save(4, &s.task) } -func (c *cwdSymlink) afterLoad() {} +func (s *cwdSymlink) afterLoad() {} -func (c *cwdSymlink) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &c.implStatFS) - stateSourceObject.Load(1, &c.InodeAttrs) - stateSourceObject.Load(2, &c.InodeNoopRefCount) - stateSourceObject.Load(3, &c.InodeSymlink) - stateSourceObject.Load(4, &c.task) +func (s *cwdSymlink) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &s.implStatFS) + stateSourceObject.Load(1, &s.InodeAttrs) + stateSourceObject.Load(2, &s.InodeNoopRefCount) + stateSourceObject.Load(3, &s.InodeSymlink) + stateSourceObject.Load(4, &s.task) } -func (m *mountInfoData) StateTypeName() string { +func (i *mountInfoData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.mountInfoData" } -func (m *mountInfoData) StateFields() []string { +func (i *mountInfoData) StateFields() []string { return []string{ "DynamicBytesFile", "task", } } -func (m *mountInfoData) beforeSave() {} +func (i *mountInfoData) beforeSave() {} -func (m *mountInfoData) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.DynamicBytesFile) - stateSinkObject.Save(1, &m.task) +func (i *mountInfoData) StateSave(stateSinkObject state.Sink) { + i.beforeSave() + stateSinkObject.Save(0, &i.DynamicBytesFile) + stateSinkObject.Save(1, &i.task) } -func (m *mountInfoData) afterLoad() {} +func (i *mountInfoData) afterLoad() {} -func (m *mountInfoData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.DynamicBytesFile) - stateSourceObject.Load(1, &m.task) +func (i *mountInfoData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &i.DynamicBytesFile) + stateSourceObject.Load(1, &i.task) } -func (m *mountsData) StateTypeName() string { +func (i *mountsData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.mountsData" } -func (m *mountsData) StateFields() []string { +func (i *mountsData) StateFields() []string { return []string{ "DynamicBytesFile", "task", } } -func (m *mountsData) beforeSave() {} +func (i *mountsData) beforeSave() {} -func (m *mountsData) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.DynamicBytesFile) - stateSinkObject.Save(1, &m.task) +func (i *mountsData) StateSave(stateSinkObject state.Sink) { + i.beforeSave() + stateSinkObject.Save(0, &i.DynamicBytesFile) + stateSinkObject.Save(1, &i.task) } -func (m *mountsData) afterLoad() {} +func (i *mountsData) afterLoad() {} -func (m *mountsData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.DynamicBytesFile) - stateSourceObject.Load(1, &m.task) +func (i *mountsData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &i.DynamicBytesFile) + stateSourceObject.Load(1, &i.task) } -func (n *namespaceSymlink) StateTypeName() string { +func (s *namespaceSymlink) StateTypeName() string { return "pkg/sentry/fsimpl/proc.namespaceSymlink" } -func (n *namespaceSymlink) StateFields() []string { +func (s *namespaceSymlink) StateFields() []string { return []string{ "StaticSymlink", "task", } } -func (n *namespaceSymlink) beforeSave() {} +func (s *namespaceSymlink) beforeSave() {} -func (n *namespaceSymlink) StateSave(stateSinkObject state.Sink) { - n.beforeSave() - stateSinkObject.Save(0, &n.StaticSymlink) - stateSinkObject.Save(1, &n.task) +func (s *namespaceSymlink) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + stateSinkObject.Save(0, &s.StaticSymlink) + stateSinkObject.Save(1, &s.task) } -func (n *namespaceSymlink) afterLoad() {} +func (s *namespaceSymlink) afterLoad() {} -func (n *namespaceSymlink) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &n.StaticSymlink) - stateSourceObject.Load(1, &n.task) +func (s *namespaceSymlink) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &s.StaticSymlink) + stateSourceObject.Load(1, &s.task) } -func (n *namespaceInode) StateTypeName() string { +func (i *namespaceInode) StateTypeName() string { return "pkg/sentry/fsimpl/proc.namespaceInode" } -func (n *namespaceInode) StateFields() []string { +func (i *namespaceInode) StateFields() []string { return []string{ "implStatFS", "InodeAttrs", @@ -1020,34 +1020,34 @@ func (n *namespaceInode) StateFields() []string { } } -func (n *namespaceInode) beforeSave() {} +func (i *namespaceInode) beforeSave() {} -func (n *namespaceInode) StateSave(stateSinkObject state.Sink) { - n.beforeSave() - stateSinkObject.Save(0, &n.implStatFS) - stateSinkObject.Save(1, &n.InodeAttrs) - stateSinkObject.Save(2, &n.InodeNoopRefCount) - stateSinkObject.Save(3, &n.InodeNotDirectory) - stateSinkObject.Save(4, &n.InodeNotSymlink) - stateSinkObject.Save(5, &n.locks) +func (i *namespaceInode) StateSave(stateSinkObject state.Sink) { + i.beforeSave() + stateSinkObject.Save(0, &i.implStatFS) + stateSinkObject.Save(1, &i.InodeAttrs) + stateSinkObject.Save(2, &i.InodeNoopRefCount) + stateSinkObject.Save(3, &i.InodeNotDirectory) + stateSinkObject.Save(4, &i.InodeNotSymlink) + stateSinkObject.Save(5, &i.locks) } -func (n *namespaceInode) afterLoad() {} +func (i *namespaceInode) afterLoad() {} -func (n *namespaceInode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &n.implStatFS) - stateSourceObject.Load(1, &n.InodeAttrs) - stateSourceObject.Load(2, &n.InodeNoopRefCount) - stateSourceObject.Load(3, &n.InodeNotDirectory) - stateSourceObject.Load(4, &n.InodeNotSymlink) - stateSourceObject.Load(5, &n.locks) +func (i *namespaceInode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &i.implStatFS) + stateSourceObject.Load(1, &i.InodeAttrs) + stateSourceObject.Load(2, &i.InodeNoopRefCount) + stateSourceObject.Load(3, &i.InodeNotDirectory) + stateSourceObject.Load(4, &i.InodeNotSymlink) + stateSourceObject.Load(5, &i.locks) } -func (n *namespaceFD) StateTypeName() string { +func (fd *namespaceFD) StateTypeName() string { return "pkg/sentry/fsimpl/proc.namespaceFD" } -func (n *namespaceFD) StateFields() []string { +func (fd *namespaceFD) StateFields() []string { return []string{ "FileDescriptionDefaultImpl", "LockFD", @@ -1056,72 +1056,72 @@ func (n *namespaceFD) StateFields() []string { } } -func (n *namespaceFD) beforeSave() {} +func (fd *namespaceFD) beforeSave() {} -func (n *namespaceFD) StateSave(stateSinkObject state.Sink) { - n.beforeSave() - stateSinkObject.Save(0, &n.FileDescriptionDefaultImpl) - stateSinkObject.Save(1, &n.LockFD) - stateSinkObject.Save(2, &n.vfsfd) - stateSinkObject.Save(3, &n.inode) +func (fd *namespaceFD) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.FileDescriptionDefaultImpl) + stateSinkObject.Save(1, &fd.LockFD) + stateSinkObject.Save(2, &fd.vfsfd) + stateSinkObject.Save(3, &fd.inode) } -func (n *namespaceFD) afterLoad() {} +func (fd *namespaceFD) afterLoad() {} -func (n *namespaceFD) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &n.FileDescriptionDefaultImpl) - stateSourceObject.Load(1, &n.LockFD) - stateSourceObject.Load(2, &n.vfsfd) - stateSourceObject.Load(3, &n.inode) +func (fd *namespaceFD) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.FileDescriptionDefaultImpl) + stateSourceObject.Load(1, &fd.LockFD) + stateSourceObject.Load(2, &fd.vfsfd) + stateSourceObject.Load(3, &fd.inode) } -func (t *taskInodeRefs) StateTypeName() string { +func (r *taskInodeRefs) StateTypeName() string { return "pkg/sentry/fsimpl/proc.taskInodeRefs" } -func (t *taskInodeRefs) StateFields() []string { +func (r *taskInodeRefs) StateFields() []string { return []string{ "refCount", } } -func (t *taskInodeRefs) beforeSave() {} +func (r *taskInodeRefs) beforeSave() {} -func (t *taskInodeRefs) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.refCount) +func (r *taskInodeRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (t *taskInodeRefs) afterLoad() {} +func (r *taskInodeRefs) afterLoad() {} -func (t *taskInodeRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.refCount) +func (r *taskInodeRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } -func (i *ifinet6) StateTypeName() string { +func (n *ifinet6) StateTypeName() string { return "pkg/sentry/fsimpl/proc.ifinet6" } -func (i *ifinet6) StateFields() []string { +func (n *ifinet6) StateFields() []string { return []string{ "DynamicBytesFile", "stack", } } -func (i *ifinet6) beforeSave() {} +func (n *ifinet6) beforeSave() {} -func (i *ifinet6) StateSave(stateSinkObject state.Sink) { - i.beforeSave() - stateSinkObject.Save(0, &i.DynamicBytesFile) - stateSinkObject.Save(1, &i.stack) +func (n *ifinet6) StateSave(stateSinkObject state.Sink) { + n.beforeSave() + stateSinkObject.Save(0, &n.DynamicBytesFile) + stateSinkObject.Save(1, &n.stack) } -func (i *ifinet6) afterLoad() {} +func (n *ifinet6) afterLoad() {} -func (i *ifinet6) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &i.DynamicBytesFile) - stateSourceObject.Load(1, &i.stack) +func (n *ifinet6) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &n.DynamicBytesFile) + stateSourceObject.Load(1, &n.stack) } func (n *netDevData) StateTypeName() string { @@ -1176,108 +1176,108 @@ func (n *netUnixData) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &n.kernel) } -func (n *netTCPData) StateTypeName() string { +func (d *netTCPData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.netTCPData" } -func (n *netTCPData) StateFields() []string { +func (d *netTCPData) StateFields() []string { return []string{ "DynamicBytesFile", "kernel", } } -func (n *netTCPData) beforeSave() {} +func (d *netTCPData) beforeSave() {} -func (n *netTCPData) StateSave(stateSinkObject state.Sink) { - n.beforeSave() - stateSinkObject.Save(0, &n.DynamicBytesFile) - stateSinkObject.Save(1, &n.kernel) +func (d *netTCPData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.DynamicBytesFile) + stateSinkObject.Save(1, &d.kernel) } -func (n *netTCPData) afterLoad() {} +func (d *netTCPData) afterLoad() {} -func (n *netTCPData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &n.DynamicBytesFile) - stateSourceObject.Load(1, &n.kernel) +func (d *netTCPData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.DynamicBytesFile) + stateSourceObject.Load(1, &d.kernel) } -func (n *netTCP6Data) StateTypeName() string { +func (d *netTCP6Data) StateTypeName() string { return "pkg/sentry/fsimpl/proc.netTCP6Data" } -func (n *netTCP6Data) StateFields() []string { +func (d *netTCP6Data) StateFields() []string { return []string{ "DynamicBytesFile", "kernel", } } -func (n *netTCP6Data) beforeSave() {} +func (d *netTCP6Data) beforeSave() {} -func (n *netTCP6Data) StateSave(stateSinkObject state.Sink) { - n.beforeSave() - stateSinkObject.Save(0, &n.DynamicBytesFile) - stateSinkObject.Save(1, &n.kernel) +func (d *netTCP6Data) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.DynamicBytesFile) + stateSinkObject.Save(1, &d.kernel) } -func (n *netTCP6Data) afterLoad() {} +func (d *netTCP6Data) afterLoad() {} -func (n *netTCP6Data) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &n.DynamicBytesFile) - stateSourceObject.Load(1, &n.kernel) +func (d *netTCP6Data) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.DynamicBytesFile) + stateSourceObject.Load(1, &d.kernel) } -func (n *netUDPData) StateTypeName() string { +func (d *netUDPData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.netUDPData" } -func (n *netUDPData) StateFields() []string { +func (d *netUDPData) StateFields() []string { return []string{ "DynamicBytesFile", "kernel", } } -func (n *netUDPData) beforeSave() {} +func (d *netUDPData) beforeSave() {} -func (n *netUDPData) StateSave(stateSinkObject state.Sink) { - n.beforeSave() - stateSinkObject.Save(0, &n.DynamicBytesFile) - stateSinkObject.Save(1, &n.kernel) +func (d *netUDPData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.DynamicBytesFile) + stateSinkObject.Save(1, &d.kernel) } -func (n *netUDPData) afterLoad() {} +func (d *netUDPData) afterLoad() {} -func (n *netUDPData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &n.DynamicBytesFile) - stateSourceObject.Load(1, &n.kernel) +func (d *netUDPData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.DynamicBytesFile) + stateSourceObject.Load(1, &d.kernel) } -func (n *netSnmpData) StateTypeName() string { +func (d *netSnmpData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.netSnmpData" } -func (n *netSnmpData) StateFields() []string { +func (d *netSnmpData) StateFields() []string { return []string{ "DynamicBytesFile", "stack", } } -func (n *netSnmpData) beforeSave() {} +func (d *netSnmpData) beforeSave() {} -func (n *netSnmpData) StateSave(stateSinkObject state.Sink) { - n.beforeSave() - stateSinkObject.Save(0, &n.DynamicBytesFile) - stateSinkObject.Save(1, &n.stack) +func (d *netSnmpData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.DynamicBytesFile) + stateSinkObject.Save(1, &d.stack) } -func (n *netSnmpData) afterLoad() {} +func (d *netSnmpData) afterLoad() {} -func (n *netSnmpData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &n.DynamicBytesFile) - stateSourceObject.Load(1, &n.stack) +func (d *netSnmpData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.DynamicBytesFile) + stateSourceObject.Load(1, &d.stack) } func (s *snmpLine) StateTypeName() string { @@ -1306,63 +1306,63 @@ func (s *snmpLine) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &s.header) } -func (n *netRouteData) StateTypeName() string { +func (d *netRouteData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.netRouteData" } -func (n *netRouteData) StateFields() []string { +func (d *netRouteData) StateFields() []string { return []string{ "DynamicBytesFile", "stack", } } -func (n *netRouteData) beforeSave() {} +func (d *netRouteData) beforeSave() {} -func (n *netRouteData) StateSave(stateSinkObject state.Sink) { - n.beforeSave() - stateSinkObject.Save(0, &n.DynamicBytesFile) - stateSinkObject.Save(1, &n.stack) +func (d *netRouteData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.DynamicBytesFile) + stateSinkObject.Save(1, &d.stack) } -func (n *netRouteData) afterLoad() {} +func (d *netRouteData) afterLoad() {} -func (n *netRouteData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &n.DynamicBytesFile) - stateSourceObject.Load(1, &n.stack) +func (d *netRouteData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.DynamicBytesFile) + stateSourceObject.Load(1, &d.stack) } -func (n *netStatData) StateTypeName() string { +func (d *netStatData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.netStatData" } -func (n *netStatData) StateFields() []string { +func (d *netStatData) StateFields() []string { return []string{ "DynamicBytesFile", "stack", } } -func (n *netStatData) beforeSave() {} +func (d *netStatData) beforeSave() {} -func (n *netStatData) StateSave(stateSinkObject state.Sink) { - n.beforeSave() - stateSinkObject.Save(0, &n.DynamicBytesFile) - stateSinkObject.Save(1, &n.stack) +func (d *netStatData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.DynamicBytesFile) + stateSinkObject.Save(1, &d.stack) } -func (n *netStatData) afterLoad() {} +func (d *netStatData) afterLoad() {} -func (n *netStatData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &n.DynamicBytesFile) - stateSourceObject.Load(1, &n.stack) +func (d *netStatData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.DynamicBytesFile) + stateSourceObject.Load(1, &d.stack) } -func (t *tasksInode) StateTypeName() string { +func (i *tasksInode) StateTypeName() string { return "pkg/sentry/fsimpl/proc.tasksInode" } -func (t *tasksInode) StateFields() []string { +func (i *tasksInode) StateFields() []string { return []string{ "implStatFS", "AlwaysValid", @@ -1380,41 +1380,41 @@ func (t *tasksInode) StateFields() []string { } } -func (t *tasksInode) beforeSave() {} - -func (t *tasksInode) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.implStatFS) - stateSinkObject.Save(1, &t.AlwaysValid) - stateSinkObject.Save(2, &t.InodeAttrs) - stateSinkObject.Save(3, &t.InodeDirectoryNoNewChildren) - stateSinkObject.Save(4, &t.InodeNotSymlink) - stateSinkObject.Save(5, &t.OrderedChildren) - stateSinkObject.Save(6, &t.tasksInodeRefs) - stateSinkObject.Save(7, &t.locks) - stateSinkObject.Save(8, &t.fs) - stateSinkObject.Save(9, &t.pidns) - stateSinkObject.Save(10, &t.selfSymlink) - stateSinkObject.Save(11, &t.threadSelfSymlink) - stateSinkObject.Save(12, &t.cgroupControllers) -} - -func (t *tasksInode) afterLoad() {} - -func (t *tasksInode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.implStatFS) - stateSourceObject.Load(1, &t.AlwaysValid) - stateSourceObject.Load(2, &t.InodeAttrs) - stateSourceObject.Load(3, &t.InodeDirectoryNoNewChildren) - stateSourceObject.Load(4, &t.InodeNotSymlink) - stateSourceObject.Load(5, &t.OrderedChildren) - stateSourceObject.Load(6, &t.tasksInodeRefs) - stateSourceObject.Load(7, &t.locks) - stateSourceObject.Load(8, &t.fs) - stateSourceObject.Load(9, &t.pidns) - stateSourceObject.Load(10, &t.selfSymlink) - stateSourceObject.Load(11, &t.threadSelfSymlink) - stateSourceObject.Load(12, &t.cgroupControllers) +func (i *tasksInode) beforeSave() {} + +func (i *tasksInode) StateSave(stateSinkObject state.Sink) { + i.beforeSave() + stateSinkObject.Save(0, &i.implStatFS) + stateSinkObject.Save(1, &i.AlwaysValid) + stateSinkObject.Save(2, &i.InodeAttrs) + stateSinkObject.Save(3, &i.InodeDirectoryNoNewChildren) + stateSinkObject.Save(4, &i.InodeNotSymlink) + stateSinkObject.Save(5, &i.OrderedChildren) + stateSinkObject.Save(6, &i.tasksInodeRefs) + stateSinkObject.Save(7, &i.locks) + stateSinkObject.Save(8, &i.fs) + stateSinkObject.Save(9, &i.pidns) + stateSinkObject.Save(10, &i.selfSymlink) + stateSinkObject.Save(11, &i.threadSelfSymlink) + stateSinkObject.Save(12, &i.cgroupControllers) +} + +func (i *tasksInode) afterLoad() {} + +func (i *tasksInode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &i.implStatFS) + stateSourceObject.Load(1, &i.AlwaysValid) + stateSourceObject.Load(2, &i.InodeAttrs) + stateSourceObject.Load(3, &i.InodeDirectoryNoNewChildren) + stateSourceObject.Load(4, &i.InodeNotSymlink) + stateSourceObject.Load(5, &i.OrderedChildren) + stateSourceObject.Load(6, &i.tasksInodeRefs) + stateSourceObject.Load(7, &i.locks) + stateSourceObject.Load(8, &i.fs) + stateSourceObject.Load(9, &i.pidns) + stateSourceObject.Load(10, &i.selfSymlink) + stateSourceObject.Load(11, &i.threadSelfSymlink) + stateSourceObject.Load(12, &i.cgroupControllers) } func (s *staticFileSetStat) StateTypeName() string { @@ -1478,11 +1478,11 @@ func (s *selfSymlink) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(4, &s.pidns) } -func (t *threadSelfSymlink) StateTypeName() string { +func (s *threadSelfSymlink) StateTypeName() string { return "pkg/sentry/fsimpl/proc.threadSelfSymlink" } -func (t *threadSelfSymlink) StateFields() []string { +func (s *threadSelfSymlink) StateFields() []string { return []string{ "implStatFS", "InodeAttrs", @@ -1492,25 +1492,25 @@ func (t *threadSelfSymlink) StateFields() []string { } } -func (t *threadSelfSymlink) beforeSave() {} +func (s *threadSelfSymlink) beforeSave() {} -func (t *threadSelfSymlink) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.implStatFS) - stateSinkObject.Save(1, &t.InodeAttrs) - stateSinkObject.Save(2, &t.InodeNoopRefCount) - stateSinkObject.Save(3, &t.InodeSymlink) - stateSinkObject.Save(4, &t.pidns) +func (s *threadSelfSymlink) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + stateSinkObject.Save(0, &s.implStatFS) + stateSinkObject.Save(1, &s.InodeAttrs) + stateSinkObject.Save(2, &s.InodeNoopRefCount) + stateSinkObject.Save(3, &s.InodeSymlink) + stateSinkObject.Save(4, &s.pidns) } -func (t *threadSelfSymlink) afterLoad() {} +func (s *threadSelfSymlink) afterLoad() {} -func (t *threadSelfSymlink) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.implStatFS) - stateSourceObject.Load(1, &t.InodeAttrs) - stateSourceObject.Load(2, &t.InodeNoopRefCount) - stateSourceObject.Load(3, &t.InodeSymlink) - stateSourceObject.Load(4, &t.pidns) +func (s *threadSelfSymlink) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &s.implStatFS) + stateSourceObject.Load(1, &s.InodeAttrs) + stateSourceObject.Load(2, &s.InodeNoopRefCount) + stateSourceObject.Load(3, &s.InodeSymlink) + stateSourceObject.Load(4, &s.pidns) } func (d *dynamicBytesFileSetAttr) StateTypeName() string { @@ -1701,50 +1701,50 @@ func (v *versionData) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(0, &v.dynamicBytesFileSetAttr) } -func (f *filesystemsData) StateTypeName() string { +func (d *filesystemsData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.filesystemsData" } -func (f *filesystemsData) StateFields() []string { +func (d *filesystemsData) StateFields() []string { return []string{ "DynamicBytesFile", } } -func (f *filesystemsData) beforeSave() {} +func (d *filesystemsData) beforeSave() {} -func (f *filesystemsData) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.DynamicBytesFile) +func (d *filesystemsData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.DynamicBytesFile) } -func (f *filesystemsData) afterLoad() {} +func (d *filesystemsData) afterLoad() {} -func (f *filesystemsData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.DynamicBytesFile) +func (d *filesystemsData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.DynamicBytesFile) } -func (t *tasksInodeRefs) StateTypeName() string { +func (r *tasksInodeRefs) StateTypeName() string { return "pkg/sentry/fsimpl/proc.tasksInodeRefs" } -func (t *tasksInodeRefs) StateFields() []string { +func (r *tasksInodeRefs) StateFields() []string { return []string{ "refCount", } } -func (t *tasksInodeRefs) beforeSave() {} +func (r *tasksInodeRefs) beforeSave() {} -func (t *tasksInodeRefs) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.refCount) +func (r *tasksInodeRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (t *tasksInodeRefs) afterLoad() {} +func (r *tasksInodeRefs) afterLoad() {} -func (t *tasksInodeRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.refCount) +func (r *tasksInodeRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } func (t *tcpMemDir) StateTypeName() string { @@ -1755,30 +1755,30 @@ func (t *tcpMemDir) StateFields() []string { return nil } -func (m *mmapMinAddrData) StateTypeName() string { +func (d *mmapMinAddrData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.mmapMinAddrData" } -func (m *mmapMinAddrData) StateFields() []string { +func (d *mmapMinAddrData) StateFields() []string { return []string{ "DynamicBytesFile", "k", } } -func (m *mmapMinAddrData) beforeSave() {} +func (d *mmapMinAddrData) beforeSave() {} -func (m *mmapMinAddrData) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.DynamicBytesFile) - stateSinkObject.Save(1, &m.k) +func (d *mmapMinAddrData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.DynamicBytesFile) + stateSinkObject.Save(1, &d.k) } -func (m *mmapMinAddrData) afterLoad() {} +func (d *mmapMinAddrData) afterLoad() {} -func (m *mmapMinAddrData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.DynamicBytesFile) - stateSourceObject.Load(1, &m.k) +func (d *mmapMinAddrData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.DynamicBytesFile) + stateSourceObject.Load(1, &d.k) } func (h *hostnameData) StateTypeName() string { @@ -1804,11 +1804,11 @@ func (h *hostnameData) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(0, &h.DynamicBytesFile) } -func (t *tcpSackData) StateTypeName() string { +func (d *tcpSackData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.tcpSackData" } -func (t *tcpSackData) StateFields() []string { +func (d *tcpSackData) StateFields() []string { return []string{ "DynamicBytesFile", "stack", @@ -1816,54 +1816,54 @@ func (t *tcpSackData) StateFields() []string { } } -func (t *tcpSackData) beforeSave() {} +func (d *tcpSackData) beforeSave() {} -func (t *tcpSackData) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.DynamicBytesFile) - stateSinkObject.Save(1, &t.stack) - stateSinkObject.Save(2, &t.enabled) +func (d *tcpSackData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.DynamicBytesFile) + stateSinkObject.Save(1, &d.stack) + stateSinkObject.Save(2, &d.enabled) } -func (t *tcpSackData) afterLoad() {} +func (d *tcpSackData) afterLoad() {} -func (t *tcpSackData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.DynamicBytesFile) - stateSourceObject.LoadWait(1, &t.stack) - stateSourceObject.Load(2, &t.enabled) +func (d *tcpSackData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.DynamicBytesFile) + stateSourceObject.LoadWait(1, &d.stack) + stateSourceObject.Load(2, &d.enabled) } -func (t *tcpRecoveryData) StateTypeName() string { +func (d *tcpRecoveryData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.tcpRecoveryData" } -func (t *tcpRecoveryData) StateFields() []string { +func (d *tcpRecoveryData) StateFields() []string { return []string{ "DynamicBytesFile", "stack", } } -func (t *tcpRecoveryData) beforeSave() {} +func (d *tcpRecoveryData) beforeSave() {} -func (t *tcpRecoveryData) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.DynamicBytesFile) - stateSinkObject.Save(1, &t.stack) +func (d *tcpRecoveryData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.DynamicBytesFile) + stateSinkObject.Save(1, &d.stack) } -func (t *tcpRecoveryData) afterLoad() {} +func (d *tcpRecoveryData) afterLoad() {} -func (t *tcpRecoveryData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.DynamicBytesFile) - stateSourceObject.LoadWait(1, &t.stack) +func (d *tcpRecoveryData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.DynamicBytesFile) + stateSourceObject.LoadWait(1, &d.stack) } -func (t *tcpMemData) StateTypeName() string { +func (d *tcpMemData) StateTypeName() string { return "pkg/sentry/fsimpl/proc.tcpMemData" } -func (t *tcpMemData) StateFields() []string { +func (d *tcpMemData) StateFields() []string { return []string{ "DynamicBytesFile", "dir", @@ -1871,28 +1871,28 @@ func (t *tcpMemData) StateFields() []string { } } -func (t *tcpMemData) beforeSave() {} +func (d *tcpMemData) beforeSave() {} -func (t *tcpMemData) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.DynamicBytesFile) - stateSinkObject.Save(1, &t.dir) - stateSinkObject.Save(2, &t.stack) +func (d *tcpMemData) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.DynamicBytesFile) + stateSinkObject.Save(1, &d.dir) + stateSinkObject.Save(2, &d.stack) } -func (t *tcpMemData) afterLoad() {} +func (d *tcpMemData) afterLoad() {} -func (t *tcpMemData) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.DynamicBytesFile) - stateSourceObject.Load(1, &t.dir) - stateSourceObject.LoadWait(2, &t.stack) +func (d *tcpMemData) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.DynamicBytesFile) + stateSourceObject.Load(1, &d.dir) + stateSourceObject.LoadWait(2, &d.stack) } -func (i *ipForwarding) StateTypeName() string { +func (ipf *ipForwarding) StateTypeName() string { return "pkg/sentry/fsimpl/proc.ipForwarding" } -func (i *ipForwarding) StateFields() []string { +func (ipf *ipForwarding) StateFields() []string { return []string{ "DynamicBytesFile", "stack", @@ -1900,21 +1900,21 @@ func (i *ipForwarding) StateFields() []string { } } -func (i *ipForwarding) beforeSave() {} +func (ipf *ipForwarding) beforeSave() {} -func (i *ipForwarding) StateSave(stateSinkObject state.Sink) { - i.beforeSave() - stateSinkObject.Save(0, &i.DynamicBytesFile) - stateSinkObject.Save(1, &i.stack) - stateSinkObject.Save(2, &i.enabled) +func (ipf *ipForwarding) StateSave(stateSinkObject state.Sink) { + ipf.beforeSave() + stateSinkObject.Save(0, &ipf.DynamicBytesFile) + stateSinkObject.Save(1, &ipf.stack) + stateSinkObject.Save(2, &ipf.enabled) } -func (i *ipForwarding) afterLoad() {} +func (ipf *ipForwarding) afterLoad() {} -func (i *ipForwarding) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &i.DynamicBytesFile) - stateSourceObject.LoadWait(1, &i.stack) - stateSourceObject.Load(2, &i.enabled) +func (ipf *ipForwarding) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &ipf.DynamicBytesFile) + stateSourceObject.LoadWait(1, &ipf.stack) + stateSourceObject.Load(2, &ipf.enabled) } func init() { diff --git a/pkg/sentry/fsimpl/signalfd/signalfd_state_autogen.go b/pkg/sentry/fsimpl/signalfd/signalfd_state_autogen.go index 4a1496528..b3596a886 100644 --- a/pkg/sentry/fsimpl/signalfd/signalfd_state_autogen.go +++ b/pkg/sentry/fsimpl/signalfd/signalfd_state_autogen.go @@ -6,11 +6,11 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (s *SignalFileDescription) StateTypeName() string { +func (sfd *SignalFileDescription) StateTypeName() string { return "pkg/sentry/fsimpl/signalfd.SignalFileDescription" } -func (s *SignalFileDescription) StateFields() []string { +func (sfd *SignalFileDescription) StateFields() []string { return []string{ "vfsfd", "FileDescriptionDefaultImpl", @@ -21,27 +21,27 @@ func (s *SignalFileDescription) StateFields() []string { } } -func (s *SignalFileDescription) beforeSave() {} +func (sfd *SignalFileDescription) beforeSave() {} -func (s *SignalFileDescription) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.vfsfd) - stateSinkObject.Save(1, &s.FileDescriptionDefaultImpl) - stateSinkObject.Save(2, &s.DentryMetadataFileDescriptionImpl) - stateSinkObject.Save(3, &s.NoLockFD) - stateSinkObject.Save(4, &s.target) - stateSinkObject.Save(5, &s.mask) +func (sfd *SignalFileDescription) StateSave(stateSinkObject state.Sink) { + sfd.beforeSave() + stateSinkObject.Save(0, &sfd.vfsfd) + stateSinkObject.Save(1, &sfd.FileDescriptionDefaultImpl) + stateSinkObject.Save(2, &sfd.DentryMetadataFileDescriptionImpl) + stateSinkObject.Save(3, &sfd.NoLockFD) + stateSinkObject.Save(4, &sfd.target) + stateSinkObject.Save(5, &sfd.mask) } -func (s *SignalFileDescription) afterLoad() {} +func (sfd *SignalFileDescription) afterLoad() {} -func (s *SignalFileDescription) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.vfsfd) - stateSourceObject.Load(1, &s.FileDescriptionDefaultImpl) - stateSourceObject.Load(2, &s.DentryMetadataFileDescriptionImpl) - stateSourceObject.Load(3, &s.NoLockFD) - stateSourceObject.Load(4, &s.target) - stateSourceObject.Load(5, &s.mask) +func (sfd *SignalFileDescription) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &sfd.vfsfd) + stateSourceObject.Load(1, &sfd.FileDescriptionDefaultImpl) + stateSourceObject.Load(2, &sfd.DentryMetadataFileDescriptionImpl) + stateSourceObject.Load(3, &sfd.NoLockFD) + stateSourceObject.Load(4, &sfd.target) + stateSourceObject.Load(5, &sfd.mask) } func init() { diff --git a/pkg/sentry/fsimpl/sockfs/sockfs_state_autogen.go b/pkg/sentry/fsimpl/sockfs/sockfs_state_autogen.go index 38bbf9eb5..6a6607555 100644 --- a/pkg/sentry/fsimpl/sockfs/sockfs_state_autogen.go +++ b/pkg/sentry/fsimpl/sockfs/sockfs_state_autogen.go @@ -6,49 +6,49 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (f *filesystemType) StateTypeName() string { +func (fsType *filesystemType) StateTypeName() string { return "pkg/sentry/fsimpl/sockfs.filesystemType" } -func (f *filesystemType) StateFields() []string { +func (fsType *filesystemType) StateFields() []string { return []string{} } -func (f *filesystemType) beforeSave() {} +func (fsType *filesystemType) beforeSave() {} -func (f *filesystemType) StateSave(stateSinkObject state.Sink) { - f.beforeSave() +func (fsType *filesystemType) StateSave(stateSinkObject state.Sink) { + fsType.beforeSave() } -func (f *filesystemType) afterLoad() {} +func (fsType *filesystemType) afterLoad() {} -func (f *filesystemType) StateLoad(stateSourceObject state.Source) { +func (fsType *filesystemType) StateLoad(stateSourceObject state.Source) { } -func (f *filesystem) StateTypeName() string { +func (fs *filesystem) StateTypeName() string { return "pkg/sentry/fsimpl/sockfs.filesystem" } -func (f *filesystem) StateFields() []string { +func (fs *filesystem) StateFields() []string { return []string{ "Filesystem", "devMinor", } } -func (f *filesystem) beforeSave() {} +func (fs *filesystem) beforeSave() {} -func (f *filesystem) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.Filesystem) - stateSinkObject.Save(1, &f.devMinor) +func (fs *filesystem) StateSave(stateSinkObject state.Sink) { + fs.beforeSave() + stateSinkObject.Save(0, &fs.Filesystem) + stateSinkObject.Save(1, &fs.devMinor) } -func (f *filesystem) afterLoad() {} +func (fs *filesystem) afterLoad() {} -func (f *filesystem) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.Filesystem) - stateSourceObject.Load(1, &f.devMinor) +func (fs *filesystem) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fs.Filesystem) + stateSourceObject.Load(1, &fs.devMinor) } func (i *inode) StateTypeName() string { diff --git a/pkg/sentry/fsimpl/sys/sys_state_autogen.go b/pkg/sentry/fsimpl/sys/sys_state_autogen.go index 6ba7397ba..410e5a7d0 100644 --- a/pkg/sentry/fsimpl/sys/sys_state_autogen.go +++ b/pkg/sentry/fsimpl/sys/sys_state_autogen.go @@ -6,34 +6,34 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (d *dirRefs) StateTypeName() string { +func (r *dirRefs) StateTypeName() string { return "pkg/sentry/fsimpl/sys.dirRefs" } -func (d *dirRefs) StateFields() []string { +func (r *dirRefs) StateFields() []string { return []string{ "refCount", } } -func (d *dirRefs) beforeSave() {} +func (r *dirRefs) beforeSave() {} -func (d *dirRefs) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - stateSinkObject.Save(0, &d.refCount) +func (r *dirRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (d *dirRefs) afterLoad() {} +func (r *dirRefs) afterLoad() {} -func (d *dirRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.refCount) +func (r *dirRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } -func (k *kcovInode) StateTypeName() string { +func (i *kcovInode) StateTypeName() string { return "pkg/sentry/fsimpl/sys.kcovInode" } -func (k *kcovInode) StateFields() []string { +func (i *kcovInode) StateFields() []string { return []string{ "InodeAttrs", "InodeNoopRefCount", @@ -43,32 +43,32 @@ func (k *kcovInode) StateFields() []string { } } -func (k *kcovInode) beforeSave() {} +func (i *kcovInode) beforeSave() {} -func (k *kcovInode) StateSave(stateSinkObject state.Sink) { - k.beforeSave() - stateSinkObject.Save(0, &k.InodeAttrs) - stateSinkObject.Save(1, &k.InodeNoopRefCount) - stateSinkObject.Save(2, &k.InodeNotDirectory) - stateSinkObject.Save(3, &k.InodeNotSymlink) - stateSinkObject.Save(4, &k.implStatFS) +func (i *kcovInode) StateSave(stateSinkObject state.Sink) { + i.beforeSave() + stateSinkObject.Save(0, &i.InodeAttrs) + stateSinkObject.Save(1, &i.InodeNoopRefCount) + stateSinkObject.Save(2, &i.InodeNotDirectory) + stateSinkObject.Save(3, &i.InodeNotSymlink) + stateSinkObject.Save(4, &i.implStatFS) } -func (k *kcovInode) afterLoad() {} +func (i *kcovInode) afterLoad() {} -func (k *kcovInode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &k.InodeAttrs) - stateSourceObject.Load(1, &k.InodeNoopRefCount) - stateSourceObject.Load(2, &k.InodeNotDirectory) - stateSourceObject.Load(3, &k.InodeNotSymlink) - stateSourceObject.Load(4, &k.implStatFS) +func (i *kcovInode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &i.InodeAttrs) + stateSourceObject.Load(1, &i.InodeNoopRefCount) + stateSourceObject.Load(2, &i.InodeNotDirectory) + stateSourceObject.Load(3, &i.InodeNotSymlink) + stateSourceObject.Load(4, &i.implStatFS) } -func (k *kcovFD) StateTypeName() string { +func (fd *kcovFD) StateTypeName() string { return "pkg/sentry/fsimpl/sys.kcovFD" } -func (k *kcovFD) StateFields() []string { +func (fd *kcovFD) StateFields() []string { return []string{ "FileDescriptionDefaultImpl", "NoLockFD", @@ -78,70 +78,70 @@ func (k *kcovFD) StateFields() []string { } } -func (k *kcovFD) beforeSave() {} +func (fd *kcovFD) beforeSave() {} -func (k *kcovFD) StateSave(stateSinkObject state.Sink) { - k.beforeSave() - stateSinkObject.Save(0, &k.FileDescriptionDefaultImpl) - stateSinkObject.Save(1, &k.NoLockFD) - stateSinkObject.Save(2, &k.vfsfd) - stateSinkObject.Save(3, &k.inode) - stateSinkObject.Save(4, &k.kcov) +func (fd *kcovFD) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.FileDescriptionDefaultImpl) + stateSinkObject.Save(1, &fd.NoLockFD) + stateSinkObject.Save(2, &fd.vfsfd) + stateSinkObject.Save(3, &fd.inode) + stateSinkObject.Save(4, &fd.kcov) } -func (k *kcovFD) afterLoad() {} +func (fd *kcovFD) afterLoad() {} -func (k *kcovFD) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &k.FileDescriptionDefaultImpl) - stateSourceObject.Load(1, &k.NoLockFD) - stateSourceObject.Load(2, &k.vfsfd) - stateSourceObject.Load(3, &k.inode) - stateSourceObject.Load(4, &k.kcov) +func (fd *kcovFD) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.FileDescriptionDefaultImpl) + stateSourceObject.Load(1, &fd.NoLockFD) + stateSourceObject.Load(2, &fd.vfsfd) + stateSourceObject.Load(3, &fd.inode) + stateSourceObject.Load(4, &fd.kcov) } -func (f *FilesystemType) StateTypeName() string { +func (fsType *FilesystemType) StateTypeName() string { return "pkg/sentry/fsimpl/sys.FilesystemType" } -func (f *FilesystemType) StateFields() []string { +func (fsType *FilesystemType) StateFields() []string { return []string{} } -func (f *FilesystemType) beforeSave() {} +func (fsType *FilesystemType) beforeSave() {} -func (f *FilesystemType) StateSave(stateSinkObject state.Sink) { - f.beforeSave() +func (fsType *FilesystemType) StateSave(stateSinkObject state.Sink) { + fsType.beforeSave() } -func (f *FilesystemType) afterLoad() {} +func (fsType *FilesystemType) afterLoad() {} -func (f *FilesystemType) StateLoad(stateSourceObject state.Source) { +func (fsType *FilesystemType) StateLoad(stateSourceObject state.Source) { } -func (f *filesystem) StateTypeName() string { +func (fs *filesystem) StateTypeName() string { return "pkg/sentry/fsimpl/sys.filesystem" } -func (f *filesystem) StateFields() []string { +func (fs *filesystem) StateFields() []string { return []string{ "Filesystem", "devMinor", } } -func (f *filesystem) beforeSave() {} +func (fs *filesystem) beforeSave() {} -func (f *filesystem) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.Filesystem) - stateSinkObject.Save(1, &f.devMinor) +func (fs *filesystem) StateSave(stateSinkObject state.Sink) { + fs.beforeSave() + stateSinkObject.Save(0, &fs.Filesystem) + stateSinkObject.Save(1, &fs.devMinor) } -func (f *filesystem) afterLoad() {} +func (fs *filesystem) afterLoad() {} -func (f *filesystem) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.Filesystem) - stateSourceObject.Load(1, &f.devMinor) +func (fs *filesystem) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fs.Filesystem) + stateSourceObject.Load(1, &fs.devMinor) } func (d *dir) StateTypeName() string { diff --git a/pkg/sentry/fsimpl/timerfd/timerfd_state_autogen.go b/pkg/sentry/fsimpl/timerfd/timerfd_state_autogen.go index 0bfca83b9..d3c01e9e7 100644 --- a/pkg/sentry/fsimpl/timerfd/timerfd_state_autogen.go +++ b/pkg/sentry/fsimpl/timerfd/timerfd_state_autogen.go @@ -6,11 +6,11 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (t *TimerFileDescription) StateTypeName() string { +func (tfd *TimerFileDescription) StateTypeName() string { return "pkg/sentry/fsimpl/timerfd.TimerFileDescription" } -func (t *TimerFileDescription) StateFields() []string { +func (tfd *TimerFileDescription) StateFields() []string { return []string{ "vfsfd", "FileDescriptionDefaultImpl", @@ -22,29 +22,29 @@ func (t *TimerFileDescription) StateFields() []string { } } -func (t *TimerFileDescription) beforeSave() {} - -func (t *TimerFileDescription) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.vfsfd) - stateSinkObject.Save(1, &t.FileDescriptionDefaultImpl) - stateSinkObject.Save(2, &t.DentryMetadataFileDescriptionImpl) - stateSinkObject.Save(3, &t.NoLockFD) - stateSinkObject.Save(4, &t.events) - stateSinkObject.Save(5, &t.timer) - stateSinkObject.Save(6, &t.val) +func (tfd *TimerFileDescription) beforeSave() {} + +func (tfd *TimerFileDescription) StateSave(stateSinkObject state.Sink) { + tfd.beforeSave() + stateSinkObject.Save(0, &tfd.vfsfd) + stateSinkObject.Save(1, &tfd.FileDescriptionDefaultImpl) + stateSinkObject.Save(2, &tfd.DentryMetadataFileDescriptionImpl) + stateSinkObject.Save(3, &tfd.NoLockFD) + stateSinkObject.Save(4, &tfd.events) + stateSinkObject.Save(5, &tfd.timer) + stateSinkObject.Save(6, &tfd.val) } -func (t *TimerFileDescription) afterLoad() {} +func (tfd *TimerFileDescription) afterLoad() {} -func (t *TimerFileDescription) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.vfsfd) - stateSourceObject.Load(1, &t.FileDescriptionDefaultImpl) - stateSourceObject.Load(2, &t.DentryMetadataFileDescriptionImpl) - stateSourceObject.Load(3, &t.NoLockFD) - stateSourceObject.Load(4, &t.events) - stateSourceObject.Load(5, &t.timer) - stateSourceObject.Load(6, &t.val) +func (tfd *TimerFileDescription) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &tfd.vfsfd) + stateSourceObject.Load(1, &tfd.FileDescriptionDefaultImpl) + stateSourceObject.Load(2, &tfd.DentryMetadataFileDescriptionImpl) + stateSourceObject.Load(3, &tfd.NoLockFD) + stateSourceObject.Load(4, &tfd.events) + stateSourceObject.Load(5, &tfd.timer) + stateSourceObject.Load(6, &tfd.val) } func init() { diff --git a/pkg/sentry/fsimpl/tmpfs/tmpfs_state_autogen.go b/pkg/sentry/fsimpl/tmpfs/tmpfs_state_autogen.go index 8fa28e3da..a58a4ed20 100644 --- a/pkg/sentry/fsimpl/tmpfs/tmpfs_state_autogen.go +++ b/pkg/sentry/fsimpl/tmpfs/tmpfs_state_autogen.go @@ -6,56 +6,56 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (d *dentryList) StateTypeName() string { +func (l *dentryList) StateTypeName() string { return "pkg/sentry/fsimpl/tmpfs.dentryList" } -func (d *dentryList) StateFields() []string { +func (l *dentryList) StateFields() []string { return []string{ "head", "tail", } } -func (d *dentryList) beforeSave() {} +func (l *dentryList) beforeSave() {} -func (d *dentryList) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - stateSinkObject.Save(0, &d.head) - stateSinkObject.Save(1, &d.tail) +func (l *dentryList) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.head) + stateSinkObject.Save(1, &l.tail) } -func (d *dentryList) afterLoad() {} +func (l *dentryList) afterLoad() {} -func (d *dentryList) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.head) - stateSourceObject.Load(1, &d.tail) +func (l *dentryList) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.head) + stateSourceObject.Load(1, &l.tail) } -func (d *dentryEntry) StateTypeName() string { +func (e *dentryEntry) StateTypeName() string { return "pkg/sentry/fsimpl/tmpfs.dentryEntry" } -func (d *dentryEntry) StateFields() []string { +func (e *dentryEntry) StateFields() []string { return []string{ "next", "prev", } } -func (d *dentryEntry) beforeSave() {} +func (e *dentryEntry) beforeSave() {} -func (d *dentryEntry) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - stateSinkObject.Save(0, &d.next) - stateSinkObject.Save(1, &d.prev) +func (e *dentryEntry) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.next) + stateSinkObject.Save(1, &e.prev) } -func (d *dentryEntry) afterLoad() {} +func (e *dentryEntry) afterLoad() {} -func (d *dentryEntry) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.next) - stateSourceObject.Load(1, &d.prev) +func (e *dentryEntry) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.next) + stateSourceObject.Load(1, &e.prev) } func (d *deviceFile) StateTypeName() string { @@ -90,11 +90,11 @@ func (d *deviceFile) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(3, &d.minor) } -func (d *directory) StateTypeName() string { +func (dir *directory) StateTypeName() string { return "pkg/sentry/fsimpl/tmpfs.directory" } -func (d *directory) StateFields() []string { +func (dir *directory) StateFields() []string { return []string{ "dentry", "inode", @@ -104,32 +104,32 @@ func (d *directory) StateFields() []string { } } -func (d *directory) beforeSave() {} +func (dir *directory) beforeSave() {} -func (d *directory) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - stateSinkObject.Save(0, &d.dentry) - stateSinkObject.Save(1, &d.inode) - stateSinkObject.Save(2, &d.childMap) - stateSinkObject.Save(3, &d.numChildren) - stateSinkObject.Save(4, &d.childList) +func (dir *directory) StateSave(stateSinkObject state.Sink) { + dir.beforeSave() + stateSinkObject.Save(0, &dir.dentry) + stateSinkObject.Save(1, &dir.inode) + stateSinkObject.Save(2, &dir.childMap) + stateSinkObject.Save(3, &dir.numChildren) + stateSinkObject.Save(4, &dir.childList) } -func (d *directory) afterLoad() {} +func (dir *directory) afterLoad() {} -func (d *directory) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.dentry) - stateSourceObject.Load(1, &d.inode) - stateSourceObject.Load(2, &d.childMap) - stateSourceObject.Load(3, &d.numChildren) - stateSourceObject.Load(4, &d.childList) +func (dir *directory) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &dir.dentry) + stateSourceObject.Load(1, &dir.inode) + stateSourceObject.Load(2, &dir.childMap) + stateSourceObject.Load(3, &dir.numChildren) + stateSourceObject.Load(4, &dir.childList) } -func (d *directoryFD) StateTypeName() string { +func (fd *directoryFD) StateTypeName() string { return "pkg/sentry/fsimpl/tmpfs.directoryFD" } -func (d *directoryFD) StateFields() []string { +func (fd *directoryFD) StateFields() []string { return []string{ "fileDescription", "DirectoryFileDescriptionDefaultImpl", @@ -138,46 +138,46 @@ func (d *directoryFD) StateFields() []string { } } -func (d *directoryFD) beforeSave() {} +func (fd *directoryFD) beforeSave() {} -func (d *directoryFD) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - stateSinkObject.Save(0, &d.fileDescription) - stateSinkObject.Save(1, &d.DirectoryFileDescriptionDefaultImpl) - stateSinkObject.Save(2, &d.iter) - stateSinkObject.Save(3, &d.off) +func (fd *directoryFD) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.fileDescription) + stateSinkObject.Save(1, &fd.DirectoryFileDescriptionDefaultImpl) + stateSinkObject.Save(2, &fd.iter) + stateSinkObject.Save(3, &fd.off) } -func (d *directoryFD) afterLoad() {} +func (fd *directoryFD) afterLoad() {} -func (d *directoryFD) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.fileDescription) - stateSourceObject.Load(1, &d.DirectoryFileDescriptionDefaultImpl) - stateSourceObject.Load(2, &d.iter) - stateSourceObject.Load(3, &d.off) +func (fd *directoryFD) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.fileDescription) + stateSourceObject.Load(1, &fd.DirectoryFileDescriptionDefaultImpl) + stateSourceObject.Load(2, &fd.iter) + stateSourceObject.Load(3, &fd.off) } -func (i *inodeRefs) StateTypeName() string { +func (r *inodeRefs) StateTypeName() string { return "pkg/sentry/fsimpl/tmpfs.inodeRefs" } -func (i *inodeRefs) StateFields() []string { +func (r *inodeRefs) StateFields() []string { return []string{ "refCount", } } -func (i *inodeRefs) beforeSave() {} +func (r *inodeRefs) beforeSave() {} -func (i *inodeRefs) StateSave(stateSinkObject state.Sink) { - i.beforeSave() - stateSinkObject.Save(0, &i.refCount) +func (r *inodeRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (i *inodeRefs) afterLoad() {} +func (r *inodeRefs) afterLoad() {} -func (i *inodeRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &i.refCount) +func (r *inodeRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } func (n *namedPipe) StateTypeName() string { @@ -206,11 +206,11 @@ func (n *namedPipe) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &n.pipe) } -func (r *regularFile) StateTypeName() string { +func (rf *regularFile) StateTypeName() string { return "pkg/sentry/fsimpl/tmpfs.regularFile" } -func (r *regularFile) StateFields() []string { +func (rf *regularFile) StateFields() []string { return []string{ "inode", "memFile", @@ -223,57 +223,57 @@ func (r *regularFile) StateFields() []string { } } -func (r *regularFile) beforeSave() {} +func (rf *regularFile) beforeSave() {} -func (r *regularFile) StateSave(stateSinkObject state.Sink) { - r.beforeSave() - stateSinkObject.Save(0, &r.inode) - stateSinkObject.Save(1, &r.memFile) - stateSinkObject.Save(2, &r.memoryUsageKind) - stateSinkObject.Save(3, &r.mappings) - stateSinkObject.Save(4, &r.writableMappingPages) - stateSinkObject.Save(5, &r.data) - stateSinkObject.Save(6, &r.seals) - stateSinkObject.Save(7, &r.size) -} - -func (r *regularFile) afterLoad() {} - -func (r *regularFile) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &r.inode) - stateSourceObject.Load(1, &r.memFile) - stateSourceObject.Load(2, &r.memoryUsageKind) - stateSourceObject.Load(3, &r.mappings) - stateSourceObject.Load(4, &r.writableMappingPages) - stateSourceObject.Load(5, &r.data) - stateSourceObject.Load(6, &r.seals) - stateSourceObject.Load(7, &r.size) -} - -func (r *regularFileFD) StateTypeName() string { +func (rf *regularFile) StateSave(stateSinkObject state.Sink) { + rf.beforeSave() + stateSinkObject.Save(0, &rf.inode) + stateSinkObject.Save(1, &rf.memFile) + stateSinkObject.Save(2, &rf.memoryUsageKind) + stateSinkObject.Save(3, &rf.mappings) + stateSinkObject.Save(4, &rf.writableMappingPages) + stateSinkObject.Save(5, &rf.data) + stateSinkObject.Save(6, &rf.seals) + stateSinkObject.Save(7, &rf.size) +} + +func (rf *regularFile) afterLoad() {} + +func (rf *regularFile) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &rf.inode) + stateSourceObject.Load(1, &rf.memFile) + stateSourceObject.Load(2, &rf.memoryUsageKind) + stateSourceObject.Load(3, &rf.mappings) + stateSourceObject.Load(4, &rf.writableMappingPages) + stateSourceObject.Load(5, &rf.data) + stateSourceObject.Load(6, &rf.seals) + stateSourceObject.Load(7, &rf.size) +} + +func (fd *regularFileFD) StateTypeName() string { return "pkg/sentry/fsimpl/tmpfs.regularFileFD" } -func (r *regularFileFD) StateFields() []string { +func (fd *regularFileFD) StateFields() []string { return []string{ "fileDescription", "off", } } -func (r *regularFileFD) beforeSave() {} +func (fd *regularFileFD) beforeSave() {} -func (r *regularFileFD) StateSave(stateSinkObject state.Sink) { - r.beforeSave() - stateSinkObject.Save(0, &r.fileDescription) - stateSinkObject.Save(1, &r.off) +func (fd *regularFileFD) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.fileDescription) + stateSinkObject.Save(1, &fd.off) } -func (r *regularFileFD) afterLoad() {} +func (fd *regularFileFD) afterLoad() {} -func (r *regularFileFD) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &r.fileDescription) - stateSourceObject.Load(1, &r.off) +func (fd *regularFileFD) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.fileDescription) + stateSourceObject.Load(1, &fd.off) } func (s *socketFile) StateTypeName() string { @@ -328,30 +328,30 @@ func (s *symlink) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &s.target) } -func (f *FilesystemType) StateTypeName() string { +func (fstype *FilesystemType) StateTypeName() string { return "pkg/sentry/fsimpl/tmpfs.FilesystemType" } -func (f *FilesystemType) StateFields() []string { +func (fstype *FilesystemType) StateFields() []string { return []string{} } -func (f *FilesystemType) beforeSave() {} +func (fstype *FilesystemType) beforeSave() {} -func (f *FilesystemType) StateSave(stateSinkObject state.Sink) { - f.beforeSave() +func (fstype *FilesystemType) StateSave(stateSinkObject state.Sink) { + fstype.beforeSave() } -func (f *FilesystemType) afterLoad() {} +func (fstype *FilesystemType) afterLoad() {} -func (f *FilesystemType) StateLoad(stateSourceObject state.Source) { +func (fstype *FilesystemType) StateLoad(stateSourceObject state.Source) { } -func (f *filesystem) StateTypeName() string { +func (fs *filesystem) StateTypeName() string { return "pkg/sentry/fsimpl/tmpfs.filesystem" } -func (f *filesystem) StateFields() []string { +func (fs *filesystem) StateFields() []string { return []string{ "vfsfs", "memFile", @@ -361,25 +361,25 @@ func (f *filesystem) StateFields() []string { } } -func (f *filesystem) beforeSave() {} +func (fs *filesystem) beforeSave() {} -func (f *filesystem) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.vfsfs) - stateSinkObject.Save(1, &f.memFile) - stateSinkObject.Save(2, &f.clock) - stateSinkObject.Save(3, &f.devMinor) - stateSinkObject.Save(4, &f.nextInoMinusOne) +func (fs *filesystem) StateSave(stateSinkObject state.Sink) { + fs.beforeSave() + stateSinkObject.Save(0, &fs.vfsfs) + stateSinkObject.Save(1, &fs.memFile) + stateSinkObject.Save(2, &fs.clock) + stateSinkObject.Save(3, &fs.devMinor) + stateSinkObject.Save(4, &fs.nextInoMinusOne) } -func (f *filesystem) afterLoad() {} +func (fs *filesystem) afterLoad() {} -func (f *filesystem) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.vfsfs) - stateSourceObject.Load(1, &f.memFile) - stateSourceObject.Load(2, &f.clock) - stateSourceObject.Load(3, &f.devMinor) - stateSourceObject.Load(4, &f.nextInoMinusOne) +func (fs *filesystem) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fs.vfsfs) + stateSourceObject.Load(1, &fs.memFile) + stateSourceObject.Load(2, &fs.clock) + stateSourceObject.Load(3, &fs.devMinor) + stateSourceObject.Load(4, &fs.nextInoMinusOne) } func (f *FilesystemOpts) StateTypeName() string { @@ -508,11 +508,11 @@ func (i *inode) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(13, &i.impl) } -func (f *fileDescription) StateTypeName() string { +func (fd *fileDescription) StateTypeName() string { return "pkg/sentry/fsimpl/tmpfs.fileDescription" } -func (f *fileDescription) StateFields() []string { +func (fd *fileDescription) StateFields() []string { return []string{ "vfsfd", "FileDescriptionDefaultImpl", @@ -520,21 +520,21 @@ func (f *fileDescription) StateFields() []string { } } -func (f *fileDescription) beforeSave() {} +func (fd *fileDescription) beforeSave() {} -func (f *fileDescription) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.vfsfd) - stateSinkObject.Save(1, &f.FileDescriptionDefaultImpl) - stateSinkObject.Save(2, &f.LockFD) +func (fd *fileDescription) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.vfsfd) + stateSinkObject.Save(1, &fd.FileDescriptionDefaultImpl) + stateSinkObject.Save(2, &fd.LockFD) } -func (f *fileDescription) afterLoad() {} +func (fd *fileDescription) afterLoad() {} -func (f *fileDescription) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.vfsfd) - stateSourceObject.Load(1, &f.FileDescriptionDefaultImpl) - stateSourceObject.Load(2, &f.LockFD) +func (fd *fileDescription) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.vfsfd) + stateSourceObject.Load(1, &fd.FileDescriptionDefaultImpl) + stateSourceObject.Load(2, &fd.LockFD) } func init() { diff --git a/pkg/sentry/kernel/auth/auth_state_autogen.go b/pkg/sentry/kernel/auth/auth_state_autogen.go index 7381b79ea..b844c1fdc 100644 --- a/pkg/sentry/kernel/auth/auth_state_autogen.go +++ b/pkg/sentry/kernel/auth/auth_state_autogen.go @@ -94,61 +94,61 @@ func (i *IDMapEntry) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(2, &i.Length) } -func (i *idMapRange) StateTypeName() string { +func (r *idMapRange) StateTypeName() string { return "pkg/sentry/kernel/auth.idMapRange" } -func (i *idMapRange) StateFields() []string { +func (r *idMapRange) StateFields() []string { return []string{ "Start", "End", } } -func (i *idMapRange) beforeSave() {} +func (r *idMapRange) beforeSave() {} -func (i *idMapRange) StateSave(stateSinkObject state.Sink) { - i.beforeSave() - stateSinkObject.Save(0, &i.Start) - stateSinkObject.Save(1, &i.End) +func (r *idMapRange) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.Start) + stateSinkObject.Save(1, &r.End) } -func (i *idMapRange) afterLoad() {} +func (r *idMapRange) afterLoad() {} -func (i *idMapRange) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &i.Start) - stateSourceObject.Load(1, &i.End) +func (r *idMapRange) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.Start) + stateSourceObject.Load(1, &r.End) } -func (i *idMapSet) StateTypeName() string { +func (s *idMapSet) StateTypeName() string { return "pkg/sentry/kernel/auth.idMapSet" } -func (i *idMapSet) StateFields() []string { +func (s *idMapSet) StateFields() []string { return []string{ "root", } } -func (i *idMapSet) beforeSave() {} +func (s *idMapSet) beforeSave() {} -func (i *idMapSet) StateSave(stateSinkObject state.Sink) { - i.beforeSave() - var rootValue *idMapSegmentDataSlices = i.saveRoot() +func (s *idMapSet) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + var rootValue *idMapSegmentDataSlices = s.saveRoot() stateSinkObject.SaveValue(0, rootValue) } -func (i *idMapSet) afterLoad() {} +func (s *idMapSet) afterLoad() {} -func (i *idMapSet) StateLoad(stateSourceObject state.Source) { - stateSourceObject.LoadValue(0, new(*idMapSegmentDataSlices), func(y interface{}) { i.loadRoot(y.(*idMapSegmentDataSlices)) }) +func (s *idMapSet) StateLoad(stateSourceObject state.Source) { + stateSourceObject.LoadValue(0, new(*idMapSegmentDataSlices), func(y interface{}) { s.loadRoot(y.(*idMapSegmentDataSlices)) }) } -func (i *idMapnode) StateTypeName() string { +func (n *idMapnode) StateTypeName() string { return "pkg/sentry/kernel/auth.idMapnode" } -func (i *idMapnode) StateFields() []string { +func (n *idMapnode) StateFields() []string { return []string{ "nrSegments", "parent", @@ -161,31 +161,31 @@ func (i *idMapnode) StateFields() []string { } } -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 (n *idMapnode) beforeSave() {} + +func (n *idMapnode) StateSave(stateSinkObject state.Sink) { + n.beforeSave() + stateSinkObject.Save(0, &n.nrSegments) + stateSinkObject.Save(1, &n.parent) + stateSinkObject.Save(2, &n.parentIndex) + stateSinkObject.Save(3, &n.hasChildren) + stateSinkObject.Save(4, &n.maxGap) + stateSinkObject.Save(5, &n.keys) + stateSinkObject.Save(6, &n.values) + stateSinkObject.Save(7, &n.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 (n *idMapnode) afterLoad() {} + +func (n *idMapnode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &n.nrSegments) + stateSourceObject.Load(1, &n.parent) + stateSourceObject.Load(2, &n.parentIndex) + stateSourceObject.Load(3, &n.hasChildren) + stateSourceObject.Load(4, &n.maxGap) + stateSourceObject.Load(5, &n.keys) + stateSourceObject.Load(6, &n.values) + stateSourceObject.Load(7, &n.children) } func (i *idMapSegmentDataSlices) StateTypeName() string { @@ -217,11 +217,11 @@ func (i *idMapSegmentDataSlices) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(2, &i.Values) } -func (u *UserNamespace) StateTypeName() string { +func (ns *UserNamespace) StateTypeName() string { return "pkg/sentry/kernel/auth.UserNamespace" } -func (u *UserNamespace) StateFields() []string { +func (ns *UserNamespace) StateFields() []string { return []string{ "parent", "owner", @@ -232,27 +232,27 @@ func (u *UserNamespace) StateFields() []string { } } -func (u *UserNamespace) beforeSave() {} +func (ns *UserNamespace) beforeSave() {} -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 (ns *UserNamespace) StateSave(stateSinkObject state.Sink) { + ns.beforeSave() + stateSinkObject.Save(0, &ns.parent) + stateSinkObject.Save(1, &ns.owner) + stateSinkObject.Save(2, &ns.uidMapFromParent) + stateSinkObject.Save(3, &ns.uidMapToParent) + stateSinkObject.Save(4, &ns.gidMapFromParent) + stateSinkObject.Save(5, &ns.gidMapToParent) } -func (u *UserNamespace) afterLoad() {} +func (ns *UserNamespace) afterLoad() {} -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 (ns *UserNamespace) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &ns.parent) + stateSourceObject.Load(1, &ns.owner) + stateSourceObject.Load(2, &ns.uidMapFromParent) + stateSourceObject.Load(3, &ns.uidMapToParent) + stateSourceObject.Load(4, &ns.gidMapFromParent) + stateSourceObject.Load(5, &ns.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 4002e0cb2..7b4e62296 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 (a *AtomicPtrCredentials) StateTypeName() string { +func (p *AtomicPtrCredentials) StateTypeName() string { return "pkg/sentry/kernel/auth.AtomicPtrCredentials" } -func (a *AtomicPtrCredentials) StateFields() []string { +func (p *AtomicPtrCredentials) StateFields() []string { return []string{ "ptr", } } -func (a *AtomicPtrCredentials) beforeSave() {} +func (p *AtomicPtrCredentials) beforeSave() {} -func (a *AtomicPtrCredentials) StateSave(stateSinkObject state.Sink) { - a.beforeSave() - var ptrValue *Credentials = a.savePtr() +func (p *AtomicPtrCredentials) StateSave(stateSinkObject state.Sink) { + p.beforeSave() + var ptrValue *Credentials = p.savePtr() stateSinkObject.SaveValue(0, ptrValue) } -func (a *AtomicPtrCredentials) afterLoad() {} +func (p *AtomicPtrCredentials) afterLoad() {} -func (a *AtomicPtrCredentials) StateLoad(stateSourceObject state.Source) { - stateSourceObject.LoadValue(0, new(*Credentials), func(y interface{}) { a.loadPtr(y.(*Credentials)) }) +func (p *AtomicPtrCredentials) StateLoad(stateSourceObject state.Source) { + stateSourceObject.LoadValue(0, new(*Credentials), func(y interface{}) { p.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 cdeadd3e1..ba00fe082 100644 --- a/pkg/sentry/kernel/epoll/epoll_state_autogen.go +++ b/pkg/sentry/kernel/epoll/epoll_state_autogen.go @@ -121,56 +121,56 @@ func (e *EventPoll) StateLoad(stateSourceObject state.Source) { stateSourceObject.AfterLoad(e.afterLoad) } -func (p *pollEntryList) StateTypeName() string { +func (l *pollEntryList) StateTypeName() string { return "pkg/sentry/kernel/epoll.pollEntryList" } -func (p *pollEntryList) StateFields() []string { +func (l *pollEntryList) StateFields() []string { return []string{ "head", "tail", } } -func (p *pollEntryList) beforeSave() {} +func (l *pollEntryList) beforeSave() {} -func (p *pollEntryList) StateSave(stateSinkObject state.Sink) { - p.beforeSave() - stateSinkObject.Save(0, &p.head) - stateSinkObject.Save(1, &p.tail) +func (l *pollEntryList) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.head) + stateSinkObject.Save(1, &l.tail) } -func (p *pollEntryList) afterLoad() {} +func (l *pollEntryList) afterLoad() {} -func (p *pollEntryList) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &p.head) - stateSourceObject.Load(1, &p.tail) +func (l *pollEntryList) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.head) + stateSourceObject.Load(1, &l.tail) } -func (p *pollEntryEntry) StateTypeName() string { +func (e *pollEntryEntry) StateTypeName() string { return "pkg/sentry/kernel/epoll.pollEntryEntry" } -func (p *pollEntryEntry) StateFields() []string { +func (e *pollEntryEntry) StateFields() []string { return []string{ "next", "prev", } } -func (p *pollEntryEntry) beforeSave() {} +func (e *pollEntryEntry) beforeSave() {} -func (p *pollEntryEntry) StateSave(stateSinkObject state.Sink) { - p.beforeSave() - stateSinkObject.Save(0, &p.next) - stateSinkObject.Save(1, &p.prev) +func (e *pollEntryEntry) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.next) + stateSinkObject.Save(1, &e.prev) } -func (p *pollEntryEntry) afterLoad() {} +func (e *pollEntryEntry) afterLoad() {} -func (p *pollEntryEntry) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &p.next) - stateSourceObject.Load(1, &p.prev) +func (e *pollEntryEntry) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.next) + stateSourceObject.Load(1, &e.prev) } func init() { diff --git a/pkg/sentry/kernel/fasync/fasync_state_autogen.go b/pkg/sentry/kernel/fasync/fasync_state_autogen.go index e4a0b5695..ac5f4bb54 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 (f *FileAsync) StateTypeName() string { +func (a *FileAsync) StateTypeName() string { return "pkg/sentry/kernel/fasync.FileAsync" } -func (f *FileAsync) StateFields() []string { +func (a *FileAsync) StateFields() []string { return []string{ "e", "requester", @@ -21,27 +21,27 @@ func (f *FileAsync) StateFields() []string { } } -func (f *FileAsync) beforeSave() {} +func (a *FileAsync) beforeSave() {} -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 (a *FileAsync) StateSave(stateSinkObject state.Sink) { + a.beforeSave() + stateSinkObject.Save(0, &a.e) + stateSinkObject.Save(1, &a.requester) + stateSinkObject.Save(2, &a.registered) + stateSinkObject.Save(3, &a.recipientPG) + stateSinkObject.Save(4, &a.recipientTG) + stateSinkObject.Save(5, &a.recipientT) } -func (f *FileAsync) afterLoad() {} +func (a *FileAsync) afterLoad() {} -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 (a *FileAsync) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &a.e) + stateSourceObject.Load(1, &a.requester) + stateSourceObject.Load(2, &a.registered) + stateSourceObject.Load(3, &a.recipientPG) + stateSourceObject.Load(4, &a.recipientTG) + stateSourceObject.Load(5, &a.recipientT) } func init() { diff --git a/pkg/sentry/kernel/futex/futex_state_autogen.go b/pkg/sentry/kernel/futex/futex_state_autogen.go index f36f5ccfc..f31e571f4 100644 --- a/pkg/sentry/kernel/futex/futex_state_autogen.go +++ b/pkg/sentry/kernel/futex/futex_state_autogen.go @@ -54,56 +54,56 @@ func (m *Manager) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(0, &m.sharedBucket) } -func (w *waiterList) StateTypeName() string { +func (l *waiterList) StateTypeName() string { return "pkg/sentry/kernel/futex.waiterList" } -func (w *waiterList) StateFields() []string { +func (l *waiterList) StateFields() []string { return []string{ "head", "tail", } } -func (w *waiterList) beforeSave() {} +func (l *waiterList) beforeSave() {} -func (w *waiterList) StateSave(stateSinkObject state.Sink) { - w.beforeSave() - stateSinkObject.Save(0, &w.head) - stateSinkObject.Save(1, &w.tail) +func (l *waiterList) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.head) + stateSinkObject.Save(1, &l.tail) } -func (w *waiterList) afterLoad() {} +func (l *waiterList) afterLoad() {} -func (w *waiterList) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &w.head) - stateSourceObject.Load(1, &w.tail) +func (l *waiterList) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.head) + stateSourceObject.Load(1, &l.tail) } -func (w *waiterEntry) StateTypeName() string { +func (e *waiterEntry) StateTypeName() string { return "pkg/sentry/kernel/futex.waiterEntry" } -func (w *waiterEntry) StateFields() []string { +func (e *waiterEntry) StateFields() []string { return []string{ "next", "prev", } } -func (w *waiterEntry) beforeSave() {} +func (e *waiterEntry) beforeSave() {} -func (w *waiterEntry) StateSave(stateSinkObject state.Sink) { - w.beforeSave() - stateSinkObject.Save(0, &w.next) - stateSinkObject.Save(1, &w.prev) +func (e *waiterEntry) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.next) + stateSinkObject.Save(1, &e.prev) } -func (w *waiterEntry) afterLoad() {} +func (e *waiterEntry) afterLoad() {} -func (w *waiterEntry) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &w.next) - stateSourceObject.Load(1, &w.prev) +func (e *waiterEntry) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.next) + stateSourceObject.Load(1, &e.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 6a9953ffa..19e23104f 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 (a *AtomicPtrBucket) StateTypeName() string { +func (p *AtomicPtrBucket) StateTypeName() string { return "pkg/sentry/kernel/futex.AtomicPtrBucket" } -func (a *AtomicPtrBucket) StateFields() []string { +func (p *AtomicPtrBucket) StateFields() []string { return []string{ "ptr", } } -func (a *AtomicPtrBucket) beforeSave() {} +func (p *AtomicPtrBucket) beforeSave() {} -func (a *AtomicPtrBucket) StateSave(stateSinkObject state.Sink) { - a.beforeSave() - var ptrValue *bucket = a.savePtr() +func (p *AtomicPtrBucket) StateSave(stateSinkObject state.Sink) { + p.beforeSave() + var ptrValue *bucket = p.savePtr() stateSinkObject.SaveValue(0, ptrValue) } -func (a *AtomicPtrBucket) afterLoad() {} +func (p *AtomicPtrBucket) afterLoad() {} -func (a *AtomicPtrBucket) StateLoad(stateSourceObject state.Source) { - stateSourceObject.LoadValue(0, new(*bucket), func(y interface{}) { a.loadPtr(y.(*bucket)) }) +func (p *AtomicPtrBucket) StateLoad(stateSourceObject state.Source) { + stateSourceObject.LoadValue(0, new(*bucket), func(y interface{}) { p.loadPtr(y.(*bucket)) }) } func init() { diff --git a/pkg/sentry/kernel/kernel_state_autogen.go b/pkg/sentry/kernel/kernel_state_autogen.go index 101c137de..d8ff396b7 100644 --- a/pkg/sentry/kernel/kernel_state_autogen.go +++ b/pkg/sentry/kernel/kernel_state_autogen.go @@ -152,27 +152,27 @@ func (f *FDTable) StateLoad(stateSourceObject state.Source) { stateSourceObject.LoadValue(4, new(map[int32]descriptor), func(y interface{}) { f.loadDescriptorTable(y.(map[int32]descriptor)) }) } -func (f *FDTableRefs) StateTypeName() string { +func (r *FDTableRefs) StateTypeName() string { return "pkg/sentry/kernel.FDTableRefs" } -func (f *FDTableRefs) StateFields() []string { +func (r *FDTableRefs) StateFields() []string { return []string{ "refCount", } } -func (f *FDTableRefs) beforeSave() {} +func (r *FDTableRefs) beforeSave() {} -func (f *FDTableRefs) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.refCount) +func (r *FDTableRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (f *FDTableRefs) afterLoad() {} +func (r *FDTableRefs) afterLoad() {} -func (f *FDTableRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.refCount) +func (r *FDTableRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } func (f *FSContext) StateTypeName() string { @@ -213,27 +213,27 @@ func (f *FSContext) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(5, &f.umask) } -func (f *FSContextRefs) StateTypeName() string { +func (r *FSContextRefs) StateTypeName() string { return "pkg/sentry/kernel.FSContextRefs" } -func (f *FSContextRefs) StateFields() []string { +func (r *FSContextRefs) StateFields() []string { return []string{ "refCount", } } -func (f *FSContextRefs) beforeSave() {} +func (r *FSContextRefs) beforeSave() {} -func (f *FSContextRefs) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.refCount) +func (r *FSContextRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (f *FSContextRefs) afterLoad() {} +func (r *FSContextRefs) afterLoad() {} -func (f *FSContextRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.refCount) +func (r *FSContextRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } func (i *IPCNamespace) StateTypeName() string { @@ -535,56 +535,56 @@ func (p *pendingSignal) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(2, &p.timer) } -func (p *pendingSignalList) StateTypeName() string { +func (l *pendingSignalList) StateTypeName() string { return "pkg/sentry/kernel.pendingSignalList" } -func (p *pendingSignalList) StateFields() []string { +func (l *pendingSignalList) StateFields() []string { return []string{ "head", "tail", } } -func (p *pendingSignalList) beforeSave() {} +func (l *pendingSignalList) beforeSave() {} -func (p *pendingSignalList) StateSave(stateSinkObject state.Sink) { - p.beforeSave() - stateSinkObject.Save(0, &p.head) - stateSinkObject.Save(1, &p.tail) +func (l *pendingSignalList) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.head) + stateSinkObject.Save(1, &l.tail) } -func (p *pendingSignalList) afterLoad() {} +func (l *pendingSignalList) afterLoad() {} -func (p *pendingSignalList) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &p.head) - stateSourceObject.Load(1, &p.tail) +func (l *pendingSignalList) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.head) + stateSourceObject.Load(1, &l.tail) } -func (p *pendingSignalEntry) StateTypeName() string { +func (e *pendingSignalEntry) StateTypeName() string { return "pkg/sentry/kernel.pendingSignalEntry" } -func (p *pendingSignalEntry) StateFields() []string { +func (e *pendingSignalEntry) StateFields() []string { return []string{ "next", "prev", } } -func (p *pendingSignalEntry) beforeSave() {} +func (e *pendingSignalEntry) beforeSave() {} -func (p *pendingSignalEntry) StateSave(stateSinkObject state.Sink) { - p.beforeSave() - stateSinkObject.Save(0, &p.next) - stateSinkObject.Save(1, &p.prev) +func (e *pendingSignalEntry) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.next) + stateSinkObject.Save(1, &e.prev) } -func (p *pendingSignalEntry) afterLoad() {} +func (e *pendingSignalEntry) afterLoad() {} -func (p *pendingSignalEntry) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &p.next) - stateSourceObject.Load(1, &p.prev) +func (e *pendingSignalEntry) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.next) + stateSourceObject.Load(1, &e.prev) } func (s *savedPendingSignal) StateTypeName() string { @@ -613,11 +613,11 @@ func (s *savedPendingSignal) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &s.timer) } -func (i *IntervalTimer) StateTypeName() string { +func (it *IntervalTimer) StateTypeName() string { return "pkg/sentry/kernel.IntervalTimer" } -func (i *IntervalTimer) StateFields() []string { +func (it *IntervalTimer) StateFields() []string { return []string{ "timer", "target", @@ -632,110 +632,110 @@ func (i *IntervalTimer) StateFields() []string { } } -func (i *IntervalTimer) beforeSave() {} +func (it *IntervalTimer) beforeSave() {} -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 (i *IntervalTimer) afterLoad() {} - -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 (p *processGroupList) StateTypeName() string { +func (it *IntervalTimer) StateSave(stateSinkObject state.Sink) { + it.beforeSave() + stateSinkObject.Save(0, &it.timer) + stateSinkObject.Save(1, &it.target) + stateSinkObject.Save(2, &it.signo) + stateSinkObject.Save(3, &it.id) + stateSinkObject.Save(4, &it.sigval) + stateSinkObject.Save(5, &it.group) + stateSinkObject.Save(6, &it.sigpending) + stateSinkObject.Save(7, &it.sigorphan) + stateSinkObject.Save(8, &it.overrunCur) + stateSinkObject.Save(9, &it.overrunLast) +} + +func (it *IntervalTimer) afterLoad() {} + +func (it *IntervalTimer) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &it.timer) + stateSourceObject.Load(1, &it.target) + stateSourceObject.Load(2, &it.signo) + stateSourceObject.Load(3, &it.id) + stateSourceObject.Load(4, &it.sigval) + stateSourceObject.Load(5, &it.group) + stateSourceObject.Load(6, &it.sigpending) + stateSourceObject.Load(7, &it.sigorphan) + stateSourceObject.Load(8, &it.overrunCur) + stateSourceObject.Load(9, &it.overrunLast) +} + +func (l *processGroupList) StateTypeName() string { return "pkg/sentry/kernel.processGroupList" } -func (p *processGroupList) StateFields() []string { +func (l *processGroupList) StateFields() []string { return []string{ "head", "tail", } } -func (p *processGroupList) beforeSave() {} +func (l *processGroupList) beforeSave() {} -func (p *processGroupList) StateSave(stateSinkObject state.Sink) { - p.beforeSave() - stateSinkObject.Save(0, &p.head) - stateSinkObject.Save(1, &p.tail) +func (l *processGroupList) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.head) + stateSinkObject.Save(1, &l.tail) } -func (p *processGroupList) afterLoad() {} +func (l *processGroupList) afterLoad() {} -func (p *processGroupList) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &p.head) - stateSourceObject.Load(1, &p.tail) +func (l *processGroupList) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.head) + stateSourceObject.Load(1, &l.tail) } -func (p *processGroupEntry) StateTypeName() string { +func (e *processGroupEntry) StateTypeName() string { return "pkg/sentry/kernel.processGroupEntry" } -func (p *processGroupEntry) StateFields() []string { +func (e *processGroupEntry) StateFields() []string { return []string{ "next", "prev", } } -func (p *processGroupEntry) beforeSave() {} +func (e *processGroupEntry) beforeSave() {} -func (p *processGroupEntry) StateSave(stateSinkObject state.Sink) { - p.beforeSave() - stateSinkObject.Save(0, &p.next) - stateSinkObject.Save(1, &p.prev) +func (e *processGroupEntry) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.next) + stateSinkObject.Save(1, &e.prev) } -func (p *processGroupEntry) afterLoad() {} +func (e *processGroupEntry) afterLoad() {} -func (p *processGroupEntry) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &p.next) - stateSourceObject.Load(1, &p.prev) +func (e *processGroupEntry) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.next) + stateSourceObject.Load(1, &e.prev) } -func (p *ProcessGroupRefs) StateTypeName() string { +func (r *ProcessGroupRefs) StateTypeName() string { return "pkg/sentry/kernel.ProcessGroupRefs" } -func (p *ProcessGroupRefs) StateFields() []string { +func (r *ProcessGroupRefs) StateFields() []string { return []string{ "refCount", } } -func (p *ProcessGroupRefs) beforeSave() {} +func (r *ProcessGroupRefs) beforeSave() {} -func (p *ProcessGroupRefs) StateSave(stateSinkObject state.Sink) { - p.beforeSave() - stateSinkObject.Save(0, &p.refCount) +func (r *ProcessGroupRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (p *ProcessGroupRefs) afterLoad() {} +func (r *ProcessGroupRefs) afterLoad() {} -func (p *ProcessGroupRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &p.refCount) +func (r *ProcessGroupRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } func (p *ptraceOptions) StateTypeName() string { @@ -785,30 +785,30 @@ func (p *ptraceOptions) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(8, &p.TraceVforkDone) } -func (p *ptraceStop) StateTypeName() string { +func (s *ptraceStop) StateTypeName() string { return "pkg/sentry/kernel.ptraceStop" } -func (p *ptraceStop) StateFields() []string { +func (s *ptraceStop) StateFields() []string { return []string{ "frozen", "listen", } } -func (p *ptraceStop) beforeSave() {} +func (s *ptraceStop) beforeSave() {} -func (p *ptraceStop) StateSave(stateSinkObject state.Sink) { - p.beforeSave() - stateSinkObject.Save(0, &p.frozen) - stateSinkObject.Save(1, &p.listen) +func (s *ptraceStop) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + stateSinkObject.Save(0, &s.frozen) + stateSinkObject.Save(1, &s.listen) } -func (p *ptraceStop) afterLoad() {} +func (s *ptraceStop) afterLoad() {} -func (p *ptraceStop) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &p.frozen) - stateSourceObject.Load(1, &p.listen) +func (s *ptraceStop) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &s.frozen) + stateSourceObject.Load(1, &s.listen) } func (o *OldRSeqCriticalRegion) StateTypeName() string { @@ -837,79 +837,79 @@ func (o *OldRSeqCriticalRegion) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &o.Restart) } -func (s *sessionList) StateTypeName() string { +func (l *sessionList) StateTypeName() string { return "pkg/sentry/kernel.sessionList" } -func (s *sessionList) StateFields() []string { +func (l *sessionList) StateFields() []string { return []string{ "head", "tail", } } -func (s *sessionList) beforeSave() {} +func (l *sessionList) beforeSave() {} -func (s *sessionList) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.head) - stateSinkObject.Save(1, &s.tail) +func (l *sessionList) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.head) + stateSinkObject.Save(1, &l.tail) } -func (s *sessionList) afterLoad() {} +func (l *sessionList) afterLoad() {} -func (s *sessionList) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.head) - stateSourceObject.Load(1, &s.tail) +func (l *sessionList) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.head) + stateSourceObject.Load(1, &l.tail) } -func (s *sessionEntry) StateTypeName() string { +func (e *sessionEntry) StateTypeName() string { return "pkg/sentry/kernel.sessionEntry" } -func (s *sessionEntry) StateFields() []string { +func (e *sessionEntry) StateFields() []string { return []string{ "next", "prev", } } -func (s *sessionEntry) beforeSave() {} +func (e *sessionEntry) beforeSave() {} -func (s *sessionEntry) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.next) - stateSinkObject.Save(1, &s.prev) +func (e *sessionEntry) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.next) + stateSinkObject.Save(1, &e.prev) } -func (s *sessionEntry) afterLoad() {} +func (e *sessionEntry) afterLoad() {} -func (s *sessionEntry) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.next) - stateSourceObject.Load(1, &s.prev) +func (e *sessionEntry) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.next) + stateSourceObject.Load(1, &e.prev) } -func (s *SessionRefs) StateTypeName() string { +func (r *SessionRefs) StateTypeName() string { return "pkg/sentry/kernel.SessionRefs" } -func (s *SessionRefs) StateFields() []string { +func (r *SessionRefs) StateFields() []string { return []string{ "refCount", } } -func (s *SessionRefs) beforeSave() {} +func (r *SessionRefs) beforeSave() {} -func (s *SessionRefs) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.refCount) +func (r *SessionRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (s *SessionRefs) afterLoad() {} +func (r *SessionRefs) afterLoad() {} -func (s *SessionRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.refCount) +func (r *SessionRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } func (s *Session) StateTypeName() string { @@ -950,11 +950,11 @@ func (s *Session) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(5, &s.sessionEntry) } -func (p *ProcessGroup) StateTypeName() string { +func (pg *ProcessGroup) StateTypeName() string { return "pkg/sentry/kernel.ProcessGroup" } -func (p *ProcessGroup) StateFields() []string { +func (pg *ProcessGroup) StateFields() []string { return []string{ "refs", "originator", @@ -965,102 +965,102 @@ func (p *ProcessGroup) StateFields() []string { } } -func (p *ProcessGroup) beforeSave() {} +func (pg *ProcessGroup) beforeSave() {} -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 (pg *ProcessGroup) StateSave(stateSinkObject state.Sink) { + pg.beforeSave() + stateSinkObject.Save(0, &pg.refs) + stateSinkObject.Save(1, &pg.originator) + stateSinkObject.Save(2, &pg.id) + stateSinkObject.Save(3, &pg.session) + stateSinkObject.Save(4, &pg.ancestors) + stateSinkObject.Save(5, &pg.processGroupEntry) } -func (p *ProcessGroup) afterLoad() {} +func (pg *ProcessGroup) afterLoad() {} -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 (pg *ProcessGroup) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &pg.refs) + stateSourceObject.Load(1, &pg.originator) + stateSourceObject.Load(2, &pg.id) + stateSourceObject.Load(3, &pg.session) + stateSourceObject.Load(4, &pg.ancestors) + stateSourceObject.Load(5, &pg.processGroupEntry) } -func (s *SignalHandlers) StateTypeName() string { +func (sh *SignalHandlers) StateTypeName() string { return "pkg/sentry/kernel.SignalHandlers" } -func (s *SignalHandlers) StateFields() []string { +func (sh *SignalHandlers) StateFields() []string { return []string{ "actions", } } -func (s *SignalHandlers) beforeSave() {} +func (sh *SignalHandlers) beforeSave() {} -func (s *SignalHandlers) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.actions) +func (sh *SignalHandlers) StateSave(stateSinkObject state.Sink) { + sh.beforeSave() + stateSinkObject.Save(0, &sh.actions) } -func (s *SignalHandlers) afterLoad() {} +func (sh *SignalHandlers) afterLoad() {} -func (s *SignalHandlers) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.actions) +func (sh *SignalHandlers) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &sh.actions) } -func (s *socketList) StateTypeName() string { +func (l *socketList) StateTypeName() string { return "pkg/sentry/kernel.socketList" } -func (s *socketList) StateFields() []string { +func (l *socketList) StateFields() []string { return []string{ "head", "tail", } } -func (s *socketList) beforeSave() {} +func (l *socketList) beforeSave() {} -func (s *socketList) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.head) - stateSinkObject.Save(1, &s.tail) +func (l *socketList) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.head) + stateSinkObject.Save(1, &l.tail) } -func (s *socketList) afterLoad() {} +func (l *socketList) afterLoad() {} -func (s *socketList) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.head) - stateSourceObject.Load(1, &s.tail) +func (l *socketList) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.head) + stateSourceObject.Load(1, &l.tail) } -func (s *socketEntry) StateTypeName() string { +func (e *socketEntry) StateTypeName() string { return "pkg/sentry/kernel.socketEntry" } -func (s *socketEntry) StateFields() []string { +func (e *socketEntry) StateFields() []string { return []string{ "next", "prev", } } -func (s *socketEntry) beforeSave() {} +func (e *socketEntry) beforeSave() {} -func (s *socketEntry) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.next) - stateSinkObject.Save(1, &s.prev) +func (e *socketEntry) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.next) + stateSinkObject.Save(1, &e.prev) } -func (s *socketEntry) afterLoad() {} +func (e *socketEntry) afterLoad() {} -func (s *socketEntry) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.next) - stateSourceObject.Load(1, &s.prev) +func (e *socketEntry) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.next) + stateSourceObject.Load(1, &e.prev) } func (s *syscallTableInfo) StateTypeName() string { @@ -1390,11 +1390,11 @@ func (v *vforkStop) afterLoad() {} func (v *vforkStop) StateLoad(stateSourceObject state.Source) { } -func (t *TaskContext) StateTypeName() string { +func (tc *TaskContext) StateTypeName() string { return "pkg/sentry/kernel.TaskContext" } -func (t *TaskContext) StateFields() []string { +func (tc *TaskContext) StateFields() []string { return []string{ "Name", "Arch", @@ -1404,26 +1404,26 @@ func (t *TaskContext) StateFields() []string { } } -func (t *TaskContext) beforeSave() {} +func (tc *TaskContext) beforeSave() {} -func (t *TaskContext) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - var stValue syscallTableInfo = t.saveSt() +func (tc *TaskContext) StateSave(stateSinkObject state.Sink) { + tc.beforeSave() + var stValue syscallTableInfo = tc.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) + stateSinkObject.Save(0, &tc.Name) + stateSinkObject.Save(1, &tc.Arch) + stateSinkObject.Save(2, &tc.MemoryManager) + stateSinkObject.Save(3, &tc.fu) } -func (t *TaskContext) afterLoad() {} +func (tc *TaskContext) afterLoad() {} -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 (tc *TaskContext) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &tc.Name) + stateSourceObject.Load(1, &tc.Arch) + stateSourceObject.Load(2, &tc.MemoryManager) + stateSourceObject.Load(3, &tc.fu) + stateSourceObject.LoadValue(4, new(syscallTableInfo), func(y interface{}) { tc.loadSt(y.(syscallTableInfo)) }) } func (e *execStop) StateTypeName() string { @@ -1468,30 +1468,30 @@ func (r *runSyscallAfterExecStop) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(0, &r.tc) } -func (e *ExitStatus) StateTypeName() string { +func (es *ExitStatus) StateTypeName() string { return "pkg/sentry/kernel.ExitStatus" } -func (e *ExitStatus) StateFields() []string { +func (es *ExitStatus) StateFields() []string { return []string{ "Code", "Signo", } } -func (e *ExitStatus) beforeSave() {} +func (es *ExitStatus) beforeSave() {} -func (e *ExitStatus) StateSave(stateSinkObject state.Sink) { - e.beforeSave() - stateSinkObject.Save(0, &e.Code) - stateSinkObject.Save(1, &e.Signo) +func (es *ExitStatus) StateSave(stateSinkObject state.Sink) { + es.beforeSave() + stateSinkObject.Save(0, &es.Code) + stateSinkObject.Save(1, &es.Signo) } -func (e *ExitStatus) afterLoad() {} +func (es *ExitStatus) afterLoad() {} -func (e *ExitStatus) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &e.Code) - stateSourceObject.Load(1, &e.Signo) +func (es *ExitStatus) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &es.Code) + stateSourceObject.Load(1, &es.Signo) } func (r *runExit) StateTypeName() string { @@ -1551,82 +1551,82 @@ func (r *runExitNotify) afterLoad() {} func (r *runExitNotify) StateLoad(stateSourceObject state.Source) { } -func (t *taskList) StateTypeName() string { +func (l *taskList) StateTypeName() string { return "pkg/sentry/kernel.taskList" } -func (t *taskList) StateFields() []string { +func (l *taskList) StateFields() []string { return []string{ "head", "tail", } } -func (t *taskList) beforeSave() {} +func (l *taskList) beforeSave() {} -func (t *taskList) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.head) - stateSinkObject.Save(1, &t.tail) +func (l *taskList) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.head) + stateSinkObject.Save(1, &l.tail) } -func (t *taskList) afterLoad() {} +func (l *taskList) afterLoad() {} -func (t *taskList) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.head) - stateSourceObject.Load(1, &t.tail) +func (l *taskList) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.head) + stateSourceObject.Load(1, &l.tail) } -func (t *taskEntry) StateTypeName() string { +func (e *taskEntry) StateTypeName() string { return "pkg/sentry/kernel.taskEntry" } -func (t *taskEntry) StateFields() []string { +func (e *taskEntry) StateFields() []string { return []string{ "next", "prev", } } -func (t *taskEntry) beforeSave() {} +func (e *taskEntry) beforeSave() {} -func (t *taskEntry) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.next) - stateSinkObject.Save(1, &t.prev) +func (e *taskEntry) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.next) + stateSinkObject.Save(1, &e.prev) } -func (t *taskEntry) afterLoad() {} +func (e *taskEntry) afterLoad() {} -func (t *taskEntry) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.next) - stateSourceObject.Load(1, &t.prev) +func (e *taskEntry) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.next) + stateSourceObject.Load(1, &e.prev) } -func (r *runApp) StateTypeName() string { +func (app *runApp) StateTypeName() string { return "pkg/sentry/kernel.runApp" } -func (r *runApp) StateFields() []string { +func (app *runApp) StateFields() []string { return []string{} } -func (r *runApp) beforeSave() {} +func (app *runApp) beforeSave() {} -func (r *runApp) StateSave(stateSinkObject state.Sink) { - r.beforeSave() +func (app *runApp) StateSave(stateSinkObject state.Sink) { + app.beforeSave() } -func (r *runApp) afterLoad() {} +func (app *runApp) afterLoad() {} -func (r *runApp) StateLoad(stateSourceObject state.Source) { +func (app *runApp) StateLoad(stateSourceObject state.Source) { } -func (t *TaskGoroutineSchedInfo) StateTypeName() string { +func (ts *TaskGoroutineSchedInfo) StateTypeName() string { return "pkg/sentry/kernel.TaskGoroutineSchedInfo" } -func (t *TaskGoroutineSchedInfo) StateFields() []string { +func (ts *TaskGoroutineSchedInfo) StateFields() []string { return []string{ "Timestamp", "State", @@ -1635,75 +1635,75 @@ func (t *TaskGoroutineSchedInfo) StateFields() []string { } } -func (t *TaskGoroutineSchedInfo) beforeSave() {} +func (ts *TaskGoroutineSchedInfo) beforeSave() {} -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 (ts *TaskGoroutineSchedInfo) StateSave(stateSinkObject state.Sink) { + ts.beforeSave() + stateSinkObject.Save(0, &ts.Timestamp) + stateSinkObject.Save(1, &ts.State) + stateSinkObject.Save(2, &ts.UserTicks) + stateSinkObject.Save(3, &ts.SysTicks) } -func (t *TaskGoroutineSchedInfo) afterLoad() {} +func (ts *TaskGoroutineSchedInfo) afterLoad() {} -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 (ts *TaskGoroutineSchedInfo) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &ts.Timestamp) + stateSourceObject.Load(1, &ts.State) + stateSourceObject.Load(2, &ts.UserTicks) + stateSourceObject.Load(3, &ts.SysTicks) } -func (t *taskClock) StateTypeName() string { +func (tc *taskClock) StateTypeName() string { return "pkg/sentry/kernel.taskClock" } -func (t *taskClock) StateFields() []string { +func (tc *taskClock) StateFields() []string { return []string{ "t", "includeSys", } } -func (t *taskClock) beforeSave() {} +func (tc *taskClock) beforeSave() {} -func (t *taskClock) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.t) - stateSinkObject.Save(1, &t.includeSys) +func (tc *taskClock) StateSave(stateSinkObject state.Sink) { + tc.beforeSave() + stateSinkObject.Save(0, &tc.t) + stateSinkObject.Save(1, &tc.includeSys) } -func (t *taskClock) afterLoad() {} +func (tc *taskClock) afterLoad() {} -func (t *taskClock) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.t) - stateSourceObject.Load(1, &t.includeSys) +func (tc *taskClock) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &tc.t) + stateSourceObject.Load(1, &tc.includeSys) } -func (t *tgClock) StateTypeName() string { +func (tgc *tgClock) StateTypeName() string { return "pkg/sentry/kernel.tgClock" } -func (t *tgClock) StateFields() []string { +func (tgc *tgClock) StateFields() []string { return []string{ "tg", "includeSys", } } -func (t *tgClock) beforeSave() {} +func (tgc *tgClock) beforeSave() {} -func (t *tgClock) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.tg) - stateSinkObject.Save(1, &t.includeSys) +func (tgc *tgClock) StateSave(stateSinkObject state.Sink) { + tgc.beforeSave() + stateSinkObject.Save(0, &tgc.tg) + stateSinkObject.Save(1, &tgc.includeSys) } -func (t *tgClock) afterLoad() {} +func (tgc *tgClock) afterLoad() {} -func (t *tgClock) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.tg) - stateSourceObject.Load(1, &t.includeSys) +func (tgc *tgClock) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &tgc.tg) + stateSourceObject.Load(1, &tgc.includeSys) } func (g *groupStop) StateTypeName() string { @@ -1839,11 +1839,11 @@ func (r *runSyscallExit) afterLoad() {} func (r *runSyscallExit) StateLoad(stateSourceObject state.Source) { } -func (t *ThreadGroup) StateTypeName() string { +func (tg *ThreadGroup) StateTypeName() string { return "pkg/sentry/kernel.ThreadGroup" } -func (t *ThreadGroup) StateFields() []string { +func (tg *ThreadGroup) StateFields() []string { return []string{ "threadGroupNode", "signalHandlers", @@ -1881,138 +1881,138 @@ func (t *ThreadGroup) StateFields() []string { } } -func (t *ThreadGroup) beforeSave() {} +func (tg *ThreadGroup) beforeSave() {} -func (t *ThreadGroup) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - var oldRSeqCriticalValue *OldRSeqCriticalRegion = t.saveOldRSeqCritical() +func (tg *ThreadGroup) StateSave(stateSinkObject state.Sink) { + tg.beforeSave() + var oldRSeqCriticalValue *OldRSeqCriticalRegion = tg.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 { + stateSinkObject.Save(0, &tg.threadGroupNode) + stateSinkObject.Save(1, &tg.signalHandlers) + stateSinkObject.Save(2, &tg.pendingSignals) + stateSinkObject.Save(3, &tg.groupStopDequeued) + stateSinkObject.Save(4, &tg.groupStopSignal) + stateSinkObject.Save(5, &tg.groupStopPendingCount) + stateSinkObject.Save(6, &tg.groupStopComplete) + stateSinkObject.Save(7, &tg.groupStopWaitable) + stateSinkObject.Save(8, &tg.groupContNotify) + stateSinkObject.Save(9, &tg.groupContInterrupted) + stateSinkObject.Save(10, &tg.groupContWaitable) + stateSinkObject.Save(11, &tg.exiting) + stateSinkObject.Save(12, &tg.exitStatus) + stateSinkObject.Save(13, &tg.terminationSignal) + stateSinkObject.Save(14, &tg.itimerRealTimer) + stateSinkObject.Save(15, &tg.itimerVirtSetting) + stateSinkObject.Save(16, &tg.itimerProfSetting) + stateSinkObject.Save(17, &tg.rlimitCPUSoftSetting) + stateSinkObject.Save(18, &tg.cpuTimersEnabled) + stateSinkObject.Save(19, &tg.timers) + stateSinkObject.Save(20, &tg.nextTimerID) + stateSinkObject.Save(21, &tg.exitedCPUStats) + stateSinkObject.Save(22, &tg.childCPUStats) + stateSinkObject.Save(23, &tg.ioUsage) + stateSinkObject.Save(24, &tg.maxRSS) + stateSinkObject.Save(25, &tg.childMaxRSS) + stateSinkObject.Save(26, &tg.limits) + stateSinkObject.Save(27, &tg.processGroup) + stateSinkObject.Save(28, &tg.execed) + stateSinkObject.Save(30, &tg.mounts) + stateSinkObject.Save(31, &tg.tty) + stateSinkObject.Save(32, &tg.oomScoreAdj) +} + +func (tg *ThreadGroup) afterLoad() {} + +func (tg *ThreadGroup) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &tg.threadGroupNode) + stateSourceObject.Load(1, &tg.signalHandlers) + stateSourceObject.Load(2, &tg.pendingSignals) + stateSourceObject.Load(3, &tg.groupStopDequeued) + stateSourceObject.Load(4, &tg.groupStopSignal) + stateSourceObject.Load(5, &tg.groupStopPendingCount) + stateSourceObject.Load(6, &tg.groupStopComplete) + stateSourceObject.Load(7, &tg.groupStopWaitable) + stateSourceObject.Load(8, &tg.groupContNotify) + stateSourceObject.Load(9, &tg.groupContInterrupted) + stateSourceObject.Load(10, &tg.groupContWaitable) + stateSourceObject.Load(11, &tg.exiting) + stateSourceObject.Load(12, &tg.exitStatus) + stateSourceObject.Load(13, &tg.terminationSignal) + stateSourceObject.Load(14, &tg.itimerRealTimer) + stateSourceObject.Load(15, &tg.itimerVirtSetting) + stateSourceObject.Load(16, &tg.itimerProfSetting) + stateSourceObject.Load(17, &tg.rlimitCPUSoftSetting) + stateSourceObject.Load(18, &tg.cpuTimersEnabled) + stateSourceObject.Load(19, &tg.timers) + stateSourceObject.Load(20, &tg.nextTimerID) + stateSourceObject.Load(21, &tg.exitedCPUStats) + stateSourceObject.Load(22, &tg.childCPUStats) + stateSourceObject.Load(23, &tg.ioUsage) + stateSourceObject.Load(24, &tg.maxRSS) + stateSourceObject.Load(25, &tg.childMaxRSS) + stateSourceObject.Load(26, &tg.limits) + stateSourceObject.Load(27, &tg.processGroup) + stateSourceObject.Load(28, &tg.execed) + stateSourceObject.Load(30, &tg.mounts) + stateSourceObject.Load(31, &tg.tty) + stateSourceObject.Load(32, &tg.oomScoreAdj) + stateSourceObject.LoadValue(29, new(*OldRSeqCriticalRegion), func(y interface{}) { tg.loadOldRSeqCritical(y.(*OldRSeqCriticalRegion)) }) +} + +func (l *itimerRealListener) StateTypeName() string { return "pkg/sentry/kernel.itimerRealListener" } -func (i *itimerRealListener) StateFields() []string { +func (l *itimerRealListener) StateFields() []string { return []string{ "tg", } } -func (i *itimerRealListener) beforeSave() {} +func (l *itimerRealListener) beforeSave() {} -func (i *itimerRealListener) StateSave(stateSinkObject state.Sink) { - i.beforeSave() - stateSinkObject.Save(0, &i.tg) +func (l *itimerRealListener) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.tg) } -func (i *itimerRealListener) afterLoad() {} +func (l *itimerRealListener) afterLoad() {} -func (i *itimerRealListener) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &i.tg) +func (l *itimerRealListener) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.tg) } -func (t *TaskSet) StateTypeName() string { +func (ts *TaskSet) StateTypeName() string { return "pkg/sentry/kernel.TaskSet" } -func (t *TaskSet) StateFields() []string { +func (ts *TaskSet) StateFields() []string { return []string{ "Root", "sessions", } } -func (t *TaskSet) beforeSave() {} +func (ts *TaskSet) beforeSave() {} -func (t *TaskSet) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.Root) - stateSinkObject.Save(1, &t.sessions) +func (ts *TaskSet) StateSave(stateSinkObject state.Sink) { + ts.beforeSave() + stateSinkObject.Save(0, &ts.Root) + stateSinkObject.Save(1, &ts.sessions) } -func (t *TaskSet) afterLoad() {} +func (ts *TaskSet) afterLoad() {} -func (t *TaskSet) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.Root) - stateSourceObject.Load(1, &t.sessions) +func (ts *TaskSet) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &ts.Root) + stateSourceObject.Load(1, &ts.sessions) } -func (p *PIDNamespace) StateTypeName() string { +func (ns *PIDNamespace) StateTypeName() string { return "pkg/sentry/kernel.PIDNamespace" } -func (p *PIDNamespace) StateFields() []string { +func (ns *PIDNamespace) StateFields() []string { return []string{ "owner", "parent", @@ -2029,39 +2029,39 @@ func (p *PIDNamespace) StateFields() []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 (ns *PIDNamespace) beforeSave() {} + +func (ns *PIDNamespace) StateSave(stateSinkObject state.Sink) { + ns.beforeSave() + stateSinkObject.Save(0, &ns.owner) + stateSinkObject.Save(1, &ns.parent) + stateSinkObject.Save(2, &ns.userns) + stateSinkObject.Save(3, &ns.last) + stateSinkObject.Save(4, &ns.tasks) + stateSinkObject.Save(5, &ns.tids) + stateSinkObject.Save(6, &ns.tgids) + stateSinkObject.Save(7, &ns.sessions) + stateSinkObject.Save(8, &ns.sids) + stateSinkObject.Save(9, &ns.processGroups) + stateSinkObject.Save(10, &ns.pgids) + stateSinkObject.Save(11, &ns.exiting) +} + +func (ns *PIDNamespace) afterLoad() {} + +func (ns *PIDNamespace) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &ns.owner) + stateSourceObject.Load(1, &ns.parent) + stateSourceObject.Load(2, &ns.userns) + stateSourceObject.Load(3, &ns.last) + stateSourceObject.Load(4, &ns.tasks) + stateSourceObject.Load(5, &ns.tids) + stateSourceObject.Load(6, &ns.tgids) + stateSourceObject.Load(7, &ns.sessions) + stateSourceObject.Load(8, &ns.sids) + stateSourceObject.Load(9, &ns.processGroups) + stateSourceObject.Load(10, &ns.pgids) + stateSourceObject.Load(11, &ns.exiting) } func (t *threadGroupNode) StateTypeName() string { @@ -2169,30 +2169,30 @@ func (t *Timekeeper) StateLoad(stateSourceObject state.Source) { stateSourceObject.AfterLoad(t.afterLoad) } -func (t *timekeeperClock) StateTypeName() string { +func (tc *timekeeperClock) StateTypeName() string { return "pkg/sentry/kernel.timekeeperClock" } -func (t *timekeeperClock) StateFields() []string { +func (tc *timekeeperClock) StateFields() []string { return []string{ "tk", "c", } } -func (t *timekeeperClock) beforeSave() {} +func (tc *timekeeperClock) beforeSave() {} -func (t *timekeeperClock) StateSave(stateSinkObject state.Sink) { - t.beforeSave() - stateSinkObject.Save(0, &t.tk) - stateSinkObject.Save(1, &t.c) +func (tc *timekeeperClock) StateSave(stateSinkObject state.Sink) { + tc.beforeSave() + stateSinkObject.Save(0, &tc.tk) + stateSinkObject.Save(1, &tc.c) } -func (t *timekeeperClock) afterLoad() {} +func (tc *timekeeperClock) afterLoad() {} -func (t *timekeeperClock) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &t.tk) - stateSourceObject.Load(1, &t.c) +func (tc *timekeeperClock) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &tc.tk) + stateSourceObject.Load(1, &tc.c) } func (t *TTY) StateTypeName() string { diff --git a/pkg/sentry/kernel/pipe/pipe_state_autogen.go b/pkg/sentry/kernel/pipe/pipe_state_autogen.go index 031ea2cc2..9188cef94 100644 --- a/pkg/sentry/kernel/pipe/pipe_state_autogen.go +++ b/pkg/sentry/kernel/pipe/pipe_state_autogen.go @@ -96,27 +96,27 @@ func (r *Reader) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(0, &r.ReaderWriter) } -func (r *ReaderWriter) StateTypeName() string { +func (rw *ReaderWriter) StateTypeName() string { return "pkg/sentry/kernel/pipe.ReaderWriter" } -func (r *ReaderWriter) StateFields() []string { +func (rw *ReaderWriter) StateFields() []string { return []string{ "Pipe", } } -func (r *ReaderWriter) beforeSave() {} +func (rw *ReaderWriter) beforeSave() {} -func (r *ReaderWriter) StateSave(stateSinkObject state.Sink) { - r.beforeSave() - stateSinkObject.Save(0, &r.Pipe) +func (rw *ReaderWriter) StateSave(stateSinkObject state.Sink) { + rw.beforeSave() + stateSinkObject.Save(0, &rw.Pipe) } -func (r *ReaderWriter) afterLoad() {} +func (rw *ReaderWriter) afterLoad() {} -func (r *ReaderWriter) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &r.Pipe) +func (rw *ReaderWriter) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &rw.Pipe) } func (w *Writer) StateTypeName() string { diff --git a/pkg/sentry/kernel/semaphore/semaphore_state_autogen.go b/pkg/sentry/kernel/semaphore/semaphore_state_autogen.go index 80358c6e3..aed6cfa29 100644 --- a/pkg/sentry/kernel/semaphore/semaphore_state_autogen.go +++ b/pkg/sentry/kernel/semaphore/semaphore_state_autogen.go @@ -143,56 +143,56 @@ func (w *waiter) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(2, &w.ch) } -func (w *waiterList) StateTypeName() string { +func (l *waiterList) StateTypeName() string { return "pkg/sentry/kernel/semaphore.waiterList" } -func (w *waiterList) StateFields() []string { +func (l *waiterList) StateFields() []string { return []string{ "head", "tail", } } -func (w *waiterList) beforeSave() {} +func (l *waiterList) beforeSave() {} -func (w *waiterList) StateSave(stateSinkObject state.Sink) { - w.beforeSave() - stateSinkObject.Save(0, &w.head) - stateSinkObject.Save(1, &w.tail) +func (l *waiterList) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.head) + stateSinkObject.Save(1, &l.tail) } -func (w *waiterList) afterLoad() {} +func (l *waiterList) afterLoad() {} -func (w *waiterList) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &w.head) - stateSourceObject.Load(1, &w.tail) +func (l *waiterList) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.head) + stateSourceObject.Load(1, &l.tail) } -func (w *waiterEntry) StateTypeName() string { +func (e *waiterEntry) StateTypeName() string { return "pkg/sentry/kernel/semaphore.waiterEntry" } -func (w *waiterEntry) StateFields() []string { +func (e *waiterEntry) StateFields() []string { return []string{ "next", "prev", } } -func (w *waiterEntry) beforeSave() {} +func (e *waiterEntry) beforeSave() {} -func (w *waiterEntry) StateSave(stateSinkObject state.Sink) { - w.beforeSave() - stateSinkObject.Save(0, &w.next) - stateSinkObject.Save(1, &w.prev) +func (e *waiterEntry) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.next) + stateSinkObject.Save(1, &e.prev) } -func (w *waiterEntry) afterLoad() {} +func (e *waiterEntry) afterLoad() {} -func (w *waiterEntry) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &w.next) - stateSourceObject.Load(1, &w.prev) +func (e *waiterEntry) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.next) + stateSourceObject.Load(1, &e.prev) } func init() { diff --git a/pkg/sentry/kernel/shm/shm_state_autogen.go b/pkg/sentry/kernel/shm/shm_state_autogen.go index 846cbc2d5..8202c37d6 100644 --- a/pkg/sentry/kernel/shm/shm_state_autogen.go +++ b/pkg/sentry/kernel/shm/shm_state_autogen.go @@ -112,27 +112,27 @@ func (s *Shm) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(16, &s.pendingDestruction) } -func (s *ShmRefs) StateTypeName() string { +func (r *ShmRefs) StateTypeName() string { return "pkg/sentry/kernel/shm.ShmRefs" } -func (s *ShmRefs) StateFields() []string { +func (r *ShmRefs) StateFields() []string { return []string{ "refCount", } } -func (s *ShmRefs) beforeSave() {} +func (r *ShmRefs) beforeSave() {} -func (s *ShmRefs) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.refCount) +func (r *ShmRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (s *ShmRefs) afterLoad() {} +func (r *ShmRefs) afterLoad() {} -func (s *ShmRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.refCount) +func (r *ShmRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } func init() { diff --git a/pkg/sentry/memmap/memmap_impl_state_autogen.go b/pkg/sentry/memmap/memmap_impl_state_autogen.go index e6fcd3582..c77b19e77 100644 --- a/pkg/sentry/memmap/memmap_impl_state_autogen.go +++ b/pkg/sentry/memmap/memmap_impl_state_autogen.go @@ -6,35 +6,35 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (m *MappingSet) StateTypeName() string { +func (s *MappingSet) StateTypeName() string { return "pkg/sentry/memmap.MappingSet" } -func (m *MappingSet) StateFields() []string { +func (s *MappingSet) StateFields() []string { return []string{ "root", } } -func (m *MappingSet) beforeSave() {} +func (s *MappingSet) beforeSave() {} -func (m *MappingSet) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - var rootValue *MappingSegmentDataSlices = m.saveRoot() +func (s *MappingSet) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + var rootValue *MappingSegmentDataSlices = s.saveRoot() stateSinkObject.SaveValue(0, rootValue) } -func (m *MappingSet) afterLoad() {} +func (s *MappingSet) afterLoad() {} -func (m *MappingSet) StateLoad(stateSourceObject state.Source) { - stateSourceObject.LoadValue(0, new(*MappingSegmentDataSlices), func(y interface{}) { m.loadRoot(y.(*MappingSegmentDataSlices)) }) +func (s *MappingSet) StateLoad(stateSourceObject state.Source) { + stateSourceObject.LoadValue(0, new(*MappingSegmentDataSlices), func(y interface{}) { s.loadRoot(y.(*MappingSegmentDataSlices)) }) } -func (m *Mappingnode) StateTypeName() string { +func (n *Mappingnode) StateTypeName() string { return "pkg/sentry/memmap.Mappingnode" } -func (m *Mappingnode) StateFields() []string { +func (n *Mappingnode) StateFields() []string { return []string{ "nrSegments", "parent", @@ -47,31 +47,31 @@ func (m *Mappingnode) StateFields() []string { } } -func (m *Mappingnode) beforeSave() {} - -func (m *Mappingnode) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.nrSegments) - stateSinkObject.Save(1, &m.parent) - stateSinkObject.Save(2, &m.parentIndex) - stateSinkObject.Save(3, &m.hasChildren) - stateSinkObject.Save(4, &m.maxGap) - stateSinkObject.Save(5, &m.keys) - stateSinkObject.Save(6, &m.values) - stateSinkObject.Save(7, &m.children) +func (n *Mappingnode) beforeSave() {} + +func (n *Mappingnode) StateSave(stateSinkObject state.Sink) { + n.beforeSave() + stateSinkObject.Save(0, &n.nrSegments) + stateSinkObject.Save(1, &n.parent) + stateSinkObject.Save(2, &n.parentIndex) + stateSinkObject.Save(3, &n.hasChildren) + stateSinkObject.Save(4, &n.maxGap) + stateSinkObject.Save(5, &n.keys) + stateSinkObject.Save(6, &n.values) + stateSinkObject.Save(7, &n.children) } -func (m *Mappingnode) afterLoad() {} - -func (m *Mappingnode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.nrSegments) - stateSourceObject.Load(1, &m.parent) - stateSourceObject.Load(2, &m.parentIndex) - stateSourceObject.Load(3, &m.hasChildren) - stateSourceObject.Load(4, &m.maxGap) - stateSourceObject.Load(5, &m.keys) - stateSourceObject.Load(6, &m.values) - stateSourceObject.Load(7, &m.children) +func (n *Mappingnode) afterLoad() {} + +func (n *Mappingnode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &n.nrSegments) + stateSourceObject.Load(1, &n.parent) + stateSourceObject.Load(2, &n.parentIndex) + stateSourceObject.Load(3, &n.hasChildren) + stateSourceObject.Load(4, &n.maxGap) + stateSourceObject.Load(5, &n.keys) + stateSourceObject.Load(6, &n.values) + stateSourceObject.Load(7, &n.children) } func (m *MappingSegmentDataSlices) StateTypeName() string { diff --git a/pkg/sentry/memmap/memmap_state_autogen.go b/pkg/sentry/memmap/memmap_state_autogen.go index 55ccf8cfd..7d52a10b2 100644 --- a/pkg/sentry/memmap/memmap_state_autogen.go +++ b/pkg/sentry/memmap/memmap_state_autogen.go @@ -6,63 +6,63 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (f *FileRange) StateTypeName() string { +func (fr *FileRange) StateTypeName() string { return "pkg/sentry/memmap.FileRange" } -func (f *FileRange) StateFields() []string { +func (fr *FileRange) StateFields() []string { return []string{ "Start", "End", } } -func (f *FileRange) beforeSave() {} +func (fr *FileRange) beforeSave() {} -func (f *FileRange) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.Start) - stateSinkObject.Save(1, &f.End) +func (fr *FileRange) StateSave(stateSinkObject state.Sink) { + fr.beforeSave() + stateSinkObject.Save(0, &fr.Start) + stateSinkObject.Save(1, &fr.End) } -func (f *FileRange) afterLoad() {} +func (fr *FileRange) afterLoad() {} -func (f *FileRange) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.Start) - stateSourceObject.Load(1, &f.End) +func (fr *FileRange) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fr.Start) + stateSourceObject.Load(1, &fr.End) } -func (m *MappableRange) StateTypeName() string { +func (mr *MappableRange) StateTypeName() string { return "pkg/sentry/memmap.MappableRange" } -func (m *MappableRange) StateFields() []string { +func (mr *MappableRange) StateFields() []string { return []string{ "Start", "End", } } -func (m *MappableRange) beforeSave() {} +func (mr *MappableRange) beforeSave() {} -func (m *MappableRange) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.Start) - stateSinkObject.Save(1, &m.End) +func (mr *MappableRange) StateSave(stateSinkObject state.Sink) { + mr.beforeSave() + stateSinkObject.Save(0, &mr.Start) + stateSinkObject.Save(1, &mr.End) } -func (m *MappableRange) afterLoad() {} +func (mr *MappableRange) afterLoad() {} -func (m *MappableRange) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.Start) - stateSourceObject.Load(1, &m.End) +func (mr *MappableRange) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &mr.Start) + stateSourceObject.Load(1, &mr.End) } -func (m *MappingOfRange) StateTypeName() string { +func (r *MappingOfRange) StateTypeName() string { return "pkg/sentry/memmap.MappingOfRange" } -func (m *MappingOfRange) StateFields() []string { +func (r *MappingOfRange) StateFields() []string { return []string{ "MappingSpace", "AddrRange", @@ -70,21 +70,21 @@ func (m *MappingOfRange) StateFields() []string { } } -func (m *MappingOfRange) beforeSave() {} +func (r *MappingOfRange) beforeSave() {} -func (m *MappingOfRange) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.MappingSpace) - stateSinkObject.Save(1, &m.AddrRange) - stateSinkObject.Save(2, &m.Writable) +func (r *MappingOfRange) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.MappingSpace) + stateSinkObject.Save(1, &r.AddrRange) + stateSinkObject.Save(2, &r.Writable) } -func (m *MappingOfRange) afterLoad() {} +func (r *MappingOfRange) afterLoad() {} -func (m *MappingOfRange) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.MappingSpace) - stateSourceObject.Load(1, &m.AddrRange) - stateSourceObject.Load(2, &m.Writable) +func (r *MappingOfRange) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.MappingSpace) + stateSourceObject.Load(1, &r.AddrRange) + stateSourceObject.Load(2, &r.Writable) } func init() { diff --git a/pkg/sentry/mm/mm_state_autogen.go b/pkg/sentry/mm/mm_state_autogen.go index 1fe9dfd7f..78d8fe7f9 100644 --- a/pkg/sentry/mm/mm_state_autogen.go +++ b/pkg/sentry/mm/mm_state_autogen.go @@ -86,11 +86,11 @@ func (a *AIOContext) StateLoad(stateSourceObject state.Source) { stateSourceObject.AfterLoad(a.afterLoad) } -func (a *aioMappable) StateTypeName() string { +func (m *aioMappable) StateTypeName() string { return "pkg/sentry/mm.aioMappable" } -func (a *aioMappable) StateFields() []string { +func (m *aioMappable) StateFields() []string { return []string{ "aioMappableRefs", "mfp", @@ -98,75 +98,75 @@ func (a *aioMappable) StateFields() []string { } } -func (a *aioMappable) beforeSave() {} +func (m *aioMappable) beforeSave() {} -func (a *aioMappable) StateSave(stateSinkObject state.Sink) { - a.beforeSave() - stateSinkObject.Save(0, &a.aioMappableRefs) - stateSinkObject.Save(1, &a.mfp) - stateSinkObject.Save(2, &a.fr) +func (m *aioMappable) StateSave(stateSinkObject state.Sink) { + m.beforeSave() + stateSinkObject.Save(0, &m.aioMappableRefs) + stateSinkObject.Save(1, &m.mfp) + stateSinkObject.Save(2, &m.fr) } -func (a *aioMappable) afterLoad() {} +func (m *aioMappable) afterLoad() {} -func (a *aioMappable) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &a.aioMappableRefs) - stateSourceObject.Load(1, &a.mfp) - stateSourceObject.Load(2, &a.fr) +func (m *aioMappable) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &m.aioMappableRefs) + stateSourceObject.Load(1, &m.mfp) + stateSourceObject.Load(2, &m.fr) } -func (a *aioMappableRefs) StateTypeName() string { +func (r *aioMappableRefs) StateTypeName() string { return "pkg/sentry/mm.aioMappableRefs" } -func (a *aioMappableRefs) StateFields() []string { +func (r *aioMappableRefs) StateFields() []string { return []string{ "refCount", } } -func (a *aioMappableRefs) beforeSave() {} +func (r *aioMappableRefs) beforeSave() {} -func (a *aioMappableRefs) StateSave(stateSinkObject state.Sink) { - a.beforeSave() - stateSinkObject.Save(0, &a.refCount) +func (r *aioMappableRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (a *aioMappableRefs) afterLoad() {} +func (r *aioMappableRefs) afterLoad() {} -func (a *aioMappableRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &a.refCount) +func (r *aioMappableRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } -func (f *fileRefcountSet) StateTypeName() string { +func (s *fileRefcountSet) StateTypeName() string { return "pkg/sentry/mm.fileRefcountSet" } -func (f *fileRefcountSet) StateFields() []string { +func (s *fileRefcountSet) StateFields() []string { return []string{ "root", } } -func (f *fileRefcountSet) beforeSave() {} +func (s *fileRefcountSet) beforeSave() {} -func (f *fileRefcountSet) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - var rootValue *fileRefcountSegmentDataSlices = f.saveRoot() +func (s *fileRefcountSet) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + var rootValue *fileRefcountSegmentDataSlices = s.saveRoot() stateSinkObject.SaveValue(0, rootValue) } -func (f *fileRefcountSet) afterLoad() {} +func (s *fileRefcountSet) afterLoad() {} -func (f *fileRefcountSet) StateLoad(stateSourceObject state.Source) { - stateSourceObject.LoadValue(0, new(*fileRefcountSegmentDataSlices), func(y interface{}) { f.loadRoot(y.(*fileRefcountSegmentDataSlices)) }) +func (s *fileRefcountSet) StateLoad(stateSourceObject state.Source) { + stateSourceObject.LoadValue(0, new(*fileRefcountSegmentDataSlices), func(y interface{}) { s.loadRoot(y.(*fileRefcountSegmentDataSlices)) }) } -func (f *fileRefcountnode) StateTypeName() string { +func (n *fileRefcountnode) StateTypeName() string { return "pkg/sentry/mm.fileRefcountnode" } -func (f *fileRefcountnode) StateFields() []string { +func (n *fileRefcountnode) StateFields() []string { return []string{ "nrSegments", "parent", @@ -179,31 +179,31 @@ func (f *fileRefcountnode) StateFields() []string { } } -func (f *fileRefcountnode) beforeSave() {} +func (n *fileRefcountnode) beforeSave() {} -func (f *fileRefcountnode) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.nrSegments) - stateSinkObject.Save(1, &f.parent) - stateSinkObject.Save(2, &f.parentIndex) - stateSinkObject.Save(3, &f.hasChildren) - stateSinkObject.Save(4, &f.maxGap) - stateSinkObject.Save(5, &f.keys) - stateSinkObject.Save(6, &f.values) - stateSinkObject.Save(7, &f.children) +func (n *fileRefcountnode) StateSave(stateSinkObject state.Sink) { + n.beforeSave() + stateSinkObject.Save(0, &n.nrSegments) + stateSinkObject.Save(1, &n.parent) + stateSinkObject.Save(2, &n.parentIndex) + stateSinkObject.Save(3, &n.hasChildren) + stateSinkObject.Save(4, &n.maxGap) + stateSinkObject.Save(5, &n.keys) + stateSinkObject.Save(6, &n.values) + stateSinkObject.Save(7, &n.children) } -func (f *fileRefcountnode) afterLoad() {} +func (n *fileRefcountnode) afterLoad() {} -func (f *fileRefcountnode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.nrSegments) - stateSourceObject.Load(1, &f.parent) - stateSourceObject.Load(2, &f.parentIndex) - stateSourceObject.Load(3, &f.hasChildren) - stateSourceObject.Load(4, &f.maxGap) - stateSourceObject.Load(5, &f.keys) - stateSourceObject.Load(6, &f.values) - stateSourceObject.Load(7, &f.children) +func (n *fileRefcountnode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &n.nrSegments) + stateSourceObject.Load(1, &n.parent) + stateSourceObject.Load(2, &n.parentIndex) + stateSourceObject.Load(3, &n.hasChildren) + stateSourceObject.Load(4, &n.maxGap) + stateSourceObject.Load(5, &n.keys) + stateSourceObject.Load(6, &n.values) + stateSourceObject.Load(7, &n.children) } func (f *fileRefcountSegmentDataSlices) StateTypeName() string { @@ -235,63 +235,63 @@ func (f *fileRefcountSegmentDataSlices) StateLoad(stateSourceObject state.Source stateSourceObject.Load(2, &f.Values) } -func (i *ioList) StateTypeName() string { +func (l *ioList) StateTypeName() string { return "pkg/sentry/mm.ioList" } -func (i *ioList) StateFields() []string { +func (l *ioList) StateFields() []string { return []string{ "head", "tail", } } -func (i *ioList) beforeSave() {} +func (l *ioList) beforeSave() {} -func (i *ioList) StateSave(stateSinkObject state.Sink) { - i.beforeSave() - stateSinkObject.Save(0, &i.head) - stateSinkObject.Save(1, &i.tail) +func (l *ioList) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.head) + stateSinkObject.Save(1, &l.tail) } -func (i *ioList) afterLoad() {} +func (l *ioList) afterLoad() {} -func (i *ioList) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &i.head) - stateSourceObject.Load(1, &i.tail) +func (l *ioList) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.head) + stateSourceObject.Load(1, &l.tail) } -func (i *ioEntry) StateTypeName() string { +func (e *ioEntry) StateTypeName() string { return "pkg/sentry/mm.ioEntry" } -func (i *ioEntry) StateFields() []string { +func (e *ioEntry) StateFields() []string { return []string{ "next", "prev", } } -func (i *ioEntry) beforeSave() {} +func (e *ioEntry) beforeSave() {} -func (i *ioEntry) StateSave(stateSinkObject state.Sink) { - i.beforeSave() - stateSinkObject.Save(0, &i.next) - stateSinkObject.Save(1, &i.prev) +func (e *ioEntry) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.next) + stateSinkObject.Save(1, &e.prev) } -func (i *ioEntry) afterLoad() {} +func (e *ioEntry) afterLoad() {} -func (i *ioEntry) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &i.next) - stateSourceObject.Load(1, &i.prev) +func (e *ioEntry) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.next) + stateSourceObject.Load(1, &e.prev) } -func (m *MemoryManager) StateTypeName() string { +func (mm *MemoryManager) StateTypeName() string { return "pkg/sentry/mm.MemoryManager" } -func (m *MemoryManager) StateFields() []string { +func (mm *MemoryManager) StateFields() []string { return []string{ "p", "mfp", @@ -320,73 +320,73 @@ func (m *MemoryManager) StateFields() []string { } } -func (m *MemoryManager) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - if !state.IsZeroValue(&m.active) { - state.Failf("active is %#v, expected zero", &m.active) +func (mm *MemoryManager) StateSave(stateSinkObject state.Sink) { + mm.beforeSave() + if !state.IsZeroValue(&mm.active) { + state.Failf("active is %#v, expected zero", &mm.active) } - if !state.IsZeroValue(&m.captureInvalidations) { - state.Failf("captureInvalidations is %#v, expected zero", &m.captureInvalidations) + if !state.IsZeroValue(&mm.captureInvalidations) { + state.Failf("captureInvalidations is %#v, expected zero", &mm.captureInvalidations) } - stateSinkObject.Save(0, &m.p) - stateSinkObject.Save(1, &m.mfp) - stateSinkObject.Save(2, &m.layout) - stateSinkObject.Save(3, &m.privateRefs) - stateSinkObject.Save(4, &m.users) - stateSinkObject.Save(5, &m.vmas) - stateSinkObject.Save(6, &m.brk) - stateSinkObject.Save(7, &m.usageAS) - stateSinkObject.Save(8, &m.lockedAS) - stateSinkObject.Save(9, &m.dataAS) - stateSinkObject.Save(10, &m.defMLockMode) - stateSinkObject.Save(11, &m.pmas) - stateSinkObject.Save(12, &m.curRSS) - stateSinkObject.Save(13, &m.maxRSS) - stateSinkObject.Save(14, &m.argv) - stateSinkObject.Save(15, &m.envv) - stateSinkObject.Save(16, &m.auxv) - stateSinkObject.Save(17, &m.executable) - stateSinkObject.Save(18, &m.dumpability) - stateSinkObject.Save(19, &m.aioManager) - stateSinkObject.Save(20, &m.sleepForActivation) - stateSinkObject.Save(21, &m.vdsoSigReturnAddr) - stateSinkObject.Save(22, &m.membarrierPrivateEnabled) - stateSinkObject.Save(23, &m.membarrierRSeqEnabled) -} - -func (m *MemoryManager) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.p) - stateSourceObject.Load(1, &m.mfp) - stateSourceObject.Load(2, &m.layout) - stateSourceObject.Load(3, &m.privateRefs) - stateSourceObject.Load(4, &m.users) - stateSourceObject.Load(5, &m.vmas) - stateSourceObject.Load(6, &m.brk) - stateSourceObject.Load(7, &m.usageAS) - stateSourceObject.Load(8, &m.lockedAS) - stateSourceObject.Load(9, &m.dataAS) - stateSourceObject.Load(10, &m.defMLockMode) - stateSourceObject.Load(11, &m.pmas) - stateSourceObject.Load(12, &m.curRSS) - stateSourceObject.Load(13, &m.maxRSS) - stateSourceObject.Load(14, &m.argv) - stateSourceObject.Load(15, &m.envv) - stateSourceObject.Load(16, &m.auxv) - stateSourceObject.Load(17, &m.executable) - stateSourceObject.Load(18, &m.dumpability) - stateSourceObject.Load(19, &m.aioManager) - stateSourceObject.Load(20, &m.sleepForActivation) - stateSourceObject.Load(21, &m.vdsoSigReturnAddr) - stateSourceObject.Load(22, &m.membarrierPrivateEnabled) - stateSourceObject.Load(23, &m.membarrierRSeqEnabled) - stateSourceObject.AfterLoad(m.afterLoad) -} - -func (v *vma) StateTypeName() string { + stateSinkObject.Save(0, &mm.p) + stateSinkObject.Save(1, &mm.mfp) + stateSinkObject.Save(2, &mm.layout) + stateSinkObject.Save(3, &mm.privateRefs) + stateSinkObject.Save(4, &mm.users) + stateSinkObject.Save(5, &mm.vmas) + stateSinkObject.Save(6, &mm.brk) + stateSinkObject.Save(7, &mm.usageAS) + stateSinkObject.Save(8, &mm.lockedAS) + stateSinkObject.Save(9, &mm.dataAS) + stateSinkObject.Save(10, &mm.defMLockMode) + stateSinkObject.Save(11, &mm.pmas) + stateSinkObject.Save(12, &mm.curRSS) + stateSinkObject.Save(13, &mm.maxRSS) + stateSinkObject.Save(14, &mm.argv) + stateSinkObject.Save(15, &mm.envv) + stateSinkObject.Save(16, &mm.auxv) + stateSinkObject.Save(17, &mm.executable) + stateSinkObject.Save(18, &mm.dumpability) + stateSinkObject.Save(19, &mm.aioManager) + stateSinkObject.Save(20, &mm.sleepForActivation) + stateSinkObject.Save(21, &mm.vdsoSigReturnAddr) + stateSinkObject.Save(22, &mm.membarrierPrivateEnabled) + stateSinkObject.Save(23, &mm.membarrierRSeqEnabled) +} + +func (mm *MemoryManager) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &mm.p) + stateSourceObject.Load(1, &mm.mfp) + stateSourceObject.Load(2, &mm.layout) + stateSourceObject.Load(3, &mm.privateRefs) + stateSourceObject.Load(4, &mm.users) + stateSourceObject.Load(5, &mm.vmas) + stateSourceObject.Load(6, &mm.brk) + stateSourceObject.Load(7, &mm.usageAS) + stateSourceObject.Load(8, &mm.lockedAS) + stateSourceObject.Load(9, &mm.dataAS) + stateSourceObject.Load(10, &mm.defMLockMode) + stateSourceObject.Load(11, &mm.pmas) + stateSourceObject.Load(12, &mm.curRSS) + stateSourceObject.Load(13, &mm.maxRSS) + stateSourceObject.Load(14, &mm.argv) + stateSourceObject.Load(15, &mm.envv) + stateSourceObject.Load(16, &mm.auxv) + stateSourceObject.Load(17, &mm.executable) + stateSourceObject.Load(18, &mm.dumpability) + stateSourceObject.Load(19, &mm.aioManager) + stateSourceObject.Load(20, &mm.sleepForActivation) + stateSourceObject.Load(21, &mm.vdsoSigReturnAddr) + stateSourceObject.Load(22, &mm.membarrierPrivateEnabled) + stateSourceObject.Load(23, &mm.membarrierRSeqEnabled) + stateSourceObject.AfterLoad(mm.afterLoad) +} + +func (vma *vma) StateTypeName() string { return "pkg/sentry/mm.vma" } -func (v *vma) StateFields() []string { +func (vma *vma) StateFields() []string { return []string{ "mappable", "off", @@ -400,34 +400,34 @@ func (v *vma) StateFields() []string { } } -func (v *vma) beforeSave() {} +func (vma *vma) beforeSave() {} -func (v *vma) StateSave(stateSinkObject state.Sink) { - v.beforeSave() - var realPermsValue int = v.saveRealPerms() +func (vma *vma) StateSave(stateSinkObject state.Sink) { + vma.beforeSave() + var realPermsValue int = vma.saveRealPerms() stateSinkObject.SaveValue(2, realPermsValue) - stateSinkObject.Save(0, &v.mappable) - stateSinkObject.Save(1, &v.off) - stateSinkObject.Save(3, &v.dontfork) - stateSinkObject.Save(4, &v.mlockMode) - stateSinkObject.Save(5, &v.numaPolicy) - stateSinkObject.Save(6, &v.numaNodemask) - stateSinkObject.Save(7, &v.id) - stateSinkObject.Save(8, &v.hint) -} - -func (v *vma) afterLoad() {} - -func (v *vma) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &v.mappable) - stateSourceObject.Load(1, &v.off) - stateSourceObject.Load(3, &v.dontfork) - stateSourceObject.Load(4, &v.mlockMode) - stateSourceObject.Load(5, &v.numaPolicy) - stateSourceObject.Load(6, &v.numaNodemask) - stateSourceObject.Load(7, &v.id) - stateSourceObject.Load(8, &v.hint) - stateSourceObject.LoadValue(2, new(int), func(y interface{}) { v.loadRealPerms(y.(int)) }) + stateSinkObject.Save(0, &vma.mappable) + stateSinkObject.Save(1, &vma.off) + stateSinkObject.Save(3, &vma.dontfork) + stateSinkObject.Save(4, &vma.mlockMode) + stateSinkObject.Save(5, &vma.numaPolicy) + stateSinkObject.Save(6, &vma.numaNodemask) + stateSinkObject.Save(7, &vma.id) + stateSinkObject.Save(8, &vma.hint) +} + +func (vma *vma) afterLoad() {} + +func (vma *vma) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &vma.mappable) + stateSourceObject.Load(1, &vma.off) + stateSourceObject.Load(3, &vma.dontfork) + stateSourceObject.Load(4, &vma.mlockMode) + stateSourceObject.Load(5, &vma.numaPolicy) + stateSourceObject.Load(6, &vma.numaNodemask) + stateSourceObject.Load(7, &vma.id) + stateSourceObject.Load(8, &vma.hint) + stateSourceObject.LoadValue(2, new(int), func(y interface{}) { vma.loadRealPerms(y.(int)) }) } func (p *pma) StateTypeName() string { @@ -491,35 +491,35 @@ func (p *privateRefs) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(0, &p.refs) } -func (p *pmaSet) StateTypeName() string { +func (s *pmaSet) StateTypeName() string { return "pkg/sentry/mm.pmaSet" } -func (p *pmaSet) StateFields() []string { +func (s *pmaSet) StateFields() []string { return []string{ "root", } } -func (p *pmaSet) beforeSave() {} +func (s *pmaSet) beforeSave() {} -func (p *pmaSet) StateSave(stateSinkObject state.Sink) { - p.beforeSave() - var rootValue *pmaSegmentDataSlices = p.saveRoot() +func (s *pmaSet) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + var rootValue *pmaSegmentDataSlices = s.saveRoot() stateSinkObject.SaveValue(0, rootValue) } -func (p *pmaSet) afterLoad() {} +func (s *pmaSet) afterLoad() {} -func (p *pmaSet) StateLoad(stateSourceObject state.Source) { - stateSourceObject.LoadValue(0, new(*pmaSegmentDataSlices), func(y interface{}) { p.loadRoot(y.(*pmaSegmentDataSlices)) }) +func (s *pmaSet) StateLoad(stateSourceObject state.Source) { + stateSourceObject.LoadValue(0, new(*pmaSegmentDataSlices), func(y interface{}) { s.loadRoot(y.(*pmaSegmentDataSlices)) }) } -func (p *pmanode) StateTypeName() string { +func (n *pmanode) StateTypeName() string { return "pkg/sentry/mm.pmanode" } -func (p *pmanode) StateFields() []string { +func (n *pmanode) StateFields() []string { return []string{ "nrSegments", "parent", @@ -532,31 +532,31 @@ func (p *pmanode) StateFields() []string { } } -func (p *pmanode) beforeSave() {} +func (n *pmanode) beforeSave() {} -func (p *pmanode) StateSave(stateSinkObject state.Sink) { - p.beforeSave() - stateSinkObject.Save(0, &p.nrSegments) - stateSinkObject.Save(1, &p.parent) - stateSinkObject.Save(2, &p.parentIndex) - stateSinkObject.Save(3, &p.hasChildren) - stateSinkObject.Save(4, &p.maxGap) - stateSinkObject.Save(5, &p.keys) - stateSinkObject.Save(6, &p.values) - stateSinkObject.Save(7, &p.children) +func (n *pmanode) StateSave(stateSinkObject state.Sink) { + n.beforeSave() + stateSinkObject.Save(0, &n.nrSegments) + stateSinkObject.Save(1, &n.parent) + stateSinkObject.Save(2, &n.parentIndex) + stateSinkObject.Save(3, &n.hasChildren) + stateSinkObject.Save(4, &n.maxGap) + stateSinkObject.Save(5, &n.keys) + stateSinkObject.Save(6, &n.values) + stateSinkObject.Save(7, &n.children) } -func (p *pmanode) afterLoad() {} +func (n *pmanode) afterLoad() {} -func (p *pmanode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &p.nrSegments) - stateSourceObject.Load(1, &p.parent) - stateSourceObject.Load(2, &p.parentIndex) - stateSourceObject.Load(3, &p.hasChildren) - stateSourceObject.Load(4, &p.maxGap) - stateSourceObject.Load(5, &p.keys) - stateSourceObject.Load(6, &p.values) - stateSourceObject.Load(7, &p.children) +func (n *pmanode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &n.nrSegments) + stateSourceObject.Load(1, &n.parent) + stateSourceObject.Load(2, &n.parentIndex) + stateSourceObject.Load(3, &n.hasChildren) + stateSourceObject.Load(4, &n.maxGap) + stateSourceObject.Load(5, &n.keys) + stateSourceObject.Load(6, &n.values) + stateSourceObject.Load(7, &n.children) } func (p *pmaSegmentDataSlices) StateTypeName() string { @@ -588,11 +588,11 @@ func (p *pmaSegmentDataSlices) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(2, &p.Values) } -func (s *SpecialMappable) StateTypeName() string { +func (m *SpecialMappable) StateTypeName() string { return "pkg/sentry/mm.SpecialMappable" } -func (s *SpecialMappable) StateFields() []string { +func (m *SpecialMappable) StateFields() []string { return []string{ "SpecialMappableRefs", "mfp", @@ -601,77 +601,77 @@ func (s *SpecialMappable) StateFields() []string { } } -func (s *SpecialMappable) beforeSave() {} +func (m *SpecialMappable) beforeSave() {} -func (s *SpecialMappable) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.SpecialMappableRefs) - stateSinkObject.Save(1, &s.mfp) - stateSinkObject.Save(2, &s.fr) - stateSinkObject.Save(3, &s.name) +func (m *SpecialMappable) StateSave(stateSinkObject state.Sink) { + m.beforeSave() + stateSinkObject.Save(0, &m.SpecialMappableRefs) + stateSinkObject.Save(1, &m.mfp) + stateSinkObject.Save(2, &m.fr) + stateSinkObject.Save(3, &m.name) } -func (s *SpecialMappable) afterLoad() {} +func (m *SpecialMappable) afterLoad() {} -func (s *SpecialMappable) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.SpecialMappableRefs) - stateSourceObject.Load(1, &s.mfp) - stateSourceObject.Load(2, &s.fr) - stateSourceObject.Load(3, &s.name) +func (m *SpecialMappable) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &m.SpecialMappableRefs) + stateSourceObject.Load(1, &m.mfp) + stateSourceObject.Load(2, &m.fr) + stateSourceObject.Load(3, &m.name) } -func (s *SpecialMappableRefs) StateTypeName() string { +func (r *SpecialMappableRefs) StateTypeName() string { return "pkg/sentry/mm.SpecialMappableRefs" } -func (s *SpecialMappableRefs) StateFields() []string { +func (r *SpecialMappableRefs) StateFields() []string { return []string{ "refCount", } } -func (s *SpecialMappableRefs) beforeSave() {} +func (r *SpecialMappableRefs) beforeSave() {} -func (s *SpecialMappableRefs) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.refCount) +func (r *SpecialMappableRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (s *SpecialMappableRefs) afterLoad() {} +func (r *SpecialMappableRefs) afterLoad() {} -func (s *SpecialMappableRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.refCount) +func (r *SpecialMappableRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } -func (v *vmaSet) StateTypeName() string { +func (s *vmaSet) StateTypeName() string { return "pkg/sentry/mm.vmaSet" } -func (v *vmaSet) StateFields() []string { +func (s *vmaSet) StateFields() []string { return []string{ "root", } } -func (v *vmaSet) beforeSave() {} +func (s *vmaSet) beforeSave() {} -func (v *vmaSet) StateSave(stateSinkObject state.Sink) { - v.beforeSave() - var rootValue *vmaSegmentDataSlices = v.saveRoot() +func (s *vmaSet) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + var rootValue *vmaSegmentDataSlices = s.saveRoot() stateSinkObject.SaveValue(0, rootValue) } -func (v *vmaSet) afterLoad() {} +func (s *vmaSet) afterLoad() {} -func (v *vmaSet) StateLoad(stateSourceObject state.Source) { - stateSourceObject.LoadValue(0, new(*vmaSegmentDataSlices), func(y interface{}) { v.loadRoot(y.(*vmaSegmentDataSlices)) }) +func (s *vmaSet) StateLoad(stateSourceObject state.Source) { + stateSourceObject.LoadValue(0, new(*vmaSegmentDataSlices), func(y interface{}) { s.loadRoot(y.(*vmaSegmentDataSlices)) }) } -func (v *vmanode) StateTypeName() string { +func (n *vmanode) StateTypeName() string { return "pkg/sentry/mm.vmanode" } -func (v *vmanode) StateFields() []string { +func (n *vmanode) StateFields() []string { return []string{ "nrSegments", "parent", @@ -684,31 +684,31 @@ func (v *vmanode) StateFields() []string { } } -func (v *vmanode) beforeSave() {} +func (n *vmanode) beforeSave() {} -func (v *vmanode) StateSave(stateSinkObject state.Sink) { - v.beforeSave() - stateSinkObject.Save(0, &v.nrSegments) - stateSinkObject.Save(1, &v.parent) - stateSinkObject.Save(2, &v.parentIndex) - stateSinkObject.Save(3, &v.hasChildren) - stateSinkObject.Save(4, &v.maxGap) - stateSinkObject.Save(5, &v.keys) - stateSinkObject.Save(6, &v.values) - stateSinkObject.Save(7, &v.children) -} - -func (v *vmanode) afterLoad() {} - -func (v *vmanode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &v.nrSegments) - stateSourceObject.Load(1, &v.parent) - stateSourceObject.Load(2, &v.parentIndex) - stateSourceObject.Load(3, &v.hasChildren) - stateSourceObject.Load(4, &v.maxGap) - stateSourceObject.Load(5, &v.keys) - stateSourceObject.Load(6, &v.values) - stateSourceObject.Load(7, &v.children) +func (n *vmanode) StateSave(stateSinkObject state.Sink) { + n.beforeSave() + stateSinkObject.Save(0, &n.nrSegments) + stateSinkObject.Save(1, &n.parent) + stateSinkObject.Save(2, &n.parentIndex) + stateSinkObject.Save(3, &n.hasChildren) + stateSinkObject.Save(4, &n.maxGap) + stateSinkObject.Save(5, &n.keys) + stateSinkObject.Save(6, &n.values) + stateSinkObject.Save(7, &n.children) +} + +func (n *vmanode) afterLoad() {} + +func (n *vmanode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &n.nrSegments) + stateSourceObject.Load(1, &n.parent) + stateSourceObject.Load(2, &n.parentIndex) + stateSourceObject.Load(3, &n.hasChildren) + stateSourceObject.Load(4, &n.maxGap) + stateSourceObject.Load(5, &n.keys) + stateSourceObject.Load(6, &n.values) + stateSourceObject.Load(7, &n.children) } func (v *vmaSegmentDataSlices) StateTypeName() string { diff --git a/pkg/sentry/pgalloc/pgalloc_state_autogen.go b/pkg/sentry/pgalloc/pgalloc_state_autogen.go index d3ce10163..d33710cab 100644 --- a/pkg/sentry/pgalloc/pgalloc_state_autogen.go +++ b/pkg/sentry/pgalloc/pgalloc_state_autogen.go @@ -6,61 +6,61 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (e *EvictableRange) StateTypeName() string { +func (r *EvictableRange) StateTypeName() string { return "pkg/sentry/pgalloc.EvictableRange" } -func (e *EvictableRange) StateFields() []string { +func (r *EvictableRange) StateFields() []string { return []string{ "Start", "End", } } -func (e *EvictableRange) beforeSave() {} +func (r *EvictableRange) beforeSave() {} -func (e *EvictableRange) StateSave(stateSinkObject state.Sink) { - e.beforeSave() - stateSinkObject.Save(0, &e.Start) - stateSinkObject.Save(1, &e.End) +func (r *EvictableRange) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.Start) + stateSinkObject.Save(1, &r.End) } -func (e *EvictableRange) afterLoad() {} +func (r *EvictableRange) afterLoad() {} -func (e *EvictableRange) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &e.Start) - stateSourceObject.Load(1, &e.End) +func (r *EvictableRange) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.Start) + stateSourceObject.Load(1, &r.End) } -func (e *evictableRangeSet) StateTypeName() string { +func (s *evictableRangeSet) StateTypeName() string { return "pkg/sentry/pgalloc.evictableRangeSet" } -func (e *evictableRangeSet) StateFields() []string { +func (s *evictableRangeSet) StateFields() []string { return []string{ "root", } } -func (e *evictableRangeSet) beforeSave() {} +func (s *evictableRangeSet) beforeSave() {} -func (e *evictableRangeSet) StateSave(stateSinkObject state.Sink) { - e.beforeSave() - var rootValue *evictableRangeSegmentDataSlices = e.saveRoot() +func (s *evictableRangeSet) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + var rootValue *evictableRangeSegmentDataSlices = s.saveRoot() stateSinkObject.SaveValue(0, rootValue) } -func (e *evictableRangeSet) afterLoad() {} +func (s *evictableRangeSet) afterLoad() {} -func (e *evictableRangeSet) StateLoad(stateSourceObject state.Source) { - stateSourceObject.LoadValue(0, new(*evictableRangeSegmentDataSlices), func(y interface{}) { e.loadRoot(y.(*evictableRangeSegmentDataSlices)) }) +func (s *evictableRangeSet) StateLoad(stateSourceObject state.Source) { + stateSourceObject.LoadValue(0, new(*evictableRangeSegmentDataSlices), func(y interface{}) { s.loadRoot(y.(*evictableRangeSegmentDataSlices)) }) } -func (e *evictableRangenode) StateTypeName() string { +func (n *evictableRangenode) StateTypeName() string { return "pkg/sentry/pgalloc.evictableRangenode" } -func (e *evictableRangenode) StateFields() []string { +func (n *evictableRangenode) StateFields() []string { return []string{ "nrSegments", "parent", @@ -73,31 +73,31 @@ func (e *evictableRangenode) StateFields() []string { } } -func (e *evictableRangenode) beforeSave() {} +func (n *evictableRangenode) beforeSave() {} -func (e *evictableRangenode) StateSave(stateSinkObject state.Sink) { - e.beforeSave() - stateSinkObject.Save(0, &e.nrSegments) - stateSinkObject.Save(1, &e.parent) - stateSinkObject.Save(2, &e.parentIndex) - stateSinkObject.Save(3, &e.hasChildren) - stateSinkObject.Save(4, &e.maxGap) - stateSinkObject.Save(5, &e.keys) - stateSinkObject.Save(6, &e.values) - stateSinkObject.Save(7, &e.children) +func (n *evictableRangenode) StateSave(stateSinkObject state.Sink) { + n.beforeSave() + stateSinkObject.Save(0, &n.nrSegments) + stateSinkObject.Save(1, &n.parent) + stateSinkObject.Save(2, &n.parentIndex) + stateSinkObject.Save(3, &n.hasChildren) + stateSinkObject.Save(4, &n.maxGap) + stateSinkObject.Save(5, &n.keys) + stateSinkObject.Save(6, &n.values) + stateSinkObject.Save(7, &n.children) } -func (e *evictableRangenode) afterLoad() {} +func (n *evictableRangenode) afterLoad() {} -func (e *evictableRangenode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &e.nrSegments) - stateSourceObject.Load(1, &e.parent) - stateSourceObject.Load(2, &e.parentIndex) - stateSourceObject.Load(3, &e.hasChildren) - stateSourceObject.Load(4, &e.maxGap) - stateSourceObject.Load(5, &e.keys) - stateSourceObject.Load(6, &e.values) - stateSourceObject.Load(7, &e.children) +func (n *evictableRangenode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &n.nrSegments) + stateSourceObject.Load(1, &n.parent) + stateSourceObject.Load(2, &n.parentIndex) + stateSourceObject.Load(3, &n.hasChildren) + stateSourceObject.Load(4, &n.maxGap) + stateSourceObject.Load(5, &n.keys) + stateSourceObject.Load(6, &n.values) + stateSourceObject.Load(7, &n.children) } func (e *evictableRangeSegmentDataSlices) StateTypeName() string { @@ -158,35 +158,35 @@ func (u *usageInfo) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(2, &u.refs) } -func (r *reclaimSet) StateTypeName() string { +func (s *reclaimSet) StateTypeName() string { return "pkg/sentry/pgalloc.reclaimSet" } -func (r *reclaimSet) StateFields() []string { +func (s *reclaimSet) StateFields() []string { return []string{ "root", } } -func (r *reclaimSet) beforeSave() {} +func (s *reclaimSet) beforeSave() {} -func (r *reclaimSet) StateSave(stateSinkObject state.Sink) { - r.beforeSave() - var rootValue *reclaimSegmentDataSlices = r.saveRoot() +func (s *reclaimSet) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + var rootValue *reclaimSegmentDataSlices = s.saveRoot() stateSinkObject.SaveValue(0, rootValue) } -func (r *reclaimSet) afterLoad() {} +func (s *reclaimSet) afterLoad() {} -func (r *reclaimSet) StateLoad(stateSourceObject state.Source) { - stateSourceObject.LoadValue(0, new(*reclaimSegmentDataSlices), func(y interface{}) { r.loadRoot(y.(*reclaimSegmentDataSlices)) }) +func (s *reclaimSet) StateLoad(stateSourceObject state.Source) { + stateSourceObject.LoadValue(0, new(*reclaimSegmentDataSlices), func(y interface{}) { s.loadRoot(y.(*reclaimSegmentDataSlices)) }) } -func (r *reclaimnode) StateTypeName() string { +func (n *reclaimnode) StateTypeName() string { return "pkg/sentry/pgalloc.reclaimnode" } -func (r *reclaimnode) StateFields() []string { +func (n *reclaimnode) StateFields() []string { return []string{ "nrSegments", "parent", @@ -199,31 +199,31 @@ func (r *reclaimnode) StateFields() []string { } } -func (r *reclaimnode) beforeSave() {} +func (n *reclaimnode) beforeSave() {} -func (r *reclaimnode) StateSave(stateSinkObject state.Sink) { - r.beforeSave() - stateSinkObject.Save(0, &r.nrSegments) - stateSinkObject.Save(1, &r.parent) - stateSinkObject.Save(2, &r.parentIndex) - stateSinkObject.Save(3, &r.hasChildren) - stateSinkObject.Save(4, &r.maxGap) - stateSinkObject.Save(5, &r.keys) - stateSinkObject.Save(6, &r.values) - stateSinkObject.Save(7, &r.children) +func (n *reclaimnode) StateSave(stateSinkObject state.Sink) { + n.beforeSave() + stateSinkObject.Save(0, &n.nrSegments) + stateSinkObject.Save(1, &n.parent) + stateSinkObject.Save(2, &n.parentIndex) + stateSinkObject.Save(3, &n.hasChildren) + stateSinkObject.Save(4, &n.maxGap) + stateSinkObject.Save(5, &n.keys) + stateSinkObject.Save(6, &n.values) + stateSinkObject.Save(7, &n.children) } -func (r *reclaimnode) afterLoad() {} +func (n *reclaimnode) afterLoad() {} -func (r *reclaimnode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &r.nrSegments) - stateSourceObject.Load(1, &r.parent) - stateSourceObject.Load(2, &r.parentIndex) - stateSourceObject.Load(3, &r.hasChildren) - stateSourceObject.Load(4, &r.maxGap) - stateSourceObject.Load(5, &r.keys) - stateSourceObject.Load(6, &r.values) - stateSourceObject.Load(7, &r.children) +func (n *reclaimnode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &n.nrSegments) + stateSourceObject.Load(1, &n.parent) + stateSourceObject.Load(2, &n.parentIndex) + stateSourceObject.Load(3, &n.hasChildren) + stateSourceObject.Load(4, &n.maxGap) + stateSourceObject.Load(5, &n.keys) + stateSourceObject.Load(6, &n.values) + stateSourceObject.Load(7, &n.children) } func (r *reclaimSegmentDataSlices) StateTypeName() string { @@ -255,35 +255,35 @@ func (r *reclaimSegmentDataSlices) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(2, &r.Values) } -func (u *usageSet) StateTypeName() string { +func (s *usageSet) StateTypeName() string { return "pkg/sentry/pgalloc.usageSet" } -func (u *usageSet) StateFields() []string { +func (s *usageSet) StateFields() []string { return []string{ "root", } } -func (u *usageSet) beforeSave() {} +func (s *usageSet) beforeSave() {} -func (u *usageSet) StateSave(stateSinkObject state.Sink) { - u.beforeSave() - var rootValue *usageSegmentDataSlices = u.saveRoot() +func (s *usageSet) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + var rootValue *usageSegmentDataSlices = s.saveRoot() stateSinkObject.SaveValue(0, rootValue) } -func (u *usageSet) afterLoad() {} +func (s *usageSet) afterLoad() {} -func (u *usageSet) StateLoad(stateSourceObject state.Source) { - stateSourceObject.LoadValue(0, new(*usageSegmentDataSlices), func(y interface{}) { u.loadRoot(y.(*usageSegmentDataSlices)) }) +func (s *usageSet) StateLoad(stateSourceObject state.Source) { + stateSourceObject.LoadValue(0, new(*usageSegmentDataSlices), func(y interface{}) { s.loadRoot(y.(*usageSegmentDataSlices)) }) } -func (u *usagenode) StateTypeName() string { +func (n *usagenode) StateTypeName() string { return "pkg/sentry/pgalloc.usagenode" } -func (u *usagenode) StateFields() []string { +func (n *usagenode) StateFields() []string { return []string{ "nrSegments", "parent", @@ -296,31 +296,31 @@ func (u *usagenode) StateFields() []string { } } -func (u *usagenode) beforeSave() {} +func (n *usagenode) beforeSave() {} -func (u *usagenode) StateSave(stateSinkObject state.Sink) { - u.beforeSave() - stateSinkObject.Save(0, &u.nrSegments) - stateSinkObject.Save(1, &u.parent) - stateSinkObject.Save(2, &u.parentIndex) - stateSinkObject.Save(3, &u.hasChildren) - stateSinkObject.Save(4, &u.maxGap) - stateSinkObject.Save(5, &u.keys) - stateSinkObject.Save(6, &u.values) - stateSinkObject.Save(7, &u.children) -} - -func (u *usagenode) afterLoad() {} - -func (u *usagenode) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &u.nrSegments) - stateSourceObject.Load(1, &u.parent) - stateSourceObject.Load(2, &u.parentIndex) - stateSourceObject.Load(3, &u.hasChildren) - stateSourceObject.Load(4, &u.maxGap) - stateSourceObject.Load(5, &u.keys) - stateSourceObject.Load(6, &u.values) - stateSourceObject.Load(7, &u.children) +func (n *usagenode) StateSave(stateSinkObject state.Sink) { + n.beforeSave() + stateSinkObject.Save(0, &n.nrSegments) + stateSinkObject.Save(1, &n.parent) + stateSinkObject.Save(2, &n.parentIndex) + stateSinkObject.Save(3, &n.hasChildren) + stateSinkObject.Save(4, &n.maxGap) + stateSinkObject.Save(5, &n.keys) + stateSinkObject.Save(6, &n.values) + stateSinkObject.Save(7, &n.children) +} + +func (n *usagenode) afterLoad() {} + +func (n *usagenode) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &n.nrSegments) + stateSourceObject.Load(1, &n.parent) + stateSourceObject.Load(2, &n.parentIndex) + stateSourceObject.Load(3, &n.hasChildren) + stateSourceObject.Load(4, &n.maxGap) + stateSourceObject.Load(5, &n.keys) + stateSourceObject.Load(6, &n.values) + stateSourceObject.Load(7, &n.children) } func (u *usageSegmentDataSlices) StateTypeName() string { diff --git a/pkg/sentry/socket/control/control_state_autogen.go b/pkg/sentry/socket/control/control_state_autogen.go index 98cd79747..602dd37e2 100644 --- a/pkg/sentry/socket/control/control_state_autogen.go +++ b/pkg/sentry/socket/control/control_state_autogen.go @@ -6,19 +6,19 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (r *RightsFiles) StateTypeName() string { +func (fs *RightsFiles) StateTypeName() string { return "pkg/sentry/socket/control.RightsFiles" } -func (r *RightsFiles) StateFields() []string { +func (fs *RightsFiles) StateFields() []string { return nil } -func (s *scmCredentials) StateTypeName() string { +func (c *scmCredentials) StateTypeName() string { return "pkg/sentry/socket/control.scmCredentials" } -func (s *scmCredentials) StateFields() []string { +func (c *scmCredentials) StateFields() []string { return []string{ "t", "kuid", @@ -26,21 +26,21 @@ func (s *scmCredentials) StateFields() []string { } } -func (s *scmCredentials) beforeSave() {} +func (c *scmCredentials) beforeSave() {} -func (s *scmCredentials) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.t) - stateSinkObject.Save(1, &s.kuid) - stateSinkObject.Save(2, &s.kgid) +func (c *scmCredentials) StateSave(stateSinkObject state.Sink) { + c.beforeSave() + stateSinkObject.Save(0, &c.t) + stateSinkObject.Save(1, &c.kuid) + stateSinkObject.Save(2, &c.kgid) } -func (s *scmCredentials) afterLoad() {} +func (c *scmCredentials) afterLoad() {} -func (s *scmCredentials) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.t) - stateSourceObject.Load(1, &s.kuid) - stateSourceObject.Load(2, &s.kgid) +func (c *scmCredentials) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &c.t) + stateSourceObject.Load(1, &c.kuid) + stateSourceObject.Load(2, &c.kgid) } func init() { diff --git a/pkg/sentry/socket/socket_state_autogen.go b/pkg/sentry/socket/socket_state_autogen.go index e09c161ca..b5277ffab 100644 --- a/pkg/sentry/socket/socket_state_autogen.go +++ b/pkg/sentry/socket/socket_state_autogen.go @@ -6,30 +6,30 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (s *SendReceiveTimeout) StateTypeName() string { +func (to *SendReceiveTimeout) StateTypeName() string { return "pkg/sentry/socket.SendReceiveTimeout" } -func (s *SendReceiveTimeout) StateFields() []string { +func (to *SendReceiveTimeout) StateFields() []string { return []string{ "send", "recv", } } -func (s *SendReceiveTimeout) beforeSave() {} +func (to *SendReceiveTimeout) beforeSave() {} -func (s *SendReceiveTimeout) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.send) - stateSinkObject.Save(1, &s.recv) +func (to *SendReceiveTimeout) StateSave(stateSinkObject state.Sink) { + to.beforeSave() + stateSinkObject.Save(0, &to.send) + stateSinkObject.Save(1, &to.recv) } -func (s *SendReceiveTimeout) afterLoad() {} +func (to *SendReceiveTimeout) afterLoad() {} -func (s *SendReceiveTimeout) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.send) - stateSourceObject.Load(1, &s.recv) +func (to *SendReceiveTimeout) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &to.send) + stateSourceObject.Load(1, &to.recv) } func init() { diff --git a/pkg/sentry/socket/unix/transport/transport_state_autogen.go b/pkg/sentry/socket/unix/transport/transport_state_autogen.go index 0264e8fb5..015fbc90a 100644 --- a/pkg/sentry/socket/unix/transport/transport_state_autogen.go +++ b/pkg/sentry/socket/unix/transport/transport_state_autogen.go @@ -6,11 +6,11 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (c *connectionedEndpoint) StateTypeName() string { +func (e *connectionedEndpoint) StateTypeName() string { return "pkg/sentry/socket/unix/transport.connectionedEndpoint" } -func (c *connectionedEndpoint) StateFields() []string { +func (e *connectionedEndpoint) StateFields() []string { return []string{ "baseEndpoint", "id", @@ -20,49 +20,49 @@ func (c *connectionedEndpoint) StateFields() []string { } } -func (c *connectionedEndpoint) beforeSave() {} +func (e *connectionedEndpoint) beforeSave() {} -func (c *connectionedEndpoint) StateSave(stateSinkObject state.Sink) { - c.beforeSave() - var acceptedChanValue []*connectionedEndpoint = c.saveAcceptedChan() +func (e *connectionedEndpoint) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + var acceptedChanValue []*connectionedEndpoint = e.saveAcceptedChan() stateSinkObject.SaveValue(4, acceptedChanValue) - stateSinkObject.Save(0, &c.baseEndpoint) - stateSinkObject.Save(1, &c.id) - stateSinkObject.Save(2, &c.idGenerator) - stateSinkObject.Save(3, &c.stype) + stateSinkObject.Save(0, &e.baseEndpoint) + stateSinkObject.Save(1, &e.id) + stateSinkObject.Save(2, &e.idGenerator) + stateSinkObject.Save(3, &e.stype) } -func (c *connectionedEndpoint) afterLoad() {} +func (e *connectionedEndpoint) afterLoad() {} -func (c *connectionedEndpoint) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &c.baseEndpoint) - stateSourceObject.Load(1, &c.id) - stateSourceObject.Load(2, &c.idGenerator) - stateSourceObject.Load(3, &c.stype) - stateSourceObject.LoadValue(4, new([]*connectionedEndpoint), func(y interface{}) { c.loadAcceptedChan(y.([]*connectionedEndpoint)) }) +func (e *connectionedEndpoint) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.baseEndpoint) + stateSourceObject.Load(1, &e.id) + stateSourceObject.Load(2, &e.idGenerator) + stateSourceObject.Load(3, &e.stype) + stateSourceObject.LoadValue(4, new([]*connectionedEndpoint), func(y interface{}) { e.loadAcceptedChan(y.([]*connectionedEndpoint)) }) } -func (c *connectionlessEndpoint) StateTypeName() string { +func (e *connectionlessEndpoint) StateTypeName() string { return "pkg/sentry/socket/unix/transport.connectionlessEndpoint" } -func (c *connectionlessEndpoint) StateFields() []string { +func (e *connectionlessEndpoint) StateFields() []string { return []string{ "baseEndpoint", } } -func (c *connectionlessEndpoint) beforeSave() {} +func (e *connectionlessEndpoint) beforeSave() {} -func (c *connectionlessEndpoint) StateSave(stateSinkObject state.Sink) { - c.beforeSave() - stateSinkObject.Save(0, &c.baseEndpoint) +func (e *connectionlessEndpoint) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.baseEndpoint) } -func (c *connectionlessEndpoint) afterLoad() {} +func (e *connectionlessEndpoint) afterLoad() {} -func (c *connectionlessEndpoint) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &c.baseEndpoint) +func (e *connectionlessEndpoint) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.baseEndpoint) } func (q *queue) StateTypeName() string { @@ -109,79 +109,79 @@ func (q *queue) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(7, &q.dataList) } -func (q *queueRefs) StateTypeName() string { +func (r *queueRefs) StateTypeName() string { return "pkg/sentry/socket/unix/transport.queueRefs" } -func (q *queueRefs) StateFields() []string { +func (r *queueRefs) StateFields() []string { return []string{ "refCount", } } -func (q *queueRefs) beforeSave() {} +func (r *queueRefs) beforeSave() {} -func (q *queueRefs) StateSave(stateSinkObject state.Sink) { - q.beforeSave() - stateSinkObject.Save(0, &q.refCount) +func (r *queueRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (q *queueRefs) afterLoad() {} +func (r *queueRefs) afterLoad() {} -func (q *queueRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &q.refCount) +func (r *queueRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } -func (m *messageList) StateTypeName() string { +func (l *messageList) StateTypeName() string { return "pkg/sentry/socket/unix/transport.messageList" } -func (m *messageList) StateFields() []string { +func (l *messageList) StateFields() []string { return []string{ "head", "tail", } } -func (m *messageList) beforeSave() {} +func (l *messageList) beforeSave() {} -func (m *messageList) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.head) - stateSinkObject.Save(1, &m.tail) +func (l *messageList) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.head) + stateSinkObject.Save(1, &l.tail) } -func (m *messageList) afterLoad() {} +func (l *messageList) afterLoad() {} -func (m *messageList) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.head) - stateSourceObject.Load(1, &m.tail) +func (l *messageList) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.head) + stateSourceObject.Load(1, &l.tail) } -func (m *messageEntry) StateTypeName() string { +func (e *messageEntry) StateTypeName() string { return "pkg/sentry/socket/unix/transport.messageEntry" } -func (m *messageEntry) StateFields() []string { +func (e *messageEntry) StateFields() []string { return []string{ "next", "prev", } } -func (m *messageEntry) beforeSave() {} +func (e *messageEntry) beforeSave() {} -func (m *messageEntry) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.next) - stateSinkObject.Save(1, &m.prev) +func (e *messageEntry) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.next) + stateSinkObject.Save(1, &e.prev) } -func (m *messageEntry) afterLoad() {} +func (e *messageEntry) afterLoad() {} -func (m *messageEntry) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.next) - stateSourceObject.Load(1, &m.prev) +func (e *messageEntry) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.next) + stateSourceObject.Load(1, &e.prev) } func (c *ControlMessages) StateTypeName() string { @@ -265,11 +265,11 @@ func (q *queueReceiver) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(0, &q.readQueue) } -func (s *streamQueueReceiver) StateTypeName() string { +func (q *streamQueueReceiver) StateTypeName() string { return "pkg/sentry/socket/unix/transport.streamQueueReceiver" } -func (s *streamQueueReceiver) StateFields() []string { +func (q *streamQueueReceiver) StateFields() []string { return []string{ "queueReceiver", "buffer", @@ -278,56 +278,56 @@ func (s *streamQueueReceiver) StateFields() []string { } } -func (s *streamQueueReceiver) beforeSave() {} +func (q *streamQueueReceiver) beforeSave() {} -func (s *streamQueueReceiver) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.queueReceiver) - stateSinkObject.Save(1, &s.buffer) - stateSinkObject.Save(2, &s.control) - stateSinkObject.Save(3, &s.addr) +func (q *streamQueueReceiver) StateSave(stateSinkObject state.Sink) { + q.beforeSave() + stateSinkObject.Save(0, &q.queueReceiver) + stateSinkObject.Save(1, &q.buffer) + stateSinkObject.Save(2, &q.control) + stateSinkObject.Save(3, &q.addr) } -func (s *streamQueueReceiver) afterLoad() {} +func (q *streamQueueReceiver) afterLoad() {} -func (s *streamQueueReceiver) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.queueReceiver) - stateSourceObject.Load(1, &s.buffer) - stateSourceObject.Load(2, &s.control) - stateSourceObject.Load(3, &s.addr) +func (q *streamQueueReceiver) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &q.queueReceiver) + stateSourceObject.Load(1, &q.buffer) + stateSourceObject.Load(2, &q.control) + stateSourceObject.Load(3, &q.addr) } -func (c *connectedEndpoint) StateTypeName() string { +func (e *connectedEndpoint) StateTypeName() string { return "pkg/sentry/socket/unix/transport.connectedEndpoint" } -func (c *connectedEndpoint) StateFields() []string { +func (e *connectedEndpoint) StateFields() []string { return []string{ "endpoint", "writeQueue", } } -func (c *connectedEndpoint) beforeSave() {} +func (e *connectedEndpoint) beforeSave() {} -func (c *connectedEndpoint) StateSave(stateSinkObject state.Sink) { - c.beforeSave() - stateSinkObject.Save(0, &c.endpoint) - stateSinkObject.Save(1, &c.writeQueue) +func (e *connectedEndpoint) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.endpoint) + stateSinkObject.Save(1, &e.writeQueue) } -func (c *connectedEndpoint) afterLoad() {} +func (e *connectedEndpoint) afterLoad() {} -func (c *connectedEndpoint) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &c.endpoint) - stateSourceObject.Load(1, &c.writeQueue) +func (e *connectedEndpoint) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.endpoint) + stateSourceObject.Load(1, &e.writeQueue) } -func (b *baseEndpoint) StateTypeName() string { +func (e *baseEndpoint) StateTypeName() string { return "pkg/sentry/socket/unix/transport.baseEndpoint" } -func (b *baseEndpoint) StateFields() []string { +func (e *baseEndpoint) StateFields() []string { return []string{ "Queue", "passcred", @@ -338,27 +338,27 @@ func (b *baseEndpoint) StateFields() []string { } } -func (b *baseEndpoint) beforeSave() {} +func (e *baseEndpoint) beforeSave() {} -func (b *baseEndpoint) StateSave(stateSinkObject state.Sink) { - b.beforeSave() - stateSinkObject.Save(0, &b.Queue) - stateSinkObject.Save(1, &b.passcred) - stateSinkObject.Save(2, &b.receiver) - stateSinkObject.Save(3, &b.connected) - stateSinkObject.Save(4, &b.path) - stateSinkObject.Save(5, &b.linger) +func (e *baseEndpoint) StateSave(stateSinkObject state.Sink) { + e.beforeSave() + stateSinkObject.Save(0, &e.Queue) + stateSinkObject.Save(1, &e.passcred) + stateSinkObject.Save(2, &e.receiver) + stateSinkObject.Save(3, &e.connected) + stateSinkObject.Save(4, &e.path) + stateSinkObject.Save(5, &e.linger) } -func (b *baseEndpoint) afterLoad() {} +func (e *baseEndpoint) afterLoad() {} -func (b *baseEndpoint) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &b.Queue) - stateSourceObject.Load(1, &b.passcred) - stateSourceObject.Load(2, &b.receiver) - stateSourceObject.Load(3, &b.connected) - stateSourceObject.Load(4, &b.path) - stateSourceObject.Load(5, &b.linger) +func (e *baseEndpoint) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &e.Queue) + stateSourceObject.Load(1, &e.passcred) + stateSourceObject.Load(2, &e.receiver) + stateSourceObject.Load(3, &e.connected) + stateSourceObject.Load(4, &e.path) + stateSourceObject.Load(5, &e.linger) } func init() { diff --git a/pkg/sentry/socket/unix/unix_state_autogen.go b/pkg/sentry/socket/unix/unix_state_autogen.go index 4afe51e7c..6b2886e4f 100644 --- a/pkg/sentry/socket/unix/unix_state_autogen.go +++ b/pkg/sentry/socket/unix/unix_state_autogen.go @@ -6,50 +6,50 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (s *socketOperationsRefs) StateTypeName() string { +func (r *socketOperationsRefs) StateTypeName() string { return "pkg/sentry/socket/unix.socketOperationsRefs" } -func (s *socketOperationsRefs) StateFields() []string { +func (r *socketOperationsRefs) StateFields() []string { return []string{ "refCount", } } -func (s *socketOperationsRefs) beforeSave() {} +func (r *socketOperationsRefs) beforeSave() {} -func (s *socketOperationsRefs) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.refCount) +func (r *socketOperationsRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (s *socketOperationsRefs) afterLoad() {} +func (r *socketOperationsRefs) afterLoad() {} -func (s *socketOperationsRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.refCount) +func (r *socketOperationsRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } -func (s *socketVFS2Refs) StateTypeName() string { +func (r *socketVFS2Refs) StateTypeName() string { return "pkg/sentry/socket/unix.socketVFS2Refs" } -func (s *socketVFS2Refs) StateFields() []string { +func (r *socketVFS2Refs) StateFields() []string { return []string{ "refCount", } } -func (s *socketVFS2Refs) beforeSave() {} +func (r *socketVFS2Refs) beforeSave() {} -func (s *socketVFS2Refs) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.refCount) +func (r *socketVFS2Refs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (s *socketVFS2Refs) afterLoad() {} +func (r *socketVFS2Refs) afterLoad() {} -func (s *socketVFS2Refs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.refCount) +func (r *socketVFS2Refs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } func (s *SocketOperations) StateTypeName() string { diff --git a/pkg/sentry/syscalls/linux/linux_state_autogen.go b/pkg/sentry/syscalls/linux/linux_state_autogen.go index 0ad0d2177..8ae8de973 100644 --- a/pkg/sentry/syscalls/linux/linux_state_autogen.go +++ b/pkg/sentry/syscalls/linux/linux_state_autogen.go @@ -70,11 +70,11 @@ func (p *pollRestartBlock) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(2, &p.timeout) } -func (c *clockNanosleepRestartBlock) StateTypeName() string { +func (n *clockNanosleepRestartBlock) StateTypeName() string { return "pkg/sentry/syscalls/linux.clockNanosleepRestartBlock" } -func (c *clockNanosleepRestartBlock) StateFields() []string { +func (n *clockNanosleepRestartBlock) StateFields() []string { return []string{ "c", "duration", @@ -82,21 +82,21 @@ func (c *clockNanosleepRestartBlock) StateFields() []string { } } -func (c *clockNanosleepRestartBlock) beforeSave() {} +func (n *clockNanosleepRestartBlock) beforeSave() {} -func (c *clockNanosleepRestartBlock) StateSave(stateSinkObject state.Sink) { - c.beforeSave() - stateSinkObject.Save(0, &c.c) - stateSinkObject.Save(1, &c.duration) - stateSinkObject.Save(2, &c.rem) +func (n *clockNanosleepRestartBlock) StateSave(stateSinkObject state.Sink) { + n.beforeSave() + stateSinkObject.Save(0, &n.c) + stateSinkObject.Save(1, &n.duration) + stateSinkObject.Save(2, &n.rem) } -func (c *clockNanosleepRestartBlock) afterLoad() {} +func (n *clockNanosleepRestartBlock) afterLoad() {} -func (c *clockNanosleepRestartBlock) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &c.c) - stateSourceObject.Load(1, &c.duration) - stateSourceObject.Load(2, &c.rem) +func (n *clockNanosleepRestartBlock) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &n.c) + stateSourceObject.Load(1, &n.duration) + stateSourceObject.Load(2, &n.rem) } func init() { diff --git a/pkg/sentry/usage/usage_state_autogen.go b/pkg/sentry/usage/usage_state_autogen.go index 0ef018bac..50f6d27ba 100644 --- a/pkg/sentry/usage/usage_state_autogen.go +++ b/pkg/sentry/usage/usage_state_autogen.go @@ -6,11 +6,11 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (c *CPUStats) StateTypeName() string { +func (s *CPUStats) StateTypeName() string { return "pkg/sentry/usage.CPUStats" } -func (c *CPUStats) StateFields() []string { +func (s *CPUStats) StateFields() []string { return []string{ "UserTime", "SysTime", @@ -18,21 +18,21 @@ func (c *CPUStats) StateFields() []string { } } -func (c *CPUStats) beforeSave() {} +func (s *CPUStats) beforeSave() {} -func (c *CPUStats) StateSave(stateSinkObject state.Sink) { - c.beforeSave() - stateSinkObject.Save(0, &c.UserTime) - stateSinkObject.Save(1, &c.SysTime) - stateSinkObject.Save(2, &c.VoluntarySwitches) +func (s *CPUStats) StateSave(stateSinkObject state.Sink) { + s.beforeSave() + stateSinkObject.Save(0, &s.UserTime) + stateSinkObject.Save(1, &s.SysTime) + stateSinkObject.Save(2, &s.VoluntarySwitches) } -func (c *CPUStats) afterLoad() {} +func (s *CPUStats) afterLoad() {} -func (c *CPUStats) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &c.UserTime) - stateSourceObject.Load(1, &c.SysTime) - stateSourceObject.Load(2, &c.VoluntarySwitches) +func (s *CPUStats) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &s.UserTime) + stateSourceObject.Load(1, &s.SysTime) + stateSourceObject.Load(2, &s.VoluntarySwitches) } func (i *IO) StateTypeName() string { diff --git a/pkg/sentry/vfs/memxattr/memxattr_state_autogen.go b/pkg/sentry/vfs/memxattr/memxattr_state_autogen.go index 28a4ae569..eafeac473 100644 --- a/pkg/sentry/vfs/memxattr/memxattr_state_autogen.go +++ b/pkg/sentry/vfs/memxattr/memxattr_state_autogen.go @@ -6,27 +6,27 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (s *SimpleExtendedAttributes) StateTypeName() string { +func (x *SimpleExtendedAttributes) StateTypeName() string { return "pkg/sentry/vfs/memxattr.SimpleExtendedAttributes" } -func (s *SimpleExtendedAttributes) StateFields() []string { +func (x *SimpleExtendedAttributes) StateFields() []string { return []string{ "xattrs", } } -func (s *SimpleExtendedAttributes) beforeSave() {} +func (x *SimpleExtendedAttributes) beforeSave() {} -func (s *SimpleExtendedAttributes) StateSave(stateSinkObject state.Sink) { - s.beforeSave() - stateSinkObject.Save(0, &s.xattrs) +func (x *SimpleExtendedAttributes) StateSave(stateSinkObject state.Sink) { + x.beforeSave() + stateSinkObject.Save(0, &x.xattrs) } -func (s *SimpleExtendedAttributes) afterLoad() {} +func (x *SimpleExtendedAttributes) afterLoad() {} -func (s *SimpleExtendedAttributes) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &s.xattrs) +func (x *SimpleExtendedAttributes) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &x.xattrs) } func init() { diff --git a/pkg/sentry/vfs/vfs_state_autogen.go b/pkg/sentry/vfs/vfs_state_autogen.go index 2dff75293..d78221080 100644 --- a/pkg/sentry/vfs/vfs_state_autogen.go +++ b/pkg/sentry/vfs/vfs_state_autogen.go @@ -25,56 +25,56 @@ func (a *anonFilesystemType) afterLoad() {} func (a *anonFilesystemType) StateLoad(stateSourceObject state.Source) { } -func (a *anonFilesystem) StateTypeName() string { +func (fs *anonFilesystem) StateTypeName() string { return "pkg/sentry/vfs.anonFilesystem" } -func (a *anonFilesystem) StateFields() []string { +func (fs *anonFilesystem) StateFields() []string { return []string{ "vfsfs", "devMinor", } } -func (a *anonFilesystem) beforeSave() {} +func (fs *anonFilesystem) beforeSave() {} -func (a *anonFilesystem) StateSave(stateSinkObject state.Sink) { - a.beforeSave() - stateSinkObject.Save(0, &a.vfsfs) - stateSinkObject.Save(1, &a.devMinor) +func (fs *anonFilesystem) StateSave(stateSinkObject state.Sink) { + fs.beforeSave() + stateSinkObject.Save(0, &fs.vfsfs) + stateSinkObject.Save(1, &fs.devMinor) } -func (a *anonFilesystem) afterLoad() {} +func (fs *anonFilesystem) afterLoad() {} -func (a *anonFilesystem) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &a.vfsfs) - stateSourceObject.Load(1, &a.devMinor) +func (fs *anonFilesystem) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fs.vfsfs) + stateSourceObject.Load(1, &fs.devMinor) } -func (a *anonDentry) StateTypeName() string { +func (d *anonDentry) StateTypeName() string { return "pkg/sentry/vfs.anonDentry" } -func (a *anonDentry) StateFields() []string { +func (d *anonDentry) StateFields() []string { return []string{ "vfsd", "name", } } -func (a *anonDentry) beforeSave() {} +func (d *anonDentry) beforeSave() {} -func (a *anonDentry) StateSave(stateSinkObject state.Sink) { - a.beforeSave() - stateSinkObject.Save(0, &a.vfsd) - stateSinkObject.Save(1, &a.name) +func (d *anonDentry) StateSave(stateSinkObject state.Sink) { + d.beforeSave() + stateSinkObject.Save(0, &d.vfsd) + stateSinkObject.Save(1, &d.name) } -func (a *anonDentry) afterLoad() {} +func (d *anonDentry) afterLoad() {} -func (a *anonDentry) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &a.vfsd) - stateSourceObject.Load(1, &a.name) +func (d *anonDentry) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &d.vfsd) + stateSourceObject.Load(1, &d.name) } func (d *Dentry) StateTypeName() string { @@ -106,11 +106,11 @@ func (d *Dentry) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(2, &d.impl) } -func (d *DeviceKind) StateTypeName() string { +func (kind *DeviceKind) StateTypeName() string { return "pkg/sentry/vfs.DeviceKind" } -func (d *DeviceKind) StateFields() []string { +func (kind *DeviceKind) StateFields() []string { return nil } @@ -192,11 +192,11 @@ func (r *RegisterDeviceOptions) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(0, &r.GroupName) } -func (e *EpollInstance) StateTypeName() string { +func (ep *EpollInstance) StateTypeName() string { return "pkg/sentry/vfs.EpollInstance" } -func (e *EpollInstance) StateFields() []string { +func (ep *EpollInstance) StateFields() []string { return []string{ "vfsfd", "FileDescriptionDefaultImpl", @@ -208,29 +208,29 @@ func (e *EpollInstance) StateFields() []string { } } -func (e *EpollInstance) beforeSave() {} +func (ep *EpollInstance) beforeSave() {} -func (e *EpollInstance) StateSave(stateSinkObject state.Sink) { - e.beforeSave() - stateSinkObject.Save(0, &e.vfsfd) - stateSinkObject.Save(1, &e.FileDescriptionDefaultImpl) - stateSinkObject.Save(2, &e.DentryMetadataFileDescriptionImpl) - stateSinkObject.Save(3, &e.NoLockFD) - stateSinkObject.Save(4, &e.q) - stateSinkObject.Save(5, &e.interest) - stateSinkObject.Save(6, &e.ready) +func (ep *EpollInstance) StateSave(stateSinkObject state.Sink) { + ep.beforeSave() + stateSinkObject.Save(0, &ep.vfsfd) + stateSinkObject.Save(1, &ep.FileDescriptionDefaultImpl) + stateSinkObject.Save(2, &ep.DentryMetadataFileDescriptionImpl) + stateSinkObject.Save(3, &ep.NoLockFD) + stateSinkObject.Save(4, &ep.q) + stateSinkObject.Save(5, &ep.interest) + stateSinkObject.Save(6, &ep.ready) } -func (e *EpollInstance) afterLoad() {} +func (ep *EpollInstance) afterLoad() {} -func (e *EpollInstance) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &e.vfsfd) - stateSourceObject.Load(1, &e.FileDescriptionDefaultImpl) - stateSourceObject.Load(2, &e.DentryMetadataFileDescriptionImpl) - stateSourceObject.Load(3, &e.NoLockFD) - stateSourceObject.Load(4, &e.q) - stateSourceObject.Load(5, &e.interest) - stateSourceObject.Load(6, &e.ready) +func (ep *EpollInstance) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &ep.vfsfd) + stateSourceObject.Load(1, &ep.FileDescriptionDefaultImpl) + stateSourceObject.Load(2, &ep.DentryMetadataFileDescriptionImpl) + stateSourceObject.Load(3, &ep.NoLockFD) + stateSourceObject.Load(4, &ep.q) + stateSourceObject.Load(5, &ep.interest) + stateSourceObject.Load(6, &ep.ready) } func (e *epollInterestKey) StateTypeName() string { @@ -259,11 +259,11 @@ func (e *epollInterestKey) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &e.num) } -func (e *epollInterest) StateTypeName() string { +func (epi *epollInterest) StateTypeName() string { return "pkg/sentry/vfs.epollInterest" } -func (e *epollInterest) StateFields() []string { +func (epi *epollInterest) StateFields() []string { return []string{ "epoll", "key", @@ -275,55 +275,55 @@ func (e *epollInterest) StateFields() []string { } } -func (e *epollInterest) beforeSave() {} +func (epi *epollInterest) beforeSave() {} -func (e *epollInterest) StateSave(stateSinkObject state.Sink) { - e.beforeSave() - stateSinkObject.Save(0, &e.epoll) - stateSinkObject.Save(1, &e.key) - stateSinkObject.Save(2, &e.waiter) - stateSinkObject.Save(3, &e.mask) - stateSinkObject.Save(4, &e.ready) - stateSinkObject.Save(5, &e.epollInterestEntry) - stateSinkObject.Save(6, &e.userData) +func (epi *epollInterest) StateSave(stateSinkObject state.Sink) { + epi.beforeSave() + stateSinkObject.Save(0, &epi.epoll) + stateSinkObject.Save(1, &epi.key) + stateSinkObject.Save(2, &epi.waiter) + stateSinkObject.Save(3, &epi.mask) + stateSinkObject.Save(4, &epi.ready) + stateSinkObject.Save(5, &epi.epollInterestEntry) + stateSinkObject.Save(6, &epi.userData) } -func (e *epollInterest) afterLoad() {} +func (epi *epollInterest) afterLoad() {} -func (e *epollInterest) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &e.epoll) - stateSourceObject.Load(1, &e.key) - stateSourceObject.Load(2, &e.waiter) - stateSourceObject.Load(3, &e.mask) - stateSourceObject.Load(4, &e.ready) - stateSourceObject.Load(5, &e.epollInterestEntry) - stateSourceObject.Load(6, &e.userData) +func (epi *epollInterest) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &epi.epoll) + stateSourceObject.Load(1, &epi.key) + stateSourceObject.Load(2, &epi.waiter) + stateSourceObject.Load(3, &epi.mask) + stateSourceObject.Load(4, &epi.ready) + stateSourceObject.Load(5, &epi.epollInterestEntry) + stateSourceObject.Load(6, &epi.userData) } -func (e *epollInterestList) StateTypeName() string { +func (l *epollInterestList) StateTypeName() string { return "pkg/sentry/vfs.epollInterestList" } -func (e *epollInterestList) StateFields() []string { +func (l *epollInterestList) StateFields() []string { return []string{ "head", "tail", } } -func (e *epollInterestList) beforeSave() {} +func (l *epollInterestList) beforeSave() {} -func (e *epollInterestList) StateSave(stateSinkObject state.Sink) { - e.beforeSave() - stateSinkObject.Save(0, &e.head) - stateSinkObject.Save(1, &e.tail) +func (l *epollInterestList) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.head) + stateSinkObject.Save(1, &l.tail) } -func (e *epollInterestList) afterLoad() {} +func (l *epollInterestList) afterLoad() {} -func (e *epollInterestList) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &e.head) - stateSourceObject.Load(1, &e.tail) +func (l *epollInterestList) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.head) + stateSourceObject.Load(1, &l.tail) } func (e *epollInterestEntry) StateTypeName() string { @@ -352,30 +352,30 @@ func (e *epollInterestEntry) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &e.prev) } -func (e *eventList) StateTypeName() string { +func (l *eventList) StateTypeName() string { return "pkg/sentry/vfs.eventList" } -func (e *eventList) StateFields() []string { +func (l *eventList) StateFields() []string { return []string{ "head", "tail", } } -func (e *eventList) beforeSave() {} +func (l *eventList) beforeSave() {} -func (e *eventList) StateSave(stateSinkObject state.Sink) { - e.beforeSave() - stateSinkObject.Save(0, &e.head) - stateSinkObject.Save(1, &e.tail) +func (l *eventList) StateSave(stateSinkObject state.Sink) { + l.beforeSave() + stateSinkObject.Save(0, &l.head) + stateSinkObject.Save(1, &l.tail) } -func (e *eventList) afterLoad() {} +func (l *eventList) afterLoad() {} -func (e *eventList) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &e.head) - stateSourceObject.Load(1, &e.tail) +func (l *eventList) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &l.head) + stateSourceObject.Load(1, &l.tail) } func (e *eventEntry) StateTypeName() string { @@ -404,11 +404,11 @@ func (e *eventEntry) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &e.prev) } -func (f *FileDescription) StateTypeName() string { +func (fd *FileDescription) StateTypeName() string { return "pkg/sentry/vfs.FileDescription" } -func (f *FileDescription) StateFields() []string { +func (fd *FileDescription) StateFields() []string { return []string{ "FileDescriptionRefs", "statusFlags", @@ -423,35 +423,35 @@ func (f *FileDescription) StateFields() []string { } } -func (f *FileDescription) beforeSave() {} +func (fd *FileDescription) beforeSave() {} -func (f *FileDescription) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.FileDescriptionRefs) - stateSinkObject.Save(1, &f.statusFlags) - stateSinkObject.Save(2, &f.asyncHandler) - stateSinkObject.Save(3, &f.epolls) - stateSinkObject.Save(4, &f.vd) - stateSinkObject.Save(5, &f.opts) - stateSinkObject.Save(6, &f.readable) - stateSinkObject.Save(7, &f.writable) - stateSinkObject.Save(8, &f.usedLockBSD) - stateSinkObject.Save(9, &f.impl) -} - -func (f *FileDescription) afterLoad() {} - -func (f *FileDescription) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.FileDescriptionRefs) - stateSourceObject.Load(1, &f.statusFlags) - stateSourceObject.Load(2, &f.asyncHandler) - stateSourceObject.Load(3, &f.epolls) - stateSourceObject.Load(4, &f.vd) - stateSourceObject.Load(5, &f.opts) - stateSourceObject.Load(6, &f.readable) - stateSourceObject.Load(7, &f.writable) - stateSourceObject.Load(8, &f.usedLockBSD) - stateSourceObject.Load(9, &f.impl) +func (fd *FileDescription) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.FileDescriptionRefs) + stateSinkObject.Save(1, &fd.statusFlags) + stateSinkObject.Save(2, &fd.asyncHandler) + stateSinkObject.Save(3, &fd.epolls) + stateSinkObject.Save(4, &fd.vd) + stateSinkObject.Save(5, &fd.opts) + stateSinkObject.Save(6, &fd.readable) + stateSinkObject.Save(7, &fd.writable) + stateSinkObject.Save(8, &fd.usedLockBSD) + stateSinkObject.Save(9, &fd.impl) +} + +func (fd *FileDescription) afterLoad() {} + +func (fd *FileDescription) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.FileDescriptionRefs) + stateSourceObject.Load(1, &fd.statusFlags) + stateSourceObject.Load(2, &fd.asyncHandler) + stateSourceObject.Load(3, &fd.epolls) + stateSourceObject.Load(4, &fd.vd) + stateSourceObject.Load(5, &fd.opts) + stateSourceObject.Load(6, &fd.readable) + stateSourceObject.Load(7, &fd.writable) + stateSourceObject.Load(8, &fd.usedLockBSD) + stateSourceObject.Load(9, &fd.impl) } func (f *FileDescriptionOptions) StateTypeName() string { @@ -598,11 +598,11 @@ func (s *StaticData) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(0, &s.Data) } -func (d *DynamicBytesFileDescriptionImpl) StateTypeName() string { +func (fd *DynamicBytesFileDescriptionImpl) StateTypeName() string { return "pkg/sentry/vfs.DynamicBytesFileDescriptionImpl" } -func (d *DynamicBytesFileDescriptionImpl) StateFields() []string { +func (fd *DynamicBytesFileDescriptionImpl) StateFields() []string { return []string{ "data", "buf", @@ -611,47 +611,47 @@ func (d *DynamicBytesFileDescriptionImpl) StateFields() []string { } } -func (d *DynamicBytesFileDescriptionImpl) beforeSave() {} +func (fd *DynamicBytesFileDescriptionImpl) beforeSave() {} -func (d *DynamicBytesFileDescriptionImpl) StateSave(stateSinkObject state.Sink) { - d.beforeSave() - var bufValue []byte = d.saveBuf() +func (fd *DynamicBytesFileDescriptionImpl) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + var bufValue []byte = fd.saveBuf() stateSinkObject.SaveValue(1, bufValue) - stateSinkObject.Save(0, &d.data) - stateSinkObject.Save(2, &d.off) - stateSinkObject.Save(3, &d.lastRead) + stateSinkObject.Save(0, &fd.data) + stateSinkObject.Save(2, &fd.off) + stateSinkObject.Save(3, &fd.lastRead) } -func (d *DynamicBytesFileDescriptionImpl) afterLoad() {} +func (fd *DynamicBytesFileDescriptionImpl) afterLoad() {} -func (d *DynamicBytesFileDescriptionImpl) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &d.data) - stateSourceObject.Load(2, &d.off) - stateSourceObject.Load(3, &d.lastRead) - stateSourceObject.LoadValue(1, new([]byte), func(y interface{}) { d.loadBuf(y.([]byte)) }) +func (fd *DynamicBytesFileDescriptionImpl) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.data) + stateSourceObject.Load(2, &fd.off) + stateSourceObject.Load(3, &fd.lastRead) + stateSourceObject.LoadValue(1, new([]byte), func(y interface{}) { fd.loadBuf(y.([]byte)) }) } -func (l *LockFD) StateTypeName() string { +func (fd *LockFD) StateTypeName() string { return "pkg/sentry/vfs.LockFD" } -func (l *LockFD) StateFields() []string { +func (fd *LockFD) StateFields() []string { return []string{ "locks", } } -func (l *LockFD) beforeSave() {} +func (fd *LockFD) beforeSave() {} -func (l *LockFD) StateSave(stateSinkObject state.Sink) { - l.beforeSave() - stateSinkObject.Save(0, &l.locks) +func (fd *LockFD) StateSave(stateSinkObject state.Sink) { + fd.beforeSave() + stateSinkObject.Save(0, &fd.locks) } -func (l *LockFD) afterLoad() {} +func (fd *LockFD) afterLoad() {} -func (l *LockFD) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &l.locks) +func (fd *LockFD) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fd.locks) } func (n *NoLockFD) StateTypeName() string { @@ -673,34 +673,34 @@ func (n *NoLockFD) afterLoad() {} func (n *NoLockFD) StateLoad(stateSourceObject state.Source) { } -func (f *FileDescriptionRefs) StateTypeName() string { +func (r *FileDescriptionRefs) StateTypeName() string { return "pkg/sentry/vfs.FileDescriptionRefs" } -func (f *FileDescriptionRefs) StateFields() []string { +func (r *FileDescriptionRefs) StateFields() []string { return []string{ "refCount", } } -func (f *FileDescriptionRefs) beforeSave() {} +func (r *FileDescriptionRefs) beforeSave() {} -func (f *FileDescriptionRefs) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.refCount) +func (r *FileDescriptionRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (f *FileDescriptionRefs) afterLoad() {} +func (r *FileDescriptionRefs) afterLoad() {} -func (f *FileDescriptionRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.refCount) +func (r *FileDescriptionRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } -func (f *Filesystem) StateTypeName() string { +func (fs *Filesystem) StateTypeName() string { return "pkg/sentry/vfs.Filesystem" } -func (f *Filesystem) StateFields() []string { +func (fs *Filesystem) StateFields() []string { return []string{ "FilesystemRefs", "vfs", @@ -709,23 +709,23 @@ func (f *Filesystem) StateFields() []string { } } -func (f *Filesystem) beforeSave() {} +func (fs *Filesystem) beforeSave() {} -func (f *Filesystem) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.FilesystemRefs) - stateSinkObject.Save(1, &f.vfs) - stateSinkObject.Save(2, &f.fsType) - stateSinkObject.Save(3, &f.impl) +func (fs *Filesystem) StateSave(stateSinkObject state.Sink) { + fs.beforeSave() + stateSinkObject.Save(0, &fs.FilesystemRefs) + stateSinkObject.Save(1, &fs.vfs) + stateSinkObject.Save(2, &fs.fsType) + stateSinkObject.Save(3, &fs.impl) } -func (f *Filesystem) afterLoad() {} +func (fs *Filesystem) afterLoad() {} -func (f *Filesystem) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.FilesystemRefs) - stateSourceObject.Load(1, &f.vfs) - stateSourceObject.Load(2, &f.fsType) - stateSourceObject.Load(3, &f.impl) +func (fs *Filesystem) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fs.FilesystemRefs) + stateSourceObject.Load(1, &fs.vfs) + stateSourceObject.Load(2, &fs.fsType) + stateSourceObject.Load(3, &fs.impl) } func (p *PrependPathAtVFSRootError) StateTypeName() string { @@ -785,27 +785,27 @@ func (p *PrependPathSyntheticError) afterLoad() {} func (p *PrependPathSyntheticError) StateLoad(stateSourceObject state.Source) { } -func (f *FilesystemRefs) StateTypeName() string { +func (r *FilesystemRefs) StateTypeName() string { return "pkg/sentry/vfs.FilesystemRefs" } -func (f *FilesystemRefs) StateFields() []string { +func (r *FilesystemRefs) StateFields() []string { return []string{ "refCount", } } -func (f *FilesystemRefs) beforeSave() {} +func (r *FilesystemRefs) beforeSave() {} -func (f *FilesystemRefs) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.refCount) +func (r *FilesystemRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (f *FilesystemRefs) afterLoad() {} +func (r *FilesystemRefs) afterLoad() {} -func (f *FilesystemRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.refCount) +func (r *FilesystemRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } func (r *registeredFilesystemType) StateTypeName() string { @@ -1014,37 +1014,37 @@ func (e *Event) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(5, &e.name) } -func (f *FileLocks) StateTypeName() string { +func (fl *FileLocks) StateTypeName() string { return "pkg/sentry/vfs.FileLocks" } -func (f *FileLocks) StateFields() []string { +func (fl *FileLocks) StateFields() []string { return []string{ "bsd", "posix", } } -func (f *FileLocks) beforeSave() {} +func (fl *FileLocks) beforeSave() {} -func (f *FileLocks) StateSave(stateSinkObject state.Sink) { - f.beforeSave() - stateSinkObject.Save(0, &f.bsd) - stateSinkObject.Save(1, &f.posix) +func (fl *FileLocks) StateSave(stateSinkObject state.Sink) { + fl.beforeSave() + stateSinkObject.Save(0, &fl.bsd) + stateSinkObject.Save(1, &fl.posix) } -func (f *FileLocks) afterLoad() {} +func (fl *FileLocks) afterLoad() {} -func (f *FileLocks) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &f.bsd) - stateSourceObject.Load(1, &f.posix) +func (fl *FileLocks) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &fl.bsd) + stateSourceObject.Load(1, &fl.posix) } -func (m *Mount) StateTypeName() string { +func (mnt *Mount) StateTypeName() string { return "pkg/sentry/vfs.Mount" } -func (m *Mount) StateFields() []string { +func (mnt *Mount) StateFields() []string { return []string{ "vfs", "fs", @@ -1060,45 +1060,45 @@ func (m *Mount) StateFields() []string { } } -func (m *Mount) beforeSave() {} +func (mnt *Mount) beforeSave() {} -func (m *Mount) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - var keyValue VirtualDentry = m.saveKey() +func (mnt *Mount) StateSave(stateSinkObject state.Sink) { + mnt.beforeSave() + var keyValue VirtualDentry = mnt.saveKey() stateSinkObject.SaveValue(5, keyValue) - stateSinkObject.Save(0, &m.vfs) - stateSinkObject.Save(1, &m.fs) - stateSinkObject.Save(2, &m.root) - stateSinkObject.Save(3, &m.ID) - stateSinkObject.Save(4, &m.Flags) - stateSinkObject.Save(6, &m.ns) - stateSinkObject.Save(7, &m.refs) - stateSinkObject.Save(8, &m.children) - stateSinkObject.Save(9, &m.umounted) - stateSinkObject.Save(10, &m.writers) -} - -func (m *Mount) afterLoad() {} - -func (m *Mount) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.vfs) - stateSourceObject.Load(1, &m.fs) - stateSourceObject.Load(2, &m.root) - stateSourceObject.Load(3, &m.ID) - stateSourceObject.Load(4, &m.Flags) - stateSourceObject.Load(6, &m.ns) - stateSourceObject.Load(7, &m.refs) - stateSourceObject.Load(8, &m.children) - stateSourceObject.Load(9, &m.umounted) - stateSourceObject.Load(10, &m.writers) - stateSourceObject.LoadValue(5, new(VirtualDentry), func(y interface{}) { m.loadKey(y.(VirtualDentry)) }) -} - -func (m *MountNamespace) StateTypeName() string { + stateSinkObject.Save(0, &mnt.vfs) + stateSinkObject.Save(1, &mnt.fs) + stateSinkObject.Save(2, &mnt.root) + stateSinkObject.Save(3, &mnt.ID) + stateSinkObject.Save(4, &mnt.Flags) + stateSinkObject.Save(6, &mnt.ns) + stateSinkObject.Save(7, &mnt.refs) + stateSinkObject.Save(8, &mnt.children) + stateSinkObject.Save(9, &mnt.umounted) + stateSinkObject.Save(10, &mnt.writers) +} + +func (mnt *Mount) afterLoad() {} + +func (mnt *Mount) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &mnt.vfs) + stateSourceObject.Load(1, &mnt.fs) + stateSourceObject.Load(2, &mnt.root) + stateSourceObject.Load(3, &mnt.ID) + stateSourceObject.Load(4, &mnt.Flags) + stateSourceObject.Load(6, &mnt.ns) + stateSourceObject.Load(7, &mnt.refs) + stateSourceObject.Load(8, &mnt.children) + stateSourceObject.Load(9, &mnt.umounted) + stateSourceObject.Load(10, &mnt.writers) + stateSourceObject.LoadValue(5, new(VirtualDentry), func(y interface{}) { mnt.loadKey(y.(VirtualDentry)) }) +} + +func (mntns *MountNamespace) StateTypeName() string { return "pkg/sentry/vfs.MountNamespace" } -func (m *MountNamespace) StateFields() []string { +func (mntns *MountNamespace) StateFields() []string { return []string{ "MountNamespaceRefs", "Owner", @@ -1107,23 +1107,23 @@ func (m *MountNamespace) StateFields() []string { } } -func (m *MountNamespace) beforeSave() {} +func (mntns *MountNamespace) beforeSave() {} -func (m *MountNamespace) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.MountNamespaceRefs) - stateSinkObject.Save(1, &m.Owner) - stateSinkObject.Save(2, &m.root) - stateSinkObject.Save(3, &m.mountpoints) +func (mntns *MountNamespace) StateSave(stateSinkObject state.Sink) { + mntns.beforeSave() + stateSinkObject.Save(0, &mntns.MountNamespaceRefs) + stateSinkObject.Save(1, &mntns.Owner) + stateSinkObject.Save(2, &mntns.root) + stateSinkObject.Save(3, &mntns.mountpoints) } -func (m *MountNamespace) afterLoad() {} +func (mntns *MountNamespace) afterLoad() {} -func (m *MountNamespace) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.MountNamespaceRefs) - stateSourceObject.Load(1, &m.Owner) - stateSourceObject.Load(2, &m.root) - stateSourceObject.Load(3, &m.mountpoints) +func (mntns *MountNamespace) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &mntns.MountNamespaceRefs) + stateSourceObject.Load(1, &mntns.Owner) + stateSourceObject.Load(2, &mntns.root) + stateSourceObject.Load(3, &mntns.mountpoints) } func (u *umountRecursiveOptions) StateTypeName() string { @@ -1152,27 +1152,27 @@ func (u *umountRecursiveOptions) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(1, &u.disconnectHierarchy) } -func (m *MountNamespaceRefs) StateTypeName() string { +func (r *MountNamespaceRefs) StateTypeName() string { return "pkg/sentry/vfs.MountNamespaceRefs" } -func (m *MountNamespaceRefs) StateFields() []string { +func (r *MountNamespaceRefs) StateFields() []string { return []string{ "refCount", } } -func (m *MountNamespaceRefs) beforeSave() {} +func (r *MountNamespaceRefs) beforeSave() {} -func (m *MountNamespaceRefs) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.refCount) +func (r *MountNamespaceRefs) StateSave(stateSinkObject state.Sink) { + r.beforeSave() + stateSinkObject.Save(0, &r.refCount) } -func (m *MountNamespaceRefs) afterLoad() {} +func (r *MountNamespaceRefs) afterLoad() {} -func (m *MountNamespaceRefs) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.refCount) +func (r *MountNamespaceRefs) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &r.refCount) } func (g *GetDentryOptions) StateTypeName() string { @@ -1582,11 +1582,11 @@ func (a *AccessTypes) StateFields() []string { return nil } -func (r *ResolvingPath) StateTypeName() string { +func (rp *ResolvingPath) StateTypeName() string { return "pkg/sentry/vfs.ResolvingPath" } -func (r *ResolvingPath) StateFields() []string { +func (rp *ResolvingPath) StateFields() []string { return []string{ "vfs", "root", @@ -1609,51 +1609,51 @@ func (r *ResolvingPath) StateFields() []string { } } -func (r *ResolvingPath) beforeSave() {} - -func (r *ResolvingPath) StateSave(stateSinkObject state.Sink) { - r.beforeSave() - stateSinkObject.Save(0, &r.vfs) - stateSinkObject.Save(1, &r.root) - stateSinkObject.Save(2, &r.mount) - stateSinkObject.Save(3, &r.start) - stateSinkObject.Save(4, &r.pit) - stateSinkObject.Save(5, &r.flags) - stateSinkObject.Save(6, &r.mustBeDir) - stateSinkObject.Save(7, &r.mustBeDirOrig) - stateSinkObject.Save(8, &r.symlinks) - stateSinkObject.Save(9, &r.symlinksOrig) - stateSinkObject.Save(10, &r.curPart) - stateSinkObject.Save(11, &r.numOrigParts) - stateSinkObject.Save(12, &r.creds) - stateSinkObject.Save(13, &r.nextMount) - stateSinkObject.Save(14, &r.nextStart) - stateSinkObject.Save(15, &r.absSymlinkTarget) - stateSinkObject.Save(16, &r.parts) - stateSinkObject.Save(17, &r.origParts) -} - -func (r *ResolvingPath) afterLoad() {} - -func (r *ResolvingPath) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &r.vfs) - stateSourceObject.Load(1, &r.root) - stateSourceObject.Load(2, &r.mount) - stateSourceObject.Load(3, &r.start) - stateSourceObject.Load(4, &r.pit) - stateSourceObject.Load(5, &r.flags) - stateSourceObject.Load(6, &r.mustBeDir) - stateSourceObject.Load(7, &r.mustBeDirOrig) - stateSourceObject.Load(8, &r.symlinks) - stateSourceObject.Load(9, &r.symlinksOrig) - stateSourceObject.Load(10, &r.curPart) - stateSourceObject.Load(11, &r.numOrigParts) - stateSourceObject.Load(12, &r.creds) - stateSourceObject.Load(13, &r.nextMount) - stateSourceObject.Load(14, &r.nextStart) - stateSourceObject.Load(15, &r.absSymlinkTarget) - stateSourceObject.Load(16, &r.parts) - stateSourceObject.Load(17, &r.origParts) +func (rp *ResolvingPath) beforeSave() {} + +func (rp *ResolvingPath) StateSave(stateSinkObject state.Sink) { + rp.beforeSave() + stateSinkObject.Save(0, &rp.vfs) + stateSinkObject.Save(1, &rp.root) + stateSinkObject.Save(2, &rp.mount) + stateSinkObject.Save(3, &rp.start) + stateSinkObject.Save(4, &rp.pit) + stateSinkObject.Save(5, &rp.flags) + stateSinkObject.Save(6, &rp.mustBeDir) + stateSinkObject.Save(7, &rp.mustBeDirOrig) + stateSinkObject.Save(8, &rp.symlinks) + stateSinkObject.Save(9, &rp.symlinksOrig) + stateSinkObject.Save(10, &rp.curPart) + stateSinkObject.Save(11, &rp.numOrigParts) + stateSinkObject.Save(12, &rp.creds) + stateSinkObject.Save(13, &rp.nextMount) + stateSinkObject.Save(14, &rp.nextStart) + stateSinkObject.Save(15, &rp.absSymlinkTarget) + stateSinkObject.Save(16, &rp.parts) + stateSinkObject.Save(17, &rp.origParts) +} + +func (rp *ResolvingPath) afterLoad() {} + +func (rp *ResolvingPath) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &rp.vfs) + stateSourceObject.Load(1, &rp.root) + stateSourceObject.Load(2, &rp.mount) + stateSourceObject.Load(3, &rp.start) + stateSourceObject.Load(4, &rp.pit) + stateSourceObject.Load(5, &rp.flags) + stateSourceObject.Load(6, &rp.mustBeDir) + stateSourceObject.Load(7, &rp.mustBeDirOrig) + stateSourceObject.Load(8, &rp.symlinks) + stateSourceObject.Load(9, &rp.symlinksOrig) + stateSourceObject.Load(10, &rp.curPart) + stateSourceObject.Load(11, &rp.numOrigParts) + stateSourceObject.Load(12, &rp.creds) + stateSourceObject.Load(13, &rp.nextMount) + stateSourceObject.Load(14, &rp.nextStart) + stateSourceObject.Load(15, &rp.absSymlinkTarget) + stateSourceObject.Load(16, &rp.parts) + stateSourceObject.Load(17, &rp.origParts) } func (r *resolveMountRootOrJumpError) StateTypeName() string { @@ -1713,11 +1713,11 @@ func (r *resolveAbsSymlinkError) afterLoad() {} func (r *resolveAbsSymlinkError) StateLoad(stateSourceObject state.Source) { } -func (v *VirtualFilesystem) StateTypeName() string { +func (vfs *VirtualFilesystem) StateTypeName() string { return "pkg/sentry/vfs.VirtualFilesystem" } -func (v *VirtualFilesystem) StateFields() []string { +func (vfs *VirtualFilesystem) StateFields() []string { return []string{ "mounts", "mountpoints", @@ -1731,33 +1731,33 @@ func (v *VirtualFilesystem) StateFields() []string { } } -func (v *VirtualFilesystem) beforeSave() {} +func (vfs *VirtualFilesystem) beforeSave() {} -func (v *VirtualFilesystem) StateSave(stateSinkObject state.Sink) { - v.beforeSave() - stateSinkObject.Save(0, &v.mounts) - stateSinkObject.Save(1, &v.mountpoints) - stateSinkObject.Save(2, &v.lastMountID) - stateSinkObject.Save(3, &v.anonMount) - stateSinkObject.Save(4, &v.devices) - stateSinkObject.Save(5, &v.anonBlockDevMinorNext) - stateSinkObject.Save(6, &v.anonBlockDevMinor) - stateSinkObject.Save(7, &v.fsTypes) - stateSinkObject.Save(8, &v.filesystems) +func (vfs *VirtualFilesystem) StateSave(stateSinkObject state.Sink) { + vfs.beforeSave() + stateSinkObject.Save(0, &vfs.mounts) + stateSinkObject.Save(1, &vfs.mountpoints) + stateSinkObject.Save(2, &vfs.lastMountID) + stateSinkObject.Save(3, &vfs.anonMount) + stateSinkObject.Save(4, &vfs.devices) + stateSinkObject.Save(5, &vfs.anonBlockDevMinorNext) + stateSinkObject.Save(6, &vfs.anonBlockDevMinor) + stateSinkObject.Save(7, &vfs.fsTypes) + stateSinkObject.Save(8, &vfs.filesystems) } -func (v *VirtualFilesystem) afterLoad() {} +func (vfs *VirtualFilesystem) afterLoad() {} -func (v *VirtualFilesystem) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &v.mounts) - stateSourceObject.Load(1, &v.mountpoints) - stateSourceObject.Load(2, &v.lastMountID) - stateSourceObject.Load(3, &v.anonMount) - stateSourceObject.Load(4, &v.devices) - stateSourceObject.Load(5, &v.anonBlockDevMinorNext) - stateSourceObject.Load(6, &v.anonBlockDevMinor) - stateSourceObject.Load(7, &v.fsTypes) - stateSourceObject.Load(8, &v.filesystems) +func (vfs *VirtualFilesystem) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &vfs.mounts) + stateSourceObject.Load(1, &vfs.mountpoints) + stateSourceObject.Load(2, &vfs.lastMountID) + stateSourceObject.Load(3, &vfs.anonMount) + stateSourceObject.Load(4, &vfs.devices) + stateSourceObject.Load(5, &vfs.anonBlockDevMinorNext) + stateSourceObject.Load(6, &vfs.anonBlockDevMinor) + stateSourceObject.Load(7, &vfs.fsTypes) + stateSourceObject.Load(8, &vfs.filesystems) } func (p *PathOperation) StateTypeName() string { @@ -1792,30 +1792,30 @@ func (p *PathOperation) StateLoad(stateSourceObject state.Source) { stateSourceObject.Load(3, &p.FollowFinalSymlink) } -func (v *VirtualDentry) StateTypeName() string { +func (vd *VirtualDentry) StateTypeName() string { return "pkg/sentry/vfs.VirtualDentry" } -func (v *VirtualDentry) StateFields() []string { +func (vd *VirtualDentry) StateFields() []string { return []string{ "mount", "dentry", } } -func (v *VirtualDentry) beforeSave() {} +func (vd *VirtualDentry) beforeSave() {} -func (v *VirtualDentry) StateSave(stateSinkObject state.Sink) { - v.beforeSave() - stateSinkObject.Save(0, &v.mount) - stateSinkObject.Save(1, &v.dentry) +func (vd *VirtualDentry) StateSave(stateSinkObject state.Sink) { + vd.beforeSave() + stateSinkObject.Save(0, &vd.mount) + stateSinkObject.Save(1, &vd.dentry) } -func (v *VirtualDentry) afterLoad() {} +func (vd *VirtualDentry) afterLoad() {} -func (v *VirtualDentry) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &v.mount) - stateSourceObject.Load(1, &v.dentry) +func (vd *VirtualDentry) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &vd.mount) + stateSourceObject.Load(1, &vd.dentry) } func init() { diff --git a/pkg/sentry/vfs/vfs_unsafe_state_autogen.go b/pkg/sentry/vfs/vfs_unsafe_state_autogen.go index 1dedacc1f..d23733ee7 100644 --- a/pkg/sentry/vfs/vfs_unsafe_state_autogen.go +++ b/pkg/sentry/vfs/vfs_unsafe_state_autogen.go @@ -9,30 +9,30 @@ import ( "gvisor.dev/gvisor/pkg/state" ) -func (m *mountTable) StateTypeName() string { +func (mt *mountTable) StateTypeName() string { return "pkg/sentry/vfs.mountTable" } -func (m *mountTable) StateFields() []string { +func (mt *mountTable) StateFields() []string { return []string{ "seed", "size", } } -func (m *mountTable) beforeSave() {} +func (mt *mountTable) beforeSave() {} -func (m *mountTable) StateSave(stateSinkObject state.Sink) { - m.beforeSave() - stateSinkObject.Save(0, &m.seed) - stateSinkObject.Save(1, &m.size) +func (mt *mountTable) StateSave(stateSinkObject state.Sink) { + mt.beforeSave() + stateSinkObject.Save(0, &mt.seed) + stateSinkObject.Save(1, &mt.size) } -func (m *mountTable) afterLoad() {} +func (mt *mountTable) afterLoad() {} -func (m *mountTable) StateLoad(stateSourceObject state.Source) { - stateSourceObject.Load(0, &m.seed) - stateSourceObject.Load(1, &m.size) +func (mt *mountTable) StateLoad(stateSourceObject state.Source) { + stateSourceObject.Load(0, &mt.seed) + stateSourceObject.Load(1, &mt.size) } func init() { |