// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: data.proto

package proto

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

type DirEntry struct {
	// Mode is the file's mode. Only the high bits (eg. S_IFDIR)
	// are considered.
	Mode uint32 `protobuf:"varint,1,opt,name=mode,proto3" json:"mode,omitempty"`
	// Name is the basename of the file in the directory.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// sz is the size of the file in bytes.
	Sz    uint64 `protobuf:"varint,3,opt,name=sz,proto3" json:"sz,omitempty"`
	IsDir bool   `protobuf:"varint,4,opt,name=is_dir,json=isDir,proto3" json:"is_dir,omitempty"`
	// ModTime is the modification time of the file.
	ModTime              uint64   `protobuf:"varint,5,opt,name=mod_time,json=modTime,proto3" json:"mod_time,omitempty"`
	Nlink                uint32   `protobuf:"varint,6,opt,name=nlink,proto3" json:"nlink,omitempty"`
	Ino                  uint64   `protobuf:"varint,7,opt,name=ino,proto3" json:"ino,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DirEntry) Reset()         { *m = DirEntry{} }
func (m *DirEntry) String() string { return proto.CompactTextString(m) }
func (*DirEntry) ProtoMessage()    {}
func (*DirEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{0}
}
func (m *DirEntry) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DirEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DirEntry.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DirEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DirEntry.Merge(m, src)
}
func (m *DirEntry) XXX_Size() int {
	return m.Size()
}
func (m *DirEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_DirEntry.DiscardUnknown(m)
}

var xxx_messageInfo_DirEntry proto.InternalMessageInfo

func (m *DirEntry) GetMode() uint32 {
	if m != nil {
		return m.Mode
	}
	return 0
}

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

func (m *DirEntry) GetSz() uint64 {
	if m != nil {
		return m.Sz
	}
	return 0
}

func (m *DirEntry) GetIsDir() bool {
	if m != nil {
		return m.IsDir
	}
	return false
}

func (m *DirEntry) GetModTime() uint64 {
	if m != nil {
		return m.ModTime
	}
	return 0
}

func (m *DirEntry) GetNlink() uint32 {
	if m != nil {
		return m.Nlink
	}
	return 0
}

func (m *DirEntry) GetIno() uint64 {
	if m != nil {
		return m.Ino
	}
	return 0
}

type FileHandle struct {
	Token                string   `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Flags                uint32   `protobuf:"varint,3,opt,name=flags,proto3" json:"flags,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FileHandle) Reset()         { *m = FileHandle{} }
func (m *FileHandle) String() string { return proto.CompactTextString(m) }
func (*FileHandle) ProtoMessage()    {}
func (*FileHandle) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{1}
}
func (m *FileHandle) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FileHandle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FileHandle.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FileHandle) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FileHandle.Merge(m, src)
}
func (m *FileHandle) XXX_Size() int {
	return m.Size()
}
func (m *FileHandle) XXX_DiscardUnknown() {
	xxx_messageInfo_FileHandle.DiscardUnknown(m)
}

var xxx_messageInfo_FileHandle proto.InternalMessageInfo

func (m *FileHandle) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

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

func (m *FileHandle) GetFlags() uint32 {
	if m != nil {
		return m.Flags
	}
	return 0
}

type OpenReq struct {
	FileHandle           *FileHandle `protobuf:"bytes,1,opt,name=file_handle,json=fileHandle,proto3" json:"file_handle,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *OpenReq) Reset()         { *m = OpenReq{} }
func (m *OpenReq) String() string { return proto.CompactTextString(m) }
func (*OpenReq) ProtoMessage()    {}
func (*OpenReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{2}
}
func (m *OpenReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OpenReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OpenReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *OpenReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OpenReq.Merge(m, src)
}
func (m *OpenReq) XXX_Size() int {
	return m.Size()
}
func (m *OpenReq) XXX_DiscardUnknown() {
	xxx_messageInfo_OpenReq.DiscardUnknown(m)
}

var xxx_messageInfo_OpenReq proto.InternalMessageInfo

func (m *OpenReq) GetFileHandle() *FileHandle {
	if m != nil {
		return m.FileHandle
	}
	return nil
}

type OpenResp struct {
	Errno                int64    `protobuf:"varint,1,opt,name=errno,proto3" json:"errno,omitempty"`
	Error                *Error   `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *OpenResp) Reset()         { *m = OpenResp{} }
func (m *OpenResp) String() string { return proto.CompactTextString(m) }
func (*OpenResp) ProtoMessage()    {}
func (*OpenResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{3}
}
func (m *OpenResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OpenResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OpenResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *OpenResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OpenResp.Merge(m, src)
}
func (m *OpenResp) XXX_Size() int {
	return m.Size()
}
func (m *OpenResp) XXX_DiscardUnknown() {
	xxx_messageInfo_OpenResp.DiscardUnknown(m)
}

var xxx_messageInfo_OpenResp proto.InternalMessageInfo

func (m *OpenResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

func (m *OpenResp) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type CreateReq struct {
	FileHandle           *FileHandle `protobuf:"bytes,1,opt,name=file_handle,json=fileHandle,proto3" json:"file_handle,omitempty"`
	Mode                 uint32      `protobuf:"varint,2,opt,name=mode,proto3" json:"mode,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *CreateReq) Reset()         { *m = CreateReq{} }
func (m *CreateReq) String() string { return proto.CompactTextString(m) }
func (*CreateReq) ProtoMessage()    {}
func (*CreateReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{4}
}
func (m *CreateReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CreateReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateReq.Merge(m, src)
}
func (m *CreateReq) XXX_Size() int {
	return m.Size()
}
func (m *CreateReq) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateReq.DiscardUnknown(m)
}

var xxx_messageInfo_CreateReq proto.InternalMessageInfo

func (m *CreateReq) GetFileHandle() *FileHandle {
	if m != nil {
		return m.FileHandle
	}
	return nil
}

func (m *CreateReq) GetMode() uint32 {
	if m != nil {
		return m.Mode
	}
	return 0
}

type CreateResp struct {
	Errno                int64     `protobuf:"varint,1,opt,name=errno,proto3" json:"errno,omitempty"`
	Entry                *DirEntry `protobuf:"bytes,2,opt,name=entry,proto3" json:"entry,omitempty"`
	Error                *Error    `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *CreateResp) Reset()         { *m = CreateResp{} }
func (m *CreateResp) String() string { return proto.CompactTextString(m) }
func (*CreateResp) ProtoMessage()    {}
func (*CreateResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{5}
}
func (m *CreateResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CreateResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateResp.Merge(m, src)
}
func (m *CreateResp) XXX_Size() int {
	return m.Size()
}
func (m *CreateResp) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateResp.DiscardUnknown(m)
}

var xxx_messageInfo_CreateResp proto.InternalMessageInfo

func (m *CreateResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

func (m *CreateResp) GetEntry() *DirEntry {
	if m != nil {
		return m.Entry
	}
	return nil
}

func (m *CreateResp) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type FallocateReq struct {
	FileHandle           *FileHandle `protobuf:"bytes,1,opt,name=file_handle,json=fileHandle,proto3" json:"file_handle,omitempty"`
	Off                  uint64      `protobuf:"varint,2,opt,name=off,proto3" json:"off,omitempty"`
	Size_                uint64      `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"`
	Mode                 uint32      `protobuf:"varint,4,opt,name=mode,proto3" json:"mode,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *FallocateReq) Reset()         { *m = FallocateReq{} }
func (m *FallocateReq) String() string { return proto.CompactTextString(m) }
func (*FallocateReq) ProtoMessage()    {}
func (*FallocateReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{6}
}
func (m *FallocateReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FallocateReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FallocateReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FallocateReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FallocateReq.Merge(m, src)
}
func (m *FallocateReq) XXX_Size() int {
	return m.Size()
}
func (m *FallocateReq) XXX_DiscardUnknown() {
	xxx_messageInfo_FallocateReq.DiscardUnknown(m)
}

var xxx_messageInfo_FallocateReq proto.InternalMessageInfo

func (m *FallocateReq) GetFileHandle() *FileHandle {
	if m != nil {
		return m.FileHandle
	}
	return nil
}

func (m *FallocateReq) GetOff() uint64 {
	if m != nil {
		return m.Off
	}
	return 0
}

func (m *FallocateReq) GetSize_() uint64 {
	if m != nil {
		return m.Size_
	}
	return 0
}

func (m *FallocateReq) GetMode() uint32 {
	if m != nil {
		return m.Mode
	}
	return 0
}

type FallocateResp struct {
	Errno                int64    `protobuf:"varint,1,opt,name=errno,proto3" json:"errno,omitempty"`
	Error                *Error   `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FallocateResp) Reset()         { *m = FallocateResp{} }
func (m *FallocateResp) String() string { return proto.CompactTextString(m) }
func (*FallocateResp) ProtoMessage()    {}
func (*FallocateResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{7}
}
func (m *FallocateResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FallocateResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FallocateResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FallocateResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FallocateResp.Merge(m, src)
}
func (m *FallocateResp) XXX_Size() int {
	return m.Size()
}
func (m *FallocateResp) XXX_DiscardUnknown() {
	xxx_messageInfo_FallocateResp.DiscardUnknown(m)
}

var xxx_messageInfo_FallocateResp proto.InternalMessageInfo

func (m *FallocateResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

func (m *FallocateResp) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type UnlinkReq struct {
	Token                string   `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UnlinkReq) Reset()         { *m = UnlinkReq{} }
func (m *UnlinkReq) String() string { return proto.CompactTextString(m) }
func (*UnlinkReq) ProtoMessage()    {}
func (*UnlinkReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{8}
}
func (m *UnlinkReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UnlinkReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UnlinkReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UnlinkReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UnlinkReq.Merge(m, src)
}
func (m *UnlinkReq) XXX_Size() int {
	return m.Size()
}
func (m *UnlinkReq) XXX_DiscardUnknown() {
	xxx_messageInfo_UnlinkReq.DiscardUnknown(m)
}

var xxx_messageInfo_UnlinkReq proto.InternalMessageInfo

func (m *UnlinkReq) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

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

type UnlinkResp struct {
	Errno                int64    `protobuf:"varint,1,opt,name=errno,proto3" json:"errno,omitempty"`
	Error                *Error   `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UnlinkResp) Reset()         { *m = UnlinkResp{} }
func (m *UnlinkResp) String() string { return proto.CompactTextString(m) }
func (*UnlinkResp) ProtoMessage()    {}
func (*UnlinkResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{9}
}
func (m *UnlinkResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UnlinkResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UnlinkResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UnlinkResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UnlinkResp.Merge(m, src)
}
func (m *UnlinkResp) XXX_Size() int {
	return m.Size()
}
func (m *UnlinkResp) XXX_DiscardUnknown() {
	xxx_messageInfo_UnlinkResp.DiscardUnknown(m)
}

var xxx_messageInfo_UnlinkResp proto.InternalMessageInfo

func (m *UnlinkResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

func (m *UnlinkResp) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type LinkReq struct {
	Token                string   `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	OldName              string   `protobuf:"bytes,2,opt,name=old_name,json=oldName,proto3" json:"old_name,omitempty"`
	NewName              string   `protobuf:"bytes,3,opt,name=new_name,json=newName,proto3" json:"new_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LinkReq) Reset()         { *m = LinkReq{} }
func (m *LinkReq) String() string { return proto.CompactTextString(m) }
func (*LinkReq) ProtoMessage()    {}
func (*LinkReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{10}
}
func (m *LinkReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LinkReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LinkReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LinkReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LinkReq.Merge(m, src)
}
func (m *LinkReq) XXX_Size() int {
	return m.Size()
}
func (m *LinkReq) XXX_DiscardUnknown() {
	xxx_messageInfo_LinkReq.DiscardUnknown(m)
}

var xxx_messageInfo_LinkReq proto.InternalMessageInfo

func (m *LinkReq) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *LinkReq) GetOldName() string {
	if m != nil {
		return m.OldName
	}
	return ""
}

func (m *LinkReq) GetNewName() string {
	if m != nil {
		return m.NewName
	}
	return ""
}

type LinkResp struct {
	Errno                int64    `protobuf:"varint,1,opt,name=errno,proto3" json:"errno,omitempty"`
	Error                *Error   `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LinkResp) Reset()         { *m = LinkResp{} }
func (m *LinkResp) String() string { return proto.CompactTextString(m) }
func (*LinkResp) ProtoMessage()    {}
func (*LinkResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{11}
}
func (m *LinkResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LinkResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LinkResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LinkResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LinkResp.Merge(m, src)
}
func (m *LinkResp) XXX_Size() int {
	return m.Size()
}
func (m *LinkResp) XXX_DiscardUnknown() {
	xxx_messageInfo_LinkResp.DiscardUnknown(m)
}

var xxx_messageInfo_LinkResp proto.InternalMessageInfo

func (m *LinkResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

func (m *LinkResp) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type SymlinkReq struct {
	Token                string   `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	OldName              string   `protobuf:"bytes,2,opt,name=old_name,json=oldName,proto3" json:"old_name,omitempty"`
	NewName              string   `protobuf:"bytes,3,opt,name=new_name,json=newName,proto3" json:"new_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SymlinkReq) Reset()         { *m = SymlinkReq{} }
func (m *SymlinkReq) String() string { return proto.CompactTextString(m) }
func (*SymlinkReq) ProtoMessage()    {}
func (*SymlinkReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{12}
}
func (m *SymlinkReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SymlinkReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SymlinkReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SymlinkReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SymlinkReq.Merge(m, src)
}
func (m *SymlinkReq) XXX_Size() int {
	return m.Size()
}
func (m *SymlinkReq) XXX_DiscardUnknown() {
	xxx_messageInfo_SymlinkReq.DiscardUnknown(m)
}

var xxx_messageInfo_SymlinkReq proto.InternalMessageInfo

func (m *SymlinkReq) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *SymlinkReq) GetOldName() string {
	if m != nil {
		return m.OldName
	}
	return ""
}

func (m *SymlinkReq) GetNewName() string {
	if m != nil {
		return m.NewName
	}
	return ""
}

type SymlinkResp struct {
	Errno                int64     `protobuf:"varint,1,opt,name=errno,proto3" json:"errno,omitempty"`
	Entry                *DirEntry `protobuf:"bytes,2,opt,name=entry,proto3" json:"entry,omitempty"`
	Error                *Error    `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *SymlinkResp) Reset()         { *m = SymlinkResp{} }
func (m *SymlinkResp) String() string { return proto.CompactTextString(m) }
func (*SymlinkResp) ProtoMessage()    {}
func (*SymlinkResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{13}
}
func (m *SymlinkResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SymlinkResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SymlinkResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SymlinkResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SymlinkResp.Merge(m, src)
}
func (m *SymlinkResp) XXX_Size() int {
	return m.Size()
}
func (m *SymlinkResp) XXX_DiscardUnknown() {
	xxx_messageInfo_SymlinkResp.DiscardUnknown(m)
}

var xxx_messageInfo_SymlinkResp proto.InternalMessageInfo

func (m *SymlinkResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

func (m *SymlinkResp) GetEntry() *DirEntry {
	if m != nil {
		return m.Entry
	}
	return nil
}

func (m *SymlinkResp) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type ReadlinkReq struct {
	Token                string   `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReadlinkReq) Reset()         { *m = ReadlinkReq{} }
func (m *ReadlinkReq) String() string { return proto.CompactTextString(m) }
func (*ReadlinkReq) ProtoMessage()    {}
func (*ReadlinkReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{14}
}
func (m *ReadlinkReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReadlinkReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReadlinkReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ReadlinkReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReadlinkReq.Merge(m, src)
}
func (m *ReadlinkReq) XXX_Size() int {
	return m.Size()
}
func (m *ReadlinkReq) XXX_DiscardUnknown() {
	xxx_messageInfo_ReadlinkReq.DiscardUnknown(m)
}

var xxx_messageInfo_ReadlinkReq proto.InternalMessageInfo

func (m *ReadlinkReq) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

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

type ReadlinkResp struct {
	Errno                int64    `protobuf:"varint,1,opt,name=errno,proto3" json:"errno,omitempty"`
	Buf                  []byte   `protobuf:"bytes,2,opt,name=buf,proto3" json:"buf,omitempty"`
	Error                *Error   `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReadlinkResp) Reset()         { *m = ReadlinkResp{} }
func (m *ReadlinkResp) String() string { return proto.CompactTextString(m) }
func (*ReadlinkResp) ProtoMessage()    {}
func (*ReadlinkResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{15}
}
func (m *ReadlinkResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReadlinkResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReadlinkResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ReadlinkResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReadlinkResp.Merge(m, src)
}
func (m *ReadlinkResp) XXX_Size() int {
	return m.Size()
}
func (m *ReadlinkResp) XXX_DiscardUnknown() {
	xxx_messageInfo_ReadlinkResp.DiscardUnknown(m)
}

var xxx_messageInfo_ReadlinkResp proto.InternalMessageInfo

func (m *ReadlinkResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

func (m *ReadlinkResp) GetBuf() []byte {
	if m != nil {
		return m.Buf
	}
	return nil
}

func (m *ReadlinkResp) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type RenameReq struct {
	Token                string   `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	OldName              string   `protobuf:"bytes,2,opt,name=old_name,json=oldName,proto3" json:"old_name,omitempty"`
	NewName              string   `protobuf:"bytes,3,opt,name=new_name,json=newName,proto3" json:"new_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RenameReq) Reset()         { *m = RenameReq{} }
func (m *RenameReq) String() string { return proto.CompactTextString(m) }
func (*RenameReq) ProtoMessage()    {}
func (*RenameReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{16}
}
func (m *RenameReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RenameReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RenameReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RenameReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RenameReq.Merge(m, src)
}
func (m *RenameReq) XXX_Size() int {
	return m.Size()
}
func (m *RenameReq) XXX_DiscardUnknown() {
	xxx_messageInfo_RenameReq.DiscardUnknown(m)
}

var xxx_messageInfo_RenameReq proto.InternalMessageInfo

func (m *RenameReq) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *RenameReq) GetOldName() string {
	if m != nil {
		return m.OldName
	}
	return ""
}

func (m *RenameReq) GetNewName() string {
	if m != nil {
		return m.NewName
	}
	return ""
}

type RenameResp struct {
	Errno                int64    `protobuf:"varint,1,opt,name=errno,proto3" json:"errno,omitempty"`
	Error                *Error   `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RenameResp) Reset()         { *m = RenameResp{} }
func (m *RenameResp) String() string { return proto.CompactTextString(m) }
func (*RenameResp) ProtoMessage()    {}
func (*RenameResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{17}
}
func (m *RenameResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RenameResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RenameResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RenameResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RenameResp.Merge(m, src)
}
func (m *RenameResp) XXX_Size() int {
	return m.Size()
}
func (m *RenameResp) XXX_DiscardUnknown() {
	xxx_messageInfo_RenameResp.DiscardUnknown(m)
}

var xxx_messageInfo_RenameResp proto.InternalMessageInfo

func (m *RenameResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

func (m *RenameResp) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type MknodReq struct {
	Token                string   `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Mode                 uint32   `protobuf:"varint,3,opt,name=mode,proto3" json:"mode,omitempty"`
	Dev                  uint32   `protobuf:"varint,4,opt,name=dev,proto3" json:"dev,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MknodReq) Reset()         { *m = MknodReq{} }
func (m *MknodReq) String() string { return proto.CompactTextString(m) }
func (*MknodReq) ProtoMessage()    {}
func (*MknodReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{18}
}
func (m *MknodReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MknodReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MknodReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MknodReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MknodReq.Merge(m, src)
}
func (m *MknodReq) XXX_Size() int {
	return m.Size()
}
func (m *MknodReq) XXX_DiscardUnknown() {
	xxx_messageInfo_MknodReq.DiscardUnknown(m)
}

var xxx_messageInfo_MknodReq proto.InternalMessageInfo

func (m *MknodReq) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

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

func (m *MknodReq) GetMode() uint32 {
	if m != nil {
		return m.Mode
	}
	return 0
}

func (m *MknodReq) GetDev() uint32 {
	if m != nil {
		return m.Dev
	}
	return 0
}

type MknodResp struct {
	Errno                int64     `protobuf:"varint,1,opt,name=errno,proto3" json:"errno,omitempty"`
	Entry                *DirEntry `protobuf:"bytes,2,opt,name=entry,proto3" json:"entry,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *MknodResp) Reset()         { *m = MknodResp{} }
func (m *MknodResp) String() string { return proto.CompactTextString(m) }
func (*MknodResp) ProtoMessage()    {}
func (*MknodResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{19}
}
func (m *MknodResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MknodResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MknodResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MknodResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MknodResp.Merge(m, src)
}
func (m *MknodResp) XXX_Size() int {
	return m.Size()
}
func (m *MknodResp) XXX_DiscardUnknown() {
	xxx_messageInfo_MknodResp.DiscardUnknown(m)
}

var xxx_messageInfo_MknodResp proto.InternalMessageInfo

func (m *MknodResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

func (m *MknodResp) GetEntry() *DirEntry {
	if m != nil {
		return m.Entry
	}
	return nil
}

type MkdirReq struct {
	Token                string   `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Mode                 uint32   `protobuf:"varint,3,opt,name=mode,proto3" json:"mode,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MkdirReq) Reset()         { *m = MkdirReq{} }
func (m *MkdirReq) String() string { return proto.CompactTextString(m) }
func (*MkdirReq) ProtoMessage()    {}
func (*MkdirReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{20}
}
func (m *MkdirReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MkdirReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MkdirReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MkdirReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MkdirReq.Merge(m, src)
}
func (m *MkdirReq) XXX_Size() int {
	return m.Size()
}
func (m *MkdirReq) XXX_DiscardUnknown() {
	xxx_messageInfo_MkdirReq.DiscardUnknown(m)
}

var xxx_messageInfo_MkdirReq proto.InternalMessageInfo

func (m *MkdirReq) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

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

func (m *MkdirReq) GetMode() uint32 {
	if m != nil {
		return m.Mode
	}
	return 0
}

type MkdirResp struct {
	Errno                int64     `protobuf:"varint,1,opt,name=errno,proto3" json:"errno,omitempty"`
	Entry                *DirEntry `protobuf:"bytes,2,opt,name=entry,proto3" json:"entry,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *MkdirResp) Reset()         { *m = MkdirResp{} }
func (m *MkdirResp) String() string { return proto.CompactTextString(m) }
func (*MkdirResp) ProtoMessage()    {}
func (*MkdirResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{21}
}
func (m *MkdirResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MkdirResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MkdirResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MkdirResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MkdirResp.Merge(m, src)
}
func (m *MkdirResp) XXX_Size() int {
	return m.Size()
}
func (m *MkdirResp) XXX_DiscardUnknown() {
	xxx_messageInfo_MkdirResp.DiscardUnknown(m)
}

var xxx_messageInfo_MkdirResp proto.InternalMessageInfo

func (m *MkdirResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

func (m *MkdirResp) GetEntry() *DirEntry {
	if m != nil {
		return m.Entry
	}
	return nil
}

type RmdirReq struct {
	Token                string   `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RmdirReq) Reset()         { *m = RmdirReq{} }
func (m *RmdirReq) String() string { return proto.CompactTextString(m) }
func (*RmdirReq) ProtoMessage()    {}
func (*RmdirReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{22}
}
func (m *RmdirReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RmdirReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RmdirReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RmdirReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RmdirReq.Merge(m, src)
}
func (m *RmdirReq) XXX_Size() int {
	return m.Size()
}
func (m *RmdirReq) XXX_DiscardUnknown() {
	xxx_messageInfo_RmdirReq.DiscardUnknown(m)
}

var xxx_messageInfo_RmdirReq proto.InternalMessageInfo

func (m *RmdirReq) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

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

type RmdirResp struct {
	Errno                int64    `protobuf:"varint,1,opt,name=errno,proto3" json:"errno,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RmdirResp) Reset()         { *m = RmdirResp{} }
func (m *RmdirResp) String() string { return proto.CompactTextString(m) }
func (*RmdirResp) ProtoMessage()    {}
func (*RmdirResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{23}
}
func (m *RmdirResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RmdirResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RmdirResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RmdirResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RmdirResp.Merge(m, src)
}
func (m *RmdirResp) XXX_Size() int {
	return m.Size()
}
func (m *RmdirResp) XXX_DiscardUnknown() {
	xxx_messageInfo_RmdirResp.DiscardUnknown(m)
}

var xxx_messageInfo_RmdirResp proto.InternalMessageInfo

func (m *RmdirResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

type StatfsReq struct {
	Token                string   `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StatfsReq) Reset()         { *m = StatfsReq{} }
func (m *StatfsReq) String() string { return proto.CompactTextString(m) }
func (*StatfsReq) ProtoMessage()    {}
func (*StatfsReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{24}
}
func (m *StatfsReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StatfsReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StatfsReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *StatfsReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StatfsReq.Merge(m, src)
}
func (m *StatfsReq) XXX_Size() int {
	return m.Size()
}
func (m *StatfsReq) XXX_DiscardUnknown() {
	xxx_messageInfo_StatfsReq.DiscardUnknown(m)
}

var xxx_messageInfo_StatfsReq proto.InternalMessageInfo

func (m *StatfsReq) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

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

type StatfsResp struct {
	Errno                int64    `protobuf:"varint,1,opt,name=errno,proto3" json:"errno,omitempty"`
	Blocks               uint64   `protobuf:"varint,2,opt,name=blocks,proto3" json:"blocks,omitempty"`
	Bfree                uint64   `protobuf:"varint,3,opt,name=bfree,proto3" json:"bfree,omitempty"`
	Bavail               uint64   `protobuf:"varint,4,opt,name=bavail,proto3" json:"bavail,omitempty"`
	Files                uint64   `protobuf:"varint,5,opt,name=files,proto3" json:"files,omitempty"`
	Ffree                uint64   `protobuf:"varint,6,opt,name=ffree,proto3" json:"ffree,omitempty"`
	Bsize                uint32   `protobuf:"varint,7,opt,name=bsize,proto3" json:"bsize,omitempty"`
	Namelen              uint32   `protobuf:"varint,8,opt,name=namelen,proto3" json:"namelen,omitempty"`
	Frsize               uint32   `protobuf:"varint,9,opt,name=frsize,proto3" json:"frsize,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StatfsResp) Reset()         { *m = StatfsResp{} }
func (m *StatfsResp) String() string { return proto.CompactTextString(m) }
func (*StatfsResp) ProtoMessage()    {}
func (*StatfsResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{25}
}
func (m *StatfsResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StatfsResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StatfsResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *StatfsResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StatfsResp.Merge(m, src)
}
func (m *StatfsResp) XXX_Size() int {
	return m.Size()
}
func (m *StatfsResp) XXX_DiscardUnknown() {
	xxx_messageInfo_StatfsResp.DiscardUnknown(m)
}

var xxx_messageInfo_StatfsResp proto.InternalMessageInfo

func (m *StatfsResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

func (m *StatfsResp) GetBlocks() uint64 {
	if m != nil {
		return m.Blocks
	}
	return 0
}

func (m *StatfsResp) GetBfree() uint64 {
	if m != nil {
		return m.Bfree
	}
	return 0
}

func (m *StatfsResp) GetBavail() uint64 {
	if m != nil {
		return m.Bavail
	}
	return 0
}

func (m *StatfsResp) GetFiles() uint64 {
	if m != nil {
		return m.Files
	}
	return 0
}

func (m *StatfsResp) GetFfree() uint64 {
	if m != nil {
		return m.Ffree
	}
	return 0
}

func (m *StatfsResp) GetBsize() uint32 {
	if m != nil {
		return m.Bsize
	}
	return 0
}

func (m *StatfsResp) GetNamelen() uint32 {
	if m != nil {
		return m.Namelen
	}
	return 0
}

func (m *StatfsResp) GetFrsize() uint32 {
	if m != nil {
		return m.Frsize
	}
	return 0
}

type ReaddirReq struct {
	Token                string   `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReaddirReq) Reset()         { *m = ReaddirReq{} }
func (m *ReaddirReq) String() string { return proto.CompactTextString(m) }
func (*ReaddirReq) ProtoMessage()    {}
func (*ReaddirReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{26}
}
func (m *ReaddirReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReaddirReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReaddirReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ReaddirReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReaddirReq.Merge(m, src)
}
func (m *ReaddirReq) XXX_Size() int {
	return m.Size()
}
func (m *ReaddirReq) XXX_DiscardUnknown() {
	xxx_messageInfo_ReaddirReq.DiscardUnknown(m)
}

var xxx_messageInfo_ReaddirReq proto.InternalMessageInfo

func (m *ReaddirReq) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

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

type ReaddirResp struct {
	Entries              []*DirEntry `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
	Errno                int64       `protobuf:"varint,2,opt,name=errno,proto3" json:"errno,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *ReaddirResp) Reset()         { *m = ReaddirResp{} }
func (m *ReaddirResp) String() string { return proto.CompactTextString(m) }
func (*ReaddirResp) ProtoMessage()    {}
func (*ReaddirResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{27}
}
func (m *ReaddirResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReaddirResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReaddirResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ReaddirResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReaddirResp.Merge(m, src)
}
func (m *ReaddirResp) XXX_Size() int {
	return m.Size()
}
func (m *ReaddirResp) XXX_DiscardUnknown() {
	xxx_messageInfo_ReaddirResp.DiscardUnknown(m)
}

var xxx_messageInfo_ReaddirResp proto.InternalMessageInfo

func (m *ReaddirResp) GetEntries() []*DirEntry {
	if m != nil {
		return m.Entries
	}
	return nil
}

func (m *ReaddirResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

type LookupReq struct {
	Token                string   `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LookupReq) Reset()         { *m = LookupReq{} }
func (m *LookupReq) String() string { return proto.CompactTextString(m) }
func (*LookupReq) ProtoMessage()    {}
func (*LookupReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{28}
}
func (m *LookupReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LookupReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LookupReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LookupReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LookupReq.Merge(m, src)
}
func (m *LookupReq) XXX_Size() int {
	return m.Size()
}
func (m *LookupReq) XXX_DiscardUnknown() {
	xxx_messageInfo_LookupReq.DiscardUnknown(m)
}

var xxx_messageInfo_LookupReq proto.InternalMessageInfo

func (m *LookupReq) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

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

type LookupResp struct {
	Errno                int64     `protobuf:"varint,1,opt,name=errno,proto3" json:"errno,omitempty"`
	Entry                *DirEntry `protobuf:"bytes,2,opt,name=entry,proto3" json:"entry,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *LookupResp) Reset()         { *m = LookupResp{} }
func (m *LookupResp) String() string { return proto.CompactTextString(m) }
func (*LookupResp) ProtoMessage()    {}
func (*LookupResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{29}
}
func (m *LookupResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LookupResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LookupResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LookupResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LookupResp.Merge(m, src)
}
func (m *LookupResp) XXX_Size() int {
	return m.Size()
}
func (m *LookupResp) XXX_DiscardUnknown() {
	xxx_messageInfo_LookupResp.DiscardUnknown(m)
}

var xxx_messageInfo_LookupResp proto.InternalMessageInfo

func (m *LookupResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

func (m *LookupResp) GetEntry() *DirEntry {
	if m != nil {
		return m.Entry
	}
	return nil
}

type SetattrReq struct {
	Token                string      `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	FileHandle           *FileHandle `protobuf:"bytes,2,opt,name=file_handle,json=fileHandle,proto3" json:"file_handle,omitempty"`
	Entry                *DirEntry   `protobuf:"bytes,3,opt,name=entry,proto3" json:"entry,omitempty"`
	SetMode              bool        `protobuf:"varint,4,opt,name=set_mode,json=setMode,proto3" json:"set_mode,omitempty"`
	SetSize              bool        `protobuf:"varint,5,opt,name=set_size,json=setSize,proto3" json:"set_size,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *SetattrReq) Reset()         { *m = SetattrReq{} }
func (m *SetattrReq) String() string { return proto.CompactTextString(m) }
func (*SetattrReq) ProtoMessage()    {}
func (*SetattrReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{30}
}
func (m *SetattrReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SetattrReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SetattrReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SetattrReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetattrReq.Merge(m, src)
}
func (m *SetattrReq) XXX_Size() int {
	return m.Size()
}
func (m *SetattrReq) XXX_DiscardUnknown() {
	xxx_messageInfo_SetattrReq.DiscardUnknown(m)
}

var xxx_messageInfo_SetattrReq proto.InternalMessageInfo

func (m *SetattrReq) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *SetattrReq) GetFileHandle() *FileHandle {
	if m != nil {
		return m.FileHandle
	}
	return nil
}

func (m *SetattrReq) GetEntry() *DirEntry {
	if m != nil {
		return m.Entry
	}
	return nil
}

func (m *SetattrReq) GetSetMode() bool {
	if m != nil {
		return m.SetMode
	}
	return false
}

func (m *SetattrReq) GetSetSize() bool {
	if m != nil {
		return m.SetSize
	}
	return false
}

type SetattrResp struct {
	Errno                int64     `protobuf:"varint,1,opt,name=errno,proto3" json:"errno,omitempty"`
	Entry                *DirEntry `protobuf:"bytes,2,opt,name=entry,proto3" json:"entry,omitempty"`
	Error                *Error    `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *SetattrResp) Reset()         { *m = SetattrResp{} }
func (m *SetattrResp) String() string { return proto.CompactTextString(m) }
func (*SetattrResp) ProtoMessage()    {}
func (*SetattrResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{31}
}
func (m *SetattrResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SetattrResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SetattrResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SetattrResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetattrResp.Merge(m, src)
}
func (m *SetattrResp) XXX_Size() int {
	return m.Size()
}
func (m *SetattrResp) XXX_DiscardUnknown() {
	xxx_messageInfo_SetattrResp.DiscardUnknown(m)
}

var xxx_messageInfo_SetattrResp proto.InternalMessageInfo

func (m *SetattrResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

func (m *SetattrResp) GetEntry() *DirEntry {
	if m != nil {
		return m.Entry
	}
	return nil
}

func (m *SetattrResp) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type AccessReq struct {
	Token                string   `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Mode                 uint32   `protobuf:"varint,3,opt,name=mode,proto3" json:"mode,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AccessReq) Reset()         { *m = AccessReq{} }
func (m *AccessReq) String() string { return proto.CompactTextString(m) }
func (*AccessReq) ProtoMessage()    {}
func (*AccessReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{32}
}
func (m *AccessReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AccessReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AccessReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AccessReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AccessReq.Merge(m, src)
}
func (m *AccessReq) XXX_Size() int {
	return m.Size()
}
func (m *AccessReq) XXX_DiscardUnknown() {
	xxx_messageInfo_AccessReq.DiscardUnknown(m)
}

var xxx_messageInfo_AccessReq proto.InternalMessageInfo

func (m *AccessReq) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

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

func (m *AccessReq) GetMode() uint32 {
	if m != nil {
		return m.Mode
	}
	return 0
}

type AccessResp struct {
	Errno                int64    `protobuf:"varint,1,opt,name=errno,proto3" json:"errno,omitempty"`
	Error                *Error   `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AccessResp) Reset()         { *m = AccessResp{} }
func (m *AccessResp) String() string { return proto.CompactTextString(m) }
func (*AccessResp) ProtoMessage()    {}
func (*AccessResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{33}
}
func (m *AccessResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AccessResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AccessResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AccessResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AccessResp.Merge(m, src)
}
func (m *AccessResp) XXX_Size() int {
	return m.Size()
}
func (m *AccessResp) XXX_DiscardUnknown() {
	xxx_messageInfo_AccessResp.DiscardUnknown(m)
}

var xxx_messageInfo_AccessResp proto.InternalMessageInfo

func (m *AccessResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

func (m *AccessResp) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type CloseReq struct {
	FileHandle           *FileHandle `protobuf:"bytes,3,opt,name=file_handle,json=fileHandle,proto3" json:"file_handle,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *CloseReq) Reset()         { *m = CloseReq{} }
func (m *CloseReq) String() string { return proto.CompactTextString(m) }
func (*CloseReq) ProtoMessage()    {}
func (*CloseReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{34}
}
func (m *CloseReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CloseReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CloseReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CloseReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloseReq.Merge(m, src)
}
func (m *CloseReq) XXX_Size() int {
	return m.Size()
}
func (m *CloseReq) XXX_DiscardUnknown() {
	xxx_messageInfo_CloseReq.DiscardUnknown(m)
}

var xxx_messageInfo_CloseReq proto.InternalMessageInfo

func (m *CloseReq) GetFileHandle() *FileHandle {
	if m != nil {
		return m.FileHandle
	}
	return nil
}

type CloseResp struct {
	Errno                int64    `protobuf:"varint,1,opt,name=errno,proto3" json:"errno,omitempty"`
	Error                *Error   `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CloseResp) Reset()         { *m = CloseResp{} }
func (m *CloseResp) String() string { return proto.CompactTextString(m) }
func (*CloseResp) ProtoMessage()    {}
func (*CloseResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{35}
}
func (m *CloseResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CloseResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CloseResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CloseResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloseResp.Merge(m, src)
}
func (m *CloseResp) XXX_Size() int {
	return m.Size()
}
func (m *CloseResp) XXX_DiscardUnknown() {
	xxx_messageInfo_CloseResp.DiscardUnknown(m)
}

var xxx_messageInfo_CloseResp proto.InternalMessageInfo

func (m *CloseResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

func (m *CloseResp) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type ReadReq struct {
	FileHandle           *FileHandle `protobuf:"bytes,1,opt,name=file_handle,json=fileHandle,proto3" json:"file_handle,omitempty"`
	Off                  int64       `protobuf:"varint,2,opt,name=off,proto3" json:"off,omitempty"`
	Len                  int64       `protobuf:"varint,3,opt,name=len,proto3" json:"len,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *ReadReq) Reset()         { *m = ReadReq{} }
func (m *ReadReq) String() string { return proto.CompactTextString(m) }
func (*ReadReq) ProtoMessage()    {}
func (*ReadReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{36}
}
func (m *ReadReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReadReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReadReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ReadReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReadReq.Merge(m, src)
}
func (m *ReadReq) XXX_Size() int {
	return m.Size()
}
func (m *ReadReq) XXX_DiscardUnknown() {
	xxx_messageInfo_ReadReq.DiscardUnknown(m)
}

var xxx_messageInfo_ReadReq proto.InternalMessageInfo

func (m *ReadReq) GetFileHandle() *FileHandle {
	if m != nil {
		return m.FileHandle
	}
	return nil
}

func (m *ReadReq) GetOff() int64 {
	if m != nil {
		return m.Off
	}
	return 0
}

func (m *ReadReq) GetLen() int64 {
	if m != nil {
		return m.Len
	}
	return 0
}

type Frame struct {
	Off                  uint64   `protobuf:"varint,1,opt,name=off,proto3" json:"off,omitempty"`
	Len                  uint64   `protobuf:"varint,2,opt,name=len,proto3" json:"len,omitempty"`
	Data                 []byte   `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Frame) Reset()         { *m = Frame{} }
func (m *Frame) String() string { return proto.CompactTextString(m) }
func (*Frame) ProtoMessage()    {}
func (*Frame) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{37}
}
func (m *Frame) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Frame) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Frame.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Frame) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Frame.Merge(m, src)
}
func (m *Frame) XXX_Size() int {
	return m.Size()
}
func (m *Frame) XXX_DiscardUnknown() {
	xxx_messageInfo_Frame.DiscardUnknown(m)
}

var xxx_messageInfo_Frame proto.InternalMessageInfo

func (m *Frame) GetOff() uint64 {
	if m != nil {
		return m.Off
	}
	return 0
}

func (m *Frame) GetLen() uint64 {
	if m != nil {
		return m.Len
	}
	return 0
}

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

type ReadResp struct {
	Buf                  []byte   `protobuf:"bytes,1,opt,name=buf,proto3" json:"buf,omitempty"`
	Frames               []*Frame `protobuf:"bytes,2,rep,name=frames,proto3" json:"frames,omitempty"`
	Done                 bool     `protobuf:"varint,3,opt,name=done,proto3" json:"done,omitempty"`
	Errno                int64    `protobuf:"varint,4,opt,name=errno,proto3" json:"errno,omitempty"`
	Error                *Error   `protobuf:"bytes,5,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReadResp) Reset()         { *m = ReadResp{} }
func (m *ReadResp) String() string { return proto.CompactTextString(m) }
func (*ReadResp) ProtoMessage()    {}
func (*ReadResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{38}
}
func (m *ReadResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReadResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReadResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ReadResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReadResp.Merge(m, src)
}
func (m *ReadResp) XXX_Size() int {
	return m.Size()
}
func (m *ReadResp) XXX_DiscardUnknown() {
	xxx_messageInfo_ReadResp.DiscardUnknown(m)
}

var xxx_messageInfo_ReadResp proto.InternalMessageInfo

func (m *ReadResp) GetBuf() []byte {
	if m != nil {
		return m.Buf
	}
	return nil
}

func (m *ReadResp) GetFrames() []*Frame {
	if m != nil {
		return m.Frames
	}
	return nil
}

func (m *ReadResp) GetDone() bool {
	if m != nil {
		return m.Done
	}
	return false
}

func (m *ReadResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

func (m *ReadResp) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type WriteReq struct {
	FileHandle           *FileHandle `protobuf:"bytes,1,opt,name=file_handle,json=fileHandle,proto3" json:"file_handle,omitempty"`
	Buf                  []byte      `protobuf:"bytes,2,opt,name=buf,proto3" json:"buf,omitempty"`
	Off                  int64       `protobuf:"varint,3,opt,name=off,proto3" json:"off,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *WriteReq) Reset()         { *m = WriteReq{} }
func (m *WriteReq) String() string { return proto.CompactTextString(m) }
func (*WriteReq) ProtoMessage()    {}
func (*WriteReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{39}
}
func (m *WriteReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WriteReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_WriteReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *WriteReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WriteReq.Merge(m, src)
}
func (m *WriteReq) XXX_Size() int {
	return m.Size()
}
func (m *WriteReq) XXX_DiscardUnknown() {
	xxx_messageInfo_WriteReq.DiscardUnknown(m)
}

var xxx_messageInfo_WriteReq proto.InternalMessageInfo

func (m *WriteReq) GetFileHandle() *FileHandle {
	if m != nil {
		return m.FileHandle
	}
	return nil
}

func (m *WriteReq) GetBuf() []byte {
	if m != nil {
		return m.Buf
	}
	return nil
}

func (m *WriteReq) GetOff() int64 {
	if m != nil {
		return m.Off
	}
	return 0
}

type WriteResp struct {
	Written              int64    `protobuf:"varint,1,opt,name=written,proto3" json:"written,omitempty"`
	Errno                int64    `protobuf:"varint,2,opt,name=errno,proto3" json:"errno,omitempty"`
	Error                *Error   `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *WriteResp) Reset()         { *m = WriteResp{} }
func (m *WriteResp) String() string { return proto.CompactTextString(m) }
func (*WriteResp) ProtoMessage()    {}
func (*WriteResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{40}
}
func (m *WriteResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WriteResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_WriteResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *WriteResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WriteResp.Merge(m, src)
}
func (m *WriteResp) XXX_Size() int {
	return m.Size()
}
func (m *WriteResp) XXX_DiscardUnknown() {
	xxx_messageInfo_WriteResp.DiscardUnknown(m)
}

var xxx_messageInfo_WriteResp proto.InternalMessageInfo

func (m *WriteResp) GetWritten() int64 {
	if m != nil {
		return m.Written
	}
	return 0
}

func (m *WriteResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

func (m *WriteResp) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type FlushReq struct {
	FileHandle           *FileHandle `protobuf:"bytes,1,opt,name=file_handle,json=fileHandle,proto3" json:"file_handle,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *FlushReq) Reset()         { *m = FlushReq{} }
func (m *FlushReq) String() string { return proto.CompactTextString(m) }
func (*FlushReq) ProtoMessage()    {}
func (*FlushReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{41}
}
func (m *FlushReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FlushReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FlushReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FlushReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FlushReq.Merge(m, src)
}
func (m *FlushReq) XXX_Size() int {
	return m.Size()
}
func (m *FlushReq) XXX_DiscardUnknown() {
	xxx_messageInfo_FlushReq.DiscardUnknown(m)
}

var xxx_messageInfo_FlushReq proto.InternalMessageInfo

func (m *FlushReq) GetFileHandle() *FileHandle {
	if m != nil {
		return m.FileHandle
	}
	return nil
}

type FlushResp struct {
	Errno                int64     `protobuf:"varint,1,opt,name=errno,proto3" json:"errno,omitempty"`
	Entry                *DirEntry `protobuf:"bytes,2,opt,name=entry,proto3" json:"entry,omitempty"`
	Error                *Error    `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *FlushResp) Reset()         { *m = FlushResp{} }
func (m *FlushResp) String() string { return proto.CompactTextString(m) }
func (*FlushResp) ProtoMessage()    {}
func (*FlushResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{42}
}
func (m *FlushResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FlushResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FlushResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FlushResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FlushResp.Merge(m, src)
}
func (m *FlushResp) XXX_Size() int {
	return m.Size()
}
func (m *FlushResp) XXX_DiscardUnknown() {
	xxx_messageInfo_FlushResp.DiscardUnknown(m)
}

var xxx_messageInfo_FlushResp proto.InternalMessageInfo

func (m *FlushResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

func (m *FlushResp) GetEntry() *DirEntry {
	if m != nil {
		return m.Entry
	}
	return nil
}

func (m *FlushResp) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type FsyncReq struct {
	FileHandle           *FileHandle `protobuf:"bytes,1,opt,name=file_handle,json=fileHandle,proto3" json:"file_handle,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *FsyncReq) Reset()         { *m = FsyncReq{} }
func (m *FsyncReq) String() string { return proto.CompactTextString(m) }
func (*FsyncReq) ProtoMessage()    {}
func (*FsyncReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{43}
}
func (m *FsyncReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FsyncReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FsyncReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FsyncReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FsyncReq.Merge(m, src)
}
func (m *FsyncReq) XXX_Size() int {
	return m.Size()
}
func (m *FsyncReq) XXX_DiscardUnknown() {
	xxx_messageInfo_FsyncReq.DiscardUnknown(m)
}

var xxx_messageInfo_FsyncReq proto.InternalMessageInfo

func (m *FsyncReq) GetFileHandle() *FileHandle {
	if m != nil {
		return m.FileHandle
	}
	return nil
}

type FsyncResp struct {
	Errno                int64     `protobuf:"varint,1,opt,name=errno,proto3" json:"errno,omitempty"`
	Entry                *DirEntry `protobuf:"bytes,2,opt,name=entry,proto3" json:"entry,omitempty"`
	Error                *Error    `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *FsyncResp) Reset()         { *m = FsyncResp{} }
func (m *FsyncResp) String() string { return proto.CompactTextString(m) }
func (*FsyncResp) ProtoMessage()    {}
func (*FsyncResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{44}
}
func (m *FsyncResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FsyncResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FsyncResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FsyncResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FsyncResp.Merge(m, src)
}
func (m *FsyncResp) XXX_Size() int {
	return m.Size()
}
func (m *FsyncResp) XXX_DiscardUnknown() {
	xxx_messageInfo_FsyncResp.DiscardUnknown(m)
}

var xxx_messageInfo_FsyncResp proto.InternalMessageInfo

func (m *FsyncResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

func (m *FsyncResp) GetEntry() *DirEntry {
	if m != nil {
		return m.Entry
	}
	return nil
}

func (m *FsyncResp) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type BatchCommandsRequest struct {
	Requests             []*BatchCommandsRequest_Request `protobuf:"bytes,1,rep,name=requests,proto3" json:"requests,omitempty"`
	RequestIds           []uint64                        `protobuf:"varint,2,rep,packed,name=request_ids,json=requestIds,proto3" json:"request_ids,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
	XXX_unrecognized     []byte                          `json:"-"`
	XXX_sizecache        int32                           `json:"-"`
}

func (m *BatchCommandsRequest) Reset()         { *m = BatchCommandsRequest{} }
func (m *BatchCommandsRequest) String() string { return proto.CompactTextString(m) }
func (*BatchCommandsRequest) ProtoMessage()    {}
func (*BatchCommandsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{45}
}
func (m *BatchCommandsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BatchCommandsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BatchCommandsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BatchCommandsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BatchCommandsRequest.Merge(m, src)
}
func (m *BatchCommandsRequest) XXX_Size() int {
	return m.Size()
}
func (m *BatchCommandsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BatchCommandsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BatchCommandsRequest proto.InternalMessageInfo

func (m *BatchCommandsRequest) GetRequests() []*BatchCommandsRequest_Request {
	if m != nil {
		return m.Requests
	}
	return nil
}

func (m *BatchCommandsRequest) GetRequestIds() []uint64 {
	if m != nil {
		return m.RequestIds
	}
	return nil
}

type BatchCommandsRequest_Request struct {
	// Types that are valid to be assigned to Cmd:
	//	*BatchCommandsRequest_Request_Read
	//	*BatchCommandsRequest_Request_Write
	//	*BatchCommandsRequest_Request_Flush
	//	*BatchCommandsRequest_Request_Fsync
	//	*BatchCommandsRequest_Request_Setattr
	//	*BatchCommandsRequest_Request_Fallocate
	Cmd                  isBatchCommandsRequest_Request_Cmd `protobuf_oneof:"Cmd"`
	XXX_NoUnkeyedLiteral struct{}                           `json:"-"`
	XXX_unrecognized     []byte                             `json:"-"`
	XXX_sizecache        int32                              `json:"-"`
}

func (m *BatchCommandsRequest_Request) Reset()         { *m = BatchCommandsRequest_Request{} }
func (m *BatchCommandsRequest_Request) String() string { return proto.CompactTextString(m) }
func (*BatchCommandsRequest_Request) ProtoMessage()    {}
func (*BatchCommandsRequest_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{45, 0}
}
func (m *BatchCommandsRequest_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BatchCommandsRequest_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BatchCommandsRequest_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BatchCommandsRequest_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BatchCommandsRequest_Request.Merge(m, src)
}
func (m *BatchCommandsRequest_Request) XXX_Size() int {
	return m.Size()
}
func (m *BatchCommandsRequest_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_BatchCommandsRequest_Request.DiscardUnknown(m)
}

var xxx_messageInfo_BatchCommandsRequest_Request proto.InternalMessageInfo

type isBatchCommandsRequest_Request_Cmd interface {
	isBatchCommandsRequest_Request_Cmd()
	MarshalTo([]byte) (int, error)
	Size() int
}

type BatchCommandsRequest_Request_Read struct {
	Read *ReadReq `protobuf:"bytes,1,opt,name=read,proto3,oneof" json:"read,omitempty"`
}
type BatchCommandsRequest_Request_Write struct {
	Write *WriteReq `protobuf:"bytes,2,opt,name=write,proto3,oneof" json:"write,omitempty"`
}
type BatchCommandsRequest_Request_Flush struct {
	Flush *FlushReq `protobuf:"bytes,3,opt,name=flush,proto3,oneof" json:"flush,omitempty"`
}
type BatchCommandsRequest_Request_Fsync struct {
	Fsync *FsyncReq `protobuf:"bytes,4,opt,name=fsync,proto3,oneof" json:"fsync,omitempty"`
}
type BatchCommandsRequest_Request_Setattr struct {
	Setattr *SetattrReq `protobuf:"bytes,5,opt,name=setattr,proto3,oneof" json:"setattr,omitempty"`
}
type BatchCommandsRequest_Request_Fallocate struct {
	Fallocate *FallocateReq `protobuf:"bytes,6,opt,name=fallocate,proto3,oneof" json:"fallocate,omitempty"`
}

func (*BatchCommandsRequest_Request_Read) isBatchCommandsRequest_Request_Cmd()      {}
func (*BatchCommandsRequest_Request_Write) isBatchCommandsRequest_Request_Cmd()     {}
func (*BatchCommandsRequest_Request_Flush) isBatchCommandsRequest_Request_Cmd()     {}
func (*BatchCommandsRequest_Request_Fsync) isBatchCommandsRequest_Request_Cmd()     {}
func (*BatchCommandsRequest_Request_Setattr) isBatchCommandsRequest_Request_Cmd()   {}
func (*BatchCommandsRequest_Request_Fallocate) isBatchCommandsRequest_Request_Cmd() {}

func (m *BatchCommandsRequest_Request) GetCmd() isBatchCommandsRequest_Request_Cmd {
	if m != nil {
		return m.Cmd
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetRead() *ReadReq {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Read); ok {
		return x.Read
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetWrite() *WriteReq {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Write); ok {
		return x.Write
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetFlush() *FlushReq {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Flush); ok {
		return x.Flush
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetFsync() *FsyncReq {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Fsync); ok {
		return x.Fsync
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetSetattr() *SetattrReq {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Setattr); ok {
		return x.Setattr
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetFallocate() *FallocateReq {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Fallocate); ok {
		return x.Fallocate
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*BatchCommandsRequest_Request) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*BatchCommandsRequest_Request_Read)(nil),
		(*BatchCommandsRequest_Request_Write)(nil),
		(*BatchCommandsRequest_Request_Flush)(nil),
		(*BatchCommandsRequest_Request_Fsync)(nil),
		(*BatchCommandsRequest_Request_Setattr)(nil),
		(*BatchCommandsRequest_Request_Fallocate)(nil),
	}
}

type BatchCommandsResponse struct {
	Responses            []*BatchCommandsResponse_Response `protobuf:"bytes,1,rep,name=responses,proto3" json:"responses,omitempty"`
	RequestIds           []uint64                          `protobuf:"varint,2,rep,packed,name=request_ids,json=requestIds,proto3" json:"request_ids,omitempty"`
	NotMount             bool                              `protobuf:"varint,3,opt,name=not_mount,json=notMount,proto3" json:"not_mount,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
	XXX_unrecognized     []byte                            `json:"-"`
	XXX_sizecache        int32                             `json:"-"`
}

func (m *BatchCommandsResponse) Reset()         { *m = BatchCommandsResponse{} }
func (m *BatchCommandsResponse) String() string { return proto.CompactTextString(m) }
func (*BatchCommandsResponse) ProtoMessage()    {}
func (*BatchCommandsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{46}
}
func (m *BatchCommandsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BatchCommandsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BatchCommandsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BatchCommandsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BatchCommandsResponse.Merge(m, src)
}
func (m *BatchCommandsResponse) XXX_Size() int {
	return m.Size()
}
func (m *BatchCommandsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_BatchCommandsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_BatchCommandsResponse proto.InternalMessageInfo

func (m *BatchCommandsResponse) GetResponses() []*BatchCommandsResponse_Response {
	if m != nil {
		return m.Responses
	}
	return nil
}

func (m *BatchCommandsResponse) GetRequestIds() []uint64 {
	if m != nil {
		return m.RequestIds
	}
	return nil
}

func (m *BatchCommandsResponse) GetNotMount() bool {
	if m != nil {
		return m.NotMount
	}
	return false
}

type BatchCommandsResponse_Response struct {
	// Types that are valid to be assigned to Cmd:
	//	*BatchCommandsResponse_Response_Read
	//	*BatchCommandsResponse_Response_Write
	//	*BatchCommandsResponse_Response_Flush
	//	*BatchCommandsResponse_Response_Fsync
	//	*BatchCommandsResponse_Response_Setattr
	//	*BatchCommandsResponse_Response_Fallocate
	Cmd                  isBatchCommandsResponse_Response_Cmd `protobuf_oneof:"Cmd"`
	XXX_NoUnkeyedLiteral struct{}                             `json:"-"`
	XXX_unrecognized     []byte                               `json:"-"`
	XXX_sizecache        int32                                `json:"-"`
}

func (m *BatchCommandsResponse_Response) Reset()         { *m = BatchCommandsResponse_Response{} }
func (m *BatchCommandsResponse_Response) String() string { return proto.CompactTextString(m) }
func (*BatchCommandsResponse_Response) ProtoMessage()    {}
func (*BatchCommandsResponse_Response) Descriptor() ([]byte, []int) {
	return fileDescriptor_871986018790d2fd, []int{46, 0}
}
func (m *BatchCommandsResponse_Response) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BatchCommandsResponse_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BatchCommandsResponse_Response.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BatchCommandsResponse_Response) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BatchCommandsResponse_Response.Merge(m, src)
}
func (m *BatchCommandsResponse_Response) XXX_Size() int {
	return m.Size()
}
func (m *BatchCommandsResponse_Response) XXX_DiscardUnknown() {
	xxx_messageInfo_BatchCommandsResponse_Response.DiscardUnknown(m)
}

var xxx_messageInfo_BatchCommandsResponse_Response proto.InternalMessageInfo

type isBatchCommandsResponse_Response_Cmd interface {
	isBatchCommandsResponse_Response_Cmd()
	MarshalTo([]byte) (int, error)
	Size() int
}

type BatchCommandsResponse_Response_Read struct {
	Read *ReadResp `protobuf:"bytes,1,opt,name=read,proto3,oneof" json:"read,omitempty"`
}
type BatchCommandsResponse_Response_Write struct {
	Write *WriteResp `protobuf:"bytes,2,opt,name=write,proto3,oneof" json:"write,omitempty"`
}
type BatchCommandsResponse_Response_Flush struct {
	Flush *FlushResp `protobuf:"bytes,3,opt,name=flush,proto3,oneof" json:"flush,omitempty"`
}
type BatchCommandsResponse_Response_Fsync struct {
	Fsync *FsyncResp `protobuf:"bytes,4,opt,name=fsync,proto3,oneof" json:"fsync,omitempty"`
}
type BatchCommandsResponse_Response_Setattr struct {
	Setattr *SetattrResp `protobuf:"bytes,5,opt,name=setattr,proto3,oneof" json:"setattr,omitempty"`
}
type BatchCommandsResponse_Response_Fallocate struct {
	Fallocate *FallocateResp `protobuf:"bytes,6,opt,name=fallocate,proto3,oneof" json:"fallocate,omitempty"`
}

func (*BatchCommandsResponse_Response_Read) isBatchCommandsResponse_Response_Cmd()      {}
func (*BatchCommandsResponse_Response_Write) isBatchCommandsResponse_Response_Cmd()     {}
func (*BatchCommandsResponse_Response_Flush) isBatchCommandsResponse_Response_Cmd()     {}
func (*BatchCommandsResponse_Response_Fsync) isBatchCommandsResponse_Response_Cmd()     {}
func (*BatchCommandsResponse_Response_Setattr) isBatchCommandsResponse_Response_Cmd()   {}
func (*BatchCommandsResponse_Response_Fallocate) isBatchCommandsResponse_Response_Cmd() {}

func (m *BatchCommandsResponse_Response) GetCmd() isBatchCommandsResponse_Response_Cmd {
	if m != nil {
		return m.Cmd
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetRead() *ReadResp {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Read); ok {
		return x.Read
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetWrite() *WriteResp {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Write); ok {
		return x.Write
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetFlush() *FlushResp {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Flush); ok {
		return x.Flush
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetFsync() *FsyncResp {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Fsync); ok {
		return x.Fsync
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetSetattr() *SetattrResp {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Setattr); ok {
		return x.Setattr
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetFallocate() *FallocateResp {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Fallocate); ok {
		return x.Fallocate
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*BatchCommandsResponse_Response) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*BatchCommandsResponse_Response_Read)(nil),
		(*BatchCommandsResponse_Response_Write)(nil),
		(*BatchCommandsResponse_Response_Flush)(nil),
		(*BatchCommandsResponse_Response_Fsync)(nil),
		(*BatchCommandsResponse_Response_Setattr)(nil),
		(*BatchCommandsResponse_Response_Fallocate)(nil),
	}
}

func init() {
	proto.RegisterType((*DirEntry)(nil), "data.DirEntry")
	proto.RegisterType((*FileHandle)(nil), "data.FileHandle")
	proto.RegisterType((*OpenReq)(nil), "data.OpenReq")
	proto.RegisterType((*OpenResp)(nil), "data.OpenResp")
	proto.RegisterType((*CreateReq)(nil), "data.CreateReq")
	proto.RegisterType((*CreateResp)(nil), "data.CreateResp")
	proto.RegisterType((*FallocateReq)(nil), "data.FallocateReq")
	proto.RegisterType((*FallocateResp)(nil), "data.FallocateResp")
	proto.RegisterType((*UnlinkReq)(nil), "data.UnlinkReq")
	proto.RegisterType((*UnlinkResp)(nil), "data.UnlinkResp")
	proto.RegisterType((*LinkReq)(nil), "data.LinkReq")
	proto.RegisterType((*LinkResp)(nil), "data.LinkResp")
	proto.RegisterType((*SymlinkReq)(nil), "data.SymlinkReq")
	proto.RegisterType((*SymlinkResp)(nil), "data.SymlinkResp")
	proto.RegisterType((*ReadlinkReq)(nil), "data.ReadlinkReq")
	proto.RegisterType((*ReadlinkResp)(nil), "data.ReadlinkResp")
	proto.RegisterType((*RenameReq)(nil), "data.RenameReq")
	proto.RegisterType((*RenameResp)(nil), "data.RenameResp")
	proto.RegisterType((*MknodReq)(nil), "data.MknodReq")
	proto.RegisterType((*MknodResp)(nil), "data.MknodResp")
	proto.RegisterType((*MkdirReq)(nil), "data.MkdirReq")
	proto.RegisterType((*MkdirResp)(nil), "data.MkdirResp")
	proto.RegisterType((*RmdirReq)(nil), "data.RmdirReq")
	proto.RegisterType((*RmdirResp)(nil), "data.RmdirResp")
	proto.RegisterType((*StatfsReq)(nil), "data.StatfsReq")
	proto.RegisterType((*StatfsResp)(nil), "data.StatfsResp")
	proto.RegisterType((*ReaddirReq)(nil), "data.ReaddirReq")
	proto.RegisterType((*ReaddirResp)(nil), "data.ReaddirResp")
	proto.RegisterType((*LookupReq)(nil), "data.LookupReq")
	proto.RegisterType((*LookupResp)(nil), "data.LookupResp")
	proto.RegisterType((*SetattrReq)(nil), "data.SetattrReq")
	proto.RegisterType((*SetattrResp)(nil), "data.SetattrResp")
	proto.RegisterType((*AccessReq)(nil), "data.AccessReq")
	proto.RegisterType((*AccessResp)(nil), "data.AccessResp")
	proto.RegisterType((*CloseReq)(nil), "data.CloseReq")
	proto.RegisterType((*CloseResp)(nil), "data.CloseResp")
	proto.RegisterType((*ReadReq)(nil), "data.ReadReq")
	proto.RegisterType((*Frame)(nil), "data.Frame")
	proto.RegisterType((*ReadResp)(nil), "data.ReadResp")
	proto.RegisterType((*WriteReq)(nil), "data.WriteReq")
	proto.RegisterType((*WriteResp)(nil), "data.WriteResp")
	proto.RegisterType((*FlushReq)(nil), "data.FlushReq")
	proto.RegisterType((*FlushResp)(nil), "data.FlushResp")
	proto.RegisterType((*FsyncReq)(nil), "data.FsyncReq")
	proto.RegisterType((*FsyncResp)(nil), "data.FsyncResp")
	proto.RegisterType((*BatchCommandsRequest)(nil), "data.BatchCommandsRequest")
	proto.RegisterType((*BatchCommandsRequest_Request)(nil), "data.BatchCommandsRequest.Request")
	proto.RegisterType((*BatchCommandsResponse)(nil), "data.BatchCommandsResponse")
	proto.RegisterType((*BatchCommandsResponse_Response)(nil), "data.BatchCommandsResponse.Response")
}

func init() { proto.RegisterFile("data.proto", fileDescriptor_871986018790d2fd) }

var fileDescriptor_871986018790d2fd = []byte{
	// 1568 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xdd, 0x6e, 0xdc, 0xc4,
	0x17, 0x8f, 0xd7, 0xbb, 0x59, 0xfb, 0x6c, 0x3e, 0xb6, 0xf3, 0x6f, 0xff, 0xda, 0xb8, 0x52, 0x08,
	0x6e, 0xa1, 0x2b, 0x15, 0x22, 0x9a, 0x16, 0xb8, 0xe1, 0x43, 0x24, 0x6d, 0xba, 0x15, 0x09, 0x95,
	0x26, 0x54, 0x45, 0x08, 0x29, 0x38, 0xeb, 0x59, 0x6a, 0xc5, 0x6b, 0x2f, 0xb6, 0xd3, 0xaa, 0xe5,
	0x09, 0xb8, 0x42, 0xdc, 0x20, 0x2e, 0x78, 0x09, 0x78, 0x0a, 0x2e, 0x79, 0x00, 0x2e, 0x50, 0x79,
	0x0f, 0x84, 0xce, 0x99, 0x19, 0x7b, 0xed, 0x6c, 0xb6, 0x49, 0xb7, 0xe4, 0xca, 0xf3, 0x71, 0xe6,
	0xcc, 0x6f, 0xce, 0xef, 0xcc, 0x39, 0x67, 0x0c, 0xe0, 0x7b, 0x99, 0xb7, 0x3e, 0x4a, 0xe2, 0x2c,
	0x66, 0x75, 0x6c, 0x3b, 0x8b, 0x22, 0x49, 0xe2, 0x64, 0x74, 0x20, 0x07, 0xdd, 0x5f, 0x0c, 0xb0,
	0x6e, 0x07, 0xc9, 0x9d, 0x28, 0x4b, 0x9e, 0x32, 0x06, 0xf5, 0x61, 0xec, 0x8b, 0x8e, 0xb1, 0x66,
	0x74, 0x17, 0x39, 0xb5, 0x71, 0x2c, 0xf2, 0x86, 0xa2, 0x53, 0x5b, 0x33, 0xba, 0x36, 0xa7, 0x36,
	0x5b, 0x82, 0x5a, 0xfa, 0xac, 0x63, 0xae, 0x19, 0xdd, 0x3a, 0xaf, 0xa5, 0xcf, 0xd8, 0x25, 0x98,
	0x0f, 0xd2, 0x7d, 0x3f, 0x48, 0x3a, 0xf5, 0x35, 0xa3, 0x6b, 0xf1, 0x46, 0x90, 0xde, 0x0e, 0x12,
	0xb6, 0x02, 0xd6, 0x30, 0xf6, 0xf7, 0xb3, 0x60, 0x28, 0x3a, 0x0d, 0x12, 0x6e, 0x0e, 0x63, 0xff,
	0xf3, 0x60, 0x28, 0xd8, 0x45, 0x68, 0x44, 0x61, 0x10, 0x1d, 0x76, 0xe6, 0x69, 0x2b, 0xd9, 0x61,
	0x6d, 0x30, 0x83, 0x28, 0xee, 0x34, 0x49, 0x16, 0x9b, 0xee, 0x0e, 0xc0, 0x76, 0x10, 0x8a, 0x9e,
	0x17, 0xf9, 0x21, 0xad, 0xca, 0xe2, 0x43, 0x11, 0x11, 0x40, 0x9b, 0xcb, 0xce, 0x44, 0x84, 0x17,
	0xa1, 0x31, 0x08, 0xbd, 0x6f, 0x52, 0x02, 0xb9, 0xc8, 0x65, 0xc7, 0xfd, 0x00, 0x9a, 0xf7, 0x47,
	0x22, 0xe2, 0xe2, 0x5b, 0x76, 0x03, 0x5a, 0x83, 0x20, 0x14, 0xfb, 0x8f, 0x48, 0x33, 0x29, 0x6c,
	0x6d, 0xb4, 0xd7, 0xc9, 0x5c, 0xc5, 0x8e, 0x1c, 0x06, 0x79, 0xdb, 0xdd, 0x06, 0x4b, 0xae, 0x4e,
	0x47, 0xa8, 0x5f, 0x24, 0x49, 0x14, 0xd3, 0x42, 0x93, 0xcb, 0x0e, 0xbb, 0x4a, 0xa3, 0x71, 0x42,
	0x50, 0x5a, 0x1b, 0x4b, 0xeb, 0xda, 0xd6, 0x77, 0xf0, 0xcb, 0xe5, 0xa4, 0xcb, 0xc1, 0xde, 0x4a,
	0x84, 0x97, 0x89, 0x97, 0xc3, 0x91, 0xb3, 0x54, 0x2b, 0x58, 0x72, 0x23, 0x00, 0xad, 0x73, 0x2a,
	0x3a, 0xa4, 0x39, 0x47, 0x47, 0x9b, 0x68, 0xf2, 0xb9, 0x9c, 0x2c, 0xce, 0x60, 0x4e, 0x3b, 0xc3,
	0x77, 0xb0, 0xb0, 0xed, 0x85, 0x61, 0xdc, 0x7f, 0xf9, 0x63, 0xb4, 0xc1, 0x8c, 0x07, 0x03, 0x02,
	0x53, 0xe7, 0xd8, 0xc4, 0x83, 0xa5, 0xc1, 0x33, 0xa1, 0x1c, 0x8b, 0xda, 0xf9, 0x61, 0xeb, 0x63,
	0x87, 0xfd, 0x14, 0x16, 0xc7, 0x36, 0x9f, 0x91, 0x8d, 0x77, 0xc1, 0x7e, 0x40, 0xde, 0x87, 0xc7,
	0x38, 0xb5, 0x83, 0xb9, 0x3d, 0x00, 0xbd, 0x6c, 0x46, 0x00, 0x0f, 0xa0, 0xb9, 0x33, 0x75, 0xfb,
	0x15, 0xb0, 0xe2, 0xd0, 0xdf, 0x1f, 0x83, 0xd0, 0x8c, 0x43, 0xff, 0x33, 0x74, 0xf3, 0x15, 0xb0,
	0x22, 0xf1, 0x44, 0x4e, 0x99, 0x72, 0x2a, 0x12, 0x4f, 0x70, 0x0a, 0xbd, 0x75, 0xe7, 0x55, 0xc0,
	0xfb, 0x02, 0x60, 0xef, 0xe9, 0x30, 0xfc, 0x0f, 0x10, 0xc6, 0xd0, 0xca, 0x35, 0x9f, 0x8b, 0xd3,
	0xbe, 0x0f, 0x2d, 0x2e, 0x3c, 0xff, 0xec, 0x64, 0x7f, 0x05, 0x0b, 0xc5, 0xc2, 0x13, 0xa1, 0xb6,
	0xc1, 0x3c, 0x38, 0x92, 0x0e, 0xbd, 0xc0, 0xb1, 0x79, 0x4a, 0x58, 0x0f, 0xc1, 0xe6, 0x02, 0xf7,
	0x79, 0xd5, 0x06, 0xee, 0x01, 0x68, 0xc5, 0x33, 0x3a, 0xc1, 0x97, 0x60, 0xed, 0x1e, 0x46, 0xb1,
	0x7f, 0x26, 0xb3, 0xe5, 0x77, 0xd7, 0x1c, 0x4b, 0x27, 0x6d, 0x30, 0x7d, 0xf1, 0x58, 0x5d, 0x67,
	0x6c, 0xba, 0x77, 0xc1, 0x56, 0xba, 0x67, 0x73, 0x02, 0xb7, 0x87, 0x20, 0xfd, 0x20, 0x99, 0x19,
	0xa4, 0x84, 0x44, 0x9a, 0x66, 0x84, 0x74, 0x0b, 0x2c, 0x3e, 0x3c, 0x2b, 0x24, 0xf7, 0x75, 0xb0,
	0xd5, 0xaa, 0x93, 0xb6, 0xc7, 0xa8, 0xb5, 0x97, 0x79, 0xd9, 0x20, 0x3d, 0x9b, 0xe6, 0x3f, 0x0d,
	0x00, 0xbd, 0xee, 0xc4, 0xa3, 0xfd, 0x1f, 0xe6, 0x0f, 0xc2, 0xb8, 0x7f, 0x98, 0xaa, 0xd8, 0xac,
	0x7a, 0x28, 0x7d, 0x30, 0x48, 0x84, 0x8e, 0xcf, 0xb2, 0x43, 0xd2, 0xde, 0x63, 0x2f, 0x08, 0x89,
	0x53, 0x94, 0xa6, 0x1e, 0x65, 0xe0, 0x20, 0x14, 0xa9, 0xca, 0xfc, 0xb2, 0x43, 0xa3, 0xa4, 0x63,
	0x5e, 0x8d, 0x92, 0x0e, 0xd4, 0x4c, 0x91, 0xbf, 0x29, 0xb3, 0x35, 0x75, 0x58, 0x07, 0x9a, 0x08,
	0x3a, 0x14, 0x51, 0xc7, 0xa2, 0x71, 0xdd, 0xc5, 0x3d, 0x07, 0x09, 0x2d, 0xb0, 0x69, 0x42, 0xf5,
	0xdc, 0xf7, 0xd0, 0xe1, 0x3d, 0xff, 0xcc, 0x06, 0xdf, 0x95, 0x81, 0x41, 0x9b, 0xbc, 0x0b, 0x4d,
	0xa4, 0x2f, 0x10, 0x69, 0xc7, 0x58, 0x33, 0x27, 0xb0, 0xab, 0xa7, 0x0b, 0x03, 0xd6, 0x2a, 0xe4,
	0xec, 0xc4, 0xf1, 0xe1, 0xd1, 0xe8, 0xcc, 0x29, 0x45, 0x2f, 0x9b, 0xd1, 0xed, 0x7e, 0x45, 0x9a,
	0x45, 0xe6, 0x65, 0xd9, 0x14, 0x43, 0x54, 0x52, 0x76, 0xed, 0x14, 0x29, 0x3b, 0xdf, 0xdd, 0x9c,
	0x16, 0x8c, 0x57, 0xc0, 0x4a, 0x45, 0xb6, 0x9f, 0xa7, 0x6d, 0x8b, 0x37, 0x53, 0x91, 0xed, 0xe2,
	0xed, 0x57, 0x53, 0x44, 0x5d, 0x23, 0x9f, 0xda, 0x43, 0xee, 0x30, 0x1b, 0x68, 0xc8, 0xe7, 0x92,
	0x0d, 0xee, 0x81, 0xfd, 0x49, 0xbf, 0x2f, 0xd2, 0x74, 0xf6, 0x78, 0xd1, 0x03, 0xd0, 0xaa, 0x5e,
	0x1c, 0x68, 0xa7, 0x82, 0xfa, 0x10, 0xac, 0xad, 0x30, 0x4e, 0x27, 0xd5, 0x54, 0xe6, 0x29, 0x4a,
	0xd4, 0xbb, 0x60, 0xab, 0xe5, 0x33, 0x06, 0xfc, 0xaf, 0xa1, 0x89, 0x37, 0x62, 0xf6, 0xd2, 0xce,
	0x94, 0xa5, 0x5d, 0x1b, 0x4c, 0xbc, 0xc7, 0xa6, 0x1c, 0x09, 0x45, 0xe4, 0x7e, 0x0c, 0x8d, 0xed,
	0x04, 0x0d, 0xaa, 0x84, 0x8d, 0xa2, 0x0e, 0x54, 0xc2, 0xaa, 0x32, 0x0c, 0x25, 0x11, 0xb8, 0x1f,
	0xad, 0x5f, 0xe0, 0xd4, 0x76, 0x7f, 0x34, 0xc0, 0x92, 0x18, 0xd3, 0x91, 0xce, 0xbd, 0x46, 0x91,
	0x7b, 0xaf, 0x60, 0x8c, 0xf0, 0x86, 0x02, 0xa3, 0x18, 0xde, 0xe1, 0x96, 0x42, 0x8c, 0x63, 0x5c,
	0x4d, 0x91, 0xde, 0x38, 0x92, 0xb6, 0xb5, 0x38, 0xb5, 0x0b, 0xb3, 0xd5, 0x27, 0x9a, 0xad, 0x31,
	0xcd, 0x6c, 0x1e, 0x58, 0x0f, 0x93, 0x60, 0x96, 0x92, 0xb8, 0x52, 0x41, 0x28, 0xe3, 0x98, 0xb9,
	0x25, 0x5d, 0x0f, 0x6c, 0xb5, 0x45, 0x3a, 0xc2, 0x10, 0xf9, 0x24, 0x09, 0xb2, 0x4c, 0x39, 0xae,
	0xc9, 0x75, 0x77, 0x72, 0x64, 0x3a, 0xbd, 0x13, 0x6e, 0x87, 0x47, 0xe9, 0xa3, 0x97, 0x7c, 0x27,
	0x0d, 0xc1, 0x56, 0xcb, 0xcf, 0xe5, 0x1e, 0x23, 0xda, 0xf4, 0x69, 0xd4, 0x9f, 0x01, 0xad, 0x5c,
	0x7e, 0x2e, 0x68, 0xbf, 0x37, 0xe1, 0xe2, 0xa6, 0x97, 0xf5, 0x1f, 0x6d, 0xc5, 0xc3, 0xa1, 0x17,
	0xf9, 0x18, 0x7d, 0x8e, 0x44, 0x9a, 0xb1, 0x8f, 0xc0, 0x4a, 0x64, 0x53, 0x67, 0x1d, 0x57, 0xee,
	0x33, 0x49, 0x7a, 0x5d, 0x7d, 0x79, 0xbe, 0x86, 0xbd, 0x06, 0x2d, 0xd5, 0xde, 0x0f, 0x7c, 0xe9,
	0xf4, 0x75, 0x0e, 0x6a, 0xe8, 0x9e, 0x9f, 0x3a, 0x3f, 0xd4, 0xf0, 0x4e, 0xcb, 0xcd, 0xae, 0x40,
	0x3d, 0x11, 0x9e, 0xaf, 0x0c, 0xb4, 0x28, 0x37, 0x52, 0x17, 0xbe, 0x37, 0xc7, 0x69, 0x92, 0xbd,
	0x09, 0x0d, 0xf4, 0x26, 0x51, 0x3e, 0xb6, 0xf6, 0xef, 0xde, 0x1c, 0x97, 0xd3, 0x28, 0x37, 0x40,
	0xbe, 0xcb, 0x59, 0x41, 0x7b, 0x10, 0xca, 0xd1, 0x34, 0xc9, 0xa1, 0xa5, 0xe9, 0x62, 0x15, 0x72,
	0x8a, 0x3b, 0x92, 0xc3, 0x36, 0x7b, 0x0b, 0x30, 0x29, 0x60, 0x26, 0x50, 0x97, 0x4d, 0x11, 0x58,
	0x64, 0xb4, 0xde, 0x1c, 0xd7, 0x22, 0x6c, 0x03, 0xec, 0x81, 0x7e, 0x0c, 0x52, 0x55, 0xd1, 0xda,
	0x60, 0x4a, 0xf3, 0xd8, 0x03, 0xb5, 0x37, 0xc7, 0x0b, 0xb1, 0xcd, 0x06, 0x98, 0x5b, 0x43, 0xdf,
	0xfd, 0xcd, 0x84, 0x4b, 0x15, 0xeb, 0xa6, 0xa3, 0x38, 0x4a, 0x05, 0xdb, 0x04, 0x3b, 0x51, 0x6d,
	0xcd, 0xc6, 0xd5, 0x89, 0x6c, 0x48, 0x99, 0x75, 0xdd, 0xe0, 0xc5, 0xb2, 0x17, 0x12, 0xc2, 0x2e,
	0x83, 0x1d, 0xc5, 0x98, 0x27, 0x8f, 0xa2, 0x4c, 0x45, 0x20, 0x2b, 0x8a, 0xb3, 0x5d, 0xec, 0x3b,
	0x3f, 0xd5, 0x30, 0xba, 0x29, 0x38, 0x57, 0x4b, 0x74, 0x2d, 0x8d, 0xd3, 0x95, 0x8e, 0x72, 0xbe,
	0xae, 0x95, 0xf9, 0x5a, 0x2e, 0xf1, 0x45, 0x72, 0x8a, 0xb0, 0x6b, 0x65, 0xc2, 0x96, 0x4b, 0x84,
	0x49, 0x41, 0xc9, 0xd8, 0xb5, 0x32, 0x63, 0xcb, 0x25, 0xc6, 0x94, 0x20, 0x51, 0xf6, 0x76, 0x95,
	0xb2, 0x0b, 0x15, 0xca, 0x48, 0x38, 0xe7, 0xec, 0xe6, 0x71, 0xce, 0xfe, 0x77, 0x8c, 0x33, 0x5a,
	0x72, 0x8c, 0xb4, 0x8d, 0x7f, 0x9a, 0xf4, 0x18, 0x0b, 0x87, 0x7b, 0x22, 0x79, 0x1c, 0xf4, 0x05,
	0xbb, 0x0e, 0xf3, 0xf2, 0xd7, 0x07, 0x53, 0xf8, 0xf2, 0x9f, 0x2b, 0x4e, 0xbb, 0x3c, 0x90, 0x8e,
	0xd8, 0x1b, 0x50, 0xbf, 0x3f, 0x12, 0x11, 0x53, 0x2e, 0xaf, 0xfe, 0x06, 0x39, 0x4b, 0xe3, 0xdd,
	0x74, 0xc4, 0x6e, 0x81, 0x9d, 0x23, 0x61, 0x13, 0xdc, 0xc9, 0x99, 0x04, 0x17, 0x95, 0x23, 0x29,
	0xac, 0x7c, 0x9f, 0x9c, 0x0a, 0x5f, 0xac, 0x0b, 0x0d, 0x22, 0x85, 0x55, 0x6e, 0x94, 0x53, 0x65,
	0x0c, 0x25, 0x89, 0x15, 0x56, 0xb9, 0x53, 0x4e, 0x95, 0x32, 0x34, 0x82, 0xfc, 0x1d, 0xa1, 0x8d,
	0x90, 0xff, 0xd3, 0xd0, 0x46, 0x18, 0xfb, 0x5b, 0xb1, 0x2e, 0x93, 0xbb, 0x1f, 0x24, 0xac, 0x5d,
	0x60, 0x93, 0x55, 0xb3, 0x73, 0xa1, 0x32, 0x22, 0x95, 0xcb, 0xc2, 0x54, 0x2b, 0xcf, 0xab, 0x5b,
	0xad, 0x7c, 0xac, 0x6e, 0xed, 0x42, 0x83, 0x4a, 0x10, 0x8d, 0x59, 0x97, 0x33, 0x1a, 0x73, 0x51,
	0x9f, 0xe0, 0xe9, 0xc8, 0x7b, 0x2a, 0x91, 0xc0, 0xa9, 0xfa, 0x19, 0x1a, 0x76, 0x07, 0xcf, 0xa6,
	0x0c, 0xab, 0x7e, 0x97, 0x68, 0xc3, 0xee, 0x8c, 0x9d, 0x4b, 0xfd, 0x50, 0xd0, 0xe7, 0x2a, 0xfe,
	0x5c, 0xe8, 0x73, 0x8d, 0xff, 0x71, 0xb8, 0x21, 0x0b, 0x08, 0x5a, 0x30, 0x76, 0x6c, 0xbd, 0x82,
	0x55, 0x87, 0xa4, 0x29, 0xe4, 0x93, 0x5a, 0x9b, 0x22, 0x7f, 0xb9, 0x3b, 0xed, 0xf2, 0x80, 0x3c,
	0x20, 0xbd, 0x6c, 0xf5, 0x01, 0xf5, 0x13, 0x5a, 0x1f, 0xb0, 0x78, 0xf6, 0x92, 0x24, 0xf2, 0x91,
	0x4b, 0x2a, 0x36, 0x96, 0x4b, 0x7d, 0x29, 0x49, 0x6f, 0x43, 0x2d, 0xa9, 0x9f, 0x97, 0x5a, 0xb2,
	0x78, 0x38, 0x5e, 0x87, 0x79, 0xf9, 0xd4, 0xd3, 0x50, 0xf3, 0x07, 0xa3, 0x86, 0x3a, 0xf6, 0x12,
	0x44, 0xd3, 0xa9, 0xcb, 0x79, 0x2c, 0xda, 0x3a, 0xc7, 0x2f, 0x33, 0x2a, 0x97, 0x15, 0xaf, 0x56,
	0x9e, 0x97, 0xd2, 0x5a, 0xf9, 0x58, 0x41, 0xbc, 0x03, 0x8b, 0xa5, 0xb0, 0xc9, 0x9c, 0x93, 0x33,
	0x9b, 0x73, 0x79, 0x4a, 0x9c, 0xed, 0x1a, 0xef, 0x18, 0x9b, 0xed, 0xdf, 0x9f, 0xaf, 0x1a, 0x7f,
	0x3c, 0x5f, 0x35, 0xfe, 0x7a, 0xbe, 0x6a, 0xfc, 0xfc, 0xf7, 0xea, 0xdc, 0xc1, 0x3c, 0xfd, 0xca,
	0xbe, 0xf9, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7b, 0xbd, 0x8c, 0x3e, 0xed, 0x16, 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

// RealmServiceClient is the client API for RealmService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RealmServiceClient interface {
	Create(ctx context.Context, in *CreateReq, opts ...grpc.CallOption) (*CreateResp, error)
	Open(ctx context.Context, in *OpenReq, opts ...grpc.CallOption) (*OpenResp, error)
	Fallocate(ctx context.Context, in *FallocateReq, opts ...grpc.CallOption) (*FallocateResp, error)
	Read(ctx context.Context, in *ReadReq, opts ...grpc.CallOption) (*ReadResp, error)
	Write(ctx context.Context, in *WriteReq, opts ...grpc.CallOption) (*WriteResp, error)
	Flush(ctx context.Context, in *FlushReq, opts ...grpc.CallOption) (*FlushResp, error)
	Unlink(ctx context.Context, in *UnlinkReq, opts ...grpc.CallOption) (*UnlinkResp, error)
	Readdir(ctx context.Context, in *ReaddirReq, opts ...grpc.CallOption) (*ReaddirResp, error)
	Lookup(ctx context.Context, in *LookupReq, opts ...grpc.CallOption) (*LookupResp, error)
	Close(ctx context.Context, in *CloseReq, opts ...grpc.CallOption) (*CloseResp, error)
	Fsync(ctx context.Context, in *FsyncReq, opts ...grpc.CallOption) (*FsyncResp, error)
	Link(ctx context.Context, in *LinkReq, opts ...grpc.CallOption) (*LinkResp, error)
	Symlink(ctx context.Context, in *SymlinkReq, opts ...grpc.CallOption) (*SymlinkResp, error)
	Readlink(ctx context.Context, in *ReadlinkReq, opts ...grpc.CallOption) (*ReadlinkResp, error)
	Rename(ctx context.Context, in *RenameReq, opts ...grpc.CallOption) (*RenameResp, error)
	Mknod(ctx context.Context, in *MknodReq, opts ...grpc.CallOption) (*MknodResp, error)
	Mkdir(ctx context.Context, in *MkdirReq, opts ...grpc.CallOption) (*MkdirResp, error)
	Rmdir(ctx context.Context, in *RmdirReq, opts ...grpc.CallOption) (*RmdirResp, error)
	Statfs(ctx context.Context, in *StatfsReq, opts ...grpc.CallOption) (*StatfsResp, error)
	Setattr(ctx context.Context, in *SetattrReq, opts ...grpc.CallOption) (*SetattrResp, error)
	Access(ctx context.Context, in *AccessReq, opts ...grpc.CallOption) (*AccessResp, error)
	BatchCommands(ctx context.Context, opts ...grpc.CallOption) (RealmService_BatchCommandsClient, error)
}

type realmServiceClient struct {
	cc *grpc.ClientConn
}

func NewRealmServiceClient(cc *grpc.ClientConn) RealmServiceClient {
	return &realmServiceClient{cc}
}

func (c *realmServiceClient) Create(ctx context.Context, in *CreateReq, opts ...grpc.CallOption) (*CreateResp, error) {
	out := new(CreateResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Create", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Open(ctx context.Context, in *OpenReq, opts ...grpc.CallOption) (*OpenResp, error) {
	out := new(OpenResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Open", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Fallocate(ctx context.Context, in *FallocateReq, opts ...grpc.CallOption) (*FallocateResp, error) {
	out := new(FallocateResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Fallocate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Read(ctx context.Context, in *ReadReq, opts ...grpc.CallOption) (*ReadResp, error) {
	out := new(ReadResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Read", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Write(ctx context.Context, in *WriteReq, opts ...grpc.CallOption) (*WriteResp, error) {
	out := new(WriteResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Write", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Flush(ctx context.Context, in *FlushReq, opts ...grpc.CallOption) (*FlushResp, error) {
	out := new(FlushResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Flush", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Unlink(ctx context.Context, in *UnlinkReq, opts ...grpc.CallOption) (*UnlinkResp, error) {
	out := new(UnlinkResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Unlink", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Readdir(ctx context.Context, in *ReaddirReq, opts ...grpc.CallOption) (*ReaddirResp, error) {
	out := new(ReaddirResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Readdir", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Lookup(ctx context.Context, in *LookupReq, opts ...grpc.CallOption) (*LookupResp, error) {
	out := new(LookupResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Lookup", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Close(ctx context.Context, in *CloseReq, opts ...grpc.CallOption) (*CloseResp, error) {
	out := new(CloseResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Close", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Fsync(ctx context.Context, in *FsyncReq, opts ...grpc.CallOption) (*FsyncResp, error) {
	out := new(FsyncResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Fsync", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Link(ctx context.Context, in *LinkReq, opts ...grpc.CallOption) (*LinkResp, error) {
	out := new(LinkResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Link", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Symlink(ctx context.Context, in *SymlinkReq, opts ...grpc.CallOption) (*SymlinkResp, error) {
	out := new(SymlinkResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Symlink", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Readlink(ctx context.Context, in *ReadlinkReq, opts ...grpc.CallOption) (*ReadlinkResp, error) {
	out := new(ReadlinkResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Readlink", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Rename(ctx context.Context, in *RenameReq, opts ...grpc.CallOption) (*RenameResp, error) {
	out := new(RenameResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Rename", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Mknod(ctx context.Context, in *MknodReq, opts ...grpc.CallOption) (*MknodResp, error) {
	out := new(MknodResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Mknod", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Mkdir(ctx context.Context, in *MkdirReq, opts ...grpc.CallOption) (*MkdirResp, error) {
	out := new(MkdirResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Mkdir", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Rmdir(ctx context.Context, in *RmdirReq, opts ...grpc.CallOption) (*RmdirResp, error) {
	out := new(RmdirResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Rmdir", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Statfs(ctx context.Context, in *StatfsReq, opts ...grpc.CallOption) (*StatfsResp, error) {
	out := new(StatfsResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Statfs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Setattr(ctx context.Context, in *SetattrReq, opts ...grpc.CallOption) (*SetattrResp, error) {
	out := new(SetattrResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Setattr", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) Access(ctx context.Context, in *AccessReq, opts ...grpc.CallOption) (*AccessResp, error) {
	out := new(AccessResp)
	err := c.cc.Invoke(ctx, "/data.RealmService/Access", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmServiceClient) BatchCommands(ctx context.Context, opts ...grpc.CallOption) (RealmService_BatchCommandsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RealmService_serviceDesc.Streams[0], "/data.RealmService/BatchCommands", opts...)
	if err != nil {
		return nil, err
	}
	x := &realmServiceBatchCommandsClient{stream}
	return x, nil
}

type RealmService_BatchCommandsClient interface {
	Send(*BatchCommandsRequest) error
	Recv() (*BatchCommandsResponse, error)
	grpc.ClientStream
}

type realmServiceBatchCommandsClient struct {
	grpc.ClientStream
}

func (x *realmServiceBatchCommandsClient) Send(m *BatchCommandsRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *realmServiceBatchCommandsClient) Recv() (*BatchCommandsResponse, error) {
	m := new(BatchCommandsResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// RealmServiceServer is the server API for RealmService service.
type RealmServiceServer interface {
	Create(context.Context, *CreateReq) (*CreateResp, error)
	Open(context.Context, *OpenReq) (*OpenResp, error)
	Fallocate(context.Context, *FallocateReq) (*FallocateResp, error)
	Read(context.Context, *ReadReq) (*ReadResp, error)
	Write(context.Context, *WriteReq) (*WriteResp, error)
	Flush(context.Context, *FlushReq) (*FlushResp, error)
	Unlink(context.Context, *UnlinkReq) (*UnlinkResp, error)
	Readdir(context.Context, *ReaddirReq) (*ReaddirResp, error)
	Lookup(context.Context, *LookupReq) (*LookupResp, error)
	Close(context.Context, *CloseReq) (*CloseResp, error)
	Fsync(context.Context, *FsyncReq) (*FsyncResp, error)
	Link(context.Context, *LinkReq) (*LinkResp, error)
	Symlink(context.Context, *SymlinkReq) (*SymlinkResp, error)
	Readlink(context.Context, *ReadlinkReq) (*ReadlinkResp, error)
	Rename(context.Context, *RenameReq) (*RenameResp, error)
	Mknod(context.Context, *MknodReq) (*MknodResp, error)
	Mkdir(context.Context, *MkdirReq) (*MkdirResp, error)
	Rmdir(context.Context, *RmdirReq) (*RmdirResp, error)
	Statfs(context.Context, *StatfsReq) (*StatfsResp, error)
	Setattr(context.Context, *SetattrReq) (*SetattrResp, error)
	Access(context.Context, *AccessReq) (*AccessResp, error)
	BatchCommands(RealmService_BatchCommandsServer) error
}

// UnimplementedRealmServiceServer can be embedded to have forward compatible implementations.
type UnimplementedRealmServiceServer struct {
}

func (*UnimplementedRealmServiceServer) Create(ctx context.Context, req *CreateReq) (*CreateResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Create not implemented")
}
func (*UnimplementedRealmServiceServer) Open(ctx context.Context, req *OpenReq) (*OpenResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Open not implemented")
}
func (*UnimplementedRealmServiceServer) Fallocate(ctx context.Context, req *FallocateReq) (*FallocateResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Fallocate not implemented")
}
func (*UnimplementedRealmServiceServer) Read(ctx context.Context, req *ReadReq) (*ReadResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Read not implemented")
}
func (*UnimplementedRealmServiceServer) Write(ctx context.Context, req *WriteReq) (*WriteResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Write not implemented")
}
func (*UnimplementedRealmServiceServer) Flush(ctx context.Context, req *FlushReq) (*FlushResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Flush not implemented")
}
func (*UnimplementedRealmServiceServer) Unlink(ctx context.Context, req *UnlinkReq) (*UnlinkResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Unlink not implemented")
}
func (*UnimplementedRealmServiceServer) Readdir(ctx context.Context, req *ReaddirReq) (*ReaddirResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Readdir not implemented")
}
func (*UnimplementedRealmServiceServer) Lookup(ctx context.Context, req *LookupReq) (*LookupResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Lookup not implemented")
}
func (*UnimplementedRealmServiceServer) Close(ctx context.Context, req *CloseReq) (*CloseResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Close not implemented")
}
func (*UnimplementedRealmServiceServer) Fsync(ctx context.Context, req *FsyncReq) (*FsyncResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Fsync not implemented")
}
func (*UnimplementedRealmServiceServer) Link(ctx context.Context, req *LinkReq) (*LinkResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Link not implemented")
}
func (*UnimplementedRealmServiceServer) Symlink(ctx context.Context, req *SymlinkReq) (*SymlinkResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Symlink not implemented")
}
func (*UnimplementedRealmServiceServer) Readlink(ctx context.Context, req *ReadlinkReq) (*ReadlinkResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Readlink not implemented")
}
func (*UnimplementedRealmServiceServer) Rename(ctx context.Context, req *RenameReq) (*RenameResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Rename not implemented")
}
func (*UnimplementedRealmServiceServer) Mknod(ctx context.Context, req *MknodReq) (*MknodResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Mknod not implemented")
}
func (*UnimplementedRealmServiceServer) Mkdir(ctx context.Context, req *MkdirReq) (*MkdirResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Mkdir not implemented")
}
func (*UnimplementedRealmServiceServer) Rmdir(ctx context.Context, req *RmdirReq) (*RmdirResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Rmdir not implemented")
}
func (*UnimplementedRealmServiceServer) Statfs(ctx context.Context, req *StatfsReq) (*StatfsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Statfs not implemented")
}
func (*UnimplementedRealmServiceServer) Setattr(ctx context.Context, req *SetattrReq) (*SetattrResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Setattr not implemented")
}
func (*UnimplementedRealmServiceServer) Access(ctx context.Context, req *AccessReq) (*AccessResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Access not implemented")
}
func (*UnimplementedRealmServiceServer) BatchCommands(srv RealmService_BatchCommandsServer) error {
	return status.Errorf(codes.Unimplemented, "method BatchCommands not implemented")
}

func RegisterRealmServiceServer(s *grpc.Server, srv RealmServiceServer) {
	s.RegisterService(&_RealmService_serviceDesc, srv)
}

func _RealmService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Create(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Create",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Create(ctx, req.(*CreateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Open_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(OpenReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Open(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Open",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Open(ctx, req.(*OpenReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Fallocate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FallocateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Fallocate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Fallocate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Fallocate(ctx, req.(*FallocateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Read_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReadReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Read(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Read",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Read(ctx, req.(*ReadReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Write_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WriteReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Write(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Write",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Write(ctx, req.(*WriteReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Flush_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FlushReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Flush(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Flush",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Flush(ctx, req.(*FlushReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Unlink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnlinkReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Unlink(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Unlink",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Unlink(ctx, req.(*UnlinkReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Readdir_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReaddirReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Readdir(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Readdir",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Readdir(ctx, req.(*ReaddirReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Lookup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LookupReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Lookup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Lookup",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Lookup(ctx, req.(*LookupReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Close_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CloseReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Close(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Close",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Close(ctx, req.(*CloseReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Fsync_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FsyncReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Fsync(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Fsync",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Fsync(ctx, req.(*FsyncReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Link_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LinkReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Link(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Link",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Link(ctx, req.(*LinkReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Symlink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SymlinkReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Symlink(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Symlink",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Symlink(ctx, req.(*SymlinkReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Readlink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReadlinkReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Readlink(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Readlink",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Readlink(ctx, req.(*ReadlinkReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Rename_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RenameReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Rename(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Rename",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Rename(ctx, req.(*RenameReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Mknod_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MknodReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Mknod(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Mknod",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Mknod(ctx, req.(*MknodReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Mkdir_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MkdirReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Mkdir(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Mkdir",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Mkdir(ctx, req.(*MkdirReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Rmdir_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RmdirReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Rmdir(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Rmdir",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Rmdir(ctx, req.(*RmdirReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Statfs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StatfsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Statfs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Statfs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Statfs(ctx, req.(*StatfsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Setattr_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetattrReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Setattr(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Setattr",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Setattr(ctx, req.(*SetattrReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_Access_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccessReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmServiceServer).Access(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/data.RealmService/Access",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmServiceServer).Access(ctx, req.(*AccessReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmService_BatchCommands_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RealmServiceServer).BatchCommands(&realmServiceBatchCommandsServer{stream})
}

type RealmService_BatchCommandsServer interface {
	Send(*BatchCommandsResponse) error
	Recv() (*BatchCommandsRequest, error)
	grpc.ServerStream
}

type realmServiceBatchCommandsServer struct {
	grpc.ServerStream
}

func (x *realmServiceBatchCommandsServer) Send(m *BatchCommandsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *realmServiceBatchCommandsServer) Recv() (*BatchCommandsRequest, error) {
	m := new(BatchCommandsRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _RealmService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "data.RealmService",
	HandlerType: (*RealmServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Create",
			Handler:    _RealmService_Create_Handler,
		},
		{
			MethodName: "Open",
			Handler:    _RealmService_Open_Handler,
		},
		{
			MethodName: "Fallocate",
			Handler:    _RealmService_Fallocate_Handler,
		},
		{
			MethodName: "Read",
			Handler:    _RealmService_Read_Handler,
		},
		{
			MethodName: "Write",
			Handler:    _RealmService_Write_Handler,
		},
		{
			MethodName: "Flush",
			Handler:    _RealmService_Flush_Handler,
		},
		{
			MethodName: "Unlink",
			Handler:    _RealmService_Unlink_Handler,
		},
		{
			MethodName: "Readdir",
			Handler:    _RealmService_Readdir_Handler,
		},
		{
			MethodName: "Lookup",
			Handler:    _RealmService_Lookup_Handler,
		},
		{
			MethodName: "Close",
			Handler:    _RealmService_Close_Handler,
		},
		{
			MethodName: "Fsync",
			Handler:    _RealmService_Fsync_Handler,
		},
		{
			MethodName: "Link",
			Handler:    _RealmService_Link_Handler,
		},
		{
			MethodName: "Symlink",
			Handler:    _RealmService_Symlink_Handler,
		},
		{
			MethodName: "Readlink",
			Handler:    _RealmService_Readlink_Handler,
		},
		{
			MethodName: "Rename",
			Handler:    _RealmService_Rename_Handler,
		},
		{
			MethodName: "Mknod",
			Handler:    _RealmService_Mknod_Handler,
		},
		{
			MethodName: "Mkdir",
			Handler:    _RealmService_Mkdir_Handler,
		},
		{
			MethodName: "Rmdir",
			Handler:    _RealmService_Rmdir_Handler,
		},
		{
			MethodName: "Statfs",
			Handler:    _RealmService_Statfs_Handler,
		},
		{
			MethodName: "Setattr",
			Handler:    _RealmService_Setattr_Handler,
		},
		{
			MethodName: "Access",
			Handler:    _RealmService_Access_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "BatchCommands",
			Handler:       _RealmService_BatchCommands_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "data.proto",
}

func (m *DirEntry) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DirEntry) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DirEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Ino != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Ino))
		i--
		dAtA[i] = 0x38
	}
	if m.Nlink != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Nlink))
		i--
		dAtA[i] = 0x30
	}
	if m.ModTime != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.ModTime))
		i--
		dAtA[i] = 0x28
	}
	if m.IsDir {
		i--
		if m.IsDir {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Sz != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Sz))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintData(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if m.Mode != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *FileHandle) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FileHandle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FileHandle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Flags != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Flags))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintData(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintData(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *OpenReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *OpenReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OpenReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.FileHandle != nil {
		{
			size, err := m.FileHandle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *OpenResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *OpenResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OpenResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *CreateReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CreateReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreateReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Mode != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x10
	}
	if m.FileHandle != nil {
		{
			size, err := m.FileHandle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CreateResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CreateResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreateResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Entry != nil {
		{
			size, err := m.Entry.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *FallocateReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FallocateReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FallocateReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Mode != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x20
	}
	if m.Size_ != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Size_))
		i--
		dAtA[i] = 0x18
	}
	if m.Off != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Off))
		i--
		dAtA[i] = 0x10
	}
	if m.FileHandle != nil {
		{
			size, err := m.FileHandle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FallocateResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FallocateResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FallocateResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *UnlinkReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UnlinkReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UnlinkReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintData(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintData(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UnlinkResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UnlinkResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UnlinkResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *LinkReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LinkReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LinkReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.NewName) > 0 {
		i -= len(m.NewName)
		copy(dAtA[i:], m.NewName)
		i = encodeVarintData(dAtA, i, uint64(len(m.NewName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.OldName) > 0 {
		i -= len(m.OldName)
		copy(dAtA[i:], m.OldName)
		i = encodeVarintData(dAtA, i, uint64(len(m.OldName)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintData(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *LinkResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LinkResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LinkResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *SymlinkReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SymlinkReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SymlinkReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.NewName) > 0 {
		i -= len(m.NewName)
		copy(dAtA[i:], m.NewName)
		i = encodeVarintData(dAtA, i, uint64(len(m.NewName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.OldName) > 0 {
		i -= len(m.OldName)
		copy(dAtA[i:], m.OldName)
		i = encodeVarintData(dAtA, i, uint64(len(m.OldName)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintData(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *SymlinkResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SymlinkResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SymlinkResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Entry != nil {
		{
			size, err := m.Entry.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ReadlinkReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ReadlinkReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ReadlinkReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintData(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintData(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ReadlinkResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ReadlinkResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ReadlinkResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Buf) > 0 {
		i -= len(m.Buf)
		copy(dAtA[i:], m.Buf)
		i = encodeVarintData(dAtA, i, uint64(len(m.Buf)))
		i--
		dAtA[i] = 0x12
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RenameReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RenameReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RenameReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.NewName) > 0 {
		i -= len(m.NewName)
		copy(dAtA[i:], m.NewName)
		i = encodeVarintData(dAtA, i, uint64(len(m.NewName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.OldName) > 0 {
		i -= len(m.OldName)
		copy(dAtA[i:], m.OldName)
		i = encodeVarintData(dAtA, i, uint64(len(m.OldName)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintData(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RenameResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RenameResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RenameResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MknodReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MknodReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MknodReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Dev != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Dev))
		i--
		dAtA[i] = 0x20
	}
	if m.Mode != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintData(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintData(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MknodResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MknodResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MknodResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Entry != nil {
		{
			size, err := m.Entry.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MkdirReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MkdirReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MkdirReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Mode != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintData(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintData(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MkdirResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MkdirResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MkdirResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Entry != nil {
		{
			size, err := m.Entry.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RmdirReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RmdirReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RmdirReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintData(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintData(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RmdirResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RmdirResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RmdirResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *StatfsReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StatfsReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StatfsReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintData(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintData(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *StatfsResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StatfsResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StatfsResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Frsize != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Frsize))
		i--
		dAtA[i] = 0x48
	}
	if m.Namelen != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Namelen))
		i--
		dAtA[i] = 0x40
	}
	if m.Bsize != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Bsize))
		i--
		dAtA[i] = 0x38
	}
	if m.Ffree != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Ffree))
		i--
		dAtA[i] = 0x30
	}
	if m.Files != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Files))
		i--
		dAtA[i] = 0x28
	}
	if m.Bavail != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Bavail))
		i--
		dAtA[i] = 0x20
	}
	if m.Bfree != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Bfree))
		i--
		dAtA[i] = 0x18
	}
	if m.Blocks != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Blocks))
		i--
		dAtA[i] = 0x10
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ReaddirReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ReaddirReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ReaddirReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintData(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintData(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ReaddirResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ReaddirResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ReaddirResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Entries) > 0 {
		for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintData(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *LookupReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LookupReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LookupReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintData(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintData(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *LookupResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LookupResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LookupResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Entry != nil {
		{
			size, err := m.Entry.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *SetattrReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SetattrReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SetattrReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.SetSize {
		i--
		if m.SetSize {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.SetMode {
		i--
		if m.SetMode {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Entry != nil {
		{
			size, err := m.Entry.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.FileHandle != nil {
		{
			size, err := m.FileHandle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintData(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *SetattrResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SetattrResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SetattrResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Entry != nil {
		{
			size, err := m.Entry.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *AccessReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AccessReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AccessReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Mode != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintData(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintData(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AccessResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AccessResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AccessResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *CloseReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CloseReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CloseReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.FileHandle != nil {
		{
			size, err := m.FileHandle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}

func (m *CloseResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CloseResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CloseResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ReadReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ReadReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ReadReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Len != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Len))
		i--
		dAtA[i] = 0x18
	}
	if m.Off != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Off))
		i--
		dAtA[i] = 0x10
	}
	if m.FileHandle != nil {
		{
			size, err := m.FileHandle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Frame) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Frame) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Frame) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Data) > 0 {
		i -= len(m.Data)
		copy(dAtA[i:], m.Data)
		i = encodeVarintData(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Len != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Len))
		i--
		dAtA[i] = 0x10
	}
	if m.Off != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Off))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ReadResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ReadResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ReadResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x20
	}
	if m.Done {
		i--
		if m.Done {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Frames) > 0 {
		for iNdEx := len(m.Frames) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Frames[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintData(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Buf) > 0 {
		i -= len(m.Buf)
		copy(dAtA[i:], m.Buf)
		i = encodeVarintData(dAtA, i, uint64(len(m.Buf)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *WriteReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WriteReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WriteReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Off != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Off))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Buf) > 0 {
		i -= len(m.Buf)
		copy(dAtA[i:], m.Buf)
		i = encodeVarintData(dAtA, i, uint64(len(m.Buf)))
		i--
		dAtA[i] = 0x12
	}
	if m.FileHandle != nil {
		{
			size, err := m.FileHandle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *WriteResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WriteResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WriteResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x10
	}
	if m.Written != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Written))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *FlushReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FlushReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FlushReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.FileHandle != nil {
		{
			size, err := m.FileHandle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FlushResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FlushResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FlushResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Entry != nil {
		{
			size, err := m.Entry.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *FsyncReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FsyncReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FsyncReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.FileHandle != nil {
		{
			size, err := m.FileHandle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FsyncResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FsyncResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FsyncResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Entry != nil {
		{
			size, err := m.Entry.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Errno != 0 {
		i = encodeVarintData(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BatchCommandsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BatchCommandsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BatchCommandsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.RequestIds) > 0 {
		dAtA35 := make([]byte, len(m.RequestIds)*10)
		var j34 int
		for _, num := range m.RequestIds {
			for num >= 1<<7 {
				dAtA35[j34] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j34++
			}
			dAtA35[j34] = uint8(num)
			j34++
		}
		i -= j34
		copy(dAtA[i:], dAtA35[:j34])
		i = encodeVarintData(dAtA, i, uint64(j34))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Requests) > 0 {
		for iNdEx := len(m.Requests) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Requests[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintData(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *BatchCommandsRequest_Request) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BatchCommandsRequest_Request) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BatchCommandsRequest_Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Cmd != nil {
		{
			size := m.Cmd.Size()
			i -= size
			if _, err := m.Cmd.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *BatchCommandsRequest_Request_Read) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BatchCommandsRequest_Request_Read) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Read != nil {
		{
			size, err := m.Read.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *BatchCommandsRequest_Request_Write) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BatchCommandsRequest_Request_Write) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Write != nil {
		{
			size, err := m.Write.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *BatchCommandsRequest_Request_Flush) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BatchCommandsRequest_Request_Flush) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Flush != nil {
		{
			size, err := m.Flush.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *BatchCommandsRequest_Request_Fsync) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BatchCommandsRequest_Request_Fsync) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Fsync != nil {
		{
			size, err := m.Fsync.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *BatchCommandsRequest_Request_Setattr) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BatchCommandsRequest_Request_Setattr) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Setattr != nil {
		{
			size, err := m.Setattr.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *BatchCommandsRequest_Request_Fallocate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BatchCommandsRequest_Request_Fallocate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Fallocate != nil {
		{
			size, err := m.Fallocate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *BatchCommandsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BatchCommandsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BatchCommandsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.NotMount {
		i--
		if m.NotMount {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.RequestIds) > 0 {
		dAtA43 := make([]byte, len(m.RequestIds)*10)
		var j42 int
		for _, num := range m.RequestIds {
			for num >= 1<<7 {
				dAtA43[j42] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j42++
			}
			dAtA43[j42] = uint8(num)
			j42++
		}
		i -= j42
		copy(dAtA[i:], dAtA43[:j42])
		i = encodeVarintData(dAtA, i, uint64(j42))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Responses) > 0 {
		for iNdEx := len(m.Responses) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Responses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintData(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *BatchCommandsResponse_Response) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BatchCommandsResponse_Response) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BatchCommandsResponse_Response) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Cmd != nil {
		{
			size := m.Cmd.Size()
			i -= size
			if _, err := m.Cmd.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *BatchCommandsResponse_Response_Read) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BatchCommandsResponse_Response_Read) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Read != nil {
		{
			size, err := m.Read.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *BatchCommandsResponse_Response_Write) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BatchCommandsResponse_Response_Write) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Write != nil {
		{
			size, err := m.Write.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *BatchCommandsResponse_Response_Flush) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BatchCommandsResponse_Response_Flush) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Flush != nil {
		{
			size, err := m.Flush.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *BatchCommandsResponse_Response_Fsync) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BatchCommandsResponse_Response_Fsync) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Fsync != nil {
		{
			size, err := m.Fsync.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *BatchCommandsResponse_Response_Setattr) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BatchCommandsResponse_Response_Setattr) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Setattr != nil {
		{
			size, err := m.Setattr.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *BatchCommandsResponse_Response_Fallocate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BatchCommandsResponse_Response_Fallocate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Fallocate != nil {
		{
			size, err := m.Fallocate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintData(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func encodeVarintData(dAtA []byte, offset int, v uint64) int {
	offset -= sovData(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *DirEntry) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Mode != 0 {
		n += 1 + sovData(uint64(m.Mode))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	if m.Sz != 0 {
		n += 1 + sovData(uint64(m.Sz))
	}
	if m.IsDir {
		n += 2
	}
	if m.ModTime != 0 {
		n += 1 + sovData(uint64(m.ModTime))
	}
	if m.Nlink != 0 {
		n += 1 + sovData(uint64(m.Nlink))
	}
	if m.Ino != 0 {
		n += 1 + sovData(uint64(m.Ino))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *FileHandle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	if m.Flags != 0 {
		n += 1 + sovData(uint64(m.Flags))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OpenReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FileHandle != nil {
		l = m.FileHandle.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OpenResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreateReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FileHandle != nil {
		l = m.FileHandle.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.Mode != 0 {
		n += 1 + sovData(uint64(m.Mode))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreateResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.Entry != nil {
		l = m.Entry.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *FallocateReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FileHandle != nil {
		l = m.FileHandle.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.Off != 0 {
		n += 1 + sovData(uint64(m.Off))
	}
	if m.Size_ != 0 {
		n += 1 + sovData(uint64(m.Size_))
	}
	if m.Mode != 0 {
		n += 1 + sovData(uint64(m.Mode))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *FallocateResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UnlinkReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UnlinkResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LinkReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	l = len(m.OldName)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	l = len(m.NewName)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LinkResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SymlinkReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	l = len(m.OldName)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	l = len(m.NewName)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SymlinkResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.Entry != nil {
		l = m.Entry.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ReadlinkReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ReadlinkResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	l = len(m.Buf)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RenameReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	l = len(m.OldName)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	l = len(m.NewName)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RenameResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MknodReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	if m.Mode != 0 {
		n += 1 + sovData(uint64(m.Mode))
	}
	if m.Dev != 0 {
		n += 1 + sovData(uint64(m.Dev))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MknodResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.Entry != nil {
		l = m.Entry.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MkdirReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	if m.Mode != 0 {
		n += 1 + sovData(uint64(m.Mode))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MkdirResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.Entry != nil {
		l = m.Entry.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RmdirReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RmdirResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StatfsReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StatfsResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.Blocks != 0 {
		n += 1 + sovData(uint64(m.Blocks))
	}
	if m.Bfree != 0 {
		n += 1 + sovData(uint64(m.Bfree))
	}
	if m.Bavail != 0 {
		n += 1 + sovData(uint64(m.Bavail))
	}
	if m.Files != 0 {
		n += 1 + sovData(uint64(m.Files))
	}
	if m.Ffree != 0 {
		n += 1 + sovData(uint64(m.Ffree))
	}
	if m.Bsize != 0 {
		n += 1 + sovData(uint64(m.Bsize))
	}
	if m.Namelen != 0 {
		n += 1 + sovData(uint64(m.Namelen))
	}
	if m.Frsize != 0 {
		n += 1 + sovData(uint64(m.Frsize))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ReaddirReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ReaddirResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Entries) > 0 {
		for _, e := range m.Entries {
			l = e.Size()
			n += 1 + l + sovData(uint64(l))
		}
	}
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LookupReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LookupResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.Entry != nil {
		l = m.Entry.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SetattrReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	if m.FileHandle != nil {
		l = m.FileHandle.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.Entry != nil {
		l = m.Entry.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.SetMode {
		n += 2
	}
	if m.SetSize {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SetattrResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.Entry != nil {
		l = m.Entry.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AccessReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	if m.Mode != 0 {
		n += 1 + sovData(uint64(m.Mode))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AccessResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CloseReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FileHandle != nil {
		l = m.FileHandle.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CloseResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ReadReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FileHandle != nil {
		l = m.FileHandle.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.Off != 0 {
		n += 1 + sovData(uint64(m.Off))
	}
	if m.Len != 0 {
		n += 1 + sovData(uint64(m.Len))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Frame) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Off != 0 {
		n += 1 + sovData(uint64(m.Off))
	}
	if m.Len != 0 {
		n += 1 + sovData(uint64(m.Len))
	}
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ReadResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Buf)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	if len(m.Frames) > 0 {
		for _, e := range m.Frames {
			l = e.Size()
			n += 1 + l + sovData(uint64(l))
		}
	}
	if m.Done {
		n += 2
	}
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *WriteReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FileHandle != nil {
		l = m.FileHandle.Size()
		n += 1 + l + sovData(uint64(l))
	}
	l = len(m.Buf)
	if l > 0 {
		n += 1 + l + sovData(uint64(l))
	}
	if m.Off != 0 {
		n += 1 + sovData(uint64(m.Off))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *WriteResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Written != 0 {
		n += 1 + sovData(uint64(m.Written))
	}
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *FlushReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FileHandle != nil {
		l = m.FileHandle.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *FlushResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.Entry != nil {
		l = m.Entry.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *FsyncReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FileHandle != nil {
		l = m.FileHandle.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *FsyncResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Errno != 0 {
		n += 1 + sovData(uint64(m.Errno))
	}
	if m.Entry != nil {
		l = m.Entry.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BatchCommandsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Requests) > 0 {
		for _, e := range m.Requests {
			l = e.Size()
			n += 1 + l + sovData(uint64(l))
		}
	}
	if len(m.RequestIds) > 0 {
		l = 0
		for _, e := range m.RequestIds {
			l += sovData(uint64(e))
		}
		n += 1 + sovData(uint64(l)) + l
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BatchCommandsRequest_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Cmd != nil {
		n += m.Cmd.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BatchCommandsRequest_Request_Read) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Read != nil {
		l = m.Read.Size()
		n += 1 + l + sovData(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_Write) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Write != nil {
		l = m.Write.Size()
		n += 1 + l + sovData(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_Flush) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Flush != nil {
		l = m.Flush.Size()
		n += 1 + l + sovData(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_Fsync) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Fsync != nil {
		l = m.Fsync.Size()
		n += 1 + l + sovData(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_Setattr) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Setattr != nil {
		l = m.Setattr.Size()
		n += 1 + l + sovData(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_Fallocate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Fallocate != nil {
		l = m.Fallocate.Size()
		n += 1 + l + sovData(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Responses) > 0 {
		for _, e := range m.Responses {
			l = e.Size()
			n += 1 + l + sovData(uint64(l))
		}
	}
	if len(m.RequestIds) > 0 {
		l = 0
		for _, e := range m.RequestIds {
			l += sovData(uint64(e))
		}
		n += 1 + sovData(uint64(l)) + l
	}
	if m.NotMount {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BatchCommandsResponse_Response) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Cmd != nil {
		n += m.Cmd.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BatchCommandsResponse_Response_Read) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Read != nil {
		l = m.Read.Size()
		n += 1 + l + sovData(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_Write) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Write != nil {
		l = m.Write.Size()
		n += 1 + l + sovData(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_Flush) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Flush != nil {
		l = m.Flush.Size()
		n += 1 + l + sovData(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_Fsync) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Fsync != nil {
		l = m.Fsync.Size()
		n += 1 + l + sovData(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_Setattr) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Setattr != nil {
		l = m.Setattr.Size()
		n += 1 + l + sovData(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_Fallocate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Fallocate != nil {
		l = m.Fallocate.Size()
		n += 1 + l + sovData(uint64(l))
	}
	return n
}

func sovData(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozData(x uint64) (n int) {
	return sovData(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *DirEntry) 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 ErrIntOverflowData
			}
			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: DirEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DirEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sz", wireType)
			}
			m.Sz = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sz |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsDir", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsDir = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ModTime", wireType)
			}
			m.ModTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ModTime |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nlink", wireType)
			}
			m.Nlink = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Nlink |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ino", wireType)
			}
			m.Ino = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Ino |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *FileHandle) 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 ErrIntOverflowData
			}
			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: FileHandle: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FileHandle: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Flags", wireType)
			}
			m.Flags = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Flags |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *OpenReq) 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 ErrIntOverflowData
			}
			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: OpenReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OpenReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileHandle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FileHandle == nil {
				m.FileHandle = &FileHandle{}
			}
			if err := m.FileHandle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *OpenResp) 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 ErrIntOverflowData
			}
			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: OpenResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OpenResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *CreateReq) 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 ErrIntOverflowData
			}
			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: CreateReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileHandle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FileHandle == nil {
				m.FileHandle = &FileHandle{}
			}
			if err := m.FileHandle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *CreateResp) 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 ErrIntOverflowData
			}
			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: CreateResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Entry == nil {
				m.Entry = &DirEntry{}
			}
			if err := m.Entry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *FallocateReq) 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 ErrIntOverflowData
			}
			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: FallocateReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FallocateReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileHandle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FileHandle == nil {
				m.FileHandle = &FileHandle{}
			}
			if err := m.FileHandle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Off", wireType)
			}
			m.Off = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Off |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType)
			}
			m.Size_ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Size_ |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *FallocateResp) 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 ErrIntOverflowData
			}
			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: FallocateResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FallocateResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *UnlinkReq) 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 ErrIntOverflowData
			}
			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: UnlinkReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnlinkReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *UnlinkResp) 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 ErrIntOverflowData
			}
			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: UnlinkResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnlinkResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *LinkReq) 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 ErrIntOverflowData
			}
			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: LinkReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LinkReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OldName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OldName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NewName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *LinkResp) 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 ErrIntOverflowData
			}
			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: LinkResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LinkResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *SymlinkReq) 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 ErrIntOverflowData
			}
			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: SymlinkReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SymlinkReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OldName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OldName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NewName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *SymlinkResp) 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 ErrIntOverflowData
			}
			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: SymlinkResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SymlinkResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Entry == nil {
				m.Entry = &DirEntry{}
			}
			if err := m.Entry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *ReadlinkReq) 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 ErrIntOverflowData
			}
			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: ReadlinkReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReadlinkReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *ReadlinkResp) 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 ErrIntOverflowData
			}
			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: ReadlinkResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReadlinkResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Buf", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Buf = append(m.Buf[:0], dAtA[iNdEx:postIndex]...)
			if m.Buf == nil {
				m.Buf = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *RenameReq) 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 ErrIntOverflowData
			}
			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: RenameReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RenameReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OldName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OldName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NewName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *RenameResp) 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 ErrIntOverflowData
			}
			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: RenameResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RenameResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *MknodReq) 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 ErrIntOverflowData
			}
			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: MknodReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MknodReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dev", wireType)
			}
			m.Dev = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Dev |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *MknodResp) 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 ErrIntOverflowData
			}
			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: MknodResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MknodResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Entry == nil {
				m.Entry = &DirEntry{}
			}
			if err := m.Entry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *MkdirReq) 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 ErrIntOverflowData
			}
			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: MkdirReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MkdirReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *MkdirResp) 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 ErrIntOverflowData
			}
			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: MkdirResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MkdirResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Entry == nil {
				m.Entry = &DirEntry{}
			}
			if err := m.Entry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *RmdirReq) 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 ErrIntOverflowData
			}
			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: RmdirReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RmdirReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *RmdirResp) 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 ErrIntOverflowData
			}
			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: RmdirResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RmdirResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *StatfsReq) 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 ErrIntOverflowData
			}
			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: StatfsReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StatfsReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *StatfsResp) 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 ErrIntOverflowData
			}
			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: StatfsResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StatfsResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Blocks", wireType)
			}
			m.Blocks = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Blocks |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bfree", wireType)
			}
			m.Bfree = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Bfree |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bavail", wireType)
			}
			m.Bavail = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Bavail |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Files", wireType)
			}
			m.Files = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Files |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ffree", wireType)
			}
			m.Ffree = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Ffree |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bsize", wireType)
			}
			m.Bsize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Bsize |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namelen", wireType)
			}
			m.Namelen = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Namelen |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Frsize", wireType)
			}
			m.Frsize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Frsize |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *ReaddirReq) 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 ErrIntOverflowData
			}
			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: ReaddirReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReaddirReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *ReaddirResp) 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 ErrIntOverflowData
			}
			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: ReaddirResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReaddirResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Entries = append(m.Entries, &DirEntry{})
			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *LookupReq) 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 ErrIntOverflowData
			}
			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: LookupReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LookupReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *LookupResp) 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 ErrIntOverflowData
			}
			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: LookupResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LookupResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Entry == nil {
				m.Entry = &DirEntry{}
			}
			if err := m.Entry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *SetattrReq) 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 ErrIntOverflowData
			}
			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: SetattrReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetattrReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileHandle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FileHandle == nil {
				m.FileHandle = &FileHandle{}
			}
			if err := m.FileHandle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Entry == nil {
				m.Entry = &DirEntry{}
			}
			if err := m.Entry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SetMode", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SetMode = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SetSize", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SetSize = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *SetattrResp) 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 ErrIntOverflowData
			}
			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: SetattrResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetattrResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Entry == nil {
				m.Entry = &DirEntry{}
			}
			if err := m.Entry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *AccessReq) 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 ErrIntOverflowData
			}
			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: AccessReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AccessReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *AccessResp) 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 ErrIntOverflowData
			}
			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: AccessResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AccessResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *CloseReq) 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 ErrIntOverflowData
			}
			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: CloseReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloseReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileHandle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FileHandle == nil {
				m.FileHandle = &FileHandle{}
			}
			if err := m.FileHandle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *CloseResp) 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 ErrIntOverflowData
			}
			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: CloseResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloseResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *ReadReq) 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 ErrIntOverflowData
			}
			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: ReadReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReadReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileHandle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FileHandle == nil {
				m.FileHandle = &FileHandle{}
			}
			if err := m.FileHandle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Off", wireType)
			}
			m.Off = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Off |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Len", wireType)
			}
			m.Len = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Len |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *Frame) 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 ErrIntOverflowData
			}
			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: Frame: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Frame: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Off", wireType)
			}
			m.Off = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Off |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Len", wireType)
			}
			m.Len = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Len |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
			if m.Data == nil {
				m.Data = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *ReadResp) 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 ErrIntOverflowData
			}
			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: ReadResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReadResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Buf", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Buf = append(m.Buf[:0], dAtA[iNdEx:postIndex]...)
			if m.Buf == nil {
				m.Buf = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Frames", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Frames = append(m.Frames, &Frame{})
			if err := m.Frames[len(m.Frames)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Done", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Done = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *WriteReq) 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 ErrIntOverflowData
			}
			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: WriteReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WriteReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileHandle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FileHandle == nil {
				m.FileHandle = &FileHandle{}
			}
			if err := m.FileHandle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Buf", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Buf = append(m.Buf[:0], dAtA[iNdEx:postIndex]...)
			if m.Buf == nil {
				m.Buf = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Off", wireType)
			}
			m.Off = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Off |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *WriteResp) 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 ErrIntOverflowData
			}
			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: WriteResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WriteResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Written", wireType)
			}
			m.Written = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Written |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *FlushReq) 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 ErrIntOverflowData
			}
			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: FlushReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FlushReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileHandle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FileHandle == nil {
				m.FileHandle = &FileHandle{}
			}
			if err := m.FileHandle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *FlushResp) 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 ErrIntOverflowData
			}
			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: FlushResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FlushResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Entry == nil {
				m.Entry = &DirEntry{}
			}
			if err := m.Entry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *FsyncReq) 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 ErrIntOverflowData
			}
			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: FsyncReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FsyncReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileHandle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FileHandle == nil {
				m.FileHandle = &FileHandle{}
			}
			if err := m.FileHandle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *FsyncResp) 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 ErrIntOverflowData
			}
			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: FsyncResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FsyncResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Entry == nil {
				m.Entry = &DirEntry{}
			}
			if err := m.Entry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *BatchCommandsRequest) 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 ErrIntOverflowData
			}
			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: BatchCommandsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchCommandsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Requests", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Requests = append(m.Requests, &BatchCommandsRequest_Request{})
			if err := m.Requests[len(m.Requests)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowData
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RequestIds = append(m.RequestIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowData
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthData
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthData
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RequestIds) == 0 {
					m.RequestIds = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowData
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RequestIds = append(m.RequestIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestIds", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *BatchCommandsRequest_Request) 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 ErrIntOverflowData
			}
			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: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Read", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ReadReq{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_Read{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Write", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &WriteReq{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_Write{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Flush", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &FlushReq{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_Flush{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fsync", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &FsyncReq{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_Fsync{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Setattr", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &SetattrReq{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_Setattr{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fallocate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &FallocateReq{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_Fallocate{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *BatchCommandsResponse) 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 ErrIntOverflowData
			}
			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: BatchCommandsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchCommandsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Responses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Responses = append(m.Responses, &BatchCommandsResponse_Response{})
			if err := m.Responses[len(m.Responses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowData
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RequestIds = append(m.RequestIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowData
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthData
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthData
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RequestIds) == 0 {
					m.RequestIds = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowData
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RequestIds = append(m.RequestIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestIds", wireType)
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotMount", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.NotMount = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 *BatchCommandsResponse_Response) 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 ErrIntOverflowData
			}
			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: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Read", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ReadResp{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_Read{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Write", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &WriteResp{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_Write{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Flush", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &FlushResp{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_Flush{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fsync", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &FsyncResp{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_Fsync{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Setattr", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &SetattrResp{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_Setattr{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fallocate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &FallocateResp{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_Fallocate{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthData
			}
			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 skipData(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowData
			}
			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, ErrIntOverflowData
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowData
				}
				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, ErrInvalidLengthData
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupData
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthData
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthData        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowData          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupData = fmt.Errorf("proto: unexpected end of group")
)