Killed off InitOp.
This wasn't useful to users to begin with, and an API change in bazil.org/fuse made it non-functional. Fixes #10.geesefs-0-30-9
commit
23590532ff
|
@ -42,14 +42,6 @@ func Convert(
|
|||
|
||||
var io internalOp
|
||||
switch typed := r.(type) {
|
||||
case *bazilfuse.InitRequest:
|
||||
to := &InitOp{
|
||||
maxReadahead: typed.MaxReadahead,
|
||||
}
|
||||
|
||||
io = to
|
||||
co = &to.commonOp
|
||||
|
||||
case *bazilfuse.LookupRequest:
|
||||
to := &LookUpInodeOp{
|
||||
Parent: InodeID(typed.Header.Node),
|
||||
|
|
|
@ -53,64 +53,6 @@ type Op interface {
|
|||
Logf(format string, v ...interface{})
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
// Setup
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// Sent once when mounting the file system. It must succeed in order for the
|
||||
// mount to succeed.
|
||||
type InitOp struct {
|
||||
commonOp
|
||||
|
||||
maxReadahead uint32
|
||||
}
|
||||
|
||||
func (o *InitOp) toBazilfuseResponse() (bfResp interface{}) {
|
||||
resp := bazilfuse.InitResponse{}
|
||||
bfResp = &resp
|
||||
|
||||
// Ask the Linux kernel for larger write requests.
|
||||
//
|
||||
// As of 2015-03-26, the behavior in the kernel is:
|
||||
//
|
||||
// * (http://goo.gl/jMKHMZ, http://goo.gl/XTF4ZH) Cap the max write size at
|
||||
// the maximum of 4096 and init_response->max_write.
|
||||
//
|
||||
// * (http://goo.gl/gEIvHZ) If FUSE_BIG_WRITES isn't set, don't return more
|
||||
// than one page.
|
||||
//
|
||||
// * (http://goo.gl/4RLhxZ, http://goo.gl/hi0Cm2) Never write more than
|
||||
// FUSE_MAX_PAGES_PER_REQ pages (128 KiB on x86).
|
||||
//
|
||||
// 4 KiB is crazy small. Ask for significantly more, and take what the kernel
|
||||
// will give us.
|
||||
const maxWrite = 1 << 21
|
||||
resp.Flags |= bazilfuse.InitBigWrites
|
||||
resp.MaxWrite = maxWrite
|
||||
|
||||
// Ask the Linux kernel for larger read requests.
|
||||
//
|
||||
// As of 2015-03-26, the behavior in the kernel is:
|
||||
//
|
||||
// * (http://goo.gl/bQ1f1i, http://goo.gl/HwBrR6) Set the local variable
|
||||
// ra_pages to be init_response->max_readahead divided by the page size.
|
||||
//
|
||||
// * (http://goo.gl/gcIsSh, http://goo.gl/LKV2vA) Set
|
||||
// backing_dev_info::ra_pages to the min of that value and what was sent
|
||||
// in the request's max_readahead field.
|
||||
//
|
||||
// * (http://goo.gl/u2SqzH) Use backing_dev_info::ra_pages when deciding
|
||||
// how much to read ahead.
|
||||
//
|
||||
// * (http://goo.gl/JnhbdL) Don't read ahead at all if that field is zero.
|
||||
//
|
||||
// Reading a page at a time is a drag. Ask for as much as the kernel is
|
||||
// willing to give us.
|
||||
resp.MaxReadahead = o.maxReadahead
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
// Inodes
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
|
|
@ -40,7 +40,6 @@ var fRandomDelays = flag.Bool(
|
|||
// See NotImplementedFileSystem for a convenient way to embed default
|
||||
// implementations for methods you don't care about.
|
||||
type FileSystem interface {
|
||||
Init(*fuseops.InitOp) error
|
||||
LookUpInode(*fuseops.LookUpInodeOp) error
|
||||
GetInodeAttributes(*fuseops.GetInodeAttributesOp) error
|
||||
SetInodeAttributes(*fuseops.SetInodeAttributesOp) error
|
||||
|
@ -128,9 +127,6 @@ func (s *fileSystemServer) handleOp(op fuseops.Op) {
|
|||
default:
|
||||
err = fuse.ENOSYS
|
||||
|
||||
case *fuseops.InitOp:
|
||||
err = s.fs.Init(typed)
|
||||
|
||||
case *fuseops.LookUpInodeOp:
|
||||
err = s.fs.LookUpInode(typed)
|
||||
|
||||
|
|
|
@ -28,12 +28,6 @@ type NotImplementedFileSystem struct {
|
|||
|
||||
var _ FileSystem = &NotImplementedFileSystem{}
|
||||
|
||||
func (fs *NotImplementedFileSystem) Init(
|
||||
op *fuseops.InitOp) (err error) {
|
||||
err = fuse.ENOSYS
|
||||
return
|
||||
}
|
||||
|
||||
func (fs *NotImplementedFileSystem) LookUpInode(
|
||||
op *fuseops.LookUpInodeOp) (err error) {
|
||||
err = fuse.ENOSYS
|
||||
|
|
|
@ -184,9 +184,7 @@ func (c *MountConfig) bazilfuseOptions() (opts []bazilfuse.MountOption) {
|
|||
|
||||
// Attempt to mount a file system on the given directory, using the supplied
|
||||
// Server to serve connection requests. This function blocks until the file
|
||||
// system is successfully mounted. On some systems, this requires the supplied
|
||||
// Server to make forward progress (in particular, to respond to
|
||||
// fuseops.InitOp).
|
||||
// system is successfully mounted.
|
||||
func Mount(
|
||||
dir string,
|
||||
server Server,
|
||||
|
|
|
@ -238,11 +238,6 @@ func (fs *cachingFS) SetMtime(mtime time.Time) {
|
|||
// FileSystem methods
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
func (fs *cachingFS) Init(
|
||||
op *fuseops.InitOp) (err error) {
|
||||
return
|
||||
}
|
||||
|
||||
// LOCKS_EXCLUDED(fs.mu)
|
||||
func (fs *cachingFS) LookUpInode(
|
||||
op *fuseops.LookUpInodeOp) (err error) {
|
||||
|
|
|
@ -92,11 +92,6 @@ func (fs *flushFS) barAttributes() fuseops.InodeAttributes {
|
|||
// FileSystem methods
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
func (fs *flushFS) Init(
|
||||
op *fuseops.InitOp) (err error) {
|
||||
return
|
||||
}
|
||||
|
||||
func (fs *flushFS) LookUpInode(
|
||||
op *fuseops.LookUpInodeOp) (err error) {
|
||||
fs.mu.Lock()
|
||||
|
|
|
@ -222,11 +222,6 @@ func (fs *fsImpl) findInodeByID(id fuseops.InodeID) (in *inode) {
|
|||
// FileSystem methods
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
func (fs *fsImpl) Init(
|
||||
op *fuseops.InitOp) (err error) {
|
||||
return
|
||||
}
|
||||
|
||||
func (fs *fsImpl) LookUpInode(
|
||||
op *fuseops.LookUpInodeOp) (err error) {
|
||||
fs.mu.Lock()
|
||||
|
|
|
@ -147,10 +147,6 @@ func (fs *helloFS) patchAttributes(
|
|||
attr.Crtime = now
|
||||
}
|
||||
|
||||
func (fs *helloFS) Init(op *fuseops.InitOp) (err error) {
|
||||
return
|
||||
}
|
||||
|
||||
func (fs *helloFS) LookUpInode(op *fuseops.LookUpInodeOp) (err error) {
|
||||
// Find the info for the parent.
|
||||
parentInfo, ok := gInodeInfo[op.Parent]
|
||||
|
|
|
@ -77,11 +77,6 @@ func (fs *InterruptFS) WaitForReadInFlight() {
|
|||
// FileSystem methods
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
func (fs *InterruptFS) Init(
|
||||
op *fuseops.InitOp) (err error) {
|
||||
return
|
||||
}
|
||||
|
||||
func (fs *InterruptFS) LookUpInode(
|
||||
op *fuseops.LookUpInodeOp) (err error) {
|
||||
// We support only one parent.
|
||||
|
|
|
@ -199,11 +199,6 @@ func (fs *memFS) deallocateInode(id fuseops.InodeID) {
|
|||
// FileSystem methods
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
func (fs *memFS) Init(
|
||||
op *fuseops.InitOp) (err error) {
|
||||
return
|
||||
}
|
||||
|
||||
func (fs *memFS) LookUpInode(
|
||||
op *fuseops.LookUpInodeOp) (err error) {
|
||||
fs.mu.Lock()
|
||||
|
|
Loading…
Reference in New Issue