Merge release-20210927.0-60-g8682ce689 (automated)

23 files changed, 225 insertions, 258 deletions

diff --git a/pkg/sentry/fs/fdpipe/fdpipe_state_autogen.go b/pkg/sentry/fs/fdpipe/fdpipe_state_autogen.go
index 68406ce66..247aba66b 100644
--- a/pkg/sentry/fs/fdpipe/fdpipe_state_autogen.go
+++ b/pkg/sentry/fs/fdpipe/fdpipe_state_autogen.go
@@ -13,6 +13,7 @@ func (p *pipeOperations) StateTypeName() string {
 
 func (p *pipeOperations) StateFields() []string {
 	return []string{
+		"Queue",
 		"flags",
 		"opener",
 		"readAheadBuffer",
@@ -24,16 +25,18 @@ func (p *pipeOperations) StateSave(stateSinkObject state.Sink) {
 	p.beforeSave()
 	var flagsValue fs.FileFlags
 	flagsValue = p.saveFlags()
-	stateSinkObject.SaveValue(0, flagsValue)
-	stateSinkObject.Save(1, &p.opener)
-	stateSinkObject.Save(2, &p.readAheadBuffer)
+	stateSinkObject.SaveValue(1, flagsValue)
+	stateSinkObject.Save(0, &p.Queue)
+	stateSinkObject.Save(2, &p.opener)
+	stateSinkObject.Save(3, &p.readAheadBuffer)
 }
 
 // +checklocksignore
 func (p *pipeOperations) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.LoadWait(1, &p.opener)
-	stateSourceObject.Load(2, &p.readAheadBuffer)
-	stateSourceObject.LoadValue(0, new(fs.FileFlags), func(y interface{}) { p.loadFlags(y.(fs.FileFlags)) })
+	stateSourceObject.Load(0, &p.Queue)
+	stateSourceObject.LoadWait(2, &p.opener)
+	stateSourceObject.Load(3, &p.readAheadBuffer)
+	stateSourceObject.LoadValue(1, new(fs.FileFlags), func(y interface{}) { p.loadFlags(y.(fs.FileFlags)) })
 	stateSourceObject.AfterLoad(p.afterLoad)
 }
 
diff --git a/pkg/sentry/fs/fdpipe/pipe.go b/pkg/sentry/fs/fdpipe/pipe.go
index 4370cce33..d2eb03bb7 100644
--- a/pkg/sentry/fs/fdpipe/pipe.go
+++ b/pkg/sentry/fs/fdpipe/pipe.go
@@ -45,7 +45,8 @@ type pipeOperations struct {
 	fsutil.FileNoIoctl              `state:"nosave"`
 	fsutil.FileNoSplice             `state:"nosave"`
 	fsutil.FileUseInodeUnstableAttr `state:"nosave"`
-	waiter.Queue                    `state:"nosave"`
+
+	waiter.Queue
 
 	// flags are the flags used to open the pipe.
 	flags fs.FileFlags `state:".(fs.FileFlags)"`
diff --git a/pkg/sentry/fs/fs_state_autogen.go b/pkg/sentry/fs/fs_state_autogen.go
index 62ab34d6f..22059a271 100644
--- a/pkg/sentry/fs/fs_state_autogen.go
+++ b/pkg/sentry/fs/fs_state_autogen.go
@@ -833,6 +833,7 @@ func (i *Inotify) StateTypeName() string {
 func (i *Inotify) StateFields() []string {
 	return []string{
 		"id",
+		"Queue",
 		"events",
 		"scratch",
 		"nextWatch",
@@ -846,10 +847,11 @@ func (i *Inotify) beforeSave() {}
 func (i *Inotify) StateSave(stateSinkObject state.Sink) {
 	i.beforeSave()
 	stateSinkObject.Save(0, &i.id)
-	stateSinkObject.Save(1, &i.events)
-	stateSinkObject.Save(2, &i.scratch)
-	stateSinkObject.Save(3, &i.nextWatch)
-	stateSinkObject.Save(4, &i.watches)
+	stateSinkObject.Save(1, &i.Queue)
+	stateSinkObject.Save(2, &i.events)
+	stateSinkObject.Save(3, &i.scratch)
+	stateSinkObject.Save(4, &i.nextWatch)
+	stateSinkObject.Save(5, &i.watches)
 }
 
 func (i *Inotify) afterLoad() {}
@@ -857,10 +859,11 @@ func (i *Inotify) afterLoad() {}
 // +checklocksignore
 func (i *Inotify) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(0, &i.id)
-	stateSourceObject.Load(1, &i.events)
-	stateSourceObject.Load(2, &i.scratch)
-	stateSourceObject.Load(3, &i.nextWatch)
-	stateSourceObject.Load(4, &i.watches)
+	stateSourceObject.Load(1, &i.Queue)
+	stateSourceObject.Load(2, &i.events)
+	stateSourceObject.Load(3, &i.scratch)
+	stateSourceObject.Load(4, &i.nextWatch)
+	stateSourceObject.Load(5, &i.watches)
 }
 
 func (e *Event) StateTypeName() string {
diff --git a/pkg/sentry/fs/host/host_state_autogen.go b/pkg/sentry/fs/host/host_state_autogen.go
index b06247919..50869fd79 100644
--- a/pkg/sentry/fs/host/host_state_autogen.go
+++ b/pkg/sentry/fs/host/host_state_autogen.go
@@ -115,6 +115,7 @@ func (i *inodeFileState) StateTypeName() string {
 func (i *inodeFileState) StateFields() []string {
 	return []string{
 		"descriptor",
+		"queue",
 		"sattr",
 		"savedUAttr",
 	}
@@ -125,19 +126,18 @@ func (i *inodeFileState) beforeSave() {}
 // +checklocksignore
 func (i *inodeFileState) StateSave(stateSinkObject state.Sink) {
 	i.beforeSave()
-	if !state.IsZeroValue(&i.queue) {
-		state.Failf("queue is %#v, expected zero", &i.queue)
-	}
 	stateSinkObject.Save(0, &i.descriptor)
-	stateSinkObject.Save(1, &i.sattr)
-	stateSinkObject.Save(2, &i.savedUAttr)
+	stateSinkObject.Save(1, &i.queue)
+	stateSinkObject.Save(2, &i.sattr)
+	stateSinkObject.Save(3, &i.savedUAttr)
 }
 
 // +checklocksignore
 func (i *inodeFileState) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.LoadWait(0, &i.descriptor)
-	stateSourceObject.LoadWait(1, &i.sattr)
-	stateSourceObject.Load(2, &i.savedUAttr)
+	stateSourceObject.Load(1, &i.queue)
+	stateSourceObject.LoadWait(2, &i.sattr)
+	stateSourceObject.Load(3, &i.savedUAttr)
 	stateSourceObject.AfterLoad(i.afterLoad)
 }
 
diff --git a/pkg/sentry/fs/host/inode.go b/pkg/sentry/fs/host/inode.go
index 92d58e3e9..99c37291e 100644
--- a/pkg/sentry/fs/host/inode.go
+++ b/pkg/sentry/fs/host/inode.go
@@ -70,7 +70,7 @@ type inodeFileState struct {
 	descriptor *descriptor `state:"wait"`
 
 	// Event queue for blocking operations.
-	queue waiter.Queue `state:"zerovalue"`
+	queue waiter.Queue
 
 	// sattr is used to restore the inodeOperations.
 	sattr fs.StableAttr `state:"wait"`
diff --git a/pkg/sentry/fs/inotify.go b/pkg/sentry/fs/inotify.go
index 51cd6cd37..941f37116 100644
--- a/pkg/sentry/fs/inotify.go
+++ b/pkg/sentry/fs/inotify.go
@@ -43,7 +43,7 @@ type Inotify struct {
 	// user, since we may aggressively reuse an id on S/R.
 	id uint64
 
-	waiter.Queue `state:"nosave"`
+	waiter.Queue
 
 	// evMu *only* protects the events list. We need a separate lock because
 	// while queuing events, a watch needs to lock the event queue, and using mu
diff --git a/pkg/sentry/fs/lock/lock.go b/pkg/sentry/fs/lock/lock.go
index 7d7a207cc..e39d340fe 100644
--- a/pkg/sentry/fs/lock/lock.go
+++ b/pkg/sentry/fs/lock/lock.go
@@ -132,7 +132,7 @@ type Locks struct {
 	locks LockSet
 
 	// blockedQueue is the queue of waiters that are waiting on a lock.
-	blockedQueue waiter.Queue `state:"zerovalue"`
+	blockedQueue waiter.Queue
 }
 
 // Blocker is the interface used for blocking locks. Passing a nil Blocker
diff --git a/pkg/sentry/fs/lock/lock_state_autogen.go b/pkg/sentry/fs/lock/lock_state_autogen.go
index 4a9d0a1d8..8ddb3795c 100644
--- a/pkg/sentry/fs/lock/lock_state_autogen.go
+++ b/pkg/sentry/fs/lock/lock_state_autogen.go
@@ -69,6 +69,7 @@ func (l *Locks) StateTypeName() string {
 func (l *Locks) StateFields() []string {
 	return []string{
 		"locks",
+		"blockedQueue",
 	}
 }
 
@@ -77,10 +78,8 @@ func (l *Locks) beforeSave() {}
 // +checklocksignore
 func (l *Locks) StateSave(stateSinkObject state.Sink) {
 	l.beforeSave()
-	if !state.IsZeroValue(&l.blockedQueue) {
-		state.Failf("blockedQueue is %#v, expected zero", &l.blockedQueue)
-	}
 	stateSinkObject.Save(0, &l.locks)
+	stateSinkObject.Save(1, &l.blockedQueue)
 }
 
 func (l *Locks) afterLoad() {}
@@ -88,6 +87,7 @@ func (l *Locks) afterLoad() {}
 // +checklocksignore
 func (l *Locks) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(0, &l.locks)
+	stateSourceObject.Load(1, &l.blockedQueue)
 }
 
 func (r *LockRange) StateTypeName() string {
diff --git a/pkg/sentry/fs/timerfd/timerfd.go b/pkg/sentry/fs/timerfd/timerfd.go
index 1c8518d71..ca8be8683 100644
--- a/pkg/sentry/fs/timerfd/timerfd.go
+++ b/pkg/sentry/fs/timerfd/timerfd.go
@@ -43,7 +43,7 @@ type TimerOperations struct {
 	fsutil.FileNoopFlush            `state:"nosave"`
 	fsutil.FileUseInodeUnstableAttr `state:"nosave"`
 
-	events waiter.Queue `state:"zerovalue"`
+	events waiter.Queue
 	timer  *ktime.Timer
 
 	// val is the number of timer expirations since the last successful call to
diff --git a/pkg/sentry/fs/timerfd/timerfd_state_autogen.go b/pkg/sentry/fs/timerfd/timerfd_state_autogen.go
index 822eecdd6..6cab87796 100644
--- a/pkg/sentry/fs/timerfd/timerfd_state_autogen.go
+++ b/pkg/sentry/fs/timerfd/timerfd_state_autogen.go
@@ -12,6 +12,7 @@ func (t *TimerOperations) StateTypeName() string {
 
 func (t *TimerOperations) StateFields() []string {
 	return []string{
+		"events",
 		"timer",
 		"val",
 	}
@@ -22,19 +23,18 @@ func (t *TimerOperations) beforeSave() {}
 // +checklocksignore
 func (t *TimerOperations) StateSave(stateSinkObject state.Sink) {
 	t.beforeSave()
-	if !state.IsZeroValue(&t.events) {
-		state.Failf("events is %#v, expected zero", &t.events)
-	}
-	stateSinkObject.Save(0, &t.timer)
-	stateSinkObject.Save(1, &t.val)
+	stateSinkObject.Save(0, &t.events)
+	stateSinkObject.Save(1, &t.timer)
+	stateSinkObject.Save(2, &t.val)
 }
 
 func (t *TimerOperations) afterLoad() {}
 
 // +checklocksignore
 func (t *TimerOperations) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &t.timer)
-	stateSourceObject.Load(1, &t.val)
+	stateSourceObject.Load(0, &t.events)
+	stateSourceObject.Load(1, &t.timer)
+	stateSourceObject.Load(2, &t.val)
 }
 
 func init() {
diff --git a/pkg/sentry/fs/tty/line_discipline.go b/pkg/sentry/fs/tty/line_discipline.go
index f9fca6d8e..f2c9e9668 100644
--- a/pkg/sentry/fs/tty/line_discipline.go
+++ b/pkg/sentry/fs/tty/line_discipline.go
@@ -102,10 +102,10 @@ type lineDiscipline struct {
 	column int
 
 	// masterWaiter is used to wait on the master end of the TTY.
-	masterWaiter waiter.Queue `state:"zerovalue"`
+	masterWaiter waiter.Queue
 
 	// replicaWaiter is used to wait on the replica end of the TTY.
-	replicaWaiter waiter.Queue `state:"zerovalue"`
+	replicaWaiter waiter.Queue
 }
 
 func newLineDiscipline(termios linux.KernelTermios) *lineDiscipline {
diff --git a/pkg/sentry/fs/tty/tty_state_autogen.go b/pkg/sentry/fs/tty/tty_state_autogen.go
index 2fb0a8d27..1319a8d28 100644
--- a/pkg/sentry/fs/tty/tty_state_autogen.go
+++ b/pkg/sentry/fs/tty/tty_state_autogen.go
@@ -127,6 +127,8 @@ func (l *lineDiscipline) StateFields() []string {
 		"outQueue",
 		"termios",
 		"column",
+		"masterWaiter",
+		"replicaWaiter",
 	}
 }
 
@@ -135,17 +137,13 @@ func (l *lineDiscipline) beforeSave() {}
 // +checklocksignore
 func (l *lineDiscipline) StateSave(stateSinkObject state.Sink) {
 	l.beforeSave()
-	if !state.IsZeroValue(&l.masterWaiter) {
-		state.Failf("masterWaiter is %#v, expected zero", &l.masterWaiter)
-	}
-	if !state.IsZeroValue(&l.replicaWaiter) {
-		state.Failf("replicaWaiter is %#v, expected zero", &l.replicaWaiter)
-	}
 	stateSinkObject.Save(0, &l.size)
 	stateSinkObject.Save(1, &l.inQueue)
 	stateSinkObject.Save(2, &l.outQueue)
 	stateSinkObject.Save(3, &l.termios)
 	stateSinkObject.Save(4, &l.column)
+	stateSinkObject.Save(5, &l.masterWaiter)
+	stateSinkObject.Save(6, &l.replicaWaiter)
 }
 
 func (l *lineDiscipline) afterLoad() {}
@@ -157,6 +155,8 @@ func (l *lineDiscipline) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(2, &l.outQueue)
 	stateSourceObject.Load(3, &l.termios)
 	stateSourceObject.Load(4, &l.column)
+	stateSourceObject.Load(5, &l.masterWaiter)
+	stateSourceObject.Load(6, &l.replicaWaiter)
 }
 
 func (o *outputQueueTransformer) StateTypeName() string {
diff --git a/pkg/sentry/kernel/epoll/epoll.go b/pkg/sentry/kernel/epoll/epoll.go
index 6006c46a9..8d0a21baf 100644
--- a/pkg/sentry/kernel/epoll/epoll.go
+++ b/pkg/sentry/kernel/epoll/epoll.go
@@ -66,7 +66,7 @@ type pollEntry struct {
 	file     *refs.WeakRef  `state:"manual"`
 	id       FileIdentifier `state:"wait"`
 	userData [2]int32
-	waiter   waiter.Entry `state:"manual"`
+	waiter   waiter.Entry
 	mask     waiter.EventMask
 	flags    EntryFlags
 
@@ -102,7 +102,7 @@ type EventPoll struct {
 
 	// Wait queue is used to notify interested parties when the event poll
 	// object itself becomes readable or writable.
-	waiter.Queue `state:"zerovalue"`
+	waiter.Queue
 
 	// files is the map of all the files currently being observed, it is
 	// protected by mu.
@@ -454,14 +454,3 @@ func (e *EventPoll) RemoveEntry(ctx context.Context, id FileIdentifier) error {
 
 	return nil
 }
-
-// UnregisterEpollWaiters removes the epoll waiter objects from the waiting
-// queues. This is different from Release() as the file is not dereferenced.
-func (e *EventPoll) UnregisterEpollWaiters() {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-
-	for _, entry := range e.files {
-		entry.id.File.EventUnregister(&entry.waiter)
-	}
-}
diff --git a/pkg/sentry/kernel/epoll/epoll_state.go b/pkg/sentry/kernel/epoll/epoll_state.go
index e08d6287f..135a6d72c 100644
--- a/pkg/sentry/kernel/epoll/epoll_state.go
+++ b/pkg/sentry/kernel/epoll/epoll_state.go
@@ -21,9 +21,7 @@ import (
 
 // afterLoad is invoked by stateify.
 func (p *pollEntry) afterLoad() {
-	p.waiter.Callback = p
 	p.file = refs.NewWeakRef(p.id.File, p)
-	p.id.File.EventRegister(&p.waiter, p.mask)
 }
 
 // afterLoad is invoked by stateify.
diff --git a/pkg/sentry/kernel/epoll/epoll_state_autogen.go b/pkg/sentry/kernel/epoll/epoll_state_autogen.go
index 44bd520ac..25fbc8f72 100644
--- a/pkg/sentry/kernel/epoll/epoll_state_autogen.go
+++ b/pkg/sentry/kernel/epoll/epoll_state_autogen.go
@@ -43,6 +43,7 @@ func (p *pollEntry) StateFields() []string {
 		"pollEntryEntry",
 		"id",
 		"userData",
+		"waiter",
 		"mask",
 		"flags",
 		"epoll",
@@ -57,9 +58,10 @@ func (p *pollEntry) StateSave(stateSinkObject state.Sink) {
 	stateSinkObject.Save(0, &p.pollEntryEntry)
 	stateSinkObject.Save(1, &p.id)
 	stateSinkObject.Save(2, &p.userData)
-	stateSinkObject.Save(3, &p.mask)
-	stateSinkObject.Save(4, &p.flags)
-	stateSinkObject.Save(5, &p.epoll)
+	stateSinkObject.Save(3, &p.waiter)
+	stateSinkObject.Save(4, &p.mask)
+	stateSinkObject.Save(5, &p.flags)
+	stateSinkObject.Save(6, &p.epoll)
 }
 
 // +checklocksignore
@@ -67,9 +69,10 @@ func (p *pollEntry) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(0, &p.pollEntryEntry)
 	stateSourceObject.LoadWait(1, &p.id)
 	stateSourceObject.Load(2, &p.userData)
-	stateSourceObject.Load(3, &p.mask)
-	stateSourceObject.Load(4, &p.flags)
-	stateSourceObject.Load(5, &p.epoll)
+	stateSourceObject.Load(3, &p.waiter)
+	stateSourceObject.Load(4, &p.mask)
+	stateSourceObject.Load(5, &p.flags)
+	stateSourceObject.Load(6, &p.epoll)
 	stateSourceObject.AfterLoad(p.afterLoad)
 }
 
@@ -79,6 +82,7 @@ func (e *EventPoll) StateTypeName() string {
 
 func (e *EventPoll) StateFields() []string {
 	return []string{
+		"Queue",
 		"files",
 		"readyList",
 		"waitingList",
@@ -109,21 +113,20 @@ func (e *EventPoll) StateSave(stateSinkObject state.Sink) {
 	if !state.IsZeroValue(&e.FileNoMMap) {
 		state.Failf("FileNoMMap is %#v, expected zero", &e.FileNoMMap)
 	}
-	if !state.IsZeroValue(&e.Queue) {
-		state.Failf("Queue is %#v, expected zero", &e.Queue)
-	}
-	stateSinkObject.Save(0, &e.files)
-	stateSinkObject.Save(1, &e.readyList)
-	stateSinkObject.Save(2, &e.waitingList)
-	stateSinkObject.Save(3, &e.disabledList)
+	stateSinkObject.Save(0, &e.Queue)
+	stateSinkObject.Save(1, &e.files)
+	stateSinkObject.Save(2, &e.readyList)
+	stateSinkObject.Save(3, &e.waitingList)
+	stateSinkObject.Save(4, &e.disabledList)
 }
 
 // +checklocksignore
 func (e *EventPoll) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &e.files)
-	stateSourceObject.Load(1, &e.readyList)
-	stateSourceObject.Load(2, &e.waitingList)
-	stateSourceObject.Load(3, &e.disabledList)
+	stateSourceObject.Load(0, &e.Queue)
+	stateSourceObject.Load(1, &e.files)
+	stateSourceObject.Load(2, &e.readyList)
+	stateSourceObject.Load(3, &e.waitingList)
+	stateSourceObject.Load(4, &e.disabledList)
 	stateSourceObject.AfterLoad(e.afterLoad)
 }
 
diff --git a/pkg/sentry/kernel/eventfd/eventfd.go b/pkg/sentry/kernel/eventfd/eventfd.go
index 5ea44a2c2..bf625dede 100644
--- a/pkg/sentry/kernel/eventfd/eventfd.go
+++ b/pkg/sentry/kernel/eventfd/eventfd.go
@@ -54,7 +54,7 @@ type EventOperations struct {
 
 	// Queue is used to notify interested parties when the event object
 	// becomes readable or writable.
-	wq waiter.Queue `state:"zerovalue"`
+	wq waiter.Queue
 
 	// val is the current value of the event counter.
 	val uint64
diff --git a/pkg/sentry/kernel/eventfd/eventfd_state_autogen.go b/pkg/sentry/kernel/eventfd/eventfd_state_autogen.go
index 596920c42..97b5089d1 100644
--- a/pkg/sentry/kernel/eventfd/eventfd_state_autogen.go
+++ b/pkg/sentry/kernel/eventfd/eventfd_state_autogen.go
@@ -12,6 +12,7 @@ func (e *EventOperations) StateTypeName() string {
 
 func (e *EventOperations) StateFields() []string {
 	return []string{
+		"wq",
 		"val",
 		"semMode",
 		"hostfd",
@@ -23,21 +24,20 @@ func (e *EventOperations) beforeSave() {}
 // +checklocksignore
 func (e *EventOperations) StateSave(stateSinkObject state.Sink) {
 	e.beforeSave()
-	if !state.IsZeroValue(&e.wq) {
-		state.Failf("wq is %#v, expected zero", &e.wq)
-	}
-	stateSinkObject.Save(0, &e.val)
-	stateSinkObject.Save(1, &e.semMode)
-	stateSinkObject.Save(2, &e.hostfd)
+	stateSinkObject.Save(0, &e.wq)
+	stateSinkObject.Save(1, &e.val)
+	stateSinkObject.Save(2, &e.semMode)
+	stateSinkObject.Save(3, &e.hostfd)
 }
 
 func (e *EventOperations) afterLoad() {}
 
 // +checklocksignore
 func (e *EventOperations) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &e.val)
-	stateSourceObject.Load(1, &e.semMode)
-	stateSourceObject.Load(2, &e.hostfd)
+	stateSourceObject.Load(0, &e.wq)
+	stateSourceObject.Load(1, &e.val)
+	stateSourceObject.Load(2, &e.semMode)
+	stateSourceObject.Load(3, &e.hostfd)
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/kernel.go b/pkg/sentry/kernel/kernel.go
index f913d25db..5dc821a48 100644
--- a/pkg/sentry/kernel/kernel.go
+++ b/pkg/sentry/kernel/kernel.go
@@ -57,7 +57,6 @@ import (
 	"gvisor.dev/gvisor/pkg/sentry/hostcpu"
 	"gvisor.dev/gvisor/pkg/sentry/inet"
 	"gvisor.dev/gvisor/pkg/sentry/kernel/auth"
-	"gvisor.dev/gvisor/pkg/sentry/kernel/epoll"
 	"gvisor.dev/gvisor/pkg/sentry/kernel/futex"
 	"gvisor.dev/gvisor/pkg/sentry/kernel/sched"
 	ktime "gvisor.dev/gvisor/pkg/sentry/kernel/time"
@@ -486,11 +485,6 @@ func (k *Kernel) SaveTo(ctx context.Context, w wire.Writer) error {
 			return err
 		}
 
-		// Remove all epoll waiter objects from underlying wait queues.
-		// NOTE: for programs to resume execution in future snapshot scenarios,
-		// we will need to re-establish these waiter objects after saving.
-		k.tasks.unregisterEpollWaiters(ctx)
-
 		// Clear the dirent cache before saving because Dirents must be Loaded in a
 		// particular order (parents before children), and Loading dirents from a cache
 		// breaks that order.
@@ -623,32 +617,6 @@ func (k *Kernel) flushWritesToFiles(ctx context.Context) error {
 	})
 }
 
-// Preconditions: !VFS2Enabled.
-func (ts *TaskSet) unregisterEpollWaiters(ctx context.Context) {
-	ts.mu.RLock()
-	defer ts.mu.RUnlock()
-
-	// Tasks that belong to the same process could potentially point to the
-	// same FDTable. So we retain a map of processed ones to avoid
-	// processing the same FDTable multiple times.
-	processed := make(map[*FDTable]struct{})
-	for t := range ts.Root.tids {
-		// We can skip locking Task.mu here since the kernel is paused.
-		if t.fdTable == nil {
-			continue
-		}
-		if _, ok := processed[t.fdTable]; ok {
-			continue
-		}
-		t.fdTable.forEach(ctx, func(_ int32, file *fs.File, _ *vfs.FileDescription, _ FDFlags) {
-			if e, ok := file.FileOperations.(*epoll.EventPoll); ok {
-				e.UnregisterEpollWaiters()
-			}
-		})
-		processed[t.fdTable] = struct{}{}
-	}
-}
-
 // Preconditions: The kernel must be paused.
 func (k *Kernel) invalidateUnsavableMappings(ctx context.Context) error {
 	invalidated := make(map[*mm.MemoryManager]struct{})
diff --git a/pkg/sentry/kernel/kernel_state_autogen.go b/pkg/sentry/kernel/kernel_state_autogen.go
index d48c96425..ef8dd88f6 100644
--- a/pkg/sentry/kernel/kernel_state_autogen.go
+++ b/pkg/sentry/kernel/kernel_state_autogen.go
@@ -1318,6 +1318,7 @@ func (t *Task) StateFields() []string {
 		"haveSavedSignalMask",
 		"savedSignalMask",
 		"signalStack",
+		"signalQueue",
 		"groupStopPending",
 		"groupStopAcknowledged",
 		"trapStopPending",
@@ -1377,15 +1378,12 @@ func (t *Task) beforeSave() {}
 // +checklocksignore
 func (t *Task) StateSave(stateSinkObject state.Sink) {
 	t.beforeSave()
-	if !state.IsZeroValue(&t.signalQueue) {
-		state.Failf("signalQueue is %#v, expected zero", &t.signalQueue)
-	}
 	var ptraceTracerValue *Task
 	ptraceTracerValue = t.savePtraceTracer()
-	stateSinkObject.SaveValue(31, ptraceTracerValue)
+	stateSinkObject.SaveValue(32, ptraceTracerValue)
 	var syscallFiltersValue []bpf.Program
 	syscallFiltersValue = t.saveSyscallFilters()
-	stateSinkObject.SaveValue(48, syscallFiltersValue)
+	stateSinkObject.SaveValue(49, syscallFiltersValue)
 	stateSinkObject.Save(0, &t.taskNode)
 	stateSinkObject.Save(1, &t.runState)
 	stateSinkObject.Save(2, &t.taskWorkCount)
@@ -1399,55 +1397,56 @@ func (t *Task) StateSave(stateSinkObject state.Sink) {
 	stateSinkObject.Save(10, &t.haveSavedSignalMask)
 	stateSinkObject.Save(11, &t.savedSignalMask)
 	stateSinkObject.Save(12, &t.signalStack)
-	stateSinkObject.Save(13, &t.groupStopPending)
-	stateSinkObject.Save(14, &t.groupStopAcknowledged)
-	stateSinkObject.Save(15, &t.trapStopPending)
-	stateSinkObject.Save(16, &t.trapNotifyPending)
-	stateSinkObject.Save(17, &t.stop)
-	stateSinkObject.Save(18, &t.exitStatus)
-	stateSinkObject.Save(19, &t.syscallRestartBlock)
-	stateSinkObject.Save(20, &t.k)
-	stateSinkObject.Save(21, &t.containerID)
-	stateSinkObject.Save(22, &t.image)
-	stateSinkObject.Save(23, &t.fsContext)
-	stateSinkObject.Save(24, &t.fdTable)
-	stateSinkObject.Save(25, &t.vforkParent)
-	stateSinkObject.Save(26, &t.exitState)
-	stateSinkObject.Save(27, &t.exitTracerNotified)
-	stateSinkObject.Save(28, &t.exitTracerAcked)
-	stateSinkObject.Save(29, &t.exitParentNotified)
-	stateSinkObject.Save(30, &t.exitParentAcked)
-	stateSinkObject.Save(32, &t.ptraceTracees)
-	stateSinkObject.Save(33, &t.ptraceSeized)
-	stateSinkObject.Save(34, &t.ptraceOpts)
-	stateSinkObject.Save(35, &t.ptraceSyscallMode)
-	stateSinkObject.Save(36, &t.ptraceSinglestep)
-	stateSinkObject.Save(37, &t.ptraceCode)
-	stateSinkObject.Save(38, &t.ptraceSiginfo)
-	stateSinkObject.Save(39, &t.ptraceEventMsg)
-	stateSinkObject.Save(40, &t.ptraceYAMAExceptionAdded)
-	stateSinkObject.Save(41, &t.ioUsage)
-	stateSinkObject.Save(42, &t.creds)
-	stateSinkObject.Save(43, &t.utsns)
-	stateSinkObject.Save(44, &t.ipcns)
-	stateSinkObject.Save(45, &t.abstractSockets)
-	stateSinkObject.Save(46, &t.mountNamespaceVFS2)
-	stateSinkObject.Save(47, &t.parentDeathSignal)
-	stateSinkObject.Save(49, &t.cleartid)
-	stateSinkObject.Save(50, &t.allowedCPUMask)
-	stateSinkObject.Save(51, &t.cpu)
-	stateSinkObject.Save(52, &t.niceness)
-	stateSinkObject.Save(53, &t.numaPolicy)
-	stateSinkObject.Save(54, &t.numaNodeMask)
-	stateSinkObject.Save(55, &t.netns)
-	stateSinkObject.Save(56, &t.rseqCPU)
-	stateSinkObject.Save(57, &t.oldRSeqCPUAddr)
-	stateSinkObject.Save(58, &t.rseqAddr)
-	stateSinkObject.Save(59, &t.rseqSignature)
-	stateSinkObject.Save(60, &t.robustList)
-	stateSinkObject.Save(61, &t.startTime)
-	stateSinkObject.Save(62, &t.kcov)
-	stateSinkObject.Save(63, &t.cgroups)
+	stateSinkObject.Save(13, &t.signalQueue)
+	stateSinkObject.Save(14, &t.groupStopPending)
+	stateSinkObject.Save(15, &t.groupStopAcknowledged)
+	stateSinkObject.Save(16, &t.trapStopPending)
+	stateSinkObject.Save(17, &t.trapNotifyPending)
+	stateSinkObject.Save(18, &t.stop)
+	stateSinkObject.Save(19, &t.exitStatus)
+	stateSinkObject.Save(20, &t.syscallRestartBlock)
+	stateSinkObject.Save(21, &t.k)
+	stateSinkObject.Save(22, &t.containerID)
+	stateSinkObject.Save(23, &t.image)
+	stateSinkObject.Save(24, &t.fsContext)
+	stateSinkObject.Save(25, &t.fdTable)
+	stateSinkObject.Save(26, &t.vforkParent)
+	stateSinkObject.Save(27, &t.exitState)
+	stateSinkObject.Save(28, &t.exitTracerNotified)
+	stateSinkObject.Save(29, &t.exitTracerAcked)
+	stateSinkObject.Save(30, &t.exitParentNotified)
+	stateSinkObject.Save(31, &t.exitParentAcked)
+	stateSinkObject.Save(33, &t.ptraceTracees)
+	stateSinkObject.Save(34, &t.ptraceSeized)
+	stateSinkObject.Save(35, &t.ptraceOpts)
+	stateSinkObject.Save(36, &t.ptraceSyscallMode)
+	stateSinkObject.Save(37, &t.ptraceSinglestep)
+	stateSinkObject.Save(38, &t.ptraceCode)
+	stateSinkObject.Save(39, &t.ptraceSiginfo)
+	stateSinkObject.Save(40, &t.ptraceEventMsg)
+	stateSinkObject.Save(41, &t.ptraceYAMAExceptionAdded)
+	stateSinkObject.Save(42, &t.ioUsage)
+	stateSinkObject.Save(43, &t.creds)
+	stateSinkObject.Save(44, &t.utsns)
+	stateSinkObject.Save(45, &t.ipcns)
+	stateSinkObject.Save(46, &t.abstractSockets)
+	stateSinkObject.Save(47, &t.mountNamespaceVFS2)
+	stateSinkObject.Save(48, &t.parentDeathSignal)
+	stateSinkObject.Save(50, &t.cleartid)
+	stateSinkObject.Save(51, &t.allowedCPUMask)
+	stateSinkObject.Save(52, &t.cpu)
+	stateSinkObject.Save(53, &t.niceness)
+	stateSinkObject.Save(54, &t.numaPolicy)
+	stateSinkObject.Save(55, &t.numaNodeMask)
+	stateSinkObject.Save(56, &t.netns)
+	stateSinkObject.Save(57, &t.rseqCPU)
+	stateSinkObject.Save(58, &t.oldRSeqCPUAddr)
+	stateSinkObject.Save(59, &t.rseqAddr)
+	stateSinkObject.Save(60, &t.rseqSignature)
+	stateSinkObject.Save(61, &t.robustList)
+	stateSinkObject.Save(62, &t.startTime)
+	stateSinkObject.Save(63, &t.kcov)
+	stateSinkObject.Save(64, &t.cgroups)
 }
 
 // +checklocksignore
@@ -1465,57 +1464,58 @@ func (t *Task) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(10, &t.haveSavedSignalMask)
 	stateSourceObject.Load(11, &t.savedSignalMask)
 	stateSourceObject.Load(12, &t.signalStack)
-	stateSourceObject.Load(13, &t.groupStopPending)
-	stateSourceObject.Load(14, &t.groupStopAcknowledged)
-	stateSourceObject.Load(15, &t.trapStopPending)
-	stateSourceObject.Load(16, &t.trapNotifyPending)
-	stateSourceObject.Load(17, &t.stop)
-	stateSourceObject.Load(18, &t.exitStatus)
-	stateSourceObject.Load(19, &t.syscallRestartBlock)
-	stateSourceObject.Load(20, &t.k)
-	stateSourceObject.Load(21, &t.containerID)
-	stateSourceObject.Load(22, &t.image)
-	stateSourceObject.Load(23, &t.fsContext)
-	stateSourceObject.Load(24, &t.fdTable)
-	stateSourceObject.Load(25, &t.vforkParent)
-	stateSourceObject.Load(26, &t.exitState)
-	stateSourceObject.Load(27, &t.exitTracerNotified)
-	stateSourceObject.Load(28, &t.exitTracerAcked)
-	stateSourceObject.Load(29, &t.exitParentNotified)
-	stateSourceObject.Load(30, &t.exitParentAcked)
-	stateSourceObject.Load(32, &t.ptraceTracees)
-	stateSourceObject.Load(33, &t.ptraceSeized)
-	stateSourceObject.Load(34, &t.ptraceOpts)
-	stateSourceObject.Load(35, &t.ptraceSyscallMode)
-	stateSourceObject.Load(36, &t.ptraceSinglestep)
-	stateSourceObject.Load(37, &t.ptraceCode)
-	stateSourceObject.Load(38, &t.ptraceSiginfo)
-	stateSourceObject.Load(39, &t.ptraceEventMsg)
-	stateSourceObject.Load(40, &t.ptraceYAMAExceptionAdded)
-	stateSourceObject.Load(41, &t.ioUsage)
-	stateSourceObject.Load(42, &t.creds)
-	stateSourceObject.Load(43, &t.utsns)
-	stateSourceObject.Load(44, &t.ipcns)
-	stateSourceObject.Load(45, &t.abstractSockets)
-	stateSourceObject.Load(46, &t.mountNamespaceVFS2)
-	stateSourceObject.Load(47, &t.parentDeathSignal)
-	stateSourceObject.Load(49, &t.cleartid)
-	stateSourceObject.Load(50, &t.allowedCPUMask)
-	stateSourceObject.Load(51, &t.cpu)
-	stateSourceObject.Load(52, &t.niceness)
-	stateSourceObject.Load(53, &t.numaPolicy)
-	stateSourceObject.Load(54, &t.numaNodeMask)
-	stateSourceObject.Load(55, &t.netns)
-	stateSourceObject.Load(56, &t.rseqCPU)
-	stateSourceObject.Load(57, &t.oldRSeqCPUAddr)
-	stateSourceObject.Load(58, &t.rseqAddr)
-	stateSourceObject.Load(59, &t.rseqSignature)
-	stateSourceObject.Load(60, &t.robustList)
-	stateSourceObject.Load(61, &t.startTime)
-	stateSourceObject.Load(62, &t.kcov)
-	stateSourceObject.Load(63, &t.cgroups)
-	stateSourceObject.LoadValue(31, new(*Task), func(y interface{}) { t.loadPtraceTracer(y.(*Task)) })
-	stateSourceObject.LoadValue(48, new([]bpf.Program), func(y interface{}) { t.loadSyscallFilters(y.([]bpf.Program)) })
+	stateSourceObject.Load(13, &t.signalQueue)
+	stateSourceObject.Load(14, &t.groupStopPending)
+	stateSourceObject.Load(15, &t.groupStopAcknowledged)
+	stateSourceObject.Load(16, &t.trapStopPending)
+	stateSourceObject.Load(17, &t.trapNotifyPending)
+	stateSourceObject.Load(18, &t.stop)
+	stateSourceObject.Load(19, &t.exitStatus)
+	stateSourceObject.Load(20, &t.syscallRestartBlock)
+	stateSourceObject.Load(21, &t.k)
+	stateSourceObject.Load(22, &t.containerID)
+	stateSourceObject.Load(23, &t.image)
+	stateSourceObject.Load(24, &t.fsContext)
+	stateSourceObject.Load(25, &t.fdTable)
+	stateSourceObject.Load(26, &t.vforkParent)
+	stateSourceObject.Load(27, &t.exitState)
+	stateSourceObject.Load(28, &t.exitTracerNotified)
+	stateSourceObject.Load(29, &t.exitTracerAcked)
+	stateSourceObject.Load(30, &t.exitParentNotified)
+	stateSourceObject.Load(31, &t.exitParentAcked)
+	stateSourceObject.Load(33, &t.ptraceTracees)
+	stateSourceObject.Load(34, &t.ptraceSeized)
+	stateSourceObject.Load(35, &t.ptraceOpts)
+	stateSourceObject.Load(36, &t.ptraceSyscallMode)
+	stateSourceObject.Load(37, &t.ptraceSinglestep)
+	stateSourceObject.Load(38, &t.ptraceCode)
+	stateSourceObject.Load(39, &t.ptraceSiginfo)
+	stateSourceObject.Load(40, &t.ptraceEventMsg)
+	stateSourceObject.Load(41, &t.ptraceYAMAExceptionAdded)
+	stateSourceObject.Load(42, &t.ioUsage)
+	stateSourceObject.Load(43, &t.creds)
+	stateSourceObject.Load(44, &t.utsns)
+	stateSourceObject.Load(45, &t.ipcns)
+	stateSourceObject.Load(46, &t.abstractSockets)
+	stateSourceObject.Load(47, &t.mountNamespaceVFS2)
+	stateSourceObject.Load(48, &t.parentDeathSignal)
+	stateSourceObject.Load(50, &t.cleartid)
+	stateSourceObject.Load(51, &t.allowedCPUMask)
+	stateSourceObject.Load(52, &t.cpu)
+	stateSourceObject.Load(53, &t.niceness)
+	stateSourceObject.Load(54, &t.numaPolicy)
+	stateSourceObject.Load(55, &t.numaNodeMask)
+	stateSourceObject.Load(56, &t.netns)
+	stateSourceObject.Load(57, &t.rseqCPU)
+	stateSourceObject.Load(58, &t.oldRSeqCPUAddr)
+	stateSourceObject.Load(59, &t.rseqAddr)
+	stateSourceObject.Load(60, &t.rseqSignature)
+	stateSourceObject.Load(61, &t.robustList)
+	stateSourceObject.Load(62, &t.startTime)
+	stateSourceObject.Load(63, &t.kcov)
+	stateSourceObject.Load(64, &t.cgroups)
+	stateSourceObject.LoadValue(32, new(*Task), func(y interface{}) { t.loadPtraceTracer(y.(*Task)) })
+	stateSourceObject.LoadValue(49, new([]bpf.Program), func(y interface{}) { t.loadSyscallFilters(y.([]bpf.Program)) })
 	stateSourceObject.AfterLoad(t.afterLoad)
 }
 
@@ -2296,6 +2296,7 @@ func (t *threadGroupNode) StateTypeName() string {
 func (t *threadGroupNode) StateFields() []string {
 	return []string{
 		"pidns",
+		"eventQueue",
 		"leader",
 		"execing",
 		"tasks",
@@ -2311,12 +2312,13 @@ func (t *threadGroupNode) beforeSave() {}
 func (t *threadGroupNode) StateSave(stateSinkObject state.Sink) {
 	t.beforeSave()
 	stateSinkObject.Save(0, &t.pidns)
-	stateSinkObject.Save(1, &t.leader)
-	stateSinkObject.Save(2, &t.execing)
-	stateSinkObject.Save(3, &t.tasks)
-	stateSinkObject.Save(4, &t.tasksCount)
-	stateSinkObject.Save(5, &t.liveTasks)
-	stateSinkObject.Save(6, &t.activeTasks)
+	stateSinkObject.Save(1, &t.eventQueue)
+	stateSinkObject.Save(2, &t.leader)
+	stateSinkObject.Save(3, &t.execing)
+	stateSinkObject.Save(4, &t.tasks)
+	stateSinkObject.Save(5, &t.tasksCount)
+	stateSinkObject.Save(6, &t.liveTasks)
+	stateSinkObject.Save(7, &t.activeTasks)
 }
 
 func (t *threadGroupNode) afterLoad() {}
@@ -2324,12 +2326,13 @@ func (t *threadGroupNode) afterLoad() {}
 // +checklocksignore
 func (t *threadGroupNode) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(0, &t.pidns)
-	stateSourceObject.Load(1, &t.leader)
-	stateSourceObject.Load(2, &t.execing)
-	stateSourceObject.Load(3, &t.tasks)
-	stateSourceObject.Load(4, &t.tasksCount)
-	stateSourceObject.Load(5, &t.liveTasks)
-	stateSourceObject.Load(6, &t.activeTasks)
+	stateSourceObject.Load(1, &t.eventQueue)
+	stateSourceObject.Load(2, &t.leader)
+	stateSourceObject.Load(3, &t.execing)
+	stateSourceObject.Load(4, &t.tasks)
+	stateSourceObject.Load(5, &t.tasksCount)
+	stateSourceObject.Load(6, &t.liveTasks)
+	stateSourceObject.Load(7, &t.activeTasks)
 }
 
 func (t *taskNode) StateTypeName() string {
diff --git a/pkg/sentry/kernel/pipe/pipe.go b/pkg/sentry/kernel/pipe/pipe.go
index 86beee6fe..8345473f3 100644
--- a/pkg/sentry/kernel/pipe/pipe.go
+++ b/pkg/sentry/kernel/pipe/pipe.go
@@ -55,7 +55,7 @@ const (
 //
 // +stateify savable
 type Pipe struct {
-	waiter.Queue `state:"nosave"`
+	waiter.Queue
 
 	// isNamed indicates whether this is a named pipe.
 	//
diff --git a/pkg/sentry/kernel/pipe/pipe_state_autogen.go b/pkg/sentry/kernel/pipe/pipe_state_autogen.go
index 57451e951..cbacc0dd1 100644
--- a/pkg/sentry/kernel/pipe/pipe_state_autogen.go
+++ b/pkg/sentry/kernel/pipe/pipe_state_autogen.go
@@ -40,6 +40,7 @@ func (p *Pipe) StateTypeName() string {
 
 func (p *Pipe) StateFields() []string {
 	return []string{
+		"Queue",
 		"isNamed",
 		"readers",
 		"writers",
@@ -56,26 +57,28 @@ func (p *Pipe) beforeSave() {}
 // +checklocksignore
 func (p *Pipe) StateSave(stateSinkObject state.Sink) {
 	p.beforeSave()
-	stateSinkObject.Save(0, &p.isNamed)
-	stateSinkObject.Save(1, &p.readers)
-	stateSinkObject.Save(2, &p.writers)
-	stateSinkObject.Save(3, &p.buf)
-	stateSinkObject.Save(4, &p.off)
-	stateSinkObject.Save(5, &p.size)
-	stateSinkObject.Save(6, &p.max)
-	stateSinkObject.Save(7, &p.hadWriter)
+	stateSinkObject.Save(0, &p.Queue)
+	stateSinkObject.Save(1, &p.isNamed)
+	stateSinkObject.Save(2, &p.readers)
+	stateSinkObject.Save(3, &p.writers)
+	stateSinkObject.Save(4, &p.buf)
+	stateSinkObject.Save(5, &p.off)
+	stateSinkObject.Save(6, &p.size)
+	stateSinkObject.Save(7, &p.max)
+	stateSinkObject.Save(8, &p.hadWriter)
 }
 
 // +checklocksignore
 func (p *Pipe) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &p.isNamed)
-	stateSourceObject.Load(1, &p.readers)
-	stateSourceObject.Load(2, &p.writers)
-	stateSourceObject.Load(3, &p.buf)
-	stateSourceObject.Load(4, &p.off)
-	stateSourceObject.Load(5, &p.size)
-	stateSourceObject.Load(6, &p.max)
-	stateSourceObject.Load(7, &p.hadWriter)
+	stateSourceObject.Load(0, &p.Queue)
+	stateSourceObject.Load(1, &p.isNamed)
+	stateSourceObject.Load(2, &p.readers)
+	stateSourceObject.Load(3, &p.writers)
+	stateSourceObject.Load(4, &p.buf)
+	stateSourceObject.Load(5, &p.off)
+	stateSourceObject.Load(6, &p.size)
+	stateSourceObject.Load(7, &p.max)
+	stateSourceObject.Load(8, &p.hadWriter)
 	stateSourceObject.AfterLoad(p.afterLoad)
 }
 
diff --git a/pkg/sentry/kernel/task.go b/pkg/sentry/kernel/task.go
index b0004482c..1ea3c1bf7 100644
--- a/pkg/sentry/kernel/task.go
+++ b/pkg/sentry/kernel/task.go
@@ -158,7 +158,7 @@ type Task struct {
 	// signalQueue is protected by the signalMutex. Note that the task does
 	// not implement all queue methods, specifically the readiness checks.
 	// The task only broadcast a notification on signal delivery.
-	signalQueue waiter.Queue `state:"zerovalue"`
+	signalQueue waiter.Queue
 
 	// If groupStopPending is true, the task should participate in a group
 	// stop in the interrupt path.
diff --git a/pkg/sentry/kernel/threads.go b/pkg/sentry/kernel/threads.go
index 77ad62445..e38b723ce 100644
--- a/pkg/sentry/kernel/threads.go
+++ b/pkg/sentry/kernel/threads.go
@@ -324,11 +324,7 @@ type threadGroupNode struct {
 	// eventQueue is notified whenever a event of interest to Task.Wait occurs
 	// in a child of this thread group, or a ptrace tracee of a task in this
 	// thread group. Events are defined in task_exit.go.
-	//
-	// Note that we cannot check and save this wait queue similarly to other
-	// wait queues, as the queue will not be empty by the time of saving, due
-	// to the wait sourced from Exec().
-	eventQueue waiter.Queue `state:"nosave"`
+	eventQueue waiter.Queue
 
 	// leader is the thread group's leader, which is the oldest task in the
 	// thread group; usually the last task in the thread group to call