



		    convert_MR10_2_audit_flags_.pl1 01/26/85  1332.8r w 01/22/85  1240.5       59562



/*  ***********************************************************
   *                                                         *
   * Copyright, (C) Honeywell Information Systems Inc., 1984 *
   *                                                         *
   *********************************************************** */

/* format: style1,^inddcls,^indnoniterdo,insnl,linecom,indcomtxt */

convert_MR10_2_audit_flags_:
     procedure (a_flags);

/* format: off */
	/*  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  * */
	/*									*/
	/* CONVERT_MR10_2_AUDIT_FLAGS_						*/
	/*									*/
	/* Routine to convert a set of audit flags from pre-MR11 format to MR11 format.		*/
	/*									*/
	/* RESET_MR10_2_AUDIT_FLAGS_							*/
	/*									*/
	/* Routine to attempt backing-out the changes made by convert_MR10_2_audit_flags_.  (It	*/
	/* is not possible to obtain exactly the original flags).				*/
	/*									*/
	/* Last Modified:								*/
	/* 1984-12-10 EJ Sharpe - initial coding					*/
	/*									*/
	/*  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  * */
/* format: on */


dcl     a_flags		 bit (36) aligned parameter;
dcl     1 new_flags		 aligned like audit_flags;
dcl     1 old_flags		 aligned like OLD_audit_flags;

dcl     string		 builtin;
dcl     unspec		 builtin;
%page;

/* pre-MR11 flag definition */

dcl     1 OLD_audit_flags	 aligned based,		/* These flags control which auditable protection
						   events do in fact produce audit entries in
						   the syserr or other logs for this process */
	2 ring_0_flags	 unaligned,		/* Flags checked by ring 0 */
	( 3 protected_seg_init,			/* ON => audit initiations of non-directory
						   segments with non-null access class
						   (not including ring 1 multi-class segments) */
	  3 protected_dir_init,			/* ON => audit making known of directories
						   with non-null access class */
	  3 r1_multi_class_init,			/* ON => audit initiaions of ring 1 multi-class
						   segments.  (This flag is OFF when ring 1
						   is doing its own auditing) */
	  3 access_denied,				/* ON => audit instances of access denied
						   to segments or directories due to improper
						   authorization, ACL mode, or ring validation level */
	  3 illegal_proc,				/* ON => audit illegal procedure faults
						   (except legal EIS faults) */
	  3 access_viol_mode,			/* ON => audit ACL mode related
						   access violation faults */
	  3 access_viol_ring,			/* ON => audit ring related
						   access violation faults */
	  3 wakeup_denied,				/* ON => audit unsuccessful attempts to send
						   IPC messages due to improper authorization */
	  3 sys_privilege,				/* ON => audit changing of special privileges
						   (including setting of system privilege bits,
						   privileged initiations) */
	  3 SSA_ops,				/* ON => audit SSA downgrade, turning
						   security-oos off, other security related operations */
	  3 attach_denied,				/* ON => audit denied attachment of devices
						   (disk and tape drives) in ring 0 */
	  3 pad		 (7)
	  )		 bit (1),			/* Reserved for expansion of ring 0
						   audit selectivity */

	2 ring_1_flags	 unaligned,		/* Flags checked by ring 1 */
	( 3 mount_denied,				/* ON => audit instances of denied
						   mounts of media (disk and tape) */
	  3 mseg_events,				/* ON => audit protection events concerning
						   message segments (overflows) */
	  3 comm_events,				/* ON => audit use of communications AIM privilege */
	  3 pad		 (15)
	  )		 bit (1);			/* Reserved for expansion of ring 1
						   audit selectivity */
%page;
/* MR11 audit flag definition */

%include access_audit_flags;
%page;

	string (old_flags) = a_flags;
	unspec (new_flags) = ""b;

/****
      We really should check the input flags for validity, however,
      we also want badly to succeed.  Thus, we'll just ignore
      any garbage in the pad fields:
      if  string(old_flags.ring_0_flags.pad) ^= ""b
      | string(old_flags.ring_1_flags.pad) ^= ""b
      then grin_and_bear_it;
*/

	if old_flags.protected_seg_init
	     | old_flags.protected_dir_init
	     | old_flags.r1_multi_class_init
	     | old_flags.access_denied
	then new_flags.objects (FSOBJ_AUDIT_OBJECT_INDEX).deny_level = READ;

	if old_flags.access_denied
	then new_flags.objects (FSATTR_AUDIT_OBJECT_INDEX).deny_level = READ;

	if old_flags.illegal_proc
	     | old_flags.access_viol_mode
	     | old_flags.access_viol_ring
	then new_flags.faults = "1"b;

	if old_flags.wakeup_denied
	then new_flags.objects (SPECIAL_AUDIT_OBJECT_INDEX).deny_level = MODIFY;

	if old_flags.sys_privilege
	then new_flags.priv_ops = "1"b;

	if old_flags.SSA_ops
	then new_flags.admin_ops = "1"b;

	if old_flags.attach_denied
	     | old_flags.mount_denied
	then new_flags.objects (RCP_AUDIT_OBJECT_INDEX).deny_level = READ;

	if old_flags.mseg_events
	     | old_flags.comm_events
	then new_flags.objects (OTHER_AUDIT_OBJECT_INDEX).deny_level = READ;

	a_flags = unspec (new_flags);

	return;
%page;

/* RESET_MR10_2_AUDIT_FLAGS_ - entry to convert MR11 flags back to pre-MR11 format */

reset_MR10_2_audit_flags_:
     entry (a_flags);

	string (old_flags) = ""b;
	unspec (new_flags) = a_flags;

/****
      We really should check the input flags for validity, however,
      we also want badly to succeed.  Thus, we'll just ignore
      any illegal values:
      if  new_flags.pad ^= ""b
      | new_flags.objects(FSOBJ_AUDIT_OBJECT_INDEX).grant_level = MODIFY_ACCESS
      | new_flags.objects(FSOBJ_AUDIT_OBJECT_INDEX).deny_level = MODIFY_ACCESS
      then grin_and_bear_it;
*/

	if new_flags.objects (FSOBJ_AUDIT_OBJECT_INDEX).deny_level ^= NONE
	then old_flags.protected_seg_init,
		old_flags.protected_dir_init,
		old_flags.r1_multi_class_init,
		old_flags.access_denied = "1"b;

	if new_flags.objects (FSATTR_AUDIT_OBJECT_INDEX).deny_level ^= NONE
	then old_flags.access_denied = "1"b;

	if new_flags.faults
	then old_flags.illegal_proc,
		old_flags.access_viol_mode,
		old_flags.access_viol_ring = "1"b;

	if new_flags.objects (SPECIAL_AUDIT_OBJECT_INDEX).deny_level > MODIFY_ACCESS
	then old_flags.wakeup_denied = "1"b;

	if new_flags.priv_ops
	then old_flags.sys_privilege = "1"b;

	if new_flags.admin_ops
	then old_flags.SSA_ops = "1"b;

	if new_flags.objects (RCP_AUDIT_OBJECT_INDEX).deny_level ^= NONE
	then old_flags.attach_denied,
		old_flags.mount_denied = "1"b;

	if new_flags.objects (OTHER_AUDIT_OBJECT_INDEX).deny_level ^= NONE
	then old_flags.mseg_events,
		old_flags.comm_events = "1"b;

	a_flags = string (old_flags);

	return;


     end convert_MR10_2_audit_flags_;




		    convert_MR10_2_mail_table.pl1   12/05/84  1349.9rew 12/05/84  0854.0       22563



/* ***********************************************************
   *                                                         *
   * Copyright, (C) Honeywell Information Systems Inc., 1984 *
   *                                                         *
   *********************************************************** */
/* CONVERT_MR10_2_MAIL_TABLE: Program to convert a MR10.2 MAIL_TABLE to
   a MR11 MAIL_TABLE.  MR11 MAIL_TABLEs are Version 3 MSTBs rather than
   Version 2.  The format of the MAIL_TABLE entries themselves has not 
   changed. */

/* format: style2 */
/* Written 1984-08-06 by Eric Swenson */

convert_MR10_2_mail_table:
     procedure options (variable);

/* Automatic */

	dcl     argument_idx	 fixed bin (17);
	dcl     argument_lth	 fixed bin (21);
	dcl     argument_ptr	 ptr;
	dcl     code		 fixed bin (35);
	dcl     dirname		 char (168);
	dcl     entryname		 char (32);
	dcl     n_arguments		 fixed bin (17);
	dcl     pathname		 char (168);	/* Based */

	dcl     argument		 char (argument_lth) based (argument_ptr);

/* External Entries */

	dcl     com_err_		 entry () options (variable);
	dcl     cu_$arg_count	 entry (fixed bin, fixed bin (35));
	dcl     cu_$arg_ptr		 entry (fixed bin, ptr, fixed bin (21), fixed bin (35));
	dcl     expand_pathname_	 entry (char (*), char (*), char (*), fixed bin (35));
	dcl     ioa_		 entry options (variable);
	dcl     mail_table_priv_$convert_v2_mail_table
				 entry (char (*), char (*), fixed bin (35));
	dcl     pathname_		 entry (char (*), char (*)) returns (char (168));

