countervalidate_label_.pl1 12/11/99 1838.1r w 12/11/99 1808.4 38592 /****^ *********************************************************** * * * 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(99-06-23,Haggett): Y2K END HISTORY COMMENTS */ countervalidate_label_: proc (a_labelp, a_valid_reg, a_valid_copy, a_ss_pack); /* Countervalidator of labels for mdxhdx/rcp Bernard Greenberg 12/1/76 */ /* Modified 84-09-04 by EJ Sharpe - rename hdx refs to volume_registration_mgr_ */ /* Modified 84-10-29 by EJ Sharpe - change date_time_ refs to date_time_$format */ dcl a_labelp ptr; dcl a_valid_reg bit (1); /* 1 => instance of valid registered volume */ dcl a_valid_copy bit (1); /* 1 => valid and registered, but mtd copy exists */ dcl a_ss_pack bit (1); /* 1 => this is a storage system pack. */ dcl volume_registration_mgr_$pvname_info entry (char (*), bit (36) aligned, char (*), bit (36) aligned, fixed bin, fixed bin (35)); dcl mdx$check_lv entry (char (*), fixed bin (35)); dcl code fixed bin (35); dcl (lvname, pvname) char (32); dcl addr builtin; labelp = a_labelp; if label.Multics ^= Multics_ID_String then do; /* Not even ss pack */ a_valid_reg, a_valid_copy, a_ss_pack = "0"b; return; end; pvname = label.pv_name; a_ss_pack = "1"b; /* Is surely a ss pack */ call volume_registration_mgr_$pvname_info (pvname, pvid, lvname, lvid, (0), code); if code ^= 0 then do; /* No such volume */ a_valid_reg, a_valid_copy = "0"b; return; end; if pvid = label.pvid & lvid = label.lvid & lvname = label.lv_name then do; /* It's real */ a_valid_reg = "1"b; call mdx$check_lv (lvname, code); a_valid_copy = (code = 0); end; else a_valid_reg, a_valid_copy = "0"b; return; /* ----------------------------------------------------------- */ query: entry (a_labelp, a_pvname, a_progname, a_drivename) returns (bit (1)); dcl a_pvname char (32); dcl (a_progname, a_drivename) char (*); dcl (valid_reg, valid_copy, ss_pack) bit (1); dcl command_query_ entry options (variable); dcl answer char (10) varying; dcl date_time_$format entry (char(*), fixed bin(71), char(*), char(*)) returns(char(250) var); dcl chtime char (24); dcl story char (50); dcl 1 query_info aligned, 2 version fixed bin, 2 yes_or_no_sw bit (1) unal, 2 suppress_name_sw bit (1) unal, 2 code fixed bin (35), 2 query_code fixed bin (35); dcl initializer_mdc_$countervalidate_label_ entry (ptr, bit (1), bit (1), bit (1)); labelp = a_labelp; pvname = a_pvname; call initializer_mdc_$countervalidate_label_ (labelp, valid_reg, valid_copy, ss_pack); /* Recursively get dope in other ring */ if ^ss_pack then return ("1"b); /* No problem here! */ if ^valid_reg then story = "an unregistered pack named"; else if pvname = label.pv_name then if valid_copy then story = "a copy of pv"; else story = "an earlier instance of pv"; else if valid_copy then story = "a copy of Multics Storage System Volume"; else story = "Multics Storage System Volume"; if valid_reg & ^(^valid_copy & ^(pvname = label.pv_name)) then chtime = date_time_$format ("^9999yc-^my-^dm_^Hd:^MH", label.time_map_updated, "", ""); else chtime = ""; query_info.version = 2; query_info.yes_or_no_sw = "1"b; query_info.suppress_name_sw = "0"b; query_info.code = 0; query_info.query_code = 0; call command_query_ (addr (query_info), answer, a_progname, "Volume on ^a is ^a ""^a""^[.^/^2s^;,^/^[which was never used^s^;last used ^a^]. ^]Do you wish to overwrite it?", a_drivename, story, label.pv_name, chtime = "", label.time_map_updated = 0, chtime); return (answer = "yes"); %include fs_vol_label; end;  disk_rebuild_caller.pl1 11/11/89 1102.4r w 11/11/89 0802.8 61380 /****^ *********************************************************** * * * 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. * * * *********************************************************** */ /****^ HISTORY COMMENTS: 1) change(86-01-16,Fawcett), approve(86-04-11,MCR7383), audit(86-05-14,LJAdams), install(86-07-17,MR12.0-1097): Add support for subvolumes, and 512_WORD_IO, 3380 and 3390. END HISTORY COMMENTS */ disk_rebuild_caller: proc (a_dtp, apvtx1, apvtx2, opt_bits); /* Written by Kobziar from init_disk_pack_. */ /* Reworked for fill_vol_extents_, BSG 08/31/76 */ /* Modified for countervalidate_label_ BSG 12/1/76 */ /* Modified for to allow rebuild to larger disk, 7/23/81 M.R. Jordan */ /* Modified for new volume format, and to allow reduction in number of VTOCEs, March 1982, J. Bongiovanni */ /* Modified '83 KPL for fix to error message about rebuild */ dcl opt_bits bit (36) aligned, (pvtx1, pvtx2) fixed bin, /* Physical Volume Table Indexes */ tpsp fixed bin, /* total partition space */ a_dtp ptr, (apvtx1, apvtx2) fixed bin, /* drive args */ (dev_type1, dev_type2) fixed bin, /* drive types index */ code fixed bin (35); /* error code */ dcl num_pages fixed bin, /* Number of records in paging area on this volume */ baseadd fixed bin, i fixed bin, interlace fixed bin init (2), /* use alternate address assignment in copying */ old_n_vtoce fixed bin, n_vtoce fixed bin; /* number of VTOC entries in VTOC */ dcl buffer (512) fixed bin (71); dcl (addr, clock) builtin; dcl com_err_ entry options (variable); dcl countervalidate_label_$query entry (ptr, char (*), char (*), char (*)) returns (bit (1)); dcl fill_vol_extents_ entry (ptr, fixed bin, fixed bin, fixed bin, fixed bin, bit (1) aligned, fixed bin (17), fixed bin (35)); dcl initializer_gate_$disk_rebuild entry (fixed bin, fixed bin, ptr, bit (36) aligned, fixed bin, fixed bin (35)); dcl initializer_gate_$read_disk entry (fixed bin, fixed bin, ptr, fixed bin (35)); dcl ioa_ entry options (variable); %page; labelp = addr (buffer); dtp = a_dtp; pvtx1 = apvtx1; pvtx2 = apvtx2; dev_type1 = dt.array (pvtx1).device_type; dev_type2 = dt.array (pvtx2).device_type; call ioa_ ("rebuild_disk: volume ^a from ^a onto ^a", dt.array (pvtx1).pvname, dt.array (pvtx1).drive_name, dt.array (pvtx2).drive_name); call initializer_gate_$read_disk (pvtx2, LABEL_ADDR, labelp, code); if code ^= 0 then go to ERR; if ^countervalidate_label_$query (labelp, (dt.array (pvtx1).pvname), "disk_rebuild", (dt.array (pvtx2).drive_name)) then return; call initializer_gate_$read_disk (pvtx1, LABEL_ADDR, labelp, code); if code ^= 0 then go to ERR; if ^dt.array (pvtx1).used /* Must be in use for rin-0 to work */ then do; call ioa_ ("rebuild_disk: Volume ^a must be mounted before rebuilding", dt.array (pvtx1).drive_name); return; end; label.time_map_updated, label.time_unmounted, label.time_salvaged = clock (); label.shutdown_state = 0; /* If you believe this... */ label.esd_state = 0; interlace = 2; /* Default, triggers f_v_e that this is rebuild */ tpsp = 0; call ioa_ ("^/ Current disk parameters:^/"); do i = 1 to label.nparts; call ioa_ ("part ^a ^d ^d", label.parts (i).part, label.parts (i).frec, label.parts (i).nrec); tpsp = tpsp + label.parts (i).nrec; end; old_n_vtoce = (label.vtoc_size - VTOC_ORIGIN) * VTOCES_PER_RECORD (dev_type1); call ioa_ ("Vtoc size is ^d, ave. seg length = ^.3f", label.vtoc_size, ((label.vol_size - tpsp - VTOC_ORIGIN) / (label.vtoc_size - VTOC_ORIGIN)) / VTOCES_PER_RECORD (dev_type1)); call ioa_ ("Current number of VTOCEs = ^d", old_n_vtoce); call ioa_ (""); call ioa_ ("^/New starting parameters (no partitions defined):"); if dt.array (pvtx2).is_sub_vol then do; dtep = addr (dt.array (pvtx2)); label.vol_size = rec_per_sv (dte.device_type); label.number_of_sv = dte.num_of_sv; label.this_sv = dte.sv_num; label.sub_vol_name = valid_sv_array (dte.sv_num); end; else do; label.vol_size = rec_per_dev (dt.array (pvtx2).device_type); label.number_of_sv = 0; label.this_sv = 0; end; comloop: call fill_vol_extents_ (labelp, interlace, n_vtoce, baseadd, num_pages, "0"b, (dev_type2), code); if code ^= 0 then return; call initializer_gate_$disk_rebuild (pvtx1, pvtx2, labelp, opt_bits, interlace, code); return; ERR: call com_err_ (code, "rebuild_disk", "Error in rebuild of volume ^a.", dt.array (pvtx1).pvname); return; %page; %include disk_pack; %page; %include disk_table; %page; %include fs_vol_label; %page; %include fs_dev_types; /* BEGIN MESSAGE DOCUMENTATION Message: rebuild_disk: volume PVNAME from DSKA_XX onto DSKA_YY .br Current disk parameters: .br part NAME FREC NREC .br Vtoc size is XX, ave. seg length = Y.ZZZ .br Current number of VTOCEs = XX S: $initializer_io T: $response M: This is the response to the operator command "rebuild_disk" issued in ring 1. A: $ignore Message: rebuild_disk: Volume PVNAME must be mounted before rebuilding S: $initializer_io T: $response M: The rebuild_disk command was invoked on an mounted volume. Only volumes which are mounted may be rebuilt. No action was taken. A: Salvage the volume first, and then reissue the rebuild_disk command. Message: New starting parameters (no partitions defined): S: $initializer_io T: $response M: This message requests the input of new disk parameters. A: Input the new disk parameters. Use the "end" request when done. Message: Cannot shrink VTOC from XX to YY VTOCEs. Respecify parameters. S: $initializer_io T: $response M: An attempt has been made to shrink the VTOC, which is illegal. A: Respecify the parameters. Message: rebuild_disk: Error XX in rebuild of volume PVNAME. S: $initializer_io T: $response M: An error has occurred trying to rebuild the disk. The new copy should not be used. A: If the problem can be repaired, repair it and try again. $inform END MESSAGE DOCUMENTATION */ end disk_rebuild_caller;  disk_table_.pl1 11/11/89 1102.4rew 11/11/89 0800.0 417762 /****^ *********************************************************** * * * 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(86-06-05,GJohnson), approve(86-06-05,MCR7387), audit(86-06-10,Martinson), install(86-07-17,MR12.0-1091): Correct error message documentation. 2) change(86-06-30,Fawcett), approve(86-06-30,MCR7383), audit(86-06-30,LJAdams), install(86-07-17,MR12.0-1097): Add support for subvolumes, 3380 and 3390. 3) change(88-04-18,Farley), approve(88-05-26,MCR7880), audit(88-06-07,Parisek), install(88-07-05,MR12.2-1052): Corrected problem in dry_run_mhv execution by removing the zeroing of the return error code in MHV, which was making the dry run appear to succeed. Also corrected several coding violations. END HISTORY COMMENTS */ /* format: style2,^inddcls,indcomtxt */ disk_table_: proc; /* DISK_TABLE_ - manage the system's Disk Table. This program is called by system_startup_ and sc_command_ to manage a table parallel to the PVT which contains the long names of volumes and various other management information. Atually this program is just message typing and arg counting.. see mdx for the real stuff. This program refers to "hv" and "hvol" which mean Hierarchy Volume. The new term is "Logical Volume", which means the same thing. See MTB-213 by Bernie Greenberg for the design. By Tom VanVleck, and Bernie Greenberg. Modified April 1976 by Greenberg for demounter, parallel drive assignment, new salv interface (28-4). Modified September 1976 by Greenberg for auto mhvs by lv_request, init_vol -no_reg. Modified December 1976 by Greenberg for dte.demounted, mhv drive selector recoded. Modified March 1977 by Greenberg for init_vol -copy, ss_io_reconfig. Modified February 1977 by Greenberg for init_vol -copy. Modified July 1977 by T. Casey to add set_lv_pdir_bit entry. Modified August 1981 by J. Bongiovanni to improve synchronization of the various copies of the disk table Modified December 1981 by J. Bongiovanni to allow mounting LVEs on mhv dry run Modified April 1982 by J. Bongiovanni for better init_vol argument parsing Modified 831122 by E. A. Ranzenbach for set_vacate_pdirs_bit entry. Modified 84-08-29 by EJ Sharpe for auto registration of RLV PVs during cold boot Modified 84-10-30 by EJ Sharpe for some minor fixes Modified 85-01-31 by Keith Loepere for real error codes. Modified 1985-04-02, BIM: don't suggest drives for non-demountable disks. Report missing root physical volumes at accept_rlv time. (Note that those messages will be repeated each time that system_startup_ calls $accept_rlv.) Modified 04/85 by RAF to support subvolumes. */ dcl (i, j) fixed bin, demount_problem bit (1), took bit (1), (lpv, llv, bfsw, ldrive) bit (1), /* for list entry */ copy_sw bit (1) aligned, rlv_sw bit (1) aligned, fb71 fixed bin (71), ap ptr, al fixed bin, bchr char (al) based (ap), pvap ptr, npv fixed bin, match_dtx fixed bin, /* Used in dt scan */ trial fixed bin, /* 1ce for no *offs, 2 for yes */ mhvtest_lvx fixed bin, /* for referencecounting vols */ tpvtx fixed bin, /* for mhv error drive */ last_sv fixed bin, pvname char (32), pvname1 char (32), lvname char (32), drive_arg char (8) aligned, publicstr char (10), drivea char (2), drive_id char (8), arg char (64), arg_list_ptr ptr, ignore_num fixed bin, ignore_ec fixed bin (35), ec fixed bin (35); dcl (a_pvname, a_copydrive, a_drive, a_lvname) char (*) parm; dcl new bit (1); /* TRUE if made new disk_table */ dcl sdtp ptr static init (null); dcl cu_$level_get entry (fixed bin); dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin, fixed bin (35)); dcl cu_$arg_list_ptr entry (ptr); dcl level fixed bin; dcl 1 pva (100) based (pvap) aligned, 2 pvname char (32), 2 device_type fixed bin, 2 pad fixed bin; dcl 1 pvinfo aligned like pv_registration; dcl ( ARG1 fixed bin init (1), ARG2 fixed bin init (2), STOP_MOUNT fixed bin init (1), START_DEMOUNT fixed bin init (2), FINISH_DEMOUNT fixed bin init (3) ) internal static options (constant); dcl ( ioa_, ioa_$rsnnl ) entry options (variable); dcl com_err_ entry options (variable); dcl hcs_$make_seg entry (char (*), char (*), char (*), fixed bin (5), ptr, fixed bin (35)); dcl disk_table_$accept_rlv entry (fixed bin (35)); dcl lv_request_$dhv entry (char (*)); dcl lv_request_$mhv_complete entry (fixed bin, ptr); dcl disk_rebuild_caller entry (ptr, fixed bin, fixed bin, bit (36) aligned); dcl initializer_mdc_$rlvolcheck entry (fixed bin, fixed bin, bit (36) aligned, fixed bin (35)); dcl initializer_mdc_$init entry (ptr, bit (1), fixed bin (35)); dcl initializer_mdc_$get_lv_pvinfo entry (char (*), ptr, fixed bin, fixed bin, fixed bin (35)); dcl initializer_mdc_$mhv entry (fixed bin, fixed bin, fixed bin (35)); dcl initializer_mdc_$demount_lv entry (fixed bin, fixed bin, fixed bin (35)); dcl initializer_mdc_$demount_pv entry (fixed bin, fixed bin (35)); dcl initializer_mdc_$take entry (char (*), fixed bin, bit (1), fixed bin (35)); dcl initializer_mdc_$assert entry (char (*), fixed bin, fixed bin (35)); dcl initializer_mdc_$volsalv entry (char (*), fixed bin, bit (36) aligned, fixed bin (35)); dcl initializer_mdc_$forget entry (fixed bin, fixed bin (35)); dcl initializer_mdc_$set_lv_pdir_bit entry (char (*), bit (1) aligned, fixed bin (35)); dcl initializer_mdc_$set_vacate_pdirs_bit entry (char (*), bit (1) aligned, fixed bin (35)); dcl initializer_mdc_$ss_io_reconfig entry (fixed bin, bit (1) aligned, fixed bin (35)); dcl init_disk_pack_ entry (ptr, ptr, fixed bin, ptr, fixed bin (35)); dcl init_disk_pack_$parse_args entry (ptr, char (*), char (*), bit (1) aligned, bit (1) aligned, fixed bin (35)); dcl initializer_mdc_$read_disk_table entry (ptr, fixed bin (35)); dcl volume_registration_mgr_$add_pvr entry (char (*), ptr, fixed bin (35)); dcl disk_table_$accept_all entry (fixed bin (35)); dcl mdx$reregister entry (char (*), fixed bin, fixed bin (35)); dcl (addr, clock, length, null, rtrim, substr, unspec, char, verify) builtin; dcl error_table_$unregistered_volume fixed bin (35) ext; dcl error_table_$action_not_performed fixed bin (35) ext; /* ======================================================== */ init: entry (rc); /* called by system_startup_ */ dcl rc fixed bin (35); /* errcode */ dcl rce bit (1); /* sw for rc entries */ rce = "1"b; call initializer_mdc_$init (sdtp, new, rc); if new then call com_err_ (rc, "disk_table_", "New disk_table created"); else if rc ^= 0 then call com_err_ (rc, "disk_table_", ""); return; /* -------------------------------------------------------- */ accept_all: entry (rc); rce = "1"b; rc = 0; call copy_disk_table (); do i = 1 to dt.n_entries; dtep = addr (dt.array (i)); if ^dte.used then /* Take only unused volumes */ if dte.storage_system & ^dte.deleted then if dte.known | dte.pre_accepted then do; call initializer_mdc_$take ((dte.pvname), i, took, ec); if ec ^= 0 then call print_error; if ec ^= 0 then rc = ec; /* Remember if any screwed up */ else if took & dte.lvx ^= 1 then call announce_mount ((dte.lvx)); end; end; return; /* -------------------------------------------------------- */ general_mhv: entry (rc); /* Entry to induce a general mhv, and report results */ rce = "1"b; call mhv ("-all"); /* start the mhvs */ call copy_disk_table (); do i = 1 to dt.n_lv_entries; /* Scan the lve array */ lvep = addr (dt.lv_array (i)); if lve.used & ^lve.hv_mounted & ^lve.demounted_only then do; rc = error_table_$action_not_performed; call com_err_ (0, "disk_table_", "Some volumes are incomplete. Complete or demount them."); return; end; end; rc = 0; return; accept_rlv: entry (rc); /**** NOTE: this procedure does not do the "find a free drive and request a mount" thing that the normal "alv" command does. Operators must always tell US where root LV pv's are to be found. Could/should this be changed? --BIM */ rce = "1"b; rc = 0; call copy_disk_table (); call initializer_mdc_$mhv ((dt.array (dt.rpvx).lvx), tpvtx, rc); ec = rc; if rc ^= 0 then do; if tpvtx > 0 then do; dtep = addr (dt.array (tpvtx)); call print_error; /* Still return the code and prevent exit to ring 4 */ end; else call list_missing_rlv_pvs; /* whether code is 1 (missing vol) or something else, the call to get_lv_pvinfo will detect it. */ /* our caller just tests the code for 0 */ rc = 1; end; return; list_missing_rlv_pvs: procedure; call copy_disk_table (); call initializer_mdc_$get_lv_pvinfo ("root", pvap, npv, ignore_num, ec); /* Read the registry */ if ec ^= 0 then do; /* Impossible! */ call com_err_ (ec, "disk_table_", "Cannot get volume registration info for the root logical volume.^/ Shutdown and reboot with ""boot nolv""." ); return; end; call ioa_ ("The root logical volume is incomplete."); call MHV ("root", "0"b, 0); /* Find some drives, print some messages */ return; end list_missing_rlv_pvs; accept: entry; rce = "0"b; call cu_$arg_ptr (ARG1, ap, al, ec); if ec ^= 0 then go to gruz; if bchr = "-all" | bchr = "-a" then do; call disk_table_$accept_all (ignore_ec); return; end; pvname = bchr; call cu_$arg_ptr (ARG2, ap, al, ec); if ec ^= 0 then do; gruz: call com_err_ (ec, "disk_table_", ""); ret: if rce then rc = ec; return; end; call parse_drive_id (bchr); call verify_drive; /* check drive for free */ call initializer_mdc_$take (pvname, i, took, ec); call copy_disk_table (); if ec ^= 0 then call print_error; else if took then call announce_mount ((dte.lvx)); else if dt.array (i).used then if dt.array (i).lvx ^= 1 then call ioa_ ("added pv ^a to mounted lv ^a.", pvname, dt.lv_array (dt.array (i).lvx).lvname); return; mount_hvol: mhv: entry options (variable); rce = "0"b; call cu_$arg_ptr (ARG1, ap, al, ec); if ec ^= 0 then go to gruz; call copy_disk_table (); if bchr = "-all" | bchr = "-a" then do; do j = 1 to dt.n_lv_entries; lvep = addr (dt.lv_array (j)); if lve.used & ^lve.hv_mounted & ^lve.demounted_only then do; call mhv ((lve.lvname)); call copy_disk_table (); end; end; return; end; lvname = bchr; j = 0; /* -1 suppresses lve creation */ call initializer_mdc_$get_lv_pvinfo (lvname, pvap, npv, j, ec); if ec ^= 0 then do; call com_err_ (ec, "disk_table_", "^a", lvname); return; end; call copy_disk_table (); lvep = addr (dt.lv_array (j)); if lve.hv_mounted then do; call com_err_ (0, "disk_table_", "lv ^a already mounted", lvname); return; end; else if lve.demounting then do; call com_err_ (0, "disk_table_", "lv ^a cannot be mounted, in process of demount.", lvname); return; end; call initializer_mdc_$mhv (j, tpvtx, ec); call copy_disk_table (); if ec = 0 then do; call announce_mount (j); return; end; else if tpvtx > 0 then do; dtep = addr (dt.array (tpvtx)); call print_error; end; call MHV (lvname, "0"b, 0); /* test is off */ return; /* --------------------------------------------------------- */ dry_run_mhv: entry (a_lvname, rc); lvname = a_lvname; rce = "1"b; j = 0; call initializer_mdc_$get_lv_pvinfo (lvname, pvap, npv, j, ec); if ec ^= 0 then do; rc = ec; /* He'll get tired after a while */ return; end; rc = 0; /* show initial success */ /* do NOT copy disk table -- lv_request_ is munging current copy for test purposes */ dtp = sdtp; do i = 1 to dt.n_lv_entries while (dt.lv_array (i).lvname ^= lvname); end; if i > dt.n_lv_entries then do; /* Put phony one in there */ dt.n_lv_entries = i; lvep = addr (dt.lv_array (i)); unspec (lve) = "0"b; lve.lvname = lvname; end; mhvtest_lvx = i; dt.lv_array (mhvtest_lvx).mounting = "1"b; /* Note elegant effect upon mhvver */ call MHV (lvname, "1"b, mhvtest_lvx); /* this sets rc */ return; /**** Assume that pva and npv are set on entry to this procedure */ MHV: procedure (lvname, mhvtest, mhvtest_lvx); declare mhvtest bit (1) aligned; declare mhvtest_lvx fixed bin; declare lvname char (*); do i = 1 to npv; call MHV_ONE_PV; end; return; MHV_ONE_PV: procedure; /* i is global parm (ycch) specifying which pv */ declare (found, found_good_drive) bit (1) aligned; pvname = pva (i).pvname; /* for calls &c */ found = "0"b; /* set to one iff we find it mounted */ found_good_drive = "0"b; /* set to one iff we have a drive in mind to mount it on */ /**** NOTE: the following assumes that there can only be one dte with a given PV name in the entire disk table. */ do j = 1 to dt.n_entries while (^found & ^found_good_drive); dtep = addr (dt.array (j)); if dte.pvname = pvname then if dte.used | dte.known then found = "1"b; /* its already mounted */ else if dte.pre_accepted | dte.demounted then found_good_drive = "1"b; /**** + ASSUME: pv names are unique across the system. no pv can be listed twice in the disk table. THEN: if this entry has our pv name, is available for storage system use, then it will be either already known (test above) or free, since no other LV could claim it. Thus it is the last place that we saw this disk pack. Since disk packs are notorious for their tendency to stay where one leaves them, we should tell the operator to spin it up HERE. */ else if dte.storage_system & ^dte.deleted & (dte.device_type = pva (i).device_type) then found_good_drive = "1"b; end; if ^found then do; if ^found_good_drive & media_removable (pva (i).device_type) /* we can search for a good drive for 451's */ /* for non-demountables we either know where it was */ /* or stay mute, to avoid fatuous suggestions. */ then do trial = 1 to 3 while (^found_good_drive); do j = 1 to dt.n_entries while (^found_good_drive); dtep = addr (dt.array (j)); /* Here are usability criteria */ if dte.storage_system & ^dte.deleted /** available at all */ & ^(dte.used | dte.known) /** not in use already */ & dte.device_type = pva (i).device_type /** the right kind */ then if (^(dte.pre_accepted & dt.lv_array (dte.lvx).mounting) /** we can't be planning to mount something else here */ | (mhvtest & dt.lv_array (dte.lvx).good_candidate)) /** unless this is a dry run and we propose to demount this lv */ & ^((trial = 1) & dte.demounted) /** dont unseat in pass 1, we might mount it again */ & ^((trial < 3) & dte.pre_accepted) /** we are trying to mount something else here */ then found_good_drive = "1"b; end; end; /**** We arrive here directly if the first loop found that the drive that the pack used to be on is available. In that case found_good_drive will be on. If the first loop found nothing, then found_good_drive will be on if the second loop found a place to put the pack. For a non-demountable pack, the second loop does not run, and we never set found_good_drive. */ if found_good_drive then do; j = j - 1; /* both loops fall out of the bottom after do has bumped the index */ /* dtep is ok */ if mhvtest then do; /* claim tbl spot */ dte.pre_accepted = "1"b; dte.demounted = "0"b; dte.lvx = mhvtest_lvx; dte.pvname = pvname; end; else do; /* assume for real */ if dte.pre_accepted then ec = 0; else do; call initializer_mdc_$assert (pvname, j, ec); call copy_disk_table; if ec ^= 0 then call print_error; end; if ec = 0 then call ioa_ ("mount pack ^a on ^a", dte.pvname, dte.drive_name); end; end; /* End of found_good_drive case */ else if media_removable (pva (i).device_type) then do; /* If we couldn't suggest a drive for a 451, its an error. */ if mhvtest then do; /* no drive avl */ rc = 1; /* experiment failed */ return; end; else call ioa_ ("disk_table_: no drive available for ^a of ^a", pvname, lvname); end; else do; /* its a fixed disk, so we report the problem and claim success. The site must have a home for it someplace */ if mhvtest then /* only mhvtest has an rc */ rc = 0; call ioa_ ("mount pack ^a.", pva (i).pvname); end; end; return; end MHV_ONE_PV; end MHV; /* ------------------------------------------------------- */ get_dtp: entry returns (ptr); rce = "0"b; call copy_disk_table (); return (dtp); /* -------------------------------------------------------- */ set_lv_pdir_bit: entry (a_lvname, a_bit, rc); dcl a_bit bit (1) aligned parm; rce = "1"b; call initializer_mdc_$set_lv_pdir_bit (a_lvname, a_bit, rc); call copy_disk_table (); return; /* -------------------------------------------------------- */ set_vacate_pdirs_bit: entry (a_lvname, a_bit, rc); rce = "1"b; call initializer_mdc_$set_vacate_pdirs_bit (a_lvname, a_bit, rc); call copy_disk_table (); return; /* -------------------------------------------------------- */ initialize_disk: entry; rce = "0"b; call cu_$arg_list_ptr (arg_list_ptr); call init_disk_pack_$parse_args (arg_list_ptr, drive_id, pvname1, copy_sw, rlv_sw, ec); if ec ^= 0 then goto ret; call parse_drive_id (drive_id); if copy_sw then pvname = ""; else pvname = pvname1; call verify_drive; /* Check drive not in use, pvname not is use, set ptrs */ if copy_sw then do; do j = 1 to dt.n_entries while ( ^(dt.array (j).pvname = pvname1 & dt.array (j).storage_system & (dt.array (j).used | dt.array (j).known | dt.array (j).pre_accepted))); end; if j > dt.n_entries then do; call ioa_ ("disk_table_: ^a not found.", pvname1); return; end; dtep = addr (dt.array (j)); end; else do; call initializer_mdc_$assert (pvname1, i, ec); if ec = error_table_$unregistered_volume & rlv_sw then do; /* rlv_sw will be on if operator supplied the "-rlv" control to "init_vol" AND if we're running in ring 1 AND we're in the midst of a cold boot. We will automatically register the PV on the root LV. This will allow the initial system to have a multi pack RLV. */ fb71 = clock (); pvinfo.pvid = substr (unspec (fb71), 36, 36); pvinfo.model = dte.device_type; /* will be stuck with this */ pvinfo.pvname = pvname1; pvinfo.location = drive_id; pvinfo.mfg_serial = "registered at cold boot"; pvinfo.date_registered = fb71; pvinfo.password = ""b; /* register the PV */ call volume_registration_mgr_$add_pvr ("root", addr (pvinfo), ec); if ec ^= 0 then do; call print_error; /* nothing we can do, must retry cold boot */ return; end; call initializer_mdc_$assert (pvname1, i, ec); /* try it again, with registration */ end; call copy_disk_table (); if ec ^= 0 then do; call print_error; return; end; end; call init_disk_pack_ (dtp, dtep, i, arg_list_ptr, ec); return; /* ------------------------------------------------------- */ reregister: entry; rce = "0"b; call cu_$level_get (level); if level ^= 1 then do; call ioa_ ("disk_table_: cannot reregister from ring 4"); return; end; call cu_$arg_ptr (ARG1, ap, al, ec); if ec ^= 0 then go to gruz; pvname = bchr; call cu_$arg_ptr (ARG2, ap, al, ec); if ec ^= 0 then go to gruz; call parse_drive_id (bchr); call verify_drive; /* Check drive not in use */ call mdx$reregister (pvname, i, ec); if ec ^= 0 then if ec < 100 then call print_error; else call com_err_ (ec, "disk_table_", "error reregistering ^a", drive_arg); return; /* -------------------------------------------------------- */ demount_hvol: entry; dhv: entry (a_lvname); rce = "0"b; call cu_$arg_ptr (ARG1, ap, al, ec); if ec ^= 0 then go to gruz; lvname = bchr; call copy_disk_table (); do j = 1 to dt.n_lv_entries while (^dt.lv_array (j).used | (dt.lv_array (j).lvname ^= lvname)); end; if j > dt.n_lv_entries then do; call com_err_ (0, "disk_table_", "lv ^a not found", lvname); return; end; lvep = addr (dt.lv_array (j)); if lve.mounting then do; call initializer_mdc_$demount_lv (j, STOP_MOUNT, ec); call copy_disk_table (); if ec ^= 0 then do; call com_err_ (ec, "disk_table_", "cannot stop mount of ^a", lvname); return; end; call lv_request_$dhv (lvname); call copy_disk_table (); if lve.demounting & lve.lvname = lvname /* potential interlock? */ then call ioa_ ("disk_table_: demounting partially mounted volume ^a", lvname); else do; call ioa_ ("mount of ^a stopped", lvname); return; end; end; else if lve.demounting then call ioa_ ("continuing demount of lv ^a", lvname); else if ^lve.hv_mounted then do; call ioa_ ("lv ^a is not mounted", lvname); return; end; else if lve.pdirs_ok then do; call ioa_ (" lv ^a may contain process directories. Will not be demounted.", lvname); return; end; else do; call lv_request_$dhv (lvname); call initializer_mdc_$demount_lv (j, START_DEMOUNT, ec); call copy_disk_table (); if ec ^= 0 then do; call com_err_ (ec, "disk_table_", "Cannot demount lv ^a.", lvname); return; end; end; demount_problem = "0"b; do i = 1 to dt.n_entries; dtep = addr (dt.array (i)); if (dte.lvx = j) & dte.used & dte.storage_system then do; call initializer_mdc_$demount_pv (i, ec); call copy_disk_table (); if ec ^= 0 then do; demount_problem = "1"b; call com_err_ (ec, "disk_table_", "Could not demount pv ^a of lv ^a (^a)", dte.pvname, lve.lvname, dte.drive_name); end; end; end; if demount_problem then call com_err_ (0, "disk_table_", "Could not finish demount of lv ^a", lvname); else do; call initializer_mdc_$demount_lv (j, FINISH_DEMOUNT, ec); call copy_disk_table (); if ec ^= 0 then call com_err_ (ec, "disk_table_", "Could not finish demount of lv ^a", lvname); else call ioa_ ("demounted lv ^a", lvname); end; return; /* -------------------------------------------------------- */ remove: entry; rce = "0"b; call cu_$arg_ptr (1, ap, al, ec); if ec ^= 0 then go to gruz; if bchr = "-all" | bchr = "-a" then do; call copy_disk_table (); do i = 1 to dt.n_entries; dtep = addr (dt.array (i)); if dte.storage_system & ^dte.deleted & ^dte.used & (dte.known | dte.pre_accepted) then do; call initializer_mdc_$forget (i, ec); call copy_disk_table (); end; end; return; end; call parse_drive_id (bchr); call copy_disk_table (); do i = 1 to dt.n_entries; dtep = addr (dt.array (i)); if dte.drive_name = drive_arg then do; if ^dte.storage_system then call ioa_ ("disk_table_: ^a is an IO drive", drive_arg); else if dte.deleted then call ioa_ ("disk_table_: ^a is deleted", drive_arg); else if dte.used then call ioa_ ("disk_table_: ^a in use with ^a", drive_arg, dte.pvname); else if dte.pre_accepted | dte.known then do; call initializer_mdc_$forget (i, ec); call copy_disk_table (); end; else call ioa_ ("disk_table_: ^a not in use.", dte.drive_name); return; end; end; call ioa_ ("disk_table_: cannot locate ^a", drive_arg); return; /* ------------------------------------------------------- */ io_ss_reconfig: entry; rce = "0"b; call cu_$arg_ptr (ARG1, ap, al, ec); if ec ^= 0 then go to gruz; call parse_drive_id (bchr); call cu_$arg_ptr (ARG2, ap, al, ec); if ec ^= 0 then go to gruz; if ^(bchr = "io" | bchr = "ss" | bchr = "storage_system") then do; call ioa_ ("disk_table_: ""^a"" is not ""io"", ""storage_system"", or ""ss"".", bchr); return; end; call copy_disk_table; do i = 1 to dt.n_entries while (substr (dt.array (i).drive_name, 1, 7) ^= drive_arg); end; if i > dt.n_entries then do; call ioa_ ("disk_table_: ^a not found.", drive_arg); return; end; if dt.array (i).is_sub_vol then do; last_sv = (i + dt.array (i).num_of_sv) - 1; end; else do; last_sv = i; end; do i = i to last_sv; call initializer_mdc_$ss_io_reconfig (i, (substr (bchr, 1, 1) = "i"), ec); call copy_disk_table (); if ec ^= 0 then call com_err_ (ec, "disk_table_"); end; return; /* --------------------------------------------------------- */ list: entry; rce = "0"b; lpv, llv, bfsw, ldrive = "0"b; call cu_$arg_ptr (ARG1, ap, al, ec); if ec = 0 then do; if bchr = "-pv" then do; lpv = "1"b; call cu_$arg_ptr (ARG2, ap, al, ec); if ec ^= 0 then go to gruz; arg = bchr; end; else if bchr = "-bf" | bchr = "-brief" then bfsw = "1"b; else if bchr = "-mounts" | bchr = "-mt" then do; call copy_disk_table; go to list_hvols; end; else if bchr = "-lv" | bchr = "-hv" then do; llv = "1"b; call cu_$arg_ptr (ARG2, ap, al, ec); if ec ^= 0 then go to gruz; arg = bchr; end; else do; ldrive = "1"b; call parse_drive_id (bchr); end; end; call copy_disk_table (); do i = 1 to dt.n_entries; dtep = addr (dt.array (i)); if ldrive & (dte.drive_name ^= drive_arg) then go to skip; lvep = addr (dt.lv_array (dte.lvx)); if lve.hv_mounted then lvname = lve.lvname; else call ioa_$rsnnl ("(^a)", lvname, ignore_num, lve.lvname); if ^dte.storage_system then if dte.deleted then if ldrive then call ioa_ ("^a (deleted io drive)", dte.drive_name); else ; else call ioa_ ("^a (io drive)", dte.drive_name); else if dte.deleted then if ldrive then call ioa_ ("^a deleted", drive_arg); else ; else do; if lpv & (^(dte.used | (dte.known | dte.pre_accepted)) | (dte.pvname ^= arg)) then go to skip; if llv & ((^lve.used) | (lve.lvname ^= arg)) then go to skip; if dte.used then call ioa_ ("^a ^8a ^8a", dte.drive_name, dte.pvname, lvname); else if dte.known then call ioa_ ("^a ^8a ^8a ***", dte.drive_name, dte.pvname, lvname); else if dte.pre_accepted then call ioa_ ("^a ^8a ^8a *", dte.drive_name, dte.pvname, lvname); else if llv | bfsw then go to skip; else call ioa_ ("^a", dte.drive_name); end; skip: end; if llv | lpv | ldrive then return; /* List out mounts and demounts in progresss */ list_hvols: do i = 1 to dt.n_lv_entries; lvep = addr (dt.lv_array (i)); if lve.public then publicstr = "public"; else publicstr = "private"; if lve.mounting then call ioa_ ("^7a lv ^a mount in progress", publicstr, lve.lvname); if lve.demounting then call ioa_ ("^7a lv ^a demount in progress", publicstr, lve.lvname); end; return; /* --------------------------------------------------------------- */ volsalv: entry (a_pvname, a_drive, salv_opt_bits, rc); rce = "1"b; pvname = a_pvname; ap = addr (a_drive); al = length (a_drive); rc = 1; call parse_drive_id (bchr); if salv_opts.check then do; call disk_table_$accept_rlv (ec); if ec ^= 0 then do; call copy_disk_table (); go to ret; end; end; call verify_drive; /* change args to dtx */ call initializer_mdc_$volsalv (pvname, i, salv_opt_bits, ec); call copy_disk_table (); if ec > 0 & ec < 100 then do; call print_error; ec = error_table_$action_not_performed; end; rc = ec; return; /* ------------------------------------------------------- */ volsalvall: entry (salv_opt_bits, rc); rce = "1"b; if salv_opts.check then do; call disk_table_$accept_rlv (ec); if ec ^= 0 then do; call copy_disk_table (); go to ret; end; end; call copy_disk_table (); do i = 1 to dt.n_entries; dtep = addr (dt.array (i)); if ^dte.used then if dte.storage_system & ^dte.deleted & ^dte.used & (dte.known | dte.pre_accepted) then do; pvname = dte.pvname; call initializer_mdc_$volsalv (pvname, i, salv_opt_bits, ec); if ec ^= 0 then if ec < 100 then call print_error; else call com_err_ (ec, "disk_table_", "salvaging ^a on ^a", pvname, dte.drive_name); end; end; call copy_disk_table (); return; /* -------------------------------------------------------------------- */ volrlvcheck: entry (a_pvname, a_drive, a_copydrive, salv_opt_bits, rc); dcl rbldsw bit (1) aligned; rbldsw = "0"b; goto copy_vol; rbld_disk: entry (a_pvname, a_drive, a_copydrive, salv_opt_bits, rc); rbldsw = "1"b; copy_vol: rce = "1"b; call copy_disk_table (); ap = addr (a_copydrive); al = length (a_copydrive); rc = 1; call parse_drive_id (bchr); pvname = ""; /* verify object drive */ call verify_drive; j = i; if dte.pre_accepted then call initializer_mdc_$forget (j, ignore_ec); pvname = a_pvname; ap = addr (a_drive); al = length (a_drive); call parse_drive_id (bchr); do i = 1 to dt.n_entries; if dt.array (i).drive_name = drive_arg then go to vlrlvc1; end; call com_err_ (0, "disk_table_", "cannot locate ^a", drive_arg); rc = 4; return; vlrlvc1: dtep = addr (dt.array (i)); if dte.used & (dte.pvname = pvname) then ; else do; call verify_drive; call initializer_mdc_$take (pvname, i, took, rc); if rc ^= 0 then do; call copy_disk_table (); return; end; end; call copy_disk_table (); dtep = addr (dt.array (i)); if ^rbldsw then if dte.lvx ^= 1 then do; call com_err_ (0, "disk_table_", "^a is not part of root volume", pvname); return; end; rc = 0; if salv_opts.check then do; call disk_table_$accept_rlv (ec); if ec ^= 0 then do; call copy_disk_table (); go to ret; end; end; call copy_disk_table (); if rbldsw then call disk_rebuild_caller (dtp, i, j, salv_opt_bits); else call initializer_mdc_$rlvolcheck (i, j, salv_opt_bits, rc); return; /* --------------------------------------------------------------- */ salv_flag: entry () returns (bit (1)); rce = "0"b; call copy_disk_table (); do i = 1 to dt.n_entries; dtep = addr (dt.array (i)); if dte.storage_system & ^dte.deleted & dte.used & (dte.lvx = 1) then if dte.need_salvage then return ("1"b); end; return ("0"b); /* All clean */ parse_drive_id: proc (drive_id); dcl drive_id char (*); dcl id_len fixed bin; id_len = length (rtrim (drive_id)); if char (drive_id, 3) ^= "dsk" | id_len < 7 then do; faugh: call ioa_ ("disk_table_: invalid drive id ""^a""", drive_id); ec = 10; go to ret; end; if id_len >= 9 then goto faugh; drive_arg = drive_id; if substr (drive_id, 5, 1) ^= "_" then go to faugh; drivea = substr (drive_id, 6, 2); if drivea = "" then go to faugh; if verify (drivea, "0123456789") ^= 0 then go to faugh; if id_len = 8 then do; if verify (substr (drive_id, 8, 1), valid_sv_string) ^= 0 then goto faugh; end; end parse_drive_id; verify_drive: procedure; /* Int proc to check not-in-use drive */ call copy_disk_table (); match_dtx = -1; do i = 1 to dt.n_entries; /* Search for named volume */ dtep = addr (dt.array (i)); if ^dte.storage_system & (drive_arg = dte.drive_name) then do; call ioa_ ("disk_table_: ^a is an IO drive", drive_arg); ec = 5; go to ret; end; else if dte.deleted & (drive_arg = dte.drive_name) then do; call ioa_ ("disk_table_: ^a is deleted", drive_arg); ec = 4; go to ret; end; else if dte.used then do; if dte.pvname = pvname then do; /* If already in table, error */ call ioa_ ("disk_table_: ^a already in use on ^a.", pvname, dte.drive_name); ec = 1; go to ret; end; else if dte.drive_name = drive_arg then do; /* if somebody else on there */ call ioa_ ("disk_table_: ^a in use: contains ^a", drive_arg, dte.pvname); ec = 2; go to ret; end; else ; end; else if dte.known & (dte.pvname = pvname) & (dte.drive_name ^= drive_arg) then do; call ioa_ ("disk_table_: ^a currently known to be on ^a.", pvname, dte.drive_name); ec = 3; go to ret; end; else if dte.drive_name = drive_arg then match_dtx = i; /* Unused */ end; if match_dtx > 0 then do; /* If we found it */ dtep = addr (dt.array (match_dtx)); i = match_dtx; return; end; call ioa_ ("disk_table_: cannot locate ^a", drive_arg); ec = 4; go to ret; end verify_drive; print_error: proc; call com_err_ (ec, "disk_table_", "Cannot verify label of ^a", dte.drive_name); end print_error; copy_disk_table: proc (); /* This internal procedure is called whenever a fresh copy of the disk_table is needed in the user ring... */ call cu_$level_get (level); if level = 1 then dtp = sdtp; else do; if sdtp = null then call hcs_$make_seg ("", "", "", 1011b, sdtp, ignore_ec); dtp = sdtp; call initializer_mdc_$read_disk_table (dtp, ignore_ec); end; pvap = addr (dt.lv_array (dt.max_n_entries + 1)); end copy_disk_table; announce_mount: proc (lvxa); dcl lvxa fixed bin; call ioa_ ("lv ^a mounted", dt.lv_array (lvxa).lvname); if lvxa ^= 1 then /* Not for the root */ call lv_request_$mhv_complete (lvxa, dtp); end; %include fs_dev_types; %include disk_table; %include salv_options; %include volume_registration; /* BEGIN MESSAGE DOCUMENTATION Message: disk_table_: no drive available for PVNAME LVNAME S: $initializer_io T: $run M: An alv LVNAME command was unable to allocate a drive for PVNAME. A: Demount some un-needed logical volume and try again. Message: disk_table_: PVNAME not found. S: $initializer_io T: $run M: An initialize_disk -copy command could not find the source volume. A: $tryagn Message: disk_table_: cannot reregister from ring 4 S: $initializer_io T: $run M: A reregister command was issued from ring 4. A: $tryagn Message: disk_table_: demounting partially mounted volume LVNAME S: $initializer_io T: $run M: The operator issued a dlv LVNAME command for a logical volume for which a previous dlv command did not succeed. A: $ignore Message: mount of LVNAME stopped S: $initializer_io T: $run M: The operator issued a dlv LVNAME command for a volume which was being mounted. A: $ignore Message: lv LVNAME is not mounted S: $initializer_io T: $run M: The operator issued a dlv LVNAME command but LVNAME was not mounted. A: $tryagn Message: continuing demount of lv LVNAME S: $initializer_io T: $run The operator issued a dlv command for a logical volume for which a previous dlv command failed. A: $ignore Message: demounted lv LVNAME S: $initializer_io T: $run M: The demount of the logical volume LVNAME is complete. A: $ignore Message: disk_table_: DRIVENAME is an IO drive S: $initializer_io T: $run M: The operator issued a del_vol command but the drive is an IO drive. A: $tryagn Message: disk_table_: DRIVENAME is deleted S: $initializer_io T: $run M: A del_vol command was issued but the drive has been deleted. A: $tryagn Message: disk_table_: DRIVE in use with PVNAME S: $initializer_io T: $run M: A del_vol DRIVE command was issued but the drive is currently in use. A: $tryagn To demount the pack, use the dlv command. Message: disk_table_: DRIVE not in use. S: $initializer_io T: $run M: A del_vol command was issued but nothing is on the drive. A: $tryagn Message: disk_table_: cannot locate DRIVE S: $initializer_io T: $run M: A del_vol DRIVE command was issued but there is no such drive in the configuration. A: $tryagn Message: disk_table_: "KEY" is not "io", "storage_system", or "ss". S: $initializer_io T: $run M: The operator issued an set_drive_usage DRIVE KEY command. KEY is invalid. A: $tryagn Message: disk_table_: DRIVE not found. S: $initializer_io T: $run M: The operator issued an set_drive_usage DRIVE KEY command, but DRIVE is not in the current configuration. A: $tryagn Message: disk_table_: invalid drive id "ARG" S: $initializer_io T: $run M: The drive id ARG does not have the form dskX_NN. A: $tryagn Message: disk_table_: DRIVE is an IO drive S: $initializer_io T: $run M: A command has been issued to affect DRIVE, but it is currently in use as an IO drive. A: $tryagn Use the set_drive_usage command to change it if necessary. Message: disk_table_: DRIVE is deleted S: $initializer_io T: $run M: The drive named is deleted. A: $tryagn Message: disk_table_: PVNAME already in use on DRIVE. S: $initializer_io T: $run M: An attempt to add a physical volume finds the volume already in use on another drive. A: $tryagn Message: disk_table_: DRIVE in use: contains PVNAME S: $initializer_io T: $run M: An attempt to use DRIVE finds it already in use. A: $tryagn Message: disk_table_: PVNAME currently known to be on DRIVE S: $initializer_io T: $run M: An attempt to specify that PVNAME is on a certain drive finds it on another drive. A: $tryagn Use the del_vol command if necessary to cause the system to forget DRIVE's old contents, if a pack has been moved. Message: disk_table_: cannot locate DRIVE S: $initializer_io T: $run M: A command specifying DRIVE was issued but no such drive can be found. A: $tryagn Message: lv LVNAME mounted S: $initializer_io T: $run M: The mounting of LVNAME is complete. A: $tryagn Message: disk_table_: ERROR_MESSAGE. New disk_table created S: $initializer_io T: $init M: The system has created a new copy of the segment >disk_table at initialization time. The copy from the previous bootload could not be found. The position of all previously mounted volumes has been forgotten. A: Use the av command to specify the position of all volumes, and the alv command to mount them. Message: disk_table_: ERROR_MESSAGE. S: $initializer_io T: $init M: An error has been returned from initializer_mdc_$init. $err Subsequent attempts to mount volumes may malfunction. A: $contact Message: disk_table_: Some volumes are incomplete. Complete or demount them. S: $initializer_io T: $init M: Initialization has failed to remount all the volumes which were previously known, in response to a startup command. A: Use the list_disks command to find out which volumes are incomplete. Use the av or dlv commands to rectify the situation, and try startup again. Message: disk_table_: ERROR_MESSAGE. Cannot get volume registration for the root logical volume. .brf Shutdown and reboot with "boot nolv". S: $initializer_io T: $init M: The system is unable to read the volume registration for the root logical volume, and cannot therefore determine if the root is complete. A: Shutdown. If you can mount the entire root, do so, describe all volumes on the root config card, "boot stan nosc", and fix the registration. If this fails, shutdown, and "boot nolv". Message: disk_table_: The root logical volume is incomplete. S: $initializer_io T: $init M: Some registered physical volume(s) of the root logical volume are not mounted, but the operator has attempted to execute a command that requires the root to be completely mounted. This message is followed by mount messages for the missing volumes. A: Mount the missing volumes, and notify the system of their location with the add_vol command. Message: disk_table_: ERROR_MESSAGE. S: $initializer_io T: $run M: An error has occurred in a storage system disk manipulation command. A: $tryagn Message: disk_table_: ERROR_MESSAGE. LVNAME S: $initializer_io T: $run M: An error occurred trying to get the list of physical volumes which comprise LVNAME. A: $tryagn Message: disk_table_: lv LVNAME already mounted S: $initializer_io T: $run M: An alv LVNAME command finds LVNAME already mounted. A: $tryagn Message: disk_table_: lv LVNAME cannot be mounted, in process of demount. S: $initializer_io T: $run M: An alv LVNAME command was issued but the logical volume is in the process of demounting. A: $tryagn Message: disk_table_: ERROR_MESSAGE. error reregistering DRIVE S: $initializer_io T: $run M: The reregister DRIVE command did not succeed. A: $tryagn Message: disk_table_: lv LVNAME not found S: $initializer_io T: $run M: A dlv LVNAME command was issued but no such logical volume is mounted. A: $tryagn Message: disk_table_: ERROR_MESSAGE. cannot stop mount of LVNAME S: $initializer_io T: $run M: A dlv LVNAME command was issued but an error prevents the dlv from working. A: $tryagn Message: disk_table_: ERROR_MESSAGE. Cannot demount lv LVNAME S: $initializer_io T: $run M: A dlv LVNAME command was issued but an error prevents the dlv from working. A: $tryagn Message: disk_table_: ERROR_MESSAGE. Could not demount pv PVNAME of lv LVNAME (DRIVE) S: $initializer_io T: $run M: An error occurred when trying to demount a physical volume. This may be due to process directory or wired segments being on this physical volume. The del_lv command will be partially successful when this happens. A: Determine which processes, if any, have process directories on this logical volume and bump or terminate them. Use list_disks to determine which volumes are still mounted, and try dlv again. $inform Message: disk_table_: Could not finish demount of lv LVNAME S: $initializer_io T: $run M: The system encountered a problem trying to delete the logical volume LVNAME. A: $inform Message: disk_table_: ERROR_MESSAGE. salvaging PVNAME on DRIVE S: $initializer_io T: $run M: An error occurred while doing a salvage_vol -all. A: $tryagn Message: disk_table_: cannot locate DRIVE S: $initializer_io T: $run M: A disk_rebuild command cannot locate the output drive. A: $tryagn Message: disk_table_: Cannot verify label of DRIVE: REASON S: $initializer_io T: $run M: An error occurred checking the label of DRIVE. Usually either the drive is not ready, or the pack label does not match the required pack label. A: $tryagn Message: disk_table_: ERROR_MESSAGE. Cannot verify label of DRIVE S: $initializer_io T: $run M: An error occurred checking the label of the pack on DRIVE. Usually either the drive is not ready, or the pack label does not match the required pack label. A: $tryagn Message: added pv PVNAME to mounted lv LVNAME. S: $initializer_io T: $run M: An av command was used to increase the size of a mounted volume. A: $ignore Message: mount pack PVNAME {on DRIVE} S: $initializer_io T: $run M: This message occurs when the system is attempting to mount a logical volume and finds one or more physical volumes have not been made known via the add_vol command. If the pack is a non-demountable volume, a DRIVE will only be printed if the system knows the drive on which the pack was previously mounted. If the pack is a demountable volume, then a DRIVE will be printed always. If the system does not know the drive on which the pack was last mounted, then it chooses a drive where the pack should be mounted and prints this message. A: Mount the pack specified. If it is not convenient to use the specified DRIVE, use another. Then use the add_vol command to tell the system that the physical volume has been mounted. When all packs have been mounted and either accepted via add_vol or are on the drives where the system called for them, issue a "alv LVNAME" command to accept them all at once. The logical volume will be put in use. END MESSAGE DOCUMENTATION */ end disk_table_;  init_disk_pack_.pl1 11/11/89 1102.4r w 11/11/89 0803.1 119448 /****^ *********************************************************** * * * 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. * * * *********************************************************** */ /****^ HISTORY COMMENTS: 1) change(86-01-16,Fawcett), approve(86-04-11,MCR7383), audit(86-05-29,LJAdams), install(86-07-17,MR12.0-1097): Add support for subvolumes, and 512_WORD_IO, 3380 and 3390. END HISTORY COMMENTS */ /* format: style3 */ init_disk_pack_$parse_args: proc (Arg_list_ptr, Drive_id, Pvname, Copy_flag, RLV_flag, Code); /* This procedure initializes a disk from Ring 1. Two cases are covered, either the disk is mounted, but not accepted, or a copy is being made of an accepted disk. It is passed the PVT index and a pointer to the disk_table entry. This procedure prepares the label from the disk table entry and data derived from interrogation of the operator, and calls init_vol_header_ to write the disk based on this info. Revised for init_vol_header_, fixing several bugs, BSG 06/25/76 Revised for fill_vol_extents_, forcing the latter to do all calculation, BSG 08/31/76 Revised for countervalidate_label_ BSG 12/1/76 Fixed not to assume pvtx and dtep correspond for Vol Backup, BSG 3/9/77 Modified by Mike Grady 9/79 to improve above fix Modified by J. Bongiovanni, April 1982, to add parse_args entry, general cleanup Modified '82 for english error codes Modified 84-09-24 by EJ Sharpe for "-rlv" arg and RLV_flag Modified 84-10-30 by EJ Sharpe to user convert_status_code_ and some minor fixes Modified 85-04-29 by EJ Sharpe to fix uninitialized copy_sw */ /* Parameter */ dcl Arg_list_ptr ptr parameter; /* Command arg list pointer */ dcl Drive_id char (*) parameter; /* Drive identifier (dskX_NN) */ dcl Pvname char (*) parameter; /* Physical volume name */ dcl Copy_flag bit (1) aligned parameter; /* ON => -copy specified */ dcl RLV_flag bit (1) aligned parameter; dcl Dtp ptr; /* -> disk table */ dcl Dtep ptr; /* -> disk table entry */ dcl Pvtx fixed bin; /* PVT index */ dcl Code fixed bin (35); /* Automatic */ dcl argl fixed bin (21); dcl argp ptr; dcl baseadd fixed bin; dcl conversation bit (1) aligned; dcl copy_sw bit (1) aligned; dcl dev_type fixed bin; dcl longerr char (100) aligned; dcl n_vtoce fixed bin; dcl no_reg_sw bit (1) aligned; dcl num_pages fixed bin; dcl pagep ptr; dcl pv_name char (32); dcl rlv_sw bit (1) aligned; dcl shorterr char (8) aligned; dcl thing char (20); /* Static */ dcl myname char (20) init ("init_disk_pack_") static options (constant); /* Based */ dcl arg char (argl) based (argp); dcl 1 buffer aligned like label; dcl page bit (36 * 1024) based (pagep); /* External */ dcl error_table_$badopt fixed bin (35) external; dcl error_table_$bad_label fixed bin (35) external; dcl sys_info$access_class_ceiling bit (72) aligned external; /* Builtin */ dcl addr builtin; dcl clock builtin; dcl null builtin; /* Entry */ dcl com_err_ entry options (variable); dcl config_$find entry (char(4) aligned, ptr); dcl convert_status_code_ entry (fixed bin(35), char(8) aligned, char(100) aligned); dcl countervalidate_label_$query entry (ptr, char (*), char (*), char (*)) returns (bit (1)); dcl cu_$arg_ptr_rel entry (fixed bin, ptr, fixed bin (21), fixed bin (35), ptr); dcl fill_vol_extents_ entry (ptr, fixed bin, fixed bin, fixed bin, fixed bin, bit (1) aligned, fixed bin (17), fixed bin (35)); dcl get_ring_ entry() returns(fixed bin(3)); dcl init_vol_header_ entry (fixed bin, fixed bin, ptr, entry, char (*), fixed bin, fixed bin, fixed bin, fixed bin (35)); dcl initializer_gate_$write_disk entry (fixed bin, fixed bin, ptr, fixed bin (35)); dcl initializer_gate_$read_disk entry (fixed bin, fixed bin, ptr, fixed bin (35)); dcl ioa_ entry options (variable); %page; /* Parse command arguments and return information to disk_table_ */ Code = 0; call cu_$arg_ptr_rel (1, argp, argl, Code, Arg_list_ptr); if Code ^= 0 then do; call com_err_ (Code, myname, "pvname"); return; end; Pvname = arg; call cu_$arg_ptr_rel (2, argp, argl, Code, Arg_list_ptr); if Code ^= 0 then do; call com_err_ (Code, myname, "drive_id"); return; end; Drive_id = arg; call PARSE_ARGS; Copy_flag = copy_sw; RLV_flag = rlv_sw; return; %page; /* Entry to do the work */ init_disk_pack_: entry (Dtp, Dtep, Pvtx, Arg_list_ptr, Code); dtp = Dtp; dtep = Dtep; labelp = addr (buffer); call PARSE_ARGS; pv_name = "read"; thing = "label"; call initializer_gate_$read_disk (Pvtx, LABEL_ADDR, labelp, Code); if Code ^= 0 then do; call com_err_ (Code, myname, "Cannot read current label of ^a.", (dt.array (Pvtx).drive_name)); return; end; if ^countervalidate_label_$query (labelp, (dte.pvname), myname, (dt.array (Pvtx).drive_name)) then do; Code = error_table_$bad_label; return; end; pagep = addr (buffer); page = "0"b; dev_type = dte.device_type; label.version = 1; label.mfg_serial = dte.pvname; /* Good enough for a start */ pv_name, label.pv_name = dte.pvname; label.time_registered = clock (); if dte.is_sub_vol then do; label.vol_size = rec_per_sv (dte.device_type); label.number_of_sv = dte.num_of_sv; label.this_sv = dte.sv_num; label.sub_vol_name = valid_sv_array (dte.sv_num); end; else do; label.vol_size = rec_per_dev (dte.device_type); /* use whole pack */ label.number_of_sv = 0; label.this_sv = 0; end; if ^no_reg_sw then do; label.pvid = dte.pvid; /* disk_table_ made this up */ lvep = addr (dt.lv_array (dte.lvx)); label.lvid = lve.lvid; /* Get from disk_table_. who searched. */ label.lv_name = lve.lvname; label.min_access_class = lve.min_access_class; label.max_access_class = lve.max_access_class; label.private = ^lve.public; end; else do; label.pvid, label.lvid = (36)"1"b; label.lv_name = ""; label.max_access_class = sys_info$access_class_ceiling; label.min_access_class = ""b; end; label.Multics = Multics_ID_String; label.password = ""b; label.root.disk_table_vtocx = -1; label.root.disk_table_uid = ""b; label.root_vtocx = 0; label.shutdown_state = 0; label.esd_state = 0; /* Fill volume defaults. Hold a dialogue if requested. */ call fill_vol_extents_ (labelp, -1, n_vtoce, baseadd, num_pages, ^conversation, dev_type, Code); /* -1 = no "lace" */ if Code ^= 0 then return; /* Write out the actual disk */ call init_vol_header_ (Pvtx, dev_type, pagep, initializer_gate_$write_disk, thing, n_vtoce, baseadd, num_pages, Code); if Code ^= 0 then do; call convert_status_code_ (Code, shorterr, longerr); call ioa_ ("^a: ^a ^a disk err ""^a"" on ^a", myname, dte.drive_name, pv_name, longerr, thing); end; else call ioa_ ("volume ^a ^d records", pv_name, num_pages); return; %page; /* Internal Procedure to do argument parsing */ PARSE_ARGS: proc; dcl code fixed bin (35); dcl arg_no fixed bin; conversation, no_reg_sw, rlv_sw, copy_sw = "0"b; code = 0; do arg_no = 3 repeat arg_no + 1 while (code = 0); call cu_$arg_ptr_rel (arg_no, argp, argl, code, Arg_list_ptr); if code = 0 then do; if arg = "-special" then conversation = "1"b; else if arg = "-copy" then conversation, copy_sw = "1"b; else if arg = "-no_reg" then conversation, no_reg_sw = "1"b; else if arg = "-rlv" then if ^( (get_ring_() = 1) & BOOTED_COLD () ) then do; Code = error_table_$badopt; call com_err_ (Code, myname, """-rlv"" allowed only at ring 1 during cold boot."); return; end; else rlv_sw = "1"b; else do; Code = error_table_$badopt; call com_err_ (Code, myname, arg); return; end; end; end; end PARSE_ARGS; %page; /* Internal procedure to determine if we're in middle of cold boot */ BOOTED_COLD: proc () returns (bit (1) aligned); intk_cardp = null (); call config_$find ("intk", intk_cardp); if intk_cardp = null () then do; call com_err_ (0, myname, "INTK card missing from config deck."); return ("0"b); end; else return (intk_card.warm_or_cold = "cold"); end BOOTED_COLD; %page; %include config_intk_card; %page; %include disk_pack; %page; %include disk_table; %page; %include fs_dev_types; %page; %include fs_vol_label; %page; /* BEGIN MESSAGE DOCUMENTATION Message: init_disk_pack_: Cannot read current label of DRIVE: ERROR_MESSAGE S: $initializer_io T: $response M: A disk error prevents checking the label of the pack on DRIVE. The pack may need to be formatted before it can be initialized. A: Take appropriate action. Message: init_disk_pack_: INTK card missing from config deck. S: $initializer_io T: $response M: When the operator specifies the "-rlv" control argument to "init_vol" this program attempts to verify that the system is in cold boot by inspecting the INTK card in the config deck. When this message appears, there is some difficulty in locating that card. A: If really trying to boot cold, try again. Message: init_disk_pack_: Specified control argument not accepted. "-rlv" allowed only at ring-1 during a cold boot. S: $initializer_io T: $response M: Automatic registration of root PVs is allowed only during a cold boot of Multics. A: Use the "add_volume_registration" administrative command to register the PV before attempting to initialize it. Message: init_disk_pack_: DRIVE PVNAME disk err WWWW on ITEM S: $initializer_io T: $response M: A disk error prevents writing the ITEM section of the disk volume PVNAME. A: Fix the drive, or use a new pack. Message: init_disk_pack_: Volume on DRIVE is Multics Storage System Volume "PVNAME", .br last used DATE_TIME. Do you wish to overwrite it? S: $initializer_io T: $response M: The init_disk command specifed a disk pack which has a valid Multics label. Initializing this pack will destroy all data contained on it. A: Do not answer yes unless you are sure that the pack contents should be destroyed. Check the pack serial number. Message: init_disk_pack_: Volume on DRIVE is a copy of Multics Storage System Volume "PVNAME", .br last used DATE_TIME. Do you wish to overwrite it? S: $initializer_io T: $response M: The init_disk command specifed a disk pack which has a valid Multics label. Another copy of PVNAME is currently in use. Initializing this pack will destroy all data contained on it. A: Do not answer yes unless you are sure that the pack contents should be destroyed. Check the pack serial number. Message: init_disk_pack_: Volume on DRIVE is a copy of pv "PVNAME", .br last used DATE_TIME. Do you wish to overwrite it? S: $initializer_io T: $response M: The init_disk command specifed a disk pack which has a valid Multics label. It appears to be a copy of a mounted pack. Initializing this pack will destroy all data contained on it. A: Do not answer yes unless you are sure that the pack contents should be destroyed. Check the pack serial number. Message: init_disk_pack_: Volume on DRIVE is an earlier instance of pv "PVNAME", .br last used DATE_TIME. Do you wish to overwrite it? S: $initializer_io T: $response M: The init_disk command specifed a disk pack which has a valid Multics label. Initializing this pack will destroy all data contained on it. A: Do not answer yes unless you are sure that the pack contents should be destroyed. Check the pack serial number. Message: init_disk_pack_: Volume on DRIVE is an unregistered pack named "PVNAME", .br last used DATE_TIME. Do you wish to overwrite it? S: $initializer_io T: $response M: The init_disk command specifed a disk pack which has a valid Multics label. Initializing this pack will destroy all data contained on it. A: Do not answer yes unless you are sure that the pack contents should be destroyed. Check the pack serial number. Message: init_disk_pack_: unrecognized argument: BLAH S: $initializer_io T: $response M: Illegal input was typed. A: $tryagn Message: volume PVNAME XX records S: $initializer_io T: $response M: The physical volume PVNAME has been successfully initialized. There are XX (decimal) records in the paging area. A: $ignore END MESSAGE DOCUMENTATION */ end init_disk_pack_$parse_args;  lv_request_communicator_.pl1 11/11/89 1102.4rew 11/11/89 0803.1 51255 /****^ *********************************************************** * * * 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. * * * *********************************************************** */ lv_request_communicator_$alloc_lvate: proc (a_ec) returns (ptr); /* Bernard Greenberg 9/8/76 */ /* Called by user-process RCP in ring 1, this procedure intermediates conversation with the lv_attach_table, talking to wdx in the Initializer process */ dcl 1 message based (addr (fixedmessage)), 2 text char (4) unal, 2 lvax fixed bin (17) unal, 2 other fixed bin (17) unal; dcl SYSDIR char (168) static init (">lv"); dcl LVAT_NAME char (32) static init ("lv_attach_table") options (constant); dcl (error_table_$action_not_performed, error_table_$noalloc) fixed bin (35) ext; dcl error_table_$resource_unassigned fixed bin (35) ext; dcl fixedmessage fixed bin (71) aligned; dcl vhighest_used fixed bin (35); dcl hcs_$wakeup ext entry (bit (36) aligned, fixed bin (71), fixed bin (71), fixed bin (35)); dcl hcs_$initiate entry (char (*), char (*), char (*), fixed bin (1), fixed bin (1), ptr, fixed bin (35)); dcl get_process_id_ entry (bit (36) aligned); dcl admin_gate_$syserr entry options (variable); dcl stac builtin; dcl stacq entry (ptr, bit (36) aligned, bit (36) aligned) returns (bit (1) aligned); dcl lvname char (32); dcl code fixed bin (35); dcl s_lvatp ptr static init (null); dcl processid bit (36) aligned static; dcl ec fixed bin (35); dcl lvax fixed bin; dcl a_lvatep ptr; dcl a_evch fixed bin (71) aligned; dcl a_lvname char (*); dcl a_ec fixed bin (35); dcl a_state fixed bin; dcl (null, rel, addr) builtin; /* */ if s_lvatp = null then do; call get_process_id_ (processid); call hcs_$initiate (SYSDIR, LVAT_NAME, "", 0, 0, lvatp, ec); if lvatp = null then do; a_ec = ec; return (null); end; s_lvatp = lvatp; end; lvatp = s_lvatp; do lvax = 1 to lvat.max_n_entries; lvatep = addr (lvat.array (lvax)); if stac (addr (lvate.pid), processid) then do; lll: vhighest_used = lvat.highest_used; if lvax > vhighest_used then if ^stacq (addr (lvat.highest_used), unspec (vhighest_used), unspec (lvax)) then go to lll; string (lvate.flags) = "0"b; a_ec = 0; return (lvatep); end; end; a_ec = error_table_$noalloc; return (null); intent_to_mount: entry (a_lvatep, a_lvname, a_evch, a_ec); lvatep = a_lvatep; lvatp = s_lvatp; lvname = a_lvname; if lvate.pid ^= processid then go to unas; string (lvate.flags) = "0"b; lvate.lvname = lvname; /* copy stuff first, */ lvate.evchn = a_evch; lvate.state = 0; lvate.code = 0; lvate.pending_mount = "1"b; /* flag is last */ call transmit ("moun"); /* give guy a zetz */ a_ec = 0; return; check: entry (a_lvatep, a_state, a_ec); lvatep = a_lvatep; lvatp = s_lvatp; if lvate.pid ^= processid then do; /* got snarfed */ unasa: a_state = 3; unas: a_ec = error_table_$resource_unassigned; return; end; if lvate.invalidated then go to unasa; if lvate.mount_req_answered then do; if lvate.waiting then a_state = 1; else if lvate.code ^= 0 then a_state = 3; else a_state = 0; a_ec = lvate.code; end; else do; /* No answer thru yet */ if lvate.pending_mount then a_state = 1; else a_state = 3; a_ec = 0; end; return; intent_to_detach: entry (a_lvatep, a_ec); lvatep = a_lvatep; lvatp = s_lvatp; if lvate.pid ^= processid | lvate.invalidated then go to unas; lvate.detach_requested = "1"b; call transmit ("demo"); a_ec = 0; return; abandon: entry (a_lvatep); lvatep = a_lvatep; lvatp = s_lvatp; string (lvate.flags) = "0"b; lvate.lvname = ""; if ^stacq (addr (lvate.pid), processid, "0"b) then call admin_gate_$syserr (0, "lv_request_communicator_: lock ^= processid lvate ^p", lvatep); return; transmit: procedure (m); dcl m char (*); message.text = m; message.lvax = 1 + divide (fixed (rel (lvatep), 18) - fixed (rel (addr (lvat.array)), 18), size (lvate), 17, 0); message.other = 0; call hcs_$wakeup (lvat.master_pid, lvat.master_evchn, fixedmessage, ec); if ec ^= 0 then do; call admin_gate_$syserr (0, "lv_request_communicator_: code ^o from wakeup", code); a_ec = error_table_$action_not_performed; go to nlx; end; end transmit; nlx: return; test: entry (testdir); dcl testdir char (*); SYSDIR = testdir; return; /* */ %include lv_atttbl; /* BEGIN MESSAGE DOCUMENTATION Message: lv_request_communicator_: lock ^= processid lvate PPP S: $info T: In response to a user's detach_lv command M: A logical volume attachment table entry became disassociated from a user to whom it had been assigned. $err A: $notify Be prepared to demount logical volumes manually which might otherwise have been demounted automatically. Message: lv_request_communicator_: code CCC from wakeup S: $info T: $run M: A wakeup could not be sent to the initializer process in order to perform communication about attachment/detachment of logical volumes. A: $notify END MESSAGE DOCUMENTATION */ end;  mdx.pl1 11/11/89 1102.4r w 11/11/89 0803.2 323658 /****^ *********************************************************** * * * 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. * * * *********************************************************** */ /****^ HISTORY COMMENTS: 1) change(86-06-05,GJohnson), approve(86-06-05,MCR7387), audit(86-06-10,Martinson), install(86-07-17,MR12.0-1091): Correct error message documentation. 2) change(86-06-30,Fawcett), approve(86-06-30,MCR7383), audit(86-06-30,LJAdams), install(86-07-17,MR12.0-1097): Add support for subvolumes, 3380 and 3390. END HISTORY COMMENTS */ /* format: indattr,inddcls,dclind5,idind30,struclvlind5,ifthenstmt,ifthendo,^inditerdo,^indnoniterend,case,^tree,^indproc,^indend,^delnl,^insnl,comcol81,indcom,linecom,^indcomtxt */ mdx: proc; /* Guts of volume management. This program is the brains behind disk_table_. We run in ring 1 here and can mess with the disk table - but we don't print any messages. system_startup_ and sc_command_ call disk_table_ which can run in any ring and print. disk_table_ calls us through initializer_mdc_. THVV 4/2/76 by Greenberg for demount and auto lv/pv vanishing 12/4/76 by Greenberg for new lv vanish including demounted bits 03/8/77 by Greenberg for static ac/dc disks and random refcount bugs July 1977 by T. Casey to add set_lv_pdir_bit entry Jan 1978 by B. Greenberg for prev_bootload bit, making lvs "mounting" at startup. July 1978 by B. Greenberg for hardcore RLV acceptance. July 1981 by J. Bongiovanni to validate lv indices March 1982 by J. Bongiovanni for new PVTE '82 for english disk error codes 831122 by E. A. Ranzenbach for set_vacate_pdirs_bit entry. August 1984 by Chris Jones to tell IOI when we add or delete a drive. 84-09-04 by EJ Sharpe to change hdx refs to volume_registration_mgr_ also changed check_hv entry to check_lv 85-01-31 by EJ Sharpe to force-init DT entries for: 1) root PVs not on the ROOT config card (i.e. not in PVT at init time); and 2) root PVs have moved to a different drive (these used to be done incorrectly by "forgetter"). Also, clear all lve.pdirs_ok bits at initialization. 1985-04-02, BIM: Indicate to caller of "take" when this call has completed the rlv, so that the last add_vol of an root PV's crows with success. 05/07/85 by Chris Jones to let IOI decide when a drive can or cannot be reconfigured. 08/28/85 by Rich Fawcett to support sub-volumes. */ dcl found bit (1); dcl must_term bit (1) init ("0"b); dcl (sdtp, stat_pvtp) ptr static init (null); dcl ROOT char (168) static init (">"); dcl SL1 char (168) static init (">system_library_1"); dcl i fixed bin; dcl dvn char (8); dcl (tpvtx, a_tpvtx) fixed bin; dcl lvx fixed bin; dcl prev_state bit (1); dcl oldlev fixed bin; dcl num_pic pic "99"; dcl pvt_n_entries fixed bin; dcl xec fixed bin (35); dcl reasonable_time fixed bin (71) int static init (2276881905645328); dcl (addr, fixed, null, max, rel, rtrim, substr, unspec) builtin; dcl admin_gate_$ioi_add_device entry (char (*), fixed bin (35)); dcl admin_gate_$ioi_delete_device entry (char (*), fixed bin (35)); dcl (cu_$level_set, cu_$level_get) entry (fixed bin); dcl initializer_gate_$add_pv_to_lv entry (bit (36) aligned, bit (36) aligned, fixed bin (35)); dcl initializer_gate_$read_disk entry (fixed bin, fixed bin, ptr, fixed bin (35)); dcl initializer_gate_$define_lv entry (ptr, fixed bin (35)); dcl initializer_gate_$delete_lv entry (bit (36) aligned, fixed bin (35)); dcl initializer_gate_$set_disk_table_loc entry (ptr, fixed bin (35)); dcl initializer_gate_$accept_fs_disk entry (fixed bin, fixed bin (35)); dcl initializer_gate_$demount_pv entry (fixed bin, fixed bin (35)); dcl initializer_gate_$vol_salv entry (fixed bin, bit (36) aligned, fixed bin (35)); dcl initializer_gate_$ss_io_reconfigure entry (fixed bin, bit (1) aligned, fixed bin (35)); dcl verify_label_ entry (ptr, ptr, fixed bin, fixed bin (35)); dcl volume_registration_mgr_$init entry (ptr); dcl volume_registration_mgr_$test entry (char (*)); dcl volume_registration_mgr_$check_volume_registration entry (ptr, fixed bin (35)); dcl volume_registration_mgr_$get_lv_pvinfo entry (char (*), ptr, fixed bin, fixed bin, fixed bin (35)); dcl volume_registration_mgr_$find entry (ptr, fixed bin (35)); dcl hcs_$initiate entry (char (*), char (*), char (*), fixed bin (1), fixed bin (2), ptr, fixed bin (35)); dcl hcs_$terminate_noname entry (ptr, fixed bin (35)); dcl hcs_$make_seg entry (char (*), char (*), char (*), fixed bin (5), ptr, fixed bin (35)); dcl hcs_$truncate_seg entry (ptr, fixed bin, fixed bin (35)); dcl hcs_$add_acl_entries entry (char (*), char (*), ptr, fixed bin, fixed bin (35)); dcl rcp_control_$ss_io_interchange entry (char (*), bit (1) aligned, bit (1) aligned, fixed bin (35)); dcl admin_gate_$syserr ext entry options (variable); dcl 1 label_buffer like label; dcl 1 adte like dte aligned based (aux_dtep); dcl 1 alve like lve aligned based (aux_lvep); dcl (aux_dtep, aux_lvep) ptr; dcl 1 aa aligned int static, 2 name char (32) init ("*.*.*"), 2 mode bit (36) init ("111"b), 2 mbz bit (36) init ((36)"0"b), 2 code fixed bin (35); dcl sys_info$access_class_ceiling bit (72) ext; dcl error_table_$fsdisk_not_salv fixed bin (35) ext; dcl error_table_$no_label fixed bin (35) ext; dcl error_table_$invalid_state fixed bin (35) ext; dcl error_table_$bad_label fixed bin (35) ext; dcl error_table_$argerr fixed bin (35) ext; dcl error_table_$action_not_performed fixed bin (35) ext; dcl error_table_$io_still_assnd fixed bin (35) ext; dcl error_table_$logical_volume_not_defined fixed bin (35) ext; dcl error_table_$mount_not_ready fixed bin (35) ext; dcl error_table_$private_volume fixed bin (35) ext; /* -------------------------------------------------------- */ /* This entry is the guts of disk_table_$init. Actually we could call ioa_ here but don't. */ init: entry (a_dtp, new, ec); dcl a_dtp ptr, new bit (1), ec fixed bin (35); ec = 0; new = "0"b; call hcs_$make_seg (ROOT, "disk_table", "", 1010b, dtp, xec); if dtp = null then do; /* Must have one */ ec = xec; /* quelle horreur */ return; end; call hcs_$add_acl_entries (ROOT, "disk_table", addr (aa), 1, xec); call initializer_gate_$set_disk_table_loc (dtp, xec); /* Tell BOS where it is (fsout too) */ call hcs_$initiate (SL1, "pvt", "", 0, 1, pvtp, xec); if pvtp = null then do; ec = xec; /* system is broken */ return; end; stat_pvtp = pvtp; /* save value for use in copying pvt.salv bit */ sdtp = dtp; /* Save static copy for other ep's */ call volume_registration_mgr_$init (dtp); a_dtp = dtp; /* Does the PVT match the Disk Table? */ pvt_n_entries = pvt.n_entries; pvt_arrayp = addr (pvt.array); if dt.version ^= 1 then ec = 3; else if pvt_n_entries = dt.n_entries then do; /* Must be same size */ do i = 1 to dt.n_lv_entries; /* Cause lv table to be garbage-collected */ lvep = addr (dt.lv_array (i)); lve.mounting = "0"b; /* As to not induce mhv's */ lve.demounted_only = "0"b; /* develop this later */ lve.demounting = "0"b; /* As to not induce dhv's */ lve.used = "0"b; /* So that gc will work */ lve.hv_mounted = "0"b; /* not until we know better */ lve.pdirs_ok = "0"b; /* site should set these each bootload */ end; do i = 1 to pvt_n_entries; /* Find hardcore-accepted volumes, scratch old DT entries. */ pvtep = addr (pvt_array (i)); dtep = addr (dt.array (i)); dte.rpv = "0"b; /* Will be set by make_root_pve if true */ if pvte.used then call make_root_pve; else dte.hc_accepted = "0"b; end; do i = 1 to pvt_n_entries; /* check all entries xcept PD */ pvtep = addr (pvt_array (i)); dtep = addr (dt.array (i)); dte.need_salvage = "0"b; if pvte.storage_system ^= dte.storage_system then do; dte.known, dte.used, dte.demounted, dte.pre_accepted = "0"b; dte.storage_system = pvte.storage_system; end; if dte.deleted | ^dte.storage_system then dte.used, dte.known, dte.pre_accepted, dte.demounted = "0"b; num_pic = pvte.logical_area_number; dvn = pvte.devname || "_" || num_pic; if pvte.is_sv then dvn = rtrim (dvn) || rtrim (pvte.sv_name); lvx = dte.lvx; /* Can't be TOO bad. */ lvep = addr (dt.lv_array (lvx)); if dvn ^= dte.drive_name then ec = 4; else if pvte.device_type ^= dte.device_type then ec = 5; else if dte.deleted then dte.deleted = "0"b; /* Cancel previous "deld" */ else if lvx <= 0 then goto skip_lv; /* invalid index -- don't diddle lve */ else if dte.used then do; /* good thing last time? */ if dte.hc_accepted then call volume_registration_mgr_$check_volume_registration (dtep, xec); /* re-register root pack */ else if dte.lvx = 1 then do; /* root PV that is not on ROOT card */ call admin_gate_$syserr (BEEP, "disk_table_: Deleted root PV ""^a"" on ^a.", dte.pvname, dte.drive_name); call force_init_dte (i); end; else do; /* Other volumes are "pre-accepted" (ie assumed) */ estab_lv: call make_assumed; lve.demounted_only = "0"b; if dte.lvx ^= 1 then lve.mounting = "1"b; lve.prev_bootload = "1"b; suggest_lv: lve.used = "1"b; dt.n_lv_entries = max (dt.n_lv_entries, dte.lvx); end; end; else if dte.known | dte.pre_accepted then go to estab_lv; else if dte.demounted then do; if ^lve.used then lve.demounted_only = "1"b; go to suggest_lv; /* good vol will turn off, */ /* bad vols wont turn on */ end; else ; /* Idle last time */ skip_lv: end; if ec = 0 then return; /* If disk config didn't change we exit normally */ end; else if dt.n_entries = 0 then do; /* Did we create a new disk table */ ec = 1; /* Yes */ end; else do; /* Some other mismatch */ ec = 2; /* disk config changed. rebuild whole thing */ end; call hcs_$truncate_seg (dtp, 0, xec); /* Throw away all old stuff */ dt.version = 1; /* .. and make new */ new = "1"b; dt.n_entries = pvt_n_entries; /* Discount the paging device */ dt.max_n_entries = pvt.max_n_entries; dt.n_lv_entries = 0; do i = 1 to dt.n_entries; /* Make new table */ pvtep = addr (pvt_array (i)); dtep = addr (dt.array (i)); call force_init_dte (i); if pvte.used then do; call make_root_pve; /* Kosher by definition */ call volume_registration_mgr_$check_volume_registration (dtep, xec); /* Make sure the rpv is registered */ end; end; return; /* --------------------------------------------------------- */ take: entry (a_pvname, a_indx, took, ec); dcl a_pvname char (*); dcl a_indx fixed bin; dcl took bit (1); ec = 0; dtp = sdtp; i = a_indx; dtep = addr (dt.array (i)); took = "0"b; if ^dte.storage_system | dte.deleted | dte.used then do; fail: ec = error_table_$argerr; return; end; call verify_drive_vanish_pve (dtep, a_pvname, ec); if ec ^= 0 then return; /* Consistentize disk table */ dte.pvname = a_pvname; if ^dte.known then do; call volume_registration_mgr_$find (dtep, ec); if ec ^= 0 then do; call make_demounted; return; end; if ^get_it_known (i, ec) then do; call make_demounted; return; end; end; lvep = addr (dt.lv_array (dte.lvx)); if lve.hv_mounted then do; /* Adding vol to live lv (eg root) */ call initializer_gate_$accept_fs_disk (i, ec); if ec = error_table_$fsdisk_not_salv then do; /* salvage if needed */ call initializer_gate_$vol_salv (i, ""b, ec); call initializer_gate_$accept_fs_disk (i, ec); end; if ec = 0 then do; call make_used; call initializer_gate_$add_pv_to_lv (lve.lvid, dte.pvid, ec); end; call check_lv_complete (xec); /* Always try to announce success in completing the RLV */ if xec = 0 then do; call verify_whole_lv (1, xec); took = (xec = 0); end; end; else do; i = dte.lvx; call check_lv_complete (xec); if xec = 0 & lve.mounting then do; /* If vol complete AND mhv was called */ call verify_whole_lv (i, ec); if ec = 0 then took = "1"b; end; end; return; /* ------------------------------------------------------ */ assert: entry (a_pvname, a_indx, ec); ec = 0; dtp = sdtp; i = a_indx; dtep = addr (dt.array (i)); if ^dte.storage_system | dte.deleted | dte.used then go to fail; call verify_drive_vanish_pve (dtep, a_pvname, ec); if ec ^= 0 then return; dte.pvname = a_pvname; call volume_registration_mgr_$find (dtep, ec); if ec = 0 then call make_assumed; else call make_blank; return; /* --------------------------------------------------------- */ forget: entry (a_indx, ec); ec = 0; dtp = sdtp; i = a_indx; dtep = addr (dt.array (i)); if ^dte.storage_system | dte.deleted | dte.used then go to fail; call make_blank; return; /* -------------------------------------------------------- */ volsalv: entry (a_pvname, a_indx, opt, ec); dcl opt bit (36) aligned; ec = 0; dtp = sdtp; i = a_indx; dtep = addr (dt.array (i)); if ^dte.storage_system | dte.deleted | dte.used then go to fail; call verify_drive_vanish_pve (dtep, a_pvname, ec); if ec ^= 0 then return; dte.pvname = a_pvname; call volume_registration_mgr_$find (dtep, ec); if ec ^= 0 then return; call verify_label_ (dtp, dtep, i, ec); if ec ^= 0 then return; call make_known; call initializer_gate_$vol_salv (i, opt, ec); return; /* ---------------------------------------------------------- */ rlvolcheck: entry (a_indx, a_pvtx, opt, ec); /* allow connection volsalv of copies of rlv members */ /* a_pvtx is copy, a_indx is real one */ dcl a_pvtx fixed bin, rdtep ptr; i = a_pvtx; dtp = sdtp; dtep = addr (dt.array (i)); /* dtep -> copy being salved */ rdtep = addr (dt.array (a_indx)); /* rdtep is place where live one lives */ if dte.deleted | ^dte.storage_system | dte.used then go to fail; if ^(rdtep -> dte.used | rdtep -> dte.known) then go to fail; call verify_label_ (dtp, rdtep, i, ec); /* LIE to verify_label_: info for live, read phony */ if ec ^= 0 then return; call make_blank; /* Bash away stuff, can't be right */ call initializer_gate_$vol_salv (i, opt, ec); return; /* --------------------------------------------------------- */ mhv: entry (a_indx, a_tpvtx, ec); ec = 0; tpvtx, a_tpvtx = 0; dtp = sdtp; lvep = addr (dt.lv_array (a_indx)); if (lve.hv_mounted & ^(a_indx = 1)) /* ok doublemount rlv */ | (lve.mounting & ^lve.prev_bootload) /* autograb last-time's */ | lve.demounting | ^lve.used then go to fail; if a_indx ^= 1 then lve.mounting = "1"b; call check_lv_complete (ec); if ec = 0 | ec = -1 then do; /* Complete or completeable? */ call verify_whole_lv (a_indx, ec); end; a_tpvtx = tpvtx; return; /* --------------------------------------------------------- */ reregister: entry (a_pvname, a_indx, ec); /* Called when opr asserts disk is ok */ ec = 0; dtp = sdtp; dtep = addr (dt.array (a_indx)); if ^dte.storage_system | dte.used | dte.deleted then go to fail; call verify_drive_vanish_pve (dtep, a_pvname, ec); if ec ^= 0 then return; labelp = addr (label_buffer); call initializer_gate_$read_disk (a_indx, LABEL_ADDR, labelp, ec); if ec ^= 0 then return; ec = error_table_$no_label; if label.Multics ^= Multics_ID_String then return; if label.version ^= 1 then return; if label.time_registered < reasonable_time then return; ec = error_table_$bad_label; if label.pv_name ^= a_pvname then return; dte.pvname = label.pv_name; dte.pvid = label.pvid; do i = 1 to dt.n_lv_entries while (^dt.lv_array (i).used | dt.lv_array (i).lvname ^= label.lv_name); end; dte.lvx = i; lvep = addr (dt.lv_array (dte.lvx)); if dte.lvx > dt.n_lv_entries then do; dt.n_lv_entries = dt.n_lv_entries + 1; unspec (lve) = ""b; lve.lvname = label.lv_name; lve.lvid = label.lvid; lve.max_access_class = label.max_access_class; lve.min_access_class = label.min_access_class; lve.public = ^label.private; lve.used = "1"b; end; call volume_registration_mgr_$check_volume_registration (dtep, ec); if ec ^= 0 then return; call make_known; return; /* --------------------------------------------------------- */ read_disk_table: entry (spacep, ec); dcl spacep ptr; dcl move_len fixed bin (18); dcl move_table (move_len) fixed bin (35) aligned based; if ^get_local_dtp () then return; ec = 0; move_len = fixed (rel (addr (dt.lv_array (dt.n_lv_entries + 1))), 18); spacep -> move_table = dtp -> move_table; go to term_exit; /* --------------------------------------------------------- */ check_pv: entry (a_pvname, ec); if ^get_local_dtp () then return; found = "0"b; do i = 1 to dt.n_entries while (^found); dtep = addr (dt.array (i)); if a_pvname = dte.pvname & (dte.used | dte.known) then found = "1"b; /* oughtta take out of tbl here */ end; go to found_exit; /* ------------------------------------------------------- */ check_lv: entry (a_hvname, ec); dcl a_hvname char (*); if ^get_local_dtp () then return; found = "0"b; do i = 1 to dt.n_lv_entries while (^found); if dt.lv_array (i).lvname = a_hvname & dt.lv_array (i).used & dt.lv_array (i).hv_mounted then found = "1"b; end; found_exit: if ^found then ec = error_table_$mount_not_ready; else ec = 0; term_exit: if must_term then do; call cu_$level_set (oldlev); call hcs_$terminate_noname (dtp, (0)); end; return; /* --------------------------------------------------------- */ set_lv_pdir_bit: entry (a_hvname, a_bit, ec); dcl a_bit bit (1) aligned; ec = 0; /* until something goes wrong */ if ^get_local_dtp () then return; found = ""b; do i = 1 to dt.n_lv_entries while (^found); if dt.lv_array (i).lvname = a_hvname & dt.lv_array (i).used then do; found = "1"b; if dt.lv_array (i).public then dt.lv_array (i).pdirs_ok = a_bit; else ec = error_table_$private_volume; end; end; if ^found then ec = error_table_$mount_not_ready; return; /* --------------------------------------------------------- */ set_vacate_pdirs_bit: entry (a_hvname, a_bit, ec); ec = 0; /* until something goes wrong */ if ^get_local_dtp () then return; found = ""b; do i = 1 to dt.n_lv_entries while (^found); if dt.lv_array (i).lvname = a_hvname & dt.lv_array (i).used then do; found = "1"b; if dt.lv_array (i).public then do; dt.lv_array (i).vacate_pdirs = a_bit; if dt.lv_array (i).pdirs_ok & a_bit then dt.lv_array (i).pdirs_ok = "0"b; end; else ec = error_table_$private_volume; end; end; if ^found then ec = error_table_$mount_not_ready; return; /* --------------------------------------------------------- */ add_del: entry (a_device_name, a_adding_drive, true_if_found, ec); dcl a_device_name char (*), a_adding_drive bit (1) aligned, true_if_found bit (1) aligned; dcl adding_drive bit (1); /* "0"b if deleting device "1"b if adding device */ adding_drive = a_adding_drive; dtp = sdtp; ec = 0; true_if_found = "0"b; do i = 1 to dt.n_entries; dtep = addr (dt.array (i)); if dte.drive_name = a_device_name then do; true_if_found = dte.storage_system; if dte.used | dte.known then ec = error_table_$io_still_assnd; else if dte.deleted ^= adding_drive then ec = error_table_$action_not_performed; else do; if adding_drive then call admin_gate_$ioi_add_device ((dte.drive_name), ec); else call admin_gate_$ioi_delete_device ((dte.drive_name), ec); if ec = 0 then do; dte.deleted = ^adding_drive; if dte.storage_system then do; call make_blank; call admin_gate_$syserr (ANNOUNCE, "disk_table_: ^[Added^;Deleted^] drive ^a.", (adding_drive), (a_device_name)); end; end; end; end; end; return; /* -------------------------------------------------------- */ ss_io_reconfig: entry (a_pvtx, a_from_ss, ec); dcl a_from_ss bit (1); dcl from_ss bit (1) aligned; from_ss = a_from_ss; i = a_pvtx; dtp = sdtp; dtep = addr (dt.array (i)); xec = 0; if from_ss ^= dte.storage_system then do; ec = error_table_$invalid_state; return; end; if from_ss then if dte.known | dte.used then do; ec = error_table_$io_still_assnd; return; end; call make_blank; call cu_$level_get (oldlev); call cu_$level_set (1); if dte.is_sub_vol then do; /* if this is a drive that contains subvolumes only tell rcp about the last one */ if dte.sv_num = (dte.num_of_sv - 1) then /* This should be the last one */ call rcp_control_$ss_io_interchange ((substr (dte.drive_name, 1, 7)), from_ss, (dte.deleted), xec); end; else call rcp_control_$ss_io_interchange ((dte.drive_name), from_ss, (dte.deleted), xec); call cu_$level_set (oldlev); if xec = 0 then call initializer_gate_$ss_io_reconfigure (i, from_ss, xec); if xec = 0 then dte.storage_system = ^from_ss; ec = xec; return; /* --------------------------------------------------------- */ demount_pv: entry (a_pvtx, ec); dtp = sdtp; dtep = addr (dt.array (a_pvtx)); if ^dte.storage_system | ^dte.used then do; ec = error_table_$action_not_performed; return; end; lvx = dte.lvx; if lvx < 0 | lvx > dt.n_lv_entries then do; ec = error_table_$action_not_performed; return; end; lvep = addr (dt.lv_array (lvx)); if ^lve.demounting then do; ec = error_table_$io_still_assnd; return; end; call initializer_gate_$demount_pv (a_pvtx, ec); if ec = 0 then call make_demounted; return; /* --------------------------------------------------------- */ demount_lv: entry (a_lvx, a_dhv_act, ec); dcl a_lvx fixed bin, a_dhv_act fixed bin; dtp = sdtp; lvx = a_lvx; lvep = addr (dt.lv_array (lvx)); if ^lve.used then do; lve.hv_mounted, lve.demounting, lve.mounting = "0"b; /* for robustness */ ec = error_table_$action_not_performed; return; end; if lvx = dt.array (dt.rpvx).lvx | (lve.pdirs_ok & lve.hv_mounted) then do; ec = error_table_$action_not_performed; return; end; ec = 0; /* Unless otherwise */ if a_dhv_act = 1 then do; /* Stop a mhv */ if ^lve.mounting then go to fail; /* argerr */ lve.mounting = "0"b; do i = 1 to dt.n_entries while (^(dt.array (i).used & dt.array (i).lvx = lvx)); end; if i <= dt.n_entries then lve.demounting = "1"b; end; else if a_dhv_act = 2 then do; /* Demount start, take out of r0 */ if lve.mounting then go to fail; if ^lve.hv_mounted then go to fail; call initializer_gate_$delete_lv (lve.lvid, ec); if ec = error_table_$logical_volume_not_defined then ec = 0;/* Ignore not-there */ lve.demounting = "1"b; lve.hv_mounted = "0"b; end; else if a_dhv_act = 3 then do; /* Turn off demounting */ if ^lve.demounting then go to fail; lve.demounting = "0"b; end; if ec ^= 0 then return; do i = 1 to dt.n_entries; /* Make Ops happy, erase the thing. */ dtep = addr (dt.array (i)); if dte.pre_accepted & (dte.lvx = lvx) then call make_demounted; end; if ^lve.used then return; lve.mounting = "0"b; /* General principles, minimize screwups */ call develop_lve_status_anon; /* Check for weird case */ return; %page; /* SUBROUTINES AND OTHER UTILE CONSTRUCTIONS */ get_it_known: proc (b_dtx, b_ec) returns (bit (1)); /* Call verify_label, leave drive hungry or known */ dcl b_dtx fixed bin; /* passed for convenience */ dcl b_ec fixed bin (35); call verify_label_ (dtp, dtep, b_dtx, b_ec); if b_ec = 0 then do; call make_known; return ("1"b); end; return ("0"b); end get_it_known; verify_drive_vanish_pve: proc (b_dtep, b_pvname, ec); dcl ec fixed bin (35); dcl b_dtep ptr; dcl b_pvname char (*); dcl bpk fixed bin; dcl save_dtep ptr; dcl k fixed bin; do k = 1 to dt.n_entries; aux_dtep = addr (dt.array (k)); if aux_dtep = b_dtep then bpk = k; else do; if (adte.used | adte.known) & adte.pvname = b_pvname then do; ec = error_table_$io_still_assnd; return; end; if (adte.pre_accepted | adte.demounted) & adte.pvname = b_pvname then call forgetter (k); end; end; aux_dtep = b_dtep; if adte.used | adte.known then if adte.pvname = b_pvname then ec = 0; else ec = error_table_$io_still_assnd; else if adte.pre_accepted | adte.demounted then call forgetter (bpk); if ec = 0 then do; save_dtep = dtep; dtep = b_dtep; /* This is what lambda was invented for */ call make_blank; dtep = save_dtep; end; end; forgetter: entry (a_indx); /* recursive only */ dtp = sdtp; dtep = addr (dt.array (a_indx)); call make_blank; return; %page; make_root_pve: proc; dcl mrpve_pvtx fixed bin; /* This procedure is called to construct DT PV entries for volumes accepted by the hardcore during initialization. PVT and DT pointers are valid. */ dte.storage_system = "1"b; /* Get good params going */ dte.deleted = "0"b; dte.rpv = pvte.rpv; /* Get rpv bit */ dte.pvid = pvte.pvid; if dte.rpv then dt.rpvx = i; dte.lvx = 1; dte.permanent = "1"b; call make_root_lve; call verify_label_ (dtp, dtep, i, ec); /* Special kludge in verify_label_ will cause name fillin into DT instead of check. lvname = root triggers this. */ dte.hc_accepted = "1"b; /* Cause comparator to ignore. */ call make_used; do mrpve_pvtx = 1 to dt.n_entries; /* Since this is the first pass of mdx init, flush all other claims to this volume, regardless of how strong they are. */ aux_dtep = addr (dt.array (mrpve_pvtx)); if aux_dtep ^= dtep then do; /* Don't consider self */ if adte.pvname = dte.pvname | adte.pvid = dte.pvid then do; call admin_gate_$syserr (ANNOUNCE, "disk_table_: Root PV ""^a"" moved from ^a to ^a.", dte.pvname, adte.drive_name, dte.drive_name); call force_init_dte (mrpve_pvtx); end; end; end; end; make_root_lve: proc; lvep = addr (dt.lv_array (1)); if lve.lvname ^= "root" | ^lve.used then do; dt.n_lv_entries = 1; unspec (lve) = ""b; lve.public = "1"b; lve.lvid = pvte.lvid; lve.lvname = "root"; lve.min_access_class = ""b; lve.max_access_class = sys_info$access_class_ceiling; end; lve.used = "1"b; /* gc turned off */ lve.hv_mounted = "1"b; end make_root_lve; force_init_dte: /* procedure used during disk_table initialzation to clear a particular entry */ proc (dte_index); dcl dte_index fixed bin parameter; dcl l_dtep ptr; dcl 1 l_dte aligned like dte based (l_dtep); dcl l_pvtep ptr; dcl 1 l_pvte aligned like pvte based (l_pvtep); l_dtep = addr (dt.array (dte_index)); l_pvtep = addr (pvt_array (dte_index)); unspec (l_dte) = ""b; num_pic = l_pvte.logical_area_number; l_dte.is_sub_vol = l_pvte.is_sv; l_dte.sv_num = l_pvte.sv_num; l_dte.drive_name = l_pvte.devname || "_" || num_pic; if l_dte.is_sub_vol then l_dte.drive_name = rtrim (l_dte.drive_name) || rtrim (l_pvte.sv_name); l_dte.device_type = l_pvte.device_type; l_dte.storage_system = l_pvte.storage_system; l_dte.permanent = l_pvte.permanent; l_dte.num_of_sv = l_pvte.num_of_svs; l_dte.sv_name = l_pvte.sv_name; return; end force_init_dte; %page; verify_whole_lv: proc (desired_lvx, ec); /* This procedure is called when it is desired to mount an entire hierarchy volume, and all constituent pv's are either pre_accepted, known, or in use (from a previous failing attempt). It tries to accept them all, promoting all drives up through the states. As is the convention in mdx, any time a label is read which contradicts a pre_accepted, the latter is turned off. No volumes are promoted to used (ring 0 called) unless all labels check. */ dcl desired_lvx fixed bin, ec fixed bin (35); dcl i fixed bin; dcl 1 local_lvte aligned like lvte; lvep = addr (dt.lv_array (desired_lvx)); do i = 1 to dt.n_entries; dtep = addr (dt.array (i)); if dte.lvx = desired_lvx & dte.pre_accepted then do; if ^get_it_known (i, ec) then do; tpvtx = i; call make_assumed; return; end; end; end; do i = 1 to dt.n_entries; dtep = addr (dt.array (i)); if dte.lvx = desired_lvx & dte.known then do; call initializer_gate_$accept_fs_disk (i, ec); if ec = error_table_$fsdisk_not_salv then do; /* salvage if needed */ call initializer_gate_$vol_salv (i, ""b, ec); call initializer_gate_$accept_fs_disk (i, ec); end; if ec ^= 0 then do; tpvtx = i; return; end; call make_used; if lve.hv_mounted then call initializer_gate_$add_pv_to_lv (lve.lvid, dte.pvid, ec); end; end; if ^lve.hv_mounted then do; /* Want to mount new vol? */ unspec (local_lvte) = "0"b; local_lvte.lvid = lve.lvid; local_lvte.access_class.min = lve.min_access_class; local_lvte.access_class.max = lve.max_access_class; local_lvte.public = lve.public; call initializer_gate_$define_lv (addr (local_lvte), ec); if ec = 0 then do; lve.hv_mounted = "1"b; lve.mounting = "0"b; end; end; end verify_whole_lv; %page; check_lv_complete: proc (ec); /* This procedure checks the registration for a given LV, and determines if they are all in the disk table. */ dcl ec fixed bin (35); dcl pvap ptr; dcl npv fixed bin; dcl (i, j) fixed bin; dcl (found, ready) bit (1); dcl 1 pva (100) based (pvap) aligned, 2 pvname char (32), 2 device_type fixed bin, 2 pad fixed bin; pvap = addr (dt.lv_array (dt.max_n_entries + 1)); call volume_registration_mgr_$get_lv_pvinfo ((lve.lvname), pvap, npv, (0), ec); if ec ^= 0 then return; ec = 0; ready = "1"b; do i = 1 to npv while (ec = 0); /* Look for any unmounted vol */ found = "0"b; do j = 1 to dt.n_entries while (^found); dtep = addr (dt.array (j)); if dte.pvname = pva (i).pvname then if dte.used | dte.known then found = "1"b; else if dte.pre_accepted then do; found = "1"b; ready = "0"b; end; end; if ^found then ec = 1; end; if ec = 0 & ^ready then ec = -1; end check_lv_complete; %page; /* SUBROUTINES TO PERFORM STATE TRANSIT */ /* All assume dtep is set */ make_blank: proc; call hold_status; dte.pre_accepted, dte.used, dte.known, dte.demounted = "0"b; call develop_lve_status; end; make_assumed: proc; dte.used, dte.known, dte.demounted, dte.used = "0"b; dte.pre_accepted = "1"b; if dte.lvx > 0 & dte.lvx <= dt.n_lv_entries then dt.lv_array (dte.lvx).demounted_only = "0"b; end; make_demounted: proc; prev_state = "1"b; /* lvx must be good */ dte.pre_accepted, dte.used, dte.known = "0"b; dte.demounted = "1"b; call develop_lve_status; end; make_known: proc; dte.pre_accepted, dte.used, dte.demounted = "0"b; dte.known = "1"b; if dte.lvx > 0 & dte.lvx <= dt.n_lv_entries then dt.lv_array (dte.lvx).demounted_only = "0"b; end; make_used: proc; dte.pre_accepted, dte.demounted, dte.known = "0"b; if ^dte.used then call admin_gate_$syserr (LOG, "disk_table_: accepted PV ^a on ^a.", dte.pvname, dte.drive_name); dte.used = "1"b; if dte.lvx > 0 & dte.lvx <= dt.n_lv_entries then dt.lv_array (dte.lvx).demounted_only = "0"b; end; hold_status: proc; prev_state = dte.used | dte.pre_accepted | dte.known | dte.demounted; end; develop_lve_status: proc; dcl ii fixed bin; dcl l_lvx fixed bin; dcl hold bit (1) init ("0"b); if ^prev_state then do; dte.lvx = -2; /* sure asdmp */ return; /* dont check garbage */ end; l_lvx = dte.lvx; go to join; develop_lve_status_anon: entry; l_lvx = lvx; /* global */ join: if l_lvx < 0 | l_lvx > dt.n_lv_entries then return; aux_lvep = addr (dt.lv_array (l_lvx)); do ii = 1 to dt.n_entries; aux_dtep = addr (dt.array (ii)); if adte.lvx = l_lvx then do; if adte.demounted then hold = "1"b; else if adte.used | adte.known | adte.pre_accepted then do; alve.demounted_only = "0"b; return; end; end; end; if hold then do; /* He thinks its vanished */ alve.demounted_only = "1"b; alve.prev_bootload = "0"b; /* No more special privileges */ end; if alve.mounting then return; if ^hold then do; alve.used = "0"b; alve.lvid = "0"b; end; end develop_lve_status; %page; get_local_dtp: proc returns (bit (1)); dtp = sdtp; must_term = "0"b; if dtp = null () then do; /* we're not Inz */ call cu_$level_get (oldlev); call cu_$level_set (1); call hcs_$initiate (ROOT, "disk_table", "", 0, 1, dtp, ec); if dtp = null () then do; call cu_$level_set (oldlev); return ("0"b); end; must_term = "1"b; end; return ("1"b); end; test: entry (aroot); dcl aroot char (*); SL1, ROOT = aroot; call volume_registration_mgr_$test (aroot); return; /* format: off */ %page; %include disk_table; %page; %include lvt; %page; %include pvt; %page; %include pvte; %page; %include fs_vol_label; %page; %include disk_pack; %page; %include syserr_constants; %page; /* BEGIN MESSAGE DOCUMENTATION Message: disk_table_: Added drive DSKX_NN S: $info T: $response M: The operator has added a storage system disk drive with adddev. A: $ignore Message: disk_table_: Deleted drive DSKX_NN S: $info T: $response M: The operator has deleted a storage system disk drive with deldev. A: $ignore Message: disk_table_: accepted PV PVNAME on DSKX_NN S: $log T: $response $init M: A storage system physical volume has been placed in use. The volume and drive name are identified. A: $ignore This message is provided for the benefit of automatic error analysis and logging. Message: disk_table_: Deleted root PV "PV_NAME" on DSKX_NN. S: $beep T: $init M: The specified drive did not appear in the ROOT config card. Thus, it was removed from the disk_table_. This will also occur when the volume is intentionally deleted. A: $notify Message: disk_table_: Root PV "PV_NAME" moved from DSKX_NN to DSKX_NN. S: $info T: $init M: The specified root volume has been moved to a different drive since the last shutdown. A: $ignore END MESSAGE DOCUMENTATION */ end mdx;  salv_caller.pl1 11/11/89 1102.4rew 11/11/89 0803.2 97128 /****^ *********************************************************** * * * 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. * * * *********************************************************** */ salv_caller: procedure; return; /* salv_caller -- Module to implement administrative salvager commands */ /* Bernard Greenberg, April 6 1976 */ /* Modified 7/77 by S.E. Barr to delete branch checking. */ dcl cu_$arg_count entry returns (fixed bin); dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin, fixed bin (35)); dcl code fixed bin (35); dcl arg char (argl) based (argp); dcl argp ptr, argl fixed bin; dcl SALV_RING fixed bin static init (1); dcl cv_dec_check_ entry (char (*), fixed bin (35), fixed bin); dcl i fixed bin; dcl n fixed bin; dcl disk_table_$general_mhv entry (fixed bin (35)); dcl disk_table_$accept_rlv entry (fixed bin (35)); dcl disk_table_$rbld_disk entry (char (*), char (*), char (*), bit (36) aligned, fixed bin (35)); dcl disk_table_$volsalv entry (char (*), char (*), bit (36) aligned, fixed bin (35)); dcl disk_table_$volsalvall entry (bit (36) aligned, fixed bin (35)); dcl disk_table_$volrlvcheck entry (char (*), char (*), char (*), bit (36) aligned, fixed bin (35)); dcl initializer_gate_$salvager entry (bit (36) aligned, fixed bin, fixed bin (35)); dcl cu_$level_get entry returns (fixed bin); dcl (ioa_, com_err_) entry options (variable); dcl isvol bit (1); dcl (copysw, allsw, drivesw, packsw, rbldsw) bit (1) init ("0"b); dcl (drive, copyarg, pvname) char (32); dcl (error_table_$action_not_performed, error_table_$badopt, error_table_$noarg) fixed bin (35) ext; dcl active_all_rings_data$max_tree_depth fixed bin ext; %include salv_options; dirsalv: entry; isvol = "0"b; /* directory salvage */ go to join; packsalv: entry; isvol = "1"b; /* pack salvage */ go to join; rbld_disk: entry; isvol = "1"b; rbldsw = "1"b; join: salv_opt_bits = "0"b; /* clear all flags */ if ^isvol then do; if cu_$level_get () > SALV_RING then do; call com_err_ (0, "salvage_dirs", "must be in ring ^d for dir salv", SALV_RING); return; end; n = active_all_rings_data$max_tree_depth; end; do i = 1 to cu_$arg_count ();; call cu_$arg_ptr (i, argp, argl, code); if arg = "-console" then salv_opts.console = "1"b; else if arg = "-debug" | arg = "-db" then salv_opts.debug = "1"b; else if arg = "-dump" then salv_opts.dump = "1"b; else if arg = "-nodump" then salv_opts.ndump = "1"b; else if arg = "-nodebug" then salv_opts.ndebug = "1"b; else if arg = "-noconsole" then salv_opts.nconsole = "1"b; else if isvol then do; if arg = "-all" then do; if ^rbldsw then allsw = "1"b; else do; call com_err_ (error_table_$badopt, "rebuild disk", arg); return; end; end; else if arg = "-copy" then do; i = i + 1; call cu_$arg_ptr (i, argp, argl, code); if code ^= 0 then do; nocopyarg: call com_err_ (code, "salvage_vol", "need copy drive name"); return; end; if substr (arg, 1, 1) = "-" then do; code = error_table_$noarg; go to nocopyarg; end; copyarg = arg; copysw = "1"b; end; else if i = 1 & substr (arg, 1, 1) ^= "-" then do; /* pack name */ pvname = arg; packsw = "1"b; end; else if i = 2 & packsw & substr (arg, 1, 1) ^= "-" then do; /* drive name */ drive = arg; drivesw = "1"b; end; else do; call com_err_ (error_table_$badopt, "salvage_vol", arg); return; end; end; else do; /* dir salv */ if arg = "-rebuild" then salv_opts.rbld = "1"b; else if arg = "-pathname" then salv_opts.pnames = "1"b; else if arg = "-long" then salv_opts.rbld, salv_opts.check, salv_opts.pnames = "1"b; else if arg = "-check_vtoce" then salv_opts.check = "1"b; else if arg = "-delete_connection_failure" | arg = "-dcf" then salv_opts.dcf = "1"b; else if arg = "-norebuild" then salv_opts.nrbld = "1"b; else if arg = "-nopathname" then salv_opts.npnames = "1"b; else if arg = "-nocheck_vtoce" then salv_opts.ncheck = "1"b; else if arg = "-nodelete_connection_failure" | arg = "-nodcf" then salv_opts.ndcf = "1"b; else if arg = "-level" then do; i = i + 1; call cu_$arg_ptr (i, argp, argl, code); if code ^= 0 then do; levnoarg: call com_err_ (code, "salvage_dirs", "level number required"); return; end; if substr (arg, 1, 1) = "-" then do; code = error_table_$noarg; go to levnoarg; end; call cv_dec_check_ (arg, code, n); if code ^= 0 then do; call com_err_ (0, "salvage_dirs", "decimal number required for level, not ^a", arg); return; end; if n < 0 | n > active_all_rings_data$max_tree_depth then do; call com_err_ (0, "salvage_dirs", "depth must be between ^d and ^d", 0, active_all_rings_data$max_tree_depth); return; end; end; else do; call com_err_ (error_table_$badopt, "salvage_dirs", arg); return; end; end; end; if substr (salv_opt_bits, 1, 18) & substr (salv_opt_bits, 19, 18) then do; if isvol then call com_err_ (0, "salvage_vol", "Inconsistent arguments have been specified"); else call com_err_ (0, "salvage_dirs", "Inconsistent arguments have been specified"); return; end; if salv_opts.ncheck & salv_opts.dcf then do; call com_err_ (0, "salvage_dirs", "VTOC checking is required for connection failure deletion."); return; end; salv_opts.check = salv_opts.check | salv_opts.dcf; if ^isvol then do; call disk_table_$accept_rlv (code); if code ^= 0 then do; call com_err_ (0, "salvage_dirs", "will not salvage until root complete"); return; end; if salv_opts.check then do; call disk_table_$general_mhv (code); if code ^= 0 then do; call com_err_ (0, "salvage_dirs", "Will not salvage"); return; end; end; end; if copysw & allsw then do; call com_err_ (0, "salvage_vol", "-all and -copy arguments cannot be used together"); return; end; if allsw & drivesw then do; call com_err_ (0, "salvage_vol", "no drive may be specified for -all"); return; end; if isvol & ^allsw & ^(packsw & drivesw) then do; call com_err_ (error_table_$noarg, "salvage_vol", "first two args must be phys vol name and drive name"); return; end; if rbldsw & ^(drivesw & copysw) then do; call com_err_ (error_table_$noarg, "rebuild_disk", "args are: pack name dirve name -copy drive name"); return; end; if rbldsw then call disk_table_$rbld_disk (pvname, drive, copyarg, salv_opt_bits, code); else if copysw then call disk_table_$volrlvcheck (pvname, drive, copyarg, salv_opt_bits, code); else if allsw then call disk_table_$volsalvall (salv_opt_bits, code); else if isvol then call disk_table_$volsalv (pvname, drive, salv_opt_bits, code); else call initializer_gate_$salvager (salv_opt_bits, n, code); if code ^= 0 then do; if code < 100 then code = error_table_$action_not_performed; if isvol then call com_err_ (code, "salvage_vol"); else call com_err_ (code, "salvage_dirs"); end; return; test: entry; SALV_RING = cu_$level_get (); return; /* BEGIN MESSAGE DOCUMENTATION Message: rebuild_disk: Expected argument missing. S: $initializer_io T: $response M: Incorrect arguments were specified. A: $tryagn Message: rebuild_disk: Specified control argument is not implemented by this command. BLAH S: $initializer_io T: $response M: Incorrect arguments were specified. A: $tryagn Message: salvage_dirs: ERROR_MESSAGE S: $initializer_io T: $response M: Incorrect arguments were specified. A: $tryagn Message: salvage_dirs: ERROR_MESSAGE. level number required S: $initializer_io T: $response M: Incorrect arguments were specified. A: $tryagn Message: salvage_dirs: Inconsistent arguments have been specified S: $initializer_io T: $response M: Incorrect arguments were specified. A: $tryagn Message: salvage_dirs: Specified control argument is not implemented by this command. BLAH S: $initializer_io T: $response M: Incorrect arguments were specified. A: $tryagn Message: salvage_dirs: Will not salvage S: $initializer_io T: $response M: Incorrect arguments were specified. A: $tryagn Message: salvage_dirs: decimal number required for level, not BLAH S: $initializer_io T: $response M: Incorrect arguments were specified. A: $tryagn Message: salvage_dirs: depth must be between 0 and 15 S: $initializer_io T: $response M: Incorrect arguments were specified. A: $tryagn Message: salvage_dirs: must be in ring 1 for dir salv S: $initializer_io T: $response M: Incorrect arguments were specified. A: $tryagn Message: salvage_dirs: will not salvage until root complete S: $initializer_io T: $response M: Incorrect arguments were specified. A: $tryagn Message: salvage_vol: -all and -copy arguments cannot be used together S: $initializer_io T: $response M: Incorrect arguments were specified. A: $tryagn Message: salvage_vol: ERROR_MESSAGE S: $initializer_io T: $response M: Incorrect arguments were specified. A: $tryagn Message: salvage_vol: ERROR_MESSAGE. need copy drive name S: $initializer_io T: $response M: Incorrect arguments were specified. A: $tryagn Message: salvage_vol: Expected argument missing. first two args must be phys vol name and drive name S: $initializer_io T: $response M: Incorrect arguments were specified. A: $tryagn Message: salvage_vol: Inconsistent arguments have been specified S: $initializer_io T: $response M: Incorrect arguments were specified. A: $tryagn Message: salvage_vol: Specified control argument is not implemented by this command. BLAH S: $initializer_io T: $response M: Incorrect arguments were specified. A: $tryagn Message: salvage_vol: no drive may be specified for -all S: $initializer_io T: $response M: Incorrect arguments were specified. A: $tryagn Message: salvage_dirs: VTOC checking is required for connection failure deletion. S: $initializer_io T: $response M: An attempt was made to specify directory salvage with connection failure deletion, but no VTOC checking. A: $tryagn END MESSAGE DOCUMENTATION */ end;  verify_label_.pl1 11/11/89 1102.4r w 11/11/89 0803.3 21888 /****^ *********************************************************** * * * 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. * * * *********************************************************** */ verify_label_: proc (a_dtp, a_dtep, a_pvtx, ec); /* VERIFY_LABEL_: Ring-1 program to check the label of a file system disk. This interim version calls the hardcore to read the label. Later versions will call IOI to read the label in. */ dcl (a_dtp, a_dtep) ptr parameter, a_pvtx fixed bin, ec fixed bin (35) parameter; dcl initializer_gate_$read_disk entry (fixed bin, fixed bin, ptr, fixed bin (35)); dcl error_table_$bad_label fixed bin (35) ext; dcl error_table_$no_label fixed bin (35) ext; dcl error_table_$ai_restricted fixed bin (35) ext; dcl reasonable_time fixed bin (71) int static init (2276881905645328); dcl 1 label_buffer like label; /* -------------------------------------------------------- */ labelp = addr (label_buffer); ec = 0; call initializer_gate_$read_disk (a_pvtx, LABEL_ADDR, labelp, ec); if ec ^= 0 then return; dtp = a_dtp; dtep = a_dtep; ec = error_table_$no_label; if label.Multics ^= Multics_ID_String then return; if label.version ^= 1 then return; if label.time_registered < reasonable_time then return; ec = error_table_$bad_label; if label.pvid ^= dte.pvid then return; if label.root.here ^= dte.rpv then return; lvep = addr (dt.lv_array (dte.lvx)); if label.lv_name ^= lve.lvname then return; if label.lvid ^= lve.lvid then return; if label.password ^= "0"b then return; if lve.lvname = "root" then dte.pvname = label.pv_name; /* Gran kludge */ else if label.pv_name ^= dte.pvname then return; ec = error_table_$ai_restricted; if label.max_access_class ^= lve.max_access_class then return; if label.min_access_class ^= lve.min_access_class then return; ec = 0; %include disk_pack; %include fs_vol_label; %include disk_table; end verify_label_;  volume_registration_cmds_.pl1 11/11/89 1102.4r w 11/11/89 0803.3 298125 /****^ *********************************************************** * * * 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: ^inddcls,indattr,^indnoniterdo */ volume_registration_cmds_: vrc_: proc; comname = "volume_registration_cmds_"; ec = 0; call FAIL ("This entry not used."); return; /* Logical Volume Registration Functions. add_volume_registration -pv name -lv name2 -model device_model ... change_volume_registration -pv|-lv name ... delete_volume_registration -pv|-lv name list_volume_registration -pv|-lv name {-bf} THVV Modified 4/79 by Michael R. Jordan to require -model in avr and print correct model number in lvr. Modified 84-08-21 by EJ Sharpe to move more of the database manipulation into ring-1 to make these system administrator rather than operator commands. Change name to volume_registration_cmds_ from hvr_. Also added internal documentation. Modified 84-10-30 by EJ Sharpe for some minor upgrades */ /* AUTOMATIC */ dcl ap ptr; /* arg pointer */ dcl al fixed bin (21); /* arg length */ dcl bchr char (al) based (ap); /* args */ dcl pvname char (32) init (""); /* Physical volume name */ dcl location char (32) init ("uninitialized"); dcl dt_str char (24); dcl pvid bit (36) aligned init ("0"b); dcl lvname char (32) init (""); /* Logical volume name */ dcl lvid bit (36) aligned init ("0"b); dcl tcs char (32) init (""); /* Control arg */ dcl tcs1 char (256) init (""); /* Value */ dcl temp_ptr ptr init (null); dcl comname char (32) init ("add_vol_registration"); dcl aa_string char (32) aligned; dcl auth_mnemonics char (172); dcl b36 bit (36) aligned init ("0"b); dcl fb35 fixed bin (35); dcl fb71 fixed bin (71); dcl old_lvid bit (36) init ("0"b); dcl old_lvname char (32) init (""); dcl access_range (2) bit (72) aligned init ("0"b, sys_info$access_class_ceiling); dcl gave_access_low bit (1) init ("0"b); /* TRUE if user specified */ dcl gave_access_high bit (1) init ("0"b); /* TRUE if user specified */ dcl gave_public bit (1) init ("0"b); /* TRUE if user specified */ dcl lv_already_registered bit (1) init ("0"b); dcl new_lv bit (1) init ("0"b); /* TRUE if new seg */ dcl acs_dir char (168) init (""); dcl acs_ent char (32) init (""); dcl ans bit (1); dcl (i, j) fixed bin; dcl more_args bit (1) init ("1"b); dcl argno fixed bin init (1); dcl serial char (32) init ("unspecified"); /* Medium manufacturer's serial */ dcl pubbit bit (1) init ("1"b); /* TRUE if public volume */ dcl owner char (32) init (""); /* Person.Project of vol owner */ dcl owneri fixed bin; /* .. index of dot in owner */ dcl model fixed bin init (0); /* internal model number */ dcl change_model bit (1); dcl change_name bit (1); dcl change_uid bit (1); dcl change_auth bit (1); dcl change_range bit (1); dcl ec fixed bin (35) init (0); dcl ec2 fixed bin (35) init (0); dcl temp_str char (256); /* for building error msgfs, etc */ dcl str_len fixed bin (21); /* length of string passed to ioa_$rsnnl */ /* CONSTANTS */ dcl YESNO (0:1) char (3) static init ("no", "yes"); dcl PVNAME_LEGAL char (37) static options (constant) init ("0123456789abcdefghijklmnopqrstuvwxyz_"); dcl LVNAME_LEGAL char (76) static options (constant) init (" `'_^~+-:{}!.0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"); /* MISC */ dcl (addr, clock, null, rtrim, fixed, hbound, index, length, substr, unspec, verify) builtin; dcl cleanup condition; dcl error_table_$ai_invalid_range fixed bin (35) ext; dcl error_table_$badopt fixed bin (35) ext; dcl error_table_$bad_arg fixed bin (35) ext; dcl error_table_$noarg fixed bin (35) ext; dcl sys_info$access_class_ceiling bit (72) aligned ext; /* ENTRIES */ dcl aim_check_$greater_or_equal entry (bit(72) aligned, bit(72) aligned) returns(bit(1) aligned); dcl com_err_ entry() options(variable); dcl convert_access_class_$from_string entry (bit(72) aligned, char(*), fixed bin(35)); dcl convert_access_class_$from_string_range entry ((2) bit(72) aligned, char(*), fixed bin(35)); dcl convert_access_class_$to_string_short entry (bit(72) aligned, char(*), fixed bin(35)); dcl convert_aim_attributes_ entry (bit(72) aligned) returns(char(32) aligned); dcl convert_date_to_binary_ entry (char(*), fixed bin(71), fixed bin(35)); dcl cv_dec_check_ entry (char(*), fixed bin(35)) returns(fixed bin(35)); dcl cv_oct_check_ entry (char(*), fixed bin(35)) returns(fixed bin(35)); dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin(21), fixed bin(35)); dcl date_time_$format entry (char(*), fixed bin(71), char(*), char(*)) returns(char(250) var); dcl expand_pathname_$add_suffix entry (char(*), char(*), char(*), char(*), fixed bin(35)); dcl get_temp_segment_ entry (char(*), ptr, fixed bin(35)); dcl release_temp_segment_ entry (char(*), ptr, fixed bin(35)); dcl hcs_$truncate_seg entry (ptr, fixed bin(19), fixed bin(35)); dcl command_query_$yes_no entry() options(variable); dcl mdc_priv_$change_lvr entry (char(*), ptr, fixed bin(35)); dcl mdc_priv_$change_pvr entry (char(*), ptr, fixed bin(35)); dcl mdc_priv_$delete_lvr entry (char(*), fixed bin(35)); dcl mdc_priv_$delete_pvr entry (char(*), fixed bin(35)); dcl mdc_priv_$read_lvr entry (char(*), ptr, fixed bin(35)); dcl mdc_priv_$read_pvr entry (char(*), ptr, fixed bin(35)); dcl mdc_priv_$add_lvr entry (char(*), ptr, fixed bin(35)); dcl mdc_priv_$add_pvr entry (char(*), ptr, fixed bin(35)); dcl mdc_$find_volname entry (bit(36), char(*), char(*), fixed bin(35)); dcl pathname_ entry (char(*), char(*)) returns(char(168)); dcl unique_chars_ entry (bit(*)) returns(char(15)); dcl get_group_id_ entry() returns(char(32)); dcl ioa_ entry() options(variable); dcl ioa_$rsnnl entry() options(variable); %page; add_volume_registration: add_vol_registration: /* operator command name - pre MR11 */ avr: entry; /****************************************************************************** This is an administrative command used to register logical or physical volumes. It accepts arguments which specify attributes of the volume being registered. Its syntax is: avr -pv NAME {PV ATTRIBUTE ARGS}... ... -lv NAME {LV ATTRIBUTE ARGS} The "PV ATTRIBUTE ARGS" must include at least the device model. The "LV ATTRIBUTE ARGS" are specified only when registering a new LV. All arguments are non-positional except for the first two (i.e. "pv NAME"). The code is written like: entry setup process args check arg consistancy if LV not already registered then fill in registration structure for new LV and new PV call inner ring else fill in registration structure for new PV call inner ring cleanup exit ******************************************************************************/ call set_up("add_volume_registration"); on cleanup call clean_up; call getarg (tcs); /* First arg must be "pv" */ ec = 0; if ^(tcs = "pv" /* retained for compatability */ | tcs = "-physical_volume" | tcs = "-pv") then do; ec = error_table_$badopt; call FAIL ("First arg must be ""-pv""."); end; call getarg (pvname); /* Get physical volume name */ if pvname = "" then call FAIL ("PV name not specified."); if verify (rtrim (pvname), PVNAME_LEGAL) ^= 0 then call FAIL ("Invalid characters in name: " || pvname); do while (more_args); call getarg (tcs); /* Get control arg */ call getarg (tcs1); /* .. and value */ /* The control args -lv, -access_(high low), -owner, -public, -acs, and -lvid describe the Logical Volume */ if tcs = "-logical_volume" | tcs = "-lv" then do; lvname = tcs1; if verify (rtrim(lvname), LVNAME_LEGAL) ^= 0 then call FAIL("Illegal characters in LV name."); end; else if tcs = "-access_class" | tcs = "-acc" then do; call convert_access_class_$from_string_range (access_range, tcs1, ec); if ec ^= 0 then call FAIL (tcs1); end; /* -access_low and -access_high retained for compatability with the old operator avr command */ else if tcs = "-access_low" | tcs = "-ac_low" then do; call convert_access_class_$from_string (access_range(1), tcs1, ec); if ec ^= 0 then call FAIL ("Illegal auth: " || tcs1); gave_access_low = "1"b; end; else if tcs = "-access_high" | tcs = "-ac_high" then do; call convert_access_class_$from_string (access_range(2), tcs1, ec); if ec ^= 0 then call FAIL ("Illegal auth: " || tcs1); gave_access_high = "1"b; end; else if tcs = "-owner" | tcs = "-ow" then do; call check_owner; if owneri = 0 then call FAIL ("Invalid owner: " || tcs1); end; else if tcs = "-public" | tcs = "-pub" then do; if tcs1 ^= "yes" & tcs1 ^= "y" & tcs1 ^= "no" & tcs1 ^= "n" then do; ec = error_table_$bad_arg; call FAIL("Public argument must be ""yes"" or ""no""."); end; pubbit = ( (tcs1 = "yes") | (tcs1 = "y") ); gave_public = "1"b; end; else if tcs = "-acs_path" | tcs = "-acs" then do; if tcs1 ^= "" then do; call expand_pathname_$add_suffix (tcs1, "acs", acs_dir, acs_ent, ec); if ec ^= 0 then call FAIL ("Bad ACS path: " || tcs1); end; else do; acs_dir = ""; acs_ent = ""; end; end; else if tcs = "-logical_volume_uid" | tcs = "-lvid" then do; fb35 = cv_oct_check_ (tcs1, ec2); lvid = unspec(fb35); if ec2 ^= 0 then call FAIL ("Invalid LVID: " || tcs1); end; /* The rest of the control arguments (-pvid, -model, -location, and -serial) are PV specific */ else if tcs = "-physical_volume_uid" | tcs = "-pvid" then do; fb35 = cv_oct_check_ (tcs1, ec2); pvid = unspec(fb35); if ec2 ^= 0 then call FAIL ("Invalid PVID: " || tcs1); end; else if tcs = "-device_model" | tcs = "-model" then do; i = cv_dec_check_ (tcs1, ec2); if ec2 ^= 0 then call FAIL ("Invalid model: " || tcs1); do model = 1 to hbound (MODEL, 1) while (i ^= MODEL (model)); end; if model > hbound (MODEL, 1) then call FAIL ("Unknown model: " || tcs1); model = MODELX (model); end; else if tcs = "-manufacturer_serial" | tcs = "-serial" then serial = tcs1; else if tcs = "-location" | tcs = "-loc" then location = tcs1; /* no control arg for "password" field */ else do; ec = error_table_$badopt; call FAIL (tcs); end; end; if model = 0 /* Missing -model control arg */ then do; ec = error_table_$noarg; call FAIL ("-model must be specified"); end; if lvname = "" then call FAIL ("""-lv"" must be specified."); /* Check given args */ call mdc_priv_$read_lvr (lvname, vrp, ec); lv_already_registered = ( ec = 0 ); if lv_already_registered & (gave_access_low | gave_access_high | gave_public | owner^="" | acs_dir^="" | lvid) then call FAIL ("LV already registered, use change_volume_registration to modify its attributes."); call mdc_priv_$read_pvr (pvname, vrp, ec); if ec = 0 then call FAIL ("PV already registered: " || pvname); ec = 0; if gave_access_low | gave_access_high then if ^aim_check_$greater_or_equal (access_range(2), access_range(1)) then do; ec = error_table_$ai_invalid_range; call FAIL (""); end; call hcs_$truncate_seg (vrp, 0, ec); /* initialize registration */ if ec ^= 0 then call FAIL ("Trouble initializing structure."); if ^lv_already_registered then do; /* code to register new LV */ if ^pubbit | acs_dir ^= "" then do; /* Is ACS requested or needed? */ if acs_dir = "" then do; str_len = length (acs_dir); call ioa_$rsnnl (">udd>^a>^a", acs_dir, str_len, substr(owner, owneri+1), substr (owner, 1, owneri-1)); acs_ent = rtrim(lvname)||".acs"; end; else if acs_ent ^= rtrim(lvname)||".acs" then call FAIL ("Invalid ACS path."); end; /* first let's check with user */ call command_query_$yes_no (ans, 0, comname, "", "LV ""^a"" does not exist. Do you wish to create it? ", lvname); if ^ans then do; /* must've mis-typed LV name */ call clean_up; return; end; if owner = "" then do; /* if owner not specified, we'll make it the caller */ owner = get_group_id_ (); i = length(rtrim(owner))-2; owner = substr(owner, 1, i); /* strip off tag */ owneri = index (owner, "."); end; /* fill in the registration structure... */ volume_registration.version = Volume_Registration_Version_2; if lvid then volume_registration.lvid = lvid; else do; fb71 = clock(); volume_registration.lvid = substr (unspec (fb71), 36, 36); end; volume_registration.lvname = lvname; volume_registration.volume_owner = owner; volume_registration.public = pubbit; volume_registration.access_class_range = access_range; if acs_dir = "" & acs_ent = "" then volume_registration.acs_path = ""; else volume_registration.acs_path = pathname_ (acs_dir, acs_ent); volume_registration.npv = 1; /* registering first right now */ /* now, let's get the first PV into the registration */ volume_registration.npv = 1; pvrp = addr (volume_registration.pv(1)); /* use first entry */ if pvid then pv_registration.pvid = pvid; else do; fb71 = clock(); pv_registration.pvid = substr (unspec (fb71), 36, 36); end; pv_registration.model = model; pv_registration.pvname = pvname; pv_registration.location = location; pv_registration.mfg_serial = serial; pv_registration.password = "0"b; pv_registration.date_registered = clock (); call mdc_priv_$add_lvr (lvname, vrp, ec); if ec ^= 0 then call FAIL ("Cannot register: " || lvname); call ioa_ ("^a: Registered PV ""^a"" (pvid ^w) on new LV ""^a"" lvid ^w).", comname, pvname, volume_registration.pv(1).pvid, lvname, volume_registration.lvid); end; else do; /* we'll just add a new PV to an existing LV */ if pvid then pv_registration.pvid = pvid; else do; fb71 = clock(); pv_registration.pvid = substr (unspec (fb71), 36, 36); end; pv_registration.model = model; /* Fill in per-pak data */ pv_registration.pvname = pvname; pv_registration.location = location; pv_registration.mfg_serial = serial; pv_registration.password = "0"b; pv_registration.date_registered = clock (); call mdc_priv_$add_pvr (lvname, pvrp, ec); if ec ^= 0 then call FAIL ("Cannot register: " || pvname); call ioa_ ("^a: Registered PV ""^a"" (pvid ^w) on LV ""^a"".", comname, pvname, pvrp->pv_registration.pvid, lvname); end; call clean_up; return; %page; change_volume_registration: change_vol_registration: /* operator command name - pre MR11 */ cvr: entry; /****************************************************************************** This is an administrative command which facilitates the adjustment of volume attributes. Its syntax is: cvr [-pv | -lv] NAME {PV or LV ATTRIBUTE ARGS} Some volume attributes should not be changed when the physical disk medium has already been initialized. This is because some attributes (e.g. name and unique identifier) are written onto the medium label at initialization and cannot be altered without re-initialization of the medium. The code is written like: entry setup if first arg is "pv" then process args for PV check arg consistancy fill in PV registration structure with changes call inner ring else if first arg is "lv" then process args for LV check arg consistancy fill in LV registration structure with changes call inner ring else first arg is in error cleanup exit ******************************************************************************/ call set_up("change_volume_registration"); on cleanup call clean_up; call getarg (tcs); ec = 0; change_model, change_name, change_uid, change_auth, change_range = "0"b; if tcs = "pv" /* retained for compatability */ | tcs = "-physical_volume" | tcs = "-pv" then do; pvrp = vrp; /* use pv_registration instead of volume_registration */ call getarg (pvname); /* yes */ call mdc_priv_$read_pvr (pvname, pvrp, ec); if ec ^= 0 then call FAIL ("PV not found: " || pvname); do while (more_args); call getarg (tcs); /* Get control arg */ call getarg (tcs1); /* .. and value */ if tcs = "-device_model" | tcs = "-model" then do; j = cv_dec_check_ (tcs1, ec2); if ec2 ^= 0 then call FAIL("Invalid model: "||tcs1); else do; do model = 1 to hbound (MODEL, 1) while (j ^= MODEL (model)); end; if model > hbound (MODEL, 1) then call FAIL("Unknown model: "||tcs1); else do; model = MODELX (model); pv_registration.model = model; end; end; change_model = "1"b; end; else if tcs = "-manufacturer_serial" | tcs = "-serial" then pv_registration.mfg_serial = tcs1; else if tcs = "-location" | tcs = "-loc" then pv_registration.location = tcs1; else if tcs = "-date_registered" | tcs = "-dtr" then do; call convert_date_to_binary_ (tcs1, pv_registration.date_registered, ec); if ec ^= 0 then call FAIL("Bad date: "||tcs1); end; else if tcs = "-name" | tcs = "-nm" then do; if verify (rtrim (tcs1), PVNAME_LEGAL) ^= 0 then call FAIL ("Invalid characters in name: " || tcs1); else pv_registration.pvname = tcs1; change_name = "1"b; end; else if tcs = "-physical_volume_uid" | tcs = "-pvid" then do; fb35 = cv_oct_check_ (tcs1, ec2); b36 = unspec(fb35); if ec2 ^= 0 then call FAIL("Invalid PVID: "||tcs1); else pv_registration.pvid = b36; change_uid = "1"b; end; /* there is no control arg for changing "password" field */ else do; ec = error_table_$bad_arg; call FAIL("Bad control arg: "||tcs||" "||tcs1); end; end; if change_model | change_name | change_uid then do; call command_query_$yes_no (ans, 0, comname, "", "PV model, name, or uid should not be changed for initialized volumes. Do you wish to continue? "); if ^ans then do; call clean_up; return; end; end; /* now tell ring-1 to do it! */ call mdc_priv_$change_pvr (pvname, pvrp, ec); if ec ^= 0 then call FAIL ("Could not make changes."); call ioa_ ("^a: Changed attributes for PV ""^a"".", comname, pvname); end; else if tcs = "lv" /* retained for compatability */ | tcs = "-logical_volume" | tcs = "-lv" then do; call getarg (lvname); call mdc_priv_$read_lvr (lvname, vrp, ec); if ec ^= 0 then call FAIL ("LV not registered: " || lvname); volume_registration.npv = 0; /* don't care about the PV entries... */ do while (more_args); call getarg (tcs); call getarg (tcs1); if tcs = "-access_class" | tcs = "-acc" then do; call convert_access_class_$from_string_range (access_range, tcs1, ec); if ec ^= 0 then call FAIL (tcs1); change_range = "1"b; volume_registration.access_class_range = access_range; end; /* -access_low and -access_high retained for compatability with the old operator cvr command */ else if tcs = "-access_low" | tcs = "-ac_low" then do; call convert_access_class_$from_string (access_range(1), tcs1, ec); if ec ^= 0 then call FAIL("Illegal auth: "||tcs1); else volume_registration.access_class_range(1) = access_range(1); change_auth = "1"b; end; else if tcs = "-access_high" | tcs = "-ac_high" then do; call convert_access_class_$from_string (access_range(2), tcs1, ec); if ec ^= 0 then call FAIL("Illegal auth: "||tcs1); else volume_registration.access_class_range(2) = access_range(2); change_auth = "1"b; end; else if tcs = "-public" | tcs = "-pub" then do; if tcs1 ^= "yes" & tcs1 ^= "y" & tcs1 ^= "no" & tcs1 ^= "n" then call FAIL("Public argument must be ""yes"" or ""no""."); volume_registration.public = ( (tcs1 = "yes") | (tcs1 = "y") ); end; else if tcs = "-acs_path" | tcs = "-acs" then do; if tcs1 ^= "" then do; call expand_pathname_$add_suffix (tcs1, "acs", acs_dir, acs_ent, ec); if ec ^= 0 then call FAIL("Bad acs path: "||tcs1); if acs_ent ^= rtrim(lvname)||".acs" then call FAIL ("Bad acs path: "||tcs1); volume_registration.acs_path = pathname_ (acs_dir, acs_ent); end; else do; acs_dir = ""; acs_ent = ""; volume_registration.acs_path = ""; end; end; else if tcs = "-owner" | tcs = "-ow" then do; call check_owner; if owneri = 0 then do; ec = error_table_$bad_arg; call FAIL("Invalid owner: "||tcs1); end; else volume_registration.volume_owner = owner; end; else if tcs = "-name" | tcs = "-nm" then do; if verify (rtrim(tcs1), LVNAME_LEGAL) ^= 0 then call FAIL("Illegal characters in LV name."); volume_registration.lvname = tcs1; change_name = "1"b; end; else if tcs = "-logical_volume_uid" | tcs = "-lvid" then do; fb35 = cv_oct_check_ (tcs1, ec2); b36 = unspec(fb35); if ec2 ^= 0 then call FAIL("Invalid LVID: "||tcs1); else volume_registration.lvid = b36; change_uid = "1"b; end; else do; ec = error_table_$badopt; call FAIL(tcs); end; end; if change_auth then if ^aim_check_$greater_or_equal (volume_registration.access_class_range(2), volume_registration.access_class_range(1)) then do; ec = error_table_$ai_invalid_range; call FAIL (""); end; if change_range | change_auth | change_name | change_uid then do; call command_query_$yes_no (ans, 0, comname, "", "LV access class, name, or uid should not be changed for initialized volumes. Do you wish to continue? "); if ^ans then do; call clean_up; return; end; end; /* now get ring-1 to make the changes */ call mdc_priv_$change_lvr (lvname, vrp, ec); if ec ^= 0 then call FAIL ("Unable to make changes."); call ioa_ ("^a: Changed attributes of LV ""^a"".", comname, lvname); end; else do; ec = error_table_$badopt; call FAIL ("First arg must be ""-pv"" or ""-lv""."); end; call clean_up; return; %page; delete_volume_registration: del_vol_registration: /* operator command name - pre MR11 */ dvr: entry; /****************************************************************************** This is an administrative command used to remove the registration of a logical or physical volume. Its syntax is: dvr [-lv | -pv] NAME Physical volumes should only be deregistered when their contents have been moved onto other physical volumes (within the same logical volume). Logical volumes should only be deregistered when their corresponding directory hierearchies have been removed from the system (thus leaving the whole LV empty). Since a logical volume must always have at least one physical volume, the last PV in an LV may not be deleted from the LV, the LV itself must be deleted. The code is written like: entry setup if first arg is "pv" then check existance of PV get name of PV's LV check LV for more than one PV call inner ring to delete PV else if first arg is "lv" then check existance of LV list names of PVs being deleted with the LV call inner ring to delete LV else first arg is invalid cleanup exit ******************************************************************************/ call set_up("delete_volume_registration"); on cleanup call clean_up; call getarg (tcs); ec = 0; if tcs = "pv" /* retained for compatability */ | tcs = "-physical_volume" | tcs = "-pv" then do; call getarg (pvname); if verify (rtrim(pvname), PVNAME_LEGAL) ^= 0 then call FAIL("Illegal characters in PV name."); call mdc_priv_$read_pvr (pvname, pvrp, ec); if ec ^= 0 then call FAIL ("PV not found: " || pvname); call mdc_$find_volname ((pv_registration.pvid), pvname, lvname, ec); if ec ^= 0 then call FAIL ("Unable to get LV name."); call mdc_priv_$read_lvr (lvname, vrp, ec); if ec ^= 0 then call FAIL ("Unable to get LV data."); if volume_registration.npv = 1 then do; str_len = length (temp_str); call ioa_$rsnnl ("PV ""^a"" is last in LV ""^a"". User ""dvr lv ^a"".", temp_str, str_len, pvname, lvname, lvname); call FAIL (temp_str); end; call mdc_priv_$delete_pvr (pvname, ec); if ec ^= 0 then call FAIL ("Cannot delete: " || pvname); call ioa_ ("^a: Deleted PV ""^a"" from LV ""^a"".", comname, pvname, lvname); end; else if tcs = "lv" /* retained for compatability */ | tcs = "-logical_volume" | tcs = "-lv" then do; call getarg (lvname); if verify(rtrim(lvname), LVNAME_LEGAL) ^= 0 then call FAIL("Illegal characters in LV name."); call mdc_priv_$read_lvr (lvname, vrp, ec); if ec ^= 0 then call FAIL ("LV not registered: " || lvname); do i = 1 to volume_registration.npv; call ioa_ ("^a: Deleting PV ""^a"" from LV ""^a"".", comname, volume_registration.pv (i).pvname, lvname); end; call mdc_priv_$delete_lvr (lvname, ec); if ec ^= 0 then call FAIL ("Cannot modify: " || lvname); call ioa_ ("^a: Deleted LV ""^a"".", comname, lvname); end; else do; ec = error_table_$badopt; call FAIL ("First arg must be ""-pv"" or ""-lv""."); end; call clean_up; return; %page; list_volume_registration: list_vol_registration: /* operator command name - pre MR11 */ lvr: entry; /****************************************************************************** This is an administrative command which lists the attributes of the specified logical or physical volume. Its syntax is: lvr [-pv | -lv] NAME {-brief} When listing a logical volume, all physical volumes in that logical volume will be listed unless "-brief" is given. The code is written like: entry setup if first arg is "pv" then call inner ring for PV registration structure format report of PV and print else if first arg is "lv" then call inner ring for LV registration structure (including all PVs in that LV) if brief arg not given then format report of LV and print if brief arg given then print only the PV names else format report of each PV and print else first arg is invalid cleanup exit ******************************************************************************/ call set_up("list_volume_registration"); on cleanup call clean_up; call getarg (tcs); if tcs = "pv" /* retained for compatability */ | tcs = "-physical_volume" | tcs = "-pv" then do; call getarg (pvname); if verify(rtrim(pvname), PVNAME_LEGAL) ^= 0 then call FAIL("Illegal characters in PV name."); call mdc_priv_$read_pvr (pvname, vrp, ec); if ec ^= 0 then call FAIL ("PV not found: " || pvname); call mdc_$find_volname ((pv_registration.pvid), pvname, lvname, ec); if ec ^= 0 then call FAIL ("Unable to get LV name."); call ioa_ ("^/pvname:^-^a", pv_registration.pvname); call ioa_ ("pvid:^-^-^w (^a)", pv_registration.pvid, unique_chars_((pv_registration.pvid))); call ioa_ ("serial:^-^-^a", pv_registration.mfg_serial); call ioa_ ("model:^-^-^d", MODELN (pv_registration.model)); call ioa_ ("location:^-^-^a", pv_registration.location); dt_str = date_time_$format ("date_time", pv_registration.date_registered, "", ""); call ioa_ ("date registered:^-^a", dt_str); /* password field not printed */ call ioa_ ("lvname:^-^-^a", lvname); end; else if tcs = "lv" /* retained for compatability */ | tcs = "-logical_volume" | tcs = "-lv" then do; call getarg (lvname); if verify(rtrim(lvname), LVNAME_LEGAL) ^= 0 then call FAIL("Illegal characters in LV name."); call mdc_priv_$read_lvr (lvname, vrp, ec); if ec ^= 0 then call FAIL ("LV not registered: " || lvname); call getarg (tcs); if tcs ^= "-bf" & tcs ^= "-brief" then do; call ioa_ ("^/lvname:^-^a", lvname); call ioa_ ("lvid:^-^-^w (^a)", volume_registration.lvid, unique_chars_((volume_registration.lvid))); call ioa_ ("public:^-^-^a", YESNO (fixed (volume_registration.public, 1))); call ioa_ ("owner:^-^-^a", volume_registration.volume_owner); aa_string = convert_aim_attributes_ (volume_registration.access_class_range(1)); call convert_access_class_$to_string_short (volume_registration.access_class_range(1), auth_mnemonics, ec); if ec ^= 0 then do; call com_err_ (ec, comname, "Unable to convert min auth to name string."); auth_mnemonics = "system_low?"; end; call ioa_ ("min_access_class:^-^a (^a)", aa_string, auth_mnemonics); aa_string = convert_aim_attributes_ (volume_registration.access_class_range(2)); call convert_access_class_$to_string_short (volume_registration.access_class_range(2), auth_mnemonics, ec); if ec ^= 0 then do; call com_err_ (ec, comname, "Unable to convert max auth to name string."); auth_mnemonics = "system_high?"; end; call ioa_ ("max_access_class:^-^a (^a)", aa_string, auth_mnemonics); call ioa_ ("acs_path:^-^-^a", volume_registration.acs_path); call ioa_ ("^/npv:^-^-^d", volume_registration.npv); end; do i = 1 to volume_registration.npv; pvrp = addr(volume_registration.pv(i)); if tcs = "-bf" | tcs = "-brief" then call ioa_ ("^a", pv_registration.pvname); else do; call ioa_ ("^/ pvname:^-^a", pv_registration.pvname); call ioa_ (" pvid:^-^-^w (^a)", pv_registration.pvid, unique_chars_((pv_registration.pvid))); call ioa_ (" serial:^-^-^a", pv_registration.mfg_serial); call ioa_ (" model:^-^-^d", MODELN (pv_registration.model)); call ioa_ (" location:^-^a", pv_registration.location); dt_str = date_time_$format ("date_time", pv_registration.date_registered, "", ""); call ioa_ (" date registered:^-^a", dt_str); /* password field not printed */ end; end; end; else do; ec = error_table_$badopt; call FAIL ("First arg must be ""-pv"" or ""-lv""."); end; call ioa_ (""); call clean_up; return; %page; /* -------------- UTILITY ROUTINES ---------------------- */ /* ------------------------------------------------------ */ set_up: proc (name); /* initializations for all entrypoints */ dcl name char (*); comname = name; ec = 0; temp_ptr, vrp, pvrp = null(); call get_temp_segment_ (comname, temp_ptr, ec); if ec ^= 0 then call FAIL ("Trouble getting temporary segment."); vrp, pvrp = temp_ptr; /* we'll use temp for either structure */ return; end set_up; /* ------------------------------------------------------ */ clean_up: proc (); /* clean up our external mess... */ dcl tptr ptr; if temp_ptr ^= null () then do; tptr = temp_ptr; temp_ptr = null (); /* so we don't try this again */ call release_temp_segment_ (comname, temp_ptr, ec); end; return; end clean_up; /* ------------------------------------------------------ */ getarg: proc (x); /* get next argument on command line */ dcl x char (*); dcl errc fixed bin (35); call cu_$arg_ptr (argno, ap, al, errc); if errc = 0 then do; if al > length(x) then call FAIL ("Argument too long"); x = bchr; end; else x = ""; argno = argno + 1; call cu_$arg_ptr (argno, ap, al, errc); if errc ^= 0 | bchr = "" then more_args = "0"b; return; end getarg; /* ------------------------------------------------------ */ FAIL: proc (x); /* come here when something bad happens */ dcl x char (*); call com_err_ (ec, comname, "^a", x); call clean_up; go to BUST; end FAIL; BUST: return; /* return from this module */ /* ------------------------------------------------------ */ check_owner: proc; /* validates Person_ID.Project_ID */ owneri = index (tcs1, "."); if owneri = 0 then return; if index (substr (tcs1, owneri+1), ".") ^= 0 then owneri = 0; else owner = tcs1; return; end check_owner; %page; %include volume_registration; %page; %include fs_dev_types; /* ------------------------------------------------------ */ /* ------------------------------------------------------ */ end volume_registration_cmds_;  volume_registration_mgr_.pl1 11/11/89 1102.4r w 11/11/89 0803.3 975069 /****^ *********************************************************** * * * 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. * * * *********************************************************** */ /****^ HISTORY COMMENTS: 1) change(85-07-10,EJSharpe), approve(86-02-20,MCR7304), audit(86-03-27,CLJones), install(86-04-23,MR12.0-1044): added get_access_for_attach entrypoint in order for rcp_attach_lv_ to perform security auditing The two "get_access" entries should be merged into an access kernel for MDC and LV mgmt. END HISTORY COMMENTS */ /* format: style1,insnl,linecom,indcomtxt,^inddcls,^indnoniterdo */ volume_registration_mgr_: vrm_: proc; /* Logical Volume Registration Guts. This program knows where the volume registration data for logical volumes is kept. It contain entries called by the volume_registration_cmds_ and service entries called by many other programs. The whole program runs in ring 1. Written by T. H. VanVleck Modified July 1981 by J. Bongiovanni to validate lvx. Modified 83-12-06 BIM to use RCP privilege to circumvent AIM. Modified 83-12-07 BIM to update disk table from vol registration. Modified 84-08-21 by EJ Sharpe This module used to be named "hdx". removed entries: read_hv, read_pv, write_hv, delete_hv, make_link, and chname_hv. Replaced with add_lvr, add_pvr, read_lvr, read_pvr, change_lvr, change_pvr, delete_lvr, and delete_pvr. These entries do their own work (don't rely on ring 4 caller) and now set a lock while changing the database. Also, added auditing of database changes, removed ACS link hack, changed module name to volume_registration_mgr_, and generally improved the code. (This was all in order to move the registration commands from the operator interface to the system administrator's - for B2.) One more thing - fixed hardcore error #643 - LV access now not dependant on AIM and ring brackets of ACS. Modified 84-10-31 by EJ Sharpe for some misc upgrades and change get_access entry to return bit (36) modes instead of fixed bin (5). Modified 84-12-17 by EJ Sharpe for fixes: 1) use currentsize instead of size in reference to volume_registration 2) attempt delete of MDCS before deleting registration data file 3) use hcs_$get_user_raw_mode for LV access computation Modified 84-12-27 by Keith Loepere for version 2 create_branch_info. Modified 85-01-18 by EJ Sharpe for handling unexpected conditions properly in a ring 1 process (e.g. Dumper) */ %page; /* PARAMETERS */ dcl a_lvname char (*); /* Logical Volume name */ dcl a_lv_access_class_range (2) bit (72) aligned; /* returned from get_access_for_attach */ dcl a_dtp ptr; /* disk_table ptr */ dcl a_ptr ptr; /* ptr to volume_registration or pv_registration */ dcl a_ec fixed bin (35); /* error code */ dcl a_pvname char (*); /* Physical Volume name */ dcl a_device_type fixed bin; /* model of disk drive */ dcl a_lvid bit (36); /* Logical volume uid */ dcl a_pvid bit (36); /* Physical volume ID (input) */ dcl a_level fixed bin (3); /* validation level (input) */ dcl a_mode bit (36) aligned; /* effective mode (output) */ dcl a_pub_bit bit (1) aligned; /* volume is public (output) */ dcl a_pvap ptr; /* ptr to pva (input) */ dcl a_npv fixed bin; /* number returned (output) */ dcl a_lvx fixed bin; /* logical volume index (in disk_table) */ dcl a_dtep ptr; /* disk_table entry ptr */ dcl a_dn char (*); /* dir name */ dcl a_dn2 char (*); /* dir name */ /* AUTOMATIC */ dcl MYNAME char (65) init (""); /* first thing set by each entry */ dcl lvid_changed bit (1); /* flag used by change-lvr */ dcl pvid_changed bit (1); /* flag used by change_pvr */ dcl lvid bit (36) aligned; /* temp */ dcl old_lvid bit (36) aligned; /* used by change_lvr */ dcl new_lvid bit (36) aligned; /* used by change_lvr */ dcl pvid bit (36) aligned; /* temp */ dcl old_pvid bit (36) aligned; /* used by change_pvr */ dcl new_pvid bit (36) aligned; /* used by change_pvr */ dcl uname char (32); /* unique name temp */ dcl uname2 char (32); /* unique name temp */ dcl old_uname char (32); /* used by change_(lvr pvr) */ dcl new_uname char (32); /* used by change_(lvr pvr) */ dcl pvname char (32); /* temp */ dcl old_pvname char (32); /* used by change_pvr */ dcl new_pvname char (32); /* used by change_pvr */ dcl lvname char (32); /* temp */ dcl old_lvname char (32); /* used by change_lvr */ dcl new_lvname char (32); /* used by change_lvr */ dcl old_aa_str char (168); /* access auth string used by change_lvr */ dcl new_aa_str char (168); /* access auth string used by change_lvr */ dcl old_dt_reg char (24); /* date-time string used by change_pvr */ dcl new_dt_reg char (24); /* date-time string used by change_pvr */ dcl level fixed bin; dcl npvrp ptr; /* pointer to new pv_reg struct */ dcl nvrp ptr; /* pointer to new vol_reg struct */ dcl upvrp ptr; /* pointer to user's pv_reg struct */ dcl uvrp ptr; /* pointer to user's vol_reg struct */ dcl tsegp ptr init (null); /* pointer to temporary seg */ dcl databasep ptr init (null); /* pointer to volume registration database */ dcl dn char (168); /* Volume registration DB dir */ dcl en char (32); /* Volume registration DB entry */ dcl mode bit (36) aligned; /* access mode */ dcl type fixed bin (2); /* entry type */ dcl bc fixed bin (24); /* bit count */ dcl (i, j) fixed bin; /* index vars */ dcl owner char (32); /* Person.Project of vol owner */ dcl (proj, oproj) char (9); /* temps for access check */ dcl (pers, opers) char (22); /* temps for access check */ dcl old_level fixed bin init (-1); dcl ec fixed bin (35); /* error code */ dcl ec2 fixed bin (35); /* error code */ dcl make_lve bit (1); /* flag for lvname_info/ get_lv_pvinfo */ dcl auth_mnemonics char (172); /* string to hold human readable form of AIM stuff */ dcl temp_str char (512); /* temp area for formatting strings */ dcl tstr_len fixed bin (21); /* length of formatted strings */ dcl pub_bit bit (1) aligned; /* used in get_access */ dcl set_access_range bit (1) aligned; /* indicator for get_access/get_access_for_attach entries */ dcl access_class_range (2) bit (72) aligned init ("0"b, sys_info$access_class_ceiling); dcl 1 aa aligned, /* access for lv.** segs */ 2 name char (32) init ("*.*.*"), 2 mode bit (36) init ("101"b), 2 mbz bit (36) init ((36)"0"b), 2 code fixed bin (35); dcl 1 dacl aligned, /* access for >lv */ 2 name char (32) init ("*.SysAdmin.*"), 2 mode bit (36) init ("111"b), 2 code fixed bin (35); dcl 1 CBI aligned like create_branch_info; /* STATIC */ dcl testing bit (1) static init ("0"b); dcl sdtp ptr static init (null); dcl first bit (1) static init ("1"b); dcl PRIV (0:1) char (8) static options (constant) init ("private", "public"); dcl LVNAME_LEGAL char (76) int static options (constant) init /* Valid characters for LV names. */ (" '_`~^+-.{}:!0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"); dcl PVNAME_LEGAL char (37) int static options (constant) init ("0123456789abcdefghijklmnopqrstuvwxyz_"); dcl PV bit (1) static init ("0"b) options (constant); dcl LV bit (1) static init ("1"b) options (constant); dcl INIT bit (1) static init ("0"b) options (constant); dcl DONT_INIT bit (1) static init ("1"b) options (constant); dcl SMALL_DT fixed bin (71) static options (constant) init (2019686401000000); /* 01/01/65 00:00:01 */ dcl ROOT char (168) static init (">lv"); /* may be changed by "test" entrypoint */ dcl LV_DIR char (168) static init (">lv"); /* may be changed by "test" entrypoint */ dcl (REAL_LV_DIR) char (168) static init (">lv") options (constant); /* MISC */ dcl sys_info$access_class_ceiling bit (72) aligned external; dcl (cleanup, any_other) condition; dcl (addr, baseno, clock, currentsize, fixed, hbound, index, lbound, length, null, rtrim, string, substr, unspec, verify) builtin; /* ERROR CODES */ dcl error_table_$improper_data_format fixed bin (35) ext; dcl error_table_$unimplemented_version fixed bin (35) ext; dcl error_table_$action_not_performed fixed bin (35) ext; dcl error_table_$argerr fixed bin (35) ext; dcl error_table_$bad_segment fixed bin (35) ext; dcl error_table_$unregistered_volume fixed bin (35) ext; dcl error_table_$fatal_error fixed bin (35) ext; dcl error_table_$bad_volid fixed bin (35) ext; dcl error_table_$incorrect_device_type fixed bin (35) ext; dcl error_table_$segknown fixed bin (35) ext; dcl error_table_$segnamedup fixed bin (35) ext; dcl error_table_$namedup fixed bin (35) ext; dcl error_table_$bad_arg fixed bin (35) ext; dcl error_table_$unexpected_condition fixed bin (35) ext; /* ENTRIES */ dcl aim_check_$in_range entry (bit (72) aligned, (2) bit (72) aligned) returns (bit (1)); dcl aim_check_$greater_or_equal entry (bit (72) aligned, bit (72) aligned) returns (bit (1) aligned); dcl ioa_$general_rs entry (ptr, fixed bin, fixed bin, char (*), fixed bin (21), bit (1) aligned, bit (1) aligned); dcl admin_gate_$syserr entry () options (variable); dcl admin_gate_$syserr_error_code entry () options (variable); dcl admin_gate_$reclassify_sys_seg entry (char (*), char (*), bit (72) aligned, fixed bin (35)); dcl display_access_class_ entry (bit (72) aligned) returns (char (32) aligned); dcl date_time_$format entry (char (*), fixed bin (71), char (*), char (*)) returns (char (250) var); dcl get_temp_segment_ entry (char (*), ptr, fixed bin (35)); dcl get_ring_ entry () returns (fixed bin (3)); dcl get_initial_ring_ entry () returns (fixed bin); dcl release_temp_segment_ entry (char (*), ptr, fixed bin (35)); dcl vrm_lock_$vrm_data_init entry (); dcl vrm_lock_$lock entry (fixed bin (35)); dcl vrm_lock_$cleanup entry (); dcl cu_$arg_list_ptr entry (ptr); dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin (21), fixed bin (35)); dcl cu_$level_get entry (fixed bin); dcl cu_$level_set entry (fixed bin); dcl com_err_ entry () options (variable); dcl continue_to_signal_ entry (fixed bin (35)); dcl expand_path_ entry (ptr, fixed bin (21), ptr, ptr, fixed bin (35)); dcl expand_pathname_ entry (char (*), char (*), char (*), fixed bin (35)); dcl pathname_ entry (char (*), char (*)) returns (char (168)); dcl mdc_repair_$make_mdcs entry (char (*), bit (36) aligned, fixed bin (35)); dcl mdc_repair_$update_lvid entry (char (*), bit (36) aligned, bit (36) aligned, fixed bin (35)); dcl mdc_repair_$rename_mdcs entry (char (*), bit (36) aligned, char (*), fixed bin (35)); dcl mdc_repair_$delete_mdcs entry (char (*), bit (36) aligned, fixed bin (35)); dcl mdc_repair_$recreate_mdcs entry (char (*), bit (36) aligned, fixed bin (35)); dcl mdc_init_ entry (); dcl get_authorization_ entry () returns (bit (72) aligned); dcl get_privileges_ entry () returns (bit (36) aligned); dcl get_group_id_ entry () returns (char (32)); dcl hcs_$replace_acl entry (char (*), char (*), ptr, fixed bin, bit (1), fixed bin (35)); dcl hcs_$append_link entry (char (*), char (*), char (*), fixed bin (35)); dcl hcs_$chname_seg entry (ptr, char (*), char (*), fixed bin (35)); dcl hcs_$create_branch_ entry (char (*), char (*), ptr, fixed bin (35)); dcl hcs_$get_user_raw_mode entry (char (*), char (*), char (*), bit (36) aligned, fixed bin (35)); dcl delete_$path entry (char (*), char (*), bit (36) aligned, char (*), fixed bin (35)); dcl delete_$ptr entry (ptr, bit (36) aligned, char (*), fixed bin (35)); dcl hcs_$add_dir_acl_entries entry (char (*), char (*), ptr, fixed bin, fixed bin (35)); dcl hcs_$initiate entry (char (*), char (*), char (*), fixed bin (1), fixed bin (2), ptr, fixed bin (35)); dcl hcs_$make_seg entry (char (*), char (*), char (*), fixed bin (5), ptr, fixed bin (35)); dcl hcs_$set_bc_seg entry (ptr, fixed bin (24), fixed bin (35)); dcl hcs_$set_damaged_sw entry (char (*), char (*), bit (1), fixed bin (35)); dcl hcs_$set_damaged_sw_seg entry (ptr, bit (1), fixed bin (35)); dcl hphcs_$set_rpv entry (char (*), char (*), fixed bin (35)); dcl hcs_$status_minf entry (char (*), char (*), fixed bin (1), fixed bin (2), fixed bin (24), fixed bin (35)); dcl hcs_$terminate_noname entry (ptr, fixed bin (35)); dcl hcs_$truncate_seg entry (ptr, fixed bin (19), fixed bin (35)); dcl read_allowed_ entry (bit (72) aligned, bit (72) aligned) returns (bit (1) aligned); dcl write_allowed_ entry (bit (72) aligned, bit (72) aligned) returns (bit (1) aligned); dcl unique_chars_ entry (bit (*)) returns (char (15)); dcl convert_access_class_$to_string_short entry (bit (72) aligned, char (*), fixed bin (35)); %page; /* ===================================================== */ /* INIT - Entry called during system initialization to get set up. */ /* Salvaging, if necessary, is done later by mdx$init. */ init: entry (a_dtp); /* Called from mdx */ /**** ************************************************************************** This entry is called at system initialization time by mdx$init (which is invoked by disk_table_$init just prior to ring-1 initializer command level). This "init" entry simply saves a copy of the disk_table points for later use, sets up its lock segment >sl1>vrm_data, and calls mdc_init_ (which simply sets up the lock segment for Master Directory Control). ************************************************************************** ****/ MYNAME = "volume_registration_mgr_$init"; sdtp = a_dtp; /* Save ptr to disk_table */ call hcs_$set_damaged_sw_seg (sdtp, "0"b, (0)); /* We will salvage */ call vrm_lock_$vrm_data_init (); /* set up lock seg */ call mdc_init_; /* get master directory control going */ return; %page; /* ===================================================== */ /* Primitive entry points to read and write volume registration segments. read_lvr read_pvr add_lvr add_pvr delete_lvr delete_pvr change_lvr change_pvr These entries are called through mdc_priv_ from volume_registration_cmds_ */ /* ===================================================== */ /* READ_LVR - Entry to return registration database for given LV */ read_lvr: entry (a_lvname, a_ptr, a_ec); /**** ************************************************************************** Reads the LV registration data, including the data for all PVs belonging to that LV, into a place provided by the caller. The caller supplies the PV name. ************************************************************************** ****/ MYNAME = "volume_registration_mgr_$read_lvr"; on any_other call emergency_exit; on cleanup call clean_up; /* COPY ARGS */ lvname = a_lvname; uvrp = a_ptr; call locate_ (lvname, LV, INIT); /* Parse name */ uvrp -> volume_registration = volume_registration;/* Copy whole seg to user ring */ ec = 0; goto EXIT; %page; /* READ_PVR - Entry to return data structure for given PV */ read_pvr: entry (a_pvname, a_ptr, a_ec); /* Same thing given pvname */ /**** ************************************************************************** Reads the PV registration data for a single PV into a place provided by the caller. The caller supplies the PV name. ************************************************************************** ****/ MYNAME = "volume_registration_mgr_$read_pvr"; on any_other call emergency_exit; on cleanup call clean_up; /* COPY ARGS */ pvname = a_pvname; upvrp = a_ptr; call locate_ (pvname, PV, INIT); /* Parse name */ do i = 1 to volume_registration.npv; if volume_registration.pv (i).pvname = pvname then do; ec = 0; /* copy PV entry into user ring structure */ upvrp -> pv_registration = volume_registration.pv (i); goto EXIT; end; end; ec = error_table_$bad_segment; call announce_syserr ("PV entry missing from database ""pv.^a"".", pvname); goto EXIT; %page; /* ADD_LVR - Entry to create a registration database for a new LV */ add_lvr: entry (a_lvname, a_ptr, a_ec); /**** ************************************************************************** Adds a new registration data segment to the volume registration database. The caller provides a volume_registration structure containing the LV attributes and the attributes for a single PV. The structure is the same as that used for the ring-1 data segment. If all validation passes, the caller's structure is copied into a new segment names "lv.LVNAME". Three addnames are added to the segment corresponding to the LVID, PVNAME, and PVID. This entry is not used for creating the RLV registration. RLV registration is done during system initialization by the entry "check_volume_registration". The Master Directory Control entry "create_mdcs" is called to create its data segment which corresponds to the LV registratoin data segment. The code is implemented like: entry setup copy args lock database check caller's LV and PV registration data check existance of LV and PV already in database make a new segment in database for this LV {if anything goes wrong after this, delete the new segment} copy caller's data into database add proper names to new segment call MDC to create its database for the new LV create proper database links if necessary cleanup exit ************************************************************************** ****/ MYNAME = "volume_registration_mgr_$add_lvr"; on any_other call emergency_exit; on cleanup call clean_up; /* COPY ARGS */ lvname = a_lvname; uvrp = a_ptr; call get_tseg; /* place to copy user structure */ vrp = tsegp; /* we'll check to make sure number of entries is correct before attempting to copy the beast into our ring. It'll be checked again after copying the structure by "check_new_lv" */ if uvrp -> volume_registration.npv ^= 1 then do; ec = error_table_$bad_arg; goto EXIT; end; volume_registration = uvrp -> volume_registration; /* Verify consistancy of arguments */ if verify (lvname, LVNAME_LEGAL) ^= 0 | volume_registration.lvname ^= lvname then do; ec = error_table_$argerr; goto EXIT; end; call vrm_lock_$lock (ec); if ec ^= 0 then goto EXIT; call check_new_lv (vrp); call check_new_pv (addr (volume_registration.pv (1))); if name_exists (LV_DIR, "lv." || lvname) | name_exists (LV_DIR, "lvid." || unique_chars_ ((volume_registration.lvid))) | name_exists (LV_DIR, "pv." || volume_registration.pv (1).pvname) | name_exists (LV_DIR, "pvid." || unique_chars_ ((volume_registration.pv (1).pvid))) then do; ec = error_table_$namedup; goto EXIT; end; call locate_ (lvname, LV, DONT_INIT); /* Just parse th name */ call hcs_$make_seg (dn, en, "", 1010b, databasep, ec); /* Create new lv seg */ if ec ^= 0 then goto EXIT; nvrp = databasep; call hcs_$replace_acl (dn, en, addr (aa), 1, "0"b /* SysDaemon OK */, ec); if ec ^= 0 then goto REMOVE_NEW_LV; call admin_gate_$reclassify_sys_seg (dn, en, sys_info$access_class_ceiling, ec); if ec ^= 0 then goto REMOVE_NEW_LV; nvrp -> volume_registration = volume_registration;/* Copy whole structure */ vrp = nvrp; /* Now refer to the new copy */ pvrp = addr (volume_registration.pv (1)); /* ... and to the only PV */ /* If any of the following operations fail we'll back out the new LV simply by deleting its database */ uname = "lvid." || unique_chars_ ((volume_registration.lvid)); call hcs_$chname_seg (vrp, "", uname, ec); if ec ^= 0 then goto REMOVE_NEW_LV; call hcs_$chname_seg (vrp, "", "pv." || pv_registration.pvname, ec); if ec ^= 0 then goto REMOVE_NEW_LV; uname2 = "pvid." || unique_chars_ ((pv_registration.pvid)); call hcs_$chname_seg (vrp, "", uname2, ec); if ec ^= 0 then goto REMOVE_NEW_LV; call mdc_repair_$make_mdcs (lvname, volume_registration.lvid, ec); if ec ^= 0 then goto REMOVE_NEW_LV; call log_it ("Added new LV ""^a"".", lvname); call log_it ("Added new PV ""^a"" to LV ""^a"".", volume_registration.pv (1).pvname, lvname); if dn ^= LV_DIR then do; /* add links */ call hcs_$append_link (LV_DIR, en, pathname_ (dn, en), ec); if ec ^= 0 then call announce_syserr_code (ec, "Could not append link for LV name."); call hcs_$append_link (LV_DIR, uname, pathname_ (dn, uname), ec); if ec ^= 0 then call announce_syserr_code (ec, "Could not append link for LVID."); call hcs_$append_link (LV_DIR, "pv." || pv_registration.pvname, pathname_ (dn, "pv." || pv_registration.pvname), ec); if ec ^= 0 then call announce_syserr_code (ec, "Could not append link for PV name."); call hcs_$append_link (LV_DIR, uname2, pathname_ (dn, uname2), ec); if ec ^= 0 then call announce_syserr_code (ec, "Could not append link for PVID."); end; ec = 0; /* success! */ goto EXIT; REMOVE_NEW_LV: /* come to this point if something went wrong in the middle of new database creation. */ string (delete_options) = ""b; delete_options.force = "1"b; delete_options.segment = "1"b; delete_options.raw = "1"b; call delete_$ptr (nvrp, string (delete_options), "", ec2); if ec2 ^= 0 then call announce_syserr_code (ec2, "Unable to back out database ""lv.^a"".", lvname); else databasep = null (); /* be nice to our clean_up handler */ goto EXIT; %page; /* ADD_PVR - Entry to add a new PV entry to an existing LV */ add_pvr: entry (a_lvname, a_ptr, a_ec); /**** ************************************************************************** This entry adds the registration data for a single PV to an existing LV registration data segment. If all attributes in the given pv_registration structure are valid, it is added to the end of the "pv" array in the LV data segment. Two addnames are appended to the LV registration data segment entry corresponding to the PV name and PVID. If the LV registration data segment is in ">", two links are created in ">lv" corresponding to these two new addnames. The code is implemented like: entry setup copy args check caller's registration data for new PV lock database check existance of PV already in database find proper LV data segment for this new PV search LV data for PV already exists (DB consistancy check) copy caller's PV data into database add proper names to LV data segment bump LV's number of PV's (to include new PV data) add proper database links if necessary cleanup exit ************************************************************************** ****/ MYNAME = "volume_registration_mgr_$add_pvr"; on any_other call emergency_exit; on cleanup call clean_up; /* COPY ARGS */ lvname = a_lvname; upvrp = a_ptr; call get_tseg; /* place to copy user's structure */ pvrp = tsegp; pv_registration = upvrp -> pv_registration; call check_new_pv (pvrp); call vrm_lock_$lock (ec); if ec ^= 0 then goto EXIT; /* Check to see if there's already a database with this name */ uname = "pvid." || unique_chars_ ((pv_registration.pvid)); if name_exists (LV_DIR, "pv." || pv_registration.pvname) | name_exists (LV_DIR, uname) then do; ec = error_table_$namedup; goto EXIT; end; call locate_ (lvname, LV, INIT); /* we've already checked for its existance above, here we'll double check to make sure there's no record with the pvname already in the file. */ do i = 1 to volume_registration.npv while (volume_registration.pv (i).pvname ^= pv_registration.pvname); end; if i <= volume_registration.npv then do; call announce_syserr ("Extra PV entry ""^a"" in database ""lv.^a"".", pvname, lvname); ec = error_table_$bad_segment; goto EXIT; end; volume_registration.pv (i) = pv_registration; /* OOB ref */ pvrp = addr (volume_registration.pv (i)); /* start using DB */ pvname = pv_registration.pvname; call hcs_$chname_seg (vrp, "", "pv." || pvname, ec); if ec ^= 0 then goto EXIT; call hcs_$chname_seg (vrp, "", uname, ec); if ec ^= 0 then do; /* must remove other name we just put on */ call hcs_$chname_seg (vrp, "pv." || pvname, "", ec2); if ec2 ^= 0 then call announce_syserr_code (ec2, "Unable to back out database addname ""pv.^a"".", pvname); goto EXIT; end; volume_registration.npv = i; /* now, let it be legally in the array */ call log_it ("Added new PV ""^a"" to LV ""^a"".", pvname, lvname); if dn ^= LV_DIR then do; /* add links */ call hcs_$append_link (LV_DIR, "pv." || pvname, pathname_ (dn, "pv." || pvname), ec); if ec ^= 0 then call announce_syserr_code (ec, "Could not append link for PV name."); call hcs_$append_link (LV_DIR, uname, pathname_ (dn, uname), ec); if ec ^= 0 then call announce_syserr_code (ec, "Could not append link for PVID."); end; ec = 0; goto EXIT; %page; /* DELETE_LVR - Entry to remove a volume registration database. */ delete_lvr: entry (a_lvname, a_ec); /**** ************************************************************************** This entry deletes the registration data segment for the given LV. If the segment was in ">", the links corresponding to the LV and all the PVs are removed from ">lv". The Master Directory Control entry "delete_mdcs" is called to delete its data segment which corresponds to the deleted LV registration data segment. The code is implemented like: entry setup copy args lock database locate LV registration data segment copy data to temporary delete the segment log deletion of each PV delete associated database links if necessary call MDC to delete its database for the LV cleanup exit ************************************************************************** ****/ MYNAME = "volume_registration_mgr_$delete_lvr"; on any_other call emergency_exit; on cleanup call clean_up; /* COPY ARGS */ lvname = a_lvname; call get_tseg; call vrm_lock_$lock (ec); if ec ^= 0 then goto EXIT; call locate_ (lvname, LV, INIT); lvid = volume_registration.lvid; /* save this for later... */ call mdc_repair_$delete_mdcs (lvname, lvid, ec); if ec ^= 0 then goto EXIT; tsegp -> volume_registration = volume_registration; /* make copy so we can log individual PV deletions later. */ string (delete_options) = ""b; delete_options.force = "1"b; delete_options.segment = "1"b; delete_options.raw = "1"b; call delete_$ptr (vrp, string (delete_options), "", ec); /* this removes the LV (and all its PVs) */ if ec ^= 0 then goto EXIT; databasep = null (); /* be nice to our clean_up handler */ vrp = null; /* so we dont ref deleted seg */ do i = 1 to tsegp -> volume_registration.npv; pvname = tsegp -> volume_registration.pv (i).pvname; pvid = tsegp -> volume_registration.pv (i).pvid; call log_it ("Deleted PV ""^a"" from LV ""^a"".", pvname, lvname); if dn ^= LV_DIR then do; /* remove links */ string (delete_options) = ""b; delete_options.force = "1"b; delete_options.link = "1"b; delete_options.raw = "1"b; call delete_$path (LV_DIR, "pv." || pvname, string (delete_options), "", ec); if ec ^= 0 then call announce_syserr_code (ec, "Could not remove PV name database link."); call delete_$path (LV_DIR, "pvid." || unique_chars_ ((pvid)), string (delete_options), "", ec); if ec ^= 0 then call announce_syserr_code (ec, "Could not remove PVID database link."); end; end; call log_it ("Deleted LV ""^a"".", lvname); if dn ^= LV_DIR then do; /* remove links for LV */ string (delete_options) = ""b; delete_options.force = "1"b; delete_options.link = "1"b; delete_options.raw = "1"b; call delete_$path (LV_DIR, "lv." || lvname, string (delete_options), "", ec); if ec ^= 0 then call announce_syserr_code (ec, "Could not remove LV name database link."); call delete_$path (LV_DIR, "lvid." || unique_chars_ ((lvid)), string (delete_options), "", ec); if ec ^= 0 then call announce_syserr_code (ec, "Could not remove LVID database link."); end; go to EXIT; %page; /* DELETE_PVR - Entry to remove a single PV entry from an LV database. */ delete_pvr: entry (a_pvname, a_ec); /**** ************************************************************************** This entry deletes the registration data for a single PV. The two addnames corresponding to the PV are removed from the LV registration data segment. The "pv" array is compressed so that the remaining active entries are contiguous. If the registration data segment is in ">", the two links corresponding to the PV are removed from ">lv". The code is implemented like: entry setup copy args lock database locate database segment containing the PV find the PV entry remove the entry adjust "number of PVs" in the header delete associated database links if necessary cleanup logout ************************************************************************** ****/ MYNAME = "volume_registration_mgr_$delete_pvr"; on any_other call emergency_exit; on cleanup call clean_up; /* COPY ARGS */ pvname = a_pvname; call vrm_lock_$lock (ec); if ec ^= 0 then goto EXIT; call locate_ (pvname, PV, INIT); /* get volume registration database containing the PV */ if volume_registration.npv = 1 then do; /* we won't delete the last PV */ ec = error_table_$action_not_performed; goto EXIT; end; do i = 1 to volume_registration.npv while (volume_registration.pv (i).pvname ^= pvname); end; if i > volume_registration.npv then do; ec = error_table_$bad_segment; call announce_syserr ("PV entry missing from database ""pv.^a"".", pvname); goto EXIT; end; /* get rid of the names */ call hcs_$chname_seg (vrp, "pv." || pvname, "", ec); if ec ^= 0 then goto EXIT; uname = "pvid." || unique_chars_ ((volume_registration.pv (i).pvid)); call hcs_$chname_seg (vrp, uname, "", ec); if ec ^= 0 then do; /* put other name back on to retain consistancy */ call hcs_$chname_seg (vrp, "", "pv." || pvname, ec2); if ec2 ^= 0 then call announce_syserr_code (ec2, "Unable to replace database name ""pv.^a"".", pvname); goto EXIT; end; /* squash the database */ do j = i + 1 to volume_registration.npv; volume_registration.pv (j - 1) = volume_registration.pv (j); end; volume_registration.npv = volume_registration.npv - 1; call hcs_$truncate_seg (vrp, currentsize (volume_registration), ec); if ec ^= 0 then call announce_syserr_code (ec, "Trimming registration."); call log_it ("Deleted PV ""^a"" from LV ""^a"".", pvname, volume_registration.lvname); call locate_ ((volume_registration.lvname), LV, DONT_INIT); /* find out real location of segment */ if dn ^= LV_DIR then do; /* remove links */ string (delete_options) = ""b; delete_options.force = "1"b; delete_options.link = "1"b; delete_options.raw = "1"b; call delete_$path (LV_DIR, "pv." || pvname, string (delete_options), "", ec); if ec ^= 0 then call announce_syserr_code (ec, "Could not remove PV name database link."); call delete_$path (LV_DIR, uname, string (delete_options), "", ec); if ec ^= 0 then call announce_syserr_code (ec, "Could not remove PVID database link."); end; ec = 0; goto EXIT; /* all done */ %page; /* CHANGE_LVR - Entry to change logical volume data. */ change_lvr: entry (a_lvname, a_ptr, a_ec); /**** ************************************************************************** This entry changes selected attributes of an LV. The caller supplies a volume_registration structure with no "pv" array entries. All attributes are validated before any changes are made. Changes to the LV name or LVID are propagated to Master Directory Control through a call to its entry "update_lvid" and "rename_mdcs". Also, changes to the LV name or LVID make it necessary to change the LV registration data segment names (and possibly the names of links in ">lv"). The code is implemented like: entry setup copy args check caller's registration data structure lock the database locate LV data segment make LVID change if requested make NAME change if requested (back out LVID change if unable to make NAME change) make other changes as requested cleanup exit ************************************************************************** ****/ /* a_lvname is the current name of the volume, it may change depending upon the incoming value of volume_registration.lvname */ MYNAME = "volume_registration_mgr_$change_lvr"; on any_other call emergency_exit; on cleanup call clean_up; /* COPY ARGS */ lvname = a_lvname; uvrp = a_ptr; call get_tseg; /* space for copy of user's structure */ nvrp = tsegp; /* let's make sure it isn't just garbage */ /* we'll check again after the copy */ if uvrp -> volume_registration.npv ^= 0 then do; ec = error_table_$bad_arg; goto EXIT; end; nvrp -> volume_registration = uvrp -> volume_registration; if nvrp -> volume_registration.npv ^= 0 then do; ec = error_table_$bad_arg; goto EXIT; end; call check_lv (nvrp); call vrm_lock_$lock (ec); if ec ^= 0 then goto EXIT; call locate_ (lvname, LV, INIT); /* The next bit of code is a touch hairy. We need to add (potentially) 2 names in two places each. Should anything go wrong, we need to undo names already in place. Thus, there's a slightly complicated mechanism for backing out partial changes. */ lvid_changed = "0"b; if volume_registration.lvid ^= nvrp -> volume_registration.lvid then do; new_lvid = nvrp -> volume_registration.lvid; old_lvid = volume_registration.lvid; old_uname = "lvid." || unique_chars_ ((old_lvid)); new_uname = "lvid." || unique_chars_ ((new_lvid)); call hcs_$chname_seg (vrp, old_uname, new_uname, ec); if ec ^= 0 then do; if ec ^= error_table_$namedup & ec ^= error_table_$segnamedup /* if not normal error... */ then call announce_syserr_code (ec, "Unexpected trouble changing name ""^a"".", old_uname); goto EXIT; end; volume_registration.lvid = new_lvid; /* whew */ lvid_changed = "1"b; call mdc_repair_$update_lvid (lvname, old_lvid, new_lvid, ec); if ec ^= 0 then do; /* must back out the change... */ call hcs_$chname_seg (vrp, new_uname, old_uname, ec2); if ec2 ^= 0 then call announce_syserr_code (ec2, "Unable to change name ""^a"" back to ""^a"".", new_uname, old_uname); else volume_registration.lvid = old_lvid; goto EXIT; end; /* we won't log change yet - first see if name change goes OK */ end; if volume_registration.lvname ^= nvrp -> volume_registration.lvname then do; new_lvname = nvrp -> volume_registration.lvname; old_lvname = volume_registration.lvname; if old_lvname = "root" then do; /* can't let this happen */ ec = error_table_$bad_arg; go to back_out_lvid_change; /* and exit */ end; call hcs_$chname_seg (vrp, "lv." || old_lvname, "lv." || new_lvname, ec); if ec ^= 0 then do; /* ugh! now we have to back out preceeding lvid changes. */ if ec ^= error_table_$namedup & ec ^= error_table_$segnamedup /* if not normal error... */ then call announce_syserr_code (ec, "Unexpected error changing name on ""lv.^a"".", old_lvname); back_out_lvid_change: if lvid_changed then do; call hcs_$chname_seg (vrp, new_uname, old_uname, ec2); if ec2 ^= 0 then call announce_syserr_code (ec2, "Unable to change name ""^a"" back to ""^a"".", new_uname, old_uname); else do; volume_registration.lvid = old_lvid; call mdc_repair_$update_lvid (lvname, new_lvid, old_lvid, ec2); if ec2 ^= 0 then call announce_syserr_code (ec2, "Unable to back out LVID change to ""^a.mdcs"".", lvname); end; end /* back_out_lvid_change */; goto EXIT; end; /* update the internal name */ volume_registration.lvname = new_lvname; /* now make sure MDC keeps up */ call mdc_repair_$rename_mdcs (old_lvname, volume_registration.lvid, new_lvname, ec); if ec ^= 0 then do; /* now we need to back out lvname change AND lvid change */ call hcs_$chname_seg (vrp, "lv." || new_lvname, "lv." || old_lvname, ec2); if ec2 ^= 0 then call announce_syserr_code (ec2, "Unable to change name ""^a"" back to ""^a"".", new_lvname, old_lvname); else do; volume_registration.lvname = old_lvname; goto back_out_lvid_change; end; goto EXIT; end; call log_it ("Changed name of LV ""^a"" to ""^a"".", lvname, new_lvname); if dn ^= LV_DIR then do; /* adjust link */ string (delete_options) = ""b; delete_options.force = "1"b; delete_options.link = "1"b; delete_options.raw = "1"b; call delete_$path (LV_DIR, "lv." || old_lvname, string (delete_options), "", ec); if ec ^= 0 then call announce_syserr_code (ec, "Couldn't delete link for old LV name."); call hcs_$append_link (LV_DIR, "lv." || new_lvname, pathname_ (dn, "lv." || new_lvname), ec); if ec ^= 0 then call announce_syserr_code (ec, "Couldn't create link for new LV name."); end; end; if lvid_changed then do; /* now we can log the LVID change - we wont be backing it out */ call log_it ("Changed LVID of LV ""^a"" from ""^w"" to ""^w"".", lvname, old_lvid, new_lvid); if dn ^= LV_DIR then do; /* adjust link */ string (delete_options) = ""b; delete_options.force = "1"b; delete_options.link = "1"b; delete_options.raw = "1"b; call delete_$path (LV_DIR, old_uname, string (delete_options), "", ec); if ec ^= 0 then call announce_syserr_code (ec, "Couldn't delete link for old LVID."); call hcs_$append_link (LV_DIR, new_uname, pathname_ (dn, new_uname), ec); if ec ^= 0 then call announce_syserr_code (ec, "Couldn't create link for new LVID."); end; end; /* the rest of the changes are easy... */ if volume_registration.access_class_range (2) ^= nvrp -> volume_registration.access_class_range (2) then do; old_aa_str = display_access_class_ (volume_registration.access_class_range (2)); new_aa_str = display_access_class_ (nvrp -> volume_registration.access_class_range (2)); call convert_access_class_$to_string_short (nvrp -> volume_registration.access_class_range (2), auth_mnemonics, ec); if ec ^= 0 then do; call announce_syserr_code (ec, "Unable to convert max auth to name_string."); auth_mnemonics = "can't convert"; end; volume_registration.access_class_range (2) = nvrp -> volume_registration.access_class_range (2); call log_it ("Changed max access class of LV ""^a"" from ""^a"" to ""^a"". (^a)", lvname, old_aa_str, new_aa_str, auth_mnemonics); end; if volume_registration.access_class_range (1) ^= nvrp -> volume_registration.access_class_range (1) then do; old_aa_str = display_access_class_ (volume_registration.access_class_range (1)); new_aa_str = display_access_class_ (nvrp -> volume_registration.access_class_range (1)); call convert_access_class_$to_string_short (nvrp -> volume_registration.access_class_range (1), auth_mnemonics, ec); if ec ^= 0 then do; call announce_syserr_code (ec, "Unable to convert min auth to name_string."); auth_mnemonics = "can't convert"; end; volume_registration.access_class_range (1) = nvrp -> volume_registration.access_class_range (1); call log_it ("Changed min access class of LV ""^a"" from ""^a"" to ""^a"" (^a).", lvname, old_aa_str, new_aa_str, auth_mnemonics); end; if volume_registration.volume_owner ^= nvrp -> volume_registration.volume_owner then do; call log_it ("Changed owner of LV ""^a"" from ""^a"" to ""^a"".", lvname, volume_registration.volume_owner, nvrp -> volume_registration.volume_owner); volume_registration.volume_owner = nvrp -> volume_registration.volume_owner; end; if volume_registration.public ^= nvrp -> volume_registration.public then do; call log_it ("Changed LV ""^a"" to ^[PUBLIC^;PRIVATE^].", lvname, volume_registration.public); volume_registration.public = nvrp -> volume_registration.public; end; if volume_registration.acs_path ^= nvrp -> volume_registration.acs_path then do; volume_registration.acs_path = nvrp -> volume_registration.acs_path; call log_it ("Changed ACS pathname for LV ""^a"" to ""^a"".", lvname, volume_registration.acs_path); end; ec = 0; /* to be sure */ goto EXIT; %page; /* CHANGE_PVR - Entry to change information about a particular PV */ change_pvr: entry (a_pvname, a_ptr, a_ec); /**** ************************************************************************** This entry changes selected attributes of a PV. The caller supplies a pv_registration structure with all members initialized. All attributes are validated before any changes are made. If the LV name or LVID changes it is necessary to also change the corresponding names on the LV registration data segment (and possibly the names of links in ">lv"). The code is implemented like: entry setup copy_args check caller's registration data structure lock database locate registration data segment find PV entry in data segment make PVID change if requested make NAME change if requested (back out PVID change if error is encountered) make other changes as requested cleanup exit ************************************************************************** ****/ MYNAME = "volume_registration_mgr_$change_pvr"; on any_other call emergency_exit; on cleanup call clean_up; /* COPY ARGS */ pvname = a_pvname; upvrp = a_ptr; call get_tseg; /* place to make copy of user's structure */ npvrp = tsegp; npvrp -> pv_registration = upvrp -> pv_registration; /* copy the structure */ call check_pv (npvrp); call vrm_lock_$lock (ec); if ec ^= 0 then goto EXIT; call locate_ (pvname, PV, INIT); do i = 1 to volume_registration.npv while (volume_registration.pv (i).pvname ^= pvname); end; if i > volume_registration.npv then do; call announce_syserr ("PV entry missing from database ""pv.^a"".", pvname); ec = error_table_$bad_segment; goto EXIT; end; pvrp = addr (volume_registration.pv (i)); /* now - make the changes */ /* as in "change_lvr" we have to make potentially two name changes but only to the volume registration database (i.e. not any MDCS) */ pvid_changed = "0"b; if pv_registration.pvid ^= npvrp -> pv_registration.pvid then do; old_pvid = pv_registration.pvid; new_pvid = npvrp -> pv_registration.pvid; old_uname = "pvid." || unique_chars_ ((old_pvid)); new_uname = "pvid." || unique_chars_ ((new_pvid)); call hcs_$chname_seg (vrp, old_uname, new_uname, ec); if ec ^= 0 then do; if ec ^= error_table_$namedup & ec ^= error_table_$segnamedup /* check for unusual errors... */ then call announce_syserr_code (ec, "Unexpected trouble changing name ""^a"".", old_uname); goto EXIT; end; pv_registration.pvid = new_pvid; pvid_changed = "1"b; end; if pv_registration.pvname ^= npvrp -> pv_registration.pvname then do; old_pvname = pv_registration.pvname; new_pvname = npvrp -> pv_registration.pvname; if old_pvname = "rpv" then do; ec = error_table_$bad_arg; /* can't let 'em do this */ goto back_out_pvid_change; /* and exit */ end; call hcs_$chname_seg (vrp, "pv." || old_pvname, "pv." || new_pvname, ec); if ec ^= 0 then do; if ec ^= error_table_$namedup & ec ^= error_table_$segnamedup /* check for unusual errors... */ then call announce_syserr_code (ec, "Unexpected trouble changing name ""^a"".", old_pvname); back_out_pvid_change: if pvid_changed then do; /* must back out other name change */ call hcs_$chname_seg (vrp, new_uname, old_uname, ec2); if ec2 ^= 0 then call announce_syserr_code (ec2, "Unable to back out PVID change to ""^a.mdcs"".", pvname); else pv_registration.pvid = old_pvid; end; goto EXIT; end; pv_registration.pvname = new_pvname; call log_it ("Changed name of PV ""^a"" to ""^a"".", old_pvname, new_pvname); call locate_ ((volume_registration.lvname), LV, DONT_INIT); /* find out real location of segment */ if dn ^= LV_DIR then do; /* adjust link */ string (delete_options) = ""b; delete_options.force = "1"b; delete_options.link = "1"b; delete_options.raw = "1"b; call delete_$path (LV_DIR, "pv." || old_pvname, string (delete_options), "", ec); if ec ^= 0 then call announce_syserr_code (ec, "Couldn't delete link for old PV name."); call hcs_$append_link (LV_DIR, "pv." || new_pvname, pathname_ (dn, "pv." || new_pvname), ec); if ec ^= 0 then call announce_syserr_code (ec, "Couldn't create link for new PV name."); end; end; if pvid_changed then do; /* now we can log that fact - since it ain't gonna be backed out */ call log_it ("Changed PVID of PV ""^a"" from ""^w"" to ""^w"".", pvname, old_pvid, new_pvid); call locate_ ((volume_registration.lvname), LV, DONT_INIT); /* find out real location of segment */ if dn ^= LV_DIR then do; /* adjust link */ string (delete_options) = ""b; delete_options.force = "1"b; delete_options.link = "1"b; delete_options.raw = "1"b; call delete_$path (LV_DIR, old_uname, string (delete_options), "", ec); if ec ^= 0 then call announce_syserr_code (ec, "Couldn't delete link for old PVID."); call hcs_$append_link (LV_DIR, new_uname, pathname_ (dn, new_uname), ec); if ec ^= 0 then call announce_syserr_code (ec, "Couldn't create link for new PVID."); end; end; if pv_registration.model ^= npvrp -> pv_registration.model then do; call log_it ("Changed model of PV ""^a"" from ""^d"" to ""^d"".", pvname, MODELN (pv_registration.model), MODELN (npvrp -> pv_registration.model)); pv_registration.model = npvrp -> pv_registration.model; end; if pv_registration.location ^= npvrp -> pv_registration.location then do; call log_it ("Changed location of PV ""^a"" from ""^a"" to ""^a"".", pvname, pv_registration.location, npvrp -> pv_registration.location); pv_registration.location = npvrp -> pv_registration.location; end; if pv_registration.mfg_serial ^= npvrp -> pv_registration.mfg_serial then do; call log_it ("Changed mfg_serial of PV ""^a"" from ""^a"" to ""^a"".", pvname, pv_registration.mfg_serial, npvrp -> pv_registration.mfg_serial); pv_registration.mfg_serial = npvrp -> pv_registration.mfg_serial; end; if pv_registration.date_registered ^= npvrp -> pv_registration.date_registered then do; old_dt_reg = date_time_$format ("date_time", pv_registration.date_registered, "", ""); new_dt_reg = date_time_$format ("date_time", npvrp -> pv_registration.date_registered, "", ""); call log_it ("Changed date_registered of PV ""^a"" from ""^a"" to ""^a"".", pvname, old_dt_reg, new_dt_reg); pv_registration.date_registered = npvrp -> pv_registration.date_registered; end; if pv_registration.password ^= npvrp -> pv_registration.password then do; call log_it ("Changed password of PV ""^a"".", pvname); /* don't tell what it was or now is... */ pv_registration.password = npvrp -> pv_registration.password; end; goto EXIT; %page; /* ------------------------------------------------------- */ /* Service entries called by various other programs which need to know about volume registration information. Status, dumper, master dir control, mount */ /* ------------------------------------------------------- */ /* PVNAME_INFO - Entry to return information about a given PV */ pvname_info: entry (a_pvname, a_pvid, a_lvname, a_lvid, a_device_type, a_ec); /**** ************************************************************************** This entry returns the PVID, LV name, LVID, and device type (model index) for a given PV name. ************************************************************************** ****/ MYNAME = "volume_registration_mgr_$pvname_info"; on any_other call emergency_exit; on cleanup call clean_up; pvname = a_pvname; call vrm_lock_$lock (ec); if ec ^= 0 then goto EXIT; call locate_ (pvname, PV, INIT); do i = 1 to volume_registration.npv while (pvname ^= volume_registration.pv (i).pvname); end; if i > volume_registration.npv then do; ec = error_table_$unregistered_volume; call announce_syserr ("PV entry not found in database ""pv.^a"".", pvname); goto EXIT; end; ec = 0; a_pvid = volume_registration.pv (i).pvid; a_device_type = volume_registration.pv (i).model; a_lvname = volume_registration.lvname; a_lvid = volume_registration.lvid; goto EXIT; %page; /* FIND_LVID - Entry to return LVID given LV name */ find_lvid: entry (a_lvname, a_lvid, a_ec); /* Translate name to uid */ /**** ************************************************************************** This entry returns the LVID for a given LV name. ************************************************************************** ****/ MYNAME = "volume_registration_mgr_$find_lvid"; on any_other call emergency_exit; on cleanup call clean_up; lvname = a_lvname; call vrm_lock_$lock (ec); if ec ^= 0 then goto EXIT; call locate_ (lvname, LV, INIT); a_lvid = volume_registration.lvid; /* Return the value */ ec = 0; go to EXIT; %page; /* FIND_VOLNAME - Entry to return LV and PV names given PVID */ find_volname: entry (a_pvid, a_pvname, a_lvname, a_ec); /* pvid -> pvname, lvname (dumper) */ /**** ************************************************************************** This entry returns the PV name and LV name for a given PVID. ************************************************************************** ****/ MYNAME = "volume_registration_mgr_$find_volname"; on any_other call emergency_exit; on cleanup call clean_up; pvid = a_pvid; /* copy input arg */ /* init return values */ a_pvname, a_lvname = ""; uname = "pvid." || unique_chars_ ((pvid)); /* Use name on segment */ call vrm_lock_$lock (ec); if ec ^= 0 then goto EXIT; call locate_uid_ (pvid, PV, INIT); do i = 1 to volume_registration.npv while (volume_registration.pv (i).pvid ^= pvid); end; if i > volume_registration.npv then do; call announce_syserr ("PV entry not found in database ""^a"".", uname); ec = error_table_$bad_volid; goto EXIT; end; a_pvname = volume_registration.pv (i).pvname; /* Rah. Divulge volume name */ a_lvname = volume_registration.lvname; /* Hand back volume name */ ec = 0; go to EXIT; %page; /* FIND_LVNAME - Entry to return LV name given the LVID */ find_lvname: entry (a_lvid, a_lvname, a_ec); /* lvid -> lvname */ /**** ************************************************************************** This entry returns the LV name for a given LVID. ************************************************************************** ****/ MYNAME = "volume_registration_mgr_$find_lvname"; on any_other call emergency_exit; on cleanup call clean_up; lvid = a_lvid; a_lvname = ""; /* init return value */ uname = "lvid." || unique_chars_ ((lvid)); /* Use the trick names */ call vrm_lock_$lock (ec); if ec ^= 0 then goto EXIT; call locate_uid_ (lvid, LV, INIT); a_lvname = volume_registration.lvname; ec = 0; go to EXIT; %page; /* GET_ACCESS - Entry to return callers' access to given LV */ get_access: entry (a_lvname, a_level, a_mode, a_pub_bit, a_ec); /* Effective mode to lv (mount, mdc) */ set_access_range = "0"b; goto GET_ACCESS_JOIN; get_access_for_attach: entry (a_lvname, a_level, a_mode, a_pub_bit, a_lv_access_class_range, a_ec); /* special entry for rcp_attach_lv_ */ a_lv_access_class_range = sys_info$access_class_ceiling; /* initial value */ set_access_range = "1"b; GET_ACCESS_JOIN: /**** ************************************************************************** This entry computes the callers access mode to a given LV. The code first checks the AIM access range and RCP_PRIVILEGE. If neither of these are acceptable, the mode returned is "null". Otherwise, the access will be computed from the ACS. If no acs_path is registered, or if the ACS itself is missing, the access returned is "REW" for the owner, "null" for all others. NOTE: NOTE: this code should really be removed and made into "lv_access_kernel_" The code is implemented like: entry setup copy args lock database locate registration data segment for LV if process access class out of range or process not privileged then return NULL mode else if ACS exists for LV then return process's raw mode to ACS else if process is LV owner then return REW mode else return NULL mode cleanup exit ************************************************************************** ****/ MYNAME = "volume_registration_mgr_$get_access"; on any_other call emergency_exit; on cleanup call clean_up; lvname = a_lvname; /* copy input args */ level = a_level; call vrm_lock_$lock (ec); if ec ^= 0 then goto EXIT; call locate_ (lvname, LV, INIT); if ^((read_allowed_ (get_authorization_ (), volume_registration.access_class_range (1)) & write_allowed_ (get_authorization_ (), volume_registration.access_class_range (2))) | ((get_privileges_ () & RCP_PRIVILEGE) ^= ""b)) then do; mode = N_ACCESS; /* if vol off aim limits, n.g. */ pub_bit = "0"b; end; else do; if volume_registration.acs_path ^= "" then do; call expand_pathname_ ((volume_registration.acs_path), dn, en, ec); if ec ^= 0 then do; call announce_syserr_code (ec, "Bad ACS path in database ""lv.^a"".", lvname); goto NO_ACS; /* check for owner mode */ end; call hcs_$get_user_raw_mode (dn, en, "", mode, ec); /* ignores ring brackets and AIM */ if ec ^= 0 then goto NO_ACS; /* check for owner mode */ pub_bit = volume_registration.public; end; else do; NO_ACS: /* ACS need not exist */ uname = get_group_id_ (); j = length (rtrim (uname)); substr (uname, j - 1) = ""; /* Blank instance tag */ j = index (uname, "."); pers = substr (uname, 1, j - 1); proj = substr (uname, j + 1); j = index (volume_registration.volume_owner, "."); opers = substr (volume_registration.volume_owner, 1, j - 1); oproj = substr (volume_registration.volume_owner, j + 1); if (pers = opers | opers = "*") & (proj = oproj | oproj = "*") then mode = REW_ACCESS; /* Volume owner always REW */ else if volume_registration.public then mode = RW_ACCESS; /* Everybody has RW to public vols */ else mode = N_ACCESS; /* Private vol, no ACS */ pub_bit = volume_registration.public; end; end; a_mode = mode; /* Tell user */ a_pub_bit = pub_bit; if set_access_range then a_lv_access_class_range = volume_registration.access_class_range; ec = 0; go to EXIT; %page; /* LVNAME_INFO - Entry to return information about PVs given an LV name */ lvname_info: entry (a_lvname, a_pvap, a_npv, a_ec); /**** ************************************************************************** This entry returns a specialized structure of information on all PVs belonging to a given LV name. The code is implemented like: entry setup copy args lock database locate registration data segment for LV fill in caller's structure with info on all PVs in the LV cleanup exit ************************************************************************** ****/ dcl pvap ptr; dcl 1 pva (100) based (pvap) aligned, /* This entrypoint fills in a struc */ 2 pvname char (32), /* .. listing all volumes */ 2 device_type fixed bin, /* .. and their model numbers */ 2 pvid bit (36); /* and pvid */ MYNAME = "volume_registration_mgr_$lvname_info"; make_lve = "0"b; /* dont fiddle with disk table */ goto lv_pvinfo_common; %page; /* GET_LV_PVINFO - Entry to do same as LVNAME_INFO plus make LVE in disk table */ /* This entry is called by disk_table_ (via initializer_mdc_) and by mdx */ get_lv_pvinfo: entry (a_lvname, a_pvap, a_npv, a_lvx, a_ec); /* Get lv pv list, make lve */ /**** ************************************************************************** This entry has the same function as "lvname_info". In addition it will return the index of the corresponding LV disk_table entry. If there is no corresponding disk table LV entry, it will be created. The code is implemented like: entry setup copy args lock database locate registration data segment for LV locate disk table LV entry or make one if not already existing fill in caller's structure with info on all PVs in the LV cleanup exit ************************************************************************** ****/ MYNAME = "volume_registration_mgr_$get_lv_pvinfo"; make_lve = "1"b; /* update disk table */ lv_pvinfo_common: on any_other call emergency_exit; on cleanup call clean_up; dtp = sdtp; dtep = null; /* not needed at this entry */ lvname = a_lvname; pvap = a_pvap; call vrm_lock_$lock (ec); if ec ^= 0 then goto EXIT; call locate_ (lvname, LV, INIT); if make_lve then a_lvx = get_lve (); do i = 1 to volume_registration.npv; pva (i).pvname = volume_registration.pv (i).pvname; pva (i).device_type = volume_registration.pv (i).model; pva (i).pvid = volume_registration.pv (i).pvid; end; a_npv = volume_registration.npv; ec = 0; go to EXIT; %page; /* FIND - Entry to fill in disk table from volume registration data */ /* This entry is called by mdx */ find: entry (a_dtep, a_ec); /**** ************************************************************************** This entry will create an LV disk table entry given an index to a disk table PV entry. The LV entry will correspond to the LV of the given PV. The code is implemented like: entry setup copy args lock database locate registration data segment containing PV locate disk table LV entry or create one if it doesnt exist locate PV entry in the data segment if model in registration data and disk table are the same then copy to registered PVID into the disk table else there's an error cleanup exit ************************************************************************** ****/ MYNAME = "volume_registration_mgr_$find"; on any_other call emergency_exit; on cleanup call clean_up; dtp = sdtp; dtep = a_dtep; pvname = dte.pvname; /* dte.pvname is input */ call vrm_lock_$lock (ec); if ec ^= 0 then goto EXIT; call locate_ (pvname, PV, INIT); dte.lvx = get_lve (); do i = 1 to volume_registration.npv while (volume_registration.pv (i).pvname ^= dte.pvname); end; if i <= volume_registration.npv then do; if dte.device_type = volume_registration.pv (i).model then do; dte.pvid = volume_registration.pv (i).pvid; /* Found stuff. Get pvid */ ec = 0; end; else ec = error_table_$incorrect_device_type; end; else do; call announce_syserr ("PV entry missing from ""pv.^a"".", pvname); ec = error_table_$bad_volid; end; go to EXIT; %page; /* CHECK_VOLUME_REGISTRATION - Salvage the registration database. */ check_volume_registration: entry (a_dtep, a_ec); /* salvager module */ /**** ************************************************************************** This entry is called during system initialization to validate/re-create the volume registration database. "mdx$init" (which had previously called our "init" entry) scans the old disk table and calls here for each entry that had a valid drive mounted in the previous session. This is evidence that the PV should have a valid registration. On the first call this entry will create ">lv" if necessary (i.e. if its a new system or was booted with NOLV). The disk table PV entry is checked to determine that it points to a valid disk table LV entry. If not, the disk table LV entry is recreated from the PV's LV registration data. If the LV registration can't be determined, nothing more can be done but issue a console message. If the disk table does contain a valid LV entry for the PV in question it is compared to the LV registration data. If the LV registration disagrees with the disk table entry, or can't be found, it is recreated. (Thus, the disk table is the more trusted database.) If the PV registration data disagrees with the disk table PV entry, the registration data is "fixed" to be the same. If the PV registration doesn't exist in the LV registration data segment, it is recreated there. This entry also ensures that all proper addnames and links are in place. The code is implemented like: entry setup (no need to copy args or lock database) if first call then create ">lv" if it doesn't exist validate PV name in disk table entry if disk table LV entry invalid then if PV is registered then recreate disk table LV entry else return to caller as failure validate LV name in disk table entry if LV registration data segment non existant then create new one and fill in header else validate existing header information - recreate if anything in error create proper database link for LV name if necessary create proper data seg addname for LVID create proper database link for LVID if necessary create proper database link for MDC data seg if necessary call MDC to recreate its data seg for the LV as it sees fit create proper data seg addname for PV name create proper database link for PV name if necessary if PV entry does not exist in data seg then create it else validate PVID and device type against disk table entry - update registration entry with disk table info if in error create proper data seg addname for PVID create proper database link for PVID if necessary cleanup exit ************************************************************************** ****/ MYNAME = "volume_registration_mgr_$check_volume_registration"; on any_other begin; a_ec = error_table_$unexpected_condition; goto CK_VREG_EXIT; end; on cleanup ; /* No locking is needed at this entrypoint since only the Initializer exists */ a_ec = 0; if first then do; /* We are always called at least once (for the root) */ first = "0"b; i = length (rtrim (LV_DIR)); call expand_path_ (addr (LV_DIR), (i), addr (dn), addr (en), ec); call hcs_$status_minf (dn, en, 0, type, bc, ec); if ec ^= 0 | type ^= 2 then do; unspec (CBI) = ""b; CBI.version = create_branch_version_2; CBI.dir_sw = "1"b; CBI.parent_ac_sw = "1"b; CBI.mode = "111"b; CBI.rings (1) = 7; CBI.rings (2) = 7; CBI.rings (3) = 7; CBI.userid = get_group_id_ (); call hcs_$create_branch_ (dn, en, addr (CBI), ec); if ec ^= 0 then call announce_syserr_code (ec, "Cannot re-create ^a.", LV_DIR); else do; call hcs_$add_dir_acl_entries (dn, en, addr (dacl), 1, ec); if ec ^= 0 then call announce_syserr_code (ec, "Cannot add SysAdmin access to ^a.", LV_DIR); end; end; if LV_DIR = REAL_LV_DIR then do; /* Make LV dir be on RPV */ call hphcs_$set_rpv (dn, en, ec); if ec ^= 0 then call announce_syserr_code (ec, "Putting LV dir on RPV"); end; end; dtp = sdtp; dtep = a_dtep; if verify (rtrim (dte.pvname), PVNAME_LEGAL) ^= 0 then return; /* Dont reregister crap */ if dte.lvx <= 0 | dte.lvx > dt.n_lv_entries then go to lvfail; lvep = addr (dt.lv_array (dte.lvx)); if ^lve.used then do; lvfail: pvname = dte.pvname; /* Invalid lve. Try to recover */ call locate_ (pvname, PV, DONT_INIT); call hcs_$initiate (dn, en, "", 0, 0, vrp, ec); /* look in pv seg for lvname */ if vrp = null then do; /* Cannot find pv */ call announce_syserr_code (ec, "Cannot reregister PV ""^a"".", pvname); a_ec = ec; /* unable to proceed */ return; /* .. because i dont know what lv */ end; dte.lvx = get_lve (); call hcs_$terminate_noname (vrp, (0)); end; lvname = lve.lvname; if verify (lvname, LVNAME_LEGAL) ^= 0 then return; call locate_ (lvname, LV, DONT_INIT); call hcs_$initiate (dn, en, "", 0, 0, vrp, ec); /* LV should be registered */ if vrp = null then do; call hcs_$make_seg (dn, en, "", 1010b, vrp, ec); /* Wasn't. Make new */ if vrp = null then do; call announce_syserr_code (ec, "Cannot reregister LV ""^a"".", lvname); a_ec = ec; return; end; call admin_gate_$reclassify_sys_seg (dn, en, sys_info$access_class_ceiling, ec); if ec ^= 0 then call announce_syserr_code (ec, pathname_ (dn, en)); remake_lv: volume_registration.version = Volume_Registration_Version_2; volume_registration.lvid = lve.lvid; volume_registration.lvname = lvname; owner = get_group_id_ (); i = length (rtrim (owner)); volume_registration.volume_owner = substr (owner, 1, i - 2); volume_registration.public = lve.public; volume_registration.access_class_range (1) = lve.min_access_class; volume_registration.access_class_range (2) = lve.max_access_class; volume_registration.acs_path = ""; call announce_syserr ("Reregistered ^a LV ^a LVID ^w", PRIV (fixed (lve.public, 1)), lvname, lve.lvid); call hcs_$replace_acl (dn, en, addr (aa), 1, "0"b /* SysDaemon OK */, ec); end; else do; call hcs_$set_damaged_sw_seg (vrp, "0"b, ec);/* Salvaging ourself */ ec = 0; if volume_registration.lvname ^= lvname then ec = 2; if volume_registration.lvid ^= lve.lvid then ec = 3; if volume_registration.public ^= lve.public then ec = 4; if volume_registration.access_class_range (1) ^= lve.min_access_class then ec = 5; if volume_registration.access_class_range (2) ^= lve.max_access_class then ec = 6; if volume_registration.version ^= Volume_Registration_Version_2 then call convert_database (ec); /* to new version */ if ec ^= 0 then do; call announce_syserr_code (ec, "lv.^a disagreed with disk_table. It was rebuilt.", lvname); go to remake_lv; end; end; if dn ^= LV_DIR /* The ROOT lv must be linked to special */ then call hcs_$append_link (LV_DIR, en, pathname_ (dn, en), ec); uname = "lvid." || unique_chars_ ((volume_registration.lvid)); /* Force unique name back on */ call hcs_$chname_seg (vrp, "", uname, ec); if ec ^= 0 then if ec ^= error_table_$segnamedup then call announce_syserr_code (ec, "Cant add name ""^a"" to ""^a"".", uname, en); if dn ^= LV_DIR then call hcs_$append_link (LV_DIR, uname, pathname_ (dn, uname), ec); /* ACS linking code was removed from this point - ejs */ uname = rtrim (lvname) || ".mdcs"; if dn ^= LV_DIR then call hcs_$append_link (LV_DIR, uname, pathname_ (dn, uname), (0)); call hcs_$set_damaged_sw (LV_DIR, uname, "0"b, (0)); /* Don't fault */ call mdc_repair_$recreate_mdcs (lvname, (volume_registration.lvid), ec); if ec ^= 0 then if ec ^= error_table_$namedup then call announce_syserr_code (ec, "Cannot make mdcs for LV ^a", lvname); pvname = dte.pvname; en = "pv." || pvname; call hcs_$chname_seg (vrp, "", en, ec); /* Put pv name back on */ if ec ^= 0 then if ec ^= error_table_$segnamedup then call announce_syserr_code (ec, "Cant add name ""^a"" to ""^a"".", en, lvname); if dn ^= LV_DIR then call hcs_$append_link (LV_DIR, en, pathname_ (dn, en), ec); do i = 1 to volume_registration.npv while (volume_registration.pvname (i) ^= pvname); end; if i > volume_registration.npv then do; volume_registration.pv (i).pvid = dte.pvid; /* Vol was not in lv */ volume_registration.pv (i).pvname = pvname; volume_registration.pv (i).model = dte.device_type; volume_registration.pv (i).location = "online"; volume_registration.pv (i).mfg_serial = "registered by crash recovery"; volume_registration.pv (i).password = "0"b; volume_registration.pv (i).date_registered = clock (); volume_registration.npv = volume_registration.npv + 1; call announce_syserr ("Reregistered PV ^a PVID ^w in LV ^a", volume_registration.pv (i).pvname, volume_registration.pv (i).pvid, lvname); call hcs_$set_bc_seg (vrp, 36 * currentsize (volume_registration), ec); end; else do; if volume_registration.pv (i).pvid ^= dte.pvid | volume_registration.pv (i).model ^= dte.device_type then call announce_syserr ("Registration for PV ^a was different from disk_table.", pvname); volume_registration.pv (i).pvid = dte.pvid; volume_registration.pv (i).model = dte.device_type; end; uname = "pvid." || unique_chars_ ((volume_registration.pv (i).pvid)); call hcs_$chname_seg (vrp, "", uname, ec); /* Put name back on */ if ec ^= 0 then if ec ^= error_table_$segnamedup then call announce_syserr_code (ec, "Cant add name ""^a"" to ""^a"".", uname, lvname); if dn ^= LV_DIR /* Hard case */ then call hcs_$append_link (LV_DIR, uname, pathname_ (dn, uname), ec); call hcs_$terminate_noname (vrp, ec); CK_VREG_EXIT: return; %page; /* -------------------------------------------------- */ /* INTERNAL SUPPORT ROUTINES */ /* -------------------------------------------------- */ log_it: /* log changes to databases */ proc options (variable); dcl severity fixed bin; dcl based_msg char (tstr_len) based (addr (temp_str)); dcl alp pointer; severity = LOG; goto log_it_join; announce_syserr: entry options (variable); severity = ANNOUNCE; log_it_join: on any_other ; call cu_$arg_list_ptr (alp); call ioa_$general_rs (alp, 1, 2, temp_str, tstr_len, "0"b /* no pad */, "0"b /* nnl */); if testing then call com_err_ (0, MYNAME, "(^[SYSERR^;SYSLOG^]) ^a (^a)", (severity = ANNOUNCE), based_msg, get_group_id_ ()); else call admin_gate_$syserr (severity, "^a: ^a (^a)", MYNAME, based_msg, get_group_id_ ()); return; end log_it; /* -------------------------------------------------- */ announce_syserr_code: /* console msg about something awful */ proc options (variable); dcl ecode fixed bin (35) based (ecode_p); dcl ecode_p pointer; dcl ecode_len fixed bin (21); /* ignored */ dcl based_msg char (tstr_len) based (addr (temp_str)); dcl severity fixed bin; dcl based_packed_ptr ptr unal based; dcl alp pointer; severity = ANNOUNCE; on any_other ; call cu_$arg_list_ptr (alp); call ioa_$general_rs (alp, 2, 3, temp_str, tstr_len, "0"b /* no pad */, "0"b /* nnl */); call cu_$arg_ptr (1, ecode_p, ecode_len, ec2); if testing then call com_err_ (ecode, MYNAME, "(^[SYSERR^;SYSLOG^]) ^a (^a)", (severity = ANNOUNCE), based_msg, get_group_id_ ()); else call admin_gate_$syserr_error_code (ANNOUNCE, ecode, "^a:^[ Code=^d.^;^s^] ^a (^a)", MYNAME, (baseno (addr (ecode) -> based_packed_ptr) = "0"b), ecode, based_msg, get_group_id_ ()); return; end announce_syserr_code; /* -------------------------------------------------- */ clean_up: /* tidy the place before we leave */ proc; dcl tptr ptr; if tsegp ^= null then do; tptr = tsegp; tsegp = null; /* so we don't try to do it again... */ call release_temp_segment_ ((MYNAME), tptr, ec2); if ec2 ^= 0 then call announce_syserr_code (ec2, "Unable to release temp segment."); end; if databasep ^= null then do; tptr = databasep; databasep = null; call hcs_$terminate_noname (tptr, ec2); if ec2 ^= 0 then call announce_syserr_code (ec2, "Unable to terminate database reference."); end; call vrm_lock_$cleanup (); if old_level ^= -1 then call cu_$level_set (old_level); a_ec = ec; /* tell caller our final status */ end clean_up; /* -------------------------------------------------- */ emergency_exit: /* just in case ... */ proc; if get_ring_ () = get_initial_ring_ () /* inner ring process? */ then do; call continue_to_signal_ (ec); /* behave like user ring subroutine */ if ec ^= 0 then goto EXIT; end; else do; /* throw fit if inner ring */ call announce_syserr ("Unexpected error occurred. Database may be in an inconsistant state."); ec = error_table_$unexpected_condition; goto EXIT; /* "clean_up" called from there... */ end; end emergency_exit; /* -------------------------------------------------- */ get_tseg: /* get temporary for caller */ proc; if tsegp ^= null () then do; /* should only need one temporary per invocation */ ec = error_table_$fatal_error; call announce_syserr (ec, "Attempting to get second temp segment."); goto EXIT; end; else do; call get_temp_segment_ ((MYNAME), tsegp, ec); if ec ^= 0 then goto EXIT; end; end get_tseg; /* -------------------------------------------------- */ check_lv: /* procedure to validate data for LV registration */ proc (p); dcl p ptr; ec = error_table_$bad_arg; /* guilty 'til proven innocent */ if p -> volume_registration.version ^= Volume_Registration_Version_2 then do; ec = error_table_$unimplemented_version; /* we'll be a little more specific here */ goto EXIT; end; if p -> volume_registration.lvid = "0"b then goto EXIT; if p -> volume_registration.lvname = "" then goto EXIT; if verify (rtrim (p -> volume_registration.lvname), LVNAME_LEGAL) ^= 0 then goto EXIT; if ^aim_check_$in_range (p -> volume_registration.access_class_range (2), access_class_range) then goto EXIT; if ^aim_check_$in_range (p -> volume_registration.access_class_range (1), access_class_range) then goto EXIT; if ^aim_check_$greater_or_equal (p -> volume_registration.access_class_range (2), p -> volume_registration.access_class_range (1)) then goto EXIT; if p -> volume_registration.volume_owner = "" then goto EXIT; if p -> volume_registration.acs_path ^= "" then do; call expand_pathname_ ((p -> volume_registration.acs_path), dn, en, ec2); if ec2 ^= 0 then do; ec = ec2; goto EXIT; end; j = length (rtrim (en)); if substr (en, j - 3, 4) ^= ".acs" then goto EXIT; end; /* we'll leave validation of "npv" up to our caller */ /* passed all tests */ ec = 0; return; end check_lv; /* -------------------------------------------------- */ check_new_lv: /* validate NEW LV registration data */ proc (p); dcl p ptr; call check_lv (p); /* will return if all OK */ if p -> volume_registration.npv ^= 1 then do; ec = error_table_$bad_arg; goto EXIT; end; ec = 0; return; end check_new_lv; /* -------------------------------------------------- */ check_pv: /* validate PV registration data */ proc (p); dcl p ptr; /* points to pv_registration structure */ ec = error_table_$bad_arg; if p -> pv_registration.pvid = "0"b then goto EXIT; if p -> pv_registration.model > hbound (MODELN, 1) | p -> pv_registration.model < lbound (MODELN, 1) then goto EXIT; if verify (rtrim (p -> pv_registration.pvname), PVNAME_LEGAL) ^= 0 then goto EXIT; if p -> pv_registration.location = "" then p -> pv_registration.location = "uninitialized"; if p -> pv_registration.mfg_serial = "" then p -> pv_registration.mfg_serial = "uninitialized"; if p -> pv_registration.date_registered > clock () | p -> pv_registration.date_registered < SMALL_DT then goto EXIT; /* the two bits of "password" may be anything */ ec = 0; return; end check_pv; /* -------------------------------------------------- */ check_new_pv: /* validate registration data for NEW PV */ proc (p); dcl p ptr; call check_pv (p); /* no special data checks for new PVs at this time */ return; end check_new_pv; /* -------------------------------------------------- */ name_exists: /* see if name exists in given directory */ proc (dname, ename) returns (bit (1)); dcl dname char (*); dcl ename char (*); call hcs_$status_minf (dname, ename, 0, type, bc, ec2); if ec2 ^= 0 then return ("0"b); else return ("1"b); end name_exists; /* -------------------------------------------------- */ locate_: /* find and set pointer to registration database */ proc (name, lvflag, dont_init_it); dcl name char (*); dcl (lvflag, dont_init_it) bit (1); if lvflag then do; if name = "root" then dn = ROOT; else dn = LV_DIR; en = "lv." || name; end; else do; if name = "rpv" then dn = ROOT; else dn = LV_DIR; en = "pv." || name; end; call cu_$level_get (old_level); call cu_$level_set (get_ring_ ()); /* SET LEVEL FOR OUR CALLER */ if ^dont_init_it then do; call hcs_$initiate (dn, en, "", 0, 0, databasep, ec); /* Locate volume registration for p|lv */ if ec = error_table_$segknown then do; /* program error */ call announce_syserr_code (ec, "Database - ""^a"".", en); ec = 0; end; else if ec ^= 0 then do; ec = error_table_$unregistered_volume; goto EXIT; end; vrp = databasep; /* this database is "volume_registration" */ if volume_registration.version ^= Volume_Registration_Version_2 then do; call convert_database (ec); if ec ^= 0 then goto EXIT; end; end; end locate_; /* -------------------------------------------------- */ locate_uid_: /* find registration and set pointer based on LVID or PVID */ proc (uid, lvflag, dont_init_it); dcl uid bit (36) aligned; dcl (lvflag, dont_init_it) bit (1); dn = LV_DIR; /* we don't know whether it's a root volume or not. However, the LV_DIR contains links for all the unique names ... */ if lvflag then en = "lvid." || unique_chars_ ((uid)); else en = "pvid." || unique_chars_ ((uid)); call cu_$level_get (old_level); call cu_$level_set (get_ring_ ()); /* SET LEVEL FOR OUR CALLER */ if ^dont_init_it then do; call hcs_$initiate (dn, en, "", 0, 0, databasep, ec); /* Locate volume registration for p|lv */ if ec = error_table_$segknown then do; /* program error */ call announce_syserr_code (ec, "Database - ""^a"".", en); ec = 0; end; else if ec ^= 0 then do; ec = error_table_$unregistered_volume; goto EXIT; end; vrp = databasep; /* this database is "volume_registration" */ if volume_registration.version ^= Volume_Registration_Version_2 then do; call convert_database (ec); if ec ^= 0 then goto EXIT; end; end; end locate_uid_; /* -------------------------------------------------- */ get_lve: /* routine to update Logical Volume entry in disk_table */ proc () returns (fixed bin); /* This entry modifies "disk_table" on behalf of the following entries: check_volume_registration find get_lv_pvinfo lvname_info */ dcl (freex, j) fixed bin init (0); dcl found bit (1) init ("0"b); dcl lvx fixed bin; do j = 1 to dt.n_lv_entries while (^found); lvep = addr (dt.lv_array (j)); if ^lve.used then if freex = 0 then freex = j; else ; else if lve.lvname = volume_registration.lvname then do; lvx = j; found = "1"b; end; end; if ^found then do; if freex = 0 then freex, dt.n_lv_entries = dt.n_lv_entries + 1; lvx = freex; lvep = addr (dt.lv_array (freex)); unspec (lve) = ""b; lve.used = "1"b; end; else lvep = addr (dt.lv_array (lvx)); /* Always make sure disk table is up to date with our manipulations */ lve.public = volume_registration.public; lve.lvid = volume_registration.lvid; lve.lvname = volume_registration.lvname; lve.min_access_class = volume_registration.access_class_range (1); lve.max_access_class = volume_registration.access_class_range (2); return (lvx); end get_lve; /* -------------------------------------------------- */ convert_database: /* routine to convert from version 1 to version 2 database */ procedure (a_ec); dcl a_ec parameter fixed bin (35); dcl temp_class bit (72) aligned; if volume_registration.version ^= 1 then a_ec = error_table_$improper_data_format; else do; /* switch access class values */ temp_class = volume_registration.access_class_range (1); volume_registration.access_class_range (1) = volume_registration.access_class_range (2); volume_registration.access_class_range (2) = temp_class; volume_registration.version = Volume_Registration_Version_2; call announce_syserr ("Converted "">lv>lv.^a"" to version 2.", volume_registration.lvname); a_ec = 0; end; return; end convert_database; /* -------------------------------------------------- */ /* ************************************************** */ /* This is the main exit for all entries */ /* ************************************************** */ EXIT: call clean_up; return; /* -------------------------------------------------- */ test: entry (a_dn); /* PUT US IN TEST MODE - i.e. don't use the real databases */ ROOT, LV_DIR = a_dn; testing = "1"b; return; /* ------------------------------ */ test2: entry (a_dn, a_dn2); /* same as above entry, except ROOT and LV_DIR may be specified differently */ ROOT = a_dn; LV_DIR = a_dn2; testing = "1"b; return; %page; %include aim_privileges; %page; %include volume_registration; %page; %include disk_table; %page; %include create_branch_info; %page; %include fs_dev_types; %page; %include syserr_constants; %page; %include access_mode_values; %page; %include delete_options; %page; /* BEGIN MESSAGE DOCUMENTATION Message: volume_registration_mgr_$ENTRY: Attempting to get second temp segment. (GROUP_ID) S: $info T: $run M: $err All entrypoints to volume_registration_mgr_ require at most one temporary segment. A: $contact Message: volume_registration_mgr_$ENTRY: Database - {lvid.UNIQUE | lv.LVNAME | pvid.UNIQUE | pv.PVNAME}. (GROUP_ID) Segment already known to process. S: $info T: $run M: $err The inner ring module always trerminates references to the database segments upon return to its caller. It found the specified segment already initiated upon entry to the specified routine. A: $contact Message: volume_registration_mgr_$ENTRY: Unable to release temp segment. (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: $err Some unexpected state is preventing the module from releasing its temporary segment. A: $contact Message: volume_registration_mgr_$ENTRY: Unable to terminate database reference. (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: $err Some unexpected state is preventing the module from terminating reference to a database segment. A: $contact Message: volume_registration_mgr_$ENTRY: Unexpected error occurred. Database may be in an inconsistant state. (GROUP_ID) S: $info T: $run M: $err Some unexpected condition was signalled while the module was executing. A: $contact Message: volume_registration_mgr_$add_lvr: Added new LV "LVNAME". (GROUP_ID) S: $log T: $run M: A new storage system logical volume has been registered on the system. A: $ignore Message: volume_registration_mgr_$add_lvr: Added new PV "PVNAME" to LV "LVNAME". (GROUP_ID) S: $log T: $run M: A new storage system physical volume has been registered on the system. A: $ignore Message: volume_registration_mgr_$add_lvr: Could not append link for {LV name | LVID | PV name | PVID}. (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: A link could not be added into >lv whose target is a database segment located under the root directory. Future database references may not be possible. A: $contact Message: volume_registration_mgr_$add_lvr: Unable to back out database "lv.LVNAME". (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: When attempting to register a new logical volume, some error occurred. The entry then attempted to remove the database segment just created. This removal failed. A: $contact Message: volume_registration_mgr_$add_pvr: Added new PV "PVNAME" to LV "LVNAME". (GROUP_ID) -log- S: $log T: $run M: A new storage system physical volume has been registered on the system. A: $ignore Message: volume_registration_mgr_$add_pvr: Could not append link for {PV name| PVID}. (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: A link could not be added into >lv whose target is a database segment located under the root directory. Future database references may not be possible. A: $contact Message: volume_registration_mgr_$add_pvr: Extra PV entry "PVNAME" in database "lv.LVNAME". (GROUP_ID) S: $info T: $run M: $err An entry for the specified PV was found in the database segment for the specified LV where no segment addname indicated its existance. A: $contact Message: volume_registration_mgr_$add_pvr: Unable to back out database addname "pv.PVNAME". (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: An error occurred while registering a new PV. The entry attmpts to undo all work up to the point of the error. In this case, it was unable to undo its manipulations and left a spurious addname "pv.PVNAME" on the database segment. A: $contact Message: volume_registration_mgr_$change_lvr: Changed ACS pathname for LV "LVNAME" to "PATH". (GROUP_ID) S: $log T: $run M: The registered ACS pathname of a storage system logical volume has been changed as indicated. A: $ignore Message: volume_registration_mgr_$change_lvr: Changed LV "LVNAME" to {PRIVATE | PUBLIC}. (GROUP_ID) S: $log T: $run M: The access type of the specified logical volume has been changed. A: $ignore Message: volume_registration_mgr_$change_lvr: Changed LVID of LV "LVNAME" from "LVID1" to "LVID2". (GROUP_ID) S: $log T: $run M: The registered logical volume unique ID has been changed for the specified LV. A: $ignore Message: volume_registration_mgr_$change_lvr: Changed name of LV "LVNAME1" to "LVNAME2". (GROUP_ID) S: $log T: $run M: The registered name of a storage system logical volume has been changed as indicated. A: $ignore Message: volume_registration_mgr_$change_lvr: Changed owner of LV "LVNAME" from "Person1.Project1" to "Person2.Project2". (GROUP_ID) S: $log T: $run M: The owner of a storage system logical volume has been changed as indicated. A: $ignore Message: volume_registration_mgr_$change_lvr: Changed {max | min} access class of LV "LVNAME" from "AUTH_STR1" to "AUTH_STR2". (GROUP_ID) S: $log T: $run M: The access class of a storage system logical volume has been changed as indicated. A: $ignore Message: volume_registration_mgr_$change_lvr: Couldn't {delete | create} link for {old | new} {LV name | LVID}. (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: A link for the specified database segment residing under the root directory could not be created in >lv. A: $contact Message: volume_registration_mgr_$change_lvr: Unable to back out LVID change to "LVNAME.mdcs". (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: $err While changing attributes of the logical volume LVNAME, an error was encountered. The entry then attempted to remove some changes already made to the registration database. In this case, it could not remove the LVID change to the master directory control database LVNAME.mdcs. A: $contact Message: volume_registration_mgr_$change_lvr: Unable to change name "lv.LVNAME1" back to "lv.LVNAME2" (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: $err While changing attributes ot the logical volume LVNAME, an error was encountered. The entry then attempted to remove some changes already made to the registration database. In this case, it could not remove theLV name change. A: $contact Message: volume_registration_mgr_$change_lvr: Unable to change name "lvid.UNIQUE1" back to "lvid.UNIQUE2". (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: $err While changing attributes ot the logical volume LVNAME, an error was encountered. The entry then attempted to remove some changes already made to the registration database. In this case, it could not remove LVID name change. A: $contact Message: volume_registration_mgr_$change_lvr: Unable to convert {max | min} auth to name_string. (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: $err A binary authorization string could not be converted to its readable representation. A: $contact Message: volume_registration_mgr_$change_lvr: Unexpected error changing name on "lv.LVNAME". (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: $err An unexpected error occured while changing the name on an LV registration data segment. The message explains the trouble. A: $contact Message: volume_registration_mgr_$change_lvr: Unexpected trouble changing name "lvid.UNIQUE". (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: $err An unexpected error occured while changing the name on an LV registration data segment. The message explains the trouble. A: $contact Message: volume_registration_mgr_$change_pvr: Changed PVID of PV "PVNAME" from "PVID1" to "PVID2" (GROUP_ID) S: $log T: $run M: The registered physical volume unique IFD has been changed as indicated. A: $ignore Message: volume_registration_mgr_$change_pvr: Changed date_registered of PV "PVNAME" from "DT1" to "DT2". (GROUP_ID) S: $log T: $run M: The registered date for the specified PV has been changed as indicated. A: $ignore Message: volume_registration_mgr_$change_pvr: Changed location of PV "PVNAME" from "LOC1" to "LOC2". (GROUP_ID) S: $log T: $run M: The registered location of the specified PV has been changed as indicated. A: $ignore Message: volume_registration_mgr_$change_pvr: Changed mfg_serial of PV "PVNAME" from "STR1" to "STR2". (GROUP_ID) S: $log T: $run M: The registered serial of the specified PV has been changed as indicated. A: $ignore Message: volume_registration_mgr_$change_pvr: Changed model of PV "PVNAME" from "TYPE1" to "TYPE2". (GROUP_ID) S: $log T: $run M: The registered model number of the specified PV has been changed as indicated. A: $ignore Message: volume_registration_mgr_$change_pvr: Changed name of PV "PVNAME1" to "PVNAME2". (GROUP_ID) S: $log T: $run M: The registered name of the specified PV has been changed as indicated. A: $ignore Message: volume_registration_mgr_$change_pvr: Changed password of PV "PVNAME". (GROUP_ID) S: $log T: $run M: The registered password of the specified PV has been changed as indicated. A: $ignore Message: volume_registration_mgr_$change_pvr: Couldn't {delete | create} link for {old | new} {PV name | PVID}. (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: A link for a database segment residing in the root directory could not be created in >lv. This may make some registration data inaccessible. A: $contact Message: volume_registration_mgr_$change_pvr: PV entry missing from database "pv.PVNAME". (GROUP_ID) S: $info T: $run M: $err An entry for the specified PV could not be found in the data segment although an addname for that PV exists on the segment entry. A: $contact Message: volume_registration_mgr_$change_pvr: Unable to back out PVID change. (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: While making changes to the registered PV attributes an error was encountered. The module attempts to remove any work already done on other attributes. For reasons given in ERROR_MESSAGE the PVID change could not be removed. A: $contact Message: volume_registration_mgr_$change_pvr: Unexpected trouble changing name "pv.PVNAME". (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: While making changes to the registered PV attributes an error was encountered. The module attempts to remove any work already done on other attributes. For reasons given in ERROR_MESSAGE the PV name change could not be removed. A: $contact Message: volume_registration_mgr_$change_pvr: Unexpected trouble changing name "pvid.UNIQUE". (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: An unexpected state made the program unable to change the database name associated with the PV unique ID. A: $contact Message: volume_registration_mgr_$check_volume_registration: ERROR_MESSAGE. cannot re-create >lv S: $info T: $init M: When the system is bootloaded, it checks the list of packs which were mounted during the last bootload to make sure that each one has a valid logical and physical volume registration. If the registration does not exist, the registration files are reconstructed. These registration files reside in the directory >lv, which is also remade if it was lost or did not exist. .sp This message indicates that there is a problem in re-creating >lv. Other error messages will follow and reregistration will fail. A: $inform Message: volume_registration_mgr_$check_volume_registration: ERROR_MESSAGE. Putting LV dir on RPV S: $info T: $init M: When the system is bootloaded, it checks the list of packs which were mounted during the last bootload to make sure that each one has a valid logical and physical volume registration. While re-creating >lv, the system attempted to set the directory flag which means "RPV only" and failed to do so. A: $inform Message: volume_registration_mgr_$check_volume_registration: ERROR_MESSAGE. Cannot add SysAdmin access to >lv. S: $info T: $init M: After creating a new >lv directory, an attempt is made to add "sma" access for *.SysAdmin.*. This failed. A: $inform Message: volume_registration_mgr_$check_volume_registration: ERROR_MESSAGE. Cannot reregister pv PVNAME S: $info T: $init M: When the system is bootloaded, it checks the list of packs which were mounted during the last bootload to make sure that each one has a valid logical and physical volume registration. .sp The system was unable to re-register the physical volume PVNAME because its logical volume entry could not be located in the old disk_table and its physical volume registration file could not be found. The volume will have to be re-registered manually. A: If PVNAME is garbage, ignore this message. Otherwise, use add_vol_registration to re-register the volume. Message: volume_registration_mgr_$check_volume_registration: ERROR_MESSAGE. Cannot reregister lv LVNAME S: $info T: $init M: When the system is bootloaded, it checks the list of packs which were mounted during the last bootload to make sure that each one has a valid logical and physical volume registration. .sp The system was unable to append a branch for >lv>lv.LVNAME. The logical volume will have to be re-registered manually. A: Use the add_vol_registration command to re-register the volume manually. Message: volume_registration_mgr_$check_volume_registration: ERROR_MESSAGE. PATH S: $info T: $init M: An error occurred when trying to reclassify a new lv.** seg as a multi-class system segment. A: $inform Message: volume_registration_mgr_$check_volume_registration: Reregistered TYPE lv LVNAME lvid WWWW S: $info T: $init M: When the system is bootloaded, it checks the list of packs which were mounted during the last bootload to make sure that each one has a valid logical and physical volume registration. The registration file for LVNAME did not exist and was reconstructed. .sp This message is always produced for the root logical volume during a cold boot of the Multics hierarchy. A: Use the list_vol_registration command to list the registration and check it against the re-created copy. Correct it with change_vol_registration if necessary. Message: volume_registration_mgr_$check_volume_registration: Code N. lv.LVNAME disagreed with disk_table. It was rebuilt. S: $info T: $init M: When the system is bootloaded, it checks the list of packs which were mounted during the last bootload to make sure that each one has a valid logical and physical volume registration. The registration file lv.LVNAME was found but disagreed with the disk_table_, and so it was corrected. The meaning of the codes can be determined from the listing of volume_registration_mgr_; it is rarely important. A: Use list_vol_registration to examine the remade registration, and correct it with change_vol_registration if necessary. Message: volume_registration_mgr_$check_volume_registration: ERROR_MESSAGE. Cant add name lvid.UNIQUE to lv.LVNAME S: $info T: $init M: When the system is bootloaded, it checks the list of packs which were mounted during the last bootload to make sure that each one has a valid logical and physical volume registration. The registration file for LVNAME did not have the additional name constructed from the volume unique ID, and an error was discovered trying to add it. If this name is on another segment, confusion will result. A: $inform Enter admin mode and do a "list >lv>**" command. Message: volume_registration_mgr_$check_volume_registration: ERROR_MESSAGE. Cannot make mdcs for LVNAME S: $info T: $init M: When the system is bootloaded, it checks the list of packs which were mounted during the last bootload to make sure that each one has a valid logical and physical volume registration. An error occurred while reconstructing LVNAME.mdcs. Operation on master directories for LVNAME may encounter problems. A: $inform_sa Message: volume_registration_mgr_$check_volume_registration: ERROR_MESSAGE. Cant add name pv.PVNAME to LVNAME S: $info T: $init M: When the system is bootloaded, it checks the list of packs which were mounted during the last bootload to make sure that each one has a valid logical and physical volume registration. .sp An error occurred adding the name pv.PVNAME to >lv>lv.LVNAME. If this name is missing or on another segment, confusion will result. A: $inform Enter admin mode and do a "list >lv>**" command. Message: volume_registration_mgr_$check_volume_registration: Reregistered pv PVNAME pvid WWWW in lv LVNAME S: $info T: $init M: When the system is bootloaded, it checks the list of packs which were mounted during the last bootload to make sure that each one has a valid logical and physical volume registration. Registration for PVNAME was added to the registration file for LVNAME. .sp This message is always produced for the root physical volume, rpv, during a cold boot of the Multics hierarchy. A: Use the list_vol_registration command to check the registration. If necessary, correct it with change_vol_registration. Message: volume_registration_mgr_$check_volume_registration: Registration for PVNAME was different from disk_table S: $info T: $init M: When the system is bootloaded, it checks the list of packs which were mounted during the last bootload to make sure that each one has a valid logical and physical volume registration. The physical volume ID or model number of PVNAME was wrong in the registration files and was corrected. A: $inform_sa Message: volume_registration_mgr_$check_volume_registration: ERROR_MESSAGE. Cant add name pvid.UNIQUE to LVNAME S: $info T: $init M: When the system is bootloaded, it checks the list of packs which were mounted during the last bootload to make sure that each one has a valid logical and physical volume registration. An error occurred adding the name pvid.UNIQUE to >lv>lv.LVNAME. If this name is missing or is on another segment, confusion will result. A: $inform Enter admin mode and do a "list >lv>**" command. Message: volume_registration_mgr_$delete_lvr: Could not remove {PV name | PVID | LV name | LVID} database link. (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: An unexpected state prevented the program from removing the database links associated with an LV just deleted. The links (in >lv) should be removed by hand using Ring_1_Repair. A: $contact Message: volume_registration_mgr_$delete_lvr: Deleted LV "LVNAME". (GROUP_ID) S: $log T: $run M: The registration for the spcified logical volume has been removed. A: $ignore Message: volume_registration_mgr_$delete_lvr: Deleted PV "PVNAME" from LV "LVNAME". (GROUP_ID) S: $log T: $run M: The registration for the specified physical volume was removed while removing the entire logical volume registration. A: $ignore Message: volume_registration_mgr_$delete_lvr: Unable to delete MDCS "LVNAME.mdcs". (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: After deleting the registration for a logical volume the module was unable to delete the corresponding master directory control database indicated in the message. A: $contact Message: volume_registration_mgr_$delete_pvr: Could not remove {PV name | PVID} database link. (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: An unexpected state prevented the removal of database links associated with a PV registration that was just deleted. The links should be deleted by hand using Ring_1_Repair. A: $contact Message: volume_registration_mgr_$delete_pvr: Deleted PV "PVNAME" from LV "LVNAME". (GROUP_ID) S: $log T: $run M: The registration fo the specified PV has been deleted. A: $ignore Message: volume_registration_mgr_$delete_pvr: PV entry missing from database "pv.PVNAME". (GROUP_ID) S: $info T: $run M: $err The entry for the specified PV could not be located in the database segment although its name appears on the segment entry. A: $contact Message: volume_registration_mgr_$delete_pvr: Trimming registration. (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: An unexpected state prevented the trimming of a registration database segment. This will not hinder subsystem performance. A: $contact Message: volume_registration_mgr_$delete_pvr: Unable to replace database name "pv.PVNAME". (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: $err While deleting the registration for the specified PV an error occurred. The program attempts to undo any changes to "leave things as they were." The attempt to put back the database segment name (as indicated) failed. A: $contact Message: volume_registration_mgr_$find: PV entry missing from "pv.PVNAME". (GROUP_ID) S: $info T: $run M: $err The entry for the specified PV could not be found in the registration database segment although the name appears on the segment's entry. A: $contact Message: volume_registration_mgr_$find_volname: PV entry not found in database "pvid.UNIQUE". (GROUP_ID) S: $info T: $run M: $err The entry for the specified PV could not be found in the registration database segment although the name appears on the segment's entry. A: $contact Message: volume_registration_mgr_$get_access: ACS not segment - "PATH". (GROUP_ID) S: $info T: $run M: The ACS indicated in the logical volume registration database is not a segment. The database entry should be corrected using "change_volume_registration". A: $contact_sa Message: volume_registration_mgr_$get_access: Bad ACS path in database "lv.LVNAME". (GROUP_ID) ERROR_MESSAGE S: $info T: $run M: $err The ACS pathname entry in the LVNAME database is illegal. This should not happen normally because the ring-1 primitives check all paths before entering them into the database. A: $contact Message: volume_registration_mgr_$pvname_info: PV entry not found in database "pv.PVNAME". (GROUP_ID) S: $info T: $run M: $err The entry for the specified PV could not be found in the registration database segment although the name appears on the segment's entry. A: $contact Message: volume_registration_mgr_$read_pvr: PV entry missing from database "pv.PVNAME". (GROUP_ID) S: $info T: $run M: $err The entry for the specified PV could not be found in the registration database segment although the name appears on the segment's entry. A: $contact END MESSAGE DOCUMENTATION */ end volume_registration_mgr_;  vrm_lock_.pl1 11/11/89 1102.4rew 11/11/89 0803.3 72729 /****^ *********************************************************** * * * 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. * * * *********************************************************** */ /****^ HISTORY COMMENTS: 1) change(86-06-05,GJohnson), approve(86-06-05,MCR7387), audit(86-06-10,Martinson), install(86-07-11,MR12.0-1091): Correct error message documentation. END HISTORY COMMENTS */ /* VRM_LOCK_: Entries which handle logical volume registration lock */ /* Created 07/31/84 by EJ Sharpe - actually pirated mdc_lock_ */ /* Modified 84-11-01 by EJ Sharpe for some minor fixes */ vrm_lock_: proc; /* Parameters */ dcl arg_code fixed bin (35); /* Automatic */ dcl code fixed bin (35); dcl vl fixed bin; /* Validation level */ dcl vrm_data_rings (3) fixed bin (3); /* Static */ dcl saved_data_ptr ptr int static init (null); dcl test_mode bit (1) int static init ("0"b); /* For debugging */ /* Constants */ dcl vrm_data_dir char (32) int static options (constant) init (">system_library_1"); dcl vrm_data_ename char (32) int static options (constant) init ("vrm_data"); %include vrm_data; /* External stuff */ dcl admin_gate_$syserr_error_code entry () options (variable); dcl clock_ entry returns (fixed bin (52)); dcl cu_$level_get entry (fixed bin); dcl cu_$level_set entry (fixed bin); dcl get_group_id_ entry returns (char (32)); dcl get_lock_id_ entry returns (bit (36)); dcl get_ring_ entry returns (fixed bin); dcl hcs_$initiate entry (char (*), char (*), char (*), fixed bin (1), fixed bin (2), ptr, fixed bin (35)); dcl hcs_$truncate_file entry (char (*), char (*), fixed bin (19), fixed bin (35)); dcl hcs_$append_branchx entry (char (*), char (*), fixed bin (5), dim (3) fixed bin (3), char (*), fixed bin (1), fixed bin (1), fixed bin (24), fixed bin (35)); dcl admin_gate_$reclassify_sys_seg entry (char (*), char (*), bit (72) aligned, fixed bin (35)); dcl set_lock_$lock entry (bit (36) aligned, fixed bin, fixed bin (35)); dcl set_lock_$unlock entry (bit (36) aligned, fixed bin (35)); dcl error_table_$invalid_lock_reset ext fixed bin (35); dcl error_table_$namedup ext fixed bin (35); dcl sys_info$access_class_ceiling bit (72) aligned external; dcl (null) builtin; /* Entries to handle the lock */ lock: entry (arg_code); if test_mode then do; arg_code = 0; return; end; call find_vrm_data; /* Get pointer */ call set_lock_$lock (vrm_data.lock, 30, code); if code = 0 then go to locked; /* Locked ok */ if code = error_table_$invalid_lock_reset then do; /* Recoverable error */ call admin_gate_$syserr_error_code (4, code, "vrm_lock_$lock:"); code = 0; go to locked; end; arg_code = code; return; /* Lock failed */ locked: vrm_data.lock_cnt = vrm_data.lock_cnt + 1; /* Do some meters */ vrm_data.time_locked = clock_ (); vrm_data.locker_name = get_group_id_ (); arg_code = code; return; unlock: entry; if test_mode then return; call find_vrm_data; unlock_common: vrm_data.unlock_cnt = vrm_data.unlock_cnt + 1; vrm_data.time_spent_locked = vrm_data.time_spent_locked + clock_ () - vrm_data.time_locked; call set_lock_$unlock (vrm_data.lock, code); if code ^= 0 then call admin_gate_$syserr_error_code (4, code, "vrm_lock_$unlock:"); return; /* Entry called by cleanup handlers on crawl-out. It is not certain that the lock is locked */ cleanup: entry; if test_mode then return; if saved_data_ptr = null then return; /* Never called lock */ vrm_datap = saved_data_ptr; if vrm_data.lock ^= get_lock_id_ () then return; /* Not locked by me */ go to unlock_common; /* Join std path */ /* Entry to set test mode */ set_test_mode: entry; test_mode = "1"b; return; /* Internal procedure to get a pointer to the vrm_data segment */ find_vrm_data: proc; dcl vrm_data_err condition; if saved_data_ptr ^= null then do; /* Pointer already knwon */ vrm_datap = saved_data_ptr; return; end; call cu_$level_get (vl); call cu_$level_set (get_ring_ ()); call hcs_$initiate (vrm_data_dir, vrm_data_ename, "", 0, 0, saved_data_ptr, code); call cu_$level_set (vl); if saved_data_ptr ^= null then do; /* It worked */ vrm_datap = saved_data_ptr; return; end; call admin_gate_$syserr_error_code (4, code, "vrm_lock_: Unable to initiate ^a>^a.", vrm_data_dir, vrm_data_ename); signal vrm_data_err; /* I don't know what else to do now */ return; end find_vrm_data; /* Initialization entry to create the vrm_data segment which contains the lock */ vrm_data_init: entry; if test_mode then return; vrm_data_rings = get_ring_ (); call hcs_$append_branchx (vrm_data_dir, vrm_data_ename, 01010b, vrm_data_rings, "*.*.*", 0, 0, 0, code); if (code ^= 0) & (code ^= error_table_$namedup) then do; call admin_gate_$syserr_error_code (0, code, "vrm_lock_$vrm_data_init: Unable to create ^a>^a.", vrm_data_dir, vrm_data_ename); return; end; if code = error_table_$namedup then do; call hcs_$truncate_file (vrm_data_dir, vrm_data_ename, 0, code); if code ^= 0 then do; call admin_gate_$syserr_error_code (0, code, "vrm_lock_$vrm_data_init: Unable to truncate ^a>^a.", vrm_data_dir, vrm_data_ename); return; end; end; call admin_gate_$reclassify_sys_seg (vrm_data_dir, vrm_data_ename, sys_info$access_class_ceiling, code); if code ^= 0 then call admin_gate_$syserr_error_code (0, code, "vrm_lock_$vrm_data_init: Unable to reclassify ^a>^a.", vrm_data_dir, vrm_data_ename); return; /* BEGIN MESSAGE DOCUMENTATION Message: vrm_lock_$lock: LOCK ERROR MESSAGE. S: $log T: $run M: A logical volume registration operation failed because of a problem with the vrm control lock. A: $ignore Message: vrm_lock_$unlock: LOCK ERROR MESSAGE. S: $log T: $run M: At the completion ofa logical volume registratin operation, some error occured unlocking the vrm control lock. A: $ignore Message: vrm_lock_: Unable to initiate PATHNAME. REASON. S: $log T: $run M: Logical volume registration control (vrm) was unable to initiate PATHNAME, which contains the vrm control lock, because of REASON. The logical volume registration control operation requested was not performed. A: $ignore Message: vrm_lock_$vrm_data_init: Unable to create PATHNAME. REASON. S: $info T: $init M: Logical volume registration control (vrm) was unable to create the segment PATHNAME, to be used for the vrm control lock, for the REASON given. Subsequent logical volume registration control operations may fail. A: $ignore Message: vrm_lock_$vrm_data_init: Unable to truncate PATHNAME. REASON. S: $info T: $init M: Logical volume registration control was unable to truncate the segment PATHNAME for the REASON given. This segment is to be used for the logical volume registration control lock. Subsequent logical volume registration control operations may fail. A: $ignore Message: vrm_lock_$vrm_data_init: Unable to reclassify PATHNAME. REASON. S: $info T: $init M: Logical volume registration control was unable to reclassify the segment PATHNAME to its proper access class for the REASON given. This segment is to be used for the logical volume registration control lock. Subsequent logical volume registration control operations may fail. END MESSAGE DOCUMENTATION */ end vrm_lock_;  wdx.pl1 11/11/89 1102.4r w 11/11/89 0803.3 96003 /****^ *********************************************************** * * * 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. * * * *********************************************************** */ wdx$init: proc (a_evchn, a_ec); /* wdx - ring 1 lv_attach_table manager Runs in Initializer process, communicates lv_request_'s desires to table and user process. Entries are accessible through initializer_mdc_ Entry Points: check_mount issue syserr message for overdue mount free_lvate clear one out init set up for bootload invalidate_lvate cause process to give up lv mhvmessage issue syserr message for Operator poll_mounts check for overdue mounts respond_mount_lv set return state, code, and bit retrieve_lvate dredge entry out of lvat scan_lv find all lv occurences scan_process find all process occurrences set_lvinfo put lvid and stuff in lvate Bernard Greenberg 09/08/76 Modified December 1981 by J. Bongiovanni for poll_mounts, check_mount Modified April 82 BIM for legal acls. */ /* Parameter */ dcl a_array (*) fixed bin; dcl a_code fixed bin (35); dcl a_ec fixed bin (35); dcl a_evchn fixed bin (71); dcl a_lvatep ptr; dcl a_lvax fixed bin (17); dcl a_lvid bit (36) aligned; dcl a_lvname char (*); dcl a_lvx fixed bin; dcl a_n fixed bin; dcl a_next_time fixed bin (71); dcl a_pid bit (36) aligned; dcl a_state fixed bin; dcl a_unit_string char (*) varying; dcl a_username char (*); /* Automatic */ dcl 1 seg_acl (1) aligned like segment_acl_entry; dcl ec fixed bin (35); dcl fixedipcmessage fixed bin (71); dcl lvax fixed bin; dcl lvname char (32); dcl n fixed bin; dcl next_time fixed bin (71); dcl pid bit (36) aligned; dcl save_lev fixed bin; dcl username char (32); /* Static */ dcl END_OF_TIME fixed bin (71) int static options (constant) init (1111111111111111111111111111111111111111111111111111b); dcl LVAT_NAME char (32) static init ("lv_attach_table") options (constant); dcl s_lvatp ptr static init (null); dcl SYSDIR char (168) static init (">lv"); dcl TIMEOUT fixed bin (71) int static options (constant) init (240000000); /* 4 minutes */ dcl WDX_RING fixed bin init (1) static; /* Based */ dcl ipcmessage char (8) based (addr (fixedipcmessage)); /* Entry */ dcl admin_gate_$reclassify_sys_seg entry (char (*), char (*), bit (72) aligned, fixed bin (35)); dcl admin_gate_$syserr entry options (variable); dcl admin_gate_$syserr_error_code entry options (variable); dcl cu_$level_get entry (fixed bin); dcl cu_$level_set entry (fixed bin); dcl get_max_authorization_ returns (bit (72) aligned); dcl get_process_id_ entry returns (bit (36) aligned); dcl get_ring_ entry returns (fixed bin); dcl hcs_$add_acl_entries entry (char (*), char (*), ptr, fixed bin, fixed bin (35)); dcl hcs_$make_seg entry (char (*), char (*), char (*), fixed bin (5), ptr, fixed bin (35)); dcl hcs_$truncate_seg entry (ptr, fixed bin, fixed bin (35)); dcl hcs_$wakeup entry (bit (36) aligned, fixed bin (71), fixed bin (71), fixed bin (35)); /* Builtin */ dcl clock builtin; dcl min builtin; dcl null builtin; dcl stacq builtin; /* Condition */ dcl cleanup condition; /* */ a_ec = 0; call cu_$level_get (save_lev); on cleanup call cu_$level_set (save_lev); call cu_$level_set (WDX_RING); call hcs_$make_seg (SYSDIR, LVAT_NAME, "", 1011b, s_lvatp, ec); if s_lvatp = null then do; init_lose: call cu_$level_set (save_lev); a_ec = ec; return; end; call hcs_$truncate_seg (s_lvatp, 0, ec); if ec ^= 0 then go to init_lose; call admin_gate_$reclassify_sys_seg (SYSDIR, LVAT_NAME, get_max_authorization_ (), ec); if ec ^= 0 then go to init_lose; seg_acl (1).access_name = "*.*.*"; seg_acl (1).mode = RW_ACCESS; seg_acl (1).extended_mode = ""b; seg_acl (1).status_code = 0; call hcs_$add_acl_entries (SYSDIR, LVAT_NAME, addr (seg_acl), 1, ec); if ec = 0 then if seg_acl (1).status_code ^= 0 then ec = seg_acl (1).status_code; if ec ^= 0 then go to init_lose; call cu_$level_set (save_lev); lvatp = s_lvatp; lvat.master_pid = get_process_id_ (); lvat.master_evchn = a_evchn; lvat.max_n_entries = 10000; lvat.highest_used = 0; lvat.initialized = "1"b; return; /* --------------------------------------------------------- */ retrieve_lvate: entry (a_lvax, a_lvatep, a_ec); lvax = a_lvax; lvatp = s_lvatp; if lvax > lvat.highest_used | lvax <= 0 then do; a_ec = 5; return; end; lvatep = addr (lvat.array (lvax)); a_lvatep -> lvate = lvate; a_ec = 0; return; /* --------------------------------------------------------- */ free_lvate: entry (a_lvax); lvatp = s_lvatp; lvatep = addr (lvat.array (a_lvax)); if stacq (lvate.pid, "0"b, (lvate.pid)) then; return; /* --------------------------------------------------------- */ respond_mount_lv: entry (a_lvax, a_state, a_code, a_ec); lvatp = s_lvatp; lvatep = addr (lvat.array (a_lvax)); lvate.code = a_code; lvate.state = a_state; if lvate.state = 1 then do; lvate.waiting = "0"b; lvate.mounted = "1"b; end; else if lvate.state = 4 then do; lvate.waiting = "1"b; lvate.mount_request_timeout = clock () + TIMEOUT; ipcmessage = "poll "; call hcs_$wakeup (lvat.master_pid, lvat.master_evchn, fixedipcmessage, ec); if ec ^= 0 then call admin_gate_$syserr_error_code (0, ec, "wdx: Unable to send wakeup on master channel"); end; else lvate.waiting = "0"b; if lvate.state ^= 4 then lvate.pending_mount = "0"b; lvate.mount_req_answered = "1"b; ipcmessage = "lv_mount"; call hcs_$wakeup (lvate.pid, lvate.evchn, fixedipcmessage, ec); a_ec = ec; return; /* --------------------------------------------------------- */ scan_process: entry (a_pid, a_array, a_n); pid = a_pid; lvatp = s_lvatp; n = 0; do lvax = 1 to lvat.highest_used; if lvat.array (lvax).pid = pid then do; n = n + 1; a_array (n) = lvax; end; end; a_n = n; return; /* --------------------------------------------------------- */ scan_lv: entry (a_lvname, a_array, a_n); lvname = a_lvname; lvatp = s_lvatp; n = 0; do lvax = 1 to lvat.highest_used; lvatep = addr (lvat.array (lvax)); if lvate.pid ^= "0"b then if lvate.pending_mount | lvate.mount_req_answered then if lvate.lvname = lvname & ^lvate.invalidated then do; n = n + 1; a_array (n) = lvax; end; end; a_n = n; return; /* --------------------------------------------------------- */ invalidate_lvate: entry (a_lvax); lvatp = s_lvatp; lvatep = addr (lvat.array (a_lvax)); lvate.invalidated = "1"b; return; /* --------------------------------------------------------- */ set_lvinfo: entry (a_lvax, a_lvid, a_lvx); lvatp = s_lvatp; lvatep = addr (lvat.array (a_lvax)); lvate.lvid = a_lvid; lvate.lvx = a_lvx; return; /* --------------------------------------------------------- */ mhvmessage: entry (a_lvax, a_username); lvatp = s_lvatp; lvatep = addr (lvat.array (a_lvax)); username = a_username; call admin_gate_$syserr (3, "RCP: Mount logical volume ^a for ^a", lvate.lvname, username); return; /* --------------------------------------------------------- */ poll_mounts: entry (a_array, a_n, a_next_time); lvatp = s_lvatp; next_time = END_OF_TIME; n = 0; do lvax = 1 to lvat.highest_used; lvatep = addr (lvat.array (lvax)); if (lvate.pid ^= "0"b) & lvate.waiting & lvate.mount_req_answered & ^lvate.invalidated then do; if lvate.mount_request_timeout < clock () then do; n = n + 1; a_array (n) = lvax; lvate.mount_request_timeout = clock () + TIMEOUT; end; next_time = min (next_time, lvate.mount_request_timeout); end; end; a_n = n; if next_time = END_OF_TIME then a_next_time = -1; else a_next_time = next_time; return; /* --------------------------------------------------------- */ check_mount: entry (a_lvax, a_username, a_unit_string); lvatp = s_lvatp; lvatep = addr (lvat.array (a_lvax)); if lvate.pid ^= "0"b & lvate.waiting & lvate.mount_req_answered & ^lvate.invalidated then call admin_gate_$syserr (3, "RCP: Check mount of logical volume ^a for ^a^/^15x^a", lvate.lvname, (a_username), (a_unit_string)); return; /* --------------------------------------------------------- */ test: entry (testdir); dcl testdir char (*); SYSDIR = testdir; WDX_RING = get_ring_ (); return; /* */ %include acl_structures; %include access_mode_values; %include lv_atttbl; /* BEGIN MESSAGE DOCUMENTATION Message: RCP: Mount logical volume LVNAME for PROCESSNAME S: $beep T: $run M: A user (PROCESSNAME) has requested the attachment of logical volume LVNAME. It is not now mounted. The initializer will issue mount messages for all physical volumes needed. A: Mount the required physical volumes, using the add_vol command to indicate when each has been made ready. The user process will continue when the last volume has been mounted. If the volume cannot be mounted, use the del_lv command to indicate this fact, and the user process will receive an error indication. Message: RCP: Check mount of logical volume LVNAME for PROCESSNAME PVNAME1(DRIVE1) ... S: $beep T: $run M: A user (PROCESSNAME) previously requested the attachment of logical volume LVNAME. The mount has not been accomplished in a 4 minutes. All required physical volumes are specified (PVNAMEi, DRIVEi). A: Mount the required physical volumes, using the add_vol command to indicate when each has been made ready. The user process will continue when the last volume has been mounted. If the volume cannot be mounted, use the del_lv command to indicate this fact, and the user process will receive an error indication. Message: wdx: ERRORCODE Unable to send wakeup on master channel. S: $info T: $run M: The ring-1 logical volume mount software was unable to send a wakeup to the ring-4 software for the reason indicated. Some mount requests may have been lost. A: $contact_sa END MESSAGE DOCUMENTATION */ end; 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