1 /****^  ***********************************************************
  2         *                                                         *
  3         * Copyright, (C) Honeywell Bull Inc., 1987                *
  4         *                                                         *
  5         * Copyright, (C) Honeywell Information Systems Inc., 1984 *
  6         *                                                         *
  7         * Copyright (c) 1972 by Massachusetts Institute of        *
  8         * Technology and Honeywell Information Systems, Inc.      *
  9         *                                                         *
 10         *********************************************************** */
 11 
 12 /* This program is the ring zero portion of the dynamic reconfiguration software
 13    for system controllers and processors. It is callable only through hphcs_ and assumes
 14    the caller has validated the arguments so that they within proper range.
 15 
 16    Modified March 1976 by Steve Webber -- Initial coding
 17    modified 4/6/76 by Noel I. Morris
 18    last modified 4/13/78 by J. A. Bush to add code for cpu testing
 19    Modified 16 Feb 79 by D. Spector to recompute write_limit when reconfiguring memory
 20    Modified 09/11/80 by J. A. Bush for the DPS8/70M cpu
 21    Modified April 1982 by J. Bongiovanni for expanded SCS switch/mask
 22    Modified June 1982 by J. Bongiovanni to fix bug in adding an SCU with
 23    less memory than the port size
 24    Modified Sept 1983 by J. A. Bush to increase ISOLTS required memory to 128K for DPS8 cpus
 25    Modified 6/14/83 by S. Krupp to add rc_lock entry.
 26 
 27 */
 28 /* format: style4,delnl,insnl,indattr,ifthen,dclind10 */
 29 
 30 reconfig:
 31      proc;
 32 
 33 /* Parameters */
 34 
 35 dcl       tag                    fixed bin (3);
 36 dcl       (cpu_tag, scu_tag, scu_port)
 37                                  fixed bin (5);
 38 dcl       switches               (4) bit (36) aligned;
 39 dcl       lace                   bit (1) aligned;
 40 dcl       badtag                 fixed bin (3);
 41 dcl       code                   fixed bin (35);
 42 dcl       first_frame            fixed bin;
 43 dcl       n_frames               fixed bin;
 44 dcl       (rci_ptr, wseg_p)      ptr;
 45 
 46 /* Automatic */
 47 
 48 dcl       tcode                  fixed bin (35);
 49 dcl       errtag                 fixed bin (3);
 50 dcl       first                  fixed bin (3);
 51 dcl       last                   fixed bin (3);
 52 dcl       (i, k)                 fixed bin;
 53 dcl       j                      fixed bin (3);
 54 dcl       vl                     fixed bin (3);
 55 dcl       req_mem                fixed bin;
 56 dcl       size                   fixed bin;
 57 dcl       base                   fixed bin;
 58 dcl       top                    fixed bin;
 59 dcl       abs_seg_p              ptr;
 60 dcl       p_mess                 bit (1);
 61 dcl       switchesp              ptr;
 62 dcl       1 tsdw                 aligned like sdw;
 63 
 64 /* Based */
 65 
 66 dcl       based_switches         (4) bit (36) aligned based (switchesp);
 67 
 68 /* External */
 69 
 70 dcl       error_table_$bad_subr_arg fixed bin(35) ext static;
 71 dcl       pds$processid          bit (36) aligned ext;
 72 dcl       pds$process_group_id   char (32) aligned ext;
 73 dcl       isolts_abs_seg$        ext;
 74 
 75 /* Entries */
 76 
 77 dcl       syserr                 entry options (variable);
 78 dcl       start_cpu              entry (fixed bin (3), fixed bin (35));
 79 dcl       configure_test_cpu     entry (fixed bin (35));
 80 dcl       configure_test_cpu$isolts_final
 81                                  entry;
 82 dcl       level$get              entry returns (fixed bin (3));
 83 dcl       privileged_mode_ut$swap_sdw
 84                                  entry (ptr, ptr);
 85 dcl       config_$find_2         entry (char (4) aligned, fixed bin, ptr);
 86 dcl       config_$update         entry ();
 87 dcl       stop_cpu               entry (fixed bin (3), fixed bin (35));
 88 dcl       add_scu                entry (fixed bin (3), fixed bin (3), fixed bin (35));
 89 dcl       freecore               entry (fixed bin);
 90 dcl       pc_abs$remove_core     entry (fixed bin, fixed bin, fixed bin (35));
 91 dcl       add_scu$remove_scu     entry (fixed bin (3));
 92 dcl       validate_cpu_card      entry (fixed bin (3), ptr);
 93 
 94 /* Builtins */
 95 
 96 dcl       (addr, bin, bit, divide, hbound, max, mod, null, rel, stac, stacq, string, substr, unspec)
 97                                  builtin;
 98 
 99 /* constants */
