Merge pull request #6579 from prattmic:runsc_do_profile

PiperOrigin-RevId: 397114051

2 files changed, 91 insertions, 54 deletions

diff --git a/runsc/cmd/boot.go b/runsc/cmd/boot.go
index f5c9821b2..e33a7f3cb 100644
--- a/runsc/cmd/boot.go
+++ b/runsc/cmd/boot.go
@@ -79,6 +79,26 @@ type Boot struct {
 	// sandbox (e.g. gofer) and sent through this FD.
 	mountsFD int
 
+	// profileBlockFD is the file descriptor to write a block profile to.
+	// Valid if >= 0.
+	profileBlockFD int
+
+	// profileCPUFD is the file descriptor to write a CPU profile to.
+	// Valid if >= 0.
+	profileCPUFD int
+
+	// profileHeapFD is the file descriptor to write a heap profile to.
+	// Valid if >= 0.
+	profileHeapFD int
+
+	// profileMutexFD is the file descriptor to write a mutex profile to.
+	// Valid if >= 0.
+	profileMutexFD int
+
+	// traceFD is the file descriptor to write a Go execution trace to.
+	// Valid if >= 0.
+	traceFD int
+
 	// pidns is set if the sandbox is in its own pid namespace.
 	pidns bool
 
@@ -119,6 +139,11 @@ func (b *Boot) SetFlags(f *flag.FlagSet) {
 	f.IntVar(&b.userLogFD, "user-log-fd", 0, "file descriptor to write user logs to. 0 means no logging.")
 	f.IntVar(&b.startSyncFD, "start-sync-fd", -1, "required FD to used to synchronize sandbox startup")
 	f.IntVar(&b.mountsFD, "mounts-fd", -1, "mountsFD is the file descriptor to read list of mounts after they have been resolved (direct paths, no symlinks).")
+	f.IntVar(&b.profileBlockFD, "profile-block-fd", -1, "file descriptor to write block profile to. -1 disables profiling.")
+	f.IntVar(&b.profileCPUFD, "profile-cpu-fd", -1, "file descriptor to write CPU profile to. -1 disables profiling.")
+	f.IntVar(&b.profileHeapFD, "profile-heap-fd", -1, "file descriptor to write heap profile to. -1 disables profiling.")
+	f.IntVar(&b.profileMutexFD, "profile-mutex-fd", -1, "file descriptor to write mutex profile to. -1 disables profiling.")
+	f.IntVar(&b.traceFD, "trace-fd", -1, "file descriptor to write Go execution trace to. -1 disables tracing.")
 	f.BoolVar(&b.attached, "attached", false, "if attached is true, kills the sandbox process when the parent process terminates")
 }
 
@@ -213,16 +238,21 @@ func (b *Boot) Execute(_ context.Context, f *flag.FlagSet, args ...interface{})
 
 	// Create the loader.
 	bootArgs := boot.Args{
-		ID:           f.Arg(0),
-		Spec:         spec,
-		Conf:         conf,
-		ControllerFD: b.controllerFD,
-		Device:       os.NewFile(uintptr(b.deviceFD), "platform device"),
-		GoferFDs:     b.ioFDs.GetArray(),
-		StdioFDs:     b.stdioFDs.GetArray(),
-		NumCPU:       b.cpuNum,
-		TotalMem:     b.totalMem,
-		UserLogFD:    b.userLogFD,
+		ID:             f.Arg(0),
+		Spec:           spec,
+		Conf:           conf,
+		ControllerFD:   b.controllerFD,
+		Device:         os.NewFile(uintptr(b.deviceFD), "platform device"),
+		GoferFDs:       b.ioFDs.GetArray(),
+		StdioFDs:       b.stdioFDs.GetArray(),
+		NumCPU:         b.cpuNum,
+		TotalMem:       b.totalMem,
+		UserLogFD:      b.userLogFD,
+		ProfileBlockFD: b.profileBlockFD,
+		ProfileCPUFD:   b.profileCPUFD,
+		ProfileHeapFD:  b.profileHeapFD,
+		ProfileMutexFD: b.profileMutexFD,
+		TraceFD:        b.traceFD,
 	}
 	l, err := boot.New(bootArgs)
 	if err != nil {
diff --git a/runsc/cmd/debug.go b/runsc/cmd/debug.go
index f773ccca0..318753728 100644
--- a/runsc/cmd/debug.go
+++ b/runsc/cmd/debug.go
@@ -37,9 +37,9 @@ type Debug struct {
 	pid          int
 	stacks       bool
 	signal       int
-	profileHeap  string
-	profileCPU   string
 	profileBlock string
+	profileCPU   string
+	profileHeap  string
 	profileMutex string
 	trace        string
 	strace       string
@@ -70,9 +70,9 @@ func (*Debug) Usage() string {
 func (d *Debug) SetFlags(f *flag.FlagSet) {
 	f.IntVar(&d.pid, "pid", 0, "sandbox process ID. Container ID is not necessary if this is set")
 	f.BoolVar(&d.stacks, "stacks", false, "if true, dumps all sandbox stacks to the log")
-	f.StringVar(&d.profileHeap, "profile-heap", "", "writes heap profile to the given file.")
-	f.StringVar(&d.profileCPU, "profile-cpu", "", "writes CPU profile to the given file.")
 	f.StringVar(&d.profileBlock, "profile-block", "", "writes block profile to the given file.")
+	f.StringVar(&d.profileCPU, "profile-cpu", "", "writes CPU profile to the given file.")
+	f.StringVar(&d.profileHeap, "profile-heap", "", "writes heap profile to the given file.")
 	f.StringVar(&d.profileMutex, "profile-mutex", "", "writes mutex profile to the given file.")
 	f.DurationVar(&d.delay, "delay", time.Hour, "amount of time to delay for collecting heap and goroutine profiles.")
 	f.DurationVar(&d.duration, "duration", time.Hour, "amount of time to wait for CPU and trace profiles.")
@@ -90,6 +90,13 @@ func (d *Debug) Execute(_ context.Context, f *flag.FlagSet, args ...interface{})
 	var c *container.Container
 	conf := args[0].(*config.Config)
 
+	if conf.ProfileBlock != "" || conf.ProfileCPU != "" || conf.ProfileHeap != "" || conf.ProfileMutex != "" {
+		return Errorf("global -profile-{block,cpu,heap,mutex} flags have no effect on runsc debug. Pass runsc debug -profile-{block,cpu,heap,mutex} instead")
+	}
+	if conf.TraceFile != "" {
+		return Errorf("global -trace flag has no effect on runsc debug. Pass runsc debug -trace instead")
+	}
+
 	if d.pid == 0 {
 		// No pid, container ID must have been provided.
 		if f.NArg() != 1 {
@@ -219,19 +226,19 @@ func (d *Debug) Execute(_ context.Context, f *flag.FlagSet, args ...interface{})
 
 	// Open profiling files.
 	var (
-		heapFile  *os.File
-		cpuFile   *os.File
-		traceFile *os.File
 		blockFile *os.File
+		cpuFile   *os.File
+		heapFile  *os.File
 		mutexFile *os.File
+		traceFile *os.File
 	)
-	if d.profileHeap != "" {
-		f, err := os.OpenFile(d.profileHeap, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
+	if d.profileBlock != "" {
+		f, err := os.OpenFile(d.profileBlock, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
 		if err != nil {
-			return Errorf("error opening heap profile output: %v", err)
+			return Errorf("error opening blocking profile output: %v", err)
 		}
 		defer f.Close()
-		heapFile = f
+		blockFile = f
 	}
 	if d.profileCPU != "" {
 		f, err := os.OpenFile(d.profileCPU, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
@@ -241,20 +248,13 @@ func (d *Debug) Execute(_ context.Context, f *flag.FlagSet, args ...interface{})
 		defer f.Close()
 		cpuFile = f
 	}
-	if d.trace != "" {
-		f, err := os.OpenFile(d.trace, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
-		if err != nil {
-			return Errorf("error opening trace profile output: %v", err)
-		}
-		traceFile = f
-	}
-	if d.profileBlock != "" {
-		f, err := os.OpenFile(d.profileBlock, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
+	if d.profileHeap != "" {
+		f, err := os.OpenFile(d.profileHeap, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
 		if err != nil {
-			return Errorf("error opening blocking profile output: %v", err)
+			return Errorf("error opening heap profile output: %v", err)
 		}
 		defer f.Close()
-		blockFile = f
+		heapFile = f
 	}
 	if d.profileMutex != "" {
 		f, err := os.OpenFile(d.profileMutex, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
@@ -264,21 +264,28 @@ func (d *Debug) Execute(_ context.Context, f *flag.FlagSet, args ...interface{})
 		defer f.Close()
 		mutexFile = f
 	}
+	if d.trace != "" {
+		f, err := os.OpenFile(d.trace, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
+		if err != nil {
+			return Errorf("error opening trace profile output: %v", err)
+		}
+		traceFile = f
+	}
 
 	// Collect profiles.
 	var (
 		wg       sync.WaitGroup
-		heapErr  error
-		cpuErr   error
-		traceErr error
 		blockErr error
+		cpuErr   error
+		heapErr  error
 		mutexErr error
+		traceErr error
 	)
-	if heapFile != nil {
+	if blockFile != nil {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			heapErr = c.Sandbox.HeapProfile(heapFile, d.delay)
+			blockErr = c.Sandbox.BlockProfile(blockFile, d.duration)
 		}()
 	}
 	if cpuFile != nil {
@@ -288,25 +295,25 @@ func (d *Debug) Execute(_ context.Context, f *flag.FlagSet, args ...interface{})
 			cpuErr = c.Sandbox.CPUProfile(cpuFile, d.duration)
 		}()
 	}
-	if traceFile != nil {
+	if heapFile != nil {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			traceErr = c.Sandbox.Trace(traceFile, d.duration)
+			heapErr = c.Sandbox.HeapProfile(heapFile, d.delay)
 		}()
 	}
-	if blockFile != nil {
+	if mutexFile != nil {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			blockErr = c.Sandbox.BlockProfile(blockFile, d.duration)
+			mutexErr = c.Sandbox.MutexProfile(mutexFile, d.duration)
 		}()
 	}
-	if mutexFile != nil {
+	if traceFile != nil {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			mutexErr = c.Sandbox.MutexProfile(mutexFile, d.duration)
+			traceErr = c.Sandbox.Trace(traceFile, d.duration)
 		}()
 	}
 
@@ -339,31 +346,31 @@ func (d *Debug) Execute(_ context.Context, f *flag.FlagSet, args ...interface{})
 
 	// Collect all errors.
 	errorCount := 0
-	if heapErr != nil {
+	if blockErr != nil {
 		errorCount++
-		log.Infof("error collecting heap profile: %v", heapErr)
-		os.Remove(heapFile.Name())
+		log.Infof("error collecting block profile: %v", blockErr)
+		os.Remove(blockFile.Name())
 	}
 	if cpuErr != nil {
 		errorCount++
 		log.Infof("error collecting cpu profile: %v", cpuErr)
 		os.Remove(cpuFile.Name())
 	}
-	if traceErr != nil {
-		errorCount++
-		log.Infof("error collecting trace profile: %v", traceErr)
-		os.Remove(traceFile.Name())
-	}
-	if blockErr != nil {
+	if heapErr != nil {
 		errorCount++
-		log.Infof("error collecting block profile: %v", blockErr)
-		os.Remove(blockFile.Name())
+		log.Infof("error collecting heap profile: %v", heapErr)
+		os.Remove(heapFile.Name())
 	}
 	if mutexErr != nil {
 		errorCount++
 		log.Infof("error collecting mutex profile: %v", mutexErr)
 		os.Remove(mutexFile.Name())
 	}
+	if traceErr != nil {
+		errorCount++
+		log.Infof("error collecting trace profile: %v", traceErr)
+		os.Remove(traceFile.Name())
+	}
 
 	if errorCount > 0 {
 		return subcommands.ExitFailure