CREPRC, part 2

In the last article, we documented the CREPRC system service. In this article, we will examine the code to implement it.

function SYS_CREPRC( pidadr, image, input, output, error, prvadr, quota, prcnam,
    baspri, uic, mbxunt, stsflg, itmlst, node, home_rad : int64 ) : int64 ;

var Status : int64 ;
    SysRequest : TS6I9_Request ;

begin
    fillchar( SysRequest, sizeof( SysRequest ), 0 ) ;
    Status := 0 ;
    SysRequest.Request.Subsystem :=  UOS_Subsystem_USC ;
    SysRequest.Request.Request := UOS_USC_Create_Process ;
    SysRequest.Request.Length := sizeof( SysRequest ) - sizeof( Sysrequest.Request ) ;
    SysRequest.Request.Status := integer( @Status ) ;
    SysRequest.Integer1 := pidadr ;
    if( Image <> 0 ) then
    begin
        SysRequest.SRB1 := PSRB( Image )^ ;
    end ;
    if( Input <> 0 ) then
    begin
        SysRequest.SRB2 := PSRB( Input )^ ;
    end ;
    if( Output <> 0 ) then
    begin
        SysRequest.SRB3 := PSRB( Output )^ ;
    end ;
    if( Error <> 0 ) then
    begin
        SysRequest.SRB4 := PSRB( Error )^ ;
    end ;
    SysRequest.Integer2 := prvadr ;
    SysRequest.Integer3 := quota ;
    if( prcnam <> 0 ) then
    begin
        SysRequest.SRB5 := PSRB( prcnam )^ ;
    end ;
    SysRequest.Integer4 := baspri ;
    SysRequest.Integer5 := uic ;
    SysRequest.Integer6 := mbxunt ;
    SysRequest.Integer7 := stsflg ;
    SysRequest.Integer8 := itmlst ;
    if( node <> 0 ) then
    begin
        SysRequest.SRB6 := PSRB( node )^ ;
    end ;
    SysRequest.Integer9 := home_rad ;
    Call_To_Ring0( integer( @SysRequest ) ) ;
    Result := Status ;
end ;

This function was added to the SYS module as a wrapper to the CREPRC service.

        UOS_USC_Create_Process:
            begin
                UE := Enter_System_Call( Request, SReq, PID, MMC, 
                    sizeof( S6I9_Request ) - sizeof( SReq ), Address ) ;
                if( UE <> nil ) then
                begin
                    Set_Last_Error( UE ) ;
                    exit ;
                end ;
                try
                    S6I9_Request := PS6I9_Request( Address ) ;
                    Create_SubProcess( S6I9_Request.Integer1, S6I9_Request.SRB1,
                        S6I9_Request.SRB2, S6I9_Request.SRB3,
                        S6I9_Request.SRB4, S6I9_Request.Integer2,
                        S6I9_Request.Integer3, S6I9_Request.SRB4,
                        S6I9_Request.Integer4, S6I9_Request.Integer5,
                        S6I9_Request.Integer6, S6I9_Request.Integer7,
                        S6I9_Request.Integer8, S6I9_Request.SRB5,
                        S6I9_Request.Integer9 ) ;
                finally
                    Exit_System_Call( Request, PID, MMC, 
                        sizeof( TItem_Request ) - sizeof( SReq ) ) ;
                end ;
            end ;

This code is added to the USC.API method to handle CREPRC calls.

function TUSC.Create_SubProcess( pidadr : int64 ;
    image, input, output, error : TSRB ; prvadr, quota : int64 ; prcnam : TSRB ;
    baspri, uic, mbxunt, stsflg, itmlst : int64 ; node : TSRB ;
    home_rad : int64 ) : int64 ;

var I : cardinal ;
    New_Process, Process : TProcess ;
    User : Tuser ;
    QuotaB : TQuota_Block ;
    Status : integer ;
    Base_Name, sImage, sName, sInput, sOutput, sError : string ;
    Resource : TResource ;
    RNG : TSRNG32 ;
    This_PID : TPID ;
    Value : cardinal ;

begin
    // Setup...
    Result := 0 ; // Assume success
    This_PID := _Kernel.PID ;
    Process := Get_Process( This_PID ) ;
    if( Process = nil ) then
    begin
        exit ;
    end ;
    User := Process.User ;