/* Constant */

	dcl     ME		 char (32) initial ("convert_MR10_2_mail_table") internal static
				 options (constant);
%page;
/* Program */

	call cu_$arg_count (n_arguments, code);
	if code ^= 0
	then do;
		call com_err_ (code, ME);
		return;
	     end;

	if n_arguments = 0
	then do;
		call com_err_ (0, ME, "Usage: ^a pathname_of_mail_table_to_convert", ME);
		return;
	     end;

	call cu_$arg_ptr (1, argument_ptr, argument_lth, (0));
	call expand_pathname_ (argument, dirname, entryname, code);
	if code ^= 0
	then do;
		call com_err_ (code, ME, "^a", argument);
		return;
	     end;

	pathname = pathname_ (dirname, entryname);
	call ioa_ ("^a: Converting ^a.", ME, pathname);
	call mail_table_priv_$convert_v2_mail_table (dirname, entryname, code);
	if code ^= 0
	then do;
		call com_err_ (code, ME, "Converting ^a", pathname);
		return;
	     end;
	call ioa_ ("^a: Finished conversion of ^a.", ME, pathname);
	return;

     end convert_MR10_2_mail_table;




		    convert_MR10_2_pdts.pl1         07/13/88  1238.1r w 07/13/88  0943.1       52524



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


/* format: style2 */
/* convert_MR10_2_pdts - program to set MR11 PDT default values in live pdts.

   1) authorization ranges

   82-03-12  E. N. Kittlitz. stolen from cv_MR9_pdts.
   84-07-05  BIM stolen from cv_MR10_pdts
*/

convert_MR10_2_pdts:
     procedure;


/* automatic */

	dcl     arg_count		 fixed bin;
	dcl     alp		 pointer;
	dcl     ap		 pointer;
	dcl     al		 fixed bin (21);
	dcl     (pdtp, pdtep)	 ptr;
	dcl     (namex, i)		 fixed bin;
	dcl     name		 char (32);
	dcl     code		 fixed bin (35);
	dcl     bit_count		 fixed bin (24);
	dcl     pdt_directory	 char (168);
	dcl     area_ptr		 ptr;

/* based */

	dcl     argument		 char (al) based (ap);

/* builtins */

	dcl     (addr, null, sum)	 builtin;

/* entries */

	dcl     absolute_pathname_	 entry (character (*), character (*), fixed binary (35));
	dcl     cu_$arg_list_ptr	 entry (ptr);
	dcl     cu_$arg_count_rel	 entry (fixed bin, ptr, fixed bin (35));
	dcl     cu_$arg_ptr_rel	 entry (fixed bin, ptr, fixed bin (21), fixed bin (35), ptr);
	dcl     hcs_$star_		 entry (char (*), char (*), fixed bin, ptr, fixed bin, ptr, ptr, fixed bin (35));
	dcl     initiate_file_	 entry (character (*), character (*), bit (*), pointer, fixed binary (24),
				 fixed binary (35));
	dcl     terminate_file_	 entry (pointer, fixed binary (24), bit (*), fixed binary (35));
	dcl     get_system_free_area_	 entry (ptr);
	dcl     com_err_		 entry options (variable);

/* based */

	dcl     system_area		 area (65536 + 24) aligned based (area_ptr);

/* include files */

%include access_mode_values;
%include pdt;
%include star_structures;
%include user_attributes;
%include terminate_file;
%page;

/* program */

	call cu_$arg_list_ptr (alp);
	call do_work (alp, "convert_MR10_2_pdts", format_pdt);
	return;

reset_MR10_2_pdts:
     entry options (variable);

	call cu_$arg_list_ptr (alp);
	call do_work (alp, "reset_MR10_2_pdts", reset_pdt);
	return;


do_work:
     procedure (arg_list_ptr, me, worker_proc);

	declare arg_list_ptr	 pointer;
	declare me		 char (*);
	declare worker_proc		 entry variable;

	call cu_$arg_count_rel (arg_count, arg_list_ptr, code);
	if code ^= 0
	then do;
		call com_err_ (code, me);
		return;
	     end;

	if arg_count ^= 1
	then do;
		call com_err_ (0, me, "Usage: ^a PDT_DIR_PATHNAME", me);
		return;
	     end;

	call cu_$arg_ptr_rel (1, ap, al, (0), arg_list_ptr);
	call absolute_pathname_ (argument, pdt_directory, code);
	if code ^= 0
	then do;
		call com_err_ (code, me, "^a", argument);
		return;
	     end;

	call get_system_free_area_ (area_ptr);
	call map_over_pdts (pdt_directory, worker_proc);
	return;

/* Internal procedure to format all pdts in a given directory */

map_over_pdts:
     procedure (bv_pdt_dir, formatter);

/* parameters */

	dcl     bv_pdt_dir		 char (*) parameter;
	dcl     formatter		 entry (char (*), char (*), char (*)) variable;

/* program */

	call hcs_$star_ (bv_pdt_dir, "**.pdt", 3, area_ptr, star_entry_count, star_entry_ptr, star_names_ptr, code);
	if code ^= 0
	then do;
		call com_err_ (code, "convert_MR10_2_pdts", "^a", bv_pdt_dir);
		return;
	     end;

	do namex = 1 to star_entry_count;
	     name = star_names (star_entries.nindex (namex));
	     call formatter (me, bv_pdt_dir, name);
	end;

	free star_names in (system_area);
	free star_entries in (system_area);
	return;



/* This internal procedure initializes a single PDT.  All PDT entries
   which have ever been used are modified; not just those which are presently
   active.  For MR11, initialize authorization ranges. */


     end map_over_pdts;
     end do_work;


format_pdt:
     proc (me, bv_pdt_dirname, bv_pdt_name);

/* parameters */

	dcl     me		 char (*);
	dcl     (bv_pdt_dirname, bv_pdt_name)
				 char (*) parameter;



/* program */

	call initiate_file_ (bv_pdt_dirname, bv_pdt_name, RW_ACCESS, pdtp, bit_count, code);
	if code ^= 0
	then do;
		call com_err_ (code, "convert_MR10_2_pdts", "^a>^a", bv_pdt_dirname, bv_pdt_name);
		return;
	     end;

	if pdt.version = PDT_version
	then go to TERM_RETURN;			/* already done */
	pdt.version = -1;				/* broken while in transition */
	do i = 1 to pdt.current_size;
	     pdtep = addr (pdt.user (i));
	     user.user_authorization (1) = ""b;		/* system_low */
	     user.user_authorization (2) = user.pad_was_authorization;
	     user.pad_was_authorization = ""b;
	end;
	pdt.version = PDT_version;
TERM_RETURN:
	call terminate_file_ (pdtp, (0), TERM_FILE_TERM, code);

	return;

     end format_pdt;

reset_pdt:
     proc (me, bv_pdt_dirname, bv_pdt_name);

/* parameters */

	dcl     me		 char (*);
	dcl     (bv_pdt_dirname, bv_pdt_name)
				 char (*) parameter;



/* program */

	call initiate_file_ (bv_pdt_dirname, bv_pdt_name, RW_ACCESS, pdtp, bit_count, code);
	if code ^= 0
	then do;
		call com_err_ (code, me, "^a>^a", bv_pdt_dirname, bv_pdt_name);
		return;
	     end;

	if pdt.version = PDT_version - 1		/* already reset */
	then go to TERM_RETURN;
	pdt.version = -1;				/* broken while in transition */
	do i = 1 to pdt.current_size;
	     pdtep = addr (pdt.user (i));
	     user.pad_was_authorization = user.user_authorization (2);
	     user.user_authorization (*) = ""b;
	end;
	pdt.version = PDT_version - 1;
TERM_RETURN:
	call terminate_file_ (pdtp, (0), TERM_FILE_TERM, code);

	return;

     end reset_pdt;
     end convert_MR10_2_pdts;




		    convert_MR10_2_pnt.pl1          12/05/84  1350.0rew 12/05/84  0854.0       23013



/* ***********************************************************
   *                                                         *
   * Copyright, (C) Honeywell Information Systems Inc., 1984 *
   *                                                         *
   *********************************************************** */
/* CONVERT_MR10_2_PNT: This program converts a MR10.2 PNT to an MR11 PNT.
   MR11 PNTs use Version 3 MSTBs for better integrity and use a new format
   PNT entry which accomodates longer passwords, AIM ranges, and a version
   number (currently 2). */

/* format: style2 */

/* Written 1984-08-08 by E. Swenson */
/* Modified 1984-09-18 by E. Swenson to use pnt_admin_gate_. */

convert_MR10_2_pnt:
     procedure options (variable);

