.TITLE ACC
	.IDENT	/1.65/
 
;+
;	ACC -- CPU LOGGING DISPATCH AND CONTROL TASK
; WRITTEN BY:
;		JAMES G. DOWNWARD
;		KMS FUSION,INC
;		3941 RESEARCH PARK DR.
;		ANN ARBOR, MICH. 48104
;		(313)-769-8500
;
;	THE TASK ACC IS DESIGNED TO CONTROL THE FUNCTIONALITY AND OPTIONS
; OF THE RSX11M SYSTEM ACCOUNTING TASK, SYSLOG. IT IS DESIGNED TO BE
; USED AS AN EXTERNAL MCR COMMAND.  IT HAS THE FOLLOWING FUNCTIONS.
;
;	1.	START ACCOUNTING 
;	2.	SET THE ACCOUNT FEATURE MASK FOR THE DESIRED ACCOUNTING OPTIONS.
;	3.	CHANGE THE ACCOUNTING FEATURES DESIRED(EXCEPT FOR CPU
;		TIME ACCOUNTING AND NULL TIME ACCOUNTING) ON LINE WITHOUT
;		INTERUPTING ACCOUNTING.
;	4.	MODIFY THE ACCOUNTING SAMPLE INTERVAL.
;	5.	TURN OFF ACCOUNTING
;	6.	DISPLAY THE CURRENT ACCOUNTING FEATURES
;
; COMMAND SYNTAX:
;			ACC /SW1/SW2/SW3 ...
;	WHERE THE SWITCHES ARE
;	
;	START	- START UP THE ACCOUNTING TASK SYSLOG
;	STOP	- STOP THE ACCOUNTING TASK SYSLOG(NO OTHER SWITCHES WILL BE
;		  RECOGNIZED WITH THE STOP COMMAND
;	CPU	- START USER CPU TIME ACCOUNTING AND SYSTEM NULL TIME ACCOUNTING
;	GBL	- LOG SYSTEM GLOBAL VARIABLES AT EACH INTERVAL
;	QIO	- ACTIVATE SYSTEM WIDE QIO ACCOUNTING(FORCES CPU TIME ACCOUNTING)
;	UQIO	- ACTIVATE SYSTEM WIDE AND USER QIO ACCOUNTING
;	DIR	- ACTIVATE DIRECTIVE ACCOUNTING(ONLY VALID IF /CPU FOUND)
;	MEM	- LOG MEMORY UTILIZATION VARIABLES (MAINTAINED BY RMDEMO)
;		  AT EACH SAMPLE INTERVAL.
;	FREE	- LOG MEMORY UTILIZATION VARIABLES, IF CORE SPACE IS TIGHT
;		  OR IF AN EXCESSIVE NUMBER OF TASK ARE ON THE CHECKPOINT FILE
;	POOL	- LOG MEMORY UTILIZATION VARIABLES IF POOL GETS TOO LOW
;	DLT:n	- CHANGE SAMPLE INTERVAL TIME, TO n MINUTES
;		  DEFAULTS TO 30 MIN SAMPLES.
;	LOG	- LOG HELLO/BYE/UPD SIGN ON/OFF TIMES AND TERMINALS
;	DSP	- DISPLAY CURRENT SETTINGS OF ACCOUNT MASK
;	LCO	- LOG CO: STATISTICS EACH SAMPLE INTERVAL
;	TAS[K]	- START UP SELECTIVE TASK ACCOUNTING(NO /UQIO ALLOWED)
;	PRI[NT] - PRINT TASK ACCOUNTING STATISTICS ON TI:
;	SPO[OL] - LOG ALL PRINT SPOOLER STATISTICS
;	NUQ[IO]	- DISABLE TERMINAL  QIO ACCOUNTING(SYSTEM WIDE QIO ACCOUNTING CONTINUES)
;	NLO[G]	- DISABLE LOGGING HELLO/BYE/UPD DATA
;	NLC[O]	- DISABLE LOGGING CO: STATISTICS
;	NME[M]	- DISABLE MEMORY LOGGING
;	NFR[EE] - DISABLE MEMORY LOGGING ON LOW FREE CORE
;	NPO[OL] - DISABLE MEMORY LOGGIG ON LOW FREE POOL
;	NTA[SK]	- DISABLE TASK ACCOUNTING
;	NPR[INT]- DISABLE PRINTING OF TASK ACCOUNTING STATISTICS ON TI:
;	NSPO[OL]- DISABLE LOGGING PRINT SPOOLER STATISTICS
;
;
;
;	FOR THIS PACKAGE TO WORK A SYSTEM GENERATION MUST BE DONE TO INCOR-
; PORATE DATA STRUCTURES INTO SYSCM, AND THE DATA BASES FOR TTDRV,CODRV,AND
; VTDRV.  FOR RSX11M V3.2, THIS SYSGEN IS QUIET EASY TO DO.  ADDITIONALLY, 
; IF THE USER DESIRES THE VARIOUS FEATURES OF THIS PACKAGE TO BE USED, IT IS 
; NECESSARY TO APPLY SLP FILES FOR HELLO, BYE, ACNT, INS, AND ACTFIL.
; WHILE THIS SOUNDS LIKE QUITE A LOT OF CHANGES TO MAKE, THE CHANGES 
; RELATING TO INCORPORATING RSX11M SYSTEM ACCOUNTING ARE QUITE SMALL.  MOST
; OF THE CODE IN THE VARIOUS SLP FILES RELATES TO EITHER AN IMPROVED HELLO/BYE
; WHICH INCORPORATES ONE LEVEL OF ACCOUNTING(THIS HAS BEEN DISTRIBUTED FOR
; TWO YEARS NOW), RUN PRIVLEGE ALLOCATION, AND PASSING COMMAND LINES VIA INSTALL
; OR THE RUN COMMAND. USER BY USER CPU TIME ACCOUNTING WILL WORK
; WITH ONLY THE SYSCM, DRIVER, HELLO ,BYE AND ACTFIL CHANGES. ONCE THE DATA
; BASES IN SYSCM AND THE DRIVERS ARE ADDED AS MANY OR AS FEW OF THE OTHER
; CHANGES MAY BE MADE WITH OUT ADVERSELY AFFECTING OTHER ELEMENTS OF THE
; SYSTEM.  THE SLP FILE FOR ACNT ENABLES AN EXISTING FEATURE (ACCOUNT ID NUMBER).
; AT LOGON THE ACCOUNT ID IS PLACED IN THE TERMINAL UCB.  DURING LOGGING OF
; TERMINAL STATISTICS, THE ID IS SENT WITH THE DATA PACKET.  THIS ENABLES PROGRAMS
; TO LATER DETERMINE WHICH ACCOUNT WAS RESPONSIBLE FOR THE USAGE.
;
; THIS TASK MAY BE BUILT
; 
;	MAC ACC.OBJ;1=LB:[1,1]EXEMC/ML,[200,200]RSXCM/PA:1,SY:[UIC]ACC
;	TKB ACC.TSK;1/PR/CP=ACC.OBJ;1
;	/
;	TASK=...ACC
;	PRI=50
;	//
;-
	.MCALL	UCBDF$,TCBDF$,HWDDF$,EXIT$S,SDAT$,RQST$,QIOW$,DIR$,USTP$
	.MCALL	EXST$S,RCST$,STOP$S,ALUN$S
	TCBDF$		; DEFINE TCB OFFSETS
	.MCALL	GMCR$
		TCBDF$		; DEFINE TCB OFFSETS
		HWDDF$		; DEFINE HARDWARE OFFSETS
		UCBDF$		; DEFINE UCB OFFSETS
 
; LOCAL MACROS
;
	.MACRO	PRINT	STRING
	MOV	#STRING,R0
	CALL	PNTLIN
	.ENDM	PRINT
 
;
; ERROR MESSAGES
;
	.NLIST BEX
	.EVEN
M1:	.ASCIZ	<15><12>/ACC -- FATAL, NOT A PRIVLEGED TERMINAL/
M2:	.ASCIZ	<15><12>/ACC -- FATAL, SYSLOG NOT INSTALLED/
M3:	.ASCIZ	<15><12>/ACC -- SYSTEM ACCOUNTING NOT STARTED/
M4:	.ASCIZ	<15><12>/ACC -- FATAL, SYSTEM ACCOUNTING NOT STARTED/
M5:	.ASCIZ	<15><12>/ACC -- FATAL, COMMAND SWITCHES ARE MISSING/
M6:	.ASCIZ	<15><12>/ACC -- FATAL, COMMAND ERROR/
M7:	.ASCIZ	<15><12>/ACC -- FATAL, SYNTAX ERROR/
M8:	.ASCIZ	<15><12>/ACC -- FATAL, ILLEGAL SWITCH/
M9:	.ASCIZ	<15><12>\ACC -- WARNING, ALL OTHER SWITCHES EXCEPT /STOP ARE IGNORED\
M10:	.ASCIZ	<15><12>/ACC -- FATAL, $ACMSK SAYS ACCOUNTING IS ACTIVE/
M11:	.ASCIZ	<15><12>/ACC -- FATAL, SYSLOG COULD NOT BE REQUESTED(IE.ACT OR IE.INS)/
M12:	.ASCIZ	<15><12>/ACC -- FATAL, SYSLOG COULD NOT BE UNSTOPPED/
M13:	.ASCIZ	<15><12>/ACC -- FATAL, ACCOUNTING MUST BE STARTED FIRST/
M14:	.ASCIZ	<15><12>/ACC -- FATAL, NO ACCOUNTING OPTIONS SELECTED/
M15:	.ASCIZ	<15><12>\ACC -- FATAL, /QIO CAN NOT BE SELECTED AFTER SYSLOG STARTS\
M16:	.ASCIZ	<15><12>\ACC -- FATAL, /DIR CAN NOT BE SELECTED AFTER SYSLOG STARTS\
M17:	.ASCIZ	<15><12>/ACC -- FATAL, ILLEGAL SAMPLING INTERVAL/
M18:	.ASCIZ	<15><12>\ACC -- FATAL, /UQIO MAY NOT BE ENABLED AFTER SYSLOG RUNNING\
M19:	.ASCIZ	<15><12>/ACC -- SYSLOG NOT ACTIVE BUT CODE NODE PRESENT, RESTARTING SYSLOG/
M20:	.ASCIZ	<15><12>/ACC -- SYSTEM WIDE DIRECTIVE ACCOUNTING NOT YET IMPLEMENTED/
M21:	.ASCIZ	<15><12>/ACC -- FATAL, "TSKLOG" NOT INSTALLED, OR OR ALREADY ACTIVE/
M22:	.ASCIZ	<15><12>/ACC -- FATAL, "TSKLOG" IS ACTIVE/
M23:	.ASCIZ	<15><12>\ACC -- WARNING, /QIO AND/OR /UQIO NOT ENABLED FOR "TSKLOG"\
M25:	.ASCIZ	<15><12>/ACC -- "TSKLOG" NOT INSTALLED/
M26:	.ASCIZ	<15><12>/ACC -- "TSKLOG" NOT ACTIVE/
M27:	.ASCIZ	<15><12>/ACC -- FATAL, MEMORY ALLOCATION FAILURE WHILE STOPPING "TSKLOG"/
	.EVEN
 
 

; BIT DEFINITIONS OF THE SYSTEM ACCOUNTING MASK, $ACMSK
;
; BIT 	0	1	CPU TIME ACCOUNTING IS DESIRED/ENABLED(USER AND NULL TIME))
; BIT	1	2	QIO ACCOUNTING DESIRED/ENABLED
; BIT	2	4	DIRECTIVE ACCOUNTING DESIRED/ENABLED
; BIT	3      10	LOG GLOBAL CPU USAGE STATISTICS AT SPECIFIED INTERVALS
; BIT	4      20	LOG MEMORY USAGE STATISTICS AT SPECIFIED INTERVALS
; BIT	5      40	LOG MEMORY STATISTICS IF CORE FULL/FILES CHECKPOINTED
; BIT 	6     100	LOG MEMORY STATISTICS IF POOL LOW OR TOO FRAGMENTED
; BIT	7     200	LOG HELLO AND BYE SIGN ON/OFF TIMES AND TERMINALS
; BIT	8     400	LOG CO: STATISTICS
; BIT	9    1000	ENABLE TERMINAL QIO ACCOUNTING
; BIT  10    2000	TASK ACCOUNTING ENABLED
; BIT  11    4000	WRITE TASK ACCOUNTING STATISTICS TO TI:
; BIT  12   10000	ENABLE PRINT SPOOLER LOGGING
; BIT 13-15		UNDEFINED
 
 
;
; ACCOUNTING STATUS/MASK DISPLAY MESSAGES
;
ACCHDR:	.ASCII	<15><12>/SYSTEM ACCOUNTING OPTIONS ENABLED/
	.ASCIZ	<15><12>/BIT	MEANING/
