fix dep, impl nonempty

vendor/github.com/hanwen/go-fuse/splice/pair.go

@@ -6,11 +6,11 @@ package splice
 
 import (
 	"fmt"
-	"os"
+	"syscall"
 )
 
 type Pair struct {
-	r, w *os.File
+	r, w int
 	size int
 }
 
@@ -30,7 +30,7 @@ func (p *Pair) Grow(n int) error {
 		return fmt.Errorf("splice: want %d bytes, max pipe size %d", n, maxPipeSize)
 	}
 
-	newsize, errNo := fcntl(p.r.Fd(), F_SETPIPE_SZ, n)
+	newsize, errNo := fcntl(uintptr(p.r), F_SETPIPE_SZ, n)
 	if errNo != 0 {
 		return fmt.Errorf("splice: fcntl returned %v", errNo)
 	}
@@ -43,8 +43,8 @@ func (p *Pair) Cap() int {
 }
 
 func (p *Pair) Close() error {
-	err1 := p.r.Close()
-	err2 := p.w.Close()
+	err1 := syscall.Close(p.r)
+	err2 := syscall.Close(p.w)
 	if err1 != nil {
 		return err1
 	}
@@ -52,17 +52,17 @@ func (p *Pair) Close() error {
 }
 
 func (p *Pair) Read(d []byte) (n int, err error) {
-	return p.r.Read(d)
-}
-
-func (p *Pair) ReadFd() uintptr {
-	return p.r.Fd()
-}
-
-func (p *Pair) WriteFd() uintptr {
-	return p.w.Fd()
+	return syscall.Read(p.r, d)
 }
 
 func (p *Pair) Write(d []byte) (n int, err error) {
-	return p.w.Write(d)
+	return syscall.Write(p.w, d)
+}
+
+func (p *Pair) ReadFd() uintptr {
+	return uintptr(p.r)
+}
+
+func (p *Pair) WriteFd() uintptr {
+	return uintptr(p.w)
 }

vendor/github.com/hanwen/go-fuse/splice/pair_linux.go

@@ -11,7 +11,7 @@ import (
 )
 
 func (p *Pair) LoadFromAt(fd uintptr, sz int, off int64) (int, error) {
-	n, err := syscall.Splice(int(fd), &off, int(p.w.Fd()), nil, sz, 0)
+	n, err := syscall.Splice(int(fd), &off, p.w, nil, sz, 0)
 	return int(n), err
 }
 
@@ -21,7 +21,7 @@ func (p *Pair) LoadFrom(fd uintptr, sz int) (int, error) {
 			sz, p.size)
 	}
 
-	n, err := syscall.Splice(int(fd), nil, int(p.w.Fd()), nil, sz, 0)
+	n, err := syscall.Splice(int(fd), nil, p.w, nil, sz, 0)
 	if err != nil {
 		err = os.NewSyscallError("Splice load from", err)
 	}
@@ -29,9 +29,20 @@ func (p *Pair) LoadFrom(fd uintptr, sz int) (int, error) {
 }
 
 func (p *Pair) WriteTo(fd uintptr, n int) (int, error) {
-	m, err := syscall.Splice(int(p.r.Fd()), nil, int(fd), nil, int(n), 0)
+	m, err := syscall.Splice(p.r, nil, int(fd), nil, int(n), 0)
 	if err != nil {
 		err = os.NewSyscallError("Splice write", err)
 	}
 	return int(m), err
 }
+
+const _SPLICE_F_NONBLOCK = 0x2
+
+func (p *Pair) discard() {
+	_, err := syscall.Splice(p.r, nil, int(devNullFD), nil, int(p.size), _SPLICE_F_NONBLOCK)
+	if err == syscall.EAGAIN {
+		// all good.
+	} else if err != nil {
+		panic(err)
+	}
+}

vendor/github.com/hanwen/go-fuse/splice/pool.go

@@ -5,7 +5,6 @@
 package splice
 
 import (
-	"io"
 	"sync"
 )
 
@@ -33,7 +32,7 @@ func Used() int {
 	return splicePool.used()
 }
 
-// Return pipe pair to pool
+// Done returns the pipe pair to pool.
 func Done(p *Pair) {
 	splicePool.done(p)
 }
@@ -47,71 +46,59 @@ func newSplicePairPool() *pairPool {
 	return &pairPool{}
 }
 
