COMPILATION LISTING OF SEGMENT dmpr_output_ Compiled by: Multics PL/I Compiler, Release 32f, of October 9, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 10/10/89 1419.4 mst Tue Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1988 * 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 13 14 15 /****^ HISTORY COMMENTS: 16* 1) change(88-10-05,GWMay), approve(88-10-05,MCR8005), audit(88-10-12,Farley), 17* install(88-10-17,MR12.2-1173): 18* Changed to output a unique string to delimit each set of system data 19* dumped. 20* END HISTORY COMMENTS */ 21 22 23 /* format: style1,ind2,^inddcls,ifthenstmt,dclind2,declareind2,ifthendo,ifthen*/ 24 dmpr_output_: proc; 25 26 /* This routine writes the objects that are being dumped through the specified switch. It controls 27* error recovery and volume attachment for the switch. Any object written is preceeded by logical header which 28* identifies its type and length and provides a unique pattern in case resynchronization is necessary. */ 29 30 /* 1) Modified: 12/17/81 by GA Texada to add a query in the attach proc to enable a clean exit. */ 31 /* and to fix phxXXXXX */ 32 /* 2) Modified: 7/15/82 by GA Texada to fix hardcore 372 (phx01702). */ 33 /* 3) Modified: 11/12/82 by GA Texada to implement phx14088, */ 34 /* implements preattach_(vols ioname) */ 35 /* 4) Modified: 1/26/83 to set dmpr_data_.cur_vol_open */ 36 /* 5) Modified: August 1983 by GA Texada to add new_pass_attach and end_pass_detach. */ 37 /* 6) Modified: April 1985 by SGH (UNCA) to fix preattach cleanup -- phx17367, 38* to complete fix for phx8938, and to synchronize output after 39* non-null objects */ 40 41 dcl dirname char (168); 42 dcl ename char (32); 43 dcl ldn fixed bin; 44 dcl current_length fixed bin; 45 dcl attach_name char (32); 46 dcl answer char (3) var; 47 dcl error_count fixed bin; 48 dcl prev_contentsp ptr; 49 dcl retry bit (1); 50 dcl new_tape bit (1); 51 dcl att_desc char (256); 52 dcl write_volume_log bit (1); 53 dcl code fixed bin (35); 54 dcl ignore fixed bin (35); 55 dcl datap ptr; 56 dcl (prex, sprex) fixed bin; 57 dcl pagex fixed bin; 58 dcl pagep ptr; 59 dcl page_of_chars char (CHARS_PER_PAGE) based (pagep) aligned; 60 dcl page_by_page bit (1); 61 dcl start_numeric fixed bin; 62 dcl char_num char (32); 63 dcl num fixed bin; 64 65 dcl myname char (32) int static init ("dmpr_output_") options (constant); 66 dcl max_error_count fixed bin int static options (constant) init (64); 67 dcl zero_char char (1) int static init ("") options (constant); 68 dcl ascii_type (3) char (4) int static init ("incr", "cons", "comp") options (constant); 69 dcl retry_explanation char (143) init ( 70 "The attachment of the dump volume has failed. 71 A ""yes"" answer will attempt to reattach the same volume. 72 A ""no"" answer will terminate the dump.") int static options (constant); 73 dcl delete_explanation char (148) init ( 74 "The open of the dump volume has failed. 75 A ""yes"" answer will delete the volume from the volume pool. 76 A ""no"" answer will leave the volume in the pool.") int static options (constant); 77 dcl continue_explanation char (141) init ( 78 "The open of the dump volume has failed. 79 A ""yes"" answer will continue the dump with a different volume. 80 A ""no"" answer will terminate the dump.") int static options (constant); 81 82 83 dcl 1 volid aligned, 84 2 char char (2) unaligned, 85 2 num fixed bin unaligned; 86 87 88 dcl 1 local_status_branch like status_branch aligned; 89 90 dcl command_query_ entry options (variable); 91 dcl continue_to_signal_ entry (fixed bin (35)); 92 dcl suffixed_name_$make entry (char (*), char (*), char (*), fixed bin (35)); 93 dcl manage_volume_pool_$reserve entry (ptr, entry options (variable), char (*), char (*), char (*), 94 fixed bin (35)); 95 dcl manage_volume_pool_$allocate entry (ptr, entry options (variable), char (*), char (*), char (*), 96 fixed bin (35)); 97 dcl manage_volume_pool_$free entry (ptr, entry options (variable), char (*), fixed bin (35)); 98 dcl manage_volume_pool_$delete entry (ptr, entry options (variable), char (*), fixed bin (35)); 99 dcl manage_volume_pool_$set_volid entry (ptr, entry options (variable), char (*), bit (36), fixed bin (35)); 100 dcl cv_dec_check_ entry (char (*), fixed bin (35)) returns (fixed bin); 101 dcl iox_$attach_ioname entry (char (*), ptr, char (*), fixed bin (35)); 102 dcl iox_$control entry (ptr, char (*), ptr, fixed bin (35)); 103 dcl iox_$modes entry (ptr, char (*), char (*), fixed bin (35)); 104 dcl iox_$open entry (ptr, fixed bin, bit (36), fixed bin (35)); 105 dcl iox_$put_chars entry (ptr, ptr, fixed bin, fixed bin (35)); 106 dcl iox_$close entry (ptr, fixed bin (35)); 107 dcl iox_$detach_iocb entry (ptr, fixed bin (35)); 108 dcl dmpr_output_$preattach_vols entry (fixed bin, fixed bin, fixed bin (35)); 109 dcl dmpr_output_$preattach_ioname entry (fixed bin, fixed bin, fixed bin (35)); 110 dcl dmpr_report_$error_output entry options (variable); 111 dcl dmpr_log_$init_account_file entry (fixed bin (35)); 112 dcl dmpr_log_$close_account_file entry (fixed bin (35)); 113 dcl dmpr_log_$open_volume_log entry (fixed bin (35)); 114 dcl dmpr_log_$close_volume_log entry (fixed bin (35)); 115 dcl dmpr_log_$init_contents_seg entry (fixed bin (35)); 116 dcl dmpr_log_$update_pvolog entry (fixed bin (35)); 117 dcl dmpr_log_$create_pvolog entry (char (*), fixed bin (35)); 118 dcl hcs_$delentry_seg entry (ptr, fixed bin (35)); 119 dcl hcs_$initiate entry (char (*), char (*), char (*), fixed bin, 120 fixed bin, ptr, fixed bin (35)); 121 dcl hcs_$terminate_seg entry (ptr, fixed bin, fixed bin (35)); 122 dcl hcs_$fs_get_path_name entry (ptr, char (*), fixed bin, char (*), fixed bin (35)); 123 dcl adjust_bit_count_ entry (char (*), char (*), bit (1), fixed bin, fixed bin (35)); 124 dcl hcs_$status_long entry (char (*), char (*), fixed bin, ptr, ptr, fixed bin (35)); 125 dcl dmpr_report_$online_output entry options (variable); 126 dcl ioa_$rsnnl entry options (variable); 127 dcl unique_bits_ entry () returns (bit (70)); 128 dcl tape_check bit (72); 129 dcl seg_fault_error condition; 130 dcl page_read_error condition; 131 dcl page_fault_error condition; 132 133 dcl error_table_$segfault ext fixed bin (35); 134 dcl error_table_$bad_volid ext fixed bin (35); 135 dcl error_table_$action_not_performed ext fixed bin (35); 136 dcl error_table_$device_end ext fixed bin (35); 137 dcl error_table_$end_of_info ext fixed bin (35); 138 dcl error_table_$fatal_error ext fixed bin (35); 139 dcl error_table_$undefined_order_request ext fixed bin (35); 140 dcl error_table_$no_operation ext fixed bin (35); 141 142 dcl (addr, substr, null, size, fixed, ptr, search, unspec, length, rtrim, clock) builtin; 143 dcl (before, bit, divide) builtin; 144 145 init: entry (code); 146 147 /* This entry initializes the output routine. It sets up the logical record header and attaches the 148* number of output volumes requested */ 149 150 dcl local_pre_attach_vol fixed bin; /* for use in preattaching volumes */ 151 152 code = 0; 153 write_volume_log = ""b; 154 query_info.version = query_info_version_5; 155 query_info.yes_or_no_sw = "1"b; 156 recordp = dmpr_data_.recordp; 157 backup_volume_record.version = backup_volume_record_version_2; 158 backup_volume_record.pattern1 = pattern1; 159 backup_volume_record.pattern2 = pattern2; 160 backup_volume_record.pattern3 = pattern3; 161 162 if dmpr_data_.pre_attach_vol > 0 then do; 163 local_pre_attach_vol = dmpr_data_.pre_attach_vol; 164 dmpr_data_.pre_attach_vol = 0; 165 call dmpr_output_$preattach_vols (local_pre_attach_vol, 1, code); 166 if code ^= 0 then return; 167 call dmpr_report_$online_output (0, dmpr_data_.myname, "Please get the following volumes: ^v(^a ^)", 168 local_pre_attach_vol, dmpr_data_.pre_attach_volname (*)); 169 dmpr_data_.pvlp = null; 170 dmpr_data_.volid = "0"b; 171 dmpr_data_.volname = ""; 172 call dmpr_output_$preattach_ioname (local_pre_attach_vol, 1, code); 173 if code ^= 0 then return; 174 dmpr_data_.pre_attach_vol = local_pre_attach_vol; 175 end; 176 call attach; 177 return; 178 179 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 180 181 new_pass_attach: entry (code); 182 183 write_volume_log = ""b; 184 call attach (); /* takes care of errors himself */ 185 return; 186 187 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 188 189 end_pass_detach: entry (code); 190 191 write_volume_log = ""b; 192 call detach (); 193 return; 194 195 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 196 197 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 198 199 200 output_object: entry (datap, code); 201 202 /* This entry writes the vtoce and the object , if one exists, on the attached switch. If the object has 203* pages of zeros it is written out in a compacted form. The output strategy is to write the object 204* untill the write succedes. Thus if an object spans a dump volume , it will be rewritten, in 205* its entirity on the new dump volume */ 206 207 code = 0; 208 write_volume_log = ""b; 209 query_info.version = query_info_version_5; 210 query_info.yes_or_no_sw = "1"b; 211 recordp = dmpr_data_.recordp; 212 bvlp = dmpr_data_.bvlp; 213 page_by_page = "0"b; 214 backup_volume_record.rec1_type = vtoce_type; 215 backup_volume_record.rec1_len = CHARS_PER_WORD * size (backup_volume_record); 216 217 if datap ^= null then do; 218 if backup_volume_record.dirsw then backup_volume_record.rec2_type = dir_type; 219 else backup_volume_record.rec2_type = seg_type; 220 if fixed (backup_volume_record.csl, 9) ^= fixed (backup_volume_record.records, 9) then do; 221 page_by_page = "1"b; 222 backup_volume_record.rec2_len = CHARS_PER_PAGE * fixed (backup_volume_record.records, 9); 223 end; 224 else if fixed (backup_volume_record.csl, 9) = 0 then backup_volume_record.rec2_len = 0; 225 else backup_volume_record.rec2_len = CHARS_PER_PAGE * (fixed (backup_volume_record.records, 9) - 1) 226 + CHARS_PER_WORD * last_page_length (); 227 end; 228 else do; 229 backup_volume_record.rec2_type = null_type; 230 backup_volume_record.rec2_len = 0; 231 end; 232 233 start_io: 234 retry = "1"b; 235 do while (retry); /* write the VTOCE for this seg/dir */ 236 call iox_$put_chars (dmpr_data_.outputvol_iocbp, recordp, 237 backup_volume_record.rec1_len, code); 238 call check_output_error; 239 end; 240 241 on seg_fault_error, page_fault_error begin; 242 if tape_check ^= ""b then do; 243 call iox_$put_chars (dmpr_data_.outputvol_iocbp, 244 addr (tape_check), size (tape_check) * CHARS_PER_WORD, code); 245 call check_output_error; 246 end; 247 call continue_to_signal_ (code); 248 end; 249 250 tape_check = ""b; /* write the data from this seg/dir */ 251 if backup_volume_record.rec2_len ^= 0 then do; 252 tape_check = dmpr_data_.volid || substr (unique_bits_ (), 35); 253 call iox_$put_chars (dmpr_data_.outputvol_iocbp, 254 addr (tape_check), size (tape_check) * CHARS_PER_WORD, code); 255 call check_output_error; 256 if new_tape then goto start_io; 257 258 if ^page_by_page then do; 259 retry = "1"b; 260 do while (retry); 261 call iox_$put_chars (dmpr_data_.outputvol_iocbp, datap, 262 backup_volume_record.rec2_len, code); 263 call check_output_error; 264 if new_tape then goto start_io; 265 end; 266 end; 267 else call page_by_page_write; 268 269 call iox_$put_chars (dmpr_data_.outputvol_iocbp, 270 addr (tape_check), size (tape_check) * CHARS_PER_WORD, code); 271 call check_output_error; 272 if new_tape then goto start_io; 273 tape_check = ""b; /* back to "" so it doesn't get written below */ 274 275 call iox_$control (dmpr_data_.outputvol_iocbp, "error_count", addr (error_count), code); /* force output synchronization */ 276 if ^(code = error_table_$undefined_order_request | code = error_table_$no_operation) then do; 277 if code = 0 then 278 if error_count > max_error_count then 279 code = error_table_$fatal_error; /* too many errors, abandon tape */ 280 call check_output_error; 281 if new_tape then goto start_io; 282 end; 283 end; 284 non_local_return: 285 if tape_check ^= ""b then do; 286 call iox_$put_chars (dmpr_data_.outputvol_iocbp, 287 addr (tape_check), size (tape_check) * CHARS_PER_WORD, code); 288 call check_output_error; 289 end; 290 291 return; 292 293 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 294 295 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 296 297 298 preattach_vols: 299 entry (nvols_to_get, begin_indx, mcode); 300 301 dcl (nvols_to_get, begin_indx) fixed bin, 302 mcode fixed bin (35), 303 safe_pvlp ptr, /* use to save the current values */ 304 safe_volname char (32), /* crucial variables from dmpr_data_ */ 305 safe_volid bit (36); /* when doing this routine */ 306 307 safe_volname = dmpr_data_.volname; 308 safe_volid = dmpr_data_.volid; 309 safe_pvlp = dmpr_data_.pvlp; 310 write_volume_log = ""b; 311 312 do prex = begin_indx to (dmpr_data_.pre_attach_vol + nvols_to_get); 313 call get_volname (mcode); 314 if mcode ^= 0 then goto restore_safe; 315 dmpr_data_.pre_attach_volname (prex) = dmpr_data_.volname; 316 dmpr_data_.pre_attach_volid (prex) = dmpr_data_.volid; 317 dmpr_data_.pre_attach_pvlp (prex) = dmpr_data_.pvlp; 318 end; 319 restore_safe: 320 dmpr_data_.volname = safe_volname; /* restore all these */ 321 dmpr_data_.volid = safe_volid; 322 dmpr_data_.pvlp = safe_pvlp; 323 return; 324 325 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 326 327 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 328 329 330 preattach_ioname: 331 entry (nvols_to_name, begin_indx, picode); 332 333 dcl nvols_to_name fixed bin, 334 picode fixed bin (35); 335 336 write_volume_log = ""b; 337 do prex = begin_indx to (dmpr_data_.pre_attach_vol + nvols_to_name); 338 call ioa_$rsnnl ("^a.^d", attach_name, (0), "dump_volume", prex); 339 if dmpr_data_.att_desc ^= "" then 340 call ioa_$rsnnl (dmpr_data_.att_desc, att_desc, (0), dmpr_data_.pre_attach_volname (prex)); 341 else call ioa_$rsnnl ("tape_mult_ ^a -write -system", att_desc, (0), dmpr_data_.pre_attach_volname (prex)); 342 dmpr_data_.io_module = before (att_desc, " "); 343 call iox_$attach_ioname (attach_name, dmpr_data_.pre_attach_iocbp (prex), att_desc, picode); 344 if picode ^= 0 then do; 345 call dmpr_report_$error_output (picode, myname, "Unable to attach ^a via desc ^a", attach_name, att_desc); 346 if (prex - begin_indx >= 1) then do; /* if I got at least one attached, fake 'em out */ 347 picode = 0; /* so we don't quit */ 348 sprex = prex - begin_indx; /* this is how many we have */ 349 end; 350 else sprex = 0; 351 do prex = prex to (dmpr_data_.pre_attach_vol + nvols_to_name); /* get rid of the pvolog segments for these */ 352 call hcs_$delentry_seg (dmpr_data_.pre_attach_pvlp (prex), ignore); 353 dmpr_data_.pre_attach_pvlp (prex) = null (); 354 if dmpr_data_.auto_vol then /* and free the volumes in the pool */ 355 call manage_volume_pool_$free (dmpr_data_.vpp, dmpr_report_$error_output, 356 (dmpr_data_.pre_attach_volname (prex)), ignore); 357 dmpr_data_.pre_attach_volname (prex) = ""; /* and clean up these... */ 358 dmpr_data_.pre_attach_volid (prex) = "0"b; 359 end; 360 nvols_to_name = sprex; /* now, tell him how many we really did */ 361 end; 362 end; 363 return; 364 365 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 366 367 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 368 369 370 write_volume_log: entry (code); 371 372 /* This entry writes a volume log on the attached switch. */ 373 374 code = 0; 375 query_info.version = query_info_version_5; 376 write_volume_log = "1"b; 377 recordp = dmpr_data_.recordp; 378 bvlp = dmpr_data_.bvlp; 379 380 381 call get_seg_current_length (bvlp); 382 if code ^= 0 then do; 383 call dmpr_report_$error_output (code, myname, "Unable to find length of volume log ^a.volog", dmpr_data_.pvname); 384 return; 385 end; 386 387 backup_volume_log.rec1_len = current_length * CHARS_PER_PAGE; 388 backup_volume_record.rec2_type = null_type; 389 backup_volume_record.rec2_len = 0; 390 backup_volume_log.time_dumped = substr (bit (fixed (clock, 52), 52), 1, 36); 391 392 /* vologs have the header builtin so 393* we don't write one. */ 394 /* Just write it as one big header */ 395 retry = "1"b; 396 do while (retry); 397 call iox_$put_chars (dmpr_data_.outputvol_iocbp, bvlp, backup_volume_log.rec1_len, code); 398 call check_output_error; 399 end; 400 401 402 return; 403 404 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 405 406 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 407 408 409 get_volname: proc (ec); 410 411 dcl volid bit (36); 412 dcl volname char (32); 413 dcl ec fixed bin (35); 414 415 416 /* This proc reads a dump volume name and converts it to a volume id. Volume names are restricted to two or less 417* acsii characters preceeding a numeric value(eg ic12345 is ok but inc12345 is not). It also creates an output log 418* for the dump volume in which all the physical volumes that are dumped on this dump volume will be recorded. 419* If the output log can not be created then it is assumed that the volume is alreay in use and another volume name 420* is requested. */ 421 422 request: volname = "*"; 423 if dmpr_data_.auto_vol then do; 424 get_vol: call manage_volume_pool_$reserve (dmpr_data_.vpp, dmpr_report_$error_output, volname, 425 ascii_type (dmpr_data_.dump_type), volname, ec); 426 if ec ^= 0 then do; 427 if volname ^= "*" & ec = error_table_$action_not_performed then do; 428 call dmpr_report_$online_output (0, myname, 429 "Pool volume ^a already allocated", volname); 430 return; /* let attach get us a new one */ 431 end; 432 if ec = error_table_$action_not_performed then ec = 0; 433 call dmpr_report_$online_output (ec, myname, 434 "Unable to get next dump volume name from dump volume pool"); 435 reread1: call get_volname_from_user (volname); 436 goto get_vol; /* add to volume pool */ 437 end; 438 call set_volid (volname, volid, ec); 439 if ec ^= 0 then do; 440 call dmpr_report_$online_output (ec, myname, "Invalid volume id ^a", 441 volname); 442 bad_volid: call manage_volume_pool_$free (dmpr_data_.vpp, dmpr_report_$error_output, 443 volname, ignore); 444 call manage_volume_pool_$delete (dmpr_data_.vpp, dmpr_report_$error_output, 445 volname, ignore); 446 goto request; 447 end; 448 call manage_volume_pool_$set_volid (dmpr_data_.vpp, dmpr_report_$error_output, 449 volname, volid, ec); 450 if ec ^= 0 then do; 451 call dmpr_report_$error_output (ec, dmpr_data_.myname, "Unable to set volid for ^a", 452 volname); 453 goto bad_volid; 454 end; 455 end; 456 else do; 457 reread2: call get_volname_from_user (volname); 458 call set_volid (volname, volid, ec); 459 if ec ^= 0 then do; 460 call dmpr_report_$online_output (ec, myname, "Invalid volume id ^a specified.", volname); 461 goto reread2; 462 end; 463 end; 464 call dmpr_log_$create_pvolog (volname, ec); 465 if ec ^= 0 then do; 466 call dmpr_report_$online_output (0, myname, 467 "Dump volume ^a still contains pertinent information", volname); 468 goto request; 469 end; 470 dmpr_data_.volid = volid; 471 dmpr_data_.volname = volname; 472 return; 473 end get_volname; 474 475 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 476 477 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 478 479 480 attach: proc; 481 482 /* This proc attaches an output volume through the specified attach description and opens it. 483* It then create a contents segment and an account sgment for this volume. It then attempts to determine the previous 484* dump volume of this type and write its contents segment on the just attached dump volume. Finally it 485* updates the prev output log to reflect this dump volume is now the previous dump volume. 486* A return code of a -1 will indicate that the dump should be aborted by Operator request. */ 487 488 489 490 dmpr_data_.cur_vol_open = "0"b; 491 retry_attach: 492 if dmpr_data_.pre_attach_vol > 0 then do; 493 dmpr_data_.vol_idx = dmpr_data_.vol_idx + 1; 494 if dmpr_data_.vol_idx > dmpr_data_.pre_attach_vol then do; 495 dmpr_data_.pre_attach_vol, dmpr_data_.vol_idx = 0; 496 goto non_pre_attach; /* turn it off */ 497 end; 498 dmpr_data_.volname = dmpr_data_.pre_attach_volname (dmpr_data_.vol_idx); 499 dmpr_data_.volid = dmpr_data_.pre_attach_volid (dmpr_data_.vol_idx); 500 dmpr_data_.outputvol_iocbp = dmpr_data_.pre_attach_iocbp (dmpr_data_.vol_idx); 501 dmpr_data_.pvlp = dmpr_data_.pre_attach_pvlp (dmpr_data_.vol_idx); 502 end; 503 else do; 504 non_pre_attach: 505 call get_volname (code); 506 if code ^= 0 then return; 507 508 if dmpr_data_.att_desc ^= "" then 509 call ioa_$rsnnl (dmpr_data_.att_desc, att_desc, (0), dmpr_data_.volname); 510 else call ioa_$rsnnl ("tape_mult_ ^a -write -system", att_desc, (0), dmpr_data_.volname); 511 dmpr_data_.io_module = before (att_desc, " "); 512 reattach: call iox_$attach_ioname ("dump_volume", dmpr_data_.outputvol_iocbp, att_desc, code); 513 if code ^= 0 then do; 514 call dmpr_report_$error_output (code, myname, "Unable to attach dump volume ^a.", 515 dmpr_data_.volname); 516 query_info.explanation_ptr = addr (retry_explanation); 517 query_info.explanation_len = length (retry_explanation); 518 call command_query_ (addr (query_info), answer, myname, "^/Do you wish to re-try the attachment?"); 519 520 query_info.explanation_ptr = null (); /* because its used elsewhere */ 521 query_info.explanation_len = 0; /* and we dont want to confuse anyone */ 522 if answer = "yes" then goto reattach; 523 else do; 524 call hcs_$delentry_seg (dmpr_data_.pvlp, ignore); 525 call hcs_$terminate_seg (dmpr_data_.pvlp, 0, ignore); 526 dmpr_data_.pvlp = null (); 527 if dmpr_data_.auto_vol then 528 call manage_volume_pool_$free (dmpr_data_.vpp, dmpr_report_$error_output, 529 (dmpr_data_.volname), ignore); 530 code = -1; /* flag for dumper */ 531 return; 532 end; 533 end; 534 end; 535 if dmpr_data_.auto_vol then do; 536 call manage_volume_pool_$allocate (dmpr_data_.vpp, dmpr_report_$error_output, (dmpr_data_.volname), 537 ascii_type (dmpr_data_.dump_type), 538 (dmpr_data_.volname), code); 539 if code ^= 0 then do; 540 call dmpr_report_$error_output (code, myname, "Unable to mark ^a allocated in volume pool", 541 dmpr_data_.volname); 542 call hcs_$delentry_seg (dmpr_data_.pvlp, ignore); 543 call hcs_$terminate_seg (dmpr_data_.pvlp, 0, ignore); 544 dmpr_data_.pvlp = null (); 545 call iox_$detach_iocb (dmpr_data_.outputvol_iocbp, (0)); 546 goto retry_attach; 547 end; 548 end; 549 call iox_$open (dmpr_data_.outputvol_iocbp, Stream_output, "0"b, code); 550 if code ^= 0 then do; 551 call dmpr_report_$error_output (code, myname, "Error on opening dump volume ^a", 552 dmpr_data_.volname); 553 call iox_$detach_iocb (dmpr_data_.outputvol_iocbp, ignore); 554 call hcs_$delentry_seg (dmpr_data_.pvlp, ignore); 555 call hcs_$terminate_seg (dmpr_data_.pvlp, 0, ignore); 556 dmpr_data_.pvlp = null (); 557 if dmpr_data_.auto_vol then do; 558 call manage_volume_pool_$free (dmpr_data_.vpp, dmpr_report_$error_output, 559 (dmpr_data_.volname), ignore); 560 if dmpr_data_.pre_attach_vol > 0 then goto retry_attach; /* presumably, there isn't anyone to answer our questions so,*/ 561 562 query_info.explanation_ptr = addr (delete_explanation); 563 query_info.explanation_len = length (delete_explanation); 564 call command_query_ (addr (query_info), answer, myname, "^/^a^/^a", 565 "The open operation has failed.", 566 "Do you wish to delete the volume from the pool? "); 567 if answer = "yes" then 568 call manage_volume_pool_$delete (dmpr_data_.vpp, dmpr_report_$error_output, 569 (dmpr_data_.volname), ignore); 570 query_info.explanation_ptr = addr (continue_explanation); 571 query_info.explanation_len = length (continue_explanation); 572 call command_query_ (addr (query_info), answer, myname, "^/Do you wish to continue the dump?"); 573 query_info.explanation_ptr = null (); 574 query_info.explanation_len = 0; 575 if answer = "yes" then ; 576 else do; 577 code = -1; /* Operator aborted the dump */ 578 return; 579 end; 580 end; 581 goto retry_attach; 582 end; 583 call iox_$modes (dmpr_data_.outputvol_iocbp, "async", (""), (0)); 584 /* run asynchronously */ 585 dmpr_data_.cur_vol_open = "1"b; /* ok, good open */ 586 call dmpr_log_$init_contents_seg (code); 587 if code ^= 0 then do; 588 call dmpr_report_$error_output (code, myname, "Contents seg init failure"); 589 return; 590 end; 591 592 if dmpr_data_.accounting then do; 593 call dmpr_log_$init_account_file (code); 594 if code ^= 0 then do; 595 call dmpr_report_$error_output (code, myname, "Account file init failure"); 596 return; 597 end; 598 end; 599 600 infop = dmpr_data_.infop; 601 backup_info.rec2_type = null_type; 602 backup_info.rec2_len = 0; 603 backup_info.dump_volname = dmpr_data_.volname; 604 backup_info.dump_volid = dmpr_data_.volid; 605 backup_info.time_dumped = substr (bit (fixed (clock, 52), 52), 1, 36); 606 retry = "1"b; 607 do while (retry); 608 call iox_$put_chars (dmpr_data_.outputvol_iocbp, infop, backup_info.rec1_len, code); 609 call check_output_error; 610 end; 611 612 if dmpr_data_.prev_volname = "" then do; 613 call dmpr_report_$error_output (0, dmpr_data_.myname, 614 "Previous dump volume not known. Contents segment not written to new dump volume"); 615 goto update_prev; 616 end; 617 call suffixed_name_$make ((dmpr_data_.prev_volname), "contents", ename, code); 618 if code ^= 0 then goto prev_err; 619 620 call hcs_$initiate (rtrim (dmpr_data_.sys_dir) || ">contents", ename, "", 0, 1, prev_contentsp, code); 621 if prev_contentsp = null then do; 622 prev_err: call dmpr_report_$error_output (code, myname, 623 "Unable to locate contents seg ^a", ename); 624 goto update_prev; 625 end; 626 627 call get_seg_current_length (prev_contentsp); 628 if code ^= 0 then do; 629 call dmpr_report_$error_output (code, myname, 630 "Unable to determine length of previous contents file"); 631 goto update_prev; 632 end; 633 prev_contentsp -> backup_volume_contents.rec1_len = CHARS_PER_PAGE * current_length; 634 prev_contentsp -> backup_volume_contents.rec2_type = null_type; 635 prev_contentsp -> backup_volume_contents.rec2_len = 0; 636 prev_contentsp -> backup_volume_contents.time_dumped = substr (bit (fixed (clock, 52), 52), 1, 36); 637 retry = "1"b; 638 do while (retry); 639 call iox_$put_chars (dmpr_data_.outputvol_iocbp, prev_contentsp, 640 prev_contentsp -> backup_volume_contents.rec1_len, code); 641 call check_output_error; 642 end; 643 644 update_prev: 645 dmpr_data_.prev_volname = dmpr_data_.volname; 646 647 if dmpr_data_.bvlp ^= null then do; 648 if ^write_volume_log then call dmpr_log_$open_volume_log (code); 649 if code ^= 0 then 650 call dmpr_report_$error_output (code, myname, "Unable to open ^a.volog", dmpr_data_.pvname); 651 end; 652 653 dmpr_data_.not_reported = "1"b; 654 dmpr_data_.dump_volume_seg_num = 0; 655 dmpr_data_.dump_volume_seg_rec = 0; 656 dmpr_data_.dump_volume_dir_num = 0; 657 dmpr_data_.dump_volume_dir_rec = 0; 658 659 end attach; 660 661 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 662 663 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 664 665 666 detach: proc; 667 668 /* This proc closes out the use of a dump volume. It does this by closing the account segment and terminating the 669* account and contents segment. It then closes and detachs the dump volume. */ 670 671 if dmpr_data_.accounting then do; 672 call dmpr_log_$close_account_file (code); 673 if code ^= 0 then 674 call dmpr_report_$error_output (code, myname, "Unable to close account seg"); 675 end; 676 call setbc_term (dmpr_data_.contentsp); 677 call setbc_term (dmpr_data_.pvlp); 678 call iox_$close (dmpr_data_.outputvol_iocbp, code); 679 if code ^= 0 then 680 call dmpr_report_$error_output (code, myname, "Unable to close dump volume ^a", dmpr_data_.volname); 681 call iox_$detach_iocb (dmpr_data_.outputvol_iocbp, code); 682 if code ^= 0 then 683 call dmpr_report_$error_output (code, myname, "Unable to detach dump volume ^a", dmpr_data_.volname); ; 684 dmpr_data_.outputvol_iocbp = null; /* be sure */ 685 call dmpr_report_$online_output (0, myname, 686 "Finished ^a: ^d ^d ^d ^d", dmpr_data_.volname, 687 dmpr_data_.dump_volume_dir_rec, dmpr_data_.dump_volume_dir_num, dmpr_data_.dump_volume_seg_rec, 688 dmpr_data_.dump_volume_seg_num); 689 dmpr_data_.not_reported = "0"b; 690 if ^write_volume_log then call dmpr_log_$close_volume_log (code); 691 if code ^= 0 then 692 call dmpr_report_$error_output (code, myname, 693 "Unable to close ^a.volog", dmpr_data_.volname); 694 695 dmpr_data_.dump_volume_seg_num = 0; 696 dmpr_data_.dump_volume_seg_rec = 0; 697 dmpr_data_.dump_volume_dir_num = 0; 698 dmpr_data_.dump_volume_dir_rec = 0; 699 end detach; 700 701 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 702 703 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 704 705 706 check_output_error: proc; 707 708 /* This proc checks the error code retrurned from a write operation. If no error then it returns to its caller. 709* If the dump volume is used up(end of reel/no more room) it closes the volume log, resets the counters associated with 710* the dump volume and detachs the dump volume. It then atttaches a new dump volume, opens the same volume log, but 711* for a new dump volume, and requests the caller to retry the write operation. For any other kind of error it is 712* reported but the action is the same */ 713 714 715 new_tape, retry = "0"b; 716 if code = 0 then return; 717 continue_error_check: /* if segfault err return to caller - data pointer is no good */ 718 if code = error_table_$segfault then goto non_local_return; 719 if ^(code = error_table_$device_end | code = error_table_$end_of_info) then do; 720 if code = error_table_$fatal_error then /* Special case too many recoverable errors for *proper* message*/ 721 call dmpr_report_$error_output (0, myname, "The threshold for recoverable write errors (^d) has been reached. 722 Output to volume ^a will be terminated to minimize possible problems in later attempts to read it.", 723 max_error_count, dmpr_data_.volname); 724 else call dmpr_report_$error_output (code, myname, "Error on output volume ^a", dmpr_data_.volname); 725 end; 726 call detach; 727 call attach; 728 if code ^= 0 then goto non_local_return; 729 if ^write_volume_log then 730 call dmpr_log_$update_pvolog (code); 731 if code ^= 0 then do; 732 call dmpr_report_$error_output (code, myname, "Unable to update ^a.pvolog", dmpr_data_.volname); 733 goto non_local_return; 734 end; 735 new_tape = "1"b; 736 retry = "1"b; 737 return; 738 739 end check_output_error; 740 741 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 742 743 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 744 745 746 get_seg_current_length: proc (segp); 747 748 /* This proc calculates the length of the segment specified by segptr and returns the value in a global variable */ 749 750 dcl segp ptr; 751 call hcs_$fs_get_path_name (segp, dirname, ldn, ename, code); 752 if code ^= 0 then do; 753 call dmpr_report_$error_output (code, myname, "Unable to convert ptr to path-name"); 754 return; 755 end; 756 757 call hcs_$status_long (dirname, ename, 1, addr (local_status_branch), null, code); 758 if code ^= 0 then do; 759 call dmpr_report_$error_output (code, myname, "Unable to get current length of ^a>^a", dirname, ename); 760 return; 761 end; 762 763 current_length = local_status_branch.current_length; 764 765 end get_seg_current_length; 766 767 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 768 769 770 page_by_page_write: proc; 771 772 /* This proc is use to write out a data object which has whole pages of zeros intermixed with non-zero pages. 773* This is done to reduce the output load. To do this the file map contained in the vtoce is scanned and 774* only non-null pages are written. If we switch to a new volume then we start from the beginning again. */ 775 776 do pagex = 0 to fixed (backup_volume_record.csl, 9) - 1; 777 if ^substr (backup_volume_record.fm (pagex), 1, 1) then do; 778 pagep = ptr (datap, pagex * WORDS_PER_PAGE); 779 retry = "1"b; 780 do while (retry); 781 call iox_$put_chars (dmpr_data_.outputvol_iocbp, pagep, fixed (CHARS_PER_PAGE, 21), code); 782 call check_output_error; 783 if new_tape then goto start_io; 784 end; 785 end; 786 end; 787 return; 788 end page_by_page_write; 789 790 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 791 792 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 793 794 795 set_volid: proc (a_volname, a_volid, code); 796 dcl a_volname char (*); 797 dcl a_volid bit (36); 798 dcl code fixed bin (35); 799 800 /* This proc constructs a volume id from a volume name. This is a interim measure until all dump volume are registered 801* and have a unique id. This construction restricts the volume name to two or less non numeric characters followed 802* by any numeric value lest then 262144. */ 803 804 /* when rcp_ interface is defined 805* call rcp_$volname_info (volname, dmpr_data_.volid, code); 806* if code ^= 0 then 807* call dmpr_report_$error_output (code, myname, "Unable to set volid"); 808* 809* but until then fudge it */ 810 811 812 start_numeric = search (a_volname, "0123456789"); 813 if start_numeric > 3 | start_numeric = 0 then do; 814 bad_volid: code = error_table_$bad_volid; 815 return; 816 end; 817 else do; 818 if start_numeric > 1 then volid.char = substr (a_volname, 1, start_numeric - 1); 819 else volid.char = ""; 820 char_num = substr (a_volname, start_numeric, length (a_volname) - start_numeric); 821 num = cv_dec_check_ (char_num, code); 822 if code ^= 0 then goto bad_volid; 823 volid.num = num; 824 end; 825 a_volid = unspec (volid); 826 return; 827 end set_volid; 828 829 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 830 831 832 get_volname_from_user: proc (a_volname); 833 dcl a_volname char (*); 834 dcl avolname char (32) var; 835 /* query_info is already set up */ 836 query_info.yes_or_no_sw = "0"b; /* except for this */ 837 rq: call command_query_ (addr (query_info), avolname, myname, "Type output volume name:"); 838 if avolname ^= "" then do; 839 a_volname = avolname; 840 query_info.yes_or_no_sw = "1"b; /* back to my "normal" state */ 841 end; 842 else goto rq; 843 844 end get_volname_from_user; 845 846 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 847 848 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 849 850 851 last_page_length: proc returns (fixed bin); 852 853 /* This proc back scans the last page of an object for the first non-zero character and returns the 854* length of the non-zero page in words. The condition handler is established in case we share the segment with an 855* other user who deletes/resets the ACL. */ 856 857 858 on seg_fault_error, page_read_error begin; 859 code = error_table_$segfault; 860 goto non_local_return; 861 end; 862 pagep = ptr (datap, (fixed (backup_volume_record.csl, 9) - 1) * WORDS_PER_PAGE); 863 return (divide (length (rtrim (page_of_chars, zero_char)) + 3, CHARS_PER_WORD, 17, 0)); 864 end last_page_length; 865 866 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 867 868 869 setbc_term: proc (p); 870 871 /* This proc terminates the specified segment and sets the ptr to it to null */ 872 873 dcl p ptr; 874 dcl dn char (168); 875 dcl en char (32); 876 dcl ldn fixed bin; 877 call hcs_$fs_get_path_name (p, dn, ldn, en, ignore); 878 call adjust_bit_count_ (dn, en, "0"b, (0), ignore); 879 call hcs_$terminate_seg (p, 0, ignore); 880 p = null; 881 882 end setbc_term; 883 884 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 885 1 1 /* BEGIN INCLUDE FILE ... dmpr_data_.incl.pl1 Feb 1976 */ 1 2 /* format: style1,ind2,^inddcls,ifthenstmt,dclind2,declareind2,ifthendo,ifthen*/ 1 3 /* Modified 7/79 by D. Vinograd to add new variables and change to based structure */ 1 4 /* Modified: 1/26/83 by GA Texada to add cur_vol_open and change version to 2. */ 1 5 /* Modified: 04/05/83 by GA Texada to add trace switch to support tracing. */ 1 6 /* Modified 04/84 by GA Texada to change to version 3 (disk_type). This begins the adding of new items */ 1 7 /* to the END of the structure to facilite easy additions. */ 1 8 dcl dmprp ptr ext static init (null); 1 9 dcl dmpr_data_version_2 fixed bin int static init (2) options (constant); 1 10 dcl dmpr_data_version_3 fixed bin int static init (3) options (constant); 1 11 /* Version 3 is current */ 1 12 1 13 dcl 1 dmpr_data_ aligned based (dmprp), 1 14 2 version fixed bin, /* version */ 1 15 2 lock bit (36), /* inter-lock */ 1 16 2 ptrs, 1 17 3 pre_attach_pvlp (50) ptr, /* array of pvolog ptrs */ 1 18 3 contents_namesp ptr, /* ptr to contents name seg */ 1 19 3 pre_attach_iocbp (50) ptr, /* array of output iocbp */ 1 20 3 pvlp ptr, /* ptr to dump volume log */ 1 21 3 account_iocbp ptr, /* iocbp for account seg */ 1 22 3 infop ptr, /* ptr to info seg */ 1 23 3 inputp ptr, /* ptr to input storage for sup interface */ 1 24 3 recordp ptr, /* ditto for output */ 1 25 3 control_iocbp ptr, /* iocbp for dump control segment */ 1 26 3 error_iocbp ptr, /* iocbp for error output file */ 1 27 3 outputvol_iocbp ptr, /* iocbp for dump volume */ 1 28 3 contentsp ptr, /* ptr to dump volume table of contents */ 1 29 3 bvlp ptr, /* ptr to volume log */ 1 30 3 dirp ptr, /* ptr to directory buffer seg */ 1 31 3 segp ptr, /* ptr to segment to be dumped */ 1 32 3 fcbp ptr, /* ptr to file control block for contents_name msf */ 1 33 3 vpp ptr, /* ptr to volume pool */ 1 34 2 fixed_bin, 1 35 3 retrys fixed bin, /* number of time segment disappeared while being dumped */ 1 36 3 physical_volume_dir_num fixed bin, /* number of dirs dumped from this physical volume */ 1 37 3 physical_volume_dir_rec fixed bin, /* number of dir records on this physical volume */ 1 38 3 physical_volume_seg_num fixed bin, /* number of segs dumped from this physical volume */ 1 39 3 physical_volume_seg_rec fixed bin, /* number of seg records dumped from this physical volume */ 1 40 3 vol_log_dir_num fixed bin, /* dirs dumped from pvol to dump vol */ 1 41 3 vol_log_dir_rec fixed bin, /* dir rec on this pvol to dump vol */ 1 42 3 vol_log_seg_num fixed bin, /* segs dumped from pvol to dump vol */ 1 43 3 vol_log_seg_rec fixed bin, /* seg rec dumped from pvol to dump vol */ 1 44 3 dump_volume_dir_num fixed bin, /* number of dirs dumped on this dump volume */ 1 45 3 dump_volume_dir_rec fixed bin, /* number of dir records on this dump volume */ 1 46 3 dump_volume_seg_num fixed bin, /* number of segs dumped on this dump volume */ 1 47 3 dump_volume_seg_rec fixed bin, /* number of seg records dumped on this dump volume */ 1 48 3 num_null_vtoce fixed bin, /* number of null vtoce dumped from this physical volume */ 1 49 3 num_vtoce_only fixed bin, /* number of vtoce only */ 1 50 3 mod_after_time fixed bin (71), /* dump all modified since this date */ 1 51 3 dump_type fixed bin, /* type of dump */ 1 52 3 save_time fixed bin (71), /* date, time of start of dump */ 1 53 3 start_time fixed bin (71), /* start time of physical volume pass */ 1 54 3 wakeup_interval fixed bin (71), /* interval between wakeups of dumper in micro secs. */ 1 55 3 incr_ev_chn fixed bin (71), /* event chn used to wakeup incremental dumper */ 1 56 3 incr_skip_count fixed bin, /* number of incr cycles skiped befor purging */ 1 57 3 pre_attach_vol fixed bin, /* if greater then 1 then pre attach output streams */ 1 58 3 vol_idx fixed bin, /* index of multi volume attachment sequence */ 1 59 3 component fixed bin, /* msf component of contents_name seg */ 1 60 2 bits, 1 61 3 volid bit (36), /* uid of dump volume */ 1 62 3 pre_attach_volid (50) bit (36), /* array of volid */ 1 63 3 cycle_uid bit (36), /* uid of this dump cycle */ 1 64 3 pvid bit (36), /* uid of physical volume being dumped */ 1 65 3 flags, 1 66 ( 4 purge bit (1), /* if on purge volume logs */ 1 67 4 auto_vol bit (1), /* if on use automatic dump volume selection */ 1 68 4 disable_error_report bit (1), /* if on disables error reporting */ 1 69 4 arg_init bit (1), /* if on indicates args have been processed */ 1 70 4 manual_free bit (1), /* on if manual free will be done */ 1 71 4 err_online bit (1), /* Flag error output to be online, default to a file */ 1 72 4 detach bit (1), /* if on control detachment of dump volume */ 1 73 4 no_object bit (1), /* if on not copy object from ring 0 */ 1 74 4 no_update bit (1), /* if on prevent vtoce update */ 1 75 4 data_init bit (1), /* if on indicates that data structure has been initialized */ 1 76 4 reset bit (1), /* if on put items back on list */ 1 77 4 accounting bit (1), /* if on enables accounting */ 1 78 4 dmpr_asleep bit (1), /* dumper is asleep - interlock to prevent restart of last volume */ 1 79 4 dump_in_progress bit (1), /* recursive entry interlock */ 1 80 4 not_reported bit (1), /* on if output counts not reported */ 1 81 4 names bit (1), /* collect all names from dirs that are dumped */ 1 82 4 cur_vol_open bit (1), /* if a successful open on this volname */ 1 83 4 trace bit (1), /* ON => trace */ 1 84 4 pad bit (18)) unal, /* fill out the word properly */ 1 85 3 old_256K_switch bit(2) aligned, /* 256K segs enabled prior to this dumper invocation?*/ 1 86 3 rpv_pvid bit (36), /* because the label really doesn't have it */ 1 87 2 chars, 1 88 3 sys_dir char (168), /* system directory where all volume dumper data lives */ 1 89 3 prev_volname char (32), 1 90 3 pre_attach_volname (50) char (32), /* array of volnames */ 1 91 3 io_module char (32), /* name of attached outer module for output io */ 1 92 3 pvname char (32), /* name of physical volume being dumped */ 1 93 3 att_desc char (256), /* attach description for output */ 1 94 3 volname char (32), /* name of dump volume */ 1 95 3 control_name char (32), /* dump control file name */ 1 96 3 myname char (32), /* name of entry called */ 1 97 3 operator char (32), /* operator name */ 1 98 3 restart_pvname char (32), /* where to restart complete or consolidated dump */ 1 99 3 lvname char (32), /* name of logical volume being dumped */ 1 100 2 disk_type fixed bin; /* disk type for recording in the volog */ 1 101 1 102 1 103 /* END OF INCLUDE FILE ... dmpr_data_.incl.pl1 */ 886 887 2 1 /* BEGIN INCLUDE FILE ... backup_info.incl.pl1 ... June 1976 */ 2 2 2 3 dcl infop ptr; /* ptr to structure */ 2 4 2 5 dcl backup_info_version_2 fixed bin static init (2) options (constant); /* version number */ 2 6 2 7 dcl 1 backup_info based (infop) aligned, 2 8 2 header like backup_volume_header aligned, 2 9 2 version fixed bin, /* version number */ 2 10 2 rpv_pvid bit (36), /* pvid of rpv */ 2 11 2 rpv_lvid bit (36), /* lvid of rpv */ 2 12 2 rpv_disk_type fixed bin, /* disk model index of rpv */ 2 13 2 dump_volid bit (36), /* dump volume id */ 2 14 2 pad bit (36), 2 15 2 dump_type fixed bin, /* type of dump */ 2 16 2 dump_volname char (32), /* volname of dump volume */ 2 17 2 system_id char (32), /* system identifier */ 2 18 2 control_file char (168), /* path name of dump control file */ 2 19 2 operator char (32); /* operator who started dump */ 2 20 2 21 /* END INCLUDE FILE ... backup_info.incl.pl1 */ 888 889 3 1 /* BEGIN INCLUDE FILE backup_volume_contents.incl.pl1 ... May 1976 */ 3 2 3 3 3 4 3 5 /****^ HISTORY COMMENTS: 3 6* 1) change(86-11-10,GWMay), approve(86-11-10,MCR7445), audit(86-11-19,GDixon), 3 7* install(86-11-21,MR12.0-1223): 3 8* increased the size of the offset field to fixed bin (18). 3 9* END HISTORY COMMENTS */ 3 10 3 11 3 12 dcl contentsp ptr; /* ptr to structure */ 3 13 3 14 dcl backup_volume_contents_version_3 fixed bin static init (3) options (constant); 3 15 3 16 3 17 dcl 1 v1_backup_volume_contents based (contentsp) aligned, 3 18 2 header like backup_volume_header aligned, 3 19 2 version fixed bin, /* version number of structure */ 3 20 2 volname char (32), /* volume name */ 3 21 2 volid bit (36), /* volume id */ 3 22 2 next fixed bin, /* index of next available slot in uid array */ 3 23 2 array (1: 1 refer (backup_volume_contents.next)), /* array of arrays of data objects on this output volume */ 3 24 3 uid bit (36); /* uid */ 3 25 3 26 dcl 1 v2_backup_volume_contents based (contentsp) aligned, 3 27 2 header like backup_volume_header aligned, 3 28 2 version fixed bin, /* version number of structure */ 3 29 2 volname char (32), /* volume name */ 3 30 2 volid bit (36), /* volume id */ 3 31 2 next fixed bin, /* index of next available slot in uid array */ 3 32 2 pad (10) bit (36), 3 33 2 array (1: 1 refer (backup_volume_contents.next)), /* array of arrays of data objects on this output volume */ 3 34 3 uid bit (36), /* uid */ 3 35 3 location, /* offset of name string */ 3 36 4 component fixed bin (17) unal, 3 37 4 offset fixed bin (17) unal ; 3 38 3 39 dcl 1 backup_volume_contents based (contentsp) aligned, 3 40 2 header like backup_volume_header aligned, 3 41 2 version fixed bin, /* version number of structure */ 3 42 2 volname char (32), /* volume name */ 3 43 2 volid bit (36), /* volume id */ 3 44 2 next fixed bin, /* index of next available slot in uid array */ 3 45 2 pad (10) bit (36), 3 46 2 array (1: 1 refer (backup_volume_contents.next)), /* array of arrays of data objects on this output volume */ 3 47 3 uid bit (36), /* uid */ 3 48 3 tape_loc fixed bin (35), 3 49 3 pad1 bit (36), 3 50 3 location, /* offset of name string */ 3 51 4 component fixed bin (18) unsigned unal, 3 52 4 offset fixed bin (18) unsigned unal ; 3 53 3 54 dcl contents_namesp ptr; /* ptr to optional name seg */ 3 55 3 56 dcl 1 backup_volume_contents_names based (contents_namesp) aligned, 3 57 2 version fixed bin, 3 58 2 offset fixed bin (18), /* next free location */ 3 59 2 pad (6) bit (36), 3 60 2 begin bit (36); 3 61 3 62 3 63 /* END INCLUDE FILE backup_volume_contents.incl.pl1 */ 890 891 4 1 /* BEGIN INCLUDE FILE ... backup_volume_header ... Feb 1976 */ 4 2 4 3 dcl hdp ptr; /* ptr to header */ 4 4 4 5 dcl 1 backup_volume_header based (hdp) aligned, 4 6 2 pattern1 bit (36), /* unique word 1 */ 4 7 2 rec1_type fixed bin, /* record 1 type */ 4 8 2 rec1_len fixed bin, /* length in chars */ 4 9 2 pattern2 bit (36), /* unique word 2 */ 4 10 2 rec2_type fixed bin, /* record 2 type */ 4 11 2 rec2_len fixed bin, /* length in chars */ 4 12 2 pattern3 bit (36), /* unique word 3 */ 4 13 2 time_dumped bit (36); /* dump time of this record */ 4 14 4 15 dcl vtoce_type fixed bin static init (1) options (constant); /* type code for vtoce */ 4 16 dcl dir_type fixed bin static init (2) options (constant); /* type code for directory */ 4 17 dcl seg_type fixed bin static init (3) options (constant); /* type code for segment */ 4 18 dcl null_type fixed bin static init (4) options (constant); /* type code for null record */ 4 19 dcl volume_log_type fixed bin static init (5) options (constant); /* type code for volume log */ 4 20 dcl prev_output_log_type fixed bin static init (6) options (constant); /* type code for prev output log */ 4 21 dcl contents_type fixed bin static init (7) options (constant); /* type code for contents segment of previous volume */ 4 22 dcl info_type fixed bin static init (8) options (constant); /* type code for info structure */ 4 23 4 24 dcl pattern1 bit (36) int static init ("110111000011001100011101101010100101"b) options (constant); 4 25 dcl pattern2 bit (36) int static init ("101001010101101110001100110000111011"b) options (constant); 4 26 dcl pattern3 bit (36) int static init ("001000111100110011100010010101011010"b) options (constant); 4 27 4 28 /* END INCLUDE FILE ... backup_volume_header */ 892 5 1 /* BEGIN INCLUDE FILE ... backup_volume_record.incl.pl1 ... March 1976 */ 5 2 5 3 5 4 5 5 /****^ HISTORY COMMENTS: 5 6* 1) change(88-10-05,GWMay), approve(88-10-05,MCR8005), audit(88-10-12,Farley), 5 7* install(88-10-17,MR12.2-1173): 5 8* Added a version 2 constant 5 9* END HISTORY COMMENTS */ 5 10 5 11 5 12 dcl recordp ptr; 5 13 5 14 dcl backup_volume_record_version_1 fixed bin static init (1) options (constant); 5 15 dcl backup_volume_record_version_2 fixed bin static init (2) options (constant); 5 16 5 17 dcl 1 backup_volume_record based (recordp) aligned, 5 18 2 header like backup_volume_header aligned, 5 19 2 version fixed bin, /* version number of structure */ 5 20 2 pvid bit (36), /* physical volume id */ 5 21 2 vtocx fixed bin, /* vtoc index of returned vtoc entry */ 5 22 2 vtoce like vtoce aligned; /* vtoc entry */ 5 23 5 24 /* END INCLUDE FILE ... backup_volume_record.incl.pl1 */ 893 894 6 1 /* BEGIN INCLUDE FILE ...vtoce.incl.pl1 ... last modified September 1982 */ 6 2 /* Template for a VTOC entry. Length = 192 words. (3 * 64). */ 6 3 /* NOTE: vtoc_man clears pad fields before writing a vtoce. */ 6 4 6 5 dcl vtocep ptr; 6 6 6 7 dcl 1 vtoce based (vtocep) aligned, 6 8 6 9 6 10 (2 pad_free_vtoce_chain bit (36), /* Used to be pointer to next free VTOCE */ 6 11 6 12 2 uid bit (36), /* segment's uid - zero if vtoce is free */ 6 13 6 14 2 msl bit (9), /* maximum segment length in 1024 word units */ 6 15 2 csl bit (9), /* current segment length - in 1024 word units */ 6 16 2 records bit (9), /* number of records used by the seg in second storage */ 6 17 2 pad2 bit (9), 6 18 6 19 2 dtu bit (36), /* date and time segment was last used */ 6 20 6 21 2 dtm bit (36), /* date and time segment was last modified */ 6 22 6 23 2 nqsw bit (1), /* no quota switch - no checking for pages of this seg */ 6 24 2 deciduous bit (1), /* true if hc_sdw */ 6 25 2 nid bit (1), /* no incremental dump switch */ 6 26 2 dnzp bit (1), /* Dont null zero pages */ 6 27 2 gtpd bit (1), /* Global transparent paging device */ 6 28 2 per_process bit (1), /* Per process segment (deleted every bootload) */ 6 29 2 damaged bit (1), /* TRUE if contents damaged */ 6 30 2 fm_damaged bit (1), /* TRUE if filemap checksum bad */ 6 31 2 fm_checksum_valid bit (1), /* TRUE if the checksum has been computed */ 6 32 2 synchronized bit (1), /* TRUE if this is a data management synchronized segment */ 6 33 2 pad3 bit (8), 6 34 2 dirsw bit (1), /* directory switch */ 6 35 2 master_dir bit (1), /* master directory - a root for the logical volume */ 6 36 2 pad4 bit (16)) unaligned, /* not used */ 6 37 6 38 2 fm_checksum bit (36) aligned, /* Checksum of used portion of file map */ 6 39 6 40 (2 quota (0:1) fixed bin (18) unsigned, /* sec storage quota - (0) for non dir pages */ 6 41 6 42 2 used (0:1) fixed bin (18) unsigned, /* sec storage used - (0) for non dir pages */ 6 43 6 44 2 received (0:1) fixed bin (18) unsigned, /* total amount of storage this dir has received */ 6 45 6 46 2 trp (0:1) fixed bin (71), /* time record product - (0) for non dir pages */ 6 47 6 48 2 trp_time (0:1) bit (36), /* time time_record_product was last calculated */ 6 49 6 50 6 51 6 52 6 53 6 54 2 fm (0:255) bit (18), /* file map - 256 entries - 18 bits per entry */ 6 55 6 56 2 pad6 (10) bit (36), /* not used */ 6 57 6 58 2 ncd bit (1), /* no complete dump switch */ 6 59 2 pad7 bit (17), 6 60 2 pad8 bit (18), 6 61 6 62 2 dtd bit (36), /* date-time-dumped */ 6 63 6 64 2 volid (3) bit (36), /* volume ids of last incremental, consolidated, and complete dumps */ 6 65 6 66 2 master_dir_uid bit (36), /* superior master directory uid */ 6 67 6 68 6 69 6 70 6 71 2 uid_path (0:15) bit (36), /* uid pathname of all parents starting after the root */ 6 72 6 73 2 primary_name char (32), /* primary name of the segment */ 6 74 6 75 2 time_created bit (36), /* time the segment was created */ 6 76 6 77 2 par_pvid bit (36), /* physical volume id of the parent */ 6 78 6 79 2 par_vtocx fixed bin (17), /* vtoc entry index of the parent */ 6 80 2 branch_rp bit (18)) unaligned, /* rel pointer of the branch of this segment */ 6 81 6 82 2 cn_salv_time bit (36), /* time branch - vtoce connection checked */ 6 83 6 84 2 access_class bit (72), /* access class in branch */ 6 85 2 perm_flags aligned, 6 86 3 per_bootload bit (1) unal, /* ON => deleted each bootload */ 6 87 3 pad9 bit (35) unal, 6 88 2 owner bit (36); /* pvid of this volume */ 6 89 6 90 dcl vtoce_parts (3) bit (36 * 64) aligned based (vtocep); 6 91 6 92 dcl 1 seg_vtoce based (vtocep) aligned, /* Overlay for vtoce of segments, which don't have quota */ 6 93 2 pad1 bit (7*36), 6 94 2 usage fixed bin (35), /* page fault count: overlays quota */ 6 95 2 pad2 bit (184*36); 6 96 6 97 /* END INCLUDE FILE vtoce.incl.pl1 */ 895 896 7 1 /* BEGIN INCLUDE FILE ... backup_volume_log.incl.pl1 ... Feb 1976 */ 7 2 7 3 7 4 /****^ HISTORY COMMENTS: 7 5* 1) change(88-03-03,GWMay), approve(89-10-03,MCR8135), 7 6* audit(89-10-04,Beattie), install(89-10-10,MR12.3-1089): 7 7* Added values for storing the number of incremental and consolidated dump 7 8* sets to retain in the volume log. Incremented version number to 3. 7 9* END HISTORY COMMENTS */ 7 10 7 11 7 12 /* Modified: 3/7/84 by GA Texada to change to version 2 */ 7 13 dcl bvlp ptr; 7 14 dcl bvlep ptr; 7 15 7 16 dcl backup_volume_log_version_1 fixed bin static init (1) options (constant); 7 17 dcl backup_volume_log_version_2 fixed bin init(2) int static options(constant); 7 18 dcl backup_volume_log_version_3 fixed bin init(3) int static options(constant); 7 19 7 20 dcl 1 backup_volume_log based (bvlp) aligned, 7 21 2 header like backup_volume_header aligned, 7 22 2 info like backup_pvol_info aligned, 7 23 2 version fixed bin, /* version number */ 7 24 2 lock bit (36), /* shared data base */ 7 25 2 pvname char (32), /* physical volume name */ 7 26 2 pvid bit (36), /* physical volume id */ 7 27 2 next fixed bin, /* next available dump record */ 7 28 2 reload_groups fixed bin, /* number of reload groups in log */ 7 29 2 purge_control (3), /* control selective purging by dump type */ 7 30 3 group (36) bit (1) unaligned, /* up to 36 reload groups */ 7 31 2 disk_type fixed bin unal, /* type of disk drive */ 7 32 2 half_word_pad bit(18) unal, /* MBZ */ 7 33 2 rpv_pvid bit(36), /* pvid of this volumes RPV */ 7 34 2 Nsaved_incr_sets fixed bin, /* number of incr cycles to retain */ 7 35 2 Nsaved_cons_sets fixed bin, /* number of incr cycles to retain */ 7 36 2 pad (31) bit (36), /* for future expansion (MBZ) */ 7 37 2 array (1:1 refer (backup_volume_log.next)) like bvle aligned; 7 38 7 39 dcl 1 bvle based (bvlep) aligned, 7 40 2 cycle_uid bit (36), /* uid of this dump cycle */ 7 41 2 dump_type fixed bin, /* type of dump */ 7 42 2 volname char (32), /* name of output volume */ 7 43 2 open_time fixed bin (71), /* opening time of dump pass on this physical volume */ 7 44 2 close_time fixed bin (71), /* ending time of dump pass */ 7 45 2 volid bit (36), /* uid of output volume */ 7 46 2 io_module char (32), /* outer module name that wrote this volume */ 7 47 2 flags, /* flags */ 7 48 3 purge_scan_logged bit (1) unaligned, /* if on object looged during purge scan */ 7 49 3 pad1 bit (35) unaligned, 7 50 2 pad (7) bit (36), /* for future expansion */ 7 51 (2 dir_num fixed bin, /* number of dirs dumped on this pass */ 7 52 2 dir_rec fixed bin, /* number of records of dirs */ 7 53 2 seg_num fixed bin, /* number of segs dumped on this pass */ 7 54 2 seg_rec fixed bin) unaligned; /* number of records of segs */ 7 55 7 56 /* END INCLUDE FILE ... backup_volume_log */ 897 8 1 /* BEGIN INCLUDE FILE ... backup_pvol_info.incl.pl1 */ 8 2 8 3 dcl bpvip ptr; 8 4 8 5 dcl 1 backup_pvol_info based (bpvip) aligned, 8 6 2 label like label aligned, 8 7 2 n_vtoce fixed bin, 8 8 2 n_free_vtoce fixed bin, 8 9 2 n_rec fixed bin, 8 10 2 baseadd fixed bin, 8 11 2 n_free_rec fixed bin; 8 12 8 13 /* END INCLUDE FILE ... backup_pvol_info.incl.pl1 */ 898 899 9 1 /* BEGIN INCLUDE FILE ... fs_vol_label.incl.pl1 .. last modified January 1982 for new volume map format */ 9 2 9 3 /****^ HISTORY COMMENTS: 9 4* 1) change(86-04-10,Fawcett), approve(86-04-10,MCR7383), 9 5* audit(86-05-12,Coppola), install(86-07-18,MR12.0-1098): 9 6* Add the subvolume info. 9 7* 2) change(88-05-27,GWMay), approve(88-05-27,MCR7883), 9 8* audit(88-06-14,Beattie), install(88-07-19,MR12.2-1061): 9 9* Added inconsistent_dbm bit used to determine consistency of volume 9 10* dumper bit maps. 9 11* END HISTORY COMMENTS */ 9 12 9 13 /* This is the label at fixed location of each physical volume. Length 1 page */ 9 14 /* Note: fsout_vol clears pad fields before writing the label */ 9 15 9 16 dcl labelp ptr; 9 17 9 18 dcl 1 label based (labelp) aligned, 9 19 9 20 /* First comes data not used by Multics.. for compatibility with GCOS */ 9 21 9 22 2 gcos (5*64) fixed bin, 9 23 9 24 /* Now we have the Multics label */ 9 25 9 26 2 Multics char (32) init ("Multics Storage System Volume"), /* Identifier */ 9 27 2 version fixed bin, /* Version 1 */ 9 28 2 mfg_serial char (32), /* Manufacturer's serial number */ 9 29 2 pv_name char (32), /* Physical volume name. */ 9 30 2 lv_name char (32), /* Name of logical volume for pack */ 9 31 2 pvid bit (36), /* Unique ID of this pack */ 9 32 2 lvid bit (36), /* unique ID of its logical vol */ 9 33 2 root_pvid bit (36), /* unique ID of the pack containing the root. everybody must agree. */ 9 34 2 time_registered fixed bin (71), /* time imported to system */ 9 35 2 n_pv_in_lv fixed bin, /* # phys volumes in logical */ 9 36 2 vol_size fixed bin, /* total size of volume, in records */ 9 37 2 vtoc_size fixed bin, /* number of recs in fixed area + vtoc */ 9 38 2 not_used bit (1) unal, /* used to be multiple_class */ 9 39 2 private bit (1) unal, /* TRUE if was registered as private */ 9 40 2 inconsistent_dbm bit (1) unal, /* TRUE if ESD-less crash */ 9 41 2 flagpad bit (33) unal, 9 42 2 max_access_class bit (72), /* Maximum access class for stuff on volume */ 9 43 2 min_access_class bit (72), /* Minimum access class for stuff on volume */ 9 44 2 password bit (72), /* not yet used */ 9 45 2 number_of_sv fixed bin, /* if = 0 not a subvolume else the number of svs */ 9 46 2 this_sv fixed bin, /* what subvolume number it is */ 9 47 2 sub_vol_name char (1), /* what subvolume name (a b c d) it is */ 9 48 2 pad1 (13) fixed bin, 9 49 2 time_mounted fixed bin (71), /* time mounted */ 9 50 2 time_map_updated fixed bin (71), /* time vmap known good */ 9 51 9 52 /* The next two words overlay time_unmounted on pre-MR10 systems. This 9 53* forces a salvage if an MR10 pack is mounted on an earlier system. 9 54* */ 9 55 2 volmap_version fixed bin, /* version of volume map (currently 1) */ 9 56 2 pad6 fixed bin, 9 57 9 58 2 time_salvaged fixed bin (71), /* time salvaged */ 9 59 2 time_of_boot fixed bin (71), /* time of last bootload */ 9 60 2 time_unmounted fixed bin (71), /* time unmounted cleanly */ 9 61 2 last_pvtx fixed bin, /* pvtx in that PDMAP */ 9 62 2 pad1a (2) fixed bin, 9 63 2 err_hist_size fixed bin, /* size of pack error history */ 9 64 2 time_last_dmp (3) fixed bin (71), /* time last completed dump pass started */ 9 65 2 time_last_reloaded fixed bin (71), /* what it says */ 9 66 2 pad2 (40) fixed bin, 9 67 2 root, 9 68 3 here bit (1), /* TRUE if the root is on this pack */ 9 69 3 root_vtocx fixed bin (35), /* VTOC index of root, if it is here */ 9 70 3 shutdown_state fixed bin, /* Status of hierarchy */ 9 71 3 pad7 bit (1) aligned, 9 72 3 disk_table_vtocx fixed bin, /* VTOC index of disk table on RPV */ 9 73 3 disk_table_uid bit (36) aligned, /* UID of disk table */ 9 74 3 esd_state fixed bin, /* State of esd */ 9 75 2 volmap_record fixed bin, /* Begin record of volume map */ 9 76 2 size_of_volmap fixed bin, /* Number of records in volume map */ 9 77 2 vtoc_map_record fixed bin, /* Begin record of VTOC map */ 9 78 2 size_of_vtoc_map fixed bin, /* Number of records in VTOC map */ 9 79 2 volmap_unit_size fixed bin, /* Number of words per volume map section */ 9 80 2 vtoc_origin_record fixed bin, /* Begin record of VTOC */ 9 81 2 dumper_bit_map_record fixed bin, /* Begin record of dumper bit-map */ 9 82 2 vol_trouble_count fixed bin, /* Count of inconsistencies found since salvage */ 9 83 2 pad3 (52) fixed bin, 9 84 2 nparts fixed bin, /* Number of special partitions on pack */ 9 85 2 parts (47), 9 86 3 part char (4), /* Name of partition */ 9 87 3 frec fixed bin, /* First record */ 9 88 3 nrec fixed bin, /* Number of records */ 9 89 3 pad5 fixed bin, 9 90 2 pad4 (5*64) fixed bin; 9 91 9 92 dcl Multics_ID_String char (32) init ("Multics Storage System Volume") static; 9 93 9 94 /* END INCLUDE FILE fs_vol_label.incl.pl1 */ 900 901 10 1 /* Begin include file ..... iox_modes.incl.pl1 */ 10 2 10 3 /* Written by C. D. Tavares, 03/17/75 */ 10 4 /* Updated 10/31/77 by CDT to include short iox mode strings */ 10 5 10 6 dcl iox_modes (13) char (24) int static options (constant) aligned initial 10 7 ("stream_input", "stream_output", "stream_input_output", 10 8 "sequential_input", "sequential_output", "sequential_input_output", "sequential_update", 10 9 "keyed_sequential_input", "keyed_sequential_output", "keyed_sequential_update", 10 10 "direct_input", "direct_output", "direct_update"); 10 11 10 12 dcl short_iox_modes (13) char (4) int static options (constant) aligned initial 10 13 ("si", "so", "sio", "sqi", "sqo", "sqio", "squ", "ksqi", "ksqo", "ksqu", "di", "do", "du"); 10 14 10 15 dcl (Stream_input initial (1), 10 16 Stream_output initial (2), 10 17 Stream_input_output initial (3), 10 18 Sequential_input initial (4), 10 19 Sequential_output initial (5), 10 20 Sequential_input_output initial (6), 10 21 Sequential_update initial (7), 10 22 Keyed_sequential_input initial (8), 10 23 Keyed_sequential_output initial (9), 10 24 Keyed_sequential_update initial (10), 10 25 Direct_input initial (11), 10 26 Direct_output initial (12), 10 27 Direct_update initial (13)) fixed bin int static options (constant); 10 28 10 29 /* End include file ..... iox_modes.incl.pl1 */ 902 903 11 1 /* --------------- BEGIN include file status_structures.incl.pl1 --------------- */ 11 2 11 3 /* Revised from existing include files 09/26/78 by C. D. Tavares */ 11 4 11 5 /* This include file contains branch and link structures returned by 11 6* hcs_$status_ and hcs_$status_long. */ 11 7 11 8 dcl 1 status_branch aligned based (status_ptr), 11 9 2 short aligned, 11 10 3 type fixed bin (2) unaligned unsigned, /* seg, dir, or link */ 11 11 3 nnames fixed bin (16) unaligned unsigned, /* number of names */ 11 12 3 names_relp bit (18) unaligned, /* see entry_names dcl */ 11 13 3 dtcm bit (36) unaligned, /* date/time contents last modified */ 11 14 3 dtu bit (36) unaligned, /* date/time last used */ 11 15 3 mode bit (5) unaligned, /* caller's effective access */ 11 16 3 raw_mode bit (5) unaligned, /* caller's raw "rew" modes */ 11 17 3 pad1 bit (8) unaligned, 11 18 3 records_used fixed bin (18) unaligned unsigned, /* number of NONZERO pages used */ 11 19 11 20 /* Limit of information returned by hcs_$status_ */ 11 21 11 22 2 long aligned, 11 23 3 dtd bit (36) unaligned, /* date/time last dumped */ 11 24 3 dtem bit (36) unaligned, /* date/time branch last modified */ 11 25 3 lvid bit (36) unaligned, /* logical volume ID */ 11 26 3 current_length fixed bin (12) unaligned unsigned, /* number of last page used */ 11 27 3 bit_count fixed bin (24) unaligned unsigned, /* reported length in bits */ 11 28 3 pad2 bit (8) unaligned, 11 29 3 copy_switch bit (1) unaligned, /* copy switch */ 11 30 3 tpd_switch bit (1) unaligned, /* transparent to paging device switch */ 11 31 3 mdir_switch bit (1) unaligned, /* is a master dir */ 11 32 3 damaged_switch bit (1) unaligned, /* salvager warned of possible damage */ 11 33 3 synchronized_switch bit (1) unaligned, /* DM synchronized file */ 11 34 3 pad3 bit (5) unaligned, 11 35 3 ring_brackets (0:2) fixed bin (6) unaligned unsigned, 11 36 3 uid bit (36) unaligned; /* unique ID */ 11 37 11 38 dcl 1 status_link aligned based (status_ptr), 11 39 2 type fixed bin (2) unaligned unsigned, /* as above */ 11 40 2 nnames fixed bin (16) unaligned unsigned, 11 41 2 names_relp bit (18) unaligned, 11 42 2 dtem bit (36) unaligned, 11 43 2 dtd bit (36) unaligned, 11 44 2 pathname_length fixed bin (17) unaligned, /* see pathname */ 11 45 2 pathname_relp bit (18) unaligned; /* see pathname */ 11 46 11 47 dcl status_entry_names (status_branch.nnames) character (32) aligned 11 48 based (pointer (status_area_ptr, status_branch.names_relp)), 11 49 /* array of names returned */ 11 50 status_pathname character (status_link.pathname_length) aligned 11 51 based (pointer (status_area_ptr, status_link.pathname_relp)), 11 52 /* link target path */ 11 53 status_area_ptr pointer, 11 54 status_ptr pointer; 11 55 11 56 dcl (Link initial (0), 11 57 Segment initial (1), 11 58 Directory initial (2)) fixed bin internal static options (constant); 11 59 /* values for type fields declared above */ 11 60 11 61 /* ---------------- END include file status_structures.incl.pl1 ---------------- */ 904 905 12 1 /* BEGIN INCLUDE FILE query_info.incl.pl1 TAC June 1, 1973 */ 12 2 /* Renamed to query_info.incl.pl1 and cp_escape_control added, 08/10/78 WOS */ 12 3 /* version number changed to 4, 08/10/78 WOS */ 12 4 /* Version 5 adds explanation_(ptr len) 05/08/81 S. Herbst */ 12 5 /* Version 6 adds literal_sw, prompt_after_explanation switch 12/15/82 S. Herbst */ 12 6 12 7 dcl 1 query_info aligned, /* argument structure for command_query_ call */ 12 8 2 version fixed bin, /* version of this structure - must be set, see below */ 12 9 2 switches aligned, /* various bit switch values */ 12 10 3 yes_or_no_sw bit (1) unaligned init ("0"b), /* not a yes-or-no question, by default */ 12 11 3 suppress_name_sw bit (1) unaligned init ("0"b), /* do not suppress command name */ 12 12 3 cp_escape_control bit (2) unaligned init ("00"b), /* obey static default value */ 12 13 /* "01" -> invalid, "10" -> don't allow, "11" -> allow */ 12 14 3 suppress_spacing bit (1) unaligned init ("0"b), /* whether to print extra spacing */ 12 15 3 literal_sw bit (1) unaligned init ("0"b), /* ON => do not strip leading/trailing white space */ 12 16 3 prompt_after_explanation bit (1) unaligned init ("0"b), /* ON => repeat question after explanation */ 12 17 3 padding bit (29) unaligned init (""b), /* pads it out to t word */ 12 18 2 status_code fixed bin (35) init (0), /* query not prompted by any error, by default */ 12 19 2 query_code fixed bin (35) init (0), /* currently has no meaning */ 12 20 12 21 /* Limit of data defined for version 2 */ 12 22 12 23 2 question_iocbp ptr init (null ()), /* IO switch to write question */ 12 24 2 answer_iocbp ptr init (null ()), /* IO switch to read answer */ 12 25 2 repeat_time fixed bin (71) init (0), /* repeat question every N seconds if no answer */ 12 26 /* minimum of 30 seconds required for repeat */ 12 27 /* otherwise, no repeat will occur */ 12 28 /* Limit of data defined for version 4 */ 12 29 12 30 2 explanation_ptr ptr init (null ()), /* explanation of question to be printed if */ 12 31 2 explanation_len fixed bin (21) init (0); /* user answers "?" (disabled if ptr=null or len=0) */ 12 32 12 33 dcl query_info_version_3 fixed bin int static options (constant) init (3); 12 34 dcl query_info_version_4 fixed bin int static options (constant) init (4); 12 35 dcl query_info_version_5 fixed bin int static options (constant) init (5); 12 36 dcl query_info_version_6 fixed bin int static options (constant) init (6); /* the current version number */ 12 37 12 38 /* END INCLUDE FILE query_info.incl.pl1 */ 906 907 13 1 /* BEGIN INCLUDE FILE ... system_constants.incl.pl1 */ 13 2 13 3 /****^ HISTORY COMMENTS: 13 4* 1) change(86-11-12,GWMay), approve(86-11-12,MCR7445), audit(86-11-19,GDixon), 13 5* install(86-11-21,MR12.0-1223): 13 6* created. 13 7* END HISTORY COMMENTS */ 13 8 13 9 /* format: off */ 13 10 13 11 /* ************************************************************************ */ 13 12 /* */ 13 13 /* Function: Provides constants for commonly used Multics system values. */ 13 14 /* */ 13 15 /* Usage: These values are available for use in place of "magic" numbers */ 13 16 /* (unexplained numbers) in programming applications. */ 13 17 /* */ 13 18 /* Definitions: */ 13 19 /* */ 13 20 /* PER bit character/byte word page segment */ 13 21 /* */ 13 22 /* bits 1 9 36 36864 9400320 */ 13 23 /* characters/bytes 1 4 4096 1044480 */ 13 24 /* words 1 1024 261120 */ 13 25 /* pages 1 255 */ 13 26 /* segments 1 */ 13 27 /* */ 13 28 /* The base values for a bit, char, word and page are determined by the */ 13 29 /* Multics hardware implementation. The other values are calculated from */ 13 30 /* their relation to one another as shown in the matrix above. */ 13 31 /* */ 13 32 /* BITS_PER_CHAR = 9 (defined by the hardware) */ 13 33 /* BITS_PER_WORD = BITS_PER_CHAR * CHARS_PER_WORD */ 13 34 /* = 9 * 4 */ 13 35 /* = 36 */ 13 36 /* BITS_PER_PAGE = BITS_PER_CHAR * CHARS_PER_WORD * CHARS_PER_PAGE */ 13 37 /* = 9 * 4 * 1024 */ 13 38 /* = 36864 */ 13 39 /* BITS_PER_SEGMENT = BITS_PER_CHAR * CHARS_PER_WORD * CHARS_PER_PAGE * */ 13 40 /* PAGES_PER_SEGMENT */ 13 41 /* = 9 * 4 * 1024 * 255 */ 13 42 /* = 9400320 */ 13 43 /* */ 13 44 /* CHARS_PER_WORD = 4 (defined by the hardware) */ 13 45 /* CHARS_PER_PAGE = CHARS_PER_WORD * WORDS_PER_PAGE */ 13 46 /* = 4 * 1024 */ 13 47 /* = 4096 */ 13 48 /* CHARS_PER_SEGMENT = CHARS_PER_WORD * WORDS_PER_PAGE * PAGES_PER_SEGMENT */ 13 49 /* = 4 * 1024 * 255 */ 13 50 /* = 1044480 */ 13 51 /* */ 13 52 /* WORDS_PER_PAGE = 1024 (defined by the hardware) */ 13 53 /* WORDS_PER_SEGMENT = WORDS_PER_PAGE * PAGES_PER_SEGMENT */ 13 54 /* = 1024 * 255 */ 13 55 /* = 261120 */ 13 56 /* */ 13 57 /* PAGES_PER_SEGMENT = 255 (defined by system standard) */ 13 58 /* */ 13 59 /* ************************************************************************ */ 13 60 13 61 declare BITS_PER_CHAR fixed bin (4) internal static 13 62 options (constant) initial (9); 13 63 13 64 declare BITS_PER_WORD fixed bin (6) internal static 13 65 options (constant) initial (36); 13 66 13 67 declare BITS_PER_PAGE fixed bin (16) internal static 13 68 options (constant) initial (36864); 13 69 13 70 declare BITS_PER_SEGMENT fixed bin (24) internal static 13 71 options (constant) initial (9400320); 13 72 13 73 declare CHARS_PER_WORD fixed bin (3) internal static 13 74 options (constant) initial (4); 13 75 13 76 declare CHARS_PER_PAGE fixed bin (13) internal static 13 77 options (constant) initial (4096); 13 78 13 79 declare CHARS_PER_SEGMENT fixed bin (21) internal static 13 80 options (constant) initial (1044480); 13 81 13 82 /* Note: WORDS_PER_PAGE should be equal to sys_info$max_page_size */ 13 83 13 84 declare WORDS_PER_PAGE fixed bin (11) internal static 13 85 options (constant) initial (1024); 13 86 13 87 /* Note: WORDS_PER_SEGMENT should be equal to sys_info$max_seg_size */ 13 88 13 89 declare WORDS_PER_SEGMENT fixed bin (21) internal static 13 90 options (constant) initial (261120); 13 91 13 92 declare PAGES_PER_SEGMENT fixed bin (8) internal static 13 93 options (constant) initial (255); 13 94 13 95 /* END INCLUDE FILE ... system_constants.incl.pl1 */ 13 96 908 909 910 end dmpr_output_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 10/10/89 1359.8 dmpr_output_.pl1 >special_ldd>install>MR12.3-1089>dmpr_output_.pl1 886 1 10/24/84 0933.1 dmpr_data_.incl.pl1 >ldd>include>dmpr_data_.incl.pl1 888 2 09/05/80 1136.5 backup_info.incl.pl1 >ldd>include>backup_info.incl.pl1 890 3 11/24/86 1243.9 backup_volume_contents.incl.pl1 >ldd>include>backup_volume_contents.incl.pl1 892 4 09/05/80 1136.5 backup_volume_header.incl.pl1 >ldd>include>backup_volume_header.incl.pl1 893 5 10/18/88 1215.0 backup_volume_record.incl.pl1 >ldd>include>backup_volume_record.incl.pl1 895 6 10/04/83 1105.1 vtoce.incl.pl1 >ldd>include>vtoce.incl.pl1 897 7 10/10/89 1357.9 backup_volume_log.incl.pl1 >special_ldd>install>MR12.3-1089>backup_volume_log.incl.pl1 898 8 06/07/77 1233.6 backup_pvol_info.incl.pl1 >ldd>include>backup_pvol_info.incl.pl1 900 9 07/21/88 2036.0 fs_vol_label.incl.pl1 >ldd>include>fs_vol_label.incl.pl1 902 10 02/02/78 1229.7 iox_modes.incl.pl1 >ldd>include>iox_modes.incl.pl1 904 11 11/22/82 0955.7 status_structures.incl.pl1 >ldd>include>status_structures.incl.pl1 906 12 03/11/83 1204.3 query_info.incl.pl1 >ldd>include>query_info.incl.pl1 908 13 11/24/86 1243.9 system_constants.incl.pl1 >ldd>include>system_constants.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. CHARS_PER_PAGE constant fixed bin(13,0) initial dcl 13-76 ref 222 225 387 633 781 781 863 CHARS_PER_WORD constant fixed bin(3,0) initial dcl 13-73 ref 215 225 243 253 269 286 863 Stream_output 000243 constant fixed bin(17,0) initial dcl 10-15 set ref 549* WORDS_PER_PAGE constant fixed bin(11,0) initial dcl 13-84 ref 778 862 a_volid parameter bit(36) packed unaligned dcl 797 set ref 795 825* a_volname parameter char packed unaligned dcl 833 in procedure "get_volname_from_user" set ref 832 839* a_volname parameter char packed unaligned dcl 796 in procedure "set_volid" ref 795 812 818 820 820 accounting 475(11) based bit(1) level 4 packed packed unaligned dcl 1-13 ref 592 671 addr builtin function dcl 142 ref 243 243 253 253 269 269 275 275 286 286 516 518 518 562 564 564 570 572 572 757 757 837 837 adjust_bit_count_ 000104 constant entry external dcl 123 ref 878 answer 000174 automatic varying char(3) dcl 46 set ref 518* 522 564* 567 572* 575 answer_iocbp 6 000404 automatic pointer initial level 2 dcl 12-7 set ref 12-7* ascii_type 000160 constant char(4) initial array packed unaligned dcl 68 set ref 424* 536* att_desc 1422 based char(256) level 3 in structure "dmpr_data_" dcl 1-13 in procedure "dmpr_output_" set ref 339 339* 508 508* att_desc 000204 automatic char(256) packed unaligned dcl 51 in procedure "dmpr_output_" set ref 339* 341* 342 343* 345* 508* 510* 511 512* attach_name 000164 automatic char(32) packed unaligned dcl 45 set ref 338* 343* 345* auto_vol 475(01) based bit(1) level 4 packed packed unaligned dcl 1-13 ref 354 423 527 535 557 avolname 000126 automatic varying char(32) dcl 834 set ref 837* 838 839 backup_info based structure level 1 dcl 2-7 backup_pvol_info based structure level 1 dcl 8-5 backup_volume_contents based structure level 1 dcl 3-39 backup_volume_header based structure level 1 dcl 4-5 backup_volume_log based structure level 1 dcl 7-20 backup_volume_record based structure level 1 dcl 5-17 set ref 215 backup_volume_record_version_2 constant fixed bin(17,0) initial dcl 5-15 ref 157 before builtin function dcl 143 ref 342 511 begin_indx parameter fixed bin(17,0) dcl 301 ref 298 312 330 337 346 348 bit builtin function dcl 143 ref 390 605 636 bits 410 based structure level 2 dcl 1-13 bvle based structure level 1 dcl 7-39 bvlp 336 based pointer level 3 in structure "dmpr_data_" dcl 1-13 in procedure "dmpr_output_" ref 212 378 647 bvlp 000402 automatic pointer dcl 7-13 in procedure "dmpr_output_" set ref 212* 378* 381* 387 390 397* 397 char 000327 automatic char(2) level 2 packed packed unaligned dcl 83 set ref 818* 819* char_num 000316 automatic char(32) packed unaligned dcl 62 set ref 820* 821* chars 500 based structure level 2 dcl 1-13 clock builtin function dcl 142 ref 390 605 636 code parameter fixed bin(35,0) dcl 53 in procedure "dmpr_output_" set ref 145 152* 165* 166 172* 173 181 189 200 207* 236* 243* 247* 253* 261* 269* 275* 276 276 277 277* 286* 370 374* 382 383* 397* 504* 506 512* 513 514* 530* 536* 539 540* 549* 550 551* 577* 586* 587 588* 593* 594 595* 608* 617* 618 620* 622* 628 629* 639* 648* 649 649* 672* 673 673* 678* 679 679* 681* 682 682* 690* 691 691* 716 717 719 719 720 724* 728 729* 731 732* 751* 752 753* 757* 758 759* 781* 859* code parameter fixed bin(35,0) dcl 798 in procedure "set_volid" set ref 795 814* 821* 822 command_query_ 000010 constant entry external dcl 90 ref 518 564 572 837 contentsp 334 based pointer level 3 dcl 1-13 set ref 676* continue_explanation 000003 constant char(141) initial packed unaligned dcl 77 set ref 570 571 continue_to_signal_ 000012 constant entry external dcl 91 ref 247 cp_escape_control 1(02) 000404 automatic bit(2) initial level 3 packed packed unaligned dcl 12-7 set ref 12-7* csl 15(09) based bit(9) level 3 packed packed unaligned dcl 5-17 ref 220 224 776 862 cur_vol_open 475(16) based bit(1) level 4 packed packed unaligned dcl 1-13 set ref 490* 585* current_length 7 000330 automatic fixed bin(12,0) level 3 in structure "local_status_branch" packed packed unsigned unaligned dcl 88 in procedure "dmpr_output_" set ref 763 current_length 000163 automatic fixed bin(17,0) dcl 44 in procedure "dmpr_output_" set ref 387 633 763* cv_dec_check_ 000030 constant entry external dcl 100 ref 821 datap parameter pointer dcl 55 set ref 200 217 261* 778 862 delete_explanation 000047 constant char(148) initial packed unaligned dcl 73 set ref 562 563 dir_type constant fixed bin(17,0) initial dcl 4-16 ref 218 dirname 000100 automatic char(168) packed unaligned dcl 41 set ref 751* 757* 759* dirsw 20(18) based bit(1) level 3 packed packed unaligned dcl 5-17 ref 218 divide builtin function dcl 143 ref 863 dmpr_data_ based structure level 1 dcl 1-13 dmpr_log_$close_account_file 000060 constant entry external dcl 112 ref 672 dmpr_log_$close_volume_log 000064 constant entry external dcl 114 ref 690 dmpr_log_$create_pvolog 000072 constant entry external dcl 117 ref 464 dmpr_log_$init_account_file 000056 constant entry external dcl 111 ref 593 dmpr_log_$init_contents_seg 000066 constant entry external dcl 115 ref 586 dmpr_log_$open_volume_log 000062 constant entry external dcl 113 ref 648 dmpr_log_$update_pvolog 000070 constant entry external dcl 116 ref 729 dmpr_output_$preattach_ioname 000052 constant entry external dcl 109 ref 172 dmpr_output_$preattach_vols 000050 constant entry external dcl 108 ref 165 dmpr_report_$error_output 000054 constant entry external dcl 110 ref 345 354 354 383 424 424 442 442 444 444 448 448 451 514 527 527 536 536 540 551 558 558 567 567 588 595 613 622 629 649 673 679 682 691 720 724 732 753 759 dmpr_report_$online_output 000110 constant entry external dcl 125 ref 167 428 433 440 460 466 685 dmprp 000136 external static pointer initial dcl 1-8 ref 156 162 163 164 167 167 169 170 171 174 211 212 236 243 252 253 261 269 275 286 307 308 309 312 315 315 316 316 317 317 319 321 322 337 339 339 339 341 342 343 351 352 353 354 354 354 357 358 377 378 383 397 423 424 424 442 444 448 451 470 471 490 491 493 493 494 494 495 495 498 498 498 499 499 499 500 500 500 501 501 501 508 508 508 510 511 512 514 524 525 526 527 527 527 535 536 536 536 536 540 542 543 544 545 549 551 553 554 555 556 557 558 558 560 567 567 583 585 592 600 603 604 608 612 613 617 620 639 644 644 647 649 653 654 655 656 657 671 676 677 678 679 681 682 684 685 685 685 685 685 689 691 695 696 697 698 720 724 732 781 dn 000106 automatic char(168) packed unaligned dcl 874 set ref 877* 878* dump_type 372 based fixed bin(17,0) level 3 dcl 1-13 ref 424 536 dump_volid 14 based bit(36) level 2 dcl 2-7 set ref 604* dump_volname 17 based char(32) level 2 dcl 2-7 set ref 603* dump_volume_dir_num 361 based fixed bin(17,0) level 3 dcl 1-13 set ref 656* 685* 697* dump_volume_dir_rec 362 based fixed bin(17,0) level 3 dcl 1-13 set ref 657* 685* 698* dump_volume_seg_num 363 based fixed bin(17,0) level 3 dcl 1-13 set ref 654* 685* 695* dump_volume_seg_rec 364 based fixed bin(17,0) level 3 dcl 1-13 set ref 655* 685* 696* ec parameter fixed bin(35,0) dcl 413 set ref 409 424* 426 427 432 432* 433* 438* 439 440* 448* 450 451* 458* 459 460* 464* 465 en 000160 automatic char(32) packed unaligned dcl 875 set ref 877* 878* ename 000152 automatic char(32) packed unaligned dcl 42 set ref 617* 620* 622* 751* 757* 759* error_count 000176 automatic fixed bin(17,0) dcl 47 set ref 275 275 277 error_table_$action_not_performed 000122 external static fixed bin(35,0) dcl 135 ref 427 432 error_table_$bad_volid 000120 external static fixed bin(35,0) dcl 134 ref 814 error_table_$device_end 000124 external static fixed bin(35,0) dcl 136 ref 719 error_table_$end_of_info 000126 external static fixed bin(35,0) dcl 137 ref 719 error_table_$fatal_error 000130 external static fixed bin(35,0) dcl 138 ref 277 720 error_table_$no_operation 000134 external static fixed bin(35,0) dcl 140 ref 276 error_table_$segfault 000116 external static fixed bin(35,0) dcl 133 ref 717 859 error_table_$undefined_order_request 000132 external static fixed bin(35,0) dcl 139 ref 276 explanation_len 14 000404 automatic fixed bin(21,0) initial level 2 dcl 12-7 set ref 12-7* 517* 521* 563* 571* 574* explanation_ptr 12 000404 automatic pointer initial level 2 dcl 12-7 set ref 12-7* 516* 520* 562* 570* 573* fixed builtin function dcl 142 ref 220 220 222 224 225 390 605 636 776 781 781 862 fixed_bin 350 based structure level 2 dcl 1-13 flags 475 based structure level 3 dcl 1-13 fm 33 based bit(18) array level 3 packed packed unaligned dcl 5-17 ref 777 hcs_$delentry_seg 000074 constant entry external dcl 118 ref 352 524 542 554 hcs_$fs_get_path_name 000102 constant entry external dcl 122 ref 751 877 hcs_$initiate 000076 constant entry external dcl 119 ref 620 hcs_$status_long 000106 constant entry external dcl 124 ref 757 hcs_$terminate_seg 000100 constant entry external dcl 121 ref 525 543 555 879 header based structure level 2 in structure "backup_info" dcl 2-7 in procedure "dmpr_output_" header based structure level 2 in structure "backup_volume_log" dcl 7-20 in procedure "dmpr_output_" header based structure level 2 in structure "backup_volume_contents" dcl 3-39 in procedure "dmpr_output_" header based structure level 2 in structure "backup_volume_record" dcl 5-17 in procedure "dmpr_output_" ignore 000305 automatic fixed bin(35,0) dcl 54 set ref 352* 354* 442* 444* 524* 525* 527* 542* 543* 553* 554* 555* 558* 567* 877* 878* 879* infop 000376 automatic pointer dcl 2-3 in procedure "dmpr_output_" set ref 600* 601 602 603 604 605 608* 608 infop 320 based pointer level 3 in structure "dmpr_data_" dcl 1-13 in procedure "dmpr_output_" ref 600 io_module 1402 based char(32) level 3 dcl 1-13 set ref 342* 511* ioa_$rsnnl 000112 constant entry external dcl 126 ref 338 339 341 508 510 iox_$attach_ioname 000032 constant entry external dcl 101 ref 343 512 iox_$close 000044 constant entry external dcl 106 ref 678 iox_$control 000034 constant entry external dcl 102 ref 275 iox_$detach_iocb 000046 constant entry external dcl 107 ref 545 553 681 iox_$modes 000036 constant entry external dcl 103 ref 583 iox_$open 000040 constant entry external dcl 104 ref 549 iox_$put_chars 000042 constant entry external dcl 105 ref 236 243 253 261 269 286 397 608 639 781 label based structure level 1 dcl 9-18 ldn 000162 automatic fixed bin(17,0) dcl 43 in procedure "dmpr_output_" set ref 751* ldn 000170 automatic fixed bin(17,0) dcl 876 in procedure "setbc_term" set ref 877* length builtin function dcl 142 ref 517 563 571 820 863 literal_sw 1(05) 000404 automatic bit(1) initial level 3 packed packed unaligned dcl 12-7 set ref 12-7* local_pre_attach_vol 000360 automatic fixed bin(17,0) dcl 150 set ref 163* 165* 167* 172* 174 local_status_branch 000330 automatic structure level 1 dcl 88 set ref 757 757 long 4 000330 automatic structure level 2 dcl 88 manage_volume_pool_$allocate 000020 constant entry external dcl 95 ref 536 manage_volume_pool_$delete 000024 constant entry external dcl 98 ref 444 567 manage_volume_pool_$free 000022 constant entry external dcl 97 ref 354 442 527 558 manage_volume_pool_$reserve 000016 constant entry external dcl 93 ref 424 manage_volume_pool_$set_volid 000026 constant entry external dcl 99 ref 448 max_error_count 000242 constant fixed bin(17,0) initial dcl 66 set ref 277 720* mcode parameter fixed bin(35,0) dcl 301 set ref 298 313* 314 myname 1542 based char(32) level 3 in structure "dmpr_data_" dcl 1-13 in procedure "dmpr_output_" set ref 167* 451* 613* myname 000163 constant char(32) initial packed unaligned dcl 65 in procedure "dmpr_output_" set ref 345* 383* 428* 433* 440* 460* 466* 514* 518* 540* 551* 564* 572* 588* 595* 622* 629* 649* 673* 679* 682* 685* 691* 720* 724* 732* 753* 759* 837* new_tape 000203 automatic bit(1) packed unaligned dcl 50 set ref 256 264 272 281 715* 735* 783 not_reported 475(14) based bit(1) level 4 packed packed unaligned dcl 1-13 set ref 653* 689* null builtin function dcl 142 ref 169 217 353 12-7 12-7 12-7 520 526 544 556 573 621 647 684 757 757 880 null_type constant fixed bin(17,0) initial dcl 4-18 ref 229 388 601 634 num 0(18) 000327 automatic fixed bin(17,0) level 2 in structure "volid" packed packed unaligned dcl 83 in procedure "dmpr_output_" set ref 823* num 000326 automatic fixed bin(17,0) dcl 63 in procedure "dmpr_output_" set ref 821* 823 nvols_to_get parameter fixed bin(17,0) dcl 301 ref 298 312 nvols_to_name parameter fixed bin(17,0) dcl 333 set ref 330 337 351 360* outputvol_iocbp 332 based pointer level 3 dcl 1-13 set ref 236* 243* 253* 261* 269* 275* 286* 397* 500* 512* 545* 549* 553* 583* 608* 639* 678* 681* 684* 781* p parameter pointer dcl 873 set ref 869 877* 879* 880* padding 1(07) 000404 automatic bit(29) initial level 3 packed packed unaligned dcl 12-7 set ref 12-7* page_by_page 000314 automatic bit(1) packed unaligned dcl 60 set ref 213* 221* 258 page_fault_error 000352 stack reference condition dcl 131 ref 241 page_of_chars based char dcl 59 ref 863 page_read_error 000000 stack reference condition dcl 130 ref 858 pagep 000312 automatic pointer dcl 58 set ref 778* 781* 862* 863 pagex 000310 automatic fixed bin(17,0) dcl 57 set ref 776* 777 778* pattern1 000002 constant bit(36) initial packed unaligned dcl 4-24 in procedure "dmpr_output_" ref 158 pattern1 based bit(36) level 3 in structure "backup_volume_record" dcl 5-17 in procedure "dmpr_output_" set ref 158* pattern2 000001 constant bit(36) initial packed unaligned dcl 4-25 in procedure "dmpr_output_" ref 159 pattern2 3 based bit(36) level 3 in structure "backup_volume_record" dcl 5-17 in procedure "dmpr_output_" set ref 159* pattern3 000000 constant bit(36) initial packed unaligned dcl 4-26 in procedure "dmpr_output_" ref 160 pattern3 6 based bit(36) level 3 in structure "backup_volume_record" dcl 5-17 in procedure "dmpr_output_" set ref 160* picode parameter fixed bin(35,0) dcl 333 set ref 330 343* 344 345* 347* pre_attach_iocbp 150 based pointer array level 3 dcl 1-13 set ref 343* 500 pre_attach_pvlp 2 based pointer array level 3 dcl 1-13 set ref 317* 352* 353* 501 pre_attach_vol 405 based fixed bin(17,0) level 3 dcl 1-13 set ref 162 163 164* 174* 312 337 351 491 494 495* 560 pre_attach_volid 411 based bit(36) array level 3 dcl 1-13 set ref 316* 358* 499 pre_attach_volname 562 based char(32) array level 3 dcl 1-13 set ref 167* 315* 339* 341* 354 357* 498 prev_contentsp 000200 automatic pointer dcl 48 set ref 620* 621 627* 633 634 635 636 639* 639 prev_volname 552 based char(32) level 3 dcl 1-13 set ref 612 617 644* prex 000306 automatic fixed bin(17,0) dcl 56 set ref 312* 315 316 317* 337* 338* 339 341 343 346 348 351* 351* 352 353 354 357 358* prompt_after_explanation 1(06) 000404 automatic bit(1) initial level 3 packed packed unaligned dcl 12-7 set ref 12-7* ptr builtin function dcl 142 ref 778 862 ptrs 2 based structure level 2 dcl 1-13 pvlp 314 based pointer level 3 dcl 1-13 set ref 169* 309 317 322* 501* 524* 525* 526* 542* 543* 544* 554* 555* 556* 677* pvname 1412 based char(32) level 3 dcl 1-13 set ref 383* 649* query_code 3 000404 automatic fixed bin(35,0) initial level 2 dcl 12-7 set ref 12-7* query_info 000404 automatic structure level 1 dcl 12-7 set ref 518 518 564 564 572 572 837 837 query_info_version_5 constant fixed bin(17,0) initial dcl 12-35 ref 154 209 375 question_iocbp 4 000404 automatic pointer initial level 2 dcl 12-7 set ref 12-7* rec1_len 2 based fixed bin(17,0) level 3 in structure "backup_volume_log" dcl 7-20 in procedure "dmpr_output_" set ref 387* 397* rec1_len 2 based fixed bin(17,0) level 3 in structure "backup_volume_contents" dcl 3-39 in procedure "dmpr_output_" set ref 633* 639* rec1_len 2 based fixed bin(17,0) level 3 in structure "backup_info" dcl 2-7 in procedure "dmpr_output_" set ref 608* rec1_len 2 based fixed bin(17,0) level 3 in structure "backup_volume_record" dcl 5-17 in procedure "dmpr_output_" set ref 215* 236* rec1_type 1 based fixed bin(17,0) level 3 dcl 5-17 set ref 214* rec2_len 5 based fixed bin(17,0) level 3 in structure "backup_volume_record" dcl 5-17 in procedure "dmpr_output_" set ref 222* 224* 225* 230* 251 261* 389* rec2_len 5 based fixed bin(17,0) level 3 in structure "backup_volume_contents" dcl 3-39 in procedure "dmpr_output_" set ref 635* rec2_len 5 based fixed bin(17,0) level 3 in structure "backup_info" dcl 2-7 in procedure "dmpr_output_" set ref 602* rec2_type 4 based fixed bin(17,0) level 3 in structure "backup_info" dcl 2-7 in procedure "dmpr_output_" set ref 601* rec2_type 4 based fixed bin(17,0) level 3 in structure "backup_volume_contents" dcl 3-39 in procedure "dmpr_output_" set ref 634* rec2_type 4 based fixed bin(17,0) level 3 in structure "backup_volume_record" dcl 5-17 in procedure "dmpr_output_" set ref 218* 219* 229* 388* recordp 000400 automatic pointer dcl 5-12 in procedure "dmpr_output_" set ref 156* 157 158 159 160 211* 214 215 215 218 218 219 220 220 222 222 224 224 225 225 229 230 236* 236 251 261 377* 388 389 776 777 862 recordp 324 based pointer level 3 in structure "dmpr_data_" dcl 1-13 in procedure "dmpr_output_" ref 156 211 377 records 15(18) based bit(9) level 3 packed packed unaligned dcl 5-17 ref 220 222 225 repeat_time 10 000404 automatic fixed bin(71,0) initial level 2 dcl 12-7 set ref 12-7* retry 000202 automatic bit(1) packed unaligned dcl 49 set ref 233* 235 259* 260 395* 396 606* 607 637* 638 715* 736* 779* 780 retry_explanation 000114 constant char(143) initial packed unaligned dcl 69 set ref 516 517 rtrim builtin function dcl 142 ref 620 863 safe_pvlp 000362 automatic pointer dcl 301 set ref 309* 322 safe_volid 000374 automatic bit(36) packed unaligned dcl 301 set ref 308* 321 safe_volname 000364 automatic char(32) packed unaligned dcl 301 set ref 307* 319 search builtin function dcl 142 ref 812 seg_fault_error 000344 stack reference condition dcl 129 ref 241 858 seg_type constant fixed bin(17,0) initial dcl 4-17 ref 219 segp parameter pointer dcl 750 set ref 746 751* size builtin function dcl 142 ref 215 243 253 269 286 sprex 000307 automatic fixed bin(17,0) dcl 56 set ref 348* 350* 360 start_numeric 000315 automatic fixed bin(17,0) dcl 61 set ref 812* 813 813 818 818 820 820 status_branch based structure level 1 dcl 11-8 status_code 2 000404 automatic fixed bin(35,0) initial level 2 dcl 12-7 set ref 12-7* substr builtin function dcl 142 ref 252 390 605 636 777 818 820 suffixed_name_$make 000014 constant entry external dcl 92 ref 617 suppress_name_sw 1(01) 000404 automatic bit(1) initial level 3 packed packed unaligned dcl 12-7 set ref 12-7* suppress_spacing 1(04) 000404 automatic bit(1) initial level 3 packed packed unaligned dcl 12-7 set ref 12-7* switches 1 000404 automatic structure level 2 dcl 12-7 sys_dir 500 based char(168) level 3 dcl 1-13 ref 620 tape_check 000342 automatic bit(72) packed unaligned dcl 128 set ref 242 243 243 243 250* 252* 253 253 253 269 269 269 273* 284 286 286 286 time_dumped 7 based bit(36) level 3 in structure "backup_volume_contents" dcl 3-39 in procedure "dmpr_output_" set ref 636* time_dumped 7 based bit(36) level 3 in structure "backup_volume_log" dcl 7-20 in procedure "dmpr_output_" set ref 390* time_dumped 7 based bit(36) level 3 in structure "backup_info" dcl 2-7 in procedure "dmpr_output_" set ref 605* unique_bits_ 000114 constant entry external dcl 127 ref 252 unspec builtin function dcl 142 ref 825 version 10 based fixed bin(17,0) level 2 in structure "backup_volume_record" dcl 5-17 in procedure "dmpr_output_" set ref 157* version 000404 automatic fixed bin(17,0) level 2 in structure "query_info" dcl 12-7 in procedure "dmpr_output_" set ref 154* 209* 375* vol_idx 406 based fixed bin(17,0) level 3 dcl 1-13 set ref 493* 493 494 495* 498 499 500 501 volid 000327 automatic structure level 1 dcl 83 in procedure "dmpr_output_" set ref 825 volid 410 based bit(36) level 3 in structure "dmpr_data_" dcl 1-13 in procedure "dmpr_output_" set ref 170* 252 308 316 321* 470* 499* 604 volid 000100 automatic bit(36) packed unaligned dcl 411 in procedure "get_volname" set ref 438* 448* 458* 470 volname 1522 based char(32) level 3 in structure "dmpr_data_" dcl 1-13 in procedure "dmpr_output_" set ref 171* 307 315 319* 471* 498* 508* 510* 514* 527 536 536 540* 551* 558 567 603 644 679* 682* 685* 691* 720* 724* 732* volname 000101 automatic char(32) packed unaligned dcl 412 in procedure "get_volname" set ref 422* 424* 424* 427 428* 435* 438* 440* 442* 444* 448* 451* 457* 458* 460* 464* 466* 471 vpp 346 based pointer level 3 dcl 1-13 set ref 354* 424* 442* 444* 448* 527* 536* 558* 567* vtoce 13 based structure level 2 in structure "backup_volume_record" dcl 5-17 in procedure "dmpr_output_" vtoce based structure level 1 dcl 6-7 in procedure "dmpr_output_" vtoce_type constant fixed bin(17,0) initial dcl 4-15 ref 214 write_volume_log 000304 automatic bit(1) packed unaligned dcl 52 set ref 153* 183* 191* 208* 310* 336* 376* 648 690 729 yes_or_no_sw 1 000404 automatic bit(1) initial level 3 packed packed unaligned dcl 12-7 set ref 155* 210* 12-7* 836* 840* zero_char constant char(1) initial packed unaligned dcl 67 ref 863 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. BITS_PER_CHAR internal static fixed bin(4,0) initial dcl 13-61 BITS_PER_PAGE internal static fixed bin(16,0) initial dcl 13-67 BITS_PER_SEGMENT internal static fixed bin(24,0) initial dcl 13-70 BITS_PER_WORD internal static fixed bin(6,0) initial dcl 13-64 CHARS_PER_SEGMENT internal static fixed bin(21,0) initial dcl 13-79 Direct_input internal static fixed bin(17,0) initial dcl 10-15 Direct_output internal static fixed bin(17,0) initial dcl 10-15 Direct_update internal static fixed bin(17,0) initial dcl 10-15 Directory internal static fixed bin(17,0) initial dcl 11-56 Keyed_sequential_input internal static fixed bin(17,0) initial dcl 10-15 Keyed_sequential_output internal static fixed bin(17,0) initial dcl 10-15 Keyed_sequential_update internal static fixed bin(17,0) initial dcl 10-15 Link internal static fixed bin(17,0) initial dcl 11-56 Multics_ID_String internal static char(32) initial packed unaligned dcl 9-92 PAGES_PER_SEGMENT internal static fixed bin(8,0) initial dcl 13-92 Segment internal static fixed bin(17,0) initial dcl 11-56 Sequential_input internal static fixed bin(17,0) initial dcl 10-15 Sequential_input_output internal static fixed bin(17,0) initial dcl 10-15 Sequential_output internal static fixed bin(17,0) initial dcl 10-15 Sequential_update internal static fixed bin(17,0) initial dcl 10-15 Stream_input internal static fixed bin(17,0) initial dcl 10-15 Stream_input_output internal static fixed bin(17,0) initial dcl 10-15 WORDS_PER_SEGMENT internal static fixed bin(21,0) initial dcl 13-89 backup_info_version_2 internal static fixed bin(17,0) initial dcl 2-5 backup_volume_contents_names based structure level 1 dcl 3-56 backup_volume_contents_version_3 internal static fixed bin(17,0) initial dcl 3-14 backup_volume_log_version_1 internal static fixed bin(17,0) initial dcl 7-16 backup_volume_log_version_2 internal static fixed bin(17,0) initial dcl 7-17 backup_volume_log_version_3 internal static fixed bin(17,0) initial dcl 7-18 backup_volume_record_version_1 internal static fixed bin(17,0) initial dcl 5-14 bpvip automatic pointer dcl 8-3 bvlep automatic pointer dcl 7-14 contents_namesp automatic pointer dcl 3-54 contents_type internal static fixed bin(17,0) initial dcl 4-21 contentsp automatic pointer dcl 3-12 dmpr_data_version_2 internal static fixed bin(17,0) initial dcl 1-9 dmpr_data_version_3 internal static fixed bin(17,0) initial dcl 1-10 hdp automatic pointer dcl 4-3 info_type internal static fixed bin(17,0) initial dcl 4-22 iox_modes internal static char(24) initial array dcl 10-6 labelp automatic pointer dcl 9-16 prev_output_log_type internal static fixed bin(17,0) initial dcl 4-20 query_info_version_3 internal static fixed bin(17,0) initial dcl 12-33 query_info_version_4 internal static fixed bin(17,0) initial dcl 12-34 query_info_version_6 internal static fixed bin(17,0) initial dcl 12-36 seg_vtoce based structure level 1 dcl 6-92 short_iox_modes internal static char(4) initial array dcl 10-12 status_area_ptr automatic pointer dcl 11-47 status_entry_names based char(32) array dcl 11-47 status_link based structure level 1 dcl 11-38 status_pathname based char dcl 11-47 status_ptr automatic pointer dcl 11-47 v1_backup_volume_contents based structure level 1 dcl 3-17 v2_backup_volume_contents based structure level 1 dcl 3-26 volume_log_type internal static fixed bin(17,0) initial dcl 4-19 vtoce_parts based bit(2304) array dcl 6-90 vtocep automatic pointer dcl 6-5 NAMES DECLARED BY EXPLICIT CONTEXT. attach 003535 constant entry internal dcl 480 ref 176 184 727 bad_volid 006731 constant label dcl 814 in procedure "set_volid" ref 822 bad_volid 003203 constant label dcl 442 in procedure "get_volname" ref 453 check_output_error 006174 constant entry internal dcl 706 ref 238 245 255 263 271 280 288 398 609 641 782 continue_error_check 006206 constant label dcl 717 detach 005620 constant entry internal dcl 666 ref 192 726 dmpr_output_ 001073 constant entry external dcl 24 end_pass_detach 001312 constant entry external dcl 189 get_seg_current_length 006413 constant entry internal dcl 746 ref 381 627 get_vol 002765 constant label dcl 424 ref 436 get_volname 002747 constant entry internal dcl 409 ref 313 504 get_volname_from_user 007011 constant entry internal dcl 832 ref 435 457 init 001105 constant entry external dcl 145 last_page_length 007101 constant entry internal dcl 851 ref 225 new_pass_attach 001271 constant entry external dcl 181 non_local_return 002021 constant label dcl 284 ref 717 728 733 860 non_pre_attach 003605 constant label dcl 504 ref 496 output_object 001335 constant entry external dcl 200 page_by_page_write 006607 constant entry internal dcl 770 ref 267 preattach_ioname 002164 constant entry external dcl 330 preattach_vols 002057 constant entry external dcl 298 prev_err 005364 constant label dcl 622 ref 618 reattach 003721 constant label dcl 512 ref 522 request 002754 constant label dcl 422 ref 446 468 reread1 003122 constant label dcl 435 reread2 003372 constant label dcl 457 ref 461 restore_safe 002147 constant label dcl 319 ref 314 retry_attach 003546 constant label dcl 491 ref 546 560 581 rq 007025 constant label dcl 837 ref 838 set_volid 006677 constant entry internal dcl 795 ref 438 458 setbc_term 007171 constant entry internal dcl 869 ref 676 677 start_io 001456 constant label dcl 233 ref 256 264 272 281 783 update_prev 005525 constant label dcl 644 ref 615 624 631 write_volume_log 002602 constant entry external dcl 370 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 10414 10554 7525 10424 Length 11460 7525 140 667 666 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME dmpr_output_ 346 external procedure is an external procedure. on unit on line 241 78 on unit get_volname 188 internal procedure is called by several nonquick procedures. attach 172 internal procedure is called by several nonquick procedures. detach 224 internal procedure is called by several nonquick procedures. check_output_error 130 internal procedure is called by several nonquick procedures. get_seg_current_length 132 internal procedure is called by several nonquick procedures. page_by_page_write internal procedure shares stack frame of external procedure dmpr_output_. set_volid internal procedure shares stack frame of internal procedure get_volname. get_volname_from_user internal procedure shares stack frame of internal procedure get_volname. last_page_length 77 internal procedure enables or reverts conditions. on unit on line 858 64 on unit setbc_term internal procedure shares stack frame of internal procedure detach. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME detach 000106 dn setbc_term 000160 en setbc_term 000170 ldn setbc_term dmpr_output_ 000100 dirname dmpr_output_ 000152 ename dmpr_output_ 000162 ldn dmpr_output_ 000163 current_length dmpr_output_ 000164 attach_name dmpr_output_ 000174 answer dmpr_output_ 000176 error_count dmpr_output_ 000200 prev_contentsp dmpr_output_ 000202 retry dmpr_output_ 000203 new_tape dmpr_output_ 000204 att_desc dmpr_output_ 000304 write_volume_log dmpr_output_ 000305 ignore dmpr_output_ 000306 prex dmpr_output_ 000307 sprex dmpr_output_ 000310 pagex dmpr_output_ 000312 pagep dmpr_output_ 000314 page_by_page dmpr_output_ 000315 start_numeric dmpr_output_ 000316 char_num dmpr_output_ 000326 num dmpr_output_ 000327 volid dmpr_output_ 000330 local_status_branch dmpr_output_ 000342 tape_check dmpr_output_ 000360 local_pre_attach_vol dmpr_output_ 000362 safe_pvlp dmpr_output_ 000364 safe_volname dmpr_output_ 000374 safe_volid dmpr_output_ 000376 infop dmpr_output_ 000400 recordp dmpr_output_ 000402 bvlp dmpr_output_ 000404 query_info dmpr_output_ get_volname 000100 volid get_volname 000101 volname get_volname 000126 avolname get_volname_from_user THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_char_temp call_ext_out_desc call_ext_out call_int_this call_int_other return_mac tra_ext_1 enable_op shorten_stack ext_entry int_entry clock_mac THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. adjust_bit_count_ command_query_ continue_to_signal_ cv_dec_check_ dmpr_log_$close_account_file dmpr_log_$close_volume_log dmpr_log_$create_pvolog dmpr_log_$init_account_file dmpr_log_$init_contents_seg dmpr_log_$open_volume_log dmpr_log_$update_pvolog dmpr_output_$preattach_ioname dmpr_output_$preattach_vols dmpr_report_$error_output dmpr_report_$online_output hcs_$delentry_seg hcs_$fs_get_path_name hcs_$initiate hcs_$status_long hcs_$terminate_seg ioa_$rsnnl iox_$attach_ioname iox_$close iox_$control iox_$detach_iocb iox_$modes iox_$open iox_$put_chars manage_volume_pool_$allocate manage_volume_pool_$delete manage_volume_pool_$free manage_volume_pool_$reserve manage_volume_pool_$set_volid suffixed_name_$make unique_bits_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. dmprp error_table_$action_not_performed error_table_$bad_volid error_table_$device_end error_table_$end_of_info error_table_$fatal_error error_table_$no_operation error_table_$segfault error_table_$undefined_order_request LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 12 7 001040 24 001072 145 001101 152 001116 153 001117 154 001120 155 001122 156 001124 157 001131 158 001133 159 001135 160 001137 162 001141 163 001145 164 001146 165 001147 166 001163 167 001165 169 001224 170 001231 171 001234 172 001237 173 001253 174 001255 176 001262 177 001266 181 001267 183 001302 184 001303 185 001307 189 001310 191 001323 192 001324 193 001330 200 001331 207 001346 208 001347 209 001350 210 001352 211 001354 212 001361 213 001365 214 001366 215 001370 217 001372 218 001377 219 001405 220 001407 221 001421 222 001423 223 001426 224 001427 225 001433 227 001452 229 001453 230 001455 233 001456 235 001460 236 001462 238 001502 239 001506 241 001507 242 001523 243 001526 245 001550 247 001555 248 001565 241 001566 250 001573 251 001575 252 001600 253 001617 255 001637 256 001643 258 001645 259 001647 260 001651 261 001654 263 001675 264 001701 265 001703 266 001704 267 001705 269 001706 271 001731 272 001735 273 001737 275 001741 276 001776 277 002004 280 002013 281 002017 284 002021 286 002023 288 002046 291 002052 298 002053 307 002065 308 002073 309 002075 310 002077 312 002100 313 002111 314 002120 315 002123 316 002136 317 002141 318 002145 319 002147 321 002155 322 002157 323 002161 330 002162 336 002172 337 002173 338 002207 339 002247 341 002306 342 002340 343 002353 344 002402 345 002405 346 002440 347 002445 348 002446 349 002451 350 002452 351 002453 352 002467 353 002502 354 002511 357 002553 358 002564 359 002570 360 002572 362 002575 363 002577 370 002600 374 002613 375 002614 376 002616 377 002620 378 002625 381 002631 382 002637 383 002641 384 002673 387 002674 388 002700 389 002703 390 002704 395 002713 396 002715 397 002720 398 002740 399 002744 402 002745 409 002746 422 002754 423 002757 424 002765 426 003031 427 003034 428 003043 430 003072 432 003073 433 003077 435 003122 436 003125 438 003126 439 003146 440 003151 442 003203 444 003237 446 003273 448 003274 450 003333 451 003336 453 003370 455 003371 457 003372 458 003375 459 003416 460 003421 461 003450 464 003451 465 003467 466 003472 468 003522 470 003523 471 003530 472 003533 480 003534 490 003542 491 003546 493 003553 494 003554 495 003557 496 003561 498 003562 499 003567 500 003572 501 003576 502 003604 504 003605 506 003615 508 003620 510 003655 511 003705 512 003721 513 003755 514 003760 516 004011 517 004014 518 004016 520 004050 521 004053 522 004054 524 004061 525 004074 526 004113 527 004120 530 004161 531 004164 535 004165 536 004173 539 004242 540 004245 542 004277 543 004313 544 004332 545 004337 546 004352 549 004353 550 004375 551 004400 553 004432 554 004446 555 004462 556 004501 557 004506 558 004513 560 004547 562 004554 563 004557 564 004561 567 004627 570 004673 571 004676 572 004700 573 004732 574 004735 575 004736 577 004744 578 004746 581 004747 583 004750 585 005002 586 005007 587 005016 588 005021 589 005045 592 005046 593 005054 594 005062 595 005065 596 005111 600 005112 601 005117 602 005121 603 005122 604 005127 605 005131 606 005137 607 005142 608 005145 609 005165 610 005172 612 005173 613 005202 615 005226 617 005227 618 005260 620 005263 621 005356 622 005364 624 005413 627 005414 628 005423 629 005426 631 005452 633 005453 634 005457 635 005461 636 005462 637 005470 638 005473 639 005477 641 005517 642 005524 644 005525 647 005533 648 005537 649 005550 653 005605 654 005612 655 005613 656 005614 657 005615 659 005616 666 005617 671 005625 672 005632 673 005641 676 005670 677 005701 678 005712 679 005726 681 005763 682 005777 684 006034 685 006041 689 006110 690 006115 691 006126 695 006163 696 006167 697 006170 698 006171 699 006172 706 006173 715 006201 716 006204 717 006206 719 006213 720 006222 724 006263 726 006314 727 006321 728 006326 729 006334 731 006346 732 006351 733 006403 735 006406 736 006410 737 006411 746 006412 751 006420 752 006452 753 006455 754 006501 757 006502 758 006544 759 006547 760 006602 763 006603 765 006606 770 006607 776 006610 777 006623 778 006631 779 006640 780 006642 781 006644 782 006665 783 006671 784 006673 786 006674 787 006676 795 006677 812 006710 813 006725 814 006731 815 006735 818 006736 819 006745 820 006747 821 006755 822 006776 823 007001 825 007004 826 007010 832 007011 836 007022 837 007025 838 007060 839 007065 840 007074 844 007077 851 007100 858 007106 859 007122 860 007126 858 007131 862 007136 863 007152 869 007171 877 007173 878 007225 879 007262 880 007300 882 007303 ----------------------------------------------------------- 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