Mounting the Boot Device
In the last article, we discussed the loading of the rest of the executive components. The next step is to dismount the file system and remount it via the File Processor. From this point on, the FiP will be the means of accessing file systems. Here is the code:

    // Dismount file system and remount via FiP...
    E := FS.Dismount ;
    if( E <> nil ) then
    begin
        Show_Error( E ) ;
        H.Halt ;
    end ;
    E := FiP.Mount( PChar( Boot_Name[ 1 ] ), FS, FiP_Flags or FiP_Force, '', '' ) ;
    if( E <> nil ) then
    begin
        Show_Error( E ) ;
        H.Halt ;
    end ;

Processing Startup Parameters
The next step is to process the startup parameters. As you recall from past articles, Init will pass configuration information to UOS. This information includes such things as which devices are disabled, and any RAM disks. Other data is optionally passed to UOS, some of which we will cover in a future article. Let's take a look at that code:

    // Process startup parameters...
    if( not S.Read_Only ) then
    begin
        St := Get_Startup_Data ;
    end else
    begin
        setlength( St, H.Get_Configuration_Size ) ;
        move( H.Get_Configuration[ 0 ], PChar( St )[ 0 ], length( St ) ) ;
    end ;

function Get_Startup_Data : string ;

var E : TUnified_Exception ;
    Info : TUOS_File_Info ;
    UF : TUOS_File ;

begin
    Result := '' ;
    UF := FS.Get_File( PChar( '\uos\startup.dat' ) ) ;
    if( UF = nil ) then
    begin
        E := FS.Last_Error ;
        if( ( E <> nil ) and ( E.Get_Error = UOS_File_System_File_Not_Found ) ) then
        begin
            exit ; // No file means no parameters
        end ;
        if( E <> nil ) then
        begin
            Show_Error( E ) ;
            Output( 'Could not load startup parameters' + CRLF ) ;
            exit ;
        end ;
    end ;
    try
        Info := FS.Get_File_Info( PChar( '\uos\startup.dat' ), 0 ) ;
        setlength( Result, Info.Size ) ;
        UF.Read( 0, 0, Info.Size, PChar( Result )[ 0 ] ) ;
    finally
        UF.Free ;
    end ;
end ; // .Get_Startup_Data

In article 26 we discussed the Init code to generate the configuration information. The following code parses the information from Init:

    P := 1 ;
    while( P <= length( St ) ) do
    begin
        R := ord( St[ P ] ) ;
        inc( P ) ;
        case R and 3 of
            0 : Size := 1 ;
            1 : Size := 2 ;
            2 : Size := 4 ;
            4 : Size := 8 ;
        end ;
        R := R and ( not 3 ) ;
        case R of
            UOS_Config_Disabled_Device:
                begin
                    P1 := Get_Value( copy( St, P, Size ) ) ; // Device type
                    P := P + Size ;
                    P2 := Get_Value( copy( St, P, Size ) ) ; // Controller #
                    P := P + Size ;
                    P3 := Get_Value( copy( St, P, Size ) ) ; // Unit #
                    P := P + Size ;
                    H.Disable( P1, P2, P3 ) ;
                end ;
            UOS_Config_RAM_Disk:
                begin
                    P1 := Get_Value( copy( St, P, Size ) ) ; // Address
                    P := P + Size ;
                    P2 := Get_Value( copy( St, P, Size ) ) ; // Size
                    P := P + Size ;
                    P3 := Get_Value( copy( St, P, Size ) ) ; // Clustersize
                    P := P + Size ;
                    if( RAM_Disks = nil ) then
                    begin
                        RAM_Disks := TList.Create ;
                    end ;
                    RAM_Disk := TRAM_Disk64.Create ;
                    RAM_Disk.Set_Min_Storage( P3 ) ;
                    RAM_Disk.Set_Buffer( pointer( P1 ), P2, E ) ;
                    if( not Show_Error( E ) ) then
                    begin
                        RAM_Disks.Add( RAM_Disk ) ;
                    end ;
                end ;
            UOS_Config_Boot_Device: // Ignore since we already know the boot device
                begin
                    P := P + Size * 3 ; // Skip past the items
                end ;
            UOS_Config_Installation:
                begin
                    P1 := Get_Value( copy( St, P, Size ) ) ; // Length of string
                    P := P + Size ;
                    setlength( Installation, P1 ) ;
                    move( St[ P ], PChar( Installation )[ 0 ], P1 ) ;
                    P := P + P1 ;
                end ;
        end ;
    end ; // while( P <= length( St ) )

The FiP provides the interface to all devices, so after getting the configuration, we have to notify it.

    // Readjust FiP devices...
    FiP.Reload_Devices ;
    if( RAM_Disks <> nil ) then
    begin
        for I := 0 to RAM_Disks.Count - 1 do
        begin
            // Add to FiP...
            FiP.Add_Store_Device( TRAM_Disk64( RAM_Disks[ I ] ), True ) ; // Add RAM disk
            if( Show_Error( FiP.Last_Error ) ) then
            begin
                Output( 'Could not add RAM Disk ' + inttostr( I ) ) ;
            end ;
        end ;
    end ;

Sys$system and Loading the SSC
Now we load the final executive component - the User and Security Component (USC).

    // Load USC component...
    _USC := TUOS_User_Security( Load_Component( FS, Installation + 'usc.sys', USC_Index ) ) ;
    if( _USC = nil ) then
    begin
        Output( 'Error loading the USC' ) ;
        H.Halt ;
    end ;
    _USC.Kernel := self ;

The next step is to define a symbol that can be used to refer to the booted installation folder.

procedure Set_Symbol( const S, S1 : string ) ;

var Str : TString ;

begin
    Str := TString.Create ;
    try
        Str.P := Pchar( S1 ) ;
        Str.Len := length( S1 ) ;
        SSC.Set_Symbol( LNM_System, 0, PChar( S ), Str ) ;
    finally
        Str.Free ;
    end ;
end ;

In the next article, we will discuss the implementation of the System Services component.