cadvisor/container/lmctfy/lmctfy.pb.go

// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Code generated by protoc-gen-go.
// source: lmctfy.proto
// DO NOT EDIT!

/*
Package containers is a generated protocol buffer package.

It is generated from these files:
	lmctfy.proto
	virtual_host.proto

It has these top-level messages:
	ContainerSpec
	EventSpec
	RunSpec
	VirtualHostSpec
	CpuSpec
	MemorySpec
	BlockIoSpec
	NetworkSpec
	MonitoringSpec
	FilesystemSpec
	DeviceSpec
	SecuritySpec
	ContainerStats
	HistogramMap
	ThrottlingData
	CpuStats
	MemoryStats
	BlockIoStats
	NetworkStats
	MonitoringStats
	FilesystemStats
*/
package lmctfy

import proto "code.google.com/p/goprotobuf/proto"
import json "encoding/json"
import math "math"

// Reference proto, json, and math imports to suppress error if they are not otherwise used.
var _ = proto.Marshal
var _ = &json.SyntaxError{}
var _ = math.Inf

type SchedulingLatency int32

const (
	SchedulingLatency_BEST_EFFORT SchedulingLatency = 1
	SchedulingLatency_NORMAL      SchedulingLatency = 2
	SchedulingLatency_PRIORITY    SchedulingLatency = 3
	SchedulingLatency_PREMIER     SchedulingLatency = 4
)

var SchedulingLatency_name = map[int32]string{
	1: "BEST_EFFORT",
	2: "NORMAL",
	3: "PRIORITY",
	4: "PREMIER",
}
var SchedulingLatency_value = map[string]int32{
	"BEST_EFFORT": 1,
	"NORMAL":      2,
	"PRIORITY":    3,
	"PREMIER":     4,
}

func (x SchedulingLatency) Enum() *SchedulingLatency {
	p := new(SchedulingLatency)
	*p = x
	return p
}
func (x SchedulingLatency) String() string {
	return proto.EnumName(SchedulingLatency_name, int32(x))
}
func (x *SchedulingLatency) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(SchedulingLatency_value, data, "SchedulingLatency")
	if err != nil {
		return err
	}
	*x = SchedulingLatency(value)
	return nil
}

type CpuHistogramType int32

const (
	CpuHistogramType_SERVE       CpuHistogramType = 1
	CpuHistogramType_ONCPU       CpuHistogramType = 2
	CpuHistogramType_SLEEP       CpuHistogramType = 3
	CpuHistogramType_QUEUE_SELF  CpuHistogramType = 4
	CpuHistogramType_QUEUE_OTHER CpuHistogramType = 5
)

var CpuHistogramType_name = map[int32]string{
	1: "SERVE",
	2: "ONCPU",
	3: "SLEEP",
	4: "QUEUE_SELF",
	5: "QUEUE_OTHER",
}
var CpuHistogramType_value = map[string]int32{
	"SERVE":       1,
	"ONCPU":       2,
	"SLEEP":       3,
	"QUEUE_SELF":  4,
	"QUEUE_OTHER": 5,
}

func (x CpuHistogramType) Enum() *CpuHistogramType {
	p := new(CpuHistogramType)
	*p = x
	return p
}
func (x CpuHistogramType) String() string {
	return proto.EnumName(CpuHistogramType_name, int32(x))
}
func (x *CpuHistogramType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(CpuHistogramType_value, data, "CpuHistogramType")
	if err != nil {
		return err
	}
	*x = CpuHistogramType(value)
	return nil
}

type RunSpec_FdPolicy int32

const (
	RunSpec_UNKNOWN  RunSpec_FdPolicy = 0
	RunSpec_INHERIT  RunSpec_FdPolicy = 1
	RunSpec_DETACHED RunSpec_FdPolicy = 2
)

var RunSpec_FdPolicy_name = map[int32]string{
	0: "UNKNOWN",
	1: "INHERIT",
	2: "DETACHED",
}
var RunSpec_FdPolicy_value = map[string]int32{
	"UNKNOWN":  0,
	"INHERIT":  1,
	"DETACHED": 2,
}

func (x RunSpec_FdPolicy) Enum() *RunSpec_FdPolicy {
	p := new(RunSpec_FdPolicy)
	*p = x
	return p
}
func (x RunSpec_FdPolicy) String() string {
	return proto.EnumName(RunSpec_FdPolicy_name, int32(x))
}
func (x *RunSpec_FdPolicy) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(RunSpec_FdPolicy_value, data, "RunSpec_FdPolicy")
	if err != nil {
		return err
	}
	*x = RunSpec_FdPolicy(value)
	return nil
}

type BlockIoSpec_OpType int32

const (
	BlockIoSpec_READ  BlockIoSpec_OpType = 1
	BlockIoSpec_WRITE BlockIoSpec_OpType = 2
)

var BlockIoSpec_OpType_name = map[int32]string{
	1: "READ",
	2: "WRITE",
}
var BlockIoSpec_OpType_value = map[string]int32{
	"READ":  1,
	"WRITE": 2,
}

func (x BlockIoSpec_OpType) Enum() *BlockIoSpec_OpType {
	p := new(BlockIoSpec_OpType)
	*p = x
	return p
}
func (x BlockIoSpec_OpType) String() string {
	return proto.EnumName(BlockIoSpec_OpType_name, int32(x))
}
func (x *BlockIoSpec_OpType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(BlockIoSpec_OpType_value, data, "BlockIoSpec_OpType")
	if err != nil {
		return err
	}
	*x = BlockIoSpec_OpType(value)
	return nil
}

type BlockIoSpec_LimitType int32

const (
	BlockIoSpec_BYTES_PER_SECOND BlockIoSpec_LimitType = 1
	BlockIoSpec_IO_PER_SECOND    BlockIoSpec_LimitType = 2
)

var BlockIoSpec_LimitType_name = map[int32]string{
	1: "BYTES_PER_SECOND",
	2: "IO_PER_SECOND",
}
var BlockIoSpec_LimitType_value = map[string]int32{
	"BYTES_PER_SECOND": 1,
	"IO_PER_SECOND":    2,
}

func (x BlockIoSpec_LimitType) Enum() *BlockIoSpec_LimitType {
	p := new(BlockIoSpec_LimitType)
	*p = x
	return p
}
func (x BlockIoSpec_LimitType) String() string {
	return proto.EnumName(BlockIoSpec_LimitType_name, int32(x))
}
func (x *BlockIoSpec_LimitType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(BlockIoSpec_LimitType_value, data, "BlockIoSpec_LimitType")
	if err != nil {
		return err
	}
	*x = BlockIoSpec_LimitType(value)
	return nil
}

type DeviceSpec_DeviceType int32

const (
	DeviceSpec_DEVICE_CHAR  DeviceSpec_DeviceType = 0
	DeviceSpec_DEVICE_BLOCK DeviceSpec_DeviceType = 1
	DeviceSpec_DEVICE_ALL   DeviceSpec_DeviceType = 2
)

var DeviceSpec_DeviceType_name = map[int32]string{
	0: "DEVICE_CHAR",
	1: "DEVICE_BLOCK",
	2: "DEVICE_ALL",
}
var DeviceSpec_DeviceType_value = map[string]int32{
	"DEVICE_CHAR":  0,
	"DEVICE_BLOCK": 1,
	"DEVICE_ALL":   2,
}

func (x DeviceSpec_DeviceType) Enum() *DeviceSpec_DeviceType {
	p := new(DeviceSpec_DeviceType)
	*p = x
	return p
}
func (x DeviceSpec_DeviceType) String() string {
	return proto.EnumName(DeviceSpec_DeviceType_name, int32(x))
}
func (x *DeviceSpec_DeviceType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(DeviceSpec_DeviceType_value, data, "DeviceSpec_DeviceType")
	if err != nil {
		return err
	}
	*x = DeviceSpec_DeviceType(value)
	return nil
}

type DeviceSpec_DeviceAccess int32

const (
	DeviceSpec_READ  DeviceSpec_DeviceAccess = 1
	DeviceSpec_WRITE DeviceSpec_DeviceAccess = 2
	DeviceSpec_MKNOD DeviceSpec_DeviceAccess = 3
)

var DeviceSpec_DeviceAccess_name = map[int32]string{
	1: "READ",
	2: "WRITE",
	3: "MKNOD",
}
var DeviceSpec_DeviceAccess_value = map[string]int32{
	"READ":  1,
	"WRITE": 2,
	"MKNOD": 3,
}

func (x DeviceSpec_DeviceAccess) Enum() *DeviceSpec_DeviceAccess {
	p := new(DeviceSpec_DeviceAccess)
	*p = x
	return p
}
func (x DeviceSpec_DeviceAccess) String() string {
	return proto.EnumName(DeviceSpec_DeviceAccess_name, int32(x))
}
func (x *DeviceSpec_DeviceAccess) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(DeviceSpec_DeviceAccess_value, data, "DeviceSpec_DeviceAccess")
	if err != nil {
		return err
	}
	*x = DeviceSpec_DeviceAccess(value)
	return nil
}

type DeviceSpec_DevicePermission int32

const (
	DeviceSpec_ALLOW DeviceSpec_DevicePermission = 1
	DeviceSpec_DENY  DeviceSpec_DevicePermission = 2
)

var DeviceSpec_DevicePermission_name = map[int32]string{
	1: "ALLOW",
	2: "DENY",
}
var DeviceSpec_DevicePermission_value = map[string]int32{
	"ALLOW": 1,
	"DENY":  2,
}

