CREATESTREAM, STREAMNAME, and Set_Contiguous

In this article we will we look at some more changes made to support COPY, including new system services.

                                 function Write_Stream( Stream, Position, Size,
                                     Src : int64 ) : int64 ; override ;
                                 function Create_Stream( Value : PChar ) : int64 ;
                                     override ;
                                 function Get_Privileges : int64 ; override ;
                                 procedure Set_Privileges( Value : int64 ) ;
                                     override ;
                                 function Stream_Name( Index : int64 ) : PChar ;
                                     override ;
                                 function Last_Access : int64 ; override ;
                                 function Last_Backup : int64 ; override ;
                                 function Creation : int64 ; override ;
                                 function Expiration : int64 ; override ;
                                 function Last_Modified : int64 ; override ;
                                 function Get_EOF : int64 ; override ;
                                 function Get_Owner : int64 ; override ;
                                 procedure Set_Owner( Value : int64 ) ;
                                     override ;
                                 function Get_Protection : int64 ; override ;
                                 procedure Set_Protection( Value : int64 ) ;
                                     override ;
                                 function Get_Symlink : boolean ; override ;
                                 procedure Set_Symlink( Value : boolean ) ;
                                     override ;

These methods are added to the TUOS_File_Wrapper class to hide the gory implementation details.

function TUOS_File_Wrapper.Write_Stream( Stream, Position, Size,
    Src : int64 ) : int64 ;

var RAB : TRAB ;

begin
    fillchar( RAB, sizeof( RAB ), 0 ) ;
    RAB.RAB_Size := sizeof( RAB ) ;
    RAB.RAB_L_BKT := Position ;
    RAB.RAB_W_ISI := FAB.FAB_Q_HANDLE ;
    RAB.RAB_L_UBF	:= Src ; // User buffer address
    RAB.RAB_W_USZ	:= Size ; // Bytes to write
    RAB.RAB_Data_Stream := Stream ;
    SYS_WRITE( int64( @RAB ), 0, 0 ) ;
    Result := RAB.RAB_W_RSZ ; // Bytes actually written
end ;

This is the compliment to the Read_Stream method.

function TUOS_File_Wrapper.Create_Stream( Value : PChar ) : int64 ;

var S : string ;
    SRB : TSRB ;

begin
    Result := 0 ;
    S := Value ;
    if( S = '' ) then
    begin
        exit ;
    end ;
    Set_String( S, SRB ) ;
    SYS_CREATESTREAM( int64( @FAB ), int64( @SRB ), int64( @Result ) ) ;
end ;


function TUOS_File_Wrapper.Stream_Name( Index : int64 ) : PChar ;

var Len : int64 ;

begin
    Len := 256 ;
    setlength( Temp, Len ) ;
    SYS_GETSTREAMNAME( int64( @FAB ), int64( @Index ), int64( PChar( Temp ) ), int64( @Len ) ) ;
    setlength( Temp, Len ) ;
    Result := PChar( Temp ) ;
end ;


function TUOS_File_Wrapper.Get_Privileges : int64 ;

begin
    Result := XABFHC.XAB_Q_PRIV ;
end ;


procedure TUOS_File_Wrapper.Set_Privileges( Value : int64 ) ;

begin
    XABFHC.XAB_Q_PRIV := Value ;
end ;

The first two of of these methods are wrappers for new system service calls. The second two are property handlers that wrap the privilege field of the XABFHC block.

function TUOS_File_Wrapper.Creation : int64 ;

begin
    Result := XABDAT.XAB_Q_CDT ;
end ;


function TUOS_File_Wrapper.Expiration : int64 ;

begin
    Result := XABDAT.XAB_Q_EDT ;
end ;


function TUOS_File_Wrapper.Last_Modified : int64 ;

begin
    Result := XABDAT.XAB_Q_RDT ;
end ;


function TUOS_File_Wrapper.Get_EOF : int64 ;

begin
    Result := XABFHC.XAB_Q_EOF ;
end ;


function TUOS_File_Wrapper.Get_Owner : int64 ;

