8 files changed, 305 insertions, 558 deletions
diff --git a/pkg/sentry/kernel/pipe/BUILD b/pkg/sentry/kernel/pipe/BUILD
deleted file mode 100644
index 4c049d5b4..000000000
--- a/pkg/sentry/kernel/pipe/BUILD
+++ /dev/null
@@ -1,67 +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 = "buffer_list",
-    out = "buffer_list.go",
-    package = "pipe",
-    prefix = "buffer",
-    template = "//pkg/ilist:generic_list",
-    types = {
-        "Element": "*buffer",
-        "Linker": "*buffer",
-    },
-)
-
-go_library(
-    name = "pipe",
-    srcs = [
-        "buffer.go",
-        "buffer_list.go",
-        "device.go",
-        "node.go",
-        "pipe.go",
-        "pipe_util.go",
-        "reader.go",
-        "reader_writer.go",
-        "vfs.go",
-        "writer.go",
-    ],
-    visibility = ["//pkg/sentry:internal"],
-    deps = [
-        "//pkg/abi/linux",
-        "//pkg/amutex",
-        "//pkg/context",
-        "//pkg/safemem",
-        "//pkg/sentry/arch",
-        "//pkg/sentry/device",
-        "//pkg/sentry/fs",
-        "//pkg/sentry/fs/fsutil",
-        "//pkg/sentry/vfs",
-        "//pkg/sync",
-        "//pkg/syserror",
-        "//pkg/usermem",
-        "//pkg/waiter",
-    ],
-)
-
-go_test(
-    name = "pipe_test",
-    size = "small",
-    srcs = [
-        "buffer_test.go",
-        "node_test.go",
-        "pipe_test.go",
-    ],
-    library = ":pipe",
-    deps = [
-        "//pkg/context",
-        "//pkg/sentry/contexttest",
-        "//pkg/sentry/fs",
-        "//pkg/syserror",
-        "//pkg/usermem",
-        "//pkg/waiter",
-    ],
-)
diff --git a/pkg/sentry/kernel/pipe/buffer_list.go b/pkg/sentry/kernel/pipe/buffer_list.go
new file mode 100755
index 000000000..42ec78788
--- /dev/null
+++ b/pkg/sentry/kernel/pipe/buffer_list.go
@@ -0,0 +1,173 @@
+package pipe
+
+// 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 bufferElementMapper struct{}
+
+// linkerFor maps an Element to a Linker.
+//
+// This default implementation should be inlined.
+//
+//go:nosplit
+func (bufferElementMapper) linkerFor(elem *buffer) *buffer { 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 bufferList struct {
+	head *buffer
+	tail *buffer
+}
+
+// Reset resets list l to the empty state.
+func (l *bufferList) Reset() {
+	l.head = nil
+	l.tail = nil
+}
+
+// Empty returns true iff the list is empty.
+func (l *bufferList) Empty() bool {
+	return l.head == nil
+}
+
+// Front returns the first element of list l or nil.
+func (l *bufferList) Front() *buffer {
+	return l.head
+}
+
+// Back returns the last element of list l or nil.
+func (l *bufferList) Back() *buffer {
+	return l.tail
+}
+
+// PushFront inserts the element e at the front of list l.
+func (l *bufferList) PushFront(e *buffer) {
+	bufferElementMapper{}.linkerFor(e).SetNext(l.head)
+	bufferElementMapper{}.linkerFor(e).SetPrev(nil)
+
+	if l.head != nil {
+		bufferElementMapper{}.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 *bufferList) PushBack(e *buffer) {
+	bufferElementMapper{}.linkerFor(e).SetNext(nil)
+	bufferElementMapper{}.linkerFor(e).SetPrev(l.tail)
+
+	if l.tail != nil {
+		bufferElementMapper{}.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 *bufferList) PushBackList(m *bufferList) {
+	if l.head == nil {
+		l.head = m.head
+		l.tail = m.tail
+	} else if m.head != nil {
+		bufferElementMapper{}.linkerFor(l.tail).SetNext(m.head)
+		bufferElementMapper{}.linkerFor(m.head).SetPrev(l.tail)
+
+		l.tail = m.tail
+	}
+
+	m.head = nil
+	m.tail = nil
+}
+
+// InsertAfter inserts e after b.
+func (l *bufferList) InsertAfter(b, e *buffer) {
+	a := bufferElementMapper{}.linkerFor(b).Next()
+	bufferElementMapper{}.linkerFor(e).SetNext(a)
+	bufferElementMapper{}.linkerFor(e).SetPrev(b)
+	bufferElementMapper{}.linkerFor(b).SetNext(e)
+
+	if a != nil {
+		bufferElementMapper{}.linkerFor(a).SetPrev(e)
+	} else {
+		l.tail = e
+	}
+}
+
+// InsertBefore inserts e before a.
+func (l *bufferList) InsertBefore(a, e *buffer) {
+	b := bufferElementMapper{}.linkerFor(a).Prev()
+	bufferElementMapper{}.linkerFor(e).SetNext(a)
+	bufferElementMapper{}.linkerFor(e).SetPrev(b)
+	bufferElementMapper{}.linkerFor(a).SetPrev(e)
+
+	if b != nil {
+		bufferElementMapper{}.linkerFor(b).SetNext(e)
+	} else {
+		l.head = e
+	}
+}
+
+// Remove removes e from l.
+func (l *bufferList) Remove(e *buffer) {
+	prev := bufferElementMapper{}.linkerFor(e).Prev()
+	next := bufferElementMapper{}.linkerFor(e).Next()
+
+	if prev != nil {
+		bufferElementMapper{}.linkerFor(prev).SetNext(next)
+	} else {
+		l.head = next
+	}
+
+	if next != nil {
+		bufferElementMapper{}.linkerFor(next).SetPrev(prev)
+	} else {
+		l.tail = prev
+	}
+}
+
+// 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 bufferEntry struct {
+	next *buffer
+	prev *buffer
+}
+
+// Next returns the entry that follows e in the list.
+func (e *bufferEntry) Next() *buffer {
+	return e.next
+}
+
+// Prev returns the entry that precedes e in the list.
+func (e *bufferEntry) Prev() *buffer {
+	return e.prev
+}
+
+// SetNext assigns 'entry' as the entry that follows e in the list.
+func (e *bufferEntry) SetNext(elem *buffer) {
+	e.next = elem
+}
+
+// SetPrev assigns 'entry' as the entry that precedes e in the list.
+func (e *bufferEntry) SetPrev(elem *buffer) {
+	e.prev = elem
+}
diff --git a/pkg/sentry/kernel/pipe/buffer_test.go b/pkg/sentry/kernel/pipe/buffer_test.go
deleted file mode 100644
index 4d54b8b8f..000000000
--- a/pkg/sentry/kernel/pipe/buffer_test.go
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright 2019 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 pipe
-
-import (
-	"testing"
-	"unsafe"
-
-	"gvisor.dev/gvisor/pkg/usermem"
-)
-
-func TestBufferSize(t *testing.T) {
-	bufferSize := unsafe.Sizeof(buffer{})
-	if bufferSize < usermem.PageSize {
-		t.Errorf("buffer is less than a page")
-	}
-	if bufferSize > (2 * usermem.PageSize) {
-		t.Errorf("buffer is greater than two pages")
-	}
-}
diff --git a/pkg/sentry/kernel/pipe/node_test.go b/pkg/sentry/kernel/pipe/node_test.go
deleted file mode 100644
index ab75a87ff..000000000
--- a/pkg/sentry/kernel/pipe/node_test.go
+++ /dev/null
@@ -1,320 +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 pipe
-
-import (
-	"testing"
-	"time"
-
-	"gvisor.dev/gvisor/pkg/context"
-	"gvisor.dev/gvisor/pkg/sentry/contexttest"
-	"gvisor.dev/gvisor/pkg/sentry/fs"
-	"gvisor.dev/gvisor/pkg/syserror"
-	"gvisor.dev/gvisor/pkg/usermem"
-)
-
-type sleeper struct {
-	context.Context
-	ch chan struct{}
-}
-
-func newSleeperContext(t *testing.T) context.Context {
-	return &sleeper{
-		Context: contexttest.Context(t),
-		ch:      make(chan struct{}),
-	}
-}
-
-func (s *sleeper) SleepStart() <-chan struct{} {
-	return s.ch
-}
-
-func (s *sleeper) SleepFinish(bool) {
-}
-
-func (s *sleeper) Cancel() {
-	s.ch <- struct{}{}
-}
-
-func (s *sleeper) Interrupted() bool {
-	return len(s.ch) != 0
-}
-
-type openResult struct {
-	*fs.File
-	error
-}
-
-var perms fs.FilePermissions = fs.FilePermissions{
-	User: fs.PermMask{Read: true, Write: true},
-}
-
-func testOpenOrDie(ctx context.Context, t *testing.T, n fs.InodeOperations, flags fs.FileFlags, doneChan chan<- struct{}) (*fs.File, error) {
-	inode := fs.NewMockInode(ctx, fs.NewMockMountSource(nil), fs.StableAttr{Type: fs.Pipe})
-	d := fs.NewDirent(ctx, inode, "pipe")
-	file, err := n.GetFile(ctx, d, flags)
-	if err != nil {
-		t.Fatalf("open with flags %+v failed: %v", flags, err)
-	}
-	if doneChan != nil {
-		doneChan <- struct{}{}
-	}
-	return file, err
-}
-
-func testOpen(ctx context.Context, t *testing.T, n fs.InodeOperations, flags fs.FileFlags, resChan chan<- openResult) (*fs.File, error) {
-	inode := fs.NewMockInode(ctx, fs.NewMockMountSource(nil), fs.StableAttr{Type: fs.Pipe})
-	d := fs.NewDirent(ctx, inode, "pipe")
-	file, err := n.GetFile(ctx, d, flags)
-	if resChan != nil {
-		resChan <- openResult{file, err}
-	}
-	return file, err
-}
-
-func newNamedPipe(t *testing.T) *Pipe {
-	return NewPipe(true, DefaultPipeSize, usermem.PageSize)
-}
-
-func newAnonPipe(t *testing.T) *Pipe {
-	return NewPipe(false, DefaultPipeSize, usermem.PageSize)
-}
-
-// assertRecvBlocks ensures that a recv attempt on c blocks for at least
-// blockDuration. This is useful for checking that a goroutine that is supposed
-// to be executing a blocking operation is actually blocking.
-func assertRecvBlocks(t *testing.T, c <-chan struct{}, blockDuration time.Duration, failMsg string) {
-	select {
-	case <-c:
-		t.Fatalf(failMsg)
-	case <-time.After(blockDuration):
-		// Ok, blocked for the required duration.
-	}
-}
-
-func TestReadOpenBlocksForWriteOpen(t *testing.T) {
-	ctx := newSleeperContext(t)
-	f := NewInodeOperations(ctx, perms, newNamedPipe(t))
-
-	rDone := make(chan struct{})
-	go testOpenOrDie(ctx, t, f, fs.FileFlags{Read: true}, rDone)
-
-	// Verify that the open for read is blocking.
-	assertRecvBlocks(t, rDone, time.Millisecond*100,
-		"open for read not blocking with no writers")
-
-	wDone := make(chan struct{})
-	go testOpenOrDie(ctx, t, f, fs.FileFlags{Write: true}, wDone)
-
-	<-wDone
-	<-rDone
-}
-
-func TestWriteOpenBlocksForReadOpen(t *testing.T) {
-	ctx := newSleeperContext(t)
-	f := NewInodeOperations(ctx, perms, newNamedPipe(t))
-
-	wDone := make(chan struct{})
-	go testOpenOrDie(ctx, t, f, fs.FileFlags{Write: true}, wDone)
-
-	// Verify that the open for write is blocking
-	assertRecvBlocks(t, wDone, time.Millisecond*100,
-		"open for write not blocking with no readers")
-
-	rDone := make(chan struct{})
-	go testOpenOrDie(ctx, t, f, fs.FileFlags{Read: true}, rDone)
-
-	<-rDone
-	<-wDone
-}
-
-func TestMultipleWriteOpenDoesntCountAsReadOpen(t *testing.T) {
-	ctx := newSleeperContext(t)
-	f := NewInodeOperations(ctx, perms, newNamedPipe(t))
-
-	rDone1 := make(chan struct{})
-	rDone2 := make(chan struct{})
-	go testOpenOrDie(ctx, t, f, fs.FileFlags{Read: true}, rDone1)
-	go testOpenOrDie(ctx, t, f, fs.FileFlags{Read: true}, rDone2)
-
-	assertRecvBlocks(t, rDone1, time.Millisecond*100,
-		"open for read didn't block with no writers")
-	assertRecvBlocks(t, rDone2, time.Millisecond*100,
-		"open for read didn't block with no writers")
-
-	wDone := make(chan struct{})
-	go testOpenOrDie(ctx, t, f, fs.FileFlags{Write: true}, wDone)
-
-	<-wDone
-	<-rDone2
-	<-rDone1
-}
-
-func TestClosedReaderBlocksWriteOpen(t *testing.T) {
-	ctx := newSleeperContext(t)
-	f := NewInodeOperations(ctx, perms, newNamedPipe(t))
-
-	rFile, _ := testOpenOrDie(ctx, t, f, fs.FileFlags{Read: true, NonBlocking: true}, nil)
-	rFile.DecRef()
-
-	wDone := make(chan struct{})
-	// This open for write should block because the reader is now gone.
-	go testOpenOrDie(ctx, t, f, fs.FileFlags{Write: true}, wDone)
-	assertRecvBlocks(t, wDone, time.Millisecond*100,
-		"open for write didn't block with no concurrent readers")
-
-	// Open for read again. This should unblock the open for write.
-	rDone := make(chan struct{})
-	go testOpenOrDie(ctx, t, f, fs.FileFlags{Read: true}, rDone)
-
-	<-rDone
-	<-wDone
-}
-
-func TestReadWriteOpenNeverBlocks(t *testing.T) {
-	ctx := newSleeperContext(t)
-	f := NewInodeOperations(ctx, perms, newNamedPipe(t))
-
-	rwDone := make(chan struct{})
-	// Open for read-write never wait for a reader or writer, even if the
-	// nonblocking flag is not set.
-	go testOpenOrDie(ctx, t, f, fs.FileFlags{Read: true, Write: true, NonBlocking: false}, rwDone)
-	<-rwDone
-}
-
-func TestReadWriteOpenUnblocksReadOpen(t *testing.T) {
-	ctx := newSleeperContext(t)
-	f := NewInodeOperations(ctx, perms, newNamedPipe(t))
-
-	rDone := make(chan struct{})
-	go testOpenOrDie(ctx, t, f, fs.FileFlags{Read: true}, rDone)
-
-	rwDone := make(chan struct{})
-	go testOpenOrDie(ctx, t, f, fs.FileFlags{Read: true, Write: true}, rwDone)
-
-	<-rwDone
-	<-rDone
-}
-
-func TestReadWriteOpenUnblocksWriteOpen(t *testing.T) {
-	ctx := newSleeperContext(t)
-	f := NewInodeOperations(ctx, perms, newNamedPipe(t))
-
-	wDone := make(chan struct{})
-	go testOpenOrDie(ctx, t, f, fs.FileFlags{Write: true}, wDone)
-
-	rwDone := make(chan struct{})
-	go testOpenOrDie(ctx, t, f, fs.FileFlags{Read: true, Write: true}, rwDone)
-
-	<-rwDone
-	<-wDone
-}
-
-func TestBlockedOpenIsCancellable(t *testing.T) {
-	ctx := newSleeperContext(t)
-	f := NewInodeOperations(ctx, perms, newNamedPipe(t))
-
-	done := make(chan openResult)
-	go testOpen(ctx, t, f, fs.FileFlags{Read: true}, done)
-	select {
-	case <-done:
-		t.Fatalf("open for read didn't block with no writers")
-	case <-time.After(time.Millisecond * 100):
-		// Ok.
-	}
-
-	ctx.(*sleeper).Cancel()
-	// If the cancel on the sleeper didn't work, the open for read would never
-	// return.
-	res := <-done
-	if res.error != syserror.ErrInterrupted {
-		t.Fatalf("Cancellation didn't cause GetFile to return fs.ErrInterrupted, got %v.",
-			res.error)
-	}
-}
-
-func TestNonblockingReadOpenFileNoWriters(t *testing.T) {
-	ctx := newSleeperContext(t)
-	f := NewInodeOperations(ctx, perms, newNamedPipe(t))
-
-	if _, err := testOpen(ctx, t, f, fs.FileFlags{Read: true, NonBlocking: true}, nil); err != nil {
-		t.Fatalf("Nonblocking open for read failed with error %v.", err)
-	}
-}
-
-func TestNonblockingWriteOpenFileNoReaders(t *testing.T) {
-	ctx := newSleeperContext(t)
-	f := NewInodeOperations(ctx, perms, newNamedPipe(t))
-
-	if _, err := testOpen(ctx, t, f, fs.FileFlags{Write: true, NonBlocking: true}, nil); err != syserror.ENXIO {
-		t.Fatalf("Nonblocking open for write failed unexpected error %v.", err)
-	}
-}
-
-func TestNonBlockingReadOpenWithWriter(t *testing.T) {
-	ctx := newSleeperContext(t)
-	f := NewInodeOperations(ctx, perms, newNamedPipe(t))
-
-	wDone := make(chan struct{})
-	go testOpenOrDie(ctx, t, f, fs.FileFlags{Write: true}, wDone)
-
-	// Open for write blocks since there are no readers yet.
-	assertRecvBlocks(t, wDone, time.Millisecond*100,
-		"Open for write didn't block with no reader.")
-
-	if _, err := testOpen(ctx, t, f, fs.FileFlags{Read: true, NonBlocking: true}, nil); err != nil {
-		t.Fatalf("Nonblocking open for read failed with error %v.", err)
-	}
-
-	// Open for write should now be unblocked.
-	<-wDone
-}
-
-func TestNonBlockingWriteOpenWithReader(t *testing.T) {
-	ctx := newSleeperContext(t)
-	f := NewInodeOperations(ctx, perms, newNamedPipe(t))
-
-	rDone := make(chan struct{})
-	go testOpenOrDie(ctx, t, f, fs.FileFlags{Read: true}, rDone)
-
-	// Open for write blocked, since no reader yet.
-	assertRecvBlocks(t, rDone, time.Millisecond*100,
-		"Open for reader didn't block with no writer.")
-
-	if _, err := testOpen(ctx, t, f, fs.FileFlags{Write: true, NonBlocking: true}, nil); err != nil {
-		t.Fatalf("Nonblocking open for write failed with error %v.", err)
-	}
-
-	// Open for write should now be unblocked.
-	<-rDone
-}
-
-func TestAnonReadOpen(t *testing.T) {
-	ctx := newSleeperContext(t)
-	f := NewInodeOperations(ctx, perms, newAnonPipe(t))
-
-	if _, err := testOpen(ctx, t, f, fs.FileFlags{Read: true}, nil); err != nil {
-		t.Fatalf("open anon pipe for read failed: %v", err)
-	}
-}
-
-func TestAnonWriteOpen(t *testing.T) {
-	ctx := newSleeperContext(t)
-	f := NewInodeOperations(ctx, perms, newAnonPipe(t))
-
-	if _, err := testOpen(ctx, t, f, fs.FileFlags{Write: true}, nil); err != nil {
-		t.Fatalf("open anon pipe for write failed: %v", err)
-	}
-}
diff --git a/pkg/sentry/kernel/pipe/pipe_state_autogen.go b/pkg/sentry/kernel/pipe/pipe_state_autogen.go
new file mode 100755
index 000000000..f7f9f32dc
--- /dev/null
+++ b/pkg/sentry/kernel/pipe/pipe_state_autogen.go
@@ -0,0 +1,132 @@
+// automatically generated by stateify.
+
+package pipe
+
+import (
+	"gvisor.dev/gvisor/pkg/state"
+)
+
+func (x *buffer) beforeSave() {}
+func (x *buffer) save(m state.Map) {
+	x.beforeSave()
+	m.Save("data", &x.data)
+	m.Save("read", &x.read)
+	m.Save("write", &x.write)
+	m.Save("bufferEntry", &x.bufferEntry)
+}
+
+func (x *buffer) afterLoad() {}
+func (x *buffer) load(m state.Map) {
+	m.Load("data", &x.data)
+	m.Load("read", &x.read)
+	m.Load("write", &x.write)
+	m.Load("bufferEntry", &x.bufferEntry)
+}
+
+func (x *bufferList) beforeSave() {}
+func (x *bufferList) save(m state.Map) {
+	x.beforeSave()
+	m.Save("head", &x.head)
+	m.Save("tail", &x.tail)
+}
+
+func (x *bufferList) afterLoad() {}
+func (x *bufferList) load(m state.Map) {
+	m.Load("head", &x.head)
+	m.Load("tail", &x.tail)
+}
+
+func (x *bufferEntry) beforeSave() {}
+func (x *bufferEntry) save(m state.Map) {
+	x.beforeSave()
+	m.Save("next", &x.next)
+	m.Save("prev", &x.prev)
+}
+
+func (x *bufferEntry) afterLoad() {}
+func (x *bufferEntry) load(m state.Map) {
+	m.Load("next", &x.next)
+	m.Load("prev", &x.prev)
+}
+
+func (x *inodeOperations) beforeSave() {}
+func (x *inodeOperations) save(m state.Map) {
+	x.beforeSave()
+	m.Save("InodeSimpleAttributes", &x.InodeSimpleAttributes)
+	m.Save("p", &x.p)
+}
+
+func (x *inodeOperations) afterLoad() {}
+func (x *inodeOperations) load(m state.Map) {
+	m.Load("InodeSimpleAttributes", &x.InodeSimpleAttributes)
+	m.Load("p", &x.p)
+}
+
+func (x *Pipe) beforeSave() {}
+func (x *Pipe) save(m state.Map) {
+	x.beforeSave()
+	m.Save("isNamed", &x.isNamed)
+	m.Save("atomicIOBytes", &x.atomicIOBytes)
+	m.Save("readers", &x.readers)
+	m.Save("writers", &x.writers)
+	m.Save("data", &x.data)
+	m.Save("max", &x.max)
+	m.Save("size", &x.size)
+	m.Save("hadWriter", &x.hadWriter)
+}
+
+func (x *Pipe) afterLoad() {}
+func (x *Pipe) load(m state.Map) {
+	m.Load("isNamed", &x.isNamed)
+	m.Load("atomicIOBytes", &x.atomicIOBytes)
+	m.Load("readers", &x.readers)
+	m.Load("writers", &x.writers)
+	m.Load("data", &x.data)
+	m.Load("max", &x.max)
+	m.Load("size", &x.size)
+	m.Load("hadWriter", &x.hadWriter)
+}
+
+func (x *Reader) beforeSave() {}
+func (x *Reader) save(m state.Map) {
+	x.beforeSave()
+	m.Save("ReaderWriter", &x.ReaderWriter)
+}
+
+func (x *Reader) afterLoad() {}
+func (x *Reader) load(m state.Map) {
+	m.Load("ReaderWriter", &x.ReaderWriter)
+}
+
+func (x *ReaderWriter) beforeSave() {}
+func (x *ReaderWriter) save(m state.Map) {
+	x.beforeSave()
+	m.Save("Pipe", &x.Pipe)
+}
+
+func (x *ReaderWriter) afterLoad() {}
+func (x *ReaderWriter) load(m state.Map) {
+	m.Load("Pipe", &x.Pipe)
+}
+
+func (x *Writer) beforeSave() {}
+func (x *Writer) save(m state.Map) {
+	x.beforeSave()
+	m.Save("ReaderWriter", &x.ReaderWriter)
+}
+
+func (x *Writer) afterLoad() {}
+func (x *Writer) load(m state.Map) {
+	m.Load("ReaderWriter", &x.ReaderWriter)
+}
+
+func init() {
+	state.Register("pkg/sentry/kernel/pipe.buffer", (*buffer)(nil), state.Fns{Save: (*buffer).save, Load: (*buffer).load})
+	state.Register("pkg/sentry/kernel/pipe.bufferList", (*bufferList)(nil), state.Fns{Save: (*bufferList).save, Load: (*bufferList).load})
+	state.Register("pkg/sentry/kernel/pipe.bufferEntry", (*bufferEntry)(nil), state.Fns{Save: (*bufferEntry).save, Load: (*bufferEntry).load})
+	state.Register("pkg/sentry/kernel/pipe.inodeOperations", (*inodeOperations)(nil), state.Fns{Save: (*inodeOperations).save, Load: (*inodeOperations).load})
+	state.Register("pkg/sentry/kernel/pipe.Pipe", (*Pipe)(nil), state.Fns{Save: (*Pipe).save, Load: (*Pipe).load})
+	state.Register("pkg/sentry/kernel/pipe.Reader", (*Reader)(nil), state.Fns{Save: (*Reader).save, Load: (*Reader).load})
+	state.Register("pkg/sentry/kernel/pipe.ReaderWriter", (*ReaderWriter)(nil), state.Fns{Save: (*ReaderWriter).save, Load: (*ReaderWriter).load})
+	state.Register("pkg/sentry/kernel/pipe.Writer", (*Writer)(nil), state.Fns{Save: (*Writer).save, Load: (*Writer).load})
+}
diff --git a/pkg/sentry/kernel/pipe/pipe_test.go b/pkg/sentry/kernel/pipe/pipe_test.go
deleted file mode 100644
index bda739dbe..000000000
--- a/pkg/sentry/kernel/pipe/pipe_test.go
+++ /dev/null
@@ -1,139 +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 pipe
-
-import (
-	"bytes"
-	"testing"
-
-	"gvisor.dev/gvisor/pkg/sentry/contexttest"
-	"gvisor.dev/gvisor/pkg/syserror"
-	"gvisor.dev/gvisor/pkg/usermem"
-	"gvisor.dev/gvisor/pkg/waiter"
-)
-
-func TestPipeRW(t *testing.T) {
-	ctx := contexttest.Context(t)
-	r, w := NewConnectedPipe(ctx, 65536, 4096)
-	defer r.DecRef()
-	defer w.DecRef()
-
-	msg := []byte("here's some bytes")
-	wantN := int64(len(msg))
-	n, err := w.Writev(ctx, usermem.BytesIOSequence(msg))
-	if n != wantN || err != nil {
-		t.Fatalf("Writev: got (%d, %v), wanted (%d, nil)", n, err, wantN)
-	}
-
-	buf := make([]byte, len(msg))
-	n, err = r.Readv(ctx, usermem.BytesIOSequence(buf))
-	if n != wantN || err != nil || !bytes.Equal(buf, msg) {
-		t.Fatalf("Readv: got (%d, %v) %q, wanted (%d, nil) %q", n, err, buf, wantN, msg)
-	}
-}
-
-func TestPipeReadBlock(t *testing.T) {
-	ctx := contexttest.Context(t)
-	r, w := NewConnectedPipe(ctx, 65536, 4096)
-	defer r.DecRef()
-	defer w.DecRef()
-
-	n, err := r.Readv(ctx, usermem.BytesIOSequence(make([]byte, 1)))
-	if n != 0 || err != syserror.ErrWouldBlock {
-		t.Fatalf("Readv: got (%d, %v), wanted (0, %v)", n, err, syserror.ErrWouldBlock)
-	}
-}
-
-func TestPipeWriteBlock(t *testing.T) {
-	const atomicIOBytes = 2
-	const capacity = MinimumPipeSize
-
-	ctx := contexttest.Context(t)
-	r, w := NewConnectedPipe(ctx, capacity, atomicIOBytes)
-	defer r.DecRef()
-	defer w.DecRef()
-
-	msg := make([]byte, capacity+1)
-	n, err := w.Writev(ctx, usermem.BytesIOSequence(msg))
-	if wantN, wantErr := int64(capacity), syserror.ErrWouldBlock; n != wantN || err != wantErr {
-		t.Fatalf("Writev: got (%d, %v), wanted (%d, %v)", n, err, wantN, wantErr)
-	}
-}
-
-func TestPipeWriteUntilEnd(t *testing.T) {
-	const atomicIOBytes = 2
-
-	ctx := contexttest.Context(t)
-	r, w := NewConnectedPipe(ctx, atomicIOBytes, atomicIOBytes)
-	defer r.DecRef()
-	defer w.DecRef()
-
-	msg := []byte("here's some bytes")
-
-	wDone := make(chan struct{}, 0)
-	rDone := make(chan struct{}, 0)
-	defer func() {
-		// Signal the reader to stop and wait until it does so.
-		close(wDone)
-		<-rDone
-	}()
-
-	go func() {
-		defer close(rDone)
-		// Read from r until done is closed.
-		ctx := contexttest.Context(t)
-		buf := make([]byte, len(msg)+1)
-		dst := usermem.BytesIOSequence(buf)
-		e, ch := waiter.NewChannelEntry(nil)
-		r.EventRegister(&e, waiter.EventIn)
-		defer r.EventUnregister(&e)
-		for {
-			n, err := r.Readv(ctx, dst)
-			dst = dst.DropFirst64(n)
-			if err == syserror.ErrWouldBlock {
-				select {
-				case <-ch:
-					continue
-				case <-wDone:
-					// We expect to have 1 byte left in dst since len(buf) ==
-					// len(msg)+1.
-					if dst.NumBytes() != 1 || !bytes.Equal(buf[:len(msg)], msg) {
-						t.Errorf("Reader: got %q (%d bytes remaining), wanted %q", buf, dst.NumBytes(), msg)
-					}
-					return
-				}
-			}
-			if err != nil {
-				t.Fatalf("Readv: got unexpected error %v", err)
-			}
-		}
-	}()
-
-	src := usermem.BytesIOSequence(msg)
-	e, ch := waiter.NewChannelEntry(nil)
-	w.EventRegister(&e, waiter.EventOut)
-	defer w.EventUnregister(&e)
-	for src.NumBytes() != 0 {
-		n, err := w.Writev(ctx, src)
-		src = src.DropFirst64(n)
-		if err == syserror.ErrWouldBlock {
-			<-ch
-			continue
-		}
-		if err != nil {
-			t.Fatalf("Writev: got (%d, %v)", n, err)
-		}
-	}
-}
diff --git a/pkg/sentry/kernel/pipe/pipe_util.go b/pkg/sentry/kernel/pipe/pipe_util.go
index 80158239e..80158239e 100644..100755
--- a/pkg/sentry/kernel/pipe/pipe_util.go
+++ b/pkg/sentry/kernel/pipe/pipe_util.go
diff --git a/pkg/sentry/kernel/pipe/vfs.go b/pkg/sentry/kernel/pipe/vfs.go
index a5675bd70..a5675bd70 100644..100755
--- a/pkg/sentry/kernel/pipe/vfs.go
+++ b/pkg/sentry/kernel/pipe/vfs.go