/* Automatic */

	dcl     argument_idx	 fixed bin (17);
	dcl     argument_lth	 fixed bin (21);
	dcl     argument_ptr	 ptr;
	dcl     code		 fixed bin (35);
	dcl     dirname		 char (168);
	dcl     entryname		 char (32);
	dcl     n_arguments		 fixed bin (17);
	dcl     pathname		 char (168);

/* Based */

	dcl     argument		 char (argument_lth) based (argument_ptr);

/* External Entries */

	dcl     com_err_		 entry () options (variable);
	dcl     cu_$arg_count	 entry (fixed bin, fixed bin (35));
	dcl     cu_$arg_ptr		 entry (fixed bin, ptr, fixed bin (21), fixed bin (35));
	dcl     expand_pathname_	 entry (char (*), char (*), char (*), fixed bin (35));
	dcl     ioa_		 entry options (variable);
	dcl     pnt_admin_gate_$convert_v2_pnt
				 entry (char (*), char (*), fixed bin (35));
	dcl     pathname_		 entry (char (*), char (*)) returns (char (168));

/* Constant */

	dcl     ME		 char (32) initial ("convert_MR10_2_pnt") internal static options (constant);
%page;
/* Program */

	call cu_$arg_count (n_arguments, code);
	if code ^= 0
	then do;
		call com_err_ (code, ME);
		return;
	     end;

	if n_arguments = 0
	then do;
		call com_err_ (0, ME, "Usage: ^a pathname_of_pnt_to_convert", ME);
		return;
	     end;

	call cu_$arg_ptr (1, argument_ptr, argument_lth, (0));
	call expand_pathname_ (argument, dirname, entryname, code);
	if code ^= 0
	then do;
		call com_err_ (code, ME, "^a", argument);
		return;
	     end;

	pathname = pathname_ (dirname, entryname);

	call ioa_ ("^a: Beginning conversion of ^a.", ME, pathname);
	call pnt_admin_gate_$convert_v2_pnt (dirname, entryname, code);
	if code ^= 0
	then do;
		call com_err_ (code, ME, "Converting ^a", pathname);
		return;
	     end;
	call ioa_ ("^a: Finished conversion of ^a.", ME, pathname);
	return;

     end convert_MR10_2_pnt;




		    convert_MR10_2_projfile.pl1     04/09/85  1521.7r w 04/08/85  1134.5       36720



/* ***********************************************************
   *                                                         *
   * Copyright, (C) Honeywell Information Systems Inc., 1983 *
   *                                                         *
   *********************************************************** */
/* convert_MR10_2_projfile.pl1 -- converts to MR11 projfile-entry format */
/* To be run over >udd>sa>a>projfile  */
/* format: style2 */

/* BIM 1984-07-05 */
/* Modified 1984-09-14 to detect double-conversions */

convert_MR10_2_projfile:
     procedure options (variable);

	declare com_err_		 entry () options (variable);
	declare cu_$arg_count	 entry (fixed bin, fixed bin (35));
	declare cu_$arg_ptr		 entry (fixed bin, ptr, fixed bin (21), fixed bin (35));
	declare expand_pathname_	 entry (character (*), character (*), character (*), fixed binary (35));
	declare get_temp_segment_	 entry (character (*), pointer, fixed binary (35));
	declare initiate_file_	 entry (character (*), character (*), bit (*), pointer, fixed binary (24),
				 fixed binary (35));
	declare pathname_		 entry (character (*), character (*)) returns (character (168));
	declare release_temp_segment_	 entry (character (*), pointer, fixed binary (35));
	declare terminate_file_	 entry (pointer, fixed binary (24), bit (*), fixed binary (35));


	declare arg_count		 fixed bin;
	declare ap		 pointer;
	declare al		 fixed bin (21);
	declare argument		 char (al) based (ap);
	declare code		 fixed bin (35);
	declare dir_name		 char (168);
	declare entryname		 char (32);
	declare (pp, old_pp)	 pointer;
	declare projfileex		 fixed bin;

	declare ME		 char (32) init ("convert_MR10_2_projfile") int static options (constant);

%include projfile;
%include access_mode_values;
%include terminate_file;

/**** MR10.2 projfile structure */

	dcl     1 old_projfile	 based (old_pp) aligned,
						/* Project history file */
		2 nproj		 fixed bin (35),	/* number of entries */
		2 projfilexx0_1	 (7) bit (36) aligned,
		2 projfiletab	 (3000),
		  3 id		 char (12),	/* project ID */
		  3 title		 char (52),	/* project title */
		  3 inv		 char (32),	/* name of principal investigator */
		  3 inv_addr	 char (32),	/* address */
		  3 sup		 char (32),	/* name of supervisor */
		  3 sup_addr	 char (32),	/* address */
		  3 sup_phone	 char (16),	/* telephone */
		  3 on		 fixed bin (71),	/* date on */
		  3 off		 fixed bin (71),	/* date off */
		  3 disk_psec	 fixed bin (71),	/* project disk page-seconds */
		  3 disk_quota	 fixed bin (35),	/* project disk quota */
		  3 disk_use	 fixed bin (35),	/* total segment pages used */
		  3 dir_disk_use	 fixed bin (35),	/* total directory pages used */
		  3 misc_charges	 float bin,	/* manuals, etc */
		  3 n_misc	 fixed bin,	/* number of entries */
		  3 processed	 fixed bin;	/* temp for usage-report */


	call cu_$arg_count (arg_count, code);
	if code ^= 0
	then do;
		call com_err_ (code, ME);
		return;
	     end;

	if arg_count ^= 1
	then do;
		call com_err_ (0, ME, "Usage: ^a PROJFILE_PATH", ME);
		return;
	     end;

	pp, old_pp = null ();

	call cu_$arg_ptr (1, ap, al, (0));
	call expand_pathname_ (argument, dir_name, entryname, code);
	if code ^= 0
	then do;
		call com_err_ (code, ME, "^a", argument);
		return;
	     end;

	call initiate_file_ (dir_name, entryname, RW_ACCESS, old_pp, (0), code);
	if code ^= 0
	then do;
		call com_err_ (code, ME, "^a", pathname_ (dir_name, entryname));
		return;
	     end;

	if old_pp -> projfile.version = PROJFILE_VERSION
	then do;
		call com_err_ (0, ME, "^a has already been converted to version ^d.", pathname_ (dir_name, entryname),
		     PROJFILE_VERSION);
		call terminate_file_ (old_pp, (0), TERM_FILE_TERM, (0));
		return;
	     end;
	call get_temp_segment_ (ME, pp, (0));

	projfile = old_projfile, by name;
	projfile.version = PROJFILE_VERSION;
	old_pp -> projfile = projfile;
	call terminate_file_ (old_pp, (loph + (old_pp -> projfile.nproj * lope)) * 36, TERM_FILE_TRUNC_BC_TERM, (0));
	call release_temp_segment_ (ME, pp, (0));
	return;
     end convert_MR10_2_projfile;




		    convert_MR10_2_reqfile.pl1      05/14/85  1132.6rew 05/14/85  1047.8       22932



/* ***********************************************************
   *                                                         *
   * Copyright, (C) Honeywell Information Systems Inc., 1984 *
   *                                                         *
   *********************************************************** */
/* convert_MR10_2_reqfile.pl1 -- converts to MR11 reqfile-entry format */
/* To be run over >udd>sa>a>reqfile  */
/* format: style2 */

/* BIM 1984-07-05 */
/* Modified 1985-04-24 by E. Swenson to terminate the reqfile properly. */

convert_MR10_2_reqfile:
     procedure options (variable);

	declare com_err_		 entry () options (variable);
	declare cu_$arg_count	 entry (fixed bin, fixed bin (35));
	declare cu_$arg_ptr		 entry (fixed bin, ptr, fixed bin (21), fixed bin (35));
	declare expand_pathname_	 entry (character (*), character (*), character (*), fixed binary (35));
	declare get_temp_segment_	 entry (character (*), pointer, fixed binary (35));
	declare initiate_file_	 entry (character (*), character (*), bit (*), pointer, fixed binary (24),
				 fixed binary (35));
	declare pathname_		 entry (character (*), character (*)) returns (character (168));
	declare release_temp_segment_	 entry (character (*), pointer, fixed binary (35));
	declare terminate_file_	 entry (pointer, fixed binary (24), bit (*), fixed binary (35));


	declare arg_count		 fixed bin;
	declare ap		 pointer;
	declare al		 fixed bin (21);
	declare argument		 char (al) based (ap);
	declare code		 fixed bin (35);
	declare dir_name		 char (168);
	declare entryname		 char (32);
	declare qp		 pointer;
	declare reqfileex		 fixed bin;

	declare ME		 char (32) init ("convert_MR10_2_reqfile") int static options (constant);