ACCM00:	.ASCIZ	<15><12>\ 00	USER CPU TIME/SYSTEM NULL TIME\
ACCM01:	.ASCIZ	<15><12>/ 01	QIO ACCOUNTING ENABLED/
ACCM02:	.ASCIZ	<15><12>/ 02	DIRECTIVE ACCOUNTING ENABLED/
ACCM03:	.ASCIZ	<15><12>/ 03	CPU USAGE LOGGED EVERY DELTA MINUTES/
ACCM04:	.ASCIZ	<15><12>/ 04	MEMORY USAGE LOGGED EVERY DELTA MINUTES/
ACCM05:	.ASCIZ	<15><12>/ 05	MEMORY USAGE LOGGED IF FREE CORE TIGHT/
ACCM06:	.ASCIZ	<15><12>/ 06	MEMORY USAGE LOGGED IF POOL TOO LOW OR FRAGMENTED/
ACCM07:	.ASCIZ	<15><12>\ 07	LOG HELLO/BYE/UPD SIGN ON/OFF TIMES, TERMINALS, ETC\
ACCM08:	.ASCIZ	<15><12>/ 08	LOG CO: STATISTICS/
ACCM09:	.ASCIZ	<15><12>/ 09	TERMINAL QIO ACCOUNTING/
ACCM10:	.ASCIZ	<15><12>/ 10	SELECTIVE TASK ACCOUNTING/
ACCM11:	.ASCIZ	<15><12>/ 11	WRITE TASK ACCOUNTING STATISTICS TO CO:/
ACCM12:	.ASCIZ	<15><12>/ 12	LOG PRINT SPOOLER USAGE/
ACCM13:	.ASCIZ	<15><12>/ 13	UNDEFINED/
ACCM14:	.ASCIZ	<15><12>/ 14	UNDEFINED/
ACCM15:	.ASCIZ	<15><12>/ 15	UNDEFINED/
ACCTIM:	.ASCII	<15><12>/	CURRENT SAMPLING INTERVAL(MIN) = /
ACCTM:	.ASCIZ	/     /
 
 
 
 
;
; FLAGS TO INDICATE SWITCHES FOUND AND LOCAL DATA STORAGE
	.EVEN
