Solaris internals / Architecture and tehniques / Core kernel components

Enhanced descriptions from Syndetics:

PREFACE

The internals of the UNIX kernel are fairly well-documented, most notably by Goodheart and Cox 10, Bach 1, McKusick et al. 19, and Vahalia 39. These texts have become a common source of reference information for those who want to better understand the internals of UNIX. However little has been written about the specifics of the Solaris kernel.

The paucity of Solaris specific information led us to create our own reference material. As we published information through white papers, magazine columns, and tutorials, the number of folks expressing interest motivated us to produce a complete work that discussed Solaris exclusively.

About This Book

This book is about the internals of Sun's Solaris Operating Environment. The rapid growth of Solaris has created a large number of users, software developers, systems administrators, performance analysts, and other members of the technical community, all of whom require in-depth knowledge about the environment in which they work.

Since the focus of this book is the internals of the Solaris kernel, the book provides a great deal of information on the architecture of the kernel and the major data structures and algorithms implemented in the operating system. However, rather than approach the subject matter from a purely academic point of view, we wrote the book with an eye on the practical application of the information contained herein. Thus, we have emphasized the methods and tools that can be used on a Solaris system to extract information that otherwise is not easily accessible with the standard bundled commands and utilities. We want to illustrate how you can apply this knowledge in a meaningful way, as your job or interest dictates.

To maximize the usefulness of the text, we included specific information on Solaris versions 2.5.1, 2.6, and Solaris 7. We cover the major Solaris subsystems, including memory management, process management, threads, files, and file systems. We do not cover details of low-level I/O, device drivers, STREAMS, and networking. For reference material on these topics, see "Writing Device Drivers" 28, the "STREAMS Programming Guide" 29, and "UNIX Network Programming" 32.

The material included in this book is not necessarily presented at an introductory level, although whenever possible we begin discussing a topic with some conceptual background information. We assume that you have some familiarity with operating systems concepts and have used a UNIX-based operating system. Some knowledge of the C programming language is useful but not required.

Because of the variety of hardware platforms on which Solaris runs, it is not practical to discuss the low-level details of all the different processors and architectures, so our hardware focus, when detail is required, is admittedly UltraSPARC-centric. This approach makes the most sense since it represents the current technology and addresses the largest installed base. In general, the concepts put forth when detail is required apply to other processors and platforms supported. The differences are in the specific implementation details, such as per-processor hardware registers.

Throughout the book we refer to specific kernel functions by name as we describe the flow of various code segments. These routines are internal to the operating system and should not be construed as, or confused with, the public interfaces that ship as part of the Solaris product line-the systems calls and library interfaces. The functions referenced throughout the text, unless explicitly noted, are private to the kernel and not callable or in any way usable by application programs.

Intended Audience

We hope that this book will serve as a useful reference for a variety of technical staff members working with the Solaris Operating Environment.

Application developerscan find information in this book about how Solaris implements functions behind the application programming interfaces. This information helps developers understand performance, scalability, and implementation specifics of each interface when they develop Solaris applications. The system overview section and sections on scheduling, interprocess communication, and file system behavior should be the most useful sections. Device driver and kernel module developersof drivers, STREAMS modules, loadable system calls, etc., can find herein the general architecture and implementation theory of the Solaris Operating Environment. The Solaris kernel framework and facilities portions of the book (especially the locking and synchronization primitives chapters) are particularly relevant. Systems administrators, systems analysts, database administrators, and ERP managersresponsible for performance tuning and capacity planning can learn about the behavioral characteristics of the major Solaris subsystems. The file system caching and memory management chapters provide a great deal of information about how Solaris behaves in real-world environments. The algorithms behind Solaris tunable parameters (which are detailed in Appendix A) are covered in depth throughout the book. Technical support staffresponsible for the diagnosis, debugging, and support of Solaris will find a wealth of information about implementation details of Solaris. Major data structures and data flow diagrams are provided in each chapter to aid debugging and navigation of Solaris Systems. System users who just want to know moreabout how the Solaris kernel works will find high-level overviews at the start of each chapter.

