// automatically generated by stateify.

package fs

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

func (x *StableAttr) StateTypeName() string {
	return "pkg/sentry/fs.StableAttr"
}

func (x *StableAttr) StateFields() []string {
	return []string{
		"Type",
		"DeviceID",
		"InodeID",
		"BlockSize",
		"DeviceFileMajor",
		"DeviceFileMinor",
	}
}

func (x *StableAttr) beforeSave() {}

func (x *StableAttr) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.Type)
	m.Save(1, &x.DeviceID)
	m.Save(2, &x.InodeID)
	m.Save(3, &x.BlockSize)
	m.Save(4, &x.DeviceFileMajor)
	m.Save(5, &x.DeviceFileMinor)
}

func (x *StableAttr) afterLoad() {}

func (x *StableAttr) StateLoad(m state.Source) {
	m.Load(0, &x.Type)
	m.Load(1, &x.DeviceID)
	m.Load(2, &x.InodeID)
	m.Load(3, &x.BlockSize)
	m.Load(4, &x.DeviceFileMajor)
	m.Load(5, &x.DeviceFileMinor)
}

func (x *UnstableAttr) StateTypeName() string {
	return "pkg/sentry/fs.UnstableAttr"
}

func (x *UnstableAttr) StateFields() []string {
	return []string{
		"Size",
		"Usage",
		"Perms",
		"Owner",
		"AccessTime",
		"ModificationTime",
		"StatusChangeTime",
		"Links",
	}
}

func (x *UnstableAttr) beforeSave() {}

func (x *UnstableAttr) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.Size)
	m.Save(1, &x.Usage)
	m.Save(2, &x.Perms)
	m.Save(3, &x.Owner)
	m.Save(4, &x.AccessTime)
	m.Save(5, &x.ModificationTime)
	m.Save(6, &x.StatusChangeTime)
	m.Save(7, &x.Links)
}

func (x *UnstableAttr) afterLoad() {}

func (x *UnstableAttr) StateLoad(m state.Source) {
	m.Load(0, &x.Size)
	m.Load(1, &x.Usage)
	m.Load(2, &x.Perms)
	m.Load(3, &x.Owner)
	m.Load(4, &x.AccessTime)
	m.Load(5, &x.ModificationTime)
	m.Load(6, &x.StatusChangeTime)
	m.Load(7, &x.Links)
}

func (x *AttrMask) StateTypeName() string {
	return "pkg/sentry/fs.AttrMask"
}

func (x *AttrMask) StateFields() []string {
	return []string{
		"Type",
		"DeviceID",
		"InodeID",
		"BlockSize",
		"Size",
		"Usage",
		"Perms",
		"UID",
		"GID",
		"AccessTime",
		"ModificationTime",
		"StatusChangeTime",
		"Links",
	}
}

func (x *AttrMask) beforeSave() {}

func (x *AttrMask) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.Type)
	m.Save(1, &x.DeviceID)
	m.Save(2, &x.InodeID)
	m.Save(3, &x.BlockSize)
	m.Save(4, &x.Size)
	m.Save(5, &x.Usage)
	m.Save(6, &x.Perms)
	m.Save(7, &x.UID)
	m.Save(8, &x.GID)
	m.Save(9, &x.AccessTime)
	m.Save(10, &x.ModificationTime)
	m.Save(11, &x.StatusChangeTime)
	m.Save(12, &x.Links)
}

func (x *AttrMask) afterLoad() {}

func (x *AttrMask) StateLoad(m state.Source) {
	m.Load(0, &x.Type)
	m.Load(1, &x.DeviceID)
	m.Load(2, &x.InodeID)
	m.Load(3, &x.BlockSize)
	m.Load(4, &x.Size)
	m.Load(5, &x.Usage)
	m.Load(6, &x.Perms)
	m.Load(7, &x.UID)
	m.Load(8, &x.GID)
	m.Load(9, &x.AccessTime)
	m.Load(10, &x.ModificationTime)
	m.Load(11, &x.StatusChangeTime)
	m.Load(12, &x.Links)
}

func (x *PermMask) StateTypeName() string {
	return "pkg/sentry/fs.PermMask"
}

