In the previous article, we referenced a couple new system services. In this article we will cover them. Here's the user documentation for DELPRC:

Mnuemonic

Meaning

DELPRC_M_EXIT

Exit handlers are called, according to mode. If no exit handler has been specified, the process is immediately terminated.

DELPROC_M_MODE

Indicates the ring in which to call the exit handler.

DELPROC_M_NOEXIT

Disables calling any exit handler.

Note that this service makes use of exit procedures, which we won't be covering until the future (at which time we will revisit some of this code).

function SYS_DELPRC( pidadr : int64 = 0 ; prcnam : int64 = 0 ; flags : int64 = 0 ) : int64 ;

var SRB : PSRB ;
    Status : int64 ;
    SysRequest : TS1I2_Request ;

begin
    SRB := PSRB( pointer( Prcnam ) ) ;
    fillchar( SysRequest, sizeof( SysRequest ), 0 ) ;
    Status := 0 ;
    SysRequest.Request.Subsystem :=  UOS_Subsystem_USC ;
    SysRequest.Request.Request := UOS_USC_DELPRC ;
    SysRequest.Request.Length := sizeof( SysRequest ) - sizeof( Sysrequest.Request ) ;
    SysRequest.Request.Status := integer( @Status ) ;
    if( SRB <> nil ) then
    begin
        SysRequest.SRB.Buffer := SRB.Buffer ;
        SysRequest.SRB.Length := SRB.Length ;
    end ;
    SysRequest.Integer1 := PIDAdr ;
    SysRequest.Integer2 := Flags ;

    Call_To_Ring0( integer( @SysRequest ) ) ;

    Result := Status ;
end ;

        UOS_USC_DELPRC:
            begin
                UE := Enter_System_Call( Request, SReq, PID, MMC, 
                    sizeof( TS1I2_Request ) - sizeof( SReq ), Address ) ;
                if( UE <> nil ) then
                begin
                    Set_Last_Error( UE ) ;
                    exit ;
                end ;
                try
                    S1I2_Request := PS1I2_Request( Address ) ;
                    if( Delete_Process( S1I2_Request.Integer1, S1I2_Request.SRB, S1I2_Request.Integer2 ) = 
                        0 ) then
                    begin
                        Kernel.Kill_Process( PID ) ;
                    end ;
                finally
                    Exit_System_Call( Request, PID, MMC, sizeof( TS1I2_Request ) - sizeof( SReq ) ) ;
                end ;
            end ;

procedure TUSC.Delete_Process( PIDAdr : int64 ; PrcName : TSRB ; Flags : int64 ) ;

var I : integer ;
    IOSB : TIOSB ;
    PID, Flag, TargetPID : int64 ;
    Name : string ;
    Process, Target_Process : TProcess ;
    Status : longint ;

begin
    // Setup...
    PID := Kernel.PID ;
    TargetPID := 0 ;
    Name := '' ;

    // Get parameters...
    if( PIDAdr <> 0 ) then // PID Address specified
    begin
        TargetPID := Get_User_Integer( Kernel, PID, pidadr, Status ) ;
        if( Status = UE_Error ) then
        begin
            IOSB.r_io_64.w_status := Status ;
            if( MMC.Last_Error = nil ) then
            begin
                Generate_Exception( UOSErr_Memory_Address_Error ) ;
            end ;
            exit ;
        end ;
        if( TargetPID = 0 ) then
        begin
            TargetPID := PID ;
        end ;
    end ; // if( PIDAdr <> 0 )
    if( ( TargetPID = 0 ) and ( PrcName.Length > 0 ) ) then
    begin
        Name := Get_String( Kernel, PID, PrcName, Status ) ;
        if( Status = UE_Error ) then
        begin
            IOSB.r_io_64.w_status := Status ;
            if( MMC.Last_Error = nil ) then
            begin
                Generate_Exception( UOSErr_Memory_Address_Error ) ;
            end ;
            exit ;
        end ;
        //TODO:Handle process names with node prefix on clusters
        Name := lowercase( Name ) ;
        for I := 0 to Processes.Count - 1 do
        begin
            Process := TProcess( Processes[ I ] ) ;
            if( Process <> nil ) then
            begin
                if( Name = lowercase( Process.Name ) ) then
                begin
                    TargetPID := Process._PID ;
                    break ;
                end ; // if( prcnam = lowercase( Process.Name ) )
            end ; // if( Process <> nil )
        end ; // for I := 0 to Processes.Count - 1
        if( TargetPID = 0 ) then // Named process not found
        begin
            Generate_Exception( UOSErr_Nonexistent_Process ) ;
            exit ;
        end ;
    end ; // if( ( PrcName <> 0 ) and ( TargetPID = 0 ) )
    if( Flags <> 0 ) then // Flags Address specified
    begin
        Flag := Get_User_Integer( Kernel, PID, Flags, Status ) ;
        if( Status = UE_Error ) then
        begin
            IOSB.r_io_64.w_status := Status ;
            if( MMC.Last_Error = nil ) then
            begin
                Generate_Exception( UOSErr_Memory_Address_Error ) ;
            end ;
            exit ;
        end ;
    end ; // if( PIDAdr <> 0 )

    // Get process...
    if( TargetPID = 0 ) then
    begin
        TargetPID := PID ;
    end ;
    Target_Process := Get_Process( TargetPID ) ;
    if( Target_Process = nil ) then
    begin
        Generate_Exception( UOSErr_Nonexistent_Process ) ;
        exit ;
    end ;

    // Validate privileges if differnet process...
    if( ( TargetPID <> PID ) and ( PID <> 0 ) ) then
    begin
        // Different process...
        Process := Get_Process( PID ) ;
        if( Process._User <> Target_Process._User ) then // Different user
        begin
            if( ( Process.Current_Privileges and WORLD ) = 0 ) then
            begin
                if( ( Process.Current_Privileges and GROUP ) = 0 ) then
                begin
                    //TODO
                    Set_Last_Error( Create_Error( UOSErr_Protection_Violation ) ) ;
                    exit ;
                end ;
            end ; // if( ( Process.Current_Privileges and WORLD ) = 0 )
        end ; // if( Process._User <> Target_Process._User )
    end ; // if( ( TargetPID <> Kernel.PID ) and ( Kernel.PID <> 0 ) )

    Terminate_Image( TargetPID ) ;
    Target_Process.Free ;
