Renaissance: The startup_32( ) Functions
by Marco Cesati, Daniel P. Bovet
Understanding the Linux Kernel, Second Edition
- Understanding the Linux Kernel, 2nd Edition
- Preface
- 1. Introduction
- Linux Versus Other Unix-Like Kernels
- Hardware Dependency
- Linux Versions
- Basic Operating System Concepts
- An Overview of the Unix Filesystem
- An Overview of Unix Kernels
- 2. Memory Addressing
- 3. Processes
- 4. Interrupts and Exceptions
- 5. Kernel Synchronization
- Kernel Control Paths
- When Synchronization Is Not Necessary
- Synchronization Primitives
- Synchronizing Accesses to Kernel Data Structures
- Choosing Among Spin Locks, Semaphores, and Interrupt Disabling
- Protecting a data structure accessed by exceptions
- Protecting a data structure accessed by interrupts
- Protecting a data structure accessed by deferrable functions
- Protecting a data structure accessed by exceptions and interrupts
- Protecting a data structure accessed by exceptions and deferrable functions
- Protecting a data structure accessed by interrupts and deferrable functions
- Protecting a data structure accessed by exceptions, interrupts, and deferrable functions
- Choosing Among Spin Locks, Semaphores, and Interrupt Disabling
- Examples of Race Condition Prevention
- 6. Timing Measurements
- 7. Memory Management
- Page Frame Management
- Memory Area Management
- The Slab Allocator
- Cache Descriptor
- Slab Descriptor
- General and Specific Caches
- Interfacing the Slab Allocator with the Buddy System
- Allocating a Slab to a Cache
- Releasing a Slab from a Cache
- Object Descriptor
- Aligning Objects in Memory
- Slab Coloring
- Local Array of Objects in Multiprocessor Systems
- Allocating an Object in a Cache
- Releasing an Object from a Cache
- General Purpose Objects
- Noncontiguous Memory Area Management
- 8. Process Address Space
- The Process’s Address Space
- The Memory Descriptor
- Memory Regions
- Page Fault Exception Handler
- Creating and Deleting a Process Address Space
- Managing the Heap
- 9. System Calls
- 10. Signals
- 11. Process Scheduling
- 12. The Virtual Filesystem
- 13. Managing I/O Devices
- I/O Architecture
- Device Files
- Device Drivers
- Block Device Drivers
- Character Device Drivers
- 14. Disk Caches
- 15. Accessing Files
- 16. Swapping: Methods for Freeing Memory
- What Is Swapping?
- Swap Area
- The Swap Cache
- Transferring Swap Pages
- Swapping Out Pages
- Swapping in Pages
- Reclaiming Page Frame
- 17. The Ext2 and Ext3 Filesystems
- 18. Networking
- 19. Process Communication
- 20. Program Execution
- A. System Startup
- B. Modules
- C. Source Code Structure
- 21. Bibliography
- Index
- Colophon
There are two different startup_32( ) functions;
the one we refer to here is coded in the
arch/i386/boot/compressed/head.S file. After
setup( ) terminates, the function has been moved
either to physical address 0x00100000 or to
physical address 0x00001000, depending on whether
the kernel image was loaded high or low in RAM.
This function performs the following operations:
Initializes the segmentation registers and a provisional stack.
Fills the area of uninitialized data of the kernel identified by the
_edataand_endsymbols with zeros (see Section 2.5.3).Invokes the
decompress_kernel( )function to decompress the kernel image. The “Uncompressing Linux . . . " message is displayed first. After the kernel image is decompressed, the “O K, booting the kernel.” message is shown. If the kernel image was loaded low, the decompressed kernel is placed at physical address0x00100000. Otherwise, if the kernel image was loaded high, the decompressed kernel is placed in a temporary buffer located after the compressed image. The decompressed image is then moved into its final position, which starts at physical address0x00100000.Jumps to physical address
0x00100000.
The decompressed kernel image begins with another
startup_32( ) function included in the
arch/i386/kernel/head.S file. Using the same
name for both the functions does not create any problems (besides
confusing our readers), since both functions are executed by jumping
to their initial physical addresses.
The second startup_32( ) function sets up the
execution environment for the first Linux process (process 0). The
function performs the following operations:
Initializes the segmentation registers with their final values.
Sets up the Kernel Mode stack for process 0 (see Section 3.4.2).
Initializes the provisional kernel Page Tables contained in
swapper_pg_dirandpg0to identically map the linear addresses to the same physical addresses, as explained in Section 2.5.5.Stores the address of the Page Global Directory in the
cr3register, and enables paging by setting the PG bit in thecr0register.Fills the bss segment of the kernel (see Section 20.1.4) with zeros.
Invokes
setup_idt( )to fill the IDT with null interrupt handlers (see Section 4.4.2).Puts the system parameters obtained from the BIOS and the parameters passed to the operating system into the first page frame (see Section 2.5.3).
Identifies the model of the processor.
Loads the
gdtrandidtrregisters with the addresses of the GDT and IDT tables.Jumps to the
start_kernel( )function.
-
No Comment