The protocol is:

  request: read (with buffer 1024)
  response: data (if buffer is big enough), or (data size, ERANGE)

Before, the raw API provided

* GetXAttrSize: called if the kernel sends a 0 sized buffer (which
  never happens

* GetXAttrData: called in other cases. The return value is []byte
  forcing allocation of potentially large buffers

* ListXAttr: return value []byte, so also problematic for allocation.

Now, the raw API mirrors the kernel API more closely, and use recycled
buffers for more efficiency.

This should be tagged with a version bump because it changes the
RawFileSystem API.

Changes to nodefs and paths will be transparent: a Cancel channel was
added to the fuse.Context struct. In addition fuse.Context now
implements the Go context package. This also increases the minimum Go
version to 1.7.

compile on darwin too

When using automatic NodeIds, we can still have a race.

Suggestion by Kirill Smelkov.

This causes an INTERRUPT to happen, which is useful to see in
practice.

When adding a sleep to the READ operation, this yields the following
trace:

 rx 28: OPEN i2 {O_RDONLY,0x8000} 
 tx 28:     OK, {Fh 1 }
 rx 30: READ i2 {Fh 1 [0 +4096)  L 0 RDONLY,0x8000} 
 killing subprocess
 rx 32: FLUSH i2 {Fh 1} 
 tx 32:     OK
 rx 33: INTERRUPT i0 {ix 32} 
 tx 33:     OK
 tx 30:     OK,  1024b data "********"...
 rx 34: RELEASE i2 {Fh 1 0x8000  L0} 
 tx 34:     OK


ie. rather than canceling the READ, a FLUSH is issued which is then
INTERRUPTed.

Add stub implementations for the rest of the methods from the
Operations interface, and add a compile-time check that we don't
have missed any.

This should decrease confusion between Inode and Node

This lets filesystems control Generation produced. It also unifies
OpaqueID (used for implementors) NodeID (used for kernel comms) and
the Ino field (reported in Stat/Lstat calls).

For loopback, there is a minor inconvenience, which is that the file
is determined by (Dev, Ino). Get around this by xoring Dev and Ino.

Fix and test Nlink==0 test (issue #137)

Do not overwrite Attr.Ino, otherwise recycled inodes risk giving tools
like RSync the impression there are more hardlinks than there are.

identification

This fixes another possible race condition if the same file is looked
up through 2 different paths.

Remove FindChildByOpaqueID(), since it is still susceptible to race
conditions: two lookup calls might be racing, and both may see
FindChildByOpaqueID == nil, creating two Node objects

Instead, NewInode() automatically discards a new Node if it finds one
with existing opaqueID.

The FileID struct has (uint64,uint64) for Dev, Ino. While Dev
typically is uint32 (the FUSE protocol has uint32), it is uint64
analogous to syscall.Stat_t. The resulting 128 bits of ID space is
also ample space for storing hashes of other IDs (eg strings)

Inode.MvChild

Fix opaqueID