PDP-10 Archive: mcb/sc/scxres.bli from BB-R595B-SM

Trailing-Edge - PDP-10 Archives - BB-R595B-SM_11-9-85 - mcb/sc/scxres.bli

There is 1 other file named scxres.bli in the archive. Click here to see a list.

module SCXRES (				! Resource-Wait Processing
		ident = 'X01190'
		) =
begin
!
!                    COPYRIGHT (c) 1980, 1981, 1982
!                    DIGITAL EQUIPMENT CORPORATION
!                        Maynard, Massachusetts
!
!     This software is furnished under a license and may  be  used
!     and copied only in accordance with the terms of such license
!     and with the inclusion of the above copyright notice.   This
!     software  or any other copies thereof may not be provided or
!     otherwise made available to any other person.  No  title  to
!     and ownership of the software is hereby transferred.
!
!     The information  in  this  software  is  subject  to  change
!     without  notice  and should not be construed as a commitment
!     by DIGITAL EQUIPMENT CORPORATION.
!
!     DIGITAL assumes no responsibility for the use or reliability
!     of  its  software  on  equipment  which  is  not supplied by
!     DIGITAL.
!

!++
!
! FACILITY:	Task Session Control
!
! ABSTRACT:	This module performs resource-wait processing,
!		such as encountered when a buffer cannot be
!		obtained for a data transfer.
!
! ENVIRONMENT:	MCB (RSX-11 user)
!
! AUTHOR:	Buren Hoffman		CREATION DATE: 6-Aug-80
!
! MODIFIED BY:
!	X01010	Changed code to use $byt_ptr macro in place of the
!		ch$ptr macro.
!	X01020	Fixed routine entry binding problems.
!	X01030	Disconnect flag was not being set for case of
!		disconnect received.
!	X01040	Added AST activation on receipt of disconnect or
!		interrupt data.
!	X01050	Using local own queueing routines because CMQxx$ routines
!		are for CCBs only.
!	X01060	Use new Comm/Exec to process linkage (.CRDAT for database)
!	X01070	Upgraded GLN support
!	X01080	Updated to use library calls, instead of requires.
!	X01090	Repaired missing forward reference.
!	X01100	Fixed reject processing to return proper reject code.
!	X01110	Added call to QUEAST to queue ASTs.
!	X01120	Fixed link counter keeping.
!	X01130	Updated disconnect-received processing to correspond
!		to modified system interface definition.
!	X01140	Set proper lun in MB packet for interrupt or disconnect
!		received.
!	X01150	Separate abort and disconnect processing into separate
!		routines.
!	X01160	Memory management cleanup.
!	X01170	Optimization work.
!	X01180	Identified bug in processing CLOSE - $HEADR may not be
!		set up right. Problem not yet fixed.
!
!	x01190  Use DSR space instead or an LDB for connect info.
!
!--

!
! INCLUDE FILES:
!
library 'SCPRM';
library 'MCB:MCBLIB';
library 'MCB:RSXLIB';
library 'MCB:XPORTX';
library 'MCB:SCSYS';

require 'SCRSX';

!
! TABLE OF CONTENTS:
!

forward routine
    SRUDSW: novalue,		! Disconnect received
    SRUINW: novalue,		! Interrupt received

    U$ABW: novalue,		! Abort
    U$ACW: novalue,		! Accept
    U$ARQ: novalue,		! * Abort wait *
    U$CLW: novalue,		! Close
    U$CNW: novalue,		! Connect
    U$DSW: novalue,		! Disconnect
    U$GLW: novalue,		! Get local node info
    U$IO:  novalue,		! I/O handler for U$RCW, U$SNW, and U$XMW
    U$IRQ: novalue,		! * Interrupt request wait *
!   U$RCW: novalue,		! Receive data (See U$IO)
    U$RJW: novalue;		! Reject
!   U$SNW: novalue		! Send data (See U$IO)
!   U$XMW: novalue		! Xmit interrupt data (See U$IO)

!
! MACROS:
!
!
! EQUATED SYMBOLS:
!
global bind routine
    U$RCW = U$IO: novalue,
    U$SNW = U$IO: novalue,
    U$XMW = U$IO: novalue;

!
! OWN STORAGE:
!

!
! EXTERNAL REFERENCES:
!
external routine
    $C5TA: novalue,		! Convert rad50 to ascii
    QUEAST,			! Queue an AST to RSX
    ULARD;			! Determine LCB address from ULA