100 
101 dcl       letters                char (15) int static options (constant) init ("abcdefghijklmo");
102 ^L
103 /*
104    ADD_CPU               ADD_CPU               ADD_CPU
105 
106    This entry is called to add a processor to the system
107 
108 */
109 
110 add_cpu:
111      entry (tag, switches, code);
112 
113           if check_lock () then
114                return;                                      /* not locked to us */
115 
116           if scs$processor_data (tag).online then do;       /* If already online ... */
117                code = rcerr_online;
118                call UNLOCK;
119                return;
120           end;
121 
122           if ^scs$processor_data (tag).offline then do;     /* If not offline ... */
123                code = rcerr_no_config;
124                call UNLOCK;
125                return;
126           end;
127 
128           call start_cpu (tag, tcode);                      /* do the work */
129 
130 /* Perform error checking and recovery. */
131 
132           if tcode ^= 0 then do;
133                code = tcode;                                /* Return the error code. */
134                switchesp = addr (scs$processor_switch_compare (1));
135                switches = based_switches;                   /* Return switch 1-4 descrepancies */
136 
137           end;
138 
139           call UNLOCK;
140 
141           return;
142 ^L
143 /*
144    DEL_CPU               DEL_CPU               DEL_CPU
145 
146 
147    This entry is called to delete a processor from the system
148 
149 */
150 
151 del_cpu:
152      entry (tag, code);
153 
154           if check_lock () then
155                return;
156 
157           if ^scs$processor_data (tag).online then do;      /* If not online ... */
158                code = rcerr_not_online;
159                call UNLOCK;
160                return;
161           end;
162 
163           if scs$nprocessors <= 1 then do;                  /* If only one processor ... */
164                code = rcerr_delcpu_last;
165                call UNLOCK;
166                return;
167           end;
168 
169           call stop_cpu (tag, tcode);
170           if tcode ^= 0 then
171                code = tcode;
172 
173           call UNLOCK;
174 
175           return;
176 ^L
177 /*
178    ADD_SCU               ADD_SCU               ADD_SCU
179 
180    This entry is called to add a system controller and its memory to the system. If the
181    system controller is one of a pair of externally interlaced
182    controllers, both controllers are added.
183 
184 */
185 
186 add_scu:
187      entry (tag, lace, badtag, code);
188 
189           if check_lock () then
190                return;
191 
192           if scs$controller_data (tag).online then do;      /* If already online ... */
193                code = rcerr_online;
194                call UNLOCK;
195                return;
196           end;
197           if ^scs$controller_data (tag).offline then do;    /* If not offline ... */
198                code = rcerr_no_config;
199                call UNLOCK;
200                return;
201           end;
202           if scs$controller_data (tag).ext_interlaced then do;
203                first = tag - mod (tag, 2);
204                last = first + 1;
205                lace = "1"b;
206           end;
207           else do;
208                first, last = tag;
209                lace = "0"b;
210           end;
211 
212           do j = first to last;
213                call add_scu (j, errtag, tcode);
214                if tcode ^= 0 then do;
215                     code = tcode;                           /* Return the error code. */
216                     badtag = errtag;
217 
218                     if (first ^= last) & (j = last) then    /* must undo for first */
219                          call add_scu$remove_scu (first);
220 
221                     call UNLOCK;
222 
223                     return;
224                end;
225           end;
226 
227           do j = first to last;
228                call free_all_of (j);
229           end;
230 
231           call UNLOCK;
232 
233           call recompute_write_limit;
234 
235           return;
236 ^L
237 /*
238    DEL_SCU               DEL_SCU               DEL_SCU
239 
240 
241    This entry is called to delete a system controller and its memory from the system. If the system
242    controller is one of a pair of externally interlaced controllers, the
243    other controller of the pair is also deleted.
244 
245 */
246 
247 del_scu:
248      entry (tag, lace, code);
249 
250           if check_lock () then
251                return;
252 
253           if ^scs$controller_data (tag).online then do;
254                code = rcerr_not_online;
255                call UNLOCK;
256                return;
257           end;
258           if scs$controller_data (tag).ext_interlaced then do;
259                first = tag - mod (tag, 2);
260                last = first + 1;
261                lace = "1"b;
262           end;
263           else do;
264                first, last = tag;
265                lace = "0"b;
266           end;
267 
268           do j = first to last;
269                base = scs$controller_data (j).base;
270                size = scs$controller_config_size (j);
271 
272 
273                call pc_abs$remove_core (base, size, tcode);
274                if tcode ^= 0 then do;
275                     if (first ^= last) & (j ^= first) then
276                          call free_all_of (first);
277 
278                     call UNLOCK;
279 
280                     if tcode = 1 then
281                          code = rcerr_delmain_nomem;
282                     else if tcode = 2 then
283                          code = rcerr_delmain_abs_wired;
284                     else code = tcode;
285 
286                     return;
287                end;
288           end;
289 
290           do j = first to last;
291                call add_scu$remove_scu (j);
292           end;
293 
294           call UNLOCK;
295 
296           call recompute_write_limit;
297 
298           return;
299 ^L
300 /*
301    ADD_MAIN              ADD_MAIN              ADD_MAIN
302 
303 
304    This entry is used to add a subregion of a controller to the system.
305 
306 */
307 
308 add_main:
309      entry (first_frame, n_frames, code);
310 
311           if check_lock () then
312                return;
313 
314           if check_range () then
315                return;
316 
317           do k = first_frame to first_frame + n_frames - 1;
318                call freecore (k);
319           end;
320 
321           call UNLOCK;
322 
323           call recompute_write_limit;
324 
325           return;
326 
327 
328 
329 
330 /*
331    DEL_MAIN              DEL_MAIN              DEL_MAIN
332 
333 
334    This entry is used to remove selected regions of a controller from the system
335 
336 */
337 
338 del_main:
339      entry (first_frame, n_frames, code);
340 
341           if check_lock () then
342                return;
343 
344           if check_range () then
345                return;
346 
347           call pc_abs$remove_core (first_frame, n_frames, tcode);
348           if tcode ^= 0 then do;
349                if tcode = 1 then
350                     code = rcerr_delmain_nomem;
351                else if tcode = 2 then
352                     code = rcerr_delmain_abs_wired;
353                else code = tcode;
354           end;
355 
356           call UNLOCK;
357 
358           call recompute_write_limit;
359 
360           return;
361 ^L
362 /*        RECOMPUTE_WRITE_LIMIT                   RECOMPUTE_WRITE_LIMIT
363 
364    When memory is reconfigured, write_limit is set to 1/8 of pages used
365    (but no less than 30).  This overrides any explicit change via
366    change_tuning_parameters.
367 
368 */
369 
370 recompute_write_limit:
371      proc;
372 
373 declare  sst$write_limit        fixed bin (35) external static;
374 declare  sst$nused              fixed bin (35) external static;
375 
376           sst$write_limit = max (30, divide (sst$nused, 8, 17, 0));
377 
378      end;
379 ^L
380 /*
381    RC_FORCE_UNLOCK       RC_FORCE_UNLOCK       RC_FORCE_UNLOCK
382 
383 
384    This entry is called to unlock the reconfig lock.
385 
386 */
387 
388 rc_unlock:
389      entry;
390 
391           if scs$reconfig_lock ^= pds$processid then
392                return;                                      /* not locked to us */
393 
394 
395 rc_force_unlock:
396      entry;
397 
398           call UNLOCK;
399 
400           return;
401 
402 
403 /*
404    RC_LOCK               RC_LOCK               RC_LOCK
405 
406    This entry is called to set the reconfiguration lock.
407 
408    If the lock is already locked, the error code set by check_lock
409    is returned. Otherwise, check_lock locks the lock and a code of 0
410    is returned.
411 */
412 
413 rc_lock:
414      entry (code);
415 
416           if ^check_lock () then
417                code = 0;
418 
419           return;
420 
421 
422 /* UNLOCK                UNLOCK                UNLOCK */
423 
424 UNLOCK:
425      proc;
426 
427           if ^stacq (scs$reconfig_lock, (36)"0"b, scs$reconfig_lock) then
428                call syserr (0, "reconfig: trouble unlocking scs$reconfig_lock");
429 
430      end UNLOCK;
431 
432 
433 
434 /* CHECK_LOCK            CHECK_LOCK            CHECK_LOCK */
435 
436 check_lock:
437      proc returns (bit (1) aligned);
438 
439           code = 0;
440 
441           if ^stac (addr (scs$reconfig_lock), pds$processid) then do;
442                code = rcerr_locked;
443                return ("1"b);
444           end;
445 
446           else do;
447                scs$reconfig_locker_id = pds$process_group_id;
448                return ("0"b);
449           end;
450 
451 
452      end check_lock;
453 ^L
454 /* FREE_ALL_OF           FREE_ALL_OF           FREE_ALL_OF */
455 
456 free_all_of:
457      proc (mem);
458 
459 dcl       mem                    fixed bin (3);
460 
461 dcl       i                      fixed bin;
462 dcl       base                   fixed bin;
463 dcl       top                    fixed bin;
464 
465           base = scs$controller_data (mem).base;
466           top = scs$controller_config_size (mem) + base - 1;
467           do i = base to top;
468                call freecore (i);
469           end;
470 
471      end free_all_of;
472 
473 
474 
475 /* CHECK_RANGE           CHECK_RANGE           CHECK_RANGE */
476 
477 check_range:
478      proc returns (bit (1) aligned);
479 
480 dcl       i                      fixed bin;
481 dcl       base                   fixed bin;
482 dcl       top                    fixed bin;
483 
484           if n_frames < 0 then do;
485                code = error_table_$bad_subr_arg;
486                goto check_range_error;
487           end;
488 
489           do i = 0 to 7;
490                if scs$controller_data (i).online then do;
491                     base = scs$controller_data (i).base;
492                     top = base + scs$controller_config_size (i) - 1;
493                     if (first_frame >= base) & (first_frame + n_frames - 1 <= top) then
494                          return ("0"b);
495                end;
496           end;
497 
498           code = rcerr_range;
499 check_range_error:
500           call UNLOCK;
501 
502           return ("1"b);
503 
504      end check_range;
505 ^L
506 /*
507    RECONFIG_INFO         RECONFIG_INFO         RECONFIG_INFO
508 
509 
510    This entry is used to return information about the current configuration. The reconfig lock in
511    scs is also set. If the lock is not settable (locked to other logged in process) the
512    process_group_id of that process is returned, along with an error code
513 
514 */
515 
516 reconfig_info:
517      entry (rci_ptr, code);
518 
519           if ^stac (addr (scs$reconfig_lock), pds$processid) then do;
520                rci_ptr -> rci.locker_group_id = scs$reconfig_locker_id;
521                code = rcerr_locked;
522                return;
523           end;
524 
525           code = 0;
526           scs$reconfig_locker_id = pds$process_group_id;
527 
528 /* Now copy the data from the SCS */
529 
530           rci_ptr -> rci.controller_data = scs$controller_data;
531           rci_ptr -> rci.processor_data = scs$processor_data;
532 
533           return;
534 ^L
535 /*
536    CHECK_RESOURCE   CHECK_RESOURCE      CHECK_RESOURCE
537 
538 
539    This entry is the initial entry for the ISOlTS reconfiguration software. It is called by the ISOLTS driver
540    to check if the Processor and Memory resources required to test a CPU are present. Note that the reconfig
541    lock is set upon entry but is not reset on exit. The reconfig lock will remain set until the destroy_cpu_test_env
542    entry is called.
543 */
544 
545 check_resource:
546      entry (cpu_tag, scu_tag, scu_port, code);
547 
548           code = 0;                                         /* preset return code  to 0 */
549 
550           if check_lock () then do;                         /* lock reconfig lock if possible */
551                code = rcerr_isolts_locked;                  /* data base already locked */
552                return;
553           end;
554 
555           if cpu_tag > hbound (scs$processor_data, 1) then do;
556                                                             /* trying to test non existant cpu */
557                code = rcerr_isolts_illegal_cpu;
558                call UNLOCK;                                 /* unlock reconfig lock */
559                return;
560           end;
561 
562           if scs$processor_data (cpu_tag).online then do;   /* cpu must be offline */
563                code = rcerr_isolts_cpu_online;
564                call UNLOCK;
565                return;
566           end;
567 
568           if ^scs$processor_data (cpu_tag).offline then do; /* trying to test cpu that is not configured */
569                code = rcerr_isolts_no_config;
570                call UNLOCK;
571                return;
572           end;
573 
574           if scu_tag = -1 then do;                          /* We will determine which SCU to use */
575 
576 /* find scu that is not zero based and has the smallest amount of memory */
577 
578                k = -1;
579                do i = 0 to hbound (scs$controller_data, 1); /* iterate through all possible scu's */
580                     if scs$controller_data (i).online then  /* if scu online */
581                          if scs$controller_data (i).base ^= 0 then
582                                                             /* and not zero based */
583                               if scs$controller_data (i).size >= 128 then
584                                                             /* and if memory size is at least 128k */
585                                    if ^scs$controller_data (i).abs_wired then
586                                                             /* and no abs wired pages */
587                                         if ^scs$controller_data (i).ext_interlaced then
588                                                             /* and not ext interlaced */
589                                              if k ^= -1 then/* not first time through */
590                                                   if scs$controller_data (i).size <
591                                                             /* if size of this scu is less */
592                                                        scs$controller_data (k).size then
593                                                             /* then previous saved */
594                                                        k = i;
595                                                             /* save this tag */
596                                                   else ;
597                                              else k = i;    /* first time through, save this tag */
598                end;
599 
600                if k = -1 then do;                           /* Not enough SCUs to continue */
601                     code = rcerr_isolts_two_scu;
602                     call UNLOCK;
603                     return;
604                end;
605                scu_tag = k;                                 /* save the scu tag to return to user */
606           end;
607 
608           else do;                                          /* user wants to run with particular SCU */
609 
610                if scu_tag > hbound (scs$controller_data, 1) then do;
611                                                             /* check it for legality */
612                     code = rcerr_isolts_illegal_scu;
613                     call UNLOCK;
614                     return;
615                end;
616 
617                if scu_tag = scs$interrupt_controller then do;
618                                                             /* can't use bootload controller */
619                     code = rcerr_isolts_bootload_scu;
620                     call UNLOCK;
621                     return;
622                end;
623 
624                if ^scs$controller_data (scu_tag).online then do;
625                                                             /* scu must be online */
626                     code = rcerr_isolts_scu_not;
627                     call UNLOCK;
628                     return;
629                end;
630 
631           end;
632 
633           scu_port = scs$processor_data (cpu_tag).controller_port;
634                                                             /* set port for user */
635 
636           return;                                           /*  return with no error and reconfig lock locked */
637 ^L
638 /*
639    CREATE_CPU_TEST_ENV        CREATE_CPU_TEST_ENV CREATE_CPU_TEST_ENV
640 
641 
642    This entry is called by the ISOLTS driver after  manual reconfiguration of a CPU to test and the SCU to be
643    used for testing is accomplished by the Operator.
644 
645 */
646 
647 create_cpu_test_env:
648      entry (cpu_tag, scu_tag, switches, wseg_p, code);
649 
650           code = 0;                                         /* preset return code */
651           wseg_p = null;                                    /* set work seg ptr to null initially */
652 
653           if scs$reconfig_lock ^= pds$processid then do;    /* not locked to us */
654                code = rcerr_isolts_not;
655                return;
656           end;
657           scs$processor_test_data.cpu_tag = cpu_tag;        /* initialize  processor_test_data structure */
658           scs$processor_test_data.scu_tag = scu_tag;
659           scs$processor_test_data.scu_state = "00"b;
660           scs$processor_test_data.active = "1"b;            /* set active flag */
661 
662           call configure_test_cpu (tcode);                  /* go do the work */
663           switchesp = addr (scs$processor_switch_compare (1));
664           switches = based_switches;                        /* return switch info 1-4 */
665           if tcode ^= 0 then do;                            /* bad problems */
666                call destroy_cpu_test_env_no_mess;           /* give back all resources */
667                code = tcode;
668                return;
669           end;
670           abs_seg_p = addr (isolts_abs_seg$);               /* get ptr to isolts_abs_seg */
671           req_mem = scs$processor_test_data.req_mem;        /* get auto copy of memory required */
672 
673 /* set up an sdw for isolts_abs_seg that points to the base of our scu */
674 
675           vl = level$get ();                                /* get users current validation level */
676           string (tsdw) = "0"b;
677           tsdw.add = bit (bin (scs$controller_data (scu_tag).base * 1024, 24), 24);
678           tsdw.r1, tsdw.r2, tsdw.r3 = bit (bin (vl, 3), 3); /* set ring brks to users validation level */
679           tsdw.df = "1"b;                                   /* do not want seg fault on this segment */
680           tsdw.read = "1"b;
681           tsdw.write = "1"b;                                /* set read and write access for user */
682           tsdw.unpaged = "1"b;                              /* this is an unpaged segment */
683           tsdw.bound = bit (bin (divide (req_mem * 1024, 16, 14) - 1, 14), 14);
684                                                             /* set bounds for <req_mem>k */
685           call privileged_mode_ut$swap_sdw (abs_seg_p, addr (tsdw));
686                                                             /* swap new sdw with current one */
687           wseg_p = abs_seg_p;                               /* give ptr to isolts abs seg to user */
688           call config_$find_2 (CPU_CARD_WORD, cpu_tag + 1, cpu_cardp);
689                                                             /* set up target cpu card */
690           cpu_card.state = "test";                          /* for test state */
691           call config_$update ();
692           call validate_cpu_card ((cpu_tag), addr (scs$processor_switch_compare (2)));
693                                                             /* validate cpu type and model */
694 
695           call syserr (0, "reconfig: Assigned CPU ^a to ^a for testing",
696                                                             /* tell operator what we are doing */
697                substr (letters, cpu_tag + 1, 1), pds$process_group_id);
698           call syserr (0, "reconfig: Using base ^dk of MEM ^a for testing CPU ^a", req_mem,
699                substr (letters, scu_tag + 1, 1), substr (letters, cpu_tag + 1, 1));
700 
701           return;                                           /* return to caller */
702 ^L
703 /*
704    DESTROY_CPU_TEST_ENV       DESTROY_CPU_TEST_ENV          DESTROY_CPU_TEST_ENV
705 
706    This entry is called by the ISOLTS driver to undo any reconfiguration that was done for cpu testing.
707    It is also called by the answering service hardcore module deact_proc if the condition of the reconfig_lock is set
708    with the process_id of the process in termination and the processor_test_data.active flag is on.
709    this acts as a system cleanup handler in case of ISOLTS process abnormal termination.
710 
711 */
712 
713 destroy_cpu_test_env:
714      entry;
715 
716           p_mess = "1"b;                                    /* set flag to display unassign message */
717           go to destroy_test_env_com;                       /* go join common code */
718 
719 destroy_cpu_test_env_no_mess:
720      entry;
721 
722           p_mess = "0"b;                                    /* reset flag do not print unassign messages */
723 
724 destroy_test_env_com:
725           if scs$processor_test_data.active then do;        /* if test active */
726                call configure_test_cpu$isolts_final;        /* give back SCU and memory to system */
727                abs_seg_p = addr (isolts_abs_seg$);          /* destroy users sdw to isolts_abs_seg */
728                string (tsdw) = "0"b;
729                call privileged_mode_ut$swap_sdw (abs_seg_p, addr (tsdw));
730                call config_$find_2 (CPU_CARD_WORD, scs$processor_test_data.cpu_tag + 1, cpu_cardp);
731                cpu_card.state = "off ";                     /* reset cpu state to off */
732                call config_$update ();
733                if p_mess then do;                           /* only output messages if entry by destroy_cpu_test_env */
734                     call syserr (0, "reconfig: Unassigned CPU ^a from ^a",
735                                                             /* tell operator what we are doing */
736                          substr (letters, scs$processor_test_data.cpu_tag + 1, 1), scs$reconfig_locker_id);
737                     call syserr (0, "reconfig: Releasing base ^dk of MEM ^a", scs$processor_test_data.req_mem,
738                          substr (letters, scs$processor_test_data.scu_tag + 1, 1));
739                end;
740                unspec (scs$processor_test_data) = "0"b;     /* initialize test data structure */
741           end;
742 
743 /* reset reconfig_lock, and return */
744 
745           call UNLOCK;
746 
747           return;
748 ^L
749 %include config_cpu_card;
750 %page;
751 %include scs;
752 %page;
753 %include sdw;
754 %page;
755 %include rcerr;
756 %include rci;
757 ^L
758 /* BEGIN MESSAGE DOCUMENTATION
759 
760    Message:
761    reconfig: trouble unlocking scs$reconfig_lock
762 
763    S:     $info
764 
765    T:     $run
766 
767    M:     The reconfiguration lock
768    could not be unlocked.
769    It is left in its current state.
770    Further attempts at reconfiguration may fail.
771 
772    A:     $ignore
773 
774    Message:
775    reconfig: Assigned CPU <cputag> to <Person.Project.instance> for testing
776 
777    S: $info
778 
779    T: $run
780 
781    M: Successful reconfiguration of the indicated processor has been
782    performed by the processor testing (ISOLTS) subsystem.
783 
784    A: $ignore
785 
786    Message:
787    reconfig: Using base <req_mem>k of MEM <scutag> for testing CPU cputag
788 
789    S: $info
790 
791    T: $run
792 
793    M: Successful reconfiguration of the indicated memory has been
794    performed by the processor testing (ISOLTS) subsystem.
795 
796    A: $ignore
797 
798    Message:
799    reconfig: Unassigned CPU <cputag> from <Person.Project.instance>
800 
801    S: $info
802 
803    T: $run
804 
805    M: Processor testing has been terminated and the indicated
806    processor is now available for reconfiguration.
807 
808    A: $ignore
809 
810    Message:
811    reconfig: Releasing base <req_mem>k of MEM <scutag>
812 
813    S: $info
814 
815    T: $run
816 
817    M: Processor testing has been terminated and the indicated
818    memory is now available for reconfiguration.
819 
820    A: $ignore
821 
822    END MESSAGE DOCUMENTATION */
823 
824      end reconfig;