



		    illegal_procedure.pl1           11/11/89  1139.4r w 11/11/89  0839.1       17298



/****^  ***********************************************************
        *                                                         *
        * Copyright, (C) Honeywell Bull Inc., 1987                *
        *                                                         *
        * Copyright, (C) Honeywell Information Systems Inc., 1982 *
        *                                                         *
        *********************************************************** */
%;
/* ******************************************************
   *                                                    *
   *                                                    *
   * Copyright (c) 1972 by Massachusetts Institute of   *
   * Technology and Honeywell Information Systems, Inc. *
   *                                                    *
   *                                                    *
   ****************************************************** */

/*
   Last Modified (Date and Reason):
   10/15/73 Steve Webber -- Initial coding.
   10/09/74 Lee Scheffler - Add auditing of bona fide illegal procedure faults.
   06/07/76 Bernard Greenberg- mc.resignal for truncation fault, incl. internal procedure for lth.
   85-01-15 EJ Sharpe - deleted all but set_pl1_machine entry since unused
   */

illegal_procedure$set_pl1_machine_mode: proc (new_mode, old_mode);

/* This entry will change the state of a process from a "pl1 machine" to a "bare machine".
   In the pl1 machine mode certain illegal procedure are ignored. In the bare
   machine mode these faults are signalled to the user. */

dcl (new_mode, old_mode) fixed bin;
dcl  pds$pl1_machine fixed bin ext;
dcl  i fixed bin;


	i = pds$pl1_machine;			/* return old value of the mode */
	pds$pl1_machine = new_mode;			/* change the mode for the process */
	old_mode = i;				/* return the copied old value */
	return;

     end illegal_procedure$set_pl1_machine_mode;




		    mos_memory_check.pl1            11/11/89  1139.4rew 11/11/89  0839.1       67878



/****^  ***********************************************************
        *                                                         *
        * Copyright, (C) Honeywell Bull Inc., 1987                *
        *                                                         *
        * Copyright, (C) Honeywell Information Systems Inc., 1982 *
        *                                                         *
        * Copyright (c) 1972 by Massachusetts Institute of        *
        * Technology and Honeywell Information Systems, Inc.      *
        *                                                         *
        *********************************************************** */

/* format: style4 */

/* MOS_MEMORY_CHECK: This procedure scans memorys to check for MOS memory EDAC errors to be logged. */

/* Written April 1976 by Larry Johnson */
/* The initial version will check only the low order memory on each controller */
/* Modified June 1976 by Larry Johnson to check all memories on a controller */
/* Modified September 1977 by Larry Johnson for new memory board types */
/* Modified October 1981 by M.R. Jordan for new 64K chip memory */
/* Modified February 1985 by EJ Sharpe to not log binary value for polling interval, add format */

mos_memory_check: proc (arg_mem, arg_store, arg_data, arg_code);

dcl  arg_mem (0:31) char (1) unal;
dcl  arg_store (0:31) char (2) unal;
dcl  arg_data (0:31) fixed bin (71);			/* Array of maintenance registers */
dcl  arg_code fixed bin (35);
dcl  arg_time fixed bin;

dcl  port fixed bin;
dcl  rscr_result fixed bin (71);
dcl  poll_entry bit (1) init ("0"b);			/* Set if called by polling */
dcl  time fixed bin;
dcl  (store_a_index, store_b_index) fixed bin (5);	/* Scas indexes for pmut$rscr */
dcl  mem char (1);
dcl  aloud fixed bin;

dcl  spoke (0:31) bit (1) int static init ((32) (1)"0"b);

dcl  never fixed bin (52) int static options (constant)
	init (1111111111111111111111111111111111111111111111111111b);


dcl  letter (0:7) char (1) unal int static options (constant) init ("a", "b", "c", "d", "e", "f", "g", "h");

dcl  privileged_mode_ut$rscr entry (fixed bin (5), fixed bin (6), fixed bin (71));
dcl  clock_ entry returns (fixed bin (71));
dcl  syserr entry options (variable);
dcl  syserr$binary entry options (variable);

dcl  tc_data$mos_polling_time ext fixed bin (52);
dcl  tc_data$mos_polling_interval ext fixed bin;
dcl  pds$process_group_id ext char (32) aligned;
dcl  pds$processid ext bit (36) aligned;
dcl  error_table_$lock_wait_time_exceeded ext fixed bin (35);