This USC routine handles the CREPRC system service. The first thing we do is get the current process PID and process instance.

    // Check quotas...
    if( User.Rec.Quotas.PRCLM <> 0 ) then // There is a limit
    begin
        if( User.Usage.PRCLM >= User.Rec.Quotas.PRCLM ) then
        begin
            Generate_Exception( UOSErr_Quota_Exceeded ) ;
            exit ;
        end ;
    end ; // if( Process.Rec.Quotas.PRCLM <> 0 )
    if( User.Rec.Quotas.MAXJOBS <> 0 ) then
    begin
        if( User.Usage.MAXJOBS >= User.Rec.Quotas.MAXJOBS ) then
        begin
            Generate_Exception( UOSErr_Quota_Exceeded ) ;
            exit ;
        end ;
    end ;

Next we check to make sure we aren't creating a process that causes an exceeded quota.

    // Get flags...
    if( stsflg <> 0 ) then
    begin
        stsflg := Get_User_Integer( _Kernel, This_PID, stsflg, Status ) ;
        if( Status = UE_Error ) then
        begin
            if( MMC.Last_Error = nil ) then
            begin
                Generate_Exception( UOSErr_Memory_Address_Error ) ;
            end ;
            exit ;
        end ;
    end ;

    // Validate permissions...
    if( ( stsflg and PRC_M_TRUSTED ) = 0 ) then // Not trusted creation
    begin
        if( ( Process.User.Flags and UAI_V_CAPTIVE ) <> 0 ) then // Captive account
        begin
            Generate_Exception( SS_NOPRIV ) ;
            exit ;
        end ;
    end ;
    if( ( stsflg and PRC_M_NETWRK ) <> 0 ) then
    begin
        if( ( Process.Current_Privileges and IMPERSONATE ) = 0 ) then
        begin
            Generate_Exception( SS_NOPRIV ) ;
            exit ;
        end ;
    end ;
    if( ( stsflg and PRC_M_BATCH ) <> 0 ) then
    begin
        if( ( Process.Current_Privileges and IMPERSONATE ) = 0 ) then
        begin
            Generate_Exception( SS_NOPRIV ) ;
            exit ;
        end ;
    end ;
    if( ( stsflg and PRC_M_NOACNT ) <> 0 ) then
    begin
        if( ( Process.Current_Privileges and ACNT ) = 0 ) then
        begin
            Generate_Exception( SS_NOPRIV ) ;
            exit ;
        end ;
    end ;
    if( ( stsflg and PRC_M_PSWAPM ) <> 0 ) then
    begin
        if( ( Process.Current_Privileges and PSWAPM ) = 0 ) then
        begin
            Generate_Exception( SS_NOPRIV ) ;
            exit ;
        end ;
    end ;
    if( ( stsflg and PRC_M_TCB ) <> 0 ) then
    begin
        if( ( Process.Current_Privileges and IMPERSONATE ) = 0 ) then
        begin
            Generate_Exception( SS_NOPRIV ) ;
            exit ;
        end ;
    end ;

    sInput := trim( Get_User_String_As_String( _Kernel, This_PID, Input, Status ) ) ;
    if( Status = UE_Error ) then
    begin
        if( MMC.Last_Error = nil ) then
        begin
            Generate_Exception( UOSErr_Memory_Address_Error ) ;
        end ;
        exit ;
    end ;
    sOutput := trim( Get_User_String_As_String( _Kernel, This_PID, Output, Status ) ) ;
    if( Status = UE_Error ) then
    begin
        if( MMC.Last_Error = nil ) then
        begin
            Generate_Exception( UOSErr_Memory_Address_Error ) ;
        end ;
        exit ;
    end ;
    sError := trim( Get_User_String_As_String( _Kernel, This_PID, Error, Status ) ) ;
    if( Status = UE_Error ) then
    begin
        if( MMC.Last_Error = nil ) then
        begin
            Generate_Exception( UOSErr_Memory_Address_Error ) ;
        end ;
        exit ;
    end ;

