Solaris is a Unix based operating system that was developed by Sun Microsystems and after its acquisition by Oracle it is known as Oracle Solaris. It is known for its scalability and its innovative features such as DTrace, ZFS, Time Slider etc.
The kernel is the core of the operating system as its main function is to manage the hardware by allocating resources appropriately. Solaris is a microkernel design and it is not possible to create a monolithic Solaris kernel.
Booting the kernel from a local disk in Solaris can be done using the following steps −
Reading and loading the bootblock into the memory is the first step in the Solaris booting. This uses the system firmware in PROM, which is known as Open Boot PROM (OBP). The steps that are completed are providing system parameters, building hardware device tree and providing bootstrap support for manual or automatic system booting.
The bootblock locates the secondary boot program ufsboot. When the ufsboot is loaded, control passes from bootblock to ufsboot. The bootblock program cannot be larger than 7680 bytes so the only things that can be done with this space are read a Unix directory, locate the file and load it into memory.
The ufsboot program locates and loads the core kernel and the linker into /platform//kernel/unix and /kernel/misc/krtldn respectively. The ufsboot program can load the required krtldn program and pass control to it as it can parse the executable and linking format headers.
The krtldn searches for specific modules whose path is determined by a key variable. This variable is either set in the OBP firmware or it can also be entered into the boot program’s command line manually.
The Solaris kernel runs using the virtual memory address space but some initialization is needed before the user applications are started. Processor registers are initialized and mlsetup(), main() and startup() calls are made.
The init process is the first real user process that is allocated user address space rather than kernel address space. Init is the last process that is created by the kernel to get the system in motion.
Solaris has a small core kernel which has different modules that can be linked dynamically. These modules are like layers to some extent as all of them have their defined tasks and interfaces with other modules.
However, each of the modules can contact each other as required. This removes the problem of interacting with each other through multiple intermediate layers.
The Solaris Loadable Modules can be represented using the given diagram −