// automatically generated by stateify.

package proc

import (
	"context"

	"gvisor.dev/gvisor/pkg/state"
)

func (r *fdDirInodeRefs) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.fdDirInodeRefs"
}

func (r *fdDirInodeRefs) StateFields() []string {
	return []string{
		"refCount",
	}
}

func (r *fdDirInodeRefs) beforeSave() {}

// +checklocksignore
func (r *fdDirInodeRefs) StateSave(stateSinkObject state.Sink) {
	r.beforeSave()
	stateSinkObject.Save(0, &r.refCount)
}

// +checklocksignore
func (r *fdDirInodeRefs) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &r.refCount)
	stateSourceObject.AfterLoad(func() { r.afterLoad(ctx) })
}

func (r *fdInfoDirInodeRefs) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.fdInfoDirInodeRefs"
}

func (r *fdInfoDirInodeRefs) StateFields() []string {
	return []string{
		"refCount",
	}
}

func (r *fdInfoDirInodeRefs) beforeSave() {}

// +checklocksignore
func (r *fdInfoDirInodeRefs) StateSave(stateSinkObject state.Sink) {
	r.beforeSave()
	stateSinkObject.Save(0, &r.refCount)
}

// +checklocksignore
func (r *fdInfoDirInodeRefs) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &r.refCount)
	stateSourceObject.AfterLoad(func() { r.afterLoad(ctx) })
}

func (ft *FilesystemType) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.FilesystemType"
}

func (ft *FilesystemType) StateFields() []string {
	return []string{}
}

func (ft *FilesystemType) beforeSave() {}

// +checklocksignore
func (ft *FilesystemType) StateSave(stateSinkObject state.Sink) {
	ft.beforeSave()
}

func (ft *FilesystemType) afterLoad(context.Context) {}

// +checklocksignore
func (ft *FilesystemType) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (fs *filesystem) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.filesystem"
}

func (fs *filesystem) StateFields() []string {
	return []string{
		"Filesystem",
		"devMinor",
	}
}

func (fs *filesystem) beforeSave() {}

// +checklocksignore
func (fs *filesystem) StateSave(stateSinkObject state.Sink) {
	fs.beforeSave()
	stateSinkObject.Save(0, &fs.Filesystem)
	stateSinkObject.Save(1, &fs.devMinor)
}

func (fs *filesystem) afterLoad(context.Context) {}

// +checklocksignore
func (fs *filesystem) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &fs.Filesystem)
	stateSourceObject.Load(1, &fs.devMinor)
}

func (s *staticFile) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.staticFile"
}

func (s *staticFile) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"StaticData",
	}
}

func (s *staticFile) beforeSave() {}

// +checklocksignore
func (s *staticFile) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.DynamicBytesFile)
	stateSinkObject.Save(1, &s.StaticData)
}

func (s *staticFile) afterLoad(context.Context) {}

// +checklocksignore
func (s *staticFile) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.DynamicBytesFile)
	stateSourceObject.Load(1, &s.StaticData)
}

func (i *InternalData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.InternalData"
}

func (i *InternalData) StateFields() []string {
	return []string{
		"ExtraInternalData",
		"Cgroups",
	}
}

func (i *InternalData) beforeSave() {}

// +checklocksignore
func (i *InternalData) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.ExtraInternalData)
	stateSinkObject.Save(1, &i.Cgroups)
}

func (i *InternalData) afterLoad(context.Context) {}

// +checklocksignore
func (i *InternalData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.ExtraInternalData)
	stateSourceObject.Load(1, &i.Cgroups)
}

func (i *implStatFS) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.implStatFS"
}

func (i *implStatFS) StateFields() []string {
	return []string{}
}

func (i *implStatFS) beforeSave() {}

// +checklocksignore
func (i *implStatFS) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
}

func (i *implStatFS) afterLoad(context.Context) {}

// +checklocksignore
func (i *implStatFS) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (i *subtasksInode) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.subtasksInode"
}

func (i *subtasksInode) StateFields() []string {
	return []string{
		"implStatFS",
		"InodeAlwaysValid",
		"InodeAttrs",
		"InodeDirectoryNoNewChildren",
		"InodeNotAnonymous",
		"InodeNotSymlink",
		"InodeTemporary",
		"InodeWatches",
		"OrderedChildren",
		"subtasksInodeRefs",
		"locks",
		"fs",
		"task",
		"pidns",
		"cgroupControllers",
	}
}

func (i *subtasksInode) beforeSave() {}

// +checklocksignore
func (i *subtasksInode) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.implStatFS)
	stateSinkObject.Save(1, &i.InodeAlwaysValid)
	stateSinkObject.Save(2, &i.InodeAttrs)
	stateSinkObject.Save(3, &i.InodeDirectoryNoNewChildren)
	stateSinkObject.Save(4, &i.InodeNotAnonymous)
	stateSinkObject.Save(5, &i.InodeNotSymlink)
	stateSinkObject.Save(6, &i.InodeTemporary)
	stateSinkObject.Save(7, &i.InodeWatches)
	stateSinkObject.Save(8, &i.OrderedChildren)
	stateSinkObject.Save(9, &i.subtasksInodeRefs)
	stateSinkObject.Save(10, &i.locks)
	stateSinkObject.Save(11, &i.fs)
	stateSinkObject.Save(12, &i.task)
	stateSinkObject.Save(13, &i.pidns)
	stateSinkObject.Save(14, &i.cgroupControllers)
}

func (i *subtasksInode) afterLoad(context.Context) {}

// +checklocksignore
func (i *subtasksInode) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.implStatFS)
	stateSourceObject.Load(1, &i.InodeAlwaysValid)
	stateSourceObject.Load(2, &i.InodeAttrs)
	stateSourceObject.Load(3, &i.InodeDirectoryNoNewChildren)
	stateSourceObject.Load(4, &i.InodeNotAnonymous)
	stateSourceObject.Load(5, &i.InodeNotSymlink)
	stateSourceObject.Load(6, &i.InodeTemporary)
	stateSourceObject.Load(7, &i.InodeWatches)
	stateSourceObject.Load(8, &i.OrderedChildren)
	stateSourceObject.Load(9, &i.subtasksInodeRefs)
	stateSourceObject.Load(10, &i.locks)
	stateSourceObject.Load(11, &i.fs)
	stateSourceObject.Load(12, &i.task)
	stateSourceObject.Load(13, &i.pidns)
	stateSourceObject.Load(14, &i.cgroupControllers)
}

func (fd *subtasksFD) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.subtasksFD"
}

func (fd *subtasksFD) StateFields() []string {
	return []string{
		"GenericDirectoryFD",
		"task",
	}
}

func (fd *subtasksFD) beforeSave() {}

// +checklocksignore
func (fd *subtasksFD) StateSave(stateSinkObject state.Sink) {
	fd.beforeSave()
	stateSinkObject.Save(0, &fd.GenericDirectoryFD)
	stateSinkObject.Save(1, &fd.task)
}

func (fd *subtasksFD) afterLoad(context.Context) {}

// +checklocksignore
func (fd *subtasksFD) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &fd.GenericDirectoryFD)
	stateSourceObject.Load(1, &fd.task)
}

func (r *subtasksInodeRefs) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.subtasksInodeRefs"
}

func (r *subtasksInodeRefs) StateFields() []string {
	return []string{
		"refCount",
	}
}

func (r *subtasksInodeRefs) beforeSave() {}

// +checklocksignore
func (r *subtasksInodeRefs) StateSave(stateSinkObject state.Sink) {
	r.beforeSave()
	stateSinkObject.Save(0, &r.refCount)
}

// +checklocksignore
func (r *subtasksInodeRefs) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &r.refCount)
	stateSourceObject.AfterLoad(func() { r.afterLoad(ctx) })
}

func (i *taskInode) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.taskInode"
}

func (i *taskInode) StateFields() []string {
	return []string{
		"implStatFS",
		"InodeAttrs",
		"InodeDirectoryNoNewChildren",
		"InodeNotAnonymous",
		"InodeNotSymlink",
		"InodeTemporary",
		"InodeWatches",
		"OrderedChildren",
		"taskInodeRefs",
		"locks",
		"task",
	}
}