%sbttl 'System Interface';
global routine SRUDSW (TNB): novalue =

!++
! FUNCTIONAL DESCRIPTION:
!	Obtain Mailbox memory to store arriving disconnect.
!
! FORMAL PARAMETERS:
!	TNB	The Task Networking block
!
! IMPLICIT INPUTS:
!	First CCB on the input queue
!
! IMPLICIT OUTPUTS:
!	None
!
! ROUTINE VALUE:
! COMPLETION CODES:
!	None
!
! SIDE EFFECTS:
!	APR6 is modified
!--

    begin
    $scx_get_data_base (SCXDB);
    map TNB: ref block field (TNB_FIELDS);
    local
	CCB: ref block field (C_FIELDS),
	LCB: ref block field (LCB_FIELDS),
	MB: ref block field (MBP_FIELDS);
    bind
	QUICK_LOOK_CCB = TNB [TN_IQHD]: ref block field (C_FIELDS);

    if not $MCB_GET_DSR (MBP_SIZE*bytes_word + .QUICK_LOOK_CCB [C_CNT], MB)
    then $SCX_WAIT;

    $SCX_DEQUEUE (TNB [TN_IQUE], CCB);	! Get CCB off queue
    MAP$ (.CCB [C_BIAS]);
    ch$move (.CCB [C_CNT], .CCB [C_ADDR], byt$ptr (MB [MB_DATA]));
    MB [MB_CNT] = .CCB [C_CNT];
    MB [MB_LLA] = .CCB [C_LIX];
    MB [MB_ULA] = .CCB [$sub_field (C_PRM1, LO_BYTE)];
    LCB = ULARD (.MB [MB_ULA]);
    MB [MB_LUN] = .LCB [LC_LUN];
    LCB [LCF_DSC] = true;
    MB [MB_FNC] =
	begin
	    selectone .CCB [C_PRM2] of
		set
		[-S_EDBO]:	MB$DSC;		! Disconnect
		[-S_EABM]:	MB$ABO;		! Abort by management
		[-S_EABO]:	MB$ABT;		! Abort by object
		[otherwise]:	MB$ABT;
		tes
	end;

    $SCX_ENQUEUE (TNB [TN_MBXQ], .MB);	! Queue the MB
    QUEAST (.TNB);			! Queue the AST
    $SCX_DO_RCE (.CCB)
    end;

global routine SRUINW (TNB): novalue =

!++
! FUNCTIONAL DESCRIPTION:
!	Obtain Mailbox memory to store arriving interrupt message
!
! FORMAL PARAMETERS:
!	TNB	The Task Networking Block address
!
! IMPLICIT INPUTS:
!	First CCB on the input queue
!
! IMPLICIT OUTPUTS:
!	None
!
! ROUTINE VALUE:
! COMPLETION CODES:
!	None
!
! SIDE EFFECTS:
!	None
!--

    begin
    $scx_get_data_base (SCXDB);
    map TNB: ref block field (TNB_FIELDS);
    local
	CCB: ref block field (C_FIELDS),
	LCB: ref block field (LCB_FIELDS),
	MB: ref block field (MBP_FIELDS);
    bind
	QUICK_LOOK_CCB = TNB [TN_IQHD]: ref block field (C_FIELDS);

    if not $MCB_GET_DSR (MBP_SIZE*bytes_word + .QUICK_LOOK_CCB [C_CNT], MB)
    then $SCX_WAIT;

    $SCX_DEQUEUE (TNB [TN_IQUE], CCB);	! Get CCB off queue
    MFBF$S (.CCB [C_CNT], .CCB [C_BIAS],.CCB [C_ADDR], byt$ptr (MB [MB_DATA]));
    MB [MB_CNT] = .CCB [C_CNT] ;
    MB [MB_LLA] = .CCB [C_LIX];
    MB [MB_ULA] = .CCB [$sub_field (C_PRM1, LO_BYTE)];
    LCB = ULARD (.MB [MB_ULA]);
    MB [MB_LUN] = .LCB [LC_LUN];
    MB [MB_FNC] = MB$INT;
    $SCX_ENQUEUE (TNB [TN_MBXQ], .MB);	! Queue the MB
    QUEAST (.TNB);			! Queue the AST
    $SCX_DO_RCE (.CCB)
    end;

%sbttl 'User Interface';
global routine U$ABW (LCB): novalue =