Next we get some parameters and check for privileges that are required for certain operations.

    // Handle UIC...
    if( UIC <> 0 ) then
    begin
        UIC := Get_User_Integer( _Kernel, This_PID, UIC, Status ) ;
        if( Status = UE_Error ) then
        begin
            if( MMC.Last_Error = nil ) then
            begin
                Generate_Exception( UOSErr_Memory_Address_Error ) ;
            end ;
            exit ;
        end ;
    end ;
    if( UIC = 0 ) then
    begin
        UIC := Process.User.UIC ;
    end ;
    if( UIC <> Process.User.UIC ) then // Creating a process for a different UIC
    begin
        if( ( Process.Current_Privileges and ( IMPERSONATE or CMKRNL ) ) = 0 ) then
        begin
            Generate_Exception( SS_NOPRIV ) ;
            exit ;
        end ;

        // Creating a detached process...
        if(
            ( Process.Quotas[ PQL_MAXDETJOBS ] <> 0 )
            and
            ( Process.Usage[ PQL_MAXDETJOBS ] >= Process.Quotas[ PQL_MAXDETJOBS ] )
          ) then
        begin
            Generate_Exception( UOSErr_Exceeded_Process_Limit ) ;
            exit ;
        end ;
    end ;

Next we get the UIC. If it is 0 or points to a value of 0, we set it to the user of the current process. If the UIC is different from the user of the current process, we are creating a detached process. In that case, we need to have the appropriate privileges and not exceed the MAXDETJOBS quota.

    // Create the subprocess...
    Result := Create_Process( UIC, This_PID, Process.Job_Type ) ; // Create process
    if( Result = 0 ) then
    begin
        Generate_Exception( UOSErr_Out_Of_Resources ) ;
        exit ;
    end ;
    New_Process := Get_Process( Result ) ;
    if( pidadr <> 0 ) then
    begin
        Status := Write_User_int64( _Kernel, This_PID, pidadr, Result ) ;
        if( Status = UE_Error ) then
        begin
            if( MMC.Last_Error = nil ) then
            begin
                Generate_Exception( UOSErr_Memory_Address_Error ) ;
            end ;
            exit ;
        end ;
    end ;
    if( UIC <> Process.User.UIC ) then // Creating a detached process...
    begin
        Process.Usage[ PQL_MAXDETJOBS ] := Process.Usage[ PQL_MAXDETJOBS ] + 1 ;
    end ;

Next we call the Create_Process (which we covered in a previous article) which creates the process instance. If an address was provided, we write the new PID to that address. Then we add to the process' MAXDETJOBS usage.

    // Copy symbol table...
    if( ( stsflg and PRC_M_CLONE_SYMBOLS ) <> 0 ) then
    begin
        New_Process.Symbols.Copy_From( Process.Symbols ) ;
    end ;

    // Apply toward quotas...
    if( User.Rec.Quotas.PRCLM <> 0 ) then // There is a limit
    begin
        inc( User.Usage.PRCLM ) ;
    end ; // if( Process.Rec.Quotas.PRCLM <> 0 )
    if( User.Rec.Quotas.MAXJOBS <> 0 ) then
    begin
        inc( User.Usage.MAXJOBS ) ;
    end ;

Next we clone the symbol table, if requested. Then we increase the usages for the PRCLM and MAXJOBS quotas.

    // Handle priority...
    if( BasPri <> 0 ) then
    begin
        Get_User_Data( _Kernel, This_PID, BasPri, 1, BasPri, Status ) ;
        BasPri := BasPri and 255 ;
        if( Status = UE_Error ) then
        begin
            if( MMC.Last_Error = nil ) then
            begin
                Generate_Exception( UOSErr_Memory_Address_Error ) ;
            end ;
            exit ;
        end ;
    end ;
    if( BasPri = 0 ) then // Not specified
    begin
        BasPri := Process.Priority ;
    end ;
    if( BasPri > Process.Priority ) then // Requesting elevated priority
    begin
        if( ( Process.Current_Privileges and ALTPRI ) = 0 ) then // No privilege
        begin
            BasPri := Process.Priority ; // Set to caller's priority
        end ;
    end ;