DLTFLG:	.WORD	0		; CHANGE SAMPLING TIME
STRFLG:	.WORD	0		; START UP SYSLOG
STPFLG:	.WORD	0		; STOP SYSLOG
ACMASK:	.WORD	0		; USE TO BUILD UP SYSTEM ACCOUNT MASK WORD
DLTVAL:	.WORD	30.		; CONVERTED VALUE OF DELTA TO SEND TO SYSLOG
				; INITIALLY SET TO 30 MINUTES.
	.EVEN
DLTMIN:	.ASCII	/NNNNNN/	; AREA TO INSERT ASCII VALUE FOR DELTA
	.EVEN
 
 
; DIRECTIVE PARAMETER BLOCKS
;
REQST:	RQST$	SYSLOG		; REQUEST SYSLOG TO START UP
RECV:	RCST$	SYSLOG,SEND	; RECIEVE DATA OR STOP FROM SYSLOG
UNSTOP:	USTP$	SYSLOG		; UNSTOP SYSLOG
SENDAT:	SDAT$	SYSLOG,SEND	; SEND DATA TO SYSLOG TO EITHER STOP IT 
				; OR CHANGE IT'S SAMPLING INTERVAL
USTP:	USTP$	TSKLOG		; UNSTOP TSKLOG
SNDTKS:	SDAT$	TSKLOG,SEND	; SEND DATA PACKET TO STOP TASK LOGGING
RQTSK:	RQST$	TSKLOG		; REQUEST TSKLOG TO RUN
SEND:	.BLKW	15.		; SEND BUFFER AND RECEIVE BUFFER
QIODPB:	QIOW$	IO.WVB,2,2,,,,<0,0,0> ; WRITE TO TERMINAL
GMCR:	GMCR$			; GET COMMANDLINE DPB
BUF:	.BLKW	40		; BUFFER FOR TERMINAL OUTPUT
	.WORD	0
 
 
;
; SWITCH TABLE
;
SWTAB:	.RAD50	/STA/
	.RAD50	/STO/
	.RAD50	/CPU/
	.RAD50	/GBL/
	.RAD50	/QIO/
	.RAD50	/DIR/
	.RAD50	/MEM/
	.RAD50	/FRE/
	.RAD50	/POO/
	.RAD50	/DLT/
	.RAD50	/LOG/
	.RAD50	/DSP/
	.RAD50	/LCO/
	.RAD50	/NLC/		; DISABLE CO: LOGGING
	.RAD50	/NME/		; DISABLE MEMORY STATISTICS LOGGING
	.RAD50	/NFR/		; DISABLE MEM STAT LOGGING ON TIGHT CORE
	.RAD50	/NPO/		; DISABLE MEM STAT LOGGING ON LOW POOL
	.RAD50	/NLO/		; DISABLE LOGIN ACCOUNTING
	.RAD50	/UQI/		; ENABLE TERMINAL QIO ACCOUNTING
	.RAD50	/NUQ/		; DISABLE TERMINAL QIO ACCOUNTING
	.RAD50	/TAS/		; SELECTIVE TASK ACCOUNTING
	.RAD50	/NTA/		; DISABLE SELECTIVE TASK ACCOUNTING
	.RAD50	/PRI/		; PRINT TASK STATISTICS TO CO0:
	.RAD50	/NPR/		; DISABLE PRINTING OF STATISTICS
	.RAD50	/SPO/		; ENABLE LOGGING PRINT SPOOLER DATA
	.RAD50	/NSP/		; DISABLE LOGGING PRINT SPOOLER DATA