func (x *PermMask) StateFields() []string {
	return []string{
		"Read",
		"Write",
		"Execute",
	}
}

func (x *PermMask) beforeSave() {}

func (x *PermMask) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.Read)
	m.Save(1, &x.Write)
	m.Save(2, &x.Execute)
}

func (x *PermMask) afterLoad() {}

func (x *PermMask) StateLoad(m state.Source) {
	m.Load(0, &x.Read)
	m.Load(1, &x.Write)
	m.Load(2, &x.Execute)
}

func (x *FilePermissions) StateTypeName() string {
	return "pkg/sentry/fs.FilePermissions"
}

func (x *FilePermissions) StateFields() []string {
	return []string{
		"User",
		"Group",
		"Other",
		"Sticky",
		"SetUID",
		"SetGID",
	}
}

func (x *FilePermissions) beforeSave() {}

func (x *FilePermissions) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.User)
	m.Save(1, &x.Group)
	m.Save(2, &x.Other)
	m.Save(3, &x.Sticky)
	m.Save(4, &x.SetUID)
	m.Save(5, &x.SetGID)
}

func (x *FilePermissions) afterLoad() {}

func (x *FilePermissions) StateLoad(m state.Source) {
	m.Load(0, &x.User)
	m.Load(1, &x.Group)
	m.Load(2, &x.Other)
	m.Load(3, &x.Sticky)
	m.Load(4, &x.SetUID)
	m.Load(5, &x.SetGID)
}

func (x *FileOwner) StateTypeName() string {
	return "pkg/sentry/fs.FileOwner"
}

func (x *FileOwner) StateFields() []string {
	return []string{
		"UID",
		"GID",
	}
}

func (x *FileOwner) beforeSave() {}

func (x *FileOwner) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.UID)
	m.Save(1, &x.GID)
}

func (x *FileOwner) afterLoad() {}

func (x *FileOwner) StateLoad(m state.Source) {
	m.Load(0, &x.UID)
	m.Load(1, &x.GID)
}

func (x *DentAttr) StateTypeName() string {
	return "pkg/sentry/fs.DentAttr"
}

func (x *DentAttr) StateFields() []string {
	return []string{
		"Type",
		"InodeID",
	}
}

func (x *DentAttr) beforeSave() {}

func (x *DentAttr) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.Type)
	m.Save(1, &x.InodeID)
}

func (x *DentAttr) afterLoad() {}

func (x *DentAttr) StateLoad(m state.Source) {
	m.Load(0, &x.Type)
	m.Load(1, &x.InodeID)
}

func (x *SortedDentryMap) StateTypeName() string {
	return "pkg/sentry/fs.SortedDentryMap"
}

func (x *SortedDentryMap) StateFields() []string {
	return []string{
		"names",
		"entries",
	}
}

func (x *SortedDentryMap) beforeSave() {}

func (x *SortedDentryMap) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.names)
	m.Save(1, &x.entries)
}

func (x *SortedDentryMap) afterLoad() {}

func (x *SortedDentryMap) StateLoad(m state.Source) {
	m.Load(0, &x.names)
	m.Load(1, &x.entries)
}

func (x *Dirent) StateTypeName() string {
	return "pkg/sentry/fs.Dirent"
}

func (x *Dirent) StateFields() []string {
	return []string{
		"AtomicRefCount",
		"userVisible",
		"Inode",
		"name",
		"parent",
		"deleted",
		"mounted",
		"children",
	}
}

func (x *Dirent) StateSave(m state.Sink) {
	x.beforeSave()
	var children map[string]*Dirent = x.saveChildren()
	m.SaveValue(7, children)
	m.Save(0, &x.AtomicRefCount)
	m.Save(1, &x.userVisible)
	m.Save(2, &x.Inode)
	m.Save(3, &x.name)
	m.Save(4, &x.parent)
	m.Save(5, &x.deleted)
	m.Save(6, &x.mounted)
}

