wip

Signed-off-by: Harsh Rawat <harshrawat@microsoft.com>

Author: rawahars

cmd/containerd-shim-lcow-v2/main.go

@@ -16,6 +16,7 @@ import (
 	"github.com/Microsoft/hcsshim/internal/log"
 	"github.com/Microsoft/hcsshim/internal/oc"
 	"github.com/Microsoft/hcsshim/internal/shim"
+	"github.com/Microsoft/hcsshim/osversion"
 
 	"github.com/containerd/errdefs"
 	"github.com/sirupsen/logrus"
@@ -42,6 +43,12 @@ func main() {
 		os.Exit(1)
 	}
 
+	// This shim is supported on Windows Build 26100 and later.
+	if osversion.Build() < osversion.V25H1Server {
+		_, _ = fmt.Fprintf(os.Stderr,
+			"%s: Windows version [%v] is not supported", service.ShimName, osversion.Build())
+	}
+
 	// Start the shim manager event loop. The manager is responsible for
 	// handling containerd start/stop lifecycle calls for the shim process.
 	shim.Run(context.Background(), newShimManager(service.ShimName), func(c *shim.Config) {

cmd/containerd-shim-lcow-v2/service/service.go

@@ -7,6 +7,7 @@ import (
 	"sync"
 
 	"github.com/Microsoft/hcsshim/internal/builder/vm/lcow"
+	"github.com/Microsoft/hcsshim/internal/controller/pod"
 	"github.com/Microsoft/hcsshim/internal/controller/vm"
 	"github.com/Microsoft/hcsshim/internal/log"
 	"github.com/Microsoft/hcsshim/internal/shim"
@@ -47,6 +48,14 @@ type Service struct {
 	// vmController is responsible for managing the lifecycle of the underlying utility VM and its associated resources.
 	vmController vm.Controller
 
+	// podControllers maps podID -> PodController for each active pod.
+	podControllers map[string]pod.Controller
+
+	// containerPodMapping maps containerID -> podID, allowing callers to look up
+	// which pod a container belongs to and then retrieve the corresponding controller
+	// from podControllers.
+	containerPodMapping map[string]string
+
 	// shutdown manages graceful shutdown operations and allows registration of cleanup callbacks.
 	shutdown shutdown.Service
 }
@@ -64,6 +73,8 @@ func NewService(ctx context.Context, eventsPublisher shim.Publisher, sd shutdown
 
 	go svc.forward(ctx, eventsPublisher)
 
+	// todo: kill and delete all running pods.
+
 	// Register a shutdown callback to close the events channel,
 	// which signals the forward goroutine to exit.
 	sd.RegisterCallback(func(context.Context) error {

cmd/containerd-shim-lcow-v2/service/service_shimdiag.go

@@ -72,14 +72,14 @@ func (s *Service) DiagShare(ctx context.Context, request *shimdiag.ShareRequest)
 
 // DiagStacks returns the stack traces of all goroutines in the shim.
 // This method is part of the instrumentation layer and business logic is included in diagStacksInternal.
-func (s *Service) DiagStacks(ctx context.Context, request *shimdiag.StacksRequest) (resp *shimdiag.StacksResponse, err error) {
+func (s *Service) DiagStacks(ctx context.Context, _ *shimdiag.StacksRequest) (resp *shimdiag.StacksResponse, err error) {
 	ctx, span := oc.StartSpan(ctx, "DiagStacks")
 	defer span.End()
 	defer func() { oc.SetSpanStatus(span, err) }()
 
 	span.AddAttributes(trace.StringAttribute(logfields.SandboxID, s.sandboxID))
 
-	r, e := s.diagStacksInternal(ctx, request)
+	r, e := s.diagStacksInternal(ctx)
 	return r, errgrpc.ToGRPC(e)
 }
 

cmd/containerd-shim-lcow-v2/service/service_shimdiag_internal.go

@@ -5,8 +5,12 @@ package service
 import (
 	"context"
 	"fmt"
+	"runtime"
+	"time"
 
+	"github.com/Microsoft/hcsshim/internal/controller/vm"
 	"github.com/Microsoft/hcsshim/internal/shimdiag"
+
 	"github.com/containerd/errdefs"
 )
 
@@ -22,14 +26,83 @@ func (s *Service) diagExecInHostInternal(ctx context.Context, request *shimdiag.
 	return &shimdiag.ExecProcessResponse{ExitCode: int32(ec)}, nil
 }
 
-func (s *Service) diagTasksInternal(_ context.Context, _ *shimdiag.TasksRequest) (*shimdiag.TasksResponse, error) {
-	return nil, errdefs.ErrNotImplemented
+func (s *Service) diagTasksInternal(ctx context.Context, request *shimdiag.TasksRequest) (*shimdiag.TasksResponse, error) {
+	if s.vmController.State() != vm.StateRunning {
+		return nil, fmt.Errorf("cannot list tasks when vm is not running: %w", errdefs.ErrFailedPrecondition)
+	}
+
+	// Originally this method was intended to be used in a single pod setup and therefore,
+	// we do not specify a TaskID in the request. Since our shim can support multiple pods,
+	// we will modify this functionality so that we will return all tasks running in the UVM,
+	// regardless of which pod they belong to.
+
+	resp := &shimdiag.TasksResponse{}
+
+	// todo: think about concurrency handling here.
+	// Do we want to lock for entire duration or not.
+	// This is a diagnostic method and therefore, should not have
+	// performance implications in prod.
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	for _, podCtrl := range s.podControllers {
+		containers, err := podCtrl.ListContainers()
+		if err != nil {
+			return nil, fmt.Errorf("failed to list containers: %w", err)
+		}
+
+		for containerID, ctrCtrl := range containers {
+			t := &shimdiag.Task{ID: containerID}
+
+			if request.Execs {
+				processes, err := ctrCtrl.ListProcesses()
+				if err != nil {
+					return nil, fmt.Errorf("failed to list processes for container %s: %w", containerID, err)
+				}
+
+				for _, proc := range processes {
+					status := proc.Status(false)
+					t.Execs = append(t.Execs, &shimdiag.Exec{
+						ID:    status.ExecID,
+						State: status.Status.String(),
+					})
+				}
+			}
+
+			resp.Tasks = append(resp.Tasks, t)
+		}
+	}
+
+	return resp, nil
 }
 
 func (s *Service) diagShareInternal(_ context.Context, _ *shimdiag.ShareRequest) (*shimdiag.ShareResponse, error) {
 	return nil, errdefs.ErrNotImplemented
 }
 
-func (s *Service) diagStacksInternal(_ context.Context, _ *shimdiag.StacksRequest) (*shimdiag.StacksResponse, error) {
-	return nil, errdefs.ErrNotImplemented
+func (s *Service) diagStacksInternal(ctx context.Context) (*shimdiag.StacksResponse, error) {
+	if s.vmController.State() != vm.StateRunning {
+		return nil, fmt.Errorf("cannot dump stacks when vm is not running: %w", errdefs.ErrFailedPrecondition)
+	}
+
+	buf := make([]byte, 4096)
+	for {
+		buf = buf[:runtime.Stack(buf, true)]
+		if len(buf) < cap(buf) {
+			break
+		}
+		buf = make([]byte, 2*len(buf))
+	}
+
+	timedCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
+	defer cancel()
+
+	resp := &shimdiag.StacksResponse{Stacks: string(buf)}
+	stacks, err := s.vmController.DumpStacks(timedCtx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to dump stacks: %w", err)
+	}
+
+	resp.GuestStacks = stacks
+	return resp, nil
 }

cmd/containerd-shim-lcow-v2/service/service_task.go

@@ -4,6 +4,7 @@ package service
 
 import (
 	"context"
+	"os"
 
 	"github.com/Microsoft/hcsshim/internal/logfields"
 	"github.com/Microsoft/hcsshim/internal/oc"
@@ -319,8 +320,13 @@ func (s *Service) Connect(ctx context.Context, request *task.ConnectRequest) (re
 		trace.StringAttribute(logfields.SandboxID, s.sandboxID),
 		trace.StringAttribute(logfields.ID, request.ID))
 
-	r, e := s.connectInternal(ctx, request)
-	return r, errgrpc.ToGRPC(e)
+	// We treat the shim/task as the same pid on the Windows host.
+	pid := uint32(os.Getpid())
+
+	return &task.ConnectResponse{
+		ShimPid: pid,
+		TaskPid: pid,
+	}, nil
 }
 
 // Shutdown gracefully shuts down the Service.