vitalif
/
fusego
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

remove naked returns across the code base (#75) 

fixes #73
geesefs-0-30-9
Michael Stapelberg 2020-01-28 10:10:08 +01:00 committed by GitHub
parent 4898d79241
commit ae5da07e4c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
39 changed files with 678 additions and 929 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
connection.go
View File

@ -95,8 +95,8 @@ func newConnection(
cfg MountConfig,
debugLogger *log.Logger,
errorLogger *log.Logger,
dev *os.File) (c *Connection, err error) {
c = &Connection{
dev *os.File) (*Connection, error) {
c := &Connection{
cfg: cfg,
debugLogger: debugLogger,
errorLogger: errorLogger,
@ -105,30 +105,26 @@ func newConnection(
}
// Initialize.
err = c.Init()
if err != nil {
if err := c.Init(); err != nil {
c.close()
err = fmt.Errorf("Init: %v", err)
return
return nil, fmt.Errorf("Init: %v", err)
}
return
return c, nil
}
// Init performs the work necessary to cause the mount process to complete.
func (c *Connection) Init() (err error) {
func (c *Connection) Init() error {
// Read the init op.
ctx, op, err := c.ReadOp()
if err != nil {
err = fmt.Errorf("Reading init op: %v", err)
return
return fmt.Errorf("Reading init op: %v", err)
}
initOp, ok := op.(*initOp)
if !ok {
c.Reply(ctx, syscall.EPROTO)
err = fmt.Errorf("Expected *initOp, got %T", op)
return
return fmt.Errorf("Expected *initOp, got %T", op)
}
// Make sure the protocol version spoken by the kernel is new enough.
@ -139,8 +135,7 @@ func (c *Connection) Init() (err error) {
if initOp.Kernel.LT(min) {
c.Reply(ctx, syscall.EPROTO)
err = fmt.Errorf("Version too old: %v", initOp.Kernel)
return
return fmt.Errorf("Version too old: %v", initOp.Kernel)
}
// Downgrade our protocol if necessary.
@ -169,7 +164,7 @@ func (c *Connection) Init() (err error) {
}
c.Reply(ctx, nil)
return
return nil
}
// Log information for an operation with the given ID. calldepth is the depth
@ -228,9 +223,9 @@ func (c *Connection) recordCancelFunc(
// LOCKS_EXCLUDED(c.mu)
func (c *Connection) beginOp(
opCode uint32,
fuseID uint64) (ctx context.Context) {
fuseID uint64) context.Context {
// Start with the parent context.
ctx = c.cfg.OpContext
ctx := c.cfg.OpContext
// Set up a cancellation function.
//
@ -246,7 +241,7 @@ func (c *Connection) beginOp(
c.recordCancelFunc(fuseID, cancel)
}
return
return ctx
}
// Clean up all state associated with an op to which the user has responded,
@ -307,14 +302,14 @@ func (c *Connection) handleInterrupt(fuseID uint64) {
// Read the next message from the kernel. The message must later be destroyed
// using destroyInMessage.
func (c *Connection) readMessage() (m *buffer.InMessage, err error) {
func (c *Connection) readMessage() (*buffer.InMessage, error) {
// Allocate a message.
m = c.getInMessage()
m := c.getInMessage()
// Loop past transient errors.
for {
// Attempt a reaed.
err = m.Init(c.dev)
err := m.Init(c.dev)
// Special cases:
//
@ -336,28 +331,26 @@ func (c *Connection) readMessage() (m *buffer.InMessage, err error) {
if err != nil {
c.putInMessage(m)
m = nil
return
return nil, err
}
return
return m, nil
}
}
// Write the supplied message to the kernel.
func (c *Connection) writeMessage(msg []byte) (err error) {
func (c *Connection) writeMessage(msg []byte) error {
// Avoid the retry loop in os.File.Write.
n, err := syscall.Write(int(c.dev.Fd()), msg)
if err != nil {
return
return err
}
if n != len(msg) {
err = fmt.Errorf("Wrote %d bytes; expected %d", n, len(msg))
return
return fmt.Errorf("Wrote %d bytes; expected %d", n, len(msg))
}
return
return nil
}
// ReadOp consumes the next op from the kernel process, returning the op and a
@ -371,14 +364,13 @@ func (c *Connection) writeMessage(msg []byte) (err error) {
// /dev/fuse. It must not be called multiple times concurrently.
//
// LOCKS_EXCLUDED(c.mu)
func (c *Connection) ReadOp() (ctx context.Context, op interface{}, err error) {
func (c *Connection) ReadOp() (_ context.Context, op interface{}, _ error) {
// Keep going until we find a request we know how to convert.
for {
// Read the next message from the kernel.
var inMsg *buffer.InMessage
inMsg, err = c.readMessage()
inMsg, err := c.readMessage()
if err != nil {
return
return nil, nil, err
}
// Convert the message to an op.
@ -386,8 +378,7 @@ func (c *Connection) ReadOp() (ctx context.Context, op interface{}, err error) {
op, err = convertInMessage(inMsg, outMsg, c.protocol)
if err != nil {
c.putOutMessage(outMsg)
err = fmt.Errorf("convertInMessage: %v", err)
return
return nil, nil, fmt.Errorf("convertInMessage: %v", err)
}
// Choose an ID for this operation for the purposes of logging, and log it.
@ -402,11 +393,11 @@ func (c *Connection) ReadOp() (ctx context.Context, op interface{}, err error) {
}
// Set up a context that remembers information about this op.
ctx = c.beginOp(inMsg.Header().Opcode, inMsg.Header().Unique)
ctx := c.beginOp(inMsg.Header().Opcode, inMsg.Header().Unique)
ctx = context.WithValue(ctx, contextKey, opState{inMsg, outMsg, op})
// Return the op to the user.
return
return ctx, op, nil
}
}
@ -499,10 +490,9 @@ func (c *Connection) Reply(ctx context.Context, opErr error) {
// Close the connection. Must not be called until operations that were read
// from the connection have been responded to.
func (c *Connection) close() (err error) {
func (c *Connection) close() error {
// Posix doesn't say that close can be called concurrently with read or
// write, but luckily we exclude the possibility of a race by requiring the
// user to respond to all ops first.
err = c.dev.Close()
return
return c.dev.Close()
}

140
conversions.go
View File

@ -46,8 +46,7 @@ func convertInMessage(
buf := inMsg.ConsumeBytes(inMsg.Len())
n := len(buf)
if n == 0 || buf[n-1] != '\x00' {
err = errors.New("Corrupt OpLookup")
return
return nil, errors.New("Corrupt OpLookup")
}
o = &fuseops.LookUpInodeOp{
@ -64,8 +63,7 @@ func convertInMessage(
type input fusekernel.SetattrIn
in := (*input)(inMsg.Consume(unsafe.Sizeof(input{})))
if in == nil {
err = errors.New("Corrupt OpSetattr")
return
return nil, errors.New("Corrupt OpSetattr")
}
to := &fuseops.SetInodeAttributesOp{
@ -102,8 +100,7 @@ func convertInMessage(
type input fusekernel.ForgetIn
in := (*input)(inMsg.Consume(unsafe.Sizeof(input{})))
if in == nil {
err = errors.New("Corrupt OpForget")
return
return nil, errors.New("Corrupt OpForget")
}
o = &fuseops.ForgetInodeOp{
@ -114,15 +111,13 @@ func convertInMessage(
case fusekernel.OpMkdir:
in := (*fusekernel.MkdirIn)(inMsg.Consume(fusekernel.MkdirInSize(protocol)))
if in == nil {
err = errors.New("Corrupt OpMkdir")
return
return nil, errors.New("Corrupt OpMkdir")
}
name := inMsg.ConsumeBytes(inMsg.Len())
i := bytes.IndexByte(name, '\x00')
if i < 0 {
err = errors.New("Corrupt OpMkdir")
return
return nil, errors.New("Corrupt OpMkdir")
}
name = name[:i]
@ -142,15 +137,13 @@ func convertInMessage(
case fusekernel.OpMknod:
in := (*fusekernel.MknodIn)(inMsg.Consume(fusekernel.MknodInSize(protocol)))
if in == nil {
err = errors.New("Corrupt OpMknod")
return
return nil, errors.New("Corrupt OpMknod")
}
name := inMsg.ConsumeBytes(inMsg.Len())
i := bytes.IndexByte(name, '\x00')
if i < 0 {
err = errors.New("Corrupt OpMknod")
return
return nil, errors.New("Corrupt OpMknod")
}
name = name[:i]
@ -163,15 +156,13 @@ func convertInMessage(
case fusekernel.OpCreate:
in := (*fusekernel.CreateIn)(inMsg.Consume(fusekernel.CreateInSize(protocol)))
if in == nil {
err = errors.New("Corrupt OpCreate")
return
return nil, errors.New("Corrupt OpCreate")
}
name := inMsg.ConsumeBytes(inMsg.Len())
i := bytes.IndexByte(name, '\x00')
if i < 0 {
err = errors.New("Corrupt OpCreate")
return
return nil, errors.New("Corrupt OpCreate")
}
name = name[:i]
@ -185,13 +176,11 @@ func convertInMessage(
// The message is "newName\0target\0".
names := inMsg.ConsumeBytes(inMsg.Len())
if len(names) == 0 || names[len(names)-1] != 0 {
err = errors.New("Corrupt OpSymlink")
return
return nil, errors.New("Corrupt OpSymlink")
}
i := bytes.IndexByte(names, '\x00')
if i < 0 {
err = errors.New("Corrupt OpSymlink")
return
return nil, errors.New("Corrupt OpSymlink")
}
newName, target := names[0:i], names[i+1:len(names)-1]
@ -205,24 +194,20 @@ func convertInMessage(
type input fusekernel.RenameIn
in := (*input)(inMsg.Consume(unsafe.Sizeof(input{})))
if in == nil {
err = errors.New("Corrupt OpRename")
return
return nil, errors.New("Corrupt OpRename")
}
names := inMsg.ConsumeBytes(inMsg.Len())
// names should be "old\x00new\x00"
if len(names) < 4 {
err = errors.New("Corrupt OpRename")
return
return nil, errors.New("Corrupt OpRename")
}
if names[len(names)-1] != '\x00' {
err = errors.New("Corrupt OpRename")
return
return nil, errors.New("Corrupt OpRename")
}
i := bytes.IndexByte(names, '\x00')
if i < 0 {
err = errors.New("Corrupt OpRename")
return
return nil, errors.New("Corrupt OpRename")
}
oldName, newName := names[:i], names[i+1:len(names)-1]
@ -237,8 +222,7 @@ func convertInMessage(
buf := inMsg.ConsumeBytes(inMsg.Len())
n := len(buf)
if n == 0 || buf[n-1] != '\x00' {
err = errors.New("Corrupt OpUnlink")
return
return nil, errors.New("Corrupt OpUnlink")
}
o = &fuseops.UnlinkOp{
@ -250,8 +234,7 @@ func convertInMessage(
buf := inMsg.ConsumeBytes(inMsg.Len())
n := len(buf)
if n == 0 || buf[n-1] != '\x00' {
err = errors.New("Corrupt OpRmdir")
return
return nil, errors.New("Corrupt OpRmdir")
}
o = &fuseops.RmDirOp{
@ -272,8 +255,7 @@ func convertInMessage(
case fusekernel.OpRead:
in := (*fusekernel.ReadIn)(inMsg.Consume(fusekernel.ReadInSize(protocol)))
if in == nil {
err = errors.New("Corrupt OpRead")
return
return nil, errors.New("Corrupt OpRead")
}
to := &fuseops.ReadFileOp{
@ -286,8 +268,7 @@ func convertInMessage(
readSize := int(in.Size)
p := outMsg.GrowNoZero(readSize)
if p == nil {
err = fmt.Errorf("Can't grow for %d-byte read", readSize)
return
return nil, fmt.Errorf("Can't grow for %d-byte read", readSize)
}
sh := (*reflect.SliceHeader)(unsafe.Pointer(&to.Dst))
@ -298,8 +279,7 @@ func convertInMessage(
case fusekernel.OpReaddir:
in := (*fusekernel.ReadIn)(inMsg.Consume(fusekernel.ReadInSize(protocol)))
if in == nil {
err = errors.New("Corrupt OpReaddir")
return
return nil, errors.New("Corrupt OpReaddir")
}
to := &fuseops.ReadDirOp{
@ -312,8 +292,7 @@ func convertInMessage(
readSize := int(in.Size)
p := outMsg.GrowNoZero(readSize)
if p == nil {
err = fmt.Errorf("Can't grow for %d-byte read", readSize)
return
return nil, fmt.Errorf("Can't grow for %d-byte read", readSize)
}
sh := (*reflect.SliceHeader)(unsafe.Pointer(&to.Dst))
@ -325,8 +304,7 @@ func convertInMessage(
type input fusekernel.ReleaseIn
in := (*input)(inMsg.Consume(unsafe.Sizeof(input{})))
if in == nil {
err = errors.New("Corrupt OpRelease")
return
return nil, errors.New("Corrupt OpRelease")
}
o = &fuseops.ReleaseFileHandleOp{
@ -337,8 +315,7 @@ func convertInMessage(
type input fusekernel.ReleaseIn
in := (*input)(inMsg.Consume(unsafe.Sizeof(input{})))
if in == nil {
err = errors.New("Corrupt OpReleasedir")
return
return nil, errors.New("Corrupt OpReleasedir")
}
o = &fuseops.ReleaseDirHandleOp{
@ -348,14 +325,12 @@ func convertInMessage(
case fusekernel.OpWrite:
in := (*fusekernel.WriteIn)(inMsg.Consume(fusekernel.WriteInSize(protocol)))
if in == nil {
err = errors.New("Corrupt OpWrite")
return
return nil, errors.New("Corrupt OpWrite")
}
buf := inMsg.ConsumeBytes(inMsg.Len())
if len(buf) < int(in.Size) {
err = errors.New("Corrupt OpWrite")
return
return nil, errors.New("Corrupt OpWrite")
}
o = &fuseops.WriteFileOp{
@ -369,8 +344,7 @@ func convertInMessage(
type input fusekernel.FsyncIn
in := (*input)(inMsg.Consume(unsafe.Sizeof(input{})))
if in == nil {
err = errors.New("Corrupt OpFsync")
return
return nil, errors.New("Corrupt OpFsync")
}
o = &fuseops.SyncFileOp{
@ -382,8 +356,7 @@ func convertInMessage(
type input fusekernel.FlushIn
in := (*input)(inMsg.Consume(unsafe.Sizeof(input{})))
if in == nil {
err = errors.New("Corrupt OpFlush")
return
return nil, errors.New("Corrupt OpFlush")
}
o = &fuseops.FlushFileOp{
@ -403,8 +376,7 @@ func convertInMessage(
type input fusekernel.InterruptIn
in := (*input)(inMsg.Consume(unsafe.Sizeof(input{})))
if in == nil {
err = errors.New("Corrupt OpInterrupt")
return
return nil, errors.New("Corrupt OpInterrupt")
}
o = &interruptOp{
@ -415,8 +387,7 @@ func convertInMessage(
type input fusekernel.InitIn
in := (*input)(inMsg.Consume(unsafe.Sizeof(input{})))
if in == nil {
err = errors.New("Corrupt OpInit")
return
return nil, errors.New("Corrupt OpInit")
}
o = &initOp{
@ -429,20 +400,17 @@ func convertInMessage(
type input fusekernel.LinkIn
in := (*input)(inMsg.Consume(unsafe.Sizeof(input{})))
if in == nil {
err = errors.New("Corrupt OpLink")
return
return nil, errors.New("Corrupt OpLink")
}
name := inMsg.ConsumeBytes(inMsg.Len())
i := bytes.IndexByte(name, '\x00')
if i < 0 {
err = errors.New("Corrupt OpLink")
return
return nil, errors.New("Corrupt OpLink")
}
name = name[:i]
if len(name) == 0 {
err = errors.New("Corrupt OpLink (Name not read)")
return
return nil, errors.New("Corrupt OpLink (Name not read)")
}
o = &fuseops.CreateLinkOp{
@ -455,8 +423,7 @@ func convertInMessage(
buf := inMsg.ConsumeBytes(inMsg.Len())
n := len(buf)
if n == 0 || buf[n-1] != '\x00' {
err = errors.New("Corrupt OpRemovexattr")
return
return nil, errors.New("Corrupt OpRemovexattr")
}
o = &fuseops.RemoveXattrOp{
@ -468,15 +435,13 @@ func convertInMessage(
type input fusekernel.GetxattrIn
in := (*input)(inMsg.Consume(unsafe.Sizeof(input{})))
if in == nil {
err = errors.New("Corrupt OpGetxattr")
return
return nil, errors.New("Corrupt OpGetxattr")
}
name := inMsg.ConsumeBytes(inMsg.Len())
i := bytes.IndexByte(name, '\x00')
if i < 0 {
err = errors.New("Corrupt OpGetxattr")
return
return nil, errors.New("Corrupt OpGetxattr")
}
name = name[:i]
@ -489,8 +454,7 @@ func convertInMessage(
readSize := int(in.Size)
p := outMsg.GrowNoZero(readSize)
if p == nil {
err = fmt.Errorf("Can't grow for %d-byte read", readSize)
return
return nil, fmt.Errorf("Can't grow for %d-byte read", readSize)
}
sh := (*reflect.SliceHeader)(unsafe.Pointer(&to.Dst))
@ -502,8 +466,7 @@ func convertInMessage(
type input fusekernel.ListxattrIn
in := (*input)(inMsg.Consume(unsafe.Sizeof(input{})))
if in == nil {
err = errors.New("Corrupt OpListxattr")
return
return nil, errors.New("Corrupt OpListxattr")
}
to := &fuseops.ListXattrOp{
@ -515,8 +478,7 @@ func convertInMessage(
if readSize != 0 {
p := outMsg.GrowNoZero(readSize)
if p == nil {
err = fmt.Errorf("Can't grow for %d-byte read", readSize)
return
return nil, fmt.Errorf("Can't grow for %d-byte read", readSize)
}
sh := (*reflect.SliceHeader)(unsafe.Pointer(&to.Dst))
sh.Data = uintptr(p)
@ -527,20 +489,17 @@ func convertInMessage(
type input fusekernel.SetxattrIn
in := (*input)(inMsg.Consume(unsafe.Sizeof(input{})))
if in == nil {
err = errors.New("Corrupt OpSetxattr")
return
return nil, errors.New("Corrupt OpSetxattr")
}
payload := inMsg.ConsumeBytes(inMsg.Len())
// payload should be "name\x00value"
if len(payload) < 3 {
err = errors.New("Corrupt OpSetxattr")
return
return nil, errors.New("Corrupt OpSetxattr")
}
i := bytes.IndexByte(payload, '\x00')
if i < 0 {
err = errors.New("Corrupt OpSetxattr")
return
return nil, errors.New("Corrupt OpSetxattr")
}
name, value := payload[:i], payload[i+1:len(payload)]
@ -555,8 +514,7 @@ func convertInMessage(
type input fusekernel.FallocateIn
in := (*input)(inMsg.Consume(unsafe.Sizeof(input{})))
if in == nil {
err = errors.New("Corrupt OpFallocate")
return
return nil, errors.New("Corrupt OpFallocate")
}
o = &fuseops.FallocateOp{
@ -574,7 +532,7 @@ func convertInMessage(
}
}
return
return o, nil
}
////////////////////////////////////////////////////////////////////////
@ -595,12 +553,10 @@ func (c *Connection) kernelResponse(
// interruptOp .
switch op.(type) {
case *fuseops.ForgetInodeOp:
noResponse = true
return
return true
case *interruptOp:
noResponse = true
return
return true
}
// If the user returned the error, fill in the error field of the outgoing
@ -629,7 +585,7 @@ func (c *Connection) kernelResponse(
}
h.Len = uint32(m.Len())
return
return false
}
// Like kernelResponse, but assumes the user replied with a nil error to the
@ -829,7 +785,7 @@ func convertTime(t time.Time) (secs uint64, nsec uint32) {
totalNano := t.UnixNano()
secs = uint64(totalNano / 1e9)
nsec = uint32(totalNano % 1e9)
return
return secs, nsec
}
func convertAttributes(
@ -886,7 +842,7 @@ func convertExpirationTime(t time.Time) (secs uint64, nsecs uint32) {
nsecs = uint32((d % time.Second) / time.Nanosecond)
}
return
return secs, nsecs
}
func convertChildInodeEntry(

12
freelists.go
View File

@ -25,16 +25,16 @@ import (
////////////////////////////////////////////////////////////////////////
// LOCKS_EXCLUDED(c.mu)
func (c *Connection) getInMessage() (x *buffer.InMessage) {
func (c *Connection) getInMessage() *buffer.InMessage {
c.mu.Lock()
x = (*buffer.InMessage)(c.inMessages.Get())
x := (*buffer.InMessage)(c.inMessages.Get())
c.mu.Unlock()
if x == nil {
x = new(buffer.InMessage)
}
return
return x
}
// LOCKS_EXCLUDED(c.mu)
@ -49,9 +49,9 @@ func (c *Connection) putInMessage(x *buffer.InMessage) {
////////////////////////////////////////////////////////////////////////
// LOCKS_EXCLUDED(c.mu)
func (c *Connection) getOutMessage() (x *buffer.OutMessage) {
func (c *Connection) getOutMessage() *buffer.OutMessage {
c.mu.Lock()
x = (*buffer.OutMessage)(c.outMessages.Get())
x := (*buffer.OutMessage)(c.outMessages.Get())
c.mu.Unlock()
if x == nil {
@ -59,7 +59,7 @@ func (c *Connection) getOutMessage() (x *buffer.OutMessage) {
}
x.Reset()
return
return x
}
// LOCKS_EXCLUDED(c.mu)

15
fsutil/fsutil.go
View File

@ -28,25 +28,22 @@ import (
// Warning: this is not production-quality code, and should only be used for
// testing purposes. In particular, there is a race between creating and
// unlinking by name.
func AnonymousFile(dir string) (f *os.File, err error) {
func AnonymousFile(dir string) (*os.File, error) {
// Choose a prefix based on the binary name.
prefix := path.Base(os.Args[0])
// Create the file.
f, err = ioutil.TempFile(dir, prefix)
f, err := ioutil.TempFile(dir, prefix)
if err != nil {
err = fmt.Errorf("TempFile: %v", err)
return
return nil, fmt.Errorf("TempFile: %v", err)
}
// Unlink it.
err = os.Remove(f.Name())
if err != nil {
err = fmt.Errorf("Remove: %v", err)
return
if err := os.Remove(f.Name()); err != nil {
return nil, fmt.Errorf("Remove: %v", err)
}
return
return f, nil
}
// Call fdatasync on the supplied file.

109
fusetesting/parallel.go
View File

@ -44,22 +44,18 @@ func RunCreateInParallelTest_NoTruncate(
// Set up a function that opens the file with O_CREATE and then appends a
// byte to it.
worker := func(id byte) (err error) {
worker := func(id byte) error {
f, err := os.OpenFile(filename, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0600)
if err != nil {
err = fmt.Errorf("Worker %d: Open: %v", id, err)
return
return fmt.Errorf("Worker %d: Open: %v", id, err)
}
defer f.Close()
_, err = f.Write([]byte{id})
if err != nil {
err = fmt.Errorf("Worker %d: Write: %v", id, err)
return
if _, err := f.Write([]byte{id}); err != nil {
return fmt.Errorf("Worker %d: Write: %v", id, err)
}
return
return nil
}
// Run several workers in parallel.
@ -67,9 +63,8 @@ func RunCreateInParallelTest_NoTruncate(
b := syncutil.NewBundle(ctx)
for i := 0; i < numWorkers; i++ {
id := byte(i)
b.Add(func(ctx context.Context) (err error) {
err = worker(id)
return
b.Add(func(ctx context.Context) error {
return worker(id)
})
}
@ -121,21 +116,16 @@ func RunCreateInParallelTest_Truncate(
filename,
os.O_CREATE|os.O_WRONLY|os.O_APPEND|os.O_TRUNC,
0600)
if err != nil {
err = fmt.Errorf("Worker %d: Open: %v", id, err)
return
return fmt.Errorf("Worker %d: Open: %v", id, err)
}
defer f.Close()
_, err = f.Write([]byte{id})
if err != nil {
err = fmt.Errorf("Worker %d: Write: %v", id, err)
return
if _, err := f.Write([]byte{id}); err != nil {
return fmt.Errorf("Worker %d: Write: %v", id, err)
}
return
return nil
}
// Run several workers in parallel.
@ -143,9 +133,8 @@ func RunCreateInParallelTest_Truncate(
b := syncutil.NewBundle(ctx)
for i := 0; i < numWorkers; i++ {
id := byte(i)
b.Add(func(ctx context.Context) (err error) {
err = worker(id)
return
b.Add(func(ctx context.Context) error {
return worker(id)
})
}
@ -203,26 +192,22 @@ func RunCreateInParallelTest_Exclusive(
// If we failed to open due to the file already existing, just leave.
if os.IsExist(err) {
err = nil
return
return nil
}
// Propgate other errors.
if err != nil {
err = fmt.Errorf("Worker %d: Open: %v", id, err)
return
return fmt.Errorf("Worker %d: Open: %v", id, err)
}
atomic.AddUint64(&openCount, 1)
defer f.Close()
_, err = f.Write([]byte{id})
if err != nil {
err = fmt.Errorf("Worker %d: Write: %v", id, err)
return
if _, err := f.Write([]byte{id}); err != nil {
return fmt.Errorf("Worker %d: Write: %v", id, err)
}
return
return nil
}
// Run several workers in parallel.
@ -230,9 +215,8 @@ func RunCreateInParallelTest_Exclusive(
b := syncutil.NewBundle(ctx)
for i := 0; i < numWorkers; i++ {
id := byte(i)
b.Add(func(ctx context.Context) (err error) {
err = worker(id)
return
b.Add(func(ctx context.Context) error {
return worker(id)
})
}
@ -269,19 +253,16 @@ func RunMkdirInParallelTest(
filename := path.Join(dir, "foo")
// Set up a function that creates the directory, ignoring EEXIST errors.
worker := func(id byte) (err error) {
err = os.Mkdir(filename, 0700)
worker := func(id byte) error {
err := os.Mkdir(filename, 0700)
if os.IsExist(err) {
err = nil
return nil
}
if err != nil {
err = fmt.Errorf("Worker %d: Mkdir: %v", id, err)
return
return fmt.Errorf("Worker %d: Mkdir: %v", id, err)
}
return
return nil
}
// Run several workers in parallel.
@ -289,9 +270,8 @@ func RunMkdirInParallelTest(
b := syncutil.NewBundle(ctx)
for i := 0; i < numWorkers; i++ {
id := byte(i)
b.Add(func(ctx context.Context) (err error) {
err = worker(id)
return
b.Add(func(ctx context.Context) error {
return worker(id)
})
}
@ -325,19 +305,17 @@ func RunSymlinkInParallelTest(
filename := path.Join(dir, "foo")
// Set up a function that creates the symlink, ignoring EEXIST errors.
worker := func(id byte) (err error) {
err = os.Symlink("blah", filename)
worker := func(id byte) error {
err := os.Symlink("blah", filename)
if os.IsExist(err) {
err = nil
return nil
}
if err != nil {
err = fmt.Errorf("Worker %d: Symlink: %v", id, err)
return
return fmt.Errorf("Worker %d: Symlink: %v", id, err)
}
return
return nil
}
// Run several workers in parallel.
@ -345,9 +323,8 @@ func RunSymlinkInParallelTest(
b := syncutil.NewBundle(ctx)
for i := 0; i < numWorkers; i++ {
id := byte(i)
b.Add(func(ctx context.Context) (err error) {
err = worker(id)
return
b.Add(func(ctx context.Context) error {
return worker(id)
})
}
@ -388,19 +365,16 @@ func RunHardlinkInParallelTest(
filename := path.Join(dir, "foo")
// Set up a function that creates the symlink, ignoring EEXIST errors.
worker := func(id byte) (err error) {
err = os.Link(originalFile, filename)
worker := func(id byte) error {
err := os.Link(originalFile, filename)
if os.IsExist(err) {
err = nil
return nil
}
if err != nil {
err = fmt.Errorf("Worker %d: Link: %v", id, err)
return
return fmt.Errorf("Worker %d: Link: %v", id, err)
}
return
return nil
}
// Run several workers in parallel.
@ -408,9 +382,8 @@ func RunHardlinkInParallelTest(
b := syncutil.NewBundle(ctx)
for i := 0; i < numWorkers; i++ {
id := byte(i)
b.Add(func(ctx context.Context) (err error) {
err = worker(id)
return
b.Add(func(ctx context.Context) error {
return worker(id)
})
}

11
fusetesting/readdir.go
View File

@ -37,8 +37,7 @@ func ReadDirPicky(dirname string) (entries []os.FileInfo, err error) {
// Open the directory.
f, err := os.Open(dirname)
if err != nil {
err = fmt.Errorf("Open: %v", err)
return
return nil, fmt.Errorf("Open: %v", err)
}
// Don't forget to close it later.
@ -52,8 +51,7 @@ func ReadDirPicky(dirname string) (entries []os.FileInfo, err error) {
// Read all of the names from the directory.
names, err := f.Readdirnames(-1)
if err != nil {
err = fmt.Errorf("Readdirnames: %v", err)
return
return nil, fmt.Errorf("Readdirnames: %v", err)
}
// Stat each one.
@ -62,8 +60,7 @@ func ReadDirPicky(dirname string) (entries []os.FileInfo, err error) {
fi, err = os.Lstat(path.Join(dirname, name))
if err != nil {
err = fmt.Errorf("Lstat(%s): %v", name, err)
return
return nil, fmt.Errorf("Lstat(%s): %v", name, err)
}
entries = append(entries, fi)
@ -72,5 +69,5 @@ func ReadDirPicky(dirname string) (entries []os.FileInfo, err error) {
// Sort the entries by name.
sort.Sort(sortedEntries(entries))
return
return entries, nil
}

14
fusetesting/stat_darwin.go
View File

@ -20,26 +20,20 @@ import (
)
func extractMtime(sys interface{}) (mtime time.Time, ok bool) {
mtime = time.Unix(sys.(*syscall.Stat_t).Mtimespec.Unix())
ok = true
return
return time.Unix(sys.(*syscall.Stat_t).Mtimespec.Unix()), true
}
func extractBirthtime(sys interface{}) (birthtime time.Time, ok bool) {
birthtime = time.Unix(sys.(*syscall.Stat_t).Birthtimespec.Unix())
ok = true
return
return time.Unix(sys.(*syscall.Stat_t).Birthtimespec.Unix()), true
}
func extractNlink(sys interface{}) (nlink uint64, ok bool) {
nlink = uint64(sys.(*syscall.Stat_t).Nlink)
ok = true
return
return uint64(sys.(*syscall.Stat_t).Nlink), true
}
func getTimes(stat *syscall.Stat_t) (atime, ctime, mtime time.Time) {
atime = time.Unix(stat.Atimespec.Unix())
ctime = time.Unix(stat.Ctimespec.Unix())
mtime = time.Unix(stat.Mtimespec.Unix())
return
return atime, ctime, mtime
}

12
fusetesting/stat_linux.go
View File

@ -20,24 +20,20 @@ import (
)
func extractMtime(sys interface{}) (mtime time.Time, ok bool) {
mtime = time.Unix(sys.(*syscall.Stat_t).Mtim.Unix())
ok = true
return
return time.Unix(sys.(*syscall.Stat_t).Mtim.Unix()), true
}
func extractBirthtime(sys interface{}) (birthtime time.Time, ok bool) {
return
return time.Time{}, false
}
func extractNlink(sys interface{}) (nlink uint64, ok bool) {
nlink = sys.(*syscall.Stat_t).Nlink
ok = true
return
return sys.(*syscall.Stat_t).Nlink, true
}
func getTimes(stat *syscall.Stat_t) (atime, ctime, mtime time.Time) {
atime = time.Unix(stat.Atim.Unix())
ctime = time.Unix(stat.Ctim.Unix())
mtime = time.Unix(stat.Mtim.Unix())
return
return atime, ctime, mtime
}

4
fuseutil/dirent.go
View File

@ -79,7 +79,7 @@ func WriteDirent(buf []byte, d Dirent) (n int) {
// Do we have enough room?
totalLen := direntSize + len(d.Name) + padLen
if totalLen > len(buf) {
return
return n
}
// Write the header.
@ -101,5 +101,5 @@ func WriteDirent(buf []byte, d Dirent) (n int) {
n += copy(buf[n:], padding[:padLen])
}
return
return n
}

140
fuseutil/not_implemented_file_system.go
View File

@ -32,198 +32,170 @@ var _ FileSystem = &NotImplementedFileSystem{}
func (fs *NotImplementedFileSystem) StatFS(
ctx context.Context,
op *fuseops.StatFSOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.StatFSOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) LookUpInode(
ctx context.Context,
op *fuseops.LookUpInodeOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.LookUpInodeOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) GetInodeAttributes(
ctx context.Context,
op *fuseops.GetInodeAttributesOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.GetInodeAttributesOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) SetInodeAttributes(
ctx context.Context,
op *fuseops.SetInodeAttributesOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.SetInodeAttributesOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) ForgetInode(
ctx context.Context,
op *fuseops.ForgetInodeOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.ForgetInodeOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) MkDir(
ctx context.Context,
op *fuseops.MkDirOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.MkDirOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) MkNode(
ctx context.Context,
op *fuseops.MkNodeOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.MkNodeOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) CreateFile(
ctx context.Context,
op *fuseops.CreateFileOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.CreateFileOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) CreateSymlink(
ctx context.Context,
op *fuseops.CreateSymlinkOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.CreateSymlinkOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) CreateLink(
ctx context.Context,
op *fuseops.CreateLinkOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.CreateLinkOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) Rename(
ctx context.Context,
op *fuseops.RenameOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.RenameOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) RmDir(
ctx context.Context,
op *fuseops.RmDirOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.RmDirOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) Unlink(
ctx context.Context,
op *fuseops.UnlinkOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.UnlinkOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) OpenDir(
ctx context.Context,
op *fuseops.OpenDirOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.OpenDirOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) ReadDir(
ctx context.Context,
op *fuseops.ReadDirOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.ReadDirOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) ReleaseDirHandle(
ctx context.Context,
op *fuseops.ReleaseDirHandleOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.ReleaseDirHandleOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) OpenFile(
ctx context.Context,
op *fuseops.OpenFileOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.OpenFileOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) ReadFile(
ctx context.Context,
op *fuseops.ReadFileOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.ReadFileOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) WriteFile(
ctx context.Context,
op *fuseops.WriteFileOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.WriteFileOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) SyncFile(
ctx context.Context,
op *fuseops.SyncFileOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.SyncFileOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) FlushFile(
ctx context.Context,
op *fuseops.FlushFileOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.FlushFileOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) ReleaseFileHandle(
ctx context.Context,
op *fuseops.ReleaseFileHandleOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.ReleaseFileHandleOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) ReadSymlink(
ctx context.Context,
op *fuseops.ReadSymlinkOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.ReadSymlinkOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) RemoveXattr(
ctx context.Context,
op *fuseops.RemoveXattrOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.RemoveXattrOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) GetXattr(
ctx context.Context,
op *fuseops.GetXattrOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.GetXattrOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) ListXattr(
ctx context.Context,
op *fuseops.ListXattrOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.ListXattrOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) SetXattr(
ctx context.Context,
op *fuseops.SetXattrOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.SetXattrOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) Fallocate(
ctx context.Context,
op *fuseops.FallocateOp) (err error) {
err = fuse.ENOSYS
return
op *fuseops.FallocateOp) error {
return fuse.ENOSYS
}
func (fs *NotImplementedFileSystem) Destroy() {

34
internal/buffer/in_message.go
View File

@ -49,38 +49,34 @@ type InMessage struct {
// Initialize with the data read by a single call to r.Read. The first call to
// Consume will consume the bytes directly after the fusekernel.InHeader
// struct.
func (m *InMessage) Init(r io.Reader) (err error) {
func (m *InMessage) Init(r io.Reader) error {
n, err := r.Read(m.storage[:])
if err != nil {
return
return err
}
// Make sure the message is long enough.