end ; // TUSC.Delete_Process

The call to OS^.Command_Line makes a call to LIB_GET_FOREIGN. Here is the user documentation:

The LIB_GET_FOREIGN routine retrieves the command line used to invoke the currently running image. This is named after the VMS servive; the term "foreign" has to do with the way VMS handles command lines. UOS does things slightly differently, but we keep the name for compatibility sake. Here is the user documentation:

Returns the text of the command line that invoked the current program, minus the program's name.

        UOS_FIP_Get_Foreign:
            begin
                UE := Enter_System_Call( Request, SReq, PID, MMC, 
                    sizeof( TS2I2_Request ) - sizeof( SReq ), Address ) ;
                if( UE <> nil ) then
                begin
                    Set_Last_Error( UE ) ;
                    exit ;
                end ;
                try
                    S2I2_Request := PS2I2_Request( Address ) ;

                    // Read input into user's buffer...
                    IOSB.r_io_64.w_status := Get_Foreign( S2I2_Request.SRB1, S2I2_Request.SRB2,
                        S2I2_Request.Integer1, S2I2_Request.Integer2 ) ;
                    Write_User_int64( Kernel, PID, S2I2_Request.Request.Status, IOSB.r_io_64.w_status ) ;
                finally
                    Exit_System_Call( integer( S2I2_Request ), PID, MMC, 
                        sizeof( TS2I2_Request ) - sizeof( SReq ) ) ;
                end ;
            end ;

function TUOS_FiP.Get_Foreign( Res, Prompt : TSRB ; Len, Flags : int64 ) : int64 ;

var Flag, R : int64 ;
    IOSB : TIOSB ;
    PID : TPID ;
    Prmpt, S : string ;
    Status : longint ;

begin
    // Setup...
    Result := 0 ;
    PID := Kernel.PID ;

    // Get parameters...
    Flag := 0 ;
    if( Flags <> 0 ) then
    begin
        Get_User_Integer( Kernel, PID, Flag, Status ) ;
        if( Status <> 0 ) then
        begin
            Result := Status ;
            exit ;
        end ;
    end ;
    Prmpt := Get_String( Kernel, PID, Prompt, Status ) ;

    // Get command line...
    S := USC.Command_Line( PID ) ;
    if(
        ( Prmpt <> '' ) // Prompt specified
        and
        ( ( ( Flag and 1 ) = 1 ) or ( S = '' ) ) // No command line or force prompting
      ) then // Prompt the user
    begin
        // Do IO_READPROMPT
        QIO( 0, RH_SysInput, IO_READPROMPT, IOSB, 0, 0,
            Res.Buffer, Res.Length, 0, 0, Prompt.Buffer, Prompt.Length ) ;
        Result := IOSB.r_io_64.w_status ;
        if( ( Result = 0 ) and ( Len <> 0 ) ) then
        begin
            Result := Write_User_int64( Kernel, PID, Len, IOSB.r_io_64.r_bcnt_32.l_bcnt ) ;
        end ;
        exit ;
    end ;

    // Return the command line...
    if( Res.Length < length( S ) ) then
    begin
        setlength( S, Res.Length ) ;
        Result := UOSErr_Buffer_Overflow ;
    end ;
    R := Set_User_String( Kernel, PID, Res, S ) ;
    if( R = UE_Error ) then
    begin
        Result := R ;
        exit ;
    end ;
    if( Len <> 0 ) then
    begin
        R := Write_User_int64( Kernel, PID, Len, Length( S ) ) ;
        if( R = UE_Error ) then
        begin
            Result := R ;
            exit ;
        end ;
    end ;
end ; // TUOS_FiP.Get_Foreign

function TUSC.Command_Line( PID : TPID ) : string ;

var P : TProcess ;

begin
    P := Get_Process( PID ) ;
    if( P = nil ) then // Process doesn't exist
    begin
        Result := '' ;
        exit ;
    end ;
    Result := P.Command_Line ;
end ;

In the next few articles, we will cover the process of logging in, and related code.