304 lines
7.7 KiB
Go
304 lines
7.7 KiB
Go
// Copyright 2020 The gVisor Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package linux
|
|
|
|
// +marshal
|
|
type FUSEOpcode uint32
|
|
|
|
// +marshal
|
|
type FUSEOpID uint64
|
|
|
|
// Opcodes for FUSE operations. Analogous to the opcodes in include/linux/fuse.h.
|
|
const (
|
|
FUSE_LOOKUP FUSEOpcode = 1
|
|
FUSE_FORGET = 2 /* no reply */
|
|
FUSE_GETATTR = 3
|
|
FUSE_SETATTR = 4
|
|
FUSE_READLINK = 5
|
|
FUSE_SYMLINK = 6
|
|
_
|
|
FUSE_MKNOD = 8
|
|
FUSE_MKDIR = 9
|
|
FUSE_UNLINK = 10
|
|
FUSE_RMDIR = 11
|
|
FUSE_RENAME = 12
|
|
FUSE_LINK = 13
|
|
FUSE_OPEN = 14
|
|
FUSE_READ = 15
|
|
FUSE_WRITE = 16
|
|
FUSE_STATFS = 17
|
|
FUSE_RELEASE = 18
|
|
_
|
|
FUSE_FSYNC = 20
|
|
FUSE_SETXATTR = 21
|
|
FUSE_GETXATTR = 22
|
|
FUSE_LISTXATTR = 23
|
|
FUSE_REMOVEXATTR = 24
|
|
FUSE_FLUSH = 25
|
|
FUSE_INIT = 26
|
|
FUSE_OPENDIR = 27
|
|
FUSE_READDIR = 28
|
|
FUSE_RELEASEDIR = 29
|
|
FUSE_FSYNCDIR = 30
|
|
FUSE_GETLK = 31
|
|
FUSE_SETLK = 32
|
|
FUSE_SETLKW = 33
|
|
FUSE_ACCESS = 34
|
|
FUSE_CREATE = 35
|
|
FUSE_INTERRUPT = 36
|
|
FUSE_BMAP = 37
|
|
FUSE_DESTROY = 38
|
|
FUSE_IOCTL = 39
|
|
FUSE_POLL = 40
|
|
FUSE_NOTIFY_REPLY = 41
|
|
FUSE_BATCH_FORGET = 42
|
|
)
|
|
|
|
const (
|
|
// FUSE_MIN_READ_BUFFER is the minimum size the read can be for any FUSE filesystem.
|
|
// This is the minimum size Linux supports. See linux.fuse.h.
|
|
FUSE_MIN_READ_BUFFER uint32 = 8192
|
|
)
|
|
|
|
// FUSEHeaderIn is the header read by the daemon with each request.
|
|
//
|
|
// +marshal
|
|
type FUSEHeaderIn struct {
|
|
// Len specifies the total length of the data, including this header.
|
|
Len uint32
|
|
|
|
// Opcode specifies the kind of operation of the request.
|
|
Opcode FUSEOpcode
|
|
|
|
// Unique specifies the unique identifier for this request.
|
|
Unique FUSEOpID
|
|
|
|
// NodeID is the ID of the filesystem object being operated on.
|
|
NodeID uint64
|
|
|
|
// UID is the UID of the requesting process.
|
|
UID uint32
|
|
|
|
// GID is the GID of the requesting process.
|
|
GID uint32
|
|
|
|
// PID is the PID of the requesting process.
|
|
PID uint32
|
|
|
|
_ uint32
|
|
}
|
|
|
|
// FUSEHeaderOut is the header written by the daemon when it processes
|
|
// a request and wants to send a reply (almost all operations require a
|
|
// reply; if they do not, this will be explicitly documented).
|
|
//
|
|
// +marshal
|
|
type FUSEHeaderOut struct {
|
|
// Len specifies the total length of the data, including this header.
|
|
Len uint32
|
|
|
|
// Error specifies the error that occurred (0 if none).
|
|
Error int32
|
|
|
|
// Unique specifies the unique identifier of the corresponding request.
|
|
Unique FUSEOpID
|
|
}
|
|
|
|
// FUSEWriteIn is the header written by a daemon when it makes a
|
|
// write request to the FUSE filesystem.
|
|
//
|
|
// +marshal
|
|
type FUSEWriteIn struct {
|
|
// Fh specifies the file handle that is being written to.
|
|
Fh uint64
|
|
|
|
// Offset is the offset of the write.
|
|
Offset uint64
|
|
|
|
// Size is the size of data being written.
|
|
Size uint32
|
|
|
|
// WriteFlags is the flags used during the write.
|
|
WriteFlags uint32
|
|
|
|
// LockOwner is the ID of the lock owner.
|
|
LockOwner uint64
|
|
|
|
// Flags is the flags for the request.
|
|
Flags uint32
|
|
|
|
_ uint32
|
|
}
|
|
|
|
// FUSE_INIT flags, consistent with the ones in include/uapi/linux/fuse.h.
|
|
const (
|
|
FUSE_ASYNC_READ = 1 << 0
|
|
FUSE_POSIX_LOCKS = 1 << 1
|
|
FUSE_FILE_OPS = 1 << 2
|
|
FUSE_ATOMIC_O_TRUNC = 1 << 3
|
|
FUSE_EXPORT_SUPPORT = 1 << 4
|
|
FUSE_BIG_WRITES = 1 << 5
|
|
FUSE_DONT_MASK = 1 << 6
|
|
FUSE_SPLICE_WRITE = 1 << 7
|
|
FUSE_SPLICE_MOVE = 1 << 8
|
|
FUSE_SPLICE_READ = 1 << 9
|
|
FUSE_FLOCK_LOCKS = 1 << 10
|
|
FUSE_HAS_IOCTL_DIR = 1 << 11
|
|
FUSE_AUTO_INVAL_DATA = 1 << 12
|
|
FUSE_DO_READDIRPLUS = 1 << 13
|
|
FUSE_READDIRPLUS_AUTO = 1 << 14
|
|
FUSE_ASYNC_DIO = 1 << 15
|
|
FUSE_WRITEBACK_CACHE = 1 << 16
|
|
FUSE_NO_OPEN_SUPPORT = 1 << 17
|
|
FUSE_PARALLEL_DIROPS = 1 << 18
|
|
FUSE_HANDLE_KILLPRIV = 1 << 19
|
|
FUSE_POSIX_ACL = 1 << 20
|
|
FUSE_ABORT_ERROR = 1 << 21
|
|
FUSE_MAX_PAGES = 1 << 22
|
|
FUSE_CACHE_SYMLINKS = 1 << 23
|
|
FUSE_NO_OPENDIR_SUPPORT = 1 << 24
|
|
FUSE_EXPLICIT_INVAL_DATA = 1 << 25
|
|
FUSE_MAP_ALIGNMENT = 1 << 26
|
|
)
|
|
|
|
// currently supported FUSE protocol version numbers.
|
|
const (
|
|
FUSE_KERNEL_VERSION = 7
|
|
FUSE_KERNEL_MINOR_VERSION = 31
|
|
)
|
|
|
|
// FUSEInitIn is the request sent by the kernel to the daemon,
|
|
// to negotiate the version and flags.
|
|
//
|
|
// +marshal
|
|
type FUSEInitIn struct {
|
|
// Major version supported by kernel.
|
|
Major uint32
|
|
|
|
// Minor version supported by the kernel.
|
|
Minor uint32
|
|
|
|
// MaxReadahead is the maximum number of bytes to read-ahead
|
|
// decided by the kernel.
|
|
MaxReadahead uint32
|
|
|
|
// Flags of this init request.
|
|
Flags uint32
|
|
}
|
|
|
|
// FUSEInitOut is the reply sent by the daemon to the kernel
|
|
// for FUSEInitIn.
|
|
//
|
|
// +marshal
|
|
type FUSEInitOut struct {
|
|
// Major version supported by daemon.
|
|
Major uint32
|
|
|
|
// Minor version supported by daemon.
|
|
Minor uint32
|
|
|
|
// MaxReadahead is the maximum number of bytes to read-ahead.
|
|
// Decided by the daemon, after receiving the value from kernel.
|
|
MaxReadahead uint32
|
|
|
|
// Flags of this init reply.
|
|
Flags uint32
|
|
|
|
// MaxBackground is the maximum number of pending background requests
|
|
// that the daemon wants.
|
|
MaxBackground uint16
|
|
|
|
// CongestionThreshold is the daemon-decided threshold for
|
|
// the number of the pending background requests.
|
|
CongestionThreshold uint16
|
|
|
|
// MaxWrite is the daemon's maximum size of a write buffer.
|
|
// Kernel adjusts it to the minimum (fuse/init.go:fuseMinMaxWrite).
|
|
// if the value from daemon is too small.
|
|
MaxWrite uint32
|
|
|
|
// TimeGran is the daemon's time granularity for mtime and ctime metadata.
|
|
// The unit is nanosecond.
|
|
// Value should be power of 10.
|
|
// 1 indicates full nanosecond granularity support.
|
|
TimeGran uint32
|
|
|
|
// MaxPages is the daemon's maximum number of pages for one write operation.
|
|
// Kernel adjusts it to the maximum (fuse/init.go:FUSE_MAX_MAX_PAGES).
|
|
// if the value from daemon is too large.
|
|
MaxPages uint16
|
|
|
|
// MapAlignment is an unknown field and not used by this package at this moment.
|
|
// Use as a placeholder to be consistent with the FUSE protocol.
|
|
MapAlignment uint16
|
|
|
|
_ [8]uint32
|
|
}
|
|
|
|
// FUSEGetAttrIn is the request sent by the kernel to the daemon,
|
|
// to get the attribute of a inode.
|
|
//
|
|
// +marshal
|
|
type FUSEGetAttrIn struct {
|
|
// GetAttrFlags specifies whether getattr request is sent with a nodeid or
|
|
// with a file handle.
|
|
GetAttrFlags uint32
|
|
|
|
_ uint32
|
|
|
|
// Fh is the file handler when GetAttrFlags has FUSE_GETATTR_FH bit. If
|
|
// used, the operation is analogous to fstat(2).
|
|
Fh uint64
|
|
}
|
|
|
|
// FUSEAttr is the struct used in the reponse FUSEGetAttrOut.
|
|
//
|
|
// +marshal
|
|
type FUSEAttr struct {
|
|
Ino uint64
|
|
Size uint64
|
|
Blocks uint64
|
|
Atime uint64
|
|
Mtime uint64
|
|
Ctime uint64
|
|
AtimeNsec uint32
|
|
MtimeNsec uint32
|
|
CtimeNsec uint32
|
|
Mode uint32
|
|
Nlink uint32
|
|
UID uint32
|
|
GID uint32
|
|
Rdev uint32
|
|
BlkSize uint32
|
|
_ uint32
|
|
}
|
|
|
|
// FUSEGetAttrOut is the reply sent by the daemon to the kernel
|
|
// for FUSEGetAttrIn.
|
|
//
|
|
// +marshal
|
|
type FUSEGetAttrOut struct {
|
|
// AttrValid and AttrValidNsec describe the attribute cache duration
|
|
AttrValid uint64
|
|
|
|
// AttrValidNsec is the nanosecond part of the attribute cache duration
|
|
AttrValidNsec uint32
|
|
|
|
_ uint32
|
|
|
|
// Attr contains the metadata returned from the FUSE server
|
|
Attr FUSEAttr
|
|
}
|