begin
    Result := XABPRO.XAB_L_UIC ;
end ;


procedure TUOS_File_Wrapper.Set_Owner( Value : int64 ) ;

begin
    XABPRO.XAB_L_UIC := Value ;
end ;


function TUOS_File_Wrapper.Get_Protection : int64 ;

begin
    Result := XABPRO.XAB_W_PRO ;
end ;


procedure TUOS_File_Wrapper.Set_Protection( Value : int64 ) ;

begin
    XABPRO.XAB_W_PRO := Value ;
end ;


function TUOS_File_Wrapper.Get_Symlink : boolean ;

begin
    Result := ( XABFHC.XAB_W_FLG and FAF_LINK ) <> 0 ;
end ;


procedure TUOS_File_Wrapper.Set_Symlink( Value : boolean ) ;

begin
    if( Value ) then
    begin
        XABFHC.XAB_W_FLG := XABFHC.XAB_W_FLG or FAF_LINK ;
    end else
    begin
        XABFHC.XAB_W_FLG := XABFHC.XAB_W_FLG and ( not FAF_LINK ) ;
    end ;
end 


function TUOS_File_Wrapper.Get_Contiguous : boolean ;

begin
    Result := ( FAB.FAB_L_FOP and FAB_V_CTG ) <> 0 ;
end ;


procedure TUOS_File_Wrapper.Set_Contiguous( Value : boolean ) ;

var SRB : TSRB ;
    V : int64 ;

begin
    Set_String( _Name, SRB ) ;
    V := ord( Value ) ;
    SYS_Set_Contiguous( int64( @SRB ), int64( @V ) ) ;
end ;

These methods simplify access to date, protection, and owner fields for the file. The last four methods are property handlers for access to the LINK and contiguous flags. You may note that after changing the internal structures (except for the contiguous state), no system calls are made to implement the changes. The reason for this is that these values are saved when the file is closed.

    // Handle special cases...
    if( copy( S, 1, 5 ) = 'today' ) then
    begin
        TS := Today_Timestamp ;
        S := trim( copy( S, 6, length( S ) ) ) ;
        DTSS.Flags := 0 ; // Clear flags
    end else
    if( copy( S, 1, 8 ) = 'tomorrow' ) then
    begin
        TS := Today_Timestamp + One_Day ;
        S := trim( copy( S, 9, length( S ) ) ) ;
        DTSS.Flags := 0 ; // Clear flags
    end else
    if( copy( S, 1, 9 ) = 'yesterday' ) then
    begin
        TS := Today_Timestamp - One_Day ;
        S := trim( copy( S, 10, length( S ) ) ) ;
        DTSS.Flags := 0 ; // Clear flags
    end ;
    if( DTSS.Flags = 0 ) then // Handle special case
    begin
        Parse_Sirius_Timestamp( TS, Y, Mo, D, H, M, Sec, NS ) ;
        DTSS.Year := Y ;
        DTSS.Month := Mo ;
        DTSS.Day := D ;
    end ;

This chunk of code is inserted into the LIB_Parse_Date_Time function in Starlet to support date/time specifications of "TODAY", "YESTERDAY", and "TOMORROW". This was added to support switches in COPY, but because it is in Starlet, the feature is supported for any date/time specifications passed to this function.

SYS_GETSTREAMNAME

Returns the name of the given stream index.

Format

SYS_GETSTREAMNAME FAB Idx Dst Len

Arguments

FAB
An address of a File Access Block structure for an open file.

Idx
An address of a 64-bit integer indicating the stream index for which to return a name.

Dst
An address of a buffer where to write the name.

Len
An address of a 64-bit integer value indicating the maximum length of the receiving buffer, in bytes. Upon return, the actual length of data returned is written to this address. The name returned for stream index 0 (the default data stream), is a null string.

Description

This service returns the name of the stream associated with the passed index in an open file. The file must be currently open, and the index must match a valid ancillary data stream index. If the length of the stream name exceeds the passed buffer length, the result is trimmed to that length. The returned length will always be the number of bytes actually written to the result buffer, which may be less than the length of the stream name.