!++
! FUNCTIONAL DESCRIPTION:
!	Get resources to finish processing a link abort
!
! FORMAL PARAMETERS:
!	LCB	The link control block
!
! IMPLICIT INPUTS:
!	IOP contents
!	 I_PRM1 = Optional-data bias
!	 I_PRM2 = Optional-data address
!	 I_PRM3 = Optional-data length
!
! IMPLICIT OUTPUTS:
!	None
!
! ROUTINE VALUE:
! COMPLETION CODES:
!	None
!
! SIDE EFFECTS:
!	None
!--

    begin
    $scx_get_data_base (SCXDB);
    map LCB: ref block field (LCB_FIELDS);
    local
	CCB: ref block field (C_FIELDS),
	IOP: ref block field (IOP_FIELDS);
    bind
	TNB = LCB [LC_TNB]: ref block field (TNB_FIELDS);

    if not CCBGT$ (CCB) then $SCX_WAIT;

    $SCX_DEQUEUE (LCB [LC_NQUE], IOP);
    $SCX_DO_XME (.CCB, S$ABO, .IOP, .LCB, IOP [I_PRM1])
    end;

global routine U$ACW (LCB): novalue =

!++
! FUNCTIONAL DESCRIPTION:
!	Obtain resources to finish processing of link acceptance.
!
! FORMAL PARAMETERS:
!	LCB	The link control block
!
! IMPLICIT INPUTS:
!	IOP contents
!	 I_PRM1	Connect block bias
!	 I_PRM2	Connect block address
!	 I_PRM3	Output buffer bias
!	 I_PRM4	  "      "    address
!	 I_PRM5   "      "    length
!
! IMPLICIT OUTPUTS:
!	None
!
! ROUTINE VALUE:
! COMPLETION CODES:
!	None
!
! SIDE EFFECTS:
!	None
!--

    begin
    $scx_get_data_base (SCXDB);
    map LCB: ref block field (LCB_FIELDS);
    local
	CCB: ref block field (C_FIELDS),
	IOP: ref block field (IOP_FIELDS);
    bind
	TNB = LCB [LC_TNB]: ref block field (TNB_FIELDS);

    if not CCBGT$ (CCB) then $SCX_WAIT;

    $SCX_DEQUEUE (LCB [LC_OQUE], IOP);
    CCB [$sub_field (C_PRM1, HI_BYTE)] = S$PMSG;
    $SCX_DO_XME (.CCB, S$ACC, .IOP, .LCB, IOP [I_PRM3])
    end;

global routine U$ARQ (LCB): novalue =

!++
! FUNCTIONAL DESCRIPTION:
!	Obtain resources to verify link abort
!
! FORMAL PARAMETERS:
!	LCB	LCB address
!
! IMPLICIT INPUTS:
!	None
!
! IMPLICIT OUTPUTS:
!	None
!
! ROUTINE VALUE:
! COMPLETION CODES:
!	None
!
! SIDE EFFECTS:
!	None
!--

    begin
    $scx_get_data_base (SCXDB);
    map LCB: ref block field (LCB_FIELDS);
    local
	CCB: ref block field (C_FIELDS);
    bind
	TNB = LCB [LC_TNB]: ref block field (TNB_FIELDS);

    if not CCBGT$ (CCB) then (LCB [LCF_ARES] = true; $SCX_WAIT);

    CCB [C_ADDR] = CCB [C_CNT] = CCB [C_PRM5] = 0;
    $SCX_DO_XME (.CCB, S$ABO, 0, .LCB, 0)
    end;

global routine U$CLW (TNB): novalue =

