Cześć.

Poszukuje inspiracji a być może gotowca. Ale to trudno powiedzieć. A
chodzi o coś takiego:

Implementacja abstrkacyjnego filesystemu pracującego na urzeniau
blokowym, do którego dostęp zapewniam ja, przez stosowane abstrkacje.
Wykorzystać było by fajnie, ale najważniejsze to możliwośc podejrzenia
rozwiązań.

Wiec to tak powinno wyglądać:

struct IFooFileSystem
{
std::shared_ptr< IFile > openFile( std::string cosnt& _fileName, Flags
_flags );

bool fileExist( std::string const& _fileName );

[...]
};

struct IBlockDevice
{
std::shared_ptr< Block > readBlock( BlockIndes _index );

void writeBlock( BlockIndes _index, Block& _block );
};

struct IFile
{
void read(...);
void seek(...);
[...]
}

std::shared_ptr< IFooFileSystem >
createFileSystem( myBlockDevice );

Coś w ten deseń, czyli to ja dostaczam abstrakcje robiącą I/O na
poziomie block/cluster a kod realizuje wysokopoziomowe operacje plikowe.

To nie musi być z czymkolwiek kompatybilne, nawet lepiej gdyby nie było.
Musi być natomist komplenie nie zależne od czegokolwiek, czy to systemu
czy zewnatrznych biblitek. I thread safe, będę jednoczesnie czytał i
zapisywał wiele "plików" z róznych wątków. W zasadzie poza "plikami"
reszta kompletnie zbędna, nie interesują mnie atrybuty czy nawet
katalogi. Mocno uproszczony filesystem, coś w rodzaju wielu niezależnych
strumieni w jednym kontenerze.

Mogę to napisać samodzielnie, ale zanim to zrobie: ktoś widział taki
projekt lub część jakiegoś projektu?

Dla zastanawiajacych się po co mi to:

Jest *prawdziwy* plik. W moim kodzie jest konwertowany do urządzenia
blokowego i wystawiany do tego mechanizmu fiesystemu.

Dzięki temu mogę w jednym pliku trzymac w środku wiele plików,
bezustannie je czytajac i zmieniając. Ułatwi mi to pracę, ponieważ pliki
te są trzymane razem, user nie może nic w nich popsuć, nie muszę
bezustannie pakować/rozpakować jak robi np. OpenOffice (u nich
kontenerem jest packer). Od razu gotowe do pracy.

Katalog odpada: user może w nim coś popsuć.

Ewentualne puchnięcie moża jakoś obejśc pisząc garbage collector
trimujący ten "wirtualny filesystem" i przenoszący bloki w tle.

Coś podobnego robi np. VirtualBox ale nie chodzi o taki poziom emulacji
dysków, to ma byc mała pierdoła do kodu który mam pod kontrolą.

Innymi słowy: czy ktoś widział tego typu wirtualny filesystem?
Interesują mnie zagadnienia takie jak uproszczony wielodostęp czy
realizacja kroniki. Chciałbym je poderzeć, ponieważ nie mam w tym
doswiadczenia, pewnie napiszę to mało optymalnie.

Projekt Fuse nie nadaje się bez bardzo poważnego wrapowania. Ponadto ja
nie potrzebuje wielu filesystemów, potrzebuje tylko jeden, o mało ważnej
kompatybilności ze światem zewnętrznym. Taki FooFS.