dcl  cleanup condition;

dcl  (addr, stac, stacq) builtin;
%page;
/* First, lock the reconfig lock */

	arg_code = 0;

start:

	on cleanup call clean_up;

	if ^stac (addr (scs$reconfig_lock), pds$processid) then do;
	     if poll_entry then tc_data$mos_polling_time = clock_ () + 60000000; /* Try again in 1 minute */
	     else arg_code = error_table_$lock_wait_time_exceeded;
	     return;
	end;
	scs$reconfig_locker_id = pds$process_group_id;

/* Now scan looking for memorys */

	scrp = addr (rscr_result);

	do port = 0 to 7;				/* Scan all controlers */

	     if scs$controller_data.online (port) then do;/* Found active memory */
		if ^scs$controller_data.store_b_is_lower (port) then do; /* Store a lower */
		     store_a_index = port;		/* Set scas indexes */
		     store_b_index = port + 8;
		end;
		else do;				/* Memory upside down */
		     store_a_index = port + 8;
		     store_b_index = port;
		end;

		mem = letter (port);

		if scs$controller_data.store_a_online (port) then /* Check all stores */
		     call check_store ("a", store_a_index);
		if scs$controller_data.store_a1_online (port) then
		     call check_store ("a1", store_a_index + 16);
		if scs$controller_data.store_b_online (port) then
		     call check_store ("b", store_b_index);
		if scs$controller_data.store_b1_online (port) then
		     call check_store ("b1", store_b_index + 16);

	     end;

	end;

	if poll_entry then call reschedule;		/* Must schedule next pass */
	if ^stacq (scs$reconfig_lock, "0"b, pds$processid) then
	     call syserr (ANNOUNCE, "mos_memory_check: Lock error.");
	return;

/* Enter here from pxss for polling */

poll: entry;

	if tc_data$mos_polling_interval = 0 then do;	/* Polling was turned off */
	     tc_data$mos_polling_time = never;
	     return;
	end;
	poll_entry = "1"b;
	go to start;


/* Entry to set the polling interval */

set_poll_time: entry (arg_time);

	time = arg_time;
	if time < 0 then do;			/* Request to return time */
	     arg_time = tc_data$mos_polling_interval;
	     return;
	end;
	tc_data$mos_polling_interval = time;
	call syserr (JUST_LOG, "mos_memory_check: MOS polling ^[disabled^;time ^d minute^[s^]^].",
	     (time = 0), time, (time ^= 1));
	call reschedule;
	return;


/* Procedure that will check one store of one memory */

check_store: proc (store_name, scas_index);

dcl  store_name char (2);				/* Name of store being tested */
dcl  scas_index fixed bin (5);			/* Index in scas for pmut$rscr */
dcl  id bit (4) aligned;

	call privileged_mode_ut$rscr (scas_index, (SC_SU), rscr_result); /* Read maintence register */
	if ^poll_entry then do;			/* Called thru gate, so must return data */
	     arg_mem (scas_index) = mem;
	     arg_store (scas_index) = store_name;
	     arg_data (scas_index) = rscr_result;
	end;

	id = scr_su.identification;			/* copy id for easier access */
	if (id = "0011"b) | (id = "0100"b) | (id = "1010"b)
	     | (id = "1011"b) | (id = "1110"b) | (id = "1111"b) then do; /* MOS memory */
	     if scr_su.syndrome ^= "0"b then do;	/* Some error occured */
		if spoke (scas_index) then aloud = JUST_LOG; else aloud = ANNOUNCE; /* Mild fuss first time */
		spoke (scas_index) = "1"b;
		call syserr$binary (aloud, scrp, SB_mos_err, SBL_mos_err,
		     "mos_memory_check: EDAC error on mem ^a store ^a.", mem, store_name);
	     end;
	end;
	return;

     end check_store;

/* Procedure to calculate the next time to poll */

reschedule: proc;

	if tc_data$mos_polling_interval = 0 then tc_data$mos_polling_time = never;
	else tc_data$mos_polling_time = clock_ () + 60000000 * tc_data$mos_polling_interval;

	return;

     end reschedule;


