Directory entries having "/" character - input/output error.

[prasad83]

When Directory has filename with "/" - results of ls randomly shows input/output error.

[prasad83]

main.go

package main

import (
	"context"
	"fmt"
	"os"
	"os/exec"
	"os/signal"
	"syscall"
	"time"

	"bazil.org/fuse"
	"bazil.org/fuse/fs"
)

type EntryGetter interface {
	GetDirentType() fuse.DirentType
}

type myFS struct {
}

func (mfs *myFS) Root() (fs.Node, error) {
	return newDir()
}

type myNode struct {
	Type  fuse.DirentType
	Attrs fuse.Attr
}

func (n *myNode) GetDirentType() fuse.DirentType {
	return n.Type
}

func (n *myNode) Attr(ctx context.Context, a *fuse.Attr) error {
	*a = n.Attrs
	return nil
}

type myDir struct {
	myNode
	Entries map[string]interface{}
}

func (d *myDir) Lookup(ctx context.Context, name string) (fs.Node, error) {
	if node, ok := d.Entries[name]; ok {
		return node.(fs.Node), nil
	}
	return nil, syscall.ENOENT
}

func (d *myDir) ReadDirAll(ctx context.Context) ([]fuse.Dirent, error) {
	var entries []fuse.Dirent
	for k, v := range d.Entries {
		var a fuse.Attr
		v.(fs.Node).Attr(ctx, &a)
		entries = append(entries, fuse.Dirent{
			Name:  k,
			Inode: a.Inode,
			Type:  v.(EntryGetter).GetDirentType(),
		})
	}

	return entries, nil
}

type myFile struct {
	myNode
	content []byte
}

func (f *myFile) ReadAll(ctx context.Context) ([]byte, error) {
	return f.content, nil
}

func newFS() fs.FS {
	return &myFS{}
}

func newDir() (fs.Node, error) {
	filenames := []string{
		"ABC",
		"ABC/def",
	}

	dir := &myDir{
		myNode: myNode{
			Type: fuse.DT_Dir,
			Attrs: fuse.Attr{
				Inode: 1,
				Atime: time.Now(),
				Mtime: time.Now(),
				Ctime: time.Now(),
				Mode:  os.ModeDir | 0o777,
			},
		},
		Entries: make(map[string]interface{}),
	}

	for findex, fname := range filenames {
                fcontent := []byte(fname)
		dir.Entries[fname] = &myFile{
			myNode: myNode{
				Type: fuse.DT_File,
				Attrs: fuse.Attr{
					Inode: uint64(findex + 1),
					Mode:  0o644,
                                        Size: uint64(len(fcontent)),
					Atime: time.Now(),
					Mtime: time.Now(),
					Ctime: time.Now(),
				},
			},
			content: fcontent,
		}
	}

	return dir, nil
}

func main() {
	mountpoint := "/mnt"

	c, err := fuse.Mount(mountpoint, fuse.FSName("myfs"), fuse.Subtype("myfs"))
	if err != nil {
		panic(err)
	}
	defer c.Close()

	sigc := make(chan os.Signal, 1)
	signal.Notify(sigc, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
	go func() {
		switch <-sigc {
		case syscall.SIGHUP:
			println("signal: hangup")
		case syscall.SIGINT:
			println("signal: interrupt")
		case syscall.SIGTERM:
			println("signal: terminate")
		case syscall.SIGQUIT:
			println("signal: quit")
		}

		// unmount safely
		if err := exec.Command("fusermount3", "-u", mountpoint).Run(); err != nil {
			println("error: could not unmount, use [sudo fusermount -u " + mountpoint + "]")
		}
		os.Exit(0)
	}()

	fmt.Println("filesystem mounted at " + mountpoint + ", use CRTL+C to stop")
	server := fs.New(c, &fs.Config{
		Debug: func(msg interface{}) {
			fmt.Printf("[DEBUG] %v\n", msg)
		},
	})

	if err := server.Serve(newFS()); err != nil {
		panic(err)
	}
}

[prasad83]

go build main.go
sudo ./main

ls /mnt

ls: reading directory '/mnt': Input/output error
ABC

ABC/def is not listed.

[tv42]

Linux/UNIX directory entry names cannot contain slashes. I do not expect the IO errors to be "random", at all, but very consistent.

What are you trying to do here?

[tv42]

This seems to be a misunderstanding of UNIX filesystems, with nothing actionable here.