!++
! FUNCTIONAL DESCRIPTION:
!	Obtain resources to complete network close.
!
! FORMAL PARAMETERS:
!	TNB	The task networking block address
!
! IMPLICIT INPUTS:
!	IOP contents
!
! IMPLICIT OUTPUTS:
!	None
!
! ROUTINE VALUE:
! COMPLETION CODES:
!	None
!
! SIDE EFFECTS:
!	None
!--

    begin
    $scx_get_data_base (SCXDB);
    external
	$HEADR: ref block field (HDR_FIELDS);	!!**** Problems here
						! This may not be set up
    map TNB: ref block field (TNB_FIELDS);
    local
	MB: ref block field (MBP_FIELDS),
	IOP: ref block field (IOP_FIELDS),
	LIOP: ref block field (IOP_FIELDS),
	CCB: ref block field (C_FIELDS),
	LCB: ref block field (LCB_FIELDS);

    if .TNB [TN_LCB] neq 0
    then
	! ** Abort all links
	begin
	LCB = TNB [TN_LCB];		! Scan all LCBs
	while (LCB = .LCB [LC_LINK]) neq 0 do
	    begin
	    if not .LCB [LCF_CLS]	! Abort already started ?
	    then
		begin
		LCB [LCF_ARES] = false;		! Assure this flag is cleared
		U$ARQ (.LCB);			! Initiate the abort
		if .LCB [LCF_ARES]		! Did we get it ?
		then exitloop			!  No, so quit banging
		else LCB [LCF_CLS] = true	!  Yes, mark it
		end
	    end
	end
    else
	! ** All links are aborted
	begin
	local
	    THIS_TNB: ref block field (TNB_FIELDS),
	    PREV_TNB: ref block field (TNB_FIELDS);

	THIS_TNB = SCXDB [SCX_TNB];		! Find our TNB in list
	while (PREV_TNB = .THIS_TNB; THIS_TNB = .THIS_TNB [TN_LINK]) neq 0 do
	    begin
	    if .THIS_TNB eql .TNB then exitloop
	    end;

	if .THIS_TNB eql 0 then SIGNAL_STOP (SCX$_ILE);
	PREV_TNB [TN_LINK] = .TNB [TN_LINK];	! Unlink our TNB
	$HEADR [H_NML] = 0;			! No more networking LUN
	$SCX_DEQUEUE (TNB [TN_OQHD], IOP);	! Get IOP we are processing
	.(IOP [I_LN2]) = 0;			! Kill the LUN

	! ** Flush the queues
	while $SCX_DEQUEUE (TNB [TN_IQHD], CCB) do $SCX_DO_RCE (.CCB);
	while $SCX_DEQUEUE (TNB [TN_OQHD], LIOP) do IOFIN$ (.SCXDB [SCX_UCB], .LIOP, IE_ABO, 0);
	while $SCX_DEQUEUE (TNB [TN_MBXQ], MB) do $MCB_RETURN_DSR (MBP_SIZE*bytes_word + .MB [MB_CNT], .MB);
	IOFIN$ (.SCXDB [SCX_UCB], .IOP, IS_SUC, 0)
	end
    end;

global routine U$CNW (LCB): novalue =

!++
! FUNCTIONAL DESCRIPTION:
!	Obtain resources to complete connect processing
!
! FORMAL PARAMETERS:
!	LCB	LCB address
!
! IMPLICIT INPUTS:
!	IOP contents
!	 I_PRM1	Connect block bias
!	 I_PRM2	Connect block address
!	 I_PRM3	Output buffer bias
!	 I_PRM4	  "      "    address
!	 I_PRM5   "      "    length
!	 I_PRM6	Input buffer bias
!	 I_PRM7	  "     "    address
!	 I_PRM8	  "     "    length
!
! IMPLICIT OUTPUTS:
!	None
!
! ROUTINE VALUE:
! COMPLETION CODES:
!	None
!
! SIDE EFFECTS:
!	None
!--

    begin
    $scx_get_data_base (SCXDB);
    map LCB: ref block field (LCB_FIELDS);
    local
	CNT,
	PTR,
	CB: ref block field (CB_FIELDS),
	CBU: ref block field (CBU_FIELDS),
	CCB: ref block field (C_FIELDS),
	IOP: ref block field (IOP_FIELDS),
	TCB: ref block field (TCB_FIELDS);
    bind
	TNB = LCB [LC_TNB]: ref block field (TNB_FIELDS);
    literal
	CB_L1 = (%fieldexpand (CB_SFMT, 0) - %fieldexpand (CB_NODE, 0)) * bytes_word,
	CB_L2 = (%fieldexpand (CB_OPDL, 0) - %fieldexpand (CB_RQDL, 0)) * bytes_word;

    if
	begin
	if CCBGT$( CCB) then true else false
	end
	and
	begin
	if $MCB_GET_DSR( DSR_CONNECT_BLOCK_SIZE, CCB[C_ADDR])
	then true 
	else 
		begin
		CCBRT$( .CCB);
		false
		end
	end
    then
	CCB[C_BIAS] = 0
    else
	$SCX_WAIT;

    CB = .CCB [C_ADDR];
    $SCX_DEQUEUE (LCB [LC_OQUE], IOP);
    CBU = .IOP [I_PRM2];
    TCB = .IOP [I_TCB];

    CCB [$sub_field (C_PRM1, HI_BYTE)] = S$PMSG;
    CCB [C_PRM2] = .IOP [I_PRM6];		! Input buffer bias
    CCB [C_PRM3] = .IOP [I_PRM7];		!   "     "    address
    CCB [C_PRM4] = .IOP [I_PRM8];		!   "     "    length

    ! ** Now build connect block
    CCB [C_CNT] = CB_SIZE*bytes_word;
    MAP$ (.IOP [I_PRM1]);
    MTBF$S (CB_L1, CBU [CBU_NODE], .CCB [C_BIAS], byt$ptr (CB [CB_NODE]));
    MTBF$S (CB_L2, CBU [CBU_RQDL], .CCB [C_BIAS], byt$ptr (CB [CB_RQDL]));
    MAP$ (.IOP [I_PRM3]);
    MTBF$S (.IOP [I_PRM5], .IOP [I_PRM4], .CCB [C_BIAS], byt$ptr (CB [CB_OPTD]));
    MAP$ (.CCB [C_BIAS]);
    CB [CB_OPDL] = .IOP [I_PRM5];
    CB [CB_SFMT] = 1;
    CB [CB_SOBJ] = 0;

    CNT = 0;
    PTR = byt$ptr (CB [CB_SPR1]);
    %if %bliss (bliss36)
    %then
	$C5TA (.TCB [T_NAM], PTR, CNT);
    %else
	$C5TA (.TCB [T_NM1], PTR, CNT);
	if .TCB [T_NM2] neq 0 then $C5TA (.TCB [T_NM2], PTR, CNT);
    %fi
    CB [CB_SPL1] = .CNT;
    $SCX_DO_XME (.CCB, S$CON, .IOP, .LCB, 0)
    end;