clean_up: proc;

dcl  ignore bit (1);

	ignore = stacq (scs$reconfig_lock, "0"b, pds$processid); /* Unlock if I locked it */
	return;

     end clean_up;
						/* format: off */
%page; %include syserr_constants;
%page; %include syserr_binary_def;
%page; %include scr;
%page; %include scs;
%page;
/* BEGIN MESSAGE DOCUMENTATION

   Message:
   mos_memory_check: Lock error.

   S:	$info

   T:	$run

   M:	After checking the memory controllers for errors,
   the program mos_memory check attempted to unlock the reconfiguration lock
   and found it unlocked.
   The system continues to run.

   A:	$ignore


   Message:
   mos_memory_check: MOS polling disabled

   S:	$log

   T:	$run

   M:	A system administrator has disabled MOS memory polling.

   A:	$ignore


   Message:
   mos_memory_check: MOS polling time NN minutes.

   S:	$log

   T:	$run

   M:	A system administrator has set the MOS memory polling time to NN minutes.

   A:	$ignore


   Message:
   mos_memory_check: EDAC error on mem X store Y.

   S:	$warn

   T:	$run

   M:	MOS memory polling has found that
   the maintenance register in the system controller
   shows a nonzero syndrome.
   The data is logged for use by HEALS or mos_edac_summary.
   Only the first occurrence of this error is printed online for each box.

   A:	$ignore


   END MESSAGE DOCUMENTATION */

     end mos_memory_check;




		    syserr_copy_wired_log.pl1       11/11/89  1139.4rew 11/11/89  0839.1       83970



/****^  ***********************************************************
        *                                                         *
        * Copyright, (C) Honeywell Bull Inc., 1987                *
        *                                                         *
        * Copyright, (C) Honeywell Information Systems Inc., 1984 *
        *                                                         *
        *********************************************************** */
/* format: style2,indcomtxt */

syserr_copy_wired_log:
     procedure;

/**** This procedure copies all the messages from the wired buffer
      to the paged syserr log partition.

      It is called by the SyserrLogger the Hproc.

      This procedure expects to be called unwired, with neither the
      paged log lock nor the wired log lock held.

      1) It locks the paged log.

      2) It wires down.

      3) It locks the wired log (a spin lock)

      4) It copies the wired buffer and marks it empty.

      5) It unlocks the wired log.

      6) It unwires and unmasks.

      7) It calls syserr_copy to actually put the text from
      the copy of the wired buffer into the paged log.

      8) It unlocks the paged log and returns.

      NOTE
      This would be considerably more robust if syserr_copy
      were able to copy directly into the paged log from the
      wired log, by temp-wiring the neccessary pages of paged log,
      copying, and then unwiring. The wired buffer should not
      be marked AVAILABLE until the messages have been successfully
      disposed of.
*/

/**** History
      Created 1984-11-26 BIM: from syserr_log_daemon of Sibert.
      Modified 1985-01-25 Keith Loepere: fix race in syserr_real copying.
      Modified 1985-02-19 Keith Loepere: for making the paged syserr lock
      the highest paged lock.
      Modified 1985-03-08 EJ Sharpe: added adjust_wired_log_sequence
*/
%page;

	declare P_sequence_increment	 fixed bin (35) parameter;

	declare automatic_buffer	 (syserr_data$wired_log_size) bit (36) aligned automatic;
	declare based_buffer	 (syserr_data$wired_log_size) bit (36) aligned based;

	declare msg_idx		 fixed bin;
	declare sequence_increment	 fixed bin (35);	/* arg copy */
	declare temp_mask		 bit (72) aligned;	/* global since it is unwise to call unwire_unmask in a condition handler */
	declare wire_arg		 fixed bin (71);
	declare wire_ptr		 pointer;

	declare pmut$read_mask	 entry (bit (72) aligned);
	declare pmut$wire_and_mask	 entry (fixed bin (71), pointer);
	declare pmut$unwire_unmask	 entry (fixed bin (71), pointer);
	declare syserr		 entry options (variable);
	declare syserr_copy$lock	 entry ();
	declare syserr_copy$unlock	 entry ();
	declare syserr_copy$wired_log	 entry (pointer);

	declare pds$processid	 bit (36) external aligned;
	declare syserr_data$wired_log_size
				 external fixed bin (35);
	declare scs$sys_level	 bit (72) aligned external;

	declare any_other		 condition;

	declare (addr, null, rel, stacq, unspec)
				 builtin;