-func (me *pairPool) clear() {
-	me.Lock()
-	for _, p := range me.unused {
+func (pp *pairPool) clear() {
+	pp.Lock()
+	for _, p := range pp.unused {
 		p.Close()
 	}
-	me.unused = me.unused[:0]
-	me.Unlock()
+	pp.unused = pp.unused[:0]
+	pp.Unlock()
 }
 
-func (me *pairPool) used() (n int) {
-	me.Lock()
-	n = me.usedCount
-	me.Unlock()
+func (pp *pairPool) used() (n int) {
+	pp.Lock()
+	n = pp.usedCount
+	pp.Unlock()
 
 	return n
 }
 
-func (me *pairPool) total() int {
-	me.Lock()
-	n := me.usedCount + len(me.unused)
-	me.Unlock()
+func (pp *pairPool) total() int {
+	pp.Lock()
+	n := pp.usedCount + len(pp.unused)
+	pp.Unlock()
 	return n
 }
 
-func (me *pairPool) drop(p *Pair) {
+func (pp *pairPool) drop(p *Pair) {
 	p.Close()
-	me.Lock()
-	me.usedCount--
-	me.Unlock()
+	pp.Lock()
+	pp.usedCount--
+	pp.Unlock()
 }
 
-func (me *pairPool) get() (p *Pair, err error) {
-	me.Lock()
-	defer me.Unlock()
+func (pp *pairPool) get() (p *Pair, err error) {
+	pp.Lock()
+	defer pp.Unlock()
 
-	me.usedCount++
-	l := len(me.unused)
+	pp.usedCount++
+	l := len(pp.unused)
 	if l > 0 {
-		p := me.unused[l-1]
-		me.unused = me.unused[:l-1]
+		p := pp.unused[l-1]
+		pp.unused = pp.unused[:l-1]
 		return p, nil
 	}
 
 	return newSplicePair()
 }
 
-var discardBuffer [32 * 1024]byte
+func (pp *pairPool) done(p *Pair) {
+	p.discard()
 
-func DiscardAll(r io.Reader) {
-	buf := discardBuffer[:]
-	for {
-		n, _ := r.Read(buf)
-		if n < len(buf) {
-			break
-		}
-	}
-}
-
-func (me *pairPool) done(p *Pair) {
-	DiscardAll(p.r)
-
-	me.Lock()
-	me.usedCount--
-	me.unused = append(me.unused, p)
-	me.Unlock()
+	pp.Lock()
+	pp.usedCount--
+	pp.unused = append(pp.unused, p)
+	pp.Unlock()
 }
 
 func init() {

vendor/github.com/hanwen/go-fuse/splice/splice.go

@@ -30,6 +30,9 @@ func MaxPipeSize() int {
 // Since Linux 2.6.11, the pipe capacity is 65536 bytes.
 const DefaultPipeSize = 16 * 4096
 
+// We empty pipes by splicing to /dev/null.
+var devNullFD uintptr
+
 func init() {
 	content, err := ioutil.ReadFile("/proc/sys/fs/pipe-max-size")
 	if err != nil {
@@ -48,6 +51,13 @@ func init() {
 	resizable = resizable && (errNo == 0)
 	r.Close()
 	w.Close()
+
+	fd, err := syscall.Open("/dev/null", os.O_WRONLY, 0)
+	if err != nil {
+		log.Panicf("splice: %v", err)
+	}
+
+	devNullFD = uintptr(fd)
 }
 
 // copy & paste from syscall.
@@ -61,30 +71,27 @@ func fcntl(fd uintptr, cmd int, arg int) (val int, errno syscall.Errno) {
 const F_SETPIPE_SZ = 1031
 const F_GETPIPE_SZ = 1032
 
+func osPipe() (int, int, error) {
+	var fds [2]int
+	err := syscall.Pipe2(fds[:], syscall.O_NONBLOCK)
+	return fds[0], fds[1], err
+}
+
 func newSplicePair() (p *Pair, err error) {
 	p = &Pair{}
-	p.r, p.w, err = os.Pipe()
+	p.r, p.w, err = osPipe()
 	if err != nil {
 		return nil, err
 	}
-
-	errNo := syscall.Errno(0)
-	for _, f := range []*os.File{p.r, p.w} {
-		_, errNo = fcntl(f.Fd(), syscall.F_SETFL, syscall.O_NONBLOCK)
-		if errNo != 0 {
-			p.Close()
-			return nil, os.NewSyscallError("fcntl setfl", errNo)
-		}
-	}
-
-	p.size, errNo = fcntl(p.r.Fd(), F_GETPIPE_SZ, 0)
-	if errNo == syscall.EINVAL {
+	var errNo syscall.Errno
+	p.size, errNo = fcntl(uintptr(p.r), F_GETPIPE_SZ, 0)
+	if err == syscall.EINVAL {
 		p.size = DefaultPipeSize
 		return p, nil
 	}
 	if errNo != 0 {
 		p.Close()
-		return nil, os.NewSyscallError("fcntl getsize", errNo)
+		return nil, fmt.Errorf("fcntl getsize: %v", errNo)
 	}
 	return p, nil
 }