accept_rpv.pl1 11/11/89 1108.3r w 11/11/89 0827.9 76581 /****^ *********************************************************** * * * Copyright, (C) Honeywell Bull Inc., 1987 * * * * Copyright, (C) Honeywell Information Systems Inc., 1983 * * * *********************************************************** */ accept_rpv: procedure; /****^ HISTORY COMMENTS: 1) change(86-05-13,GJohnson), approve(86-05-13,MCR7387), audit(86-05-13,Martinson), install(86-05-14,MR12.0-1056): Correct error message documentation. 2) change(86-05-19,Lippard), approve(85-12-02,MCR7309), audit(86-05-21,Coppola), install(86-07-17,MR12.0-1097): Modified by Jim Lippard to base determination of whether this volume is a root PV on the new root_lv flag in the pvt rather than on hc_part_used, since root PVs need not have hardcore partitions now. 3) change(86-05-20,Fawcett), approve(86-04-11,MCR7383), audit(86-05-21,Coppola), install(86-07-17,MR12.0-1097): Add subvolume support. 4) change(87-01-08,Farley), approve(87-01-12,MECR0008), audit(87-01-09,GDixon), install(87-01-12,MR12.0-1268): Changed to reset pvt$rpvs_requested after successfully accepting all the rlv. This will then allow system_startup_ to do a salvage_dirs when required. 5) change(87-01-14,Farley), approve(87-01-14,MCR7608), audit(87-01-14,GDixon), install(87-01-14,MR12.0-1279): Offical installation of above corrections. END HISTORY COMMENTS */ /* This procedure accepts the RPV during system initialization. Stolen from accept_fs_disk August 1980 by C. Hornig Modified March 1982, J. Bongiovanni, to eliminate use of FSDCT Modified '82 for english error codes. Modified 1985-03-28, BIM: pre-accept non-partition volumes. */ dcl pvt$n_entries fixed bin external; dcl pvt$root_lvid bit (36) aligned external; dcl pvt$root_pvtx fixed bin external; dcl pvt$rlv_needs_salv bit (1) aligned external; dcl pvt$rpv_needs_salv bit (1) aligned external; dcl pvt$rpvs_requested bit (1) aligned external; dcl salv_data$rpv bit (1) aligned external; dcl accept_fs_disk entry (fixed bin, fixed bin (35)); dcl config_$find entry (char (4) aligned, ptr); dcl config_$find_parm entry (char (4) aligned, ptr); dcl make_sdw$reset_hcp entry; dcl read_disk entry (fixed bin, fixed bin, ptr, fixed bin (35)); dcl salvager$volume_salvage entry (fixed bin, bit (36) aligned, fixed bin (35)); dcl (syserr, syserr$error_code) entry options (variable); dcl wired_shutdown$enable entry; dcl all_root_vols_accepted bit (1); dcl code fixed bin (35); dcl i fixed bin; dcl pvtx fixed bin; dcl severity fixed bin; dcl n_hc_volmap_pages fixed bin; dcl salv_rlv_request bit (1); dcl 1 buffer aligned like label; dcl (addr, hbound, null, string) builtin; %page; labelp = addr (buffer); pvt_arrayp = addr (pvt$array); call config_$find_parm ("hcpt", intk_cardp); if intk_cardp = null () then severity = LOG; else severity = ANNOUNCE; /* Check all the claimed "RLV" volumes for brotherhood of the RPV. */ do pvtx = 1 to pvt$n_entries; /* Scan the PVT */ pvtep = addr (pvt_array (pvtx)); if pvte.hc_part_used & ^pvte.rpv then do; call read_disk (pvtx, LABEL_ADDR, labelp, code); if code ^= 0 then call syserr$error_code (CRASH, code, "accept_rpv: Cannot read label of ^a.", name (pvte)); if label.lvid ^= pvt$root_lvid then call syserr (CRASH, "accept_rpv: pv ^a lv ^a (^a) is not part of root.", label.pv_name, label.lv_name, name (pvte)); end; end; /* With this in hand, deal with the RPV personally. */ pvt$rpvs_requested = "0"b; salv_rlv_request = "0"b; intk_cardp = null (); /* search config deck */ call config_$find ("intk", intk_cardp); /* for the INTK card */ if intk_cardp ^= null () then do i = 1 to hbound (intk_card.parms, 1); /* search the card for RPVS and RLVS */ if intk_card.parms (i) = "rpvs" then do; intk_card.parms (i) = ""; /* clear it out */ pvt$rpvs_requested = "1"b; end; else if intk_card.parms (i) = "rlvs" then do; /* Salvage all PVs in RLV */ intk_card.parms (i) = ""; pvt$rpvs_requested = "1"b; salv_rlv_request = "1"b; end; end; pvtx = pvt$root_pvtx; /* Init_pvt left this here */ pvtep = addr (pvt_array (pvtx)); salv_data$rpv = "1"b; if pvt$rpv_needs_salv | pvt$rpvs_requested then pvt$rlv_needs_salv = "1"b; /* Salvage critical directories */ if pvt$rpvs_requested /* Explicit salvage RPV */ then call salvager$volume_salvage (pvtx, ""b, code); do pvtx = 1 to pvt$n_entries; pvtep = addr (pvt_array (pvtx)); if pvte.hc_part_used then do; n_hc_volmap_pages = pvte.volmap_stock_ptr -> record_stock.n_volmap_pages; call syserr (severity, "accept_rpv: HC part on ^a used ^d out of ^d records.", name (pvte), (pvte.totrec - pvte.nleft + n_hc_volmap_pages), pvte.totrec + n_hc_volmap_pages); end; end; call accept_fs_disk (pvt$root_pvtx, code); /* Do the standard trip on the RPV */ if code ^= 0 then call syserr$error_code (CRASH, code, "accept_rpv: Error accepting RPV"); call wired_shutdown$enable; /* Now if we crash clean it up */ fgbxp = addr (flagbox$); /* Set bit in the flagbox. */ fgbx.ssenb = "1"b; /* Flush the pvt brother threads that we had been using for HC part chain. */ /* They tend to bother logical_volume_manager. */ call make_sdw$reset_hcp; do i = 1 to pvt$n_entries; pvtep = addr (pvt_array (i)); pvte.brother_pvtx = 0; end; /* Now try to get all those "root volumes" accepted. */ all_root_vols_accepted = "1"b; /* assume success */ do pvtx = 1 to pvt$n_entries; pvtep = addr (pvt_array (pvtx)); if pvte.root_lv & ^pvte.rpv then do; if salv_rlv_request then call salvager$volume_salvage (pvtx, ""b, code); call accept_fs_disk (pvtx, code); if code ^= 0 then all_root_vols_accepted = "0"b; /* rlv incomplete */ end; end; salv_data$rpv = "0"b; if all_root_vols_accepted then pvt$rpvs_requested = "0"b; /* nolonger needed, if rlv accepted */ return; /* * * * * * * * * NAME * * * * * * * * * */ name: procedure (Pvte) returns (char (8) aligned); dcl 1 Pvte aligned like pvte parameter; dcl 1 dname aligned, 2 dev char (4) unaligned, 2 u char (1) unaligned, 2 num pic "99" unaligned, 2 sv char (1) unaligned; dname.dev = Pvte.devname; dname.u = "_"; dname.num = Pvte.logical_area_number; if Pvte.is_sv then dname.sv = valid_sv_array (Pvte.sv_num); else dname.sv = ""; return (string (dname)); end name; %page; %include disk_pack; %include flagbox; %include fs_vol_label; %include fs_dev_types; %include config_intk_card; %include pvte; %include stock_seg; %include syserr_constants; %page; /* BEGIN MESSAGE DOCUMENTATION Message: accept_rpv: pv PVNAME lv LVNAME (DSKX_NN) is not part of root. S: $crash T: $init M: The pack on the drive DSKX_NN, with pv name and lv name as read from its label, is specified on the ROOT CONFIG card, but is not part of the same logical volume as the RPV. A: Check the ROOT CONFIG card for errors. Check for the proper packs. Reboot the system. Message: accept_rpv: Error ERRORMESSAGE accepting RPV S: $crash T: $init M: Some problem was encountered trying to set up the use of the RPV for normal segment creation and activation. The label of the RPV may have been damaged, or encountered disk errors, as indicated by the ERRORMESSAGE. A: Make sure that the RPV label area (first eight records), or a dump of it, is available for system programmer inspection. $note Message: accept_rpv: HC part on dskX_NN used XXX out of YYY records. S: This message is printed on the console if an HCPT card is in the config deck. Otherwise, it is logged into the syserr_log. T: $init M: The message appears for each disk volume which contains a Hardcore Partition (PART HC). It indicates how many records were actually used (XXX) in the partition, which had size YYY. A: $ignore END MESSAGE DOCUMENTATION */ end accept_rpv;  create_root_dir.pl1 11/11/89 1108.3rew 11/11/89 0826.9 26703 /****^ *********************************************************** * * * Copyright, (C) Honeywell Bull Inc., 1987 * * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * *********************************************************** */ create_root_dir: procedure (Dp); dcl Dp ptr parameter; /* Written by C. Hornig, February 1982. */ dcl active_hardcore_data$alloc_sizes (2) fixed bin external; dcl active_hardcore_data$nalloc_sizes fixed bin external; dcl active_hardcore_data$cold_boot_switch bit (1) aligned external; dcl active_hardcore_data$dir_arearp fixed bin (18) external; dcl pvt$root_lvid bit (36) aligned external; dcl pvt$root_pvid bit (36) aligned external; dcl sys_info$default_dir_max_length fixed bin external; dcl allocate_dir_ht_ entry (ptr, fixed bin, fixed bin (35)); dcl fs_alloc$init entry (pointer, fixed bin, pointer, fixed bin); dcl lock$dir_lock_write entry (pointer, fixed bin (35)); dcl lock$dir_unlock entry (pointer); dcl syserr$error_code entry options (variable); dcl code fixed bin (35); %page; dp = Dp; dir.uid = "777777777777"b3; call lock$dir_lock_write (dp, code); /* Lock the root. */ if code ^= 0 then call syserr$error_code (1, code, "create_root_dir: lock error on ^p.", dp); active_hardcore_data$cold_boot_switch = "1"b; /* set flag indicating cold boot */ dir.pvid = pvt$root_pvid; /* get info left by init_pvt */ dir.sons_lvid = pvt$root_lvid; dir.master_dir = "1"b; /* The below calculations set the relative pointers in the directory structure. They are based on the assumption that directories have a max length of ROOT_MAX_SIZE and that the relative pointers in the directory have been set in active_hardcore_data. */ dir.arearp = bit (active_hardcore_data$dir_arearp, 18); call fs_alloc$init (pointer (dp, dir.arearp), (sys_info$default_dir_max_length - active_hardcore_data$dir_arearp), addr (active_hardcore_data$alloc_sizes), active_hardcore_data$nalloc_sizes); call allocate_dir_ht_ (dp, 0, code); if code ^= 0 then call syserr$error_code (1, code, "create_root_dir: allocating hash table"); call lock$dir_unlock (dp); /* Unlock the root */ return; %page; %include dir_header; %page; /* BEGIN MESSAGE DOCUMENTATION Message: create_root_dir: lock error on PPP S: $crash T: $init M: The supervisor was unable to lock the root. $err A: $recover $boot_tape Message: create_root_dir: allocating hash table ERROR_MESSAGE S: $crash T: Cold boot of Multics hierarchy. M: $err An error has occurred allocating the hash table for the root directory. A: Reboot with a different version of the system. END MESSAGE DOCUMENTATION */ end create_root_dir;  create_root_vtoce.pl1 11/11/89 1108.3r w 11/11/89 0826.9 47844 /****^ *********************************************************** * * * Copyright, (C) Honeywell Bull Inc., 1987 * * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * *********************************************************** */ create_root_vtoce: procedure; /* format: style4,indattr,ifthenstmt,ifthen,idind35,^indcomtxt */ /****^ HISTORY COMMENTS: 1) change(82-02-01,Hornig), approve(), audit(), install(): Written by C. Hornig. 2) change(84-11-01,Loepere), approve(), audit(), install(): Modified by Keith Loepere to update label when done. 3) change(86-02-01,Fawcett), approve(86-05-27,MCR7417), audit(86-08-18,Hartogs), install(86-08-19,MR12.0-1120): Modified to check for root vtoce not a zero. END HISTORY COMMENTS */ dcl pvt$root_pvid bit (36) aligned external; dcl pvt$root_pvtx fixed bin external; dcl pvt$root_vtocx fixed bin external; dcl sys_info$default_dir_max_length fixed bin external; dcl sys_info$time_of_bootload fixed bin (71) external; dcl dbm_man$set_incr entry (fixed bin, fixed bin, fixed bin (35)); dcl read_disk entry (fixed bin, fixed bin (17), ptr, fixed bin (35)); dcl syserr entry options (variable); dcl syserr$error_code entry options (variable); dcl vtoc_man$alloc_and_put_vtoce entry (bit (36) aligned, fixed bin, ptr, fixed bin (35)) returns (fixed bin); dcl write_disk entry (fixed bin, fixed bin (17), ptr, fixed bin (35)); dcl code fixed bin (35); dcl 1 local_label aligned like label; dcl 1 local_vtoce aligned like vtoce; dcl (addr, binary, bit, clock, divide, unspec) builtin; /* * * * * * * * * * CREATE_ROOT_VTOCE * * * * * * * * * */ unspec (local_vtoce) = ""b; local_vtoce.uid = "777777777777"b3; /* Fill in new VTOC entry */ local_vtoce.msl = bit (divide (sys_info$default_dir_max_length, 1024, 9, 0)); local_vtoce.csl = "0"b; local_vtoce.records = "0"b; local_vtoce.dtm, local_vtoce.dtu = bit (binary (sys_info$time_of_bootload, 52)); local_vtoce.nqsw = "1"b; /* The root's immune (saves nasty recursion) */ local_vtoce.dirsw = "1"b; local_vtoce.master_dir = "1"b; local_vtoce.quota (*) = binary ("777777"b3, 18); /* Biggest quota possible */ local_vtoce.used (*) = 0; local_vtoce.received (*) = 0; local_vtoce.trp (*) = 0; local_vtoce.trp_time (*) = local_vtoce.dtm; local_vtoce.primary_name = ">"; /* Fill in info for salvager */ local_vtoce.branch_rp = "0"b; local_vtoce.time_created = local_vtoce.dtm; local_vtoce.par_pvid = pvt$root_pvid; local_vtoce.par_vtocx = -1; local_vtoce.uid_path (*) = "0"b; local_vtoce.fm (*) = create_vtoce_null_addr; pvt$root_vtocx = vtoc_man$alloc_and_put_vtoce ("0"b, pvt$root_pvtx, addr (local_vtoce), code); if code ^= 0 then call syserr$error_code (SYSERR_CRASH_SYSTEM, code, "create_root_vtoce: Cannot alloc-write root VTOCE."); /* if the first free vtoce on rpv is not vtoc 0 then the cold boot was not preceeded by an rpv init_vol */ if pvt$root_vtocx ^= 0 then call syserr (SYSERR_CRASH_SYSTEM, "create_root_vtoce: Root vtoce not allocated at 0, RPV not initialized."); call read_disk (pvt$root_pvtx, LABEL_ADDR, addr (local_label), code); if code ^= 0 then go to RPV_error; local_label.root_vtocx = pvt$root_vtocx; local_label.time_registered = clock; call write_disk (pvt$root_pvtx, LABEL_ADDR, addr (local_label), code); if code ^= 0 then RPV_error: call syserr$error_code (SYSERR_CRASH_SYSTEM, code, "create_root_vtoce: Cannot set root_vtocx in RPV label."); call dbm_man$set_incr (pvt$root_pvtx, pvt$root_vtocx, code); if code ^= 0 then call syserr (SYSERR_PRINT_ON_CONSOLE, "create_root_vtoce: Cannot set dmpr bit map for root."); return; %page; %include disk_pack; %page; %include fs_vol_label; %page; %include null_addresses; %page; %include syserr_constants; %page; %include vtoce; %page; /* BEGIN MESSAGE DOCUMENTATION Message: create_root_vtoce: Cannot alloc-write root vtoce ERROR_MESSAGE S: $crash T: Cold boot of Multics hierarchy. M: The system is unable to write out the VTOC entry for the root directory. A: Correct the disk problem if one exists and reboot. Otherwise reboot with a different version of the system. Message: create_root_vtoce: Cannot set dmpr bit map for root ERROR_MESSAGE S: $info T: Cold boot of Multics hierarchy. M: $err A: $inform Message: create_root_vtoce: Cannot set root_vtocx in RPV label. S: $crash T: Cold boot of Multics hierarchy. M: The system is unable to update the RPV label for the root directory. A: Correct the disk problem if one exists and reboot. Otherwise reboot with a different version of the system. Message: create_root_vtoce: Root vtoce not allocated at 0, RPV not initialized. S: $crash T: Cold boot of Multics hierarchy. M: A boot -cold was attempted without init_vol for RPV. A: Reboot system answering the find_rpv_subsystem with cold instead of rpv. END MESSAGE DOCUMENTATION */ end create_root_vtoce;  dir_lock_init.pl1 11/11/89 1108.3rew 11/11/89 0826.9 28359 /****^ *********************************************************** * * * Copyright, (C) Honeywell Bull Inc., 1987 * * * * Copyright, (C) Honeywell Information Systems Inc., 1983 * * * *********************************************************** */ /* dir_lock_init.pl1 -- intialization (collection 2) of dir_lock_seg. */ /* format: style2 */ dir_lock_init: procedure; /* BIM 830212 */ /* Modified 831107 BIM for readers seperate from locks proper */ /* Modified 831111 BIM to remove threads. */ declare make_sdw$unthreaded entry (fixed binary (18), fixed binary (71), pointer, pointer); declare pmut$swap_sdw entry (ptr, ptr); declare syserr entry options (variable); declare dir_lock_seg_size fixed bin; declare n_dir_locks fixed bin; declare code fixed bin (35); declare tsdw fixed bin (71); declare ptp pointer; declare astep pointer; declare i fixed bin; declare slt$ external static; declare tc_data$max_max_eligible fixed bin (35, 18) external static; declare active_all_rings_data$max_tree_depth fixed bin external static; declare (addr, divide, segno, size) builtin; declare 1 local_dir_lock_header aligned like dir_lock_seg_header; dir_lock_segp = addr (local_dir_lock_header); dir_lock_seg.max_readers = tc_data$max_max_eligible; n_dir_locks, dir_lock_seg.n_dir_locks = tc_data$max_max_eligible * active_all_rings_data$max_tree_depth; dir_lock_seg_size = size (dir_lock_seg); /* auto header makes reference to size of dir_lock possible */ dir_lock_segp = addr (dir_lock_seg$); sltp = addr (slt$); sltep = addr (slt.seg (segno (dir_lock_segp))); slte_uns.abs_seg = "0"b; slte_uns.cur_length, slte_uns.max_length = divide (dir_lock_seg_size + 1023, 1024, 18, 0); call make_sdw$unthreaded (segno (dir_lock_segp), tsdw, astep, ptp); if astep = null () then call syserr (CRASH, "dir_lock_init: Cannot get ASTE for dir_lock_seg."); call pmut$swap_sdw (dir_lock_segp, addr (tsdw)); unspec (dir_lock_seg.header) = ""b; dir_lock_seg.n_dir_locks = n_dir_locks; dir_lock_seg.header.highest_in_use = 0; dir_lock_seg.header.max_readers = tc_data$max_max_eligible; dir_lock_seg.header.readers_ptr = addr (dir_lock_seg.readers); dir_lock_seg.header.locks_ptr = addr (dir_lock_seg.dir_locks); unspec (dir_lock_seg.dir_locks) = ""b; dir_lock_seg.readers (*, *) = ""b; unspec (dir_lock_seg.seg_lock.event) = unspec (DIR_LOCK_SEG_EVENT); return; /* format: off */ %page; %include slt; %page; %include slte; %page; %include dir_lock_seg_; %page; %include hc_lock; %page; %include syserr_constants; /* BEGIN MESSAGE DOCUMENTATION Message: dir_lock_init: cannot get ASTE for dir_lock_seg. S: $crash T: $init M: No space could be obtained for dir_lock_seg. This can result from inadequate ASTE pools or hardcore partition. A: $recover $boot_tape END MESSAGE DOCUMENTATION */ end dir_lock_init;  fnp_init.pl1 11/11/89 1108.3rew 11/11/89 0826.9 130302 /****^ *********************************************************** * * * Copyright, (C) BULL HN Information Systems Inc., 1989 * * * * 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. * * * *********************************************************** */ /****^ HISTORY COMMENTS: 1) change(88-06-14,Berno), approve(88-07-13,MCR7928), audit(88-06-14,Parisek), install(88-07-19,MR12.2-1061): Add support for the uncp multiplexer to implement the DSA gateway interface. 2) change(89-03-20,Parisek), approve(89-06-01,MCR8110), audit(89-10-09,Farley), install(89-10-25,MR12.3-1100): Add support of protocol mpx. END HISTORY COMMENTS */ /* format: style4,delnl,insnl,tree,ifthenstmt,indnoniterend */ fnp_init: procedure; /* FNP initialization for hardcore */ /* extracted from fnp_init on 5/11/76 by Robert S. Coren */ /* Modified 9/12/78 by J. Stern to initialize tty_buf, tty_area, and tty_tables */ /* Modified January 1980 by C. Hornig for MCM tracing */ /* Modified April 1981 by Chris Jones for io_manager conversion */ /* Modified February 1982 by C. Hornig for MR10 io_manager */ /* Modified November 1982 by Robert Coren to explicitly clear dn355_mailbox */ /* Modified 83-12-14 BIM to leave iom_manager assignment for FNP bootload time. */ /* Modified 84-07-09 MMP (and BIM) to insert model in prph fnp card. */ /* Modified 1984-07-30 BIM for paged mode IOM. */ /* Modified 1984-10-18 BIM to abs_wire tty_buf. *BLUSH!* */ /* Modified November 1984 by Robert Coren to initialize tty_area_lock.event. */ /* UNCP MPX */ /* Report modifications for the Datanet 7100, August 85 */ /**** NOTE: two undocumented parameters are checked here: dfnp turns on dn355_data.debug_stop, tfnp turns on dn533_data.trace. See the code of fnp_util and fnp_multiplexer to see what they do. */ dcl astep pointer; dcl i fixed bin; dcl j fixed bin; dcl bufsize fixed bin; dcl cptr ptr; dcl prot_ptr ptr; dcl p ptr; dcl tsdw fixed bin (71); dcl tty_area_size fixed bin (18); dcl code fixed bin (35); dcl cl fixed bin; dcl ptp pointer; dcl modelx fixed bin (17); dcl uncp_fnp_configured bit (1); dcl syserr entry options (variable); dcl syserr$error_code entry options (variable); dcl config_$find_2 entry (character (4) aligned, character (4) aligned, pointer); dcl config_$find_parm entry (char (*), ptr); dcl make_sdw$unthreaded entry (fixed bin (18), fixed bin (71), ptr, ptr); dcl pc_abs$wire_abs entry (ptr, fixed bin, fixed bin, fixed bin (35)); dcl pmut$swap_sdw entry (ptr, ptr); dcl get_fnp_name_ entry (fixed bin) returns (char (32)); dcl tty_space_man$get_perm_space entry (fixed bin, ptr); dcl slt$ external; dcl sys_info$page_size fixed bin external; dcl (addr, addrel, bin, currentsize, divide, empty, hbound, lbound, mod, null, pointer, ptr, rel, segno, size, string, substr, unspec) builtin; dcl 1 prot_parm aligned based (prot_ptr), 2 name char (4), 2 size fixed bin; dcl 1 tty_parm aligned based (cptr), 2 name char (4), 2 size fixed bin; dcl dn355_mailbox$ fixed bin ext; dcl 1 dn355mbx_array (max_no_355s) based (addr (dn355_mailbox$)) aligned, 2 actual_mbx (192) fixed bin (35); /* allow 300(8) per mbx */ dcl tty_area area (tty_area_size) based (addr (tty_area$)); dcl tty_area$ external; declare FNP_CONFIG_EVENT char (4) aligned init ("fnpc"); /* CONSTANTS */ dcl DEFAULT_BUFSIZE fixed bin int static options (constant) init (5120); dcl MAX_PROT_CHNLS fixed bin int static options (constant) init (128); dcl MIN_BUFSIZE fixed bin int static options (constant) init (256); dcl TTY_PERM_SPACE fixed bin int static options (constant) init (2048); dcl UNCP_CQ_SIZE fixed bin int static options (constant) init (2000); dcl EXPECTED_FIELDS fixed bin int static options (constant) init (5); dcl PAGE fixed bin int static options (constant) init (1024); dcl WORD15 fixed bin int static options (constant) init (15); dcl BIT36 fixed bin int static options (constant) init (36); dcl TRACE_INDEX bit (36) int static options (constant) init ("000000000001"b3); ttybp = addr (tty_buf$); /* get ptrs to tty_buf and dn355_data */ infop = addr (dn355_data$); /* allocate and setup tty_buf now. */ call config_$find_parm ("ttyb", cptr); /* get ptr to ttyb parameter */ if cptr = null then bufsize = DEFAULT_BUFSIZE; /* default size of tty_buf is 5K */ else bufsize = tty_parm.size; /* unless TTYB nnnn was given */ sltp = addr (slt$); sltep = addr (slt.seg (segno (ttybp))); cl = divide (bufsize + sys_info$page_size - 1, sys_info$page_size, 18, 0); slte_uns.bit_count = cl * BIT36 * PAGE; slte_uns.max_length, slte_uns.cur_length = cl; slte_uns.wired = "0"b; /* make_sdw will not wire the right way */ call make_sdw$unthreaded (segno (ttybp), tsdw, astep, ptp); call pc_abs$wire_abs (astep, 0, cl, code); if code ^= 0 then call syserr$error_code (CRASH, code, "fnp_init: Unable to abs_wire tty_buf."); call pmut$swap_sdw (ttybp, addr (tsdw)); /* swap in the sdw setup by get_main */ begin; declare tty_buf_pages (slte_uns.cur_length, 1024) bit (36) aligned based (ttybp); tty_buf_pages = ""b; end; tty_buf.absorig = sys_info$page_size * FIRST_TTY_BUF_PAGEX; /* origin in IO segment */ tty_buf.lct_ptr = null; p = addr (tty_buf.free_space); /* get ptr to start of free space */ /**** tty_buf is not at location 0 of the I/O segment */ i = bin (rel (p), 18); /* mod pointer to next 16 words */ string (tty_buf.trace) = ""b; call config_$find_parm ("ttyt", cptr); /* need a trace table be allocated */ if cptr ^= null () then do; i = i + mod (i, 2); /* must be at even word */ trace_array_ptr = pointer (ttybp, i); trace_array.num_entries = tty_parm.size; trace_array.idx = TRACE_INDEX; tty_buf.trace.data_offset = rel (trace_array_ptr); i = bin (rel (addrel (trace_array_ptr, currentsize (trace_array)))); end; i = i + WORD15; i = i - mod (i, WORD15+1); p = ptr (p, i); tty_buf.borig, tty_buf.free = rel (p); /* free list of blocks starts here */ tty_buf.bleft = bufsize - bin (tty_buf.borig); if tty_buf.bleft < MIN_BUFSIZE then call syserr (CRASH, "fnp_init: Less than 256 words of free space in tty_buf: ^d", tty_buf.bleft); free_blockp = p; free_block.next = "0"b; /* one block */ free_block.size = tty_buf.bleft; tty_buf.tty_area_lock.event = TTY_AREA_LOCK_EVENT; /* initialize tty_area */ tty_area_size = get_seg_size (addr (tty_area$)); tty_area = empty (); /* initialize tty_tables segment */ ttytp = addr (tty_tables$); tty_tables_hdr.event = tty_ev; /* init wait event for tty_tables lock */ tty_tables_hdr.table_area_size = get_seg_size (ttytp) - currentsize (tty_tables_hdr); tty_tables_hdr.table_area = empty (); /* init table area */ /* search for protocol "prot" parameter in the config deck then do allocation/initialization of protocol_data if one is found */ call config_$find_parm ("prot", prot_ptr); /* get ptr to PROT parameter */ if prot_ptr = null /* site not running "protocol_mpx" software */ then datanet_info.protocol_datap = null; else do; if prot_parm.size > MAX_PROT_CHNLS then call syserr (CRASH, "fnp_init: The number of configured protocol channels of ^d^/^-exceeds the maximum allowed of ^d.", prot_parm.size, MAX_PROT_CHNLS); else protocol_channels = prot_parm.size; call tty_space_man$get_perm_space (size (protocol_data), protocol_data_ptr); protocol_data.max_channels = protocol_channels; datanet_info.protocol_datap = protocol_data_ptr; end; /* read FNP cards and do init */ tty_buf.fnp_config_flags (*) = "0"b; /* start with no fnps configured */ datanet_info.configuration_lock.pid = ""b; datanet_info.configuration_lock.event = unspec (FNP_CONFIG_EVENT); datanet_info.configuration_lock.flags = "0"b; uncp_fnp_configured = "0"b; do i = 1 to max_no_355s; /* set up la indices */ fnpp = addr (datanet_info.per_datanet (i)); fnp_info.mbx_pt = null; /* start null */ fnp_info.lcte_ptr = null; do j = lbound(fnp_info.lsla_idx, 1) to hbound(fnp_info.lsla_idx, 1); /* initialize HSLA/LSLA indices */ if j <= hbound(fnp_info.hsla_idx, 1) then fnp_info.hsla_idx (j) = -1; fnp_info.lsla_idx (j) = -1; end; mbxp = addr (dn355mbx_array (i)); /* get addr of this mbx */ unspec (datanet_mbx) = ""b; /* make sure whole mailbox starts out 0 */ prph_fnp_cardp = null (); call config_$find_2 ("prph", "fnp" || substr (get_fnp_name_ (i), 1, 1), prph_fnp_cardp); if prph_fnp_cardp ^= null () then do; if prph_fnp_card.n_fields ^= EXPECTED_FIELDS | (prph_fnp_card.field_type (5) ^= CONFIG_STRING_TYPE) | (prph_fnp_card.state ^= "on" & prph_fnp_card.state ^= "off") then call syserr (CRASH, "fnp_init: Invalid state on prph ^a card.", prph_fnp_card.name); do modelx = 1 to hbound (fnp_models, 1) while (prph_fnp_card.model ^= fnp_models (modelx)); end; if modelx > hbound (fnp_models, 1) | ^supported_fnp (modelx) then call syserr (CRASH, "fnp_init: Invalid model # (^d) on prph ^a card.", prph_fnp_card.model, prph_fnp_card.name); if modelx = DN7100 then uncp_fnp_configured = "1"b; fnpp = addr (datanet_info.per_datanet (i)); tty_buf.fnp_config_flags (i) = "1"b; /* its in the config deck */ fnp_info.available = prph_fnp_card.state = "on"; fnp_info.mbx_pt = mbxp; /* place ptr to mbx in per dn slot */ fnp_info.fnp_number = i; fnp_info.fnp_tag = substr (get_fnp_name_ (i), 1, 1); fnp_info.ptx = -1; /* not yet known */ fnp_info.ptp = null (); /* don't allocate until/unless loaded */ datanet_info.no_of_355s = datanet_info.no_of_355s + 1; call io_chnl_util$iom_to_name (prph_fnp_card.iom, (prph_fnp_card.chan), fnp_info.io_chanid, code); if code ^= 0 then call syserr (CRASH, "fnp_init: code ^o from io_chnl_util$iom_to_name.", code); /* something wrong here... */ end; end; if datanet_info.no_of_355s = 0 then call syserr (ANNOUNCE, "fnp_init: Warning: no FNP's configured."); /* Add for the Datanet 7100. */ if uncp_fnp_configured then do; call tty_space_man$get_perm_space (TTY_PERM_SPACE, datanet_info.uncp_bufp); uncpbp = datanet_info.uncp_bufp; uncp_buf.cq_max_size = UNCP_CQ_SIZE; uncp_buf.cq_free = uncp_buf.cq_max_size; /* Start of the free space */ uncp_buf.cq_hbound = uncp_buf.cq_max_size - 1; /* The circular queue is a table (0:cq_max_size - 1) */ end; else datanet_info.uncp_bufp = null (); cptr = null (); call config_$find_parm ("tfnp", cptr); datanet_info.trace = (cptr ^= null ()); cptr = null (); call config_$find_parm ("dfnp", cptr); datanet_info.debug_stop = (cptr ^= null ()); return; %page; get_seg_size: proc (segp) returns (fixed bin (18)); /* gets segment sizes from the slt */ dcl segp ptr; /* ptr to seg whose size is wanted */ dcl seg_no fixed bin (18); seg_no = segno (segp); sltp = addr (slt$); sltep = addr (slt.seg (seg_no)); return (slte_uns.max_length * sys_info$page_size); end get_seg_size; %page; %include tty_buf; %include uncp_buf; %include mcs_trace_data; %include tty_buffer_block; %include tty_tables; %include config_deck; %include config_prph_fnp_card; %include dn355_data; %include slt; %include slte; %include syserr_constants; %include dn355_mailbox; %include io_chnl_util_dcls; %include fnp_types; %include protocol_data; %page; /* BEGIN MESSAGE DOCUMENTATION Message: fnp_init: Less than 256 words of free space in tty_buf: N S: $crash T: $init M: Only N words of free space remain in tty_buf after allocating the header and circular queue. A minimum of 256 words is required and ordinarily more free space is desirable. Either the size of tty_buf, as specified by the PARM TTYB config card, must be increased or the circular queue size, as specified by the PARM TTYQ config card, must be decreased. A: Correct the config deck and reboot the system. Message: fnp_init: no fnp cards in config deck S: $info T: $init M: There are no fnp cards in the config deck and therefore, no FNP will be initialized. Usually this indicates an error, although it is possible to run Multics without an FNP. A: If an FNP is wanted, reboot the system with an appropriate config deck. Message: fnp_init: FNP number N > max allowed number (MAX) of FNPs S: $crash T: $init M: An fnp card from the config deck specifies an FNP tag other than A, B, C, D, E, F, G, or H. A: Replace the bad fnp card and reboot. Message: fnp_init: inconsistent fnp cards. S: $crash T: $init M: Two or more fnp cards from the config deck specify the same FNP tag. A: Replace or remove the bad fnp card(s) and reboot. Message: fnp_init: Unable to abs_wire tty_buf. ERROR_CODE_MESSAGE S: $crash T: $init M: The call to allocate memory in the bootload memory controller for tty_buf failed. A: $contact Message: fnp_init: Invalid state on prph fnpX card. S: $crash T: $init M: The only valid states are "on" or "off". A: $contact Message: fnp_init: Invalid model # (MODELN) on prph fnpX card. S: $crash T: $init M: The current fnp model number MODELN, is not a supported number. A: $contact Message: fnp_init: The number of configured protocol channels of N exceeds the maximum allowed of N. S: $crash T: $init M: The prot parm from the config deck specifies too many protocol channels. A: $contact END MESSAGE DOCUMENTATION */ end fnp_init;  init_dm_journal_seg.pl1 11/11/89 1108.3rew 11/11/89 0826.9 39573 /****^ *********************************************************** * * * Copyright, (C) Honeywell Bull Inc., 1987 * * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * *********************************************************** */ /* format: style3 */ init_dm_journal_seg: proc; /* Program to initialize the Page Control data base dm_journal_seg_ Written October 1982 by J. Bongiovanni Modified January 1983 by J. Bongiovanni to call make_sdw instead of get_main */ /* Automatic */ dcl dm_journal_astep ptr; dcl dm_journal_segno fixed bin (18); dcl journalx fixed bin; dcl pagex fixed bin; dcl seg_pages fixed bin; dcl sx fixed bin; dcl tsdw fixed bin (71); /* Static */ dcl DBMJ_CARD_FIELDS fixed bin internal static options (constant) init (6); dcl JOURNAL_WAIT_EVENT bit (36) aligned internal static options (constant) init ("666000000000"b3); /* External */ dcl slt$ external; dcl sst$dm_enabled bit (1) aligned external static; dcl 1 sst$level (0:3) aligned external, 2 ausedp bit (18) unaligned, 2 no_aste fixed bin (18) unsigned unaligned; dcl sst$nused fixed bin (19) external static; dcl tc_data$end_of_time fixed bin (71) external static; /* Entry */ dcl config$find entry (char (4) aligned, ptr); dcl make_sdw entry (fixed bin (18), fixed bin (71), ptr, ptr); dcl pmut$swap_sdw entry (ptr, ptr); dcl syserr entry options (variable); /* Builtin */ dcl addr builtin; dcl divide builtin; dcl null builtin; dcl rel builtin; dcl size builtin; %page; /* Parse DBMJ config card, if there is one */ dbmj_cardp = null (); call config$find (DBMJ_CARD_WORD, dbmj_cardp); if dbmj_cardp = null () then return; if dbmj_card.type_word.n_fields ^= DBMJ_CARD_FIELDS then do; BAD_DBMJ_CARD: call syserr (CRASH, "init_dm_journal_seg: Invalid DBMJ config card."); end; else do; if (dbmj_card.n_journals <= 0) | (dbmj_card.max_held_pages <= 0) then goto BAD_DBMJ_CARD; do sx = lbound (dbmj_card.per_aste_pool, 1) to hbound (dbmj_card.per_aste_pool, 1); if sst$level (sx).no_aste <= dbmj_card.per_aste_pool (sx) then goto BAD_DBMJ_CARD; end; n_dm_journals = dbmj_card.n_journals; max_dm_pages = dbmj_card.max_held_pages; end; /* Get memory for dm_journal_seg_ */ dm_journal_segp = addr (dm_journal_seg_$); seg_pages = divide (size (dm_journal) + 1023, 1024, 17); dm_journal_segno = bin (baseno (dm_journal_segp)); sltp = addr (slt$); sltep = addr (slt.seg (dm_journal_segno)); slte_uns.cur_length = seg_pages; slte.wired = "1"b; call make_sdw (dm_journal_segno, tsdw, dm_journal_astep, (null ())); if dm_journal_astep = null () then call syserr (CRASH, "init_dm_journal_seg: make_sdw failed for dm_journal_seg_"); call pmut$swap_sdw (dm_journal_segp, addr (tsdw)); /* Initialize dm_journal_seg_ */ dm_journal.n_journals = n_dm_journals; dm_journal.max_held_pages_mem = max_dm_pages; dm_journal.per_aste_pool (*).threshold = dbmj_card.per_aste_pool (*); dm_journal.free_list_relp = rel (addr (dm_journal.page_entry)); dm_journal.wait_event = JOURNAL_WAIT_EVENT; do journalx = 1 to n_dm_journals; dm_journal.per_journal (journalx).time_stamp = tc_data$end_of_time; end; do pagex = 1 to max_dm_pages - 1; dm_journal.page_entry (pagex).fp = rel (addr (dm_journal.page_entry (pagex + 1))); end; sst$dm_enabled = "1"b; return; /* format: off */ %page; %include config_dbmj_card; %page; %include dm_journal_seg_; %page; %include slt; %page; %include slte; %page; %include syserr_constants; %page; /* BEGIN MESSAGE DOCUMENTATION Message: init_dm_journal_seg: Invalid DBMJ config card. S: $crash T: $init M: The DBMJ configuration card is not in proper format. This could be a format error, or one of the following criteria may not be satisfied. The limit on active segments for a pool must be smaller than the pool size. A: Correct the configuration deck and reboot. Message: init_dm_journal_seg: make_sdw failed for dm_journal_seg_ S: $crash T: $init M: The ASTE for dm_journal_seg_ could not be created. A: $contact END MESSAGE DOCUMENTATION */ end init_dm_journal_seg;  init_hardcore_gates.pl1 11/11/89 1108.3rew 11/11/89 0826.9 50139 /****^ *********************************************************** * * * Copyright, (C) Honeywell Bull Inc., 1987 * * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * *********************************************************** */ /* INIT_HARDCORE_GATES - Initialize all gates into the hardcore ring. */ /* This program is called to set up the linkage pointers stored in all hardcore gates. The only reason is efficiency, i.e. to make normal execution thru the gate faster. The program also sets up the entry bounds (call limiters) within the SDWs for the hardcore gates. Ring brackets are also put in the hardcore descriptors for restart_fault and return_to_ring_0_. */ /****^ HISTORY COMMENTS: 1) change(77-06-01,Morris), approve(), audit(), install(): Library maintenance installation. Rewritten to determine hardcore gates automatically from ring brackets in the SLT. 6/77 by Noel I. Morris END HISTORY COMMENTS */ /* ****************************************************** * * * * * Copyright (c) 1972 by Massachusetts Institute of * * Technology and Honeywell Information Systems, Inc. * * * * * ****************************************************** */ init_hardcore_gates: proc; dcl tsdw fixed bin (71), /* temporary for SDW */ segno fixed bin (18), /* gate segment number */ segp ptr, /* pointer to gate segment */ lp ptr, /* pointer to gate's linkage */ dp ptr, /* pointer to gate's definitions */ lp_ptr ptr, /* pointer to linkage pointer within gate */ tv_ptr ptr; /* pointer to call limiter within gate */ dcl based_ptr ptr based, /* based pointer */ tv_end bit (14) aligned based; /* based call limiter value */ dcl 1 segname_acc aligned, (2 l fixed bin (8), 2 s char (31)) unal; dcl 1 my_lp_acc static aligned options (constant), (2 l fixed bin (8) init (6), 2 s char (6) init (".my_lp")) unal; dcl 1 tv_end_acc static aligned options (constant), (2 l fixed bin (8) init (7), 2 s char (7) init (".tv_end")) unal; dcl lot$ (0: 1023) ptr unaligned ext, dseg$ (0: 1) fixed bin (71) ext, slt$ ext, restart_fault$ ext, return_to_ring_0_$ ext; dcl pmut$swap_sdw entry (ptr, ptr), get_defptr_ entry (ptr, ptr, ptr, ptr, fixed bin (35)); dcl (addr, baseno, baseptr, bin, length, ptr, rtrim, substr, unspec) builtin; % include sdw; % include slt; % include slte; % include definition; sltp = addr (slt$); /* Get ptr to slt */ sdwp = addr (tsdw); /* and pointer to temporary SDW */ do segno = slt.first_sup_seg to slt.last_sup_seg; /* Iterate through all supervisor segments. */ sltep = addr (slt.seg (segno)); /* Get pointer to SLT entry. */ if slte.ringbrack (3) ^= "0"b3 & /* If a hardcore gate ... */ slte.ringbrack (2) = "0"b3 & slte.ringbrack (1) = "0"b3 then do; segp = baseptr (segno); /* Get pointer to base of segment. */ lp = lot$ (segno); /* Get pointer to linkage for gate. */ dp = lp -> based_ptr; /* Get pointer to definitions. */ namep = ptr (slt.name_seg_ptr, slte.names_ptr); /* Get name of segment. */ unspec (segname_acc) = "0"b; /* Clear name ACC string. */ segname_acc.l = length (rtrim (segnam.names (1).name)); substr (segname_acc.s, 1, length (rtrim (segnam.names (1).name))) = segnam.names (1).name; lp_ptr = getadr (addr (my_lp_acc)); /* Get pointer to lp to be filled in. */ tv_ptr = getadr (addr (tv_end_acc)); /* Get pointer to call limiter. */ tsdw = dseg$ (segno); /* Grab the SDW for segment. */ sdw.write = "1"b; /* Give write access. */ call pmut$swap_sdw (segp, sdwp); lp_ptr -> based_ptr = lp; /* Set linkage pointer in segment. */ sdw.entry_bound_sw = "0"b; /* Enable call limiter. */ sdw.entry_bound = tv_ptr -> tv_end; /* Set call limiter. */ sdw.write = "0"b; /* Take away write access. */ call pmut$swap_sdw (segp, sdwp); /* Insert new SDW in descriptor segment. */ end; end; /* Now set the ringbrackets in the SDWs for restart_fault and return_to_ring_0_. */ call set_sdw (addr (restart_fault$)); /* Set ring brackets and put in dseg */ call set_sdw (addr (return_to_ring_0_$)); return; set_sdw: procedure (segptr); /* This procedure inserts ring brackets from the SLT into hardcore descriptors */ dcl segptr ptr; segno = bin (baseno (segptr), 18); /* Get number of segment. */ sltep = addr (slt.seg (segno)); /* access SLT entry */ tsdw = dseg$ (segno); /* grab the SDW */ sdwp -> sdw.r1 = slte.ringbrack (1); /* copy ring brackets */ sdwp -> sdw.r2 = slte.ringbrack (2); sdwp -> sdw.r3 = slte.ringbrack (3); call pmut$swap_sdw (segptr, sdwp); /* actually place SDW */ end set_sdw; getadr: proc (accp) returns (ptr); /* procedure to search for definition symbol */ dcl accp ptr; dcl defsp ptr, code fixed bin (35); call get_defptr_ (dp, addr (segname_acc), accp, defsp, code); return (ptr (segp, defsp -> definition.value)); end getadr; end;  init_lvt.pl1 11/11/89 1108.3r w 11/11/89 0826.9 23256 /****^ *********************************************************** * * * 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. * * * *********************************************************** */ init_lvt: proc (); /****^ HISTORY COMMENTS: 1) change(76-02-17,Bratt), approve(), audit(), install(): Modified March 1982 by J. Bongiovanni to eliminate use of FSDCT This module initializes the lvt and defines the RLV as containing the RPV which is assumed to be already accepted. END HISTORY COMMENTS */ dcl 1 local_label like label aligned; dcl 1 local_lvte like lvte aligned; dcl code fixed bin (35); dcl pvt$root_pvtx fixed bin external; dcl pvt$root_lvid bit (36) aligned external; dcl read_disk entry (fixed bin, fixed bin, ptr, fixed bin (35)); dcl logical_volume_manager$add entry (ptr, fixed bin (35)); dcl syserr entry options (variable); /* initialize lvt */ lvtp = addr (lvt$); lvt.max_lvtex = 50; lvt.high_water_lvtex = 0; lvt.free_lvtep = null (); lvt.ht (*) = null (); /* get RLV together */ call read_disk (pvt$root_pvtx, LABEL_ADDR, addr (local_label), code); if code ^= 0 then call syserr (1, "init_lvt: unable to read RPV label, code = ^o", code); local_lvte.lvid = pvt$root_lvid; local_lvte.access_class.min = local_label.min_access_class; local_lvte.access_class.max = local_label.max_access_class; unspec (local_lvte.flags) = (36)"0"b; local_lvte.flags.public = "1"b; call logical_volume_manager$add (addr (local_lvte), code); if code ^= 0 then call syserr (1, "init_lvt: unable to define RLV, code = ^o", code); return; /* */ %include fs_vol_label; /* */ %include disk_pack; /* */ %include lvt; /* BEGIN MESSAGE DOCUMENTATION Message: init_lvt: unable to read RPV label, code = WWWW S: $crash T: $init M: The RPV label, which was successfully read a few seconds ago, cannot be read. A: $recover $boot_tape Message: init_lvt: unable to define RLV, code = WWWW S: $crash T: $init M: $err A: $recover $boot_tape END MESSAGE DOCUMENTATION */ end init_lvt;  init_root_dir.pl1 11/11/89 1108.3r w 11/11/89 0826.9 48609 /****^ *********************************************************** * * * Copyright, (C) Honeywell Bull Inc., 1987 * * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * *********************************************************** */ init_root_dir: procedure; /* USAGE: call init_root_dir; NOTES: Called during system initialization "init_root_dir" creates and initializes the root directory if the system is being cold booted. Various directory variables are set/preset such as the root id and all self referencing pointers. If the system is being warm booted these variables are not reset. In either case the root directory is made known to the initializer process. modified 4/75 for NSS by THVV modified 8/76 for variable size hash tables by S.E. Barr Modified by D. Vinograd 6/76 to set volume dumper bit map Modified 4/77 by M. Weaver to replace makeknown with makeknown_ Modified 18 Feb 79 by D. Spector to extend root quota from 17 to 18 bits Modified February 1982 by C. Hornig to salvage root when necessary Modified March 1982 by J. Bongiovanni to eliminate use of FSDCT Modified October 1984 by K. Loepere for explicit activation of root. */ dcl vtocx fixed bin; dcl pvtx fixed bin; dcl segno fixed bin; dcl code fixed bin (35); dcl cold bit (1) aligned; dcl pvt$rlv_needs_salv bit (1) aligned external; dcl pvt$root_pvtx fixed bin external; dcl pvt$root_vtocx fixed bin external; dcl sst$root_astep ptr external; dcl ROOT_UID bit (36) int static options (constant) init ((36)"1"b); dcl (addr, baseptr, binary, null, unspec) builtin; dcl create_root_dir entry (ptr); dcl create_root_vtoce entry; dcl find entry (char (*), ptr); dcl get_aste entry (fixed bin (9)) returns (ptr); dcl initialize_kst entry (); dcl makeknown_ entry (ptr, fixed bin, fixed bin, fixed bin (35)); dcl pathname_am$initialize entry (); dcl pc$fill_page_table entry (ptr, ptr, fixed bin (9)); dcl salvager$dir_salv_boot entry (char (*)); dcl search_ast$hash_in entry (ptr); dcl syserr entry options (variable); dcl syserr$error_code entry options (variable); dcl vtoc_man$get_vtoce entry (bit (36) aligned, fixed bin, fixed bin, bit (3), ptr, fixed bin (35)); dcl 1 mk_info aligned like makeknown_info; dcl 1 local_vtoce like vtoce aligned; %page; intk_cardp = null (); call find ("intk", intk_cardp); /* see if hierarchy is intact */ cold = (intk_card.warm_or_cold = "cold"); if cold then call create_root_vtoce; /* Create the root */ pvtx = pvt$root_pvtx; /* Find the pack where the root is */ vtocx = pvt$root_vtocx; /* CONVENTION: root vtocx always 0 */ vtocep = addr (local_vtoce); call vtoc_man$get_vtoce ("0"b, pvtx, vtocx, "111"b, vtocep, code); if code ^= 0 then call syserr$error_code (1, code, "init_root_dir: Error on root vtoce"); sst$root_astep, astep = get_aste (64); /* Obtain proper VTOC entry */ aste.msl = vtoce.msl; /* and activate the ROOT */ aste.vtocx = vtocx; aste.pvtx = pvtx; aste.usedf, aste.gtus, aste.gtms, aste.nqsw, aste.dirsw, aste.master_dir, aste.ehs, aste.gtpd, aste.dnzp = "1"b; aste.dtu = vtoce.dtu; aste.dtm = vtoce.dtm; aste.csl = vtoce.csl; aste.records = vtoce.records; aste.quota (*) = vtoce.quota (*); aste.used (*) = vtoce.used (*); aste.tqsw (*) = "1"b; call pc$fill_page_table (astep, addr (vtoce.fm), binary (aste.csl, 9)); aste.uid = ROOT_UID; call search_ast$hash_in (astep); /* Set up Initializer's KST. Must be done after sys_info is initialized & before call to makeknown. */ call initialize_kst; call pathname_am$initialize; unspec (mk_info) = "0"b; mk_info.uid = ROOT_UID; mk_info.entryp = null (); mk_info.dirsw = "1"b; mk_info.allow_write = "1"b; mk_info.activate = "1"b; call makeknown_ (addr (mk_info), segno, (0), code); if code ^= 0 then call syserr$error_code (1, code, "init_root_dir: Error from makeknown on root."); dp = baseptr (segno); /* If this is a cold boot, set up the root directory. Code assumes new pages are zero. */ if cold then call create_root_dir (dp); if dir.uid ^= ROOT_UID then call syserr (1, "init_root_dir: Root damaged."); if pvt$rlv_needs_salv | (dir.uid ^= ROOT_UID) | (dir.modify ^= ""b) then call salvager$dir_salv_boot (">"); return; %page; %include aste; %include config_intk_card; %include dir_header; %include makeknown_info; %include vtoce; %page; /* BEGIN MESSAGE DOCUMENTATION Message: init_root_dir: Error on root vtoce ERROR_MESSAGE S: $crash T: $init M: The supervisor cannot locate the VTOC entry for the root directory. The RPV may have been damaged. A: $recover A recovery of the RPV may be required. Message: init_root_dir: Error from makeknown on root ERROR_MESSAGE S: $crash T: $init M: $err A: Reboot with a different version of the system. Message: init_root_dir: Root damaged. S: $crash T: $init M: The unique ID of the root directory in the directory header is incorrect. The contents of the RPV may have been damaged. A: $recover A recovery of the RPV may be required. END MESSAGE DOCUMENTATION */ end init_root_dir;  init_scavenger_data.pl1 11/11/89 1108.3r w 11/11/89 0826.9 41985 /****^ *********************************************************** * * * Copyright, (C) Honeywell Bull Inc., 1987 * * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * *********************************************************** */ /****^ HISTORY COMMENTS: 1) change(86-01-15,Fawcett), approve(86-04-11,MCR7383), audit(86-05-21,Coppola), install(86-07-17,MR12.0-1097): Add subvolume support. END HISTORY COMMENTS */ /* format: style3 */ init_scavenger_data: proc; /* Program to initialize scavenger_data. The number of processes allowed to scavenge simultaneously is based on the size of scavenger_data, which may be changed by a TBLS SCAV card. Written July 1982 by J. Bongiovanni Modified November 1982 by J. Bongiovanni for static process memory assignment */ /* Automatic */ dcl first_free_page fixed bin; dcl max_rec_per_sv fixed bin; dcl n_free_pages fixed bin; dcl pages_per_process fixed bin; dcl processx fixed bin; dcl pvtx fixed bin; dcl sc_data_pages fixed bin; dcl sc_data_words fixed bin (19); /* Static */ dcl N_OVFL fixed bin int static options (constant) init (1023); dcl N_OVERHEAD_PAGES fixed bin int static options (constant) init (1); dcl SCAVENGER_WAIT_EVENT bit (36) aligned int static options (constant) init ("555000000000"b3); /* External */ dcl dseg$ (0:1023) fixed bin (71) external; /* Entry */ dcl sdw_util_$get_size entry (ptr, fixed bin (19)); dcl syserr entry options (variable); /* Builtin */ dcl addr builtin; dcl baseno builtin; dcl bin builtin; dcl divide builtin; dcl hbound builtin; dcl lbound builtin; dcl rel builtin; dcl size builtin; %page; max_rec_per_sv = 0; pvt_arrayp = addr(pvt$array); /* set the max record number for the largest device configured */ do pvtx = lbound (pvt_array, 1) to hbound (pvt_array, 1); pvtep = addr(pvt_array(pvtx)); if rec_per_sv (pvte.device_type) > max_rec_per_sv then max_rec_per_sv = rec_per_sv (pvte.device_type); end; scavenger_n_records = max_rec_per_sv; scavenger_n_ovfl = N_OVFL; pages_per_process = divide (size (scavenger_block) + 1023, 1024, 17); scavenger_datap = addr (scavenger_data$); call sdw_util_$get_size (addr (dseg$ (bin (baseno (scavenger_datap)))), sc_data_words); sc_data_pages = divide (sc_data_words, 1024, 17); scavenger_data.lock.wait_event = SCAVENGER_WAIT_EVENT; sc_n_processes = divide (sc_data_pages - N_OVERHEAD_PAGES, pages_per_process, 17); /* Assume header is 1 page */ if sc_n_processes < 1 then call syserr (CRASH, "init_scavenger_data: scavenger_data is too small."); sc_process_tablep = addr (scavenger_data.free); scavenger_data.process_table_ptr = sc_process_tablep; sc_process_table.max_n_processes = sc_n_processes; first_free_page = divide (bin (rel (addr (scavenger_data.free))) + size (sc_process_table) + 1023, 1024, 17); n_free_pages = sc_data_pages - first_free_page + 1; if first_free_page > N_OVERHEAD_PAGES then call syserr (CRASH, "init_scavenger_data: scavenger_data inconsistency."); do processx = 1 to sc_n_processes; sc_process_table.process (processx).blockp = addr (scavenger_data_pages.page (first_free_page)); sc_process_table.process (processx).first_block_page = first_free_page; first_free_page = first_free_page + pages_per_process; n_free_pages = n_free_pages - pages_per_process; if n_free_pages < 0 then call syserr (CRASH, "init_scavenger_data: scavenger_data inconsistency."); end; scavenger_data.error_severity = ANNOUNCE; return; /* format: off */ %page; %include fs_dev_types; %page; %include pvte; %page; %include scavenger_data; %page; %include syserr_constants; %page; /* BEGIN MESSAGE DOCUMENTATION Message: init_scavenger_data: scavenger_data too small. S: $crash T: $init M: The size of the scavenger_data segment is too small. It can be increased by the TBLS SCAV config card. It must be at least 68KW, with an additional 67KW for each additional process (beyond 1) which is to be scavenging simultaneously. A: Correct the configuration deck and reboot. Message: init_scavenger_data: scavenger_data inconsistency. T: $init S: $crash M: An error was encountered initializing the scavenger's data base. A: $contact END MESSAGE DOCUMENTATION */ end init_scavenger_data;  init_sst_name_seg.pl1 11/11/89 1108.3rew 11/11/89 0826.9 33030 /****^ *********************************************************** * * * 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. * * * *********************************************************** */ init_sst_name_seg: procedure; /* This procedure is called by initialization to set up the names of the hardcore segments in the SST name table, if selected via the DEBG card. The SLT is scanned, and the names of all segments who are IN FACT (not necessarily in the SLT) paged are placed in the SST name table. This must be done before the first seg_fault to tell BOS of the validity of this segment. Last Modified and Reason: Coded by Bernard Greenberg, 10/10/74 Modified 03/21/81, W. Olin Sibert, for ADP PTWs and get_ptrs_$given_sdw Modified 9/83, Keith Loepere for paged, wired segs. Modified 8/84, Keith Loepere to rename sstnt.multics_or_bos. */ dcl slt$ external static; dcl sst_seg$ external static; dcl dseg$ (0:1023) fixed bin (71) external static; dcl sst$ast_track bit (1) aligned external static; dcl sst$pts (0:3) fixed bin external static; dcl unpaged_page_tables$ external static; dcl get_ptrs_$given_sdw entry (pointer) returns (pointer); dcl sdw_util_$dissect entry (pointer, pointer); dcl (pts, ptsi, segnum, segnam_size) fixed bin; dcl 1 sdwi aligned like sdw_info aligned automatic; dcl (addr, bin, divide, ptr, rel, reverse, segno, substr, verify) builtin; if ^sst$ast_track then return; /* No work called for */ sstnp = addr (sst_names_$); /* get ptr to SLT's name table seg */ sltp = addr (slt$); /* and the current 'name table */ names_ptr = sltp -> slt.name_seg_ptr; /* Get SLT name seg ptr. */ sstnp -> sstnt.valid = "1"b; /* Signify to BOS not to fill in */ sstnp -> sstnt.multics_or_bce = "mult"; upt_ptr = addr (unpaged_page_tables$); do segnum = sltp -> slt.first_sup_seg to sltp -> slt.last_sup_seg, sltp -> slt.first_init_seg to sltp -> slt.last_init_seg; sltep = addr (sltp -> slt.seg (segnum)); /* get ptr to SLTE of segment */ namep = ptr (names_ptr, sltep -> slte.names_ptr); /* get ptr to seg name block */ call sdw_util_$dissect (addr (dseg$ (segnum)), addr (sdwi)); if ^sdwi.faulted & sdwi.paged & (upt.sst_absloc <= sdwi.address & sdwi.address <= upt.sst_last_loc) then do; /* process segs with page tables in sst */ astep = get_ptrs_$given_sdw (addr (dseg$ (segnum))); /* Get the AST entry ptr */ ptsi = bin (astep -> aste.ptsi, 3);/* get pt size index from ASTE */ pts = sst$pts (ptsi); /* and real Page Table size. */ segnam_size = 32 - verify (reverse (namep -> segnam.name (1)), " ") + 1; sstnp -> sstnt.names (divide (bin (rel (astep), 18) - sstnp -> sstnt.ast_offsets (ptsi), sstnp -> sstnt.ast_sizes (ptsi), 17, 0) + sstnp -> sstnt.ast_name_offsets (ptsi)) = substr (namep -> segnam.name (1), 1, segnam_size); /* Copy primary name into SST name table */ end; end; %page; %include sstnt; %page; %include aste; %page; %include slt; %page; %include slte; %page; %include sdw_info; %page; %include unpaged_page_tables; end;  init_stack_0.pl1 11/11/89 1108.3r w 11/11/89 0826.9 74997 /****^ *********************************************************** * * * 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. * * * *********************************************************** */ init_stack_0: proc; /* Program to build stack 0 segs to be shared by users */ /* Created May 79 by Mike Grady */ /* Modified June 81 by J. Bongiovanni to call update_vtoce for each stack, retry by deleting on error */ /* Modified December 1981 by J. Bongiovanni to clear usage count in ASTE */ /* Modified November 1984 by Keith Loepere to rename terminate to terminate_ */ dcl append$branchx entry (char (*), char (*), fixed bin (5), (*) fixed bin, char (*), fixed bin, fixed bin, fixed bin, fixed bin (35)); dcl chname$cfile entry (char (*), char (*), char (*), char (*), fixed bin (35)); dcl delentry$dfile entry (char (*), char (*), fixed bin (35)); dcl initiate entry (char (*), char (*), char (*), fixed bin, fixed bin, ptr, fixed bin (35)); dcl truncate$trseg entry (ptr, fixed bin, fixed bin (35)); dcl asd_$replace_sall entry (char (*), char (*), ptr, fixed bin, bit (1), fixed bin (35)); dcl terminate_$noname entry (ptr, fixed bin (35)); dcl grab_aste$prewithdraw entry (ptr, fixed bin, fixed bin (35)) returns (ptr); dcl get_ptrs_$given_astep entry (ptr) returns (bit (72) aligned); dcl syserr$error_code entry options (variable); dcl syserr entry options (variable); dcl unique_chars_ entry (bit(*)) returns(char(15)); dcl update_vtoce entry (ptr); dcl error_table_$namedup fixed bin (35) ext; dcl dseg$ fixed bin ext; dcl active_all_rings_data$stack_base_segno fixed bin ext; dcl pds$apt_ptr ptr aligned ext; dcl pds$stack_0_sdwp ptr ext; dcl pds$stack_0_ptr ptr ext; dcl indx fixed bin; dcl count fixed bin; dcl stk_no fixed bin; dcl stk_segp ptr; dcl dirname char (20) int static options (constant) init (">system_library_1"); dcl stack_name char (32); dcl pic picture "999"; dcl new_stkp ptr; dcl code fixed bin (35); dcl 1 tsdw like sdw; dcl seg_rb (3) fixed bin init (0, 0, 0) static options (constant); dcl retry bit (1); dcl 1 acl (1) aligned, 2 name char (32), 2 mode bit (36), 2 zp bit (36) init ("0"b), 2 code fixed bin (35); dcl 1 stack aligned based (sb), 2 header like stack_header, 2 frame_start fixed bin; dcl (addr, baseno, baseptr, fixed, null, ptr, rel, size, string) builtin; /* */ new_stkp = baseptr (active_all_rings_data$stack_base_segno); sdtp = addr (stack_0_data$); count = sdt.num_stacks; indx = 1; /* setup count and index for stack creation */ stk_no = 1; stk_segp = null (); do while (count ^= 0); /* build stack segs */ sdtep = addr (sdt.stacks (indx)); /* ptr to this entry */ retry = "1"b; /* retry by deleting on error */ pic = stk_no; stack_name = "stack_0." || pic; retry_stack: call append$branchx (dirname, stack_name, 01010b, seg_rb, "*.*.*", 0, 0, 0, code); if code ^= 0 then do; if code = error_table_$namedup then; else call error ("append", code); end; acl.name = "Initializer.SysDaemon.*"; acl.mode = "101"b; call asd_$replace_sall (dirname, stack_name, addr (acl), 1, "1"b, code); if code ^= 0 then call error ("asd_", code); call initiate (dirname, stack_name, "", 0, 0, stk_segp, code); if code ^= 0 then call error ("initiate", code); call truncate$trseg (stk_segp, 0, code); if code ^= 0 then call error ("truncate", code); astep = grab_aste$prewithdraw (stk_segp, 16*1024, code); /* get the correct aste */ if code ^= 0 then call error ("grab_aste", code); seg_aste.usage = 0; /* counts only meaningful since bootload, anyway */ call update_vtoce (astep); string (tsdw) = get_ptrs_$given_astep (astep); /* get a real SDW for the stack seg */ tsdw.cache = "1"b; /* stacks go in the cache */ sdte.sdw = string (tsdw); /* fill in the sdte */ sdte.astep = rel (astep); sdte.nextp = sdt.freep; /* thread this guy into list */ sdt.freep = rel (sdtep); /* and point free to this */ stk_segp -> stack_header_overlay = pds$stack_0_ptr -> stack_header_overlay; sb = stk_segp; /* for header re_build */ stack_header.stack_begin_ptr, stack_header.stack_end_ptr = ptr (new_stkp, rel (addr (stack.frame_start))); call terminate_$noname (stk_segp, code); /* we don't need this anymore */ stk_segp = null (); call asd_$replace_sall (dirname, stack_name, addr (acl), 0, "1"b, code); /* delete ACL */ count = count - 1; indx = indx + 1; try_again: stk_no = stk_no + 1; end; sdtep = ptr (sdtp, sdt.freep); /* take first stack for Initializer */ sdt.freep = sdte.nextp; /* re-thread free list */ sdte.nextp = "0"b; /* claim this one */ sdte.aptep = rel (pds$apt_ptr); /* Initializers APTE */ pds$apt_ptr -> apte.flags.shared_stack_0 = "1"b; /* Has a shared ring-0 stack */ sdwp = addr (dseg$); pds$stack_0_sdwp = addr (sdwa (fixed (baseno (new_stkp)))); pds$stack_0_ptr = new_stkp; sdwp = pds$stack_0_sdwp; string (sdw) = sdte.sdw; /* fill in correct SDW for Initializer's stack 0 */ return; error: proc (who, code); dcl who char (*); dcl code fixed bin (35); dcl ecode fixed bin (35); dcl temp_stack_name char (32); if retry then do; retry = "0"b; call syserr (0, "init_stack_0: Error creating >sl1>^a from ^a. Retrying.", stack_name, who); call syserr$error_code (0, code, "init_stack_0: "); if stk_segp ^= null () then do; call terminate_$noname (stk_segp, ecode); stk_segp = null (); end; temp_stack_name = "stack_0." || unique_chars_ (""b); call chname$cfile (dirname, stack_name, stack_name, temp_stack_name, ecode); if ecode ^= 0 then call error ("chname", ecode); call delentry$dfile (dirname, temp_stack_name, ecode); if ecode ^= 0 then call error ("delentry", ecode); goto retry_stack; end; else do; call syserr (3, "init_stack_0: Error creating >sl1>^a from ^a. Stack skipped.", stack_name, who); call syserr$error_code (0, code, "init_stack_0: "); go to try_again; end; end; %include apte; %include aste; %include stack_0_data; %include sdw; %include stack_header; %page; /* BEGIN MESSAGE DOCUMENTATION Message: init_stack_0: Error creating >sl1>XXXXXX from YYYYY. Retrying. S: $info T: $init M: An error was encountered in creating the stack_0 segment XXXXXX. The error was returned by module YYYYYY, and is described in detail in the following message. init_stack_0 will attempt to correct the problem by renaming the segment XXXXXX to stack_0., deleting it, and retrying the creation of segment XXXXXX once. A: No action is required if the above actions correct the problem. If the message persists, it may be symptomatic of hardware or software problems, and it should be brought to the attention of the System Programming Staff. Message: init_stack_0: Error creating >sl1>XXXXXX from YYYYYY. Stack skipped. S: $info T: $init M: An error was encountered in creating the stack_0 segment XXXXXX. The error was returned by module YYYYYY, and is described in detail in the following message. This error could not be corrected by renaming the segment XXXXXX to stack_0., deleting it, and retrying the creation of segment XXXXXX once. The stack_0 represented by segment XXXXXX is skipped, and there will be one fewer stack_0 than specified by the max_max_eligible tuning parameter for each message of this sort. A: This message may be symptomatic of hardware or software problems. It should be brought to the attention of the System Programming Staff. END MESSAGE DOCUMENTATION */ end;  init_str_seg.pl1 11/11/89 1108.3r w 11/11/89 0826.9 16407 /****^ *********************************************************** * * * 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. * * * *********************************************************** */ init_str_seg: proc; /* Procedure to init trailer segment. */ /* Modified 04/17/81, WOS, to record the number of trailers created in the sst */ dcl trp pointer; dcl idx fixed bin; dcl slt$ external static; dcl sst$tfreep pointer external static; dcl sst$strsize fixed bin external static; dcl sst$n_trailers fixed bin external static; dcl sys_info$page_size fixed bin external static; dcl (addr, baseno, binary, divide, rel, size) builtin; /* */ sst$tfreep = addr(str_seg$); /* Pointer to trailer segment. */ trp = sst$tfreep; sst$strsize = size (str); sltep = addr (addr (slt$) -> slt.seg (binary (baseno (trp)))); sst$n_trailers = divide ((binary (slte.cur_length, 9) * sys_info$page_size), sst$strsize, 17, 0); do idx = 1 to sst$n_trailers; /* Initialize them all */ strp = addr (trp -> stra (idx - 1)); /* Pointer to this entry. */ strp -> str.dstep = "777777"b3; /* set pattern in dstep */ strp -> str.fp = rel (sst$tfreep); /* Thread onto free list. */ sst$tfreep = strp; end; return; %page; %include str; %page; %include slt; %page; %include slte; end init_str_seg;  init_sys_var.pl1 11/11/89 1108.3rew 11/11/89 0826.9 42012 /****^ *********************************************************** * * * Copyright, (C) Honeywell Bull Inc., 1987 * * * * Copyright, (C) Honeywell Information Systems Inc., 1984 * * * * Copyright (c) 1972 by Massachusetts Institute of * * Technology and Honeywell Information Systems, Inc. * * * *********************************************************** */ /* format: style2 */ init_sys_var: procedure; /* Updated for NSS 4/75 THVV */ /* Modified by E. Stone 10/73 to correct bug in construction of initializer's channel */ /* OPTY support removed April 1981 by Benson I. Margulies */ /* Modified for ADP SDWs, 05/01/81, W. Olin Sibert */ /* Modified by J. Bongiovanni, December 1981, to remove sst$asthtp setup */ /* Modified by J. Bongiovanni, February 1982, to eliminate FSDCT */ /* Modified by J. Bongiovanni, October 1982, for sst$checksum_filemap */ /* Modified BIM 830312 to move dir_lock initialization to its own program. */ /* Modified by Keith Loepere, January 1985 for sst$seg_state_chg_operation. */ /* This program used to parse a channel name like tty_NNN off of the now undocumented config card OPTY. Channel names do not look like that any more. FNP's are not loaded from BOS. Therefore this has been decommissioned. If it is restored it should use config and not find to look at the deck. */ dcl dbrp pointer; dcl stack_base fixed bin (14) unsigned; dcl chn_name char (12); dcl parm_ptr ptr; dcl sst$seg_state_chg_operation bit (36) aligned external static; dcl sst$pvhtp pointer unaligned external static; dcl sst$rqover fixed bin (35) external static; dcl sst$checksum_filemap fixed bin external static; dcl sys_info$system_type fixed bin external static; dcl sys_info$time_of_bootload fixed bin (71) ext; dcl pvt$time_of_bootload fixed bin (71) ext; dcl pds$apt_ptr ptr ext; dcl active_all_rings_data$hcscnt fixed bin ext; dcl tc_data$max_hproc_segno fixed bin ext; dcl active_all_rings_data$stack_base_segno fixed bin (18) ext; dcl dseg$ (0:1024) fixed bin (71) ext; dcl access_operations_$excessive_seg_state_chg bit (36) aligned external; dcl error_table_$rqover fixed bin (35) external; dcl slt$ fixed bin ext; dcl (addr, bin, mod, bit, divide, segno, size) builtin; dcl get_pvtx$ret_pvhtp entry returns (ptr); dcl config_$find_parm entry (char (4) aligned, ptr); dcl syserr entry options (variable); %include syserr_constants; sltp = addr (slt$); stack_base = slt.last_sup_seg; /* calculate hard core seg count */ stack_base = 8 + stack_base - mod (stack_base, 8);/* Make it 0 mod 8 (for stack segno's). */ active_all_rings_data$stack_base_segno, active_all_rings_data$hcscnt = stack_base; if tc_data$max_hproc_segno < stack_base then /* make sure hproc dsegs will be large enough */ call syserr (CRASH, "init_sys_var: max_hproc_segno < hcscnt of ^o.", stack_base); dbrp = addr (dseg$ (segno (addr (dseg$)))); if sys_info$system_type = ADP_SYSTEM then do; /* Set the stack base in the DSBR. */ dbrp -> adp_dbr.stack_base_segno = divide (stack_base, 8, 14, 0); addr (pds$apt_ptr -> apte.dbr) -> adp_dbr.stack_base_segno = dbrp -> adp_dbr.stack_base_segno; end; else do; dbrp -> l68_dbr.stack_base_segno = divide (stack_base, 8, 14, 0); addr (pds$apt_ptr -> apte.dbr) -> l68_dbr.stack_base_segno = dbrp -> l68_dbr.stack_base_segno; end; /* Set the stack base in the DSBR. */ sys_info$time_of_bootload = pvt$time_of_bootload; /* get bootload time */ sst$pvhtp = get_pvtx$ret_pvhtp (); sst$rqover = error_table_$rqover; /* set up RQO error code */ sst$seg_state_chg_operation = access_operations_$excessive_seg_state_chg; call config_$find_parm ("nock", parm_ptr); if parm_ptr = null () then sst$checksum_filemap = 1; return; /* format: off */ %page; %include apte; %page; %include slt; %page; %include "dbr.l68"; %page; %include "dbr.adp"; %page; %include system_types; /* BEGIN MESSAGE DOCUMENTATION Message: init_sys_var: max_hproc_segno < hcscnt of XXX S: $crash T: $init M: The upper bound of the descriptor segment for hardcore processes is too small. $err A: $recover $boot_tape END MESSAGE DOCUMENTATION */ end init_sys_var;  init_syserr_log.pl1 11/11/89 1108.3r w 11/11/89 0826.9 221949 /****^ *********************************************************** * * * Copyright, (C) Honeywell Bull Inc., 1987 * * * * Copyright, (C) Honeywell Information Systems Inc., 1984 * * * *********************************************************** */ /* format: style4 */ init_syserr_log: procedure (); /* * INIT_SYSERR_LOG * * This procedure is called early in collection II initialization. * It performs the following major initialization tasks: * 1. Sets up the log partition so it can be referenced as paged segments. * 2. If the version in the paged syserr_log_data segment is not * correct, then we initialize the paged syserr_log_data segment. * 3. Initializes the wired log buffer in syserr_data$syserr_area * 4. Creates the syserr HPROC. * * Modification history: * 73-08-11, Bill Silver: Initial coding * 75-11-02, Larry Johnson: Modified for new log and message format * 76-03-23, Steve Webber: Modified to create HPROC for logging * 77-04-11, Bernard Greenberg: Modified for syserr_daemon segments * 79-05-26, Mike Grady: Modified for ring zero stack sharing * 81-07-09, Ellie Donner: Modified for new format of event channel names * 82-03-20, John Bongiovanni: Eliminated use of FSDCT * 84-08-24, W. Olin Sibert: Modifications (part 1) for new syserr log format: * Three segments in the partition, new log format, name changed from * syserr_log_init to init_syserr_log, diagnose no PART LOG card. * 84-11-16 by E. Swenson: Changed for new IPC validation. * 1984-12-03, BIM: change to a fast lock. * 1984-12-05 by E. Swenson: Fixed to not use regular event channel. * 1984-12-10 by Keith Loepere: To force LOG part onto RPV until * init_branches becomes smarter. * 1985-03-03, EJ Sharpe: added check for service bit, format, * and set history_dir in log header at partition initialization * 1985-03-25, EJ Sharpe: fixed subscript error, cleanup syserr messages */ declare code fixed bin (35); declare log_part_pvtx fixed bin; declare log_part_start fixed bin (18); declare log_part_size fixed bin (18); declare part_idx fixed bin; declare r_offset fixed bin (18); /* used in IPC event channel creation and validation */ declare r_factor fixed bin (35); /* ditto */ declare rpv_label bit (36 * 1024) aligned; declare special_channel fixed bin (71); /* event channel for syserr copy wakeups */ declare initializing bit (1) aligned; /* Set if we are reinitializing partition */ declare test_mode bit (1) aligned; /* Sets up a ring four test environment */ declare log_data_$syserr_log_dir char (32) external static; declare log_data_$syserr_log_history_dir char (168) external static; declare log_data_$syserr_log_partition char (4) external static; declare log_data_$syserr_log_daemon char (32) external static; declare pds$process_id bit (36) aligned external static; declare pds$process_group_id char (32) external static; declare pvt$root_pvtx fixed bin external static; declare sys_info$page_size fixed bin external static; declare syserr_data$log_meters fixed bin external static; declare syserr_data$wired_log_size fixed bin external static; declare syserr_data$logger_proc_id bit (36) aligned external static; declare syserr_data$logger_ec fixed bin (71) external static; declare syserr_log_laurel$ fixed bin external static; declare syserr_log_hardy$ fixed bin external static; declare create_hproc$early_hproc entry (char (*), bit (1) aligned, pointer, pointer, pointer, pointer, pointer, fixed bin (35)); declare ipc_validate_$encode_event_channel_name entry (fixed bin (18), fixed bin (35), bit (3) aligned, fixed bin (15), fixed bin (3), bit (1) aligned, fixed bin (18), fixed bin (71)); declare log_initialize_ entry (pointer, pointer, fixed bin (18), char (*), fixed bin (35)); declare log_segment_$create_message entry (pointer, fixed bin, fixed bin, char (10) varying, pointer, fixed bin (35)); declare log_segment_$finish_message entry (pointer, pointer, fixed bin (35)); declare log_segment_$get_service_bit entry (ptr, bit (1) aligned, fixed bin (35)); declare log_segment_$last_message_info entry (pointer, fixed bin (35), fixed bin (18), fixed bin (35)); declare log_segment_$place_in_service entry (pointer, fixed bin (35)); declare log_segment_$remove_from_service entry (pointer, fixed bin (35)); declare map_onto_disk entry (fixed bin, fixed bin (20), fixed bin, pointer, bit (1) aligned); declare read_disk entry (fixed bin, fixed bin (18), ptr, fixed bin (35)); declare syserr entry options (variable); declare syserr$error_code entry options (variable); declare syserr_log_daemon entry (); declare tc_util$get_ipc_operands_priv entry (bit (36) aligned, fixed bin (18), fixed bin (35), fixed bin (35)); declare FAST_CHANNEL_TYPE bit (1) aligned internal static options (constant) initial ("0"b); declare WHOAMI char (32) internal static options (constant) init ("init_syserr_log"); declare (abs, addr, baseno, binary, clock, codeptr, copy, dimension, divide, length, null, rel, sign, size, sum, unspec) builtin; %page; test_mode = "0"b; goto BEGIN_INITIALIZATION; init_syserr_log$test: entry (); test_mode = "1"b; /* This entrypoint sets up a ring four test environment */ /* First, locate and check out the wired data area. */ /* NOTE: THIS CHANGES WHEN THE WIRED AREA IS CONVERTED TO LOG SEGMENTS */ BEGIN_INITIALIZATION: wlog_ptr = addr (syserr_data$wired_log_area); sd_ptr = addr (syserr_data$syserr_area); if (size (wlog) > syserr_data$wired_log_size) then call syserr (SYSERR_CRASH_SYSTEM, "^a: Size of wired log is inconsistent.", WHOAMI); /* Next, locate the LOG partition. If none, we do no logging, but we say so (a new message) because it's almost sure to be a mistake. */ if ^test_mode then do; /* Don't play with the partition in test mode */ /* call partition_io$find_partition (log_data_$syserr_log_partition, log_part_pvtx, (""b), log_part_start, log_part_size, code); */ labelp = addr (rpv_label); log_part_pvtx = pvt$root_pvtx; call read_disk (log_part_pvtx, 0, labelp, code); if code ^= 0 then go to log_part_error; do part_idx = 1 to label.nparts while (label.parts (part_idx).part ^= log_data_$syserr_log_partition); end; if part_idx > dimension (label.parts, 1) then do; log_part_error: call syserr (SYSERR_CRASH_SYSTEM, "^a: No LOG partition found, syserr logging disabled.", WHOAMI); return; end; log_part_start = label.parts (part_idx).frec; log_part_size = label.parts (part_idx).nrec; end; else log_part_size = 3; /* Give each segment 1 record */ /* Next, setup the syserr_log_data segment. It is always one page long, and located in the first record of the partition. */ syserr_log_data_ptr = addr (syserr_log_data$); call setup_segment (syserr_log_data_ptr, 0, 1); /* See if it has valid contents. If not, reinitialize it; if so, re-use it */ initializing = ^syserr_data_valid (); /* See if there's anything useful there now */ if initializing then /* If not, rebuild syserr_dta first */ call initialize_syserr_data (); /* Set up the two alternating buffer segments; their locations may have been remembered, or set up by initialize_syserr_data if we reinitialize */ syserr_log_data.log_ptr (1) = addr (syserr_log_laurel$); syserr_log_data.log_ptr (2) = addr (syserr_log_hardy$); syserr_log_data.log_name (1) = "syserr_log_laurel"; syserr_log_data.log_name (2) = "syserr_log_hardy"; syserr_log_data.log_dir = log_data_$syserr_log_dir; call setup_segment (syserr_log_data.log_ptr (1), syserr_log_data.log_start (1), syserr_log_data.log_size (1)); call setup_segment (syserr_log_data.log_ptr (2), syserr_log_data.log_start (2), syserr_log_data.log_size (2)); unspec (syserr_log_data.lock) = ""b; syserr_log_data.lock.event_id = binary ("105"b3); /* Initialize per-bootload items */ if initializing then /* If we are rebuilding, re-set the log segments */ call initialize_log_segments (); /* In both cases, these set wlog.seq_num appropriately */ else call check_log_segments (); /* Otherwise, just check the contents */ wlog.next = rel (addr (wlog.buffer)); /* Also set some other variables in the wired buffer */ wlog.count = 0; addr (syserr_data$log_meters) -> olm.last_time = clock (); if test_mode then /* Set up IPC event-call kludge */ call create_ring_four_test_logger (); else call create_syserr_daemon (); /* Create the daemon, and, if we make it this far, */ syserr_log_data.test_mode = test_mode; /* Keep track of test mode operation */ if initializing then /* If we are rebuilding, make it be finally valid */ syserr_log_data.version = SYSERR_LOG_DATA_V1; sd.log_flag = "1"b; /* tell the daemon to start logging messages. */ MAIN_RETURN: return; %page; setup_segment: procedure (P_seg_ptr, P_first_rec, P_seg_lth); declare P_seg_ptr pointer parameter; declare P_first_rec fixed bin parameter; declare P_seg_lth fixed bin parameter; declare segno fixed bin; declare slt$ fixed bin external static; /* This procedure is used to set up an ASTE for the specified hardcore segment (P_seg_ptr), the pages of which map onto a particular portion of the LOG partition. */ if test_mode then /* This has no meaning in test mode */ return; segno = binary (baseno (P_seg_ptr)); sltp = addr (slt$); /* Check to see that the resulting page table will */ sltep = addr (slt.seg (segno)); /* be large enough; that is, was declared large */ if (P_seg_lth > binary (slte.max_length)) then /* enough in the header. */ call syserr (SYSERR_CRASH_SYSTEM, "^a: Size of ^p larger on disk than in header.", WHOAMI, P_seg_ptr); call map_onto_disk /* Pop the abs-seg onto the right place in the partition */ (log_part_pvtx, (log_part_start + P_first_rec), P_seg_lth, P_seg_ptr, "1"b); return; end setup_segment; %page; syserr_data_valid: procedure () returns (bit (1) aligned); declare allocation_error bit (1) aligned; if (syserr_log_data.version ^= SYSERR_LOG_DATA_V1) then return ("0"b); /* These tests verify that the first log segment thinks it starts immediately after the one-page header, that the second starts immediately after that, that no values are negative, that they don't overflow the partition, and that they are evenly balanced */ if (syserr_log_data.log_start (1) ^= 1) then allocation_error = "1"b; else if (syserr_log_data.log_start (2) ^= (1 + syserr_log_data.log_size (1))) then allocation_error = "1"b; else if (sum (sign (syserr_log_data.log_start)) ^= 2) then allocation_error = "1"b; else if (sum (sign (syserr_log_data.log_size)) ^= 2) then allocation_error = "1"b; else if ((sum (syserr_log_data.log_size) + 1) > log_part_size) then allocation_error = "1"b; else if (abs (syserr_log_data.log_size (1) - syserr_log_data.log_size (2)) > 2) then allocation_error = "1"b; else if (syserr_log_data.live_log ^= 1) & (syserr_log_data.live_log ^= 2) then allocation_error = "1"b; else allocation_error = "0"b; if allocation_error then do; call syserr (SYSERR_PRINT_WITH_ALARM, "^a: LOG partition damaged. Reinitializing.", WHOAMI); return ("0"b); end; /* If the syserr_log_data appears to be valid, then we reinitialize the per-bootload values before returning; if not, this job will be taken care of by initialize_syserr_data. */ unspec (syserr_log_data.per_bootload) = ""b; syserr_log_data.log_ptr (*) = null (); return ("1"b); end syserr_data_valid; %page; initialize_syserr_data: procedure (); declare segment_size fixed bin; /* This procedure reinitializes the contents of the partition, splitting it as evenly as possible between the two segments. It initializes all the permanent information in syserr_log_data EXCEPT the version number, which gets set after everything else is correct. */ if (syserr_log_data.old_init_word = "INIT") then call syserr (SYSERR_PRINT_ON_CONSOLE, "^a: Converting MR10.2 syserr partition", WHOAMI); unspec (syserr_log_data) = ""b; /* Clean it out */ segment_size = divide ((log_part_size - 1), 2, 17, 0); /* Remember a page for the header */ syserr_log_data.log_start (1) = 1; syserr_log_data.log_start (2) = 1 + segment_size; syserr_log_data.log_size (*) = segment_size; syserr_log_data.old_init_word = "*NEW"; syserr_log_data.live_log = 1; syserr_log_data.swap_time = 0; /* This marks the other log as empty */ syserr_log_data.log_ptr (*) = null (); /* Just to catch errors */ return; end initialize_syserr_data; %page; initialize_log_segments: procedure (); declare log_idx fixed bin; declare sys_log_ptr pointer; declare log_size fixed bin (18); declare INITIAL_MESSAGE char (100) varying internal static options (constant) init ("init_syserr_log: Syserr LOG partition reinitialized."); do log_idx = 1, 2; /* Two segments */ sys_log_ptr = syserr_log_data.log_ptr (log_idx); log_size = syserr_log_data.log_size (log_idx) * sys_info$page_size; call log_initialize_ (null (), sys_log_ptr, log_size, "", code); if (code ^= 0) then call syserr (SYSERR_CRASH_SYSTEM, "^a: Cannot initialize paged syserr log ^p", WHOAMI, sys_log_ptr); call log_segment_$remove_from_service (sys_log_ptr, (0)); end; sys_log_ptr = syserr_log_data.log_ptr (syserr_log_data.live_log); call log_segment_$place_in_service (sys_log_ptr, (0)); sys_log_ptr -> log_segment.previous_log_dir = log_data_$syserr_log_history_dir; call log_segment_$create_message (sys_log_ptr, length (INITIAL_MESSAGE), 0, "", log_message_ptr, code); if (code ^= 0) then call syserr (SYSERR_CRASH_SYSTEM, "^a: Cannot write initial message to paged syserr log ^p", WHOAMI, sys_log_ptr); log_message.time = clock (); log_message.severity = 0; log_message.process_id = pds$process_id; log_message.text = INITIAL_MESSAGE; call log_segment_$finish_message (sys_log_ptr, log_message_ptr, (0)); wlog.seq_num = log_message.sequence; call syserr (SYSERR_PRINT_ON_CONSOLE, log_message.text); return; end initialize_log_segments; %page; check_log_segments: procedure (); declare last_log_ptr pointer; declare last_message_number fixed bin (35); declare service_bit bit (1) aligned; last_log_ptr = syserr_log_data.log_ptr (syserr_log_data.live_log); call log_segment_$last_message_info (last_log_ptr, last_message_number, (0), code); if (code ^= 0) then do; call syserr$error_code (SYSERR_PRINT_ON_CONSOLE, code, "^a: Cannot get last message info from paged syserr log ^p", WHOAMI, last_log_ptr); initializing = "1"b; call initialize_log_segments (); return; end; call log_segment_$get_service_bit (last_log_ptr, service_bit, code); if (code ^= 0) then do; call syserr$error_code (SYSERR_PRINT_ON_CONSOLE, code, "^a: Cannot get service bit from paged syserr log ^p", WHOAMI, last_log_ptr); initializing = "1"b; call initialize_log_segments (); return; end; if (service_bit ^= "1"b) then do; call syserr (SYSERR_PRINT_ON_CONSOLE, "^a: Service bit off for live paged syserr log ^p.", WHOAMI, last_log_ptr); initializing = "1"b; call initialize_log_segments (); return; end; wlog.seq_num = last_message_number; return; end check_log_segments; %page; create_syserr_daemon: procedure (); /* This procedure creates the HPROC and fills in variables so syserr_real knows how to call upon it. Note that its stack, PDS, and DSEG are defined in the header */ declare 1 syserr_stk aligned based (sb), /* Overlay for initializing daemon's stack */ 2 header like stack_header, 2 frame like stack_frame; declare syserr_daemon_dseg$ fixed bin external static; declare syserr_daemon_pds$ fixed bin external static; declare syserr_daemon_stack$ fixed bin external static; declare pds$stack_0_ptr pointer external static; sb = addr (syserr_daemon_stack$); /* base of syserr's ring 0 stack */ stack_header_overlay = pds$stack_0_ptr -> stack_header_overlay; /* copy the stack header */ stack_header.stack_begin_ptr = addr (syserr_stk.frame); /* setup first frame ptrs */ stack_header.stack_end_ptr = addr (syserr_stk.frame); call create_hproc$early_hproc (log_data_$syserr_log_daemon, "0"b, aptep, codeptr (syserr_log_daemon), addr (syserr_daemon_dseg$), addr (syserr_daemon_pds$), addr (syserr_daemon_stack$), code); if code ^= 0 then do; call syserr (SYSERR_PRINT_ON_CONSOLE, "^a: Cannot create logger process.", WHOAMI); goto MAIN_RETURN; end; syserr_data$logger_proc_id = apte.processid; /* for use by syserr_real */ /**** In order to create an event channel, a process must know its values of R-Offset and R-Factor. These were set up when the process was created. Retrieve then now from the APTE. create_hproc set them. */ call tc_util$get_ipc_operands_priv (apte.processid, r_offset, r_factor, code); if code ^= 0 then do; call syserr (SYSERR_PRINT_ON_CONSOLE, "^a: Unable to retrieve IPC operands from APTE. Syserr log copying disabled.", WHOAMI); goto MAIN_RETURN; end; /**** Create a valid (encoded) event channel name. */ call ipc_validate_$encode_event_channel_name (r_offset, r_factor, "000"b /* flags */, 1 /* index */, 0 /* ring */, FAST_CHANNEL_TYPE, 1 /* unique id */, special_channel); syserr_data$logger_ec = special_channel; return; end create_syserr_daemon; %page; create_ring_four_test_logger: procedure (); /* This procedure causes all sorts of nasty error messages if it is included as-is on the system tape, because it goes in a temp-seg, yet contains links to things not in ring zero. So, we have a nasty kludge to avoid it, using comments instead of pl1_macro just to make the thing easier to compile. The real (external) entry declarations are commented out in the installed version, and replaced by entry variable declarations that all turn into calls to pxss$block (no special reason, save that it's guaranteed not to be found). To run this in the outer ring, just un-comment the first set of declarations, and comment out the second. */ /* COMMENTED OUT FOR RING ZERO INSTALLED VERSION declare com_err_ entry options (variable); declare get_group_id_ entry () returns (char (32) aligned); declare get_lock_id_ entry () returns (bit (36) aligned); declare get_process_id_ entry () returns (bit (36) aligned); declare ioa_ entry options (variable); declare ipc_$create_ev_chn entry (fixed bin (71), fixed bin (35)); declare ipc_$decl_event_call_chn entry (fixed bin(71), entry, pointer, fixed bin, fixed bin (35)); COMMENTED OUT FOR RING ZERO INSTALLED VERSION */ /* KLUDGE DECLARATIONS LEFT IN RING ZERO INSTALLED VERSION */ declare 1 kludge_entries variable automatic, 2 com_err_ entry options (variable), 2 get_group_id_ entry () returns (char (32) aligned), 2 get_lock_id_ entry () returns (bit (36) aligned), 2 get_process_id_ entry () returns (bit (36) aligned), 2 ioa_ entry options (variable), 2 ipc_$create_ev_chn entry (fixed bin (71), fixed bin (35)), 2 ipc_$decl_event_call_chn entry (fixed bin (71), entry, pointer, fixed bin, fixed bin (35)); unspec (kludge_entries) = copy ("040"b3, (4 * size (kludge_entries))); /* Force fault_tag_1 */ /* KLUDGE DECLARATIONS LEFT IN RING ZERO INSTALLED VERSION */ declare pds$processid bit (36) aligned external static; call ipc_$create_ev_chn (syserr_data$logger_ec, code); if (code ^= 0) then goto IPC_ERROR; call ipc_$decl_event_call_chn (syserr_data$logger_ec, syserr_log_daemon, null (), 0, code); if (code ^= 0) then do; IPC_ERROR: call com_err_ (code, WHOAMI, "Cannot create IPC channel for test logger."); return; end; syserr_data$logger_proc_id = get_process_id_ (); pds$processid = get_lock_id_ (); pds$process_group_id = get_group_id_ (); sd.ocdcm_init_flag = "1"b; /* Let's claim that ocdcm_ works, too */ /* syserr message MUST come BEFORE the log flag is turned on because logging is not really operational until after collection 1 is done */ call ioa_ ("^a: Syserr log test environment initialized", WHOAMI); return; end create_ring_four_test_logger; /* format: off */ %page; %include add_type; %page; %include apte; %page; %include ect_structures; %page; %include oc_log_meters; %page; %include slt; %page; %include slte; %page; %include stack_frame; %page; %include stack_header; %page; %include syserr_data; %page; %include syserr_log_dcls; %page; %include syserr_constants; %page; %include log_segment; %page; %include log_message; %page; %include fs_vol_label; %page; /* BEGIN MESSAGE DOCUMENTATION Message: init_syserr_log: Size of wired log is inconsistent. S: $crash T: $init M: The definitions in syserr_data.cds are inconsistent with those in syserr_data.incl.pl1. This indicates a programming error. A: $recover Message: init_syserr_log: No LOG partition found, syserr logging disabled. S: $crash T: $init M: The system requires a LOG partition on the RPV disk to hold syserr messages before they are copied into >sc1>syserr_log. This partition must exist on the volume, and be defined by a "PART LOG" card in the config deck. A: Create a LOG partition on the RPV and define it in the config deck, then re-boot. The LOG partition should be at least 200 records long, and may be as large as 513. Message: init_syserr_log: Size of PTR larger on disk than in header. S: $crash T: $init M: The LOG partition has been damaged. Some messages may be lost if the previous shutdown was caused by a crash. A: Reinitialize the LOG partition with the BCE test_disk command and re-boot. Message: init_syserr_log: LOG partition damaged. Reinitializing. S: $beep T: $init M: The LOG partition has been damaged. Some messages may be lost if the previous shutdown was caused by a crash. The partition is automatically reinitialized. A: $recover Message: init_syserr_log: Converting MR10.2 syserr partition. S: $info T: $init M: This message occurs during the first bootload with an MR11.0 system tape, and indicates that the LOG partition is now in the new format. A: $ignore Message: init_syserr_log: Cannot initialize paged syserr log PTR. S: $crash T: $init M: $err A: $recover Message: init_syserr_log: Cannot write initial message to paged syserr log PTR. ERROR-MESSAGE S: $crash T: $init M: $err A: $recover It may be necessary to reinitialize the LOG partition with the BCE test_disk command after this error. Message: init_syserr_log: Cannot get last message info from paged syserr log PTR. ERROR-MESSAGE S: $info T: $init M: $err A: $recover It may be necessary to reinitialize the LOG partition with the BCE test_disk command after this error. Message: init_syserr_log: Cannot create logger process. ERROR-MESSAGE S: $info T: $init M: $err No syserr messages will be logged during this bootload. A: $recover Message: init_syserr_log: Unable to retrieve IPC operands from APTE. Syserr log copying disabled. S: $info T: $init M: $err No syserr messages will be logged during this bootload. A: $recover Message: init_syserr_log: Cannot get service bit from paged syserr log PTR. MESSAGE S: $info T: $init M: $err Some error occurred when attempting to check the in service bit for the specified ring 0 paged log segment. A: $ignore The log partition will be automatically reinitialized. Message: init_syserr_log: Service bit off for live paged syserr log PTR. S: $info T: $init M: The in service flag for the specified ring 0 paged log segment was found off. Being this is supposed to be the live log, an error is indicated. This may occur when booting after a system crash. A: $ignore The syserr log partition will be automatically reinitialized. END MESSAGE DOCUMENTATION */ end init_syserr_log;  init_vtoc_man.pl1 11/11/89 1108.3r w 11/11/89 0826.9 30303 /****^ *********************************************************** * * * Copyright, (C) Honeywell Bull Inc., 1987 * * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * *********************************************************** */ /* format: style3 */ init_vtoc_man: proc; /* init_vtoc_man The "init_vtoc_man" procedure initializes all constants located in the header of the vtoc buffer segment. It gets the number of buffers to use from the vtb parameter found on one of the parm cards. Modified by : 07/09/82 J. Bongiovanni for new VTOC buffer strategy 02/14/76 Steve Webber to call get_main 06/20/75 Andre Bensoussan. */ /* Automatic */ dcl code fixed bin (35); dcl mask bit (36) aligned; dcl tsdw fixed bin (71); /* Static */ dcl DEFAULT_MASK bit (36) aligned int static options (constant) init ("000000000037"b3); dcl DEFAULT_N_BUCKETS fixed bin int static options (constant) init (32); dcl DEFAULT_N_BUFFERS fixed bin int static options (constant) init (30); dcl WAIT_EVENT bit (36) aligned int static options (constant) init ("333000000000"b3); /* Entry */ dcl absadr entry (ptr, fixed bin (35)) returns (fixed bin (24)); dcl find_parm entry (char (4) aligned, ptr); dcl get_main entry (ptr, fixed bin (18), fixed bin (71)); dcl pmut$swap_sdw entry (ptr, ptr); dcl syserr entry options (variable); %page; vtoc_buffer_segp = addr (vtoc_buffer_seg$); /* Determine the number of VTOCE buffers */ call find_parm ("vtb ", parm_ptr); if parm_ptr = null () then vtoc_buf_n_buffers = DEFAULT_N_BUFFERS; else vtoc_buf_n_buffers = numeric_parm.value; /* Determine the number of hash buckets (currently constant) */ vtoc_buf_n_buckets = DEFAULT_N_BUCKETS; mask = DEFAULT_MASK; /* Get contiguous memory for vtoc_buffer_seg and establish its SDW */ call get_main (vtoc_buffer_segp, size (vtoc_buffer), tsdw); call pmut$swap_sdw (vtoc_buffer_segp, addr (tsdw)); /* Fill in vtoc_buffer_seg */ vtoc_buffer.lock.wait_event = WAIT_EVENT; vtoc_buffer.n_bufs = vtoc_buf_n_buffers; vtoc_buffer.n_hash_buckets = vtoc_buf_n_buckets; vtoc_buffer.hash_mask = mask; vtoc_buffer.abs_addr = absadr (vtoc_buffer_segp, code); if code ^= 0 then call syserr (CRASH, "init_vtoc_man: Unexpected error from absadr. Code ^o", code); vtoc_buffer.wait_event_constant = bin (WAIT_EVENT, 36); vtoc_buf_desc_arrayp = addr (vtoc_buffer.buf_desc); vtoc_buf_arrayp = addr (vtoc_buffer.buffer); vtoc_buffer.buf_desc_offset = rel (vtoc_buf_desc_arrayp); vtoc_buffer.buf_offset = rel (vtoc_buf_arrayp); vtoc_buffer.hash_table_offset = rel (addr (vtoc_buffer.hash_table)); vtoc_buffer.search_index = 1; return; %page; %include config_parm_card; %page; %include syserr_constants; %page; %include vtoc_buffer; %page; /* BEGIN MESSAGE DOCUMENTATION Message: init_vtoc_man: Unexpected error from absadr. Code XX. S: $crash T: $init M: The absolute address of vtoc_buffer_seg could not be determined. This indicates hardware or software malfunction. A: $recover END MESSAGE DOCUMENTATION */ end init_vtoc_man; 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