Linux Gains Lossless File System
Anonymous Coward writes "An R&D affiliate of the world's largest telephone company has achieved a stable release of a new Linux file system said to improve reliability over conventional Linux file systems, and offer performance advantages over Solaris's UFS file system. NILFS 1.0 (new implementation of a log-structured file system) is available now from NTT Labs (Nippon Telegraph and Telephone's Cyber Space Laboratories)."
Please correct me if I'm wrong here but wouldn't a log that is only appended to and never overwritten cause a massive ammount of bloat after a period of prolonged use?
The article was a bit light on details. Perhaps someone could enlighten me as to exactly why this is better than existing log-structured filesystems, such as NetBSD's LFS.
I am TheRaven on Soylent News
A lossless file system? Good lord... I most certainly hope all the exisiting file systems out there are not lossy. I have hundreds of gigabytes of data that I don't want to lose.
Or is this filesystem somehow able to recover data once the hard drive crashes? That would be neat...
---
Programming is like sex... Make one mistake and support it the rest of your life.
If it is lossless, I won't be able to store MPEG, XVid, JPEG and MP3 on it anymore? :(
Websites with MILFS have been around for years.
Oh, wait. NILFS. My bad.
Log-structured filesystems write down all data in a continuous log-like format that is only appended to, never overwritten. The approach is said to reduce seek times, as well as minimizing the kind of data loss that occurs with conventional Linux filesystems.
This sounds a lot like how database servers work. They keep both a log file and a database file. The log file is continuously written to and is only truncated when backups occur.
Bradley Holt
Will there be a Windows Driver?
If there isn't, this has no chance on taking off. Consumers today want portability. They don't like lock-in. A linux exclusive format is lock-in.
Create a good windows (and Mac OS) driver, and it's got massive potential.
NILFS is too close to MILFs
"I'd rather be a lightning rod than a seismometer." -Ken Kesey
The system might hang under heavy load.
The system hangs on a disk full condition.
Aren't those kind of important to saying that something is stable?
-=JML=-
Or am I thinking of something else? I'm not sure now. I better go check. No interruptions for 10 minutes, please.
NILFS is a log-structured file system developed for the Linux kernel 2.6. NILFS is an abbreviation of the New Implementation of a Log-structured File System. A log-structured file system has the characteristic that all file system data including metadata is written in a log-like format. Data is never overwritten, only appended in this file system. This greatly improves performance because there is little overhead regarding disk seeks. NILFS also has the following specific features:
* Slick snapshots.
* B-tree based file and inode management.
* Immediate recovery after system crash.
* 64-bit data structures; support many files, large files and disks.
* Loadable kernel module; no recompilation of the kernel is required.
If you "get" pointers add me as a friend (116)!
" When the system reboots, the journal notes that the write did not complete, and any partial data writes are lost. "
Isn't this similar to NTFS's journaling file system?
If they are serious about a filesystem, it has to be bundled with the linux distros every release. Take Reiser and JFS for example, some distros have it, some don't. Not every release of the same distro has it, what a mess. Only two have stayed permanently EXT2, EXT3. Everything else is trendy.
More file integrity is always good. Ever since journaling file systems became available I just started turning the power off to my computers (via a power strip) rather than going through the shutdown command. It never made sense to me that we'd have to "shut down" as opposed to just turning the thing off.
Slashdot: Failed Car Analogies. Amateur Lawyering. Anecdote Battles.
http://www.nilfs.org/
I've experienced roached ext3 filesystems a number of times- With no hardware failure. Recovering that data by converting it to ext2 helped once, but I'm still trying to recover the data after the last incident. I'm sure (rather, hope!) that these experiences aren't the norm.
Note: instead of modding this +1 funny, mod it +0.1 pathetic.
Click here or here.
Aside from gasoline and water, data is the most valuable thing in the world.
.tiff format) along with full-quality movies and all the games I've ever played back to Duke Nukem on 80x386 on a RAID array that's grown to nearly 2 terabytes.
:) Same for HDDs
Walmart's most prized possesion is their billion-billion-billion transaction customer sales database. They use it to find things like, among other things, men tend to buy beer and diapers at the time.
With disks costing $1.00/GB or less these days, many people including myself simply DON'T delete data anymore. I keep all my original digital photos (in
So yes, for many people, disk space is just something you keep adding to, like you'd move from a coupe to a sedan when you have kids and when you have that 6th kid you move to a minivan and if you happen to have 2 more, you get a cargo van when #8 comes along
If you "get" pointers add me as a friend (116)!
Otherwise, an ACLU lawyer might start to salivate...
A goal is a dream with a deadline
Has anyone considered the privacy implications of this yet?
Not sure I like logs listing that 3 years ago, I had a file named bad_kiddie_pr0n.jpeg (or whatever) on my computer.
They'd better have a good cleanup script!
--LWM
...but I want a business card that says I work at "Cyber Space Laboratory"!
Just junk food for thought...
I'd looove to replace ext2/3 as my filesystem for years since it's not so fast and most distro don't include binary tree indexing for ext3 (so large dir is slow). Unfortunately I haven't been able to do so. Here are my requirements:
1. Distro support. I don't want to have to compile my own kernel. The FS needs to be supported by the distro (Debian in this case). I want to be able to create root partition and RAID with the FS.
2. ACL and extended attributes.
3. extended inode attributes would be nice ("chattr +i" is handy sometimes).
4. optionally I would like to be able to create large Bestcrypt partitions (e.g. 30GB) with that FS.
5. fast large dir and small files performance (I have millions of small files on my desktop).
6. no need to fsck or fast fsck (i.e. journalling or some other technique or whatever).
7. disk quota!
8. optionally, transparent compression and encryption will be a big plus point.
9. Snapshots would be nice too, for consistent backups.
10. Versioning is also very welcome.
XFS: very close but it still has problems with #4. It also doesn't have undelete like ext2/ext3 (not that it's a requirement though).
JFS: it just lacks many features.
Reiser3: How's the quota support, still have to patch kernel everytime? Plus it doesn't have ACL.
Reiser4: not ready yet.
I might have to look at FreeBSD after all. Background fsck, hmm....
I am probably not the only one to come back to an old file saved years ago only to find a glitch in it. I noticed it with a couple of movies. Movies I know were perfect as I watched them without copying them. So the only explanation is that part of the disk got corrupted.
The solution is availbale manually in the form of PAR or other recovery software but wouldn't it be nice if this was part of the OS or hardware itself? I would happily add another disk to my raid this one loaded with data to help check that the data is 100% correct.
Does such a solution exist?
MMO Quests are like orgasms:
You may solo them, I prefer them in a group.
I've had an idea kicking around for a while now... "HDFS / Home-Dir File System" ... I want a (s)low-performance, bloated, version controlled, roll-back featured, viewcvs.cgi enabled file system for my /home/rames (or at least /home/rames/documents).
With FUSE it might even be possible for mere mortals like me.
Basically, I very rarely push more around more than 100-200kb at a time of "my stuff" unless it's big OGG's or tgz's, etc. Mostly source files, documents, resume's, etc. In that case, I want to be able to go historical to any saved revision *at the file-system level*, kindof like "always on cvs / svn / (git?)" for certain directories. Then when I accidently nuke files or make mistakes or whatever, I can drag a slider in a GUI and "roll-back" my filesystem to a certain point in time and bring that saved state into the present.
Performance is not an issue (at first), as I'm OK if my files take 3 seconds to save in vim or OpenOffice instead of 0.5 seconds. Space is not an issue because I don't generally revise Large(tm) files (and it would be pretty straightforward to have a MaxLimit size for any particular file). Maintenance would also be pretty straighforward: crontab "@daily dump revisions > 1 month". Include some special logic for "if a file is changing a lot, only snapshot versions every 5-10 minutes" and you could even handle some of the larger stuff like images without too much work.
Having done quite a bit of reading of KernelTraffic (Hi Zack) and recently about GIT, maybe it's time to dust off some python and C and see what happens...
--Robert
I suppose the released version is lossless, compared to their first development version, which was a wee little bit buggy?
Oh well, what the hell...
nobody seems to know the difference between lossy and lossless filesystems. neither do I, and neither does whoever wrote the article, it seems.
but hey, that's never slowed me down.
This new filesystem is like old ones, with a big difference and a few small ones.
It has something called 'snapshots', which seems to mean that you can work off of a partition, but seperately load up the version of that partition you had before you last had a power failure, or whatever went wrong.
it also claims to:
* Fast write and recovery times
* Minimal damage to file data and system consistency on hardware failure
* Correctly ordered data and meta-data writes
* File and inode blocks are managed by a B-tree structure
o Can create and store huge files
* Internal data are processed in 64 bit wide word size
that no doubt means something, to somebody. lucky them!
and yes, this is actually more informative than the article.
remember kids, never, NEVER RTFA. it will only confuse and scare you.
Sounds to me an aweful lot like a tape drive. Start at one end and start writting until you're done. I can see the point of wanting to keep all parts of each single file together in one block so that it's not broken up. That way there is no need to defrag, but I thought ext2 and ext3 did that type of thing already. Correct me if I'm wrong, but I was told that ext2/ext3 would keep a file whole at just about every cost pending a really really full drive and absolutley no contiguous room to put it, then it'd break it up. Am I wrong?
I'm also not sure how seek time is going to be affected by this. I'm not an expert on seek times for hard drives or anything, but if the File Allocation Table says it's out at point X and the PC then gives instructions to retrient that file by saying "the file starts at X address" the seek time is the same no matter how the file is sitting on the drive. Correct me if I'm wrong, but lets look at a quick scenario to make sure we're all on the same page. Then if I have fault in my thinking, please tell me. Lets say that a file starts at the farthest point away from the reader head on the drive that it can start and still fit the file there. (The very last section on the drive that the file can fit) In both instances the head would have to move the same distance from it's starting point wouldn't it? I though that seek time was dependant mostly on the hard drive hardware speed itself as the time that it took the head to get to the starting point of the file. If the file is broken up into tiny pieces all over the drive it's going to take longer for the file to be read in completely, but the seek time isn't changed to find the head of the file is it? Maybe I misunderstand "seek time" someone, if I'm way off please enlighten me. I'm always good for an education. Thanks.
Generation Trance: What generation are you?
Here is a sampling of the known bugs
The system might hang under heavy load.
Are you intolerant of intolerant people?
Raid 5 allows you to keep 1 or more parity checksums of the volume. In principle you could use partitions on the same disk if you cannot afford a multi disk setup.
This space is intentionally staring blankly at you
Nannies.
And yes, they've been around for years.
I usually put /var/log in a seperate partition anyhow. The easy solution would be to put this FS just on the areas that you want to be "lossless" and leave the rest with standard filesystems.
I only use LOSSY filesystems. I figure entropy is the natural way of things, and as such, my filesystem should loose bits left and right (not really loose, just reset them randomly left and right).
These 'holes' in the data allow new data to 'evolve' through a darwinian selection process.
Yes, I use FAT16 for everything. MS clearly understood how to generate mutations in the 'ecosystem' of the software world, and MS clearly understands how mutations drive us towards the inevitable evolution of Skynet!
I, for one, welcome our new, homicidal robotic overlords!
WhiteWolf666 an exBush supporter. All you new-school,compassionate,save the children Republicans can rot in hell
I guess you can argue that if a project is actively maintained, any problems are potentially fixable. Even with Open Source, an abandoned project is going to be a lot tougher to work on - especially if it was broken at the time it was abandoned, as then you've got to spend time figuring out what was intended, not just what was coded.
Personally, I'd be more in favour of improving the file system layering - eg: having a layer that supports different forms of journalling and logging. Then you could remove explicit logging from the filesystems themselves, you'd only need to provide hooks to the journal/log layer. This would surely reduce bloat, allow people to experiment with different combinations of journal/log and filesystem, etc. If you add a metadata layer, you could even resolve many of the politics of Reiser4 by moving the directories-as-files and other metadata code into such a layer, making it universally available to all filesystems.
It is certainly true that abstracting out and encapsulating in this way usually produces slower code, as you can't have the calls as tightly written or the layer as specialized. On the other hand, I'm going to argue that loose bindings make for easier maintenance and will also increase the number of people who would have an interest in maintaining the code, which will eventually lead to better code and therefore faster code. Only it won't just be faster for one filesystem, it'll be faster for ALL filesystems the user has linked that log/journal component to.
It's a small world and it smells funny; I'd buy another if it wasn't for the money; Take back what I paid (SoM)
Actually, it's faster-to-write, slower-to-read.
It's better to be the foot on the boot than the face on the pavement. ~~ tkx Kadin2048
For binary document formats (eg: MS Office's
A better approach might be a hybrid of these - have a method of extracting/inserting the text as ASCII (which you can then log using a conventional source-control system) and have control sequences recorded as a macro on top of that. You then have to be absolutely certain that the correct two are applied together and in the right order, which may get complicated if there are branches, but the increase in complexity should be more than matched by a reduction in the amount you need to actually store.
It's a small world and it smells funny; I'd buy another if it wasn't for the money; Take back what I paid (SoM)
Because old stuff can be overwritten when you fill the whole disk. As I mentioned in other posting, data writes are Real Fast in log filesystems, but data reads are Real Slow.
The biggest problem of this filesystem (link is missing from the original posting) is that it's Not Really Ready (among other important stuff, mmap() is not implemented yet).
It's better to be the foot on the boot than the face on the pavement. ~~ tkx Kadin2048
Doesn't such a filesystem store all data semi-permanently, even the data you no longer want?
When I delete a file, maybe I want it to be nonrecoverable.
It would be nice to have a feature in the system that automatically wipes deleted files.
While I have found utilities that wipe files by overwriting them with different passes of varying data, this may not work at all in a journalling filesystem where a rewrite of a file not necessarily stores the datablocks in the same location. It also does not work when you forget to wipe the file before deleting, or for temporary files that are deleted without user action.
What I would like to see is some daemon process or kernel thread that securely erases all files that have been deleted (or truncated) through the normal system calls. Probably you would want to have it configurable to write only zeroes or write that DOD-certified series of patters for the really paranoid. And maybe some configurable priority for the overwrites (only do it when the disk is really idle, or perform the overwrites with some urgency).
Blocks from files being deleted by the filesystem would be handed over to this daemon to be securely erased at a convenient time.
Same for swapspace. Blocks from processes that have exited or that have been swapped back in and subsequently modified in memory would be erased.
Does such a thing exist for Linux?
I think a log based file system would be really good for FLASH device based file systems, where erasing can typically only be achieved for a block of the device at a time. Essentially most flash file systems end up copying data out of a block to some new block before erasing the old block and starting again, much like how a log based file system works.
Given that a lot of FLASH based devices are embedded and maybe portable using battery power (think PDA/Mobile etc...), this technique could add extra safety to data stored on the device if the battery were to drain during an erase or write cycle. Nice.
-- Mike
It never made sense to me that we'd have to "shut down" as opposed to just turning the thing off.
As everyone else is saying, you lose your disk cache that way. The solution to long shutdown sequences is rm /etc/rc.d/rc?.d/K* (or the equivalent for your distribution). 99% of the daemons out there will shut down just fine on SIGTERM and won't suffer any harm from a SIGKILL; let the standard shutdown script unmount everything and you're done. Shutdown time on my desktop is around 3-5 seconds after the global SIGKILL, which is definitely within my acceptable range.
(Caveat: make sure you check what you're deleting before you delete it! Some weird distribution might have the shutdown script as a K* script, who knows)
Gmail lossless. As in, I have so much space here that I can store every copy of every email that I've sent out.
Also a bit in the Escalade lossless, as in, if it crashes, you can put it back together again, and have most of the pieces... or is that Volvo lossless?
I am unamerican, and proud of it!
People who sling mod points around without engaging their sense of humour first should be banned.
If I can't mount it with Knoppix, no way in hell am I going to use it for anything important.
There are also several bugs that need squishing - ls, df, and du all have problems representing disk space, and support of the GNU Tools is listed in their "planned" section (read: distant future, outside the "todo" list). (ACL, GRUB support, atime, and other newly deemed "essential" aspects are also "planned.")
Use my userscript to add story images to Slashdot. There's no going back.
For the lazy among you, I looked up what NILFS stands for:
New Implementation I'd Like to FSck
Consider the daffodil. And while you're doing that, I'll be over here, looking through your stuff.
If you have a licensed copy of the OS you can get source. Or at least, you used to be able to - many years ago when I was considered a VMS expert (something I certainly am not now) I used to look stuff up in the fiche; most of the stuff I was referencing was written in BLISS, I think.
As I recall, RMS is an indexed file management system. I wrote a molluscan taxonomy database system that used it in the 80s... but I usually encapsulate all OS-specific stuff in subroutines, so somebody has probably ported it to a cheaper database by now.
I don't get it - you are bragging that Sun has a filesystem that is too broken for release?
I've been a long time user of JFS and XFS. I've found JFS more stable in the past, and it is nice that JFS's fsck tool actually does something as opposed to XFS's fsck which exists with 0 and whos manpage tells you to use xfs_recover.
However both of them seem to have grown to be fairly stable, however there are still many instances where I've suffered dataloss, sometimes entire directories which I though was what a journaling filesystem was supposed to prevent...journaling directory meta data before writing it.
There was one instance where I had a hard drive continually being corrupted because of a bad hard drive controller, in which case no file system could have prevented data loss. Still in the pass I hate to think about how much media and data I've lost because of a power outage and a corrupt filesystem. Good think in Gentoo you can always to an "emerge world --emptytree" to get all your binary executables back, so long as didn't loose your compiler in the crash.
Not atomic snapshots. Not that everyone needs this, but if you do, it does require FS support. Netapp's file system, for instance, supports atomic snapshots. Very nice for hot backups of DB data files, for example.
I forget what 8 was for.
What is cool about it, for auditors obsessed with SOX, GLB & HIPAA compliance, is that it maintains a near-perfect audit trail at the cost of disk space (which is cheap compared the other costs of regulatory compliance).
You can mount the disk at any checkpoint, essentially providing a snapshot of each of the filesystem's unique states - unlike conventional backup (the usual 24-hour backup cycle gets a very coarse picture of the changes, obviously).
Other than that, it's yawn-yawn SSDD. The whole "lossy/lossless" thing is overblown hype, because all disk hardware fails to complete a write operation if you remove power before the operation is complete. They are trying to make their system seem better than it really is by making others seem worse than they really are. The fact is, plenty of people have run totally lossless data storage systems using ext2/ext3 and ISO9660, and no filesystem (including NILFS) can prevent your data from being butchered if your power supply is crap.
NetBSD's LFS is totally unexciting compared to MILFS 1.0, which everyone knows will go down on you, play rusty trombone with you, wrap her boobs around you, and otherwise get you off while her hubby and kids aren't home.
Say it right: "Nuc-le-ah Powah".
NTFS has had criteria 1-6 for over 12 years, 7 and 8 for 5 years, and 9 has been around since the most recent versions. About the only thing it doesn't support is versioning, although snapshots are often as good.
Since it was designed for POSIX compliance, it has file change times, case sensitivity, and hard links. About the only issue is that you may have to write your own plug-in for proper soft link support.
As bonus features, you also get a change journal (persistent log of all directory changes -- useful for indexing applications), programmatic sparse files (you use ioctls to tell it where the holes are), Unicode filenames, multiple data streams per file, and a plug-in architecture (reparse points).
Additionally, there are already plug-ins (reparse point filters) for things like copy-on-write files, hierarchical storage (an old file may be archived to CD, but still has a directory entry, and when opened is brought back onto disk), and persistent mount points.
And in upcoming versions there will be more goodies, such as directory quotas, filename restrictions (so you could prevent somebody from creating a filename that ends in '.exe' in your web root), and fully distributed ACID transactions.
Now some may argue that some of these things, such as compression and encryption, don't belong in the filesystem. However, I can't think of any way to do it cleaner. For one thing, in order to encrypt a file you must first compress it (reduce entropy). Do you have compression on top of encryption on top of the filesystem, or do you have two different compression implementations?
Your compression layer would need to intercept not only reads and writes, it would have to intercept calls to get or set the file length, otherwise an unsuspecting program would get the compressed size. And now your compression layer needs some metadata about which files are compressed and what their expanded sizes would be. Where do you store that? Do you put it all in one file somewhere that an unwitting sysadmin might be tempted to delete it to save space, or where a single corrupt sector could screw up all the data, causing you to lose every one of your compressed/encrypted files? Remember, most filesystems log metadata changes, not data changes. Since compression is sitting on top of the filesystem, its metadata looks like regular data to the FS, so it is (along with all of your files) vulnerable in the event of a crash.
What happens when somebody decides to optimize the compression layer by storing some of the compressed data (perhaps a Huffman coding table) in the metadata file? Since the metadata file probably isn't encrypted, an attacker now has some information to help him decrypt your files!
dom
Huh? I was under the impression that hard drives have had Error Correction Codes for ages. Wouldn't that make the kind of errors you describe extremely unlikely, and even less likely that they would go undetected?
Please correct me if I got my facts wrong.
Anyone? Seriously that's an awesome word. What's it mean?! Is it the same as moron?!
This filesystem most likely stems from the ideas in Venti which is a filesystem that came out a few years ago. Link is included at the bottom. The (quite compelling) argument made originally is if you graph unique data growth (unique is important here) and compare it to the growth of commidity storage, as long as the storage growth is greater than unique data growth, there's no reason to ever delete anything since you essentially have infinite storage.
t ml
This is actually compelling for a large number of use cases. Many types of servers (think any sort of application server that's not a file server or something) fit this model. The disaster recover story is just fantastic, you can rollback to virtually any instance of the previous state of the filesystem.
FWIW, most new distributed SCMs are based on this same idea (like git or mercurial) so this is a pretty well-understood paradigm.
http://www.cs.bell-labs.com/sys/doc/venti/venti.h
Totally offtopic, but do you have a good source for cases to hold a lot of drives? Right now I'm just using a mid-tower, but I'm out of bays. I'd like something with a crapload of 3.5" bays and at least some thought as to air circulation, without paying for an all out server case. Any tips?
Is there anything out there that's actually slower than UFS? Achieving that seem like it would be a real technological feat.
sic transit gloria mundi
Damn it, now every time I see a MILF video, I'll be thinking about Linux.
Assume I was drunk when I posted this.
I've always wondered if it would be worthwhile to have a version control style filesystem. Basically, a built-in subversion or CVS-type backend that operates without your knowledge until you need to roll something back. Of course you'd need to manage space usage, but with 1TB storage capacities within reach of the home user perhaps it's less of an issue? I think losing data is quite a bit more expensive than storage these days. :-)
John Sauter, former DEC software engineer, (J_Sauter@Empire.Net)
Maybe you tried it back when it used to be buggy?
The sniper's bullet makes sound AS IT TRAVELS because it is traveling at supersonic speed. That is how the location of the sniper is found. If there is more than one robot, they can triangulate the location within a few feet. We used this technology in Bosnia mounted on Bradley's almost 10 years ago and it worked well.
So what are the choices? ext2/ext3 which are slow, reiserfs which sucks ass when it breaks..
Apart from the big (production quality) alternatives like IBM's JFS (which I use myself) and SGI's XFS (and Reiser - "Reiser sucks when it breaks" is so 1999) Linux additionally supports the following filesystems (from http://www.xenotime.net/linux/linux-fs.html, also try http://www.tldp.org/HOWTO/Filesystems-HOWTO.html):
* accessfs: permission filesystem
* AFS FAQ
* AutoFS
* AVFS: A Virtual File System
* AVFS: A Virtual Filesystem
* BeFS for Linux2.4
* BeOS filesystem for Linux
* BFS UnixWare, Linux Implementation of
* CDfs
* CIFS
* Cluster File Systems Home
* Coda File System
* Crypto HOWTO
* convertfs: convert Linux filesystems
* DAFS: Direct Access File System
* Devfs (Device File System) FAQ
* efslook: read/debug EFS filesystems (ported to Linux & x86) {new}
* Enhanced Loopback (for XFS)
* E2fsprogs: Ext2 Filesystem Utilities
* E2fsprogs: Ext2 FS Utilities
* Ext2 Compression Extension
* FSDEXT2: ext2 filesystem for Win95
* ext2fsnt: Linux Ext2 filesystem for Windows NT driver
* ext2 fs resize utilities
* ext2 online growth patch (adilger)
* Explore2fs
* FHS: Filesystem Hierarchy Standard
* FHS Test Suite
* Filesystems HOWTO
* FiST: File System Translator
* FreeVXFS
* fsv: 3D File System Visualizer
* Global File System (Sistina)
* GNU ext2resize: ext2 filesystem resizer
* HFS+ filesystem
* HFS+ filesystem #2
* InterMezzo FS
* JFFS (axis.com)
* Journaling Flash File System, v2
* JFS for Linux (IBM)
* journal_fs report (OSDL)
* Kragen's Amazing List of Filesystems
* Large File Support in Linux
* Large File Summit (LFS) stuff
* Large File / File System Support
* Linux EXT2 salvage utility
* Linux Ext2fs Undeletion mini-HOWTO
* Linux FAT-32 support
* Linux filesystem redundancy
* Linux Links: File Systems
* Linux NFS FAQ
* Linux RAID Solutions
* LUFS: Linux Userland File System
* Lustre & Lustre Light filesystems
* NFS project
* NFSv4 for Linux 2.4
* Linux NTFS file system support
* loop-aes cryptoloop device
Even with a "cleaner", I bet any block is more blocks of access away in a log-structured fs to read than in more conventional types of fs.
It's better to be the foot on the boot than the face on the pavement. ~~ tkx Kadin2048