ENDTAB:
 
;
; JUMP TABLE TO PROCESSING ROUTINES
;
JMPTAB:	
	.WORD	START		; START UP SYSLOG
	.WORD	STOP		; STOP SYSLOG
	.WORD	CPUSET		; SET CPU TIME LOGGING
	.WORD	GBLSET		; SET GBL QTY LOGGING
	.WORD	QIOSET		; SET QIO ACCOUNTING
	.WORD	DIRECT		; SET DIRECTIVE COUNTING LOGGING
	.WORD	MEMORY		; LOG MEMORY STATISTICS
	.WORD	FREMEM		; LOG IF FREE MEM GETS TOO LOW
	.WORD	TOTPOO		; LOG IF FREE POOL GETS TO LOW
	.WORD	DELTA		; RESET THE TIME INTERVAL FOR LOGGING
	.WORD	LOGSET		; SET LOGIN ACCOUNTING
	.WORD	DSPLAY		; DISPLAY THE SETTINGS OF THE ACCOUNT MASK
	.WORD	LOGCO		; LOG CO: STATISTICS
	.WORD	NOLGCO		; DISABLE CO: STATISTICS
	.WORD	NOMEM		; DISABLE MEMORY STATISTICS LOGGING
	.WORD	NOFREE		; DISABLE MEMORY STATISTICS LOGGING IF CORE TIGHT
	.WORD	NOPOOL		; DISABLE MEMORY LOGGING STATISTICS ON LOW POOL
	.WORD	NOLOG		; DISABLE LOGIN ACCOUNTING
	.WORD	UQIOLG		; ENABLE TERMINAL QIO ACCOUNTING
	.WORD	NUQILG		; DISABLE TERMINAL QIO ACCOUNTING
	.WORD	TSKON		; START UP TASK ACCOUNTING
	.WORD	TSKOFF		; TURN OFF TASK ACCOUNTING
	.WORD	PRTSK		; PRINT TASK STATISTICS TO CO:
	.WORD	NPRTSK		; DISABLE PRINTING TASK STATISTICS TO CO:
	.WORD	SPOOL		; ENABLE LOGGING PRINT SPOOLER DATA
	.WORD	NSPOOL		; DISABLE LOGGING PRINT SPOOLER DATA
 
 
 
 
; PARAMETERS REQUIRED FOR CONTROLING TSKLOG
BLKSIZ=24			; SIZE OF TASK ACCOUNTING BLOCK NODE
ERROR:	.WORD	0		; ERROR FLAG WORD
TSKLOG:	.RAD50	/TSKLOG/	; THE TASK'S NAME
 
	.SBTTL	START OF PROGRAM
ACC:				; REF LABLE
	MOV	$TKTCB,R0	; FIRST GET OUR TCB
	MOV	T.UCB(R0),R0	; THEN OUR UCB ADDRESS
	BIT	#U2.PRV,U.CW2(R0) ; IS TERMINAL PRIVLEGED
	BNE	2$		; IF NE, YES
	PRINT	M1		; WARN THAT TERMINAL IS NOT PRIVLEGED
1$:	JMP	ERRXIT		; AND EXIT WITH SEVERE ERROR
2$:				; REF LABLE
	DIR$	#GMCR		; GET MCR COMMAND LINE
	BCC	10$		; NO ERROR, SO PROCEED
	PRINT	M6		; COMMAND ERROR
	BR	1$		; AND EXIT
10$:	MOV	#GMCR+G.MCRB,R5	; GET ADDRESS OF MCR COMMAND LINE
	CMP	$DSW,#7.	; SEE IF ANY COMMANDS PRESENT
	BGE	20$		; MUST HAVE AT LEAST 7 CHARACTERS IN LINE
	PRINT 	M5		; OR ELSE NO VALID COMMAND PRESENT
	BR	1$		; AND EXIT
20$:	ADD	#1,R5		; POINT TO WHERE WE EXPECT A SPACE
25$:	INC	R5		; BUMP COUNTER
	CMPB	(R5),#15	; IS IT A <CR>
	BNE	27$		; IF NE , NO, CONTINUE SCAN
	JMP	ENDUP		; IF EQ, YES, ENDUP AS APPROPRIATE
27$:	CMPB	(R5),#33	; IS IT AN <ESC>
	BNE	28$		; IF NE,NO, CONTINUE
	JMP	ENDUP		; IF EQ, YES, ENDUP AS APPROPRIATE
28$:	CMPB	(R5),#'/	; IS IT A SWITCH
	BNE	25$		; IF NE, NO IT ISN'T, CONTINUE SCAN
	INC	R5		; BUMP PAST /
	CALL	KEYWRD		; SCAN FOR KEYWORD
	BR	25$		; AND SCAN LINE FOR MORE
 
 
 
;+
; KEYWRD -- SCAN THROUGH THE SWITCH TABLE LOOKING FOR A MATCH
;	    IF A MATCH IS FOUND, EXECUTE AN @CALL VIA THE
;	    JMP TABLE TO THE PROCESSING ROUTINE.
;	    IF NO MATCH IS FOUND , DECLARE AN ILLEGAL KEYWORD ERROR
;	    AND EXIT WITH GRACE.
;-
KEYWRD:				;
	MOV	R5,R0		; POINTER TO THE NEXT THREE BYTES
	CLR	R1		; CONTROL FOR $CAT5(DO NOT CONTROL DOTS)	
	CALL	$CAT5		; CONVERT THOSE THREE BYTES TO ONE RAD50 WORD IN R1
	MOV	#SWTAB,R4	; NOW WE WILL SEARCH COMMAND TABLE FOR MATCH
10$:	CMP	R1,(R4)+	; DO WE HAVE A MATCH
	BEQ	20$		; YES WE DO
	CMP	R4,#ENDTAB	; ARE WE AT END
	BLO	10$		; IF LO, NO, LOOK SOME MORE
	PRINT	M8		; ILLEGAL COMMAND SWITCH
	JMP	ERRXIT		; EXIT WITH ERROR STATUS
20$:				;
	CALL	@JMPTAB-SWTAB-2(R4) ; JUST LIKE IN CCL
	RETURN
 
 