func (i *taskInode) beforeSave() {}

// +checklocksignore
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.InodeNotAnonymous)
	stateSinkObject.Save(4, &i.InodeNotSymlink)
	stateSinkObject.Save(5, &i.InodeTemporary)
	stateSinkObject.Save(6, &i.InodeWatches)
	stateSinkObject.Save(7, &i.OrderedChildren)
	stateSinkObject.Save(8, &i.taskInodeRefs)
	stateSinkObject.Save(9, &i.locks)
	stateSinkObject.Save(10, &i.task)
}

func (i *taskInode) afterLoad(context.Context) {}

// +checklocksignore
func (i *taskInode) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.implStatFS)
	stateSourceObject.Load(1, &i.InodeAttrs)
	stateSourceObject.Load(2, &i.InodeDirectoryNoNewChildren)
	stateSourceObject.Load(3, &i.InodeNotAnonymous)
	stateSourceObject.Load(4, &i.InodeNotSymlink)
	stateSourceObject.Load(5, &i.InodeTemporary)
	stateSourceObject.Load(6, &i.InodeWatches)
	stateSourceObject.Load(7, &i.OrderedChildren)
	stateSourceObject.Load(8, &i.taskInodeRefs)
	stateSourceObject.Load(9, &i.locks)
	stateSourceObject.Load(10, &i.task)
}

func (i *taskOwnedInode) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.taskOwnedInode"
}

func (i *taskOwnedInode) StateFields() []string {
	return []string{
		"Inode",
		"owner",
	}
}

func (i *taskOwnedInode) beforeSave() {}

// +checklocksignore
func (i *taskOwnedInode) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.Inode)
	stateSinkObject.Save(1, &i.owner)
}

func (i *taskOwnedInode) afterLoad(context.Context) {}

// +checklocksignore
func (i *taskOwnedInode) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.Inode)
	stateSourceObject.Load(1, &i.owner)
}

func (i *fdDir) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.fdDir"
}

func (i *fdDir) StateFields() []string {
	return []string{
		"locks",
		"fs",
		"task",
		"produceSymlink",
	}
}

func (i *fdDir) beforeSave() {}

// +checklocksignore
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 (i *fdDir) afterLoad(context.Context) {}

// +checklocksignore
func (i *fdDir) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.locks)
	stateSourceObject.Load(1, &i.fs)
	stateSourceObject.Load(2, &i.task)
	stateSourceObject.Load(3, &i.produceSymlink)
}

func (i *fdDirInode) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.fdDirInode"
}

func (i *fdDirInode) StateFields() []string {
	return []string{
		"fdDir",
		"fdDirInodeRefs",
		"implStatFS",
		"InodeAlwaysValid",
		"InodeAttrs",
		"InodeDirectoryNoNewChildren",
		"InodeNotAnonymous",
		"InodeNotSymlink",
		"InodeTemporary",
		"InodeWatches",
		"OrderedChildren",
	}
}

func (i *fdDirInode) beforeSave() {}

// +checklocksignore
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.InodeAlwaysValid)
	stateSinkObject.Save(4, &i.InodeAttrs)
	stateSinkObject.Save(5, &i.InodeDirectoryNoNewChildren)
	stateSinkObject.Save(6, &i.InodeNotAnonymous)
	stateSinkObject.Save(7, &i.InodeNotSymlink)
	stateSinkObject.Save(8, &i.InodeTemporary)
	stateSinkObject.Save(9, &i.InodeWatches)
	stateSinkObject.Save(10, &i.OrderedChildren)
}

func (i *fdDirInode) afterLoad(context.Context) {}

// +checklocksignore
func (i *fdDirInode) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.fdDir)
	stateSourceObject.Load(1, &i.fdDirInodeRefs)
	stateSourceObject.Load(2, &i.implStatFS)
	stateSourceObject.Load(3, &i.InodeAlwaysValid)
	stateSourceObject.Load(4, &i.InodeAttrs)
	stateSourceObject.Load(5, &i.InodeDirectoryNoNewChildren)
	stateSourceObject.Load(6, &i.InodeNotAnonymous)
	stateSourceObject.Load(7, &i.InodeNotSymlink)
	stateSourceObject.Load(8, &i.InodeTemporary)
	stateSourceObject.Load(9, &i.InodeWatches)
	stateSourceObject.Load(10, &i.OrderedChildren)
}

func (s *fdSymlink) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.fdSymlink"
}

func (s *fdSymlink) StateFields() []string {
	return []string{
		"implStatFS",
		"InodeAttrs",
		"InodeNoopRefCount",
		"InodeNotAnonymous",
		"InodeSymlink",
		"InodeWatches",
		"fs",
		"task",
		"fd",
	}
}

func (s *fdSymlink) beforeSave() {}

// +checklocksignore
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.InodeNotAnonymous)
	stateSinkObject.Save(4, &s.InodeSymlink)
	stateSinkObject.Save(5, &s.InodeWatches)
	stateSinkObject.Save(6, &s.fs)
	stateSinkObject.Save(7, &s.task)
	stateSinkObject.Save(8, &s.fd)
}

func (s *fdSymlink) afterLoad(context.Context) {}

// +checklocksignore
func (s *fdSymlink) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.implStatFS)
	stateSourceObject.Load(1, &s.InodeAttrs)
	stateSourceObject.Load(2, &s.InodeNoopRefCount)
	stateSourceObject.Load(3, &s.InodeNotAnonymous)
	stateSourceObject.Load(4, &s.InodeSymlink)
	stateSourceObject.Load(5, &s.InodeWatches)
	stateSourceObject.Load(6, &s.fs)
	stateSourceObject.Load(7, &s.task)
	stateSourceObject.Load(8, &s.fd)
}

func (i *fdInfoDirInode) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.fdInfoDirInode"
}

func (i *fdInfoDirInode) StateFields() []string {
	return []string{
		"fdDir",
		"fdInfoDirInodeRefs",
		"implStatFS",
		"InodeAlwaysValid",
		"InodeAttrs",
		"InodeDirectoryNoNewChildren",
		"InodeNotAnonymous",
		"InodeNotSymlink",
		"InodeTemporary",
		"InodeWatches",
		"OrderedChildren",
	}
}

func (i *fdInfoDirInode) beforeSave() {}

// +checklocksignore
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.InodeAlwaysValid)
	stateSinkObject.Save(4, &i.InodeAttrs)
	stateSinkObject.Save(5, &i.InodeDirectoryNoNewChildren)
	stateSinkObject.Save(6, &i.InodeNotAnonymous)
	stateSinkObject.Save(7, &i.InodeNotSymlink)
	stateSinkObject.Save(8, &i.InodeTemporary)
	stateSinkObject.Save(9, &i.InodeWatches)
	stateSinkObject.Save(10, &i.OrderedChildren)
}

func (i *fdInfoDirInode) afterLoad(context.Context) {}

// +checklocksignore
func (i *fdInfoDirInode) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.fdDir)
	stateSourceObject.Load(1, &i.fdInfoDirInodeRefs)
	stateSourceObject.Load(2, &i.implStatFS)
	stateSourceObject.Load(3, &i.InodeAlwaysValid)
	stateSourceObject.Load(4, &i.InodeAttrs)
	stateSourceObject.Load(5, &i.InodeDirectoryNoNewChildren)
	stateSourceObject.Load(6, &i.InodeNotAnonymous)
	stateSourceObject.Load(7, &i.InodeNotSymlink)
	stateSourceObject.Load(8, &i.InodeTemporary)
	stateSourceObject.Load(9, &i.InodeWatches)
	stateSourceObject.Load(10, &i.OrderedChildren)
}

func (d *fdInfoData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.fdInfoData"
}

func (d *fdInfoData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"fs",
		"task",
		"fd",
	}
}

func (d *fdInfoData) beforeSave() {}

// +checklocksignore
func (d *fdInfoData) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.DynamicBytesFile)
	stateSinkObject.Save(1, &d.fs)
	stateSinkObject.Save(2, &d.task)
	stateSinkObject.Save(3, &d.fd)
}

