wip demo

client/allocrunner/taskrunner/task_runner.go

@@ -772,10 +772,12 @@ func (tr *TaskRunner) runDriver() error {
 
 	taskConfig := tr.buildTaskConfig()
 	if tr.cpusetCgroupPathGetter != nil {
+		fmt.Println("TaskRunner.runDriver, will wait for cpuset group")
 		cpusetCgroupPath, err := tr.cpusetCgroupPathGetter(tr.killCtx)
 		if err != nil {
 			return err
 		}
+		fmt.Println("TaskRunner.runDriver, got cpuset group:", cpusetCgroupPath)
 		taskConfig.Resources.LinuxResources.CpusetCgroupPath = cpusetCgroupPath
 	}
 

client/config/config.go

@@ -774,7 +774,7 @@ func DefaultConfig() *Config {
 		CNIConfigDir:       "/opt/cni/config",
 		CNIInterfacePrefix: "eth",
 		HostNetworks:       map[string]*structs.ClientHostNetworkConfig{},
-		CgroupParent:       cgutil.DefaultCgroupV1Parent,
+		CgroupParent:       cgutil.GetCgroupParent(""),
 		MaxDynamicPort:     structs.DefaultMinDynamicPort,
 		MinDynamicPort:     structs.DefaultMaxDynamicPort,
 	}

client/lib/cgutil/cgutil_linux.go

@@ -7,9 +7,20 @@ import (
 
 	"github.com/hashicorp/go-hclog"
 	"github.com/opencontainers/runc/libcontainer/cgroups"
+	lcc "github.com/opencontainers/runc/libcontainer/configs"
 	"golang.org/x/sys/unix"
 )
 
+// GetCgroupParent returns the mount point under the root cgroup in which Nomad
+// will create cgroups. If parent is not set, an appropriate name for the version
+// of cgroups will be used.
+func GetCgroupParent(parent string) string {
+	if cgroups.IsCgroup2UnifiedMode() {
+		return v2GetParent(parent)
+	}
+	return getParentV1(parent)
+}
+
 // CreateCPUSetManager creates a V1 or V2 CpusetManager depending on system configuration.
 func CreateCPUSetManager(parent string, logger hclog.Logger) CpusetManager {
 	if cgroups.IsCgroup2UnifiedMode() {
@@ -25,6 +36,37 @@ func GetCPUsFromCgroup(group string) ([]uint16, error) {
 	return getCPUsFromCgroupV1(getParentV1(group))
 }
 
+func CgroupID(allocID, task string) string {
+	if allocID == "" || task == "" {
+		panic("empty alloc or task")
+	}
+
+	if cgroups.IsCgroup2UnifiedMode() {
+		return fmt.Sprintf("%s.%s.scope", allocID, task)
+	}
+	return fmt.Sprintf("%s.%s", task, allocID)
+}
+
+func ConfigureBasicCgroups(cgroup string, config *lcc.Config) error {
+	if cgroups.IsCgroup2UnifiedMode() {
+		panic("do not call me for cgroups.v2")
+	}
+
+	// In V1 we must setup the freezer cgroup ourselves
+	subsystem := "freezer"
+	path, err := getCgroupPathHelper(subsystem, filepath.Join(DefaultCgroupV1Parent, cgroup))
+	if err != nil {
+		return fmt.Errorf("failed to find %s cgroup mountpoint: %v", subsystem, err)
+	}
+	if err = os.MkdirAll(path, 0755); err != nil {
+		return err
+	}
+	config.Cgroups.Paths = map[string]string{
+		subsystem: path,
+	}
+	return nil
+}
+
 func getCpusetSubsystemSettings(parent string) (cpus, mems string, err error) {
 	if cpus, err = cgroups.ReadFile(parent, "cpuset.cpus"); err != nil {
 		return
@@ -111,8 +153,10 @@ func getCgroupPathHelper(subsystem, cgroup string) (string, error) {
 		return "", err
 	}
 
-	fmt.Println("SH C")
-	return filepath.Join(mnt, relCgroup), nil
+	result := filepath.Join(mnt, relCgroup)
+
+	fmt.Println("SH getCgroupPathHelper", result)
+	return result, nil
 }
 
 // FindCgroupMountpointDir is used to find the cgroup mount point on a Linux

client/lib/cgutil/cpuset_manager.go

@@ -8,10 +8,10 @@ import (
 )
 
 // CpusetManager is used to setup cpuset cgroups for each task. A pool of shared cpus is managed for
-// tasks which don't require any reserved cores and a cgroup is managed secretly for each task which
+// allocToInfo which don't require any reserved cores and a cgroup is managed secretly for each task which
 // require reserved cores.
 type CpusetManager interface {
-	// Init should be called before any tasks are managed to ensure the cgroup parent exists and
+	// Init should be called before any allocToInfo are managed to ensure the cgroup parent exists and
 	// check that proper permissions are granted to manage cgroups.
 	Init() error
 
@@ -42,8 +42,10 @@ func (n NoopCpusetManager) CgroupPathFor(allocID, task string) CgroupPathGetter
 	return func(context.Context) (string, error) { return "", nil }
 }
 
-// CgroupPathGetter is a function which returns the cgroup path and any error which ocured during cgroup initialization.
-// It should block until the cgroup has been created or an error is reported
+// CgroupPathGetter is a function which returns the cgroup path and any error which
+// occurred during cgroup initialization.
+//
+// It should block until the cgroup has been created or an error is reported.
 type CgroupPathGetter func(context.Context) (path string, err error)
 
 type TaskCgroupInfo struct {

client/lib/cgutil/cpuset_manager_v2_linux.go

@@ -5,54 +5,68 @@ import (
 	"fmt"
 	"path/filepath"
 	"sync"
+	"time"
 
 	"github.com/hashicorp/go-hclog"
+	"github.com/hashicorp/nomad/helper"
 	"github.com/hashicorp/nomad/lib/cpuset"
 	"github.com/hashicorp/nomad/nomad/structs"
 	"github.com/opencontainers/runc/libcontainer/cgroups"
 	"github.com/opencontainers/runc/libcontainer/cgroups/fs2"
-	"github.com/opencontainers/runc/libcontainer/configs"
 )
 
 const (
+	// V2defaultCgroupParent is the name of Nomad's default parent cgroup, under which
+	// all other cgroups are managed. This can be changed with client configuration
+	// in case for e.g. Nomad tasks should be further constrained by an externally
+	// configured systemd cgroup.
 	V2defaultCgroupParent = "nomad.slice"
 
-	// v2CgroupRoot is hard-coded in the cgroups.v2 specification
+	// v2SharedCgroup is the name of Nomad's shared cgroup.
+	v2SharedCgroup = "shared.scope"
+
+	// v2ReservedCgroup is the name of Nomad's reserved cgroup.
+	//
+	// Tasks which reserve cores will have a cgroup created underneath.
+	v2ReservedCgroup = "reserved.slice"
+
+	// v2CgroupRoot is hard-coded in the cgroups.v2 specification.
 	v2CgroupRoot = "/sys/fs/cgroup"
 
-	// v2isRootless is (for now) always false; Nomad clients require root
+	// v2isRootless is (for now) always false; Nomad clients require root.
 	v2isRootless = false
 
-	// v2CreationPID is a special PID in libcontainer/cgroups used to denote a
-	// cgroup
+	// v2CreationPID is a special PID in libcontainer used to denote a cgroup
+	// should be created, but with no process added.
 	v2CreationPID = -1
 )
 
 func NewCpusetManagerV2(parent string, logger hclog.Logger) CpusetManager {
+	cgroupParent := v2GetParent(parent)
 	return &cpusetManagerV2{
-		ctx:    context.TODO(),
-		parent: v2GetParent(parent),
-		logger: logger,
+		ctx:       context.TODO(),
+		parent:    cgroupParent,
+		parentAbs: filepath.Join(v2CgroupRoot, cgroupParent),
+		logger:    logger,
+		tracker: &cgroupTracker{
+			allocToInfo: make(map[string]allocTaskCgroupInfo),
+		},
 	}
 }
 
 type cpusetManagerV2 struct {
-	ctx    context.Context
-	logger hclog.Logger
-	parent string
-	mgr    cgroups.Manager
-
-	lock        sync.Mutex
-	allocations map[string]allocTaskCgroupInfo
+	ctx       context.Context
+	logger    hclog.Logger
+	tracker   *cgroupTracker
+	parent    string // relative to cgroup root (e.g. "nomad.slice")
+	parentAbs string // absolute path (e.g. "/sys/fs/cgroup/nomad.slice")
 }
 
 func (c *cpusetManagerV2) Init() error {
-	fmt.Println("SH mgr V2 Iinit")
 	if err := c.initHierarchy(); err != nil {
 		c.logger.Error("failed to init cpuset manager", "err", err)
 		return err
 	}
-
 	return nil
 }
 
@@ -61,20 +75,95 @@ func (c *cpusetManagerV2) AddAlloc(alloc *structs.Allocation) {
 		return
 	}
 	c.logger.Trace("add allocation", "name", alloc.Name, "id", alloc.ID)
-	//for task, resources := range alloc.AllocatedResources.Tasks {
-	//	taskCpuset := cpuset.New(resources.Cpu.ReservedCores...)
-	//
-	//}
-	// alloc.Resources.Cores
 
+	info := make(allocTaskCgroupInfo)
+	for task, resources := range alloc.AllocatedResources.Tasks {
+		taskCpuset := cpuset.New(resources.Cpu.ReservedCores...)
+		// todo, uh what about all this
+		// absPath := filepath.Join(c.parentAbs, v2SharedCgroup)
+		// relPath := filepath.Join(c.parent, v2SharedCgroup)
+		// if !taskCpuset.Empty() {
+		//   absPath, relPath = c.pathsForTask(alloc.ID, task)
+		// }
+		id := CgroupID(alloc.ID, task)
+		absPath := filepath.Join(c.parentAbs, id)
+		relPath := filepath.Join(c.parent, id)
+		info[task] = &TaskCgroupInfo{
+			CgroupPath:         absPath,
+			RelativeCgroupPath: relPath,
+			Cpuset:             taskCpuset,
+		}
+	}
+
+	c.tracker.set(alloc.ID, info)
+
+	// todo: reconcile
+	c.reconcile()
+}
+
+func (c cpusetManagerV2) pathsForTask(allocID, task string) (string, string) {
+	name := fmt.Sprintf("%s-%s", allocID, task)
+	absPath := filepath.Join(c.parentAbs, v2ReservedCgroup, name)
+	relPath := filepath.Join(c.parent, v2ReservedCgroup, name)
+	return absPath, relPath
 }
 
 func (c *cpusetManagerV2) RemoveAlloc(allocID string) {
-	panic("implement me")
+	c.logger.Trace("remove allocation", "id", allocID)
+	c.tracker.delete(allocID)
 }
 
-func (c *cpusetManagerV2) CgroupPathFor(allocID, taskName string) CgroupPathGetter {
-	panic("implement me")
+func (c *cpusetManagerV2) CgroupPathFor(allocID, task string) CgroupPathGetter {
+	c.logger.Trace("cgroup path for", "id", allocID, "task", task)
+	fmt.Println("CPF want CgroupPathFor id:", allocID, "task", task)
+	return func(ctx context.Context) (string, error) {
+		ticker, cancel := helper.NewSafeTimer(100 * time.Millisecond)
+		defer cancel()
+
+		for {
+			taskInfo := c.tracker.get(allocID, task)
+			if taskInfo == nil {
+				fmt.Println("CPF task info is nil for id:", allocID, "task:", task)
+				return "", fmt.Errorf("cgroup not found for %s-%s", allocID, task)
+			}
+
+			if taskInfo.Error != nil {
+				fmt.Println("CPF task info error:", taskInfo.Error)
+				return taskInfo.CgroupPath, taskInfo.Error
+			}
+
+			mgr, err := fs2.NewManager(nil, taskInfo.CgroupPath, v2isRootless)
+			if err != nil {
+				fmt.Println("CPF new manager error:", err)
+				return "", err
+			}
+
+			if mgr.Exists() {
+				fmt.Println("CPF exists! id:", allocID, "task:", task, "path:", taskInfo.CgroupPath)
+				return taskInfo.CgroupPath, nil
+			}
+
+			select {
+			case <-ctx.Done():
+				fmt.Println("CPF context done, id:", allocID, "task:", task, "error:", ctx.Err())
+				return taskInfo.CgroupPath, ctx.Err()
+			case <-ticker.C:
+				continue
+			}
+		}
+	}
+}
+
+func (c *cpusetManagerV2) reconcile() {
+	c.tracker.walk(func(info *TaskCgroupInfo) {
+		mgr, err := fs2.NewManager(nil, info.CgroupPath, v2isRootless)
+		if err != nil {
+			panic(err)
+		}
+		if err = mgr.Apply(v2CreationPID); err != nil {
+			panic(err)
+		}
+	})
 }
 
 func (c *cpusetManagerV2) getParent() string {
@@ -82,22 +171,20 @@ func (c *cpusetManagerV2) getParent() string {
 }
 
 func (c *cpusetManagerV2) initHierarchy() error {
-	cfg := &configs.Cgroup{}
-
-	parent := c.getParent()
+	// Create parent cgroup
 
-	mgr, err := fs2.NewManager(cfg, parent, v2isRootless)
-	if err != nil {
-		return fmt.Errorf("failed to setup cgroup hierarchy: %w", err)
+	fmt.Println("SH create:", c.parentAbs)
+	parentMgr, parentErr := fs2.NewManager(nil, c.parentAbs, v2isRootless)
+	if parentErr != nil {
+		return parentErr
 	}
 
-	c.mgr = mgr
-
-	if err = c.mgr.Apply(v2CreationPID); err != nil {
-		return fmt.Errorf("failed to apply initial cgroup hierarchy: %w", err)
+	if applyParentErr := parentMgr.Apply(v2CreationPID); applyParentErr != nil {
+		return applyParentErr
 	}
+	fmt.Println("SH created parent")
 
-	c.logger.Debug("established cgroup hierarchy", "parent", parent)
+	c.logger.Debug("established initial cgroup hierarchy", "parent", c.getParent())
 	return nil
 }
 
@@ -107,24 +194,14 @@ func v2Root(group string) string {
 
 func v2GetCPUsFromCgroup(group string) ([]uint16, error) {
 	path := v2Root(group)
-
-	fmt.Println("SH v2GetCPUsFromCgroup, group:", group, "path:", path)
-
 	effective, err := cgroups.ReadFile(path, "cpuset.cpus.effective")
 	if err != nil {
-		fmt.Println("A err:", err)
 		return nil, err
 	}
-
-	fmt.Println("B effective:", effective)
 	set, err := cpuset.Parse(effective)
 	if err != nil {
-		fmt.Println("C: parse:", err)
 		return nil, err
 	}
-
-	fmt.Println("D: set:", set)
-
 	return set.ToSlice(), nil
 }
 
@@ -134,3 +211,54 @@ func v2GetParent(parent string) string {
 	}
 	return parent
 }
+
+type cgroupTracker struct {
+	lock        sync.RWMutex
+	allocToInfo map[string]allocTaskCgroupInfo
+}
+
+func (cm *cgroupTracker) set(allocID string, info allocTaskCgroupInfo) {
+	cm.lock.Lock()
+	defer cm.lock.Unlock()
+
+	cm.allocToInfo[allocID] = info
+}
+
+func (cm *cgroupTracker) delete(allocID string) {
+	cm.lock.Lock()
+	defer cm.lock.Unlock()
+
+	delete(cm.allocToInfo, allocID)
+}
+
+func (cm *cgroupTracker) get(allocID, task string) *TaskCgroupInfo {
+	cm.lock.RLock()
+	defer cm.lock.RUnlock()
+
+	allocInfo, allocExists := cm.allocToInfo[allocID]
+	if !allocExists {
+		return nil
+	}
+	taskInfo, taskExists := allocInfo[task]
+	if !taskExists {
+		return nil
+	}
+	return &TaskCgroupInfo{
+		CgroupPath:         taskInfo.CgroupPath,
+		RelativeCgroupPath: taskInfo.RelativeCgroupPath,
+		Cpuset:             taskInfo.Cpuset.Copy(),
+		Error:              taskInfo.Error,
+	}
+}
+
+func (cm *cgroupTracker) walk(f func(info *TaskCgroupInfo)) {
+	cm.lock.RLock()
+	defer cm.lock.RUnlock()
+
+	for alloc, taskInfo := range cm.allocToInfo {
+		for task, info := range taskInfo {
+			fmt.Println("walk, alloc:", alloc, "task:", task, "path:", info.CgroupPath)
+			f(info)
+		}
+	}
+}

command/agent/agent.go

@@ -894,6 +894,9 @@ func (a *Agent) setupClient() error {
 		return fmt.Errorf("client setup failed: %v", err)
 	}
 
+	// todo remove
+	fmt.Println("SH client.conf reservable_cores:", conf.ReservableCores)
+
 	// Reserve some ports for the plugins if we are on Windows
 	if runtime.GOOS == "windows" {
 		if err := a.reservePortsForClient(conf); err != nil {

drivers/exec/driver.go

@@ -359,6 +359,8 @@ func (d *Driver) buildFingerprint() *drivers.Fingerprint {
 		return fp
 	}
 
+	fmt.Println("SH exec mount:", mount)
+
 	if mount == "" {
 		fp.Health = drivers.HealthStateUnhealthy
 		fp.HealthDescription = drivers.CgroupMountEmpty
@@ -498,8 +500,12 @@ func (d *Driver) StartTask(cfg *drivers.TaskConfig) (*drivers.TaskHandle, *drive
 		ModePID:          executor.IsolationMode(d.config.DefaultModePID, driverConfig.ModePID),
 		ModeIPC:          executor.IsolationMode(d.config.DefaultModeIPC, driverConfig.ModeIPC),
 		Capabilities:     caps,
+		AllocID:          cfg.AllocID,
+		Task:             cfg.Name,
 	}
 
+	fmt.Println("SH driver.StartTask, exec:", execCmd.Cmd)
+
 	ps, err := exec.Launch(execCmd)
 	if err != nil {
 		pluginClient.Kill()

drivers/shared/executor/executor.go

@@ -154,6 +154,12 @@ type ExecCommand struct {
 
 	// Capabilities are the linux capabilities to be enabled by the task driver.
 	Capabilities []string
+
+	// AllocID the allocation ID for which this command is being executed.
+	AllocID string
+
+	// Task the task name for which this command is being executed.
+	Task string
 }
 
 // SetWriters sets the writer for the process stdout and stderr. This should
@@ -302,7 +308,10 @@ func (e *UniversalExecutor) Launch(command *ExecCommand) (*ProcessState, error)
 
 	// Setup cgroups on linux
 	if e.commandCfg.ResourceLimits || e.commandCfg.BasicProcessCgroup {
-		if err := e.configureResourceContainer(os.Getpid()); err != nil {
+		pid := os.Getpid()
+		allocID := command.AllocID
+		taskName := command.Task
+		if err := e.configureResourceContainer(pid, allocID, taskName); err != nil {
 			return nil, err
 		}
 	}

drivers/shared/executor/executor_linux.go

@@ -19,6 +19,7 @@ import (
 	"github.com/hashicorp/consul-template/signals"
 	hclog "github.com/hashicorp/go-hclog"
 	"github.com/hashicorp/nomad/client/allocdir"
+	"github.com/hashicorp/nomad/client/lib/cgutil"
 	"github.com/hashicorp/nomad/client/stats"
 	cstructs "github.com/hashicorp/nomad/client/structs"
 	"github.com/hashicorp/nomad/drivers/shared/capabilities"
@@ -68,9 +69,20 @@ type LibcontainerExecutor struct {
 	userProc       *libcontainer.Process
 	userProcExited chan interface{}
 	exitState      *ProcessState
+
+	debug *os.File
 }
 
 func NewExecutorWithIsolation(logger hclog.Logger) Executor {
+	debug, err := os.OpenFile("/tmp/debug.log", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0655)
+	if err != nil {
+		panic(err)
+	}
+
+	dlog := hclog.New(&hclog.LoggerOptions{
+		Output: debug,
+		Name:   "exec",
+	})
 
 	logger = logger.Named("isolated_executor")
 	if err := shelpers.Init(); err != nil {
@@ -78,15 +90,20 @@ func NewExecutorWithIsolation(logger hclog.Logger) Executor {
 	}
 	return &LibcontainerExecutor{
 		id:             strings.ReplaceAll(uuid.Generate(), "-", "_"),
-		logger:         logger,
+		logger:         dlog,
 		totalCpuStats:  stats.NewCpuStats(),
 		userCpuStats:   stats.NewCpuStats(),
 		systemCpuStats: stats.NewCpuStats(),
 		pidCollector:   newPidCollector(logger),
+
+		debug: debug,
 	}
 }
 
 // Launch creates a new container in libcontainer and starts a new process with it
+//
+// BTW, logging and printing does nothing here, this is being running in a sub-process.
+// For debugging, try writing to a file.
 func (l *LibcontainerExecutor) Launch(command *ExecCommand) (*ProcessState, error) {
 	l.logger.Trace("preparing to launch command", "command", command.Cmd, "args", strings.Join(command.Args, " "))
 
@@ -111,6 +128,9 @@ func (l *LibcontainerExecutor) Launch(command *ExecCommand) (*ProcessState, erro
 		return nil, fmt.Errorf("failed to create factory: %v", err)
 	}
 
+	// FIND THIS
+	l.logger.Info("LibcontainerExecutor.Launch", "cmd", command.Cmd, "alloc_id", command.AllocID, "task", command.Task)
+
 	// A container groups processes under the same isolation enforcement
 	containerCfg, err := newLibcontainerConfig(command)
 	if err != nil {
@@ -271,6 +291,10 @@ func (l *LibcontainerExecutor) wait() {
 // Shutdown stops all processes started and cleans up any resources
 // created (such as mountpoints, devices, etc).
 func (l *LibcontainerExecutor) Shutdown(signal string, grace time.Duration) error {
+	l.logger.Info("shutdown")
+	_ = l.debug.Sync()
+	_ = l.debug.Close()
+
 	if l.container == nil {
 		return nil
 	}
@@ -665,14 +689,30 @@ func configureIsolation(cfg *lconfigs.Config, command *ExecCommand) error {
 }
 
 func configureCgroups(cfg *lconfigs.Config, command *ExecCommand) error {
+	f, err := os.OpenFile("/tmp/cc.log", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
+	if err != nil {
+		panic(err)
+	}
+	defer func() {
+		_ = f.Sync()
+		_ = f.Close()
+	}()
+
+	logger := hclog.New(&hclog.LoggerOptions{
+		Output: f,
+	})
+
+	id := cgutil.CgroupID(command.AllocID, command.Task)
+	logger.Info("configureCgroups", "id", id)
 
 	// If resources are not limited then manually create cgroups needed
 	if !command.ResourceLimits {
-		return configureBasicCgroups(cfg)
+		return cgutil.ConfigureBasicCgroups(id, cfg)
 	}
 
-	id := uuid.Generate()
-	cfg.Cgroups.Path = filepath.Join("/", defaultCgroupParent, id)
+	cfg.Cgroups.Path = filepath.Join("/", cgutil.GetCgroupParent(cfg.Cgroups.Parent), id)
+
+	fmt.Println("SH has cmd resource limits, not basic, id:", id, "cgroups.path:", cfg.Cgroups.Path)
 
 	if command.Resources == nil || command.Resources.NomadResources == nil {
 		return nil
@@ -715,28 +755,6 @@ func configureCgroups(cfg *lconfigs.Config, command *ExecCommand) error {
 	return nil
 }
 
-func configureBasicCgroups(cfg *lconfigs.Config) error {
-	id := uuid.Generate()
-
-	// Manually create freezer cgroup
-
-	subsystem := "freezer"
-
-	path, err := getCgroupPathHelper(subsystem, filepath.Join(defaultCgroupParent, id))
-	if err != nil {
-		return fmt.Errorf("failed to find %s cgroup mountpoint: %v", subsystem, err)
-	}
-
-	if err = os.MkdirAll(path, 0755); err != nil {
-		return err
-	}
-
-	cfg.Cgroups.Paths = map[string]string{
-		subsystem: path,
-	}
-	return nil
-}
-
 func getCgroupPathHelper(subsystem, cgroup string) (string, error) {
 	mnt, root, err := cgroups.FindCgroupMountpointAndRoot("", subsystem)
 	if err != nil {
@@ -888,6 +906,7 @@ func lookPathIn(path string, root string, bin string) (string, error) {
 }
 
 func newSetCPUSetCgroupHook(cgroupPath string) lconfigs.Hook {
+	fmt.Println("SH newSetCPUSetCgroupHook, cgroupPath:", cgroupPath)
 	return lconfigs.NewFunctionHook(func(state *specs.State) error {
 		return cgroups.WriteCgroupProc(cgroupPath, state.Pid)
 	})

drivers/shared/executor/executor_universal_linux.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/containernetworking/plugins/pkg/ns"
 	multierror "github.com/hashicorp/go-multierror"
+	"github.com/hashicorp/nomad/client/lib/cgutil"
 	"github.com/hashicorp/nomad/plugins/drivers"
 	"github.com/opencontainers/runc/libcontainer/cgroups"
 	cgroupFs "github.com/opencontainers/runc/libcontainer/cgroups/fs"
@@ -67,7 +68,7 @@ func setCmdUser(cmd *exec.Cmd, userid string) error {
 
 // configureResourceContainer configured the cgroups to be used to track pids
 // created by the executor
-func (e *UniversalExecutor) configureResourceContainer(pid int) error {
+func (e *UniversalExecutor) configureResourceContainer(pid int, allocID, task string) error {
 	cfg := &lconfigs.Config{
 		Cgroups: &lconfigs.Cgroup{
 			Resources: &lconfigs.Resources{},
@@ -77,8 +78,9 @@ func (e *UniversalExecutor) configureResourceContainer(pid int) error {
 		cfg.Cgroups.Resources.Devices = append(cfg.Cgroups.Resources.Devices, &device.Rule)
 	}
 
-	err := configureBasicCgroups(cfg)
-	if err != nil {
+	// need allocID and task name
+	cgroupID := cgutil.CgroupID(allocID, task)
+	if err := cgutil.ConfigureBasicCgroups(cgroupID, cfg); err != nil {
 		// Log this error to help diagnose cases where nomad is run with too few
 		// permissions, but don't return an error. There is no separate check for
 		// cgroup creation permissions, so this may be the happy path.

drivers/shared/executor/client.go → drivers/shared/executor/grpc_client.go

@@ -31,6 +31,7 @@ type grpcExecutorClient struct {
 }
 
 func (c *grpcExecutorClient) Launch(cmd *ExecCommand) (*ProcessState, error) {
+	fmt.Println("SH grpc.Launch cmd:", cmd.Cmd, "id:", cmd.AllocID, "task:", cmd.Task)
 	ctx := context.Background()
 	req := &proto.LaunchRequest{
 		Cmd:                cmd.Cmd,
@@ -50,6 +51,8 @@ func (c *grpcExecutorClient) Launch(cmd *ExecCommand) (*ProcessState, error) {
 		DefaultPidMode:     cmd.ModePID,
 		DefaultIpcMode:     cmd.ModeIPC,
 		Capabilities:       cmd.Capabilities,
+		AllocId:            cmd.AllocID,
+		TaskName:           cmd.Task,
 	}
 	resp, err := c.client.Launch(ctx, req)
 	if err != nil {

drivers/shared/executor/server.go → drivers/shared/executor/grpc_server.go

@@ -20,6 +20,7 @@ type grpcExecutorServer struct {
 }
 
 func (s *grpcExecutorServer) Launch(ctx context.Context, req *proto.LaunchRequest) (*proto.LaunchResponse, error) {
+	fmt.Println("grpc.Launch, id:", req.AllocId, "task:", req.TaskName)
 	ps, err := s.impl.Launch(&ExecCommand{
 		Cmd:                req.Cmd,
 		Args:               req.Args,
@@ -38,6 +39,8 @@ func (s *grpcExecutorServer) Launch(ctx context.Context, req *proto.LaunchReques
 		ModePID:            req.DefaultPidMode,
 		ModeIPC:            req.DefaultIpcMode,
 		Capabilities:       req.Capabilities,
+		AllocID:            req.AllocId,
+		Task:               req.TaskName,
 	})
 
 	if err != nil {

drivers/shared/executor/proto/executor.pb.go

@@ -46,6 +46,8 @@ type LaunchRequest struct {
 	CpusetCgroup         string                       `protobuf:"bytes,17,opt,name=cpuset_cgroup,json=cpusetCgroup,proto3" json:"cpuset_cgroup,omitempty"`
 	AllowCaps            []string                     `protobuf:"bytes,18,rep,name=allow_caps,json=allowCaps,proto3" json:"allow_caps,omitempty"`
 	Capabilities         []string                     `protobuf:"bytes,19,rep,name=capabilities,proto3" json:"capabilities,omitempty"`
+	AllocId              string                       `protobuf:"bytes,20,opt,name=alloc_id,json=allocId,proto3" json:"alloc_id,omitempty"`
+	TaskName             string                       `protobuf:"bytes,21,opt,name=task_name,json=taskName,proto3" json:"task_name,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
 	XXX_unrecognized     []byte                       `json:"-"`
 	XXX_sizecache        int32                        `json:"-"`
@@ -209,6 +211,20 @@ func (m *LaunchRequest) GetCapabilities() []string {
 	return nil
 }
 
+func (m *LaunchRequest) GetAllocId() string {
+	if m != nil {
+		return m.AllocId
+	}
+	return ""
+}
+
+func (m *LaunchRequest) GetTaskName() string {
+	if m != nil {
+		return m.TaskName
+	}
+	return ""
+}
+
 type LaunchResponse struct {
 	Process              *ProcessState `protobuf:"bytes,1,opt,name=process,proto3" json:"process,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
@@ -874,74 +890,75 @@ func init() {
 }
 
 var fileDescriptor_66b85426380683f3 = []byte{
-	// 1058 bytes of a gzipped FileDescriptorProto
+	// 1088 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0x6d, 0x6f, 0x1b, 0x45,
-	0x10, 0xee, 0xc5, 0x89, 0x5f, 0xc6, 0x76, 0xe2, 0x2e, 0xa8, 0x5c, 0x8d, 0x50, 0xcd, 0x21, 0x51,
-	0x0b, 0xca, 0x25, 0x4a, 0xdf, 0x90, 0x90, 0x28, 0x22, 0x2d, 0xa8, 0x52, 0x1a, 0x45, 0x97, 0x42,
+	0x10, 0xee, 0xc5, 0x89, 0x5f, 0xc6, 0x76, 0xe2, 0x2e, 0x25, 0x5c, 0x8d, 0x50, 0xcd, 0x21, 0x51,
+	0x0b, 0xca, 0x25, 0x4a, 0xdf, 0x90, 0x90, 0x28, 0x22, 0x29, 0x28, 0x52, 0x1a, 0x45, 0x97, 0x42,
 	0x25, 0x3e, 0x70, 0x6c, 0xee, 0xb6, 0xf6, 0x2a, 0xf6, 0xed, 0xb2, 0xbb, 0xe7, 0x04, 0x09, 0x89,
-	0x4f, 0xfc, 0x03, 0x90, 0xf8, 0x31, 0xfc, 0x38, 0xb4, 0x6f, 0x17, 0x3b, 0x2d, 0xd5, 0xb9, 0x88,
-	0x4f, 0xbe, 0x1d, 0x3f, 0xcf, 0xcc, 0xec, 0xce, 0xcc, 0x33, 0x70, 0x27, 0x17, 0x74, 0x41, 0x84,
-	0xdc, 0x95, 0x53, 0x2c, 0x48, 0xbe, 0x4b, 0x2e, 0x48, 0x56, 0x2a, 0x26, 0x76, 0xb9, 0x60, 0x8a,
-	0x55, 0xc7, 0xd8, 0x1c, 0xd1, 0xc7, 0x53, 0x2c, 0xa7, 0x34, 0x63, 0x82, 0xc7, 0x05, 0x9b, 0xe3,
-	0x3c, 0xe6, 0xb3, 0x72, 0x42, 0x0b, 0x19, 0xaf, 0xe2, 0x86, 0xb7, 0x26, 0x8c, 0x4d, 0x66, 0xc4,
-	0x3a, 0x39, 0x2d, 0x5f, 0xee, 0x2a, 0x3a, 0x27, 0x52, 0xe1, 0x39, 0x77, 0x80, 0xc8, 0x11, 0x77,
-	0x7d, 0x78, 0x1b, 0xce, 0x9e, 0x2c, 0x26, 0xfa, 0xbb, 0x09, 0xfd, 0x43, 0x5c, 0x16, 0xd9, 0x34,
-	0x21, 0x3f, 0x97, 0x44, 0x2a, 0x34, 0x80, 0x46, 0x36, 0xcf, 0xc3, 0x60, 0x14, 0x8c, 0x3b, 0x89,
-	0xfe, 0x44, 0x08, 0x36, 0xb1, 0x98, 0xc8, 0x70, 0x63, 0xd4, 0x18, 0x77, 0x12, 0xf3, 0x8d, 0x8e,
-	0xa0, 0x23, 0x88, 0x64, 0xa5, 0xc8, 0x88, 0x0c, 0x1b, 0xa3, 0x60, 0xdc, 0xdd, 0xdf, 0x8b, 0xff,
-	0x2d, 0x71, 0x17, 0xdf, 0x86, 0x8c, 0x13, 0xcf, 0x4b, 0x2e, 0x5d, 0xa0, 0x5b, 0xd0, 0x95, 0x2a,
-	0x67, 0xa5, 0x4a, 0x39, 0x56, 0xd3, 0x70, 0xd3, 0x44, 0x07, 0x6b, 0x3a, 0xc6, 0x6a, 0xea, 0x00,
-	0x44, 0x08, 0x0b, 0xd8, 0xaa, 0x00, 0x44, 0x08, 0x03, 0x18, 0x40, 0x83, 0x14, 0x8b, 0xb0, 0x69,
-	0x92, 0xd4, 0x9f, 0x3a, 0xef, 0x52, 0x12, 0x11, 0xb6, 0x0c, 0xd6, 0x7c, 0xa3, 0x9b, 0xd0, 0x56,
-	0x58, 0x9e, 0xa5, 0x39, 0x15, 0x61, 0xdb, 0xd8, 0x5b, 0xfa, 0xfc, 0x98, 0x0a, 0x74, 0x1b, 0x76,
-	0x7c, 0x3e, 0xe9, 0x8c, 0xce, 0xa9, 0x92, 0x61, 0x67, 0x14, 0x8c, 0xdb, 0xc9, 0xb6, 0x37, 0x1f,
-	0x1a, 0x2b, 0xda, 0x83, 0x77, 0x4f, 0xb1, 0xa4, 0x59, 0xca, 0x05, 0xcb, 0x88, 0x94, 0x69, 0x36,
-	0x11, 0xac, 0xe4, 0x21, 0x18, 0x34, 0x32, 0xff, 0x1d, 0xdb, 0xbf, 0x0e, 0xcc, 0x3f, 0xe8, 0x31,
-	0x34, 0xe7, 0xac, 0x2c, 0x94, 0x0c, 0xbb, 0xa3, 0xc6, 0xb8, 0xbb, 0x7f, 0xa7, 0xe6, 0x53, 0x3d,
-	0xd3, 0xa4, 0xc4, 0x71, 0xd1, 0xb7, 0xd0, 0xca, 0xc9, 0x82, 0xea, 0x17, 0xef, 0x19, 0x37, 0x9f,
-	0xd5, 0x74, 0xf3, 0xd8, 0xb0, 0x12, 0xcf, 0x46, 0x53, 0xb8, 0x5e, 0x10, 0x75, 0xce, 0xc4, 0x59,
-	0x4a, 0x25, 0x9b, 0x61, 0x45, 0x59, 0x11, 0xf6, 0x4d, 0x11, 0xbf, 0xa8, 0xe9, 0xf2, 0xc8, 0xf2,
-	0x9f, 0x7a, 0xfa, 0x09, 0x27, 0x59, 0x32, 0x28, 0xae, 0x58, 0x51, 0x04, 0xfd, 0x82, 0xa5, 0x9c,
-	0x2e, 0x98, 0x4a, 0x05, 0x63, 0x2a, 0xdc, 0x36, 0x6f, 0xd4, 0x2d, 0xd8, 0xb1, 0xb6, 0x25, 0x8c,
-	0x29, 0x34, 0x86, 0x41, 0x4e, 0x5e, 0xe2, 0x72, 0xa6, 0x52, 0x4e, 0xf3, 0x74, 0xce, 0x72, 0x12,
-	0xee, 0x98, 0xd2, 0x6c, 0x3b, 0xfb, 0x31, 0xcd, 0x9f, 0xb1, 0x9c, 0x2c, 0x23, 0x29, 0xcf, 0x2c,
-	0x72, 0xb0, 0x82, 0x7c, 0xca, 0x33, 0x83, 0xfc, 0x08, 0xfa, 0x19, 0x2f, 0x25, 0x51, 0xbe, 0x36,
-	0xd7, 0x0d, 0xac, 0x67, 0x8d, 0xae, 0x2a, 0x1f, 0x00, 0xe0, 0xd9, 0x8c, 0x9d, 0xa7, 0x19, 0xe6,
-	0x32, 0x44, 0xa6, 0x71, 0x3a, 0xc6, 0x72, 0x80, 0xb9, 0x44, 0x11, 0xf4, 0x32, 0xcc, 0xf1, 0x29,
-	0x9d, 0x51, 0x45, 0x89, 0x0c, 0xdf, 0x31, 0x80, 0x15, 0x5b, 0xf4, 0x13, 0x6c, 0xfb, 0xe9, 0x91,
-	0x9c, 0x15, 0x92, 0xa0, 0x23, 0x68, 0xb9, 0xb6, 0x30, 0x23, 0xd4, 0xdd, 0xbf, 0x17, 0xd7, 0x9b,
-	0xe7, 0xd8, 0xb5, 0xcc, 0x89, 0xc2, 0x8a, 0x24, 0xde, 0x49, 0xd4, 0x87, 0xee, 0x0b, 0x4c, 0x95,
-	0x9b, 0xce, 0xe8, 0x47, 0xe8, 0xd9, 0xe3, 0xff, 0x14, 0xee, 0x10, 0x76, 0x4e, 0xa6, 0xa5, 0xca,
-	0xd9, 0x79, 0xe1, 0x05, 0xe1, 0x06, 0x34, 0x25, 0x9d, 0x14, 0x78, 0xe6, 0x34, 0xc1, 0x9d, 0xd0,
-	0x87, 0xd0, 0x9b, 0x08, 0x9c, 0x91, 0x94, 0x13, 0x41, 0x59, 0x1e, 0x6e, 0x8c, 0x82, 0x71, 0x23,
-	0xe9, 0x1a, 0xdb, 0xb1, 0x31, 0x45, 0x08, 0x06, 0x97, 0xde, 0x6c, 0xc6, 0xd1, 0x14, 0x6e, 0x7c,
-	0xc7, 0x73, 0x1d, 0xb4, 0xd2, 0x01, 0x17, 0x68, 0x45, 0x53, 0x82, 0xff, 0xac, 0x29, 0xd1, 0x4d,
-	0x78, 0xef, 0x95, 0x48, 0x2e, 0x89, 0x01, 0x6c, 0x7f, 0x4f, 0x84, 0xa4, 0xcc, 0xdf, 0x32, 0xfa,
-	0x14, 0x76, 0x2a, 0x8b, 0x7b, 0xdb, 0x10, 0x5a, 0x0b, 0x6b, 0x72, 0x37, 0xf7, 0xc7, 0xe8, 0x13,
-	0xe8, 0xe9, 0x77, 0xab, 0x32, 0x1f, 0x42, 0x9b, 0x16, 0x8a, 0x88, 0x85, 0x7b, 0xa4, 0x46, 0x52,
-	0x9d, 0xa3, 0x17, 0xd0, 0x77, 0x58, 0xe7, 0xf6, 0x1b, 0xd8, 0x92, 0xda, 0xb0, 0xe6, 0x15, 0x9f,
-	0x63, 0x79, 0x66, 0x1d, 0x59, 0x7a, 0x74, 0x1b, 0xfa, 0x27, 0xa6, 0x12, 0xaf, 0x2f, 0xd4, 0x96,
-	0x2f, 0x94, 0xbe, 0xac, 0x07, 0xba, 0xeb, 0x9f, 0x41, 0xf7, 0xc9, 0x05, 0xc9, 0x3c, 0xf1, 0x01,
-	0xb4, 0x73, 0x82, 0xf3, 0x19, 0x2d, 0x88, 0x4b, 0x6a, 0x18, 0xdb, 0xe5, 0x12, 0xfb, 0xe5, 0x12,
-	0x3f, 0xf7, 0xcb, 0x25, 0xa9, 0xb0, 0x7e, 0x55, 0x6c, 0xbc, 0xba, 0x2a, 0x1a, 0x97, 0xab, 0x22,
-	0x3a, 0x80, 0x9e, 0x0d, 0xe6, 0xee, 0x7f, 0x03, 0x9a, 0xac, 0x54, 0xbc, 0x54, 0x26, 0x56, 0x2f,
-	0x71, 0x27, 0xf4, 0x3e, 0x74, 0xc8, 0x05, 0x55, 0x69, 0xa6, 0xc7, 0x7a, 0xc3, 0xdc, 0xa0, 0xad,
-	0x0d, 0x07, 0x2c, 0x27, 0xd1, 0xef, 0x01, 0xf4, 0x96, 0x3b, 0x56, 0xc7, 0xe6, 0x34, 0x77, 0x37,
-	0xd5, 0x9f, 0x6f, 0xe4, 0x2f, 0xbd, 0x4d, 0x63, 0xf9, 0x6d, 0x50, 0x0c, 0x9b, 0x7a, 0x6d, 0x9a,
-	0x85, 0xf3, 0xe6, 0x6b, 0x1b, 0xdc, 0xfe, 0x9f, 0x1d, 0x68, 0x3f, 0x71, 0x83, 0x84, 0x7e, 0x81,
-	0xa6, 0x9d, 0x7e, 0x74, 0xbf, 0xee, 0xd4, 0xad, 0xec, 0xda, 0xe1, 0x83, 0x75, 0x69, 0xae, 0x7e,
-	0xd7, 0x90, 0x84, 0x4d, 0xad, 0x03, 0xe8, 0x6e, 0x5d, 0x0f, 0x4b, 0x22, 0x32, 0xbc, 0xb7, 0x1e,
-	0xa9, 0x0a, 0xfa, 0x1b, 0xb4, 0xfd, 0x38, 0xa3, 0x87, 0x75, 0x7d, 0x5c, 0x91, 0x93, 0xe1, 0xe7,
-	0xeb, 0x13, 0xab, 0x04, 0xfe, 0x08, 0x60, 0xe7, 0xca, 0x48, 0xa3, 0x2f, 0xeb, 0xfa, 0x7b, 0xbd,
-	0xea, 0x0c, 0x1f, 0xbd, 0x35, 0xbf, 0x4a, 0xeb, 0x57, 0x68, 0x39, 0xed, 0x40, 0xb5, 0x2b, 0xba,
-	0x2a, 0x3f, 0xc3, 0x87, 0x6b, 0xf3, 0xaa, 0xe8, 0x17, 0xb0, 0x65, 0x74, 0x01, 0xd5, 0x2e, 0xeb,
-	0xb2, 0x76, 0x0d, 0xef, 0xaf, 0xc9, 0xf2, 0x71, 0xf7, 0x02, 0xdd, 0xff, 0x56, 0x58, 0xea, 0xf7,
-	0xff, 0x8a, 0x62, 0xd5, 0xef, 0xff, 0x2b, 0xfa, 0x65, 0xfa, 0x5f, 0x8f, 0x61, 0xfd, 0xfe, 0x5f,
-	0xd2, 0xbb, 0xfa, 0xfd, 0xbf, 0xac, 0x5b, 0xd1, 0x35, 0xf4, 0x57, 0x00, 0x7d, 0x6d, 0x3a, 0x51,
-	0x82, 0xe0, 0x39, 0x2d, 0x26, 0xe8, 0x51, 0x4d, 0xf1, 0xd6, 0x2c, 0x2b, 0xe0, 0x8e, 0xe9, 0x53,
-	0xf9, 0xea, 0xed, 0x1d, 0xf8, 0xb4, 0xc6, 0xc1, 0x5e, 0xf0, 0x75, 0xeb, 0x87, 0x2d, 0xab, 0x59,
-	0x4d, 0xf3, 0x73, 0xf7, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x2e, 0x63, 0xc4, 0xd3, 0x74, 0x0c,
-	0x00, 0x00,
+	0x4f, 0xfc, 0x03, 0x90, 0xf8, 0xa1, 0xfc, 0x00, 0xb4, 0x6f, 0x8e, 0x9d, 0x96, 0xea, 0x5c, 0xc4,
+	0x27, 0xdf, 0x8c, 0x9f, 0x67, 0x66, 0x76, 0x67, 0xe6, 0x59, 0xb8, 0x97, 0x0b, 0x3a, 0x23, 0x42,
+	0xee, 0xc8, 0x31, 0x16, 0x24, 0xdf, 0x21, 0x97, 0x24, 0x2b, 0x15, 0x13, 0x3b, 0x5c, 0x30, 0xc5,
+	0xe6, 0x66, 0x6c, 0x4c, 0xf4, 0xf1, 0x18, 0xcb, 0x31, 0xcd, 0x98, 0xe0, 0x71, 0xc1, 0xa6, 0x38,
+	0x8f, 0xf9, 0xa4, 0x1c, 0xd1, 0x42, 0xc6, 0xcb, 0xb8, 0xfe, 0x9d, 0x11, 0x63, 0xa3, 0x09, 0xb1,
+	0x41, 0xce, 0xca, 0x97, 0x3b, 0x8a, 0x4e, 0x89, 0x54, 0x78, 0xca, 0x1d, 0x20, 0x72, 0xc4, 0x1d,
+	0x9f, 0xde, 0xa6, 0xb3, 0x96, 0xc5, 0x44, 0x7f, 0xd7, 0xa1, 0x7b, 0x84, 0xcb, 0x22, 0x1b, 0x27,
+	0xe4, 0xe7, 0x92, 0x48, 0x85, 0x7a, 0x50, 0xcb, 0xa6, 0x79, 0x18, 0x0c, 0x82, 0x61, 0x2b, 0xd1,
+	0x9f, 0x08, 0xc1, 0x3a, 0x16, 0x23, 0x19, 0xae, 0x0d, 0x6a, 0xc3, 0x56, 0x62, 0xbe, 0xd1, 0x31,
+	0xb4, 0x04, 0x91, 0xac, 0x14, 0x19, 0x91, 0x61, 0x6d, 0x10, 0x0c, 0xdb, 0x7b, 0xbb, 0xf1, 0xbf,
+	0x15, 0xee, 0xf2, 0xdb, 0x94, 0x71, 0xe2, 0x79, 0xc9, 0x55, 0x08, 0x74, 0x07, 0xda, 0x52, 0xe5,
+	0xac, 0x54, 0x29, 0xc7, 0x6a, 0x1c, 0xae, 0x9b, 0xec, 0x60, 0x5d, 0x27, 0x58, 0x8d, 0x1d, 0x80,
+	0x08, 0x61, 0x01, 0x1b, 0x73, 0x00, 0x11, 0xc2, 0x00, 0x7a, 0x50, 0x23, 0xc5, 0x2c, 0xac, 0x9b,
+	0x22, 0xf5, 0xa7, 0xae, 0xbb, 0x94, 0x44, 0x84, 0x0d, 0x83, 0x35, 0xdf, 0xe8, 0x36, 0x34, 0x15,
+	0x96, 0xe7, 0x69, 0x4e, 0x45, 0xd8, 0x34, 0xfe, 0x86, 0xb6, 0x0f, 0xa8, 0x40, 0x77, 0x61, 0xcb,
+	0xd7, 0x93, 0x4e, 0xe8, 0x94, 0x2a, 0x19, 0xb6, 0x06, 0xc1, 0xb0, 0x99, 0x6c, 0x7a, 0xf7, 0x91,
+	0xf1, 0xa2, 0x5d, 0xb8, 0x75, 0x86, 0x25, 0xcd, 0x52, 0x2e, 0x58, 0x46, 0xa4, 0x4c, 0xb3, 0x91,
+	0x60, 0x25, 0x0f, 0xc1, 0xa0, 0x91, 0xf9, 0xef, 0xc4, 0xfe, 0xb5, 0x6f, 0xfe, 0x41, 0x07, 0x50,
+	0x9f, 0xb2, 0xb2, 0x50, 0x32, 0x6c, 0x0f, 0x6a, 0xc3, 0xf6, 0xde, 0xbd, 0x8a, 0x57, 0xf5, 0x4c,
+	0x93, 0x12, 0xc7, 0x45, 0xdf, 0x42, 0x23, 0x27, 0x33, 0xaa, 0x6f, 0xbc, 0x63, 0xc2, 0x7c, 0x56,
+	0x31, 0xcc, 0x81, 0x61, 0x25, 0x9e, 0x8d, 0xc6, 0x70, 0xb3, 0x20, 0xea, 0x82, 0x89, 0xf3, 0x94,
+	0x4a, 0x36, 0xc1, 0x8a, 0xb2, 0x22, 0xec, 0x9a, 0x26, 0x7e, 0x51, 0x31, 0xe4, 0xb1, 0xe5, 0x1f,
+	0x7a, 0xfa, 0x29, 0x27, 0x59, 0xd2, 0x2b, 0xae, 0x79, 0x51, 0x04, 0xdd, 0x82, 0xa5, 0x9c, 0xce,
+	0x98, 0x4a, 0x05, 0x63, 0x2a, 0xdc, 0x34, 0x77, 0xd4, 0x2e, 0xd8, 0x89, 0xf6, 0x25, 0x8c, 0x29,
+	0x34, 0x84, 0x5e, 0x4e, 0x5e, 0xe2, 0x72, 0xa2, 0x52, 0x4e, 0xf3, 0x74, 0xca, 0x72, 0x12, 0x6e,
+	0x99, 0xd6, 0x6c, 0x3a, 0xff, 0x09, 0xcd, 0x9f, 0xb1, 0x9c, 0x2c, 0x22, 0x29, 0xcf, 0x2c, 0xb2,
+	0xb7, 0x84, 0x3c, 0xe4, 0x99, 0x41, 0x7e, 0x04, 0xdd, 0x8c, 0x97, 0x92, 0x28, 0xdf, 0x9b, 0x9b,
+	0x06, 0xd6, 0xb1, 0x4e, 0xd7, 0x95, 0x0f, 0x00, 0xf0, 0x64, 0xc2, 0x2e, 0xd2, 0x0c, 0x73, 0x19,
+	0x22, 0x33, 0x38, 0x2d, 0xe3, 0xd9, 0xc7, 0x5c, 0xa2, 0x08, 0x3a, 0x19, 0xe6, 0xf8, 0x8c, 0x4e,
+	0xa8, 0xa2, 0x44, 0x86, 0xef, 0x18, 0xc0, 0x92, 0x4f, 0x8f, 0x93, 0x26, 0x64, 0x29, 0xcd, 0xc3,
+	0x5b, 0x76, 0x9c, 0x8c, 0x7d, 0x98, 0xa3, 0xf7, 0xa1, 0x65, 0x26, 0xad, 0xc0, 0x53, 0x12, 0xbe,
+	0x6b, 0xfe, 0x33, 0xa3, 0x77, 0x8c, 0xa7, 0x24, 0xfa, 0x09, 0x36, 0xfd, 0xd6, 0x49, 0xce, 0x0a,
+	0x49, 0xd0, 0x31, 0x34, 0xdc, 0x38, 0x99, 0xd5, 0x6b, 0xef, 0x3d, 0x88, 0xab, 0xe9, 0x40, 0xec,
+	0x46, 0xed, 0x54, 0x61, 0x45, 0x12, 0x1f, 0x24, 0xea, 0x42, 0xfb, 0x05, 0xa6, 0xca, 0x6d, 0x75,
+	0xf4, 0x23, 0x74, 0xac, 0xf9, 0x3f, 0xa5, 0x3b, 0x82, 0xad, 0xd3, 0x71, 0xa9, 0x72, 0x76, 0x51,
+	0x78, 0x21, 0xd9, 0x86, 0xba, 0xa4, 0xa3, 0x02, 0x4f, 0x9c, 0x96, 0x38, 0x0b, 0x7d, 0x08, 0x9d,
+	0x91, 0xc0, 0x19, 0x49, 0x39, 0x11, 0x94, 0xe5, 0xe1, 0xda, 0x20, 0x18, 0xd6, 0x92, 0xb6, 0xf1,
+	0x9d, 0x18, 0x57, 0x84, 0xa0, 0x77, 0x15, 0xcd, 0x56, 0x1c, 0x8d, 0x61, 0xfb, 0x3b, 0x9e, 0xeb,
+	0xa4, 0x73, 0xfd, 0x70, 0x89, 0x96, 0xb4, 0x28, 0xf8, 0xcf, 0x5a, 0x14, 0xdd, 0x86, 0xf7, 0x5e,
+	0xc9, 0xe4, 0x8a, 0xe8, 0xc1, 0xe6, 0xf7, 0x44, 0x48, 0xca, 0xfc, 0x29, 0xa3, 0x4f, 0x61, 0x6b,
+	0xee, 0x71, 0x77, 0x1b, 0x42, 0x63, 0x66, 0x5d, 0xee, 0xe4, 0xde, 0x8c, 0x3e, 0x81, 0x8e, 0xbe,
+	0xb7, 0x79, 0xe5, 0x7d, 0x68, 0xd2, 0x42, 0x11, 0x31, 0x73, 0x97, 0x54, 0x4b, 0xe6, 0x76, 0xf4,
+	0x02, 0xba, 0x0e, 0xeb, 0xc2, 0x7e, 0x03, 0x1b, 0x52, 0x3b, 0x56, 0x3c, 0xe2, 0x73, 0x2c, 0xcf,
+	0x6d, 0x20, 0x4b, 0x8f, 0xee, 0x42, 0xf7, 0xd4, 0x74, 0xe2, 0xf5, 0x8d, 0xda, 0xf0, 0x8d, 0xd2,
+	0x87, 0xf5, 0x40, 0x77, 0xfc, 0x73, 0x68, 0x3f, 0xbd, 0x24, 0x99, 0x27, 0x3e, 0x82, 0x66, 0x4e,
+	0x70, 0x3e, 0xa1, 0x05, 0x71, 0x45, 0xf5, 0x63, 0xfb, 0x28, 0xc5, 0xfe, 0x51, 0x8a, 0x9f, 0xfb,
+	0x47, 0x29, 0x99, 0x63, 0xfd, 0x13, 0xb3, 0xf6, 0xea, 0x13, 0x53, 0xbb, 0x7a, 0x62, 0xa2, 0x7d,
+	0xe8, 0xd8, 0x64, 0xee, 0xfc, 0xdb, 0x50, 0x67, 0xa5, 0xe2, 0xa5, 0x32, 0xb9, 0x3a, 0x89, 0xb3,
+	0xf4, 0xa2, 0x91, 0x4b, 0xaa, 0xd2, 0x4c, 0xcb, 0xc1, 0x9a, 0x39, 0x41, 0x53, 0x3b, 0xf6, 0x59,
+	0x4e, 0xa2, 0xdf, 0x03, 0xe8, 0x2c, 0x4e, 0xac, 0xce, 0xcd, 0x69, 0xee, 0x4e, 0xaa, 0x3f, 0xdf,
+	0xc8, 0x5f, 0xb8, 0x9b, 0xda, 0xe2, 0xdd, 0xa0, 0x18, 0xd6, 0xf5, 0x73, 0x6b, 0x1e, 0xaa, 0x37,
+	0x1f, 0xdb, 0xe0, 0xf6, 0xfe, 0x6c, 0x41, 0xf3, 0xa9, 0x5b, 0x24, 0xf4, 0x0b, 0xd4, 0xed, 0xf6,
+	0xa3, 0x87, 0x55, 0xb7, 0x6e, 0xe9, 0x8d, 0xee, 0x3f, 0x5a, 0x95, 0xe6, 0xfa, 0x77, 0x03, 0x49,
+	0x58, 0xd7, 0x3a, 0x80, 0xee, 0x57, 0x8d, 0xb0, 0x20, 0x22, 0xfd, 0x07, 0xab, 0x91, 0xe6, 0x49,
+	0x7f, 0x83, 0xa6, 0x5f, 0x67, 0xf4, 0xb8, 0x6a, 0x8c, 0x6b, 0x72, 0xd2, 0xff, 0x7c, 0x75, 0xe2,
+	0xbc, 0x80, 0x3f, 0x02, 0xd8, 0xba, 0xb6, 0xd2, 0xe8, 0xcb, 0xaa, 0xf1, 0x5e, 0xaf, 0x3a, 0xfd,
+	0x27, 0x6f, 0xcd, 0x9f, 0x97, 0xf5, 0x2b, 0x34, 0x9c, 0x76, 0xa0, 0xca, 0x1d, 0x5d, 0x96, 0x9f,
+	0xfe, 0xe3, 0x95, 0x79, 0xf3, 0xec, 0x97, 0xb0, 0x61, 0x74, 0x01, 0x55, 0x6e, 0xeb, 0xa2, 0x76,
+	0xf5, 0x1f, 0xae, 0xc8, 0xf2, 0x79, 0x77, 0x03, 0x3d, 0xff, 0x56, 0x58, 0xaa, 0xcf, 0xff, 0x92,
+	0x62, 0x55, 0x9f, 0xff, 0x6b, 0xfa, 0x65, 0xe6, 0x5f, 0xaf, 0x61, 0xf5, 0xf9, 0x5f, 0xd0, 0xbb,
+	0xea, 0xf3, 0xbf, 0xa8, 0x5b, 0xd1, 0x0d, 0xf4, 0x57, 0x00, 0x5d, 0xed, 0x3a, 0x55, 0x82, 0xe0,
+	0x29, 0x2d, 0x46, 0xe8, 0x49, 0x45, 0xf1, 0xd6, 0x2c, 0x2b, 0xe0, 0x8e, 0xe9, 0x4b, 0xf9, 0xea,
+	0xed, 0x03, 0xf8, 0xb2, 0x86, 0xc1, 0x6e, 0xf0, 0x75, 0xe3, 0x87, 0x0d, 0xab, 0x59, 0x75, 0xf3,
+	0x73, 0xff, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x0e, 0xfa, 0x9c, 0xac, 0x0c, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.

drivers/shared/executor/proto/executor.proto

@@ -47,6 +47,8 @@ message LaunchRequest {
     string cpuset_cgroup = 17;
     repeated string allow_caps = 18;
     repeated string capabilities = 19;
+    string alloc_id = 20;
+    string task_name = 21;
 }
 
 message LaunchResponse {

lib/cpuset/cpuset.go

@@ -28,6 +28,17 @@ func New(cpus ...uint16) CPUSet {
 	return cpuset
 }
 
+// Copy returns a deep copy of CPUSet c.
+func (c CPUSet) Copy() CPUSet {
+	cpus := make(map[uint16]struct{}, len(c.cpus))
+	for k := range c.cpus {
+		cpus[k] = struct{}{}
+	}
+	return CPUSet{
+		cpus: cpus,
+	}
+}
+
 // String returns the cpuset as a comma delimited set of core values and ranged
 func (c CPUSet) String() string {
 	if c.Size() == 0 {
@@ -65,6 +76,11 @@ func (c CPUSet) Size() int {
 	return len(c.cpus)
 }
 
+// Empty returns whether any cpus are contained in the CPUSet.
+func (c CPUSet) Empty() bool {
+	return c.Size() <= 0
+}
+
 // ToSlice returns a sorted slice of uint16 CPU IDs contained in the CPUSet.
 func (c CPUSet) ToSlice() []uint16 {
 	cpus := []uint16{}

plugins/drivers/driver.go

@@ -267,7 +267,7 @@ type TaskConfig struct {
 	JobName          string
 	JobID            string
 	TaskGroupName    string
-	Name             string
+	Name             string // task.Name
 	Namespace        string
 	NodeName         string
 	NodeID           string