deps: remove vendored fuse lib

License: MIT
Signed-off-by: Jakub Sztandera <kubuxu@protonmail.ch>

Godeps/_workspace/src/bazil.org/fuse/.gitattributes

-*.go filter=gofmt
-*.cgo filter=gofmt

Godeps/_workspace/src/bazil.org/fuse/.gitignore

-*~
-.#*
-## the next line needs to start with a backslash to avoid looking like
-## a comment
-\#*#
-.*.swp
-
-*.test

Godeps/_workspace/src/bazil.org/fuse/LICENSE

-Copyright (c) 2013-2015 Tommi Virtanen.
-Copyright (c) 2009, 2011, 2012 The Go Authors.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-
-The following included software components have additional copyright
-notices and license terms that may differ from the above.
-
-
-File fuse.go:
-
-// 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.
-
-
-File fuse_kernel.go:
-
-// Derived from FUSE's fuse_kernel.h
-/*
-   This file defines the kernel interface of FUSE
-   Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
-
-
-   This -- and only this -- header file may also be distributed under
-   the terms of the BSD Licence as follows:
-
-   Copyright (C) 2001-2007 Miklos Szeredi. All rights reserved.
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met:
-   1. Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-   2. Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-   THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
-   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-   ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
-   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
-   OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-   OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-   SUCH DAMAGE.
-*/

Godeps/_workspace/src/bazil.org/fuse/README.md

-bazil.org/fuse -- Filesystems in Go
-===================================
-
-`bazil.org/fuse` is a Go library for writing FUSE userspace
-filesystems.
-
-It is a from-scratch implementation of the kernel-userspace
-communication protocol, and does not use the C library from the
-project called FUSE. `bazil.org/fuse` embraces Go fully for safety and
-ease of programming.
-
-Here’s how to get going:
-
-    go get bazil.org/fuse
-
-Website: http://bazil.org/fuse/
-
-Github repository: https://github.com/bazil/fuse
-
-API docs: http://godoc.org/bazil.org/fuse
-
-Our thanks to Russ Cox for his fuse library, which this project is
-based on.

Godeps/_workspace/src/bazil.org/fuse/debug.go

-package fuse
-
-import (
-	"runtime"
-)
-
-func stack() string {
-	buf := make([]byte, 1024)
-	return string(buf[:runtime.Stack(buf, false)])
-}
-
-func nop(msg interface{}) {}
-
-// Debug is called to output debug messages, including protocol
-// traces. The default behavior is to do nothing.
-//
-// The messages have human-friendly string representations and are
-// safe to marshal to JSON.
-//
-// Implementations must not retain msg.
-var Debug func(msg interface{}) = nop

Godeps/_workspace/src/bazil.org/fuse/doc/.gitignore

