// automatically generated by stateify.

package sys

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

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

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

func (r *dirRefs) beforeSave() {}

func (r *dirRefs) StateSave(stateSinkObject state.Sink) {
	r.beforeSave()
	stateSinkObject.Save(0, &r.refCount)
}

func (r *dirRefs) StateLoad(stateSourceObject state.Source) {
	stateSourceObject.Load(0, &r.refCount)
	stateSourceObject.AfterLoad(r.afterLoad)
}

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

func (i *kcovInode) StateFields() []string {
	return []string{
		"InodeAttrs",
		"InodeNoopRefCount",
		"InodeNotDirectory",
		"InodeNotSymlink",
		"implStatFS",
	}
}

func (i *kcovInode) beforeSave() {}

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 (i *kcovInode) afterLoad() {}

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 (fd *kcovFD) StateTypeName() string {
	return "pkg/sentry/fsimpl/sys.kcovFD"
}

func (fd *kcovFD) StateFields() []string {
	return []string{
		"FileDescriptionDefaultImpl",
		"NoLockFD",
		"vfsfd",
		"inode",
		"kcov",
	}
}

func (fd *kcovFD) beforeSave() {}

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 (fd *kcovFD) afterLoad() {}

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 (fsType *FilesystemType) StateTypeName() string {
	return "pkg/sentry/fsimpl/sys.FilesystemType"
}

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

func (fsType *FilesystemType) beforeSave() {}

func (fsType *FilesystemType) StateSave(stateSinkObject state.Sink) {
	fsType.beforeSave()
}

func (fsType *FilesystemType) afterLoad() {}

func (fsType *FilesystemType) StateLoad(stateSourceObject state.Source) {
}

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

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

func (fs *filesystem) beforeSave() {}

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

func (fs *filesystem) afterLoad() {}

func (fs *filesystem) StateLoad(stateSourceObject state.Source) {
	stateSourceObject.Load(0, &fs.Filesystem)
	stateSourceObject.Load(1, &fs.devMinor)
}

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

func (d *dir) StateFields() []string {
	return []string{
		"dirRefs",
		"InodeAlwaysValid",
		"InodeAttrs",
		"InodeNotSymlink",
		"InodeDirectoryNoNewChildren",
		"InodeTemporary",
		"OrderedChildren",
		"locks",
	}
}

func (d *dir) beforeSave() {}

func (d *dir) StateSave(stateSinkObject state.Sink) {
	d.beforeSave()
	stateSinkObject.Save(0, &d.dirRefs)
	stateSinkObject.Save(1, &d.InodeAlwaysValid)
	stateSinkObject.Save(2, &d.InodeAttrs)
	stateSinkObject.Save(3, &d.InodeNotSymlink)
	stateSinkObject.Save(4, &d.InodeDirectoryNoNewChildren)
	stateSinkObject.Save(5, &d.InodeTemporary)
	stateSinkObject.Save(6, &d.OrderedChildren)
	stateSinkObject.Save(7, &d.locks)
}

func (d *dir) afterLoad() {}

func (d *dir) StateLoad(stateSourceObject state.Source) {
	stateSourceObject.Load(0, &d.dirRefs)
	stateSourceObject.Load(1, &d.InodeAlwaysValid)
	stateSourceObject.Load(2, &d.InodeAttrs)
	stateSourceObject.Load(3, &d.InodeNotSymlink)
	stateSourceObject.Load(4, &d.InodeDirectoryNoNewChildren)
	stateSourceObject.Load(5, &d.InodeTemporary)
	stateSourceObject.Load(6, &d.OrderedChildren)
	stateSourceObject.Load(7, &d.locks)
}

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

func (c *cpuFile) StateFields() []string {
	return []string{
		"implStatFS",
		"DynamicBytesFile",
		"maxCores",
	}
}

func (c *cpuFile) beforeSave() {}

func (c *cpuFile) StateSave(stateSinkObject state.Sink) {
	c.beforeSave()
	stateSinkObject.Save(0, &c.implStatFS)
	stateSinkObject.Save(1, &c.DynamicBytesFile)
	stateSinkObject.Save(2, &c.maxCores)
}

func (c *cpuFile) afterLoad() {}

func (c *cpuFile) StateLoad(stateSourceObject state.Source) {
	stateSourceObject.Load(0, &c.implStatFS)
	stateSourceObject.Load(1, &c.DynamicBytesFile)
	stateSourceObject.Load(2, &c.maxCores)
}

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

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

func (i *implStatFS) beforeSave() {}

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

func (i *implStatFS) afterLoad() {}

func (i *implStatFS) StateLoad(stateSourceObject state.Source) {
}

func init() {
	state.Register((*dirRefs)(nil))
	state.Register((*kcovInode)(nil))
	state.Register((*kcovFD)(nil))
	state.Register((*FilesystemType)(nil))
	state.Register((*filesystem)(nil))
	state.Register((*dir)(nil))
	state.Register((*cpuFile)(nil))
	state.Register((*implStatFS)(nil))
}