THIS FILE IS DAMAGED COMPILATION LISTING OF SEGMENT disk_table_ Compiled by: Multics PL/I Compiler, Release 32f, of October 9, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 11/11/89 1018.3 mst Sat Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* *********************************************************** */ 11 12 /****^ HISTORY COMMENTS: 13* 1) change(86-06-05,GJohnson), approve(86-06-05,MCR7387), 14* audit(86-06-10,Martinson), install(86-07-17,MR12.0-1091): 15* Correct error message documentation. 16* 2) change(86-06-30,Fawcett), approve(86-06-30,MCR7383), 17* audit(86-06-30,LJAdams), install(86-07-17,MR12.0-1097): 18* Add support for subvolumes, 3380 and 3390. 19* 3) change(88-04-18,Farley), approve(88-05-26,MCR7880), 20* audit(88-06-07,Parisek), install(88-07-05,MR12.2-1052): 21* Corrected problem in dry_run_mhv execution by removing the zeroing of the 22* return error code in MHV, which was making the dry run appear to succeed. 23* Also corrected several coding violations. 24* END HISTORY COMMENTS */ 25 26 /* format: style2,^inddcls,indcomtxt */ 27 28 disk_table_: 29 proc; 30 31 /* DISK_TABLE_ - manage the system's Disk Table. 32* 33* This program is called by system_startup_ and sc_command_ 34* to manage a table parallel to the PVT 35* which contains the long names of volumes 36* and various other management information. 37* 38* Atually this program is just message typing and arg counting.. see mdx for the real stuff. 39* 40* This program refers to "hv" and "hvol" which mean Hierarchy Volume. 41* The new term is "Logical Volume", which means the same thing. 42* 43* See MTB-213 by Bernie Greenberg for the design. 44* 45* By Tom VanVleck, and Bernie Greenberg. 46* Modified April 1976 by Greenberg for demounter, parallel drive assignment, new salv interface (28-4). 47* Modified September 1976 by Greenberg for auto mhvs by lv_request, init_vol -no_reg. 48* Modified December 1976 by Greenberg for dte.demounted, mhv drive selector recoded. 49* Modified March 1977 by Greenberg for init_vol -copy, ss_io_reconfig. 50* Modified February 1977 by Greenberg for init_vol -copy. 51* Modified July 1977 by T. Casey to add set_lv_pdir_bit entry. 52* Modified August 1981 by J. Bongiovanni to improve synchronization of the 53* various copies of the disk table 54* Modified December 1981 by J. Bongiovanni to allow mounting LVEs on mhv dry run 55* Modified April 1982 by J. Bongiovanni for better init_vol argument parsing 56* Modified 831122 by E. A. Ranzenbach for set_vacate_pdirs_bit entry. 57* Modified 84-08-29 by EJ Sharpe for auto registration of RLV PVs during cold boot 58* Modified 84-10-30 by EJ Sharpe for some minor fixes 59* Modified 85-01-31 by Keith Loepere for real error codes. 60* Modified 1985-04-02, BIM: don't suggest drives for non-demountable 61* disks. Report missing root physical volumes at accept_rlv time. 62* (Note that those messages will be repeated each time that 63* system_startup_ calls $accept_rlv.) 64* Modified 04/85 by RAF to support subvolumes. 65**/ 66 67 68 dcl (i, j) fixed bin, 69 demount_problem bit (1), 70 took bit (1), 71 (lpv, llv, bfsw, ldrive) 72 bit (1), /* for list entry */ 73 copy_sw bit (1) aligned, 74 rlv_sw bit (1) aligned, 75 fb71 fixed bin (71), 76 ap ptr, 77 al fixed bin, 78 bchr char (al) based (ap), 79 pvap ptr, 80 npv fixed bin, 81 match_dtx fixed bin, /* Used in dt scan */ 82 trial fixed bin, /* 1ce for no *offs, 2 for yes */ 83 mhvtest_lvx fixed bin, /* for referencecounting vols */ 84 tpvtx fixed bin, /* for mhv error drive */ 85 last_sv fixed bin, 86 pvname char (32), 87 pvname1 char (32), 88 lvname char (32), 89 drive_arg char (8) aligned, 90 publicstr char (10), 91 drivea char (2), 92 drive_id char (8), 93 arg char (64), 94 arg_list_ptr ptr, 95 ignore_num fixed bin, 96 ignore_ec fixed bin (35), 97 ec fixed bin (35); 98 99 dcl (a_pvname, a_copydrive, a_drive, a_lvname) 100 char (*) parm; 101 102 dcl new bit (1); /* TRUE if made new disk_table */ 103 dcl sdtp ptr static init (null); 104 dcl cu_$level_get entry (fixed bin); 105 dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin, fixed bin (35)); 106 dcl cu_$arg_list_ptr entry (ptr); 107 dcl level fixed bin; 108 109 dcl 1 pva (100) based (pvap) aligned, 110 2 pvname char (32), 111 2 device_type fixed bin, 112 2 pad fixed bin; 113 114 dcl 1 pvinfo aligned like pv_registration; 115 116 dcl ( 117 ARG1 fixed bin init (1), 118 ARG2 fixed bin init (2), 119 STOP_MOUNT fixed bin init (1), 120 START_DEMOUNT fixed bin init (2), 121 FINISH_DEMOUNT fixed bin init (3) 122 ) internal static options (constant); 123 124 dcl ( 125 ioa_, 126 ioa_$rsnnl 127 ) entry options (variable); 128 dcl com_err_ entry options (variable); 129 dcl hcs_$make_seg entry (char (*), char (*), char (*), fixed bin (5), ptr, fixed bin (35)); 130 dcl disk_table_$accept_rlv entry (fixed bin (35)); 131 dcl lv_request_$dhv entry (char (*)); 132 dcl lv_request_$mhv_complete 133 entry (fixed bin, ptr); 134 dcl disk_rebuild_caller entry (ptr, fixed bin, fixed bin, bit (36) aligned); 135 dcl initializer_mdc_$rlvolcheck 136 entry (fixed bin, fixed bin, bit (36) aligned, fixed bin (35)); 137 dcl initializer_mdc_$init entry (ptr, bit (1), fixed bin (35)); 138 dcl initializer_mdc_$get_lv_pvinfo 139 entry (char (*), ptr, fixed bin, fixed bin, fixed bin (35)); 140 dcl initializer_mdc_$mhv entry (fixed bin, fixed bin, fixed bin (35)); 141 dcl initializer_mdc_$demount_lv 142 entry (fixed bin, fixed bin, fixed bin (35)); 143 dcl initializer_mdc_$demount_pv 144 entry (fixed bin, fixed bin (35)); 145 dcl initializer_mdc_$take entry (char (*), fixed bin, bit (1), fixed bin (35)); 146 dcl initializer_mdc_$assert 147 entry (char (*), fixed bin, fixed bin (35)); 148 dcl initializer_mdc_$volsalv 149 entry (char (*), fixed bin, bit (36) aligned, fixed bin (35)); 150 dcl initializer_mdc_$forget 151 entry (fixed bin, fixed bin (35)); 152 dcl initializer_mdc_$set_lv_pdir_bit 153 entry (char (*), bit (1) aligned, fixed bin (35)); 154 dcl initializer_mdc_$set_vacate_pdirs_bit 155 entry (char (*), bit (1) aligned, fixed bin (35)); 156 dcl initializer_mdc_$ss_io_reconfig 157 entry (fixed bin, bit (1) aligned, fixed bin (35)); 158 dcl init_disk_pack_ entry (ptr, ptr, fixed bin, ptr, fixed bin (35)); 159 dcl init_disk_pack_$parse_args 160 entry (ptr, char (*), char (*), bit (1) aligned, bit (1) aligned, fixed bin (35)); 161 dcl initializer_mdc_$read_disk_table 162 entry (ptr, fixed bin (35)); 163 dcl volume_registration_mgr_$add_pvr 164 entry (char (*), ptr, fixed bin (35)); 165 dcl disk_table_$accept_all entry (fixed bin (35)); 166 dcl mdx$reregister entry (char (*), fixed bin, fixed bin (35)); 167 168 dcl (addr, clock, length, null, rtrim, substr, unspec, char, verify) 169 builtin; 170 171 dcl error_table_$unregistered_volume 172 fixed bin (35) ext; 173 dcl error_table_$action_not_performed 174 fixed bin (35) ext; 175 176 /* ======================================================== */ 177 178 init: 179 entry (rc); /* called by system_startup_ */ 180 181 dcl rc fixed bin (35); /* errcode */ 182 dcl rce bit (1); /* sw for rc entries */ 183 184 rce = "1"b; 185 call initializer_mdc_$init (sdtp, new, rc); 186 if new 187 then call com_err_ (rc, "disk_table_", "New disk_table created"); 188 else if rc ^= 0 189 then call com_err_ (rc, "disk_table_", ""); 190 191 return; 192 193 /* -------------------------------------------------------- */ 194 195 accept_all: 196 entry (rc); 197 198 rce = "1"b; 199 rc = 0; 200 201 call copy_disk_table (); 202 do i = 1 to dt.n_entries; 203 dtep = addr (dt.array (i)); 204 if ^dte.used 205 then /* Take only unused volumes */ 206 if dte.storage_system & ^dte.deleted 207 then if dte.known | dte.pre_accepted 208 then do; 209 call initializer_mdc_$take ((dte.pvname), i, took, ec); 210 if ec ^= 0 211 then call print_error; 212 if ec ^= 0 213 then rc = ec; /* Remember if any screwed up */ 214 else if took & dte.lvx ^= 1 215 then call announce_mount ((dte.lvx)); 216 end; 217 end; 218 return; 219 220 /* -------------------------------------------------------- */ 221 222 general_mhv: 223 entry (rc); /* Entry to induce a general mhv, and report results */ 224 225 rce = "1"b; 226 call mhv ("-all"); /* start the mhvs */ 227 call copy_disk_table (); 228 do i = 1 to dt.n_lv_entries; /* Scan the lve array */ 229 lvep = addr (dt.lv_array (i)); 230 if lve.used & ^lve.hv_mounted & ^lve.demounted_only 231 then do; 232 rc = error_table_$action_not_performed; 233 call com_err_ (0, "disk_table_", "Some volumes are incomplete. Complete or demount them."); 234 return; 235 end; 236 end; 237 rc = 0; 238 return; 239 240 241 accept_rlv: 242 entry (rc); 243 244 /**** NOTE: this procedure does not do the "find a free drive and 245* request a mount" thing that the normal "alv" command does. 246* Operators must always tell US where root LV pv's are to be 247* found. Could/should this be changed? --BIM */ 248 249 rce = "1"b; 250 rc = 0; 251 call copy_disk_table (); 252 call initializer_mdc_$mhv ((dt.array (dt.rpvx).lvx), tpvtx, rc); 253 ec = rc; 254 if rc ^= 0 255 then do; 256 if tpvtx > 0 257 then do; 258 dtep = addr (dt.array (tpvtx)); 259 call print_error; /* Still return the code and prevent exit to ring 4 */ 260 end; 261 else call list_missing_rlv_pvs; /* whether code is 1 (missing vol) or something else, the call to get_lv_pvinfo will detect it. */ 262 /* our caller just tests the code for 0 */ 263 rc = 1; 264 end; 265 return; 266 267 list_missing_rlv_pvs: 268 procedure; 269 270 call copy_disk_table (); 271 call initializer_mdc_$get_lv_pvinfo ("root", pvap, npv, ignore_num, ec); 272 /* Read the registry */ 273 if ec ^= 0 274 then do; /* Impossible! */ 275 call com_err_ (ec, "disk_table_", 276 "Cannot get volume registration info for the root logical volume.^/ Shutdown and reboot with ""boot nolv""." 277 ); 278 return; 279 end; 280 281 call ioa_ ("The root logical volume is incomplete."); 282 call MHV ("root", "0"b, 0); /* Find some drives, print some messages */ 283 return; 284 285 end list_missing_rlv_pvs; 286 287 288 accept: 289 entry; 290 291 rce = "0"b; 292 call cu_$arg_ptr (ARG1, ap, al, ec); 293 if ec ^= 0 294 then go to gruz; 295 if bchr = "-all" | bchr = "-a" 296 then do; 297 call disk_table_$accept_all (ignore_ec); 298 return; 299 end; 300 pvname = bchr; 301 call cu_$arg_ptr (ARG2, ap, al, ec); 302 if ec ^= 0 303 then do; 304 gruz: 305 call com_err_ (ec, "disk_table_", ""); 306 ret: 307 if rce 308 then rc = ec; 309 return; 310 end; 311 call parse_drive_id (bchr); 312 call verify_drive; /* check drive for free */ 313 314 call initializer_mdc_$take (pvname, i, took, ec); 315 call copy_disk_table (); 316 if ec ^= 0 317 then call print_error; 318 else if took 319 then call announce_mount ((dte.lvx)); 320 else if dt.array (i).used 321 then if dt.array (i).lvx ^= 1 322 then call ioa_ ("added pv ^a to mounted lv ^a.", pvname, dt.lv_array (dt.array (i).lvx).lvname); 323 return; 324 325 326 327 mount_hvol: 328 mhv: 329 entry options (variable); 330 331 rce = "0"b; 332 call cu_$arg_ptr (ARG1, ap, al, ec); 333 if ec ^= 0 334 then go to gruz; 335 call copy_disk_table (); 336 if bchr = "-all" | bchr = "-a" 337 then do; 338 do j = 1 to dt.n_lv_entries; 339 lvep = addr (dt.lv_array (j)); 340 if lve.used & ^lve.hv_mounted & ^lve.demounted_only 341 then do; 342 call mhv ((lve.lvname)); 343 call copy_disk_table (); 344 end; 345 end; 346 return; 347 end; 348 lvname = bchr; 349 j = 0; /* -1 suppresses lve creation */ 350 call initializer_mdc_$get_lv_pvinfo (lvname, pvap, npv, j, ec); 351 if ec ^= 0 352 then do; 353 call com_err_ (ec, "disk_table_", "^a", lvname); 354 return; 355 end; 356 call copy_disk_table (); 357 lvep = addr (dt.lv_array (j)); 358 if lve.hv_mounted 359 then do; 360 call com_err_ (0, "disk_table_", "lv ^a already mounted", lvname); 361 return; 362 end; 363 else if lve.demounting 364 then do; 365 call com_err_ (0, "disk_table_", "lv ^a cannot be mounted, in process of demount.", lvname); 366 return; 367 end; 368 call initializer_mdc_$mhv (j, tpvtx, ec); 369 call copy_disk_table (); 370 if ec = 0 371 then do; 372 call announce_mount (j); 373 return; 374 end; 375 else if tpvtx > 0 376 then do; 377 dtep = addr (dt.array (tpvtx)); 378 call print_error; 379 380 end; 381 382 call MHV (lvname, "0"b, 0); /* test is off */ 383 return; 384 385 /* --------------------------------------------------------- */ 386 387 dry_run_mhv: 388 entry (a_lvname, rc); 389 390 lvname = a_lvname; 391 rce = "1"b; 392 j = 0; 393 call initializer_mdc_$get_lv_pvinfo (lvname, pvap, npv, j, ec); 394 if ec ^= 0 395 then do; 396 rc = ec; /* He'll get tired after a while */ 397 return; 398 end; 399 400 rc = 0; /* show initial success */ 401 402 /* do NOT copy disk table -- lv_request_ is munging current copy for test purposes */ 403 404 dtp = sdtp; 405 406 do i = 1 to dt.n_lv_entries while (dt.lv_array (i).lvname ^= lvname); 407 end; 408 if i > dt.n_lv_entries 409 then do; /* Put phony one in there */ 410 dt.n_lv_entries = i; 411 lvep = addr (dt.lv_array (i)); 412 unspec (lve) = "0"b; 413 lve.lvname = lvname; 414 end; 415 416 mhvtest_lvx = i; 417 dt.lv_array (mhvtest_lvx).mounting = "1"b; /* Note elegant effect upon mhvver */ 418 419 call MHV (lvname, "1"b, mhvtest_lvx); /* this sets rc */ 420 return; 421 422 423 424 /**** Assume that pva and npv are set on entry to this procedure */ 425 426 MHV: 427 procedure (lvname, mhvtest, mhvtest_lvx); 428 429 declare mhvtest bit (1) aligned; 430 declare mhvtest_lvx fixed bin; 431 declare lvname char (*); 432 433 do i = 1 to npv; 434 call MHV_ONE_PV; 435 end; 436 return; 437 438 MHV_ONE_PV: 439 procedure; /* i is global parm (ycch) specifying which pv */ 440 441 declare (found, found_good_drive) 442 bit (1) aligned; 443 444 pvname = pva (i).pvname; /* for calls &c */ 445 found = "0"b; /* set to one iff we find it mounted */ 446 found_good_drive = "0"b; /* set to one iff we have a drive in mind to mount it on */ 447 448 /**** NOTE: the following assumes that there can only be one dte 449* with a given PV name in the entire disk table. */ 450 451 do j = 1 to dt.n_entries while (^found & ^found_good_drive); 452 dtep = addr (dt.array (j)); 453 if dte.pvname = pvname 454 then if dte.used | dte.known 455 then found = "1"b; /* its already mounted */ 456 else if dte.pre_accepted | dte.demounted 457 then found_good_drive = "1"b; 458 459 /**** + ASSUME: pv names are unique across the system. 460* no pv can be listed twice in the disk table. 461* 462* THEN: if this entry has our pv name, is available for 463* storage system use, then it will be either already 464* known (test above) or free, since no other LV 465* could claim it. Thus it is the last place that we 466* saw this disk pack. Since disk packs are notorious 467* for their tendency to stay where one leaves them, 468* we should tell the operator to spin it up HERE. */ 469 470 else if dte.storage_system & ^dte.deleted & (dte.device_type = pva (i).device_type) 471 then found_good_drive = "1"b; 472 end; 473 474 if ^found 475 then do; 476 477 if ^found_good_drive & media_removable (pva (i).device_type) 478 /* we can search for a good drive for 451's */ 479 /* for non-demountables we either know where it was */ 480 /* or stay mute, to avoid fatuous suggestions. */ 481 then do trial = 1 to 3 while (^found_good_drive); 482 do j = 1 to dt.n_entries while (^found_good_drive); 483 dtep = addr (dt.array (j)); 484 /* Here are usability criteria */ 485 if dte.storage_system & ^dte.deleted 486 /** available at all */ 487 & ^(dte.used | dte.known) 488 /** not in use already */ 489 & dte.device_type = pva (i).device_type 490 /** the right kind */ 491 then if (^(dte.pre_accepted & dt.lv_array (dte.lvx).mounting) 492 /** we can't be planning to mount something else here */ 493 | (mhvtest & dt.lv_array (dte.lvx).good_candidate)) 494 /** unless this is a dry run and we propose to demount this lv */ 495 & ^((trial = 1) & dte.demounted) 496 /** dont unseat in pass 1, we might mount it again */ 497 & ^((trial < 3) & dte.pre_accepted) 498 /** we are trying to mount something else here */ 499 then found_good_drive = "1"b; 500 end; 501 end; 502 503 504 /**** We arrive here directly if the first loop found that the 505* drive that the pack used to be on is available. In that 506* case found_good_drive will be on. If the first loop found nothing, 507* then found_good_drive will be on if the second loop found 508* a place to put the pack. For a non-demountable pack, 509* the second loop does not run, and we never set found_good_drive. */ 510 511 if found_good_drive 512 then do; 513 j = j - 1; /* both loops fall out of the bottom after do has bumped the index */ 514 /* dtep is ok */ 515 if mhvtest 516 then do; /* claim tbl spot */ 517 dte.pre_accepted = "1"b; 518 dte.demounted = "0"b; 519 dte.lvx = mhvtest_lvx; 520 dte.pvname = pvname; 521 end; 522 else do; /* assume for real */ 523 if dte.pre_accepted 524 then ec = 0; 525 else do; 526 call initializer_mdc_$assert (pvname, j, ec); 527 call copy_disk_table; 528 if ec ^= 0 529 then call print_error; 530 end; 531 if ec = 0 532 then call ioa_ ("mount pack ^a on ^a", dte.pvname, dte.drive_name); 533 end; 534 end; /* End of found_good_drive case */ 535 else if media_removable (pva (i).device_type) 536 then do; /* If we couldn't suggest a drive for a 451, its an error. */ 537 if mhvtest 538 then do; /* no drive avl */ 539 rc = 1; /* experiment failed */ 540 return; 541 end; 542 else call ioa_ ("disk_table_: no drive available for ^a of ^a", pvname, lvname); 543 end; 544 else do; /* its a fixed disk, so we report the problem and claim success. The site must have a home for it someplace */ 545 if mhvtest 546 then /* only mhvtest has an rc */ 547 rc = 0; 548 call ioa_ ("mount pack ^a.", pva (i).pvname); 549 end; 550 end; 551 return; 552 end MHV_ONE_PV; 553 554 end MHV; 555 556 557 /* ------------------------------------------------------- */ 558 559 get_dtp: 560 entry returns (ptr); 561 562 rce = "0"b; 563 call copy_disk_table (); 564 return (dtp); 565 566 /* -------------------------------------------------------- */ 567 568 569 set_lv_pdir_bit: 570 entry (a_lvname, a_bit, rc); 571 572 dcl a_bit bit (1) aligned parm; 573 574 rce = "1"b; 575 call initializer_mdc_$set_lv_pdir_bit (a_lvname, a_bit, rc); 576 call copy_disk_table (); 577 return; 578 579 580 /* -------------------------------------------------------- */ 581 582 583 set_vacate_pdirs_bit: 584 entry (a_lvname, a_bit, rc); 585 586 rce = "1"b; 587 call initializer_mdc_$set_vacate_pdirs_bit (a_lvname, a_bit, rc); 588 call copy_disk_table (); 589 return; 590 591 592 /* -------------------------------------------------------- */ 593 594 initialize_disk: 595 entry; 596 597 rce = "0"b; 598 call cu_$arg_list_ptr (arg_list_ptr); 599 call init_disk_pack_$parse_args (arg_list_ptr, drive_id, pvname1, copy_sw, rlv_sw, ec); 600 if ec ^= 0 601 then goto ret; 602 603 call parse_drive_id (drive_id); 604 605 if copy_sw 606 then pvname = ""; 607 else pvname = pvname1; 608 call verify_drive; /* Check drive not in use, pvname not is use, set ptrs */ 609 610 611 if copy_sw 612 then do; 613 do j = 1 to dt.n_entries 614 while ( 615 ^(dt.array (j).pvname = pvname1 & dt.array (j).storage_system 616 & (dt.array (j).used | dt.array (j).known | dt.array (j).pre_accepted))); 617 end; 618 if j > dt.n_entries 619 then do; 620 call ioa_ ("disk_table_: ^a not found.", pvname1); 621 return; 622 end; 623 dtep = addr (dt.array (j)); 624 end; 625 else do; 626 call initializer_mdc_$assert (pvname1, i, ec); 627 if ec = error_table_$unregistered_volume & rlv_sw 628 then do; /* rlv_sw will be on if operator supplied the "-rlv" 629* control to "init_vol" AND if we're running in 630* ring 1 AND we're in the midst of a cold boot. 631* We will automatically register the PV on the 632* root LV. This will allow the initial system 633* to have a multi pack RLV. 634* */ 635 fb71 = clock (); 636 pvinfo.pvid = substr (unspec (fb71), 36, 36); 637 pvinfo.model = dte.device_type; 638 /* will be stuck with this */ 639 pvinfo.pvname = pvname1; 640 pvinfo.location = drive_id; 641 pvinfo.mfg_serial = "registered at cold boot"; 642 pvinfo.date_registered = fb71; 643 pvinfo.password = ""b; /* register the PV */ 644 call volume_registration_mgr_$add_pvr ("root", addr (pvinfo), ec); 645 if ec ^= 0 646 then do; 647 call print_error; /* nothing we can do, must retry cold boot */ 648 return; 649 end; 650 call initializer_mdc_$assert (pvname1, i, ec); 651 /* try it again, with registration */ 652 end; 653 call copy_disk_table (); 654 if ec ^= 0 655 then do; 656 call print_error; 657 return; 658 end; 659 660 end; 661 call init_disk_pack_ (dtp, dtep, i, arg_list_ptr, ec); 662 return; 663 664 /* ------------------------------------------------------- */ 665 666 reregister: 667 entry; 668 669 rce = "0"b; 670 call cu_$level_get (level); 671 if level ^= 1 672 then do; 673 call ioa_ ("disk_table_: cannot reregister from ring 4"); 674 return; 675 end; 676 call cu_$arg_ptr (ARG1, ap, al, ec); 677 if ec ^= 0 678 then go to gruz; 679 pvname = bchr; 680 call cu_$arg_ptr (ARG2, ap, al, ec); 681 if ec ^= 0 682 then go to gruz; 683 call parse_drive_id (bchr); 684 call verify_drive; /* Check drive not in use */ 685 686 call mdx$reregister (pvname, i, ec); 687 if ec ^= 0 688 then if ec < 100 689 then call print_error; 690 else call com_err_ (ec, "disk_table_", "error reregistering ^a", drive_arg); 691 return; 692 693 /* -------------------------------------------------------- */ 694 695 demount_hvol: 696 entry; 697 dhv: 698 entry (a_lvname); 699 700 rce = "0"b; 701 call cu_$arg_ptr (ARG1, ap, al, ec); 702 if ec ^= 0 703 then go to gruz; 704 705 lvname = bchr; 706 707 call copy_disk_table (); 708 709 do j = 1 to dt.n_lv_entries while (^dt.lv_array (j).used | (dt.lv_array (j).lvname ^= lvname)); 710 end; 711 if j > dt.n_lv_entries 712 then do; 713 call com_err_ (0, "disk_table_", "lv ^a not found", lvname); 714 return; 715 end; 716 717 lvep = addr (dt.lv_array (j)); 718 719 if lve.mounting 720 then do; 721 call initializer_mdc_$demount_lv (j, STOP_MOUNT, ec); 722 call copy_disk_table (); 723 if ec ^= 0 724 then do; 725 call com_err_ (ec, "disk_table_", "cannot stop mount of ^a", lvname); 726 return; 727 end; 728 729 call lv_request_$dhv (lvname); 730 731 call copy_disk_table (); 732 733 if lve.demounting & lve.lvname = lvname /* potential interlock? */ 734 then call ioa_ ("disk_table_: demounting partially mounted volume ^a", lvname); 735 else do; 736 call ioa_ ("mount of ^a stopped", lvname); 737 return; 738 end; 739 end; 740 else if lve.demounting 741 then call ioa_ ("continuing demount of lv ^a", lvname); 742 else if ^lve.hv_mounted 743 then do; 744 call ioa_ ("lv ^a is not mounted", lvname); 745 return; 746 end; 747 else if lve.pdirs_ok 748 then do; 749 call ioa_ (" lv ^a may contain process directories. Will not be demounted.", lvname); 750 return; 751 end; 752 else do; 753 call lv_request_$dhv (lvname); 754 call initializer_mdc_$demount_lv (j, START_DEMOUNT, ec); 755 call copy_disk_table (); 756 if ec ^= 0 757 then do; 758 call com_err_ (ec, "disk_table_", "Cannot demount lv ^a.", lvname); 759 return; 760 end; 761 end; 762 763 demount_problem = "0"b; 764 765 do i = 1 to dt.n_entries; 766 dtep = addr (dt.array (i)); 767 if (dte.lvx = j) & dte.used & dte.storage_system 768 then do; 769 call initializer_mdc_$demount_pv (i, ec); 770 call copy_disk_table (); 771 if ec ^= 0 772 then do; 773 demount_problem = "1"b; 774 call com_err_ (ec, "disk_table_", "Could not demount pv ^a of lv ^a (^a)", dte.pvname, 775 lve.lvname, dte.drive_name); 776 end; 777 end; 778 end; 779 780 if demount_problem 781 then call com_err_ (0, "disk_table_", "Could not finish demount of lv ^a", lvname); 782 else do; 783 call initializer_mdc_$demount_lv (j, FINISH_DEMOUNT, ec); 784 call copy_disk_table (); 785 if ec ^= 0 786 then call com_err_ (ec, "disk_table_", "Could not finish demount of lv ^a", lvname); 787 else call ioa_ ("demounted lv ^a", lvname); 788 end; 789 return; 790 791 /* -------------------------------------------------------- */ 792 793 remove: 794 entry; 795 796 rce = "0"b; 797 call cu_$arg_ptr (1, ap, al, ec); 798 if ec ^= 0 799 then go to gruz; 800 if bchr = "-all" | bchr = "-a" 801 then do; 802 call copy_disk_table (); 803 do i = 1 to dt.n_entries; 804 dtep = addr (dt.array (i)); 805 if dte.storage_system & ^dte.deleted & ^dte.used & (dte.known | dte.pre_accepted) 806 then do; 807 call initializer_mdc_$forget (i, ec); 808 call copy_disk_table (); 809 end; 810 end; 811 return; 812 end; 813 call parse_drive_id (bchr); 814 815 call copy_disk_table (); 816 do i = 1 to dt.n_entries; 817 dtep = addr (dt.array (i)); 818 if dte.drive_name = drive_arg 819 then do; 820 if ^dte.storage_system 821 then call ioa_ ("disk_table_: ^a is an IO drive", drive_arg); 822 else if dte.deleted 823 then call ioa_ ("disk_table_: ^a is deleted", drive_arg); 824 else if dte.used 825 then call ioa_ ("disk_table_: ^a in use with ^a", drive_arg, dte.pvname); 826 else if dte.pre_accepted | dte.known 827 then do; 828 call initializer_mdc_$forget (i, ec); 829 call copy_disk_table (); 830 end; 831 else call ioa_ ("disk_table_: ^a not in use.", dte.drive_name); 832 return; 833 end; 834 end; 835 call ioa_ ("disk_table_: cannot locate ^a", drive_arg); 836 return; 837 838 /* ------------------------------------------------------- */ 839 840 io_ss_reconfig: 841 entry; 842 843 rce = "0"b; 844 call cu_$arg_ptr (ARG1, ap, al, ec); 845 if ec ^= 0 846 then go to gruz; 847 848 call parse_drive_id (bchr); 849 850 call cu_$arg_ptr (ARG2, ap, al, ec); 851 if ec ^= 0 852 then go to gruz; 853 854 if ^(bchr = "io" | bchr = "ss" | bchr = "storage_system") 855 then do; 856 call ioa_ ("disk_table_: ""^a"" is not ""io"", ""storage_system"", or ""ss"".", bchr); 857 return; 858 end; 859 860 call copy_disk_table; 861 do i = 1 to dt.n_entries while (substr (dt.array (i).drive_name, 1, 7) ^= drive_arg); 862 end; 863 if i > dt.n_entries 864 then do; 865 call ioa_ ("disk_table_: ^a not found.", drive_arg); 866 return; 867 end; 868 if dt.array (i).is_sub_vol 869 then do; 870 last_sv = (i + dt.array (i).num_of_sv) - 1; 871 end; 872 else do; 873 last_sv = i; 874 end; 875 876 do i = i to last_sv; 877 call initializer_mdc_$ss_io_reconfig (i, (substr (bchr, 1, 1) = "i"), ec); 878 call copy_disk_table (); 879 if ec ^= 0 880 then call com_err_ (ec, "disk_table_"); 881 end; 882 return; 883 884 /* --------------------------------------------------------- */ 885 886 list: 887 entry; 888 889 rce = "0"b; 890 lpv, llv, bfsw, ldrive = "0"b; 891 call cu_$arg_ptr (ARG1, ap, al, ec); 892 if ec = 0 893 then do; 894 if bchr = "-pv" 895 then do; 896 lpv = "1"b; 897 call cu_$arg_ptr (ARG2, ap, al, ec); 898 if ec ^= 0 899 then go to gruz; 900 arg = bchr; 901 end; 902 else if bchr = "-bf" | bchr = "-brief" 903 then bfsw = "1"b; 904 else if bchr = "-mounts" | bchr = "-mt" 905 then do; 906 call copy_disk_table; 907 go to list_hvols; 908 end; 909 else if bchr = "-lv" | bchr = "-hv" 910 then do; 911 llv = "1"b; 912 call cu_$arg_ptr (ARG2, ap, al, ec); 913 if ec ^= 0 914 then go to gruz; 915 arg = bchr; 916 end; 917 else do; 918 ldrive = "1"b; 919 call parse_drive_id (bchr); 920 end; 921 end; 922 923 call copy_disk_table (); 924 do i = 1 to dt.n_entries; 925 dtep = addr (dt.array (i)); 926 if ldrive & (dte.drive_name ^= drive_arg) 927 then go to skip; 928 lvep = addr (dt.lv_array (dte.lvx)); 929 if lve.hv_mounted 930 then lvname = lve.lvname; 931 else call ioa_$rsnnl ("(^a)", lvname, ignore_num, lve.lvname); 932 if ^dte.storage_system 933 then if dte.deleted 934 then if ldrive 935 then call ioa_ ("^a (deleted io drive)", dte.drive_name); 936 else ; 937 else call ioa_ ("^a (io drive)", dte.drive_name); 938 else if dte.deleted 939 then if ldrive 940 then call ioa_ ("^a deleted", drive_arg); 941 else ; 942 else do; 943 if lpv & (^(dte.used | (dte.known | dte.pre_accepted)) | (dte.pvname ^= arg)) 944 then go to skip; 945 if llv & ((^lve.used) | (lve.lvname ^= arg)) 946 then go to skip; 947 if dte.used 948 then call ioa_ ("^a ^8a ^8a", dte.drive_name, dte.pvname, lvname); 949 else if dte.known 950 then call ioa_ ("^a ^8a ^8a ***", dte.drive_name, dte.pvname, lvname); 951 else if dte.pre_accepted 952 then call ioa_ ("^a ^8a ^8a *", dte.drive_name, dte.pvname, lvname); 953 else if llv | bfsw 954 then go to skip; 955 else call ioa_ ("^a", dte.drive_name); 956 end; 957 skip: 958 end; 959 if llv | lpv | ldrive 960 then return; /* List out mounts and demounts in progresss */ 961 962 list_hvols: 963 do i = 1 to dt.n_lv_entries; 964 lvep = addr (dt.lv_array (i)); 965 if lve.public 966 then publicstr = "public"; 967 else publicstr = "private"; 968 if lve.mounting 969 then call ioa_ ("^7a lv ^a mount in progress", publicstr, lve.lvname); 970 if lve.demounting 971 then call ioa_ ("^7a lv ^a demount in progress", publicstr, lve.lvname); 972 end; 973 return; 974 975 /* --------------------------------------------------------------- */ 976 977 volsalv: 978 entry (a_pvname, a_drive, salv_opt_bits, rc); 979 980 rce = "1"b; 981 pvname = a_pvname; 982 ap = addr (a_drive); 983 al = length (a_drive); 984 rc = 1; 985 call parse_drive_id (bchr); 986 if salv_opts.check 987 then do; 988 call disk_table_$accept_rlv (ec); 989 if ec ^= 0 990 then do; 991 call copy_disk_table (); 992 go to ret; 993 end; 994 end; 995 996 call verify_drive; /* change args to dtx */ 997 998 call initializer_mdc_$volsalv (pvname, i, salv_opt_bits, ec); 999 call copy_disk_table (); 1000 if ec > 0 & ec < 100 1001 then do; 1002 call print_error; 1003 ec = error_table_$action_not_performed; 1004 end; 1005 rc = ec; 1006 return; 1007 1008 /* ------------------------------------------------------- */ 1009 1010 volsalvall: 1011 entry (salv_opt_bits, rc); 1012 1013 rce = "1"b; 1014 if salv_opts.check 1015 then do; 1016 call disk_table_$accept_rlv (ec); 1017 if ec ^= 0 1018 then do; 1019 call copy_disk_table (); 1020 go to ret; 1021 end; 1022 end; 1023 1024 call copy_disk_table (); 1025 1026 do i = 1 to dt.n_entries; 1027 dtep = addr (dt.array (i)); 1028 if ^dte.used 1029 then if dte.storage_system & ^dte.deleted & ^dte.used & (dte.known | dte.pre_accepted) 1030 then do; 1031 pvname = dte.pvname; 1032 call initializer_mdc_$volsalv (pvname, i, salv_opt_bits, ec); 1033 if ec ^= 0 1034 then if ec < 100 1035 then call print_error; 1036 else call com_err_ (ec, "disk_table_", "salvaging ^a on ^a", pvname, dte.drive_name); 1037 end; 1038 end; 1039 1040 call copy_disk_table (); 1041 1042 return; 1043 1044 /* -------------------------------------------------------------------- */ 1045 1046 volrlvcheck: 1047 entry (a_pvname, a_drive, a_copydrive, salv_opt_bits, rc); 1048 1049 dcl rbldsw bit (1) aternal static bit(1) initial array packed unaligned dcl 1-72 first_alt_sect_num internal static fixed bin(24,0) initial array dcl 1-130 first_dev_number internal static fixed bin(17,0) initial array dcl 1-69 first_rec_num internal static fixed bin(17,0) initial array dcl 1-115 first_sect_num internal static fixed bin(24,0) initial array dcl 1-124 last_alt_sect_num internal static fixed bin(24,0) initial array dcl 1-133 last_physical_sect_num internal static fixed bin(24,0) initial array dcl 1-136 last_rec_num internal static fixed bin(18,0) initial array dcl 1-118 last_sect_num internal static fixed bin(24,0) initial array dcl 1-127 last_sv_rec_num internal static fixed bin(18,0) initial array dcl 1-121 maxdevt internal static fixed bin(4,0) initial dcl 1-43 msu0400devt internal static fixed bin(4,0) initial dcl 1-43 msu0450devt internal static fixed bin(4,0) initial dcl 1-43 msu0451devt internal static fixed bin(4,0) initial dcl 1-43 msu0500devt internal static fixed bin(4,0) initial dcl 1-43 msu0501devt internal static fixed bin(4,0) initial dcl 1-43 needs_alt_part internal static bit(1) initial array packed unaligned dcl 1-81 number_of_sv internal static fixed bin(17,0) initial array dcl 1-93 pvrp automatic pointer dcl 5-12 rec_per_cyl internal static fixed bin(17,0) initial array dcl 1-108 rec_per_dev internal static fixed bin(21,0) initial array dcl 1-87 rec_per_sv internal static fixed bin(17,0) initial array dcl 1-90 sect_per_cyl internal static fixed bin(17,0) initial array dcl 2-15 sect_per_rec internal static fixed bin(17,0) initial array dcl 2-21 sect_per_sv internal static fixed bin(24,0) initial array dcl 2-18 sect_per_track internal static fixed bin(17,0) initial array dcl 2-33 sect_per_vtoc internal static fixed bin(17,0) initial array dcl 2-26 shared_spindle internal static bit(1) initial array packed unaligned dcl 1-78 tracks_per_cyl internal static fixed bin(17,0) initial array dcl 1-111 valid_sv_array internal static char(1) initial array packed unaligned dcl 1-99 volume_registration based structure level 1 dcl 5-14 vrp automatic pointer dcl 5-11 vtoc_per_rec internal static fixed bin(17,0) initial array dcl 2-29 words_per_sect internal static fixed bin(17,0) initial array dcl 2-36 NAMES DECLARED BY EXPLICIT CONTEXT. MHV 010366 constant entry internal dcl 426 ref 282 382 419 MHV_ONE_PV 010413 constant entry internal dcl 438 ref 434 accept 001561 constant entry external dcl 288 accept_all 001162 constant entry external dcl 195 accept_rlv 001467 constant entry external dcl 241 announce_mount 011674 constant entry i 007210 constant entry external dcl 1010 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 13012 13124 12254 13022 Length 13606 12254 112 445 535 2 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME disk_table_ 618 external procedure is an external procedure. list_missing_rlv_pvs internal procedure shares stack frame of external procedure disk_table_. MHV internal procedure shares stack frame of external procedure disk_table_. MHV_ONE_PV internal procedure shares stack frame of external procedure disk_table_. parse_drive_id internal procedure shares stack frame of external procedure disk_table_. verify_drive internal procedure shares stack frame of external procedure disk_table_. print_error internal procedure shares stack frame of external procedure disk_table_. copy_disk_table internal procedure shares stack frame of external procedure disk_table_. announce_mount internal procedure shares stack frame of external procedure disk_table_. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 sdtp disk_table_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME disk_table_ 000100 i disk_table_ 000101 j disk_table_ 000102 demount_problem disk_table_ 000103 took disk_table_ 000104 lpv disk_table_ 000105 llv disk_table_ 000106 bfsw disk_table_ 000107 ldrive disk_table_ 000110 copy_sw disk_table_ 000111 rlv_sw disk_table_ 000112 fb71 disk_table_ 000114 ap disk_table_ 000116 al disk_table_ 000120 pvap disk_table_ 000122 npv disk_table_ 000123 match_dtx disk_table_ 000124 trial disk_table_ 000125 mhvtest_lvx disk_table_ 000126 tpvtx disk_table_ 000127 last_sv disk_table_ 000130 pvname disk_table_ 000140 pvname1 disk_table_ 000150 lvname disk_table_ 000160 drive_arg disk_table_ 000162 publicstr disk_table_ 000165 drivea disk_table_ 000166 drive_id disk_table_ 000170 arg disk_table_ 000210 arg_list_ptr disk_table_ 000212 ignore_num disk_table_ 000213 ignore_ec disk_table_ 000214 ec disk_table_ 000215 new disk_table_ 000216 level disk_table_ 000220 pvinfo disk_table_ 000255 rce disk_table_ 000256 rbldsw disk_table_ 000260 seek_command disk_table_ 000262 dtp disk_table_ 000264 dtep disk_table_ 000266 lvep disk_table_ 000344 found MHV_ONE_PV 000345 found_good_drive MHV_ONE_PV 000356 id_len parse_drive_id THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as call_ext_in_desc call_ext_out_desc call_ext_out return_mac signal_op ext_entry ext_entry_desc clock_mac THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ cu_$arg_list_ptr cu_$arg_ptr cu_$level_get disk_rebuild_caller disk_table_$accept_all disk_table_$accept_rlv hcs_$make_seg init_disk_pack_ init_disk_pack_$parse_args initializer_mdc_$assert initializer_mdc_$demount_lv initializer_mdc_$demount_pv initializer_mdc_$forget initializer_mdc_$get_lv_pvinfo initializer_mdc_$init initializer_mdc_$mhv initializer_mdc_$read_disk_table initializer_mdc_$rlvolcheck initializer_mdc_$set_lv_pdir_bit initializer_mdc_$set_vacate_pdirs_bit initializer_mdc_$ss_io_reconfig initializer_mdc_$take initializer_mdc_$volsalv ioa_ ioa_$rsnnl lv_request_$dhv lv_request_$mhv_complete mdx$reregister volume_registration_mgr_$add_pvr THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$action_not_performed error_table_$unregistered_volume LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 1 84 000720 28 001011 178 001022 184 001041 185 001043 186 001056 188 001116 191 001146 195 001160 198 001175 199 001177 201 001200 202 001201 203 001211 204 001215 209 001231 210 001261 212 001264 214 001270 217 001304 218 001306 222 001320 225 001335 226 001337 227 001351 228 001352 229 001363 230 001374 232 001402 233 001405 234 001436 236 001450 237 001452 238 001453 241 001465 249 001502 250 001504 251 001505 252 001506 253 001530 254 001532 256 001533 258 001535 259 001541 260 001542 261 001543 263 001544 265 001546 288 001560 291 001571 292 001572 293 001607 295 001611 297 001623 298 001632 300 001644 301 001647 302 001664 304 001666 306 001714 309 001720 311 001732 312 001745 314 001746 315 001773 316 001774 318 002000 320 002013 323 002065 327 002077 331 002122 332 002123 333 002140 335 002142 336 002143 338 002155 339 002165 340 002176 342 002204 343 002217 345 002220 346 002222 348 002234 349 002237 350 002240 351 002270 353 002272 354 002326 356 002340 357 002341 358 002353 360 002356 361 002417 363 002431 365 002434 366 002472 368 002504 369 002517 370 002520 372 002522 373 002524 375 002536 377 002540 378 002544 382 002545 383 002553 387 002565 390 002612 391 002620 392 002622 393 002623 394 002653 396 002655 397 002656 400 002670 404 002671 406 002674 407 002721 408 002723 410 002727 411 002730 412 002740 413 002743 416 002746 417 002750 419 002764 420 002771 559 003003 562 003016 563 003017 564 003020 569 003034 574 003062 575 003064 576 003107 577 003110 583 003122 586 003145 587 003147 588 003172 589 003173 594 003205 597 003216 598 003217 599 003226 600 003262 603 003264 605 003267 607 003276 608 003301 611 003302 613 003305 617 003333 618 003335 620 003340 621 003360 623 003372 624 003376 626 003377 627 003420 635 003427 636 003431 637 003434 639 003440 640 003443 641 003446 642 003451 643 003453 644 003454 645 003501 647 003503 648 003504 650 003516 653 003537 654 003540 656 003542 657 003543 661 003555 662 003574 666 003606 669 003617 670 003620 671 003627 673 003632 674 003646 676 003660 677 003675 679 003677 680 003704 681 003721 683 003723 684 003736 686 003737 687 003760 690 003766 691 004026 695 004040 697 004051 700 004073 701 004074 702 004111 705 004113 707 004120 709 004121 710 004156 711 004160 713 004164 714 004223 717 004235 719 004245 721 004250 722 004263 723 004264 725 004266 726 004326 729 004340 731 004351 733 004352 736 004403 737 004423 739 004435 740 004436 742 004462 744 004465 745 004510 747 004522 749 004525 750 004545 753 004557 754 004570 755 004603 756 004604 758 004606 759 004646 763 004660 765 004661 766 004671 767 004675 769 004706 770 004717 771 004720 773 004722 774 004724 778 004772 780 004774 783 005035 784 005050 785 005051 787 005111 789 005132 793 005144 796 005155 797 005156 798 005175 800 005177 802 005211 803 005212 804 005221 805 005225 807 005236 808 005247 810 005250 811 005252 813 005264 815 005277 816 005300 817 005307 818 005313 820 005317 822 005343 824 005367 826 005417 828 005422 829 005433 830 005434 831 005435 832 005455 834 005467 835 005471 836 005511 840 005523 843 005534 844 005535 845 005552 848 005554 850 005567 851 005604 854 005606 856 005624 857 005647 860 005661 861 005662 862 005701 863 005703 865 005706 866 005726 868 005740 870 005746 871 005754 873 005755 876 005757 877 005765 878 006006 879 006007 881 006033 882 006035 886 006047 889 006060 890 006061 891 006065 892 006102 894 006104 896 006112 897 006114 898 006131 900 006133 901 006140 902 006141 904 006154 906 006164 907 006165 909 006166 911 006176 912 006200 913 006215 915 006217 916 006224 918 006225 919 006227 923 006242 924 006243 925 006253 926 006257 928 006265 929 006301 931 006310 932 006337 936 006373 937 006374 938 006416 941 006444 943 006445 945 006474 947 006506 949 006543 951 006577 953 006633 955 006637 957 006656 959 006660 962 006700 964 006711 965 006722 967 006731 968 006734 970 006763 972 007013 973 007015 977 007027 980 007064 981 007066 982 007074 983 007076 984 007100 985 007102 986 007114 988 007117 989 007126 991 007130 992 007131 996 007132 998 007133 999 007160 1000 007161 1002 007165 1003 007166 1005 007171 1006 007172 1010 007204 1013 007225 1014 007227 1016 007232 1017 007241 1019 007243 1020 007244 1024 007245 1026 007246 1027 007255 1028 007261 1031 007300 1032 007303 1033 007330 1036 007336 1038 007377 1040 007401 1042 007402 1046 007414 1051 007456 1052 007457 1054 007460 1057 007517 1059 007521 1061 007523 1062 007524 1063 007527 1064 007531 1065 007533 1066 007545 1067 007550 1068 007551 1069 007553 1072 007570 1073 007576 1074 007600 1075 007602 1076 007613 1077 007623 1079 007632 1081 007634 1082 007673 1083 007675 1084 007707 1086 007712 1089 007722 1091 007723 1092 007750 1094 007752 1095 007753 1099 007765 1100 007766 1102 007773 1105 010002 1106 010040 1109 010052 1110 010053 1112 010056 1113 010065 1115 010067 1116 010070 1119 010071 1121 010072 1123 010112 1124 010127 1127 010141 1130 010153 1131 010154 1132 010155 1133 010165 1134 010171 1137 010230 1138 010232 1883 010250 267 010251 270 010252 271 010253 273 010305 275 010307 278 010340 281 010341 282 010355 283 010365 426 010366 433 010377 434 010407 435 010410 436 010412 438 010413 444 010414 445 010423 446 010424 451 010425 452 010441 453 010445 456 010457 470 010465 472 010505 474 010507 477 010511 482 010533 483 010545 485 010551 500 010647 501 010651 511 010653 513 010655 515 010657 517 010663 518 010666 519 010670 520 010675 521 010700 523 010701 526 010707 527 010730 528 010731 531 010734 534 010766 535 010767 537 011000 539 011004 540 011006 542 011007 543 011034 545 011035 548 011042 551 011064 1140 011065 1146 011076 1147 011112 1149 011124 1151 011146 1152 011150 1154 011151 1156 011153 1157 011157 1159 011163 1160 011167 1162 011174 1164 011206 1166 011211 1170 011221 1172 011222 1175 011223 1176 011224 1177 011226 1178 011235 1179 011241 1181 011253 1182 011273 1183 011275 1185 011276 1187 011303 1188 011323 1189 011325 1191 011326 1193 011331 1195 011335 1196 011361 1197 011363 1199 011364 1201 011370 1202 011414 1203 011416 1206 011417 1207 011420 1209 011433 1210 011457 1211 011461 1213 011462 1215 011470 1217 011472 1219 011474 1220 011500 1221 011502 1223 011503 1224 011523 1225 011525 1228 011526 1230 011527 1232 011564 1234 011565 1240 011566 1241 011575 1244 011604 1246 011645 1247 011650 1249 011660 1251 011673 1253 011674 1258 011676 1259 011731 1262 011746 ----------------------------------------------------------- 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