func (fs *loopbackFileSystem) Open(name string, flags uint32, context *fuse.Context) (fuseFile nodefs.File, status fuse.Status) { f, err := os.OpenFile(fs.GetPath(name), int(flags), 0) if err != nil { return nil, fuse.ToStatus(err) } return nodefs.NewLoopbackFile(f), fuse.OK }
func (me *memNode) Open(flags uint32, context *fuse.Context) (file nodefs.File, code fuse.Status) { me.mutex.Lock() defer me.mutex.Unlock() if flags&fuse.O_ANYWRITE != 0 { me.promote() me.touch() } if me.backing != "" { f, err := os.OpenFile(me.backing, int(flags), 0666) if err != nil { return nil, fuse.ToStatus(err) } wr := flags&fuse.O_ANYWRITE != 0 if wr { me.fs.openWritable++ } return me.newFile(nodefs.NewLoopbackFile(f), wr), fuse.OK } file, code = me.fs.readonly.Open(me.original, flags, context) if !code.Ok() { return nil, code } return me.newFile(file, false), fuse.OK }
func (n *p4File) Open(flags uint32, context *fuse.Context) (file nodefs.File, code fuse.Status) { if flags&fuse.O_ANYWRITE != 0 { return nil, fuse.EROFS } n.fetch() f, err := os.OpenFile(n.backing, int(flags), 0644) if err != nil { return nil, fuse.ToStatus(err) } return nodefs.NewLoopbackFile(f), fuse.OK }
func (p *pendingFile) Read(data []byte, off int64) (fuse.ReadResult, fuse.Status) { if p.loopback == nil { if err := p.node.fetch(); err != nil { log.Printf("fetch failed: %v", err) return nil, fuse.EIO } f, err := os.OpenFile(p.node.backing, os.O_RDWR|os.O_CREATE, 0644) if err != nil { return nil, fuse.ToStatus(err) } p.loopback = nodefs.NewLoopbackFile(f) } return p.loopback.Read(data, off) }
func (p *pendingFile) rwLoopback() (nodefs.File, fuse.Status) { if p.loopback == nil { if err := p.node.fetch(); err != nil { return nil, fuse.ToStatus(err) } f, err := os.OpenFile(p.node.backing, os.O_RDWR|os.O_CREATE, 0644) if err != nil { return nil, fuse.ToStatus(err) } p.loopback = nodefs.NewLoopbackFile(f) } return p.loopback, fuse.OK }
func (me *memNode) Create(name string, flags uint32, mode uint32, context *fuse.Context) (file nodefs.File, ch *nodefs.Inode, code fuse.Status) { me.mutex.Lock() defer me.mutex.Unlock() n := me.fs.newNode(false) n.info.Mode = mode | fuse.S_IFREG n.changed = true n.backing = me.fs.getFilename() f, err := os.Create(n.backing) if err != nil { log.Printf("Backing store error %q: %v", n.backing, err) return nil, nil, fuse.ToStatus(err) } ch = me.Inode().NewChild(name, false, n) me.touch() me.fs.openWritable++ return n.newFile(nodefs.NewLoopbackFile(f), true), ch, fuse.OK }
func (fs *deviceFS) createClassicFile(obj mtp.ObjectInfo) (file nodefs.File, node nodefs.Node, err error) { backingFile, err := ioutil.TempFile(fs.options.Dir, "") cl := &classicNode{ mtpNodeImpl: mtpNodeImpl{ Node: nodefs.NewDefaultNode(), obj: &obj, fs: fs, }, dirty: true, backing: backingFile.Name(), } file = &pendingFile{ loopback: nodefs.NewLoopbackFile(backingFile), node: cl, File: nodefs.NewDefaultFile(), } node = cl return }
// NewFile returns a new go-fuse File instance. func NewFile(fd *os.File, writeOnly bool, fs *FS) (nodefs.File, fuse.Status) { var st syscall.Stat_t err := syscall.Fstat(int(fd.Fd()), &st) if err != nil { tlog.Warn.Printf("NewFile: Fstat on fd %d failed: %v\n", fd.Fd(), err) return nil, fuse.ToStatus(err) } di := DevInoFromStat(&st) t := openFileMap.register(di) return &file{ fd: fd, writeOnly: writeOnly, contentEnc: fs.contentEnc, devIno: di, fileTableEntry: t, loopbackFile: nodefs.NewLoopbackFile(fd), fs: fs, }, fuse.OK }
func (n *blobNode) LoadDisk() (nodefs.File, error) { p := filepath.Join(n.fs.opts.TempDir, n.id.String()) if _, err := os.Lstat(p); os.IsNotExist(err) { blob, err := n.fs.repo.LookupBlob(n.id) if err != nil { return nil, err } defer blob.Free() // TODO - atomic, use content store to share content. if err := ioutil.WriteFile(p, blob.Contents(), 0644); err != nil { return nil, err } } f, err := os.Open(p) if err != nil { return nil, err } return nodefs.NewLoopbackFile(f), nil }
// Must run inside mutex. func (me *memNode) promote() { if me.backing == "" { me.backing = me.fs.getFilename() destfs := pathfs.NewLoopbackFileSystem("/") pathfs.CopyFile(me.fs.readonly, destfs, me.original, strings.TrimLeft(me.backing, "/"), nil) me.original = "" files := me.Inode().Files(0) for _, f := range files { mf := f.File.(*memNodeFile) inner := mf.File osFile, err := os.Open(me.backing) if err != nil { panic("error opening backing file") } mf.File = nodefs.NewLoopbackFile(osFile) inner.Flush() inner.Release() } } }
func (fs *loopbackFileSystem) Create(path string, flags uint32, mode uint32, context *fuse.Context) (fuseFile nodefs.File, code fuse.Status) { f, err := os.OpenFile(fs.GetPath(path), int(flags)|os.O_CREATE, os.FileMode(mode)) return nodefs.NewLoopbackFile(f), fuse.ToStatus(err) }