func (d *fdInfoData) afterLoad(context.Context) {}

// +checklocksignore
func (d *fdInfoData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
	stateSourceObject.Load(1, &d.fs)
	stateSourceObject.Load(2, &d.task)
	stateSourceObject.Load(3, &d.fd)
}

func (d *auxvData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.auxvData"
}

func (d *auxvData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"task",
	}
}

func (d *auxvData) beforeSave() {}

// +checklocksignore
func (d *auxvData) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.DynamicBytesFile)
	stateSinkObject.Save(1, &d.task)
}

func (d *auxvData) afterLoad(context.Context) {}

// +checklocksignore
func (d *auxvData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
	stateSourceObject.Load(1, &d.task)
}

func (d *metadataData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.metadataData"
}

func (d *metadataData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"task",
		"metaType",
	}
}

func (d *metadataData) beforeSave() {}

// +checklocksignore
func (d *metadataData) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.DynamicBytesFile)
	stateSinkObject.Save(1, &d.task)
	stateSinkObject.Save(2, &d.metaType)
}

func (d *metadataData) afterLoad(context.Context) {}

// +checklocksignore
func (d *metadataData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
	stateSourceObject.Load(1, &d.task)
	stateSourceObject.Load(2, &d.metaType)
}

func (i *commInode) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.commInode"
}

func (i *commInode) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"task",
	}
}

func (i *commInode) beforeSave() {}

// +checklocksignore
func (i *commInode) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.DynamicBytesFile)
	stateSinkObject.Save(1, &i.task)
}

func (i *commInode) afterLoad(context.Context) {}

// +checklocksignore
func (i *commInode) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.DynamicBytesFile)
	stateSourceObject.Load(1, &i.task)
}

func (d *commData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.commData"
}

func (d *commData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"task",
	}
}

func (d *commData) beforeSave() {}

// +checklocksignore
func (d *commData) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.DynamicBytesFile)
	stateSinkObject.Save(1, &d.task)
}

func (d *commData) afterLoad(context.Context) {}

// +checklocksignore
func (d *commData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
	stateSourceObject.Load(1, &d.task)
}

func (d *idMapData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.idMapData"
}

func (d *idMapData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"task",
		"gids",
	}
}

func (d *idMapData) beforeSave() {}

// +checklocksignore
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 (d *idMapData) afterLoad(context.Context) {}

// +checklocksignore
func (d *idMapData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
	stateSourceObject.Load(1, &d.task)
	stateSourceObject.Load(2, &d.gids)
}

func (f *memInode) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.memInode"
}

func (f *memInode) StateFields() []string {
	return []string{
		"InodeAttrs",
		"InodeNoStatFS",
		"InodeNoopRefCount",
		"InodeNotAnonymous",
		"InodeNotDirectory",
		"InodeNotSymlink",
		"InodeWatches",
		"task",
		"locks",
	}
}

func (f *memInode) beforeSave() {}

// +checklocksignore
func (f *memInode) 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.InodeNotAnonymous)
	stateSinkObject.Save(4, &f.InodeNotDirectory)
	stateSinkObject.Save(5, &f.InodeNotSymlink)
	stateSinkObject.Save(6, &f.InodeWatches)
	stateSinkObject.Save(7, &f.task)
	stateSinkObject.Save(8, &f.locks)
}

func (f *memInode) afterLoad(context.Context) {}

// +checklocksignore
func (f *memInode) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &f.InodeAttrs)
	stateSourceObject.Load(1, &f.InodeNoStatFS)
	stateSourceObject.Load(2, &f.InodeNoopRefCount)
	stateSourceObject.Load(3, &f.InodeNotAnonymous)
	stateSourceObject.Load(4, &f.InodeNotDirectory)
	stateSourceObject.Load(5, &f.InodeNotSymlink)
	stateSourceObject.Load(6, &f.InodeWatches)
	stateSourceObject.Load(7, &f.task)
	stateSourceObject.Load(8, &f.locks)
}

func (fd *memFD) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.memFD"
}

func (fd *memFD) StateFields() []string {
	return []string{
		"vfsfd",
		"FileDescriptionDefaultImpl",
		"LockFD",
		"inode",
		"offset",
	}
}

func (fd *memFD) beforeSave() {}

// +checklocksignore
func (fd *memFD) StateSave(stateSinkObject state.Sink) {
	fd.beforeSave()
	stateSinkObject.Save(0, &fd.vfsfd)
	stateSinkObject.Save(1, &fd.FileDescriptionDefaultImpl)
	stateSinkObject.Save(2, &fd.LockFD)
	stateSinkObject.Save(3, &fd.inode)
	stateSinkObject.Save(4, &fd.offset)
}

func (fd *memFD) afterLoad(context.Context) {}

// +checklocksignore
func (fd *memFD) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &fd.vfsfd)
	stateSourceObject.Load(1, &fd.FileDescriptionDefaultImpl)
	stateSourceObject.Load(2, &fd.LockFD)
	stateSourceObject.Load(3, &fd.inode)
	stateSourceObject.Load(4, &fd.offset)
}

func (d *limitsData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.limitsData"
}

func (d *limitsData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"task",
	}
}

func (d *limitsData) beforeSave() {}

// +checklocksignore
func (d *limitsData) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.DynamicBytesFile)
	stateSinkObject.Save(1, &d.task)
}

func (d *limitsData) afterLoad(context.Context) {}

// +checklocksignore
func (d *limitsData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
	stateSourceObject.Load(1, &d.task)
}

func (d *mapsData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.mapsData"
}

func (d *mapsData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"task",
	}
}

func (d *mapsData) beforeSave() {}

// +checklocksignore
func (d *mapsData) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.DynamicBytesFile)
	stateSinkObject.Save(1, &d.task)
}

func (d *mapsData) afterLoad(context.Context) {}

// +checklocksignore
func (d *mapsData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
	stateSourceObject.Load(1, &d.task)
}

func (d *smapsData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.smapsData"
}

func (d *smapsData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"task",
	}
}

func (d *smapsData) beforeSave() {}

// +checklocksignore
func (d *smapsData) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.DynamicBytesFile)
	stateSinkObject.Save(1, &d.task)
}

func (d *smapsData) afterLoad(context.Context) {}

// +checklocksignore
func (d *smapsData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
	stateSourceObject.Load(1, &d.task)
}

func (s *taskStatData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.taskStatData"
}

func (s *taskStatData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"task",
		"tgstats",
		"pidns",
	}
}

func (s *taskStatData) beforeSave() {}

// +checklocksignore
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 (s *taskStatData) afterLoad(context.Context) {}

// +checklocksignore
func (s *taskStatData) StateLoad(ctx context.Context, 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 {
	return "pkg/sentry/fsimpl/proc.statmData"
}

func (s *statmData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"task",
	}
}

func (s *statmData) beforeSave() {}

// +checklocksignore
func (s *statmData) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.DynamicBytesFile)
	stateSinkObject.Save(1, &s.task)
}

func (s *statmData) afterLoad(context.Context) {}

// +checklocksignore
func (s *statmData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.DynamicBytesFile)
	stateSourceObject.Load(1, &s.task)
}

func (s *statusInode) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.statusInode"
}

func (s *statusInode) StateFields() []string {
	return []string{
		"InodeAttrs",
		"InodeNoStatFS",
		"InodeNoopRefCount",
		"InodeNotAnonymous",
		"InodeNotDirectory",
		"InodeNotSymlink",
		"InodeWatches",
		"task",
		"pidns",
		"locks",
	}
}

func (s *statusInode) beforeSave() {}

// +checklocksignore
func (s *statusInode) 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.InodeNotAnonymous)
	stateSinkObject.Save(4, &s.InodeNotDirectory)
	stateSinkObject.Save(5, &s.InodeNotSymlink)
	stateSinkObject.Save(6, &s.InodeWatches)
	stateSinkObject.Save(7, &s.task)
	stateSinkObject.Save(8, &s.pidns)
	stateSinkObject.Save(9, &s.locks)
}

func (s *statusInode) afterLoad(context.Context) {}