%page;
	syserr_log_data_ptr = addr (syserr_log_data$);
	sd_ptr = addr (syserr_data$syserr_area);
	wlog_ptr = addr (syserr_data$wired_log_area);

	call syserr_copy$lock ();			/* Lock the paged log */

	call pmut$wire_and_mask (wire_arg, wire_ptr);

	call get_wired_log ();

	call pmut$unwire_unmask (wire_arg, wire_ptr);	/* Permit faults to occur and be handled */

	on any_other call condition_handler;

	call syserr_copy$wired_log (addr (automatic_buffer));

	if syserr_log_data.take_a_fault
	then do;					/* For use to test fault recovery: patch this bit on */
		syserr_log_data.take_a_fault = "0"b;	/* and get a fault. Turn it off, of course, since we */
		null () -> syserr_log_data.take_a_fault = "0"b;
						/* only want one fault at a time */
	     end;

	revert any_other;

	call syserr_copy$unlock ();			/* Unlock the paged log */
	return;

RETURN_ERROR:
	if (syserr_log_data.lock.pid = pds$processid)
	then call syserr_copy$unlock ();

	if temp_mask = scs$sys_level
	then call pmut$unwire_unmask (wire_arg, wire_ptr);

	if (syserr_log_data.error_count > 5) & sd.log_flag
	then do;					/* We turn off logging after five errors */
		call syserr (BEEP, "syserr_copy_wired_log: Too many faults: log copying will be disabled.");
		sd.log_flag = "0"b;			/* to avoid getting into a loop doing this */
	     end;
	syserr_log_data.error_count = syserr_log_data.error_count + 1;

	return;
%page;

/* The following entrypoint is called from syserr_seg_manager during
   answering service initialization.  The task is to increase all sequence
   numbers in the wired log by the value supplied.   This is to get the paged
   and wired log messages consistant with what the AS has found in the syserr
   log history (i.e. the permanent log segments). */

adjust_wired_log_sequence:
     entry (P_sequence_increment);

	sequence_increment = P_sequence_increment;
	sd_ptr = addr (syserr_data$syserr_area);
	wlog_ptr = addr (syserr_data$wired_log_area);

	call pmut$wire_and_mask (wire_arg, wire_ptr);

	if (sd.lock = pds$processid)
	then call lock_error ();

	do while (^stacq (sd.lock, pds$processid, ""b));
	end;

	wlog.seq_num = wlog.seq_num + sequence_increment; /* make sure next incoming message will be right */

	wmess_ptr = addr (wlog.buffer);		/* first message */

	do msg_idx = 1 to wlog.head.count;
	     wmess.seq_num = wmess.seq_num + sequence_increment;
	     wmess_ptr = addrel (wmess_ptr, currentsize (wmess));
						/* Move on to the next message */
	end;

	if ^stacq (sd.lock, ""b, pds$processid)
	then call lock_error ();

	call pmut$unwire_unmask (wire_arg, wire_ptr);

	return;
%page;

get_wired_log:
     procedure ();

	declare message_count	 fixed bin;

/* This procedure copies the contents of the wired log into our buffer in automatic
   storage (also wired, at the moment).	 It locks the wired log, copies the message(s),
   resets the wired log to say that it's now empty, unlocks the wired log, and
   returns.  Once we unlock, the next message will be put at the top of the wired
   buffer.  If we can do all of this before the wired buffer is full, we will never
   lose any messages. */


	if (sd.lock = pds$processid)
	then /* MYLOCK error */
	     call lock_error ();

	do while (^stacq (sd.lock, pds$processid, ""b));
	end;

/* We will copy the whole wired log buffer plus its extension into our own buffer. */

	unspec (automatic_buffer) = unspec (wlog_ptr -> based_buffer);

	message_count = wlog.count;			/* Save for metering */