Condition codes returned

RMS_FAB The FAB block has an invalid layout.
RMS_BLN The FAB block has an invalid length.
UOSErr_Invalid_Handle The FAB does not contain an valid file handle.
LIB_INVOPER Operation attempted on a non-file resource.
SS_ACCVIO Memory access violation.
SS_NORMAL Normal completion of service.

SYS_CREATESTREAM

Creates an ancillary data stream on an open file.

Format

SYS_CREATESTREAM FAB Name Res

Arguments

FAB
An address of a File Access Block structure for an open file.

Name
An address of a SRB that points to the name for the newly created stream. Leading and trailing spaces are trimmed from this name. The name may not be null, and it must follow the rules for file names on the file system where the file is located. If a stream of the same name exists (case is not significant), an error occurs.

Res
An address of a 64-bit integer where the stream index of the newly created stream is to be written. If an error occurs, this value will be 0.

Description

This service creates an ancillary data stream for a file. The file must be currently open.

Condition codes returned

SS_NORMAL Normal completion of service.
RMS_FAB The FAB block has an invalid layout.
RMS_BLN The FAB block has an invalid length.
UOSErr_Invalid_Handle The FAB does not contain an valid file handle.
LIB_INVOPER Operation attempted on a non-file resource.
SS_ACCVIO Memory access violation.
SS_DUPLNAM A stream with that name already exists.
SS_NOPRIV User does not have privileges or permission to modify the file.
SS_EXQUOTA Operation cannot complete due to quotas.
UOSErr_Invalid_Resource_Name The name is null or contains characters that are not valid for a filename on the file system.

SYS_Set_Contiguous

Sets an existing file to contiguous or non-contiguous layout on a store.

Format

SYS_Set_Contiguous Name Value

Arguments

Name
An address of a SRB that points to the name of the file to affect.

Value
An address of a 64-bit integer that is 0 to set the file to non-contiguous or 1 to set the file to contiguous.

Description

This service alters the contiguous state of the specified existing file. When converting from non-contiguous to contiguous, there must be a contiguous area on the store large enough to contain the entire file. When converting from contiguous to non-contiguous, there must be enough non-contiguous space on the store to contain the allocation chain for the file. If there is insufficient space on the store to perform this operation, the service fails without returning an error. Files on sequential stores are always inherently contiguous and are unaffected by this service.

Condition codes returned

UOSErr_Device_Not_File_Structured A non-file was specified.
SS_NOSUCHNODE An invalid node was specified.
SS_ACCVIO Memory access violation.
SS_NORMAL Normal completion of service.

function SYS_GETSTREAMNAME( FAB, Idx, Dst, Len : int64 ) : int64 ;

var Status : int64 ;
    SysRequest : TInteger4_Request ;

begin
    if( FAB = 0 ) then
    begin
        Result := RMS_FAB ;
        exit ;
    end ;
    Status := 0 ;
    fillchar( SysRequest, sizeof( SysRequest ), 0 ) ;
    SysRequest.Request.Subsystem :=  UOS_Subsystem_FIP ;
    SysRequest.Request.Request := UOS_FIP_Get_Stream_Name ;
    SysRequest.Request.Length := sizeof( SysRequest ) - sizeof( TSystem_Request ) ;
    SysRequest.Request.Status := integer( @Status ) ;
    SysRequest.Int1 := FAB ;
    SysRequest.Int2 := Idx ;
    SysRequest.Int3 := Dst ;
    SysRequest.Int4 := Len ;

    Call_To_Ring0( integer( @SysRequest ) ) ;
    Result := Status ;
end ;


function SYS_CREATESTREAM( FAB, Name, Res : int64 ) : int64 ;

var Status : int64 ;
    SysRequest : TS1I2_Request ;

