4 files changed, 375 insertions, 105 deletions
diff --git a/pkg/sentry/kernel/epoll/BUILD b/pkg/sentry/kernel/epoll/BUILD
deleted file mode 100644
index 75eedd5a2..000000000
--- a/pkg/sentry/kernel/epoll/BUILD
+++ /dev/null
@@ -1,51 +0,0 @@
-load("//tools:defs.bzl", "go_library", "go_test")
-load("//tools/go_generics:defs.bzl", "go_template_instance")
-
-package(licenses = ["notice"])
-
-go_template_instance(
-    name = "epoll_list",
-    out = "epoll_list.go",
-    package = "epoll",
-    prefix = "pollEntry",
-    template = "//pkg/ilist:generic_list",
-    types = {
-        "Element": "*pollEntry",
-        "Linker": "*pollEntry",
-    },
-)
-
-go_library(
-    name = "epoll",
-    srcs = [
-        "epoll.go",
-        "epoll_list.go",
-        "epoll_state.go",
-    ],
-    visibility = ["//pkg/sentry:internal"],
-    deps = [
-        "//pkg/abi/linux",
-        "//pkg/context",
-        "//pkg/refs",
-        "//pkg/sentry/fs",
-        "//pkg/sentry/fs/anon",
-        "//pkg/sentry/fs/fsutil",
-        "//pkg/sync",
-        "//pkg/usermem",
-        "//pkg/waiter",
-    ],
-)
-
-go_test(
-    name = "epoll_test",
-    size = "small",
-    srcs = [
-        "epoll_test.go",
-    ],
-    library = ":epoll",
-    deps = [
-        "//pkg/sentry/contexttest",
-        "//pkg/sentry/fs/filetest",
-        "//pkg/waiter",
-    ],
-)
diff --git a/pkg/sentry/kernel/epoll/epoll_list.go b/pkg/sentry/kernel/epoll/epoll_list.go
new file mode 100644
index 000000000..56d05c770
--- /dev/null
+++ b/pkg/sentry/kernel/epoll/epoll_list.go
@@ -0,0 +1,193 @@
+package epoll
+
+// ElementMapper provides an identity mapping by default.
+//
+// This can be replaced to provide a struct that maps elements to linker
+// objects, if they are not the same. An ElementMapper is not typically
+// required if: Linker is left as is, Element is left as is, or Linker and
+// Element are the same type.
+type pollEntryElementMapper struct{}
+
+// linkerFor maps an Element to a Linker.
+//
+// This default implementation should be inlined.
+//
+//go:nosplit
+func (pollEntryElementMapper) linkerFor(elem *pollEntry) *pollEntry { return elem }
+
+// List is an intrusive list. Entries can be added to or removed from the list
+// in O(1) time and with no additional memory allocations.
+//
+// The zero value for List is an empty list ready to use.
+//
+// To iterate over a list (where l is a List):
+//      for e := l.Front(); e != nil; e = e.Next() {
+// 		// do something with e.
+//      }
+//
+// +stateify savable
+type pollEntryList struct {
+	head *pollEntry
+	tail *pollEntry
+}
+
+// Reset resets list l to the empty state.
+func (l *pollEntryList) Reset() {
+	l.head = nil
+	l.tail = nil
+}
+
+// Empty returns true iff the list is empty.
+func (l *pollEntryList) Empty() bool {
+	return l.head == nil
+}
+
+// Front returns the first element of list l or nil.
+func (l *pollEntryList) Front() *pollEntry {
+	return l.head
+}
+
+// Back returns the last element of list l or nil.
+func (l *pollEntryList) Back() *pollEntry {
+	return l.tail
+}
+
+// Len returns the number of elements in the list.
+//
+// NOTE: This is an O(n) operation.
+func (l *pollEntryList) Len() (count int) {
+	for e := l.Front(); e != nil; e = (pollEntryElementMapper{}.linkerFor(e)).Next() {
+		count++
+	}
+	return count
+}
+
+// PushFront inserts the element e at the front of list l.
+func (l *pollEntryList) PushFront(e *pollEntry) {
+	linker := pollEntryElementMapper{}.linkerFor(e)
+	linker.SetNext(l.head)
+	linker.SetPrev(nil)
+	if l.head != nil {
+		pollEntryElementMapper{}.linkerFor(l.head).SetPrev(e)
+	} else {
+		l.tail = e
+	}
+
+	l.head = e
+}
+
+// PushBack inserts the element e at the back of list l.
+func (l *pollEntryList) PushBack(e *pollEntry) {
+	linker := pollEntryElementMapper{}.linkerFor(e)
+	linker.SetNext(nil)
+	linker.SetPrev(l.tail)
+	if l.tail != nil {
+		pollEntryElementMapper{}.linkerFor(l.tail).SetNext(e)
+	} else {
+		l.head = e
+	}
+
+	l.tail = e
+}
+
+// PushBackList inserts list m at the end of list l, emptying m.
+func (l *pollEntryList) PushBackList(m *pollEntryList) {
+	if l.head == nil {
+		l.head = m.head
+		l.tail = m.tail
+	} else if m.head != nil {
+		pollEntryElementMapper{}.linkerFor(l.tail).SetNext(m.head)
+		pollEntryElementMapper{}.linkerFor(m.head).SetPrev(l.tail)
+
+		l.tail = m.tail
+	}
+	m.head = nil
+	m.tail = nil
+}
+
+// InsertAfter inserts e after b.
+func (l *pollEntryList) InsertAfter(b, e *pollEntry) {
+	bLinker := pollEntryElementMapper{}.linkerFor(b)
+	eLinker := pollEntryElementMapper{}.linkerFor(e)
+
+	a := bLinker.Next()
+
+	eLinker.SetNext(a)
+	eLinker.SetPrev(b)
+	bLinker.SetNext(e)
+
+	if a != nil {
+		pollEntryElementMapper{}.linkerFor(a).SetPrev(e)
+	} else {
+		l.tail = e
+	}
+}
+
+// InsertBefore inserts e before a.
+func (l *pollEntryList) InsertBefore(a, e *pollEntry) {
+	aLinker := pollEntryElementMapper{}.linkerFor(a)
+	eLinker := pollEntryElementMapper{}.linkerFor(e)
+
+	b := aLinker.Prev()
+	eLinker.SetNext(a)
+	eLinker.SetPrev(b)
+	aLinker.SetPrev(e)
+
+	if b != nil {
+		pollEntryElementMapper{}.linkerFor(b).SetNext(e)
+	} else {
+		l.head = e
+	}
+}
+
+// Remove removes e from l.
+func (l *pollEntryList) Remove(e *pollEntry) {
+	linker := pollEntryElementMapper{}.linkerFor(e)
+	prev := linker.Prev()
+	next := linker.Next()
+
+	if prev != nil {
+		pollEntryElementMapper{}.linkerFor(prev).SetNext(next)
+	} else if l.head == e {
+		l.head = next
+	}
+
+	if next != nil {
+		pollEntryElementMapper{}.linkerFor(next).SetPrev(prev)
+	} else if l.tail == e {
+		l.tail = prev
+	}
+
+	linker.SetNext(nil)
+	linker.SetPrev(nil)
+}
+
+// Entry is a default implementation of Linker. Users can add anonymous fields
+// of this type to their structs to make them automatically implement the
+// methods needed by List.
+//
+// +stateify savable
+type pollEntryEntry struct {
+	next *pollEntry
+	prev *pollEntry
+}
+
+// Next returns the entry that follows e in the list.
+func (e *pollEntryEntry) Next() *pollEntry {
+	return e.next
+}
+
+// Prev returns the entry that precedes e in the list.
+func (e *pollEntryEntry) Prev() *pollEntry {
+	return e.prev
+}
+
+// SetNext assigns 'entry' as the entry that follows e in the list.
+func (e *pollEntryEntry) SetNext(elem *pollEntry) {
+	e.next = elem
+}
+
+// SetPrev assigns 'entry' as the entry that precedes e in the list.
+func (e *pollEntryEntry) SetPrev(elem *pollEntry) {
+	e.prev = elem
+}
diff --git a/pkg/sentry/kernel/epoll/epoll_state_autogen.go b/pkg/sentry/kernel/epoll/epoll_state_autogen.go
new file mode 100644
index 000000000..3b9d76751
--- /dev/null
+++ b/pkg/sentry/kernel/epoll/epoll_state_autogen.go
@@ -0,0 +1,182 @@
+// automatically generated by stateify.
+
+package epoll
+
+import (
+	"gvisor.dev/gvisor/pkg/state"
+)
+
+func (x *FileIdentifier) StateTypeName() string {
+	return "pkg/sentry/kernel/epoll.FileIdentifier"
+}
+
+func (x *FileIdentifier) StateFields() []string {
+	return []string{
+		"File",
+		"Fd",
+	}
+}
+
+func (x *FileIdentifier) beforeSave() {}
+
+func (x *FileIdentifier) StateSave(m state.Sink) {
+	x.beforeSave()
+	m.Save(0, &x.File)
+	m.Save(1, &x.Fd)
+}
+
+func (x *FileIdentifier) afterLoad() {}
+
+func (x *FileIdentifier) StateLoad(m state.Source) {
+	m.LoadWait(0, &x.File)
+	m.Load(1, &x.Fd)
+}
+
+func (x *pollEntry) StateTypeName() string {
+	return "pkg/sentry/kernel/epoll.pollEntry"
+}
+
+func (x *pollEntry) StateFields() []string {
+	return []string{
+		"pollEntryEntry",
+		"id",
+		"userData",
+		"mask",
+		"flags",
+		"epoll",
+	}
+}
+
+func (x *pollEntry) beforeSave() {}
+
+func (x *pollEntry) StateSave(m state.Sink) {
+	x.beforeSave()
+	m.Save(0, &x.pollEntryEntry)
+	m.Save(1, &x.id)
+	m.Save(2, &x.userData)
+	m.Save(3, &x.mask)
+	m.Save(4, &x.flags)
+	m.Save(5, &x.epoll)
+}
+
+func (x *pollEntry) StateLoad(m state.Source) {
+	m.Load(0, &x.pollEntryEntry)
+	m.LoadWait(1, &x.id)
+	m.Load(2, &x.userData)
+	m.Load(3, &x.mask)
+	m.Load(4, &x.flags)
+	m.Load(5, &x.epoll)
+	m.AfterLoad(x.afterLoad)
+}
+
+func (x *EventPoll) StateTypeName() string {
+	return "pkg/sentry/kernel/epoll.EventPoll"
+}
+
+func (x *EventPoll) StateFields() []string {
+	return []string{
+		"files",
+		"readyList",
+		"waitingList",
+		"disabledList",
+	}
+}
+
+func (x *EventPoll) beforeSave() {}
+
+func (x *EventPoll) StateSave(m state.Sink) {
+	x.beforeSave()
+	if !state.IsZeroValue(&x.FilePipeSeek) {
+		state.Failf("FilePipeSeek is %#v, expected zero", &x.FilePipeSeek)
+	}
+	if !state.IsZeroValue(&x.FileNotDirReaddir) {
+		state.Failf("FileNotDirReaddir is %#v, expected zero", &x.FileNotDirReaddir)
+	}
+	if !state.IsZeroValue(&x.FileNoFsync) {
+		state.Failf("FileNoFsync is %#v, expected zero", &x.FileNoFsync)
+	}
+	if !state.IsZeroValue(&x.FileNoopFlush) {
+		state.Failf("FileNoopFlush is %#v, expected zero", &x.FileNoopFlush)
+	}
+	if !state.IsZeroValue(&x.FileNoIoctl) {
+		state.Failf("FileNoIoctl is %#v, expected zero", &x.FileNoIoctl)
+	}
+	if !state.IsZeroValue(&x.FileNoMMap) {
+		state.Failf("FileNoMMap is %#v, expected zero", &x.FileNoMMap)
+	}
+	if !state.IsZeroValue(&x.Queue) {
+		state.Failf("Queue is %#v, expected zero", &x.Queue)
+	}
+	m.Save(0, &x.files)
+	m.Save(1, &x.readyList)
+	m.Save(2, &x.waitingList)
+	m.Save(3, &x.disabledList)
+}
+
+func (x *EventPoll) StateLoad(m state.Source) {
+	m.Load(0, &x.files)
+	m.Load(1, &x.readyList)
+	m.Load(2, &x.waitingList)
+	m.Load(3, &x.disabledList)
+	m.AfterLoad(x.afterLoad)
+}
+
+func (x *pollEntryList) StateTypeName() string {
+	return "pkg/sentry/kernel/epoll.pollEntryList"
+}
+
+func (x *pollEntryList) StateFields() []string {
+	return []string{
+		"head",
+		"tail",
+	}
+}
+
+func (x *pollEntryList) beforeSave() {}
+
+func (x *pollEntryList) StateSave(m state.Sink) {
+	x.beforeSave()
+	m.Save(0, &x.head)
+	m.Save(1, &x.tail)
+}
+
+func (x *pollEntryList) afterLoad() {}
+
+func (x *pollEntryList) StateLoad(m state.Source) {
+	m.Load(0, &x.head)
+	m.Load(1, &x.tail)
+}
+
+func (x *pollEntryEntry) StateTypeName() string {
+	return "pkg/sentry/kernel/epoll.pollEntryEntry"
+}
+
+func (x *pollEntryEntry) StateFields() []string {
+	return []string{
+		"next",
+		"prev",
+	}
+}
+
+func (x *pollEntryEntry) beforeSave() {}
+
+func (x *pollEntryEntry) StateSave(m state.Sink) {
+	x.beforeSave()
+	m.Save(0, &x.next)
+	m.Save(1, &x.prev)
+}
+
+func (x *pollEntryEntry) afterLoad() {}
+
+func (x *pollEntryEntry) StateLoad(m state.Source) {
+	m.Load(0, &x.next)
+	m.Load(1, &x.prev)
+}
+
+func init() {
+	state.Register((*FileIdentifier)(nil))
+	state.Register((*pollEntry)(nil))
+	state.Register((*EventPoll)(nil))
+	state.Register((*pollEntryList)(nil))
+	state.Register((*pollEntryEntry)(nil))
+}
diff --git a/pkg/sentry/kernel/epoll/epoll_test.go b/pkg/sentry/kernel/epoll/epoll_test.go
deleted file mode 100644
index 22630e9c5..000000000
--- a/pkg/sentry/kernel/epoll/epoll_test.go
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright 2018 The gVisor Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package epoll
-
-import (
-	"testing"
-
-	"gvisor.dev/gvisor/pkg/sentry/contexttest"
-	"gvisor.dev/gvisor/pkg/sentry/fs/filetest"
-	"gvisor.dev/gvisor/pkg/waiter"
-)
-
-func TestFileDestroyed(t *testing.T) {
-	f := filetest.NewTestFile(t)
-	id := FileIdentifier{f, 12}
-
-	efile := NewEventPoll(contexttest.Context(t))
-	e := efile.FileOperations.(*EventPoll)
-	if err := e.AddEntry(id, 0, waiter.EventIn, [2]int32{}); err != nil {
-		t.Fatalf("addEntry failed: %v", err)
-	}
-
-	// Check that we get an event reported twice in a row.
-	evt := e.ReadEvents(1)
-	if len(evt) != 1 {
-		t.Fatalf("Unexpected number of ready events: want %v, got %v", 1, len(evt))
-	}
-
-	evt = e.ReadEvents(1)
-	if len(evt) != 1 {
-		t.Fatalf("Unexpected number of ready events: want %v, got %v", 1, len(evt))
-	}
-
-	// Destroy the file. Check that we get no more events.
-	f.DecRef()
-
-	evt = e.ReadEvents(1)
-	if len(evt) != 0 {
-		t.Fatalf("Unexpected number of ready events: want %v, got %v", 0, len(evt))
-	}
-
-}