START:				;
	INC	STRFLG		; SHOW WE ARE TO ISSUE A START COMMAND
	RETURN			;
STOP:				;
	INC	STPFLG		; SHOW WE MUST STOP
	RETURN			;
CPUSET:	BIS	#1,ACMASK	; WE WILL SET THIS BIT IN $ACMSK
	RETURN			;
 
GBLSET:	BIS	#10,ACMASK	; WE WILL SET THIS BIT IN $ACMSK
	RETURN			;
QIOSET:	BIS	#3,ACMASK	; WE WILL SET THESE BITS IN $ACMSK 
				; TO ENABLE QIO ACCOUNTING(SYSTEM WIDE)
	TST	$ACMSK		; IS ACCOUNTING ALREADY RUNNING
	BEQ	10$		; IF EQ, NO, ALL OK
	PRINT	M15		; WARN USER
	JMP	ERRXIT		; EXIT WITH ERROR
				; NOTE THAT CPU TIME ACCOUNTING IS REQUIRED ALSO
10$:	RETURN			;
 
 
UQIOLG:				;
1$:	BIT	#2,$ACMSK	; IS QIO ACCOUNTING ALREADY RUNNING
	BNE	3$		; IF NE,YES
	TST	$ACMSK		; IS ACCOUNTING EVEN RUNNING?
	BEQ	3$		; IF EQ 0, NO, SO WE CAN PROCEED TO SET IT UP
	PRINT	M18		; IF NE, ACCOUNTING IS RUNNING BUT QIO'S ARE NOT ENABLED
	JMP	ERRXIT		; SO WE MUST EXIT IN ERROR
3$:	BIS	#1003,ACMASK	; SO SET ALL THE RIGHT BITS
	RETURN			; AND RETURN
NUQILG:				;
	BIT	#2000,$ACMSK	; IS TASK  LOGGING ACTIVE
	BEQ	3$		; IF EQ, NO
	PRINT	M22		; ELSE WARN USER
	JMP	ERRXIT		; EXIT WITH BAD STATUS
3$:	BIC	#1000,$ACMSK	; RESET THE BIT
	RETURN
 
 
TSKON:				; /TASK IS A STAND ALONE COMMAND
	TST	$ACMSK		; IS ACCOUNTING ALREADY RUNNING
	BNE	5$		; IF NE, YES QIO ACCOUNTING IS RUNNING, ALL OK
	PRINT	M13		; NO IT ISN'T
	JMP	ERRXIT		; SO EXIT WITH ERROR
5$:	BIT	#1000,$ACMSK	; BOTH QIO AND USER BY USER QIO ACCOUNTING MUST BE RUNNING
	BNE	10$		; IF NE, THEY ARE
	PRINT	M23		; THEY ARN'T, WARN USER BUT CONTINUE
10$:	DIR$	#RQTSK		; REQUEST TASKLOG
	BCC	15$		; ALL OK, TSKLOG INSTALLED
	PRINT 	M21		; WARN USER TSKLOG NOT INSTALLED
15$:	JMP	XIT		;
 
	.ENABL LSB
TSKOFF:				;
	CLR	ERROR		; CLEAR ALLOCATION ERROR INDICATOR
	CALL	$LOCKL		; LOCK THE SYSTEM LISTS
	MOV	#TSKLOG,R3	; GET TASK NAME ADDRESS IN R3
	CALL	$SRSTD		; SCAN THE STD FOR TSKLOG
	BCC	1$		; IF CC  ALL OK
	PRINT	M25		; NO TSKLOG
	CALL 	$UNLKL		; UNLOCK THE SYSTEM LISTS
	RETURN			; CHECK FOR MORE
1$:
	BIT	#TS.EXE,T.STAT(R0) ; IS IT ACTIVE?
	BEQ	2$		; IF EQ, IS ACTIVE SO PROCEDE
	PRINT	M26		; IS NOT ACTIVE , WARN USER
	CALL	$UNLKL		; UNLOCK THE SYSTEM LISTS
	RETURN			; NOT REALLY AN ERROR
2$:				;
	MOV	R0,R5		; SAVE TCB ADDRESS
	MOV	#BLKSIZ,R1	; GET BLOCK SIZE TO ALLOCATE
	CALL	$SWSTK,10$	; SWITCH TO SYSTEM STATE
	CALL	$ALOCB		;; GET IT
	BCS	ALLERR		;; IF C=1, THEN ALLOCATION FAILURE
	MOV	R0,R1		;; COPY BLOCK TO R1
	MOV	#1,2(R1)	;; SET WORD TO INDICATE EXIT
	MOV	R5,R0		;; RESTORE TCB ADDRESS
	CALLR	$EXRQF		;; QUEUE AND STOP TASKLOG
 
ALLERR:	INC	ERROR		;; INDICATE ERROR
	RETURN			;; AND EXIT SYSTEM STATE
 
10$:	TST	ERROR		; WAS THERE AN ERROR?
	BEQ	20$		; NO, EXIT
	PRINT	M27		; SAY THERE WAS ALLOCATION FAILURE
	CALL	$UNLKL		; UNLOCK SYSTEM LISTS
	JMP	ERRXIT		; AND EXIT WITH ERROR
20$:	CALL	$UNLKL		; UNLOCK THE SYSTEM LISTS
	BIC	#6000,$ACMSK	; ZERO BIT IN ACCOUNTING MASK
	RETURN
 
	.DSABLE	LSB
PRTSK:	BIS	#4000,ACMASK	; SET BIT TO SHOW SHOULD PRINT STATISTICS TO CO:
	RETURN			; BACK FOR MORE
NPRTSK:	BIC	#4000,ACMASK	; RESET BIT TO DISABLE PRINTING OF STATISTICS
	RETURN			; AND TRY AGAIN FOR ANOTHER COMMAND
SPOOL:	BIS	#10000,ACMASK	; SET BIT TO SHOW WE SHOULD LOG PRINT SPOOLER STATISTICS
	RETURN			; BACK FOR MORE
NSPOOL:	BIC	#10000,$ACMSK	; RESET BIT TO DISABLE LOGGING PRINT SPOOLER STATISTICS
	RETURN			; BACK FOR MORE
 
 
