*DECK NS$EXC USETEXT COM$NS USETEXT DEF$NS USETEXT ERR$NS USETEXT NAT$NS USETEXT NPT$NS PROC NS$EXC; # NS EXECUTIVE # # TITLE NS$EXC - NS EXECUTIVE. # BEGIN # NS$EXC # # ** NS$EXC - NS EXECUTIVE. * * J.C. LEE 1981 * * THIS IS THE NS MAIN PROGRAM. IT IS THE EXECUTIVE. * * PROC NS$EXC * * ENTRY: * NONE. * * EXIT: * NONE. * * METHOD: * LOAD AND EXECUTE NS INITIALIZATION OVERLAY. * THIS PROC CONSISTS PRIMARY OF A LARGE LOOP. * EACH TIME THROUGH THE LOOP, THE FOLLOWING IS DONE: * GET REAL TIME CLOCK READING AND SET CURRENT TIME * IN SECONDS. * IF NS NOT IN NORMAL MODE AND STARTUP MODE TIMER * EXPIRED: * SET NS TO NORMAL MODE. * CALL SM PROCESSOR TO PROCESS ALL INCOMING SMS. * IF FORCE SHUTDOWN IN EFFECT: * NETOFF NS. * STOP RUN. * IF NOT FORCE SHUTDOWN: * CHECK NPU ACTIVITY TIMER. * IF NPU-TIMEOUT-INTERVAL NQ 0: * SET NETWAIT TIME TO NPU-TIMEOUT-INTERVAL. * ELSE: * SET NETWAIT TIME TO 4095 SECONDS. * CALL TSB MANAGER TO PERFORM MEMORY COMPACTION. * LOOP TERMINATES WHEN NS NETOFF, OR ERROR IS DETECTED. * # $BEGIN XREF BEGIN PROC NS$DBG; # TRACE PROCEDURE CALL # END $END XREF BEGIN PROC NDLOVLD; # OVERLAY LOADER # PROC NETCHEK; # AIP NETCHEK CALL # PROC NETWAIT; # NETWAIT # FUNC NS$FEC U; # FORMAT ERROR CODE # PROC NS$MSG; # MESSAGE DISPATCHER # PROC NS$OFF; # DISCONNECT FROM NETWORK # PROC NS$SHD; # SHUTDOWN PROCESSOR # PROC NS$SMP; # SUPERVISORY MESSAGE PROCESSOR # PROC MOVEOK; # ALLOW TSB TO MOVE # PROC RECALL; # RECALL # PROC RTIME; # GET REAL TIME CLOCK READING # PROC TSBINFO; # LOCATE TSB # PROC XFLMGR; # EXCESS FIELD LENGTH MANAGER # END ITEM ERRCODE U; # ERROR CODE # ITEM GTIMER U; # ACTIVITY TIMER # ITEM I I; # LOOP VARIABLE # ITEM LTIMER U; # RESPONSE TIMER # ITEM NATFWA U; # NAT FWA # ITEM NATSIZE U; # NAT SIZE # ITEM NEXTNATTSB U; # NAT TSB NUMBER # ITEM TSBN U; # TSB NUMBER # DEF L$CSHDMSG # 3 #; # MESSAGE SIZE # DEF DM$CSHDMSG # DM$LOCAL + DM$NAMLOG #; # ROUTING OPTIONS # ARRAY MSG$CSHD [0:0] S(L$CSHDMSG); BEGIN # SHUTDOWN COMPLETED MESSAGE # ITEM CSHD$TEXT C(00,00,25) = ["SHUTDOWN COMPLETED."]; ITEM CSHD$END U(02,30,30) = [0]; END ARRAY REALTIME [0:0] S(1); BEGIN # STATUS WORD FOR RTIME CALL # ITEM CURSEC U(00,00,24); # SECOND CLOCK # ITEM CURMS U(00,24,36); # MILLISECOND CLOCK # END ARRAY NSI$OVLY [0:0] S(1); BEGIN # INITIALIZATION OVERLAY NAME AND LEVEL # ITEM NO$NAM C(00,00,07) = ["NSIOVLY"]; ITEM NO$LV1 U(00,42,09) = [1]; ITEM NO$LV2 U(00,51,09) = [0]; END ARRAY MKD$OVLY [0:0] S(1); BEGIN # K-DISPLAY MANAGER OVERLAY NAME/LEVEL # ITEM MO$NAM C(00,00,07) = ["MKDOVLY"]; ITEM MO$LV1 U(00,42,09) = [3]; ITEM MO$LV2 U(00,51,09) = [0]; END ARRAY ERR$OVLY [0:0] S(1); BEGIN # ERROR PROCESSOR OVERLAY NAME AND LEVEL # ITEM EO$NAM C(00,00,07) = ["ERROVLY"]; ITEM EO$LV1 U(00,42,09) = [5]; ITEM EO$LV2 U(00,51,09) = [0]; END CONTROL EJECT; $BEGIN NS$DBG("EXC"); $END # LOAD AND EXECUTE NS INITIALIZATION OVERLAY # NDLOVLD(NSI$OVLY); FOR I = 0 DO # NS EXECUTIVE LOOP # BEGIN RTIME(REALTIME); # GET REAL TIME CLOCK READING # CURTIME = CURSEC[0]; # SET CURRENT TIME IN SECONDS # IF NSM NQ M$NORMAL # NS NOT IN NORMAL MODE # AND CURTIME GR NMTIME # STARTUP MODE TIMER EXPIRED # THEN NSM = M$NORMAL; # SET NS TO NORMAL MODE # # CALL SUPERVISORY MESSAGE PROCESSOR TO PROCESS ALL INCOMING SUPERVISORY MESSAGES # NS$SMP; IF NOT FORCESHUT THEN # FORCE SHUTDOWN IS NOT IN EFFECT # BEGIN # CHECK NPU ACTIVITY TIMERS FOR EXPIRATION # NEXTNATTSB = NPT$NLHEAD[0]; # HEAD PTR OF NAT LIST # FOR I = 0 WHILE NEXTNATTSB NQ 0 DO # MORE NAT IN LIST # BEGIN # CHECK NAT FOR TIMER EXPIRATION# TSBINFO(NATSIZE,NATFWA,NEXTNATTSB); # LOCATE NAT # P = NATFWA; # FWA OF NAT # TSBN = NEXTNATTSB; # SAVE CURRENT NAT TSBN # NEXTNATTSB = NAT$NLFP[0]; # NEXT NAT IN LIST # LTIMER = NAT$LTIMER[0]; # RESPONSE TIMER # GTIMER = NAT$GTIMER[0]; # ACTIVITY TIMER # IF CURTIME GR LTIMER OR (GTIMER NQ 0 AND CURTIME GR GTIMER) THEN # TIMEOUT ERROR # BEGIN NTORD = NAT$NTORD[0]; # NPU TABLE ORDINAL # ERRCODE = NS$FEC(EC"ERR$TIMER",0); NDLOVLD(ERR$OVLY,ERRCODE); # PROCESS TIMEOUT ERROR # IF NPT$NATTSB[NTORD] NQ 0 THEN NEXTNATTSB = TSBN; END ELSE # TIMER(S) ARE STILL RUNNING # BEGIN MOVEOK(TSBN); # ALLOW NAT TO MOVE # END END END IF FORCESHUT # FORCE SHUTDOWN IN EFFECT # OR (GRADSHUT AND NPT$NLHEAD[0] EQ 0) # GRADUAL SHUTDOWN/NO NP# THEN # SHUTDOWN NS # BEGIN NS$MSG(MSG$CSHD,L$CSHDMSG,DM$CSHDMSG); NS$OFF; # DISCONNECT FROM NETWORK # STOP; # ENDRUN # END IF DCW$F$SKD[0] THEN # K-DISPLAY DATA TO SEND # NDLOVLD(MKD$OVLY); # CALL K-DISPLAY MANAGER # # PERFORM EXCESS FIELD LENGTH PROCESSING # XFLMGR; # GIVE UP CPU WHILE WAITING FOR NEXT INPUT # IF NPT$NLHEAD[0] NQ 0 THEN # ACTIVE NPU(S) STILL EXIST # BEGIN # STAY IN CONTROL POINT UNTIL ACTIVITY COMPLETED # NETCHEK; # FLUSH WORKLIST AND GET UPDATED S/I STATUS # RECALL(0); # RELINQUISH CPU WHILE WAITING FOR INPUT # END ELSE # NO ACTIVE NPU # NETWAIT(MAX$NWTIME,FALSE); END RETURN; END # NS$EXC # TERM