func (x DeviceSpec_DevicePermission) Enum() *DeviceSpec_DevicePermission {
	p := new(DeviceSpec_DevicePermission)
	*p = x
	return p
}
func (x DeviceSpec_DevicePermission) String() string {
	return proto.EnumName(DeviceSpec_DevicePermission_name, int32(x))
}
func (x *DeviceSpec_DevicePermission) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(DeviceSpec_DevicePermission_value, data, "DeviceSpec_DevicePermission")
	if err != nil {
		return err
	}
	*x = DeviceSpec_DevicePermission(value)
	return nil
}

type ContainerSpec struct {
	Owner            *int64           `protobuf:"varint,1,opt,name=owner" json:"owner,omitempty"`
	OwnerGroup       *int64           `protobuf:"varint,8,opt,name=owner_group" json:"owner_group,omitempty"`
	ChildrenLimit    *int64           `protobuf:"varint,9,opt,name=children_limit" json:"children_limit,omitempty"`
	Cpu              *CpuSpec         `protobuf:"bytes,2,opt,name=cpu" json:"cpu,omitempty"`
	Memory           *MemorySpec      `protobuf:"bytes,3,opt,name=memory" json:"memory,omitempty"`
	Network          *NetworkSpec     `protobuf:"bytes,5,opt,name=network" json:"network,omitempty"`
	Blockio          *BlockIoSpec     `protobuf:"bytes,12,opt,name=blockio" json:"blockio,omitempty"`
	Monitoring       *MonitoringSpec  `protobuf:"bytes,6,opt,name=monitoring" json:"monitoring,omitempty"`
	Filesystem       *FilesystemSpec  `protobuf:"bytes,7,opt,name=filesystem" json:"filesystem,omitempty"`
	Device           *DeviceSpec      `protobuf:"bytes,11,opt,name=device" json:"device,omitempty"`
	VirtualHost      *VirtualHostSpec `protobuf:"bytes,10,opt,name=virtual_host" json:"virtual_host,omitempty"`
	SecuritySpec     *SecuritySpec    `protobuf:"bytes,13,opt,name=security_spec" json:"security_spec,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

func (m *ContainerSpec) Reset()         { *m = ContainerSpec{} }
func (m *ContainerSpec) String() string { return proto.CompactTextString(m) }
func (*ContainerSpec) ProtoMessage()    {}

func (m *ContainerSpec) GetOwner() int64 {
	if m != nil && m.Owner != nil {
		return *m.Owner
	}
	return 0
}

func (m *ContainerSpec) GetOwnerGroup() int64 {
	if m != nil && m.OwnerGroup != nil {
		return *m.OwnerGroup
	}
	return 0
}

func (m *ContainerSpec) GetChildrenLimit() int64 {
	if m != nil && m.ChildrenLimit != nil {
		return *m.ChildrenLimit
	}
	return 0
}

func (m *ContainerSpec) GetCpu() *CpuSpec {
	if m != nil {
		return m.Cpu
	}
	return nil
}

func (m *ContainerSpec) GetMemory() *MemorySpec {
	if m != nil {
		return m.Memory
	}
	return nil
}

func (m *ContainerSpec) GetNetwork() *NetworkSpec {
	if m != nil {
		return m.Network
	}
	return nil
}

func (m *ContainerSpec) GetBlockio() *BlockIoSpec {
	if m != nil {
		return m.Blockio
	}
	return nil
}

func (m *ContainerSpec) GetMonitoring() *MonitoringSpec {
	if m != nil {
		return m.Monitoring
	}
	return nil
}

func (m *ContainerSpec) GetFilesystem() *FilesystemSpec {
	if m != nil {
		return m.Filesystem
	}
	return nil
}

func (m *ContainerSpec) GetDevice() *DeviceSpec {
	if m != nil {
		return m.Device
	}
	return nil
}

func (m *ContainerSpec) GetVirtualHost() *VirtualHostSpec {
	if m != nil {
		return m.VirtualHost
	}
	return nil
}

func (m *ContainerSpec) GetSecuritySpec() *SecuritySpec {
	if m != nil {
		return m.SecuritySpec
	}
	return nil
}

type EventSpec struct {
	Oom              *EventSpec_Oom             `protobuf:"bytes,1,opt,name=oom" json:"oom,omitempty"`
	MemoryThreshold  *EventSpec_MemoryThreshold `protobuf:"bytes,2,opt,name=memory_threshold" json:"memory_threshold,omitempty"`
	ContainerEmpty   *EventSpec_ContainerEmpty  `protobuf:"bytes,3,opt,name=container_empty" json:"container_empty,omitempty"`
	XXX_unrecognized []byte                     `json:"-"`
}

func (m *EventSpec) Reset()         { *m = EventSpec{} }
func (m *EventSpec) String() string { return proto.CompactTextString(m) }
func (*EventSpec) ProtoMessage()    {}

func (m *EventSpec) GetOom() *EventSpec_Oom {
	if m != nil {
		return m.Oom
	}
	return nil
}

func (m *EventSpec) GetMemoryThreshold() *EventSpec_MemoryThreshold {
	if m != nil {
		return m.MemoryThreshold
	}
	return nil
}

func (m *EventSpec) GetContainerEmpty() *EventSpec_ContainerEmpty {
	if m != nil {
		return m.ContainerEmpty
	}
	return nil
}

type EventSpec_Oom struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *EventSpec_Oom) Reset()         { *m = EventSpec_Oom{} }
func (m *EventSpec_Oom) String() string { return proto.CompactTextString(m) }
func (*EventSpec_Oom) ProtoMessage()    {}

type EventSpec_MemoryThreshold struct {
	Usage            *int64 `protobuf:"varint,1,opt,name=usage" json:"usage,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *EventSpec_MemoryThreshold) Reset()         { *m = EventSpec_MemoryThreshold{} }
func (m *EventSpec_MemoryThreshold) String() string { return proto.CompactTextString(m) }
func (*EventSpec_MemoryThreshold) ProtoMessage()    {}

func (m *EventSpec_MemoryThreshold) GetUsage() int64 {
	if m != nil && m.Usage != nil {
		return *m.Usage
	}
	return 0
}

type EventSpec_ContainerEmpty struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *EventSpec_ContainerEmpty) Reset()         { *m = EventSpec_ContainerEmpty{} }
func (m *EventSpec_ContainerEmpty) String() string { return proto.CompactTextString(m) }
func (*EventSpec_ContainerEmpty) ProtoMessage()    {}

type RunSpec struct {
	FdPolicy         *RunSpec_FdPolicy `protobuf:"varint,1,opt,name=fd_policy,enum=containers.RunSpec_FdPolicy" json:"fd_policy,omitempty"`
	Console          *RunSpec_Console  `protobuf:"bytes,2,opt,name=console" json:"console,omitempty"`
	ApparmorProfile  *string           `protobuf:"bytes,3,opt,name=apparmor_profile" json:"apparmor_profile,omitempty"`
	XXX_unrecognized []byte            `json:"-"`
}

func (m *RunSpec) Reset()         { *m = RunSpec{} }
func (m *RunSpec) String() string { return proto.CompactTextString(m) }
func (*RunSpec) ProtoMessage()    {}

func (m *RunSpec) GetFdPolicy() RunSpec_FdPolicy {
	if m != nil && m.FdPolicy != nil {
		return *m.FdPolicy
	}
	return RunSpec_UNKNOWN
}

func (m *RunSpec) GetConsole() *RunSpec_Console {
	if m != nil {
		return m.Console
	}
	return nil
}

func (m *RunSpec) GetApparmorProfile() string {
	if m != nil && m.ApparmorProfile != nil {
		return *m.ApparmorProfile
	}
	return ""
}