// +checklocksignore
func (s *statusInode) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.InodeAttrs)
	stateSourceObject.Load(1, &s.InodeNoStatFS)
	stateSourceObject.Load(2, &s.InodeNoopRefCount)
	stateSourceObject.Load(3, &s.InodeNotAnonymous)
	stateSourceObject.Load(4, &s.InodeNotDirectory)
	stateSourceObject.Load(5, &s.InodeNotSymlink)
	stateSourceObject.Load(6, &s.InodeWatches)
	stateSourceObject.Load(7, &s.task)
	stateSourceObject.Load(8, &s.pidns)
	stateSourceObject.Load(9, &s.locks)
}

func (s *statusFD) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.statusFD"
}

func (s *statusFD) StateFields() []string {
	return []string{
		"statusFDLowerBase",
		"DynamicBytesFileDescriptionImpl",
		"LockFD",
		"vfsfd",
		"inode",
		"task",
		"pidns",
		"userns",
	}
}

func (s *statusFD) beforeSave() {}

// +checklocksignore
func (s *statusFD) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.statusFDLowerBase)
	stateSinkObject.Save(1, &s.DynamicBytesFileDescriptionImpl)
	stateSinkObject.Save(2, &s.LockFD)
	stateSinkObject.Save(3, &s.vfsfd)
	stateSinkObject.Save(4, &s.inode)
	stateSinkObject.Save(5, &s.task)
	stateSinkObject.Save(6, &s.pidns)
	stateSinkObject.Save(7, &s.userns)
}

func (s *statusFD) afterLoad(context.Context) {}

// +checklocksignore
func (s *statusFD) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.statusFDLowerBase)
	stateSourceObject.Load(1, &s.DynamicBytesFileDescriptionImpl)
	stateSourceObject.Load(2, &s.LockFD)
	stateSourceObject.Load(3, &s.vfsfd)
	stateSourceObject.Load(4, &s.inode)
	stateSourceObject.Load(5, &s.task)
	stateSourceObject.Load(6, &s.pidns)
	stateSourceObject.Load(7, &s.userns)
}

func (s *statusFDLowerBase) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.statusFDLowerBase"
}

func (s *statusFDLowerBase) StateFields() []string {
	return []string{
		"FileDescriptionDefaultImpl",
	}
}

func (s *statusFDLowerBase) beforeSave() {}

// +checklocksignore
func (s *statusFDLowerBase) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.FileDescriptionDefaultImpl)
}

func (s *statusFDLowerBase) afterLoad(context.Context) {}

// +checklocksignore
func (s *statusFDLowerBase) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.FileDescriptionDefaultImpl)
}

func (i *ioData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.ioData"
}

func (i *ioData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"ioUsage",
	}
}

func (i *ioData) beforeSave() {}

// +checklocksignore
func (i *ioData) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.DynamicBytesFile)
	stateSinkObject.Save(1, &i.ioUsage)
}

func (i *ioData) afterLoad(context.Context) {}

// +checklocksignore
func (i *ioData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.DynamicBytesFile)
	stateSourceObject.Load(1, &i.ioUsage)
}

func (o *oomScoreAdj) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.oomScoreAdj"
}

func (o *oomScoreAdj) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"task",
	}
}

func (o *oomScoreAdj) beforeSave() {}

// +checklocksignore
func (o *oomScoreAdj) StateSave(stateSinkObject state.Sink) {
	o.beforeSave()
	stateSinkObject.Save(0, &o.DynamicBytesFile)
	stateSinkObject.Save(1, &o.task)
}

func (o *oomScoreAdj) afterLoad(context.Context) {}

// +checklocksignore
func (o *oomScoreAdj) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &o.DynamicBytesFile)
	stateSourceObject.Load(1, &o.task)
}

func (s *exeSymlink) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.exeSymlink"
}

func (s *exeSymlink) StateFields() []string {
	return []string{
		"implStatFS",
		"InodeAttrs",
		"InodeNoopRefCount",
		"InodeNotAnonymous",
		"InodeSymlink",
		"InodeWatches",
		"fs",
		"task",
	}
}

func (s *exeSymlink) beforeSave() {}

// +checklocksignore
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.InodeNotAnonymous)
	stateSinkObject.Save(4, &s.InodeSymlink)
	stateSinkObject.Save(5, &s.InodeWatches)
	stateSinkObject.Save(6, &s.fs)
	stateSinkObject.Save(7, &s.task)
}

func (s *exeSymlink) afterLoad(context.Context) {}

// +checklocksignore
func (s *exeSymlink) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.implStatFS)
	stateSourceObject.Load(1, &s.InodeAttrs)
	stateSourceObject.Load(2, &s.InodeNoopRefCount)
	stateSourceObject.Load(3, &s.InodeNotAnonymous)
	stateSourceObject.Load(4, &s.InodeSymlink)
	stateSourceObject.Load(5, &s.InodeWatches)
	stateSourceObject.Load(6, &s.fs)
	stateSourceObject.Load(7, &s.task)
}

func (s *cwdSymlink) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.cwdSymlink"
}

func (s *cwdSymlink) StateFields() []string {
	return []string{
		"implStatFS",
		"InodeAttrs",
		"InodeNoopRefCount",
		"InodeNotAnonymous",
		"InodeSymlink",
		"InodeWatches",
		"fs",
		"task",
	}
}

func (s *cwdSymlink) beforeSave() {}

// +checklocksignore
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.InodeNotAnonymous)
	stateSinkObject.Save(4, &s.InodeSymlink)
	stateSinkObject.Save(5, &s.InodeWatches)
	stateSinkObject.Save(6, &s.fs)
	stateSinkObject.Save(7, &s.task)
}

func (s *cwdSymlink) afterLoad(context.Context) {}

// +checklocksignore
func (s *cwdSymlink) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.implStatFS)
	stateSourceObject.Load(1, &s.InodeAttrs)
	stateSourceObject.Load(2, &s.InodeNoopRefCount)
	stateSourceObject.Load(3, &s.InodeNotAnonymous)
	stateSourceObject.Load(4, &s.InodeSymlink)
	stateSourceObject.Load(5, &s.InodeWatches)
	stateSourceObject.Load(6, &s.fs)
	stateSourceObject.Load(7, &s.task)
}

func (s *rootSymlink) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.rootSymlink"
}

func (s *rootSymlink) StateFields() []string {
	return []string{
		"implStatFS",
		"InodeAttrs",
		"InodeNoopRefCount",
		"InodeNotAnonymous",
		"InodeSymlink",
		"InodeWatches",
		"fs",
		"task",
	}
}

func (s *rootSymlink) beforeSave() {}

// +checklocksignore
func (s *rootSymlink) 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.InodeNotAnonymous)
	stateSinkObject.Save(4, &s.InodeSymlink)
	stateSinkObject.Save(5, &s.InodeWatches)
	stateSinkObject.Save(6, &s.fs)
	stateSinkObject.Save(7, &s.task)
}

func (s *rootSymlink) afterLoad(context.Context) {}

// +checklocksignore
func (s *rootSymlink) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.implStatFS)
	stateSourceObject.Load(1, &s.InodeAttrs)
	stateSourceObject.Load(2, &s.InodeNoopRefCount)
	stateSourceObject.Load(3, &s.InodeNotAnonymous)
	stateSourceObject.Load(4, &s.InodeSymlink)
	stateSourceObject.Load(5, &s.InodeWatches)
	stateSourceObject.Load(6, &s.fs)
	stateSourceObject.Load(7, &s.task)
}

func (i *mountInfoData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.mountInfoData"
}

func (i *mountInfoData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"fs",
		"task",
	}
}

func (i *mountInfoData) beforeSave() {}

// +checklocksignore
func (i *mountInfoData) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.DynamicBytesFile)
	stateSinkObject.Save(1, &i.fs)
	stateSinkObject.Save(2, &i.task)
}

func (i *mountInfoData) afterLoad(context.Context) {}

// +checklocksignore
func (i *mountInfoData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.DynamicBytesFile)
	stateSourceObject.Load(1, &i.fs)
	stateSourceObject.Load(2, &i.task)
}

