|
|
About ::
TODO ::
Blog ::
RSS ::
Old blog ::
Projects ::
GIT ::
Gallery ::
Notes
Fri, 15 Jun 2007
NILFS by AMAGAI Yoshiji at Nippon Telegraph and Telephone Corporation.
NILFS is log-structured filesystem by Japan telecom company,
which allows to have snapshots and garbage collection over them.
Looks interesting, but it has fundamental flaw - it writes all metadata updates
as a log in a special file, which means heavy fragmentation when oldest updates
are removed. It also supports (at least it looks so) copy-on-write (and it looks
like only for data), which allows to forget about slow recovery after crash
and can improve performance.
NILFS supports checksums for segment data and related metadata. Superblock and management blocks
maintain own checksums. Currently it is only crc32. There are no checksums for individual
data blocks.
NILFS uses simple B-tree structure with 64-bit keys.
Like Btrfs it does not support
sync, direct and mmapped processing and quotas.
It also does not allow to have writable snapshots.
First papers about his filesystem appeared two years ago.
There are no benchmarks on the official site.
It looks like log-structured filesystems become popular
(getting into accout when I first time wrote
about such filesystems in this blog there were zero projects in that direction).
/devel/fs :: Link / Comments (0)
BTRFS by Chris Mason at Oracle.
There are number of features currently not implemented,
and which limits design:
- Absence of delayed allocation.
This means that fragmentation will kill a filesystem, even if it is extent based
(which is just a block size increase).
Currently btrfs allocates new on-disk chunk for each 8k write.
- Bad tree locking
Which does not allow multithreaded writing.
- Some minor nits like absence of sync, direct and mapped processing,
which is unlikely to be design problem though.
Actually, I plan to watch this project, but currently limit my filesystems
interests to the block layer - I still want to implement distributed
storage with raid-like (not exactly raid, since for higher order checksums (like 32 bit crc)
it requires slow Galois-field multiplications, but something like that) functionality,
which could be put under the filesystem and allow to put usual filesystems
on top of highly-sized arrays distributed over the net.
/devel/fs :: Link / Comments (0)
|