Slashdot Mirror
Practical File System Design with the Be File System
Table of Contents
- Chapter 1 Introduction to the BeOS and BFS
- Chapter 2 What Is a File System?
- Chapter 3 Other File Systems
- Chapter 4 The Data Structures of BFS
- Chapter 5 Attributes, Indexing, and Queries
- Chapter 6 Allocation Policies
- Chapter 7 Journaling
- Chapter 8 The Disk Block Cache
- Chapter 9 File System Performance
- Chapter 10 The Vnode Layer
- Chapter 11 User-Level API
- Chapter 12 Testing
- Appendix A File System Construction Kit
First thing to note is that Giampaolo is not a great writer, nor is he a bad one. He does not have the gift that some tech writers have of making both an interesting technical document and a fun read. His style is very straightforward - introduce idea, explicate idea, summarize idea. On the other hand, he knows his topic inside and out, and has an obvious enthusiasm for the material, and a real talent for saying things simply without dumbing it down, and his occasional dry wit makes the book a surprisingly easy read.
Giampaolo is doing two things - discussing designing filesystems in general and documenting the Be filesystem. He does both well. BeFS has some advanced features - arbitrary metadata, attribute queries, and indexing. The desire to support these features influences the overall design of the system, but Giampaolo shows how changes to that design change implementation details. The result is a good overview of how a file system works, the trade-offs in optimizing for a particular usage pattern, and how to design one yourself.
The book can be roughly divided into three sections: the first is an overview of how filesystems work and some of the concepts that you encounter - extents, inodes, B-trees, superblocks, and the other standard pieces of a filesystem. Included in this early section is a good high-level overview of the design of five other file systems: BSD FFS, Linux's ext2, Macintosh HFS, Irix XFS, and Windows NT's NTFS. The coverage here strikes a proper balance between too much and too little information. Giampaolo prefers to show rather than to tell, and these filesystem overviews make the connection between design, performance, and features perfectly clear, and provide a solid background to talk about a specific implementation in detail - namely BeFS.
The second section is the bulk of the book - how to implement a filesystem from the ground up, leaning heavily on the BeFS implementation for examples. This is the most straightforward part of the book. Giampaolo covers a single issue in design and implementation in a "Here's the problem, here's and overview of possible solutions and their drawbacks, here's how I did it, now lets summarize" manner. Again, Giampaolo's style makes this an easy if somewhat dry read. As a filesystem and kernel ignoramus, I would have appreciated a slightly more detailed coverage of how all of the various data structures get to disk - how are they serialized, whether endianess is an issue, etc. The BeOS was pretty portable, running at one time or another on the AT&T Hobbit processor, PowerPC, and x86 - I would have liked to have seen portability issues discussed, however, BeFS wasn't written until after the move from the Hobbit to PowerPC, and the book was written prior to the move to x86, so the lack of coverage is reasonable.
Even considering the plain Jane style of this middle section, there are a few gems. The coverage of journaling is excellent, and while I've long understood journaling from a 10,000 foot perspective, this really made me understand the underlying concepts, combined with simple code snippets that helped understand implementation. The Allocation Policies chapter showed in clear terms that disk access is a major bottleneck, and filesystems have become very sophisticated in their optimizations.
The third section of the book deals with some of the more indirect concerns in implementing a file system; specifically, interacting with the kernel, designing a user level API and the major role of testing in filesystem development. This is the one place Giampaolo's writing shines. He really is a good teacher, and this section affords him the chance to talk about the broader perspective of OS design, and even recount a few war stories. For example, in terms of parentage, the BeOS has BSD and classic MacOS as its father and mother. In a few places, such as the Storage Kit API covered in chapter 11, this heritage shows some signs of less-than-seamless integration, and this offers Giampalo a chance to wax philosophical on the nature of OS design, company politics, and the pressure of shipping dates.
In short, the book lives up to it's title. The author is a pragmatist, and offers a clear roadmap for those who have a need to work with low level filesystem implementation. His emphasis on testing, careful optimization, and data structure protection not only helps to show the pitfalls of filesystem work, but also offers a Swiss army knife of techniques to dodge them. The book concludes with a short appendix which covers a file system construction kit, allowing a would-be implementor to begin work on his own filesystem safely without worrying about killing his hard disk. All in all, a solid read.
Here's a link to Practical File System Design with the Be File System as a PDF; you can also look for a used copy at Barnes & Noble. Slashdot welcomes readers' book reviews -- to see your own review here, carefully read the book review guidelines, then visit the submission page.
http://biggestpos.com/pfs/ It took me so long to download the file I thought I'd put it on a faster server for you guys.
What, me worry?
No. You need four:
1. Ext2 or Ext3 on primary hard drive
2. IS09660 on CDs
3. minix for initrd
4. FAT for floppies/USB devices
I generally think it's a good thing when books get put up (legally) on the web like this. My personal view on BeOS is that it's more of a hobby OS than a production one, but a book that details the workings of a complex system is useful. After all, maybe it'll help form the basis of a new, advanced FS.
Only the purest of souls seek enlightenment. Everyone else just wants power.
He does not have the gift that some tech writers have of making both an interesting technical document and a fun read.
But for most people this is seriously dull subject matter. Oscar Wilde would stuggle to get a chuckle out of this stuff.
Do not try to read the dupe, thats impossible. Instead, only try to realize the truth
What truth?
There is no dupe
the BeOS rising to join the ranks of OSs that won't die
An OS isn't dead or dying until Netcraft confirms it.
Trolling is a art,
A practical file system with an impractical OS!
and just where are you going to store that database? on another database acting as a filesystem? or will you have a db built into the OS, right next to your flight simulator, and supercolliding monkey accelerator?
All those years I've slagged off Amiga blow^H^H^H^Hdie-hards, and here am I with a rev-a. BeBox I refuse to part with. I love the damn thing. I never noticed it, but I've got Amigazoids' Disease.
.PDF) to put on my Amig^H^H^H^HBeBox, beautiful and blue though it sits in the corner, gathering dust, as if there's nothing else to do with it ... ;)
Why, oh why can't someone invent a "Parallel Universe Chunnel" so I can get myself a laptop BeBox. tiBooks come close, but Apple crack is still crack!
Ah well. At least I have something else (the
; -- the corruption of government starts with its secrets. a truly free people keep no secrets. --
Apple considered buying Be a few years ago for BeOS and opted for NeXT instead. Now, years, later, they have hired several Be engineers to work on the Mac OS X filesystem. It looks like Apple is getting Be without having to buy the whole company. Be fans, look at Tiger as an upgrade for your favorite OS.
BLING BLING. Meet the architecture that's changing everything.
isn't love a journaling filesystem? My girlfriend can remember every little issue I would like to delete.
It's interesting that one of the features of BeFS is its metadata indexing capabilities (which are the beginnings of a relational model).
Clearly the BeOS designers agree with you.
It's also interesting that the author spends quite a while discussing how difficult it is to do well (particularly performance-wise) and how they almost left it out (IIRC) and/or had to limit its scope.
Clearly the BeOS developers think you're wrong.
And personally, I'll believe people who have actually tried to implement the technology in question over people who say others should do so.
It may be redundant - if it is, just moderate it as such, but here is a Torrent, so that we don't completely destroy the nice BiggestPOS' mirror.
I'll seed it for an hour or so.
OpenBeOS's clone of the Be File System has been selected recently by the folks creating the SkyOS.
The BFS replacement has been one of the fastest progressing parts of the OpenBeOS project. Dominic Giampaolo has actually commented to the team lead of OpenBFS, and complemented the team on the good work they accomplished.
my pet machine
Actually, Be started with a full database instead of a file-system. They found it to be incredibly slow and crash-prone, and so they developped the marvel that is the Be file system.
my pet machine
Amusing sarcasm but there's no reason for a database not to write directly to any random access device.
You think love is bad? Wait till you see the vengence in action. Sure it remembers everything little issue, but using an advanced AI system it creates arbitrary yet realistic scenarios in a multi-threading manner. These can be variously intepreted based on context by others systems reading the disk, which may result in locks and race conditions or possibly even data loss. Love is nice, but wouldn't recommend the post-love vengence patch - best bet is to keep plugging away with what you've got. Don't forget to keep up with maintenance and the system's support needs.
Forget thrust, drag, lift and weight. Airplanes fly because of money.
Access control lists, user-defined metadata, indexing at the file system level, and all that are not new ideas; they go back to the 1960's. Be didn't invent them, and neither did Microsoft (with WinFS).
All that complexity comes at a price. UNIX was a reaction against putting so many features into the kernel, and, in my opinion, the UNIX arguments against putting those kinds of features into the kernel are as valid today as they were 30 years ago.
Unfortunately, the book gives very little historical perspective. It seems to simply assume that "more features" translates into "more advanced". From a quick perusal, division of functionality between kernel and user space seems to be not covered. File versioning at the file system level, another important feature, does not seem to be covered. Historically important file systems and functionality, like those found on VMS, IBM mainframes, and database-based file systems are hardly covered at all.
This book may give you a good idea of what kind of thinking went into the design of the BeOS file system, but it doesn't even come close to a book on file system design in general. And even as a book on the BeOS file system design, it tells you as much about what the creator of the file system didn't think about as what he did think about.