github/containerd
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

ListPids returns process ID and other info

Browse Source 
Signed-off-by: Jess <jessica.valarezo@docker.com>
This commit is contained in:
Jess 2017-10-10 22:57:15 +00:00
parent 72bb45ac46
commit 061c719209
18 changed files with 1118 additions and 405 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
api/next.pb.txt
View File

@ -2956,6 +2956,7 @@ file {
package: "containerd.v1.types" package: "containerd.v1.types"
dependency: "gogoproto/gogo.proto" dependency: "gogoproto/gogo.proto"
dependency: "google/protobuf/timestamp.proto" dependency: "google/protobuf/timestamp.proto"
dependency: "google/protobuf/any.proto"
message_type { message_type {
name: "Process" name: "Process"
field { field {
@ -3035,6 +3036,24 @@ file {
json_name: "exitedAt" json_name: "exitedAt"
} }
} }
message_type {
name: "ProcessInfo"
field {
name: "pid"
number: 1
label: LABEL_OPTIONAL
type: TYPE_UINT32
json_name: "pid"
}
field {
name: "info"
number: 2
label: LABEL_OPTIONAL
type: TYPE_MESSAGE
type_name: ".google.protobuf.Any"
json_name: "info"
}
}
enum_type { enum_type {
name: "Status" name: "Status"
value { value {
@ -3490,11 +3509,12 @@ file {
message_type { message_type {
name: "ListPidsResponse" name: "ListPidsResponse"
field { field {
name: "pids" name: "processes"
number: 1 number: 1
label: LABEL_REPEATED label: LABEL_REPEATED
type: TYPE_UINT32 type: TYPE_MESSAGE
json_name: "pids" type_name: ".containerd.v1.types.ProcessInfo"
json_name: "processes"
} }
} }
message_type { message_type {

296
api/services/tasks/v1/tasks.pb.go
View File

@ -268,7 +268,8 @@ func (*ListPidsRequest) ProtoMessage() {}
func (*ListPidsRequest) Descriptor() ([]byte, []int) { return fileDescriptorTasks, []int{18} } func (*ListPidsRequest) Descriptor() ([]byte, []int) { return fileDescriptorTasks, []int{18} }
type ListPidsResponse struct { type ListPidsResponse struct {
Pids []uint32 `protobuf:"varint,1,rep,packed,name=pids" json:"pids,omitempty"` // Processes includes the process ID and additional process information
Processes []*containerd_v1_types.ProcessInfo `protobuf:"bytes,1,rep,name=processes" json:"processes,omitempty"`
} }
func (m *ListPidsResponse) Reset() { *m = ListPidsResponse{} } func (m *ListPidsResponse) Reset() { *m = ListPidsResponse{} }
@ -1646,22 +1647,17 @@ func (m *ListPidsResponse) MarshalTo(dAtA []byte) (int, error) {
_ = i _ = i
var l int var l int
_ = l _ = l
if len(m.Pids) > 0 { if len(m.Processes) > 0 {
dAtA7 := make([]byte, len(m.Pids)*10) for _, msg := range m.Processes {
var j6 int dAtA[i] = 0xa
for _, num := range m.Pids { i++
for num >= 1<<7 { i = encodeVarintTasks(dAtA, i, uint64(msg.Size()))
dAtA7[j6] = uint8(uint64(num)&0x7f | 0x80) n, err := msg.MarshalTo(dAtA[i:])
num >>= 7 if err != nil {
j6++ return 0, err
} }
dAtA7[j6] = uint8(num) i += n
j6++
} }
dAtA[i] = 0xa
i++
i = encodeVarintTasks(dAtA, i, uint64(j6))
i += copy(dAtA[i:], dAtA7[:j6])
} }
return i, nil return i, nil
} }
@ -1697,11 +1693,11 @@ func (m *CheckpointTaskRequest) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x1a dAtA[i] = 0x1a
i++ i++
i = encodeVarintTasks(dAtA, i, uint64(m.Options.Size())) i = encodeVarintTasks(dAtA, i, uint64(m.Options.Size()))
n8, err := m.Options.MarshalTo(dAtA[i:]) n6, err := m.Options.MarshalTo(dAtA[i:])
if err != nil { if err != nil {
return 0, err return 0, err
} }
i += n8 i += n6
} }
return i, nil return i, nil
} }
@ -1761,11 +1757,11 @@ func (m *UpdateTaskRequest) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x12 dAtA[i] = 0x12
i++ i++
i = encodeVarintTasks(dAtA, i, uint64(m.Resources.Size())) i = encodeVarintTasks(dAtA, i, uint64(m.Resources.Size()))
n9, err := m.Resources.MarshalTo(dAtA[i:]) n7, err := m.Resources.MarshalTo(dAtA[i:])
if err != nil { if err != nil {
return 0, err return 0, err
} }
i += n9 i += n7
} }
return i, nil return i, nil
} }
@ -1886,11 +1882,11 @@ func (m *WaitResponse) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x12 dAtA[i] = 0x12
i++ i++
i = encodeVarintTasks(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt))) i = encodeVarintTasks(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt)))
n10, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i:]) n8, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i:])
if err != nil { if err != nil {
return 0, err return 0, err
} }
i += n10 i += n8
return i, nil return i, nil
} }
@ -2213,12 +2209,11 @@ func (m *ListPidsRequest) Size() (n int) {
func (m *ListPidsResponse) Size() (n int) { func (m *ListPidsResponse) Size() (n int) {
var l int var l int
_ = l _ = l
if len(m.Pids) > 0 { if len(m.Processes) > 0 {
l = 0 for _, e := range m.Processes {
for _, e := range m.Pids { l = e.Size()
l += sovTasks(uint64(e)) n += 1 + l + sovTasks(uint64(l))
} }
n += 1 + sovTasks(uint64(l)) + l
} }
return n return n
} }
@ -2551,7 +2546,7 @@ func (this *ListPidsResponse) String() string {
return "nil" return "nil"
} }
s := strings.Join([]string{`&ListPidsResponse{`, s := strings.Join([]string{`&ListPidsResponse{`,
`Pids:` + fmt.Sprintf("%v", this.Pids) + `,`, `Processes:` + strings.Replace(fmt.Sprintf("%v", this.Processes), "ProcessInfo", "containerd_v1_types.ProcessInfo", 1) + `,`,
`}`, `}`,
}, "") }, "")
return s return s
@ -4868,67 +4863,36 @@ func (m *ListPidsResponse) Unmarshal(dAtA []byte) error {
} }
switch fieldNum { switch fieldNum {
case 1: case 1:
if wireType == 0 { if wireType != 2 {
var v uint32 return fmt.Errorf("proto: wrong wireType = %d for field Processes", wireType)
for shift := uint(0); ; shift += 7 { }
if shift >= 64 { var msglen int
return ErrIntOverflowTasks for shift := uint(0); ; shift += 7 {
} if shift >= 64 {
if iNdEx >= l { return ErrIntOverflowTasks
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
} }
m.Pids = append(m.Pids, v) if iNdEx >= l {
} else if wireType == 2 {
var packedLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTasks
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
packedLen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if packedLen < 0 {
return ErrInvalidLengthTasks
}
postIndex := iNdEx + packedLen
if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
for iNdEx < postIndex { b := dAtA[iNdEx]
var v uint32 iNdEx++
for shift := uint(0); ; shift += 7 { msglen |= (int(b) & 0x7F) << shift
if shift >= 64 { if b < 0x80 {
return ErrIntOverflowTasks break
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.Pids = append(m.Pids, v)
} }
} else {
return fmt.Errorf("proto: wrong wireType = %d for field Pids", wireType)
} }
if msglen < 0 {
return ErrInvalidLengthTasks
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Processes = append(m.Processes, &containerd_v1_types.ProcessInfo{})
if err := m.Processes[len(m.Processes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default: default:
iNdEx = preIndex iNdEx = preIndex
skippy, err := skipTasks(dAtA[iNdEx:]) skippy, err := skipTasks(dAtA[iNdEx:])
@ -5761,88 +5725,88 @@ func init() {
} }
var fileDescriptorTasks = []byte{ var fileDescriptorTasks = []byte{
// 1313 bytes of a gzipped FileDescriptorProto // 1317 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x5b, 0x6f, 0x1b, 0x45, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x5b, 0x6f, 0x1b, 0x45,
0x14, 0xee, 0xfa, 0xee, 0xe3, 0xa4, 0x4d, 0x86, 0x34, 0x98, 0xa5, 0x8a, 0xc3, 0x22, 0x21, 0x13, 0x1b, 0xee, 0xfa, 0xec, 0xd7, 0x49, 0x9b, 0xec, 0x97, 0xe6, 0x33, 0x4b, 0x15, 0x87, 0xe5, 0xc6,
0xe8, 0x2e, 0x75, 0x51, 0x85, 0x68, 0x85, 0xd4, 0x5c, 0x88, 0x2c, 0xa8, 0x9a, 0x6e, 0xcb, 0x45, 0x04, 0xba, 0x4b, 0x5d, 0x54, 0x21, 0x5a, 0x21, 0x35, 0x07, 0x22, 0x0b, 0xaa, 0xa6, 0xdb, 0x72,
0x95, 0x50, 0xd8, 0xee, 0x4e, 0x9c, 0x51, 0xec, 0xdd, 0xed, 0xce, 0x38, 0x6d, 0xe0, 0x01, 0x7e, 0x50, 0x25, 0x14, 0xb6, 0xbb, 0x13, 0x67, 0x14, 0x7b, 0x67, 0xbb, 0x33, 0x4e, 0x1b, 0xb8, 0x80,
0x42, 0x5f, 0x79, 0xe1, 0xf7, 0xe4, 0x91, 0x47, 0x84, 0xaa, 0x40, 0xfd, 0x2f, 0x78, 0x43, 0x73, 0x9f, 0xd0, 0x5b, 0x6e, 0xf8, 0x3d, 0xb9, 0xe4, 0x12, 0xa1, 0x2a, 0x50, 0xff, 0x0b, 0xee, 0xd0,
0xd9, 0xcd, 0xc6, 0x8e, 0xbd, 0x4e, 0xd3, 0xf0, 0xd2, 0xce, 0xcc, 0x7e, 0xe7, 0xcc, 0x99, 0x6f, 0x1c, 0x76, 0xb3, 0xb1, 0x63, 0xaf, 0x93, 0x34, 0xdc, 0xb4, 0x33, 0xb3, 0xef, 0x69, 0x9e, 0x79,
0xce, 0x9c, 0xf3, 0x39, 0xb0, 0xda, 0x21, 0x6c, 0xb7, 0xff, 0xc4, 0x74, 0x83, 0x9e, 0xe5, 0x06, 0x0f, 0x8f, 0x03, 0xab, 0x1d, 0xcc, 0x76, 0xfb, 0xcf, 0x2c, 0x8f, 0xf4, 0x6c, 0x8f, 0x04, 0xcc,
0x3e, 0x73, 0x88, 0x8f, 0x23, 0x2f, 0x3d, 0x74, 0x42, 0x62, 0x51, 0x1c, 0xed, 0x13, 0x17, 0x53, 0xc5, 0x01, 0x8a, 0xfc, 0xf4, 0xd2, 0x0d, 0xb1, 0x4d, 0x51, 0xb4, 0x8f, 0x3d, 0x44, 0x6d, 0xe6,
0x8b, 0x39, 0x74, 0x8f, 0x5a, 0xfb, 0x37, 0xe4, 0xc0, 0x0c, 0xa3, 0x80, 0x05, 0xe8, 0xda, 0x31, 0xd2, 0x3d, 0x6a, 0xef, 0xdf, 0x92, 0x0b, 0x2b, 0x8c, 0x08, 0x23, 0xfa, 0x8d, 0x63, 0x69, 0x2b,
0xda, 0x8c, 0x91, 0xa6, 0x04, 0xec, 0xdf, 0xd0, 0xdf, 0xed, 0x04, 0x41, 0xa7, 0x8b, 0x2d, 0x81, 0x96, 0xb4, 0xa4, 0xc0, 0xfe, 0x2d, 0xe3, 0xdd, 0x0e, 0x21, 0x9d, 0x2e, 0xb2, 0x85, 0xec, 0xb3,
0x7d, 0xd2, 0xdf, 0xb1, 0x70, 0x2f, 0x64, 0x07, 0xd2, 0x54, 0x7f, 0x67, 0xf8, 0xa3, 0xe3, 0xc7, 0xfe, 0x8e, 0x8d, 0x7a, 0x21, 0x3b, 0x90, 0xaa, 0xc6, 0x3b, 0xc3, 0x1f, 0xdd, 0x20, 0xfe, 0xb4,
0x9f, 0x16, 0x3a, 0x41, 0x27, 0x10, 0x43, 0x8b, 0x8f, 0xd4, 0xea, 0xad, 0xa9, 0xe2, 0x65, 0x07, 0xd0, 0x21, 0x1d, 0x22, 0x96, 0x36, 0x5f, 0xa9, 0xd3, 0x3b, 0x53, 0xc5, 0xcb, 0x0e, 0x42, 0x44,
0x21, 0xa6, 0x56, 0x2f, 0xe8, 0xfb, 0x4c, 0xd9, 0x7d, 0x76, 0x16, 0x3b, 0xcc, 0x22, 0xe2, 0xaa, 0xed, 0x1e, 0xe9, 0x07, 0x4c, 0xe9, 0x7d, 0x7a, 0x16, 0x3d, 0xc4, 0x22, 0xec, 0xa9, 0xdb, 0x19,
0xd3, 0xe9, 0xb7, 0xcf, 0x60, 0xe9, 0x61, 0xea, 0x46, 0x24, 0x64, 0x41, 0xa4, 0x8c, 0x3f, 0x3f, 0x77, 0xcf, 0xa0, 0xe9, 0x23, 0xea, 0x45, 0x38, 0x64, 0x24, 0x52, 0xca, 0x9f, 0x9d, 0x41, 0x99,
0x83, 0x31, 0x67, 0x4c, 0xfc, 0xa3, 0x6c, 0x1b, 0xc3, 0xdc, 0x30, 0xd2, 0xc3, 0x94, 0x39, 0xbd, 0x23, 0x26, 0xfe, 0x51, 0xba, 0x8d, 0x61, 0x6c, 0x18, 0xee, 0x21, 0xca, 0xdc, 0x5e, 0x28, 0x05,
0x50, 0x02, 0x8c, 0xc3, 0x1c, 0xcc, 0xaf, 0x45, 0xd8, 0x61, 0xf8, 0x91, 0x43, 0xf7, 0x6c, 0xfc, 0xcc, 0xc3, 0x1c, 0xcc, 0xaf, 0x45, 0xc8, 0x65, 0xe8, 0x89, 0x4b, 0xf7, 0x1c, 0xf4, 0xbc, 0x8f,
0xb4, 0x8f, 0x29, 0x43, 0x2d, 0x98, 0x49, 0xdc, 0x6f, 0x13, 0xaf, 0xae, 0x2d, 0x6b, 0xcd, 0xea, 0x28, 0xd3, 0x5b, 0x30, 0x93, 0x98, 0xdf, 0xc6, 0x7e, 0x5d, 0x5b, 0xd6, 0x9a, 0xd5, 0xd5, 0x6b,
0xea, 0x95, 0xc1, 0x51, 0xa3, 0xb6, 0x16, 0xaf, 0xb7, 0xd7, 0xed, 0x5a, 0x02, 0x6a, 0x7b, 0xc8, 0x83, 0xa3, 0x46, 0x6d, 0x2d, 0x3e, 0x6f, 0xaf, 0x3b, 0xb5, 0x44, 0xa8, 0xed, 0xeb, 0x36, 0x94,
0x82, 0x52, 0x14, 0x04, 0x6c, 0x87, 0xd6, 0xf3, 0xcb, 0xf9, 0x66, 0xad, 0xf5, 0xb6, 0x99, 0xba, 0x22, 0x42, 0xd8, 0x0e, 0xad, 0xe7, 0x97, 0xf3, 0xcd, 0x5a, 0xeb, 0xff, 0x56, 0xea, 0x49, 0x45,
0x52, 0x11, 0x9d, 0x79, 0x8f, 0x93, 0x69, 0x2b, 0x18, 0x5a, 0x80, 0x22, 0x65, 0x1e, 0xf1, 0xeb, 0x74, 0xd6, 0x03, 0x0e, 0xa6, 0xa3, 0xc4, 0xf4, 0x05, 0x28, 0x52, 0xe6, 0xe3, 0xa0, 0x5e, 0xe0,
0x05, 0xee, 0xdd, 0x96, 0x13, 0xb4, 0x08, 0x25, 0xca, 0xbc, 0xa0, 0xcf, 0xea, 0x45, 0xb1, 0xac, 0xd6, 0x1d, 0xb9, 0xd1, 0x17, 0xa1, 0x44, 0x99, 0x4f, 0xfa, 0xac, 0x5e, 0x14, 0xc7, 0x6a, 0xa7,
0x66, 0x6a, 0x1d, 0x47, 0x51, 0xbd, 0x94, 0xac, 0xe3, 0x28, 0x42, 0x3a, 0x54, 0x18, 0x8e, 0x7a, 0xce, 0x51, 0x14, 0xd5, 0x4b, 0xc9, 0x39, 0x8a, 0x22, 0xdd, 0x80, 0x0a, 0x43, 0x51, 0x0f, 0x07,
0xc4, 0x77, 0xba, 0xf5, 0xf2, 0xb2, 0xd6, 0xac, 0xd8, 0xc9, 0x1c, 0xdd, 0x01, 0x70, 0x77, 0xb1, 0x6e, 0xb7, 0x5e, 0x5e, 0xd6, 0x9a, 0x15, 0x27, 0xd9, 0xeb, 0xf7, 0x00, 0xbc, 0x5d, 0xe4, 0xed,
0xbb, 0x17, 0x06, 0xc4, 0x67, 0xf5, 0xca, 0xb2, 0xd6, 0xac, 0xb5, 0xae, 0x8d, 0x86, 0xb5, 0x9e, 0x85, 0x04, 0x07, 0xac, 0x5e, 0x59, 0xd6, 0x9a, 0xb5, 0xd6, 0x8d, 0xd1, 0xb0, 0xd6, 0x13, 0xc4,
0x30, 0x6e, 0xa7, 0xf0, 0xc8, 0x84, 0x72, 0x10, 0x32, 0x12, 0xf8, 0xb4, 0x5e, 0x15, 0xa6, 0x0b, 0x9d, 0x94, 0xbc, 0x6e, 0x41, 0x99, 0x84, 0x0c, 0x93, 0x80, 0xd6, 0xab, 0x42, 0x75, 0xc1, 0x92,
0xa6, 0x64, 0xd3, 0x8c, 0xd9, 0x34, 0xef, 0xfa, 0x07, 0x76, 0x0c, 0x32, 0x1e, 0x03, 0x4a, 0x33, 0x68, 0x5a, 0x31, 0x9a, 0xd6, 0xfd, 0xe0, 0xc0, 0x89, 0x85, 0xcc, 0xa7, 0xa0, 0xa7, 0x91, 0xa4,
0x49, 0xc3, 0xc0, 0xa7, 0xf8, 0xb5, 0xa8, 0x9c, 0x83, 0x7c, 0x48, 0xbc, 0x7a, 0x6e, 0x59, 0x6b, 0x21, 0x09, 0x28, 0x3a, 0x17, 0x94, 0x73, 0x90, 0x0f, 0xb1, 0x5f, 0xcf, 0x2d, 0x6b, 0xcd, 0x59,
0xce, 0xda, 0x7c, 0x68, 0x74, 0x60, 0xe6, 0x21, 0x73, 0x22, 0x76, 0x9e, 0x0b, 0x7a, 0x1f, 0xca, 0x87, 0x2f, 0xcd, 0x0e, 0xcc, 0x3c, 0x66, 0x6e, 0xc4, 0x2e, 0xf2, 0x40, 0xef, 0x43, 0x19, 0xbd,
0xf8, 0x39, 0x76, 0xb7, 0x95, 0xe7, 0xea, 0x2a, 0x0c, 0x8e, 0x1a, 0xa5, 0x8d, 0xe7, 0xd8, 0x6d, 0x44, 0xde, 0xb6, 0xb2, 0x5c, 0x5d, 0x85, 0xc1, 0x51, 0xa3, 0xb4, 0xf1, 0x12, 0x79, 0xed, 0x75,
0xaf, 0xdb, 0x25, 0xfe, 0xa9, 0xed, 0x19, 0xef, 0xc1, 0xac, 0xda, 0x48, 0xc5, 0xaf, 0x62, 0xd1, 0xa7, 0xc4, 0x3f, 0xb5, 0x7d, 0xf3, 0x3d, 0x98, 0x55, 0x8e, 0x54, 0xfc, 0x2a, 0x16, 0xed, 0x38,
0x8e, 0x63, 0xd9, 0x84, 0xf9, 0x75, 0xdc, 0xc5, 0xe7, 0xce, 0x18, 0xe3, 0x77, 0x0d, 0x2e, 0x4b, 0x96, 0x4d, 0x98, 0x5f, 0x47, 0x5d, 0x74, 0xe1, 0x8c, 0x31, 0x7f, 0xd3, 0xe0, 0xaa, 0xb4, 0x94,
0x4f, 0xc9, 0x6e, 0x8b, 0x90, 0x4b, 0x8c, 0x4b, 0x83, 0xa3, 0x46, 0xae, 0xbd, 0x6e, 0xe7, 0xc8, 0x78, 0x5b, 0x84, 0x5c, 0xa2, 0x5c, 0x1a, 0x1c, 0x35, 0x72, 0xed, 0x75, 0x27, 0x87, 0x4f, 0x41,
0x29, 0x8c, 0xa0, 0x06, 0xd4, 0xf0, 0x73, 0xc2, 0xb6, 0x29, 0x73, 0x58, 0x9f, 0xe7, 0x1c, 0xff, 0x44, 0x6f, 0x40, 0x0d, 0xbd, 0xc4, 0x6c, 0x9b, 0x32, 0x97, 0xf5, 0x79, 0xce, 0xf1, 0x2f, 0xc0,
0x02, 0x7c, 0xe9, 0xa1, 0x58, 0x41, 0x77, 0xa1, 0xca, 0x67, 0xd8, 0xdb, 0x76, 0x98, 0x48, 0xb1, 0x8f, 0x1e, 0x8b, 0x13, 0xfd, 0x3e, 0x54, 0xf9, 0x0e, 0xf9, 0xdb, 0x2e, 0x13, 0x29, 0x56, 0x6b,
0x5a, 0x4b, 0x1f, 0xb9, 0xc0, 0x47, 0xf1, 0x73, 0x58, 0xad, 0x1c, 0x1e, 0x35, 0x2e, 0xbd, 0xf8, 0x19, 0x23, 0x0f, 0xf8, 0x24, 0x2e, 0x87, 0xd5, 0xca, 0xe1, 0x51, 0xe3, 0xca, 0xab, 0xbf, 0x1a,
0xbb, 0xa1, 0xd9, 0x15, 0x69, 0x76, 0x97, 0x19, 0x01, 0x2c, 0xc8, 0xf8, 0xb6, 0xa2, 0xc0, 0xc5, 0x9a, 0x53, 0x91, 0x6a, 0xf7, 0x99, 0x49, 0x60, 0x41, 0xc6, 0xb7, 0x15, 0x11, 0x0f, 0x51, 0x7a,
0x94, 0x5e, 0x38, 0xfb, 0x18, 0x60, 0x13, 0x5f, 0xfc, 0x25, 0x6f, 0x40, 0x4d, 0x6c, 0xa3, 0x48, 0xe9, 0xe8, 0x23, 0x80, 0x4d, 0x74, 0xf9, 0x8f, 0xbc, 0x01, 0x35, 0xe1, 0x46, 0x81, 0x7e, 0x07,
0xbf, 0x05, 0xe5, 0x50, 0x1e, 0x50, 0x6c, 0x31, 0xf4, 0x46, 0xf6, 0x6f, 0xa8, 0x67, 0x12, 0x93, 0xca, 0xa1, 0xbc, 0xa0, 0x70, 0x31, 0x54, 0x23, 0xfb, 0xb7, 0x54, 0x99, 0xc4, 0x20, 0xc4, 0xc2,
0x10, 0x83, 0x8d, 0x15, 0x98, 0xfb, 0x9a, 0x50, 0xc6, 0xd3, 0x20, 0xa1, 0x66, 0x11, 0x4a, 0x3b, 0xe6, 0x0a, 0xcc, 0x7d, 0x85, 0x29, 0xe3, 0x69, 0x90, 0x40, 0xb3, 0x08, 0xa5, 0x1d, 0xdc, 0x65,
0xa4, 0xcb, 0x70, 0x24, 0xa3, 0xb5, 0xd5, 0x8c, 0x27, 0x4d, 0x0a, 0x9b, 0xbc, 0x8d, 0xa2, 0x28, 0x28, 0x92, 0xd1, 0x3a, 0x6a, 0xc7, 0x93, 0x26, 0x25, 0x9b, 0xd4, 0x46, 0x51, 0xb4, 0xf8, 0xba,
0xf1, 0x75, 0x4d, 0x54, 0x8c, 0xc9, 0xdb, 0x4a, 0xa8, 0xf1, 0x42, 0x83, 0xda, 0x57, 0xa4, 0xdb, 0x26, 0x3a, 0xc6, 0x64, 0xb7, 0x52, 0xd4, 0x7c, 0xa5, 0x41, 0xed, 0x4b, 0xdc, 0xed, 0x5e, 0x36,
0xbd, 0x68, 0x92, 0x44, 0xc1, 0x21, 0x1d, 0x5e, 0x56, 0x64, 0x6e, 0xa9, 0x19, 0x4f, 0x45, 0xa7, 0x48, 0xa2, 0xe1, 0xe0, 0x0e, 0x6f, 0x2b, 0x32, 0xb7, 0xd4, 0x8e, 0xa7, 0xa2, 0xdb, 0xed, 0x8a,
0xdb, 0x15, 0x19, 0x55, 0xb1, 0xf9, 0xd0, 0xf8, 0x57, 0x03, 0xc4, 0x8d, 0xdf, 0x40, 0x96, 0x24, 0x8c, 0xaa, 0x38, 0x7c, 0x69, 0xfe, 0xa3, 0x81, 0xce, 0x95, 0xdf, 0x42, 0x96, 0x24, 0x3d, 0x31,
0x35, 0x31, 0x77, 0x7a, 0x4d, 0xcc, 0x8f, 0xa9, 0x89, 0x85, 0xb1, 0x35, 0xb1, 0x38, 0x54, 0x13, 0x77, 0x7a, 0x4f, 0xcc, 0x8f, 0xe9, 0x89, 0x85, 0xb1, 0x3d, 0xb1, 0x38, 0xd4, 0x13, 0x9b, 0x50,
0x9b, 0x50, 0xa0, 0x21, 0x76, 0x45, 0x15, 0x1d, 0x57, 0xd2, 0x04, 0x22, 0xcd, 0x52, 0x79, 0x6c, 0xa0, 0x21, 0xf2, 0x44, 0x17, 0x1d, 0xd7, 0xd2, 0x84, 0x44, 0x1a, 0xa5, 0xf2, 0xd8, 0x54, 0xba,
0x2a, 0x5d, 0x85, 0xb7, 0x4e, 0x1c, 0x5d, 0xde, 0xac, 0xf1, 0x9b, 0x06, 0x73, 0x36, 0xa6, 0xe4, 0x0e, 0xff, 0x3b, 0x71, 0x75, 0xf9, 0xb2, 0xe6, 0xaf, 0x1a, 0xcc, 0x39, 0x88, 0xe2, 0x1f, 0xd1,
0x27, 0xbc, 0xc5, 0x0e, 0x2e, 0xfc, 0xaa, 0x16, 0xa0, 0xf8, 0x8c, 0x78, 0x6c, 0x57, 0xdd, 0x94, 0x16, 0x3b, 0xb8, 0xf4, 0xa7, 0x5a, 0x80, 0xe2, 0x0b, 0xec, 0xb3, 0x5d, 0xf5, 0x52, 0x72, 0xc3,
0x9c, 0x70, 0x76, 0x76, 0x31, 0xe9, 0xec, 0xca, 0xd7, 0x3f, 0x6b, 0xab, 0x99, 0xf1, 0x0b, 0x5c, 0xd1, 0xd9, 0x45, 0xb8, 0xb3, 0x2b, 0xab, 0x7f, 0xd6, 0x51, 0x3b, 0xf3, 0x67, 0xb8, 0xba, 0xd6,
0x5e, 0xeb, 0x06, 0x14, 0xb7, 0xef, 0xff, 0x1f, 0x81, 0xc9, 0xeb, 0xcc, 0x8b, 0x5b, 0x90, 0x13, 0x25, 0x14, 0xb5, 0x1f, 0xfe, 0x17, 0x81, 0xc9, 0xe7, 0xcc, 0x8b, 0x57, 0x90, 0x1b, 0xf3, 0x0b,
0xe3, 0x4b, 0x98, 0xdb, 0x72, 0xfa, 0xf4, 0xdc, 0xf5, 0x73, 0x13, 0xe6, 0x6d, 0x4c, 0xfb, 0xbd, 0x98, 0xdb, 0x72, 0xfb, 0xf4, 0xc2, 0xfd, 0x73, 0x13, 0xe6, 0x1d, 0x44, 0xfb, 0xbd, 0x0b, 0x1b,
0x73, 0x3b, 0xda, 0x80, 0x2b, 0xfc, 0x71, 0x6e, 0x11, 0xef, 0x3c, 0xc9, 0x6b, 0x7c, 0x20, 0xeb, 0xda, 0x80, 0x6b, 0xbc, 0x38, 0xb7, 0xb0, 0x7f, 0x91, 0xe4, 0x35, 0x1d, 0xd9, 0x0f, 0xa4, 0x19,
0x81, 0x74, 0xa3, 0x9e, 0x38, 0x82, 0x42, 0x48, 0x3c, 0xf9, 0xc2, 0x67, 0x6d, 0x31, 0x36, 0x5e, 0x55, 0xe2, 0x9f, 0x43, 0x55, 0xb5, 0x0b, 0x14, 0x97, 0xf9, 0xf2, 0xa4, 0x32, 0x6f, 0x07, 0x3b,
0x6a, 0x70, 0x75, 0x2d, 0xe9, 0xb3, 0xe7, 0xd5, 0x1d, 0xdb, 0x30, 0x1f, 0x3a, 0x11, 0xf6, 0xd9, 0xc4, 0x39, 0x56, 0x31, 0x5f, 0x6b, 0x70, 0x7d, 0x2d, 0x99, 0xc9, 0x17, 0xe5, 0x28, 0xdb, 0x30,
0x76, 0xaa, 0xd7, 0xcb, 0x2b, 0x69, 0xf1, 0x9a, 0xfe, 0xd7, 0x51, 0x63, 0x25, 0xa5, 0xa0, 0x82, 0x1f, 0xba, 0x11, 0x0a, 0xd8, 0x76, 0x8a, 0x17, 0xc8, 0xe7, 0x6b, 0xf1, 0xfe, 0xff, 0xe7, 0x51,
0x10, 0xfb, 0x89, 0x39, 0xb5, 0x3a, 0xc1, 0x75, 0x8f, 0x74, 0x30, 0x65, 0xe6, 0xba, 0xf8, 0xcf, 0x63, 0x25, 0xc5, 0xb6, 0x48, 0x88, 0x82, 0x44, 0x9d, 0xda, 0x1d, 0x72, 0xd3, 0xc7, 0x1d, 0x44,
0x9e, 0x93, 0xce, 0xd6, 0x4e, 0xd5, 0x01, 0xf9, 0x69, 0x74, 0xc0, 0xf7, 0xb0, 0x38, 0x7c, 0x3a, 0x99, 0xb5, 0x2e, 0xfe, 0x73, 0xe6, 0xa4, 0xb1, 0xb5, 0x53, 0x39, 0x43, 0x7e, 0x1a, 0xce, 0xf0,
0x45, 0xc6, 0x17, 0x50, 0x3b, 0x56, 0x77, 0xa7, 0x56, 0xbd, 0x11, 0x41, 0x92, 0x36, 0x30, 0x7e, 0x1d, 0x2c, 0x0e, 0xdf, 0x2e, 0x01, 0xae, 0x76, 0xcc, 0x04, 0x4f, 0xed, 0x90, 0x23, 0xe4, 0x25,
0x86, 0xf9, 0x6f, 0x42, 0xef, 0x0d, 0x68, 0xb5, 0x16, 0x54, 0x23, 0x4c, 0x83, 0x7e, 0xe4, 0x62, 0xad, 0x60, 0xfe, 0x04, 0xf3, 0x5f, 0x87, 0xfe, 0x5b, 0xe0, 0x75, 0x2d, 0xa8, 0x46, 0x88, 0x92,
0x2a, 0xb8, 0x1a, 0x77, 0xa8, 0x63, 0x98, 0xb1, 0x02, 0x97, 0xef, 0x49, 0x51, 0x1b, 0xef, 0x5c, 0x7e, 0xe4, 0x21, 0x2a, 0xb0, 0x1a, 0x77, 0xa9, 0x63, 0x31, 0x73, 0x05, 0xae, 0x3e, 0x90, 0x04,
0x87, 0xb2, 0xac, 0xee, 0xf2, 0x28, 0x55, 0x3b, 0x9e, 0xf2, 0x84, 0x4a, 0xb0, 0x49, 0xad, 0x2f, 0x38, 0xf6, 0x5c, 0x87, 0xb2, 0x9c, 0x04, 0xf2, 0x2a, 0x55, 0x27, 0xde, 0xf2, 0xe4, 0x4b, 0x64,
0x2b, 0x4d, 0xac, 0xce, 0x5d, 0x3f, 0x45, 0x1f, 0x0a, 0x80, 0x1d, 0x03, 0x8d, 0x1d, 0xa8, 0x7d, 0x93, 0xb9, 0x50, 0x56, 0xfc, 0x59, 0xdd, 0xbb, 0x7e, 0x0a, 0x97, 0x14, 0x02, 0x4e, 0x2c, 0x68,
0xe7, 0x90, 0x8b, 0xef, 0x87, 0x11, 0xcc, 0xc8, 0x7d, 0x54, 0xac, 0x43, 0xda, 0x42, 0x9b, 0xac, 0xee, 0x40, 0xed, 0x5b, 0x17, 0x5f, 0xfe, 0xec, 0x8c, 0x60, 0x46, 0xfa, 0x51, 0xb1, 0x0e, 0xf1,
0x2d, 0x72, 0xaf, 0xa3, 0x2d, 0x5a, 0x2f, 0x67, 0xa0, 0x28, 0xba, 0x21, 0xda, 0x83, 0x92, 0xd4, 0x10, 0x6d, 0x32, 0x0f, 0xc9, 0x9d, 0x87, 0x87, 0xb4, 0x5e, 0xcf, 0x40, 0x51, 0x4c, 0x4e, 0x7d,
0x8d, 0xc8, 0x32, 0x27, 0xfd, 0x0a, 0x32, 0x47, 0x74, 0xba, 0xfe, 0xc9, 0xf4, 0x06, 0xea, 0x68, 0x0f, 0x4a, 0x92, 0x63, 0xea, 0xb6, 0x35, 0xe9, 0x17, 0x93, 0x35, 0xc2, 0xe9, 0x8d, 0x8f, 0xa7,
0x3f, 0x42, 0x51, 0xe8, 0x3b, 0xb4, 0x32, 0xd9, 0x34, 0xad, 0x36, 0xf5, 0x8f, 0xa6, 0xc2, 0xaa, 0x57, 0x50, 0x57, 0xfb, 0x01, 0x8a, 0x82, 0x0b, 0xea, 0x2b, 0x93, 0x55, 0xd3, 0xcc, 0xd4, 0xf8,
0x1d, 0x3a, 0x50, 0x92, 0xa2, 0x29, 0xeb, 0x38, 0x23, 0x22, 0x52, 0xff, 0x78, 0x1a, 0x83, 0x64, 0x70, 0x2a, 0x59, 0xe5, 0xa1, 0x03, 0x25, 0x49, 0xb0, 0xb2, 0xae, 0x33, 0x42, 0x38, 0x8d, 0x8f,
0xa3, 0xa7, 0x30, 0x7b, 0x42, 0x9d, 0xa1, 0xd6, 0x34, 0xe6, 0x27, 0x9b, 0xf4, 0x19, 0xb7, 0x7c, 0xa6, 0x51, 0x48, 0x1c, 0x3d, 0x87, 0xd9, 0x13, 0x4c, 0x4e, 0x6f, 0x4d, 0xa3, 0x7e, 0x72, 0xa0,
0x0c, 0xf9, 0x4d, 0xcc, 0x50, 0x73, 0xb2, 0xd1, 0xb1, 0x84, 0xd3, 0x3f, 0x9c, 0x02, 0x99, 0xf0, 0x9f, 0xd1, 0xe5, 0x53, 0xc8, 0x6f, 0x22, 0xa6, 0x37, 0x27, 0x2b, 0x1d, 0xd3, 0x3d, 0xe3, 0x83,
0x56, 0xe0, 0xd5, 0x13, 0x99, 0x93, 0x4d, 0x86, 0x15, 0x97, 0x6e, 0x4d, 0x8d, 0x57, 0x1b, 0xb5, 0x29, 0x24, 0x13, 0xdc, 0x0a, 0xbc, 0xd3, 0xea, 0xd6, 0x64, 0x95, 0x61, 0x76, 0x66, 0xd8, 0x53,
0xa1, 0xc0, 0x05, 0x14, 0xca, 0x88, 0x2d, 0x25, 0xb2, 0xf4, 0xc5, 0x91, 0xe4, 0xde, 0xe0, 0x3f, 0xcb, 0x2b, 0x47, 0x6d, 0x28, 0x70, 0xb2, 0xa5, 0x67, 0xc4, 0x96, 0x22, 0x64, 0xc6, 0xe2, 0x48,
0xc0, 0xd1, 0x16, 0x14, 0xf8, 0x53, 0x42, 0x19, 0x79, 0x38, 0x2a, 0x8e, 0xc6, 0x7a, 0x7c, 0x08, 0x72, 0x6f, 0xf0, 0x1f, 0xeb, 0xfa, 0x16, 0x14, 0x78, 0x29, 0xe9, 0x19, 0x79, 0x38, 0x4a, 0xa4,
0xd5, 0x44, 0x37, 0x64, 0x51, 0x31, 0x2c, 0x30, 0xc6, 0x3a, 0xbd, 0x0f, 0x65, 0xd5, 0xf1, 0x51, 0xc6, 0x5a, 0x7c, 0x0c, 0xd5, 0x84, 0x63, 0x64, 0x41, 0x31, 0x4c, 0x46, 0xc6, 0x1a, 0x7d, 0x08,
0xc6, 0x7d, 0x9f, 0x14, 0x06, 0x13, 0x1c, 0x16, 0x45, 0x07, 0xcf, 0x8a, 0x70, 0xb8, 0xcd, 0x8f, 0x65, 0xc5, 0x0e, 0xf4, 0x8c, 0xf7, 0x3e, 0x49, 0x22, 0x26, 0x18, 0x2c, 0x8a, 0x69, 0x9f, 0x15,
0x75, 0xf8, 0x00, 0x4a, 0xb2, 0x95, 0x67, 0x3d, 0x9a, 0x91, 0x86, 0x3f, 0xd6, 0x25, 0x81, 0x4a, 0xe1, 0x30, 0x25, 0x18, 0x6b, 0xf0, 0x11, 0x94, 0xe4, 0xd8, 0xcf, 0x2a, 0x9a, 0x11, 0x72, 0x30,
0xdc, 0x8d, 0xd1, 0xf5, 0xec, 0x1c, 0x49, 0x35, 0x7f, 0xdd, 0x9c, 0x16, 0xae, 0x32, 0xea, 0x19, 0xd6, 0x24, 0x86, 0x4a, 0x3c, 0xb9, 0xf5, 0x9b, 0xd9, 0x39, 0x92, 0x22, 0x0a, 0x86, 0x35, 0xad,
0x40, 0xaa, 0x5f, 0xde, 0xcc, 0xa0, 0xf8, 0xb4, 0xce, 0xaf, 0x7f, 0x7a, 0x36, 0x23, 0xb5, 0xf1, 0xb8, 0xca, 0xa8, 0x17, 0x00, 0xa9, 0x79, 0x79, 0x3b, 0x03, 0xe2, 0xd3, 0x26, 0xbf, 0xf1, 0xc9,
0x03, 0x28, 0xc9, 0x86, 0x98, 0x45, 0xdb, 0x48, 0xdb, 0x1c, 0x4b, 0xdb, 0x0e, 0x94, 0x55, 0xeb, 0xd9, 0x94, 0x94, 0xe3, 0x47, 0x50, 0x92, 0x03, 0x31, 0x0b, 0xb6, 0x91, 0xb1, 0x39, 0x16, 0xb6,
0xca, 0xca, 0x95, 0x93, 0xdd, 0x50, 0xbf, 0x3e, 0x25, 0x5a, 0x85, 0xfe, 0x03, 0x14, 0x78, 0xcf, 0x1d, 0x28, 0xab, 0xd1, 0x95, 0x95, 0x2b, 0x27, 0xa7, 0xa1, 0x71, 0x73, 0x4a, 0x69, 0x15, 0xfa,
0xc9, 0x7a, 0x85, 0xa9, 0xfe, 0xa7, 0xaf, 0x4c, 0x03, 0x95, 0xee, 0x57, 0xbf, 0x3d, 0x7c, 0xb5, 0xf7, 0x50, 0xe0, 0x33, 0x27, 0xab, 0x0a, 0x53, 0xf3, 0xcf, 0x58, 0x99, 0x46, 0x54, 0x9a, 0x5f,
0x74, 0xe9, 0xcf, 0x57, 0x4b, 0x97, 0x7e, 0x1d, 0x2c, 0x69, 0x87, 0x83, 0x25, 0xed, 0x8f, 0xc1, 0xfd, 0xe6, 0xf0, 0xcd, 0xd2, 0x95, 0x3f, 0xde, 0x2c, 0x5d, 0xf9, 0x65, 0xb0, 0xa4, 0x1d, 0x0e,
0x92, 0xf6, 0xcf, 0x60, 0x49, 0x7b, 0x7c, 0xe7, 0xf5, 0xfe, 0x5a, 0x77, 0x5b, 0x0c, 0x9e, 0x94, 0x96, 0xb4, 0xdf, 0x07, 0x4b, 0xda, 0xdf, 0x83, 0x25, 0xed, 0xe9, 0xbd, 0xf3, 0xfd, 0x65, 0xef,
0x04, 0x5d, 0x37, 0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xe9, 0xe2, 0x8e, 0x41, 0xf4, 0x13, 0x00, 0xae, 0x58, 0x3c, 0x2b, 0x09, 0xb8, 0x6e, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x67, 0xc5, 0x63,
0x00, 0x32, 0x20, 0x14, 0x00, 0x00,
} }

5
api/services/tasks/v1/tasks.proto
View File

@ -170,8 +170,9 @@ message ListPidsRequest {
string container_id = 1; string container_id = 1;
} }
message ListPidsResponse{ message ListPidsResponse {
repeated uint32 pids = 1; // Processes includes the process ID and additional process information
repeated containerd.v1.types.ProcessInfo processes = 1;
} }
message CheckpointTaskRequest { message CheckpointTaskRequest {

243
api/types/task/task.pb.go
View File

@ -10,6 +10,7 @@
It has these top-level messages: It has these top-level messages:
Process Process
ProcessInfo
*/ */
package task package task
@ -18,6 +19,7 @@ import fmt "fmt"
import math "math" import math "math"
import _ "github.com/gogo/protobuf/gogoproto" import _ "github.com/gogo/protobuf/gogoproto"
import _ "github.com/gogo/protobuf/types" import _ "github.com/gogo/protobuf/types"
import google_protobuf2 "github.com/gogo/protobuf/types"
import time "time" import time "time"
@ -90,8 +92,22 @@ func (m *Process) Reset() { *m = Process{} }
func (*Process) ProtoMessage() {} func (*Process) ProtoMessage() {}
func (*Process) Descriptor() ([]byte, []int) { return fileDescriptorTask, []int{0} } func (*Process) Descriptor() ([]byte, []int) { return fileDescriptorTask, []int{0} }
type ProcessInfo struct {
// PID is the process ID.
Pid uint32 `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"`
// Info contains additional process information.
//
// Info varies by platform.
Info *google_protobuf2.Any `protobuf:"bytes,2,opt,name=info" json:"info,omitempty"`
}
func (m *ProcessInfo) Reset() { *m = ProcessInfo{} }
func (*ProcessInfo) ProtoMessage() {}
func (*ProcessInfo) Descriptor() ([]byte, []int) { return fileDescriptorTask, []int{1} }
func init() { func init() {
proto.RegisterType((*Process)(nil), "containerd.v1.types.Process") proto.RegisterType((*Process)(nil), "containerd.v1.types.Process")
proto.RegisterType((*ProcessInfo)(nil), "containerd.v1.types.ProcessInfo")
proto.RegisterEnum("containerd.v1.types.Status", Status_name, Status_value) proto.RegisterEnum("containerd.v1.types.Status", Status_name, Status_value)
} }
func (m *Process) Marshal() (dAtA []byte, err error) { func (m *Process) Marshal() (dAtA []byte, err error) {
@ -175,6 +191,39 @@ func (m *Process) MarshalTo(dAtA []byte) (int, error) {
return i, nil return i, nil
} }
func (m *ProcessInfo) 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 *ProcessInfo) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Pid != 0 {
dAtA[i] = 0x8
i++
i = encodeVarintTask(dAtA, i, uint64(m.Pid))
}
if m.Info != nil {
dAtA[i] = 0x12
i++
i = encodeVarintTask(dAtA, i, uint64(m.Info.Size()))
n2, err := m.Info.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n2
}
return i, nil
}
func encodeFixed64Task(dAtA []byte, offset int, v uint64) int { func encodeFixed64Task(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v) dAtA[offset] = uint8(v)
dAtA[offset+1] = uint8(v >> 8) dAtA[offset+1] = uint8(v >> 8)
@ -242,6 +291,19 @@ func (m *Process) Size() (n int) {
return n return n
} }
func (m *ProcessInfo) Size() (n int) {
var l int
_ = l
if m.Pid != 0 {
n += 1 + sovTask(uint64(m.Pid))
}
if m.Info != nil {
l = m.Info.Size()
n += 1 + l + sovTask(uint64(l))
}
return n
}
func sovTask(x uint64) (n int) { func sovTask(x uint64) (n int) {
for { for {
n++ n++
@ -274,6 +336,17 @@ func (this *Process) String() string {
}, "") }, "")
return s return s
} }
func (this *ProcessInfo) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&ProcessInfo{`,
`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
`Info:` + strings.Replace(fmt.Sprintf("%v", this.Info), "Any", "google_protobuf2.Any", 1) + `,`,
`}`,
}, "")
return s
}
func valueToStringTask(v interface{}) string { func valueToStringTask(v interface{}) string {
rv := reflect.ValueOf(v) rv := reflect.ValueOf(v)
if rv.IsNil() { if rv.IsNil() {
@ -584,6 +657,108 @@ func (m *Process) Unmarshal(dAtA []byte) error {
} }
return nil return nil
} }
func (m *ProcessInfo) 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: ProcessInfo: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ProcessInfo: 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 ErrIntOverflowTask
}
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 Info", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTask
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthTask
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Info == nil {
m.Info = &google_protobuf2.Any{}
}
if err := m.Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
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 skipTask(dAtA []byte) (n int, err error) { func skipTask(dAtA []byte) (n int, err error) {
l := len(dAtA) l := len(dAtA)
iNdEx := 0 iNdEx := 0
@ -694,37 +869,39 @@ func init() {
} }
var fileDescriptorTask = []byte{ var fileDescriptorTask = []byte{
// 503 bytes of a gzipped FileDescriptorProto // 543 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0x3d, 0x6f, 0xd3, 0x40, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xcf, 0x6e, 0xd3, 0x4c,
0x1c, 0xc6, 0x73, 0x6e, 0xe3, 0x24, 0x97, 0xb6, 0x98, 0xa3, 0xaa, 0x2c, 0x83, 0x6c, 0x8b, 0x29, 0x14, 0xc5, 0x33, 0x6e, 0xe3, 0x24, 0xe3, 0xb6, 0x9f, 0x3f, 0x13, 0x55, 0xc6, 0x20, 0xdb, 0xea,
0x62, 0xb0, 0x45, 0xba, 0xb1, 0xe5, 0x4d, 0x28, 0x42, 0x72, 0xa3, 0x4b, 0x22, 0xc6, 0xc8, 0xc9, 0xca, 0x62, 0x61, 0x8b, 0x74, 0xc7, 0x2e, 0xff, 0x84, 0x2c, 0x24, 0x37, 0x72, 0x12, 0xb1, 0x8c,
0x1d, 0xe6, 0xd4, 0xe6, 0xce, 0xb2, 0xcf, 0xbc, 0x6c, 0x8c, 0xa8, 0x13, 0x5f, 0xa0, 0x13, 0x7c, 0x9c, 0x78, 0x62, 0x46, 0x6d, 0x66, 0x2c, 0x7b, 0x0c, 0x64, 0xc7, 0x12, 0x75, 0xc5, 0x0b, 0x74,
0x0a, 0x3e, 0x41, 0x46, 0x26, 0xc4, 0x14, 0xa8, 0x3f, 0x09, 0x3a, 0xdb, 0x09, 0x19, 0x58, 0xac, 0x05, 0x4f, 0xc1, 0x13, 0x64, 0xc9, 0x0a, 0xb1, 0x0a, 0xd4, 0x4f, 0x82, 0xc6, 0x76, 0xd2, 0x08,
0x7b, 0x9e, 0xdf, 0x73, 0x8f, 0xff, 0xf7, 0x87, 0x2f, 0x22, 0x26, 0xdf, 0x66, 0x4b, 0x6f, 0x25, 0xd8, 0x8c, 0xee, 0x3d, 0xbf, 0x33, 0x77, 0xee, 0x1c, 0xf8, 0x22, 0xc2, 0xec, 0x4d, 0x36, 0xb7,
0xd6, 0xfe, 0x4a, 0x70, 0x19, 0x32, 0x4e, 0x13, 0x72, 0x78, 0x0c, 0x63, 0xe6, 0xcb, 0x8f, 0x31, 0x17, 0x74, 0xe5, 0x2c, 0x28, 0x61, 0x01, 0x26, 0x28, 0x09, 0x0f, 0xcb, 0x20, 0xc6, 0x0e, 0x5b,
0x4d, 0x7d, 0x19, 0xa6, 0xd7, 0xc5, 0xc7, 0x8b, 0x13, 0x21, 0x05, 0x7a, 0xf4, 0x2f, 0xe5, 0xbd, 0xc7, 0x28, 0x75, 0x58, 0x90, 0x5e, 0x17, 0x87, 0x1d, 0x27, 0x94, 0x51, 0xe5, 0xd1, 0x83, 0xcb,
0x7b, 0xee, 0x15, 0x21, 0xeb, 0x3c, 0x12, 0x91, 0x28, 0xb8, 0xaf, 0x4e, 0x65, 0xd4, 0x72, 0x22, 0x7e, 0xfb, 0xdc, 0x2e, 0x4c, 0x5a, 0x3b, 0xa2, 0x11, 0x2d, 0xb8, 0xc3, 0xab, 0xd2, 0xaa, 0x19,
0x21, 0xa2, 0x1b, 0xea, 0x17, 0x6a, 0x99, 0xbd, 0xf1, 0x25, 0x5b, 0xd3, 0x54, 0x86, 0xeb, 0xb8, 0x11, 0xa5, 0xd1, 0x0d, 0x72, 0x8a, 0x6e, 0x9e, 0x2d, 0x1d, 0x86, 0x57, 0x28, 0x65, 0xc1, 0x2a,
0x0c, 0x3c, 0xcd, 0x35, 0xd8, 0x98, 0x24, 0x62, 0x45, 0xd3, 0x14, 0x75, 0xe1, 0xc9, 0xbe, 0x79, 0xae, 0x0c, 0x8f, 0xff, 0x34, 0x04, 0x64, 0x5d, 0xa2, 0x8b, 0x5c, 0x80, 0x8d, 0x51, 0x42, 0x17,
0xc1, 0x88, 0x09, 0x5c, 0xd0, 0x69, 0xf5, 0x1f, 0xe4, 0x5b, 0xa7, 0x3d, 0xd8, 0xf9, 0xe3, 0x21, 0x28, 0x4d, 0x95, 0x0e, 0x3c, 0xd9, 0x3f, 0x3a, 0xc3, 0xa1, 0x0a, 0x4c, 0x60, 0xb5, 0x7a, 0xff,
0x6e, 0xef, 0x43, 0x63, 0x82, 0x2e, 0xa0, 0xc6, 0x88, 0xa9, 0x15, 0x49, 0x3d, 0xdf, 0x3a, 0xda, 0xe5, 0x5b, 0x43, 0xea, 0xef, 0x74, 0x77, 0xe0, 0x4b, 0x7b, 0x93, 0x1b, 0x2a, 0xe7, 0x50, 0xc0,
0x78, 0x88, 0x35, 0x46, 0x90, 0x01, 0x8f, 0x62, 0x46, 0xcc, 0x23, 0x17, 0x74, 0x4e, 0xb1, 0x3a, 0xa1, 0x2a, 0x14, 0x4e, 0x31, 0xdf, 0x1a, 0x82, 0x3b, 0xf0, 0x05, 0x1c, 0x2a, 0x32, 0x3c, 0x8a,
0xa2, 0x4b, 0xa8, 0xa7, 0x32, 0x94, 0x59, 0x6a, 0x1e, 0xbb, 0xa0, 0x73, 0xd6, 0x7d, 0xec, 0xfd, 0x71, 0xa8, 0x1e, 0x99, 0xc0, 0x3a, 0xf5, 0x79, 0xa9, 0x5c, 0x42, 0x31, 0x65, 0x01, 0xcb, 0x52,
0xe7, 0x19, 0xde, 0xb4, 0x88, 0xe0, 0x2a, 0x8a, 0xce, 0x61, 0x3d, 0x95, 0x84, 0x71, 0xb3, 0xae, 0xf5, 0xd8, 0x04, 0xd6, 0x59, 0xe7, 0x89, 0xfd, 0x8f, 0x1f, 0xda, 0xe3, 0xc2, 0xe2, 0x57, 0x56,
0xfe, 0x80, 0x4b, 0x81, 0x2e, 0x54, 0x15, 0x11, 0x99, 0x34, 0xf5, 0xc2, 0xae, 0x54, 0xe5, 0xd3, 0xa5, 0x0d, 0xeb, 0x29, 0x0b, 0x31, 0x51, 0xeb, 0xfc, 0x05, 0xbf, 0x6c, 0x94, 0x73, 0x3e, 0x2a,
0x24, 0x31, 0x1b, 0x7b, 0x9f, 0x26, 0x09, 0xb2, 0x60, 0x53, 0xd2, 0x64, 0xcd, 0x78, 0x78, 0x63, 0xa4, 0x19, 0x53, 0xc5, 0x42, 0xae, 0xba, 0x4a, 0x47, 0x49, 0xa2, 0x36, 0xf6, 0x3a, 0x4a, 0x12,
0x36, 0x5d, 0xd0, 0x69, 0xe2, 0xbd, 0x46, 0x0e, 0x6c, 0xd3, 0x0f, 0x4c, 0x2e, 0xaa, 0xd9, 0x5a, 0x45, 0x83, 0x4d, 0x86, 0x92, 0x15, 0x26, 0xc1, 0x8d, 0xda, 0x34, 0x81, 0xd5, 0xf4, 0xf7, 0xbd,
0xc5, 0xc0, 0x50, 0x59, 0xe5, 0x28, 0xa8, 0x07, 0x5b, 0x4a, 0x51, 0xb2, 0x08, 0xa5, 0x09, 0x5d, 0x62, 0x40, 0x09, 0xbd, 0xc7, 0x6c, 0x56, 0xed, 0xd6, 0x2a, 0x16, 0x86, 0x5c, 0x2a, 0x57, 0x51,
0xd0, 0x69, 0x77, 0x2d, 0xaf, 0x5c, 0xab, 0xb7, 0x5b, 0xab, 0x37, 0xdb, 0xad, 0xb5, 0xdf, 0xdc, 0xba, 0xb0, 0xc5, 0x3b, 0x14, 0xce, 0x02, 0xa6, 0x42, 0x13, 0x58, 0x52, 0x47, 0xb3, 0xcb, 0x40,
0x6c, 0x9d, 0xda, 0x97, 0xdf, 0x0e, 0xc0, 0xcd, 0xf2, 0x5a, 0x4f, 0x3e, 0xfb, 0x09, 0xa0, 0x5e, 0xed, 0x5d, 0xa0, 0xf6, 0x64, 0x97, 0x78, 0xaf, 0xb9, 0xd9, 0x1a, 0xb5, 0x4f, 0x3f, 0x0d, 0xe0,
0xb5, 0xd9, 0xb0, 0x31, 0x0f, 0x5e, 0x05, 0x57, 0xaf, 0x03, 0xa3, 0x66, 0x3d, 0xbc, 0xbd, 0x73, 0x37, 0xcb, 0x6b, 0x5d, 0x76, 0xe1, 0x42, 0xa9, 0xca, 0xd8, 0x25, 0x4b, 0xba, 0xcb, 0x06, 0x3c,
0x4f, 0x4b, 0x30, 0xe7, 0xd7, 0x5c, 0xbc, 0xe7, 0x8a, 0x0f, 0xf0, 0xa8, 0x37, 0x1b, 0x0d, 0x0d, 0x64, 0x63, 0xc1, 0x63, 0x4c, 0x96, 0xb4, 0xc8, 0x51, 0xea, 0xb4, 0xff, 0x1a, 0xdf, 0x25, 0x6b,
0x70, 0xc8, 0x07, 0x09, 0x0d, 0x25, 0x25, 0x8a, 0xe3, 0x79, 0x10, 0x8c, 0x83, 0x97, 0x86, 0x76, 0xbf, 0x70, 0x3c, 0xfb, 0x0e, 0xa0, 0x58, 0x2d, 0xa6, 0xc3, 0xc6, 0xd4, 0x7b, 0xe5, 0x5d, 0xbd,
0xc8, 0x71, 0xc6, 0x39, 0xe3, 0x91, 0xe2, 0xd3, 0xd9, 0xd5, 0x64, 0x32, 0x1a, 0x1a, 0x47, 0x87, 0xf6, 0xe4, 0x9a, 0xf6, 0xff, 0xed, 0x9d, 0x79, 0x5a, 0x82, 0x29, 0xb9, 0x26, 0xf4, 0x1d, 0xe1,
0x7c, 0x2a, 0x45, 0x1c, 0x53, 0x82, 0x9e, 0x40, 0x7d, 0xd2, 0x9b, 0x4f, 0x47, 0x43, 0xe3, 0xd8, 0xbc, 0xef, 0x0f, 0xbb, 0x93, 0xe1, 0x40, 0x06, 0x87, 0xbc, 0x9f, 0xa0, 0x80, 0xa1, 0x90, 0x73,
0x32, 0x6e, 0xef, 0xdc, 0x93, 0x12, 0x4f, 0xc2, 0x2c, 0x2d, 0xdb, 0x15, 0x55, 0xed, 0xf5, 0xc3, 0x7f, 0xea, 0x79, 0xae, 0xf7, 0x52, 0x16, 0x0e, 0xb9, 0x9f, 0x11, 0x82, 0x49, 0xc4, 0xf9, 0x78,
0xdb, 0x0a, 0x33, 0x1e, 0x59, 0x67, 0x9f, 0xbf, 0xda, 0xb5, 0xef, 0xdf, 0xec, 0xea, 0x35, 0x7d, 0x72, 0x35, 0x1a, 0x0d, 0x07, 0xf2, 0xd1, 0x21, 0x1f, 0x33, 0x1a, 0xc7, 0x28, 0x54, 0x9e, 0x42,
0x73, 0x73, 0x6f, 0xd7, 0x7e, 0xdd, 0xdb, 0xb5, 0x4f, 0xb9, 0x0d, 0x36, 0xb9, 0x0d, 0x7e, 0xe4, 0x71, 0xd4, 0x9d, 0x8e, 0x87, 0x03, 0xf9, 0x58, 0x93, 0x6f, 0xef, 0xcc, 0x93, 0x12, 0x8f, 0x82,
0x36, 0xf8, 0x93, 0xdb, 0x60, 0xa9, 0x17, 0xab, 0xb9, 0xfc, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x14, 0x2c, 0x2d, 0xa7, 0x73, 0xca, 0xa7, 0xd7, 0x0f, 0x6f, 0x73, 0x8c, 0x49, 0xa4, 0x9d, 0x7d, 0xfc,
0xf3, 0xee, 0x85, 0xe8, 0x02, 0x00, 0x00, 0xac, 0xd7, 0xbe, 0x7e, 0xd1, 0xab, 0xdf, 0xf4, 0xd4, 0xcd, 0xbd, 0x5e, 0xfb, 0x71, 0xaf, 0xd7,
0x3e, 0xe4, 0x3a, 0xd8, 0xe4, 0x3a, 0xf8, 0x96, 0xeb, 0xe0, 0x57, 0xae, 0x83, 0xb9, 0x58, 0xc4,
0x70, 0xf9, 0x3b, 0x00, 0x00, 0xff, 0xff, 0x19, 0xf7, 0x5b, 0x8f, 0x4e, 0x03, 0x00, 0x00,
} }

10
api/types/task/task.proto
View File

@ -4,6 +4,7 @@ package containerd.v1.types;
import "gogoproto/gogo.proto"; import "gogoproto/gogo.proto";
import "google/protobuf/timestamp.proto"; import "google/protobuf/timestamp.proto";
import "google/protobuf/any.proto";
enum Status { enum Status {
option (gogoproto.goproto_enum_prefix) = false; option (gogoproto.goproto_enum_prefix) = false;
@ -29,3 +30,12 @@ message Process {
uint32 exit_status = 9; uint32 exit_status = 9;
google.protobuf.Timestamp exited_at = 10 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; google.protobuf.Timestamp exited_at = 10 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
} }
message ProcessInfo {
// PID is the process ID.
uint32 pid = 1;
// Info contains additional process information.
//
// Info varies by platform.
google.protobuf.Any info = 2;
}

16
cmd/ctr/ps.go
View File

@ -5,6 +5,7 @@ import (
"os" "os"
"text/tabwriter" "text/tabwriter"
"github.com/containerd/containerd/windows/hcsshimopts"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/urfave/cli" "github.com/urfave/cli"
) )
@ -41,10 +42,19 @@ var taskPsCommand = cli.Command{
return err return err
} }
w := tabwriter.NewWriter(os.Stdout, 10, 1, 3, ' ', 0) w := tabwriter.NewWriter(os.Stdout, 10, 1, 3, ' ', 0)
fmt.Fprintln(w, "PID") fmt.Fprintln(w, "PID\tINFO")
for _, ps := range processes { for _, ps := range processes {
if _, err := fmt.Fprintf(w, "%d\n", ps); err != nil { if ps.Info != nil {
return err var details hcsshimopts.ProcessDetails
if err := details.Unmarshal(ps.Info.Value); err == nil {
if _, err := fmt.Fprintf(w, "%d\t%+v\n", ps.Pid, details); err != nil {
return err
}
}
} else {
if _, err := fmt.Fprintf(w, "%d\t-\n", ps.Pid); err != nil {
return err
}
} }
} }
return w.Flush() return w.Flush()

27
container_test.go
View File

@ -17,6 +17,7 @@ import (
"github.com/containerd/typeurl" "github.com/containerd/typeurl"
"github.com/containerd/containerd/errdefs" "github.com/containerd/containerd/errdefs"
"github.com/containerd/containerd/windows/hcsshimopts"
gogotypes "github.com/gogo/protobuf/types" gogotypes "github.com/gogo/protobuf/types"
) )
@ -377,13 +378,25 @@ func TestContainerPids(t *testing.T) {
t.Error(err) t.Error(err)
return return
} }
if l := len(processes); l != 1 { switch runtime.GOOS {
t.Errorf("expected 1 process but received %d", l) case "windows":
} if processes[0].Info == nil {
if len(processes) > 0 { t.Error("expected additional process information but received nil")
actual := processes[0] } else {
if pid != actual { var details hcsshimopts.ProcessDetails
t.Errorf("expected pid %d but received %d", pid, actual) if err := details.Unmarshal(processes[0].Info.Value); err != nil {
t.Errorf("expected Windows info type hcsshimopts.ProcessDetails %v", err)
}
}
default:
if l := len(processes); l != 1 {
t.Errorf("expected 1 process but received %d", l)
}
if len(processes) > 0 {
actual := processes[0].Pid
if pid != actual {
t.Errorf("expected pid %d but received %d", pid, actual)
}
} }
} }
if err := task.Kill(ctx, syscall.SIGKILL); err != nil { if err := task.Kill(ctx, syscall.SIGKILL); err != nil {

8
linux/shim/service.go
View File

@ -345,8 +345,14 @@ func (s *Service) ListPids(ctx context.Context, r *shimapi.ListPidsRequest) (*sh
if err != nil { if err != nil {
return nil, errdefs.ToGRPC(err) return nil, errdefs.ToGRPC(err)
} }
var processes []*task.ProcessInfo
for _, pid := range pids {
processes = append(processes, &task.ProcessInfo{
Pid: pid,
})
}
return &shimapi.ListPidsResponse{ return &shimapi.ListPidsResponse{
Pids: pids, Processes: processes,
}, nil }, nil
} }

273
linux/shim/v1/shim.pb.go
View File

@ -195,7 +195,7 @@ func (*ListPidsRequest) ProtoMessage() {}
func (*ListPidsRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{11} } func (*ListPidsRequest) Descriptor() ([]byte, []int) { return fileDescriptorShim, []int{11} }
type ListPidsResponse struct { type ListPidsResponse struct {
Pids []uint32 `protobuf:"varint,1,rep,packed,name=pids" json:"pids,omitempty"` Processes []*containerd_v1_types.ProcessInfo `protobuf:"bytes,1,rep,name=processes" json:"processes,omitempty"`
} }
func (m *ListPidsResponse) Reset() { *m = ListPidsResponse{} } func (m *ListPidsResponse) Reset() { *m = ListPidsResponse{} }
@ -1367,22 +1367,17 @@ func (m *ListPidsResponse) MarshalTo(dAtA []byte) (int, error) {
_ = i _ = i
var l int var l int
_ = l _ = l
if len(m.Pids) > 0 { if len(m.Processes) > 0 {
dAtA6 := make([]byte, len(m.Pids)*10) for _, msg := range m.Processes {
var j5 int dAtA[i] = 0xa
for _, num := range m.Pids { i++
for num >= 1<<7 { i = encodeVarintShim(dAtA, i, uint64(msg.Size()))
dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80) n, err := msg.MarshalTo(dAtA[i:])
num >>= 7 if err != nil {
j5++ return 0, err
} }
dAtA6[j5] = uint8(num) i += n
j5++
} }
dAtA[i] = 0xa
i++
i = encodeVarintShim(dAtA, i, uint64(j5))
i += copy(dAtA[i:], dAtA6[:j5])
} }
return i, nil return i, nil
} }
@ -1412,11 +1407,11 @@ func (m *CheckpointTaskRequest) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x12 dAtA[i] = 0x12
i++ i++
i = encodeVarintShim(dAtA, i, uint64(m.Options.Size())) i = encodeVarintShim(dAtA, i, uint64(m.Options.Size()))
n7, err := m.Options.MarshalTo(dAtA[i:]) n5, err := m.Options.MarshalTo(dAtA[i:])
if err != nil { if err != nil {
return 0, err return 0, err
} }
i += n7 i += n5
} }
return i, nil return i, nil
} }
@ -1463,11 +1458,11 @@ func (m *UpdateTaskRequest) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa dAtA[i] = 0xa
i++ i++
i = encodeVarintShim(dAtA, i, uint64(m.Resources.Size())) i = encodeVarintShim(dAtA, i, uint64(m.Resources.Size()))
n8, err := m.Resources.MarshalTo(dAtA[i:]) n6, err := m.Resources.MarshalTo(dAtA[i:])
if err != nil { if err != nil {
return 0, err return 0, err
} }
i += n8 i += n6
} }
return i, nil return i, nil
} }
@ -1572,11 +1567,11 @@ func (m *WaitResponse) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x12 dAtA[i] = 0x12
i++ i++
i = encodeVarintShim(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt))) i = encodeVarintShim(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt)))
n9, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i:]) n7, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i:])
if err != nil { if err != nil {
return 0, err return 0, err
} }
i += n9 i += n7
return i, nil return i, nil
} }
@ -1834,12 +1829,11 @@ func (m *ListPidsRequest) Size() (n int) {
func (m *ListPidsResponse) Size() (n int) { func (m *ListPidsResponse) Size() (n int) {
var l int var l int
_ = l _ = l
if len(m.Pids) > 0 { if len(m.Processes) > 0 {
l = 0 for _, e := range m.Processes {
for _, e := range m.Pids { l = e.Size()
l += sovShim(uint64(e)) n += 1 + l + sovShim(uint64(l))
} }
n += 1 + sovShim(uint64(l)) + l
} }
return n return n
} }
@ -2089,7 +2083,7 @@ func (this *ListPidsResponse) String() string {
return "nil" return "nil"
} }
s := strings.Join([]string{`&ListPidsResponse{`, s := strings.Join([]string{`&ListPidsResponse{`,
`Pids:` + fmt.Sprintf("%v", this.Pids) + `,`, `Processes:` + strings.Replace(fmt.Sprintf("%v", this.Processes), "ProcessInfo", "containerd_v1_types.ProcessInfo", 1) + `,`,
`}`, `}`,
}, "") }, "")
return s return s
@ -3900,67 +3894,36 @@ func (m *ListPidsResponse) Unmarshal(dAtA []byte) error {
} }
switch fieldNum { switch fieldNum {
case 1: case 1:
if wireType == 0 { if wireType != 2 {
var v uint32 return fmt.Errorf("proto: wrong wireType = %d for field Processes", wireType)
for shift := uint(0); ; shift += 7 { }
if shift >= 64 { var msglen int
return ErrIntOverflowShim for shift := uint(0); ; shift += 7 {
} if shift >= 64 {
if iNdEx >= l { return ErrIntOverflowShim
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
} }
m.Pids = append(m.Pids, v) if iNdEx >= l {
} else if wireType == 2 {
var packedLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowShim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
packedLen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if packedLen < 0 {
return ErrInvalidLengthShim
}
postIndex := iNdEx + packedLen
if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
for iNdEx < postIndex { b := dAtA[iNdEx]
var v uint32 iNdEx++
for shift := uint(0); ; shift += 7 { msglen |= (int(b) & 0x7F) << shift
if shift >= 64 { if b < 0x80 {
return ErrIntOverflowShim break
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.Pids = append(m.Pids, v)
} }
} else {
return fmt.Errorf("proto: wrong wireType = %d for field Pids", wireType)
} }
if msglen < 0 {
return ErrInvalidLengthShim
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Processes = append(m.Processes, &containerd_v1_types.ProcessInfo{})
if err := m.Processes[len(m.Processes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default: default:
iNdEx = preIndex iNdEx = preIndex
skippy, err := skipShim(dAtA[iNdEx:]) skippy, err := skipShim(dAtA[iNdEx:])
@ -4711,76 +4674,76 @@ func init() {
} }
var fileDescriptorShim = []byte{ var fileDescriptorShim = []byte{
// 1123 bytes of a gzipped FileDescriptorProto // 1131 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0xcd, 0x6e, 0xdb, 0x46, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0x4f, 0x4f, 0x1b, 0x47,
0x10, 0x36, 0xf5, 0xaf, 0x51, 0xe4, 0xda, 0x5b, 0xc7, 0x65, 0x14, 0x40, 0x16, 0x08, 0xd4, 0x50, 0x14, 0x67, 0x8d, 0xff, 0x3e, 0xc7, 0x14, 0xa6, 0x84, 0x6e, 0x1c, 0xc9, 0x58, 0x2b, 0x35, 0xa2,
0x51, 0x84, 0xaa, 0xe5, 0x22, 0x69, 0x5a, 0xa0, 0x80, 0xed, 0x04, 0x85, 0xd1, 0x1a, 0x31, 0x68, 0xaa, 0xb2, 0x2e, 0xa6, 0x4a, 0x9a, 0x56, 0x8a, 0x04, 0x24, 0xaa, 0x50, 0x8b, 0x82, 0x16, 0xd2,
0xa7, 0x29, 0x5a, 0x14, 0x06, 0x2d, 0xae, 0xa5, 0x85, 0x29, 0x92, 0xe1, 0x2e, 0x5d, 0xbb, 0xa7, 0x54, 0xad, 0x2a, 0xb4, 0x78, 0x07, 0x7b, 0x84, 0xbd, 0xb3, 0xd9, 0x99, 0xa5, 0xd0, 0x53, 0x4f,
0x9e, 0x7a, 0xee, 0xe3, 0xf4, 0x11, 0x7c, 0xc8, 0xa1, 0xc7, 0x9e, 0xd2, 0xc6, 0xf7, 0xbe, 0x43, 0x3d, 0xf7, 0xe3, 0xf4, 0x23, 0x70, 0xc8, 0xa1, 0xc7, 0x9e, 0xd2, 0xc6, 0xf7, 0x7e, 0x87, 0x68,
0xb1, 0x3f, 0x92, 0x28, 0xc9, 0x0c, 0x29, 0x5f, 0xac, 0x9d, 0xe5, 0x37, 0xbb, 0xb3, 0xf3, 0x7d, 0xfe, 0x18, 0xaf, 0x6d, 0x36, 0xbb, 0xe6, 0x82, 0xf7, 0xcd, 0xfc, 0xde, 0xcc, 0x9b, 0xf7, 0xfb,
0x3b, 0xb3, 0x86, 0xa7, 0x7d, 0xc2, 0x06, 0xd1, 0xa9, 0xd9, 0xf3, 0x87, 0x9d, 0x9e, 0xef, 0x31, 0xcd, 0x7b, 0x03, 0x3c, 0xe9, 0x12, 0xde, 0x8b, 0x4e, 0xec, 0x0e, 0x1d, 0xb4, 0x3a, 0xd4, 0xe7,
0x9b, 0x78, 0x38, 0x74, 0xe2, 0x43, 0x97, 0x78, 0xd1, 0x65, 0x87, 0x0e, 0xc8, 0xb0, 0x73, 0xb1, 0x2e, 0xf1, 0x71, 0xe8, 0xc5, 0x3f, 0xfb, 0xc4, 0x8f, 0x2e, 0x5a, 0xac, 0x47, 0x06, 0xad, 0xf3,
0x25, 0x7e, 0xcd, 0x20, 0xf4, 0x99, 0x8f, 0x5a, 0x13, 0x90, 0x19, 0x46, 0x1e, 0x23, 0x43, 0x6c, 0x4d, 0xf9, 0x6b, 0x07, 0x21, 0xe5, 0x14, 0x35, 0xc7, 0x20, 0x3b, 0x8c, 0x7c, 0x4e, 0x06, 0xd8,
0x0a, 0xb0, 0x29, 0x40, 0x17, 0x5b, 0x8d, 0x07, 0x7d, 0xdf, 0xef, 0xbb, 0xb8, 0x23, 0xf0, 0xa7, 0x96, 0x60, 0x5b, 0x82, 0xce, 0x37, 0xeb, 0xf7, 0xba, 0x94, 0x76, 0xfb, 0xb8, 0x25, 0xf1, 0x27,
0xd1, 0x59, 0xc7, 0xf6, 0xae, 0xa4, 0x73, 0xe3, 0xe1, 0xec, 0x27, 0x3c, 0x0c, 0xd8, 0xe8, 0xe3, 0xd1, 0x69, 0xcb, 0xf5, 0x2f, 0x95, 0x73, 0xfd, 0xfe, 0xf4, 0x14, 0x1e, 0x04, 0x7c, 0x34, 0xb9,
0x5a, 0xdf, 0xef, 0xfb, 0x62, 0xd8, 0xe1, 0x23, 0x35, 0xbb, 0x31, 0xeb, 0xc2, 0x77, 0xa4, 0xcc, 0xda, 0xa5, 0x5d, 0x2a, 0x3f, 0x5b, 0xe2, 0x4b, 0x8f, 0xae, 0x4f, 0xbb, 0x88, 0x1d, 0x19, 0x77,
0x1e, 0x06, 0x0a, 0xf0, 0x38, 0xf5, 0x2c, 0x76, 0x40, 0x3a, 0xec, 0x2a, 0xc0, 0xb4, 0x33, 0xf4, 0x07, 0x81, 0x06, 0x3c, 0x4a, 0x3d, 0x8b, 0x1b, 0x90, 0x16, 0xbf, 0x0c, 0x30, 0x6b, 0x0d, 0x68,
0x23, 0x8f, 0x29, 0xbf, 0x2f, 0x17, 0xf0, 0x63, 0x36, 0x3d, 0x17, 0x7f, 0xa4, 0xaf, 0xf1, 0x5f, 0xe4, 0x73, 0xed, 0xf7, 0xf5, 0x1c, 0x7e, 0xdc, 0x65, 0x67, 0xf2, 0x8f, 0xf2, 0xb5, 0xfe, 0xcf,
0x0e, 0x56, 0xf7, 0x42, 0x6c, 0x33, 0x7c, 0x6c, 0xd3, 0x73, 0x0b, 0xbf, 0x8e, 0x30, 0x65, 0x68, 0xc1, 0xca, 0x6e, 0x88, 0x5d, 0x8e, 0x8f, 0x5c, 0x76, 0xe6, 0xe0, 0xd7, 0x11, 0x66, 0x1c, 0xad,
0x1d, 0x72, 0xc4, 0xd1, 0xb5, 0x96, 0xd6, 0xae, 0xee, 0x96, 0x6e, 0xde, 0x6e, 0xe4, 0xf6, 0x9f, 0x41, 0x8e, 0x78, 0xa6, 0xd1, 0x34, 0x36, 0x2a, 0x3b, 0xc5, 0xe1, 0xdb, 0xf5, 0xdc, 0xde, 0x33,
0x59, 0x39, 0xe2, 0xa0, 0x75, 0x28, 0x9d, 0x46, 0x9e, 0xe3, 0x62, 0x3d, 0xc7, 0xbf, 0x59, 0xca, 0x27, 0x47, 0x3c, 0xb4, 0x06, 0xc5, 0x93, 0xc8, 0xf7, 0xfa, 0xd8, 0xcc, 0x89, 0x39, 0x47, 0x5b,
0x42, 0x3a, 0x94, 0x55, 0x06, 0xf5, 0xbc, 0xf8, 0x30, 0x32, 0x51, 0x07, 0x4a, 0xa1, 0xef, 0xb3, 0xc8, 0x84, 0x92, 0xce, 0xa0, 0xb9, 0x28, 0x27, 0x46, 0x26, 0x6a, 0x41, 0x31, 0xa4, 0x94, 0x9f,
0x33, 0xaa, 0x17, 0x5a, 0xf9, 0x76, 0xad, 0xfb, 0x91, 0x19, 0xcb, 0xba, 0x08, 0xc9, 0x3c, 0xe0, 0x32, 0x33, 0xdf, 0x5c, 0xdc, 0xa8, 0xb6, 0x3f, 0xb1, 0x63, 0x59, 0x97, 0x21, 0xd9, 0xfb, 0xe2,
0x47, 0xb1, 0x14, 0x0c, 0x35, 0xa0, 0xc2, 0x70, 0x38, 0x24, 0x9e, 0xed, 0xea, 0xc5, 0x96, 0xd6, 0x28, 0x8e, 0x86, 0xa1, 0x3a, 0x94, 0x39, 0x0e, 0x07, 0xc4, 0x77, 0xfb, 0x66, 0xa1, 0x69, 0x6c,
0xae, 0x58, 0x63, 0x1b, 0xad, 0x41, 0x91, 0x32, 0x87, 0x78, 0x7a, 0x49, 0x6c, 0x22, 0x0d, 0x1e, 0x94, 0x9d, 0x6b, 0x1b, 0xad, 0x42, 0x81, 0x71, 0x8f, 0xf8, 0x66, 0x51, 0x6e, 0xa2, 0x0c, 0x11,
0x14, 0x65, 0x8e, 0x1f, 0x31, 0xbd, 0x2c, 0x83, 0x92, 0x96, 0x9a, 0xc7, 0x61, 0xa8, 0x57, 0xc6, 0x14, 0xe3, 0x1e, 0x8d, 0xb8, 0x59, 0x52, 0x41, 0x29, 0x4b, 0x8f, 0xe3, 0x30, 0x34, 0xcb, 0xd7,
0xf3, 0x38, 0x0c, 0x51, 0x13, 0xa0, 0x37, 0xc0, 0xbd, 0xf3, 0xc0, 0x27, 0x1e, 0xd3, 0xab, 0xe2, 0xe3, 0x38, 0x0c, 0x51, 0x03, 0xa0, 0xd3, 0xc3, 0x9d, 0xb3, 0x80, 0x12, 0x9f, 0x9b, 0x15, 0x39,
0x5b, 0x6c, 0x06, 0x7d, 0x0a, 0xab, 0x81, 0x1d, 0x62, 0x8f, 0x9d, 0xc4, 0x60, 0x20, 0x60, 0x2b, 0x17, 0x1b, 0x41, 0x9f, 0xc3, 0x4a, 0xe0, 0x86, 0xd8, 0xe7, 0xc7, 0x31, 0x18, 0x48, 0xd8, 0xb2,
0xf2, 0xc3, 0xde, 0x04, 0x6c, 0x42, 0xd9, 0x0f, 0x18, 0xf1, 0x3d, 0xaa, 0xd7, 0x5a, 0x5a, 0xbb, 0x9a, 0xd8, 0x1d, 0x83, 0x6d, 0x28, 0xd1, 0x80, 0x13, 0xea, 0x33, 0xb3, 0xda, 0x34, 0x36, 0xaa,
0xd6, 0x5d, 0x33, 0x25, 0xcd, 0xe6, 0x88, 0x66, 0x73, 0xc7, 0xbb, 0xb2, 0x46, 0x20, 0x63, 0x13, 0xed, 0x55, 0x5b, 0xd1, 0x6c, 0x8f, 0x68, 0xb6, 0xb7, 0xfd, 0x4b, 0x67, 0x04, 0xb2, 0x1e, 0x00,
0x50, 0x3c, 0xdd, 0x34, 0xf0, 0x3d, 0x8a, 0xd1, 0x0a, 0xe4, 0x03, 0x95, 0xf0, 0xba, 0xc5, 0x87, 0x8a, 0xa7, 0x9b, 0x05, 0xd4, 0x67, 0x18, 0x2d, 0xc3, 0x62, 0xa0, 0x13, 0x5e, 0x73, 0xc4, 0xa7,
0xc6, 0xef, 0x1a, 0x2c, 0x3f, 0xc3, 0x2e, 0x66, 0x38, 0x19, 0x84, 0x36, 0xa0, 0x86, 0x2f, 0x09, 0xf5, 0x87, 0x01, 0x4b, 0xcf, 0x70, 0x1f, 0x73, 0x9c, 0x0c, 0x42, 0xeb, 0x50, 0xc5, 0x17, 0x84,
0x3b, 0xa1, 0xcc, 0x66, 0x11, 0x15, 0x9c, 0xd4, 0x2d, 0xe0, 0x53, 0x47, 0x62, 0x06, 0xed, 0x40, 0x1f, 0x33, 0xee, 0xf2, 0x88, 0x49, 0x4e, 0x6a, 0x0e, 0x88, 0xa1, 0x43, 0x39, 0x82, 0xb6, 0xa1,
0x95, 0x5b, 0xd8, 0x39, 0xb1, 0x99, 0x60, 0xa6, 0xd6, 0x6d, 0xcc, 0xc5, 0x77, 0x3c, 0x92, 0xe1, 0x22, 0x2c, 0xec, 0x1d, 0xbb, 0x5c, 0x32, 0x53, 0x6d, 0xd7, 0x67, 0xe2, 0x3b, 0x1a, 0xc9, 0x70,
0x6e, 0xe5, 0xfa, 0xed, 0xc6, 0xd2, 0x1f, 0xff, 0x6c, 0x68, 0x56, 0x45, 0xba, 0xed, 0x30, 0xc3, 0xa7, 0x7c, 0xf5, 0x76, 0x7d, 0xe1, 0xcf, 0x7f, 0xd7, 0x0d, 0xa7, 0xac, 0xdc, 0xb6, 0xb9, 0x65,
0x84, 0x35, 0x19, 0xc7, 0x61, 0xe8, 0xf7, 0x30, 0xa5, 0x29, 0x12, 0x31, 0xfe, 0xd4, 0x00, 0x3d, 0xc3, 0xaa, 0x8a, 0xe3, 0x20, 0xa4, 0x1d, 0xcc, 0x58, 0x8a, 0x44, 0xac, 0xbf, 0x0c, 0x40, 0xcf,
0xbf, 0xc4, 0xbd, 0x6c, 0xf0, 0x29, 0xba, 0x73, 0x49, 0x74, 0xe7, 0x6f, 0xa7, 0xbb, 0x90, 0x40, 0x2f, 0x70, 0x27, 0x1b, 0x7c, 0x82, 0xee, 0x5c, 0x12, 0xdd, 0x8b, 0x37, 0xd3, 0x9d, 0x4f, 0xa0,
0x77, 0x71, 0x8a, 0xee, 0x36, 0x14, 0x68, 0x80, 0x7b, 0x42, 0x33, 0x49, 0xf4, 0x08, 0x84, 0x71, 0xbb, 0x30, 0x41, 0xf7, 0x06, 0xe4, 0x59, 0x80, 0x3b, 0x52, 0x33, 0x49, 0xf4, 0x48, 0x84, 0x75,
0x1f, 0x3e, 0x9c, 0x8a, 0x5c, 0xe6, 0xdd, 0xf8, 0x01, 0x56, 0x2c, 0x4c, 0xc9, 0xaf, 0xf8, 0x90, 0x17, 0x3e, 0x9e, 0x88, 0x5c, 0xe5, 0xdd, 0xfa, 0x11, 0x96, 0x1d, 0xcc, 0xc8, 0x6f, 0xf8, 0x80,
0x5d, 0xa5, 0x1d, 0x67, 0x0d, 0x8a, 0xbf, 0x10, 0x87, 0x0d, 0x14, 0x17, 0xd2, 0xe0, 0xa1, 0x0d, 0x5f, 0xa6, 0x1d, 0x67, 0x15, 0x0a, 0xbf, 0x12, 0x8f, 0xf7, 0x34, 0x17, 0xca, 0x10, 0xa1, 0xf5,
0x30, 0xe9, 0x0f, 0x24, 0x07, 0x75, 0x4b, 0x59, 0xc6, 0x26, 0xdc, 0xe3, 0x44, 0xe1, 0xb4, 0x9c, 0x30, 0xe9, 0xf6, 0x14, 0x07, 0x35, 0x47, 0x5b, 0xd6, 0x03, 0xb8, 0x23, 0x88, 0xc2, 0x69, 0x39,
0xbe, 0xc9, 0x41, 0x5d, 0x01, 0x95, 0x16, 0x16, 0xbd, 0xa0, 0x4a, 0x3b, 0xf9, 0x89, 0x76, 0xb6, 0x7d, 0x93, 0x83, 0x9a, 0x06, 0x6a, 0x2d, 0xcc, 0x7b, 0x41, 0xb5, 0x76, 0x16, 0xc7, 0xda, 0xd9,
0x79, 0xba, 0x84, 0x6c, 0x78, 0x1a, 0x97, 0xbb, 0x0f, 0xe3, 0x17, 0xf3, 0x62, 0x4b, 0xdd, 0x4d, 0x12, 0xe9, 0x92, 0xb2, 0x11, 0x69, 0x5c, 0x6a, 0xdf, 0x8f, 0x5f, 0xcc, 0xf3, 0x4d, 0x7d, 0x37,
0xa9, 0x23, 0x4b, 0x41, 0x27, 0x8c, 0x14, 0x6f, 0x67, 0xa4, 0x94, 0xc0, 0x48, 0x79, 0x8a, 0x91, 0x95, 0x8e, 0x1c, 0x0d, 0x1d, 0x33, 0x52, 0xb8, 0x99, 0x91, 0x62, 0x02, 0x23, 0xa5, 0x09, 0x46,
0x38, 0xe7, 0x95, 0x19, 0xce, 0x67, 0x24, 0x5d, 0x7d, 0xbf, 0xa4, 0xe1, 0x4e, 0x92, 0x7e, 0x01, 0xe2, 0x9c, 0x97, 0xa7, 0x38, 0x9f, 0x92, 0x74, 0xe5, 0xc3, 0x92, 0x86, 0x5b, 0x49, 0xfa, 0x05,
0xb5, 0x6f, 0x89, 0xeb, 0x66, 0x28, 0x76, 0x94, 0xf4, 0x47, 0xc2, 0xac, 0x5b, 0xca, 0xe2, 0xb9, 0x54, 0xbf, 0x23, 0xfd, 0x7e, 0x86, 0x62, 0xc7, 0x48, 0x77, 0x24, 0xcc, 0x9a, 0xa3, 0x2d, 0x91,
0xb4, 0x5d, 0x57, 0xe4, 0xb2, 0x62, 0xf1, 0xa1, 0xf1, 0x35, 0x2c, 0xef, 0xb9, 0x3e, 0xc5, 0xfb, 0x4b, 0xb7, 0xdf, 0x97, 0xb9, 0x2c, 0x3b, 0xe2, 0xd3, 0x7a, 0x0a, 0x4b, 0xbb, 0x7d, 0xca, 0xf0,
0x2f, 0x32, 0xe8, 0x43, 0x26, 0x50, 0x6a, 0x5d, 0x1a, 0xc6, 0x27, 0xf0, 0xc1, 0x77, 0x84, 0xb2, 0xde, 0x8b, 0x0c, 0xfa, 0x50, 0x09, 0x54, 0x5a, 0x57, 0x86, 0xf5, 0x19, 0x7c, 0xf4, 0x3d, 0x61,
0x43, 0xe2, 0xa4, 0x5e, 0xaf, 0x4d, 0x58, 0x99, 0x40, 0x95, 0x18, 0x10, 0x14, 0x02, 0xe2, 0x50, 0xfc, 0x80, 0x78, 0xa9, 0xd7, 0xcb, 0x81, 0xe5, 0x31, 0x54, 0x8b, 0xe1, 0x29, 0x54, 0x02, 0xa5,
0x5d, 0x6b, 0xe5, 0xdb, 0x75, 0x4b, 0x8c, 0x8d, 0x9f, 0xe0, 0xfe, 0xa4, 0x4a, 0xc5, 0x4b, 0x3b, 0x59, 0xcc, 0x4c, 0x43, 0x96, 0xd9, 0xe6, 0x8d, 0x6c, 0x6a, 0x65, 0xef, 0xf9, 0xa7, 0xd4, 0x19,
0x07, 0xdb, 0x6c, 0x20, 0x97, 0xb6, 0xc4, 0x38, 0x5e, 0xc4, 0x72, 0x59, 0x8a, 0xd8, 0x23, 0x58, 0xbb, 0x58, 0x3f, 0xc3, 0xdd, 0x71, 0x45, 0x8b, 0xb7, 0x01, 0x04, 0xf9, 0xc0, 0xe5, 0x3d, 0x15,
0x39, 0x1a, 0x90, 0xe1, 0xbe, 0x77, 0xe6, 0x8f, 0x83, 0x78, 0x00, 0x15, 0xde, 0x36, 0x4f, 0x26, 0x86, 0x23, 0xbf, 0xe3, 0x05, 0x2f, 0x97, 0xa5, 0xe0, 0x3d, 0x84, 0xe5, 0xc3, 0x1e, 0x19, 0xc8,
0x25, 0xaa, 0xcc, 0xed, 0x43, 0xe2, 0x18, 0xdf, 0xc0, 0xea, 0xcb, 0xc0, 0x99, 0x69, 0x31, 0x5d, 0x3d, 0x47, 0x01, 0xdf, 0x83, 0xb2, 0x68, 0xb1, 0xc7, 0xe3, 0x72, 0x56, 0x12, 0xf6, 0x01, 0xf1,
0xa8, 0x86, 0x98, 0xfa, 0x51, 0xd8, 0xc3, 0x54, 0x38, 0x24, 0xed, 0x3a, 0x81, 0xa9, 0xfb, 0x12, 0xac, 0x6f, 0x61, 0xe5, 0x65, 0xe0, 0x4d, 0xb5, 0xa3, 0x36, 0x54, 0x42, 0xcc, 0x68, 0x14, 0x76,
0xb2, 0xb4, 0x24, 0x3d, 0x15, 0xd7, 0x85, 0xe3, 0x52, 0xae, 0x8b, 0xba, 0x16, 0xb9, 0x49, 0xdd, 0xe4, 0x01, 0x93, 0x77, 0x1d, 0xc3, 0xf4, 0xdd, 0x0a, 0x79, 0x5a, 0x42, 0x9f, 0xc8, 0xab, 0x25,
0xfd, 0x18, 0x6a, 0xaf, 0x6c, 0x92, 0xba, 0x43, 0x08, 0xf7, 0x24, 0x4c, 0x6d, 0x30, 0x23, 0x5b, 0x70, 0x29, 0x57, 0x4b, 0x5f, 0xa1, 0xdc, 0xb8, 0x46, 0x7f, 0x0a, 0xd5, 0x57, 0x2e, 0x49, 0xdd,
0xed, 0xfd, 0xb2, 0xcd, 0xdd, 0x45, 0xb6, 0xdd, 0x37, 0x35, 0x28, 0xf0, 0xb4, 0xa3, 0x01, 0x14, 0x21, 0x84, 0x3b, 0x0a, 0xa6, 0x37, 0x98, 0x92, 0xb8, 0xf1, 0x61, 0x89, 0xe7, 0x6e, 0x23, 0xf1,
0x45, 0x35, 0x40, 0xa6, 0x99, 0xf6, 0x84, 0x31, 0xe3, 0xf5, 0xa5, 0xd1, 0xc9, 0x8c, 0x57, 0xc7, 0xf6, 0x9b, 0x2a, 0xe4, 0x45, 0xda, 0x51, 0x0f, 0x0a, 0xb2, 0x72, 0x20, 0xdb, 0x4e, 0x7b, 0xee,
0xa2, 0x50, 0x92, 0xdd, 0x0a, 0x6d, 0xa7, 0xbb, 0xce, 0x3d, 0x23, 0x1a, 0x9f, 0x2f, 0xe6, 0xa4, 0xd8, 0xf1, 0x5a, 0x54, 0x6f, 0x65, 0xc6, 0xeb, 0x63, 0x31, 0x28, 0xaa, 0xce, 0x86, 0xb6, 0xd2,
0x36, 0x95, 0xc7, 0x0b, 0x59, 0xc6, 0xe3, 0x8d, 0xe5, 0x90, 0xf1, 0x78, 0x31, 0x59, 0x58, 0x50, 0x5d, 0x67, 0x9e, 0x1c, 0xf5, 0x2f, 0xe7, 0x73, 0xd2, 0x9b, 0xaa, 0xe3, 0x85, 0x3c, 0xe3, 0xf1,
0x92, 0xbd, 0x0d, 0xad, 0xcf, 0x71, 0xf1, 0x9c, 0xbf, 0xe7, 0x1a, 0x9f, 0xa5, 0x2f, 0x39, 0xd3, 0xae, 0xe5, 0x90, 0xf1, 0x78, 0x31, 0x59, 0x38, 0x50, 0x54, 0x7d, 0x10, 0xad, 0xcd, 0x70, 0xf1,
0xa5, 0xaf, 0xa0, 0x3e, 0xd5, 0x2f, 0xd1, 0xe3, 0xac, 0x4b, 0x4c, 0x77, 0xcc, 0x3b, 0x6c, 0xfd, 0x5c, 0xbc, 0xfd, 0xea, 0x5f, 0xa4, 0x2f, 0x39, 0xd5, 0xd1, 0x2f, 0xa1, 0x36, 0xd1, 0x5b, 0xd1,
0x1a, 0x2a, 0xa3, 0xda, 0x80, 0xb6, 0xd2, 0xbd, 0x67, 0x4a, 0x4e, 0xa3, 0xbb, 0x88, 0x8b, 0xda, 0xa3, 0xac, 0x4b, 0x4c, 0x76, 0xd7, 0x5b, 0x6c, 0xfd, 0x1a, 0xca, 0xa3, 0x3a, 0x82, 0x36, 0xd3,
0xf2, 0x09, 0x14, 0x0f, 0xed, 0x88, 0x26, 0x27, 0x30, 0x61, 0x1e, 0x7d, 0x01, 0x25, 0x0b, 0xd3, 0xbd, 0xa7, 0xca, 0x53, 0xbd, 0x3d, 0x8f, 0x8b, 0xde, 0xf2, 0x31, 0x14, 0x0e, 0xdc, 0x88, 0x25,
0x68, 0xb8, 0xb8, 0xe7, 0xcf, 0x00, 0xb1, 0xf7, 0xd7, 0x93, 0x0c, 0x12, 0xbb, 0xad, 0x0e, 0x26, 0x27, 0x30, 0x61, 0x1c, 0x7d, 0x05, 0x45, 0x07, 0xb3, 0x68, 0x30, 0xbf, 0xe7, 0x2f, 0x00, 0xb1,
0x2e, 0x7f, 0x00, 0x05, 0xde, 0x1c, 0xd0, 0xa3, 0xf4, 0x85, 0x63, 0x4d, 0x24, 0x71, 0xb9, 0x63, 0xb7, 0xda, 0xe3, 0x0c, 0x12, 0xbb, 0xa9, 0x0e, 0x26, 0x2e, 0xbf, 0x0f, 0x79, 0xd1, 0x48, 0xd0,
0x28, 0xf0, 0x37, 0x05, 0xca, 0x70, 0x15, 0xe6, 0x5f, 0x4d, 0x89, 0xab, 0xbe, 0x82, 0xea, 0xf8, 0xc3, 0xf4, 0x85, 0x63, 0x0d, 0x27, 0x71, 0xb9, 0x23, 0xc8, 0x8b, 0xf7, 0x07, 0xca, 0x70, 0x15,
0x49, 0x82, 0x32, 0xf0, 0x36, 0xfb, 0x7e, 0x49, 0x5c, 0xf8, 0x08, 0xca, 0xaa, 0x93, 0xa1, 0x0c, 0x66, 0x5f, 0x58, 0x89, 0xab, 0xbe, 0x82, 0xca, 0xf5, 0xf3, 0x05, 0x65, 0xe0, 0x6d, 0xfa, 0xad,
0xfa, 0x9b, 0x6e, 0x7a, 0x89, 0x8b, 0x7e, 0x0f, 0x95, 0x51, 0xbb, 0x48, 0x64, 0x3b, 0xc3, 0x21, 0x93, 0xb8, 0xf0, 0x21, 0x94, 0x74, 0xd7, 0x43, 0x19, 0xf4, 0x37, 0xd9, 0x20, 0x13, 0x17, 0xfd,
0xe6, 0x5a, 0xce, 0x4b, 0x28, 0xc9, 0xbe, 0x92, 0xa5, 0x3a, 0xcd, 0x75, 0xa0, 0xc4, 0x70, 0x31, 0x01, 0xca, 0xa3, 0x76, 0x91, 0xc8, 0x76, 0x86, 0x43, 0xcc, 0xb4, 0x9c, 0x97, 0x50, 0x54, 0x7d,
0x14, 0x78, 0x6d, 0xcf, 0xa2, 0x80, 0x58, 0xab, 0x68, 0x98, 0x59, 0xe1, 0x32, 0xfa, 0xdd, 0x83, 0x25, 0x4b, 0x75, 0x9a, 0xe9, 0x40, 0x89, 0xe1, 0x62, 0xc8, 0x8b, 0xda, 0x9e, 0x45, 0x01, 0xb1,
0xeb, 0x77, 0xcd, 0xa5, 0xbf, 0xdf, 0x35, 0x97, 0x7e, 0xbb, 0x69, 0x6a, 0xd7, 0x37, 0x4d, 0xed, 0x56, 0x51, 0xb7, 0xb3, 0xc2, 0x55, 0xf4, 0x3b, 0xfb, 0x57, 0xef, 0x1a, 0x0b, 0xff, 0xbc, 0x6b,
0xaf, 0x9b, 0xa6, 0xf6, 0xef, 0x4d, 0x53, 0xfb, 0x71, 0x7b, 0xb1, 0xff, 0x69, 0xbf, 0xe2, 0xbf, 0x2c, 0xfc, 0x3e, 0x6c, 0x18, 0x57, 0xc3, 0x86, 0xf1, 0xf7, 0xb0, 0x61, 0xfc, 0x37, 0x6c, 0x18,
0xa7, 0x25, 0x71, 0x8a, 0xed, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0x70, 0x88, 0x12, 0x32, 0x11, 0x3f, 0x6d, 0xcd, 0xf7, 0xff, 0xef, 0x37, 0xe2, 0xf7, 0xa4, 0x28, 0x4f, 0xb1, 0xf5, 0x3e, 0x00,
0x0f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xad, 0x60, 0x08, 0x28, 0x3d, 0x0f, 0x00, 0x00,
} }

4
linux/shim/v1/shim.proto
View File

@ -129,8 +129,8 @@ message ListPidsRequest {
string id = 1; string id = 1;
} }
message ListPidsResponse{ message ListPidsResponse {
repeated uint32 pids = 1; repeated containerd.v1.types.ProcessInfo processes = 1;
} }
message CheckpointTaskRequest { message CheckpointTaskRequest {

10
linux/task.go
View File

@ -172,14 +172,20 @@ func (t *Task) Exec(ctx context.Context, id string, opts runtime.ExecOpts) (runt
} }
// Pids returns all system level process ids running inside the task // Pids returns all system level process ids running inside the task
func (t *Task) Pids(ctx context.Context) ([]uint32, error) { func (t *Task) Pids(ctx context.Context) ([]runtime.ProcessInfo, error) {
resp, err := t.shim.ListPids(ctx, &shim.ListPidsRequest{ resp, err := t.shim.ListPids(ctx, &shim.ListPidsRequest{
ID: t.id, ID: t.id,
}) })
if err != nil { if err != nil {
return nil, errdefs.FromGRPC(err) return nil, errdefs.FromGRPC(err)
} }
return resp.Pids, nil var processList []runtime.ProcessInfo
for _, p := range resp.Processes {
processList = append(processList, runtime.ProcessInfo{
Pid: p.Pid,
})
}
return processList, nil
} }
// ResizePty changes the side of the task's PTY to the provided width and height // ResizePty changes the side of the task's PTY to the provided width and height

10
runtime/task.go
View File

@ -42,7 +42,7 @@ type Task interface {
// Exec adds a process into the container // Exec adds a process into the container
Exec(context.Context, string, ExecOpts) (Process, error) Exec(context.Context, string, ExecOpts) (Process, error)
// Pids returns all pids // Pids returns all pids
Pids(context.Context) ([]uint32, error) Pids(context.Context) ([]ProcessInfo, error)
// Checkpoint checkpoints a container to an image with live system data // Checkpoint checkpoints a container to an image with live system data
Checkpoint(context.Context, string, *types.Any) error Checkpoint(context.Context, string, *types.Any) error
// DeleteProcess deletes a specific exec process via its id // DeleteProcess deletes a specific exec process via its id
@ -92,3 +92,11 @@ type State struct {
Stderr string Stderr string
Terminal bool Terminal bool
} }
type ProcessInfo struct {
// Pid is the process ID
Pid uint32
// Info includes additional process information
// Info varies by platform
Info interface{}
}

19
services/tasks/service.go
View File

@ -27,6 +27,7 @@ import (
"github.com/containerd/containerd/runtime" "github.com/containerd/containerd/runtime"
"github.com/containerd/typeurl" "github.com/containerd/typeurl"
google_protobuf "github.com/golang/protobuf/ptypes/empty" google_protobuf "github.com/golang/protobuf/ptypes/empty"
"github.com/pkg/errors"
"golang.org/x/net/context" "golang.org/x/net/context"
"google.golang.org/grpc" "google.golang.org/grpc"
"google.golang.org/grpc/codes" "google.golang.org/grpc/codes"
@ -331,12 +332,26 @@ func (s *Service) ListPids(ctx context.Context, r *api.ListPidsRequest) (*api.Li
if err != nil { if err != nil {
return nil, err return nil, err
} }
pids, err := t.Pids(ctx) processList, err := t.Pids(ctx)
if err != nil { if err != nil {
return nil, errdefs.ToGRPC(err) return nil, errdefs.ToGRPC(err)
} }
var processes []*task.ProcessInfo
for _, p := range processList {
processInfo := task.ProcessInfo{
Pid: p.Pid,
}
if p.Info != nil {
a, err := typeurl.MarshalAny(p.Info)
if err != nil {
return nil, errors.Wrapf(err, "failed to marshal process %d info", p.Pid)
}
processInfo.Info = a
}
processes = append(processes, &processInfo)
}
return &api.ListPidsResponse{ return &api.ListPidsResponse{
Pids: pids, Processes: processes,
}, nil }, nil
} }

19
task.go
View File

@ -20,6 +20,7 @@ import (
"github.com/containerd/containerd/plugin" "github.com/containerd/containerd/plugin"
"github.com/containerd/containerd/rootfs" "github.com/containerd/containerd/rootfs"
"github.com/containerd/typeurl" "github.com/containerd/typeurl"
google_protobuf "github.com/gogo/protobuf/types"
digest "github.com/opencontainers/go-digest" digest "github.com/opencontainers/go-digest"
"github.com/opencontainers/image-spec/specs-go/v1" "github.com/opencontainers/image-spec/specs-go/v1"
specs "github.com/opencontainers/runtime-spec/specs-go" specs "github.com/opencontainers/runtime-spec/specs-go"
@ -41,6 +42,14 @@ type Status struct {
ExitTime time.Time ExitTime time.Time
} }
type ProcessInfo struct {
// Pid is the process ID
Pid uint32
// Info includes additional process information
// Info varies by platform
Info *google_protobuf.Any
}
// ProcessStatus returns a human readable status for the Process representing its current status // ProcessStatus returns a human readable status for the Process representing its current status
type ProcessStatus string type ProcessStatus string
@ -107,7 +116,7 @@ type Task interface {
// Exec creates a new process inside the task // Exec creates a new process inside the task
Exec(context.Context, string, *specs.Process, IOCreation) (Process, error) Exec(context.Context, string, *specs.Process, IOCreation) (Process, error)
// Pids returns a list of system specific process ids inside the task // Pids returns a list of system specific process ids inside the task
Pids(context.Context) ([]uint32, error) Pids(context.Context) ([]ProcessInfo, error)
// Checkpoint serializes the runtime and memory information of a task into an // Checkpoint serializes the runtime and memory information of a task into an
// OCI Index that can be push and pulled from a remote resource. // OCI Index that can be push and pulled from a remote resource.
// //
@ -294,14 +303,18 @@ func (t *task) Exec(ctx context.Context, id string, spec *specs.Process, ioCreat
}, nil }, nil
} }
func (t *task) Pids(ctx context.Context) ([]uint32, error) { func (t *task) Pids(ctx context.Context) ([]ProcessInfo, error) {
response, err := t.client.TaskService().ListPids(ctx, &tasks.ListPidsRequest{ response, err := t.client.TaskService().ListPids(ctx, &tasks.ListPidsRequest{
ContainerID: t.id, ContainerID: t.id,
}) })
if err != nil { if err != nil {
return nil, errdefs.FromGRPC(err) return nil, errdefs.FromGRPC(err)
} }
return response.Pids, nil var processList []ProcessInfo
for _, p := range response.Processes {
processList = append(processList, ProcessInfo(*p))
}
return processList, nil
} }
func (t *task) CloseIO(ctx context.Context, opts ...IOCloserOpts) error { func (t *task) CloseIO(ctx context.Context, opts ...IOCloserOpts) error {

406
windows/hcsshimopts/hcsshim.pb.go
View File

@ -10,6 +10,7 @@
It has these top-level messages: It has these top-level messages:
CreateOptions CreateOptions
ProcessDetails
*/ */
package hcsshimopts package hcsshimopts
@ -18,6 +19,7 @@ import fmt "fmt"
import math "math" import math "math"
import _ "github.com/gogo/protobuf/gogoproto" import _ "github.com/gogo/protobuf/gogoproto"
import _ "github.com/golang/protobuf/ptypes/duration" import _ "github.com/golang/protobuf/ptypes/duration"
import google_protobuf2 "github.com/gogo/protobuf/types"
import time "time" import time "time"
@ -48,8 +50,26 @@ func (m *CreateOptions) Reset() { *m = CreateOptions{} }
func (*CreateOptions) ProtoMessage() {} func (*CreateOptions) ProtoMessage() {}
func (*CreateOptions) Descriptor() ([]byte, []int) { return fileDescriptorHcsshim, []int{0} } func (*CreateOptions) Descriptor() ([]byte, []int) { return fileDescriptorHcsshim, []int{0} }
// ProcessDetails contains additional information about a process
// ProcessDetails is made of the same fields as found in hcsshim.ProcessListItem
type ProcessDetails struct {
ImageName string `protobuf:"bytes,1,opt,name=image_name,json=imageName,proto3" json:"image_name,omitempty"`
CreatedAt *google_protobuf2.Timestamp `protobuf:"bytes,2,opt,name=created_at,json=createdAt" json:"created_at,omitempty"`
KernelTime_100Ns uint64 `protobuf:"varint,3,opt,name=kernel_time_100_ns,json=kernelTime100Ns,proto3" json:"kernel_time_100_ns,omitempty"`
MemoryCommitBytes uint64 `protobuf:"varint,4,opt,name=memory_commit_bytes,json=memoryCommitBytes,proto3" json:"memory_commit_bytes,omitempty"`
MemoryWorkingSetPrivateBytes uint64 `protobuf:"varint,5,opt,name=memory_working_set_private_bytes,json=memoryWorkingSetPrivateBytes,proto3" json:"memory_working_set_private_bytes,omitempty"`
MemoryWorkingSetSharedBytes uint64 `protobuf:"varint,6,opt,name=memory_working_set_shared_bytes,json=memoryWorkingSetSharedBytes,proto3" json:"memory_working_set_shared_bytes,omitempty"`
ProcessID uint32 `protobuf:"varint,7,opt,name=process_id,json=processId,proto3" json:"process_id,omitempty"`
UserTime_100Ns uint64 `protobuf:"varint,8,opt,name=user_time_100_ns,json=userTime100Ns,proto3" json:"user_time_100_ns,omitempty"`
}
func (m *ProcessDetails) Reset() { *m = ProcessDetails{} }
func (*ProcessDetails) ProtoMessage() {}
func (*ProcessDetails) Descriptor() ([]byte, []int) { return fileDescriptorHcsshim, []int{1} }
func init() { func init() {
proto.RegisterType((*CreateOptions)(nil), "containerd.windows.hcsshim.CreateOptions") proto.RegisterType((*CreateOptions)(nil), "containerd.windows.hcsshim.CreateOptions")
proto.RegisterType((*ProcessDetails)(nil), "containerd.windows.hcsshim.ProcessDetails")
} }
func (m *CreateOptions) Marshal() (dAtA []byte, err error) { func (m *CreateOptions) Marshal() (dAtA []byte, err error) {
size := m.Size() size := m.Size()
@ -77,6 +97,70 @@ func (m *CreateOptions) MarshalTo(dAtA []byte) (int, error) {
return i, nil return i, nil
} }
func (m *ProcessDetails) 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 *ProcessDetails) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.ImageName) > 0 {
dAtA[i] = 0xa
i++
i = encodeVarintHcsshim(dAtA, i, uint64(len(m.ImageName)))
i += copy(dAtA[i:], m.ImageName)
}
if m.CreatedAt != nil {
dAtA[i] = 0x12
i++
i = encodeVarintHcsshim(dAtA, i, uint64(m.CreatedAt.Size()))
n2, err := m.CreatedAt.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n2
}
if m.KernelTime_100Ns != 0 {
dAtA[i] = 0x18
i++
i = encodeVarintHcsshim(dAtA, i, uint64(m.KernelTime_100Ns))
}
if m.MemoryCommitBytes != 0 {
dAtA[i] = 0x20
i++
i = encodeVarintHcsshim(dAtA, i, uint64(m.MemoryCommitBytes))
}
if m.MemoryWorkingSetPrivateBytes != 0 {
dAtA[i] = 0x28
i++
i = encodeVarintHcsshim(dAtA, i, uint64(m.MemoryWorkingSetPrivateBytes))
}
if m.MemoryWorkingSetSharedBytes != 0 {
dAtA[i] = 0x30
i++
i = encodeVarintHcsshim(dAtA, i, uint64(m.MemoryWorkingSetSharedBytes))
}
if m.ProcessID != 0 {
dAtA[i] = 0x38
i++
i = encodeVarintHcsshim(dAtA, i, uint64(m.ProcessID))
}
if m.UserTime_100Ns != 0 {
dAtA[i] = 0x40
i++
i = encodeVarintHcsshim(dAtA, i, uint64(m.UserTime_100Ns))
}
return i, nil
}
func encodeFixed64Hcsshim(dAtA []byte, offset int, v uint64) int { func encodeFixed64Hcsshim(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v) dAtA[offset] = uint8(v)
dAtA[offset+1] = uint8(v >> 8) dAtA[offset+1] = uint8(v >> 8)
@ -112,6 +196,38 @@ func (m *CreateOptions) Size() (n int) {
return n return n
} }
func (m *ProcessDetails) Size() (n int) {
var l int
_ = l
l = len(m.ImageName)
if l > 0 {
n += 1 + l + sovHcsshim(uint64(l))
}
if m.CreatedAt != nil {
l = m.CreatedAt.Size()
n += 1 + l + sovHcsshim(uint64(l))
}
if m.KernelTime_100Ns != 0 {
n += 1 + sovHcsshim(uint64(m.KernelTime_100Ns))
}
if m.MemoryCommitBytes != 0 {
n += 1 + sovHcsshim(uint64(m.MemoryCommitBytes))
}
if m.MemoryWorkingSetPrivateBytes != 0 {
n += 1 + sovHcsshim(uint64(m.MemoryWorkingSetPrivateBytes))
}
if m.MemoryWorkingSetSharedBytes != 0 {
n += 1 + sovHcsshim(uint64(m.MemoryWorkingSetSharedBytes))
}
if m.ProcessID != 0 {
n += 1 + sovHcsshim(uint64(m.ProcessID))
}
if m.UserTime_100Ns != 0 {
n += 1 + sovHcsshim(uint64(m.UserTime_100Ns))
}
return n
}
func sovHcsshim(x uint64) (n int) { func sovHcsshim(x uint64) (n int) {
for { for {
n++ n++
@ -135,6 +251,23 @@ func (this *CreateOptions) String() string {
}, "") }, "")
return s return s
} }
func (this *ProcessDetails) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&ProcessDetails{`,
`ImageName:` + fmt.Sprintf("%v", this.ImageName) + `,`,
`CreatedAt:` + strings.Replace(fmt.Sprintf("%v", this.CreatedAt), "Timestamp", "google_protobuf2.Timestamp", 1) + `,`,
`KernelTime_100Ns:` + fmt.Sprintf("%v", this.KernelTime_100Ns) + `,`,
`MemoryCommitBytes:` + fmt.Sprintf("%v", this.MemoryCommitBytes) + `,`,
`MemoryWorkingSetPrivateBytes:` + fmt.Sprintf("%v", this.MemoryWorkingSetPrivateBytes) + `,`,
`MemoryWorkingSetSharedBytes:` + fmt.Sprintf("%v", this.MemoryWorkingSetSharedBytes) + `,`,
`ProcessID:` + fmt.Sprintf("%v", this.ProcessID) + `,`,
`UserTime_100Ns:` + fmt.Sprintf("%v", this.UserTime_100Ns) + `,`,
`}`,
}, "")
return s
}
func valueToStringHcsshim(v interface{}) string { func valueToStringHcsshim(v interface{}) string {
rv := reflect.ValueOf(v) rv := reflect.ValueOf(v)
if rv.IsNil() { if rv.IsNil() {
@ -223,6 +356,232 @@ func (m *CreateOptions) Unmarshal(dAtA []byte) error {
} }
return nil return nil
} }
func (m *ProcessDetails) 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 ErrIntOverflowHcsshim
}
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: ProcessDetails: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ProcessDetails: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ImageName", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHcsshim
}
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 ErrInvalidLengthHcsshim
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ImageName = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHcsshim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthHcsshim
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.CreatedAt == nil {
m.CreatedAt = &google_protobuf2.Timestamp{}
}
if err := m.CreatedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field KernelTime_100Ns", wireType)
}
m.KernelTime_100Ns = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHcsshim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.KernelTime_100Ns |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field MemoryCommitBytes", wireType)
}
m.MemoryCommitBytes = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHcsshim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.MemoryCommitBytes |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 5:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field MemoryWorkingSetPrivateBytes", wireType)
}
m.MemoryWorkingSetPrivateBytes = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHcsshim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.MemoryWorkingSetPrivateBytes |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 6:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field MemoryWorkingSetSharedBytes", wireType)
}
m.MemoryWorkingSetSharedBytes = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHcsshim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.MemoryWorkingSetSharedBytes |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 7:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ProcessID", wireType)
}
m.ProcessID = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHcsshim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ProcessID |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 8:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field UserTime_100Ns", wireType)
}
m.UserTime_100Ns = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHcsshim
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.UserTime_100Ns |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipHcsshim(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthHcsshim
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipHcsshim(dAtA []byte) (n int, err error) { func skipHcsshim(dAtA []byte) (n int, err error) {
l := len(dAtA) l := len(dAtA)
iNdEx := 0 iNdEx := 0
@ -333,20 +692,35 @@ func init() {
} }
var fileDescriptorHcsshim = []byte{ var fileDescriptorHcsshim = []byte{
// 227 bytes of a gzipped FileDescriptorProto // 473 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x72, 0x4a, 0xcf, 0x2c, 0xc9, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x92, 0xc1, 0x6e, 0xd3, 0x30,
0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d, 0x1c, 0xc6, 0x1b, 0x36, 0xc6, 0x6a, 0x54, 0x60, 0x86, 0x43, 0x28, 0x90, 0x54, 0xbb, 0x50, 0x09,
0x4a, 0x41, 0x66, 0x96, 0x67, 0xe6, 0xa5, 0xe4, 0x97, 0x17, 0xeb, 0x67, 0x24, 0x17, 0x17, 0x67, 0x94, 0x74, 0x70, 0x42, 0x5c, 0x20, 0xab, 0x90, 0x76, 0x19, 0x53, 0x86, 0x84, 0xb4, 0x8b, 0xe5,
0x64, 0xe6, 0xe6, 0x17, 0x94, 0xc0, 0xd9, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0x52, 0x08, 0x26, 0x7f, 0x52, 0x6b, 0xb5, 0x1d, 0xd9, 0x2e, 0xd5, 0x6e, 0x3c, 0x06, 0x0f, 0xc1, 0x83, 0xf4,
0xd5, 0x7a, 0x50, 0xd5, 0x7a, 0x50, 0x15, 0x52, 0x22, 0xe9, 0xf9, 0xe9, 0xf9, 0x60, 0x65, 0xfa, 0xc8, 0x91, 0xd3, 0x60, 0x79, 0x12, 0x14, 0xdb, 0x2d, 0x63, 0x70, 0xda, 0xed, 0x1f, 0x7f, 0xbf,
0x20, 0x16, 0x44, 0x87, 0x94, 0x5c, 0x7a, 0x7e, 0x7e, 0x7a, 0x4e, 0xaa, 0x3e, 0x98, 0x97, 0x54, 0xef, 0xfb, 0xc7, 0x5f, 0x82, 0xb2, 0x8a, 0x99, 0xe9, 0x7c, 0x92, 0x14, 0x92, 0xa7, 0x85, 0x14,
0x9a, 0xa6, 0x9f, 0x52, 0x5a, 0x94, 0x58, 0x92, 0x99, 0x9f, 0x07, 0x91, 0x57, 0x4a, 0xe6, 0xe2, 0x86, 0x32, 0x01, 0xaa, 0xbc, 0x3c, 0x2e, 0x98, 0x28, 0xe5, 0x42, 0xa7, 0xd3, 0x42, 0xeb, 0x29,
0x75, 0x2e, 0x4a, 0x4d, 0x2c, 0x49, 0xf5, 0x2f, 0x00, 0x89, 0x16, 0x0b, 0x05, 0x71, 0x09, 0x95, 0xe3, 0xb2, 0x36, 0xeb, 0x39, 0xa9, 0x95, 0x34, 0x12, 0xf7, 0xff, 0xd0, 0x89, 0xa7, 0x13, 0x4f,
0xa4, 0x16, 0xe5, 0x66, 0xe6, 0x25, 0x96, 0xa4, 0xc6, 0xc3, 0x14, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0xf4, 0x1f, 0x54, 0xb2, 0x92, 0x16, 0x4b, 0xdb, 0xc9, 0x39, 0xfa, 0x51, 0x25, 0x65, 0x35, 0x83,
0x70, 0x1b, 0x49, 0xea, 0x41, 0x4c, 0xd3, 0x83, 0x99, 0xa6, 0xe7, 0x02, 0x55, 0xe0, 0xc4, 0x71, 0xd4, 0x3e, 0x4d, 0xe6, 0x9f, 0xd2, 0x72, 0xae, 0xa8, 0x61, 0x52, 0x78, 0x3d, 0xbe, 0xaa, 0x1b,
0xe2, 0x9e, 0x3c, 0xc3, 0x8c, 0xfb, 0xf2, 0x8c, 0x41, 0x82, 0x70, 0xed, 0x70, 0xc9, 0xa8, 0x13, 0xc6, 0x41, 0x1b, 0xca, 0x6b, 0x07, 0xec, 0x16, 0xa8, 0xb7, 0xaf, 0x80, 0x1a, 0x78, 0x5f, 0xb7,
0x0f, 0xe5, 0x18, 0x6e, 0x3c, 0x94, 0x63, 0x68, 0x78, 0x24, 0xc7, 0x78, 0xe2, 0x91, 0x1c, 0xe3, 0x36, 0x8d, 0x73, 0x84, 0x0d, 0x28, 0xce, 0x04, 0x35, 0x40, 0x56, 0x69, 0x61, 0x30, 0x08, 0x86,
0x85, 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, 0x31, 0x46, 0x39, 0x90, 0x13, 0x28, 0xd6, 0x48, 0xec, 0xb7, 0x5f, 0x3c, 0x4c, 0x5c, 0x5c, 0xb2, 0x8a, 0x4b, 0xc6, 0x1e, 0xc8, 0xb6, 0x97, 0xe7, 0x71,
0x24, 0x36, 0xb0, 0x5b, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x75, 0x31, 0x65, 0xd0, 0x5f, 0xe7, 0xeb, 0xcf, 0x38, 0xc8, 0x77, 0xd6, 0xf6, 0x95, 0xb8, 0xfb, 0x6d, 0x03, 0xdd, 0x39, 0x52,
0x01, 0x00, 0x00, 0xb2, 0x00, 0xad, 0xc7, 0x60, 0x28, 0x9b, 0x69, 0xfc, 0x04, 0x21, 0xc6, 0x69, 0x05, 0x44, 0x50,
0x0e, 0x36, 0xbe, 0x9b, 0x77, 0xed, 0xc9, 0x21, 0xe5, 0x80, 0x5f, 0x21, 0x54, 0xd8, 0xd7, 0x2a,
0x09, 0x35, 0xe1, 0x0d, 0xbb, 0xbd, 0xff, 0xcf, 0xf6, 0x0f, 0xab, 0xcb, 0xe4, 0x5d, 0x4f, 0xbf,
0x35, 0xf8, 0x19, 0xc2, 0xa7, 0xa0, 0x04, 0xcc, 0x48, 0x7b, 0x57, 0xb2, 0x37, 0x1a, 0x11, 0xa1,
0xc3, 0x8d, 0x41, 0x30, 0xdc, 0xcc, 0xef, 0x3a, 0xa5, 0xf5, 0xed, 0x8d, 0x46, 0x87, 0x1a, 0x27,
0xe8, 0x3e, 0x07, 0x2e, 0xd5, 0x19, 0x29, 0x24, 0xe7, 0xcc, 0x90, 0xc9, 0x99, 0x01, 0x1d, 0x6e,
0x5a, 0x7a, 0xc7, 0x49, 0xfb, 0x56, 0xc9, 0x5a, 0x01, 0xbf, 0x43, 0x03, 0xcf, 0x2f, 0xa4, 0x3a,
0x65, 0xa2, 0x22, 0x1a, 0x0c, 0xa9, 0x15, 0xfb, 0xdc, 0xd6, 0xe5, 0xcc, 0x37, 0xad, 0xf9, 0xb1,
0xe3, 0x3e, 0x3a, 0xec, 0x18, 0xcc, 0x91, 0x83, 0x5c, 0xce, 0x18, 0xc5, 0xff, 0xc9, 0xd1, 0x53,
0xaa, 0xa0, 0xf4, 0x31, 0x5b, 0x36, 0xe6, 0xd1, 0xd5, 0x98, 0x63, 0xcb, 0xb8, 0x94, 0xe7, 0x08,
0xd5, 0xae, 0x56, 0xc2, 0xca, 0xf0, 0xd6, 0x20, 0x18, 0xf6, 0xb2, 0x5e, 0x73, 0x1e, 0x77, 0x7d,
0xd9, 0x07, 0xe3, 0xbc, 0xeb, 0x81, 0x83, 0x12, 0x3f, 0x45, 0xf7, 0xe6, 0x1a, 0xd4, 0x5f, 0xb5,
0x6c, 0xdb, 0x25, 0xbd, 0xf6, 0x7c, 0x5d, 0x4a, 0x76, 0xb2, 0xbc, 0x88, 0x3a, 0x3f, 0x2e, 0xa2,
0xce, 0x97, 0x26, 0x0a, 0x96, 0x4d, 0x14, 0x7c, 0x6f, 0xa2, 0xe0, 0x57, 0x13, 0x05, 0x27, 0x6f,
0xae, 0xf3, 0x93, 0xbf, 0xbe, 0x34, 0x4f, 0xb6, 0xec, 0xc7, 0x7b, 0xf9, 0x3b, 0x00, 0x00, 0xff,
0xff, 0x75, 0x5d, 0xc9, 0xa6, 0x2f, 0x03, 0x00, 0x00,
} }

14
windows/hcsshimopts/hcsshim.proto
View File

@ -4,9 +4,23 @@ package containerd.windows.hcsshim;
import "gogoproto/gogo.proto"; import "gogoproto/gogo.proto";
import "google/protobuf/duration.proto"; import "google/protobuf/duration.proto";
import "google/protobuf/timestamp.proto";
option go_package = "github.com/containerd/containerd/windows/hcsshimopts;hcsshimopts"; option go_package = "github.com/containerd/containerd/windows/hcsshimopts;hcsshimopts";
message CreateOptions { message CreateOptions {
google.protobuf.Duration terminate_duration = 1 [(gogoproto.stdduration) = true, (gogoproto.nullable) = false]; google.protobuf.Duration terminate_duration = 1 [(gogoproto.stdduration) = true, (gogoproto.nullable) = false];
} }
// ProcessDetails contains additional information about a process
// ProcessDetails is made of the same fields as found in hcsshim.ProcessListItem
message ProcessDetails {
string image_name = 1;
google.protobuf.Timestamp created_at = 2;
uint64 kernel_time_100_ns = 3;
uint64 memory_commit_bytes = 4;
uint64 memory_working_set_private_bytes = 5;
uint64 memory_working_set_shared_bytes = 6;
uint32 process_id = 7;
uint64 user_time_100_ns = 8;
}

92
windows/hcsshimopts/next.pb.txt
View File

@ -29,11 +29,43 @@ file {
} }
syntax: "proto3" syntax: "proto3"
} }
file {
name: "google/protobuf/timestamp.proto"
package: "google.protobuf"
message_type {
name: "Timestamp"
field {
name: "seconds"
number: 1
label: LABEL_OPTIONAL
type: TYPE_INT64
json_name: "seconds"
}
field {
name: "nanos"
number: 2
label: LABEL_OPTIONAL
type: TYPE_INT32
json_name: "nanos"
}
}
options {
java_package: "com.google.protobuf"
java_outer_classname: "TimestampProto"
java_multiple_files: true
go_package: "github.com/golang/protobuf/ptypes/timestamp"
cc_enable_arenas: true
objc_class_prefix: "GPB"
csharp_namespace: "Google.Protobuf.WellKnownTypes"
}
syntax: "proto3"
}
file { file {
name: "github.com/containerd/containerd/windows/hcsshimopts/hcsshim.proto" name: "github.com/containerd/containerd/windows/hcsshimopts/hcsshim.proto"
package: "containerd.windows.hcsshim" package: "containerd.windows.hcsshim"
dependency: "gogoproto/gogo.proto" dependency: "gogoproto/gogo.proto"
dependency: "google/protobuf/duration.proto" dependency: "google/protobuf/duration.proto"
dependency: "google/protobuf/timestamp.proto"
message_type { message_type {
name: "CreateOptions" name: "CreateOptions"
field { field {
@ -49,6 +81,66 @@ file {
json_name: "terminateDuration" json_name: "terminateDuration"
} }
} }
message_type {
name: "ProcessDetails"
field {
name: "image_name"
number: 1
label: LABEL_OPTIONAL
type: TYPE_STRING
json_name: "imageName"
}
field {
name: "created_at"
number: 2
label: LABEL_OPTIONAL
type: TYPE_MESSAGE
type_name: ".google.protobuf.Timestamp"
json_name: "createdAt"
}
field {
name: "kernel_time_100_ns"
number: 3
label: LABEL_OPTIONAL
type: TYPE_UINT64
json_name: "kernelTime100Ns"
}
field {
name: "memory_commit_bytes"
number: 4
label: LABEL_OPTIONAL
type: TYPE_UINT64
json_name: "memoryCommitBytes"
}
field {
name: "memory_working_set_private_bytes"
number: 5
label: LABEL_OPTIONAL
type: TYPE_UINT64
json_name: "memoryWorkingSetPrivateBytes"
}
field {
name: "memory_working_set_shared_bytes"
number: 6
label: LABEL_OPTIONAL
type: TYPE_UINT64
json_name: "memoryWorkingSetSharedBytes"
}
field {
name: "process_id"
number: 7
label: LABEL_OPTIONAL
type: TYPE_UINT32
json_name: "processId"
}
field {
name: "user_time_100_ns"
number: 8
label: LABEL_OPTIONAL
type: TYPE_UINT64
json_name: "userTime100Ns"
}
}
options { options {
go_package: "github.com/containerd/containerd/windows/hcsshimopts;hcsshimopts" go_package: "github.com/containerd/containerd/windows/hcsshimopts;hcsshimopts"
} }

45
windows/task.go
View File

@ -12,6 +12,7 @@ import (
"github.com/containerd/containerd/errdefs" "github.com/containerd/containerd/errdefs"
"github.com/containerd/containerd/events" "github.com/containerd/containerd/events"
"github.com/containerd/containerd/runtime" "github.com/containerd/containerd/runtime"
"github.com/containerd/containerd/windows/hcsshimopts"
"github.com/containerd/typeurl" "github.com/containerd/typeurl"
"github.com/gogo/protobuf/types" "github.com/gogo/protobuf/types"
specs "github.com/opencontainers/runtime-spec/specs-go" specs "github.com/opencontainers/runtime-spec/specs-go"
@ -213,20 +214,28 @@ func (t *task) Exec(ctx context.Context, id string, opts runtime.ExecOpts) (runt
return p, nil return p, nil
} }
func (t *task) Pids(ctx context.Context) ([]uint32, error) { func (t *task) Pids(ctx context.Context) ([]runtime.ProcessInfo, error) {
t.Lock() t.Lock()
defer t.Unlock() defer t.Unlock()
var ( var infoList []runtime.ProcessInfo
pids = make([]uint32, len(t.processes)) hcsProcessList, err := t.hcsContainer.ProcessList()
idx = 0 if err != nil {
) return nil, err
for _, p := range t.processes {
pids[idx] = p.Pid()
idx++
} }
return pids, nil for _, process := range hcsProcessList {
info, err := t.convertToProcessDetails(process)
if err != nil {
return nil, err
}
infoList = append(infoList, runtime.ProcessInfo{
Pid: process.ProcessId,
Info: info,
})
}
return infoList, nil
} }
func (t *task) Checkpoint(_ context.Context, _ string, _ *types.Any) error { func (t *task) Checkpoint(_ context.Context, _ string, _ *types.Any) error {
@ -388,3 +397,21 @@ func (t *task) cleanup() {
removeLayer(context.Background(), t.rwLayer) removeLayer(context.Background(), t.rwLayer)
t.Unlock() t.Unlock()
} }
// convertToProcessDetails converts a given hcsshim ProcessListItem to proto ProcessDetails
func (t *task) convertToProcessDetails(p hcsshim.ProcessListItem) (*hcsshimopts.ProcessDetails, error) {
protobufTime, err := types.TimestampProto(p.CreateTimestamp)
if err != nil {
return nil, errors.Wrapf(errdefs.ErrInvalidArgument, "failed to convert timestamp for process pid: %d\n", p.ProcessId)
}
return &hcsshimopts.ProcessDetails{
ImageName: p.ImageName,
CreatedAt: protobufTime,
KernelTime_100Ns: p.KernelTime100ns,
MemoryCommitBytes: p.MemoryCommitBytes,
MemoryWorkingSetPrivateBytes: p.MemoryWorkingSetPrivateBytes,
MemoryWorkingSetSharedBytes: p.MemoryWorkingSetSharedBytes,
ProcessID: p.ProcessId,
UserTime_100Ns: p.UserTime100ns,
}, nil
}