Now we obtain the base priority. If the address is 0 or the value is 0, we use the priority of the current process. If specified and the priority is less than or equal to the priority of the current process, the new process is given the specified priority. Otherwise, the ALTPRI privilege is required.

    // Set privileges...
    New_Process.Current_Privileges := Process.Current_Privileges ;
    if( prvadr <> 0 ) then
    begin
        New_Process.Current_Privileges := Get_User_Integer( _Kernel, This_PID, prvadr, Status ) ;
        if( ( Process.Current_Privileges and SETPRV ) = 0 ) then // No SETPRV privilege
        begin
            New_Process.Current_Privileges :=
                New_Process.Current_Privileges and Process.Current_Privileges ;
                // Limit to caller's privileges
        end ;
    end ;

Next we set the new process privileges if they were specified. Unless the calling process has the SETPRV privilege, the specified privileges are limited to the current process' privilege mask (via an and operation) without returning an error.

    // Set quotas...
    if( quota <> 0 ) then
    begin
        // Get first block...
        Get_User_Data( _Kernel, This_PID, Quota, sizeof( QuotaB ), QuotaB, Status ) ;
        if( Status = UE_Error ) then
        begin
            if( MMC.Last_Error = nil ) then
            begin
                Generate_Exception( UOSErr_Memory_Address_Error ) ;
            end ;
            exit ;
        end ;
        while( QuotaB.Quota <> PQL_LISTEND ) do // until end of list
        begin
            Value := QuotaB.Value ;
            if( Value <> 0 ) then
            begin
                case QuotaB.Quota of
                    Quota_ASTLM,
                    Quota_BIOLM,
                    Quota_BYTLM,
                    Quota_CPUTIM,
                    Quota_DIOLM,
                    Quota_ENQLM,
                    Quota_FILLM,
                    Quota_MAXACCTJOBS,
                    Quota_MAXJOBS,
                    Quota_PGFLQUOTA,
                    Quota_TQELM,
                    Quota_WSEXTENT,
                    Quota_PRCLM,
                    Quota_THREADLM,
                    PQL_JTQUOTA,
                    PQL_WSDEFAULT,
                    PQL_WSQUOTA :
                        begin
                            if( ( Process.Current_Privileges and ( IMPERSONATE or CMKRNL ))=0 ) then
                            begin
                                // No privileges...
                                if( Value > Process.Quotas[ QuotaB.Quota ] ) then
                                begin
                                    Value := Process.Quotas[ QuotaB.Quota ] ;
                                end ;
                            end ;
                            New_Process.Quotas[ QuotaB.Quota ] := Value ;
                        end ;
                    else
                        begin
                            Generate_Exception( UOSErr_Invalid_Quota_List ) ;
                            exit ;
                        end ;
                end ;
            end ;

            // Get next quota block...
            Get_User_Data( _Kernel, This_PID, Quota, sizeof( QuotaB ), QuotaB, Status ) ;
            if( Status = UE_Error ) then
            begin
                if( MMC.Last_Error = nil ) then
                begin
                    Generate_Exception( UOSErr_Memory_Address_Error ) ;
                end ;
                exit ;
            end ;
        end ; // if( Status = UE_Error )
    end ; // if( quota <> 0 )

If a quota address was specified, we process through the list until we find a PQL_LISTEND item. If the item isn't recognized, we exit with an error. Otherwise, we set the quota. If the process has IMPERSONATE or CMKRNL privileges, we do no checks, since those privileges allow any quota to be exceeded. Otherwise we don't allow the new process to have a higher quota than the current process. Keep in mind that a quota value of 0 means "unlimited".

    // Get image...
    sImage := trim( Get_User_String_As_String( _Kernel, This_PID, Image, Status ) ) ;
    if( Status = UE_Error ) then
    begin
        if( MMC.Last_Error = nil ) then
        begin
            Generate_Exception( UOSErr_Memory_Address_Error ) ;
        end ;
        exit ;
    end ;
    if( sImage = '' ) then // No image specified
    begin
        sImage := Grab_String( New_Process.User.Rec.Shell ) ;
        if( ( sImage = '' ) or ( not FiP.File_Exists( This_PID, sImage ) ) ) then
        begin
            sImage := 'sys$system:ucl.exe' ; // Default to UCL
        end ;
    end ;