DIRECT:	BIS	#5,ACMASK	; WE WILL SET THESE BITS IN $ACMSK TO
				; TO ENABLE DIRECTIVE ACCOUNTING(SYSTEM WIDE)
				; NOTE THIS OPTION REQUIRES CPU TIME ACCOUNTING
	TST	$ACMSK		; IS ACCOUNTING ALREADY RUNNING
	BEQ	20$		; IF EQ 0, NO, ALL OKAY
	PRINT	M16		; WARN USER THAT THIS IS INVALID AFTER SYSLOG RUNNING
	JMP	ERRXIT		; ERROR EXIT
20$:	PRINT	M20		; *** WARN USER ITS NOT YET IMPLEMENTED IN SYSLOG
	RETURN			;
MEMORY:	BIS	#20,ACMASK	; SET TO DO MEMORY STAT. ACCOUNTING
	RETURN			;
FREMEM:	BIS	#40,ACMASK	; SET TO DO MEM. STAT ACCOUNTING ONLY IF
	RETURN			; MEMORY GETS IN BAD SHAPE
TOTPOO:	BIS	#100,ACMASK	; SET TO DO MEM STAT, ONLY IF POOL GETS IN BAD
	RETURN			; SHAPE

DELTA:
	CLR	R3		; CLEAR COUNTER
	INC	DLTFLG		; SHOW WE HAVE PASSED THIS WAY ONCE
	MOV	#DLTMIN,R0	; WHERE WE WILL PUT NUMBER
1$:	CMPB	(R5),#15	; CR IS ILLEGAL HERE
	BNE	10$		; IF NE, OK
5$:	PRINT	M7		; A CR HERE IS SYNTAX ERROR
	JMP	ERRXIT		; EXIT WITH ERROR STATUS
10$:	CMPB	(R5),#33	; AN ESC IS ALSO ILLEGAL
	BEQ	5$		; SO EXIT WITH ERROR
	CMPB	(R5),#'/	; A '/' HERE UNTIL AFTER NUMBER IS ILLEGAL
	BEQ	5$		; SO EXIT WITH ERROR IF FOUND
	CMPB	(R5)+,#':	; HAVE WE GOT ':'
	BEQ	20$		; IF EQ, YES, LOOK FOR NUMBER
	BR	1$		; AND LOOK SOME MORE
20$:				;
	CMPB	(R5),#15	; IS A <CR> RIGHT AFTER ':'
	BEQ	5$		; IF EQ, YES, SYNTAX ERROR
	CMPB	(R5),#33	; PERHAPS ITS AN ESC RIGHT AFTER ':'
	BEQ	5$		; IF EQ, YES, ITS A FATAL SYNTAX ERROR
25$:				;
	CMPB	(R5),#'0	; IS IT >=0
	BLT	50$		; IF LT, ASSUME NUMBER DONE, TRY TO CONVERT IT
	CMPB	(R5),#'9	; IS IT <=9
	BGT	5$		; IF GT 9 BEFORE ENCOUNTERING A '/', ITS A SYNTAX ERROR
	INC	R3		; KEEP TRACK OF THE NUMBER OF CHARACTERS
	CMP	R3,#5		; IS IT GREATER THAN 5
	BGT	5$		; IF YES, SYNTAX ERROR
	MOVB	(R5)+,(R0)+	; IF NO, MOVE INTO DLTMIN
	BR	25$		; GET ANOTHER NUMBER
50$:				;
	CMPB	(R5),#'/	; IS IT A '/'
	BEQ	60$		; A '/' IS OK
	CMPB	(R5),#15	; IS IT EOL
	BEQ	60$		; EOL IS OK ALSO
	CMPB	(R5),#33	; IS IT ESC
	BEQ	60$		; AN ESC FOR EOL OK ALSO
	BR	5$		; ANYTHING ELSE IS FATAL SYNTAX ERROR
60$:				;
	MOVB	#'*,(R0)	; SET A NON NUMERIC CHARACTER TO TERMINATE CONVERSION
	MOV	#DLTMIN,R0	; GET ADDRESS OF ASCII STRING
	CALL	$CDTB		; CONVERT TO DECIMAL
	MOV	R1,DLTVAL	; SET THE DELTA VALUE(IN MIN)
	TST	R1		; IS IT >0
	BNE	65$		; IF NE,YES
63$:	PRINT	M17		 ; WARN USER, DELTA VALUE IS ILLEGAL
	JMP	ERRXIT		; AND EXIT WITH ERROR
65$:	CMP	R1,#1440. 	; SAMPLE INTERVAL(IN MIN) MUST BE LESS THAN THIS
	BGT	63$		; IF GT, ERROR
	DEC	R5		; BACK UP POINTER TO BEFORE /(IF ANY)
	RETURN			;
LOGSET:	BIS	#200,ACMASK	; SET TO LOG HELLO/BYE/UPD DATA
	RETURN			;

DSPLAY:
	TST	$ACMSK		; THE SYSTEM ACCOUNT MASK
	BNE	1$		; ACCOUNTING IS STARTED, SO PROCEED
	PRINT	M3		; WARN USER , ACCOUNTING NOT STARTED
	RETURN			; ALL DONE
1$:				;
	PRINT	ACCHDR		; DISPLAY HEADER
	BIT	#1,$ACMSK	; IS CPU ACCOUNTING ENABLED
	BEQ	2$		; IF EQ, NO
	PRINT	ACCM00		; IF NE, YES, SHOW IT
2$:				;
	BIT	#2,$ACMSK	; IS QIO ACCOUNTING ENABLED?
	BEQ	3$		; IF EQ, NO
	PRINT	ACCM01		; IF NE, YES, SHOW IT
3$:	BIT	#4,$ACMSK	; IS DIRECTIVE ACCOUNTING ENABLED
	BEQ	4$		; IF EQ, NO
	PRINT	ACCM02		; IF NE, YES, SHOW IT
4$:	BIT	#10,$ACMSK	; IS GLOBAL CPU STATISTICS LOGGING ENABLED
	BEQ	5$		; IF EQ, NO
	PRINT 	ACCM03		; IF NE, YES, SHOW IT