func (x *Dirent) StateLoad(m state.Source) {
	m.Load(0, &x.AtomicRefCount)
	m.Load(1, &x.userVisible)
	m.Load(2, &x.Inode)
	m.Load(3, &x.name)
	m.Load(4, &x.parent)
	m.Load(5, &x.deleted)
	m.Load(6, &x.mounted)
	m.LoadValue(7, new(map[string]*Dirent), func(y interface{}) { x.loadChildren(y.(map[string]*Dirent)) })
	m.AfterLoad(x.afterLoad)
}

func (x *DirentCache) StateTypeName() string {
	return "pkg/sentry/fs.DirentCache"
}

func (x *DirentCache) StateFields() []string {
	return []string{
		"maxSize",
		"limit",
	}
}

func (x *DirentCache) beforeSave() {}

func (x *DirentCache) StateSave(m state.Sink) {
	x.beforeSave()
	if !state.IsZeroValue(&x.currentSize) {
		state.Failf("currentSize is %#v, expected zero", &x.currentSize)
	}
	if !state.IsZeroValue(&x.list) {
		state.Failf("list is %#v, expected zero", &x.list)
	}
	m.Save(0, &x.maxSize)
	m.Save(1, &x.limit)
}

func (x *DirentCache) afterLoad() {}

func (x *DirentCache) StateLoad(m state.Source) {
	m.Load(0, &x.maxSize)
	m.Load(1, &x.limit)
}

func (x *DirentCacheLimiter) StateTypeName() string {
	return "pkg/sentry/fs.DirentCacheLimiter"
}

func (x *DirentCacheLimiter) StateFields() []string {
	return []string{
		"max",
	}
}

func (x *DirentCacheLimiter) beforeSave() {}

func (x *DirentCacheLimiter) StateSave(m state.Sink) {
	x.beforeSave()
	if !state.IsZeroValue(&x.count) {
		state.Failf("count is %#v, expected zero", &x.count)
	}
	m.Save(0, &x.max)
}

func (x *DirentCacheLimiter) afterLoad() {}

func (x *DirentCacheLimiter) StateLoad(m state.Source) {
	m.Load(0, &x.max)
}

func (x *direntList) StateTypeName() string {
	return "pkg/sentry/fs.direntList"
}

func (x *direntList) StateFields() []string {
	return []string{
		"head",
		"tail",
	}
}

func (x *direntList) beforeSave() {}

func (x *direntList) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.head)
	m.Save(1, &x.tail)
}

func (x *direntList) afterLoad() {}

func (x *direntList) StateLoad(m state.Source) {
	m.Load(0, &x.head)
	m.Load(1, &x.tail)
}

func (x *direntEntry) StateTypeName() string {
	return "pkg/sentry/fs.direntEntry"
}

func (x *direntEntry) StateFields() []string {
	return []string{
		"next",
		"prev",
	}
}

func (x *direntEntry) beforeSave() {}

func (x *direntEntry) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.next)
	m.Save(1, &x.prev)
}

func (x *direntEntry) afterLoad() {}

func (x *direntEntry) StateLoad(m state.Source) {
	m.Load(0, &x.next)
	m.Load(1, &x.prev)
}

func (x *eventList) StateTypeName() string {
	return "pkg/sentry/fs.eventList"
}

func (x *eventList) StateFields() []string {
	return []string{
		"head",
		"tail",
	}
}

func (x *eventList) beforeSave() {}

func (x *eventList) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.head)
	m.Save(1, &x.tail)
}

func (x *eventList) afterLoad() {}

func (x *eventList) StateLoad(m state.Source) {
	m.Load(0, &x.head)
	m.Load(1, &x.tail)
}

func (x *eventEntry) StateTypeName() string {
	return "pkg/sentry/fs.eventEntry"
}

func (x *eventEntry) StateFields() []string {
	return []string{
		"next",
		"prev",
	}
}

func (x *eventEntry) beforeSave() {}

func (x *eventEntry) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.next)
	m.Save(1, &x.prev)
}

func (x *eventEntry) afterLoad() {}

func (x *eventEntry) StateLoad(m state.Source) {
	m.Load(0, &x.next)
	m.Load(1, &x.prev)
}

func (x *File) StateTypeName() string {
	return "pkg/sentry/fs.File"
}