In addition to the various technical staff members listed above, we also believe that members of the academic community will find the book of value in studying how a volume, production kernel implements major subsystems and solves the problems inherent in operating systems development.

How This Book Is Organized

We organized Solaras Internals into several logical parts, each part grouping several chapters containing related information. Our goal was to provide a building block approach to the material, where later sections build on information provided in earlier chapters. However, for readers familiar with particular aspects of operating systems design and implementation, the individual parts and chapters can stand on their own in terms of the subject matter they cover.

Part One: Introduction to Solaris Internals Chapter 1 -- An Introduction to Solaris Chapter 2 -- Kernel Services Chapter 3 -- Kernel Synchronization Primitives Chapter 4 -- Kernel Bootstrap and Initialization Part Two: The Solaris Memory System Chapter 5 -- Solaris Memory Architecture Chapter 6 -- Kernel Memory Chapter 7 -- Memory Monitoring Part Three: Threads, Processes, and IPC Chapter 8 -- The Solaris Multithreaded Process Architecture Chapter 9 -- The Solaris Kernel Dispatcher Chapter 10 -- Interprocess Communication Part Four: Files and File Systems Chapter 11 -- Solaris Files and File I/O Chapter 12 -- File System Overview Chapter 13 -- File System Framework Chapter 14 -- The UNIX File System Chapter 15 -- Solaris File System Cache Solaris Source Code

In February 2000, Sun announced the availability of Solaris source. This book provides the essential companion to the Solaris source and can be used as a guide to the Solaris kernel framework and architecture.

It should also be noted that the source available from Sun is the Solaris 8 source. Although this book covers Solaris versions up to and including Solaris 7, almost all of the material is relevant to Solaris 8.

Updates and Related Material

To complement this book, we created a Web site where we will place updated material, tools we refer to, and links to related material on the topics covered. The Web site is available at http://www.solarisinternals.com.

A Note from the Authors

We certainly hope that you get as much out of reading Solaris Internals as we did from writing it. We welcome comments, suggestions, and questions from readers.

Table of contents provided by Syndetics