5$:	BIT	#20,$ACMSK	; LOG ALL MEM STAT
	BEQ	6$		; IF EQ,YES
	PRINT	ACCM04		; IF NE,YES, SHOW IT
6$:	BIT	#40,$ACMSK	;  LOG MEM STATISTICS IF CORE TOO TIGHT
	BEQ	7$		; IF EQ, NO
	PRINT	ACCM05		; IF NE, YES, SHOW IT
7$:	BIT	#100,$ACMSK	; LOG MEM STAT IF POOL TO LOW
	BEQ	8$		; IF EQ, NO
	PRINT	ACCM06		; IF NE, YES, SHOWIT
8$:	BIT	#200,$ACMSK	; LOG HELLO/BYE/UPD STATISTICS
	BEQ	9$		; IF EQ, NO
	PRINT	ACCM07		; IF NE, YES,SHOW IT
9$:	BIT	#400,$ACMSK	; ** UNDEFINED
	BEQ	10$		; ** UNDEFINED
	PRINT	ACCM08		; ** UNDEFINED
10$:	BIT	#1000,$ACMSK	; ** UNDEFINED
	BEQ	11$		; ** UNDEFINED
	PRINT	ACCM09		; ** UNDEFINED
11$:	BIT	#2000,$ACMSK	; ** UNDEFINED
	BEQ	12$		; ** UNDEFINED
	PRINT	ACCM10		; ** UNDEFINED
12$:	BIT	#4000,$ACMSK	; ** UNDEFINED
	BEQ	13$		; ** UNDEFINED
	PRINT	ACCM11		; ** UNDEFINED
13$:	BIT	#10000,$ACMSK	; ** UNDEFINED
	BEQ	14$		; ** UNDEFINED
	PRINT	ACCM12		; ** UNDEFINED
14$:	BIT	#20000,$ACMSK	; ** UNDEFINED
	BEQ	15$		; ** UNDEFINED
	PRINT	ACCM13		; ** UNDEFINED
15$:	BIT	#40000,$ACMSK	; ** UNDEFINED
	BEQ	16$		; ** UNDEFINED
	PRINT	ACCM14		; ** UNDEFINED
16$:	BIT	#100000,$ACMSK	; ** UNDEFINED
	BEQ	20$		; ** UNDEFINED
	PRINT	ACCM15		; ** UNDEFINED
20$:				;
	MOV	$DELTA,R1	; GET THE SAMPLE INTERVAL VALUE
	MOV	#ACCTM,R0	; ADDRESS OF WHERE TO PLACE TIME NUMBER
	CLR	R2		; SUPPRESS LEADING ZEROS
	CALL	$CBDMG		; CONVERT TO DECIMAL ASCII
	PRINT	ACCTIM		; PRINT OUT TIME MESSAGE
	RETURN			; AND RETURN TO MAINLINE
 

;
; LOGCO  - LOG CO0: STATISTICS, REQUIRES CPU ACCOUNTING
;
LOGCO:	BIS	#401,ACMASK	; REQUIRES CPU TIME ACCOUNTING
	RETURN
 
 
	.SBTTL	DISABLE VARIOUS ACCOUNTING FEATURES ON LINE
NOLGCO:	BIC	#400,$ACMSK	; HOWEVER, MUST LEAVE CPU ACCOUNTING RUNNING
	RETURN
NOMEM:	BIC	#20,$ACMSK	; DISABLE UNCONDITIONAL MEMORY STATISTICS LOGGING
	RETURN			;
NOFREE:	BIC	#40,$ACMSK	; DISABLE LOGGING MEM STAT. IF CORE TIGHT
	RETURN			;
NOPOOL:	BIC	#100,$ACMSK	; DISABLE LOGGING MEM STAT. IF POOL <500 WORDS
	RETURN			;
NOLOG:	BIC	#200,$ACMSK	; DISABLE HELLO/BYE/UPD LOGGING TO FILE
	RETURN			;
 
 
 
	.SBTTL	ENDUP	PROCES THE COMMANDS AND EXIT
;+
; ENDUP -- PROCESS THE VARIOUS COMMANDS ISSUED ON THE COMMAND LINE
;	   AND EXIT
;
;	THE FOLLOWING RULES GOVERN ...ACC'S ACTION WITH SYSLOG.
;	1.  IF A 'STOP' COMMAND IS ISSUED, NO OTHER COMMAND ON THE
;	    LINE WILL BE EXECUTED EXCEPT STOP.  SYSLOG WILL BE ASKED TO
;	    STOP, AND THEN AN ERROR MESSAGE WILL INFORM USERS THAT THE
;	    OTHER COMMANDS ARE BEING IGNORED.
;	2.  THE /DSP COMMAND IS EXECUTED BEFORE ANY OTHER COMMAND AND
;	    SHOWS THE STATE OF THE SYSTEM ACCOUNT MASK PRIOR TO
;	    SETTING ANY BITS IN $ACMSK VIA ANY OF THE COMMANDS.  
;	    $ACMSK BITS ARE NOT SET UNTIL THIS SECTION OF CODE
;	    WHEREAS, /DSP IS PROCESSED EARLIER.
;	3.  ALL THE BIT SETTING SWITCHES ARE SET IN ONE MOV OF
;	    ACMASK TO $ACMSK.  THIS IS DONE PRIOR TO STARTING
;	    SYSLOG, OR TO SENDING IT A NEW SCHEDULING DELTA.
;	    IF ONE WANTS SYSLOG TO IMMEDIATLY RESPOND TO A NEW
;	    SETTING OF $ACMSK, ONE MUST REALIZE THAT IT WILL DO
;	    NOTHING UNTIL AFTER IT'S MARKTIME ENDS.  AFTER IT
;	    RECIEVES A CHANGE DELTA COMMAND, IT CHANGES THE 
;	    NUMBER OF MINUTES TO WAIT ON, AND THEN WAITS.
;	4.  ONE CAN SET /DLT WITH THE /START SWITCH.  IF ONE DOES
;	    NOT DO SO, DELTA DEFAULTS TO 30 MIN.
;	
;-
ENDUP:				;
	TST	STPFLG		; WAS THE COMMAND STOP?
	BEQ	20$		; NO, SKIP OVER
	TST	$ACMSK		; HAS ACCOUNTING BEEN STARTED
	BNE	5$		; IF NE, WHY YES IT WAS
	PRINT	M4		; WARN USER ACCOUNTING HAS NOT BEEN STARTED
	JMP	ERRXIT		; AND EXIT