%include reqfile;
%include access_mode_values;
%include terminate_file;


	call cu_$arg_count (arg_count, code);
	if code ^= 0
	then do;
		call com_err_ (code, ME);
		return;
	     end;

	if arg_count ^= 1
	then do;
		call com_err_ (0, ME, "Usage: ^a REQFILE_PATH.reqfile", ME);
		return;
	     end;

	qp = null ();

	call cu_$arg_ptr (1, ap, al, (0));
	call expand_pathname_ (argument, dir_name, entryname, code);
	if code ^= 0
	then do;
		call com_err_ (code, ME, "^a", argument);
		return;
	     end;

	call initiate_file_ (dir_name, entryname, RW_ACCESS, qp, (0), code);
	if code ^= 0
	then do;
		call com_err_ (code, ME, "^a", pathname_ (dir_name, entryname));
		return;
	     end;

	reqfile.version = REQFILE_VERSION;
	call terminate_file_ (qp, (0), TERM_FILE_TERM, (0));
	return;
     end convert_MR10_2_reqfile;




		    convert_MR10_2_sat.pl1          07/13/88  1238.1r w 07/13/88  0943.1       62874



/* ***********************************************************
   *                                                         *
   * Copyright, (C) Honeywell Information Systems Inc., 1983 *
   *                                                         *
   *********************************************************** */
/* convert_MR10_2_sat.pl1 -- converts to MR11 SAT-entry format */
/* To be run over >udd>sa>a>smf.cur.sat and >sc1>sat */
/* format: style2 */

/* BIM 1984-07-05 */
/* Modified 1984-09-14 BIM to unalign old "groups" */
/* Modified 1984-12-14 by EJ Sharpe to call (convert reset)_MR10_2_audit_flags_ */

convert_MR10_2_sat:
     procedure options (variable);

	declare com_err_		 entry () options (variable);
	declare convert_MR10_2_audit_flags_ entry (bit (36) aligned);
	declare cu_$arg_count_rel	 entry (fixed bin, ptr, fixed bin (35));
	declare cu_$arg_ptr_rel	 entry (fixed bin, ptr, fixed bin (21), fixed bin (35), ptr);
	declare cu_$arg_list_ptr	 entry (ptr);
	declare expand_pathname_	 entry (character (*), character (*), character (*), fixed binary (35));
	declare initiate_file_	 entry (character (*), character (*), bit (*), pointer, fixed binary (24),
				 fixed binary (35));
	declare pathname_		 entry (character (*), character (*)) returns (character (168));
	declare reset_MR10_2_audit_flags_ entry (bit (36) aligned);
	declare terminate_file_	 entry (pointer, fixed binary (24), bit (*), fixed binary (35));


	declare arg_count		 fixed bin;
	declare ap		 pointer;
	declare al		 fixed bin (21);
	declare alp		 pointer;
	declare argument		 char (al) based (ap);
	declare code		 fixed bin (35);
	declare dir_name		 char (168);
	declare entryname		 char (32);
	declare old_authorization	 bit (72) aligned;
	declare (satp, satep)	 pointer;		/* live */
	declare satex		 fixed bin;

%include sat;
%include user_attributes;
%include access_mode_values;
%include terminate_file;

	declare 1 new_project	 aligned like project;

/**** MR10.2 sat entry structure */

/**** The entry size does not change in this change, but the variables
      are rearranged. */

	dcl     1 old_project	 aligned,		/* declaration of a single SAT entry  */
		2 state		 fixed bin,	/* state 1 = normal, 0 = free, 2 = deleted */
		2 project_id	 char (12) aligned, /* project's name */
		2 project_dir	 char (64) aligned, /* project's directory */
		2 pdt_ptr		 pointer,		/* pointer to current PDT */
		2 max_users	 fixed bin,	/* maximum number of users from project */
		2 n_users		 fixed bin,	/* current number */
		2 at		 like user_attributes aligned,
						/* include user_attributes.incl.pl1 */
		2 admin		 (4) aligned,	/* list of project's administrators  */
		  3 userid	 char (30) unal,	/* administrator's user-id (personid.projectid) */
		  3 pad		 char (2) unal,
		2 cutoff		 char (1),	/* if project is cut off, why. */
		2 min_ring	 fixed bin,	/* lowest ring for project */
		2 max_ring	 fixed bin,	/* highest ring for project */
		2 alias		 char (8),	/* project alias */
		2 group		 char (8),	/* default group for this project */
		2 grace_max	 fixed bin,	/* maximum bump grace */
		2 audit		 bit (36),	/* audit flags for project */
		2 project_authorization_1
				 bit (72),	/* authorization of this project */
		2 groups		 (2) char (8) unal,	/* authorized groups for this project */
		2 days_to_cutoff	 fixed bin (17) unaligned,
						/* these figures are as of last running of daily_summary */
		2 pct_balance	 fixed bin (17) unaligned,
						/* they are used for warning message printing only */
		2 dollars_to_cutoff	 float bin,	/* and are not to be taken as up-to-date figures */
		2 pdir_quota	 fixed bin (17) unaligned,
						/* max pdir quota allowed for project */
		2 max_foreground	 fixed bin (9) unsigned unaligned,
						/* max simultaneous foreground and background */
		2 max_background	 fixed bin (9) unsigned unaligned,
						/* processes that a user on this project can have */
		2 abs_foreground_cpu_limit
				 fixed bin (17) unaligned,
						/* time limit on foreground absentee jobs */
		2 rs_number	 fixed bin (9) unsigned unaligned,
						/* rate structure number (0=default rates ) */
		2 satpad1		 fixed bin (9) unsigned unaligned,
		2 satpad_1	 (3) fixed bin,	/* pad to 80 words */
		2 chain		 fixed bin;	/* if free entry, chain */


	call cu_$arg_list_ptr (alp);
	call do_work ("convert_MR10_2_sat", alp, converter, SAT_version);
	return;

reset_MR10_2_sat:
     entry options (variable);

	call cu_$arg_list_ptr (alp);
	call do_work ("reset_MR10_2_sat", alp, reverter, SAT_version - 1);
	return;

do_work:
     procedure (ME, alp, worker, target_version);
	declare alp		 ptr;
	declare ME		 char (*);
	declare worker		 entry (ptr) variable;
	declare target_version	 fixed bin;

	call cu_$arg_count_rel (arg_count, alp, code);
	if code ^= 0
	then do;
		call com_err_ (code, ME);
		return;
	     end;

	if arg_count ^= 1
	then do;
		call com_err_ (0, ME, "Usage: ^a SAT_PATH.sat", ME);
		return;
	     end;

	satp = null ();

	call cu_$arg_ptr_rel (1, ap, al, (0), alp);
	call expand_pathname_ (argument, dir_name, entryname, code);
	if code ^= 0
	then do;
		call com_err_ (code, ME, "^a", argument);
		return;
	     end;

	call initiate_file_ (dir_name, entryname, RW_ACCESS, satp, (0), code);
	if code ^= 0
	then do;
		call com_err_ (code, ME, "^a", pathname_ (dir_name, entryname));
		return;
	     end;


	if sat.version = target_version
	then do;
		call com_err_ (0, ME, "SAT ^a is already version ^d.", pathname_ (dir_name, entryname),
		     target_version);
		go to TERM_RETURN;
	     end;
	if sat.version = -1
	then do;
		call com_err_ (0, ME,
		     "SAT ^a was partially converted, and is notr salvageable. Recover a saved version.",
		     pathname_ (dir_name, entryname));
		go to TERM_RETURN;
	     end;

	sat.version = -1;				/* BROKEN */
	do satex = 1 to sat.current_size;
	     satep = addr (sat.project (satex));
	     if project.state ^= 0
	     then do;				/* worth fixing */
		     call worker (satep);
		end;
	end;

	sat.version = target_version;
TERM_RETURN:
	call terminate_file_ (satp, (0), TERM_FILE_TERM, (0));
	return;
     end do_work;

converter:
     procedure (satep);
	declare satep		 pointer;

	unspec (new_project) = ""b;
	unspec (old_project) = unspec (satep -> project);
	new_project = old_project, by name;
	old_authorization = old_project.project_authorization_1;
	new_project.project_authorization (1) = ""b;
	new_project.project_authorization (2) = old_authorization;
	call convert_MR10_2_audit_flags_ (new_project.audit);
	satep -> project = new_project;
	return;
     end converter;

reverter:
     procedure (satep);
	declare satep		 pointer;

	unspec (old_project) = ""b;
	unspec (new_project) = unspec (satep -> project);
	old_project = new_project, by name;
	old_project.project_authorization_1 = new_project.project_authorization (2);
	call reset_MR10_2_audit_flags_ (old_project.audit);
	unspec (satep -> project) = unspec (old_project);
	return;
     end reverter;
     end convert_MR10_2_sat;




		    convert_MR10_2_urf.pl1          12/05/84  1350.0r w 12/05/84  0854.0       33291



/* ***********************************************************
   *                                                         *
   * Copyright, (C) Honeywell Information Systems Inc., 1984 *
   *                                                         *
   *********************************************************** */
/* CONVERT_MR10_2_URF: Program to convert a MR10.2 URF to a MR11 URF.
   MR11 URFs are Version 3 MSTBs rather than Version 1 or 2.  The 
   format of the URF entries themselves has not changed. */

