diff --git a/vendor.conf b/vendor.conf index 10b2b5e9d..146990740 100644 --- a/vendor.conf +++ b/vendor.conf @@ -1,7 +1,7 @@ github.com/coreos/go-systemd 48702e0da86bd25e76cfef347e2adeb434a0d0a6 github.com/containerd/go-runc ba22f6a82e52be3be4eb4a00000fe816f4b41c2e github.com/containerd/console 76d18fd1d66972718ab2284449591db0b3cdb4de -github.com/containerd/cgroups e6d1aa8c71c6103624b2c6e6f4be0863b67027f1 +github.com/containerd/cgroups e364e5d4183340acdf51f943ba033543ecb747d3 github.com/docker/go-metrics 8fd5772bf1584597834c6f7961a530f06cbfbb87 github.com/docker/go-events 9461782956ad83b30282bf90e31fa6a70c255ba9 github.com/godbus/dbus c7fdd8b5cd55e87b4e1f4e372cdb1db61dd6c66f diff --git a/vendor/github.com/containerd/cgroups/README.md b/vendor/github.com/containerd/cgroups/README.md index 89007ebbb..69e932a9f 100644 --- a/vendor/github.com/containerd/cgroups/README.md +++ b/vendor/github.com/containerd/cgroups/README.md @@ -92,6 +92,11 @@ processes, err := control.Processes(cgroups.Devices, recursive) stats, err := control.Stat() ``` +By adding `cgroups.IgnoreNotExist` all non-existent files will be ignored, e.g. swap memory stats without swap enabled +```go +stats, err := control.Stat(cgroups.IgnoreNotExist) +``` + ### Move process across cgroups This allows you to take processes from one cgroup and move them to another. diff --git a/vendor/github.com/containerd/cgroups/blkio.go b/vendor/github.com/containerd/cgroups/blkio.go index e1fd73ce0..88f9ce9b2 100644 --- a/vendor/github.com/containerd/cgroups/blkio.go +++ b/vendor/github.com/containerd/cgroups/blkio.go @@ -56,7 +56,7 @@ func (b *blkioController) Update(path string, resources *specs.LinuxResources) e return b.Create(path, resources) } -func (b *blkioController) Stat(path string, stats *Stats) error { +func (b *blkioController) Stat(path string, stats *Metrics) error { stats.Blkio = &BlkioStat{} settings := []blkioStatSettings{ { @@ -119,7 +119,7 @@ func (b *blkioController) Stat(path string, stats *Stats) error { return nil } -func (b *blkioController) readEntry(devices map[deviceKey]string, path, name string, entry *[]BlkioEntry) error { +func (b *blkioController) readEntry(devices map[deviceKey]string, path, name string, entry *[]*BlkioEntry) error { f, err := os.Open(filepath.Join(b.Path(path), fmt.Sprintf("blkio.%s", name))) if err != nil { return err @@ -158,7 +158,7 @@ func (b *blkioController) readEntry(devices map[deviceKey]string, path, name str if err != nil { return err } - *entry = append(*entry, BlkioEntry{ + *entry = append(*entry, &BlkioEntry{ Device: devices[deviceKey{major, minor}], Major: major, Minor: minor, @@ -235,7 +235,7 @@ type blkioSettings struct { type blkioStatSettings struct { name string - entry *[]BlkioEntry + entry *[]*BlkioEntry } func uintf(v interface{}) []byte { diff --git a/vendor/github.com/containerd/cgroups/cgroup.go b/vendor/github.com/containerd/cgroups/cgroup.go index 74a324f9e..5070bd68f 100644 --- a/vendor/github.com/containerd/cgroups/cgroup.go +++ b/vendor/github.com/containerd/cgroups/cgroup.go @@ -154,8 +154,8 @@ func (c *cgroup) Delete() error { return nil } -// Stat returns the current stats for the cgroup -func (c *cgroup) Stat(handlers ...ErrorHandler) (*Stats, error) { +// Stat returns the current metrics for the cgroup +func (c *cgroup) Stat(handlers ...ErrorHandler) (*Metrics, error) { c.mu.Lock() defer c.mu.Unlock() if c.err != nil { @@ -165,9 +165,11 @@ func (c *cgroup) Stat(handlers ...ErrorHandler) (*Stats, error) { handlers = append(handlers, errPassthrough) } var ( - stats = &Stats{} - wg = &sync.WaitGroup{} - errs = make(chan error, len(c.subsystems)) + stats = &Metrics{ + Cpu: &CpuStat{}, + } + wg = &sync.WaitGroup{} + errs = make(chan error, len(c.subsystems)) ) for _, s := range c.subsystems { if ss, ok := s.(stater); ok { diff --git a/vendor/github.com/containerd/cgroups/control.go b/vendor/github.com/containerd/cgroups/control.go index c83b2417f..2de26732c 100644 --- a/vendor/github.com/containerd/cgroups/control.go +++ b/vendor/github.com/containerd/cgroups/control.go @@ -40,7 +40,7 @@ type Cgroup interface { // subsystems are moved one at a time MoveTo(Cgroup) error // Stat returns the stats for all subsystems in the cgroup - Stat(...ErrorHandler) (*Stats, error) + Stat(...ErrorHandler) (*Metrics, error) // Update updates all the subsystems with the provided resource changes Update(resources *specs.LinuxResources) error // Processes returns all the processes in a select subsystem for the cgroup diff --git a/vendor/github.com/containerd/cgroups/cpu.go b/vendor/github.com/containerd/cgroups/cpu.go index 036bb8fd0..54bcef648 100644 --- a/vendor/github.com/containerd/cgroups/cpu.go +++ b/vendor/github.com/containerd/cgroups/cpu.go @@ -84,20 +84,13 @@ func (c *cpuController) Update(path string, resources *specs.LinuxResources) err return c.Create(path, resources) } -func (c *cpuController) Stat(path string, stats *Stats) error { +func (c *cpuController) Stat(path string, stats *Metrics) error { f, err := os.Open(filepath.Join(c.Path(path), "cpu.stat")) if err != nil { return err } defer f.Close() // get or create the cpu field because cpuacct can also set values on this struct - stats.cpuMu.Lock() - cpu := stats.Cpu - if cpu == nil { - cpu = &CpuStat{} - stats.Cpu = cpu - } - stats.cpuMu.Unlock() sc := bufio.NewScanner(f) for sc.Scan() { if err := sc.Err(); err != nil { @@ -109,11 +102,11 @@ func (c *cpuController) Stat(path string, stats *Stats) error { } switch key { case "nr_periods": - cpu.Throttling.Periods = v + stats.Cpu.Throttling.Periods = v case "nr_throttled": - cpu.Throttling.ThrottledPeriods = v + stats.Cpu.Throttling.ThrottledPeriods = v case "throttled_time": - cpu.Throttling.ThrottledTime = v + stats.Cpu.Throttling.ThrottledTime = v } } return nil diff --git a/vendor/github.com/containerd/cgroups/cpuacct.go b/vendor/github.com/containerd/cgroups/cpuacct.go index 329234887..58fbbdf4e 100644 --- a/vendor/github.com/containerd/cgroups/cpuacct.go +++ b/vendor/github.com/containerd/cgroups/cpuacct.go @@ -30,7 +30,7 @@ func (c *cpuacctController) Path(path string) string { return filepath.Join(c.root, path) } -func (c *cpuacctController) Stat(path string, stats *Stats) error { +func (c *cpuacctController) Stat(path string, stats *Metrics) error { user, kernel, err := c.getUsage(path) if err != nil { return err @@ -43,17 +43,10 @@ func (c *cpuacctController) Stat(path string, stats *Stats) error { if err != nil { return err } - stats.cpuMu.Lock() - cpu := stats.Cpu - if cpu == nil { - cpu = &CpuStat{} - stats.Cpu = cpu - } - stats.cpuMu.Unlock() - cpu.Usage.Total = total - cpu.Usage.User = user - cpu.Usage.Kernel = kernel - cpu.Usage.PerCpu = percpu + stats.Cpu.Usage.Total = total + stats.Cpu.Usage.User = user + stats.Cpu.Usage.Kernel = kernel + stats.Cpu.Usage.PerCpu = percpu return nil } diff --git a/vendor/github.com/containerd/cgroups/hugetlb.go b/vendor/github.com/containerd/cgroups/hugetlb.go index 650bb069f..20241b0d2 100644 --- a/vendor/github.com/containerd/cgroups/hugetlb.go +++ b/vendor/github.com/containerd/cgroups/hugetlb.go @@ -51,8 +51,8 @@ func (h *hugetlbController) Create(path string, resources *specs.LinuxResources) return nil } -func (h *hugetlbController) Stat(path string, stats *Stats) error { - stats.Hugetlb = make(map[string]HugetlbStat) +func (h *hugetlbController) Stat(path string, stats *Metrics) error { + stats.Hugetlb = make(map[string]*HugetlbStat) for _, size := range h.sizes { s, err := h.readSizeStat(path, size) if err != nil { @@ -63,7 +63,7 @@ func (h *hugetlbController) Stat(path string, stats *Stats) error { return nil } -func (h *hugetlbController) readSizeStat(path, size string) (HugetlbStat, error) { +func (h *hugetlbController) readSizeStat(path, size string) (*HugetlbStat, error) { var s HugetlbStat for _, t := range []struct { name string @@ -84,9 +84,9 @@ func (h *hugetlbController) readSizeStat(path, size string) (HugetlbStat, error) } { v, err := readUint(filepath.Join(h.Path(path), strings.Join([]string{"hugetlb", size, t.name}, "."))) if err != nil { - return s, err + return nil, err } *t.value = v } - return s, nil + return &s, nil } diff --git a/vendor/github.com/containerd/cgroups/memory.go b/vendor/github.com/containerd/cgroups/memory.go index 9e2ddf2e4..148a66701 100644 --- a/vendor/github.com/containerd/cgroups/memory.go +++ b/vendor/github.com/containerd/cgroups/memory.go @@ -81,7 +81,7 @@ func (m *memoryController) Update(path string, resources *specs.LinuxResources) return m.set(path, settings) } -func (m *memoryController) Stat(path string, stats *Stats) error { +func (m *memoryController) Stat(path string, stats *Metrics) error { f, err := os.Open(filepath.Join(m.Path(path), "memory.stat")) if err != nil { return err @@ -97,19 +97,19 @@ func (m *memoryController) Stat(path string, stats *Stats) error { }{ { module: "", - entry: &stats.Memory.Usage, + entry: stats.Memory.Usage, }, { module: "memsw", - entry: &stats.Memory.Swap, + entry: stats.Memory.Swap, }, { module: "kmem", - entry: &stats.Memory.Kernel, + entry: stats.Memory.Kernel, }, { module: "kmem.tcp", - entry: &stats.Memory.KernelTCP, + entry: stats.Memory.KernelTcp, }, } { for _, tt := range []struct { @@ -194,8 +194,8 @@ func (m *memoryController) parseStats(r io.Reader, stat *MemoryStat) error { line++ } stat.Cache = raw["cache"] - stat.RSS = raw["rss"] - stat.RSSHuge = raw["rss_huge"] + stat.Rss = raw["rss"] + stat.RssHuge = raw["rss_huge"] stat.MappedFile = raw["mapped_file"] stat.Dirty = raw["dirty"] stat.Writeback = raw["writeback"] @@ -211,8 +211,8 @@ func (m *memoryController) parseStats(r io.Reader, stat *MemoryStat) error { stat.HierarchicalMemoryLimit = raw["hierarchical_memory_limit"] stat.HierarchicalSwapLimit = raw["hierarchical_memsw_limit"] stat.TotalCache = raw["total_cache"] - stat.TotalRSS = raw["total_rss"] - stat.TotalRSSHuge = raw["total_rss_huge"] + stat.TotalRss = raw["total_rss"] + stat.TotalRssHuge = raw["total_rss_huge"] stat.TotalMappedFile = raw["total_mapped_file"] stat.TotalDirty = raw["total_dirty"] stat.TotalWriteback = raw["total_writeback"] diff --git a/vendor/github.com/containerd/cgroups/metrics.pb.go b/vendor/github.com/containerd/cgroups/metrics.pb.go new file mode 100644 index 000000000..2ec1ed5d6 --- /dev/null +++ b/vendor/github.com/containerd/cgroups/metrics.pb.go @@ -0,0 +1,787 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: metrics.proto + +/* +Package cgroups is a generated protocol buffer package. + +It is generated from these files: + metrics.proto + +It has these top-level messages: + Metrics + HugetlbStat + PidsStat + CpuStat + CpuUsage + Throttle + MemoryStat + MemoryEntry + BlkioStat + BlkioEntry +*/ +package cgroups + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + +type Metrics struct { + Hugetlb map[string]*HugetlbStat `protobuf:"bytes,1,rep,name=hugetlb" json:"hugetlb,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Pids *PidsStat `protobuf:"bytes,2,opt,name=pids" json:"pids,omitempty"` + Cpu *CpuStat `protobuf:"bytes,3,opt,name=cpu" json:"cpu,omitempty"` + Memory *MemoryStat `protobuf:"bytes,4,opt,name=memory" json:"memory,omitempty"` + Blkio *BlkioStat `protobuf:"bytes,5,opt,name=blkio" json:"blkio,omitempty"` +} + +func (m *Metrics) Reset() { *m = Metrics{} } +func (m *Metrics) String() string { return proto.CompactTextString(m) } +func (*Metrics) ProtoMessage() {} +func (*Metrics) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } + +func (m *Metrics) GetHugetlb() map[string]*HugetlbStat { + if m != nil { + return m.Hugetlb + } + return nil +} + +func (m *Metrics) GetPids() *PidsStat { + if m != nil { + return m.Pids + } + return nil +} + +func (m *Metrics) GetCpu() *CpuStat { + if m != nil { + return m.Cpu + } + return nil +} + +func (m *Metrics) GetMemory() *MemoryStat { + if m != nil { + return m.Memory + } + return nil +} + +func (m *Metrics) GetBlkio() *BlkioStat { + if m != nil { + return m.Blkio + } + return nil +} + +type HugetlbStat struct { + Usage uint64 `protobuf:"varint,1,opt,name=usage" json:"usage,omitempty"` + Max uint64 `protobuf:"varint,2,opt,name=max" json:"max,omitempty"` + Failcnt uint64 `protobuf:"varint,3,opt,name=failcnt" json:"failcnt,omitempty"` +} + +func (m *HugetlbStat) Reset() { *m = HugetlbStat{} } +func (m *HugetlbStat) String() string { return proto.CompactTextString(m) } +func (*HugetlbStat) ProtoMessage() {} +func (*HugetlbStat) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } + +func (m *HugetlbStat) GetUsage() uint64 { + if m != nil { + return m.Usage + } + return 0 +} + +func (m *HugetlbStat) GetMax() uint64 { + if m != nil { + return m.Max + } + return 0 +} + +func (m *HugetlbStat) GetFailcnt() uint64 { + if m != nil { + return m.Failcnt + } + return 0 +} + +type PidsStat struct { + Current uint64 `protobuf:"varint,1,opt,name=current" json:"current,omitempty"` + Limit uint64 `protobuf:"varint,2,opt,name=limit" json:"limit,omitempty"` +} + +func (m *PidsStat) Reset() { *m = PidsStat{} } +func (m *PidsStat) String() string { return proto.CompactTextString(m) } +func (*PidsStat) ProtoMessage() {} +func (*PidsStat) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } + +func (m *PidsStat) GetCurrent() uint64 { + if m != nil { + return m.Current + } + return 0 +} + +func (m *PidsStat) GetLimit() uint64 { + if m != nil { + return m.Limit + } + return 0 +} + +type CpuStat struct { + Usage *CpuUsage `protobuf:"bytes,1,opt,name=usage" json:"usage,omitempty"` + Throttling *Throttle `protobuf:"bytes,2,opt,name=throttling" json:"throttling,omitempty"` +} + +func (m *CpuStat) Reset() { *m = CpuStat{} } +func (m *CpuStat) String() string { return proto.CompactTextString(m) } +func (*CpuStat) ProtoMessage() {} +func (*CpuStat) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } + +func (m *CpuStat) GetUsage() *CpuUsage { + if m != nil { + return m.Usage + } + return nil +} + +func (m *CpuStat) GetThrottling() *Throttle { + if m != nil { + return m.Throttling + } + return nil +} + +type CpuUsage struct { + // values in nanoseconds + Total uint64 `protobuf:"varint,1,opt,name=total" json:"total,omitempty"` + Kernel uint64 `protobuf:"varint,2,opt,name=kernel" json:"kernel,omitempty"` + User uint64 `protobuf:"varint,3,opt,name=user" json:"user,omitempty"` + PerCpu []uint64 `protobuf:"varint,4,rep,packed,name=per_cpu,json=perCpu" json:"per_cpu,omitempty"` +} + +func (m *CpuUsage) Reset() { *m = CpuUsage{} } +func (m *CpuUsage) String() string { return proto.CompactTextString(m) } +func (*CpuUsage) ProtoMessage() {} +func (*CpuUsage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } + +func (m *CpuUsage) GetTotal() uint64 { + if m != nil { + return m.Total + } + return 0 +} + +func (m *CpuUsage) GetKernel() uint64 { + if m != nil { + return m.Kernel + } + return 0 +} + +func (m *CpuUsage) GetUser() uint64 { + if m != nil { + return m.User + } + return 0 +} + +func (m *CpuUsage) GetPerCpu() []uint64 { + if m != nil { + return m.PerCpu + } + return nil +} + +type Throttle struct { + Periods uint64 `protobuf:"varint,1,opt,name=periods" json:"periods,omitempty"` + ThrottledPeriods uint64 `protobuf:"varint,2,opt,name=throttled_periods,json=throttledPeriods" json:"throttled_periods,omitempty"` + ThrottledTime uint64 `protobuf:"varint,3,opt,name=throttled_time,json=throttledTime" json:"throttled_time,omitempty"` +} + +func (m *Throttle) Reset() { *m = Throttle{} } +func (m *Throttle) String() string { return proto.CompactTextString(m) } +func (*Throttle) ProtoMessage() {} +func (*Throttle) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} } + +func (m *Throttle) GetPeriods() uint64 { + if m != nil { + return m.Periods + } + return 0 +} + +func (m *Throttle) GetThrottledPeriods() uint64 { + if m != nil { + return m.ThrottledPeriods + } + return 0 +} + +func (m *Throttle) GetThrottledTime() uint64 { + if m != nil { + return m.ThrottledTime + } + return 0 +} + +type MemoryStat struct { + Cache uint64 `protobuf:"varint,1,opt,name=cache" json:"cache,omitempty"` + Rss uint64 `protobuf:"varint,2,opt,name=rss" json:"rss,omitempty"` + RssHuge uint64 `protobuf:"varint,3,opt,name=rss_huge,json=rssHuge" json:"rss_huge,omitempty"` + MappedFile uint64 `protobuf:"varint,4,opt,name=mapped_file,json=mappedFile" json:"mapped_file,omitempty"` + Dirty uint64 `protobuf:"varint,5,opt,name=dirty" json:"dirty,omitempty"` + Writeback uint64 `protobuf:"varint,6,opt,name=writeback" json:"writeback,omitempty"` + PgPgIn uint64 `protobuf:"varint,7,opt,name=pg_pg_in,json=pgPgIn" json:"pg_pg_in,omitempty"` + PgPgOut uint64 `protobuf:"varint,8,opt,name=pg_pg_out,json=pgPgOut" json:"pg_pg_out,omitempty"` + PgFault uint64 `protobuf:"varint,9,opt,name=pg_fault,json=pgFault" json:"pg_fault,omitempty"` + PgMajFault uint64 `protobuf:"varint,10,opt,name=pg_maj_fault,json=pgMajFault" json:"pg_maj_fault,omitempty"` + InactiveAnon uint64 `protobuf:"varint,11,opt,name=inactive_anon,json=inactiveAnon" json:"inactive_anon,omitempty"` + ActiveAnon uint64 `protobuf:"varint,12,opt,name=active_anon,json=activeAnon" json:"active_anon,omitempty"` + InactiveFile uint64 `protobuf:"varint,13,opt,name=inactive_file,json=inactiveFile" json:"inactive_file,omitempty"` + ActiveFile uint64 `protobuf:"varint,14,opt,name=active_file,json=activeFile" json:"active_file,omitempty"` + Unevictable uint64 `protobuf:"varint,15,opt,name=unevictable" json:"unevictable,omitempty"` + HierarchicalMemoryLimit uint64 `protobuf:"varint,16,opt,name=hierarchical_memory_limit,json=hierarchicalMemoryLimit" json:"hierarchical_memory_limit,omitempty"` + HierarchicalSwapLimit uint64 `protobuf:"varint,17,opt,name=hierarchical_swap_limit,json=hierarchicalSwapLimit" json:"hierarchical_swap_limit,omitempty"` + TotalCache uint64 `protobuf:"varint,18,opt,name=total_cache,json=totalCache" json:"total_cache,omitempty"` + TotalRss uint64 `protobuf:"varint,19,opt,name=total_rss,json=totalRss" json:"total_rss,omitempty"` + TotalRssHuge uint64 `protobuf:"varint,20,opt,name=total_rss_huge,json=totalRssHuge" json:"total_rss_huge,omitempty"` + TotalMappedFile uint64 `protobuf:"varint,21,opt,name=total_mapped_file,json=totalMappedFile" json:"total_mapped_file,omitempty"` + TotalDirty uint64 `protobuf:"varint,22,opt,name=total_dirty,json=totalDirty" json:"total_dirty,omitempty"` + TotalWriteback uint64 `protobuf:"varint,23,opt,name=total_writeback,json=totalWriteback" json:"total_writeback,omitempty"` + TotalPgPgIn uint64 `protobuf:"varint,24,opt,name=total_pg_pg_in,json=totalPgPgIn" json:"total_pg_pg_in,omitempty"` + TotalPgPgOut uint64 `protobuf:"varint,25,opt,name=total_pg_pg_out,json=totalPgPgOut" json:"total_pg_pg_out,omitempty"` + TotalPgFault uint64 `protobuf:"varint,26,opt,name=total_pg_fault,json=totalPgFault" json:"total_pg_fault,omitempty"` + TotalPgMajFault uint64 `protobuf:"varint,27,opt,name=total_pg_maj_fault,json=totalPgMajFault" json:"total_pg_maj_fault,omitempty"` + TotalInactiveAnon uint64 `protobuf:"varint,28,opt,name=total_inactive_anon,json=totalInactiveAnon" json:"total_inactive_anon,omitempty"` + TotalActiveAnon uint64 `protobuf:"varint,29,opt,name=total_active_anon,json=totalActiveAnon" json:"total_active_anon,omitempty"` + TotalInactiveFile uint64 `protobuf:"varint,30,opt,name=total_inactive_file,json=totalInactiveFile" json:"total_inactive_file,omitempty"` + TotalActiveFile uint64 `protobuf:"varint,31,opt,name=total_active_file,json=totalActiveFile" json:"total_active_file,omitempty"` + TotalUnevictable uint64 `protobuf:"varint,32,opt,name=total_unevictable,json=totalUnevictable" json:"total_unevictable,omitempty"` + Usage *MemoryEntry `protobuf:"bytes,33,opt,name=usage" json:"usage,omitempty"` + Swap *MemoryEntry `protobuf:"bytes,34,opt,name=swap" json:"swap,omitempty"` + Kernel *MemoryEntry `protobuf:"bytes,35,opt,name=kernel" json:"kernel,omitempty"` + KernelTcp *MemoryEntry `protobuf:"bytes,36,opt,name=kernel_tcp,json=kernelTcp" json:"kernel_tcp,omitempty"` +} + +func (m *MemoryStat) Reset() { *m = MemoryStat{} } +func (m *MemoryStat) String() string { return proto.CompactTextString(m) } +func (*MemoryStat) ProtoMessage() {} +func (*MemoryStat) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} } + +func (m *MemoryStat) GetCache() uint64 { + if m != nil { + return m.Cache + } + return 0 +} + +func (m *MemoryStat) GetRss() uint64 { + if m != nil { + return m.Rss + } + return 0 +} + +func (m *MemoryStat) GetRssHuge() uint64 { + if m != nil { + return m.RssHuge + } + return 0 +} + +func (m *MemoryStat) GetMappedFile() uint64 { + if m != nil { + return m.MappedFile + } + return 0 +} + +func (m *MemoryStat) GetDirty() uint64 { + if m != nil { + return m.Dirty + } + return 0 +} + +func (m *MemoryStat) GetWriteback() uint64 { + if m != nil { + return m.Writeback + } + return 0 +} + +func (m *MemoryStat) GetPgPgIn() uint64 { + if m != nil { + return m.PgPgIn + } + return 0 +} + +func (m *MemoryStat) GetPgPgOut() uint64 { + if m != nil { + return m.PgPgOut + } + return 0 +} + +func (m *MemoryStat) GetPgFault() uint64 { + if m != nil { + return m.PgFault + } + return 0 +} + +func (m *MemoryStat) GetPgMajFault() uint64 { + if m != nil { + return m.PgMajFault + } + return 0 +} + +func (m *MemoryStat) GetInactiveAnon() uint64 { + if m != nil { + return m.InactiveAnon + } + return 0 +} + +func (m *MemoryStat) GetActiveAnon() uint64 { + if m != nil { + return m.ActiveAnon + } + return 0 +} + +func (m *MemoryStat) GetInactiveFile() uint64 { + if m != nil { + return m.InactiveFile + } + return 0 +} + +func (m *MemoryStat) GetActiveFile() uint64 { + if m != nil { + return m.ActiveFile + } + return 0 +} + +func (m *MemoryStat) GetUnevictable() uint64 { + if m != nil { + return m.Unevictable + } + return 0 +} + +func (m *MemoryStat) GetHierarchicalMemoryLimit() uint64 { + if m != nil { + return m.HierarchicalMemoryLimit + } + return 0 +} + +func (m *MemoryStat) GetHierarchicalSwapLimit() uint64 { + if m != nil { + return m.HierarchicalSwapLimit + } + return 0 +} + +func (m *MemoryStat) GetTotalCache() uint64 { + if m != nil { + return m.TotalCache + } + return 0 +} + +func (m *MemoryStat) GetTotalRss() uint64 { + if m != nil { + return m.TotalRss + } + return 0 +} + +func (m *MemoryStat) GetTotalRssHuge() uint64 { + if m != nil { + return m.TotalRssHuge + } + return 0 +} + +func (m *MemoryStat) GetTotalMappedFile() uint64 { + if m != nil { + return m.TotalMappedFile + } + return 0 +} + +func (m *MemoryStat) GetTotalDirty() uint64 { + if m != nil { + return m.TotalDirty + } + return 0 +} + +func (m *MemoryStat) GetTotalWriteback() uint64 { + if m != nil { + return m.TotalWriteback + } + return 0 +} + +func (m *MemoryStat) GetTotalPgPgIn() uint64 { + if m != nil { + return m.TotalPgPgIn + } + return 0 +} + +func (m *MemoryStat) GetTotalPgPgOut() uint64 { + if m != nil { + return m.TotalPgPgOut + } + return 0 +} + +func (m *MemoryStat) GetTotalPgFault() uint64 { + if m != nil { + return m.TotalPgFault + } + return 0 +} + +func (m *MemoryStat) GetTotalPgMajFault() uint64 { + if m != nil { + return m.TotalPgMajFault + } + return 0 +} + +func (m *MemoryStat) GetTotalInactiveAnon() uint64 { + if m != nil { + return m.TotalInactiveAnon + } + return 0 +} + +func (m *MemoryStat) GetTotalActiveAnon() uint64 { + if m != nil { + return m.TotalActiveAnon + } + return 0 +} + +func (m *MemoryStat) GetTotalInactiveFile() uint64 { + if m != nil { + return m.TotalInactiveFile + } + return 0 +} + +func (m *MemoryStat) GetTotalActiveFile() uint64 { + if m != nil { + return m.TotalActiveFile + } + return 0 +} + +func (m *MemoryStat) GetTotalUnevictable() uint64 { + if m != nil { + return m.TotalUnevictable + } + return 0 +} + +func (m *MemoryStat) GetUsage() *MemoryEntry { + if m != nil { + return m.Usage + } + return nil +} + +func (m *MemoryStat) GetSwap() *MemoryEntry { + if m != nil { + return m.Swap + } + return nil +} + +func (m *MemoryStat) GetKernel() *MemoryEntry { + if m != nil { + return m.Kernel + } + return nil +} + +func (m *MemoryStat) GetKernelTcp() *MemoryEntry { + if m != nil { + return m.KernelTcp + } + return nil +} + +type MemoryEntry struct { + Limit uint64 `protobuf:"varint,1,opt,name=limit" json:"limit,omitempty"` + Usage uint64 `protobuf:"varint,2,opt,name=usage" json:"usage,omitempty"` + Max uint64 `protobuf:"varint,3,opt,name=max" json:"max,omitempty"` + Failcnt uint64 `protobuf:"varint,4,opt,name=failcnt" json:"failcnt,omitempty"` +} + +func (m *MemoryEntry) Reset() { *m = MemoryEntry{} } +func (m *MemoryEntry) String() string { return proto.CompactTextString(m) } +func (*MemoryEntry) ProtoMessage() {} +func (*MemoryEntry) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } + +func (m *MemoryEntry) GetLimit() uint64 { + if m != nil { + return m.Limit + } + return 0 +} + +func (m *MemoryEntry) GetUsage() uint64 { + if m != nil { + return m.Usage + } + return 0 +} + +func (m *MemoryEntry) GetMax() uint64 { + if m != nil { + return m.Max + } + return 0 +} + +func (m *MemoryEntry) GetFailcnt() uint64 { + if m != nil { + return m.Failcnt + } + return 0 +} + +type BlkioStat struct { + IoServiceBytesRecursive []*BlkioEntry `protobuf:"bytes,1,rep,name=io_service_bytes_recursive,json=ioServiceBytesRecursive" json:"io_service_bytes_recursive,omitempty"` + IoServicedRecursive []*BlkioEntry `protobuf:"bytes,2,rep,name=io_serviced_recursive,json=ioServicedRecursive" json:"io_serviced_recursive,omitempty"` + IoQueuedRecursive []*BlkioEntry `protobuf:"bytes,3,rep,name=io_queued_recursive,json=ioQueuedRecursive" json:"io_queued_recursive,omitempty"` + IoServiceTimeRecursive []*BlkioEntry `protobuf:"bytes,4,rep,name=io_service_time_recursive,json=ioServiceTimeRecursive" json:"io_service_time_recursive,omitempty"` + IoWaitTimeRecursive []*BlkioEntry `protobuf:"bytes,5,rep,name=io_wait_time_recursive,json=ioWaitTimeRecursive" json:"io_wait_time_recursive,omitempty"` + IoMergedRecursive []*BlkioEntry `protobuf:"bytes,6,rep,name=io_merged_recursive,json=ioMergedRecursive" json:"io_merged_recursive,omitempty"` + IoTimeRecursive []*BlkioEntry `protobuf:"bytes,7,rep,name=io_time_recursive,json=ioTimeRecursive" json:"io_time_recursive,omitempty"` + SectorsRecursive []*BlkioEntry `protobuf:"bytes,8,rep,name=sectors_recursive,json=sectorsRecursive" json:"sectors_recursive,omitempty"` +} + +func (m *BlkioStat) Reset() { *m = BlkioStat{} } +func (m *BlkioStat) String() string { return proto.CompactTextString(m) } +func (*BlkioStat) ProtoMessage() {} +func (*BlkioStat) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} } + +func (m *BlkioStat) GetIoServiceBytesRecursive() []*BlkioEntry { + if m != nil { + return m.IoServiceBytesRecursive + } + return nil +} + +func (m *BlkioStat) GetIoServicedRecursive() []*BlkioEntry { + if m != nil { + return m.IoServicedRecursive + } + return nil +} + +func (m *BlkioStat) GetIoQueuedRecursive() []*BlkioEntry { + if m != nil { + return m.IoQueuedRecursive + } + return nil +} + +func (m *BlkioStat) GetIoServiceTimeRecursive() []*BlkioEntry { + if m != nil { + return m.IoServiceTimeRecursive + } + return nil +} + +func (m *BlkioStat) GetIoWaitTimeRecursive() []*BlkioEntry { + if m != nil { + return m.IoWaitTimeRecursive + } + return nil +} + +func (m *BlkioStat) GetIoMergedRecursive() []*BlkioEntry { + if m != nil { + return m.IoMergedRecursive + } + return nil +} + +func (m *BlkioStat) GetIoTimeRecursive() []*BlkioEntry { + if m != nil { + return m.IoTimeRecursive + } + return nil +} + +func (m *BlkioStat) GetSectorsRecursive() []*BlkioEntry { + if m != nil { + return m.SectorsRecursive + } + return nil +} + +type BlkioEntry struct { + Op string `protobuf:"bytes,1,opt,name=op" json:"op,omitempty"` + Device string `protobuf:"bytes,2,opt,name=device" json:"device,omitempty"` + Major uint64 `protobuf:"varint,3,opt,name=major" json:"major,omitempty"` + Minor uint64 `protobuf:"varint,4,opt,name=minor" json:"minor,omitempty"` + Value uint64 `protobuf:"varint,5,opt,name=value" json:"value,omitempty"` +} + +func (m *BlkioEntry) Reset() { *m = BlkioEntry{} } +func (m *BlkioEntry) String() string { return proto.CompactTextString(m) } +func (*BlkioEntry) ProtoMessage() {} +func (*BlkioEntry) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} } + +func (m *BlkioEntry) GetOp() string { + if m != nil { + return m.Op + } + return "" +} + +func (m *BlkioEntry) GetDevice() string { + if m != nil { + return m.Device + } + return "" +} + +func (m *BlkioEntry) GetMajor() uint64 { + if m != nil { + return m.Major + } + return 0 +} + +func (m *BlkioEntry) GetMinor() uint64 { + if m != nil { + return m.Minor + } + return 0 +} + +func (m *BlkioEntry) GetValue() uint64 { + if m != nil { + return m.Value + } + return 0 +} + +func init() { + proto.RegisterType((*Metrics)(nil), "cgroups.Metrics") + proto.RegisterType((*HugetlbStat)(nil), "cgroups.HugetlbStat") + proto.RegisterType((*PidsStat)(nil), "cgroups.PidsStat") + proto.RegisterType((*CpuStat)(nil), "cgroups.CpuStat") + proto.RegisterType((*CpuUsage)(nil), "cgroups.CpuUsage") + proto.RegisterType((*Throttle)(nil), "cgroups.Throttle") + proto.RegisterType((*MemoryStat)(nil), "cgroups.MemoryStat") + proto.RegisterType((*MemoryEntry)(nil), "cgroups.MemoryEntry") + proto.RegisterType((*BlkioStat)(nil), "cgroups.BlkioStat") + proto.RegisterType((*BlkioEntry)(nil), "cgroups.BlkioEntry") +} + +func init() { proto.RegisterFile("metrics.proto", fileDescriptor0) } + +var fileDescriptor0 = []byte{ + // 1175 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x96, 0x6f, 0x6f, 0xdb, 0x36, + 0x10, 0xc6, 0x61, 0x5b, 0x89, 0xed, 0x73, 0x92, 0xc6, 0x74, 0x9b, 0x28, 0x69, 0xbb, 0x7a, 0x6e, + 0x8b, 0x06, 0xc9, 0x10, 0x60, 0x2d, 0xb0, 0x0d, 0x79, 0xb3, 0xb5, 0xd9, 0xba, 0x16, 0x58, 0x56, + 0x4f, 0x49, 0xd1, 0x97, 0x82, 0x2c, 0x33, 0x0a, 0x13, 0x59, 0xe4, 0x28, 0xca, 0x69, 0xbe, 0xd8, + 0xbe, 0xc5, 0x80, 0x7d, 0xa4, 0x81, 0x47, 0x4a, 0xa2, 0xf3, 0xef, 0x9d, 0x8e, 0xf7, 0xe3, 0xa3, + 0xe3, 0xf1, 0x91, 0x48, 0x58, 0x9d, 0x51, 0x25, 0x59, 0x9c, 0xef, 0x0b, 0xc9, 0x15, 0x27, 0xed, + 0x38, 0x91, 0xbc, 0x10, 0xf9, 0xe8, 0x9f, 0x26, 0xb4, 0x8f, 0x4c, 0x8a, 0xfc, 0x08, 0xed, 0xb3, + 0x22, 0xa1, 0x2a, 0x9d, 0xf8, 0x8d, 0x61, 0x6b, 0xa7, 0xf7, 0xfa, 0xe9, 0xbe, 0xc5, 0xf6, 0x2d, + 0xb2, 0xff, 0xc1, 0xe4, 0x7f, 0xcb, 0x94, 0xbc, 0x0a, 0x4a, 0x9a, 0xbc, 0x04, 0x4f, 0xb0, 0x69, + 0xee, 0x37, 0x87, 0x8d, 0x9d, 0xde, 0xeb, 0x7e, 0x35, 0x6b, 0xcc, 0xa6, 0xf9, 0xb1, 0x8a, 0x54, + 0x80, 0x69, 0x32, 0x82, 0x56, 0x2c, 0x0a, 0xbf, 0x85, 0xd4, 0x7a, 0x45, 0x1d, 0x8a, 0x02, 0x21, + 0x9d, 0x24, 0x7b, 0xb0, 0x3c, 0xa3, 0x33, 0x2e, 0xaf, 0x7c, 0x0f, 0xb1, 0x81, 0x53, 0x82, 0x1e, + 0x46, 0xd2, 0x22, 0x64, 0x07, 0x96, 0x26, 0xe9, 0x05, 0xe3, 0xfe, 0x12, 0xb2, 0xa4, 0x62, 0xdf, + 0xe9, 0x51, 0x44, 0x0d, 0xb0, 0x3d, 0x86, 0x15, 0xb7, 0x74, 0xb2, 0x0e, 0xad, 0x0b, 0x7a, 0xe5, + 0x37, 0x86, 0x8d, 0x9d, 0x6e, 0xa0, 0x1f, 0xc9, 0x2e, 0x2c, 0xcd, 0xa3, 0xb4, 0xa0, 0x76, 0x11, + 0x0f, 0x2b, 0x2d, 0x3b, 0xcf, 0xa8, 0x21, 0x72, 0xd0, 0xfc, 0xa9, 0x31, 0xfa, 0x04, 0x3d, 0x27, + 0x43, 0x1e, 0xc2, 0x52, 0x91, 0x47, 0x09, 0x45, 0x49, 0x2f, 0x30, 0x81, 0x7e, 0xcd, 0x2c, 0xfa, + 0x8a, 0x92, 0x5e, 0xa0, 0x1f, 0x89, 0x0f, 0xed, 0xd3, 0x88, 0xa5, 0x71, 0xa6, 0xb0, 0x0f, 0x5e, + 0x50, 0x86, 0xa3, 0x03, 0xe8, 0x94, 0xfd, 0xd2, 0x54, 0x5c, 0x48, 0x49, 0x33, 0x65, 0xf5, 0xca, + 0x50, 0xbf, 0x27, 0x65, 0x33, 0xa6, 0xac, 0xa6, 0x09, 0x46, 0x14, 0xda, 0xb6, 0x8b, 0xe4, 0x95, + 0x5b, 0x88, 0xbb, 0x19, 0x87, 0xa2, 0xf8, 0xac, 0x13, 0x65, 0x6d, 0xdf, 0x03, 0xa8, 0x33, 0xc9, + 0x95, 0x4a, 0x59, 0x96, 0xdc, 0xd8, 0xba, 0x13, 0x93, 0xa2, 0x81, 0x03, 0x8d, 0x28, 0x74, 0x4a, + 0x15, 0x5d, 0x88, 0xe2, 0x2a, 0x4a, 0xcb, 0x05, 0x63, 0x40, 0x36, 0x60, 0xf9, 0x82, 0xca, 0x8c, + 0xa6, 0xb6, 0x3e, 0x1b, 0x11, 0x02, 0x5e, 0x91, 0x53, 0x69, 0xd7, 0x8c, 0xcf, 0x64, 0x13, 0xda, + 0x82, 0xca, 0x50, 0x5b, 0xc2, 0x1b, 0xb6, 0x34, 0x2c, 0xa8, 0x3c, 0x14, 0xc5, 0xe8, 0x2b, 0x74, + 0xca, 0xd7, 0xeb, 0x4e, 0x08, 0x2a, 0x19, 0x9f, 0xe6, 0x65, 0x27, 0x6c, 0x48, 0xf6, 0xa0, 0x6f, + 0x4b, 0xa3, 0xd3, 0xb0, 0x64, 0xcc, 0x5b, 0xd7, 0xab, 0xc4, 0xd8, 0xc2, 0x2f, 0x61, 0xad, 0x86, + 0x15, 0x9b, 0x51, 0x5b, 0xc9, 0x6a, 0x35, 0x7a, 0xc2, 0x66, 0x74, 0xf4, 0x1f, 0x00, 0xd4, 0x3e, + 0xd3, 0x6b, 0x8c, 0xa3, 0xf8, 0xac, 0xda, 0x54, 0x0c, 0xf4, 0xa6, 0xca, 0xbc, 0x7c, 0x95, 0x7e, + 0x24, 0x5b, 0xd0, 0x91, 0x79, 0x1e, 0xea, 0xcf, 0xa1, 0xdc, 0x55, 0x99, 0xe7, 0xda, 0x1e, 0xe4, + 0x19, 0xf4, 0x66, 0x91, 0x10, 0x74, 0x1a, 0x9e, 0xb2, 0x94, 0xa2, 0xa9, 0xbd, 0x00, 0xcc, 0xd0, + 0x7b, 0x96, 0x62, 0x1f, 0xa7, 0x4c, 0xaa, 0x2b, 0xf4, 0xb0, 0x17, 0x98, 0x80, 0x3c, 0x81, 0xee, + 0xa5, 0x64, 0x8a, 0x4e, 0xa2, 0xf8, 0xc2, 0x5f, 0xc6, 0x4c, 0x3d, 0x40, 0x7c, 0xe8, 0x88, 0x24, + 0x14, 0x49, 0xc8, 0x32, 0xbf, 0x6d, 0xfa, 0x2c, 0x92, 0x71, 0xf2, 0x31, 0x23, 0xdb, 0xd0, 0x35, + 0x19, 0x5e, 0x28, 0xbf, 0x63, 0x1b, 0x96, 0x8c, 0x93, 0x4f, 0x85, 0xd2, 0x55, 0x8a, 0x24, 0x3c, + 0x8d, 0x8a, 0x54, 0xf9, 0xdd, 0x32, 0xf5, 0x5e, 0x87, 0x64, 0x08, 0x2b, 0x22, 0x09, 0x67, 0xd1, + 0xb9, 0x4d, 0x83, 0x29, 0x53, 0x24, 0x47, 0xd1, 0xb9, 0x21, 0x9e, 0xc3, 0x2a, 0xcb, 0xa2, 0x58, + 0xb1, 0x39, 0x0d, 0xa3, 0x8c, 0x67, 0x7e, 0x0f, 0x91, 0x95, 0x72, 0xf0, 0x6d, 0xc6, 0x33, 0xbd, + 0x58, 0x17, 0x59, 0x31, 0x2a, 0x0e, 0xe0, 0xaa, 0x60, 0x3f, 0x56, 0x17, 0x55, 0xb0, 0x23, 0xb5, + 0x0a, 0x22, 0x6b, 0xae, 0x0a, 0x02, 0x43, 0xe8, 0x15, 0x19, 0x9d, 0xb3, 0x58, 0x45, 0x93, 0x94, + 0xfa, 0x0f, 0x10, 0x70, 0x87, 0xc8, 0x01, 0x6c, 0x9d, 0x31, 0x2a, 0x23, 0x19, 0x9f, 0xb1, 0x38, + 0x4a, 0x43, 0xf3, 0xbf, 0x08, 0xcd, 0x97, 0xb3, 0x8e, 0xfc, 0xa6, 0x0b, 0x98, 0x3d, 0xff, 0x43, + 0xa7, 0xc9, 0x0f, 0xb0, 0x90, 0x0a, 0xf3, 0xcb, 0x48, 0xd8, 0x99, 0x7d, 0x9c, 0xf9, 0xc8, 0x4d, + 0x1f, 0x5f, 0x46, 0xc2, 0xcc, 0x7b, 0x06, 0x3d, 0xfc, 0x06, 0x42, 0x63, 0x19, 0x62, 0xca, 0xc6, + 0xa1, 0x43, 0xf4, 0xcd, 0x63, 0xe8, 0x1a, 0x40, 0xbb, 0x67, 0x80, 0xe9, 0x0e, 0x0e, 0x04, 0x79, + 0x4e, 0x5e, 0xc0, 0x5a, 0x95, 0x34, 0x46, 0x7a, 0x68, 0x5a, 0x53, 0x12, 0xe8, 0xa6, 0x5d, 0xe8, + 0x1b, 0xca, 0xf5, 0xd4, 0x23, 0x04, 0x1f, 0x60, 0xe2, 0xa8, 0x36, 0x56, 0x55, 0x8f, 0xb1, 0xd7, + 0x86, 0x53, 0xcf, 0xaf, 0xe8, 0xb1, 0x57, 0x60, 0xe6, 0x84, 0xb5, 0xd3, 0x36, 0x11, 0x32, 0x95, + 0x7c, 0xa9, 0xec, 0xf6, 0xbc, 0xac, 0xad, 0x32, 0x9d, 0x6f, 0x5a, 0x8e, 0xa3, 0x63, 0xe3, 0xbc, + 0x97, 0xa5, 0x5a, 0xed, 0xbf, 0x2d, 0x67, 0x05, 0x63, 0x6b, 0xc2, 0x17, 0x8e, 0x96, 0xf1, 0xda, + 0xf6, 0x02, 0x65, 0xdc, 0xb6, 0x07, 0xa4, 0xa2, 0x6a, 0x57, 0x3e, 0x76, 0x16, 0x3a, 0xae, 0xad, + 0xb9, 0x0f, 0x03, 0x03, 0x2f, 0x1a, 0xf4, 0x09, 0xd2, 0xa6, 0x5f, 0x1f, 0x5d, 0x97, 0x56, 0x4d, + 0x74, 0xe9, 0xa7, 0x8e, 0xf6, 0xdb, 0x9a, 0xbd, 0xa9, 0x8d, 0x2d, 0xff, 0xe6, 0x16, 0x6d, 0x6c, + 0xfa, 0x75, 0x6d, 0xa4, 0x9f, 0xdd, 0xd0, 0x46, 0x76, 0xaf, 0x64, 0x5d, 0x33, 0x0f, 0xed, 0x0f, + 0x4c, 0x27, 0x3e, 0x3b, 0x8e, 0xde, 0x2d, 0x7f, 0xeb, 0xdf, 0x5e, 0x3b, 0x9e, 0x8c, 0x75, 0xcd, + 0x81, 0x6c, 0xff, 0xec, 0x3b, 0xe0, 0x69, 0xd3, 0xfa, 0xa3, 0x7b, 0x50, 0x24, 0xc8, 0x77, 0xd5, + 0xef, 0xfa, 0xf9, 0x3d, 0x6c, 0xf9, 0x13, 0x7f, 0x03, 0x60, 0x9e, 0x42, 0x15, 0x0b, 0xff, 0xc5, + 0x3d, 0x33, 0xba, 0x86, 0x3b, 0x89, 0xc5, 0x88, 0x42, 0xcf, 0xc9, 0xd4, 0xe7, 0x57, 0xc3, 0x39, + 0xbf, 0xea, 0xd3, 0xb3, 0x79, 0xcb, 0xe9, 0xd9, 0xba, 0xf5, 0xf4, 0xf4, 0x16, 0x4f, 0xcf, 0x7f, + 0x3d, 0xe8, 0x56, 0xa7, 0x3e, 0x19, 0xc3, 0x36, 0xe3, 0x61, 0x4e, 0xe5, 0x9c, 0xc5, 0x34, 0x9c, + 0x5c, 0x29, 0x9a, 0x87, 0x92, 0xc6, 0x85, 0xcc, 0xd9, 0x9c, 0xda, 0xcb, 0xcd, 0x60, 0xf1, 0xb6, + 0x60, 0x0a, 0xdf, 0x64, 0xfc, 0xd8, 0xcc, 0x7a, 0xa7, 0x27, 0x05, 0xe5, 0x1c, 0xf2, 0x3b, 0x3c, + 0xaa, 0x15, 0xa7, 0x8e, 0x58, 0xf3, 0x6e, 0xb1, 0x41, 0x25, 0x36, 0xad, 0x85, 0x0e, 0x61, 0xc0, + 0x78, 0xf8, 0x77, 0x41, 0x8b, 0x05, 0x99, 0xd6, 0xdd, 0x32, 0x7d, 0xc6, 0xff, 0x42, 0xbc, 0x16, + 0xf9, 0x13, 0xb6, 0x9c, 0xf5, 0xe9, 0xf3, 0xcc, 0x91, 0xf2, 0xee, 0x96, 0xda, 0xa8, 0x2a, 0xd2, + 0xc7, 0x5d, 0xad, 0xf7, 0x01, 0x36, 0x18, 0x0f, 0x2f, 0x23, 0xa6, 0xae, 0x8b, 0x2d, 0xdd, 0xbb, + 0xbc, 0x2f, 0x11, 0x53, 0x8b, 0x4a, 0x66, 0x79, 0x33, 0x2a, 0x93, 0x85, 0xe5, 0x2d, 0xdf, 0xbb, + 0xbc, 0x23, 0xc4, 0x6b, 0x91, 0x9f, 0xa1, 0xcf, 0xf8, 0xf5, 0x4a, 0xda, 0x77, 0x4b, 0x3c, 0x60, + 0x7c, 0xb1, 0x8a, 0x5f, 0xa0, 0x9f, 0xd3, 0x58, 0x71, 0xe9, 0x6e, 0x7b, 0xe7, 0x6e, 0x81, 0x75, + 0x4b, 0x57, 0x0a, 0xa3, 0x39, 0x40, 0x9d, 0x27, 0x6b, 0xd0, 0xe4, 0xc2, 0xde, 0x16, 0x9b, 0x5c, + 0xe8, 0x6b, 0xce, 0x54, 0x7f, 0x9b, 0xc6, 0xb0, 0xdd, 0xc0, 0x46, 0xda, 0xc7, 0xb3, 0xe8, 0x9c, + 0x97, 0xf7, 0x1c, 0x13, 0xe0, 0x28, 0xcb, 0xb8, 0xb4, 0x9e, 0x35, 0x81, 0x1e, 0x35, 0x17, 0x4e, + 0x7b, 0xf0, 0x63, 0x30, 0x59, 0xc6, 0xfb, 0xf9, 0x9b, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0xda, + 0x6f, 0x7a, 0x0a, 0xb0, 0x0b, 0x00, 0x00, +} diff --git a/vendor/github.com/containerd/cgroups/metrics.proto b/vendor/github.com/containerd/cgroups/metrics.proto new file mode 100644 index 000000000..8295d2fa9 --- /dev/null +++ b/vendor/github.com/containerd/cgroups/metrics.proto @@ -0,0 +1,107 @@ +syntax = "proto3"; + +package cgroups; + +message Metrics { + map hugetlb = 1; + PidsStat pids = 2; + CpuStat cpu = 3; + MemoryStat memory = 4; + BlkioStat blkio = 5; +} + +message HugetlbStat { + uint64 usage = 1; + uint64 max = 2; + uint64 failcnt = 3; +} + +message PidsStat { + uint64 current = 1; + uint64 limit = 2; +} + +message CpuStat { + CpuUsage usage = 1; + Throttle throttling = 2; +} + +message CpuUsage { + // values in nanoseconds + uint64 total = 1; + uint64 kernel = 2; + uint64 user = 3; + repeated uint64 per_cpu = 4; +} + +message Throttle { + uint64 periods = 1; + uint64 throttled_periods = 2; + uint64 throttled_time = 3; +} + +message MemoryStat { + uint64 cache = 1; + uint64 rss = 2; + uint64 rss_huge = 3; + uint64 mapped_file = 4; + uint64 dirty = 5; + uint64 writeback = 6; + uint64 pg_pg_in = 7; + uint64 pg_pg_out = 8; + uint64 pg_fault = 9; + uint64 pg_maj_fault = 10; + uint64 inactive_anon = 11; + uint64 active_anon = 12; + uint64 inactive_file = 13; + uint64 active_file = 14; + uint64 unevictable = 15; + uint64 hierarchical_memory_limit = 16; + uint64 hierarchical_swap_limit = 17; + uint64 total_cache = 18; + uint64 total_rss = 19; + uint64 total_rss_huge = 20; + uint64 total_mapped_file = 21; + uint64 total_dirty = 22; + uint64 total_writeback = 23; + uint64 total_pg_pg_in = 24; + uint64 total_pg_pg_out = 25; + uint64 total_pg_fault = 26; + uint64 total_pg_maj_fault = 27; + uint64 total_inactive_anon = 28; + uint64 total_active_anon = 29; + uint64 total_inactive_file = 30; + uint64 total_active_file = 31; + uint64 total_unevictable = 32; + MemoryEntry usage = 33; + MemoryEntry swap = 34; + MemoryEntry kernel = 35; + MemoryEntry kernel_tcp = 36; + +} + +message MemoryEntry { + uint64 limit = 1; + uint64 usage = 2; + uint64 max = 3; + uint64 failcnt = 4; +} + +message BlkioStat { + repeated BlkioEntry io_service_bytes_recursive = 1; + repeated BlkioEntry io_serviced_recursive = 2; + repeated BlkioEntry io_queued_recursive = 3; + repeated BlkioEntry io_service_time_recursive = 4; + repeated BlkioEntry io_wait_time_recursive = 5; + repeated BlkioEntry io_merged_recursive = 6; + repeated BlkioEntry io_time_recursive = 7; + repeated BlkioEntry sectors_recursive = 8; +} + +message BlkioEntry { + string op = 1; + string device = 2; + uint64 major = 3; + uint64 minor = 4; + uint64 value = 5; +} diff --git a/vendor/github.com/containerd/cgroups/pids.go b/vendor/github.com/containerd/cgroups/pids.go index bdcc10a90..dcf4e29e1 100644 --- a/vendor/github.com/containerd/cgroups/pids.go +++ b/vendor/github.com/containerd/cgroups/pids.go @@ -46,7 +46,7 @@ func (p *pidsController) Update(path string, resources *specs.LinuxResources) er return p.Create(path, resources) } -func (p *pidsController) Stat(path string, stats *Stats) error { +func (p *pidsController) Stat(path string, stats *Metrics) error { current, err := readUint(filepath.Join(p.Path(path), "pids.current")) if err != nil { return err diff --git a/vendor/github.com/containerd/cgroups/stats.go b/vendor/github.com/containerd/cgroups/stats.go deleted file mode 100644 index 47fbfa96b..000000000 --- a/vendor/github.com/containerd/cgroups/stats.go +++ /dev/null @@ -1,109 +0,0 @@ -package cgroups - -import "sync" - -type Stats struct { - cpuMu sync.Mutex - - Hugetlb map[string]HugetlbStat - Pids *PidsStat - Cpu *CpuStat - Memory *MemoryStat - Blkio *BlkioStat -} - -type HugetlbStat struct { - Usage uint64 - Max uint64 - Failcnt uint64 -} - -type PidsStat struct { - Current uint64 - Limit uint64 -} - -type CpuStat struct { - Usage CpuUsage - Throttling Throttle -} - -type CpuUsage struct { - // Units: nanoseconds. - Total uint64 - PerCpu []uint64 - Kernel uint64 - User uint64 -} - -type Throttle struct { - Periods uint64 - ThrottledPeriods uint64 - ThrottledTime uint64 -} - -type MemoryStat struct { - Cache uint64 - RSS uint64 - RSSHuge uint64 - MappedFile uint64 - Dirty uint64 - Writeback uint64 - PgPgIn uint64 - PgPgOut uint64 - PgFault uint64 - PgMajFault uint64 - InactiveAnon uint64 - ActiveAnon uint64 - InactiveFile uint64 - ActiveFile uint64 - Unevictable uint64 - HierarchicalMemoryLimit uint64 - HierarchicalSwapLimit uint64 - TotalCache uint64 - TotalRSS uint64 - TotalRSSHuge uint64 - TotalMappedFile uint64 - TotalDirty uint64 - TotalWriteback uint64 - TotalPgPgIn uint64 - TotalPgPgOut uint64 - TotalPgFault uint64 - TotalPgMajFault uint64 - TotalInactiveAnon uint64 - TotalActiveAnon uint64 - TotalInactiveFile uint64 - TotalActiveFile uint64 - TotalUnevictable uint64 - - Usage MemoryEntry - Swap MemoryEntry - Kernel MemoryEntry - KernelTCP MemoryEntry -} - -type MemoryEntry struct { - Limit uint64 - Usage uint64 - Max uint64 - Failcnt uint64 -} - -type BlkioStat struct { - IoServiceBytesRecursive []BlkioEntry - IoServicedRecursive []BlkioEntry - IoQueuedRecursive []BlkioEntry - IoServiceTimeRecursive []BlkioEntry - IoWaitTimeRecursive []BlkioEntry - IoMergedRecursive []BlkioEntry - IoTimeRecursive []BlkioEntry - SectorsRecursive []BlkioEntry -} - -type BlkioEntry struct { - Op string - Device string - Major uint64 - Minor uint64 - Value uint64 -} diff --git a/vendor/github.com/containerd/cgroups/subsystem.go b/vendor/github.com/containerd/cgroups/subsystem.go index aab403b8a..9393eec19 100644 --- a/vendor/github.com/containerd/cgroups/subsystem.go +++ b/vendor/github.com/containerd/cgroups/subsystem.go @@ -67,7 +67,7 @@ type deleter interface { type stater interface { Subsystem - Stat(path string, stats *Stats) error + Stat(path string, stats *Metrics) error } type updater interface { diff --git a/vendor/github.com/containerd/cgroups/systemd.go b/vendor/github.com/containerd/cgroups/systemd.go index 5e052a821..fd816e32e 100644 --- a/vendor/github.com/containerd/cgroups/systemd.go +++ b/vendor/github.com/containerd/cgroups/systemd.go @@ -43,19 +43,13 @@ func Slice(slice, name string) Path { } func NewSystemd(root string) (*SystemdController, error) { - conn, err := systemdDbus.New() - if err != nil { - return nil, err - } return &SystemdController{ root: root, - conn: conn, }, nil } type SystemdController struct { mu sync.Mutex - conn *systemdDbus.Conn root string } @@ -64,6 +58,11 @@ func (s *SystemdController) Name() Name { } func (s *SystemdController) Create(path string, resources *specs.LinuxResources) error { + conn, err := systemdDbus.New() + if err != nil { + return err + } + defer conn.Close() slice, name := splitName(path) properties := []systemdDbus.Property{ systemdDbus.PropDescription(fmt.Sprintf("cgroup %s", name)), @@ -74,14 +73,29 @@ func (s *SystemdController) Create(path string, resources *specs.LinuxResources) newProperty("CPUAccounting", true), newProperty("BlockIOAccounting", true), } - _, err := s.conn.StartTransientUnit(name, "replace", properties, nil) - return err + ch := make(chan string) + _, err = conn.StartTransientUnit(name, "replace", properties, ch) + if err != nil { + return err + } + <-ch + return nil } func (s *SystemdController) Delete(path string) error { + conn, err := systemdDbus.New() + if err != nil { + return err + } + defer conn.Close() _, name := splitName(path) - _, err := s.conn.StopUnit(name, "replace", nil) - return err + ch := make(chan string) + _, err = conn.StopUnit(name, "replace", ch) + if err != nil { + return err + } + <-ch + return nil } func newProperty(name string, units interface{}) systemdDbus.Property {