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

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

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: github.com/Microsoft/hcsshim/internal/shimdiag/shimdiag.proto
     3  
     4  package shimdiag
     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  	io "io"
    12  	math "math"
    13  	math_bits "math/bits"
    14  	reflect "reflect"
    15  	strings "strings"
    16  )
    17  
    18  // Reference imports to suppress errors if they are not otherwise used.
    19  var _ = proto.Marshal
    20  var _ = fmt.Errorf
    21  var _ = math.Inf
    22  
    23  // This is a compile-time assertion to ensure that this generated file
    24  // is compatible with the proto package it is being compiled against.
    25  // A compilation error at this line likely means your copy of the
    26  // proto package needs to be updated.
    27  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    28  
    29  type ExecProcessRequest struct {
    30  	Args                 []string `protobuf:"bytes,1,rep,name=args,proto3" json:"args,omitempty"`
    31  	Workdir              string   `protobuf:"bytes,2,opt,name=workdir,proto3" json:"workdir,omitempty"`
    32  	Terminal             bool     `protobuf:"varint,3,opt,name=terminal,proto3" json:"terminal,omitempty"`
    33  	Stdin                string   `protobuf:"bytes,4,opt,name=stdin,proto3" json:"stdin,omitempty"`
    34  	Stdout               string   `protobuf:"bytes,5,opt,name=stdout,proto3" json:"stdout,omitempty"`
    35  	Stderr               string   `protobuf:"bytes,6,opt,name=stderr,proto3" json:"stderr,omitempty"`
    36  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
    37  	XXX_unrecognized     []byte   `json:"-"`
    38  	XXX_sizecache        int32    `json:"-"`
    39  }
    40  
    41  func (m *ExecProcessRequest) Reset()      { *m = ExecProcessRequest{} }
    42  func (*ExecProcessRequest) ProtoMessage() {}
    43  func (*ExecProcessRequest) Descriptor() ([]byte, []int) {
    44  	return fileDescriptor_c7933dc6ffbb8784, []int{0}
    45  }
    46  func (m *ExecProcessRequest) XXX_Unmarshal(b []byte) error {
    47  	return m.Unmarshal(b)
    48  }
    49  func (m *ExecProcessRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    50  	if deterministic {
    51  		return xxx_messageInfo_ExecProcessRequest.Marshal(b, m, deterministic)
    52  	} else {
    53  		b = b[:cap(b)]
    54  		n, err := m.MarshalToSizedBuffer(b)
    55  		if err != nil {
    56  			return nil, err
    57  		}
    58  		return b[:n], nil
    59  	}
    60  }
    61  func (m *ExecProcessRequest) XXX_Merge(src proto.Message) {
    62  	xxx_messageInfo_ExecProcessRequest.Merge(m, src)
    63  }
    64  func (m *ExecProcessRequest) XXX_Size() int {
    65  	return m.Size()
    66  }
    67  func (m *ExecProcessRequest) XXX_DiscardUnknown() {
    68  	xxx_messageInfo_ExecProcessRequest.DiscardUnknown(m)
    69  }
    70  
    71  var xxx_messageInfo_ExecProcessRequest proto.InternalMessageInfo
    72  
    73  type ExecProcessResponse struct {
    74  	ExitCode             int32    `protobuf:"varint,1,opt,name=exit_code,json=exitCode,proto3" json:"exit_code,omitempty"`
    75  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
    76  	XXX_unrecognized     []byte   `json:"-"`
    77  	XXX_sizecache        int32    `json:"-"`
    78  }
    79  
    80  func (m *ExecProcessResponse) Reset()      { *m = ExecProcessResponse{} }
    81  func (*ExecProcessResponse) ProtoMessage() {}
    82  func (*ExecProcessResponse) Descriptor() ([]byte, []int) {
    83  	return fileDescriptor_c7933dc6ffbb8784, []int{1}
    84  }
    85  func (m *ExecProcessResponse) XXX_Unmarshal(b []byte) error {
    86  	return m.Unmarshal(b)
    87  }
    88  func (m *ExecProcessResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    89  	if deterministic {
    90  		return xxx_messageInfo_ExecProcessResponse.Marshal(b, m, deterministic)
    91  	} else {
    92  		b = b[:cap(b)]
    93  		n, err := m.MarshalToSizedBuffer(b)
    94  		if err != nil {
    95  			return nil, err
    96  		}
    97  		return b[:n], nil
    98  	}
    99  }
   100  func (m *ExecProcessResponse) XXX_Merge(src proto.Message) {
   101  	xxx_messageInfo_ExecProcessResponse.Merge(m, src)
   102  }
   103  func (m *ExecProcessResponse) XXX_Size() int {
   104  	return m.Size()
   105  }
   106  func (m *ExecProcessResponse) XXX_DiscardUnknown() {
   107  	xxx_messageInfo_ExecProcessResponse.DiscardUnknown(m)
   108  }
   109  
   110  var xxx_messageInfo_ExecProcessResponse proto.InternalMessageInfo
   111  
   112  type StacksRequest struct {
   113  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   114  	XXX_unrecognized     []byte   `json:"-"`
   115  	XXX_sizecache        int32    `json:"-"`
   116  }
   117  
   118  func (m *StacksRequest) Reset()      { *m = StacksRequest{} }
   119  func (*StacksRequest) ProtoMessage() {}
   120  func (*StacksRequest) Descriptor() ([]byte, []int) {
   121  	return fileDescriptor_c7933dc6ffbb8784, []int{2}
   122  }
   123  func (m *StacksRequest) XXX_Unmarshal(b []byte) error {
   124  	return m.Unmarshal(b)
   125  }
   126  func (m *StacksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   127  	if deterministic {
   128  		return xxx_messageInfo_StacksRequest.Marshal(b, m, deterministic)
   129  	} else {
   130  		b = b[:cap(b)]
   131  		n, err := m.MarshalToSizedBuffer(b)
   132  		if err != nil {
   133  			return nil, err
   134  		}
   135  		return b[:n], nil
   136  	}
   137  }
   138  func (m *StacksRequest) XXX_Merge(src proto.Message) {
   139  	xxx_messageInfo_StacksRequest.Merge(m, src)
   140  }
   141  func (m *StacksRequest) XXX_Size() int {
   142  	return m.Size()
   143  }
   144  func (m *StacksRequest) XXX_DiscardUnknown() {
   145  	xxx_messageInfo_StacksRequest.DiscardUnknown(m)
   146  }
   147  
   148  var xxx_messageInfo_StacksRequest proto.InternalMessageInfo
   149  
   150  type StacksResponse struct {
   151  	Stacks               string   `protobuf:"bytes,1,opt,name=stacks,proto3" json:"stacks,omitempty"`
   152  	GuestStacks          string   `protobuf:"bytes,2,opt,name=guest_stacks,json=guestStacks,proto3" json:"guest_stacks,omitempty"`
   153  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   154  	XXX_unrecognized     []byte   `json:"-"`
   155  	XXX_sizecache        int32    `json:"-"`
   156  }
   157  
   158  func (m *StacksResponse) Reset()      { *m = StacksResponse{} }
   159  func (*StacksResponse) ProtoMessage() {}
   160  func (*StacksResponse) Descriptor() ([]byte, []int) {
   161  	return fileDescriptor_c7933dc6ffbb8784, []int{3}
   162  }
   163  func (m *StacksResponse) XXX_Unmarshal(b []byte) error {
   164  	return m.Unmarshal(b)
   165  }
   166  func (m *StacksResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   167  	if deterministic {
   168  		return xxx_messageInfo_StacksResponse.Marshal(b, m, deterministic)
   169  	} else {
   170  		b = b[:cap(b)]
   171  		n, err := m.MarshalToSizedBuffer(b)
   172  		if err != nil {
   173  			return nil, err
   174  		}
   175  		return b[:n], nil
   176  	}
   177  }
   178  func (m *StacksResponse) XXX_Merge(src proto.Message) {
   179  	xxx_messageInfo_StacksResponse.Merge(m, src)
   180  }
   181  func (m *StacksResponse) XXX_Size() int {
   182  	return m.Size()
   183  }
   184  func (m *StacksResponse) XXX_DiscardUnknown() {
   185  	xxx_messageInfo_StacksResponse.DiscardUnknown(m)
   186  }
   187  
   188  var xxx_messageInfo_StacksResponse proto.InternalMessageInfo
   189  
   190  type ShareRequest struct {
   191  	HostPath             string   `protobuf:"bytes,1,opt,name=host_path,json=hostPath,proto3" json:"host_path,omitempty"`
   192  	UvmPath              string   `protobuf:"bytes,2,opt,name=uvm_path,json=uvmPath,proto3" json:"uvm_path,omitempty"`
   193  	ReadOnly             bool     `protobuf:"varint,3,opt,name=read_only,json=readOnly,proto3" json:"read_only,omitempty"`
   194  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   195  	XXX_unrecognized     []byte   `json:"-"`
   196  	XXX_sizecache        int32    `json:"-"`
   197  }
   198  
   199  func (m *ShareRequest) Reset()      { *m = ShareRequest{} }
   200  func (*ShareRequest) ProtoMessage() {}
   201  func (*ShareRequest) Descriptor() ([]byte, []int) {
   202  	return fileDescriptor_c7933dc6ffbb8784, []int{4}
   203  }
   204  func (m *ShareRequest) XXX_Unmarshal(b []byte) error {
   205  	return m.Unmarshal(b)
   206  }
   207  func (m *ShareRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   208  	if deterministic {
   209  		return xxx_messageInfo_ShareRequest.Marshal(b, m, deterministic)
   210  	} else {
   211  		b = b[:cap(b)]
   212  		n, err := m.MarshalToSizedBuffer(b)
   213  		if err != nil {
   214  			return nil, err
   215  		}
   216  		return b[:n], nil
   217  	}
   218  }
   219  func (m *ShareRequest) XXX_Merge(src proto.Message) {
   220  	xxx_messageInfo_ShareRequest.Merge(m, src)
   221  }
   222  func (m *ShareRequest) XXX_Size() int {
   223  	return m.Size()
   224  }
   225  func (m *ShareRequest) XXX_DiscardUnknown() {
   226  	xxx_messageInfo_ShareRequest.DiscardUnknown(m)
   227  }
   228  
   229  var xxx_messageInfo_ShareRequest proto.InternalMessageInfo
   230  
   231  type ShareResponse struct {
   232  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   233  	XXX_unrecognized     []byte   `json:"-"`
   234  	XXX_sizecache        int32    `json:"-"`
   235  }
   236  
   237  func (m *ShareResponse) Reset()      { *m = ShareResponse{} }
   238  func (*ShareResponse) ProtoMessage() {}
   239  func (*ShareResponse) Descriptor() ([]byte, []int) {
   240  	return fileDescriptor_c7933dc6ffbb8784, []int{5}
   241  }
   242  func (m *ShareResponse) XXX_Unmarshal(b []byte) error {
   243  	return m.Unmarshal(b)
   244  }
   245  func (m *ShareResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   246  	if deterministic {
   247  		return xxx_messageInfo_ShareResponse.Marshal(b, m, deterministic)
   248  	} else {
   249  		b = b[:cap(b)]
   250  		n, err := m.MarshalToSizedBuffer(b)
   251  		if err != nil {
   252  			return nil, err
   253  		}
   254  		return b[:n], nil
   255  	}
   256  }
   257  func (m *ShareResponse) XXX_Merge(src proto.Message) {
   258  	xxx_messageInfo_ShareResponse.Merge(m, src)
   259  }
   260  func (m *ShareResponse) XXX_Size() int {
   261  	return m.Size()
   262  }
   263  func (m *ShareResponse) XXX_DiscardUnknown() {
   264  	xxx_messageInfo_ShareResponse.DiscardUnknown(m)
   265  }
   266  
   267  var xxx_messageInfo_ShareResponse proto.InternalMessageInfo
   268  
   269  type PidRequest struct {
   270  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   271  	XXX_unrecognized     []byte   `json:"-"`
   272  	XXX_sizecache        int32    `json:"-"`
   273  }
   274  
   275  func (m *PidRequest) Reset()      { *m = PidRequest{} }
   276  func (*PidRequest) ProtoMessage() {}
   277  func (*PidRequest) Descriptor() ([]byte, []int) {
   278  	return fileDescriptor_c7933dc6ffbb8784, []int{6}
   279  }
   280  func (m *PidRequest) XXX_Unmarshal(b []byte) error {
   281  	return m.Unmarshal(b)
   282  }
   283  func (m *PidRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   284  	if deterministic {
   285  		return xxx_messageInfo_PidRequest.Marshal(b, m, deterministic)
   286  	} else {
   287  		b = b[:cap(b)]
   288  		n, err := m.MarshalToSizedBuffer(b)
   289  		if err != nil {
   290  			return nil, err
   291  		}
   292  		return b[:n], nil
   293  	}
   294  }
   295  func (m *PidRequest) XXX_Merge(src proto.Message) {
   296  	xxx_messageInfo_PidRequest.Merge(m, src)
   297  }
   298  func (m *PidRequest) XXX_Size() int {
   299  	return m.Size()
   300  }
   301  func (m *PidRequest) XXX_DiscardUnknown() {
   302  	xxx_messageInfo_PidRequest.DiscardUnknown(m)
   303  }
   304  
   305  var xxx_messageInfo_PidRequest proto.InternalMessageInfo
   306  
   307  type PidResponse struct {
   308  	Pid                  int32    `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"`
   309  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   310  	XXX_unrecognized     []byte   `json:"-"`
   311  	XXX_sizecache        int32    `json:"-"`
   312  }
   313  
   314  func (m *PidResponse) Reset()      { *m = PidResponse{} }
   315  func (*PidResponse) ProtoMessage() {}
   316  func (*PidResponse) Descriptor() ([]byte, []int) {
   317  	return fileDescriptor_c7933dc6ffbb8784, []int{7}
   318  }
   319  func (m *PidResponse) XXX_Unmarshal(b []byte) error {
   320  	return m.Unmarshal(b)
   321  }
   322  func (m *PidResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   323  	if deterministic {
   324  		return xxx_messageInfo_PidResponse.Marshal(b, m, deterministic)
   325  	} else {
   326  		b = b[:cap(b)]
   327  		n, err := m.MarshalToSizedBuffer(b)
   328  		if err != nil {
   329  			return nil, err
   330  		}
   331  		return b[:n], nil
   332  	}
   333  }
   334  func (m *PidResponse) XXX_Merge(src proto.Message) {
   335  	xxx_messageInfo_PidResponse.Merge(m, src)
   336  }
   337  func (m *PidResponse) XXX_Size() int {
   338  	return m.Size()
   339  }
   340  func (m *PidResponse) XXX_DiscardUnknown() {
   341  	xxx_messageInfo_PidResponse.DiscardUnknown(m)
   342  }
   343  
   344  var xxx_messageInfo_PidResponse proto.InternalMessageInfo
   345  
   346  type TasksRequest struct {
   347  	Execs                bool     `protobuf:"varint,1,opt,name=execs,proto3" json:"execs,omitempty"`
   348  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   349  	XXX_unrecognized     []byte   `json:"-"`
   350  	XXX_sizecache        int32    `json:"-"`
   351  }
   352  
   353  func (m *TasksRequest) Reset()      { *m = TasksRequest{} }
   354  func (*TasksRequest) ProtoMessage() {}
   355  func (*TasksRequest) Descriptor() ([]byte, []int) {
   356  	return fileDescriptor_c7933dc6ffbb8784, []int{8}
   357  }
   358  func (m *TasksRequest) XXX_Unmarshal(b []byte) error {
   359  	return m.Unmarshal(b)
   360  }
   361  func (m *TasksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   362  	if deterministic {
   363  		return xxx_messageInfo_TasksRequest.Marshal(b, m, deterministic)
   364  	} else {
   365  		b = b[:cap(b)]
   366  		n, err := m.MarshalToSizedBuffer(b)
   367  		if err != nil {
   368  			return nil, err
   369  		}
   370  		return b[:n], nil
   371  	}
   372  }
   373  func (m *TasksRequest) XXX_Merge(src proto.Message) {
   374  	xxx_messageInfo_TasksRequest.Merge(m, src)
   375  }
   376  func (m *TasksRequest) XXX_Size() int {
   377  	return m.Size()
   378  }
   379  func (m *TasksRequest) XXX_DiscardUnknown() {
   380  	xxx_messageInfo_TasksRequest.DiscardUnknown(m)
   381  }
   382  
   383  var xxx_messageInfo_TasksRequest proto.InternalMessageInfo
   384  
   385  type Task struct {
   386  	ID                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   387  	Execs                []*Exec  `protobuf:"bytes,2,rep,name=execs,proto3" json:"execs,omitempty"`
   388  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   389  	XXX_unrecognized     []byte   `json:"-"`
   390  	XXX_sizecache        int32    `json:"-"`
   391  }
   392  
   393  func (m *Task) Reset()      { *m = Task{} }
   394  func (*Task) ProtoMessage() {}
   395  func (*Task) Descriptor() ([]byte, []int) {
   396  	return fileDescriptor_c7933dc6ffbb8784, []int{9}
   397  }
   398  func (m *Task) XXX_Unmarshal(b []byte) error {
   399  	return m.Unmarshal(b)
   400  }
   401  func (m *Task) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   402  	if deterministic {
   403  		return xxx_messageInfo_Task.Marshal(b, m, deterministic)
   404  	} else {
   405  		b = b[:cap(b)]
   406  		n, err := m.MarshalToSizedBuffer(b)
   407  		if err != nil {
   408  			return nil, err
   409  		}
   410  		return b[:n], nil
   411  	}
   412  }
   413  func (m *Task) XXX_Merge(src proto.Message) {
   414  	xxx_messageInfo_Task.Merge(m, src)
   415  }
   416  func (m *Task) XXX_Size() int {
   417  	return m.Size()
   418  }
   419  func (m *Task) XXX_DiscardUnknown() {
   420  	xxx_messageInfo_Task.DiscardUnknown(m)
   421  }
   422  
   423  var xxx_messageInfo_Task proto.InternalMessageInfo
   424  
   425  type Exec struct {
   426  	ID                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   427  	State                string   `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"`
   428  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   429  	XXX_unrecognized     []byte   `json:"-"`
   430  	XXX_sizecache        int32    `json:"-"`
   431  }
   432  
   433  func (m *Exec) Reset()      { *m = Exec{} }
   434  func (*Exec) ProtoMessage() {}
   435  func (*Exec) Descriptor() ([]byte, []int) {
   436  	return fileDescriptor_c7933dc6ffbb8784, []int{10}
   437  }
   438  func (m *Exec) XXX_Unmarshal(b []byte) error {
   439  	return m.Unmarshal(b)
   440  }
   441  func (m *Exec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   442  	if deterministic {
   443  		return xxx_messageInfo_Exec.Marshal(b, m, deterministic)
   444  	} else {
   445  		b = b[:cap(b)]
   446  		n, err := m.MarshalToSizedBuffer(b)
   447  		if err != nil {
   448  			return nil, err
   449  		}
   450  		return b[:n], nil
   451  	}
   452  }
   453  func (m *Exec) XXX_Merge(src proto.Message) {
   454  	xxx_messageInfo_Exec.Merge(m, src)
   455  }
   456  func (m *Exec) XXX_Size() int {
   457  	return m.Size()
   458  }
   459  func (m *Exec) XXX_DiscardUnknown() {
   460  	xxx_messageInfo_Exec.DiscardUnknown(m)
   461  }
   462  
   463  var xxx_messageInfo_Exec proto.InternalMessageInfo
   464  
   465  type TasksResponse struct {
   466  	Tasks                []*Task  `protobuf:"bytes,1,rep,name=tasks,proto3" json:"tasks,omitempty"`
   467  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   468  	XXX_unrecognized     []byte   `json:"-"`
   469  	XXX_sizecache        int32    `json:"-"`
   470  }
   471  
   472  func (m *TasksResponse) Reset()      { *m = TasksResponse{} }
   473  func (*TasksResponse) ProtoMessage() {}
   474  func (*TasksResponse) Descriptor() ([]byte, []int) {
   475  	return fileDescriptor_c7933dc6ffbb8784, []int{11}
   476  }
   477  func (m *TasksResponse) XXX_Unmarshal(b []byte) error {
   478  	return m.Unmarshal(b)
   479  }
   480  func (m *TasksResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   481  	if deterministic {
   482  		return xxx_messageInfo_TasksResponse.Marshal(b, m, deterministic)
   483  	} else {
   484  		b = b[:cap(b)]
   485  		n, err := m.MarshalToSizedBuffer(b)
   486  		if err != nil {
   487  			return nil, err
   488  		}
   489  		return b[:n], nil
   490  	}
   491  }
   492  func (m *TasksResponse) XXX_Merge(src proto.Message) {
   493  	xxx_messageInfo_TasksResponse.Merge(m, src)
   494  }
   495  func (m *TasksResponse) XXX_Size() int {
   496  	return m.Size()
   497  }
   498  func (m *TasksResponse) XXX_DiscardUnknown() {
   499  	xxx_messageInfo_TasksResponse.DiscardUnknown(m)
   500  }
   501  
   502  var xxx_messageInfo_TasksResponse proto.InternalMessageInfo
   503  
   504  func init() {
   505  	proto.RegisterType((*ExecProcessRequest)(nil), "containerd.runhcs.v1.diag.ExecProcessRequest")
   506  	proto.RegisterType((*ExecProcessResponse)(nil), "containerd.runhcs.v1.diag.ExecProcessResponse")
   507  	proto.RegisterType((*StacksRequest)(nil), "containerd.runhcs.v1.diag.StacksRequest")
   508  	proto.RegisterType((*StacksResponse)(nil), "containerd.runhcs.v1.diag.StacksResponse")
   509  	proto.RegisterType((*ShareRequest)(nil), "containerd.runhcs.v1.diag.ShareRequest")
   510  	proto.RegisterType((*ShareResponse)(nil), "containerd.runhcs.v1.diag.ShareResponse")
   511  	proto.RegisterType((*PidRequest)(nil), "containerd.runhcs.v1.diag.PidRequest")
   512  	proto.RegisterType((*PidResponse)(nil), "containerd.runhcs.v1.diag.PidResponse")
   513  	proto.RegisterType((*TasksRequest)(nil), "containerd.runhcs.v1.diag.TasksRequest")
   514  	proto.RegisterType((*Task)(nil), "containerd.runhcs.v1.diag.Task")
   515  	proto.RegisterType((*Exec)(nil), "containerd.runhcs.v1.diag.Exec")
   516  	proto.RegisterType((*TasksResponse)(nil), "containerd.runhcs.v1.diag.TasksResponse")
   517  }
   518  
   519  func init() {
   520  	proto.RegisterFile("github.com/Microsoft/hcsshim/internal/shimdiag/shimdiag.proto", fileDescriptor_c7933dc6ffbb8784)
   521  }
   522  
   523  var fileDescriptor_c7933dc6ffbb8784 = []byte{
   524  	// 623 bytes of a gzipped FileDescriptorProto
   525  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xcb, 0x6e, 0xd3, 0x40,
   526  	0x14, 0xad, 0xf3, 0xaa, 0x7d, 0x9b, 0x16, 0x34, 0xa0, 0xca, 0x4d, 0xa5, 0x34, 0x58, 0x3c, 0xcc,
   527  	0x02, 0x47, 0x14, 0x2a, 0x16, 0x88, 0x4d, 0x29, 0x88, 0x0a, 0x21, 0x82, 0x0b, 0x12, 0x62, 0x41,
   528  	0x34, 0xb5, 0x87, 0x78, 0xd4, 0xc4, 0x13, 0x66, 0xc6, 0xa5, 0xdd, 0xf1, 0x31, 0x7c, 0x4c, 0x97,
   529  	0x2c, 0x59, 0x21, 0x9a, 0xaf, 0x60, 0x89, 0xe6, 0xe1, 0x40, 0x16, 0x4d, 0xca, 0xca, 0x73, 0xce,
   530  	0xdc, 0x73, 0xee, 0xc3, 0xd7, 0x86, 0x27, 0x03, 0x2a, 0xb3, 0xe2, 0x30, 0x4a, 0xd8, 0xa8, 0xfb,
   531  	0x8a, 0x26, 0x9c, 0x09, 0xf6, 0x49, 0x76, 0xb3, 0x44, 0x88, 0x8c, 0x8e, 0xba, 0x34, 0x97, 0x84,
   532  	0xe7, 0x78, 0xd8, 0x55, 0x28, 0xa5, 0x78, 0x30, 0x3d, 0x44, 0x63, 0xce, 0x24, 0x43, 0x1b, 0x09,
   533  	0xcb, 0x25, 0xa6, 0x39, 0xe1, 0x69, 0xc4, 0x8b, 0x3c, 0x4b, 0x44, 0x74, 0x7c, 0x3f, 0x52, 0x01,
   534  	0xc1, 0x37, 0x07, 0xd0, 0xb3, 0x13, 0x92, 0xf4, 0x38, 0x4b, 0x88, 0x10, 0x31, 0xf9, 0x5c, 0x10,
   535  	0x21, 0x11, 0x82, 0x1a, 0xe6, 0x03, 0xe1, 0x3b, 0x9d, 0x6a, 0xe8, 0xc5, 0xfa, 0x8c, 0x7c, 0x58,
   536  	0xfe, 0xc2, 0xf8, 0x51, 0x4a, 0xb9, 0x5f, 0xe9, 0x38, 0xa1, 0x17, 0x97, 0x10, 0xb5, 0xc0, 0x95,
   537  	0x84, 0x8f, 0x68, 0x8e, 0x87, 0x7e, 0xb5, 0xe3, 0x84, 0x6e, 0x3c, 0xc5, 0xe8, 0x3a, 0xd4, 0x85,
   538  	0x4c, 0x69, 0xee, 0xd7, 0xb4, 0xc6, 0x00, 0xb4, 0x0e, 0x0d, 0x21, 0x53, 0x56, 0x48, 0xbf, 0xae,
   539  	0x69, 0x8b, 0x2c, 0x4f, 0x38, 0xf7, 0x1b, 0x53, 0x9e, 0x70, 0x1e, 0x6c, 0xc3, 0xb5, 0x99, 0x2a,
   540  	0xc5, 0x98, 0xe5, 0x82, 0xa0, 0x4d, 0xf0, 0xc8, 0x09, 0x95, 0xfd, 0x84, 0xa5, 0xc4, 0x77, 0x3a,
   541  	0x4e, 0x58, 0x8f, 0x5d, 0x45, 0x3c, 0x65, 0x29, 0x09, 0xae, 0xc0, 0xea, 0x81, 0xc4, 0xc9, 0x51,
   542  	0xd9, 0x54, 0xf0, 0x12, 0xd6, 0x4a, 0xc2, 0xea, 0x75, 0x3a, 0xc5, 0x68, 0xb1, 0x4e, 0xa7, 0x10,
   543  	0xba, 0x01, 0xcd, 0x81, 0x92, 0xf4, 0xed, 0xad, 0xe9, 0x77, 0x45, 0x73, 0xc6, 0x22, 0x48, 0xa0,
   544  	0x79, 0x90, 0x61, 0x4e, 0xca, 0x89, 0x6d, 0x82, 0x97, 0x31, 0x21, 0xfb, 0x63, 0x2c, 0x33, 0xeb,
   545  	0xe6, 0x2a, 0xa2, 0x87, 0x65, 0x86, 0x36, 0xc0, 0x2d, 0x8e, 0x47, 0xe6, 0xce, 0xce, 0xae, 0x38,
   546  	0x1e, 0xe9, 0xab, 0x4d, 0xf0, 0x38, 0xc1, 0x69, 0x9f, 0xe5, 0xc3, 0xd3, 0x72, 0x78, 0x8a, 0x78,
   547  	0x9d, 0x0f, 0x4f, 0x75, 0x0b, 0x26, 0x89, 0x29, 0x38, 0x68, 0x02, 0xf4, 0x68, 0x5a, 0x36, 0xb4,
   548  	0x05, 0x2b, 0x1a, 0xd9, 0x6e, 0xae, 0x42, 0x75, 0x4c, 0x53, 0x3b, 0x07, 0x75, 0x0c, 0x6e, 0x42,
   549  	0xf3, 0x2d, 0x16, 0xd3, 0x09, 0xa8, 0x97, 0x41, 0x4e, 0x48, 0x62, 0xda, 0x75, 0x63, 0x03, 0x82,
   550  	0x77, 0x50, 0x53, 0x51, 0x68, 0x1d, 0x2a, 0x56, 0xee, 0xed, 0x36, 0x26, 0x3f, 0xb7, 0x2a, 0xfb,
   551  	0x7b, 0x71, 0x85, 0xa6, 0x68, 0xa7, 0x54, 0x55, 0x3a, 0xd5, 0x70, 0x65, 0x7b, 0x2b, 0xba, 0x70,
   552  	0x9d, 0x22, 0xf5, 0x92, 0x4a, 0xdb, 0x87, 0x50, 0x53, 0xf0, 0x42, 0x5b, 0xbd, 0x19, 0x58, 0x12,
   553  	0x3b, 0x11, 0x03, 0x82, 0xe7, 0xb0, 0x6a, 0x4b, 0xb6, 0x5d, 0xed, 0x40, 0x5d, 0x2a, 0x42, 0xef,
   554  	0xe2, 0xfc, 0xec, 0x4a, 0x18, 0x9b, 0xe8, 0xed, 0xdf, 0x55, 0x70, 0x0f, 0x32, 0x3a, 0xda, 0xa3,
   555  	0x78, 0x80, 0x18, 0xac, 0xa9, 0xa7, 0x2a, 0x67, 0x3f, 0x7f, 0xc1, 0x84, 0x44, 0xf7, 0x16, 0x34,
   556  	0x31, 0xfb, 0x3d, 0xb4, 0xa2, 0xcb, 0x86, 0xdb, 0xa2, 0x31, 0x80, 0x4a, 0x68, 0x76, 0x05, 0x85,
   557  	0x73, 0xd4, 0x33, 0x2b, 0xda, 0xba, 0x7b, 0x89, 0x48, 0x9b, 0xe2, 0x23, 0x78, 0x2a, 0x85, 0x1e,
   558  	0x16, 0xba, 0xb3, 0x60, 0x2a, 0xd3, 0x04, 0xe1, 0xe2, 0xc0, 0x59, 0x7f, 0xbd, 0x7f, 0x73, 0xfd,
   559  	0xff, 0xfd, 0x0c, 0xe6, 0xfa, 0xcf, 0xac, 0x32, 0x7a, 0x0f, 0xcb, 0xca, 0xbf, 0x47, 0x53, 0x74,
   560  	0x6b, 0x8e, 0xe8, 0xef, 0xba, 0xb7, 0x6e, 0x2f, 0x0a, 0x33, 0xce, 0xbb, 0x6f, 0xce, 0xce, 0xdb,
   561  	0x4b, 0x3f, 0xce, 0xdb, 0x4b, 0x5f, 0x27, 0x6d, 0xe7, 0x6c, 0xd2, 0x76, 0xbe, 0x4f, 0xda, 0xce,
   562  	0xaf, 0x49, 0xdb, 0xf9, 0xf0, 0xe8, 0xff, 0xfe, 0xa3, 0x8f, 0xcb, 0xc3, 0x61, 0x43, 0xff, 0x48,
   563  	0x1f, 0xfc, 0x09, 0x00, 0x00, 0xff, 0xff, 0x40, 0x66, 0xf4, 0x09, 0x89, 0x05, 0x00, 0x00,
   564  }
   565  
   566  func (m *ExecProcessRequest) Marshal() (dAtA []byte, err error) {
   567  	size := m.Size()
   568  	dAtA = make([]byte, size)
   569  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   570  	if err != nil {
   571  		return nil, err
   572  	}
   573  	return dAtA[:n], nil
   574  }
   575  
   576  func (m *ExecProcessRequest) MarshalTo(dAtA []byte) (int, error) {
   577  	size := m.Size()
   578  	return m.MarshalToSizedBuffer(dAtA[:size])
   579  }
   580  
   581  func (m *ExecProcessRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   582  	i := len(dAtA)
   583  	_ = i
   584  	var l int
   585  	_ = l
   586  	if m.XXX_unrecognized != nil {
   587  		i -= len(m.XXX_unrecognized)
   588  		copy(dAtA[i:], m.XXX_unrecognized)
   589  	}
   590  	if len(m.Stderr) > 0 {
   591  		i -= len(m.Stderr)
   592  		copy(dAtA[i:], m.Stderr)
   593  		i = encodeVarintShimdiag(dAtA, i, uint64(len(m.Stderr)))
   594  		i--
   595  		dAtA[i] = 0x32
   596  	}
   597  	if len(m.Stdout) > 0 {
   598  		i -= len(m.Stdout)
   599  		copy(dAtA[i:], m.Stdout)
   600  		i = encodeVarintShimdiag(dAtA, i, uint64(len(m.Stdout)))
   601  		i--
   602  		dAtA[i] = 0x2a
   603  	}
   604  	if len(m.Stdin) > 0 {
   605  		i -= len(m.Stdin)
   606  		copy(dAtA[i:], m.Stdin)
   607  		i = encodeVarintShimdiag(dAtA, i, uint64(len(m.Stdin)))
   608  		i--
   609  		dAtA[i] = 0x22
   610  	}
   611  	if m.Terminal {
   612  		i--
   613  		if m.Terminal {
   614  			dAtA[i] = 1
   615  		} else {
   616  			dAtA[i] = 0
   617  		}
   618  		i--
   619  		dAtA[i] = 0x18
   620  	}
   621  	if len(m.Workdir) > 0 {
   622  		i -= len(m.Workdir)
   623  		copy(dAtA[i:], m.Workdir)
   624  		i = encodeVarintShimdiag(dAtA, i, uint64(len(m.Workdir)))
   625  		i--
   626  		dAtA[i] = 0x12
   627  	}
   628  	if len(m.Args) > 0 {
   629  		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
   630  			i -= len(m.Args[iNdEx])
   631  			copy(dAtA[i:], m.Args[iNdEx])
   632  			i = encodeVarintShimdiag(dAtA, i, uint64(len(m.Args[iNdEx])))
   633  			i--
   634  			dAtA[i] = 0xa
   635  		}
   636  	}
   637  	return len(dAtA) - i, nil
   638  }
   639  
   640  func (m *ExecProcessResponse) Marshal() (dAtA []byte, err error) {
   641  	size := m.Size()
   642  	dAtA = make([]byte, size)
   643  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   644  	if err != nil {
   645  		return nil, err
   646  	}
   647  	return dAtA[:n], nil
   648  }
   649  
   650  func (m *ExecProcessResponse) MarshalTo(dAtA []byte) (int, error) {
   651  	size := m.Size()
   652  	return m.MarshalToSizedBuffer(dAtA[:size])
   653  }
   654  
   655  func (m *ExecProcessResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   656  	i := len(dAtA)
   657  	_ = i
   658  	var l int
   659  	_ = l
   660  	if m.XXX_unrecognized != nil {
   661  		i -= len(m.XXX_unrecognized)
   662  		copy(dAtA[i:], m.XXX_unrecognized)
   663  	}
   664  	if m.ExitCode != 0 {
   665  		i = encodeVarintShimdiag(dAtA, i, uint64(m.ExitCode))
   666  		i--
   667  		dAtA[i] = 0x8
   668  	}
   669  	return len(dAtA) - i, nil
   670  }
   671  
   672  func (m *StacksRequest) Marshal() (dAtA []byte, err error) {
   673  	size := m.Size()
   674  	dAtA = make([]byte, size)
   675  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   676  	if err != nil {
   677  		return nil, err
   678  	}
   679  	return dAtA[:n], nil
   680  }
   681  
   682  func (m *StacksRequest) MarshalTo(dAtA []byte) (int, error) {
   683  	size := m.Size()
   684  	return m.MarshalToSizedBuffer(dAtA[:size])
   685  }
   686  
   687  func (m *StacksRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   688  	i := len(dAtA)
   689  	_ = i
   690  	var l int
   691  	_ = l
   692  	if m.XXX_unrecognized != nil {
   693  		i -= len(m.XXX_unrecognized)
   694  		copy(dAtA[i:], m.XXX_unrecognized)
   695  	}
   696  	return len(dAtA) - i, nil
   697  }
   698  
   699  func (m *StacksResponse) Marshal() (dAtA []byte, err error) {
   700  	size := m.Size()
   701  	dAtA = make([]byte, size)
   702  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   703  	if err != nil {
   704  		return nil, err
   705  	}
   706  	return dAtA[:n], nil
   707  }
   708  
   709  func (m *StacksResponse) MarshalTo(dAtA []byte) (int, error) {
   710  	size := m.Size()
   711  	return m.MarshalToSizedBuffer(dAtA[:size])
   712  }
   713  
   714  func (m *StacksResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   715  	i := len(dAtA)
   716  	_ = i
   717  	var l int
   718  	_ = l
   719  	if m.XXX_unrecognized != nil {
   720  		i -= len(m.XXX_unrecognized)
   721  		copy(dAtA[i:], m.XXX_unrecognized)
   722  	}
   723  	if len(m.GuestStacks) > 0 {
   724  		i -= len(m.GuestStacks)
   725  		copy(dAtA[i:], m.GuestStacks)
   726  		i = encodeVarintShimdiag(dAtA, i, uint64(len(m.GuestStacks)))
   727  		i--
   728  		dAtA[i] = 0x12
   729  	}
   730  	if len(m.Stacks) > 0 {
   731  		i -= len(m.Stacks)
   732  		copy(dAtA[i:], m.Stacks)
   733  		i = encodeVarintShimdiag(dAtA, i, uint64(len(m.Stacks)))
   734  		i--
   735  		dAtA[i] = 0xa
   736  	}
   737  	return len(dAtA) - i, nil
   738  }
   739  
   740  func (m *ShareRequest) Marshal() (dAtA []byte, err error) {
   741  	size := m.Size()
   742  	dAtA = make([]byte, size)
   743  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   744  	if err != nil {
   745  		return nil, err
   746  	}
   747  	return dAtA[:n], nil
   748  }
   749  
   750  func (m *ShareRequest) MarshalTo(dAtA []byte) (int, error) {
   751  	size := m.Size()
   752  	return m.MarshalToSizedBuffer(dAtA[:size])
   753  }
   754  
   755  func (m *ShareRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   756  	i := len(dAtA)
   757  	_ = i
   758  	var l int
   759  	_ = l
   760  	if m.XXX_unrecognized != nil {
   761  		i -= len(m.XXX_unrecognized)
   762  		copy(dAtA[i:], m.XXX_unrecognized)
   763  	}
   764  	if m.ReadOnly {
   765  		i--
   766  		if m.ReadOnly {
   767  			dAtA[i] = 1
   768  		} else {
   769  			dAtA[i] = 0
   770  		}
   771  		i--
   772  		dAtA[i] = 0x18
   773  	}
   774  	if len(m.UvmPath) > 0 {
   775  		i -= len(m.UvmPath)
   776  		copy(dAtA[i:], m.UvmPath)
   777  		i = encodeVarintShimdiag(dAtA, i, uint64(len(m.UvmPath)))
   778  		i--
   779  		dAtA[i] = 0x12
   780  	}
   781  	if len(m.HostPath) > 0 {
   782  		i -= len(m.HostPath)
   783  		copy(dAtA[i:], m.HostPath)
   784  		i = encodeVarintShimdiag(dAtA, i, uint64(len(m.HostPath)))
   785  		i--
   786  		dAtA[i] = 0xa
   787  	}
   788  	return len(dAtA) - i, nil
   789  }
   790  
   791  func (m *ShareResponse) Marshal() (dAtA []byte, err error) {
   792  	size := m.Size()
   793  	dAtA = make([]byte, size)
   794  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   795  	if err != nil {
   796  		return nil, err
   797  	}
   798  	return dAtA[:n], nil
   799  }
   800  
   801  func (m *ShareResponse) MarshalTo(dAtA []byte) (int, error) {
   802  	size := m.Size()
   803  	return m.MarshalToSizedBuffer(dAtA[:size])
   804  }
   805  
   806  func (m *ShareResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   807  	i := len(dAtA)
   808  	_ = i
   809  	var l int
   810  	_ = l
   811  	if m.XXX_unrecognized != nil {
   812  		i -= len(m.XXX_unrecognized)
   813  		copy(dAtA[i:], m.XXX_unrecognized)
   814  	}
   815  	return len(dAtA) - i, nil
   816  }
   817  
   818  func (m *PidRequest) Marshal() (dAtA []byte, err error) {
   819  	size := m.Size()
   820  	dAtA = make([]byte, size)
   821  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   822  	if err != nil {
   823  		return nil, err
   824  	}
   825  	return dAtA[:n], nil
   826  }
   827  
   828  func (m *PidRequest) MarshalTo(dAtA []byte) (int, error) {
   829  	size := m.Size()
   830  	return m.MarshalToSizedBuffer(dAtA[:size])
   831  }
   832  
   833  func (m *PidRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   834  	i := len(dAtA)
   835  	_ = i
   836  	var l int
   837  	_ = l
   838  	if m.XXX_unrecognized != nil {
   839  		i -= len(m.XXX_unrecognized)
   840  		copy(dAtA[i:], m.XXX_unrecognized)
   841  	}
   842  	return len(dAtA) - i, nil
   843  }
   844  
   845  func (m *PidResponse) Marshal() (dAtA []byte, err error) {
   846  	size := m.Size()
   847  	dAtA = make([]byte, size)
   848  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   849  	if err != nil {
   850  		return nil, err
   851  	}
   852  	return dAtA[:n], nil
   853  }
   854  
   855  func (m *PidResponse) MarshalTo(dAtA []byte) (int, error) {
   856  	size := m.Size()
   857  	return m.MarshalToSizedBuffer(dAtA[:size])
   858  }
   859  
   860  func (m *PidResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   861  	i := len(dAtA)
   862  	_ = i
   863  	var l int
   864  	_ = l
   865  	if m.XXX_unrecognized != nil {
   866  		i -= len(m.XXX_unrecognized)
   867  		copy(dAtA[i:], m.XXX_unrecognized)
   868  	}
   869  	if m.Pid != 0 {
   870  		i = encodeVarintShimdiag(dAtA, i, uint64(m.Pid))
   871  		i--
   872  		dAtA[i] = 0x8
   873  	}
   874  	return len(dAtA) - i, nil
   875  }
   876  
   877  func (m *TasksRequest) Marshal() (dAtA []byte, err error) {
   878  	size := m.Size()
   879  	dAtA = make([]byte, size)
   880  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   881  	if err != nil {
   882  		return nil, err
   883  	}
   884  	return dAtA[:n], nil
   885  }
   886  
   887  func (m *TasksRequest) MarshalTo(dAtA []byte) (int, error) {
   888  	size := m.Size()
   889  	return m.MarshalToSizedBuffer(dAtA[:size])
   890  }
   891  
   892  func (m *TasksRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   893  	i := len(dAtA)
   894  	_ = i
   895  	var l int
   896  	_ = l
   897  	if m.XXX_unrecognized != nil {
   898  		i -= len(m.XXX_unrecognized)
   899  		copy(dAtA[i:], m.XXX_unrecognized)
   900  	}
   901  	if m.Execs {
   902  		i--
   903  		if m.Execs {
   904  			dAtA[i] = 1
   905  		} else {
   906  			dAtA[i] = 0
   907  		}
   908  		i--
   909  		dAtA[i] = 0x8
   910  	}
   911  	return len(dAtA) - i, nil
   912  }
   913  
   914  func (m *Task) Marshal() (dAtA []byte, err error) {
   915  	size := m.Size()
   916  	dAtA = make([]byte, size)
   917  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   918  	if err != nil {
   919  		return nil, err
   920  	}
   921  	return dAtA[:n], nil
   922  }
   923  
   924  func (m *Task) MarshalTo(dAtA []byte) (int, error) {
   925  	size := m.Size()
   926  	return m.MarshalToSizedBuffer(dAtA[:size])
   927  }
   928  
   929  func (m *Task) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   930  	i := len(dAtA)
   931  	_ = i
   932  	var l int
   933  	_ = l
   934  	if m.XXX_unrecognized != nil {
   935  		i -= len(m.XXX_unrecognized)
   936  		copy(dAtA[i:], m.XXX_unrecognized)
   937  	}
   938  	if len(m.Execs) > 0 {
   939  		for iNdEx := len(m.Execs) - 1; iNdEx >= 0; iNdEx-- {
   940  			{
   941  				size, err := m.Execs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   942  				if err != nil {
   943  					return 0, err
   944  				}
   945  				i -= size
   946  				i = encodeVarintShimdiag(dAtA, i, uint64(size))
   947  			}
   948  			i--
   949  			dAtA[i] = 0x12
   950  		}
   951  	}
   952  	if len(m.ID) > 0 {
   953  		i -= len(m.ID)
   954  		copy(dAtA[i:], m.ID)
   955  		i = encodeVarintShimdiag(dAtA, i, uint64(len(m.ID)))
   956  		i--
   957  		dAtA[i] = 0xa
   958  	}
   959  	return len(dAtA) - i, nil
   960  }
   961  
   962  func (m *Exec) Marshal() (dAtA []byte, err error) {
   963  	size := m.Size()
   964  	dAtA = make([]byte, size)
   965  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   966  	if err != nil {
   967  		return nil, err
   968  	}
   969  	return dAtA[:n], nil
   970  }
   971  
   972  func (m *Exec) MarshalTo(dAtA []byte) (int, error) {
   973  	size := m.Size()
   974  	return m.MarshalToSizedBuffer(dAtA[:size])
   975  }
   976  
   977  func (m *Exec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   978  	i := len(dAtA)
   979  	_ = i
   980  	var l int
   981  	_ = l
   982  	if m.XXX_unrecognized != nil {
   983  		i -= len(m.XXX_unrecognized)
   984  		copy(dAtA[i:], m.XXX_unrecognized)
   985  	}
   986  	if len(m.State) > 0 {
   987  		i -= len(m.State)
   988  		copy(dAtA[i:], m.State)
   989  		i = encodeVarintShimdiag(dAtA, i, uint64(len(m.State)))
   990  		i--
   991  		dAtA[i] = 0x12
   992  	}
   993  	if len(m.ID) > 0 {
   994  		i -= len(m.ID)
   995  		copy(dAtA[i:], m.ID)
   996  		i = encodeVarintShimdiag(dAtA, i, uint64(len(m.ID)))
   997  		i--
   998  		dAtA[i] = 0xa
   999  	}
  1000  	return len(dAtA) - i, nil
  1001  }
  1002  
  1003  func (m *TasksResponse) Marshal() (dAtA []byte, err error) {
  1004  	size := m.Size()
  1005  	dAtA = make([]byte, size)
  1006  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1007  	if err != nil {
  1008  		return nil, err
  1009  	}
  1010  	return dAtA[:n], nil
  1011  }
  1012  
  1013  func (m *TasksResponse) MarshalTo(dAtA []byte) (int, error) {
  1014  	size := m.Size()
  1015  	return m.MarshalToSizedBuffer(dAtA[:size])
  1016  }
  1017  
  1018  func (m *TasksResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1019  	i := len(dAtA)
  1020  	_ = i
  1021  	var l int
  1022  	_ = l
  1023  	if m.XXX_unrecognized != nil {
  1024  		i -= len(m.XXX_unrecognized)
  1025  		copy(dAtA[i:], m.XXX_unrecognized)
  1026  	}
  1027  	if len(m.Tasks) > 0 {
  1028  		for iNdEx := len(m.Tasks) - 1; iNdEx >= 0; iNdEx-- {
  1029  			{
  1030  				size, err := m.Tasks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1031  				if err != nil {
  1032  					return 0, err
  1033  				}
  1034  				i -= size
  1035  				i = encodeVarintShimdiag(dAtA, i, uint64(size))
  1036  			}
  1037  			i--
  1038  			dAtA[i] = 0xa
  1039  		}
  1040  	}
  1041  	return len(dAtA) - i, nil
  1042  }
  1043  
  1044  func encodeVarintShimdiag(dAtA []byte, offset int, v uint64) int {
  1045  	offset -= sovShimdiag(v)
  1046  	base := offset
  1047  	for v >= 1<<7 {
  1048  		dAtA[offset] = uint8(v&0x7f | 0x80)
  1049  		v >>= 7
  1050  		offset++
  1051  	}
  1052  	dAtA[offset] = uint8(v)
  1053  	return base
  1054  }
  1055  func (m *ExecProcessRequest) Size() (n int) {
  1056  	if m == nil {
  1057  		return 0
  1058  	}
  1059  	var l int
  1060  	_ = l
  1061  	if len(m.Args) > 0 {
  1062  		for _, s := range m.Args {
  1063  			l = len(s)
  1064  			n += 1 + l + sovShimdiag(uint64(l))
  1065  		}
  1066  	}
  1067  	l = len(m.Workdir)
  1068  	if l > 0 {
  1069  		n += 1 + l + sovShimdiag(uint64(l))
  1070  	}
  1071  	if m.Terminal {
  1072  		n += 2
  1073  	}
  1074  	l = len(m.Stdin)
  1075  	if l > 0 {
  1076  		n += 1 + l + sovShimdiag(uint64(l))
  1077  	}
  1078  	l = len(m.Stdout)
  1079  	if l > 0 {
  1080  		n += 1 + l + sovShimdiag(uint64(l))
  1081  	}
  1082  	l = len(m.Stderr)
  1083  	if l > 0 {
  1084  		n += 1 + l + sovShimdiag(uint64(l))
  1085  	}
  1086  	if m.XXX_unrecognized != nil {
  1087  		n += len(m.XXX_unrecognized)
  1088  	}
  1089  	return n
  1090  }
  1091  
  1092  func (m *ExecProcessResponse) Size() (n int) {
  1093  	if m == nil {
  1094  		return 0
  1095  	}
  1096  	var l int
  1097  	_ = l
  1098  	if m.ExitCode != 0 {
  1099  		n += 1 + sovShimdiag(uint64(m.ExitCode))
  1100  	}
  1101  	if m.XXX_unrecognized != nil {
  1102  		n += len(m.XXX_unrecognized)
  1103  	}
  1104  	return n
  1105  }
  1106  
  1107  func (m *StacksRequest) Size() (n int) {
  1108  	if m == nil {
  1109  		return 0
  1110  	}
  1111  	var l int
  1112  	_ = l
  1113  	if m.XXX_unrecognized != nil {
  1114  		n += len(m.XXX_unrecognized)
  1115  	}
  1116  	return n
  1117  }
  1118  
  1119  func (m *StacksResponse) Size() (n int) {
  1120  	if m == nil {
  1121  		return 0
  1122  	}
  1123  	var l int
  1124  	_ = l
  1125  	l = len(m.Stacks)
  1126  	if l > 0 {
  1127  		n += 1 + l + sovShimdiag(uint64(l))
  1128  	}
  1129  	l = len(m.GuestStacks)
  1130  	if l > 0 {
  1131  		n += 1 + l + sovShimdiag(uint64(l))
  1132  	}
  1133  	if m.XXX_unrecognized != nil {
  1134  		n += len(m.XXX_unrecognized)
  1135  	}
  1136  	return n
  1137  }
  1138  
  1139  func (m *ShareRequest) Size() (n int) {
  1140  	if m == nil {
  1141  		return 0
  1142  	}
  1143  	var l int
  1144  	_ = l
  1145  	l = len(m.HostPath)
  1146  	if l > 0 {
  1147  		n += 1 + l + sovShimdiag(uint64(l))
  1148  	}
  1149  	l = len(m.UvmPath)
  1150  	if l > 0 {
  1151  		n += 1 + l + sovShimdiag(uint64(l))
  1152  	}
  1153  	if m.ReadOnly {
  1154  		n += 2
  1155  	}
  1156  	if m.XXX_unrecognized != nil {
  1157  		n += len(m.XXX_unrecognized)
  1158  	}
  1159  	return n
  1160  }
  1161  
  1162  func (m *ShareResponse) Size() (n int) {
  1163  	if m == nil {
  1164  		return 0
  1165  	}
  1166  	var l int
  1167  	_ = l
  1168  	if m.XXX_unrecognized != nil {
  1169  		n += len(m.XXX_unrecognized)
  1170  	}
  1171  	return n
  1172  }
  1173  
  1174  func (m *PidRequest) Size() (n int) {
  1175  	if m == nil {
  1176  		return 0
  1177  	}
  1178  	var l int
  1179  	_ = l
  1180  	if m.XXX_unrecognized != nil {
  1181  		n += len(m.XXX_unrecognized)
  1182  	}
  1183  	return n
  1184  }
  1185  
  1186  func (m *PidResponse) Size() (n int) {
  1187  	if m == nil {
  1188  		return 0
  1189  	}
  1190  	var l int
  1191  	_ = l
  1192  	if m.Pid != 0 {
  1193  		n += 1 + sovShimdiag(uint64(m.Pid))
  1194  	}
  1195  	if m.XXX_unrecognized != nil {
  1196  		n += len(m.XXX_unrecognized)
  1197  	}
  1198  	return n
  1199  }
  1200  
  1201  func (m *TasksRequest) Size() (n int) {
  1202  	if m == nil {
  1203  		return 0
  1204  	}
  1205  	var l int
  1206  	_ = l
  1207  	if m.Execs {
  1208  		n += 2
  1209  	}
  1210  	if m.XXX_unrecognized != nil {
  1211  		n += len(m.XXX_unrecognized)
  1212  	}
  1213  	return n
  1214  }
  1215  
  1216  func (m *Task) Size() (n int) {
  1217  	if m == nil {
  1218  		return 0
  1219  	}
  1220  	var l int
  1221  	_ = l
  1222  	l = len(m.ID)
  1223  	if l > 0 {
  1224  		n += 1 + l + sovShimdiag(uint64(l))
  1225  	}
  1226  	if len(m.Execs) > 0 {
  1227  		for _, e := range m.Execs {
  1228  			l = e.Size()
  1229  			n += 1 + l + sovShimdiag(uint64(l))
  1230  		}
  1231  	}
  1232  	if m.XXX_unrecognized != nil {
  1233  		n += len(m.XXX_unrecognized)
  1234  	}
  1235  	return n
  1236  }
  1237  
  1238  func (m *Exec) Size() (n int) {
  1239  	if m == nil {
  1240  		return 0
  1241  	}
  1242  	var l int
  1243  	_ = l
  1244  	l = len(m.ID)
  1245  	if l > 0 {
  1246  		n += 1 + l + sovShimdiag(uint64(l))
  1247  	}
  1248  	l = len(m.State)
  1249  	if l > 0 {
  1250  		n += 1 + l + sovShimdiag(uint64(l))
  1251  	}
  1252  	if m.XXX_unrecognized != nil {
  1253  		n += len(m.XXX_unrecognized)
  1254  	}
  1255  	return n
  1256  }
  1257  
  1258  func (m *TasksResponse) Size() (n int) {
  1259  	if m == nil {
  1260  		return 0
  1261  	}
  1262  	var l int
  1263  	_ = l
  1264  	if len(m.Tasks) > 0 {
  1265  		for _, e := range m.Tasks {
  1266  			l = e.Size()
  1267  			n += 1 + l + sovShimdiag(uint64(l))
  1268  		}
  1269  	}
  1270  	if m.XXX_unrecognized != nil {
  1271  		n += len(m.XXX_unrecognized)
  1272  	}
  1273  	return n
  1274  }
  1275  
  1276  func sovShimdiag(x uint64) (n int) {
  1277  	return (math_bits.Len64(x|1) + 6) / 7
  1278  }
  1279  func sozShimdiag(x uint64) (n int) {
  1280  	return sovShimdiag(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  1281  }
  1282  func (this *ExecProcessRequest) String() string {
  1283  	if this == nil {
  1284  		return "nil"
  1285  	}
  1286  	s := strings.Join([]string{`&ExecProcessRequest{`,
  1287  		`Args:` + fmt.Sprintf("%v", this.Args) + `,`,
  1288  		`Workdir:` + fmt.Sprintf("%v", this.Workdir) + `,`,
  1289  		`Terminal:` + fmt.Sprintf("%v", this.Terminal) + `,`,
  1290  		`Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`,
  1291  		`Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`,
  1292  		`Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`,
  1293  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1294  		`}`,
  1295  	}, "")
  1296  	return s
  1297  }
  1298  func (this *ExecProcessResponse) String() string {
  1299  	if this == nil {
  1300  		return "nil"
  1301  	}
  1302  	s := strings.Join([]string{`&ExecProcessResponse{`,
  1303  		`ExitCode:` + fmt.Sprintf("%v", this.ExitCode) + `,`,
  1304  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1305  		`}`,
  1306  	}, "")
  1307  	return s
  1308  }
  1309  func (this *StacksRequest) String() string {
  1310  	if this == nil {
  1311  		return "nil"
  1312  	}
  1313  	s := strings.Join([]string{`&StacksRequest{`,
  1314  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1315  		`}`,
  1316  	}, "")
  1317  	return s
  1318  }
  1319  func (this *StacksResponse) String() string {
  1320  	if this == nil {
  1321  		return "nil"
  1322  	}
  1323  	s := strings.Join([]string{`&StacksResponse{`,
  1324  		`Stacks:` + fmt.Sprintf("%v", this.Stacks) + `,`,
  1325  		`GuestStacks:` + fmt.Sprintf("%v", this.GuestStacks) + `,`,
  1326  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1327  		`}`,
  1328  	}, "")
  1329  	return s
  1330  }
  1331  func (this *ShareRequest) String() string {
  1332  	if this == nil {
  1333  		return "nil"
  1334  	}
  1335  	s := strings.Join([]string{`&ShareRequest{`,
  1336  		`HostPath:` + fmt.Sprintf("%v", this.HostPath) + `,`,
  1337  		`UvmPath:` + fmt.Sprintf("%v", this.UvmPath) + `,`,
  1338  		`ReadOnly:` + fmt.Sprintf("%v", this.ReadOnly) + `,`,
  1339  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1340  		`}`,
  1341  	}, "")
  1342  	return s
  1343  }
  1344  func (this *ShareResponse) String() string {
  1345  	if this == nil {
  1346  		return "nil"
  1347  	}
  1348  	s := strings.Join([]string{`&ShareResponse{`,
  1349  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1350  		`}`,
  1351  	}, "")
  1352  	return s
  1353  }
  1354  func (this *PidRequest) String() string {
  1355  	if this == nil {
  1356  		return "nil"
  1357  	}
  1358  	s := strings.Join([]string{`&PidRequest{`,
  1359  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1360  		`}`,
  1361  	}, "")
  1362  	return s
  1363  }
  1364  func (this *PidResponse) String() string {
  1365  	if this == nil {
  1366  		return "nil"
  1367  	}
  1368  	s := strings.Join([]string{`&PidResponse{`,
  1369  		`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
  1370  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1371  		`}`,
  1372  	}, "")
  1373  	return s
  1374  }
  1375  func (this *TasksRequest) String() string {
  1376  	if this == nil {
  1377  		return "nil"
  1378  	}
  1379  	s := strings.Join([]string{`&TasksRequest{`,
  1380  		`Execs:` + fmt.Sprintf("%v", this.Execs) + `,`,
  1381  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1382  		`}`,
  1383  	}, "")
  1384  	return s
  1385  }
  1386  func (this *Task) String() string {
  1387  	if this == nil {
  1388  		return "nil"
  1389  	}
  1390  	repeatedStringForExecs := "[]*Exec{"
  1391  	for _, f := range this.Execs {
  1392  		repeatedStringForExecs += strings.Replace(f.String(), "Exec", "Exec", 1) + ","
  1393  	}
  1394  	repeatedStringForExecs += "}"
  1395  	s := strings.Join([]string{`&Task{`,
  1396  		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
  1397  		`Execs:` + repeatedStringForExecs + `,`,
  1398  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1399  		`}`,
  1400  	}, "")
  1401  	return s
  1402  }
  1403  func (this *Exec) String() string {
  1404  	if this == nil {
  1405  		return "nil"
  1406  	}
  1407  	s := strings.Join([]string{`&Exec{`,
  1408  		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
  1409  		`State:` + fmt.Sprintf("%v", this.State) + `,`,
  1410  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1411  		`}`,
  1412  	}, "")
  1413  	return s
  1414  }
  1415  func (this *TasksResponse) String() string {
  1416  	if this == nil {
  1417  		return "nil"
  1418  	}
  1419  	repeatedStringForTasks := "[]*Task{"
  1420  	for _, f := range this.Tasks {
  1421  		repeatedStringForTasks += strings.Replace(f.String(), "Task", "Task", 1) + ","
  1422  	}
  1423  	repeatedStringForTasks += "}"
  1424  	s := strings.Join([]string{`&TasksResponse{`,
  1425  		`Tasks:` + repeatedStringForTasks + `,`,
  1426  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1427  		`}`,
  1428  	}, "")
  1429  	return s
  1430  }
  1431  func valueToStringShimdiag(v interface{}) string {
  1432  	rv := reflect.ValueOf(v)
  1433  	if rv.IsNil() {
  1434  		return "nil"
  1435  	}
  1436  	pv := reflect.Indirect(rv).Interface()
  1437  	return fmt.Sprintf("*%v", pv)
  1438  }
  1439  
  1440  type ShimDiagService interface {
  1441  	DiagExecInHost(ctx context.Context, req *ExecProcessRequest) (*ExecProcessResponse, error)
  1442  	DiagStacks(ctx context.Context, req *StacksRequest) (*StacksResponse, error)
  1443  	DiagTasks(ctx context.Context, req *TasksRequest) (*TasksResponse, error)
  1444  	DiagShare(ctx context.Context, req *ShareRequest) (*ShareResponse, error)
  1445  	DiagPid(ctx context.Context, req *PidRequest) (*PidResponse, error)
  1446  }
  1447  
  1448  func RegisterShimDiagService(srv *github_com_containerd_ttrpc.Server, svc ShimDiagService) {
  1449  	srv.Register("containerd.runhcs.v1.diag.ShimDiag", map[string]github_com_containerd_ttrpc.Method{
  1450  		"DiagExecInHost": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
  1451  			var req ExecProcessRequest
  1452  			if err := unmarshal(&req); err != nil {
  1453  				return nil, err
  1454  			}
  1455  			return svc.DiagExecInHost(ctx, &req)
  1456  		},
  1457  		"DiagStacks": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
  1458  			var req StacksRequest
  1459  			if err := unmarshal(&req); err != nil {
  1460  				return nil, err
  1461  			}
  1462  			return svc.DiagStacks(ctx, &req)
  1463  		},
  1464  		"DiagTasks": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
  1465  			var req TasksRequest
  1466  			if err := unmarshal(&req); err != nil {
  1467  				return nil, err
  1468  			}
  1469  			return svc.DiagTasks(ctx, &req)
  1470  		},
  1471  		"DiagShare": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
  1472  			var req ShareRequest
  1473  			if err := unmarshal(&req); err != nil {
  1474  				return nil, err
  1475  			}
  1476  			return svc.DiagShare(ctx, &req)
  1477  		},
  1478  		"DiagPid": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
  1479  			var req PidRequest
  1480  			if err := unmarshal(&req); err != nil {
  1481  				return nil, err
  1482  			}
  1483  			return svc.DiagPid(ctx, &req)
  1484  		},
  1485  	})
  1486  }
  1487  
  1488  type shimDiagClient struct {
  1489  	client *github_com_containerd_ttrpc.Client
  1490  }
  1491  
  1492  func NewShimDiagClient(client *github_com_containerd_ttrpc.Client) ShimDiagService {
  1493  	return &shimDiagClient{
  1494  		client: client,
  1495  	}
  1496  }
  1497  
  1498  func (c *shimDiagClient) DiagExecInHost(ctx context.Context, req *ExecProcessRequest) (*ExecProcessResponse, error) {
  1499  	var resp ExecProcessResponse
  1500  	if err := c.client.Call(ctx, "containerd.runhcs.v1.diag.ShimDiag", "DiagExecInHost", req, &resp); err != nil {
  1501  		return nil, err
  1502  	}
  1503  	return &resp, nil
  1504  }
  1505  
  1506  func (c *shimDiagClient) DiagStacks(ctx context.Context, req *StacksRequest) (*StacksResponse, error) {
  1507  	var resp StacksResponse
  1508  	if err := c.client.Call(ctx, "containerd.runhcs.v1.diag.ShimDiag", "DiagStacks", req, &resp); err != nil {
  1509  		return nil, err
  1510  	}
  1511  	return &resp, nil
  1512  }
  1513  
  1514  func (c *shimDiagClient) DiagTasks(ctx context.Context, req *TasksRequest) (*TasksResponse, error) {
  1515  	var resp TasksResponse
  1516  	if err := c.client.Call(ctx, "containerd.runhcs.v1.diag.ShimDiag", "DiagTasks", req, &resp); err != nil {
  1517  		return nil, err
  1518  	}
  1519  	return &resp, nil
  1520  }
  1521  
  1522  func (c *shimDiagClient) DiagShare(ctx context.Context, req *ShareRequest) (*ShareResponse, error) {
  1523  	var resp ShareResponse
  1524  	if err := c.client.Call(ctx, "containerd.runhcs.v1.diag.ShimDiag", "DiagShare", req, &resp); err != nil {
  1525  		return nil, err
  1526  	}
  1527  	return &resp, nil
  1528  }
  1529  
  1530  func (c *shimDiagClient) DiagPid(ctx context.Context, req *PidRequest) (*PidResponse, error) {
  1531  	var resp PidResponse
  1532  	if err := c.client.Call(ctx, "containerd.runhcs.v1.diag.ShimDiag", "DiagPid", req, &resp); err != nil {
  1533  		return nil, err
  1534  	}
  1535  	return &resp, nil
  1536  }
  1537  func (m *ExecProcessRequest) Unmarshal(dAtA []byte) error {
  1538  	l := len(dAtA)
  1539  	iNdEx := 0
  1540  	for iNdEx < l {
  1541  		preIndex := iNdEx
  1542  		var wire uint64
  1543  		for shift := uint(0); ; shift += 7 {
  1544  			if shift >= 64 {
  1545  				return ErrIntOverflowShimdiag
  1546  			}
  1547  			if iNdEx >= l {
  1548  				return io.ErrUnexpectedEOF
  1549  			}
  1550  			b := dAtA[iNdEx]
  1551  			iNdEx++
  1552  			wire |= uint64(b&0x7F) << shift
  1553  			if b < 0x80 {
  1554  				break
  1555  			}
  1556  		}
  1557  		fieldNum := int32(wire >> 3)
  1558  		wireType := int(wire & 0x7)
  1559  		if wireType == 4 {
  1560  			return fmt.Errorf("proto: ExecProcessRequest: wiretype end group for non-group")
  1561  		}
  1562  		if fieldNum <= 0 {
  1563  			return fmt.Errorf("proto: ExecProcessRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  1564  		}
  1565  		switch fieldNum {
  1566  		case 1:
  1567  			if wireType != 2 {
  1568  				return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType)
  1569  			}
  1570  			var stringLen uint64
  1571  			for shift := uint(0); ; shift += 7 {
  1572  				if shift >= 64 {
  1573  					return ErrIntOverflowShimdiag
  1574  				}
  1575  				if iNdEx >= l {
  1576  					return io.ErrUnexpectedEOF
  1577  				}
  1578  				b := dAtA[iNdEx]
  1579  				iNdEx++
  1580  				stringLen |= uint64(b&0x7F) << shift
  1581  				if b < 0x80 {
  1582  					break
  1583  				}
  1584  			}
  1585  			intStringLen := int(stringLen)
  1586  			if intStringLen < 0 {
  1587  				return ErrInvalidLengthShimdiag
  1588  			}
  1589  			postIndex := iNdEx + intStringLen
  1590  			if postIndex < 0 {
  1591  				return ErrInvalidLengthShimdiag
  1592  			}
  1593  			if postIndex > l {
  1594  				return io.ErrUnexpectedEOF
  1595  			}
  1596  			m.Args = append(m.Args, string(dAtA[iNdEx:postIndex]))
  1597  			iNdEx = postIndex
  1598  		case 2:
  1599  			if wireType != 2 {
  1600  				return fmt.Errorf("proto: wrong wireType = %d for field Workdir", wireType)
  1601  			}
  1602  			var stringLen uint64
  1603  			for shift := uint(0); ; shift += 7 {
  1604  				if shift >= 64 {
  1605  					return ErrIntOverflowShimdiag
  1606  				}
  1607  				if iNdEx >= l {
  1608  					return io.ErrUnexpectedEOF
  1609  				}
  1610  				b := dAtA[iNdEx]
  1611  				iNdEx++
  1612  				stringLen |= uint64(b&0x7F) << shift
  1613  				if b < 0x80 {
  1614  					break
  1615  				}
  1616  			}
  1617  			intStringLen := int(stringLen)
  1618  			if intStringLen < 0 {
  1619  				return ErrInvalidLengthShimdiag
  1620  			}
  1621  			postIndex := iNdEx + intStringLen
  1622  			if postIndex < 0 {
  1623  				return ErrInvalidLengthShimdiag
  1624  			}
  1625  			if postIndex > l {
  1626  				return io.ErrUnexpectedEOF
  1627  			}
  1628  			m.Workdir = string(dAtA[iNdEx:postIndex])
  1629  			iNdEx = postIndex
  1630  		case 3:
  1631  			if wireType != 0 {
  1632  				return fmt.Errorf("proto: wrong wireType = %d for field Terminal", wireType)
  1633  			}
  1634  			var v int
  1635  			for shift := uint(0); ; shift += 7 {
  1636  				if shift >= 64 {
  1637  					return ErrIntOverflowShimdiag
  1638  				}
  1639  				if iNdEx >= l {
  1640  					return io.ErrUnexpectedEOF
  1641  				}
  1642  				b := dAtA[iNdEx]
  1643  				iNdEx++
  1644  				v |= int(b&0x7F) << shift
  1645  				if b < 0x80 {
  1646  					break
  1647  				}
  1648  			}
  1649  			m.Terminal = bool(v != 0)
  1650  		case 4:
  1651  			if wireType != 2 {
  1652  				return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType)
  1653  			}
  1654  			var stringLen uint64
  1655  			for shift := uint(0); ; shift += 7 {
  1656  				if shift >= 64 {
  1657  					return ErrIntOverflowShimdiag
  1658  				}
  1659  				if iNdEx >= l {
  1660  					return io.ErrUnexpectedEOF
  1661  				}
  1662  				b := dAtA[iNdEx]
  1663  				iNdEx++
  1664  				stringLen |= uint64(b&0x7F) << shift
  1665  				if b < 0x80 {
  1666  					break
  1667  				}
  1668  			}
  1669  			intStringLen := int(stringLen)
  1670  			if intStringLen < 0 {
  1671  				return ErrInvalidLengthShimdiag
  1672  			}
  1673  			postIndex := iNdEx + intStringLen
  1674  			if postIndex < 0 {
  1675  				return ErrInvalidLengthShimdiag
  1676  			}
  1677  			if postIndex > l {
  1678  				return io.ErrUnexpectedEOF
  1679  			}
  1680  			m.Stdin = string(dAtA[iNdEx:postIndex])
  1681  			iNdEx = postIndex
  1682  		case 5:
  1683  			if wireType != 2 {
  1684  				return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType)
  1685  			}
  1686  			var stringLen uint64
  1687  			for shift := uint(0); ; shift += 7 {
  1688  				if shift >= 64 {
  1689  					return ErrIntOverflowShimdiag
  1690  				}
  1691  				if iNdEx >= l {
  1692  					return io.ErrUnexpectedEOF
  1693  				}
  1694  				b := dAtA[iNdEx]
  1695  				iNdEx++
  1696  				stringLen |= uint64(b&0x7F) << shift
  1697  				if b < 0x80 {
  1698  					break
  1699  				}
  1700  			}
  1701  			intStringLen := int(stringLen)
  1702  			if intStringLen < 0 {
  1703  				return ErrInvalidLengthShimdiag
  1704  			}
  1705  			postIndex := iNdEx + intStringLen
  1706  			if postIndex < 0 {
  1707  				return ErrInvalidLengthShimdiag
  1708  			}
  1709  			if postIndex > l {
  1710  				return io.ErrUnexpectedEOF
  1711  			}
  1712  			m.Stdout = string(dAtA[iNdEx:postIndex])
  1713  			iNdEx = postIndex
  1714  		case 6:
  1715  			if wireType != 2 {
  1716  				return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType)
  1717  			}
  1718  			var stringLen uint64
  1719  			for shift := uint(0); ; shift += 7 {
  1720  				if shift >= 64 {
  1721  					return ErrIntOverflowShimdiag
  1722  				}
  1723  				if iNdEx >= l {
  1724  					return io.ErrUnexpectedEOF
  1725  				}
  1726  				b := dAtA[iNdEx]
  1727  				iNdEx++
  1728  				stringLen |= uint64(b&0x7F) << shift
  1729  				if b < 0x80 {
  1730  					break
  1731  				}
  1732  			}
  1733  			intStringLen := int(stringLen)
  1734  			if intStringLen < 0 {
  1735  				return ErrInvalidLengthShimdiag
  1736  			}
  1737  			postIndex := iNdEx + intStringLen
  1738  			if postIndex < 0 {
  1739  				return ErrInvalidLengthShimdiag
  1740  			}
  1741  			if postIndex > l {
  1742  				return io.ErrUnexpectedEOF
  1743  			}
  1744  			m.Stderr = string(dAtA[iNdEx:postIndex])
  1745  			iNdEx = postIndex
  1746  		default:
  1747  			iNdEx = preIndex
  1748  			skippy, err := skipShimdiag(dAtA[iNdEx:])
  1749  			if err != nil {
  1750  				return err
  1751  			}
  1752  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1753  				return ErrInvalidLengthShimdiag
  1754  			}
  1755  			if (iNdEx + skippy) > l {
  1756  				return io.ErrUnexpectedEOF
  1757  			}
  1758  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1759  			iNdEx += skippy
  1760  		}
  1761  	}
  1762  
  1763  	if iNdEx > l {
  1764  		return io.ErrUnexpectedEOF
  1765  	}
  1766  	return nil
  1767  }
  1768  func (m *ExecProcessResponse) Unmarshal(dAtA []byte) error {
  1769  	l := len(dAtA)
  1770  	iNdEx := 0
  1771  	for iNdEx < l {
  1772  		preIndex := iNdEx
  1773  		var wire uint64
  1774  		for shift := uint(0); ; shift += 7 {
  1775  			if shift >= 64 {
  1776  				return ErrIntOverflowShimdiag
  1777  			}
  1778  			if iNdEx >= l {
  1779  				return io.ErrUnexpectedEOF
  1780  			}
  1781  			b := dAtA[iNdEx]
  1782  			iNdEx++
  1783  			wire |= uint64(b&0x7F) << shift
  1784  			if b < 0x80 {
  1785  				break
  1786  			}
  1787  		}
  1788  		fieldNum := int32(wire >> 3)
  1789  		wireType := int(wire & 0x7)
  1790  		if wireType == 4 {
  1791  			return fmt.Errorf("proto: ExecProcessResponse: wiretype end group for non-group")
  1792  		}
  1793  		if fieldNum <= 0 {
  1794  			return fmt.Errorf("proto: ExecProcessResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  1795  		}
  1796  		switch fieldNum {
  1797  		case 1:
  1798  			if wireType != 0 {
  1799  				return fmt.Errorf("proto: wrong wireType = %d for field ExitCode", wireType)
  1800  			}
  1801  			m.ExitCode = 0
  1802  			for shift := uint(0); ; shift += 7 {
  1803  				if shift >= 64 {
  1804  					return ErrIntOverflowShimdiag
  1805  				}
  1806  				if iNdEx >= l {
  1807  					return io.ErrUnexpectedEOF
  1808  				}
  1809  				b := dAtA[iNdEx]
  1810  				iNdEx++
  1811  				m.ExitCode |= int32(b&0x7F) << shift
  1812  				if b < 0x80 {
  1813  					break
  1814  				}
  1815  			}
  1816  		default:
  1817  			iNdEx = preIndex
  1818  			skippy, err := skipShimdiag(dAtA[iNdEx:])
  1819  			if err != nil {
  1820  				return err
  1821  			}
  1822  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1823  				return ErrInvalidLengthShimdiag
  1824  			}
  1825  			if (iNdEx + skippy) > l {
  1826  				return io.ErrUnexpectedEOF
  1827  			}
  1828  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1829  			iNdEx += skippy
  1830  		}
  1831  	}
  1832  
  1833  	if iNdEx > l {
  1834  		return io.ErrUnexpectedEOF
  1835  	}
  1836  	return nil
  1837  }
  1838  func (m *StacksRequest) Unmarshal(dAtA []byte) error {
  1839  	l := len(dAtA)
  1840  	iNdEx := 0
  1841  	for iNdEx < l {
  1842  		preIndex := iNdEx
  1843  		var wire uint64
  1844  		for shift := uint(0); ; shift += 7 {
  1845  			if shift >= 64 {
  1846  				return ErrIntOverflowShimdiag
  1847  			}
  1848  			if iNdEx >= l {
  1849  				return io.ErrUnexpectedEOF
  1850  			}
  1851  			b := dAtA[iNdEx]
  1852  			iNdEx++
  1853  			wire |= uint64(b&0x7F) << shift
  1854  			if b < 0x80 {
  1855  				break
  1856  			}
  1857  		}
  1858  		fieldNum := int32(wire >> 3)
  1859  		wireType := int(wire & 0x7)
  1860  		if wireType == 4 {
  1861  			return fmt.Errorf("proto: StacksRequest: wiretype end group for non-group")
  1862  		}
  1863  		if fieldNum <= 0 {
  1864  			return fmt.Errorf("proto: StacksRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  1865  		}
  1866  		switch fieldNum {
  1867  		default:
  1868  			iNdEx = preIndex
  1869  			skippy, err := skipShimdiag(dAtA[iNdEx:])
  1870  			if err != nil {
  1871  				return err
  1872  			}
  1873  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1874  				return ErrInvalidLengthShimdiag
  1875  			}
  1876  			if (iNdEx + skippy) > l {
  1877  				return io.ErrUnexpectedEOF
  1878  			}
  1879  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1880  			iNdEx += skippy
  1881  		}
  1882  	}
  1883  
  1884  	if iNdEx > l {
  1885  		return io.ErrUnexpectedEOF
  1886  	}
  1887  	return nil
  1888  }
  1889  func (m *StacksResponse) Unmarshal(dAtA []byte) error {
  1890  	l := len(dAtA)
  1891  	iNdEx := 0
  1892  	for iNdEx < l {
  1893  		preIndex := iNdEx
  1894  		var wire uint64
  1895  		for shift := uint(0); ; shift += 7 {
  1896  			if shift >= 64 {
  1897  				return ErrIntOverflowShimdiag
  1898  			}
  1899  			if iNdEx >= l {
  1900  				return io.ErrUnexpectedEOF
  1901  			}
  1902  			b := dAtA[iNdEx]
  1903  			iNdEx++
  1904  			wire |= uint64(b&0x7F) << shift
  1905  			if b < 0x80 {
  1906  				break
  1907  			}
  1908  		}
  1909  		fieldNum := int32(wire >> 3)
  1910  		wireType := int(wire & 0x7)
  1911  		if wireType == 4 {
  1912  			return fmt.Errorf("proto: StacksResponse: wiretype end group for non-group")
  1913  		}
  1914  		if fieldNum <= 0 {
  1915  			return fmt.Errorf("proto: StacksResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  1916  		}
  1917  		switch fieldNum {
  1918  		case 1:
  1919  			if wireType != 2 {
  1920  				return fmt.Errorf("proto: wrong wireType = %d for field Stacks", wireType)
  1921  			}
  1922  			var stringLen uint64
  1923  			for shift := uint(0); ; shift += 7 {
  1924  				if shift >= 64 {
  1925  					return ErrIntOverflowShimdiag
  1926  				}
  1927  				if iNdEx >= l {
  1928  					return io.ErrUnexpectedEOF
  1929  				}
  1930  				b := dAtA[iNdEx]
  1931  				iNdEx++
  1932  				stringLen |= uint64(b&0x7F) << shift
  1933  				if b < 0x80 {
  1934  					break
  1935  				}
  1936  			}
  1937  			intStringLen := int(stringLen)
  1938  			if intStringLen < 0 {
  1939  				return ErrInvalidLengthShimdiag
  1940  			}
  1941  			postIndex := iNdEx + intStringLen
  1942  			if postIndex < 0 {
  1943  				return ErrInvalidLengthShimdiag
  1944  			}
  1945  			if postIndex > l {
  1946  				return io.ErrUnexpectedEOF
  1947  			}
  1948  			m.Stacks = string(dAtA[iNdEx:postIndex])
  1949  			iNdEx = postIndex
  1950  		case 2:
  1951  			if wireType != 2 {
  1952  				return fmt.Errorf("proto: wrong wireType = %d for field GuestStacks", wireType)
  1953  			}
  1954  			var stringLen uint64
  1955  			for shift := uint(0); ; shift += 7 {
  1956  				if shift >= 64 {
  1957  					return ErrIntOverflowShimdiag
  1958  				}
  1959  				if iNdEx >= l {
  1960  					return io.ErrUnexpectedEOF
  1961  				}
  1962  				b := dAtA[iNdEx]
  1963  				iNdEx++
  1964  				stringLen |= uint64(b&0x7F) << shift
  1965  				if b < 0x80 {
  1966  					break
  1967  				}
  1968  			}
  1969  			intStringLen := int(stringLen)
  1970  			if intStringLen < 0 {
  1971  				return ErrInvalidLengthShimdiag
  1972  			}
  1973  			postIndex := iNdEx + intStringLen
  1974  			if postIndex < 0 {
  1975  				return ErrInvalidLengthShimdiag
  1976  			}
  1977  			if postIndex > l {
  1978  				return io.ErrUnexpectedEOF
  1979  			}
  1980  			m.GuestStacks = string(dAtA[iNdEx:postIndex])
  1981  			iNdEx = postIndex
  1982  		default:
  1983  			iNdEx = preIndex
  1984  			skippy, err := skipShimdiag(dAtA[iNdEx:])
  1985  			if err != nil {
  1986  				return err
  1987  			}
  1988  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1989  				return ErrInvalidLengthShimdiag
  1990  			}
  1991  			if (iNdEx + skippy) > l {
  1992  				return io.ErrUnexpectedEOF
  1993  			}
  1994  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1995  			iNdEx += skippy
  1996  		}
  1997  	}
  1998  
  1999  	if iNdEx > l {
  2000  		return io.ErrUnexpectedEOF
  2001  	}
  2002  	return nil
  2003  }
  2004  func (m *ShareRequest) Unmarshal(dAtA []byte) error {
  2005  	l := len(dAtA)
  2006  	iNdEx := 0
  2007  	for iNdEx < l {
  2008  		preIndex := iNdEx
  2009  		var wire uint64
  2010  		for shift := uint(0); ; shift += 7 {
  2011  			if shift >= 64 {
  2012  				return ErrIntOverflowShimdiag
  2013  			}
  2014  			if iNdEx >= l {
  2015  				return io.ErrUnexpectedEOF
  2016  			}
  2017  			b := dAtA[iNdEx]
  2018  			iNdEx++
  2019  			wire |= uint64(b&0x7F) << shift
  2020  			if b < 0x80 {
  2021  				break
  2022  			}
  2023  		}
  2024  		fieldNum := int32(wire >> 3)
  2025  		wireType := int(wire & 0x7)
  2026  		if wireType == 4 {
  2027  			return fmt.Errorf("proto: ShareRequest: wiretype end group for non-group")
  2028  		}
  2029  		if fieldNum <= 0 {
  2030  			return fmt.Errorf("proto: ShareRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  2031  		}
  2032  		switch fieldNum {
  2033  		case 1:
  2034  			if wireType != 2 {
  2035  				return fmt.Errorf("proto: wrong wireType = %d for field HostPath", wireType)
  2036  			}
  2037  			var stringLen uint64
  2038  			for shift := uint(0); ; shift += 7 {
  2039  				if shift >= 64 {
  2040  					return ErrIntOverflowShimdiag
  2041  				}
  2042  				if iNdEx >= l {
  2043  					return io.ErrUnexpectedEOF
  2044  				}
  2045  				b := dAtA[iNdEx]
  2046  				iNdEx++
  2047  				stringLen |= uint64(b&0x7F) << shift
  2048  				if b < 0x80 {
  2049  					break
  2050  				}
  2051  			}
  2052  			intStringLen := int(stringLen)
  2053  			if intStringLen < 0 {
  2054  				return ErrInvalidLengthShimdiag
  2055  			}
  2056  			postIndex := iNdEx + intStringLen
  2057  			if postIndex < 0 {
  2058  				return ErrInvalidLengthShimdiag
  2059  			}
  2060  			if postIndex > l {
  2061  				return io.ErrUnexpectedEOF
  2062  			}
  2063  			m.HostPath = string(dAtA[iNdEx:postIndex])
  2064  			iNdEx = postIndex
  2065  		case 2:
  2066  			if wireType != 2 {
  2067  				return fmt.Errorf("proto: wrong wireType = %d for field UvmPath", wireType)
  2068  			}
  2069  			var stringLen uint64
  2070  			for shift := uint(0); ; shift += 7 {
  2071  				if shift >= 64 {
  2072  					return ErrIntOverflowShimdiag
  2073  				}
  2074  				if iNdEx >= l {
  2075  					return io.ErrUnexpectedEOF
  2076  				}
  2077  				b := dAtA[iNdEx]
  2078  				iNdEx++
  2079  				stringLen |= uint64(b&0x7F) << shift
  2080  				if b < 0x80 {
  2081  					break
  2082  				}
  2083  			}
  2084  			intStringLen := int(stringLen)
  2085  			if intStringLen < 0 {
  2086  				return ErrInvalidLengthShimdiag
  2087  			}
  2088  			postIndex := iNdEx + intStringLen
  2089  			if postIndex < 0 {
  2090  				return ErrInvalidLengthShimdiag
  2091  			}
  2092  			if postIndex > l {
  2093  				return io.ErrUnexpectedEOF
  2094  			}
  2095  			m.UvmPath = string(dAtA[iNdEx:postIndex])
  2096  			iNdEx = postIndex
  2097  		case 3:
  2098  			if wireType != 0 {
  2099  				return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
  2100  			}
  2101  			var v int
  2102  			for shift := uint(0); ; shift += 7 {
  2103  				if shift >= 64 {
  2104  					return ErrIntOverflowShimdiag
  2105  				}
  2106  				if iNdEx >= l {
  2107  					return io.ErrUnexpectedEOF
  2108  				}
  2109  				b := dAtA[iNdEx]
  2110  				iNdEx++
  2111  				v |= int(b&0x7F) << shift
  2112  				if b < 0x80 {
  2113  					break
  2114  				}
  2115  			}
  2116  			m.ReadOnly = bool(v != 0)
  2117  		default:
  2118  			iNdEx = preIndex
  2119  			skippy, err := skipShimdiag(dAtA[iNdEx:])
  2120  			if err != nil {
  2121  				return err
  2122  			}
  2123  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2124  				return ErrInvalidLengthShimdiag
  2125  			}
  2126  			if (iNdEx + skippy) > l {
  2127  				return io.ErrUnexpectedEOF
  2128  			}
  2129  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2130  			iNdEx += skippy
  2131  		}
  2132  	}
  2133  
  2134  	if iNdEx > l {
  2135  		return io.ErrUnexpectedEOF
  2136  	}
  2137  	return nil
  2138  }
  2139  func (m *ShareResponse) Unmarshal(dAtA []byte) error {
  2140  	l := len(dAtA)
  2141  	iNdEx := 0
  2142  	for iNdEx < l {
  2143  		preIndex := iNdEx
  2144  		var wire uint64
  2145  		for shift := uint(0); ; shift += 7 {
  2146  			if shift >= 64 {
  2147  				return ErrIntOverflowShimdiag
  2148  			}
  2149  			if iNdEx >= l {
  2150  				return io.ErrUnexpectedEOF
  2151  			}
  2152  			b := dAtA[iNdEx]
  2153  			iNdEx++
  2154  			wire |= uint64(b&0x7F) << shift
  2155  			if b < 0x80 {
  2156  				break
  2157  			}
  2158  		}
  2159  		fieldNum := int32(wire >> 3)
  2160  		wireType := int(wire & 0x7)
  2161  		if wireType == 4 {
  2162  			return fmt.Errorf("proto: ShareResponse: wiretype end group for non-group")
  2163  		}
  2164  		if fieldNum <= 0 {
  2165  			return fmt.Errorf("proto: ShareResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  2166  		}
  2167  		switch fieldNum {
  2168  		default:
  2169  			iNdEx = preIndex
  2170  			skippy, err := skipShimdiag(dAtA[iNdEx:])
  2171  			if err != nil {
  2172  				return err
  2173  			}
  2174  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2175  				return ErrInvalidLengthShimdiag
  2176  			}
  2177  			if (iNdEx + skippy) > l {
  2178  				return io.ErrUnexpectedEOF
  2179  			}
  2180  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2181  			iNdEx += skippy
  2182  		}
  2183  	}
  2184  
  2185  	if iNdEx > l {
  2186  		return io.ErrUnexpectedEOF
  2187  	}
  2188  	return nil
  2189  }
  2190  func (m *PidRequest) Unmarshal(dAtA []byte) error {
  2191  	l := len(dAtA)
  2192  	iNdEx := 0
  2193  	for iNdEx < l {
  2194  		preIndex := iNdEx
  2195  		var wire uint64
  2196  		for shift := uint(0); ; shift += 7 {
  2197  			if shift >= 64 {
  2198  				return ErrIntOverflowShimdiag
  2199  			}
  2200  			if iNdEx >= l {
  2201  				return io.ErrUnexpectedEOF
  2202  			}
  2203  			b := dAtA[iNdEx]
  2204  			iNdEx++
  2205  			wire |= uint64(b&0x7F) << shift
  2206  			if b < 0x80 {
  2207  				break
  2208  			}
  2209  		}
  2210  		fieldNum := int32(wire >> 3)
  2211  		wireType := int(wire & 0x7)
  2212  		if wireType == 4 {
  2213  			return fmt.Errorf("proto: PidRequest: wiretype end group for non-group")
  2214  		}
  2215  		if fieldNum <= 0 {
  2216  			return fmt.Errorf("proto: PidRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  2217  		}
  2218  		switch fieldNum {
  2219  		default:
  2220  			iNdEx = preIndex
  2221  			skippy, err := skipShimdiag(dAtA[iNdEx:])
  2222  			if err != nil {
  2223  				return err
  2224  			}
  2225  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2226  				return ErrInvalidLengthShimdiag
  2227  			}
  2228  			if (iNdEx + skippy) > l {
  2229  				return io.ErrUnexpectedEOF
  2230  			}
  2231  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2232  			iNdEx += skippy
  2233  		}
  2234  	}
  2235  
  2236  	if iNdEx > l {
  2237  		return io.ErrUnexpectedEOF
  2238  	}
  2239  	return nil
  2240  }
  2241  func (m *PidResponse) Unmarshal(dAtA []byte) error {
  2242  	l := len(dAtA)
  2243  	iNdEx := 0
  2244  	for iNdEx < l {
  2245  		preIndex := iNdEx
  2246  		var wire uint64
  2247  		for shift := uint(0); ; shift += 7 {
  2248  			if shift >= 64 {
  2249  				return ErrIntOverflowShimdiag
  2250  			}
  2251  			if iNdEx >= l {
  2252  				return io.ErrUnexpectedEOF
  2253  			}
  2254  			b := dAtA[iNdEx]
  2255  			iNdEx++
  2256  			wire |= uint64(b&0x7F) << shift
  2257  			if b < 0x80 {
  2258  				break
  2259  			}
  2260  		}
  2261  		fieldNum := int32(wire >> 3)
  2262  		wireType := int(wire & 0x7)
  2263  		if wireType == 4 {
  2264  			return fmt.Errorf("proto: PidResponse: wiretype end group for non-group")
  2265  		}
  2266  		if fieldNum <= 0 {
  2267  			return fmt.Errorf("proto: PidResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  2268  		}
  2269  		switch fieldNum {
  2270  		case 1:
  2271  			if wireType != 0 {
  2272  				return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)
  2273  			}
  2274  			m.Pid = 0
  2275  			for shift := uint(0); ; shift += 7 {
  2276  				if shift >= 64 {
  2277  					return ErrIntOverflowShimdiag
  2278  				}
  2279  				if iNdEx >= l {
  2280  					return io.ErrUnexpectedEOF
  2281  				}
  2282  				b := dAtA[iNdEx]
  2283  				iNdEx++
  2284  				m.Pid |= int32(b&0x7F) << shift
  2285  				if b < 0x80 {
  2286  					break
  2287  				}
  2288  			}
  2289  		default:
  2290  			iNdEx = preIndex
  2291  			skippy, err := skipShimdiag(dAtA[iNdEx:])
  2292  			if err != nil {
  2293  				return err
  2294  			}
  2295  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2296  				return ErrInvalidLengthShimdiag
  2297  			}
  2298  			if (iNdEx + skippy) > l {
  2299  				return io.ErrUnexpectedEOF
  2300  			}
  2301  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2302  			iNdEx += skippy
  2303  		}
  2304  	}
  2305  
  2306  	if iNdEx > l {
  2307  		return io.ErrUnexpectedEOF
  2308  	}
  2309  	return nil
  2310  }
  2311  func (m *TasksRequest) Unmarshal(dAtA []byte) error {
  2312  	l := len(dAtA)
  2313  	iNdEx := 0
  2314  	for iNdEx < l {
  2315  		preIndex := iNdEx
  2316  		var wire uint64
  2317  		for shift := uint(0); ; shift += 7 {
  2318  			if shift >= 64 {
  2319  				return ErrIntOverflowShimdiag
  2320  			}
  2321  			if iNdEx >= l {
  2322  				return io.ErrUnexpectedEOF
  2323  			}
  2324  			b := dAtA[iNdEx]
  2325  			iNdEx++
  2326  			wire |= uint64(b&0x7F) << shift
  2327  			if b < 0x80 {
  2328  				break
  2329  			}
  2330  		}
  2331  		fieldNum := int32(wire >> 3)
  2332  		wireType := int(wire & 0x7)
  2333  		if wireType == 4 {
  2334  			return fmt.Errorf("proto: TasksRequest: wiretype end group for non-group")
  2335  		}
  2336  		if fieldNum <= 0 {
  2337  			return fmt.Errorf("proto: TasksRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  2338  		}
  2339  		switch fieldNum {
  2340  		case 1:
  2341  			if wireType != 0 {
  2342  				return fmt.Errorf("proto: wrong wireType = %d for field Execs", wireType)
  2343  			}
  2344  			var v int
  2345  			for shift := uint(0); ; shift += 7 {
  2346  				if shift >= 64 {
  2347  					return ErrIntOverflowShimdiag
  2348  				}
  2349  				if iNdEx >= l {
  2350  					return io.ErrUnexpectedEOF
  2351  				}
  2352  				b := dAtA[iNdEx]
  2353  				iNdEx++
  2354  				v |= int(b&0x7F) << shift
  2355  				if b < 0x80 {
  2356  					break
  2357  				}
  2358  			}
  2359  			m.Execs = bool(v != 0)
  2360  		default:
  2361  			iNdEx = preIndex
  2362  			skippy, err := skipShimdiag(dAtA[iNdEx:])
  2363  			if err != nil {
  2364  				return err
  2365  			}
  2366  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2367  				return ErrInvalidLengthShimdiag
  2368  			}
  2369  			if (iNdEx + skippy) > l {
  2370  				return io.ErrUnexpectedEOF
  2371  			}
  2372  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2373  			iNdEx += skippy
  2374  		}
  2375  	}
  2376  
  2377  	if iNdEx > l {
  2378  		return io.ErrUnexpectedEOF
  2379  	}
  2380  	return nil
  2381  }
  2382  func (m *Task) Unmarshal(dAtA []byte) error {
  2383  	l := len(dAtA)
  2384  	iNdEx := 0
  2385  	for iNdEx < l {
  2386  		preIndex := iNdEx
  2387  		var wire uint64
  2388  		for shift := uint(0); ; shift += 7 {
  2389  			if shift >= 64 {
  2390  				return ErrIntOverflowShimdiag
  2391  			}
  2392  			if iNdEx >= l {
  2393  				return io.ErrUnexpectedEOF
  2394  			}
  2395  			b := dAtA[iNdEx]
  2396  			iNdEx++
  2397  			wire |= uint64(b&0x7F) << shift
  2398  			if b < 0x80 {
  2399  				break
  2400  			}
  2401  		}
  2402  		fieldNum := int32(wire >> 3)
  2403  		wireType := int(wire & 0x7)
  2404  		if wireType == 4 {
  2405  			return fmt.Errorf("proto: Task: wiretype end group for non-group")
  2406  		}
  2407  		if fieldNum <= 0 {
  2408  			return fmt.Errorf("proto: Task: illegal tag %d (wire type %d)", fieldNum, wire)
  2409  		}
  2410  		switch fieldNum {
  2411  		case 1:
  2412  			if wireType != 2 {
  2413  				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
  2414  			}
  2415  			var stringLen uint64
  2416  			for shift := uint(0); ; shift += 7 {
  2417  				if shift >= 64 {
  2418  					return ErrIntOverflowShimdiag
  2419  				}
  2420  				if iNdEx >= l {
  2421  					return io.ErrUnexpectedEOF
  2422  				}
  2423  				b := dAtA[iNdEx]
  2424  				iNdEx++
  2425  				stringLen |= uint64(b&0x7F) << shift
  2426  				if b < 0x80 {
  2427  					break
  2428  				}
  2429  			}
  2430  			intStringLen := int(stringLen)
  2431  			if intStringLen < 0 {
  2432  				return ErrInvalidLengthShimdiag
  2433  			}
  2434  			postIndex := iNdEx + intStringLen
  2435  			if postIndex < 0 {
  2436  				return ErrInvalidLengthShimdiag
  2437  			}
  2438  			if postIndex > l {
  2439  				return io.ErrUnexpectedEOF
  2440  			}
  2441  			m.ID = string(dAtA[iNdEx:postIndex])
  2442  			iNdEx = postIndex
  2443  		case 2:
  2444  			if wireType != 2 {
  2445  				return fmt.Errorf("proto: wrong wireType = %d for field Execs", wireType)
  2446  			}
  2447  			var msglen int
  2448  			for shift := uint(0); ; shift += 7 {
  2449  				if shift >= 64 {
  2450  					return ErrIntOverflowShimdiag
  2451  				}
  2452  				if iNdEx >= l {
  2453  					return io.ErrUnexpectedEOF
  2454  				}
  2455  				b := dAtA[iNdEx]
  2456  				iNdEx++
  2457  				msglen |= int(b&0x7F) << shift
  2458  				if b < 0x80 {
  2459  					break
  2460  				}
  2461  			}
  2462  			if msglen < 0 {
  2463  				return ErrInvalidLengthShimdiag
  2464  			}
  2465  			postIndex := iNdEx + msglen
  2466  			if postIndex < 0 {
  2467  				return ErrInvalidLengthShimdiag
  2468  			}
  2469  			if postIndex > l {
  2470  				return io.ErrUnexpectedEOF
  2471  			}
  2472  			m.Execs = append(m.Execs, &Exec{})
  2473  			if err := m.Execs[len(m.Execs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2474  				return err
  2475  			}
  2476  			iNdEx = postIndex
  2477  		default:
  2478  			iNdEx = preIndex
  2479  			skippy, err := skipShimdiag(dAtA[iNdEx:])
  2480  			if err != nil {
  2481  				return err
  2482  			}
  2483  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2484  				return ErrInvalidLengthShimdiag
  2485  			}
  2486  			if (iNdEx + skippy) > l {
  2487  				return io.ErrUnexpectedEOF
  2488  			}
  2489  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2490  			iNdEx += skippy
  2491  		}
  2492  	}
  2493  
  2494  	if iNdEx > l {
  2495  		return io.ErrUnexpectedEOF
  2496  	}
  2497  	return nil
  2498  }
  2499  func (m *Exec) Unmarshal(dAtA []byte) error {
  2500  	l := len(dAtA)
  2501  	iNdEx := 0
  2502  	for iNdEx < l {
  2503  		preIndex := iNdEx
  2504  		var wire uint64
  2505  		for shift := uint(0); ; shift += 7 {
  2506  			if shift >= 64 {
  2507  				return ErrIntOverflowShimdiag
  2508  			}
  2509  			if iNdEx >= l {
  2510  				return io.ErrUnexpectedEOF
  2511  			}
  2512  			b := dAtA[iNdEx]
  2513  			iNdEx++
  2514  			wire |= uint64(b&0x7F) << shift
  2515  			if b < 0x80 {
  2516  				break
  2517  			}
  2518  		}
  2519  		fieldNum := int32(wire >> 3)
  2520  		wireType := int(wire & 0x7)
  2521  		if wireType == 4 {
  2522  			return fmt.Errorf("proto: Exec: wiretype end group for non-group")
  2523  		}
  2524  		if fieldNum <= 0 {
  2525  			return fmt.Errorf("proto: Exec: illegal tag %d (wire type %d)", fieldNum, wire)
  2526  		}
  2527  		switch fieldNum {
  2528  		case 1:
  2529  			if wireType != 2 {
  2530  				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
  2531  			}
  2532  			var stringLen uint64
  2533  			for shift := uint(0); ; shift += 7 {
  2534  				if shift >= 64 {
  2535  					return ErrIntOverflowShimdiag
  2536  				}
  2537  				if iNdEx >= l {
  2538  					return io.ErrUnexpectedEOF
  2539  				}
  2540  				b := dAtA[iNdEx]
  2541  				iNdEx++
  2542  				stringLen |= uint64(b&0x7F) << shift
  2543  				if b < 0x80 {
  2544  					break
  2545  				}
  2546  			}
  2547  			intStringLen := int(stringLen)
  2548  			if intStringLen < 0 {
  2549  				return ErrInvalidLengthShimdiag
  2550  			}
  2551  			postIndex := iNdEx + intStringLen
  2552  			if postIndex < 0 {
  2553  				return ErrInvalidLengthShimdiag
  2554  			}
  2555  			if postIndex > l {
  2556  				return io.ErrUnexpectedEOF
  2557  			}
  2558  			m.ID = string(dAtA[iNdEx:postIndex])
  2559  			iNdEx = postIndex
  2560  		case 2:
  2561  			if wireType != 2 {
  2562  				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
  2563  			}
  2564  			var stringLen uint64
  2565  			for shift := uint(0); ; shift += 7 {
  2566  				if shift >= 64 {
  2567  					return ErrIntOverflowShimdiag
  2568  				}
  2569  				if iNdEx >= l {
  2570  					return io.ErrUnexpectedEOF
  2571  				}
  2572  				b := dAtA[iNdEx]
  2573  				iNdEx++
  2574  				stringLen |= uint64(b&0x7F) << shift
  2575  				if b < 0x80 {
  2576  					break
  2577  				}
  2578  			}
  2579  			intStringLen := int(stringLen)
  2580  			if intStringLen < 0 {
  2581  				return ErrInvalidLengthShimdiag
  2582  			}
  2583  			postIndex := iNdEx + intStringLen
  2584  			if postIndex < 0 {
  2585  				return ErrInvalidLengthShimdiag
  2586  			}
  2587  			if postIndex > l {
  2588  				return io.ErrUnexpectedEOF
  2589  			}
  2590  			m.State = string(dAtA[iNdEx:postIndex])
  2591  			iNdEx = postIndex
  2592  		default:
  2593  			iNdEx = preIndex
  2594  			skippy, err := skipShimdiag(dAtA[iNdEx:])
  2595  			if err != nil {
  2596  				return err
  2597  			}
  2598  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2599  				return ErrInvalidLengthShimdiag
  2600  			}
  2601  			if (iNdEx + skippy) > l {
  2602  				return io.ErrUnexpectedEOF
  2603  			}
  2604  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2605  			iNdEx += skippy
  2606  		}
  2607  	}
  2608  
  2609  	if iNdEx > l {
  2610  		return io.ErrUnexpectedEOF
  2611  	}
  2612  	return nil
  2613  }
  2614  func (m *TasksResponse) Unmarshal(dAtA []byte) error {
  2615  	l := len(dAtA)
  2616  	iNdEx := 0
  2617  	for iNdEx < l {
  2618  		preIndex := iNdEx
  2619  		var wire uint64
  2620  		for shift := uint(0); ; shift += 7 {
  2621  			if shift >= 64 {
  2622  				return ErrIntOverflowShimdiag
  2623  			}
  2624  			if iNdEx >= l {
  2625  				return io.ErrUnexpectedEOF
  2626  			}
  2627  			b := dAtA[iNdEx]
  2628  			iNdEx++
  2629  			wire |= uint64(b&0x7F) << shift
  2630  			if b < 0x80 {
  2631  				break
  2632  			}
  2633  		}
  2634  		fieldNum := int32(wire >> 3)
  2635  		wireType := int(wire & 0x7)
  2636  		if wireType == 4 {
  2637  			return fmt.Errorf("proto: TasksResponse: wiretype end group for non-group")
  2638  		}
  2639  		if fieldNum <= 0 {
  2640  			return fmt.Errorf("proto: TasksResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  2641  		}
  2642  		switch fieldNum {
  2643  		case 1:
  2644  			if wireType != 2 {
  2645  				return fmt.Errorf("proto: wrong wireType = %d for field Tasks", wireType)
  2646  			}
  2647  			var msglen int
  2648  			for shift := uint(0); ; shift += 7 {
  2649  				if shift >= 64 {
  2650  					return ErrIntOverflowShimdiag
  2651  				}
  2652  				if iNdEx >= l {
  2653  					return io.ErrUnexpectedEOF
  2654  				}
  2655  				b := dAtA[iNdEx]
  2656  				iNdEx++
  2657  				msglen |= int(b&0x7F) << shift
  2658  				if b < 0x80 {
  2659  					break
  2660  				}
  2661  			}
  2662  			if msglen < 0 {
  2663  				return ErrInvalidLengthShimdiag
  2664  			}
  2665  			postIndex := iNdEx + msglen
  2666  			if postIndex < 0 {
  2667  				return ErrInvalidLengthShimdiag
  2668  			}
  2669  			if postIndex > l {
  2670  				return io.ErrUnexpectedEOF
  2671  			}
  2672  			m.Tasks = append(m.Tasks, &Task{})
  2673  			if err := m.Tasks[len(m.Tasks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2674  				return err
  2675  			}
  2676  			iNdEx = postIndex
  2677  		default:
  2678  			iNdEx = preIndex
  2679  			skippy, err := skipShimdiag(dAtA[iNdEx:])
  2680  			if err != nil {
  2681  				return err
  2682  			}
  2683  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2684  				return ErrInvalidLengthShimdiag
  2685  			}
  2686  			if (iNdEx + skippy) > l {
  2687  				return io.ErrUnexpectedEOF
  2688  			}
  2689  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2690  			iNdEx += skippy
  2691  		}
  2692  	}
  2693  
  2694  	if iNdEx > l {
  2695  		return io.ErrUnexpectedEOF
  2696  	}
  2697  	return nil
  2698  }
  2699  func skipShimdiag(dAtA []byte) (n int, err error) {
  2700  	l := len(dAtA)
  2701  	iNdEx := 0
  2702  	depth := 0
  2703  	for iNdEx < l {
  2704  		var wire uint64
  2705  		for shift := uint(0); ; shift += 7 {
  2706  			if shift >= 64 {
  2707  				return 0, ErrIntOverflowShimdiag
  2708  			}
  2709  			if iNdEx >= l {
  2710  				return 0, io.ErrUnexpectedEOF
  2711  			}
  2712  			b := dAtA[iNdEx]
  2713  			iNdEx++
  2714  			wire |= (uint64(b) & 0x7F) << shift
  2715  			if b < 0x80 {
  2716  				break
  2717  			}
  2718  		}
  2719  		wireType := int(wire & 0x7)
  2720  		switch wireType {
  2721  		case 0:
  2722  			for shift := uint(0); ; shift += 7 {
  2723  				if shift >= 64 {
  2724  					return 0, ErrIntOverflowShimdiag
  2725  				}
  2726  				if iNdEx >= l {
  2727  					return 0, io.ErrUnexpectedEOF
  2728  				}
  2729  				iNdEx++
  2730  				if dAtA[iNdEx-1] < 0x80 {
  2731  					break
  2732  				}
  2733  			}
  2734  		case 1:
  2735  			iNdEx += 8
  2736  		case 2:
  2737  			var length int
  2738  			for shift := uint(0); ; shift += 7 {
  2739  				if shift >= 64 {
  2740  					return 0, ErrIntOverflowShimdiag
  2741  				}
  2742  				if iNdEx >= l {
  2743  					return 0, io.ErrUnexpectedEOF
  2744  				}
  2745  				b := dAtA[iNdEx]
  2746  				iNdEx++
  2747  				length |= (int(b) & 0x7F) << shift
  2748  				if b < 0x80 {
  2749  					break
  2750  				}
  2751  			}
  2752  			if length < 0 {
  2753  				return 0, ErrInvalidLengthShimdiag
  2754  			}
  2755  			iNdEx += length
  2756  		case 3:
  2757  			depth++
  2758  		case 4:
  2759  			if depth == 0 {
  2760  				return 0, ErrUnexpectedEndOfGroupShimdiag
  2761  			}
  2762  			depth--
  2763  		case 5:
  2764  			iNdEx += 4
  2765  		default:
  2766  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  2767  		}
  2768  		if iNdEx < 0 {
  2769  			return 0, ErrInvalidLengthShimdiag
  2770  		}
  2771  		if depth == 0 {
  2772  			return iNdEx, nil
  2773  		}
  2774  	}
  2775  	return 0, io.ErrUnexpectedEOF
  2776  }
  2777  
  2778  var (
  2779  	ErrInvalidLengthShimdiag        = fmt.Errorf("proto: negative length found during unmarshaling")
  2780  	ErrIntOverflowShimdiag          = fmt.Errorf("proto: integer overflow")
  2781  	ErrUnexpectedEndOfGroupShimdiag = fmt.Errorf("proto: unexpected end of group")
  2782  )
  2783  

View as plain text