func (x *File) StateFields() []string {
	return []string{
		"AtomicRefCount",
		"UniqueID",
		"Dirent",
		"flags",
		"async",
		"FileOperations",
		"offset",
	}
}

func (x *File) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.AtomicRefCount)
	m.Save(1, &x.UniqueID)
	m.Save(2, &x.Dirent)
	m.Save(3, &x.flags)
	m.Save(4, &x.async)
	m.Save(5, &x.FileOperations)
	m.Save(6, &x.offset)
}

func (x *File) StateLoad(m state.Source) {
	m.Load(0, &x.AtomicRefCount)
	m.Load(1, &x.UniqueID)
	m.Load(2, &x.Dirent)
	m.Load(3, &x.flags)
	m.Load(4, &x.async)
	m.LoadWait(5, &x.FileOperations)
	m.Load(6, &x.offset)
	m.AfterLoad(x.afterLoad)
}

func (x *overlayFileOperations) StateTypeName() string {
	return "pkg/sentry/fs.overlayFileOperations"
}

func (x *overlayFileOperations) StateFields() []string {
	return []string{
		"upper",
		"lower",
		"dirCursor",
	}
}

func (x *overlayFileOperations) beforeSave() {}

func (x *overlayFileOperations) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.upper)
	m.Save(1, &x.lower)
	m.Save(2, &x.dirCursor)
}

func (x *overlayFileOperations) afterLoad() {}

func (x *overlayFileOperations) StateLoad(m state.Source) {
	m.Load(0, &x.upper)
	m.Load(1, &x.lower)
	m.Load(2, &x.dirCursor)
}

func (x *overlayMappingIdentity) StateTypeName() string {
	return "pkg/sentry/fs.overlayMappingIdentity"
}

func (x *overlayMappingIdentity) StateFields() []string {
	return []string{
		"AtomicRefCount",
		"id",
		"overlayFile",
	}
}

func (x *overlayMappingIdentity) beforeSave() {}

func (x *overlayMappingIdentity) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.AtomicRefCount)
	m.Save(1, &x.id)
	m.Save(2, &x.overlayFile)
}

func (x *overlayMappingIdentity) afterLoad() {}

func (x *overlayMappingIdentity) StateLoad(m state.Source) {
	m.Load(0, &x.AtomicRefCount)
	m.Load(1, &x.id)
	m.Load(2, &x.overlayFile)
}

func (x *MountSourceFlags) StateTypeName() string {
	return "pkg/sentry/fs.MountSourceFlags"
}

func (x *MountSourceFlags) StateFields() []string {
	return []string{
		"ReadOnly",
		"NoAtime",
		"ForcePageCache",
		"NoExec",
	}
}

func (x *MountSourceFlags) beforeSave() {}

func (x *MountSourceFlags) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.ReadOnly)
	m.Save(1, &x.NoAtime)
	m.Save(2, &x.ForcePageCache)
	m.Save(3, &x.NoExec)
}

func (x *MountSourceFlags) afterLoad() {}

func (x *MountSourceFlags) StateLoad(m state.Source) {
	m.Load(0, &x.ReadOnly)
	m.Load(1, &x.NoAtime)
	m.Load(2, &x.ForcePageCache)
	m.Load(3, &x.NoExec)
}

func (x *FileFlags) StateTypeName() string {
	return "pkg/sentry/fs.FileFlags"
}

func (x *FileFlags) StateFields() []string {
	return []string{
		"Direct",
		"NonBlocking",
		"DSync",
		"Sync",
		"Append",
		"Read",
		"Write",
		"Pread",
		"Pwrite",
		"Directory",
		"Async",
		"LargeFile",
		"NonSeekable",
		"Truncate",
	}
}

func (x *FileFlags) beforeSave() {}

func (x *FileFlags) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.Direct)
	m.Save(1, &x.NonBlocking)
	m.Save(2, &x.DSync)
	m.Save(3, &x.Sync)
	m.Save(4, &x.Append)
	m.Save(5, &x.Read)
	m.Save(6, &x.Write)
	m.Save(7, &x.Pread)
	m.Save(8, &x.Pwrite)
	m.Save(9, &x.Directory)
	m.Save(10, &x.Async)
	m.Save(11, &x.LargeFile)
	m.Save(12, &x.NonSeekable)
	m.Save(13, &x.Truncate)
}

