Trailing-Edge
-
PDP-10 Archives
-
BB-H348C-RM_1982
-
swskit-v21/listings/tkb-vnp/pcor1c.bpt
There are no other files named pcor1c.bpt in the archive.
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1 !<TKB-VNP>PCOR1C.BLI.11, 13-Jun-79 07:15:58, Edit by SROBINSON
2 !<SAUTER.TKB20>PCOR1C.BLI.12, 3-May-79 06:43:39, Edit by SROBINSON
3 !<SAUTER.TKB20>PCOR1C.BLI.6, 30-Apr-79 13:06:28, Edit by SROBINSON
4 !<SAUTER.TKB20>PCOR1C.BLI.2, 24-Apr-79 08:38:52, Edit by SROBINSON
5 !<SAUTER.TKB20>PCOR1C.BLI.109, 12-Mar-79 07:35:06, Edit by SROBINSON
6 !<SAUTER.TKB20>PCOR1C.BLI.107, 6-Mar-79 06:35:09, Edit by SROBINSON
7 !<TKB-VNP>PCOR1C.BLI.3, 5-Mar-79 09:34:16, Edit by SROBINSON
8 !<SAUTER.TKB20>PCOR1C.BLI.103, 21-Feb-79 17:23:28, Edit by SROBINSON
9 !<SAUTER.TKB20>PCOR1C.BLI.102, 9-Feb-79 15:24:36, Edit by SROBINSON
10 !<SAUTER.TKB20>PCOR1C.BLI.98, 25-Jan-79 08:14:34, Edit by SROBINSON
11 !<SAUTER.TKB20>PCOR1C.BLI.96, 14-Jan-79 17:00:23, Edit by SROBINSON
12 !<SAUTER.TKB20>PCOR1C.BLI.94, 3-Jan-79 06:40:57, Edit by SROBINSON
13 !<SAUTER.TKB20>PCOR1C.BLI.87, 2-Jan-79 06:32:15, Edit by SROBINSON
14 !<SAUTER.TKB20>PCOR1C.BLI.80, 31-Dec-78 09:55:21, Edit by SROBINSON
15 !<SAUTER.TKB20>PCOR1C.BLI.77, 24-Dec-78 09:31:59, Edit by SROBINSON
16 !<SAUTER.TKB20>PCOR1C.BLI.72, 20-Dec-78 07:33:08, Edit by SROBINSON
17 !<SAUTER.TKB20>PCOR1C.BLI.69, 16-Dec-78 09:35:19, Edit by SROBINSON
18 !<SAUTER.TKB20>PCOR1C.BLI.64, 11-Dec-78 08:41:21, Edit by SROBINSON
19 !<SAUTER.TKB20>PCOR1C.BLI.56, 28-Nov-78 07:45:01, Edit by SROBINSON
20 !<SAUTER.TKB20>PCOR1C.BLI.49, 27-Nov-78 10:54:01, Edit by SROBINSON
21 !<SAUTER.TKB20>PCOR1C.BLI.46, 24-Nov-78 11:10:38, Edit by SROBINSON
22 !<SAUTER.TKB20>PCOR1C.BLI.37, 20-Nov-78 13:34:52, Edit by SROBINSON
23 !<SAUTER.TKB20>PCOR1C.BLI.29, 16-Nov-78 14:28:48, Edit by SROBINSON
24 !<SAUTER.TKB20>PCOR1C.BLI.27, 16-Nov-78 07:21:05, Edit by SROBINSON
25 !<SAUTER.TKB20>PCOR1C.BLI.16, 14-Nov-78 08:38:39, Edit by SROBINSON
26 !<SAUTER.TKB20>PCOR1C.BLI.11, 13-Nov-78 14:14:31, Edit by SROBINSON
27 !<SAUTER.TKB20>PCOR1C.BLI.9, 2-Nov-78 14:08:33, Edit by SROBINSON
28 !<SAUTER.TKB20>PCOR1C.BLI.6, 20-Oct-78 08:21:34, Edit by SROBINSON
29 !<SAUTER.TKB20>PCOR1C.BLI.5, 19-Oct-78 15:45:23, Edit by SROBINSON
30 !<SAUTER.TKB20>PCOR1C.BLI.2, 16-Oct-78 09:52:31, Edit by SROBINSON
31 MODULE PCOR1C ( !PROCESS CORE IMAGE
32 IDENT = 'X0.8'
33 ) =
34 BEGIN
35 !
36 !
37 !
38 ! COPYRIGHT (C) 1978, 1979 BY
39 ! DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
40 !
41 !
42 ! THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED
43 ! ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE
44 ! INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER
45 ! COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY
46 ! OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY
47 ! TRANSFERRED.
48 !
49 !
50 ! THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE
51 ! AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT
52 ! CORPORATION.
53 !
54 ! DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS
55 ! SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL.
56 !
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
57
58 !++
59 ! FACILITY: VNP-20
60 !
61 ! ABSTRACT:
62 !
63 !
64 ! THIS MODULE PROCESSES CORE IMAGES (KERNEL AND TASK) FOR VNP20
65 !
66 !
67 ! ENVIRONMENT: TOPS-20 USER MODE
68 !
69 ! AUTHOR: J. SAUTER, CREATION DATE: 30-MAY-78
70 !
71 ! MODIFIED BY:
72 !
73 ! Scott G. Robinson, 16-SEP-78 : VERSION X0.1-2A
74 ! - Finish Development of D_DCP
75 ! - Finish Development of D_DUP
76 ! - Develop support for NSP, DLX, AUX LLCs
77 ! - Correct minor bugs in various routines
78 !
79 ! Scott G. Robinson, 23-SEP-78 : VERSION X0.1-3A
80 ! - Split PCOR into 3 modules (PCOR0,PCOR1,PCOR2)
81 ! - Add support for passwords
82 !
83 ! Scott G. Robinson, 16-OCT-78 : VERSION X0.2
84 ! - Split PCOR1 into PCOR1A, PCOR1B, and PCOR1C so that LLC and
85 ! DDM processing can reside in seperate modules
86 !
87 ! Scott G. Robinson, 19-OCT-78 : VERSION X0.2-1, X0.2-2, X0.2-3, X0.2-4
88 ! X0.2-5, X0.2-6, X0.2-7
89 ! - Implement processing for new DDMs (LE, CR, KDZ, KDP) for
90 ! Release 4
91 ! - Implement Multipoint processing in D_DCP
92 ! - Change Method of getting storage from POOL.. partition
93 ! - Implement processing to DZ DDM
94 ! - Implement processing for KMC micro-code blocks
95 ! - Fix D_DTE for false node-init
96 ! - Fix D_DMC to set correct address of line table
97 ! - Support event logging word in DCP data base (D_DCP)
98 ! - Set location L.STIC in DCP data base for better polling performance
99 !
100 ! Scott G. Robinson, 5-MAR-79 : VERSION X0.3, X0.4
101 ! - Enable all event logging data base entries
102 ! - Support new KDZ data base
103 !
104 ! Scott G. Robinson, 24-APR-79 : VERSION X0.5, X0.6, X0.7
105 ! - Support the new DCP data base for multi-point and
106 ! point-to-point links. This is for Al's new whizmo DDCMP
107 ! module.
108 !
109 ! Scott G. Robinson, 13-JUN-79 : VERSION X0.8
110 ! - Remove some unneeded items from KDZ data base processing
111 !
112 ! , : VERSION
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
113 ! 01 -
114 !--
115
116 !<BLF/PAGE>
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
117 !
118 ! TABLE OF CONTENTS:
119 !
120
121 FORWARD ROUTINE
122 LD_DLC : NOVALUE, !BUILD DLC DATA STRUCTURES
123 SEL_CNT, !SELECT A CNT BLOCK
124 SEL_UNT, !SELECT A UNT BLOCK
125 LD_DDM : NOVALUE, !BUILD DDM DATA STRUCTURES
126 D_DTE : NOVALUE, !BUILD DATA AREA FOR DTE20
127 D_DUP : NOVALUE, !BUILD DATA AREA FOR DUP11
128 D_DMC : NOVALUE, !BUILD DATA AREA FOR DMC11
129 D_LE : NOVALUE, !BUILD DATA AREA FOR LP11
130 D_CR : NOVALUE, !BUILD DATA AREA FOR CR11
131 D_KDZ : NOVALUE, !BUILD DATA AREA FOR KMC/DZ11
132 D_KDP : NOVALUE, !BUILD DATA AREA FOR KMC/DUP11
133 D_DZ : NOVALUE, !BUILD DATA AREA FOR DZ11
134 D_DCP : NOVALUE, !BUILD DATA AREA FOR DCP
135 SEL_STA, !BUILD STATION TABLES
136 SEL_SLT, !SELECT THE CORRECT SLT_BLOCK
137 SEL_KDZ, !BUILD KDZ LINE TABLES
138 SEL_KDP, !BUILD KDP LINE TABLES
139 SEL_DZ, !BUILD DZ LINE TABLES
140 KMC_MICRO : NOVALUE; !BUILD KMC MICRO-CODE BLOCKS
141
142 !
143 ! INCLUDE FILES:
144 !
145
146 LIBRARY 'VNP-LIB.L36';
147
148 !REQUIRE 'BLOCKH.REQ'; !PREPARE TO DEFINE STORAGE BLOCKS
149 !REQUIRE 'FILE.REQ'; !DEFINE FILE BLOCK
150 !REQUIRE 'VNPVAL.REQ'; !VALUE BLOCK FOR VNP20
151 !REQUIRE 'LLC.REQ'; !DEFINE LLC BLOCK
152 !REQUIRE 'DLC.REQ'; !DEFINE DLC BLOCK
153 !REQUIRE 'DDM.REQ'; !DEFINE DDM BLOCK
154 !REQUIRE 'LIBR.REQ'; !DEFINE LIBRARY BLOCK
155 !REQUIRE 'BLOCKT.REQ'; !END OF DEFINING STORAGE BLOCKS
156 !REQUIRE 'TSKDEF.REQ'; !DEFINE TASK OFFSETS
157 !
158 ! MACROS:
159 !
160 ! NONE
161 !
162 ! EQUATED SYMBOLS:
163 !
164
165 LITERAL
166 DEBUG = 0;
167
168 !
169 ! OWN STORAGE:
170 !
171 ! NONE
172 !
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
173 ! EXTERNAL REFERENCES:
174 !
175
176 EXTERNAL ROUTINE
177 R50TOA : NOVALUE, !CONVERT RADIX50_11 TO ASCII
178 ATOR50 : NOVALUE, !CONVERT ASCII TO RADIX-50
179 OUTPUT : NOVALUE, !WRITE ON A FILE
180 RSTB : NOVALUE, !READ SYMBOL TABLE
181 RCOR : NOVALUE, !READ CORE IMAGE
182 FCOR : NOVALUE, !FREE CORE IMAGE
183 PCRLF : NOVALUE, !PRINT CR THEN LF
184 OUTSTR : NOVALUE, !PRINT A STRING
185 OUTNUM : NOVALUE, !PRINT A NUMBER
186 ERROR : NOVALUE, !SIGNAL PROGRAMMING ERROR
187 ERRMSG : NOVALUE, !ERROR MESSAGE
188 SYM_VAL, !OBTAIN VALUE OF A SYMBOL
189 GETBLK, !GET A BLOCK OF STORAGE
190 FREBLK : NOVALUE, !FREE A BLOCK OF STORAGE
191 FND_CHAIN, !"FIND" AN ITEM IN A CHAIN
192 GETBYT, !GET A PDP-11 BYTE
193 GETWRD, !GET A PDP-11 WORD
194 PUTBYT : NOVALUE, !PUT A PDP-11 BYTE
195 PUTWRD : NOVALUE, !PUT A PDP-11 WORD
196 ALOCB, !ALLOCATE PDP-11 CORE
197 ALOC_POOL, !ALLOCATE FROM POOL.. PARTITION
198 M_PCB, !MAKE A PCB
199 GET_LIBR, !LOAD A LIBRARY ROUTINE
200 GET_BIN, !LOAD A BIN ROUTINE
201 VRBL_SYM; !OBTAIN VALUE OF A DEVICE DRIVER SYMBOL
202
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
203 GLOBAL ROUTINE LD_DLC (KERNEL_FILE, FILE_CHAN, GEN_PCB, PDV_ADDR, SLT_ADDR, DDM_PTR, DLC_PTR, VALUES) :
204 NOVALUE = !BUILD DLC DATA BASE
205
206 !++
207 ! FUNCTIONAL DESCRIPTION:
208 !
209 ! BUILD THE DATA BASE FOR A DLC.
210 !
211 ! FORMAL PARAMETERS:
212 !
213 ! KERNEL_FILE - FILE BLOCK FOR THE KERNEL TO BE MODIFIED
214 ! FILE_CHAN - CHANNEL ON WHICH TO READ THE PROCESS' FILES
215 ! GEN_PCB - PDP-11 ADDRESS OF THE PCB FOR THE SYSTEM-CONTROLLED PARTITION
216 ! PDV_ADDR - PDP-11 ADDRESS OF THE PDV FOR THE PROCESS
217 ! SLT_ADDR - PDP-11 ADDRESS OF THE SYSTEM LINE TABLE ENTRY
218 ! DDM_PTR - THE DDM BLOCK FOR THIS LINE, OR 0
219 ! DLC_PTR - THE DLC BLOCK FOR THIS LINE
220 ! VALUES - A VECTOR OF LOTS OF THINGS FOR VNP20
221 !
222 ! IMPLICIT INPUTS:
223 !
224 ! NONE
225 !
226 ! IMPLICIT OUTPUTS:
227 !
228 ! NONE
229 !
230 ! ROUTINE VALUE:
231 !
232 ! NONE
233 !
234 ! SIDE EFFECTS
235 !
236 ! MODIFIES THE KERNEL
237 !
238 !--
239
240 BEGIN
241
242 BIND
243 ROUTINE_NAME = UPLIT (%ASCIZ'LD_DLC');
244
245 MAP
246 KERNEL_FILE : REF FILE_BLOCK,
247 DDM_PTR : REF DDM_BLOCK,
248 DLC_PTR : REF DLC_BLOCK,
249 VALUES : REF VNPVAL_BLOCK;
250
251 LOCAL
252 PROCESS_LABEL : REF VECTOR [1024],
253 PROCESS_BASE,
254 PROCESS_TOP,
255 PROCESS_SIZE,
256 PROCESS_FLAGS,
257 PARTITION_NAME : VECTOR [CH$ALLOCATION (7)],
258 PARTITION_BASE,
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
259 PCB_ADDR,
260 FILE_PTR : REF FILE_BLOCK,
261 CNT_PTR : REF CNT_BLOCK,
262 CNTLNO,
263 UNT_PTR : REF UNT_BLOCK,
264 UNITNO;
265
266 !
267 ! GET A FILE BLOCK FOR LOADING THE FILE
268 !
269 FILE_PTR = GETBLK (FILE_TYP, FILE_LEN);
270 !
271 ! BUILD THE NAME OF THE PROCESS, IN ASCII.
272 ! THIS IS USED AS THE FILE NAME.
273 !
274 R50TOA ((GETWRD (.KERNEL_FILE, .PDV_ADDR + .VALUES [Z_NAM])^16), FILE_PTR [FILE_NAME]);
275 !
276 ! WE ONLY WHAT THE FIRST THREE CHARACTERS OF THE NAME.
277 !
278 CH$FILL (0, 3, CH$PTR (FILE_PTR [FILE_NAME], 3));
279 !
280 ! READ IN THE SYMBOL TABLE AND CORE IMAGE
281 !
282 RSTB (.FILE_CHAN, .FILE_PTR);
283 RCOR (.FILE_PTR, .FILE_CHAN, 4*2048);
284 !
285 ! ALLOCATE A PCB, UNLESS WE ALREADY HAVE ONE..
286 !
287 PCB_ADDR = GETWRD (.KERNEL_FILE, .PDV_ADDR + .VALUES [Z_PCB]);
288
289 IF (.PCB_ADDR EQL 0)
290 THEN
291 BEGIN
292 PROCESS_LABEL = .FILE_PTR [FILE_LABEL];
293 PROCESS_BASE = .PROCESS_LABEL [L$BSA] + (.PROCESS_LABEL [L$BSA + 1]*256);
294 PROCESS_TOP = .PROCESS_LABEL [L$BHGV] + (.PROCESS_LABEL [L$BHGV + 1]*256);
295 PROCESS_SIZE = .PROCESS_TOP - .PROCESS_BASE + 1;
296 !
297 ! THE PARTITION NAME IS OF THE FORM "NT.XXX".
298 !
299 CH$COPY (3, CH$PTR (UPLIT (%ASCII'NT.')), 3, CH$PTR (FILE_PTR [FILE_NAME]), 0, 7,
300 CH$PTR (PARTITION_NAME));
301 PARTITION_BASE = .KERNEL_FILE [FILE_HWM] + 1;
302 PCB_ADDR = M_PCB (.KERNEL_FILE, PARTITION_NAME, .GEN_PCB, .PARTITION_BASE,
303 .PARTITION_BASE + .PROCESS_SIZE - 1, %O'000000',
304 .VALUES [PS_SYS] OR .VALUES [PS_COM] OR .VALUES [PS_NSF], 0, .VALUES);
305 !
306 ! COPY THE PROCESS TEXT INTO THE PARTITION
307 !
308
309 INCR COUNTER FROM 0 TO .PROCESS_SIZE - 1 DO
310 PUTBYT (.KERNEL_FILE, .PARTITION_BASE + .COUNTER, GETBYT (.FILE_PTR, .PROCESS_BASE + .COUNTER));
311
312 !
313 ! FILL IN SOME FIELDS IN THE PDV
314 !
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
315 PUTWRD (.KERNEL_FILE, .PDV_ADDR + .VALUES [Z_PCB], .PCB_ADDR);
316 PUTWRD (.KERNEL_FILE, .PDV_ADDR + .VALUES [Z_DSP], .PARTITION_BASE/64);
317 PUTWRD (.KERNEL_FILE, .PDV_ADDR + .VALUES [Z_DSP] + 2,
318 VRBL_SYM (.FILE_PTR, 3,
319 UPLIT (%ASCIZ'$\\\TB'), 0));
320 END;
321
322 !
323 ! FIND THE CORRECT CONTROLLER AND UNIT ON THIS DLC
324 !
325 CNTLNO = GETBYT (.KERNEL_FILE, .SLT_ADDR + .VALUES [L_CTL]);
326
327 IF ((CNT_PTR = FND_CHAIN (.DDM_PTR [DDM_CNT], SEL_CNT, .CNTLNO)) EQL 0)
328 THEN
329 ERROR (UPLIT (%ASCIZ' MISSING CONTROLLER - LD_DLC'));
330
331 UNITNO = GETBYT (.KERNEL_FILE, .SLT_ADDR + .VALUES [L_UNT]);
332
333 IF ((UNT_PTR = FND_CHAIN (.CNT_PTR [CNT_UNT], SEL_UNT, .UNITNO)) EQL 0)
334 THEN
335 ERROR (UPLIT (%ASCIZ' UNIT MISSING - LD_DLC'));
336
337 !
338 ! RATHER THAN READ A FILE, WE DISPATCH TO A ROUTINE WHICH CREATES
339 ! THE DLC DATA.
340 !
341
342 IF (CH$EQL (3, CH$PTR (FILE_PTR [FILE_NAME]), 3, CH$PTR (UPLIT (%ASCIZ'DCP'))))
343 THEN
344 D_DCP (.KERNEL_FILE,
345 .FILE_CHAN, .FILE_PTR, .PDV_ADDR, .SLT_ADDR, .PCB_ADDR, .DLC_PTR, .DDM_PTR, .CNT_PTR, .UNT_PTR,
346 .VALUES)
347 ELSE
348 ERRMSG (0, 37, ROUTINE_NAME, FILE_PTR [FILE_NAME], 0, 0, 0);
349
350 !
351 ! FREE THE FILE
352 !
353 FCOR (.FILE_PTR);
354 !
355 END; !OF LD_DLC
356
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
357 ROUTINE SEL_CNT (CNT_PTR, CNTLNO) = !SELECT A CNT BLOCK
358
359 !++
360 ! FUNCTIONAL DESCRIPTION:
361 !
362 ! SELECT THE CNT (CONTROLLER) BLOCK WHICH CORRESPONDS TO THE
363 ! CONTROLLER NUMBER SPECIFIED
364 !
365 ! FORMAL PARAMETERS:
366 !
367 ! CNT_PTR - POINTER TO THE CNT BLOCK TO BE TESTED
368 ! CNTLNO - NUMBER OF THE CONTROLLER WANTED
369 !
370 ! IMPLICIT INPUTS:
371 !
372 ! NONE
373 !
374 ! IMPLICIT OUTPUTS:
375 !
376 ! NONE
377 !
378 ! ROUTINE VALUE:
379 !
380 ! 0 = NOT SUITABLE, OTHERWISE A POINTER TO THE CNT BLOCK
381 !
382 ! SIDE EFFECTS
383 !
384 ! NONE
385 !
386 !--
387
388 BEGIN
389
390 BIND
391 ROUTINE_NAME = UPLIT (%ASCIZ'SEL_CNT');
392
393 MAP
394 CNT_PTR : REF CNT_BLOCK;
395
396 IF (.CNT_PTR [CNT_CONT] EQL .CNTLNO) THEN .CNT_PTR ELSE 0
397
398 END; !OF SEL_CNT
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
399 ROUTINE SEL_UNT (UNT_PTR, UNITNO) = !SELECT A UNT BLOCK
400
401 !++
402 ! FUNCTIONAL DESCRIPTION:
403 !
404 ! SELECT THE UNT (UNIT) BLOCK WHICH CORRESPONDS TO THE
405 ! UNIT NUMBER SPECIFIED
406 !
407 ! FORMAL PARAMETERS:
408 !
409 ! UNT_PTR - POINTER TO THE UNT BLOCK TO BE TESTED
410 ! UNITNO - NUMBER OF THE UNIT WANTED
411 !
412 ! IMPLICIT INPUTS:
413 !
414 ! NONE
415 !
416 ! IMPLICIT OUTPUTS:
417 !
418 ! NONE
419 !
420 ! ROUTINE VALUE:
421 !
422 ! 0 = NOT SUITABLE, OTHERWISE A POINTER TO THE UNT BLOCK
423 !
424 ! SIDE EFFECTS
425 !
426 ! NONE
427 !
428 !--
429
430 BEGIN
431
432 BIND
433 ROUTINE_NAME = UPLIT (%ASCIZ'SEL_UNT');
434
435 MAP
436 UNT_PTR : REF UNT_BLOCK;
437
438 IF (.UNT_PTR [UNT_UNIT] EQL .UNITNO) THEN .UNT_PTR ELSE 0
439
440 END; !OF SEL_UNT
441
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
442 GLOBAL ROUTINE LD_DDM (KERNEL_FILE, FILE_CHAN, GEN_PCB, PDV_ADDR, SLT_ADDR, DDM_PTR, DLC_PTR, VALUES) :
443 NOVALUE = !BUILD DDM DATA BASE
444
445 !++
446 ! FUNCTIONAL DESCRIPTION:
447 !
448 ! BUILD THE DATA BASE FOR A DDM
449 !
450 ! FORMAL PARAMETERS:
451 !
452 ! KERNEL_FILE - FILE BLOCK FOR THE KERNEL TO BE MODIFIED
453 ! FILE_CHAN - CHANNEL NUMBER ON WHICH TO READ THE DDM
454 ! GEN_PCB - PDP-11 ADDRESS OF THE SYSTEM-CONTROLLED PARTITION'S PCB
455 ! PDV_ADDR - PDP-11 ADDRESS OF THE PDV FOR THE PROCESS
456 ! SLT_ADDR - PDP-11 ADDRESS OF THE SYSTEM LINE TABLE ENTRY
457 ! DDM_PTR - BLOCK OF INFO FROM THE DDM$DF LINE OF CETAB.MAC
458 ! DLC_PTR - BLOCK OF INFO FROM THE DLC$DF LINE OF CETAB.MAC, OR 0
459 ! VALUES - A VECTOR OF LOTS OF THINGS FOR VNP20
460 !
461 ! IMPLICIT INPUTS:
462 !
463 ! NONE
464 !
465 ! IMPLICIT OUTPUTS:
466 !
467 ! NONE
468 !
469 ! ROUTINE VALUE:
470 !
471 ! NONE
472 !
473 ! SIDE EFFECTS
474 !
475 ! MODIFIES THE KERNEL
476 !
477 !--
478
479 BEGIN
480
481 BIND
482 ROUTINE_NAME = UPLIT (%ASCIZ'LD_DDM');
483
484 MAP
485 KERNEL_FILE : REF FILE_BLOCK,
486 DDM_PTR : REF DDM_BLOCK,
487 VALUES : REF VNPVAL_BLOCK;
488
489 LOCAL
490 PROCESS_LABEL : REF VECTOR [1024],
491 PROCESS_BASE,
492 PROCESS_TOP,
493 PROCESS_SIZE,
494 PROCESS_FLAGS,
495 PARTITION_NAME : VECTOR [CH$ALLOCATION (7)],
496 PARTITION_BASE,
497 PCB_ADDR,
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
498 CNT_PTR : REF CNT_BLOCK,
499 CNTLNO,
500 UNT_PTR : REF UNT_BLOCK,
501 UNITNO,
502 FILE_PTR : REF FILE_BLOCK;
503
504 !
505 ! GET A FILE BLOCK FOR LOADING THE FILE
506 !
507 FILE_PTR = GETBLK (FILE_TYP, FILE_LEN);
508 !
509 ! BUILD THE NAME OF THE PROCESS, IN ASCII.
510 ! THIS IS USED AS THE FILE NAME.
511 !
512 R50TOA ((GETWRD (.KERNEL_FILE, .PDV_ADDR + .VALUES [Z_NAM])^16), FILE_PTR [FILE_NAME]);
513 !
514 ! WE ONLY WANT THE FIRST THREE CHARACTERS OF THE NAME.
515 !
516 CH$FILL (0, 3, CH$PTR (FILE_PTR [FILE_NAME], 3));
517 !
518 ! READ IN THE SYMBOL TABLE AND CORE IMAGE
519 !
520 RSTB (.FILE_CHAN, .FILE_PTR);
521 RCOR (.FILE_PTR, .FILE_CHAN, 4*2048);
522 !
523 ! GET THE INFORMATION FROM THE CETAB.MAC ENTRIES
524 !
525 !
526 ! ALLOCATE A PCB, UNLESS WE ALREADY HAVE ONE.
527 !
528 PCB_ADDR = GETWRD (.KERNEL_FILE, .PDV_ADDR + .VALUES [Z_PCB]);
529
530 IF (.PCB_ADDR EQL 0)
531 THEN
532 BEGIN
533 PROCESS_LABEL = .FILE_PTR [FILE_LABEL];
534 PROCESS_BASE = .PROCESS_LABEL [L$BSA] + (.PROCESS_LABEL [L$BSA + 1]*256);
535 PROCESS_TOP = .PROCESS_LABEL [L$BHGV] + (.PROCESS_LABEL [L$BHGV + 1]*256);
536 PROCESS_SIZE = .PROCESS_TOP - .PROCESS_BASE + 1;
537 !
538 ! THE PARTITION NAME IS OF THE FORM "NT.XXX".
539 !
540 CH$COPY (3, CH$PTR (UPLIT (%ASCII'NT.')), 3, CH$PTR (FILE_PTR [FILE_NAME]), 0, 7,
541 CH$PTR (PARTITION_NAME));
542 PARTITION_BASE = .KERNEL_FILE [FILE_HWM] + 1;
543 PCB_ADDR = M_PCB (.KERNEL_FILE, PARTITION_NAME, .GEN_PCB, .PARTITION_BASE,
544 .PARTITION_BASE + .PROCESS_SIZE - 1, %O'000000',
545 .VALUES [PS_SYS] OR .VALUES [PS_COM] OR .VALUES [PS_NSF], 0, .VALUES);
546 !
547 ! COPY THE PROCESS TEXT INTO THE PARTITION
548 !
549
550 INCR COUNTER FROM 0 TO .PROCESS_SIZE - 1 DO
551 PUTBYT (.KERNEL_FILE, .PARTITION_BASE + .COUNTER, GETBYT (.FILE_PTR, .PROCESS_BASE + .COUNTER));
552
553 !
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
554 ! FILL IN SOME FIELDS IN THE PDV
555 !
556 PUTWRD (.KERNEL_FILE, .PDV_ADDR + .VALUES [Z_PCB], .PCB_ADDR);
557 PUTWRD (.KERNEL_FILE, .PDV_ADDR + .VALUES [Z_DSP], .PARTITION_BASE/64);
558 PUTWRD (.KERNEL_FILE, .PDV_ADDR + .VALUES [Z_DSP] + 2,
559 (IF (CH$EQL (1,
560 CH$PTR (FILE_PTR [FILE_NAME],
561 2), 1, CH$PTR (UPLIT (%ASCIZ' ')), 0)) THEN VRBL_SYM (.FILE_PTR, 2,
562 UPLIT (%ASCIZ'$\\TB '), 0) ELSE VRBL_SYM (.FILE_PTR, 3, UPLIT (%ASCIZ'$\\\TB'), 0)));
563 END;
564
565 !
566 ! FIND THE CORRECT CONTROLLER AND UNIT ON THIS DDM
567 !
568 CNTLNO = GETBYT (.KERNEL_FILE, .SLT_ADDR + .VALUES [L_CTL]);
569
570 IF ((CNT_PTR = FND_CHAIN (.DDM_PTR [DDM_CNT], SEL_CNT, .CNTLNO)) EQL 0)
571 THEN
572 ERRMSG (0, 40, ROUTINE_NAME,
573 UPLIT (%ASCIZ'CNT$DF for DDM'), .DDM_PTR [DDM_NAME], 0, 0);
574
575 UNITNO = GETBYT (.KERNEL_FILE, .SLT_ADDR + .VALUES [L_UNT]);
576
577 IF ((UNT_PTR = FND_CHAIN (.CNT_PTR [CNT_UNT], SEL_UNT, .UNITNO)) EQL 0)
578 THEN
579 ERRMSG (0, 40, ROUTINE_NAME,
580 UPLIT (%ASCIZ'UNT$DF for DDM'), .DDM_PTR [DDM_NAME], UPLIT (%ASCIZ'and CNT$DF'), .CNTLNO);
581
582 !
583 ! BUILD THE DATA BASE. RATHER THAN READ A FILE WE DISPATCH TO
584 ! A ROUTINE THAT CREATES THE DATA DIRECTLY.
585 !
586
587 IF (CH$EQL (3, CH$PTR (FILE_PTR [FILE_NAME]), 3, CH$PTR (UPLIT (%ASCIZ'DTE')), 0))
588 THEN
589 D_DTE (.KERNEL_FILE, .FILE_CHAN, .FILE_PTR, .PDV_ADDR, .SLT_ADDR, .PCB_ADDR, .DDM_PTR, .CNT_PTR,
590 .UNT_PTR, .VALUES)
591 ELSE
592
593 IF (CH$EQL (3, CH$PTR (FILE_PTR [FILE_NAME]), 3, CH$PTR (UPLIT (%ASCIZ'DUP')), 0))
594 THEN
595 D_DUP (.KERNEL_FILE, .FILE_CHAN, .FILE_PTR, .PDV_ADDR, .SLT_ADDR, .PCB_ADDR, .DDM_PTR, .CNT_PTR,
596 .UNT_PTR, .VALUES)
597 ELSE
598
599 IF (CH$EQL (3, CH$PTR (FILE_PTR [FILE_NAME]), 3, CH$PTR (UPLIT (%ASCIZ'DMC')), 0))
600 THEN
601 D_DMC (.KERNEL_FILE, .FILE_CHAN, .FILE_PTR, .PDV_ADDR, .SLT_ADDR, .PCB_ADDR, .DDM_PTR,
602 .CNT_PTR, .UNT_PTR, .VALUES)
603 ELSE
604
605 IF (CH$EQL (2, CH$PTR (FILE_PTR [FILE_NAME]), 2, CH$PTR (UPLIT (%ASCIZ'LE')), 0))
606 THEN
607 D_LE (.KERNEL_FILE, .FILE_CHAN, .FILE_PTR, .PDV_ADDR, .SLT_ADDR, .PCB_ADDR, .DDM_PTR,
608 .CNT_PTR, .UNT_PTR, .VALUES)
609 ELSE
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
610
611 IF (CH$EQL (2, CH$PTR (FILE_PTR [FILE_NAME]), 2, CH$PTR (UPLIT (%ASCIZ'CR')), 0))
612 THEN
613 D_CR (.KERNEL_FILE, .FILE_CHAN, .FILE_PTR, .PDV_ADDR, .SLT_ADDR, .PCB_ADDR, .DDM_PTR,
614 .CNT_PTR, .UNT_PTR, .VALUES)
615 ELSE
616
617 IF (CH$EQL (3, CH$PTR (FILE_PTR [FILE_NAME]), 3, CH$PTR (UPLIT (%ASCIZ'KDZ')), 0))
618 THEN
619 D_KDZ (.KERNEL_FILE, .FILE_CHAN, .FILE_PTR, .PDV_ADDR, .SLT_ADDR, .PCB_ADDR,
620 .DDM_PTR, .CNT_PTR, .UNT_PTR, .VALUES)
621 ELSE
622
623 IF (CH$EQL (3, CH$PTR (FILE_PTR [FILE_NAME]), 3, CH$PTR (UPLIT (%ASCIZ'KDP')), 0))
624
625 THEN
626 D_KDP (.KERNEL_FILE, .FILE_CHAN, .FILE_PTR, .PDV_ADDR, .SLT_ADDR, .PCB_ADDR,
627 .DDM_PTR, .CNT_PTR, .UNT_PTR, .VALUES)
628 ELSE
629
630 IF (CH$EQL (2, CH$PTR (FILE_PTR [FILE_NAME]), 2, CH$PTR (UPLIT (%ASCIZ'DZ')),
631 0))
632 THEN
633 D_DZ (.KERNEL_FILE, .FILE_CHAN, .FILE_PTR, .PDV_ADDR, .SLT_ADDR,
634 .PCB_ADDR, .DDM_PTR, .CNT_PTR, .UNT_PTR, .VALUES)
635 ELSE
636 ERRMSG (0, 36, ROUTINE_NAME, FILE_PTR [FILE_NAME], 0, 0, 0);
637
638 !
639 ! FREE THE FILE BLOCK, ETC.
640 !
641 FCOR (.FILE_PTR);
642 END; !OF LD_DDM
643
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
644 ROUTINE D_DTE (KERNEL_FILE, FILE_CHAN, FILE_PTR, PDV_ADDR, SLT_ADDR, PCB_ADDR, DDM_PTR, CNT_PTR, UNT_PTR,
645 VALUES) : NOVALUE = !CREATE DATA BASE FOR DTE
646
647 !++
648 ! FUNCTIONAL DESCRIPTION:
649 !
650 ! CREATE THE DATA BASE FOR THE DTE
651 !
652 ! FORMAL PARAMETERS:
653 !
654 ! KERNEL_FILE - POINTER TO THE FILE WHICH HOLDS THE KERNEL
655 ! FILE_CHAN - CHANNEL FOR LOADING LIBARIES (NOT USED)
656 ! FILE_PTR - POINTER TO THE FILE WHICH HAS THE DDM SYMBOLS
657 ! PDV_ADDR - PDP-11 ADDRESS OF THE PROCESS DESCRIPTOR VECTOR
658 ! SLT_ADDR - PDP-11 ADDRESS OF THE ENTRY IN THE SYSTEM LINE TABLE
659 ! PCB_ADDR - PDP-11 ADDRESS OF THE PARTITION CONTROL BLOCK
660 ! DDM_PTR - BLOCK OF INFO FROM THE DDM$DF LINE OF CETAB.MAC
661 ! CNT_PTR - BLOCK OF INFO FROM THE CNT$DF LINE OF CETAB.MAC
662 ! UNT_PTR - BLOCK OF INFO FROM THE UNT$DF LINE OF CETAB.MAC
663 ! VALUES - BLOCK OF LOTS OF GOOD THINGS FOR VNP20
664 !
665 ! IMPLICIT INPUTS:
666 !
667 ! NONE
668 !
669 ! IMPLICIT OUTPUTS:
670 !
671 ! STORES A POINTER TO THE DATA CREATED IN THE PDV
672 !
673 ! ROUTINE VALUE:
674 !
675 ! NONE
676 !
677 ! SIDE EFFECTS
678 !
679 ! MODIFIES THE KERNEL
680 !
681 !--
682
683 BEGIN
684
685 BIND
686 ROUTINE_NAME = UPLIT (%ASCIZ'D_DTE');
687
688 MAP
689 KERNEL_FILE : REF FILE_BLOCK,
690 FILE_PTR : REF FILE_BLOCK,
691 DDM_PTR : REF DDM_BLOCK,
692 CNT_PTR : REF CNT_BLOCK,
693 UNT_PTR : REF UNT_BLOCK,
694 VALUES : REF VNPVAL_BLOCK;
695
696 LOCAL
697 DTE_DATA_ADDR,
698 SLT_OFFSET,
699 SLT_NUMBER,
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
700 LOC;
701
702 !
703 ! ALLOCATE SPACE TO HOLD THE DATA
704 !
705 DTE_DATA_ADDR = ALOCB (.KERNEL_FILE, 102, 1, .VALUES);
706 !
707 ! SET UP "LOC" AS A POINTER FOR STORING DATA INTO THIS BLOCK
708 !
709 LOC = .DTE_DATA_ADDR;
710 !
711 ! NOW CREATE THE DATA. THIS HAS BEEN CODED FROM THE FILE "DTE.DAT"
712 ! IN DECNET-11M.
713 !
714 ! COMM/EXEC TIMER - L.TIM: BYTE 1
715 !
716 PUTBYT (.KERNEL_FILE, .LOC, 1);
717 LOC = .LOC + 1;
718 !
719 ! DTE20 CONTROL NUMBER - L.UNT: .CNB
720 !
721 PUTBYT (.KERNEL_FILE, .LOC, GETBYT (.KERNEL_FILE, .SLT_ADDR + .VALUES [L_CTL]));
722 LOC = .LOC + 1;
723 LOC = ((.LOC + 1) AND ( NOT 1)); !.EVEN
724 !
725 ! INTERRUPT VECTOR CONTROL BLOCK - L.IVC: .INT $DTEIS
726 !
727 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR], .LOC);
728 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR] + 2, 7*32);
729 !
730 ! NOW COMPILE INSTRUCTIONS, AS FOLLOWS:
731 !
732 ! MOV @#KIASR5,-(SP)
733 ! MOV #BIAS,@#KIASR5
734 ! JSR R5,@#DTEIS
735 !
736 PUTWRD (.KERNEL_FILE, .LOC, %O'13746');
737 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'172352');
738 LOC = .LOC + 4;
739 PUTWRD (.KERNEL_FILE, .LOC, %O'12737');
740 PUTWRD (.KERNEL_FILE, .LOC + 2, GETWRD (.KERNEL_FILE, .PCB_ADDR + .VALUES [P_REL]));
741 PUTWRD (.KERNEL_FILE, .LOC + 4, %O'172352');
742 LOC = .LOC + 6;
743 PUTWRD (.KERNEL_FILE, .LOC, %O'4537');
744 PUTWRD (.KERNEL_FILE, .LOC + 2, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'$DTEIS'), 0));
745 LOC = .LOC + 4;
746 !
747 ! INTERRUPT CCB FOR DDM ==> DLC - L.ICB: .WORD 0
748 !
749 LOC = .LOC + 2;
750 !
751 ! EXTERNAL PAGE ADDRESS OF DTE20 STATUS REGISTER - L.CST: .CSR+34
752 !
753 PUTWRD (.KERNEL_FILE, .LOC, .CNT_PTR [CNT_CSR] + %O'34');
754 LOC = .LOC + 2;
755 !
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
756 ! LINE STATUS - L.STS: .WORD 0
757 !
758 LOC = .LOC + 2;
759 !
760 ! SYSTEM LINE NUMBER - L.SLN: .SLNW
761 !
762 SLT_OFFSET = .SLT_ADDR - GETWRD (.KERNEL_FILE, .VALUES [SLTTA]);
763 SLT_NUMBER = .SLT_OFFSET/.VALUES [L_LEN];
764 PUTWRD (.KERNEL_FILE, .LOC, .SLT_NUMBER);
765 LOC = .LOC + 2;
766 !
767 ! PENDING STATUS WORD TO BE SENT TO HLP - L.PSW: .WORD 0
768 !
769 LOC = .LOC + 2;
770 !
771 ! EVENT LOGGING DESTINATION - L.LOG: .WORD 0
772 !
773 LOC = .LOC + 2;
774 !
775 ! PENDING CONTROL FUNCTION QUEUE - L.PCQ: .LSTHD
776 !
777 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
778 LOC = .LOC + 4;
779 !
780 ! SEVERAL ZERO WORDS AND BYTES
781 !
782 LOC = ((.LOC + 20) AND ( NOT 1));
783 !
784 ! FREE RECEIVE BUFFER QUEUE - L.RFQ: .LSTHD
785 !
786 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
787 LOC = .LOC + 4;
788 !
789 ! SEVERAL MORE ZERO WORDS
790 !
791 LOC = .LOC + 20;
792 !
793 ! THIRD WORD OF TO-HIM STATUS WORD
794 !
795 PUTWRD (.KERNEL_FILE, .LOC, 2);
796 LOC = .LOC + 2;
797 !
798 ! TRANSMIT QUEUE - L.XMQ: .LSTHD
799 !
800 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
801 LOC = .LOC + 4;
802 !
803 ! THE REST OF THE DATA BASE IS ZERO SO DON'T NEED TO FILL IT IN
804 !
805 ! ENABLE THE DTE FOR EVENT LOGGING
806 !
807 PUTWRD (.KERNEL_FILE, .DTE_DATA_ADDR + SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'L.LOG '), 0), .VALUES [PD_NSP]^8)
808 ;
809 !
810 ! FINALLY, STORE A POINTER TO THE DATA IN THE SLT
811 !
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
812 PUTWRD (.KERNEL_FILE, .SLT_ADDR + .VALUES [L_DDS], .DTE_DATA_ADDR);
813 END; !OF D_DTE
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
814 ROUTINE D_DUP (KERNEL_FILE, FILE_CHAN, FILE_PTR, PDV_ADDR, SLT_ADDR, PCB_ADDR, DDM_PTR, CNT_PTR, UNT_PTR,
815 VALUES) : NOVALUE = !CREATE DATA BASE FOR DUP
816
817 !++
818 ! FUNCTIONAL DESCRIPTION:
819 !
820 ! CREATE THE DATA BASE FOR THE DUP
821 !
822 ! FORMAL PARAMETERS:
823 !
824 ! KERNEL_FILE - POINTER TO THE FILE WHICH HOLDS THE KERNEL
825 ! FILE_CHAN - CHANNEL FOR LOADING LIBARIES
826 ! FILE_PTR - POINTER TO THE FILE WHICH HAS THE DDM SYMBOLS
827 ! PDV_ADDR - PDP-11 ADDRESS OF THE PROCESS DESCRIPTOR VECTOR
828 ! SLT_ADDR - PDP-11 ADDRESS OF THE ENTRY IN THE SYSTEM LINE TABLE
829 ! PCB_ADDR - PDP-11 ADDRESS OF THE PARTITION CONTROL BLOCK
830 ! DDM_PTR - BLOCK OF INFO FROM THE DDM$DF LINE OF CETAB.MAC
831 ! CNT_PTR - BLOCK OF INFO FROM THE CNT$DF LINE OF CETAB.MAC
832 ! UNT_PTR - BLOCK OF INFO FROM THE UNT$DF LINE OF CETAB.MAC
833 ! VALUES - BLOCK OF LOTS OF GOOD THINGS FOR VNP20
834 !
835 ! IMPLICIT INPUTS:
836 !
837 ! NONE
838 !
839 ! IMPLICIT OUTPUTS:
840 !
841 ! STORES A POINTER TO THE DATA CREATED IN THE PDV
842 !
843 ! ROUTINE VALUE:
844 !
845 ! NONE
846 !
847 ! SIDE EFFECTS
848 !
849 ! MODIFIES THE KERNEL
850 !
851 !--
852
853 BEGIN
854
855 BIND
856 ROUTINE_NAME = UPLIT (%ASCIZ'D_DUP');
857
858 MAP
859 KERNEL_FILE : REF FILE_BLOCK,
860 FILE_PTR : REF FILE_BLOCK,
861 DDM_PTR : REF DDM_BLOCK,
862 CNT_PTR : REF CNT_BLOCK,
863 UNT_PTR : REF UNT_BLOCK,
864 VALUES : REF VNPVAL_BLOCK;
865
866 LOCAL
867 LIBR_PTR : REF LIBR_BLOCK,
868 SLT_OFFSET,
869 SLT_NUMBER,
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
870 DUP_DATA_ADDR,
871 LOC;
872
873 !
874 ! ALLOCATE SPACE TO HOLD THE DATA
875 !
876 DUP_DATA_ADDR = ALOCB (.KERNEL_FILE, 82, 1, .VALUES);
877 !
878 ! SET UP "LOC" AS A POINTER FOR STORING DATA INTO THIS BLOCK
879 !
880 LOC = .DUP_DATA_ADDR;
881 !
882 ! NOW CREATE THE DATA. THIS HAS BEEN CODED FROM THE FILE "DUP.DAT"
883 ! IN DECNET-11M.
884 !
885 !
886 ! DEVICE DRIVER TIMER CELL
887 !
888 LOC = .LOC + 1;
889 !
890 ! DEVICE DRIVER INITIAL TIMEOUT
891 !
892 PUTBYT (.KERNEL_FILE, .LOC, 3);
893 LOC = .LOC + 1;
894 !
895 ! RECEIVER INTERRUPT SERVICE
896 !
897 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR], .LOC);
898 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR] + 2, 7*32);
899 !
900 ! COMPILE SOME INSTRUCTIONS FOR INTERRUPT DISPATCH
901 !
902 ! MOV @#KIASR5,-(SP)
903 ! MOV #BIAS,@#KIASR5
904 ! JSR R5,@#$DUPRI
905 !
906 PUTWRD (.KERNEL_FILE, .LOC, %O'13746');
907 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'172352');
908 LOC = .LOC + 4;
909 PUTWRD (.KERNEL_FILE, .LOC, %O'12737');
910 PUTWRD (.KERNEL_FILE, .LOC + 2, GETWRD (.KERNEL_FILE, .PCB_ADDR + .VALUES [P_REL]));
911 PUTWRD (.KERNEL_FILE, .LOC + 4, %O'172352');
912 LOC = .LOC + 6;
913 PUTWRD (.KERNEL_FILE, .LOC, %O'4537');
914 PUTWRD (.KERNEL_FILE, .LOC + 2, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'$DUPRI'), 0));
915 LOC = .LOC + 4;
916 !
917 ! CSR ADDRESS + 2
918 !
919 PUTWRD (.KERNEL_FILE, .LOC, .CNT_PTR [CNT_CSR] + %O'2');
920 LOC = .LOC + 2;
921 !
922 ! BIAS
923 ! ADD
924 ! CNT
925 LOC = .LOC + 6;
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
926 !
927 ! DEVICE PRIORITY
928 !
929 PUTWRD (.KERNEL_FILE, .LOC, (.CNT_PTR [CNT_PRIORITY]*%O'40') XOR %O'340');
930 LOC = .LOC + 2;
931 !
932 ! THRD
933 ! FLAG
934 ! PRIM
935 ! STAT
936 ! PCNT
937 !
938 LOC = .LOC + 10;
939 !
940 ! TRANSMIT INTERRUPT SETUP
941 !
942 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR] + 4, .LOC);
943 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR] + 6, 7*32);
944 !
945 ! SAME CODE AS FOR RECEIVER INTERRUPT ABOVE
946 !
947 PUTWRD (.KERNEL_FILE, .LOC, %O'13746');
948 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'172352');
949 LOC = .LOC + 4;
950 PUTWRD (.KERNEL_FILE, .LOC, %O'12737');
951 PUTWRD (.KERNEL_FILE, .LOC + 2, GETWRD (.KERNEL_FILE, .PCB_ADDR + .VALUES [P_REL]));
952 PUTWRD (.KERNEL_FILE, .LOC + 4, %O'172352');
953 LOC = .LOC + 6;
954 PUTWRD (.KERNEL_FILE, .LOC, %O'4537');
955 PUTWRD (.KERNEL_FILE, .LOC + 2, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'$DUPTI'), 0));
956 LOC = .LOC + 4;
957 !
958 ! DATA BUFFER ADDRESS
959 !
960 PUTWRD (.KERNEL_FILE, .LOC, .CNT_PTR [CNT_CSR] + %O'4');
961 LOC = .LOC + 2;
962 !
963 ! BIAS
964 ! ADD
965 ! CNT
966 !
967 LOC = .LOC + 6;
968 !
969 ! DEVICE PRIORITY
970 !
971 PUTWRD (.KERNEL_FILE, .LOC, (.CNT_PTR [CNT_PRIORITY]*%O'40') XOR %O'340');
972 LOC = .LOC + 2;
973 !
974 ! STAT
975 ! THRD
976 ! PRIM
977 ! SEC
978 ! ICCB
979 !
980 LOC = .LOC + 10;
981 !
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
982 ! SYSTEM LINE NUMBER (WORD)
983 !
984 SLT_OFFSET = .SLT_ADDR - GETWRD (.KERNEL_FILE, .VALUES [SLTTA]);
985 SLT_NUMBER = .SLT_OFFSET/.VALUES [L_LEN];
986 PUTWRD (.KERNEL_FILE, .LOC, .SLT_NUMBER);
987 LOC = .LOC + 2;
988 !
989 ! DEVICE CHARACTERISTICS
990 !
991 PUTWRD (.KERNEL_FILE, .LOC, .UNT_PTR [UNT_PARMSK]);
992 PUTWRD (.KERNEL_FILE, .LOC + 2, .UNT_PTR [UNT_PARM]);
993 LOC = .LOC + 4;
994 !
995 ! EVENT LOGGING DESTINATION
996 !
997 LOC = .LOC + 2;
998 !
999 ! LIBRARY ROUTINE DDHAR
1000 !
1001 LIBR_PTR = GET_LIBR (.KERNEL_FILE, .FILE_CHAN, UPLIT (%ASCIZ'DDHAR'), .VALUES);
1002 PUTWRD (.KERNEL_FILE, .LOC, .LIBR_PTR [LIBR_ADDR]/64);
1003 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'140000' + (.LIBR_PTR [LIBR_ADDR] MOD 64));
1004 LOC = .LOC + 4;
1005 !
1006 ! ENABLE THE DUP FOR EVENT LOGGING
1007 !
1008 PUTWRD (.KERNEL_FILE, .DUP_DATA_ADDR + SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'DUPLG '), 0), .VALUES [PD_NSP]^8)
1009 ;
1010 !
1011 ! FINALLY, STORE A POINTER TO THE DATA IN THE SLT
1012 !
1013 PUTWRD (.KERNEL_FILE, .SLT_ADDR + .VALUES [L_DDS], .DUP_DATA_ADDR);
1014 END; !OF D_DUP
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1015 ROUTINE D_DMC (KERNEL_FILE, FILE_CHAN, FILE_PTR, PDV_ADDR, SLT_ADDR, PCB_ADDR, DDM_PTR, CNT_PTR, UNT_PTR,
1016 VALUES) : NOVALUE = !CREATE DATA BASE FOR DMC
1017
1018 !++
1019 ! FUNCTIONAL DESCRIPTION:
1020 !
1021 ! CREATE THE DATA BASE FOR THE DMC
1022 !
1023 ! FORMAL PARAMETERS:
1024 !
1025 ! KERNEL_FILE - POINTER TO THE FILE WHICH HOLDS THE KERNEL
1026 ! FILE_CHAN - CHANNEL FOR LOADING LIBARIES
1027 ! FILE_PTR - POINTER TO THE FILE WHICH HAS THE DDM SYMBOLS
1028 ! PDV_ADDR - PDP-11 ADDRESS OF THE PROCESS DESCRIPTOR VECTOR
1029 ! SLT_ADDR - PDP-11 ADDRESS OF THE ENTRY IN THE SYSTEM LINE TABLE
1030 ! PCB_ADDR - PDP-11 ADDRESS OF THE PARTITION CONTROL BLOCK
1031 ! DDM_PTR - BLOCK OF INFO FROM THE DDM$DF LINE OF CETAB.MAC
1032 ! CNT_PTR - BLOCK OF INFO FROM THE CNT$DF LINE OF CETAB.MAC
1033 ! UNT_PTR - BLOCK OF INFO FROM THE UNT$DF LINE OF CETAB.MAC
1034 ! VALUES - BLOCK OF LOTS OF GOOD THINGS FOR VNP20
1035 !
1036 ! IMPLICIT INPUTS:
1037 !
1038 ! NONE
1039 !
1040 ! IMPLICIT OUTPUTS:
1041 !
1042 ! STORES A POINTER TO THE DATA CREATED IN THE PDV
1043 !
1044 ! ROUTINE VALUE:
1045 !
1046 ! NONE
1047 !
1048 ! SIDE EFFECTS
1049 !
1050 ! MODIFIES THE KERNEL
1051 !
1052 !--
1053
1054 BEGIN
1055
1056 BIND
1057 ROUTINE_NAME = UPLIT (%ASCIZ'D_DMC');
1058
1059 MAP
1060 KERNEL_FILE : REF FILE_BLOCK,
1061 FILE_PTR : REF FILE_BLOCK,
1062 DDM_PTR : REF DDM_BLOCK,
1063 CNT_PTR : REF CNT_BLOCK,
1064 UNT_PTR : REF UNT_BLOCK,
1065 VALUES : REF VNPVAL_BLOCK;
1066
1067 LOCAL
1068 ALOC_ADDR,
1069 SLT_NUMBER,
1070 SLT_OFFSET,
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1071 DMC_DATA_ADDR,
1072 LOC;
1073
1074 !
1075 ! ALLOCATE SPACE TO HOLD THE DATA
1076 !
1077 DMC_DATA_ADDR = ALOCB (.KERNEL_FILE, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'D.LEN '), 0), 1, .VALUES);
1078 !
1079 ! SET UP "LOC" AS A POINTER FOR STORING DATA INTO THIS BLOCK
1080 !
1081 LOC = .DMC_DATA_ADDR;
1082 !
1083 ! NOW CREATE THE DATA. THIS HAS BEEN CODED FROM THE FILE "DMC.DAT"
1084 ! IN DECNET-11M.
1085 !
1086 ! INPUT INTERRUPT SERVICE
1087 !
1088 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR], .LOC);
1089 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR] + 2, 7*32);
1090 !
1091 ! COMPILE SOME INSTRUCTIONS FOR INTERRUPT DISPATCH
1092 !
1093 ! MOV @#KIASR5,-(SP)
1094 ! MOV #BIAS,@#KIASR5
1095 ! JSR R5,@#$$DMC
1096 !
1097 PUTWRD (.KERNEL_FILE, .LOC, %O'13746');
1098 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'172352');
1099 LOC = .LOC + 4;
1100 PUTWRD (.KERNEL_FILE, .LOC, %O'12737');
1101 PUTWRD (.KERNEL_FILE, .LOC + 2, GETWRD (.KERNEL_FILE, .PCB_ADDR + .VALUES [P_REL]));
1102 PUTWRD (.KERNEL_FILE, .LOC + 4, %O'172352');
1103 LOC = .LOC + 6;
1104 PUTWRD (.KERNEL_FILE, .LOC, %O'4537');
1105 PUTWRD (.KERNEL_FILE, .LOC + 2, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'$$DMC '), 0));
1106 LOC = .LOC + 4;
1107 !
1108 ! DEVICE PRIORITY
1109 !
1110 PUTWRD (.KERNEL_FILE, .LOC, (.CNT_PTR [CNT_PRIORITY]*%O'40') XOR %O'340');
1111 LOC = .LOC + 2;
1112 !
1113 ! CSR ADDRESS
1114 !
1115 PUTWRD (.KERNEL_FILE, .LOC, .CNT_PTR [CNT_CSR]);
1116 LOC = .LOC + 2;
1117 !
1118 ! ZERO WORD
1119 !
1120 LOC = .LOC + 2;
1121 !
1122 ! OFFSET TO START OF LINE TABLE
1123 !
1124 PUTWRD (.KERNEL_FILE, .LOC, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'D.OFFI'), 0));
1125 LOC = .LOC + 2;
1126 !
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1127 ! OUTPUT INTERRUPT DISPATCH
1128 !
1129 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR] + 4, .LOC);
1130 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR] + 6, 7*32);
1131 !
1132 ! ESSENTIALLY THE SAME CODE AS ABOVE
1133 !
1134 PUTWRD (.KERNEL_FILE, .LOC, %O'13746');
1135 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'172352');
1136 LOC = .LOC + 4;
1137 PUTWRD (.KERNEL_FILE, .LOC, %O'12737');
1138 PUTWRD (.KERNEL_FILE, .LOC + 2, GETWRD (.KERNEL_FILE, .PCB_ADDR + .VALUES [P_REL]));
1139 PUTWRD (.KERNEL_FILE, .LOC + 4, %O'172352');
1140 LOC = .LOC + 6;
1141 PUTWRD (.KERNEL_FILE, .LOC, %O'4537');
1142 PUTWRD (.KERNEL_FILE, .LOC + 2, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'$$DMC '), 0));
1143 LOC = .LOC + 4;
1144 !
1145 ! DEVICE PRIORITY
1146 !
1147 PUTWRD (.KERNEL_FILE, .LOC, (.CNT_PTR [CNT_PRIORITY]*%O'40') XOR %O'340');
1148 LOC = .LOC + 2;
1149 !
1150 ! CSR ADDRESS + 2
1151 !
1152 PUTWRD (.KERNEL_FILE, .LOC, .CNT_PTR [CNT_CSR] + 2);
1153 LOC = .LOC + 2;
1154 !
1155 ! OFFSET TO INTERRUPT DISPATCH
1156 !
1157 PUTWRD (.KERNEL_FILE, .LOC, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'DMCOTB'), 0));
1158 LOC = .LOC + 2;
1159 !
1160 ! OFFSET TO START OF LINE TABLE
1161 !
1162 PUTWRD (.KERNEL_FILE, .LOC, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'D.OFFO'), 0));
1163 LOC = .LOC + 2;
1164 !
1165 ! TIMER CELL AND RESET VALUE
1166 !
1167 PUTBYT (.KERNEL_FILE, .LOC, 0);
1168 PUTBYT (.KERNEL_FILE, .LOC + 1, 24);
1169 LOC = .LOC + 2;
1170 !
1171 ! RECV BUFFERS
1172 !
1173 PUTBYT (.KERNEL_FILE, .LOC, -2);
1174 PUTBYT (.KERNEL_FILE, .LOC + 1, -2);
1175 LOC = .LOC + 2;
1176 !
1177 ! RECEIVE BUFFERS AWAITING ASSIGNMENT QUEUE
1178 !
1179 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
1180 LOC = .LOC + 4;
1181 !
1182 ! RECEIVE BUFFERS ASSIGNED TO DMC QUEUE
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1183 !
1184 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
1185 LOC = .LOC + 4;
1186 !
1187 ! CURRENT NUMBER OF TRANSMIT BUFFERS ASSIGNABLE AND MAXIMUM
1188 !
1189 PUTBYT (.KERNEL_FILE, .LOC, -7);
1190 PUTBYT (.KERNEL_FILE, .LOC + 1, -7);
1191 LOC = .LOC + 2;
1192 !
1193 ! XMIT BUFFERS AWAITING ASSIGNMENT QUEUE
1194 !
1195 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
1196 LOC = .LOC + 4;
1197 !
1198 ! XMIT BUFFERS ASSIGNED TO DMC QUEUE
1199 !
1200 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
1201 LOC = .LOC + 4;
1202 !
1203 ! SYSTEM LINE NUMBER
1204 !
1205 SLT_OFFSET = .SLT_ADDR - GETWRD (.KERNEL_FILE, .VALUES [SLTTA]);
1206 SLT_NUMBER = .SLT_OFFSET/.VALUES [L_LEN];
1207 PUTWRD (.KERNEL_FILE, .LOC, .SLT_NUMBER);
1208 LOC = .LOC + 2;
1209 !
1210 ! 128 BYTES OF CORE FROM THE POOL
1211 !
1212 ALOC_ADDR = ALOC_POOL (FILE_PTR [FILE_NAME], 128, 1, .VALUES);
1213 PUTWRD (.KERNEL_FILE, .LOC, .ALOC_ADDR/64);
1214 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'140000' + (.ALOC_ADDR MOD 64));
1215 LOC = .LOC + 4;
1216 !
1217 ! 2 ZERO WORDS
1218 !
1219 LOC = .LOC + 4;
1220 !
1221 ! PENDING CONTROL FUNCTION QUEUE
1222 !
1223 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
1224 LOC = .LOC + 4;
1225 !
1226 ! CURRENT DMC STATE
1227 !
1228 PUTWRD (.KERNEL_FILE, .LOC, %O'200');
1229 LOC = .LOC + 2;
1230 !
1231 ! DEVICE CHARACTERISTICS
1232 !
1233 PUTWRD (.KERNEL_FILE, .LOC, .UNT_PTR [UNT_PARMSK]);
1234 PUTWRD (.KERNEL_FILE, .LOC + 2, .UNT_PTR [UNT_PARM]);
1235 LOC = .LOC + 4;
1236 !
1237 ! THE REST OF THE DATA BASE IS ZERO SO DON'T FILL
1238 !
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1239 ! ENABLE EVENT LOGGING IN THE DMC DATA BASE
1240 !
1241 PUTWRD (.KERNEL_FILE,
1242 .DMC_DATA_ADDR + SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'D.LOGG'), 0) + SYM_VAL (.FILE_PTR,
1243 UPLIT (%ASCIZ'D.OFFS'), 0), .VALUES [PD_NSP]^8);
1244 !
1245 ! FINALLY, STORE A POINTER TO THE DATA IN THE SLT
1246 !
1247 PUTWRD (.KERNEL_FILE, .SLT_ADDR + .VALUES [L_DDS],
1248 .DMC_DATA_ADDR + SYM_VAL (.FILE_PTR,
1249 UPLIT (%ASCIZ'D.OFFS'), 0));
1250 END; !OF D_DMC
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1251 ROUTINE D_LE (KERNEL_FILE, FILE_CHAN, FILE_PTR, PDV_ADDR, SLT_ADDR, PCB_ADDR, DDM_PTR, CNT_PTR, UNT_PTR,
1252 VALUES) : NOVALUE =
1253
1254 !++
1255 ! FUNCTIONAL DESCRIPTION:
1256 !
1257 ! CREATE THE DATA BASE FOR THE LP11
1258 !
1259 ! FORMAL PARAMETERS:
1260 !
1261 ! KERNEL_FILE - POINTER TO THE FILE WHICH HOLDS THE KERNEL
1262 ! FILE_CHAN - CHANNEL FOR LOADING LIBARIES
1263 ! FILE_PTR - POINTER TO THE FILE WHICH HAS THE DDM SYMBOLS
1264 ! PDV_ADDR - PDP-11 ADDRESS OF THE PROCESS DESCRIPTOR VECTOR
1265 ! SLT_ADDR - PDP-11 ADDRESS OF THE ENTRY IN THE SYSTEM LINE TABLE
1266 ! PCB_ADDR - PDP-11 ADDRESS OF THE PARTITION CONTROL BLOCK
1267 ! DDM_PTR - BLOCK OF INFO FROM THE DDM$DF LINE OF CETAB.MAC
1268 ! CNT_PTR - BLOCK OF INFO FROM THE CNT$DF LINE OF CETAB.MAC
1269 ! UNT_PTR - BLOCK OF INFO FROM THE UNT$DF LINE OF CETAB.MAC
1270 ! VALUES - BLOCK OF LOTS OF GOOD THINGS FOR VNP20
1271 !
1272 ! IMPLICIT INPUTS:
1273 !
1274 ! NONE
1275 !
1276 ! IMPLICIT OUTPUTS:
1277 !
1278 ! STORES A POINTER TO THE DATA CREATED IN THE PDV
1279 !
1280 ! ROUTINE VALUE:
1281 !
1282 ! NONE
1283 !
1284 ! SIDE EFFECTS
1285 !
1286 ! MODIFIES THE KERNEL
1287 !
1288 !--
1289
1290 BEGIN
1291
1292 BIND
1293 ROUTINE_NAME = UPLIT (%ASCIZ'D_LE');
1294
1295 MAP
1296 KERNEL_FILE : REF FILE_BLOCK,
1297 FILE_PTR : REF FILE_BLOCK,
1298 DDM_PTR : REF DDM_BLOCK,
1299 CNT_PTR : REF CNT_BLOCK,
1300 UNT_PTR : REF UNT_BLOCK,
1301 VALUES : REF VNPVAL_BLOCK;
1302
1303 LOCAL
1304 LE_DATA_ADDR,
1305 LOC,
1306 XXBEG,
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1307 XXEND,
1308 DAT_FILE : REF FILE_BLOCK,
1309 SLT_OFFSET,
1310 SLT_NUMBER;
1311
1312 !
1313 ! GET FILE
1314 !
1315 DAT_FILE = GETBLK (FILE_TYP, FILE_LEN);
1316 CH$MOVE (5, CH$PTR (UPLIT (%ASCIZ'LEDAT')), CH$PTR (DAT_FILE [FILE_NAME]));
1317 RSTB (.FILE_CHAN, .DAT_FILE);
1318 RCOR (.DAT_FILE, .FILE_CHAN, 1024);
1319 !
1320 ! ALLOCATE SPACE TO HOLD THE DATA
1321 !
1322 XXBEG = SYM_VAL (.DAT_FILE, UPLIT (%ASCIZ'LEDAT '), 0);
1323 XXEND = SYM_VAL (.DAT_FILE, UPLIT (%ASCIZ'LEEND '), 0);
1324 LE_DATA_ADDR = ALOCB (.KERNEL_FILE, .XXEND - .XXBEG, 1, .VALUES);
1325 !
1326 ! COPY IN THE FILE
1327 !
1328
1329 INCR COUNTER FROM .XXBEG TO .XXEND - 1 BY 1 DO
1330 PUTBYT (.KERNEL_FILE, .LE_DATA_ADDR + .COUNTER - .XXBEG, GETBYT (.DAT_FILE, .COUNTER));
1331
1332 !
1333 ! UPDATE APPROPRIATE LOCATIONS WITHIN THE DATA BASE
1334 !
1335 LOC = .LE_DATA_ADDR + SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'L.CALL'), 0);
1336 !
1337 ! INTERRUPT VECTOR CONTROL BLOCK - L.CALL: .INT $LEINT
1338 !
1339 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR], .LOC);
1340 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR] + 2, 7*32);
1341 !
1342 ! NOW COMPILE INSTRUCTIONS, AS FOLLOWS:
1343 !
1344 ! MOV @#KIASR5,-(SP)
1345 ! MOV #BIAS,@#KIASR5
1346 ! JSR R5,@#$LEINT
1347 !
1348 PUTWRD (.KERNEL_FILE, .LOC, %O'13746');
1349 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'172352');
1350 LOC = .LOC + 4;
1351 PUTWRD (.KERNEL_FILE, .LOC, %O'12737');
1352 PUTWRD (.KERNEL_FILE, .LOC + 2, GETWRD (.KERNEL_FILE, .PCB_ADDR + .VALUES [P_REL]));
1353 PUTWRD (.KERNEL_FILE, .LOC + 4, %O'172352');
1354 LOC = .LOC + 6;
1355 PUTWRD (.KERNEL_FILE, .LOC, %O'4537');
1356 PUTWRD (.KERNEL_FILE, .LOC + 2, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'$LEINT'), 0));
1357 LOC = .LOC + 4;
1358 !
1359 ! STORE THE DEVICE PRIORITY
1360 !
1361 PUTWRD (.KERNEL_FILE, .LOC, (.CNT_PTR [CNT_PRIORITY]*%O'40') XOR %O'340');
1362 LOC = .LOC + 2;
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1363 !
1364 ! STORE THE CSR ADDRESS
1365 !
1366 PUTWRD (.KERNEL_FILE, .LOC, .CNT_PTR [CNT_CSR]);
1367 LOC = .LOC + 2;
1368 !
1369 ! STORE THE SYSTEM LINE NUMBER
1370 !
1371 LOC = .LE_DATA_ADDR + SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'L.SLN '), 0);
1372 SLT_OFFSET = .SLT_ADDR - GETWRD (.KERNEL_FILE, .VALUES [SLTTA]);
1373 SLT_NUMBER = .SLT_OFFSET/.VALUES [L_LEN];
1374 PUTWRD (.KERNEL_FILE, .LOC, .SLT_NUMBER);
1375 !
1376 ! PLUG THE LISTHEADS
1377 !
1378 LOC = .LE_DATA_ADDR + SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'L.DDMQ'), 0);
1379 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
1380 LOC = .LE_DATA_ADDR + SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'L.CMSQ'), 0);
1381 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
1382 LOC = .LE_DATA_ADDR + SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'L.DLCQ'), 0);
1383 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
1384 LOC = .LE_DATA_ADDR + SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'L.PLBQ'), 0);
1385 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
1386 LOC = .LE_DATA_ADDR + SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'L.MSGQ'), 0);
1387 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
1388 !
1389 ! RELEASE THE FILE STORAGE
1390 !
1391 FCOR (.DAT_FILE);
1392 !
1393 ! FINALLY, STORE A POINTER TO THE DATA IN THE SLT
1394 !
1395 PUTWRD (.KERNEL_FILE, .SLT_ADDR + .VALUES [L_DDS], .LE_DATA_ADDR);
1396 END; !OF D_LE
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1397 ROUTINE D_CR (KERNEL_FILE, FILE_CHAN, FILE_PTR, PDV_ADDR, SLT_ADDR, PCB_ADDR, DDM_PTR, CNT_PTR, UNT_PTR,
1398 VALUES) : NOVALUE =
1399
1400 !++
1401 ! FUNCTIONAL DESCRIPTION:
1402 !
1403 ! CREATE THE DATA BASE FOR THE LP11
1404 !
1405 ! FORMAL PARAMETERS:
1406 !
1407 ! KERNEL_FILE - POINTER TO THE FILE WHICH HOLDS THE KERNEL
1408 ! FILE_CHAN - CHANNEL FOR LOADING LIBARIES
1409 ! FILE_PTR - POINTER TO THE FILE WHICH HAS THE DDM SYMBOLS
1410 ! PDV_ADDR - PDP-11 ADDRESS OF THE PROCESS DESCRIPTOR VECTOR
1411 ! SLT_ADDR - PDP-11 ADDRESS OF THE ENTRY IN THE SYSTEM LINE TABLE
1412 ! PCB_ADDR - PDP-11 ADDRESS OF THE PARTITION CONTROL BLOCK
1413 ! DDM_PTR - BLOCK OF INFO FROM THE DDM$DF LINE OF CETAB.MAC
1414 ! CNT_PTR - BLOCK OF INFO FROM THE CNT$DF LINE OF CETAB.MAC
1415 ! UNT_PTR - BLOCK OF INFO FROM THE UNT$DF LINE OF CETAB.MAC
1416 ! VALUES - BLOCK OF LOTS OF GOOD THINGS FOR VNP20
1417 !
1418 ! IMPLICIT INPUTS:
1419 !
1420 ! NONE
1421 !
1422 ! IMPLICIT OUTPUTS:
1423 !
1424 ! STORES A POINTER TO THE DATA CREATED IN THE PDV
1425 !
1426 ! ROUTINE VALUE:
1427 !
1428 ! NONE
1429 !
1430 ! SIDE EFFECTS
1431 !
1432 ! MODIFIES THE KERNEL
1433 !
1434 !--
1435
1436 BEGIN
1437
1438 BIND
1439 ROUTINE_NAME = UPLIT (%ASCIZ'D_CR');
1440
1441 MAP
1442 KERNEL_FILE : REF FILE_BLOCK,
1443 FILE_PTR : REF FILE_BLOCK,
1444 DDM_PTR : REF DDM_BLOCK,
1445 CNT_PTR : REF CNT_BLOCK,
1446 UNT_PTR : REF UNT_BLOCK,
1447 VALUES : REF VNPVAL_BLOCK;
1448
1449 LOCAL
1450 CR_DATA_ADDR,
1451 LOC,
1452 XXBEG,
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1453 XXEND,
1454 DAT_FILE : REF FILE_BLOCK,
1455 SLT_OFFSET,
1456 SLT_NUMBER;
1457
1458 !
1459 ! GET FILE
1460 !
1461 DAT_FILE = GETBLK (FILE_TYP, FILE_LEN);
1462 CH$MOVE (5, CH$PTR (UPLIT (%ASCIZ'CRDAT')), CH$PTR (DAT_FILE [FILE_NAME]));
1463 RSTB (.FILE_CHAN, .DAT_FILE);
1464 RCOR (.DAT_FILE, .FILE_CHAN, 1024);
1465 !
1466 ! ALLOCATE SPACE TO HOLD THE DATA
1467 !
1468 XXBEG = SYM_VAL (.DAT_FILE, UPLIT (%ASCIZ'CRDAT '), 0);
1469 XXEND = SYM_VAL (.DAT_FILE, UPLIT (%ASCIZ'CREND '), 0);
1470 CR_DATA_ADDR = ALOCB (.KERNEL_FILE, .XXEND - .XXBEG, 1, .VALUES);
1471 !
1472 ! COPY IN THE FILE
1473 !
1474
1475 INCR COUNTER FROM .XXBEG TO .XXEND - 1 BY 1 DO
1476 PUTBYT (.KERNEL_FILE, .CR_DATA_ADDR + .COUNTER - .XXBEG, GETBYT (.DAT_FILE, .COUNTER));
1477
1478 !
1479 ! UPDATE APPROPRIATE LOCATIONS WITHIN THE DATA BASE
1480 !
1481 LOC = .CR_DATA_ADDR + SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'C.CALL'), 0);
1482 !
1483 ! INTERRUPT VECTOR CONTROL BLOCK - C.CALL: .INT $CRINT
1484 !
1485 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR], .LOC);
1486 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR] + 2, 7*32);
1487 !
1488 ! NOW COMPILE INSTRUCTIONS, AS FOLLOWS:
1489 !
1490 ! MOV @#KIASR5,-(SP)
1491 ! MOV #BIAS,@#KIASR5
1492 ! JSR R5,@#$CRINT
1493 !
1494 PUTWRD (.KERNEL_FILE, .LOC, %O'13746');
1495 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'172352');
1496 LOC = .LOC + 4;
1497 PUTWRD (.KERNEL_FILE, .LOC, %O'12737');
1498 PUTWRD (.KERNEL_FILE, .LOC + 2, GETWRD (.KERNEL_FILE, .PCB_ADDR + .VALUES [P_REL]));
1499 PUTWRD (.KERNEL_FILE, .LOC + 4, %O'172352');
1500 LOC = .LOC + 6;
1501 PUTWRD (.KERNEL_FILE, .LOC, %O'4537');
1502 PUTWRD (.KERNEL_FILE, .LOC + 2, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'$CRINT'), 0));
1503 LOC = .LOC + 4;
1504 !
1505 ! STORE THE DEVICE PRIORITY
1506 !
1507 PUTWRD (.KERNEL_FILE, .LOC, (.CNT_PTR [CNT_PRIORITY]*%O'40') XOR %O'340');
1508 LOC = .LOC + 2;
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1509 !
1510 ! STORE THE CSR ADDRESS
1511 !
1512 PUTWRD (.KERNEL_FILE, .LOC, .CNT_PTR [CNT_CSR]);
1513 LOC = .LOC + 2;
1514 !
1515 ! STORE THE SYSTEM LINE NUMBER
1516 !
1517 LOC = .CR_DATA_ADDR + SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'C.SLN '), 0);
1518 SLT_OFFSET = .SLT_ADDR - GETWRD (.KERNEL_FILE, .VALUES [SLTTA]);
1519 SLT_NUMBER = .SLT_OFFSET/.VALUES [L_LEN];
1520 PUTWRD (.KERNEL_FILE, .LOC, .SLT_NUMBER);
1521 !
1522 ! PLUG THE LISTHEADS
1523 !
1524 LOC = .CR_DATA_ADDR + SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'C.DDMQ'), 0);
1525 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
1526 LOC = .CR_DATA_ADDR + SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'C.CMSQ'), 0);
1527 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
1528 LOC = .CR_DATA_ADDR + SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'C.DLCQ'), 0);
1529 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
1530 LOC = .CR_DATA_ADDR + SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'C.MSGQ'), 0);
1531 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
1532 !
1533 ! RELEASE THE FILE STORAGE
1534 !
1535 FCOR (.DAT_FILE);
1536 !
1537 ! FINALLY, STORE A POINTER TO THE DATA IN THE SLT
1538 !
1539 PUTWRD (.KERNEL_FILE, .SLT_ADDR + .VALUES [L_DDS], .CR_DATA_ADDR);
1540 END; !OF D_CR
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1541 ROUTINE D_KDZ (KERNEL_FILE, FILE_CHAN, FILE_PTR, PDV_ADDR, SLT_ADDR, PCB_ADDR, DDM_PTR, CNT_PTR, UNT_PTR,
1542 VALUES) : NOVALUE =
1543
1544 !++
1545 ! FUNCTIONAL DESCRIPTION:
1546 !
1547 ! CREATE THE DATA BASE FOR THE KMC/DZ11
1548 !
1549 ! FORMAL PARAMETERS:
1550 !
1551 ! KERNEL_FILE - POINTER TO THE FILE WHICH HOLDS THE KERNEL
1552 ! FILE_CHAN - CHANNEL FOR LOADING LIBARIES
1553 ! FILE_PTR - POINTER TO THE FILE WHICH HAS THE DDM SYMBOLS
1554 ! PDV_ADDR - PDP-11 ADDRESS OF THE PROCESS DESCRIPTOR VECTOR
1555 ! SLT_ADDR - PDP-11 ADDRESS OF THE ENTRY IN THE SYSTEM LINE TABLE
1556 ! PCB_ADDR - PDP-11 ADDRESS OF THE PARTITION CONTROL BLOCK
1557 ! DDM_PTR - BLOCK OF INFO FROM THE DDM$DF LINE OF CETAB.MAC
1558 ! CNT_PTR - BLOCK OF INFO FROM THE CNT$DF LINE OF CETAB.MAC
1559 ! UNT_PTR - BLOCK OF INFO FROM THE UNT$DF LINE OF CETAB.MAC
1560 ! VALUES - BLOCK OF LOTS OF GOOD THINGS FOR VNP20
1561 !
1562 ! IMPLICIT INPUTS:
1563 !
1564 ! NONE
1565 !
1566 ! IMPLICIT OUTPUTS:
1567 !
1568 ! STORES A POINTER TO THE DATA CREATED IN THE PDV
1569 !
1570 ! ROUTINE VALUE:
1571 !
1572 ! NONE
1573 !
1574 ! SIDE EFFECTS
1575 !
1576 ! MODIFIES THE KERNEL
1577 !
1578 !--
1579
1580 BEGIN
1581
1582 BIND
1583 ROUTINE_NAME = UPLIT (%ASCIZ'D_KDZ');
1584
1585 MAP
1586 KERNEL_FILE : REF FILE_BLOCK,
1587 FILE_PTR : REF FILE_BLOCK,
1588 DDM_PTR : REF DDM_BLOCK,
1589 CNT_PTR : REF CNT_BLOCK,
1590 UNT_PTR : REF UNT_BLOCK,
1591 VALUES : REF VNPVAL_BLOCK;
1592
1593 LOCAL
1594 KDZ_DATA_ADDR,
1595 KDZLN_ADDR,
1596 KDZ_CORE_ADDR,
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1597 LOC,
1598 ALOC_LENGTH,
1599 LIBR_PTR : REF LIBR_BLOCK,
1600 KDZ_ATTRIB : VECTOR [4];
1601
1602 !
1603 ! CALCULATE AMOUNT OF SPACE TO ALLOCATE FOR THIS DATA BASE
1604 !
1605 ALOC_LENGTH = 70; !LENGTH OF KDZ FIXED PORTION
1606 KDZLN_ADDR = .ALOC_LENGTH; !OFFSET TO LINE TABLE PORTION
1607 ALOC_LENGTH = .CNT_PTR [CNT_NUM_OF_UNTS]*62 + .ALOC_LENGTH; !AND LINE TABLES
1608 !
1609 ! ALLOCATE SPACE TO HOLD THE DATA
1610 !
1611
1612 IF (.UNT_PTR [UNT_UNIT] EQL 0)
1613 THEN
1614 BEGIN
1615 KDZ_DATA_ADDR = ALOCB (.KERNEL_FILE, .ALOC_LENGTH, 1, .VALUES);
1616 VALUES [CURRENT_KDZ] = .KDZ_DATA_ADDR;
1617 END
1618 ELSE
1619 KDZ_DATA_ADDR = .VALUES [CURRENT_KDZ];
1620
1621 !
1622 ! BIAS THE LOCATIONS
1623 !
1624 KDZLN_ADDR = .KDZLN_ADDR + .KDZ_DATA_ADDR;
1625 !
1626 ! SPLIT INTO PROCESSING FOR UNIT 0 AND OTHER UNITS
1627 !
1628
1629 IF (.UNT_PTR [UNT_UNIT] EQL 0)
1630 THEN
1631 BEGIN
1632 !
1633 ! START BY FILLING IN THE KDZ FIXED PORTION OF THE DATA BASE
1634 !
1635 LOC = .KDZ_DATA_ADDR;
1636 !
1637 ! INPUT INTERRUPT SERVICE
1638 !
1639 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR], .LOC);
1640 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR] + 2, 7*32);
1641 !
1642 ! COMPILE SOME INSTRUCTIONS FOR INTERRUPT DISPATCH
1643 !
1644 ! MOV @#KIASR5,-(SP)
1645 ! MOV #BIAS,@#KIASR5
1646 ! JSR R5,@#$KZIRI
1647 !
1648 PUTWRD (.KERNEL_FILE, .LOC, %O'13746');
1649 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'172352');
1650 LOC = .LOC + 4;
1651 PUTWRD (.KERNEL_FILE, .LOC, %O'12737');
1652 PUTWRD (.KERNEL_FILE, .LOC + 2, GETWRD (.KERNEL_FILE, .PCB_ADDR + .VALUES [P_REL]));
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1653 PUTWRD (.KERNEL_FILE, .LOC + 4, %O'172352');
1654 LOC = .LOC + 6;
1655 PUTWRD (.KERNEL_FILE, .LOC, %O'4537');
1656 PUTWRD (.KERNEL_FILE, .LOC + 2, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'$KZIRI'), 0));
1657 LOC = .LOC + 4;
1658 !
1659 ! DEVICE PRIORITY
1660 !
1661 PUTWRD (.KERNEL_FILE, .LOC, (.CNT_PTR [CNT_PRIORITY]*%O'40') XOR %O'340');
1662 LOC = .LOC + 2;
1663 !
1664 ! OUTPUT INTERRUPT DISPATCH
1665 !
1666 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR] + 4, .LOC);
1667 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR] + 6, 7*32);
1668 !
1669 ! ESSENTIALLY THE SAME CODE AS ABOVE
1670 !
1671 PUTWRD (.KERNEL_FILE, .LOC, %O'13746');
1672 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'172352');
1673 LOC = .LOC + 4;
1674 PUTWRD (.KERNEL_FILE, .LOC, %O'12737');
1675 PUTWRD (.KERNEL_FILE, .LOC + 2, GETWRD (.KERNEL_FILE, .PCB_ADDR + .VALUES [P_REL]));
1676 PUTWRD (.KERNEL_FILE, .LOC + 4, %O'172352');
1677 LOC = .LOC + 6;
1678 PUTWRD (.KERNEL_FILE, .LOC, %O'4537');
1679 PUTWRD (.KERNEL_FILE, .LOC + 2, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'$KZORI'), 0));
1680 LOC = .LOC + 4;
1681 !
1682 ! DEVICE PRIORITY
1683 !
1684 PUTWRD (.KERNEL_FILE, .LOC, (.CNT_PTR [CNT_PRIORITY]*%O'40') XOR %O'340');
1685 LOC = .LOC + 2;
1686 !
1687 ! CSR ADDRESS
1688 !
1689 PUTWRD (.KERNEL_FILE, .LOC, .CNT_PTR [CNT_CSR]);
1690 LOC = .LOC + 2;
1691 !
1692 ! TWO ZERO BYTES
1693 !
1694 LOC = .LOC + 2;
1695 !
1696 ! TWO LIST HEADS
1697 !
1698 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
1699 LOC = .LOC + 4;
1700 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
1701 LOC = .LOC + 4;
1702 !
1703 ! WORDS -1,0,100001
1704 !
1705 PUTWRD (.KERNEL_FILE, .LOC, %O'177777');
1706 LOC = .LOC + 4;
1707 PUTWRD (.KERNEL_FILE, .LOC, %O'100001');
1708 LOC = .LOC + 2;
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1709 !
1710 ! SETUP EXTERNAL TABLES
1711 !
1712 KDZ_CORE_ADDR = ALOC_POOL (ROUTINE_NAME, 85 + 85, 1, .VALUES);
1713 PUTWRD (.KERNEL_FILE, .LOC, .KDZ_CORE_ADDR/64);
1714 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'140000' + (.KDZ_CORE_ADDR MOD 64));
1715 LOC = .LOC + 4;
1716 !
1717 ! WE NO LONGER LOAD KDZMOD AND VT5MOD AS PART OF POOL.., IT IS NOW PART OF THE
1718 ! KDZ DRIVER PARTITION. THE FOLLOWING CODE IS LEFT HERE TO DOCUMENT SIMULATION
1719 ! OF THE .BIN DIRECTIVE FOR VNP11.
1720 !
1721 ! LIBR_PTR = GET_BIN (.KERNEL_FILE, .FILE_CHAN, UPLIT (%ASCIZ'KDZMOD'), .VALUES);
1722 ! PUTWRD (.KERNEL_FILE, .LOC, .LIBR_PTR [LIBR_ADDR]/64);
1723 ! PUTWRD (.KERNEL_FILE, .LOC + 2, %O'140000' + (.LIBR_PTR [LIBR_ADDR] MOD 64));
1724 ! STILL SKIP OVER UNUSED LOCATIONS IN DATA BASE
1725 LOC = .LOC + 4;
1726 !
1727 ! A .BIN DIRECTIVE WORKS DIFFERENTLY THAN A .LIBR BECAUSE THE .BIN IS NOT
1728 ! ENTERED INTO THE CHAIN OF LIBRARIES. FOR THAT REASON THE NEXT STATEMENT IS
1729 ! NECESSARY TO RECLAIM THE MEMORY USED TO GET "KDZMOD" INTO THE KERNEL_FILE.
1730 !
1731 ! FREBLK (.LIBR_PTR);
1732 !
1733 ! LIBR_PTR = GET_BIN (.KERNEL_FILE, .FILE_CHAN, UPLIT (%ASCIZ'VT5MOD'), .VALUES);
1734 ! PUTWRD (.KERNEL_FILE, .LOC, .LIBR_PTR [LIBR_ADDR]/64);
1735 ! PUTWRD (.KERNEL_FILE, .LOC + 2, %O'140000' + (.LIBR_PTR [LIBR_ADDR] MOD 64));
1736 ! STILL SKIP OVER UNUSED LOCATIONS IN DATA BASE
1737 LOC = .LOC + 4;
1738 ! FREBLK (.LIBR_PTR);
1739 !
1740 ! LIBRARIES
1741 !
1742 LIBR_PTR = GET_LIBR (.KERNEL_FILE, .FILE_CHAN, UPLIT (%ASCIZ'DDHAR'), .VALUES);
1743 PUTWRD (.KERNEL_FILE, .LOC, .LIBR_PTR [LIBR_ADDR]/64);
1744 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'140000' + (.LIBR_PTR [LIBR_ADDR] MOD 64));
1745 LOC = .LOC + 4;
1746 LIBR_PTR = GET_LIBR (.KERNEL_FILE, .FILE_CHAN, UPLIT (%ASCIZ'STCRC'), .VALUES);
1747 PUTWRD (.KERNEL_FILE, .LOC, .LIBR_PTR [LIBR_ADDR]/64);
1748 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'140000' + (.LIBR_PTR [LIBR_ADDR] MOD 64));
1749 LOC = .LOC + 4;
1750 !
1751 ! VALIDATE THE ALLOCATION SCHEME ABOVE
1752 !
1753
1754 IF (.LOC NEQ .KDZLN_ADDR)
1755 THEN
1756 ERRMSG (0, 40, ROUTINE_NAME,
1757 UPLIT (%ASCIZ'Address Match Starting KDZLN'), UPLIT (0), UPLIT (%ASCIZ'For CNT$DF'),
1758 .CNT_PTR [CNT_CONT]);
1759
1760 !
1761 ! NOW SETUP ALL UNITS FOR THE KDZ
1762 !
1763 KDZ_ATTRIB [0] = .LOC;
1764 KDZ_ATTRIB [1] = .KERNEL_FILE;
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1765 KDZ_ATTRIB [3] = .VALUES;
1766 KDZ_ATTRIB [2] = .SLT_ADDR - GETWRD (.KERNEL_FILE, .VALUES [SLTTA]);
1767 KDZ_ATTRIB [2] = .KDZ_ATTRIB [2]/.VALUES [L_LEN];
1768 FND_CHAIN (.CNT_PTR [CNT_UNT], SEL_KDZ, KDZ_ATTRIB);
1769 !
1770 ! SETUP THE KMC MICRO CODE BLOCK
1771 !
1772 KMC_MICRO (.KERNEL_FILE, UPLIT (%ASCIZ'KDZ'), .CNT_PTR [CNT_CSR], .CNT_PTR [CNT_CONT], .VALUES);
1773 !
1774 END
1775 ELSE
1776 !
1777 ! HERE FOR UNITS OTHER THAN UNIT 0
1778 !
1779 BEGIN
1780 !
1781 ! CALCULATE SLT NUMBER AND OFFSET TO LINE TABLE ENTRY
1782 !
1783 KDZ_ATTRIB [2] = .SLT_ADDR - GETWRD (.KERNEL_FILE, .VALUES [SLTTA]);
1784 KDZ_ATTRIB [2] = .KDZ_ATTRIB [2]/.VALUES [L_LEN];
1785 KDZLN_ADDR = .KDZLN_ADDR + (.UNT_PTR [UNT_UNIT]*62);
1786 !
1787 ! PUT CORRECT SLN IN THIS UNIT'S ENTRY
1788 !
1789 PUTBYT (.KERNEL_FILE, .KDZLN_ADDR + 5, .KDZ_ATTRIB [2]);
1790 END;
1791
1792 !
1793 ! FINALLY, STORE A POINTER TO THE DATA IN THE SLT
1794 !
1795 PUTWRD (.KERNEL_FILE, .SLT_ADDR + .VALUES [L_DDS], .KDZLN_ADDR);
1796 END; !OF D_KDZ
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1797 ROUTINE D_KDP (KERNEL_FILE, FILE_CHAN, FILE_PTR, PDV_ADDR, SLT_ADDR, PCB_ADDR, DDM_PTR, CNT_PTR, UNT_PTR,
1798 VALUES) : NOVALUE =
1799
1800 !++
1801 ! FUNCTIONAL DESCRIPTION:
1802 !
1803 ! CREATE THE DATA BASE FOR THE KMC/DUP11
1804 !
1805 ! FORMAL PARAMETERS:
1806 !
1807 ! KERNEL_FILE - POINTER TO THE FILE WHICH HOLDS THE KERNEL
1808 ! FILE_CHAN - CHANNEL FOR LOADING LIBARIES
1809 ! FILE_PTR - POINTER TO THE FILE WHICH HAS THE DDM SYMBOLS
1810 ! PDV_ADDR - PDP-11 ADDRESS OF THE PROCESS DESCRIPTOR VECTOR
1811 ! SLT_ADDR - PDP-11 ADDRESS OF THE ENTRY IN THE SYSTEM LINE TABLE
1812 ! PCB_ADDR - PDP-11 ADDRESS OF THE PARTITION CONTROL BLOCK
1813 ! DDM_PTR - BLOCK OF INFO FROM THE DDM$DF LINE OF CETAB.MAC
1814 ! CNT_PTR - BLOCK OF INFO FROM THE CNT$DF LINE OF CETAB.MAC
1815 ! UNT_PTR - BLOCK OF INFO FROM THE UNT$DF LINE OF CETAB.MAC
1816 ! VALUES - BLOCK OF LOTS OF GOOD THINGS FOR VNP20
1817 !
1818 ! IMPLICIT INPUTS:
1819 !
1820 ! NONE
1821 !
1822 ! IMPLICIT OUTPUTS:
1823 !
1824 ! STORES A POINTER TO THE DATA CREATED IN THE PDV
1825 !
1826 ! ROUTINE VALUE:
1827 !
1828 ! NONE
1829 !
1830 ! SIDE EFFECTS
1831 !
1832 ! MODIFIES THE KERNEL
1833 !
1834 !--
1835
1836 BEGIN
1837
1838 BIND
1839 ROUTINE_NAME = UPLIT (%ASCIZ'D_KDP');
1840
1841 MAP
1842 KERNEL_FILE : REF FILE_BLOCK,
1843 FILE_PTR : REF FILE_BLOCK,
1844 DDM_PTR : REF DDM_BLOCK,
1845 CNT_PTR : REF CNT_BLOCK,
1846 UNT_PTR : REF UNT_BLOCK,
1847 VALUES : REF VNPVAL_BLOCK;
1848
1849 LOCAL
1850 ALOC_LENGTH,
1851 KDP_DATA_ADDR,
1852 KDPLN_ADDR,
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1853 KDP_ATTRIB : VECTOR [4],
1854 LOC;
1855
1856 !
1857 ! CALCULATE AMOUNT OF SPACE TO ALLOCATE FOR THIS DATA BASE
1858 !
1859 ALOC_LENGTH = 44; !LENGTH OF KDP FIXED PORTION
1860 KDPLN_ADDR = .ALOC_LENGTH; !OFFSET TO LINE TABLE PORTION
1861 ALOC_LENGTH = .CNT_PTR [CNT_NUM_OF_UNTS]*54 + .ALOC_LENGTH; !AND LINE TABLES
1862 !
1863 ! ALLOCATE SPACE TO HOLD THE DATA IF UNIT 0 OTHERWISE POINT AT DATA
1864 !
1865
1866 IF (.UNT_PTR [UNT_UNIT] EQL 0)
1867 THEN
1868 BEGIN
1869 KDP_DATA_ADDR = ALOCB (.KERNEL_FILE, .ALOC_LENGTH, 1, .VALUES);
1870 VALUES [CURRENT_KDZ] = .KDP_DATA_ADDR;
1871 END
1872 ELSE
1873 KDP_DATA_ADDR = .VALUES [CURRENT_KDZ];
1874
1875 !
1876 ! BIAS THE LOCATIONS
1877 !
1878 KDPLN_ADDR = .KDPLN_ADDR + .KDP_DATA_ADDR;
1879 !
1880 ! SPLIT INTO PROCESSING FOR UNIT 0 AND ALL OTHER UNITS
1881 !
1882
1883 IF (.UNT_PTR [UNT_UNIT] EQL 0)
1884 THEN
1885 BEGIN
1886 !
1887 ! START BY FILLING IN THE KDP FIXED PORTION OF THE DATA BASE
1888 !
1889 LOC = .KDP_DATA_ADDR;
1890 !
1891 ! INPUT INTERRUPT SERVICE
1892 !
1893 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR], .LOC);
1894 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR] + 2, 7*32);
1895 !
1896 ! COMPILE SOME INSTRUCTIONS FOR INTERRUPT DISPATCH
1897 !
1898 ! MOV @#KIASR5,-(SP)
1899 ! MOV #BIAS,@#KIASR5
1900 ! JSR R5,@#$CDIRI
1901 !
1902 PUTWRD (.KERNEL_FILE, .LOC, %O'13746');
1903 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'172352');
1904 LOC = .LOC + 4;
1905 PUTWRD (.KERNEL_FILE, .LOC, %O'12737');
1906 PUTWRD (.KERNEL_FILE, .LOC + 2, GETWRD (.KERNEL_FILE, .PCB_ADDR + .VALUES [P_REL]));
1907 PUTWRD (.KERNEL_FILE, .LOC + 4, %O'172352');
1908 LOC = .LOC + 6;
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1909 PUTWRD (.KERNEL_FILE, .LOC, %O'4537');
1910 PUTWRD (.KERNEL_FILE, .LOC + 2, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'$CDIRI'), 0));
1911 LOC = .LOC + 4;
1912 !
1913 ! DEVICE PRIORITY
1914 !
1915 PUTWRD (.KERNEL_FILE, .LOC, (.CNT_PTR [CNT_PRIORITY]*%O'40') XOR %O'340');
1916 LOC = .LOC + 2;
1917 !
1918 ! OUTPUT INTERRUPT DISPATCH
1919 !
1920 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR] + 4, .LOC);
1921 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR] + 6, 7*32);
1922 !
1923 ! ESSENTIALLY THE SAME CODE AS ABOVE
1924 !
1925 PUTWRD (.KERNEL_FILE, .LOC, %O'13746');
1926 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'172352');
1927 LOC = .LOC + 4;
1928 PUTWRD (.KERNEL_FILE, .LOC, %O'12737');
1929 PUTWRD (.KERNEL_FILE, .LOC + 2, GETWRD (.KERNEL_FILE, .PCB_ADDR + .VALUES [P_REL]));
1930 PUTWRD (.KERNEL_FILE, .LOC + 4, %O'172352');
1931 LOC = .LOC + 6;
1932 PUTWRD (.KERNEL_FILE, .LOC, %O'4537');
1933 PUTWRD (.KERNEL_FILE, .LOC + 2, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'$CDORI'), 0));
1934 LOC = .LOC + 4;
1935 !
1936 ! DEVICE PRIORITY
1937 !
1938 PUTWRD (.KERNEL_FILE, .LOC, (.CNT_PTR [CNT_PRIORITY]*%O'40') XOR %O'340');
1939 LOC = .LOC + 2;
1940 !
1941 ! CSR ADDRESS
1942 !
1943 PUTWRD (.KERNEL_FILE, .LOC, .CNT_PTR [CNT_CSR]);
1944 LOC = .LOC + 2;
1945 !
1946 ! TWO ZERO BYTES
1947 !
1948 LOC = .LOC + 2;
1949 !
1950 ! TWO LIST HEADS
1951 !
1952 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
1953 LOC = .LOC + 4;
1954 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
1955 LOC = .LOC + 4;
1956 !
1957 ! VALIDATE THE STORAGE ALLOCATION ALGORITHM ABOVE
1958 !
1959
1960 IF (.LOC NEQ .KDPLN_ADDR)
1961 THEN
1962 ERRMSG (0, 40, ROUTINE_NAME, UPLIT (%ASCIZ'Address Match for KDPLN'),
1963 UPLIT (0), UPLIT (%ASCIZ'For CNT$DF'), .CNT_PTR [CNT_CONT]);
1964
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1965 !
1966 ! BUILD THE LINE TABLE
1967 !
1968 KDP_ATTRIB [0] = .LOC;
1969 KDP_ATTRIB [1] = .KERNEL_FILE;
1970 KDP_ATTRIB [3] = .VALUES;
1971 KDP_ATTRIB [2] = .SLT_ADDR - GETWRD (.KERNEL_FILE, .VALUES [SLTTA]);
1972 KDP_ATTRIB [2] = .KDP_ATTRIB [2]/.VALUES [L_LEN];
1973 FND_CHAIN (.CNT_PTR [CNT_UNT], SEL_KDP, KDP_ATTRIB);
1974 !
1975 ! BUILD THE KMC MICRO-CODE BLOCK
1976 !
1977 KMC_MICRO (.KERNEL_FILE, UPLIT (%ASCIZ'KDP'), .CNT_PTR [CNT_CSR], .CNT_PTR [CNT_CONT], .VALUES);
1978 !
1979 END
1980 ELSE
1981 !
1982 ! HERE FOR PROCESSING NON-0 UNITS
1983 !
1984 BEGIN
1985 !
1986 ! CALCULATE SLT NUMBER AND LINE TABLE ENTRY
1987 !
1988 KDP_ATTRIB [2] = .SLT_ADDR - GETWRD (.KERNEL_FILE, .VALUES [SLTTA]);
1989 KDP_ATTRIB [2] = .KDP_ATTRIB [2]/.VALUES [L_LEN];
1990 KDPLN_ADDR = .KDPLN_ADDR + (.UNT_PTR [UNT_UNIT]*54);
1991 !
1992 ! PUT CORRECT SLN IN THIS UNITS ENTRY
1993 !
1994 PUTBYT (.KERNEL_FILE, .KDPLN_ADDR + 7, .KDP_ATTRIB [2]);
1995 END;
1996
1997 !
1998 ! FINALLY, STORE A POINTER TO THE DATA IN THE SLT
1999 !
2000 PUTWRD (.KERNEL_FILE, .SLT_ADDR + .VALUES [L_DDS], .KDPLN_ADDR);
2001 END; !OF D_KDP
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2002 ROUTINE D_DZ (KERNEL_FILE, FILE_CHAN, FILE_PTR, PDV_ADDR, SLT_ADDR, PCB_ADDR, DDM_PTR, CNT_PTR, UNT_PTR,
2003 VALUES) : NOVALUE =
2004
2005 !++
2006 ! FUNCTIONAL DESCRIPTION:
2007 !
2008 ! CREATE THE DATA BASE FOR THE DZ11
2009 !
2010 ! FORMAL PARAMETERS:
2011 !
2012 ! KERNEL_FILE - POINTER TO THE FILE WHICH HOLDS THE KERNEL
2013 ! FILE_CHAN - CHANNEL FOR LOADING LIBARIES
2014 ! FILE_PTR - POINTER TO THE FILE WHICH HAS THE DDM SYMBOLS
2015 ! PDV_ADDR - PDP-11 ADDRESS OF THE PROCESS DESCRIPTOR VECTOR
2016 ! SLT_ADDR - PDP-11 ADDRESS OF THE ENTRY IN THE SYSTEM LINE TABLE
2017 ! PCB_ADDR - PDP-11 ADDRESS OF THE PARTITION CONTROL BLOCK
2018 ! DDM_PTR - BLOCK OF INFO FROM THE DDM$DF LINE OF CETAB.MAC
2019 ! CNT_PTR - BLOCK OF INFO FROM THE CNT$DF LINE OF CETAB.MAC
2020 ! UNT_PTR - BLOCK OF INFO FROM THE UNT$DF LINE OF CETAB.MAC
2021 ! VALUES - BLOCK OF LOTS OF GOOD THINGS FOR VNP20
2022 !
2023 ! IMPLICIT INPUTS:
2024 !
2025 ! NONE
2026 !
2027 ! IMPLICIT OUTPUTS:
2028 !
2029 ! STORES A POINTER TO THE DATA CREATED IN THE PDV
2030 !
2031 ! ROUTINE VALUE:
2032 !
2033 ! NONE
2034 !
2035 ! SIDE EFFECTS
2036 !
2037 ! MODIFIES THE KERNEL
2038 !
2039 !--
2040
2041 BEGIN
2042
2043 BIND
2044 ROUTINE_NAME = UPLIT (%ASCIZ'D_DZ');
2045
2046 MAP
2047 KERNEL_FILE : REF FILE_BLOCK,
2048 FILE_PTR : REF FILE_BLOCK,
2049 DDM_PTR : REF DDM_BLOCK,
2050 CNT_PTR : REF CNT_BLOCK,
2051 UNT_PTR : REF UNT_BLOCK,
2052 VALUES : REF VNPVAL_BLOCK;
2053
2054 LOCAL
2055 ALOC_LENGTH,
2056 DZ_DATA_ADDR,
2057 DZLN_ADDR,
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2058 DZ_ATTRIB : VECTOR [4],
2059 LOC,
2060 LIBR_PTR : REF LIBR_BLOCK;
2061
2062 !
2063 ! CALCULATE AMOUNT OF SPACE TO ALLOCATE FOR THIS DATA BASE
2064 !
2065 ALOC_LENGTH = 50; !LENGTH OF DZ FIXED PORTION
2066 DZLN_ADDR = .ALOC_LENGTH; !OFFSET TO LINE TABLE PORTION
2067 ALOC_LENGTH = .CNT_PTR [CNT_NUM_OF_UNTS]*32 + .ALOC_LENGTH; !AND LINE TABLES
2068 !
2069 ! ALLOCATE SPACE TO HOLD THE DATA IF UNIT 0 OTHERWISE POINT AT DATA
2070 !
2071
2072 IF (.UNT_PTR [UNT_UNIT] EQL 0)
2073 THEN
2074 BEGIN
2075 DZ_DATA_ADDR = ALOCB (.KERNEL_FILE, .ALOC_LENGTH, 1, .VALUES);
2076 VALUES [CURRENT_KDZ] = .DZ_DATA_ADDR;
2077 END
2078 ELSE
2079 DZ_DATA_ADDR = .VALUES [CURRENT_KDZ];
2080
2081 !
2082 ! BIAS THE LOCATIONS
2083 !
2084 DZLN_ADDR = .DZLN_ADDR + .DZ_DATA_ADDR;
2085 !
2086 ! SPLIT INTO PROCESSING FOR UNIT 0 AND ALL OTHER UNITS
2087 !
2088
2089 IF (.UNT_PTR [UNT_UNIT] EQL 0)
2090 THEN
2091 BEGIN
2092 !
2093 ! START BY FILLING IN THE DZ FIXED PORTION OF THE DATA BASE
2094 !
2095 LOC = .DZ_DATA_ADDR;
2096 !
2097 ! INPUT INTERRUPT SERVICE
2098 !
2099 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR], .LOC);
2100 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR] + 2, 7*32);
2101 !
2102 ! COMPILE SOME INSTRUCTIONS FOR INTERRUPT DISPATCH
2103 !
2104 ! MOV @#KIASR5,-(SP)
2105 ! MOV #BIAS,@#KIASR5
2106 ! JSR R5,@#$DZRIS
2107 !
2108 PUTWRD (.KERNEL_FILE, .LOC, %O'13746');
2109 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'172352');
2110 LOC = .LOC + 4;
2111 PUTWRD (.KERNEL_FILE, .LOC, %O'12737');
2112 PUTWRD (.KERNEL_FILE, .LOC + 2, GETWRD (.KERNEL_FILE, .PCB_ADDR + .VALUES [P_REL]));
2113 PUTWRD (.KERNEL_FILE, .LOC + 4, %O'172352');
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2114 LOC = .LOC + 6;
2115 PUTWRD (.KERNEL_FILE, .LOC, %O'4537');
2116 PUTWRD (.KERNEL_FILE, .LOC + 2, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'$DZRIS'), 0));
2117 LOC = .LOC + 4;
2118 !
2119 ! DEVICE PRIORITY
2120 !
2121 PUTWRD (.KERNEL_FILE, .LOC, (.CNT_PTR [CNT_PRIORITY]*%O'40') XOR %O'340');
2122 LOC = .LOC + 2;
2123 !
2124 ! CSR ADDRESS + 2
2125 !
2126 PUTWRD (.KERNEL_FILE, .LOC, .CNT_PTR [CNT_CSR] + 2);
2127 LOC = .LOC + 2;
2128 !
2129 ! OUTPUT INTERRUPT DISPATCH
2130 !
2131 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR] + 4, .LOC);
2132 PUTWRD (.KERNEL_FILE, .CNT_PTR [CNT_VECTOR] + 6, 7*32);
2133 !
2134 ! ESSENTIALLY THE SAME CODE AS ABOVE
2135 !
2136 PUTWRD (.KERNEL_FILE, .LOC, %O'13746');
2137 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'172352');
2138 LOC = .LOC + 4;
2139 PUTWRD (.KERNEL_FILE, .LOC, %O'12737');
2140 PUTWRD (.KERNEL_FILE, .LOC + 2, GETWRD (.KERNEL_FILE, .PCB_ADDR + .VALUES [P_REL]));
2141 PUTWRD (.KERNEL_FILE, .LOC + 4, %O'172352');
2142 LOC = .LOC + 6;
2143 PUTWRD (.KERNEL_FILE, .LOC, %O'4537');
2144 PUTWRD (.KERNEL_FILE, .LOC + 2, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'$DZTIS'), 0));
2145 LOC = .LOC + 4;
2146 !
2147 ! DEVICE PRIORITY
2148 !
2149 PUTWRD (.KERNEL_FILE, .LOC, (.CNT_PTR [CNT_PRIORITY]*%O'40') XOR %O'340');
2150 LOC = .LOC + 2;
2151 !
2152 ! CSR ADDRESS + 6
2153 !
2154 PUTWRD (.KERNEL_FILE, .LOC, .CNT_PTR [CNT_CSR] + 6);
2155 LOC = .LOC + 2;
2156 !
2157 ! CSR ADDRESS
2158 !
2159 PUTWRD (.KERNEL_FILE, .LOC, .CNT_PTR [CNT_CSR]);
2160 LOC = .LOC + 2;
2161 !
2162 ! BLKW 2
2163 !
2164 LOC = .LOC + 4;
2165 !
2166 ! TWO ZERO BYTES
2167 !
2168 LOC = .LOC + 2;
2169 !
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2170 ! LIBRARY ROUTINE STCRC
2171 !
2172 LIBR_PTR = GET_LIBR (.KERNEL_FILE, .FILE_CHAN, UPLIT (%ASCIZ'STCRC'), .VALUES);
2173 PUTWRD (.KERNEL_FILE, .LOC, .LIBR_PTR [LIBR_ADDR]/64);
2174 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'140000' + (.LIBR_PTR [LIBR_ADDR] MOD 64));
2175 LOC = .LOC + 4;
2176 !
2177 ! ZERO WORD
2178 !
2179 LOC = .LOC + 2;
2180 !
2181 ! VALIDATE THE STORAGE ALLOCATION ALGORITHM ABOVE
2182 !
2183
2184 IF (.LOC NEQ .DZLN_ADDR)
2185 THEN
2186 ERRMSG (0, 40, ROUTINE_NAME, UPLIT (%ASCIZ'Address Match for DZLN'),
2187 UPLIT (0), UPLIT (%ASCIZ'For CNT$DF'), .CNT_PTR [CNT_CONT]);
2188
2189 !
2190 ! BUILD THE LINE TABLE
2191 !
2192 DZ_ATTRIB [0] = .LOC;
2193 DZ_ATTRIB [1] = .KERNEL_FILE;
2194 DZ_ATTRIB [3] = .VALUES;
2195 DZ_ATTRIB [2] = .SLT_ADDR - GETWRD (.KERNEL_FILE, .VALUES [SLTTA]);
2196 DZ_ATTRIB [2] = .DZ_ATTRIB [2]/.VALUES [L_LEN];
2197 FND_CHAIN (.CNT_PTR [CNT_UNT], SEL_DZ, DZ_ATTRIB);
2198 END
2199 ELSE
2200 !
2201 ! HERE FOR PROCESSING NON-0 UNITS
2202 !
2203 BEGIN
2204 !
2205 ! CALCULATE SLT NUMBER AND LINE TABLE ENTRY
2206 !
2207 DZ_ATTRIB [2] = .SLT_ADDR - GETWRD (.KERNEL_FILE, .VALUES [SLTTA]);
2208 DZ_ATTRIB [2] = .DZ_ATTRIB [2]/.VALUES [L_LEN];
2209 DZLN_ADDR = .DZLN_ADDR + (.UNT_PTR [UNT_UNIT]*32);
2210 !
2211 ! PUT CORRECT SLN IN THIS UNITS ENTRY
2212 !
2213 PUTBYT (.KERNEL_FILE, .DZLN_ADDR + 25, .DZ_ATTRIB [2]);
2214 END;
2215
2216 !
2217 ! FINALLY, STORE A POINTER TO THE DATA IN THE SLT
2218 !
2219 PUTWRD (.KERNEL_FILE, .SLT_ADDR + .VALUES [L_DDS], .DZLN_ADDR);
2220 END; !OF D_DZ
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2221 ROUTINE D_DCP (KERNEL_FILE, FILE_CHAN, FILE_PTR, PDV_ADDR, SLT_ADDR, PCB_ADDR, DLC_PTR, DDM_PTR, CNT_PTR,
2222 UNT_PTR, VALUES) : NOVALUE = !CREATE DATA BASE FOR DCP
2223
2224 !++
2225 ! FUNCTIONAL DESCRIPTION:
2226 !
2227 ! CREATE THE DATA BASE FOR THE DCP
2228 !
2229 ! FORMAL PARAMETERS:
2230 !
2231 ! KERNEL_FILE - POINTER TO THE FILE WHICH HOLDS THE KERNEL
2232 ! FILE_CHAN - CHANNEL FOR LOADING LIBARIES
2233 ! FILE_PTR - POINTER TO THE FILE WHICH HAS THE DDM SYMBOLS
2234 ! PDV_ADDR - PDP-11 ADDRESS OF THE PROCESS DESCRIPTOR VECTOR
2235 ! SLT_ADDR - PDP-11 ADDRESS OF THE ENTRY IN THE SYSTEM LINE TABLE
2236 ! PCB_ADDR - PDP-11 ADDRESS OF THE PARTITION CONTROL BLOCK
2237 ! DLC_PTR - BLOCK OF INFO FROM THE DLC$DF LINE OF CETAB.MAC, OR 0
2238 ! DDM_PTR - BLOCK OF INFO FROM THE DDM$DF LINE OF CETAB.MAC, OR 0
2239 ! CNT_PTR - BLOCK OF INFO FROM THE CNT$DF LINE OF CETAB.MAC
2240 ! UNT_PTR - BLOCK OF INFO FROM THE UNT$DF LINE OF CETAB.MAC
2241 ! VALUES - BLOCK OF LOTS OF GOOD THINGS FOR VNP20
2242 !
2243 ! IMPLICIT INPUTS:
2244 !
2245 ! NONE
2246 !
2247 ! IMPLICIT OUTPUTS:
2248 !
2249 ! STORES A POINTER TO THE DATA CREATED IN THE SLT
2250 !
2251 ! ROUTINE VALUE:
2252 !
2253 ! NONE
2254 !
2255 ! SIDE EFFECTS
2256 !
2257 ! MODIFIES THE KERNEL
2258 !
2259 !--
2260
2261 BEGIN
2262
2263 BIND
2264 ROUTINE_NAME = UPLIT (%ASCIZ'D_DCP');
2265
2266 MAP
2267 KERNEL_FILE : REF FILE_BLOCK,
2268 FILE_PTR : REF FILE_BLOCK,
2269 DLC_PTR : REF DLC_BLOCK,
2270 DDM_PTR : REF DDM_BLOCK,
2271 CNT_PTR : REF CNT_BLOCK,
2272 UNT_PTR : REF UNT_BLOCK,
2273 VALUES : REF VNPVAL_BLOCK;
2274
2275 LOCAL
2276 LIBR_PTR : REF LIBR_BLOCK,
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2277 DCP_DATA_ADDR,
2278 DCP_DROP_ADDR,
2279 LOC,
2280 SLT_OFFSET,
2281 SLT_NUMBER,
2282 SLT_PTR : REF SLT_BLOCK,
2283 NUM_OF_STA,
2284 S_STLG,
2285 L_STBL,
2286 STA_ATTRIB : VECTOR [6];
2287
2288 BIND
2289 DROP_ADDR = STA_ATTRIB [0],
2290 PREV_DROP_ADDR = STA_ATTRIB [1],
2291 TEMP_ADDR = STA_ATTRIB [2],
2292 STA_NUMBER = STA_ATTRIB [3],
2293 MPL_ADDR = STA_ATTRIB [4],
2294 FILE_PTR_PASS = STA_ATTRIB [5];
2295
2296 SLT_OFFSET = .SLT_ADDR - GETWRD (.KERNEL_FILE, .VALUES [SLTTA]);
2297 SLT_NUMBER = .SLT_OFFSET/.VALUES [L_LEN];
2298 TEMP_ADDR = .SLT_NUMBER;
2299
2300 IF ((SLT_PTR = FND_CHAIN (.VALUES [SLT_CHAIN], SEL_SLT, TEMP_ADDR)) EQL 0)
2301 THEN
2302 ERROR (UPLIT (%ASCIZ' MISSING SLT - D_DCP'));
2303
2304 !
2305 ! START BY ALLOCATING THE STATION TABLE PORTION OF THE DATA BASE
2306 ! A MINIMUM OF ONE STATION IS ALLOCATED
2307 !
2308 S_STLG = SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'S.STLG'), 0);
2309 NUM_OF_STA = MAX (.SLT_PTR [SLT_NUM_OF_STA], 1);
2310 DCP_DROP_ADDR = ALOCB (.KERNEL_FILE, .NUM_OF_STA*.S_STLG, 1, .VALUES);
2311 !
2312 ! ALLOCATE THE FIXED PORTION OF THE DATA BASE
2313 !
2314 L_STBL = SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'L.STBL'), 0);
2315 DCP_DATA_ADDR = ALOCB (.KERNEL_FILE, .L_STBL, 1, .VALUES);
2316 !
2317 ! SET UP "LOC" AS A POINTER FOR STORING DATA INTO THIS BLOCK
2318 !
2319 LOC = .DCP_DATA_ADDR;
2320 !
2321 ! NOW CREATE THE DATA. THIS HAS BEEN CODED FROM THE FILE "DCP.DAT"
2322 ! IN DECNET-11M.
2323 !
2324 ! CURRENT TIMEOUT VALUE - L.CTMO: .BYTE 0
2325 !
2326 LOC = .LOC + 1;
2327 !
2328 ! LINK TIMER INITIAL VALUE - L.ITMO: .BYTE 3
2329 !
2330 PUTBYT (.KERNEL_FILE, .LOC, 3);
2331 LOC = .LOC + 1;
2332 !
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2333 ! LINE STATUS WORD - L.STS: .WORD LI.STS
2334 !
2335 PUTWRD (.KERNEL_FILE, .LOC, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'LI.STS'), 0));
2336 LOC = .LOC + 2;
2337 !
2338 ! TRANSMIT DONE QUEUE - L.TDNQ: .LSTHD
2339 !
2340 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
2341 LOC = .LOC + 4;
2342 !
2343 ! CONTROL FUNCTION QUEUE - L.FCNL: .LSTHD
2344 !
2345 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
2346 LOC = .LOC + 4;
2347 !
2348 ! 2 WORDS - MULTIPOINT LISTHEAD - L.STAL: .MPLHD
2349 !
2350 PUTWRD (.KERNEL_FILE, .LOC, .DCP_DROP_ADDR);
2351 PUTWRD (.KERNEL_FILE, .LOC + 2, .DCP_DROP_ADDR);
2352 MPL_ADDR = .LOC + 2;
2353 LOC = .LOC + 4;
2354 !
2355 ! POINTER TO CURRENT STATION - L.CRST: .WORD 0
2356 ! LAST ACTIVE STATION POLLED - L.ACST: .BLKW 1
2357 ! LAST DEAD STATION POLLED - L.DDST: .BLKW 1
2358 ! NEXT STATION TO TRANSMIT DATA FOR - L.XMST: .BLKW 1
2359 ! LIST OF CCBS FOR HEADER - L.HDR: .WORD 0
2360 !
2361 LOC = .LOC + 10;
2362 !
2363 ! CRC LIBRARY ROUTINE - L.CRC: .LIBR STCRC
2364 !
2365 LIBR_PTR = GET_LIBR (.KERNEL_FILE, .FILE_CHAN, UPLIT (%ASCIZ'STCRC'), .VALUES);
2366 PUTWRD (.KERNEL_FILE, .LOC, .LIBR_PTR [LIBR_ADDR]/64);
2367 PUTWRD (.KERNEL_FILE, .LOC + 2, %O'140000' + (.LIBR_PTR [LIBR_ADDR] MOD 64));
2368 LOC = .LOC + 4;
2369 !
2370 ! LINE PARAMETERS - L.CHAR: .DVCHA
2371 !
2372 PUTWRD (.KERNEL_FILE, .LOC, .UNT_PTR [UNT_PARMSK]);
2373 PUTWRD (.KERNEL_FILE, .LOC + 2, .UNT_PTR [UNT_PARM]);
2374 LOC = .LOC + 4;
2375 !
2376 ! EVENT LOGGING DESTINATION - L.LOGG: .WORD PD$NSP
2377 !
2378 PUTWRD (.KERNEL_FILE, .LOC, .VALUES [PD_NSP]^8);
2379 LOC = .LOC + 2;
2380 !
2381 ! ADDRESS OF POLLING UPDATE TIMER CCB - L.UPDT: .BLKW 1
2382 ! ADDRESS OF DEAD STATION POLLING TIMER CCB - L.DEDT: .BLKW 1
2383 ! ADDRESS OF POLLING DELAY TIMER CCB - L.PDLT: .BLKW 1
2384 ! ADDRESS OF BABBLING STATION TIMER CCB - L.BABT: .BLKW 1
2385 !
2386 LOC = .LOC + 8;
2387 !
2388 ! POLLING UPDATE INTERVAL (IN TICKS) - L.UPDI: .BYTE LI.UPD
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2389 !
2390 PUTBYT (.KERNEL_FILE, .LOC, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'LI.UPD'), 0));
2391 LOC = .LOC + 1;
2392 !
2393 ! DEAD STATION POLLING INTERVAL (IN TICKS) - L.DEDI: .BYTE LI.DED
2394 !
2395 PUTBYT (.KERNEL_FILE, .LOC, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'LI.DED'), 0));
2396 LOC = .LOC + 1;
2397 !
2398 ! POLLING DELAY INTERVAL (IN TICKS) - L.PDLI: .BYTE LI.PDL
2399 !
2400 PUTBYT (.KERNEL_FILE, .LOC, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'LI.PDL'), 0));
2401 LOC = .LOC + 1;
2402 !
2403 ! BABBLING STATION TIMEOUT INTERVAL (IN SECONDS) - L.BABI: .BYTE LI.BAB
2404 !
2405 PUTBYT (.KERNEL_FILE, .LOC, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'LI.BAB'), 0));
2406 LOC = .LOC + 1;
2407 !
2408 ! SYSTEM LINE NUMBER OF THIS LINE - L.LNUM: .SLNB
2409 !
2410 PUTBYT (.KERNEL_FILE, .LOC, .SLT_NUMBER);
2411 LOC = .LOC + 1;
2412 !
2413 ! LINE ENABLE COUNTER - L.ENA: .BYTE 0
2414 ! MESSAGES OUTSTANDING TO THE DRIVER - L.MOTD: .BLKB 1
2415 ! NUMBER OF ACTIVE STATIONS ON THIS LINE - L.NAST: .BYTE 0
2416 ! NUMBER OF DEAD STATIONS - L.NDED: .BLKB 1
2417 !
2418 LOC = .LOC + 4;
2419 !
2420 ! .EVEN
2421 !
2422 LOC = (.LOC + 1) AND ( NOT 1);
2423 !
2424 ! VALIDATE ALLOCATION OF DATA BASE
2425 !
2426
2427 IF ((.LOC - .DCP_DATA_ADDR) NEQ .L_STBL)
2428 THEN
2429 ERRMSG (0, 40, ROUTINE_NAME,
2430 UPLIT (%ASCIZ'Line Table Length (L.STBL)'), UPLIT (0), UPLIT (%ASCIZ'for SLT$DF number '),
2431 .SLT_NUMBER);
2432
2433 !
2434 ! NOW FILL IN THE DROPS, FILLING IN AT LEAST ONE DROP
2435 !
2436 DROP_ADDR = .DCP_DROP_ADDR;
2437 PREV_DROP_ADDR = .MPL_ADDR;
2438 TEMP_ADDR = .KERNEL_FILE;
2439 STA_NUMBER = 0;
2440 FILE_PTR_PASS = .FILE_PTR;
2441
2442 IF (.SLT_PTR [SLT_STA] NEQ 0)
2443 THEN
2444 FND_CHAIN (.SLT_PTR [SLT_STA], SEL_STA, STA_ATTRIB)
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2445 ELSE
2446 SEL_STA (0,
2447 STA_ATTRIB);
2448
2449 !
2450 ! FINALLY, STORE A POINTER TO THE DATA IN THE SLT
2451 !
2452 PUTWRD (.KERNEL_FILE, .SLT_ADDR + .VALUES [L_DLS], .DCP_DATA_ADDR);
2453 END; !OF D_DCP
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2454 ROUTINE SEL_STA (STA_PTR, STA_ATTRIB) = !PROCESS AN STATION BLOCK
2455
2456 !++
2457 ! FUNCTIONAL DESCRIPTION:
2458 !
2459 ! BUILD THE DCP STATION TABLE FOR THE CURRENT STATION AND SLT
2460 !
2461 ! FORMAL PARAMETERS:
2462 !
2463 ! STA_PTR = POINTER TO STA BLOCK TO BE PROCESSED
2464 ! STA_ATTRIB = STATION ATTRIBUTES DATA STRUCTURE
2465 !
2466 ! IMPLICIT INPUTS:
2467 !
2468 ! NONE
2469 !
2470 ! IMPLICIT OUTPUTS:
2471 !
2472 ! NONE
2473 !
2474 ! ROUTINE VALUE:
2475 !
2476 ! ALWAYS RETURNS 0
2477 !
2478 ! SIDE EFFECTS
2479 !
2480 ! NONE
2481 !
2482 !--
2483
2484 BEGIN
2485
2486 BIND
2487 ROUTINE_NAME = UPLIT (%ASCIZ'SEL_STA');
2488
2489 MAP
2490 STA_PTR : REF STA_BLOCK,
2491 STA_ATTRIB : REF VECTOR [6];
2492
2493 BIND
2494 LOC = STA_ATTRIB [0],
2495 PREV_DROP_ADDR = STA_ATTRIB [1],
2496 KERNEL_FILE = STA_ATTRIB [2] : REF FILE_BLOCK,
2497 STA_NUMBER = STA_ATTRIB [3],
2498 MPL_ADDR = STA_ATTRIB [4],
2499 FILE_PTR = STA_ATTRIB [5] : REF FILE_BLOCK;
2500
2501 !
2502 ! NOW FILL IN THE DROP, START BY LINKING IT INTO THE CHAIN
2503 !
2504 PUTWRD (.KERNEL_FILE, .MPL_ADDR, .LOC);
2505 !
2506 PUTWRD (.KERNEL_FILE, .PREV_DROP_ADDR, .LOC);
2507 !
2508 PREV_DROP_ADDR = .LOC;
2509 !
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2510 ! STATION TABLE THREAD WORD - S.LNK: .WORD 0
2511 !
2512 PUTWRD (.KERNEL_FILE, .LOC, 0);
2513 LOC = .LOC + 2;
2514 !
2515 ! STATION STATUS WORD - S.STS: .WORD SI.STS
2516 !
2517 PUTWRD (.KERNEL_FILE, .LOC, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'SI.STS'), 0));
2518 LOC = .LOC + 2;
2519 !
2520 ! SLAVE-ONLY PRETRANSMIT QUEUE - S.PTXQ: .LSTHD
2521 !
2522 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
2523 LOC = .LOC + 4;
2524 !
2525 ! MOP MESSAGE QUEUE - S.MOPQ:
2526 ! WAITING FOR ACKNOWLEDGE QUEUE - S.TAKQ: .LSTHD
2527 !
2528 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
2529 LOC = .LOC + 4;
2530 !
2531 ! FUNCTION PENDING LIST - S.FCNL: .WORD 0
2532 !
2533 LOC = .LOC + 2;
2534 !
2535 ! STATION LOGICAL ADDRESS NUMBER - S.SLAN: .UNB
2536 !
2537 PUTBYT (.KERNEL_FILE, .LOC, .STA_NUMBER);
2538 LOC = .LOC + 1;
2539 STA_NUMBER = .STA_NUMBER + 1;
2540 !
2541 ! STATION PHYSICAL ADDRESS NUMBER - S.SPAN: .STNB
2542 !
2543
2544 IF (.STA_PTR EQL 0)
2545 THEN
2546 PUTBYT (.KERNEL_FILE, .LOC, 1)
2547 ELSE
2548 PUTBYT (.KERNEL_FILE, .LOC,
2549 .STA_PTR [STA_NUM]);
2550
2551 LOC = .LOC + 1;
2552 !
2553 ! STATUS EXTENSION EXTENSION BYTE - S.STE: .BYTE SI.STE
2554 !
2555 PUTBYT (.KERNEL_FILE, .LOC, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'SI.STE'), 0));
2556 LOC = .LOC + 1;
2557 !
2558 ! POLLING STATE - S.PLS: .BYTE SI.PLS
2559 !
2560 PUTBYT (.KERNEL_FILE, .LOC, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'SI.PLS'), 0));
2561 LOC = .LOC + 1;
2562 !
2563 ! CURRENT STATION PRIORITY - S.U: .WORD 0
2564 ! CURRENT PRIORITY INCREMENT - S.I: .WORD 0
2565 !
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2566 LOC = .LOC + 4;
2567 !
2568 ! POTENTIALLY DEAD POLLING PARAMETERS .WORD SI.P
2569 !
2570 PUTWRD (.KERNEL_FILE, .LOC, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'SI.P '), 0));
2571 LOC = .LOC + 2;
2572 !
2573 ! INACTIVE POLLING PARAMETERS - .WORD SI.I
2574 !
2575 PUTWRD (.KERNEL_FILE, .LOC, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'SI.I '), 0));
2576 LOC = .LOC + 2;
2577 !
2578 ! ACTIVE POLLING PARAMETERS - .WORD SI.A
2579 !
2580 PUTWRD (.KERNEL_FILE, .LOC, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'SI.A '), 0));
2581 LOC = .LOC + 2;
2582 !
2583 ! THRESHOLD OF NON-DATA RESPONSES TO INACTIVE - S.THI: .BYTE SI.THI
2584 !
2585 PUTBYT (.KERNEL_FILE, .LOC, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'SI.THI'), 0));
2586 LOC = .LOC + 1;
2587 !
2588 ! THRESHOLD OF NON-RESPONSES TO POTENTIALLY DEAD - S.THP: .BYTE SI.THP
2589 !
2590 PUTBYT (.KERNEL_FILE, .LOC, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'SI.THP'), 0));
2591 LOC = .LOC + 1;
2592 !
2593 ! THRESHOLD OF NON-RESPONSES TO DEAD - S.THD: .BYTE SI.THD
2594 !
2595 PUTBYT (.KERNEL_FILE, .LOC, SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'SI.THD'), 0));
2596 LOC = .LOC + 1;
2597 !
2598 ! ALL THE REST OF THE STATION TABLE IS ZERO.
2599 !
2600 LOC = ((.LOC + 1) AND ( NOT 1));
2601 LOC = .LOC + 28;
2602 !
2603 ! VALIDATE THE DATA BASE ALLOCATION
2604 !
2605
2606 IF ((.LOC - .PREV_DROP_ADDR) NEQ SYM_VAL (.FILE_PTR, UPLIT (%ASCIZ'S.STLG'), 0))
2607 THEN
2608 ERRMSG (0, 40,
2609 ROUTINE_NAME, UPLIT (%ASCIZ'Station Table Length (S.STLG)'), UPLIT (0),
2610 UPLIT (%ASCIZ'For Station Number '), .STA_NUMBER);
2611
2612 !
2613 0
2614 END; !OF SEL_STA
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2615 ROUTINE SEL_SLT (SLT_PTR, SLT_NUMBER) = !SELECT A SLT BLOCK
2616
2617 !++
2618 ! FUNCTIONAL DESCRIPTION:
2619 !
2620 ! SELECT THE SLT WHOSE NUMBER IS SLT_NUMBER
2621 !
2622 ! FORMAL PARAMETERS:
2623 !
2624 ! SLT_PTR = POINTER TO SLT BLOCK THAT MAY BE USEFUL
2625 ! SLT_NUMBER = WHICH SLT TO EXTRACT
2626 !
2627 ! IMPLICIT INPUTS:
2628 !
2629 ! NONE
2630 !
2631 ! IMPLICIT OUTPUTS:
2632 !
2633 ! NONE
2634 !
2635 ! ROUTINE VALUE:
2636 !
2637 ! 0 = NOT SUITABLE, OTHERWISE A POINTER TO THE SLT BLOCK
2638 !
2639 ! SIDE EFFECTS
2640 !
2641 ! NONE
2642 !
2643 !--
2644
2645 BEGIN
2646
2647 BIND
2648 ROUTINE_NAME = UPLIT (%ASCIZ'SEL_SLT');
2649
2650 MAP
2651 SLT_PTR : REF SLT_BLOCK;
2652
2653 IF (..SLT_NUMBER NEQ 0)
2654 THEN
2655 BEGIN
2656 .SLT_NUMBER = ..SLT_NUMBER - 1;
2657 0
2658 END
2659 ELSE
2660 .SLT_PTR
2661
2662 END; !OF SEL_SLT
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2663 ROUTINE SEL_KDZ (UNT_PTR, KDZ_ATTRIB) = !BUILD THE KDZ LINE TABLES
2664
2665 !++
2666 ! FUNCTIONAL DESCRIPTION:
2667 !
2668 ! BUILD THE PART OF THE KDZ DATA BASE WHICH REFERS TO EACH DZ11 CONTROLLED
2669 ! BY THIS KMC11.
2670 !
2671 ! FORMAL PARAMETERS:
2672 !
2673 ! UNT_PTR - POINTS AT THE UNT_BLOCK TO BUILD FROM
2674 ! KDZ_ATTRIB - ATTRIBUTES VECTOR
2675 !
2676 ! IMPLICIT INPUTS:
2677 !
2678 ! NONE
2679 !
2680 ! IMPLICIT OUTPUTS:
2681 !
2682 ! NONE
2683 !
2684 ! ROUTINE VALUE:
2685 !
2686 ! ALWAYS RETURNS 0
2687 !
2688 ! SIDE EFFECTS
2689 !
2690 ! NONE
2691 !
2692 !--
2693
2694 BEGIN
2695
2696 BIND
2697 ROUTINE_NAME = UPLIT (%ASCIZ'SEL_KDZ');
2698
2699 MAP
2700 UNT_PTR : REF UNT_BLOCK,
2701 KDZ_ATTRIB : REF VECTOR;
2702
2703 BIND
2704 LOC = KDZ_ATTRIB [0],
2705 KERNEL_FILE = KDZ_ATTRIB [1] : REF FILE_BLOCK,
2706 SLNUM = KDZ_ATTRIB [2],
2707 VALUES = KDZ_ATTRIB [3] : REF VNPVAL_BLOCK;
2708
2709 !
2710 ! DZ LINE SPECIFIC DATA BASE
2711 !
2712 !
2713 ! .WORD 0
2714 !
2715 LOC = .LOC + 2;
2716 !
2717 ! .SECCSR
2718 !
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2719 PUTWRD (.KERNEL_FILE, .LOC, .UNT_PTR [UNT_SECCSR]);
2720 LOC = .LOC + 2;
2721 !
2722 ! .UNB
2723 !
2724 PUTBYT (.KERNEL_FILE, .LOC, .UNT_PTR [UNT_UNIT]);
2725 LOC = .LOC + 1;
2726 !
2727 ! .SLNB
2728 !
2729 PUTBYT (.KERNEL_FILE, .LOC, .SLNUM);
2730 LOC = .LOC + 1;
2731 !
2732 ! VARIOUS ZERO WORDS
2733 !
2734 LOC = .LOC + 46;
2735 !
2736 ! DVCHA WORDS
2737 !
2738 PUTWRD (.KERNEL_FILE, .LOC, .UNT_PTR [UNT_PARMSK]);
2739 PUTWRD (.KERNEL_FILE, .LOC + 2, .UNT_PTR [UNT_PARM]);
2740 LOC = .LOC + 4;
2741 PUTWRD (.KERNEL_FILE, .LOC, .UNT_PTR [UNT_PARMSK]);
2742 PUTWRD (.KERNEL_FILE, .LOC + 2, .UNT_PTR [UNT_PARM]);
2743 LOC = .LOC + 4;
2744 !
2745 ! EVENT LOGGING DESTINATION - ENABLED IN THE KDZ DATA BASE
2746 !
2747 PUTWRD (.KERNEL_FILE, .LOC, .VALUES [PD_NSP]^8);
2748 LOC = .LOC + 2;
2749 !
2750 ! EXIT
2751 !
2752 0
2753 END; !OF SEL_KDZ
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2754 ROUTINE SEL_KDP (UNT_PTR, KDP_ATTRIB) = !BUILD A KDP LINE TABLE
2755
2756 !++
2757 ! FUNCTIONAL DESCRIPTION:
2758 !
2759 ! BUILD THE PART OF THE KDP DATA BASE WHICH REFERS TO EACH DUP11
2760 ! ON THIS KMC11.
2761 !
2762 ! FORMAL PARAMETERS:
2763 !
2764 ! UNT_PTR - POINTS AT THE UNT_BLOCK TO BUILD FROM
2765 ! KDP_ATTRIB - ATTRIBUTES VECTOR
2766 !
2767 ! IMPLICIT INPUTS:
2768 !
2769 ! NONE
2770 !
2771 ! IMPLICIT OUTPUTS:
2772 !
2773 ! NONE
2774 !
2775 ! ROUTINE VALUE:
2776 !
2777 ! ALWAYS RETURNS 0
2778 !
2779 ! SIDE EFFECTS
2780 !
2781 ! NONE
2782 !
2783 !--
2784
2785 BEGIN
2786
2787 BIND
2788 ROUTINE_NAME = UPLIT (%ASCIZ'SEL_KDP');
2789
2790 MAP
2791 UNT_PTR : REF UNT_BLOCK,
2792 KDP_ATTRIB : REF VECTOR;
2793
2794 BIND
2795 LOC = KDP_ATTRIB [0],
2796 KERNEL_FILE = KDP_ATTRIB [1] : REF FILE_BLOCK,
2797 SLNUM = KDP_ATTRIB [2],
2798 VALUES = KDP_ATTRIB [3] : REF VNPVAL_BLOCK;
2799
2800 !
2801 ! DUP LINE SPECIFIC DATA BASE
2802 !
2803 !
2804 ! .WORD 0
2805 !
2806 LOC = .LOC + 2;
2807 !
2808 ! .SECCSR
2809 !
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2810 PUTWRD (.KERNEL_FILE, .LOC, .UNT_PTR [UNT_SECCSR]);
2811 LOC = .LOC + 2;
2812 !
2813 ! .WORD 0
2814 !
2815 LOC = .LOC + 2;
2816 !
2817 ! .UNB
2818 !
2819 PUTBYT (.KERNEL_FILE, .LOC, .UNT_PTR [UNT_UNIT]);
2820 LOC = .LOC + 1;
2821 !
2822 ! .SLNB
2823 !
2824 PUTBYT (.KERNEL_FILE, .LOC, .SLNUM);
2825 LOC = .LOC + 1;
2826 !
2827 ! DVCHA WORDS
2828 !
2829 PUTWRD (.KERNEL_FILE, .LOC, .UNT_PTR [UNT_PARMSK]);
2830 PUTWRD (.KERNEL_FILE, .LOC + 2, .UNT_PTR [UNT_PARM]);
2831 LOC = .LOC + 4;
2832 !
2833 ! EVENT LOGGING DESTINATION - ENABLED IN THE KDP DATA BASE
2834 !
2835 PUTWRD (.KERNEL_FILE, .LOC, .VALUES [PD_NSP]^8);
2836 LOC = .LOC + 2;
2837 !
2838 ! ZERO WORD
2839 !
2840 LOC = .LOC + 2;
2841 !
2842 ! A LISTHEAD
2843 !
2844 PUTWRD (.KERNEL_FILE, .LOC + 2, .LOC);
2845 LOC = .LOC + 4;
2846 !
2847 ! MISCELLANEOUS ZERO WORDS
2848 !
2849 LOC = .LOC + 34;
2850 !
2851 ! EXIT
2852 !
2853 0
2854 END; !OF SEL_KDP
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2855 ROUTINE SEL_DZ (UNT_PTR, DZ_ATTRIB) = !BUILD A DZ LINE TABLE
2856
2857 !++
2858 ! FUNCTIONAL DESCRIPTION:
2859 !
2860 ! BUILD THE PART OF THE DZ DATA BASE WHICH REFERS TO EACH LINE
2861 ! ON THIS DZ11.
2862 !
2863 ! FORMAL PARAMETERS:
2864 !
2865 ! UNT_PTR - POINTS AT THE UNT_BLOCK TO BUILD FROM
2866 ! DZ_ATTRIB - ATTRIBUTES VECTOR
2867 !
2868 ! IMPLICIT INPUTS:
2869 !
2870 ! NONE
2871 !
2872 ! IMPLICIT OUTPUTS:
2873 !
2874 ! NONE
2875 !
2876 ! ROUTINE VALUE:
2877 !
2878 ! ALWAYS RETURNS 0
2879 !
2880 ! SIDE EFFECTS
2881 !
2882 ! NONE
2883 !
2884 !--
2885
2886 BEGIN
2887
2888 BIND
2889 ROUTINE_NAME = UPLIT (%ASCIZ'SEL_DZ');
2890
2891 MAP
2892 UNT_PTR : REF UNT_BLOCK,
2893 DZ_ATTRIB : REF VECTOR;
2894
2895 BIND
2896 LOC = DZ_ATTRIB [0],
2897 KERNEL_FILE = DZ_ATTRIB [1] : REF FILE_BLOCK,
2898 SLNUM = DZ_ATTRIB [2],
2899 VALUES = DZ_ATTRIB [3] : REF VNPVAL_BLOCK;
2900
2901 !
2902 ! DZ LINE SPECIFIC DATA BASE
2903 !
2904 !
2905 ! .BYTE 0,10
2906 !
2907 LOC = .LOC + 1;
2908 PUTBYT (.KERNEL_FILE, .LOC, %O'10');
2909 LOC = .LOC + 1;
2910 !
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2911 ! MISC ZERO WORDS
2912 !
2913 LOC = .LOC + 10;
2914 !
2915 ! EVENT LOGGING DESTINATION - ENABLED IN THE DZ DATA BASE
2916 !
2917 PUTWRD (.KERNEL_FILE, .LOC, .VALUES [PD_NSP]^8);
2918 LOC = .LOC + 2;
2919 !
2920 ! .WORD 1
2921 !
2922 PUTWRD (.KERNEL_FILE, .LOC, 1);
2923 LOC = .LOC + 2;
2924 !
2925 ! SOME MORE ZERO WORDS
2926 !
2927 LOC = .LOC + 8;
2928 !
2929 ! A ZERO BYTE
2930 !
2931 LOC = .LOC + 1;
2932 !
2933 ! .SLNB
2934 !
2935 PUTBYT (.KERNEL_FILE, .LOC, .SLNUM);
2936 LOC = .LOC + 1;
2937 !
2938 ! DVCHA WORDS
2939 !
2940 PUTWRD (.KERNEL_FILE, .LOC, .UNT_PTR [UNT_PARMSK]);
2941 PUTWRD (.KERNEL_FILE, .LOC + 2, .UNT_PTR [UNT_PARM]);
2942 LOC = .LOC + 4;
2943 !
2944 ! .UNB
2945 !
2946 PUTBYT (.KERNEL_FILE, .LOC, .UNT_PTR [UNT_UNIT]);
2947 LOC = .LOC + 1;
2948 !
2949 ! .EVEN
2950 !
2951 LOC = .LOC + 1;
2952 !
2953 ! EXIT
2954 !
2955 0
2956 END; !OF SEL_DZ
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2957 ROUTINE KMC_MICRO (KERNEL_FILE, KMC_TYPE, KMC_CSR, KMC_UNIT, VALUES) : NOVALUE =
2958 !BUILD KMC MICRO-CODE BLOCK
2959
2960 !++
2961 ! FUNCTIONAL DESCRIPTION:
2962 !
2963 ! CONSTRUCT AN KMC MICRO-CODE BLOCK WITHIN THE NTL DATA BASE.
2964 !
2965 ! FORMAL PARAMETERS:
2966 !
2967 ! KERNEL_FILE - THE SYSTEM IMAGE
2968 ! KMC_TYPE - CHARACTER LITERAL OF EITHER KDZ OR KDP
2969 ! KMC_UNIT - THE CONTROLLER UNIT NUMBER FOR THIS KMC
2970 ! KMC_CSR - THE KMC CSR ADDRESS
2971 ! VALUES - THE BLOCK CONTAINING ALL GOOD STUFF FOR VNP
2972 !
2973 ! IMPLICIT INPUTS:
2974 !
2975 ! NONE
2976 !
2977 ! IMPLICIT OUTPUTS:
2978 !
2979 ! NONE
2980 !
2981 ! ROUTINE VALUE:
2982 !
2983 ! NONE
2984 !
2985 ! SIDE EFFECTS:
2986 !
2987 ! NONE
2988 !--
2989
2990 BEGIN
2991
2992 BIND
2993 ROUTINE_NAME = UPLIT (%ASCIZ'KMC_MICRO');
2994
2995 MAP
2996 KERNEL_FILE : REF FILE_BLOCK,
2997 VALUES : REF VNPVAL_BLOCK;
2998
2999 LOCAL
3000 LOC,
3001 BLK_PTR,
3002 SEARCH_DONE,
3003 KMC_R50 : VECTOR [4];
3004
3005 !
3006 ! DETERMINE WHETHER WE ALREADY ALLOCATED A BLOCK TO HOLD MICRO-CODE DESCRIPTORS
3007 !
3008
3009 IF ((BLK_PTR = GETWRD (.KERNEL_FILE, .VALUES [POOL_BASE] + $CXKMC)*64) EQL 0)
3010 THEN
3011 BEGIN !NEED TO ALLOCATE A BLOCK
3012 BLK_PTR = ALOC_POOL (.KERNEL_FILE, $UNBSZ, 0, .VALUES);
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
3013 PUTWRD (.KERNEL_FILE, .VALUES [POOL_BASE] + $CXKMC, .BLK_PTR/64);
3014 PUTWRD (.KERNEL_FILE, .BLK_PTR + UBLK_LNK, 0); !ZERO LINK
3015 PUTWRD (.KERNEL_FILE, .BLK_PTR + UBLK_FIRST, 0); !SHOW FIRST FREE
3016 END;
3017
3018 !
3019 ! NOW FIND EMPTY SLOT IN BLOCK TO STICK KMC DESCRIPTOR
3020 !
3021 SEARCH_DONE = 0;
3022 LOC = .BLK_PTR + UBLK_FIRST; !START HERE
3023
3024 WHILE (.SEARCH_DONE EQL 0) DO
3025 BEGIN
3026
3027 IF ((GETWRD (.KERNEL_FILE, .LOC) EQL 0) AND ((.LOC - .BLK_PTR) LSS ($UNBSZ - KMC_ENTRY_LEN)))
3028 THEN
3029 SEARCH_DONE = 1
3030 ELSE
3031 BEGIN
3032
3033 IF ((.LOC - .BLK_PTR) LEQ ($UNBSZ - KMC_ENTRY_LEN))
3034 THEN
3035 LOC = .LOC + KMC_ENTRY_LEN
3036 ELSE
3037 BEGIN
3038 LOC = .BLK_PTR;
3039
3040 IF ((BLK_PTR = GETWRD (.KERNEL_FILE, .LOC)*64) EQL 0)
3041 THEN
3042 BEGIN
3043 BLK_PTR = ALOC_POOL (.KERNEL_FILE, $UNBSZ, 0, .VALUES);
3044 PUTWRD (.KERNEL_FILE, .LOC + UBLK_LNK, .BLK_PTR/64);
3045 PUTWRD (.KERNEL_FILE, .BLK_PTR + UBLK_LNK, 0);
3046 PUTWRD (.KERNEL_FILE, .BLK_PTR + UBLK_FIRST, 0);
3047 END;
3048
3049 LOC = .BLK_PTR + UBLK_FIRST;
3050 END;
3051
3052 END;
3053
3054 END;
3055
3056 !
3057 ! NOW BUILD THE DESCRIPTOR
3058 !
3059 PUTWRD (.KERNEL_FILE, .LOC + KMC_CSR_ADDR, .KMC_CSR);
3060 PUTBYT (.KERNEL_FILE, .LOC + KMC_CNTL_NUM, .KMC_UNIT);
3061 ATOR50 (.KMC_TYPE, KMC_R50);
3062 PUTBYT (.KERNEL_FILE, .LOC + KMC_NAME, .KMC_R50 [0]);
3063 PUTBYT (.KERNEL_FILE, .LOC + KMC_NAME + 1, .KMC_R50 [1]);
3064 END; !END OF KMC_MICRO
3065 END
3066
3067 ELUDOM
3068 ! Local Modes:
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
3069 ! Comment Column:36
3070 ! Comment Start:!
3071 ! Mode:Fundamental
3072 ! Auto Save Mode:2
3073 ! End:
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
ALOCB 196 705 876 1077 1324 1470 1615
1869 2075 2310 2315
ALOC_ADDR 1068 1212# 1213 1214
ALOC_LENGTH 1598 1605# 1606 1607# 1615 1850 1859#
1860 1861# 1869 2055 2065# 2066 2067#
2075
ALOC_POOL 197 1212 1712 3012 3043
ATOR50 178 3061
BLK_PTR 3001 3009# 3012# 3013 3014 3015 3022
3027 3033 3038 3040# 3043# 3044 3045
3046 3049
CNTLNO 262 325# 327 357 396 499 568#
570 580
CNT_BLOCK 261 394 498 692 862 1063 1299
1445 1589 1845 2050 2271
CNT_CONT 396 1758 1772 1963 1977 2187
CNT_CSR 753 919 960 1115 1152 1366 1512
1689 1772 1943 1977 2126 2154 2159
CNT_NUM_OF_UNTS 1607 1861 2067
CNT_PRIORITY 929 971 1110 1147 1361 1507 1661
1684 1915 1938 2121 2149
CNT_PTR 261 327# 333 345 357 394 396
498 570# 577 589 595 602 608
614 620 627 634 644 692 727
728 753 814 862 897 898 919
929 942 943 960 971 1015 1063
1088 1089 1110 1115 1129 1130 1147
1152 1251 1299 1339 1340 1361 1366
1397 1445 1485 1486 1507 1512 1541
1589 1607 1639 1640 1661 1666 1667
1684 1689 1758 1768 1772 1797 1845
1861 1893 1894 1915 1920 1921 1938
1943 1963 1973 1977 2002 2050 2067
2099 2100 2121 2126 2131 2132 2149
2154 2159 2187 2197 2221 2271
CNT_UNT 333 577 1768 1973 2197
CNT_VECTOR 727 728 897 898 942 943 1088
1089 1129 1130 1339 1340 1485 1486
1639 1640 1666 1667 1893 1894 1920
1921 2099 2100 2131 2132
COUNTER 309 310 550 551 1329 1330 1475
1476
CR_DATA_ADDR 1450 1470# 1476 1481 1517 1524 1526
1528 1530 1539
CURRENT_KDZ 1616 1619 1870 1873 2076 2079
DAT_FILE 1308 1315# 1316 1317 1318 1322 1323
1330 1391 1454 1461# 1462 1463 1464
1468 1469 1476 1535
DCP_DATA_ADDR 2277 2315# 2319 2427 2452
DCP_DROP_ADDR 2278 2310# 2350 2351 2436
DDM_BLOCK 247 486 691 861 1062 1298 1444
1588 1844 2049 2270
DDM_CNT 327 570
DDM_NAME 573 580
DDM_PTR 203 247 327 345 442 486 570
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
573 580 589 595 601 607 613
620 627 634 644 691 814 861
1015 1062 1251 1298 1397 1444 1541
1588 1797 1844 2002 2049 2221 2270
DLC_BLOCK 248 2269
DLC_PTR 203 248 345 442 2221 2269
DMC_DATA_ADDR 1071 1077# 1081 1242 1248
DROP_ADDR 2289# 2436#
DTE_DATA_ADDR 697 705# 709 807 812
DUP_DATA_ADDR 870 876# 880 1008 1013
DZLN_ADDR 2057 2066# 2084# 2184 2209# 2213 2219
DZ_ATTRIB 2058 2192# 2193# 2194# 2195# 2196# 2197
2207# 2208# 2213 2855 2893 2896 2897
2898 2899
DZ_DATA_ADDR 2056 2075# 2076 2079# 2084 2095
D_CR 130 613 1397*
D_DCP 134 344 2221*
D_DMC 128 601 1015*
D_DTE 126 589 644*
D_DUP 127 595 814*
D_DZ 133 633 2002*
D_KDP 132 626 1797*
D_KDZ 131 619 1541*
D_LE 129 607 1251*
ERRMSG 187 348 572 579 636 1756 1962
2186 2429 2608
ERROR 186 329 335 2302
FCOR 182 353 641 1391 1535
FILE_BLOCK 246 260 485 502 689 690 859
860 1060 1061 1296 1297 1308 1442
1443 1454 1586 1587 1842 1843 2047
2048 2267 2268 2496 2499 2705 2796
2897 2996
FILE_CHAN 203 282 283 345 442 520 521
589 595 601 607 613 619 626
633 644 814 1001 1015 1251 1317
1318 1397 1463 1464 1541 1742 1746
1797 2002 2172 2221 2365
FILE_HWM 301 542
FILE_LABEL 292 533
FILE_LEN 269 507 1315 1461
FILE_NAME 274 278 299 342 348 512 516
540 560 587 593 599 605 611
617 623 630 636 1212 1316 1462
FILE_PTR 260 269# 274 278 282 283 292
299 310 318 342 345 348 353
502 507# 512 516 520 521 533
540 551 560 561 562 587 589
593 595 599 601 605 607 611
613 617 619 623 626 630 633
636 641 644 690 744 807 814
860 914 955 1008 1015 1061 1077
1105 1124 1142 1157 1162 1212 1242
1248 1251 1297 1335 1356 1371 1378
1380 1382 1384 1386 1397 1443 1481
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1502 1517 1524 1526 1528 1530 1541
1587 1656 1679 1797 1843 1910 1933
2002 2048 2116 2144 2221 2268 2308
2314 2335 2390 2395 2400 2405 2440
2499# 2517 2555 2560 2570 2575 2580
2585 2590 2595 2606
FILE_PTR_PASS 2294# 2440#
FILE_TYP 269 507 1315 1461
FND_CHAIN 191 327 333 570 577 1768 1973
2197 2300 2444
FREBLK 190
GEN_PCB 203 302 442 543
GETBLK 189 269 507 1315 1461
GETBYT 192 310 325 331 551 568 575
721 1330 1476
GETWRD 193 274 287 512 528 740 762
910 951 984 1101 1138 1205 1352
1372 1498 1518 1652 1675 1766 1783
1906 1929 1971 1988 2112 2140 2195
2207 2296 3009 3027 3040
GET_BIN 200
GET_LIBR 199 1001 1742 1746 2172 2365
KDPLN_ADDR 1852 1860# 1878# 1960 1990# 1994 2000
KDP_ATTRIB 1853 1968# 1969# 1970# 1971# 1972# 1973
1988# 1989# 1994 2754 2792 2795 2796
2797 2798
KDP_DATA_ADDR 1851 1869# 1870 1873# 1878 1889
KDZLN_ADDR 1595 1606# 1624# 1754 1785# 1789 1795
KDZ_ATTRIB 1600 1763# 1764# 1765# 1766# 1767# 1768
1783# 1784# 1789 2663 2701 2704 2705
2706 2707
KDZ_CORE_ADDR 1596 1712# 1713 1714
KDZ_DATA_ADDR 1594 1615# 1616 1619# 1624 1635
KERNEL_FILE 203 246 274 287 301 302 310
315 316 317 325 331 344 442
485 512 528 542 543 551 556
557 558 568 575 589 595 601
607 613 619 626 633 644 689
705 716 721 727 728 736 737
739 740 741 743 744 753 762
764 777 786 795 800 807 812
814 859 876 892 897 898 906
907 909 910 911 913 914 919
929 942 943 947 948 950 951
952 954 955 960 971 984 986
991 992 1001 1002 1003 1008 1013
1015 1060 1077 1088 1089 1097 1098
1100 1101 1102 1104 1105 1110 1115
1124 1129 1130 1134 1135 1137 1138
1139 1141 1142 1147 1152 1157 1162
1167 1168 1173 1174 1179 1184 1189
1190 1195 1200 1205 1207 1213 1214
1223 1228 1233 1234 1241 1247 1251
1296 1324 1330 1339 1340 1348 1349
1351 1352 1353 1355 1356 1361 1366
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
1372 1374 1379 1381 1383 1385 1387
1395 1397 1442 1470 1476 1485 1486
1494 1495 1497 1498 1499 1501 1502
1507 1512 1518 1520 1525 1527 1529
1531 1539 1541 1586 1615 1639 1640
1648 1649 1651 1652 1653 1655 1656
1661 1666 1667 1671 1672 1674 1675
1676 1678 1679 1684 1689 1698 1700
1705 1707 1713 1714 1742 1743 1744
1746 1747 1748 1764 1766 1772 1783
1789 1795 1797 1842 1869 1893 1894
1902 1903 1905 1906 1907 1909 1910
1915 1920 1921 1925 1926 1928 1929
1930 1932 1933 1938 1943 1952 1954
1969 1971 1977 1988 1994 2000 2002
2047 2075 2099 2100 2108 2109 2111
2112 2113 2115 2116 2121 2126 2131
2132 2136 2137 2139 2140 2141 2143
2144 2149 2154 2159 2172 2173 2174
2193 2195 2207 2213 2219 2221 2267
2296 2310 2315 2330 2335 2340 2345
2350 2351 2365 2366 2367 2372 2373
2378 2390 2395 2400 2405 2410 2438
2452 2496# 2504 2506 2512 2517 2522
2528 2537 2546 2548 2555 2560 2570
2575 2580 2585 2590 2595 2705# 2719
2724 2729 2738 2739 2741 2742 2747
2796# 2810 2819 2824 2829 2830 2835
2844 2897# 2908 2917 2922 2935 2940
2941 2946 2957 2996 3009 3012 3013
3014 3015 3027 3040 3043 3044 3045
3046 3059 3060 3062 3063
KMC_CNTL_NUM 3060
KMC_CSR 2957 3059
KMC_CSR_ADDR 3059
KMC_ENTRY_LEN 3027 3033 3035
KMC_MICRO 140# 1772 1977 2957*
KMC_NAME 3062 3063
KMC_R50 3003 3061 3062 3063
KMC_TYPE 2957 3061
KMC_UNIT 2957 3060
L$BHGV 294 535
L$BSA 293 534
LD_DDM 125 442*
LD_DLC 122 203*
LE_DATA_ADDR 1304 1324# 1330 1335 1371 1378 1380
1382 1384 1386 1395
LIBR_ADDR 1002 1003 1743 1744 1747 1748 2173
2174 2366 2367
LIBR_BLOCK 867 1599 2060 2276
LIBR_PTR 867 1001# 1002 1003 1599 1742# 1743
1744 1746# 1747 1748 2060 2172# 2173
2174 2276 2365# 2366 2367
LOC 700 709# 716 717# 721 722# 723#
727 736 737 738# 739 740 741
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
742# 743 744 745# 749# 753 754#
758# 764 765# 769# 773# 777 778#
782# 786 787# 791# 795 796# 800
801# 871 880# 888# 892 893# 897
906 907 908# 909 910 911 912#
913 914 915# 919 920# 925# 929
930# 938# 942 947 948 949# 950
951 952 953# 954 955 956# 960
961# 967# 971 972# 980# 986 987#
991 992 993# 997# 1002 1003 1004#
1072 1081# 1088 1097 1098 1099# 1100
1101 1102 1103# 1104 1105 1106# 1110
1111# 1115 1116# 1120# 1124 1125# 1129
1134 1135 1136# 1137 1138 1139 1140#
1141 1142 1143# 1147 1148# 1152 1153#
1157 1158# 1162 1163# 1167 1168 1169#
1173 1174 1175# 1179 1180# 1184 1185#
1189 1190 1191# 1195 1196# 1200 1201#
1207 1208# 1213 1214 1215# 1219# 1223
1224# 1228 1229# 1233 1234 1235# 1305
1335# 1339 1348 1349 1350# 1351 1352
1353 1354# 1355 1356 1357# 1361 1362#
1366 1367# 1371# 1374 1378# 1379 1380#
1381 1382# 1383 1384# 1385 1386# 1387
1451 1481# 1485 1494 1495 1496# 1497
1498 1499 1500# 1501 1502 1503# 1507
1508# 1512 1513# 1517# 1520 1524# 1525
1526# 1527 1528# 1529 1530# 1531 1597
1635# 1639 1648 1649 1650# 1651 1652
1653 1654# 1655 1656 1657# 1661 1662#
1666 1671 1672 1673# 1674 1675 1676
1677# 1678 1679 1680# 1684 1685# 1689
1690# 1694# 1698 1699# 1700 1701# 1705
1706# 1707 1708# 1713 1714 1715# 1725#
1737# 1743 1744 1745# 1747 1748 1749#
1754 1763 1854 1889# 1893 1902 1903
1904# 1905 1906 1907 1908# 1909 1910
1911# 1915 1916# 1920 1925 1926 1927#
1928 1929 1930 1931# 1932 1933 1934#
1938 1939# 1943 1944# 1948# 1952 1953#
1954 1955# 1960 1968 2059 2095# 2099
2108 2109 2110# 2111 2112 2113 2114#
2115 2116 2117# 2121 2122# 2126 2127#
2131 2136 2137 2138# 2139 2140 2141
2142# 2143 2144 2145# 2149 2150# 2154
2155# 2159 2160# 2164# 2168# 2173 2174
2175# 2179# 2184 2192 2279 2319# 2326#
2330 2331# 2335 2336# 2340 2341# 2345
2346# 2350 2351 2352 2353# 2361# 2366
2367 2368# 2372 2373 2374# 2378 2379#
2386# 2390 2391# 2395 2396# 2400 2401#
2405 2406# 2410 2411# 2418# 2422# 2427
2494# 2504 2506 2508 2512 2513# 2517
2518# 2522 2523# 2528 2529# 2533# 2537
2538# 2546 2548 2551# 2555 2556# 2560
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
2561# 2566# 2570 2571# 2575 2576# 2580
2581# 2585 2586# 2590 2591# 2595 2596#
2600# 2601# 2606 2704# 2715# 2719 2720#
2724 2725# 2729 2730# 2734# 2738 2739
2740# 2741 2742 2743# 2747 2748# 2795#
2806# 2810 2811# 2815# 2819 2820# 2824
2825# 2829 2830 2831# 2835 2836# 2840#
2844 2845# 2849# 2896# 2907# 2908 2909#
2913# 2917 2918# 2922 2923# 2927# 2931#
2935 2936# 2940 2941 2942# 2946 2947#
2951# 3000 3022# 3027 3033 3035# 3038#
3040 3044 3049# 3059 3060 3062 3063
L_CTL 325 568 721
L_DDS 812 1013 1247 1395 1539 1795 2000
2219
L_DLS 2452
L_LEN 763 985 1206 1373 1519 1767 1784
1972 1989 2196 2208 2297
L_STBL 2285 2314# 2315 2427
L_UNT 331 575
MPL_ADDR 2293# 2352# 2437 2498# 2504
M_PCB 198 302 543
NUM_OF_STA 2283 2309# 2310
OUTNUM 185
OUTPUT 179
OUTSTR 184
PARTITION_BASE 258 301# 302 303 310 316 496
542# 543 544 551 557
PARTITION_NAME 257 300 302 495 541 543
PCB_ADDR 259 287# 289 302# 315 345 497
528# 530 543# 556 589 595 601
607 613 619 626 634 644 740
814 910 951 1015 1101 1138 1251
1352 1397 1498 1541 1652 1675 1797
1906 1929 2002 2112 2140 2221
PCOR1C 31#
PCRLF 183
PDV_ADDR 203 274 287 315 316 317 345
442 512 528 556 557 558 589
595 601 607 613 619 626 633
644 814 1015 1251 1397 1541 1797
2002 2221
PD_NSP 807 1008 1243 2378 2747 2835 2917
POOL_BASE 3009 3013
PREV_DROP_ADDR 2290# 2437# 2495# 2506 2508# 2606
PROCESS_BASE 253 293# 295 310 491 534# 536
551
PROCESS_FLAGS 256 494
PROCESS_LABEL 252 292# 293 294 490 533# 534
535
PROCESS_SIZE 255 295# 303 309 493 536# 544
550
PROCESS_TOP 254 294# 295 492 535# 536
PS_COM 304 545
PS_NSF 304 545
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
PS_SYS 304 545
PUTBYT 194 310 551 716 721 892 1167
1168 1173 1174 1189 1190 1330 1476
1789 1994 2213 2330 2390 2395 2400
2405 2410 2537 2546 2548 2555 2560
2585 2590 2595 2724 2729 2819 2824
2908 2935 2946 3060 3062 3063
PUTWRD 195 315 316 317 556 557 558
727 728 736 737 739 740 741
743 744 753 764 777 786 795
800 807 812 897 898 906 907
909 910 911 913 914 919 929
942 943 947 948 950 951 952
954 955 960 971 986 991 992
1002 1003 1008 1013 1088 1089 1097
1098 1100 1101 1102 1104 1105 1110
1115 1124 1129 1130 1134 1135 1137
1138 1139 1141 1142 1147 1152 1157
1162 1179 1184 1195 1200 1207 1213
1214 1223 1228 1233 1234 1241 1247
1339 1340 1348 1349 1351 1352 1353
1355 1356 1361 1366 1374 1379 1381
1383 1385 1387 1395 1485 1486 1494
1495 1497 1498 1499 1501 1502 1507
1512 1520 1525 1527 1529 1531 1539
1639 1640 1648 1649 1651 1652 1653
1655 1656 1661 1666 1667 1671 1672
1674 1675 1676 1678 1679 1684 1689
1698 1700 1705 1707 1713 1714 1743
1744 1747 1748 1795 1893 1894 1902
1903 1905 1906 1907 1909 1910 1915
1920 1921 1925 1926 1928 1929 1930
1932 1933 1938 1943 1952 1954 2000
2099 2100 2108 2109 2111 2112 2113
2115 2116 2121 2126 2131 2132 2136
2137 2139 2140 2141 2143 2144 2149
2154 2159 2173 2174 2219 2335 2340
2345 2350 2351 2366 2367 2372 2373
2378 2452 2504 2506 2512 2517 2522
2528 2570 2575 2580 2719 2738 2739
2741 2742 2747 2810 2829 2830 2835
2844 2917 2922 2940 2941 3013 3014
3015 3044 3045 3046 3059
P_REL 740 910 951 1101 1138 1352 1498
1652 1675 1906 1929 2112 2140
R50TOA 177* 274 512
RCOR 181 283 521 1318 1464
ROUTINE_NAME 243# 348 391# 433# 482# 572 579
636 686# 856# 1057# 1293# 1439# 1583#
1712 1756 1839# 1962 2044# 2186 2264#
2429 2487# 2609 2648# 2697# 2788# 2889#
2993#
RSTB 180 282 520 1317 1463
SEARCH_DONE 3002 3021# 3024 3029#
SEL_CNT 123 327 357* 570
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
SEL_DZ 139 2197 2855*
SEL_KDP 138 1973 2754*
SEL_KDZ 137 1768 2663*
SEL_SLT 136 2300 2615*
SEL_STA 135 2444 2446 2454*
SEL_UNT 124 333 399* 577
SLNUM 2706# 2729 2797# 2824 2898# 2935
SLTTA 762 984 1205 1372 1518 1766 1783
1971 1988 2195 2207 2296
SLT_ADDR 203 325 331 345 442 568 575
589 595 601 607 613 619 626
633 644 721 762 812 814 984
1013 1015 1205 1247 1251 1372 1395
1397 1518 1539 1541 1766 1783 1795
1797 1971 1988 2000 2002 2195 2207
2219 2221 2296 2452
SLT_BLOCK 2282 2651
SLT_CHAIN 2300
SLT_NUMBER 699 763# 764 869 985# 986 1069
1206# 1207 1310 1373# 1374 1456 1519#
1520 2281 2297# 2298 2410 2431 2615
2653 2656#
SLT_NUM_OF_STA 2309
SLT_OFFSET 698 762# 763 868 984# 985 1070
1205# 1206 1309 1372# 1373 1455 1518#
1519 2280 2296# 2297
SLT_PTR 2282 2300# 2309 2442 2444 2615 2651
2660
SLT_STA 2442 2444
STA_ATTRIB 2286 2289 2290 2291 2292 2293 2294
2444 2447 2454 2491 2494 2495 2496
2497 2498 2499
STA_BLOCK 2490
STA_NUM 2549
STA_NUMBER 2292# 2439# 2497# 2537 2539# 2610
STA_PTR 2454 2490 2544 2549
SYM_VAL 188 744 807 914 955 1008 1077
1105 1124 1142 1157 1162 1242 1248
1322 1323 1335 1356 1371 1378 1380
1382 1384 1386 1468 1469 1481 1502
1517 1524 1526 1528 1530 1656 1679
1910 1933 2116 2144 2308 2314 2335
2390 2395 2400 2405 2517 2555 2560
2570 2575 2580 2585 2590 2595 2606
S_STLG 2284 2308# 2310
TEMP_ADDR 2291# 2298# 2300 2438#
UBLK_FIRST 3015 3022 3046 3049
UBLK_LNK 3014 3044 3045
UNITNO 264 331# 333 399 438 501 575#
577
UNT_BLOCK 263 436 500 693 863 1064 1300
1446 1590 1846 2051 2272 2700 2791
2892
UNT_PARM 992 1234 2373 2739 2742 2830 2941
UNT_PARMSK 991 1233 2372 2738 2741 2829 2940
DSK:PCOR1C.XRF[4,31] 31-Aug-79 14:55
UNT_PTR 263 333# 345 399 436 438 500
577# 590 596 602 608 614 620
627 634 644 693 814 863 991
992 1015 1064 1233 1234 1251 1300
1397 1446 1541 1590 1612 1629 1785
1797 1846 1866 1883 1990 2002 2051
2072 2089 2209 2222 2272 2372 2373
2663 2700 2719 2724 2738 2739 2741
2742 2754 2791 2810 2819 2829 2830
2855 2892 2940 2941 2946
UNT_SECCSR 2719 2810
UNT_UNIT 438 1612 1629 1785 1866 1883 1990
2072 2089 2209 2724 2819 2946
VALUES 203 249 274 287 304 315 316
317 325 331 346 442 487 512
528 545 556 557 558 568 575
590 596 602 608 614 620 627
634 645 694 705 721 740 762
763 807 812 815 864 876 910
951 984 985 1001 1008 1013 1016
1065 1077 1101 1138 1205 1206 1212
1243 1247 1252 1301 1324 1352 1372
1373 1395 1398 1447 1470 1498 1518
1519 1539 1542 1591 1615 1616# 1619
1652 1675 1712 1742 1746 1765 1766
1767 1772 1783 1784 1795 1798 1847
1869 1870# 1873 1906 1929 1970 1971
1972 1977 1988 1989 2000 2003 2052
2075 2076# 2079 2112 2140 2172 2194
2195 2196 2207 2208 2219 2222 2273
2296 2297 2300 2310 2315 2365 2378
2452 2707# 2747 2798# 2835 2899# 2917
2957 2997 3009 3012 3013 3043
VNPVAL_BLOCK 249 487 694 864 1065 1301 1447
1591 1847 2052 2273 2707 2798 2899
2997
VRBL_SYM 201 318 561 562
XXBEG 1306 1322# 1324 1329 1330 1452 1468#
1470 1475 1476
XXEND 1307 1323# 1324 1329 1453 1469# 1470
1475
Z_DSP 316 317 557 558
Z_NAM 274 512
Z_PCB 287 315 528 556
$CXKMC 3009 3013
$UNBSZ 3012 3027 3033 3043