diff --git a/api/services/shim/shim.pb.go b/api/services/shim/shim.pb.go
index 4c4c91df7..fa0f44e90 100644
--- a/api/services/shim/shim.pb.go
+++ b/api/services/shim/shim.pb.go
@@ -26,9 +26,8 @@
 		ExitRequest
 		KillRequest
 		CloseStdinRequest
-		PsRequest
-		Ps
-		PsResponse
+		ProcessesRequest
+		ProcessesResponse
 */
 package shim
 
@@ -221,30 +220,21 @@ func (m *CloseStdinRequest) Reset()                    { *m = CloseStdinRequest{
 func (*CloseStdinRequest) ProtoMessage()               {}
 func (*CloseStdinRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{16} }
 
-type PsRequest struct {
+type ProcessesRequest struct {
 	ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
 }
 
-func (m *PsRequest) Reset()                    { *m = PsRequest{} }
-func (*PsRequest) ProtoMessage()               {}
-func (*PsRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{17} }
+func (m *ProcessesRequest) Reset()                    { *m = ProcessesRequest{} }
+func (*ProcessesRequest) ProtoMessage()               {}
+func (*ProcessesRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{17} }
 
-type Ps struct {
-	Pid         uint32               `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"`
-	RuntimeData *google_protobuf.Any `protobuf:"bytes,2,opt,name=runtime_data,json=runtimeData" json:"runtime_data,omitempty"`
+type ProcessesResponse struct {
+	Processes []*containerd_v1_types1.Process `protobuf:"bytes,1,rep,name=processes" json:"processes,omitempty"`
 }
 
-func (m *Ps) Reset()                    { *m = Ps{} }
-func (*Ps) ProtoMessage()               {}
-func (*Ps) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{18} }
-
-type PsResponse struct {
-	Ps []*Ps `protobuf:"bytes,1,rep,name=ps" json:"ps,omitempty"`
-}
-
-func (m *PsResponse) Reset()                    { *m = PsResponse{} }
-func (*PsResponse) ProtoMessage()               {}
-func (*PsResponse) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{19} }
+func (m *ProcessesResponse) Reset()                    { *m = ProcessesResponse{} }
+func (*ProcessesResponse) ProtoMessage()               {}
+func (*ProcessesResponse) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{18} }
 
 func init() {
 	proto.RegisterType((*CreateRequest)(nil), "containerd.v1.services.shim.CreateRequest")
@@ -264,9 +254,8 @@ func init() {
 	proto.RegisterType((*ExitRequest)(nil), "containerd.v1.services.shim.ExitRequest")
 	proto.RegisterType((*KillRequest)(nil), "containerd.v1.services.shim.KillRequest")
 	proto.RegisterType((*CloseStdinRequest)(nil), "containerd.v1.services.shim.CloseStdinRequest")
-	proto.RegisterType((*PsRequest)(nil), "containerd.v1.services.shim.PsRequest")
-	proto.RegisterType((*Ps)(nil), "containerd.v1.services.shim.Ps")
-	proto.RegisterType((*PsResponse)(nil), "containerd.v1.services.shim.PsResponse")
+	proto.RegisterType((*ProcessesRequest)(nil), "containerd.v1.services.shim.ProcessesRequest")
+	proto.RegisterType((*ProcessesResponse)(nil), "containerd.v1.services.shim.ProcessesResponse")
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -284,7 +273,7 @@ type ShimClient interface {
 	Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
 	Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error)
 	State(ctx context.Context, in *StateRequest, opts ...grpc.CallOption) (*StateResponse, error)
-	Ps(ctx context.Context, in *PsRequest, opts ...grpc.CallOption) (*PsResponse, error)
+	Processes(ctx context.Context, in *ProcessesRequest, opts ...grpc.CallOption) (*ProcessesResponse, error)
 	Pause(ctx context.Context, in *PauseRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
 	Resume(ctx context.Context, in *ResumeRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
 	Exit(ctx context.Context, in *ExitRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
@@ -339,9 +328,9 @@ func (c *shimClient) State(ctx context.Context, in *StateRequest, opts ...grpc.C
 	return out, nil
 }
 
-func (c *shimClient) Ps(ctx context.Context, in *PsRequest, opts ...grpc.CallOption) (*PsResponse, error) {
-	out := new(PsResponse)
-	err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Ps", in, out, c.cc, opts...)
+func (c *shimClient) Processes(ctx context.Context, in *ProcessesRequest, opts ...grpc.CallOption) (*ProcessesResponse, error) {
+	out := new(ProcessesResponse)
+	err := grpc.Invoke(ctx, "/containerd.v1.services.shim.Shim/Processes", in, out, c.cc, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -450,7 +439,7 @@ type ShimServer interface {
 	Start(context.Context, *StartRequest) (*google_protobuf1.Empty, error)
 	Delete(context.Context, *DeleteRequest) (*DeleteResponse, error)
 	State(context.Context, *StateRequest) (*StateResponse, error)
-	Ps(context.Context, *PsRequest) (*PsResponse, error)
+	Processes(context.Context, *ProcessesRequest) (*ProcessesResponse, error)
 	Pause(context.Context, *PauseRequest) (*google_protobuf1.Empty, error)
 	Resume(context.Context, *ResumeRequest) (*google_protobuf1.Empty, error)
 	Exit(context.Context, *ExitRequest) (*google_protobuf1.Empty, error)
@@ -537,20 +526,20 @@ func _Shim_State_Handler(srv interface{}, ctx context.Context, dec func(interfac
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Shim_Ps_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(PsRequest)
+func _Shim_Processes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ProcessesRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(ShimServer).Ps(ctx, in)
+		return srv.(ShimServer).Processes(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/containerd.v1.services.shim.Shim/Ps",
+		FullMethod: "/containerd.v1.services.shim.Shim/Processes",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ShimServer).Ps(ctx, req.(*PsRequest))
+		return srv.(ShimServer).Processes(ctx, req.(*ProcessesRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -723,8 +712,8 @@ var _Shim_serviceDesc = grpc.ServiceDesc{
 			Handler:    _Shim_State_Handler,
 		},
 		{
-			MethodName: "Ps",
-			Handler:    _Shim_Ps_Handler,
+			MethodName: "Processes",
+			Handler:    _Shim_Processes_Handler,
 		},
 		{
 			MethodName: "Pause",
@@ -1295,7 +1284,7 @@ func (m *CloseStdinRequest) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func (m *PsRequest) Marshal() (dAtA []byte, err error) {
+func (m *ProcessesRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -1305,7 +1294,7 @@ func (m *PsRequest) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *PsRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *ProcessesRequest) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -1319,7 +1308,7 @@ func (m *PsRequest) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func (m *Ps) Marshal() (dAtA []byte, err error) {
+func (m *ProcessesResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -1329,46 +1318,13 @@ func (m *Ps) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Ps) MarshalTo(dAtA []byte) (int, error) {
+func (m *ProcessesResponse) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.Pid != 0 {
-		dAtA[i] = 0x8
-		i++
-		i = encodeVarintShim(dAtA, i, uint64(m.Pid))
-	}
-	if m.RuntimeData != nil {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintShim(dAtA, i, uint64(m.RuntimeData.Size()))
-		n3, err := m.RuntimeData.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n3
-	}
-	return i, nil
-}
-
-func (m *PsResponse) 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 *PsResponse) MarshalTo(dAtA []byte) (int, error) {
-	var i int
-	_ = i
-	var l int
-	_ = l
-	if len(m.Ps) > 0 {
-		for _, msg := range m.Ps {
+	if len(m.Processes) > 0 {
+		for _, msg := range m.Processes {
 			dAtA[i] = 0xa
 			i++
 			i = encodeVarintShim(dAtA, i, uint64(msg.Size()))
@@ -1631,7 +1587,7 @@ func (m *CloseStdinRequest) Size() (n int) {
 	return n
 }
 
-func (m *PsRequest) Size() (n int) {
+func (m *ProcessesRequest) Size() (n int) {
 	var l int
 	_ = l
 	l = len(m.ID)
@@ -1641,24 +1597,11 @@ func (m *PsRequest) Size() (n int) {
 	return n
 }
 
-func (m *Ps) Size() (n int) {
+func (m *ProcessesResponse) Size() (n int) {
 	var l int
 	_ = l
-	if m.Pid != 0 {
-		n += 1 + sovShim(uint64(m.Pid))
-	}
-	if m.RuntimeData != nil {
-		l = m.RuntimeData.Size()
-		n += 1 + l + sovShim(uint64(l))
-	}
-	return n
-}
-
-func (m *PsResponse) Size() (n int) {
-	var l int
-	_ = l
-	if len(m.Ps) > 0 {
-		for _, e := range m.Ps {
+	if len(m.Processes) > 0 {
+		for _, e := range m.Processes {
 			l = e.Size()
 			n += 1 + l + sovShim(uint64(l))
 		}
@@ -1866,33 +1809,22 @@ func (this *CloseStdinRequest) String() string {
 	}, "")
 	return s
 }
-func (this *PsRequest) String() string {
+func (this *ProcessesRequest) String() string {
 	if this == nil {
 		return "nil"
 	}
-	s := strings.Join([]string{`&PsRequest{`,
+	s := strings.Join([]string{`&ProcessesRequest{`,
 		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
 		`}`,
 	}, "")
 	return s
 }
-func (this *Ps) String() string {
+func (this *ProcessesResponse) String() string {
 	if this == nil {
 		return "nil"
 	}
-	s := strings.Join([]string{`&Ps{`,
-		`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
-		`RuntimeData:` + strings.Replace(fmt.Sprintf("%v", this.RuntimeData), "Any", "google_protobuf.Any", 1) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-func (this *PsResponse) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&PsResponse{`,
-		`Ps:` + strings.Replace(fmt.Sprintf("%v", this.Ps), "Ps", "Ps", 1) + `,`,
+	s := strings.Join([]string{`&ProcessesResponse{`,
+		`Processes:` + strings.Replace(fmt.Sprintf("%v", this.Processes), "Process", "containerd_v1_types1.Process", 1) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -3574,7 +3506,7 @@ func (m *CloseStdinRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *PsRequest) Unmarshal(dAtA []byte) error {
+func (m *ProcessesRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -3597,10 +3529,10 @@ func (m *PsRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: PsRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: ProcessesRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: PsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ProcessesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -3653,7 +3585,7 @@ func (m *PsRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *Ps) Unmarshal(dAtA []byte) error {
+func (m *ProcessesResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -3676,34 +3608,15 @@ func (m *Ps) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: Ps: wiretype end group for non-group")
+			return fmt.Errorf("proto: ProcessesResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Ps: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ProcessesResponse: 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
-				}
-			}
-		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RuntimeData", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Processes", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -3727,91 +3640,8 @@ func (m *Ps) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.RuntimeData == nil {
-				m.RuntimeData = &google_protobuf.Any{}
-			}
-			if err := m.RuntimeData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			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 *PsResponse) 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: PsResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: PsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Ps", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowShim
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthShim
-			}
-			postIndex := iNdEx + msglen
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Ps = append(m.Ps, &Ps{})
-			if err := m.Ps[len(m.Ps)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Processes = append(m.Processes, &containerd_v1_types1.Process{})
+			if err := m.Processes[len(m.Processes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -3946,67 +3776,65 @@ func init() {
 }
 
 var fileDescriptorShim = []byte{
-	// 983 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0xcd, 0x6f, 0xe3, 0x44,
-	0x14, 0xaf, 0x93, 0xd4, 0x4d, 0x5f, 0xea, 0x2e, 0x8c, 0xaa, 0xca, 0x9b, 0xa2, 0xa4, 0x18, 0x01,
-	0xdd, 0x45, 0x72, 0xa0, 0x7b, 0x40, 0x42, 0xec, 0xa1, 0xdd, 0x14, 0xb1, 0xb0, 0x88, 0x68, 0xba,
-	0x9c, 0x90, 0xa8, 0xdc, 0x78, 0x9a, 0x8c, 0x64, 0x7b, 0x8c, 0x67, 0x5c, 0x36, 0x37, 0xce, 0x9c,
-	0xb8, 0xf2, 0xef, 0x70, 0xea, 0x81, 0x03, 0x47, 0x4e, 0x0b, 0x9b, 0xbf, 0x04, 0xcd, 0x87, 0xf3,
-	0xd1, 0xc6, 0x71, 0xf7, 0x62, 0xcd, 0x3c, 0xff, 0xe6, 0xcd, 0xef, 0xfd, 0xde, 0xc7, 0xc0, 0xd3,
-	0x11, 0x15, 0xe3, 0xfc, 0xd2, 0x1f, 0xb2, 0xb8, 0x37, 0x64, 0x89, 0x08, 0x68, 0x42, 0xb2, 0x70,
-	0x71, 0x19, 0xa4, 0xb4, 0xc7, 0x49, 0x76, 0x4d, 0x87, 0x84, 0xf7, 0xf8, 0x98, 0xc6, 0xea, 0xe3,
-	0xa7, 0x19, 0x13, 0x0c, 0x1d, 0xcc, 0x81, 0xfe, 0xf5, 0x67, 0x7e, 0x81, 0xf3, 0x25, 0xa4, 0xfd,
-	0x70, 0xc4, 0xd8, 0x28, 0x22, 0x3d, 0x05, 0xbd, 0xcc, 0xaf, 0x7a, 0x41, 0x32, 0xd1, 0xe7, 0xda,
-	0x07, 0xb7, 0x7f, 0x91, 0x38, 0x15, 0xc5, 0xcf, 0xbd, 0x11, 0x1b, 0x31, 0xb5, 0xec, 0xc9, 0x95,
-	0xb1, 0x7e, 0x79, 0x2f, 0xa6, 0x62, 0x92, 0x12, 0xde, 0x8b, 0x59, 0x9e, 0x08, 0xfd, 0x35, 0xa7,
-	0xfb, 0x6f, 0x71, 0x7a, 0x66, 0x9c, 0xaf, 0x8c, 0x97, 0xee, 0x6d, 0xda, 0x82, 0xc6, 0x84, 0x8b,
-	0x20, 0x4e, 0x35, 0xc0, 0xfb, 0xad, 0x06, 0xce, 0xb3, 0x8c, 0x04, 0x82, 0x60, 0xf2, 0x73, 0x4e,
-	0xb8, 0x40, 0xfb, 0x50, 0xa3, 0xa1, 0x6b, 0x1d, 0x5a, 0x47, 0xdb, 0xa7, 0xf6, 0xf4, 0x75, 0xb7,
-	0xf6, 0xbc, 0x8f, 0x6b, 0x34, 0x44, 0xfb, 0x60, 0x5f, 0xe6, 0x49, 0x18, 0x11, 0xb7, 0x26, 0xff,
-	0x61, 0xb3, 0x43, 0x2e, 0x6c, 0x65, 0x79, 0x22, 0xfd, 0xba, 0x75, 0xf5, 0xa3, 0xd8, 0xa2, 0x87,
-	0xd0, 0x4c, 0xd8, 0x45, 0x4a, 0xaf, 0x99, 0x70, 0x1b, 0x87, 0xd6, 0x51, 0x13, 0x6f, 0x25, 0x6c,
-	0x20, 0xb7, 0xa8, 0x0d, 0x4d, 0x41, 0xb2, 0x98, 0x26, 0x41, 0xe4, 0x6e, 0xaa, 0x5f, 0xb3, 0x3d,
-	0xda, 0x83, 0x4d, 0x2e, 0x42, 0x9a, 0xb8, 0xb6, 0x72, 0xa7, 0x37, 0xf2, 0x7a, 0x2e, 0x42, 0x96,
-	0x0b, 0x77, 0x4b, 0x5f, 0xaf, 0x77, 0xc6, 0x4e, 0xb2, 0xcc, 0x6d, 0xce, 0xec, 0x24, 0xcb, 0xd0,
-	0x31, 0xd8, 0x19, 0x63, 0xe2, 0x8a, 0xbb, 0xdb, 0x87, 0xf5, 0xa3, 0xd6, 0x71, 0xdb, 0x5f, 0xce,
-	0xbc, 0x52, 0xce, 0xff, 0x4e, 0x2a, 0x8e, 0x0d, 0xd2, 0xf3, 0x60, 0xb7, 0xd0, 0x82, 0xa7, 0x2c,
-	0xe1, 0x04, 0xbd, 0x03, 0xf5, 0xd4, 0xa8, 0xe1, 0x60, 0xb9, 0xf4, 0x76, 0x61, 0xe7, 0x5c, 0x04,
-	0x99, 0x30, 0x72, 0x79, 0xef, 0x83, 0xd3, 0x27, 0x11, 0x99, 0xeb, 0x77, 0xf7, 0x88, 0x80, 0xdd,
-	0x02, 0x62, 0xdc, 0x76, 0xa1, 0x45, 0x5e, 0x51, 0x71, 0xc1, 0x45, 0x20, 0x72, 0x6e, 0xb0, 0x20,
-	0x4d, 0xe7, 0xca, 0x82, 0x4e, 0x60, 0x5b, 0xee, 0x48, 0x78, 0x11, 0x08, 0xa5, 0xb7, 0x0c, 0x40,
-	0xe7, 0xd2, 0x2f, 0x72, 0xe9, 0xbf, 0x2c, 0x72, 0x79, 0xda, 0xbc, 0x79, 0xdd, 0xdd, 0xf8, 0xfd,
-	0xdf, 0xae, 0x85, 0x9b, 0xfa, 0xd8, 0x89, 0xf0, 0xfe, 0xb0, 0xa0, 0x75, 0xf6, 0x8a, 0x0c, 0x0b,
-	0x5e, 0x8b, 0x92, 0x5b, 0x65, 0x92, 0xd7, 0x56, 0x4b, 0x5e, 0x2f, 0x91, 0xbc, 0xb1, 0x24, 0xf9,
-	0x11, 0x34, 0x78, 0x4a, 0x86, 0x2a, 0xa1, 0xad, 0xe3, 0xbd, 0x3b, 0x7c, 0x4f, 0x92, 0x09, 0x56,
-	0x08, 0xaf, 0x0f, 0x36, 0x8e, 0x68, 0x4c, 0x05, 0x42, 0xd0, 0x90, 0x99, 0xd0, 0xf5, 0x86, 0xd5,
-	0x5a, 0xda, 0xc6, 0x41, 0x16, 0x2a, 0x32, 0x0d, 0xac, 0xd6, 0xd2, 0xc6, 0xd9, 0x95, 0x66, 0xd2,
-	0xc0, 0x6a, 0xed, 0x1d, 0xc2, 0x8e, 0x0e, 0xb0, 0x34, 0x59, 0x2f, 0x00, 0x06, 0x62, 0x52, 0x9a,
-	0x19, 0x19, 0xf7, 0x2f, 0x34, 0x14, 0x63, 0x75, 0x95, 0x83, 0xf5, 0x46, 0xc6, 0x37, 0x26, 0x74,
-	0x34, 0xd6, 0xb7, 0x39, 0xd8, 0xec, 0xbc, 0x07, 0xe0, 0x9c, 0x5d, 0x93, 0x44, 0xf0, 0x22, 0xf7,
-	0xba, 0x16, 0x66, 0xa9, 0xf7, 0xfe, 0xb4, 0xc0, 0x31, 0x06, 0x43, 0xe9, 0x6d, 0x9b, 0xc9, 0x50,
-	0xac, 0xcf, 0x29, 0x3e, 0x91, 0x62, 0xab, 0x2a, 0x91, 0x62, 0xef, 0x1e, 0x1f, 0xac, 0xac, 0x63,
-	0x5d, 0x36, 0xd8, 0x40, 0xd1, 0x17, 0xb0, 0x9d, 0x66, 0x6c, 0x48, 0x38, 0x27, 0xdc, 0xdd, 0x54,
-	0xf5, 0xff, 0xde, 0xca, 0x73, 0x03, 0x8d, 0xc2, 0x73, 0xb8, 0x0c, 0x6a, 0x10, 0xe4, 0x7c, 0x16,
-	0xd4, 0x03, 0x70, 0x30, 0xe1, 0x79, 0x3c, 0x33, 0x38, 0xb2, 0xae, 0xe8, 0xac, 0x01, 0x9e, 0x43,
-	0xeb, 0x5b, 0x1a, 0x45, 0xf3, 0xf1, 0x61, 0x73, 0x3a, 0x2a, 0x8a, 0xcc, 0xc1, 0x66, 0x27, 0x23,
-	0x0b, 0xa2, 0x48, 0x85, 0xdb, 0xc4, 0x72, 0x79, 0x37, 0x56, 0xef, 0x43, 0x78, 0xf7, 0x59, 0xc4,
-	0x38, 0x39, 0x97, 0xe5, 0x57, 0xde, 0x4f, 0x1f, 0xc0, 0xf6, 0x80, 0x57, 0x8c, 0x2b, 0xef, 0x7b,
-	0xa8, 0x0d, 0xf8, 0x8a, 0x94, 0x7f, 0x0e, 0x3b, 0x66, 0x3e, 0x5d, 0x84, 0x81, 0x08, 0x4c, 0x73,
-	0xad, 0x2e, 0xd6, 0x96, 0x41, 0xf6, 0x03, 0x11, 0x78, 0x4f, 0x01, 0xe4, 0xad, 0x26, 0xb1, 0x3d,
-	0xa8, 0xa5, 0xb2, 0x71, 0xa5, 0xb4, 0x5d, 0x7f, 0xcd, 0xa3, 0xe2, 0x0f, 0x38, 0xae, 0xa5, 0xfc,
-	0xf8, 0xaf, 0x26, 0x34, 0xce, 0xc7, 0x34, 0x46, 0x01, 0xd8, 0x7a, 0xc8, 0xa0, 0xc7, 0x6b, 0xcf,
-	0x2d, 0x4d, 0xe5, 0xf6, 0x27, 0xf7, 0xc2, 0x1a, 0x72, 0xdf, 0xc0, 0xa6, 0x9a, 0x51, 0xe8, 0xd1,
-	0xda, 0x53, 0x8b, 0x73, 0xac, 0xbd, 0x7f, 0x47, 0x81, 0x33, 0xf9, 0xc2, 0x49, 0xba, 0x7a, 0x78,
-	0x55, 0xd0, 0x5d, 0x1a, 0x82, 0x15, 0x74, 0x6f, 0x4d, 0xc3, 0x9f, 0x14, 0x5d, 0x41, 0xaa, 0xe9,
-	0xce, 0x2f, 0x78, 0x7c, 0x1f, 0xa8, 0xf1, 0xff, 0x83, 0x2a, 0x85, 0x8f, 0xaa, 0xb2, 0x64, 0x3c,
-	0x7f, 0x5c, 0x89, 0x9b, 0xab, 0xac, 0x1a, 0xa5, 0x82, 0xf6, 0x62, 0x33, 0x95, 0xaa, 0xfc, 0x02,
-	0x6c, 0xdd, 0x64, 0x15, 0x2a, 0x2f, 0x75, 0x62, 0xa9, 0xb7, 0xaf, 0xa1, 0x21, 0x3b, 0x14, 0x1d,
-	0xad, 0xf5, 0xb5, 0xd0, 0xc4, 0xa5, 0x9e, 0x30, 0xd8, 0x7a, 0xe4, 0x55, 0xf0, 0x5a, 0x9a, 0x8b,
-	0xed, 0xd5, 0x6f, 0xad, 0xc2, 0x7c, 0x6a, 0x49, 0x76, 0x72, 0x60, 0x54, 0xb0, 0x5b, 0x98, 0x29,
-	0xa5, 0xec, 0x7e, 0x94, 0x71, 0x92, 0x61, 0x65, 0x9c, 0xb3, 0x47, 0xb0, 0xfd, 0xe8, 0x1e, 0x48,
-	0x93, 0xde, 0xaf, 0xa0, 0x3e, 0x10, 0x13, 0x54, 0x51, 0x0e, 0xb3, 0xd7, 0xa5, 0x94, 0xe4, 0x4b,
-	0x80, 0xf9, 0x50, 0x43, 0xfe, 0xfa, 0x3e, 0xbe, 0x3d, 0xfd, 0xca, 0xbc, 0x9e, 0xba, 0x37, 0x6f,
-	0x3a, 0x1b, 0xff, 0xbc, 0xe9, 0x6c, 0xfc, 0x3a, 0xed, 0x58, 0x37, 0xd3, 0x8e, 0xf5, 0xf7, 0xb4,
-	0x63, 0xfd, 0x37, 0xed, 0x58, 0x97, 0xb6, 0x42, 0x3e, 0xf9, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x7a,
-	0x10, 0xcb, 0x24, 0x29, 0x0b, 0x00, 0x00,
+	// 951 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0xcf, 0x6f, 0xe3, 0x44,
+	0x14, 0x5e, 0x27, 0xa9, 0x9b, 0xbe, 0xac, 0xbb, 0xbb, 0xa3, 0xaa, 0xf2, 0xa6, 0x28, 0x29, 0x96,
+	0x10, 0xd9, 0x22, 0x1c, 0xc8, 0xde, 0x10, 0x1c, 0xda, 0x6d, 0x11, 0x0b, 0x8b, 0x88, 0xa6, 0x7b,
+	0x43, 0xa2, 0x72, 0x93, 0x69, 0x32, 0xc8, 0xf6, 0x18, 0xcf, 0xb8, 0x6c, 0x6e, 0x9c, 0x39, 0x71,
+	0xe5, 0xdf, 0xe1, 0xd4, 0x23, 0x47, 0x4e, 0x0b, 0xcd, 0x5f, 0x82, 0xe6, 0x87, 0x9d, 0xa4, 0xa9,
+	0x93, 0xf4, 0x62, 0xcd, 0x7b, 0xfe, 0x66, 0xe6, 0x7b, 0xdf, 0xfb, 0x31, 0xf0, 0xd5, 0x88, 0x8a,
+	0x71, 0x76, 0xe9, 0x0f, 0x58, 0xd4, 0x1d, 0xb0, 0x58, 0x04, 0x34, 0x26, 0xe9, 0x70, 0x7e, 0x19,
+	0x24, 0xb4, 0xcb, 0x49, 0x7a, 0x4d, 0x07, 0x84, 0x77, 0xf9, 0x98, 0x46, 0xea, 0xe3, 0x27, 0x29,
+	0x13, 0x0c, 0x1d, 0xcc, 0x80, 0xfe, 0xf5, 0xe7, 0x7e, 0x8e, 0xf3, 0x25, 0xa4, 0xf9, 0x7c, 0xc4,
+	0xd8, 0x28, 0x24, 0x5d, 0x05, 0xbd, 0xcc, 0xae, 0xba, 0x41, 0x3c, 0xd1, 0xfb, 0x9a, 0x07, 0x77,
+	0x7f, 0x91, 0x28, 0x11, 0xf9, 0xcf, 0xbd, 0x11, 0x1b, 0x31, 0xb5, 0xec, 0xca, 0x95, 0xf1, 0x7e,
+	0xb9, 0x11, 0x53, 0x31, 0x49, 0x08, 0xef, 0x46, 0x2c, 0x8b, 0x85, 0xfe, 0x9a, 0xdd, 0xa7, 0x0f,
+	0xd8, 0x5d, 0x38, 0x67, 0x2b, 0x73, 0x4a, 0xfb, 0x2e, 0x6d, 0x41, 0x23, 0xc2, 0x45, 0x10, 0x25,
+	0x1a, 0xe0, 0xfd, 0x5e, 0x01, 0xe7, 0x55, 0x4a, 0x02, 0x41, 0x30, 0xf9, 0x25, 0x23, 0x5c, 0xa0,
+	0x7d, 0xa8, 0xd0, 0xa1, 0x6b, 0x1d, 0x5a, 0x9d, 0x9d, 0x13, 0x7b, 0xfa, 0xbe, 0x5d, 0x79, 0x7d,
+	0x8a, 0x2b, 0x74, 0x88, 0xf6, 0xc1, 0xbe, 0xcc, 0xe2, 0x61, 0x48, 0xdc, 0x8a, 0xfc, 0x87, 0x8d,
+	0x85, 0x5c, 0xd8, 0x4e, 0xb3, 0x58, 0x9e, 0xeb, 0x56, 0xd5, 0x8f, 0xdc, 0x44, 0xcf, 0xa1, 0x1e,
+	0xb3, 0x8b, 0x84, 0x5e, 0x33, 0xe1, 0xd6, 0x0e, 0xad, 0x4e, 0x1d, 0x6f, 0xc7, 0xac, 0x2f, 0x4d,
+	0xd4, 0x84, 0xba, 0x20, 0x69, 0x44, 0xe3, 0x20, 0x74, 0xb7, 0xd4, 0xaf, 0xc2, 0x46, 0x7b, 0xb0,
+	0xc5, 0xc5, 0x90, 0xc6, 0xae, 0xad, 0x8e, 0xd3, 0x86, 0xbc, 0x9e, 0x8b, 0x21, 0xcb, 0x84, 0xbb,
+	0xad, 0xaf, 0xd7, 0x96, 0xf1, 0x93, 0x34, 0x75, 0xeb, 0x85, 0x9f, 0xa4, 0x29, 0xea, 0x81, 0x9d,
+	0x32, 0x26, 0xae, 0xb8, 0xbb, 0x73, 0x58, 0xed, 0x34, 0x7a, 0x4d, 0x7f, 0x31, 0xf3, 0x4a, 0x39,
+	0xff, 0x7b, 0xa9, 0x38, 0x36, 0x48, 0xcf, 0x83, 0xdd, 0x5c, 0x0b, 0x9e, 0xb0, 0x98, 0x13, 0xf4,
+	0x14, 0xaa, 0x89, 0x51, 0xc3, 0xc1, 0x72, 0xe9, 0xed, 0xc2, 0xe3, 0x73, 0x11, 0xa4, 0xc2, 0xc8,
+	0xe5, 0x7d, 0x08, 0xce, 0x29, 0x09, 0xc9, 0x4c, 0xbf, 0xe5, 0x2d, 0x02, 0x76, 0x73, 0x88, 0x39,
+	0xb6, 0x0d, 0x0d, 0xf2, 0x8e, 0x8a, 0x0b, 0x2e, 0x02, 0x91, 0x71, 0x83, 0x05, 0xe9, 0x3a, 0x57,
+	0x1e, 0x74, 0x0c, 0x3b, 0xd2, 0x22, 0xc3, 0x8b, 0x40, 0x28, 0xbd, 0x65, 0x00, 0x3a, 0x97, 0x7e,
+	0x9e, 0x4b, 0xff, 0x6d, 0x9e, 0xcb, 0x93, 0xfa, 0xcd, 0xfb, 0xf6, 0xa3, 0x3f, 0xfe, 0x6d, 0x5b,
+	0xb8, 0xae, 0xb7, 0x1d, 0x0b, 0xef, 0x4f, 0x0b, 0x1a, 0x67, 0xef, 0xc8, 0x20, 0xe7, 0x35, 0x2f,
+	0xb9, 0x55, 0x26, 0x79, 0xe5, 0x7e, 0xc9, 0xab, 0x25, 0x92, 0xd7, 0x16, 0x24, 0xef, 0x40, 0x8d,
+	0x27, 0x64, 0xa0, 0x12, 0xda, 0xe8, 0xed, 0x2d, 0xf1, 0x3d, 0x8e, 0x27, 0x58, 0x21, 0xbc, 0x53,
+	0xb0, 0x71, 0x48, 0x23, 0x2a, 0x10, 0x82, 0x9a, 0xcc, 0x84, 0xae, 0x37, 0xac, 0xd6, 0xd2, 0x37,
+	0x0e, 0xd2, 0xa1, 0x22, 0x53, 0xc3, 0x6a, 0x2d, 0x7d, 0x9c, 0x5d, 0x69, 0x26, 0x35, 0xac, 0xd6,
+	0xde, 0x21, 0x3c, 0xd6, 0x01, 0x96, 0x26, 0xeb, 0x0d, 0x40, 0x5f, 0x4c, 0x4a, 0x33, 0x23, 0xe3,
+	0xfe, 0x95, 0x0e, 0xc5, 0x58, 0x5d, 0xe5, 0x60, 0x6d, 0xc8, 0xf8, 0xc6, 0x84, 0x8e, 0xc6, 0xfa,
+	0x36, 0x07, 0x1b, 0xcb, 0x7b, 0x02, 0xce, 0xd9, 0x35, 0x89, 0x05, 0xcf, 0x73, 0xaf, 0x6b, 0xa1,
+	0x48, 0xbd, 0xf7, 0x97, 0x05, 0x8e, 0x71, 0x18, 0x4a, 0x0f, 0x6d, 0x26, 0x43, 0xb1, 0x3a, 0xa3,
+	0xf8, 0x52, 0x8a, 0xad, 0xaa, 0x44, 0x8a, 0xbd, 0xdb, 0x3b, 0xb8, 0xb7, 0x8e, 0x75, 0xd9, 0x60,
+	0x03, 0x45, 0x5f, 0xc0, 0x4e, 0x92, 0xb2, 0x01, 0xe1, 0x9c, 0x70, 0x77, 0x4b, 0xd5, 0xff, 0x07,
+	0xf7, 0xee, 0xeb, 0x6b, 0x14, 0x9e, 0xc1, 0x65, 0x50, 0xfd, 0x20, 0xe3, 0x45, 0x50, 0x4f, 0xc0,
+	0xc1, 0x84, 0x67, 0x51, 0xe1, 0x70, 0x64, 0x5d, 0xd1, 0xa2, 0x01, 0x5e, 0x43, 0xe3, 0x3b, 0x1a,
+	0x86, 0xb3, 0xf1, 0x61, 0x73, 0x3a, 0xca, 0x8b, 0xcc, 0xc1, 0xc6, 0x92, 0x91, 0x05, 0x61, 0xa8,
+	0xc2, 0xad, 0x63, 0xb9, 0x5c, 0x8e, 0xd5, 0xfb, 0x08, 0x9e, 0xbd, 0x0a, 0x19, 0x27, 0xe7, 0xb2,
+	0xfc, 0xca, 0xfb, 0xe9, 0x08, 0x9e, 0xf6, 0x73, 0xba, 0x6b, 0xa6, 0x96, 0xf7, 0x03, 0x3c, 0x9b,
+	0xc3, 0x9a, 0xac, 0x2c, 0xc8, 0x63, 0x3d, 0x48, 0x9e, 0xde, 0x6d, 0x1d, 0x6a, 0xe7, 0x63, 0x1a,
+	0xa1, 0x00, 0x6c, 0x3d, 0x2c, 0xd0, 0x91, 0xbf, 0xe2, 0x51, 0xf1, 0x17, 0xa6, 0x6b, 0xf3, 0x93,
+	0x8d, 0xb0, 0x86, 0xe7, 0xb7, 0xb0, 0xa5, 0x66, 0x0d, 0x7a, 0xb1, 0x72, 0xd7, 0xfc, 0x3c, 0x6a,
+	0xee, 0x2f, 0xb5, 0xdd, 0x99, 0x7c, 0xa9, 0x24, 0x5d, 0x3d, 0x84, 0xd6, 0xd0, 0x5d, 0x18, 0x66,
+	0x6b, 0xe8, 0xde, 0x99, 0x6a, 0x3f, 0x29, 0xba, 0x82, 0xac, 0xa7, 0x3b, 0xbb, 0xe0, 0x68, 0x13,
+	0xa8, 0x39, 0xff, 0x67, 0xd8, 0x29, 0x72, 0x89, 0x3e, 0x5d, 0xb9, 0xf1, 0x6e, 0x7d, 0x34, 0xfd,
+	0x4d, 0xe1, 0x33, 0xe9, 0x55, 0x17, 0xac, 0x89, 0x65, 0xbe, 0x53, 0x4a, 0xa5, 0x7f, 0x03, 0xb6,
+	0xee, 0xa0, 0x35, 0xd2, 0x2f, 0xb4, 0x59, 0xe9, 0x69, 0xdf, 0x40, 0x4d, 0xb6, 0x1f, 0xea, 0xac,
+	0x3c, 0x6b, 0xae, 0x43, 0x4b, 0x4f, 0xc2, 0x60, 0xeb, 0x79, 0xb6, 0x86, 0xd7, 0xc2, 0xd0, 0x6b,
+	0xde, 0xff, 0x90, 0x2a, 0xcc, 0x67, 0x96, 0x64, 0x27, 0xa7, 0xc1, 0x1a, 0x76, 0x73, 0x03, 0xa3,
+	0x94, 0xdd, 0x8f, 0x32, 0x4e, 0x32, 0x58, 0x1b, 0x67, 0xf1, 0xc2, 0x35, 0x5f, 0x6c, 0x80, 0x34,
+	0xe9, 0xfd, 0x1a, 0xaa, 0x7d, 0x31, 0x41, 0x1f, 0xaf, 0x4e, 0x6e, 0xf1, 0x74, 0x94, 0x92, 0x7c,
+	0x0b, 0x30, 0x9b, 0x58, 0x68, 0x75, 0x91, 0x2d, 0x8d, 0xb6, 0xb2, 0x53, 0x4f, 0xdc, 0x9b, 0xdb,
+	0xd6, 0xa3, 0x7f, 0x6e, 0x5b, 0x8f, 0x7e, 0x9b, 0xb6, 0xac, 0x9b, 0x69, 0xcb, 0xfa, 0x7b, 0xda,
+	0xb2, 0xfe, 0x9b, 0xb6, 0xac, 0x4b, 0x5b, 0x21, 0x5f, 0xfe, 0x1f, 0x00, 0x00, 0xff, 0xff, 0x26,
+	0xfb, 0xd6, 0x0f, 0x06, 0x0b, 0x00, 0x00,
 }
diff --git a/api/services/shim/shim.proto b/api/services/shim/shim.proto
index c3285c0a8..2aa12c682 100644
--- a/api/services/shim/shim.proto
+++ b/api/services/shim/shim.proto
@@ -18,7 +18,7 @@ service Shim {
 	rpc Start(StartRequest) returns (google.protobuf.Empty);
 	rpc Delete(DeleteRequest) returns (DeleteResponse);
 	rpc State(StateRequest) returns (StateResponse);
-	rpc Ps(PsRequest) returns (PsResponse);
+	rpc Processes(ProcessesRequest) returns (ProcessesResponse);
 	rpc Pause(PauseRequest) returns (google.protobuf.Empty);
 	rpc Resume(ResumeRequest) returns (google.protobuf.Empty);
 
@@ -115,15 +115,10 @@ message CloseStdinRequest {
 	uint32 pid = 1;
 }
 
-message PsRequest {
+message ProcessesRequest {
 	string id = 1 [(gogoproto.customname) = "ID"];
 }
 
-message Ps {
-	uint32 pid = 1;
-	google.protobuf.Any runtime_data = 2;
-}
-
-message PsResponse{
-	repeated Ps ps = 1;
+message ProcessesResponse{
+	repeated containerd.v1.types.Process processes = 1;
 }
diff --git a/cmd/ctr/ps.go b/cmd/ctr/ps.go
index e53525886..d8589da9d 100644
--- a/cmd/ctr/ps.go
+++ b/cmd/ctr/ps.go
@@ -48,9 +48,9 @@ var psCommand = cli.Command{
 			); err != nil {
 				return err
 			}
-			if err := w.Flush(); err != nil {
-				return err
-			}
+		}
+		if err := w.Flush(); err != nil {
+			return err
 		}
 
 		return nil
diff --git a/linux/container.go b/linux/container.go
index b5a355a0e..e09a9e045 100644
--- a/linux/container.go
+++ b/linux/container.go
@@ -114,8 +114,8 @@ func (c *Container) Exec(ctx context.Context, opts plugin.ExecOpts) (plugin.Proc
 	}, nil
 }
 
-func (c *Container) Ps(ctx context.Context) ([]uint32, error) {
-	resp, err := c.shim.Ps(ctx, &shim.PsRequest{
+func (c *Container) Processes(ctx context.Context) ([]uint32, error) {
+	resp, err := c.shim.Processes(ctx, &shim.ProcessesRequest{
 		ID: c.id,
 	})
 
@@ -123,9 +123,9 @@ func (c *Container) Ps(ctx context.Context) ([]uint32, error) {
 		return nil, err
 	}
 
-	pids := make([]uint32, 0, len(resp.Ps))
+	pids := make([]uint32, 0, len(resp.Processes))
 
-	for _, ps := range resp.Ps {
+	for _, ps := range resp.Processes {
 		pids = append(pids, ps.Pid)
 	}
 
diff --git a/linux/shim/client.go b/linux/shim/client.go
index 9f72cebb7..1ab1f64e2 100644
--- a/linux/shim/client.go
+++ b/linux/shim/client.go
@@ -82,8 +82,8 @@ func (c *client) Kill(ctx context.Context, in *shimapi.KillRequest, opts ...grpc
 	return c.s.Kill(ctx, in)
 }
 
-func (c *client) Ps(ctx context.Context, in *shimapi.PsRequest, opts ...grpc.CallOption) (*shimapi.PsResponse, error) {
-	return c.s.Ps(ctx, in)
+func (c *client) Processes(ctx context.Context, in *shimapi.ProcessesRequest, opts ...grpc.CallOption) (*shimapi.ProcessesResponse, error) {
+	return c.s.Processes(ctx, in)
 }
 
 func (c *client) Exit(ctx context.Context, in *shimapi.ExitRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
diff --git a/linux/shim/service.go b/linux/shim/service.go
index e5fc1736a..a8a857f33 100644
--- a/linux/shim/service.go
+++ b/linux/shim/service.go
@@ -250,20 +250,20 @@ func (s *Service) Kill(ctx context.Context, r *shimapi.KillRequest) (*google_pro
 	return empty, nil
 }
 
-func (s *Service) Ps(ctx context.Context, r *shimapi.PsRequest) (*shimapi.PsResponse, error) {
+func (s *Service) Processes(ctx context.Context, r *shimapi.ProcessesRequest) (*shimapi.ProcessesResponse, error) {
 	pids, err := s.getContainerPids(ctx, r.ID)
 	if err != nil {
 		return nil, err
 	}
 
-	ps := []*shimapi.Ps{}
+	ps := []*container.Process{}
 	for _, pid := range pids {
-		ps = append(ps, &shimapi.Ps{
+		ps = append(ps, &container.Process{
 			Pid: pid,
 		})
 	}
-	resp := &shimapi.PsResponse{
-		Ps: ps,
+	resp := &shimapi.ProcessesResponse{
+		Processes: ps,
 	}
 
 	return resp, nil
diff --git a/plugin/container.go b/plugin/container.go
index 53d85d6c0..75ebc13f7 100644
--- a/plugin/container.go
+++ b/plugin/container.go
@@ -22,8 +22,8 @@ type Container interface {
 	Kill(context.Context, uint32, uint32, bool) error
 	// Exec adds a process into the container
 	Exec(context.Context, ExecOpts) (Process, error)
-	// Ps returns all pids for the container
-	Ps(context.Context) ([]uint32, error)
+	// Processes returns all pids for the container
+	Processes(context.Context) ([]uint32, error)
 	// Pty resizes the processes pty/console
 	Pty(context.Context, uint32, ConsoleSize) error
 	// CloseStdin closes the processes stdin
diff --git a/services/execution/service.go b/services/execution/service.go
index d85a820f3..149793021 100644
--- a/services/execution/service.go
+++ b/services/execution/service.go
@@ -240,7 +240,7 @@ func (s *Service) Processes(ctx context.Context, r *api.ProcessesRequest) (*api.
 		return nil, err
 	}
 
-	pids, err := c.Ps(ctx)
+	pids, err := c.Processes(ctx)
 	if err != nil {
 		return nil, err
 	}
diff --git a/windows/container.go b/windows/container.go
index 80fa3aa6c..ae22ff3ae 100644
--- a/windows/container.go
+++ b/windows/container.go
@@ -174,7 +174,7 @@ func (c *container) Pid() uint32 {
 	return c.ctr.Pid()
 }
 
-func (c *container) Ps(ctx context.Context) ([]uint32, error) {
+func (c *container) Processes(ctx context.Context) ([]uint32, error) {
 	// TODO (ehazlett): support finding all processes in windows container
 	p, err := c.ctr.ProcessList()
 	if err != nil {