Merge release-20250820.0-48-gbf4fd11e1 (automated)

Author: gvisor-bot

pkg/gomaxprocs/gomaxprocs_mutex.go

@@ -60,5 +60,5 @@ func gomaxprocsinitLockNames() {}
 
 func init() {
 	gomaxprocsinitLockNames()
-	gomaxprocsprefixIndex = locking.NewMutexClass(reflect.TypeOf(gomaxprocsMutex{}), gomaxprocslockNames)
+	gomaxprocsprefixIndex = locking.NewMutexClass(reflect.TypeFor[gomaxprocsMutex](), gomaxprocslockNames)
 }

pkg/metric/metric.go

@@ -384,7 +384,7 @@ func newFieldMapper(fields ...Field) (fieldMapper, error) {
 // +checkescape:all
 //
 //go:nosplit
-func (m fieldMapper) lookupSingle(fieldIndex int, fieldValue *FieldValue, idx, remainingCombinationBucket int) (int, int) {
+func (m *fieldMapper) lookupSingle(fieldIndex int, fieldValue *FieldValue, idx, remainingCombinationBucket int) (int, int) {
 	field := m.fields[fieldIndex]
 	numValues := len(field.values)
 
@@ -422,7 +422,7 @@ func (m fieldMapper) lookupSingle(fieldIndex int, fieldValue *FieldValue, idx, r
 // +checkescape:all
 //
 //go:nosplit
-func (m fieldMapper) lookupConcat(fields1, fields2 []*FieldValue) int {
+func (m *fieldMapper) lookupConcat(fields1, fields2 []*FieldValue) int {
 	if (len(fields1) + len(fields2)) != len(m.fields) {
 		panic("invalid field lookup depth")
 	}
@@ -447,15 +447,15 @@ func (m fieldMapper) lookupConcat(fields1, fields2 []*FieldValue) int {
 // +checkescape:all
 //
 //go:nosplit
-func (m fieldMapper) lookup(fields ...*FieldValue) int {
+func (m *fieldMapper) lookup(fields ...*FieldValue) int {
 	return m.lookupConcat(fields, nil)
 }
 
 // numKeys returns the total number of key-to-field-combinations mappings
 // defined by the fieldMapper.
 //
 //go:nosplit
-func (m fieldMapper) numKeys() int {
+func (m *fieldMapper) numKeys() int {
 	return m.numFieldCombinations
 }
 
@@ -464,7 +464,7 @@ func (m fieldMapper) numKeys() int {
 //     accessed using index "keys" made by fieldMapper.
 //   - The second level corresponds to buckets within a metric. The number of
 //     buckets is specified by numBuckets.
-func (m fieldMapper) makeDistributionSampleMap(numBuckets int) [][]atomicbitops.Uint64 {
+func (m *fieldMapper) makeDistributionSampleMap(numBuckets int) [][]atomicbitops.Uint64 {
 	samples := make([][]atomicbitops.Uint64, m.numKeys())
 	for i := range samples {
 		samples[i] = make([]atomicbitops.Uint64, numBuckets)
@@ -475,7 +475,7 @@ func (m fieldMapper) makeDistributionSampleMap(numBuckets int) [][]atomicbitops.
 // keyToMultiField is the reverse of lookup/lookupConcat. The returned list of
 // field values corresponds to the same order of fields that were passed in to
 // newFieldMapper.
-func (m fieldMapper) keyToMultiField(key int) []string {
+func (m *fieldMapper) keyToMultiField(key int) []string {
 	depth := len(m.fields)
 	if depth == 0 && key == 0 {
 		return nil
@@ -495,7 +495,7 @@ func (m fieldMapper) keyToMultiField(key int) []string {
 // `len(m.fields)`.
 //
 //go:nosplit
-func (m fieldMapper) keyToMultiFieldInPlace(key int, fieldValues []*FieldValue) {
+func (m *fieldMapper) keyToMultiFieldInPlace(key int, fieldValues []*FieldValue) {
 	if len(m.fields) == 0 {
 		return
 	}
@@ -1386,10 +1386,10 @@ func EmitMetricUpdate() {
 				if (!ok && metricValue == 0) || (ok && prev.([]uint64)[fieldKey] == metricValue) {
 					continue
 				}
-
+				uint64M := allMetrics.uint64Metrics[k]
 				m.Metrics = append(m.Metrics, &pb.MetricValue{
 					Name:        k,
-					FieldValues: allMetrics.uint64Metrics[k].fieldMapper.keyToMultiField(fieldKey),
+					FieldValues: uint64M.fieldMapper.keyToMultiField(fieldKey),
 					Value:       &pb.MetricValue_Uint64Value{Uint64Value: metricValue},
 				})
 			}

pkg/ring0/kernel_amd64.go

@@ -32,7 +32,7 @@ func HaltAndWriteFSBase(regs *arch.Registers)
 
 // init initializes architecture-specific state.
 func (k *Kernel) init(maxCPUs int) {
-	entrySize := reflect.TypeOf(kernelEntry{}).Size()
+	entrySize := reflect.TypeFor[kernelEntry]().Size()
 	var (
 		entries []kernelEntry
 		padding = 1
@@ -51,7 +51,7 @@ func (k *Kernel) init(maxCPUs int) {
 	k.cpuEntries = entries
 
 	k.globalIDT = &idt64{}
-	if reflect.TypeOf(idt64{}).Size() != hostarch.PageSize {
+	if reflect.TypeFor[idt64]().Size() != hostarch.PageSize {
 		panic("Size of globalIDT should be PageSize")
 	}
 	if reflect.ValueOf(k.globalIDT).Pointer()&(hostarch.PageSize-1) != 0 {
@@ -77,12 +77,12 @@ func (k *Kernel) EntryRegions() map[uintptr]uintptr {
 	regions := make(map[uintptr]uintptr)
 
 	addr := reflect.ValueOf(&k.cpuEntries[0]).Pointer()
-	size := reflect.TypeOf(kernelEntry{}).Size() * uintptr(len(k.cpuEntries))
+	size := reflect.TypeFor[kernelEntry]().Size() * uintptr(len(k.cpuEntries))
 	end, _ := hostarch.Addr(addr + size).RoundUp()
 	regions[uintptr(hostarch.Addr(addr).RoundDown())] = uintptr(end)
 
 	addr = reflect.ValueOf(k.globalIDT).Pointer()
-	size = reflect.TypeOf(idt64{}).Size()
+	size = reflect.TypeFor[idt64]().Size()
 	end, _ = hostarch.Addr(addr + size).RoundUp()
 	regions[uintptr(hostarch.Addr(addr).RoundDown())] = uintptr(end)
 

pkg/sentry/control/lifecycle.go

@@ -21,6 +21,7 @@ import (
 
 	"google.golang.org/protobuf/types/known/timestamppb"
 	"gvisor.dev/gvisor/pkg/abi/linux"
+	"gvisor.dev/gvisor/pkg/cleanup"
 	"gvisor.dev/gvisor/pkg/eventchannel"
 	"gvisor.dev/gvisor/pkg/fd"
 	"gvisor.dev/gvisor/pkg/log"
@@ -288,6 +289,8 @@ func (l *Lifecycle) StartContainer(args *StartContainerArgs, _ *uint32) error {
 
 	initArgs.MountNamespace = mntns
 	initArgs.MountNamespace.IncRef()
+	mntnsCu := cleanup.Make(func() { initArgs.MountNamespace.DecRef(ctx) })
+	defer mntnsCu.Clean()
 
 	if args.ResolveBinaryPath {
 		resolved, err := user.ResolveExecutablePath(ctx, &initArgs)
@@ -327,6 +330,7 @@ func (l *Lifecycle) StartContainer(args *StartContainerArgs, _ *uint32) error {
 	}
 	initArgs.InitialCgroups = initialCgroups
 
+	mntnsCu.Release() // mntns ref is transferred to Kernel.CreateProcess()
 	tg, _, err := l.Kernel.CreateProcess(initArgs)
 	if err != nil {
 		return err

pkg/sentry/control/proc.go

@@ -25,6 +25,7 @@ import (
 	"time"
 
 	"gvisor.dev/gvisor/pkg/abi/linux"
+	"gvisor.dev/gvisor/pkg/cleanup"
 	"gvisor.dev/gvisor/pkg/fd"
 	"gvisor.dev/gvisor/pkg/log"
 	"gvisor.dev/gvisor/pkg/sentry/fdimport"
@@ -217,13 +218,18 @@ func (proc *Proc) execAsync(args *ExecArgs) (*kernel.ThreadGroup, kernel.ThreadI
 		PIDNamespace:         pidns,
 		Origin:               kernel.OriginExec,
 	}
-	if initArgs.MountNamespace != nil {
-		// initArgs must hold a reference on MountNamespace, which will
-		// be donated to the new process in CreateProcess.
-		initArgs.MountNamespace.IncRef()
-	}
 	ctx := initArgs.NewContext(proc.Kernel)
 
+	if initArgs.MountNamespace == nil {
+		// Set initArgs so that 'ctx' returns the namespace.
+		initArgs.MountNamespace = proc.Kernel.GlobalInit().Leader().MountNamespace()
+	}
+	// initArgs must hold a reference on MountNamespace, which will
+	// be donated to the new process in CreateProcess.
+	initArgs.MountNamespace.IncRef()
+	mntnsCu := cleanup.Make(func() { initArgs.MountNamespace.DecRef(ctx) })
+	defer mntnsCu.Clean()
+
 	// Import file descriptors.
 	var fdTable *kernel.FDTable
 	if args.FDTable != nil {
@@ -235,15 +241,6 @@ func (proc *Proc) execAsync(args *ExecArgs) (*kernel.ThreadGroup, kernel.ThreadI
 	}
 	initArgs.FDTable = fdTable
 
-	// Get the full path to the filename from the PATH env variable.
-	if initArgs.MountNamespace == nil {
-		// Set initArgs so that 'ctx' returns the namespace.
-		//
-		// Add a reference to the namespace, which is transferred to the new process.
-		initArgs.MountNamespace = proc.Kernel.GlobalInit().Leader().MountNamespace()
-		initArgs.MountNamespace.IncRef()
-	}
-
 	fdMap, execFD, err := args.unpackFiles()
 	if err != nil {
 		return nil, 0, nil, fmt.Errorf("creating fd map: %w", err)
@@ -311,6 +308,7 @@ func (proc *Proc) execAsync(args *ExecArgs) (*kernel.ThreadGroup, kernel.ThreadI
 		initArgs.InitialCgroups = initialCgrps
 	}
 
+	mntnsCu.Release() // mntns ref is transferred to Kernel.CreateProcess()
 	tg, tid, err := proc.Kernel.CreateProcess(initArgs)
 	if err != nil {
 		return nil, 0, nil, err

pkg/sentry/devices/nvproxy/fds_mutex.go

@@ -60,5 +60,5 @@ func fdsinitLockNames() {}
 
 func init() {
 	fdsinitLockNames()
-	fdsprefixIndex = locking.NewMutexClass(reflect.TypeOf(fdsMutex{}), fdslockNames)
+	fdsprefixIndex = locking.NewMutexClass(reflect.TypeFor[fdsMutex](), fdslockNames)
 }

pkg/sentry/devices/nvproxy/frontend_mmap_mutex.go

@@ -60,5 +60,5 @@ func frontendMmapinitLockNames() {}
 
 func init() {
 	frontendMmapinitLockNames()
-	frontendMmapprefixIndex = locking.NewMutexClass(reflect.TypeOf(frontendMmapMutex{}), frontendMmaplockNames)
+	frontendMmapprefixIndex = locking.NewMutexClass(reflect.TypeFor[frontendMmapMutex](), frontendMmaplockNames)
 }

pkg/sentry/devices/nvproxy/objs_mutex.go

@@ -60,5 +60,5 @@ func objsinitLockNames() {}
 
 func init() {
 	objsinitLockNames()
-	objsprefixIndex = locking.NewMutexClass(reflect.TypeOf(objsMutex{}), objslockNames)
+	objsprefixIndex = locking.NewMutexClass(reflect.TypeFor[objsMutex](), objslockNames)
 }

pkg/sentry/fsimpl/cgroupfs/pids_controller_mutex.go

@@ -60,5 +60,5 @@ func pidsControllerinitLockNames() {}
 
 func init() {
 	pidsControllerinitLockNames()
-	pidsControllerprefixIndex = locking.NewMutexClass(reflect.TypeOf(pidsControllerMutex{}), pidsControllerlockNames)
+	pidsControllerprefixIndex = locking.NewMutexClass(reflect.TypeFor[pidsControllerMutex](), pidsControllerlockNames)
 }

pkg/sentry/fsimpl/cgroupfs/task_mutex.go

@@ -92,5 +92,5 @@ func taskinitLockNames() {}
 
 func init() {
 	taskinitLockNames()
-	taskprefixIndex = locking.NewMutexClass(reflect.TypeOf(taskRWMutex{}), tasklockNames)
+	taskprefixIndex = locking.NewMutexClass(reflect.TypeFor[taskRWMutex](), tasklockNames)
 }