Create ipc.Registry.

Create ipc.Registry to hold fields, and define functionality common to
all SysV registries, and have registries use it.

3 files changed, 84 insertions, 105 deletions

diff --git a/pkg/sentry/kernel/semaphore/BUILD b/pkg/sentry/kernel/semaphore/BUILD
index 5dd607953..2ae08ed12 100644
--- a/pkg/sentry/kernel/semaphore/BUILD
+++ b/pkg/sentry/kernel/semaphore/BUILD
@@ -26,7 +26,6 @@ go_library(
         "//pkg/abi/linux",
         "//pkg/context",
         "//pkg/errors/linuxerr",
-        "//pkg/log",
         "//pkg/sentry/fs",
         "//pkg/sentry/kernel/auth",
         "//pkg/sentry/kernel/ipc",
@@ -42,10 +41,11 @@ go_test(
     srcs = ["semaphore_test.go"],
     library = ":semaphore",
     deps = [
-        "//pkg/abi/linux",
-        "//pkg/context",
-        "//pkg/sentry/contexttest",
-        "//pkg/sentry/kernel/auth",
-        "//pkg/syserror",
+        "//pkg/abi/linux",  # keep
+        "//pkg/context",  # keep
+        "//pkg/sentry/contexttest",  # keep
+        "//pkg/sentry/kernel/auth",  # keep
+        "//pkg/sentry/kernel/ipc",  # keep
+        "//pkg/syserror",  # keep
     ],
 )
diff --git a/pkg/sentry/kernel/semaphore/semaphore.go b/pkg/sentry/kernel/semaphore/semaphore.go
index d609d88e2..b7879d284 100644
--- a/pkg/sentry/kernel/semaphore/semaphore.go
+++ b/pkg/sentry/kernel/semaphore/semaphore.go
@@ -21,7 +21,6 @@ import (
 	"gvisor.dev/gvisor/pkg/abi/linux"
 	"gvisor.dev/gvisor/pkg/context"
 	"gvisor.dev/gvisor/pkg/errors/linuxerr"
-	"gvisor.dev/gvisor/pkg/log"
 	"gvisor.dev/gvisor/pkg/sentry/fs"
 	"gvisor.dev/gvisor/pkg/sentry/kernel/auth"
 	"gvisor.dev/gvisor/pkg/sentry/kernel/ipc"
@@ -48,12 +47,12 @@ const (
 //
 // +stateify savable
 type Registry struct {
-	// userNS owning the ipc name this registry belongs to. Immutable.
-	userNS *auth.UserNamespace
 	// mu protects all fields below.
-	mu         sync.Mutex `state:"nosave"`
-	semaphores map[ipc.ID]*Set
-	lastIDUsed ipc.ID
+	mu sync.Mutex `state:"nosave"`
+
+	// reg defines basic fields and operations needed for all SysV registries.
+	reg *ipc.Registry
+
 	// indexes maintains a mapping between a set's index in virtual array and
 	// its identifier.
 	indexes map[int32]ipc.ID
@@ -69,7 +68,6 @@ type Set struct {
 	// mu protects all fields below.
 	mu sync.Mutex `state:"nosave"`
 
-	// obj defines basic fields that should be included in all SysV IPC objects.
 	obj *ipc.Object
 
 	opTime     ktime.Time
@@ -109,9 +107,8 @@ type waiter struct {
 // NewRegistry creates a new semaphore set registry.
 func NewRegistry(userNS *auth.UserNamespace) *Registry {
 	return &Registry{
-		userNS:     userNS,
-		semaphores: make(map[ipc.ID]*Set),
-		indexes:    make(map[int32]ipc.ID),
+		reg:     ipc.NewRegistry(userNS),
+		indexes: make(map[int32]ipc.ID),
 	}
 }
 
@@ -129,31 +126,19 @@ func (r *Registry) FindOrCreate(ctx context.Context, key ipc.Key, nsems int32, m
 	defer r.mu.Unlock()
 
 	if !private {
-		// Look up an existing semaphore.
-		if set := r.findByKey(key); set != nil {
-			set.mu.Lock()
-			defer set.mu.Unlock()
-
-			// Check that caller can access semaphore set.
-			creds := auth.CredentialsFromContext(ctx)
-			if !set.obj.CheckPermissions(creds, fs.PermsFromMode(mode)) {
-				return nil, linuxerr.EACCES
-			}
+		set, err := r.reg.Find(ctx, key, mode, create, exclusive)
+		if err != nil {
+			return nil, err
+		}
 
-			// Validate parameters.
+		// Validate semaphore-specific parameters.
+		if set != nil {
+			set := set.(*Set)
 			if nsems > int32(set.Size()) {
 				return nil, linuxerr.EINVAL
 			}
-			if create && exclusive {
-				return nil, linuxerr.EEXIST
-			}
 			return set, nil
 		}
-
-		if !create {
-			// Semaphore not found and should not be created.
-			return nil, syserror.ENOENT
-		}
 	}
 
 	// Zero is only valid if an existing set is found.
@@ -163,9 +148,9 @@ func (r *Registry) FindOrCreate(ctx context.Context, key ipc.Key, nsems int32, m
 
 	// Apply system limits.
 	//
-	// Map semaphores and map indexes in a registry are of the same size,
-	// check map semaphores only here for the system limit.
-	if len(r.semaphores) >= setsMax {
+	// Map reg.objects and map indexes in a registry are of the same size,
+	// check map reg.objects only here for the system limit.
+	if r.reg.ObjectCount() >= setsMax {
 		return nil, syserror.ENOSPC
 	}
 	if r.totalSems() > int(semsTotalMax-nsems) {
@@ -173,9 +158,7 @@ func (r *Registry) FindOrCreate(ctx context.Context, key ipc.Key, nsems int32, m
 	}
 
 	// Finally create a new set.
-	owner := fs.FileOwnerFromContext(ctx)
-	perms := fs.FilePermsFromMode(mode)
-	return r.newSet(ctx, key, owner, owner, perms, nsems)
+	return r.newSetLocked(ctx, key, fs.FileOwnerFromContext(ctx), fs.FilePermsFromMode(mode), nsems)
 }
 
 // IPCInfo returns information about system-wide semaphore limits and parameters.
@@ -202,7 +185,7 @@ func (r *Registry) SemInfo() *linux.SemInfo {
 	defer r.mu.Unlock()
 
 	info := r.IPCInfo()
-	info.SemUsz = uint32(len(r.semaphores))
+	info.SemUsz = uint32(r.reg.ObjectCount())
 	info.SemAem = uint32(r.totalSems())
 
 	return info
@@ -225,74 +208,59 @@ func (r *Registry) HighestIndex() int32 {
 	return highestIndex
 }
 
-// RemoveID removes set with give 'id' from the registry and marks the set as
+// Remove removes set with give 'id' from the registry and marks the set as
 // dead. All waiters will be awakened and fail.
-func (r *Registry) RemoveID(id ipc.ID, creds *auth.Credentials) error {
+func (r *Registry) Remove(id ipc.ID, creds *auth.Credentials) error {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 
-	set := r.semaphores[id]
-	if set == nil {
-		return linuxerr.EINVAL
-	}
+	r.reg.Remove(id, creds)
+
 	index, found := r.findIndexByID(id)
 	if !found {
 		// Inconsistent state.
 		panic(fmt.Sprintf("unable to find an index for ID: %d", id))
 	}
-
-	set.mu.Lock()
-	defer set.mu.Unlock()
-
-	// "The effective user ID of the calling process must match the creator or
-	// owner of the semaphore set, or the caller must be privileged."
-	if !set.obj.CheckOwnership(creds) {
-		return linuxerr.EACCES
-	}
-
-	delete(r.semaphores, set.obj.ID)
 	delete(r.indexes, index)
-	set.destroy()
+
 	return nil
 }
 
-func (r *Registry) newSet(ctx context.Context, key ipc.Key, owner, creator fs.FileOwner, perms fs.FilePermissions, nsems int32) (*Set, error) {
-	// Find the next available ID.
-	for id := r.lastIDUsed + 1; id != r.lastIDUsed; id++ {
-		// Handle wrap around.
-		if id < 0 {
-			id = 0
-			continue
-		}
-		if r.semaphores[id] == nil {
-			index, found := r.findFirstAvailableIndex()
-			if !found {
-				panic("unable to find an available index")
-			}
-			r.indexes[index] = id
-			r.lastIDUsed = id
-
-			set := &Set{
-				registry:   r,
-				obj:        ipc.NewObject(r.userNS, ipc.ID(id), ipc.Key(key), creator, owner, perms),
-				changeTime: ktime.NowFromContext(ctx),
-				sems:       make([]sem, nsems),
-			}
-			r.semaphores[id] = set
+// newSetLocked creates a new Set using given fields. An error is returned if there
+// are no more available identifiers.
+//
+// Precondition: r.mu must be held.
+func (r *Registry) newSetLocked(ctx context.Context, key ipc.Key, creator fs.FileOwner, perms fs.FilePermissions, nsems int32) (*Set, error) {
+	set := &Set{
+		registry:   r,
+		obj:        ipc.NewObject(r.reg.UserNS, ipc.Key(key), creator, creator, perms),
+		changeTime: ktime.NowFromContext(ctx),
+		sems:       make([]sem, nsems),
+	}
 
-			return set, nil
-		}
+	err := r.reg.Register(set)
+	if err != nil {
+		return nil, err
+	}
+
+	index, found := r.findFirstAvailableIndex()
+	if !found {
+		panic("unable to find an available index")
 	}
+	r.indexes[index] = set.obj.ID
 
-	log.Warningf("Semaphore map is full, they must be leaking")
-	return nil, syserror.ENOMEM
+	return set, nil
 }
 
 // FindByID looks up a set given an ID.
 func (r *Registry) FindByID(id ipc.ID) *Set {
 	r.mu.Lock()
 	defer r.mu.Unlock()
-	return r.semaphores[id]
+	mech := r.reg.FindByID(id)
+	if mech == nil {
+		return nil
+	}
+	return mech.(*Set)
 }
 
 // FindByIndex looks up a set given an index.
@@ -304,16 +272,7 @@ func (r *Registry) FindByIndex(index int32) *Set {
 	if !present {
 		return nil
 	}
-	return r.semaphores[id]
-}
-
-func (r *Registry) findByKey(key ipc.Key) *Set {
-	for _, v := range r.semaphores {
-		if v.obj.Key == key {
-			return v
-		}
-	}
-	return nil
+	return r.reg.FindByID(id).(*Set)
 }
 
 func (r *Registry) findIndexByID(id ipc.ID) (int32, bool) {
@@ -336,9 +295,11 @@ func (r *Registry) findFirstAvailableIndex() (int32, bool) {
 
 func (r *Registry) totalSems() int {
 	totalSems := 0
-	for _, v := range r.semaphores {
-		totalSems += v.Size()
-	}
+	r.reg.ForAllObjects(
+		func(o ipc.Mechanism) {
+			totalSems += o.(*Set).Size()
+		},
+	)
 	return totalSems
 }
 
@@ -347,6 +308,23 @@ func (s *Set) ID() ipc.ID {
 	return s.obj.ID
 }
 
+// Object implements ipc.Mechanism.Object.
+func (s *Set) Object() *ipc.Object {
+	return s.obj
+}
+
+// Lock implements ipc.Mechanism.Lock.
+func (s *Set) Lock() {
+	s.mu.Lock()
+}
+
+// Unlock implements ipc.mechanism.Unlock.
+//
+// +checklocksignore
+func (s *Set) Unlock() {
+	s.mu.Unlock()
+}
+
 func (s *Set) findSem(num int32) *sem {
 	if num < 0 || int(num) >= s.Size() {
 		return nil
@@ -671,10 +649,10 @@ func (s *Set) AbortWait(num int32, ch chan struct{}) {
 	// Waiter may not be found in case it raced with wakeWaiters().
 }
 
-// destroy destroys the set.
+// Destroy implements ipc.Mechanism.Destroy.
 //
 // Preconditions: Caller must hold 's.mu'.
-func (s *Set) destroy() {
+func (s *Set) Destroy() {
 	// Notify all waiters. They will fail on the next attempt to execute
 	// operations and return error.
 	s.dead = true
diff --git a/pkg/sentry/kernel/semaphore/semaphore_test.go b/pkg/sentry/kernel/semaphore/semaphore_test.go
index 0c7abb68e..2e4ab8121 100644
--- a/pkg/sentry/kernel/semaphore/semaphore_test.go
+++ b/pkg/sentry/kernel/semaphore/semaphore_test.go
@@ -139,6 +139,7 @@ func TestUnregister(t *testing.T) {
 	ctx := contexttest.Context(t)
 	r := NewRegistry(auth.NewRootUserNamespace())
 	set, err := r.FindOrCreate(ctx, 123, 2, linux.FileMode(0x600), true, true, true)
+
 	if err != nil {
 		t.Fatalf("FindOrCreate() failed, err: %v", err)
 	}
@@ -156,8 +157,8 @@ func TestUnregister(t *testing.T) {
 	}
 
 	creds := auth.CredentialsFromContext(ctx)
-	if err := r.RemoveID(set.obj.ID, creds); err != nil {
-		t.Fatalf("RemoveID(%d) failed, err: %v", set.obj.ID, err)
+	if err := r.Remove(set.obj.ID, creds); err != nil {
+		t.Fatalf("Remove(%d) failed, err: %v", set.obj.ID, err)
 	}
 	if !set.dead {
 		t.Fatalf("set is not dead: %+v", set)