/* This is where a call to meter_oc_log_ used to be made, but it was removed
   because meter_oc_log_ is so silly, and because there isn't anything to
   extract the meters, anyway. Real metering ought to be added back someday. */

	wlog.next = rel (addr (wlog.buffer));		/* Start next message at top of buffer. */
	wlog.count = 0;				/* No entries in buffer now. */

	if ^stacq (sd.lock, ""b, pds$processid)
	then call lock_error ();

	return;
     end get_wired_log;


lock_error:
     procedure ();

/* This procedure crashes the system when a locking error occurs on the
   wired syserr data lock-- but first, it turns off logging just in case
   it gets restarted or other messages are generated before the crash. */

	sd.log_flag = "0"b;
	call syserr (CRASH, "syserr_copy_wired_log: Bad syserr_data lock ^w.", sd.lock);

	return;
     end lock_error;

condition_handler:
     procedure ();

	declare severity		 fixed bin;
	declare buf_ptr		 pointer;
	declare mess_ptr		 pointer;

	call pmut$read_mask (temp_mask);
	if temp_mask = scs$sys_level
	then /* If we took a fault while wired, we should have */
	     severity = CRASH;			/* crashed already (fim detects this), but just in case... */
	else severity = BEEP;

	buf_ptr = addr (automatic_buffer);
	mess_ptr = addr (buf_ptr -> wlog.buffer);

	call syserr (severity,
	     "syserr_copy_wired_log: Fault occurred while copying into LOG partition. Messages ^d to ^d may be lost",
	     mess_ptr -> wmess.seq_num, buf_ptr -> wlog.head.seq_num);

	go to RETURN_ERROR;				/* main line uses temp_mask to decide to unwire. */
     end condition_handler;

%page;
%include syserr_data;
%page;
%include syserr_log_dcls;
%page;
%include syserr_constants;
%page;
/* BEGIN MESSAGE DOCUMENTATION

   Message:
   syserr_copy_wired_log: Bad lock WWWWWWWWWWWW at SSS|OOOOOO

   S:	$crash

   T:	$run

   M:	$err
   The contents of the lock word and its address are printed, as an aid
   for debugging.

   A:	$recover

   Message:
   syserr_copy_wired_log: Fault occurred while copying into LOG partition. Messages NNNN to NNNN may be lost.

   S:	$crash

   T:	$run

   M:	$err
   A fault has occurred while copying data from the wired syserr log buffer
   to the paged syserr log. This
   usually results from a disk error on the LOG partition, which would
   also generate disk error messages.  The sequence numbers of the
   affected messages are given because those messages may not appear
   in the LOG partition.

   A:	$recover


   Message:
   syserr_copy_wired_log: Too many faults, log copying disabled.

   S:	$beep

   T:	$run

   M:	$err
   If too many errors occur updating the LOG partition, log copying will
   be disabled, which causes all further messages to be printed on the
   console but not entered in the log.

   A:	$notify

   END MESSAGE DOCUMENTATION */

     end syserr_copy_wired_log;




		    syserr_log_daemon.pl1           11/11/89  1139.4rew 11/11/89  0839.1       33408



/****^  ***********************************************************
        *                                                         *
        * Copyright, (C) Honeywell Bull Inc., 1987                *
        *                                                         *
        * Copyright, (C) Honeywell Information Systems Inc., 1984 *
        *                                                         *
        *********************************************************** */
syserr_log_daemon:
     procedure ();