/* format: style2 */
/* Written 1984-07-31 by Eric Swenson */

convert_MR10_2_urf:
     procedure options (variable);

/* Automatic */

	dcl     argument_idx	 fixed bin (17);
	dcl     argument_lth	 fixed bin (21);
	dcl     argument_ptr	 ptr;
	dcl     code		 fixed bin (35);
	dcl     dirname		 char (168);
	dcl     entryname		 char (32);
	dcl     n_arguments		 fixed bin (17);
	dcl     new_entryname	 char (32);
	dcl     old_entryname	 char (32);
	dcl     old_newname		 char (32);

/* Based */

	dcl     argument		 char (argument_lth) based (argument_ptr);

/* External Entries */

	dcl     com_err_		 entry () options (variable);
	dcl     convert_v2_mstb_	 entry (char (*), char (*), char (*), char (*), entry, fixed bin (18) unsigned,
				 fixed bin (35));
	dcl     convert_v2_mstb_$default_convert_proc
				 entry (ptr, ptr, ptr, fixed bin (35));
	dcl     cu_$arg_count	 entry (fixed bin, fixed bin (35));
	dcl     cu_$arg_ptr		 entry (fixed bin, ptr, fixed bin (21), fixed bin (35));
	dcl     expand_pathname_	 entry (char (*), char (*), char (*), fixed bin (35));
	dcl     hcs_$chname_file	 entry (char (*), char (*), char (*), char (*), fixed bin (35));
	dcl     ms_table_mgr_$delete	 entry (char (*), char (*), fixed bin (35));
	dcl     pathname_		 entry (char (*), char (*)) returns (char (168));
	dcl     unique_chars_	 entry (bit (*)) returns (char (15));

/* Constant */

	dcl     ME		 char (32) initial ("convert_MR10_2_urf") internal static options (constant);
	dcl     SAME_SIZE		 fixed bin (18) unsigned internal static options (constant) initial (0);
%page;
/* Program */

	call cu_$arg_count (n_arguments, code);
	if code ^= 0
	then do;
		call com_err_ (code, ME);
		return;
	     end;

	if n_arguments = 0
	then do;
		call com_err_ (0, ME, "Usage: ^a pathname_of_urf_to_convert", ME);
		return;
	     end;

	call cu_$arg_ptr (1, argument_ptr, argument_lth, (0));
	call expand_pathname_ (argument, dirname, entryname, code);
	if code ^= 0
	then do;
		call com_err_ (code, ME, "^a", argument);
		return;
	     end;

	new_entryname = rtrim (substr (entryname, 1, 16)) || "." || unique_chars_ (""b);

	call convert_v2_mstb_ (dirname, entryname, dirname, new_entryname, convert_v2_mstb_$default_convert_proc,
	     SAME_SIZE, code);
	if code ^= 0
	then do;					/* Error occured, delete new table (if created), and rename old one back. */
		call com_err_ (code, ME, "Converting v2 MSTB.");
		return;
	     end;

	old_newname = rtrim (substr (entryname, 1, 16)) || "." || unique_chars_ (""b);

/* Add shriekname to old MSTB */

	call hcs_$chname_file (dirname, entryname, "", old_newname, code);
	if code ^= 0
	then do;
		call com_err_ (code, ME, "Adding shriekname to old MSTB.");
		return;
	     end;

/* Delete real name from old MSTB */

	call hcs_$chname_file (dirname, entryname, entryname, "", code);
	if code ^= 0
	then do;
		call com_err_ (code, ME, "Deleting name from old MSTB.");
		return;
	     end;

/* Rename the new one to the real name */

	call hcs_$chname_file (dirname, new_entryname, new_entryname, entryname, code);
	if code ^= 0
	then do;
		call com_err_ (code, ME, "Renaming new MSTB.");
		return;
	     end;

	return;

     end convert_MR10_2_urf;




		    convert_MR10_2_use_totals.pl1   08/29/88  0945.7rew 08/29/88  0858.7       95031



/****^  ***********************************************************
        *                                                         *
        * Copyright, (C) Honeywell Bull Inc., 1988                *
        *                                                         *
        * Copyright, (C) Honeywell Information Systems Inc., 1984 *
        *                                                         *
        *********************************************************** */


/****^  HISTORY COMMENTS:
  1) change(88-04-28,GDixon), approve(88-08-15,MCR7969),
     audit(88-08-03,Lippard), install(88-08-29,MR12.2-1093):
      A) Use correct array extents in do-group limits. (phx20016)
                                                   END HISTORY COMMENTS */


/* convert_MR10_2_use_totals.pl1 */
/* format: style2 */