5$:				; REF LABLE
	BIT	#2000,$ACMSK	; IS TASK ACCOUNTING RUNNING
	BEQ	7$		; IF EQ,NO
	CALL	TSKOFF		; TURN OFF TASK LOGGING(IF ACTIVE) FIRST
7$:	MOV	#1,SEND		; SO SET A 1 AS FIRST WORD OF SEND BUFFER AS
				; A FLAG TO TELL SYSOFF TO EXIT
	DIR$	#SENDAT		; SEND OFF THE DATA
	BCC	10$		; IF SEND IS OK, PROCEED TO UNSTOP
	PRINT	M2		; OH SHIT, ACCOUNTING WAS ONCE ACTIVE
				; BUT SYSLOG IS NOT INSTALLED(OR BAD DPB)
	JMP	ERRXIT		; EXIT WITH ERROR
10$:	DIR$	#UNSTOP		; UNSTOP SYSLOG
	TST	ACMASK		; DID THE USER TRY SPECIFYING OTHER SWITCHES
	BEQ	15$		; IF EQ 0, NO HE/SHE KNOWS HOW TO USE ...ACC
	PRINT 	M9		; TRIED TO USE OTHER SWITCHES, SO WARN USER
15$:	JMP	XIT		; EXIT 
20$:
	TST	STRFLG		; IS THIS THE START COMMAND?
	BEQ	24$		; IF EQ, NO
	TST	$ACMSK		; SINCE ITS THE START COMMAND $ACMSK BETTER BE ALL ZERO
	BEQ	26$		; GOOD, IT  IS
	TST	$ACCHD		; NO, IT ISN'T, DO WE HAVE A LEFT OVER CODE NODE
	BEQ	23$		; IF EQ, NO CODE NODE, JUST A SIMPLE ERROR
	PRINT	M19		; WARN USER
	INC	STRFLG		; FORCE A START
	JMP	28$		; START UP SYSLOG AGAIN, BUT LEAVE $ACMSK ALONE
23$:				; REF LABLE
	PRINT	M10		; WARN USER, ACCOUNTING SOMEHOW ALREADY ACTIVE
	JMP	ERRXIT		; AND EXIT WITH ERROR
24$:				;
	TST	ACMASK		; SEE IF ANY VALUES TO SET
	BEQ	28$		; IF EQ,NO VALUES TO SET, SO SKIP
	TST	$ACMSK		; COMMAND NOT START, SO ONLY SET NEW VALUES IF
				; ACCOUNTING ALREADY ONGOING
	BNE	26$		; ACCOUNTING IS ONGOING, CONTINUE
	PRINT	M13		; FATAL, ACCOUNTING MUST BE RUNNING FIRST
	BR	ERRXIT		; EXIT
26$:
	TST	ACMASK		; ARE ANY ACCOUNTING OPTIONS ENABLED
	BNE	27$		; IF  NE, YES, CONTINUE
	PRINT	M14		; ELSE WARN USER, THIS IS A NO, NO
	BR	ERRXIT		; AND EXIT
27$:	BIS	ACMASK,$ACMSK	; SET ANY VALUES IN SYSTEM ACCOUNT MASK WORD
28$:	MOV	#3,SEND		; ASSUME WE WILL START UP ACCOUNTING
	MOV	DLTVAL,SEND+2	; ASSUME WE WILL SEND THE NEW DELTA VALUE
	TST	STRFLG		; SHOULD WE ISSUE A START COMMAND?
	BNE	30$		; YES WE SHOULD
	MOV	#2,SEND		; MAYBE ITS A CHANGE DELTA COMMAND
	TST	DLTFLG		; IS IT DESIRED TO CHANGE SAMPLE RATE
	BEQ	XIT		; IF NE,NO JUST EXIT
30$:	DIR$	#SENDAT		; SO SEND OFF DATA
	BCC	35$		; PROCEED TO UNSTOP OR START TASK AS NEEDED
	PRINT	M2		; SYSLOG NOT INSTALLED OR WORSE
	TST	$ACCHD		; IF ACCOUNTING WAS RUNNING(BUT SYSLOG ABORTED)
	BNE	32$		; IF $ACCHD <>0,DON'T ZERO $ACMSK
	CLR	$ACMSK		; IF ACCOUNTING NEVER ACTIVE($ACCHD=0) ZERO $ACMSK
				; SO WE WON'T THINK ACCOUNTING ACTIVE
32$:	JMP	ERRXIT		; EXIT WITH SEVERE ERROR
35$:	TST	STRFLG		; IS THIS A START
	BEQ	40$		; IF EQ, NO
	DIR$	#REQST		; REQUEST SYSLOG TO RUN AT WHICH TIME IT GETS ITS
				; SEND PACKET
	BCC	XIT		; ALL OK
	PRINT 	M11		; SOMETHING'S REALY SCREWED, SYSLOG IS ACTIVE
				; OR NOT INSTALLED, WHICH SEEMS LIKE IT COULD
				; NOT POSSIBLY HAPPEN.
40$:	DIR$	#UNSTOP		; COMMAND WAS CHANGE DELTA, SO UNSTOP SYSLOG
	BCC	XIT		; ALL OK
	PRINT	M12		; COULDN'T UNSTOP SYSLOG??
	BR	ERRXIT		;
XIT:	EXST$S	#1		;
ERRXIT:	EXST$S	#4		;

 
 
 
;+
; PNTLIN
;
; THIS ROUTINE WILL PRINT AN ASCIZ LINE
;-
PNTLIN:	MOV	#-1,R1		; GET COUNT INITIALIZED
	MOV	R0,QIODPB+Q.IOPL ; STORE BUFFER ADDRESS
170$:	INC	R1		; INCREMENT COUNTER
	TSTB	(R0)+		; IS THIS THE LAST BYTE?
	BNE	170$		; NO. KEEP GOING
	MOV	R1,QIODPB+Q.IOPL+2 ; STORE BYTE COUNT
	DIR$	#QIODPB
	RETURN
 
	.END	ACC