-/*.seq.svg
-
-# not ignoring *.seq.png; we want those committed to the repo
-# for embedding on Github

Godeps/_workspace/src/bazil.org/fuse/doc/README.md

-# bazil.org/fuse documentation
-
-See also API docs at http://godoc.org/bazil.org/fuse
-
-- [The mount sequence](mount-sequence.md)
-- [Writing documentation](writing-docs.md)

Godeps/_workspace/src/bazil.org/fuse/doc/mount-linux-error-init.seq

-seqdiag {
-  app;
-  fuse [label="bazil.org/fuse"];
-  fusermount;
-  kernel;
-  mounts;
-
-  app;
-  fuse [label="bazil.org/fuse"];
-  fusermount;
-  kernel;
-  mounts;
-
-  app -> fuse [label="Mount"];
-  fuse -> fusermount [label="spawn, pass socketpair fd"];
-  fusermount -> kernel [label="open /dev/fuse"];
-  fusermount -> kernel [label="mount(2)"];
-  kernel ->> mounts [label="mount is visible"];
-  fusermount <-- kernel [label="mount(2) returns"];
-  fuse <<-- fusermount [diagonal, label="exit, receive /dev/fuse fd", leftnote="on Linux, successful exit here\nmeans the mount has happened,\nthough InitRequest might not have yet"];
-  app <-- fuse [label="Mount returns\nConn.Ready is already closed"];
-
-  app -> fuse [label="fs.Serve"];
-  fuse => kernel [label="read /dev/fuse fd", note="starts with InitRequest"];
-  fuse -> app [label="Init"];
-  fuse <-- app [color=red];
-  fuse -> kernel [label="write /dev/fuse fd", color=red];
-  kernel -> kernel [label="set connection\nstate to error", color=red];
-  fuse <-- kernel;
-  ... conn.MountError == nil, so it is still mounted ...
-  ... call conn.Close to clean up ...
-}

Godeps/_workspace/src/bazil.org/fuse/doc/mount-linux.seq

-seqdiag {
-  // seqdiag -T svg -o doc/mount-osx.svg doc/mount-osx.seq
-  app;
-  fuse [label="bazil.org/fuse"];
-  fusermount;
-  kernel;
-  mounts;
-
-  app -> fuse [label="Mount"];
-  fuse -> fusermount [label="spawn, pass socketpair fd"];
-  fusermount -> kernel [label="open /dev/fuse"];
-  fusermount -> kernel [label="mount(2)"];
-  kernel ->> mounts [label="mount is visible"];
-  fusermount <-- kernel [label="mount(2) returns"];
-  fuse <<-- fusermount [diagonal, label="exit, receive /dev/fuse fd", leftnote="on Linux, successful exit here\nmeans the mount has happened,\nthough InitRequest might not have yet"];
-  app <-- fuse [label="Mount returns\nConn.Ready is already closed", rightnote="InitRequest and StatfsRequest\nmay or may not be seen\nbefore Conn.Ready,\ndepending on platform"];
-
-  app -> fuse [label="fs.Serve"];
-  fuse => kernel [label="read /dev/fuse fd", note="starts with InitRequest"];
-  fuse => app [label="FS/Node/Handle methods"];
-  fuse => kernel [label="write /dev/fuse fd"];
-  ... repeat ...
-
-  ... shutting down ...
-  app -> fuse [label="Unmount"];
-  fuse -> fusermount [label="fusermount -u"];
-  fusermount -> kernel;
-  kernel <<-- mounts;
-  fusermount <-- kernel;
-  fuse <<-- fusermount [diagonal];
-  app <-- fuse [label="Unmount returns"];
-
-  // actually triggers before above
-  fuse <<-- kernel [diagonal, label="/dev/fuse EOF"];
-  app <-- fuse [label="fs.Serve returns"];
-
-  app -> fuse [label="conn.Close"];
-  fuse -> kernel  [label="close /dev/fuse fd"];
-  fuse <-- kernel;
-  app <-- fuse;
-}

Godeps/_workspace/src/bazil.org/fuse/doc/mount-osx-error-init.seq

-seqdiag {
-  app;
-  fuse [label="bazil.org/fuse"];
-  wait [label="callMount\nhelper goroutine"];
-  mount_osxfusefs;
-  kernel;
-
-  app -> fuse [label="Mount"];
-  fuse -> kernel [label="open /dev/osxfuseN"];
-  fuse -> mount_osxfusefs [label="spawn, pass fd"];
-  fuse -> wait [label="goroutine", note="blocks on cmd.Wait"];
-  app <-- fuse [label="Mount returns"];
-
-  mount_osxfusefs -> kernel [label="mount(2)"];
-
-  app -> fuse [label="fs.Serve"];
-  fuse => kernel [label="read /dev/osxfuseN fd", note="starts with InitRequest,\nalso seen before mount exits:\ntwo StatfsRequest calls"];
-  fuse -> app [label="Init"];
-  fuse <-- app [color=red];
-  fuse -> kernel [label="write /dev/osxfuseN fd", color=red];
-  fuse <-- kernel;
-
-  mount_osxfusefs <-- kernel [label="mount(2) returns", color=red];
-  wait <<-- mount_osxfusefs [diagonal, label="exit", color=red];
-  app <<-- wait [diagonal, label="mount has failed,\nclose Conn.Ready", color=red];
-
-  // actually triggers before above
-  fuse <<-- kernel [diagonal, label="/dev/osxfuseN EOF"];
-  app <-- fuse [label="fs.Serve returns"];
-  ... conn.MountError != nil, so it was was never mounted ...
-  ... call conn.Close to clean up ...
-}

Godeps/_workspace/src/bazil.org/fuse/doc/mount-osx.seq

-seqdiag {
-  // seqdiag -T svg -o doc/mount-osx.svg doc/mount-osx.seq
-  app;
-  fuse [label="bazil.org/fuse"];
-  wait [label="callMount\nhelper goroutine"];
-  mount_osxfusefs;
-  kernel;
-  mounts;
-
-  app -> fuse [label="Mount"];
-  fuse -> kernel [label="open /dev/osxfuseN"];
-  fuse -> mount_osxfusefs [label="spawn, pass fd"];
-  fuse -> wait [label="goroutine", note="blocks on cmd.Wait"];
-  app <-- fuse [label="Mount returns"];
-
-  mount_osxfusefs -> kernel [label="mount(2)"];
-
-  app -> fuse [label="fs.Serve"];
-  fuse => kernel [label="read /dev/osxfuseN fd", note="starts with InitRequest,\nalso seen before mount exits:\ntwo StatfsRequest calls"];
-  fuse => app [label="FS/Node/Handle methods"];
-  fuse => kernel [label="write /dev/osxfuseN fd"];
-  ... repeat ...
-
-  kernel ->> mounts [label="mount is visible"];
-  mount_osxfusefs <-- kernel [label="mount(2) returns"];
-  wait <<-- mount_osxfusefs [diagonal, label="exit", leftnote="on OS X, successful exit\nhere means we finally know\nthe mount has happened\n(can't trust InitRequest,\nkernel might have timed out\nwaiting for InitResponse)"];
-
-  app <<-- wait [diagonal, label="mount is ready,\nclose Conn.Ready", rightnote="InitRequest and StatfsRequest\nmay or may not be seen\nbefore Conn.Ready,\ndepending on platform"];
-
-  ... shutting down ...
-  app -> fuse [label="Unmount"];
-  fuse -> kernel [label="umount(2)"];
-  kernel <<-- mounts;
-  fuse <-- kernel;
-  app <-- fuse [label="Unmount returns"];
-
-  // actually triggers before above
-  fuse <<-- kernel [diagonal, label="/dev/osxfuseN EOF"];
-  app <-- fuse [label="fs.Serve returns"];
-
-  app -> fuse [label="conn.Close"];
-  fuse -> kernel [label="close /dev/osxfuseN"];
-  fuse <-- kernel;
-  app <-- fuse;
-}

Godeps/_workspace/src/bazil.org/fuse/doc/mount-sequence.md

-# The mount sequence
-
-FUSE mounting is a little bit tricky. There's a userspace helper tool
-that performs the handshake with the kernel, and then steps out of the
-way. This helper behaves differently on different platforms, forcing a
-more complex API on us.
-
-## Successful runs
-
-On Linux, the mount is immediate and file system accesses wait until
-the requests are served.
-
-![Diagram of Linux FUSE mount sequence](mount-linux.seq.png)
-
-On OS X, the mount becomes visible only after `InitRequest` (and maybe
-more) have been served.
-
-![Diagram of OSXFUSE mount sequence](mount-osx.seq.png)
-
-
-## Errors
-
-Let's see what happens if `InitRequest` gets an error response. On
-Linux, the mountpoint is there but all operations will fail:
-
-![Diagram of Linux error handling](mount-linux-error-init.seq.png)
-
-On OS X, the mount never happened:
-
-![Diagram of OS X error handling](mount-osx-error-init.seq.png)

Godeps/_workspace/src/bazil.org/fuse/doc/writing-docs.md

-# Writing documentation
-
-## Sequence diagrams
-
-The sequence diagrams are generated with `seqdiag`:
-http://blockdiag.com/en/seqdiag/index.html
-
-An easy way to work on them is to automatically update the generated
-files with https://github.com/cespare/reflex :
-
-    reflex -g 'doc/[^.]*.seq' -- seqdiag -T svg -o '{}.svg' '{}' &
-
-    reflex -g 'doc/[^.]*.seq' -- seqdiag -T png -o '{}.png' '{}' &
-
-The markdown files refer to PNG images because of Github limitations,
-but the SVG is generally more pleasant to view.

Godeps/_workspace/src/bazil.org/fuse/error_darwin.go

-package fuse
-
-import (
-	"syscall"
-)
-
-const (
-	ENOATTR = Errno(syscall.ENOATTR)
-)
-
-const (
-	errNoXattr = ENOATTR
-)
-
-func init() {
-	errnoNames[errNoXattr] = "ENOATTR"
-}

Godeps/_workspace/src/bazil.org/fuse/error_freebsd.go

-package fuse
-
-import "syscall"
-
-const (
-	ENOATTR = Errno(syscall.ENOATTR)
-)
-
-const (
-	errNoXattr = ENOATTR
-)
-
-func init() {
-	errnoNames[errNoXattr] = "ENOATTR"
-}

Godeps/_workspace/src/bazil.org/fuse/error_linux.go

-package fuse
-
-import (
-	"syscall"
-)
-
-const (
-	ENODATA = Errno(syscall.ENODATA)
-)
-
-const (
-	errNoXattr = ENODATA
-)
-
-func init() {
-	errnoNames[errNoXattr] = "ENODATA"
-}

Godeps/_workspace/src/bazil.org/fuse/error_std.go

-package fuse
-
-// There is very little commonality in extended attribute errors
-// across platforms.
-//
-// getxattr return value for "extended attribute does not exist" is
-// ENOATTR on OS X, and ENODATA on Linux and apparently at least
-// NetBSD. There may be a #define ENOATTR on Linux too, but the value
-// is ENODATA in the actual syscalls. FreeBSD and OpenBSD have no
-// ENODATA, only ENOATTR. ENOATTR is not in any of the standards,
-// ENODATA exists but is only used for STREAMs.
-//
-// Each platform will define it a errNoXattr constant, and this file
-// will enforce that it implements the right interfaces and hide the
-// implementation.
-//
-// https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man2/getxattr.2.html
-// http://mail-index.netbsd.org/tech-kern/2012/04/30/msg013090.html
-// http://mail-index.netbsd.org/tech-kern/2012/04/30/msg013097.html
-// http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/errno.h.html
-// http://www.freebsd.org/cgi/man.cgi?query=extattr_get_file&sektion=2
-// http://nixdoc.net/man-pages/openbsd/man2/extattr_get_file.2.html
-
-// ErrNoXattr is a platform-independent error value meaning the
-// extended attribute was not found. It can be used to respond to
-// GetxattrRequest and such.
-const ErrNoXattr = errNoXattr
-
-var _ error = ErrNoXattr
-var _ Errno = ErrNoXattr
-var _ ErrorNumber = ErrNoXattr

Godeps/_workspace/src/bazil.org/fuse/fs/bench/bench_test.go

-package bench_test
-
-import (
-	"context"
-	"io"
-	"io/ioutil"
-	"os"
-	"path"
-	"testing"
-
-	"github.com/ipfs/go-ipfs/Godeps/_workspace/src/bazil.org/fuse"
-	"github.com/ipfs/go-ipfs/Godeps/_workspace/src/bazil.org/fuse/fs"
-	"github.com/ipfs/go-ipfs/Godeps/_workspace/src/bazil.org/fuse/fs/fstestutil"
-)
-
-type benchConfig struct {
-	directIO bool
-}
-
-type benchFS struct {
-	conf *benchConfig
-}
-
-var _ = fs.FS(benchFS{})
-var _ = fs.FSIniter(benchFS{})
-
-func (benchFS) Init(ctx context.Context, req *fuse.InitRequest, resp *fuse.InitResponse) error {
-	resp.MaxReadahead = 64 * 1024 * 1024
-	resp.Flags |= fuse.InitAsyncRead
-	return nil
-}
-
-func (f benchFS) Root() (fs.Node, error) {
-	return benchDir{conf: f.conf}, nil
-}
-
-type benchDir struct {
-	conf *benchConfig
-}
-
-var _ = fs.Node(benchDir{})
-var _ = fs.NodeStringLookuper(benchDir{})
-var _ = fs.Handle(benchDir{})
-var _ = fs.HandleReadDirAller(benchDir{})
-
-func (benchDir) Attr(ctx context.Context, a *fuse.Attr) error {
-	a.Inode = 1
-	a.Mode = os.ModeDir | 0555
-	return nil
-}
-
-func (d benchDir) Lookup(ctx context.Context, name string) (fs.Node, error) {
-	if name == "bench" {
-		return benchFile{conf: d.conf}, nil
-	}
-	return nil, fuse.ENOENT
-}
-
-func (benchDir) ReadDirAll(ctx context.Context) ([]fuse.Dirent, error) {
-	l := []fuse.Dirent{
-		{Inode: 2, Name: "bench", Type: fuse.DT_File},
-	}
-	return l, nil
-}
-
-type benchFile struct {
-	conf *benchConfig
-}
-
-var _ = fs.Node(benchFile{})
-var _ = fs.NodeOpener(benchFile{})
-var _ = fs.NodeFsyncer(benchFile{})
-var _ = fs.Handle(benchFile{})
-var _ = fs.HandleReader(benchFile{})
-var _ = fs.HandleWriter(benchFile{})
-
-func (benchFile) Attr(ctx context.Context, a *fuse.Attr) error {
-	a.Inode = 2
-	a.Mode = 0644
-	a.Size = 9999999999999999
-	return nil
-}
-
-func (f benchFile) Open(ctx context.Context, req *fuse.OpenRequest, resp *fuse.OpenResponse) (fs.Handle, error) {
-	if f.conf.directIO {
-		resp.Flags |= fuse.OpenDirectIO
-	}
-	// TODO configurable?
-	resp.Flags |= fuse.OpenKeepCache
-	return f, nil
-}
-
-func (benchFile) Read(ctx context.Context, req *fuse.ReadRequest, resp *fuse.ReadResponse) error {
-	resp.Data = resp.Data[:cap(resp.Data)]
-	return nil
-}
-
-func (benchFile) Write(ctx context.Context, req *fuse.WriteRequest, resp *fuse.WriteResponse) error {
-	resp.Size = len(req.Data)
-	return nil
-}
-
-func (benchFile) Fsync(ctx context.Context, req *fuse.FsyncRequest) error {
-	return nil
-}
-
-func benchmark(b *testing.B, fn func(b *testing.B, mnt string), conf *benchConfig) {
-	srv := &fs.Server{
-		FS: benchFS{
-			conf: conf,
-		},
-	}
-	mnt, err := fstestutil.Mounted(srv)
-	if err != nil {
-		b.Fatal(err)
-	}
-	defer mnt.Close()
-
-	fn(b, mnt.Dir)
-}
-
-type zero struct{}
-
-func (zero) Read(p []byte) (n int, err error) {
-	return len(p), nil
-}
-
-var Zero io.Reader = zero{}
-
-func doWrites(size int64) func(b *testing.B, mnt string) {
-	return func(b *testing.B, mnt string) {
-		p := path.Join(mnt, "bench")
-
-		f, err := os.Create(p)
-		if err != nil {
-			b.Fatalf("create: %v", err)
-		}
-		defer f.Close()
-
-		b.ResetTimer()
-		b.SetBytes(size)
-
-		for i := 0; i < b.N; i++ {
-			_, err = io.CopyN(f, Zero, size)
-			if err != nil {
-				b.Fatalf("write: %v", err)
-			}
-		}
-	}
-}
-
-func BenchmarkWrite100(b *testing.B) {
-	benchmark(b, doWrites(100), &benchConfig{})
-}
-
-func BenchmarkWrite10MB(b *testing.B) {
-	benchmark(b, doWrites(10*1024*1024), &benchConfig{})
-}
-
-func BenchmarkWrite100MB(b *testing.B) {
-	benchmark(b, doWrites(100*1024*1024), &benchConfig{})
-}
-
-func BenchmarkDirectWrite100(b *testing.B) {
-	benchmark(b, doWrites(100), &benchConfig{
-		directIO: true,
-	})
-}
-
-func BenchmarkDirectWrite10MB(b *testing.B) {
-	benchmark(b, doWrites(10*1024*1024), &benchConfig{
-		directIO: true,
-	})
-}
-
-func BenchmarkDirectWrite100MB(b *testing.B) {
-	benchmark(b, doWrites(100*1024*1024), &benchConfig{
-		directIO: true,
-	})
-}
-
-func doWritesSync(size int64) func(b *testing.B, mnt string) {
-	return func(b *testing.B, mnt string) {
-		p := path.Join(mnt, "bench")
-
-		f, err := os.Create(p)
-		if err != nil {
-			b.Fatalf("create: %v", err)
-		}
-		defer f.Close()
-
-		b.ResetTimer()
-		b.SetBytes(size)
-
-		for i := 0; i < b.N; i++ {
-			_, err = io.CopyN(f, Zero, size)
-			if err != nil {
-				b.Fatalf("write: %v", err)
-			}
-
-			if err := f.Sync(); err != nil {
-				b.Fatalf("sync: %v", err)
-			}
-		}
-	}
-}
-
-func BenchmarkWriteSync100(b *testing.B) {
-	benchmark(b, doWritesSync(100), &benchConfig{})
-}
-
-func BenchmarkWriteSync10MB(b *testing.B) {
-	benchmark(b, doWritesSync(10*1024*1024), &benchConfig{})
-}
-
-func BenchmarkWriteSync100MB(b *testing.B) {
-	benchmark(b, doWritesSync(100*1024*1024), &benchConfig{})
-}
-
-func doReads(size int64) func(b *testing.B, mnt string) {
-	return func(b *testing.B, mnt string) {
-		p := path.Join(mnt, "bench")
-
-		f, err := os.Open(p)
-		if err != nil {
-			b.Fatalf("close: %v", err)
-		}
-		defer f.Close()
-
-		b.ResetTimer()
-		b.SetBytes(size)
-
-		for i := 0; i < b.N; i++ {
-			n, err := io.CopyN(ioutil.Discard, f, size)
-			if err != nil {
-				b.Fatalf("read: %v", err)
-			}
-			if n != size {
-				b.Errorf("unexpected size: %d != %d", n, size)
-			}
-		}
-	}
-}
-
-func BenchmarkRead100(b *testing.B) {
-	benchmark(b, doReads(100), &benchConfig{})
-}
-
-func BenchmarkRead10MB(b *testing.B) {
-	benchmark(b, doReads(10*1024*1024), &benchConfig{})
-}
-
-func BenchmarkRead100MB(b *testing.B) {
-	benchmark(b, doReads(100*1024*1024), &benchConfig{})
-}
-
-func BenchmarkDirectRead100(b *testing.B) {
-	benchmark(b, doReads(100), &benchConfig{
-		directIO: true,
-	})
-}
-
-func BenchmarkDirectRead10MB(b *testing.B) {
-	benchmark(b, doReads(10*1024*1024), &benchConfig{
-		directIO: true,
-	})
-}
-
-func BenchmarkDirectRead100MB(b *testing.B) {
-	benchmark(b, doReads(100*1024*1024), &benchConfig{
-		directIO: true,
-	})
-}

Godeps/_workspace/src/bazil.org/fuse/fs/bench/doc.go

-// Package bench contains benchmarks.
-//
-// It is kept in a separate package to avoid conflicting with the
-// debug-heavy defaults for the actual tests.
-package bench

Godeps/_workspace/src/bazil.org/fuse/fs/fstestutil/debug.go

-package fstestutil
-
-import (
-	"flag"
-	"log"
-	"strconv"
-
-	"github.com/ipfs/go-ipfs/Godeps/_workspace/src/bazil.org/fuse"
-)
-
-type flagDebug bool
-
-var debug flagDebug
-
-var _ = flag.Value(&debug)
-
-func (f *flagDebug) IsBoolFlag() bool {
-	return true
-}
-
-func nop(msg interface{}) {}
-
-func (f *flagDebug) Set(s string) error {
-	v, err := strconv.ParseBool(s)
-	if err != nil {
-		return err
-	}
-	*f = flagDebug(v)
-	if v {
-		fuse.Debug = logMsg
-	} else {
-		fuse.Debug = nop
-	}
-	return nil
-}
-
-func (f *flagDebug) String() string {
-	return strconv.FormatBool(bool(*f))
-}
-
-func logMsg(msg interface{}) {
-	log.Printf("FUSE: %s\n", msg)
-}
-
-func init() {
-	flag.Var(&debug, "fuse.debug", "log FUSE processing details")
-}
-
-// DebugByDefault changes the default of the `-fuse.debug` flag to
-// true.
-//
-// This package registers a command line flag `-fuse.debug` and when
-// run with that flag (and activated inside the tests), logs FUSE
-// debug messages.
-//
-// This is disabled by default, as most callers probably won't care
-// about FUSE details. Use DebugByDefault for tests where you'd
-// normally be passing `-fuse.debug` all the time anyway.
-//
-// Call from an init function.
-func DebugByDefault() {
-	f := flag.Lookup("fuse.debug")
-	f.DefValue = "true"
-	f.Value.Set(f.DefValue)
-}

Godeps/_workspace/src/bazil.org/fuse/fs/fstestutil/doc.go

-package fstestutil

Godeps/_workspace/src/bazil.org/fuse/fs/fstestutil/mounted.go

-package fstestutil
-
-import (
-	"errors"
-	"io/ioutil"
-	"log"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/ipfs/go-ipfs/Godeps/_workspace/src/bazil.org/fuse"
-	"github.com/ipfs/go-ipfs/Godeps/_workspace/src/bazil.org/fuse/fs"
-)
-
-// Mount contains information about the mount for the test to use.
-type Mount struct {
-	// Dir is the temporary directory where the filesystem is mounted.
-	Dir string
-
-	Conn *fuse.Conn
-
-	// Error will receive the return value of Serve.
-	Error <-chan error
-
-	done   <-chan struct{}
-	closed bool
-}
-
-// Close unmounts the filesystem and waits for fs.Serve to return. Any
-// returned error will be stored in Err. It is safe to call Close
-// multiple times.
-func (mnt *Mount) Close() {
-	if mnt.closed {
-		return
-	}
-	mnt.closed = true
-	for tries := 0; tries < 1000; tries++ {
-		err := fuse.Unmount(mnt.Dir)
-		if err != nil {
-			// TODO do more than log?
-			log.Printf("unmount error: %v", err)
-			time.Sleep(10 * time.Millisecond)
-			continue
-		}
-		break
-	}
-	<-mnt.done
-	mnt.Conn.Close()
-	os.Remove(mnt.Dir)
-}
-
-// Mounted mounts the fuse.Server at a temporary directory.
-//
-// It also waits until the filesystem is known to be visible (OS X
-// workaround).
-//
-// After successful return, caller must clean up by calling Close.
-func Mounted(srv *fs.Server, options ...fuse.MountOption) (*Mount, error) {
-	dir, err := ioutil.TempDir("", "fusetest")
-	if err != nil {
-		return nil, err
-	}
-	c, err := fuse.Mount(dir, options...)
-	if err != nil {
-		return nil, err
-	}
-
-	done := make(chan struct{})
-	serveErr := make(chan error, 1)
-	mnt := &Mount{
-		Dir:   dir,
-		Conn:  c,
-		Error: serveErr,
-		done:  done,
-	}
-	go func() {
-		defer close(done)
-		serveErr <- srv.Serve(c)
-	}()
-
-	select {
-	case <-mnt.Conn.Ready:
-		if mnt.Conn.MountError != nil {
-			return nil, err
-		}
-		return mnt, err
-	case err = <-mnt.Error:
-		// Serve quit early
-		if err != nil {
-			return nil, err
-		}
-		return nil, errors.New("Serve exited early")
-	}
-}
-
-// MountedT mounts the filesystem at a temporary directory,
-// directing it's debug log to the testing logger.
-//
-// See Mounted for usage.
-//
-// The debug log is not enabled by default. Use `-fuse.debug` or call
-// DebugByDefault to enable.
-func MountedT(t testing.TB, filesys fs.FS, options ...fuse.MountOption) (*Mount, error) {
-	srv := &fs.Server{
-		FS: filesys,
-	}
-	if debug {
-		srv.Debug = func(msg interface{}) {
-			t.Logf("FUSE: %s", msg)
-		}
-	}
-	return Mounted(srv, options...)
-}

Godeps/_workspace/src/bazil.org/fuse/fs/fstestutil/mountinfo.go

-package fstestutil
-
-// MountInfo describes a mounted file system.
-type MountInfo struct {
-	FSName string
-	Type   string
-}
-
-// GetMountInfo finds information about the mount at mnt. It is
-// intended for use by tests only, and only fetches information
-// relevant to the current tests.
-func GetMountInfo(mnt string) (*MountInfo, error) {
-	return getMountInfo(mnt)
-}
-
-// cstr converts a nil-terminated C string into a Go string
-func cstr(ca []int8) string {
-	s := make([]byte, 0, len(ca))
-	for _, c := range ca {
-		if c == 0x00 {
-			break
-		}
-		s = append(s, byte(c))
-	}
-	return string(s)
-}

Godeps/_workspace/src/bazil.org/fuse/fs/fstestutil/mountinfo_darwin.go

-package fstestutil
-
-import (
-	"regexp"
-	"syscall"
-)
-
-var re = regexp.MustCompile(`\\(.)`)
-
-// unescape removes backslash-escaping. The escaped characters are not
-// mapped in any way; that is, unescape(`\n` ) == `n`.
-func unescape(s string) string {
-	return re.ReplaceAllString(s, `$1`)
-}
-
-func getMountInfo(mnt string) (*MountInfo, error) {
-	var st syscall.Statfs_t
-	err := syscall.Statfs(mnt, &st)
-	if err != nil {
-		return nil, err
-	}
-	i := &MountInfo{
-		// osx getmntent(3) fails to un-escape the data, so we do it..
-		// this might lead to double-unescaping in the future. fun.
-		// TestMountOptionFSNameEvilBackslashDouble checks for that.
-		FSName: unescape(cstr(st.Mntfromname[:])),
-	}
-	return i, nil
-}

Godeps/_workspace/src/bazil.org/fuse/fs/fstestutil/mountinfo_freebsd.go

-package fstestutil
-
-import "errors"
-
-func getMountInfo(mnt string) (*MountInfo, error) {
-	return nil, errors.New("FreeBSD has no useful mount information")
-}

Godeps/_workspace/src/bazil.org/fuse/fs/fstestutil/mountinfo_linux.go

-package fstestutil
-
-import (
-	"errors"
-	"io/ioutil"
-	"strings"
-)
-
-// Linux /proc/mounts shows current mounts.
-// Same format as /etc/fstab. Quoting getmntent(3):
-//
-// Since fields in the mtab and fstab files are separated by whitespace,
-// octal escapes are used to represent the four characters space (\040),
-// tab (\011), newline (\012) and backslash (\134) in those files when
-// they occur in one of the four strings in a mntent structure.
-//
-// http://linux.die.net/man/3/getmntent
-
-var fstabUnescape = strings.NewReplacer(
-	`\040`, "\040",
-	`\011`, "\011",
-	`\012`, "\012",
-	`\134`, "\134",
-)
-
-var errNotFound = errors.New("mount not found")
-
-func getMountInfo(mnt string) (*MountInfo, error) {
-	data, err := ioutil.ReadFile("/proc/mounts")
-	if err != nil {
-		return nil, err
-	}
-	for _, line := range strings.Split(string(data), "\n") {
-		fields := strings.Fields(line)
-		if len(fields) < 3 {
-			continue
-		}
-		// Fields are: fsname dir type opts freq passno
-		fsname := fstabUnescape.Replace(fields[0])
-		dir := fstabUnescape.Replace(fields[1])
-		fstype := fstabUnescape.Replace(fields[2])
-		if mnt == dir {
-			info := &MountInfo{
-				FSName: fsname,
-				Type:   fstype,
-			}
-			return info, nil
-		}
-	}
-	return nil, errNotFound
-}

Godeps/_workspace/src/bazil.org/fuse/fs/fstestutil/record/buffer.go

-package record
-
-import (
-	"bytes"
-	"io"
-	"sync"
-)
-
-// Buffer is like bytes.Buffer but safe to access from multiple
-// goroutines.
-type Buffer struct {
-	mu  sync.Mutex
-	buf bytes.Buffer
-}
-
-var _ = io.Writer(&Buffer{})
-
-func (b *Buffer) Write(p []byte) (n int, err error) {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	return b.buf.Write(p)
-}
-
-func (b *Buffer) Bytes() []byte {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	return b.buf.Bytes()
-}

Godeps/_workspace/src/bazil.org/fuse/fs/fstestutil/record/record.go

-package record
-
-import (
-	"context"
-	"sync"
-	"sync/atomic"
-
-	"github.com/ipfs/go-ipfs/Godeps/_workspace/src/bazil.org/fuse"
-	"github.com/ipfs/go-ipfs/Godeps/_workspace/src/bazil.org/fuse/fs"
-)
-
-// Writes gathers data from FUSE Write calls.
-type Writes struct {
-	buf Buffer
-}
-
-var _ = fs.HandleWriter(&Writes{})
-
-func (w *Writes) Write(ctx context.Context, req *fuse.WriteRequest, resp *fuse.WriteResponse) error {
-	n, err := w.buf.Write(req.Data)
-	resp.Size = n
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func (w *Writes) RecordedWriteData() []byte {
-	return w.buf.Bytes()
-}
-
-// Counter records number of times a thing has occurred.
-type Counter struct {
-	count uint32
-}
-
-func (r *Counter) Inc() {
-	atomic.StoreUint32(&r.count, 1)
-}
-
-func (r *Counter) Count() uint32 {
-	return atomic.LoadUint32(&r.count)
-}
-
-// MarkRecorder records whether a thing has occurred.
-type MarkRecorder struct {
-	count Counter
-}
-
-func (r *MarkRecorder) Mark() {
-	r.count.Inc()
-}
-
-func (r *MarkRecorder) Recorded() bool {
-	return r.count.Count() > 0
-}
-
-// Flushes notes whether a FUSE Flush call has been seen.
-type Flushes struct {
-	rec MarkRecorder
-}
-
-var _ = fs.HandleFlusher(&Flushes{})
-
-func (r *Flushes) Flush(ctx context.Context, req *fuse.FlushRequest) error {
-	r.rec.Mark()
-	return nil
-}
-
-func (r *Flushes) RecordedFlush() bool {
-	return r.rec.Recorded()
-}
-
-type Recorder struct {
-	mu  sync.Mutex
-	val interface{}
-}
-
-// Record that we've seen value. A nil value is indistinguishable from
-// no value recorded.
-func (r *Recorder) Record(value interface{}) {
-	r.mu.Lock()
-	r.val = value
-	r.mu.Unlock()
-}
-
-func (r *Recorder) Recorded() interface{} {
-	r.mu.Lock()
-	val := r.val
-	r.mu.Unlock()
-	return val
-}
-
-type RequestRecorder struct {
-	rec Recorder
-}
-
-// Record a fuse.Request, after zeroing header fields that are hard to
-// reproduce.
-//
-// Make sure to record a copy, not the original request.
-func (r *RequestRecorder) RecordRequest(req fuse.Request) {
-	hdr := req.Hdr()
-	*hdr = fuse.Header{}
-	r.rec.Record(req)
-}
-
-func (r *RequestRecorder) Recorded() fuse.Request {
-	val := r.rec.Recorded()
-	if val == nil {
-		return nil
-	}
-	return val.(fuse.Request)
-}
-
-// Setattrs records a Setattr request and its fields.
-type Setattrs struct {
-	rec RequestRecorder
-}
-
-var _ = fs.NodeSetattrer(&Setattrs{})
-
-func (r *Setattrs) Setattr(ctx context.Context, req *fuse.SetattrRequest, resp *fuse.SetattrResponse) error {
-	tmp := *req
-	r.rec.RecordRequest(&tmp)
-	return nil
-}
-
-func (r *Setattrs) RecordedSetattr() fuse.SetattrRequest {
-	val := r.rec.Recorded()
-	if val == nil {
-		return fuse.SetattrRequest{}
-	}
-	return *(val.(*fuse.SetattrRequest))
-}
-
-// Fsyncs records an Fsync request and its fields.
-type Fsyncs struct {
-	rec RequestRecorder
-}
-
-var _ = fs.NodeFsyncer(&Fsyncs{})
-
-func (r *Fsyncs) Fsync(ctx context.Context, req *fuse.FsyncRequest) error {
-	tmp := *req
-	r.rec.RecordRequest(&tmp)
-	return nil
-}
-
-func (r *Fsyncs) RecordedFsync() fuse.FsyncRequest {
-	val := r.rec.Recorded()
-	if val == nil {
-		return fuse.FsyncRequest{}
-	}
-	return *(val.(*fuse.FsyncRequest))
-}
-
-// Mkdirs records a Mkdir request and its fields.
-type Mkdirs struct {
-	rec RequestRecorder
-}
-
-var _ = fs.NodeMkdirer(&Mkdirs{})
-
-// Mkdir records the request and returns an error. Most callers should
-// wrap this call in a function that returns a more useful result.
-func (r *Mkdirs) Mkdir(ctx context.Context, req *fuse.MkdirRequest) (fs.Node, error) {
-	tmp := *req
-	r.rec.RecordRequest(&tmp)
-	return nil, fuse.EIO
-}
-
-// RecordedMkdir returns information about the Mkdir request.
-// If no request was seen, returns a zero value.
-func (r *Mkdirs) RecordedMkdir() fuse.MkdirRequest {
-	val := r.rec.Recorded()
-	if val == nil {
-		return fuse.MkdirRequest{}
-	}
-	return *(val.(*fuse.MkdirRequest))
-}
-
-// Symlinks records a Symlink request and its fields.
-type Symlinks struct {
-	rec RequestRecorder
-}
-
-var _ = fs.NodeSymlinker(&Symlinks{})
-
-// Symlink records the request and returns an error. Most callers should
-// wrap this call in a function that returns a more useful result.
-func (r *Symlinks) Symlink(ctx context.Context, req *fuse.SymlinkRequest) (fs.Node, error) {
-	tmp := *req
-	r.rec.RecordRequest(&tmp)
-	return nil, fuse.EIO
-}
-
-// RecordedSymlink returns information about the Symlink request.
-// If no request was seen, returns a zero value.
-func (r *Symlinks) RecordedSymlink() fuse.SymlinkRequest {
-	val := r.rec.Recorded()
-	if val == nil {
-		return fuse.SymlinkRequest{}
-	}
-	return *(val.(*fuse.SymlinkRequest))
-}
-
-// Links records a Link request and its fields.
-type Links struct {
-	rec RequestRecorder
-}
-
-var _ = fs.NodeLinker(&Links{})
-
-// Link records the request and returns an error. Most callers should
-// wrap this call in a function that returns a more useful result.
-func (r *Links) Link(ctx context.Context, req *fuse.LinkRequest, old fs.Node) (fs.Node, error) {
-	tmp := *req
-	r.rec.RecordRequest(&tmp)
-	return nil, fuse.EIO
-}
-
-// RecordedLink returns information about the Link request.
-// If no request was seen, returns a zero value.
-func (r *Links) RecordedLink() fuse.LinkRequest {
-	val := r.rec.Recorded()
-	if val == nil {
-		return fuse.LinkRequest{}
-	}
-	return *(val.(*fuse.LinkRequest))
-}
-
-// Mknods records a Mknod request and its fields.
-type Mknods struct {
-	rec RequestRecorder
-}
-
-var _ = fs.NodeMknoder(&Mknods{})
-
-// Mknod records the request and returns an error. Most callers should
-// wrap this call in a function that returns a more useful result.
-func (r *Mknods) Mknod(ctx context.Context, req *fuse.MknodRequest) (fs.Node, error) {
-	tmp := *req
-	r.rec.RecordRequest(&tmp)
-	return nil, fuse.EIO
-}
-
-// RecordedMknod returns information about the Mknod request.
-// If no request was seen, returns a zero value.
-func (r *Mknods) RecordedMknod() fuse.MknodRequest {
-	val := r.rec.Recorded()
-	if val == nil {
-		return fuse.MknodRequest{}
-	}
-	return *(val.(*fuse.MknodRequest))
-}
-
-// Opens records a Open request and its fields.
-type Opens struct {
-	rec RequestRecorder
-}
-
-var _ = fs.NodeOpener(&Opens{})
-
-// Open records the request and returns an error. Most callers should
-// wrap this call in a function that returns a more useful result.
-func (r *Opens) Open(ctx context.Context, req *fuse.OpenRequest, resp *fuse.OpenResponse) (fs.Handle, error) {
-	tmp := *req
-	r.rec.RecordRequest(&tmp)
-	return nil, fuse.EIO
-}
-
-// RecordedOpen returns information about the Open request.
-// If no request was seen, returns a zero value.
-func (r *Opens) RecordedOpen() fuse.OpenRequest {
-	val := r.rec.Recorded()
-	if val == nil {
-		return fuse.OpenRequest{}
-	}
-	return *(val.(*fuse.OpenRequest))
-}
-
-// Getxattrs records a Getxattr request and its fields.
-type Getxattrs struct {
-	rec RequestRecorder
-}
-
-var _ = fs.NodeGetxattrer(&Getxattrs{})
-
-// Getxattr records the request and returns an error. Most callers should
-// wrap this call in a function that returns a more useful result.
-func (r *Getxattrs) Getxattr(ctx context.Context, req *fuse.GetxattrRequest, resp *fuse.GetxattrResponse) error {
-	tmp := *req
-	r.rec.RecordRequest(&tmp)
-	return fuse.ErrNoXattr
-}
-
-// RecordedGetxattr returns information about the Getxattr request.
-// If no request was seen, returns a zero value.
-func (r *Getxattrs) RecordedGetxattr() fuse.GetxattrRequest {
-	val := r.rec.Recorded()
-	if val == nil {
-		return fuse.GetxattrRequest{}
-	}
-	return *(val.(*fuse.GetxattrRequest))
-}
-
-// Listxattrs records a Listxattr request and its fields.
-type Listxattrs struct {
-	rec RequestRecorder
-}
-
-var _ = fs.NodeListxattrer(&Listxattrs{})
-
-// Listxattr records the request and returns an error. Most callers should
-// wrap this call in a function that returns a more useful result.
-func (r *Listxattrs) Listxattr(ctx context.Context, req *fuse.ListxattrRequest, resp *fuse.ListxattrResponse) error {
-	tmp := *req
-	r.rec.RecordRequest(&tmp)
-	return fuse.ErrNoXattr
-}
-
-// RecordedListxattr returns information about the Listxattr request.
-// If no request was seen, returns a zero value.
-func (r *Listxattrs) RecordedListxattr() fuse.ListxattrRequest {
-	val := r.rec.Recorded()
-	if val == nil {
-		return fuse.ListxattrRequest{}
-	}
-	return *(val.(*fuse.ListxattrRequest))
-}
-
-// Setxattrs records a Setxattr request and its fields.
-type Setxattrs struct {
-	rec RequestRecorder
-}
-
-var _ = fs.NodeSetxattrer(&Setxattrs{})
-
-// Setxattr records the request and returns an error. Most callers should
-// wrap this call in a function that returns a more useful result.
-func (r *Setxattrs) Setxattr(ctx context.Context, req *fuse.SetxattrRequest) error {
-	tmp := *req
-	r.rec.RecordRequest(&tmp)
-	return nil
-}
-
-// RecordedSetxattr returns information about the Setxattr request.
-// If no request was seen, returns a zero value.
-func (r *Setxattrs) RecordedSetxattr() fuse.SetxattrRequest {
-	val := r.rec.Recorded()
-	if val == nil {
-		return fuse.SetxattrRequest{}
-	}
-	return *(val.(*fuse.SetxattrRequest))
-}
-
-// Removexattrs records a Removexattr request and its fields.
-type Removexattrs struct {
-	rec RequestRecorder
-}
-
-var _ = fs.NodeRemovexattrer(&Removexattrs{})
-
-// Removexattr records the request and returns an error. Most callers should
-// wrap this call in a function that returns a more useful result.
-func (r *Removexattrs) Removexattr(ctx context.Context, req *fuse.RemovexattrRequest) error {
-	tmp := *req
-	r.rec.RecordRequest(&tmp)
-	return nil
-}
-
-// RecordedRemovexattr returns information about the Removexattr request.
-// If no request was seen, returns a zero value.
-func (r *Removexattrs) RecordedRemovexattr() fuse.RemovexattrRequest {
-	val := r.rec.Recorded()
-	if val == nil {
-		return fuse.RemovexattrRequest{}
-	}
-	return *(val.(*fuse.RemovexattrRequest))
-}

Godeps/_workspace/src/bazil.org/fuse/fs/fstestutil/record/wait.go

-package record
-
-import (
-	"context"
-	"sync"
-	"time"
-
-	"github.com/ipfs/go-ipfs/Godeps/_workspace/src/bazil.org/fuse"
-	"github.com/ipfs/go-ipfs/Godeps/_workspace/src/bazil.org/fuse/fs"
-)
-
-type nothing struct{}
-
-// ReleaseWaiter notes whether a FUSE Release call has been seen.
-//
-// Releases are not guaranteed to happen synchronously with any client
-// call, so they must be waited for.
-type ReleaseWaiter struct {
-	once sync.Once
-	seen chan nothing
-}
-
-var _ = fs.HandleReleaser(&ReleaseWaiter{})
-
-func (r *ReleaseWaiter) init() {
-	r.once.Do(func() {
-		r.seen = make(chan nothing, 1)
-	})
-}
-
-func (r *ReleaseWaiter) Release(ctx context.Context, req *fuse.ReleaseRequest) error {
-	r.init()
-	close(r.seen)
-	return nil
-}
-
-// WaitForRelease waits for Release to be called.
-//
-// With zero duration, wait forever. Otherwise, timeout early
-// in a more controller way than `-test.timeout`.
-//
-// Returns whether a Release was seen. Always true if dur==0.
-func (r *ReleaseWaiter) WaitForRelease(dur time.Duration) bool {
-	r.init()
-	var timeout <-chan time.Time
-	if dur > 0 {
-		timeout = time.After(dur)
-	}
-	select {
-	case <-r.seen:
-		return true
-	case <-timeout:
-		return false
-	}
-}

Godeps/_workspace/src/bazil.org/fuse/fs/fstestutil/testfs.go

-package fstestutil
-
-import (
-	"context"
-	"os"
-
-	"github.com/ipfs/go-ipfs/Godeps/_workspace/src/bazil.org/fuse"
-	"github.com/ipfs/go-ipfs/Godeps/_workspace/src/bazil.org/fuse/fs"
-)
-
-// SimpleFS is a trivial FS that just implements the Root method.
-type SimpleFS struct {
-	Node fs.Node
-}
-
-var _ = fs.FS(SimpleFS{})
-
-func (f SimpleFS) Root() (fs.Node, error) {
-	return f.Node, nil
-}
-
-// File can be embedded in a struct to make it look like a file.
-type File struct{}
-
-func (f File) Attr(ctx context.Context, a *fuse.Attr) error {
-	a.Mode = 0666
-	return nil
-}
-
-// Dir can be embedded in a struct to make it look like a directory.
-type Dir struct{}
-
-func (f Dir) Attr(ctx context.Context, a *fuse.Attr) error {
-	a.Mode = os.ModeDir | 0777
-	return nil
-}
-
-// ChildMap is a directory with child nodes looked up from a map.
-type ChildMap map[string]fs.Node
-
-var _ = fs.Node(ChildMap{})
-var _ = fs.NodeStringLookuper(ChildMap{})
-
-func (f ChildMap) Attr(ctx context.Context, a *fuse.Attr) error {
-	a.Mode = os.ModeDir | 0777
-	return nil
-}
-
-func (f ChildMap) Lookup(ctx context.Context, name string) (fs.Node, error) {
-	child, ok := f[name]
-	if !ok {
-		return nil, fuse.ENOENT
-	}
-	return child, nil
-}

Godeps/_workspace/src/bazil.org/fuse/fs/helpers_test.go

-package fs_test
-
-import (
-	"errors"
-	"flag"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"testing"
-)
-
-var childHelpers = map[string]func(){}
-
-type childProcess struct {
-	name string
-	fn   func()
-}
-
-var _ flag.Value = (*childProcess)(nil)
-
-func (c *childProcess) String() string {
-	return c.name
-}
-
-func (c *childProcess) Set(s string) error {
-	fn, ok := childHelpers[s]
-	if !ok {
-		return errors.New("helper not found")
-	}
-	c.name = s
-	c.fn = fn
-	return nil
-}
-
-var childMode childProcess
-
-func init() {
-	flag.Var(&childMode, "fuse.internal.child", "internal use only")
-}
-
-// childCmd prepares a test function to be run in a subprocess, with
-// childMode set to true. Caller must still call Run or Start.
-//
-// Re-using the test executable as the subprocess is useful because
-// now test executables can e.g. be cross-compiled, transferred
-// between hosts, and run in settings where the whole Go development
-// environment is not installed.
-func childCmd(childName string) (*exec.Cmd, error) {
-	// caller may set cwd, so we can't rely on relative paths
-	executable, err := filepath.Abs(os.Args[0])
-	if err != nil {
-		return nil, err
-	}
-	cmd := exec.Command(executable, "-fuse.internal.child="+childName)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	return cmd, nil
-}
-
-func TestMain(m *testing.M) {
-	flag.Parse()
-	if childMode.fn != nil {
-		childMode.fn()
-		os.Exit(0)
-	}
-	os.Exit(m.Run())
-}

Godeps/_workspace/src/bazil.org/fuse/fuse_kernel_freebsd.go

-package fuse
-
-import "time"
-
-type attr struct {
-	Ino       uint64
-	Size      uint64
-	Blocks    uint64
-	Atime     uint64
-	Mtime     uint64
-	Ctime     uint64
-	AtimeNsec uint32
-	MtimeNsec uint32
-	CtimeNsec uint32
-	Mode      uint32
-	Nlink     uint32
-	Uid       uint32
-	Gid       uint32
-	Rdev      uint32
-}
-
-func (a *attr) Crtime() time.Time {
-	return time.Time{}
-}
-
-func (a *attr) SetCrtime(s uint64, ns uint32) {
-	// ignored on freebsd
-}
-
-func (a *attr) SetFlags(f uint32) {
-	// ignored on freebsd
-}
-
-type setattrIn struct {
-	setattrInCommon
-}
-
-func (in *setattrIn) BkupTime() time.Time {
-	return time.Time{}
-}
-
-func (in *setattrIn) Chgtime() time.Time {
-	return time.Time{}
-}
-
-func (in *setattrIn) Flags() uint32 {
-	return 0
-}
-
-func openFlags(flags uint32) OpenFlags {
-	return OpenFlags(flags)
-}
-
-type getxattrIn struct {
-	getxattrInCommon
-}
-
-type setxattrIn struct {
-	setxattrInCommon
-}

Godeps/_workspace/src/bazil.org/fuse/fuse_kernel_std.go

-package fuse

Godeps/_workspace/src/bazil.org/fuse/syscallx/syscallx.go

-package syscallx
-
-// make us look more like package syscall, so mksyscall.pl output works
-var _zero uintptr