1
2
3
4 package v1
5
6 import (
7 fmt "fmt"
8 _ "github.com/gogo/protobuf/gogoproto"
9 proto "github.com/gogo/protobuf/proto"
10 io "io"
11 math "math"
12 math_bits "math/bits"
13 reflect "reflect"
14 strings "strings"
15 )
16
17
18 var _ = proto.Marshal
19 var _ = fmt.Errorf
20 var _ = math.Inf
21
22
23
24
25
26 const _ = proto.GoGoProtoPackageIsVersion3
27
28 type Metrics struct {
29 Hugetlb []*HugetlbStat `protobuf:"bytes,1,rep,name=hugetlb,proto3" json:"hugetlb,omitempty"`
30 Pids *PidsStat `protobuf:"bytes,2,opt,name=pids,proto3" json:"pids,omitempty"`
31 CPU *CPUStat `protobuf:"bytes,3,opt,name=cpu,proto3" json:"cpu,omitempty"`
32 Memory *MemoryStat `protobuf:"bytes,4,opt,name=memory,proto3" json:"memory,omitempty"`
33 Blkio *BlkIOStat `protobuf:"bytes,5,opt,name=blkio,proto3" json:"blkio,omitempty"`
34 Rdma *RdmaStat `protobuf:"bytes,6,opt,name=rdma,proto3" json:"rdma,omitempty"`
35 Network []*NetworkStat `protobuf:"bytes,7,rep,name=network,proto3" json:"network,omitempty"`
36 CgroupStats *CgroupStats `protobuf:"bytes,8,opt,name=cgroup_stats,json=cgroupStats,proto3" json:"cgroup_stats,omitempty"`
37 MemoryOomControl *MemoryOomControl `protobuf:"bytes,9,opt,name=memory_oom_control,json=memoryOomControl,proto3" json:"memory_oom_control,omitempty"`
38 XXX_NoUnkeyedLiteral struct{} `json:"-"`
39 XXX_unrecognized []byte `json:"-"`
40 XXX_sizecache int32 `json:"-"`
41 }
42
43 func (m *Metrics) Reset() { *m = Metrics{} }
44 func (*Metrics) ProtoMessage() {}
45 func (*Metrics) Descriptor() ([]byte, []int) {
46 return fileDescriptor_a17b2d87c332bfaa, []int{0}
47 }
48 func (m *Metrics) XXX_Unmarshal(b []byte) error {
49 return m.Unmarshal(b)
50 }
51 func (m *Metrics) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
52 if deterministic {
53 return xxx_messageInfo_Metrics.Marshal(b, m, deterministic)
54 } else {
55 b = b[:cap(b)]
56 n, err := m.MarshalToSizedBuffer(b)
57 if err != nil {
58 return nil, err
59 }
60 return b[:n], nil
61 }
62 }
63 func (m *Metrics) XXX_Merge(src proto.Message) {
64 xxx_messageInfo_Metrics.Merge(m, src)
65 }
66 func (m *Metrics) XXX_Size() int {
67 return m.Size()
68 }
69 func (m *Metrics) XXX_DiscardUnknown() {
70 xxx_messageInfo_Metrics.DiscardUnknown(m)
71 }
72
73 var xxx_messageInfo_Metrics proto.InternalMessageInfo
74
75 type HugetlbStat struct {
76 Usage uint64 `protobuf:"varint,1,opt,name=usage,proto3" json:"usage,omitempty"`
77 Max uint64 `protobuf:"varint,2,opt,name=max,proto3" json:"max,omitempty"`
78 Failcnt uint64 `protobuf:"varint,3,opt,name=failcnt,proto3" json:"failcnt,omitempty"`
79 Pagesize string `protobuf:"bytes,4,opt,name=pagesize,proto3" json:"pagesize,omitempty"`
80 XXX_NoUnkeyedLiteral struct{} `json:"-"`
81 XXX_unrecognized []byte `json:"-"`
82 XXX_sizecache int32 `json:"-"`
83 }
84
85 func (m *HugetlbStat) Reset() { *m = HugetlbStat{} }
86 func (*HugetlbStat) ProtoMessage() {}
87 func (*HugetlbStat) Descriptor() ([]byte, []int) {
88 return fileDescriptor_a17b2d87c332bfaa, []int{1}
89 }
90 func (m *HugetlbStat) XXX_Unmarshal(b []byte) error {
91 return m.Unmarshal(b)
92 }
93 func (m *HugetlbStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
94 if deterministic {
95 return xxx_messageInfo_HugetlbStat.Marshal(b, m, deterministic)
96 } else {
97 b = b[:cap(b)]
98 n, err := m.MarshalToSizedBuffer(b)
99 if err != nil {
100 return nil, err
101 }
102 return b[:n], nil
103 }
104 }
105 func (m *HugetlbStat) XXX_Merge(src proto.Message) {
106 xxx_messageInfo_HugetlbStat.Merge(m, src)
107 }
108 func (m *HugetlbStat) XXX_Size() int {
109 return m.Size()
110 }
111 func (m *HugetlbStat) XXX_DiscardUnknown() {
112 xxx_messageInfo_HugetlbStat.DiscardUnknown(m)
113 }
114
115 var xxx_messageInfo_HugetlbStat proto.InternalMessageInfo
116
117 type PidsStat struct {
118 Current uint64 `protobuf:"varint,1,opt,name=current,proto3" json:"current,omitempty"`
119 Limit uint64 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
120 XXX_NoUnkeyedLiteral struct{} `json:"-"`
121 XXX_unrecognized []byte `json:"-"`
122 XXX_sizecache int32 `json:"-"`
123 }
124
125 func (m *PidsStat) Reset() { *m = PidsStat{} }
126 func (*PidsStat) ProtoMessage() {}
127 func (*PidsStat) Descriptor() ([]byte, []int) {
128 return fileDescriptor_a17b2d87c332bfaa, []int{2}
129 }
130 func (m *PidsStat) XXX_Unmarshal(b []byte) error {
131 return m.Unmarshal(b)
132 }
133 func (m *PidsStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
134 if deterministic {
135 return xxx_messageInfo_PidsStat.Marshal(b, m, deterministic)
136 } else {
137 b = b[:cap(b)]
138 n, err := m.MarshalToSizedBuffer(b)
139 if err != nil {
140 return nil, err
141 }
142 return b[:n], nil
143 }
144 }
145 func (m *PidsStat) XXX_Merge(src proto.Message) {
146 xxx_messageInfo_PidsStat.Merge(m, src)
147 }
148 func (m *PidsStat) XXX_Size() int {
149 return m.Size()
150 }
151 func (m *PidsStat) XXX_DiscardUnknown() {
152 xxx_messageInfo_PidsStat.DiscardUnknown(m)
153 }
154
155 var xxx_messageInfo_PidsStat proto.InternalMessageInfo
156
157 type CPUStat struct {
158 Usage *CPUUsage `protobuf:"bytes,1,opt,name=usage,proto3" json:"usage,omitempty"`
159 Throttling *Throttle `protobuf:"bytes,2,opt,name=throttling,proto3" json:"throttling,omitempty"`
160 XXX_NoUnkeyedLiteral struct{} `json:"-"`
161 XXX_unrecognized []byte `json:"-"`
162 XXX_sizecache int32 `json:"-"`
163 }
164
165 func (m *CPUStat) Reset() { *m = CPUStat{} }
166 func (*CPUStat) ProtoMessage() {}
167 func (*CPUStat) Descriptor() ([]byte, []int) {
168 return fileDescriptor_a17b2d87c332bfaa, []int{3}
169 }
170 func (m *CPUStat) XXX_Unmarshal(b []byte) error {
171 return m.Unmarshal(b)
172 }
173 func (m *CPUStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
174 if deterministic {
175 return xxx_messageInfo_CPUStat.Marshal(b, m, deterministic)
176 } else {
177 b = b[:cap(b)]
178 n, err := m.MarshalToSizedBuffer(b)
179 if err != nil {
180 return nil, err
181 }
182 return b[:n], nil
183 }
184 }
185 func (m *CPUStat) XXX_Merge(src proto.Message) {
186 xxx_messageInfo_CPUStat.Merge(m, src)
187 }
188 func (m *CPUStat) XXX_Size() int {
189 return m.Size()
190 }
191 func (m *CPUStat) XXX_DiscardUnknown() {
192 xxx_messageInfo_CPUStat.DiscardUnknown(m)
193 }
194
195 var xxx_messageInfo_CPUStat proto.InternalMessageInfo
196
197 type CPUUsage struct {
198
199 Total uint64 `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
200 Kernel uint64 `protobuf:"varint,2,opt,name=kernel,proto3" json:"kernel,omitempty"`
201 User uint64 `protobuf:"varint,3,opt,name=user,proto3" json:"user,omitempty"`
202 PerCPU []uint64 `protobuf:"varint,4,rep,packed,name=per_cpu,json=perCpu,proto3" json:"per_cpu,omitempty"`
203 XXX_NoUnkeyedLiteral struct{} `json:"-"`
204 XXX_unrecognized []byte `json:"-"`
205 XXX_sizecache int32 `json:"-"`
206 }
207
208 func (m *CPUUsage) Reset() { *m = CPUUsage{} }
209 func (*CPUUsage) ProtoMessage() {}
210 func (*CPUUsage) Descriptor() ([]byte, []int) {
211 return fileDescriptor_a17b2d87c332bfaa, []int{4}
212 }
213 func (m *CPUUsage) XXX_Unmarshal(b []byte) error {
214 return m.Unmarshal(b)
215 }
216 func (m *CPUUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
217 if deterministic {
218 return xxx_messageInfo_CPUUsage.Marshal(b, m, deterministic)
219 } else {
220 b = b[:cap(b)]
221 n, err := m.MarshalToSizedBuffer(b)
222 if err != nil {
223 return nil, err
224 }
225 return b[:n], nil
226 }
227 }
228 func (m *CPUUsage) XXX_Merge(src proto.Message) {
229 xxx_messageInfo_CPUUsage.Merge(m, src)
230 }
231 func (m *CPUUsage) XXX_Size() int {
232 return m.Size()
233 }
234 func (m *CPUUsage) XXX_DiscardUnknown() {
235 xxx_messageInfo_CPUUsage.DiscardUnknown(m)
236 }
237
238 var xxx_messageInfo_CPUUsage proto.InternalMessageInfo
239
240 type Throttle struct {
241 Periods uint64 `protobuf:"varint,1,opt,name=periods,proto3" json:"periods,omitempty"`
242 ThrottledPeriods uint64 `protobuf:"varint,2,opt,name=throttled_periods,json=throttledPeriods,proto3" json:"throttled_periods,omitempty"`
243 ThrottledTime uint64 `protobuf:"varint,3,opt,name=throttled_time,json=throttledTime,proto3" json:"throttled_time,omitempty"`
244 XXX_NoUnkeyedLiteral struct{} `json:"-"`
245 XXX_unrecognized []byte `json:"-"`
246 XXX_sizecache int32 `json:"-"`
247 }
248
249 func (m *Throttle) Reset() { *m = Throttle{} }
250 func (*Throttle) ProtoMessage() {}
251 func (*Throttle) Descriptor() ([]byte, []int) {
252 return fileDescriptor_a17b2d87c332bfaa, []int{5}
253 }
254 func (m *Throttle) XXX_Unmarshal(b []byte) error {
255 return m.Unmarshal(b)
256 }
257 func (m *Throttle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
258 if deterministic {
259 return xxx_messageInfo_Throttle.Marshal(b, m, deterministic)
260 } else {
261 b = b[:cap(b)]
262 n, err := m.MarshalToSizedBuffer(b)
263 if err != nil {
264 return nil, err
265 }
266 return b[:n], nil
267 }
268 }
269 func (m *Throttle) XXX_Merge(src proto.Message) {
270 xxx_messageInfo_Throttle.Merge(m, src)
271 }
272 func (m *Throttle) XXX_Size() int {
273 return m.Size()
274 }
275 func (m *Throttle) XXX_DiscardUnknown() {
276 xxx_messageInfo_Throttle.DiscardUnknown(m)
277 }
278
279 var xxx_messageInfo_Throttle proto.InternalMessageInfo
280
281 type MemoryStat struct {
282 Cache uint64 `protobuf:"varint,1,opt,name=cache,proto3" json:"cache,omitempty"`
283 RSS uint64 `protobuf:"varint,2,opt,name=rss,proto3" json:"rss,omitempty"`
284 RSSHuge uint64 `protobuf:"varint,3,opt,name=rss_huge,json=rssHuge,proto3" json:"rss_huge,omitempty"`
285 MappedFile uint64 `protobuf:"varint,4,opt,name=mapped_file,json=mappedFile,proto3" json:"mapped_file,omitempty"`
286 Dirty uint64 `protobuf:"varint,5,opt,name=dirty,proto3" json:"dirty,omitempty"`
287 Writeback uint64 `protobuf:"varint,6,opt,name=writeback,proto3" json:"writeback,omitempty"`
288 PgPgIn uint64 `protobuf:"varint,7,opt,name=pg_pg_in,json=pgPgIn,proto3" json:"pg_pg_in,omitempty"`
289 PgPgOut uint64 `protobuf:"varint,8,opt,name=pg_pg_out,json=pgPgOut,proto3" json:"pg_pg_out,omitempty"`
290 PgFault uint64 `protobuf:"varint,9,opt,name=pg_fault,json=pgFault,proto3" json:"pg_fault,omitempty"`
291 PgMajFault uint64 `protobuf:"varint,10,opt,name=pg_maj_fault,json=pgMajFault,proto3" json:"pg_maj_fault,omitempty"`
292 InactiveAnon uint64 `protobuf:"varint,11,opt,name=inactive_anon,json=inactiveAnon,proto3" json:"inactive_anon,omitempty"`
293 ActiveAnon uint64 `protobuf:"varint,12,opt,name=active_anon,json=activeAnon,proto3" json:"active_anon,omitempty"`
294 InactiveFile uint64 `protobuf:"varint,13,opt,name=inactive_file,json=inactiveFile,proto3" json:"inactive_file,omitempty"`
295 ActiveFile uint64 `protobuf:"varint,14,opt,name=active_file,json=activeFile,proto3" json:"active_file,omitempty"`
296 Unevictable uint64 `protobuf:"varint,15,opt,name=unevictable,proto3" json:"unevictable,omitempty"`
297 HierarchicalMemoryLimit uint64 `protobuf:"varint,16,opt,name=hierarchical_memory_limit,json=hierarchicalMemoryLimit,proto3" json:"hierarchical_memory_limit,omitempty"`
298 HierarchicalSwapLimit uint64 `protobuf:"varint,17,opt,name=hierarchical_swap_limit,json=hierarchicalSwapLimit,proto3" json:"hierarchical_swap_limit,omitempty"`
299 TotalCache uint64 `protobuf:"varint,18,opt,name=total_cache,json=totalCache,proto3" json:"total_cache,omitempty"`
300 TotalRSS uint64 `protobuf:"varint,19,opt,name=total_rss,json=totalRss,proto3" json:"total_rss,omitempty"`
301 TotalRSSHuge uint64 `protobuf:"varint,20,opt,name=total_rss_huge,json=totalRssHuge,proto3" json:"total_rss_huge,omitempty"`
302 TotalMappedFile uint64 `protobuf:"varint,21,opt,name=total_mapped_file,json=totalMappedFile,proto3" json:"total_mapped_file,omitempty"`
303 TotalDirty uint64 `protobuf:"varint,22,opt,name=total_dirty,json=totalDirty,proto3" json:"total_dirty,omitempty"`
304 TotalWriteback uint64 `protobuf:"varint,23,opt,name=total_writeback,json=totalWriteback,proto3" json:"total_writeback,omitempty"`
305 TotalPgPgIn uint64 `protobuf:"varint,24,opt,name=total_pg_pg_in,json=totalPgPgIn,proto3" json:"total_pg_pg_in,omitempty"`
306 TotalPgPgOut uint64 `protobuf:"varint,25,opt,name=total_pg_pg_out,json=totalPgPgOut,proto3" json:"total_pg_pg_out,omitempty"`
307 TotalPgFault uint64 `protobuf:"varint,26,opt,name=total_pg_fault,json=totalPgFault,proto3" json:"total_pg_fault,omitempty"`
308 TotalPgMajFault uint64 `protobuf:"varint,27,opt,name=total_pg_maj_fault,json=totalPgMajFault,proto3" json:"total_pg_maj_fault,omitempty"`
309 TotalInactiveAnon uint64 `protobuf:"varint,28,opt,name=total_inactive_anon,json=totalInactiveAnon,proto3" json:"total_inactive_anon,omitempty"`
310 TotalActiveAnon uint64 `protobuf:"varint,29,opt,name=total_active_anon,json=totalActiveAnon,proto3" json:"total_active_anon,omitempty"`
311 TotalInactiveFile uint64 `protobuf:"varint,30,opt,name=total_inactive_file,json=totalInactiveFile,proto3" json:"total_inactive_file,omitempty"`
312 TotalActiveFile uint64 `protobuf:"varint,31,opt,name=total_active_file,json=totalActiveFile,proto3" json:"total_active_file,omitempty"`
313 TotalUnevictable uint64 `protobuf:"varint,32,opt,name=total_unevictable,json=totalUnevictable,proto3" json:"total_unevictable,omitempty"`
314 Usage *MemoryEntry `protobuf:"bytes,33,opt,name=usage,proto3" json:"usage,omitempty"`
315 Swap *MemoryEntry `protobuf:"bytes,34,opt,name=swap,proto3" json:"swap,omitempty"`
316 Kernel *MemoryEntry `protobuf:"bytes,35,opt,name=kernel,proto3" json:"kernel,omitempty"`
317 KernelTCP *MemoryEntry `protobuf:"bytes,36,opt,name=kernel_tcp,json=kernelTcp,proto3" json:"kernel_tcp,omitempty"`
318 XXX_NoUnkeyedLiteral struct{} `json:"-"`
319 XXX_unrecognized []byte `json:"-"`
320 XXX_sizecache int32 `json:"-"`
321 }
322
323 func (m *MemoryStat) Reset() { *m = MemoryStat{} }
324 func (*MemoryStat) ProtoMessage() {}
325 func (*MemoryStat) Descriptor() ([]byte, []int) {
326 return fileDescriptor_a17b2d87c332bfaa, []int{6}
327 }
328 func (m *MemoryStat) XXX_Unmarshal(b []byte) error {
329 return m.Unmarshal(b)
330 }
331 func (m *MemoryStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
332 if deterministic {
333 return xxx_messageInfo_MemoryStat.Marshal(b, m, deterministic)
334 } else {
335 b = b[:cap(b)]
336 n, err := m.MarshalToSizedBuffer(b)
337 if err != nil {
338 return nil, err
339 }
340 return b[:n], nil
341 }
342 }
343 func (m *MemoryStat) XXX_Merge(src proto.Message) {
344 xxx_messageInfo_MemoryStat.Merge(m, src)
345 }
346 func (m *MemoryStat) XXX_Size() int {
347 return m.Size()
348 }
349 func (m *MemoryStat) XXX_DiscardUnknown() {
350 xxx_messageInfo_MemoryStat.DiscardUnknown(m)
351 }
352
353 var xxx_messageInfo_MemoryStat proto.InternalMessageInfo
354
355 type MemoryEntry struct {
356 Limit uint64 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
357 Usage uint64 `protobuf:"varint,2,opt,name=usage,proto3" json:"usage,omitempty"`
358 Max uint64 `protobuf:"varint,3,opt,name=max,proto3" json:"max,omitempty"`
359 Failcnt uint64 `protobuf:"varint,4,opt,name=failcnt,proto3" json:"failcnt,omitempty"`
360 XXX_NoUnkeyedLiteral struct{} `json:"-"`
361 XXX_unrecognized []byte `json:"-"`
362 XXX_sizecache int32 `json:"-"`
363 }
364
365 func (m *MemoryEntry) Reset() { *m = MemoryEntry{} }
366 func (*MemoryEntry) ProtoMessage() {}
367 func (*MemoryEntry) Descriptor() ([]byte, []int) {
368 return fileDescriptor_a17b2d87c332bfaa, []int{7}
369 }
370 func (m *MemoryEntry) XXX_Unmarshal(b []byte) error {
371 return m.Unmarshal(b)
372 }
373 func (m *MemoryEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
374 if deterministic {
375 return xxx_messageInfo_MemoryEntry.Marshal(b, m, deterministic)
376 } else {
377 b = b[:cap(b)]
378 n, err := m.MarshalToSizedBuffer(b)
379 if err != nil {
380 return nil, err
381 }
382 return b[:n], nil
383 }
384 }
385 func (m *MemoryEntry) XXX_Merge(src proto.Message) {
386 xxx_messageInfo_MemoryEntry.Merge(m, src)
387 }
388 func (m *MemoryEntry) XXX_Size() int {
389 return m.Size()
390 }
391 func (m *MemoryEntry) XXX_DiscardUnknown() {
392 xxx_messageInfo_MemoryEntry.DiscardUnknown(m)
393 }
394
395 var xxx_messageInfo_MemoryEntry proto.InternalMessageInfo
396
397 type MemoryOomControl struct {
398 OomKillDisable uint64 `protobuf:"varint,1,opt,name=oom_kill_disable,json=oomKillDisable,proto3" json:"oom_kill_disable,omitempty"`
399 UnderOom uint64 `protobuf:"varint,2,opt,name=under_oom,json=underOom,proto3" json:"under_oom,omitempty"`
400 OomKill uint64 `protobuf:"varint,3,opt,name=oom_kill,json=oomKill,proto3" json:"oom_kill,omitempty"`
401 XXX_NoUnkeyedLiteral struct{} `json:"-"`
402 XXX_unrecognized []byte `json:"-"`
403 XXX_sizecache int32 `json:"-"`
404 }
405
406 func (m *MemoryOomControl) Reset() { *m = MemoryOomControl{} }
407 func (*MemoryOomControl) ProtoMessage() {}
408 func (*MemoryOomControl) Descriptor() ([]byte, []int) {
409 return fileDescriptor_a17b2d87c332bfaa, []int{8}
410 }
411 func (m *MemoryOomControl) XXX_Unmarshal(b []byte) error {
412 return m.Unmarshal(b)
413 }
414 func (m *MemoryOomControl) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
415 if deterministic {
416 return xxx_messageInfo_MemoryOomControl.Marshal(b, m, deterministic)
417 } else {
418 b = b[:cap(b)]
419 n, err := m.MarshalToSizedBuffer(b)
420 if err != nil {
421 return nil, err
422 }
423 return b[:n], nil
424 }
425 }
426 func (m *MemoryOomControl) XXX_Merge(src proto.Message) {
427 xxx_messageInfo_MemoryOomControl.Merge(m, src)
428 }
429 func (m *MemoryOomControl) XXX_Size() int {
430 return m.Size()
431 }
432 func (m *MemoryOomControl) XXX_DiscardUnknown() {
433 xxx_messageInfo_MemoryOomControl.DiscardUnknown(m)
434 }
435
436 var xxx_messageInfo_MemoryOomControl proto.InternalMessageInfo
437
438 type BlkIOStat struct {
439 IoServiceBytesRecursive []*BlkIOEntry `protobuf:"bytes,1,rep,name=io_service_bytes_recursive,json=ioServiceBytesRecursive,proto3" json:"io_service_bytes_recursive,omitempty"`
440 IoServicedRecursive []*BlkIOEntry `protobuf:"bytes,2,rep,name=io_serviced_recursive,json=ioServicedRecursive,proto3" json:"io_serviced_recursive,omitempty"`
441 IoQueuedRecursive []*BlkIOEntry `protobuf:"bytes,3,rep,name=io_queued_recursive,json=ioQueuedRecursive,proto3" json:"io_queued_recursive,omitempty"`
442 IoServiceTimeRecursive []*BlkIOEntry `protobuf:"bytes,4,rep,name=io_service_time_recursive,json=ioServiceTimeRecursive,proto3" json:"io_service_time_recursive,omitempty"`
443 IoWaitTimeRecursive []*BlkIOEntry `protobuf:"bytes,5,rep,name=io_wait_time_recursive,json=ioWaitTimeRecursive,proto3" json:"io_wait_time_recursive,omitempty"`
444 IoMergedRecursive []*BlkIOEntry `protobuf:"bytes,6,rep,name=io_merged_recursive,json=ioMergedRecursive,proto3" json:"io_merged_recursive,omitempty"`
445 IoTimeRecursive []*BlkIOEntry `protobuf:"bytes,7,rep,name=io_time_recursive,json=ioTimeRecursive,proto3" json:"io_time_recursive,omitempty"`
446 SectorsRecursive []*BlkIOEntry `protobuf:"bytes,8,rep,name=sectors_recursive,json=sectorsRecursive,proto3" json:"sectors_recursive,omitempty"`
447 XXX_NoUnkeyedLiteral struct{} `json:"-"`
448 XXX_unrecognized []byte `json:"-"`
449 XXX_sizecache int32 `json:"-"`
450 }
451
452 func (m *BlkIOStat) Reset() { *m = BlkIOStat{} }
453 func (*BlkIOStat) ProtoMessage() {}
454 func (*BlkIOStat) Descriptor() ([]byte, []int) {
455 return fileDescriptor_a17b2d87c332bfaa, []int{9}
456 }
457 func (m *BlkIOStat) XXX_Unmarshal(b []byte) error {
458 return m.Unmarshal(b)
459 }
460 func (m *BlkIOStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
461 if deterministic {
462 return xxx_messageInfo_BlkIOStat.Marshal(b, m, deterministic)
463 } else {
464 b = b[:cap(b)]
465 n, err := m.MarshalToSizedBuffer(b)
466 if err != nil {
467 return nil, err
468 }
469 return b[:n], nil
470 }
471 }
472 func (m *BlkIOStat) XXX_Merge(src proto.Message) {
473 xxx_messageInfo_BlkIOStat.Merge(m, src)
474 }
475 func (m *BlkIOStat) XXX_Size() int {
476 return m.Size()
477 }
478 func (m *BlkIOStat) XXX_DiscardUnknown() {
479 xxx_messageInfo_BlkIOStat.DiscardUnknown(m)
480 }
481
482 var xxx_messageInfo_BlkIOStat proto.InternalMessageInfo
483
484 type BlkIOEntry struct {
485 Op string `protobuf:"bytes,1,opt,name=op,proto3" json:"op,omitempty"`
486 Device string `protobuf:"bytes,2,opt,name=device,proto3" json:"device,omitempty"`
487 Major uint64 `protobuf:"varint,3,opt,name=major,proto3" json:"major,omitempty"`
488 Minor uint64 `protobuf:"varint,4,opt,name=minor,proto3" json:"minor,omitempty"`
489 Value uint64 `protobuf:"varint,5,opt,name=value,proto3" json:"value,omitempty"`
490 XXX_NoUnkeyedLiteral struct{} `json:"-"`
491 XXX_unrecognized []byte `json:"-"`
492 XXX_sizecache int32 `json:"-"`
493 }
494
495 func (m *BlkIOEntry) Reset() { *m = BlkIOEntry{} }
496 func (*BlkIOEntry) ProtoMessage() {}
497 func (*BlkIOEntry) Descriptor() ([]byte, []int) {
498 return fileDescriptor_a17b2d87c332bfaa, []int{10}
499 }
500 func (m *BlkIOEntry) XXX_Unmarshal(b []byte) error {
501 return m.Unmarshal(b)
502 }
503 func (m *BlkIOEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
504 if deterministic {
505 return xxx_messageInfo_BlkIOEntry.Marshal(b, m, deterministic)
506 } else {
507 b = b[:cap(b)]
508 n, err := m.MarshalToSizedBuffer(b)
509 if err != nil {
510 return nil, err
511 }
512 return b[:n], nil
513 }
514 }
515 func (m *BlkIOEntry) XXX_Merge(src proto.Message) {
516 xxx_messageInfo_BlkIOEntry.Merge(m, src)
517 }
518 func (m *BlkIOEntry) XXX_Size() int {
519 return m.Size()
520 }
521 func (m *BlkIOEntry) XXX_DiscardUnknown() {
522 xxx_messageInfo_BlkIOEntry.DiscardUnknown(m)
523 }
524
525 var xxx_messageInfo_BlkIOEntry proto.InternalMessageInfo
526
527 type RdmaStat struct {
528 Current []*RdmaEntry `protobuf:"bytes,1,rep,name=current,proto3" json:"current,omitempty"`
529 Limit []*RdmaEntry `protobuf:"bytes,2,rep,name=limit,proto3" json:"limit,omitempty"`
530 XXX_NoUnkeyedLiteral struct{} `json:"-"`
531 XXX_unrecognized []byte `json:"-"`
532 XXX_sizecache int32 `json:"-"`
533 }
534
535 func (m *RdmaStat) Reset() { *m = RdmaStat{} }
536 func (*RdmaStat) ProtoMessage() {}
537 func (*RdmaStat) Descriptor() ([]byte, []int) {
538 return fileDescriptor_a17b2d87c332bfaa, []int{11}
539 }
540 func (m *RdmaStat) XXX_Unmarshal(b []byte) error {
541 return m.Unmarshal(b)
542 }
543 func (m *RdmaStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
544 if deterministic {
545 return xxx_messageInfo_RdmaStat.Marshal(b, m, deterministic)
546 } else {
547 b = b[:cap(b)]
548 n, err := m.MarshalToSizedBuffer(b)
549 if err != nil {
550 return nil, err
551 }
552 return b[:n], nil
553 }
554 }
555 func (m *RdmaStat) XXX_Merge(src proto.Message) {
556 xxx_messageInfo_RdmaStat.Merge(m, src)
557 }
558 func (m *RdmaStat) XXX_Size() int {
559 return m.Size()
560 }
561 func (m *RdmaStat) XXX_DiscardUnknown() {
562 xxx_messageInfo_RdmaStat.DiscardUnknown(m)
563 }
564
565 var xxx_messageInfo_RdmaStat proto.InternalMessageInfo
566
567 type RdmaEntry struct {
568 Device string `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
569 HcaHandles uint32 `protobuf:"varint,2,opt,name=hca_handles,json=hcaHandles,proto3" json:"hca_handles,omitempty"`
570 HcaObjects uint32 `protobuf:"varint,3,opt,name=hca_objects,json=hcaObjects,proto3" json:"hca_objects,omitempty"`
571 XXX_NoUnkeyedLiteral struct{} `json:"-"`
572 XXX_unrecognized []byte `json:"-"`
573 XXX_sizecache int32 `json:"-"`
574 }
575
576 func (m *RdmaEntry) Reset() { *m = RdmaEntry{} }
577 func (*RdmaEntry) ProtoMessage() {}
578 func (*RdmaEntry) Descriptor() ([]byte, []int) {
579 return fileDescriptor_a17b2d87c332bfaa, []int{12}
580 }
581 func (m *RdmaEntry) XXX_Unmarshal(b []byte) error {
582 return m.Unmarshal(b)
583 }
584 func (m *RdmaEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
585 if deterministic {
586 return xxx_messageInfo_RdmaEntry.Marshal(b, m, deterministic)
587 } else {
588 b = b[:cap(b)]
589 n, err := m.MarshalToSizedBuffer(b)
590 if err != nil {
591 return nil, err
592 }
593 return b[:n], nil
594 }
595 }
596 func (m *RdmaEntry) XXX_Merge(src proto.Message) {
597 xxx_messageInfo_RdmaEntry.Merge(m, src)
598 }
599 func (m *RdmaEntry) XXX_Size() int {
600 return m.Size()
601 }
602 func (m *RdmaEntry) XXX_DiscardUnknown() {
603 xxx_messageInfo_RdmaEntry.DiscardUnknown(m)
604 }
605
606 var xxx_messageInfo_RdmaEntry proto.InternalMessageInfo
607
608 type NetworkStat struct {
609 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
610 RxBytes uint64 `protobuf:"varint,2,opt,name=rx_bytes,json=rxBytes,proto3" json:"rx_bytes,omitempty"`
611 RxPackets uint64 `protobuf:"varint,3,opt,name=rx_packets,json=rxPackets,proto3" json:"rx_packets,omitempty"`
612 RxErrors uint64 `protobuf:"varint,4,opt,name=rx_errors,json=rxErrors,proto3" json:"rx_errors,omitempty"`
613 RxDropped uint64 `protobuf:"varint,5,opt,name=rx_dropped,json=rxDropped,proto3" json:"rx_dropped,omitempty"`
614 TxBytes uint64 `protobuf:"varint,6,opt,name=tx_bytes,json=txBytes,proto3" json:"tx_bytes,omitempty"`
615 TxPackets uint64 `protobuf:"varint,7,opt,name=tx_packets,json=txPackets,proto3" json:"tx_packets,omitempty"`
616 TxErrors uint64 `protobuf:"varint,8,opt,name=tx_errors,json=txErrors,proto3" json:"tx_errors,omitempty"`
617 TxDropped uint64 `protobuf:"varint,9,opt,name=tx_dropped,json=txDropped,proto3" json:"tx_dropped,omitempty"`
618 XXX_NoUnkeyedLiteral struct{} `json:"-"`
619 XXX_unrecognized []byte `json:"-"`
620 XXX_sizecache int32 `json:"-"`
621 }
622
623 func (m *NetworkStat) Reset() { *m = NetworkStat{} }
624 func (*NetworkStat) ProtoMessage() {}
625 func (*NetworkStat) Descriptor() ([]byte, []int) {
626 return fileDescriptor_a17b2d87c332bfaa, []int{13}
627 }
628 func (m *NetworkStat) XXX_Unmarshal(b []byte) error {
629 return m.Unmarshal(b)
630 }
631 func (m *NetworkStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
632 if deterministic {
633 return xxx_messageInfo_NetworkStat.Marshal(b, m, deterministic)
634 } else {
635 b = b[:cap(b)]
636 n, err := m.MarshalToSizedBuffer(b)
637 if err != nil {
638 return nil, err
639 }
640 return b[:n], nil
641 }
642 }
643 func (m *NetworkStat) XXX_Merge(src proto.Message) {
644 xxx_messageInfo_NetworkStat.Merge(m, src)
645 }
646 func (m *NetworkStat) XXX_Size() int {
647 return m.Size()
648 }
649 func (m *NetworkStat) XXX_DiscardUnknown() {
650 xxx_messageInfo_NetworkStat.DiscardUnknown(m)
651 }
652
653 var xxx_messageInfo_NetworkStat proto.InternalMessageInfo
654
655
656 type CgroupStats struct {
657
658 NrSleeping uint64 `protobuf:"varint,1,opt,name=nr_sleeping,json=nrSleeping,proto3" json:"nr_sleeping,omitempty"`
659
660 NrRunning uint64 `protobuf:"varint,2,opt,name=nr_running,json=nrRunning,proto3" json:"nr_running,omitempty"`
661
662 NrStopped uint64 `protobuf:"varint,3,opt,name=nr_stopped,json=nrStopped,proto3" json:"nr_stopped,omitempty"`
663
664 NrUninterruptible uint64 `protobuf:"varint,4,opt,name=nr_uninterruptible,json=nrUninterruptible,proto3" json:"nr_uninterruptible,omitempty"`
665
666 NrIoWait uint64 `protobuf:"varint,5,opt,name=nr_io_wait,json=nrIoWait,proto3" json:"nr_io_wait,omitempty"`
667 XXX_NoUnkeyedLiteral struct{} `json:"-"`
668 XXX_unrecognized []byte `json:"-"`
669 XXX_sizecache int32 `json:"-"`
670 }
671
672 func (m *CgroupStats) Reset() { *m = CgroupStats{} }
673 func (*CgroupStats) ProtoMessage() {}
674 func (*CgroupStats) Descriptor() ([]byte, []int) {
675 return fileDescriptor_a17b2d87c332bfaa, []int{14}
676 }
677 func (m *CgroupStats) XXX_Unmarshal(b []byte) error {
678 return m.Unmarshal(b)
679 }
680 func (m *CgroupStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
681 if deterministic {
682 return xxx_messageInfo_CgroupStats.Marshal(b, m, deterministic)
683 } else {
684 b = b[:cap(b)]
685 n, err := m.MarshalToSizedBuffer(b)
686 if err != nil {
687 return nil, err
688 }
689 return b[:n], nil
690 }
691 }
692 func (m *CgroupStats) XXX_Merge(src proto.Message) {
693 xxx_messageInfo_CgroupStats.Merge(m, src)
694 }
695 func (m *CgroupStats) XXX_Size() int {
696 return m.Size()
697 }
698 func (m *CgroupStats) XXX_DiscardUnknown() {
699 xxx_messageInfo_CgroupStats.DiscardUnknown(m)
700 }
701
702 var xxx_messageInfo_CgroupStats proto.InternalMessageInfo
703
704 func init() {
705 proto.RegisterType((*Metrics)(nil), "io.containerd.cgroups.v1.Metrics")
706 proto.RegisterType((*HugetlbStat)(nil), "io.containerd.cgroups.v1.HugetlbStat")
707 proto.RegisterType((*PidsStat)(nil), "io.containerd.cgroups.v1.PidsStat")
708 proto.RegisterType((*CPUStat)(nil), "io.containerd.cgroups.v1.CPUStat")
709 proto.RegisterType((*CPUUsage)(nil), "io.containerd.cgroups.v1.CPUUsage")
710 proto.RegisterType((*Throttle)(nil), "io.containerd.cgroups.v1.Throttle")
711 proto.RegisterType((*MemoryStat)(nil), "io.containerd.cgroups.v1.MemoryStat")
712 proto.RegisterType((*MemoryEntry)(nil), "io.containerd.cgroups.v1.MemoryEntry")
713 proto.RegisterType((*MemoryOomControl)(nil), "io.containerd.cgroups.v1.MemoryOomControl")
714 proto.RegisterType((*BlkIOStat)(nil), "io.containerd.cgroups.v1.BlkIOStat")
715 proto.RegisterType((*BlkIOEntry)(nil), "io.containerd.cgroups.v1.BlkIOEntry")
716 proto.RegisterType((*RdmaStat)(nil), "io.containerd.cgroups.v1.RdmaStat")
717 proto.RegisterType((*RdmaEntry)(nil), "io.containerd.cgroups.v1.RdmaEntry")
718 proto.RegisterType((*NetworkStat)(nil), "io.containerd.cgroups.v1.NetworkStat")
719 proto.RegisterType((*CgroupStats)(nil), "io.containerd.cgroups.v1.CgroupStats")
720 }
721
722 func init() {
723 proto.RegisterFile("github.com/containerd/cgroups/stats/v1/metrics.proto", fileDescriptor_a17b2d87c332bfaa)
724 }
725
726 var fileDescriptor_a17b2d87c332bfaa = []byte{
727
728 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x58, 0xcd, 0x72, 0xe3, 0xc6,
729 0x11, 0x36, 0x45, 0x48, 0x24, 0x9a, 0x92, 0x56, 0x9a, 0xfd, 0x83, 0xe4, 0xb5, 0x28, 0x53, 0xbb,
730 0x89, 0xe2, 0xad, 0x48, 0x65, 0x27, 0xb5, 0x95, 0x75, 0xec, 0x4a, 0x59, 0x5a, 0xbb, 0x76, 0xcb,
731 0x51, 0x44, 0x83, 0x52, 0xd9, 0x39, 0xa1, 0x40, 0x70, 0x16, 0x9c, 0x15, 0x80, 0x81, 0x07, 0x03,
732 0x89, 0xca, 0x29, 0x87, 0x54, 0xe5, 0x94, 0x07, 0xca, 0x1b, 0xf8, 0x98, 0x4b, 0x52, 0xc9, 0x45,
733 0x15, 0xf3, 0x49, 0x52, 0x33, 0x3d, 0xf8, 0xa1, 0xbc, 0x5a, 0x85, 0x37, 0x76, 0xcf, 0xd7, 0x5f,
734 0xf7, 0x34, 0xbe, 0x19, 0x34, 0x08, 0xbf, 0x0e, 0x99, 0x1c, 0xe7, 0xc3, 0xbd, 0x80, 0xc7, 0xfb,
735 0x01, 0x4f, 0xa4, 0xcf, 0x12, 0x2a, 0x46, 0xfb, 0x41, 0x28, 0x78, 0x9e, 0x66, 0xfb, 0x99, 0xf4,
736 0x65, 0xb6, 0x7f, 0xfe, 0xf1, 0x7e, 0x4c, 0xa5, 0x60, 0x41, 0xb6, 0x97, 0x0a, 0x2e, 0x39, 0x71,
737 0x18, 0xdf, 0xab, 0xd0, 0x7b, 0x06, 0xbd, 0x77, 0xfe, 0xf1, 0xe6, 0xbd, 0x90, 0x87, 0x5c, 0x83,
738 0xf6, 0xd5, 0x2f, 0xc4, 0xf7, 0xfe, 0x65, 0x41, 0xeb, 0x08, 0x19, 0xc8, 0xef, 0xa0, 0x35, 0xce,
739 0x43, 0x2a, 0xa3, 0xa1, 0xd3, 0xd8, 0x6e, 0xee, 0x76, 0x3e, 0x79, 0xb2, 0x77, 0x13, 0xdb, 0xde,
740 0x4b, 0x04, 0x0e, 0xa4, 0x2f, 0xdd, 0x22, 0x8a, 0x3c, 0x03, 0x2b, 0x65, 0xa3, 0xcc, 0x59, 0xd8,
741 0x6e, 0xec, 0x76, 0x3e, 0xe9, 0xdd, 0x1c, 0xdd, 0x67, 0xa3, 0x4c, 0x87, 0x6a, 0x3c, 0xf9, 0x0c,
742 0x9a, 0x41, 0x9a, 0x3b, 0x4d, 0x1d, 0xf6, 0xe1, 0xcd, 0x61, 0x87, 0xfd, 0x53, 0x15, 0x75, 0xd0,
743 0x9a, 0x5e, 0x75, 0x9b, 0x87, 0xfd, 0x53, 0x57, 0x85, 0x91, 0xcf, 0x60, 0x29, 0xa6, 0x31, 0x17,
744 0x97, 0x8e, 0xa5, 0x09, 0x1e, 0xdf, 0x4c, 0x70, 0xa4, 0x71, 0x3a, 0xb3, 0x89, 0x21, 0xcf, 0x61,
745 0x71, 0x18, 0x9d, 0x31, 0xee, 0x2c, 0xea, 0xe0, 0x9d, 0x9b, 0x83, 0x0f, 0xa2, 0xb3, 0x57, 0xc7,
746 0x3a, 0x16, 0x23, 0xd4, 0x76, 0xc5, 0x28, 0xf6, 0x9d, 0xa5, 0xdb, 0xb6, 0xeb, 0x8e, 0x62, 0x1f,
747 0xb7, 0xab, 0xf0, 0xaa, 0xcf, 0x09, 0x95, 0x17, 0x5c, 0x9c, 0x39, 0xad, 0xdb, 0xfa, 0xfc, 0x07,
748 0x04, 0x62, 0x9f, 0x4d, 0x14, 0x79, 0x09, 0xcb, 0x08, 0xf1, 0xb4, 0x0a, 0x9c, 0xb6, 0x2e, 0xe0,
749 0x1d, 0x2c, 0x87, 0xfa, 0xa7, 0x22, 0xc9, 0xdc, 0x4e, 0x50, 0x19, 0xe4, 0x3b, 0x20, 0xd8, 0x07,
750 0x8f, 0xf3, 0xd8, 0x53, 0xc1, 0x82, 0x47, 0x8e, 0xad, 0xf9, 0x3e, 0xba, 0xad, 0x8f, 0xc7, 0x3c,
751 0x3e, 0xc4, 0x08, 0x77, 0x2d, 0xbe, 0xe6, 0xe9, 0x9d, 0x41, 0xa7, 0xa6, 0x11, 0x72, 0x0f, 0x16,
752 0xf3, 0xcc, 0x0f, 0xa9, 0xd3, 0xd8, 0x6e, 0xec, 0x5a, 0x2e, 0x1a, 0x64, 0x0d, 0x9a, 0xb1, 0x3f,
753 0xd1, 0x7a, 0xb1, 0x5c, 0xf5, 0x93, 0x38, 0xd0, 0x7a, 0xed, 0xb3, 0x28, 0x48, 0xa4, 0x96, 0x83,
754 0xe5, 0x16, 0x26, 0xd9, 0x84, 0x76, 0xea, 0x87, 0x34, 0x63, 0x7f, 0xa2, 0xfa, 0x41, 0xdb, 0x6e,
755 0x69, 0xf7, 0x3e, 0x85, 0x76, 0x21, 0x29, 0xc5, 0x10, 0xe4, 0x42, 0xd0, 0x44, 0x9a, 0x5c, 0x85,
756 0xa9, 0x6a, 0x88, 0x58, 0xcc, 0xa4, 0xc9, 0x87, 0x46, 0xef, 0xaf, 0x0d, 0x68, 0x19, 0x61, 0x91,
757 0xdf, 0xd4, 0xab, 0x7c, 0xe7, 0x23, 0x3d, 0xec, 0x9f, 0x9e, 0x2a, 0x64, 0xb1, 0x93, 0x03, 0x00,
758 0x39, 0x16, 0x5c, 0xca, 0x88, 0x25, 0xe1, 0xed, 0x07, 0xe0, 0x04, 0xb1, 0xd4, 0xad, 0x45, 0xf5,
759 0xbe, 0x87, 0x76, 0x41, 0xab, 0x6a, 0x95, 0x5c, 0xfa, 0x51, 0xd1, 0x2f, 0x6d, 0x90, 0x07, 0xb0,
760 0x74, 0x46, 0x45, 0x42, 0x23, 0xb3, 0x05, 0x63, 0x11, 0x02, 0x56, 0x9e, 0x51, 0x61, 0x5a, 0xa6,
761 0x7f, 0x93, 0x1d, 0x68, 0xa5, 0x54, 0x78, 0xea, 0x60, 0x59, 0xdb, 0xcd, 0x5d, 0xeb, 0x00, 0xa6,
762 0x57, 0xdd, 0xa5, 0x3e, 0x15, 0xea, 0xe0, 0x2c, 0xa5, 0x54, 0x1c, 0xa6, 0x79, 0x6f, 0x02, 0xed,
763 0xa2, 0x14, 0xd5, 0xb8, 0x94, 0x0a, 0xc6, 0x47, 0x59, 0xd1, 0x38, 0x63, 0x92, 0xa7, 0xb0, 0x6e,
764 0xca, 0xa4, 0x23, 0xaf, 0xc0, 0x60, 0x05, 0x6b, 0xe5, 0x42, 0xdf, 0x80, 0x9f, 0xc0, 0x6a, 0x05,
765 0x96, 0x2c, 0xa6, 0xa6, 0xaa, 0x95, 0xd2, 0x7b, 0xc2, 0x62, 0xda, 0xfb, 0x4f, 0x07, 0xa0, 0x3a,
766 0x8e, 0x6a, 0xbf, 0x81, 0x1f, 0x8c, 0x4b, 0x7d, 0x68, 0x83, 0x6c, 0x40, 0x53, 0x64, 0x26, 0x15,
767 0x9e, 0x7a, 0x77, 0x30, 0x70, 0x95, 0x8f, 0xfc, 0x0c, 0xda, 0x22, 0xcb, 0x3c, 0x75, 0xf5, 0x60,
768 0x82, 0x83, 0xce, 0xf4, 0xaa, 0xdb, 0x72, 0x07, 0x03, 0x25, 0x3b, 0xb7, 0x25, 0xb2, 0x4c, 0xfd,
769 0x20, 0x5d, 0xe8, 0xc4, 0x7e, 0x9a, 0xd2, 0x91, 0xf7, 0x9a, 0x45, 0xa8, 0x1c, 0xcb, 0x05, 0x74,
770 0x7d, 0xc5, 0x22, 0xdd, 0xe9, 0x11, 0x13, 0xf2, 0x52, 0x5f, 0x00, 0x96, 0x8b, 0x06, 0x79, 0x04,
771 0xf6, 0x85, 0x60, 0x92, 0x0e, 0xfd, 0xe0, 0x4c, 0x1f, 0x70, 0xcb, 0xad, 0x1c, 0xc4, 0x81, 0x76,
772 0x1a, 0x7a, 0x69, 0xe8, 0xb1, 0xc4, 0x69, 0xe1, 0x93, 0x48, 0xc3, 0x7e, 0xf8, 0x2a, 0x21, 0x9b,
773 0x60, 0xe3, 0x0a, 0xcf, 0xa5, 0x3e, 0x97, 0xaa, 0x8d, 0x61, 0x3f, 0x3c, 0xce, 0x25, 0xd9, 0xd0,
774 0x51, 0xaf, 0xfd, 0x3c, 0x92, 0xfa, 0x88, 0xe9, 0xa5, 0xaf, 0x94, 0x49, 0xb6, 0x61, 0x39, 0x0d,
775 0xbd, 0xd8, 0x7f, 0x63, 0x96, 0x01, 0xcb, 0x4c, 0xc3, 0x23, 0xff, 0x0d, 0x22, 0x76, 0x60, 0x85,
776 0x25, 0x7e, 0x20, 0xd9, 0x39, 0xf5, 0xfc, 0x84, 0x27, 0x4e, 0x47, 0x43, 0x96, 0x0b, 0xe7, 0x17,
777 0x09, 0x4f, 0xd4, 0x66, 0xeb, 0x90, 0x65, 0x64, 0xa9, 0x01, 0xea, 0x2c, 0xba, 0x1f, 0x2b, 0xb3,
778 0x2c, 0xba, 0x23, 0x15, 0x8b, 0x86, 0xac, 0xd6, 0x59, 0x34, 0x60, 0x1b, 0x3a, 0x79, 0x42, 0xcf,
779 0x59, 0x20, 0xfd, 0x61, 0x44, 0x9d, 0x3b, 0x1a, 0x50, 0x77, 0x91, 0x4f, 0x61, 0x63, 0xcc, 0xa8,
780 0xf0, 0x45, 0x30, 0x66, 0x81, 0x1f, 0x79, 0xe6, 0x92, 0xc1, 0xe3, 0xb7, 0xa6, 0xf1, 0x0f, 0xeb,
781 0x00, 0x54, 0xc2, 0xef, 0xd5, 0x32, 0x79, 0x06, 0x33, 0x4b, 0x5e, 0x76, 0xe1, 0xa7, 0x26, 0x72,
782 0x5d, 0x47, 0xde, 0xaf, 0x2f, 0x0f, 0x2e, 0xfc, 0x14, 0xe3, 0xba, 0xd0, 0xd1, 0xa7, 0xc4, 0x43,
783 0x21, 0x11, 0x2c, 0x5b, 0xbb, 0x0e, 0xb5, 0x9a, 0x7e, 0x01, 0x36, 0x02, 0x94, 0xa6, 0xee, 0x6a,
784 0xcd, 0x2c, 0x4f, 0xaf, 0xba, 0xed, 0x13, 0xe5, 0x54, 0xc2, 0x6a, 0xeb, 0x65, 0x37, 0xcb, 0xc8,
785 0x33, 0x58, 0x2d, 0xa1, 0xa8, 0xb1, 0x7b, 0x1a, 0xbf, 0x36, 0xbd, 0xea, 0x2e, 0x17, 0x78, 0x2d,
786 0xb4, 0xe5, 0x22, 0x46, 0xab, 0xed, 0x23, 0x58, 0xc7, 0xb8, 0xba, 0xe6, 0xee, 0xeb, 0x4a, 0xee,
787 0xe8, 0x85, 0xa3, 0x4a, 0x78, 0x65, 0xbd, 0x28, 0xbf, 0x07, 0xb5, 0x7a, 0x5f, 0x68, 0x0d, 0xfe,
788 0x1c, 0x30, 0xc6, 0xab, 0x94, 0xf8, 0x50, 0x83, 0xb0, 0xb6, 0x6f, 0x4b, 0x39, 0xee, 0x14, 0xd5,
789 0x96, 0xa2, 0x74, 0xf0, 0x91, 0x68, 0x6f, 0x1f, 0x95, 0xf9, 0xa4, 0x60, 0xab, 0xf4, 0xb9, 0x81,
790 0x0f, 0xbf, 0x44, 0x29, 0x91, 0x3e, 0xae, 0x71, 0xa1, 0x16, 0x37, 0x67, 0x50, 0xa8, 0xc6, 0xa7,
791 0x40, 0x4a, 0x54, 0xa5, 0xda, 0xf7, 0x6b, 0x1b, 0xed, 0x57, 0xd2, 0xdd, 0x83, 0xbb, 0x08, 0x9e,
792 0x15, 0xf0, 0x23, 0x8d, 0xc6, 0x7e, 0xbd, 0xaa, 0xab, 0xb8, 0x6c, 0x62, 0x1d, 0xfd, 0x41, 0x8d,
793 0xfb, 0x8b, 0x0a, 0xfb, 0x53, 0x6e, 0xdd, 0xf2, 0xad, 0xb7, 0x70, 0xeb, 0xa6, 0x5f, 0xe7, 0xd6,
794 0xe8, 0xee, 0x4f, 0xb8, 0x35, 0xf6, 0x69, 0x81, 0xad, 0x8b, 0x7d, 0xdb, 0x5c, 0x7b, 0x6a, 0xe1,
795 0xb4, 0xa6, 0xf8, 0xdf, 0x16, 0xaf, 0x8e, 0x0f, 0x6f, 0x7b, 0x19, 0xa3, 0xd6, 0xbf, 0x4c, 0xa4,
796 0xb8, 0x2c, 0xde, 0x1e, 0xcf, 0xc1, 0x52, 0x2a, 0x77, 0x7a, 0xf3, 0xc4, 0xea, 0x10, 0xf2, 0x79,
797 0xf9, 0x4a, 0xd8, 0x99, 0x27, 0xb8, 0x78, 0x73, 0x0c, 0x00, 0xf0, 0x97, 0x27, 0x83, 0xd4, 0x79,
798 0x3c, 0x07, 0xc5, 0xc1, 0xca, 0xf4, 0xaa, 0x6b, 0x7f, 0xad, 0x83, 0x4f, 0x0e, 0xfb, 0xae, 0x8d,
799 0x3c, 0x27, 0x41, 0xda, 0xa3, 0xd0, 0xa9, 0x01, 0xab, 0xf7, 0x6e, 0xa3, 0xf6, 0xde, 0xad, 0x26,
800 0x82, 0x85, 0xb7, 0x4c, 0x04, 0xcd, 0xb7, 0x4e, 0x04, 0xd6, 0xcc, 0x44, 0xd0, 0x93, 0xb0, 0x76,
801 0x7d, 0x10, 0x21, 0xbb, 0xb0, 0xa6, 0x26, 0x99, 0x33, 0x16, 0xa9, 0x73, 0x95, 0xe9, 0x47, 0x86,
802 0x69, 0x57, 0x39, 0x8f, 0xbf, 0x66, 0x51, 0xf4, 0x02, 0xbd, 0xe4, 0x7d, 0xb0, 0xf3, 0x64, 0x44,
803 0x85, 0x9a, 0x7c, 0x4c, 0x0d, 0x6d, 0xed, 0x38, 0xe6, 0xb1, 0xba, 0xaa, 0x0b, 0x9a, 0x62, 0x0e,
804 0x31, 0xe1, 0xbd, 0x7f, 0x2e, 0x82, 0x5d, 0x8e, 0x82, 0xc4, 0x87, 0x4d, 0xc6, 0xbd, 0x8c, 0x8a,
805 0x73, 0x16, 0x50, 0x6f, 0x78, 0x29, 0x69, 0xe6, 0x09, 0x1a, 0xe4, 0x22, 0x63, 0xe7, 0xd4, 0x8c,
806 0xd1, 0x8f, 0x6f, 0x99, 0x29, 0xf1, 0x89, 0x3c, 0x64, 0x7c, 0x80, 0x34, 0x07, 0x8a, 0xc5, 0x2d,
807 0x48, 0xc8, 0x77, 0x70, 0xbf, 0x4a, 0x31, 0xaa, 0xb1, 0x2f, 0xcc, 0xc1, 0x7e, 0xb7, 0x64, 0x1f,
808 0x55, 0xcc, 0x27, 0x70, 0x97, 0x71, 0xef, 0xfb, 0x9c, 0xe6, 0x33, 0xbc, 0xcd, 0x39, 0x78, 0xd7,
809 0x19, 0xff, 0x46, 0xc7, 0x57, 0xac, 0x1e, 0x6c, 0xd4, 0x5a, 0xa2, 0x26, 0x80, 0x1a, 0xb7, 0x35,
810 0x07, 0xf7, 0x83, 0xb2, 0x66, 0x35, 0x31, 0x54, 0x09, 0xfe, 0x08, 0x0f, 0x18, 0xf7, 0x2e, 0x7c,
811 0x26, 0xaf, 0xb3, 0x2f, 0xce, 0xd7, 0x91, 0x6f, 0x7d, 0x26, 0x67, 0xa9, 0xb1, 0x23, 0x31, 0x15,
812 0xe1, 0x4c, 0x47, 0x96, 0xe6, 0xeb, 0xc8, 0x91, 0x8e, 0xaf, 0x58, 0xfb, 0xb0, 0xce, 0xf8, 0xf5,
813 0x5a, 0x5b, 0x73, 0x70, 0xde, 0x61, 0x7c, 0xb6, 0xce, 0x6f, 0x60, 0x3d, 0xa3, 0x81, 0xe4, 0xa2,
814 0xae, 0xb6, 0xf6, 0x1c, 0x8c, 0x6b, 0x26, 0xbc, 0xa4, 0xec, 0x9d, 0x03, 0x54, 0xeb, 0x64, 0x15,
815 0x16, 0x78, 0xaa, 0x4f, 0x8e, 0xed, 0x2e, 0xf0, 0x54, 0x4d, 0x9e, 0x23, 0x75, 0xd9, 0xe1, 0x71,
816 0xb5, 0x5d, 0x63, 0xa9, 0x53, 0x1c, 0xfb, 0x6f, 0x78, 0x31, 0x7a, 0xa2, 0xa1, 0xbd, 0x2c, 0xe1,
817 0xc2, 0x9c, 0x58, 0x34, 0x94, 0xf7, 0xdc, 0x8f, 0x72, 0x5a, 0x4c, 0x5a, 0xda, 0xe8, 0xfd, 0xa5,
818 0x01, 0xed, 0xe2, 0x03, 0x89, 0x7c, 0x5e, 0x1f, 0xde, 0x9b, 0xef, 0xfe, 0x1e, 0x53, 0x41, 0xb8,
819 0x99, 0x72, 0xc2, 0x7f, 0x5e, 0x4d, 0xf8, 0xff, 0x77, 0xb0, 0xf9, 0x0c, 0xa0, 0x60, 0x97, 0xbe,
820 0xda, 0x6e, 0x1b, 0x33, 0xbb, 0xed, 0x42, 0x67, 0x1c, 0xf8, 0xde, 0xd8, 0x4f, 0x46, 0x11, 0xc5,
821 0xb9, 0x74, 0xc5, 0x85, 0x71, 0xe0, 0xbf, 0x44, 0x4f, 0x01, 0xe0, 0xc3, 0x37, 0x34, 0x90, 0x99,
822 0x6e, 0x0a, 0x02, 0x8e, 0xd1, 0xd3, 0xfb, 0xdb, 0x02, 0x74, 0x6a, 0xdf, 0x74, 0x6a, 0x72, 0x4f,
823 0xfc, 0xb8, 0xc8, 0xa3, 0x7f, 0xab, 0xcb, 0x47, 0x4c, 0xf0, 0x2e, 0x31, 0x17, 0x53, 0x4b, 0x4c,
824 0xf4, 0xa5, 0x40, 0x3e, 0x00, 0x10, 0x13, 0x2f, 0xf5, 0x83, 0x33, 0x6a, 0xe8, 0x2d, 0xd7, 0x16,
825 0x93, 0x3e, 0x3a, 0xd4, 0x9d, 0x26, 0x26, 0x1e, 0x15, 0x82, 0x8b, 0xcc, 0xf4, 0xbe, 0x2d, 0x26,
826 0x5f, 0x6a, 0xdb, 0xc4, 0x8e, 0x04, 0x57, 0x13, 0x88, 0x79, 0x06, 0xb6, 0x98, 0xbc, 0x40, 0x87,
827 0xca, 0x2a, 0x8b, 0xac, 0x38, 0xf0, 0xb6, 0x64, 0x95, 0x55, 0x56, 0x59, 0x71, 0xe0, 0xb5, 0x65,
828 0x3d, 0xab, 0x2c, 0xb3, 0xe2, 0xcc, 0xdb, 0x96, 0xb5, 0xac, 0xb2, 0xca, 0x6a, 0x17, 0xb1, 0x26,
829 0x6b, 0xef, 0xef, 0x0d, 0xe8, 0xd4, 0xbe, 0x4e, 0x55, 0x03, 0x13, 0xe1, 0x65, 0x11, 0xa5, 0xa9,
830 0xfa, 0x90, 0xc2, 0xab, 0x1b, 0x12, 0x31, 0x30, 0x1e, 0xc5, 0x97, 0x08, 0x4f, 0xe4, 0x49, 0x52,
831 0x7c, 0x68, 0x59, 0xae, 0x9d, 0x08, 0x17, 0x1d, 0x66, 0x39, 0x93, 0x98, 0xae, 0x59, 0x2c, 0x0f,
832 0xd0, 0x41, 0x7e, 0x09, 0x24, 0x11, 0x5e, 0x9e, 0xb0, 0x44, 0x52, 0x21, 0xf2, 0x54, 0xb2, 0x61,
833 0xf9, 0x51, 0xb0, 0x9e, 0x88, 0xd3, 0xd9, 0x05, 0xf2, 0x48, 0xb3, 0x99, 0xcb, 0xc6, 0xb4, 0xac,
834 0x9d, 0x88, 0x57, 0xfa, 0xe6, 0x38, 0x70, 0x7e, 0xf8, 0x71, 0xeb, 0xbd, 0x7f, 0xff, 0xb8, 0xf5,
835 0xde, 0x9f, 0xa7, 0x5b, 0x8d, 0x1f, 0xa6, 0x5b, 0x8d, 0x7f, 0x4c, 0xb7, 0x1a, 0xff, 0x9d, 0x6e,
836 0x35, 0x86, 0x4b, 0xfa, 0xcf, 0x95, 0x5f, 0xfd, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xc4, 0x4e, 0x24,
837 0x22, 0xc4, 0x11, 0x00, 0x00,
838 }
839
840 func (m *Metrics) Marshal() (dAtA []byte, err error) {
841 size := m.Size()
842 dAtA = make([]byte, size)
843 n, err := m.MarshalToSizedBuffer(dAtA[:size])
844 if err != nil {
845 return nil, err
846 }
847 return dAtA[:n], nil
848 }
849
850 func (m *Metrics) MarshalTo(dAtA []byte) (int, error) {
851 size := m.Size()
852 return m.MarshalToSizedBuffer(dAtA[:size])
853 }
854
855 func (m *Metrics) MarshalToSizedBuffer(dAtA []byte) (int, error) {
856 i := len(dAtA)
857 _ = i
858 var l int
859 _ = l
860 if m.XXX_unrecognized != nil {
861 i -= len(m.XXX_unrecognized)
862 copy(dAtA[i:], m.XXX_unrecognized)
863 }
864 if m.MemoryOomControl != nil {
865 {
866 size, err := m.MemoryOomControl.MarshalToSizedBuffer(dAtA[:i])
867 if err != nil {
868 return 0, err
869 }
870 i -= size
871 i = encodeVarintMetrics(dAtA, i, uint64(size))
872 }
873 i--
874 dAtA[i] = 0x4a
875 }
876 if m.CgroupStats != nil {
877 {
878 size, err := m.CgroupStats.MarshalToSizedBuffer(dAtA[:i])
879 if err != nil {
880 return 0, err
881 }
882 i -= size
883 i = encodeVarintMetrics(dAtA, i, uint64(size))
884 }
885 i--
886 dAtA[i] = 0x42
887 }
888 if len(m.Network) > 0 {
889 for iNdEx := len(m.Network) - 1; iNdEx >= 0; iNdEx-- {
890 {
891 size, err := m.Network[iNdEx].MarshalToSizedBuffer(dAtA[:i])
892 if err != nil {
893 return 0, err
894 }
895 i -= size
896 i = encodeVarintMetrics(dAtA, i, uint64(size))
897 }
898 i--
899 dAtA[i] = 0x3a
900 }
901 }
902 if m.Rdma != nil {
903 {
904 size, err := m.Rdma.MarshalToSizedBuffer(dAtA[:i])
905 if err != nil {
906 return 0, err
907 }
908 i -= size
909 i = encodeVarintMetrics(dAtA, i, uint64(size))
910 }
911 i--
912 dAtA[i] = 0x32
913 }
914 if m.Blkio != nil {
915 {
916 size, err := m.Blkio.MarshalToSizedBuffer(dAtA[:i])
917 if err != nil {
918 return 0, err
919 }
920 i -= size
921 i = encodeVarintMetrics(dAtA, i, uint64(size))
922 }
923 i--
924 dAtA[i] = 0x2a
925 }
926 if m.Memory != nil {
927 {
928 size, err := m.Memory.MarshalToSizedBuffer(dAtA[:i])
929 if err != nil {
930 return 0, err
931 }
932 i -= size
933 i = encodeVarintMetrics(dAtA, i, uint64(size))
934 }
935 i--
936 dAtA[i] = 0x22
937 }
938 if m.CPU != nil {
939 {
940 size, err := m.CPU.MarshalToSizedBuffer(dAtA[:i])
941 if err != nil {
942 return 0, err
943 }
944 i -= size
945 i = encodeVarintMetrics(dAtA, i, uint64(size))
946 }
947 i--
948 dAtA[i] = 0x1a
949 }
950 if m.Pids != nil {
951 {
952 size, err := m.Pids.MarshalToSizedBuffer(dAtA[:i])
953 if err != nil {
954 return 0, err
955 }
956 i -= size
957 i = encodeVarintMetrics(dAtA, i, uint64(size))
958 }
959 i--
960 dAtA[i] = 0x12
961 }
962 if len(m.Hugetlb) > 0 {
963 for iNdEx := len(m.Hugetlb) - 1; iNdEx >= 0; iNdEx-- {
964 {
965 size, err := m.Hugetlb[iNdEx].MarshalToSizedBuffer(dAtA[:i])
966 if err != nil {
967 return 0, err
968 }
969 i -= size
970 i = encodeVarintMetrics(dAtA, i, uint64(size))
971 }
972 i--
973 dAtA[i] = 0xa
974 }
975 }
976 return len(dAtA) - i, nil
977 }
978
979 func (m *HugetlbStat) Marshal() (dAtA []byte, err error) {
980 size := m.Size()
981 dAtA = make([]byte, size)
982 n, err := m.MarshalToSizedBuffer(dAtA[:size])
983 if err != nil {
984 return nil, err
985 }
986 return dAtA[:n], nil
987 }
988
989 func (m *HugetlbStat) MarshalTo(dAtA []byte) (int, error) {
990 size := m.Size()
991 return m.MarshalToSizedBuffer(dAtA[:size])
992 }
993
994 func (m *HugetlbStat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
995 i := len(dAtA)
996 _ = i
997 var l int
998 _ = l
999 if m.XXX_unrecognized != nil {
1000 i -= len(m.XXX_unrecognized)
1001 copy(dAtA[i:], m.XXX_unrecognized)
1002 }
1003 if len(m.Pagesize) > 0 {
1004 i -= len(m.Pagesize)
1005 copy(dAtA[i:], m.Pagesize)
1006 i = encodeVarintMetrics(dAtA, i, uint64(len(m.Pagesize)))
1007 i--
1008 dAtA[i] = 0x22
1009 }
1010 if m.Failcnt != 0 {
1011 i = encodeVarintMetrics(dAtA, i, uint64(m.Failcnt))
1012 i--
1013 dAtA[i] = 0x18
1014 }
1015 if m.Max != 0 {
1016 i = encodeVarintMetrics(dAtA, i, uint64(m.Max))
1017 i--
1018 dAtA[i] = 0x10
1019 }
1020 if m.Usage != 0 {
1021 i = encodeVarintMetrics(dAtA, i, uint64(m.Usage))
1022 i--
1023 dAtA[i] = 0x8
1024 }
1025 return len(dAtA) - i, nil
1026 }
1027
1028 func (m *PidsStat) Marshal() (dAtA []byte, err error) {
1029 size := m.Size()
1030 dAtA = make([]byte, size)
1031 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1032 if err != nil {
1033 return nil, err
1034 }
1035 return dAtA[:n], nil
1036 }
1037
1038 func (m *PidsStat) MarshalTo(dAtA []byte) (int, error) {
1039 size := m.Size()
1040 return m.MarshalToSizedBuffer(dAtA[:size])
1041 }
1042
1043 func (m *PidsStat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1044 i := len(dAtA)
1045 _ = i
1046 var l int
1047 _ = l
1048 if m.XXX_unrecognized != nil {
1049 i -= len(m.XXX_unrecognized)
1050 copy(dAtA[i:], m.XXX_unrecognized)
1051 }
1052 if m.Limit != 0 {
1053 i = encodeVarintMetrics(dAtA, i, uint64(m.Limit))
1054 i--
1055 dAtA[i] = 0x10
1056 }
1057 if m.Current != 0 {
1058 i = encodeVarintMetrics(dAtA, i, uint64(m.Current))
1059 i--
1060 dAtA[i] = 0x8
1061 }
1062 return len(dAtA) - i, nil
1063 }
1064
1065 func (m *CPUStat) Marshal() (dAtA []byte, err error) {
1066 size := m.Size()
1067 dAtA = make([]byte, size)
1068 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1069 if err != nil {
1070 return nil, err
1071 }
1072 return dAtA[:n], nil
1073 }
1074
1075 func (m *CPUStat) MarshalTo(dAtA []byte) (int, error) {
1076 size := m.Size()
1077 return m.MarshalToSizedBuffer(dAtA[:size])
1078 }
1079
1080 func (m *CPUStat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1081 i := len(dAtA)
1082 _ = i
1083 var l int
1084 _ = l
1085 if m.XXX_unrecognized != nil {
1086 i -= len(m.XXX_unrecognized)
1087 copy(dAtA[i:], m.XXX_unrecognized)
1088 }
1089 if m.Throttling != nil {
1090 {
1091 size, err := m.Throttling.MarshalToSizedBuffer(dAtA[:i])
1092 if err != nil {
1093 return 0, err
1094 }
1095 i -= size
1096 i = encodeVarintMetrics(dAtA, i, uint64(size))
1097 }
1098 i--
1099 dAtA[i] = 0x12
1100 }
1101 if m.Usage != nil {
1102 {
1103 size, err := m.Usage.MarshalToSizedBuffer(dAtA[:i])
1104 if err != nil {
1105 return 0, err
1106 }
1107 i -= size
1108 i = encodeVarintMetrics(dAtA, i, uint64(size))
1109 }
1110 i--
1111 dAtA[i] = 0xa
1112 }
1113 return len(dAtA) - i, nil
1114 }
1115
1116 func (m *CPUUsage) Marshal() (dAtA []byte, err error) {
1117 size := m.Size()
1118 dAtA = make([]byte, size)
1119 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1120 if err != nil {
1121 return nil, err
1122 }
1123 return dAtA[:n], nil
1124 }
1125
1126 func (m *CPUUsage) MarshalTo(dAtA []byte) (int, error) {
1127 size := m.Size()
1128 return m.MarshalToSizedBuffer(dAtA[:size])
1129 }
1130
1131 func (m *CPUUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1132 i := len(dAtA)
1133 _ = i
1134 var l int
1135 _ = l
1136 if m.XXX_unrecognized != nil {
1137 i -= len(m.XXX_unrecognized)
1138 copy(dAtA[i:], m.XXX_unrecognized)
1139 }
1140 if len(m.PerCPU) > 0 {
1141 dAtA11 := make([]byte, len(m.PerCPU)*10)
1142 var j10 int
1143 for _, num := range m.PerCPU {
1144 for num >= 1<<7 {
1145 dAtA11[j10] = uint8(uint64(num)&0x7f | 0x80)
1146 num >>= 7
1147 j10++
1148 }
1149 dAtA11[j10] = uint8(num)
1150 j10++
1151 }
1152 i -= j10
1153 copy(dAtA[i:], dAtA11[:j10])
1154 i = encodeVarintMetrics(dAtA, i, uint64(j10))
1155 i--
1156 dAtA[i] = 0x22
1157 }
1158 if m.User != 0 {
1159 i = encodeVarintMetrics(dAtA, i, uint64(m.User))
1160 i--
1161 dAtA[i] = 0x18
1162 }
1163 if m.Kernel != 0 {
1164 i = encodeVarintMetrics(dAtA, i, uint64(m.Kernel))
1165 i--
1166 dAtA[i] = 0x10
1167 }
1168 if m.Total != 0 {
1169 i = encodeVarintMetrics(dAtA, i, uint64(m.Total))
1170 i--
1171 dAtA[i] = 0x8
1172 }
1173 return len(dAtA) - i, nil
1174 }
1175
1176 func (m *Throttle) Marshal() (dAtA []byte, err error) {
1177 size := m.Size()
1178 dAtA = make([]byte, size)
1179 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1180 if err != nil {
1181 return nil, err
1182 }
1183 return dAtA[:n], nil
1184 }
1185
1186 func (m *Throttle) MarshalTo(dAtA []byte) (int, error) {
1187 size := m.Size()
1188 return m.MarshalToSizedBuffer(dAtA[:size])
1189 }
1190
1191 func (m *Throttle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1192 i := len(dAtA)
1193 _ = i
1194 var l int
1195 _ = l
1196 if m.XXX_unrecognized != nil {
1197 i -= len(m.XXX_unrecognized)
1198 copy(dAtA[i:], m.XXX_unrecognized)
1199 }
1200 if m.ThrottledTime != 0 {
1201 i = encodeVarintMetrics(dAtA, i, uint64(m.ThrottledTime))
1202 i--
1203 dAtA[i] = 0x18
1204 }
1205 if m.ThrottledPeriods != 0 {
1206 i = encodeVarintMetrics(dAtA, i, uint64(m.ThrottledPeriods))
1207 i--
1208 dAtA[i] = 0x10
1209 }
1210 if m.Periods != 0 {
1211 i = encodeVarintMetrics(dAtA, i, uint64(m.Periods))
1212 i--
1213 dAtA[i] = 0x8
1214 }
1215 return len(dAtA) - i, nil
1216 }
1217
1218 func (m *MemoryStat) Marshal() (dAtA []byte, err error) {
1219 size := m.Size()
1220 dAtA = make([]byte, size)
1221 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1222 if err != nil {
1223 return nil, err
1224 }
1225 return dAtA[:n], nil
1226 }
1227
1228 func (m *MemoryStat) MarshalTo(dAtA []byte) (int, error) {
1229 size := m.Size()
1230 return m.MarshalToSizedBuffer(dAtA[:size])
1231 }
1232
1233 func (m *MemoryStat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1234 i := len(dAtA)
1235 _ = i
1236 var l int
1237 _ = l
1238 if m.XXX_unrecognized != nil {
1239 i -= len(m.XXX_unrecognized)
1240 copy(dAtA[i:], m.XXX_unrecognized)
1241 }
1242 if m.KernelTCP != nil {
1243 {
1244 size, err := m.KernelTCP.MarshalToSizedBuffer(dAtA[:i])
1245 if err != nil {
1246 return 0, err
1247 }
1248 i -= size
1249 i = encodeVarintMetrics(dAtA, i, uint64(size))
1250 }
1251 i--
1252 dAtA[i] = 0x2
1253 i--
1254 dAtA[i] = 0xa2
1255 }
1256 if m.Kernel != nil {
1257 {
1258 size, err := m.Kernel.MarshalToSizedBuffer(dAtA[:i])
1259 if err != nil {
1260 return 0, err
1261 }
1262 i -= size
1263 i = encodeVarintMetrics(dAtA, i, uint64(size))
1264 }
1265 i--
1266 dAtA[i] = 0x2
1267 i--
1268 dAtA[i] = 0x9a
1269 }
1270 if m.Swap != nil {
1271 {
1272 size, err := m.Swap.MarshalToSizedBuffer(dAtA[:i])
1273 if err != nil {
1274 return 0, err
1275 }
1276 i -= size
1277 i = encodeVarintMetrics(dAtA, i, uint64(size))
1278 }
1279 i--
1280 dAtA[i] = 0x2
1281 i--
1282 dAtA[i] = 0x92
1283 }
1284 if m.Usage != nil {
1285 {
1286 size, err := m.Usage.MarshalToSizedBuffer(dAtA[:i])
1287 if err != nil {
1288 return 0, err
1289 }
1290 i -= size
1291 i = encodeVarintMetrics(dAtA, i, uint64(size))
1292 }
1293 i--
1294 dAtA[i] = 0x2
1295 i--
1296 dAtA[i] = 0x8a
1297 }
1298 if m.TotalUnevictable != 0 {
1299 i = encodeVarintMetrics(dAtA, i, uint64(m.TotalUnevictable))
1300 i--
1301 dAtA[i] = 0x2
1302 i--
1303 dAtA[i] = 0x80
1304 }
1305 if m.TotalActiveFile != 0 {
1306 i = encodeVarintMetrics(dAtA, i, uint64(m.TotalActiveFile))
1307 i--
1308 dAtA[i] = 0x1
1309 i--
1310 dAtA[i] = 0xf8
1311 }
1312 if m.TotalInactiveFile != 0 {
1313 i = encodeVarintMetrics(dAtA, i, uint64(m.TotalInactiveFile))
1314 i--
1315 dAtA[i] = 0x1
1316 i--
1317 dAtA[i] = 0xf0
1318 }
1319 if m.TotalActiveAnon != 0 {
1320 i = encodeVarintMetrics(dAtA, i, uint64(m.TotalActiveAnon))
1321 i--
1322 dAtA[i] = 0x1
1323 i--
1324 dAtA[i] = 0xe8
1325 }
1326 if m.TotalInactiveAnon != 0 {
1327 i = encodeVarintMetrics(dAtA, i, uint64(m.TotalInactiveAnon))
1328 i--
1329 dAtA[i] = 0x1
1330 i--
1331 dAtA[i] = 0xe0
1332 }
1333 if m.TotalPgMajFault != 0 {
1334 i = encodeVarintMetrics(dAtA, i, uint64(m.TotalPgMajFault))
1335 i--
1336 dAtA[i] = 0x1
1337 i--
1338 dAtA[i] = 0xd8
1339 }
1340 if m.TotalPgFault != 0 {
1341 i = encodeVarintMetrics(dAtA, i, uint64(m.TotalPgFault))
1342 i--
1343 dAtA[i] = 0x1
1344 i--
1345 dAtA[i] = 0xd0
1346 }
1347 if m.TotalPgPgOut != 0 {
1348 i = encodeVarintMetrics(dAtA, i, uint64(m.TotalPgPgOut))
1349 i--
1350 dAtA[i] = 0x1
1351 i--
1352 dAtA[i] = 0xc8
1353 }
1354 if m.TotalPgPgIn != 0 {
1355 i = encodeVarintMetrics(dAtA, i, uint64(m.TotalPgPgIn))
1356 i--
1357 dAtA[i] = 0x1
1358 i--
1359 dAtA[i] = 0xc0
1360 }
1361 if m.TotalWriteback != 0 {
1362 i = encodeVarintMetrics(dAtA, i, uint64(m.TotalWriteback))
1363 i--
1364 dAtA[i] = 0x1
1365 i--
1366 dAtA[i] = 0xb8
1367 }
1368 if m.TotalDirty != 0 {
1369 i = encodeVarintMetrics(dAtA, i, uint64(m.TotalDirty))
1370 i--
1371 dAtA[i] = 0x1
1372 i--
1373 dAtA[i] = 0xb0
1374 }
1375 if m.TotalMappedFile != 0 {
1376 i = encodeVarintMetrics(dAtA, i, uint64(m.TotalMappedFile))
1377 i--
1378 dAtA[i] = 0x1
1379 i--
1380 dAtA[i] = 0xa8
1381 }
1382 if m.TotalRSSHuge != 0 {
1383 i = encodeVarintMetrics(dAtA, i, uint64(m.TotalRSSHuge))
1384 i--
1385 dAtA[i] = 0x1
1386 i--
1387 dAtA[i] = 0xa0
1388 }
1389 if m.TotalRSS != 0 {
1390 i = encodeVarintMetrics(dAtA, i, uint64(m.TotalRSS))
1391 i--
1392 dAtA[i] = 0x1
1393 i--
1394 dAtA[i] = 0x98
1395 }
1396 if m.TotalCache != 0 {
1397 i = encodeVarintMetrics(dAtA, i, uint64(m.TotalCache))
1398 i--
1399 dAtA[i] = 0x1
1400 i--
1401 dAtA[i] = 0x90
1402 }
1403 if m.HierarchicalSwapLimit != 0 {
1404 i = encodeVarintMetrics(dAtA, i, uint64(m.HierarchicalSwapLimit))
1405 i--
1406 dAtA[i] = 0x1
1407 i--
1408 dAtA[i] = 0x88
1409 }
1410 if m.HierarchicalMemoryLimit != 0 {
1411 i = encodeVarintMetrics(dAtA, i, uint64(m.HierarchicalMemoryLimit))
1412 i--
1413 dAtA[i] = 0x1
1414 i--
1415 dAtA[i] = 0x80
1416 }
1417 if m.Unevictable != 0 {
1418 i = encodeVarintMetrics(dAtA, i, uint64(m.Unevictable))
1419 i--
1420 dAtA[i] = 0x78
1421 }
1422 if m.ActiveFile != 0 {
1423 i = encodeVarintMetrics(dAtA, i, uint64(m.ActiveFile))
1424 i--
1425 dAtA[i] = 0x70
1426 }
1427 if m.InactiveFile != 0 {
1428 i = encodeVarintMetrics(dAtA, i, uint64(m.InactiveFile))
1429 i--
1430 dAtA[i] = 0x68
1431 }
1432 if m.ActiveAnon != 0 {
1433 i = encodeVarintMetrics(dAtA, i, uint64(m.ActiveAnon))
1434 i--
1435 dAtA[i] = 0x60
1436 }
1437 if m.InactiveAnon != 0 {
1438 i = encodeVarintMetrics(dAtA, i, uint64(m.InactiveAnon))
1439 i--
1440 dAtA[i] = 0x58
1441 }
1442 if m.PgMajFault != 0 {
1443 i = encodeVarintMetrics(dAtA, i, uint64(m.PgMajFault))
1444 i--
1445 dAtA[i] = 0x50
1446 }
1447 if m.PgFault != 0 {
1448 i = encodeVarintMetrics(dAtA, i, uint64(m.PgFault))
1449 i--
1450 dAtA[i] = 0x48
1451 }
1452 if m.PgPgOut != 0 {
1453 i = encodeVarintMetrics(dAtA, i, uint64(m.PgPgOut))
1454 i--
1455 dAtA[i] = 0x40
1456 }
1457 if m.PgPgIn != 0 {
1458 i = encodeVarintMetrics(dAtA, i, uint64(m.PgPgIn))
1459 i--
1460 dAtA[i] = 0x38
1461 }
1462 if m.Writeback != 0 {
1463 i = encodeVarintMetrics(dAtA, i, uint64(m.Writeback))
1464 i--
1465 dAtA[i] = 0x30
1466 }
1467 if m.Dirty != 0 {
1468 i = encodeVarintMetrics(dAtA, i, uint64(m.Dirty))
1469 i--
1470 dAtA[i] = 0x28
1471 }
1472 if m.MappedFile != 0 {
1473 i = encodeVarintMetrics(dAtA, i, uint64(m.MappedFile))
1474 i--
1475 dAtA[i] = 0x20
1476 }
1477 if m.RSSHuge != 0 {
1478 i = encodeVarintMetrics(dAtA, i, uint64(m.RSSHuge))
1479 i--
1480 dAtA[i] = 0x18
1481 }
1482 if m.RSS != 0 {
1483 i = encodeVarintMetrics(dAtA, i, uint64(m.RSS))
1484 i--
1485 dAtA[i] = 0x10
1486 }
1487 if m.Cache != 0 {
1488 i = encodeVarintMetrics(dAtA, i, uint64(m.Cache))
1489 i--
1490 dAtA[i] = 0x8
1491 }
1492 return len(dAtA) - i, nil
1493 }
1494
1495 func (m *MemoryEntry) Marshal() (dAtA []byte, err error) {
1496 size := m.Size()
1497 dAtA = make([]byte, size)
1498 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1499 if err != nil {
1500 return nil, err
1501 }
1502 return dAtA[:n], nil
1503 }
1504
1505 func (m *MemoryEntry) MarshalTo(dAtA []byte) (int, error) {
1506 size := m.Size()
1507 return m.MarshalToSizedBuffer(dAtA[:size])
1508 }
1509
1510 func (m *MemoryEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1511 i := len(dAtA)
1512 _ = i
1513 var l int
1514 _ = l
1515 if m.XXX_unrecognized != nil {
1516 i -= len(m.XXX_unrecognized)
1517 copy(dAtA[i:], m.XXX_unrecognized)
1518 }
1519 if m.Failcnt != 0 {
1520 i = encodeVarintMetrics(dAtA, i, uint64(m.Failcnt))
1521 i--
1522 dAtA[i] = 0x20
1523 }
1524 if m.Max != 0 {
1525 i = encodeVarintMetrics(dAtA, i, uint64(m.Max))
1526 i--
1527 dAtA[i] = 0x18
1528 }
1529 if m.Usage != 0 {
1530 i = encodeVarintMetrics(dAtA, i, uint64(m.Usage))
1531 i--
1532 dAtA[i] = 0x10
1533 }
1534 if m.Limit != 0 {
1535 i = encodeVarintMetrics(dAtA, i, uint64(m.Limit))
1536 i--
1537 dAtA[i] = 0x8
1538 }
1539 return len(dAtA) - i, nil
1540 }
1541
1542 func (m *MemoryOomControl) Marshal() (dAtA []byte, err error) {
1543 size := m.Size()
1544 dAtA = make([]byte, size)
1545 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1546 if err != nil {
1547 return nil, err
1548 }
1549 return dAtA[:n], nil
1550 }
1551
1552 func (m *MemoryOomControl) MarshalTo(dAtA []byte) (int, error) {
1553 size := m.Size()
1554 return m.MarshalToSizedBuffer(dAtA[:size])
1555 }
1556
1557 func (m *MemoryOomControl) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1558 i := len(dAtA)
1559 _ = i
1560 var l int
1561 _ = l
1562 if m.XXX_unrecognized != nil {
1563 i -= len(m.XXX_unrecognized)
1564 copy(dAtA[i:], m.XXX_unrecognized)
1565 }
1566 if m.OomKill != 0 {
1567 i = encodeVarintMetrics(dAtA, i, uint64(m.OomKill))
1568 i--
1569 dAtA[i] = 0x18
1570 }
1571 if m.UnderOom != 0 {
1572 i = encodeVarintMetrics(dAtA, i, uint64(m.UnderOom))
1573 i--
1574 dAtA[i] = 0x10
1575 }
1576 if m.OomKillDisable != 0 {
1577 i = encodeVarintMetrics(dAtA, i, uint64(m.OomKillDisable))
1578 i--
1579 dAtA[i] = 0x8
1580 }
1581 return len(dAtA) - i, nil
1582 }
1583
1584 func (m *BlkIOStat) Marshal() (dAtA []byte, err error) {
1585 size := m.Size()
1586 dAtA = make([]byte, size)
1587 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1588 if err != nil {
1589 return nil, err
1590 }
1591 return dAtA[:n], nil
1592 }
1593
1594 func (m *BlkIOStat) MarshalTo(dAtA []byte) (int, error) {
1595 size := m.Size()
1596 return m.MarshalToSizedBuffer(dAtA[:size])
1597 }
1598
1599 func (m *BlkIOStat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1600 i := len(dAtA)
1601 _ = i
1602 var l int
1603 _ = l
1604 if m.XXX_unrecognized != nil {
1605 i -= len(m.XXX_unrecognized)
1606 copy(dAtA[i:], m.XXX_unrecognized)
1607 }
1608 if len(m.SectorsRecursive) > 0 {
1609 for iNdEx := len(m.SectorsRecursive) - 1; iNdEx >= 0; iNdEx-- {
1610 {
1611 size, err := m.SectorsRecursive[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1612 if err != nil {
1613 return 0, err
1614 }
1615 i -= size
1616 i = encodeVarintMetrics(dAtA, i, uint64(size))
1617 }
1618 i--
1619 dAtA[i] = 0x42
1620 }
1621 }
1622 if len(m.IoTimeRecursive) > 0 {
1623 for iNdEx := len(m.IoTimeRecursive) - 1; iNdEx >= 0; iNdEx-- {
1624 {
1625 size, err := m.IoTimeRecursive[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1626 if err != nil {
1627 return 0, err
1628 }
1629 i -= size
1630 i = encodeVarintMetrics(dAtA, i, uint64(size))
1631 }
1632 i--
1633 dAtA[i] = 0x3a
1634 }
1635 }
1636 if len(m.IoMergedRecursive) > 0 {
1637 for iNdEx := len(m.IoMergedRecursive) - 1; iNdEx >= 0; iNdEx-- {
1638 {
1639 size, err := m.IoMergedRecursive[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1640 if err != nil {
1641 return 0, err
1642 }
1643 i -= size
1644 i = encodeVarintMetrics(dAtA, i, uint64(size))
1645 }
1646 i--
1647 dAtA[i] = 0x32
1648 }
1649 }
1650 if len(m.IoWaitTimeRecursive) > 0 {
1651 for iNdEx := len(m.IoWaitTimeRecursive) - 1; iNdEx >= 0; iNdEx-- {
1652 {
1653 size, err := m.IoWaitTimeRecursive[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1654 if err != nil {
1655 return 0, err
1656 }
1657 i -= size
1658 i = encodeVarintMetrics(dAtA, i, uint64(size))
1659 }
1660 i--
1661 dAtA[i] = 0x2a
1662 }
1663 }
1664 if len(m.IoServiceTimeRecursive) > 0 {
1665 for iNdEx := len(m.IoServiceTimeRecursive) - 1; iNdEx >= 0; iNdEx-- {
1666 {
1667 size, err := m.IoServiceTimeRecursive[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1668 if err != nil {
1669 return 0, err
1670 }
1671 i -= size
1672 i = encodeVarintMetrics(dAtA, i, uint64(size))
1673 }
1674 i--
1675 dAtA[i] = 0x22
1676 }
1677 }
1678 if len(m.IoQueuedRecursive) > 0 {
1679 for iNdEx := len(m.IoQueuedRecursive) - 1; iNdEx >= 0; iNdEx-- {
1680 {
1681 size, err := m.IoQueuedRecursive[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1682 if err != nil {
1683 return 0, err
1684 }
1685 i -= size
1686 i = encodeVarintMetrics(dAtA, i, uint64(size))
1687 }
1688 i--
1689 dAtA[i] = 0x1a
1690 }
1691 }
1692 if len(m.IoServicedRecursive) > 0 {
1693 for iNdEx := len(m.IoServicedRecursive) - 1; iNdEx >= 0; iNdEx-- {
1694 {
1695 size, err := m.IoServicedRecursive[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1696 if err != nil {
1697 return 0, err
1698 }
1699 i -= size
1700 i = encodeVarintMetrics(dAtA, i, uint64(size))
1701 }
1702 i--
1703 dAtA[i] = 0x12
1704 }
1705 }
1706 if len(m.IoServiceBytesRecursive) > 0 {
1707 for iNdEx := len(m.IoServiceBytesRecursive) - 1; iNdEx >= 0; iNdEx-- {
1708 {
1709 size, err := m.IoServiceBytesRecursive[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1710 if err != nil {
1711 return 0, err
1712 }
1713 i -= size
1714 i = encodeVarintMetrics(dAtA, i, uint64(size))
1715 }
1716 i--
1717 dAtA[i] = 0xa
1718 }
1719 }
1720 return len(dAtA) - i, nil
1721 }
1722
1723 func (m *BlkIOEntry) Marshal() (dAtA []byte, err error) {
1724 size := m.Size()
1725 dAtA = make([]byte, size)
1726 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1727 if err != nil {
1728 return nil, err
1729 }
1730 return dAtA[:n], nil
1731 }
1732
1733 func (m *BlkIOEntry) MarshalTo(dAtA []byte) (int, error) {
1734 size := m.Size()
1735 return m.MarshalToSizedBuffer(dAtA[:size])
1736 }
1737
1738 func (m *BlkIOEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1739 i := len(dAtA)
1740 _ = i
1741 var l int
1742 _ = l
1743 if m.XXX_unrecognized != nil {
1744 i -= len(m.XXX_unrecognized)
1745 copy(dAtA[i:], m.XXX_unrecognized)
1746 }
1747 if m.Value != 0 {
1748 i = encodeVarintMetrics(dAtA, i, uint64(m.Value))
1749 i--
1750 dAtA[i] = 0x28
1751 }
1752 if m.Minor != 0 {
1753 i = encodeVarintMetrics(dAtA, i, uint64(m.Minor))
1754 i--
1755 dAtA[i] = 0x20
1756 }
1757 if m.Major != 0 {
1758 i = encodeVarintMetrics(dAtA, i, uint64(m.Major))
1759 i--
1760 dAtA[i] = 0x18
1761 }
1762 if len(m.Device) > 0 {
1763 i -= len(m.Device)
1764 copy(dAtA[i:], m.Device)
1765 i = encodeVarintMetrics(dAtA, i, uint64(len(m.Device)))
1766 i--
1767 dAtA[i] = 0x12
1768 }
1769 if len(m.Op) > 0 {
1770 i -= len(m.Op)
1771 copy(dAtA[i:], m.Op)
1772 i = encodeVarintMetrics(dAtA, i, uint64(len(m.Op)))
1773 i--
1774 dAtA[i] = 0xa
1775 }
1776 return len(dAtA) - i, nil
1777 }
1778
1779 func (m *RdmaStat) Marshal() (dAtA []byte, err error) {
1780 size := m.Size()
1781 dAtA = make([]byte, size)
1782 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1783 if err != nil {
1784 return nil, err
1785 }
1786 return dAtA[:n], nil
1787 }
1788
1789 func (m *RdmaStat) MarshalTo(dAtA []byte) (int, error) {
1790 size := m.Size()
1791 return m.MarshalToSizedBuffer(dAtA[:size])
1792 }
1793
1794 func (m *RdmaStat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1795 i := len(dAtA)
1796 _ = i
1797 var l int
1798 _ = l
1799 if m.XXX_unrecognized != nil {
1800 i -= len(m.XXX_unrecognized)
1801 copy(dAtA[i:], m.XXX_unrecognized)
1802 }
1803 if len(m.Limit) > 0 {
1804 for iNdEx := len(m.Limit) - 1; iNdEx >= 0; iNdEx-- {
1805 {
1806 size, err := m.Limit[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1807 if err != nil {
1808 return 0, err
1809 }
1810 i -= size
1811 i = encodeVarintMetrics(dAtA, i, uint64(size))
1812 }
1813 i--
1814 dAtA[i] = 0x12
1815 }
1816 }
1817 if len(m.Current) > 0 {
1818 for iNdEx := len(m.Current) - 1; iNdEx >= 0; iNdEx-- {
1819 {
1820 size, err := m.Current[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1821 if err != nil {
1822 return 0, err
1823 }
1824 i -= size
1825 i = encodeVarintMetrics(dAtA, i, uint64(size))
1826 }
1827 i--
1828 dAtA[i] = 0xa
1829 }
1830 }
1831 return len(dAtA) - i, nil
1832 }
1833
1834 func (m *RdmaEntry) Marshal() (dAtA []byte, err error) {
1835 size := m.Size()
1836 dAtA = make([]byte, size)
1837 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1838 if err != nil {
1839 return nil, err
1840 }
1841 return dAtA[:n], nil
1842 }
1843
1844 func (m *RdmaEntry) MarshalTo(dAtA []byte) (int, error) {
1845 size := m.Size()
1846 return m.MarshalToSizedBuffer(dAtA[:size])
1847 }
1848
1849 func (m *RdmaEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1850 i := len(dAtA)
1851 _ = i
1852 var l int
1853 _ = l
1854 if m.XXX_unrecognized != nil {
1855 i -= len(m.XXX_unrecognized)
1856 copy(dAtA[i:], m.XXX_unrecognized)
1857 }
1858 if m.HcaObjects != 0 {
1859 i = encodeVarintMetrics(dAtA, i, uint64(m.HcaObjects))
1860 i--
1861 dAtA[i] = 0x18
1862 }
1863 if m.HcaHandles != 0 {
1864 i = encodeVarintMetrics(dAtA, i, uint64(m.HcaHandles))
1865 i--
1866 dAtA[i] = 0x10
1867 }
1868 if len(m.Device) > 0 {
1869 i -= len(m.Device)
1870 copy(dAtA[i:], m.Device)
1871 i = encodeVarintMetrics(dAtA, i, uint64(len(m.Device)))
1872 i--
1873 dAtA[i] = 0xa
1874 }
1875 return len(dAtA) - i, nil
1876 }
1877
1878 func (m *NetworkStat) Marshal() (dAtA []byte, err error) {
1879 size := m.Size()
1880 dAtA = make([]byte, size)
1881 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1882 if err != nil {
1883 return nil, err
1884 }
1885 return dAtA[:n], nil
1886 }
1887
1888 func (m *NetworkStat) MarshalTo(dAtA []byte) (int, error) {
1889 size := m.Size()
1890 return m.MarshalToSizedBuffer(dAtA[:size])
1891 }
1892
1893 func (m *NetworkStat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1894 i := len(dAtA)
1895 _ = i
1896 var l int
1897 _ = l
1898 if m.XXX_unrecognized != nil {
1899 i -= len(m.XXX_unrecognized)
1900 copy(dAtA[i:], m.XXX_unrecognized)
1901 }
1902 if m.TxDropped != 0 {
1903 i = encodeVarintMetrics(dAtA, i, uint64(m.TxDropped))
1904 i--
1905 dAtA[i] = 0x48
1906 }
1907 if m.TxErrors != 0 {
1908 i = encodeVarintMetrics(dAtA, i, uint64(m.TxErrors))
1909 i--
1910 dAtA[i] = 0x40
1911 }
1912 if m.TxPackets != 0 {
1913 i = encodeVarintMetrics(dAtA, i, uint64(m.TxPackets))
1914 i--
1915 dAtA[i] = 0x38
1916 }
1917 if m.TxBytes != 0 {
1918 i = encodeVarintMetrics(dAtA, i, uint64(m.TxBytes))
1919 i--
1920 dAtA[i] = 0x30
1921 }
1922 if m.RxDropped != 0 {
1923 i = encodeVarintMetrics(dAtA, i, uint64(m.RxDropped))
1924 i--
1925 dAtA[i] = 0x28
1926 }
1927 if m.RxErrors != 0 {
1928 i = encodeVarintMetrics(dAtA, i, uint64(m.RxErrors))
1929 i--
1930 dAtA[i] = 0x20
1931 }
1932 if m.RxPackets != 0 {
1933 i = encodeVarintMetrics(dAtA, i, uint64(m.RxPackets))
1934 i--
1935 dAtA[i] = 0x18
1936 }
1937 if m.RxBytes != 0 {
1938 i = encodeVarintMetrics(dAtA, i, uint64(m.RxBytes))
1939 i--
1940 dAtA[i] = 0x10
1941 }
1942 if len(m.Name) > 0 {
1943 i -= len(m.Name)
1944 copy(dAtA[i:], m.Name)
1945 i = encodeVarintMetrics(dAtA, i, uint64(len(m.Name)))
1946 i--
1947 dAtA[i] = 0xa
1948 }
1949 return len(dAtA) - i, nil
1950 }
1951
1952 func (m *CgroupStats) Marshal() (dAtA []byte, err error) {
1953 size := m.Size()
1954 dAtA = make([]byte, size)
1955 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1956 if err != nil {
1957 return nil, err
1958 }
1959 return dAtA[:n], nil
1960 }
1961
1962 func (m *CgroupStats) MarshalTo(dAtA []byte) (int, error) {
1963 size := m.Size()
1964 return m.MarshalToSizedBuffer(dAtA[:size])
1965 }
1966
1967 func (m *CgroupStats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1968 i := len(dAtA)
1969 _ = i
1970 var l int
1971 _ = l
1972 if m.XXX_unrecognized != nil {
1973 i -= len(m.XXX_unrecognized)
1974 copy(dAtA[i:], m.XXX_unrecognized)
1975 }
1976 if m.NrIoWait != 0 {
1977 i = encodeVarintMetrics(dAtA, i, uint64(m.NrIoWait))
1978 i--
1979 dAtA[i] = 0x28
1980 }
1981 if m.NrUninterruptible != 0 {
1982 i = encodeVarintMetrics(dAtA, i, uint64(m.NrUninterruptible))
1983 i--
1984 dAtA[i] = 0x20
1985 }
1986 if m.NrStopped != 0 {
1987 i = encodeVarintMetrics(dAtA, i, uint64(m.NrStopped))
1988 i--
1989 dAtA[i] = 0x18
1990 }
1991 if m.NrRunning != 0 {
1992 i = encodeVarintMetrics(dAtA, i, uint64(m.NrRunning))
1993 i--
1994 dAtA[i] = 0x10
1995 }
1996 if m.NrSleeping != 0 {
1997 i = encodeVarintMetrics(dAtA, i, uint64(m.NrSleeping))
1998 i--
1999 dAtA[i] = 0x8
2000 }
2001 return len(dAtA) - i, nil
2002 }
2003
2004 func encodeVarintMetrics(dAtA []byte, offset int, v uint64) int {
2005 offset -= sovMetrics(v)
2006 base := offset
2007 for v >= 1<<7 {
2008 dAtA[offset] = uint8(v&0x7f | 0x80)
2009 v >>= 7
2010 offset++
2011 }
2012 dAtA[offset] = uint8(v)
2013 return base
2014 }
2015 func (m *Metrics) Size() (n int) {
2016 if m == nil {
2017 return 0
2018 }
2019 var l int
2020 _ = l
2021 if len(m.Hugetlb) > 0 {
2022 for _, e := range m.Hugetlb {
2023 l = e.Size()
2024 n += 1 + l + sovMetrics(uint64(l))
2025 }
2026 }
2027 if m.Pids != nil {
2028 l = m.Pids.Size()
2029 n += 1 + l + sovMetrics(uint64(l))
2030 }
2031 if m.CPU != nil {
2032 l = m.CPU.Size()
2033 n += 1 + l + sovMetrics(uint64(l))
2034 }
2035 if m.Memory != nil {
2036 l = m.Memory.Size()
2037 n += 1 + l + sovMetrics(uint64(l))
2038 }
2039 if m.Blkio != nil {
2040 l = m.Blkio.Size()
2041 n += 1 + l + sovMetrics(uint64(l))
2042 }
2043 if m.Rdma != nil {
2044 l = m.Rdma.Size()
2045 n += 1 + l + sovMetrics(uint64(l))
2046 }
2047 if len(m.Network) > 0 {
2048 for _, e := range m.Network {
2049 l = e.Size()
2050 n += 1 + l + sovMetrics(uint64(l))
2051 }
2052 }
2053 if m.CgroupStats != nil {
2054 l = m.CgroupStats.Size()
2055 n += 1 + l + sovMetrics(uint64(l))
2056 }
2057 if m.MemoryOomControl != nil {
2058 l = m.MemoryOomControl.Size()
2059 n += 1 + l + sovMetrics(uint64(l))
2060 }
2061 if m.XXX_unrecognized != nil {
2062 n += len(m.XXX_unrecognized)
2063 }
2064 return n
2065 }
2066
2067 func (m *HugetlbStat) Size() (n int) {
2068 if m == nil {
2069 return 0
2070 }
2071 var l int
2072 _ = l
2073 if m.Usage != 0 {
2074 n += 1 + sovMetrics(uint64(m.Usage))
2075 }
2076 if m.Max != 0 {
2077 n += 1 + sovMetrics(uint64(m.Max))
2078 }
2079 if m.Failcnt != 0 {
2080 n += 1 + sovMetrics(uint64(m.Failcnt))
2081 }
2082 l = len(m.Pagesize)
2083 if l > 0 {
2084 n += 1 + l + sovMetrics(uint64(l))
2085 }
2086 if m.XXX_unrecognized != nil {
2087 n += len(m.XXX_unrecognized)
2088 }
2089 return n
2090 }
2091
2092 func (m *PidsStat) Size() (n int) {
2093 if m == nil {
2094 return 0
2095 }
2096 var l int
2097 _ = l
2098 if m.Current != 0 {
2099 n += 1 + sovMetrics(uint64(m.Current))
2100 }
2101 if m.Limit != 0 {
2102 n += 1 + sovMetrics(uint64(m.Limit))
2103 }
2104 if m.XXX_unrecognized != nil {
2105 n += len(m.XXX_unrecognized)
2106 }
2107 return n
2108 }
2109
2110 func (m *CPUStat) Size() (n int) {
2111 if m == nil {
2112 return 0
2113 }
2114 var l int
2115 _ = l
2116 if m.Usage != nil {
2117 l = m.Usage.Size()
2118 n += 1 + l + sovMetrics(uint64(l))
2119 }
2120 if m.Throttling != nil {
2121 l = m.Throttling.Size()
2122 n += 1 + l + sovMetrics(uint64(l))
2123 }
2124 if m.XXX_unrecognized != nil {
2125 n += len(m.XXX_unrecognized)
2126 }
2127 return n
2128 }
2129
2130 func (m *CPUUsage) Size() (n int) {
2131 if m == nil {
2132 return 0
2133 }
2134 var l int
2135 _ = l
2136 if m.Total != 0 {
2137 n += 1 + sovMetrics(uint64(m.Total))
2138 }
2139 if m.Kernel != 0 {
2140 n += 1 + sovMetrics(uint64(m.Kernel))
2141 }
2142 if m.User != 0 {
2143 n += 1 + sovMetrics(uint64(m.User))
2144 }
2145 if len(m.PerCPU) > 0 {
2146 l = 0
2147 for _, e := range m.PerCPU {
2148 l += sovMetrics(uint64(e))
2149 }
2150 n += 1 + sovMetrics(uint64(l)) + l
2151 }
2152 if m.XXX_unrecognized != nil {
2153 n += len(m.XXX_unrecognized)
2154 }
2155 return n
2156 }
2157
2158 func (m *Throttle) Size() (n int) {
2159 if m == nil {
2160 return 0
2161 }
2162 var l int
2163 _ = l
2164 if m.Periods != 0 {
2165 n += 1 + sovMetrics(uint64(m.Periods))
2166 }
2167 if m.ThrottledPeriods != 0 {
2168 n += 1 + sovMetrics(uint64(m.ThrottledPeriods))
2169 }
2170 if m.ThrottledTime != 0 {
2171 n += 1 + sovMetrics(uint64(m.ThrottledTime))
2172 }
2173 if m.XXX_unrecognized != nil {
2174 n += len(m.XXX_unrecognized)
2175 }
2176 return n
2177 }
2178
2179 func (m *MemoryStat) Size() (n int) {
2180 if m == nil {
2181 return 0
2182 }
2183 var l int
2184 _ = l
2185 if m.Cache != 0 {
2186 n += 1 + sovMetrics(uint64(m.Cache))
2187 }
2188 if m.RSS != 0 {
2189 n += 1 + sovMetrics(uint64(m.RSS))
2190 }
2191 if m.RSSHuge != 0 {
2192 n += 1 + sovMetrics(uint64(m.RSSHuge))
2193 }
2194 if m.MappedFile != 0 {
2195 n += 1 + sovMetrics(uint64(m.MappedFile))
2196 }
2197 if m.Dirty != 0 {
2198 n += 1 + sovMetrics(uint64(m.Dirty))
2199 }
2200 if m.Writeback != 0 {
2201 n += 1 + sovMetrics(uint64(m.Writeback))
2202 }
2203 if m.PgPgIn != 0 {
2204 n += 1 + sovMetrics(uint64(m.PgPgIn))
2205 }
2206 if m.PgPgOut != 0 {
2207 n += 1 + sovMetrics(uint64(m.PgPgOut))
2208 }
2209 if m.PgFault != 0 {
2210 n += 1 + sovMetrics(uint64(m.PgFault))
2211 }
2212 if m.PgMajFault != 0 {
2213 n += 1 + sovMetrics(uint64(m.PgMajFault))
2214 }
2215 if m.InactiveAnon != 0 {
2216 n += 1 + sovMetrics(uint64(m.InactiveAnon))
2217 }
2218 if m.ActiveAnon != 0 {
2219 n += 1 + sovMetrics(uint64(m.ActiveAnon))
2220 }
2221 if m.InactiveFile != 0 {
2222 n += 1 + sovMetrics(uint64(m.InactiveFile))
2223 }
2224 if m.ActiveFile != 0 {
2225 n += 1 + sovMetrics(uint64(m.ActiveFile))
2226 }
2227 if m.Unevictable != 0 {
2228 n += 1 + sovMetrics(uint64(m.Unevictable))
2229 }
2230 if m.HierarchicalMemoryLimit != 0 {
2231 n += 2 + sovMetrics(uint64(m.HierarchicalMemoryLimit))
2232 }
2233 if m.HierarchicalSwapLimit != 0 {
2234 n += 2 + sovMetrics(uint64(m.HierarchicalSwapLimit))
2235 }
2236 if m.TotalCache != 0 {
2237 n += 2 + sovMetrics(uint64(m.TotalCache))
2238 }
2239 if m.TotalRSS != 0 {
2240 n += 2 + sovMetrics(uint64(m.TotalRSS))
2241 }
2242 if m.TotalRSSHuge != 0 {
2243 n += 2 + sovMetrics(uint64(m.TotalRSSHuge))
2244 }
2245 if m.TotalMappedFile != 0 {
2246 n += 2 + sovMetrics(uint64(m.TotalMappedFile))
2247 }
2248 if m.TotalDirty != 0 {
2249 n += 2 + sovMetrics(uint64(m.TotalDirty))
2250 }
2251 if m.TotalWriteback != 0 {
2252 n += 2 + sovMetrics(uint64(m.TotalWriteback))
2253 }
2254 if m.TotalPgPgIn != 0 {
2255 n += 2 + sovMetrics(uint64(m.TotalPgPgIn))
2256 }
2257 if m.TotalPgPgOut != 0 {
2258 n += 2 + sovMetrics(uint64(m.TotalPgPgOut))
2259 }
2260 if m.TotalPgFault != 0 {
2261 n += 2 + sovMetrics(uint64(m.TotalPgFault))
2262 }
2263 if m.TotalPgMajFault != 0 {
2264 n += 2 + sovMetrics(uint64(m.TotalPgMajFault))
2265 }
2266 if m.TotalInactiveAnon != 0 {
2267 n += 2 + sovMetrics(uint64(m.TotalInactiveAnon))
2268 }
2269 if m.TotalActiveAnon != 0 {
2270 n += 2 + sovMetrics(uint64(m.TotalActiveAnon))
2271 }
2272 if m.TotalInactiveFile != 0 {
2273 n += 2 + sovMetrics(uint64(m.TotalInactiveFile))
2274 }
2275 if m.TotalActiveFile != 0 {
2276 n += 2 + sovMetrics(uint64(m.TotalActiveFile))
2277 }
2278 if m.TotalUnevictable != 0 {
2279 n += 2 + sovMetrics(uint64(m.TotalUnevictable))
2280 }
2281 if m.Usage != nil {
2282 l = m.Usage.Size()
2283 n += 2 + l + sovMetrics(uint64(l))
2284 }
2285 if m.Swap != nil {
2286 l = m.Swap.Size()
2287 n += 2 + l + sovMetrics(uint64(l))
2288 }
2289 if m.Kernel != nil {
2290 l = m.Kernel.Size()
2291 n += 2 + l + sovMetrics(uint64(l))
2292 }
2293 if m.KernelTCP != nil {
2294 l = m.KernelTCP.Size()
2295 n += 2 + l + sovMetrics(uint64(l))
2296 }
2297 if m.XXX_unrecognized != nil {
2298 n += len(m.XXX_unrecognized)
2299 }
2300 return n
2301 }
2302
2303 func (m *MemoryEntry) Size() (n int) {
2304 if m == nil {
2305 return 0
2306 }
2307 var l int
2308 _ = l
2309 if m.Limit != 0 {
2310 n += 1 + sovMetrics(uint64(m.Limit))
2311 }
2312 if m.Usage != 0 {
2313 n += 1 + sovMetrics(uint64(m.Usage))
2314 }
2315 if m.Max != 0 {
2316 n += 1 + sovMetrics(uint64(m.Max))
2317 }
2318 if m.Failcnt != 0 {
2319 n += 1 + sovMetrics(uint64(m.Failcnt))
2320 }
2321 if m.XXX_unrecognized != nil {
2322 n += len(m.XXX_unrecognized)
2323 }
2324 return n
2325 }
2326
2327 func (m *MemoryOomControl) Size() (n int) {
2328 if m == nil {
2329 return 0
2330 }
2331 var l int
2332 _ = l
2333 if m.OomKillDisable != 0 {
2334 n += 1 + sovMetrics(uint64(m.OomKillDisable))
2335 }
2336 if m.UnderOom != 0 {
2337 n += 1 + sovMetrics(uint64(m.UnderOom))
2338 }
2339 if m.OomKill != 0 {
2340 n += 1 + sovMetrics(uint64(m.OomKill))
2341 }
2342 if m.XXX_unrecognized != nil {
2343 n += len(m.XXX_unrecognized)
2344 }
2345 return n
2346 }
2347
2348 func (m *BlkIOStat) Size() (n int) {
2349 if m == nil {
2350 return 0
2351 }
2352 var l int
2353 _ = l
2354 if len(m.IoServiceBytesRecursive) > 0 {
2355 for _, e := range m.IoServiceBytesRecursive {
2356 l = e.Size()
2357 n += 1 + l + sovMetrics(uint64(l))
2358 }
2359 }
2360 if len(m.IoServicedRecursive) > 0 {
2361 for _, e := range m.IoServicedRecursive {
2362 l = e.Size()
2363 n += 1 + l + sovMetrics(uint64(l))
2364 }
2365 }
2366 if len(m.IoQueuedRecursive) > 0 {
2367 for _, e := range m.IoQueuedRecursive {
2368 l = e.Size()
2369 n += 1 + l + sovMetrics(uint64(l))
2370 }
2371 }
2372 if len(m.IoServiceTimeRecursive) > 0 {
2373 for _, e := range m.IoServiceTimeRecursive {
2374 l = e.Size()
2375 n += 1 + l + sovMetrics(uint64(l))
2376 }
2377 }
2378 if len(m.IoWaitTimeRecursive) > 0 {
2379 for _, e := range m.IoWaitTimeRecursive {
2380 l = e.Size()
2381 n += 1 + l + sovMetrics(uint64(l))
2382 }
2383 }
2384 if len(m.IoMergedRecursive) > 0 {
2385 for _, e := range m.IoMergedRecursive {
2386 l = e.Size()
2387 n += 1 + l + sovMetrics(uint64(l))
2388 }
2389 }
2390 if len(m.IoTimeRecursive) > 0 {
2391 for _, e := range m.IoTimeRecursive {
2392 l = e.Size()
2393 n += 1 + l + sovMetrics(uint64(l))
2394 }
2395 }
2396 if len(m.SectorsRecursive) > 0 {
2397 for _, e := range m.SectorsRecursive {
2398 l = e.Size()
2399 n += 1 + l + sovMetrics(uint64(l))
2400 }
2401 }
2402 if m.XXX_unrecognized != nil {
2403 n += len(m.XXX_unrecognized)
2404 }
2405 return n
2406 }
2407
2408 func (m *BlkIOEntry) Size() (n int) {
2409 if m == nil {
2410 return 0
2411 }
2412 var l int
2413 _ = l
2414 l = len(m.Op)
2415 if l > 0 {
2416 n += 1 + l + sovMetrics(uint64(l))
2417 }
2418 l = len(m.Device)
2419 if l > 0 {
2420 n += 1 + l + sovMetrics(uint64(l))
2421 }
2422 if m.Major != 0 {
2423 n += 1 + sovMetrics(uint64(m.Major))
2424 }
2425 if m.Minor != 0 {
2426 n += 1 + sovMetrics(uint64(m.Minor))
2427 }
2428 if m.Value != 0 {
2429 n += 1 + sovMetrics(uint64(m.Value))
2430 }
2431 if m.XXX_unrecognized != nil {
2432 n += len(m.XXX_unrecognized)
2433 }
2434 return n
2435 }
2436
2437 func (m *RdmaStat) Size() (n int) {
2438 if m == nil {
2439 return 0
2440 }
2441 var l int
2442 _ = l
2443 if len(m.Current) > 0 {
2444 for _, e := range m.Current {
2445 l = e.Size()
2446 n += 1 + l + sovMetrics(uint64(l))
2447 }
2448 }
2449 if len(m.Limit) > 0 {
2450 for _, e := range m.Limit {
2451 l = e.Size()
2452 n += 1 + l + sovMetrics(uint64(l))
2453 }
2454 }
2455 if m.XXX_unrecognized != nil {
2456 n += len(m.XXX_unrecognized)
2457 }
2458 return n
2459 }
2460
2461 func (m *RdmaEntry) Size() (n int) {
2462 if m == nil {
2463 return 0
2464 }
2465 var l int
2466 _ = l
2467 l = len(m.Device)
2468 if l > 0 {
2469 n += 1 + l + sovMetrics(uint64(l))
2470 }
2471 if m.HcaHandles != 0 {
2472 n += 1 + sovMetrics(uint64(m.HcaHandles))
2473 }
2474 if m.HcaObjects != 0 {
2475 n += 1 + sovMetrics(uint64(m.HcaObjects))
2476 }
2477 if m.XXX_unrecognized != nil {
2478 n += len(m.XXX_unrecognized)
2479 }
2480 return n
2481 }
2482
2483 func (m *NetworkStat) Size() (n int) {
2484 if m == nil {
2485 return 0
2486 }
2487 var l int
2488 _ = l
2489 l = len(m.Name)
2490 if l > 0 {
2491 n += 1 + l + sovMetrics(uint64(l))
2492 }
2493 if m.RxBytes != 0 {
2494 n += 1 + sovMetrics(uint64(m.RxBytes))
2495 }
2496 if m.RxPackets != 0 {
2497 n += 1 + sovMetrics(uint64(m.RxPackets))
2498 }
2499 if m.RxErrors != 0 {
2500 n += 1 + sovMetrics(uint64(m.RxErrors))
2501 }
2502 if m.RxDropped != 0 {
2503 n += 1 + sovMetrics(uint64(m.RxDropped))
2504 }
2505 if m.TxBytes != 0 {
2506 n += 1 + sovMetrics(uint64(m.TxBytes))
2507 }
2508 if m.TxPackets != 0 {
2509 n += 1 + sovMetrics(uint64(m.TxPackets))
2510 }
2511 if m.TxErrors != 0 {
2512 n += 1 + sovMetrics(uint64(m.TxErrors))
2513 }
2514 if m.TxDropped != 0 {
2515 n += 1 + sovMetrics(uint64(m.TxDropped))
2516 }
2517 if m.XXX_unrecognized != nil {
2518 n += len(m.XXX_unrecognized)
2519 }
2520 return n
2521 }
2522
2523 func (m *CgroupStats) Size() (n int) {
2524 if m == nil {
2525 return 0
2526 }
2527 var l int
2528 _ = l
2529 if m.NrSleeping != 0 {
2530 n += 1 + sovMetrics(uint64(m.NrSleeping))
2531 }
2532 if m.NrRunning != 0 {
2533 n += 1 + sovMetrics(uint64(m.NrRunning))
2534 }
2535 if m.NrStopped != 0 {
2536 n += 1 + sovMetrics(uint64(m.NrStopped))
2537 }
2538 if m.NrUninterruptible != 0 {
2539 n += 1 + sovMetrics(uint64(m.NrUninterruptible))
2540 }
2541 if m.NrIoWait != 0 {
2542 n += 1 + sovMetrics(uint64(m.NrIoWait))
2543 }
2544 if m.XXX_unrecognized != nil {
2545 n += len(m.XXX_unrecognized)
2546 }
2547 return n
2548 }
2549
2550 func sovMetrics(x uint64) (n int) {
2551 return (math_bits.Len64(x|1) + 6) / 7
2552 }
2553 func sozMetrics(x uint64) (n int) {
2554 return sovMetrics(uint64((x << 1) ^ uint64((int64(x) >> 63))))
2555 }
2556 func (this *Metrics) String() string {
2557 if this == nil {
2558 return "nil"
2559 }
2560 repeatedStringForHugetlb := "[]*HugetlbStat{"
2561 for _, f := range this.Hugetlb {
2562 repeatedStringForHugetlb += strings.Replace(f.String(), "HugetlbStat", "HugetlbStat", 1) + ","
2563 }
2564 repeatedStringForHugetlb += "}"
2565 repeatedStringForNetwork := "[]*NetworkStat{"
2566 for _, f := range this.Network {
2567 repeatedStringForNetwork += strings.Replace(f.String(), "NetworkStat", "NetworkStat", 1) + ","
2568 }
2569 repeatedStringForNetwork += "}"
2570 s := strings.Join([]string{`&Metrics{`,
2571 `Hugetlb:` + repeatedStringForHugetlb + `,`,
2572 `Pids:` + strings.Replace(this.Pids.String(), "PidsStat", "PidsStat", 1) + `,`,
2573 `CPU:` + strings.Replace(this.CPU.String(), "CPUStat", "CPUStat", 1) + `,`,
2574 `Memory:` + strings.Replace(this.Memory.String(), "MemoryStat", "MemoryStat", 1) + `,`,
2575 `Blkio:` + strings.Replace(this.Blkio.String(), "BlkIOStat", "BlkIOStat", 1) + `,`,
2576 `Rdma:` + strings.Replace(this.Rdma.String(), "RdmaStat", "RdmaStat", 1) + `,`,
2577 `Network:` + repeatedStringForNetwork + `,`,
2578 `CgroupStats:` + strings.Replace(this.CgroupStats.String(), "CgroupStats", "CgroupStats", 1) + `,`,
2579 `MemoryOomControl:` + strings.Replace(this.MemoryOomControl.String(), "MemoryOomControl", "MemoryOomControl", 1) + `,`,
2580 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2581 `}`,
2582 }, "")
2583 return s
2584 }
2585 func (this *HugetlbStat) String() string {
2586 if this == nil {
2587 return "nil"
2588 }
2589 s := strings.Join([]string{`&HugetlbStat{`,
2590 `Usage:` + fmt.Sprintf("%v", this.Usage) + `,`,
2591 `Max:` + fmt.Sprintf("%v", this.Max) + `,`,
2592 `Failcnt:` + fmt.Sprintf("%v", this.Failcnt) + `,`,
2593 `Pagesize:` + fmt.Sprintf("%v", this.Pagesize) + `,`,
2594 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2595 `}`,
2596 }, "")
2597 return s
2598 }
2599 func (this *PidsStat) String() string {
2600 if this == nil {
2601 return "nil"
2602 }
2603 s := strings.Join([]string{`&PidsStat{`,
2604 `Current:` + fmt.Sprintf("%v", this.Current) + `,`,
2605 `Limit:` + fmt.Sprintf("%v", this.Limit) + `,`,
2606 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2607 `}`,
2608 }, "")
2609 return s
2610 }
2611 func (this *CPUStat) String() string {
2612 if this == nil {
2613 return "nil"
2614 }
2615 s := strings.Join([]string{`&CPUStat{`,
2616 `Usage:` + strings.Replace(this.Usage.String(), "CPUUsage", "CPUUsage", 1) + `,`,
2617 `Throttling:` + strings.Replace(this.Throttling.String(), "Throttle", "Throttle", 1) + `,`,
2618 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2619 `}`,
2620 }, "")
2621 return s
2622 }
2623 func (this *CPUUsage) String() string {
2624 if this == nil {
2625 return "nil"
2626 }
2627 s := strings.Join([]string{`&CPUUsage{`,
2628 `Total:` + fmt.Sprintf("%v", this.Total) + `,`,
2629 `Kernel:` + fmt.Sprintf("%v", this.Kernel) + `,`,
2630 `User:` + fmt.Sprintf("%v", this.User) + `,`,
2631 `PerCPU:` + fmt.Sprintf("%v", this.PerCPU) + `,`,
2632 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2633 `}`,
2634 }, "")
2635 return s
2636 }
2637 func (this *Throttle) String() string {
2638 if this == nil {
2639 return "nil"
2640 }
2641 s := strings.Join([]string{`&Throttle{`,
2642 `Periods:` + fmt.Sprintf("%v", this.Periods) + `,`,
2643 `ThrottledPeriods:` + fmt.Sprintf("%v", this.ThrottledPeriods) + `,`,
2644 `ThrottledTime:` + fmt.Sprintf("%v", this.ThrottledTime) + `,`,
2645 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2646 `}`,
2647 }, "")
2648 return s
2649 }
2650 func (this *MemoryStat) String() string {
2651 if this == nil {
2652 return "nil"
2653 }
2654 s := strings.Join([]string{`&MemoryStat{`,
2655 `Cache:` + fmt.Sprintf("%v", this.Cache) + `,`,
2656 `RSS:` + fmt.Sprintf("%v", this.RSS) + `,`,
2657 `RSSHuge:` + fmt.Sprintf("%v", this.RSSHuge) + `,`,
2658 `MappedFile:` + fmt.Sprintf("%v", this.MappedFile) + `,`,
2659 `Dirty:` + fmt.Sprintf("%v", this.Dirty) + `,`,
2660 `Writeback:` + fmt.Sprintf("%v", this.Writeback) + `,`,
2661 `PgPgIn:` + fmt.Sprintf("%v", this.PgPgIn) + `,`,
2662 `PgPgOut:` + fmt.Sprintf("%v", this.PgPgOut) + `,`,
2663 `PgFault:` + fmt.Sprintf("%v", this.PgFault) + `,`,
2664 `PgMajFault:` + fmt.Sprintf("%v", this.PgMajFault) + `,`,
2665 `InactiveAnon:` + fmt.Sprintf("%v", this.InactiveAnon) + `,`,
2666 `ActiveAnon:` + fmt.Sprintf("%v", this.ActiveAnon) + `,`,
2667 `InactiveFile:` + fmt.Sprintf("%v", this.InactiveFile) + `,`,
2668 `ActiveFile:` + fmt.Sprintf("%v", this.ActiveFile) + `,`,
2669 `Unevictable:` + fmt.Sprintf("%v", this.Unevictable) + `,`,
2670 `HierarchicalMemoryLimit:` + fmt.Sprintf("%v", this.HierarchicalMemoryLimit) + `,`,
2671 `HierarchicalSwapLimit:` + fmt.Sprintf("%v", this.HierarchicalSwapLimit) + `,`,
2672 `TotalCache:` + fmt.Sprintf("%v", this.TotalCache) + `,`,
2673 `TotalRSS:` + fmt.Sprintf("%v", this.TotalRSS) + `,`,
2674 `TotalRSSHuge:` + fmt.Sprintf("%v", this.TotalRSSHuge) + `,`,
2675 `TotalMappedFile:` + fmt.Sprintf("%v", this.TotalMappedFile) + `,`,
2676 `TotalDirty:` + fmt.Sprintf("%v", this.TotalDirty) + `,`,
2677 `TotalWriteback:` + fmt.Sprintf("%v", this.TotalWriteback) + `,`,
2678 `TotalPgPgIn:` + fmt.Sprintf("%v", this.TotalPgPgIn) + `,`,
2679 `TotalPgPgOut:` + fmt.Sprintf("%v", this.TotalPgPgOut) + `,`,
2680 `TotalPgFault:` + fmt.Sprintf("%v", this.TotalPgFault) + `,`,
2681 `TotalPgMajFault:` + fmt.Sprintf("%v", this.TotalPgMajFault) + `,`,
2682 `TotalInactiveAnon:` + fmt.Sprintf("%v", this.TotalInactiveAnon) + `,`,
2683 `TotalActiveAnon:` + fmt.Sprintf("%v", this.TotalActiveAnon) + `,`,
2684 `TotalInactiveFile:` + fmt.Sprintf("%v", this.TotalInactiveFile) + `,`,
2685 `TotalActiveFile:` + fmt.Sprintf("%v", this.TotalActiveFile) + `,`,
2686 `TotalUnevictable:` + fmt.Sprintf("%v", this.TotalUnevictable) + `,`,
2687 `Usage:` + strings.Replace(this.Usage.String(), "MemoryEntry", "MemoryEntry", 1) + `,`,
2688 `Swap:` + strings.Replace(this.Swap.String(), "MemoryEntry", "MemoryEntry", 1) + `,`,
2689 `Kernel:` + strings.Replace(this.Kernel.String(), "MemoryEntry", "MemoryEntry", 1) + `,`,
2690 `KernelTCP:` + strings.Replace(this.KernelTCP.String(), "MemoryEntry", "MemoryEntry", 1) + `,`,
2691 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2692 `}`,
2693 }, "")
2694 return s
2695 }
2696 func (this *MemoryEntry) String() string {
2697 if this == nil {
2698 return "nil"
2699 }
2700 s := strings.Join([]string{`&MemoryEntry{`,
2701 `Limit:` + fmt.Sprintf("%v", this.Limit) + `,`,
2702 `Usage:` + fmt.Sprintf("%v", this.Usage) + `,`,
2703 `Max:` + fmt.Sprintf("%v", this.Max) + `,`,
2704 `Failcnt:` + fmt.Sprintf("%v", this.Failcnt) + `,`,
2705 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2706 `}`,
2707 }, "")
2708 return s
2709 }
2710 func (this *MemoryOomControl) String() string {
2711 if this == nil {
2712 return "nil"
2713 }
2714 s := strings.Join([]string{`&MemoryOomControl{`,
2715 `OomKillDisable:` + fmt.Sprintf("%v", this.OomKillDisable) + `,`,
2716 `UnderOom:` + fmt.Sprintf("%v", this.UnderOom) + `,`,
2717 `OomKill:` + fmt.Sprintf("%v", this.OomKill) + `,`,
2718 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2719 `}`,
2720 }, "")
2721 return s
2722 }
2723 func (this *BlkIOStat) String() string {
2724 if this == nil {
2725 return "nil"
2726 }
2727 repeatedStringForIoServiceBytesRecursive := "[]*BlkIOEntry{"
2728 for _, f := range this.IoServiceBytesRecursive {
2729 repeatedStringForIoServiceBytesRecursive += strings.Replace(f.String(), "BlkIOEntry", "BlkIOEntry", 1) + ","
2730 }
2731 repeatedStringForIoServiceBytesRecursive += "}"
2732 repeatedStringForIoServicedRecursive := "[]*BlkIOEntry{"
2733 for _, f := range this.IoServicedRecursive {
2734 repeatedStringForIoServicedRecursive += strings.Replace(f.String(), "BlkIOEntry", "BlkIOEntry", 1) + ","
2735 }
2736 repeatedStringForIoServicedRecursive += "}"
2737 repeatedStringForIoQueuedRecursive := "[]*BlkIOEntry{"
2738 for _, f := range this.IoQueuedRecursive {
2739 repeatedStringForIoQueuedRecursive += strings.Replace(f.String(), "BlkIOEntry", "BlkIOEntry", 1) + ","
2740 }
2741 repeatedStringForIoQueuedRecursive += "}"
2742 repeatedStringForIoServiceTimeRecursive := "[]*BlkIOEntry{"
2743 for _, f := range this.IoServiceTimeRecursive {
2744 repeatedStringForIoServiceTimeRecursive += strings.Replace(f.String(), "BlkIOEntry", "BlkIOEntry", 1) + ","
2745 }
2746 repeatedStringForIoServiceTimeRecursive += "}"
2747 repeatedStringForIoWaitTimeRecursive := "[]*BlkIOEntry{"
2748 for _, f := range this.IoWaitTimeRecursive {
2749 repeatedStringForIoWaitTimeRecursive += strings.Replace(f.String(), "BlkIOEntry", "BlkIOEntry", 1) + ","
2750 }
2751 repeatedStringForIoWaitTimeRecursive += "}"
2752 repeatedStringForIoMergedRecursive := "[]*BlkIOEntry{"
2753 for _, f := range this.IoMergedRecursive {
2754 repeatedStringForIoMergedRecursive += strings.Replace(f.String(), "BlkIOEntry", "BlkIOEntry", 1) + ","
2755 }
2756 repeatedStringForIoMergedRecursive += "}"
2757 repeatedStringForIoTimeRecursive := "[]*BlkIOEntry{"
2758 for _, f := range this.IoTimeRecursive {
2759 repeatedStringForIoTimeRecursive += strings.Replace(f.String(), "BlkIOEntry", "BlkIOEntry", 1) + ","
2760 }
2761 repeatedStringForIoTimeRecursive += "}"
2762 repeatedStringForSectorsRecursive := "[]*BlkIOEntry{"
2763 for _, f := range this.SectorsRecursive {
2764 repeatedStringForSectorsRecursive += strings.Replace(f.String(), "BlkIOEntry", "BlkIOEntry", 1) + ","
2765 }
2766 repeatedStringForSectorsRecursive += "}"
2767 s := strings.Join([]string{`&BlkIOStat{`,
2768 `IoServiceBytesRecursive:` + repeatedStringForIoServiceBytesRecursive + `,`,
2769 `IoServicedRecursive:` + repeatedStringForIoServicedRecursive + `,`,
2770 `IoQueuedRecursive:` + repeatedStringForIoQueuedRecursive + `,`,
2771 `IoServiceTimeRecursive:` + repeatedStringForIoServiceTimeRecursive + `,`,
2772 `IoWaitTimeRecursive:` + repeatedStringForIoWaitTimeRecursive + `,`,
2773 `IoMergedRecursive:` + repeatedStringForIoMergedRecursive + `,`,
2774 `IoTimeRecursive:` + repeatedStringForIoTimeRecursive + `,`,
2775 `SectorsRecursive:` + repeatedStringForSectorsRecursive + `,`,
2776 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2777 `}`,
2778 }, "")
2779 return s
2780 }
2781 func (this *BlkIOEntry) String() string {
2782 if this == nil {
2783 return "nil"
2784 }
2785 s := strings.Join([]string{`&BlkIOEntry{`,
2786 `Op:` + fmt.Sprintf("%v", this.Op) + `,`,
2787 `Device:` + fmt.Sprintf("%v", this.Device) + `,`,
2788 `Major:` + fmt.Sprintf("%v", this.Major) + `,`,
2789 `Minor:` + fmt.Sprintf("%v", this.Minor) + `,`,
2790 `Value:` + fmt.Sprintf("%v", this.Value) + `,`,
2791 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2792 `}`,
2793 }, "")
2794 return s
2795 }
2796 func (this *RdmaStat) String() string {
2797 if this == nil {
2798 return "nil"
2799 }
2800 repeatedStringForCurrent := "[]*RdmaEntry{"
2801 for _, f := range this.Current {
2802 repeatedStringForCurrent += strings.Replace(f.String(), "RdmaEntry", "RdmaEntry", 1) + ","
2803 }
2804 repeatedStringForCurrent += "}"
2805 repeatedStringForLimit := "[]*RdmaEntry{"
2806 for _, f := range this.Limit {
2807 repeatedStringForLimit += strings.Replace(f.String(), "RdmaEntry", "RdmaEntry", 1) + ","
2808 }
2809 repeatedStringForLimit += "}"
2810 s := strings.Join([]string{`&RdmaStat{`,
2811 `Current:` + repeatedStringForCurrent + `,`,
2812 `Limit:` + repeatedStringForLimit + `,`,
2813 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2814 `}`,
2815 }, "")
2816 return s
2817 }
2818 func (this *RdmaEntry) String() string {
2819 if this == nil {
2820 return "nil"
2821 }
2822 s := strings.Join([]string{`&RdmaEntry{`,
2823 `Device:` + fmt.Sprintf("%v", this.Device) + `,`,
2824 `HcaHandles:` + fmt.Sprintf("%v", this.HcaHandles) + `,`,
2825 `HcaObjects:` + fmt.Sprintf("%v", this.HcaObjects) + `,`,
2826 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2827 `}`,
2828 }, "")
2829 return s
2830 }
2831 func (this *NetworkStat) String() string {
2832 if this == nil {
2833 return "nil"
2834 }
2835 s := strings.Join([]string{`&NetworkStat{`,
2836 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2837 `RxBytes:` + fmt.Sprintf("%v", this.RxBytes) + `,`,
2838 `RxPackets:` + fmt.Sprintf("%v", this.RxPackets) + `,`,
2839 `RxErrors:` + fmt.Sprintf("%v", this.RxErrors) + `,`,
2840 `RxDropped:` + fmt.Sprintf("%v", this.RxDropped) + `,`,
2841 `TxBytes:` + fmt.Sprintf("%v", this.TxBytes) + `,`,
2842 `TxPackets:` + fmt.Sprintf("%v", this.TxPackets) + `,`,
2843 `TxErrors:` + fmt.Sprintf("%v", this.TxErrors) + `,`,
2844 `TxDropped:` + fmt.Sprintf("%v", this.TxDropped) + `,`,
2845 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2846 `}`,
2847 }, "")
2848 return s
2849 }
2850 func (this *CgroupStats) String() string {
2851 if this == nil {
2852 return "nil"
2853 }
2854 s := strings.Join([]string{`&CgroupStats{`,
2855 `NrSleeping:` + fmt.Sprintf("%v", this.NrSleeping) + `,`,
2856 `NrRunning:` + fmt.Sprintf("%v", this.NrRunning) + `,`,
2857 `NrStopped:` + fmt.Sprintf("%v", this.NrStopped) + `,`,
2858 `NrUninterruptible:` + fmt.Sprintf("%v", this.NrUninterruptible) + `,`,
2859 `NrIoWait:` + fmt.Sprintf("%v", this.NrIoWait) + `,`,
2860 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
2861 `}`,
2862 }, "")
2863 return s
2864 }
2865 func valueToStringMetrics(v interface{}) string {
2866 rv := reflect.ValueOf(v)
2867 if rv.IsNil() {
2868 return "nil"
2869 }
2870 pv := reflect.Indirect(rv).Interface()
2871 return fmt.Sprintf("*%v", pv)
2872 }
2873 func (m *Metrics) Unmarshal(dAtA []byte) error {
2874 l := len(dAtA)
2875 iNdEx := 0
2876 for iNdEx < l {
2877 preIndex := iNdEx
2878 var wire uint64
2879 for shift := uint(0); ; shift += 7 {
2880 if shift >= 64 {
2881 return ErrIntOverflowMetrics
2882 }
2883 if iNdEx >= l {
2884 return io.ErrUnexpectedEOF
2885 }
2886 b := dAtA[iNdEx]
2887 iNdEx++
2888 wire |= uint64(b&0x7F) << shift
2889 if b < 0x80 {
2890 break
2891 }
2892 }
2893 fieldNum := int32(wire >> 3)
2894 wireType := int(wire & 0x7)
2895 if wireType == 4 {
2896 return fmt.Errorf("proto: Metrics: wiretype end group for non-group")
2897 }
2898 if fieldNum <= 0 {
2899 return fmt.Errorf("proto: Metrics: illegal tag %d (wire type %d)", fieldNum, wire)
2900 }
2901 switch fieldNum {
2902 case 1:
2903 if wireType != 2 {
2904 return fmt.Errorf("proto: wrong wireType = %d for field Hugetlb", wireType)
2905 }
2906 var msglen int
2907 for shift := uint(0); ; shift += 7 {
2908 if shift >= 64 {
2909 return ErrIntOverflowMetrics
2910 }
2911 if iNdEx >= l {
2912 return io.ErrUnexpectedEOF
2913 }
2914 b := dAtA[iNdEx]
2915 iNdEx++
2916 msglen |= int(b&0x7F) << shift
2917 if b < 0x80 {
2918 break
2919 }
2920 }
2921 if msglen < 0 {
2922 return ErrInvalidLengthMetrics
2923 }
2924 postIndex := iNdEx + msglen
2925 if postIndex < 0 {
2926 return ErrInvalidLengthMetrics
2927 }
2928 if postIndex > l {
2929 return io.ErrUnexpectedEOF
2930 }
2931 m.Hugetlb = append(m.Hugetlb, &HugetlbStat{})
2932 if err := m.Hugetlb[len(m.Hugetlb)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2933 return err
2934 }
2935 iNdEx = postIndex
2936 case 2:
2937 if wireType != 2 {
2938 return fmt.Errorf("proto: wrong wireType = %d for field Pids", wireType)
2939 }
2940 var msglen int
2941 for shift := uint(0); ; shift += 7 {
2942 if shift >= 64 {
2943 return ErrIntOverflowMetrics
2944 }
2945 if iNdEx >= l {
2946 return io.ErrUnexpectedEOF
2947 }
2948 b := dAtA[iNdEx]
2949 iNdEx++
2950 msglen |= int(b&0x7F) << shift
2951 if b < 0x80 {
2952 break
2953 }
2954 }
2955 if msglen < 0 {
2956 return ErrInvalidLengthMetrics
2957 }
2958 postIndex := iNdEx + msglen
2959 if postIndex < 0 {
2960 return ErrInvalidLengthMetrics
2961 }
2962 if postIndex > l {
2963 return io.ErrUnexpectedEOF
2964 }
2965 if m.Pids == nil {
2966 m.Pids = &PidsStat{}
2967 }
2968 if err := m.Pids.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2969 return err
2970 }
2971 iNdEx = postIndex
2972 case 3:
2973 if wireType != 2 {
2974 return fmt.Errorf("proto: wrong wireType = %d for field CPU", wireType)
2975 }
2976 var msglen int
2977 for shift := uint(0); ; shift += 7 {
2978 if shift >= 64 {
2979 return ErrIntOverflowMetrics
2980 }
2981 if iNdEx >= l {
2982 return io.ErrUnexpectedEOF
2983 }
2984 b := dAtA[iNdEx]
2985 iNdEx++
2986 msglen |= int(b&0x7F) << shift
2987 if b < 0x80 {
2988 break
2989 }
2990 }
2991 if msglen < 0 {
2992 return ErrInvalidLengthMetrics
2993 }
2994 postIndex := iNdEx + msglen
2995 if postIndex < 0 {
2996 return ErrInvalidLengthMetrics
2997 }
2998 if postIndex > l {
2999 return io.ErrUnexpectedEOF
3000 }
3001 if m.CPU == nil {
3002 m.CPU = &CPUStat{}
3003 }
3004 if err := m.CPU.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3005 return err
3006 }
3007 iNdEx = postIndex
3008 case 4:
3009 if wireType != 2 {
3010 return fmt.Errorf("proto: wrong wireType = %d for field Memory", wireType)
3011 }
3012 var msglen int
3013 for shift := uint(0); ; shift += 7 {
3014 if shift >= 64 {
3015 return ErrIntOverflowMetrics
3016 }
3017 if iNdEx >= l {
3018 return io.ErrUnexpectedEOF
3019 }
3020 b := dAtA[iNdEx]
3021 iNdEx++
3022 msglen |= int(b&0x7F) << shift
3023 if b < 0x80 {
3024 break
3025 }
3026 }
3027 if msglen < 0 {
3028 return ErrInvalidLengthMetrics
3029 }
3030 postIndex := iNdEx + msglen
3031 if postIndex < 0 {
3032 return ErrInvalidLengthMetrics
3033 }
3034 if postIndex > l {
3035 return io.ErrUnexpectedEOF
3036 }
3037 if m.Memory == nil {
3038 m.Memory = &MemoryStat{}
3039 }
3040 if err := m.Memory.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3041 return err
3042 }
3043 iNdEx = postIndex
3044 case 5:
3045 if wireType != 2 {
3046 return fmt.Errorf("proto: wrong wireType = %d for field Blkio", wireType)
3047 }
3048 var msglen int
3049 for shift := uint(0); ; shift += 7 {
3050 if shift >= 64 {
3051 return ErrIntOverflowMetrics
3052 }
3053 if iNdEx >= l {
3054 return io.ErrUnexpectedEOF
3055 }
3056 b := dAtA[iNdEx]
3057 iNdEx++
3058 msglen |= int(b&0x7F) << shift
3059 if b < 0x80 {
3060 break
3061 }
3062 }
3063 if msglen < 0 {
3064 return ErrInvalidLengthMetrics
3065 }
3066 postIndex := iNdEx + msglen
3067 if postIndex < 0 {
3068 return ErrInvalidLengthMetrics
3069 }
3070 if postIndex > l {
3071 return io.ErrUnexpectedEOF
3072 }
3073 if m.Blkio == nil {
3074 m.Blkio = &BlkIOStat{}
3075 }
3076 if err := m.Blkio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3077 return err
3078 }
3079 iNdEx = postIndex
3080 case 6:
3081 if wireType != 2 {
3082 return fmt.Errorf("proto: wrong wireType = %d for field Rdma", wireType)
3083 }
3084 var msglen int
3085 for shift := uint(0); ; shift += 7 {
3086 if shift >= 64 {
3087 return ErrIntOverflowMetrics
3088 }
3089 if iNdEx >= l {
3090 return io.ErrUnexpectedEOF
3091 }
3092 b := dAtA[iNdEx]
3093 iNdEx++
3094 msglen |= int(b&0x7F) << shift
3095 if b < 0x80 {
3096 break
3097 }
3098 }
3099 if msglen < 0 {
3100 return ErrInvalidLengthMetrics
3101 }
3102 postIndex := iNdEx + msglen
3103 if postIndex < 0 {
3104 return ErrInvalidLengthMetrics
3105 }
3106 if postIndex > l {
3107 return io.ErrUnexpectedEOF
3108 }
3109 if m.Rdma == nil {
3110 m.Rdma = &RdmaStat{}
3111 }
3112 if err := m.Rdma.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3113 return err
3114 }
3115 iNdEx = postIndex
3116 case 7:
3117 if wireType != 2 {
3118 return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType)
3119 }
3120 var msglen int
3121 for shift := uint(0); ; shift += 7 {
3122 if shift >= 64 {
3123 return ErrIntOverflowMetrics
3124 }
3125 if iNdEx >= l {
3126 return io.ErrUnexpectedEOF
3127 }
3128 b := dAtA[iNdEx]
3129 iNdEx++
3130 msglen |= int(b&0x7F) << shift
3131 if b < 0x80 {
3132 break
3133 }
3134 }
3135 if msglen < 0 {
3136 return ErrInvalidLengthMetrics
3137 }
3138 postIndex := iNdEx + msglen
3139 if postIndex < 0 {
3140 return ErrInvalidLengthMetrics
3141 }
3142 if postIndex > l {
3143 return io.ErrUnexpectedEOF
3144 }
3145 m.Network = append(m.Network, &NetworkStat{})
3146 if err := m.Network[len(m.Network)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3147 return err
3148 }
3149 iNdEx = postIndex
3150 case 8:
3151 if wireType != 2 {
3152 return fmt.Errorf("proto: wrong wireType = %d for field CgroupStats", wireType)
3153 }
3154 var msglen int
3155 for shift := uint(0); ; shift += 7 {
3156 if shift >= 64 {
3157 return ErrIntOverflowMetrics
3158 }
3159 if iNdEx >= l {
3160 return io.ErrUnexpectedEOF
3161 }
3162 b := dAtA[iNdEx]
3163 iNdEx++
3164 msglen |= int(b&0x7F) << shift
3165 if b < 0x80 {
3166 break
3167 }
3168 }
3169 if msglen < 0 {
3170 return ErrInvalidLengthMetrics
3171 }
3172 postIndex := iNdEx + msglen
3173 if postIndex < 0 {
3174 return ErrInvalidLengthMetrics
3175 }
3176 if postIndex > l {
3177 return io.ErrUnexpectedEOF
3178 }
3179 if m.CgroupStats == nil {
3180 m.CgroupStats = &CgroupStats{}
3181 }
3182 if err := m.CgroupStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3183 return err
3184 }
3185 iNdEx = postIndex
3186 case 9:
3187 if wireType != 2 {
3188 return fmt.Errorf("proto: wrong wireType = %d for field MemoryOomControl", wireType)
3189 }
3190 var msglen int
3191 for shift := uint(0); ; shift += 7 {
3192 if shift >= 64 {
3193 return ErrIntOverflowMetrics
3194 }
3195 if iNdEx >= l {
3196 return io.ErrUnexpectedEOF
3197 }
3198 b := dAtA[iNdEx]
3199 iNdEx++
3200 msglen |= int(b&0x7F) << shift
3201 if b < 0x80 {
3202 break
3203 }
3204 }
3205 if msglen < 0 {
3206 return ErrInvalidLengthMetrics
3207 }
3208 postIndex := iNdEx + msglen
3209 if postIndex < 0 {
3210 return ErrInvalidLengthMetrics
3211 }
3212 if postIndex > l {
3213 return io.ErrUnexpectedEOF
3214 }
3215 if m.MemoryOomControl == nil {
3216 m.MemoryOomControl = &MemoryOomControl{}
3217 }
3218 if err := m.MemoryOomControl.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3219 return err
3220 }
3221 iNdEx = postIndex
3222 default:
3223 iNdEx = preIndex
3224 skippy, err := skipMetrics(dAtA[iNdEx:])
3225 if err != nil {
3226 return err
3227 }
3228 if (skippy < 0) || (iNdEx+skippy) < 0 {
3229 return ErrInvalidLengthMetrics
3230 }
3231 if (iNdEx + skippy) > l {
3232 return io.ErrUnexpectedEOF
3233 }
3234 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
3235 iNdEx += skippy
3236 }
3237 }
3238
3239 if iNdEx > l {
3240 return io.ErrUnexpectedEOF
3241 }
3242 return nil
3243 }
3244 func (m *HugetlbStat) Unmarshal(dAtA []byte) error {
3245 l := len(dAtA)
3246 iNdEx := 0
3247 for iNdEx < l {
3248 preIndex := iNdEx
3249 var wire uint64
3250 for shift := uint(0); ; shift += 7 {
3251 if shift >= 64 {
3252 return ErrIntOverflowMetrics
3253 }
3254 if iNdEx >= l {
3255 return io.ErrUnexpectedEOF
3256 }
3257 b := dAtA[iNdEx]
3258 iNdEx++
3259 wire |= uint64(b&0x7F) << shift
3260 if b < 0x80 {
3261 break
3262 }
3263 }
3264 fieldNum := int32(wire >> 3)
3265 wireType := int(wire & 0x7)
3266 if wireType == 4 {
3267 return fmt.Errorf("proto: HugetlbStat: wiretype end group for non-group")
3268 }
3269 if fieldNum <= 0 {
3270 return fmt.Errorf("proto: HugetlbStat: illegal tag %d (wire type %d)", fieldNum, wire)
3271 }
3272 switch fieldNum {
3273 case 1:
3274 if wireType != 0 {
3275 return fmt.Errorf("proto: wrong wireType = %d for field Usage", wireType)
3276 }
3277 m.Usage = 0
3278 for shift := uint(0); ; shift += 7 {
3279 if shift >= 64 {
3280 return ErrIntOverflowMetrics
3281 }
3282 if iNdEx >= l {
3283 return io.ErrUnexpectedEOF
3284 }
3285 b := dAtA[iNdEx]
3286 iNdEx++
3287 m.Usage |= uint64(b&0x7F) << shift
3288 if b < 0x80 {
3289 break
3290 }
3291 }
3292 case 2:
3293 if wireType != 0 {
3294 return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType)
3295 }
3296 m.Max = 0
3297 for shift := uint(0); ; shift += 7 {
3298 if shift >= 64 {
3299 return ErrIntOverflowMetrics
3300 }
3301 if iNdEx >= l {
3302 return io.ErrUnexpectedEOF
3303 }
3304 b := dAtA[iNdEx]
3305 iNdEx++
3306 m.Max |= uint64(b&0x7F) << shift
3307 if b < 0x80 {
3308 break
3309 }
3310 }
3311 case 3:
3312 if wireType != 0 {
3313 return fmt.Errorf("proto: wrong wireType = %d for field Failcnt", wireType)
3314 }
3315 m.Failcnt = 0
3316 for shift := uint(0); ; shift += 7 {
3317 if shift >= 64 {
3318 return ErrIntOverflowMetrics
3319 }
3320 if iNdEx >= l {
3321 return io.ErrUnexpectedEOF
3322 }
3323 b := dAtA[iNdEx]
3324 iNdEx++
3325 m.Failcnt |= uint64(b&0x7F) << shift
3326 if b < 0x80 {
3327 break
3328 }
3329 }
3330 case 4:
3331 if wireType != 2 {
3332 return fmt.Errorf("proto: wrong wireType = %d for field Pagesize", wireType)
3333 }
3334 var stringLen uint64
3335 for shift := uint(0); ; shift += 7 {
3336 if shift >= 64 {
3337 return ErrIntOverflowMetrics
3338 }
3339 if iNdEx >= l {
3340 return io.ErrUnexpectedEOF
3341 }
3342 b := dAtA[iNdEx]
3343 iNdEx++
3344 stringLen |= uint64(b&0x7F) << shift
3345 if b < 0x80 {
3346 break
3347 }
3348 }
3349 intStringLen := int(stringLen)
3350 if intStringLen < 0 {
3351 return ErrInvalidLengthMetrics
3352 }
3353 postIndex := iNdEx + intStringLen
3354 if postIndex < 0 {
3355 return ErrInvalidLengthMetrics
3356 }
3357 if postIndex > l {
3358 return io.ErrUnexpectedEOF
3359 }
3360 m.Pagesize = string(dAtA[iNdEx:postIndex])
3361 iNdEx = postIndex
3362 default:
3363 iNdEx = preIndex
3364 skippy, err := skipMetrics(dAtA[iNdEx:])
3365 if err != nil {
3366 return err
3367 }
3368 if (skippy < 0) || (iNdEx+skippy) < 0 {
3369 return ErrInvalidLengthMetrics
3370 }
3371 if (iNdEx + skippy) > l {
3372 return io.ErrUnexpectedEOF
3373 }
3374 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
3375 iNdEx += skippy
3376 }
3377 }
3378
3379 if iNdEx > l {
3380 return io.ErrUnexpectedEOF
3381 }
3382 return nil
3383 }
3384 func (m *PidsStat) Unmarshal(dAtA []byte) error {
3385 l := len(dAtA)
3386 iNdEx := 0
3387 for iNdEx < l {
3388 preIndex := iNdEx
3389 var wire uint64
3390 for shift := uint(0); ; shift += 7 {
3391 if shift >= 64 {
3392 return ErrIntOverflowMetrics
3393 }
3394 if iNdEx >= l {
3395 return io.ErrUnexpectedEOF
3396 }
3397 b := dAtA[iNdEx]
3398 iNdEx++
3399 wire |= uint64(b&0x7F) << shift
3400 if b < 0x80 {
3401 break
3402 }
3403 }
3404 fieldNum := int32(wire >> 3)
3405 wireType := int(wire & 0x7)
3406 if wireType == 4 {
3407 return fmt.Errorf("proto: PidsStat: wiretype end group for non-group")
3408 }
3409 if fieldNum <= 0 {
3410 return fmt.Errorf("proto: PidsStat: illegal tag %d (wire type %d)", fieldNum, wire)
3411 }
3412 switch fieldNum {
3413 case 1:
3414 if wireType != 0 {
3415 return fmt.Errorf("proto: wrong wireType = %d for field Current", wireType)
3416 }
3417 m.Current = 0
3418 for shift := uint(0); ; shift += 7 {
3419 if shift >= 64 {
3420 return ErrIntOverflowMetrics
3421 }
3422 if iNdEx >= l {
3423 return io.ErrUnexpectedEOF
3424 }
3425 b := dAtA[iNdEx]
3426 iNdEx++
3427 m.Current |= uint64(b&0x7F) << shift
3428 if b < 0x80 {
3429 break
3430 }
3431 }
3432 case 2:
3433 if wireType != 0 {
3434 return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
3435 }
3436 m.Limit = 0
3437 for shift := uint(0); ; shift += 7 {
3438 if shift >= 64 {
3439 return ErrIntOverflowMetrics
3440 }
3441 if iNdEx >= l {
3442 return io.ErrUnexpectedEOF
3443 }
3444 b := dAtA[iNdEx]
3445 iNdEx++
3446 m.Limit |= uint64(b&0x7F) << shift
3447 if b < 0x80 {
3448 break
3449 }
3450 }
3451 default:
3452 iNdEx = preIndex
3453 skippy, err := skipMetrics(dAtA[iNdEx:])
3454 if err != nil {
3455 return err
3456 }
3457 if (skippy < 0) || (iNdEx+skippy) < 0 {
3458 return ErrInvalidLengthMetrics
3459 }
3460 if (iNdEx + skippy) > l {
3461 return io.ErrUnexpectedEOF
3462 }
3463 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
3464 iNdEx += skippy
3465 }
3466 }
3467
3468 if iNdEx > l {
3469 return io.ErrUnexpectedEOF
3470 }
3471 return nil
3472 }
3473 func (m *CPUStat) Unmarshal(dAtA []byte) error {
3474 l := len(dAtA)
3475 iNdEx := 0
3476 for iNdEx < l {
3477 preIndex := iNdEx
3478 var wire uint64
3479 for shift := uint(0); ; shift += 7 {
3480 if shift >= 64 {
3481 return ErrIntOverflowMetrics
3482 }
3483 if iNdEx >= l {
3484 return io.ErrUnexpectedEOF
3485 }
3486 b := dAtA[iNdEx]
3487 iNdEx++
3488 wire |= uint64(b&0x7F) << shift
3489 if b < 0x80 {
3490 break
3491 }
3492 }
3493 fieldNum := int32(wire >> 3)
3494 wireType := int(wire & 0x7)
3495 if wireType == 4 {
3496 return fmt.Errorf("proto: CPUStat: wiretype end group for non-group")
3497 }
3498 if fieldNum <= 0 {
3499 return fmt.Errorf("proto: CPUStat: illegal tag %d (wire type %d)", fieldNum, wire)
3500 }
3501 switch fieldNum {
3502 case 1:
3503 if wireType != 2 {
3504 return fmt.Errorf("proto: wrong wireType = %d for field Usage", wireType)
3505 }
3506 var msglen int
3507 for shift := uint(0); ; shift += 7 {
3508 if shift >= 64 {
3509 return ErrIntOverflowMetrics
3510 }
3511 if iNdEx >= l {
3512 return io.ErrUnexpectedEOF
3513 }
3514 b := dAtA[iNdEx]
3515 iNdEx++
3516 msglen |= int(b&0x7F) << shift
3517 if b < 0x80 {
3518 break
3519 }
3520 }
3521 if msglen < 0 {
3522 return ErrInvalidLengthMetrics
3523 }
3524 postIndex := iNdEx + msglen
3525 if postIndex < 0 {
3526 return ErrInvalidLengthMetrics
3527 }
3528 if postIndex > l {
3529 return io.ErrUnexpectedEOF
3530 }
3531 if m.Usage == nil {
3532 m.Usage = &CPUUsage{}
3533 }
3534 if err := m.Usage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3535 return err
3536 }
3537 iNdEx = postIndex
3538 case 2:
3539 if wireType != 2 {
3540 return fmt.Errorf("proto: wrong wireType = %d for field Throttling", wireType)
3541 }
3542 var msglen int
3543 for shift := uint(0); ; shift += 7 {
3544 if shift >= 64 {
3545 return ErrIntOverflowMetrics
3546 }
3547 if iNdEx >= l {
3548 return io.ErrUnexpectedEOF
3549 }
3550 b := dAtA[iNdEx]
3551 iNdEx++
3552 msglen |= int(b&0x7F) << shift
3553 if b < 0x80 {
3554 break
3555 }
3556 }
3557 if msglen < 0 {
3558 return ErrInvalidLengthMetrics
3559 }
3560 postIndex := iNdEx + msglen
3561 if postIndex < 0 {
3562 return ErrInvalidLengthMetrics
3563 }
3564 if postIndex > l {
3565 return io.ErrUnexpectedEOF
3566 }
3567 if m.Throttling == nil {
3568 m.Throttling = &Throttle{}
3569 }
3570 if err := m.Throttling.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3571 return err
3572 }
3573 iNdEx = postIndex
3574 default:
3575 iNdEx = preIndex
3576 skippy, err := skipMetrics(dAtA[iNdEx:])
3577 if err != nil {
3578 return err
3579 }
3580 if (skippy < 0) || (iNdEx+skippy) < 0 {
3581 return ErrInvalidLengthMetrics
3582 }
3583 if (iNdEx + skippy) > l {
3584 return io.ErrUnexpectedEOF
3585 }
3586 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
3587 iNdEx += skippy
3588 }
3589 }
3590
3591 if iNdEx > l {
3592 return io.ErrUnexpectedEOF
3593 }
3594 return nil
3595 }
3596 func (m *CPUUsage) Unmarshal(dAtA []byte) error {
3597 l := len(dAtA)
3598 iNdEx := 0
3599 for iNdEx < l {
3600 preIndex := iNdEx
3601 var wire uint64
3602 for shift := uint(0); ; shift += 7 {
3603 if shift >= 64 {
3604 return ErrIntOverflowMetrics
3605 }
3606 if iNdEx >= l {
3607 return io.ErrUnexpectedEOF
3608 }
3609 b := dAtA[iNdEx]
3610 iNdEx++
3611 wire |= uint64(b&0x7F) << shift
3612 if b < 0x80 {
3613 break
3614 }
3615 }
3616 fieldNum := int32(wire >> 3)
3617 wireType := int(wire & 0x7)
3618 if wireType == 4 {
3619 return fmt.Errorf("proto: CPUUsage: wiretype end group for non-group")
3620 }
3621 if fieldNum <= 0 {
3622 return fmt.Errorf("proto: CPUUsage: illegal tag %d (wire type %d)", fieldNum, wire)
3623 }
3624 switch fieldNum {
3625 case 1:
3626 if wireType != 0 {
3627 return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
3628 }
3629 m.Total = 0
3630 for shift := uint(0); ; shift += 7 {
3631 if shift >= 64 {
3632 return ErrIntOverflowMetrics
3633 }
3634 if iNdEx >= l {
3635 return io.ErrUnexpectedEOF
3636 }
3637 b := dAtA[iNdEx]
3638 iNdEx++
3639 m.Total |= uint64(b&0x7F) << shift
3640 if b < 0x80 {
3641 break
3642 }
3643 }
3644 case 2:
3645 if wireType != 0 {
3646 return fmt.Errorf("proto: wrong wireType = %d for field Kernel", wireType)
3647 }
3648 m.Kernel = 0
3649 for shift := uint(0); ; shift += 7 {
3650 if shift >= 64 {
3651 return ErrIntOverflowMetrics
3652 }
3653 if iNdEx >= l {
3654 return io.ErrUnexpectedEOF
3655 }
3656 b := dAtA[iNdEx]
3657 iNdEx++
3658 m.Kernel |= uint64(b&0x7F) << shift
3659 if b < 0x80 {
3660 break
3661 }
3662 }
3663 case 3:
3664 if wireType != 0 {
3665 return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
3666 }
3667 m.User = 0
3668 for shift := uint(0); ; shift += 7 {
3669 if shift >= 64 {
3670 return ErrIntOverflowMetrics
3671 }
3672 if iNdEx >= l {
3673 return io.ErrUnexpectedEOF
3674 }
3675 b := dAtA[iNdEx]
3676 iNdEx++
3677 m.User |= uint64(b&0x7F) << shift
3678 if b < 0x80 {
3679 break
3680 }
3681 }
3682 case 4:
3683 if wireType == 0 {
3684 var v uint64
3685 for shift := uint(0); ; shift += 7 {
3686 if shift >= 64 {
3687 return ErrIntOverflowMetrics
3688 }
3689 if iNdEx >= l {
3690 return io.ErrUnexpectedEOF
3691 }
3692 b := dAtA[iNdEx]
3693 iNdEx++
3694 v |= uint64(b&0x7F) << shift
3695 if b < 0x80 {
3696 break
3697 }
3698 }
3699 m.PerCPU = append(m.PerCPU, v)
3700 } else if wireType == 2 {
3701 var packedLen int
3702 for shift := uint(0); ; shift += 7 {
3703 if shift >= 64 {
3704 return ErrIntOverflowMetrics
3705 }
3706 if iNdEx >= l {
3707 return io.ErrUnexpectedEOF
3708 }
3709 b := dAtA[iNdEx]
3710 iNdEx++
3711 packedLen |= int(b&0x7F) << shift
3712 if b < 0x80 {
3713 break
3714 }
3715 }
3716 if packedLen < 0 {
3717 return ErrInvalidLengthMetrics
3718 }
3719 postIndex := iNdEx + packedLen
3720 if postIndex < 0 {
3721 return ErrInvalidLengthMetrics
3722 }
3723 if postIndex > l {
3724 return io.ErrUnexpectedEOF
3725 }
3726 var elementCount int
3727 var count int
3728 for _, integer := range dAtA[iNdEx:postIndex] {
3729 if integer < 128 {
3730 count++
3731 }
3732 }
3733 elementCount = count
3734 if elementCount != 0 && len(m.PerCPU) == 0 {
3735 m.PerCPU = make([]uint64, 0, elementCount)
3736 }
3737 for iNdEx < postIndex {
3738 var v uint64
3739 for shift := uint(0); ; shift += 7 {
3740 if shift >= 64 {
3741 return ErrIntOverflowMetrics
3742 }
3743 if iNdEx >= l {
3744 return io.ErrUnexpectedEOF
3745 }
3746 b := dAtA[iNdEx]
3747 iNdEx++
3748 v |= uint64(b&0x7F) << shift
3749 if b < 0x80 {
3750 break
3751 }
3752 }
3753 m.PerCPU = append(m.PerCPU, v)
3754 }
3755 } else {
3756 return fmt.Errorf("proto: wrong wireType = %d for field PerCPU", wireType)
3757 }
3758 default:
3759 iNdEx = preIndex
3760 skippy, err := skipMetrics(dAtA[iNdEx:])
3761 if err != nil {
3762 return err
3763 }
3764 if (skippy < 0) || (iNdEx+skippy) < 0 {
3765 return ErrInvalidLengthMetrics
3766 }
3767 if (iNdEx + skippy) > l {
3768 return io.ErrUnexpectedEOF
3769 }
3770 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
3771 iNdEx += skippy
3772 }
3773 }
3774
3775 if iNdEx > l {
3776 return io.ErrUnexpectedEOF
3777 }
3778 return nil
3779 }
3780 func (m *Throttle) Unmarshal(dAtA []byte) error {
3781 l := len(dAtA)
3782 iNdEx := 0
3783 for iNdEx < l {
3784 preIndex := iNdEx
3785 var wire uint64
3786 for shift := uint(0); ; shift += 7 {
3787 if shift >= 64 {
3788 return ErrIntOverflowMetrics
3789 }
3790 if iNdEx >= l {
3791 return io.ErrUnexpectedEOF
3792 }
3793 b := dAtA[iNdEx]
3794 iNdEx++
3795 wire |= uint64(b&0x7F) << shift
3796 if b < 0x80 {
3797 break
3798 }
3799 }
3800 fieldNum := int32(wire >> 3)
3801 wireType := int(wire & 0x7)
3802 if wireType == 4 {
3803 return fmt.Errorf("proto: Throttle: wiretype end group for non-group")
3804 }
3805 if fieldNum <= 0 {
3806 return fmt.Errorf("proto: Throttle: illegal tag %d (wire type %d)", fieldNum, wire)
3807 }
3808 switch fieldNum {
3809 case 1:
3810 if wireType != 0 {
3811 return fmt.Errorf("proto: wrong wireType = %d for field Periods", wireType)
3812 }
3813 m.Periods = 0
3814 for shift := uint(0); ; shift += 7 {
3815 if shift >= 64 {
3816 return ErrIntOverflowMetrics
3817 }
3818 if iNdEx >= l {
3819 return io.ErrUnexpectedEOF
3820 }
3821 b := dAtA[iNdEx]
3822 iNdEx++
3823 m.Periods |= uint64(b&0x7F) << shift
3824 if b < 0x80 {
3825 break
3826 }
3827 }
3828 case 2:
3829 if wireType != 0 {
3830 return fmt.Errorf("proto: wrong wireType = %d for field ThrottledPeriods", wireType)
3831 }
3832 m.ThrottledPeriods = 0
3833 for shift := uint(0); ; shift += 7 {
3834 if shift >= 64 {
3835 return ErrIntOverflowMetrics
3836 }
3837 if iNdEx >= l {
3838 return io.ErrUnexpectedEOF
3839 }
3840 b := dAtA[iNdEx]
3841 iNdEx++
3842 m.ThrottledPeriods |= uint64(b&0x7F) << shift
3843 if b < 0x80 {
3844 break
3845 }
3846 }
3847 case 3:
3848 if wireType != 0 {
3849 return fmt.Errorf("proto: wrong wireType = %d for field ThrottledTime", wireType)
3850 }
3851 m.ThrottledTime = 0
3852 for shift := uint(0); ; shift += 7 {
3853 if shift >= 64 {
3854 return ErrIntOverflowMetrics
3855 }
3856 if iNdEx >= l {
3857 return io.ErrUnexpectedEOF
3858 }
3859 b := dAtA[iNdEx]
3860 iNdEx++
3861 m.ThrottledTime |= uint64(b&0x7F) << shift
3862 if b < 0x80 {
3863 break
3864 }
3865 }
3866 default:
3867 iNdEx = preIndex
3868 skippy, err := skipMetrics(dAtA[iNdEx:])
3869 if err != nil {
3870 return err
3871 }
3872 if (skippy < 0) || (iNdEx+skippy) < 0 {
3873 return ErrInvalidLengthMetrics
3874 }
3875 if (iNdEx + skippy) > l {
3876 return io.ErrUnexpectedEOF
3877 }
3878 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
3879 iNdEx += skippy
3880 }
3881 }
3882
3883 if iNdEx > l {
3884 return io.ErrUnexpectedEOF
3885 }
3886 return nil
3887 }
3888 func (m *MemoryStat) Unmarshal(dAtA []byte) error {
3889 l := len(dAtA)
3890 iNdEx := 0
3891 for iNdEx < l {
3892 preIndex := iNdEx
3893 var wire uint64
3894 for shift := uint(0); ; shift += 7 {
3895 if shift >= 64 {
3896 return ErrIntOverflowMetrics
3897 }
3898 if iNdEx >= l {
3899 return io.ErrUnexpectedEOF
3900 }
3901 b := dAtA[iNdEx]
3902 iNdEx++
3903 wire |= uint64(b&0x7F) << shift
3904 if b < 0x80 {
3905 break
3906 }
3907 }
3908 fieldNum := int32(wire >> 3)
3909 wireType := int(wire & 0x7)
3910 if wireType == 4 {
3911 return fmt.Errorf("proto: MemoryStat: wiretype end group for non-group")
3912 }
3913 if fieldNum <= 0 {
3914 return fmt.Errorf("proto: MemoryStat: illegal tag %d (wire type %d)", fieldNum, wire)
3915 }
3916 switch fieldNum {
3917 case 1:
3918 if wireType != 0 {
3919 return fmt.Errorf("proto: wrong wireType = %d for field Cache", wireType)
3920 }
3921 m.Cache = 0
3922 for shift := uint(0); ; shift += 7 {
3923 if shift >= 64 {
3924 return ErrIntOverflowMetrics
3925 }
3926 if iNdEx >= l {
3927 return io.ErrUnexpectedEOF
3928 }
3929 b := dAtA[iNdEx]
3930 iNdEx++
3931 m.Cache |= uint64(b&0x7F) << shift
3932 if b < 0x80 {
3933 break
3934 }
3935 }
3936 case 2:
3937 if wireType != 0 {
3938 return fmt.Errorf("proto: wrong wireType = %d for field RSS", wireType)
3939 }
3940 m.RSS = 0
3941 for shift := uint(0); ; shift += 7 {
3942 if shift >= 64 {
3943 return ErrIntOverflowMetrics
3944 }
3945 if iNdEx >= l {
3946 return io.ErrUnexpectedEOF
3947 }
3948 b := dAtA[iNdEx]
3949 iNdEx++
3950 m.RSS |= uint64(b&0x7F) << shift
3951 if b < 0x80 {
3952 break
3953 }
3954 }
3955 case 3:
3956 if wireType != 0 {
3957 return fmt.Errorf("proto: wrong wireType = %d for field RSSHuge", wireType)
3958 }
3959 m.RSSHuge = 0
3960 for shift := uint(0); ; shift += 7 {
3961 if shift >= 64 {
3962 return ErrIntOverflowMetrics
3963 }
3964 if iNdEx >= l {
3965 return io.ErrUnexpectedEOF
3966 }
3967 b := dAtA[iNdEx]
3968 iNdEx++
3969 m.RSSHuge |= uint64(b&0x7F) << shift
3970 if b < 0x80 {
3971 break
3972 }
3973 }
3974 case 4:
3975 if wireType != 0 {
3976 return fmt.Errorf("proto: wrong wireType = %d for field MappedFile", wireType)
3977 }
3978 m.MappedFile = 0
3979 for shift := uint(0); ; shift += 7 {
3980 if shift >= 64 {
3981 return ErrIntOverflowMetrics
3982 }
3983 if iNdEx >= l {
3984 return io.ErrUnexpectedEOF
3985 }
3986 b := dAtA[iNdEx]
3987 iNdEx++
3988 m.MappedFile |= uint64(b&0x7F) << shift
3989 if b < 0x80 {
3990 break
3991 }
3992 }
3993 case 5:
3994 if wireType != 0 {
3995 return fmt.Errorf("proto: wrong wireType = %d for field Dirty", wireType)
3996 }
3997 m.Dirty = 0
3998 for shift := uint(0); ; shift += 7 {
3999 if shift >= 64 {
4000 return ErrIntOverflowMetrics
4001 }
4002 if iNdEx >= l {
4003 return io.ErrUnexpectedEOF
4004 }
4005 b := dAtA[iNdEx]
4006 iNdEx++
4007 m.Dirty |= uint64(b&0x7F) << shift
4008 if b < 0x80 {
4009 break
4010 }
4011 }
4012 case 6:
4013 if wireType != 0 {
4014 return fmt.Errorf("proto: wrong wireType = %d for field Writeback", wireType)
4015 }
4016 m.Writeback = 0
4017 for shift := uint(0); ; shift += 7 {
4018 if shift >= 64 {
4019 return ErrIntOverflowMetrics
4020 }
4021 if iNdEx >= l {
4022 return io.ErrUnexpectedEOF
4023 }
4024 b := dAtA[iNdEx]
4025 iNdEx++
4026 m.Writeback |= uint64(b&0x7F) << shift
4027 if b < 0x80 {
4028 break
4029 }
4030 }
4031 case 7:
4032 if wireType != 0 {
4033 return fmt.Errorf("proto: wrong wireType = %d for field PgPgIn", wireType)
4034 }
4035 m.PgPgIn = 0
4036 for shift := uint(0); ; shift += 7 {
4037 if shift >= 64 {
4038 return ErrIntOverflowMetrics
4039 }
4040 if iNdEx >= l {
4041 return io.ErrUnexpectedEOF
4042 }
4043 b := dAtA[iNdEx]
4044 iNdEx++
4045 m.PgPgIn |= uint64(b&0x7F) << shift
4046 if b < 0x80 {
4047 break
4048 }
4049 }
4050 case 8:
4051 if wireType != 0 {
4052 return fmt.Errorf("proto: wrong wireType = %d for field PgPgOut", wireType)
4053 }
4054 m.PgPgOut = 0
4055 for shift := uint(0); ; shift += 7 {
4056 if shift >= 64 {
4057 return ErrIntOverflowMetrics
4058 }
4059 if iNdEx >= l {
4060 return io.ErrUnexpectedEOF
4061 }
4062 b := dAtA[iNdEx]
4063 iNdEx++
4064 m.PgPgOut |= uint64(b&0x7F) << shift
4065 if b < 0x80 {
4066 break
4067 }
4068 }
4069 case 9:
4070 if wireType != 0 {
4071 return fmt.Errorf("proto: wrong wireType = %d for field PgFault", wireType)
4072 }
4073 m.PgFault = 0
4074 for shift := uint(0); ; shift += 7 {
4075 if shift >= 64 {
4076 return ErrIntOverflowMetrics
4077 }
4078 if iNdEx >= l {
4079 return io.ErrUnexpectedEOF
4080 }
4081 b := dAtA[iNdEx]
4082 iNdEx++
4083 m.PgFault |= uint64(b&0x7F) << shift
4084 if b < 0x80 {
4085 break
4086 }
4087 }
4088 case 10:
4089 if wireType != 0 {
4090 return fmt.Errorf("proto: wrong wireType = %d for field PgMajFault", wireType)
4091 }
4092 m.PgMajFault = 0
4093 for shift := uint(0); ; shift += 7 {
4094 if shift >= 64 {
4095 return ErrIntOverflowMetrics
4096 }
4097 if iNdEx >= l {
4098 return io.ErrUnexpectedEOF
4099 }
4100 b := dAtA[iNdEx]
4101 iNdEx++
4102 m.PgMajFault |= uint64(b&0x7F) << shift
4103 if b < 0x80 {
4104 break
4105 }
4106 }
4107 case 11:
4108 if wireType != 0 {
4109 return fmt.Errorf("proto: wrong wireType = %d for field InactiveAnon", wireType)
4110 }
4111 m.InactiveAnon = 0
4112 for shift := uint(0); ; shift += 7 {
4113 if shift >= 64 {
4114 return ErrIntOverflowMetrics
4115 }
4116 if iNdEx >= l {
4117 return io.ErrUnexpectedEOF
4118 }
4119 b := dAtA[iNdEx]
4120 iNdEx++
4121 m.InactiveAnon |= uint64(b&0x7F) << shift
4122 if b < 0x80 {
4123 break
4124 }
4125 }
4126 case 12:
4127 if wireType != 0 {
4128 return fmt.Errorf("proto: wrong wireType = %d for field ActiveAnon", wireType)
4129 }
4130 m.ActiveAnon = 0
4131 for shift := uint(0); ; shift += 7 {
4132 if shift >= 64 {
4133 return ErrIntOverflowMetrics
4134 }
4135 if iNdEx >= l {
4136 return io.ErrUnexpectedEOF
4137 }
4138 b := dAtA[iNdEx]
4139 iNdEx++
4140 m.ActiveAnon |= uint64(b&0x7F) << shift
4141 if b < 0x80 {
4142 break
4143 }
4144 }
4145 case 13:
4146 if wireType != 0 {
4147 return fmt.Errorf("proto: wrong wireType = %d for field InactiveFile", wireType)
4148 }
4149 m.InactiveFile = 0
4150 for shift := uint(0); ; shift += 7 {
4151 if shift >= 64 {
4152 return ErrIntOverflowMetrics
4153 }
4154 if iNdEx >= l {
4155 return io.ErrUnexpectedEOF
4156 }
4157 b := dAtA[iNdEx]
4158 iNdEx++
4159 m.InactiveFile |= uint64(b&0x7F) << shift
4160 if b < 0x80 {
4161 break
4162 }
4163 }
4164 case 14:
4165 if wireType != 0 {
4166 return fmt.Errorf("proto: wrong wireType = %d for field ActiveFile", wireType)
4167 }
4168 m.ActiveFile = 0
4169 for shift := uint(0); ; shift += 7 {
4170 if shift >= 64 {
4171 return ErrIntOverflowMetrics
4172 }
4173 if iNdEx >= l {
4174 return io.ErrUnexpectedEOF
4175 }
4176 b := dAtA[iNdEx]
4177 iNdEx++
4178 m.ActiveFile |= uint64(b&0x7F) << shift
4179 if b < 0x80 {
4180 break
4181 }
4182 }
4183 case 15:
4184 if wireType != 0 {
4185 return fmt.Errorf("proto: wrong wireType = %d for field Unevictable", wireType)
4186 }
4187 m.Unevictable = 0
4188 for shift := uint(0); ; shift += 7 {
4189 if shift >= 64 {
4190 return ErrIntOverflowMetrics
4191 }
4192 if iNdEx >= l {
4193 return io.ErrUnexpectedEOF
4194 }
4195 b := dAtA[iNdEx]
4196 iNdEx++
4197 m.Unevictable |= uint64(b&0x7F) << shift
4198 if b < 0x80 {
4199 break
4200 }
4201 }
4202 case 16:
4203 if wireType != 0 {
4204 return fmt.Errorf("proto: wrong wireType = %d for field HierarchicalMemoryLimit", wireType)
4205 }
4206 m.HierarchicalMemoryLimit = 0
4207 for shift := uint(0); ; shift += 7 {
4208 if shift >= 64 {
4209 return ErrIntOverflowMetrics
4210 }
4211 if iNdEx >= l {
4212 return io.ErrUnexpectedEOF
4213 }
4214 b := dAtA[iNdEx]
4215 iNdEx++
4216 m.HierarchicalMemoryLimit |= uint64(b&0x7F) << shift
4217 if b < 0x80 {
4218 break
4219 }
4220 }
4221 case 17:
4222 if wireType != 0 {
4223 return fmt.Errorf("proto: wrong wireType = %d for field HierarchicalSwapLimit", wireType)
4224 }
4225 m.HierarchicalSwapLimit = 0
4226 for shift := uint(0); ; shift += 7 {
4227 if shift >= 64 {
4228 return ErrIntOverflowMetrics
4229 }
4230 if iNdEx >= l {
4231 return io.ErrUnexpectedEOF
4232 }
4233 b := dAtA[iNdEx]
4234 iNdEx++
4235 m.HierarchicalSwapLimit |= uint64(b&0x7F) << shift
4236 if b < 0x80 {
4237 break
4238 }
4239 }
4240 case 18:
4241 if wireType != 0 {
4242 return fmt.Errorf("proto: wrong wireType = %d for field TotalCache", wireType)
4243 }
4244 m.TotalCache = 0
4245 for shift := uint(0); ; shift += 7 {
4246 if shift >= 64 {
4247 return ErrIntOverflowMetrics
4248 }
4249 if iNdEx >= l {
4250 return io.ErrUnexpectedEOF
4251 }
4252 b := dAtA[iNdEx]
4253 iNdEx++
4254 m.TotalCache |= uint64(b&0x7F) << shift
4255 if b < 0x80 {
4256 break
4257 }
4258 }
4259 case 19:
4260 if wireType != 0 {
4261 return fmt.Errorf("proto: wrong wireType = %d for field TotalRSS", wireType)
4262 }
4263 m.TotalRSS = 0
4264 for shift := uint(0); ; shift += 7 {
4265 if shift >= 64 {
4266 return ErrIntOverflowMetrics
4267 }
4268 if iNdEx >= l {
4269 return io.ErrUnexpectedEOF
4270 }
4271 b := dAtA[iNdEx]
4272 iNdEx++
4273 m.TotalRSS |= uint64(b&0x7F) << shift
4274 if b < 0x80 {
4275 break
4276 }
4277 }
4278 case 20:
4279 if wireType != 0 {
4280 return fmt.Errorf("proto: wrong wireType = %d for field TotalRSSHuge", wireType)
4281 }
4282 m.TotalRSSHuge = 0
4283 for shift := uint(0); ; shift += 7 {
4284 if shift >= 64 {
4285 return ErrIntOverflowMetrics
4286 }
4287 if iNdEx >= l {
4288 return io.ErrUnexpectedEOF
4289 }
4290 b := dAtA[iNdEx]
4291 iNdEx++
4292 m.TotalRSSHuge |= uint64(b&0x7F) << shift
4293 if b < 0x80 {
4294 break
4295 }
4296 }
4297 case 21:
4298 if wireType != 0 {
4299 return fmt.Errorf("proto: wrong wireType = %d for field TotalMappedFile", wireType)
4300 }
4301 m.TotalMappedFile = 0
4302 for shift := uint(0); ; shift += 7 {
4303 if shift >= 64 {
4304 return ErrIntOverflowMetrics
4305 }
4306 if iNdEx >= l {
4307 return io.ErrUnexpectedEOF
4308 }
4309 b := dAtA[iNdEx]
4310 iNdEx++
4311 m.TotalMappedFile |= uint64(b&0x7F) << shift
4312 if b < 0x80 {
4313 break
4314 }
4315 }
4316 case 22:
4317 if wireType != 0 {
4318 return fmt.Errorf("proto: wrong wireType = %d for field TotalDirty", wireType)
4319 }
4320 m.TotalDirty = 0
4321 for shift := uint(0); ; shift += 7 {
4322 if shift >= 64 {
4323 return ErrIntOverflowMetrics
4324 }
4325 if iNdEx >= l {
4326 return io.ErrUnexpectedEOF
4327 }
4328 b := dAtA[iNdEx]
4329 iNdEx++
4330 m.TotalDirty |= uint64(b&0x7F) << shift
4331 if b < 0x80 {
4332 break
4333 }
4334 }
4335 case 23:
4336 if wireType != 0 {
4337 return fmt.Errorf("proto: wrong wireType = %d for field TotalWriteback", wireType)
4338 }
4339 m.TotalWriteback = 0
4340 for shift := uint(0); ; shift += 7 {
4341 if shift >= 64 {
4342 return ErrIntOverflowMetrics
4343 }
4344 if iNdEx >= l {
4345 return io.ErrUnexpectedEOF
4346 }
4347 b := dAtA[iNdEx]
4348 iNdEx++
4349 m.TotalWriteback |= uint64(b&0x7F) << shift
4350 if b < 0x80 {
4351 break
4352 }
4353 }
4354 case 24:
4355 if wireType != 0 {
4356 return fmt.Errorf("proto: wrong wireType = %d for field TotalPgPgIn", wireType)
4357 }
4358 m.TotalPgPgIn = 0
4359 for shift := uint(0); ; shift += 7 {
4360 if shift >= 64 {
4361 return ErrIntOverflowMetrics
4362 }
4363 if iNdEx >= l {
4364 return io.ErrUnexpectedEOF
4365 }
4366 b := dAtA[iNdEx]
4367 iNdEx++
4368 m.TotalPgPgIn |= uint64(b&0x7F) << shift
4369 if b < 0x80 {
4370 break
4371 }
4372 }
4373 case 25:
4374 if wireType != 0 {
4375 return fmt.Errorf("proto: wrong wireType = %d for field TotalPgPgOut", wireType)
4376 }
4377 m.TotalPgPgOut = 0
4378 for shift := uint(0); ; shift += 7 {
4379 if shift >= 64 {
4380 return ErrIntOverflowMetrics
4381 }
4382 if iNdEx >= l {
4383 return io.ErrUnexpectedEOF
4384 }
4385 b := dAtA[iNdEx]
4386 iNdEx++
4387 m.TotalPgPgOut |= uint64(b&0x7F) << shift
4388 if b < 0x80 {
4389 break
4390 }
4391 }
4392 case 26:
4393 if wireType != 0 {
4394 return fmt.Errorf("proto: wrong wireType = %d for field TotalPgFault", wireType)
4395 }
4396 m.TotalPgFault = 0
4397 for shift := uint(0); ; shift += 7 {
4398 if shift >= 64 {
4399 return ErrIntOverflowMetrics
4400 }
4401 if iNdEx >= l {
4402 return io.ErrUnexpectedEOF
4403 }
4404 b := dAtA[iNdEx]
4405 iNdEx++
4406 m.TotalPgFault |= uint64(b&0x7F) << shift
4407 if b < 0x80 {
4408 break
4409 }
4410 }
4411 case 27:
4412 if wireType != 0 {
4413 return fmt.Errorf("proto: wrong wireType = %d for field TotalPgMajFault", wireType)
4414 }
4415 m.TotalPgMajFault = 0
4416 for shift := uint(0); ; shift += 7 {
4417 if shift >= 64 {
4418 return ErrIntOverflowMetrics
4419 }
4420 if iNdEx >= l {
4421 return io.ErrUnexpectedEOF
4422 }
4423 b := dAtA[iNdEx]
4424 iNdEx++
4425 m.TotalPgMajFault |= uint64(b&0x7F) << shift
4426 if b < 0x80 {
4427 break
4428 }
4429 }
4430 case 28:
4431 if wireType != 0 {
4432 return fmt.Errorf("proto: wrong wireType = %d for field TotalInactiveAnon", wireType)
4433 }
4434 m.TotalInactiveAnon = 0
4435 for shift := uint(0); ; shift += 7 {
4436 if shift >= 64 {
4437 return ErrIntOverflowMetrics
4438 }
4439 if iNdEx >= l {
4440 return io.ErrUnexpectedEOF
4441 }
4442 b := dAtA[iNdEx]
4443 iNdEx++
4444 m.TotalInactiveAnon |= uint64(b&0x7F) << shift
4445 if b < 0x80 {
4446 break
4447 }
4448 }
4449 case 29:
4450 if wireType != 0 {
4451 return fmt.Errorf("proto: wrong wireType = %d for field TotalActiveAnon", wireType)
4452 }
4453 m.TotalActiveAnon = 0
4454 for shift := uint(0); ; shift += 7 {
4455 if shift >= 64 {
4456 return ErrIntOverflowMetrics
4457 }
4458 if iNdEx >= l {
4459 return io.ErrUnexpectedEOF
4460 }
4461 b := dAtA[iNdEx]
4462 iNdEx++
4463 m.TotalActiveAnon |= uint64(b&0x7F) << shift
4464 if b < 0x80 {
4465 break
4466 }
4467 }
4468 case 30:
4469 if wireType != 0 {
4470 return fmt.Errorf("proto: wrong wireType = %d for field TotalInactiveFile", wireType)
4471 }
4472 m.TotalInactiveFile = 0
4473 for shift := uint(0); ; shift += 7 {
4474 if shift >= 64 {
4475 return ErrIntOverflowMetrics
4476 }
4477 if iNdEx >= l {
4478 return io.ErrUnexpectedEOF
4479 }
4480 b := dAtA[iNdEx]
4481 iNdEx++
4482 m.TotalInactiveFile |= uint64(b&0x7F) << shift
4483 if b < 0x80 {
4484 break
4485 }
4486 }
4487 case 31:
4488 if wireType != 0 {
4489 return fmt.Errorf("proto: wrong wireType = %d for field TotalActiveFile", wireType)
4490 }
4491 m.TotalActiveFile = 0
4492 for shift := uint(0); ; shift += 7 {
4493 if shift >= 64 {
4494 return ErrIntOverflowMetrics
4495 }
4496 if iNdEx >= l {
4497 return io.ErrUnexpectedEOF
4498 }
4499 b := dAtA[iNdEx]
4500 iNdEx++
4501 m.TotalActiveFile |= uint64(b&0x7F) << shift
4502 if b < 0x80 {
4503 break
4504 }
4505 }
4506 case 32:
4507 if wireType != 0 {
4508 return fmt.Errorf("proto: wrong wireType = %d for field TotalUnevictable", wireType)
4509 }
4510 m.TotalUnevictable = 0
4511 for shift := uint(0); ; shift += 7 {
4512 if shift >= 64 {
4513 return ErrIntOverflowMetrics
4514 }
4515 if iNdEx >= l {
4516 return io.ErrUnexpectedEOF
4517 }
4518 b := dAtA[iNdEx]
4519 iNdEx++
4520 m.TotalUnevictable |= uint64(b&0x7F) << shift
4521 if b < 0x80 {
4522 break
4523 }
4524 }
4525 case 33:
4526 if wireType != 2 {
4527 return fmt.Errorf("proto: wrong wireType = %d for field Usage", wireType)
4528 }
4529 var msglen int
4530 for shift := uint(0); ; shift += 7 {
4531 if shift >= 64 {
4532 return ErrIntOverflowMetrics
4533 }
4534 if iNdEx >= l {
4535 return io.ErrUnexpectedEOF
4536 }
4537 b := dAtA[iNdEx]
4538 iNdEx++
4539 msglen |= int(b&0x7F) << shift
4540 if b < 0x80 {
4541 break
4542 }
4543 }
4544 if msglen < 0 {
4545 return ErrInvalidLengthMetrics
4546 }
4547 postIndex := iNdEx + msglen
4548 if postIndex < 0 {
4549 return ErrInvalidLengthMetrics
4550 }
4551 if postIndex > l {
4552 return io.ErrUnexpectedEOF
4553 }
4554 if m.Usage == nil {
4555 m.Usage = &MemoryEntry{}
4556 }
4557 if err := m.Usage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4558 return err
4559 }
4560 iNdEx = postIndex
4561 case 34:
4562 if wireType != 2 {
4563 return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType)
4564 }
4565 var msglen int
4566 for shift := uint(0); ; shift += 7 {
4567 if shift >= 64 {
4568 return ErrIntOverflowMetrics
4569 }
4570 if iNdEx >= l {
4571 return io.ErrUnexpectedEOF
4572 }
4573 b := dAtA[iNdEx]
4574 iNdEx++
4575 msglen |= int(b&0x7F) << shift
4576 if b < 0x80 {
4577 break
4578 }
4579 }
4580 if msglen < 0 {
4581 return ErrInvalidLengthMetrics
4582 }
4583 postIndex := iNdEx + msglen
4584 if postIndex < 0 {
4585 return ErrInvalidLengthMetrics
4586 }
4587 if postIndex > l {
4588 return io.ErrUnexpectedEOF
4589 }
4590 if m.Swap == nil {
4591 m.Swap = &MemoryEntry{}
4592 }
4593 if err := m.Swap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4594 return err
4595 }
4596 iNdEx = postIndex
4597 case 35:
4598 if wireType != 2 {
4599 return fmt.Errorf("proto: wrong wireType = %d for field Kernel", wireType)
4600 }
4601 var msglen int
4602 for shift := uint(0); ; shift += 7 {
4603 if shift >= 64 {
4604 return ErrIntOverflowMetrics
4605 }
4606 if iNdEx >= l {
4607 return io.ErrUnexpectedEOF
4608 }
4609 b := dAtA[iNdEx]
4610 iNdEx++
4611 msglen |= int(b&0x7F) << shift
4612 if b < 0x80 {
4613 break
4614 }
4615 }
4616 if msglen < 0 {
4617 return ErrInvalidLengthMetrics
4618 }
4619 postIndex := iNdEx + msglen
4620 if postIndex < 0 {
4621 return ErrInvalidLengthMetrics
4622 }
4623 if postIndex > l {
4624 return io.ErrUnexpectedEOF
4625 }
4626 if m.Kernel == nil {
4627 m.Kernel = &MemoryEntry{}
4628 }
4629 if err := m.Kernel.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4630 return err
4631 }
4632 iNdEx = postIndex
4633 case 36:
4634 if wireType != 2 {
4635 return fmt.Errorf("proto: wrong wireType = %d for field KernelTCP", wireType)
4636 }
4637 var msglen int
4638 for shift := uint(0); ; shift += 7 {
4639 if shift >= 64 {
4640 return ErrIntOverflowMetrics
4641 }
4642 if iNdEx >= l {
4643 return io.ErrUnexpectedEOF
4644 }
4645 b := dAtA[iNdEx]
4646 iNdEx++
4647 msglen |= int(b&0x7F) << shift
4648 if b < 0x80 {
4649 break
4650 }
4651 }
4652 if msglen < 0 {
4653 return ErrInvalidLengthMetrics
4654 }
4655 postIndex := iNdEx + msglen
4656 if postIndex < 0 {
4657 return ErrInvalidLengthMetrics
4658 }
4659 if postIndex > l {
4660 return io.ErrUnexpectedEOF
4661 }
4662 if m.KernelTCP == nil {
4663 m.KernelTCP = &MemoryEntry{}
4664 }
4665 if err := m.KernelTCP.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4666 return err
4667 }
4668 iNdEx = postIndex
4669 default:
4670 iNdEx = preIndex
4671 skippy, err := skipMetrics(dAtA[iNdEx:])
4672 if err != nil {
4673 return err
4674 }
4675 if (skippy < 0) || (iNdEx+skippy) < 0 {
4676 return ErrInvalidLengthMetrics
4677 }
4678 if (iNdEx + skippy) > l {
4679 return io.ErrUnexpectedEOF
4680 }
4681 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4682 iNdEx += skippy
4683 }
4684 }
4685
4686 if iNdEx > l {
4687 return io.ErrUnexpectedEOF
4688 }
4689 return nil
4690 }
4691 func (m *MemoryEntry) Unmarshal(dAtA []byte) error {
4692 l := len(dAtA)
4693 iNdEx := 0
4694 for iNdEx < l {
4695 preIndex := iNdEx
4696 var wire uint64
4697 for shift := uint(0); ; shift += 7 {
4698 if shift >= 64 {
4699 return ErrIntOverflowMetrics
4700 }
4701 if iNdEx >= l {
4702 return io.ErrUnexpectedEOF
4703 }
4704 b := dAtA[iNdEx]
4705 iNdEx++
4706 wire |= uint64(b&0x7F) << shift
4707 if b < 0x80 {
4708 break
4709 }
4710 }
4711 fieldNum := int32(wire >> 3)
4712 wireType := int(wire & 0x7)
4713 if wireType == 4 {
4714 return fmt.Errorf("proto: MemoryEntry: wiretype end group for non-group")
4715 }
4716 if fieldNum <= 0 {
4717 return fmt.Errorf("proto: MemoryEntry: illegal tag %d (wire type %d)", fieldNum, wire)
4718 }
4719 switch fieldNum {
4720 case 1:
4721 if wireType != 0 {
4722 return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
4723 }
4724 m.Limit = 0
4725 for shift := uint(0); ; shift += 7 {
4726 if shift >= 64 {
4727 return ErrIntOverflowMetrics
4728 }
4729 if iNdEx >= l {
4730 return io.ErrUnexpectedEOF
4731 }
4732 b := dAtA[iNdEx]
4733 iNdEx++
4734 m.Limit |= uint64(b&0x7F) << shift
4735 if b < 0x80 {
4736 break
4737 }
4738 }
4739 case 2:
4740 if wireType != 0 {
4741 return fmt.Errorf("proto: wrong wireType = %d for field Usage", wireType)
4742 }
4743 m.Usage = 0
4744 for shift := uint(0); ; shift += 7 {
4745 if shift >= 64 {
4746 return ErrIntOverflowMetrics
4747 }
4748 if iNdEx >= l {
4749 return io.ErrUnexpectedEOF
4750 }
4751 b := dAtA[iNdEx]
4752 iNdEx++
4753 m.Usage |= uint64(b&0x7F) << shift
4754 if b < 0x80 {
4755 break
4756 }
4757 }
4758 case 3:
4759 if wireType != 0 {
4760 return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType)
4761 }
4762 m.Max = 0
4763 for shift := uint(0); ; shift += 7 {
4764 if shift >= 64 {
4765 return ErrIntOverflowMetrics
4766 }
4767 if iNdEx >= l {
4768 return io.ErrUnexpectedEOF
4769 }
4770 b := dAtA[iNdEx]
4771 iNdEx++
4772 m.Max |= uint64(b&0x7F) << shift
4773 if b < 0x80 {
4774 break
4775 }
4776 }
4777 case 4:
4778 if wireType != 0 {
4779 return fmt.Errorf("proto: wrong wireType = %d for field Failcnt", wireType)
4780 }
4781 m.Failcnt = 0
4782 for shift := uint(0); ; shift += 7 {
4783 if shift >= 64 {
4784 return ErrIntOverflowMetrics
4785 }
4786 if iNdEx >= l {
4787 return io.ErrUnexpectedEOF
4788 }
4789 b := dAtA[iNdEx]
4790 iNdEx++
4791 m.Failcnt |= uint64(b&0x7F) << shift
4792 if b < 0x80 {
4793 break
4794 }
4795 }
4796 default:
4797 iNdEx = preIndex
4798 skippy, err := skipMetrics(dAtA[iNdEx:])
4799 if err != nil {
4800 return err
4801 }
4802 if (skippy < 0) || (iNdEx+skippy) < 0 {
4803 return ErrInvalidLengthMetrics
4804 }
4805 if (iNdEx + skippy) > l {
4806 return io.ErrUnexpectedEOF
4807 }
4808 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4809 iNdEx += skippy
4810 }
4811 }
4812
4813 if iNdEx > l {
4814 return io.ErrUnexpectedEOF
4815 }
4816 return nil
4817 }
4818 func (m *MemoryOomControl) Unmarshal(dAtA []byte) error {
4819 l := len(dAtA)
4820 iNdEx := 0
4821 for iNdEx < l {
4822 preIndex := iNdEx
4823 var wire uint64
4824 for shift := uint(0); ; shift += 7 {
4825 if shift >= 64 {
4826 return ErrIntOverflowMetrics
4827 }
4828 if iNdEx >= l {
4829 return io.ErrUnexpectedEOF
4830 }
4831 b := dAtA[iNdEx]
4832 iNdEx++
4833 wire |= uint64(b&0x7F) << shift
4834 if b < 0x80 {
4835 break
4836 }
4837 }
4838 fieldNum := int32(wire >> 3)
4839 wireType := int(wire & 0x7)
4840 if wireType == 4 {
4841 return fmt.Errorf("proto: MemoryOomControl: wiretype end group for non-group")
4842 }
4843 if fieldNum <= 0 {
4844 return fmt.Errorf("proto: MemoryOomControl: illegal tag %d (wire type %d)", fieldNum, wire)
4845 }
4846 switch fieldNum {
4847 case 1:
4848 if wireType != 0 {
4849 return fmt.Errorf("proto: wrong wireType = %d for field OomKillDisable", wireType)
4850 }
4851 m.OomKillDisable = 0
4852 for shift := uint(0); ; shift += 7 {
4853 if shift >= 64 {
4854 return ErrIntOverflowMetrics
4855 }
4856 if iNdEx >= l {
4857 return io.ErrUnexpectedEOF
4858 }
4859 b := dAtA[iNdEx]
4860 iNdEx++
4861 m.OomKillDisable |= uint64(b&0x7F) << shift
4862 if b < 0x80 {
4863 break
4864 }
4865 }
4866 case 2:
4867 if wireType != 0 {
4868 return fmt.Errorf("proto: wrong wireType = %d for field UnderOom", wireType)
4869 }
4870 m.UnderOom = 0
4871 for shift := uint(0); ; shift += 7 {
4872 if shift >= 64 {
4873 return ErrIntOverflowMetrics
4874 }
4875 if iNdEx >= l {
4876 return io.ErrUnexpectedEOF
4877 }
4878 b := dAtA[iNdEx]
4879 iNdEx++
4880 m.UnderOom |= uint64(b&0x7F) << shift
4881 if b < 0x80 {
4882 break
4883 }
4884 }
4885 case 3:
4886 if wireType != 0 {
4887 return fmt.Errorf("proto: wrong wireType = %d for field OomKill", wireType)
4888 }
4889 m.OomKill = 0
4890 for shift := uint(0); ; shift += 7 {
4891 if shift >= 64 {
4892 return ErrIntOverflowMetrics
4893 }
4894 if iNdEx >= l {
4895 return io.ErrUnexpectedEOF
4896 }
4897 b := dAtA[iNdEx]
4898 iNdEx++
4899 m.OomKill |= uint64(b&0x7F) << shift
4900 if b < 0x80 {
4901 break
4902 }
4903 }
4904 default:
4905 iNdEx = preIndex
4906 skippy, err := skipMetrics(dAtA[iNdEx:])
4907 if err != nil {
4908 return err
4909 }
4910 if (skippy < 0) || (iNdEx+skippy) < 0 {
4911 return ErrInvalidLengthMetrics
4912 }
4913 if (iNdEx + skippy) > l {
4914 return io.ErrUnexpectedEOF
4915 }
4916 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4917 iNdEx += skippy
4918 }
4919 }
4920
4921 if iNdEx > l {
4922 return io.ErrUnexpectedEOF
4923 }
4924 return nil
4925 }
4926 func (m *BlkIOStat) Unmarshal(dAtA []byte) error {
4927 l := len(dAtA)
4928 iNdEx := 0
4929 for iNdEx < l {
4930 preIndex := iNdEx
4931 var wire uint64
4932 for shift := uint(0); ; shift += 7 {
4933 if shift >= 64 {
4934 return ErrIntOverflowMetrics
4935 }
4936 if iNdEx >= l {
4937 return io.ErrUnexpectedEOF
4938 }
4939 b := dAtA[iNdEx]
4940 iNdEx++
4941 wire |= uint64(b&0x7F) << shift
4942 if b < 0x80 {
4943 break
4944 }
4945 }
4946 fieldNum := int32(wire >> 3)
4947 wireType := int(wire & 0x7)
4948 if wireType == 4 {
4949 return fmt.Errorf("proto: BlkIOStat: wiretype end group for non-group")
4950 }
4951 if fieldNum <= 0 {
4952 return fmt.Errorf("proto: BlkIOStat: illegal tag %d (wire type %d)", fieldNum, wire)
4953 }
4954 switch fieldNum {
4955 case 1:
4956 if wireType != 2 {
4957 return fmt.Errorf("proto: wrong wireType = %d for field IoServiceBytesRecursive", wireType)
4958 }
4959 var msglen int
4960 for shift := uint(0); ; shift += 7 {
4961 if shift >= 64 {
4962 return ErrIntOverflowMetrics
4963 }
4964 if iNdEx >= l {
4965 return io.ErrUnexpectedEOF
4966 }
4967 b := dAtA[iNdEx]
4968 iNdEx++
4969 msglen |= int(b&0x7F) << shift
4970 if b < 0x80 {
4971 break
4972 }
4973 }
4974 if msglen < 0 {
4975 return ErrInvalidLengthMetrics
4976 }
4977 postIndex := iNdEx + msglen
4978 if postIndex < 0 {
4979 return ErrInvalidLengthMetrics
4980 }
4981 if postIndex > l {
4982 return io.ErrUnexpectedEOF
4983 }
4984 m.IoServiceBytesRecursive = append(m.IoServiceBytesRecursive, &BlkIOEntry{})
4985 if err := m.IoServiceBytesRecursive[len(m.IoServiceBytesRecursive)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4986 return err
4987 }
4988 iNdEx = postIndex
4989 case 2:
4990 if wireType != 2 {
4991 return fmt.Errorf("proto: wrong wireType = %d for field IoServicedRecursive", wireType)
4992 }
4993 var msglen int
4994 for shift := uint(0); ; shift += 7 {
4995 if shift >= 64 {
4996 return ErrIntOverflowMetrics
4997 }
4998 if iNdEx >= l {
4999 return io.ErrUnexpectedEOF
5000 }
5001 b := dAtA[iNdEx]
5002 iNdEx++
5003 msglen |= int(b&0x7F) << shift
5004 if b < 0x80 {
5005 break
5006 }
5007 }
5008 if msglen < 0 {
5009 return ErrInvalidLengthMetrics
5010 }
5011 postIndex := iNdEx + msglen
5012 if postIndex < 0 {
5013 return ErrInvalidLengthMetrics
5014 }
5015 if postIndex > l {
5016 return io.ErrUnexpectedEOF
5017 }
5018 m.IoServicedRecursive = append(m.IoServicedRecursive, &BlkIOEntry{})
5019 if err := m.IoServicedRecursive[len(m.IoServicedRecursive)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5020 return err
5021 }
5022 iNdEx = postIndex
5023 case 3:
5024 if wireType != 2 {
5025 return fmt.Errorf("proto: wrong wireType = %d for field IoQueuedRecursive", wireType)
5026 }
5027 var msglen int
5028 for shift := uint(0); ; shift += 7 {
5029 if shift >= 64 {
5030 return ErrIntOverflowMetrics
5031 }
5032 if iNdEx >= l {
5033 return io.ErrUnexpectedEOF
5034 }
5035 b := dAtA[iNdEx]
5036 iNdEx++
5037 msglen |= int(b&0x7F) << shift
5038 if b < 0x80 {
5039 break
5040 }
5041 }
5042 if msglen < 0 {
5043 return ErrInvalidLengthMetrics
5044 }
5045 postIndex := iNdEx + msglen
5046 if postIndex < 0 {
5047 return ErrInvalidLengthMetrics
5048 }
5049 if postIndex > l {
5050 return io.ErrUnexpectedEOF
5051 }
5052 m.IoQueuedRecursive = append(m.IoQueuedRecursive, &BlkIOEntry{})
5053 if err := m.IoQueuedRecursive[len(m.IoQueuedRecursive)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5054 return err
5055 }
5056 iNdEx = postIndex
5057 case 4:
5058 if wireType != 2 {
5059 return fmt.Errorf("proto: wrong wireType = %d for field IoServiceTimeRecursive", wireType)
5060 }
5061 var msglen int
5062 for shift := uint(0); ; shift += 7 {
5063 if shift >= 64 {
5064 return ErrIntOverflowMetrics
5065 }
5066 if iNdEx >= l {
5067 return io.ErrUnexpectedEOF
5068 }
5069 b := dAtA[iNdEx]
5070 iNdEx++
5071 msglen |= int(b&0x7F) << shift
5072 if b < 0x80 {
5073 break
5074 }
5075 }
5076 if msglen < 0 {
5077 return ErrInvalidLengthMetrics
5078 }
5079 postIndex := iNdEx + msglen
5080 if postIndex < 0 {
5081 return ErrInvalidLengthMetrics
5082 }
5083 if postIndex > l {
5084 return io.ErrUnexpectedEOF
5085 }
5086 m.IoServiceTimeRecursive = append(m.IoServiceTimeRecursive, &BlkIOEntry{})
5087 if err := m.IoServiceTimeRecursive[len(m.IoServiceTimeRecursive)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5088 return err
5089 }
5090 iNdEx = postIndex
5091 case 5:
5092 if wireType != 2 {
5093 return fmt.Errorf("proto: wrong wireType = %d for field IoWaitTimeRecursive", wireType)
5094 }
5095 var msglen int
5096 for shift := uint(0); ; shift += 7 {
5097 if shift >= 64 {
5098 return ErrIntOverflowMetrics
5099 }
5100 if iNdEx >= l {
5101 return io.ErrUnexpectedEOF
5102 }
5103 b := dAtA[iNdEx]
5104 iNdEx++
5105 msglen |= int(b&0x7F) << shift
5106 if b < 0x80 {
5107 break
5108 }
5109 }
5110 if msglen < 0 {
5111 return ErrInvalidLengthMetrics
5112 }
5113 postIndex := iNdEx + msglen
5114 if postIndex < 0 {
5115 return ErrInvalidLengthMetrics
5116 }
5117 if postIndex > l {
5118 return io.ErrUnexpectedEOF
5119 }
5120 m.IoWaitTimeRecursive = append(m.IoWaitTimeRecursive, &BlkIOEntry{})
5121 if err := m.IoWaitTimeRecursive[len(m.IoWaitTimeRecursive)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5122 return err
5123 }
5124 iNdEx = postIndex
5125 case 6:
5126 if wireType != 2 {
5127 return fmt.Errorf("proto: wrong wireType = %d for field IoMergedRecursive", wireType)
5128 }
5129 var msglen int
5130 for shift := uint(0); ; shift += 7 {
5131 if shift >= 64 {
5132 return ErrIntOverflowMetrics
5133 }
5134 if iNdEx >= l {
5135 return io.ErrUnexpectedEOF
5136 }
5137 b := dAtA[iNdEx]
5138 iNdEx++
5139 msglen |= int(b&0x7F) << shift
5140 if b < 0x80 {
5141 break
5142 }
5143 }
5144 if msglen < 0 {
5145 return ErrInvalidLengthMetrics
5146 }
5147 postIndex := iNdEx + msglen
5148 if postIndex < 0 {
5149 return ErrInvalidLengthMetrics
5150 }
5151 if postIndex > l {
5152 return io.ErrUnexpectedEOF
5153 }
5154 m.IoMergedRecursive = append(m.IoMergedRecursive, &BlkIOEntry{})
5155 if err := m.IoMergedRecursive[len(m.IoMergedRecursive)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5156 return err
5157 }
5158 iNdEx = postIndex
5159 case 7:
5160 if wireType != 2 {
5161 return fmt.Errorf("proto: wrong wireType = %d for field IoTimeRecursive", wireType)
5162 }
5163 var msglen int
5164 for shift := uint(0); ; shift += 7 {
5165 if shift >= 64 {
5166 return ErrIntOverflowMetrics
5167 }
5168 if iNdEx >= l {
5169 return io.ErrUnexpectedEOF
5170 }
5171 b := dAtA[iNdEx]
5172 iNdEx++
5173 msglen |= int(b&0x7F) << shift
5174 if b < 0x80 {
5175 break
5176 }
5177 }
5178 if msglen < 0 {
5179 return ErrInvalidLengthMetrics
5180 }
5181 postIndex := iNdEx + msglen
5182 if postIndex < 0 {
5183 return ErrInvalidLengthMetrics
5184 }
5185 if postIndex > l {
5186 return io.ErrUnexpectedEOF
5187 }
5188 m.IoTimeRecursive = append(m.IoTimeRecursive, &BlkIOEntry{})
5189 if err := m.IoTimeRecursive[len(m.IoTimeRecursive)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5190 return err
5191 }
5192 iNdEx = postIndex
5193 case 8:
5194 if wireType != 2 {
5195 return fmt.Errorf("proto: wrong wireType = %d for field SectorsRecursive", wireType)
5196 }
5197 var msglen int
5198 for shift := uint(0); ; shift += 7 {
5199 if shift >= 64 {
5200 return ErrIntOverflowMetrics
5201 }
5202 if iNdEx >= l {
5203 return io.ErrUnexpectedEOF
5204 }
5205 b := dAtA[iNdEx]
5206 iNdEx++
5207 msglen |= int(b&0x7F) << shift
5208 if b < 0x80 {
5209 break
5210 }
5211 }
5212 if msglen < 0 {
5213 return ErrInvalidLengthMetrics
5214 }
5215 postIndex := iNdEx + msglen
5216 if postIndex < 0 {
5217 return ErrInvalidLengthMetrics
5218 }
5219 if postIndex > l {
5220 return io.ErrUnexpectedEOF
5221 }
5222 m.SectorsRecursive = append(m.SectorsRecursive, &BlkIOEntry{})
5223 if err := m.SectorsRecursive[len(m.SectorsRecursive)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5224 return err
5225 }
5226 iNdEx = postIndex
5227 default:
5228 iNdEx = preIndex
5229 skippy, err := skipMetrics(dAtA[iNdEx:])
5230 if err != nil {
5231 return err
5232 }
5233 if (skippy < 0) || (iNdEx+skippy) < 0 {
5234 return ErrInvalidLengthMetrics
5235 }
5236 if (iNdEx + skippy) > l {
5237 return io.ErrUnexpectedEOF
5238 }
5239 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5240 iNdEx += skippy
5241 }
5242 }
5243
5244 if iNdEx > l {
5245 return io.ErrUnexpectedEOF
5246 }
5247 return nil
5248 }
5249 func (m *BlkIOEntry) Unmarshal(dAtA []byte) error {
5250 l := len(dAtA)
5251 iNdEx := 0
5252 for iNdEx < l {
5253 preIndex := iNdEx
5254 var wire uint64
5255 for shift := uint(0); ; shift += 7 {
5256 if shift >= 64 {
5257 return ErrIntOverflowMetrics
5258 }
5259 if iNdEx >= l {
5260 return io.ErrUnexpectedEOF
5261 }
5262 b := dAtA[iNdEx]
5263 iNdEx++
5264 wire |= uint64(b&0x7F) << shift
5265 if b < 0x80 {
5266 break
5267 }
5268 }
5269 fieldNum := int32(wire >> 3)
5270 wireType := int(wire & 0x7)
5271 if wireType == 4 {
5272 return fmt.Errorf("proto: BlkIOEntry: wiretype end group for non-group")
5273 }
5274 if fieldNum <= 0 {
5275 return fmt.Errorf("proto: BlkIOEntry: illegal tag %d (wire type %d)", fieldNum, wire)
5276 }
5277 switch fieldNum {
5278 case 1:
5279 if wireType != 2 {
5280 return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)
5281 }
5282 var stringLen uint64
5283 for shift := uint(0); ; shift += 7 {
5284 if shift >= 64 {
5285 return ErrIntOverflowMetrics
5286 }
5287 if iNdEx >= l {
5288 return io.ErrUnexpectedEOF
5289 }
5290 b := dAtA[iNdEx]
5291 iNdEx++
5292 stringLen |= uint64(b&0x7F) << shift
5293 if b < 0x80 {
5294 break
5295 }
5296 }
5297 intStringLen := int(stringLen)
5298 if intStringLen < 0 {
5299 return ErrInvalidLengthMetrics
5300 }
5301 postIndex := iNdEx + intStringLen
5302 if postIndex < 0 {
5303 return ErrInvalidLengthMetrics
5304 }
5305 if postIndex > l {
5306 return io.ErrUnexpectedEOF
5307 }
5308 m.Op = string(dAtA[iNdEx:postIndex])
5309 iNdEx = postIndex
5310 case 2:
5311 if wireType != 2 {
5312 return fmt.Errorf("proto: wrong wireType = %d for field Device", wireType)
5313 }
5314 var stringLen uint64
5315 for shift := uint(0); ; shift += 7 {
5316 if shift >= 64 {
5317 return ErrIntOverflowMetrics
5318 }
5319 if iNdEx >= l {
5320 return io.ErrUnexpectedEOF
5321 }
5322 b := dAtA[iNdEx]
5323 iNdEx++
5324 stringLen |= uint64(b&0x7F) << shift
5325 if b < 0x80 {
5326 break
5327 }
5328 }
5329 intStringLen := int(stringLen)
5330 if intStringLen < 0 {
5331 return ErrInvalidLengthMetrics
5332 }
5333 postIndex := iNdEx + intStringLen
5334 if postIndex < 0 {
5335 return ErrInvalidLengthMetrics
5336 }
5337 if postIndex > l {
5338 return io.ErrUnexpectedEOF
5339 }
5340 m.Device = string(dAtA[iNdEx:postIndex])
5341 iNdEx = postIndex
5342 case 3:
5343 if wireType != 0 {
5344 return fmt.Errorf("proto: wrong wireType = %d for field Major", wireType)
5345 }
5346 m.Major = 0
5347 for shift := uint(0); ; shift += 7 {
5348 if shift >= 64 {
5349 return ErrIntOverflowMetrics
5350 }
5351 if iNdEx >= l {
5352 return io.ErrUnexpectedEOF
5353 }
5354 b := dAtA[iNdEx]
5355 iNdEx++
5356 m.Major |= uint64(b&0x7F) << shift
5357 if b < 0x80 {
5358 break
5359 }
5360 }
5361 case 4:
5362 if wireType != 0 {
5363 return fmt.Errorf("proto: wrong wireType = %d for field Minor", wireType)
5364 }
5365 m.Minor = 0
5366 for shift := uint(0); ; shift += 7 {
5367 if shift >= 64 {
5368 return ErrIntOverflowMetrics
5369 }
5370 if iNdEx >= l {
5371 return io.ErrUnexpectedEOF
5372 }
5373 b := dAtA[iNdEx]
5374 iNdEx++
5375 m.Minor |= uint64(b&0x7F) << shift
5376 if b < 0x80 {
5377 break
5378 }
5379 }
5380 case 5:
5381 if wireType != 0 {
5382 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
5383 }
5384 m.Value = 0
5385 for shift := uint(0); ; shift += 7 {
5386 if shift >= 64 {
5387 return ErrIntOverflowMetrics
5388 }
5389 if iNdEx >= l {
5390 return io.ErrUnexpectedEOF
5391 }
5392 b := dAtA[iNdEx]
5393 iNdEx++
5394 m.Value |= uint64(b&0x7F) << shift
5395 if b < 0x80 {
5396 break
5397 }
5398 }
5399 default:
5400 iNdEx = preIndex
5401 skippy, err := skipMetrics(dAtA[iNdEx:])
5402 if err != nil {
5403 return err
5404 }
5405 if (skippy < 0) || (iNdEx+skippy) < 0 {
5406 return ErrInvalidLengthMetrics
5407 }
5408 if (iNdEx + skippy) > l {
5409 return io.ErrUnexpectedEOF
5410 }
5411 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5412 iNdEx += skippy
5413 }
5414 }
5415
5416 if iNdEx > l {
5417 return io.ErrUnexpectedEOF
5418 }
5419 return nil
5420 }
5421 func (m *RdmaStat) Unmarshal(dAtA []byte) error {
5422 l := len(dAtA)
5423 iNdEx := 0
5424 for iNdEx < l {
5425 preIndex := iNdEx
5426 var wire uint64
5427 for shift := uint(0); ; shift += 7 {
5428 if shift >= 64 {
5429 return ErrIntOverflowMetrics
5430 }
5431 if iNdEx >= l {
5432 return io.ErrUnexpectedEOF
5433 }
5434 b := dAtA[iNdEx]
5435 iNdEx++
5436 wire |= uint64(b&0x7F) << shift
5437 if b < 0x80 {
5438 break
5439 }
5440 }
5441 fieldNum := int32(wire >> 3)
5442 wireType := int(wire & 0x7)
5443 if wireType == 4 {
5444 return fmt.Errorf("proto: RdmaStat: wiretype end group for non-group")
5445 }
5446 if fieldNum <= 0 {
5447 return fmt.Errorf("proto: RdmaStat: illegal tag %d (wire type %d)", fieldNum, wire)
5448 }
5449 switch fieldNum {
5450 case 1:
5451 if wireType != 2 {
5452 return fmt.Errorf("proto: wrong wireType = %d for field Current", wireType)
5453 }
5454 var msglen int
5455 for shift := uint(0); ; shift += 7 {
5456 if shift >= 64 {
5457 return ErrIntOverflowMetrics
5458 }
5459 if iNdEx >= l {
5460 return io.ErrUnexpectedEOF
5461 }
5462 b := dAtA[iNdEx]
5463 iNdEx++
5464 msglen |= int(b&0x7F) << shift
5465 if b < 0x80 {
5466 break
5467 }
5468 }
5469 if msglen < 0 {
5470 return ErrInvalidLengthMetrics
5471 }
5472 postIndex := iNdEx + msglen
5473 if postIndex < 0 {
5474 return ErrInvalidLengthMetrics
5475 }
5476 if postIndex > l {
5477 return io.ErrUnexpectedEOF
5478 }
5479 m.Current = append(m.Current, &RdmaEntry{})
5480 if err := m.Current[len(m.Current)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5481 return err
5482 }
5483 iNdEx = postIndex
5484 case 2:
5485 if wireType != 2 {
5486 return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
5487 }
5488 var msglen int
5489 for shift := uint(0); ; shift += 7 {
5490 if shift >= 64 {
5491 return ErrIntOverflowMetrics
5492 }
5493 if iNdEx >= l {
5494 return io.ErrUnexpectedEOF
5495 }
5496 b := dAtA[iNdEx]
5497 iNdEx++
5498 msglen |= int(b&0x7F) << shift
5499 if b < 0x80 {
5500 break
5501 }
5502 }
5503 if msglen < 0 {
5504 return ErrInvalidLengthMetrics
5505 }
5506 postIndex := iNdEx + msglen
5507 if postIndex < 0 {
5508 return ErrInvalidLengthMetrics
5509 }
5510 if postIndex > l {
5511 return io.ErrUnexpectedEOF
5512 }
5513 m.Limit = append(m.Limit, &RdmaEntry{})
5514 if err := m.Limit[len(m.Limit)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5515 return err
5516 }
5517 iNdEx = postIndex
5518 default:
5519 iNdEx = preIndex
5520 skippy, err := skipMetrics(dAtA[iNdEx:])
5521 if err != nil {
5522 return err
5523 }
5524 if (skippy < 0) || (iNdEx+skippy) < 0 {
5525 return ErrInvalidLengthMetrics
5526 }
5527 if (iNdEx + skippy) > l {
5528 return io.ErrUnexpectedEOF
5529 }
5530 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5531 iNdEx += skippy
5532 }
5533 }
5534
5535 if iNdEx > l {
5536 return io.ErrUnexpectedEOF
5537 }
5538 return nil
5539 }
5540 func (m *RdmaEntry) Unmarshal(dAtA []byte) error {
5541 l := len(dAtA)
5542 iNdEx := 0
5543 for iNdEx < l {
5544 preIndex := iNdEx
5545 var wire uint64
5546 for shift := uint(0); ; shift += 7 {
5547 if shift >= 64 {
5548 return ErrIntOverflowMetrics
5549 }
5550 if iNdEx >= l {
5551 return io.ErrUnexpectedEOF
5552 }
5553 b := dAtA[iNdEx]
5554 iNdEx++
5555 wire |= uint64(b&0x7F) << shift
5556 if b < 0x80 {
5557 break
5558 }
5559 }
5560 fieldNum := int32(wire >> 3)
5561 wireType := int(wire & 0x7)
5562 if wireType == 4 {
5563 return fmt.Errorf("proto: RdmaEntry: wiretype end group for non-group")
5564 }
5565 if fieldNum <= 0 {
5566 return fmt.Errorf("proto: RdmaEntry: illegal tag %d (wire type %d)", fieldNum, wire)
5567 }
5568 switch fieldNum {
5569 case 1:
5570 if wireType != 2 {
5571 return fmt.Errorf("proto: wrong wireType = %d for field Device", wireType)
5572 }
5573 var stringLen uint64
5574 for shift := uint(0); ; shift += 7 {
5575 if shift >= 64 {
5576 return ErrIntOverflowMetrics
5577 }
5578 if iNdEx >= l {
5579 return io.ErrUnexpectedEOF
5580 }
5581 b := dAtA[iNdEx]
5582 iNdEx++
5583 stringLen |= uint64(b&0x7F) << shift
5584 if b < 0x80 {
5585 break
5586 }
5587 }
5588 intStringLen := int(stringLen)
5589 if intStringLen < 0 {
5590 return ErrInvalidLengthMetrics
5591 }
5592 postIndex := iNdEx + intStringLen
5593 if postIndex < 0 {
5594 return ErrInvalidLengthMetrics
5595 }
5596 if postIndex > l {
5597 return io.ErrUnexpectedEOF
5598 }
5599 m.Device = string(dAtA[iNdEx:postIndex])
5600 iNdEx = postIndex
5601 case 2:
5602 if wireType != 0 {
5603 return fmt.Errorf("proto: wrong wireType = %d for field HcaHandles", wireType)
5604 }
5605 m.HcaHandles = 0
5606 for shift := uint(0); ; shift += 7 {
5607 if shift >= 64 {
5608 return ErrIntOverflowMetrics
5609 }
5610 if iNdEx >= l {
5611 return io.ErrUnexpectedEOF
5612 }
5613 b := dAtA[iNdEx]
5614 iNdEx++
5615 m.HcaHandles |= uint32(b&0x7F) << shift
5616 if b < 0x80 {
5617 break
5618 }
5619 }
5620 case 3:
5621 if wireType != 0 {
5622 return fmt.Errorf("proto: wrong wireType = %d for field HcaObjects", wireType)
5623 }
5624 m.HcaObjects = 0
5625 for shift := uint(0); ; shift += 7 {
5626 if shift >= 64 {
5627 return ErrIntOverflowMetrics
5628 }
5629 if iNdEx >= l {
5630 return io.ErrUnexpectedEOF
5631 }
5632 b := dAtA[iNdEx]
5633 iNdEx++
5634 m.HcaObjects |= uint32(b&0x7F) << shift
5635 if b < 0x80 {
5636 break
5637 }
5638 }
5639 default:
5640 iNdEx = preIndex
5641 skippy, err := skipMetrics(dAtA[iNdEx:])
5642 if err != nil {
5643 return err
5644 }
5645 if (skippy < 0) || (iNdEx+skippy) < 0 {
5646 return ErrInvalidLengthMetrics
5647 }
5648 if (iNdEx + skippy) > l {
5649 return io.ErrUnexpectedEOF
5650 }
5651 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5652 iNdEx += skippy
5653 }
5654 }
5655
5656 if iNdEx > l {
5657 return io.ErrUnexpectedEOF
5658 }
5659 return nil
5660 }
5661 func (m *NetworkStat) Unmarshal(dAtA []byte) error {
5662 l := len(dAtA)
5663 iNdEx := 0
5664 for iNdEx < l {
5665 preIndex := iNdEx
5666 var wire uint64
5667 for shift := uint(0); ; shift += 7 {
5668 if shift >= 64 {
5669 return ErrIntOverflowMetrics
5670 }
5671 if iNdEx >= l {
5672 return io.ErrUnexpectedEOF
5673 }
5674 b := dAtA[iNdEx]
5675 iNdEx++
5676 wire |= uint64(b&0x7F) << shift
5677 if b < 0x80 {
5678 break
5679 }
5680 }
5681 fieldNum := int32(wire >> 3)
5682 wireType := int(wire & 0x7)
5683 if wireType == 4 {
5684 return fmt.Errorf("proto: NetworkStat: wiretype end group for non-group")
5685 }
5686 if fieldNum <= 0 {
5687 return fmt.Errorf("proto: NetworkStat: illegal tag %d (wire type %d)", fieldNum, wire)
5688 }
5689 switch fieldNum {
5690 case 1:
5691 if wireType != 2 {
5692 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
5693 }
5694 var stringLen uint64
5695 for shift := uint(0); ; shift += 7 {
5696 if shift >= 64 {
5697 return ErrIntOverflowMetrics
5698 }
5699 if iNdEx >= l {
5700 return io.ErrUnexpectedEOF
5701 }
5702 b := dAtA[iNdEx]
5703 iNdEx++
5704 stringLen |= uint64(b&0x7F) << shift
5705 if b < 0x80 {
5706 break
5707 }
5708 }
5709 intStringLen := int(stringLen)
5710 if intStringLen < 0 {
5711 return ErrInvalidLengthMetrics
5712 }
5713 postIndex := iNdEx + intStringLen
5714 if postIndex < 0 {
5715 return ErrInvalidLengthMetrics
5716 }
5717 if postIndex > l {
5718 return io.ErrUnexpectedEOF
5719 }
5720 m.Name = string(dAtA[iNdEx:postIndex])
5721 iNdEx = postIndex
5722 case 2:
5723 if wireType != 0 {
5724 return fmt.Errorf("proto: wrong wireType = %d for field RxBytes", wireType)
5725 }
5726 m.RxBytes = 0
5727 for shift := uint(0); ; shift += 7 {
5728 if shift >= 64 {
5729 return ErrIntOverflowMetrics
5730 }
5731 if iNdEx >= l {
5732 return io.ErrUnexpectedEOF
5733 }
5734 b := dAtA[iNdEx]
5735 iNdEx++
5736 m.RxBytes |= uint64(b&0x7F) << shift
5737 if b < 0x80 {
5738 break
5739 }
5740 }
5741 case 3:
5742 if wireType != 0 {
5743 return fmt.Errorf("proto: wrong wireType = %d for field RxPackets", wireType)
5744 }
5745 m.RxPackets = 0
5746 for shift := uint(0); ; shift += 7 {
5747 if shift >= 64 {
5748 return ErrIntOverflowMetrics
5749 }
5750 if iNdEx >= l {
5751 return io.ErrUnexpectedEOF
5752 }
5753 b := dAtA[iNdEx]
5754 iNdEx++
5755 m.RxPackets |= uint64(b&0x7F) << shift
5756 if b < 0x80 {
5757 break
5758 }
5759 }
5760 case 4:
5761 if wireType != 0 {
5762 return fmt.Errorf("proto: wrong wireType = %d for field RxErrors", wireType)
5763 }
5764 m.RxErrors = 0
5765 for shift := uint(0); ; shift += 7 {
5766 if shift >= 64 {
5767 return ErrIntOverflowMetrics
5768 }
5769 if iNdEx >= l {
5770 return io.ErrUnexpectedEOF
5771 }
5772 b := dAtA[iNdEx]
5773 iNdEx++
5774 m.RxErrors |= uint64(b&0x7F) << shift
5775 if b < 0x80 {
5776 break
5777 }
5778 }
5779 case 5:
5780 if wireType != 0 {
5781 return fmt.Errorf("proto: wrong wireType = %d for field RxDropped", wireType)
5782 }
5783 m.RxDropped = 0
5784 for shift := uint(0); ; shift += 7 {
5785 if shift >= 64 {
5786 return ErrIntOverflowMetrics
5787 }
5788 if iNdEx >= l {
5789 return io.ErrUnexpectedEOF
5790 }
5791 b := dAtA[iNdEx]
5792 iNdEx++
5793 m.RxDropped |= uint64(b&0x7F) << shift
5794 if b < 0x80 {
5795 break
5796 }
5797 }
5798 case 6:
5799 if wireType != 0 {
5800 return fmt.Errorf("proto: wrong wireType = %d for field TxBytes", wireType)
5801 }
5802 m.TxBytes = 0
5803 for shift := uint(0); ; shift += 7 {
5804 if shift >= 64 {
5805 return ErrIntOverflowMetrics
5806 }
5807 if iNdEx >= l {
5808 return io.ErrUnexpectedEOF
5809 }
5810 b := dAtA[iNdEx]
5811 iNdEx++
5812 m.TxBytes |= uint64(b&0x7F) << shift
5813 if b < 0x80 {
5814 break
5815 }
5816 }
5817 case 7:
5818 if wireType != 0 {
5819 return fmt.Errorf("proto: wrong wireType = %d for field TxPackets", wireType)
5820 }
5821 m.TxPackets = 0
5822 for shift := uint(0); ; shift += 7 {
5823 if shift >= 64 {
5824 return ErrIntOverflowMetrics
5825 }
5826 if iNdEx >= l {
5827 return io.ErrUnexpectedEOF
5828 }
5829 b := dAtA[iNdEx]
5830 iNdEx++
5831 m.TxPackets |= uint64(b&0x7F) << shift
5832 if b < 0x80 {
5833 break
5834 }
5835 }
5836 case 8:
5837 if wireType != 0 {
5838 return fmt.Errorf("proto: wrong wireType = %d for field TxErrors", wireType)
5839 }
5840 m.TxErrors = 0
5841 for shift := uint(0); ; shift += 7 {
5842 if shift >= 64 {
5843 return ErrIntOverflowMetrics
5844 }
5845 if iNdEx >= l {
5846 return io.ErrUnexpectedEOF
5847 }
5848 b := dAtA[iNdEx]
5849 iNdEx++
5850 m.TxErrors |= uint64(b&0x7F) << shift
5851 if b < 0x80 {
5852 break
5853 }
5854 }
5855 case 9:
5856 if wireType != 0 {
5857 return fmt.Errorf("proto: wrong wireType = %d for field TxDropped", wireType)
5858 }
5859 m.TxDropped = 0
5860 for shift := uint(0); ; shift += 7 {
5861 if shift >= 64 {
5862 return ErrIntOverflowMetrics
5863 }
5864 if iNdEx >= l {
5865 return io.ErrUnexpectedEOF
5866 }
5867 b := dAtA[iNdEx]
5868 iNdEx++
5869 m.TxDropped |= uint64(b&0x7F) << shift
5870 if b < 0x80 {
5871 break
5872 }
5873 }
5874 default:
5875 iNdEx = preIndex
5876 skippy, err := skipMetrics(dAtA[iNdEx:])
5877 if err != nil {
5878 return err
5879 }
5880 if (skippy < 0) || (iNdEx+skippy) < 0 {
5881 return ErrInvalidLengthMetrics
5882 }
5883 if (iNdEx + skippy) > l {
5884 return io.ErrUnexpectedEOF
5885 }
5886 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5887 iNdEx += skippy
5888 }
5889 }
5890
5891 if iNdEx > l {
5892 return io.ErrUnexpectedEOF
5893 }
5894 return nil
5895 }
5896 func (m *CgroupStats) Unmarshal(dAtA []byte) error {
5897 l := len(dAtA)
5898 iNdEx := 0
5899 for iNdEx < l {
5900 preIndex := iNdEx
5901 var wire uint64
5902 for shift := uint(0); ; shift += 7 {
5903 if shift >= 64 {
5904 return ErrIntOverflowMetrics
5905 }
5906 if iNdEx >= l {
5907 return io.ErrUnexpectedEOF
5908 }
5909 b := dAtA[iNdEx]
5910 iNdEx++
5911 wire |= uint64(b&0x7F) << shift
5912 if b < 0x80 {
5913 break
5914 }
5915 }
5916 fieldNum := int32(wire >> 3)
5917 wireType := int(wire & 0x7)
5918 if wireType == 4 {
5919 return fmt.Errorf("proto: CgroupStats: wiretype end group for non-group")
5920 }
5921 if fieldNum <= 0 {
5922 return fmt.Errorf("proto: CgroupStats: illegal tag %d (wire type %d)", fieldNum, wire)
5923 }
5924 switch fieldNum {
5925 case 1:
5926 if wireType != 0 {
5927 return fmt.Errorf("proto: wrong wireType = %d for field NrSleeping", wireType)
5928 }
5929 m.NrSleeping = 0
5930 for shift := uint(0); ; shift += 7 {
5931 if shift >= 64 {
5932 return ErrIntOverflowMetrics
5933 }
5934 if iNdEx >= l {
5935 return io.ErrUnexpectedEOF
5936 }
5937 b := dAtA[iNdEx]
5938 iNdEx++
5939 m.NrSleeping |= uint64(b&0x7F) << shift
5940 if b < 0x80 {
5941 break
5942 }
5943 }
5944 case 2:
5945 if wireType != 0 {
5946 return fmt.Errorf("proto: wrong wireType = %d for field NrRunning", wireType)
5947 }
5948 m.NrRunning = 0
5949 for shift := uint(0); ; shift += 7 {
5950 if shift >= 64 {
5951 return ErrIntOverflowMetrics
5952 }
5953 if iNdEx >= l {
5954 return io.ErrUnexpectedEOF
5955 }
5956 b := dAtA[iNdEx]
5957 iNdEx++
5958 m.NrRunning |= uint64(b&0x7F) << shift
5959 if b < 0x80 {
5960 break
5961 }
5962 }
5963 case 3:
5964 if wireType != 0 {
5965 return fmt.Errorf("proto: wrong wireType = %d for field NrStopped", wireType)
5966 }
5967 m.NrStopped = 0
5968 for shift := uint(0); ; shift += 7 {
5969 if shift >= 64 {
5970 return ErrIntOverflowMetrics
5971 }
5972 if iNdEx >= l {
5973 return io.ErrUnexpectedEOF
5974 }
5975 b := dAtA[iNdEx]
5976 iNdEx++
5977 m.NrStopped |= uint64(b&0x7F) << shift
5978 if b < 0x80 {
5979 break
5980 }
5981 }
5982 case 4:
5983 if wireType != 0 {
5984 return fmt.Errorf("proto: wrong wireType = %d for field NrUninterruptible", wireType)
5985 }
5986 m.NrUninterruptible = 0
5987 for shift := uint(0); ; shift += 7 {
5988 if shift >= 64 {
5989 return ErrIntOverflowMetrics
5990 }
5991 if iNdEx >= l {
5992 return io.ErrUnexpectedEOF
5993 }
5994 b := dAtA[iNdEx]
5995 iNdEx++
5996 m.NrUninterruptible |= uint64(b&0x7F) << shift
5997 if b < 0x80 {
5998 break
5999 }
6000 }
6001 case 5:
6002 if wireType != 0 {
6003 return fmt.Errorf("proto: wrong wireType = %d for field NrIoWait", wireType)
6004 }
6005 m.NrIoWait = 0
6006 for shift := uint(0); ; shift += 7 {
6007 if shift >= 64 {
6008 return ErrIntOverflowMetrics
6009 }
6010 if iNdEx >= l {
6011 return io.ErrUnexpectedEOF
6012 }
6013 b := dAtA[iNdEx]
6014 iNdEx++
6015 m.NrIoWait |= uint64(b&0x7F) << shift
6016 if b < 0x80 {
6017 break
6018 }
6019 }
6020 default:
6021 iNdEx = preIndex
6022 skippy, err := skipMetrics(dAtA[iNdEx:])
6023 if err != nil {
6024 return err
6025 }
6026 if (skippy < 0) || (iNdEx+skippy) < 0 {
6027 return ErrInvalidLengthMetrics
6028 }
6029 if (iNdEx + skippy) > l {
6030 return io.ErrUnexpectedEOF
6031 }
6032 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6033 iNdEx += skippy
6034 }
6035 }
6036
6037 if iNdEx > l {
6038 return io.ErrUnexpectedEOF
6039 }
6040 return nil
6041 }
6042 func skipMetrics(dAtA []byte) (n int, err error) {
6043 l := len(dAtA)
6044 iNdEx := 0
6045 depth := 0
6046 for iNdEx < l {
6047 var wire uint64
6048 for shift := uint(0); ; shift += 7 {
6049 if shift >= 64 {
6050 return 0, ErrIntOverflowMetrics
6051 }
6052 if iNdEx >= l {
6053 return 0, io.ErrUnexpectedEOF
6054 }
6055 b := dAtA[iNdEx]
6056 iNdEx++
6057 wire |= (uint64(b) & 0x7F) << shift
6058 if b < 0x80 {
6059 break
6060 }
6061 }
6062 wireType := int(wire & 0x7)
6063 switch wireType {
6064 case 0:
6065 for shift := uint(0); ; shift += 7 {
6066 if shift >= 64 {
6067 return 0, ErrIntOverflowMetrics
6068 }
6069 if iNdEx >= l {
6070 return 0, io.ErrUnexpectedEOF
6071 }
6072 iNdEx++
6073 if dAtA[iNdEx-1] < 0x80 {
6074 break
6075 }
6076 }
6077 case 1:
6078 iNdEx += 8
6079 case 2:
6080 var length int
6081 for shift := uint(0); ; shift += 7 {
6082 if shift >= 64 {
6083 return 0, ErrIntOverflowMetrics
6084 }
6085 if iNdEx >= l {
6086 return 0, io.ErrUnexpectedEOF
6087 }
6088 b := dAtA[iNdEx]
6089 iNdEx++
6090 length |= (int(b) & 0x7F) << shift
6091 if b < 0x80 {
6092 break
6093 }
6094 }
6095 if length < 0 {
6096 return 0, ErrInvalidLengthMetrics
6097 }
6098 iNdEx += length
6099 case 3:
6100 depth++
6101 case 4:
6102 if depth == 0 {
6103 return 0, ErrUnexpectedEndOfGroupMetrics
6104 }
6105 depth--
6106 case 5:
6107 iNdEx += 4
6108 default:
6109 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
6110 }
6111 if iNdEx < 0 {
6112 return 0, ErrInvalidLengthMetrics
6113 }
6114 if depth == 0 {
6115 return iNdEx, nil
6116 }
6117 }
6118 return 0, io.ErrUnexpectedEOF
6119 }
6120
6121 var (
6122 ErrInvalidLengthMetrics = fmt.Errorf("proto: negative length found during unmarshaling")
6123 ErrIntOverflowMetrics = fmt.Errorf("proto: integer overflow")
6124 ErrUnexpectedEndOfGroupMetrics = fmt.Errorf("proto: unexpected end of group")
6125 )
6126
View as plain text