convert_MR10_2_use_totals:
     procedure options (variable);

	declare cv_dec_check_	 entry (character (*), fixed binary (35)) returns (fixed binary (35));
	declare expand_pathname_$add_suffix
				 entry (character (*), character (*), character (*), character (*),
				 fixed binary (35));
	declare initiate_file_	 entry (character (*), character (*), bit (*), pointer, fixed binary (24),
				 fixed binary (35));
	declare terminate_file_	 entry (pointer, fixed binary (24), bit (*), fixed binary (35));
	declare get_temp_segment_	 entry (character (*), pointer, fixed binary (35));
	declare release_temp_segment_	 entry (character (*), pointer, fixed binary (35));
	declare com_err_		 entry () options (variable);
	declare com_err_$suppress_name entry () options (variable);
	declare cu_$arg_count	 entry (fixed bin, fixed bin (35));
	declare cu_$arg_ptr		 entry (fixed bin, ptr, fixed bin (21), fixed bin (35));
	declare pathname_		 entry (character (*), character (*)) returns (character (168));

	declare argp		 pointer;
	declare argl		 fixed bin (21);
	declare argument		 char (argl) based (argp);
	declare arg_count		 fixed bin;
	declare code		 fixed bin (35);
	declare (dayx, qhx, sh)	 fixed bin;
	declare dir		 char (168);
	declare entryname		 char (32);
	declare np		 pointer;		/* pointer to temp seg */
	declare 1 new		 aligned like use_totals based (np);

	declare (addr, hbound, min, null, size)
				 builtin;
	declare cleanup		 condition;
	declare ME		 char (32) init ("convert_MR10_2_use_totals") int static options (constant);


	call cu_$arg_count (arg_count, code);
	if code ^= 0
	then do;
		call com_err_ (code, ME);
		return;
	     end;

	if arg_count ^= 1
	then do;
		call com_err_$suppress_name (0, ME, "Usage:  convert_MR10_2_use_totals USE_TOTALS_PATHNAME");
		return;
	     end;

	np, use_totals_ptr = null ();
	on cleanup
	     begin;
		if use_totals_ptr ^= null ()
		then call terminate_file_ (use_totals_ptr, (0), TERM_FILE_TERM, (0));
		if np ^= null ()
		then call release_temp_segment_ (ME, np, (0));
	     end;

	call cu_$arg_ptr (1, argp, argl, (0));
	call expand_pathname_$add_suffix (argument, "use_totals", dir, entryname, code);
	if code ^= 0
	then do;
		call com_err_ (code, ME, """^a"".", argument);
		return;
	     end;
	call initiate_file_ (dir, entryname, RW_ACCESS, use_totals_ptr, (0), code);
	if code ^= 0
	then do;
		call com_err_ (code, ME, "^a", pathname_ (dir, entryname));
		return;
	     end;

	call get_temp_segment_ (ME, np, (0));

	new.meters = v2_use_totals.meters;		/* aggregately */
	new.version = USE_TOTALS_VERSION_3;
	new.b_and_w.origin = v2_use_totals.b_and_w.origin;
	new.b_and_w.max_day_log = v2_use_totals.b_and_w.max_day_log;
	new.b_and_w.max_qhour = v2_use_totals.b_and_w.max_qhour;
	do dayx = 1 to min (v2_use_totals.max_day_log, hbound (v2_use_totals.daylog, 1));
	     do qhx = 1 to min (v2_use_totals.max_qhour, hbound (v2_use_totals.daylog.qh, 1));
		begin;
		     declare 1 old_qh	      aligned like v2_use_totals.daylog.qh based (old_qhp);
		     declare 1 new_qh	      aligned like use_totals.daylog.qh based (new_qhp);
		     declare (old_qhp, new_qhp)     pointer;
		     old_qhp = addr (v2_use_totals.daylog (dayx).qh (qhx));
		     new_qhp = addr (new.daylog (dayx).qh (qhx));
		     new_qh.time = old_qh.time;
		     new_qh.sysid = old_qh.sysid;
		     if old_qh.erfno = "shutdown"
		     then new_qh.shutdown = "1"b;
		     else new_qh.dump_number = cv_dec_check_ ((old_qh.erfno), code);
		     if code ^= 0
		     then new_qh.dump_number = 0;
		     new_qh.cpu = old_qh.cpu;
		     new_qh.kmem = old_qh.kmem;
		     new_qh.nunits = old_qh.nunits;
		     new_qh.starttime = old_qh.starttime;
		     new_qh.crashtime = old_qh.crashtime;
		end;
	     end;
	end;

	new.bins.ntypes = v2_use_totals.bins.ntypes;
	new.bins.n_select = v2_use_totals.bins.n_select;
	do sh = 1 to min (hbound (new.bin_data, 1), new.bins.n_select);
	     new.bin_data (sh).select_proj = v2_use_totals.select_proj (sh);
	     new.bin_data (sh).select_ut = v2_use_totals.select_ut (sh);
	end;
	do sh = 1 to min (hbound (new.ut, 1), new.bins.ntypes);
	     new.bins.ut (sh) = v2_use_totals.bins.ut (sh);
	end;
	use_totals = new;				/* copy back */
	call terminate_file_ (use_totals_ptr, 36 * size (use_totals), TERM_FILE_TRUNC_BC, (0));
	call release_temp_segment_ (ME, np, (0));
	return;
%page;

%include use_totals;
%include access_mode_values;
%include terminate_file;

	dcl     1 v2_use_totals	 based (use_totals_ptr) aligned,
		2 meters,
		  3 generated	 fixed bin (71),	/* Time usage data generated. */
		  3 period_begin	 fixed bin (71),	/* Earliest time covered */
		  3 period_end	 fixed bin (71),	/* Latest time */
		  3 disk_available	 fixed bin (35),	/* Total disk capacity in MULT partition. */
		  3 disk_left	 fixed bin (35),	/* Total disk unused in MULT partition. */
		  3 version	 char (8),	/* revision of this include file */
		  3 pad1		 (6) fixed bin,	/* Gross system statistics, determined from answering service meters. */
		  3 uptime	 fixed bin (71),	/* Time system has been on the air. */
		  3 sys_starts	 fixed bin,	/* Number of bootloads */
		  3 sys_crash	 fixed bin,	/* Number of crashes */
		  3 cpu_avail	 fixed bin (71),	/* CPU time available. >= uptime by two-cpu time */
		  3 idle		 fixed bin (71),	/* Total idle for all causes */
		  3 initializer	 fixed bin (71),	/* Initializer usage */
		  3 total_cpu	 fixed bin (71),	/* Total VIRTUAL cpu from bins - so get overhead */
		  3 zidle		 fixed bin (71),	/* Total zero idle. */
		  3 mpidle	 fixed bin (71),	/* Total MP idle */
		  3 pad2		 (6) fixed bin (71),/* variables used while reading answering service meters */
		  3 zidle_since_boot fixed bin (71),	/* Zero idle since boot */
		  3 mpidle_since_boot
				 fixed bin (71),	/* MP idle since boot */
		  3 time_last_boot	 fixed bin (71),	/* Time of last bootload */
		  3 time_last_sample fixed bin (71),	/* Time of last 15-minute sample */
		  3 uptime_since_boot
				 fixed bin (71),	/* Time system on air since last boot */
		  3 cpu_avail_since_boot
				 fixed bin (71),	/* CPU available since boot */
		  3 idle_since_boot	 fixed bin (71),	/* Idle time since boot */
		  3 last_sysid	 char (8),	/* Current system ID */
		  3 n_users_on	 fixed bin,	/* Users on at last sample */
		  3 n_stat_gaps	 fixed bin,	/* Number of times we missed getting all data */
						/* Statistics by day, for black and white chart. */
		2 b_and_w,
		  3 origin	 fixed bin (71),	/* Base time for slot 1 */
		  3 max_day_log	 fixed bin,	/* Highest used day. */
		  3 max_qhour	 fixed bin,	/* Highest quarter in highest day */
		  3 daylog	 (40),		/* array of days. */
		    4 qh		 (96),		/* Quarter-hour within the day. */
		      5 time	 fixed bin (71),	/* Time of sample. */
		      5 sysid	 char (8),	/* System ID */
		      5 erfno	 char (8),	/* If crash occurred, ERF no  */
		      5 cpu	 fixed bin (5) unal,/* Number of CPU */
		      5 pad1	 fixed bin (11) unal,
		      5 kmem	 fixed bin (17) unal,
						/* Number of K of core */
		      5 kbulk	 fixed bin (17) unal,
						/* Number fo K of bulk */
		      5 nunits	 fixed bin (17) unal,
						/* Number of load units */
		      5 starttime	 fixed bin (71),	/* Boot time */
		      5 crashtime	 fixed bin (71),	/* Time of crash */
		      5 pad2	 (4) fixed bin,	/* User-classification info, loaded once a month. defines usage bins. bin 1 is always "other" */
		2 bins,
		  3 ntypes	 fixed bin,	/* Number of valid bins */
		  3 n_select	 fixed bin,	/* Number of selectors */
		  3 select_proj	 (3258) char (12) aligned,
						/* Project ID - same number as in sat */
		  3 select_ut	 (3258) fixed bin,	/* Bin number for the project */
		  3 ut		 (301),		/* array usage by project type */
		    4 utype	 char (24),	/* Label for usage bin */
		    4 dollar_charge	 float bin,	/* total dollars spent this month */
		    4 logins	 fixed bin,	/* number of logins */
		    4 crashes	 fixed bin,	/* sessions abnormally terminated */
		    4 nproj	 fixed bin,	/* projects in this class */
		    4 nusers	 fixed bin,	/* users in this class */
		    4 disk_psec	 fixed bin (71),	/* Total page-seconds */
		    4 disk_quota	 fixed bin (35),	/* Total quota */
		    4 disk_usage	 fixed bin (35),	/* Disk occupancy */
		    4 misc	 float bin,	/* Miscellaneous charges */
		    4 flag	 char (4),	/* paying catagories = "$" */
		    4 flag1	 char (4),	/* used to control reporting of catagories */
		    4 pad1a	 (3) fixed bin (35),
		    4 rs_number	 fixed bin,	/* rate structure number for all projects in this bin */
		    4 pad1b	 (14) fixed bin (35),
		    4 interactive	 (0:7),		/* interactive use, shifts 0-7 */
		      5 charge	 float bin,	/* total dollar charge this shift */
		      5 pad1	 fixed bin,
		      5 cpu	 fixed bin (71),	/* cpu usage in microseconds */
		      5 core	 fixed bin (71),	/* core demand in page-microseconds */
		      5 connect	 fixed bin (71),	/* total console time in microseconds */
		      5 io_ops	 fixed bin (71),	/* total terminal i/o ops */
		    4 absentee	 (4),		/* absentee use, queues 1-4 */
		      5 charge	 float bin,	/* dollar charge this queue */
		      5 jobs	 fixed bin,	/* number of jobs submitted */
		      5 cpu	 fixed bin (71),	/* total cpu time in microseconds */
		      5 memory	 fixed bin (71),	/* total memory usage in mu */
		    4 iod		 (4),		/* io daemon use, queues 1-4 */
		      5 charge	 float bin,	/* dollar charge this queue */
		      5 pieces	 fixed bin,	/* pieces of output requested */
		      5 pad2	 fixed bin,
		      5 pages	 fixed bin,	/* number of pages output */
		      5 lines	 fixed bin (71),	/* total record count of output */
		    4 devices	 (16) float bin;	/* device charges */




     end convert_MR10_2_use_totals;




		    convert_old_log.pl1             04/09/85  1521.7r w 04/08/85  1134.6      115344



/* ***********************************************************
   *                                                         *
   * Copyright, (C) Honeywell Information Systems Inc., 1982 *
   *                                                         *
   *********************************************************** */

/* format: style5 */
convert_old_log:
        procedure options (variable);


/**** Modification history:
      Created 1984-12-18, BIM: from the old print_log command.
      Modified 1985-01-20, BIM: to be run after the first bootload.
      Modified 1985 Jan 21, Art Beattie: display old log names in error messages
      and as conversion progresses. */

        dcl     absolute_pathname_	entry (character (*), character (*),
				fixed binary (35));
        dcl     expand_pathname_	entry (character (*), character (*),
				character (*), fixed binary (35));
        dcl     initiate_file_	entry (character (*), character (*),
				bit (*), pointer, fixed binary (24),
				fixed binary (35));
        dcl     terminate_file_	entry (pointer, fixed binary (24),
				bit (*), fixed binary (35));
        declare pathname_		entry (character (*), character (*))
				returns (character (168));
        dcl     com_err_		entry options (variable);
        dcl     cu_$arg_list_ptr	entry returns (pointer);
        dcl     ioa_		entry () options (variable);
        declare sub_err_		entry () options (variable);
        declare ssu_$standalone_invocation
				entry (ptr, char (*), char (*), ptr,
				entry, fixed bin (35));
        declare ssu_$destroy_invocation entry (ptr);
        declare ssu_$arg_count	entry (ptr, fixed bin);
        declare ssu_$arg_ptr		entry (ptr, fixed bin, ptr,
				fixed bin (21));
        declare ssu_$abort_line	entry () options (variable);
        dcl     log_read_$open	entry (character (*), character (*),
				pointer, fixed binary (35));
        dcl     log_read_$close	entry (pointer, fixed binary (35));
        dcl     log_write_$open_for_migrate
				entry (character (*), character (*),
				bit (1) aligned, pointer,
				fixed binary (35));
        dcl     log_write_$close	entry (pointer, fixed binary (35));
        dcl     log_write_$general	entry (pointer, fixed binary (35),
				fixed binary, fixed binary,
				character (10) var, pointer,
				fixed binary (35));
        dcl     log_segment_$finish_message
				entry (pointer, pointer,
				fixed binary (35));
        dcl     copy_		entry (pointer);


        dcl     code		fixed bin (35);
        dcl     argument		char (al) based (ap) unaligned;
        dcl     ap			ptr;
        dcl     al			fixed bin (21);
        dcl     old_log_x		fixed bin;
        dcl     an			fixed bin;
        dcl     n_args		fixed bin;
        dcl     total_messages	fixed bin;
        dcl     sci_ptr		pointer;

        dcl     COMMAND_NAME		char (32) int static
				options (constant)
				init ("convert_old_log");
        dcl     error_table_$badopt	ext fixed bin (35);
        dcl     error_table_$too_many_args
				fixed bin (35) ext static;
        dcl     error_table_$noarg	fixed bin (35) ext static;

        dcl     cleanup		condition;
        dcl     no_write_permission	condition;

        declare 1 opt		aligned,
	        2 log_write_ptr	pointer,
	        2 log_read_ptr	pointer,
	        2 pathnames		unaligned,
		3 old_log		unaligned,
		  4 dir_name	char (168),
		  4 entryname	char (32),
		  4 history_dir	char (168),
		3 new_log		unaligned,
		  4 dir_name	char (168),
		  4 entryname	char (32),
		  4 history_dir	char (168),
	        2 n_old_logs	fixed bin,
	        2 old_log_ptrs	(200) pointer,
	        2 old_log_names	(200) char (32);

        declare (addr, length, rtrim)	builtin;


        call ssu_$standalone_invocation (sci_ptr, COMMAND_NAME, "1.0",
	  cu_$arg_list_ptr (), SSU_ABORT, code);
        if code ^= 0 then
	      do;
	      call com_err_ (code, COMMAND_NAME,
		"Failed to create ssu_ invocation");
	      return;
	      end;

        call ssu_$arg_count (sci_ptr, n_args);

        opt.log_write_ptr = null ();
        opt.pathnames = "";
        opt.old_log_ptrs (*) = null ();
        opt.n_old_logs = 0;

        on cleanup call clean_up;

        if n_args = 0 then
	      call ssu_$abort_line (sci_ptr, 0,
		"Usage: ^a OLD_LOG_PATHNAME {-old_history_dir OLD_LOG_DIR_PATH -new_dir NEW_LOG_DIR_PATH -new_history_dir NEW_LOG_HISTORY_PATH}"
		, COMMAND_NAME);

        do an = 1 to n_args;
	      call ssu_$arg_ptr (sci_ptr, an, ap, al);
	      if index (argument, "-") ^= 1 then
		    do;
		    if opt.old_log.dir_name ^= "" then
			  call ssu_$abort_line (sci_ptr,
			      error_table_$too_many_args,
			      "Only one log pathname may be given. ^a is the second."
			      , argument);
		    call expand_pathname_ (argument, opt.old_log.dir_name,
		        opt.old_log.entryname, code);
		    if code ^= 0 then
			  call ssu_$abort_line (sci_ptr, code, "^a",
			      argument);
		    end;
	      else if (argument = "-old_history_dir") | (argument = "-ohd")
		then
		    do;
		    call get_next_arg (
		        "pathname of a dir full of old logs following -history."
		        );
		    call absolute_pathname_ (argument,
		        opt.old_log.history_dir, code);
		    if code ^= 0 then
			  call ssu_$abort_line (sci_ptr, code, "^a",
			      argument);
		    end;
	      else if (argument = "-new_dir") | (argument = "-nd") then
		    do;
		    call get_next_arg (
		        "target directory for converted log.");
		    call absolute_pathname_ (argument, opt.new_log.dir_name,
		        code);
		    if code ^= 0 then
			  call ssu_$abort_line (sci_ptr, code, "^a",
			      argument);
		    end;
	      else if (argument = "-new_history_dir") | (argument = "-nhd")
		then
		    do;
		    call get_next_arg (
		        "target directory for the second and later new log segments."
		        );
		    call absolute_pathname_ (argument,
		        opt.new_log.history_dir, code);
		    if code ^= 0 then
			  call ssu_$abort_line (sci_ptr, code, "^a",
			      argument);
		    end;
	      else
		    call ssu_$abort_line (sci_ptr, error_table_$badopt,
		        "^a", argument);
        end;

        if opt.old_log.dir_name = "" then
	      call ssu_$abort_line (sci_ptr, error_table_$noarg,
		"A log to be converted must be specified.");
        if opt.old_log.history_dir = "" then
	      opt.old_log.history_dir = ">udd>SysAdmin>admin>history";
        if opt.new_log.dir_name = "" then
	      opt.new_log.dir_name = ">system_control_dir>as_logs";
        opt.new_log.entryname = opt.old_log.entryname;
        if opt.new_log.history_dir = "" then
	      opt.new_log.history_dir = ">udd>SysAdmin>admin>history";

/**** Initiate the first (most recent) log. */

        call initiate_file_ (opt.old_log.dir_name, opt.old_log.entryname,
	  R_ACCESS, opt.old_log_ptrs (1), (0), code);
        if code ^= 0 then
	      call ssu_$abort_line (sci_ptr, code, "Failed to initiate ^a.",
		pathname_ (opt.old_log.dir_name, opt.old_log.entryname));
        opt.old_log_names (1) = opt.old_log.entryname;
        opt.n_old_logs = 1;

        call add_to_history (1, opt.old_log.dir_name);  /* get the co-resident segments */
        call add_to_history (opt.n_old_logs, opt.old_log.history_dir);

/**** We now have an array of pointers to old log segments to eat */
/**** We want to write all the messages into segments in the history dir. */
/**** And then move the last one and fix its header. */

        call log_write_$open_for_migrate (opt.new_log.history_dir,
	  opt.new_log.entryname, "1"b, opt.log_write_ptr, code);
        if code ^= 0 then
	      call ssu_$abort_line (sci_ptr, code,
		"Failed to open new log ^a.",
		pathname_ (opt.new_log.dir_name, opt.new_log.entryname));

        total_messages = 0;
        do old_log_x = opt.n_old_logs to 1 by -1;	      /* Work from the oldest */
	      call ioa_ ("convert_old_log: Converting old log segment ^a",
		opt.old_log_names (old_log_x));
	      call write_one_log (opt.old_log_ptrs (old_log_x),
		opt.old_log_names (old_log_x));
        end;

        call log_write_$close (opt.log_write_ptr, (0));
        if opt.new_log.dir_name ^= opt.new_log.history_dir then
	      call fix_history_dir;
        call terminate_old_logs;

        call ioa_ ("convert_old_log: Converted ^d segments, ^d messages.",
	  opt.n_old_logs, total_messages);

        return;


get_next_arg:
        procedure (P_what);

        declare P_what		char (*);

        if n_args = an then
	      call ssu_$abort_line (sci_ptr, error_table_$noarg, "^a", P_what)
		;
        an = an + 1;
        call ssu_$arg_ptr (sci_ptr, an, ap, al);
        return;
        end get_next_arg;

terminate_old_logs:
        procedure;

        declare x			fixed bin;

        do x = 1 to opt.n_old_logs;
	      call terminate_file_ (opt.old_log_ptrs (x), (0), TERM_FILE_TERM,
		(0));
        end;
        return;
        end terminate_old_logs;

add_to_history:
        procedure (P_oldest_index, P_dir_name);

        declare P_oldest_index	fixed bin;
        declare P_dir_name		char (*);

        declare entryname		char (32);
        declare current_log_ptr	pointer;
        declare older_log_ptr		pointer;

        current_log_ptr = opt.old_log_ptrs (P_oldest_index);
        code = 0;
        do while ("1"b);
	      entryname =
		rtrim (opt.old_log.entryname) || ".-."
		|| current_log_ptr -> sys_log_file.lls;
	      call initiate_file_ (P_dir_name, entryname, R_ACCESS,
		older_log_ptr, (0), code);
	      if code ^= 0 then
		    return;
	      opt.n_old_logs = opt.n_old_logs + 1;
	      opt.old_log_ptrs (opt.n_old_logs) = older_log_ptr;
	      opt.old_log_names (opt.n_old_logs) = entryname;
	      current_log_ptr = older_log_ptr;
        end;
        end add_to_history;

write_one_log:
        procedure (P_log_ptr, P_log_name);

        declare P_log_ptr		pointer;
        declare log_ptr		pointer;
        declare 1 log		aligned like sys_log_file
				based (log_ptr);
        declare x			fixed bin;
        declare log_name		char (32);
        declare P_log_name		char (*) aligned;

        log_name = P_log_name;
        log_ptr = P_log_ptr;
        do x = 1 to log.count;
RETRY:
	      total_messages = total_messages + 1;
	      call log_write_$general (opt.log_write_ptr, (0),
		length (rtrim (log.array (x).line)), (0), "",
		log_message_ptr, code);
	      if code ^= 0 then
		    do;
		    call sub_err_ (code, COMMAND_NAME, ACTION_CAN_RESTART,
		        null (), (0),
		        "Failed to add message ^d from segment ^a (^p) to log ^a."
		        , x, log_name, log_ptr, opt.new_log.entryname);
		    go to RETRY;
		    end;
	      log_message.severity = log.array (x).svty;
	      log_message.time = log.array (x).time;
	      log_message.text =
		substr (log.array (x).line, 1, log_message.text_lth);
	      call log_segment_$finish_message (
		setwordno (log_message_ptr, 0), log_message_ptr, code);
	      if code ^= 0 then
		    call sub_err_ (code, COMMAND_NAME, ACTION_CANT_RESTART,
		        null (), (0),
		        "Failed to finish message ^d in new log that was obtained from old log ^a"
		        , log_message.sequence, log_name);
        end;
        end write_one_log;

fix_history_dir:
        procedure;

        call log_read_$open (opt.new_log.dir_name, opt.new_log.entryname,
	  opt.log_read_ptr, code);
        if code ^= 0 then
	      do;
	      call com_err_ (code, "convert_old_log",
		"No log named ^a found in ^a. If you create one, you must use the set_log_history_dir command to link it to the converted log."
		, opt.new_log.entryname, opt.new_log.dir_name);
	      return;
	      end;

        log_segment_ptr =
	  opt.log_read_ptr
	  -> log_read_data
	  .segments (opt.log_read_ptr -> log_read_data.very_first_log_idx)
	  .ptr;
        on no_write_permission go to NO_WRITE;
        log_segment.previous_log_dir = opt.new_log.history_dir;
        revert no_write_permission;
        call log_read_$close (opt.log_read_ptr, (0));
        return;
NO_WRITE:
        call com_err_ (0, "convert_old_log",
	  "You lack w access to the current log ^a, so the previous log dir was not set."
	  , opt.new_log.entryname);
        return;

        end fix_history_dir;


clean_up:
        procedure;

        call terminate_old_logs;
        if opt.log_write_ptr ^= null () then
	      call log_write_$close (opt.log_write_ptr, (0));
        if sci_ptr ^= null () then
	      call ssu_$destroy_invocation (sci_ptr);
        return;
        end clean_up;

SSU_ABORT:
        procedure;

        go to ABORT;
        end SSU_ABORT;

ABORT:
        call clean_up;
        return;

%include log_message;
%include log_segment;
%include log_read_data;
%include syslog;
        declare sys_log_ptr		pointer init (null ());
%include access_mode_values;
%include sub_err_flags;
%include terminate_file;
        end convert_old_log;




		    convert_old_value_seg.pl1       04/09/85  1521.7r w 04/08/85  1134.6       48717



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

/* format: style2 */
/**** Created 1984-12-11 BIM from the old value command. */


convert_old_value_seg:
     procedure options (variable);

	dcl     entry		 char (32),
	        dir		 char (168),
	        segptr		 ptr,
	        vs_ptr		 pointer,
	        created		 bit (1) aligned,
	        set_first		 bit (1) aligned,
	        i			 fixed bin,
	        ap		 ptr,
	        al		 fixed bin (21),
	        bchr		 char (al) unal based (ap),
	        code		 fixed bin (35);

	dcl     (null, substr, addr, min)
				 builtin;

	dcl     com_err_		 entry options (variable);
	dcl     expand_pathname_	 entry (character (*), character (*), character (*), fixed binary (35));
	dcl     expand_pathname_$add_suffix
				 entry (character (*), character (*), character (*), character (*),
				 fixed binary (35));
	dcl     cu_$arg_ptr		 entry (fixed bin, ptr, fixed bin (21), fixed bin (35));
	dcl     cu_$arg_count	 entry (fixed bin, fixed bin (35));
	dcl     initiate_file_	 entry (character (*), character (*), bit (*), pointer, fixed binary (24),
				 fixed binary (35));
	dcl     initiate_file_$create	 entry (character (*), character (*), bit (*), pointer, bit (1) aligned,
				 fixed binary (24), fixed binary (35));
	dcl     pathname_		 entry (character (*), character (*)) returns (character (168));
	dcl     terminate_file_	 entry (pointer, fixed binary (24), bit (*), fixed binary (35));
	dcl     requote_string_	 entry (character (*)) returns (character (*));
	dcl     value_$init_seg	 entry (pointer, fixed binary, pointer, fixed binary (19), fixed binary (35));
	dcl     value_$set		 entry () options (variable);
	dcl     ioa_		 entry options (variable);

	dcl     error_table_$not_seg_type
				 fixed bin (35) ext static;

	dcl     PERMANENT		 bit (36) aligned init ("20000000000"b3) int static options (constant);


	dcl     1 valueseg		 based (segptr) aligned,
		2 laste		 fixed bin,
		2 freep		 fixed bin,
		2 pad		 (6) fixed bin,
		2 arry		 (14506),
		  3 name		 char (32),
		  3 valu		 char (32),
		  3 lth		 fixed bin,
		  3 chain		 fixed bin;


	call cu_$arg_count (i, code);
	if code ^= 0
	then do;
		call com_err_ (code, "convert_old_value_seg");
		return;
	     end;

	if i ^= 2
	then do;
		call com_err_ (0, "convert_old_value_seg", "Usage: convert_old_value_seg OLD_PATH NEW_PATH.value");
		return;
	     end;

	call cu_$arg_ptr (1, ap, al, (0));
	call expand_pathname_ (bchr, dir, entry, code);
	if code ^= 0
	then do;
		call com_err_ (code, "convert_old_value_seg", "old value seg ^a.", bchr);
		return;
	     end;

	call initiate_file_ (dir, entry, R_ACCESS, segptr, (0), code);
	if code ^= 0
	then do;
		call com_err_ (code, "convert_old_value_seg", "old value seg ^a.", bchr);
		return;
	     end;

	call cu_$arg_ptr (2, ap, al, (0));
	call expand_pathname_$add_suffix (bchr, "value", dir, entry, code);
	if code ^= 0
	then do;
		call com_err_ (code, "convert_old_value_seg", "new value seg ^a.", bchr);
		return;
	     end;

	call initiate_file_$create (dir, entry, RW_ACCESS, vs_ptr, created, (0), code);
	if code ^= 0
	then do;
		call com_err_ (code, "convert_old_value_seg", "new value seg ^a.", bchr);
		return;
	     end;

	if created
	then call ioa_ ("convert_old_value_seg: Created ^a.", pathname_ (dir, entry));

	if created
	then call initialize_value_segment;

	set_first = "0"b;

RETRY_CONVERSION:					/* Here if the first set discovered an uninitialized value segment */
	do i = 1 to valueseg.laste;			/* laste is last in use */
	     if (valueseg.chain (i) = 0) & (valueseg.name (i) ^= "")
	     then do;
		     call value_$set (vs_ptr, PERMANENT, valueseg.name (i),
			substr (valueseg.valu (i), 1, valueseg.lth (i)), (""), code);
		     if code = error_table_$not_seg_type
		     then do;
			     if set_first
			     then do;
				     call com_err_ (code, "convert_old_value_seg",
					"The new value segment became invalid after a vaue was set in it.");
				     go to CLEANUP_RETURN;
				end;
			     set_first = "1"b;
			     call initialize_value_segment;
			     go to RETRY_CONVERSION;
			end;
		     if code ^= 0
		     then do;
			     call com_err_ (code, "convert_old_value_seg",
				"Error setting new value seg variable ^a to ^a.",
				requote_string_ ((valueseg.name (i))),
				requote_string_ (substr (valueseg.valu (i), 1, valueseg.lth (i))));
			     go to CLEANUP_RETURN;
			end;
		end;
	end;

CLEANUP_RETURN:
	call terminate_file_ (segptr, (0), TERM_FILE_TERM, (0));
	call terminate_file_ (vs_ptr, (0), TERM_FILE_TERM, (0));
	return;



initialize_value_segment:
     procedure;

	call value_$init_seg (vs_ptr, 0, null (), 0, code);
	if code ^= 0
	then do;
		call com_err_ (code, "convert_old_value_seg", "Unable to initialize ^a as a value segment.",
		     pathname_ (dir, entry));
		go to CLEANUP_RETURN;
	     end;
	return;
     end initialize_value_segment;

%include access_mode_values;
%include terminate_file;
     end convert_old_value_seg;






		    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