begin
    Status := 0 ;
    fillchar( SysRequest, sizeof( SysRequest ), 0 ) ;
    SysRequest.Request.Subsystem :=  UOS_Subsystem_FIP ;
    SysRequest.Request.Request := UOS_FIP_Create_Stream ;
    SysRequest.Request.Length := sizeof( SysRequest ) - sizeof( TSystem_Request ) ;
    SysRequest.Request.Status := integer( @Status ) ;
    SysRequest.Integer1 := FAB ;
    SysRequest.Integer2 := Res ;
    SysRequest.SRB := PSRB( Name )^ ;

    Call_To_Ring0( integer( @SysRequest ) ) ;
    Result := Status ;
end ;


function SYS_Set_Contiguous( SRB, Value : int64 ) : int64 ;

var Status : int64 ;
    SysRequest : TS1I1_Request ;

begin
    fillchar( SysRequest, sizeof( SysRequest ), 0 ) ;
    Status := 0 ;
    SysRequest.Request.Subsystem :=  UOS_Subsystem_FIP ;
    SysRequest.Request.Request := UOS_FIP_Set_Contiguous ;
    SysRequest.Request.Length := sizeof( SysRequest ) - sizeof( Sysrequest.Request ) ;
    SysRequest.Request.Status := integer( @Status ) ;
    SysRequest.SRB := PSRB( SRB )^ ;
    SysRequest.Integer1 := Value ;

    Call_To_Ring0( integer( @SysRequest ) ) ;

    Result := Status ;
end ;

These three routines are added to the SYS unit to wrap the calls to the executive.

        UOS_FIP_Get_Stream_Name:
            begin
                UE := Enter_System_Call( Request, SReq, PID, MMC,
                    sizeof( Integer4_Request ) - sizeof( SReq ), Address ) ;
                if( UE <> nil ) then
                begin
                    Set_Last_Error( UE ) ;
                    exit ;
                end ;
                try
                    Integer4_Request := PInteger4_Request( Address ) ;

                    Status := File_Get_Stream_Name( Integer4_Request.Int1,
                        Integer4_Request.Int2, Integer4_Request.Int3,
                        Integer4_Request.Int4, IOSB ) ;
                    Write_User_int64( Kernel, PID, Integer4_Request.Request.Status,
                        IOSB.r_io_64.r_bcnt_32.l_bcnt ) ;
                finally
                    Exit_System_Call( integer( Integer4_Request ), PID, MMC,
                        sizeof( Integer4_Request ) - sizeof( SReq ) ) ;
                end ;
            end ;
        UOS_FIP_Create_Stream:
            begin
                UE := Enter_System_Call( Request, SReq, PID, MMC,
                    sizeof( S1I2_Request ) - sizeof( SReq ), Address ) ;
                if( UE <> nil ) then
                begin
                    Set_Last_Error( UE ) ;
                    exit ;
                end ;
                try
                    S1I2_Request := PS1I2_Request( Address ) ;

                    Status := File_Create_Stream( S1I2_Request.Integer1,
                        S1I2_Request.SRB, S1I2_Request.Integer2, IOSB ) ;
                    Write_User_int64( Kernel, PID, S1I2_Request.Request.Status,
                        IOSB.r_io_64.r_bcnt_32.l_bcnt ) ;
                finally
                    Exit_System_Call( integer( S1I2_Request ), PID, MMC,
                        sizeof( S1I2_Request ) - sizeof( SReq ) ) ;
                end ;
            end ;
        UOS_FIP_Set_Contiguous:
            begin
                UE := Enter_System_Call( Request, SReq, PID, MMC,
                    sizeof( S1I1_Request ) - sizeof( SReq ), Address ) ;
                if( UE <> nil ) then
                begin
                    Set_Last_Error( UE ) ;
                    exit ;
                end ;
                try
                    S1I1_Request := PS1I1_Request( Address ) ;

                    Status := Set_Contiguous( S1I1_Request.SRB, S1I1_Request.Integer1, IOSB ) ;
                    Write_User_int64( Kernel, PID, S1I1_Request.Request.Status,
                        IOSB.r_io_64.r_bcnt_32.l_bcnt ) ;
                finally
                    Exit_System_Call( integer( S1I1_Request ), PID, MMC,
                        sizeof( S1I1_Request ) - sizeof( SReq ) ) ;
                end ;
            end ;