global routine U$DSW (LCB): novalue =

!++
! FUNCTIONAL DESCRIPTION:
!	Get resources to finish processing a link disconnect.
!
! FORMAL PARAMETERS:
!	LCB	The link control block
!
! IMPLICIT INPUTS:
!	IOP contents
!	 I_PRM1 = Optional-data bias
!	 I_PRM2 = Optional-data address
!	 I_PRM3 = Optional-data length
!
! IMPLICIT OUTPUTS:
!	None
!
! ROUTINE VALUE:
! COMPLETION CODES:
!	None
!
! SIDE EFFECTS:
!	None
!--

    begin
    $scx_get_data_base (SCXDB);
    map LCB: ref block field (LCB_FIELDS);
    local
	CCB: ref block field (C_FIELDS),
	IOP: ref block field (IOP_FIELDS);
    bind
	TNB = LCB [LC_TNB]: ref block field (TNB_FIELDS);

    if not CCBGT$ (CCB) then $SCX_WAIT;

    $SCX_DEQUEUE (LCB [LC_OQUE], IOP);
    $SCX_DO_XME (.CCB, S$DIS, .IOP, .LCB, IOP [I_PRM1])
    end;

global routine U$GLW (TNB): novalue =

!++
! FUNCTIONAL DESCRIPTION:
!	Obtain resources to complete "Get-Local-Node-Information"
!
! FORMAL PARAMETERS:
!	TNB	The task networking block address
!
! IMPLICIT INPUTS:
!	IOP contents
!	 I_PRM1 = Buffer bias
!	 I_PRM2 = Buffer address
!	 I_PRM3 = Buffer length
!	 I_PRM4 = Option selector
!
! IMPLICIT OUTPUTS:
!	None
!
! ROUTINE VALUE:
! COMPLETION CODES:
!	None
!
! SIDE EFFECTS:
!	None
!--

    begin
    $scx_get_data_base (SCXDB);
    map TNB: ref block field (TNB_FIELDS);
    local
	CCB: ref block field (C_FIELDS),
	IOP: ref block field (IOP_FIELDS);

    if not CCBGT$ (CCB) then $SCX_WAIT;

    $SCX_DEQUEUE (TNB [TN_OQUE], IOP);
    CCB [C_PRM1] = .IOP [I_PRM4];
    $SCX_DO_XME (.CCB, S$GLN, .IOP, 0, IOP [I_PRM1])
    end;

global routine U$IO (LCB): novalue =