func (x *FileFlags) afterLoad() {}

func (x *FileFlags) StateLoad(m state.Source) {
	m.Load(0, &x.Direct)
	m.Load(1, &x.NonBlocking)
	m.Load(2, &x.DSync)
	m.Load(3, &x.Sync)
	m.Load(4, &x.Append)
	m.Load(5, &x.Read)
	m.Load(6, &x.Write)
	m.Load(7, &x.Pread)
	m.Load(8, &x.Pwrite)
	m.Load(9, &x.Directory)
	m.Load(10, &x.Async)
	m.Load(11, &x.LargeFile)
	m.Load(12, &x.NonSeekable)
	m.Load(13, &x.Truncate)
}

func (x *Inode) StateTypeName() string {
	return "pkg/sentry/fs.Inode"
}

func (x *Inode) StateFields() []string {
	return []string{
		"AtomicRefCount",
		"InodeOperations",
		"StableAttr",
		"LockCtx",
		"Watches",
		"MountSource",
		"overlay",
	}
}

func (x *Inode) beforeSave() {}

func (x *Inode) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.AtomicRefCount)
	m.Save(1, &x.InodeOperations)
	m.Save(2, &x.StableAttr)
	m.Save(3, &x.LockCtx)
	m.Save(4, &x.Watches)
	m.Save(5, &x.MountSource)
	m.Save(6, &x.overlay)
}

func (x *Inode) afterLoad() {}

func (x *Inode) StateLoad(m state.Source) {
	m.Load(0, &x.AtomicRefCount)
	m.Load(1, &x.InodeOperations)
	m.Load(2, &x.StableAttr)
	m.Load(3, &x.LockCtx)
	m.Load(4, &x.Watches)
	m.Load(5, &x.MountSource)
	m.Load(6, &x.overlay)
}

func (x *LockCtx) StateTypeName() string {
	return "pkg/sentry/fs.LockCtx"
}

func (x *LockCtx) StateFields() []string {
	return []string{
		"Posix",
		"BSD",
	}
}

func (x *LockCtx) beforeSave() {}

func (x *LockCtx) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.Posix)
	m.Save(1, &x.BSD)
}

func (x *LockCtx) afterLoad() {}

func (x *LockCtx) StateLoad(m state.Source) {
	m.Load(0, &x.Posix)
	m.Load(1, &x.BSD)
}

func (x *Watches) StateTypeName() string {
	return "pkg/sentry/fs.Watches"
}

func (x *Watches) StateFields() []string {
	return []string{
		"ws",
		"unlinked",
	}
}

func (x *Watches) beforeSave() {}

func (x *Watches) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.ws)
	m.Save(1, &x.unlinked)
}

func (x *Watches) afterLoad() {}

func (x *Watches) StateLoad(m state.Source) {
	m.Load(0, &x.ws)
	m.Load(1, &x.unlinked)
}

func (x *Inotify) StateTypeName() string {
	return "pkg/sentry/fs.Inotify"
}

func (x *Inotify) StateFields() []string {
	return []string{
		"id",
		"events",
		"scratch",
		"nextWatch",
		"watches",
	}
}

func (x *Inotify) beforeSave() {}

func (x *Inotify) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.id)
	m.Save(1, &x.events)
	m.Save(2, &x.scratch)
	m.Save(3, &x.nextWatch)
	m.Save(4, &x.watches)
}

func (x *Inotify) afterLoad() {}

func (x *Inotify) StateLoad(m state.Source) {
	m.Load(0, &x.id)
	m.Load(1, &x.events)
	m.Load(2, &x.scratch)
	m.Load(3, &x.nextWatch)
	m.Load(4, &x.watches)
}

func (x *Event) StateTypeName() string {
	return "pkg/sentry/fs.Event"
}

func (x *Event) StateFields() []string {
	return []string{
		"eventEntry",
		"wd",
		"mask",
		"cookie",
		"len",
		"name",
	}
}

func (x *Event) beforeSave() {}