func (i *mountsData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.mountsData"
}

func (i *mountsData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"fs",
		"task",
	}
}

func (i *mountsData) beforeSave() {}

// +checklocksignore
func (i *mountsData) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.DynamicBytesFile)
	stateSinkObject.Save(1, &i.fs)
	stateSinkObject.Save(2, &i.task)
}

func (i *mountsData) afterLoad(context.Context) {}

// +checklocksignore
func (i *mountsData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.DynamicBytesFile)
	stateSourceObject.Load(1, &i.fs)
	stateSourceObject.Load(2, &i.task)
}

func (s *namespaceSymlink) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.namespaceSymlink"
}

func (s *namespaceSymlink) StateFields() []string {
	return []string{
		"StaticSymlink",
		"task",
		"nsType",
	}
}

func (s *namespaceSymlink) beforeSave() {}

// +checklocksignore
func (s *namespaceSymlink) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.StaticSymlink)
	stateSinkObject.Save(1, &s.task)
	stateSinkObject.Save(2, &s.nsType)
}

func (s *namespaceSymlink) afterLoad(context.Context) {}

// +checklocksignore
func (s *namespaceSymlink) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.StaticSymlink)
	stateSourceObject.Load(1, &s.task)
	stateSourceObject.Load(2, &s.nsType)
}

func (i *namespaceInode) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.namespaceInode"
}

func (i *namespaceInode) StateFields() []string {
	return []string{
		"implStatFS",
		"InodeAttrs",
		"InodeNoopRefCount",
		"InodeNotAnonymous",
		"InodeNotDirectory",
		"InodeNotSymlink",
		"InodeWatches",
		"locks",
	}
}

func (i *namespaceInode) beforeSave() {}

// +checklocksignore
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.InodeNotAnonymous)
	stateSinkObject.Save(4, &i.InodeNotDirectory)
	stateSinkObject.Save(5, &i.InodeNotSymlink)
	stateSinkObject.Save(6, &i.InodeWatches)
	stateSinkObject.Save(7, &i.locks)
}

func (i *namespaceInode) afterLoad(context.Context) {}

// +checklocksignore
func (i *namespaceInode) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.implStatFS)
	stateSourceObject.Load(1, &i.InodeAttrs)
	stateSourceObject.Load(2, &i.InodeNoopRefCount)
	stateSourceObject.Load(3, &i.InodeNotAnonymous)
	stateSourceObject.Load(4, &i.InodeNotDirectory)
	stateSourceObject.Load(5, &i.InodeNotSymlink)
	stateSourceObject.Load(6, &i.InodeWatches)
	stateSourceObject.Load(7, &i.locks)
}

func (fd *namespaceFD) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.namespaceFD"
}

func (fd *namespaceFD) StateFields() []string {
	return []string{
		"FileDescriptionDefaultImpl",
		"LockFD",
		"vfsfd",
		"inode",
	}
}

func (fd *namespaceFD) beforeSave() {}

// +checklocksignore
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 (fd *namespaceFD) afterLoad(context.Context) {}

// +checklocksignore
func (fd *namespaceFD) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &fd.FileDescriptionDefaultImpl)
	stateSourceObject.Load(1, &fd.LockFD)
	stateSourceObject.Load(2, &fd.vfsfd)
	stateSourceObject.Load(3, &fd.inode)
}

func (d *taskCgroupData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.taskCgroupData"
}

func (d *taskCgroupData) StateFields() []string {
	return []string{
		"dynamicBytesFileSetAttr",
		"task",
	}
}

func (d *taskCgroupData) beforeSave() {}

// +checklocksignore
func (d *taskCgroupData) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.dynamicBytesFileSetAttr)
	stateSinkObject.Save(1, &d.task)
}

func (d *taskCgroupData) afterLoad(context.Context) {}

// +checklocksignore
func (d *taskCgroupData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.dynamicBytesFileSetAttr)
	stateSourceObject.Load(1, &d.task)
}

func (d *childrenData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.childrenData"
}

func (d *childrenData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"task",
		"pidns",
	}
}

func (d *childrenData) beforeSave() {}

// +checklocksignore
func (d *childrenData) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.DynamicBytesFile)
	stateSinkObject.Save(1, &d.task)
	stateSinkObject.Save(2, &d.pidns)
}

func (d *childrenData) afterLoad(context.Context) {}

// +checklocksignore
func (d *childrenData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
	stateSourceObject.Load(1, &d.task)
	stateSourceObject.Load(2, &d.pidns)
}

func (r *taskInodeRefs) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.taskInodeRefs"
}

func (r *taskInodeRefs) StateFields() []string {
	return []string{
		"refCount",
	}
}

func (r *taskInodeRefs) beforeSave() {}

// +checklocksignore
func (r *taskInodeRefs) StateSave(stateSinkObject state.Sink) {
	r.beforeSave()
	stateSinkObject.Save(0, &r.refCount)
}

// +checklocksignore
func (r *taskInodeRefs) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &r.refCount)
	stateSourceObject.AfterLoad(func() { r.afterLoad(ctx) })
}

func (n *ifinet6) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.ifinet6"
}

func (n *ifinet6) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"stack",
	}
}

func (n *ifinet6) beforeSave() {}

// +checklocksignore
func (n *ifinet6) StateSave(stateSinkObject state.Sink) {
	n.beforeSave()
	stateSinkObject.Save(0, &n.DynamicBytesFile)
	stateSinkObject.Save(1, &n.stack)
}

func (n *ifinet6) afterLoad(context.Context) {}

// +checklocksignore
func (n *ifinet6) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &n.DynamicBytesFile)
	stateSourceObject.Load(1, &n.stack)
}

func (n *netDevData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.netDevData"
}

func (n *netDevData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"stack",
	}
}

func (n *netDevData) beforeSave() {}

// +checklocksignore
func (n *netDevData) StateSave(stateSinkObject state.Sink) {
	n.beforeSave()
	stateSinkObject.Save(0, &n.DynamicBytesFile)
	stateSinkObject.Save(1, &n.stack)
}

func (n *netDevData) afterLoad(context.Context) {}

// +checklocksignore
func (n *netDevData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &n.DynamicBytesFile)
	stateSourceObject.Load(1, &n.stack)
}

func (n *netUnixData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.netUnixData"
}

func (n *netUnixData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"kernel",
	}
}

func (n *netUnixData) beforeSave() {}

// +checklocksignore
func (n *netUnixData) StateSave(stateSinkObject state.Sink) {
	n.beforeSave()
	stateSinkObject.Save(0, &n.DynamicBytesFile)
	stateSinkObject.Save(1, &n.kernel)
}

func (n *netUnixData) afterLoad(context.Context) {}

// +checklocksignore
func (n *netUnixData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &n.DynamicBytesFile)
	stateSourceObject.Load(1, &n.kernel)
}

func (d *netTCPData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.netTCPData"
}

func (d *netTCPData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"kernel",
	}
}

func (d *netTCPData) beforeSave() {}

// +checklocksignore
func (d *netTCPData) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.DynamicBytesFile)
	stateSinkObject.Save(1, &d.kernel)
}

func (d *netTCPData) afterLoad(context.Context) {}

// +checklocksignore
func (d *netTCPData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
	stateSourceObject.Load(1, &d.kernel)
}

func (d *netTCP6Data) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.netTCP6Data"
}

func (d *netTCP6Data) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"kernel",
	}
}

func (d *netTCP6Data) beforeSave() {}

// +checklocksignore
func (d *netTCP6Data) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.DynamicBytesFile)
	stateSinkObject.Save(1, &d.kernel)
}

func (d *netTCP6Data) afterLoad(context.Context) {}

// +checklocksignore
func (d *netTCP6Data) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
	stateSourceObject.Load(1, &d.kernel)
}

func (d *netUDPData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.netUDPData"
}

func (d *netUDPData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"kernel",
	}
}

func (d *netUDPData) beforeSave() {}

// +checklocksignore
func (d *netUDPData) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.DynamicBytesFile)
	stateSinkObject.Save(1, &d.kernel)
}

func (d *netUDPData) afterLoad(context.Context) {}