Next we get the image for the new process to run. If it is not specified or null, we default it to the default shell for the user.

    sName := trim( Get_User_String_As_String( _Kernel, This_PID, prcnam, Status ) ) ;
    if( SName = '' ) then // No name specified
    begin
        Base_Name := Process.User.Name ;
        if( ( stsflg and PRC_M_NONRANDOM ) <> 0 ) then
        begin
            I := 1 ;
            sName := Base_Name + inttostr( I ) ;
            while( Process_By_Name( sName ) <> nil ) do
            begin
                inc( I ) ;
                sName := Base_Name + '_' + inttostr( I ) ;
            end ;
        end else
        begin
            RNG.Set_X( HAL.Timestamp and $FFFFFFFF ) ;
            sName := Base_Name + '_' + inttostr( RNG.Generate ) ;
            while( Process_By_Name( sName ) <> nil ) do
            begin
                sName := Base_Name + '_' + inttostr( RNG.Generate ) ;
            end ;
        end ;
    end else
    if( Process_By_Name( sName ) <> nil ) then
    begin
        Generate_Exception( UOSErr_Duplicate_Name ) ;
        exit ;
    end ;

Next, we get the specified process name. If one was specified and already exists, we exit with an error. Otherwise, we generate one. As described in the documentation in the previous article, if the PRC_M_NONRANDOM flag is set, we try constructing the name with an incrementing value until an unused name is found. Otherwise, we generate a random number and loop until we come up with an unused process name. Note that VMS generates a hexadecimal value, but we use a decimal value to avoid the overhead of converting it to hexadecimal, since there isn't a good reason to do the convesion (on VMS, it is probably to reduce the maximum length of process names - but UOS has no length limit for process names so it isn't a consideration).

    if( ( stsflg and PRC_M_BATCH ) <> 0 ) then
    begin
        New_Process.Status := New_Process.Status or PCB_V_BATCH ;
    end ;

    _Kernel.USC.Run( New_Process._PID, PChar( sImage ), '', 0, False ) ;
    if( ( stsflg and PRC_M_HIBER ) <> 0 ) then
    begin
        New_Process.State := SCH_C_HIB ;
        New_Process.Status := New_Process.Status or PCB_V_HIBER ;
    end ;
    if( ( stsflg and PRC_M_INTER ) <> 0 ) then
    begin
        New_Process.Status := New_Process.Status or PCB_V_INTER ;
    end ;
    if( ( stsflg and PRC_M_NETWRK ) <> 0 ) then
    begin
        New_Process.Status := New_Process.Status or PCB_V_NETWRK ;
    end ;
    if( ( stsflg and PRC_M_NOACNT ) <> 0 ) then
    begin
        New_Process.Status := New_Process.Status or PCB_V_NOACNT ;
    end ;
    if( ( stsflg and PRC_M_PSWAPM ) <> 0 ) then
    begin
        New_Process.Status := New_Process.Status or PCB_V_PSWAPM ;
    end ;
    Process.Creation_Flags := stsflg ;

Next we convert from CREPRC flags to process state flags. We also store the flags in the Creation_Flags data.

    if( UIC = Process.User.UIC ) then // Not creating a detached process
    begin
        // Assign standard devices...
        if( sInput = '' ) then
        begin
            Resource := TResource( Process.Get_Sys_Input ) ;
            Resource.Attach ;
        end else
        begin
            Resource := FIP.Create_File_Handle( New_Process._PID, PChar( sInput ), 0 ) ;
            if( Resource = nil ) then
            begin
                exit ;
            end ;
        end ;
        _Kernel.USC.Assign_Channel( New_Process._PID, RH_SysInput, int64( Resource ) ) ;

        if( sOutput = '' ) then
        begin
            Resource := TResource( Process.Get_Sys_Output ) ;
            Resource.Attach ;
        end else
        begin
            Resource := FIP.Create_File_Handle( New_Process._PID, PChar( sOutput ), 0 ) ;
            if( Resource = nil ) then
            begin
                exit ;
            end ;
        end ;
        _Kernel.USC.Assign_Channel( New_Process._PID, RH_SysOutput, int64( Resource ) ) ;

        if( sError = '' ) then
        begin
            Resource := TResource( Process.Get_Sys_Error ) ;
            Resource.Attach ;
        end else
        begin
            Resource := FIP.Create_File_Handle( New_Process._PID, PChar( sError ), 0 ) ;
            if( Resource = nil ) then
            begin
                exit ;
            end ;
        end ;
        _Kernel.USC.Assign_Channel( New_Process._PID, RH_SysError, int64( Resource ) ) ;
    end ;
