-
Notifications
You must be signed in to change notification settings - Fork 0
/
ocdcm_.list
18926 lines (17269 loc) · 869 KB
/
ocdcm_.list
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
COMPILATION LISTING OF SEGMENT ocdcm_
Compiled by: Multics PL/I Compiler, Release 32f, of October 9, 1989
Compiled at: Bull HN, Phoenix AZ, System-M
Compiled on: 11/11/89 0944.3 mst Sat
Options: optimize list
1 /****^ ***********************************************************
2* * *
3* * Copyright, (C) BULL HN Information Systems Inc., 1989 *
4* * *
5* * Copyright, (C) Honeywell Bull Inc., 1987 *
6* * *
7* * Copyright, (C) Honeywell Information Systems Inc., 1983 *
8* * *
9* *********************************************************** */
10
11
12 /****^ HISTORY COMMENTS:
13* 1) change(85-09-30,Farley), approve(85-11-14,MCR6979),
14* audit(85-11-14,Fawcett), install(86-03-21,MR12.0-1033):
15* To support IMU.
16* 2) change(85-12-03,Farley), approve(85-12-03,MCR7306),
17* audit(86-03-03,Fawcett), install(86-03-21,MR12.0-1033):
18* Fix bugs found while doing Dipper changes.
19* 3) change(85-12-03,Farley), approve(85-12-03,MCR7312),
20* audit(86-03-03,Fawcett), install(86-03-21,MR12.0-1033):
21* Add BCE MCA lock and unlock.
22* 4) change(86-03-12,Fawcett), approve(86-03-12,MCR7359),
23* audit(86-09-05,Lippard), install(86-09-16,MR12.0-1159):
24* Enable the locking and unlocking of MCA after system is booted. If system
25* is not at BCE then enter audit trail.
26* 5) change(86-05-13,GJohnson), approve(86-05-13,MCR7387),
27* audit(86-05-13,Martinson), install(86-05-14,MR12.0-1056):
28* Correct error message documentation.
29* 6) change(86-07-01,Farley), approve(86-09-02,MCR7523),
30* audit(86-10-03,Fawcett), install(86-10-09,MR12.0-1181):
31* Add the BAIL_OUT label, as a place for process_io to goto when it finds
32* that there is no functional console. Also some other fixes suggested by
33* John Ata in TR phx19534.
34* 7) change(86-08-07,Farley), approve(86-09-02,MCR7523),
35* audit(86-10-03,Fawcett), install(86-10-09,MR12.0-1181):
36* Increased all timeouts for IMU consoles to 2 min 30 sec. This is needed
37* because the console adapter firmware waits 2 min before returning "Device
38* Busy" (01/00) when someone is inputing something on the multi-drop.
39* Also removed the timeout_factor code, as it is nolonger needed.
40* 8) change(86-12-18,Farley), approve(87-01-05,MECR0007),
41* audit(86-12-18,Fawcett), install(87-01-05,MR12.0-1253):
42* Reset oc_data.write_q_full after get_mc_output entry picks up a message
43* and after freeing all the write queues in the esd_reset entry and
44* reset_console/retry_io procedures.
45*
46* Changed to call process_io as part of the duties of the poll_for_timeout
47* entry. This will allow queued IO to be started.
48* 9) change(87-01-14,Farley), approve(87-01-14,MCR7603),
49* audit(87-01-14,Fawcett), install(87-01-14,MR12.0-1279):
50* Offical installation of above corrections (closes MECR0007).
51* 10) change(87-07-15,Farley), approve(87-07-17,MCR7735),
52* audit(87-07-20,Fawcett), install(87-07-22,MR12.1-1044):
53* Changed queue_io entry to set oc_entry_ptr before checking if MC I/O
54* is enabled, as this code will eventually want to use it..
55*
56* Changed queue_console_io to check for a write_queue_full condition
57* after adding an entry. This corrects the age old problem of
58* out-of-sequence I/O..
59*
60* Added a wire_and_mask flag and moved the wiring/masking and
61* unwiring/unmasking to internal procs to allow it to only occur when
62* required.
63*
64* Changed several sections of the code to check for a null oc_entry_ptr
65* before attempting to reference data in the oc_entry structure. Also
66* turn off the in_service flag in most cases.
67*
68* Removed extra new_line (NL) from error_msg.
69*
70* Changed all CRASH severities to PANIC, so that report_error will
71* properly crash the system.
72*
73* Changed init_all_consoles to first find all available consoles then
74* try to assign the bootload. If attempt fails then it will now
75* attempt error recovery.
76*
77* Changed reconfigure (MAKE_BOOTLOAD_CONSOLE) to reassign previous
78* (old) console if new console assignment fails.
79* 11) change(89-08-28,Farley), approve(89-09-18,MCR8132),
80* audit(89-10-10,WAAnderson), install(89-10-11,MR12.3-1091):
81* Added checks in the reconfigure MAKE_IO_DEVICE and MAKE_INOP_DEVICE code
82* after unassigning the bootload console for a NULL oc_entry_ptr. If it is
83* null then attempt to find the console again and if unsuccessful return an
84* error code to the caller.
85*
86* Changed console_recovery to call change_console_state to insure that the
87* config_deck gets properly modified.
88*
89* Changed fill_oc_entry to insure that only ONE console has a state of "ON",
90* changing all others to "ALT".
91*
92* Increased the size of the error_msg and error_buffer to be consistent with
93* oc_trans_output_.
94*
95* Added a temporary holding area for oc_entry.line_leng in report_error.
96* This is required when reporting a multi-line error message and the console
97* goes inoperative prior to completing the sequence.
98*
99* Changed "I/O error" log message to optionally include a timeout indication
100* ("I/O timeout error") and also include the OPC name in the ascii text.
101* END HISTORY COMMENTS */
102 /* format: off */
103
104 ocdcm_:
105 proc ();
106
107 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
108 /* */
109 /* Purpose: */
110 /* */
111 /* This is the operator console DIM. It has the following responsibilities: */
112 /* */
113 /* 1.) Initialize and maintain the ring 0 oc_data database. */
114 /* */
115 /* 2.) Establish and maintain communications with the bootload console. */
116 /* */
117 /* 3.) Detect console faults and handle these faults through one of the following */
118 /* recovery strategies: */
119 /* */
120 /* a.) Utilize an alternate console as the bootload console device. */
121 /* b.) Forward all console traffic to the message coordinator. */
122 /* */
123 /* 4.) Provide an orderly means explicitly reconfiguring all configured console */
124 /* devices. */
125 /* */
126 /* Note: This code was redesigned and rewritten from the original ocdcm_ to add support of */
127 /* multiple consoles and to provide a better automated recovery strategy. */
128 /* */
129 /* */
130 /* Written: 07/20/73 */
131 /* */
132 /* Author: Bill Silver (Silver.Multics) */
133 /* */
134 /* Rewritten: 05/01/83 */
135 /* */
136 /* Author: E. A. Ranzenbach (Ranzenbach.Multics@M) */
137 /* Location: System-M. */
138 /* Release: MR10.2 */
139 /* */
140 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
141 /* */
142 /* Modifications: */
143 /* */
144 /* Date Author Reason */
145 /* */
146 /* 831207 Edward A. Ranzenbach Set the wired_hardcore_data$abort_request bit for bce. */
147 /* Also, list consoles only at appropriate times. */
148 /* */
149 /* 840320 Edward A. Ranzenbach Critical Fix for MR10.2. Corrected reconfiguration crashes */
150 /* caused by inadvertantly leaving oc_data locked. */
151 /* */
152 /* 840410 Edward A. Ranzenbach Fixed yet another reconfiguration problem which produces */
153 /* a "Lock not Mine" condition. Added set_prompt entrypoint */
154 /* for B2. Cut size of I/Os to 132 bytes. Changed bootload */
155 /* consoles reconfigured implicitly by a new bootload console */
156 /* to have a state of ALT, thus making them immediately */
157 /* available to console recovery. Changed console recovery */
158 /* strategy during crash to search for a good console until it */
159 /* can find one. */
160 /* */
161 /* 840417 E. A. Ranzenbach Better error reporting stragegy which prevents syserr race */
162 /* conditions. */
163 /* 840502 E. A. Ranzenbach Changed certain reconfiguration options to not wire and */
164 /* mask. */
165 /* */
166 /* 840517 E. A. Ranzenbach Update the wired config deck dynamically. */
167 /* */
168 /* 840605 E. A. Ranzenbach Fix garbled I/O problems and attempts to unlock oc_data */
169 /* multiple times. */
170 /* 840712 E. A. Ranzenbach Fixed problem that stored uninitialized pointer in the */
171 /* event queue. */
172 /* */
173 /* 840724 E. A. Ranzenbach To change timeouts to look for good status before retrying */
174 /* the I/O. Necessary for bce breakpoints. */
175 /* */
176 /* 841105 E. A. Ranzenbach Implemented printer_(on off) control order and fixed one */
177 /* more reconfiguration locking strategy problem. */
178 /* */
179 /* 841115 E. A. Ranzenbach Change for Olin to send wakeup when taking back */
180 /* responsibility for I/O from theMC. */
181 /* */
182 /* 841115 E. A. Ranzenbach Simulate a pending READ during initialization. */
183 /* */
184 /* 850111 E. A. Ranzenbach Added lost special interrupt protection so that EMC's */
185 /* won't lose during heavey traffic. */
186 /* 850329 E. A. Ranzenbach Cut the size of I/O's to 132 chars, improved error */
187 /* reporting. TR19223. */
188 /* 850405 E. A. Ranzenbach Fixed console_io.io_in_progress not being reset during */
189 /* console recovery. TR19225. */
190 /* */
191 /* 850620 Paul K Farley To wait five milliseconds after status arrives, if doing */
192 /* priority_io. This will allow the IMU console time to send */
193 /* the interrupt and get ready for the next IO. */
194 /* */
195 /* Add code to check if PCW gets executed by console. Only */
196 /* IOM consoles use it, and if on an IMU we need to know. */
197 /* */
198 /* Add a flag to know that the program was called at */
199 /* $interrupt_handler. Change the status pause check to */
200 /* check this flag, instead of checking for priority io in */
201 /* progress. This is because there could be an IO */
202 /* outstanding that will not terminate properly if not given */
203 /* the extra time. */
204 /* */
205 /* Added code to LOCK(disable) or UNLOCK(enable) the console */
206 /* input to the MCA (in the IMU). */
207 /* */
208 /* 850827 Paul K Farley To change report_error to locate the bootload console */
209 /* before outputting error message. Also added more info */
210 /* to the oc_data event trace. */
211 /* */
212 /* 850911 Paul K Farley To reset alerted switch in priority_io entry. */
213 /* */
214 /* 850913 Paul K Farley To add a timeout_factor to oc_entry for increasing the */
215 /* IO timeout under special conditions. */
216 /* */
217 /* 850925 Paul K Farley To allow for times when NO cpu cards are present and */
218 /* to properly find the entrypoint_name in report_error. */
219 /* */
220 /* 850930 Paul K Farley To add the process_group_id to the new MCA messages. */
221 /* */
222 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
223
224 console_free:
225 entry (console_to_check_parm, console_is_free_parm);
226
227 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
228 /* */
229 /* Entry to check if the specified console is available to RCP. If the console is not assigned as */
230 /* a bootload or alternate then console_is_free is returned true. If no such console is configured */
231 /* or the console is assigned as a bootload or alternate console then console_is_free is returned */
232 /* false. */
233 /* */
234 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
235
236 /* parameters... (I) = Input, (O) = Output */
237
238 dcl console_to_check_parm char (4) parameter; /* name of the console to check... (I) */
239 dcl console_is_free_parm bit (1) parameter; /* ON => console is free... (O) */
240
241 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
242
243
244 console_to_check = console_to_check_parm; /* copy args before we wire and mask... */
245
246 call lock_oc_data (); /* get the lock, wire and mask... */
247
248 oc_entry_ptr = find_oc_entry (console_to_check); /* locate the console... */
249 if oc_entry_ptr = null then do; /* no such animal... */
250 call unlock_oc_data (); /* release lock, unwire, unmask... */
251 console_is_free_parm = false; /* set parameter value... */
252 return;
253 end;
254
255 console_is_free = (^oc_entry.bootload_console & ^oc_entry.alternate); /* setup internal parm value... */
256
257 call unlock_oc_data (); /* release lock, unwire, unmask... */
258
259 console_is_free_parm = console_is_free; /* copy to caller's stack... */
260
261 return; /* done... */
262
263 console_info:
264 entry (oc_name, oc_flags, oc_channel, oc_device_idx, oc_line_leng, code);
265
266 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
267 /* */
268 /* Entry to return information about the requested console. If oc_name = "" then information about */
269 /* the bootload console is returned. */
270 /* */
271 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
272
273 /* parameters... (I) = Input, (O) = Output */
274
275 dcl oc_name char (4) aligned /* console info is requested for..(I/O) */
276 parameter;
277 dcl oc_flags bit (36) parameter; /* oc_entry.flags... (O) */
278 dcl oc_channel char (8) parameter; /* console's IOM channel... (O) */
279 dcl oc_device_idx fixed bin (17) parameter; /* console's assigned device index..(O) */
280 dcl oc_line_leng fixed bin (17) parameter; /* console's line length... (O) */
281 /* dcl code fixed bin (35) parameter; standard Multics error code... (O) */
282
283 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
284
285 oc_entry_ptr = find_oc_entry (oc_name); /* locate the requested console... */
286
287 if oc_entry_ptr = null then do; /* no such console... */
288 code = error_table_$device_not_active;
289 return;
290 end;
291
292 oc_flags = unspec (oc_entry.flags); /* copy the info... */
293 oc_channel = oc_entry.channel;
294 oc_device_idx = oc_entry.device_idx;
295 oc_line_leng = oc_entry.line_leng;
296
297 code = 0; /* indicate successful completion... */
298
299 return;
300
301 drain_io:
302 entry ();
303
304 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
305 /* */
306 /* Entry to quies the console. This is done by locking oc_data, thus preventing I/O queueing, then */
307 /* completing any I/O in progress and then attempting to complete any I/O in the queue. */
308 /* */
309 /* Note: This entry leaves oc_entry.io_in_progress set to prevent further attempts at I/O... */
310 /* */
311 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
312
313 oc_data_ptr = addr (oc_data$); /* locate oc_data... */
314
315 if ^oc_data.in_service | oc_data.mc_io_enabled then return; /* console is not configured... */
316
317 oc_entry_ptr = find_oc_entry (""); /* find the bootload console... */
318 if oc_entry_ptr = null then return; /* no console, no need to drain... */
319
320 do while (^done); /* quies the console... */
321 call lock_oc_data (); /* get the lock, wire and mask... */
322 do while (oc_entry.io_in_progress); /* finish I/O that is in progress... */
323 call process_io_status (); /* process received statuses... */
324 end;
325 if next_console_io () = null then done = true;
326 else call process_io (); /* and outstanding I/O... */
327 call unlock_oc_data (); /* release lock, unwire and unmask... */
328 end;
329
330 oc_entry.io_in_progress = true; /* only my hairdresser knows for sure...*/
331
332 return; /* pending I/O completed... */
333
334 err_event_chan:
335 entry (event_chan);
336
337 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
338 /* */
339 /* Entry which when called will install the event channel specified by the caller into */
340 /* oc_data.err_event_cid. This event channel will be utilizied to wakeup the caller any time a */
341 /* condition exists where I/O cannot be handled by any of the configured consoles. */
342 /* */
343 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
344
345 /* parameters... (I) = Input, (O) = Output */
346
347 dcl event_chan fixed bin (71) parameter; /* event channel to send wakeup on..(I) */
348
349 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
350
351 oc_data_ptr = addr (oc_data$); /* locate oc_data... */
352
353 oc_data.err_event_cid = event_chan; /* install the channel... */
354 oc_data.err_event_pid = pds$process_id; /* and the process ID of the caller... */
355
356 return; /* done... */
357
358 esd_reset:
359 entry ();
360
361 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
362 /* */
363 /* Entry called by ESD to ensure that it has a usable console. */
364 /* */
365 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
366
367 entrypoint = "esd_reset"; /* set entrypoint name... */
368
369 oc_data_ptr = addr (oc_data$); /* locate oc_data... */
370 oc_data.lock = ""b; /* reset lock... */
371
372 if ^oc_data.in_service then do; /* no good consoles to run on... */
373 return; /* all that is necessary... */
374 end;
375
376 oc_data.mc_io_enabled = false; /* MC will not be operative... */
377
378 oc_data.crash_on_crf = false; /* give ESD a fair shake at recovery... */
379
380 unspec (oc_data.priority_io) = ""b; /* erase any residue... */
381 oc_data.priority_io.completed = true; /* mark the slot free... */
382
383 do idx = 1 to WRITE_QUEUE_SIZE; /* free all WRITES... */
384 unspec (oc_data.write_queue (idx)) = ""b; /* erase any residue... */
385 oc_data.write_queue (idx).completed = true; /* mark the slot free... */
386 end;
387 oc_data.write_q_full = false; /* reset the full flag... */
388
389 oc_data.stacked_read_cnt = 1; /* free all READs, leave one pending... */
390 unspec (oc_data.read_io) = ""b; /* erase any residue... */
391 oc_data.read_io.completed = true; /* mark the slot free... */
392
393 call unassign_bootload_console (); /* unassign the bootload console... */
394
395 if oc_entry_ptr = null then do; /* no bootload console found... */
396 oc_data.in_service = false; /* best we can do... */
397 return;
398 end;
399
400 oc_entry.io_in_progress = false; /* reset certain flags... */
401 oc_entry.discard = false;
402 oc_entry.discarded = false;
403 oc_entry.got_special_int = false;
404 oc_entry.oper_request = false;
405 oc_entry.retry_cnt = 0;
406 oc_entry.io_time = 0;
407
408 call assign_bootload_console (oc_entry.name, err_code); /* and now re-assign it... */
409
410 call reset_channel (); /* reset the console channel... */
411
412 return;
413
414 get_input:
415 entry (input_text, input_length, code);
416
417 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
418 /* */
419 /* Entry to pickup operator input. Although there is only one physical READ I/O additional READs */
420 /* may be queued before this one completes. This is accomplished by stacking the READ requests. As */
421 /* a READ is picked up a check is made and the READ is reset if any READs have been stacked. */
422 /* */
423 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
424
425 /* parameters... (I) = Input, (O) = Output */
426
427 dcl input_text char (256) parameter; /* text of the input line... (O) */
428 dcl input_length fixed bin (17) parameter; /* length of the input line... (O) */
429 /* dcl code fixed bin (35) parameter; standard Multics error code... (O) */
430
431 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
432
433 input_text = ""; /* initialize... */
434 input_length = 0;
435 code = 0;
436
437 oc_entry_ptr = find_oc_entry (""); /* find the bootload console... */
438 if oc_entry_ptr = null then return; /* no console, no data... */
439
440 call lock_oc_data (); /* get the lock, wire and mask... */
441
442 local_io = oc_data.read_io; /* copy to local storage... */
443 call reset_read (); /* reset the READ I/O... */
444 oc_data.stacked_read_cnt = oc_data.stacked_read_cnt - 1; /* decrement the read stack... */
445 if oc_data.stacked_read_cnt > 0 then do; /* if we have stacked reads... */
446 call log_console_event (POPPED_READ, addr (oc_data.read_io)); /* log the POP... */
447 end;
448 call unlock_oc_data (); /* release lock, unwire and unmask... */
449 input_text = local_io.text; /* copy the input text... */
450 input_length = local_io.leng; /* and the input text length... */
451 call log_console_event (READ_PICKUP, addr (oc_data.read_io)); /* log the event... */
452
453 return;
454
455 get_mc_output:
456 entry (mc_io_uid , output_length, output_text);
457
458
459 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
460 /* */
461 /* Entry called be the Message Coordinator to pickup the text of a non-syserr message. The */
462 /* mc_io_uid contains the negated time that the message was queued. This was passed to the Message */
463 /* Coordinator when we told it there was someting to do. This message UID is used to search the */
464 /* message queue and retrieve the right message. */
465 /* */
466 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
467
468 /* parameters... (I) = Input, (O) = Output */
469
470 dcl mc_io_uid fixed bin (71) parameter; /* negated time queued of output... (I) */
471 dcl output_length fixed bin (17) parameter; /* (O) */
472 dcl output_text char (256) parameter; /* (O) */
473
474 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
475
476 oc_data_ptr = addr (oc_data$); /* locate oc_data... */
477 oc_entry_ptr = null;
478
479 do idx = 1 to WRITE_QUEUE_SIZE; /* search the WRITE queue... */
480 if -oc_data.write_queue (idx).time_queued = mc_io_uid then do; /* found it... */
481 console_io_ptr = addr (oc_data.write_queue (idx)); /* overlay the WRITE... */
482 output_length = multiply (console_io.leng, 4, 17); /* setup return parameters... */
483 output_text = console_io.text;
484 console_io.completed = true; /* free the I/O slot... */
485 oc_data.write_q_full = false; /* reset the full flag... */
486 call log_console_event (MC_IO_PICKUP, console_io_ptr);
487 return;
488 end;
489 end;
490
491 output_length = 0; /* requested output not found... */
492 output_text = "";
493
494 call log_console_event (MC_IO_FAILURE, null);
495
496 return; /* done... */
497
498 init_all_consoles:
499 entry ();
500
501 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
502 /* */
503 /* This entry is called by real_initializer during initialization to configure all consoles */
504 /* described in the config file. */
505 /* */
506 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
507
508 entrypoint = "init_all_consoles"; /* set entrypoint name... */
509
510 oc_data_ptr = addr (oc_data$); /* find oc_data... */
511 oc_entry_ptr = null;
512
513 unspec (oc_data) = ""b; /* zero the database... */
514
515 sd_ptr = addr (syserr_data$syserr_area); /* find syserr data... */
516 sd.char_type_flag = true; /* ASCII console... */
517 sd.ocdcm_init_flag = false; /* specify no active console yet... */
518
519 oc_data.version = oc_data_version; /* set the version... */
520 oc_data.flags.printer_on = true; /* start with echoing input... */
521
522 oc_data.last_read_queued = -1; /* initialize some times... */
523 oc_data.last_write_queued = -1;
524 oc_data.last_poll_time = -1;
525 oc_data.max_computed_io_time = MAX_MAX_IO_TIME * 1e06; /* for now... */
526
527 oc_data.next_free_write = 1; /* initialize indices... */
528 oc_data.next_event = 1;
529
530 oc_data.read_io.completed = true; /* free the read slot... */
531 oc_data.priority_io.completed = true; /* and mark priority as empty... */
532
533 do idx = 1 to WRITE_QUEUE_SIZE; /* mark all WRITE slots as free... */
534 oc_data.write_queue (idx).completed = true;
535 end;
536
537 oc_data.abs_addr = absadr (oc_data_ptr, err_code); /* find absolute address of oc_data... */
538 if err_code ^= 0 then call report_error (PANIC, entrypoint,
539 "Unable to determine absolute memory address of oc_data.");
540
541 oc_data.prompt = "M-> " || copy (byte (binary ("177"b3)), 4); /* setup prompt string & pad... */
542 oc_data.write_return = "177177012015"b3; /* string to write = PAD PAD CR LF... */
543 oc_data.discard_notice = byte (10) || byte (13) || "(output discarded)" || /* initialize the discard notice... */
544 byte (10) || byte (13) || copy (byte (binary ("177"b3)), 2);
545
546 prph_opc_cardp = null; /* initialize for card search... */
547
548 call config_$find_parm ("ccrf", parm_ptr); /* find the CCRF parm... */
549 if parm_ptr ^= null then oc_data.crash_on_crf = true; /* found it... */
550
551 call config_$find_parm ("clst", parm_ptr); /* find the CLST parm... */
552 if parm_ptr ^= null then oc_data.list_consoles = true; /* found it... */
553
554 do while (^done); /* process all "opc" "prph" cards... */
555 call config_$find ("prph", prph_opc_cardp); /* find a "prph" card... */
556 if prph_opc_cardp = null then done = true; /* no more prph cards... */
557 else do;
558 if substr (prph_opc_card.name, 1, 3) = "opc" then do; /* found an "opc" card... */
559 if oc_data.console_cnt = MAX_OPC_CNT then do; /* don't reference beyond oc_data... */
560 done = true; /* signal end of initialization loop... */
561 call report_error (BEEP, entrypoint, "Maximum console count exceeded.");
562 call report_error (ANNOUNCE, entrypoint, "Additional consoles will not be configured.");
563 end;
564 else do;
565 call fill_oc_entry (oc_data_ptr, /* build DCW list, etc... */
566 oc_data.console_cnt + 1, prph_opc_cardp, oc_entry_ptr);
567 if oc_entry.active then /* if we succeeded... */
568 oc_data.console_cnt = oc_data.console_cnt + 1;
569 end;
570 end;
571 end;
572 end;
573
574 if oc_data.console_cnt < 1 then do; /* must be at least one opc card... */
575 call report_error (PANIC, entrypoint, "Missing prph opc card.");
576 end;
577
578 do idx = 1 to oc_data.console_cnt; /* locate the console... */
579 oc_entry_ptr = addr (oc_data.opc (idx));
580 if oc_entry.bootload_console then do; /* found bootload console, turn it on...*/
581 call assign_bootload_console (oc_entry.name, err_code);
582 if err_code ^= 0 then call console_recovery ();
583 if oc_data.bootload_console_idx < 1 then
584 call report_error (PANIC, entrypoint, "Console channel assignment failed.");
585 sd.ocdcm_init_flag = true; /* enable syserr traffic... */
586 end;
587 end;
588
589 if oc_data.bootload_console_idx < 1 then do; /* must have an active console... */
590 call console_recovery ();
591 if oc_data.bootload_console_idx < 1 then
592 call report_error (PANIC, entrypoint, "No active console configured.");
593 end;
594
595 prph_opc_cardp = null; /* might as well use this ptr... */
596 cpu_cnt = 0; /* initialize the counter... */
597 done = false; /* initialize loop terminator... */
598
599 do while (^done); /* count the number of CPUs... */
600 call config_$find ("cpu", prph_opc_cardp);
601 if prph_opc_cardp ^= null then cpu_cnt = cpu_cnt + 1;
602 else done = true;
603 end;
604 /* maximum time we will wait for lock...*/
605 oc_data.max_computed_io_time = oc_data.max_computed_io_time * max (1, cpu_cnt);
606
607 if oc_data.list_consoles &
608 (sys_info$collection_1_phase = BOOT_INITIALIZATION
609 | sys_info$collection_1_phase = SERVICE_INITIALIZATION) then
610 do idx = 1 to oc_data.console_cnt; /* list the assignments... */
611 oc_entry_ptr = addr (oc_data.opc (idx));
612 device_type = "uninitialized";
613 if oc_entry.bootload_console then device_type = "bootload";
614 else if oc_entry.alternate then device_type = "alternate";
615 else if oc_entry.io_device then device_type = "I/O";
616 else if oc_entry.inop_device then device_type = "inoperative";
617 else if oc_entry.no_device then device_type = "off";
618 call report_error (ANNOUNCE, entrypoint, "Assigned console ^a as ^a device.",
619 oc_entry.name, device_type);
620 end;
621
622 if sys_info$collection_1_phase < SERVICE_INITIALIZATION then do; /* simulate a waiting READ... */
623 oc_data.opc (oc_data.bootload_console_idx).oper_request = true; /* prime the RE(TURN QUEST) key... */
624 end;
625
626 call log_console_event (INIT_OC_DATA, oc_data.io_ptr);
627
628 return; /* done... */
629
630 interrupt_handler:
631 entry (assigned_idx, interrupt_level, fault_status);
632
633 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
634 /* */
635 /* Entry called to field an interrupt for the console channel. It should be noted that any Multics */
636 /* process on the CPU when the interrupt arrives will execute this code. If we are unable to get */
637 /* the lock and we have a special interrupt (level 7) then we will post it in a special area of */
638 /* oc_data that can be modified without protection of the lock. It is the responsibility of anyone */
639 /* unlocking oc_data to process any pending specials. */
640 /* */
641 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
642
643 /* parameters... (I) = Input, (O) = Output */
644
645 dcl assigned_idx fixed bin (35) parameter; /* index of console causing interrupt. (I) */
646 dcl interrupt_level fixed bin (3) parameter; /* should be 1, 3, or 7... (I) */
647 dcl fault_status bit (36) parameter; /* system fault status, IGNORED... (I) */
648
649 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
650
651 entrypoint = "interrupt_handler"; /* set entrypoint name... */
652
653
654 entered_via_interrupt = true; /* show which way we came in.. */
655
656 if interrupt_level = 1 then do; /* IOM overhead fault... */
657 call report_error (JUST_LOG, entrypoint, "System Fault."); /* log it... */
658 return; /* and ignore it... */
659 end;
660
661 oc_data_ptr = addr (oc_data$); /* locate oc_data... */
662
663 oc_entry_ptr = find_oc_entry (""); /* locate the bootload console... */
664 if oc_entry_ptr = null then return; /* no bootload console... */
665 if assigned_idx > 0 & assigned_idx ^= oc_entry.device_idx then do; /* interrupt not from bootload console. */
666 if interrupt_level = 7 then return; /* no specials, please... */
667 do idx = 1 to oc_data.console_cnt; /* locate the console... */
668 if oc_data.opc (idx).device_idx = assigned_idx then /* found it... */
669 oc_entry_ptr = (addr (oc_data.opc (idx)));
670 end;
671 if assigned_idx ^= oc_entry.device_idx then return; /* could not locate console... */
672 if ^oc_entry.assigned then return; /* console no longer assigned... */
673 end;
674
675 if stac (addr (oc_data.lock), pds$process_id) then do; /* only field terminates if we get lock.*/
676 call wire_and_mask; /* so unlock can unwire... */
677 if interrupt_level = 7 then oc_entry.got_special_int = true; /* operator pushed RE(TURN QUEST) ... */
678
679 call process_io_status (); /* process any associated I/O status... */
680
681 call process_io (); /* process any waiting output... */
682
683 call unlock_oc_data (); /* release lock, unwire and unmask... */
684 end;
685 else if interrupt_level = 7 then do;
686 oc_data.no_lock_flags.got_special_int = true;
687 oc_data.meters.queued_special_int_count = oc_data.meters.queued_special_int_count +1;
688 end;
689
690 return;
691
692 poll_for_timeout:
693 entry ();
694
695 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
696 /* */
697 /* Entry called by traffic control to check for I/O timeouts on the console. */
698 /* */
699 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
700
701 oc_data_ptr = addr (oc_data$); /* locate oc_data... */
702
703 if ^oc_data.in_service | oc_data.mc_io_enabled then return; /* no console service, no timeouts... */
704
705 if oc_data.lock = pds$process_id then do; /* MYLOCK error... */
706 call report_error (PANIC, "lock_oc_data", "Mylock error."); /* crash system, store flagbox message..*/
707 end;
708
709 if ^stac (addr (oc_data.lock), pds$process_id) then return; /* if I can't get the lock return... */
710
711 oc_data.last_poll_time = clock (); /* note last time polling occured... */
712
713 oc_entry_ptr = find_oc_entry (""); /* find the bootload console entry... */
714
715 if oc_entry_ptr ^= null then do; /* only do if console available... */
716 call process_io_status (); /* timeout check done there.. */
717
718 call process_io (); /* process any waiting output... */
719 end;
720 else if ^oc_data.mc_io_enabled then
721 oc_data.in_service = false;
722
723 if ^stacq (oc_data.lock, ""b, pds$process_id) then do; /* clear lock... */
724 if oc_data.lock ^= ""b then /* if not free crash... */
725 call report_error (PANIC, "unlock_oc_data", "Lock not mine.");
726 end;
727
728 return; /* done... */
729
730 printer_off:
731 entry ();
732
733 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
734 /* */
735 /* Entry which implements "printer_off" control order. Once this entry has been called all input */
736 /* from the console will be in the blind until the "printer_on" entry is called. */
737 /* */
738 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
739
740 oc_data_ptr = addr (oc_data$); /* no need to lock and wire for this... */
741 oc_data.flags.printer_on = false; /* turn off read echoing... */
742 return; /* all there is to it... */
743
744 printer_on:
745 entry ();
746
747 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
748 /* */
749 /* Re-enables echoing of input from the console... */
750 /* */
751 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
752
753 oc_data_ptr = addr (oc_data$); /* no need to lock and wire for this... */
754 oc_data.flags.printer_on = true; /* turn it back on... */
755 return; /* all there is to it... */
756
757 priority_io:
758 entry (priority_io_ptr);
759
760 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
761 /* */
762 /* This entry provides a means of performing priority I/O to the operator's console. The I/O is */
763 /* placed into a special buffer in oc_data. The caller then calls the appropriate internal */
764 /* procedures to cause the I/O to be immediately executed. */
765 /* */
766 /* * * * W A R N I N G * * * */
767 /* */
768 /* The use of this entrypoint causes the caller to loop in ocdcm_ awaiting the successful */
769 /* completion of the I/O. This looping is done on a wired stack in a masked interrupt environment */
770 /* and can cause the processor of execution to loop for as long as it takes to complete the I/O. */
771 /* For READs this can take longer than thirty (30) seconds. */
772 /* */
773 /* Noting the effects that this can have on performance it is imperative that this entrypoint be */
774 /* utilized judiciously. */
775 /* */
776 /* Note: An additional side effect of this entrypoint is that I/O performed by it will not be in */
777 /* chronological order with I/O performed through the queue_io entrypoint. */
778 /* */
779 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
780
781 /* parameters... (I) = Input, (O) = Output */
782
783 dcl priority_io_ptr ptr parameter; /* -> console_io structure... (I) */
784
785 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
786
787 oc_data_ptr = addr (oc_data$); /* locate oc_data... */
788
789 if ^oc_data.in_service then return; /* no tickee, no washee... */
790
791 local_io = priority_io_ptr -> console_io; /* copy the I/O to our stack... */
792
793 call lock_oc_data (); /* get the lock, wire and mask... */
794
795 oc_data.priority_io = local_io; /* copy the priority I/O... */
796
797 oc_data.priority_io.time_queued = clock (); /* next_console_io needs this... */
798 oc_data.priority_io.process_id = pds$process_id; /* store our process_id... */
799 oc_data.priority_io.event_chan = 0; /* caller will loop on completion... */
800 oc_data.priority_io.completed = false; /* start off on the right foot.. */
801 oc_data.priority_io.in_progress = false;
802 oc_data.priority_io.alerted = false;
803
804 if oc_data.priority_io.read then do; /* reset READ stuff... */
805 oc_data.priority_io.sequence_no = 0; /* READs don't have syserr numbers... */
806 oc_data.priority_io.prompted = false;
807 oc_data.priority_io.leng = 0;
808 oc_data.priority_io.text = "";
809 end;
810
811 oc_entry_ptr = find_oc_entry (""); /* locate the bootload console... */
812
813 if oc_entry_ptr ^= null then
814 do while (oc_entry.io_in_progress); /* quies the console... */
815 call process_io_status ();
816 end;
817
818 if oc_data.mc_io_enabled then do; /* Message Coordinator is handling I/O..*/
819 if ^oc_data.priority_io.read then do; /* only pass on WRITEs... */
820 call bump_io_to_mc ((oc_data.priority_io.sequence_no));
821 oc_data.priority_io.completed = true; /* free the space... */
822 end;
823 call unlock_oc_data (); /* release lock, unwire, unmask... */
824 return; /* all we can do... */
825 end;
826
827
828 do while (^oc_data.priority_io.completed); /* LOOP IN RING ZERO TILL I/O COMPLETE..*/
829 call process_io (); /* process the I/O... */
830 if oc_data.priority_io.read & ^oc_data.priority_io.in_progress then do;
831 call unlock_oc_data (); /* let Special interrupts through... */
832 call lock_oc_data (); /* and wire and mask again... */
833 end;
834 call process_io_status (); /* process the status... */
835 end;
836
837 local_io = oc_data.priority_io; /* copy results to local storage... */
838 oc_data.priority_io.read = false; /* prevent priority READ resets... */
839
840 call unlock_oc_data (); /* release lock, unwire and unmask... */
841
842 if local_io.read then do; /* copy results for the caller... */
843 priority_io_ptr -> console_io = local_io;
844 end;
845
846 return; /* I/O complete... */
847
848 queue_io:
849 entry (user_io_ptr, io_queue_time);
850
851 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
852 /* */
853 /* Entry to queue an I/O. This entry first copies the I/O onto our stack before we wire it with a */
854 /* call to lock_oc_data. This is necessary because we would are not allowed to page fault on the */
855 /* callers data after we wire ourselves. The entry the makes some preliminary decisions about the */
856 /* I/O and the console state and calls the queue_console_io routine to do the actual queueing. For */
857 /* WRITEs the caller is returned the time that the I/O is queued. If that time is 0 then the queue */
858 /* is full and the caller will have to try again later. A time of 0 is always returned for */
859 /* READs since the caller always goes blocked awaiting READ completion. */
860 /* */
861 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
862
863 /* parameters... (I) = Input, (O) = Output */
864
865 dcl user_io_ptr ptr parameter; /* -> console_io structure... (I) */
866 dcl io_queue_time fixed bin (71) parameter; /* UID of this I/O request... (O) */
867
868 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
869
870 oc_data_ptr = addr (oc_data$); /* find oc_data... */
871
872 if ^oc_data.in_service then do; /* pass it to the log... */
873 call syserr (JUST_LOG, substr (user_io_ptr -> console_io.text, 1,
874 multiply (user_io_ptr -> console_io.leng, 4, 17)));
875 io_queue_time = clock (); /* make it look as if successful... */
876 return;
877 end;
878
879 local_io = user_io_ptr -> console_io; /* copy the I/O to our stack... */
880
881 if oc_data.write_q_full & ^local_io.read then do; /* no room at the Inn... */
882 oc_data.meters.write_q_full_cnt = oc_data.meters.write_q_full_cnt + 1;
883 io_queue_time = 0; /* make them try again... */
884 return;
885 end;
886
887 call lock_oc_data (); /* get the lock, wire and mask... */
888
889 oc_entry_ptr = find_oc_entry (""); /* locate the bootload console... */
890
891 if oc_data.mc_io_enabled then do; /* Message Coordinator is handling I/O..*/
892 local_time = 0;
893 if ^local_io.read then do; /* only pass on WRITEs... */
894 local_time = queue_console_io (); /* attempt to queue the I/O... */
895 if local_time ^= 0 then do; /* if we were successful then do... */
896 call bump_io_to_mc ((-local_time)); /* send I/O to the MC... */
897 end;
898 end;
899 else local_time = clock (); /* simulate successful queuing of READ..*/
900 call unlock_oc_data (); /* release lock, unwire, unmask... */
901 io_queue_time = local_time; /* copy argument... */
902 return; /* all we can do... */
903 end;
904
905 if oc_entry_ptr = null then do; /* no bootload console... */
906 call syserr (JUST_LOG, substr (user_io_ptr -> console_io.text, 1,
907 multiply (user_io_ptr -> console_io.leng, 4, 17)));
908 io_queue_time = clock (); /* make it look as if successful... */
909 oc_data.in_service = false;
910 return;
911 end;
912
913 if oc_entry.discard & ^local_io.read then do; /* if DISCARD condition and not a READ..*/
914 if ^oc_entry.discarded then do; /* haven't informed them yet... */
915 oc_entry.discarded = true; /* note that we're informing them... */
916 call log_console_event (DISCARDED_OUTPUT, oc_data.io_ptr); /* log it... */
917 end;
918 call unlock_oc_data (); /* release lock, unwire and unmask... */
919 io_queue_time = -1; /* let caller know... */
920 return; /* flush the output... */
921 end;
922
923 call process_io_status (); /* process any pending I/O status... */
924 call process_io (); /* process any pending I/O... */
925 local_time = queue_console_io (); /* attempt to queue the I/O... */
926
927 call process_io (); /* attempt to start the I/O... */
928
929 call unlock_oc_data (); /* release lock, unwire and unmask... */
930
931 io_queue_time = local_time; /* copy argument... */
932
933 return;
934
935 reconfigure:
936 entry (console_name_parm, reconfig_option_parm, code);
937
938 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
939 /* */
940 /* This entry is called to explicitly reconfigure any configured console. The respective actions */
941 /* taken are controlled via the reconfig_option parameter and are described in */
942 /* opc_reconfig_options.incl.pl1 */
943 /* */
944 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
945
946 /* parameters... (I) = Input, (O) = Output */
947
948 dcl console_name_parm char (4) parameter; /* console being reconfigured or MCA */
949 /* number to unlock "M_xx"... (I) */
950 dcl reconfig_option_parm fixed bin (17) parameter; /* see opc_reconfig_options... (I) */
951 /* dcl code fixed bin (35) parameter; standard Multics error code... (O) */
952
953 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
954
955 entrypoint = "reconfigure"; /* set entrypoint name... */
956 audit_flag = "0"b;
957 code = 0; /* initialize it... */
958 console_name = console_name_parm; /* copy arguments into our stack... */
959 reconfig_option = reconfig_option_parm;
960
961 oc_data_ptr = addr (oc_data$); /* for unwired operations... */
962
963 if reconfig_option = NOP then do; /* just return an error code... */
964 code = error_table_$no_operation;
965 end;
966
967 if reconfig_option = SUSPEND_CONSOLE_SERVICE then do; /* indicate no console service... */
968 oc_data.in_service = false; /* and normal I/O... */
969 return;
970 end;
971
972 if reconfig_option = ENABLE_CONSOLE_SERVICE then do; /* indicate no console service... */
973 oc_data.in_service = true; /* and normal I/O... */
974 return;
975 end;
976
977 if reconfig_option = SEND_MC_IO then do; /* send I/O to MC... */
978 oc_data.mc_io_enabled = true;
979 return;
980 end;
981
982 if reconfig_option = CRASH_ON_CRF then do; /* set the right flags... */
983 oc_data.crash_on_crf = true;
984 return;
985 end;
986
987 if reconfig_option = RUN_ON_CRF then do; /* set the right flags... */
988 oc_data.crash_on_crf = false;
989 return;
990 end;
991
992 if reconfig_option = UNLOCK_MCA_INPUT then do; /* save mca# & reset console_name... */
993 mca_to_unlock = cv_dec_check_ (substr (console_name, 3, 2), err_code);
994 if substr (console_name, 1, 2) ^= "M_" | err_code ^= 0 | mca_to_unlock < MIN_MCA | mca_to_unlock > MAX_MCA then do;