// +checklocksignore
func (d *netUDPData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
	stateSourceObject.Load(1, &d.kernel)
}

func (d *netSnmpData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.netSnmpData"
}

func (d *netSnmpData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"stack",
	}
}

func (d *netSnmpData) beforeSave() {}

// +checklocksignore
func (d *netSnmpData) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.DynamicBytesFile)
	stateSinkObject.Save(1, &d.stack)
}

func (d *netSnmpData) afterLoad(context.Context) {}

// +checklocksignore
func (d *netSnmpData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
	stateSourceObject.Load(1, &d.stack)
}

func (s *snmpLine) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.snmpLine"
}

func (s *snmpLine) StateFields() []string {
	return []string{
		"prefix",
		"header",
	}
}

func (s *snmpLine) beforeSave() {}

// +checklocksignore
func (s *snmpLine) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.prefix)
	stateSinkObject.Save(1, &s.header)
}

func (s *snmpLine) afterLoad(context.Context) {}

// +checklocksignore
func (s *snmpLine) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.prefix)
	stateSourceObject.Load(1, &s.header)
}

func (d *netRouteData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.netRouteData"
}

func (d *netRouteData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"stack",
	}
}

func (d *netRouteData) beforeSave() {}

// +checklocksignore
func (d *netRouteData) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.DynamicBytesFile)
	stateSinkObject.Save(1, &d.stack)
}

func (d *netRouteData) afterLoad(context.Context) {}

// +checklocksignore
func (d *netRouteData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
	stateSourceObject.Load(1, &d.stack)
}

func (d *netStatData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.netStatData"
}

func (d *netStatData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"stack",
	}
}

func (d *netStatData) beforeSave() {}

// +checklocksignore
func (d *netStatData) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.DynamicBytesFile)
	stateSinkObject.Save(1, &d.stack)
}

func (d *netStatData) afterLoad(context.Context) {}

// +checklocksignore
func (d *netStatData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
	stateSourceObject.Load(1, &d.stack)
}

func (i *tasksInode) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.tasksInode"
}

func (i *tasksInode) StateFields() []string {
	return []string{
		"implStatFS",
		"InodeAlwaysValid",
		"InodeAttrs",
		"InodeDirectoryNoNewChildren",
		"InodeNotAnonymous",
		"InodeNotSymlink",
		"InodeTemporary",
		"InodeWatches",
		"OrderedChildren",
		"tasksInodeRefs",
		"locks",
		"fs",
		"pidns",
		"fakeCgroupControllers",
	}
}

func (i *tasksInode) beforeSave() {}

// +checklocksignore
func (i *tasksInode) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.implStatFS)
	stateSinkObject.Save(1, &i.InodeAlwaysValid)
	stateSinkObject.Save(2, &i.InodeAttrs)
	stateSinkObject.Save(3, &i.InodeDirectoryNoNewChildren)
	stateSinkObject.Save(4, &i.InodeNotAnonymous)
	stateSinkObject.Save(5, &i.InodeNotSymlink)
	stateSinkObject.Save(6, &i.InodeTemporary)
	stateSinkObject.Save(7, &i.InodeWatches)
	stateSinkObject.Save(8, &i.OrderedChildren)
	stateSinkObject.Save(9, &i.tasksInodeRefs)
	stateSinkObject.Save(10, &i.locks)
	stateSinkObject.Save(11, &i.fs)
	stateSinkObject.Save(12, &i.pidns)
	stateSinkObject.Save(13, &i.fakeCgroupControllers)
}

func (i *tasksInode) afterLoad(context.Context) {}

// +checklocksignore
func (i *tasksInode) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.implStatFS)
	stateSourceObject.Load(1, &i.InodeAlwaysValid)
	stateSourceObject.Load(2, &i.InodeAttrs)
	stateSourceObject.Load(3, &i.InodeDirectoryNoNewChildren)
	stateSourceObject.Load(4, &i.InodeNotAnonymous)
	stateSourceObject.Load(5, &i.InodeNotSymlink)
	stateSourceObject.Load(6, &i.InodeTemporary)
	stateSourceObject.Load(7, &i.InodeWatches)
	stateSourceObject.Load(8, &i.OrderedChildren)
	stateSourceObject.Load(9, &i.tasksInodeRefs)
	stateSourceObject.Load(10, &i.locks)
	stateSourceObject.Load(11, &i.fs)
	stateSourceObject.Load(12, &i.pidns)
	stateSourceObject.Load(13, &i.fakeCgroupControllers)
}

func (s *staticFileSetStat) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.staticFileSetStat"
}

func (s *staticFileSetStat) StateFields() []string {
	return []string{
		"dynamicBytesFileSetAttr",
		"StaticData",
	}
}

func (s *staticFileSetStat) beforeSave() {}

// +checklocksignore
func (s *staticFileSetStat) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.dynamicBytesFileSetAttr)
	stateSinkObject.Save(1, &s.StaticData)
}

func (s *staticFileSetStat) afterLoad(context.Context) {}

// +checklocksignore
func (s *staticFileSetStat) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.dynamicBytesFileSetAttr)
	stateSourceObject.Load(1, &s.StaticData)
}

func (s *selfSymlink) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.selfSymlink"
}

func (s *selfSymlink) StateFields() []string {
	return []string{
		"implStatFS",
		"InodeAttrs",
		"InodeNoopRefCount",
		"InodeNotAnonymous",
		"InodeSymlink",
		"InodeWatches",
		"pidns",
	}
}

func (s *selfSymlink) beforeSave() {}

// +checklocksignore
func (s *selfSymlink) 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.InodeNotAnonymous)
	stateSinkObject.Save(4, &s.InodeSymlink)
	stateSinkObject.Save(5, &s.InodeWatches)
	stateSinkObject.Save(6, &s.pidns)
}

func (s *selfSymlink) afterLoad(context.Context) {}

// +checklocksignore
func (s *selfSymlink) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.implStatFS)
	stateSourceObject.Load(1, &s.InodeAttrs)
	stateSourceObject.Load(2, &s.InodeNoopRefCount)
	stateSourceObject.Load(3, &s.InodeNotAnonymous)
	stateSourceObject.Load(4, &s.InodeSymlink)
	stateSourceObject.Load(5, &s.InodeWatches)
	stateSourceObject.Load(6, &s.pidns)
}

func (s *threadSelfSymlink) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.threadSelfSymlink"
}

func (s *threadSelfSymlink) StateFields() []string {
	return []string{
		"implStatFS",
		"InodeAttrs",
		"InodeNoopRefCount",
		"InodeNotAnonymous",
		"InodeSymlink",
		"InodeWatches",
		"pidns",
	}
}

func (s *threadSelfSymlink) beforeSave() {}

// +checklocksignore
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.InodeNotAnonymous)
	stateSinkObject.Save(4, &s.InodeSymlink)
	stateSinkObject.Save(5, &s.InodeWatches)
	stateSinkObject.Save(6, &s.pidns)
}

func (s *threadSelfSymlink) afterLoad(context.Context) {}

// +checklocksignore
func (s *threadSelfSymlink) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.implStatFS)
	stateSourceObject.Load(1, &s.InodeAttrs)
	stateSourceObject.Load(2, &s.InodeNoopRefCount)
	stateSourceObject.Load(3, &s.InodeNotAnonymous)
	stateSourceObject.Load(4, &s.InodeSymlink)
	stateSourceObject.Load(5, &s.InodeWatches)
	stateSourceObject.Load(6, &s.pidns)
}

func (d *dynamicBytesFileSetAttr) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.dynamicBytesFileSetAttr"
}

func (d *dynamicBytesFileSetAttr) StateFields() []string {
	return []string{
		"DynamicBytesFile",
	}
}

func (d *dynamicBytesFileSetAttr) beforeSave() {}

// +checklocksignore
func (d *dynamicBytesFileSetAttr) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.DynamicBytesFile)
}

func (d *dynamicBytesFileSetAttr) afterLoad(context.Context) {}

// +checklocksignore
func (d *dynamicBytesFileSetAttr) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
}

func (c *cpuStats) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.cpuStats"
}