• Contents (p. vii)
• List of Figures (p. xxi)
• List of Tables (p. xxvii)
• List of Header Files (p. xxxi)
• Preface (p. xxxiii)
• Acknowledgments (p. xxxix)
• Part 1 Introduction To Solaris Internals (p. 1)
• 1. An Introduction to Solaris (p. 3)
• A Brief History (p. 4)
• Key Differentiators (p. 8)
• Kernel Overview (p. 10)
• Solaris Kernel Architecture (p. 11)
• Modular Implementation (p. 12)
• Processes, Threads, and Scheduling (p. 14)
• Two-Level Thread Model (p. 15)
• Global Process Priorities and Scheduling (p. 16)
• Interprocess Communication (p. 17)
• Traditional UNIX IPC (p. 17)
• System V IPC (p. 18)
• POSIX IPC (p. 18)
• Advanced Solaris IPC (p. 18)
• Signals (p. 19)
• Memory Management (p. 19)
• Global Memory Allocation (p. 20)
• Kernel Memory Management (p. 21)
• Files and File Systems (p. 21)
• File Descriptors and File System Calls (p. 22)
• The Virtual File System Framework (p. 23)
• I/O Architecture (p. 25)
• 2. Kernel Services (p. 27)
• Access to Kernel Services (p. 27)
• Entering Kernel Mode (p. 28)
• Context (p. 29)
• Threads in Kernel and Interrupt Context (p. 30)
• UltraSPARC I and II Traps (p. 31)
• Interrupts (p. 38)
• Interrupt Priorities (p. 38)
• Interrupt Monitoring (p. 42)
• Interprocessor Interrupts and Cross-Calls (p. 43)
• System Calls (p. 44)
• Regular System Calls (p. 44)
• Fast Trap System Calls (p. 46)
• The Kernel Callout Table (p. 47)
• Solaris 2.6 and 7 Callout Tables (p. 47)
• Solaris 2.5.1 Callout Tables (p. 51)
• The System Clock (p. 54)
• Process Execution Time Statistics (p. 55)
• High-Resolution Clock Interrupts (p. 56)
• High-Resolution Timer (p. 57)
• Time-of-Day Clock (p. 57)
• 3. Kernel Synchronization Primitives (p. 59)
• Synchronization (p. 59)
• Parallel Systems Architectures (p. 60)
• Hardware Considerations for Locks and Synchronization (p. 63)
• Introduction to Synchronization Objects (p. 68)
• Synchronization Process (p. 69)
• Synchronization Object Operations Vector (p. 70)
• Mutex Locks (p. 71)
• Overview (p. 71)
• Solaris 7 Mutex Lock Implementation (p. 74)
• Reader/Writer Locks (p. 82)
• Solaris 7 Reader/Writer Locks (p. 82)
• Solaris 2.6 RW Lock Differences (p. 85)
• Solaris 2.5.1 RW Lock Differences (p. 86)
• Turnstiles and Priority Inheritance (p. 88)
• Solaris 7 Turnstiles (p. 89)
• Solaris 2.5.1 and 2.6 Turnstiles (p. 92)
• Dispatcher Locks (p. 96)
• Kernel Semaphores (p. 98)
• 4. Kernel Bootstrap and Initialization (p. 103)
• Kernel Directory Hierarchy (p. 103)
• Kernel Bootstrap and Initialization (p. 107)
• Loading the Bootblock (p. 107)
• Loading ufsboot (p. 108)
• Locating Core Kernel Images and Linker (p. 109)
• Loading Kernel Modules (p. 109)
• Creating Kernel Structures, Resources, and Components (p. 110)
• Completing the Boot Process (p. 114)
• During the Boot Process: Creating System Kernel Threads (p. 115)
• Kernel Module Loading and Linking (p. 116)
• Part 2 The Solaris Memory System (p. 123)
• 5. Solaris Memory Architecture (p. 125)
• Why Have a Virtual Memory System? (p. 125)
• Modular Implementation (p. 128)
• Virtual Address Spaces (p. 130)
• Sharing of Executables and Libraries (p. 132)
• SPARC Address Spaces (p. 132)
• Intel Address Space Layout (p. 134)
• Process Memory Allocation (p. 134)
• The Stack (p. 136)
• Address Space Management (p. 137)
• Virtual Memory Protection Modes (p. 140)
• Page Faults in Address Spaces (p. 140)
• Memory Segments (p. 143)
• The vnode Segment: seg_vn (p. 147)
• Copy-on-Write (p. 152)
• Page Protection and Advice (p. 152)
• Anonymous Memory (p. 153)
• The Anonymous Memory Layer (p. 153)
• The swapfs Layer (p. 156)
• Anonymous Memory Accounting (p. 161)
• Virtual Memory Watchpoints (p. 164)
• Global Page Management (p. 167)
• Pages--The Basic Unit of Solaris Memory (p. 167)
• The Page Hash List (p. 168)
• MMU-Specific Page Structures (p. 169)
• Physical Page Lists (p. 170)
• The Page-Level Interfaces (p. 172)
• The Page Throttle (p. 173)
• Page Sizes (p. 173)
• Page Coloring (p. 174)
• The Page Scanner (p. 178)
• Page Scanner Operation (p. 179)
• Page-out Algorithm and Parameters (p. 180)
• Shared Library Optimizations (p. 183)
• The Priority Paging Algorithm (p. 183)
• Page Scanner Implementation (p. 187)
• The Memory Scheduler (p. 189)
• The Hardware Address Translation Layer (p. 190)
• Virtual Memory Contexts and Address Spaces (p. 192)
• The UltraSPARC-I and -II HAT (p. 193)
• Address Space Identifiers (p. 198)
• Large Pages (p. 201)
• 6. Kernel Memory (p. 205)
• Kernel Virtual Memory Layout (p. 205)
• Kernel Address Space (p. 206)
• The Kernel Text and Data Segments (p. 208)
• Virtual Memory Data Structures (p. 208)
• The SPARC V8 and V9 Kernel Nucleus (p. 209)
• Loadable Kernel Module Text and Data (p. 209)
• The Kernel Address Space and Segments (p. 211)
• Kernel Memory Allocation (p. 212)
• The Kernel Map (p. 213)
• The Resource Map Allocator (p. 214)
• The Kernel Memory Segment Driver (p. 216)
• The Kernel Memory Slab Allocator (p. 217)
• 7. Memory Monitoring (p. 233)
• A Quick Introduction to Memory Monitoring (p. 233)
• Total Physical Memory (p. 234)
• Kernel Memory (p. 234)
• Free Memory (p. 234)
• File System Caching Memory (p. 234)
• Memory Shortage Detection (p. 235)
• Swap Space (p. 236)
• Memory Monitoring Tools (p. 237)
• The vmstat Command (p. 238)
• Free Memory (p. 239)
• Swap Space (p. 239)
• Paging Counters (p. 239)
• Process Memory Usage, ps, and the pmap Command (p. 240)
• MemTool: Unbundled Memory Tools (p. 242)
• MemTool Utilities (p. 243)
• Command-Line Tools (p. 243)
• The MemTool GUI (p. 245)
• Other Memory Tools (p. 250)
• The Workspace Monitor Utility: WSM (p. 250)
• An Extended vmstat Command: memstat (p. 251)
• Part 3 Threads, Processes, and IPC (p. 255)
• 8. The Solaris Multithreaded Process Architecture (p. 257)
• Introduction to Solaris Processes (p. 257)
• Architecture of a Process (p. 258)
• Process Image (p. 263)
• Process Structures (p. 265)
• The Process Structure (p. 265)
• The User Area (p. 277)
• The Lightweight Process (LWP) (p. 281)
• The Kernel Thread (kthread) (p. 283)
• The Kernel Process Table (p. 286)
• Process Limits (p. 287)
• LWP Limits (p. 289)
• Process Creation (p. 289)
• Process Termination (p. 298)
• The LWP/kthread Model (p. 300)
• Deathrow (p. 301)
• Procfs--The Process File System (p. 302)
• Procfs Implementation (p. 305)
• Process Resource Usage (p. 314)
• Microstate Accounting (p. 316)
• Signals (p. 320)
• Signal Implementation (p. 326)
• Sigwaiting: A Special Signal (p. 337)
• Sessions and Process Groups (p. 337)
• 9. The Solaris Kernel Dispatcher (p. 343)
• Overview (p. 344)
• Scheduling Classes (p. 346)
• Dispatch Tables (p. 356)
• The Kernel Dispatcher (p. 362)
• Dispatch Queues (p. 365)
• Thread Priorities (p. 369)
• Dispatcher Functions (p. 382)
• The Kernel Sleep/Wakeup Facility (p. 396)
• Condition Variables (p. 397)
• Sleep Queues (p. 399)
• The Sleep Process (p. 402)
• The Wakeup Mechanism (p. 405)
• Scheduler Activations (p. 407)
• User Thread Activation (p. 408)
• LWP Pool Activation (p. 409)
• Kernel Processor Control and Processor Sets (p. 411)
• Processor Control (p. 413)
• Processor Sets (p. 416)
• 10. Interprocess Communication (p. 421)
• Generic System V IPC Support (p. 422)
• Module Creation (p. 422)
• Resource Maps (p. 425)
• System V Shared Memory (p. 425)
• Shared Memory Kernel Implementation (p. 430)
• Intimate Shared Memory (ISM) (p. 432)
• System V Semaphores (p. 436)
• Semaphore Kernel Resources (p. 436)
• Kernel Implementation of System V Semaphores (p. 439)
• Semaphore Operations Inside Solaris (p. 440)
• System V Message Queues (p. 442)
• Kernel Resources for Message Queues (p. 442)
• Kernel Implementation of Message Queues (p. 447)
• POSX IPC (p. 449)
• POSIX Shared Memory (p. 452)
• POSIX Semaphores (p. 452)
• POSIX Message Queues (p. 455)
• Solaris Doors (p. 459)
• Doors Overview (p. 460)
• Doors Implementation (p. 461)
• Part 4 Files and File Systems (p. 469)
• 11. Solaris Files and File I/O (p. 471)
• Files in Solaris (p. 471)
• Kernel File Structures (p. 476)
• File Application Programming Interfaces (APIs) (p. 478)
• Standard I/O (stdio) (p. 479)
• C Runtime File Handles (p. 482)
• Standard I/O Buffer Sizes (p. 483)
• System File I/O (p. 483)
• File I/O System Calls (p. 483)
• File Open Modes and File Descriptor Flags (p. 485)
• Asynchronous I/O (p. 492)
• File System Asynchronous I/O (p. 493)
• Kernel Asynchronous I/O (p. 494)
• Memory Mapped File I/O (p. 498)
• Mapping Options (p. 500)
• Providing Advice to the Memory System (p. 502)
• 64-bit Files in Solaris (p. 506)
• 64-bit Device Support in Solaris 2.0 (p. 507)
• 64-bit File Application Programming Interfaces in Solaris 2.5.1 (p. 507)
• Solaris 2.6: The Large-File OS (p. 508)
• File System Support for Large Files (p. 511)
• 12. File System Overview (p. 513)
• Why Have a File System? (p. 513)
• Support for Multiple File System Types (p. 514)
• Regular (On-Disk) File Systems (p. 515)
• Allocation and Storage Strategy (p. 516)
• File System Capacity (p. 519)
• Variable Block Size Support (p. 520)
• Access Control Lists (p. 521)
• File Systems Logging (Journaling) (p. 522)
• Expanding and Shrinking File Systems (p. 526)
• Direct I/O (p. 527)
• 13. File System Framework (p. 531)
• Solaris File System Framework (p. 531)
• Unified File System Interface (p. 532)
• File System Framework Facilities (p. 533)
• The vnode (p. 533)
• Vnode Types (p. 535)
• Vnode Methods (p. 536)
• Vnode Reference Count (p. 538)
• Interfaces for Paging vnode Cache (p. 538)
• Block I/O on vnode Pages (p. 540)
• The vfs Object (p. 540)
• The File System Switch Table (p. 542)
• The Mounted vfs List (p. 544)
• File System I/O (p. 547)
• Memory Mapped I/O (p. 548)
• read() and write() System Calls (p. 549)
• The seg_map Segment (p. 549)
• Path-Name Management (p. 554)
• The lookupname() and lookuppn() Methods (p. 554)
• The vop_lookup() Method (p. 555)
• The vop_readdir() Method (p. 555)
• Path-Name Traversal Functions (p. 556)
• The Directory Name Lookup Cache (DNLC) (p. 557)
• File System Modules (p. 561)
• Mounting and Unmounting (p. 561)
• The File System Flush Daemon (p. 563)
• 14. The UNIX File System (p. 565)
• UFS Development History (p. 565)
• UFS On-Disk Format (p. 567)
• UFS Inodes (p. 567)
• UFS Directories (p. 567)
• UFS Hard Links (p. 569)
• UFS Layout (p. 569)
• Disk Block Location (p. 572)
• UFS Block Allocation (p. 573)
• UFS Allocation and Parameters (p. 574)
• UFS Implementation (p. 577)
• Mapping of Files to Disk Blocks (p. 579)
• Methods to Read and Write UFS Files (p. 580)
• In-Core UFS Inodes (p. 584)
• UFS Directories and Path Names (p. 587)
• 15. Solaris File System Cache (p. 589)
• Introduction to File Caching (p. 589)
• Solaris Page Cache (p. 590)
• Block Buffer Cache (p. 592)
• Page Cache and Virtual Memory System (p. 593)
• File System Paging Optimizations (p. 595)
• Is All That Paging Bad for My System? (p. 595)
• Paging Parameters That Affect File System Performance (p. 599)
• Bypassing the Page Cache with Direct I/O (p. 600)
• UFS Direct I/O (p. 600)
• Direct I/O with Veritas VxFS (p. 603)
• Directory Name Cache (p. 603)
• Inode Caches (p. 605)
• UFS Inode Cache Size (p. 605)
• VxFS Inode Cache (p. 607)
• Appendix A Kernel Tunables, Switches, and Limits (p. 609)
• Appendix B Kernel Virtual Address Maps (p. 621)
• Appendix C A Sample Procfs Utility (p. 629)
• Bibliography (p. 635)
• Index (p. 639)

