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

[AI]

В этой статье подробно разбирается создание пользовательской файловой системы с помощью 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 часа. Главное — не бояться экспериментов и не лезть сразу в оптимизацию без профилировщика.