Repository: firecracker-microvm/firecracker-containerd
Pull request #178 (2019-05-07 17:12:31)

Re-use proto messages for both ttrpc and grpc.
Before this change, each protobuf message type was generated for both grpc and
ttrpc. However, if both definitions get loaded into the same process (i.e. a
process that's translating between the two such as the fccontrol plugin), the
protobuf names will conflict with each other.

This change results in protobuf message types being generated only once. Now
only the service definitions are generated separately for both grpc and ttrpc.

Signed-off-by: Erik Sipsma <sipsma@amazon.com>

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.



Patch:
diff --git a/Makefile b/Makefile
index cc7298d..cefb049 100644
--- a/Makefile
+++ b/Makefile
@@ -54,6 +54,7 @@ deps:
 	GOBIN=$(BINPATH) GO111MODULE=off go get -u github.com/vbatts/git-validation
 	GOBIN=$(BINPATH) GO111MODULE=off go get -u github.com/kunalkushwaha/ltag
 	GOBIN=$(BINPATH) GO111MODULE=off go get -u github.com/containerd/ttrpc/cmd/protoc-gen-gogottrpc
+	GOBIN=$(BINPATH) GO111MODULE=off go get -u github.com/gogo/protobuf/protoc-gen-gogo
 
 runc-builder: runc-builder-stamp
 
diff --git a/agent/service.go b/agent/service.go
index 26d4ef4..188a410 100644
--- a/agent/service.go
+++ b/agent/service.go
@@ -33,7 +33,7 @@ import (
 
 	"github.com/firecracker-microvm/firecracker-containerd/internal/bundle"
 	"github.com/firecracker-microvm/firecracker-containerd/internal/vm"
-	proto "github.com/firecracker-microvm/firecracker-containerd/proto/grpc"
+	"github.com/firecracker-microvm/firecracker-containerd/proto"
 )
 
 const (
diff --git a/examples/taskworkflow.go b/examples/taskworkflow.go
index 28cabe0..baf2a0c 100644
--- a/examples/taskworkflow.go
+++ b/examples/taskworkflow.go
@@ -27,7 +27,7 @@ import (
 	"github.com/containerd/containerd/cio"
 	"github.com/containerd/containerd/namespaces"
 	"github.com/containerd/containerd/oci"
-	proto "github.com/firecracker-microvm/firecracker-containerd/proto/grpc"
+	"github.com/firecracker-microvm/firecracker-containerd/proto"
 	specs "github.com/opencontainers/runtime-spec/specs-go"
 	"github.com/pkg/errors"
 )
diff --git a/firecracker-control/helpers.go b/firecracker-control/helpers.go
index 696ced8..2a4783d 100644
--- a/firecracker-control/helpers.go
+++ b/firecracker-control/helpers.go
@@ -19,7 +19,7 @@ import (
 	"github.com/firecracker-microvm/firecracker-go-sdk"
 	models "github.com/firecracker-microvm/firecracker-go-sdk/client/models"
 
-	proto "github.com/firecracker-microvm/firecracker-containerd/proto/grpc"
+	"github.com/firecracker-microvm/firecracker-containerd/proto"
 )
 
 func machineConfigurationFromProto(req *proto.FirecrackerMachineConfiguration) models.MachineConfiguration {
diff --git a/firecracker-control/local.go b/firecracker-control/local.go
index b39e7f0..509c3e9 100644
--- a/firecracker-control/local.go
+++ b/firecracker-control/local.go
@@ -29,11 +29,12 @@ import (
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 
-	proto "github.com/firecracker-microvm/firecracker-containerd/proto/grpc"
+	"github.com/firecracker-microvm/firecracker-containerd/proto"
+	fccontrol "github.com/firecracker-microvm/firecracker-containerd/proto/service/fccontrol/grpc"
 )
 
 var (
-	_ proto.FirecrackerServer = (*local)(nil)
+	_ fccontrol.FirecrackerServer = (*local)(nil)
 )
 
 func init() {
diff --git a/firecracker-control/service.go b/firecracker-control/service.go
index fda61e7..f0d948f 100644
--- a/firecracker-control/service.go
+++ b/firecracker-control/service.go
@@ -22,7 +22,8 @@ import (
 	"github.com/golang/protobuf/ptypes/empty"
 	"google.golang.org/grpc"
 
-	proto "github.com/firecracker-microvm/firecracker-containerd/proto/grpc"
+	"github.com/firecracker-microvm/firecracker-containerd/proto"
+	fccontrol "github.com/firecracker-microvm/firecracker-containerd/proto/service/fccontrol/grpc"
 )
 
 func init() {
@@ -50,19 +51,19 @@ func init() {
 				return nil, err
 			}
 
-			return &service{local: instance.(proto.FirecrackerServer)}, nil
+			return &service{local: instance.(fccontrol.FirecrackerServer)}, nil
 		},
 	})
 }
 
 type service struct {
-	local proto.FirecrackerServer
+	local fccontrol.FirecrackerServer
 }
 
-var _ proto.FirecrackerServer = (*service)(nil)
+var _ fccontrol.FirecrackerServer = (*service)(nil)
 
 func (s *service) Register(server *grpc.Server) error {
-	proto.RegisterFirecrackerServer(server, s)
+	fccontrol.RegisterFirecrackerServer(server, s)
 	return nil
 }
 
diff --git a/internal/vm/task.go b/internal/vm/task.go
index d203ebc..3b2c834 100644
--- a/internal/vm/task.go
+++ b/internal/vm/task.go
@@ -30,7 +30,7 @@ import (
 
 	"github.com/firecracker-microvm/firecracker-containerd/internal"
 	"github.com/firecracker-microvm/firecracker-containerd/internal/bundle"
-	proto "github.com/firecracker-microvm/firecracker-containerd/proto/grpc"
+	"github.com/firecracker-microvm/firecracker-containerd/proto"
 )
 
 // IODirection represents the direction in which container related I/O should
diff --git a/proto/Makefile b/proto/Makefile
index 1215f23..40848b9 100644
--- a/proto/Makefile
+++ b/proto/Makefile
@@ -13,22 +13,17 @@
 
 PROTO_SRC := $(wildcard *.proto)
 PROTO_GEN_SRC := $(PROTO_SRC:.proto=.pb.go)
-PROTO_GEN_SRC_GRPC := $(addprefix grpc/,$(PROTO_GEN_SRC))
-PROTO_GEN_SRC_TTRPC := $(addprefix ttrpc/,$(PROTO_GEN_SRC))
 
-$(PROTO_GEN_SRC_TTRPC): $(PROTO_SRC)
+$(PROTO_GEN_SRC): $(PROTO_SRC)
 	protoc \
-		--gogottrpc_out=plugins=ttrpc,Mgoogle/protobuf/any.proto=github.com/gogo/protobuf/types:ttrpc \
+		--gogo_out=Mgoogle/protobuf/any.proto=github.com/gogo/protobuf/types:. \
 		$^
 
-$(PROTO_GEN_SRC_GRPC): $(PROTO_SRC)
-	protoc \
-		--gogo_out=plugins=grpc,Mgoogle/protobuf/any.proto=github.com/gogo/protobuf/types:grpc \
-		$^
-
-proto: $(PROTO_GEN_SRC_GRPC) $(PROTO_GEN_SRC_TTRPC)
+proto: $(PROTO_GEN_SRC)
+	PROTOPATH=$(CURDIR) $(MAKE) -C service/fccontrol proto
 
 clean:
-	- rm -f $(PROTO_GEN_SRC_GRPC) $(PROTO_GEN_SRC_TTRPC)
+	- rm -f $(PROTO_GEN_SRC)
+	- $(MAKE) -C service/fccontrol clean
 
 .PHONY: clean proto
diff --git a/proto/grpc/events.pb.go b/proto/events.pb.go
similarity index 100%
rename from proto/grpc/events.pb.go
rename to proto/events.pb.go
diff --git a/proto/grpc/firecracker.pb.go b/proto/firecracker.pb.go
similarity index 54%
rename from proto/grpc/firecracker.pb.go
rename to proto/firecracker.pb.go
index bbe66ab..e9afdf6 100644
--- a/proto/grpc/firecracker.pb.go
+++ b/proto/firecracker.pb.go
@@ -4,11 +4,8 @@
 package proto
 
 import (
-	context "context"
 	fmt "fmt"
 	proto "github.com/gogo/protobuf/proto"
-	empty "github.com/golang/protobuf/ptypes/empty"
-	grpc "google.golang.org/grpc"
 	math "math"
 )
 
@@ -329,216 +326,31 @@ func init() {
 func init() { proto.RegisterFile("firecracker.proto", fileDescriptor_a73317e9fb8da571) }
 
 var fileDescriptor_a73317e9fb8da571 = []byte{
-	// 502 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x53, 0xdb, 0x6e, 0xd3, 0x40,
-	0x10, 0x95, 0xc9, 0xa5, 0xf1, 0x44, 0xb9, 0x78, 0x05, 0xc8, 0x0a, 0x15, 0xb2, 0x82, 0x54, 0xe5,
-	0x69, 0x83, 0x02, 0xaf, 0x20, 0x4a, 0x42, 0x90, 0x01, 0x23, 0xe4, 0x48, 0x79, 0xe0, 0x6d, 0x71,
-	0xc6, 0xae, 0x95, 0x64, 0x37, 0xac, 0x37, 0x85, 0x7e, 0x08, 0x1f, 0xc2, 0x67, 0xf1, 0x17, 0xc8,
-	0xeb, 0x3a, 0xb5, 0xdd, 0x34, 0x4f, 0xd6, 0x9c, 0x39, 0x47, 0x73, 0xbc, 0x67, 0x06, 0xac, 0x30,
-	0x96, 0x18, 0x48, 0x16, 0xac, 0x51, 0xd2, 0x9d, 0x14, 0x4a, 0x0c, 0x9e, 0x45, 0x42, 0x44, 0x1b,
-	0x1c, 0xeb, 0xea, 0xc7, 0x3e, 0x1c, 0xe3, 0x76, 0xa7, 0x6e, 0x6e, 0x9b, 0x6d, 0x75, 0xb3, 0xc3,
-	0x24, 0x2b, 0x86, 0x7f, 0x6a, 0xd0, 0x9b, 0x4a, 0x64, 0x0a, 0x97, 0x9e, 0x8f, 0x3f, 0xf7, 0x98,
-	0x28, 0x42, 0xa0, 0xbe, 0xf4, 0xdc, 0x99, 0x6d, 0x38, 0xc6, 0xc8, 0xf4, 0xeb, 0xd7, 0x9e, 0x3b,
-	0x23, 0xef, 0x00, 0x3c, 0x16, 0x5c, 0xc5, 0x1c, 0xa7, 0x61, 0x64, 0x3f, 0x72, 0x8c, 0x51, 0x7b,
-	0xe2, 0xd0, 0xf9, 0xdd, 0xe4, 0xbc, 0x2b, 0x78, 0x18, 0x47, 0x7b, 0xc9, 0x54, 0x2c, 0xb8, 0x0f,
-	0xdb, 0x83, 0x86, 0x8c, 0xa0, 0xf7, 0x19, 0x25, 0xc7, 0x8d, 0xbb, 0x65, 0x11, 0x7e, 0x63, 0xea,
-	0xca, 0xae, 0xe9, 0x01, 0xbd, 0x75, 0x19, 0x26, 0xcf, 0x01, 0x32, 0xe6, 0xa5, 0x8c, 0x12, 0xbb,
-	0xae, 0x49, 0xb0, 0x3e, 0x20, 0x64, 0x0c, 0xa6, 0x2f, 0x84, 0x9a, 0xc9, 0xf8, 0x1a, 0xed, 0x86,
-	0xb6, 0x62, 0x15, 0xad, 0xe8, 0x86, 0x6f, 0xca, 0x9c, 0x43, 0xde, 0x40, 0xff, 0x72, 0xb5, 0x8a,
-	0x53, 0x4b, 0x6c, 0xa3, 0xa1, 0xc4, 0x6e, 0x3a, 0xb5, 0xe3, 0xba, 0x3e, 0xab, 0x50, 0xc9, 0x27,
-	0xb0, 0xbe, 0xa2, 0xfa, 0x25, 0xe4, 0xda, 0xe5, 0x0a, 0x65, 0xc8, 0x02, 0x4c, 0xec, 0x33, 0xad,
-	0x3f, 0x2f, 0xea, 0xab, 0x24, 0xdf, 0xe2, 0x55, 0x19, 0xb9, 0x80, 0xee, 0x54, 0x70, 0xc5, 0x62,
-	0x8e, 0x72, 0x2a, 0xf6, 0x5c, 0xd9, 0x2d, 0xc7, 0x18, 0x35, 0xfc, 0x6e, 0x50, 0x42, 0x87, 0x2f,
-	0xa0, 0xb3, 0x50, 0x62, 0x77, 0x32, 0x94, 0xe1, 0x05, 0xf4, 0x3f, 0xa2, 0x5a, 0x7a, 0x2e, 0x0f,
-	0xc5, 0x29, 0xde, 0x5f, 0x03, 0xac, 0x02, 0x31, 0xd9, 0x09, 0x9e, 0xe0, 0xd1, 0x98, 0xcf, 0xc1,
-	0x4c, 0xed, 0xe1, 0x6f, 0xe5, 0xce, 0x74, 0xca, 0x1d, 0xdf, 0x0c, 0x72, 0x20, 0x0d, 0x66, 0x21,
-	0x82, 0x35, 0xaa, 0x42, 0x7a, 0x90, 0x1c, 0x10, 0xe2, 0x40, 0xfb, 0x8b, 0x88, 0xe6, 0x71, 0x28,
-	0x34, 0x21, 0x4b, 0xae, 0xbd, 0xb9, 0x83, 0xd2, 0x25, 0xf0, 0x50, 0xc9, 0x38, 0x48, 0x0e, 0xac,
-	0x46, 0xb6, 0x04, 0xdb, 0x32, 0x3c, 0x9c, 0xc3, 0xe3, 0x45, 0x6a, 0xd9, 0x43, 0xc5, 0x56, 0x4c,
-	0xb1, 0x53, 0xcb, 0x39, 0x80, 0x56, 0x4e, 0xd3, 0xa6, 0x4d, 0xbf, 0xb5, 0xbd, 0xad, 0x27, 0xff,
-	0x0c, 0x68, 0x17, 0x32, 0x22, 0xaf, 0xa1, 0x95, 0xef, 0x3b, 0xe9, 0xd3, 0xca, 0xea, 0x0f, 0x9e,
-	0xd2, 0xec, 0x72, 0x68, 0x7e, 0x39, 0xf4, 0x43, 0x7a, 0x39, 0xe4, 0x25, 0x34, 0xb3, 0x38, 0x48,
-	0x97, 0x96, 0x72, 0x79, 0x50, 0x31, 0x01, 0xf3, 0xf0, 0xe4, 0xc4, 0xa2, 0xd5, 0x9c, 0x06, 0x84,
-	0xde, 0x4f, 0xe4, 0x2d, 0x74, 0x4a, 0xff, 0x4c, 0x9e, 0xd0, 0x63, 0x6f, 0xf0, 0xd0, 0xcc, 0xf7,
-	0x67, 0xdf, 0x1b, 0x19, 0xd2, 0xd4, 0x9f, 0x57, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0x29, 0xa5,
-	0xe3, 0xff, 0x1b, 0x04, 0x00, 0x00,
-}
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConn
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion4
-
-// FirecrackerClient is the client API for Firecracker service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type FirecrackerClient interface {
-	// Runs new Firecracker VM instance
-	CreateVM(ctx context.Context, in *CreateVMRequest, opts ...grpc.CallOption) (*empty.Empty, error)
-	// Stops existing Firecracker instance by VM ID
-	StopVM(ctx context.Context, in *StopVMRequest, opts ...grpc.CallOption) (*empty.Empty, error)
-	// Returns VM info by VM ID
-	GetVMInfo(ctx context.Context, in *GetVMInfoRequest, opts ...grpc.CallOption) (*GetVMInfoResponse, error)
-	// Sets VM's instance metadata
-	SetVMMetadata(ctx context.Context, in *SetVMMetadataRequest, opts ...grpc.CallOption) (*empty.Empty, error)
-}
-
-type firecrackerClient struct {
-	cc *grpc.ClientConn
-}
-
-func NewFirecrackerClient(cc *grpc.ClientConn) FirecrackerClient {
-	return &firecrackerClient{cc}
-}
-
-func (c *firecrackerClient) CreateVM(ctx context.Context, in *CreateVMRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
-	out := new(empty.Empty)
-	err := c.cc.Invoke(ctx, "/Firecracker/CreateVM", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *firecrackerClient) StopVM(ctx context.Context, in *StopVMRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
-	out := new(empty.Empty)
-	err := c.cc.Invoke(ctx, "/Firecracker/StopVM", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *firecrackerClient) GetVMInfo(ctx context.Context, in *GetVMInfoRequest, opts ...grpc.CallOption) (*GetVMInfoResponse, error) {
-	out := new(GetVMInfoResponse)
-	err := c.cc.Invoke(ctx, "/Firecracker/GetVMInfo", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *firecrackerClient) SetVMMetadata(ctx context.Context, in *SetVMMetadataRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
-	out := new(empty.Empty)
-	err := c.cc.Invoke(ctx, "/Firecracker/SetVMMetadata", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// FirecrackerServer is the server API for Firecracker service.
-type FirecrackerServer interface {
-	// Runs new Firecracker VM instance
-	CreateVM(context.Context, *CreateVMRequest) (*empty.Empty, error)
-	// Stops existing Firecracker instance by VM ID
-	StopVM(context.Context, *StopVMRequest) (*empty.Empty, error)
-	// Returns VM info by VM ID
-	GetVMInfo(context.Context, *GetVMInfoRequest) (*GetVMInfoResponse, error)
-	// Sets VM's instance metadata
-	SetVMMetadata(context.Context, *SetVMMetadataRequest) (*empty.Empty, error)
-}
-
-func RegisterFirecrackerServer(s *grpc.Server, srv FirecrackerServer) {
-	s.RegisterService(&_Firecracker_serviceDesc, srv)
-}
-
-func _Firecracker_CreateVM_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(CreateVMRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(FirecrackerServer).CreateVM(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/Firecracker/CreateVM",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(FirecrackerServer).CreateVM(ctx, req.(*CreateVMRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Firecracker_StopVM_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(StopVMRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(FirecrackerServer).StopVM(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/Firecracker/StopVM",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(FirecrackerServer).StopVM(ctx, req.(*StopVMRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Firecracker_GetVMInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetVMInfoRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(FirecrackerServer).GetVMInfo(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/Firecracker/GetVMInfo",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(FirecrackerServer).GetVMInfo(ctx, req.(*GetVMInfoRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Firecracker_SetVMMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(SetVMMetadataRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(FirecrackerServer).SetVMMetadata(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/Firecracker/SetVMMetadata",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(FirecrackerServer).SetVMMetadata(ctx, req.(*SetVMMetadataRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-var _Firecracker_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "Firecracker",
-	HandlerType: (*FirecrackerServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "CreateVM",
-			Handler:    _Firecracker_CreateVM_Handler,
-		},
-		{
-			MethodName: "StopVM",
-			Handler:    _Firecracker_StopVM_Handler,
-		},
-		{
-			MethodName: "GetVMInfo",
-			Handler:    _Firecracker_GetVMInfo_Handler,
-		},
-		{
-			MethodName: "SetVMMetadata",
-			Handler:    _Firecracker_SetVMMetadata_Handler,
-		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "firecracker.proto",
+	// 416 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x92, 0xd1, 0x8a, 0x13, 0x31,
+	0x18, 0x85, 0x19, 0xdb, 0xee, 0x76, 0xfe, 0xb2, 0xdb, 0x4e, 0xf0, 0x22, 0x2c, 0x8b, 0x0c, 0x15,
+	0x96, 0x5e, 0xad, 0xa0, 0xd7, 0x82, 0x6b, 0x4b, 0x65, 0xd4, 0x11, 0x49, 0xa1, 0x17, 0xde, 0xc5,
+	0xf4, 0x9f, 0xd9, 0x30, 0x6d, 0x52, 0x93, 0xbf, 0xab, 0x3e, 0x88, 0x0f, 0xe2, 0x1b, 0xca, 0xa4,
+	0xb6, 0x3b, 0x2d, 0x4b, 0xaf, 0x86, 0x9c, 0x7c, 0x67, 0x72, 0xe0, 0x1c, 0x48, 0x0a, 0xed, 0x50,
+	0x39, 0xa9, 0x2a, 0x74, 0xb7, 0x6b, 0x67, 0xc9, 0x5e, 0xf5, 0xe8, 0xf7, 0x1a, 0xfd, 0xf6, 0x30,
+	0xfc, 0xd3, 0x82, 0xfe, 0xd8, 0xa1, 0x24, 0x9c, 0xe7, 0x02, 0x7f, 0x6c, 0xd0, 0x13, 0x63, 0xd0,
+	0x9e, 0xe7, 0xd9, 0x84, 0x47, 0x69, 0x34, 0x8a, 0x45, 0xfb, 0x21, 0xcf, 0x26, 0xec, 0x1d, 0x40,
+	0x2e, 0xd5, 0xbd, 0x36, 0x38, 0x2e, 0x4a, 0xfe, 0x2c, 0x8d, 0x46, 0xbd, 0xd7, 0xe9, 0xed, 0xf4,
+	0xf1, 0xe7, 0xbb, 0x5b, 0x6b, 0x0a, 0x5d, 0x6e, 0x9c, 0x24, 0x6d, 0x8d, 0x80, 0xd5, 0xde, 0xc3,
+	0x46, 0xd0, 0xff, 0x84, 0xce, 0xe0, 0x32, 0x5b, 0xc9, 0x12, 0xbf, 0x4a, 0xba, 0xe7, 0xad, 0xf0,
+	0x40, 0xbf, 0x3a, 0x94, 0xd9, 0x0b, 0x80, 0x2d, 0x79, 0xe7, 0x4a, 0xcf, 0xdb, 0x01, 0x82, 0x6a,
+	0xaf, 0xb0, 0x57, 0x10, 0x0b, 0x6b, 0x69, 0xe2, 0xf4, 0x03, 0xf2, 0x4e, 0x88, 0x92, 0x34, 0xa3,
+	0x84, 0x0b, 0x11, 0xbb, 0x1d, 0xc3, 0xde, 0xc2, 0xe0, 0x6e, 0xb1, 0xd0, 0x75, 0x24, 0xb9, 0x0c,
+	0x92, 0xe7, 0x67, 0x69, 0xeb, 0x69, 0xdf, 0x40, 0x1e, 0xa1, 0xec, 0x23, 0x24, 0x5f, 0x90, 0x7e,
+	0x5a, 0x57, 0x65, 0x86, 0xd0, 0x15, 0x52, 0xa1, 0xe7, 0xe7, 0xc1, 0x7f, 0xdd, 0xf4, 0x1f, 0x43,
+	0x22, 0x31, 0xc7, 0x36, 0x76, 0x03, 0x97, 0x63, 0x6b, 0x48, 0x6a, 0x83, 0x6e, 0x6c, 0x37, 0x86,
+	0x78, 0x37, 0x8d, 0x46, 0x1d, 0x71, 0xa9, 0x0e, 0xd4, 0xe1, 0x4b, 0xb8, 0x98, 0x91, 0x5d, 0x9f,
+	0x2c, 0x65, 0x78, 0x03, 0x83, 0x0f, 0x48, 0xf3, 0x3c, 0x33, 0x85, 0x3d, 0xc5, 0xfd, 0x8d, 0x20,
+	0x69, 0x80, 0x7e, 0x6d, 0x8d, 0xc7, 0x27, 0x6b, 0xbe, 0x86, 0xb8, 0x8e, 0x87, 0xbf, 0x28, 0x9b,
+	0x84, 0x96, 0x2f, 0x44, 0xac, 0x76, 0x42, 0x5d, 0xcc, 0xcc, 0xaa, 0x0a, 0xa9, 0xd1, 0x1e, 0xf8,
+	0xbd, 0xc2, 0x52, 0xe8, 0x7d, 0xb6, 0xe5, 0x54, 0x17, 0x36, 0x00, 0xdb, 0xe6, 0x7a, 0xcb, 0x47,
+	0xa9, 0x1e, 0x41, 0x8e, 0xe4, 0xb4, 0xf2, 0x7b, 0xaa, 0xb3, 0x1d, 0xc1, 0xea, 0x50, 0x1e, 0x4e,
+	0xe1, 0xf9, 0xac, 0x8e, 0x9c, 0x23, 0xc9, 0x85, 0x24, 0x79, 0x6a, 0x9c, 0x57, 0xd0, 0xdd, 0x61,
+	0x21, 0x74, 0x2c, 0xba, 0xab, 0xff, 0xe7, 0xf7, 0xe7, 0xdf, 0x3a, 0x61, 0xe9, 0xdf, 0xcf, 0xc2,
+	0xe7, 0xcd, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x58, 0x21, 0x2d, 0x79, 0x12, 0x03, 0x00, 0x00,
 }
diff --git a/proto/firecracker.proto b/proto/firecracker.proto
index aae660e..3da4b0f 100644
--- a/proto/firecracker.proto
+++ b/proto/firecracker.proto
@@ -1,24 +1,9 @@
 syntax = "proto3";
 
-import "google/protobuf/empty.proto";
 import "types.proto";
 
 option go_package = "proto";
 
-service Firecracker {
-    // Runs new Firecracker VM instance
-    rpc CreateVM(CreateVMRequest) returns (google.protobuf.Empty);
-
-    // Stops existing Firecracker instance by VM ID
-    rpc StopVM(StopVMRequest) returns (google.protobuf.Empty);
-
-    // Returns VM info by VM ID
-    rpc GetVMInfo(GetVMInfoRequest) returns (GetVMInfoResponse);
-
-    // Sets VM's instance metadata
-    rpc SetVMMetadata(SetVMMetadataRequest) returns (google.protobuf.Empty);
-}
-
 // CreateVMRequest specifies creation parameters for a new FC instance
 message CreateVMRequest {
     // VM identifier to assign
diff --git a/proto/service/fccontrol/Makefile b/proto/service/fccontrol/Makefile
new file mode 100644
index 0000000..0964b09
--- /dev/null
+++ b/proto/service/fccontrol/Makefile
@@ -0,0 +1,34 @@
+# Copyright 2018-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You may
+# not use this file except in compliance with the License. A copy of the
+# License is located at
+#
+# 	http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+PROTO_SRC := $(wildcard *.proto)
+PROTO_GEN_SRC := $(PROTO_SRC:.proto=.pb.go)
+PROTO_GEN_SRC_GRPC := $(addprefix grpc/,$(PROTO_GEN_SRC))
+PROTO_GEN_SRC_TTRPC := $(addprefix ttrpc/,$(PROTO_GEN_SRC))
+
+$(PROTO_GEN_SRC_TTRPC): $(PROTO_SRC)
+	protoc -I. -I$(PROTOPATH)\
+		--gogottrpc_out=plugins=ttrpc,Mfirecracker.proto=github.com/firecracker-microvm/firecracker-containerd/proto:ttrpc \
+		$^
+
+$(PROTO_GEN_SRC_GRPC): $(PROTO_SRC)
+	protoc -I. -I$(PROTOPATH)\
+		--gogo_out=plugins=grpc,Mfirecracker.proto=github.com/firecracker-microvm/firecracker-containerd/proto:grpc \
+		$^
+
+proto: $(PROTO_GEN_SRC_GRPC) $(PROTO_GEN_SRC_TTRPC)
+
+clean:
+	- rm -f $(PROTO_GEN_SRC_GRPC) $(PROTO_GEN_SRC_TTRPC)
+
+.PHONY: clean proto
diff --git a/proto/service/fccontrol/fccontrol.proto b/proto/service/fccontrol/fccontrol.proto
new file mode 100644
index 0000000..367801f
--- /dev/null
+++ b/proto/service/fccontrol/fccontrol.proto
@@ -0,0 +1,21 @@
+syntax = "proto3";
+
+import "google/protobuf/empty.proto";
+
+import "firecracker.proto";
+
+option go_package = "fccontrol";
+
+service Firecracker {
+    // Runs new Firecracker VM instance
+    rpc CreateVM(CreateVMRequest) returns (google.protobuf.Empty);
+
+    // Stops existing Firecracker instance by VM ID
+    rpc StopVM(StopVMRequest) returns (google.protobuf.Empty);
+
+    // Returns VM info by VM ID
+    rpc GetVMInfo(GetVMInfoRequest) returns (GetVMInfoResponse);
+
+    // Sets VM's instance metadata
+    rpc SetVMMetadata(SetVMMetadataRequest) returns (google.protobuf.Empty);
+}
diff --git a/proto/service/fccontrol/grpc/fccontrol.pb.go b/proto/service/fccontrol/grpc/fccontrol.pb.go
new file mode 100644
index 0000000..fa905e3
--- /dev/null
+++ b/proto/service/fccontrol/grpc/fccontrol.pb.go
@@ -0,0 +1,223 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: fccontrol.proto
+
+package fccontrol
+
+import (
+	context "context"
+	fmt "fmt"
+	proto1 "github.com/firecracker-microvm/firecracker-containerd/proto"
+	proto "github.com/gogo/protobuf/proto"
+	empty "github.com/golang/protobuf/ptypes/empty"
+	grpc "google.golang.org/grpc"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
+
+func init() { proto.RegisterFile("fccontrol.proto", fileDescriptor_b99f53e2bf82c5ef) }
+
+var fileDescriptor_b99f53e2bf82c5ef = []byte{
+	// 199 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x4f, 0x4b, 0x4e, 0xce,
+	0xcf, 0x2b, 0x29, 0xca, 0xcf, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x97, 0x92, 0x4e, 0xcf, 0xcf,
+	0x4f, 0xcf, 0x49, 0xd5, 0x07, 0xf3, 0x92, 0x4a, 0xd3, 0xf4, 0x53, 0x73, 0x0b, 0x4a, 0x2a, 0xa1,
+	0x92, 0x82, 0x69, 0x99, 0x45, 0xa9, 0xc9, 0x45, 0x89, 0xc9, 0xd9, 0xa9, 0x45, 0x10, 0x21, 0xa3,
+	0x97, 0x8c, 0x5c, 0xdc, 0x6e, 0x08, 0x51, 0x21, 0x13, 0x2e, 0x0e, 0xe7, 0xa2, 0xd4, 0xc4, 0x92,
+	0xd4, 0x30, 0x5f, 0x21, 0x01, 0x3d, 0x18, 0x33, 0x28, 0xb5, 0xb0, 0x34, 0xb5, 0xb8, 0x44, 0x4a,
+	0x4c, 0x0f, 0x62, 0xbc, 0x1e, 0xcc, 0x78, 0x3d, 0x57, 0x90, 0xf1, 0x42, 0x06, 0x5c, 0x6c, 0xc1,
+	0x25, 0xf9, 0x05, 0x61, 0xbe, 0x42, 0x7c, 0x7a, 0x10, 0x06, 0x21, 0x1d, 0x46, 0x5c, 0x9c, 0xee,
+	0xa9, 0x25, 0x61, 0xbe, 0x9e, 0x79, 0x69, 0xf9, 0x42, 0x82, 0x7a, 0x70, 0x36, 0x4c, 0x9f, 0x10,
+	0xb2, 0x50, 0x71, 0x41, 0x7e, 0x5e, 0x71, 0xaa, 0x90, 0x1d, 0x17, 0x6f, 0x30, 0x48, 0xd0, 0x37,
+	0xb5, 0x24, 0x31, 0x25, 0xb1, 0x24, 0x51, 0x48, 0x54, 0x0f, 0x85, 0x4f, 0xc0, 0x4e, 0x27, 0xee,
+	0x28, 0x4e, 0x78, 0x70, 0x25, 0xb1, 0x81, 0x25, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x90,
+	0xa1, 0xa0, 0x2a, 0x42, 0x01, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// FirecrackerClient is the client API for Firecracker service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type FirecrackerClient interface {
+	// Runs new Firecracker VM instance
+	CreateVM(ctx context.Context, in *proto1.CreateVMRequest, opts ...grpc.CallOption) (*empty.Empty, error)
+	// Stops existing Firecracker instance by VM ID
+	StopVM(ctx context.Context, in *proto1.StopVMRequest, opts ...grpc.CallOption) (*empty.Empty, error)
+	// Returns VM info by VM ID
+	GetVMInfo(ctx context.Context, in *proto1.GetVMInfoRequest, opts ...grpc.CallOption) (*proto1.GetVMInfoResponse, error)
+	// Sets VM's instance metadata
+	SetVMMetadata(ctx context.Context, in *proto1.SetVMMetadataRequest, opts ...grpc.CallOption) (*empty.Empty, error)
+}
+
+type firecrackerClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewFirecrackerClient(cc *grpc.ClientConn) FirecrackerClient {
+	return &firecrackerClient{cc}
+}
+
+func (c *firecrackerClient) CreateVM(ctx context.Context, in *proto1.CreateVMRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
+	out := new(empty.Empty)
+	err := c.cc.Invoke(ctx, "/Firecracker/CreateVM", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *firecrackerClient) StopVM(ctx context.Context, in *proto1.StopVMRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
+	out := new(empty.Empty)
+	err := c.cc.Invoke(ctx, "/Firecracker/StopVM", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *firecrackerClient) GetVMInfo(ctx context.Context, in *proto1.GetVMInfoRequest, opts ...grpc.CallOption) (*proto1.GetVMInfoResponse, error) {
+	out := new(proto1.GetVMInfoResponse)
+	err := c.cc.Invoke(ctx, "/Firecracker/GetVMInfo", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *firecrackerClient) SetVMMetadata(ctx context.Context, in *proto1.SetVMMetadataRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
+	out := new(empty.Empty)
+	err := c.cc.Invoke(ctx, "/Firecracker/SetVMMetadata", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// FirecrackerServer is the server API for Firecracker service.
+type FirecrackerServer interface {
+	// Runs new Firecracker VM instance
+	CreateVM(context.Context, *proto1.CreateVMRequest) (*empty.Empty, error)
+	// Stops existing Firecracker instance by VM ID
+	StopVM(context.Context, *proto1.StopVMRequest) (*empty.Empty, error)
+	// Returns VM info by VM ID
+	GetVMInfo(context.Context, *proto1.GetVMInfoRequest) (*proto1.GetVMInfoResponse, error)
+	// Sets VM's instance metadata
+	SetVMMetadata(context.Context, *proto1.SetVMMetadataRequest) (*empty.Empty, error)
+}
+
+func RegisterFirecrackerServer(s *grpc.Server, srv FirecrackerServer) {
+	s.RegisterService(&_Firecracker_serviceDesc, srv)
+}
+
+func _Firecracker_CreateVM_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(proto1.CreateVMRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(FirecrackerServer).CreateVM(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/Firecracker/CreateVM",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(FirecrackerServer).CreateVM(ctx, req.(*proto1.CreateVMRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Firecracker_StopVM_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(proto1.StopVMRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(FirecrackerServer).StopVM(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/Firecracker/StopVM",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(FirecrackerServer).StopVM(ctx, req.(*proto1.StopVMRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Firecracker_GetVMInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(proto1.GetVMInfoRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(FirecrackerServer).GetVMInfo(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/Firecracker/GetVMInfo",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(FirecrackerServer).GetVMInfo(ctx, req.(*proto1.GetVMInfoRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Firecracker_SetVMMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(proto1.SetVMMetadataRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(FirecrackerServer).SetVMMetadata(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/Firecracker/SetVMMetadata",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(FirecrackerServer).SetVMMetadata(ctx, req.(*proto1.SetVMMetadataRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Firecracker_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "Firecracker",
+	HandlerType: (*FirecrackerServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "CreateVM",
+			Handler:    _Firecracker_CreateVM_Handler,
+		},
+		{
+			MethodName: "StopVM",
+			Handler:    _Firecracker_StopVM_Handler,
+		},
+		{
+			MethodName: "GetVMInfo",
+			Handler:    _Firecracker_GetVMInfo_Handler,
+		},
+		{
+			MethodName: "SetVMMetadata",
+			Handler:    _Firecracker_SetVMMetadata_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "fccontrol.proto",
+}
diff --git a/proto/service/fccontrol/ttrpc/fccontrol.pb.go b/proto/service/fccontrol/ttrpc/fccontrol.pb.go
new file mode 100644
index 0000000..299326c
--- /dev/null
+++ b/proto/service/fccontrol/ttrpc/fccontrol.pb.go
@@ -0,0 +1,127 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: fccontrol.proto
+
+package fccontrol
+
+import (
+	context "context"
+	fmt "fmt"
+	github_com_containerd_ttrpc "github.com/containerd/ttrpc"
+	proto1 "github.com/firecracker-microvm/firecracker-containerd/proto"
+	proto "github.com/gogo/protobuf/proto"
+	empty "github.com/golang/protobuf/ptypes/empty"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
+
+func init() { proto.RegisterFile("fccontrol.proto", fileDescriptor_b99f53e2bf82c5ef) }
+
+var fileDescriptor_b99f53e2bf82c5ef = []byte{
+	// 224 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x4f, 0x4b, 0x4e, 0xce,
+	0xcf, 0x2b, 0x29, 0xca, 0xcf, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x97, 0x92, 0x4e, 0xcf, 0xcf,
+	0x4f, 0xcf, 0x49, 0xd5, 0x07, 0xf3, 0x92, 0x4a, 0xd3, 0xf4, 0x53, 0x73, 0x0b, 0x4a, 0x2a, 0xa1,
+	0x92, 0x82, 0x69, 0x99, 0x45, 0xa9, 0xc9, 0x45, 0x89, 0xc9, 0xd9, 0xa9, 0x45, 0x10, 0x21, 0xa3,
+	0x97, 0x8c, 0x5c, 0xdc, 0x6e, 0x08, 0x51, 0x21, 0x13, 0x2e, 0x0e, 0xe7, 0xa2, 0xd4, 0xc4, 0x92,
+	0xd4, 0x30, 0x5f, 0x21, 0x01, 0x3d, 0x18, 0x33, 0x28, 0xb5, 0xb0, 0x34, 0xb5, 0xb8, 0x44, 0x4a,
+	0x4c, 0x0f, 0x62, 0xbc, 0x1e, 0xcc, 0x78, 0x3d, 0x57, 0x90, 0xf1, 0x42, 0x06, 0x5c, 0x6c, 0xc1,
+	0x25, 0xf9, 0x05, 0x61, 0xbe, 0x42, 0x7c, 0x7a, 0x10, 0x06, 0x21, 0x1d, 0x46, 0x5c, 0x9c, 0xee,
+	0xa9, 0x25, 0x61, 0xbe, 0x9e, 0x79, 0x69, 0xf9, 0x42, 0x82, 0x7a, 0x70, 0x36, 0x4c, 0x9f, 0x10,
+	0xb2, 0x50, 0x71, 0x41, 0x7e, 0x5e, 0x71, 0xaa, 0x90, 0x1d, 0x17, 0x6f, 0x30, 0x48, 0xd0, 0x37,
+	0xb5, 0x24, 0x31, 0x25, 0xb1, 0x24, 0x51, 0x48, 0x54, 0x0f, 0x85, 0x4f, 0xc0, 0x4e, 0x27, 0xe5,
+	0x13, 0x0f, 0xe5, 0x18, 0x6e, 0x3c, 0x94, 0x63, 0x68, 0x78, 0x24, 0xc7, 0x78, 0xe2, 0x91, 0x1c,
+	0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, 0x31, 0x46, 0x71, 0xc2, 0x83, 0x31, 0x89, 0x0d,
+	0xac, 0xc9, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x49, 0x50, 0xf9, 0xd3, 0x5a, 0x01, 0x00, 0x00,
+}
+
+type FirecrackerService interface {
+	CreateVM(ctx context.Context, req *proto1.CreateVMRequest) (*empty.Empty, error)
+	StopVM(ctx context.Context, req *proto1.StopVMRequest) (*empty.Empty, error)
+	GetVMInfo(ctx context.Context, req *proto1.GetVMInfoRequest) (*proto1.GetVMInfoResponse, error)
+	SetVMMetadata(ctx context.Context, req *proto1.SetVMMetadataRequest) (*empty.Empty, error)
+}
+
+func RegisterFirecrackerService(srv *github_com_containerd_ttrpc.Server, svc FirecrackerService) {
+	srv.Register("Firecracker", map[string]github_com_containerd_ttrpc.Method{
+		"CreateVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+			var req proto1.CreateVMRequest
+			if err := unmarshal(&req); err != nil {
+				return nil, err
+			}
+			return svc.CreateVM(ctx, &req)
+		},
+		"StopVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+			var req proto1.StopVMRequest
+			if err := unmarshal(&req); err != nil {
+				return nil, err
+			}
+			return svc.StopVM(ctx, &req)
+		},
+		"GetVMInfo": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+			var req proto1.GetVMInfoRequest
+			if err := unmarshal(&req); err != nil {
+				return nil, err
+			}
+			return svc.GetVMInfo(ctx, &req)
+		},
+		"SetVMMetadata": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+			var req proto1.SetVMMetadataRequest
+			if err := unmarshal(&req); err != nil {
+				return nil, err
+			}
+			return svc.SetVMMetadata(ctx, &req)
+		},
+	})
+}
+
+type firecrackerClient struct {
+	client *github_com_containerd_ttrpc.Client
+}
+
+func NewFirecrackerClient(client *github_com_containerd_ttrpc.Client) FirecrackerService {
+	return &firecrackerClient{
+		client: client,
+	}
+}
+
+func (c *firecrackerClient) CreateVM(ctx context.Context, req *proto1.CreateVMRequest) (*empty.Empty, error) {
+	var resp empty.Empty
+	if err := c.client.Call(ctx, "Firecracker", "CreateVM", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *firecrackerClient) StopVM(ctx context.Context, req *proto1.StopVMRequest) (*empty.Empty, error) {
+	var resp empty.Empty
+	if err := c.client.Call(ctx, "Firecracker", "StopVM", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *firecrackerClient) GetVMInfo(ctx context.Context, req *proto1.GetVMInfoRequest) (*proto1.GetVMInfoResponse, error) {
+	var resp proto1.GetVMInfoResponse
+	if err := c.client.Call(ctx, "Firecracker", "GetVMInfo", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *firecrackerClient) SetVMMetadata(ctx context.Context, req *proto1.SetVMMetadataRequest) (*empty.Empty, error) {
+	var resp empty.Empty
+	if err := c.client.Call(ctx, "Firecracker", "SetVMMetadata", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
diff --git a/proto/ttrpc/events.pb.go b/proto/ttrpc/events.pb.go
deleted file mode 100644
index b08bb0e..0000000
--- a/proto/ttrpc/events.pb.go
+++ /dev/null
@@ -1,541 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: events.proto
-
-package proto
-
-import (
-	fmt "fmt"
-	proto "github.com/gogo/protobuf/proto"
-	io "io"
-	math "math"
-	reflect "reflect"
-	strings "strings"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
-
-type VMStart struct {
-	VMID                 string   `protobuf:"bytes,1,opt,name=VMID,json=vMID,proto3" json:"VMID,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *VMStart) Reset()      { *m = VMStart{} }
-func (*VMStart) ProtoMessage() {}
-func (*VMStart) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8f22242cb04491f9, []int{0}
-}
-func (m *VMStart) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *VMStart) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_VMStart.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *VMStart) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_VMStart.Merge(m, src)
-}
-func (m *VMStart) XXX_Size() int {
-	return m.Size()
-}
-func (m *VMStart) XXX_DiscardUnknown() {
-	xxx_messageInfo_VMStart.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_VMStart proto.InternalMessageInfo
-
-type VMStop struct {
-	VMID                 string   `protobuf:"bytes,1,opt,name=VMID,json=vMID,proto3" json:"VMID,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *VMStop) Reset()      { *m = VMStop{} }
-func (*VMStop) ProtoMessage() {}
-func (*VMStop) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8f22242cb04491f9, []int{1}
-}
-func (m *VMStop) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *VMStop) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_VMStop.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *VMStop) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_VMStop.Merge(m, src)
-}
-func (m *VMStop) XXX_Size() int {
-	return m.Size()
-}
-func (m *VMStop) XXX_DiscardUnknown() {
-	xxx_messageInfo_VMStop.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_VMStop proto.InternalMessageInfo
-
-func init() {
-	proto.RegisterType((*VMStart)(nil), "VMStart")
-	proto.RegisterType((*VMStop)(nil), "VMStop")
-}
-
-func init() { proto.RegisterFile("events.proto", fileDescriptor_8f22242cb04491f9) }
-
-var fileDescriptor_8f22242cb04491f9 = []byte{
-	// 112 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x49, 0x2d, 0x4b, 0xcd,
-	0x2b, 0x29, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x57, 0x92, 0xe5, 0x62, 0x0f, 0xf3, 0x0d, 0x2e,
-	0x49, 0x2c, 0x2a, 0x11, 0x12, 0xe2, 0x62, 0x09, 0xf3, 0xf5, 0x74, 0x91, 0x60, 0x54, 0x60, 0xd4,
-	0xe0, 0x0c, 0x62, 0x29, 0xf3, 0xf5, 0x74, 0x51, 0x92, 0xe1, 0x62, 0x03, 0x49, 0xe7, 0x17, 0x60,
-	0x93, 0x75, 0x92, 0x38, 0xf1, 0x50, 0x8e, 0xe1, 0xc6, 0x43, 0x39, 0x86, 0x86, 0x47, 0x72, 0x8c,
-	0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0x63, 0x12, 0x1b, 0xd8,
-	0x74, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x54, 0x93, 0xbc, 0xf8, 0x6d, 0x00, 0x00, 0x00,
-}
-
-func (m *VMStart) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *VMStart) MarshalTo(dAtA []byte) (int, error) {
-	var i int
-	_ = i
-	var l int
-	_ = l
-	if len(m.VMID) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintEvents(dAtA, i, uint64(len(m.VMID)))
-		i += copy(dAtA[i:], m.VMID)
-	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
-}
-
-func (m *VMStop) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *VMStop) MarshalTo(dAtA []byte) (int, error) {
-	var i int
-	_ = i
-	var l int
-	_ = l
-	if len(m.VMID) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintEvents(dAtA, i, uint64(len(m.VMID)))
-		i += copy(dAtA[i:], m.VMID)
-	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
-}
-
-func encodeVarintEvents(dAtA []byte, offset int, v uint64) int {
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return offset + 1
-}
-func (m *VMStart) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.VMID)
-	if l > 0 {
-		n += 1 + l + sovEvents(uint64(l))
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
-	return n
-}
-
-func (m *VMStop) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.VMID)
-	if l > 0 {
-		n += 1 + l + sovEvents(uint64(l))
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
-	return n
-}
-
-func sovEvents(x uint64) (n int) {
-	for {
-		n++
-		x >>= 7
-		if x == 0 {
-			break
-		}
-	}
-	return n
-}
-func sozEvents(x uint64) (n int) {
-	return sovEvents(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (this *VMStart) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&VMStart{`,
-		`VMID:` + fmt.Sprintf("%v", this.VMID) + `,`,
-		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-func (this *VMStop) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&VMStop{`,
-		`VMID:` + fmt.Sprintf("%v", this.VMID) + `,`,
-		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-func valueToStringEvents(v interface{}) string {
-	rv := reflect.ValueOf(v)
-	if rv.IsNil() {
-		return "nil"
-	}
-	pv := reflect.Indirect(rv).Interface()
-	return fmt.Sprintf("*%v", pv)
-}
-func (m *VMStart) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowEvents
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: VMStart: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: VMStart: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field VMID", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthEvents
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.VMID = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipEvents(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *VMStop) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowEvents
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: VMStop: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: VMStop: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field VMID", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthEvents
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.VMID = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipEvents(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthEvents
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipEvents(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowEvents
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-			return iNdEx, nil
-		case 1:
-			iNdEx += 8
-			return iNdEx, nil
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowEvents
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthEvents
-			}
-			iNdEx += length
-			if iNdEx < 0 {
-				return 0, ErrInvalidLengthEvents
-			}
-			return iNdEx, nil
-		case 3:
-			for {
-				var innerWire uint64
-				var start int = iNdEx
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return 0, ErrIntOverflowEvents
-					}
-					if iNdEx >= l {
-						return 0, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					innerWire |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				innerWireType := int(innerWire & 0x7)
-				if innerWireType == 4 {
-					break
-				}
-				next, err := skipEvents(dAtA[start:])
-				if err != nil {
-					return 0, err
-				}
-				iNdEx = start + next
-				if iNdEx < 0 {
-					return 0, ErrInvalidLengthEvents
-				}
-			}
-			return iNdEx, nil
-		case 4:
-			return iNdEx, nil
-		case 5:
-			iNdEx += 4
-			return iNdEx, nil
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-	}
-	panic("unreachable")
-}
-
-var (
-	ErrInvalidLengthEvents = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowEvents   = fmt.Errorf("proto: integer overflow")
-)
diff --git a/proto/ttrpc/firecracker.pb.go b/proto/ttrpc/firecracker.pb.go
deleted file mode 100644
index 00e360d..0000000
--- a/proto/ttrpc/firecracker.pb.go
+++ /dev/null
@@ -1,1746 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: firecracker.proto
-
-package proto
-
-import (
-	context "context"
-	fmt "fmt"
-	github_com_containerd_ttrpc "github.com/containerd/ttrpc"
-	proto "github.com/gogo/protobuf/proto"
-	empty "github.com/golang/protobuf/ptypes/empty"
-	io "io"
-	math "math"
-	reflect "reflect"
-	strings "strings"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
-
-// CreateVMRequest specifies creation parameters for a new FC instance
-type CreateVMRequest struct {
-	// VM identifier to assign
-	VMID string `protobuf:"bytes,1,opt,name=VMID,json=vMID,proto3" json:"VMID,omitempty"`
-	// Specifies the machine configuration for the VM
-	MachineCfg *FirecrackerMachineConfiguration `protobuf:"bytes,2,opt,name=MachineCfg,json=machineCfg,proto3" json:"MachineCfg,omitempty"`
-	// Specifies the file path where the kernel image is located
-	KernelImagePath string `protobuf:"bytes,3,opt,name=KernelImagePath,json=kernelImagePath,proto3" json:"KernelImagePath,omitempty"`
-	// Specifies the commandline arguments that should be passed to the kernel
-	KernelArgs string `protobuf:"bytes,4,opt,name=KernelArgs,json=kernelArgs,proto3" json:"KernelArgs,omitempty"`
-	// Specifies the root block device for the VM
-	RootDrive *FirecrackerDrive `protobuf:"bytes,5,opt,name=RootDrive,json=rootDrive,proto3" json:"RootDrive,omitempty"`
-	// Specifies the additional block device config for the VM.
-	AdditionalDrives []*FirecrackerDrive `protobuf:"bytes,6,rep,name=AdditionalDrives,json=additionalDrives,proto3" json:"AdditionalDrives,omitempty"`
-	// Specifies the networking configuration for a VM
-	NetworkInterfaces []*FirecrackerNetworkInterface `protobuf:"bytes,7,rep,name=NetworkInterfaces,json=networkInterfaces,proto3" json:"NetworkInterfaces,omitempty"`
-	// The number of dummy drives to reserve in advance before running FC instance.
-	ContainerCount       int32    `protobuf:"varint,8,opt,name=ContainerCount,json=containerCount,proto3" json:"ContainerCount,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *CreateVMRequest) Reset()      { *m = CreateVMRequest{} }
-func (*CreateVMRequest) ProtoMessage() {}
-func (*CreateVMRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_a73317e9fb8da571, []int{0}
-}
-func (m *CreateVMRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *CreateVMRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_CreateVMRequest.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *CreateVMRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CreateVMRequest.Merge(m, src)
-}
-func (m *CreateVMRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *CreateVMRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_CreateVMRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CreateVMRequest proto.InternalMessageInfo
-
-type StopVMRequest struct {
-	VMID                 string   `protobuf:"bytes,1,opt,name=VMID,json=vMID,proto3" json:"VMID,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *StopVMRequest) Reset()      { *m = StopVMRequest{} }
-func (*StopVMRequest) ProtoMessage() {}
-func (*StopVMRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_a73317e9fb8da571, []int{1}
-}
-func (m *StopVMRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *StopVMRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_StopVMRequest.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *StopVMRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_StopVMRequest.Merge(m, src)
-}
-func (m *StopVMRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *StopVMRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_StopVMRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_StopVMRequest proto.InternalMessageInfo
-
-type GetVMInfoRequest struct {
-	VMID                 string   `protobuf:"bytes,1,opt,name=VMID,json=vMID,proto3" json:"VMID,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *GetVMInfoRequest) Reset()      { *m = GetVMInfoRequest{} }
-func (*GetVMInfoRequest) ProtoMessage() {}
-func (*GetVMInfoRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_a73317e9fb8da571, []int{2}
-}
-func (m *GetVMInfoRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *GetVMInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_GetVMInfoRequest.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *GetVMInfoRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GetVMInfoRequest.Merge(m, src)
-}
-func (m *GetVMInfoRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *GetVMInfoRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_GetVMInfoRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GetVMInfoRequest proto.InternalMessageInfo
-
-type GetVMInfoResponse struct {
-	VMID                 string   `protobuf:"bytes,1,opt,name=VMID,json=vMID,proto3" json:"VMID,omitempty"`
-	ContextID            uint32   `protobuf:"varint,2,opt,name=ContextID,json=contextID,proto3" json:"ContextID,omitempty"`
-	SocketPath           string   `protobuf:"bytes,3,opt,name=SocketPath,json=socketPath,proto3" json:"SocketPath,omitempty"`
-	LogFifoPath          string   `protobuf:"bytes,4,opt,name=LogFifoPath,json=logFifoPath,proto3" json:"LogFifoPath,omitempty"`
-	MetricsFifoPath      string   `protobuf:"bytes,5,opt,name=MetricsFifoPath,json=metricsFifoPath,proto3" json:"MetricsFifoPath,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *GetVMInfoResponse) Reset()      { *m = GetVMInfoResponse{} }
-func (*GetVMInfoResponse) ProtoMessage() {}
-func (*GetVMInfoResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_a73317e9fb8da571, []int{3}
-}
-func (m *GetVMInfoResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *GetVMInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_GetVMInfoResponse.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *GetVMInfoResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GetVMInfoResponse.Merge(m, src)
-}
-func (m *GetVMInfoResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *GetVMInfoResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_GetVMInfoResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GetVMInfoResponse proto.InternalMessageInfo
-
-type SetVMMetadataRequest struct {
-	VMID                 string   `protobuf:"bytes,1,opt,name=VMID,json=vMID,proto3" json:"VMID,omitempty"`
-	Metadata             string   `protobuf:"bytes,2,opt,name=Metadata,json=metadata,proto3" json:"Metadata,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *SetVMMetadataRequest) Reset()      { *m = SetVMMetadataRequest{} }
-func (*SetVMMetadataRequest) ProtoMessage() {}
-func (*SetVMMetadataRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_a73317e9fb8da571, []int{4}
-}
-func (m *SetVMMetadataRequest) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *SetVMMetadataRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_SetVMMetadataRequest.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *SetVMMetadataRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_SetVMMetadataRequest.Merge(m, src)
-}
-func (m *SetVMMetadataRequest) XXX_Size() int {
-	return m.Size()
-}
-func (m *SetVMMetadataRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_SetVMMetadataRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_SetVMMetadataRequest proto.InternalMessageInfo
-
-func init() {
-	proto.RegisterType((*CreateVMRequest)(nil), "CreateVMRequest")
-	proto.RegisterType((*StopVMRequest)(nil), "StopVMRequest")
-	proto.RegisterType((*GetVMInfoRequest)(nil), "GetVMInfoRequest")
-	proto.RegisterType((*GetVMInfoResponse)(nil), "GetVMInfoResponse")
-	proto.RegisterType((*SetVMMetadataRequest)(nil), "SetVMMetadataRequest")
-}
-
-func init() { proto.RegisterFile("firecracker.proto", fileDescriptor_a73317e9fb8da571) }
-
-var fileDescriptor_a73317e9fb8da571 = []byte{
-	// 533 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x53, 0x4d, 0x8f, 0xd2, 0x50,
-	0x14, 0x9d, 0xca, 0x87, 0xf4, 0x12, 0x3e, 0xfa, 0xa2, 0xa6, 0xc1, 0x49, 0x6d, 0x30, 0x99, 0xb0,
-	0x2a, 0x06, 0xdd, 0x6a, 0x1c, 0x41, 0x4c, 0xd5, 0x1a, 0x53, 0x12, 0x16, 0xee, 0x9e, 0xe5, 0xb6,
-	0xd3, 0x00, 0xef, 0xe1, 0xeb, 0x63, 0x74, 0x76, 0xfe, 0x09, 0x7f, 0x88, 0xff, 0x62, 0x96, 0x2e,
-	0x5d, 0x3a, 0xec, 0xfc, 0x17, 0xa6, 0xaf, 0x53, 0x06, 0x90, 0x61, 0xd5, 0xdc, 0x73, 0xcf, 0xc9,
-	0x3d, 0x7d, 0xe7, 0x5e, 0x30, 0xc2, 0x58, 0x60, 0x20, 0x68, 0x30, 0x45, 0xe1, 0x2c, 0x04, 0x97,
-	0xbc, 0xf5, 0x30, 0xe2, 0x3c, 0x9a, 0x61, 0x57, 0x55, 0x9f, 0x97, 0x61, 0x17, 0xe7, 0x0b, 0x79,
-	0x71, 0xdd, 0xac, 0xca, 0x8b, 0x05, 0x26, 0x59, 0xd1, 0xfe, 0x51, 0x80, 0x46, 0x5f, 0x20, 0x95,
-	0x38, 0xf6, 0x7c, 0xfc, 0xb2, 0xc4, 0x44, 0x12, 0x02, 0xc5, 0xb1, 0xe7, 0x0e, 0x4c, 0xcd, 0xd6,
-	0x3a, 0xba, 0x5f, 0x3c, 0xf7, 0xdc, 0x01, 0x79, 0x09, 0xe0, 0xd1, 0xe0, 0x2c, 0x66, 0xd8, 0x0f,
-	0x23, 0xf3, 0x8e, 0xad, 0x75, 0xaa, 0x3d, 0xdb, 0x19, 0xde, 0x4c, 0xce, 0xbb, 0x9c, 0x85, 0x71,
-	0xb4, 0x14, 0x54, 0xc6, 0x9c, 0xf9, 0x30, 0x5f, 0x6b, 0x48, 0x07, 0x1a, 0xef, 0x50, 0x30, 0x9c,
-	0xb9, 0x73, 0x1a, 0xe1, 0x47, 0x2a, 0xcf, 0xcc, 0x82, 0x1a, 0xd0, 0x98, 0x6e, 0xc3, 0xc4, 0x02,
-	0xc8, 0x98, 0xa7, 0x22, 0x4a, 0xcc, 0xa2, 0x22, 0xc1, 0x74, 0x8d, 0x90, 0x2e, 0xe8, 0x3e, 0xe7,
-	0x72, 0x20, 0xe2, 0x73, 0x34, 0x4b, 0xca, 0x8a, 0xb1, 0x69, 0x45, 0x35, 0x7c, 0x5d, 0xe4, 0x1c,
-	0xf2, 0x1c, 0x9a, 0xa7, 0x93, 0x49, 0x9c, 0x5a, 0xa2, 0x33, 0x05, 0x25, 0x66, 0xd9, 0x2e, 0xec,
-	0xd7, 0x35, 0xe9, 0x0e, 0x95, 0xbc, 0x05, 0xe3, 0x03, 0xca, 0xaf, 0x5c, 0x4c, 0x5d, 0x26, 0x51,
-	0x84, 0x34, 0xc0, 0xc4, 0xbc, 0xab, 0xf4, 0xc7, 0x9b, 0xfa, 0x5d, 0x92, 0x6f, 0xb0, 0x5d, 0x19,
-	0x39, 0x81, 0x7a, 0x9f, 0x33, 0x49, 0x63, 0x86, 0xa2, 0xcf, 0x97, 0x4c, 0x9a, 0x15, 0x5b, 0xeb,
-	0x94, 0xfc, 0x7a, 0xb0, 0x85, 0xb6, 0x1f, 0x43, 0x6d, 0x24, 0xf9, 0xe2, 0x60, 0x28, 0xed, 0x13,
-	0x68, 0xbe, 0x41, 0x39, 0xf6, 0x5c, 0x16, 0xf2, 0x43, 0xbc, 0x9f, 0x1a, 0x18, 0x1b, 0xc4, 0x64,
-	0xc1, 0x59, 0x82, 0x7b, 0x63, 0x3e, 0x06, 0x3d, 0xb5, 0x87, 0xdf, 0xa4, 0x3b, 0x50, 0x29, 0xd7,
-	0x7c, 0x3d, 0xc8, 0x81, 0x34, 0x98, 0x11, 0x0f, 0xa6, 0x28, 0x37, 0xd2, 0x83, 0x64, 0x8d, 0x10,
-	0x1b, 0xaa, 0xef, 0x79, 0x34, 0x8c, 0x43, 0xae, 0x08, 0x59, 0x72, 0xd5, 0xd9, 0x0d, 0x94, 0x2e,
-	0x81, 0x87, 0x52, 0xc4, 0x41, 0xb2, 0x66, 0x95, 0xb2, 0x25, 0x98, 0x6f, 0xc3, 0xed, 0x21, 0xdc,
-	0x1b, 0xa5, 0x96, 0x3d, 0x94, 0x74, 0x42, 0x25, 0x3d, 0xb4, 0x9c, 0x2d, 0xa8, 0xe4, 0x34, 0x65,
-	0x5a, 0xf7, 0x2b, 0xf3, 0xeb, 0xba, 0xf7, 0x57, 0x83, 0xea, 0x46, 0x46, 0xe4, 0x19, 0x54, 0xf2,
-	0x7d, 0x27, 0x4d, 0x67, 0x67, 0xf5, 0x5b, 0x0f, 0x9c, 0xec, 0x72, 0x9c, 0xfc, 0x72, 0x9c, 0xd7,
-	0xe9, 0xe5, 0x90, 0x27, 0x50, 0xce, 0xe2, 0x20, 0x75, 0x67, 0x2b, 0x97, 0x5b, 0x15, 0x3d, 0xd0,
-	0xd7, 0x4f, 0x4e, 0x0c, 0x67, 0x37, 0xa7, 0x16, 0x71, 0xfe, 0x4f, 0xe4, 0x05, 0xd4, 0xb6, 0xfe,
-	0x99, 0xdc, 0x77, 0xf6, 0xbd, 0xc1, 0x6d, 0x33, 0x5f, 0x3d, 0xba, 0xbc, 0xb2, 0x8e, 0x7e, 0x5f,
-	0x59, 0x47, 0xdf, 0x57, 0x96, 0x76, 0xb9, 0xb2, 0xb4, 0x5f, 0x2b, 0x4b, 0xfb, 0xb3, 0xb2, 0xb4,
-	0x4f, 0xa5, 0x8c, 0x59, 0x56, 0x9f, 0xa7, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x42, 0xe9, 0xd8,
-	0x58, 0x33, 0x04, 0x00, 0x00,
-}
-
-func (m *CreateVMRequest) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *CreateVMRequest) MarshalTo(dAtA []byte) (int, error) {
-	var i int
-	_ = i
-	var l int
-	_ = l
-	if len(m.VMID) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintFirecracker(dAtA, i, uint64(len(m.VMID)))
-		i += copy(dAtA[i:], m.VMID)
-	}
-	if m.MachineCfg != nil {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintFirecracker(dAtA, i, uint64(m.MachineCfg.Size()))
-		n1, err1 := m.MachineCfg.MarshalTo(dAtA[i:])
-		if err1 != nil {
-			return 0, err1
-		}
-		i += n1
-	}
-	if len(m.KernelImagePath) > 0 {
-		dAtA[i] = 0x1a
-		i++
-		i = encodeVarintFirecracker(dAtA, i, uint64(len(m.KernelImagePath)))
-		i += copy(dAtA[i:], m.KernelImagePath)
-	}
-	if len(m.KernelArgs) > 0 {
-		dAtA[i] = 0x22
-		i++
-		i = encodeVarintFirecracker(dAtA, i, uint64(len(m.KernelArgs)))
-		i += copy(dAtA[i:], m.KernelArgs)
-	}
-	if m.RootDrive != nil {
-		dAtA[i] = 0x2a
-		i++
-		i = encodeVarintFirecracker(dAtA, i, uint64(m.RootDrive.Size()))
-		n2, err2 := m.RootDrive.MarshalTo(dAtA[i:])
-		if err2 != nil {
-			return 0, err2
-		}
-		i += n2
-	}
-	if len(m.AdditionalDrives) > 0 {
-		for _, msg := range m.AdditionalDrives {
-			dAtA[i] = 0x32
-			i++
-			i = encodeVarintFirecracker(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
-			}
-			i += n
-		}
-	}
-	if len(m.NetworkInterfaces) > 0 {
-		for _, msg := range m.NetworkInterfaces {
-			dAtA[i] = 0x3a
-			i++
-			i = encodeVarintFirecracker(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
-			}
-			i += n
-		}
-	}
-	if m.ContainerCount != 0 {
-		dAtA[i] = 0x40
-		i++
-		i = encodeVarintFirecracker(dAtA, i, uint64(m.ContainerCount))
-	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
-}
-
-func (m *StopVMRequest) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *StopVMRequest) MarshalTo(dAtA []byte) (int, error) {
-	var i int
-	_ = i
-	var l int
-	_ = l
-	if len(m.VMID) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintFirecracker(dAtA, i, uint64(len(m.VMID)))
-		i += copy(dAtA[i:], m.VMID)
-	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
-}
-
-func (m *GetVMInfoRequest) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *GetVMInfoRequest) MarshalTo(dAtA []byte) (int, error) {
-	var i int
-	_ = i
-	var l int
-	_ = l
-	if len(m.VMID) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintFirecracker(dAtA, i, uint64(len(m.VMID)))
-		i += copy(dAtA[i:], m.VMID)
-	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
-}
-
-func (m *GetVMInfoResponse) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *GetVMInfoResponse) MarshalTo(dAtA []byte) (int, error) {
-	var i int
-	_ = i
-	var l int
-	_ = l
-	if len(m.VMID) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintFirecracker(dAtA, i, uint64(len(m.VMID)))
-		i += copy(dAtA[i:], m.VMID)
-	}
-	if m.ContextID != 0 {
-		dAtA[i] = 0x10
-		i++
-		i = encodeVarintFirecracker(dAtA, i, uint64(m.ContextID))
-	}
-	if len(m.SocketPath) > 0 {
-		dAtA[i] = 0x1a
-		i++
-		i = encodeVarintFirecracker(dAtA, i, uint64(len(m.SocketPath)))
-		i += copy(dAtA[i:], m.SocketPath)
-	}
-	if len(m.LogFifoPath) > 0 {
-		dAtA[i] = 0x22
-		i++
-		i = encodeVarintFirecracker(dAtA, i, uint64(len(m.LogFifoPath)))
-		i += copy(dAtA[i:], m.LogFifoPath)
-	}
-	if len(m.MetricsFifoPath) > 0 {
-		dAtA[i] = 0x2a
-		i++
-		i = encodeVarintFirecracker(dAtA, i, uint64(len(m.MetricsFifoPath)))
-		i += copy(dAtA[i:], m.MetricsFifoPath)
-	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
-}
-
-func (m *SetVMMetadataRequest) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *SetVMMetadataRequest) MarshalTo(dAtA []byte) (int, error) {
-	var i int
-	_ = i
-	var l int
-	_ = l
-	if len(m.VMID) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintFirecracker(dAtA, i, uint64(len(m.VMID)))
-		i += copy(dAtA[i:], m.VMID)
-	}
-	if len(m.Metadata) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintFirecracker(dAtA, i, uint64(len(m.Metadata)))
-		i += copy(dAtA[i:], m.Metadata)
-	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
-}
-
-func encodeVarintFirecracker(dAtA []byte, offset int, v uint64) int {
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return offset + 1
-}
-func (m *CreateVMRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.VMID)
-	if l > 0 {
-		n += 1 + l + sovFirecracker(uint64(l))
-	}
-	if m.MachineCfg != nil {
-		l = m.MachineCfg.Size()
-		n += 1 + l + sovFirecracker(uint64(l))
-	}
-	l = len(m.KernelImagePath)
-	if l > 0 {
-		n += 1 + l + sovFirecracker(uint64(l))
-	}
-	l = len(m.KernelArgs)
-	if l > 0 {
-		n += 1 + l + sovFirecracker(uint64(l))
-	}
-	if m.RootDrive != nil {
-		l = m.RootDrive.Size()
-		n += 1 + l + sovFirecracker(uint64(l))
-	}
-	if len(m.AdditionalDrives) > 0 {
-		for _, e := range m.AdditionalDrives {
-			l = e.Size()
-			n += 1 + l + sovFirecracker(uint64(l))
-		}
-	}
-	if len(m.NetworkInterfaces) > 0 {
-		for _, e := range m.NetworkInterfaces {
-			l = e.Size()
-			n += 1 + l + sovFirecracker(uint64(l))
-		}
-	}
-	if m.ContainerCount != 0 {
-		n += 1 + sovFirecracker(uint64(m.ContainerCount))
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
-	return n
-}
-
-func (m *StopVMRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.VMID)
-	if l > 0 {
-		n += 1 + l + sovFirecracker(uint64(l))
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
-	return n
-}
-
-func (m *GetVMInfoRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.VMID)
-	if l > 0 {
-		n += 1 + l + sovFirecracker(uint64(l))
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
-	return n
-}
-
-func (m *GetVMInfoResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.VMID)
-	if l > 0 {
-		n += 1 + l + sovFirecracker(uint64(l))
-	}
-	if m.ContextID != 0 {
-		n += 1 + sovFirecracker(uint64(m.ContextID))
-	}
-	l = len(m.SocketPath)
-	if l > 0 {
-		n += 1 + l + sovFirecracker(uint64(l))
-	}
-	l = len(m.LogFifoPath)
-	if l > 0 {
-		n += 1 + l + sovFirecracker(uint64(l))
-	}
-	l = len(m.MetricsFifoPath)
-	if l > 0 {
-		n += 1 + l + sovFirecracker(uint64(l))
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
-	return n
-}
-
-func (m *SetVMMetadataRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.VMID)
-	if l > 0 {
-		n += 1 + l + sovFirecracker(uint64(l))
-	}
-	l = len(m.Metadata)
-	if l > 0 {
-		n += 1 + l + sovFirecracker(uint64(l))
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
-	return n
-}
-
-func sovFirecracker(x uint64) (n int) {
-	for {
-		n++
-		x >>= 7
-		if x == 0 {
-			break
-		}
-	}
-	return n
-}
-func sozFirecracker(x uint64) (n int) {
-	return sovFirecracker(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (this *CreateVMRequest) String() string {
-	if this == nil {
-		return "nil"
-	}
-	repeatedStringForAdditionalDrives := "[]*FirecrackerDrive{"
-	for _, f := range this.AdditionalDrives {
-		repeatedStringForAdditionalDrives += strings.Replace(fmt.Sprintf("%v", f), "FirecrackerDrive", "FirecrackerDrive", 1) + ","
-	}
-	repeatedStringForAdditionalDrives += "}"
-	repeatedStringForNetworkInterfaces := "[]*FirecrackerNetworkInterface{"
-	for _, f := range this.NetworkInterfaces {
-		repeatedStringForNetworkInterfaces += strings.Replace(fmt.Sprintf("%v", f), "FirecrackerNetworkInterface", "FirecrackerNetworkInterface", 1) + ","
-	}
-	repeatedStringForNetworkInterfaces += "}"
-	s := strings.Join([]string{`&CreateVMRequest{`,
-		`VMID:` + fmt.Sprintf("%v", this.VMID) + `,`,
-		`MachineCfg:` + strings.Replace(fmt.Sprintf("%v", this.MachineCfg), "FirecrackerMachineConfiguration", "FirecrackerMachineConfiguration", 1) + `,`,
-		`KernelImagePath:` + fmt.Sprintf("%v", this.KernelImagePath) + `,`,
-		`KernelArgs:` + fmt.Sprintf("%v", this.KernelArgs) + `,`,
-		`RootDrive:` + strings.Replace(fmt.Sprintf("%v", this.RootDrive), "FirecrackerDrive", "FirecrackerDrive", 1) + `,`,
-		`AdditionalDrives:` + repeatedStringForAdditionalDrives + `,`,
-		`NetworkInterfaces:` + repeatedStringForNetworkInterfaces + `,`,
-		`ContainerCount:` + fmt.Sprintf("%v", this.ContainerCount) + `,`,
-		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-func (this *StopVMRequest) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&StopVMRequest{`,
-		`VMID:` + fmt.Sprintf("%v", this.VMID) + `,`,
-		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-func (this *GetVMInfoRequest) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&GetVMInfoRequest{`,
-		`VMID:` + fmt.Sprintf("%v", this.VMID) + `,`,
-		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-func (this *GetVMInfoResponse) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&GetVMInfoResponse{`,
-		`VMID:` + fmt.Sprintf("%v", this.VMID) + `,`,
-		`ContextID:` + fmt.Sprintf("%v", this.ContextID) + `,`,
-		`SocketPath:` + fmt.Sprintf("%v", this.SocketPath) + `,`,
-		`LogFifoPath:` + fmt.Sprintf("%v", this.LogFifoPath) + `,`,
-		`MetricsFifoPath:` + fmt.Sprintf("%v", this.MetricsFifoPath) + `,`,
-		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-func (this *SetVMMetadataRequest) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&SetVMMetadataRequest{`,
-		`VMID:` + fmt.Sprintf("%v", this.VMID) + `,`,
-		`Metadata:` + fmt.Sprintf("%v", this.Metadata) + `,`,
-		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-func valueToStringFirecracker(v interface{}) string {
-	rv := reflect.ValueOf(v)
-	if rv.IsNil() {
-		return "nil"
-	}
-	pv := reflect.Indirect(rv).Interface()
-	return fmt.Sprintf("*%v", pv)
-}
-
-type FirecrackerService interface {
-	CreateVM(ctx context.Context, req *CreateVMRequest) (*empty.Empty, error)
-	StopVM(ctx context.Context, req *StopVMRequest) (*empty.Empty, error)
-	GetVMInfo(ctx context.Context, req *GetVMInfoRequest) (*GetVMInfoResponse, error)
-	SetVMMetadata(ctx context.Context, req *SetVMMetadataRequest) (*empty.Empty, error)
-}
-
-func RegisterFirecrackerService(srv *github_com_containerd_ttrpc.Server, svc FirecrackerService) {
-	srv.Register("Firecracker", map[string]github_com_containerd_ttrpc.Method{
-		"CreateVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
-			var req CreateVMRequest
-			if err := unmarshal(&req); err != nil {
-				return nil, err
-			}
-			return svc.CreateVM(ctx, &req)
-		},
-		"StopVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
-			var req StopVMRequest
-			if err := unmarshal(&req); err != nil {
-				return nil, err
-			}
-			return svc.StopVM(ctx, &req)
-		},
-		"GetVMInfo": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
-			var req GetVMInfoRequest
-			if err := unmarshal(&req); err != nil {
-				return nil, err
-			}
-			return svc.GetVMInfo(ctx, &req)
-		},
-		"SetVMMetadata": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
-			var req SetVMMetadataRequest
-			if err := unmarshal(&req); err != nil {
-				return nil, err
-			}
-			return svc.SetVMMetadata(ctx, &req)
-		},
-	})
-}
-
-type firecrackerClient struct {
-	client *github_com_containerd_ttrpc.Client
-}
-
-func NewFirecrackerClient(client *github_com_containerd_ttrpc.Client) FirecrackerService {
-	return &firecrackerClient{
-		client: client,
-	}
-}
-
-func (c *firecrackerClient) CreateVM(ctx context.Context, req *CreateVMRequest) (*empty.Empty, error) {
-	var resp empty.Empty
-	if err := c.client.Call(ctx, "Firecracker", "CreateVM", req, &resp); err != nil {
-		return nil, err
-	}
-	return &resp, nil
-}
-
-func (c *firecrackerClient) StopVM(ctx context.Context, req *StopVMRequest) (*empty.Empty, error) {
-	var resp empty.Empty
-	if err := c.client.Call(ctx, "Firecracker", "StopVM", req, &resp); err != nil {
-		return nil, err
-	}
-	return &resp, nil
-}
-
-func (c *firecrackerClient) GetVMInfo(ctx context.Context, req *GetVMInfoRequest) (*GetVMInfoResponse, error) {
-	var resp GetVMInfoResponse
-	if err := c.client.Call(ctx, "Firecracker", "GetVMInfo", req, &resp); err != nil {
-		return nil, err
-	}
-	return &resp, nil
-}
-
-func (c *firecrackerClient) SetVMMetadata(ctx context.Context, req *SetVMMetadataRequest) (*empty.Empty, error) {
-	var resp empty.Empty
-	if err := c.client.Call(ctx, "Firecracker", "SetVMMetadata", req, &resp); err != nil {
-		return nil, err
-	}
-	return &resp, nil
-}
-func (m *CreateVMRequest) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowFirecracker
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: CreateVMRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: CreateVMRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field VMID", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowFirecracker
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.VMID = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MachineCfg", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowFirecracker
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.MachineCfg == nil {
-				m.MachineCfg = &FirecrackerMachineConfiguration{}
-			}
-			if err := m.MachineCfg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field KernelImagePath", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowFirecracker
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.KernelImagePath = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field KernelArgs", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowFirecracker
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.KernelArgs = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RootDrive", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowFirecracker
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.RootDrive == nil {
-				m.RootDrive = &FirecrackerDrive{}
-			}
-			if err := m.RootDrive.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 6:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field AdditionalDrives", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowFirecracker
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.AdditionalDrives = append(m.AdditionalDrives, &FirecrackerDrive{})
-			if err := m.AdditionalDrives[len(m.AdditionalDrives)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 7:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field NetworkInterfaces", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowFirecracker
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.NetworkInterfaces = append(m.NetworkInterfaces, &FirecrackerNetworkInterface{})
-			if err := m.NetworkInterfaces[len(m.NetworkInterfaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 8:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ContainerCount", wireType)
-			}
-			m.ContainerCount = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowFirecracker
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.ContainerCount |= int32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipFirecracker(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *StopVMRequest) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowFirecracker
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: StopVMRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: StopVMRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field VMID", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowFirecracker
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.VMID = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipFirecracker(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *GetVMInfoRequest) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowFirecracker
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: GetVMInfoRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GetVMInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field VMID", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowFirecracker
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.VMID = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipFirecracker(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *GetVMInfoResponse) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowFirecracker
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: GetVMInfoResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GetVMInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field VMID", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowFirecracker
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.VMID = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ContextID", wireType)
-			}
-			m.ContextID = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowFirecracker
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.ContextID |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field SocketPath", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowFirecracker
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.SocketPath = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field LogFifoPath", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowFirecracker
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.LogFifoPath = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MetricsFifoPath", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowFirecracker
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.MetricsFifoPath = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipFirecracker(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *SetVMMetadataRequest) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowFirecracker
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: SetVMMetadataRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: SetVMMetadataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field VMID", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowFirecracker
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.VMID = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowFirecracker
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Metadata = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipFirecracker(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthFirecracker
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipFirecracker(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowFirecracker
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowFirecracker
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-			return iNdEx, nil
-		case 1:
-			iNdEx += 8
-			return iNdEx, nil
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowFirecracker
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthFirecracker
-			}
-			iNdEx += length
-			if iNdEx < 0 {
-				return 0, ErrInvalidLengthFirecracker
-			}
-			return iNdEx, nil
-		case 3:
-			for {
-				var innerWire uint64
-				var start int = iNdEx
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return 0, ErrIntOverflowFirecracker
-					}
-					if iNdEx >= l {
-						return 0, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					innerWire |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				innerWireType := int(innerWire & 0x7)
-				if innerWireType == 4 {
-					break
-				}
-				next, err := skipFirecracker(dAtA[start:])
-				if err != nil {
-					return 0, err
-				}
-				iNdEx = start + next
-				if iNdEx < 0 {
-					return 0, ErrInvalidLengthFirecracker
-				}
-			}
-			return iNdEx, nil
-		case 4:
-			return iNdEx, nil
-		case 5:
-			iNdEx += 4
-			return iNdEx, nil
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-	}
-	panic("unreachable")
-}
-
-var (
-	ErrInvalidLengthFirecracker = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowFirecracker   = fmt.Errorf("proto: integer overflow")
-)
diff --git a/proto/ttrpc/types.pb.go b/proto/ttrpc/types.pb.go
deleted file mode 100644
index 050578f..0000000
--- a/proto/ttrpc/types.pb.go
+++ /dev/null
@@ -1,2500 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: types.proto
-
-package proto
-
-import (
-	fmt "fmt"
-	proto "github.com/gogo/protobuf/proto"
-	types "github.com/gogo/protobuf/types"
-	io "io"
-	math "math"
-	reflect "reflect"
-	strings "strings"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
-
-// Message to store bundle/config.json bytes
-type ExtraData struct {
-	JsonSpec             []byte     `protobuf:"bytes,1,opt,name=JsonSpec,json=jsonSpec,proto3" json:"JsonSpec,omitempty"`
-	RuncOptions          *types.Any `protobuf:"bytes,2,opt,name=RuncOptions,json=runcOptions,proto3" json:"RuncOptions,omitempty"`
-	StdinPort            uint32     `protobuf:"varint,3,opt,name=StdinPort,json=stdinPort,proto3" json:"StdinPort,omitempty"`
-	StdoutPort           uint32     `protobuf:"varint,4,opt,name=StdoutPort,json=stdoutPort,proto3" json:"StdoutPort,omitempty"`
-	StderrPort           uint32     `protobuf:"varint,5,opt,name=StderrPort,json=stderrPort,proto3" json:"StderrPort,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
-	XXX_unrecognized     []byte     `json:"-"`
-	XXX_sizecache        int32      `json:"-"`
-}
-
-func (m *ExtraData) Reset()      { *m = ExtraData{} }
-func (*ExtraData) ProtoMessage() {}
-func (*ExtraData) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d938547f84707355, []int{0}
-}
-func (m *ExtraData) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *ExtraData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_ExtraData.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *ExtraData) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ExtraData.Merge(m, src)
-}
-func (m *ExtraData) XXX_Size() int {
-	return m.Size()
-}
-func (m *ExtraData) XXX_DiscardUnknown() {
-	xxx_messageInfo_ExtraData.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ExtraData proto.InternalMessageInfo
-
-// Message to specify the various Firecracker VM configurations for a task
-type FirecrackerConfig struct {
-	RuncOptions       *types.Any                       `protobuf:"bytes,1,opt,name=RuncOptions,json=runcOptions,proto3" json:"RuncOptions,omitempty"`
-	NetworkInterfaces []*FirecrackerNetworkInterface   `protobuf:"bytes,2,rep,name=NetworkInterfaces,json=networkInterfaces,proto3" json:"NetworkInterfaces,omitempty"`
-	KernelImagePath   string                           `protobuf:"bytes,3,opt,name=KernelImagePath,json=kernelImagePath,proto3" json:"KernelImagePath,omitempty"`
-	KernelArgs        string                           `protobuf:"bytes,4,opt,name=KernelArgs,json=kernelArgs,proto3" json:"KernelArgs,omitempty"`
-	MachineCfg        *FirecrackerMachineConfiguration `protobuf:"bytes,5,opt,name=MachineCfg,json=machineCfg,proto3" json:"MachineCfg,omitempty"`
-	RootDrive         *FirecrackerDrive                `protobuf:"bytes,6,opt,name=RootDrive,json=rootDrive,proto3" json:"RootDrive,omitempty"`
-	// Specifies the additional block device config for the VM. Note that
-	// the snapshotter used might itself present block devices to the be
-	// attached to the VM. This fields allows additional block devices to
-	// that list.
-	AdditionalDrives     []*FirecrackerDrive `protobuf:"bytes,7,rep,name=AdditionalDrives,json=additionalDrives,proto3" json:"AdditionalDrives,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
-	XXX_unrecognized     []byte              `json:"-"`
-	XXX_sizecache        int32               `json:"-"`
-}
-
-func (m *FirecrackerConfig) Reset()      { *m = FirecrackerConfig{} }
-func (*FirecrackerConfig) ProtoMessage() {}
-func (*FirecrackerConfig) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d938547f84707355, []int{1}
-}
-func (m *FirecrackerConfig) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *FirecrackerConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_FirecrackerConfig.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *FirecrackerConfig) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FirecrackerConfig.Merge(m, src)
-}
-func (m *FirecrackerConfig) XXX_Size() int {
-	return m.Size()
-}
-func (m *FirecrackerConfig) XXX_DiscardUnknown() {
-	xxx_messageInfo_FirecrackerConfig.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FirecrackerConfig proto.InternalMessageInfo
-
-// Message to specify network config for a Firecracker VM
-type FirecrackerNetworkInterface struct {
-	MacAddress           string                  `protobuf:"bytes,1,opt,name=MacAddress,json=macAddress,proto3" json:"MacAddress,omitempty"`
-	HostDevName          string                  `protobuf:"bytes,2,opt,name=HostDevName,json=hostDevName,proto3" json:"HostDevName,omitempty"`
-	AllowMMDS            bool                    `protobuf:"varint,3,opt,name=AllowMMDS,json=allowMMDS,proto3" json:"AllowMMDS,omitempty"`
-	InRateLimiter        *FirecrackerRateLimiter `protobuf:"bytes,4,opt,name=InRateLimiter,json=inRateLimiter,proto3" json:"InRateLimiter,omitempty"`
-	OutRateLimiter       *FirecrackerRateLimiter `protobuf:"bytes,5,opt,name=OutRateLimiter,json=outRateLimiter,proto3" json:"OutRateLimiter,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
-	XXX_unrecognized     []byte                  `json:"-"`
-	XXX_sizecache        int32                   `json:"-"`
-}
-
-func (m *FirecrackerNetworkInterface) Reset()      { *m = FirecrackerNetworkInterface{} }
-func (*FirecrackerNetworkInterface) ProtoMessage() {}
-func (*FirecrackerNetworkInterface) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d938547f84707355, []int{2}
-}
-func (m *FirecrackerNetworkInterface) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *FirecrackerNetworkInterface) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_FirecrackerNetworkInterface.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *FirecrackerNetworkInterface) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FirecrackerNetworkInterface.Merge(m, src)
-}
-func (m *FirecrackerNetworkInterface) XXX_Size() int {
-	return m.Size()
-}
-func (m *FirecrackerNetworkInterface) XXX_DiscardUnknown() {
-	xxx_messageInfo_FirecrackerNetworkInterface.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FirecrackerNetworkInterface proto.InternalMessageInfo
-
-// Message to set the machine config for a Firecracker VM
-type FirecrackerMachineConfiguration struct {
-	CPUTemplate string `protobuf:"bytes,1,opt,name=CPUTemplate,json=cPUTemplate,proto3" json:"CPUTemplate,omitempty"`
-	HtEnabled   bool   `protobuf:"varint,2,opt,name=HtEnabled,json=htEnabled,proto3" json:"HtEnabled,omitempty"`
-	// Specifies the memory size of VM
-	// This lets us create a Firecracker VM of up to 4096 TiB, which
-	// for a mircroVM should be large enough
-	MemSizeMib           uint32   `protobuf:"varint,3,opt,name=MemSizeMib,json=memSizeMib,proto3" json:"MemSizeMib,omitempty"`
-	VcpuCount            uint32   `protobuf:"varint,4,opt,name=VcpuCount,json=vcpuCount,proto3" json:"VcpuCount,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *FirecrackerMachineConfiguration) Reset()      { *m = FirecrackerMachineConfiguration{} }
-func (*FirecrackerMachineConfiguration) ProtoMessage() {}
-func (*FirecrackerMachineConfiguration) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d938547f84707355, []int{3}
-}
-func (m *FirecrackerMachineConfiguration) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *FirecrackerMachineConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_FirecrackerMachineConfiguration.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *FirecrackerMachineConfiguration) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FirecrackerMachineConfiguration.Merge(m, src)
-}
-func (m *FirecrackerMachineConfiguration) XXX_Size() int {
-	return m.Size()
-}
-func (m *FirecrackerMachineConfiguration) XXX_DiscardUnknown() {
-	xxx_messageInfo_FirecrackerMachineConfiguration.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FirecrackerMachineConfiguration proto.InternalMessageInfo
-
-// Message to specify the block device config for a Firecracker VM
-type FirecrackerDrive struct {
-	IsReadOnly           bool                    `protobuf:"varint,1,opt,name=IsReadOnly,json=isReadOnly,proto3" json:"IsReadOnly,omitempty"`
-	IsRootDevice         bool                    `protobuf:"varint,2,opt,name=IsRootDevice,json=isRootDevice,proto3" json:"IsRootDevice,omitempty"`
-	Partuuid             string                  `protobuf:"bytes,3,opt,name=Partuuid,json=partuuid,proto3" json:"Partuuid,omitempty"`
-	PathOnHost           string                  `protobuf:"bytes,4,opt,name=PathOnHost,json=pathOnHost,proto3" json:"PathOnHost,omitempty"`
-	RateLimiter          *FirecrackerRateLimiter `protobuf:"bytes,5,opt,name=RateLimiter,json=rateLimiter,proto3" json:"RateLimiter,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
-	XXX_unrecognized     []byte                  `json:"-"`
-	XXX_sizecache        int32                   `json:"-"`
-}
-
-func (m *FirecrackerDrive) Reset()      { *m = FirecrackerDrive{} }
-func (*FirecrackerDrive) ProtoMessage() {}
-func (*FirecrackerDrive) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d938547f84707355, []int{4}
-}
-func (m *FirecrackerDrive) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *FirecrackerDrive) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_FirecrackerDrive.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *FirecrackerDrive) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FirecrackerDrive.Merge(m, src)
-}
-func (m *FirecrackerDrive) XXX_Size() int {
-	return m.Size()
-}
-func (m *FirecrackerDrive) XXX_DiscardUnknown() {
-	xxx_messageInfo_FirecrackerDrive.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FirecrackerDrive proto.InternalMessageInfo
-
-// Message to specify an IO rate limiter with bytes/s and ops/s limits
-type FirecrackerRateLimiter struct {
-	Bandwidth            *FirecrackerTokenBucket `protobuf:"bytes,1,opt,name=Bandwidth,json=bandwidth,proto3" json:"Bandwidth,omitempty"`
-	Ops                  *FirecrackerTokenBucket `protobuf:"bytes,2,opt,name=Ops,json=ops,proto3" json:"Ops,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
-	XXX_unrecognized     []byte                  `json:"-"`
-	XXX_sizecache        int32                   `json:"-"`
-}
-
-func (m *FirecrackerRateLimiter) Reset()      { *m = FirecrackerRateLimiter{} }
-func (*FirecrackerRateLimiter) ProtoMessage() {}
-func (*FirecrackerRateLimiter) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d938547f84707355, []int{5}
-}
-func (m *FirecrackerRateLimiter) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *FirecrackerRateLimiter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_FirecrackerRateLimiter.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *FirecrackerRateLimiter) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FirecrackerRateLimiter.Merge(m, src)
-}
-func (m *FirecrackerRateLimiter) XXX_Size() int {
-	return m.Size()
-}
-func (m *FirecrackerRateLimiter) XXX_DiscardUnknown() {
-	xxx_messageInfo_FirecrackerRateLimiter.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FirecrackerRateLimiter proto.InternalMessageInfo
-
-// Message to specify a token buicket used to rate limit disk and network IO for a Firecracker VM
-type FirecrackerTokenBucket struct {
-	OneTimeBurst         int64    `protobuf:"varint,1,opt,name=OneTimeBurst,json=oneTimeBurst,proto3" json:"OneTimeBurst,omitempty"`
-	RefillTime           int64    `protobuf:"varint,2,opt,name=RefillTime,json=refillTime,proto3" json:"RefillTime,omitempty"`
-	Capacity             int64    `protobuf:"varint,3,opt,name=Capacity,json=capacity,proto3" json:"Capacity,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *FirecrackerTokenBucket) Reset()      { *m = FirecrackerTokenBucket{} }
-func (*FirecrackerTokenBucket) ProtoMessage() {}
-func (*FirecrackerTokenBucket) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d938547f84707355, []int{6}
-}
-func (m *FirecrackerTokenBucket) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *FirecrackerTokenBucket) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_FirecrackerTokenBucket.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *FirecrackerTokenBucket) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FirecrackerTokenBucket.Merge(m, src)
-}
-func (m *FirecrackerTokenBucket) XXX_Size() int {
-	return m.Size()
-}
-func (m *FirecrackerTokenBucket) XXX_DiscardUnknown() {
-	xxx_messageInfo_FirecrackerTokenBucket.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FirecrackerTokenBucket proto.InternalMessageInfo
-
-func init() {
-	proto.RegisterType((*ExtraData)(nil), "ExtraData")
-	proto.RegisterType((*FirecrackerConfig)(nil), "FirecrackerConfig")
-	proto.RegisterType((*FirecrackerNetworkInterface)(nil), "FirecrackerNetworkInterface")
-	proto.RegisterType((*FirecrackerMachineConfiguration)(nil), "FirecrackerMachineConfiguration")
-	proto.RegisterType((*FirecrackerDrive)(nil), "FirecrackerDrive")
-	proto.RegisterType((*FirecrackerRateLimiter)(nil), "FirecrackerRateLimiter")
-	proto.RegisterType((*FirecrackerTokenBucket)(nil), "FirecrackerTokenBucket")
-}
-
-func init() { proto.RegisterFile("types.proto", fileDescriptor_d938547f84707355) }
-
-var fileDescriptor_d938547f84707355 = []byte{
-	// 750 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x94, 0xcd, 0x6e, 0xe3, 0x36,
-	0x10, 0xc7, 0xa3, 0xaa, 0x49, 0x2d, 0xca, 0xf9, 0xb0, 0x50, 0xb4, 0x6e, 0x1a, 0x38, 0x86, 0x4f,
-	0xee, 0xc5, 0x01, 0x5c, 0xb4, 0x40, 0x0f, 0x41, 0xeb, 0x8f, 0x14, 0x71, 0x5a, 0xc7, 0x06, 0x9d,
-	0xf6, 0xd0, 0x1b, 0x2d, 0x8d, 0x6d, 0xd6, 0x12, 0x29, 0x50, 0x94, 0x13, 0xe7, 0xd4, 0x77, 0xe8,
-	0x03, 0xf4, 0x49, 0x7a, 0xcf, 0xa5, 0x40, 0x8f, 0x7b, 0xdc, 0xf8, 0x3d, 0x16, 0x58, 0x90, 0x96,
-	0x14, 0xd9, 0xc8, 0x66, 0x77, 0x4f, 0x02, 0x7f, 0xff, 0x99, 0xe1, 0xcc, 0x9f, 0x14, 0x91, 0x2d,
-	0x97, 0x21, 0x44, 0x8d, 0x50, 0x70, 0xc9, 0x8f, 0xbf, 0x9a, 0x72, 0x3e, 0xf5, 0xe1, 0x4c, 0xaf,
-	0xc6, 0xf1, 0xe4, 0x8c, 0xb0, 0xe5, 0x5a, 0xaa, 0xfd, 0x6b, 0x20, 0xeb, 0xe2, 0x4e, 0x0a, 0xd2,
-	0x25, 0x92, 0x38, 0xc7, 0xa8, 0x70, 0x15, 0x71, 0x36, 0x0a, 0xc1, 0x2d, 0x1b, 0x55, 0xa3, 0x5e,
-	0xc4, 0x85, 0x3f, 0x93, 0xb5, 0xf3, 0x3d, 0xb2, 0x71, 0xcc, 0xdc, 0x41, 0x28, 0x29, 0x67, 0x51,
-	0xf9, 0x93, 0xaa, 0x51, 0xb7, 0x9b, 0x9f, 0x37, 0xd6, 0xa5, 0x1b, 0x69, 0xe9, 0x46, 0x8b, 0x2d,
-	0xb1, 0x2d, 0x9e, 0x02, 0x9d, 0x13, 0x64, 0x8d, 0xa4, 0x47, 0xd9, 0x90, 0x0b, 0x59, 0x36, 0xab,
-	0x46, 0x7d, 0x1f, 0x5b, 0x51, 0x0a, 0x9c, 0x0a, 0x42, 0x23, 0xe9, 0xf1, 0x58, 0x6a, 0xf9, 0x53,
-	0x2d, 0xa3, 0x28, 0x23, 0x89, 0x0e, 0x42, 0x68, 0x7d, 0x37, 0xd3, 0x13, 0x52, 0xfb, 0xdb, 0x44,
-	0xa5, 0x9f, 0xa9, 0x00, 0x57, 0x10, 0x77, 0x0e, 0xa2, 0xc3, 0xd9, 0x84, 0x4e, 0xb7, 0x7b, 0x35,
-	0x3e, 0xb4, 0xd7, 0x2b, 0x54, 0xba, 0x06, 0x79, 0xcb, 0xc5, 0xbc, 0xc7, 0x24, 0x88, 0x09, 0x71,
-	0x41, 0x4d, 0x6a, 0xd6, 0xed, 0xe6, 0x49, 0x23, 0xb7, 0xcd, 0x76, 0x10, 0x2e, 0xb1, 0xed, 0x34,
-	0xa7, 0x8e, 0x0e, 0x7f, 0x01, 0xc1, 0xc0, 0xef, 0x05, 0x64, 0x0a, 0x43, 0x22, 0x67, 0x7a, 0x7a,
-	0x0b, 0x1f, 0xce, 0x37, 0xb1, 0x9a, 0x71, 0x1d, 0xd9, 0x12, 0xd3, 0x48, 0x7b, 0x60, 0x61, 0x34,
-	0xcf, 0x88, 0xf3, 0x13, 0x42, 0x7d, 0xe2, 0xce, 0x28, 0x83, 0xce, 0x64, 0xaa, 0x3d, 0xb0, 0x9b,
-	0xd5, 0x7c, 0x3b, 0xa9, 0xaa, 0x87, 0x8f, 0x05, 0x51, 0xc3, 0x60, 0x14, 0x64, 0x39, 0xce, 0x19,
-	0xb2, 0x30, 0xe7, 0xb2, 0x2b, 0xe8, 0x02, 0xca, 0x7b, 0xba, 0x40, 0x29, 0x5f, 0x40, 0x0b, 0xd8,
-	0x12, 0x69, 0x8c, 0x73, 0x8e, 0x8e, 0x5a, 0x9e, 0x47, 0x55, 0x21, 0xe2, 0x6b, 0x14, 0x95, 0x3f,
-	0xd3, 0x3e, 0x3c, 0x93, 0x77, 0x44, 0xb6, 0x42, 0x6b, 0x6f, 0x0c, 0xf4, 0xf5, 0x0b, 0x76, 0xa9,
-	0x89, 0xfb, 0xc4, 0x6d, 0x79, 0x9e, 0x80, 0x68, 0x7d, 0x3c, 0x96, 0xee, 0x37, 0x21, 0x4e, 0x15,
-	0xd9, 0x97, 0x3c, 0x92, 0x5d, 0x58, 0x5c, 0x93, 0x00, 0xf4, 0x5d, 0xb3, 0xb0, 0x3d, 0x7b, 0x42,
-	0xea, 0x56, 0xb5, 0x7c, 0x9f, 0xdf, 0xf6, 0xfb, 0xdd, 0x91, 0xf6, 0xb5, 0x80, 0x2d, 0x92, 0x02,
-	0xe7, 0x1c, 0xed, 0xf7, 0x18, 0x26, 0x12, 0x7e, 0xa5, 0x01, 0x95, 0x20, 0xb4, 0xa9, 0x76, 0xf3,
-	0xcb, 0x7c, 0xef, 0x39, 0x19, 0xef, 0xd3, 0x7c, 0xb4, 0xf3, 0x23, 0x3a, 0x18, 0xc4, 0x32, 0x9f,
-	0xbf, 0xfb, 0x72, 0xfe, 0x01, 0xdf, 0x08, 0xaf, 0xfd, 0x63, 0xa0, 0xd3, 0xf7, 0x9c, 0x8f, 0x9a,
-	0xb1, 0x33, 0xfc, 0xed, 0x06, 0x82, 0xd0, 0x27, 0x12, 0x12, 0x13, 0x6c, 0xf7, 0x09, 0xa9, 0x19,
-	0x2f, 0xe5, 0x05, 0x23, 0x63, 0x1f, 0x3c, 0xed, 0x41, 0x01, 0x5b, 0xb3, 0x14, 0x68, 0x0f, 0x21,
-	0x18, 0xd1, 0x7b, 0xe8, 0xd3, 0x71, 0xf2, 0x63, 0xa1, 0x20, 0x23, 0x2a, 0xfb, 0x77, 0x37, 0x8c,
-	0x3b, 0x3c, 0x66, 0xe9, 0x8f, 0x65, 0x2d, 0x52, 0x50, 0xfb, 0xcf, 0x40, 0x47, 0xdb, 0x07, 0xa9,
-	0x4a, 0xf6, 0x22, 0x0c, 0xc4, 0x1b, 0x30, 0x7f, 0xa9, 0x3b, 0x2a, 0x60, 0x44, 0x33, 0xe2, 0xd4,
-	0x50, 0xb1, 0x17, 0xe9, 0x8b, 0x04, 0x0b, 0xea, 0x42, 0xd2, 0x53, 0x91, 0xe6, 0x98, 0x7a, 0x42,
-	0x86, 0x44, 0xc8, 0x38, 0xa6, 0x5e, 0x72, 0xdf, 0x0b, 0x61, 0xb2, 0x56, 0xf5, 0xd5, 0x85, 0x1f,
-	0x30, 0x75, 0xb8, 0xe9, 0x45, 0x0f, 0x33, 0xe2, 0xfc, 0x80, 0xec, 0x8f, 0x30, 0xdd, 0x16, 0x39,
-	0xc7, 0xef, 0xd1, 0x17, 0xcf, 0x87, 0x39, 0xdf, 0x21, 0xab, 0x4d, 0x98, 0x77, 0x4b, 0x3d, 0x39,
-	0x4b, 0x5e, 0x82, 0x8d, 0x92, 0x37, 0x7c, 0x0e, 0xac, 0x1d, 0xbb, 0x73, 0x90, 0xd8, 0x1a, 0xa7,
-	0x91, 0xce, 0x37, 0xc8, 0x1c, 0x84, 0xe9, 0x33, 0xf7, 0xce, 0x04, 0x93, 0x87, 0x51, 0xed, 0x6e,
-	0x63, 0xef, 0x9c, 0xac, 0x0c, 0x1b, 0x30, 0xb8, 0xa1, 0x01, 0xb4, 0x63, 0x11, 0x49, 0xbd, 0xbd,
-	0x89, 0x8b, 0x3c, 0xc7, 0x94, 0x29, 0x18, 0x26, 0xd4, 0xf7, 0x15, 0xd2, 0xfb, 0x99, 0x18, 0x89,
-	0x8c, 0x28, 0x43, 0x3b, 0x24, 0x24, 0x2e, 0x95, 0x4b, 0x6d, 0xa8, 0x89, 0x0b, 0x6e, 0xb2, 0x6e,
-	0x9f, 0x3e, 0x3c, 0x56, 0x76, 0x5e, 0x3d, 0x56, 0x76, 0xfe, 0x5a, 0x55, 0x8c, 0x87, 0x55, 0xc5,
-	0xf8, 0x7f, 0x55, 0x31, 0x5e, 0xaf, 0x2a, 0xc6, 0x1f, 0xbb, 0xeb, 0x47, 0x6e, 0x4f, 0x7f, 0xbe,
-	0x7d, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xd6, 0x23, 0xb3, 0xad, 0x0f, 0x06, 0x00, 0x00,
-}
-
-func (m *ExtraData) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *ExtraData) MarshalTo(dAtA []byte) (int, error) {
-	var i int
-	_ = i
-	var l int
-	_ = l
-	if len(m.JsonSpec) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.JsonSpec)))
-		i += copy(dAtA[i:], m.JsonSpec)
-	}
-	if m.RuncOptions != nil {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.RuncOptions.Size()))
-		n1, err1 := m.RuncOptions.MarshalTo(dAtA[i:])
-		if err1 != nil {
-			return 0, err1
-		}
-		i += n1
-	}
-	if m.StdinPort != 0 {
-		dAtA[i] = 0x18
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.StdinPort))
-	}
-	if m.StdoutPort != 0 {
-		dAtA[i] = 0x20
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.StdoutPort))
-	}
-	if m.StderrPort != 0 {
-		dAtA[i] = 0x28
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.StderrPort))
-	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
-}
-
-func (m *FirecrackerConfig) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *FirecrackerConfig) MarshalTo(dAtA []byte) (int, error) {
-	var i int
-	_ = i
-	var l int
-	_ = l
-	if m.RuncOptions != nil {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.RuncOptions.Size()))
-		n2, err2 := m.RuncOptions.MarshalTo(dAtA[i:])
-		if err2 != nil {
-			return 0, err2
-		}
-		i += n2
-	}
-	if len(m.NetworkInterfaces) > 0 {
-		for _, msg := range m.NetworkInterfaces {
-			dAtA[i] = 0x12
-			i++
-			i = encodeVarintTypes(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
-			}
-			i += n
-		}
-	}
-	if len(m.KernelImagePath) > 0 {
-		dAtA[i] = 0x1a
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.KernelImagePath)))
-		i += copy(dAtA[i:], m.KernelImagePath)
-	}
-	if len(m.KernelArgs) > 0 {
-		dAtA[i] = 0x22
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.KernelArgs)))
-		i += copy(dAtA[i:], m.KernelArgs)
-	}
-	if m.MachineCfg != nil {
-		dAtA[i] = 0x2a
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.MachineCfg.Size()))
-		n3, err3 := m.MachineCfg.MarshalTo(dAtA[i:])
-		if err3 != nil {
-			return 0, err3
-		}
-		i += n3
-	}
-	if m.RootDrive != nil {
-		dAtA[i] = 0x32
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.RootDrive.Size()))
-		n4, err4 := m.RootDrive.MarshalTo(dAtA[i:])
-		if err4 != nil {
-			return 0, err4
-		}
-		i += n4
-	}
-	if len(m.AdditionalDrives) > 0 {
-		for _, msg := range m.AdditionalDrives {
-			dAtA[i] = 0x3a
-			i++
-			i = encodeVarintTypes(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
-			}
-			i += n
-		}
-	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
-}
-
-func (m *FirecrackerNetworkInterface) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *FirecrackerNetworkInterface) MarshalTo(dAtA []byte) (int, error) {
-	var i int
-	_ = i
-	var l int
-	_ = l
-	if len(m.MacAddress) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.MacAddress)))
-		i += copy(dAtA[i:], m.MacAddress)
-	}
-	if len(m.HostDevName) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.HostDevName)))
-		i += copy(dAtA[i:], m.HostDevName)
-	}
-	if m.AllowMMDS {
-		dAtA[i] = 0x18
-		i++
-		if m.AllowMMDS {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i++
-	}
-	if m.InRateLimiter != nil {
-		dAtA[i] = 0x22
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.InRateLimiter.Size()))
-		n5, err5 := m.InRateLimiter.MarshalTo(dAtA[i:])
-		if err5 != nil {
-			return 0, err5
-		}
-		i += n5
-	}
-	if m.OutRateLimiter != nil {
-		dAtA[i] = 0x2a
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.OutRateLimiter.Size()))
-		n6, err6 := m.OutRateLimiter.MarshalTo(dAtA[i:])
-		if err6 != nil {
-			return 0, err6
-		}
-		i += n6
-	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
-}
-
-func (m *FirecrackerMachineConfiguration) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *FirecrackerMachineConfiguration) MarshalTo(dAtA []byte) (int, error) {
-	var i int
-	_ = i
-	var l int
-	_ = l
-	if len(m.CPUTemplate) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.CPUTemplate)))
-		i += copy(dAtA[i:], m.CPUTemplate)
-	}
-	if m.HtEnabled {
-		dAtA[i] = 0x10
-		i++
-		if m.HtEnabled {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i++
-	}
-	if m.MemSizeMib != 0 {
-		dAtA[i] = 0x18
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.MemSizeMib))
-	}
-	if m.VcpuCount != 0 {
-		dAtA[i] = 0x20
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.VcpuCount))
-	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
-}
-
-func (m *FirecrackerDrive) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *FirecrackerDrive) MarshalTo(dAtA []byte) (int, error) {
-	var i int
-	_ = i
-	var l int
-	_ = l
-	if m.IsReadOnly {
-		dAtA[i] = 0x8
-		i++
-		if m.IsReadOnly {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i++
-	}
-	if m.IsRootDevice {
-		dAtA[i] = 0x10
-		i++
-		if m.IsRootDevice {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i++
-	}
-	if len(m.Partuuid) > 0 {
-		dAtA[i] = 0x1a
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.Partuuid)))
-		i += copy(dAtA[i:], m.Partuuid)
-	}
-	if len(m.PathOnHost) > 0 {
-		dAtA[i] = 0x22
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.PathOnHost)))
-		i += copy(dAtA[i:], m.PathOnHost)
-	}
-	if m.RateLimiter != nil {
-		dAtA[i] = 0x2a
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.RateLimiter.Size()))
-		n7, err7 := m.RateLimiter.MarshalTo(dAtA[i:])
-		if err7 != nil {
-			return 0, err7
-		}
-		i += n7
-	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
-}
-
-func (m *FirecrackerRateLimiter) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *FirecrackerRateLimiter) MarshalTo(dAtA []byte) (int, error) {
-	var i int
-	_ = i
-	var l int
-	_ = l
-	if m.Bandwidth != nil {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.Bandwidth.Size()))
-		n8, err8 := m.Bandwidth.MarshalTo(dAtA[i:])
-		if err8 != nil {
-			return 0, err8
-		}
-		i += n8
-	}
-	if m.Ops != nil {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.Ops.Size()))
-		n9, err9 := m.Ops.MarshalTo(dAtA[i:])
-		if err9 != nil {
-			return 0, err9
-		}
-		i += n9
-	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
-}
-
-func (m *FirecrackerTokenBucket) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *FirecrackerTokenBucket) MarshalTo(dAtA []byte) (int, error) {
-	var i int
-	_ = i
-	var l int
-	_ = l
-	if m.OneTimeBurst != 0 {
-		dAtA[i] = 0x8
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.OneTimeBurst))
-	}
-	if m.RefillTime != 0 {
-		dAtA[i] = 0x10
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.RefillTime))
-	}
-	if m.Capacity != 0 {
-		dAtA[i] = 0x18
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.Capacity))
-	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
-}
-
-func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return offset + 1
-}
-func (m *ExtraData) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.JsonSpec)
-	if l > 0 {
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	if m.RuncOptions != nil {
-		l = m.RuncOptions.Size()
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	if m.StdinPort != 0 {
-		n += 1 + sovTypes(uint64(m.StdinPort))
-	}
-	if m.StdoutPort != 0 {
-		n += 1 + sovTypes(uint64(m.StdoutPort))
-	}
-	if m.StderrPort != 0 {
-		n += 1 + sovTypes(uint64(m.StderrPort))
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
-	return n
-}
-
-func (m *FirecrackerConfig) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.RuncOptions != nil {
-		l = m.RuncOptions.Size()
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	if len(m.NetworkInterfaces) > 0 {
-		for _, e := range m.NetworkInterfaces {
-			l = e.Size()
-			n += 1 + l + sovTypes(uint64(l))
-		}
-	}
-	l = len(m.KernelImagePath)
-	if l > 0 {
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	l = len(m.KernelArgs)
-	if l > 0 {
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	if m.MachineCfg != nil {
-		l = m.MachineCfg.Size()
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	if m.RootDrive != nil {
-		l = m.RootDrive.Size()
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	if len(m.AdditionalDrives) > 0 {
-		for _, e := range m.AdditionalDrives {
-			l = e.Size()
-			n += 1 + l + sovTypes(uint64(l))
-		}
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
-	return n
-}
-
-func (m *FirecrackerNetworkInterface) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.MacAddress)
-	if l > 0 {
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	l = len(m.HostDevName)
-	if l > 0 {
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	if m.AllowMMDS {
-		n += 2
-	}
-	if m.InRateLimiter != nil {
-		l = m.InRateLimiter.Size()
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	if m.OutRateLimiter != nil {
-		l = m.OutRateLimiter.Size()
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
-	return n
-}
-
-func (m *FirecrackerMachineConfiguration) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.CPUTemplate)
-	if l > 0 {
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	if m.HtEnabled {
-		n += 2
-	}
-	if m.MemSizeMib != 0 {
-		n += 1 + sovTypes(uint64(m.MemSizeMib))
-	}
-	if m.VcpuCount != 0 {
-		n += 1 + sovTypes(uint64(m.VcpuCount))
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
-	return n
-}
-
-func (m *FirecrackerDrive) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.IsReadOnly {
-		n += 2
-	}
-	if m.IsRootDevice {
-		n += 2
-	}
-	l = len(m.Partuuid)
-	if l > 0 {
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	l = len(m.PathOnHost)
-	if l > 0 {
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	if m.RateLimiter != nil {
-		l = m.RateLimiter.Size()
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
-	return n
-}
-
-func (m *FirecrackerRateLimiter) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.Bandwidth != nil {
-		l = m.Bandwidth.Size()
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	if m.Ops != nil {
-		l = m.Ops.Size()
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
-	return n
-}
-
-func (m *FirecrackerTokenBucket) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.OneTimeBurst != 0 {
-		n += 1 + sovTypes(uint64(m.OneTimeBurst))
-	}
-	if m.RefillTime != 0 {
-		n += 1 + sovTypes(uint64(m.RefillTime))
-	}
-	if m.Capacity != 0 {
-		n += 1 + sovTypes(uint64(m.Capacity))
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
-	return n
-}
-
-func sovTypes(x uint64) (n int) {
-	for {
-		n++
-		x >>= 7
-		if x == 0 {
-			break
-		}
-	}
-	return n
-}
-func sozTypes(x uint64) (n int) {
-	return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (this *ExtraData) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&ExtraData{`,
-		`JsonSpec:` + fmt.Sprintf("%v", this.JsonSpec) + `,`,
-		`RuncOptions:` + strings.Replace(fmt.Sprintf("%v", this.RuncOptions), "Any", "types.Any", 1) + `,`,
-		`StdinPort:` + fmt.Sprintf("%v", this.StdinPort) + `,`,
-		`StdoutPort:` + fmt.Sprintf("%v", this.StdoutPort) + `,`,
-		`StderrPort:` + fmt.Sprintf("%v", this.StderrPort) + `,`,
-		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-func (this *FirecrackerConfig) String() string {
-	if this == nil {
-		return "nil"
-	}
-	repeatedStringForNetworkInterfaces := "[]*FirecrackerNetworkInterface{"
-	for _, f := range this.NetworkInterfaces {
-		repeatedStringForNetworkInterfaces += strings.Replace(f.String(), "FirecrackerNetworkInterface", "FirecrackerNetworkInterface", 1) + ","
-	}
-	repeatedStringForNetworkInterfaces += "}"
-	repeatedStringForAdditionalDrives := "[]*FirecrackerDrive{"
-	for _, f := range this.AdditionalDrives {
-		repeatedStringForAdditionalDrives += strings.Replace(f.String(), "FirecrackerDrive", "FirecrackerDrive", 1) + ","
-	}
-	repeatedStringForAdditionalDrives += "}"
-	s := strings.Join([]string{`&FirecrackerConfig{`,
-		`RuncOptions:` + strings.Replace(fmt.Sprintf("%v", this.RuncOptions), "Any", "types.Any", 1) + `,`,
-		`NetworkInterfaces:` + repeatedStringForNetworkInterfaces + `,`,
-		`KernelImagePath:` + fmt.Sprintf("%v", this.KernelImagePath) + `,`,
-		`KernelArgs:` + fmt.Sprintf("%v", this.KernelArgs) + `,`,
-		`MachineCfg:` + strings.Replace(this.MachineCfg.String(), "FirecrackerMachineConfiguration", "FirecrackerMachineConfiguration", 1) + `,`,
-		`RootDrive:` + strings.Replace(this.RootDrive.String(), "FirecrackerDrive", "FirecrackerDrive", 1) + `,`,
-		`AdditionalDrives:` + repeatedStringForAdditionalDrives + `,`,
-		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-func (this *FirecrackerNetworkInterface) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&FirecrackerNetworkInterface{`,
-		`MacAddress:` + fmt.Sprintf("%v", this.MacAddress) + `,`,
-		`HostDevName:` + fmt.Sprintf("%v", this.HostDevName) + `,`,
-		`AllowMMDS:` + fmt.Sprintf("%v", this.AllowMMDS) + `,`,
-		`InRateLimiter:` + strings.Replace(this.InRateLimiter.String(), "FirecrackerRateLimiter", "FirecrackerRateLimiter", 1) + `,`,
-		`OutRateLimiter:` + strings.Replace(this.OutRateLimiter.String(), "FirecrackerRateLimiter", "FirecrackerRateLimiter", 1) + `,`,
-		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-func (this *FirecrackerMachineConfiguration) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&FirecrackerMachineConfiguration{`,
-		`CPUTemplate:` + fmt.Sprintf("%v", this.CPUTemplate) + `,`,
-		`HtEnabled:` + fmt.Sprintf("%v", this.HtEnabled) + `,`,
-		`MemSizeMib:` + fmt.Sprintf("%v", this.MemSizeMib) + `,`,
-		`VcpuCount:` + fmt.Sprintf("%v", this.VcpuCount) + `,`,
-		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-func (this *FirecrackerDrive) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&FirecrackerDrive{`,
-		`IsReadOnly:` + fmt.Sprintf("%v", this.IsReadOnly) + `,`,
-		`IsRootDevice:` + fmt.Sprintf("%v", this.IsRootDevice) + `,`,
-		`Partuuid:` + fmt.Sprintf("%v", this.Partuuid) + `,`,
-		`PathOnHost:` + fmt.Sprintf("%v", this.PathOnHost) + `,`,
-		`RateLimiter:` + strings.Replace(this.RateLimiter.String(), "FirecrackerRateLimiter", "FirecrackerRateLimiter", 1) + `,`,
-		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-func (this *FirecrackerRateLimiter) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&FirecrackerRateLimiter{`,
-		`Bandwidth:` + strings.Replace(this.Bandwidth.String(), "FirecrackerTokenBucket", "FirecrackerTokenBucket", 1) + `,`,
-		`Ops:` + strings.Replace(this.Ops.String(), "FirecrackerTokenBucket", "FirecrackerTokenBucket", 1) + `,`,
-		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-func (this *FirecrackerTokenBucket) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&FirecrackerTokenBucket{`,
-		`OneTimeBurst:` + fmt.Sprintf("%v", this.OneTimeBurst) + `,`,
-		`RefillTime:` + fmt.Sprintf("%v", this.RefillTime) + `,`,
-		`Capacity:` + fmt.Sprintf("%v", this.Capacity) + `,`,
-		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-func valueToStringTypes(v interface{}) string {
-	rv := reflect.ValueOf(v)
-	if rv.IsNil() {
-		return "nil"
-	}
-	pv := reflect.Indirect(rv).Interface()
-	return fmt.Sprintf("*%v", pv)
-}
-func (m *ExtraData) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: ExtraData: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ExtraData: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field JsonSpec", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.JsonSpec = append(m.JsonSpec[:0], dAtA[iNdEx:postIndex]...)
-			if m.JsonSpec == nil {
-				m.JsonSpec = []byte{}
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RuncOptions", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.RuncOptions == nil {
-				m.RuncOptions = &types.Any{}
-			}
-			if err := m.RuncOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StdinPort", wireType)
-			}
-			m.StdinPort = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.StdinPort |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 4:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StdoutPort", wireType)
-			}
-			m.StdoutPort = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.StdoutPort |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 5:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StderrPort", wireType)
-			}
-			m.StderrPort = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.StderrPort |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *FirecrackerConfig) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: FirecrackerConfig: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: FirecrackerConfig: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RuncOptions", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.RuncOptions == nil {
-				m.RuncOptions = &types.Any{}
-			}
-			if err := m.RuncOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field NetworkInterfaces", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.NetworkInterfaces = append(m.NetworkInterfaces, &FirecrackerNetworkInterface{})
-			if err := m.NetworkInterfaces[len(m.NetworkInterfaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field KernelImagePath", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.KernelImagePath = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field KernelArgs", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.KernelArgs = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MachineCfg", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.MachineCfg == nil {
-				m.MachineCfg = &FirecrackerMachineConfiguration{}
-			}
-			if err := m.MachineCfg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 6:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RootDrive", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.RootDrive == nil {
-				m.RootDrive = &FirecrackerDrive{}
-			}
-			if err := m.RootDrive.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 7:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field AdditionalDrives", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.AdditionalDrives = append(m.AdditionalDrives, &FirecrackerDrive{})
-			if err := m.AdditionalDrives[len(m.AdditionalDrives)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *FirecrackerNetworkInterface) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: FirecrackerNetworkInterface: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: FirecrackerNetworkInterface: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MacAddress", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.MacAddress = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field HostDevName", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.HostDevName = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field AllowMMDS", wireType)
-			}
-			var v int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				v |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			m.AllowMMDS = bool(v != 0)
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field InRateLimiter", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.InRateLimiter == nil {
-				m.InRateLimiter = &FirecrackerRateLimiter{}
-			}
-			if err := m.InRateLimiter.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field OutRateLimiter", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.OutRateLimiter == nil {
-				m.OutRateLimiter = &FirecrackerRateLimiter{}
-			}
-			if err := m.OutRateLimiter.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *FirecrackerMachineConfiguration) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: FirecrackerMachineConfiguration: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: FirecrackerMachineConfiguration: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CPUTemplate", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.CPUTemplate = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field HtEnabled", wireType)
-			}
-			var v int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				v |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			m.HtEnabled = bool(v != 0)
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MemSizeMib", wireType)
-			}
-			m.MemSizeMib = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.MemSizeMib |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 4:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field VcpuCount", wireType)
-			}
-			m.VcpuCount = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.VcpuCount |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *FirecrackerDrive) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: FirecrackerDrive: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: FirecrackerDrive: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IsReadOnly", wireType)
-			}
-			var v int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				v |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			m.IsReadOnly = bool(v != 0)
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IsRootDevice", wireType)
-			}
-			var v int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				v |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			m.IsRootDevice = bool(v != 0)
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Partuuid", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Partuuid = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PathOnHost", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.PathOnHost = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RateLimiter", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.RateLimiter == nil {
-				m.RateLimiter = &FirecrackerRateLimiter{}
-			}
-			if err := m.RateLimiter.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *FirecrackerRateLimiter) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: FirecrackerRateLimiter: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: FirecrackerRateLimiter: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Bandwidth", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.Bandwidth == nil {
-				m.Bandwidth = &FirecrackerTokenBucket{}
-			}
-			if err := m.Bandwidth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Ops", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.Ops == nil {
-				m.Ops = &FirecrackerTokenBucket{}
-			}
-			if err := m.Ops.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *FirecrackerTokenBucket) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: FirecrackerTokenBucket: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: FirecrackerTokenBucket: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field OneTimeBurst", wireType)
-			}
-			m.OneTimeBurst = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.OneTimeBurst |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RefillTime", wireType)
-			}
-			m.RefillTime = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.RefillTime |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType)
-			}
-			m.Capacity = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Capacity |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipTypes(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-			return iNdEx, nil
-		case 1:
-			iNdEx += 8
-			return iNdEx, nil
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthTypes
-			}
-			iNdEx += length
-			if iNdEx < 0 {
-				return 0, ErrInvalidLengthTypes
-			}
-			return iNdEx, nil
-		case 3:
-			for {
-				var innerWire uint64
-				var start int = iNdEx
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return 0, ErrIntOverflowTypes
-					}
-					if iNdEx >= l {
-						return 0, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					innerWire |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				innerWireType := int(innerWire & 0x7)
-				if innerWireType == 4 {
-					break
-				}
-				next, err := skipTypes(dAtA[start:])
-				if err != nil {
-					return 0, err
-				}
-				iNdEx = start + next
-				if iNdEx < 0 {
-					return 0, ErrInvalidLengthTypes
-				}
-			}
-			return iNdEx, nil
-		case 4:
-			return iNdEx, nil
-		case 5:
-			iNdEx += 4
-			return iNdEx, nil
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-	}
-	panic("unreachable")
-}
-
-var (
-	ErrInvalidLengthTypes = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowTypes   = fmt.Errorf("proto: integer overflow")
-)
diff --git a/proto/grpc/types.pb.go b/proto/types.pb.go
similarity index 100%
rename from proto/grpc/types.pb.go
rename to proto/types.pb.go
diff --git a/runtime/service.go b/runtime/service.go
index 1f669be..847e05f 100644
--- a/runtime/service.go
+++ b/runtime/service.go
@@ -56,7 +56,7 @@ import (
 	"github.com/firecracker-microvm/firecracker-containerd/eventbridge"
 	"github.com/firecracker-microvm/firecracker-containerd/internal/bundle"
 	"github.com/firecracker-microvm/firecracker-containerd/internal/vm"
-	proto "github.com/firecracker-microvm/firecracker-containerd/proto/grpc"
+	"github.com/firecracker-microvm/firecracker-containerd/proto"
 )
 
 func init() {
diff --git a/runtime/taskfirecrackeropts.go b/runtime/taskfirecrackeropts.go
index 7cc2097..8d70e4d 100644
--- a/runtime/taskfirecrackeropts.go
+++ b/runtime/taskfirecrackeropts.go
@@ -16,7 +16,7 @@ package main
 import (
 	"time"
 
-	proto "github.com/firecracker-microvm/firecracker-containerd/proto/grpc"
+	"github.com/firecracker-microvm/firecracker-containerd/proto"
 	firecracker "github.com/firecracker-microvm/firecracker-go-sdk"
 	models "github.com/firecracker-microvm/firecracker-go-sdk/client/models"
 	"github.com/pkg/errors"


Test patch:
diff --git a/firecracker-control/helpers_test.go b/firecracker-control/helpers_test.go
index c4a56c5..fcb5a6f 100644
--- a/firecracker-control/helpers_test.go
+++ b/firecracker-control/helpers_test.go
@@ -20,7 +20,7 @@ import (
 	models "github.com/firecracker-microvm/firecracker-go-sdk/client/models"
 	"github.com/stretchr/testify/assert"
 
-	proto "github.com/firecracker-microvm/firecracker-containerd/proto/grpc"
+	"github.com/firecracker-microvm/firecracker-containerd/proto"
 )
 
 const (
diff --git a/firecracker-control/local_test.go b/firecracker-control/local_test.go
index 1b2a504..5bf35f4 100644
--- a/firecracker-control/local_test.go
+++ b/firecracker-control/local_test.go
@@ -25,7 +25,7 @@ import (
 	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/assert"
 
-	proto "github.com/firecracker-microvm/firecracker-containerd/proto/grpc"
+	"github.com/firecracker-microvm/firecracker-containerd/proto"
 )
 
 var testCtx = context.Background()
diff --git a/internal/vm/task_test.go b/internal/vm/task_test.go
index e843a9a..b20659b 100644
--- a/internal/vm/task_test.go
+++ b/internal/vm/task_test.go
@@ -25,7 +25,7 @@ import (
 	"github.com/containerd/containerd/cio"
 	"github.com/containerd/containerd/runtime/v2/task"
 	"github.com/firecracker-microvm/firecracker-containerd/internal/bundle"
-	proto "github.com/firecracker-microvm/firecracker-containerd/proto/grpc"
+	"github.com/firecracker-microvm/firecracker-containerd/proto"
 	"github.com/stretchr/testify/require"
 )
 
diff --git a/runtime/service_integ_test.go b/runtime/service_integ_test.go
index bf1ee2d..b48197b 100644
--- a/runtime/service_integ_test.go
+++ b/runtime/service_integ_test.go
@@ -41,7 +41,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/firecracker-microvm/firecracker-containerd/internal"
-	proto "github.com/firecracker-microvm/firecracker-containerd/proto/grpc"
+	"github.com/firecracker-microvm/firecracker-containerd/proto"
 	"github.com/firecracker-microvm/firecracker-containerd/runtime/firecrackeroci"
 )
 
diff --git a/runtime/service_test.go b/runtime/service_test.go
index 3829201..6896bac 100644
--- a/runtime/service_test.go
+++ b/runtime/service_test.go
@@ -19,7 +19,7 @@ import (
 	"testing"
 
 	"github.com/containerd/typeurl"
-	proto "github.com/firecracker-microvm/firecracker-containerd/proto/grpc"
+	"github.com/firecracker-microvm/firecracker-containerd/proto"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/runtime/taskfirecrackeropts_test.go b/runtime/taskfirecrackeropts_test.go
index 12a8f73..ec00232 100644
--- a/runtime/taskfirecrackeropts_test.go
+++ b/runtime/taskfirecrackeropts_test.go
@@ -16,7 +16,7 @@ package main
 import (
 	"testing"
 
-	proto "github.com/firecracker-microvm/firecracker-containerd/proto/grpc"
+	"github.com/firecracker-microvm/firecracker-containerd/proto"
 	firecracker "github.com/firecracker-microvm/firecracker-go-sdk"
 	models "github.com/firecracker-microvm/firecracker-go-sdk/client/models"
 	"github.com/stretchr/testify/assert"