Excerpt provided by Syndetics

PREFACE The internals of the UNIX kernel are fairly well-documented, most notably by Goodheart and Cox 10, Bach 1, McKusick et al. 19, and Vahalia 39. These texts have become a common source of reference information for those who want to better understand the internals of UNIX. However little has been written about the specifics of the Solaris kernel. The paucity of Solaris specific information led us to create our own reference material. As we published information through white papers, magazine columns, and tutorials, the number of folks expressing interest motivated us to produce a complete work that discussed Solaris exclusively. About This Book This book is about the internals of Sun's Solaris Operating Environment. The rapid growth of Solaris has created a large number of users, software developers, systems administrators, performance analysts, and other members of the technical community, all of whom require in-depth knowledge about the environment in which they work. Since the focus of this book is the internals of the Solaris kernel, the book provides a great deal of information on the architecture of the kernel and the major data structures and algorithms implemented in the operating system. However, rather than approach the subject matter from a purely academic point of view, we wrote the book with an eye on the practical application of the information contained herein. Thus, we have emphasized the methods and tools that can be used on a Solaris system to extract information that otherwise is not easily accessible with the standard bundled commands and utilities. We want to illustrate how you can apply this knowledge in a meaningful way, as your job or interest dictates. To maximize the usefulness of the text, we included specific information on Solaris versions 2.5.1, 2.6, and Solaris 7. We cover the major Solaris subsystems, including memory management, process management, threads, files, and file systems. We do not cover details of low-level I/O, device drivers, STREAMS, and networking. For reference material on these topics, see "Writing Device Drivers" 28, the "STREAMS Programming Guide" 29, and "UNIX Network Programming" 32. The material included in this book is not necessarily presented at an introductory level, although whenever possible we begin discussing a topic with some conceptual background information. We assume that you have some familiarity with operating systems concepts and have used a UNIX-based operating system. Some knowledge of the C programming language is useful but not required. Because of the variety of hardware platforms on which Solaris runs, it is not practical to discuss the low-level details of all the different processors and architectures, so our hardware focus, when detail is required, is admittedly UltraSPARC-centric. This approach makes the most sense since it represents the current technology and addresses the largest installed base. In general, the concepts put forth when detail is required apply to other processors and platforms supported. The differences are in the specific implementation details, such as per-processor hardware registers. Throughout the book we refer to specific kernel functions by name as we describe the flow of various code segments. These routines are internal to the operating system and should not be construed as, or confused with, the public interfaces that ship as part of the Solaris product line-the systems calls and library interfaces. The functions referenced throughout the text, unless explicitly noted, are private to the kernel and not callable or in any way usable by application programs. Intended Audience We hope that this book will serve as a useful reference for a variety of technical staff members working with the Solaris Operating Environment. Application developers can find information in this book about how Solaris implements functions behind the application programming interfaces. This information helps developers understand performance, scalability, and implementation specifics of each interface when they develop Solaris applications. The system overview section and sections on scheduling, interprocess communication, and file system behavior should be the most useful sections. Device driver and kernel module developers of drivers, STREAMS modules, loadable system calls, etc., can find herein the general architecture and implementation theory of the Solaris Operating Environment. The Solaris kernel framework and facilities portions of the book (especially the locking and synchronization primitives chapters) are particularly relevant. Systems administrators, systems analysts, database administrators, and ERP managers responsible for performance tuning and capacity planning can learn about the behavioral characteristics of the major Solaris subsystems. The file system caching and memory management chapters provide a great deal of information about how Solaris behaves in real-world environments. The algorithms behind Solaris tunable parameters (which are detailed in Appendix A) are covered in depth throughout the book. Technical support staff responsible for the diagnosis, debugging, and support of Solaris will find a wealth of information about implementation details of Solaris. Major data structures and data flow diagrams are provided in each chapter to aid debugging and navigation of Solaris Systems. System users who just want to know more about how the Solaris kernel works will find high-level overviews at the start of each chapter. In addition to the various technical staff members listed above, we also believe that members of the academic community will find the book of value in studying how a volume, production kernel implements major subsystems and solves the problems inherent in operating systems development. How This Book Is Organized We organized Solaras Internals into several logical parts, each part grouping several chapters containing related information. Our goal was to provide a building block approach to the material, where later sections build on information provided in earlier chapters. However, for readers familiar with particular aspects of operating systems design and implementation, the individual parts and chapters can stand on their own in terms of the subject matter they cover. Part One: Introduction to Solaris Internals Chapter 1 -- An Introduction to Solaris Chapter 2 -- Kernel Services Chapter 3 -- Kernel Synchronization Primitives Chapter 4 -- Kernel Bootstrap and Initialization Part Two: The Solaris Memory System Chapter 5 -- Solaris Memory Architecture Chapter 6 -- Kernel Memory Chapter 7 -- Memory Monitoring Part Three: Threads, Processes, and IPC Chapter 8 -- The Solaris Multithreaded Process Architecture Chapter 9 -- The Solaris Kernel Dispatcher Chapter 10 -- Interprocess Communication Part Four: Files and File Systems Chapter 11 -- Solaris Files and File I/O Chapter 12 -- File System Overview Chapter 13 -- File System Framework Chapter 14 -- The UNIX File System Chapter 15 -- Solaris File System Cache Solaris Source Code In February 2000, Sun announced the availability of Solaris source. This book provides the essential companion to the Solaris source and can be used as a guide to the Solaris kernel framework and architecture. It should also be noted that the source available from Sun is the Solaris 8 source. Although this book covers Solaris versions up to and including Solaris 7, almost all of the material is relevant to Solaris 8. Updates and Related Material To complement this book, we created a Web site where we will place updated material, tools we refer to, and links to related material on the topics covered. The Web site is available at http://www.solarisinternals.com. A Note from the Authors We certainly hope that you get as much out of reading Solaris Internals as we did from writing it. We welcome comments, suggestions, and questions from readers. Excerpted from Solaris Internals by Richard McDougall, Jim Mauro, Sun Microsystems Press Staff All rights reserved by the original copyright owners. Excerpts are provided for display purposes only and may not be reproduced, reprinted or distributed without the written permission of the publisher.

Author notes provided by Syndetics

JIM MAURO has 20 years of industry experience with UNIX systems. Jim is a senior engineer in the Performance Applications Engineering group at Sun Microsystems. When Jim is not wrestling with his two sons, his house, or his yard, he works on systems and applications availability and resource management-related projects for Sun.

RICHARD McDOUGALL is a senior engineer in the Performance Applications Engineering group at Sun Microsystems, focusing on enterprise systems architecture, large system performance, and OS technology. He has been known to have some knowledge of operating system architecture and internals. When Richard isn't tinkering with cars or racing karts, he is usually found analyzing system performance, contributing to Solaris development, and developing tools for measurement, monitoring, tracing, and sizing UNIX systems.