Two new books are creating a stir in systems administration circles. One is an evolution, the other a revolution. Both are worth consideration as holiday gifts -- for yourself or a loved one.

Well, maybe your sweetheart isn't really that interested in a book about Solaris internals. And it's probably not a good idea to pull a Homer Simpson and give it to someone who doesn't want it, just so you can use it. But one book that should be on every system administrator's wish list is Solaris Internals: Core Kernel Architecture, by Jim Mauro and Richard McDougall.

This book's predecessors are works like Unix Internals (Vahalia), The Design and Implementation of 4.3BSD Unix Operating System (Lefler et al.), and Lion's Commentary on Unix 6th Edition (Lions). While those books are interesting (to some) and educational, they lack the utility and applicability of Solaris Internals.

In many ways, Solaris Internals is the best of both worlds. It includes illuminating details of the inner workings of Solaris (through Solaris 7), as well as useful information for systems administrators running Solaris machines. It could also be a good resource for students of operating systems, and developers using Solaris.

The book covers the expected topics, including kernel services, synchronization, bootstrap, memory, threads, processes, interprocess communication, files, and filesystems. It has appendices that cover kernel tunables, switches and limits, the kernel virtual address map, and an example of the procfs utility.

Those topics are all discussed in extraordinary detail. For example, the coverage of memory includes a description of virtual memory, virtual-to-physical translation, how the kernel implements VM, hardware address translation (HAT), virtual address spaces (both SPARC and Intel), heap size information for each OS release, stack structure, Solaris 7 address space system functions, page faults, memory segments, memory mapped files, shared mapped files, anonymous memory, swap space implementation, virtual memory watchpoints, global page management, the page scanner, kernel memory, and a whole section on memory monitoring tools!

Want to know the data structure behind caches, or how the kernel allocates memory? It's in there. Kernel queuing? It's there. How threads are implemented? Semaphore types and implementation? Kernel trap handling? UFS structures and how UFS logging is implemented? It's all there.

Like any book, Solaris Internals has a few shortcomings. The layout is odd: most pages have a uniform text size, but on some pages the text terminates early, and on others the text drops dangerously toward the bottom of the page.

Some topics were purposely omitted from the book, including low-level I/O (device drivers, STREAMS, and networking). It would have been nice to include the topic, but the authors do provide adequate references for that information.

I also found one topic that I presume was accidentally excluded: access control lists (ACLs) and their implementation. The swap algorithms are covered explicitly, but one detail I really wanted was missing: how space is allocated when there are multiple swap spaces on a system. I was

• Email
• Print
• Share
  • Slashdot
  • Digg
  • Stumble
  • Reddit
  • Newsvine