func (x *Event) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.eventEntry)
	m.Save(1, &x.wd)
	m.Save(2, &x.mask)
	m.Save(3, &x.cookie)
	m.Save(4, &x.len)
	m.Save(5, &x.name)
}

func (x *Event) afterLoad() {}

func (x *Event) StateLoad(m state.Source) {
	m.Load(0, &x.eventEntry)
	m.Load(1, &x.wd)
	m.Load(2, &x.mask)
	m.Load(3, &x.cookie)
	m.Load(4, &x.len)
	m.Load(5, &x.name)
}

func (x *Watch) StateTypeName() string {
	return "pkg/sentry/fs.Watch"
}

func (x *Watch) StateFields() []string {
	return []string{
		"owner",
		"wd",
		"target",
		"unpinned",
		"mask",
		"pins",
	}
}

func (x *Watch) beforeSave() {}

func (x *Watch) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.owner)
	m.Save(1, &x.wd)
	m.Save(2, &x.target)
	m.Save(3, &x.unpinned)
	m.Save(4, &x.mask)
	m.Save(5, &x.pins)
}

func (x *Watch) afterLoad() {}

func (x *Watch) StateLoad(m state.Source) {
	m.Load(0, &x.owner)
	m.Load(1, &x.wd)
	m.Load(2, &x.target)
	m.Load(3, &x.unpinned)
	m.Load(4, &x.mask)
	m.Load(5, &x.pins)
}

func (x *MountSource) StateTypeName() string {
	return "pkg/sentry/fs.MountSource"
}

func (x *MountSource) StateFields() []string {
	return []string{
		"AtomicRefCount",
		"MountSourceOperations",
		"FilesystemType",
		"Flags",
		"fscache",
		"direntRefs",
	}
}

func (x *MountSource) beforeSave() {}

func (x *MountSource) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.AtomicRefCount)
	m.Save(1, &x.MountSourceOperations)
	m.Save(2, &x.FilesystemType)
	m.Save(3, &x.Flags)
	m.Save(4, &x.fscache)
	m.Save(5, &x.direntRefs)
}

func (x *MountSource) afterLoad() {}

func (x *MountSource) StateLoad(m state.Source) {
	m.Load(0, &x.AtomicRefCount)
	m.Load(1, &x.MountSourceOperations)
	m.Load(2, &x.FilesystemType)
	m.Load(3, &x.Flags)
	m.Load(4, &x.fscache)
	m.Load(5, &x.direntRefs)
}

func (x *SimpleMountSourceOperations) StateTypeName() string {
	return "pkg/sentry/fs.SimpleMountSourceOperations"
}

func (x *SimpleMountSourceOperations) StateFields() []string {
	return []string{
		"keep",
		"revalidate",
		"cacheReaddir",
	}
}

func (x *SimpleMountSourceOperations) beforeSave() {}

func (x *SimpleMountSourceOperations) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.keep)
	m.Save(1, &x.revalidate)
	m.Save(2, &x.cacheReaddir)
}

func (x *SimpleMountSourceOperations) afterLoad() {}

func (x *SimpleMountSourceOperations) StateLoad(m state.Source) {
	m.Load(0, &x.keep)
	m.Load(1, &x.revalidate)
	m.Load(2, &x.cacheReaddir)
}

func (x *overlayMountSourceOperations) StateTypeName() string {
	return "pkg/sentry/fs.overlayMountSourceOperations"
}

func (x *overlayMountSourceOperations) StateFields() []string {
	return []string{
		"upper",
		"lower",
	}
}

func (x *overlayMountSourceOperations) beforeSave() {}

func (x *overlayMountSourceOperations) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.upper)
	m.Save(1, &x.lower)
}

func (x *overlayMountSourceOperations) afterLoad() {}

func (x *overlayMountSourceOperations) StateLoad(m state.Source) {
	m.Load(0, &x.upper)
	m.Load(1, &x.lower)
}

func (x *overlayFilesystem) StateTypeName() string {
	return "pkg/sentry/fs.overlayFilesystem"
}

func (x *overlayFilesystem) StateFields() []string {
	return []string{}
}

func (x *overlayFilesystem) beforeSave() {}

func (x *overlayFilesystem) StateSave(m state.Sink) {
	x.beforeSave()
}