end ; // TUSC.Create_Subprocess

Finally, if we are creating a subprocess, we assign the default sys$input, sys$output, and sys$error channels (detached processes don't have any of them assigned). For each one, we check to see if it was specified. If not, we grab the corresponding resource from the current process, otherwise we get a new file handle for what was specified. Then we assign the channel with the new resource.

type TQuota_Block = packed record
                        Quota : byte ;
                        Value : cardinal ;
                    end ;

This is the quota block definition used above.

                        property Quotas[ Index : integer ] : cardinal
                            read Get_Quota
                            write Set_Quota ;
                        property Usage[ Index : integer ] : cardinal
                            read Get_Usage
                            write Set_Usage ;

These new properties are added to TProcess to make it easier to access quotas and usages, as we've seen in the above code.

function TProcess.Get_Usage( Index : integer ) : cardinal ;

begin
    case Index of
        Quota_ASTLM : Result := _Usage.ASTLM ;
        Quota_BIOLM : Result := _Usage.BIOLM ;
        Quota_BYTLM : Result := _Usage.BYTLM ;
        Quota_CPUTIM : Result := _Usage.CPUTIM ;
        Quota_DIOLM : Result := _Usage.DIOLM ;
        Quota_ENQLM : Result := _Usage.ENQLM ;
        Quota_FILLM : Result := _Usage.FILLM ;
        Quota_MAXACCTJOBS : Result := _Usage.MAXACCTJOBS ;
        Quota_MAXJOBS : Result := _Usage.MAXJOBS ;
        Quota_PGFLQUOTA : Result := _Usage.PGFLQUOTA ;
        Quota_TQELM : Result := _Usage.TQELM ;
        Quota_WSEXTENT : Result := _Usage.WSEXTENT ;
        Quota_PRCLM : Result := _Usage.PRCLM ;
        Quota_THREADLM : Result := _Usage.THREADLM ;
        PQL_JTQUOTA : Result := _Usage.JTQUOTA ;
        PQL_WSDEFAULT : Result := _Usage.WSDEFAULT ;
        PQL_WSQUOTA : Result := _Usage.WSQUO ;
        PQL_MAXDETJOBS : Result := _Usage.MAXDETJOBS ;
        else Result := 0 ;
    end ;
end ;


procedure TProcess.Set_Usage( Index : integer ; Value : cardinal ) ;

begin
    case Index of
        Quota_ASTLM : _Usage.ASTLM := Value ;
        Quota_BIOLM : _Usage.BIOLM := Value ;
        Quota_BYTLM : _Usage.BYTLM := Value ;
        Quota_CPUTIM : _Usage.CPUTIM := Value ;
        Quota_DIOLM : _Usage.DIOLM := Value ;
        Quota_ENQLM : _Usage.ENQLM := Value ;
        Quota_FILLM : _Usage.FILLM := Value ;
        Quota_MAXACCTJOBS : _Usage.MAXACCTJOBS := Value ;
        Quota_MAXJOBS : _Usage.MAXJOBS := Value ;
        Quota_PGFLQUOTA : _Usage.PGFLQUOTA := Value ;
        Quota_TQELM : _Usage.TQELM := Value ;
        Quota_WSEXTENT : _Usage.WSEXTENT := Value ;
        Quota_PRCLM : _Usage.PRCLM := Value ;
        Quota_THREADLM : _Usage.THREADLM := Value ;
        PQL_MAXDETJOBS : _Usage.MAXDETJOBS := Value ;
        PQL_JTQUOTA : _Usage.JTQUOTA := Value ;
        PQL_WSDEFAULT : _Usage.WSDEFAULT := Value ;
        PQL_WSQUOTA : _Usage.WSQUO := Value ;
    end ;
end ;


function TProcess.Get_Quota( Index : integer ) : cardinal ;

begin
    case Index of
        Quota_ASTLM : Result := _Quotas.ASTLM ;
        Quota_BIOLM : Result := _Quotas.BIOLM ;
        Quota_BYTLM : Result := _Quotas.BYTLM ;
        Quota_CPUTIM : Result := _Quotas.CPUTIM ;
        Quota_DIOLM : Result := _Quotas.DIOLM ;
        Quota_ENQLM : Result := _Quotas.ENQLM ;
        Quota_FILLM : Result := _Quotas.FILLM ;
        Quota_MAXACCTJOBS : Result := _Quotas.MAXACCTJOBS ;
        Quota_MAXJOBS : Result := _Quotas.MAXJOBS ;
        Quota_PGFLQUOTA : Result := _Quotas.PGFLQUOTA ;
        Quota_TQELM : Result := _Quotas.TQELM ;
        Quota_WSEXTENT : Result := _Quotas.WSEXTENT ;
        Quota_PRCLM : Result := _Quotas.PRCLM ;
        Quota_THREADLM : Result := _Quotas.THREADLM ;
        PQL_MAXDETJOBS : Result := _Quotas.MAXDETJOBS ;
        PQL_JTQUOTA : Result := _Quotas.JTQUOTA ;
        PQL_WSDEFAULT : Result := _Quotas.WSDEFAULT ;
        PQL_WSQUOTA : Result := _Quotas.WSQUO ;
        else Result := 0 ;
    end ;
end ;


procedure TProcess.Set_Quota( Index : integer ; Value : cardinal ) ;

begin
    case Index of
        Quota_ASTLM : _Quotas.ASTLM := Value ;
        Quota_BIOLM : _Quotas.BIOLM := Value ;
        Quota_BYTLM : _Quotas.BYTLM := Value ;
        Quota_CPUTIM : _Quotas.CPUTIM := Value ;
        Quota_DIOLM : _Quotas.DIOLM := Value ;
        Quota_ENQLM : _Quotas.ENQLM := Value ;
        Quota_FILLM : _Quotas.FILLM := Value ;
        Quota_MAXACCTJOBS : _Quotas.MAXACCTJOBS := Value ;
        Quota_MAXJOBS : _Quotas.MAXJOBS := Value ;
        Quota_PGFLQUOTA : _Quotas.PGFLQUOTA := Value ;
        Quota_TQELM : _Quotas.TQELM := Value ;
        Quota_WSEXTENT : _Quotas.WSEXTENT := Value ;
        Quota_PRCLM : _Quotas.PRCLM := Value ;
        Quota_THREADLM : _Quotas.THREADLM := Value ;
        PQL_MAXDETJOBS : _Usage.MAXDETJOBS := Value ;
        PQL_JTQUOTA : _Quotas.JTQUOTA := Value ;
        PQL_WSDEFAULT : _Quotas.WSDEFAULT := Value ;
        PQL_WSQUOTA : _Quotas.WSQUO := Value ;
    end ;
end ;

These are the property handlers for Usage and Quota.

    Process._User := UIC ;
    Process._Quotas := User.Quotas ;
    Process.Current_Privileges := User.Privileges ;

This code is added to the end of the USC.Force_Login method. This causes the process quotas and privileges to be set to their initial states.

    // Delete all children processes...
    for I := 0 to _Children.Count - 1 do
    begin
        Child := Get_Process( _Children[ I ] ) ;
        Child.Free ;
    end ;

Now that we are dealing with subprocesses, it is time to add general support for them. This code is added to the TProcess destructor. When a process is terminated, we must first terminate all subprocesses by looping through the _Children list and deleting each child process.

    if( Parent = 0 ) then // Job table needed
    begin
        Process._Job_Symbols :=
            TSymbol_Table.Create( '$JOB$' + inttostr( Process._PID ) ) ;
    end else
    begin
        Parent_Process := Get_Process( Parent ) ;
        if( Parent_Process <> nil ) then
        begin
            Parent_Process._Children.Add( Process._PID ) ;
            Process._Job_Symbols := Parent_Process._Job_Symbols ;
        end ;
    end ;

We make a change to the Create_Process function so that if a parent PID is provided, we add the new process to the parent's children list. We also make sure the child process job symbols point to the job's symbol table.

var Current_Users : TList = nil ; 
    // List of current users (those associated with one or more processes)

Since multiple processes can have the same user, and each process can affect the user-level quotas, we need a way to "share" a user object between multipe processes. Each process could have a separate TUser instance, but altering a user quota/usage in one wouldn't alter it in another and then when a process is using a quota in its own TUser instance wouldn't be using the current quota values. So we want the same TUser instance shared with all the processes for that user. This list is used to keep a single instance of each user currently associated with one or more processes.

    _Kernel.Lock( Spinlock_Current_Users ) ;
    User.Decrement_Count ;
    if( User.Count = 0 ) then
    begin
        Current_Users.Remove( User ) ;
    end ;
    _Kernel.Unlock( Spinlock_Current_Users ) ;

At the end of the TProcess destructor, we decrement the process count in TUser (which is a count specifically in the class for this purpose). If the count reaches 0, no more processes are associated with the user and we delete the user instance from the list. We surround this operation with spinlock protection.

    if( Current_Users = nil ) then
    begin
        Current_Users := TList.Create ;
    end ;
    _Kernel.Lock( Spinlock_Current_Users ) ;
    I := Current_User_IDs.ItemIndex( _User ) ;
    if( I = -1 ) then // User not loaded...
    begin
        I := Current_Users.Count ;
        Current_Users.Add( Get_User( _User ) ) ;
    end ;
    .
    .
    .
    _Kernel.Unlock( Spinlock_Current_Users ) ;

This code is added to the start of the TProcess.User to initialize the list, if needed, and add the process' user to the list if not already present. At the end of the routine, we call User.Increment_Count and release the spinlock.

var System_Locks : int64 = 0 ;

procedure TKernel.Lock( ID : integer ) ;

begin
    HAL.Test_And_Set( int64( @System_Locks ), ID - 1 ) ;
end ;


procedure TKernel.Unlock( ID : integer ) ;

begin
    HAL.Clear_Flag( int64( @System_Locks ), ID - 1 ) ;
end ;

In one previous article, we looked at code that used a spinlock. It was handled by the SSC component and the spinlock was identified by a string. Upon further reflection, I decided better of it. String operations are relatively expensive operations on any CPU, and we want to minimize the time surrounding the setting, resetting, and checking of spinlocks since the whole point of locks is to handle contention for resources. The more overhead that is associated with locks, the slower the system becomes when contention occurs. Thus, we use an integer identifier instead of a string.

Moving the lock/unlock from the SSC to the kernel was more of a philosophical change. The kernel is the central part of the executive and since all components may want to use spinlocks, it seemed to make more sense to me to have it in the kernel. But it also improves performance a tiny bit. All executive components have a pointer to the kernel instance, but to get to the SSC to handle spinlocks means that we have to request the SSC instance from the kernel. This change eliminates that extra step.

The actual code is very simple, as it only makes calls to the HAL. This is necessary since the HAL is intimately familiar with the hardware and knows the best way to handle the operation atomically. For instance, on Intel CPUs, a LOCK instruction prefix could be used. On other CPUs, different mechanisms may need to be used. But the point is that these details are left to the HAL rather than the kernel.

procedure TSymbol_Table.Copy_From( Source : TUOS_Symbol_Table ) ;

var I, Index, Loop : integer ;
    New_Symbols, Symbols : TStringList ;
    Src : TSymbol_Table ;
    This_Symbol : TSymbol ;

begin
    if( Source = nil ) then
    begin
        exit ;
    end ;
    Src := TSymbol_Table( Source ) ;
    for Loop := 0 to Src.List.Count - 1 do
    begin
        Symbols := TStringList( Src.List.Objects[ Loop ] ) ;
        New_Symbols := TStringList.Create ;
        New_Symbols.Assign( Symbols ) ;
        List.AddObject( Src.List[ Loop ], New_Symbols ) ;
    end ; // for Loop := 0 to Source.List.Count - 1
end ; // TSymbol_Table.Copy_From

Finally, we add this method to the TSymbol_Table class to handle the quick copy of another string table to the current instance. If the source table is nil, we exit immediately. Otherwise, we loop through the source table's list, creating new string lists and copying from the source.

In the next article, we will start looking at the COPY CUSP.