This code is added to the FIP's API method to handle these new services. This is similar to the rest of the code in the method.

function TUOS_FiP.File_Get_Stream_Name( _FAB, _Stream, Dst, Len : int64 ;
    var IOSB : TIOSB ) : int64 ;

var FAB : TFAB ;
    I : integer ;
    Index, L : int64 ;
    PID : TPID ;
    Resource : TResource ;
    S : string ;
    SI : int64 ;
    SRB : TSRB ;
    Status : longint ;

begin
    // Initial check...
    Result := 0 ;
    if( _FAB = 0 ) then
    begin
        Result := RMS_FAB ;
        IOSB.r_io_64.w_status := Result ;
        exit ;
    end ;

    // Get the FAB...
    fillchar( FAB, sizeof( FAB ), 0 ) ;
    PID := Kernel.PID ;
    Get_User_Data( Kernel, PID, _FAB, 2, FAB, IOSB.r_io_64.w_status ) ; // Get FAB length
    if( IOSB.r_io_64.w_status <> 0 ) then
    begin
        Result := IOSB.r_io_64.w_status ;
        exit ;
    end ;
    if( FAB.FAB_B_BLN > sizeof( FAB ) ) then
    begin
        FAB.FAB_B_BLN := sizeof( FAB ) ;
    end ;
    Get_User_Data( Kernel, PID, _FAB, FAB.FAB_B_BLN, FAB, IOSB.r_io_64.w_status ) ; // Get FAB
    if( IOSB.r_io_64.w_status <> 0 ) then
    begin
        Result := IOSB.r_io_64.w_status ;
        exit ;
    end ;

    // Get stream index and result length...
    Index := Get_User_Integer( Kernel, PID, _Stream, I ) ;
    if( I <> 0 ) then
    begin
        Result := I ;
        exit ;
    end ;
    if( Len <> 0 ) then
    begin
        L := Get_User_Integer( Kernel, PID, Len, I ) ;
        if( I <> 0 ) then
        begin
            Result := I ;
            exit ;
        end ;
    end ;

    // Get file...
    Resource := TResource( FAB.FAB_Q_HANDLE ) ;
    if( Resource._File = nil ) then // Only files have streams
    begin
        Result := UOSErr_Invalid_Operation ;
        Set_Last_Error( Create_Error( Result ) ) ;
        exit ;
    end ;

This method handles retrieving a stream name. First we initialize some variables and then we read all the parameters from the user space.

    // Get stream name...
    S := Resource._File.Stream_Name( Index ) ;
    if( length( S ) > L ) then
    begin
        setlength( S, L ) ;
    end ;

    // Write stream name to user address space...
    if( Dst <> 0 ) then
    begin
        Status := Write_User( Kernel, PID, Dst, length( S ), PChar( S )[ 0 ] ) ;
        if( Status <> 0 ) then
        begin
            IOSB.r_io_64.w_status := Status ;
            Generate_Exception( Status ) ;
            Result := IOSB.r_io_64.w_status ;
            exit ;
        end ;
    end ;

    // Write result length
    if( Len <> 0 ) then
    begin
        Status := Write_User_int64( Kernel, PID, Len, length( S ) ) ;
        if( Status <> 0 ) then
        begin
            IOSB.r_io_64.w_status := Status ;
        end ;
    end ;
end ;

Next we ask the file for the stream name, trim the length if it is longer than the passed length, then write the name to the user's buffer, and update the length to match how many bytes are written to the length.

function TUOS_FiP.File_Create_Stream( FAB : int64 ; SRB : TSRB ; Res : int64 ;
    IOSB : TIOSB ) : int64 ;

var _FAB : TFAB ;
    Index : int64 ;
    Name : string ;
    Resource : TResource ;
    Status : integer ;