func (c *cpuStats) StateFields() []string {
	return []string{
		"user",
		"nice",
		"system",
		"idle",
		"ioWait",
		"irq",
		"softirq",
		"steal",
		"guest",
		"guestNice",
	}
}

func (c *cpuStats) beforeSave() {}

// +checklocksignore
func (c *cpuStats) StateSave(stateSinkObject state.Sink) {
	c.beforeSave()
	stateSinkObject.Save(0, &c.user)
	stateSinkObject.Save(1, &c.nice)
	stateSinkObject.Save(2, &c.system)
	stateSinkObject.Save(3, &c.idle)
	stateSinkObject.Save(4, &c.ioWait)
	stateSinkObject.Save(5, &c.irq)
	stateSinkObject.Save(6, &c.softirq)
	stateSinkObject.Save(7, &c.steal)
	stateSinkObject.Save(8, &c.guest)
	stateSinkObject.Save(9, &c.guestNice)
}

func (c *cpuStats) afterLoad(context.Context) {}

// +checklocksignore
func (c *cpuStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &c.user)
	stateSourceObject.Load(1, &c.nice)
	stateSourceObject.Load(2, &c.system)
	stateSourceObject.Load(3, &c.idle)
	stateSourceObject.Load(4, &c.ioWait)
	stateSourceObject.Load(5, &c.irq)
	stateSourceObject.Load(6, &c.softirq)
	stateSourceObject.Load(7, &c.steal)
	stateSourceObject.Load(8, &c.guest)
	stateSourceObject.Load(9, &c.guestNice)
}

func (s *statData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.statData"
}

func (s *statData) StateFields() []string {
	return []string{
		"dynamicBytesFileSetAttr",
	}
}

func (s *statData) beforeSave() {}

// +checklocksignore
func (s *statData) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.dynamicBytesFileSetAttr)
}

func (s *statData) afterLoad(context.Context) {}

// +checklocksignore
func (s *statData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.dynamicBytesFileSetAttr)
}

func (l *loadavgData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.loadavgData"
}

func (l *loadavgData) StateFields() []string {
	return []string{
		"dynamicBytesFileSetAttr",
	}
}

func (l *loadavgData) beforeSave() {}

// +checklocksignore
func (l *loadavgData) StateSave(stateSinkObject state.Sink) {
	l.beforeSave()
	stateSinkObject.Save(0, &l.dynamicBytesFileSetAttr)
}

func (l *loadavgData) afterLoad(context.Context) {}

// +checklocksignore
func (l *loadavgData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &l.dynamicBytesFileSetAttr)
}

func (m *meminfoData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.meminfoData"
}

func (m *meminfoData) StateFields() []string {
	return []string{
		"dynamicBytesFileSetAttr",
	}
}

func (m *meminfoData) beforeSave() {}

// +checklocksignore
func (m *meminfoData) StateSave(stateSinkObject state.Sink) {
	m.beforeSave()
	stateSinkObject.Save(0, &m.dynamicBytesFileSetAttr)
}

func (m *meminfoData) afterLoad(context.Context) {}

// +checklocksignore
func (m *meminfoData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &m.dynamicBytesFileSetAttr)
}

func (u *uptimeData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.uptimeData"
}

func (u *uptimeData) StateFields() []string {
	return []string{
		"dynamicBytesFileSetAttr",
	}
}

func (u *uptimeData) beforeSave() {}

// +checklocksignore
func (u *uptimeData) StateSave(stateSinkObject state.Sink) {
	u.beforeSave()
	stateSinkObject.Save(0, &u.dynamicBytesFileSetAttr)
}

func (u *uptimeData) afterLoad(context.Context) {}

// +checklocksignore
func (u *uptimeData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &u.dynamicBytesFileSetAttr)
}

func (v *versionData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.versionData"
}

func (v *versionData) StateFields() []string {
	return []string{
		"dynamicBytesFileSetAttr",
	}
}

func (v *versionData) beforeSave() {}

// +checklocksignore
func (v *versionData) StateSave(stateSinkObject state.Sink) {
	v.beforeSave()
	stateSinkObject.Save(0, &v.dynamicBytesFileSetAttr)
}

func (v *versionData) afterLoad(context.Context) {}

// +checklocksignore
func (v *versionData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &v.dynamicBytesFileSetAttr)
}

func (d *filesystemsData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.filesystemsData"
}

func (d *filesystemsData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
	}
}

func (d *filesystemsData) beforeSave() {}

// +checklocksignore
func (d *filesystemsData) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.DynamicBytesFile)
}

func (d *filesystemsData) afterLoad(context.Context) {}

// +checklocksignore
func (d *filesystemsData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
}

func (c *cgroupsData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.cgroupsData"
}

func (c *cgroupsData) StateFields() []string {
	return []string{
		"dynamicBytesFileSetAttr",
	}
}

func (c *cgroupsData) beforeSave() {}

// +checklocksignore
func (c *cgroupsData) StateSave(stateSinkObject state.Sink) {
	c.beforeSave()
	stateSinkObject.Save(0, &c.dynamicBytesFileSetAttr)
}

func (c *cgroupsData) afterLoad(context.Context) {}

// +checklocksignore
func (c *cgroupsData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &c.dynamicBytesFileSetAttr)
}

func (c *cmdLineData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.cmdLineData"
}

func (c *cmdLineData) StateFields() []string {
	return []string{
		"dynamicBytesFileSetAttr",
	}
}

func (c *cmdLineData) beforeSave() {}

// +checklocksignore
func (c *cmdLineData) StateSave(stateSinkObject state.Sink) {
	c.beforeSave()
	stateSinkObject.Save(0, &c.dynamicBytesFileSetAttr)
}

func (c *cmdLineData) afterLoad(context.Context) {}

// +checklocksignore
func (c *cmdLineData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &c.dynamicBytesFileSetAttr)
}

func (s *sentryMeminfoData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.sentryMeminfoData"
}

func (s *sentryMeminfoData) StateFields() []string {
	return []string{
		"dynamicBytesFileSetAttr",
	}
}

func (s *sentryMeminfoData) beforeSave() {}

// +checklocksignore
func (s *sentryMeminfoData) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.dynamicBytesFileSetAttr)
}

func (s *sentryMeminfoData) afterLoad(context.Context) {}

// +checklocksignore
func (s *sentryMeminfoData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.dynamicBytesFileSetAttr)
}

func (r *tasksInodeRefs) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.tasksInodeRefs"
}

func (r *tasksInodeRefs) StateFields() []string {
	return []string{
		"refCount",
	}
}

func (r *tasksInodeRefs) beforeSave() {}

// +checklocksignore
func (r *tasksInodeRefs) StateSave(stateSinkObject state.Sink) {
	r.beforeSave()
	stateSinkObject.Save(0, &r.refCount)
}

// +checklocksignore
func (r *tasksInodeRefs) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &r.refCount)
	stateSourceObject.AfterLoad(func() { r.afterLoad(ctx) })
}

func (t *tcpMemDir) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.tcpMemDir"
}

func (t *tcpMemDir) StateFields() []string {
	return nil
}

func (d *mmapMinAddrData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.mmapMinAddrData"
}

func (d *mmapMinAddrData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"k",
	}
}

func (d *mmapMinAddrData) beforeSave() {}

// +checklocksignore
func (d *mmapMinAddrData) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.DynamicBytesFile)
	stateSinkObject.Save(1, &d.k)
}

func (d *mmapMinAddrData) afterLoad(context.Context) {}

// +checklocksignore
func (d *mmapMinAddrData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
	stateSourceObject.Load(1, &d.k)
}

func (h *hostnameData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.hostnameData"
}

func (h *hostnameData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
	}
}

func (h *hostnameData) beforeSave() {}

// +checklocksignore
func (h *hostnameData) StateSave(stateSinkObject state.Sink) {
	h.beforeSave()
	stateSinkObject.Save(0, &h.DynamicBytesFile)
}

func (h *hostnameData) afterLoad(context.Context) {}

// +checklocksignore
func (h *hostnameData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &h.DynamicBytesFile)
}