type RunSpec_Console struct {
	SlavePty         *string `protobuf:"bytes,1,opt,name=slave_pty" json:"slave_pty,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *RunSpec_Console) Reset()         { *m = RunSpec_Console{} }
func (m *RunSpec_Console) String() string { return proto.CompactTextString(m) }
func (*RunSpec_Console) ProtoMessage()    {}

func (m *RunSpec_Console) GetSlavePty() string {
	if m != nil && m.SlavePty != nil {
		return *m.SlavePty
	}
	return ""
}

type VirtualHostSpec struct {
	VirtualHostname  *string               `protobuf:"bytes,1,opt,name=virtual_hostname" json:"virtual_hostname,omitempty"`
	Init             *VirtualHostSpec_Init `protobuf:"bytes,2,opt,name=init" json:"init,omitempty"`
	Network          *Network              `protobuf:"bytes,3,opt,name=network" json:"network,omitempty"`
	XXX_unrecognized []byte                `json:"-"`
}

func (m *VirtualHostSpec) Reset()         { *m = VirtualHostSpec{} }
func (m *VirtualHostSpec) String() string { return proto.CompactTextString(m) }
func (*VirtualHostSpec) ProtoMessage()    {}

func (m *VirtualHostSpec) GetVirtualHostname() string {
	if m != nil && m.VirtualHostname != nil {
		return *m.VirtualHostname
	}
	return ""
}

func (m *VirtualHostSpec) GetInit() *VirtualHostSpec_Init {
	if m != nil {
		return m.Init
	}
	return nil
}

func (m *VirtualHostSpec) GetNetwork() *Network {
	if m != nil {
		return m.Network
	}
	return nil
}

type VirtualHostSpec_Init struct {
	InitArgv         []string `protobuf:"bytes,1,rep,name=init_argv" json:"init_argv,omitempty"`
	RunSpec          *RunSpec `protobuf:"bytes,2,opt,name=run_spec" json:"run_spec,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

func (m *VirtualHostSpec_Init) Reset()         { *m = VirtualHostSpec_Init{} }
func (m *VirtualHostSpec_Init) String() string { return proto.CompactTextString(m) }
func (*VirtualHostSpec_Init) ProtoMessage()    {}

func (m *VirtualHostSpec_Init) GetInitArgv() []string {
	if m != nil {
		return m.InitArgv
	}
	return nil
}

func (m *VirtualHostSpec_Init) GetRunSpec() *RunSpec {
	if m != nil {
		return m.RunSpec
	}
	return nil
}

type CpuSpec struct {
	SchedulingLatency *SchedulingLatency `protobuf:"varint,1,opt,name=scheduling_latency,enum=containers.SchedulingLatency" json:"scheduling_latency,omitempty"`
	Limit             *uint64            `protobuf:"varint,2,opt,name=limit" json:"limit,omitempty"`
	MaxLimit          *uint64            `protobuf:"varint,3,opt,name=max_limit" json:"max_limit,omitempty"`
	Mask              *CpuSpec_Mask      `protobuf:"bytes,4,opt,name=mask" json:"mask,omitempty"`
	XXX_unrecognized  []byte             `json:"-"`
}

func (m *CpuSpec) Reset()         { *m = CpuSpec{} }
func (m *CpuSpec) String() string { return proto.CompactTextString(m) }
func (*CpuSpec) ProtoMessage()    {}

func (m *CpuSpec) GetSchedulingLatency() SchedulingLatency {
	if m != nil && m.SchedulingLatency != nil {
		return *m.SchedulingLatency
	}
	return SchedulingLatency_BEST_EFFORT
}

func (m *CpuSpec) GetLimit() uint64 {
	if m != nil && m.Limit != nil {
		return *m.Limit
	}
	return 0
}

func (m *CpuSpec) GetMaxLimit() uint64 {
	if m != nil && m.MaxLimit != nil {
		return *m.MaxLimit
	}
	return 0
}

func (m *CpuSpec) GetMask() *CpuSpec_Mask {
	if m != nil {
		return m.Mask
	}
	return nil
}

type CpuSpec_Mask struct {
	Data             []uint64 `protobuf:"varint,1,rep,name=data" json:"data,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

func (m *CpuSpec_Mask) Reset()         { *m = CpuSpec_Mask{} }
func (m *CpuSpec_Mask) String() string { return proto.CompactTextString(m) }
func (*CpuSpec_Mask) ProtoMessage()    {}

func (m *CpuSpec_Mask) GetData() []uint64 {
	if m != nil {
		return m.Data
	}
	return nil
}

type MemorySpec struct {
	EvictionPriority         *int32                `protobuf:"varint,1,opt,name=eviction_priority" json:"eviction_priority,omitempty"`
	Limit                    *int64                `protobuf:"varint,2,opt,name=limit" json:"limit,omitempty"`
	MaxLimit                 *int64                `protobuf:"varint,3,opt,name=max_limit" json:"max_limit,omitempty"`
	Reservation              *int64                `protobuf:"varint,4,opt,name=reservation" json:"reservation,omitempty"`
	HugetlbfsPath            *string               `protobuf:"bytes,5,opt,name=hugetlbfs_path" json:"hugetlbfs_path,omitempty"`
	Tmpfs                    *MemorySpec_TmpfsSpec `protobuf:"bytes,6,opt,name=tmpfs" json:"tmpfs,omitempty"`
	SwapLimit                *int64                `protobuf:"varint,7,opt,name=swap_limit" json:"swap_limit,omitempty"`
	CompressionSamplingRatio *int32                `protobuf:"varint,8,opt,name=compression_sampling_ratio" json:"compression_sampling_ratio,omitempty"`
	StalePageAge             *int32                `protobuf:"varint,9,opt,name=stale_page_age" json:"stale_page_age,omitempty"`
	Dirty                    *MemorySpec_Dirty     `protobuf:"bytes,10,opt,name=dirty" json:"dirty,omitempty"`
	KmemChargeUsage          *bool                 `protobuf:"varint,11,opt,name=kmem_charge_usage" json:"kmem_charge_usage,omitempty"`
	XXX_unrecognized         []byte                `json:"-"`
}

func (m *MemorySpec) Reset()         { *m = MemorySpec{} }
func (m *MemorySpec) String() string { return proto.CompactTextString(m) }
func (*MemorySpec) ProtoMessage()    {}

func (m *MemorySpec) GetEvictionPriority() int32 {
	if m != nil && m.EvictionPriority != nil {
		return *m.EvictionPriority
	}
	return 0
}

func (m *MemorySpec) GetLimit() int64 {
	if m != nil && m.Limit != nil {
		return *m.Limit
	}
	return 0
}

func (m *MemorySpec) GetMaxLimit() int64 {
	if m != nil && m.MaxLimit != nil {
		return *m.MaxLimit
	}
	return 0
}

func (m *MemorySpec) GetReservation() int64 {
	if m != nil && m.Reservation != nil {
		return *m.Reservation
	}
	return 0
}

func (m *MemorySpec) GetHugetlbfsPath() string {
	if m != nil && m.HugetlbfsPath != nil {
		return *m.HugetlbfsPath
	}
	return ""
}

func (m *MemorySpec) GetTmpfs() *MemorySpec_TmpfsSpec {
	if m != nil {
		return m.Tmpfs
	}
	return nil
}

func (m *MemorySpec) GetSwapLimit() int64 {
	if m != nil && m.SwapLimit != nil {
		return *m.SwapLimit
	}
	return 0
}

func (m *MemorySpec) GetCompressionSamplingRatio() int32 {
	if m != nil && m.CompressionSamplingRatio != nil {
		return *m.CompressionSamplingRatio
	}
	return 0
}

func (m *MemorySpec) GetStalePageAge() int32 {
	if m != nil && m.StalePageAge != nil {
		return *m.StalePageAge
	}
	return 0
}

func (m *MemorySpec) GetDirty() *MemorySpec_Dirty {
	if m != nil {
		return m.Dirty
	}
	return nil
}

func (m *MemorySpec) GetKmemChargeUsage() bool {
	if m != nil && m.KmemChargeUsage != nil {
		return *m.KmemChargeUsage
	}
	return false
}

type MemorySpec_TmpfsSpec struct {
	Path             []string `protobuf:"bytes,1,rep,name=path" json:"path,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

func (m *MemorySpec_TmpfsSpec) Reset()         { *m = MemorySpec_TmpfsSpec{} }
func (m *MemorySpec_TmpfsSpec) String() string { return proto.CompactTextString(m) }
func (*MemorySpec_TmpfsSpec) ProtoMessage()    {}

func (m *MemorySpec_TmpfsSpec) GetPath() []string {
	if m != nil {
		return m.Path
	}
	return nil
}

type MemorySpec_Dirty struct {
	Ratio            *int32 `protobuf:"varint,1,opt,name=ratio" json:"ratio,omitempty"`
	Limit            *int32 `protobuf:"varint,2,opt,name=limit" json:"limit,omitempty"`
	BackgroundRatio  *int32 `protobuf:"varint,3,opt,name=background_ratio" json:"background_ratio,omitempty"`
	BackgroundLimit  *int32 `protobuf:"varint,4,opt,name=background_limit" json:"background_limit,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *MemorySpec_Dirty) Reset()         { *m = MemorySpec_Dirty{} }
func (m *MemorySpec_Dirty) String() string { return proto.CompactTextString(m) }
func (*MemorySpec_Dirty) ProtoMessage()    {}

func (m *MemorySpec_Dirty) GetRatio() int32 {
	if m != nil && m.Ratio != nil {
		return *m.Ratio
	}
	return 0
}

func (m *MemorySpec_Dirty) GetLimit() int32 {
	if m != nil && m.Limit != nil {
		return *m.Limit
	}
	return 0
}

func (m *MemorySpec_Dirty) GetBackgroundRatio() int32 {
	if m != nil && m.BackgroundRatio != nil {
		return *m.BackgroundRatio
	}
	return 0
}

func (m *MemorySpec_Dirty) GetBackgroundLimit() int32 {
	if m != nil && m.BackgroundLimit != nil {
		return *m.BackgroundLimit
	}
	return 0
}

type BlockIoSpec struct {
	DeviceLimitSet    *BlockIoSpec_DeviceLimitSet `protobuf:"bytes,1,opt,name=device_limit_set" json:"device_limit_set,omitempty"`
	MaxDeviceLimitSet *BlockIoSpec_MaxLimitSet    `protobuf:"bytes,2,opt,name=max_device_limit_set" json:"max_device_limit_set,omitempty"`
	XXX_unrecognized  []byte                      `json:"-"`
}

func (m *BlockIoSpec) Reset()         { *m = BlockIoSpec{} }
func (m *BlockIoSpec) String() string { return proto.CompactTextString(m) }
func (*BlockIoSpec) ProtoMessage()    {}

func (m *BlockIoSpec) GetDeviceLimitSet() *BlockIoSpec_DeviceLimitSet {
	if m != nil {
		return m.DeviceLimitSet
	}
	return nil
}

func (m *BlockIoSpec) GetMaxDeviceLimitSet() *BlockIoSpec_MaxLimitSet {
	if m != nil {
		return m.MaxDeviceLimitSet
	}
	return nil
}

type BlockIoSpec_Device struct {
	Major            *int64 `protobuf:"varint,1,opt,name=major" json:"major,omitempty"`
	Minor            *int64 `protobuf:"varint,2,opt,name=minor" json:"minor,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *BlockIoSpec_Device) Reset()         { *m = BlockIoSpec_Device{} }
func (m *BlockIoSpec_Device) String() string { return proto.CompactTextString(m) }
func (*BlockIoSpec_Device) ProtoMessage()    {}

func (m *BlockIoSpec_Device) GetMajor() int64 {
	if m != nil && m.Major != nil {
		return *m.Major
	}
	return 0
}

func (m *BlockIoSpec_Device) GetMinor() int64 {
	if m != nil && m.Minor != nil {
		return *m.Minor
	}
	return 0
}

type BlockIoSpec_DeviceLimit struct {
	Device           *BlockIoSpec_Device `protobuf:"bytes,1,opt,name=device" json:"device,omitempty"`
	Limit            *uint64             `protobuf:"varint,2,opt,name=limit" json:"limit,omitempty"`
	XXX_unrecognized []byte              `json:"-"`
}

func (m *BlockIoSpec_DeviceLimit) Reset()         { *m = BlockIoSpec_DeviceLimit{} }
func (m *BlockIoSpec_DeviceLimit) String() string { return proto.CompactTextString(m) }
func (*BlockIoSpec_DeviceLimit) ProtoMessage()    {}

func (m *BlockIoSpec_DeviceLimit) GetDevice() *BlockIoSpec_Device {
	if m != nil {
		return m.Device
	}
	return nil
}

func (m *BlockIoSpec_DeviceLimit) GetLimit() uint64 {
	if m != nil && m.Limit != nil {
		return *m.Limit
	}
	return 0
}

type BlockIoSpec_DeviceLimitSet struct {
	DefaultLimit     *uint32                    `protobuf:"varint,1,opt,name=default_limit" json:"default_limit,omitempty"`
	DeviceLimits     []*BlockIoSpec_DeviceLimit `protobuf:"bytes,2,rep,name=device_limits" json:"device_limits,omitempty"`
	XXX_unrecognized []byte                     `json:"-"`
}

func (m *BlockIoSpec_DeviceLimitSet) Reset()         { *m = BlockIoSpec_DeviceLimitSet{} }
func (m *BlockIoSpec_DeviceLimitSet) String() string { return proto.CompactTextString(m) }
func (*BlockIoSpec_DeviceLimitSet) ProtoMessage()    {}

func (m *BlockIoSpec_DeviceLimitSet) GetDefaultLimit() uint32 {
	if m != nil && m.DefaultLimit != nil {
		return *m.DefaultLimit
	}
	return 0
}

func (m *BlockIoSpec_DeviceLimitSet) GetDeviceLimits() []*BlockIoSpec_DeviceLimit {
	if m != nil {
		return m.DeviceLimits
	}
	return nil
}

type BlockIoSpec_MaxLimit struct {
	Limits           []*BlockIoSpec_DeviceLimit `protobuf:"bytes,1,rep,name=limits" json:"limits,omitempty"`
	OpType           *BlockIoSpec_OpType        `protobuf:"varint,2,opt,name=op_type,enum=containers.BlockIoSpec_OpType" json:"op_type,omitempty"`
	LimitType        *BlockIoSpec_LimitType     `protobuf:"varint,3,opt,name=limit_type,enum=containers.BlockIoSpec_LimitType" json:"limit_type,omitempty"`
	XXX_unrecognized []byte                     `json:"-"`
}

func (m *BlockIoSpec_MaxLimit) Reset()         { *m = BlockIoSpec_MaxLimit{} }
func (m *BlockIoSpec_MaxLimit) String() string { return proto.CompactTextString(m) }
func (*BlockIoSpec_MaxLimit) ProtoMessage()    {}

func (m *BlockIoSpec_MaxLimit) GetLimits() []*BlockIoSpec_DeviceLimit {
	if m != nil {
		return m.Limits
	}
	return nil
}

func (m *BlockIoSpec_MaxLimit) GetOpType() BlockIoSpec_OpType {
	if m != nil && m.OpType != nil {
		return *m.OpType
	}
	return BlockIoSpec_READ
}

func (m *BlockIoSpec_MaxLimit) GetLimitType() BlockIoSpec_LimitType {
	if m != nil && m.LimitType != nil {
		return *m.LimitType
	}
	return BlockIoSpec_BYTES_PER_SECOND
}

type BlockIoSpec_MaxLimitSet struct {
	MaxLimits        []*BlockIoSpec_MaxLimit `protobuf:"bytes,1,rep,name=max_limits" json:"max_limits,omitempty"`
	XXX_unrecognized []byte                  `json:"-"`
}

func (m *BlockIoSpec_MaxLimitSet) Reset()         { *m = BlockIoSpec_MaxLimitSet{} }
func (m *BlockIoSpec_MaxLimitSet) String() string { return proto.CompactTextString(m) }
func (*BlockIoSpec_MaxLimitSet) ProtoMessage()    {}

func (m *BlockIoSpec_MaxLimitSet) GetMaxLimits() []*BlockIoSpec_MaxLimit {
	if m != nil {
		return m.MaxLimits
	}
	return nil
}

type NetworkSpec struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *NetworkSpec) Reset()         { *m = NetworkSpec{} }
func (m *NetworkSpec) String() string { return proto.CompactTextString(m) }
func (*NetworkSpec) ProtoMessage()    {}

type MonitoringSpec struct {
	EnablePerfCounters *bool  `protobuf:"varint,1,opt,name=enable_perf_counters" json:"enable_perf_counters,omitempty"`
	XXX_unrecognized   []byte `json:"-"`
}

func (m *MonitoringSpec) Reset()         { *m = MonitoringSpec{} }
func (m *MonitoringSpec) String() string { return proto.CompactTextString(m) }
func (*MonitoringSpec) ProtoMessage()    {}

func (m *MonitoringSpec) GetEnablePerfCounters() bool {
	if m != nil && m.EnablePerfCounters != nil {
		return *m.EnablePerfCounters
	}
	return false
}

type FilesystemSpec struct {
	FdLimit          *uint64 `protobuf:"varint,1,opt,name=fd_limit" json:"fd_limit,omitempty"`
	Rootfs           *string `protobuf:"bytes,2,opt,name=rootfs" json:"rootfs,omitempty"`
	Mounts           *Mounts `protobuf:"bytes,3,opt,name=mounts" json:"mounts,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *FilesystemSpec) Reset()         { *m = FilesystemSpec{} }
func (m *FilesystemSpec) String() string { return proto.CompactTextString(m) }
func (*FilesystemSpec) ProtoMessage()    {}

func (m *FilesystemSpec) GetFdLimit() uint64 {
	if m != nil && m.FdLimit != nil {
		return *m.FdLimit
	}
	return 0
}

func (m *FilesystemSpec) GetRootfs() string {
	if m != nil && m.Rootfs != nil {
		return *m.Rootfs
	}
	return ""
}

func (m *FilesystemSpec) GetMounts() *Mounts {
	if m != nil {
		return m.Mounts
	}
	return nil
}

type DeviceSpec struct {
	RestrictionsSet  *DeviceSpec_DeviceRestrictionsSet `protobuf:"bytes,1,opt,name=restrictions_set" json:"restrictions_set,omitempty"`
	XXX_unrecognized []byte                            `json:"-"`
}

func (m *DeviceSpec) Reset()         { *m = DeviceSpec{} }
func (m *DeviceSpec) String() string { return proto.CompactTextString(m) }
func (*DeviceSpec) ProtoMessage()    {}

func (m *DeviceSpec) GetRestrictionsSet() *DeviceSpec_DeviceRestrictionsSet {
	if m != nil {
		return m.RestrictionsSet
	}
	return nil
}

type DeviceSpec_DeviceRestrictions struct {
	Permission       *DeviceSpec_DevicePermission `protobuf:"varint,1,opt,name=permission,enum=containers.DeviceSpec_DevicePermission" json:"permission,omitempty"`
	Type             *DeviceSpec_DeviceType       `protobuf:"varint,2,opt,name=type,enum=containers.DeviceSpec_DeviceType" json:"type,omitempty"`
	Access           []DeviceSpec_DeviceAccess    `protobuf:"varint,3,rep,name=access,enum=containers.DeviceSpec_DeviceAccess" json:"access,omitempty"`
	Major            *int64                       `protobuf:"varint,4,opt,name=major" json:"major,omitempty"`
	Minor            *int64                       `protobuf:"varint,5,opt,name=minor" json:"minor,omitempty"`
	XXX_unrecognized []byte                       `json:"-"`
}

func (m *DeviceSpec_DeviceRestrictions) Reset()         { *m = DeviceSpec_DeviceRestrictions{} }
func (m *DeviceSpec_DeviceRestrictions) String() string { return proto.CompactTextString(m) }
func (*DeviceSpec_DeviceRestrictions) ProtoMessage()    {}

func (m *DeviceSpec_DeviceRestrictions) GetPermission() DeviceSpec_DevicePermission {
	if m != nil && m.Permission != nil {
		return *m.Permission
	}
	return DeviceSpec_ALLOW
}

func (m *DeviceSpec_DeviceRestrictions) GetType() DeviceSpec_DeviceType {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return DeviceSpec_DEVICE_CHAR
}

func (m *DeviceSpec_DeviceRestrictions) GetAccess() []DeviceSpec_DeviceAccess {
	if m != nil {
		return m.Access
	}
	return nil
}

func (m *DeviceSpec_DeviceRestrictions) GetMajor() int64 {
	if m != nil && m.Major != nil {
		return *m.Major
	}
	return 0
}

func (m *DeviceSpec_DeviceRestrictions) GetMinor() int64 {
	if m != nil && m.Minor != nil {
		return *m.Minor
	}
	return 0
}

type DeviceSpec_DeviceRestrictionsSet struct {
	Restrictions     []*DeviceSpec_DeviceRestrictions `protobuf:"bytes,1,rep,name=restrictions" json:"restrictions,omitempty"`
	XXX_unrecognized []byte                           `json:"-"`
}

func (m *DeviceSpec_DeviceRestrictionsSet) Reset()         { *m = DeviceSpec_DeviceRestrictionsSet{} }
func (m *DeviceSpec_DeviceRestrictionsSet) String() string { return proto.CompactTextString(m) }
func (*DeviceSpec_DeviceRestrictionsSet) ProtoMessage()    {}

func (m *DeviceSpec_DeviceRestrictionsSet) GetRestrictions() []*DeviceSpec_DeviceRestrictions {
	if m != nil {
		return m.Restrictions
	}
	return nil
}

type SecuritySpec struct {
	ApparmorProfile  *SecuritySpec_AppArmorProfile `protobuf:"bytes,1,opt,name=apparmor_profile" json:"apparmor_profile,omitempty"`
	XXX_unrecognized []byte                        `json:"-"`
}

func (m *SecuritySpec) Reset()         { *m = SecuritySpec{} }
func (m *SecuritySpec) String() string { return proto.CompactTextString(m) }
func (*SecuritySpec) ProtoMessage()    {}

func (m *SecuritySpec) GetApparmorProfile() *SecuritySpec_AppArmorProfile {
	if m != nil {
		return m.ApparmorProfile
	}
	return nil
}

type SecuritySpec_AppArmorProfile struct {
	Name             *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *SecuritySpec_AppArmorProfile) Reset()         { *m = SecuritySpec_AppArmorProfile{} }
func (m *SecuritySpec_AppArmorProfile) String() string { return proto.CompactTextString(m) }
func (*SecuritySpec_AppArmorProfile) ProtoMessage()    {}

func (m *SecuritySpec_AppArmorProfile) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

type ContainerStats struct {
	Cpu              *CpuStats        `protobuf:"bytes,1,opt,name=cpu" json:"cpu,omitempty"`
	Memory           *MemoryStats     `protobuf:"bytes,2,opt,name=memory" json:"memory,omitempty"`
	Network          *NetworkStats    `protobuf:"bytes,4,opt,name=network" json:"network,omitempty"`
	Blockio          *BlockIoStats    `protobuf:"bytes,7,opt,name=blockio" json:"blockio,omitempty"`
	Monitoring       *MonitoringStats `protobuf:"bytes,5,opt,name=monitoring" json:"monitoring,omitempty"`
	Filesystem       *FilesystemStats `protobuf:"bytes,6,opt,name=filesystem" json:"filesystem,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

func (m *ContainerStats) Reset()         { *m = ContainerStats{} }
func (m *ContainerStats) String() string { return proto.CompactTextString(m) }
func (*ContainerStats) ProtoMessage()    {}

func (m *ContainerStats) GetCpu() *CpuStats {
	if m != nil {
		return m.Cpu
	}
	return nil
}

func (m *ContainerStats) GetMemory() *MemoryStats {
	if m != nil {
		return m.Memory
	}
	return nil
}

func (m *ContainerStats) GetNetwork() *NetworkStats {
	if m != nil {
		return m.Network
	}
	return nil
}

func (m *ContainerStats) GetBlockio() *BlockIoStats {
	if m != nil {
		return m.Blockio
	}
	return nil
}

func (m *ContainerStats) GetMonitoring() *MonitoringStats {
	if m != nil {
		return m.Monitoring
	}
	return nil
}

func (m *ContainerStats) GetFilesystem() *FilesystemStats {
	if m != nil {
		return m.Filesystem
	}
	return nil
}

type HistogramMap struct {
	Type             *CpuHistogramType      `protobuf:"varint,1,req,name=type,enum=containers.CpuHistogramType" json:"type,omitempty"`
	Stat             []*HistogramMap_Bucket `protobuf:"bytes,2,rep,name=stat" json:"stat,omitempty"`
	XXX_unrecognized []byte                 `json:"-"`
}

func (m *HistogramMap) Reset()         { *m = HistogramMap{} }
func (m *HistogramMap) String() string { return proto.CompactTextString(m) }
func (*HistogramMap) ProtoMessage()    {}

func (m *HistogramMap) GetType() CpuHistogramType {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return CpuHistogramType_SERVE
}

func (m *HistogramMap) GetStat() []*HistogramMap_Bucket {
	if m != nil {
		return m.Stat
	}
	return nil
}

type HistogramMap_Bucket struct {
	Bucket           *int32 `protobuf:"varint,1,req,name=bucket" json:"bucket,omitempty"`
	Value            *int64 `protobuf:"varint,2,req,name=value" json:"value,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *HistogramMap_Bucket) Reset()         { *m = HistogramMap_Bucket{} }
func (m *HistogramMap_Bucket) String() string { return proto.CompactTextString(m) }
func (*HistogramMap_Bucket) ProtoMessage()    {}

func (m *HistogramMap_Bucket) GetBucket() int32 {
	if m != nil && m.Bucket != nil {
		return *m.Bucket
	}
	return 0
}

func (m *HistogramMap_Bucket) GetValue() int64 {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return 0
}

type ThrottlingData struct {
	Periods          *int64 `protobuf:"varint,1,opt,name=periods" json:"periods,omitempty"`
	ThrottledPeriods *int64 `protobuf:"varint,2,opt,name=throttled_periods" json:"throttled_periods,omitempty"`
	ThrottledTime    *int64 `protobuf:"varint,3,opt,name=throttled_time" json:"throttled_time,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *ThrottlingData) Reset()         { *m = ThrottlingData{} }
func (m *ThrottlingData) String() string { return proto.CompactTextString(m) }
func (*ThrottlingData) ProtoMessage()    {}

func (m *ThrottlingData) GetPeriods() int64 {
	if m != nil && m.Periods != nil {
		return *m.Periods
	}
	return 0
}

func (m *ThrottlingData) GetThrottledPeriods() int64 {
	if m != nil && m.ThrottledPeriods != nil {
		return *m.ThrottledPeriods
	}
	return 0
}

func (m *ThrottlingData) GetThrottledTime() int64 {
	if m != nil && m.ThrottledTime != nil {
		return *m.ThrottledTime
	}
	return 0
}

type CpuStats struct {
	Usage            *CpuStats_Usage `protobuf:"bytes,1,opt,name=usage" json:"usage,omitempty"`
	Load             *int32          `protobuf:"varint,2,opt,name=load" json:"load,omitempty"`
	ThrottlingData   *ThrottlingData `protobuf:"bytes,3,opt,name=throttling_data" json:"throttling_data,omitempty"`
	Histograms       []*HistogramMap `protobuf:"bytes,4,rep,name=histograms" json:"histograms,omitempty"`
	XXX_unrecognized []byte          `json:"-"`
}

func (m *CpuStats) Reset()         { *m = CpuStats{} }
func (m *CpuStats) String() string { return proto.CompactTextString(m) }
func (*CpuStats) ProtoMessage()    {}

func (m *CpuStats) GetUsage() *CpuStats_Usage {
	if m != nil {
		return m.Usage
	}
	return nil
}

func (m *CpuStats) GetLoad() int32 {
	if m != nil && m.Load != nil {
		return *m.Load
	}
	return 0
}

func (m *CpuStats) GetThrottlingData() *ThrottlingData {
	if m != nil {
		return m.ThrottlingData
	}
	return nil
}

func (m *CpuStats) GetHistograms() []*HistogramMap {
	if m != nil {
		return m.Histograms
	}
	return nil
}

type CpuStats_Usage struct {
	Total            *uint64 `protobuf:"varint,1,opt,name=total" json:"total,omitempty"`
	PerCpu           []int64 `protobuf:"varint,2,rep,name=per_cpu" json:"per_cpu,omitempty"`
	User             *int64  `protobuf:"varint,3,opt,name=user" json:"user,omitempty"`
	System           *int64  `protobuf:"varint,4,opt,name=system" json:"system,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *CpuStats_Usage) Reset()         { *m = CpuStats_Usage{} }
func (m *CpuStats_Usage) String() string { return proto.CompactTextString(m) }
func (*CpuStats_Usage) ProtoMessage()    {}

func (m *CpuStats_Usage) GetTotal() uint64 {
	if m != nil && m.Total != nil {
		return *m.Total
	}
	return 0
}

func (m *CpuStats_Usage) GetPerCpu() []int64 {
	if m != nil {
		return m.PerCpu
	}
	return nil
}

func (m *CpuStats_Usage) GetUser() int64 {
	if m != nil && m.User != nil {
		return *m.User
	}
	return 0
}

func (m *CpuStats_Usage) GetSystem() int64 {
	if m != nil && m.System != nil {
		return *m.System
	}
	return 0
}

type MemoryStats struct {
	Limit                   *int64                                `protobuf:"varint,1,opt,name=limit" json:"limit,omitempty"`
	EffectiveLimit          *int64                                `protobuf:"varint,2,opt,name=effective_limit" json:"effective_limit,omitempty"`
	Reservation             *int64                                `protobuf:"varint,3,opt,name=reservation" json:"reservation,omitempty"`
	Usage                   *int64                                `protobuf:"varint,4,opt,name=usage" json:"usage,omitempty"`
	MaxUsage                *int64                                `protobuf:"varint,5,opt,name=max_usage" json:"max_usage,omitempty"`
	WorkingSet              *int64                                `protobuf:"varint,6,opt,name=working_set" json:"working_set,omitempty"`
	ContainerData           *MemoryStats_MemoryData               `protobuf:"bytes,7,opt,name=container_data" json:"container_data,omitempty"`
	HierarchicalData        *MemoryStats_MemoryData               `protobuf:"bytes,8,opt,name=hierarchical_data" json:"hierarchical_data,omitempty"`
	HierarchicalMemoryLimit *int64                                `protobuf:"varint,9,opt,name=hierarchical_memory_limit" json:"hierarchical_memory_limit,omitempty"`
	Numa                    *MemoryStats_NumaStats                `protobuf:"bytes,10,opt,name=numa" json:"numa,omitempty"`
	IdlePage                *MemoryStats_IdlePageStats            `protobuf:"bytes,11,opt,name=idle_page" json:"idle_page,omitempty"`
	CompressionSampling     *MemoryStats_CompressionSamplingStats `protobuf:"bytes,12,opt,name=compression_sampling" json:"compression_sampling,omitempty"`
	FailCount               *int64                                `protobuf:"varint,13,opt,name=fail_count" json:"fail_count,omitempty"`
	XXX_unrecognized        []byte                                `json:"-"`
}

func (m *MemoryStats) Reset()         { *m = MemoryStats{} }
func (m *MemoryStats) String() string { return proto.CompactTextString(m) }
func (*MemoryStats) ProtoMessage()    {}

func (m *MemoryStats) GetLimit() int64 {
	if m != nil && m.Limit != nil {
		return *m.Limit
	}
	return 0
}

func (m *MemoryStats) GetEffectiveLimit() int64 {
	if m != nil && m.EffectiveLimit != nil {
		return *m.EffectiveLimit
	}
	return 0
}

func (m *MemoryStats) GetReservation() int64 {
	if m != nil && m.Reservation != nil {
		return *m.Reservation
	}
	return 0
}

func (m *MemoryStats) GetUsage() int64 {
	if m != nil && m.Usage != nil {
		return *m.Usage
	}
	return 0
}

func (m *MemoryStats) GetMaxUsage() int64 {
	if m != nil && m.MaxUsage != nil {
		return *m.MaxUsage
	}
	return 0
}

func (m *MemoryStats) GetWorkingSet() int64 {
	if m != nil && m.WorkingSet != nil {
		return *m.WorkingSet
	}
	return 0
}

func (m *MemoryStats) GetContainerData() *MemoryStats_MemoryData {
	if m != nil {
		return m.ContainerData
	}
	return nil
}

func (m *MemoryStats) GetHierarchicalData() *MemoryStats_MemoryData {
	if m != nil {
		return m.HierarchicalData
	}
	return nil
}

func (m *MemoryStats) GetHierarchicalMemoryLimit() int64 {
	if m != nil && m.HierarchicalMemoryLimit != nil {
		return *m.HierarchicalMemoryLimit
	}
	return 0
}

func (m *MemoryStats) GetNuma() *MemoryStats_NumaStats {
	if m != nil {
		return m.Numa
	}
	return nil
}

func (m *MemoryStats) GetIdlePage() *MemoryStats_IdlePageStats {
	if m != nil {
		return m.IdlePage
	}
	return nil
}

func (m *MemoryStats) GetCompressionSampling() *MemoryStats_CompressionSamplingStats {
	if m != nil {
		return m.CompressionSampling
	}
	return nil
}

func (m *MemoryStats) GetFailCount() int64 {
	if m != nil && m.FailCount != nil {
		return *m.FailCount
	}
	return 0
}

type MemoryStats_MemoryData struct {
	Cache                        *int64                         `protobuf:"varint,1,opt,name=cache" json:"cache,omitempty"`
	Rss                          *int64                         `protobuf:"varint,2,opt,name=rss" json:"rss,omitempty"`
	RssHuge                      *int64                         `protobuf:"varint,3,opt,name=rss_huge" json:"rss_huge,omitempty"`
	MappedFile                   *int64                         `protobuf:"varint,4,opt,name=mapped_file" json:"mapped_file,omitempty"`
	Pgpgin                       *int64                         `protobuf:"varint,5,opt,name=pgpgin" json:"pgpgin,omitempty"`
	Pgpgout                      *int64                         `protobuf:"varint,6,opt,name=pgpgout" json:"pgpgout,omitempty"`
	Pgfault                      *int64                         `protobuf:"varint,7,opt,name=pgfault" json:"pgfault,omitempty"`
	Pgmajfault                   *int64                         `protobuf:"varint,8,opt,name=pgmajfault" json:"pgmajfault,omitempty"`
	Dirty                        *int64                         `protobuf:"varint,9,opt,name=dirty" json:"dirty,omitempty"`
	Writeback                    *int64                         `protobuf:"varint,10,opt,name=writeback" json:"writeback,omitempty"`
	InactiveAnon                 *int64                         `protobuf:"varint,11,opt,name=inactive_anon" json:"inactive_anon,omitempty"`
	ActiveAnon                   *int64                         `protobuf:"varint,12,opt,name=active_anon" json:"active_anon,omitempty"`
	InactiveFile                 *int64                         `protobuf:"varint,13,opt,name=inactive_file" json:"inactive_file,omitempty"`
	ActiveFile                   *int64                         `protobuf:"varint,14,opt,name=active_file" json:"active_file,omitempty"`
	Unevictable                  *int64                         `protobuf:"varint,15,opt,name=unevictable" json:"unevictable,omitempty"`
	Thp                          *MemoryStats_MemoryData_THP    `protobuf:"bytes,16,opt,name=thp" json:"thp,omitempty"`
	Kernel                       *MemoryStats_MemoryData_Kernel `protobuf:"bytes,17,opt,name=kernel" json:"kernel,omitempty"`
	KernelNoncharged             *MemoryStats_MemoryData_Kernel `protobuf:"bytes,18,opt,name=kernel_noncharged" json:"kernel_noncharged,omitempty"`
	CompressedPoolPages          *int64                         `protobuf:"varint,19,opt,name=compressed_pool_pages" json:"compressed_pool_pages,omitempty"`
	CompressedStoredPages        *int64                         `protobuf:"varint,20,opt,name=compressed_stored_pages" json:"compressed_stored_pages,omitempty"`
	CompressedRejectCompressPoor *int64                         `protobuf:"varint,21,opt,name=compressed_reject_compress_poor" json:"compressed_reject_compress_poor,omitempty"`
	ZswapZsmallocFail            *int64                         `protobuf:"varint,22,opt,name=zswap_zsmalloc_fail" json:"zswap_zsmalloc_fail,omitempty"`
	ZswapKmemcacheFail           *int64                         `protobuf:"varint,23,opt,name=zswap_kmemcache_fail" json:"zswap_kmemcache_fail,omitempty"`
	ZswapDuplicateEntry          *int64                         `protobuf:"varint,24,opt,name=zswap_duplicate_entry" json:"zswap_duplicate_entry,omitempty"`
	ZswapCompressedPages         *int64                         `protobuf:"varint,25,opt,name=zswap_compressed_pages" json:"zswap_compressed_pages,omitempty"`
	ZswapDecompressedPages       *int64                         `protobuf:"varint,26,opt,name=zswap_decompressed_pages" json:"zswap_decompressed_pages,omitempty"`
	ZswapCompressionNsec         *int64                         `protobuf:"varint,27,opt,name=zswap_compression_nsec" json:"zswap_compression_nsec,omitempty"`
	ZswapDecompressionNsec       *int64                         `protobuf:"varint,28,opt,name=zswap_decompression_nsec" json:"zswap_decompression_nsec,omitempty"`
	XXX_unrecognized             []byte                         `json:"-"`
}

func (m *MemoryStats_MemoryData) Reset()         { *m = MemoryStats_MemoryData{} }
func (m *MemoryStats_MemoryData) String() string { return proto.CompactTextString(m) }
func (*MemoryStats_MemoryData) ProtoMessage()    {}

func (m *MemoryStats_MemoryData) GetCache() int64 {
	if m != nil && m.Cache != nil {
		return *m.Cache
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetRss() int64 {
	if m != nil && m.Rss != nil {
		return *m.Rss
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetRssHuge() int64 {
	if m != nil && m.RssHuge != nil {
		return *m.RssHuge
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetMappedFile() int64 {
	if m != nil && m.MappedFile != nil {
		return *m.MappedFile
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetPgpgin() int64 {
	if m != nil && m.Pgpgin != nil {
		return *m.Pgpgin
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetPgpgout() int64 {
	if m != nil && m.Pgpgout != nil {
		return *m.Pgpgout
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetPgfault() int64 {
	if m != nil && m.Pgfault != nil {
		return *m.Pgfault
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetPgmajfault() int64 {
	if m != nil && m.Pgmajfault != nil {
		return *m.Pgmajfault
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetDirty() int64 {
	if m != nil && m.Dirty != nil {
		return *m.Dirty
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetWriteback() int64 {
	if m != nil && m.Writeback != nil {
		return *m.Writeback
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetInactiveAnon() int64 {
	if m != nil && m.InactiveAnon != nil {
		return *m.InactiveAnon
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetActiveAnon() int64 {
	if m != nil && m.ActiveAnon != nil {
		return *m.ActiveAnon
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetInactiveFile() int64 {
	if m != nil && m.InactiveFile != nil {
		return *m.InactiveFile
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetActiveFile() int64 {
	if m != nil && m.ActiveFile != nil {
		return *m.ActiveFile
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetUnevictable() int64 {
	if m != nil && m.Unevictable != nil {
		return *m.Unevictable
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetThp() *MemoryStats_MemoryData_THP {
	if m != nil {
		return m.Thp
	}
	return nil
}

func (m *MemoryStats_MemoryData) GetKernel() *MemoryStats_MemoryData_Kernel {
	if m != nil {
		return m.Kernel
	}
	return nil
}

func (m *MemoryStats_MemoryData) GetKernelNoncharged() *MemoryStats_MemoryData_Kernel {
	if m != nil {
		return m.KernelNoncharged
	}
	return nil
}

func (m *MemoryStats_MemoryData) GetCompressedPoolPages() int64 {
	if m != nil && m.CompressedPoolPages != nil {
		return *m.CompressedPoolPages
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetCompressedStoredPages() int64 {
	if m != nil && m.CompressedStoredPages != nil {
		return *m.CompressedStoredPages
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetCompressedRejectCompressPoor() int64 {
	if m != nil && m.CompressedRejectCompressPoor != nil {
		return *m.CompressedRejectCompressPoor
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetZswapZsmallocFail() int64 {
	if m != nil && m.ZswapZsmallocFail != nil {
		return *m.ZswapZsmallocFail
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetZswapKmemcacheFail() int64 {
	if m != nil && m.ZswapKmemcacheFail != nil {
		return *m.ZswapKmemcacheFail
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetZswapDuplicateEntry() int64 {
	if m != nil && m.ZswapDuplicateEntry != nil {
		return *m.ZswapDuplicateEntry
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetZswapCompressedPages() int64 {
	if m != nil && m.ZswapCompressedPages != nil {
		return *m.ZswapCompressedPages
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetZswapDecompressedPages() int64 {
	if m != nil && m.ZswapDecompressedPages != nil {
		return *m.ZswapDecompressedPages
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetZswapCompressionNsec() int64 {
	if m != nil && m.ZswapCompressionNsec != nil {
		return *m.ZswapCompressionNsec
	}
	return 0
}

func (m *MemoryStats_MemoryData) GetZswapDecompressionNsec() int64 {
	if m != nil && m.ZswapDecompressionNsec != nil {
		return *m.ZswapDecompressionNsec
	}
	return 0
}

type MemoryStats_MemoryData_THP struct {
	FaultAlloc          *int64 `protobuf:"varint,1,opt,name=fault_alloc" json:"fault_alloc,omitempty"`
	FaultFallback       *int64 `protobuf:"varint,2,opt,name=fault_fallback" json:"fault_fallback,omitempty"`
	CollapseAlloc       *int64 `protobuf:"varint,3,opt,name=collapse_alloc" json:"collapse_alloc,omitempty"`
	CollapseAllocFailed *int64 `protobuf:"varint,4,opt,name=collapse_alloc_failed" json:"collapse_alloc_failed,omitempty"`
	Split               *int64 `protobuf:"varint,5,opt,name=split" json:"split,omitempty"`
	XXX_unrecognized    []byte `json:"-"`
}

func (m *MemoryStats_MemoryData_THP) Reset()         { *m = MemoryStats_MemoryData_THP{} }
func (m *MemoryStats_MemoryData_THP) String() string { return proto.CompactTextString(m) }
func (*MemoryStats_MemoryData_THP) ProtoMessage()    {}

func (m *MemoryStats_MemoryData_THP) GetFaultAlloc() int64 {
	if m != nil && m.FaultAlloc != nil {
		return *m.FaultAlloc
	}
	return 0
}

func (m *MemoryStats_MemoryData_THP) GetFaultFallback() int64 {
	if m != nil && m.FaultFallback != nil {
		return *m.FaultFallback
	}
	return 0
}

func (m *MemoryStats_MemoryData_THP) GetCollapseAlloc() int64 {
	if m != nil && m.CollapseAlloc != nil {
		return *m.CollapseAlloc
	}
	return 0
}

func (m *MemoryStats_MemoryData_THP) GetCollapseAllocFailed() int64 {
	if m != nil && m.CollapseAllocFailed != nil {
		return *m.CollapseAllocFailed
	}
	return 0
}

func (m *MemoryStats_MemoryData_THP) GetSplit() int64 {
	if m != nil && m.Split != nil {
		return *m.Split
	}
	return 0
}

type MemoryStats_MemoryData_Kernel struct {
	Memory             *int64 `protobuf:"varint,1,opt,name=memory" json:"memory,omitempty"`
	SlabMemory         *int64 `protobuf:"varint,2,opt,name=slab_memory" json:"slab_memory,omitempty"`
	StackMemory        *int64 `protobuf:"varint,3,opt,name=stack_memory" json:"stack_memory,omitempty"`
	PgtableMemory      *int64 `protobuf:"varint,4,opt,name=pgtable_memory" json:"pgtable_memory,omitempty"`
	VmallocMemory      *int64 `protobuf:"varint,5,opt,name=vmalloc_memory" json:"vmalloc_memory,omitempty"`
	MiscMemory         *int64 `protobuf:"varint,6,opt,name=misc_memory" json:"misc_memory,omitempty"`
	TargetedSlabMemory *int64 `protobuf:"varint,7,opt,name=targeted_slab_memory" json:"targeted_slab_memory,omitempty"`
	CompressedMemory   *int64 `protobuf:"varint,8,opt,name=compressed_memory" json:"compressed_memory,omitempty"`
	XXX_unrecognized   []byte `json:"-"`
}

func (m *MemoryStats_MemoryData_Kernel) Reset()         { *m = MemoryStats_MemoryData_Kernel{} }
func (m *MemoryStats_MemoryData_Kernel) String() string { return proto.CompactTextString(m) }
func (*MemoryStats_MemoryData_Kernel) ProtoMessage()    {}

func (m *MemoryStats_MemoryData_Kernel) GetMemory() int64 {
	if m != nil && m.Memory != nil {
		return *m.Memory
	}
	return 0
}

func (m *MemoryStats_MemoryData_Kernel) GetSlabMemory() int64 {
	if m != nil && m.SlabMemory != nil {
		return *m.SlabMemory
	}
	return 0
}

func (m *MemoryStats_MemoryData_Kernel) GetStackMemory() int64 {
	if m != nil && m.StackMemory != nil {
		return *m.StackMemory
	}
	return 0
}

func (m *MemoryStats_MemoryData_Kernel) GetPgtableMemory() int64 {
	if m != nil && m.PgtableMemory != nil {
		return *m.PgtableMemory
	}
	return 0
}

func (m *MemoryStats_MemoryData_Kernel) GetVmallocMemory() int64 {
	if m != nil && m.VmallocMemory != nil {
		return *m.VmallocMemory
	}
	return 0
}

func (m *MemoryStats_MemoryData_Kernel) GetMiscMemory() int64 {
	if m != nil && m.MiscMemory != nil {
		return *m.MiscMemory
	}
	return 0
}

func (m *MemoryStats_MemoryData_Kernel) GetTargetedSlabMemory() int64 {
	if m != nil && m.TargetedSlabMemory != nil {
		return *m.TargetedSlabMemory
	}
	return 0
}

func (m *MemoryStats_MemoryData_Kernel) GetCompressedMemory() int64 {
	if m != nil && m.CompressedMemory != nil {
		return *m.CompressedMemory
	}
	return 0
}

type MemoryStats_NumaStats struct {
	ContainerData    *MemoryStats_NumaStats_NumaData `protobuf:"bytes,1,opt,name=container_data" json:"container_data,omitempty"`
	HierarchicalData *MemoryStats_NumaStats_NumaData `protobuf:"bytes,2,opt,name=hierarchical_data" json:"hierarchical_data,omitempty"`
	XXX_unrecognized []byte                          `json:"-"`
}

func (m *MemoryStats_NumaStats) Reset()         { *m = MemoryStats_NumaStats{} }
func (m *MemoryStats_NumaStats) String() string { return proto.CompactTextString(m) }
func (*MemoryStats_NumaStats) ProtoMessage()    {}

func (m *MemoryStats_NumaStats) GetContainerData() *MemoryStats_NumaStats_NumaData {
	if m != nil {
		return m.ContainerData
	}
	return nil
}

func (m *MemoryStats_NumaStats) GetHierarchicalData() *MemoryStats_NumaStats_NumaData {
	if m != nil {
		return m.HierarchicalData
	}
	return nil
}

type MemoryStats_NumaStats_NumaData struct {
	Total            *MemoryStats_NumaStats_NumaData_Stat `protobuf:"bytes,1,opt,name=total" json:"total,omitempty"`
	File             *MemoryStats_NumaStats_NumaData_Stat `protobuf:"bytes,2,opt,name=file" json:"file,omitempty"`
	Anon             *MemoryStats_NumaStats_NumaData_Stat `protobuf:"bytes,3,opt,name=anon" json:"anon,omitempty"`
	Unevictable      *MemoryStats_NumaStats_NumaData_Stat `protobuf:"bytes,4,opt,name=unevictable" json:"unevictable,omitempty"`
	XXX_unrecognized []byte                               `json:"-"`
}

func (m *MemoryStats_NumaStats_NumaData) Reset()         { *m = MemoryStats_NumaStats_NumaData{} }
func (m *MemoryStats_NumaStats_NumaData) String() string { return proto.CompactTextString(m) }
func (*MemoryStats_NumaStats_NumaData) ProtoMessage()    {}

func (m *MemoryStats_NumaStats_NumaData) GetTotal() *MemoryStats_NumaStats_NumaData_Stat {
	if m != nil {
		return m.Total
	}
	return nil
}

func (m *MemoryStats_NumaStats_NumaData) GetFile() *MemoryStats_NumaStats_NumaData_Stat {
	if m != nil {
		return m.File
	}
	return nil
}

func (m *MemoryStats_NumaStats_NumaData) GetAnon() *MemoryStats_NumaStats_NumaData_Stat {
	if m != nil {
		return m.Anon
	}
	return nil
}

func (m *MemoryStats_NumaStats_NumaData) GetUnevictable() *MemoryStats_NumaStats_NumaData_Stat {
	if m != nil {
		return m.Unevictable
	}
	return nil
}

type MemoryStats_NumaStats_NumaData_Stat struct {
	Node             []*MemoryStats_NumaStats_NumaData_Stat_Node `protobuf:"bytes,1,rep,name=node" json:"node,omitempty"`
	TotalPageCount   *int64                                      `protobuf:"varint,2,opt,name=total_page_count" json:"total_page_count,omitempty"`
	XXX_unrecognized []byte                                      `json:"-"`
}

func (m *MemoryStats_NumaStats_NumaData_Stat) Reset()         { *m = MemoryStats_NumaStats_NumaData_Stat{} }
func (m *MemoryStats_NumaStats_NumaData_Stat) String() string { return proto.CompactTextString(m) }
func (*MemoryStats_NumaStats_NumaData_Stat) ProtoMessage()    {}

func (m *MemoryStats_NumaStats_NumaData_Stat) GetNode() []*MemoryStats_NumaStats_NumaData_Stat_Node {
	if m != nil {
		return m.Node
	}
	return nil
}

func (m *MemoryStats_NumaStats_NumaData_Stat) GetTotalPageCount() int64 {
	if m != nil && m.TotalPageCount != nil {
		return *m.TotalPageCount
	}
	return 0
}

type MemoryStats_NumaStats_NumaData_Stat_Node struct {
	Level            *int32 `protobuf:"varint,1,opt,name=level" json:"level,omitempty"`
	PageCount        *int64 `protobuf:"varint,2,opt,name=page_count" json:"page_count,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *MemoryStats_NumaStats_NumaData_Stat_Node) Reset() {
	*m = MemoryStats_NumaStats_NumaData_Stat_Node{}
}
func (m *MemoryStats_NumaStats_NumaData_Stat_Node) String() string { return proto.CompactTextString(m) }
func (*MemoryStats_NumaStats_NumaData_Stat_Node) ProtoMessage()    {}

func (m *MemoryStats_NumaStats_NumaData_Stat_Node) GetLevel() int32 {
	if m != nil && m.Level != nil {
		return *m.Level
	}
	return 0
}

func (m *MemoryStats_NumaStats_NumaData_Stat_Node) GetPageCount() int64 {
	if m != nil && m.PageCount != nil {
		return *m.PageCount
	}
	return 0
}

type MemoryStats_IdlePageStats struct {
	Stats            []*MemoryStats_IdlePageStats_Stats `protobuf:"bytes,1,rep,name=stats" json:"stats,omitempty"`
	Scans            *int64                             `protobuf:"varint,2,opt,name=scans" json:"scans,omitempty"`
	Stale            *int64                             `protobuf:"varint,3,opt,name=stale" json:"stale,omitempty"`
	XXX_unrecognized []byte                             `json:"-"`
}

func (m *MemoryStats_IdlePageStats) Reset()         { *m = MemoryStats_IdlePageStats{} }
func (m *MemoryStats_IdlePageStats) String() string { return proto.CompactTextString(m) }
func (*MemoryStats_IdlePageStats) ProtoMessage()    {}

func (m *MemoryStats_IdlePageStats) GetStats() []*MemoryStats_IdlePageStats_Stats {
	if m != nil {
		return m.Stats
	}
	return nil
}

func (m *MemoryStats_IdlePageStats) GetScans() int64 {
	if m != nil && m.Scans != nil {
		return *m.Scans
	}
	return 0
}

func (m *MemoryStats_IdlePageStats) GetStale() int64 {
	if m != nil && m.Stale != nil {
		return *m.Stale
	}
	return 0
}

type MemoryStats_IdlePageStats_Stats struct {
	AgeInSecs        *int32 `protobuf:"varint,1,opt,name=age_in_secs" json:"age_in_secs,omitempty"`
	Clean            *int64 `protobuf:"varint,2,opt,name=clean" json:"clean,omitempty"`
	DirtyFile        *int64 `protobuf:"varint,3,opt,name=dirty_file" json:"dirty_file,omitempty"`
	DirtySwap        *int64 `protobuf:"varint,4,opt,name=dirty_swap" json:"dirty_swap,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *MemoryStats_IdlePageStats_Stats) Reset()         { *m = MemoryStats_IdlePageStats_Stats{} }
func (m *MemoryStats_IdlePageStats_Stats) String() string { return proto.CompactTextString(m) }
func (*MemoryStats_IdlePageStats_Stats) ProtoMessage()    {}

func (m *MemoryStats_IdlePageStats_Stats) GetAgeInSecs() int32 {
	if m != nil && m.AgeInSecs != nil {
		return *m.AgeInSecs
	}
	return 0
}

func (m *MemoryStats_IdlePageStats_Stats) GetClean() int64 {
	if m != nil && m.Clean != nil {
		return *m.Clean
	}
	return 0
}

func (m *MemoryStats_IdlePageStats_Stats) GetDirtyFile() int64 {
	if m != nil && m.DirtyFile != nil {
		return *m.DirtyFile
	}
	return 0
}

func (m *MemoryStats_IdlePageStats_Stats) GetDirtySwap() int64 {
	if m != nil && m.DirtySwap != nil {
		return *m.DirtySwap
	}
	return 0
}

type MemoryStats_CompressionSamplingStats struct {
	RawSize          *int64 `protobuf:"varint,1,opt,name=raw_size" json:"raw_size,omitempty"`
	CompressedSize   *int64 `protobuf:"varint,2,opt,name=compressed_size" json:"compressed_size,omitempty"`
	FifoOverflow     *int64 `protobuf:"varint,3,opt,name=fifo_overflow" json:"fifo_overflow,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *MemoryStats_CompressionSamplingStats) Reset()         { *m = MemoryStats_CompressionSamplingStats{} }
func (m *MemoryStats_CompressionSamplingStats) String() string { return proto.CompactTextString(m) }
func (*MemoryStats_CompressionSamplingStats) ProtoMessage()    {}

func (m *MemoryStats_CompressionSamplingStats) GetRawSize() int64 {
	if m != nil && m.RawSize != nil {
		return *m.RawSize
	}
	return 0
}

func (m *MemoryStats_CompressionSamplingStats) GetCompressedSize() int64 {
	if m != nil && m.CompressedSize != nil {
		return *m.CompressedSize
	}
	return 0
}

func (m *MemoryStats_CompressionSamplingStats) GetFifoOverflow() int64 {
	if m != nil && m.FifoOverflow != nil {
		return *m.FifoOverflow
	}
	return 0
}

type BlockIoStats struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *BlockIoStats) Reset()         { *m = BlockIoStats{} }
func (m *BlockIoStats) String() string { return proto.CompactTextString(m) }
func (*BlockIoStats) ProtoMessage()    {}

type NetworkStats struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *NetworkStats) Reset()         { *m = NetworkStats{} }
func (m *NetworkStats) String() string { return proto.CompactTextString(m) }
func (*NetworkStats) ProtoMessage()    {}

type MonitoringStats struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *MonitoringStats) Reset()         { *m = MonitoringStats{} }
func (m *MonitoringStats) String() string { return proto.CompactTextString(m) }
func (*MonitoringStats) ProtoMessage()    {}

type FilesystemStats struct {
	FdUsage          *int64 `protobuf:"varint,1,opt,name=fd_usage" json:"fd_usage,omitempty"`
	FdMaxUsage       *int64 `protobuf:"varint,2,opt,name=fd_max_usage" json:"fd_max_usage,omitempty"`
	FdFailCount      *int64 `protobuf:"varint,3,opt,name=fd_fail_count" json:"fd_fail_count,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *FilesystemStats) Reset()         { *m = FilesystemStats{} }
func (m *FilesystemStats) String() string { return proto.CompactTextString(m) }
func (*FilesystemStats) ProtoMessage()    {}

func (m *FilesystemStats) GetFdUsage() int64 {
	if m != nil && m.FdUsage != nil {
		return *m.FdUsage
	}
	return 0
}

func (m *FilesystemStats) GetFdMaxUsage() int64 {
	if m != nil && m.FdMaxUsage != nil {
		return *m.FdMaxUsage
	}
	return 0
}

func (m *FilesystemStats) GetFdFailCount() int64 {
	if m != nil && m.FdFailCount != nil {
		return *m.FdFailCount
	}
	return 0
}

func init() {
	proto.RegisterEnum("containers.SchedulingLatency", SchedulingLatency_name, SchedulingLatency_value)
	proto.RegisterEnum("containers.CpuHistogramType", CpuHistogramType_name, CpuHistogramType_value)
	proto.RegisterEnum("containers.RunSpec_FdPolicy", RunSpec_FdPolicy_name, RunSpec_FdPolicy_value)
	proto.RegisterEnum("containers.BlockIoSpec_OpType", BlockIoSpec_OpType_name, BlockIoSpec_OpType_value)
	proto.RegisterEnum("containers.BlockIoSpec_LimitType", BlockIoSpec_LimitType_name, BlockIoSpec_LimitType_value)
	proto.RegisterEnum("containers.DeviceSpec_DeviceType", DeviceSpec_DeviceType_name, DeviceSpec_DeviceType_value)
	proto.RegisterEnum("containers.DeviceSpec_DeviceAccess", DeviceSpec_DeviceAccess_name, DeviceSpec_DeviceAccess_value)
	proto.RegisterEnum("containers.DeviceSpec_DevicePermission", DeviceSpec_DevicePermission_name, DeviceSpec_DevicePermission_value)
}