mirror of
https://github.com/octoleo/restic.git
synced 2024-12-12 06:07:55 +00:00
bff635bc5f
So, `dep` got an nice new feature to remove tests and non-go files from `vendor/`, and this brings the size of the vendor directory from ~300MiB down to ~20MiB. We don that now.
2305 lines
58 KiB
Go
2305 lines
58 KiB
Go
// See the file LICENSE for copyright and licensing information.
|
|
|
|
// Adapted from Plan 9 from User Space's src/cmd/9pfuse/fuse.c,
|
|
// which carries this notice:
|
|
//
|
|
// The files in this directory are subject to the following license.
|
|
//
|
|
// The author of this software is Russ Cox.
|
|
//
|
|
// Copyright (c) 2006 Russ Cox
|
|
//
|
|
// Permission to use, copy, modify, and distribute this software for any
|
|
// purpose without fee is hereby granted, provided that this entire notice
|
|
// is included in all copies of any software which is or includes a copy
|
|
// or modification of this software and in all copies of the supporting
|
|
// documentation for such software.
|
|
//
|
|
// THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
|
|
// WARRANTY. IN PARTICULAR, THE AUTHOR MAKES NO REPRESENTATION OR WARRANTY
|
|
// OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS SOFTWARE OR ITS
|
|
// FITNESS FOR ANY PARTICULAR PURPOSE.
|
|
|
|
// Package fuse enables writing FUSE file systems on Linux, OS X, and FreeBSD.
|
|
//
|
|
// On OS X, it requires OSXFUSE (http://osxfuse.github.com/).
|
|
//
|
|
// There are two approaches to writing a FUSE file system. The first is to speak
|
|
// the low-level message protocol, reading from a Conn using ReadRequest and
|
|
// writing using the various Respond methods. This approach is closest to
|
|
// the actual interaction with the kernel and can be the simplest one in contexts
|
|
// such as protocol translators.
|
|
//
|
|
// Servers of synthesized file systems tend to share common
|
|
// bookkeeping abstracted away by the second approach, which is to
|
|
// call fs.Serve to serve the FUSE protocol using an implementation of
|
|
// the service methods in the interfaces FS* (file system), Node* (file
|
|
// or directory), and Handle* (opened file or directory).
|
|
// There are a daunting number of such methods that can be written,
|
|
// but few are required.
|
|
// The specific methods are described in the documentation for those interfaces.
|
|
//
|
|
// The hellofs subdirectory contains a simple illustration of the fs.Serve approach.
|
|
//
|
|
// Service Methods
|
|
//
|
|
// The required and optional methods for the FS, Node, and Handle interfaces
|
|
// have the general form
|
|
//
|
|
// Op(ctx context.Context, req *OpRequest, resp *OpResponse) error
|
|
//
|
|
// where Op is the name of a FUSE operation. Op reads request
|
|
// parameters from req and writes results to resp. An operation whose
|
|
// only result is the error result omits the resp parameter.
|
|
//
|
|
// Multiple goroutines may call service methods simultaneously; the
|
|
// methods being called are responsible for appropriate
|
|
// synchronization.
|
|
//
|
|
// The operation must not hold on to the request or response,
|
|
// including any []byte fields such as WriteRequest.Data or
|
|
// SetxattrRequest.Xattr.
|
|
//
|
|
// Errors
|
|
//
|
|
// Operations can return errors. The FUSE interface can only
|
|
// communicate POSIX errno error numbers to file system clients, the
|
|
// message is not visible to file system clients. The returned error
|
|
// can implement ErrorNumber to control the errno returned. Without
|
|
// ErrorNumber, a generic errno (EIO) is returned.
|
|
//
|
|
// Error messages will be visible in the debug log as part of the
|
|
// response.
|
|
//
|
|
// Interrupted Operations
|
|
//
|
|
// In some file systems, some operations
|
|
// may take an undetermined amount of time. For example, a Read waiting for
|
|
// a network message or a matching Write might wait indefinitely. If the request
|
|
// is cancelled and no longer needed, the context will be cancelled.
|
|
// Blocking operations should select on a receive from ctx.Done() and attempt to
|
|
// abort the operation early if the receive succeeds (meaning the channel is closed).
|
|
// To indicate that the operation failed because it was aborted, return fuse.EINTR.
|
|
//
|
|
// If an operation does not block for an indefinite amount of time, supporting
|
|
// cancellation is not necessary.
|
|
//
|
|
// Authentication
|
|
//
|
|
// All requests types embed a Header, meaning that the method can
|
|
// inspect req.Pid, req.Uid, and req.Gid as necessary to implement
|
|
// permission checking. The kernel FUSE layer normally prevents other
|
|
// users from accessing the FUSE file system (to change this, see
|
|
// AllowOther, AllowRoot), but does not enforce access modes (to
|
|
// change this, see DefaultPermissions).
|
|
//
|
|
// Mount Options
|
|
//
|
|
// Behavior and metadata of the mounted file system can be changed by
|
|
// passing MountOption values to Mount.
|
|
//
|
|
package fuse // import "bazil.org/fuse"
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"sync"
|
|
"syscall"
|
|
"time"
|
|
"unsafe"
|
|
)
|
|
|
|
// A Conn represents a connection to a mounted FUSE file system.
|
|
type Conn struct {
|
|
// Ready is closed when the mount is complete or has failed.
|
|
Ready <-chan struct{}
|
|
|
|
// MountError stores any error from the mount process. Only valid
|
|
// after Ready is closed.
|
|
MountError error
|
|
|
|
// File handle for kernel communication. Only safe to access if
|
|
// rio or wio is held.
|
|
dev *os.File
|
|
wio sync.RWMutex
|
|
rio sync.RWMutex
|
|
|
|
// Protocol version negotiated with InitRequest/InitResponse.
|
|
proto Protocol
|
|
}
|
|
|
|
// MountpointDoesNotExistError is an error returned when the
|
|
// mountpoint does not exist.
|
|
type MountpointDoesNotExistError struct {
|
|
Path string
|
|
}
|
|
|
|
var _ error = (*MountpointDoesNotExistError)(nil)
|
|
|
|
func (e *MountpointDoesNotExistError) Error() string {
|
|
return fmt.Sprintf("mountpoint does not exist: %v", e.Path)
|
|
}
|
|
|
|
// Mount mounts a new FUSE connection on the named directory
|
|
// and returns a connection for reading and writing FUSE messages.
|
|
//
|
|
// After a successful return, caller must call Close to free
|
|
// resources.
|
|
//
|
|
// Even on successful return, the new mount is not guaranteed to be
|
|
// visible until after Conn.Ready is closed. See Conn.MountError for
|
|
// possible errors. Incoming requests on Conn must be served to make
|
|
// progress.
|
|
func Mount(dir string, options ...MountOption) (*Conn, error) {
|
|
conf := mountConfig{
|
|
options: make(map[string]string),
|
|
}
|
|
for _, option := range options {
|
|
if err := option(&conf); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
ready := make(chan struct{}, 1)
|
|
c := &Conn{
|
|
Ready: ready,
|
|
}
|
|
f, err := mount(dir, &conf, ready, &c.MountError)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
c.dev = f
|
|
|
|
if err := initMount(c, &conf); err != nil {
|
|
c.Close()
|
|
if err == ErrClosedWithoutInit {
|
|
// see if we can provide a better error
|
|
<-c.Ready
|
|
if err := c.MountError; err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
return c, nil
|
|
}
|
|
|
|
type OldVersionError struct {
|
|
Kernel Protocol
|
|
LibraryMin Protocol
|
|
}
|
|
|
|
func (e *OldVersionError) Error() string {
|
|
return fmt.Sprintf("kernel FUSE version is too old: %v < %v", e.Kernel, e.LibraryMin)
|
|
}
|
|
|
|
var (
|
|
ErrClosedWithoutInit = errors.New("fuse connection closed without init")
|
|
)
|
|
|
|
func initMount(c *Conn, conf *mountConfig) error {
|
|
req, err := c.ReadRequest()
|
|
if err != nil {
|
|
if err == io.EOF {
|
|
return ErrClosedWithoutInit
|
|
}
|
|
return err
|
|
}
|
|
r, ok := req.(*InitRequest)
|
|
if !ok {
|
|
return fmt.Errorf("missing init, got: %T", req)
|
|
}
|
|
|
|
min := Protocol{protoVersionMinMajor, protoVersionMinMinor}
|
|
if r.Kernel.LT(min) {
|
|
req.RespondError(Errno(syscall.EPROTO))
|
|
c.Close()
|
|
return &OldVersionError{
|
|
Kernel: r.Kernel,
|
|
LibraryMin: min,
|
|
}
|
|
}
|
|
|
|
proto := Protocol{protoVersionMaxMajor, protoVersionMaxMinor}
|
|
if r.Kernel.LT(proto) {
|
|
// Kernel doesn't support the latest version we have.
|
|
proto = r.Kernel
|
|
}
|
|
c.proto = proto
|
|
|
|
s := &InitResponse{
|
|
Library: proto,
|
|
MaxReadahead: conf.maxReadahead,
|
|
MaxWrite: maxWrite,
|
|
Flags: InitBigWrites | conf.initFlags,
|
|
}
|
|
r.Respond(s)
|
|
return nil
|
|
}
|
|
|
|
// A Request represents a single FUSE request received from the kernel.
|
|
// Use a type switch to determine the specific kind.
|
|
// A request of unrecognized type will have concrete type *Header.
|
|
type Request interface {
|
|
// Hdr returns the Header associated with this request.
|
|
Hdr() *Header
|
|
|
|
// RespondError responds to the request with the given error.
|
|
RespondError(error)
|
|
|
|
String() string
|
|
}
|
|
|
|
// A RequestID identifies an active FUSE request.
|
|
type RequestID uint64
|
|
|
|
func (r RequestID) String() string {
|
|
return fmt.Sprintf("%#x", uint64(r))
|
|
}
|
|
|
|
// A NodeID is a number identifying a directory or file.
|
|
// It must be unique among IDs returned in LookupResponses
|
|
// that have not yet been forgotten by ForgetRequests.
|
|
type NodeID uint64
|
|
|
|
func (n NodeID) String() string {
|
|
return fmt.Sprintf("%#x", uint64(n))
|
|
}
|
|
|
|
// A HandleID is a number identifying an open directory or file.
|
|
// It only needs to be unique while the directory or file is open.
|
|
type HandleID uint64
|
|
|
|
func (h HandleID) String() string {
|
|
return fmt.Sprintf("%#x", uint64(h))
|
|
}
|
|
|
|
// The RootID identifies the root directory of a FUSE file system.
|
|
const RootID NodeID = rootID
|
|
|
|
// A Header describes the basic information sent in every request.
|
|
type Header struct {
|
|
Conn *Conn `json:"-"` // connection this request was received on
|
|
ID RequestID // unique ID for request
|
|
Node NodeID // file or directory the request is about
|
|
Uid uint32 // user ID of process making request
|
|
Gid uint32 // group ID of process making request
|
|
Pid uint32 // process ID of process making request
|
|
|
|
// for returning to reqPool
|
|
msg *message
|
|
}
|
|
|
|
func (h *Header) String() string {
|
|
return fmt.Sprintf("ID=%v Node=%v Uid=%d Gid=%d Pid=%d", h.ID, h.Node, h.Uid, h.Gid, h.Pid)
|
|
}
|
|
|
|
func (h *Header) Hdr() *Header {
|
|
return h
|
|
}
|
|
|
|
func (h *Header) noResponse() {
|
|
putMessage(h.msg)
|
|
}
|
|
|
|
func (h *Header) respond(msg []byte) {
|
|
out := (*outHeader)(unsafe.Pointer(&msg[0]))
|
|
out.Unique = uint64(h.ID)
|
|
h.Conn.respond(msg)
|
|
putMessage(h.msg)
|
|
}
|
|
|
|
// An ErrorNumber is an error with a specific error number.
|
|
//
|
|
// Operations may return an error value that implements ErrorNumber to
|
|
// control what specific error number (errno) to return.
|
|
type ErrorNumber interface {
|
|
// Errno returns the the error number (errno) for this error.
|
|
Errno() Errno
|
|
}
|
|
|
|
const (
|
|
// ENOSYS indicates that the call is not supported.
|
|
ENOSYS = Errno(syscall.ENOSYS)
|
|
|
|
// ESTALE is used by Serve to respond to violations of the FUSE protocol.
|
|
ESTALE = Errno(syscall.ESTALE)
|
|
|
|
ENOENT = Errno(syscall.ENOENT)
|
|
EIO = Errno(syscall.EIO)
|
|
EPERM = Errno(syscall.EPERM)
|
|
|
|
// EINTR indicates request was interrupted by an InterruptRequest.
|
|
// See also fs.Intr.
|
|
EINTR = Errno(syscall.EINTR)
|
|
|
|
ERANGE = Errno(syscall.ERANGE)
|
|
ENOTSUP = Errno(syscall.ENOTSUP)
|
|
EEXIST = Errno(syscall.EEXIST)
|
|
)
|
|
|
|
// DefaultErrno is the errno used when error returned does not
|
|
// implement ErrorNumber.
|
|
const DefaultErrno = EIO
|
|
|
|
var errnoNames = map[Errno]string{
|
|
ENOSYS: "ENOSYS",
|
|
ESTALE: "ESTALE",
|
|
ENOENT: "ENOENT",
|
|
EIO: "EIO",
|
|
EPERM: "EPERM",
|
|
EINTR: "EINTR",
|
|
EEXIST: "EEXIST",
|
|
}
|
|
|
|
// Errno implements Error and ErrorNumber using a syscall.Errno.
|
|
type Errno syscall.Errno
|
|
|
|
var _ = ErrorNumber(Errno(0))
|
|
var _ = error(Errno(0))
|
|
|
|
func (e Errno) Errno() Errno {
|
|
return e
|
|
}
|
|
|
|
func (e Errno) String() string {
|
|
return syscall.Errno(e).Error()
|
|
}
|
|
|
|
func (e Errno) Error() string {
|
|
return syscall.Errno(e).Error()
|
|
}
|
|
|
|
// ErrnoName returns the short non-numeric identifier for this errno.
|
|
// For example, "EIO".
|
|
func (e Errno) ErrnoName() string {
|
|
s := errnoNames[e]
|
|
if s == "" {
|
|
s = fmt.Sprint(e.Errno())
|
|
}
|
|
return s
|
|
}
|
|
|
|
func (e Errno) MarshalText() ([]byte, error) {
|
|
s := e.ErrnoName()
|
|
return []byte(s), nil
|
|
}
|
|
|
|
func (h *Header) RespondError(err error) {
|
|
errno := DefaultErrno
|
|
if ferr, ok := err.(ErrorNumber); ok {
|
|
errno = ferr.Errno()
|
|
}
|
|
// FUSE uses negative errors!
|
|
// TODO: File bug report against OSXFUSE: positive error causes kernel panic.
|
|
buf := newBuffer(0)
|
|
hOut := (*outHeader)(unsafe.Pointer(&buf[0]))
|
|
hOut.Error = -int32(errno)
|
|
h.respond(buf)
|
|
}
|
|
|
|
// All requests read from the kernel, without data, are shorter than
|
|
// this.
|
|
var maxRequestSize = syscall.Getpagesize()
|
|
var bufSize = maxRequestSize + maxWrite
|
|
|
|
// reqPool is a pool of messages.
|
|
//
|
|
// Lifetime of a logical message is from getMessage to putMessage.
|
|
// getMessage is called by ReadRequest. putMessage is called by
|
|
// Conn.ReadRequest, Request.Respond, or Request.RespondError.
|
|
//
|
|
// Messages in the pool are guaranteed to have conn and off zeroed,
|
|
// buf allocated and len==bufSize, and hdr set.
|
|
var reqPool = sync.Pool{
|
|
New: allocMessage,
|
|
}
|
|
|
|
func allocMessage() interface{} {
|
|
m := &message{buf: make([]byte, bufSize)}
|
|
m.hdr = (*inHeader)(unsafe.Pointer(&m.buf[0]))
|
|
return m
|
|
}
|
|
|
|
func getMessage(c *Conn) *message {
|
|
m := reqPool.Get().(*message)
|
|
m.conn = c
|
|
return m
|
|
}
|
|
|
|
func putMessage(m *message) {
|
|
m.buf = m.buf[:bufSize]
|
|
m.conn = nil
|
|
m.off = 0
|
|
reqPool.Put(m)
|
|
}
|
|
|
|
// a message represents the bytes of a single FUSE message
|
|
type message struct {
|
|
conn *Conn
|
|
buf []byte // all bytes
|
|
hdr *inHeader // header
|
|
off int // offset for reading additional fields
|
|
}
|
|
|
|
func (m *message) len() uintptr {
|
|
return uintptr(len(m.buf) - m.off)
|
|
}
|
|
|
|
func (m *message) data() unsafe.Pointer {
|
|
var p unsafe.Pointer
|
|
if m.off < len(m.buf) {
|
|
p = unsafe.Pointer(&m.buf[m.off])
|
|
}
|
|
return p
|
|
}
|
|
|
|
func (m *message) bytes() []byte {
|
|
return m.buf[m.off:]
|
|
}
|
|
|
|
func (m *message) Header() Header {
|
|
h := m.hdr
|
|
return Header{
|
|
Conn: m.conn,
|
|
ID: RequestID(h.Unique),
|
|
Node: NodeID(h.Nodeid),
|
|
Uid: h.Uid,
|
|
Gid: h.Gid,
|
|
Pid: h.Pid,
|
|
|
|
msg: m,
|
|
}
|
|
}
|
|
|
|
// fileMode returns a Go os.FileMode from a Unix mode.
|
|
func fileMode(unixMode uint32) os.FileMode {
|
|
mode := os.FileMode(unixMode & 0777)
|
|
switch unixMode & syscall.S_IFMT {
|
|
case syscall.S_IFREG:
|
|
// nothing
|
|
case syscall.S_IFDIR:
|
|
mode |= os.ModeDir
|
|
case syscall.S_IFCHR:
|
|
mode |= os.ModeCharDevice | os.ModeDevice
|
|
case syscall.S_IFBLK:
|
|
mode |= os.ModeDevice
|
|
case syscall.S_IFIFO:
|
|
mode |= os.ModeNamedPipe
|
|
case syscall.S_IFLNK:
|
|
mode |= os.ModeSymlink
|
|
case syscall.S_IFSOCK:
|
|
mode |= os.ModeSocket
|
|
default:
|
|
// no idea
|
|
mode |= os.ModeDevice
|
|
}
|
|
if unixMode&syscall.S_ISUID != 0 {
|
|
mode |= os.ModeSetuid
|
|
}
|
|
if unixMode&syscall.S_ISGID != 0 {
|
|
mode |= os.ModeSetgid
|
|
}
|
|
return mode
|
|
}
|
|
|
|
type noOpcode struct {
|
|
Opcode uint32
|
|
}
|
|
|
|
func (m noOpcode) String() string {
|
|
return fmt.Sprintf("No opcode %v", m.Opcode)
|
|
}
|
|
|
|
type malformedMessage struct {
|
|
}
|
|
|
|
func (malformedMessage) String() string {
|
|
return "malformed message"
|
|
}
|
|
|
|
// Close closes the FUSE connection.
|
|
func (c *Conn) Close() error {
|
|
c.wio.Lock()
|
|
defer c.wio.Unlock()
|
|
c.rio.Lock()
|
|
defer c.rio.Unlock()
|
|
return c.dev.Close()
|
|
}
|
|
|
|
// caller must hold wio or rio
|
|
func (c *Conn) fd() int {
|
|
return int(c.dev.Fd())
|
|
}
|
|
|
|
func (c *Conn) Protocol() Protocol {
|
|
return c.proto
|
|
}
|
|
|
|
// ReadRequest returns the next FUSE request from the kernel.
|
|
//
|
|
// Caller must call either Request.Respond or Request.RespondError in
|
|
// a reasonable time. Caller must not retain Request after that call.
|
|
func (c *Conn) ReadRequest() (Request, error) {
|
|
m := getMessage(c)
|
|
loop:
|
|
c.rio.RLock()
|
|
n, err := syscall.Read(c.fd(), m.buf)
|
|
c.rio.RUnlock()
|
|
if err == syscall.EINTR {
|
|
// OSXFUSE sends EINTR to userspace when a request interrupt
|
|
// completed before it got sent to userspace?
|
|
goto loop
|
|
}
|
|
if err != nil && err != syscall.ENODEV {
|
|
putMessage(m)
|
|
return nil, err
|
|
}
|
|
if n <= 0 {
|
|
putMessage(m)
|
|
return nil, io.EOF
|
|
}
|
|
m.buf = m.buf[:n]
|
|
|
|
if n < inHeaderSize {
|
|
putMessage(m)
|
|
return nil, errors.New("fuse: message too short")
|
|
}
|
|
|
|
// FreeBSD FUSE sends a short length in the header
|
|
// for FUSE_INIT even though the actual read length is correct.
|
|
if n == inHeaderSize+initInSize && m.hdr.Opcode == opInit && m.hdr.Len < uint32(n) {
|
|
m.hdr.Len = uint32(n)
|
|
}
|
|
|
|
// OSXFUSE sometimes sends the wrong m.hdr.Len in a FUSE_WRITE message.
|
|
if m.hdr.Len < uint32(n) && m.hdr.Len >= uint32(unsafe.Sizeof(writeIn{})) && m.hdr.Opcode == opWrite {
|
|
m.hdr.Len = uint32(n)
|
|
}
|
|
|
|
if m.hdr.Len != uint32(n) {
|
|
// prepare error message before returning m to pool
|
|
err := fmt.Errorf("fuse: read %d opcode %d but expected %d", n, m.hdr.Opcode, m.hdr.Len)
|
|
putMessage(m)
|
|
return nil, err
|
|
}
|
|
|
|
m.off = inHeaderSize
|
|
|
|
// Convert to data structures.
|
|
// Do not trust kernel to hand us well-formed data.
|
|
var req Request
|
|
switch m.hdr.Opcode {
|
|
default:
|
|
Debug(noOpcode{Opcode: m.hdr.Opcode})
|
|
goto unrecognized
|
|
|
|
case opLookup:
|
|
buf := m.bytes()
|
|
n := len(buf)
|
|
if n == 0 || buf[n-1] != '\x00' {
|
|
goto corrupt
|
|
}
|
|
req = &LookupRequest{
|
|
Header: m.Header(),
|
|
Name: string(buf[:n-1]),
|
|
}
|
|
|
|
case opForget:
|
|
in := (*forgetIn)(m.data())
|
|
if m.len() < unsafe.Sizeof(*in) {
|
|
goto corrupt
|
|
}
|
|
req = &ForgetRequest{
|
|
Header: m.Header(),
|
|
N: in.Nlookup,
|
|
}
|
|
|
|
case opGetattr:
|
|
switch {
|
|
case c.proto.LT(Protocol{7, 9}):
|
|
req = &GetattrRequest{
|
|
Header: m.Header(),
|
|
}
|
|
|
|
default:
|
|
in := (*getattrIn)(m.data())
|
|
if m.len() < unsafe.Sizeof(*in) {
|
|
goto corrupt
|
|
}
|
|
req = &GetattrRequest{
|
|
Header: m.Header(),
|
|
Flags: GetattrFlags(in.GetattrFlags),
|
|
Handle: HandleID(in.Fh),
|
|
}
|
|
}
|
|
|
|
case opSetattr:
|
|
in := (*setattrIn)(m.data())
|
|
if m.len() < unsafe.Sizeof(*in) {
|
|
goto corrupt
|
|
}
|
|
req = &SetattrRequest{
|
|
Header: m.Header(),
|
|
Valid: SetattrValid(in.Valid),
|
|
Handle: HandleID(in.Fh),
|
|
Size: in.Size,
|
|
Atime: time.Unix(int64(in.Atime), int64(in.AtimeNsec)),
|
|
Mtime: time.Unix(int64(in.Mtime), int64(in.MtimeNsec)),
|
|
Mode: fileMode(in.Mode),
|
|
Uid: in.Uid,
|
|
Gid: in.Gid,
|
|
Bkuptime: in.BkupTime(),
|
|
Chgtime: in.Chgtime(),
|
|
Flags: in.Flags(),
|
|
}
|
|
|
|
case opReadlink:
|
|
if len(m.bytes()) > 0 {
|
|
goto corrupt
|
|
}
|
|
req = &ReadlinkRequest{
|
|
Header: m.Header(),
|
|
}
|
|
|
|
case opSymlink:
|
|
// m.bytes() is "newName\0target\0"
|
|
names := m.bytes()
|
|
if len(names) == 0 || names[len(names)-1] != 0 {
|
|
goto corrupt
|
|
}
|
|
i := bytes.IndexByte(names, '\x00')
|
|
if i < 0 {
|
|
goto corrupt
|
|
}
|
|
newName, target := names[0:i], names[i+1:len(names)-1]
|
|
req = &SymlinkRequest{
|
|
Header: m.Header(),
|
|
NewName: string(newName),
|
|
Target: string(target),
|
|
}
|
|
|
|
case opLink:
|
|
in := (*linkIn)(m.data())
|
|
if m.len() < unsafe.Sizeof(*in) {
|
|
goto corrupt
|
|
}
|
|
newName := m.bytes()[unsafe.Sizeof(*in):]
|
|
if len(newName) < 2 || newName[len(newName)-1] != 0 {
|
|
goto corrupt
|
|
}
|
|
newName = newName[:len(newName)-1]
|
|
req = &LinkRequest{
|
|
Header: m.Header(),
|
|
OldNode: NodeID(in.Oldnodeid),
|
|
NewName: string(newName),
|
|
}
|
|
|
|
case opMknod:
|
|
size := mknodInSize(c.proto)
|
|
if m.len() < size {
|
|
goto corrupt
|
|
}
|
|
in := (*mknodIn)(m.data())
|
|
name := m.bytes()[size:]
|
|
if len(name) < 2 || name[len(name)-1] != '\x00' {
|
|
goto corrupt
|
|
}
|
|
name = name[:len(name)-1]
|
|
r := &MknodRequest{
|
|
Header: m.Header(),
|
|
Mode: fileMode(in.Mode),
|
|
Rdev: in.Rdev,
|
|
Name: string(name),
|
|
}
|
|
if c.proto.GE(Protocol{7, 12}) {
|
|
r.Umask = fileMode(in.Umask) & os.ModePerm
|
|
}
|
|
req = r
|
|
|
|
case opMkdir:
|
|
size := mkdirInSize(c.proto)
|
|
if m.len() < size {
|
|
goto corrupt
|
|
}
|
|
in := (*mkdirIn)(m.data())
|
|
name := m.bytes()[size:]
|
|
i := bytes.IndexByte(name, '\x00')
|
|
if i < 0 {
|
|
goto corrupt
|
|
}
|
|
r := &MkdirRequest{
|
|
Header: m.Header(),
|
|
Name: string(name[:i]),
|
|
// observed on Linux: mkdirIn.Mode & syscall.S_IFMT == 0,
|
|
// and this causes fileMode to go into it's "no idea"
|
|
// code branch; enforce type to directory
|
|
Mode: fileMode((in.Mode &^ syscall.S_IFMT) | syscall.S_IFDIR),
|
|
}
|
|
if c.proto.GE(Protocol{7, 12}) {
|
|
r.Umask = fileMode(in.Umask) & os.ModePerm
|
|
}
|
|
req = r
|
|
|
|
case opUnlink, opRmdir:
|
|
buf := m.bytes()
|
|
n := len(buf)
|
|
if n == 0 || buf[n-1] != '\x00' {
|
|
goto corrupt
|
|
}
|
|
req = &RemoveRequest{
|
|
Header: m.Header(),
|
|
Name: string(buf[:n-1]),
|
|
Dir: m.hdr.Opcode == opRmdir,
|
|
}
|
|
|
|
case opRename:
|
|
in := (*renameIn)(m.data())
|
|
if m.len() < unsafe.Sizeof(*in) {
|
|
goto corrupt
|
|
}
|
|
newDirNodeID := NodeID(in.Newdir)
|
|
oldNew := m.bytes()[unsafe.Sizeof(*in):]
|
|
// oldNew should be "old\x00new\x00"
|
|
if len(oldNew) < 4 {
|
|
goto corrupt
|
|
}
|
|
if oldNew[len(oldNew)-1] != '\x00' {
|
|
goto corrupt
|
|
}
|
|
i := bytes.IndexByte(oldNew, '\x00')
|
|
if i < 0 {
|
|
goto corrupt
|
|
}
|
|
oldName, newName := string(oldNew[:i]), string(oldNew[i+1:len(oldNew)-1])
|
|
req = &RenameRequest{
|
|
Header: m.Header(),
|
|
NewDir: newDirNodeID,
|
|
OldName: oldName,
|
|
NewName: newName,
|
|
}
|
|
|
|
case opOpendir, opOpen:
|
|
in := (*openIn)(m.data())
|
|
if m.len() < unsafe.Sizeof(*in) {
|
|
goto corrupt
|
|
}
|
|
req = &OpenRequest{
|
|
Header: m.Header(),
|
|
Dir: m.hdr.Opcode == opOpendir,
|
|
Flags: openFlags(in.Flags),
|
|
}
|
|
|
|
case opRead, opReaddir:
|
|
in := (*readIn)(m.data())
|
|
if m.len() < readInSize(c.proto) {
|
|
goto corrupt
|
|
}
|
|
r := &ReadRequest{
|
|
Header: m.Header(),
|
|
Dir: m.hdr.Opcode == opReaddir,
|
|
Handle: HandleID(in.Fh),
|
|
Offset: int64(in.Offset),
|
|
Size: int(in.Size),
|
|
}
|
|
if c.proto.GE(Protocol{7, 9}) {
|
|
r.Flags = ReadFlags(in.ReadFlags)
|
|
r.LockOwner = in.LockOwner
|
|
r.FileFlags = openFlags(in.Flags)
|
|
}
|
|
req = r
|
|
|
|
case opWrite:
|
|
in := (*writeIn)(m.data())
|
|
if m.len() < writeInSize(c.proto) {
|
|
goto corrupt
|
|
}
|
|
r := &WriteRequest{
|
|
Header: m.Header(),
|
|
Handle: HandleID(in.Fh),
|
|
Offset: int64(in.Offset),
|
|
Flags: WriteFlags(in.WriteFlags),
|
|
}
|
|
if c.proto.GE(Protocol{7, 9}) {
|
|
r.LockOwner = in.LockOwner
|
|
r.FileFlags = openFlags(in.Flags)
|
|
}
|
|
buf := m.bytes()[writeInSize(c.proto):]
|
|
if uint32(len(buf)) < in.Size {
|
|
goto corrupt
|
|
}
|
|
r.Data = buf
|
|
req = r
|
|
|
|
case opStatfs:
|
|
req = &StatfsRequest{
|
|
Header: m.Header(),
|
|
}
|
|
|
|
case opRelease, opReleasedir:
|
|
in := (*releaseIn)(m.data())
|
|
if m.len() < unsafe.Sizeof(*in) {
|
|
goto corrupt
|
|
}
|
|
req = &ReleaseRequest{
|
|
Header: m.Header(),
|
|
Dir: m.hdr.Opcode == opReleasedir,
|
|
Handle: HandleID(in.Fh),
|
|
Flags: openFlags(in.Flags),
|
|
ReleaseFlags: ReleaseFlags(in.ReleaseFlags),
|
|
LockOwner: in.LockOwner,
|
|
}
|
|
|
|
case opFsync, opFsyncdir:
|
|
in := (*fsyncIn)(m.data())
|
|
if m.len() < unsafe.Sizeof(*in) {
|
|
goto corrupt
|
|
}
|
|
req = &FsyncRequest{
|
|
Dir: m.hdr.Opcode == opFsyncdir,
|
|
Header: m.Header(),
|
|
Handle: HandleID(in.Fh),
|
|
Flags: in.FsyncFlags,
|
|
}
|
|
|
|
case opSetxattr:
|
|
in := (*setxattrIn)(m.data())
|
|
if m.len() < unsafe.Sizeof(*in) {
|
|
goto corrupt
|
|
}
|
|
m.off += int(unsafe.Sizeof(*in))
|
|
name := m.bytes()
|
|
i := bytes.IndexByte(name, '\x00')
|
|
if i < 0 {
|
|
goto corrupt
|
|
}
|
|
xattr := name[i+1:]
|
|
if uint32(len(xattr)) < in.Size {
|
|
goto corrupt
|
|
}
|
|
xattr = xattr[:in.Size]
|
|
req = &SetxattrRequest{
|
|
Header: m.Header(),
|
|
Flags: in.Flags,
|
|
Position: in.position(),
|
|
Name: string(name[:i]),
|
|
Xattr: xattr,
|
|
}
|
|
|
|
case opGetxattr:
|
|
in := (*getxattrIn)(m.data())
|
|
if m.len() < unsafe.Sizeof(*in) {
|
|
goto corrupt
|
|
}
|
|
name := m.bytes()[unsafe.Sizeof(*in):]
|
|
i := bytes.IndexByte(name, '\x00')
|
|
if i < 0 {
|
|
goto corrupt
|
|
}
|
|
req = &GetxattrRequest{
|
|
Header: m.Header(),
|
|
Name: string(name[:i]),
|
|
Size: in.Size,
|
|
Position: in.position(),
|
|
}
|
|
|
|
case opListxattr:
|
|
in := (*getxattrIn)(m.data())
|
|
if m.len() < unsafe.Sizeof(*in) {
|
|
goto corrupt
|
|
}
|
|
req = &ListxattrRequest{
|
|
Header: m.Header(),
|
|
Size: in.Size,
|
|
Position: in.position(),
|
|
}
|
|
|
|
case opRemovexattr:
|
|
buf := m.bytes()
|
|
n := len(buf)
|
|
if n == 0 || buf[n-1] != '\x00' {
|
|
goto corrupt
|
|
}
|
|
req = &RemovexattrRequest{
|
|
Header: m.Header(),
|
|
Name: string(buf[:n-1]),
|
|
}
|
|
|
|
case opFlush:
|
|
in := (*flushIn)(m.data())
|
|
if m.len() < unsafe.Sizeof(*in) {
|
|
goto corrupt
|
|
}
|
|
req = &FlushRequest{
|
|
Header: m.Header(),
|
|
Handle: HandleID(in.Fh),
|
|
Flags: in.FlushFlags,
|
|
LockOwner: in.LockOwner,
|
|
}
|
|
|
|
case opInit:
|
|
in := (*initIn)(m.data())
|
|
if m.len() < unsafe.Sizeof(*in) {
|
|
goto corrupt
|
|
}
|
|
req = &InitRequest{
|
|
Header: m.Header(),
|
|
Kernel: Protocol{in.Major, in.Minor},
|
|
MaxReadahead: in.MaxReadahead,
|
|
Flags: InitFlags(in.Flags),
|
|
}
|
|
|
|
case opGetlk:
|
|
panic("opGetlk")
|
|
case opSetlk:
|
|
panic("opSetlk")
|
|
case opSetlkw:
|
|
panic("opSetlkw")
|
|
|
|
case opAccess:
|
|
in := (*accessIn)(m.data())
|
|
if m.len() < unsafe.Sizeof(*in) {
|
|
goto corrupt
|
|
}
|
|
req = &AccessRequest{
|
|
Header: m.Header(),
|
|
Mask: in.Mask,
|
|
}
|
|
|
|
case opCreate:
|
|
size := createInSize(c.proto)
|
|
if m.len() < size {
|
|
goto corrupt
|
|
}
|
|
in := (*createIn)(m.data())
|
|
name := m.bytes()[size:]
|
|
i := bytes.IndexByte(name, '\x00')
|
|
if i < 0 {
|
|
goto corrupt
|
|
}
|
|
r := &CreateRequest{
|
|
Header: m.Header(),
|
|
Flags: openFlags(in.Flags),
|
|
Mode: fileMode(in.Mode),
|
|
Name: string(name[:i]),
|
|
}
|
|
if c.proto.GE(Protocol{7, 12}) {
|
|
r.Umask = fileMode(in.Umask) & os.ModePerm
|
|
}
|
|
req = r
|
|
|
|
case opInterrupt:
|
|
in := (*interruptIn)(m.data())
|
|
if m.len() < unsafe.Sizeof(*in) {
|
|
goto corrupt
|
|
}
|
|
req = &InterruptRequest{
|
|
Header: m.Header(),
|
|
IntrID: RequestID(in.Unique),
|
|
}
|
|
|
|
case opBmap:
|
|
panic("opBmap")
|
|
|
|
case opDestroy:
|
|
req = &DestroyRequest{
|
|
Header: m.Header(),
|
|
}
|
|
|
|
// OS X
|
|
case opSetvolname:
|
|
panic("opSetvolname")
|
|
case opGetxtimes:
|
|
panic("opGetxtimes")
|
|
case opExchange:
|
|
in := (*exchangeIn)(m.data())
|
|
if m.len() < unsafe.Sizeof(*in) {
|
|
goto corrupt
|
|
}
|
|
oldDirNodeID := NodeID(in.Olddir)
|
|
newDirNodeID := NodeID(in.Newdir)
|
|
oldNew := m.bytes()[unsafe.Sizeof(*in):]
|
|
// oldNew should be "oldname\x00newname\x00"
|
|
if len(oldNew) < 4 {
|
|
goto corrupt
|
|
}
|
|
if oldNew[len(oldNew)-1] != '\x00' {
|
|
goto corrupt
|
|
}
|
|
i := bytes.IndexByte(oldNew, '\x00')
|
|
if i < 0 {
|
|
goto corrupt
|
|
}
|
|
oldName, newName := string(oldNew[:i]), string(oldNew[i+1:len(oldNew)-1])
|
|
req = &ExchangeDataRequest{
|
|
Header: m.Header(),
|
|
OldDir: oldDirNodeID,
|
|
NewDir: newDirNodeID,
|
|
OldName: oldName,
|
|
NewName: newName,
|
|
// TODO options
|
|
}
|
|
}
|
|
|
|
return req, nil
|
|
|
|
corrupt:
|
|
Debug(malformedMessage{})
|
|
putMessage(m)
|
|
return nil, fmt.Errorf("fuse: malformed message")
|
|
|
|
unrecognized:
|
|
// Unrecognized message.
|
|
// Assume higher-level code will send a "no idea what you mean" error.
|
|
h := m.Header()
|
|
return &h, nil
|
|
}
|
|
|
|
type bugShortKernelWrite struct {
|
|
Written int64
|
|
Length int64
|
|
Error string
|
|
Stack string
|
|
}
|
|
|
|
func (b bugShortKernelWrite) String() string {
|
|
return fmt.Sprintf("short kernel write: written=%d/%d error=%q stack=\n%s", b.Written, b.Length, b.Error, b.Stack)
|
|
}
|
|
|
|
type bugKernelWriteError struct {
|
|
Error string
|
|
Stack string
|
|
}
|
|
|
|
func (b bugKernelWriteError) String() string {
|
|
return fmt.Sprintf("kernel write error: error=%q stack=\n%s", b.Error, b.Stack)
|
|
}
|
|
|
|
// safe to call even with nil error
|
|
func errorString(err error) string {
|
|
if err == nil {
|
|
return ""
|
|
}
|
|
return err.Error()
|
|
}
|
|
|
|
func (c *Conn) writeToKernel(msg []byte) error {
|
|
out := (*outHeader)(unsafe.Pointer(&msg[0]))
|
|
out.Len = uint32(len(msg))
|
|
|
|
c.wio.RLock()
|
|
defer c.wio.RUnlock()
|
|
nn, err := syscall.Write(c.fd(), msg)
|
|
if err == nil && nn != len(msg) {
|
|
Debug(bugShortKernelWrite{
|
|
Written: int64(nn),
|
|
Length: int64(len(msg)),
|
|
Error: errorString(err),
|
|
Stack: stack(),
|
|
})
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (c *Conn) respond(msg []byte) {
|
|
if err := c.writeToKernel(msg); err != nil {
|
|
Debug(bugKernelWriteError{
|
|
Error: errorString(err),
|
|
Stack: stack(),
|
|
})
|
|
}
|
|
}
|
|
|
|
type notCachedError struct{}
|
|
|
|
func (notCachedError) Error() string {
|
|
return "node not cached"
|
|
}
|
|
|
|
var _ ErrorNumber = notCachedError{}
|
|
|
|
func (notCachedError) Errno() Errno {
|
|
// Behave just like if the original syscall.ENOENT had been passed
|
|
// straight through.
|
|
return ENOENT
|
|
}
|
|
|
|
var (
|
|
ErrNotCached = notCachedError{}
|
|
)
|
|
|
|
// sendInvalidate sends an invalidate notification to kernel.
|
|
//
|
|
// A returned ENOENT is translated to a friendlier error.
|
|
func (c *Conn) sendInvalidate(msg []byte) error {
|
|
switch err := c.writeToKernel(msg); err {
|
|
case syscall.ENOENT:
|
|
return ErrNotCached
|
|
default:
|
|
return err
|
|
}
|
|
}
|
|
|
|
// InvalidateNode invalidates the kernel cache of the attributes and a
|
|
// range of the data of a node.
|
|
//
|
|
// Giving offset 0 and size -1 means all data. To invalidate just the
|
|
// attributes, give offset 0 and size 0.
|
|
//
|
|
// Returns ErrNotCached if the kernel is not currently caching the
|
|
// node.
|
|
func (c *Conn) InvalidateNode(nodeID NodeID, off int64, size int64) error {
|
|
buf := newBuffer(unsafe.Sizeof(notifyInvalInodeOut{}))
|
|
h := (*outHeader)(unsafe.Pointer(&buf[0]))
|
|
// h.Unique is 0
|
|
h.Error = notifyCodeInvalInode
|
|
out := (*notifyInvalInodeOut)(buf.alloc(unsafe.Sizeof(notifyInvalInodeOut{})))
|
|
out.Ino = uint64(nodeID)
|
|
out.Off = off
|
|
out.Len = size
|
|
return c.sendInvalidate(buf)
|
|
}
|
|
|
|
// InvalidateEntry invalidates the kernel cache of the directory entry
|
|
// identified by parent directory node ID and entry basename.
|
|
//
|
|
// Kernel may or may not cache directory listings. To invalidate
|
|
// those, use InvalidateNode to invalidate all of the data for a
|
|
// directory. (As of 2015-06, Linux FUSE does not cache directory
|
|
// listings.)
|
|
//
|
|
// Returns ErrNotCached if the kernel is not currently caching the
|
|
// node.
|
|
func (c *Conn) InvalidateEntry(parent NodeID, name string) error {
|
|
const maxUint32 = ^uint32(0)
|
|
if uint64(len(name)) > uint64(maxUint32) {
|
|
// very unlikely, but we don't want to silently truncate
|
|
return syscall.ENAMETOOLONG
|
|
}
|
|
buf := newBuffer(unsafe.Sizeof(notifyInvalEntryOut{}) + uintptr(len(name)) + 1)
|
|
h := (*outHeader)(unsafe.Pointer(&buf[0]))
|
|
// h.Unique is 0
|
|
h.Error = notifyCodeInvalEntry
|
|
out := (*notifyInvalEntryOut)(buf.alloc(unsafe.Sizeof(notifyInvalEntryOut{})))
|
|
out.Parent = uint64(parent)
|
|
out.Namelen = uint32(len(name))
|
|
buf = append(buf, name...)
|
|
buf = append(buf, '\x00')
|
|
return c.sendInvalidate(buf)
|
|
}
|
|
|
|
// An InitRequest is the first request sent on a FUSE file system.
|
|
type InitRequest struct {
|
|
Header `json:"-"`
|
|
Kernel Protocol
|
|
// Maximum readahead in bytes that the kernel plans to use.
|
|
MaxReadahead uint32
|
|
Flags InitFlags
|
|
}
|
|
|
|
var _ = Request(&InitRequest{})
|
|
|
|
func (r *InitRequest) String() string {
|
|
return fmt.Sprintf("Init [%v] %v ra=%d fl=%v", &r.Header, r.Kernel, r.MaxReadahead, r.Flags)
|
|
}
|
|
|
|
// An InitResponse is the response to an InitRequest.
|
|
type InitResponse struct {
|
|
Library Protocol
|
|
// Maximum readahead in bytes that the kernel can use. Ignored if
|
|
// greater than InitRequest.MaxReadahead.
|
|
MaxReadahead uint32
|
|
Flags InitFlags
|
|
// Maximum size of a single write operation.
|
|
// Linux enforces a minimum of 4 KiB.
|
|
MaxWrite uint32
|
|
}
|
|
|
|
func (r *InitResponse) String() string {
|
|
return fmt.Sprintf("Init %v ra=%d fl=%v w=%d", r.Library, r.MaxReadahead, r.Flags, r.MaxWrite)
|
|
}
|
|
|
|
// Respond replies to the request with the given response.
|
|
func (r *InitRequest) Respond(resp *InitResponse) {
|
|
buf := newBuffer(unsafe.Sizeof(initOut{}))
|
|
out := (*initOut)(buf.alloc(unsafe.Sizeof(initOut{})))
|
|
out.Major = resp.Library.Major
|
|
out.Minor = resp.Library.Minor
|
|
out.MaxReadahead = resp.MaxReadahead
|
|
out.Flags = uint32(resp.Flags)
|
|
out.MaxWrite = resp.MaxWrite
|
|
|
|
// MaxWrite larger than our receive buffer would just lead to
|
|
// errors on large writes.
|
|
if out.MaxWrite > maxWrite {
|
|
out.MaxWrite = maxWrite
|
|
}
|
|
r.respond(buf)
|
|
}
|
|
|
|
// A StatfsRequest requests information about the mounted file system.
|
|
type StatfsRequest struct {
|
|
Header `json:"-"`
|
|
}
|
|
|
|
var _ = Request(&StatfsRequest{})
|
|
|
|
func (r *StatfsRequest) String() string {
|
|
return fmt.Sprintf("Statfs [%s]", &r.Header)
|
|
}
|
|
|
|
// Respond replies to the request with the given response.
|
|
func (r *StatfsRequest) Respond(resp *StatfsResponse) {
|
|
buf := newBuffer(unsafe.Sizeof(statfsOut{}))
|
|
out := (*statfsOut)(buf.alloc(unsafe.Sizeof(statfsOut{})))
|
|
out.St = kstatfs{
|
|
Blocks: resp.Blocks,
|
|
Bfree: resp.Bfree,
|
|
Bavail: resp.Bavail,
|
|
Files: resp.Files,
|
|
Ffree: resp.Ffree,
|
|
Bsize: resp.Bsize,
|
|
Namelen: resp.Namelen,
|
|
Frsize: resp.Frsize,
|
|
}
|
|
r.respond(buf)
|
|
}
|
|
|
|
// A StatfsResponse is the response to a StatfsRequest.
|
|
type StatfsResponse struct {
|
|
Blocks uint64 // Total data blocks in file system.
|
|
Bfree uint64 // Free blocks in file system.
|
|
Bavail uint64 // Free blocks in file system if you're not root.
|
|
Files uint64 // Total files in file system.
|
|
Ffree uint64 // Free files in file system.
|
|
Bsize uint32 // Block size
|
|
Namelen uint32 // Maximum file name length?
|
|
Frsize uint32 // Fragment size, smallest addressable data size in the file system.
|
|
}
|
|
|
|
func (r *StatfsResponse) String() string {
|
|
return fmt.Sprintf("Statfs blocks=%d/%d/%d files=%d/%d bsize=%d frsize=%d namelen=%d",
|
|
r.Bavail, r.Bfree, r.Blocks,
|
|
r.Ffree, r.Files,
|
|
r.Bsize,
|
|
r.Frsize,
|
|
r.Namelen,
|
|
)
|
|
}
|
|
|
|
// An AccessRequest asks whether the file can be accessed
|
|
// for the purpose specified by the mask.
|
|
type AccessRequest struct {
|
|
Header `json:"-"`
|
|
Mask uint32
|
|
}
|
|
|
|
var _ = Request(&AccessRequest{})
|
|
|
|
func (r *AccessRequest) String() string {
|
|
return fmt.Sprintf("Access [%s] mask=%#x", &r.Header, r.Mask)
|
|
}
|
|
|
|
// Respond replies to the request indicating that access is allowed.
|
|
// To deny access, use RespondError.
|
|
func (r *AccessRequest) Respond() {
|
|
buf := newBuffer(0)
|
|
r.respond(buf)
|
|
}
|
|
|
|
// An Attr is the metadata for a single file or directory.
|
|
type Attr struct {
|
|
Valid time.Duration // how long Attr can be cached
|
|
|
|
Inode uint64 // inode number
|
|
Size uint64 // size in bytes
|
|
Blocks uint64 // size in 512-byte units
|
|
Atime time.Time // time of last access
|
|
Mtime time.Time // time of last modification
|
|
Ctime time.Time // time of last inode change
|
|
Crtime time.Time // time of creation (OS X only)
|
|
Mode os.FileMode // file mode
|
|
Nlink uint32 // number of links (usually 1)
|
|
Uid uint32 // owner uid
|
|
Gid uint32 // group gid
|
|
Rdev uint32 // device numbers
|
|
Flags uint32 // chflags(2) flags (OS X only)
|
|
BlockSize uint32 // preferred blocksize for filesystem I/O
|
|
}
|
|
|
|
func (a Attr) String() string {
|
|
return fmt.Sprintf("valid=%v ino=%v size=%d mode=%v", a.Valid, a.Inode, a.Size, a.Mode)
|
|
}
|
|
|
|
func unix(t time.Time) (sec uint64, nsec uint32) {
|
|
nano := t.UnixNano()
|
|
sec = uint64(nano / 1e9)
|
|
nsec = uint32(nano % 1e9)
|
|
return
|
|
}
|
|
|
|
func (a *Attr) attr(out *attr, proto Protocol) {
|
|
out.Ino = a.Inode
|
|
out.Size = a.Size
|
|
out.Blocks = a.Blocks
|
|
out.Atime, out.AtimeNsec = unix(a.Atime)
|
|
out.Mtime, out.MtimeNsec = unix(a.Mtime)
|
|
out.Ctime, out.CtimeNsec = unix(a.Ctime)
|
|
out.SetCrtime(unix(a.Crtime))
|
|
out.Mode = uint32(a.Mode) & 0777
|
|
switch {
|
|
default:
|
|
out.Mode |= syscall.S_IFREG
|
|
case a.Mode&os.ModeDir != 0:
|
|
out.Mode |= syscall.S_IFDIR
|
|
case a.Mode&os.ModeDevice != 0:
|
|
if a.Mode&os.ModeCharDevice != 0 {
|
|
out.Mode |= syscall.S_IFCHR
|
|
} else {
|
|
out.Mode |= syscall.S_IFBLK
|
|
}
|
|
case a.Mode&os.ModeNamedPipe != 0:
|
|
out.Mode |= syscall.S_IFIFO
|
|
case a.Mode&os.ModeSymlink != 0:
|
|
out.Mode |= syscall.S_IFLNK
|
|
case a.Mode&os.ModeSocket != 0:
|
|
out.Mode |= syscall.S_IFSOCK
|
|
}
|
|
if a.Mode&os.ModeSetuid != 0 {
|
|
out.Mode |= syscall.S_ISUID
|
|
}
|
|
if a.Mode&os.ModeSetgid != 0 {
|
|
out.Mode |= syscall.S_ISGID
|
|
}
|
|
out.Nlink = a.Nlink
|
|
out.Uid = a.Uid
|
|
out.Gid = a.Gid
|
|
out.Rdev = a.Rdev
|
|
out.SetFlags(a.Flags)
|
|
if proto.GE(Protocol{7, 9}) {
|
|
out.Blksize = a.BlockSize
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// A GetattrRequest asks for the metadata for the file denoted by r.Node.
|
|
type GetattrRequest struct {
|
|
Header `json:"-"`
|
|
Flags GetattrFlags
|
|
Handle HandleID
|
|
}
|
|
|
|
var _ = Request(&GetattrRequest{})
|
|
|
|
func (r *GetattrRequest) String() string {
|
|
return fmt.Sprintf("Getattr [%s] %v fl=%v", &r.Header, r.Handle, r.Flags)
|
|
}
|
|
|
|
// Respond replies to the request with the given response.
|
|
func (r *GetattrRequest) Respond(resp *GetattrResponse) {
|
|
size := attrOutSize(r.Header.Conn.proto)
|
|
buf := newBuffer(size)
|
|
out := (*attrOut)(buf.alloc(size))
|
|
out.AttrValid = uint64(resp.Attr.Valid / time.Second)
|
|
out.AttrValidNsec = uint32(resp.Attr.Valid % time.Second / time.Nanosecond)
|
|
resp.Attr.attr(&out.Attr, r.Header.Conn.proto)
|
|
r.respond(buf)
|
|
}
|
|
|
|
// A GetattrResponse is the response to a GetattrRequest.
|
|
type GetattrResponse struct {
|
|
Attr Attr // file attributes
|
|
}
|
|
|
|
func (r *GetattrResponse) String() string {
|
|
return fmt.Sprintf("Getattr %v", r.Attr)
|
|
}
|
|
|
|
// A GetxattrRequest asks for the extended attributes associated with r.Node.
|
|
type GetxattrRequest struct {
|
|
Header `json:"-"`
|
|
|
|
// Maximum size to return.
|
|
Size uint32
|
|
|
|
// Name of the attribute requested.
|
|
Name string
|
|
|
|
// Offset within extended attributes.
|
|
//
|
|
// Only valid for OS X, and then only with the resource fork
|
|
// attribute.
|
|
Position uint32
|
|
}
|
|
|
|
var _ = Request(&GetxattrRequest{})
|
|
|
|
func (r *GetxattrRequest) String() string {
|
|
return fmt.Sprintf("Getxattr [%s] %q %d @%d", &r.Header, r.Name, r.Size, r.Position)
|
|
}
|
|
|
|
// Respond replies to the request with the given response.
|
|
func (r *GetxattrRequest) Respond(resp *GetxattrResponse) {
|
|
if r.Size == 0 {
|
|
buf := newBuffer(unsafe.Sizeof(getxattrOut{}))
|
|
out := (*getxattrOut)(buf.alloc(unsafe.Sizeof(getxattrOut{})))
|
|
out.Size = uint32(len(resp.Xattr))
|
|
r.respond(buf)
|
|
} else {
|
|
buf := newBuffer(uintptr(len(resp.Xattr)))
|
|
buf = append(buf, resp.Xattr...)
|
|
r.respond(buf)
|
|
}
|
|
}
|
|
|
|
// A GetxattrResponse is the response to a GetxattrRequest.
|
|
type GetxattrResponse struct {
|
|
Xattr []byte
|
|
}
|
|
|
|
func (r *GetxattrResponse) String() string {
|
|
return fmt.Sprintf("Getxattr %x", r.Xattr)
|
|
}
|
|
|
|
// A ListxattrRequest asks to list the extended attributes associated with r.Node.
|
|
type ListxattrRequest struct {
|
|
Header `json:"-"`
|
|
Size uint32 // maximum size to return
|
|
Position uint32 // offset within attribute list
|
|
}
|
|
|
|
var _ = Request(&ListxattrRequest{})
|
|
|
|
func (r *ListxattrRequest) String() string {
|
|
return fmt.Sprintf("Listxattr [%s] %d @%d", &r.Header, r.Size, r.Position)
|
|
}
|
|
|
|
// Respond replies to the request with the given response.
|
|
func (r *ListxattrRequest) Respond(resp *ListxattrResponse) {
|
|
if r.Size == 0 {
|
|
buf := newBuffer(unsafe.Sizeof(getxattrOut{}))
|
|
out := (*getxattrOut)(buf.alloc(unsafe.Sizeof(getxattrOut{})))
|
|
out.Size = uint32(len(resp.Xattr))
|
|
r.respond(buf)
|
|
} else {
|
|
buf := newBuffer(uintptr(len(resp.Xattr)))
|
|
buf = append(buf, resp.Xattr...)
|
|
r.respond(buf)
|
|
}
|
|
}
|
|
|
|
// A ListxattrResponse is the response to a ListxattrRequest.
|
|
type ListxattrResponse struct {
|
|
Xattr []byte
|
|
}
|
|
|
|
func (r *ListxattrResponse) String() string {
|
|
return fmt.Sprintf("Listxattr %x", r.Xattr)
|
|
}
|
|
|
|
// Append adds an extended attribute name to the response.
|
|
func (r *ListxattrResponse) Append(names ...string) {
|
|
for _, name := range names {
|
|
r.Xattr = append(r.Xattr, name...)
|
|
r.Xattr = append(r.Xattr, '\x00')
|
|
}
|
|
}
|
|
|
|
// A RemovexattrRequest asks to remove an extended attribute associated with r.Node.
|
|
type RemovexattrRequest struct {
|
|
Header `json:"-"`
|
|
Name string // name of extended attribute
|
|
}
|
|
|
|
var _ = Request(&RemovexattrRequest{})
|
|
|
|
func (r *RemovexattrRequest) String() string {
|
|
return fmt.Sprintf("Removexattr [%s] %q", &r.Header, r.Name)
|
|
}
|
|
|
|
// Respond replies to the request, indicating that the attribute was removed.
|
|
func (r *RemovexattrRequest) Respond() {
|
|
buf := newBuffer(0)
|
|
r.respond(buf)
|
|
}
|
|
|
|
// A SetxattrRequest asks to set an extended attribute associated with a file.
|
|
type SetxattrRequest struct {
|
|
Header `json:"-"`
|
|
|
|
// Flags can make the request fail if attribute does/not already
|
|
// exist. Unfortunately, the constants are platform-specific and
|
|
// not exposed by Go1.2. Look for XATTR_CREATE, XATTR_REPLACE.
|
|
//
|
|
// TODO improve this later
|
|
//
|
|
// TODO XATTR_CREATE and exist -> EEXIST
|
|
//
|
|
// TODO XATTR_REPLACE and not exist -> ENODATA
|
|
Flags uint32
|
|
|
|
// Offset within extended attributes.
|
|
//
|
|
// Only valid for OS X, and then only with the resource fork
|
|
// attribute.
|
|
Position uint32
|
|
|
|
Name string
|
|
Xattr []byte
|
|
}
|
|
|
|
var _ = Request(&SetxattrRequest{})
|
|
|
|
func trunc(b []byte, max int) ([]byte, string) {
|
|
if len(b) > max {
|
|
return b[:max], "..."
|
|
}
|
|
return b, ""
|
|
}
|
|
|
|
func (r *SetxattrRequest) String() string {
|
|
xattr, tail := trunc(r.Xattr, 16)
|
|
return fmt.Sprintf("Setxattr [%s] %q %x%s fl=%v @%#x", &r.Header, r.Name, xattr, tail, r.Flags, r.Position)
|
|
}
|
|
|
|
// Respond replies to the request, indicating that the extended attribute was set.
|
|
func (r *SetxattrRequest) Respond() {
|
|
buf := newBuffer(0)
|
|
r.respond(buf)
|
|
}
|
|
|
|
// A LookupRequest asks to look up the given name in the directory named by r.Node.
|
|
type LookupRequest struct {
|
|
Header `json:"-"`
|
|
Name string
|
|
}
|
|
|
|
var _ = Request(&LookupRequest{})
|
|
|
|
func (r *LookupRequest) String() string {
|
|
return fmt.Sprintf("Lookup [%s] %q", &r.Header, r.Name)
|
|
}
|
|
|
|
// Respond replies to the request with the given response.
|
|
func (r *LookupRequest) Respond(resp *LookupResponse) {
|
|
size := entryOutSize(r.Header.Conn.proto)
|
|
buf := newBuffer(size)
|
|
out := (*entryOut)(buf.alloc(size))
|
|
out.Nodeid = uint64(resp.Node)
|
|
out.Generation = resp.Generation
|
|
out.EntryValid = uint64(resp.EntryValid / time.Second)
|
|
out.EntryValidNsec = uint32(resp.EntryValid % time.Second / time.Nanosecond)
|
|
out.AttrValid = uint64(resp.Attr.Valid / time.Second)
|
|
out.AttrValidNsec = uint32(resp.Attr.Valid % time.Second / time.Nanosecond)
|
|
resp.Attr.attr(&out.Attr, r.Header.Conn.proto)
|
|
r.respond(buf)
|
|
}
|
|
|
|
// A LookupResponse is the response to a LookupRequest.
|
|
type LookupResponse struct {
|
|
Node NodeID
|
|
Generation uint64
|
|
EntryValid time.Duration
|
|
Attr Attr
|
|
}
|
|
|
|
func (r *LookupResponse) string() string {
|
|
return fmt.Sprintf("%v gen=%d valid=%v attr={%v}", r.Node, r.Generation, r.EntryValid, r.Attr)
|
|
}
|
|
|
|
func (r *LookupResponse) String() string {
|
|
return fmt.Sprintf("Lookup %s", r.string())
|
|
}
|
|
|
|
// An OpenRequest asks to open a file or directory
|
|
type OpenRequest struct {
|
|
Header `json:"-"`
|
|
Dir bool // is this Opendir?
|
|
Flags OpenFlags
|
|
}
|
|
|
|
var _ = Request(&OpenRequest{})
|
|
|
|
func (r *OpenRequest) String() string {
|
|
return fmt.Sprintf("Open [%s] dir=%v fl=%v", &r.Header, r.Dir, r.Flags)
|
|
}
|
|
|
|
// Respond replies to the request with the given response.
|
|
func (r *OpenRequest) Respond(resp *OpenResponse) {
|
|
buf := newBuffer(unsafe.Sizeof(openOut{}))
|
|
out := (*openOut)(buf.alloc(unsafe.Sizeof(openOut{})))
|
|
out.Fh = uint64(resp.Handle)
|
|
out.OpenFlags = uint32(resp.Flags)
|
|
r.respond(buf)
|
|
}
|
|
|
|
// A OpenResponse is the response to a OpenRequest.
|
|
type OpenResponse struct {
|
|
Handle HandleID
|
|
Flags OpenResponseFlags
|
|
}
|
|
|
|
func (r *OpenResponse) string() string {
|
|
return fmt.Sprintf("%v fl=%v", r.Handle, r.Flags)
|
|
}
|
|
|
|
func (r *OpenResponse) String() string {
|
|
return fmt.Sprintf("Open %s", r.string())
|
|
}
|
|
|
|
// A CreateRequest asks to create and open a file (not a directory).
|
|
type CreateRequest struct {
|
|
Header `json:"-"`
|
|
Name string
|
|
Flags OpenFlags
|
|
Mode os.FileMode
|
|
// Umask of the request. Not supported on OS X.
|
|
Umask os.FileMode
|
|
}
|
|
|
|
var _ = Request(&CreateRequest{})
|
|
|
|
func (r *CreateRequest) String() string {
|
|
return fmt.Sprintf("Create [%s] %q fl=%v mode=%v umask=%v", &r.Header, r.Name, r.Flags, r.Mode, r.Umask)
|
|
}
|
|
|
|
// Respond replies to the request with the given response.
|
|
func (r *CreateRequest) Respond(resp *CreateResponse) {
|
|
eSize := entryOutSize(r.Header.Conn.proto)
|
|
buf := newBuffer(eSize + unsafe.Sizeof(openOut{}))
|
|
|
|
e := (*entryOut)(buf.alloc(eSize))
|
|
e.Nodeid = uint64(resp.Node)
|
|
e.Generation = resp.Generation
|
|
e.EntryValid = uint64(resp.EntryValid / time.Second)
|
|
e.EntryValidNsec = uint32(resp.EntryValid % time.Second / time.Nanosecond)
|
|
e.AttrValid = uint64(resp.Attr.Valid / time.Second)
|
|
e.AttrValidNsec = uint32(resp.Attr.Valid % time.Second / time.Nanosecond)
|
|
resp.Attr.attr(&e.Attr, r.Header.Conn.proto)
|
|
|
|
o := (*openOut)(buf.alloc(unsafe.Sizeof(openOut{})))
|
|
o.Fh = uint64(resp.Handle)
|
|
o.OpenFlags = uint32(resp.Flags)
|
|
|
|
r.respond(buf)
|
|
}
|
|
|
|
// A CreateResponse is the response to a CreateRequest.
|
|
// It describes the created node and opened handle.
|
|
type CreateResponse struct {
|
|
LookupResponse
|
|
OpenResponse
|
|
}
|
|
|
|
func (r *CreateResponse) String() string {
|
|
return fmt.Sprintf("Create {%s} {%s}", r.LookupResponse.string(), r.OpenResponse.string())
|
|
}
|
|
|
|
// A MkdirRequest asks to create (but not open) a directory.
|
|
type MkdirRequest struct {
|
|
Header `json:"-"`
|
|
Name string
|
|
Mode os.FileMode
|
|
// Umask of the request. Not supported on OS X.
|
|
Umask os.FileMode
|
|
}
|
|
|
|
var _ = Request(&MkdirRequest{})
|
|
|
|
func (r *MkdirRequest) String() string {
|
|
return fmt.Sprintf("Mkdir [%s] %q mode=%v umask=%v", &r.Header, r.Name, r.Mode, r.Umask)
|
|
}
|
|
|
|
// Respond replies to the request with the given response.
|
|
func (r *MkdirRequest) Respond(resp *MkdirResponse) {
|
|
size := entryOutSize(r.Header.Conn.proto)
|
|
buf := newBuffer(size)
|
|
out := (*entryOut)(buf.alloc(size))
|
|
out.Nodeid = uint64(resp.Node)
|
|
out.Generation = resp.Generation
|
|
out.EntryValid = uint64(resp.EntryValid / time.Second)
|
|
out.EntryValidNsec = uint32(resp.EntryValid % time.Second / time.Nanosecond)
|
|
out.AttrValid = uint64(resp.Attr.Valid / time.Second)
|
|
out.AttrValidNsec = uint32(resp.Attr.Valid % time.Second / time.Nanosecond)
|
|
resp.Attr.attr(&out.Attr, r.Header.Conn.proto)
|
|
r.respond(buf)
|
|
}
|
|
|
|
// A MkdirResponse is the response to a MkdirRequest.
|
|
type MkdirResponse struct {
|
|
LookupResponse
|
|
}
|
|
|
|
func (r *MkdirResponse) String() string {
|
|
return fmt.Sprintf("Mkdir %v", r.LookupResponse.string())
|
|
}
|
|
|
|
// A ReadRequest asks to read from an open file.
|
|
type ReadRequest struct {
|
|
Header `json:"-"`
|
|
Dir bool // is this Readdir?
|
|
Handle HandleID
|
|
Offset int64
|
|
Size int
|
|
Flags ReadFlags
|
|
LockOwner uint64
|
|
FileFlags OpenFlags
|
|
}
|
|
|
|
var _ = Request(&ReadRequest{})
|
|
|
|
func (r *ReadRequest) String() string {
|
|
return fmt.Sprintf("Read [%s] %v %d @%#x dir=%v fl=%v lock=%d ffl=%v", &r.Header, r.Handle, r.Size, r.Offset, r.Dir, r.Flags, r.LockOwner, r.FileFlags)
|
|
}
|
|
|
|
// Respond replies to the request with the given response.
|
|
func (r *ReadRequest) Respond(resp *ReadResponse) {
|
|
buf := newBuffer(uintptr(len(resp.Data)))
|
|
buf = append(buf, resp.Data...)
|
|
r.respond(buf)
|
|
}
|
|
|
|
// A ReadResponse is the response to a ReadRequest.
|
|
type ReadResponse struct {
|
|
Data []byte
|
|
}
|
|
|
|
func (r *ReadResponse) String() string {
|
|
return fmt.Sprintf("Read %d", len(r.Data))
|
|
}
|
|
|
|
type jsonReadResponse struct {
|
|
Len uint64
|
|
}
|
|
|
|
func (r *ReadResponse) MarshalJSON() ([]byte, error) {
|
|
j := jsonReadResponse{
|
|
Len: uint64(len(r.Data)),
|
|
}
|
|
return json.Marshal(j)
|
|
}
|
|
|
|
// A ReleaseRequest asks to release (close) an open file handle.
|
|
type ReleaseRequest struct {
|
|
Header `json:"-"`
|
|
Dir bool // is this Releasedir?
|
|
Handle HandleID
|
|
Flags OpenFlags // flags from OpenRequest
|
|
ReleaseFlags ReleaseFlags
|
|
LockOwner uint32
|
|
}
|
|
|
|
var _ = Request(&ReleaseRequest{})
|
|
|
|
func (r *ReleaseRequest) String() string {
|
|
return fmt.Sprintf("Release [%s] %v fl=%v rfl=%v owner=%#x", &r.Header, r.Handle, r.Flags, r.ReleaseFlags, r.LockOwner)
|
|
}
|
|
|
|
// Respond replies to the request, indicating that the handle has been released.
|
|
func (r *ReleaseRequest) Respond() {
|
|
buf := newBuffer(0)
|
|
r.respond(buf)
|
|
}
|
|
|
|
// A DestroyRequest is sent by the kernel when unmounting the file system.
|
|
// No more requests will be received after this one, but it should still be
|
|
// responded to.
|
|
type DestroyRequest struct {
|
|
Header `json:"-"`
|
|
}
|
|
|
|
var _ = Request(&DestroyRequest{})
|
|
|
|
func (r *DestroyRequest) String() string {
|
|
return fmt.Sprintf("Destroy [%s]", &r.Header)
|
|
}
|
|
|
|
// Respond replies to the request.
|
|
func (r *DestroyRequest) Respond() {
|
|
buf := newBuffer(0)
|
|
r.respond(buf)
|
|
}
|
|
|
|
// A ForgetRequest is sent by the kernel when forgetting about r.Node
|
|
// as returned by r.N lookup requests.
|
|
type ForgetRequest struct {
|
|
Header `json:"-"`
|
|
N uint64
|
|
}
|
|
|
|
var _ = Request(&ForgetRequest{})
|
|
|
|
func (r *ForgetRequest) String() string {
|
|
return fmt.Sprintf("Forget [%s] %d", &r.Header, r.N)
|
|
}
|
|
|
|
// Respond replies to the request, indicating that the forgetfulness has been recorded.
|
|
func (r *ForgetRequest) Respond() {
|
|
// Don't reply to forget messages.
|
|
r.noResponse()
|
|
}
|
|
|
|
// A Dirent represents a single directory entry.
|
|
type Dirent struct {
|
|
// Inode this entry names.
|
|
Inode uint64
|
|
|
|
// Type of the entry, for example DT_File.
|
|
//
|
|
// Setting this is optional. The zero value (DT_Unknown) means
|
|
// callers will just need to do a Getattr when the type is
|
|
// needed. Providing a type can speed up operations
|
|
// significantly.
|
|
Type DirentType
|
|
|
|
// Name of the entry
|
|
Name string
|
|
}
|
|
|
|
// Type of an entry in a directory listing.
|
|
type DirentType uint32
|
|
|
|
const (
|
|
// These don't quite match os.FileMode; especially there's an
|
|
// explicit unknown, instead of zero value meaning file. They
|
|
// are also not quite syscall.DT_*; nothing says the FUSE
|
|
// protocol follows those, and even if they were, we don't
|
|
// want each fs to fiddle with syscall.
|
|
|
|
// The shift by 12 is hardcoded in the FUSE userspace
|
|
// low-level C library, so it's safe here.
|
|
|
|
DT_Unknown DirentType = 0
|
|
DT_Socket DirentType = syscall.S_IFSOCK >> 12
|
|
DT_Link DirentType = syscall.S_IFLNK >> 12
|
|
DT_File DirentType = syscall.S_IFREG >> 12
|
|
DT_Block DirentType = syscall.S_IFBLK >> 12
|
|
DT_Dir DirentType = syscall.S_IFDIR >> 12
|
|
DT_Char DirentType = syscall.S_IFCHR >> 12
|
|
DT_FIFO DirentType = syscall.S_IFIFO >> 12
|
|
)
|
|
|
|
func (t DirentType) String() string {
|
|
switch t {
|
|
case DT_Unknown:
|
|
return "unknown"
|
|
case DT_Socket:
|
|
return "socket"
|
|
case DT_Link:
|
|
return "link"
|
|
case DT_File:
|
|
return "file"
|
|
case DT_Block:
|
|
return "block"
|
|
case DT_Dir:
|
|
return "dir"
|
|
case DT_Char:
|
|
return "char"
|
|
case DT_FIFO:
|
|
return "fifo"
|
|
}
|
|
return "invalid"
|
|
}
|
|
|
|
// AppendDirent appends the encoded form of a directory entry to data
|
|
// and returns the resulting slice.
|
|
func AppendDirent(data []byte, dir Dirent) []byte {
|
|
de := dirent{
|
|
Ino: dir.Inode,
|
|
Namelen: uint32(len(dir.Name)),
|
|
Type: uint32(dir.Type),
|
|
}
|
|
de.Off = uint64(len(data) + direntSize + (len(dir.Name)+7)&^7)
|
|
data = append(data, (*[direntSize]byte)(unsafe.Pointer(&de))[:]...)
|
|
data = append(data, dir.Name...)
|
|
n := direntSize + uintptr(len(dir.Name))
|
|
if n%8 != 0 {
|
|
var pad [8]byte
|
|
data = append(data, pad[:8-n%8]...)
|
|
}
|
|
return data
|
|
}
|
|
|
|
// A WriteRequest asks to write to an open file.
|
|
type WriteRequest struct {
|
|
Header
|
|
Handle HandleID
|
|
Offset int64
|
|
Data []byte
|
|
Flags WriteFlags
|
|
LockOwner uint64
|
|
FileFlags OpenFlags
|
|
}
|
|
|
|
var _ = Request(&WriteRequest{})
|
|
|
|
func (r *WriteRequest) String() string {
|
|
return fmt.Sprintf("Write [%s] %v %d @%d fl=%v lock=%d ffl=%v", &r.Header, r.Handle, len(r.Data), r.Offset, r.Flags, r.LockOwner, r.FileFlags)
|
|
}
|
|
|
|
type jsonWriteRequest struct {
|
|
Handle HandleID
|
|
Offset int64
|
|
Len uint64
|
|
Flags WriteFlags
|
|
}
|
|
|
|
func (r *WriteRequest) MarshalJSON() ([]byte, error) {
|
|
j := jsonWriteRequest{
|
|
Handle: r.Handle,
|
|
Offset: r.Offset,
|
|
Len: uint64(len(r.Data)),
|
|
Flags: r.Flags,
|
|
}
|
|
return json.Marshal(j)
|
|
}
|
|
|
|
// Respond replies to the request with the given response.
|
|
func (r *WriteRequest) Respond(resp *WriteResponse) {
|
|
buf := newBuffer(unsafe.Sizeof(writeOut{}))
|
|
out := (*writeOut)(buf.alloc(unsafe.Sizeof(writeOut{})))
|
|
out.Size = uint32(resp.Size)
|
|
r.respond(buf)
|
|
}
|
|
|
|
// A WriteResponse replies to a write indicating how many bytes were written.
|
|
type WriteResponse struct {
|
|
Size int
|
|
}
|
|
|
|
func (r *WriteResponse) String() string {
|
|
return fmt.Sprintf("Write %d", r.Size)
|
|
}
|
|
|
|
// A SetattrRequest asks to change one or more attributes associated with a file,
|
|
// as indicated by Valid.
|
|
type SetattrRequest struct {
|
|
Header `json:"-"`
|
|
Valid SetattrValid
|
|
Handle HandleID
|
|
Size uint64
|
|
Atime time.Time
|
|
Mtime time.Time
|
|
Mode os.FileMode
|
|
Uid uint32
|
|
Gid uint32
|
|
|
|
// OS X only
|
|
Bkuptime time.Time
|
|
Chgtime time.Time
|
|
Crtime time.Time
|
|
Flags uint32 // see chflags(2)
|
|
}
|
|
|
|
var _ = Request(&SetattrRequest{})
|
|
|
|
func (r *SetattrRequest) String() string {
|
|
var buf bytes.Buffer
|
|
fmt.Fprintf(&buf, "Setattr [%s]", &r.Header)
|
|
if r.Valid.Mode() {
|
|
fmt.Fprintf(&buf, " mode=%v", r.Mode)
|
|
}
|
|
if r.Valid.Uid() {
|
|
fmt.Fprintf(&buf, " uid=%d", r.Uid)
|
|
}
|
|
if r.Valid.Gid() {
|
|
fmt.Fprintf(&buf, " gid=%d", r.Gid)
|
|
}
|
|
if r.Valid.Size() {
|
|
fmt.Fprintf(&buf, " size=%d", r.Size)
|
|
}
|
|
if r.Valid.Atime() {
|
|
fmt.Fprintf(&buf, " atime=%v", r.Atime)
|
|
}
|
|
if r.Valid.AtimeNow() {
|
|
fmt.Fprintf(&buf, " atime=now")
|
|
}
|
|
if r.Valid.Mtime() {
|
|
fmt.Fprintf(&buf, " mtime=%v", r.Mtime)
|
|
}
|
|
if r.Valid.MtimeNow() {
|
|
fmt.Fprintf(&buf, " mtime=now")
|
|
}
|
|
if r.Valid.Handle() {
|
|
fmt.Fprintf(&buf, " handle=%v", r.Handle)
|
|
} else {
|
|
fmt.Fprintf(&buf, " handle=INVALID-%v", r.Handle)
|
|
}
|
|
if r.Valid.LockOwner() {
|
|
fmt.Fprintf(&buf, " lockowner")
|
|
}
|
|
if r.Valid.Crtime() {
|
|
fmt.Fprintf(&buf, " crtime=%v", r.Crtime)
|
|
}
|
|
if r.Valid.Chgtime() {
|
|
fmt.Fprintf(&buf, " chgtime=%v", r.Chgtime)
|
|
}
|
|
if r.Valid.Bkuptime() {
|
|
fmt.Fprintf(&buf, " bkuptime=%v", r.Bkuptime)
|
|
}
|
|
if r.Valid.Flags() {
|
|
fmt.Fprintf(&buf, " flags=%v", r.Flags)
|
|
}
|
|
return buf.String()
|
|
}
|
|
|
|
// Respond replies to the request with the given response,
|
|
// giving the updated attributes.
|
|
func (r *SetattrRequest) Respond(resp *SetattrResponse) {
|
|
size := attrOutSize(r.Header.Conn.proto)
|
|
buf := newBuffer(size)
|
|
out := (*attrOut)(buf.alloc(size))
|
|
out.AttrValid = uint64(resp.Attr.Valid / time.Second)
|
|
out.AttrValidNsec = uint32(resp.Attr.Valid % time.Second / time.Nanosecond)
|
|
resp.Attr.attr(&out.Attr, r.Header.Conn.proto)
|
|
r.respond(buf)
|
|
}
|
|
|
|
// A SetattrResponse is the response to a SetattrRequest.
|
|
type SetattrResponse struct {
|
|
Attr Attr // file attributes
|
|
}
|
|
|
|
func (r *SetattrResponse) String() string {
|
|
return fmt.Sprintf("Setattr %v", r.Attr)
|
|
}
|
|
|
|
// A FlushRequest asks for the current state of an open file to be flushed
|
|
// to storage, as when a file descriptor is being closed. A single opened Handle
|
|
// may receive multiple FlushRequests over its lifetime.
|
|
type FlushRequest struct {
|
|
Header `json:"-"`
|
|
Handle HandleID
|
|
Flags uint32
|
|
LockOwner uint64
|
|
}
|
|
|
|
var _ = Request(&FlushRequest{})
|
|
|
|
func (r *FlushRequest) String() string {
|
|
return fmt.Sprintf("Flush [%s] %v fl=%#x lk=%#x", &r.Header, r.Handle, r.Flags, r.LockOwner)
|
|
}
|
|
|
|
// Respond replies to the request, indicating that the flush succeeded.
|
|
func (r *FlushRequest) Respond() {
|
|
buf := newBuffer(0)
|
|
r.respond(buf)
|
|
}
|
|
|
|
// A RemoveRequest asks to remove a file or directory from the
|
|
// directory r.Node.
|
|
type RemoveRequest struct {
|
|
Header `json:"-"`
|
|
Name string // name of the entry to remove
|
|
Dir bool // is this rmdir?
|
|
}
|
|
|
|
var _ = Request(&RemoveRequest{})
|
|
|
|
func (r *RemoveRequest) String() string {
|
|
return fmt.Sprintf("Remove [%s] %q dir=%v", &r.Header, r.Name, r.Dir)
|
|
}
|
|
|
|
// Respond replies to the request, indicating that the file was removed.
|
|
func (r *RemoveRequest) Respond() {
|
|
buf := newBuffer(0)
|
|
r.respond(buf)
|
|
}
|
|
|
|
// A SymlinkRequest is a request to create a symlink making NewName point to Target.
|
|
type SymlinkRequest struct {
|
|
Header `json:"-"`
|
|
NewName, Target string
|
|
}
|
|
|
|
var _ = Request(&SymlinkRequest{})
|
|
|
|
func (r *SymlinkRequest) String() string {
|
|
return fmt.Sprintf("Symlink [%s] from %q to target %q", &r.Header, r.NewName, r.Target)
|
|
}
|
|
|
|
// Respond replies to the request, indicating that the symlink was created.
|
|
func (r *SymlinkRequest) Respond(resp *SymlinkResponse) {
|
|
size := entryOutSize(r.Header.Conn.proto)
|
|
buf := newBuffer(size)
|
|
out := (*entryOut)(buf.alloc(size))
|
|
out.Nodeid = uint64(resp.Node)
|
|
out.Generation = resp.Generation
|
|
out.EntryValid = uint64(resp.EntryValid / time.Second)
|
|
out.EntryValidNsec = uint32(resp.EntryValid % time.Second / time.Nanosecond)
|
|
out.AttrValid = uint64(resp.Attr.Valid / time.Second)
|
|
out.AttrValidNsec = uint32(resp.Attr.Valid % time.Second / time.Nanosecond)
|
|
resp.Attr.attr(&out.Attr, r.Header.Conn.proto)
|
|
r.respond(buf)
|
|
}
|
|
|
|
// A SymlinkResponse is the response to a SymlinkRequest.
|
|
type SymlinkResponse struct {
|
|
LookupResponse
|
|
}
|
|
|
|
func (r *SymlinkResponse) String() string {
|
|
return fmt.Sprintf("Symlink %v", r.LookupResponse.string())
|
|
}
|
|
|
|
// A ReadlinkRequest is a request to read a symlink's target.
|
|
type ReadlinkRequest struct {
|
|
Header `json:"-"`
|
|
}
|
|
|
|
var _ = Request(&ReadlinkRequest{})
|
|
|
|
func (r *ReadlinkRequest) String() string {
|
|
return fmt.Sprintf("Readlink [%s]", &r.Header)
|
|
}
|
|
|
|
func (r *ReadlinkRequest) Respond(target string) {
|
|
buf := newBuffer(uintptr(len(target)))
|
|
buf = append(buf, target...)
|
|
r.respond(buf)
|
|
}
|
|
|
|
// A LinkRequest is a request to create a hard link.
|
|
type LinkRequest struct {
|
|
Header `json:"-"`
|
|
OldNode NodeID
|
|
NewName string
|
|
}
|
|
|
|
var _ = Request(&LinkRequest{})
|
|
|
|
func (r *LinkRequest) String() string {
|
|
return fmt.Sprintf("Link [%s] node %d to %q", &r.Header, r.OldNode, r.NewName)
|
|
}
|
|
|
|
func (r *LinkRequest) Respond(resp *LookupResponse) {
|
|
size := entryOutSize(r.Header.Conn.proto)
|
|
buf := newBuffer(size)
|
|
out := (*entryOut)(buf.alloc(size))
|
|
out.Nodeid = uint64(resp.Node)
|
|
out.Generation = resp.Generation
|
|
out.EntryValid = uint64(resp.EntryValid / time.Second)
|
|
out.EntryValidNsec = uint32(resp.EntryValid % time.Second / time.Nanosecond)
|
|
out.AttrValid = uint64(resp.Attr.Valid / time.Second)
|
|
out.AttrValidNsec = uint32(resp.Attr.Valid % time.Second / time.Nanosecond)
|
|
resp.Attr.attr(&out.Attr, r.Header.Conn.proto)
|
|
r.respond(buf)
|
|
}
|
|
|
|
// A RenameRequest is a request to rename a file.
|
|
type RenameRequest struct {
|
|
Header `json:"-"`
|
|
NewDir NodeID
|
|
OldName, NewName string
|
|
}
|
|
|
|
var _ = Request(&RenameRequest{})
|
|
|
|
func (r *RenameRequest) String() string {
|
|
return fmt.Sprintf("Rename [%s] from %q to dirnode %v %q", &r.Header, r.OldName, r.NewDir, r.NewName)
|
|
}
|
|
|
|
func (r *RenameRequest) Respond() {
|
|
buf := newBuffer(0)
|
|
r.respond(buf)
|
|
}
|
|
|
|
type MknodRequest struct {
|
|
Header `json:"-"`
|
|
Name string
|
|
Mode os.FileMode
|
|
Rdev uint32
|
|
// Umask of the request. Not supported on OS X.
|
|
Umask os.FileMode
|
|
}
|
|
|
|
var _ = Request(&MknodRequest{})
|
|
|
|
func (r *MknodRequest) String() string {
|
|
return fmt.Sprintf("Mknod [%s] Name %q mode=%v umask=%v rdev=%d", &r.Header, r.Name, r.Mode, r.Umask, r.Rdev)
|
|
}
|
|
|
|
func (r *MknodRequest) Respond(resp *LookupResponse) {
|
|
size := entryOutSize(r.Header.Conn.proto)
|
|
buf := newBuffer(size)
|
|
out := (*entryOut)(buf.alloc(size))
|
|
out.Nodeid = uint64(resp.Node)
|
|
out.Generation = resp.Generation
|
|
out.EntryValid = uint64(resp.EntryValid / time.Second)
|
|
out.EntryValidNsec = uint32(resp.EntryValid % time.Second / time.Nanosecond)
|
|
out.AttrValid = uint64(resp.Attr.Valid / time.Second)
|
|
out.AttrValidNsec = uint32(resp.Attr.Valid % time.Second / time.Nanosecond)
|
|
resp.Attr.attr(&out.Attr, r.Header.Conn.proto)
|
|
r.respond(buf)
|
|
}
|
|
|
|
type FsyncRequest struct {
|
|
Header `json:"-"`
|
|
Handle HandleID
|
|
// TODO bit 1 is datasync, not well documented upstream
|
|
Flags uint32
|
|
Dir bool
|
|
}
|
|
|
|
var _ = Request(&FsyncRequest{})
|
|
|
|
func (r *FsyncRequest) String() string {
|
|
return fmt.Sprintf("Fsync [%s] Handle %v Flags %v", &r.Header, r.Handle, r.Flags)
|
|
}
|
|
|
|
func (r *FsyncRequest) Respond() {
|
|
buf := newBuffer(0)
|
|
r.respond(buf)
|
|
}
|
|
|
|
// An InterruptRequest is a request to interrupt another pending request. The
|
|
// response to that request should return an error status of EINTR.
|
|
type InterruptRequest struct {
|
|
Header `json:"-"`
|
|
IntrID RequestID // ID of the request to be interrupt.
|
|
}
|
|
|
|
var _ = Request(&InterruptRequest{})
|
|
|
|
func (r *InterruptRequest) Respond() {
|
|
// nothing to do here
|
|
r.noResponse()
|
|
}
|
|
|
|
func (r *InterruptRequest) String() string {
|
|
return fmt.Sprintf("Interrupt [%s] ID %v", &r.Header, r.IntrID)
|
|
}
|
|
|
|
// An ExchangeDataRequest is a request to exchange the contents of two
|
|
// files, while leaving most metadata untouched.
|
|
//
|
|
// This request comes from OS X exchangedata(2) and represents its
|
|
// specific semantics. Crucially, it is very different from Linux
|
|
// renameat(2) RENAME_EXCHANGE.
|
|
//
|
|
// https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man2/exchangedata.2.html
|
|
type ExchangeDataRequest struct {
|
|
Header `json:"-"`
|
|
OldDir, NewDir NodeID
|
|
OldName, NewName string
|
|
// TODO options
|
|
}
|
|
|
|
var _ = Request(&ExchangeDataRequest{})
|
|
|
|
func (r *ExchangeDataRequest) String() string {
|
|
// TODO options
|
|
return fmt.Sprintf("ExchangeData [%s] %v %q and %v %q", &r.Header, r.OldDir, r.OldName, r.NewDir, r.NewName)
|
|
}
|
|
|
|
func (r *ExchangeDataRequest) Respond() {
|
|
buf := newBuffer(0)
|
|
r.respond(buf)
|
|
}
|