To use our price comparison to get the cheapest price, please click on the "Find the Cheapest Price" button located above for UNIX Filesystems: Evolution, Design, and Implementation by Steve D. Pate, Steve D. Pate (ISBN-10: 0471164836, ISBN-13: 9780471164838).
At this time we have not yet written a review for UNIX Filesystems: Evolution, Design, and Implementation by Steve D. Pate, Steve D. Pate (ISBN-10: 0471164836, ISBN-13: 9780471164838). Please continue to keep checking back to this page as we are constantly adding reviews.
Summaries and Customer Reviews are supplied by Amazon.com
- Covers all versions of UNIX, as well as Linux, operating systems that are used by the majority of Fortune 1000 companies for their mission-critical data
- Offers more detail than other books on the file input/output aspects of UNIX programming
- Describes implementation of UNIX filesystems over a thirty year period
- Demonstrates VERITAS and other filesystem examples
Great coverage of Unix file systems architecture
| Customer Rating:   | This isn't the first book I have read that covers Unix file systems. All the standard Unix implementation (e.g., Bach (SVR2), McKusick et al (BSD)) and OS design books (e.g, Tanenbaum (Minux)) have something to say about file system design. But this book is different, in that it provides a broad yet focused coverage of a large number of Unix based file systems, starting back with the AT&T research edition as a foundation, and building upon the discussion with looks at Sun VFS, UFS, FFS, Minux, and Linux. The writing is detailed, and clear, and there is a good number of figures and code listings that help explain the concepts.
The best thing about the book, however, is the source code for a Linux filesystem named uxfs. Reading the text and studying the source code (in the book, or via download) really helps make the topics discussed in the book clear. The author does a decent job of describing the uxfs source code, and shares some tips on how to approach compiling a kernel, and the filesystem source, and using gdb to set breakpoints so that one can investigate how the Linux kernel is calling into the filesystem through all the major entry points. Even if you don't give a hoot about filesystem design, its a great example of how to understand a complex system that you might not otherwise have a clue how to approach -- set breakpoints on the major entry points, look at the stack, and then read the code up the stack to see what is going on. Understanding uxfs is a great start to understanding more complicated filesystems in Linux for sure, and less directly, other Unix-based file systems as well.
Along with uxfs the author provides a set of easy, and advanced exercises. The one that looks like the most fun to me is modifying uxfs to support an inode structure that uses direct, single indirect, double indirect, and triple indirect blocks (described in Maurice Bach's book and elsewhere).
In summary, if your basic operating system book's coverage of Unix filesystems is not enough, or you want a gentle and complete introduction to designing a Linux filesystem, consider reading this book. |
An excellent treatise on the topic concerned!
| Customer Rating: | I bought this book right before the Christmas and planned to spend some time on it during the holidays.
It turned out that I was completely absorbed in it, and spent days and nights on the book with my web-browser linked to a Linux kernel source code website. I simply couldn't stop it.
Even though the general study of UNIX file system could have been a little more comprehensive than what is provided, that information could be easily found in other resources (I recommend " UNIX Internals: The New Frontiers by Uresh Vahalia"). However, this book does stand out by the way it compares different implementations of varieties of UNIX kernels (Sys-V series, Solaris, etc. ) Given the open source of old UNIX systems which could be found on ([...]), this book adds great values when you case study the file-system architecture.
Another great perk you get from the book is the attached source code for a rather primitive but very instructive uxfs file system. By showing what interfaces a programmer needs to provide to Linux, the sample codes can be easily adapted to achieve your own goal smoothly and painlessly.
In sum, this is a very impressive book and I'm still studying it. For anyone who's fascinated with file-system or any UNIX system-level topics, this will be a very good choice. |
Good overview
| Customer Rating: | | This is a well-written overview of various Unix disk and network-based filesytems. It doesn't go into nearly the depth of, say, Vahalia, but it covers a great deal more, and in a more readable style. The diagrams and code snippets are usually well-chosen. I would agree with the reviewers who question the appropriateness of 'Implementation' in the title: there are better resources for that. But for this system administrator the book is very useful nonetheless. |
Good supplements for UNIX internals
| Customer Rating: | As the author claims, this book supplements other UNIX internals books, because they lack a thorough discussion on filesystems. For example, for a long time I've been puzzled by the pseudo code for read(2) system call in Maurice Bach's book. An inode lock is taken even for read() (Design of the UNIX Operating System, p.97) That doesn't sound right. ufs_inode.h on Solaris implies that ufs uses rwlock (multi-reader/single-writer lock; forget the modern concurrent direct I/O for now). Jim Mauro's "Solaris Internals" talks about rwlocks and filesystems in separate chapters but not in the same context. Here Steve's book tells us that filesystems didn't use rwlocks almost until the time SVR4 came out, and Bach's book was written before that. This is just one example of the mysteries Steve's book solved for me. I also like Steve's examples of using Solaris crash(1M). (I even collected them in a web page: rootshell.be/~yong321/computer/SolarisMdb.txt).
Superb technical details aside, this book is also written in good pedagogical style. Hands-on exercises always help. (How many people have read Goodheart's "Magic Garden" book for longer than a week?) Some code examples, pseudo or real, also help. Steve's book has both. Lastly, it comes with a mini-filesystem. I didn't test it but I believe it would help CS students tremendously.
Since the book is just much about Solaris as about Linux, I wish he talked more about Linux debugfs() and perhaps could use gdb to debug ext2 filesystems. I hope the new edition, if there is one, can give examples of Solaris mdb since crash is deprecated, and can expand the examples to include some new FSs, riserfs, Oracle's OCFS, etc. (Both have source code available to the public.) In chapters about cluster filesystems, the technical discussion seems to be less strong. There must be ways to debug these FSes just like using crash() and adb() to follow pointers in memory to debug UFS. It's just that cluster FSes are less understood and studied in this fashion. |
Good book, encourages the reader to experiment and learn
| Customer Rating: | | I have to disagree with the "wannabe Linux filler book" another reviewer mentioned, it's a eye catching "sound bite" but in this instance it is not valid. The text is largely neutral with respect to specific flavours of platform and file system though obviously the author's experiences, source code availability and legal restrictions with respect to commercial products all play a part. Yes you can state that some reference texts are available from the Internet but the author has yet again made the subject accessible to a much larger audience through making the subject matter approachable in much the same way as he did with his book, "UNIX Internals." The example file system is written for Linux but that is a reasonable choice as it maximises accessibility for the reader. The author obviously wants the reader to learn through experimentation and actively encourages this with a number of step by step examples that the reader can easily both repeat on their systems and use as a starting point for their own "what if?" experimentation on the subject matter. Perhaps including a little more information on other current filesystems would make a good book better as mentioned in another review, but only if it provided the author with a starting point for taking the reader through examples of another filesystem feature, or perhaps an opportunity to compare and contrast solutions to a given design issue. Including UNIX filesystem history was both interesting and helpful in as much as it provides a context through which the reader can understand why the introduction of features such as page cache, Sun's vnode layer etc were necessary or useful. In summary, I found the book an interesting read and I was not disappointed with my purchase. |
|
