FUSE + Go: ковка собственной виртуальной файловой системы на блочном устройстве

В этой статье подробно разбирается создание пользовательской файловой системы с помощью FUSE и языка Go. На реальном примере мы пройдём путь от установки окружения до реализации чтения, записи, метаданных и параллельного доступа. В процессе встретятся живые комментарии, личные наблюдения и советы, которые помогут избежать распространённых подводных камней.

Введение
Давно хотел понять, как сделать “файловую систему в файле” или на блочном устройстве, чтобы потом подключить её к любому Linux-серверу. Оказалось, что комбинация FUSE и Go — отличный вариант для быстрой прототипировки без костылей на C. В этой статье я расскажу о своём опыте, забавных факапах и главных открытиях на пути к рабочей системе.

Почему FUSE и Go — идеальный дуэт

FUSE (Filesystem in Userspace) позволяет запускать код файловой системы в пространстве пользователя, не лезя в ядро. Go же приносит удобную модель конкурентности, сборщик мусора и понятный синтаксис. Вместе они дают возможность писать надёжный код в сотни строк, а не в тысячи.

Подготовка окружения и зависимости

На Ubuntu/Debian всё просто:

sudo apt update sudo apt install golang-go libfuse-dev export GO111MODULE=on mkdir -p ~/go/src/fusefs && cd ~/go/src/fusefs go mod init github.com/you/fusefs go get bazil.org/fuse go get bazil.org/fuse/fs

Здесь bazil.org/fuse — наиболее “гуёвый” биндинг к libfuse.

Черновой набросок проекта

Создаём файл main.go с минимальным кодом:

// main.go package main  import (     "bazil.org/fuse"     "bazil.org/fuse/fs"     "context"     "log" )  func main() {     conn, err := fuse.Mount(         "/mnt/fusefs",         fuse.FSName("fusefs"),         fuse.Subtype("customfs"),         fuse.LocalVolume(),         fuse.VolumeName("GoFUSE"),     )     if err != nil {         log.Fatal(err)     }     defer conn.Close()      err = fs.Serve(conn, FS{})     if err != nil {         log.Fatal(err)     } }

Здесь FS{} — наш корневой узел, который реализует интерфейс fs.FS.

Реализация корневого узла и каталогов

Немного магии — делаем корневой каталог:

type FS struct{}  func (FS) Root() (fs.Node, error) {     return &Dir{         entries: map[string]fs.Node{             "hello.txt": &File{data: []byte("Привет, FUSE + Go!\n")},         },     }, nil }  type Dir struct {     entries map[string]fs.Node }  func (d *Dir) Attr(ctx context.Context, a *fuse.Attr) error {     a.Mode = os.ModeDir | 0o755     return nil }  func (d *Dir) Lookup(ctx context.Context, name string) (fs.Node, error) {     if node, ok := d.entries[name]; ok {         return node, nil     }     return nil, fuse.ENOENT }  func (d *Dir) ReadDirAll(ctx context.Context) ([]fuse.Dirent, error) {     var list []fuse.Dirent     for name := range d.entries {         list = append(list, fuse.Dirent{Name: name})     }     return list, nil }

Таким образом мы описали каталог с одной текстовой “заглушкой”.

Реализация файловых операций (чтение/запись)

Добавим в File методы чтения:

type File struct {     data []byte     mu   sync.Mutex }  func (f *File) Attr(ctx context.Context, a *fuse.Attr) error {     a.Mode = 0o644     a.Size = uint64(len(f.data))     return nil }  func (f *File) ReadAll(ctx context.Context) ([]byte, error) {     f.mu.Lock()     defer f.mu.Unlock()     return f.data, nil }

Для записи надо внедрить интерфейс fs.HandleWriter:

func (f *File) Write(ctx context.Context, req *fuse.WriteRequest, resp *fuse.WriteResponse) error {     f.mu.Lock()     defer f.mu.Unlock()     end := int(req.Offset) + len(req.Data)     if end > len(f.data) {         newData := make([]byte, end)         copy(newData, f.data)         f.data = newData     }     copy(f.data[req.Offset:], req.Data)     resp.Size = len(req.Data)     return nil }

Теперь после монтирования можно echo "test" > /mnt/fusefs/hello.txt и читать обратно.

Обработка метаданных и времён

Часто нужно указывать Atime, Mtime, Ctime. Добавим их:

func (f *File) Attr(ctx context.Context, a *fuse.Attr) error {     a.Mode = 0o644     a.Size = uint64(len(f.data))     a.Atime = time.Now()     a.Mtime = time.Now()     a.Ctime = time.Now()     return nil }

Но по-честному стоит хранить времена в структуре и обновлять их при записи.

Параллельный доступ и конкурентность

Go отлично управляет конкурентными запросами, но нужно не забывать про мьютексы:

type SafeFile struct {     data []byte     mu   sync.RWMutex }  // В ReadAll используем RLock, а в Write — Lock.

Без этого при стресс-тестах получим расслоение данных или паники.

Производительность: буферизация и кеш

FUSE по умолчанию делает много системных вызовов. Чтобы ускорить:

• Реализовать блоки и кешировать их в памяти.

• Использовать fuse.WritebackCache() при монтировании.

• Оптимизировать ReadAll на большие файлы, отпочковывая req.Offset и req.Size.

Ломаем и чинить: типичные ошибки

1. EBUSY при монтировании — не размонтировали старый инстанс.

2. Проблемы с правами — проверяйте опции монтирования: fusermount -u /mnt/fusefs.

3. Падения из‑за неправильного Attr — следите, чтобы поля структуры fuse.Attr были корректными.

Расширение: снапшоты и снапшот‑директории

Можно хранить снимки состояния:

type SnapshotDir struct {     parent *Dir     snap   []byte // сериализованный дамп }

Выгружать образ в файл и потом монтировать его как виртуальное устройство.

Резюме по опыту

Первые полдня я пытался переписать пример с C, потом забросил и сделал на Go ещё за 2 часа. Главное — не бояться экспериментов и не лезть сразу в оптимизацию без профилировщика.