Add create/start to exec processes in shim

This splits up the create and start of an exec process in the shim to
have two separate steps like the initial process.  This will allow
better state reporting for individual process along with a more robust
wait for execs.

Signed-off-by: Michael Crosby <crosbymichael@gmail.com>

api/services/events/v1/container.pb.go

@@ -39,6 +39,7 @@
 		TaskExit
 		TaskOOM
 		TaskExecAdded
+		TaskExecStarted
 		TaskPaused
 		TaskResumed
 		TaskCheckpointed

api/services/events/v1/task.pb.go

@@ -94,20 +94,29 @@ func (*TaskOOM) Descriptor() ([]byte, []int) { return fileDescriptorTask, []int{
 type TaskExecAdded struct {
 	ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
 	ExecID      string `protobuf:"bytes,2,opt,name=exec_id,json=execId,proto3" json:"exec_id,omitempty"`
-	Pid         uint32 `protobuf:"varint,3,opt,name=pid,proto3" json:"pid,omitempty"`
 }
 
 func (m *TaskExecAdded) Reset()                    { *m = TaskExecAdded{} }
 func (*TaskExecAdded) ProtoMessage()               {}
 func (*TaskExecAdded) Descriptor() ([]byte, []int) { return fileDescriptorTask, []int{6} }
 
+type TaskExecStarted struct {
+	ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
+	ExecID      string `protobuf:"bytes,2,opt,name=exec_id,json=execId,proto3" json:"exec_id,omitempty"`
+	Pid         uint32 `protobuf:"varint,3,opt,name=pid,proto3" json:"pid,omitempty"`
+}
+
+func (m *TaskExecStarted) Reset()                    { *m = TaskExecStarted{} }
+func (*TaskExecStarted) ProtoMessage()               {}
+func (*TaskExecStarted) Descriptor() ([]byte, []int) { return fileDescriptorTask, []int{7} }
+
 type TaskPaused struct {
 	ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
 }
 
 func (m *TaskPaused) Reset()                    { *m = TaskPaused{} }
 func (*TaskPaused) ProtoMessage()               {}
-func (*TaskPaused) Descriptor() ([]byte, []int) { return fileDescriptorTask, []int{7} }
+func (*TaskPaused) Descriptor() ([]byte, []int) { return fileDescriptorTask, []int{8} }
 
 type TaskResumed struct {
 	ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
@@ -115,7 +124,7 @@ type TaskResumed struct {
 
 func (m *TaskResumed) Reset()                    { *m = TaskResumed{} }
 func (*TaskResumed) ProtoMessage()               {}
-func (*TaskResumed) Descriptor() ([]byte, []int) { return fileDescriptorTask, []int{8} }
+func (*TaskResumed) Descriptor() ([]byte, []int) { return fileDescriptorTask, []int{9} }
 
 type TaskCheckpointed struct {
 	ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
@@ -124,7 +133,7 @@ type TaskCheckpointed struct {
 
 func (m *TaskCheckpointed) Reset()                    { *m = TaskCheckpointed{} }
 func (*TaskCheckpointed) ProtoMessage()               {}
-func (*TaskCheckpointed) Descriptor() ([]byte, []int) { return fileDescriptorTask, []int{9} }
+func (*TaskCheckpointed) Descriptor() ([]byte, []int) { return fileDescriptorTask, []int{10} }
 
 func init() {
 	proto.RegisterType((*TaskCreate)(nil), "containerd.services.events.v1.TaskCreate")
@@ -134,6 +143,7 @@ func init() {
 	proto.RegisterType((*TaskExit)(nil), "containerd.services.events.v1.TaskExit")
 	proto.RegisterType((*TaskOOM)(nil), "containerd.services.events.v1.TaskOOM")
 	proto.RegisterType((*TaskExecAdded)(nil), "containerd.services.events.v1.TaskExecAdded")
+	proto.RegisterType((*TaskExecStarted)(nil), "containerd.services.events.v1.TaskExecStarted")
 	proto.RegisterType((*TaskPaused)(nil), "containerd.services.events.v1.TaskPaused")
 	proto.RegisterType((*TaskResumed)(nil), "containerd.services.events.v1.TaskResumed")
 	proto.RegisterType((*TaskCheckpointed)(nil), "containerd.services.events.v1.TaskCheckpointed")
@@ -263,6 +273,22 @@ func (m *TaskExecAdded) Field(fieldpath []string) (string, bool) {
 		return "", false
 	}
 
+	switch fieldpath[0] {
+	case "container_id":
+		return string(m.ContainerID), len(m.ContainerID) > 0
+	case "exec_id":
+		return string(m.ExecID), len(m.ExecID) > 0
+	}
+	return "", false
+}
+
+// Field returns the value for the given fieldpath as a string, if defined.
+// If the value is not defined, the second value will be false.
+func (m *TaskExecStarted) Field(fieldpath []string) (string, bool) {
+	if len(fieldpath) == 0 {
+		return "", false
+	}
+
 	switch fieldpath[0] {
 	// unhandled: pid
 	case "container_id":
@@ -579,6 +605,36 @@ func (m *TaskExecAdded) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *TaskExecAdded) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.ContainerID) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintTask(dAtA, i, uint64(len(m.ContainerID)))
+		i += copy(dAtA[i:], m.ContainerID)
+	}
+	if len(m.ExecID) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintTask(dAtA, i, uint64(len(m.ExecID)))
+		i += copy(dAtA[i:], m.ExecID)
+	}
+	return i, nil
+}
+
+func (m *TaskExecStarted) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *TaskExecStarted) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -824,6 +880,20 @@ func (m *TaskOOM) Size() (n int) {
 }
 
 func (m *TaskExecAdded) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.ContainerID)
+	if l > 0 {
+		n += 1 + l + sovTask(uint64(l))
+	}
+	l = len(m.ExecID)
+	if l > 0 {
+		n += 1 + l + sovTask(uint64(l))
+	}
+	return n
+}
+
+func (m *TaskExecStarted) Size() (n int) {
 	var l int
 	_ = l
 	l = len(m.ContainerID)
@@ -968,6 +1038,17 @@ func (this *TaskExecAdded) String() string {
 		return "nil"
 	}
 	s := strings.Join([]string{`&TaskExecAdded{`,
+		`ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
+		`ExecID:` + fmt.Sprintf("%v", this.ExecID) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+func (this *TaskExecStarted) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{`&TaskExecStarted{`,
 		`ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
 		`ExecID:` + fmt.Sprintf("%v", this.ExecID) + `,`,
 		`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
@@ -1920,6 +2001,114 @@ func (m *TaskExecAdded) Unmarshal(dAtA []byte) error {
 			return fmt.Errorf("proto: TaskExecAdded: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTask
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTask
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ContainerID = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ExecID", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTask
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTask
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ExecID = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTask(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthTask
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *TaskExecStarted) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTask
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: TaskExecStarted: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: TaskExecStarted: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
 		case 1:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
@@ -2394,45 +2583,46 @@ func init() {
 }
 
 var fileDescriptorTask = []byte{
-	// 634 bytes of a gzipped FileDescriptorProto
+	// 648 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x95, 0xcd, 0x6e, 0xd3, 0x40,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x95, 0xc1, 0x6e, 0xd3, 0x40,
-	0x10, 0xc7, 0x6b, 0xa7, 0x75, 0x93, 0x0d, 0x15, 0x95, 0x55, 0x41, 0x14, 0x09, 0x3b, 0x32, 0x42,
+	0x10, 0x86, 0x6b, 0xa7, 0x75, 0x93, 0x0d, 0x55, 0x2b, 0xab, 0x82, 0x28, 0x12, 0x76, 0x64, 0x84,
-	0xca, 0xc9, 0x56, 0x8b, 0xc4, 0x05, 0x15, 0x35, 0x69, 0x38, 0xe4, 0x50, 0x05, 0xdc, 0x9e, 0x10,
+	0x94, 0x93, 0xad, 0x16, 0x89, 0x0b, 0x2a, 0x6a, 0xd2, 0x70, 0xc8, 0xa1, 0x0a, 0xb8, 0x3d, 0x21,
-	0x52, 0xe4, 0xd8, 0x93, 0x74, 0x69, 0xec, 0xb5, 0xbc, 0xe3, 0xa8, 0x70, 0xe2, 0x11, 0x78, 0x04,
+	0xa4, 0xc8, 0xb1, 0x27, 0xc9, 0xd2, 0xc4, 0x6b, 0x79, 0xc7, 0x51, 0x91, 0x38, 0xf0, 0x08, 0x3c,
-	0x9e, 0x82, 0x67, 0xe8, 0x81, 0x03, 0x47, 0x4e, 0x81, 0xfa, 0x19, 0x38, 0x71, 0x42, 0xeb, 0x75,
+	0x02, 0x4f, 0xc1, 0x33, 0xf4, 0xc0, 0x81, 0x23, 0xa7, 0x40, 0xfd, 0x0c, 0x9c, 0x38, 0xa1, 0xf5,
-	0xdc, 0xf2, 0x55, 0x90, 0x6f, 0x33, 0xe3, 0x99, 0xff, 0xce, 0xfc, 0x76, 0xb2, 0x21, 0xfd, 0x19,
+	0x3a, 0x6e, 0xa1, 0xa2, 0x20, 0x4b, 0xdc, 0x76, 0xc6, 0x33, 0xff, 0xcc, 0x7c, 0x3b, 0xd9, 0x90,
-	0xc5, 0xd3, 0x74, 0x62, 0xfb, 0x2c, 0x74, 0x7c, 0x16, 0xa1, 0x47, 0x23, 0x48, 0x82, 0xeb, 0xa6,
+	0xee, 0x84, 0xe2, 0x34, 0x19, 0xd9, 0x3e, 0x9b, 0x3b, 0x3e, 0x0b, 0xd1, 0xa3, 0x21, 0xc4, 0xc1,
-	0x17, 0x53, 0x87, 0x43, 0xb2, 0xa0, 0x3e, 0x70, 0x07, 0x16, 0x10, 0x21, 0x77, 0x16, 0xbb, 0x0e,
+	0xf5, 0xa3, 0x17, 0x51, 0x87, 0x43, 0xbc, 0xa0, 0x3e, 0x70, 0x07, 0x16, 0x10, 0x22, 0x77, 0x16,
-	0x7a, 0xfc, 0xcc, 0x8e, 0x13, 0x86, 0x4c, 0xbf, 0x77, 0x95, 0x6d, 0xaf, 0x32, 0x6d, 0x99, 0x69,
+	0x7b, 0x0e, 0x7a, 0xfc, 0xcc, 0x8e, 0x62, 0x86, 0x4c, 0xbf, 0x7f, 0x15, 0x6d, 0xaf, 0x22, 0x6d,
-	0x2f, 0x76, 0xdb, 0x3b, 0x33, 0x36, 0x63, 0x79, 0xa6, 0x23, 0x2c, 0x59, 0xd4, 0x36, 0x67, 0x8c,
+	0x19, 0x69, 0x2f, 0xf6, 0x9a, 0xbb, 0x13, 0x36, 0x61, 0x59, 0xa4, 0x23, 0x4e, 0x32, 0xa9, 0x69,
-	0xcd, 0xe6, 0xe0, 0xe4, 0xde, 0x24, 0x9d, 0x3a, 0x48, 0x43, 0xe0, 0xe8, 0x85, 0x71, 0x91, 0xf0,
+	0x4e, 0x18, 0x9b, 0xcc, 0xc0, 0xc9, 0xac, 0x51, 0x32, 0x76, 0x90, 0xce, 0x81, 0xa3, 0x37, 0x8f,
-	0xe8, 0xbf, 0x3a, 0xc3, 0xd7, 0x31, 0x70, 0x27, 0x64, 0x69, 0x84, 0x45, 0xdd, 0xc1, 0x3f, 0xeb,
+	0xf2, 0x80, 0xc7, 0xff, 0xd4, 0x19, 0xbe, 0x89, 0x80, 0x3b, 0x73, 0x96, 0x84, 0x98, 0xe7, 0x1d,
-	0xca, 0x23, 0xe3, 0x79, 0x3a, 0xa3, 0x91, 0x33, 0xa5, 0x30, 0x0f, 0x62, 0x0f, 0x4f, 0xa5, 0x82,
+	0xfe, 0x35, 0xaf, 0x28, 0x19, 0xcd, 0x92, 0x09, 0x0d, 0x9d, 0x31, 0x85, 0x59, 0x10, 0x79, 0x38,
-	0xf5, 0x5d, 0x21, 0xe4, 0xc4, 0xe3, 0x67, 0x87, 0x09, 0x78, 0x08, 0xfa, 0x1e, 0xb9, 0x55, 0x16,
+	0x95, 0x0a, 0xd6, 0x0f, 0x85, 0x90, 0x53, 0x8f, 0x9f, 0x1d, 0xc5, 0xe0, 0x21, 0xe8, 0xfb, 0xe4,
-	0x8f, 0x69, 0xd0, 0x52, 0x3a, 0x4a, 0xb7, 0xd1, 0xbf, 0x9d, 0x2d, 0xcd, 0xe6, 0xe1, 0x2a, 0x3e,
+	0x4e, 0x91, 0x3c, 0xa4, 0x41, 0x43, 0x69, 0x29, 0xed, 0x5a, 0x77, 0x3b, 0x5d, 0x9a, 0xf5, 0xa3,
-	0x1c, 0xb8, 0xcd, 0x32, 0x69, 0x18, 0xe8, 0x77, 0x88, 0x36, 0x49, 0xa3, 0x60, 0x0e, 0x2d, 0x55,
+	0x95, 0xbf, 0xdf, 0x73, 0xeb, 0x45, 0x50, 0x3f, 0xd0, 0xef, 0x12, 0x6d, 0x94, 0x84, 0xc1, 0x0c,
-	0x64, 0xbb, 0x85, 0xa7, 0x3b, 0x44, 0x4b, 0x18, 0xc3, 0x29, 0x6f, 0xd5, 0x3a, 0xb5, 0x6e, 0x73,
+	0x1a, 0xaa, 0x88, 0x76, 0x73, 0x4b, 0x77, 0x88, 0x16, 0x33, 0x86, 0x63, 0xde, 0xa8, 0xb4, 0x2a,
-	0xef, 0xae, 0x7d, 0x8d, 0x5d, 0x3e, 0x8b, 0x7d, 0x24, 0x66, 0x71, 0x8b, 0x34, 0x7d, 0x9f, 0xa8,
+	0xed, 0xfa, 0xfe, 0x3d, 0xfb, 0x1a, 0xbb, 0x6c, 0x16, 0xfb, 0x58, 0xcc, 0xe2, 0xe6, 0x61, 0xfa,
-	0x94, 0xb5, 0xd6, 0x3b, 0x4a, 0xb7, 0xb9, 0xf7, 0xc0, 0xbe, 0x11, 0xb4, 0x2d, 0x7a, 0x1e, 0x8e,
+	0x01, 0x51, 0x29, 0x6b, 0xac, 0xb7, 0x94, 0x76, 0x7d, 0xff, 0xa1, 0x7d, 0x2b, 0x68, 0x5b, 0xf4,
-	0xfa, 0x5a, 0xb6, 0x34, 0xd5, 0xe1, 0xc8, 0x55, 0x29, 0xd3, 0x0d, 0x42, 0xfc, 0x53, 0xf0, 0xcf,
+	0xdc, 0x1f, 0x74, 0xb5, 0x74, 0x69, 0xaa, 0xfd, 0x81, 0xab, 0x52, 0xa6, 0x1b, 0x84, 0xf8, 0x53,
-	0x62, 0x46, 0x23, 0x6c, 0x6d, 0xe4, 0xbd, 0x5c, 0x8b, 0xe8, 0xdb, 0xa4, 0x16, 0xd3, 0xa0, 0xa5,
+	0xf0, 0xcf, 0x22, 0x46, 0x43, 0x6c, 0x6c, 0x64, 0xbd, 0x5c, 0xf3, 0xe8, 0x3b, 0xa4, 0x12, 0xd1,
-	0x75, 0x94, 0xee, 0x96, 0x2b, 0x4c, 0xeb, 0x39, 0x69, 0x08, 0x9d, 0x63, 0xf4, 0x12, 0xac, 0x34,
+	0xa0, 0xa1, 0xb5, 0x94, 0xf6, 0x96, 0x2b, 0x8e, 0xd6, 0x0b, 0x52, 0x13, 0x3a, 0x27, 0xe8, 0xc5,
-	0x7a, 0x21, 0xa9, 0x5e, 0x49, 0x7e, 0x28, 0x78, 0x0e, 0x60, 0x0e, 0x15, 0x79, 0xfe, 0x26, 0xaa,
+	0x58, 0x6a, 0xf4, 0x5c, 0x52, 0xbd, 0x92, 0xfc, 0x98, 0xf3, 0xec, 0xc1, 0x0c, 0x4a, 0xf2, 0xbc,
-	0x9b, 0xa4, 0x09, 0xe7, 0x14, 0xc7, 0x1c, 0x3d, 0x4c, 0x05, 0x4e, 0xf1, 0x85, 0x88, 0xd0, 0x71,
+	0x21, 0xaa, 0x9b, 0xa4, 0x0e, 0xe7, 0x14, 0x87, 0x1c, 0x3d, 0x4c, 0x04, 0x4e, 0xf1, 0x85, 0x08,
-	0x1e, 0xd1, 0x7b, 0xa4, 0x21, 0x3c, 0x08, 0xc6, 0x1e, 0x16, 0x00, 0xdb, 0xb6, 0x5c, 0x3a, 0x7b,
+	0xd7, 0x49, 0xe6, 0xd1, 0x3b, 0xa4, 0x26, 0x2c, 0x08, 0x86, 0x1e, 0xe6, 0x00, 0x9b, 0xb6, 0x5c,
-	0xb5, 0x01, 0xf6, 0xc9, 0x6a, 0xe9, 0xfa, 0xf5, 0x8b, 0xa5, 0xb9, 0xf6, 0xee, 0x8b, 0xa9, 0xb8,
+	0x3a, 0x7b, 0xb5, 0x01, 0xf6, 0xe9, 0x6a, 0xe9, 0xba, 0xd5, 0x8b, 0xa5, 0xb9, 0xf6, 0xfe, 0xab,
-	0x75, 0x59, 0xd6, 0x43, 0xeb, 0x15, 0xd1, 0x24, 0x53, 0x7d, 0x87, 0x6c, 0x70, 0x0c, 0x68, 0x24,
+	0xa9, 0xb8, 0x55, 0x99, 0xd6, 0x41, 0xeb, 0x35, 0xd1, 0x24, 0x53, 0x7d, 0x97, 0x6c, 0x70, 0x0c,
-	0x9b, 0x75, 0xa5, 0x23, 0x6e, 0x99, 0x63, 0xc0, 0x52, 0x5c, 0xdd, 0xb2, 0xf4, 0x8a, 0x38, 0x24,
+	0x68, 0x28, 0x9b, 0x75, 0xa5, 0x21, 0x6e, 0x99, 0x63, 0xc0, 0x12, 0x5c, 0xdd, 0xb2, 0xb4, 0x72,
-	0x49, 0xde, 0x96, 0x8c, 0x43, 0x92, 0xe8, 0x6d, 0x52, 0x47, 0x48, 0x42, 0x1a, 0x79, 0xf3, 0xbc,
+	0x3f, 0xc4, 0x71, 0xd6, 0x96, 0xf4, 0x43, 0x1c, 0xeb, 0x4d, 0x52, 0x45, 0x88, 0xe7, 0x34, 0xf4,
-	0xa3, 0xba, 0x5b, 0xfa, 0xd6, 0x47, 0x85, 0xd4, 0xc5, 0x61, 0x4f, 0xcf, 0x29, 0x56, 0x5c, 0x39,
+	0x66, 0x59, 0x47, 0x55, 0xb7, 0xb0, 0xad, 0x4f, 0x0a, 0xa9, 0x8a, 0x62, 0xcf, 0xce, 0x29, 0x96,
-	0xb5, 0x20, 0xd4, 0x28, 0x56, 0x60, 0xe0, 0xaa, 0xb4, 0x44, 0x57, 0xfb, 0x2b, 0xba, 0xf5, 0x9b,
+	0x5c, 0x39, 0x35, 0x27, 0x54, 0xcb, 0x57, 0xa0, 0xe7, 0xaa, 0xb4, 0x40, 0x57, 0xf9, 0x23, 0xba,
-	0xd1, 0x6d, 0x54, 0x42, 0xb7, 0x4f, 0x36, 0xc5, 0x34, 0xa3, 0xd1, 0x51, 0x95, 0x61, 0xac, 0x37,
+	0xf5, 0xdb, 0xd1, 0x6d, 0x94, 0x42, 0x77, 0x40, 0x36, 0xc5, 0x34, 0x83, 0xc1, 0x71, 0x99, 0x61,
-	0x64, 0x4b, 0xc2, 0x00, 0xbf, 0x17, 0x04, 0x10, 0x54, 0x22, 0x72, 0x9f, 0x6c, 0xc2, 0x39, 0xf8,
+	0xac, 0x29, 0xd9, 0x92, 0x30, 0xc0, 0xef, 0x04, 0x01, 0x04, 0xa5, 0x88, 0x3c, 0x20, 0x9b, 0x70,
-	0xe3, 0x12, 0x0b, 0xc9, 0x96, 0xa6, 0x26, 0x34, 0x87, 0x03, 0x57, 0x13, 0x9f, 0x86, 0x7f, 0xc0,
+	0x0e, 0xfe, 0xb0, 0xc0, 0x42, 0xd2, 0xa5, 0xa9, 0x09, 0xcd, 0x7e, 0xcf, 0xd5, 0xc4, 0xa7, 0x7e,
-	0x63, 0x1d, 0xc8, 0x6d, 0x7d, 0xe6, 0xa5, 0xbc, 0xda, 0xc1, 0x56, 0x8f, 0x34, 0x85, 0x82, 0x0b,
+	0x60, 0xbd, 0x25, 0xdb, 0xab, 0x4a, 0xd9, 0xce, 0xff, 0xc7, 0x5a, 0x37, 0xaf, 0xc2, 0x3a, 0x94,
-	0x3c, 0x0d, 0x2b, 0x4a, 0x4c, 0xc9, 0x76, 0xfe, 0x04, 0x95, 0x3f, 0xd5, 0x8a, 0x0c, 0x7e, 0x7e,
+	0xbf, 0x8c, 0xe7, 0x5e, 0xc2, 0xcb, 0x15, 0xb6, 0x3a, 0xa4, 0x2e, 0x14, 0x5c, 0xe0, 0xc9, 0xbc,
-	0x00, 0xd4, 0x5f, 0x1f, 0x80, 0xfe, 0xcb, 0x8b, 0x4b, 0x63, 0xed, 0xf3, 0xa5, 0xb1, 0xf6, 0x36,
+	0xa4, 0xc4, 0x98, 0xec, 0x64, 0xcf, 0x5d, 0xf1, 0x2c, 0x94, 0x64, 0xf0, 0xeb, 0x63, 0xa3, 0xfe,
-	0x33, 0x94, 0x8b, 0xcc, 0x50, 0x3e, 0x65, 0x86, 0xf2, 0x35, 0x33, 0x94, 0xf7, 0xdf, 0x0c, 0xe5,
+	0xfe, 0xd8, 0x74, 0x5f, 0x5d, 0x5c, 0x1a, 0x6b, 0x5f, 0x2e, 0x8d, 0xb5, 0x77, 0xa9, 0xa1, 0x5c,
-	0xc5, 0x93, 0x8a, 0xff, 0x0e, 0x8f, 0xa5, 0x35, 0xd1, 0xf2, 0x6d, 0x79, 0xf8, 0x23, 0x00, 0x00,
+	0xa4, 0x86, 0xf2, 0x39, 0x35, 0x94, 0x6f, 0xa9, 0xa1, 0x7c, 0xf8, 0x6e, 0x28, 0x2f, 0x9f, 0x96,
-	0xff, 0xff, 0xfd, 0xdf, 0x0f, 0x7f, 0x66, 0x06, 0x00, 0x00,
+	0xfc, 0x27, 0x7a, 0x22, 0x4f, 0x23, 0x2d, 0xdb, 0xcc, 0x47, 0x3f, 0x03, 0x00, 0x00, 0xff, 0xff,
+	0x76, 0xdf, 0xe7, 0xaa, 0xd2, 0x06, 0x00, 0x00,
 }

api/services/events/v1/task.proto

@@ -53,6 +53,11 @@ message TaskOOM {
 message TaskExecAdded {
 	string container_id = 1;
 	string exec_id = 2;
+}
+
+message TaskExecStarted {
+	string container_id = 1;
+	string exec_id = 2;
 	uint32 pid = 3;
 }
 

cmd/ctr/shim.go

@@ -149,7 +149,9 @@ var shimStartCommand = cli.Command{
 		if err != nil {
 			return err
 		}
-		_, err = service.Start(gocontext.Background(), empty)
+		_, err = service.Start(gocontext.Background(), &shim.StartRequest{
+			ID: context.Args().First(),
+		})
 		return err
 	},
 }
@@ -261,7 +263,12 @@ var shimExecCommand = cli.Command{
 			Stderr:   context.String("stderr"),
 			Terminal: tty,
 		}
-		r, err := service.Exec(ctx, rq)
+		if _, err := service.Exec(ctx, rq); err != nil {
+			return err
+		}
+		r, err := service.Start(ctx, &shim.StartRequest{
+			ID: id,
+		})
 		if err != nil {
 			return err
 		}

linux/shim/exec.go

@@ -36,6 +36,8 @@ type execProcess struct {
 	closers []io.Closer
 	stdin   io.Closer
 	stdio   stdio
+	path    string
+	spec    specs.Process
 
 	parent *initProcess
 }
@@ -44,43 +46,6 @@ func newExecProcess(context context.Context, path string, r *shimapi.ExecProcess
 	if err := identifiers.Validate(id); err != nil {
 		return nil, errors.Wrapf(err, "invalid exec id")
 	}
-
-	e := &execProcess{
-		id:     id,
-		parent: parent,
-		stdio: stdio{
-			stdin:    r.Stdin,
-			stdout:   r.Stdout,
-			stderr:   r.Stderr,
-			terminal: r.Terminal,
-		},
-	}
-	var (
-		err     error
-		socket  *runc.Socket
-		io      runc.IO
-		pidfile = filepath.Join(path, fmt.Sprintf("%s.pid", id))
-	)
-	if r.Terminal {
-		if socket, err = runc.NewConsoleSocket(filepath.Join(path, "pty.sock")); err != nil {
-			return nil, errors.Wrap(err, "failed to create runc console socket")
-		}
-		defer os.Remove(socket.Path())
-	} else {
-		// TODO: get uid/gid
-		if io, err = runc.NewPipeIO(0, 0); err != nil {
-			return nil, errors.Wrap(err, "failed to create runc io pipes")
-		}
-		e.io = io
-	}
-	opts := &runc.ExecOpts{
-		PidFile: pidfile,
-		IO:      io,
-		Detach:  true,
-	}
-	if socket != nil {
-		opts.ConsoleSocket = socket
-	}
 	// process exec request
 	var spec specs.Process
 	if err := json.Unmarshal(r.Spec.Value, &spec); err != nil {
@@ -88,39 +53,18 @@ func newExecProcess(context context.Context, path string, r *shimapi.ExecProcess
 	}
 	spec.Terminal = r.Terminal
 
-	if err := parent.runtime.Exec(context, parent.id, spec, opts); err != nil {
+	e := &execProcess{
-		return nil, parent.runtimeError(err, "OCI runtime exec failed")
+		id:     id,
+		path:   path,
+		parent: parent,
+		spec:   spec,
+		stdio: stdio{
+			stdin:    r.Stdin,
+			stdout:   r.Stdout,
+			stderr:   r.Stderr,
+			terminal: r.Terminal,
+		},
 	}
-	if r.Stdin != "" {
-		sc, err := fifo.OpenFifo(context, r.Stdin, syscall.O_WRONLY|syscall.O_NONBLOCK, 0)
-		if err != nil {
-			return nil, errors.Wrapf(err, "failed to open stdin fifo %s", r.Stdin)
-		}
-		e.closers = append(e.closers, sc)
-		e.stdin = sc
-	}
-	var copyWaitGroup sync.WaitGroup
-	if socket != nil {
-		console, err := socket.ReceiveMaster()
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to retrieve console master")
-		}
-		console, err = e.parent.platform.copyConsole(context, console, r.Stdin, r.Stdout, r.Stderr, &e.WaitGroup, &copyWaitGroup)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to start console copy")
-		}
-		e.console = console
-	} else {
-		if err := copyPipes(context, io, r.Stdin, r.Stdout, r.Stderr, &e.WaitGroup, &copyWaitGroup); err != nil {
-			return nil, errors.Wrap(err, "failed to start io pipe copy")
-		}
-	}
-	copyWaitGroup.Wait()
-	pid, err := runc.ReadPidFile(opts.PidFile)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to retrieve OCI runtime exec pid")
-	}
-	e.pid = pid
 	return e, nil
 }
 
@@ -178,3 +122,63 @@ func (e *execProcess) Stdin() io.Closer {
 func (e *execProcess) Stdio() stdio {
 	return e.stdio
 }
+
+func (e *execProcess) Start(ctx context.Context) (err error) {
+	var (
+		socket  *runc.Socket
+		io      runc.IO
+		pidfile = filepath.Join(e.path, fmt.Sprintf("%s.pid", e.id))
+	)
+	if e.stdio.terminal {
+		if socket, err = runc.NewConsoleSocket(filepath.Join(e.path, "pty.sock")); err != nil {
+			return errors.Wrap(err, "failed to create runc console socket")
+		}
+		defer os.Remove(socket.Path())
+	} else {
+		if io, err = runc.NewPipeIO(0, 0); err != nil {
+			return errors.Wrap(err, "failed to create runc io pipes")
+		}
+		e.io = io
+	}
+	opts := &runc.ExecOpts{
+		PidFile: pidfile,
+		IO:      io,
+		Detach:  true,
+	}
+	if socket != nil {
+		opts.ConsoleSocket = socket
+	}
+	if err := e.parent.runtime.Exec(ctx, e.parent.id, e.spec, opts); err != nil {
+		return e.parent.runtimeError(err, "OCI runtime exec failed")
+	}
+	if e.stdio.stdin != "" {
+		sc, err := fifo.OpenFifo(ctx, e.stdio.stdin, syscall.O_WRONLY|syscall.O_NONBLOCK, 0)
+		if err != nil {
+			return errors.Wrapf(err, "failed to open stdin fifo %s", e.stdio.stdin)
+		}
+		e.closers = append(e.closers, sc)
+		e.stdin = sc
+	}
+	var copyWaitGroup sync.WaitGroup
+	if socket != nil {
+		console, err := socket.ReceiveMaster()
+		if err != nil {
+			return errors.Wrap(err, "failed to retrieve console master")
+		}
+		e.console = console
+		if err := e.parent.platform.copyConsole(ctx, console, e.stdio.stdin, e.stdio.stdout, e.stdio.stderr, &e.WaitGroup, &copyWaitGroup); err != nil {
+			return errors.Wrap(err, "failed to start console copy")
+		}
+	} else {
+		if err := copyPipes(ctx, io, e.stdio.stdin, e.stdio.stdout, e.stdio.stderr, &e.WaitGroup, &copyWaitGroup); err != nil {
+			return errors.Wrap(err, "failed to start io pipe copy")
+		}
+	}
+	copyWaitGroup.Wait()
+	pid, err := runc.ReadPidFile(opts.PidFile)
+	if err != nil {
+		return errors.Wrap(err, "failed to retrieve OCI runtime exec pid")
+	}
+	e.pid = pid
+	return nil
+}

linux/shim/local.go

@@ -27,7 +27,7 @@ func (c *local) Create(ctx context.Context, in *shimapi.CreateTaskRequest, opts
 	return c.s.Create(ctx, in)
 }
 
-func (c *local) Start(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+func (c *local) Start(ctx context.Context, in *shimapi.StartRequest, opts ...grpc.CallOption) (*shimapi.StartResponse, error) {
 	return c.s.Start(ctx, in)
 }
 
@@ -43,7 +43,7 @@ func (c *local) DeleteProcess(ctx context.Context, in *shimapi.DeleteProcessRequ
 	return c.s.DeleteProcess(ctx, in)
 }
 
-func (c *local) Exec(ctx context.Context, in *shimapi.ExecProcessRequest, opts ...grpc.CallOption) (*shimapi.ExecProcessResponse, error) {
+func (c *local) Exec(ctx context.Context, in *shimapi.ExecProcessRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
 	return c.s.Exec(ctx, in)
 }
 

linux/shim/process.go

@@ -38,4 +38,6 @@ type process interface {
 	Kill(context.Context, uint32, bool) error
 	// Stdio returns io information for the container
 	Stdio() stdio
+	// Start execution of the process
+	Start(context.Context) error
 }

linux/shim/service.go

@@ -108,18 +108,36 @@ func (s *Service) Create(ctx context.Context, r *shimapi.CreateTaskRequest) (*sh
 	}, nil
 }
 
-func (s *Service) Start(ctx context.Context, r *google_protobuf.Empty) (*google_protobuf.Empty, error) {
+func (s *Service) Start(ctx context.Context, r *shimapi.StartRequest) (*shimapi.StartResponse, error) {
-	if s.initProcess == nil {
+	p, ok := s.processes[r.ID]
-		return nil, errdefs.ToGRPCf(errdefs.ErrFailedPrecondition, "container must be created")
+	if !ok {
+		return nil, errdefs.ToGRPCf(errdefs.ErrNotFound, "process %s not found", r.ID)
 	}
-	if err := s.initProcess.Start(ctx); err != nil {
+	if err := p.Start(ctx); err != nil {
 		return nil, err
 	}
+	if r.ID == s.id {
 		s.events <- &eventsapi.TaskStart{
 			ContainerID: s.id,
 			Pid:         uint32(s.initProcess.Pid()),
 		}
-	return empty, nil
+	} else {
+		pid := p.Pid()
+		cmd := &reaper.Cmd{
+			ExitCh: make(chan int, 1),
+		}
+		reaper.Default.Register(pid, cmd)
+		go s.waitExit(p, pid, cmd)
+		s.events <- &eventsapi.TaskExecStarted{
+			ContainerID: s.id,
+			ExecID:      r.ID,
+			Pid:         uint32(pid),
+		}
+	}
+	return &shimapi.StartResponse{
+		ID:  p.ID(),
+		Pid: uint32(p.Pid()),
+	}, nil
 }
 
 func (s *Service) Delete(ctx context.Context, r *google_protobuf.Empty) (*shimapi.DeleteResponse, error) {
@@ -170,7 +188,7 @@ func (s *Service) DeleteProcess(ctx context.Context, r *shimapi.DeleteProcessReq
 	}, nil
 }
 
-func (s *Service) Exec(ctx context.Context, r *shimapi.ExecProcessRequest) (*shimapi.ExecProcessResponse, error) {
+func (s *Service) Exec(ctx context.Context, r *shimapi.ExecProcessRequest) (*google_protobuf.Empty, error) {
 	if s.initProcess == nil {
 		return nil, errdefs.ToGRPCf(errdefs.ErrFailedPrecondition, "container must be created")
 	}
@@ -181,22 +199,13 @@ func (s *Service) Exec(ctx context.Context, r *shimapi.ExecProcessRequest) (*shi
 	if err != nil {
 		return nil, errdefs.ToGRPC(err)
 	}
-	pid := process.Pid()
-	cmd := &reaper.Cmd{
-		ExitCh: make(chan int, 1),
-	}
-	reaper.Default.Register(pid, cmd)
 	s.processes[r.ID] = process
 
 	s.events <- &eventsapi.TaskExecAdded{
 		ContainerID: s.id,
 		ExecID:      r.ID,
-		Pid:         uint32(pid),
 	}
-	go s.waitExit(process, pid, cmd)
+	return empty, nil
-	return &shimapi.ExecProcessResponse{
-		Pid: uint32(pid),
-	}, nil
 }
 
 func (s *Service) ResizePty(ctx context.Context, r *shimapi.ResizePtyRequest) (*google_protobuf.Empty, error) {

linux/shim/v1/shim.pb.go

@@ -25,6 +25,8 @@
 		CheckpointTaskRequest
 		ShimInfoResponse
 		UpdateTaskRequest
+		StartRequest
+		StartResponse
 */
 package shim
 
@@ -122,7 +124,6 @@ func (*ExecProcessRequest) ProtoMessage()               {}
 func (*ExecProcessRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{4} }
 
 type ExecProcessResponse struct {
-	Pid uint32 `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"`
 }
 
 func (m *ExecProcessResponse) Reset()                    { *m = ExecProcessResponse{} }
@@ -222,6 +223,23 @@ func (m *UpdateTaskRequest) Reset()                    { *m = UpdateTaskRequest{
 func (*UpdateTaskRequest) ProtoMessage()               {}
 func (*UpdateTaskRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{15} }
 
+type StartRequest struct {
+	ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+}
+
+func (m *StartRequest) Reset()                    { *m = StartRequest{} }
+func (*StartRequest) ProtoMessage()               {}
+func (*StartRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{16} }
+
+type StartResponse struct {
+	ID  string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+	Pid uint32 `protobuf:"varint,2,opt,name=pid,proto3" json:"pid,omitempty"`
+}
+
+func (m *StartResponse) Reset()                    { *m = StartResponse{} }
+func (*StartResponse) ProtoMessage()               {}
+func (*StartResponse) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{17} }
+
 func init() {
 	proto.RegisterType((*CreateTaskRequest)(nil), "containerd.runtime.linux.shim.v1.CreateTaskRequest")
 	proto.RegisterType((*CreateTaskResponse)(nil), "containerd.runtime.linux.shim.v1.CreateTaskResponse")
@@ -239,6 +257,8 @@ func init() {
 	proto.RegisterType((*CheckpointTaskRequest)(nil), "containerd.runtime.linux.shim.v1.CheckpointTaskRequest")
 	proto.RegisterType((*ShimInfoResponse)(nil), "containerd.runtime.linux.shim.v1.ShimInfoResponse")
 	proto.RegisterType((*UpdateTaskRequest)(nil), "containerd.runtime.linux.shim.v1.UpdateTaskRequest")
+	proto.RegisterType((*StartRequest)(nil), "containerd.runtime.linux.shim.v1.StartRequest")
+	proto.RegisterType((*StartResponse)(nil), "containerd.runtime.linux.shim.v1.StartResponse")
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -255,7 +275,7 @@ type ShimClient interface {
 	// State returns shim and task state information.
 	State(ctx context.Context, in *StateRequest, opts ...grpc.CallOption) (*StateResponse, error)
 	Create(ctx context.Context, in *CreateTaskRequest, opts ...grpc.CallOption) (*CreateTaskResponse, error)
-	Start(ctx context.Context, in *google_protobuf1.Empty, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
+	Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*StartResponse, error)
 	Delete(ctx context.Context, in *google_protobuf1.Empty, opts ...grpc.CallOption) (*DeleteResponse, error)
 	DeleteProcess(ctx context.Context, in *DeleteProcessRequest, opts ...grpc.CallOption) (*DeleteResponse, error)
 	ListPids(ctx context.Context, in *ListPidsRequest, opts ...grpc.CallOption) (*ListPidsResponse, error)
@@ -263,7 +283,7 @@ type ShimClient interface {
 	Resume(ctx context.Context, in *google_protobuf1.Empty, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
 	Checkpoint(ctx context.Context, in *CheckpointTaskRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
 	Kill(ctx context.Context, in *KillRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
-	Exec(ctx context.Context, in *ExecProcessRequest, opts ...grpc.CallOption) (*ExecProcessResponse, error)
+	Exec(ctx context.Context, in *ExecProcessRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
 	ResizePty(ctx context.Context, in *ResizePtyRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
 	CloseIO(ctx context.Context, in *CloseIORequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
 	// ShimInfo returns information about the shim.
@@ -297,8 +317,8 @@ func (c *shimClient) Create(ctx context.Context, in *CreateTaskRequest, opts ...
 	return out, nil
 }
 
-func (c *shimClient) Start(ctx context.Context, in *google_protobuf1.Empty, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
+func (c *shimClient) Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*StartResponse, error) {
-	out := new(google_protobuf1.Empty)
+	out := new(StartResponse)
 	err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Start", in, out, c.cc, opts...)
 	if err != nil {
 		return nil, err
@@ -369,8 +389,8 @@ func (c *shimClient) Kill(ctx context.Context, in *KillRequest, opts ...grpc.Cal
 	return out, nil
 }
 
-func (c *shimClient) Exec(ctx context.Context, in *ExecProcessRequest, opts ...grpc.CallOption) (*ExecProcessResponse, error) {
+func (c *shimClient) Exec(ctx context.Context, in *ExecProcessRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
-	out := new(ExecProcessResponse)
+	out := new(google_protobuf1.Empty)
 	err := grpc.Invoke(ctx, "/containerd.runtime.linux.shim.v1.Shim/Exec", in, out, c.cc, opts...)
 	if err != nil {
 		return nil, err
@@ -420,7 +440,7 @@ type ShimServer interface {
 	// State returns shim and task state information.
 	State(context.Context, *StateRequest) (*StateResponse, error)
 	Create(context.Context, *CreateTaskRequest) (*CreateTaskResponse, error)
-	Start(context.Context, *google_protobuf1.Empty) (*google_protobuf1.Empty, error)
+	Start(context.Context, *StartRequest) (*StartResponse, error)
 	Delete(context.Context, *google_protobuf1.Empty) (*DeleteResponse, error)
 	DeleteProcess(context.Context, *DeleteProcessRequest) (*DeleteResponse, error)
 	ListPids(context.Context, *ListPidsRequest) (*ListPidsResponse, error)
@@ -428,7 +448,7 @@ type ShimServer interface {
 	Resume(context.Context, *google_protobuf1.Empty) (*google_protobuf1.Empty, error)
 	Checkpoint(context.Context, *CheckpointTaskRequest) (*google_protobuf1.Empty, error)
 	Kill(context.Context, *KillRequest) (*google_protobuf1.Empty, error)
-	Exec(context.Context, *ExecProcessRequest) (*ExecProcessResponse, error)
+	Exec(context.Context, *ExecProcessRequest) (*google_protobuf1.Empty, error)
 	ResizePty(context.Context, *ResizePtyRequest) (*google_protobuf1.Empty, error)
 	CloseIO(context.Context, *CloseIORequest) (*google_protobuf1.Empty, error)
 	// ShimInfo returns information about the shim.
@@ -477,7 +497,7 @@ func _Shim_Create_Handler(srv interface{}, ctx context.Context, dec func(interfa
 }
 
 func _Shim_Start_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(google_protobuf1.Empty)
+	in := new(StartRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
@@ -489,7 +509,7 @@ func _Shim_Start_Handler(srv interface{}, ctx context.Context, dec func(interfac
 		FullMethod: "/containerd.runtime.linux.shim.v1.Shim/Start",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ShimServer).Start(ctx, req.(*google_protobuf1.Empty))
+		return srv.(ShimServer).Start(ctx, req.(*StartRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -1037,11 +1057,6 @@ func (m *ExecProcessResponse) MarshalTo(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.Pid != 0 {
-		dAtA[i] = 0x8
-		i++
-		i = encodeVarintShim(dAtA, i, uint64(m.Pid))
-	}
 	return i, nil
 }
 
@@ -1388,6 +1403,59 @@ func (m *UpdateTaskRequest) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
+func (m *StartRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *StartRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.ID) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintShim(dAtA, i, uint64(len(m.ID)))
+		i += copy(dAtA[i:], m.ID)
+	}
+	return i, nil
+}
+
+func (m *StartResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *StartResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.ID) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintShim(dAtA, i, uint64(len(m.ID)))
+		i += copy(dAtA[i:], m.ID)
+	}
+	if m.Pid != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintShim(dAtA, i, uint64(m.Pid))
+	}
+	return i, nil
+}
+
 func encodeFixed64Shim(dAtA []byte, offset int, v uint64) int {
 	dAtA[offset] = uint8(v)
 	dAtA[offset+1] = uint8(v >> 8)
@@ -1531,9 +1599,6 @@ func (m *ExecProcessRequest) Size() (n int) {
 func (m *ExecProcessResponse) Size() (n int) {
 	var l int
 	_ = l
-	if m.Pid != 0 {
-		n += 1 + sovShim(uint64(m.Pid))
-	}
 	return n
 }
 
@@ -1683,6 +1748,29 @@ func (m *UpdateTaskRequest) Size() (n int) {
 	return n
 }
 
+func (m *StartRequest) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.ID)
+	if l > 0 {
+		n += 1 + l + sovShim(uint64(l))
+	}
+	return n
+}
+
+func (m *StartResponse) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.ID)
+	if l > 0 {
+		n += 1 + l + sovShim(uint64(l))
+	}
+	if m.Pid != 0 {
+		n += 1 + sovShim(uint64(m.Pid))
+	}
+	return n
+}
+
 func sovShim(x uint64) (n int) {
 	for {
 		n++
@@ -1768,7 +1856,6 @@ func (this *ExecProcessResponse) String() string {
 		return "nil"
 	}
 	s := strings.Join([]string{`&ExecProcessResponse{`,
-		`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -1886,6 +1973,27 @@ func (this *UpdateTaskRequest) String() string {
 	}, "")
 	return s
 }
+func (this *StartRequest) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{`&StartRequest{`,
+		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+func (this *StartResponse) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{`&StartResponse{`,
+		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
+		`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
+		`}`,
+	}, "")
+	return s
+}
 func valueToStringShim(v interface{}) string {
 	rv := reflect.ValueOf(v)
 	if rv.IsNil() {
@@ -2774,25 +2882,6 @@ func (m *ExecProcessResponse) Unmarshal(dAtA []byte) error {
 			return fmt.Errorf("proto: ExecProcessResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)
-			}
-			m.Pid = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowShim
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Pid |= (uint32(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipShim(dAtA[iNdEx:])
@@ -3935,6 +4024,183 @@ func (m *UpdateTaskRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *StartRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowShim
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: StartRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: StartRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowShim
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthShim
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ID = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipShim(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthShim
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *StartResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowShim
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: StartResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: StartResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowShim
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthShim
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ID = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)
+			}
+			m.Pid = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowShim
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Pid |= (uint32(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipShim(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthShim
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipShim(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
@@ -4045,71 +4311,72 @@ func init() {
 }
 
 var fileDescriptorShim = []byte{
-	// 1049 bytes of a gzipped FileDescriptorProto
+	// 1072 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0x4f, 0x6f, 0xe3, 0x44,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0x5f, 0x6f, 0xe3, 0x44,
-	0x14, 0x5f, 0xe7, 0xaf, 0xfb, 0x42, 0x4a, 0x3b, 0x94, 0xe2, 0xcd, 0x4a, 0x69, 0xe4, 0x43, 0x09,
+	0x10, 0xaf, 0xf3, 0xbf, 0x13, 0x52, 0xda, 0xa5, 0x57, 0x7c, 0x39, 0x29, 0x8d, 0xfc, 0x50, 0x05,
-	0x42, 0x6b, 0xd3, 0x14, 0x76, 0xf9, 0x23, 0x21, 0xb5, 0xdd, 0x15, 0xaa, 0xa0, 0xda, 0xca, 0xdd,
+	0xa1, 0x73, 0x68, 0x8a, 0xee, 0x38, 0x90, 0x90, 0xda, 0xde, 0x09, 0x55, 0x50, 0x5d, 0xe5, 0xf6,
-	0x05, 0x04, 0x42, 0x95, 0x1b, 0x4f, 0x93, 0x51, 0x1d, 0x8f, 0xd7, 0x33, 0x2e, 0x2d, 0x27, 0x4e,
+	0x00, 0x81, 0x50, 0xe5, 0xc6, 0xdb, 0x64, 0xd5, 0xc4, 0xeb, 0xf3, 0xae, 0x4b, 0xcb, 0x13, 0x4f,
-	0x9c, 0xf9, 0x38, 0x7c, 0x84, 0x1e, 0x91, 0xb8, 0x70, 0x5a, 0xd8, 0x9c, 0xb8, 0xf0, 0x1d, 0xd0,
+	0x3c, 0xf3, 0x71, 0xf8, 0x08, 0x7d, 0xe4, 0x91, 0xa7, 0x83, 0x8b, 0x84, 0xc4, 0x0b, 0xdf, 0x01,
-	0x8c, 0x27, 0x8d, 0x93, 0xd4, 0xb2, 0xc3, 0xa5, 0x9e, 0x37, 0xf3, 0x7b, 0x33, 0xef, 0xcd, 0xef,
+	0xed, 0x9f, 0x24, 0x4e, 0x52, 0xcb, 0x0e, 0x2f, 0xcd, 0xce, 0xee, 0x6f, 0x66, 0x67, 0xe6, 0x37,
-	0xcd, 0xef, 0x35, 0xf0, 0xc9, 0x80, 0xf0, 0x61, 0x7c, 0x66, 0xf5, 0xe9, 0xc8, 0xee, 0xd3, 0x80,
+	0x3b, 0xe3, 0xc2, 0xb3, 0x1e, 0xe1, 0xfd, 0xe8, 0xc2, 0xee, 0xd2, 0x61, 0xbb, 0x4b, 0x7d, 0xee,
-	0xbb, 0x24, 0xc0, 0x91, 0x97, 0x1e, 0xfa, 0x24, 0x88, 0xaf, 0x6c, 0x36, 0x24, 0x23, 0xfb, 0x72,
+	0x12, 0x1f, 0x87, 0x5e, 0x7c, 0x39, 0x20, 0x7e, 0x74, 0xd3, 0x66, 0x7d, 0x32, 0x6c, 0x5f, 0xef,
-	0x47, 0x7e, 0xad, 0x30, 0xa2, 0x9c, 0xa2, 0xce, 0x14, 0x64, 0x45, 0x71, 0xc0, 0xc9, 0x08, 0x5b,
+	0xca, 0x5f, 0x3b, 0x08, 0x29, 0xa7, 0xa8, 0x39, 0x05, 0xd9, 0x61, 0xe4, 0x73, 0x32, 0xc4, 0xb6,
-	0x12, 0x6c, 0x49, 0xd0, 0xe5, 0x4e, 0xeb, 0xfe, 0x80, 0xd2, 0x81, 0x8f, 0x6d, 0x89, 0x3f, 0x8b,
+	0x04, 0xdb, 0x12, 0x74, 0xbd, 0x5b, 0x7f, 0xd8, 0xa3, 0xb4, 0x37, 0xc0, 0x6d, 0x89, 0xbf, 0x88,
-	0xcf, 0x6d, 0x37, 0xb8, 0x4e, 0x9c, 0x5b, 0x0f, 0xe6, 0x97, 0xf0, 0x28, 0xe4, 0x93, 0xc5, 0x8d,
+	0x2e, 0xdb, 0xae, 0x7f, 0xab, 0x94, 0xeb, 0x8f, 0xe6, 0x8f, 0xf0, 0x30, 0xe0, 0xe3, 0xc3, 0xcd,
-	0x01, 0x1d, 0x50, 0x39, 0xb4, 0xc5, 0x48, 0xcd, 0x6e, 0xcd, 0xbb, 0x88, 0x13, 0x19, 0x77, 0x47,
+	0x1e, 0xed, 0x51, 0xb9, 0x6c, 0x8b, 0x95, 0xde, 0xdd, 0x9e, 0x57, 0x11, 0x37, 0x32, 0xee, 0x0e,
-	0xa1, 0x02, 0x3c, 0xca, 0xcd, 0xc5, 0x0d, 0x89, 0xcd, 0xaf, 0x43, 0xcc, 0xec, 0x11, 0x8d, 0x03,
+	0x03, 0x0d, 0x78, 0x92, 0x1a, 0x8b, 0x1b, 0x90, 0x36, 0xbf, 0x0d, 0x30, 0x6b, 0x0f, 0x69, 0xe4,
-	0xae, 0xfc, 0x3e, 0x5d, 0xc2, 0x8f, 0xbb, 0xec, 0x42, 0xfe, 0x49, 0x7c, 0xcd, 0x7f, 0x4b, 0xb0,
+	0x73, 0xad, 0xf7, 0xe9, 0x12, 0x7a, 0xdc, 0x65, 0x57, 0xf2, 0x8f, 0xd2, 0xb5, 0xfe, 0xcd, 0xc1,
-	0x7e, 0x10, 0x61, 0x97, 0xe3, 0xe7, 0x2e, 0xbb, 0x70, 0xf0, 0xcb, 0x18, 0x33, 0x8e, 0x36, 0xa1,
+	0xc6, 0x61, 0x88, 0x5d, 0x8e, 0xcf, 0x5c, 0x76, 0xe5, 0xe0, 0xd7, 0x11, 0x66, 0x1c, 0x6d, 0x41,
-	0x44, 0x3c, 0x43, 0xeb, 0x68, 0xdd, 0x95, 0xfd, 0xda, 0xf8, 0xd5, 0x56, 0xe9, 0xf0, 0x89, 0x53,
+	0x8e, 0x78, 0xa6, 0xd1, 0x34, 0x5a, 0xab, 0x07, 0xa5, 0xd1, 0x9b, 0xed, 0xdc, 0xd1, 0x73, 0x27,
-	0x22, 0x1e, 0xda, 0x84, 0xda, 0x59, 0x1c, 0x78, 0x3e, 0x36, 0x4a, 0x62, 0xcd, 0x51, 0x16, 0x32,
+	0x47, 0x3c, 0xb4, 0x05, 0xa5, 0x8b, 0xc8, 0xf7, 0x06, 0xd8, 0xcc, 0x89, 0x33, 0x47, 0x4b, 0xc8,
-	0xa0, 0xae, 0x6e, 0xd0, 0x28, 0xcb, 0x85, 0x89, 0x89, 0x6c, 0xa8, 0x45, 0x94, 0xf2, 0x73, 0x66,
+	0x84, 0xb2, 0xce, 0xa0, 0x99, 0x97, 0x07, 0x63, 0x11, 0xb5, 0xa1, 0x14, 0x52, 0xca, 0x2f, 0x99,
-	0x54, 0x3a, 0xe5, 0x6e, 0xa3, 0xf7, 0x8e, 0x95, 0xba, 0x75, 0x19, 0x92, 0x75, 0x24, 0x52, 0x71,
+	0x59, 0x68, 0xe6, 0x5b, 0xd5, 0xce, 0xfb, 0x76, 0x2c, 0xeb, 0xd2, 0x25, 0xfb, 0x58, 0x84, 0xe2,
-	0x14, 0x0c, 0xb5, 0x40, 0xe7, 0x38, 0x1a, 0x91, 0xc0, 0xf5, 0x8d, 0x6a, 0x47, 0xeb, 0xea, 0xce,
+	0x68, 0x18, 0xaa, 0x43, 0x85, 0xe3, 0x70, 0x48, 0x7c, 0x77, 0x60, 0x16, 0x9b, 0x46, 0xab, 0xe2,
-	0xad, 0x8d, 0x36, 0xa0, 0xca, 0xb8, 0x47, 0x02, 0xa3, 0x26, 0x0f, 0x49, 0x0c, 0x11, 0x14, 0xe3,
+	0x4c, 0x64, 0xb4, 0x09, 0x45, 0xc6, 0x3d, 0xe2, 0x9b, 0x25, 0x79, 0x89, 0x12, 0x84, 0x53, 0x8c,
-	0x1e, 0x8d, 0xb9, 0x51, 0x4f, 0x82, 0x4a, 0x2c, 0x35, 0x8f, 0xa3, 0xc8, 0xd0, 0x6f, 0xe7, 0x71,
+	0x7b, 0x34, 0xe2, 0x66, 0x59, 0x39, 0xa5, 0x24, 0xbd, 0x8f, 0xc3, 0xd0, 0xac, 0x4c, 0xf6, 0x71,
-	0x14, 0xa1, 0x36, 0x40, 0x7f, 0x88, 0xfb, 0x17, 0x21, 0x25, 0x01, 0x37, 0x56, 0xe4, 0x5a, 0x6a,
+	0x18, 0xa2, 0x06, 0x40, 0xb7, 0x8f, 0xbb, 0x57, 0x01, 0x25, 0x3e, 0x37, 0x57, 0xe5, 0x59, 0x6c,
-	0x06, 0xbd, 0x0f, 0xeb, 0xa1, 0x1b, 0xe1, 0x80, 0x9f, 0xa6, 0x60, 0x20, 0x61, 0x6b, 0xc9, 0xc2,
+	0x07, 0x7d, 0x08, 0x1b, 0x81, 0x1b, 0x62, 0x9f, 0x9f, 0xc7, 0x60, 0x20, 0x61, 0xeb, 0xea, 0xe0,
-	0xc1, 0x14, 0x6c, 0x41, 0x9d, 0x86, 0x9c, 0xd0, 0x80, 0x19, 0x8d, 0x8e, 0xd6, 0x6d, 0xf4, 0x36,
+	0x70, 0x0a, 0xb6, 0xa1, 0x4c, 0x03, 0x4e, 0xa8, 0xcf, 0xcc, 0x6a, 0xd3, 0x68, 0x55, 0x3b, 0x9b,
-	0xac, 0x84, 0x66, 0x6b, 0x42, 0xb3, 0xb5, 0x17, 0x5c, 0x3b, 0x13, 0x90, 0xb9, 0x0d, 0x28, 0x7d,
+	0xb6, 0xa2, 0xd9, 0x1e, 0xd3, 0x6c, 0xef, 0xfb, 0xb7, 0xce, 0x18, 0x64, 0xed, 0x00, 0x8a, 0xa7,
-	0xdd, 0x2c, 0xa4, 0x01, 0xc3, 0x68, 0x0d, 0xca, 0xa1, 0xba, 0xf0, 0xa6, 0x23, 0x86, 0xe6, 0x2f,
+	0x9b, 0x05, 0xd4, 0x67, 0x18, 0xad, 0x43, 0x3e, 0xd0, 0x09, 0xaf, 0x39, 0x62, 0x69, 0xfd, 0x62,
-	0x1a, 0xac, 0x3e, 0xc1, 0x3e, 0xe6, 0x38, 0x1b, 0x84, 0xb6, 0xa0, 0x81, 0xaf, 0x08, 0x3f, 0x65,
+	0xc0, 0xda, 0x73, 0x3c, 0xc0, 0x1c, 0x27, 0x83, 0xd0, 0x36, 0x54, 0xf1, 0x0d, 0xe1, 0xe7, 0x8c,
-	0xdc, 0xe5, 0x31, 0x93, 0x9c, 0x34, 0x1d, 0x10, 0x53, 0x27, 0x72, 0x06, 0xed, 0xc1, 0x8a, 0xb0,
+	0xbb, 0x3c, 0x62, 0x92, 0x93, 0x9a, 0x03, 0x62, 0xeb, 0x54, 0xee, 0xa0, 0x7d, 0x58, 0x15, 0x12,
-	0xb0, 0x77, 0xea, 0x72, 0xc9, 0x4c, 0xa3, 0xd7, 0x5a, 0x88, 0xef, 0xf9, 0xa4, 0x0c, 0xf7, 0xf5,
+	0xf6, 0xce, 0x5d, 0x2e, 0x99, 0xa9, 0x76, 0xea, 0x0b, 0xfe, 0x9d, 0x8d, 0xcb, 0xf0, 0xa0, 0x72,
-	0x9b, 0x57, 0x5b, 0xf7, 0x7e, 0xfd, 0x6b, 0x4b, 0x73, 0xf4, 0xc4, 0x6d, 0x8f, 0x9b, 0x16, 0x6c,
+	0xf7, 0x66, 0x7b, 0xe5, 0xd7, 0x3f, 0xb7, 0x0d, 0xa7, 0xa2, 0xd4, 0xf6, 0xb9, 0x65, 0xc3, 0xa6,
-	0x24, 0x71, 0x1c, 0x47, 0xb4, 0x8f, 0x19, 0xcb, 0x29, 0x11, 0xf3, 0x37, 0x0d, 0xd0, 0xd3, 0x2b,
+	0xf2, 0xe3, 0x24, 0xa4, 0x5d, 0xcc, 0x58, 0x4a, 0x89, 0x58, 0xbf, 0x19, 0x80, 0x5e, 0xdc, 0xe0,
-	0xdc, 0x2f, 0x06, 0x9f, 0xa1, 0xbb, 0x94, 0x45, 0x77, 0xf9, 0x6e, 0xba, 0x2b, 0x19, 0x74, 0x57,
+	0x6e, 0x36, 0xf8, 0x0c, 0xdd, 0xb9, 0x24, 0xba, 0xf3, 0xf7, 0xd3, 0x5d, 0x48, 0xa0, 0xbb, 0x38,
-	0x67, 0xe8, 0xee, 0x42, 0x85, 0x85, 0xb8, 0x2f, 0x6b, 0x26, 0x8b, 0x1e, 0x89, 0x30, 0xdf, 0x85,
+	0x43, 0x77, 0x0b, 0x0a, 0x2c, 0xc0, 0x5d, 0x59, 0x33, 0x49, 0xf4, 0x48, 0x84, 0xf5, 0x00, 0xde,
-	0xb7, 0x66, 0x22, 0xcf, 0x24, 0xe7, 0x5b, 0x58, 0x73, 0x30, 0x23, 0x3f, 0xe1, 0x63, 0x7e, 0x9d,
+	0x9b, 0xf1, 0x5c, 0xe5, 0xdd, 0xfa, 0x16, 0xd6, 0x1d, 0xcc, 0xc8, 0x4f, 0xf8, 0x84, 0xdf, 0xa6,
-	0x97, 0xe0, 0x06, 0x54, 0x7f, 0x24, 0x1e, 0x1f, 0x2a, 0x76, 0x12, 0x43, 0x04, 0x3b, 0xc4, 0x64,
+	0x85, 0xb3, 0x09, 0xc5, 0x1f, 0x89, 0xc7, 0xfb, 0x9a, 0x0b, 0x25, 0x08, 0xd7, 0xfa, 0x98, 0xf4,
-	0x30, 0x4c, 0x58, 0x69, 0x3a, 0xca, 0x32, 0xb7, 0xe1, 0x0d, 0x41, 0x1d, 0xce, 0xbb, 0xe5, 0x7f,
+	0xfa, 0x8a, 0x83, 0x9a, 0xa3, 0x25, 0x6b, 0x07, 0xde, 0x11, 0x44, 0xe1, 0xb4, 0x9c, 0xfe, 0x63,
-	0x34, 0x68, 0x2a, 0xa0, 0x8a, 0x72, 0xd9, 0x27, 0xab, 0xb2, 0x2a, 0x4f, 0xab, 0x69, 0x57, 0x5c,
+	0x40, 0x4d, 0x03, 0x75, 0x2d, 0x2c, 0xfb, 0x40, 0x75, 0xed, 0xe4, 0xa7, 0xb5, 0xb3, 0x27, 0xd2,
-	0xa0, 0x2c, 0x24, 0x71, 0xb1, 0xab, 0xbd, 0x07, 0xe9, 0xa7, 0x7a, 0xb9, 0xa3, 0x5e, 0x6b, 0x52,
+	0x25, 0xcb, 0x46, 0xa4, 0x71, 0xad, 0xf3, 0x28, 0xfe, 0x30, 0xaf, 0x77, 0xf5, 0xdb, 0x54, 0x75,
-	0x59, 0x8e, 0x82, 0x4e, 0x39, 0xaa, 0xde, 0xcd, 0x51, 0x2d, 0x83, 0xa3, 0xfa, 0x0c, 0x47, 0xe9,
+	0xe4, 0x68, 0xe8, 0x94, 0x91, 0xe2, 0xfd, 0x8c, 0x94, 0x12, 0x18, 0x29, 0xcf, 0x30, 0x12, 0xe7,
-	0x2a, 0xd0, 0x67, 0xab, 0xc0, 0x7c, 0x06, 0x8d, 0x2f, 0x89, 0xef, 0x17, 0x90, 0x26, 0x46, 0x06,
+	0xbc, 0x32, 0xcb, 0xb9, 0xf5, 0x12, 0xaa, 0x5f, 0x92, 0xc1, 0x20, 0x43, 0x23, 0x62, 0xa4, 0x37,
-	0x93, 0x32, 0x6a, 0x3a, 0xca, 0x12, 0x79, 0xba, 0xbe, 0x2f, 0xf3, 0xd4, 0x1d, 0x31, 0x34, 0x3f,
+	0x2e, 0x9a, 0x9a, 0xa3, 0x25, 0x11, 0xa7, 0x3b, 0x18, 0xc8, 0x38, 0x2b, 0x8e, 0x58, 0x5a, 0x9f,
-	0x87, 0xd5, 0x03, 0x9f, 0x32, 0x7c, 0xf8, 0xac, 0x00, 0x77, 0x49, 0x72, 0x49, 0x65, 0x26, 0x86,
+	0xc3, 0xda, 0xe1, 0x80, 0x32, 0x7c, 0xf4, 0x32, 0x03, 0x77, 0x2a, 0x38, 0x55, 0x87, 0x4a, 0xb0,
-	0xf9, 0x1e, 0xbc, 0xf9, 0x15, 0x61, 0xfc, 0x98, 0x78, 0xb9, 0x8f, 0x61, 0x1b, 0xd6, 0xa6, 0x50,
+	0x3e, 0x80, 0x77, 0xbf, 0x22, 0x8c, 0x9f, 0x10, 0x2f, 0xb5, 0xf4, 0x77, 0x60, 0x7d, 0x0a, 0xd5,
-	0x45, 0x14, 0x82, 0x4a, 0x48, 0x3c, 0x66, 0x68, 0x9d, 0x72, 0xb7, 0xe9, 0xc8, 0xb1, 0xf9, 0x3d,
+	0x44, 0x21, 0x28, 0x04, 0xc4, 0x63, 0xa6, 0xd1, 0xcc, 0xb7, 0x6a, 0x8e, 0x5c, 0x5b, 0xdf, 0xc3,
-	0xbc, 0x3d, 0xd5, 0x94, 0xb4, 0x10, 0x0b, 0xb0, 0xcb, 0x87, 0xc9, 0xd6, 0x8e, 0x1c, 0xa7, 0x25,
+	0x83, 0x69, 0x07, 0x89, 0xb7, 0x5d, 0x01, 0x76, 0x79, 0x5f, 0x99, 0x76, 0xe4, 0x3a, 0xde, 0x60,
-	0xa7, 0x54, 0x44, 0x72, 0x1e, 0xc2, 0xda, 0xc9, 0x90, 0x8c, 0x0e, 0x83, 0x73, 0x7a, 0x1b, 0xc4,
+	0x72, 0x59, 0x1a, 0xcc, 0x63, 0x58, 0x3f, 0xed, 0x93, 0xe1, 0x91, 0x7f, 0x49, 0x27, 0x4e, 0x3c,
-	0x7d, 0xd0, 0x45, 0x93, 0x3b, 0x9d, 0x16, 0x76, 0x5d, 0xd8, 0xc7, 0xc4, 0x33, 0xbf, 0x80, 0xf5,
+	0x84, 0x8a, 0x18, 0x69, 0xe7, 0xd3, 0xf6, 0x51, 0x16, 0xf2, 0x09, 0xf1, 0xac, 0x2f, 0x60, 0xe3,
-	0x17, 0xa1, 0x37, 0xd7, 0x10, 0x7a, 0xb0, 0x12, 0x61, 0x46, 0xe3, 0xa8, 0x8f, 0x99, 0x74, 0xc8,
+	0x55, 0xe0, 0xcd, 0xb5, 0xff, 0x0e, 0xac, 0x86, 0x98, 0xd1, 0x28, 0xec, 0x62, 0x26, 0x15, 0x92,
-	0x3a, 0x75, 0x0a, 0xeb, 0xfd, 0x01, 0x50, 0x11, 0x07, 0xa3, 0x21, 0x54, 0x65, 0xad, 0x22, 0xcb,
+	0x6e, 0x9d, 0xc2, 0x74, 0x2d, 0x87, 0x3c, 0x2d, 0x49, 0xcf, 0x64, 0x29, 0x0b, 0x5c, 0x4a, 0x29,
-	0xca, 0x6b, 0xb9, 0x56, 0xba, 0xfa, 0x5b, 0x76, 0x61, 0xbc, 0x4a, 0x8b, 0x41, 0x2d, 0x51, 0x57,
+	0xeb, 0x92, 0xcd, 0x4d, 0x4a, 0xb6, 0xf3, 0x37, 0x40, 0x41, 0xc4, 0x86, 0xfa, 0x50, 0x94, 0xcf,
-	0xb4, 0x9b, 0xef, 0xba, 0xd0, 0xf6, 0x5a, 0x1f, 0x2e, 0xe7, 0xa4, 0x0e, 0x7d, 0x2c, 0xd3, 0x8b,
+	0x01, 0xd9, 0x76, 0xda, 0x0c, 0xb7, 0xe3, 0x0f, 0xac, 0xde, 0xce, 0x8c, 0xd7, 0xce, 0x31, 0x28,
-	0x38, 0xda, 0x5c, 0xb8, 0x91, 0xa7, 0xe2, 0x9f, 0x82, 0x56, 0xc6, 0x3c, 0x72, 0xa0, 0x96, 0x48,
+	0xa9, 0x76, 0x8d, 0xf6, 0xd2, 0x55, 0x17, 0xe6, 0x68, 0xfd, 0xe3, 0xe5, 0x94, 0xf4, 0xa5, 0x2a,
-	0x6b, 0xa6, 0xe7, 0x07, 0xf9, 0x01, 0xcd, 0x35, 0x89, 0x6b, 0x68, 0xce, 0xc8, 0x35, 0x7a, 0x54,
+	0xbc, 0x90, 0x67, 0x0c, 0x6f, 0x92, 0xf3, 0x8c, 0xe1, 0xc5, 0x72, 0xef, 0x40, 0x49, 0x35, 0x77,
-	0x74, 0x8b, 0x59, 0xc1, 0xfe, 0x1f, 0x47, 0xbf, 0x04, 0x7d, 0x52, 0xec, 0x68, 0x27, 0xdf, 0x7b,
+	0xb4, 0xb5, 0xc0, 0xef, 0x0b, 0xf1, 0x41, 0x53, 0xff, 0x28, 0xdd, 0xe4, 0xdc, 0x98, 0xba, 0x85,
-	0xee, 0x0d, 0xb5, 0x7a, 0xcb, 0xb8, 0x4c, 0xaf, 0xfe, 0xd8, 0x8d, 0x19, 0x5e, 0xfa, 0xea, 0x3f,
+	0xda, 0xcc, 0xc0, 0x40, 0x4f, 0xb2, 0x9a, 0x98, 0x1d, 0x19, 0xff, 0xe3, 0xea, 0xd7, 0x50, 0x19,
-	0x86, 0x9a, 0x83, 0x59, 0x3c, 0x5a, 0xde, 0xf3, 0x07, 0x80, 0x54, 0xfb, 0x7f, 0x5c, 0xa0, 0x62,
+	0x3f, 0x40, 0xb4, 0x9b, 0xae, 0x3d, 0xf7, 0xae, 0xeb, 0x9d, 0x65, 0x54, 0xf4, 0x95, 0x4f, 0xa1,
-	0xee, 0x7a, 0xd8, 0x99, 0xdb, 0x1f, 0x41, 0x45, 0xa8, 0x1d, 0x7a, 0x98, 0xbf, 0x71, 0x4a, 0x15,
+	0x78, 0xe2, 0x46, 0x2c, 0x39, 0x81, 0x09, 0xfb, 0xe8, 0x13, 0x28, 0x39, 0x98, 0x45, 0xc3, 0xe5,
-	0x33, 0xb7, 0x63, 0x50, 0x11, 0x2d, 0x0d, 0x15, 0xa8, 0xec, 0xc5, 0xa6, 0xdd, 0xfa, 0x68, 0x49,
+	0x35, 0x7f, 0x00, 0x88, 0x7d, 0x80, 0x3c, 0xcd, 0x50, 0x62, 0xf7, 0x35, 0x9b, 0x44, 0xf3, 0xc7,
-	0x2f, 0xc5, 0xca, 0x37, 0xb0, 0x72, 0xdb, 0x1e, 0x51, 0x01, 0x5a, 0xe7, 0x7b, 0x69, 0x66, 0x36,
+	0x50, 0x10, 0x1d, 0x18, 0x3d, 0x4e, 0x37, 0x1c, 0xeb, 0xd4, 0x89, 0xe6, 0xce, 0xa0, 0x20, 0x86,
-	0x27, 0x50, 0x57, 0xca, 0x8d, 0x0a, 0x94, 0xe7, 0xac, 0xc8, 0x67, 0x6e, 0xfa, 0x35, 0xe8, 0x13,
+	0x2a, 0xca, 0xf0, 0x14, 0x16, 0x3f, 0x1b, 0x12, 0xad, 0x7e, 0x03, 0xab, 0x93, 0x99, 0x8c, 0x32,
-	0x79, 0xcc, 0x2c, 0x86, 0x02, 0x49, 0x2c, 0x48, 0xec, 0x0b, 0xa8, 0x25, 0x3a, 0x5a, 0x44, 0x8b,
+	0xf0, 0x36, 0x3f, 0xc0, 0x13, 0x0d, 0x9f, 0x42, 0x59, 0x8f, 0x0b, 0x94, 0xa1, 0xfe, 0x66, 0x27,
-	0x16, 0x14, 0x37, 0x2b, 0xdc, 0xfd, 0xa3, 0x9b, 0xd7, 0xed, 0x7b, 0x7f, 0xbe, 0x6e, 0xdf, 0xfb,
+	0x4b, 0xa2, 0xd1, 0xaf, 0xa1, 0x32, 0xee, 0xc9, 0x89, 0x6c, 0x67, 0x08, 0x62, 0xa1, 0xaf, 0xbf,
-	0x79, 0xdc, 0xd6, 0x6e, 0xc6, 0x6d, 0xed, 0xf7, 0x71, 0x5b, 0xfb, 0x7b, 0xdc, 0xd6, 0xbe, 0xdb,
+	0x82, 0x92, 0x6a, 0xde, 0x59, 0xba, 0xd3, 0x42, 0x9b, 0x4f, 0x72, 0xf7, 0xe0, 0xf8, 0xee, 0x6d,
-	0x5d, 0xee, 0xa7, 0xd0, 0x67, 0xe2, 0x7b, 0x56, 0x93, 0xdb, 0xef, 0xfe, 0x17, 0x00, 0x00, 0xff,
+	0x63, 0xe5, 0x8f, 0xb7, 0x8d, 0x95, 0x9f, 0x47, 0x0d, 0xe3, 0x6e, 0xd4, 0x30, 0x7e, 0x1f, 0x35,
-	0xff, 0xa3, 0x6e, 0xef, 0x88, 0x48, 0x0d, 0x00, 0x00,
+	0x8c, 0xbf, 0x46, 0x0d, 0xe3, 0xbb, 0xbd, 0xe5, 0xfe, 0xdb, 0xfa, 0x4c, 0xfc, 0x5e, 0x94, 0xa4,
+	0xf9, 0xbd, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x05, 0x95, 0x8a, 0x43, 0xab, 0x0d, 0x00, 0x00,
 }

linux/shim/v1/shim.proto

@@ -21,7 +21,7 @@ service Shim {
 
 	rpc Create(CreateTaskRequest) returns (CreateTaskResponse);
 
-	rpc Start(google.protobuf.Empty) returns (google.protobuf.Empty);
+	rpc Start(StartRequest) returns (StartResponse);
 
 	rpc Delete(google.protobuf.Empty) returns (DeleteResponse);
 
@@ -37,7 +37,7 @@ service Shim {
 
 	rpc Kill(KillRequest) returns (google.protobuf.Empty);
 
-	rpc Exec(ExecProcessRequest) returns (ExecProcessResponse);
+	rpc Exec(ExecProcessRequest) returns (google.protobuf.Empty);
 
 	rpc ResizePty(ResizePtyRequest) returns (google.protobuf.Empty);
 
@@ -87,7 +87,6 @@ message ExecProcessRequest {
 }
 
 message ExecProcessResponse {
-	uint32 pid = 1;
 }
 
 message ResizePtyRequest {
@@ -142,3 +141,12 @@ message ShimInfoResponse {
 message UpdateTaskRequest {
 	google.protobuf.Any resources = 1;
 }
+
+message StartRequest {
+	string id = 1;
+}
+
+message StartResponse {
+	string id = 1;
+	uint32 pid = 2;
+}

linux/task.go

@@ -40,11 +40,13 @@ func (t *Task) Info() runtime.TaskInfo {
 }
 
 func (t *Task) Start(ctx context.Context) error {
-	_, err := t.shim.Start(ctx, empty)
+	_, err := t.shim.Start(ctx, &shim.StartRequest{
+		ID: t.id,
+	})
 	if err != nil {
-		err = errdefs.FromGRPC(err)
+		return errdefs.FromGRPC(err)
 	}
-	return err
+	return nil
 }
 
 func (t *Task) State(ctx context.Context) (runtime.State, error) {
@@ -116,6 +118,11 @@ func (t *Task) Exec(ctx context.Context, id string, opts runtime.ExecOpts) (runt
 	if _, err := t.shim.Exec(ctx, request); err != nil {
 		return nil, errdefs.FromGRPC(err)
 	}
+	if _, err := t.shim.Start(ctx, &shim.StartRequest{
+		ID: id,
+	}); err != nil {
+		return nil, errdefs.FromGRPC(err)
+	}
 	return &Process{
 		id: id,
 		t:  t,