!++
! FUNCTIONAL DESCRIPTION:	U$RCW & U$SNW & U$XMW
!	Obtain resources to queue a send/receive buffer to SC
!
! FORMAL PARAMETERS:
!	LCB	LCB address
!
! IMPLICIT INPUTS:
!	IOP Contents
!	 I_PRM1 = Buffer bias
!	 I_PRM2 = Buffer address
!	 I_PRM3 = Buffer length
!
! IMPLICIT OUTPUTS:
!	None
!
! ROUTINE VALUE:
! COMPLETION CODES:
!	None
!
! SIDE EFFECTS:
!	None
!--

    begin
    $scx_get_data_base (SCXDB);
    map LCB: ref block field (LCB_FIELDS);
    local
	CCB: ref block field (C_FIELDS),
	IOP: ref block field (IOP_FIELDS);
    bind
	TNB = LCB [LC_TNB]: ref block field (TNB_FIELDS);
    label
	IO_SELECT;

    if not CCBGT$ (CCB) then $SCX_WAIT;

    IO_SELECT:
	begin
	if (IOP = .LCB [LC_NQUE]) neq 0
	then
	    begin
	    if .IOP [I_FNC] eql IOP_XMT
	    then
		begin
		$SCX_DEQUEUE (LCB [LC_NQUE], CCB [C_PRM5]);
		CCB [C_MOD] = S$SNI;
		leave IO_SELECT
		end
	    end;

	if (IOP = .LCB [LC_OQUE]) neq 0
	then
	    begin
	    if .IOP [I_FNC] eql IOP_XMT
	    then
		begin
		$SCX_DEQUEUE (LCB [LC_OQUE], CCB [C_PRM5]);
		CCB [C_MOD] = S$SND;
		CCB [$sub_field (C_PRM1, HI_BYTE)] = S$PEOM;
		leave IO_SELECT
		end
	    end;

	if (IOP = .LCB [LC_OQUE]) neq 0
	then
	    begin
	    if .IOP [I_FNC] eql IOP_RCV
	    then
		begin
		$SCX_DEQUEUE (LCB [LC_OQUE], CCB [C_PRM5]);
		CCB [C_MOD] = S$MRQ;
		leave IO_SELECT
		end
	    end
	end;

    $SCX_DO_XME (.CCB, .CCB [C_MOD], .CCB [C_PRM5], .LCB, IOP [I_PRM1])
    end;

global routine U$IRQ (LCB): novalue =

!++
! FUNCTIONAL DESCRIPTION:
!	Obtain resources to request an interrupt
!
! FORMAL PARAMETERS:
!	LCB	LCB address
!
! IMPLICIT INPUTS:
!	None
!
! IMPLICIT OUTPUTS:
!	None
!
! ROUTINE VALUE:
! COMPLETION CODES:
!	None
!
! SIDE EFFECTS:
!	None
!--

    begin
    $scx_get_data_base (SCXDB);
    map LCB: ref block field (LCB_FIELDS);
    local
	CCB: ref block field (C_FIELDS);
    bind
	TNB = LCB [LC_TNB]: ref block field (TNB_FIELDS);

    if not CCBGT$ (CCB) then (LCB [LCF_NRES] = true; $SCX_WAIT);

    CCB [$sub_field (C_PRM1, HI_BYTE)] = 1;
    $SCX_DO_XME (.CCB, S$IRQ, 0, .LCB, 0)
    end;

global routine U$RJW (TNB): novalue =

!++
! FUNCTIONAL DESCRIPTION:
!	Obtain resources to effect link rejection.
!
! FORMAL PARAMETERS:
!	TNB	TNB address
!
! IMPLICIT INPUTS:
!	IOP contents
!	 I_PRM1	Connect block bias
!	 I_PRM2	Connect block address
!	 I_PRM3	Output buffer bias
!	 I_PRM4	  "      "    address
!	 I_PRM5   "      "    length
!	 I_PRM6 Logical link address of rejected link
!
! IMPLICIT OUTPUTS:
!	None
!
! ROUTINE VALUE:
! COMPLETION CODES:
!	None
!
! SIDE EFFECTS:
!	None
!--

    begin
    $scx_get_data_base (SCXDB);
    map TNB: ref block field (TNB_FIELDS);
    local
	CCB: ref block field (C_FIELDS),
	IOP: ref block field (IOP_FIELDS);

    if not CCBGT$ (CCB) then $SCX_WAIT;

    $SCX_DEQUEUE (TNB [TN_OQUE], IOP);
    CCB [C_LIX] = .IOP [I_PRM6];
    CCB [C_PRM2] = S_ERBO;
    CCB [C_PRM4] = .TNB;
    $SCX_DO_XME (.CCB, S$REJ, .IOP, 0, IOP [I_PRM3])
    end;

end
eludom