func (d *tcpSackData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.tcpSackData"
}

func (d *tcpSackData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"stack",
		"enabled",
	}
}

func (d *tcpSackData) beforeSave() {}

// +checklocksignore
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 (d *tcpSackData) afterLoad(context.Context) {}

// +checklocksignore
func (d *tcpSackData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
	stateSourceObject.LoadWait(1, &d.stack)
	stateSourceObject.Load(2, &d.enabled)
}

func (d *tcpRecoveryData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.tcpRecoveryData"
}

func (d *tcpRecoveryData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"stack",
	}
}

func (d *tcpRecoveryData) beforeSave() {}

// +checklocksignore
func (d *tcpRecoveryData) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.DynamicBytesFile)
	stateSinkObject.Save(1, &d.stack)
}

func (d *tcpRecoveryData) afterLoad(context.Context) {}

// +checklocksignore
func (d *tcpRecoveryData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
	stateSourceObject.LoadWait(1, &d.stack)
}

func (d *tcpMemData) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.tcpMemData"
}

func (d *tcpMemData) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"dir",
		"stack",
	}
}

func (d *tcpMemData) beforeSave() {}

// +checklocksignore
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 (d *tcpMemData) afterLoad(context.Context) {}

// +checklocksignore
func (d *tcpMemData) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.DynamicBytesFile)
	stateSourceObject.Load(1, &d.dir)
	stateSourceObject.LoadWait(2, &d.stack)
}

func (ipf *ipForwarding) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.ipForwarding"
}

func (ipf *ipForwarding) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"stack",
		"enabled",
	}
}

func (ipf *ipForwarding) beforeSave() {}

// +checklocksignore
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 (ipf *ipForwarding) afterLoad(context.Context) {}

// +checklocksignore
func (ipf *ipForwarding) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &ipf.DynamicBytesFile)
	stateSourceObject.LoadWait(1, &ipf.stack)
	stateSourceObject.Load(2, &ipf.enabled)
}

func (pr *portRange) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.portRange"
}

func (pr *portRange) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"stack",
		"start",
		"end",
	}
}

func (pr *portRange) beforeSave() {}

// +checklocksignore
func (pr *portRange) StateSave(stateSinkObject state.Sink) {
	pr.beforeSave()
	stateSinkObject.Save(0, &pr.DynamicBytesFile)
	stateSinkObject.Save(1, &pr.stack)
	stateSinkObject.Save(2, &pr.start)
	stateSinkObject.Save(3, &pr.end)
}

func (pr *portRange) afterLoad(context.Context) {}

// +checklocksignore
func (pr *portRange) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &pr.DynamicBytesFile)
	stateSourceObject.LoadWait(1, &pr.stack)
	stateSourceObject.Load(2, &pr.start)
	stateSourceObject.Load(3, &pr.end)
}

func (f *atomicInt32File) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.atomicInt32File"
}

func (f *atomicInt32File) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"val",
		"min",
		"max",
	}
}

func (f *atomicInt32File) beforeSave() {}

// +checklocksignore
func (f *atomicInt32File) StateSave(stateSinkObject state.Sink) {
	f.beforeSave()
	stateSinkObject.Save(0, &f.DynamicBytesFile)
	stateSinkObject.Save(1, &f.val)
	stateSinkObject.Save(2, &f.min)
	stateSinkObject.Save(3, &f.max)
}

func (f *atomicInt32File) afterLoad(context.Context) {}

// +checklocksignore
func (f *atomicInt32File) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &f.DynamicBytesFile)
	stateSourceObject.Load(1, &f.val)
	stateSourceObject.Load(2, &f.min)
	stateSourceObject.Load(3, &f.max)
}

func (s *yamaPtraceScope) StateTypeName() string {
	return "pkg/sentry/fsimpl/proc.yamaPtraceScope"
}

func (s *yamaPtraceScope) StateFields() []string {
	return []string{
		"DynamicBytesFile",
		"level",
	}
}

func (s *yamaPtraceScope) beforeSave() {}

// +checklocksignore
func (s *yamaPtraceScope) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.DynamicBytesFile)
	stateSinkObject.Save(1, &s.level)
}

func (s *yamaPtraceScope) afterLoad(context.Context) {}

// +checklocksignore
func (s *yamaPtraceScope) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.DynamicBytesFile)
	stateSourceObject.Load(1, &s.level)
}

func init() {
	state.Register((*fdDirInodeRefs)(nil))
	state.Register((*fdInfoDirInodeRefs)(nil))
	state.Register((*FilesystemType)(nil))
	state.Register((*filesystem)(nil))
	state.Register((*staticFile)(nil))
	state.Register((*InternalData)(nil))
	state.Register((*implStatFS)(nil))
	state.Register((*subtasksInode)(nil))
	state.Register((*subtasksFD)(nil))
	state.Register((*subtasksInodeRefs)(nil))
	state.Register((*taskInode)(nil))
	state.Register((*taskOwnedInode)(nil))
	state.Register((*fdDir)(nil))
	state.Register((*fdDirInode)(nil))
	state.Register((*fdSymlink)(nil))
	state.Register((*fdInfoDirInode)(nil))
	state.Register((*fdInfoData)(nil))
	state.Register((*auxvData)(nil))
	state.Register((*metadataData)(nil))
	state.Register((*commInode)(nil))
	state.Register((*commData)(nil))
	state.Register((*idMapData)(nil))
	state.Register((*memInode)(nil))
	state.Register((*memFD)(nil))
	state.Register((*limitsData)(nil))
	state.Register((*mapsData)(nil))
	state.Register((*smapsData)(nil))
	state.Register((*taskStatData)(nil))
	state.Register((*statmData)(nil))
	state.Register((*statusInode)(nil))
	state.Register((*statusFD)(nil))
	state.Register((*statusFDLowerBase)(nil))
	state.Register((*ioData)(nil))
	state.Register((*oomScoreAdj)(nil))
	state.Register((*exeSymlink)(nil))
	state.Register((*cwdSymlink)(nil))
	state.Register((*rootSymlink)(nil))
	state.Register((*mountInfoData)(nil))
	state.Register((*mountsData)(nil))
	state.Register((*namespaceSymlink)(nil))
	state.Register((*namespaceInode)(nil))
	state.Register((*namespaceFD)(nil))
	state.Register((*taskCgroupData)(nil))
	state.Register((*childrenData)(nil))
	state.Register((*taskInodeRefs)(nil))
	state.Register((*ifinet6)(nil))
	state.Register((*netDevData)(nil))
	state.Register((*netUnixData)(nil))
	state.Register((*netTCPData)(nil))
	state.Register((*netTCP6Data)(nil))
	state.Register((*netUDPData)(nil))
	state.Register((*netSnmpData)(nil))
	state.Register((*snmpLine)(nil))
	state.Register((*netRouteData)(nil))
	state.Register((*netStatData)(nil))
	state.Register((*tasksInode)(nil))
	state.Register((*staticFileSetStat)(nil))
	state.Register((*selfSymlink)(nil))
	state.Register((*threadSelfSymlink)(nil))
	state.Register((*dynamicBytesFileSetAttr)(nil))
	state.Register((*cpuStats)(nil))
	state.Register((*statData)(nil))
	state.Register((*loadavgData)(nil))
	state.Register((*meminfoData)(nil))
	state.Register((*uptimeData)(nil))
	state.Register((*versionData)(nil))
	state.Register((*filesystemsData)(nil))
	state.Register((*cgroupsData)(nil))
	state.Register((*cmdLineData)(nil))
	state.Register((*sentryMeminfoData)(nil))
	state.Register((*tasksInodeRefs)(nil))
	state.Register((*tcpMemDir)(nil))
	state.Register((*mmapMinAddrData)(nil))
	state.Register((*hostnameData)(nil))
	state.Register((*tcpSackData)(nil))
	state.Register((*tcpRecoveryData)(nil))
	state.Register((*tcpMemData)(nil))
	state.Register((*ipForwarding)(nil))
	state.Register((*portRange)(nil))
	state.Register((*atomicInt32File)(nil))
	state.Register((*yamaPtraceScope)(nil))
}
