...

Source file src/github.com/Microsoft/hcsshim/internal/vmservice/vmservice.pb.go

Documentation: github.com/Microsoft/hcsshim/internal/vmservice

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: github.com/Microsoft/hcsshim/internal/vmservice/vmservice.proto
     3  
     4  package vmservice
     5  
     6  import (
     7  	context "context"
     8  	fmt "fmt"
     9  	github_com_containerd_ttrpc "github.com/containerd/ttrpc"
    10  	proto "github.com/gogo/protobuf/proto"
    11  	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
    12  	types "github.com/gogo/protobuf/types"
    13  	io "io"
    14  	math "math"
    15  	math_bits "math/bits"
    16  	reflect "reflect"
    17  	strings "strings"
    18  )
    19  
    20  // Reference imports to suppress errors if they are not otherwise used.
    21  var _ = proto.Marshal
    22  var _ = fmt.Errorf
    23  var _ = math.Inf
    24  
    25  // This is a compile-time assertion to ensure that this generated file
    26  // is compatible with the proto package it is being compiled against.
    27  // A compilation error at this line likely means your copy of the
    28  // proto package needs to be updated.
    29  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    30  
    31  type ModifyType int32
    32  
    33  const (
    34  	ModifyType_ADD    ModifyType = 0
    35  	ModifyType_REMOVE ModifyType = 1
    36  	ModifyType_UPDATE ModifyType = 2
    37  )
    38  
    39  var ModifyType_name = map[int32]string{
    40  	0: "ADD",
    41  	1: "REMOVE",
    42  	2: "UPDATE",
    43  }
    44  
    45  var ModifyType_value = map[string]int32{
    46  	"ADD":    0,
    47  	"REMOVE": 1,
    48  	"UPDATE": 2,
    49  }
    50  
    51  func (x ModifyType) String() string {
    52  	return proto.EnumName(ModifyType_name, int32(x))
    53  }
    54  
    55  func (ModifyType) EnumDescriptor() ([]byte, []int) {
    56  	return fileDescriptor_272f12cfdaa6c7c8, []int{0}
    57  }
    58  
    59  type DiskType int32
    60  
    61  const (
    62  	DiskType_SCSI_DISK_TYPE_VHD1     DiskType = 0
    63  	DiskType_SCSI_DISK_TYPE_VHDX     DiskType = 1
    64  	DiskType_SCSI_DISK_TYPE_PHYSICAL DiskType = 2
    65  )
    66  
    67  var DiskType_name = map[int32]string{
    68  	0: "SCSI_DISK_TYPE_VHD1",
    69  	1: "SCSI_DISK_TYPE_VHDX",
    70  	2: "SCSI_DISK_TYPE_PHYSICAL",
    71  }
    72  
    73  var DiskType_value = map[string]int32{
    74  	"SCSI_DISK_TYPE_VHD1":     0,
    75  	"SCSI_DISK_TYPE_VHDX":     1,
    76  	"SCSI_DISK_TYPE_PHYSICAL": 2,
    77  }
    78  
    79  func (x DiskType) String() string {
    80  	return proto.EnumName(DiskType_name, int32(x))
    81  }
    82  
    83  func (DiskType) EnumDescriptor() ([]byte, []int) {
    84  	return fileDescriptor_272f12cfdaa6c7c8, []int{1}
    85  }
    86  
    87  type PropertiesVMRequest_PropertiesType int32
    88  
    89  const (
    90  	PropertiesVMRequest_Memory    PropertiesVMRequest_PropertiesType = 0
    91  	PropertiesVMRequest_Processor PropertiesVMRequest_PropertiesType = 1
    92  )
    93  
    94  var PropertiesVMRequest_PropertiesType_name = map[int32]string{
    95  	0: "Memory",
    96  	1: "Processor",
    97  }
    98  
    99  var PropertiesVMRequest_PropertiesType_value = map[string]int32{
   100  	"Memory":    0,
   101  	"Processor": 1,
   102  }
   103  
   104  func (x PropertiesVMRequest_PropertiesType) String() string {
   105  	return proto.EnumName(PropertiesVMRequest_PropertiesType_name, int32(x))
   106  }
   107  
   108  func (PropertiesVMRequest_PropertiesType) EnumDescriptor() ([]byte, []int) {
   109  	return fileDescriptor_272f12cfdaa6c7c8, []int{13, 0}
   110  }
   111  
   112  type CapabilitiesVMResponse_Resource int32
   113  
   114  const (
   115  	CapabilitiesVMResponse_Vpmem     CapabilitiesVMResponse_Resource = 0
   116  	CapabilitiesVMResponse_Scsi      CapabilitiesVMResponse_Resource = 1
   117  	CapabilitiesVMResponse_Vpci      CapabilitiesVMResponse_Resource = 2
   118  	CapabilitiesVMResponse_Plan9     CapabilitiesVMResponse_Resource = 3
   119  	CapabilitiesVMResponse_VMNic     CapabilitiesVMResponse_Resource = 4
   120  	CapabilitiesVMResponse_Memory    CapabilitiesVMResponse_Resource = 5
   121  	CapabilitiesVMResponse_Processor CapabilitiesVMResponse_Resource = 6
   122  )
   123  
   124  var CapabilitiesVMResponse_Resource_name = map[int32]string{
   125  	0: "Vpmem",
   126  	1: "Scsi",
   127  	2: "Vpci",
   128  	3: "Plan9",
   129  	4: "VMNic",
   130  	5: "Memory",
   131  	6: "Processor",
   132  }
   133  
   134  var CapabilitiesVMResponse_Resource_value = map[string]int32{
   135  	"Vpmem":     0,
   136  	"Scsi":      1,
   137  	"Vpci":      2,
   138  	"Plan9":     3,
   139  	"VMNic":     4,
   140  	"Memory":    5,
   141  	"Processor": 6,
   142  }
   143  
   144  func (x CapabilitiesVMResponse_Resource) String() string {
   145  	return proto.EnumName(CapabilitiesVMResponse_Resource_name, int32(x))
   146  }
   147  
   148  func (CapabilitiesVMResponse_Resource) EnumDescriptor() ([]byte, []int) {
   149  	return fileDescriptor_272f12cfdaa6c7c8, []int{15, 0}
   150  }
   151  
   152  type CapabilitiesVMResponse_SupportedGuestOS int32
   153  
   154  const (
   155  	CapabilitiesVMResponse_Windows CapabilitiesVMResponse_SupportedGuestOS = 0
   156  	CapabilitiesVMResponse_Linux   CapabilitiesVMResponse_SupportedGuestOS = 1
   157  )
   158  
   159  var CapabilitiesVMResponse_SupportedGuestOS_name = map[int32]string{
   160  	0: "Windows",
   161  	1: "Linux",
   162  }
   163  
   164  var CapabilitiesVMResponse_SupportedGuestOS_value = map[string]int32{
   165  	"Windows": 0,
   166  	"Linux":   1,
   167  }
   168  
   169  func (x CapabilitiesVMResponse_SupportedGuestOS) String() string {
   170  	return proto.EnumName(CapabilitiesVMResponse_SupportedGuestOS_name, int32(x))
   171  }
   172  
   173  func (CapabilitiesVMResponse_SupportedGuestOS) EnumDescriptor() ([]byte, []int) {
   174  	return fileDescriptor_272f12cfdaa6c7c8, []int{15, 1}
   175  }
   176  
   177  type DirectBoot struct {
   178  	KernelPath           string   `protobuf:"bytes,1,opt,name=kernel_path,json=kernelPath,proto3" json:"kernel_path,omitempty"`
   179  	InitrdPath           string   `protobuf:"bytes,2,opt,name=initrd_path,json=initrdPath,proto3" json:"initrd_path,omitempty"`
   180  	KernelCmdline        string   `protobuf:"bytes,3,opt,name=kernel_cmdline,json=kernelCmdline,proto3" json:"kernel_cmdline,omitempty"`
   181  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   182  	XXX_unrecognized     []byte   `json:"-"`
   183  	XXX_sizecache        int32    `json:"-"`
   184  }
   185  
   186  func (m *DirectBoot) Reset()      { *m = DirectBoot{} }
   187  func (*DirectBoot) ProtoMessage() {}
   188  func (*DirectBoot) Descriptor() ([]byte, []int) {
   189  	return fileDescriptor_272f12cfdaa6c7c8, []int{0}
   190  }
   191  func (m *DirectBoot) XXX_Unmarshal(b []byte) error {
   192  	return m.Unmarshal(b)
   193  }
   194  func (m *DirectBoot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   195  	if deterministic {
   196  		return xxx_messageInfo_DirectBoot.Marshal(b, m, deterministic)
   197  	} else {
   198  		b = b[:cap(b)]
   199  		n, err := m.MarshalToSizedBuffer(b)
   200  		if err != nil {
   201  			return nil, err
   202  		}
   203  		return b[:n], nil
   204  	}
   205  }
   206  func (m *DirectBoot) XXX_Merge(src proto.Message) {
   207  	xxx_messageInfo_DirectBoot.Merge(m, src)
   208  }
   209  func (m *DirectBoot) XXX_Size() int {
   210  	return m.Size()
   211  }
   212  func (m *DirectBoot) XXX_DiscardUnknown() {
   213  	xxx_messageInfo_DirectBoot.DiscardUnknown(m)
   214  }
   215  
   216  var xxx_messageInfo_DirectBoot proto.InternalMessageInfo
   217  
   218  type UEFI struct {
   219  	FirmwarePath string `protobuf:"bytes,1,opt,name=firmware_path,json=firmwarePath,proto3" json:"firmware_path,omitempty"`
   220  	DevicePath   string `protobuf:"bytes,2,opt,name=device_path,json=devicePath,proto3" json:"device_path,omitempty"`
   221  	// Optional data to include for uefi boot. For Linux this could be used as the kernel
   222  	// commandline.
   223  	OptionalData         string   `protobuf:"bytes,3,opt,name=optional_data,json=optionalData,proto3" json:"optional_data,omitempty"`
   224  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   225  	XXX_unrecognized     []byte   `json:"-"`
   226  	XXX_sizecache        int32    `json:"-"`
   227  }
   228  
   229  func (m *UEFI) Reset()      { *m = UEFI{} }
   230  func (*UEFI) ProtoMessage() {}
   231  func (*UEFI) Descriptor() ([]byte, []int) {
   232  	return fileDescriptor_272f12cfdaa6c7c8, []int{1}
   233  }
   234  func (m *UEFI) XXX_Unmarshal(b []byte) error {
   235  	return m.Unmarshal(b)
   236  }
   237  func (m *UEFI) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   238  	if deterministic {
   239  		return xxx_messageInfo_UEFI.Marshal(b, m, deterministic)
   240  	} else {
   241  		b = b[:cap(b)]
   242  		n, err := m.MarshalToSizedBuffer(b)
   243  		if err != nil {
   244  			return nil, err
   245  		}
   246  		return b[:n], nil
   247  	}
   248  }
   249  func (m *UEFI) XXX_Merge(src proto.Message) {
   250  	xxx_messageInfo_UEFI.Merge(m, src)
   251  }
   252  func (m *UEFI) XXX_Size() int {
   253  	return m.Size()
   254  }
   255  func (m *UEFI) XXX_DiscardUnknown() {
   256  	xxx_messageInfo_UEFI.DiscardUnknown(m)
   257  }
   258  
   259  var xxx_messageInfo_UEFI proto.InternalMessageInfo
   260  
   261  type MemoryConfig struct {
   262  	MemoryMb             uint64   `protobuf:"varint,1,opt,name=memory_mb,json=memoryMb,proto3" json:"memory_mb,omitempty"`
   263  	AllowOvercommit      bool     `protobuf:"varint,2,opt,name=allow_overcommit,json=allowOvercommit,proto3" json:"allow_overcommit,omitempty"`
   264  	DeferredCommit       bool     `protobuf:"varint,3,opt,name=deferred_commit,json=deferredCommit,proto3" json:"deferred_commit,omitempty"`
   265  	HotHint              bool     `protobuf:"varint,4,opt,name=hot_hint,json=hotHint,proto3" json:"hot_hint,omitempty"`
   266  	ColdHint             bool     `protobuf:"varint,5,opt,name=cold_hint,json=coldHint,proto3" json:"cold_hint,omitempty"`
   267  	ColdDiscardHint      bool     `protobuf:"varint,6,opt,name=cold_discard_hint,json=coldDiscardHint,proto3" json:"cold_discard_hint,omitempty"`
   268  	LowMmioGapInMb       uint64   `protobuf:"varint,7,opt,name=low_mmio_gap_in_mb,json=lowMmioGapInMb,proto3" json:"low_mmio_gap_in_mb,omitempty"`
   269  	HighMmioBaseInMb     uint64   `protobuf:"varint,8,opt,name=high_mmio_base_in_mb,json=highMmioBaseInMb,proto3" json:"high_mmio_base_in_mb,omitempty"`
   270  	HighMmioGapInMb      uint64   `protobuf:"varint,9,opt,name=high_mmio_gap_in_mb,json=highMmioGapInMb,proto3" json:"high_mmio_gap_in_mb,omitempty"`
   271  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   272  	XXX_unrecognized     []byte   `json:"-"`
   273  	XXX_sizecache        int32    `json:"-"`
   274  }
   275  
   276  func (m *MemoryConfig) Reset()      { *m = MemoryConfig{} }
   277  func (*MemoryConfig) ProtoMessage() {}
   278  func (*MemoryConfig) Descriptor() ([]byte, []int) {
   279  	return fileDescriptor_272f12cfdaa6c7c8, []int{2}
   280  }
   281  func (m *MemoryConfig) XXX_Unmarshal(b []byte) error {
   282  	return m.Unmarshal(b)
   283  }
   284  func (m *MemoryConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   285  	if deterministic {
   286  		return xxx_messageInfo_MemoryConfig.Marshal(b, m, deterministic)
   287  	} else {
   288  		b = b[:cap(b)]
   289  		n, err := m.MarshalToSizedBuffer(b)
   290  		if err != nil {
   291  			return nil, err
   292  		}
   293  		return b[:n], nil
   294  	}
   295  }
   296  func (m *MemoryConfig) XXX_Merge(src proto.Message) {
   297  	xxx_messageInfo_MemoryConfig.Merge(m, src)
   298  }
   299  func (m *MemoryConfig) XXX_Size() int {
   300  	return m.Size()
   301  }
   302  func (m *MemoryConfig) XXX_DiscardUnknown() {
   303  	xxx_messageInfo_MemoryConfig.DiscardUnknown(m)
   304  }
   305  
   306  var xxx_messageInfo_MemoryConfig proto.InternalMessageInfo
   307  
   308  type ProcessorConfig struct {
   309  	ProcessorCount       uint32   `protobuf:"varint,1,opt,name=processor_count,json=processorCount,proto3" json:"processor_count,omitempty"`
   310  	ProcessorWeight      uint32   `protobuf:"varint,2,opt,name=processor_weight,json=processorWeight,proto3" json:"processor_weight,omitempty"`
   311  	ProcessorLimit       uint32   `protobuf:"varint,3,opt,name=processor_limit,json=processorLimit,proto3" json:"processor_limit,omitempty"`
   312  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   313  	XXX_unrecognized     []byte   `json:"-"`
   314  	XXX_sizecache        int32    `json:"-"`
   315  }
   316  
   317  func (m *ProcessorConfig) Reset()      { *m = ProcessorConfig{} }
   318  func (*ProcessorConfig) ProtoMessage() {}
   319  func (*ProcessorConfig) Descriptor() ([]byte, []int) {
   320  	return fileDescriptor_272f12cfdaa6c7c8, []int{3}
   321  }
   322  func (m *ProcessorConfig) XXX_Unmarshal(b []byte) error {
   323  	return m.Unmarshal(b)
   324  }
   325  func (m *ProcessorConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   326  	if deterministic {
   327  		return xxx_messageInfo_ProcessorConfig.Marshal(b, m, deterministic)
   328  	} else {
   329  		b = b[:cap(b)]
   330  		n, err := m.MarshalToSizedBuffer(b)
   331  		if err != nil {
   332  			return nil, err
   333  		}
   334  		return b[:n], nil
   335  	}
   336  }
   337  func (m *ProcessorConfig) XXX_Merge(src proto.Message) {
   338  	xxx_messageInfo_ProcessorConfig.Merge(m, src)
   339  }
   340  func (m *ProcessorConfig) XXX_Size() int {
   341  	return m.Size()
   342  }
   343  func (m *ProcessorConfig) XXX_DiscardUnknown() {
   344  	xxx_messageInfo_ProcessorConfig.DiscardUnknown(m)
   345  }
   346  
   347  var xxx_messageInfo_ProcessorConfig proto.InternalMessageInfo
   348  
   349  type DevicesConfig struct {
   350  	ScsiDisks            []*SCSIDisk         `protobuf:"bytes,1,rep,name=scsi_disks,json=scsiDisks,proto3" json:"scsi_disks,omitempty"`
   351  	VpmemDisks           []*VPMEMDisk        `protobuf:"bytes,2,rep,name=vpmem_disks,json=vpmemDisks,proto3" json:"vpmem_disks,omitempty"`
   352  	NicConfig            []*NICConfig        `protobuf:"bytes,3,rep,name=nic_config,json=nicConfig,proto3" json:"nic_config,omitempty"`
   353  	WindowsDevice        []*WindowsPCIDevice `protobuf:"bytes,4,rep,name=windows_device,json=windowsDevice,proto3" json:"windows_device,omitempty"`
   354  	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
   355  	XXX_unrecognized     []byte              `json:"-"`
   356  	XXX_sizecache        int32               `json:"-"`
   357  }
   358  
   359  func (m *DevicesConfig) Reset()      { *m = DevicesConfig{} }
   360  func (*DevicesConfig) ProtoMessage() {}
   361  func (*DevicesConfig) Descriptor() ([]byte, []int) {
   362  	return fileDescriptor_272f12cfdaa6c7c8, []int{4}
   363  }
   364  func (m *DevicesConfig) XXX_Unmarshal(b []byte) error {
   365  	return m.Unmarshal(b)
   366  }
   367  func (m *DevicesConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   368  	if deterministic {
   369  		return xxx_messageInfo_DevicesConfig.Marshal(b, m, deterministic)
   370  	} else {
   371  		b = b[:cap(b)]
   372  		n, err := m.MarshalToSizedBuffer(b)
   373  		if err != nil {
   374  			return nil, err
   375  		}
   376  		return b[:n], nil
   377  	}
   378  }
   379  func (m *DevicesConfig) XXX_Merge(src proto.Message) {
   380  	xxx_messageInfo_DevicesConfig.Merge(m, src)
   381  }
   382  func (m *DevicesConfig) XXX_Size() int {
   383  	return m.Size()
   384  }
   385  func (m *DevicesConfig) XXX_DiscardUnknown() {
   386  	xxx_messageInfo_DevicesConfig.DiscardUnknown(m)
   387  }
   388  
   389  var xxx_messageInfo_DevicesConfig proto.InternalMessageInfo
   390  
   391  type VMConfig struct {
   392  	MemoryConfig    *MemoryConfig    `protobuf:"bytes,1,opt,name=memory_config,json=memoryConfig,proto3" json:"memory_config,omitempty"`
   393  	ProcessorConfig *ProcessorConfig `protobuf:"bytes,2,opt,name=processor_config,json=processorConfig,proto3" json:"processor_config,omitempty"`
   394  	DevicesConfig   *DevicesConfig   `protobuf:"bytes,3,opt,name=devices_config,json=devicesConfig,proto3" json:"devices_config,omitempty"`
   395  	SerialConfig    *SerialConfig    `protobuf:"bytes,4,opt,name=serial_config,json=serialConfig,proto3" json:"serial_config,omitempty"`
   396  	// Types that are valid to be assigned to BootConfig:
   397  	//	*VMConfig_DirectBoot
   398  	//	*VMConfig_Uefi
   399  	BootConfig     isVMConfig_BootConfig `protobuf_oneof:"BootConfig"`
   400  	WindowsOptions *WindowsOptions       `protobuf:"bytes,7,opt,name=windows_options,json=windowsOptions,proto3" json:"windows_options,omitempty"`
   401  	// Optional k:v extra data. Up to the virtstack for how to interpret this.
   402  	ExtraData            map[string]string `protobuf:"bytes,8,rep,name=extra_data,json=extraData,proto3" json:"extra_data,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
   403  	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
   404  	XXX_unrecognized     []byte            `json:"-"`
   405  	XXX_sizecache        int32             `json:"-"`
   406  }
   407  
   408  func (m *VMConfig) Reset()      { *m = VMConfig{} }
   409  func (*VMConfig) ProtoMessage() {}
   410  func (*VMConfig) Descriptor() ([]byte, []int) {
   411  	return fileDescriptor_272f12cfdaa6c7c8, []int{5}
   412  }
   413  func (m *VMConfig) XXX_Unmarshal(b []byte) error {
   414  	return m.Unmarshal(b)
   415  }
   416  func (m *VMConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   417  	if deterministic {
   418  		return xxx_messageInfo_VMConfig.Marshal(b, m, deterministic)
   419  	} else {
   420  		b = b[:cap(b)]
   421  		n, err := m.MarshalToSizedBuffer(b)
   422  		if err != nil {
   423  			return nil, err
   424  		}
   425  		return b[:n], nil
   426  	}
   427  }
   428  func (m *VMConfig) XXX_Merge(src proto.Message) {
   429  	xxx_messageInfo_VMConfig.Merge(m, src)
   430  }
   431  func (m *VMConfig) XXX_Size() int {
   432  	return m.Size()
   433  }
   434  func (m *VMConfig) XXX_DiscardUnknown() {
   435  	xxx_messageInfo_VMConfig.DiscardUnknown(m)
   436  }
   437  
   438  var xxx_messageInfo_VMConfig proto.InternalMessageInfo
   439  
   440  type isVMConfig_BootConfig interface {
   441  	isVMConfig_BootConfig()
   442  	MarshalTo([]byte) (int, error)
   443  	Size() int
   444  }
   445  
   446  type VMConfig_DirectBoot struct {
   447  	DirectBoot *DirectBoot `protobuf:"bytes,5,opt,name=direct_boot,json=directBoot,proto3,oneof" json:"direct_boot,omitempty"`
   448  }
   449  type VMConfig_Uefi struct {
   450  	Uefi *UEFI `protobuf:"bytes,6,opt,name=uefi,proto3,oneof" json:"uefi,omitempty"`
   451  }
   452  
   453  func (*VMConfig_DirectBoot) isVMConfig_BootConfig() {}
   454  func (*VMConfig_Uefi) isVMConfig_BootConfig()       {}
   455  
   456  func (m *VMConfig) GetBootConfig() isVMConfig_BootConfig {
   457  	if m != nil {
   458  		return m.BootConfig
   459  	}
   460  	return nil
   461  }
   462  
   463  func (m *VMConfig) GetDirectBoot() *DirectBoot {
   464  	if x, ok := m.GetBootConfig().(*VMConfig_DirectBoot); ok {
   465  		return x.DirectBoot
   466  	}
   467  	return nil
   468  }
   469  
   470  func (m *VMConfig) GetUefi() *UEFI {
   471  	if x, ok := m.GetBootConfig().(*VMConfig_Uefi); ok {
   472  		return x.Uefi
   473  	}
   474  	return nil
   475  }
   476  
   477  // XXX_OneofWrappers is for the internal use of the proto package.
   478  func (*VMConfig) XXX_OneofWrappers() []interface{} {
   479  	return []interface{}{
   480  		(*VMConfig_DirectBoot)(nil),
   481  		(*VMConfig_Uefi)(nil),
   482  	}
   483  }
   484  
   485  // WindowsOptions contains virtual machine configurations that are only present on a Windows host.
   486  type WindowsOptions struct {
   487  	CpuGroupID           uint64   `protobuf:"varint,1,opt,name=cpu_group_id,json=cpuGroupId,proto3" json:"cpu_group_id,omitempty"`
   488  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   489  	XXX_unrecognized     []byte   `json:"-"`
   490  	XXX_sizecache        int32    `json:"-"`
   491  }
   492  
   493  func (m *WindowsOptions) Reset()      { *m = WindowsOptions{} }
   494  func (*WindowsOptions) ProtoMessage() {}
   495  func (*WindowsOptions) Descriptor() ([]byte, []int) {
   496  	return fileDescriptor_272f12cfdaa6c7c8, []int{6}
   497  }
   498  func (m *WindowsOptions) XXX_Unmarshal(b []byte) error {
   499  	return m.Unmarshal(b)
   500  }
   501  func (m *WindowsOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   502  	if deterministic {
   503  		return xxx_messageInfo_WindowsOptions.Marshal(b, m, deterministic)
   504  	} else {
   505  		b = b[:cap(b)]
   506  		n, err := m.MarshalToSizedBuffer(b)
   507  		if err != nil {
   508  			return nil, err
   509  		}
   510  		return b[:n], nil
   511  	}
   512  }
   513  func (m *WindowsOptions) XXX_Merge(src proto.Message) {
   514  	xxx_messageInfo_WindowsOptions.Merge(m, src)
   515  }
   516  func (m *WindowsOptions) XXX_Size() int {
   517  	return m.Size()
   518  }
   519  func (m *WindowsOptions) XXX_DiscardUnknown() {
   520  	xxx_messageInfo_WindowsOptions.DiscardUnknown(m)
   521  }
   522  
   523  var xxx_messageInfo_WindowsOptions proto.InternalMessageInfo
   524  
   525  type SerialConfig struct {
   526  	Ports                []*SerialConfig_Config `protobuf:"bytes,3,rep,name=ports,proto3" json:"ports,omitempty"`
   527  	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
   528  	XXX_unrecognized     []byte                 `json:"-"`
   529  	XXX_sizecache        int32                  `json:"-"`
   530  }
   531  
   532  func (m *SerialConfig) Reset()      { *m = SerialConfig{} }
   533  func (*SerialConfig) ProtoMessage() {}
   534  func (*SerialConfig) Descriptor() ([]byte, []int) {
   535  	return fileDescriptor_272f12cfdaa6c7c8, []int{7}
   536  }
   537  func (m *SerialConfig) XXX_Unmarshal(b []byte) error {
   538  	return m.Unmarshal(b)
   539  }
   540  func (m *SerialConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   541  	if deterministic {
   542  		return xxx_messageInfo_SerialConfig.Marshal(b, m, deterministic)
   543  	} else {
   544  		b = b[:cap(b)]
   545  		n, err := m.MarshalToSizedBuffer(b)
   546  		if err != nil {
   547  			return nil, err
   548  		}
   549  		return b[:n], nil
   550  	}
   551  }
   552  func (m *SerialConfig) XXX_Merge(src proto.Message) {
   553  	xxx_messageInfo_SerialConfig.Merge(m, src)
   554  }
   555  func (m *SerialConfig) XXX_Size() int {
   556  	return m.Size()
   557  }
   558  func (m *SerialConfig) XXX_DiscardUnknown() {
   559  	xxx_messageInfo_SerialConfig.DiscardUnknown(m)
   560  }
   561  
   562  var xxx_messageInfo_SerialConfig proto.InternalMessageInfo
   563  
   564  type SerialConfig_Config struct {
   565  	Port uint32 `protobuf:"varint,1,opt,name=port,proto3" json:"port,omitempty"`
   566  	// Unix domain socket to relay serial console output to.
   567  	SocketPath           string   `protobuf:"bytes,2,opt,name=socket_path,json=socketPath,proto3" json:"socket_path,omitempty"`
   568  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   569  	XXX_unrecognized     []byte   `json:"-"`
   570  	XXX_sizecache        int32    `json:"-"`
   571  }
   572  
   573  func (m *SerialConfig_Config) Reset()      { *m = SerialConfig_Config{} }
   574  func (*SerialConfig_Config) ProtoMessage() {}
   575  func (*SerialConfig_Config) Descriptor() ([]byte, []int) {
   576  	return fileDescriptor_272f12cfdaa6c7c8, []int{7, 0}
   577  }
   578  func (m *SerialConfig_Config) XXX_Unmarshal(b []byte) error {
   579  	return m.Unmarshal(b)
   580  }
   581  func (m *SerialConfig_Config) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   582  	if deterministic {
   583  		return xxx_messageInfo_SerialConfig_Config.Marshal(b, m, deterministic)
   584  	} else {
   585  		b = b[:cap(b)]
   586  		n, err := m.MarshalToSizedBuffer(b)
   587  		if err != nil {
   588  			return nil, err
   589  		}
   590  		return b[:n], nil
   591  	}
   592  }
   593  func (m *SerialConfig_Config) XXX_Merge(src proto.Message) {
   594  	xxx_messageInfo_SerialConfig_Config.Merge(m, src)
   595  }
   596  func (m *SerialConfig_Config) XXX_Size() int {
   597  	return m.Size()
   598  }
   599  func (m *SerialConfig_Config) XXX_DiscardUnknown() {
   600  	xxx_messageInfo_SerialConfig_Config.DiscardUnknown(m)
   601  }
   602  
   603  var xxx_messageInfo_SerialConfig_Config proto.InternalMessageInfo
   604  
   605  type CreateVMRequest struct {
   606  	Config *VMConfig `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
   607  	// Optional ID to be used by the VM service in log messages. It's up to the
   608  	// virtstack to make use of this field. Useful for debugging to be able to
   609  	// correlate events for a given vm that the client launched.
   610  	LogID                string   `protobuf:"bytes,2,opt,name=log_id,json=logId,proto3" json:"log_id,omitempty"`
   611  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   612  	XXX_unrecognized     []byte   `json:"-"`
   613  	XXX_sizecache        int32    `json:"-"`
   614  }
   615  
   616  func (m *CreateVMRequest) Reset()      { *m = CreateVMRequest{} }
   617  func (*CreateVMRequest) ProtoMessage() {}
   618  func (*CreateVMRequest) Descriptor() ([]byte, []int) {
   619  	return fileDescriptor_272f12cfdaa6c7c8, []int{8}
   620  }
   621  func (m *CreateVMRequest) XXX_Unmarshal(b []byte) error {
   622  	return m.Unmarshal(b)
   623  }
   624  func (m *CreateVMRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   625  	if deterministic {
   626  		return xxx_messageInfo_CreateVMRequest.Marshal(b, m, deterministic)
   627  	} else {
   628  		b = b[:cap(b)]
   629  		n, err := m.MarshalToSizedBuffer(b)
   630  		if err != nil {
   631  			return nil, err
   632  		}
   633  		return b[:n], nil
   634  	}
   635  }
   636  func (m *CreateVMRequest) XXX_Merge(src proto.Message) {
   637  	xxx_messageInfo_CreateVMRequest.Merge(m, src)
   638  }
   639  func (m *CreateVMRequest) XXX_Size() int {
   640  	return m.Size()
   641  }
   642  func (m *CreateVMRequest) XXX_DiscardUnknown() {
   643  	xxx_messageInfo_CreateVMRequest.DiscardUnknown(m)
   644  }
   645  
   646  var xxx_messageInfo_CreateVMRequest proto.InternalMessageInfo
   647  
   648  type InspectVMRequest struct {
   649  	Query                string   `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"`
   650  	RecursionLimit       uint32   `protobuf:"varint,2,opt,name=recursion_limit,json=recursionLimit,proto3" json:"recursion_limit,omitempty"`
   651  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   652  	XXX_unrecognized     []byte   `json:"-"`
   653  	XXX_sizecache        int32    `json:"-"`
   654  }
   655  
   656  func (m *InspectVMRequest) Reset()      { *m = InspectVMRequest{} }
   657  func (*InspectVMRequest) ProtoMessage() {}
   658  func (*InspectVMRequest) Descriptor() ([]byte, []int) {
   659  	return fileDescriptor_272f12cfdaa6c7c8, []int{9}
   660  }
   661  func (m *InspectVMRequest) XXX_Unmarshal(b []byte) error {
   662  	return m.Unmarshal(b)
   663  }
   664  func (m *InspectVMRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   665  	if deterministic {
   666  		return xxx_messageInfo_InspectVMRequest.Marshal(b, m, deterministic)
   667  	} else {
   668  		b = b[:cap(b)]
   669  		n, err := m.MarshalToSizedBuffer(b)
   670  		if err != nil {
   671  			return nil, err
   672  		}
   673  		return b[:n], nil
   674  	}
   675  }
   676  func (m *InspectVMRequest) XXX_Merge(src proto.Message) {
   677  	xxx_messageInfo_InspectVMRequest.Merge(m, src)
   678  }
   679  func (m *InspectVMRequest) XXX_Size() int {
   680  	return m.Size()
   681  }
   682  func (m *InspectVMRequest) XXX_DiscardUnknown() {
   683  	xxx_messageInfo_InspectVMRequest.DiscardUnknown(m)
   684  }
   685  
   686  var xxx_messageInfo_InspectVMRequest proto.InternalMessageInfo
   687  
   688  type InspectVMResponse struct {
   689  	Result               *types.Value `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty"`
   690  	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
   691  	XXX_unrecognized     []byte       `json:"-"`
   692  	XXX_sizecache        int32        `json:"-"`
   693  }
   694  
   695  func (m *InspectVMResponse) Reset()      { *m = InspectVMResponse{} }
   696  func (*InspectVMResponse) ProtoMessage() {}
   697  func (*InspectVMResponse) Descriptor() ([]byte, []int) {
   698  	return fileDescriptor_272f12cfdaa6c7c8, []int{10}
   699  }
   700  func (m *InspectVMResponse) XXX_Unmarshal(b []byte) error {
   701  	return m.Unmarshal(b)
   702  }
   703  func (m *InspectVMResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   704  	if deterministic {
   705  		return xxx_messageInfo_InspectVMResponse.Marshal(b, m, deterministic)
   706  	} else {
   707  		b = b[:cap(b)]
   708  		n, err := m.MarshalToSizedBuffer(b)
   709  		if err != nil {
   710  			return nil, err
   711  		}
   712  		return b[:n], nil
   713  	}
   714  }
   715  func (m *InspectVMResponse) XXX_Merge(src proto.Message) {
   716  	xxx_messageInfo_InspectVMResponse.Merge(m, src)
   717  }
   718  func (m *InspectVMResponse) XXX_Size() int {
   719  	return m.Size()
   720  }
   721  func (m *InspectVMResponse) XXX_DiscardUnknown() {
   722  	xxx_messageInfo_InspectVMResponse.DiscardUnknown(m)
   723  }
   724  
   725  var xxx_messageInfo_InspectVMResponse proto.InternalMessageInfo
   726  
   727  type MemoryStats struct {
   728  	WorkingSetBytes      uint64   `protobuf:"varint,1,opt,name=working_set_bytes,json=workingSetBytes,proto3" json:"working_set_bytes,omitempty"`
   729  	AvailableMemory      uint64   `protobuf:"varint,2,opt,name=available_memory,json=availableMemory,proto3" json:"available_memory,omitempty"`
   730  	ReservedMemory       uint64   `protobuf:"varint,3,opt,name=reserved_memory,json=reservedMemory,proto3" json:"reserved_memory,omitempty"`
   731  	AssignedMemory       uint64   `protobuf:"varint,4,opt,name=assigned_memory,json=assignedMemory,proto3" json:"assigned_memory,omitempty"`
   732  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   733  	XXX_unrecognized     []byte   `json:"-"`
   734  	XXX_sizecache        int32    `json:"-"`
   735  }
   736  
   737  func (m *MemoryStats) Reset()      { *m = MemoryStats{} }
   738  func (*MemoryStats) ProtoMessage() {}
   739  func (*MemoryStats) Descriptor() ([]byte, []int) {
   740  	return fileDescriptor_272f12cfdaa6c7c8, []int{11}
   741  }
   742  func (m *MemoryStats) XXX_Unmarshal(b []byte) error {
   743  	return m.Unmarshal(b)
   744  }
   745  func (m *MemoryStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   746  	if deterministic {
   747  		return xxx_messageInfo_MemoryStats.Marshal(b, m, deterministic)
   748  	} else {
   749  		b = b[:cap(b)]
   750  		n, err := m.MarshalToSizedBuffer(b)
   751  		if err != nil {
   752  			return nil, err
   753  		}
   754  		return b[:n], nil
   755  	}
   756  }
   757  func (m *MemoryStats) XXX_Merge(src proto.Message) {
   758  	xxx_messageInfo_MemoryStats.Merge(m, src)
   759  }
   760  func (m *MemoryStats) XXX_Size() int {
   761  	return m.Size()
   762  }
   763  func (m *MemoryStats) XXX_DiscardUnknown() {
   764  	xxx_messageInfo_MemoryStats.DiscardUnknown(m)
   765  }
   766  
   767  var xxx_messageInfo_MemoryStats proto.InternalMessageInfo
   768  
   769  type ProcessorStats struct {
   770  	TotalRuntimeNs       uint64   `protobuf:"varint,1,opt,name=total_runtime_ns,json=totalRuntimeNs,proto3" json:"total_runtime_ns,omitempty"`
   771  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   772  	XXX_unrecognized     []byte   `json:"-"`
   773  	XXX_sizecache        int32    `json:"-"`
   774  }
   775  
   776  func (m *ProcessorStats) Reset()      { *m = ProcessorStats{} }
   777  func (*ProcessorStats) ProtoMessage() {}
   778  func (*ProcessorStats) Descriptor() ([]byte, []int) {
   779  	return fileDescriptor_272f12cfdaa6c7c8, []int{12}
   780  }
   781  func (m *ProcessorStats) XXX_Unmarshal(b []byte) error {
   782  	return m.Unmarshal(b)
   783  }
   784  func (m *ProcessorStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   785  	if deterministic {
   786  		return xxx_messageInfo_ProcessorStats.Marshal(b, m, deterministic)
   787  	} else {
   788  		b = b[:cap(b)]
   789  		n, err := m.MarshalToSizedBuffer(b)
   790  		if err != nil {
   791  			return nil, err
   792  		}
   793  		return b[:n], nil
   794  	}
   795  }
   796  func (m *ProcessorStats) XXX_Merge(src proto.Message) {
   797  	xxx_messageInfo_ProcessorStats.Merge(m, src)
   798  }
   799  func (m *ProcessorStats) XXX_Size() int {
   800  	return m.Size()
   801  }
   802  func (m *ProcessorStats) XXX_DiscardUnknown() {
   803  	xxx_messageInfo_ProcessorStats.DiscardUnknown(m)
   804  }
   805  
   806  var xxx_messageInfo_ProcessorStats proto.InternalMessageInfo
   807  
   808  type PropertiesVMRequest struct {
   809  	Types                []PropertiesVMRequest_PropertiesType `protobuf:"varint,1,rep,packed,name=types,proto3,enum=vmservice.PropertiesVMRequest_PropertiesType" json:"types,omitempty"`
   810  	XXX_NoUnkeyedLiteral struct{}                             `json:"-"`
   811  	XXX_unrecognized     []byte                               `json:"-"`
   812  	XXX_sizecache        int32                                `json:"-"`
   813  }
   814  
   815  func (m *PropertiesVMRequest) Reset()      { *m = PropertiesVMRequest{} }
   816  func (*PropertiesVMRequest) ProtoMessage() {}
   817  func (*PropertiesVMRequest) Descriptor() ([]byte, []int) {
   818  	return fileDescriptor_272f12cfdaa6c7c8, []int{13}
   819  }
   820  func (m *PropertiesVMRequest) XXX_Unmarshal(b []byte) error {
   821  	return m.Unmarshal(b)
   822  }
   823  func (m *PropertiesVMRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   824  	if deterministic {
   825  		return xxx_messageInfo_PropertiesVMRequest.Marshal(b, m, deterministic)
   826  	} else {
   827  		b = b[:cap(b)]
   828  		n, err := m.MarshalToSizedBuffer(b)
   829  		if err != nil {
   830  			return nil, err
   831  		}
   832  		return b[:n], nil
   833  	}
   834  }
   835  func (m *PropertiesVMRequest) XXX_Merge(src proto.Message) {
   836  	xxx_messageInfo_PropertiesVMRequest.Merge(m, src)
   837  }
   838  func (m *PropertiesVMRequest) XXX_Size() int {
   839  	return m.Size()
   840  }
   841  func (m *PropertiesVMRequest) XXX_DiscardUnknown() {
   842  	xxx_messageInfo_PropertiesVMRequest.DiscardUnknown(m)
   843  }
   844  
   845  var xxx_messageInfo_PropertiesVMRequest proto.InternalMessageInfo
   846  
   847  type PropertiesVMResponse struct {
   848  	MemoryStats          *MemoryStats    `protobuf:"bytes,1,opt,name=memory_stats,json=memoryStats,proto3" json:"memory_stats,omitempty"`
   849  	ProcessorStats       *ProcessorStats `protobuf:"bytes,2,opt,name=processor_stats,json=processorStats,proto3" json:"processor_stats,omitempty"`
   850  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
   851  	XXX_unrecognized     []byte          `json:"-"`
   852  	XXX_sizecache        int32           `json:"-"`
   853  }
   854  
   855  func (m *PropertiesVMResponse) Reset()      { *m = PropertiesVMResponse{} }
   856  func (*PropertiesVMResponse) ProtoMessage() {}
   857  func (*PropertiesVMResponse) Descriptor() ([]byte, []int) {
   858  	return fileDescriptor_272f12cfdaa6c7c8, []int{14}
   859  }
   860  func (m *PropertiesVMResponse) XXX_Unmarshal(b []byte) error {
   861  	return m.Unmarshal(b)
   862  }
   863  func (m *PropertiesVMResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   864  	if deterministic {
   865  		return xxx_messageInfo_PropertiesVMResponse.Marshal(b, m, deterministic)
   866  	} else {
   867  		b = b[:cap(b)]
   868  		n, err := m.MarshalToSizedBuffer(b)
   869  		if err != nil {
   870  			return nil, err
   871  		}
   872  		return b[:n], nil
   873  	}
   874  }
   875  func (m *PropertiesVMResponse) XXX_Merge(src proto.Message) {
   876  	xxx_messageInfo_PropertiesVMResponse.Merge(m, src)
   877  }
   878  func (m *PropertiesVMResponse) XXX_Size() int {
   879  	return m.Size()
   880  }
   881  func (m *PropertiesVMResponse) XXX_DiscardUnknown() {
   882  	xxx_messageInfo_PropertiesVMResponse.DiscardUnknown(m)
   883  }
   884  
   885  var xxx_messageInfo_PropertiesVMResponse proto.InternalMessageInfo
   886  
   887  type CapabilitiesVMResponse struct {
   888  	SupportedResources   []*CapabilitiesVMResponse_SupportedResource `protobuf:"bytes,1,rep,name=supported_resources,json=supportedResources,proto3" json:"supported_resources,omitempty"`
   889  	SupportedGuestOs     []CapabilitiesVMResponse_SupportedGuestOS   `protobuf:"varint,2,rep,packed,name=supported_guest_os,json=supportedGuestOs,proto3,enum=vmservice.CapabilitiesVMResponse_SupportedGuestOS" json:"supported_guest_os,omitempty"`
   890  	XXX_NoUnkeyedLiteral struct{}                                    `json:"-"`
   891  	XXX_unrecognized     []byte                                      `json:"-"`
   892  	XXX_sizecache        int32                                       `json:"-"`
   893  }
   894  
   895  func (m *CapabilitiesVMResponse) Reset()      { *m = CapabilitiesVMResponse{} }
   896  func (*CapabilitiesVMResponse) ProtoMessage() {}
   897  func (*CapabilitiesVMResponse) Descriptor() ([]byte, []int) {
   898  	return fileDescriptor_272f12cfdaa6c7c8, []int{15}
   899  }
   900  func (m *CapabilitiesVMResponse) XXX_Unmarshal(b []byte) error {
   901  	return m.Unmarshal(b)
   902  }
   903  func (m *CapabilitiesVMResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   904  	if deterministic {
   905  		return xxx_messageInfo_CapabilitiesVMResponse.Marshal(b, m, deterministic)
   906  	} else {
   907  		b = b[:cap(b)]
   908  		n, err := m.MarshalToSizedBuffer(b)
   909  		if err != nil {
   910  			return nil, err
   911  		}
   912  		return b[:n], nil
   913  	}
   914  }
   915  func (m *CapabilitiesVMResponse) XXX_Merge(src proto.Message) {
   916  	xxx_messageInfo_CapabilitiesVMResponse.Merge(m, src)
   917  }
   918  func (m *CapabilitiesVMResponse) XXX_Size() int {
   919  	return m.Size()
   920  }
   921  func (m *CapabilitiesVMResponse) XXX_DiscardUnknown() {
   922  	xxx_messageInfo_CapabilitiesVMResponse.DiscardUnknown(m)
   923  }
   924  
   925  var xxx_messageInfo_CapabilitiesVMResponse proto.InternalMessageInfo
   926  
   927  type CapabilitiesVMResponse_SupportedResource struct {
   928  	Add                  bool                            `protobuf:"varint,1,opt,name=Add,proto3" json:"Add,omitempty"`
   929  	Remove               bool                            `protobuf:"varint,2,opt,name=Remove,proto3" json:"Remove,omitempty"`
   930  	Update               bool                            `protobuf:"varint,3,opt,name=Update,proto3" json:"Update,omitempty"`
   931  	Resource             CapabilitiesVMResponse_Resource `protobuf:"varint,4,opt,name=resource,proto3,enum=vmservice.CapabilitiesVMResponse_Resource" json:"resource,omitempty"`
   932  	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
   933  	XXX_unrecognized     []byte                          `json:"-"`
   934  	XXX_sizecache        int32                           `json:"-"`
   935  }
   936  
   937  func (m *CapabilitiesVMResponse_SupportedResource) Reset() {
   938  	*m = CapabilitiesVMResponse_SupportedResource{}
   939  }
   940  func (*CapabilitiesVMResponse_SupportedResource) ProtoMessage() {}
   941  func (*CapabilitiesVMResponse_SupportedResource) Descriptor() ([]byte, []int) {
   942  	return fileDescriptor_272f12cfdaa6c7c8, []int{15, 0}
   943  }
   944  func (m *CapabilitiesVMResponse_SupportedResource) XXX_Unmarshal(b []byte) error {
   945  	return m.Unmarshal(b)
   946  }
   947  func (m *CapabilitiesVMResponse_SupportedResource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   948  	if deterministic {
   949  		return xxx_messageInfo_CapabilitiesVMResponse_SupportedResource.Marshal(b, m, deterministic)
   950  	} else {
   951  		b = b[:cap(b)]
   952  		n, err := m.MarshalToSizedBuffer(b)
   953  		if err != nil {
   954  			return nil, err
   955  		}
   956  		return b[:n], nil
   957  	}
   958  }
   959  func (m *CapabilitiesVMResponse_SupportedResource) XXX_Merge(src proto.Message) {
   960  	xxx_messageInfo_CapabilitiesVMResponse_SupportedResource.Merge(m, src)
   961  }
   962  func (m *CapabilitiesVMResponse_SupportedResource) XXX_Size() int {
   963  	return m.Size()
   964  }
   965  func (m *CapabilitiesVMResponse_SupportedResource) XXX_DiscardUnknown() {
   966  	xxx_messageInfo_CapabilitiesVMResponse_SupportedResource.DiscardUnknown(m)
   967  }
   968  
   969  var xxx_messageInfo_CapabilitiesVMResponse_SupportedResource proto.InternalMessageInfo
   970  
   971  type HVSocketListen struct {
   972  	ServiceID string `protobuf:"bytes,1,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"`
   973  	// Expected that the listener is a unix domain socket. These
   974  	// are supported on Windows as of 1809/RS5.
   975  	ListenerPath         string   `protobuf:"bytes,2,opt,name=listener_path,json=listenerPath,proto3" json:"listener_path,omitempty"`
   976  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   977  	XXX_unrecognized     []byte   `json:"-"`
   978  	XXX_sizecache        int32    `json:"-"`
   979  }
   980  
   981  func (m *HVSocketListen) Reset()      { *m = HVSocketListen{} }
   982  func (*HVSocketListen) ProtoMessage() {}
   983  func (*HVSocketListen) Descriptor() ([]byte, []int) {
   984  	return fileDescriptor_272f12cfdaa6c7c8, []int{16}
   985  }
   986  func (m *HVSocketListen) XXX_Unmarshal(b []byte) error {
   987  	return m.Unmarshal(b)
   988  }
   989  func (m *HVSocketListen) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   990  	if deterministic {
   991  		return xxx_messageInfo_HVSocketListen.Marshal(b, m, deterministic)
   992  	} else {
   993  		b = b[:cap(b)]
   994  		n, err := m.MarshalToSizedBuffer(b)
   995  		if err != nil {
   996  			return nil, err
   997  		}
   998  		return b[:n], nil
   999  	}
  1000  }
  1001  func (m *HVSocketListen) XXX_Merge(src proto.Message) {
  1002  	xxx_messageInfo_HVSocketListen.Merge(m, src)
  1003  }
  1004  func (m *HVSocketListen) XXX_Size() int {
  1005  	return m.Size()
  1006  }
  1007  func (m *HVSocketListen) XXX_DiscardUnknown() {
  1008  	xxx_messageInfo_HVSocketListen.DiscardUnknown(m)
  1009  }
  1010  
  1011  var xxx_messageInfo_HVSocketListen proto.InternalMessageInfo
  1012  
  1013  type VSockListen struct {
  1014  	Port                 uint32   `protobuf:"varint,1,opt,name=port,proto3" json:"port,omitempty"`
  1015  	ListenerPath         string   `protobuf:"bytes,2,opt,name=listener_path,json=listenerPath,proto3" json:"listener_path,omitempty"`
  1016  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  1017  	XXX_unrecognized     []byte   `json:"-"`
  1018  	XXX_sizecache        int32    `json:"-"`
  1019  }
  1020  
  1021  func (m *VSockListen) Reset()      { *m = VSockListen{} }
  1022  func (*VSockListen) ProtoMessage() {}
  1023  func (*VSockListen) Descriptor() ([]byte, []int) {
  1024  	return fileDescriptor_272f12cfdaa6c7c8, []int{17}
  1025  }
  1026  func (m *VSockListen) XXX_Unmarshal(b []byte) error {
  1027  	return m.Unmarshal(b)
  1028  }
  1029  func (m *VSockListen) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1030  	if deterministic {
  1031  		return xxx_messageInfo_VSockListen.Marshal(b, m, deterministic)
  1032  	} else {
  1033  		b = b[:cap(b)]
  1034  		n, err := m.MarshalToSizedBuffer(b)
  1035  		if err != nil {
  1036  			return nil, err
  1037  		}
  1038  		return b[:n], nil
  1039  	}
  1040  }
  1041  func (m *VSockListen) XXX_Merge(src proto.Message) {
  1042  	xxx_messageInfo_VSockListen.Merge(m, src)
  1043  }
  1044  func (m *VSockListen) XXX_Size() int {
  1045  	return m.Size()
  1046  }
  1047  func (m *VSockListen) XXX_DiscardUnknown() {
  1048  	xxx_messageInfo_VSockListen.DiscardUnknown(m)
  1049  }
  1050  
  1051  var xxx_messageInfo_VSockListen proto.InternalMessageInfo
  1052  
  1053  type VMSocketRequest struct {
  1054  	Type ModifyType `protobuf:"varint,1,opt,name=type,proto3,enum=vmservice.ModifyType" json:"type,omitempty"`
  1055  	// Types that are valid to be assigned to Config:
  1056  	//	*VMSocketRequest_HvsocketList
  1057  	//	*VMSocketRequest_VsockListen
  1058  	Config               isVMSocketRequest_Config `protobuf_oneof:"Config"`
  1059  	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
  1060  	XXX_unrecognized     []byte                   `json:"-"`
  1061  	XXX_sizecache        int32                    `json:"-"`
  1062  }
  1063  
  1064  func (m *VMSocketRequest) Reset()      { *m = VMSocketRequest{} }
  1065  func (*VMSocketRequest) ProtoMessage() {}
  1066  func (*VMSocketRequest) Descriptor() ([]byte, []int) {
  1067  	return fileDescriptor_272f12cfdaa6c7c8, []int{18}
  1068  }
  1069  func (m *VMSocketRequest) XXX_Unmarshal(b []byte) error {
  1070  	return m.Unmarshal(b)
  1071  }
  1072  func (m *VMSocketRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1073  	if deterministic {
  1074  		return xxx_messageInfo_VMSocketRequest.Marshal(b, m, deterministic)
  1075  	} else {
  1076  		b = b[:cap(b)]
  1077  		n, err := m.MarshalToSizedBuffer(b)
  1078  		if err != nil {
  1079  			return nil, err
  1080  		}
  1081  		return b[:n], nil
  1082  	}
  1083  }
  1084  func (m *VMSocketRequest) XXX_Merge(src proto.Message) {
  1085  	xxx_messageInfo_VMSocketRequest.Merge(m, src)
  1086  }
  1087  func (m *VMSocketRequest) XXX_Size() int {
  1088  	return m.Size()
  1089  }
  1090  func (m *VMSocketRequest) XXX_DiscardUnknown() {
  1091  	xxx_messageInfo_VMSocketRequest.DiscardUnknown(m)
  1092  }
  1093  
  1094  var xxx_messageInfo_VMSocketRequest proto.InternalMessageInfo
  1095  
  1096  type isVMSocketRequest_Config interface {
  1097  	isVMSocketRequest_Config()
  1098  	MarshalTo([]byte) (int, error)
  1099  	Size() int
  1100  }
  1101  
  1102  type VMSocketRequest_HvsocketList struct {
  1103  	HvsocketList *HVSocketListen `protobuf:"bytes,2,opt,name=hvsocket_list,json=hvsocketList,proto3,oneof" json:"hvsocket_list,omitempty"`
  1104  }
  1105  type VMSocketRequest_VsockListen struct {
  1106  	VsockListen *VSockListen `protobuf:"bytes,3,opt,name=vsock_listen,json=vsockListen,proto3,oneof" json:"vsock_listen,omitempty"`
  1107  }
  1108  
  1109  func (*VMSocketRequest_HvsocketList) isVMSocketRequest_Config() {}
  1110  func (*VMSocketRequest_VsockListen) isVMSocketRequest_Config()  {}
  1111  
  1112  func (m *VMSocketRequest) GetConfig() isVMSocketRequest_Config {
  1113  	if m != nil {
  1114  		return m.Config
  1115  	}
  1116  	return nil
  1117  }
  1118  
  1119  func (m *VMSocketRequest) GetHvsocketList() *HVSocketListen {
  1120  	if x, ok := m.GetConfig().(*VMSocketRequest_HvsocketList); ok {
  1121  		return x.HvsocketList
  1122  	}
  1123  	return nil
  1124  }
  1125  
  1126  func (m *VMSocketRequest) GetVsockListen() *VSockListen {
  1127  	if x, ok := m.GetConfig().(*VMSocketRequest_VsockListen); ok {
  1128  		return x.VsockListen
  1129  	}
  1130  	return nil
  1131  }
  1132  
  1133  // XXX_OneofWrappers is for the internal use of the proto package.
  1134  func (*VMSocketRequest) XXX_OneofWrappers() []interface{} {
  1135  	return []interface{}{
  1136  		(*VMSocketRequest_HvsocketList)(nil),
  1137  		(*VMSocketRequest_VsockListen)(nil),
  1138  	}
  1139  }
  1140  
  1141  type SCSIDisk struct {
  1142  	Controller           uint32   `protobuf:"varint,1,opt,name=controller,proto3" json:"controller,omitempty"`
  1143  	Lun                  uint32   `protobuf:"varint,2,opt,name=lun,proto3" json:"lun,omitempty"`
  1144  	HostPath             string   `protobuf:"bytes,3,opt,name=host_path,json=hostPath,proto3" json:"host_path,omitempty"`
  1145  	Type                 DiskType `protobuf:"varint,4,opt,name=type,proto3,enum=vmservice.DiskType" json:"type,omitempty"`
  1146  	ReadOnly             bool     `protobuf:"varint,5,opt,name=read_only,json=readOnly,proto3" json:"read_only,omitempty"`
  1147  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  1148  	XXX_unrecognized     []byte   `json:"-"`
  1149  	XXX_sizecache        int32    `json:"-"`
  1150  }
  1151  
  1152  func (m *SCSIDisk) Reset()      { *m = SCSIDisk{} }
  1153  func (*SCSIDisk) ProtoMessage() {}
  1154  func (*SCSIDisk) Descriptor() ([]byte, []int) {
  1155  	return fileDescriptor_272f12cfdaa6c7c8, []int{19}
  1156  }
  1157  func (m *SCSIDisk) XXX_Unmarshal(b []byte) error {
  1158  	return m.Unmarshal(b)
  1159  }
  1160  func (m *SCSIDisk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1161  	if deterministic {
  1162  		return xxx_messageInfo_SCSIDisk.Marshal(b, m, deterministic)
  1163  	} else {
  1164  		b = b[:cap(b)]
  1165  		n, err := m.MarshalToSizedBuffer(b)
  1166  		if err != nil {
  1167  			return nil, err
  1168  		}
  1169  		return b[:n], nil
  1170  	}
  1171  }
  1172  func (m *SCSIDisk) XXX_Merge(src proto.Message) {
  1173  	xxx_messageInfo_SCSIDisk.Merge(m, src)
  1174  }
  1175  func (m *SCSIDisk) XXX_Size() int {
  1176  	return m.Size()
  1177  }
  1178  func (m *SCSIDisk) XXX_DiscardUnknown() {
  1179  	xxx_messageInfo_SCSIDisk.DiscardUnknown(m)
  1180  }
  1181  
  1182  var xxx_messageInfo_SCSIDisk proto.InternalMessageInfo
  1183  
  1184  type VPMEMDisk struct {
  1185  	HostPath             string   `protobuf:"bytes,1,opt,name=host_path,json=hostPath,proto3" json:"host_path,omitempty"`
  1186  	Type                 DiskType `protobuf:"varint,2,opt,name=type,proto3,enum=vmservice.DiskType" json:"type,omitempty"`
  1187  	ReadOnly             bool     `protobuf:"varint,3,opt,name=read_only,json=readOnly,proto3" json:"read_only,omitempty"`
  1188  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  1189  	XXX_unrecognized     []byte   `json:"-"`
  1190  	XXX_sizecache        int32    `json:"-"`
  1191  }
  1192  
  1193  func (m *VPMEMDisk) Reset()      { *m = VPMEMDisk{} }
  1194  func (*VPMEMDisk) ProtoMessage() {}
  1195  func (*VPMEMDisk) Descriptor() ([]byte, []int) {
  1196  	return fileDescriptor_272f12cfdaa6c7c8, []int{20}
  1197  }
  1198  func (m *VPMEMDisk) XXX_Unmarshal(b []byte) error {
  1199  	return m.Unmarshal(b)
  1200  }
  1201  func (m *VPMEMDisk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1202  	if deterministic {
  1203  		return xxx_messageInfo_VPMEMDisk.Marshal(b, m, deterministic)
  1204  	} else {
  1205  		b = b[:cap(b)]
  1206  		n, err := m.MarshalToSizedBuffer(b)
  1207  		if err != nil {
  1208  			return nil, err
  1209  		}
  1210  		return b[:n], nil
  1211  	}
  1212  }
  1213  func (m *VPMEMDisk) XXX_Merge(src proto.Message) {
  1214  	xxx_messageInfo_VPMEMDisk.Merge(m, src)
  1215  }
  1216  func (m *VPMEMDisk) XXX_Size() int {
  1217  	return m.Size()
  1218  }
  1219  func (m *VPMEMDisk) XXX_DiscardUnknown() {
  1220  	xxx_messageInfo_VPMEMDisk.DiscardUnknown(m)
  1221  }
  1222  
  1223  var xxx_messageInfo_VPMEMDisk proto.InternalMessageInfo
  1224  
  1225  type NICConfig struct {
  1226  	NicID      string `protobuf:"bytes,1,opt,name=nic_id,json=nicId,proto3" json:"nic_id,omitempty"`
  1227  	PortID     string `protobuf:"bytes,2,opt,name=port_id,json=portId,proto3" json:"port_id,omitempty"`
  1228  	MacAddress string `protobuf:"bytes,3,opt,name=mac_address,json=macAddress,proto3" json:"mac_address,omitempty"`
  1229  	SwitchID   string `protobuf:"bytes,4,opt,name=switch_id,json=switchId,proto3" json:"switch_id,omitempty"`
  1230  	// Optional friendly name for the adapter. Might be useful to show up in logs.
  1231  	NicName              string   `protobuf:"bytes,5,opt,name=nic_name,json=nicName,proto3" json:"nic_name,omitempty"`
  1232  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  1233  	XXX_unrecognized     []byte   `json:"-"`
  1234  	XXX_sizecache        int32    `json:"-"`
  1235  }
  1236  
  1237  func (m *NICConfig) Reset()      { *m = NICConfig{} }
  1238  func (*NICConfig) ProtoMessage() {}
  1239  func (*NICConfig) Descriptor() ([]byte, []int) {
  1240  	return fileDescriptor_272f12cfdaa6c7c8, []int{21}
  1241  }
  1242  func (m *NICConfig) XXX_Unmarshal(b []byte) error {
  1243  	return m.Unmarshal(b)
  1244  }
  1245  func (m *NICConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1246  	if deterministic {
  1247  		return xxx_messageInfo_NICConfig.Marshal(b, m, deterministic)
  1248  	} else {
  1249  		b = b[:cap(b)]
  1250  		n, err := m.MarshalToSizedBuffer(b)
  1251  		if err != nil {
  1252  			return nil, err
  1253  		}
  1254  		return b[:n], nil
  1255  	}
  1256  }
  1257  func (m *NICConfig) XXX_Merge(src proto.Message) {
  1258  	xxx_messageInfo_NICConfig.Merge(m, src)
  1259  }
  1260  func (m *NICConfig) XXX_Size() int {
  1261  	return m.Size()
  1262  }
  1263  func (m *NICConfig) XXX_DiscardUnknown() {
  1264  	xxx_messageInfo_NICConfig.DiscardUnknown(m)
  1265  }
  1266  
  1267  var xxx_messageInfo_NICConfig proto.InternalMessageInfo
  1268  
  1269  type WindowsPCIDevice struct {
  1270  	// e.g. PCIP\\VEN_10DE&DEV_13F2&SUBSYS_115E10DE&REV_A1\\6&17F903&0&00400000
  1271  	InstanceID           string   `protobuf:"bytes,1,opt,name=instance_id,json=instanceId,proto3" json:"instance_id,omitempty"`
  1272  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  1273  	XXX_unrecognized     []byte   `json:"-"`
  1274  	XXX_sizecache        int32    `json:"-"`
  1275  }
  1276  
  1277  func (m *WindowsPCIDevice) Reset()      { *m = WindowsPCIDevice{} }
  1278  func (*WindowsPCIDevice) ProtoMessage() {}
  1279  func (*WindowsPCIDevice) Descriptor() ([]byte, []int) {
  1280  	return fileDescriptor_272f12cfdaa6c7c8, []int{22}
  1281  }
  1282  func (m *WindowsPCIDevice) XXX_Unmarshal(b []byte) error {
  1283  	return m.Unmarshal(b)
  1284  }
  1285  func (m *WindowsPCIDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1286  	if deterministic {
  1287  		return xxx_messageInfo_WindowsPCIDevice.Marshal(b, m, deterministic)
  1288  	} else {
  1289  		b = b[:cap(b)]
  1290  		n, err := m.MarshalToSizedBuffer(b)
  1291  		if err != nil {
  1292  			return nil, err
  1293  		}
  1294  		return b[:n], nil
  1295  	}
  1296  }
  1297  func (m *WindowsPCIDevice) XXX_Merge(src proto.Message) {
  1298  	xxx_messageInfo_WindowsPCIDevice.Merge(m, src)
  1299  }
  1300  func (m *WindowsPCIDevice) XXX_Size() int {
  1301  	return m.Size()
  1302  }
  1303  func (m *WindowsPCIDevice) XXX_DiscardUnknown() {
  1304  	xxx_messageInfo_WindowsPCIDevice.DiscardUnknown(m)
  1305  }
  1306  
  1307  var xxx_messageInfo_WindowsPCIDevice proto.InternalMessageInfo
  1308  
  1309  type ModifyMemoryRequest struct {
  1310  	MemoryMb             uint64   `protobuf:"varint,1,opt,name=memory_mb,json=memoryMb,proto3" json:"memory_mb,omitempty"`
  1311  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  1312  	XXX_unrecognized     []byte   `json:"-"`
  1313  	XXX_sizecache        int32    `json:"-"`
  1314  }
  1315  
  1316  func (m *ModifyMemoryRequest) Reset()      { *m = ModifyMemoryRequest{} }
  1317  func (*ModifyMemoryRequest) ProtoMessage() {}
  1318  func (*ModifyMemoryRequest) Descriptor() ([]byte, []int) {
  1319  	return fileDescriptor_272f12cfdaa6c7c8, []int{23}
  1320  }
  1321  func (m *ModifyMemoryRequest) XXX_Unmarshal(b []byte) error {
  1322  	return m.Unmarshal(b)
  1323  }
  1324  func (m *ModifyMemoryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1325  	if deterministic {
  1326  		return xxx_messageInfo_ModifyMemoryRequest.Marshal(b, m, deterministic)
  1327  	} else {
  1328  		b = b[:cap(b)]
  1329  		n, err := m.MarshalToSizedBuffer(b)
  1330  		if err != nil {
  1331  			return nil, err
  1332  		}
  1333  		return b[:n], nil
  1334  	}
  1335  }
  1336  func (m *ModifyMemoryRequest) XXX_Merge(src proto.Message) {
  1337  	xxx_messageInfo_ModifyMemoryRequest.Merge(m, src)
  1338  }
  1339  func (m *ModifyMemoryRequest) XXX_Size() int {
  1340  	return m.Size()
  1341  }
  1342  func (m *ModifyMemoryRequest) XXX_DiscardUnknown() {
  1343  	xxx_messageInfo_ModifyMemoryRequest.DiscardUnknown(m)
  1344  }
  1345  
  1346  var xxx_messageInfo_ModifyMemoryRequest proto.InternalMessageInfo
  1347  
  1348  type ModifyProcessorRequest struct {
  1349  	// Index of the processor to add/remove
  1350  	ProcessorIndex       uint32   `protobuf:"varint,1,opt,name=processor_index,json=processorIndex,proto3" json:"processor_index,omitempty"`
  1351  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  1352  	XXX_unrecognized     []byte   `json:"-"`
  1353  	XXX_sizecache        int32    `json:"-"`
  1354  }
  1355  
  1356  func (m *ModifyProcessorRequest) Reset()      { *m = ModifyProcessorRequest{} }
  1357  func (*ModifyProcessorRequest) ProtoMessage() {}
  1358  func (*ModifyProcessorRequest) Descriptor() ([]byte, []int) {
  1359  	return fileDescriptor_272f12cfdaa6c7c8, []int{24}
  1360  }
  1361  func (m *ModifyProcessorRequest) XXX_Unmarshal(b []byte) error {
  1362  	return m.Unmarshal(b)
  1363  }
  1364  func (m *ModifyProcessorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1365  	if deterministic {
  1366  		return xxx_messageInfo_ModifyProcessorRequest.Marshal(b, m, deterministic)
  1367  	} else {
  1368  		b = b[:cap(b)]
  1369  		n, err := m.MarshalToSizedBuffer(b)
  1370  		if err != nil {
  1371  			return nil, err
  1372  		}
  1373  		return b[:n], nil
  1374  	}
  1375  }
  1376  func (m *ModifyProcessorRequest) XXX_Merge(src proto.Message) {
  1377  	xxx_messageInfo_ModifyProcessorRequest.Merge(m, src)
  1378  }
  1379  func (m *ModifyProcessorRequest) XXX_Size() int {
  1380  	return m.Size()
  1381  }
  1382  func (m *ModifyProcessorRequest) XXX_DiscardUnknown() {
  1383  	xxx_messageInfo_ModifyProcessorRequest.DiscardUnknown(m)
  1384  }
  1385  
  1386  var xxx_messageInfo_ModifyProcessorRequest proto.InternalMessageInfo
  1387  
  1388  type ModifyProcessorConfigRequest struct {
  1389  	ProcessorWeight      uint32   `protobuf:"varint,1,opt,name=processor_weight,json=processorWeight,proto3" json:"processor_weight,omitempty"`
  1390  	ProcessorLimit       uint32   `protobuf:"varint,2,opt,name=processor_limit,json=processorLimit,proto3" json:"processor_limit,omitempty"`
  1391  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  1392  	XXX_unrecognized     []byte   `json:"-"`
  1393  	XXX_sizecache        int32    `json:"-"`
  1394  }
  1395  
  1396  func (m *ModifyProcessorConfigRequest) Reset()      { *m = ModifyProcessorConfigRequest{} }
  1397  func (*ModifyProcessorConfigRequest) ProtoMessage() {}
  1398  func (*ModifyProcessorConfigRequest) Descriptor() ([]byte, []int) {
  1399  	return fileDescriptor_272f12cfdaa6c7c8, []int{25}
  1400  }
  1401  func (m *ModifyProcessorConfigRequest) XXX_Unmarshal(b []byte) error {
  1402  	return m.Unmarshal(b)
  1403  }
  1404  func (m *ModifyProcessorConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1405  	if deterministic {
  1406  		return xxx_messageInfo_ModifyProcessorConfigRequest.Marshal(b, m, deterministic)
  1407  	} else {
  1408  		b = b[:cap(b)]
  1409  		n, err := m.MarshalToSizedBuffer(b)
  1410  		if err != nil {
  1411  			return nil, err
  1412  		}
  1413  		return b[:n], nil
  1414  	}
  1415  }
  1416  func (m *ModifyProcessorConfigRequest) XXX_Merge(src proto.Message) {
  1417  	xxx_messageInfo_ModifyProcessorConfigRequest.Merge(m, src)
  1418  }
  1419  func (m *ModifyProcessorConfigRequest) XXX_Size() int {
  1420  	return m.Size()
  1421  }
  1422  func (m *ModifyProcessorConfigRequest) XXX_DiscardUnknown() {
  1423  	xxx_messageInfo_ModifyProcessorConfigRequest.DiscardUnknown(m)
  1424  }
  1425  
  1426  var xxx_messageInfo_ModifyProcessorConfigRequest proto.InternalMessageInfo
  1427  
  1428  type ModifyResourceRequest struct {
  1429  	Type ModifyType `protobuf:"varint,1,opt,name=type,proto3,enum=vmservice.ModifyType" json:"type,omitempty"`
  1430  	// Types that are valid to be assigned to Resource:
  1431  	//	*ModifyResourceRequest_Processor
  1432  	//	*ModifyResourceRequest_ProcessorConfig
  1433  	//	*ModifyResourceRequest_Memory
  1434  	//	*ModifyResourceRequest_ScsiDisk
  1435  	//	*ModifyResourceRequest_VpmemDisk
  1436  	//	*ModifyResourceRequest_NicConfig
  1437  	//	*ModifyResourceRequest_WindowsDevice
  1438  	Resource             isModifyResourceRequest_Resource `protobuf_oneof:"resource"`
  1439  	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
  1440  	XXX_unrecognized     []byte                           `json:"-"`
  1441  	XXX_sizecache        int32                            `json:"-"`
  1442  }
  1443  
  1444  func (m *ModifyResourceRequest) Reset()      { *m = ModifyResourceRequest{} }
  1445  func (*ModifyResourceRequest) ProtoMessage() {}
  1446  func (*ModifyResourceRequest) Descriptor() ([]byte, []int) {
  1447  	return fileDescriptor_272f12cfdaa6c7c8, []int{26}
  1448  }
  1449  func (m *ModifyResourceRequest) XXX_Unmarshal(b []byte) error {
  1450  	return m.Unmarshal(b)
  1451  }
  1452  func (m *ModifyResourceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1453  	if deterministic {
  1454  		return xxx_messageInfo_ModifyResourceRequest.Marshal(b, m, deterministic)
  1455  	} else {
  1456  		b = b[:cap(b)]
  1457  		n, err := m.MarshalToSizedBuffer(b)
  1458  		if err != nil {
  1459  			return nil, err
  1460  		}
  1461  		return b[:n], nil
  1462  	}
  1463  }
  1464  func (m *ModifyResourceRequest) XXX_Merge(src proto.Message) {
  1465  	xxx_messageInfo_ModifyResourceRequest.Merge(m, src)
  1466  }
  1467  func (m *ModifyResourceRequest) XXX_Size() int {
  1468  	return m.Size()
  1469  }
  1470  func (m *ModifyResourceRequest) XXX_DiscardUnknown() {
  1471  	xxx_messageInfo_ModifyResourceRequest.DiscardUnknown(m)
  1472  }
  1473  
  1474  var xxx_messageInfo_ModifyResourceRequest proto.InternalMessageInfo
  1475  
  1476  type isModifyResourceRequest_Resource interface {
  1477  	isModifyResourceRequest_Resource()
  1478  	MarshalTo([]byte) (int, error)
  1479  	Size() int
  1480  }
  1481  
  1482  type ModifyResourceRequest_Processor struct {
  1483  	Processor *ModifyProcessorRequest `protobuf:"bytes,2,opt,name=processor,proto3,oneof" json:"processor,omitempty"`
  1484  }
  1485  type ModifyResourceRequest_ProcessorConfig struct {
  1486  	ProcessorConfig *ModifyProcessorConfigRequest `protobuf:"bytes,3,opt,name=processor_config,json=processorConfig,proto3,oneof" json:"processor_config,omitempty"`
  1487  }
  1488  type ModifyResourceRequest_Memory struct {
  1489  	Memory *ModifyMemoryRequest `protobuf:"bytes,4,opt,name=memory,proto3,oneof" json:"memory,omitempty"`
  1490  }
  1491  type ModifyResourceRequest_ScsiDisk struct {
  1492  	ScsiDisk *SCSIDisk `protobuf:"bytes,5,opt,name=scsi_disk,json=scsiDisk,proto3,oneof" json:"scsi_disk,omitempty"`
  1493  }
  1494  type ModifyResourceRequest_VpmemDisk struct {
  1495  	VpmemDisk *VPMEMDisk `protobuf:"bytes,6,opt,name=vpmem_disk,json=vpmemDisk,proto3,oneof" json:"vpmem_disk,omitempty"`
  1496  }
  1497  type ModifyResourceRequest_NicConfig struct {
  1498  	NicConfig *NICConfig `protobuf:"bytes,7,opt,name=nic_config,json=nicConfig,proto3,oneof" json:"nic_config,omitempty"`
  1499  }
  1500  type ModifyResourceRequest_WindowsDevice struct {
  1501  	WindowsDevice *WindowsPCIDevice `protobuf:"bytes,8,opt,name=windows_device,json=windowsDevice,proto3,oneof" json:"windows_device,omitempty"`
  1502  }
  1503  
  1504  func (*ModifyResourceRequest_Processor) isModifyResourceRequest_Resource()       {}
  1505  func (*ModifyResourceRequest_ProcessorConfig) isModifyResourceRequest_Resource() {}
  1506  func (*ModifyResourceRequest_Memory) isModifyResourceRequest_Resource()          {}
  1507  func (*ModifyResourceRequest_ScsiDisk) isModifyResourceRequest_Resource()        {}
  1508  func (*ModifyResourceRequest_VpmemDisk) isModifyResourceRequest_Resource()       {}
  1509  func (*ModifyResourceRequest_NicConfig) isModifyResourceRequest_Resource()       {}
  1510  func (*ModifyResourceRequest_WindowsDevice) isModifyResourceRequest_Resource()   {}
  1511  
  1512  func (m *ModifyResourceRequest) GetResource() isModifyResourceRequest_Resource {
  1513  	if m != nil {
  1514  		return m.Resource
  1515  	}
  1516  	return nil
  1517  }
  1518  
  1519  func (m *ModifyResourceRequest) GetProcessor() *ModifyProcessorRequest {
  1520  	if x, ok := m.GetResource().(*ModifyResourceRequest_Processor); ok {
  1521  		return x.Processor
  1522  	}
  1523  	return nil
  1524  }
  1525  
  1526  func (m *ModifyResourceRequest) GetProcessorConfig() *ModifyProcessorConfigRequest {
  1527  	if x, ok := m.GetResource().(*ModifyResourceRequest_ProcessorConfig); ok {
  1528  		return x.ProcessorConfig
  1529  	}
  1530  	return nil
  1531  }
  1532  
  1533  func (m *ModifyResourceRequest) GetMemory() *ModifyMemoryRequest {
  1534  	if x, ok := m.GetResource().(*ModifyResourceRequest_Memory); ok {
  1535  		return x.Memory
  1536  	}
  1537  	return nil
  1538  }
  1539  
  1540  func (m *ModifyResourceRequest) GetScsiDisk() *SCSIDisk {
  1541  	if x, ok := m.GetResource().(*ModifyResourceRequest_ScsiDisk); ok {
  1542  		return x.ScsiDisk
  1543  	}
  1544  	return nil
  1545  }
  1546  
  1547  func (m *ModifyResourceRequest) GetVpmemDisk() *VPMEMDisk {
  1548  	if x, ok := m.GetResource().(*ModifyResourceRequest_VpmemDisk); ok {
  1549  		return x.VpmemDisk
  1550  	}
  1551  	return nil
  1552  }
  1553  
  1554  func (m *ModifyResourceRequest) GetNicConfig() *NICConfig {
  1555  	if x, ok := m.GetResource().(*ModifyResourceRequest_NicConfig); ok {
  1556  		return x.NicConfig
  1557  	}
  1558  	return nil
  1559  }
  1560  
  1561  func (m *ModifyResourceRequest) GetWindowsDevice() *WindowsPCIDevice {
  1562  	if x, ok := m.GetResource().(*ModifyResourceRequest_WindowsDevice); ok {
  1563  		return x.WindowsDevice
  1564  	}
  1565  	return nil
  1566  }
  1567  
  1568  // XXX_OneofWrappers is for the internal use of the proto package.
  1569  func (*ModifyResourceRequest) XXX_OneofWrappers() []interface{} {
  1570  	return []interface{}{
  1571  		(*ModifyResourceRequest_Processor)(nil),
  1572  		(*ModifyResourceRequest_ProcessorConfig)(nil),
  1573  		(*ModifyResourceRequest_Memory)(nil),
  1574  		(*ModifyResourceRequest_ScsiDisk)(nil),
  1575  		(*ModifyResourceRequest_VpmemDisk)(nil),
  1576  		(*ModifyResourceRequest_NicConfig)(nil),
  1577  		(*ModifyResourceRequest_WindowsDevice)(nil),
  1578  	}
  1579  }
  1580  
  1581  func init() {
  1582  	proto.RegisterEnum("vmservice.ModifyType", ModifyType_name, ModifyType_value)
  1583  	proto.RegisterEnum("vmservice.DiskType", DiskType_name, DiskType_value)
  1584  	proto.RegisterEnum("vmservice.PropertiesVMRequest_PropertiesType", PropertiesVMRequest_PropertiesType_name, PropertiesVMRequest_PropertiesType_value)
  1585  	proto.RegisterEnum("vmservice.CapabilitiesVMResponse_Resource", CapabilitiesVMResponse_Resource_name, CapabilitiesVMResponse_Resource_value)
  1586  	proto.RegisterEnum("vmservice.CapabilitiesVMResponse_SupportedGuestOS", CapabilitiesVMResponse_SupportedGuestOS_name, CapabilitiesVMResponse_SupportedGuestOS_value)
  1587  	proto.RegisterType((*DirectBoot)(nil), "vmservice.DirectBoot")
  1588  	proto.RegisterType((*UEFI)(nil), "vmservice.UEFI")
  1589  	proto.RegisterType((*MemoryConfig)(nil), "vmservice.MemoryConfig")
  1590  	proto.RegisterType((*ProcessorConfig)(nil), "vmservice.ProcessorConfig")
  1591  	proto.RegisterType((*DevicesConfig)(nil), "vmservice.DevicesConfig")
  1592  	proto.RegisterType((*VMConfig)(nil), "vmservice.VMConfig")
  1593  	proto.RegisterMapType((map[string]string)(nil), "vmservice.VMConfig.ExtraDataEntry")
  1594  	proto.RegisterType((*WindowsOptions)(nil), "vmservice.WindowsOptions")
  1595  	proto.RegisterType((*SerialConfig)(nil), "vmservice.SerialConfig")
  1596  	proto.RegisterType((*SerialConfig_Config)(nil), "vmservice.SerialConfig.Config")
  1597  	proto.RegisterType((*CreateVMRequest)(nil), "vmservice.CreateVMRequest")
  1598  	proto.RegisterType((*InspectVMRequest)(nil), "vmservice.InspectVMRequest")
  1599  	proto.RegisterType((*InspectVMResponse)(nil), "vmservice.InspectVMResponse")
  1600  	proto.RegisterType((*MemoryStats)(nil), "vmservice.MemoryStats")
  1601  	proto.RegisterType((*ProcessorStats)(nil), "vmservice.ProcessorStats")
  1602  	proto.RegisterType((*PropertiesVMRequest)(nil), "vmservice.PropertiesVMRequest")
  1603  	proto.RegisterType((*PropertiesVMResponse)(nil), "vmservice.PropertiesVMResponse")
  1604  	proto.RegisterType((*CapabilitiesVMResponse)(nil), "vmservice.CapabilitiesVMResponse")
  1605  	proto.RegisterType((*CapabilitiesVMResponse_SupportedResource)(nil), "vmservice.CapabilitiesVMResponse.SupportedResource")
  1606  	proto.RegisterType((*HVSocketListen)(nil), "vmservice.HVSocketListen")
  1607  	proto.RegisterType((*VSockListen)(nil), "vmservice.VSockListen")
  1608  	proto.RegisterType((*VMSocketRequest)(nil), "vmservice.VMSocketRequest")
  1609  	proto.RegisterType((*SCSIDisk)(nil), "vmservice.SCSIDisk")
  1610  	proto.RegisterType((*VPMEMDisk)(nil), "vmservice.VPMEMDisk")
  1611  	proto.RegisterType((*NICConfig)(nil), "vmservice.NICConfig")
  1612  	proto.RegisterType((*WindowsPCIDevice)(nil), "vmservice.WindowsPCIDevice")
  1613  	proto.RegisterType((*ModifyMemoryRequest)(nil), "vmservice.ModifyMemoryRequest")
  1614  	proto.RegisterType((*ModifyProcessorRequest)(nil), "vmservice.ModifyProcessorRequest")
  1615  	proto.RegisterType((*ModifyProcessorConfigRequest)(nil), "vmservice.ModifyProcessorConfigRequest")
  1616  	proto.RegisterType((*ModifyResourceRequest)(nil), "vmservice.ModifyResourceRequest")
  1617  }
  1618  
  1619  func init() {
  1620  	proto.RegisterFile("github.com/Microsoft/hcsshim/internal/vmservice/vmservice.proto", fileDescriptor_272f12cfdaa6c7c8)
  1621  }
  1622  
  1623  var fileDescriptor_272f12cfdaa6c7c8 = []byte{
  1624  	// 2296 bytes of a gzipped FileDescriptorProto
  1625  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x58, 0xcf, 0x73, 0xdb, 0xc6,
  1626  	0xf5, 0x27, 0x28, 0x8a, 0x22, 0x1f, 0x7f, 0x88, 0x59, 0x39, 0x8e, 0x22, 0x67, 0x24, 0x07, 0x99,
  1627  	0x8c, 0x13, 0x27, 0x91, 0xbe, 0x5f, 0xba, 0xe9, 0xd8, 0xae, 0x9b, 0x54, 0x24, 0x65, 0x93, 0x8d,
  1628  	0x69, 0x29, 0xa0, 0x4d, 0xd7, 0xb9, 0x20, 0x10, 0xb0, 0x22, 0x77, 0x04, 0x60, 0x69, 0xec, 0x42,
  1629  	0xb2, 0x6e, 0x9d, 0xe9, 0xa1, 0xed, 0xa5, 0xb7, 0x1e, 0x3b, 0xfd, 0x2f, 0x3a, 0xd3, 0x6b, 0x67,
  1630  	0x3a, 0x93, 0x63, 0x8f, 0xbd, 0xd4, 0xd3, 0xe8, 0xde, 0x53, 0xff, 0x81, 0xce, 0xfe, 0x00, 0x09,
  1631  	0x90, 0x92, 0x13, 0xfb, 0x86, 0x7d, 0xfb, 0x79, 0x6f, 0xdf, 0xbe, 0xb7, 0xef, 0x17, 0xe0, 0xcb,
  1632  	0x11, 0xe1, 0xe3, 0xf8, 0x70, 0xdb, 0xa5, 0xc1, 0x4e, 0x9f, 0xb8, 0x11, 0x65, 0xf4, 0x88, 0xef,
  1633  	0x8c, 0x5d, 0xc6, 0xc6, 0x24, 0xd8, 0x21, 0x21, 0xc7, 0x51, 0xe8, 0xf8, 0x3b, 0x27, 0x01, 0xc3,
  1634  	0xd1, 0x09, 0x71, 0xf1, 0xec, 0x6b, 0x7b, 0x12, 0x51, 0x4e, 0x51, 0x79, 0x4a, 0xd8, 0xb8, 0x36,
  1635  	0xa2, 0x74, 0xe4, 0xe3, 0x1d, 0xb9, 0x71, 0x18, 0x1f, 0xed, 0xe0, 0x60, 0xc2, 0xcf, 0x14, 0x6e,
  1636  	0xe3, 0xbd, 0xf9, 0x4d, 0xc6, 0xa3, 0xd8, 0xe5, 0x6a, 0xd7, 0x8c, 0x01, 0x3a, 0x24, 0xc2, 0x2e,
  1637  	0x6f, 0x51, 0xca, 0xd1, 0x16, 0x54, 0x8e, 0x71, 0x14, 0x62, 0xdf, 0x9e, 0x38, 0x7c, 0xbc, 0x6e,
  1638  	0x5c, 0x37, 0x3e, 0x2a, 0x5b, 0xa0, 0x48, 0x07, 0x0e, 0x1f, 0x0b, 0x00, 0x09, 0x09, 0x8f, 0x3c,
  1639  	0x05, 0xc8, 0x2b, 0x80, 0x22, 0x49, 0xc0, 0x87, 0x50, 0xd7, 0x12, 0xdc, 0xc0, 0xf3, 0x49, 0x88,
  1640  	0xd7, 0x97, 0x24, 0xa6, 0xa6, 0xa8, 0x6d, 0x45, 0x34, 0x9f, 0x43, 0xe1, 0xc9, 0xde, 0xfd, 0x1e,
  1641  	0xfa, 0x00, 0x6a, 0x47, 0x24, 0x0a, 0x4e, 0x9d, 0x08, 0xa7, 0x8f, 0xac, 0x26, 0xc4, 0xe4, 0x50,
  1642  	0x0f, 0x8b, 0x8b, 0x66, 0x0e, 0x55, 0x24, 0x09, 0xf8, 0x00, 0x6a, 0x74, 0xc2, 0x09, 0x0d, 0x1d,
  1643  	0xdf, 0xf6, 0x1c, 0xee, 0xe8, 0x33, 0xab, 0x09, 0xb1, 0xe3, 0x70, 0xc7, 0xfc, 0x4f, 0x1e, 0xaa,
  1644  	0x7d, 0x1c, 0xd0, 0xe8, 0xac, 0x4d, 0xc3, 0x23, 0x32, 0x42, 0xd7, 0xa0, 0x1c, 0xc8, 0xb5, 0x1d,
  1645  	0x1c, 0xca, 0x73, 0x0b, 0x56, 0x49, 0x11, 0xfa, 0x87, 0xe8, 0x63, 0x68, 0x38, 0xbe, 0x4f, 0x4f,
  1646  	0x6d, 0x7a, 0x82, 0x23, 0x97, 0x06, 0x01, 0xe1, 0xf2, 0xe0, 0x92, 0xb5, 0x2a, 0xe9, 0xfb, 0x53,
  1647  	0x32, 0xba, 0x01, 0xab, 0x1e, 0x3e, 0xc2, 0x51, 0x84, 0x3d, 0x5b, 0x23, 0x97, 0x24, 0xb2, 0x9e,
  1648  	0x90, 0xdb, 0x0a, 0xf8, 0x2e, 0x94, 0xc6, 0x94, 0xdb, 0x63, 0x12, 0xf2, 0xf5, 0x82, 0x44, 0xac,
  1649  	0x8c, 0x29, 0xef, 0x92, 0x90, 0x0b, 0x5d, 0x5c, 0xea, 0x7b, 0x6a, 0x6f, 0x59, 0xee, 0x95, 0x04,
  1650  	0x41, 0x6e, 0xde, 0x84, 0xb7, 0xe4, 0xa6, 0x47, 0x98, 0xeb, 0x44, 0x1a, 0x54, 0x54, 0xca, 0x88,
  1651  	0x8d, 0x8e, 0xa2, 0x6b, 0x2c, 0x12, 0x5a, 0x07, 0x01, 0xa1, 0xf6, 0xc8, 0x99, 0xd8, 0x24, 0x14,
  1652  	0xb7, 0x5b, 0x91, 0xb7, 0xab, 0xfb, 0xf4, 0xb4, 0x1f, 0x10, 0xfa, 0xc0, 0x99, 0xf4, 0xc2, 0xfe,
  1653  	0x21, 0xda, 0x86, 0x2b, 0x63, 0x32, 0x1a, 0x2b, 0xf0, 0xa1, 0xc3, 0xb0, 0x46, 0x97, 0x24, 0xba,
  1654  	0x21, 0xf6, 0x04, 0xbc, 0xe5, 0x30, 0x2c, 0xf1, 0x9f, 0xc2, 0xda, 0x0c, 0x3f, 0x13, 0x5e, 0x96,
  1655  	0xf0, 0xd5, 0x04, 0xae, 0xa5, 0x9b, 0x7f, 0x30, 0x60, 0xf5, 0x20, 0xa2, 0x2e, 0x66, 0x8c, 0x46,
  1656  	0xda, 0xe4, 0x37, 0x60, 0x75, 0x92, 0x90, 0x6c, 0x97, 0xc6, 0x21, 0x97, 0x86, 0xaf, 0x59, 0xf5,
  1657  	0xc9, 0x0c, 0x19, 0x87, 0x5c, 0x98, 0x7f, 0x06, 0x3c, 0xc5, 0x64, 0x34, 0x56, 0xe6, 0xaf, 0x59,
  1658  	0x33, 0x01, 0x4f, 0x25, 0x39, 0x2b, 0xd3, 0x27, 0x89, 0xf9, 0xd3, 0x32, 0x1f, 0x0a, 0xaa, 0xf9,
  1659  	0x5f, 0x03, 0x6a, 0x1d, 0xf9, 0x68, 0x98, 0x56, 0xa7, 0x09, 0xc0, 0x5c, 0x46, 0x84, 0x61, 0x8f,
  1660  	0xd9, 0xba, 0x71, 0x7d, 0xe9, 0xa3, 0x4a, 0x73, 0x6d, 0x7b, 0x16, 0x68, 0x83, 0xf6, 0xa0, 0xd7,
  1661  	0x21, 0xec, 0xd8, 0x2a, 0x0b, 0x98, 0xf8, 0x62, 0xe8, 0x73, 0xa8, 0x9c, 0x4c, 0x02, 0x1c, 0x68,
  1662  	0xa6, 0xbc, 0x64, 0xba, 0x92, 0x62, 0x1a, 0x1e, 0xf4, 0xf7, 0xfa, 0x92, 0x0b, 0x24, 0x50, 0xb1,
  1663  	0xdd, 0x02, 0x08, 0x89, 0x6b, 0xbb, 0xf2, 0xe0, 0xf5, 0xa5, 0x05, 0xae, 0x47, 0xbd, 0xb6, 0x52,
  1664  	0xca, 0x2a, 0x87, 0xc4, 0xd5, 0xfa, 0xb5, 0xa0, 0x7e, 0x4a, 0x42, 0x8f, 0x9e, 0x32, 0x5b, 0xbd,
  1665  	0xf6, 0xf5, 0x82, 0x64, 0xbc, 0x96, 0x62, 0x7c, 0xaa, 0x00, 0x07, 0xed, 0x9e, 0xba, 0x9b, 0x55,
  1666  	0xd3, 0x2c, 0x6a, 0x69, 0xfe, 0xad, 0x00, 0xa5, 0x61, 0x5f, 0x0b, 0xbc, 0x07, 0x35, 0xfd, 0xe4,
  1667  	0xb5, 0x22, 0xc2, 0xfa, 0x95, 0xe6, 0x3b, 0x29, 0x79, 0xe9, 0x10, 0xb1, 0xaa, 0x41, 0x3a, 0x60,
  1668  	0xf6, 0xd2, 0x4e, 0xd1, 0x02, 0xf2, 0x52, 0xc0, 0x46, 0x4a, 0xc0, 0x9c, 0xcf, 0x53, 0x0e, 0xd3,
  1669  	0x62, 0xbe, 0x84, 0xba, 0xba, 0x0d, 0x9b, 0x99, 0x43, 0x08, 0x59, 0x4f, 0x09, 0xc9, 0xf8, 0xc9,
  1670  	0xaa, 0x79, 0x19, 0xb7, 0xdd, 0x83, 0x1a, 0xc3, 0x11, 0x71, 0xfc, 0x84, 0xbf, 0xb0, 0x70, 0x8b,
  1671  	0x81, 0xdc, 0x4f, 0x6e, 0xc1, 0x52, 0x2b, 0x74, 0x1b, 0x2a, 0x9e, 0xcc, 0x78, 0xf6, 0x21, 0xa5,
  1672  	0x2a, 0xd8, 0x2a, 0xcd, 0xb7, 0xd3, 0x67, 0x4f, 0xf3, 0x61, 0x37, 0x67, 0x81, 0x37, 0xcb, 0x8e,
  1673  	0x1f, 0x42, 0x21, 0xc6, 0x47, 0x44, 0x86, 0x5e, 0xa5, 0xb9, 0x9a, 0x62, 0x11, 0xb9, 0xac, 0x9b,
  1674  	0xb3, 0xe4, 0x36, 0x6a, 0xc1, 0x6a, 0xe2, 0x35, 0x95, 0x80, 0x98, 0x8c, 0xbf, 0x4a, 0xf3, 0xdd,
  1675  	0x45, 0xb7, 0xed, 0x2b, 0x80, 0x95, 0xf8, 0x59, 0xaf, 0xd1, 0x2e, 0x00, 0x7e, 0xc1, 0x23, 0x47,
  1676  	0xa5, 0xb3, 0x92, 0xf4, 0xba, 0x99, 0x7e, 0x64, 0xda, 0xa3, 0xdb, 0x7b, 0x02, 0x25, 0xf2, 0xdb,
  1677  	0x5e, 0xc8, 0xa3, 0x33, 0xab, 0x8c, 0x93, 0xf5, 0xc6, 0x3d, 0xa8, 0x67, 0x37, 0x51, 0x03, 0x96,
  1678  	0x8e, 0xf1, 0x99, 0x4e, 0xb1, 0xe2, 0x13, 0x5d, 0x81, 0xe5, 0x13, 0xc7, 0x8f, 0xb1, 0xce, 0xa9,
  1679  	0x6a, 0x71, 0x37, 0x7f, 0xdb, 0x68, 0x55, 0x01, 0xc4, 0x9d, 0xd5, 0x29, 0x66, 0x0b, 0xea, 0x59,
  1680  	0x85, 0xd1, 0xff, 0x41, 0xd5, 0x9d, 0xc4, 0xf6, 0x28, 0xa2, 0xf1, 0xc4, 0x26, 0x9e, 0xca, 0x9f,
  1681  	0xad, 0xfa, 0xf9, 0xcb, 0x2d, 0x68, 0x4f, 0xe2, 0x07, 0x82, 0xdc, 0xeb, 0x58, 0xe0, 0x26, 0xdf,
  1682  	0x9e, 0xf9, 0x1b, 0x03, 0xaa, 0x69, 0xb7, 0xa0, 0x9f, 0xc0, 0xf2, 0x84, 0x46, 0x9c, 0xe9, 0x68,
  1683  	0xd8, 0xbc, 0xc4, 0x7d, 0xdb, 0xda, 0x8b, 0x0a, 0xbc, 0xf1, 0x73, 0x28, 0x6a, 0x7e, 0x04, 0x05,
  1684  	0x41, 0xd2, 0x19, 0x44, 0x7e, 0x8b, 0x52, 0xc1, 0xa8, 0x7b, 0x8c, 0x79, 0xa6, 0x54, 0x28, 0x92,
  1685  	0x28, 0x15, 0xe6, 0xb7, 0xb0, 0xda, 0x8e, 0xb0, 0xc3, 0xf1, 0xb0, 0x6f, 0xe1, 0xe7, 0x31, 0x66,
  1686  	0x1c, 0x7d, 0x02, 0xc5, 0x4c, 0x34, 0xac, 0x5d, 0x60, 0x67, 0x4b, 0x43, 0xd0, 0x75, 0x28, 0xfa,
  1687  	0x74, 0x24, 0x6e, 0x2c, 0x65, 0xb7, 0xca, 0xe7, 0x2f, 0xb7, 0x96, 0x1f, 0xd2, 0x51, 0xaf, 0x63,
  1688  	0x2d, 0xfb, 0x74, 0xd4, 0xf3, 0xcc, 0xaf, 0xa1, 0xd1, 0x0b, 0xd9, 0x04, 0xbb, 0x7c, 0x76, 0xc4,
  1689  	0x15, 0x58, 0x7e, 0x1e, 0xe3, 0x28, 0xb1, 0xbd, 0x5a, 0x88, 0xcc, 0x15, 0x61, 0x37, 0x8e, 0x18,
  1690  	0xa1, 0xa1, 0xce, 0x5c, 0x2a, 0xc7, 0xd5, 0xa7, 0x64, 0x95, 0xb9, 0xda, 0xf0, 0x56, 0x4a, 0x24,
  1691  	0x9b, 0xd0, 0x90, 0x61, 0xb4, 0x0d, 0xc5, 0x08, 0xb3, 0xd8, 0xe7, 0x5a, 0xed, 0xab, 0xdb, 0xaa,
  1692  	0xd0, 0x6f, 0x27, 0x85, 0x7e, 0x7b, 0x28, 0xbc, 0x69, 0x69, 0x94, 0xf9, 0x17, 0x03, 0x2a, 0x2a,
  1693  	0xb8, 0x07, 0xdc, 0xe1, 0x4c, 0x54, 0x95, 0x53, 0x1a, 0x1d, 0x93, 0x70, 0x64, 0x33, 0xcc, 0xed,
  1694  	0xc3, 0x33, 0x8e, 0x99, 0x2e, 0x83, 0xab, 0x7a, 0x63, 0x80, 0x79, 0x4b, 0x90, 0x65, 0x35, 0x3c,
  1695  	0x71, 0x88, 0xef, 0x1c, 0xfa, 0xd8, 0x56, 0x39, 0x41, 0xaa, 0x5a, 0xb0, 0x56, 0xa7, 0x74, 0x25,
  1696  	0x5b, 0x5d, 0x4a, 0x98, 0x0f, 0x7b, 0x09, 0x72, 0x49, 0x55, 0x9f, 0x84, 0x3c, 0x03, 0x3a, 0x8c,
  1697  	0x91, 0x51, 0x38, 0x03, 0x16, 0x14, 0x30, 0x21, 0x2b, 0xa0, 0x79, 0x17, 0xea, 0xd3, 0x9c, 0xa2,
  1698  	0x54, 0xff, 0x08, 0x1a, 0x9c, 0x72, 0xc7, 0xb7, 0xa3, 0x38, 0xe4, 0x24, 0xc0, 0x76, 0x98, 0x68,
  1699  	0x5e, 0x97, 0x74, 0x4b, 0x91, 0x1f, 0x31, 0xf3, 0xb7, 0x06, 0xac, 0x1d, 0x44, 0x74, 0x82, 0x23,
  1700  	0x4e, 0x30, 0x9b, 0x39, 0xa4, 0x0d, 0xcb, 0xfc, 0x6c, 0x82, 0x55, 0xd2, 0xaf, 0x37, 0x3f, 0xcb,
  1701  	0xe6, 0xaf, 0x79, 0x78, 0x8a, 0xf6, 0xf8, 0x6c, 0x82, 0x2d, 0xc5, 0x6b, 0x7e, 0x22, 0x15, 0x4b,
  1702  	0x6d, 0x20, 0x80, 0xa2, 0x52, 0xba, 0x91, 0x43, 0x35, 0x28, 0x4f, 0xd5, 0x6e, 0x18, 0xe6, 0x1f,
  1703  	0x0d, 0xb8, 0x92, 0x15, 0xad, 0xfd, 0x78, 0x07, 0x74, 0x96, 0xb5, 0x99, 0xb8, 0xdc, 0xd4, 0x9b,
  1704  	0xf3, 0x29, 0x59, 0x5e, 0xdd, 0xaa, 0x04, 0x29, 0x17, 0xb6, 0xd2, 0xa5, 0x4f, 0x71, 0xe7, 0x17,
  1705  	0x32, 0x4d, 0xd6, 0x76, 0xa9, 0xaa, 0x28, 0xd7, 0xe6, 0xef, 0x0a, 0x70, 0xb5, 0xed, 0x4c, 0x9c,
  1706  	0x43, 0xe2, 0x93, 0x39, 0xcd, 0x3c, 0x58, 0x63, 0xf1, 0x44, 0xc4, 0x15, 0xf6, 0xec, 0x08, 0x33,
  1707  	0x1a, 0x47, 0x2e, 0x4e, 0xea, 0xe4, 0xad, 0xd4, 0x11, 0x17, 0xf3, 0x6f, 0x0f, 0x12, 0x66, 0x4b,
  1708  	0xf3, 0x5a, 0x88, 0xcd, 0x93, 0x18, 0xfa, 0x16, 0x66, 0x54, 0x7b, 0x24, 0xcc, 0x6d, 0x53, 0x55,
  1709  	0x57, 0xeb, 0xcd, 0xe6, 0x6b, 0x1c, 0xf2, 0x40, 0xb0, 0xee, 0x0f, 0xac, 0x06, 0xcb, 0x52, 0xd8,
  1710  	0xc6, 0x9f, 0x0c, 0x78, 0x6b, 0x41, 0x17, 0x91, 0x0d, 0x77, 0x3d, 0x95, 0xb8, 0x4a, 0x96, 0xf8,
  1711  	0x44, 0x57, 0xa1, 0x68, 0xe1, 0x80, 0x9e, 0x60, 0xdd, 0xe9, 0xe9, 0x95, 0xa0, 0x3f, 0x99, 0x78,
  1712  	0x0e, 0xc7, 0xba, 0xaf, 0xd3, 0x2b, 0x74, 0x1f, 0x4a, 0x89, 0x55, 0xe4, 0xd3, 0xad, 0x37, 0x6f,
  1713  	0xfe, 0xb0, 0xbe, 0x53, 0x5b, 0x4c, 0x79, 0xcd, 0x6f, 0xa0, 0x34, 0xd5, 0xaa, 0x0c, 0xcb, 0x43,
  1714  	0xd1, 0x35, 0x34, 0x72, 0xa8, 0x04, 0x85, 0x81, 0xcb, 0x48, 0xc3, 0x10, 0x5f, 0xc3, 0x89, 0x4b,
  1715  	0x1a, 0x79, 0xb1, 0x7d, 0xe0, 0x3b, 0xe1, 0x9d, 0xc6, 0x92, 0x44, 0xf6, 0x1f, 0x11, 0xb7, 0x51,
  1716  	0x48, 0x3d, 0xbb, 0xe5, 0xec, 0xb3, 0x2b, 0x9a, 0x37, 0xa1, 0x31, 0x6f, 0x21, 0x54, 0x81, 0x15,
  1717  	0x9d, 0xcd, 0x1b, 0x39, 0x21, 0xe6, 0x21, 0x09, 0xe3, 0x17, 0x0d, 0xc3, 0x74, 0xa1, 0xde, 0x1d,
  1718  	0x0e, 0x64, 0xae, 0x7c, 0x48, 0x18, 0xc7, 0x21, 0xfa, 0x14, 0x40, 0x5f, 0x27, 0xc9, 0xf1, 0xe5,
  1719  	0x56, 0xed, 0xfc, 0xe5, 0x56, 0x79, 0xa0, 0xa8, 0xbd, 0x8e, 0x55, 0xd6, 0x80, 0x9e, 0x27, 0xda,
  1720  	0x70, 0x5f, 0xf2, 0xe1, 0x28, 0x9d, 0x7e, 0xab, 0x09, 0x51, 0x26, 0xe0, 0xfb, 0x50, 0x91, 0x67,
  1721  	0xe8, 0x13, 0x2e, 0x4a, 0xe2, 0x3f, 0x4a, 0xce, 0xdf, 0x0d, 0x58, 0x1d, 0xf6, 0x95, 0xb6, 0x49,
  1722  	0x54, 0x7f, 0x0c, 0x05, 0x11, 0x99, 0x52, 0x58, 0x3d, 0x53, 0xd3, 0xfb, 0xd4, 0x23, 0x47, 0x67,
  1723  	0x32, 0x78, 0x25, 0x04, 0xfd, 0x02, 0x6a, 0xe3, 0x13, 0x5d, 0x2a, 0x84, 0xdc, 0x0b, 0x02, 0x27,
  1724  	0x6b, 0x8b, 0x6e, 0xce, 0xaa, 0x26, 0x1c, 0x82, 0x82, 0x7e, 0x06, 0x55, 0xb9, 0xb4, 0x95, 0x5a,
  1725  	0xba, 0x89, 0x49, 0xc7, 0x6d, 0xea, 0x9e, 0xdd, 0x9c, 0x55, 0x91, 0x68, 0xb5, 0x6c, 0x95, 0x92,
  1726  	0x2a, 0x66, 0xfe, 0xd9, 0x80, 0x52, 0xd2, 0x67, 0xa2, 0x4d, 0x00, 0x97, 0x86, 0x3c, 0xa2, 0xbe,
  1727  	0x8f, 0x23, 0x6d, 0x93, 0x14, 0x45, 0xbc, 0x59, 0x3f, 0x0e, 0x75, 0x95, 0x10, 0x9f, 0x62, 0x70,
  1728  	0x18, 0x53, 0xa6, 0xcb, 0x9d, 0x1a, 0x7b, 0x4a, 0x82, 0x20, 0xe7, 0xa2, 0x1b, 0xda, 0x1e, 0xea,
  1729  	0x71, 0xae, 0x65, 0x7a, 0x1c, 0x76, 0x9c, 0xb2, 0xc6, 0x35, 0x28, 0x47, 0xd8, 0xf1, 0x6c, 0x1a,
  1730  	0xfa, 0x67, 0xc9, 0xf8, 0x21, 0x08, 0xfb, 0xa1, 0x7f, 0x66, 0x86, 0x50, 0x9e, 0xf6, 0xb4, 0xd9,
  1731  	0xf3, 0x8c, 0x4b, 0xce, 0xcb, 0xbf, 0xd6, 0x79, 0x4b, 0x73, 0xe7, 0xfd, 0xd5, 0x80, 0xf2, 0xb4,
  1732  	0x1d, 0x16, 0x05, 0x57, 0x34, 0xce, 0xd3, 0xe7, 0x27, 0x0b, 0xee, 0x23, 0xe2, 0x8a, 0x82, 0x1b,
  1733  	0x12, 0x57, 0x3e, 0xbb, 0x15, 0xf1, 0x6c, 0x66, 0x35, 0x19, 0xce, 0x5f, 0x6e, 0x15, 0x0f, 0x68,
  1734  	0xc4, 0x7b, 0x1d, 0xab, 0x28, 0xb6, 0x7a, 0x9e, 0x68, 0x0c, 0x02, 0xc7, 0xb5, 0x1d, 0xcf, 0x8b,
  1735  	0x30, 0x63, 0xda, 0x52, 0x10, 0x38, 0xee, 0xae, 0xa2, 0xa0, 0x8f, 0xa1, 0xcc, 0x4e, 0x09, 0x77,
  1736  	0xc7, 0x42, 0x4e, 0x41, 0xca, 0xa9, 0x9e, 0xbf, 0xdc, 0x2a, 0x0d, 0x24, 0xb1, 0xd7, 0xb1, 0x4a,
  1737  	0x6a, 0xbb, 0xe7, 0x89, 0x39, 0x4e, 0xa8, 0x14, 0x3a, 0x01, 0x96, 0xc6, 0x2a, 0x5b, 0x2b, 0x21,
  1738  	0x71, 0x1f, 0x39, 0x01, 0x36, 0xdb, 0xd0, 0x98, 0x6f, 0xc8, 0xd1, 0x8e, 0x98, 0x99, 0x19, 0x77,
  1739  	0xc2, 0x74, 0x14, 0xc9, 0x4e, 0xa9, 0xa7, 0xc9, 0xa2, 0x53, 0x4a, 0x20, 0x3d, 0xcf, 0x6c, 0xc2,
  1740  	0x9a, 0x7a, 0xaf, 0x2a, 0xa8, 0x93, 0xd7, 0xfd, 0xaa, 0x79, 0xd5, 0xdc, 0x85, 0xab, 0x8a, 0x67,
  1741  	0x1a, 0xfc, 0x09, 0x5b, 0x66, 0x3e, 0x22, 0xa1, 0x87, 0x5f, 0x2c, 0xcc, 0x5c, 0x3d, 0x41, 0x35,
  1742  	0x23, 0x78, 0x6f, 0x4e, 0x84, 0xee, 0x7d, 0xa6, 0xd1, 0xb5, 0x38, 0x93, 0x19, 0x3f, 0x7a, 0x26,
  1743  	0xcb, 0x5f, 0x38, 0x93, 0xfd, 0xbe, 0x00, 0x6f, 0xab, 0x43, 0xa7, 0x79, 0xf1, 0xf5, 0x63, 0x79,
  1744  	0x17, 0xca, 0x53, 0xb1, 0x3a, 0x8e, 0xdf, 0x5f, 0xc0, 0xcf, 0xdb, 0xa5, 0x9b, 0xb3, 0x66, 0x5c,
  1745  	0xe8, 0xf1, 0x05, 0xa3, 0x8d, 0x0a, 0xe8, 0x1b, 0x97, 0x4b, 0xca, 0x98, 0xa7, 0x9b, 0x5b, 0x9c,
  1746  	0x74, 0x6e, 0x43, 0x31, 0xd5, 0xd9, 0x64, 0x5b, 0xdc, 0x0b, 0x3c, 0xdc, 0xcd, 0x59, 0x1a, 0x8f,
  1747  	0x9a, 0x50, 0x9e, 0x4e, 0xa6, 0x7a, 0x44, 0xb9, 0x68, 0x30, 0xed, 0xe6, 0xac, 0x52, 0x32, 0x9a,
  1748  	0xa2, 0xcf, 0x01, 0x66, 0x93, 0xa9, 0x1e, 0x52, 0x2e, 0x1c, 0x4c, 0xc5, 0xd5, 0xa7, 0xa3, 0xa9,
  1749  	0x60, 0x4b, 0x4d, 0xa6, 0x2b, 0x0b, 0x6c, 0xd3, 0x50, 0x14, 0x6c, 0xb3, 0xd9, 0xb4, 0xb3, 0x30,
  1750  	0x9b, 0x96, 0x24, 0xeb, 0xab, 0x66, 0xd3, 0x6e, 0x6e, 0x6e, 0x3a, 0x6d, 0xc1, 0xac, 0x84, 0xde,
  1751  	0xfc, 0x0c, 0x60, 0xe6, 0x5a, 0xb4, 0x02, 0x4b, 0xbb, 0x9d, 0x4e, 0x23, 0x27, 0x8a, 0x9b, 0xb5,
  1752  	0xd7, 0xdf, 0x1f, 0xee, 0x35, 0x0c, 0xf1, 0xfd, 0xe4, 0xa0, 0xb3, 0xfb, 0x78, 0xaf, 0x91, 0xbf,
  1753  	0xf9, 0x0c, 0x4a, 0x49, 0x56, 0x41, 0xef, 0xc0, 0x9a, 0x30, 0x89, 0xdd, 0xe9, 0x0d, 0xbe, 0xb2,
  1754  	0x1f, 0x3f, 0x3b, 0xd8, 0xb3, 0x87, 0xdd, 0xce, 0xff, 0x37, 0x72, 0x17, 0x6f, 0xfc, 0xaa, 0x61,
  1755  	0xa0, 0x6b, 0xf0, 0xce, 0xdc, 0xc6, 0x41, 0xf7, 0xd9, 0xa0, 0xd7, 0xde, 0x7d, 0xd8, 0xc8, 0x37,
  1756  	0xff, 0xb5, 0x0c, 0xf9, 0x61, 0x1f, 0x7d, 0x01, 0xa5, 0x64, 0x56, 0x40, 0xe9, 0x09, 0x77, 0x6e,
  1757  	0x80, 0xd8, 0x58, 0xec, 0xbc, 0xf7, 0x82, 0x09, 0x3f, 0x43, 0xf7, 0x00, 0x1e, 0x63, 0x27, 0xf2,
  1758  	0xe8, 0x69, 0x38, 0xec, 0xa3, 0x4b, 0x50, 0x97, 0x72, 0xdf, 0x81, 0x95, 0x03, 0x27, 0x66, 0xf8,
  1759  	0x0d, 0x58, 0xef, 0xca, 0x86, 0x22, 0x0e, 0xde, 0x84, 0xf7, 0x36, 0x14, 0x9f, 0x3a, 0x84, 0xbf,
  1760  	0x01, 0xe7, 0x7d, 0x28, 0x4f, 0xa7, 0x14, 0x94, 0x7e, 0x06, 0xf3, 0xe3, 0xd0, 0xc6, 0x7b, 0x17,
  1761  	0x6f, 0xea, 0xb6, 0xf3, 0x2b, 0xa8, 0x67, 0x7b, 0xa7, 0x4b, 0x35, 0x79, 0xff, 0x07, 0xdb, 0x2d,
  1762  	0xb4, 0x0f, 0xd5, 0x74, 0xd7, 0x8d, 0x36, 0x5f, 0xdd, 0xe9, 0x6f, 0x6c, 0x5d, 0xba, 0xaf, 0x05,
  1763  	0xfe, 0x12, 0xea, 0xd9, 0x84, 0x85, 0xae, 0x2f, 0x44, 0xf5, 0x5c, 0x2e, 0xbb, 0xd4, 0x62, 0x5f,
  1764  	0x40, 0x29, 0x69, 0x61, 0x32, 0x0f, 0x6c, 0xae, 0xaf, 0xb9, 0x94, 0xff, 0xa7, 0x50, 0xf8, 0x3a,
  1765  	0x26, 0xfc, 0x75, 0x3d, 0xd5, 0xea, 0x7d, 0xf7, 0xfd, 0x66, 0xee, 0x9f, 0xdf, 0x6f, 0xe6, 0x7e,
  1766  	0x7d, 0xbe, 0x69, 0x7c, 0x77, 0xbe, 0x69, 0xfc, 0xe3, 0x7c, 0xd3, 0xf8, 0xf7, 0xf9, 0xa6, 0xf1,
  1767  	0xcd, 0xce, 0x6b, 0xfe, 0x95, 0x3e, 0x2c, 0x4a, 0xd1, 0xb7, 0xfe, 0x17, 0x00, 0x00, 0xff, 0xff,
  1768  	0x29, 0x1c, 0xce, 0x56, 0xcf, 0x16, 0x00, 0x00,
  1769  }
  1770  
  1771  func (m *DirectBoot) Marshal() (dAtA []byte, err error) {
  1772  	size := m.Size()
  1773  	dAtA = make([]byte, size)
  1774  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1775  	if err != nil {
  1776  		return nil, err
  1777  	}
  1778  	return dAtA[:n], nil
  1779  }
  1780  
  1781  func (m *DirectBoot) MarshalTo(dAtA []byte) (int, error) {
  1782  	size := m.Size()
  1783  	return m.MarshalToSizedBuffer(dAtA[:size])
  1784  }
  1785  
  1786  func (m *DirectBoot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1787  	i := len(dAtA)
  1788  	_ = i
  1789  	var l int
  1790  	_ = l
  1791  	if m.XXX_unrecognized != nil {
  1792  		i -= len(m.XXX_unrecognized)
  1793  		copy(dAtA[i:], m.XXX_unrecognized)
  1794  	}
  1795  	if len(m.KernelCmdline) > 0 {
  1796  		i -= len(m.KernelCmdline)
  1797  		copy(dAtA[i:], m.KernelCmdline)
  1798  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.KernelCmdline)))
  1799  		i--
  1800  		dAtA[i] = 0x1a
  1801  	}
  1802  	if len(m.InitrdPath) > 0 {
  1803  		i -= len(m.InitrdPath)
  1804  		copy(dAtA[i:], m.InitrdPath)
  1805  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.InitrdPath)))
  1806  		i--
  1807  		dAtA[i] = 0x12
  1808  	}
  1809  	if len(m.KernelPath) > 0 {
  1810  		i -= len(m.KernelPath)
  1811  		copy(dAtA[i:], m.KernelPath)
  1812  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.KernelPath)))
  1813  		i--
  1814  		dAtA[i] = 0xa
  1815  	}
  1816  	return len(dAtA) - i, nil
  1817  }
  1818  
  1819  func (m *UEFI) Marshal() (dAtA []byte, err error) {
  1820  	size := m.Size()
  1821  	dAtA = make([]byte, size)
  1822  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1823  	if err != nil {
  1824  		return nil, err
  1825  	}
  1826  	return dAtA[:n], nil
  1827  }
  1828  
  1829  func (m *UEFI) MarshalTo(dAtA []byte) (int, error) {
  1830  	size := m.Size()
  1831  	return m.MarshalToSizedBuffer(dAtA[:size])
  1832  }
  1833  
  1834  func (m *UEFI) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1835  	i := len(dAtA)
  1836  	_ = i
  1837  	var l int
  1838  	_ = l
  1839  	if m.XXX_unrecognized != nil {
  1840  		i -= len(m.XXX_unrecognized)
  1841  		copy(dAtA[i:], m.XXX_unrecognized)
  1842  	}
  1843  	if len(m.OptionalData) > 0 {
  1844  		i -= len(m.OptionalData)
  1845  		copy(dAtA[i:], m.OptionalData)
  1846  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.OptionalData)))
  1847  		i--
  1848  		dAtA[i] = 0x1a
  1849  	}
  1850  	if len(m.DevicePath) > 0 {
  1851  		i -= len(m.DevicePath)
  1852  		copy(dAtA[i:], m.DevicePath)
  1853  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.DevicePath)))
  1854  		i--
  1855  		dAtA[i] = 0x12
  1856  	}
  1857  	if len(m.FirmwarePath) > 0 {
  1858  		i -= len(m.FirmwarePath)
  1859  		copy(dAtA[i:], m.FirmwarePath)
  1860  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.FirmwarePath)))
  1861  		i--
  1862  		dAtA[i] = 0xa
  1863  	}
  1864  	return len(dAtA) - i, nil
  1865  }
  1866  
  1867  func (m *MemoryConfig) Marshal() (dAtA []byte, err error) {
  1868  	size := m.Size()
  1869  	dAtA = make([]byte, size)
  1870  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1871  	if err != nil {
  1872  		return nil, err
  1873  	}
  1874  	return dAtA[:n], nil
  1875  }
  1876  
  1877  func (m *MemoryConfig) MarshalTo(dAtA []byte) (int, error) {
  1878  	size := m.Size()
  1879  	return m.MarshalToSizedBuffer(dAtA[:size])
  1880  }
  1881  
  1882  func (m *MemoryConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1883  	i := len(dAtA)
  1884  	_ = i
  1885  	var l int
  1886  	_ = l
  1887  	if m.XXX_unrecognized != nil {
  1888  		i -= len(m.XXX_unrecognized)
  1889  		copy(dAtA[i:], m.XXX_unrecognized)
  1890  	}
  1891  	if m.HighMmioGapInMb != 0 {
  1892  		i = encodeVarintVmservice(dAtA, i, uint64(m.HighMmioGapInMb))
  1893  		i--
  1894  		dAtA[i] = 0x48
  1895  	}
  1896  	if m.HighMmioBaseInMb != 0 {
  1897  		i = encodeVarintVmservice(dAtA, i, uint64(m.HighMmioBaseInMb))
  1898  		i--
  1899  		dAtA[i] = 0x40
  1900  	}
  1901  	if m.LowMmioGapInMb != 0 {
  1902  		i = encodeVarintVmservice(dAtA, i, uint64(m.LowMmioGapInMb))
  1903  		i--
  1904  		dAtA[i] = 0x38
  1905  	}
  1906  	if m.ColdDiscardHint {
  1907  		i--
  1908  		if m.ColdDiscardHint {
  1909  			dAtA[i] = 1
  1910  		} else {
  1911  			dAtA[i] = 0
  1912  		}
  1913  		i--
  1914  		dAtA[i] = 0x30
  1915  	}
  1916  	if m.ColdHint {
  1917  		i--
  1918  		if m.ColdHint {
  1919  			dAtA[i] = 1
  1920  		} else {
  1921  			dAtA[i] = 0
  1922  		}
  1923  		i--
  1924  		dAtA[i] = 0x28
  1925  	}
  1926  	if m.HotHint {
  1927  		i--
  1928  		if m.HotHint {
  1929  			dAtA[i] = 1
  1930  		} else {
  1931  			dAtA[i] = 0
  1932  		}
  1933  		i--
  1934  		dAtA[i] = 0x20
  1935  	}
  1936  	if m.DeferredCommit {
  1937  		i--
  1938  		if m.DeferredCommit {
  1939  			dAtA[i] = 1
  1940  		} else {
  1941  			dAtA[i] = 0
  1942  		}
  1943  		i--
  1944  		dAtA[i] = 0x18
  1945  	}
  1946  	if m.AllowOvercommit {
  1947  		i--
  1948  		if m.AllowOvercommit {
  1949  			dAtA[i] = 1
  1950  		} else {
  1951  			dAtA[i] = 0
  1952  		}
  1953  		i--
  1954  		dAtA[i] = 0x10
  1955  	}
  1956  	if m.MemoryMb != 0 {
  1957  		i = encodeVarintVmservice(dAtA, i, uint64(m.MemoryMb))
  1958  		i--
  1959  		dAtA[i] = 0x8
  1960  	}
  1961  	return len(dAtA) - i, nil
  1962  }
  1963  
  1964  func (m *ProcessorConfig) Marshal() (dAtA []byte, err error) {
  1965  	size := m.Size()
  1966  	dAtA = make([]byte, size)
  1967  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1968  	if err != nil {
  1969  		return nil, err
  1970  	}
  1971  	return dAtA[:n], nil
  1972  }
  1973  
  1974  func (m *ProcessorConfig) MarshalTo(dAtA []byte) (int, error) {
  1975  	size := m.Size()
  1976  	return m.MarshalToSizedBuffer(dAtA[:size])
  1977  }
  1978  
  1979  func (m *ProcessorConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1980  	i := len(dAtA)
  1981  	_ = i
  1982  	var l int
  1983  	_ = l
  1984  	if m.XXX_unrecognized != nil {
  1985  		i -= len(m.XXX_unrecognized)
  1986  		copy(dAtA[i:], m.XXX_unrecognized)
  1987  	}
  1988  	if m.ProcessorLimit != 0 {
  1989  		i = encodeVarintVmservice(dAtA, i, uint64(m.ProcessorLimit))
  1990  		i--
  1991  		dAtA[i] = 0x18
  1992  	}
  1993  	if m.ProcessorWeight != 0 {
  1994  		i = encodeVarintVmservice(dAtA, i, uint64(m.ProcessorWeight))
  1995  		i--
  1996  		dAtA[i] = 0x10
  1997  	}
  1998  	if m.ProcessorCount != 0 {
  1999  		i = encodeVarintVmservice(dAtA, i, uint64(m.ProcessorCount))
  2000  		i--
  2001  		dAtA[i] = 0x8
  2002  	}
  2003  	return len(dAtA) - i, nil
  2004  }
  2005  
  2006  func (m *DevicesConfig) Marshal() (dAtA []byte, err error) {
  2007  	size := m.Size()
  2008  	dAtA = make([]byte, size)
  2009  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2010  	if err != nil {
  2011  		return nil, err
  2012  	}
  2013  	return dAtA[:n], nil
  2014  }
  2015  
  2016  func (m *DevicesConfig) MarshalTo(dAtA []byte) (int, error) {
  2017  	size := m.Size()
  2018  	return m.MarshalToSizedBuffer(dAtA[:size])
  2019  }
  2020  
  2021  func (m *DevicesConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2022  	i := len(dAtA)
  2023  	_ = i
  2024  	var l int
  2025  	_ = l
  2026  	if m.XXX_unrecognized != nil {
  2027  		i -= len(m.XXX_unrecognized)
  2028  		copy(dAtA[i:], m.XXX_unrecognized)
  2029  	}
  2030  	if len(m.WindowsDevice) > 0 {
  2031  		for iNdEx := len(m.WindowsDevice) - 1; iNdEx >= 0; iNdEx-- {
  2032  			{
  2033  				size, err := m.WindowsDevice[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2034  				if err != nil {
  2035  					return 0, err
  2036  				}
  2037  				i -= size
  2038  				i = encodeVarintVmservice(dAtA, i, uint64(size))
  2039  			}
  2040  			i--
  2041  			dAtA[i] = 0x22
  2042  		}
  2043  	}
  2044  	if len(m.NicConfig) > 0 {
  2045  		for iNdEx := len(m.NicConfig) - 1; iNdEx >= 0; iNdEx-- {
  2046  			{
  2047  				size, err := m.NicConfig[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2048  				if err != nil {
  2049  					return 0, err
  2050  				}
  2051  				i -= size
  2052  				i = encodeVarintVmservice(dAtA, i, uint64(size))
  2053  			}
  2054  			i--
  2055  			dAtA[i] = 0x1a
  2056  		}
  2057  	}
  2058  	if len(m.VpmemDisks) > 0 {
  2059  		for iNdEx := len(m.VpmemDisks) - 1; iNdEx >= 0; iNdEx-- {
  2060  			{
  2061  				size, err := m.VpmemDisks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2062  				if err != nil {
  2063  					return 0, err
  2064  				}
  2065  				i -= size
  2066  				i = encodeVarintVmservice(dAtA, i, uint64(size))
  2067  			}
  2068  			i--
  2069  			dAtA[i] = 0x12
  2070  		}
  2071  	}
  2072  	if len(m.ScsiDisks) > 0 {
  2073  		for iNdEx := len(m.ScsiDisks) - 1; iNdEx >= 0; iNdEx-- {
  2074  			{
  2075  				size, err := m.ScsiDisks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2076  				if err != nil {
  2077  					return 0, err
  2078  				}
  2079  				i -= size
  2080  				i = encodeVarintVmservice(dAtA, i, uint64(size))
  2081  			}
  2082  			i--
  2083  			dAtA[i] = 0xa
  2084  		}
  2085  	}
  2086  	return len(dAtA) - i, nil
  2087  }
  2088  
  2089  func (m *VMConfig) Marshal() (dAtA []byte, err error) {
  2090  	size := m.Size()
  2091  	dAtA = make([]byte, size)
  2092  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2093  	if err != nil {
  2094  		return nil, err
  2095  	}
  2096  	return dAtA[:n], nil
  2097  }
  2098  
  2099  func (m *VMConfig) MarshalTo(dAtA []byte) (int, error) {
  2100  	size := m.Size()
  2101  	return m.MarshalToSizedBuffer(dAtA[:size])
  2102  }
  2103  
  2104  func (m *VMConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2105  	i := len(dAtA)
  2106  	_ = i
  2107  	var l int
  2108  	_ = l
  2109  	if m.XXX_unrecognized != nil {
  2110  		i -= len(m.XXX_unrecognized)
  2111  		copy(dAtA[i:], m.XXX_unrecognized)
  2112  	}
  2113  	if len(m.ExtraData) > 0 {
  2114  		for k := range m.ExtraData {
  2115  			v := m.ExtraData[k]
  2116  			baseI := i
  2117  			i -= len(v)
  2118  			copy(dAtA[i:], v)
  2119  			i = encodeVarintVmservice(dAtA, i, uint64(len(v)))
  2120  			i--
  2121  			dAtA[i] = 0x12
  2122  			i -= len(k)
  2123  			copy(dAtA[i:], k)
  2124  			i = encodeVarintVmservice(dAtA, i, uint64(len(k)))
  2125  			i--
  2126  			dAtA[i] = 0xa
  2127  			i = encodeVarintVmservice(dAtA, i, uint64(baseI-i))
  2128  			i--
  2129  			dAtA[i] = 0x42
  2130  		}
  2131  	}
  2132  	if m.WindowsOptions != nil {
  2133  		{
  2134  			size, err := m.WindowsOptions.MarshalToSizedBuffer(dAtA[:i])
  2135  			if err != nil {
  2136  				return 0, err
  2137  			}
  2138  			i -= size
  2139  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  2140  		}
  2141  		i--
  2142  		dAtA[i] = 0x3a
  2143  	}
  2144  	if m.BootConfig != nil {
  2145  		{
  2146  			size := m.BootConfig.Size()
  2147  			i -= size
  2148  			if _, err := m.BootConfig.MarshalTo(dAtA[i:]); err != nil {
  2149  				return 0, err
  2150  			}
  2151  		}
  2152  	}
  2153  	if m.SerialConfig != nil {
  2154  		{
  2155  			size, err := m.SerialConfig.MarshalToSizedBuffer(dAtA[:i])
  2156  			if err != nil {
  2157  				return 0, err
  2158  			}
  2159  			i -= size
  2160  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  2161  		}
  2162  		i--
  2163  		dAtA[i] = 0x22
  2164  	}
  2165  	if m.DevicesConfig != nil {
  2166  		{
  2167  			size, err := m.DevicesConfig.MarshalToSizedBuffer(dAtA[:i])
  2168  			if err != nil {
  2169  				return 0, err
  2170  			}
  2171  			i -= size
  2172  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  2173  		}
  2174  		i--
  2175  		dAtA[i] = 0x1a
  2176  	}
  2177  	if m.ProcessorConfig != nil {
  2178  		{
  2179  			size, err := m.ProcessorConfig.MarshalToSizedBuffer(dAtA[:i])
  2180  			if err != nil {
  2181  				return 0, err
  2182  			}
  2183  			i -= size
  2184  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  2185  		}
  2186  		i--
  2187  		dAtA[i] = 0x12
  2188  	}
  2189  	if m.MemoryConfig != nil {
  2190  		{
  2191  			size, err := m.MemoryConfig.MarshalToSizedBuffer(dAtA[:i])
  2192  			if err != nil {
  2193  				return 0, err
  2194  			}
  2195  			i -= size
  2196  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  2197  		}
  2198  		i--
  2199  		dAtA[i] = 0xa
  2200  	}
  2201  	return len(dAtA) - i, nil
  2202  }
  2203  
  2204  func (m *VMConfig_DirectBoot) MarshalTo(dAtA []byte) (int, error) {
  2205  	size := m.Size()
  2206  	return m.MarshalToSizedBuffer(dAtA[:size])
  2207  }
  2208  
  2209  func (m *VMConfig_DirectBoot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2210  	i := len(dAtA)
  2211  	if m.DirectBoot != nil {
  2212  		{
  2213  			size, err := m.DirectBoot.MarshalToSizedBuffer(dAtA[:i])
  2214  			if err != nil {
  2215  				return 0, err
  2216  			}
  2217  			i -= size
  2218  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  2219  		}
  2220  		i--
  2221  		dAtA[i] = 0x2a
  2222  	}
  2223  	return len(dAtA) - i, nil
  2224  }
  2225  func (m *VMConfig_Uefi) MarshalTo(dAtA []byte) (int, error) {
  2226  	size := m.Size()
  2227  	return m.MarshalToSizedBuffer(dAtA[:size])
  2228  }
  2229  
  2230  func (m *VMConfig_Uefi) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2231  	i := len(dAtA)
  2232  	if m.Uefi != nil {
  2233  		{
  2234  			size, err := m.Uefi.MarshalToSizedBuffer(dAtA[:i])
  2235  			if err != nil {
  2236  				return 0, err
  2237  			}
  2238  			i -= size
  2239  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  2240  		}
  2241  		i--
  2242  		dAtA[i] = 0x32
  2243  	}
  2244  	return len(dAtA) - i, nil
  2245  }
  2246  func (m *WindowsOptions) Marshal() (dAtA []byte, err error) {
  2247  	size := m.Size()
  2248  	dAtA = make([]byte, size)
  2249  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2250  	if err != nil {
  2251  		return nil, err
  2252  	}
  2253  	return dAtA[:n], nil
  2254  }
  2255  
  2256  func (m *WindowsOptions) MarshalTo(dAtA []byte) (int, error) {
  2257  	size := m.Size()
  2258  	return m.MarshalToSizedBuffer(dAtA[:size])
  2259  }
  2260  
  2261  func (m *WindowsOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2262  	i := len(dAtA)
  2263  	_ = i
  2264  	var l int
  2265  	_ = l
  2266  	if m.XXX_unrecognized != nil {
  2267  		i -= len(m.XXX_unrecognized)
  2268  		copy(dAtA[i:], m.XXX_unrecognized)
  2269  	}
  2270  	if m.CpuGroupID != 0 {
  2271  		i = encodeVarintVmservice(dAtA, i, uint64(m.CpuGroupID))
  2272  		i--
  2273  		dAtA[i] = 0x8
  2274  	}
  2275  	return len(dAtA) - i, nil
  2276  }
  2277  
  2278  func (m *SerialConfig) Marshal() (dAtA []byte, err error) {
  2279  	size := m.Size()
  2280  	dAtA = make([]byte, size)
  2281  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2282  	if err != nil {
  2283  		return nil, err
  2284  	}
  2285  	return dAtA[:n], nil
  2286  }
  2287  
  2288  func (m *SerialConfig) MarshalTo(dAtA []byte) (int, error) {
  2289  	size := m.Size()
  2290  	return m.MarshalToSizedBuffer(dAtA[:size])
  2291  }
  2292  
  2293  func (m *SerialConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2294  	i := len(dAtA)
  2295  	_ = i
  2296  	var l int
  2297  	_ = l
  2298  	if m.XXX_unrecognized != nil {
  2299  		i -= len(m.XXX_unrecognized)
  2300  		copy(dAtA[i:], m.XXX_unrecognized)
  2301  	}
  2302  	if len(m.Ports) > 0 {
  2303  		for iNdEx := len(m.Ports) - 1; iNdEx >= 0; iNdEx-- {
  2304  			{
  2305  				size, err := m.Ports[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2306  				if err != nil {
  2307  					return 0, err
  2308  				}
  2309  				i -= size
  2310  				i = encodeVarintVmservice(dAtA, i, uint64(size))
  2311  			}
  2312  			i--
  2313  			dAtA[i] = 0x1a
  2314  		}
  2315  	}
  2316  	return len(dAtA) - i, nil
  2317  }
  2318  
  2319  func (m *SerialConfig_Config) Marshal() (dAtA []byte, err error) {
  2320  	size := m.Size()
  2321  	dAtA = make([]byte, size)
  2322  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2323  	if err != nil {
  2324  		return nil, err
  2325  	}
  2326  	return dAtA[:n], nil
  2327  }
  2328  
  2329  func (m *SerialConfig_Config) MarshalTo(dAtA []byte) (int, error) {
  2330  	size := m.Size()
  2331  	return m.MarshalToSizedBuffer(dAtA[:size])
  2332  }
  2333  
  2334  func (m *SerialConfig_Config) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2335  	i := len(dAtA)
  2336  	_ = i
  2337  	var l int
  2338  	_ = l
  2339  	if m.XXX_unrecognized != nil {
  2340  		i -= len(m.XXX_unrecognized)
  2341  		copy(dAtA[i:], m.XXX_unrecognized)
  2342  	}
  2343  	if len(m.SocketPath) > 0 {
  2344  		i -= len(m.SocketPath)
  2345  		copy(dAtA[i:], m.SocketPath)
  2346  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.SocketPath)))
  2347  		i--
  2348  		dAtA[i] = 0x12
  2349  	}
  2350  	if m.Port != 0 {
  2351  		i = encodeVarintVmservice(dAtA, i, uint64(m.Port))
  2352  		i--
  2353  		dAtA[i] = 0x8
  2354  	}
  2355  	return len(dAtA) - i, nil
  2356  }
  2357  
  2358  func (m *CreateVMRequest) Marshal() (dAtA []byte, err error) {
  2359  	size := m.Size()
  2360  	dAtA = make([]byte, size)
  2361  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2362  	if err != nil {
  2363  		return nil, err
  2364  	}
  2365  	return dAtA[:n], nil
  2366  }
  2367  
  2368  func (m *CreateVMRequest) MarshalTo(dAtA []byte) (int, error) {
  2369  	size := m.Size()
  2370  	return m.MarshalToSizedBuffer(dAtA[:size])
  2371  }
  2372  
  2373  func (m *CreateVMRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2374  	i := len(dAtA)
  2375  	_ = i
  2376  	var l int
  2377  	_ = l
  2378  	if m.XXX_unrecognized != nil {
  2379  		i -= len(m.XXX_unrecognized)
  2380  		copy(dAtA[i:], m.XXX_unrecognized)
  2381  	}
  2382  	if len(m.LogID) > 0 {
  2383  		i -= len(m.LogID)
  2384  		copy(dAtA[i:], m.LogID)
  2385  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.LogID)))
  2386  		i--
  2387  		dAtA[i] = 0x12
  2388  	}
  2389  	if m.Config != nil {
  2390  		{
  2391  			size, err := m.Config.MarshalToSizedBuffer(dAtA[:i])
  2392  			if err != nil {
  2393  				return 0, err
  2394  			}
  2395  			i -= size
  2396  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  2397  		}
  2398  		i--
  2399  		dAtA[i] = 0xa
  2400  	}
  2401  	return len(dAtA) - i, nil
  2402  }
  2403  
  2404  func (m *InspectVMRequest) Marshal() (dAtA []byte, err error) {
  2405  	size := m.Size()
  2406  	dAtA = make([]byte, size)
  2407  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2408  	if err != nil {
  2409  		return nil, err
  2410  	}
  2411  	return dAtA[:n], nil
  2412  }
  2413  
  2414  func (m *InspectVMRequest) MarshalTo(dAtA []byte) (int, error) {
  2415  	size := m.Size()
  2416  	return m.MarshalToSizedBuffer(dAtA[:size])
  2417  }
  2418  
  2419  func (m *InspectVMRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2420  	i := len(dAtA)
  2421  	_ = i
  2422  	var l int
  2423  	_ = l
  2424  	if m.XXX_unrecognized != nil {
  2425  		i -= len(m.XXX_unrecognized)
  2426  		copy(dAtA[i:], m.XXX_unrecognized)
  2427  	}
  2428  	if m.RecursionLimit != 0 {
  2429  		i = encodeVarintVmservice(dAtA, i, uint64(m.RecursionLimit))
  2430  		i--
  2431  		dAtA[i] = 0x10
  2432  	}
  2433  	if len(m.Query) > 0 {
  2434  		i -= len(m.Query)
  2435  		copy(dAtA[i:], m.Query)
  2436  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.Query)))
  2437  		i--
  2438  		dAtA[i] = 0xa
  2439  	}
  2440  	return len(dAtA) - i, nil
  2441  }
  2442  
  2443  func (m *InspectVMResponse) Marshal() (dAtA []byte, err error) {
  2444  	size := m.Size()
  2445  	dAtA = make([]byte, size)
  2446  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2447  	if err != nil {
  2448  		return nil, err
  2449  	}
  2450  	return dAtA[:n], nil
  2451  }
  2452  
  2453  func (m *InspectVMResponse) MarshalTo(dAtA []byte) (int, error) {
  2454  	size := m.Size()
  2455  	return m.MarshalToSizedBuffer(dAtA[:size])
  2456  }
  2457  
  2458  func (m *InspectVMResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2459  	i := len(dAtA)
  2460  	_ = i
  2461  	var l int
  2462  	_ = l
  2463  	if m.XXX_unrecognized != nil {
  2464  		i -= len(m.XXX_unrecognized)
  2465  		copy(dAtA[i:], m.XXX_unrecognized)
  2466  	}
  2467  	if m.Result != nil {
  2468  		{
  2469  			size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
  2470  			if err != nil {
  2471  				return 0, err
  2472  			}
  2473  			i -= size
  2474  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  2475  		}
  2476  		i--
  2477  		dAtA[i] = 0xa
  2478  	}
  2479  	return len(dAtA) - i, nil
  2480  }
  2481  
  2482  func (m *MemoryStats) Marshal() (dAtA []byte, err error) {
  2483  	size := m.Size()
  2484  	dAtA = make([]byte, size)
  2485  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2486  	if err != nil {
  2487  		return nil, err
  2488  	}
  2489  	return dAtA[:n], nil
  2490  }
  2491  
  2492  func (m *MemoryStats) MarshalTo(dAtA []byte) (int, error) {
  2493  	size := m.Size()
  2494  	return m.MarshalToSizedBuffer(dAtA[:size])
  2495  }
  2496  
  2497  func (m *MemoryStats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2498  	i := len(dAtA)
  2499  	_ = i
  2500  	var l int
  2501  	_ = l
  2502  	if m.XXX_unrecognized != nil {
  2503  		i -= len(m.XXX_unrecognized)
  2504  		copy(dAtA[i:], m.XXX_unrecognized)
  2505  	}
  2506  	if m.AssignedMemory != 0 {
  2507  		i = encodeVarintVmservice(dAtA, i, uint64(m.AssignedMemory))
  2508  		i--
  2509  		dAtA[i] = 0x20
  2510  	}
  2511  	if m.ReservedMemory != 0 {
  2512  		i = encodeVarintVmservice(dAtA, i, uint64(m.ReservedMemory))
  2513  		i--
  2514  		dAtA[i] = 0x18
  2515  	}
  2516  	if m.AvailableMemory != 0 {
  2517  		i = encodeVarintVmservice(dAtA, i, uint64(m.AvailableMemory))
  2518  		i--
  2519  		dAtA[i] = 0x10
  2520  	}
  2521  	if m.WorkingSetBytes != 0 {
  2522  		i = encodeVarintVmservice(dAtA, i, uint64(m.WorkingSetBytes))
  2523  		i--
  2524  		dAtA[i] = 0x8
  2525  	}
  2526  	return len(dAtA) - i, nil
  2527  }
  2528  
  2529  func (m *ProcessorStats) Marshal() (dAtA []byte, err error) {
  2530  	size := m.Size()
  2531  	dAtA = make([]byte, size)
  2532  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2533  	if err != nil {
  2534  		return nil, err
  2535  	}
  2536  	return dAtA[:n], nil
  2537  }
  2538  
  2539  func (m *ProcessorStats) MarshalTo(dAtA []byte) (int, error) {
  2540  	size := m.Size()
  2541  	return m.MarshalToSizedBuffer(dAtA[:size])
  2542  }
  2543  
  2544  func (m *ProcessorStats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2545  	i := len(dAtA)
  2546  	_ = i
  2547  	var l int
  2548  	_ = l
  2549  	if m.XXX_unrecognized != nil {
  2550  		i -= len(m.XXX_unrecognized)
  2551  		copy(dAtA[i:], m.XXX_unrecognized)
  2552  	}
  2553  	if m.TotalRuntimeNs != 0 {
  2554  		i = encodeVarintVmservice(dAtA, i, uint64(m.TotalRuntimeNs))
  2555  		i--
  2556  		dAtA[i] = 0x8
  2557  	}
  2558  	return len(dAtA) - i, nil
  2559  }
  2560  
  2561  func (m *PropertiesVMRequest) Marshal() (dAtA []byte, err error) {
  2562  	size := m.Size()
  2563  	dAtA = make([]byte, size)
  2564  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2565  	if err != nil {
  2566  		return nil, err
  2567  	}
  2568  	return dAtA[:n], nil
  2569  }
  2570  
  2571  func (m *PropertiesVMRequest) MarshalTo(dAtA []byte) (int, error) {
  2572  	size := m.Size()
  2573  	return m.MarshalToSizedBuffer(dAtA[:size])
  2574  }
  2575  
  2576  func (m *PropertiesVMRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2577  	i := len(dAtA)
  2578  	_ = i
  2579  	var l int
  2580  	_ = l
  2581  	if m.XXX_unrecognized != nil {
  2582  		i -= len(m.XXX_unrecognized)
  2583  		copy(dAtA[i:], m.XXX_unrecognized)
  2584  	}
  2585  	if len(m.Types) > 0 {
  2586  		dAtA11 := make([]byte, len(m.Types)*10)
  2587  		var j10 int
  2588  		for _, num := range m.Types {
  2589  			for num >= 1<<7 {
  2590  				dAtA11[j10] = uint8(uint64(num)&0x7f | 0x80)
  2591  				num >>= 7
  2592  				j10++
  2593  			}
  2594  			dAtA11[j10] = uint8(num)
  2595  			j10++
  2596  		}
  2597  		i -= j10
  2598  		copy(dAtA[i:], dAtA11[:j10])
  2599  		i = encodeVarintVmservice(dAtA, i, uint64(j10))
  2600  		i--
  2601  		dAtA[i] = 0xa
  2602  	}
  2603  	return len(dAtA) - i, nil
  2604  }
  2605  
  2606  func (m *PropertiesVMResponse) Marshal() (dAtA []byte, err error) {
  2607  	size := m.Size()
  2608  	dAtA = make([]byte, size)
  2609  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2610  	if err != nil {
  2611  		return nil, err
  2612  	}
  2613  	return dAtA[:n], nil
  2614  }
  2615  
  2616  func (m *PropertiesVMResponse) MarshalTo(dAtA []byte) (int, error) {
  2617  	size := m.Size()
  2618  	return m.MarshalToSizedBuffer(dAtA[:size])
  2619  }
  2620  
  2621  func (m *PropertiesVMResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2622  	i := len(dAtA)
  2623  	_ = i
  2624  	var l int
  2625  	_ = l
  2626  	if m.XXX_unrecognized != nil {
  2627  		i -= len(m.XXX_unrecognized)
  2628  		copy(dAtA[i:], m.XXX_unrecognized)
  2629  	}
  2630  	if m.ProcessorStats != nil {
  2631  		{
  2632  			size, err := m.ProcessorStats.MarshalToSizedBuffer(dAtA[:i])
  2633  			if err != nil {
  2634  				return 0, err
  2635  			}
  2636  			i -= size
  2637  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  2638  		}
  2639  		i--
  2640  		dAtA[i] = 0x12
  2641  	}
  2642  	if m.MemoryStats != nil {
  2643  		{
  2644  			size, err := m.MemoryStats.MarshalToSizedBuffer(dAtA[:i])
  2645  			if err != nil {
  2646  				return 0, err
  2647  			}
  2648  			i -= size
  2649  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  2650  		}
  2651  		i--
  2652  		dAtA[i] = 0xa
  2653  	}
  2654  	return len(dAtA) - i, nil
  2655  }
  2656  
  2657  func (m *CapabilitiesVMResponse) Marshal() (dAtA []byte, err error) {
  2658  	size := m.Size()
  2659  	dAtA = make([]byte, size)
  2660  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2661  	if err != nil {
  2662  		return nil, err
  2663  	}
  2664  	return dAtA[:n], nil
  2665  }
  2666  
  2667  func (m *CapabilitiesVMResponse) MarshalTo(dAtA []byte) (int, error) {
  2668  	size := m.Size()
  2669  	return m.MarshalToSizedBuffer(dAtA[:size])
  2670  }
  2671  
  2672  func (m *CapabilitiesVMResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2673  	i := len(dAtA)
  2674  	_ = i
  2675  	var l int
  2676  	_ = l
  2677  	if m.XXX_unrecognized != nil {
  2678  		i -= len(m.XXX_unrecognized)
  2679  		copy(dAtA[i:], m.XXX_unrecognized)
  2680  	}
  2681  	if len(m.SupportedGuestOs) > 0 {
  2682  		dAtA15 := make([]byte, len(m.SupportedGuestOs)*10)
  2683  		var j14 int
  2684  		for _, num := range m.SupportedGuestOs {
  2685  			for num >= 1<<7 {
  2686  				dAtA15[j14] = uint8(uint64(num)&0x7f | 0x80)
  2687  				num >>= 7
  2688  				j14++
  2689  			}
  2690  			dAtA15[j14] = uint8(num)
  2691  			j14++
  2692  		}
  2693  		i -= j14
  2694  		copy(dAtA[i:], dAtA15[:j14])
  2695  		i = encodeVarintVmservice(dAtA, i, uint64(j14))
  2696  		i--
  2697  		dAtA[i] = 0x12
  2698  	}
  2699  	if len(m.SupportedResources) > 0 {
  2700  		for iNdEx := len(m.SupportedResources) - 1; iNdEx >= 0; iNdEx-- {
  2701  			{
  2702  				size, err := m.SupportedResources[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2703  				if err != nil {
  2704  					return 0, err
  2705  				}
  2706  				i -= size
  2707  				i = encodeVarintVmservice(dAtA, i, uint64(size))
  2708  			}
  2709  			i--
  2710  			dAtA[i] = 0xa
  2711  		}
  2712  	}
  2713  	return len(dAtA) - i, nil
  2714  }
  2715  
  2716  func (m *CapabilitiesVMResponse_SupportedResource) Marshal() (dAtA []byte, err error) {
  2717  	size := m.Size()
  2718  	dAtA = make([]byte, size)
  2719  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2720  	if err != nil {
  2721  		return nil, err
  2722  	}
  2723  	return dAtA[:n], nil
  2724  }
  2725  
  2726  func (m *CapabilitiesVMResponse_SupportedResource) MarshalTo(dAtA []byte) (int, error) {
  2727  	size := m.Size()
  2728  	return m.MarshalToSizedBuffer(dAtA[:size])
  2729  }
  2730  
  2731  func (m *CapabilitiesVMResponse_SupportedResource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2732  	i := len(dAtA)
  2733  	_ = i
  2734  	var l int
  2735  	_ = l
  2736  	if m.XXX_unrecognized != nil {
  2737  		i -= len(m.XXX_unrecognized)
  2738  		copy(dAtA[i:], m.XXX_unrecognized)
  2739  	}
  2740  	if m.Resource != 0 {
  2741  		i = encodeVarintVmservice(dAtA, i, uint64(m.Resource))
  2742  		i--
  2743  		dAtA[i] = 0x20
  2744  	}
  2745  	if m.Update {
  2746  		i--
  2747  		if m.Update {
  2748  			dAtA[i] = 1
  2749  		} else {
  2750  			dAtA[i] = 0
  2751  		}
  2752  		i--
  2753  		dAtA[i] = 0x18
  2754  	}
  2755  	if m.Remove {
  2756  		i--
  2757  		if m.Remove {
  2758  			dAtA[i] = 1
  2759  		} else {
  2760  			dAtA[i] = 0
  2761  		}
  2762  		i--
  2763  		dAtA[i] = 0x10
  2764  	}
  2765  	if m.Add {
  2766  		i--
  2767  		if m.Add {
  2768  			dAtA[i] = 1
  2769  		} else {
  2770  			dAtA[i] = 0
  2771  		}
  2772  		i--
  2773  		dAtA[i] = 0x8
  2774  	}
  2775  	return len(dAtA) - i, nil
  2776  }
  2777  
  2778  func (m *HVSocketListen) Marshal() (dAtA []byte, err error) {
  2779  	size := m.Size()
  2780  	dAtA = make([]byte, size)
  2781  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2782  	if err != nil {
  2783  		return nil, err
  2784  	}
  2785  	return dAtA[:n], nil
  2786  }
  2787  
  2788  func (m *HVSocketListen) MarshalTo(dAtA []byte) (int, error) {
  2789  	size := m.Size()
  2790  	return m.MarshalToSizedBuffer(dAtA[:size])
  2791  }
  2792  
  2793  func (m *HVSocketListen) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2794  	i := len(dAtA)
  2795  	_ = i
  2796  	var l int
  2797  	_ = l
  2798  	if m.XXX_unrecognized != nil {
  2799  		i -= len(m.XXX_unrecognized)
  2800  		copy(dAtA[i:], m.XXX_unrecognized)
  2801  	}
  2802  	if len(m.ListenerPath) > 0 {
  2803  		i -= len(m.ListenerPath)
  2804  		copy(dAtA[i:], m.ListenerPath)
  2805  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.ListenerPath)))
  2806  		i--
  2807  		dAtA[i] = 0x12
  2808  	}
  2809  	if len(m.ServiceID) > 0 {
  2810  		i -= len(m.ServiceID)
  2811  		copy(dAtA[i:], m.ServiceID)
  2812  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.ServiceID)))
  2813  		i--
  2814  		dAtA[i] = 0xa
  2815  	}
  2816  	return len(dAtA) - i, nil
  2817  }
  2818  
  2819  func (m *VSockListen) Marshal() (dAtA []byte, err error) {
  2820  	size := m.Size()
  2821  	dAtA = make([]byte, size)
  2822  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2823  	if err != nil {
  2824  		return nil, err
  2825  	}
  2826  	return dAtA[:n], nil
  2827  }
  2828  
  2829  func (m *VSockListen) MarshalTo(dAtA []byte) (int, error) {
  2830  	size := m.Size()
  2831  	return m.MarshalToSizedBuffer(dAtA[:size])
  2832  }
  2833  
  2834  func (m *VSockListen) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2835  	i := len(dAtA)
  2836  	_ = i
  2837  	var l int
  2838  	_ = l
  2839  	if m.XXX_unrecognized != nil {
  2840  		i -= len(m.XXX_unrecognized)
  2841  		copy(dAtA[i:], m.XXX_unrecognized)
  2842  	}
  2843  	if len(m.ListenerPath) > 0 {
  2844  		i -= len(m.ListenerPath)
  2845  		copy(dAtA[i:], m.ListenerPath)
  2846  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.ListenerPath)))
  2847  		i--
  2848  		dAtA[i] = 0x12
  2849  	}
  2850  	if m.Port != 0 {
  2851  		i = encodeVarintVmservice(dAtA, i, uint64(m.Port))
  2852  		i--
  2853  		dAtA[i] = 0x8
  2854  	}
  2855  	return len(dAtA) - i, nil
  2856  }
  2857  
  2858  func (m *VMSocketRequest) Marshal() (dAtA []byte, err error) {
  2859  	size := m.Size()
  2860  	dAtA = make([]byte, size)
  2861  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2862  	if err != nil {
  2863  		return nil, err
  2864  	}
  2865  	return dAtA[:n], nil
  2866  }
  2867  
  2868  func (m *VMSocketRequest) MarshalTo(dAtA []byte) (int, error) {
  2869  	size := m.Size()
  2870  	return m.MarshalToSizedBuffer(dAtA[:size])
  2871  }
  2872  
  2873  func (m *VMSocketRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2874  	i := len(dAtA)
  2875  	_ = i
  2876  	var l int
  2877  	_ = l
  2878  	if m.XXX_unrecognized != nil {
  2879  		i -= len(m.XXX_unrecognized)
  2880  		copy(dAtA[i:], m.XXX_unrecognized)
  2881  	}
  2882  	if m.Config != nil {
  2883  		{
  2884  			size := m.Config.Size()
  2885  			i -= size
  2886  			if _, err := m.Config.MarshalTo(dAtA[i:]); err != nil {
  2887  				return 0, err
  2888  			}
  2889  		}
  2890  	}
  2891  	if m.Type != 0 {
  2892  		i = encodeVarintVmservice(dAtA, i, uint64(m.Type))
  2893  		i--
  2894  		dAtA[i] = 0x8
  2895  	}
  2896  	return len(dAtA) - i, nil
  2897  }
  2898  
  2899  func (m *VMSocketRequest_HvsocketList) MarshalTo(dAtA []byte) (int, error) {
  2900  	size := m.Size()
  2901  	return m.MarshalToSizedBuffer(dAtA[:size])
  2902  }
  2903  
  2904  func (m *VMSocketRequest_HvsocketList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2905  	i := len(dAtA)
  2906  	if m.HvsocketList != nil {
  2907  		{
  2908  			size, err := m.HvsocketList.MarshalToSizedBuffer(dAtA[:i])
  2909  			if err != nil {
  2910  				return 0, err
  2911  			}
  2912  			i -= size
  2913  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  2914  		}
  2915  		i--
  2916  		dAtA[i] = 0x12
  2917  	}
  2918  	return len(dAtA) - i, nil
  2919  }
  2920  func (m *VMSocketRequest_VsockListen) MarshalTo(dAtA []byte) (int, error) {
  2921  	size := m.Size()
  2922  	return m.MarshalToSizedBuffer(dAtA[:size])
  2923  }
  2924  
  2925  func (m *VMSocketRequest_VsockListen) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2926  	i := len(dAtA)
  2927  	if m.VsockListen != nil {
  2928  		{
  2929  			size, err := m.VsockListen.MarshalToSizedBuffer(dAtA[:i])
  2930  			if err != nil {
  2931  				return 0, err
  2932  			}
  2933  			i -= size
  2934  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  2935  		}
  2936  		i--
  2937  		dAtA[i] = 0x1a
  2938  	}
  2939  	return len(dAtA) - i, nil
  2940  }
  2941  func (m *SCSIDisk) Marshal() (dAtA []byte, err error) {
  2942  	size := m.Size()
  2943  	dAtA = make([]byte, size)
  2944  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2945  	if err != nil {
  2946  		return nil, err
  2947  	}
  2948  	return dAtA[:n], nil
  2949  }
  2950  
  2951  func (m *SCSIDisk) MarshalTo(dAtA []byte) (int, error) {
  2952  	size := m.Size()
  2953  	return m.MarshalToSizedBuffer(dAtA[:size])
  2954  }
  2955  
  2956  func (m *SCSIDisk) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2957  	i := len(dAtA)
  2958  	_ = i
  2959  	var l int
  2960  	_ = l
  2961  	if m.XXX_unrecognized != nil {
  2962  		i -= len(m.XXX_unrecognized)
  2963  		copy(dAtA[i:], m.XXX_unrecognized)
  2964  	}
  2965  	if m.ReadOnly {
  2966  		i--
  2967  		if m.ReadOnly {
  2968  			dAtA[i] = 1
  2969  		} else {
  2970  			dAtA[i] = 0
  2971  		}
  2972  		i--
  2973  		dAtA[i] = 0x28
  2974  	}
  2975  	if m.Type != 0 {
  2976  		i = encodeVarintVmservice(dAtA, i, uint64(m.Type))
  2977  		i--
  2978  		dAtA[i] = 0x20
  2979  	}
  2980  	if len(m.HostPath) > 0 {
  2981  		i -= len(m.HostPath)
  2982  		copy(dAtA[i:], m.HostPath)
  2983  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.HostPath)))
  2984  		i--
  2985  		dAtA[i] = 0x1a
  2986  	}
  2987  	if m.Lun != 0 {
  2988  		i = encodeVarintVmservice(dAtA, i, uint64(m.Lun))
  2989  		i--
  2990  		dAtA[i] = 0x10
  2991  	}
  2992  	if m.Controller != 0 {
  2993  		i = encodeVarintVmservice(dAtA, i, uint64(m.Controller))
  2994  		i--
  2995  		dAtA[i] = 0x8
  2996  	}
  2997  	return len(dAtA) - i, nil
  2998  }
  2999  
  3000  func (m *VPMEMDisk) Marshal() (dAtA []byte, err error) {
  3001  	size := m.Size()
  3002  	dAtA = make([]byte, size)
  3003  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3004  	if err != nil {
  3005  		return nil, err
  3006  	}
  3007  	return dAtA[:n], nil
  3008  }
  3009  
  3010  func (m *VPMEMDisk) MarshalTo(dAtA []byte) (int, error) {
  3011  	size := m.Size()
  3012  	return m.MarshalToSizedBuffer(dAtA[:size])
  3013  }
  3014  
  3015  func (m *VPMEMDisk) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3016  	i := len(dAtA)
  3017  	_ = i
  3018  	var l int
  3019  	_ = l
  3020  	if m.XXX_unrecognized != nil {
  3021  		i -= len(m.XXX_unrecognized)
  3022  		copy(dAtA[i:], m.XXX_unrecognized)
  3023  	}
  3024  	if m.ReadOnly {
  3025  		i--
  3026  		if m.ReadOnly {
  3027  			dAtA[i] = 1
  3028  		} else {
  3029  			dAtA[i] = 0
  3030  		}
  3031  		i--
  3032  		dAtA[i] = 0x18
  3033  	}
  3034  	if m.Type != 0 {
  3035  		i = encodeVarintVmservice(dAtA, i, uint64(m.Type))
  3036  		i--
  3037  		dAtA[i] = 0x10
  3038  	}
  3039  	if len(m.HostPath) > 0 {
  3040  		i -= len(m.HostPath)
  3041  		copy(dAtA[i:], m.HostPath)
  3042  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.HostPath)))
  3043  		i--
  3044  		dAtA[i] = 0xa
  3045  	}
  3046  	return len(dAtA) - i, nil
  3047  }
  3048  
  3049  func (m *NICConfig) Marshal() (dAtA []byte, err error) {
  3050  	size := m.Size()
  3051  	dAtA = make([]byte, size)
  3052  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3053  	if err != nil {
  3054  		return nil, err
  3055  	}
  3056  	return dAtA[:n], nil
  3057  }
  3058  
  3059  func (m *NICConfig) MarshalTo(dAtA []byte) (int, error) {
  3060  	size := m.Size()
  3061  	return m.MarshalToSizedBuffer(dAtA[:size])
  3062  }
  3063  
  3064  func (m *NICConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3065  	i := len(dAtA)
  3066  	_ = i
  3067  	var l int
  3068  	_ = l
  3069  	if m.XXX_unrecognized != nil {
  3070  		i -= len(m.XXX_unrecognized)
  3071  		copy(dAtA[i:], m.XXX_unrecognized)
  3072  	}
  3073  	if len(m.NicName) > 0 {
  3074  		i -= len(m.NicName)
  3075  		copy(dAtA[i:], m.NicName)
  3076  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.NicName)))
  3077  		i--
  3078  		dAtA[i] = 0x2a
  3079  	}
  3080  	if len(m.SwitchID) > 0 {
  3081  		i -= len(m.SwitchID)
  3082  		copy(dAtA[i:], m.SwitchID)
  3083  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.SwitchID)))
  3084  		i--
  3085  		dAtA[i] = 0x22
  3086  	}
  3087  	if len(m.MacAddress) > 0 {
  3088  		i -= len(m.MacAddress)
  3089  		copy(dAtA[i:], m.MacAddress)
  3090  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.MacAddress)))
  3091  		i--
  3092  		dAtA[i] = 0x1a
  3093  	}
  3094  	if len(m.PortID) > 0 {
  3095  		i -= len(m.PortID)
  3096  		copy(dAtA[i:], m.PortID)
  3097  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.PortID)))
  3098  		i--
  3099  		dAtA[i] = 0x12
  3100  	}
  3101  	if len(m.NicID) > 0 {
  3102  		i -= len(m.NicID)
  3103  		copy(dAtA[i:], m.NicID)
  3104  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.NicID)))
  3105  		i--
  3106  		dAtA[i] = 0xa
  3107  	}
  3108  	return len(dAtA) - i, nil
  3109  }
  3110  
  3111  func (m *WindowsPCIDevice) Marshal() (dAtA []byte, err error) {
  3112  	size := m.Size()
  3113  	dAtA = make([]byte, size)
  3114  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3115  	if err != nil {
  3116  		return nil, err
  3117  	}
  3118  	return dAtA[:n], nil
  3119  }
  3120  
  3121  func (m *WindowsPCIDevice) MarshalTo(dAtA []byte) (int, error) {
  3122  	size := m.Size()
  3123  	return m.MarshalToSizedBuffer(dAtA[:size])
  3124  }
  3125  
  3126  func (m *WindowsPCIDevice) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3127  	i := len(dAtA)
  3128  	_ = i
  3129  	var l int
  3130  	_ = l
  3131  	if m.XXX_unrecognized != nil {
  3132  		i -= len(m.XXX_unrecognized)
  3133  		copy(dAtA[i:], m.XXX_unrecognized)
  3134  	}
  3135  	if len(m.InstanceID) > 0 {
  3136  		i -= len(m.InstanceID)
  3137  		copy(dAtA[i:], m.InstanceID)
  3138  		i = encodeVarintVmservice(dAtA, i, uint64(len(m.InstanceID)))
  3139  		i--
  3140  		dAtA[i] = 0xa
  3141  	}
  3142  	return len(dAtA) - i, nil
  3143  }
  3144  
  3145  func (m *ModifyMemoryRequest) Marshal() (dAtA []byte, err error) {
  3146  	size := m.Size()
  3147  	dAtA = make([]byte, size)
  3148  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3149  	if err != nil {
  3150  		return nil, err
  3151  	}
  3152  	return dAtA[:n], nil
  3153  }
  3154  
  3155  func (m *ModifyMemoryRequest) MarshalTo(dAtA []byte) (int, error) {
  3156  	size := m.Size()
  3157  	return m.MarshalToSizedBuffer(dAtA[:size])
  3158  }
  3159  
  3160  func (m *ModifyMemoryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3161  	i := len(dAtA)
  3162  	_ = i
  3163  	var l int
  3164  	_ = l
  3165  	if m.XXX_unrecognized != nil {
  3166  		i -= len(m.XXX_unrecognized)
  3167  		copy(dAtA[i:], m.XXX_unrecognized)
  3168  	}
  3169  	if m.MemoryMb != 0 {
  3170  		i = encodeVarintVmservice(dAtA, i, uint64(m.MemoryMb))
  3171  		i--
  3172  		dAtA[i] = 0x8
  3173  	}
  3174  	return len(dAtA) - i, nil
  3175  }
  3176  
  3177  func (m *ModifyProcessorRequest) Marshal() (dAtA []byte, err error) {
  3178  	size := m.Size()
  3179  	dAtA = make([]byte, size)
  3180  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3181  	if err != nil {
  3182  		return nil, err
  3183  	}
  3184  	return dAtA[:n], nil
  3185  }
  3186  
  3187  func (m *ModifyProcessorRequest) MarshalTo(dAtA []byte) (int, error) {
  3188  	size := m.Size()
  3189  	return m.MarshalToSizedBuffer(dAtA[:size])
  3190  }
  3191  
  3192  func (m *ModifyProcessorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3193  	i := len(dAtA)
  3194  	_ = i
  3195  	var l int
  3196  	_ = l
  3197  	if m.XXX_unrecognized != nil {
  3198  		i -= len(m.XXX_unrecognized)
  3199  		copy(dAtA[i:], m.XXX_unrecognized)
  3200  	}
  3201  	if m.ProcessorIndex != 0 {
  3202  		i = encodeVarintVmservice(dAtA, i, uint64(m.ProcessorIndex))
  3203  		i--
  3204  		dAtA[i] = 0x8
  3205  	}
  3206  	return len(dAtA) - i, nil
  3207  }
  3208  
  3209  func (m *ModifyProcessorConfigRequest) Marshal() (dAtA []byte, err error) {
  3210  	size := m.Size()
  3211  	dAtA = make([]byte, size)
  3212  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3213  	if err != nil {
  3214  		return nil, err
  3215  	}
  3216  	return dAtA[:n], nil
  3217  }
  3218  
  3219  func (m *ModifyProcessorConfigRequest) MarshalTo(dAtA []byte) (int, error) {
  3220  	size := m.Size()
  3221  	return m.MarshalToSizedBuffer(dAtA[:size])
  3222  }
  3223  
  3224  func (m *ModifyProcessorConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3225  	i := len(dAtA)
  3226  	_ = i
  3227  	var l int
  3228  	_ = l
  3229  	if m.XXX_unrecognized != nil {
  3230  		i -= len(m.XXX_unrecognized)
  3231  		copy(dAtA[i:], m.XXX_unrecognized)
  3232  	}
  3233  	if m.ProcessorLimit != 0 {
  3234  		i = encodeVarintVmservice(dAtA, i, uint64(m.ProcessorLimit))
  3235  		i--
  3236  		dAtA[i] = 0x10
  3237  	}
  3238  	if m.ProcessorWeight != 0 {
  3239  		i = encodeVarintVmservice(dAtA, i, uint64(m.ProcessorWeight))
  3240  		i--
  3241  		dAtA[i] = 0x8
  3242  	}
  3243  	return len(dAtA) - i, nil
  3244  }
  3245  
  3246  func (m *ModifyResourceRequest) Marshal() (dAtA []byte, err error) {
  3247  	size := m.Size()
  3248  	dAtA = make([]byte, size)
  3249  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3250  	if err != nil {
  3251  		return nil, err
  3252  	}
  3253  	return dAtA[:n], nil
  3254  }
  3255  
  3256  func (m *ModifyResourceRequest) MarshalTo(dAtA []byte) (int, error) {
  3257  	size := m.Size()
  3258  	return m.MarshalToSizedBuffer(dAtA[:size])
  3259  }
  3260  
  3261  func (m *ModifyResourceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3262  	i := len(dAtA)
  3263  	_ = i
  3264  	var l int
  3265  	_ = l
  3266  	if m.XXX_unrecognized != nil {
  3267  		i -= len(m.XXX_unrecognized)
  3268  		copy(dAtA[i:], m.XXX_unrecognized)
  3269  	}
  3270  	if m.Resource != nil {
  3271  		{
  3272  			size := m.Resource.Size()
  3273  			i -= size
  3274  			if _, err := m.Resource.MarshalTo(dAtA[i:]); err != nil {
  3275  				return 0, err
  3276  			}
  3277  		}
  3278  	}
  3279  	if m.Type != 0 {
  3280  		i = encodeVarintVmservice(dAtA, i, uint64(m.Type))
  3281  		i--
  3282  		dAtA[i] = 0x8
  3283  	}
  3284  	return len(dAtA) - i, nil
  3285  }
  3286  
  3287  func (m *ModifyResourceRequest_Processor) MarshalTo(dAtA []byte) (int, error) {
  3288  	size := m.Size()
  3289  	return m.MarshalToSizedBuffer(dAtA[:size])
  3290  }
  3291  
  3292  func (m *ModifyResourceRequest_Processor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3293  	i := len(dAtA)
  3294  	if m.Processor != nil {
  3295  		{
  3296  			size, err := m.Processor.MarshalToSizedBuffer(dAtA[:i])
  3297  			if err != nil {
  3298  				return 0, err
  3299  			}
  3300  			i -= size
  3301  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  3302  		}
  3303  		i--
  3304  		dAtA[i] = 0x12
  3305  	}
  3306  	return len(dAtA) - i, nil
  3307  }
  3308  func (m *ModifyResourceRequest_ProcessorConfig) MarshalTo(dAtA []byte) (int, error) {
  3309  	size := m.Size()
  3310  	return m.MarshalToSizedBuffer(dAtA[:size])
  3311  }
  3312  
  3313  func (m *ModifyResourceRequest_ProcessorConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3314  	i := len(dAtA)
  3315  	if m.ProcessorConfig != nil {
  3316  		{
  3317  			size, err := m.ProcessorConfig.MarshalToSizedBuffer(dAtA[:i])
  3318  			if err != nil {
  3319  				return 0, err
  3320  			}
  3321  			i -= size
  3322  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  3323  		}
  3324  		i--
  3325  		dAtA[i] = 0x1a
  3326  	}
  3327  	return len(dAtA) - i, nil
  3328  }
  3329  func (m *ModifyResourceRequest_Memory) MarshalTo(dAtA []byte) (int, error) {
  3330  	size := m.Size()
  3331  	return m.MarshalToSizedBuffer(dAtA[:size])
  3332  }
  3333  
  3334  func (m *ModifyResourceRequest_Memory) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3335  	i := len(dAtA)
  3336  	if m.Memory != nil {
  3337  		{
  3338  			size, err := m.Memory.MarshalToSizedBuffer(dAtA[:i])
  3339  			if err != nil {
  3340  				return 0, err
  3341  			}
  3342  			i -= size
  3343  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  3344  		}
  3345  		i--
  3346  		dAtA[i] = 0x22
  3347  	}
  3348  	return len(dAtA) - i, nil
  3349  }
  3350  func (m *ModifyResourceRequest_ScsiDisk) MarshalTo(dAtA []byte) (int, error) {
  3351  	size := m.Size()
  3352  	return m.MarshalToSizedBuffer(dAtA[:size])
  3353  }
  3354  
  3355  func (m *ModifyResourceRequest_ScsiDisk) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3356  	i := len(dAtA)
  3357  	if m.ScsiDisk != nil {
  3358  		{
  3359  			size, err := m.ScsiDisk.MarshalToSizedBuffer(dAtA[:i])
  3360  			if err != nil {
  3361  				return 0, err
  3362  			}
  3363  			i -= size
  3364  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  3365  		}
  3366  		i--
  3367  		dAtA[i] = 0x2a
  3368  	}
  3369  	return len(dAtA) - i, nil
  3370  }
  3371  func (m *ModifyResourceRequest_VpmemDisk) MarshalTo(dAtA []byte) (int, error) {
  3372  	size := m.Size()
  3373  	return m.MarshalToSizedBuffer(dAtA[:size])
  3374  }
  3375  
  3376  func (m *ModifyResourceRequest_VpmemDisk) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3377  	i := len(dAtA)
  3378  	if m.VpmemDisk != nil {
  3379  		{
  3380  			size, err := m.VpmemDisk.MarshalToSizedBuffer(dAtA[:i])
  3381  			if err != nil {
  3382  				return 0, err
  3383  			}
  3384  			i -= size
  3385  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  3386  		}
  3387  		i--
  3388  		dAtA[i] = 0x32
  3389  	}
  3390  	return len(dAtA) - i, nil
  3391  }
  3392  func (m *ModifyResourceRequest_NicConfig) MarshalTo(dAtA []byte) (int, error) {
  3393  	size := m.Size()
  3394  	return m.MarshalToSizedBuffer(dAtA[:size])
  3395  }
  3396  
  3397  func (m *ModifyResourceRequest_NicConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3398  	i := len(dAtA)
  3399  	if m.NicConfig != nil {
  3400  		{
  3401  			size, err := m.NicConfig.MarshalToSizedBuffer(dAtA[:i])
  3402  			if err != nil {
  3403  				return 0, err
  3404  			}
  3405  			i -= size
  3406  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  3407  		}
  3408  		i--
  3409  		dAtA[i] = 0x3a
  3410  	}
  3411  	return len(dAtA) - i, nil
  3412  }
  3413  func (m *ModifyResourceRequest_WindowsDevice) MarshalTo(dAtA []byte) (int, error) {
  3414  	size := m.Size()
  3415  	return m.MarshalToSizedBuffer(dAtA[:size])
  3416  }
  3417  
  3418  func (m *ModifyResourceRequest_WindowsDevice) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3419  	i := len(dAtA)
  3420  	if m.WindowsDevice != nil {
  3421  		{
  3422  			size, err := m.WindowsDevice.MarshalToSizedBuffer(dAtA[:i])
  3423  			if err != nil {
  3424  				return 0, err
  3425  			}
  3426  			i -= size
  3427  			i = encodeVarintVmservice(dAtA, i, uint64(size))
  3428  		}
  3429  		i--
  3430  		dAtA[i] = 0x42
  3431  	}
  3432  	return len(dAtA) - i, nil
  3433  }
  3434  func encodeVarintVmservice(dAtA []byte, offset int, v uint64) int {
  3435  	offset -= sovVmservice(v)
  3436  	base := offset
  3437  	for v >= 1<<7 {
  3438  		dAtA[offset] = uint8(v&0x7f | 0x80)
  3439  		v >>= 7
  3440  		offset++
  3441  	}
  3442  	dAtA[offset] = uint8(v)
  3443  	return base
  3444  }
  3445  func (m *DirectBoot) Size() (n int) {
  3446  	if m == nil {
  3447  		return 0
  3448  	}
  3449  	var l int
  3450  	_ = l
  3451  	l = len(m.KernelPath)
  3452  	if l > 0 {
  3453  		n += 1 + l + sovVmservice(uint64(l))
  3454  	}
  3455  	l = len(m.InitrdPath)
  3456  	if l > 0 {
  3457  		n += 1 + l + sovVmservice(uint64(l))
  3458  	}
  3459  	l = len(m.KernelCmdline)
  3460  	if l > 0 {
  3461  		n += 1 + l + sovVmservice(uint64(l))
  3462  	}
  3463  	if m.XXX_unrecognized != nil {
  3464  		n += len(m.XXX_unrecognized)
  3465  	}
  3466  	return n
  3467  }
  3468  
  3469  func (m *UEFI) Size() (n int) {
  3470  	if m == nil {
  3471  		return 0
  3472  	}
  3473  	var l int
  3474  	_ = l
  3475  	l = len(m.FirmwarePath)
  3476  	if l > 0 {
  3477  		n += 1 + l + sovVmservice(uint64(l))
  3478  	}
  3479  	l = len(m.DevicePath)
  3480  	if l > 0 {
  3481  		n += 1 + l + sovVmservice(uint64(l))
  3482  	}
  3483  	l = len(m.OptionalData)
  3484  	if l > 0 {
  3485  		n += 1 + l + sovVmservice(uint64(l))
  3486  	}
  3487  	if m.XXX_unrecognized != nil {
  3488  		n += len(m.XXX_unrecognized)
  3489  	}
  3490  	return n
  3491  }
  3492  
  3493  func (m *MemoryConfig) Size() (n int) {
  3494  	if m == nil {
  3495  		return 0
  3496  	}
  3497  	var l int
  3498  	_ = l
  3499  	if m.MemoryMb != 0 {
  3500  		n += 1 + sovVmservice(uint64(m.MemoryMb))
  3501  	}
  3502  	if m.AllowOvercommit {
  3503  		n += 2
  3504  	}
  3505  	if m.DeferredCommit {
  3506  		n += 2
  3507  	}
  3508  	if m.HotHint {
  3509  		n += 2
  3510  	}
  3511  	if m.ColdHint {
  3512  		n += 2
  3513  	}
  3514  	if m.ColdDiscardHint {
  3515  		n += 2
  3516  	}
  3517  	if m.LowMmioGapInMb != 0 {
  3518  		n += 1 + sovVmservice(uint64(m.LowMmioGapInMb))
  3519  	}
  3520  	if m.HighMmioBaseInMb != 0 {
  3521  		n += 1 + sovVmservice(uint64(m.HighMmioBaseInMb))
  3522  	}
  3523  	if m.HighMmioGapInMb != 0 {
  3524  		n += 1 + sovVmservice(uint64(m.HighMmioGapInMb))
  3525  	}
  3526  	if m.XXX_unrecognized != nil {
  3527  		n += len(m.XXX_unrecognized)
  3528  	}
  3529  	return n
  3530  }
  3531  
  3532  func (m *ProcessorConfig) Size() (n int) {
  3533  	if m == nil {
  3534  		return 0
  3535  	}
  3536  	var l int
  3537  	_ = l
  3538  	if m.ProcessorCount != 0 {
  3539  		n += 1 + sovVmservice(uint64(m.ProcessorCount))
  3540  	}
  3541  	if m.ProcessorWeight != 0 {
  3542  		n += 1 + sovVmservice(uint64(m.ProcessorWeight))
  3543  	}
  3544  	if m.ProcessorLimit != 0 {
  3545  		n += 1 + sovVmservice(uint64(m.ProcessorLimit))
  3546  	}
  3547  	if m.XXX_unrecognized != nil {
  3548  		n += len(m.XXX_unrecognized)
  3549  	}
  3550  	return n
  3551  }
  3552  
  3553  func (m *DevicesConfig) Size() (n int) {
  3554  	if m == nil {
  3555  		return 0
  3556  	}
  3557  	var l int
  3558  	_ = l
  3559  	if len(m.ScsiDisks) > 0 {
  3560  		for _, e := range m.ScsiDisks {
  3561  			l = e.Size()
  3562  			n += 1 + l + sovVmservice(uint64(l))
  3563  		}
  3564  	}
  3565  	if len(m.VpmemDisks) > 0 {
  3566  		for _, e := range m.VpmemDisks {
  3567  			l = e.Size()
  3568  			n += 1 + l + sovVmservice(uint64(l))
  3569  		}
  3570  	}
  3571  	if len(m.NicConfig) > 0 {
  3572  		for _, e := range m.NicConfig {
  3573  			l = e.Size()
  3574  			n += 1 + l + sovVmservice(uint64(l))
  3575  		}
  3576  	}
  3577  	if len(m.WindowsDevice) > 0 {
  3578  		for _, e := range m.WindowsDevice {
  3579  			l = e.Size()
  3580  			n += 1 + l + sovVmservice(uint64(l))
  3581  		}
  3582  	}
  3583  	if m.XXX_unrecognized != nil {
  3584  		n += len(m.XXX_unrecognized)
  3585  	}
  3586  	return n
  3587  }
  3588  
  3589  func (m *VMConfig) Size() (n int) {
  3590  	if m == nil {
  3591  		return 0
  3592  	}
  3593  	var l int
  3594  	_ = l
  3595  	if m.MemoryConfig != nil {
  3596  		l = m.MemoryConfig.Size()
  3597  		n += 1 + l + sovVmservice(uint64(l))
  3598  	}
  3599  	if m.ProcessorConfig != nil {
  3600  		l = m.ProcessorConfig.Size()
  3601  		n += 1 + l + sovVmservice(uint64(l))
  3602  	}
  3603  	if m.DevicesConfig != nil {
  3604  		l = m.DevicesConfig.Size()
  3605  		n += 1 + l + sovVmservice(uint64(l))
  3606  	}
  3607  	if m.SerialConfig != nil {
  3608  		l = m.SerialConfig.Size()
  3609  		n += 1 + l + sovVmservice(uint64(l))
  3610  	}
  3611  	if m.BootConfig != nil {
  3612  		n += m.BootConfig.Size()
  3613  	}
  3614  	if m.WindowsOptions != nil {
  3615  		l = m.WindowsOptions.Size()
  3616  		n += 1 + l + sovVmservice(uint64(l))
  3617  	}
  3618  	if len(m.ExtraData) > 0 {
  3619  		for k, v := range m.ExtraData {
  3620  			_ = k
  3621  			_ = v
  3622  			mapEntrySize := 1 + len(k) + sovVmservice(uint64(len(k))) + 1 + len(v) + sovVmservice(uint64(len(v)))
  3623  			n += mapEntrySize + 1 + sovVmservice(uint64(mapEntrySize))
  3624  		}
  3625  	}
  3626  	if m.XXX_unrecognized != nil {
  3627  		n += len(m.XXX_unrecognized)
  3628  	}
  3629  	return n
  3630  }
  3631  
  3632  func (m *VMConfig_DirectBoot) Size() (n int) {
  3633  	if m == nil {
  3634  		return 0
  3635  	}
  3636  	var l int
  3637  	_ = l
  3638  	if m.DirectBoot != nil {
  3639  		l = m.DirectBoot.Size()
  3640  		n += 1 + l + sovVmservice(uint64(l))
  3641  	}
  3642  	return n
  3643  }
  3644  func (m *VMConfig_Uefi) Size() (n int) {
  3645  	if m == nil {
  3646  		return 0
  3647  	}
  3648  	var l int
  3649  	_ = l
  3650  	if m.Uefi != nil {
  3651  		l = m.Uefi.Size()
  3652  		n += 1 + l + sovVmservice(uint64(l))
  3653  	}
  3654  	return n
  3655  }
  3656  func (m *WindowsOptions) Size() (n int) {
  3657  	if m == nil {
  3658  		return 0
  3659  	}
  3660  	var l int
  3661  	_ = l
  3662  	if m.CpuGroupID != 0 {
  3663  		n += 1 + sovVmservice(uint64(m.CpuGroupID))
  3664  	}
  3665  	if m.XXX_unrecognized != nil {
  3666  		n += len(m.XXX_unrecognized)
  3667  	}
  3668  	return n
  3669  }
  3670  
  3671  func (m *SerialConfig) Size() (n int) {
  3672  	if m == nil {
  3673  		return 0
  3674  	}
  3675  	var l int
  3676  	_ = l
  3677  	if len(m.Ports) > 0 {
  3678  		for _, e := range m.Ports {
  3679  			l = e.Size()
  3680  			n += 1 + l + sovVmservice(uint64(l))
  3681  		}
  3682  	}
  3683  	if m.XXX_unrecognized != nil {
  3684  		n += len(m.XXX_unrecognized)
  3685  	}
  3686  	return n
  3687  }
  3688  
  3689  func (m *SerialConfig_Config) Size() (n int) {
  3690  	if m == nil {
  3691  		return 0
  3692  	}
  3693  	var l int
  3694  	_ = l
  3695  	if m.Port != 0 {
  3696  		n += 1 + sovVmservice(uint64(m.Port))
  3697  	}
  3698  	l = len(m.SocketPath)
  3699  	if l > 0 {
  3700  		n += 1 + l + sovVmservice(uint64(l))
  3701  	}
  3702  	if m.XXX_unrecognized != nil {
  3703  		n += len(m.XXX_unrecognized)
  3704  	}
  3705  	return n
  3706  }
  3707  
  3708  func (m *CreateVMRequest) Size() (n int) {
  3709  	if m == nil {
  3710  		return 0
  3711  	}
  3712  	var l int
  3713  	_ = l
  3714  	if m.Config != nil {
  3715  		l = m.Config.Size()
  3716  		n += 1 + l + sovVmservice(uint64(l))
  3717  	}
  3718  	l = len(m.LogID)
  3719  	if l > 0 {
  3720  		n += 1 + l + sovVmservice(uint64(l))
  3721  	}
  3722  	if m.XXX_unrecognized != nil {
  3723  		n += len(m.XXX_unrecognized)
  3724  	}
  3725  	return n
  3726  }
  3727  
  3728  func (m *InspectVMRequest) Size() (n int) {
  3729  	if m == nil {
  3730  		return 0
  3731  	}
  3732  	var l int
  3733  	_ = l
  3734  	l = len(m.Query)
  3735  	if l > 0 {
  3736  		n += 1 + l + sovVmservice(uint64(l))
  3737  	}
  3738  	if m.RecursionLimit != 0 {
  3739  		n += 1 + sovVmservice(uint64(m.RecursionLimit))
  3740  	}
  3741  	if m.XXX_unrecognized != nil {
  3742  		n += len(m.XXX_unrecognized)
  3743  	}
  3744  	return n
  3745  }
  3746  
  3747  func (m *InspectVMResponse) Size() (n int) {
  3748  	if m == nil {
  3749  		return 0
  3750  	}
  3751  	var l int
  3752  	_ = l
  3753  	if m.Result != nil {
  3754  		l = m.Result.Size()
  3755  		n += 1 + l + sovVmservice(uint64(l))
  3756  	}
  3757  	if m.XXX_unrecognized != nil {
  3758  		n += len(m.XXX_unrecognized)
  3759  	}
  3760  	return n
  3761  }
  3762  
  3763  func (m *MemoryStats) Size() (n int) {
  3764  	if m == nil {
  3765  		return 0
  3766  	}
  3767  	var l int
  3768  	_ = l
  3769  	if m.WorkingSetBytes != 0 {
  3770  		n += 1 + sovVmservice(uint64(m.WorkingSetBytes))
  3771  	}
  3772  	if m.AvailableMemory != 0 {
  3773  		n += 1 + sovVmservice(uint64(m.AvailableMemory))
  3774  	}
  3775  	if m.ReservedMemory != 0 {
  3776  		n += 1 + sovVmservice(uint64(m.ReservedMemory))
  3777  	}
  3778  	if m.AssignedMemory != 0 {
  3779  		n += 1 + sovVmservice(uint64(m.AssignedMemory))
  3780  	}
  3781  	if m.XXX_unrecognized != nil {
  3782  		n += len(m.XXX_unrecognized)
  3783  	}
  3784  	return n
  3785  }
  3786  
  3787  func (m *ProcessorStats) Size() (n int) {
  3788  	if m == nil {
  3789  		return 0
  3790  	}
  3791  	var l int
  3792  	_ = l
  3793  	if m.TotalRuntimeNs != 0 {
  3794  		n += 1 + sovVmservice(uint64(m.TotalRuntimeNs))
  3795  	}
  3796  	if m.XXX_unrecognized != nil {
  3797  		n += len(m.XXX_unrecognized)
  3798  	}
  3799  	return n
  3800  }
  3801  
  3802  func (m *PropertiesVMRequest) Size() (n int) {
  3803  	if m == nil {
  3804  		return 0
  3805  	}
  3806  	var l int
  3807  	_ = l
  3808  	if len(m.Types) > 0 {
  3809  		l = 0
  3810  		for _, e := range m.Types {
  3811  			l += sovVmservice(uint64(e))
  3812  		}
  3813  		n += 1 + sovVmservice(uint64(l)) + l
  3814  	}
  3815  	if m.XXX_unrecognized != nil {
  3816  		n += len(m.XXX_unrecognized)
  3817  	}
  3818  	return n
  3819  }
  3820  
  3821  func (m *PropertiesVMResponse) Size() (n int) {
  3822  	if m == nil {
  3823  		return 0
  3824  	}
  3825  	var l int
  3826  	_ = l
  3827  	if m.MemoryStats != nil {
  3828  		l = m.MemoryStats.Size()
  3829  		n += 1 + l + sovVmservice(uint64(l))
  3830  	}
  3831  	if m.ProcessorStats != nil {
  3832  		l = m.ProcessorStats.Size()
  3833  		n += 1 + l + sovVmservice(uint64(l))
  3834  	}
  3835  	if m.XXX_unrecognized != nil {
  3836  		n += len(m.XXX_unrecognized)
  3837  	}
  3838  	return n
  3839  }
  3840  
  3841  func (m *CapabilitiesVMResponse) Size() (n int) {
  3842  	if m == nil {
  3843  		return 0
  3844  	}
  3845  	var l int
  3846  	_ = l
  3847  	if len(m.SupportedResources) > 0 {
  3848  		for _, e := range m.SupportedResources {
  3849  			l = e.Size()
  3850  			n += 1 + l + sovVmservice(uint64(l))
  3851  		}
  3852  	}
  3853  	if len(m.SupportedGuestOs) > 0 {
  3854  		l = 0
  3855  		for _, e := range m.SupportedGuestOs {
  3856  			l += sovVmservice(uint64(e))
  3857  		}
  3858  		n += 1 + sovVmservice(uint64(l)) + l
  3859  	}
  3860  	if m.XXX_unrecognized != nil {
  3861  		n += len(m.XXX_unrecognized)
  3862  	}
  3863  	return n
  3864  }
  3865  
  3866  func (m *CapabilitiesVMResponse_SupportedResource) Size() (n int) {
  3867  	if m == nil {
  3868  		return 0
  3869  	}
  3870  	var l int
  3871  	_ = l
  3872  	if m.Add {
  3873  		n += 2
  3874  	}
  3875  	if m.Remove {
  3876  		n += 2
  3877  	}
  3878  	if m.Update {
  3879  		n += 2
  3880  	}
  3881  	if m.Resource != 0 {
  3882  		n += 1 + sovVmservice(uint64(m.Resource))
  3883  	}
  3884  	if m.XXX_unrecognized != nil {
  3885  		n += len(m.XXX_unrecognized)
  3886  	}
  3887  	return n
  3888  }
  3889  
  3890  func (m *HVSocketListen) Size() (n int) {
  3891  	if m == nil {
  3892  		return 0
  3893  	}
  3894  	var l int
  3895  	_ = l
  3896  	l = len(m.ServiceID)
  3897  	if l > 0 {
  3898  		n += 1 + l + sovVmservice(uint64(l))
  3899  	}
  3900  	l = len(m.ListenerPath)
  3901  	if l > 0 {
  3902  		n += 1 + l + sovVmservice(uint64(l))
  3903  	}
  3904  	if m.XXX_unrecognized != nil {
  3905  		n += len(m.XXX_unrecognized)
  3906  	}
  3907  	return n
  3908  }
  3909  
  3910  func (m *VSockListen) Size() (n int) {
  3911  	if m == nil {
  3912  		return 0
  3913  	}
  3914  	var l int
  3915  	_ = l
  3916  	if m.Port != 0 {
  3917  		n += 1 + sovVmservice(uint64(m.Port))
  3918  	}
  3919  	l = len(m.ListenerPath)
  3920  	if l > 0 {
  3921  		n += 1 + l + sovVmservice(uint64(l))
  3922  	}
  3923  	if m.XXX_unrecognized != nil {
  3924  		n += len(m.XXX_unrecognized)
  3925  	}
  3926  	return n
  3927  }
  3928  
  3929  func (m *VMSocketRequest) Size() (n int) {
  3930  	if m == nil {
  3931  		return 0
  3932  	}
  3933  	var l int
  3934  	_ = l
  3935  	if m.Type != 0 {
  3936  		n += 1 + sovVmservice(uint64(m.Type))
  3937  	}
  3938  	if m.Config != nil {
  3939  		n += m.Config.Size()
  3940  	}
  3941  	if m.XXX_unrecognized != nil {
  3942  		n += len(m.XXX_unrecognized)
  3943  	}
  3944  	return n
  3945  }
  3946  
  3947  func (m *VMSocketRequest_HvsocketList) Size() (n int) {
  3948  	if m == nil {
  3949  		return 0
  3950  	}
  3951  	var l int
  3952  	_ = l
  3953  	if m.HvsocketList != nil {
  3954  		l = m.HvsocketList.Size()
  3955  		n += 1 + l + sovVmservice(uint64(l))
  3956  	}
  3957  	return n
  3958  }
  3959  func (m *VMSocketRequest_VsockListen) Size() (n int) {
  3960  	if m == nil {
  3961  		return 0
  3962  	}
  3963  	var l int
  3964  	_ = l
  3965  	if m.VsockListen != nil {
  3966  		l = m.VsockListen.Size()
  3967  		n += 1 + l + sovVmservice(uint64(l))
  3968  	}
  3969  	return n
  3970  }
  3971  func (m *SCSIDisk) Size() (n int) {
  3972  	if m == nil {
  3973  		return 0
  3974  	}
  3975  	var l int
  3976  	_ = l
  3977  	if m.Controller != 0 {
  3978  		n += 1 + sovVmservice(uint64(m.Controller))
  3979  	}
  3980  	if m.Lun != 0 {
  3981  		n += 1 + sovVmservice(uint64(m.Lun))
  3982  	}
  3983  	l = len(m.HostPath)
  3984  	if l > 0 {
  3985  		n += 1 + l + sovVmservice(uint64(l))
  3986  	}
  3987  	if m.Type != 0 {
  3988  		n += 1 + sovVmservice(uint64(m.Type))
  3989  	}
  3990  	if m.ReadOnly {
  3991  		n += 2
  3992  	}
  3993  	if m.XXX_unrecognized != nil {
  3994  		n += len(m.XXX_unrecognized)
  3995  	}
  3996  	return n
  3997  }
  3998  
  3999  func (m *VPMEMDisk) Size() (n int) {
  4000  	if m == nil {
  4001  		return 0
  4002  	}
  4003  	var l int
  4004  	_ = l
  4005  	l = len(m.HostPath)
  4006  	if l > 0 {
  4007  		n += 1 + l + sovVmservice(uint64(l))
  4008  	}
  4009  	if m.Type != 0 {
  4010  		n += 1 + sovVmservice(uint64(m.Type))
  4011  	}
  4012  	if m.ReadOnly {
  4013  		n += 2
  4014  	}
  4015  	if m.XXX_unrecognized != nil {
  4016  		n += len(m.XXX_unrecognized)
  4017  	}
  4018  	return n
  4019  }
  4020  
  4021  func (m *NICConfig) Size() (n int) {
  4022  	if m == nil {
  4023  		return 0
  4024  	}
  4025  	var l int
  4026  	_ = l
  4027  	l = len(m.NicID)
  4028  	if l > 0 {
  4029  		n += 1 + l + sovVmservice(uint64(l))
  4030  	}
  4031  	l = len(m.PortID)
  4032  	if l > 0 {
  4033  		n += 1 + l + sovVmservice(uint64(l))
  4034  	}
  4035  	l = len(m.MacAddress)
  4036  	if l > 0 {
  4037  		n += 1 + l + sovVmservice(uint64(l))
  4038  	}
  4039  	l = len(m.SwitchID)
  4040  	if l > 0 {
  4041  		n += 1 + l + sovVmservice(uint64(l))
  4042  	}
  4043  	l = len(m.NicName)
  4044  	if l > 0 {
  4045  		n += 1 + l + sovVmservice(uint64(l))
  4046  	}
  4047  	if m.XXX_unrecognized != nil {
  4048  		n += len(m.XXX_unrecognized)
  4049  	}
  4050  	return n
  4051  }
  4052  
  4053  func (m *WindowsPCIDevice) Size() (n int) {
  4054  	if m == nil {
  4055  		return 0
  4056  	}
  4057  	var l int
  4058  	_ = l
  4059  	l = len(m.InstanceID)
  4060  	if l > 0 {
  4061  		n += 1 + l + sovVmservice(uint64(l))
  4062  	}
  4063  	if m.XXX_unrecognized != nil {
  4064  		n += len(m.XXX_unrecognized)
  4065  	}
  4066  	return n
  4067  }
  4068  
  4069  func (m *ModifyMemoryRequest) Size() (n int) {
  4070  	if m == nil {
  4071  		return 0
  4072  	}
  4073  	var l int
  4074  	_ = l
  4075  	if m.MemoryMb != 0 {
  4076  		n += 1 + sovVmservice(uint64(m.MemoryMb))
  4077  	}
  4078  	if m.XXX_unrecognized != nil {
  4079  		n += len(m.XXX_unrecognized)
  4080  	}
  4081  	return n
  4082  }
  4083  
  4084  func (m *ModifyProcessorRequest) Size() (n int) {
  4085  	if m == nil {
  4086  		return 0
  4087  	}
  4088  	var l int
  4089  	_ = l
  4090  	if m.ProcessorIndex != 0 {
  4091  		n += 1 + sovVmservice(uint64(m.ProcessorIndex))
  4092  	}
  4093  	if m.XXX_unrecognized != nil {
  4094  		n += len(m.XXX_unrecognized)
  4095  	}
  4096  	return n
  4097  }
  4098  
  4099  func (m *ModifyProcessorConfigRequest) Size() (n int) {
  4100  	if m == nil {
  4101  		return 0
  4102  	}
  4103  	var l int
  4104  	_ = l
  4105  	if m.ProcessorWeight != 0 {
  4106  		n += 1 + sovVmservice(uint64(m.ProcessorWeight))
  4107  	}
  4108  	if m.ProcessorLimit != 0 {
  4109  		n += 1 + sovVmservice(uint64(m.ProcessorLimit))
  4110  	}
  4111  	if m.XXX_unrecognized != nil {
  4112  		n += len(m.XXX_unrecognized)
  4113  	}
  4114  	return n
  4115  }
  4116  
  4117  func (m *ModifyResourceRequest) Size() (n int) {
  4118  	if m == nil {
  4119  		return 0
  4120  	}
  4121  	var l int
  4122  	_ = l
  4123  	if m.Type != 0 {
  4124  		n += 1 + sovVmservice(uint64(m.Type))
  4125  	}
  4126  	if m.Resource != nil {
  4127  		n += m.Resource.Size()
  4128  	}
  4129  	if m.XXX_unrecognized != nil {
  4130  		n += len(m.XXX_unrecognized)
  4131  	}
  4132  	return n
  4133  }
  4134  
  4135  func (m *ModifyResourceRequest_Processor) Size() (n int) {
  4136  	if m == nil {
  4137  		return 0
  4138  	}
  4139  	var l int
  4140  	_ = l
  4141  	if m.Processor != nil {
  4142  		l = m.Processor.Size()
  4143  		n += 1 + l + sovVmservice(uint64(l))
  4144  	}
  4145  	return n
  4146  }
  4147  func (m *ModifyResourceRequest_ProcessorConfig) Size() (n int) {
  4148  	if m == nil {
  4149  		return 0
  4150  	}
  4151  	var l int
  4152  	_ = l
  4153  	if m.ProcessorConfig != nil {
  4154  		l = m.ProcessorConfig.Size()
  4155  		n += 1 + l + sovVmservice(uint64(l))
  4156  	}
  4157  	return n
  4158  }
  4159  func (m *ModifyResourceRequest_Memory) Size() (n int) {
  4160  	if m == nil {
  4161  		return 0
  4162  	}
  4163  	var l int
  4164  	_ = l
  4165  	if m.Memory != nil {
  4166  		l = m.Memory.Size()
  4167  		n += 1 + l + sovVmservice(uint64(l))
  4168  	}
  4169  	return n
  4170  }
  4171  func (m *ModifyResourceRequest_ScsiDisk) Size() (n int) {
  4172  	if m == nil {
  4173  		return 0
  4174  	}
  4175  	var l int
  4176  	_ = l
  4177  	if m.ScsiDisk != nil {
  4178  		l = m.ScsiDisk.Size()
  4179  		n += 1 + l + sovVmservice(uint64(l))
  4180  	}
  4181  	return n
  4182  }
  4183  func (m *ModifyResourceRequest_VpmemDisk) Size() (n int) {
  4184  	if m == nil {
  4185  		return 0
  4186  	}
  4187  	var l int
  4188  	_ = l
  4189  	if m.VpmemDisk != nil {
  4190  		l = m.VpmemDisk.Size()
  4191  		n += 1 + l + sovVmservice(uint64(l))
  4192  	}
  4193  	return n
  4194  }
  4195  func (m *ModifyResourceRequest_NicConfig) Size() (n int) {
  4196  	if m == nil {
  4197  		return 0
  4198  	}
  4199  	var l int
  4200  	_ = l
  4201  	if m.NicConfig != nil {
  4202  		l = m.NicConfig.Size()
  4203  		n += 1 + l + sovVmservice(uint64(l))
  4204  	}
  4205  	return n
  4206  }
  4207  func (m *ModifyResourceRequest_WindowsDevice) Size() (n int) {
  4208  	if m == nil {
  4209  		return 0
  4210  	}
  4211  	var l int
  4212  	_ = l
  4213  	if m.WindowsDevice != nil {
  4214  		l = m.WindowsDevice.Size()
  4215  		n += 1 + l + sovVmservice(uint64(l))
  4216  	}
  4217  	return n
  4218  }
  4219  
  4220  func sovVmservice(x uint64) (n int) {
  4221  	return (math_bits.Len64(x|1) + 6) / 7
  4222  }
  4223  func sozVmservice(x uint64) (n int) {
  4224  	return sovVmservice(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  4225  }
  4226  func (this *DirectBoot) String() string {
  4227  	if this == nil {
  4228  		return "nil"
  4229  	}
  4230  	s := strings.Join([]string{`&DirectBoot{`,
  4231  		`KernelPath:` + fmt.Sprintf("%v", this.KernelPath) + `,`,
  4232  		`InitrdPath:` + fmt.Sprintf("%v", this.InitrdPath) + `,`,
  4233  		`KernelCmdline:` + fmt.Sprintf("%v", this.KernelCmdline) + `,`,
  4234  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4235  		`}`,
  4236  	}, "")
  4237  	return s
  4238  }
  4239  func (this *UEFI) String() string {
  4240  	if this == nil {
  4241  		return "nil"
  4242  	}
  4243  	s := strings.Join([]string{`&UEFI{`,
  4244  		`FirmwarePath:` + fmt.Sprintf("%v", this.FirmwarePath) + `,`,
  4245  		`DevicePath:` + fmt.Sprintf("%v", this.DevicePath) + `,`,
  4246  		`OptionalData:` + fmt.Sprintf("%v", this.OptionalData) + `,`,
  4247  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4248  		`}`,
  4249  	}, "")
  4250  	return s
  4251  }
  4252  func (this *MemoryConfig) String() string {
  4253  	if this == nil {
  4254  		return "nil"
  4255  	}
  4256  	s := strings.Join([]string{`&MemoryConfig{`,
  4257  		`MemoryMb:` + fmt.Sprintf("%v", this.MemoryMb) + `,`,
  4258  		`AllowOvercommit:` + fmt.Sprintf("%v", this.AllowOvercommit) + `,`,
  4259  		`DeferredCommit:` + fmt.Sprintf("%v", this.DeferredCommit) + `,`,
  4260  		`HotHint:` + fmt.Sprintf("%v", this.HotHint) + `,`,
  4261  		`ColdHint:` + fmt.Sprintf("%v", this.ColdHint) + `,`,
  4262  		`ColdDiscardHint:` + fmt.Sprintf("%v", this.ColdDiscardHint) + `,`,
  4263  		`LowMmioGapInMb:` + fmt.Sprintf("%v", this.LowMmioGapInMb) + `,`,
  4264  		`HighMmioBaseInMb:` + fmt.Sprintf("%v", this.HighMmioBaseInMb) + `,`,
  4265  		`HighMmioGapInMb:` + fmt.Sprintf("%v", this.HighMmioGapInMb) + `,`,
  4266  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4267  		`}`,
  4268  	}, "")
  4269  	return s
  4270  }
  4271  func (this *ProcessorConfig) String() string {
  4272  	if this == nil {
  4273  		return "nil"
  4274  	}
  4275  	s := strings.Join([]string{`&ProcessorConfig{`,
  4276  		`ProcessorCount:` + fmt.Sprintf("%v", this.ProcessorCount) + `,`,
  4277  		`ProcessorWeight:` + fmt.Sprintf("%v", this.ProcessorWeight) + `,`,
  4278  		`ProcessorLimit:` + fmt.Sprintf("%v", this.ProcessorLimit) + `,`,
  4279  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4280  		`}`,
  4281  	}, "")
  4282  	return s
  4283  }
  4284  func (this *DevicesConfig) String() string {
  4285  	if this == nil {
  4286  		return "nil"
  4287  	}
  4288  	repeatedStringForScsiDisks := "[]*SCSIDisk{"
  4289  	for _, f := range this.ScsiDisks {
  4290  		repeatedStringForScsiDisks += strings.Replace(f.String(), "SCSIDisk", "SCSIDisk", 1) + ","
  4291  	}
  4292  	repeatedStringForScsiDisks += "}"
  4293  	repeatedStringForVpmemDisks := "[]*VPMEMDisk{"
  4294  	for _, f := range this.VpmemDisks {
  4295  		repeatedStringForVpmemDisks += strings.Replace(f.String(), "VPMEMDisk", "VPMEMDisk", 1) + ","
  4296  	}
  4297  	repeatedStringForVpmemDisks += "}"
  4298  	repeatedStringForNicConfig := "[]*NICConfig{"
  4299  	for _, f := range this.NicConfig {
  4300  		repeatedStringForNicConfig += strings.Replace(f.String(), "NICConfig", "NICConfig", 1) + ","
  4301  	}
  4302  	repeatedStringForNicConfig += "}"
  4303  	repeatedStringForWindowsDevice := "[]*WindowsPCIDevice{"
  4304  	for _, f := range this.WindowsDevice {
  4305  		repeatedStringForWindowsDevice += strings.Replace(f.String(), "WindowsPCIDevice", "WindowsPCIDevice", 1) + ","
  4306  	}
  4307  	repeatedStringForWindowsDevice += "}"
  4308  	s := strings.Join([]string{`&DevicesConfig{`,
  4309  		`ScsiDisks:` + repeatedStringForScsiDisks + `,`,
  4310  		`VpmemDisks:` + repeatedStringForVpmemDisks + `,`,
  4311  		`NicConfig:` + repeatedStringForNicConfig + `,`,
  4312  		`WindowsDevice:` + repeatedStringForWindowsDevice + `,`,
  4313  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4314  		`}`,
  4315  	}, "")
  4316  	return s
  4317  }
  4318  func (this *VMConfig) String() string {
  4319  	if this == nil {
  4320  		return "nil"
  4321  	}
  4322  	keysForExtraData := make([]string, 0, len(this.ExtraData))
  4323  	for k, _ := range this.ExtraData {
  4324  		keysForExtraData = append(keysForExtraData, k)
  4325  	}
  4326  	github_com_gogo_protobuf_sortkeys.Strings(keysForExtraData)
  4327  	mapStringForExtraData := "map[string]string{"
  4328  	for _, k := range keysForExtraData {
  4329  		mapStringForExtraData += fmt.Sprintf("%v: %v,", k, this.ExtraData[k])
  4330  	}
  4331  	mapStringForExtraData += "}"
  4332  	s := strings.Join([]string{`&VMConfig{`,
  4333  		`MemoryConfig:` + strings.Replace(this.MemoryConfig.String(), "MemoryConfig", "MemoryConfig", 1) + `,`,
  4334  		`ProcessorConfig:` + strings.Replace(this.ProcessorConfig.String(), "ProcessorConfig", "ProcessorConfig", 1) + `,`,
  4335  		`DevicesConfig:` + strings.Replace(this.DevicesConfig.String(), "DevicesConfig", "DevicesConfig", 1) + `,`,
  4336  		`SerialConfig:` + strings.Replace(this.SerialConfig.String(), "SerialConfig", "SerialConfig", 1) + `,`,
  4337  		`BootConfig:` + fmt.Sprintf("%v", this.BootConfig) + `,`,
  4338  		`WindowsOptions:` + strings.Replace(this.WindowsOptions.String(), "WindowsOptions", "WindowsOptions", 1) + `,`,
  4339  		`ExtraData:` + mapStringForExtraData + `,`,
  4340  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4341  		`}`,
  4342  	}, "")
  4343  	return s
  4344  }
  4345  func (this *VMConfig_DirectBoot) String() string {
  4346  	if this == nil {
  4347  		return "nil"
  4348  	}
  4349  	s := strings.Join([]string{`&VMConfig_DirectBoot{`,
  4350  		`DirectBoot:` + strings.Replace(fmt.Sprintf("%v", this.DirectBoot), "DirectBoot", "DirectBoot", 1) + `,`,
  4351  		`}`,
  4352  	}, "")
  4353  	return s
  4354  }
  4355  func (this *VMConfig_Uefi) String() string {
  4356  	if this == nil {
  4357  		return "nil"
  4358  	}
  4359  	s := strings.Join([]string{`&VMConfig_Uefi{`,
  4360  		`Uefi:` + strings.Replace(fmt.Sprintf("%v", this.Uefi), "UEFI", "UEFI", 1) + `,`,
  4361  		`}`,
  4362  	}, "")
  4363  	return s
  4364  }
  4365  func (this *WindowsOptions) String() string {
  4366  	if this == nil {
  4367  		return "nil"
  4368  	}
  4369  	s := strings.Join([]string{`&WindowsOptions{`,
  4370  		`CpuGroupID:` + fmt.Sprintf("%v", this.CpuGroupID) + `,`,
  4371  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4372  		`}`,
  4373  	}, "")
  4374  	return s
  4375  }
  4376  func (this *SerialConfig) String() string {
  4377  	if this == nil {
  4378  		return "nil"
  4379  	}
  4380  	repeatedStringForPorts := "[]*SerialConfig_Config{"
  4381  	for _, f := range this.Ports {
  4382  		repeatedStringForPorts += strings.Replace(fmt.Sprintf("%v", f), "SerialConfig_Config", "SerialConfig_Config", 1) + ","
  4383  	}
  4384  	repeatedStringForPorts += "}"
  4385  	s := strings.Join([]string{`&SerialConfig{`,
  4386  		`Ports:` + repeatedStringForPorts + `,`,
  4387  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4388  		`}`,
  4389  	}, "")
  4390  	return s
  4391  }
  4392  func (this *SerialConfig_Config) String() string {
  4393  	if this == nil {
  4394  		return "nil"
  4395  	}
  4396  	s := strings.Join([]string{`&SerialConfig_Config{`,
  4397  		`Port:` + fmt.Sprintf("%v", this.Port) + `,`,
  4398  		`SocketPath:` + fmt.Sprintf("%v", this.SocketPath) + `,`,
  4399  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4400  		`}`,
  4401  	}, "")
  4402  	return s
  4403  }
  4404  func (this *CreateVMRequest) String() string {
  4405  	if this == nil {
  4406  		return "nil"
  4407  	}
  4408  	s := strings.Join([]string{`&CreateVMRequest{`,
  4409  		`Config:` + strings.Replace(this.Config.String(), "VMConfig", "VMConfig", 1) + `,`,
  4410  		`LogID:` + fmt.Sprintf("%v", this.LogID) + `,`,
  4411  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4412  		`}`,
  4413  	}, "")
  4414  	return s
  4415  }
  4416  func (this *InspectVMRequest) String() string {
  4417  	if this == nil {
  4418  		return "nil"
  4419  	}
  4420  	s := strings.Join([]string{`&InspectVMRequest{`,
  4421  		`Query:` + fmt.Sprintf("%v", this.Query) + `,`,
  4422  		`RecursionLimit:` + fmt.Sprintf("%v", this.RecursionLimit) + `,`,
  4423  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4424  		`}`,
  4425  	}, "")
  4426  	return s
  4427  }
  4428  func (this *InspectVMResponse) String() string {
  4429  	if this == nil {
  4430  		return "nil"
  4431  	}
  4432  	s := strings.Join([]string{`&InspectVMResponse{`,
  4433  		`Result:` + strings.Replace(fmt.Sprintf("%v", this.Result), "Value", "types.Value", 1) + `,`,
  4434  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4435  		`}`,
  4436  	}, "")
  4437  	return s
  4438  }
  4439  func (this *MemoryStats) String() string {
  4440  	if this == nil {
  4441  		return "nil"
  4442  	}
  4443  	s := strings.Join([]string{`&MemoryStats{`,
  4444  		`WorkingSetBytes:` + fmt.Sprintf("%v", this.WorkingSetBytes) + `,`,
  4445  		`AvailableMemory:` + fmt.Sprintf("%v", this.AvailableMemory) + `,`,
  4446  		`ReservedMemory:` + fmt.Sprintf("%v", this.ReservedMemory) + `,`,
  4447  		`AssignedMemory:` + fmt.Sprintf("%v", this.AssignedMemory) + `,`,
  4448  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4449  		`}`,
  4450  	}, "")
  4451  	return s
  4452  }
  4453  func (this *ProcessorStats) String() string {
  4454  	if this == nil {
  4455  		return "nil"
  4456  	}
  4457  	s := strings.Join([]string{`&ProcessorStats{`,
  4458  		`TotalRuntimeNs:` + fmt.Sprintf("%v", this.TotalRuntimeNs) + `,`,
  4459  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4460  		`}`,
  4461  	}, "")
  4462  	return s
  4463  }
  4464  func (this *PropertiesVMRequest) String() string {
  4465  	if this == nil {
  4466  		return "nil"
  4467  	}
  4468  	s := strings.Join([]string{`&PropertiesVMRequest{`,
  4469  		`Types:` + fmt.Sprintf("%v", this.Types) + `,`,
  4470  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4471  		`}`,
  4472  	}, "")
  4473  	return s
  4474  }
  4475  func (this *PropertiesVMResponse) String() string {
  4476  	if this == nil {
  4477  		return "nil"
  4478  	}
  4479  	s := strings.Join([]string{`&PropertiesVMResponse{`,
  4480  		`MemoryStats:` + strings.Replace(this.MemoryStats.String(), "MemoryStats", "MemoryStats", 1) + `,`,
  4481  		`ProcessorStats:` + strings.Replace(this.ProcessorStats.String(), "ProcessorStats", "ProcessorStats", 1) + `,`,
  4482  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4483  		`}`,
  4484  	}, "")
  4485  	return s
  4486  }
  4487  func (this *CapabilitiesVMResponse) String() string {
  4488  	if this == nil {
  4489  		return "nil"
  4490  	}
  4491  	repeatedStringForSupportedResources := "[]*CapabilitiesVMResponse_SupportedResource{"
  4492  	for _, f := range this.SupportedResources {
  4493  		repeatedStringForSupportedResources += strings.Replace(fmt.Sprintf("%v", f), "CapabilitiesVMResponse_SupportedResource", "CapabilitiesVMResponse_SupportedResource", 1) + ","
  4494  	}
  4495  	repeatedStringForSupportedResources += "}"
  4496  	s := strings.Join([]string{`&CapabilitiesVMResponse{`,
  4497  		`SupportedResources:` + repeatedStringForSupportedResources + `,`,
  4498  		`SupportedGuestOs:` + fmt.Sprintf("%v", this.SupportedGuestOs) + `,`,
  4499  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4500  		`}`,
  4501  	}, "")
  4502  	return s
  4503  }
  4504  func (this *CapabilitiesVMResponse_SupportedResource) String() string {
  4505  	if this == nil {
  4506  		return "nil"
  4507  	}
  4508  	s := strings.Join([]string{`&CapabilitiesVMResponse_SupportedResource{`,
  4509  		`Add:` + fmt.Sprintf("%v", this.Add) + `,`,
  4510  		`Remove:` + fmt.Sprintf("%v", this.Remove) + `,`,
  4511  		`Update:` + fmt.Sprintf("%v", this.Update) + `,`,
  4512  		`Resource:` + fmt.Sprintf("%v", this.Resource) + `,`,
  4513  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4514  		`}`,
  4515  	}, "")
  4516  	return s
  4517  }
  4518  func (this *HVSocketListen) String() string {
  4519  	if this == nil {
  4520  		return "nil"
  4521  	}
  4522  	s := strings.Join([]string{`&HVSocketListen{`,
  4523  		`ServiceID:` + fmt.Sprintf("%v", this.ServiceID) + `,`,
  4524  		`ListenerPath:` + fmt.Sprintf("%v", this.ListenerPath) + `,`,
  4525  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4526  		`}`,
  4527  	}, "")
  4528  	return s
  4529  }
  4530  func (this *VSockListen) String() string {
  4531  	if this == nil {
  4532  		return "nil"
  4533  	}
  4534  	s := strings.Join([]string{`&VSockListen{`,
  4535  		`Port:` + fmt.Sprintf("%v", this.Port) + `,`,
  4536  		`ListenerPath:` + fmt.Sprintf("%v", this.ListenerPath) + `,`,
  4537  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4538  		`}`,
  4539  	}, "")
  4540  	return s
  4541  }
  4542  func (this *VMSocketRequest) String() string {
  4543  	if this == nil {
  4544  		return "nil"
  4545  	}
  4546  	s := strings.Join([]string{`&VMSocketRequest{`,
  4547  		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
  4548  		`Config:` + fmt.Sprintf("%v", this.Config) + `,`,
  4549  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4550  		`}`,
  4551  	}, "")
  4552  	return s
  4553  }
  4554  func (this *VMSocketRequest_HvsocketList) String() string {
  4555  	if this == nil {
  4556  		return "nil"
  4557  	}
  4558  	s := strings.Join([]string{`&VMSocketRequest_HvsocketList{`,
  4559  		`HvsocketList:` + strings.Replace(fmt.Sprintf("%v", this.HvsocketList), "HVSocketListen", "HVSocketListen", 1) + `,`,
  4560  		`}`,
  4561  	}, "")
  4562  	return s
  4563  }
  4564  func (this *VMSocketRequest_VsockListen) String() string {
  4565  	if this == nil {
  4566  		return "nil"
  4567  	}
  4568  	s := strings.Join([]string{`&VMSocketRequest_VsockListen{`,
  4569  		`VsockListen:` + strings.Replace(fmt.Sprintf("%v", this.VsockListen), "VSockListen", "VSockListen", 1) + `,`,
  4570  		`}`,
  4571  	}, "")
  4572  	return s
  4573  }
  4574  func (this *SCSIDisk) String() string {
  4575  	if this == nil {
  4576  		return "nil"
  4577  	}
  4578  	s := strings.Join([]string{`&SCSIDisk{`,
  4579  		`Controller:` + fmt.Sprintf("%v", this.Controller) + `,`,
  4580  		`Lun:` + fmt.Sprintf("%v", this.Lun) + `,`,
  4581  		`HostPath:` + fmt.Sprintf("%v", this.HostPath) + `,`,
  4582  		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
  4583  		`ReadOnly:` + fmt.Sprintf("%v", this.ReadOnly) + `,`,
  4584  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4585  		`}`,
  4586  	}, "")
  4587  	return s
  4588  }
  4589  func (this *VPMEMDisk) String() string {
  4590  	if this == nil {
  4591  		return "nil"
  4592  	}
  4593  	s := strings.Join([]string{`&VPMEMDisk{`,
  4594  		`HostPath:` + fmt.Sprintf("%v", this.HostPath) + `,`,
  4595  		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
  4596  		`ReadOnly:` + fmt.Sprintf("%v", this.ReadOnly) + `,`,
  4597  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4598  		`}`,
  4599  	}, "")
  4600  	return s
  4601  }
  4602  func (this *NICConfig) String() string {
  4603  	if this == nil {
  4604  		return "nil"
  4605  	}
  4606  	s := strings.Join([]string{`&NICConfig{`,
  4607  		`NicID:` + fmt.Sprintf("%v", this.NicID) + `,`,
  4608  		`PortID:` + fmt.Sprintf("%v", this.PortID) + `,`,
  4609  		`MacAddress:` + fmt.Sprintf("%v", this.MacAddress) + `,`,
  4610  		`SwitchID:` + fmt.Sprintf("%v", this.SwitchID) + `,`,
  4611  		`NicName:` + fmt.Sprintf("%v", this.NicName) + `,`,
  4612  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4613  		`}`,
  4614  	}, "")
  4615  	return s
  4616  }
  4617  func (this *WindowsPCIDevice) String() string {
  4618  	if this == nil {
  4619  		return "nil"
  4620  	}
  4621  	s := strings.Join([]string{`&WindowsPCIDevice{`,
  4622  		`InstanceID:` + fmt.Sprintf("%v", this.InstanceID) + `,`,
  4623  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4624  		`}`,
  4625  	}, "")
  4626  	return s
  4627  }
  4628  func (this *ModifyMemoryRequest) String() string {
  4629  	if this == nil {
  4630  		return "nil"
  4631  	}
  4632  	s := strings.Join([]string{`&ModifyMemoryRequest{`,
  4633  		`MemoryMb:` + fmt.Sprintf("%v", this.MemoryMb) + `,`,
  4634  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4635  		`}`,
  4636  	}, "")
  4637  	return s
  4638  }
  4639  func (this *ModifyProcessorRequest) String() string {
  4640  	if this == nil {
  4641  		return "nil"
  4642  	}
  4643  	s := strings.Join([]string{`&ModifyProcessorRequest{`,
  4644  		`ProcessorIndex:` + fmt.Sprintf("%v", this.ProcessorIndex) + `,`,
  4645  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4646  		`}`,
  4647  	}, "")
  4648  	return s
  4649  }
  4650  func (this *ModifyProcessorConfigRequest) String() string {
  4651  	if this == nil {
  4652  		return "nil"
  4653  	}
  4654  	s := strings.Join([]string{`&ModifyProcessorConfigRequest{`,
  4655  		`ProcessorWeight:` + fmt.Sprintf("%v", this.ProcessorWeight) + `,`,
  4656  		`ProcessorLimit:` + fmt.Sprintf("%v", this.ProcessorLimit) + `,`,
  4657  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4658  		`}`,
  4659  	}, "")
  4660  	return s
  4661  }
  4662  func (this *ModifyResourceRequest) String() string {
  4663  	if this == nil {
  4664  		return "nil"
  4665  	}
  4666  	s := strings.Join([]string{`&ModifyResourceRequest{`,
  4667  		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
  4668  		`Resource:` + fmt.Sprintf("%v", this.Resource) + `,`,
  4669  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  4670  		`}`,
  4671  	}, "")
  4672  	return s
  4673  }
  4674  func (this *ModifyResourceRequest_Processor) String() string {
  4675  	if this == nil {
  4676  		return "nil"
  4677  	}
  4678  	s := strings.Join([]string{`&ModifyResourceRequest_Processor{`,
  4679  		`Processor:` + strings.Replace(fmt.Sprintf("%v", this.Processor), "ModifyProcessorRequest", "ModifyProcessorRequest", 1) + `,`,
  4680  		`}`,
  4681  	}, "")
  4682  	return s
  4683  }
  4684  func (this *ModifyResourceRequest_ProcessorConfig) String() string {
  4685  	if this == nil {
  4686  		return "nil"
  4687  	}
  4688  	s := strings.Join([]string{`&ModifyResourceRequest_ProcessorConfig{`,
  4689  		`ProcessorConfig:` + strings.Replace(fmt.Sprintf("%v", this.ProcessorConfig), "ModifyProcessorConfigRequest", "ModifyProcessorConfigRequest", 1) + `,`,
  4690  		`}`,
  4691  	}, "")
  4692  	return s
  4693  }
  4694  func (this *ModifyResourceRequest_Memory) String() string {
  4695  	if this == nil {
  4696  		return "nil"
  4697  	}
  4698  	s := strings.Join([]string{`&ModifyResourceRequest_Memory{`,
  4699  		`Memory:` + strings.Replace(fmt.Sprintf("%v", this.Memory), "ModifyMemoryRequest", "ModifyMemoryRequest", 1) + `,`,
  4700  		`}`,
  4701  	}, "")
  4702  	return s
  4703  }
  4704  func (this *ModifyResourceRequest_ScsiDisk) String() string {
  4705  	if this == nil {
  4706  		return "nil"
  4707  	}
  4708  	s := strings.Join([]string{`&ModifyResourceRequest_ScsiDisk{`,
  4709  		`ScsiDisk:` + strings.Replace(fmt.Sprintf("%v", this.ScsiDisk), "SCSIDisk", "SCSIDisk", 1) + `,`,
  4710  		`}`,
  4711  	}, "")
  4712  	return s
  4713  }
  4714  func (this *ModifyResourceRequest_VpmemDisk) String() string {
  4715  	if this == nil {
  4716  		return "nil"
  4717  	}
  4718  	s := strings.Join([]string{`&ModifyResourceRequest_VpmemDisk{`,
  4719  		`VpmemDisk:` + strings.Replace(fmt.Sprintf("%v", this.VpmemDisk), "VPMEMDisk", "VPMEMDisk", 1) + `,`,
  4720  		`}`,
  4721  	}, "")
  4722  	return s
  4723  }
  4724  func (this *ModifyResourceRequest_NicConfig) String() string {
  4725  	if this == nil {
  4726  		return "nil"
  4727  	}
  4728  	s := strings.Join([]string{`&ModifyResourceRequest_NicConfig{`,
  4729  		`NicConfig:` + strings.Replace(fmt.Sprintf("%v", this.NicConfig), "NICConfig", "NICConfig", 1) + `,`,
  4730  		`}`,
  4731  	}, "")
  4732  	return s
  4733  }
  4734  func (this *ModifyResourceRequest_WindowsDevice) String() string {
  4735  	if this == nil {
  4736  		return "nil"
  4737  	}
  4738  	s := strings.Join([]string{`&ModifyResourceRequest_WindowsDevice{`,
  4739  		`WindowsDevice:` + strings.Replace(fmt.Sprintf("%v", this.WindowsDevice), "WindowsPCIDevice", "WindowsPCIDevice", 1) + `,`,
  4740  		`}`,
  4741  	}, "")
  4742  	return s
  4743  }
  4744  func valueToStringVmservice(v interface{}) string {
  4745  	rv := reflect.ValueOf(v)
  4746  	if rv.IsNil() {
  4747  		return "nil"
  4748  	}
  4749  	pv := reflect.Indirect(rv).Interface()
  4750  	return fmt.Sprintf("*%v", pv)
  4751  }
  4752  
  4753  type VMService interface {
  4754  	CreateVM(ctx context.Context, req *CreateVMRequest) (*types.Empty, error)
  4755  	TeardownVM(ctx context.Context, req *types.Empty) (*types.Empty, error)
  4756  	PauseVM(ctx context.Context, req *types.Empty) (*types.Empty, error)
  4757  	ResumeVM(ctx context.Context, req *types.Empty) (*types.Empty, error)
  4758  	WaitVM(ctx context.Context, req *types.Empty) (*types.Empty, error)
  4759  	InspectVM(ctx context.Context, req *InspectVMRequest) (*InspectVMResponse, error)
  4760  	CapabilitiesVM(ctx context.Context, req *types.Empty) (*CapabilitiesVMResponse, error)
  4761  	PropertiesVM(ctx context.Context, req *PropertiesVMRequest) (*PropertiesVMResponse, error)
  4762  	ModifyResource(ctx context.Context, req *ModifyResourceRequest) (*types.Empty, error)
  4763  	VMSocket(ctx context.Context, req *VMSocketRequest) (*types.Empty, error)
  4764  	Quit(ctx context.Context, req *types.Empty) (*types.Empty, error)
  4765  }
  4766  
  4767  func RegisterVMService(srv *github_com_containerd_ttrpc.Server, svc VMService) {
  4768  	srv.Register("vmservice.VM", map[string]github_com_containerd_ttrpc.Method{
  4769  		"CreateVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
  4770  			var req CreateVMRequest
  4771  			if err := unmarshal(&req); err != nil {
  4772  				return nil, err
  4773  			}
  4774  			return svc.CreateVM(ctx, &req)
  4775  		},
  4776  		"TeardownVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
  4777  			var req types.Empty
  4778  			if err := unmarshal(&req); err != nil {
  4779  				return nil, err
  4780  			}
  4781  			return svc.TeardownVM(ctx, &req)
  4782  		},
  4783  		"PauseVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
  4784  			var req types.Empty
  4785  			if err := unmarshal(&req); err != nil {
  4786  				return nil, err
  4787  			}
  4788  			return svc.PauseVM(ctx, &req)
  4789  		},
  4790  		"ResumeVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
  4791  			var req types.Empty
  4792  			if err := unmarshal(&req); err != nil {
  4793  				return nil, err
  4794  			}
  4795  			return svc.ResumeVM(ctx, &req)
  4796  		},
  4797  		"WaitVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
  4798  			var req types.Empty
  4799  			if err := unmarshal(&req); err != nil {
  4800  				return nil, err
  4801  			}
  4802  			return svc.WaitVM(ctx, &req)
  4803  		},
  4804  		"InspectVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
  4805  			var req InspectVMRequest
  4806  			if err := unmarshal(&req); err != nil {
  4807  				return nil, err
  4808  			}
  4809  			return svc.InspectVM(ctx, &req)
  4810  		},
  4811  		"CapabilitiesVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
  4812  			var req types.Empty
  4813  			if err := unmarshal(&req); err != nil {
  4814  				return nil, err
  4815  			}
  4816  			return svc.CapabilitiesVM(ctx, &req)
  4817  		},
  4818  		"PropertiesVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
  4819  			var req PropertiesVMRequest
  4820  			if err := unmarshal(&req); err != nil {
  4821  				return nil, err
  4822  			}
  4823  			return svc.PropertiesVM(ctx, &req)
  4824  		},
  4825  		"ModifyResource": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
  4826  			var req ModifyResourceRequest
  4827  			if err := unmarshal(&req); err != nil {
  4828  				return nil, err
  4829  			}
  4830  			return svc.ModifyResource(ctx, &req)
  4831  		},
  4832  		"VMSocket": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
  4833  			var req VMSocketRequest
  4834  			if err := unmarshal(&req); err != nil {
  4835  				return nil, err
  4836  			}
  4837  			return svc.VMSocket(ctx, &req)
  4838  		},
  4839  		"Quit": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
  4840  			var req types.Empty
  4841  			if err := unmarshal(&req); err != nil {
  4842  				return nil, err
  4843  			}
  4844  			return svc.Quit(ctx, &req)
  4845  		},
  4846  	})
  4847  }
  4848  
  4849  type vMClient struct {
  4850  	client *github_com_containerd_ttrpc.Client
  4851  }
  4852  
  4853  func NewVMClient(client *github_com_containerd_ttrpc.Client) VMService {
  4854  	return &vMClient{
  4855  		client: client,
  4856  	}
  4857  }
  4858  
  4859  func (c *vMClient) CreateVM(ctx context.Context, req *CreateVMRequest) (*types.Empty, error) {
  4860  	var resp types.Empty
  4861  	if err := c.client.Call(ctx, "vmservice.VM", "CreateVM", req, &resp); err != nil {
  4862  		return nil, err
  4863  	}
  4864  	return &resp, nil
  4865  }
  4866  
  4867  func (c *vMClient) TeardownVM(ctx context.Context, req *types.Empty) (*types.Empty, error) {
  4868  	var resp types.Empty
  4869  	if err := c.client.Call(ctx, "vmservice.VM", "TeardownVM", req, &resp); err != nil {
  4870  		return nil, err
  4871  	}
  4872  	return &resp, nil
  4873  }
  4874  
  4875  func (c *vMClient) PauseVM(ctx context.Context, req *types.Empty) (*types.Empty, error) {
  4876  	var resp types.Empty
  4877  	if err := c.client.Call(ctx, "vmservice.VM", "PauseVM", req, &resp); err != nil {
  4878  		return nil, err
  4879  	}
  4880  	return &resp, nil
  4881  }
  4882  
  4883  func (c *vMClient) ResumeVM(ctx context.Context, req *types.Empty) (*types.Empty, error) {
  4884  	var resp types.Empty
  4885  	if err := c.client.Call(ctx, "vmservice.VM", "ResumeVM", req, &resp); err != nil {
  4886  		return nil, err
  4887  	}
  4888  	return &resp, nil
  4889  }
  4890  
  4891  func (c *vMClient) WaitVM(ctx context.Context, req *types.Empty) (*types.Empty, error) {
  4892  	var resp types.Empty
  4893  	if err := c.client.Call(ctx, "vmservice.VM", "WaitVM", req, &resp); err != nil {
  4894  		return nil, err
  4895  	}
  4896  	return &resp, nil
  4897  }
  4898  
  4899  func (c *vMClient) InspectVM(ctx context.Context, req *InspectVMRequest) (*InspectVMResponse, error) {
  4900  	var resp InspectVMResponse
  4901  	if err := c.client.Call(ctx, "vmservice.VM", "InspectVM", req, &resp); err != nil {
  4902  		return nil, err
  4903  	}
  4904  	return &resp, nil
  4905  }
  4906  
  4907  func (c *vMClient) CapabilitiesVM(ctx context.Context, req *types.Empty) (*CapabilitiesVMResponse, error) {
  4908  	var resp CapabilitiesVMResponse
  4909  	if err := c.client.Call(ctx, "vmservice.VM", "CapabilitiesVM", req, &resp); err != nil {
  4910  		return nil, err
  4911  	}
  4912  	return &resp, nil
  4913  }
  4914  
  4915  func (c *vMClient) PropertiesVM(ctx context.Context, req *PropertiesVMRequest) (*PropertiesVMResponse, error) {
  4916  	var resp PropertiesVMResponse
  4917  	if err := c.client.Call(ctx, "vmservice.VM", "PropertiesVM", req, &resp); err != nil {
  4918  		return nil, err
  4919  	}
  4920  	return &resp, nil
  4921  }
  4922  
  4923  func (c *vMClient) ModifyResource(ctx context.Context, req *ModifyResourceRequest) (*types.Empty, error) {
  4924  	var resp types.Empty
  4925  	if err := c.client.Call(ctx, "vmservice.VM", "ModifyResource", req, &resp); err != nil {
  4926  		return nil, err
  4927  	}
  4928  	return &resp, nil
  4929  }
  4930  
  4931  func (c *vMClient) VMSocket(ctx context.Context, req *VMSocketRequest) (*types.Empty, error) {
  4932  	var resp types.Empty
  4933  	if err := c.client.Call(ctx, "vmservice.VM", "VMSocket", req, &resp); err != nil {
  4934  		return nil, err
  4935  	}
  4936  	return &resp, nil
  4937  }
  4938  
  4939  func (c *vMClient) Quit(ctx context.Context, req *types.Empty) (*types.Empty, error) {
  4940  	var resp types.Empty
  4941  	if err := c.client.Call(ctx, "vmservice.VM", "Quit", req, &resp); err != nil {
  4942  		return nil, err
  4943  	}
  4944  	return &resp, nil
  4945  }
  4946  func (m *DirectBoot) Unmarshal(dAtA []byte) error {
  4947  	l := len(dAtA)
  4948  	iNdEx := 0
  4949  	for iNdEx < l {
  4950  		preIndex := iNdEx
  4951  		var wire uint64
  4952  		for shift := uint(0); ; shift += 7 {
  4953  			if shift >= 64 {
  4954  				return ErrIntOverflowVmservice
  4955  			}
  4956  			if iNdEx >= l {
  4957  				return io.ErrUnexpectedEOF
  4958  			}
  4959  			b := dAtA[iNdEx]
  4960  			iNdEx++
  4961  			wire |= uint64(b&0x7F) << shift
  4962  			if b < 0x80 {
  4963  				break
  4964  			}
  4965  		}
  4966  		fieldNum := int32(wire >> 3)
  4967  		wireType := int(wire & 0x7)
  4968  		if wireType == 4 {
  4969  			return fmt.Errorf("proto: DirectBoot: wiretype end group for non-group")
  4970  		}
  4971  		if fieldNum <= 0 {
  4972  			return fmt.Errorf("proto: DirectBoot: illegal tag %d (wire type %d)", fieldNum, wire)
  4973  		}
  4974  		switch fieldNum {
  4975  		case 1:
  4976  			if wireType != 2 {
  4977  				return fmt.Errorf("proto: wrong wireType = %d for field KernelPath", wireType)
  4978  			}
  4979  			var stringLen uint64
  4980  			for shift := uint(0); ; shift += 7 {
  4981  				if shift >= 64 {
  4982  					return ErrIntOverflowVmservice
  4983  				}
  4984  				if iNdEx >= l {
  4985  					return io.ErrUnexpectedEOF
  4986  				}
  4987  				b := dAtA[iNdEx]
  4988  				iNdEx++
  4989  				stringLen |= uint64(b&0x7F) << shift
  4990  				if b < 0x80 {
  4991  					break
  4992  				}
  4993  			}
  4994  			intStringLen := int(stringLen)
  4995  			if intStringLen < 0 {
  4996  				return ErrInvalidLengthVmservice
  4997  			}
  4998  			postIndex := iNdEx + intStringLen
  4999  			if postIndex < 0 {
  5000  				return ErrInvalidLengthVmservice
  5001  			}
  5002  			if postIndex > l {
  5003  				return io.ErrUnexpectedEOF
  5004  			}
  5005  			m.KernelPath = string(dAtA[iNdEx:postIndex])
  5006  			iNdEx = postIndex
  5007  		case 2:
  5008  			if wireType != 2 {
  5009  				return fmt.Errorf("proto: wrong wireType = %d for field InitrdPath", wireType)
  5010  			}
  5011  			var stringLen uint64
  5012  			for shift := uint(0); ; shift += 7 {
  5013  				if shift >= 64 {
  5014  					return ErrIntOverflowVmservice
  5015  				}
  5016  				if iNdEx >= l {
  5017  					return io.ErrUnexpectedEOF
  5018  				}
  5019  				b := dAtA[iNdEx]
  5020  				iNdEx++
  5021  				stringLen |= uint64(b&0x7F) << shift
  5022  				if b < 0x80 {
  5023  					break
  5024  				}
  5025  			}
  5026  			intStringLen := int(stringLen)
  5027  			if intStringLen < 0 {
  5028  				return ErrInvalidLengthVmservice
  5029  			}
  5030  			postIndex := iNdEx + intStringLen
  5031  			if postIndex < 0 {
  5032  				return ErrInvalidLengthVmservice
  5033  			}
  5034  			if postIndex > l {
  5035  				return io.ErrUnexpectedEOF
  5036  			}
  5037  			m.InitrdPath = string(dAtA[iNdEx:postIndex])
  5038  			iNdEx = postIndex
  5039  		case 3:
  5040  			if wireType != 2 {
  5041  				return fmt.Errorf("proto: wrong wireType = %d for field KernelCmdline", wireType)
  5042  			}
  5043  			var stringLen uint64
  5044  			for shift := uint(0); ; shift += 7 {
  5045  				if shift >= 64 {
  5046  					return ErrIntOverflowVmservice
  5047  				}
  5048  				if iNdEx >= l {
  5049  					return io.ErrUnexpectedEOF
  5050  				}
  5051  				b := dAtA[iNdEx]
  5052  				iNdEx++
  5053  				stringLen |= uint64(b&0x7F) << shift
  5054  				if b < 0x80 {
  5055  					break
  5056  				}
  5057  			}
  5058  			intStringLen := int(stringLen)
  5059  			if intStringLen < 0 {
  5060  				return ErrInvalidLengthVmservice
  5061  			}
  5062  			postIndex := iNdEx + intStringLen
  5063  			if postIndex < 0 {
  5064  				return ErrInvalidLengthVmservice
  5065  			}
  5066  			if postIndex > l {
  5067  				return io.ErrUnexpectedEOF
  5068  			}
  5069  			m.KernelCmdline = string(dAtA[iNdEx:postIndex])
  5070  			iNdEx = postIndex
  5071  		default:
  5072  			iNdEx = preIndex
  5073  			skippy, err := skipVmservice(dAtA[iNdEx:])
  5074  			if err != nil {
  5075  				return err
  5076  			}
  5077  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  5078  				return ErrInvalidLengthVmservice
  5079  			}
  5080  			if (iNdEx + skippy) > l {
  5081  				return io.ErrUnexpectedEOF
  5082  			}
  5083  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  5084  			iNdEx += skippy
  5085  		}
  5086  	}
  5087  
  5088  	if iNdEx > l {
  5089  		return io.ErrUnexpectedEOF
  5090  	}
  5091  	return nil
  5092  }
  5093  func (m *UEFI) Unmarshal(dAtA []byte) error {
  5094  	l := len(dAtA)
  5095  	iNdEx := 0
  5096  	for iNdEx < l {
  5097  		preIndex := iNdEx
  5098  		var wire uint64
  5099  		for shift := uint(0); ; shift += 7 {
  5100  			if shift >= 64 {
  5101  				return ErrIntOverflowVmservice
  5102  			}
  5103  			if iNdEx >= l {
  5104  				return io.ErrUnexpectedEOF
  5105  			}
  5106  			b := dAtA[iNdEx]
  5107  			iNdEx++
  5108  			wire |= uint64(b&0x7F) << shift
  5109  			if b < 0x80 {
  5110  				break
  5111  			}
  5112  		}
  5113  		fieldNum := int32(wire >> 3)
  5114  		wireType := int(wire & 0x7)
  5115  		if wireType == 4 {
  5116  			return fmt.Errorf("proto: UEFI: wiretype end group for non-group")
  5117  		}
  5118  		if fieldNum <= 0 {
  5119  			return fmt.Errorf("proto: UEFI: illegal tag %d (wire type %d)", fieldNum, wire)
  5120  		}
  5121  		switch fieldNum {
  5122  		case 1:
  5123  			if wireType != 2 {
  5124  				return fmt.Errorf("proto: wrong wireType = %d for field FirmwarePath", wireType)
  5125  			}
  5126  			var stringLen uint64
  5127  			for shift := uint(0); ; shift += 7 {
  5128  				if shift >= 64 {
  5129  					return ErrIntOverflowVmservice
  5130  				}
  5131  				if iNdEx >= l {
  5132  					return io.ErrUnexpectedEOF
  5133  				}
  5134  				b := dAtA[iNdEx]
  5135  				iNdEx++
  5136  				stringLen |= uint64(b&0x7F) << shift
  5137  				if b < 0x80 {
  5138  					break
  5139  				}
  5140  			}
  5141  			intStringLen := int(stringLen)
  5142  			if intStringLen < 0 {
  5143  				return ErrInvalidLengthVmservice
  5144  			}
  5145  			postIndex := iNdEx + intStringLen
  5146  			if postIndex < 0 {
  5147  				return ErrInvalidLengthVmservice
  5148  			}
  5149  			if postIndex > l {
  5150  				return io.ErrUnexpectedEOF
  5151  			}
  5152  			m.FirmwarePath = string(dAtA[iNdEx:postIndex])
  5153  			iNdEx = postIndex
  5154  		case 2:
  5155  			if wireType != 2 {
  5156  				return fmt.Errorf("proto: wrong wireType = %d for field DevicePath", wireType)
  5157  			}
  5158  			var stringLen uint64
  5159  			for shift := uint(0); ; shift += 7 {
  5160  				if shift >= 64 {
  5161  					return ErrIntOverflowVmservice
  5162  				}
  5163  				if iNdEx >= l {
  5164  					return io.ErrUnexpectedEOF
  5165  				}
  5166  				b := dAtA[iNdEx]
  5167  				iNdEx++
  5168  				stringLen |= uint64(b&0x7F) << shift
  5169  				if b < 0x80 {
  5170  					break
  5171  				}
  5172  			}
  5173  			intStringLen := int(stringLen)
  5174  			if intStringLen < 0 {
  5175  				return ErrInvalidLengthVmservice
  5176  			}
  5177  			postIndex := iNdEx + intStringLen
  5178  			if postIndex < 0 {
  5179  				return ErrInvalidLengthVmservice
  5180  			}
  5181  			if postIndex > l {
  5182  				return io.ErrUnexpectedEOF
  5183  			}
  5184  			m.DevicePath = string(dAtA[iNdEx:postIndex])
  5185  			iNdEx = postIndex
  5186  		case 3:
  5187  			if wireType != 2 {
  5188  				return fmt.Errorf("proto: wrong wireType = %d for field OptionalData", wireType)
  5189  			}
  5190  			var stringLen uint64
  5191  			for shift := uint(0); ; shift += 7 {
  5192  				if shift >= 64 {
  5193  					return ErrIntOverflowVmservice
  5194  				}
  5195  				if iNdEx >= l {
  5196  					return io.ErrUnexpectedEOF
  5197  				}
  5198  				b := dAtA[iNdEx]
  5199  				iNdEx++
  5200  				stringLen |= uint64(b&0x7F) << shift
  5201  				if b < 0x80 {
  5202  					break
  5203  				}
  5204  			}
  5205  			intStringLen := int(stringLen)
  5206  			if intStringLen < 0 {
  5207  				return ErrInvalidLengthVmservice
  5208  			}
  5209  			postIndex := iNdEx + intStringLen
  5210  			if postIndex < 0 {
  5211  				return ErrInvalidLengthVmservice
  5212  			}
  5213  			if postIndex > l {
  5214  				return io.ErrUnexpectedEOF
  5215  			}
  5216  			m.OptionalData = string(dAtA[iNdEx:postIndex])
  5217  			iNdEx = postIndex
  5218  		default:
  5219  			iNdEx = preIndex
  5220  			skippy, err := skipVmservice(dAtA[iNdEx:])
  5221  			if err != nil {
  5222  				return err
  5223  			}
  5224  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  5225  				return ErrInvalidLengthVmservice
  5226  			}
  5227  			if (iNdEx + skippy) > l {
  5228  				return io.ErrUnexpectedEOF
  5229  			}
  5230  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  5231  			iNdEx += skippy
  5232  		}
  5233  	}
  5234  
  5235  	if iNdEx > l {
  5236  		return io.ErrUnexpectedEOF
  5237  	}
  5238  	return nil
  5239  }
  5240  func (m *MemoryConfig) Unmarshal(dAtA []byte) error {
  5241  	l := len(dAtA)
  5242  	iNdEx := 0
  5243  	for iNdEx < l {
  5244  		preIndex := iNdEx
  5245  		var wire uint64
  5246  		for shift := uint(0); ; shift += 7 {
  5247  			if shift >= 64 {
  5248  				return ErrIntOverflowVmservice
  5249  			}
  5250  			if iNdEx >= l {
  5251  				return io.ErrUnexpectedEOF
  5252  			}
  5253  			b := dAtA[iNdEx]
  5254  			iNdEx++
  5255  			wire |= uint64(b&0x7F) << shift
  5256  			if b < 0x80 {
  5257  				break
  5258  			}
  5259  		}
  5260  		fieldNum := int32(wire >> 3)
  5261  		wireType := int(wire & 0x7)
  5262  		if wireType == 4 {
  5263  			return fmt.Errorf("proto: MemoryConfig: wiretype end group for non-group")
  5264  		}
  5265  		if fieldNum <= 0 {
  5266  			return fmt.Errorf("proto: MemoryConfig: illegal tag %d (wire type %d)", fieldNum, wire)
  5267  		}
  5268  		switch fieldNum {
  5269  		case 1:
  5270  			if wireType != 0 {
  5271  				return fmt.Errorf("proto: wrong wireType = %d for field MemoryMb", wireType)
  5272  			}
  5273  			m.MemoryMb = 0
  5274  			for shift := uint(0); ; shift += 7 {
  5275  				if shift >= 64 {
  5276  					return ErrIntOverflowVmservice
  5277  				}
  5278  				if iNdEx >= l {
  5279  					return io.ErrUnexpectedEOF
  5280  				}
  5281  				b := dAtA[iNdEx]
  5282  				iNdEx++
  5283  				m.MemoryMb |= uint64(b&0x7F) << shift
  5284  				if b < 0x80 {
  5285  					break
  5286  				}
  5287  			}
  5288  		case 2:
  5289  			if wireType != 0 {
  5290  				return fmt.Errorf("proto: wrong wireType = %d for field AllowOvercommit", wireType)
  5291  			}
  5292  			var v int
  5293  			for shift := uint(0); ; shift += 7 {
  5294  				if shift >= 64 {
  5295  					return ErrIntOverflowVmservice
  5296  				}
  5297  				if iNdEx >= l {
  5298  					return io.ErrUnexpectedEOF
  5299  				}
  5300  				b := dAtA[iNdEx]
  5301  				iNdEx++
  5302  				v |= int(b&0x7F) << shift
  5303  				if b < 0x80 {
  5304  					break
  5305  				}
  5306  			}
  5307  			m.AllowOvercommit = bool(v != 0)
  5308  		case 3:
  5309  			if wireType != 0 {
  5310  				return fmt.Errorf("proto: wrong wireType = %d for field DeferredCommit", wireType)
  5311  			}
  5312  			var v int
  5313  			for shift := uint(0); ; shift += 7 {
  5314  				if shift >= 64 {
  5315  					return ErrIntOverflowVmservice
  5316  				}
  5317  				if iNdEx >= l {
  5318  					return io.ErrUnexpectedEOF
  5319  				}
  5320  				b := dAtA[iNdEx]
  5321  				iNdEx++
  5322  				v |= int(b&0x7F) << shift
  5323  				if b < 0x80 {
  5324  					break
  5325  				}
  5326  			}
  5327  			m.DeferredCommit = bool(v != 0)
  5328  		case 4:
  5329  			if wireType != 0 {
  5330  				return fmt.Errorf("proto: wrong wireType = %d for field HotHint", wireType)
  5331  			}
  5332  			var v int
  5333  			for shift := uint(0); ; shift += 7 {
  5334  				if shift >= 64 {
  5335  					return ErrIntOverflowVmservice
  5336  				}
  5337  				if iNdEx >= l {
  5338  					return io.ErrUnexpectedEOF
  5339  				}
  5340  				b := dAtA[iNdEx]
  5341  				iNdEx++
  5342  				v |= int(b&0x7F) << shift
  5343  				if b < 0x80 {
  5344  					break
  5345  				}
  5346  			}
  5347  			m.HotHint = bool(v != 0)
  5348  		case 5:
  5349  			if wireType != 0 {
  5350  				return fmt.Errorf("proto: wrong wireType = %d for field ColdHint", wireType)
  5351  			}
  5352  			var v int
  5353  			for shift := uint(0); ; shift += 7 {
  5354  				if shift >= 64 {
  5355  					return ErrIntOverflowVmservice
  5356  				}
  5357  				if iNdEx >= l {
  5358  					return io.ErrUnexpectedEOF
  5359  				}
  5360  				b := dAtA[iNdEx]
  5361  				iNdEx++
  5362  				v |= int(b&0x7F) << shift
  5363  				if b < 0x80 {
  5364  					break
  5365  				}
  5366  			}
  5367  			m.ColdHint = bool(v != 0)
  5368  		case 6:
  5369  			if wireType != 0 {
  5370  				return fmt.Errorf("proto: wrong wireType = %d for field ColdDiscardHint", wireType)
  5371  			}
  5372  			var v int
  5373  			for shift := uint(0); ; shift += 7 {
  5374  				if shift >= 64 {
  5375  					return ErrIntOverflowVmservice
  5376  				}
  5377  				if iNdEx >= l {
  5378  					return io.ErrUnexpectedEOF
  5379  				}
  5380  				b := dAtA[iNdEx]
  5381  				iNdEx++
  5382  				v |= int(b&0x7F) << shift
  5383  				if b < 0x80 {
  5384  					break
  5385  				}
  5386  			}
  5387  			m.ColdDiscardHint = bool(v != 0)
  5388  		case 7:
  5389  			if wireType != 0 {
  5390  				return fmt.Errorf("proto: wrong wireType = %d for field LowMmioGapInMb", wireType)
  5391  			}
  5392  			m.LowMmioGapInMb = 0
  5393  			for shift := uint(0); ; shift += 7 {
  5394  				if shift >= 64 {
  5395  					return ErrIntOverflowVmservice
  5396  				}
  5397  				if iNdEx >= l {
  5398  					return io.ErrUnexpectedEOF
  5399  				}
  5400  				b := dAtA[iNdEx]
  5401  				iNdEx++
  5402  				m.LowMmioGapInMb |= uint64(b&0x7F) << shift
  5403  				if b < 0x80 {
  5404  					break
  5405  				}
  5406  			}
  5407  		case 8:
  5408  			if wireType != 0 {
  5409  				return fmt.Errorf("proto: wrong wireType = %d for field HighMmioBaseInMb", wireType)
  5410  			}
  5411  			m.HighMmioBaseInMb = 0
  5412  			for shift := uint(0); ; shift += 7 {
  5413  				if shift >= 64 {
  5414  					return ErrIntOverflowVmservice
  5415  				}
  5416  				if iNdEx >= l {
  5417  					return io.ErrUnexpectedEOF
  5418  				}
  5419  				b := dAtA[iNdEx]
  5420  				iNdEx++
  5421  				m.HighMmioBaseInMb |= uint64(b&0x7F) << shift
  5422  				if b < 0x80 {
  5423  					break
  5424  				}
  5425  			}
  5426  		case 9:
  5427  			if wireType != 0 {
  5428  				return fmt.Errorf("proto: wrong wireType = %d for field HighMmioGapInMb", wireType)
  5429  			}
  5430  			m.HighMmioGapInMb = 0
  5431  			for shift := uint(0); ; shift += 7 {
  5432  				if shift >= 64 {
  5433  					return ErrIntOverflowVmservice
  5434  				}
  5435  				if iNdEx >= l {
  5436  					return io.ErrUnexpectedEOF
  5437  				}
  5438  				b := dAtA[iNdEx]
  5439  				iNdEx++
  5440  				m.HighMmioGapInMb |= uint64(b&0x7F) << shift
  5441  				if b < 0x80 {
  5442  					break
  5443  				}
  5444  			}
  5445  		default:
  5446  			iNdEx = preIndex
  5447  			skippy, err := skipVmservice(dAtA[iNdEx:])
  5448  			if err != nil {
  5449  				return err
  5450  			}
  5451  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  5452  				return ErrInvalidLengthVmservice
  5453  			}
  5454  			if (iNdEx + skippy) > l {
  5455  				return io.ErrUnexpectedEOF
  5456  			}
  5457  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  5458  			iNdEx += skippy
  5459  		}
  5460  	}
  5461  
  5462  	if iNdEx > l {
  5463  		return io.ErrUnexpectedEOF
  5464  	}
  5465  	return nil
  5466  }
  5467  func (m *ProcessorConfig) Unmarshal(dAtA []byte) error {
  5468  	l := len(dAtA)
  5469  	iNdEx := 0
  5470  	for iNdEx < l {
  5471  		preIndex := iNdEx
  5472  		var wire uint64
  5473  		for shift := uint(0); ; shift += 7 {
  5474  			if shift >= 64 {
  5475  				return ErrIntOverflowVmservice
  5476  			}
  5477  			if iNdEx >= l {
  5478  				return io.ErrUnexpectedEOF
  5479  			}
  5480  			b := dAtA[iNdEx]
  5481  			iNdEx++
  5482  			wire |= uint64(b&0x7F) << shift
  5483  			if b < 0x80 {
  5484  				break
  5485  			}
  5486  		}
  5487  		fieldNum := int32(wire >> 3)
  5488  		wireType := int(wire & 0x7)
  5489  		if wireType == 4 {
  5490  			return fmt.Errorf("proto: ProcessorConfig: wiretype end group for non-group")
  5491  		}
  5492  		if fieldNum <= 0 {
  5493  			return fmt.Errorf("proto: ProcessorConfig: illegal tag %d (wire type %d)", fieldNum, wire)
  5494  		}
  5495  		switch fieldNum {
  5496  		case 1:
  5497  			if wireType != 0 {
  5498  				return fmt.Errorf("proto: wrong wireType = %d for field ProcessorCount", wireType)
  5499  			}
  5500  			m.ProcessorCount = 0
  5501  			for shift := uint(0); ; shift += 7 {
  5502  				if shift >= 64 {
  5503  					return ErrIntOverflowVmservice
  5504  				}
  5505  				if iNdEx >= l {
  5506  					return io.ErrUnexpectedEOF
  5507  				}
  5508  				b := dAtA[iNdEx]
  5509  				iNdEx++
  5510  				m.ProcessorCount |= uint32(b&0x7F) << shift
  5511  				if b < 0x80 {
  5512  					break
  5513  				}
  5514  			}
  5515  		case 2:
  5516  			if wireType != 0 {
  5517  				return fmt.Errorf("proto: wrong wireType = %d for field ProcessorWeight", wireType)
  5518  			}
  5519  			m.ProcessorWeight = 0
  5520  			for shift := uint(0); ; shift += 7 {
  5521  				if shift >= 64 {
  5522  					return ErrIntOverflowVmservice
  5523  				}
  5524  				if iNdEx >= l {
  5525  					return io.ErrUnexpectedEOF
  5526  				}
  5527  				b := dAtA[iNdEx]
  5528  				iNdEx++
  5529  				m.ProcessorWeight |= uint32(b&0x7F) << shift
  5530  				if b < 0x80 {
  5531  					break
  5532  				}
  5533  			}
  5534  		case 3:
  5535  			if wireType != 0 {
  5536  				return fmt.Errorf("proto: wrong wireType = %d for field ProcessorLimit", wireType)
  5537  			}
  5538  			m.ProcessorLimit = 0
  5539  			for shift := uint(0); ; shift += 7 {
  5540  				if shift >= 64 {
  5541  					return ErrIntOverflowVmservice
  5542  				}
  5543  				if iNdEx >= l {
  5544  					return io.ErrUnexpectedEOF
  5545  				}
  5546  				b := dAtA[iNdEx]
  5547  				iNdEx++
  5548  				m.ProcessorLimit |= uint32(b&0x7F) << shift
  5549  				if b < 0x80 {
  5550  					break
  5551  				}
  5552  			}
  5553  		default:
  5554  			iNdEx = preIndex
  5555  			skippy, err := skipVmservice(dAtA[iNdEx:])
  5556  			if err != nil {
  5557  				return err
  5558  			}
  5559  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  5560  				return ErrInvalidLengthVmservice
  5561  			}
  5562  			if (iNdEx + skippy) > l {
  5563  				return io.ErrUnexpectedEOF
  5564  			}
  5565  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  5566  			iNdEx += skippy
  5567  		}
  5568  	}
  5569  
  5570  	if iNdEx > l {
  5571  		return io.ErrUnexpectedEOF
  5572  	}
  5573  	return nil
  5574  }
  5575  func (m *DevicesConfig) Unmarshal(dAtA []byte) error {
  5576  	l := len(dAtA)
  5577  	iNdEx := 0
  5578  	for iNdEx < l {
  5579  		preIndex := iNdEx
  5580  		var wire uint64
  5581  		for shift := uint(0); ; shift += 7 {
  5582  			if shift >= 64 {
  5583  				return ErrIntOverflowVmservice
  5584  			}
  5585  			if iNdEx >= l {
  5586  				return io.ErrUnexpectedEOF
  5587  			}
  5588  			b := dAtA[iNdEx]
  5589  			iNdEx++
  5590  			wire |= uint64(b&0x7F) << shift
  5591  			if b < 0x80 {
  5592  				break
  5593  			}
  5594  		}
  5595  		fieldNum := int32(wire >> 3)
  5596  		wireType := int(wire & 0x7)
  5597  		if wireType == 4 {
  5598  			return fmt.Errorf("proto: DevicesConfig: wiretype end group for non-group")
  5599  		}
  5600  		if fieldNum <= 0 {
  5601  			return fmt.Errorf("proto: DevicesConfig: illegal tag %d (wire type %d)", fieldNum, wire)
  5602  		}
  5603  		switch fieldNum {
  5604  		case 1:
  5605  			if wireType != 2 {
  5606  				return fmt.Errorf("proto: wrong wireType = %d for field ScsiDisks", wireType)
  5607  			}
  5608  			var msglen int
  5609  			for shift := uint(0); ; shift += 7 {
  5610  				if shift >= 64 {
  5611  					return ErrIntOverflowVmservice
  5612  				}
  5613  				if iNdEx >= l {
  5614  					return io.ErrUnexpectedEOF
  5615  				}
  5616  				b := dAtA[iNdEx]
  5617  				iNdEx++
  5618  				msglen |= int(b&0x7F) << shift
  5619  				if b < 0x80 {
  5620  					break
  5621  				}
  5622  			}
  5623  			if msglen < 0 {
  5624  				return ErrInvalidLengthVmservice
  5625  			}
  5626  			postIndex := iNdEx + msglen
  5627  			if postIndex < 0 {
  5628  				return ErrInvalidLengthVmservice
  5629  			}
  5630  			if postIndex > l {
  5631  				return io.ErrUnexpectedEOF
  5632  			}
  5633  			m.ScsiDisks = append(m.ScsiDisks, &SCSIDisk{})
  5634  			if err := m.ScsiDisks[len(m.ScsiDisks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5635  				return err
  5636  			}
  5637  			iNdEx = postIndex
  5638  		case 2:
  5639  			if wireType != 2 {
  5640  				return fmt.Errorf("proto: wrong wireType = %d for field VpmemDisks", wireType)
  5641  			}
  5642  			var msglen int
  5643  			for shift := uint(0); ; shift += 7 {
  5644  				if shift >= 64 {
  5645  					return ErrIntOverflowVmservice
  5646  				}
  5647  				if iNdEx >= l {
  5648  					return io.ErrUnexpectedEOF
  5649  				}
  5650  				b := dAtA[iNdEx]
  5651  				iNdEx++
  5652  				msglen |= int(b&0x7F) << shift
  5653  				if b < 0x80 {
  5654  					break
  5655  				}
  5656  			}
  5657  			if msglen < 0 {
  5658  				return ErrInvalidLengthVmservice
  5659  			}
  5660  			postIndex := iNdEx + msglen
  5661  			if postIndex < 0 {
  5662  				return ErrInvalidLengthVmservice
  5663  			}
  5664  			if postIndex > l {
  5665  				return io.ErrUnexpectedEOF
  5666  			}
  5667  			m.VpmemDisks = append(m.VpmemDisks, &VPMEMDisk{})
  5668  			if err := m.VpmemDisks[len(m.VpmemDisks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5669  				return err
  5670  			}
  5671  			iNdEx = postIndex
  5672  		case 3:
  5673  			if wireType != 2 {
  5674  				return fmt.Errorf("proto: wrong wireType = %d for field NicConfig", wireType)
  5675  			}
  5676  			var msglen int
  5677  			for shift := uint(0); ; shift += 7 {
  5678  				if shift >= 64 {
  5679  					return ErrIntOverflowVmservice
  5680  				}
  5681  				if iNdEx >= l {
  5682  					return io.ErrUnexpectedEOF
  5683  				}
  5684  				b := dAtA[iNdEx]
  5685  				iNdEx++
  5686  				msglen |= int(b&0x7F) << shift
  5687  				if b < 0x80 {
  5688  					break
  5689  				}
  5690  			}
  5691  			if msglen < 0 {
  5692  				return ErrInvalidLengthVmservice
  5693  			}
  5694  			postIndex := iNdEx + msglen
  5695  			if postIndex < 0 {
  5696  				return ErrInvalidLengthVmservice
  5697  			}
  5698  			if postIndex > l {
  5699  				return io.ErrUnexpectedEOF
  5700  			}
  5701  			m.NicConfig = append(m.NicConfig, &NICConfig{})
  5702  			if err := m.NicConfig[len(m.NicConfig)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5703  				return err
  5704  			}
  5705  			iNdEx = postIndex
  5706  		case 4:
  5707  			if wireType != 2 {
  5708  				return fmt.Errorf("proto: wrong wireType = %d for field WindowsDevice", wireType)
  5709  			}
  5710  			var msglen int
  5711  			for shift := uint(0); ; shift += 7 {
  5712  				if shift >= 64 {
  5713  					return ErrIntOverflowVmservice
  5714  				}
  5715  				if iNdEx >= l {
  5716  					return io.ErrUnexpectedEOF
  5717  				}
  5718  				b := dAtA[iNdEx]
  5719  				iNdEx++
  5720  				msglen |= int(b&0x7F) << shift
  5721  				if b < 0x80 {
  5722  					break
  5723  				}
  5724  			}
  5725  			if msglen < 0 {
  5726  				return ErrInvalidLengthVmservice
  5727  			}
  5728  			postIndex := iNdEx + msglen
  5729  			if postIndex < 0 {
  5730  				return ErrInvalidLengthVmservice
  5731  			}
  5732  			if postIndex > l {
  5733  				return io.ErrUnexpectedEOF
  5734  			}
  5735  			m.WindowsDevice = append(m.WindowsDevice, &WindowsPCIDevice{})
  5736  			if err := m.WindowsDevice[len(m.WindowsDevice)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5737  				return err
  5738  			}
  5739  			iNdEx = postIndex
  5740  		default:
  5741  			iNdEx = preIndex
  5742  			skippy, err := skipVmservice(dAtA[iNdEx:])
  5743  			if err != nil {
  5744  				return err
  5745  			}
  5746  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  5747  				return ErrInvalidLengthVmservice
  5748  			}
  5749  			if (iNdEx + skippy) > l {
  5750  				return io.ErrUnexpectedEOF
  5751  			}
  5752  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  5753  			iNdEx += skippy
  5754  		}
  5755  	}
  5756  
  5757  	if iNdEx > l {
  5758  		return io.ErrUnexpectedEOF
  5759  	}
  5760  	return nil
  5761  }
  5762  func (m *VMConfig) Unmarshal(dAtA []byte) error {
  5763  	l := len(dAtA)
  5764  	iNdEx := 0
  5765  	for iNdEx < l {
  5766  		preIndex := iNdEx
  5767  		var wire uint64
  5768  		for shift := uint(0); ; shift += 7 {
  5769  			if shift >= 64 {
  5770  				return ErrIntOverflowVmservice
  5771  			}
  5772  			if iNdEx >= l {
  5773  				return io.ErrUnexpectedEOF
  5774  			}
  5775  			b := dAtA[iNdEx]
  5776  			iNdEx++
  5777  			wire |= uint64(b&0x7F) << shift
  5778  			if b < 0x80 {
  5779  				break
  5780  			}
  5781  		}
  5782  		fieldNum := int32(wire >> 3)
  5783  		wireType := int(wire & 0x7)
  5784  		if wireType == 4 {
  5785  			return fmt.Errorf("proto: VMConfig: wiretype end group for non-group")
  5786  		}
  5787  		if fieldNum <= 0 {
  5788  			return fmt.Errorf("proto: VMConfig: illegal tag %d (wire type %d)", fieldNum, wire)
  5789  		}
  5790  		switch fieldNum {
  5791  		case 1:
  5792  			if wireType != 2 {
  5793  				return fmt.Errorf("proto: wrong wireType = %d for field MemoryConfig", wireType)
  5794  			}
  5795  			var msglen int
  5796  			for shift := uint(0); ; shift += 7 {
  5797  				if shift >= 64 {
  5798  					return ErrIntOverflowVmservice
  5799  				}
  5800  				if iNdEx >= l {
  5801  					return io.ErrUnexpectedEOF
  5802  				}
  5803  				b := dAtA[iNdEx]
  5804  				iNdEx++
  5805  				msglen |= int(b&0x7F) << shift
  5806  				if b < 0x80 {
  5807  					break
  5808  				}
  5809  			}
  5810  			if msglen < 0 {
  5811  				return ErrInvalidLengthVmservice
  5812  			}
  5813  			postIndex := iNdEx + msglen
  5814  			if postIndex < 0 {
  5815  				return ErrInvalidLengthVmservice
  5816  			}
  5817  			if postIndex > l {
  5818  				return io.ErrUnexpectedEOF
  5819  			}
  5820  			if m.MemoryConfig == nil {
  5821  				m.MemoryConfig = &MemoryConfig{}
  5822  			}
  5823  			if err := m.MemoryConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5824  				return err
  5825  			}
  5826  			iNdEx = postIndex
  5827  		case 2:
  5828  			if wireType != 2 {
  5829  				return fmt.Errorf("proto: wrong wireType = %d for field ProcessorConfig", wireType)
  5830  			}
  5831  			var msglen int
  5832  			for shift := uint(0); ; shift += 7 {
  5833  				if shift >= 64 {
  5834  					return ErrIntOverflowVmservice
  5835  				}
  5836  				if iNdEx >= l {
  5837  					return io.ErrUnexpectedEOF
  5838  				}
  5839  				b := dAtA[iNdEx]
  5840  				iNdEx++
  5841  				msglen |= int(b&0x7F) << shift
  5842  				if b < 0x80 {
  5843  					break
  5844  				}
  5845  			}
  5846  			if msglen < 0 {
  5847  				return ErrInvalidLengthVmservice
  5848  			}
  5849  			postIndex := iNdEx + msglen
  5850  			if postIndex < 0 {
  5851  				return ErrInvalidLengthVmservice
  5852  			}
  5853  			if postIndex > l {
  5854  				return io.ErrUnexpectedEOF
  5855  			}
  5856  			if m.ProcessorConfig == nil {
  5857  				m.ProcessorConfig = &ProcessorConfig{}
  5858  			}
  5859  			if err := m.ProcessorConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5860  				return err
  5861  			}
  5862  			iNdEx = postIndex
  5863  		case 3:
  5864  			if wireType != 2 {
  5865  				return fmt.Errorf("proto: wrong wireType = %d for field DevicesConfig", wireType)
  5866  			}
  5867  			var msglen int
  5868  			for shift := uint(0); ; shift += 7 {
  5869  				if shift >= 64 {
  5870  					return ErrIntOverflowVmservice
  5871  				}
  5872  				if iNdEx >= l {
  5873  					return io.ErrUnexpectedEOF
  5874  				}
  5875  				b := dAtA[iNdEx]
  5876  				iNdEx++
  5877  				msglen |= int(b&0x7F) << shift
  5878  				if b < 0x80 {
  5879  					break
  5880  				}
  5881  			}
  5882  			if msglen < 0 {
  5883  				return ErrInvalidLengthVmservice
  5884  			}
  5885  			postIndex := iNdEx + msglen
  5886  			if postIndex < 0 {
  5887  				return ErrInvalidLengthVmservice
  5888  			}
  5889  			if postIndex > l {
  5890  				return io.ErrUnexpectedEOF
  5891  			}
  5892  			if m.DevicesConfig == nil {
  5893  				m.DevicesConfig = &DevicesConfig{}
  5894  			}
  5895  			if err := m.DevicesConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5896  				return err
  5897  			}
  5898  			iNdEx = postIndex
  5899  		case 4:
  5900  			if wireType != 2 {
  5901  				return fmt.Errorf("proto: wrong wireType = %d for field SerialConfig", wireType)
  5902  			}
  5903  			var msglen int
  5904  			for shift := uint(0); ; shift += 7 {
  5905  				if shift >= 64 {
  5906  					return ErrIntOverflowVmservice
  5907  				}
  5908  				if iNdEx >= l {
  5909  					return io.ErrUnexpectedEOF
  5910  				}
  5911  				b := dAtA[iNdEx]
  5912  				iNdEx++
  5913  				msglen |= int(b&0x7F) << shift
  5914  				if b < 0x80 {
  5915  					break
  5916  				}
  5917  			}
  5918  			if msglen < 0 {
  5919  				return ErrInvalidLengthVmservice
  5920  			}
  5921  			postIndex := iNdEx + msglen
  5922  			if postIndex < 0 {
  5923  				return ErrInvalidLengthVmservice
  5924  			}
  5925  			if postIndex > l {
  5926  				return io.ErrUnexpectedEOF
  5927  			}
  5928  			if m.SerialConfig == nil {
  5929  				m.SerialConfig = &SerialConfig{}
  5930  			}
  5931  			if err := m.SerialConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5932  				return err
  5933  			}
  5934  			iNdEx = postIndex
  5935  		case 5:
  5936  			if wireType != 2 {
  5937  				return fmt.Errorf("proto: wrong wireType = %d for field DirectBoot", wireType)
  5938  			}
  5939  			var msglen int
  5940  			for shift := uint(0); ; shift += 7 {
  5941  				if shift >= 64 {
  5942  					return ErrIntOverflowVmservice
  5943  				}
  5944  				if iNdEx >= l {
  5945  					return io.ErrUnexpectedEOF
  5946  				}
  5947  				b := dAtA[iNdEx]
  5948  				iNdEx++
  5949  				msglen |= int(b&0x7F) << shift
  5950  				if b < 0x80 {
  5951  					break
  5952  				}
  5953  			}
  5954  			if msglen < 0 {
  5955  				return ErrInvalidLengthVmservice
  5956  			}
  5957  			postIndex := iNdEx + msglen
  5958  			if postIndex < 0 {
  5959  				return ErrInvalidLengthVmservice
  5960  			}
  5961  			if postIndex > l {
  5962  				return io.ErrUnexpectedEOF
  5963  			}
  5964  			v := &DirectBoot{}
  5965  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5966  				return err
  5967  			}
  5968  			m.BootConfig = &VMConfig_DirectBoot{v}
  5969  			iNdEx = postIndex
  5970  		case 6:
  5971  			if wireType != 2 {
  5972  				return fmt.Errorf("proto: wrong wireType = %d for field Uefi", wireType)
  5973  			}
  5974  			var msglen int
  5975  			for shift := uint(0); ; shift += 7 {
  5976  				if shift >= 64 {
  5977  					return ErrIntOverflowVmservice
  5978  				}
  5979  				if iNdEx >= l {
  5980  					return io.ErrUnexpectedEOF
  5981  				}
  5982  				b := dAtA[iNdEx]
  5983  				iNdEx++
  5984  				msglen |= int(b&0x7F) << shift
  5985  				if b < 0x80 {
  5986  					break
  5987  				}
  5988  			}
  5989  			if msglen < 0 {
  5990  				return ErrInvalidLengthVmservice
  5991  			}
  5992  			postIndex := iNdEx + msglen
  5993  			if postIndex < 0 {
  5994  				return ErrInvalidLengthVmservice
  5995  			}
  5996  			if postIndex > l {
  5997  				return io.ErrUnexpectedEOF
  5998  			}
  5999  			v := &UEFI{}
  6000  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6001  				return err
  6002  			}
  6003  			m.BootConfig = &VMConfig_Uefi{v}
  6004  			iNdEx = postIndex
  6005  		case 7:
  6006  			if wireType != 2 {
  6007  				return fmt.Errorf("proto: wrong wireType = %d for field WindowsOptions", wireType)
  6008  			}
  6009  			var msglen int
  6010  			for shift := uint(0); ; shift += 7 {
  6011  				if shift >= 64 {
  6012  					return ErrIntOverflowVmservice
  6013  				}
  6014  				if iNdEx >= l {
  6015  					return io.ErrUnexpectedEOF
  6016  				}
  6017  				b := dAtA[iNdEx]
  6018  				iNdEx++
  6019  				msglen |= int(b&0x7F) << shift
  6020  				if b < 0x80 {
  6021  					break
  6022  				}
  6023  			}
  6024  			if msglen < 0 {
  6025  				return ErrInvalidLengthVmservice
  6026  			}
  6027  			postIndex := iNdEx + msglen
  6028  			if postIndex < 0 {
  6029  				return ErrInvalidLengthVmservice
  6030  			}
  6031  			if postIndex > l {
  6032  				return io.ErrUnexpectedEOF
  6033  			}
  6034  			if m.WindowsOptions == nil {
  6035  				m.WindowsOptions = &WindowsOptions{}
  6036  			}
  6037  			if err := m.WindowsOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6038  				return err
  6039  			}
  6040  			iNdEx = postIndex
  6041  		case 8:
  6042  			if wireType != 2 {
  6043  				return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType)
  6044  			}
  6045  			var msglen int
  6046  			for shift := uint(0); ; shift += 7 {
  6047  				if shift >= 64 {
  6048  					return ErrIntOverflowVmservice
  6049  				}
  6050  				if iNdEx >= l {
  6051  					return io.ErrUnexpectedEOF
  6052  				}
  6053  				b := dAtA[iNdEx]
  6054  				iNdEx++
  6055  				msglen |= int(b&0x7F) << shift
  6056  				if b < 0x80 {
  6057  					break
  6058  				}
  6059  			}
  6060  			if msglen < 0 {
  6061  				return ErrInvalidLengthVmservice
  6062  			}
  6063  			postIndex := iNdEx + msglen
  6064  			if postIndex < 0 {
  6065  				return ErrInvalidLengthVmservice
  6066  			}
  6067  			if postIndex > l {
  6068  				return io.ErrUnexpectedEOF
  6069  			}
  6070  			if m.ExtraData == nil {
  6071  				m.ExtraData = make(map[string]string)
  6072  			}
  6073  			var mapkey string
  6074  			var mapvalue string
  6075  			for iNdEx < postIndex {
  6076  				entryPreIndex := iNdEx
  6077  				var wire uint64
  6078  				for shift := uint(0); ; shift += 7 {
  6079  					if shift >= 64 {
  6080  						return ErrIntOverflowVmservice
  6081  					}
  6082  					if iNdEx >= l {
  6083  						return io.ErrUnexpectedEOF
  6084  					}
  6085  					b := dAtA[iNdEx]
  6086  					iNdEx++
  6087  					wire |= uint64(b&0x7F) << shift
  6088  					if b < 0x80 {
  6089  						break
  6090  					}
  6091  				}
  6092  				fieldNum := int32(wire >> 3)
  6093  				if fieldNum == 1 {
  6094  					var stringLenmapkey uint64
  6095  					for shift := uint(0); ; shift += 7 {
  6096  						if shift >= 64 {
  6097  							return ErrIntOverflowVmservice
  6098  						}
  6099  						if iNdEx >= l {
  6100  							return io.ErrUnexpectedEOF
  6101  						}
  6102  						b := dAtA[iNdEx]
  6103  						iNdEx++
  6104  						stringLenmapkey |= uint64(b&0x7F) << shift
  6105  						if b < 0x80 {
  6106  							break
  6107  						}
  6108  					}
  6109  					intStringLenmapkey := int(stringLenmapkey)
  6110  					if intStringLenmapkey < 0 {
  6111  						return ErrInvalidLengthVmservice
  6112  					}
  6113  					postStringIndexmapkey := iNdEx + intStringLenmapkey
  6114  					if postStringIndexmapkey < 0 {
  6115  						return ErrInvalidLengthVmservice
  6116  					}
  6117  					if postStringIndexmapkey > l {
  6118  						return io.ErrUnexpectedEOF
  6119  					}
  6120  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
  6121  					iNdEx = postStringIndexmapkey
  6122  				} else if fieldNum == 2 {
  6123  					var stringLenmapvalue uint64
  6124  					for shift := uint(0); ; shift += 7 {
  6125  						if shift >= 64 {
  6126  							return ErrIntOverflowVmservice
  6127  						}
  6128  						if iNdEx >= l {
  6129  							return io.ErrUnexpectedEOF
  6130  						}
  6131  						b := dAtA[iNdEx]
  6132  						iNdEx++
  6133  						stringLenmapvalue |= uint64(b&0x7F) << shift
  6134  						if b < 0x80 {
  6135  							break
  6136  						}
  6137  					}
  6138  					intStringLenmapvalue := int(stringLenmapvalue)
  6139  					if intStringLenmapvalue < 0 {
  6140  						return ErrInvalidLengthVmservice
  6141  					}
  6142  					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
  6143  					if postStringIndexmapvalue < 0 {
  6144  						return ErrInvalidLengthVmservice
  6145  					}
  6146  					if postStringIndexmapvalue > l {
  6147  						return io.ErrUnexpectedEOF
  6148  					}
  6149  					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
  6150  					iNdEx = postStringIndexmapvalue
  6151  				} else {
  6152  					iNdEx = entryPreIndex
  6153  					skippy, err := skipVmservice(dAtA[iNdEx:])
  6154  					if err != nil {
  6155  						return err
  6156  					}
  6157  					if (skippy < 0) || (iNdEx+skippy) < 0 {
  6158  						return ErrInvalidLengthVmservice
  6159  					}
  6160  					if (iNdEx + skippy) > postIndex {
  6161  						return io.ErrUnexpectedEOF
  6162  					}
  6163  					iNdEx += skippy
  6164  				}
  6165  			}
  6166  			m.ExtraData[mapkey] = mapvalue
  6167  			iNdEx = postIndex
  6168  		default:
  6169  			iNdEx = preIndex
  6170  			skippy, err := skipVmservice(dAtA[iNdEx:])
  6171  			if err != nil {
  6172  				return err
  6173  			}
  6174  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6175  				return ErrInvalidLengthVmservice
  6176  			}
  6177  			if (iNdEx + skippy) > l {
  6178  				return io.ErrUnexpectedEOF
  6179  			}
  6180  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  6181  			iNdEx += skippy
  6182  		}
  6183  	}
  6184  
  6185  	if iNdEx > l {
  6186  		return io.ErrUnexpectedEOF
  6187  	}
  6188  	return nil
  6189  }
  6190  func (m *WindowsOptions) Unmarshal(dAtA []byte) error {
  6191  	l := len(dAtA)
  6192  	iNdEx := 0
  6193  	for iNdEx < l {
  6194  		preIndex := iNdEx
  6195  		var wire uint64
  6196  		for shift := uint(0); ; shift += 7 {
  6197  			if shift >= 64 {
  6198  				return ErrIntOverflowVmservice
  6199  			}
  6200  			if iNdEx >= l {
  6201  				return io.ErrUnexpectedEOF
  6202  			}
  6203  			b := dAtA[iNdEx]
  6204  			iNdEx++
  6205  			wire |= uint64(b&0x7F) << shift
  6206  			if b < 0x80 {
  6207  				break
  6208  			}
  6209  		}
  6210  		fieldNum := int32(wire >> 3)
  6211  		wireType := int(wire & 0x7)
  6212  		if wireType == 4 {
  6213  			return fmt.Errorf("proto: WindowsOptions: wiretype end group for non-group")
  6214  		}
  6215  		if fieldNum <= 0 {
  6216  			return fmt.Errorf("proto: WindowsOptions: illegal tag %d (wire type %d)", fieldNum, wire)
  6217  		}
  6218  		switch fieldNum {
  6219  		case 1:
  6220  			if wireType != 0 {
  6221  				return fmt.Errorf("proto: wrong wireType = %d for field CpuGroupID", wireType)
  6222  			}
  6223  			m.CpuGroupID = 0
  6224  			for shift := uint(0); ; shift += 7 {
  6225  				if shift >= 64 {
  6226  					return ErrIntOverflowVmservice
  6227  				}
  6228  				if iNdEx >= l {
  6229  					return io.ErrUnexpectedEOF
  6230  				}
  6231  				b := dAtA[iNdEx]
  6232  				iNdEx++
  6233  				m.CpuGroupID |= uint64(b&0x7F) << shift
  6234  				if b < 0x80 {
  6235  					break
  6236  				}
  6237  			}
  6238  		default:
  6239  			iNdEx = preIndex
  6240  			skippy, err := skipVmservice(dAtA[iNdEx:])
  6241  			if err != nil {
  6242  				return err
  6243  			}
  6244  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6245  				return ErrInvalidLengthVmservice
  6246  			}
  6247  			if (iNdEx + skippy) > l {
  6248  				return io.ErrUnexpectedEOF
  6249  			}
  6250  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  6251  			iNdEx += skippy
  6252  		}
  6253  	}
  6254  
  6255  	if iNdEx > l {
  6256  		return io.ErrUnexpectedEOF
  6257  	}
  6258  	return nil
  6259  }
  6260  func (m *SerialConfig) Unmarshal(dAtA []byte) error {
  6261  	l := len(dAtA)
  6262  	iNdEx := 0
  6263  	for iNdEx < l {
  6264  		preIndex := iNdEx
  6265  		var wire uint64
  6266  		for shift := uint(0); ; shift += 7 {
  6267  			if shift >= 64 {
  6268  				return ErrIntOverflowVmservice
  6269  			}
  6270  			if iNdEx >= l {
  6271  				return io.ErrUnexpectedEOF
  6272  			}
  6273  			b := dAtA[iNdEx]
  6274  			iNdEx++
  6275  			wire |= uint64(b&0x7F) << shift
  6276  			if b < 0x80 {
  6277  				break
  6278  			}
  6279  		}
  6280  		fieldNum := int32(wire >> 3)
  6281  		wireType := int(wire & 0x7)
  6282  		if wireType == 4 {
  6283  			return fmt.Errorf("proto: SerialConfig: wiretype end group for non-group")
  6284  		}
  6285  		if fieldNum <= 0 {
  6286  			return fmt.Errorf("proto: SerialConfig: illegal tag %d (wire type %d)", fieldNum, wire)
  6287  		}
  6288  		switch fieldNum {
  6289  		case 3:
  6290  			if wireType != 2 {
  6291  				return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
  6292  			}
  6293  			var msglen int
  6294  			for shift := uint(0); ; shift += 7 {
  6295  				if shift >= 64 {
  6296  					return ErrIntOverflowVmservice
  6297  				}
  6298  				if iNdEx >= l {
  6299  					return io.ErrUnexpectedEOF
  6300  				}
  6301  				b := dAtA[iNdEx]
  6302  				iNdEx++
  6303  				msglen |= int(b&0x7F) << shift
  6304  				if b < 0x80 {
  6305  					break
  6306  				}
  6307  			}
  6308  			if msglen < 0 {
  6309  				return ErrInvalidLengthVmservice
  6310  			}
  6311  			postIndex := iNdEx + msglen
  6312  			if postIndex < 0 {
  6313  				return ErrInvalidLengthVmservice
  6314  			}
  6315  			if postIndex > l {
  6316  				return io.ErrUnexpectedEOF
  6317  			}
  6318  			m.Ports = append(m.Ports, &SerialConfig_Config{})
  6319  			if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6320  				return err
  6321  			}
  6322  			iNdEx = postIndex
  6323  		default:
  6324  			iNdEx = preIndex
  6325  			skippy, err := skipVmservice(dAtA[iNdEx:])
  6326  			if err != nil {
  6327  				return err
  6328  			}
  6329  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6330  				return ErrInvalidLengthVmservice
  6331  			}
  6332  			if (iNdEx + skippy) > l {
  6333  				return io.ErrUnexpectedEOF
  6334  			}
  6335  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  6336  			iNdEx += skippy
  6337  		}
  6338  	}
  6339  
  6340  	if iNdEx > l {
  6341  		return io.ErrUnexpectedEOF
  6342  	}
  6343  	return nil
  6344  }
  6345  func (m *SerialConfig_Config) Unmarshal(dAtA []byte) error {
  6346  	l := len(dAtA)
  6347  	iNdEx := 0
  6348  	for iNdEx < l {
  6349  		preIndex := iNdEx
  6350  		var wire uint64
  6351  		for shift := uint(0); ; shift += 7 {
  6352  			if shift >= 64 {
  6353  				return ErrIntOverflowVmservice
  6354  			}
  6355  			if iNdEx >= l {
  6356  				return io.ErrUnexpectedEOF
  6357  			}
  6358  			b := dAtA[iNdEx]
  6359  			iNdEx++
  6360  			wire |= uint64(b&0x7F) << shift
  6361  			if b < 0x80 {
  6362  				break
  6363  			}
  6364  		}
  6365  		fieldNum := int32(wire >> 3)
  6366  		wireType := int(wire & 0x7)
  6367  		if wireType == 4 {
  6368  			return fmt.Errorf("proto: Config: wiretype end group for non-group")
  6369  		}
  6370  		if fieldNum <= 0 {
  6371  			return fmt.Errorf("proto: Config: illegal tag %d (wire type %d)", fieldNum, wire)
  6372  		}
  6373  		switch fieldNum {
  6374  		case 1:
  6375  			if wireType != 0 {
  6376  				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
  6377  			}
  6378  			m.Port = 0
  6379  			for shift := uint(0); ; shift += 7 {
  6380  				if shift >= 64 {
  6381  					return ErrIntOverflowVmservice
  6382  				}
  6383  				if iNdEx >= l {
  6384  					return io.ErrUnexpectedEOF
  6385  				}
  6386  				b := dAtA[iNdEx]
  6387  				iNdEx++
  6388  				m.Port |= uint32(b&0x7F) << shift
  6389  				if b < 0x80 {
  6390  					break
  6391  				}
  6392  			}
  6393  		case 2:
  6394  			if wireType != 2 {
  6395  				return fmt.Errorf("proto: wrong wireType = %d for field SocketPath", wireType)
  6396  			}
  6397  			var stringLen uint64
  6398  			for shift := uint(0); ; shift += 7 {
  6399  				if shift >= 64 {
  6400  					return ErrIntOverflowVmservice
  6401  				}
  6402  				if iNdEx >= l {
  6403  					return io.ErrUnexpectedEOF
  6404  				}
  6405  				b := dAtA[iNdEx]
  6406  				iNdEx++
  6407  				stringLen |= uint64(b&0x7F) << shift
  6408  				if b < 0x80 {
  6409  					break
  6410  				}
  6411  			}
  6412  			intStringLen := int(stringLen)
  6413  			if intStringLen < 0 {
  6414  				return ErrInvalidLengthVmservice
  6415  			}
  6416  			postIndex := iNdEx + intStringLen
  6417  			if postIndex < 0 {
  6418  				return ErrInvalidLengthVmservice
  6419  			}
  6420  			if postIndex > l {
  6421  				return io.ErrUnexpectedEOF
  6422  			}
  6423  			m.SocketPath = string(dAtA[iNdEx:postIndex])
  6424  			iNdEx = postIndex
  6425  		default:
  6426  			iNdEx = preIndex
  6427  			skippy, err := skipVmservice(dAtA[iNdEx:])
  6428  			if err != nil {
  6429  				return err
  6430  			}
  6431  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6432  				return ErrInvalidLengthVmservice
  6433  			}
  6434  			if (iNdEx + skippy) > l {
  6435  				return io.ErrUnexpectedEOF
  6436  			}
  6437  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  6438  			iNdEx += skippy
  6439  		}
  6440  	}
  6441  
  6442  	if iNdEx > l {
  6443  		return io.ErrUnexpectedEOF
  6444  	}
  6445  	return nil
  6446  }
  6447  func (m *CreateVMRequest) Unmarshal(dAtA []byte) error {
  6448  	l := len(dAtA)
  6449  	iNdEx := 0
  6450  	for iNdEx < l {
  6451  		preIndex := iNdEx
  6452  		var wire uint64
  6453  		for shift := uint(0); ; shift += 7 {
  6454  			if shift >= 64 {
  6455  				return ErrIntOverflowVmservice
  6456  			}
  6457  			if iNdEx >= l {
  6458  				return io.ErrUnexpectedEOF
  6459  			}
  6460  			b := dAtA[iNdEx]
  6461  			iNdEx++
  6462  			wire |= uint64(b&0x7F) << shift
  6463  			if b < 0x80 {
  6464  				break
  6465  			}
  6466  		}
  6467  		fieldNum := int32(wire >> 3)
  6468  		wireType := int(wire & 0x7)
  6469  		if wireType == 4 {
  6470  			return fmt.Errorf("proto: CreateVMRequest: wiretype end group for non-group")
  6471  		}
  6472  		if fieldNum <= 0 {
  6473  			return fmt.Errorf("proto: CreateVMRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  6474  		}
  6475  		switch fieldNum {
  6476  		case 1:
  6477  			if wireType != 2 {
  6478  				return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
  6479  			}
  6480  			var msglen int
  6481  			for shift := uint(0); ; shift += 7 {
  6482  				if shift >= 64 {
  6483  					return ErrIntOverflowVmservice
  6484  				}
  6485  				if iNdEx >= l {
  6486  					return io.ErrUnexpectedEOF
  6487  				}
  6488  				b := dAtA[iNdEx]
  6489  				iNdEx++
  6490  				msglen |= int(b&0x7F) << shift
  6491  				if b < 0x80 {
  6492  					break
  6493  				}
  6494  			}
  6495  			if msglen < 0 {
  6496  				return ErrInvalidLengthVmservice
  6497  			}
  6498  			postIndex := iNdEx + msglen
  6499  			if postIndex < 0 {
  6500  				return ErrInvalidLengthVmservice
  6501  			}
  6502  			if postIndex > l {
  6503  				return io.ErrUnexpectedEOF
  6504  			}
  6505  			if m.Config == nil {
  6506  				m.Config = &VMConfig{}
  6507  			}
  6508  			if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6509  				return err
  6510  			}
  6511  			iNdEx = postIndex
  6512  		case 2:
  6513  			if wireType != 2 {
  6514  				return fmt.Errorf("proto: wrong wireType = %d for field LogID", wireType)
  6515  			}
  6516  			var stringLen uint64
  6517  			for shift := uint(0); ; shift += 7 {
  6518  				if shift >= 64 {
  6519  					return ErrIntOverflowVmservice
  6520  				}
  6521  				if iNdEx >= l {
  6522  					return io.ErrUnexpectedEOF
  6523  				}
  6524  				b := dAtA[iNdEx]
  6525  				iNdEx++
  6526  				stringLen |= uint64(b&0x7F) << shift
  6527  				if b < 0x80 {
  6528  					break
  6529  				}
  6530  			}
  6531  			intStringLen := int(stringLen)
  6532  			if intStringLen < 0 {
  6533  				return ErrInvalidLengthVmservice
  6534  			}
  6535  			postIndex := iNdEx + intStringLen
  6536  			if postIndex < 0 {
  6537  				return ErrInvalidLengthVmservice
  6538  			}
  6539  			if postIndex > l {
  6540  				return io.ErrUnexpectedEOF
  6541  			}
  6542  			m.LogID = string(dAtA[iNdEx:postIndex])
  6543  			iNdEx = postIndex
  6544  		default:
  6545  			iNdEx = preIndex
  6546  			skippy, err := skipVmservice(dAtA[iNdEx:])
  6547  			if err != nil {
  6548  				return err
  6549  			}
  6550  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6551  				return ErrInvalidLengthVmservice
  6552  			}
  6553  			if (iNdEx + skippy) > l {
  6554  				return io.ErrUnexpectedEOF
  6555  			}
  6556  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  6557  			iNdEx += skippy
  6558  		}
  6559  	}
  6560  
  6561  	if iNdEx > l {
  6562  		return io.ErrUnexpectedEOF
  6563  	}
  6564  	return nil
  6565  }
  6566  func (m *InspectVMRequest) Unmarshal(dAtA []byte) error {
  6567  	l := len(dAtA)
  6568  	iNdEx := 0
  6569  	for iNdEx < l {
  6570  		preIndex := iNdEx
  6571  		var wire uint64
  6572  		for shift := uint(0); ; shift += 7 {
  6573  			if shift >= 64 {
  6574  				return ErrIntOverflowVmservice
  6575  			}
  6576  			if iNdEx >= l {
  6577  				return io.ErrUnexpectedEOF
  6578  			}
  6579  			b := dAtA[iNdEx]
  6580  			iNdEx++
  6581  			wire |= uint64(b&0x7F) << shift
  6582  			if b < 0x80 {
  6583  				break
  6584  			}
  6585  		}
  6586  		fieldNum := int32(wire >> 3)
  6587  		wireType := int(wire & 0x7)
  6588  		if wireType == 4 {
  6589  			return fmt.Errorf("proto: InspectVMRequest: wiretype end group for non-group")
  6590  		}
  6591  		if fieldNum <= 0 {
  6592  			return fmt.Errorf("proto: InspectVMRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  6593  		}
  6594  		switch fieldNum {
  6595  		case 1:
  6596  			if wireType != 2 {
  6597  				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
  6598  			}
  6599  			var stringLen uint64
  6600  			for shift := uint(0); ; shift += 7 {
  6601  				if shift >= 64 {
  6602  					return ErrIntOverflowVmservice
  6603  				}
  6604  				if iNdEx >= l {
  6605  					return io.ErrUnexpectedEOF
  6606  				}
  6607  				b := dAtA[iNdEx]
  6608  				iNdEx++
  6609  				stringLen |= uint64(b&0x7F) << shift
  6610  				if b < 0x80 {
  6611  					break
  6612  				}
  6613  			}
  6614  			intStringLen := int(stringLen)
  6615  			if intStringLen < 0 {
  6616  				return ErrInvalidLengthVmservice
  6617  			}
  6618  			postIndex := iNdEx + intStringLen
  6619  			if postIndex < 0 {
  6620  				return ErrInvalidLengthVmservice
  6621  			}
  6622  			if postIndex > l {
  6623  				return io.ErrUnexpectedEOF
  6624  			}
  6625  			m.Query = string(dAtA[iNdEx:postIndex])
  6626  			iNdEx = postIndex
  6627  		case 2:
  6628  			if wireType != 0 {
  6629  				return fmt.Errorf("proto: wrong wireType = %d for field RecursionLimit", wireType)
  6630  			}
  6631  			m.RecursionLimit = 0
  6632  			for shift := uint(0); ; shift += 7 {
  6633  				if shift >= 64 {
  6634  					return ErrIntOverflowVmservice
  6635  				}
  6636  				if iNdEx >= l {
  6637  					return io.ErrUnexpectedEOF
  6638  				}
  6639  				b := dAtA[iNdEx]
  6640  				iNdEx++
  6641  				m.RecursionLimit |= uint32(b&0x7F) << shift
  6642  				if b < 0x80 {
  6643  					break
  6644  				}
  6645  			}
  6646  		default:
  6647  			iNdEx = preIndex
  6648  			skippy, err := skipVmservice(dAtA[iNdEx:])
  6649  			if err != nil {
  6650  				return err
  6651  			}
  6652  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6653  				return ErrInvalidLengthVmservice
  6654  			}
  6655  			if (iNdEx + skippy) > l {
  6656  				return io.ErrUnexpectedEOF
  6657  			}
  6658  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  6659  			iNdEx += skippy
  6660  		}
  6661  	}
  6662  
  6663  	if iNdEx > l {
  6664  		return io.ErrUnexpectedEOF
  6665  	}
  6666  	return nil
  6667  }
  6668  func (m *InspectVMResponse) Unmarshal(dAtA []byte) error {
  6669  	l := len(dAtA)
  6670  	iNdEx := 0
  6671  	for iNdEx < l {
  6672  		preIndex := iNdEx
  6673  		var wire uint64
  6674  		for shift := uint(0); ; shift += 7 {
  6675  			if shift >= 64 {
  6676  				return ErrIntOverflowVmservice
  6677  			}
  6678  			if iNdEx >= l {
  6679  				return io.ErrUnexpectedEOF
  6680  			}
  6681  			b := dAtA[iNdEx]
  6682  			iNdEx++
  6683  			wire |= uint64(b&0x7F) << shift
  6684  			if b < 0x80 {
  6685  				break
  6686  			}
  6687  		}
  6688  		fieldNum := int32(wire >> 3)
  6689  		wireType := int(wire & 0x7)
  6690  		if wireType == 4 {
  6691  			return fmt.Errorf("proto: InspectVMResponse: wiretype end group for non-group")
  6692  		}
  6693  		if fieldNum <= 0 {
  6694  			return fmt.Errorf("proto: InspectVMResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  6695  		}
  6696  		switch fieldNum {
  6697  		case 1:
  6698  			if wireType != 2 {
  6699  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
  6700  			}
  6701  			var msglen int
  6702  			for shift := uint(0); ; shift += 7 {
  6703  				if shift >= 64 {
  6704  					return ErrIntOverflowVmservice
  6705  				}
  6706  				if iNdEx >= l {
  6707  					return io.ErrUnexpectedEOF
  6708  				}
  6709  				b := dAtA[iNdEx]
  6710  				iNdEx++
  6711  				msglen |= int(b&0x7F) << shift
  6712  				if b < 0x80 {
  6713  					break
  6714  				}
  6715  			}
  6716  			if msglen < 0 {
  6717  				return ErrInvalidLengthVmservice
  6718  			}
  6719  			postIndex := iNdEx + msglen
  6720  			if postIndex < 0 {
  6721  				return ErrInvalidLengthVmservice
  6722  			}
  6723  			if postIndex > l {
  6724  				return io.ErrUnexpectedEOF
  6725  			}
  6726  			if m.Result == nil {
  6727  				m.Result = &types.Value{}
  6728  			}
  6729  			if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6730  				return err
  6731  			}
  6732  			iNdEx = postIndex
  6733  		default:
  6734  			iNdEx = preIndex
  6735  			skippy, err := skipVmservice(dAtA[iNdEx:])
  6736  			if err != nil {
  6737  				return err
  6738  			}
  6739  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6740  				return ErrInvalidLengthVmservice
  6741  			}
  6742  			if (iNdEx + skippy) > l {
  6743  				return io.ErrUnexpectedEOF
  6744  			}
  6745  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  6746  			iNdEx += skippy
  6747  		}
  6748  	}
  6749  
  6750  	if iNdEx > l {
  6751  		return io.ErrUnexpectedEOF
  6752  	}
  6753  	return nil
  6754  }
  6755  func (m *MemoryStats) Unmarshal(dAtA []byte) error {
  6756  	l := len(dAtA)
  6757  	iNdEx := 0
  6758  	for iNdEx < l {
  6759  		preIndex := iNdEx
  6760  		var wire uint64
  6761  		for shift := uint(0); ; shift += 7 {
  6762  			if shift >= 64 {
  6763  				return ErrIntOverflowVmservice
  6764  			}
  6765  			if iNdEx >= l {
  6766  				return io.ErrUnexpectedEOF
  6767  			}
  6768  			b := dAtA[iNdEx]
  6769  			iNdEx++
  6770  			wire |= uint64(b&0x7F) << shift
  6771  			if b < 0x80 {
  6772  				break
  6773  			}
  6774  		}
  6775  		fieldNum := int32(wire >> 3)
  6776  		wireType := int(wire & 0x7)
  6777  		if wireType == 4 {
  6778  			return fmt.Errorf("proto: MemoryStats: wiretype end group for non-group")
  6779  		}
  6780  		if fieldNum <= 0 {
  6781  			return fmt.Errorf("proto: MemoryStats: illegal tag %d (wire type %d)", fieldNum, wire)
  6782  		}
  6783  		switch fieldNum {
  6784  		case 1:
  6785  			if wireType != 0 {
  6786  				return fmt.Errorf("proto: wrong wireType = %d for field WorkingSetBytes", wireType)
  6787  			}
  6788  			m.WorkingSetBytes = 0
  6789  			for shift := uint(0); ; shift += 7 {
  6790  				if shift >= 64 {
  6791  					return ErrIntOverflowVmservice
  6792  				}
  6793  				if iNdEx >= l {
  6794  					return io.ErrUnexpectedEOF
  6795  				}
  6796  				b := dAtA[iNdEx]
  6797  				iNdEx++
  6798  				m.WorkingSetBytes |= uint64(b&0x7F) << shift
  6799  				if b < 0x80 {
  6800  					break
  6801  				}
  6802  			}
  6803  		case 2:
  6804  			if wireType != 0 {
  6805  				return fmt.Errorf("proto: wrong wireType = %d for field AvailableMemory", wireType)
  6806  			}
  6807  			m.AvailableMemory = 0
  6808  			for shift := uint(0); ; shift += 7 {
  6809  				if shift >= 64 {
  6810  					return ErrIntOverflowVmservice
  6811  				}
  6812  				if iNdEx >= l {
  6813  					return io.ErrUnexpectedEOF
  6814  				}
  6815  				b := dAtA[iNdEx]
  6816  				iNdEx++
  6817  				m.AvailableMemory |= uint64(b&0x7F) << shift
  6818  				if b < 0x80 {
  6819  					break
  6820  				}
  6821  			}
  6822  		case 3:
  6823  			if wireType != 0 {
  6824  				return fmt.Errorf("proto: wrong wireType = %d for field ReservedMemory", wireType)
  6825  			}
  6826  			m.ReservedMemory = 0
  6827  			for shift := uint(0); ; shift += 7 {
  6828  				if shift >= 64 {
  6829  					return ErrIntOverflowVmservice
  6830  				}
  6831  				if iNdEx >= l {
  6832  					return io.ErrUnexpectedEOF
  6833  				}
  6834  				b := dAtA[iNdEx]
  6835  				iNdEx++
  6836  				m.ReservedMemory |= uint64(b&0x7F) << shift
  6837  				if b < 0x80 {
  6838  					break
  6839  				}
  6840  			}
  6841  		case 4:
  6842  			if wireType != 0 {
  6843  				return fmt.Errorf("proto: wrong wireType = %d for field AssignedMemory", wireType)
  6844  			}
  6845  			m.AssignedMemory = 0
  6846  			for shift := uint(0); ; shift += 7 {
  6847  				if shift >= 64 {
  6848  					return ErrIntOverflowVmservice
  6849  				}
  6850  				if iNdEx >= l {
  6851  					return io.ErrUnexpectedEOF
  6852  				}
  6853  				b := dAtA[iNdEx]
  6854  				iNdEx++
  6855  				m.AssignedMemory |= uint64(b&0x7F) << shift
  6856  				if b < 0x80 {
  6857  					break
  6858  				}
  6859  			}
  6860  		default:
  6861  			iNdEx = preIndex
  6862  			skippy, err := skipVmservice(dAtA[iNdEx:])
  6863  			if err != nil {
  6864  				return err
  6865  			}
  6866  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6867  				return ErrInvalidLengthVmservice
  6868  			}
  6869  			if (iNdEx + skippy) > l {
  6870  				return io.ErrUnexpectedEOF
  6871  			}
  6872  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  6873  			iNdEx += skippy
  6874  		}
  6875  	}
  6876  
  6877  	if iNdEx > l {
  6878  		return io.ErrUnexpectedEOF
  6879  	}
  6880  	return nil
  6881  }
  6882  func (m *ProcessorStats) Unmarshal(dAtA []byte) error {
  6883  	l := len(dAtA)
  6884  	iNdEx := 0
  6885  	for iNdEx < l {
  6886  		preIndex := iNdEx
  6887  		var wire uint64
  6888  		for shift := uint(0); ; shift += 7 {
  6889  			if shift >= 64 {
  6890  				return ErrIntOverflowVmservice
  6891  			}
  6892  			if iNdEx >= l {
  6893  				return io.ErrUnexpectedEOF
  6894  			}
  6895  			b := dAtA[iNdEx]
  6896  			iNdEx++
  6897  			wire |= uint64(b&0x7F) << shift
  6898  			if b < 0x80 {
  6899  				break
  6900  			}
  6901  		}
  6902  		fieldNum := int32(wire >> 3)
  6903  		wireType := int(wire & 0x7)
  6904  		if wireType == 4 {
  6905  			return fmt.Errorf("proto: ProcessorStats: wiretype end group for non-group")
  6906  		}
  6907  		if fieldNum <= 0 {
  6908  			return fmt.Errorf("proto: ProcessorStats: illegal tag %d (wire type %d)", fieldNum, wire)
  6909  		}
  6910  		switch fieldNum {
  6911  		case 1:
  6912  			if wireType != 0 {
  6913  				return fmt.Errorf("proto: wrong wireType = %d for field TotalRuntimeNs", wireType)
  6914  			}
  6915  			m.TotalRuntimeNs = 0
  6916  			for shift := uint(0); ; shift += 7 {
  6917  				if shift >= 64 {
  6918  					return ErrIntOverflowVmservice
  6919  				}
  6920  				if iNdEx >= l {
  6921  					return io.ErrUnexpectedEOF
  6922  				}
  6923  				b := dAtA[iNdEx]
  6924  				iNdEx++
  6925  				m.TotalRuntimeNs |= uint64(b&0x7F) << shift
  6926  				if b < 0x80 {
  6927  					break
  6928  				}
  6929  			}
  6930  		default:
  6931  			iNdEx = preIndex
  6932  			skippy, err := skipVmservice(dAtA[iNdEx:])
  6933  			if err != nil {
  6934  				return err
  6935  			}
  6936  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6937  				return ErrInvalidLengthVmservice
  6938  			}
  6939  			if (iNdEx + skippy) > l {
  6940  				return io.ErrUnexpectedEOF
  6941  			}
  6942  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  6943  			iNdEx += skippy
  6944  		}
  6945  	}
  6946  
  6947  	if iNdEx > l {
  6948  		return io.ErrUnexpectedEOF
  6949  	}
  6950  	return nil
  6951  }
  6952  func (m *PropertiesVMRequest) Unmarshal(dAtA []byte) error {
  6953  	l := len(dAtA)
  6954  	iNdEx := 0
  6955  	for iNdEx < l {
  6956  		preIndex := iNdEx
  6957  		var wire uint64
  6958  		for shift := uint(0); ; shift += 7 {
  6959  			if shift >= 64 {
  6960  				return ErrIntOverflowVmservice
  6961  			}
  6962  			if iNdEx >= l {
  6963  				return io.ErrUnexpectedEOF
  6964  			}
  6965  			b := dAtA[iNdEx]
  6966  			iNdEx++
  6967  			wire |= uint64(b&0x7F) << shift
  6968  			if b < 0x80 {
  6969  				break
  6970  			}
  6971  		}
  6972  		fieldNum := int32(wire >> 3)
  6973  		wireType := int(wire & 0x7)
  6974  		if wireType == 4 {
  6975  			return fmt.Errorf("proto: PropertiesVMRequest: wiretype end group for non-group")
  6976  		}
  6977  		if fieldNum <= 0 {
  6978  			return fmt.Errorf("proto: PropertiesVMRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  6979  		}
  6980  		switch fieldNum {
  6981  		case 1:
  6982  			if wireType == 0 {
  6983  				var v PropertiesVMRequest_PropertiesType
  6984  				for shift := uint(0); ; shift += 7 {
  6985  					if shift >= 64 {
  6986  						return ErrIntOverflowVmservice
  6987  					}
  6988  					if iNdEx >= l {
  6989  						return io.ErrUnexpectedEOF
  6990  					}
  6991  					b := dAtA[iNdEx]
  6992  					iNdEx++
  6993  					v |= PropertiesVMRequest_PropertiesType(b&0x7F) << shift
  6994  					if b < 0x80 {
  6995  						break
  6996  					}
  6997  				}
  6998  				m.Types = append(m.Types, v)
  6999  			} else if wireType == 2 {
  7000  				var packedLen int
  7001  				for shift := uint(0); ; shift += 7 {
  7002  					if shift >= 64 {
  7003  						return ErrIntOverflowVmservice
  7004  					}
  7005  					if iNdEx >= l {
  7006  						return io.ErrUnexpectedEOF
  7007  					}
  7008  					b := dAtA[iNdEx]
  7009  					iNdEx++
  7010  					packedLen |= int(b&0x7F) << shift
  7011  					if b < 0x80 {
  7012  						break
  7013  					}
  7014  				}
  7015  				if packedLen < 0 {
  7016  					return ErrInvalidLengthVmservice
  7017  				}
  7018  				postIndex := iNdEx + packedLen
  7019  				if postIndex < 0 {
  7020  					return ErrInvalidLengthVmservice
  7021  				}
  7022  				if postIndex > l {
  7023  					return io.ErrUnexpectedEOF
  7024  				}
  7025  				var elementCount int
  7026  				if elementCount != 0 && len(m.Types) == 0 {
  7027  					m.Types = make([]PropertiesVMRequest_PropertiesType, 0, elementCount)
  7028  				}
  7029  				for iNdEx < postIndex {
  7030  					var v PropertiesVMRequest_PropertiesType
  7031  					for shift := uint(0); ; shift += 7 {
  7032  						if shift >= 64 {
  7033  							return ErrIntOverflowVmservice
  7034  						}
  7035  						if iNdEx >= l {
  7036  							return io.ErrUnexpectedEOF
  7037  						}
  7038  						b := dAtA[iNdEx]
  7039  						iNdEx++
  7040  						v |= PropertiesVMRequest_PropertiesType(b&0x7F) << shift
  7041  						if b < 0x80 {
  7042  							break
  7043  						}
  7044  					}
  7045  					m.Types = append(m.Types, v)
  7046  				}
  7047  			} else {
  7048  				return fmt.Errorf("proto: wrong wireType = %d for field Types", wireType)
  7049  			}
  7050  		default:
  7051  			iNdEx = preIndex
  7052  			skippy, err := skipVmservice(dAtA[iNdEx:])
  7053  			if err != nil {
  7054  				return err
  7055  			}
  7056  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7057  				return ErrInvalidLengthVmservice
  7058  			}
  7059  			if (iNdEx + skippy) > l {
  7060  				return io.ErrUnexpectedEOF
  7061  			}
  7062  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  7063  			iNdEx += skippy
  7064  		}
  7065  	}
  7066  
  7067  	if iNdEx > l {
  7068  		return io.ErrUnexpectedEOF
  7069  	}
  7070  	return nil
  7071  }
  7072  func (m *PropertiesVMResponse) Unmarshal(dAtA []byte) error {
  7073  	l := len(dAtA)
  7074  	iNdEx := 0
  7075  	for iNdEx < l {
  7076  		preIndex := iNdEx
  7077  		var wire uint64
  7078  		for shift := uint(0); ; shift += 7 {
  7079  			if shift >= 64 {
  7080  				return ErrIntOverflowVmservice
  7081  			}
  7082  			if iNdEx >= l {
  7083  				return io.ErrUnexpectedEOF
  7084  			}
  7085  			b := dAtA[iNdEx]
  7086  			iNdEx++
  7087  			wire |= uint64(b&0x7F) << shift
  7088  			if b < 0x80 {
  7089  				break
  7090  			}
  7091  		}
  7092  		fieldNum := int32(wire >> 3)
  7093  		wireType := int(wire & 0x7)
  7094  		if wireType == 4 {
  7095  			return fmt.Errorf("proto: PropertiesVMResponse: wiretype end group for non-group")
  7096  		}
  7097  		if fieldNum <= 0 {
  7098  			return fmt.Errorf("proto: PropertiesVMResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  7099  		}
  7100  		switch fieldNum {
  7101  		case 1:
  7102  			if wireType != 2 {
  7103  				return fmt.Errorf("proto: wrong wireType = %d for field MemoryStats", wireType)
  7104  			}
  7105  			var msglen int
  7106  			for shift := uint(0); ; shift += 7 {
  7107  				if shift >= 64 {
  7108  					return ErrIntOverflowVmservice
  7109  				}
  7110  				if iNdEx >= l {
  7111  					return io.ErrUnexpectedEOF
  7112  				}
  7113  				b := dAtA[iNdEx]
  7114  				iNdEx++
  7115  				msglen |= int(b&0x7F) << shift
  7116  				if b < 0x80 {
  7117  					break
  7118  				}
  7119  			}
  7120  			if msglen < 0 {
  7121  				return ErrInvalidLengthVmservice
  7122  			}
  7123  			postIndex := iNdEx + msglen
  7124  			if postIndex < 0 {
  7125  				return ErrInvalidLengthVmservice
  7126  			}
  7127  			if postIndex > l {
  7128  				return io.ErrUnexpectedEOF
  7129  			}
  7130  			if m.MemoryStats == nil {
  7131  				m.MemoryStats = &MemoryStats{}
  7132  			}
  7133  			if err := m.MemoryStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7134  				return err
  7135  			}
  7136  			iNdEx = postIndex
  7137  		case 2:
  7138  			if wireType != 2 {
  7139  				return fmt.Errorf("proto: wrong wireType = %d for field ProcessorStats", wireType)
  7140  			}
  7141  			var msglen int
  7142  			for shift := uint(0); ; shift += 7 {
  7143  				if shift >= 64 {
  7144  					return ErrIntOverflowVmservice
  7145  				}
  7146  				if iNdEx >= l {
  7147  					return io.ErrUnexpectedEOF
  7148  				}
  7149  				b := dAtA[iNdEx]
  7150  				iNdEx++
  7151  				msglen |= int(b&0x7F) << shift
  7152  				if b < 0x80 {
  7153  					break
  7154  				}
  7155  			}
  7156  			if msglen < 0 {
  7157  				return ErrInvalidLengthVmservice
  7158  			}
  7159  			postIndex := iNdEx + msglen
  7160  			if postIndex < 0 {
  7161  				return ErrInvalidLengthVmservice
  7162  			}
  7163  			if postIndex > l {
  7164  				return io.ErrUnexpectedEOF
  7165  			}
  7166  			if m.ProcessorStats == nil {
  7167  				m.ProcessorStats = &ProcessorStats{}
  7168  			}
  7169  			if err := m.ProcessorStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7170  				return err
  7171  			}
  7172  			iNdEx = postIndex
  7173  		default:
  7174  			iNdEx = preIndex
  7175  			skippy, err := skipVmservice(dAtA[iNdEx:])
  7176  			if err != nil {
  7177  				return err
  7178  			}
  7179  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7180  				return ErrInvalidLengthVmservice
  7181  			}
  7182  			if (iNdEx + skippy) > l {
  7183  				return io.ErrUnexpectedEOF
  7184  			}
  7185  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  7186  			iNdEx += skippy
  7187  		}
  7188  	}
  7189  
  7190  	if iNdEx > l {
  7191  		return io.ErrUnexpectedEOF
  7192  	}
  7193  	return nil
  7194  }
  7195  func (m *CapabilitiesVMResponse) Unmarshal(dAtA []byte) error {
  7196  	l := len(dAtA)
  7197  	iNdEx := 0
  7198  	for iNdEx < l {
  7199  		preIndex := iNdEx
  7200  		var wire uint64
  7201  		for shift := uint(0); ; shift += 7 {
  7202  			if shift >= 64 {
  7203  				return ErrIntOverflowVmservice
  7204  			}
  7205  			if iNdEx >= l {
  7206  				return io.ErrUnexpectedEOF
  7207  			}
  7208  			b := dAtA[iNdEx]
  7209  			iNdEx++
  7210  			wire |= uint64(b&0x7F) << shift
  7211  			if b < 0x80 {
  7212  				break
  7213  			}
  7214  		}
  7215  		fieldNum := int32(wire >> 3)
  7216  		wireType := int(wire & 0x7)
  7217  		if wireType == 4 {
  7218  			return fmt.Errorf("proto: CapabilitiesVMResponse: wiretype end group for non-group")
  7219  		}
  7220  		if fieldNum <= 0 {
  7221  			return fmt.Errorf("proto: CapabilitiesVMResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  7222  		}
  7223  		switch fieldNum {
  7224  		case 1:
  7225  			if wireType != 2 {
  7226  				return fmt.Errorf("proto: wrong wireType = %d for field SupportedResources", wireType)
  7227  			}
  7228  			var msglen int
  7229  			for shift := uint(0); ; shift += 7 {
  7230  				if shift >= 64 {
  7231  					return ErrIntOverflowVmservice
  7232  				}
  7233  				if iNdEx >= l {
  7234  					return io.ErrUnexpectedEOF
  7235  				}
  7236  				b := dAtA[iNdEx]
  7237  				iNdEx++
  7238  				msglen |= int(b&0x7F) << shift
  7239  				if b < 0x80 {
  7240  					break
  7241  				}
  7242  			}
  7243  			if msglen < 0 {
  7244  				return ErrInvalidLengthVmservice
  7245  			}
  7246  			postIndex := iNdEx + msglen
  7247  			if postIndex < 0 {
  7248  				return ErrInvalidLengthVmservice
  7249  			}
  7250  			if postIndex > l {
  7251  				return io.ErrUnexpectedEOF
  7252  			}
  7253  			m.SupportedResources = append(m.SupportedResources, &CapabilitiesVMResponse_SupportedResource{})
  7254  			if err := m.SupportedResources[len(m.SupportedResources)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7255  				return err
  7256  			}
  7257  			iNdEx = postIndex
  7258  		case 2:
  7259  			if wireType == 0 {
  7260  				var v CapabilitiesVMResponse_SupportedGuestOS
  7261  				for shift := uint(0); ; shift += 7 {
  7262  					if shift >= 64 {
  7263  						return ErrIntOverflowVmservice
  7264  					}
  7265  					if iNdEx >= l {
  7266  						return io.ErrUnexpectedEOF
  7267  					}
  7268  					b := dAtA[iNdEx]
  7269  					iNdEx++
  7270  					v |= CapabilitiesVMResponse_SupportedGuestOS(b&0x7F) << shift
  7271  					if b < 0x80 {
  7272  						break
  7273  					}
  7274  				}
  7275  				m.SupportedGuestOs = append(m.SupportedGuestOs, v)
  7276  			} else if wireType == 2 {
  7277  				var packedLen int
  7278  				for shift := uint(0); ; shift += 7 {
  7279  					if shift >= 64 {
  7280  						return ErrIntOverflowVmservice
  7281  					}
  7282  					if iNdEx >= l {
  7283  						return io.ErrUnexpectedEOF
  7284  					}
  7285  					b := dAtA[iNdEx]
  7286  					iNdEx++
  7287  					packedLen |= int(b&0x7F) << shift
  7288  					if b < 0x80 {
  7289  						break
  7290  					}
  7291  				}
  7292  				if packedLen < 0 {
  7293  					return ErrInvalidLengthVmservice
  7294  				}
  7295  				postIndex := iNdEx + packedLen
  7296  				if postIndex < 0 {
  7297  					return ErrInvalidLengthVmservice
  7298  				}
  7299  				if postIndex > l {
  7300  					return io.ErrUnexpectedEOF
  7301  				}
  7302  				var elementCount int
  7303  				if elementCount != 0 && len(m.SupportedGuestOs) == 0 {
  7304  					m.SupportedGuestOs = make([]CapabilitiesVMResponse_SupportedGuestOS, 0, elementCount)
  7305  				}
  7306  				for iNdEx < postIndex {
  7307  					var v CapabilitiesVMResponse_SupportedGuestOS
  7308  					for shift := uint(0); ; shift += 7 {
  7309  						if shift >= 64 {
  7310  							return ErrIntOverflowVmservice
  7311  						}
  7312  						if iNdEx >= l {
  7313  							return io.ErrUnexpectedEOF
  7314  						}
  7315  						b := dAtA[iNdEx]
  7316  						iNdEx++
  7317  						v |= CapabilitiesVMResponse_SupportedGuestOS(b&0x7F) << shift
  7318  						if b < 0x80 {
  7319  							break
  7320  						}
  7321  					}
  7322  					m.SupportedGuestOs = append(m.SupportedGuestOs, v)
  7323  				}
  7324  			} else {
  7325  				return fmt.Errorf("proto: wrong wireType = %d for field SupportedGuestOs", wireType)
  7326  			}
  7327  		default:
  7328  			iNdEx = preIndex
  7329  			skippy, err := skipVmservice(dAtA[iNdEx:])
  7330  			if err != nil {
  7331  				return err
  7332  			}
  7333  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7334  				return ErrInvalidLengthVmservice
  7335  			}
  7336  			if (iNdEx + skippy) > l {
  7337  				return io.ErrUnexpectedEOF
  7338  			}
  7339  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  7340  			iNdEx += skippy
  7341  		}
  7342  	}
  7343  
  7344  	if iNdEx > l {
  7345  		return io.ErrUnexpectedEOF
  7346  	}
  7347  	return nil
  7348  }
  7349  func (m *CapabilitiesVMResponse_SupportedResource) Unmarshal(dAtA []byte) error {
  7350  	l := len(dAtA)
  7351  	iNdEx := 0
  7352  	for iNdEx < l {
  7353  		preIndex := iNdEx
  7354  		var wire uint64
  7355  		for shift := uint(0); ; shift += 7 {
  7356  			if shift >= 64 {
  7357  				return ErrIntOverflowVmservice
  7358  			}
  7359  			if iNdEx >= l {
  7360  				return io.ErrUnexpectedEOF
  7361  			}
  7362  			b := dAtA[iNdEx]
  7363  			iNdEx++
  7364  			wire |= uint64(b&0x7F) << shift
  7365  			if b < 0x80 {
  7366  				break
  7367  			}
  7368  		}
  7369  		fieldNum := int32(wire >> 3)
  7370  		wireType := int(wire & 0x7)
  7371  		if wireType == 4 {
  7372  			return fmt.Errorf("proto: SupportedResource: wiretype end group for non-group")
  7373  		}
  7374  		if fieldNum <= 0 {
  7375  			return fmt.Errorf("proto: SupportedResource: illegal tag %d (wire type %d)", fieldNum, wire)
  7376  		}
  7377  		switch fieldNum {
  7378  		case 1:
  7379  			if wireType != 0 {
  7380  				return fmt.Errorf("proto: wrong wireType = %d for field Add", wireType)
  7381  			}
  7382  			var v int
  7383  			for shift := uint(0); ; shift += 7 {
  7384  				if shift >= 64 {
  7385  					return ErrIntOverflowVmservice
  7386  				}
  7387  				if iNdEx >= l {
  7388  					return io.ErrUnexpectedEOF
  7389  				}
  7390  				b := dAtA[iNdEx]
  7391  				iNdEx++
  7392  				v |= int(b&0x7F) << shift
  7393  				if b < 0x80 {
  7394  					break
  7395  				}
  7396  			}
  7397  			m.Add = bool(v != 0)
  7398  		case 2:
  7399  			if wireType != 0 {
  7400  				return fmt.Errorf("proto: wrong wireType = %d for field Remove", wireType)
  7401  			}
  7402  			var v int
  7403  			for shift := uint(0); ; shift += 7 {
  7404  				if shift >= 64 {
  7405  					return ErrIntOverflowVmservice
  7406  				}
  7407  				if iNdEx >= l {
  7408  					return io.ErrUnexpectedEOF
  7409  				}
  7410  				b := dAtA[iNdEx]
  7411  				iNdEx++
  7412  				v |= int(b&0x7F) << shift
  7413  				if b < 0x80 {
  7414  					break
  7415  				}
  7416  			}
  7417  			m.Remove = bool(v != 0)
  7418  		case 3:
  7419  			if wireType != 0 {
  7420  				return fmt.Errorf("proto: wrong wireType = %d for field Update", wireType)
  7421  			}
  7422  			var v int
  7423  			for shift := uint(0); ; shift += 7 {
  7424  				if shift >= 64 {
  7425  					return ErrIntOverflowVmservice
  7426  				}
  7427  				if iNdEx >= l {
  7428  					return io.ErrUnexpectedEOF
  7429  				}
  7430  				b := dAtA[iNdEx]
  7431  				iNdEx++
  7432  				v |= int(b&0x7F) << shift
  7433  				if b < 0x80 {
  7434  					break
  7435  				}
  7436  			}
  7437  			m.Update = bool(v != 0)
  7438  		case 4:
  7439  			if wireType != 0 {
  7440  				return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
  7441  			}
  7442  			m.Resource = 0
  7443  			for shift := uint(0); ; shift += 7 {
  7444  				if shift >= 64 {
  7445  					return ErrIntOverflowVmservice
  7446  				}
  7447  				if iNdEx >= l {
  7448  					return io.ErrUnexpectedEOF
  7449  				}
  7450  				b := dAtA[iNdEx]
  7451  				iNdEx++
  7452  				m.Resource |= CapabilitiesVMResponse_Resource(b&0x7F) << shift
  7453  				if b < 0x80 {
  7454  					break
  7455  				}
  7456  			}
  7457  		default:
  7458  			iNdEx = preIndex
  7459  			skippy, err := skipVmservice(dAtA[iNdEx:])
  7460  			if err != nil {
  7461  				return err
  7462  			}
  7463  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7464  				return ErrInvalidLengthVmservice
  7465  			}
  7466  			if (iNdEx + skippy) > l {
  7467  				return io.ErrUnexpectedEOF
  7468  			}
  7469  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  7470  			iNdEx += skippy
  7471  		}
  7472  	}
  7473  
  7474  	if iNdEx > l {
  7475  		return io.ErrUnexpectedEOF
  7476  	}
  7477  	return nil
  7478  }
  7479  func (m *HVSocketListen) Unmarshal(dAtA []byte) error {
  7480  	l := len(dAtA)
  7481  	iNdEx := 0
  7482  	for iNdEx < l {
  7483  		preIndex := iNdEx
  7484  		var wire uint64
  7485  		for shift := uint(0); ; shift += 7 {
  7486  			if shift >= 64 {
  7487  				return ErrIntOverflowVmservice
  7488  			}
  7489  			if iNdEx >= l {
  7490  				return io.ErrUnexpectedEOF
  7491  			}
  7492  			b := dAtA[iNdEx]
  7493  			iNdEx++
  7494  			wire |= uint64(b&0x7F) << shift
  7495  			if b < 0x80 {
  7496  				break
  7497  			}
  7498  		}
  7499  		fieldNum := int32(wire >> 3)
  7500  		wireType := int(wire & 0x7)
  7501  		if wireType == 4 {
  7502  			return fmt.Errorf("proto: HVSocketListen: wiretype end group for non-group")
  7503  		}
  7504  		if fieldNum <= 0 {
  7505  			return fmt.Errorf("proto: HVSocketListen: illegal tag %d (wire type %d)", fieldNum, wire)
  7506  		}
  7507  		switch fieldNum {
  7508  		case 1:
  7509  			if wireType != 2 {
  7510  				return fmt.Errorf("proto: wrong wireType = %d for field ServiceID", wireType)
  7511  			}
  7512  			var stringLen uint64
  7513  			for shift := uint(0); ; shift += 7 {
  7514  				if shift >= 64 {
  7515  					return ErrIntOverflowVmservice
  7516  				}
  7517  				if iNdEx >= l {
  7518  					return io.ErrUnexpectedEOF
  7519  				}
  7520  				b := dAtA[iNdEx]
  7521  				iNdEx++
  7522  				stringLen |= uint64(b&0x7F) << shift
  7523  				if b < 0x80 {
  7524  					break
  7525  				}
  7526  			}
  7527  			intStringLen := int(stringLen)
  7528  			if intStringLen < 0 {
  7529  				return ErrInvalidLengthVmservice
  7530  			}
  7531  			postIndex := iNdEx + intStringLen
  7532  			if postIndex < 0 {
  7533  				return ErrInvalidLengthVmservice
  7534  			}
  7535  			if postIndex > l {
  7536  				return io.ErrUnexpectedEOF
  7537  			}
  7538  			m.ServiceID = string(dAtA[iNdEx:postIndex])
  7539  			iNdEx = postIndex
  7540  		case 2:
  7541  			if wireType != 2 {
  7542  				return fmt.Errorf("proto: wrong wireType = %d for field ListenerPath", wireType)
  7543  			}
  7544  			var stringLen uint64
  7545  			for shift := uint(0); ; shift += 7 {
  7546  				if shift >= 64 {
  7547  					return ErrIntOverflowVmservice
  7548  				}
  7549  				if iNdEx >= l {
  7550  					return io.ErrUnexpectedEOF
  7551  				}
  7552  				b := dAtA[iNdEx]
  7553  				iNdEx++
  7554  				stringLen |= uint64(b&0x7F) << shift
  7555  				if b < 0x80 {
  7556  					break
  7557  				}
  7558  			}
  7559  			intStringLen := int(stringLen)
  7560  			if intStringLen < 0 {
  7561  				return ErrInvalidLengthVmservice
  7562  			}
  7563  			postIndex := iNdEx + intStringLen
  7564  			if postIndex < 0 {
  7565  				return ErrInvalidLengthVmservice
  7566  			}
  7567  			if postIndex > l {
  7568  				return io.ErrUnexpectedEOF
  7569  			}
  7570  			m.ListenerPath = string(dAtA[iNdEx:postIndex])
  7571  			iNdEx = postIndex
  7572  		default:
  7573  			iNdEx = preIndex
  7574  			skippy, err := skipVmservice(dAtA[iNdEx:])
  7575  			if err != nil {
  7576  				return err
  7577  			}
  7578  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7579  				return ErrInvalidLengthVmservice
  7580  			}
  7581  			if (iNdEx + skippy) > l {
  7582  				return io.ErrUnexpectedEOF
  7583  			}
  7584  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  7585  			iNdEx += skippy
  7586  		}
  7587  	}
  7588  
  7589  	if iNdEx > l {
  7590  		return io.ErrUnexpectedEOF
  7591  	}
  7592  	return nil
  7593  }
  7594  func (m *VSockListen) Unmarshal(dAtA []byte) error {
  7595  	l := len(dAtA)
  7596  	iNdEx := 0
  7597  	for iNdEx < l {
  7598  		preIndex := iNdEx
  7599  		var wire uint64
  7600  		for shift := uint(0); ; shift += 7 {
  7601  			if shift >= 64 {
  7602  				return ErrIntOverflowVmservice
  7603  			}
  7604  			if iNdEx >= l {
  7605  				return io.ErrUnexpectedEOF
  7606  			}
  7607  			b := dAtA[iNdEx]
  7608  			iNdEx++
  7609  			wire |= uint64(b&0x7F) << shift
  7610  			if b < 0x80 {
  7611  				break
  7612  			}
  7613  		}
  7614  		fieldNum := int32(wire >> 3)
  7615  		wireType := int(wire & 0x7)
  7616  		if wireType == 4 {
  7617  			return fmt.Errorf("proto: VSockListen: wiretype end group for non-group")
  7618  		}
  7619  		if fieldNum <= 0 {
  7620  			return fmt.Errorf("proto: VSockListen: illegal tag %d (wire type %d)", fieldNum, wire)
  7621  		}
  7622  		switch fieldNum {
  7623  		case 1:
  7624  			if wireType != 0 {
  7625  				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
  7626  			}
  7627  			m.Port = 0
  7628  			for shift := uint(0); ; shift += 7 {
  7629  				if shift >= 64 {
  7630  					return ErrIntOverflowVmservice
  7631  				}
  7632  				if iNdEx >= l {
  7633  					return io.ErrUnexpectedEOF
  7634  				}
  7635  				b := dAtA[iNdEx]
  7636  				iNdEx++
  7637  				m.Port |= uint32(b&0x7F) << shift
  7638  				if b < 0x80 {
  7639  					break
  7640  				}
  7641  			}
  7642  		case 2:
  7643  			if wireType != 2 {
  7644  				return fmt.Errorf("proto: wrong wireType = %d for field ListenerPath", wireType)
  7645  			}
  7646  			var stringLen uint64
  7647  			for shift := uint(0); ; shift += 7 {
  7648  				if shift >= 64 {
  7649  					return ErrIntOverflowVmservice
  7650  				}
  7651  				if iNdEx >= l {
  7652  					return io.ErrUnexpectedEOF
  7653  				}
  7654  				b := dAtA[iNdEx]
  7655  				iNdEx++
  7656  				stringLen |= uint64(b&0x7F) << shift
  7657  				if b < 0x80 {
  7658  					break
  7659  				}
  7660  			}
  7661  			intStringLen := int(stringLen)
  7662  			if intStringLen < 0 {
  7663  				return ErrInvalidLengthVmservice
  7664  			}
  7665  			postIndex := iNdEx + intStringLen
  7666  			if postIndex < 0 {
  7667  				return ErrInvalidLengthVmservice
  7668  			}
  7669  			if postIndex > l {
  7670  				return io.ErrUnexpectedEOF
  7671  			}
  7672  			m.ListenerPath = string(dAtA[iNdEx:postIndex])
  7673  			iNdEx = postIndex
  7674  		default:
  7675  			iNdEx = preIndex
  7676  			skippy, err := skipVmservice(dAtA[iNdEx:])
  7677  			if err != nil {
  7678  				return err
  7679  			}
  7680  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7681  				return ErrInvalidLengthVmservice
  7682  			}
  7683  			if (iNdEx + skippy) > l {
  7684  				return io.ErrUnexpectedEOF
  7685  			}
  7686  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  7687  			iNdEx += skippy
  7688  		}
  7689  	}
  7690  
  7691  	if iNdEx > l {
  7692  		return io.ErrUnexpectedEOF
  7693  	}
  7694  	return nil
  7695  }
  7696  func (m *VMSocketRequest) Unmarshal(dAtA []byte) error {
  7697  	l := len(dAtA)
  7698  	iNdEx := 0
  7699  	for iNdEx < l {
  7700  		preIndex := iNdEx
  7701  		var wire uint64
  7702  		for shift := uint(0); ; shift += 7 {
  7703  			if shift >= 64 {
  7704  				return ErrIntOverflowVmservice
  7705  			}
  7706  			if iNdEx >= l {
  7707  				return io.ErrUnexpectedEOF
  7708  			}
  7709  			b := dAtA[iNdEx]
  7710  			iNdEx++
  7711  			wire |= uint64(b&0x7F) << shift
  7712  			if b < 0x80 {
  7713  				break
  7714  			}
  7715  		}
  7716  		fieldNum := int32(wire >> 3)
  7717  		wireType := int(wire & 0x7)
  7718  		if wireType == 4 {
  7719  			return fmt.Errorf("proto: VMSocketRequest: wiretype end group for non-group")
  7720  		}
  7721  		if fieldNum <= 0 {
  7722  			return fmt.Errorf("proto: VMSocketRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  7723  		}
  7724  		switch fieldNum {
  7725  		case 1:
  7726  			if wireType != 0 {
  7727  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
  7728  			}
  7729  			m.Type = 0
  7730  			for shift := uint(0); ; shift += 7 {
  7731  				if shift >= 64 {
  7732  					return ErrIntOverflowVmservice
  7733  				}
  7734  				if iNdEx >= l {
  7735  					return io.ErrUnexpectedEOF
  7736  				}
  7737  				b := dAtA[iNdEx]
  7738  				iNdEx++
  7739  				m.Type |= ModifyType(b&0x7F) << shift
  7740  				if b < 0x80 {
  7741  					break
  7742  				}
  7743  			}
  7744  		case 2:
  7745  			if wireType != 2 {
  7746  				return fmt.Errorf("proto: wrong wireType = %d for field HvsocketList", wireType)
  7747  			}
  7748  			var msglen int
  7749  			for shift := uint(0); ; shift += 7 {
  7750  				if shift >= 64 {
  7751  					return ErrIntOverflowVmservice
  7752  				}
  7753  				if iNdEx >= l {
  7754  					return io.ErrUnexpectedEOF
  7755  				}
  7756  				b := dAtA[iNdEx]
  7757  				iNdEx++
  7758  				msglen |= int(b&0x7F) << shift
  7759  				if b < 0x80 {
  7760  					break
  7761  				}
  7762  			}
  7763  			if msglen < 0 {
  7764  				return ErrInvalidLengthVmservice
  7765  			}
  7766  			postIndex := iNdEx + msglen
  7767  			if postIndex < 0 {
  7768  				return ErrInvalidLengthVmservice
  7769  			}
  7770  			if postIndex > l {
  7771  				return io.ErrUnexpectedEOF
  7772  			}
  7773  			v := &HVSocketListen{}
  7774  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7775  				return err
  7776  			}
  7777  			m.Config = &VMSocketRequest_HvsocketList{v}
  7778  			iNdEx = postIndex
  7779  		case 3:
  7780  			if wireType != 2 {
  7781  				return fmt.Errorf("proto: wrong wireType = %d for field VsockListen", wireType)
  7782  			}
  7783  			var msglen int
  7784  			for shift := uint(0); ; shift += 7 {
  7785  				if shift >= 64 {
  7786  					return ErrIntOverflowVmservice
  7787  				}
  7788  				if iNdEx >= l {
  7789  					return io.ErrUnexpectedEOF
  7790  				}
  7791  				b := dAtA[iNdEx]
  7792  				iNdEx++
  7793  				msglen |= int(b&0x7F) << shift
  7794  				if b < 0x80 {
  7795  					break
  7796  				}
  7797  			}
  7798  			if msglen < 0 {
  7799  				return ErrInvalidLengthVmservice
  7800  			}
  7801  			postIndex := iNdEx + msglen
  7802  			if postIndex < 0 {
  7803  				return ErrInvalidLengthVmservice
  7804  			}
  7805  			if postIndex > l {
  7806  				return io.ErrUnexpectedEOF
  7807  			}
  7808  			v := &VSockListen{}
  7809  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7810  				return err
  7811  			}
  7812  			m.Config = &VMSocketRequest_VsockListen{v}
  7813  			iNdEx = postIndex
  7814  		default:
  7815  			iNdEx = preIndex
  7816  			skippy, err := skipVmservice(dAtA[iNdEx:])
  7817  			if err != nil {
  7818  				return err
  7819  			}
  7820  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7821  				return ErrInvalidLengthVmservice
  7822  			}
  7823  			if (iNdEx + skippy) > l {
  7824  				return io.ErrUnexpectedEOF
  7825  			}
  7826  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  7827  			iNdEx += skippy
  7828  		}
  7829  	}
  7830  
  7831  	if iNdEx > l {
  7832  		return io.ErrUnexpectedEOF
  7833  	}
  7834  	return nil
  7835  }
  7836  func (m *SCSIDisk) Unmarshal(dAtA []byte) error {
  7837  	l := len(dAtA)
  7838  	iNdEx := 0
  7839  	for iNdEx < l {
  7840  		preIndex := iNdEx
  7841  		var wire uint64
  7842  		for shift := uint(0); ; shift += 7 {
  7843  			if shift >= 64 {
  7844  				return ErrIntOverflowVmservice
  7845  			}
  7846  			if iNdEx >= l {
  7847  				return io.ErrUnexpectedEOF
  7848  			}
  7849  			b := dAtA[iNdEx]
  7850  			iNdEx++
  7851  			wire |= uint64(b&0x7F) << shift
  7852  			if b < 0x80 {
  7853  				break
  7854  			}
  7855  		}
  7856  		fieldNum := int32(wire >> 3)
  7857  		wireType := int(wire & 0x7)
  7858  		if wireType == 4 {
  7859  			return fmt.Errorf("proto: SCSIDisk: wiretype end group for non-group")
  7860  		}
  7861  		if fieldNum <= 0 {
  7862  			return fmt.Errorf("proto: SCSIDisk: illegal tag %d (wire type %d)", fieldNum, wire)
  7863  		}
  7864  		switch fieldNum {
  7865  		case 1:
  7866  			if wireType != 0 {
  7867  				return fmt.Errorf("proto: wrong wireType = %d for field Controller", wireType)
  7868  			}
  7869  			m.Controller = 0
  7870  			for shift := uint(0); ; shift += 7 {
  7871  				if shift >= 64 {
  7872  					return ErrIntOverflowVmservice
  7873  				}
  7874  				if iNdEx >= l {
  7875  					return io.ErrUnexpectedEOF
  7876  				}
  7877  				b := dAtA[iNdEx]
  7878  				iNdEx++
  7879  				m.Controller |= uint32(b&0x7F) << shift
  7880  				if b < 0x80 {
  7881  					break
  7882  				}
  7883  			}
  7884  		case 2:
  7885  			if wireType != 0 {
  7886  				return fmt.Errorf("proto: wrong wireType = %d for field Lun", wireType)
  7887  			}
  7888  			m.Lun = 0
  7889  			for shift := uint(0); ; shift += 7 {
  7890  				if shift >= 64 {
  7891  					return ErrIntOverflowVmservice
  7892  				}
  7893  				if iNdEx >= l {
  7894  					return io.ErrUnexpectedEOF
  7895  				}
  7896  				b := dAtA[iNdEx]
  7897  				iNdEx++
  7898  				m.Lun |= uint32(b&0x7F) << shift
  7899  				if b < 0x80 {
  7900  					break
  7901  				}
  7902  			}
  7903  		case 3:
  7904  			if wireType != 2 {
  7905  				return fmt.Errorf("proto: wrong wireType = %d for field HostPath", wireType)
  7906  			}
  7907  			var stringLen uint64
  7908  			for shift := uint(0); ; shift += 7 {
  7909  				if shift >= 64 {
  7910  					return ErrIntOverflowVmservice
  7911  				}
  7912  				if iNdEx >= l {
  7913  					return io.ErrUnexpectedEOF
  7914  				}
  7915  				b := dAtA[iNdEx]
  7916  				iNdEx++
  7917  				stringLen |= uint64(b&0x7F) << shift
  7918  				if b < 0x80 {
  7919  					break
  7920  				}
  7921  			}
  7922  			intStringLen := int(stringLen)
  7923  			if intStringLen < 0 {
  7924  				return ErrInvalidLengthVmservice
  7925  			}
  7926  			postIndex := iNdEx + intStringLen
  7927  			if postIndex < 0 {
  7928  				return ErrInvalidLengthVmservice
  7929  			}
  7930  			if postIndex > l {
  7931  				return io.ErrUnexpectedEOF
  7932  			}
  7933  			m.HostPath = string(dAtA[iNdEx:postIndex])
  7934  			iNdEx = postIndex
  7935  		case 4:
  7936  			if wireType != 0 {
  7937  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
  7938  			}
  7939  			m.Type = 0
  7940  			for shift := uint(0); ; shift += 7 {
  7941  				if shift >= 64 {
  7942  					return ErrIntOverflowVmservice
  7943  				}
  7944  				if iNdEx >= l {
  7945  					return io.ErrUnexpectedEOF
  7946  				}
  7947  				b := dAtA[iNdEx]
  7948  				iNdEx++
  7949  				m.Type |= DiskType(b&0x7F) << shift
  7950  				if b < 0x80 {
  7951  					break
  7952  				}
  7953  			}
  7954  		case 5:
  7955  			if wireType != 0 {
  7956  				return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
  7957  			}
  7958  			var v int
  7959  			for shift := uint(0); ; shift += 7 {
  7960  				if shift >= 64 {
  7961  					return ErrIntOverflowVmservice
  7962  				}
  7963  				if iNdEx >= l {
  7964  					return io.ErrUnexpectedEOF
  7965  				}
  7966  				b := dAtA[iNdEx]
  7967  				iNdEx++
  7968  				v |= int(b&0x7F) << shift
  7969  				if b < 0x80 {
  7970  					break
  7971  				}
  7972  			}
  7973  			m.ReadOnly = bool(v != 0)
  7974  		default:
  7975  			iNdEx = preIndex
  7976  			skippy, err := skipVmservice(dAtA[iNdEx:])
  7977  			if err != nil {
  7978  				return err
  7979  			}
  7980  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7981  				return ErrInvalidLengthVmservice
  7982  			}
  7983  			if (iNdEx + skippy) > l {
  7984  				return io.ErrUnexpectedEOF
  7985  			}
  7986  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  7987  			iNdEx += skippy
  7988  		}
  7989  	}
  7990  
  7991  	if iNdEx > l {
  7992  		return io.ErrUnexpectedEOF
  7993  	}
  7994  	return nil
  7995  }
  7996  func (m *VPMEMDisk) Unmarshal(dAtA []byte) error {
  7997  	l := len(dAtA)
  7998  	iNdEx := 0
  7999  	for iNdEx < l {
  8000  		preIndex := iNdEx
  8001  		var wire uint64
  8002  		for shift := uint(0); ; shift += 7 {
  8003  			if shift >= 64 {
  8004  				return ErrIntOverflowVmservice
  8005  			}
  8006  			if iNdEx >= l {
  8007  				return io.ErrUnexpectedEOF
  8008  			}
  8009  			b := dAtA[iNdEx]
  8010  			iNdEx++
  8011  			wire |= uint64(b&0x7F) << shift
  8012  			if b < 0x80 {
  8013  				break
  8014  			}
  8015  		}
  8016  		fieldNum := int32(wire >> 3)
  8017  		wireType := int(wire & 0x7)
  8018  		if wireType == 4 {
  8019  			return fmt.Errorf("proto: VPMEMDisk: wiretype end group for non-group")
  8020  		}
  8021  		if fieldNum <= 0 {
  8022  			return fmt.Errorf("proto: VPMEMDisk: illegal tag %d (wire type %d)", fieldNum, wire)
  8023  		}
  8024  		switch fieldNum {
  8025  		case 1:
  8026  			if wireType != 2 {
  8027  				return fmt.Errorf("proto: wrong wireType = %d for field HostPath", wireType)
  8028  			}
  8029  			var stringLen uint64
  8030  			for shift := uint(0); ; shift += 7 {
  8031  				if shift >= 64 {
  8032  					return ErrIntOverflowVmservice
  8033  				}
  8034  				if iNdEx >= l {
  8035  					return io.ErrUnexpectedEOF
  8036  				}
  8037  				b := dAtA[iNdEx]
  8038  				iNdEx++
  8039  				stringLen |= uint64(b&0x7F) << shift
  8040  				if b < 0x80 {
  8041  					break
  8042  				}
  8043  			}
  8044  			intStringLen := int(stringLen)
  8045  			if intStringLen < 0 {
  8046  				return ErrInvalidLengthVmservice
  8047  			}
  8048  			postIndex := iNdEx + intStringLen
  8049  			if postIndex < 0 {
  8050  				return ErrInvalidLengthVmservice
  8051  			}
  8052  			if postIndex > l {
  8053  				return io.ErrUnexpectedEOF
  8054  			}
  8055  			m.HostPath = string(dAtA[iNdEx:postIndex])
  8056  			iNdEx = postIndex
  8057  		case 2:
  8058  			if wireType != 0 {
  8059  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
  8060  			}
  8061  			m.Type = 0
  8062  			for shift := uint(0); ; shift += 7 {
  8063  				if shift >= 64 {
  8064  					return ErrIntOverflowVmservice
  8065  				}
  8066  				if iNdEx >= l {
  8067  					return io.ErrUnexpectedEOF
  8068  				}
  8069  				b := dAtA[iNdEx]
  8070  				iNdEx++
  8071  				m.Type |= DiskType(b&0x7F) << shift
  8072  				if b < 0x80 {
  8073  					break
  8074  				}
  8075  			}
  8076  		case 3:
  8077  			if wireType != 0 {
  8078  				return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
  8079  			}
  8080  			var v int
  8081  			for shift := uint(0); ; shift += 7 {
  8082  				if shift >= 64 {
  8083  					return ErrIntOverflowVmservice
  8084  				}
  8085  				if iNdEx >= l {
  8086  					return io.ErrUnexpectedEOF
  8087  				}
  8088  				b := dAtA[iNdEx]
  8089  				iNdEx++
  8090  				v |= int(b&0x7F) << shift
  8091  				if b < 0x80 {
  8092  					break
  8093  				}
  8094  			}
  8095  			m.ReadOnly = bool(v != 0)
  8096  		default:
  8097  			iNdEx = preIndex
  8098  			skippy, err := skipVmservice(dAtA[iNdEx:])
  8099  			if err != nil {
  8100  				return err
  8101  			}
  8102  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8103  				return ErrInvalidLengthVmservice
  8104  			}
  8105  			if (iNdEx + skippy) > l {
  8106  				return io.ErrUnexpectedEOF
  8107  			}
  8108  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  8109  			iNdEx += skippy
  8110  		}
  8111  	}
  8112  
  8113  	if iNdEx > l {
  8114  		return io.ErrUnexpectedEOF
  8115  	}
  8116  	return nil
  8117  }
  8118  func (m *NICConfig) Unmarshal(dAtA []byte) error {
  8119  	l := len(dAtA)
  8120  	iNdEx := 0
  8121  	for iNdEx < l {
  8122  		preIndex := iNdEx
  8123  		var wire uint64
  8124  		for shift := uint(0); ; shift += 7 {
  8125  			if shift >= 64 {
  8126  				return ErrIntOverflowVmservice
  8127  			}
  8128  			if iNdEx >= l {
  8129  				return io.ErrUnexpectedEOF
  8130  			}
  8131  			b := dAtA[iNdEx]
  8132  			iNdEx++
  8133  			wire |= uint64(b&0x7F) << shift
  8134  			if b < 0x80 {
  8135  				break
  8136  			}
  8137  		}
  8138  		fieldNum := int32(wire >> 3)
  8139  		wireType := int(wire & 0x7)
  8140  		if wireType == 4 {
  8141  			return fmt.Errorf("proto: NICConfig: wiretype end group for non-group")
  8142  		}
  8143  		if fieldNum <= 0 {
  8144  			return fmt.Errorf("proto: NICConfig: illegal tag %d (wire type %d)", fieldNum, wire)
  8145  		}
  8146  		switch fieldNum {
  8147  		case 1:
  8148  			if wireType != 2 {
  8149  				return fmt.Errorf("proto: wrong wireType = %d for field NicID", wireType)
  8150  			}
  8151  			var stringLen uint64
  8152  			for shift := uint(0); ; shift += 7 {
  8153  				if shift >= 64 {
  8154  					return ErrIntOverflowVmservice
  8155  				}
  8156  				if iNdEx >= l {
  8157  					return io.ErrUnexpectedEOF
  8158  				}
  8159  				b := dAtA[iNdEx]
  8160  				iNdEx++
  8161  				stringLen |= uint64(b&0x7F) << shift
  8162  				if b < 0x80 {
  8163  					break
  8164  				}
  8165  			}
  8166  			intStringLen := int(stringLen)
  8167  			if intStringLen < 0 {
  8168  				return ErrInvalidLengthVmservice
  8169  			}
  8170  			postIndex := iNdEx + intStringLen
  8171  			if postIndex < 0 {
  8172  				return ErrInvalidLengthVmservice
  8173  			}
  8174  			if postIndex > l {
  8175  				return io.ErrUnexpectedEOF
  8176  			}
  8177  			m.NicID = string(dAtA[iNdEx:postIndex])
  8178  			iNdEx = postIndex
  8179  		case 2:
  8180  			if wireType != 2 {
  8181  				return fmt.Errorf("proto: wrong wireType = %d for field PortID", wireType)
  8182  			}
  8183  			var stringLen uint64
  8184  			for shift := uint(0); ; shift += 7 {
  8185  				if shift >= 64 {
  8186  					return ErrIntOverflowVmservice
  8187  				}
  8188  				if iNdEx >= l {
  8189  					return io.ErrUnexpectedEOF
  8190  				}
  8191  				b := dAtA[iNdEx]
  8192  				iNdEx++
  8193  				stringLen |= uint64(b&0x7F) << shift
  8194  				if b < 0x80 {
  8195  					break
  8196  				}
  8197  			}
  8198  			intStringLen := int(stringLen)
  8199  			if intStringLen < 0 {
  8200  				return ErrInvalidLengthVmservice
  8201  			}
  8202  			postIndex := iNdEx + intStringLen
  8203  			if postIndex < 0 {
  8204  				return ErrInvalidLengthVmservice
  8205  			}
  8206  			if postIndex > l {
  8207  				return io.ErrUnexpectedEOF
  8208  			}
  8209  			m.PortID = string(dAtA[iNdEx:postIndex])
  8210  			iNdEx = postIndex
  8211  		case 3:
  8212  			if wireType != 2 {
  8213  				return fmt.Errorf("proto: wrong wireType = %d for field MacAddress", wireType)
  8214  			}
  8215  			var stringLen uint64
  8216  			for shift := uint(0); ; shift += 7 {
  8217  				if shift >= 64 {
  8218  					return ErrIntOverflowVmservice
  8219  				}
  8220  				if iNdEx >= l {
  8221  					return io.ErrUnexpectedEOF
  8222  				}
  8223  				b := dAtA[iNdEx]
  8224  				iNdEx++
  8225  				stringLen |= uint64(b&0x7F) << shift
  8226  				if b < 0x80 {
  8227  					break
  8228  				}
  8229  			}
  8230  			intStringLen := int(stringLen)
  8231  			if intStringLen < 0 {
  8232  				return ErrInvalidLengthVmservice
  8233  			}
  8234  			postIndex := iNdEx + intStringLen
  8235  			if postIndex < 0 {
  8236  				return ErrInvalidLengthVmservice
  8237  			}
  8238  			if postIndex > l {
  8239  				return io.ErrUnexpectedEOF
  8240  			}
  8241  			m.MacAddress = string(dAtA[iNdEx:postIndex])
  8242  			iNdEx = postIndex
  8243  		case 4:
  8244  			if wireType != 2 {
  8245  				return fmt.Errorf("proto: wrong wireType = %d for field SwitchID", wireType)
  8246  			}
  8247  			var stringLen uint64
  8248  			for shift := uint(0); ; shift += 7 {
  8249  				if shift >= 64 {
  8250  					return ErrIntOverflowVmservice
  8251  				}
  8252  				if iNdEx >= l {
  8253  					return io.ErrUnexpectedEOF
  8254  				}
  8255  				b := dAtA[iNdEx]
  8256  				iNdEx++
  8257  				stringLen |= uint64(b&0x7F) << shift
  8258  				if b < 0x80 {
  8259  					break
  8260  				}
  8261  			}
  8262  			intStringLen := int(stringLen)
  8263  			if intStringLen < 0 {
  8264  				return ErrInvalidLengthVmservice
  8265  			}
  8266  			postIndex := iNdEx + intStringLen
  8267  			if postIndex < 0 {
  8268  				return ErrInvalidLengthVmservice
  8269  			}
  8270  			if postIndex > l {
  8271  				return io.ErrUnexpectedEOF
  8272  			}
  8273  			m.SwitchID = string(dAtA[iNdEx:postIndex])
  8274  			iNdEx = postIndex
  8275  		case 5:
  8276  			if wireType != 2 {
  8277  				return fmt.Errorf("proto: wrong wireType = %d for field NicName", wireType)
  8278  			}
  8279  			var stringLen uint64
  8280  			for shift := uint(0); ; shift += 7 {
  8281  				if shift >= 64 {
  8282  					return ErrIntOverflowVmservice
  8283  				}
  8284  				if iNdEx >= l {
  8285  					return io.ErrUnexpectedEOF
  8286  				}
  8287  				b := dAtA[iNdEx]
  8288  				iNdEx++
  8289  				stringLen |= uint64(b&0x7F) << shift
  8290  				if b < 0x80 {
  8291  					break
  8292  				}
  8293  			}
  8294  			intStringLen := int(stringLen)
  8295  			if intStringLen < 0 {
  8296  				return ErrInvalidLengthVmservice
  8297  			}
  8298  			postIndex := iNdEx + intStringLen
  8299  			if postIndex < 0 {
  8300  				return ErrInvalidLengthVmservice
  8301  			}
  8302  			if postIndex > l {
  8303  				return io.ErrUnexpectedEOF
  8304  			}
  8305  			m.NicName = string(dAtA[iNdEx:postIndex])
  8306  			iNdEx = postIndex
  8307  		default:
  8308  			iNdEx = preIndex
  8309  			skippy, err := skipVmservice(dAtA[iNdEx:])
  8310  			if err != nil {
  8311  				return err
  8312  			}
  8313  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8314  				return ErrInvalidLengthVmservice
  8315  			}
  8316  			if (iNdEx + skippy) > l {
  8317  				return io.ErrUnexpectedEOF
  8318  			}
  8319  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  8320  			iNdEx += skippy
  8321  		}
  8322  	}
  8323  
  8324  	if iNdEx > l {
  8325  		return io.ErrUnexpectedEOF
  8326  	}
  8327  	return nil
  8328  }
  8329  func (m *WindowsPCIDevice) Unmarshal(dAtA []byte) error {
  8330  	l := len(dAtA)
  8331  	iNdEx := 0
  8332  	for iNdEx < l {
  8333  		preIndex := iNdEx
  8334  		var wire uint64
  8335  		for shift := uint(0); ; shift += 7 {
  8336  			if shift >= 64 {
  8337  				return ErrIntOverflowVmservice
  8338  			}
  8339  			if iNdEx >= l {
  8340  				return io.ErrUnexpectedEOF
  8341  			}
  8342  			b := dAtA[iNdEx]
  8343  			iNdEx++
  8344  			wire |= uint64(b&0x7F) << shift
  8345  			if b < 0x80 {
  8346  				break
  8347  			}
  8348  		}
  8349  		fieldNum := int32(wire >> 3)
  8350  		wireType := int(wire & 0x7)
  8351  		if wireType == 4 {
  8352  			return fmt.Errorf("proto: WindowsPCIDevice: wiretype end group for non-group")
  8353  		}
  8354  		if fieldNum <= 0 {
  8355  			return fmt.Errorf("proto: WindowsPCIDevice: illegal tag %d (wire type %d)", fieldNum, wire)
  8356  		}
  8357  		switch fieldNum {
  8358  		case 1:
  8359  			if wireType != 2 {
  8360  				return fmt.Errorf("proto: wrong wireType = %d for field InstanceID", wireType)
  8361  			}
  8362  			var stringLen uint64
  8363  			for shift := uint(0); ; shift += 7 {
  8364  				if shift >= 64 {
  8365  					return ErrIntOverflowVmservice
  8366  				}
  8367  				if iNdEx >= l {
  8368  					return io.ErrUnexpectedEOF
  8369  				}
  8370  				b := dAtA[iNdEx]
  8371  				iNdEx++
  8372  				stringLen |= uint64(b&0x7F) << shift
  8373  				if b < 0x80 {
  8374  					break
  8375  				}
  8376  			}
  8377  			intStringLen := int(stringLen)
  8378  			if intStringLen < 0 {
  8379  				return ErrInvalidLengthVmservice
  8380  			}
  8381  			postIndex := iNdEx + intStringLen
  8382  			if postIndex < 0 {
  8383  				return ErrInvalidLengthVmservice
  8384  			}
  8385  			if postIndex > l {
  8386  				return io.ErrUnexpectedEOF
  8387  			}
  8388  			m.InstanceID = string(dAtA[iNdEx:postIndex])
  8389  			iNdEx = postIndex
  8390  		default:
  8391  			iNdEx = preIndex
  8392  			skippy, err := skipVmservice(dAtA[iNdEx:])
  8393  			if err != nil {
  8394  				return err
  8395  			}
  8396  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8397  				return ErrInvalidLengthVmservice
  8398  			}
  8399  			if (iNdEx + skippy) > l {
  8400  				return io.ErrUnexpectedEOF
  8401  			}
  8402  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  8403  			iNdEx += skippy
  8404  		}
  8405  	}
  8406  
  8407  	if iNdEx > l {
  8408  		return io.ErrUnexpectedEOF
  8409  	}
  8410  	return nil
  8411  }
  8412  func (m *ModifyMemoryRequest) Unmarshal(dAtA []byte) error {
  8413  	l := len(dAtA)
  8414  	iNdEx := 0
  8415  	for iNdEx < l {
  8416  		preIndex := iNdEx
  8417  		var wire uint64
  8418  		for shift := uint(0); ; shift += 7 {
  8419  			if shift >= 64 {
  8420  				return ErrIntOverflowVmservice
  8421  			}
  8422  			if iNdEx >= l {
  8423  				return io.ErrUnexpectedEOF
  8424  			}
  8425  			b := dAtA[iNdEx]
  8426  			iNdEx++
  8427  			wire |= uint64(b&0x7F) << shift
  8428  			if b < 0x80 {
  8429  				break
  8430  			}
  8431  		}
  8432  		fieldNum := int32(wire >> 3)
  8433  		wireType := int(wire & 0x7)
  8434  		if wireType == 4 {
  8435  			return fmt.Errorf("proto: ModifyMemoryRequest: wiretype end group for non-group")
  8436  		}
  8437  		if fieldNum <= 0 {
  8438  			return fmt.Errorf("proto: ModifyMemoryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  8439  		}
  8440  		switch fieldNum {
  8441  		case 1:
  8442  			if wireType != 0 {
  8443  				return fmt.Errorf("proto: wrong wireType = %d for field MemoryMb", wireType)
  8444  			}
  8445  			m.MemoryMb = 0
  8446  			for shift := uint(0); ; shift += 7 {
  8447  				if shift >= 64 {
  8448  					return ErrIntOverflowVmservice
  8449  				}
  8450  				if iNdEx >= l {
  8451  					return io.ErrUnexpectedEOF
  8452  				}
  8453  				b := dAtA[iNdEx]
  8454  				iNdEx++
  8455  				m.MemoryMb |= uint64(b&0x7F) << shift
  8456  				if b < 0x80 {
  8457  					break
  8458  				}
  8459  			}
  8460  		default:
  8461  			iNdEx = preIndex
  8462  			skippy, err := skipVmservice(dAtA[iNdEx:])
  8463  			if err != nil {
  8464  				return err
  8465  			}
  8466  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8467  				return ErrInvalidLengthVmservice
  8468  			}
  8469  			if (iNdEx + skippy) > l {
  8470  				return io.ErrUnexpectedEOF
  8471  			}
  8472  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  8473  			iNdEx += skippy
  8474  		}
  8475  	}
  8476  
  8477  	if iNdEx > l {
  8478  		return io.ErrUnexpectedEOF
  8479  	}
  8480  	return nil
  8481  }
  8482  func (m *ModifyProcessorRequest) Unmarshal(dAtA []byte) error {
  8483  	l := len(dAtA)
  8484  	iNdEx := 0
  8485  	for iNdEx < l {
  8486  		preIndex := iNdEx
  8487  		var wire uint64
  8488  		for shift := uint(0); ; shift += 7 {
  8489  			if shift >= 64 {
  8490  				return ErrIntOverflowVmservice
  8491  			}
  8492  			if iNdEx >= l {
  8493  				return io.ErrUnexpectedEOF
  8494  			}
  8495  			b := dAtA[iNdEx]
  8496  			iNdEx++
  8497  			wire |= uint64(b&0x7F) << shift
  8498  			if b < 0x80 {
  8499  				break
  8500  			}
  8501  		}
  8502  		fieldNum := int32(wire >> 3)
  8503  		wireType := int(wire & 0x7)
  8504  		if wireType == 4 {
  8505  			return fmt.Errorf("proto: ModifyProcessorRequest: wiretype end group for non-group")
  8506  		}
  8507  		if fieldNum <= 0 {
  8508  			return fmt.Errorf("proto: ModifyProcessorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  8509  		}
  8510  		switch fieldNum {
  8511  		case 1:
  8512  			if wireType != 0 {
  8513  				return fmt.Errorf("proto: wrong wireType = %d for field ProcessorIndex", wireType)
  8514  			}
  8515  			m.ProcessorIndex = 0
  8516  			for shift := uint(0); ; shift += 7 {
  8517  				if shift >= 64 {
  8518  					return ErrIntOverflowVmservice
  8519  				}
  8520  				if iNdEx >= l {
  8521  					return io.ErrUnexpectedEOF
  8522  				}
  8523  				b := dAtA[iNdEx]
  8524  				iNdEx++
  8525  				m.ProcessorIndex |= uint32(b&0x7F) << shift
  8526  				if b < 0x80 {
  8527  					break
  8528  				}
  8529  			}
  8530  		default:
  8531  			iNdEx = preIndex
  8532  			skippy, err := skipVmservice(dAtA[iNdEx:])
  8533  			if err != nil {
  8534  				return err
  8535  			}
  8536  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8537  				return ErrInvalidLengthVmservice
  8538  			}
  8539  			if (iNdEx + skippy) > l {
  8540  				return io.ErrUnexpectedEOF
  8541  			}
  8542  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  8543  			iNdEx += skippy
  8544  		}
  8545  	}
  8546  
  8547  	if iNdEx > l {
  8548  		return io.ErrUnexpectedEOF
  8549  	}
  8550  	return nil
  8551  }
  8552  func (m *ModifyProcessorConfigRequest) Unmarshal(dAtA []byte) error {
  8553  	l := len(dAtA)
  8554  	iNdEx := 0
  8555  	for iNdEx < l {
  8556  		preIndex := iNdEx
  8557  		var wire uint64
  8558  		for shift := uint(0); ; shift += 7 {
  8559  			if shift >= 64 {
  8560  				return ErrIntOverflowVmservice
  8561  			}
  8562  			if iNdEx >= l {
  8563  				return io.ErrUnexpectedEOF
  8564  			}
  8565  			b := dAtA[iNdEx]
  8566  			iNdEx++
  8567  			wire |= uint64(b&0x7F) << shift
  8568  			if b < 0x80 {
  8569  				break
  8570  			}
  8571  		}
  8572  		fieldNum := int32(wire >> 3)
  8573  		wireType := int(wire & 0x7)
  8574  		if wireType == 4 {
  8575  			return fmt.Errorf("proto: ModifyProcessorConfigRequest: wiretype end group for non-group")
  8576  		}
  8577  		if fieldNum <= 0 {
  8578  			return fmt.Errorf("proto: ModifyProcessorConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  8579  		}
  8580  		switch fieldNum {
  8581  		case 1:
  8582  			if wireType != 0 {
  8583  				return fmt.Errorf("proto: wrong wireType = %d for field ProcessorWeight", wireType)
  8584  			}
  8585  			m.ProcessorWeight = 0
  8586  			for shift := uint(0); ; shift += 7 {
  8587  				if shift >= 64 {
  8588  					return ErrIntOverflowVmservice
  8589  				}
  8590  				if iNdEx >= l {
  8591  					return io.ErrUnexpectedEOF
  8592  				}
  8593  				b := dAtA[iNdEx]
  8594  				iNdEx++
  8595  				m.ProcessorWeight |= uint32(b&0x7F) << shift
  8596  				if b < 0x80 {
  8597  					break
  8598  				}
  8599  			}
  8600  		case 2:
  8601  			if wireType != 0 {
  8602  				return fmt.Errorf("proto: wrong wireType = %d for field ProcessorLimit", wireType)
  8603  			}
  8604  			m.ProcessorLimit = 0
  8605  			for shift := uint(0); ; shift += 7 {
  8606  				if shift >= 64 {
  8607  					return ErrIntOverflowVmservice
  8608  				}
  8609  				if iNdEx >= l {
  8610  					return io.ErrUnexpectedEOF
  8611  				}
  8612  				b := dAtA[iNdEx]
  8613  				iNdEx++
  8614  				m.ProcessorLimit |= uint32(b&0x7F) << shift
  8615  				if b < 0x80 {
  8616  					break
  8617  				}
  8618  			}
  8619  		default:
  8620  			iNdEx = preIndex
  8621  			skippy, err := skipVmservice(dAtA[iNdEx:])
  8622  			if err != nil {
  8623  				return err
  8624  			}
  8625  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8626  				return ErrInvalidLengthVmservice
  8627  			}
  8628  			if (iNdEx + skippy) > l {
  8629  				return io.ErrUnexpectedEOF
  8630  			}
  8631  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  8632  			iNdEx += skippy
  8633  		}
  8634  	}
  8635  
  8636  	if iNdEx > l {
  8637  		return io.ErrUnexpectedEOF
  8638  	}
  8639  	return nil
  8640  }
  8641  func (m *ModifyResourceRequest) Unmarshal(dAtA []byte) error {
  8642  	l := len(dAtA)
  8643  	iNdEx := 0
  8644  	for iNdEx < l {
  8645  		preIndex := iNdEx
  8646  		var wire uint64
  8647  		for shift := uint(0); ; shift += 7 {
  8648  			if shift >= 64 {
  8649  				return ErrIntOverflowVmservice
  8650  			}
  8651  			if iNdEx >= l {
  8652  				return io.ErrUnexpectedEOF
  8653  			}
  8654  			b := dAtA[iNdEx]
  8655  			iNdEx++
  8656  			wire |= uint64(b&0x7F) << shift
  8657  			if b < 0x80 {
  8658  				break
  8659  			}
  8660  		}
  8661  		fieldNum := int32(wire >> 3)
  8662  		wireType := int(wire & 0x7)
  8663  		if wireType == 4 {
  8664  			return fmt.Errorf("proto: ModifyResourceRequest: wiretype end group for non-group")
  8665  		}
  8666  		if fieldNum <= 0 {
  8667  			return fmt.Errorf("proto: ModifyResourceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  8668  		}
  8669  		switch fieldNum {
  8670  		case 1:
  8671  			if wireType != 0 {
  8672  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
  8673  			}
  8674  			m.Type = 0
  8675  			for shift := uint(0); ; shift += 7 {
  8676  				if shift >= 64 {
  8677  					return ErrIntOverflowVmservice
  8678  				}
  8679  				if iNdEx >= l {
  8680  					return io.ErrUnexpectedEOF
  8681  				}
  8682  				b := dAtA[iNdEx]
  8683  				iNdEx++
  8684  				m.Type |= ModifyType(b&0x7F) << shift
  8685  				if b < 0x80 {
  8686  					break
  8687  				}
  8688  			}
  8689  		case 2:
  8690  			if wireType != 2 {
  8691  				return fmt.Errorf("proto: wrong wireType = %d for field Processor", wireType)
  8692  			}
  8693  			var msglen int
  8694  			for shift := uint(0); ; shift += 7 {
  8695  				if shift >= 64 {
  8696  					return ErrIntOverflowVmservice
  8697  				}
  8698  				if iNdEx >= l {
  8699  					return io.ErrUnexpectedEOF
  8700  				}
  8701  				b := dAtA[iNdEx]
  8702  				iNdEx++
  8703  				msglen |= int(b&0x7F) << shift
  8704  				if b < 0x80 {
  8705  					break
  8706  				}
  8707  			}
  8708  			if msglen < 0 {
  8709  				return ErrInvalidLengthVmservice
  8710  			}
  8711  			postIndex := iNdEx + msglen
  8712  			if postIndex < 0 {
  8713  				return ErrInvalidLengthVmservice
  8714  			}
  8715  			if postIndex > l {
  8716  				return io.ErrUnexpectedEOF
  8717  			}
  8718  			v := &ModifyProcessorRequest{}
  8719  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  8720  				return err
  8721  			}
  8722  			m.Resource = &ModifyResourceRequest_Processor{v}
  8723  			iNdEx = postIndex
  8724  		case 3:
  8725  			if wireType != 2 {
  8726  				return fmt.Errorf("proto: wrong wireType = %d for field ProcessorConfig", wireType)
  8727  			}
  8728  			var msglen int
  8729  			for shift := uint(0); ; shift += 7 {
  8730  				if shift >= 64 {
  8731  					return ErrIntOverflowVmservice
  8732  				}
  8733  				if iNdEx >= l {
  8734  					return io.ErrUnexpectedEOF
  8735  				}
  8736  				b := dAtA[iNdEx]
  8737  				iNdEx++
  8738  				msglen |= int(b&0x7F) << shift
  8739  				if b < 0x80 {
  8740  					break
  8741  				}
  8742  			}
  8743  			if msglen < 0 {
  8744  				return ErrInvalidLengthVmservice
  8745  			}
  8746  			postIndex := iNdEx + msglen
  8747  			if postIndex < 0 {
  8748  				return ErrInvalidLengthVmservice
  8749  			}
  8750  			if postIndex > l {
  8751  				return io.ErrUnexpectedEOF
  8752  			}
  8753  			v := &ModifyProcessorConfigRequest{}
  8754  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  8755  				return err
  8756  			}
  8757  			m.Resource = &ModifyResourceRequest_ProcessorConfig{v}
  8758  			iNdEx = postIndex
  8759  		case 4:
  8760  			if wireType != 2 {
  8761  				return fmt.Errorf("proto: wrong wireType = %d for field Memory", wireType)
  8762  			}
  8763  			var msglen int
  8764  			for shift := uint(0); ; shift += 7 {
  8765  				if shift >= 64 {
  8766  					return ErrIntOverflowVmservice
  8767  				}
  8768  				if iNdEx >= l {
  8769  					return io.ErrUnexpectedEOF
  8770  				}
  8771  				b := dAtA[iNdEx]
  8772  				iNdEx++
  8773  				msglen |= int(b&0x7F) << shift
  8774  				if b < 0x80 {
  8775  					break
  8776  				}
  8777  			}
  8778  			if msglen < 0 {
  8779  				return ErrInvalidLengthVmservice
  8780  			}
  8781  			postIndex := iNdEx + msglen
  8782  			if postIndex < 0 {
  8783  				return ErrInvalidLengthVmservice
  8784  			}
  8785  			if postIndex > l {
  8786  				return io.ErrUnexpectedEOF
  8787  			}
  8788  			v := &ModifyMemoryRequest{}
  8789  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  8790  				return err
  8791  			}
  8792  			m.Resource = &ModifyResourceRequest_Memory{v}
  8793  			iNdEx = postIndex
  8794  		case 5:
  8795  			if wireType != 2 {
  8796  				return fmt.Errorf("proto: wrong wireType = %d for field ScsiDisk", wireType)
  8797  			}
  8798  			var msglen int
  8799  			for shift := uint(0); ; shift += 7 {
  8800  				if shift >= 64 {
  8801  					return ErrIntOverflowVmservice
  8802  				}
  8803  				if iNdEx >= l {
  8804  					return io.ErrUnexpectedEOF
  8805  				}
  8806  				b := dAtA[iNdEx]
  8807  				iNdEx++
  8808  				msglen |= int(b&0x7F) << shift
  8809  				if b < 0x80 {
  8810  					break
  8811  				}
  8812  			}
  8813  			if msglen < 0 {
  8814  				return ErrInvalidLengthVmservice
  8815  			}
  8816  			postIndex := iNdEx + msglen
  8817  			if postIndex < 0 {
  8818  				return ErrInvalidLengthVmservice
  8819  			}
  8820  			if postIndex > l {
  8821  				return io.ErrUnexpectedEOF
  8822  			}
  8823  			v := &SCSIDisk{}
  8824  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  8825  				return err
  8826  			}
  8827  			m.Resource = &ModifyResourceRequest_ScsiDisk{v}
  8828  			iNdEx = postIndex
  8829  		case 6:
  8830  			if wireType != 2 {
  8831  				return fmt.Errorf("proto: wrong wireType = %d for field VpmemDisk", wireType)
  8832  			}
  8833  			var msglen int
  8834  			for shift := uint(0); ; shift += 7 {
  8835  				if shift >= 64 {
  8836  					return ErrIntOverflowVmservice
  8837  				}
  8838  				if iNdEx >= l {
  8839  					return io.ErrUnexpectedEOF
  8840  				}
  8841  				b := dAtA[iNdEx]
  8842  				iNdEx++
  8843  				msglen |= int(b&0x7F) << shift
  8844  				if b < 0x80 {
  8845  					break
  8846  				}
  8847  			}
  8848  			if msglen < 0 {
  8849  				return ErrInvalidLengthVmservice
  8850  			}
  8851  			postIndex := iNdEx + msglen
  8852  			if postIndex < 0 {
  8853  				return ErrInvalidLengthVmservice
  8854  			}
  8855  			if postIndex > l {
  8856  				return io.ErrUnexpectedEOF
  8857  			}
  8858  			v := &VPMEMDisk{}
  8859  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  8860  				return err
  8861  			}
  8862  			m.Resource = &ModifyResourceRequest_VpmemDisk{v}
  8863  			iNdEx = postIndex
  8864  		case 7:
  8865  			if wireType != 2 {
  8866  				return fmt.Errorf("proto: wrong wireType = %d for field NicConfig", wireType)
  8867  			}
  8868  			var msglen int
  8869  			for shift := uint(0); ; shift += 7 {
  8870  				if shift >= 64 {
  8871  					return ErrIntOverflowVmservice
  8872  				}
  8873  				if iNdEx >= l {
  8874  					return io.ErrUnexpectedEOF
  8875  				}
  8876  				b := dAtA[iNdEx]
  8877  				iNdEx++
  8878  				msglen |= int(b&0x7F) << shift
  8879  				if b < 0x80 {
  8880  					break
  8881  				}
  8882  			}
  8883  			if msglen < 0 {
  8884  				return ErrInvalidLengthVmservice
  8885  			}
  8886  			postIndex := iNdEx + msglen
  8887  			if postIndex < 0 {
  8888  				return ErrInvalidLengthVmservice
  8889  			}
  8890  			if postIndex > l {
  8891  				return io.ErrUnexpectedEOF
  8892  			}
  8893  			v := &NICConfig{}
  8894  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  8895  				return err
  8896  			}
  8897  			m.Resource = &ModifyResourceRequest_NicConfig{v}
  8898  			iNdEx = postIndex
  8899  		case 8:
  8900  			if wireType != 2 {
  8901  				return fmt.Errorf("proto: wrong wireType = %d for field WindowsDevice", wireType)
  8902  			}
  8903  			var msglen int
  8904  			for shift := uint(0); ; shift += 7 {
  8905  				if shift >= 64 {
  8906  					return ErrIntOverflowVmservice
  8907  				}
  8908  				if iNdEx >= l {
  8909  					return io.ErrUnexpectedEOF
  8910  				}
  8911  				b := dAtA[iNdEx]
  8912  				iNdEx++
  8913  				msglen |= int(b&0x7F) << shift
  8914  				if b < 0x80 {
  8915  					break
  8916  				}
  8917  			}
  8918  			if msglen < 0 {
  8919  				return ErrInvalidLengthVmservice
  8920  			}
  8921  			postIndex := iNdEx + msglen
  8922  			if postIndex < 0 {
  8923  				return ErrInvalidLengthVmservice
  8924  			}
  8925  			if postIndex > l {
  8926  				return io.ErrUnexpectedEOF
  8927  			}
  8928  			v := &WindowsPCIDevice{}
  8929  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  8930  				return err
  8931  			}
  8932  			m.Resource = &ModifyResourceRequest_WindowsDevice{v}
  8933  			iNdEx = postIndex
  8934  		default:
  8935  			iNdEx = preIndex
  8936  			skippy, err := skipVmservice(dAtA[iNdEx:])
  8937  			if err != nil {
  8938  				return err
  8939  			}
  8940  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8941  				return ErrInvalidLengthVmservice
  8942  			}
  8943  			if (iNdEx + skippy) > l {
  8944  				return io.ErrUnexpectedEOF
  8945  			}
  8946  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  8947  			iNdEx += skippy
  8948  		}
  8949  	}
  8950  
  8951  	if iNdEx > l {
  8952  		return io.ErrUnexpectedEOF
  8953  	}
  8954  	return nil
  8955  }
  8956  func skipVmservice(dAtA []byte) (n int, err error) {
  8957  	l := len(dAtA)
  8958  	iNdEx := 0
  8959  	depth := 0
  8960  	for iNdEx < l {
  8961  		var wire uint64
  8962  		for shift := uint(0); ; shift += 7 {
  8963  			if shift >= 64 {
  8964  				return 0, ErrIntOverflowVmservice
  8965  			}
  8966  			if iNdEx >= l {
  8967  				return 0, io.ErrUnexpectedEOF
  8968  			}
  8969  			b := dAtA[iNdEx]
  8970  			iNdEx++
  8971  			wire |= (uint64(b) & 0x7F) << shift
  8972  			if b < 0x80 {
  8973  				break
  8974  			}
  8975  		}
  8976  		wireType := int(wire & 0x7)
  8977  		switch wireType {
  8978  		case 0:
  8979  			for shift := uint(0); ; shift += 7 {
  8980  				if shift >= 64 {
  8981  					return 0, ErrIntOverflowVmservice
  8982  				}
  8983  				if iNdEx >= l {
  8984  					return 0, io.ErrUnexpectedEOF
  8985  				}
  8986  				iNdEx++
  8987  				if dAtA[iNdEx-1] < 0x80 {
  8988  					break
  8989  				}
  8990  			}
  8991  		case 1:
  8992  			iNdEx += 8
  8993  		case 2:
  8994  			var length int
  8995  			for shift := uint(0); ; shift += 7 {
  8996  				if shift >= 64 {
  8997  					return 0, ErrIntOverflowVmservice
  8998  				}
  8999  				if iNdEx >= l {
  9000  					return 0, io.ErrUnexpectedEOF
  9001  				}
  9002  				b := dAtA[iNdEx]
  9003  				iNdEx++
  9004  				length |= (int(b) & 0x7F) << shift
  9005  				if b < 0x80 {
  9006  					break
  9007  				}
  9008  			}
  9009  			if length < 0 {
  9010  				return 0, ErrInvalidLengthVmservice
  9011  			}
  9012  			iNdEx += length
  9013  		case 3:
  9014  			depth++
  9015  		case 4:
  9016  			if depth == 0 {
  9017  				return 0, ErrUnexpectedEndOfGroupVmservice
  9018  			}
  9019  			depth--
  9020  		case 5:
  9021  			iNdEx += 4
  9022  		default:
  9023  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  9024  		}
  9025  		if iNdEx < 0 {
  9026  			return 0, ErrInvalidLengthVmservice
  9027  		}
  9028  		if depth == 0 {
  9029  			return iNdEx, nil
  9030  		}
  9031  	}
  9032  	return 0, io.ErrUnexpectedEOF
  9033  }
  9034  
  9035  var (
  9036  	ErrInvalidLengthVmservice        = fmt.Errorf("proto: negative length found during unmarshaling")
  9037  	ErrIntOverflowVmservice          = fmt.Errorf("proto: integer overflow")
  9038  	ErrUnexpectedEndOfGroupVmservice = fmt.Errorf("proto: unexpected end of group")
  9039  )
  9040  

View as plain text