4 files changed, 592 insertions, 117 deletions
diff --git a/pkg/sentry/fsimpl/devpts/BUILD b/pkg/sentry/fsimpl/devpts/BUILD
deleted file mode 100644
index 48e13613a..000000000
--- a/pkg/sentry/fsimpl/devpts/BUILD
+++ /dev/null
@@ -1,61 +0,0 @@
-load("//tools:defs.bzl", "go_library", "go_test")
-load("//tools/go_generics:defs.bzl", "go_template_instance")
-
-licenses(["notice"])
-
-go_template_instance(
-    name = "root_inode_refs",
-    out = "root_inode_refs.go",
-    package = "devpts",
-    prefix = "rootInode",
-    template = "//pkg/refs_vfs2:refs_template",
-    types = {
-        "T": "rootInode",
-    },
-)
-
-go_library(
-    name = "devpts",
-    srcs = [
-        "devpts.go",
-        "line_discipline.go",
-        "master.go",
-        "queue.go",
-        "replica.go",
-        "root_inode_refs.go",
-        "terminal.go",
-    ],
-    visibility = ["//pkg/sentry:internal"],
-    deps = [
-        "//pkg/abi/linux",
-        "//pkg/context",
-        "//pkg/log",
-        "//pkg/marshal",
-        "//pkg/marshal/primitive",
-        "//pkg/refs",
-        "//pkg/safemem",
-        "//pkg/sentry/arch",
-        "//pkg/sentry/fs/lock",
-        "//pkg/sentry/fsimpl/kernfs",
-        "//pkg/sentry/kernel",
-        "//pkg/sentry/kernel/auth",
-        "//pkg/sentry/unimpl",
-        "//pkg/sentry/vfs",
-        "//pkg/sync",
-        "//pkg/syserror",
-        "//pkg/usermem",
-        "//pkg/waiter",
-    ],
-)
-
-go_test(
-    name = "devpts_test",
-    size = "small",
-    srcs = ["devpts_test.go"],
-    library = ":devpts",
-    deps = [
-        "//pkg/abi/linux",
-        "//pkg/sentry/contexttest",
-        "//pkg/usermem",
-    ],
-)
diff --git a/pkg/sentry/fsimpl/devpts/devpts_state_autogen.go b/pkg/sentry/fsimpl/devpts/devpts_state_autogen.go
new file mode 100644
index 000000000..61e4f6fdf
--- /dev/null
+++ b/pkg/sentry/fsimpl/devpts/devpts_state_autogen.go
@@ -0,0 +1,474 @@
+// automatically generated by stateify.
+
+package devpts
+
+import (
+	"gvisor.dev/gvisor/pkg/state"
+)
+
+func (x *FilesystemType) StateTypeName() string {
+	return "pkg/sentry/fsimpl/devpts.FilesystemType"
+}
+
+func (x *FilesystemType) StateFields() []string {
+	return []string{}
+}
+
+func (x *FilesystemType) beforeSave() {}
+
+func (x *FilesystemType) StateSave(m state.Sink) {
+	x.beforeSave()
+}
+
+func (x *FilesystemType) afterLoad() {}
+
+func (x *FilesystemType) StateLoad(m state.Source) {
+}
+
+func (x *filesystem) StateTypeName() string {
+	return "pkg/sentry/fsimpl/devpts.filesystem"
+}
+
+func (x *filesystem) StateFields() []string {
+	return []string{
+		"Filesystem",
+		"devMinor",
+	}
+}
+
+func (x *filesystem) beforeSave() {}
+
+func (x *filesystem) StateSave(m state.Sink) {
+	x.beforeSave()
+	m.Save(0, &x.Filesystem)
+	m.Save(1, &x.devMinor)
+}
+
+func (x *filesystem) afterLoad() {}
+
+func (x *filesystem) StateLoad(m state.Source) {
+	m.Load(0, &x.Filesystem)
+	m.Load(1, &x.devMinor)
+}
+
+func (x *rootInode) StateTypeName() string {
+	return "pkg/sentry/fsimpl/devpts.rootInode"
+}
+
+func (x *rootInode) StateFields() []string {
+	return []string{
+		"implStatFS",
+		"AlwaysValid",
+		"InodeAttrs",
+		"InodeDirectoryNoNewChildren",
+		"InodeNotSymlink",
+		"OrderedChildren",
+		"rootInodeRefs",
+		"locks",
+		"dentry",
+		"master",
+		"root",
+		"replicas",
+		"nextIdx",
+	}
+}
+
+func (x *rootInode) beforeSave() {}
+
+func (x *rootInode) StateSave(m state.Sink) {
+	x.beforeSave()
+	m.Save(0, &x.implStatFS)
+	m.Save(1, &x.AlwaysValid)
+	m.Save(2, &x.InodeAttrs)
+	m.Save(3, &x.InodeDirectoryNoNewChildren)
+	m.Save(4, &x.InodeNotSymlink)
+	m.Save(5, &x.OrderedChildren)
+	m.Save(6, &x.rootInodeRefs)
+	m.Save(7, &x.locks)
+	m.Save(8, &x.dentry)
+	m.Save(9, &x.master)
+	m.Save(10, &x.root)
+	m.Save(11, &x.replicas)
+	m.Save(12, &x.nextIdx)
+}
+
+func (x *rootInode) afterLoad() {}
+
+func (x *rootInode) StateLoad(m state.Source) {
+	m.Load(0, &x.implStatFS)
+	m.Load(1, &x.AlwaysValid)
+	m.Load(2, &x.InodeAttrs)
+	m.Load(3, &x.InodeDirectoryNoNewChildren)
+	m.Load(4, &x.InodeNotSymlink)
+	m.Load(5, &x.OrderedChildren)
+	m.Load(6, &x.rootInodeRefs)
+	m.Load(7, &x.locks)
+	m.Load(8, &x.dentry)
+	m.Load(9, &x.master)
+	m.Load(10, &x.root)
+	m.Load(11, &x.replicas)
+	m.Load(12, &x.nextIdx)
+}
+
+func (x *implStatFS) StateTypeName() string {
+	return "pkg/sentry/fsimpl/devpts.implStatFS"
+}
+
+func (x *implStatFS) StateFields() []string {
+	return []string{}
+}
+
+func (x *implStatFS) beforeSave() {}
+
+func (x *implStatFS) StateSave(m state.Sink) {
+	x.beforeSave()
+}
+
+func (x *implStatFS) afterLoad() {}
+
+func (x *implStatFS) StateLoad(m state.Source) {
+}
+
+func (x *lineDiscipline) StateTypeName() string {
+	return "pkg/sentry/fsimpl/devpts.lineDiscipline"
+}
+
+func (x *lineDiscipline) StateFields() []string {
+	return []string{
+		"size",
+		"inQueue",
+		"outQueue",
+		"termios",
+		"column",
+	}
+}
+
+func (x *lineDiscipline) beforeSave() {}
+
+func (x *lineDiscipline) StateSave(m state.Sink) {
+	x.beforeSave()
+	if !state.IsZeroValue(&x.masterWaiter) {
+		state.Failf("masterWaiter is %#v, expected zero", &x.masterWaiter)
+	}
+	if !state.IsZeroValue(&x.replicaWaiter) {
+		state.Failf("replicaWaiter is %#v, expected zero", &x.replicaWaiter)
+	}
+	m.Save(0, &x.size)
+	m.Save(1, &x.inQueue)
+	m.Save(2, &x.outQueue)
+	m.Save(3, &x.termios)
+	m.Save(4, &x.column)
+}
+
+func (x *lineDiscipline) afterLoad() {}
+
+func (x *lineDiscipline) StateLoad(m state.Source) {
+	m.Load(0, &x.size)
+	m.Load(1, &x.inQueue)
+	m.Load(2, &x.outQueue)
+	m.Load(3, &x.termios)
+	m.Load(4, &x.column)
+}
+
+func (x *outputQueueTransformer) StateTypeName() string {
+	return "pkg/sentry/fsimpl/devpts.outputQueueTransformer"
+}
+
+func (x *outputQueueTransformer) StateFields() []string {
+	return []string{}
+}
+
+func (x *outputQueueTransformer) beforeSave() {}
+
+func (x *outputQueueTransformer) StateSave(m state.Sink) {
+	x.beforeSave()
+}
+
+func (x *outputQueueTransformer) afterLoad() {}
+
+func (x *outputQueueTransformer) StateLoad(m state.Source) {
+}
+
+func (x *inputQueueTransformer) StateTypeName() string {
+	return "pkg/sentry/fsimpl/devpts.inputQueueTransformer"
+}
+
+func (x *inputQueueTransformer) StateFields() []string {
+	return []string{}
+}
+
+func (x *inputQueueTransformer) beforeSave() {}
+
+func (x *inputQueueTransformer) StateSave(m state.Sink) {
+	x.beforeSave()
+}
+
+func (x *inputQueueTransformer) afterLoad() {}
+
+func (x *inputQueueTransformer) StateLoad(m state.Source) {
+}
+
+func (x *masterInode) StateTypeName() string {
+	return "pkg/sentry/fsimpl/devpts.masterInode"
+}
+
+func (x *masterInode) StateFields() []string {
+	return []string{
+		"implStatFS",
+		"InodeAttrs",
+		"InodeNoopRefCount",
+		"InodeNotDirectory",
+		"InodeNotSymlink",
+		"locks",
+		"dentry",
+		"root",
+	}
+}
+
+func (x *masterInode) beforeSave() {}
+
+func (x *masterInode) StateSave(m state.Sink) {
+	x.beforeSave()
+	m.Save(0, &x.implStatFS)
+	m.Save(1, &x.InodeAttrs)
+	m.Save(2, &x.InodeNoopRefCount)
+	m.Save(3, &x.InodeNotDirectory)
+	m.Save(4, &x.InodeNotSymlink)
+	m.Save(5, &x.locks)
+	m.Save(6, &x.dentry)
+	m.Save(7, &x.root)
+}
+
+func (x *masterInode) afterLoad() {}
+
+func (x *masterInode) StateLoad(m state.Source) {
+	m.Load(0, &x.implStatFS)
+	m.Load(1, &x.InodeAttrs)
+	m.Load(2, &x.InodeNoopRefCount)
+	m.Load(3, &x.InodeNotDirectory)
+	m.Load(4, &x.InodeNotSymlink)
+	m.Load(5, &x.locks)
+	m.Load(6, &x.dentry)
+	m.Load(7, &x.root)
+}
+
+func (x *masterFileDescription) StateTypeName() string {
+	return "pkg/sentry/fsimpl/devpts.masterFileDescription"
+}
+
+func (x *masterFileDescription) StateFields() []string {
+	return []string{
+		"vfsfd",
+		"FileDescriptionDefaultImpl",
+		"LockFD",
+		"inode",
+		"t",
+	}
+}
+
+func (x *masterFileDescription) beforeSave() {}
+
+func (x *masterFileDescription) StateSave(m state.Sink) {
+	x.beforeSave()
+	m.Save(0, &x.vfsfd)
+	m.Save(1, &x.FileDescriptionDefaultImpl)
+	m.Save(2, &x.LockFD)
+	m.Save(3, &x.inode)
+	m.Save(4, &x.t)
+}
+
+func (x *masterFileDescription) afterLoad() {}
+
+func (x *masterFileDescription) StateLoad(m state.Source) {
+	m.Load(0, &x.vfsfd)
+	m.Load(1, &x.FileDescriptionDefaultImpl)
+	m.Load(2, &x.LockFD)
+	m.Load(3, &x.inode)
+	m.Load(4, &x.t)
+}
+
+func (x *queue) StateTypeName() string {
+	return "pkg/sentry/fsimpl/devpts.queue"
+}
+
+func (x *queue) StateFields() []string {
+	return []string{
+		"readBuf",
+		"waitBuf",
+		"waitBufLen",
+		"readable",
+		"transformer",
+	}
+}
+
+func (x *queue) beforeSave() {}
+
+func (x *queue) StateSave(m state.Sink) {
+	x.beforeSave()
+	m.Save(0, &x.readBuf)
+	m.Save(1, &x.waitBuf)
+	m.Save(2, &x.waitBufLen)
+	m.Save(3, &x.readable)
+	m.Save(4, &x.transformer)
+}
+
+func (x *queue) afterLoad() {}
+
+func (x *queue) StateLoad(m state.Source) {
+	m.Load(0, &x.readBuf)
+	m.Load(1, &x.waitBuf)
+	m.Load(2, &x.waitBufLen)
+	m.Load(3, &x.readable)
+	m.Load(4, &x.transformer)
+}
+
+func (x *replicaInode) StateTypeName() string {
+	return "pkg/sentry/fsimpl/devpts.replicaInode"
+}
+
+func (x *replicaInode) StateFields() []string {
+	return []string{
+		"implStatFS",
+		"InodeAttrs",
+		"InodeNoopRefCount",
+		"InodeNotDirectory",
+		"InodeNotSymlink",
+		"locks",
+		"dentry",
+		"root",
+		"t",
+	}
+}
+
+func (x *replicaInode) beforeSave() {}
+
+func (x *replicaInode) StateSave(m state.Sink) {
+	x.beforeSave()
+	m.Save(0, &x.implStatFS)
+	m.Save(1, &x.InodeAttrs)
+	m.Save(2, &x.InodeNoopRefCount)
+	m.Save(3, &x.InodeNotDirectory)
+	m.Save(4, &x.InodeNotSymlink)
+	m.Save(5, &x.locks)
+	m.Save(6, &x.dentry)
+	m.Save(7, &x.root)
+	m.Save(8, &x.t)
+}
+
+func (x *replicaInode) afterLoad() {}
+
+func (x *replicaInode) StateLoad(m state.Source) {
+	m.Load(0, &x.implStatFS)
+	m.Load(1, &x.InodeAttrs)
+	m.Load(2, &x.InodeNoopRefCount)
+	m.Load(3, &x.InodeNotDirectory)
+	m.Load(4, &x.InodeNotSymlink)
+	m.Load(5, &x.locks)
+	m.Load(6, &x.dentry)
+	m.Load(7, &x.root)
+	m.Load(8, &x.t)
+}
+
+func (x *replicaFileDescription) StateTypeName() string {
+	return "pkg/sentry/fsimpl/devpts.replicaFileDescription"
+}
+
+func (x *replicaFileDescription) StateFields() []string {
+	return []string{
+		"vfsfd",
+		"FileDescriptionDefaultImpl",
+		"LockFD",
+		"inode",
+	}
+}
+
+func (x *replicaFileDescription) beforeSave() {}
+
+func (x *replicaFileDescription) StateSave(m state.Sink) {
+	x.beforeSave()
+	m.Save(0, &x.vfsfd)
+	m.Save(1, &x.FileDescriptionDefaultImpl)
+	m.Save(2, &x.LockFD)
+	m.Save(3, &x.inode)
+}
+
+func (x *replicaFileDescription) afterLoad() {}
+
+func (x *replicaFileDescription) StateLoad(m state.Source) {
+	m.Load(0, &x.vfsfd)
+	m.Load(1, &x.FileDescriptionDefaultImpl)
+	m.Load(2, &x.LockFD)
+	m.Load(3, &x.inode)
+}
+
+func (x *rootInodeRefs) StateTypeName() string {
+	return "pkg/sentry/fsimpl/devpts.rootInodeRefs"
+}
+
+func (x *rootInodeRefs) StateFields() []string {
+	return []string{
+		"refCount",
+	}
+}
+
+func (x *rootInodeRefs) beforeSave() {}
+
+func (x *rootInodeRefs) StateSave(m state.Sink) {
+	x.beforeSave()
+	m.Save(0, &x.refCount)
+}
+
+func (x *rootInodeRefs) afterLoad() {}
+
+func (x *rootInodeRefs) StateLoad(m state.Source) {
+	m.Load(0, &x.refCount)
+}
+
+func (x *Terminal) StateTypeName() string {
+	return "pkg/sentry/fsimpl/devpts.Terminal"
+}
+
+func (x *Terminal) StateFields() []string {
+	return []string{
+		"n",
+		"ld",
+		"masterKTTY",
+		"replicaKTTY",
+	}
+}
+
+func (x *Terminal) beforeSave() {}
+
+func (x *Terminal) StateSave(m state.Sink) {
+	x.beforeSave()
+	m.Save(0, &x.n)
+	m.Save(1, &x.ld)
+	m.Save(2, &x.masterKTTY)
+	m.Save(3, &x.replicaKTTY)
+}
+
+func (x *Terminal) afterLoad() {}
+
+func (x *Terminal) StateLoad(m state.Source) {
+	m.Load(0, &x.n)
+	m.Load(1, &x.ld)
+	m.Load(2, &x.masterKTTY)
+	m.Load(3, &x.replicaKTTY)
+}
+
+func init() {
+	state.Register((*FilesystemType)(nil))
+	state.Register((*filesystem)(nil))
+	state.Register((*rootInode)(nil))
+	state.Register((*implStatFS)(nil))
+	state.Register((*lineDiscipline)(nil))
+	state.Register((*outputQueueTransformer)(nil))
+	state.Register((*inputQueueTransformer)(nil))
+	state.Register((*masterInode)(nil))
+	state.Register((*masterFileDescription)(nil))
+	state.Register((*queue)(nil))
+	state.Register((*replicaInode)(nil))
+	state.Register((*replicaFileDescription)(nil))
+	state.Register((*rootInodeRefs)(nil))
+	state.Register((*Terminal)(nil))
+}
diff --git a/pkg/sentry/fsimpl/devpts/devpts_test.go b/pkg/sentry/fsimpl/devpts/devpts_test.go
deleted file mode 100644
index 448390cfe..000000000
--- a/pkg/sentry/fsimpl/devpts/devpts_test.go
+++ /dev/null
@@ -1,56 +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 devpts
-
-import (
-	"testing"
-
-	"gvisor.dev/gvisor/pkg/abi/linux"
-	"gvisor.dev/gvisor/pkg/sentry/contexttest"
-	"gvisor.dev/gvisor/pkg/usermem"
-)
-
-func TestSimpleMasterToReplica(t *testing.T) {
-	ld := newLineDiscipline(linux.DefaultReplicaTermios)
-	ctx := contexttest.Context(t)
-	inBytes := []byte("hello, tty\n")
-	src := usermem.BytesIOSequence(inBytes)
-	outBytes := make([]byte, 32)
-	dst := usermem.BytesIOSequence(outBytes)
-
-	// Write to the input queue.
-	nw, err := ld.inputQueueWrite(ctx, src)
-	if err != nil {
-		t.Fatalf("error writing to input queue: %v", err)
-	}
-	if nw != int64(len(inBytes)) {
-		t.Fatalf("wrote wrong length: got %d, want %d", nw, len(inBytes))
-	}
-
-	// Read from the input queue.
-	nr, err := ld.inputQueueRead(ctx, dst)
-	if err != nil {
-		t.Fatalf("error reading from input queue: %v", err)
-	}
-	if nr != int64(len(inBytes)) {
-		t.Fatalf("read wrong length: got %d, want %d", nr, len(inBytes))
-	}
-
-	outStr := string(outBytes[:nr])
-	inStr := string(inBytes)
-	if outStr != inStr {
-		t.Fatalf("written and read strings do not match: got %q, want %q", outStr, inStr)
-	}
-}
diff --git a/pkg/sentry/fsimpl/devpts/root_inode_refs.go b/pkg/sentry/fsimpl/devpts/root_inode_refs.go
new file mode 100644
index 000000000..051801202
--- /dev/null
+++ b/pkg/sentry/fsimpl/devpts/root_inode_refs.go
@@ -0,0 +1,118 @@
+package devpts
+
+import (
+	"fmt"
+	"runtime"
+	"sync/atomic"
+
+	"gvisor.dev/gvisor/pkg/log"
+	refs_vfs1 "gvisor.dev/gvisor/pkg/refs"
+)
+
+// ownerType is used to customize logging. Note that we use a pointer to T so
+// that we do not copy the entire object when passed as a format parameter.
+var rootInodeownerType *rootInode
+
+// Refs implements refs.RefCounter. It keeps a reference count using atomic
+// operations and calls the destructor when the count reaches zero.
+//
+// Note that the number of references is actually refCount + 1 so that a default
+// zero-value Refs object contains one reference.
+//
+// TODO(gvisor.dev/issue/1486): Store stack traces when leak check is enabled in
+// a map with 16-bit hashes, and store the hash in the top 16 bits of refCount.
+// This will allow us to add stack trace information to the leak messages
+// without growing the size of Refs.
+//
+// +stateify savable
+type rootInodeRefs struct {
+	// refCount is composed of two fields:
+	//
+	//	[32-bit speculative references]:[32-bit real references]
+	//
+	// Speculative references are used for TryIncRef, to avoid a CompareAndSwap
+	// loop. See IncRef, DecRef and TryIncRef for details of how these fields are
+	// used.
+	refCount int64
+}
+
+func (r *rootInodeRefs) finalize() {
+	var note string
+	switch refs_vfs1.GetLeakMode() {
+	case refs_vfs1.NoLeakChecking:
+		return
+	case refs_vfs1.UninitializedLeakChecking:
+		note = "(Leak checker uninitialized): "
+	}
+	if n := r.ReadRefs(); n != 0 {
+		log.Warningf("%sRefs %p owned by %T garbage collected with ref count of %d (want 0)", note, r, rootInodeownerType, n)
+	}
+}
+
+// EnableLeakCheck checks for reference leaks when Refs gets garbage collected.
+func (r *rootInodeRefs) EnableLeakCheck() {
+	if refs_vfs1.GetLeakMode() != refs_vfs1.NoLeakChecking {
+		runtime.SetFinalizer(r, (*rootInodeRefs).finalize)
+	}
+}
+
+// ReadRefs returns the current number of references. The returned count is
+// inherently racy and is unsafe to use without external synchronization.
+func (r *rootInodeRefs) ReadRefs() int64 {
+
+	return atomic.LoadInt64(&r.refCount) + 1
+}
+
+// IncRef implements refs.RefCounter.IncRef.
+//
+//go:nosplit
+func (r *rootInodeRefs) IncRef() {
+	if v := atomic.AddInt64(&r.refCount, 1); v <= 0 {
+		panic(fmt.Sprintf("Incrementing non-positive ref count %p owned by %T", r, rootInodeownerType))
+	}
+}
+
+// TryIncRef implements refs.RefCounter.TryIncRef.
+//
+// To do this safely without a loop, a speculative reference is first acquired
+// on the object. This allows multiple concurrent TryIncRef calls to distinguish
+// other TryIncRef calls from genuine references held.
+//
+//go:nosplit
+func (r *rootInodeRefs) TryIncRef() bool {
+	const speculativeRef = 1 << 32
+	v := atomic.AddInt64(&r.refCount, speculativeRef)
+	if int32(v) < 0 {
+
+		atomic.AddInt64(&r.refCount, -speculativeRef)
+		return false
+	}
+
+	atomic.AddInt64(&r.refCount, -speculativeRef+1)
+	return true
+}
+
+// DecRef implements refs.RefCounter.DecRef.
+//
+// Note that speculative references are counted here. Since they were added
+// prior to real references reaching zero, they will successfully convert to
+// real references. In other words, we see speculative references only in the
+// following case:
+//
+//	A: TryIncRef [speculative increase => sees non-negative references]
+//	B: DecRef [real decrease]
+//	A: TryIncRef [transform speculative to real]
+//
+//go:nosplit
+func (r *rootInodeRefs) DecRef(destroy func()) {
+	switch v := atomic.AddInt64(&r.refCount, -1); {
+	case v < -1:
+		panic(fmt.Sprintf("Decrementing non-positive ref count %p, owned by %T", r, rootInodeownerType))
+
+	case v == -1:
+
+		if destroy != nil {
+			destroy()
+		}
+	}
+}