begin
    // Get parameters and verify them...
    if( FAB = 0 ) then // No FAB provided
    begin
        Result := RMS_FAB ;
        Generate_Exception( Result ) ;
        exit ;
    end ;
    Result := Get_FAB( Kernel, Kernel.PID, FAB, _FAB ) ;
    if( Result <> 0 ) then
    begin
        Generate_Exception( Result ) ;
        exit ;
    end ;
    if( _FAB.FAB_B_BID <> FAB_C_BID ) then
    begin
        Result := RMS_FAB ;
        Generate_Exception( Result ) ;
        exit ;
    end ;
    if( _FAB.FAB_B_BLN < sizeof( _FAB ) ) then
    begin
        Result := RMS_BLN ;
        Generate_Exception( Result ) ;
        exit ;
    end ;
    if( _FAB.FAB_Q_Handle = 0 ) then
    begin
        Result := UOSErr_Invalid_Handle ;
        Generate_Exception( Result ) ;
        exit ;
    end ;
    if( not USC.Valid_Handle( Kernel.PID, _FAB.FAB_Q_Handle ) ) then
    begin
        IOSB.r_io_64.w_status := UOSErr_Invalid_Handle ;
        exit ;
    end ;
    Resource := TResource( _FAB.FAB_Q_Handle ) ;

    Name := Get_String( Kernel, Kernel.PID, SRB, Status ) ;
    if( Status <> 0 ) then
    begin
        IOSB.r_io_64.w_status := Status ;
        Generate_Exception( Status ) ;
        Result := IOSB.r_io_64.w_status ;
        exit ;
    end ;

This new method is used to create a new ancillary data stream in a file. First we get the parameters. If there are problems, we return the error.

    // Create the index
    Index := Resource._File.Create_Stream( PChar( Name ) ) ;

    // Write the result...
    if( Res <> 0 ) then
    begin
        Result := Write_User_int64( Kernel, Kernel.PID, Res, Index ) ;
        if( Result = UE_Error ) then
        begin
            if( MMC.Last_Error = nil ) then
            begin
                Result := UOSErr_Memory_Address_Error ;
                Generate_Exception( Result ) ;
            end ;
            exit ;
        end ;
    end ;
end ; // TUOS_FiP.File_Create_Stream

Next we tell the file to create the stream and then return the index.

function TUOS_FiP.Set_Contiguous( SRB : TSRB ; Value : int64 ;
    var IOSB : TIOSB ) : int64 ;

var Name : string ;
    Contiguous : boolean ;
    H : TResource ;
    Node, Access, Secondary_Node, SDevice, Path, FName, Extension, Version : string ;
    Status : integer ;
    US : TUOS_String ;

begin
    // Setup and get parameters...
    Contiguous := False ;
    if( Value <> 0 ) then
    begin
        Get_User_Integer( Kernel, Kernel.PID, Value, Status ) ;
        if( Status <> 0 ) then
        begin
            Result := Status ;
            exit ;
        end ;
    end ;
    US := Get_User_String( Kernel, Kernel.PID, SRB, IOSB.r_io_64.w_status ) ;
    if( IOSB.r_io_64.w_status = UE_Error ) then
    begin
        Result := IOSB.r_io_64.w_status ;
        exit ;
    end ;
    Name := US.Contents ;
    US.Free ;

This method changes the contiguous state of an existing file. First we get the parameters.

    // Open file...
    Parse_Filename( Name, Node, Access, Secondary_Node, SDevice, Path, FName,
        Extension, Version ) ;

    // Process Node...
    if( ( Node <> '' ) and ( Node <> Kernel.Node_Name ) ) then
    begin
        Result := UOSErr_Node_Not_Found ;
        Generate_Exception( Result ) ;
        exit ;
    end ;

    H := Create_File_Handle( Kernel.PID, PChar( Name ), 0 ) ;
    if( H <> nil ) then
    begin
        H._File.Contiguous := Contiguous ;
        Close_Handle( int64( @H ) ) ;
    end ;
    Result := USC.Get_Process_Exception( Kernel.PID ).Get_Error ;
end ; // TUOS_FiP.Set_Contiguous

Next we parse the file and open it, exiting if there are errors. Finally we set the flag, close the handle, and return any errors.

In the next article, we will look at the next system utility.