func (x *overlayFilesystem) afterLoad() {}

func (x *overlayFilesystem) StateLoad(m state.Source) {
}

func (x *Mount) StateTypeName() string {
	return "pkg/sentry/fs.Mount"
}

func (x *Mount) StateFields() []string {
	return []string{
		"ID",
		"ParentID",
		"root",
		"previous",
	}
}

func (x *Mount) beforeSave() {}

func (x *Mount) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.ID)
	m.Save(1, &x.ParentID)
	m.Save(2, &x.root)
	m.Save(3, &x.previous)
}

func (x *Mount) afterLoad() {}

func (x *Mount) StateLoad(m state.Source) {
	m.Load(0, &x.ID)
	m.Load(1, &x.ParentID)
	m.Load(2, &x.root)
	m.Load(3, &x.previous)
}

func (x *MountNamespace) StateTypeName() string {
	return "pkg/sentry/fs.MountNamespace"
}

func (x *MountNamespace) StateFields() []string {
	return []string{
		"AtomicRefCount",
		"userns",
		"root",
		"mounts",
		"mountID",
	}
}

func (x *MountNamespace) beforeSave() {}

func (x *MountNamespace) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.AtomicRefCount)
	m.Save(1, &x.userns)
	m.Save(2, &x.root)
	m.Save(3, &x.mounts)
	m.Save(4, &x.mountID)
}

func (x *MountNamespace) afterLoad() {}

func (x *MountNamespace) StateLoad(m state.Source) {
	m.Load(0, &x.AtomicRefCount)
	m.Load(1, &x.userns)
	m.Load(2, &x.root)
	m.Load(3, &x.mounts)
	m.Load(4, &x.mountID)
}

func (x *overlayEntry) StateTypeName() string {
	return "pkg/sentry/fs.overlayEntry"
}

func (x *overlayEntry) StateFields() []string {
	return []string{
		"lowerExists",
		"lower",
		"mappings",
		"upper",
		"dirCache",
	}
}

func (x *overlayEntry) beforeSave() {}

func (x *overlayEntry) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.lowerExists)
	m.Save(1, &x.lower)
	m.Save(2, &x.mappings)
	m.Save(3, &x.upper)
	m.Save(4, &x.dirCache)
}

func (x *overlayEntry) afterLoad() {}

func (x *overlayEntry) StateLoad(m state.Source) {
	m.Load(0, &x.lowerExists)
	m.Load(1, &x.lower)
	m.Load(2, &x.mappings)
	m.Load(3, &x.upper)
	m.Load(4, &x.dirCache)
}

func init() {
	state.Register((*StableAttr)(nil))
	state.Register((*UnstableAttr)(nil))
	state.Register((*AttrMask)(nil))
	state.Register((*PermMask)(nil))
	state.Register((*FilePermissions)(nil))
	state.Register((*FileOwner)(nil))
	state.Register((*DentAttr)(nil))
	state.Register((*SortedDentryMap)(nil))
	state.Register((*Dirent)(nil))
	state.Register((*DirentCache)(nil))
	state.Register((*DirentCacheLimiter)(nil))
	state.Register((*direntList)(nil))
	state.Register((*direntEntry)(nil))
	state.Register((*eventList)(nil))
	state.Register((*eventEntry)(nil))
	state.Register((*File)(nil))
	state.Register((*overlayFileOperations)(nil))
	state.Register((*overlayMappingIdentity)(nil))
	state.Register((*MountSourceFlags)(nil))
	state.Register((*FileFlags)(nil))
	state.Register((*Inode)(nil))
	state.Register((*LockCtx)(nil))
	state.Register((*Watches)(nil))
	state.Register((*Inotify)(nil))
	state.Register((*Event)(nil))
	state.Register((*Watch)(nil))
	state.Register((*MountSource)(nil))
	state.Register((*SimpleMountSourceOperations)(nil))
	state.Register((*overlayMountSourceOperations)(nil))
	state.Register((*overlayFilesystem)(nil))
	state.Register((*Mount)(nil))
	state.Register((*MountNamespace)(nil))
	state.Register((*overlayEntry)(nil))
}