/* *	SYSERR_LOG_DAEMON
   *
   *	This is the procedure always run by the SyserrLogger.SysDaemon HPROC.
   *	It deals with copying between the wired syserr buffer and the log
   *	segments in the paged LOG partition.  It is called once when the 
   *	syserr daemon is created, and never returns.  It is one of the 
   *	few programs in the system to go blocked in ring zero. It sets up
   *	some automatic variables and then enters a block loop awaiting wakeups
   *	indicating that there may be something in the wired buffer to copy out
   *	into the paged log. It should be run only by the syserr logger HPROC.
   *
   *	Modification history:
   *	73-10-05, Bill Silver: Initial coding
   *	74-06-09, Bill Silver: Added copy entry
   *	74-11-12, Lee Scheffler: Log copying added
   *	75-11-15, Larry Johnson: Moved most of the code in this module to
   *	   a non-wired procedure (syserr_copy_paged)
   *	76-01-10, Larry Johnson: Modified to lock paged syserr log
   *	76-03-22, Steve Webber: Modified to use logger HPROC
   *	79-05-03, Mike Grady: Modified for ring 0 stack sharing-- hproc has
   *	   own stack and pxss$block now has no args.
   *	84-08-24, W. Olin Sibert: Reorganized for new syserr log mechanism:
   *	   use pmut$wire_and_mask instead of options (validate), use
   *	   syserr_log_data for locking, handle conditions and restart, change
   *	   name from syserr_logger to syserr_log_daemon.
   *    1984-11-26, BIM: moved the guts of this to syserr_copy_wired_log,
		which can be called outside the Daemon.
   *    1985-01-25, Keith Loepere, to fix race in async log copying.
   *	85-02-19, Keith Loepere, for making the paged syserr log the 
		highest paged lock.
   */

	declare wire_arg		 bit (72) aligned;
	declare wire_ptr		 pointer;

	declare pmut$wire_and_mask	 entry (bit (72) aligned, pointer);
	declare pmut$unwire_unmask	 entry (bit (72) aligned, pointer);
	declare pxss$block		 entry;
	declare syserr_copy_wired_log	 entry;

	declare addr		 builtin;

/* */

	syserr_log_data_ptr = addr (syserr_log_data$);
	sd_ptr = addr (syserr_data$syserr_area);
	wlog_ptr = addr (syserr_data$wired_log_area);

/* This process remains wired and masked for all its life EXCEPT when it is
   actually putting messages into the paged log (which it has already extracted
   from the wired log).  This is done in order to reduce the possibility that
   it will be unable to operate; essentially, it eliminates all but the pages
   of the paged log itself from consideration as sources of error.  This is
   not entirely true, since the stack is unwired whilst calling. */

LOGGER_LOOP:
	call pmut$wire_and_mask (wire_arg, wire_ptr);

	do while ("1"b);
	     if ^syserr_log_data.test_mode then do;
		     call pxss$block ();		/* wait for something to happen */
		end;
	     call pmut$unwire_unmask (wire_arg, wire_ptr);/* Permit faults to occur and be handled */

	     call syserr_copy_wired_log;

	     call pmut$wire_and_mask (wire_arg, wire_ptr);/* Turn faults off again */

	     if syserr_log_data.test_mode then
		return;
	end;

/* */


/* */


%page; %include syserr_data;
%page; %include syserr_log_dcls;
%page; %include syserr_constants;

     end syserr_log_daemon;



		    bull_copyright_notice.txt       08/30/05  1008.4r   08/30/05  1007.3    00020025

                                          -----------------------------------------------------------


Historical Background

This edition of the Multics software materials and documentation is provided and donated
to Massachusetts Institute of Technology by Group Bull including Bull HN Information Systems Inc. 
as a contribution to computer science knowledge.  
This donation is made also to give evidence of the common contributions of Massachusetts Institute of Technology,
Bell Laboratories, General Electric, Honeywell Information Systems Inc., Honeywell Bull Inc., Groupe Bull
and Bull HN Information Systems Inc. to the development of this operating system. 
Multics development was initiated by Massachusetts Institute of Technology Project MAC (1963-1970),
renamed the MIT Laboratory for Computer Science and Artificial Intelligence in the mid 1970s, under the leadership
of Professor Fernando Jose Corbato.Users consider that Multics provided the best software architecture for 
managing computer hardware properly and for executing programs. Many subsequent operating systems
incorporated Multics principles.
Multics was distributed in 1975 to 2000 by Group Bull in Europe , and in the U.S. by Bull HN Information Systems Inc., 
as successor in interest by change in name only to Honeywell Bull Inc. and Honeywell Information Systems Inc. .

                                          -----------------------------------------------------------

Permission to use, copy, modify, and distribute these programs and their documentation for any purpose and without
fee is hereby granted,provided that the below copyright notice and historical background appear in all copies
and that both the copyright notice and historical background and this permission notice appear in supporting
documentation, and that the names of MIT, HIS, Bull or Bull HN not be used in advertising or publicity pertaining
to distribution of the programs without specific prior written permission.
    Copyright 1972 by Massachusetts Institute of Technology and Honeywell Information Systems Inc.
    Copyright 2006 by Bull HN Information Systems Inc.
    Copyright 2006 by Bull SAS
    All Rights Reserved
