COMPILATION LISTING OF SEGMENT retv_vol_control_ 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 1420.8 mst Tue Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) BULL HN Information Systems Inc., 1989 * 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 /****^ HISTORY COMMENTS: 14* 1) change(89-08-31,GWMay), approve(89-10-03,MCR8135), 15* audit(89-10-04,Beattie), install(89-10-10,MR12.3-1089): 16* Updated to process version 3 of backup_volume_log.incl.pl1 structures. 17* END HISTORY COMMENTS */ 18 19 20 /* format: style1,ind2,^inddcls,ifthenstmt,dclind2,declareind2,ifthendo,ifthen*/ 21 22 retv_vol_control_: proc (inputp, code); 23 24 /* 25* This routine computes the set of volumes that a retrieval request might be 26* found on and then creates, if not already existent, the retriever_volume_control segment 27* for that volume and adds an entry to it for the retrieval request. If the object 28* does not have a branch in the hierarchy then the parent tree is searched until a existant 29* superior directory is found. This directory is then recovered and the branch structure is appended. 30**/ 31 /* Modified 6/79 by D. Vinograd to add directory name space searching from files created by volume dumper. 32* This feature means that if the directory name space file is available then one can check if an entry name 33* is in the directory dumped on tape and thus not have to read the tape during branch retrieval. 34* Modified: 8/83 by GA Texada to 35* 1) not look in the volume logs when -manual has been specified. 36* 2) announce only once that a volume may be searched when contents seg is missing. 37* 3) Reformatted and moved the %include's too. 38**/ 39 dcl answer char (3) var; 40 dcl a_rvcp ptr; 41 dcl message char (256); 42 dcl char_num char (32); 43 dcl code fixed bin (35); 44 dcl comp_cycle_uid bit (36); 45 dcl found bit (1); 46 dcl comp_indx fixed bin; 47 dcl comp_open_time fixed bin (71); 48 dcl cons_cycle_uid bit (36); 49 dcl cons_indx fixed bin; 50 dcl cons_open_time fixed bin (71); 51 dcl contents_idx fixed bin; 52 dcl control_name char (32); 53 dcl dirname char (168); 54 dcl done bit (1); 55 dcl emode bit (36); 56 dcl ename char (32); 57 dcl entry_name char (32); 58 dcl entry_retrieval bit (1); 59 dcl rvlx fixed bin; 60 dcl idx fixed bin; 61 dcl lns fixed bin; 62 dcl logged bit (1); 63 dcl test_name char (32); 64 dcl ignore fixed bin (35); 65 dcl incr_indx fixed bin; 66 dcl incr_close_time fixed bin (71); 67 dcl cons_close_time fixed bin (71); 68 dcl comp_close_time fixed bin (71); 69 dcl incr_open_time fixed bin (71); 70 dcl latest_indx fixed bin; 71 dcl link_retrieval bit (1); 72 dcl lock bit (1); 73 dcl lsearch_name char (32); 74 dcl ncp ptr; 75 dcl nelemt fixed bin; 76 dcl no_contents_seg bit (1); 77 dcl num fixed bin; 78 dcl object_retrieval bit (1); 79 dcl old_dirname char (168); 80 dcl open_time fixed bin (71); 81 dcl parent_check bit (1); 82 dcl pmode bit (36); 83 dcl psearch_name char (32); 84 dcl pvid bit (36); 85 dcl recursion_level fixed bin; 86 dcl search_name char (32); 87 dcl sortx fixed bin; 88 dcl sorty fixed bin; 89 dcl start_numeric fixed bin; 90 dcl type fixed bin; 91 dcl uid bit (36); 92 dcl vdtd bit (36) aligned; 93 dcl vlx fixed bin; 94 dcl volid bit (36); 95 dcl volname char (32); 96 dcl vtoce_derived_volname char (32); 97 dcl fcbp ptr; 98 dcl vtoce_volid (3) bit (36); 99 dcl dump_type fixed bin; 100 dcl nsp ptr; 101 102 dcl based_char_string char (1048576) based (ptr (contents_namesp, backup_volume_contents.offset (contents_idx))); 103 dcl name_string based (nsp) char (lns); 104 105 dcl 1 local_rvce like rvce aligned; 106 107 dcl 1 volume_id aligned, 108 2 char char (2) unaligned, 109 2 num fixed bin unaligned; 110 111 112 dcl myname char (32) static init ("retv_vol_control_") options (constant); 113 dcl segment fixed bin int static init (1) options (constant); 114 dcl DIR fixed bin int static init (2) options (constant); 115 dcl LINK fixed bin int static init (3) options (constant); 116 dcl rw bit (3) int static init ("101"b) options (constant); 117 dcl sm bit (3) int static init ("110"b) options (constant); 118 119 dcl iox_$user_input ptr ext; 120 dcl error_table_$action_not_performed ext fixed bin (35); 121 dcl error_table_$segfault ext fixed bin (35); 122 dcl error_table_$bad_volid ext fixed bin (35); 123 dcl error_table_$locked_by_this_process ext fixed bin (35); 124 dcl error_table_$bad_segment ext fixed bin (35); 125 dcl error_table_$invalid_lock_reset ext fixed bin (35); 126 127 dcl retv_notify_ entry (char (*), ptr, char (*)); 128 dcl get_temp_segment_ entry (char (*), ptr, fixed bin (35)); 129 dcl release_temp_segment_ entry (char (*), ptr, fixed bin (35)); 130 dcl hcs_$terminate_noname entry (ptr, fixed bin (35)); 131 dcl hcs_$fs_move_seg entry (ptr, ptr, fixed bin (1), fixed bin (35)); 132 dcl msf_manager_$close entry (ptr); 133 dcl msf_manager_$open entry (char (*), char (*), ptr, fixed bin (35)); 134 dcl msf_manager_$get_ptr entry (ptr, fixed bin, bit (1), ptr, fixed bin, fixed bin (35)); 135 dcl suffixed_name_$make entry (char (*), char (*), char (*), fixed bin (35)); 136 dcl expand_pathname_ entry (char (*), char (*), char (*), fixed bin (35)); 137 dcl ioa_ entry options (variable); 138 dcl ioa_$nnl entry options (variable); 139 dcl iox_$get_line entry (ptr, ptr, fixed bin, fixed bin, fixed bin (35)); 140 dcl cv_dec_check_ entry (char (*), fixed bin (35)) returns (fixed bin); 141 dcl command_query_ entry options (variable); 142 dcl retv_report_$error_output entry options (variable); 143 dcl retv_report_$online_output entry options (variable); 144 dcl ioa_$rsnnl entry options (variable); 145 dcl message_segment_$update_message_index entry (fixed bin, fixed bin, bit (72) aligned, ptr, fixed bin (35)); 146 dcl hcs_$make_seg entry (char (*), char (*), char (*), fixed bin (5), ptr, fixed bin (35)); 147 dcl mdc_$find_volname entry (bit (36), char (*), char (*), fixed bin (35)); 148 dcl set_lock_$lock entry (bit (36) aligned, fixed bin, fixed bin (35)); 149 dcl set_lock_$unlock entry (bit (36) aligned, fixed bin (35)); 150 dcl hcs_$initiate entry (char (*), char (*), char (*), fixed bin, fixed bin, ptr, fixed bin (35)); 151 dcl hc_backup_$retv_status entry (char (*), char (*), bit (72) aligned, char (*) aligned, 152 fixed bin, fixed bin, bit (36), bit (36), bit (36), bit (36), 153 (3) bit (36), bit (36) aligned, fixed bin (35)); 154 155 dcl seg_fault_error condition; 156 157 dcl min builtin; 158 dcl hbound builtin; 159 dcl index builtin; 160 dcl ptr builtin; 161 dcl unspec builtin; 162 dcl null builtin; 163 dcl search builtin; 164 dcl max builtin; 165 dcl addr builtin; 166 dcl length builtin; 167 dcl size builtin; 168 dcl substr builtin; 169 dcl rtrim builtin; 170 171 /* initialize local variables to default values */ 172 code = 0; 173 lock = "0"b; 174 vtoce_derived_volname = ""; 175 entry_name = ""; 176 link_retrieval = "0"b; 177 parent_check = "0"b; 178 entry_retrieval = "0"b; 179 object_retrieval = "0"b; 180 vtoce_volid (*) = "0"b; 181 uid = "0"b; 182 vdtd = "0"b; 183 emode = "0"b; 184 pmode = "0"b; 185 logged = "0"b; 186 bvlp, rvcp, rvcep = null; 187 contentsp, contents_namesp = null; 188 recursion_level = 0; 189 190 /* pick up static ptrs */ 191 skip = retv_data_.skip; 192 vlp = retv_data_.vlp; 193 /* copy args from input structure */ 194 dirname = retv_input.dirname; 195 ename = retv_input.ename; 196 197 /* Check to see if object in hierarchy. if so get what ever information we can about it. If not in the 198* hierarcy then the uid will be zero */ 199 200 status: 201 call hc_backup_$retv_status (dirname, ename, retv_input.access_class, retv_input.requestor, 202 retv_input.level, type, emode, pmode, uid, pvid, vtoce_volid, vdtd, code); 203 204 /* In cross retrieval case object must exist and must be a segment. Check that this is so */ 205 206 if retv_input.new_dirname ^= "" then do; 207 if recursion_level ^= 0 208 | uid = "0"b then do; 209 call ioa_$rsnnl ("Cannot locate ^a^[>^]^a for cross retrieval ", message, 0, 210 dirname, dirname ^= ">", ename); 211 call retv_notify_ (message, inputp, myname); 212 code = -1; 213 goto finish; 214 end; 215 if type ^= segment then do; 216 call ioa_$rsnnl ("Cross directory retrieval of ^a^[>^]^a not allowed", message, 0, 217 dirname, dirname ^= ">", ename); 218 call retv_notify_ (message, inputp, myname); 219 code = -1; 220 goto finish; 221 end; 222 end; 223 224 /* First check to see if requestor has the correct access. Access must be sufficient to modify the object 225* either directly or be able to set access at the parent level to do so. */ 226 227 if uid ^= "0"b & type ^= LINK then do; 228 if type = segment & ((emode & rw) = rw | (pmode & sm) = sm) then goto access_ok; 229 if (type = DIR | type = LINK) & ((emode & sm) = sm | (pmode & sm) = sm) then goto access_ok; 230 call ioa_$rsnnl ("Incorrect access to retrieve ^a^[>^]^a", message, 0, dirname, dirname ^= ">", ename); 231 code = -1; 232 call retv_notify_ (message, inputp, myname); 233 goto finish; 234 access_ok: 235 if parent_check then entry_retrieval = "1"b; 236 else object_retrieval = "1"b; 237 238 /* If dump information exists then determine the most recent volume id by back scanning the volume log for a match. 239* The volume log is located by converting the object's pvid to name and initiating that name in the sub-system dir. 240* If a time bracket has been specified then the found volume must fit within it. Save the volume name and id if found */ 241 242 if ^retv_data_.manual & (vtoce_volid (incr) ^= "0"b | 243 vtoce_volid (cons) ^= "0"b | 244 vtoce_volid (comp) ^= "0"b) then do; 245 call find_volume_log; 246 if bvlp = null then do; 247 no_volog: call retv_report_$error_output (code, myname, "Unable to locate ^a.volog", psearch_name); 248 goto finish; 249 end; 250 if ^lock then call lock_volume_log; 251 if code ^= 0 then do; 252 volog_lock_err: call retv_report_$error_output (code, myname, "Error locking ^a", psearch_name); 253 goto finish; 254 end; 255 lock = "1"b; 256 257 incr_open_time = 0; 258 cons_open_time = 0; 259 comp_open_time = 0; 260 incr_close_time = 0; 261 cons_close_time = 0; 262 comp_close_time = 0; 263 incr_indx, cons_indx, comp_indx = 0; 264 265 do idx = backup_volume_log.next to 1 by -1; 266 bvlep = addr (backup_volume_log.array (idx)); 267 if vtoce_volid (incr) ^= "0"b & vtoce_volid (incr) = bvle.volid then do; 268 incr_open_time = bvle.open_time; 269 incr_close_time = bvle.close_time; 270 incr_indx = idx; 271 end; 272 else if vtoce_volid (cons) ^= "0"b & vtoce_volid (cons) = bvle.volid then do; 273 cons_open_time = bvle.open_time; 274 cons_close_time = bvle.close_time; 275 cons_indx = idx; 276 end; 277 else if vtoce_volid (comp) ^= "0"b & vtoce_volid (comp) = bvle.volid then do; 278 comp_open_time = bvle.open_time; 279 comp_close_time = bvle.close_time; 280 comp_indx = idx; 281 end; 282 end; 283 284 if retv_input.to_time ^= 0 then do; 285 if incr_open_time > retv_input.to_time then incr_indx = 0; 286 if cons_open_time > retv_input.to_time then cons_indx = 0; 287 if comp_open_time > retv_input.to_time then comp_indx = 0; 288 end; 289 290 if retv_input.from_time ^= 0 then do; 291 if incr_close_time < retv_input.from_time then incr_indx = 0; 292 if cons_close_time < retv_input.from_time then cons_indx = 0; 293 if comp_close_time < retv_input.from_time then comp_indx = 0; 294 end; 295 296 latest_indx = max (incr_indx, cons_indx, comp_indx); 297 if latest_indx ^= 0 then do; 298 bvlep = addr (backup_volume_log.array (latest_indx)); 299 vtoce_derived_volname = bvle.volname; 300 end; 301 302 end; 303 304 /* Now search the volume log as if there was no dump information, as well there might. Find the 305* volume log, if not already found, lock it, and back scan it. If no time bracket is specified then we 306* skip over incremental tapes that are superceeded by consolidated tape and consolidated tapes that are 307* superceeded by complete dumps. If a time bracket is specified then we look at all the 308* dump volumes in case the object was deleted prematurely. For each dump volume we find we add it to the 309* volume list. Once the volume list is complete then try to save time by searching the contents seg for that 310* volume if it is available. If it is and the object is not found in it then we 311* can skip that dump volume. If the contents seg can not be found then the object is assumed to be on the 312* dump volume. For each dump volume a search request is entered into the volume control segment. 313* If this segemnt does not exist then it is created */ 314 315 if ^retv_data_.manual 316 | (retv_data_.manual & recursion_level > 1) then do; 317 if bvlp = null then do; 318 call find_volume_log; 319 if bvlp = null then goto no_volog; 320 end; 321 322 if ^lock then do; 323 call lock_volume_log; 324 if code ^= 0 then goto volog_lock_err; 325 end; 326 327 lock = "1"b; 328 vlx = 0; 329 if retv_input.to_time = 0 & retv_input.from_time = 0 then do; 330 incr_open_time = 0; 331 cons_open_time = 0; 332 comp_open_time = 0; 333 cons_cycle_uid = "0"b; 334 comp_cycle_uid = "0"b; 335 do idx = backup_volume_log.next to 1 by -1; 336 bvlep = addr (backup_volume_log.array (idx)); 337 if bvle.dump_type = incr then do; 338 if cons_open_time ^= 0 | comp_open_time ^= 0 then do; 339 if (cons_open_time ^= 0 & cons_open_time < bvle.close_time) 340 | (comp_open_time ^= 0 & comp_open_time < bvle.close_time) 341 then call update_volume_list; 342 end; 343 else do; 344 call update_volume_list; 345 incr_open_time = get_open_time (); 346 end; 347 end; 348 else if bvle.dump_type = cons then do; 349 if comp_open_time ^= 0 then do; 350 if comp_open_time < bvle.close_time 351 | cons_cycle_uid = bvle.cycle_uid then call update_volume_list; 352 end; 353 else do; 354 call update_volume_list; 355 cons_open_time = get_open_time (); 356 cons_cycle_uid = bvle.cycle_uid; 357 end; 358 end; 359 else if bvle.dump_type = comp then do; 360 if comp_cycle_uid ^= "0"b then do; 361 if comp_cycle_uid = bvle.cycle_uid then call update_volume_list; 362 comp_open_time = get_open_time (); 363 end; 364 else do; 365 comp_cycle_uid = bvle.cycle_uid; 366 comp_open_time = get_open_time (); 367 call update_volume_list; 368 end; 369 end; 370 end; 371 end; 372 else do idx = backup_volume_log.next to 1 by -1; 373 bvlep = addr (backup_volume_log.array (idx)); 374 call update_volume_list; 375 end; 376 end; 377 else do; 378 done = "0"b; 379 do vlx = 1 by 1 while (^done); 380 call get_volname; 381 retv_volume_list (vlx).open_time = 0; 382 if retv_volume_list (vlx).volname = "." then done = "1"b; 383 else retv_volume_list (vlx).use = "1"b; 384 end; 385 retv_volume_list.next = vlx - 2; 386 end; 387 do rvlx = 1 to retv_volume_list.next; 388 if retv_volume_list (rvlx).use then do; 389 volname = retv_volume_list (rvlx).volname; 390 volid = retv_volume_list (rvlx).volid; 391 open_time = retv_volume_list (rvlx).open_time; 392 dump_type = retv_volume_list (rvlx).dump_type; 393 call find_contents_seg; 394 if contentsp = null then do; 395 no_contents_seg = "1"b; 396 if entry_retrieval 397 | retv_input.to_time ^= 0 398 | retv_input.from_time ^= 0 399 | vtoce_derived_volname = volname 400 | vtoce_derived_volname = "" then do; 401 call log_uid; 402 if ^(retv_volume_list (rvlx).announced) then do; 403 call retv_report_$online_output (0, myname, 404 "May search volume ^a because contents segment not available", volname); 405 retv_volume_list (rvlx).announced = "1"b; 406 end; 407 end; 408 end; 409 else do; 410 call search_contents_seg (contents_idx, found); 411 if found then call log_uid; 412 call term_contents_segs; 413 end; 414 end; 415 end; 416 end; 417 418 /* We come here if an entry must be recovered, either because it does not already exist, or because the request 419* is for a link. If the entry does not exist then we reset dirname and ename to indicate that it is the 420* parent directory that is wanted. */ 421 422 else do; 423 recursion_level = recursion_level + 1; 424 if type = LINK then link_retrieval = "1"b; 425 parent_check = "1"b; 426 entry_name = ename; 427 old_dirname = dirname; 428 call expand_pathname_ (old_dirname, dirname, ename, code); 429 if code ^= 0 then do; 430 call ioa_$rsnnl ("Unable to expand ^a^[>^]^a", message, 0, retv_input.dirname, 431 retv_input.dirname ^= ">", retv_input.ename); 432 code = -1; 433 call retv_notify_ (message, inputp, myname); 434 goto finish; 435 end; 436 goto status; 437 end; 438 finish: 439 if code ^= 0 & code ^= -1 then do; 440 call retv_report_$error_output (code, myname, "ERROR"); 441 code = 0; 442 end; 443 if ^logged & (code ^= -1) then do; 444 call ioa_$rsnnl ("Online records indicate that ^a^[>^]^a^[>^a^;^s^] can not be found for^/retrieval of ^a^[>^]^a", 445 message, (0), dirname, dirname ^= ">", ename, entry_name ^= "", entry_name, retv_input.dirname, retv_input.dirname ^= ">", retv_input.ename); 446 call retv_notify_ (message, inputp, myname); 447 code = -1; 448 end; 449 if lock then call unlock_volume_log; 450 return; 451 sort: entry (a_rvcp, code); 452 453 /* This entry re sorts the entries in the control seg by the contents 454* index. This index marks the relative position on the dump medium of each file. 455* Thus sorting the entries allows the scan function in retrieve_from_volume_ 456* to operate a max efficiency. 457**/ 458 rvcp = a_rvcp; 459 code = 0; 460 do sortx = 1 to retv_vol_control.n_entries; 461 do sorty = 1 to retv_vol_control.n_entries; 462 if retv_vol_control.array (sorty).in_use then do; 463 if retv_vol_control.array (sorty).contentsx < retv_vol_control.array (sortx).contentsx then do; 464 local_rvce = retv_vol_control.array (sortx); 465 retv_vol_control.array (sortx) = retv_vol_control.array (sorty); 466 retv_vol_control.array (sorty) = local_rvce; 467 end; 468 end; 469 end; 470 end; 471 return; 472 473 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 474 475 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 476 477 478 update_volume_list: proc; 479 dcl (new_entry, use) bit (1); 480 dcl (vlx, sortx) fixed bin; 481 482 /* This proc is called to add a dump volume to the volume list associated with some object. 483* It is added to the list if it contains any segments or directories from this volume and 484* it is not already in the list or in the dont use list. 485* If the dump volume was created with a different dim then the one that will 486* be used to read it the operator is queried as to wheter he wants to use it. 487* If not it is added to the don't use list so the question is asked only once */ 488 489 if bvle.dir_num = 0 & bvle.seg_num = 0 then return; 490 491 do sortx = 1 to retv_skip_list.next; 492 if bvle.volname = retv_skip_list (sortx).volname then return; /* dont use it */ 493 end; 494 do sortx = 1 to retv_volume_list.next while 495 (retv_volume_list (sortx).volname ^= bvle.volname 496 & retv_volume_list (sortx).volid ^= bvle.volid); /* already in list */ 497 end; 498 if sortx > retv_volume_list.next then do; /* add or update to the list */ 499 vlx, retv_volume_list.next = retv_volume_list.next + 1; 500 new_entry = "1"b; 501 end; 502 else do; 503 new_entry = "0"b; 504 vlx = sortx; 505 end; 506 use = "1"b; 507 if retv_input.to_time ^= 0 & bvle.open_time > retv_input.to_time then use = "0"b; 508 if bvle.open_time > retv_input.submission_time then use = "0"b; 509 if retv_input.from_time ^= 0 & bvle.close_time < retv_input.from_time then use = "0"b; 510 retv_volume_list (vlx).volname = bvle.volname; 511 retv_volume_list (vlx).volid = bvle.volid; 512 retv_volume_list (vlx).use = use | retv_volume_list (vlx).use; 513 if new_entry then do; 514 retv_volume_list (vlx).open_time = bvle.open_time; 515 retv_volume_list (vlx).announced, retv_volume_list (vlx).unused = "0"b; 516 end; 517 else retv_volume_list (vlx).open_time = min (bvle.open_time, retv_volume_list (vlx).open_time); 518 retv_volume_list (vlx).close_time = max (retv_volume_list (vlx).close_time, bvle.close_time); 519 retv_volume_list (vlx).dump_type = bvle.dump_type; 520 521 if bvle.io_module ^= retv_data_.io_module then do; 522 query_info.version = query_info_version_5; 523 call command_query_ (addr (query_info), answer, myname, "^a ^a ^a ^a^/^a", 524 "io outer module", bvle.io_module, "which wrote volume", bvle.volname, 525 "different than that specified to read volume. Do you wish to use the volume ?"); 526 if answer = "no" then do; 527 retv_volume_list (vlx).use = "0"b; 528 retv_skip_list.next = retv_skip_list.next + 1; 529 retv_skip_list (retv_skip_list.next).volname = bvle.volname; 530 end; 531 end; 532 return; 533 end update_volume_list; 534 535 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 536 537 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 538 539 540 find_volume_log: proc; 541 542 /* This proc is called to located the volume log associated with an object. It does this by converting 543* the physical volume id of the object to a physical volume name and searching for it in the 544* sub-system directory. If the volume log is found a few validity checks are made also. */ 545 546 bvlp = null; 547 psearch_name = ""; 548 call mdc_$find_volname (pvid, psearch_name, lsearch_name, code); 549 if code ^= 0 then do; 550 call retv_report_$error_output (code, myname, "Unable to convert pvid to pvname"); 551 return; 552 end; 553 call suffixed_name_$make (psearch_name, "volog", search_name, code); 554 if code ^= 0 then do; 555 call retv_report_$error_output (code, myname, "Unable to construct ^a.volog", psearch_name); 556 return; 557 end; 558 on seg_fault_error begin; 559 bvlp = null; 560 code = error_table_$segfault; 561 goto find_volume_log_ret; 562 end; 563 call hcs_$initiate ((retv_data_.sys_dir), search_name, "", 0, 0, bvlp, code); 564 if bvlp ^= null then do; 565 code = 0; 566 if backup_volume_log.pvname = pvname 567 & backup_volume_log.pvid = pvid 568 & (backup_volume_log.version = backup_volume_log_version_1) | 569 (backup_volume_log.version = backup_volume_log_version_2) | 570 (backup_volume_log.version = backup_volume_log_version_3) then ; 571 else do; 572 bvlp = null; 573 code = error_table_$bad_segment; 574 call retv_report_$error_output (code, myname, "Invalid volog ^a>^a found", 575 retv_data_.sys_dir, search_name); 576 end; 577 end; 578 find_volume_log_ret: 579 if bvlp = null then call retv_report_$error_output (code, myname, "Unable to locate ^a>^a", 580 retv_data_.sys_dir, search_name); 581 return; 582 end find_volume_log; 583 584 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 585 586 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 587 588 589 lock_volume_log: proc; 590 591 /* This proc locks the volume log. It treats invalid lock ids and mylocks as recoverable errors. For all others 592* it returns an error code and leaves the volume log unlocked */ 593 594 call set_lock_$lock (backup_volume_log.lock, -1, code); 595 if code ^= 0 then if code = error_table_$invalid_lock_reset then code = 0; 596 if code = error_table_$locked_by_this_process then do; 597 call retv_report_$error_output (code, myname, "Volume log ^a", psearch_name); 598 code = 0; 599 call unlock_volume_log; 600 call lock_volume_log; 601 end; 602 return; 603 end lock_volume_log; 604 605 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 606 607 608 unlock_volume_log: proc; 609 610 /* This proc unlocks the volume log. */ 611 612 call set_lock_$unlock (backup_volume_log.lock, ignore); 613 return; 614 end unlock_volume_log; 615 616 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 617 618 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 619 620 621 create_control_seg: proc; 622 dcl (nvol_idx, insert_idx) fixed bin; 623 624 /* This proc is caled to create a volume control seg for some specified dump volume. 625* The volume control seg is created in the process directory and a pointer to 626* it is mainted in a static array. The order of pointers in the static array is very important for 627* it determines the order in which the dump volumes will be read. For this reason empty volume control 628* segments may be created as place markers so that a time wise order is maintained. Once the volume 629* control segment has been located and verified a set of checks is carried out to see if the object 630* should be recovered(searched for) from this dump volume. If so an entry is made in the 631* control segment and the queue entry is updated to reflect this. 632**/ 633 634 rvcp = null; 635 call suffixed_name_$make (volname, "control", control_name, code); 636 if code ^= 0 then do; 637 call retv_report_$error_output (code, myname, "Unable to construct ^a.control", volname); 638 return; 639 end; 640 call hcs_$make_seg ("", control_name, "", 01010b, rvcp, code); 641 if rvcp = null then do; 642 bad_seg: call retv_report_$error_output (code, myname, 643 "Unable to create control seg ^a", control_name); 644 return; 645 end; 646 /* new control seg */ 647 if code = 0 then do; 648 retv_vol_control.version = retv_vol_control_version_1; 649 retv_vol_control.volname = volname; 650 retv_vol_control.volid = volid; 651 retv_vol_control.open_time = open_time; 652 retv_vol_control.dump_type = dump_type; 653 do nvol_idx = 1 to retv_data_.nvol 654 while (retv_data_.rvcp (nvol_idx) -> retv_vol_control.open_time > open_time); 655 end; 656 if nvol_idx > retv_data_.nvol then do; /* no match */ 657 if retv_data_.nvol = hbound (retv_data_.rvcp, 1) then do; 658 rvcp = null; 659 call retv_report_$error_output (0, myname, "Limit of ^d control segs exceeded.", 660 hbound (retv_data_.rvcp, 1)); 661 code = error_table_$action_not_performed; 662 return; 663 end; 664 retv_data_.nvol = retv_data_.nvol + 1; 665 retv_data_.rvcp (retv_data_.nvol) = rvcp; 666 end; 667 else do; 668 insert_idx = nvol_idx; 669 do nvol_idx = retv_data_.nvol to insert_idx by -1; 670 retv_data_.rvcp (nvol_idx + 1) = retv_data_.rvcp (nvol_idx); 671 end; 672 retv_data_.rvcp (insert_idx) = rvcp; 673 retv_data_.nvol = retv_data_.nvol + 1; 674 end; 675 end; 676 677 code = 0; 678 end create_control_seg; 679 680 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 681 682 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 683 684 685 log_uid: proc; 686 687 688 /* This proc is called to insert a retrieval request in a specific control seg */ 689 690 call create_control_seg; 691 if rvcp = null then goto finish; 692 retv_vol_control.n_entries = retv_vol_control.n_entries + 1; 693 retv_vol_control.in_use_cnt = retv_vol_control.in_use_cnt + 1; 694 rvcep = addr (retv_vol_control.array (retv_vol_control.n_entries)); 695 rvce.in_use = "1"b; 696 rvce.uid = uid; 697 rvce.contentsx = contents_idx; 698 rvce.vdtd = vdtd; 699 rvce.dirname = dirname; 700 rvce.ename = ename; 701 rvce.entry_name = entry_name; 702 rvce.to_time = retv_input.to_time; 703 rvce.from_time = retv_input.from_time; 704 rvce.queue = retv_data_.queue; 705 rvce.retv_ms_id = retv_input.retv_ms_id; 706 rvce.entry_retrieval = entry_retrieval; 707 rvce.link_retrieval = link_retrieval; 708 rvce.no_contents_seg = no_contents_seg; 709 rvce.object_retrieval = object_retrieval; 710 rvce.vtoce_volname = (vtoce_derived_volname ^= ""); 711 rvce.previous = retv_input.previous; 712 if retv_input.uid = "0"b then do; 713 retv_input.entry_name = rvce.entry_name; 714 retv_input.entry_retrieval = entry_retrieval; 715 retv_input.uid = rvce.uid; 716 call update_queue_message; 717 end; 718 logged = "1"b; 719 return; 720 end log_uid; 721 722 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 723 724 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 725 726 727 find_contents_seg: proc; 728 729 /* This proc locates the contents segment, if it exists, in the sub-system directory. If found it performs 730* a few validity tests to be sure. The contents segment of a dump volume contains an array of uids, 731* one for each object that was written on this volume */ 732 733 contentsp = null; 734 call suffixed_name_$make (volname, "contents", search_name, code); 735 if code ^= 0 then do; 736 call retv_report_$error_output (code, myname, "Unable to construct ^a.contents", volname); 737 return; 738 end; 739 call hcs_$initiate (rtrim (retv_data_.sys_dir) || ">contents", search_name, "", 0, 0, contentsp, code); 740 on seg_fault_error begin; /* it may not be there */ 741 contentsp = null; 742 code = error_table_$segfault; 743 goto find_contents_seg_ret; 744 end; 745 if contentsp ^= null then do; 746 if backup_volume_contents.version ^= backup_volume_contents_version_3 747 then call convert_contents_seg; 748 if contentsp ^= null then do; 749 if (backup_volume_contents.volname = volname 750 & backup_volume_contents.volid = volid 751 & backup_volume_contents.version = backup_volume_contents_version_3) then return; 752 else do; 753 contentsp = null; 754 code = error_table_$bad_segment; 755 call retv_report_$error_output (code, myname, "Invalid contents seg ^a>contents>^a", 756 retv_data_.sys_dir, search_name); 757 end; 758 end; 759 end; 760 find_contents_seg_ret: 761 if contentsp = null then 762 call retv_report_$error_output (code, myname, "Unable to access ^a>contents>^a", 763 retv_data_.sys_dir, search_name); 764 return; 765 end find_contents_seg; 766 767 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 768 769 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 770 771 772 search_contents_seg: proc (contents_idx, found); 773 dcl (contents_idx, startx, endx) fixed bin; 774 dcl found bit (1); 775 776 /* This proc searchs the contents segment for a match. If one is found then 777* a code of zero is returned */ 778 779 found = "0"b; 780 do contents_idx = backup_volume_contents.next to 1 by -1; 781 if backup_volume_contents.uid (contents_idx) = uid then do; 782 if entry_retrieval & backup_volume_contents.offset (contents_idx) > 0 then do; 783 call find_contents_names_seg; 784 if contents_namesp ^= null then do; 785 nsp = addr (based_char_string); 786 lns = index (based_char_string, ">>") + 1; 787 if index (name_string, rtrim (entry_name)) ^= 0 then do; 788 startx = 1; 789 endx = index (name_string, ">"); 790 do while (endx > 0); 791 test_name = substr (name_string, startx, endx - 1); 792 if test_name = entry_name then goto gotit; 793 startx = startx + endx; 794 endx = index (substr (name_string, startx), ">"); 795 end; 796 if substr (name_string, startx, lns - startx - 1) = entry_name then goto gotit; 797 end; 798 end; 799 call msf_manager_$close (fcbp); 800 end; 801 else do; 802 gotit: found = "1"b; 803 return; 804 end; 805 end; 806 end; 807 return; 808 end search_contents_seg; 809 810 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 811 812 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 813 814 815 update_queue_message: proc; 816 817 /* This proc updates an existant message in the retrievers privite queue */ 818 819 retry_update: call message_segment_$update_message_index (retv_data_.qidx (retriever), size (retv_input) * 36, 820 retv_input.retv_ms_id, inputp, code); 821 if code = error_table_$bad_segment then do; 822 call retv_report_$error_output (code, myname, "Private queue has been salvaged"); 823 goto retry_update; 824 end; 825 if code ^= 0 then call retv_report_$error_output (code, myname, "Unable to update request in private queue"); 826 end update_queue_message; 827 828 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 829 830 831 get_volname: proc; 832 833 /* This proc reads a dump volume name and converts it to a volume id. Volume names are restricted to two or less 834* acsii characters preceeding a numeric value(eg ic12345 is ok but qwqw01 is not). */ 835 836 request: call ioa_$nnl ("Type retrieval volume name: "); /* Make up request line. */ 837 call iox_$get_line (iox_$user_input, addr (retv_volume_list (vlx).volname), 838 length (retv_volume_list (vlx).volname), nelemt, code); 839 if code ^= 0 then do; 840 call ioa_ ("input error"); 841 goto request; 842 end; 843 retv_volume_list (vlx).volname = substr (retv_volume_list (vlx).volname, 1, nelemt - 1); /* strip new line */ 844 if retv_volume_list (vlx).volname = "." then return; 845 call set_volid_; 846 if code ^= 0 then do; 847 call ioa_ ("Invalid volume id ^a specified.", retv_volume_list (vlx).volname); 848 goto request; 849 end; 850 return; 851 end get_volname; 852 853 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 854 855 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 856 857 858 set_volid_: proc; 859 860 /* This proc constructs a volume id from a volume name. This is a interim measure until all dump volume are registered 861* and have a unique id. This construction restricts the volume name to two or less non numeric characters followed 862* by any numeric value lest then 262144. */ 863 864 /* when rcp_ interface is defined 865* call rcp_$volname_info (retv_volume_list(vlx).volname, retv_volume_list(vlx).volid, code); 866* if code ^= 0 then 867* call retv_report_$error_output (code, myname, "Unable to set volid"); 868* 869* but until then fudge it */ 870 871 872 start_numeric = search (retv_volume_list (vlx).volname, "0123456789"); 873 if start_numeric > 3 | start_numeric = 0 then do; 874 bad_volid: code = error_table_$bad_volid; 875 return; 876 end; 877 else do; 878 if start_numeric > 1 then volume_id.char = substr (retv_volume_list (vlx).volname, 1, start_numeric - 1); 879 else volume_id.char = ""; 880 char_num = substr (retv_volume_list (vlx).volname, start_numeric, 881 length (retv_volume_list (vlx).volname) - start_numeric); 882 num = cv_dec_check_ (char_num, code); 883 if code ^= 0 then goto bad_volid; 884 volume_id.num = num; 885 end; 886 retv_volume_list (vlx).volid = unspec (volume_id); 887 return; 888 end set_volid_; 889 890 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 891 892 893 get_open_time: proc returns (fixed bin (71)); 894 dcl temp fixed bin (71); 895 dcl jdx fixed bin; 896 if bvle.dump_type = incr then return (bvle.open_time); 897 do jdx = idx to 1 by -1; 898 if backup_volume_log.array (jdx).cycle_uid = bvle.cycle_uid then 899 temp = backup_volume_log.array (jdx).open_time; 900 end; 901 return (temp); 902 903 end get_open_time; 904 905 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 906 907 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 908 909 910 find_contents_names_seg: proc; 911 912 /* This proc locates the contents_names segment, if it exists, in the sub-system directory. 913* The contents_names segment of a dump volume contains the name space 914* of the dirs dumped on the dump volume. */ 915 916 contents_namesp = null; 917 call suffixed_name_$make (volname, "contents_names", search_name, code); 918 if code ^= 0 then do; 919 call retv_report_$error_output (code, myname, "Unable to construct ^a.contents_name", volname); 920 return; 921 end; 922 on seg_fault_error begin; /* it may not be there */ 923 contents_namesp = null; 924 goto find_contents_names_seg_ret; 925 end; 926 call msf_manager_$open (rtrim (retv_data_.sys_dir) || ">contents", search_name, fcbp, code); 927 if code ^= 0 then do; 928 call retv_report_$error_output (code, myname, "Unable to open ^a>contents>^a", 929 retv_data_.sys_dir, search_name); 930 return; 931 end; 932 call msf_manager_$get_ptr (fcbp, (backup_volume_contents.component (contents_idx)), "0"b, 933 contents_namesp, 0, code); 934 if code ^= 0 then 935 call retv_report_$error_output (code, myname, "Unable to get ptr to component ^d of ^a>contents>^a", 936 backup_volume_contents.component (contents_idx), retv_data_.sys_dir, search_name); 937 find_contents_names_seg_ret: 938 return; 939 end find_contents_names_seg; 940 941 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 942 943 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 944 945 946 convert_contents_seg: proc; 947 dcl contents_idx fixed bin; 948 call get_temp_segment_ (myname, ncp, code); 949 if code ^= 0 then do; 950 call retv_report_$online_output (code, myname, "Unable to get temp for contents seg conversion"); 951 contentsp = null; 952 return; 953 end; 954 ncp -> backup_volume_contents.version = backup_volume_contents_version_3; 955 if backup_volume_contents.version = 2 then do; 956 ncp -> backup_volume_contents.volname = v2_backup_volume_contents.volname; 957 ncp -> backup_volume_contents.volid = v2_backup_volume_contents.volid; 958 ncp -> backup_volume_contents.next = v2_backup_volume_contents.next; 959 end; 960 else if backup_volume_contents.version = 1 then do; 961 ncp -> backup_volume_contents.volname = v1_backup_volume_contents.volname; 962 ncp -> backup_volume_contents.volid = v1_backup_volume_contents.volid; 963 ncp -> backup_volume_contents.next = v1_backup_volume_contents.next; 964 end; 965 else do; 966 call retv_report_$online_output (0, myname, "Unable to convert ^a.contents because of unknown version ^d", 967 volname, backup_volume_contents.version); 968 contentsp = null; 969 call release_temp_segment_ (myname, ncp, ignore); 970 return; 971 end; 972 do contents_idx = 1 to ncp -> backup_volume_contents.next; 973 if backup_volume_contents.version = 1 then do; 974 ncp -> backup_volume_contents (contents_idx).uid = v1_backup_volume_contents (contents_idx).uid; 975 ncp -> backup_volume_contents (contents_idx).component = 0; 976 ncp -> backup_volume_contents (contents_idx).offset = 0; 977 ncp -> backup_volume_contents (contents_idx).tape_loc = 0; 978 end; 979 else if backup_volume_contents.version = 2 then do; 980 if v2_backup_volume_contents (contents_idx).offset = -1 then do; 981 ncp -> backup_volume_contents (contents_idx).component = 0; 982 ncp -> backup_volume_contents (contents_idx).offset = 0; 983 end; 984 else do; 985 ncp -> backup_volume_contents (contents_idx).component = 986 v2_backup_volume_contents (contents_idx).component; 987 ncp -> backup_volume_contents (contents_idx).offset = 988 v2_backup_volume_contents (contents_idx).offset; 989 end; 990 ncp -> backup_volume_contents (contents_idx).uid = v2_backup_volume_contents (contents_idx).uid; 991 end; 992 end; 993 call hcs_$fs_move_seg (ncp, contentsp, 1, code); 994 if code ^= 0 then do; 995 call retv_report_$online_output (code, myname, "Unable to move converted contents seg"); 996 contentsp = null; 997 end; 998 call release_temp_segment_ (myname, ncp, ignore); 999 end convert_contents_seg; 1000 1001 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1002 1003 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1004 1005 1006 term_contents_segs: proc; 1007 dcl segp ptr; 1008 1009 /* This proc terminates the contents and contents name segs */ 1010 1011 do segp = contentsp; 1012 if segp ^= null then 1013 call hcs_$terminate_noname (segp, code); 1014 if code ^= 0 then call retv_report_$error_output (code, myname, "Unable to terminate contents segs"); 1015 end; 1016 1017 end term_contents_segs; 1018 1019 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1020 1 1 /* BEGIN INCLUDE FILE ... retv_data_.incl.pl1 ... 8/76 */ 1 2 1 3 1 4 1 5 /****^ HISTORY COMMENTS: 1 6* 1) change(86-11-17,GWMay), approve(86-11-17,MCR7445), audit(86-11-19,GDixon), 1 7* install(86-11-21,MR12.0-1223): 1 8* Changed declaration of queue_dir from constant to just internal static so 1 9* that the entrypoints "test" in the err and retrieve_from_volume requests 1 10* are able to modify the value. 1 11* 2) change(88-08-10,GWMay), approve(88-10-05,MCR8005), audit(88-10-12,Farley), 1 12* install(88-10-17,MR12.2-1173): 1 13* Added pointer and length values for use as an input_buffer for 1 14* intermediate reads. 1 15* END HISTORY COMMENTS */ 1 16 1 17 1 18 dcl retv_data_version_1 fixed bin static init (1) options(constant); /* version of data base */ 1 19 1 20 /* queue_dir should not be declared options (constant). $test entrypoints in */ 1 21 /* enter_retrieval_request and retrieve_from_volume programs modify it. */ 1 22 1 23 dcl queue_dir char (168) int static init (">daemon_dir_dir>volume_retriever"); 1 24 dcl user fixed bin static init (1) options (constant); 1 25 dcl retriever fixed bin static init (2) options (constant); 1 26 1 27 dcl 1 retv_data_ external static aligned, 1 28 2 version fixed bin, /* version of structure */ 1 29 2 fixed, 1 30 3 qidx (2) fixed bin, /* indexs of queues */ 1 31 3 queue fixed bin, /* mseg queue */ 1 32 3 nvol fixed bin, /* number of volume control segments */ 1 33 3 spare fixed bin, 1 34 3 input_buffer_len fixed bin (21), /* length of the data in the read buffer */ 1 35 3 input_buffer_start fixed bin (21), /* position in read buffer where new data begins */ 1 36 2 chars, 1 37 3 sys_dir char (168), /* system dir where files live */ 1 38 3 last_valid_vtoce_ename char (32), /* last valid entry name from vtoce */ 1 39 3 last_volname char (32), /* last volume mounted */ 1 40 3 io_module char (32), /* name of io outer module */ 1 41 3 input_volume_desc char (256), /* alternate input attach description */ 1 42 2 bits, 1 43 3 last_valid_puid (16) bit (36), /* last valid uid pathname */ 1 44 3 flags, 1 45 4 manual bit (1) unal, /* if on operator will tell us what tapes to use */ 1 46 4 arg_init bit (1) unal, /* if on indicates that args have been processed */ 1 47 4 err_online bit (1) unal, /* if on causes errors to be printed */ 1 48 4 disable_error_report bit (1) unal, /* if on - no errors are reported */ 1 49 4 all bit (1) unal, /* if on indicates all queues are processed */ 1 50 4 accounting bit (1) unal, /* if on enable accounting */ 1 51 4 debug bit (1) unal, /* if on, enable debugging features */ 1 52 4 long bit(1) unal, /* if on enable long messages */ 1 53 2 ptrs, 1 54 3 page_buffer_ptr ptr, /* ptr to paged read buffer */ 1 55 3 input_buffer_ptr ptr, /* ptr to read buffer */ 1 56 3 skip ptr, /* ptr to skip_list */ 1 57 3 rasp ptr, /* ptr to accounting seg */ 1 58 3 input_iocbp ptr, /* iocb ptr for input */ 1 59 3 error_iocbp ptr, /* iocb ptr for error output */ 1 60 3 areap ptr, /* ptr to system area */ 1 61 3 contentsp ptr, /* ptr to most recent contents seg from input volume */ 1 62 3 nlp ptr, /* ptr to name array for branch being retrieved */ 1 63 3 aclp ptr, /* ptr to acl array for branch being retrieved */ 1 64 3 recordp ptr, /* ptr to last read volume record */ 1 65 3 objectp ptr, /* ptr to last read segmet or directory */ 1 66 3 vlp ptr, /* ptr to last reload group generated */ 1 67 3 rvcp (1000) ptr; /* ptrs to volume control segments */ 1 68 1 69 /* END INCLUDE FILE ... retv_data_.incl.pl1 */ 1021 1022 2 1 /* BEGIN INCLUDE FILE ... retv_volume_list.incl.pl1 ... 8/76 */ 2 2 /* Changed to include the announced field ... GAT 8/83 */ 2 3 2 4 dcl vlp ptr; 2 5 2 6 dcl 1 retv_volume_list based (vlp) aligned, 2 7 2 next fixed bin, 2 8 2 array (1 : 1 refer (retv_volume_list.next)), 2 9 3 volname char (32), 2 10 3 volid bit (36), 2 11 3 open_time fixed bin (71), 2 12 3 close_time fixed bin(71), 2 13 3 dump_type fixed bin, 2 14 3 flags, 2 15 4 use bit (1) unal, 2 16 4 announced bit (1) unal, 2 17 4 unused bit(34) unal; 2 18 2 19 /* END INCLUDE FILE ... retv_volume_list.incl.pl1 */ 1023 3 1 /* BEGIN INCLUDE FILE ... retv_request.incl.pl1 ... June 1976 */ 3 2 3 3 dcl requestp ptr; 3 4 3 5 dcl retv_request_version_2 fixed bin int static init (2) options (constant); 3 6 3 7 dcl 1 retv_request based (requestp) aligned, 3 8 2 header like queue_msg_hdr, 3 9 2 bits, 3 10 3 subtree bit (1), /* on if sub-tree retrieval desired */ 3 11 3 dirs bit (1), /* on if only subtree dirs desired */ 3 12 3 segs bit (1), /* on if only subtree segments desired */ 3 13 3 previous bit (1), /* on if prior object desired */ 3 14 2 fixed_bin, 3 15 3 version fixed bin, /* version of structure */ 3 16 3 to_time fixed bin (71), /* latest time to start search from */ 3 17 3 from_time fixed bin (71), /* from_time time not to search past */ 3 18 2 chars, 3 19 3 new_dirname char (168), /* cross retrieval directory name */ 3 20 3 new_ename char (32); /* cross retrieval entry name */ 3 21 3 22 /* END INCLUDE FILE ... retv_request.incl.pl1 */ 1024 1025 4 1 /* BEGIN INCLUDE FILE ... queue_msg_hdr.incl.pl1 */ 4 2 4 3 /* This is the message header used for standard system queue messages, namely: 4 4* IO daemon requests, absentee requests, retrieval requests. 4 5**/ 4 6 4 7 /* Written by Jerry Whitmore, Spring 1978. 4 8* Modified by T. Casey, November 1978, to add values for state. 4 9* Modified by R. Kovalcik, June 1982, defer_until_process_terminataion 4 10**/ 4 11 4 12 dcl 1 queue_msg_hdr based aligned, /* standard header for all system queue messages */ 4 13 2 msg_time fixed bin (71), /* date and time of request */ 4 14 2 hdr_version fixed bin, /* version of this declaration */ 4 15 2 dirname char (168), /* directory name */ 4 16 2 ename char (32), /* entry name of file requested */ 4 17 2 message_type fixed bin, /* message format descriptor */ 4 18 /* 0 = absentee request */ 4 19 /* 1 = print request */ 4 20 /* 2 = punch request */ 4 21 /* 3 = tape request */ 4 22 /* 4 = retrieval request */ 4 23 2 bit_flags, 4 24 3 delete_sw bit (1) unal, /* delete file when done */ 4 25 3 notify bit (1) unal, /* user wants to be notified */ 4 26 3 defer_until_process_termination bit (1) unal, /* don't process request until process terminates */ 4 27 3 padding bit (33) unal, 4 28 2 state fixed bin, /* stage of processing after being queued: 4 29* 0 = initial unprocessed state, 1 = deferred, 4 30* 2 = in state transition, 3 = eligible, 4 = running, 4 31* 5 = bumped, 6 = deferred_until_process_termination */ 4 32 2 orig_queue fixed bin, /* queue the request was submitted to */ 4 33 2 std_length fixed bin, /* length of std msg for this type */ 4 34 2 dupt_lock bit (36) aligned, /* lock word for defer until process termination */ 4 35 2 hdr_pad (3) fixed bin; 4 36 4 37 dcl queue_msg_hdr_version_1 fixed bin int static options (constant) init (1); /* current version of the header */ 4 38 4 39 /* Values for queue_msg_hdr.state */ 4 40 4 41 dcl STATE_UNPROCESSED fixed bin int static options (constant) init (0); 4 42 dcl STATE_DEFERRED fixed bin int static options (constant) init (1); 4 43 dcl STATE_TRANSITION fixed bin int static options (constant) init (2); 4 44 dcl STATE_ELIGIBLE fixed bin int static options (constant) init (3); 4 45 dcl STATE_RUNNING fixed bin int static options (constant) init (4); 4 46 dcl STATE_BUMPED fixed bin int static options (constant) init (5); 4 47 dcl STATE_DUPT fixed bin int static options (constant) init (6); 4 48 4 49 /* END INCLUDE FILE ... queue_msg_hdr.incl.pl1 */ 1026 1027 5 1 /* BEGIN INCLUDE FILE ... retv_input.incl.pl1 ... June 1976 */ 5 2 5 3 dcl inputp ptr; 5 4 5 5 5 6 dcl 1 retv_input based (inputp) aligned, 5 7 2 request like retv_request aligned, /* orignal request */ 5 8 2 bits, 5 9 3 dir_scanned bit (1), /* if on indicates that dir already scanned for subtree requests */ 5 10 3 proxy bit (1), /* on if request submitted as result of -all option */ 5 11 3 user_ms_id bit (72), /* uid of message in user queue */ 5 12 3 retv_ms_id bit(72), /* uid of message in retv queue */ 5 13 3 access_class bit (72), /* access class of requestor */ 5 14 3 uid bit (36), /* uid of object being retrieved */ 5 15 3 entry_retrieval bit (1), /* on if this is a entry retrieval */ 5 16 3 entry_recovered bit (1), /* on if entry recovered */ 5 17 3 in_progress bit (1), /* on if retrieval in progress */ 5 18 3 object_recovered bit (1), /* on if object finished */ 5 19 3 recovery_complete bit (1), /* on if recovery complete */ 5 20 3 skip_it bit (1), /* if on skip this request */ 5 21 3 volid bit (36), /* volid object recoverd from */ 5 22 2 fixed_bin, 5 23 3 level fixed bin, /* validation level of requestor */ 5 24 3 q_num fixed bin, /* queue number of user queue being serviced */ 5 25 3 errcode fixed bin (35), /* error code if retrieval failed */ 5 26 3 submission_time fixed bin (71), /* time request submitted */ 5 27 2 chars, 5 28 3 requestor char (32), /* qed */ 5 29 3 entry_name char (32); /* name of entry being retrieved */ 5 30 5 31 /* END INCLUDE FILE ... retv_input.incl.pl1 */ 1028 1029 6 1 /* BEGIN INCLUDE FILE ... retv_vol_control.incl.pl1 8/76 */ 6 2 6 3 dcl rvcp ptr; /* ptr to volume control segment */ 6 4 dcl rvcep ptr; /* ptr to entry in volume control segment */ 6 5 6 6 dcl retv_vol_control_version_1 fixed bin static init (1) options (constant); /* version of structure */ 6 7 6 8 dcl 1 retv_vol_control based (rvcp) aligned, 6 9 2 version fixed bin, /* version number */ 6 10 2 volname char (32), /* name of volume that this segment represents */ 6 11 2 volid bit (36), /* volume id of volume that this segment controls */ 6 12 2 open_time fixed bin (71), /* time this volume was opened */ 6 13 2 in_use_cnt fixed bin, /* number of in use entries */ 6 14 2 n_entries fixed bin, /* total number of entries */ 6 15 2 switches, 6 16 3 skip_query bit (1) unal, 6 17 3 unused bit (35) unal, 6 18 2 dump_type fixed bin, /* type of dump volume */ 6 19 2 pad (1) bit (36), 6 20 2 array (1 : 1 refer (retv_vol_control.n_entries)) like rvce aligned; /* array of entries */ 6 21 6 22 dcl 1 rvce aligned based (rvcep), 6 23 2 uid bit (36), /* uid of object being retrieved */ 6 24 2 contentsx fixed bin, /* index in contents seg */ 6 25 2 dirname char (168), /* parent directory pathname */ 6 26 2 ename char (32), /* entry name */ 6 27 2 entry_name char (32), /* name of entry being retrieved */ 6 28 2 queue fixed bin, /* queue request was taken from */ 6 29 2 retv_ms_id bit (72), /* id of request in retv queue */ 6 30 2 vdtd bit (36), /* volume dtd of object if previously dumped */ 6 31 2 to_time fixed bin (71), /* time not to retrived after */ 6 32 2 from_time fixed bin (71), /* time not to retrieve befor */ 6 33 2 flags, 6 34 (3 link_retrieval bit (1), /* on if link retrieval */ 6 35 3 entry_retrieval bit (1), /* on if entry retrieval */ 6 36 3 object_retrieval bit (1), /* on if object is to be retrieved */ 6 37 3 vtoce_volname bit (1), /* on if valid volume id found in vtoce */ 6 38 3 in_use bit (1), /* on if entry in use */ 6 39 3 previous bit (1), /* on if previous object to dtd wanted */ 6 40 3 no_contents_seg bit (1))unaligned, /* on if could not find contents segment */ 6 41 2 pad bit (36); 6 42 6 43 /* END INCLUDE FILE ... retv_vol_control.incl.pl1 */ 1030 1031 7 1 /* BEGIN INCLUDE FILE backup_volume_contents.incl.pl1 ... May 1976 */ 7 2 7 3 7 4 7 5 /****^ HISTORY COMMENTS: 7 6* 1) change(86-11-10,GWMay), approve(86-11-10,MCR7445), audit(86-11-19,GDixon), 7 7* install(86-11-21,MR12.0-1223): 7 8* increased the size of the offset field to fixed bin (18). 7 9* END HISTORY COMMENTS */ 7 10 7 11 7 12 dcl contentsp ptr; /* ptr to structure */ 7 13 7 14 dcl backup_volume_contents_version_3 fixed bin static init (3) options (constant); 7 15 7 16 7 17 dcl 1 v1_backup_volume_contents based (contentsp) aligned, 7 18 2 header like backup_volume_header aligned, 7 19 2 version fixed bin, /* version number of structure */ 7 20 2 volname char (32), /* volume name */ 7 21 2 volid bit (36), /* volume id */ 7 22 2 next fixed bin, /* index of next available slot in uid array */ 7 23 2 array (1: 1 refer (backup_volume_contents.next)), /* array of arrays of data objects on this output volume */ 7 24 3 uid bit (36); /* uid */ 7 25 7 26 dcl 1 v2_backup_volume_contents based (contentsp) aligned, 7 27 2 header like backup_volume_header aligned, 7 28 2 version fixed bin, /* version number of structure */ 7 29 2 volname char (32), /* volume name */ 7 30 2 volid bit (36), /* volume id */ 7 31 2 next fixed bin, /* index of next available slot in uid array */ 7 32 2 pad (10) bit (36), 7 33 2 array (1: 1 refer (backup_volume_contents.next)), /* array of arrays of data objects on this output volume */ 7 34 3 uid bit (36), /* uid */ 7 35 3 location, /* offset of name string */ 7 36 4 component fixed bin (17) unal, 7 37 4 offset fixed bin (17) unal ; 7 38 7 39 dcl 1 backup_volume_contents based (contentsp) aligned, 7 40 2 header like backup_volume_header aligned, 7 41 2 version fixed bin, /* version number of structure */ 7 42 2 volname char (32), /* volume name */ 7 43 2 volid bit (36), /* volume id */ 7 44 2 next fixed bin, /* index of next available slot in uid array */ 7 45 2 pad (10) bit (36), 7 46 2 array (1: 1 refer (backup_volume_contents.next)), /* array of arrays of data objects on this output volume */ 7 47 3 uid bit (36), /* uid */ 7 48 3 tape_loc fixed bin (35), 7 49 3 pad1 bit (36), 7 50 3 location, /* offset of name string */ 7 51 4 component fixed bin (18) unsigned unal, 7 52 4 offset fixed bin (18) unsigned unal ; 7 53 7 54 dcl contents_namesp ptr; /* ptr to optional name seg */ 7 55 7 56 dcl 1 backup_volume_contents_names based (contents_namesp) aligned, 7 57 2 version fixed bin, 7 58 2 offset fixed bin (18), /* next free location */ 7 59 2 pad (6) bit (36), 7 60 2 begin bit (36); 7 61 7 62 7 63 /* END INCLUDE FILE backup_volume_contents.incl.pl1 */ 1032 1033 8 1 /* BEGIN INCLUDE FILE ... backup_volume_log.incl.pl1 ... Feb 1976 */ 8 2 8 3 8 4 /****^ HISTORY COMMENTS: 8 5* 1) change(88-03-03,GWMay), approve(89-10-03,MCR8135), 8 6* audit(89-10-04,Beattie), install(89-10-10,MR12.3-1089): 8 7* Added values for storing the number of incremental and consolidated dump 8 8* sets to retain in the volume log. Incremented version number to 3. 8 9* END HISTORY COMMENTS */ 8 10 8 11 8 12 /* Modified: 3/7/84 by GA Texada to change to version 2 */ 8 13 dcl bvlp ptr; 8 14 dcl bvlep ptr; 8 15 8 16 dcl backup_volume_log_version_1 fixed bin static init (1) options (constant); 8 17 dcl backup_volume_log_version_2 fixed bin init(2) int static options(constant); 8 18 dcl backup_volume_log_version_3 fixed bin init(3) int static options(constant); 8 19 8 20 dcl 1 backup_volume_log based (bvlp) aligned, 8 21 2 header like backup_volume_header aligned, 8 22 2 info like backup_pvol_info aligned, 8 23 2 version fixed bin, /* version number */ 8 24 2 lock bit (36), /* shared data base */ 8 25 2 pvname char (32), /* physical volume name */ 8 26 2 pvid bit (36), /* physical volume id */ 8 27 2 next fixed bin, /* next available dump record */ 8 28 2 reload_groups fixed bin, /* number of reload groups in log */ 8 29 2 purge_control (3), /* control selective purging by dump type */ 8 30 3 group (36) bit (1) unaligned, /* up to 36 reload groups */ 8 31 2 disk_type fixed bin unal, /* type of disk drive */ 8 32 2 half_word_pad bit(18) unal, /* MBZ */ 8 33 2 rpv_pvid bit(36), /* pvid of this volumes RPV */ 8 34 2 Nsaved_incr_sets fixed bin, /* number of incr cycles to retain */ 8 35 2 Nsaved_cons_sets fixed bin, /* number of incr cycles to retain */ 8 36 2 pad (31) bit (36), /* for future expansion (MBZ) */ 8 37 2 array (1:1 refer (backup_volume_log.next)) like bvle aligned; 8 38 8 39 dcl 1 bvle based (bvlep) aligned, 8 40 2 cycle_uid bit (36), /* uid of this dump cycle */ 8 41 2 dump_type fixed bin, /* type of dump */ 8 42 2 volname char (32), /* name of output volume */ 8 43 2 open_time fixed bin (71), /* opening time of dump pass on this physical volume */ 8 44 2 close_time fixed bin (71), /* ending time of dump pass */ 8 45 2 volid bit (36), /* uid of output volume */ 8 46 2 io_module char (32), /* outer module name that wrote this volume */ 8 47 2 flags, /* flags */ 8 48 3 purge_scan_logged bit (1) unaligned, /* if on object looged during purge scan */ 8 49 3 pad1 bit (35) unaligned, 8 50 2 pad (7) bit (36), /* for future expansion */ 8 51 (2 dir_num fixed bin, /* number of dirs dumped on this pass */ 8 52 2 dir_rec fixed bin, /* number of records of dirs */ 8 53 2 seg_num fixed bin, /* number of segs dumped on this pass */ 8 54 2 seg_rec fixed bin) unaligned; /* number of records of segs */ 8 55 8 56 /* END INCLUDE FILE ... backup_volume_log */ 1034 1035 9 1 /* BEGIN INCLUDE FILE ... backup_volume_header ... Feb 1976 */ 9 2 9 3 dcl hdp ptr; /* ptr to header */ 9 4 9 5 dcl 1 backup_volume_header based (hdp) aligned, 9 6 2 pattern1 bit (36), /* unique word 1 */ 9 7 2 rec1_type fixed bin, /* record 1 type */ 9 8 2 rec1_len fixed bin, /* length in chars */ 9 9 2 pattern2 bit (36), /* unique word 2 */ 9 10 2 rec2_type fixed bin, /* record 2 type */ 9 11 2 rec2_len fixed bin, /* length in chars */ 9 12 2 pattern3 bit (36), /* unique word 3 */ 9 13 2 time_dumped bit (36); /* dump time of this record */ 9 14 9 15 dcl vtoce_type fixed bin static init (1) options (constant); /* type code for vtoce */ 9 16 dcl dir_type fixed bin static init (2) options (constant); /* type code for directory */ 9 17 dcl seg_type fixed bin static init (3) options (constant); /* type code for segment */ 9 18 dcl null_type fixed bin static init (4) options (constant); /* type code for null record */ 9 19 dcl volume_log_type fixed bin static init (5) options (constant); /* type code for volume log */ 9 20 dcl prev_output_log_type fixed bin static init (6) options (constant); /* type code for prev output log */ 9 21 dcl contents_type fixed bin static init (7) options (constant); /* type code for contents segment of previous volume */ 9 22 dcl info_type fixed bin static init (8) options (constant); /* type code for info structure */ 9 23 9 24 dcl pattern1 bit (36) int static init ("110111000011001100011101101010100101"b) options (constant); 9 25 dcl pattern2 bit (36) int static init ("101001010101101110001100110000111011"b) options (constant); 9 26 dcl pattern3 bit (36) int static init ("001000111100110011100010010101011010"b) options (constant); 9 27 9 28 /* END INCLUDE FILE ... backup_volume_header */ 1036 10 1 /* BEGIN INCLUDE FILE ... backup_pvol_info.incl.pl1 */ 10 2 10 3 dcl bpvip ptr; 10 4 10 5 dcl 1 backup_pvol_info based (bpvip) aligned, 10 6 2 label like label aligned, 10 7 2 n_vtoce fixed bin, 10 8 2 n_free_vtoce fixed bin, 10 9 2 n_rec fixed bin, 10 10 2 baseadd fixed bin, 10 11 2 n_free_rec fixed bin; 10 12 10 13 /* END INCLUDE FILE ... backup_pvol_info.incl.pl1 */ 1037 1038 11 1 /* BEGIN INCLUDE FILE ... fs_vol_label.incl.pl1 .. last modified January 1982 for new volume map format */ 11 2 11 3 /****^ HISTORY COMMENTS: 11 4* 1) change(86-04-10,Fawcett), approve(86-04-10,MCR7383), 11 5* audit(86-05-12,Coppola), install(86-07-18,MR12.0-1098): 11 6* Add the subvolume info. 11 7* 2) change(88-05-27,GWMay), approve(88-05-27,MCR7883), 11 8* audit(88-06-14,Beattie), install(88-07-19,MR12.2-1061): 11 9* Added inconsistent_dbm bit used to determine consistency of volume 11 10* dumper bit maps. 11 11* END HISTORY COMMENTS */ 11 12 11 13 /* This is the label at fixed location of each physical volume. Length 1 page */ 11 14 /* Note: fsout_vol clears pad fields before writing the label */ 11 15 11 16 dcl labelp ptr; 11 17 11 18 dcl 1 label based (labelp) aligned, 11 19 11 20 /* First comes data not used by Multics.. for compatibility with GCOS */ 11 21 11 22 2 gcos (5*64) fixed bin, 11 23 11 24 /* Now we have the Multics label */ 11 25 11 26 2 Multics char (32) init ("Multics Storage System Volume"), /* Identifier */ 11 27 2 version fixed bin, /* Version 1 */ 11 28 2 mfg_serial char (32), /* Manufacturer's serial number */ 11 29 2 pv_name char (32), /* Physical volume name. */ 11 30 2 lv_name char (32), /* Name of logical volume for pack */ 11 31 2 pvid bit (36), /* Unique ID of this pack */ 11 32 2 lvid bit (36), /* unique ID of its logical vol */ 11 33 2 root_pvid bit (36), /* unique ID of the pack containing the root. everybody must agree. */ 11 34 2 time_registered fixed bin (71), /* time imported to system */ 11 35 2 n_pv_in_lv fixed bin, /* # phys volumes in logical */ 11 36 2 vol_size fixed bin, /* total size of volume, in records */ 11 37 2 vtoc_size fixed bin, /* number of recs in fixed area + vtoc */ 11 38 2 not_used bit (1) unal, /* used to be multiple_class */ 11 39 2 private bit (1) unal, /* TRUE if was registered as private */ 11 40 2 inconsistent_dbm bit (1) unal, /* TRUE if ESD-less crash */ 11 41 2 flagpad bit (33) unal, 11 42 2 max_access_class bit (72), /* Maximum access class for stuff on volume */ 11 43 2 min_access_class bit (72), /* Minimum access class for stuff on volume */ 11 44 2 password bit (72), /* not yet used */ 11 45 2 number_of_sv fixed bin, /* if = 0 not a subvolume else the number of svs */ 11 46 2 this_sv fixed bin, /* what subvolume number it is */ 11 47 2 sub_vol_name char (1), /* what subvolume name (a b c d) it is */ 11 48 2 pad1 (13) fixed bin, 11 49 2 time_mounted fixed bin (71), /* time mounted */ 11 50 2 time_map_updated fixed bin (71), /* time vmap known good */ 11 51 11 52 /* The next two words overlay time_unmounted on pre-MR10 systems. This 11 53* forces a salvage if an MR10 pack is mounted on an earlier system. 11 54* */ 11 55 2 volmap_version fixed bin, /* version of volume map (currently 1) */ 11 56 2 pad6 fixed bin, 11 57 11 58 2 time_salvaged fixed bin (71), /* time salvaged */ 11 59 2 time_of_boot fixed bin (71), /* time of last bootload */ 11 60 2 time_unmounted fixed bin (71), /* time unmounted cleanly */ 11 61 2 last_pvtx fixed bin, /* pvtx in that PDMAP */ 11 62 2 pad1a (2) fixed bin, 11 63 2 err_hist_size fixed bin, /* size of pack error history */ 11 64 2 time_last_dmp (3) fixed bin (71), /* time last completed dump pass started */ 11 65 2 time_last_reloaded fixed bin (71), /* what it says */ 11 66 2 pad2 (40) fixed bin, 11 67 2 root, 11 68 3 here bit (1), /* TRUE if the root is on this pack */ 11 69 3 root_vtocx fixed bin (35), /* VTOC index of root, if it is here */ 11 70 3 shutdown_state fixed bin, /* Status of hierarchy */ 11 71 3 pad7 bit (1) aligned, 11 72 3 disk_table_vtocx fixed bin, /* VTOC index of disk table on RPV */ 11 73 3 disk_table_uid bit (36) aligned, /* UID of disk table */ 11 74 3 esd_state fixed bin, /* State of esd */ 11 75 2 volmap_record fixed bin, /* Begin record of volume map */ 11 76 2 size_of_volmap fixed bin, /* Number of records in volume map */ 11 77 2 vtoc_map_record fixed bin, /* Begin record of VTOC map */ 11 78 2 size_of_vtoc_map fixed bin, /* Number of records in VTOC map */ 11 79 2 volmap_unit_size fixed bin, /* Number of words per volume map section */ 11 80 2 vtoc_origin_record fixed bin, /* Begin record of VTOC */ 11 81 2 dumper_bit_map_record fixed bin, /* Begin record of dumper bit-map */ 11 82 2 vol_trouble_count fixed bin, /* Count of inconsistencies found since salvage */ 11 83 2 pad3 (52) fixed bin, 11 84 2 nparts fixed bin, /* Number of special partitions on pack */ 11 85 2 parts (47), 11 86 3 part char (4), /* Name of partition */ 11 87 3 frec fixed bin, /* First record */ 11 88 3 nrec fixed bin, /* Number of records */ 11 89 3 pad5 fixed bin, 11 90 2 pad4 (5*64) fixed bin; 11 91 11 92 dcl Multics_ID_String char (32) init ("Multics Storage System Volume") static; 11 93 11 94 /* END INCLUDE FILE fs_vol_label.incl.pl1 */ 1039 12 1 /* BEGIN INCLUDE FILE ... backup_static_variables.incl.pl1 ... March 1976 */ 12 2 12 3 12 4 dcl incr fixed bin init (1) internal static options (constant); /* incremental dump mode */ 12 5 dcl cons fixed bin init (2) internal static options (constant); /* consolidated dump mode */ 12 6 dcl comp fixed bin init (3) internal static options (constant); /* complete dump mode */ 12 7 dcl backup_version_1 fixed bin init (1) static internal options (constant); /* backup_version_1 of input/output structures */ 12 8 12 9 12 10 12 11 /* END INCLUDE FILE ... backup_static_variables.incl.pl1 */ 1040 1041 13 1 /* BEGIN INCLUDE FILE ... retv_skip_list.incl.pl1 ... 11/76 */ 13 2 13 3 dcl skip ptr; 13 4 13 5 dcl 1 retv_skip_list aligned based (skip), 13 6 2 next fixed bin, 13 7 2 array (1 : 1 refer (retv_skip_list.next)), 13 8 3 volname char (32); 13 9 13 10 /* END INCLUDE FILE ... retv_skip_list.incl.pl1 */ 1042 14 1 /* BEGIN INCLUDE FILE query_info.incl.pl1 TAC June 1, 1973 */ 14 2 /* Renamed to query_info.incl.pl1 and cp_escape_control added, 08/10/78 WOS */ 14 3 /* version number changed to 4, 08/10/78 WOS */ 14 4 /* Version 5 adds explanation_(ptr len) 05/08/81 S. Herbst */ 14 5 /* Version 6 adds literal_sw, prompt_after_explanation switch 12/15/82 S. Herbst */ 14 6 14 7 dcl 1 query_info aligned, /* argument structure for command_query_ call */ 14 8 2 version fixed bin, /* version of this structure - must be set, see below */ 14 9 2 switches aligned, /* various bit switch values */ 14 10 3 yes_or_no_sw bit (1) unaligned init ("0"b), /* not a yes-or-no question, by default */ 14 11 3 suppress_name_sw bit (1) unaligned init ("0"b), /* do not suppress command name */ 14 12 3 cp_escape_control bit (2) unaligned init ("00"b), /* obey static default value */ 14 13 /* "01" -> invalid, "10" -> don't allow, "11" -> allow */ 14 14 3 suppress_spacing bit (1) unaligned init ("0"b), /* whether to print extra spacing */ 14 15 3 literal_sw bit (1) unaligned init ("0"b), /* ON => do not strip leading/trailing white space */ 14 16 3 prompt_after_explanation bit (1) unaligned init ("0"b), /* ON => repeat question after explanation */ 14 17 3 padding bit (29) unaligned init (""b), /* pads it out to t word */ 14 18 2 status_code fixed bin (35) init (0), /* query not prompted by any error, by default */ 14 19 2 query_code fixed bin (35) init (0), /* currently has no meaning */ 14 20 14 21 /* Limit of data defined for version 2 */ 14 22 14 23 2 question_iocbp ptr init (null ()), /* IO switch to write question */ 14 24 2 answer_iocbp ptr init (null ()), /* IO switch to read answer */ 14 25 2 repeat_time fixed bin (71) init (0), /* repeat question every N seconds if no answer */ 14 26 /* minimum of 30 seconds required for repeat */ 14 27 /* otherwise, no repeat will occur */ 14 28 /* Limit of data defined for version 4 */ 14 29 14 30 2 explanation_ptr ptr init (null ()), /* explanation of question to be printed if */ 14 31 2 explanation_len fixed bin (21) init (0); /* user answers "?" (disabled if ptr=null or len=0) */ 14 32 14 33 dcl query_info_version_3 fixed bin int static options (constant) init (3); 14 34 dcl query_info_version_4 fixed bin int static options (constant) init (4); 14 35 dcl query_info_version_5 fixed bin int static options (constant) init (5); 14 36 dcl query_info_version_6 fixed bin int static options (constant) init (6); /* the current version number */ 14 37 14 38 /* END INCLUDE FILE query_info.incl.pl1 */ 1043 1044 1045 end retv_vol_control_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 10/10/89 1355.3 retv_vol_control_.pl1 >special_ldd>install>MR12.3-1089>retv_vol_control_.pl1 1021 1 10/18/88 1215.0 retv_data_.incl.pl1 >ldd>include>retv_data_.incl.pl1 1023 2 10/03/83 1415.4 retv_volume_list.incl.pl1 >ldd>include>retv_volume_list.incl.pl1 1024 3 09/04/80 2006.4 retv_request.incl.pl1 >ldd>include>retv_request.incl.pl1 1026 4 08/31/82 1636.3 queue_msg_hdr.incl.pl1 >ldd>include>queue_msg_hdr.incl.pl1 1028 5 05/01/81 1921.2 retv_input.incl.pl1 >ldd>include>retv_input.incl.pl1 1030 6 05/01/81 1921.2 retv_vol_control.incl.pl1 >ldd>include>retv_vol_control.incl.pl1 1032 7 11/24/86 1243.9 backup_volume_contents.incl.pl1 >ldd>include>backup_volume_contents.incl.pl1 1034 8 10/10/89 1357.9 backup_volume_log.incl.pl1 >special_ldd>install>MR12.3-1089>backup_volume_log.incl.pl1 1036 9 09/05/80 1136.5 backup_volume_header.incl.pl1 >ldd>include>backup_volume_header.incl.pl1 1037 10 06/07/77 1233.6 backup_pvol_info.incl.pl1 >ldd>include>backup_pvol_info.incl.pl1 1039 11 07/21/88 2036.0 fs_vol_label.incl.pl1 >ldd>include>fs_vol_label.incl.pl1 1040 12 09/05/80 1136.5 backup_static_variables.incl.pl1 >ldd>include>backup_static_variables.incl.pl1 1042 13 09/04/80 2006.4 retv_skip_list.incl.pl1 >ldd>include>retv_skip_list.incl.pl1 1043 14 03/11/83 1204.3 query_info.incl.pl1 >ldd>include>query_info.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. DIR constant fixed bin(17,0) initial dcl 114 ref 229 LINK constant fixed bin(17,0) initial dcl 115 ref 227 229 424 a_rvcp parameter pointer dcl 40 ref 451 458 access_class 200 based bit(72) level 3 dcl 5-6 set ref 200* addr builtin function dcl 165 ref 266 298 336 373 523 523 694 785 837 837 announced 21(01) based bit(1) array level 4 packed packed unaligned dcl 2-6 set ref 402 405* 515* answer 000100 automatic varying char(3) dcl 39 set ref 523* 526 answer_iocbp 6 000672 automatic pointer initial level 2 dcl 14-7 set ref 14-7* array 35 based structure array level 2 in structure "v2_backup_volume_contents" dcl 7-26 in procedure "retv_vol_control_" array 22 based structure array level 2 in structure "retv_vol_control" dcl 6-8 in procedure "retv_vol_control_" set ref 464 465* 465 466* 694 array 23 based structure array level 2 in structure "v1_backup_volume_contents" dcl 7-17 in procedure "retv_vol_control_" array 1 based structure array level 2 in structure "retv_skip_list" dcl 13-5 in procedure "retv_vol_control_" array 2100 based structure array level 2 in structure "backup_volume_log" dcl 8-20 in procedure "retv_vol_control_" set ref 266 298 336 373 array 35 based structure array level 2 in structure "backup_volume_contents" dcl 7-39 in procedure "retv_vol_control_" array 2 based structure array level 2 in structure "retv_volume_list" dcl 2-6 in procedure "retv_vol_control_" backup_pvol_info based structure level 1 dcl 10-5 backup_volume_contents based structure level 1 dcl 7-39 backup_volume_contents_version_3 constant fixed bin(17,0) initial dcl 7-14 ref 746 749 954 backup_volume_header based structure level 1 dcl 9-5 backup_volume_log based structure level 1 dcl 8-20 backup_volume_log_version_1 constant fixed bin(17,0) initial dcl 8-16 ref 566 backup_volume_log_version_2 constant fixed bin(17,0) initial dcl 8-17 ref 566 backup_volume_log_version_3 constant fixed bin(17,0) initial dcl 8-18 ref 566 based_char_string based char(1048576) packed unaligned dcl 102 set ref 785 786 bits 212 000110 external static structure level 2 in structure "retv_data_" dcl 1-27 in procedure "retv_vol_control_" bits 76 based structure level 3 in structure "retv_input" dcl 5-6 in procedure "retv_vol_control_" bits 172 based structure level 2 in structure "retv_input" dcl 5-6 in procedure "retv_vol_control_" bvle based structure level 1 dcl 8-39 bvlep 000666 automatic pointer dcl 8-14 set ref 266* 267 268 269 272 273 274 277 278 279 298* 299 336* 337 339 339 348 350 350 356 359 361 365 373* 489 489 492 494 494 507 508 509 510 511 514 517 518 519 521 523 523 529 896 896 898 bvlp 000664 automatic pointer dcl 8-13 set ref 186* 246 265 266 298 317 319 335 336 372 373 546* 559* 563* 564 566 566 566 566 566 566 572* 578 594 612 898 898 char 000650 automatic char(2) level 2 packed packed unaligned dcl 107 set ref 878* 879* char_num 000202 automatic char(32) packed unaligned dcl 42 set ref 880* 882* chars 110 based structure level 3 in structure "retv_input" dcl 5-6 in procedure "retv_vol_control_" chars 10 000110 external static structure level 2 in structure "retv_data_" dcl 1-27 in procedure "retv_vol_control_" chars 220 based structure level 2 in structure "retv_input" dcl 5-6 in procedure "retv_vol_control_" close_time 16 based fixed bin(71,0) array level 3 in structure "retv_volume_list" dcl 2-6 in procedure "retv_vol_control_" set ref 518* 518 close_time 14 based fixed bin(71,0) level 2 in structure "bvle" dcl 8-39 in procedure "retv_vol_control_" ref 269 274 279 339 339 350 509 518 code parameter fixed bin(35,0) dcl 43 set ref 22 172* 200* 212* 219* 231* 247* 251 252* 324 428* 429 432* 438 438 440* 441* 443 447* 451 459* 548* 549 550* 553* 554 555* 560* 563* 565* 573* 574* 578* 594* 595 595 595* 596 597* 598* 635* 636 637* 640* 642* 647 661* 677* 734* 735 736* 739* 742* 754* 755* 760* 819* 821 822* 825 825* 837* 839 846 874* 882* 883 917* 918 919* 926* 927 928* 932* 934 934* 948* 949 950* 993* 994 995* 1012* 1014 1014* command_query_ 000062 constant entry external dcl 141 ref 523 comp constant fixed bin(17,0) initial dcl 12-6 ref 242 277 277 359 comp_close_time 000354 automatic fixed bin(71,0) dcl 68 set ref 262* 279* 293 comp_cycle_uid 000212 automatic bit(36) packed unaligned dcl 44 set ref 334* 360 361 365* comp_indx 000214 automatic fixed bin(17,0) dcl 46 set ref 263* 280* 287* 293* 296 comp_open_time 000216 automatic fixed bin(71,0) dcl 47 set ref 259* 278* 287 332* 338 339 339 349 350 362* 366* component 40 based fixed bin(18,0) array level 4 in structure "backup_volume_contents" packed packed unsigned unaligned dcl 7-39 in procedure "retv_vol_control_" set ref 932 934* 975* 981* 985* component 36 based fixed bin(17,0) array level 4 in structure "v2_backup_volume_contents" packed packed unaligned dcl 7-26 in procedure "retv_vol_control_" ref 985 cons constant fixed bin(17,0) initial dcl 12-5 ref 242 272 272 348 cons_close_time 000352 automatic fixed bin(71,0) dcl 67 set ref 261* 274* 292 cons_cycle_uid 000220 automatic bit(36) packed unaligned dcl 48 set ref 333* 350 356* cons_indx 000221 automatic fixed bin(17,0) dcl 49 set ref 263* 275* 286* 292* 296 cons_open_time 000222 automatic fixed bin(71,0) dcl 50 set ref 258* 273* 286 331* 338 339 339 355* contents_idx 000114 automatic fixed bin(17,0) dcl 947 in procedure "convert_contents_seg" set ref 972* 974 974 975 976 977 980 981 982 985 985 987 987 990 990* contents_idx parameter fixed bin(17,0) dcl 773 in procedure "search_contents_seg" set ref 772 780* 781 782* contents_idx 000224 automatic fixed bin(17,0) dcl 51 in procedure "retv_vol_control_" set ref 410* 697 785 786 932 934 contents_namesp 000662 automatic pointer dcl 7-54 set ref 187* 784 785 786 916* 923* 932* contentsp 000660 automatic pointer dcl 7-12 set ref 187* 394 733* 739* 741* 745 746 748 749 749 749 753* 760 780 781 782 785 786 932 934 951* 955 956 957 958 960 961 962 963 966 968* 973 974 979 980 985 987 990 993* 996* 1011 contentsx 1 based fixed bin(17,0) level 2 in structure "rvce" dcl 6-22 in procedure "retv_vol_control_" set ref 697* contentsx 23 based fixed bin(17,0) array level 3 in structure "retv_vol_control" dcl 6-8 in procedure "retv_vol_control_" set ref 463 463 control_name 000225 automatic char(32) packed unaligned dcl 52 set ref 635* 640* 642* cp_escape_control 1(02) 000672 automatic bit(2) initial level 3 packed packed unaligned dcl 14-7 set ref 14-7* cv_dec_check_ 000060 constant entry external dcl 140 ref 882 cycle_uid based bit(36) level 2 in structure "bvle" dcl 8-39 in procedure "retv_vol_control_" ref 350 356 361 365 898 cycle_uid 2100 based bit(36) array level 3 in structure "backup_volume_log" dcl 8-20 in procedure "retv_vol_control_" set ref 898 dir_num 37 based fixed bin(17,0) level 2 packed packed unaligned dcl 8-39 ref 489 dirname 2 based char(168) level 2 in structure "rvce" dcl 6-22 in procedure "retv_vol_control_" set ref 699* dirname 3 based char(168) level 4 in structure "retv_input" dcl 5-6 in procedure "retv_vol_control_" set ref 194 430* 430 444* 444 dirname 000235 automatic char(168) packed unaligned dcl 53 in procedure "retv_vol_control_" set ref 194* 200* 209* 209 216* 216 230* 230 427 428* 444* 444 699 done 000307 automatic bit(1) packed unaligned dcl 54 set ref 378* 379 382* dump_type 17 based fixed bin(17,0) level 2 in structure "retv_vol_control" dcl 6-8 in procedure "retv_vol_control_" set ref 652* dump_type 1 based fixed bin(17,0) level 2 in structure "bvle" dcl 8-39 in procedure "retv_vol_control_" ref 337 348 359 519 896 dump_type 20 based fixed bin(17,0) array level 3 in structure "retv_volume_list" dcl 2-6 in procedure "retv_vol_control_" set ref 392 519* dump_type 000537 automatic fixed bin(17,0) dcl 99 in procedure "retv_vol_control_" set ref 392* 652 emode 000310 automatic bit(36) packed unaligned dcl 55 set ref 183* 200* 228 229 ename 55 based char(32) level 4 in structure "retv_input" dcl 5-6 in procedure "retv_vol_control_" set ref 195 430* 444* ename 54 based char(32) level 2 in structure "rvce" dcl 6-22 in procedure "retv_vol_control_" set ref 700* ename 000311 automatic char(32) packed unaligned dcl 56 in procedure "retv_vol_control_" set ref 195* 200* 209* 216* 230* 426 428* 444* 700 endx 000757 automatic fixed bin(17,0) dcl 773 set ref 789* 790 791 793 794* entry_name 230 based char(32) level 3 in structure "retv_input" dcl 5-6 in procedure "retv_vol_control_" set ref 713* entry_name 64 based char(32) level 2 in structure "rvce" dcl 6-22 in procedure "retv_vol_control_" set ref 701* 713 entry_name 000321 automatic char(32) packed unaligned dcl 57 in procedure "retv_vol_control_" set ref 175* 426* 444 444* 701 787 792 796 entry_retrieval 203 based bit(1) level 3 in structure "retv_input" dcl 5-6 in procedure "retv_vol_control_" set ref 714* entry_retrieval 104(01) based bit(1) level 3 in structure "rvce" packed packed unaligned dcl 6-22 in procedure "retv_vol_control_" set ref 706* entry_retrieval 000331 automatic bit(1) packed unaligned dcl 58 in procedure "retv_vol_control_" set ref 178* 234* 396 706 714 782 error_table_$action_not_performed 000012 external static fixed bin(35,0) dcl 120 ref 661 error_table_$bad_segment 000022 external static fixed bin(35,0) dcl 124 ref 573 754 821 error_table_$bad_volid 000016 external static fixed bin(35,0) dcl 122 ref 874 error_table_$invalid_lock_reset 000024 external static fixed bin(35,0) dcl 125 ref 595 error_table_$locked_by_this_process 000020 external static fixed bin(35,0) dcl 123 ref 596 error_table_$segfault 000014 external static fixed bin(35,0) dcl 121 ref 560 742 expand_pathname_ 000050 constant entry external dcl 136 ref 428 explanation_len 14 000672 automatic fixed bin(21,0) initial level 2 dcl 14-7 set ref 14-7* explanation_ptr 12 000672 automatic pointer initial level 2 dcl 14-7 set ref 14-7* fcbp 000532 automatic pointer dcl 97 set ref 799* 926* 932* fixed 1 000110 external static structure level 2 dcl 1-27 fixed_bin 212 based structure level 2 in structure "retv_input" dcl 5-6 in procedure "retv_vol_control_" fixed_bin 102 based structure level 3 in structure "retv_input" dcl 5-6 in procedure "retv_vol_control_" flags 21 based structure array level 3 in structure "retv_volume_list" dcl 2-6 in procedure "retv_vol_control_" flags 126 based structure array level 3 in structure "retv_vol_control" dcl 6-8 in procedure "retv_vol_control_" flags 232 000110 external static structure level 3 in structure "retv_data_" dcl 1-27 in procedure "retv_vol_control_" flags 104 based structure level 2 in structure "rvce" dcl 6-22 in procedure "retv_vol_control_" found parameter bit(1) packed unaligned dcl 774 in procedure "search_contents_seg" set ref 772 779* 802* found 000213 automatic bit(1) packed unaligned dcl 45 in procedure "retv_vol_control_" set ref 410* 411 from_time 106 based fixed bin(71,0) level 4 in structure "retv_input" dcl 5-6 in procedure "retv_vol_control_" ref 290 291 292 293 329 396 509 509 703 from_time 102 based fixed bin(71,0) level 2 in structure "rvce" dcl 6-22 in procedure "retv_vol_control_" set ref 703* get_temp_segment_ 000030 constant entry external dcl 128 ref 948 hbound builtin function dcl 158 ref 657 659 659 hc_backup_$retv_status 000106 constant entry external dcl 151 ref 200 hcs_$fs_move_seg 000036 constant entry external dcl 131 ref 993 hcs_$initiate 000104 constant entry external dcl 150 ref 563 739 hcs_$make_seg 000074 constant entry external dcl 146 ref 640 hcs_$terminate_noname 000034 constant entry external dcl 130 ref 1012 header based structure level 3 dcl 5-6 idx 000333 automatic fixed bin(17,0) dcl 60 set ref 265* 266 270 275 280* 335* 336* 372* 373* 897 ignore 000346 automatic fixed bin(35,0) dcl 64 set ref 612* 969* 998* in_use 104(04) based bit(1) level 3 in structure "rvce" packed packed unaligned dcl 6-22 in procedure "retv_vol_control_" set ref 695* in_use 126(04) based bit(1) array level 4 in structure "retv_vol_control" packed packed unaligned dcl 6-8 in procedure "retv_vol_control_" set ref 462 in_use_cnt 14 based fixed bin(17,0) level 2 dcl 6-8 set ref 693* 693 incr constant fixed bin(17,0) initial dcl 12-4 ref 242 267 267 337 896 incr_close_time 000350 automatic fixed bin(71,0) dcl 66 set ref 260* 269* 291 incr_indx 000347 automatic fixed bin(17,0) dcl 65 set ref 263* 270* 285* 291* 296 incr_open_time 000356 automatic fixed bin(71,0) dcl 69 set ref 257* 268* 285 330* 345* index builtin function dcl 159 ref 786 787 789 794 inputp parameter pointer dcl 5-3 set ref 22 194 195 200 200 200 206 211* 218* 232* 284 285 286 287 290 291 292 293 329 329 396 396 430 430 430 433* 444 444 444 446* 507 507 508 509 509 702 703 705 711 712 713 714 715 819 819 819* insert_idx 000737 automatic fixed bin(17,0) dcl 622 set ref 668* 669 672 io_module 102 000110 external static char(32) level 3 in structure "retv_data_" dcl 1-27 in procedure "retv_vol_control_" ref 521 io_module 17 based char(32) level 2 in structure "bvle" dcl 8-39 in procedure "retv_vol_control_" set ref 521 523* ioa_ 000052 constant entry external dcl 137 ref 840 847 ioa_$nnl 000054 constant entry external dcl 138 ref 836 ioa_$rsnnl 000070 constant entry external dcl 144 ref 209 216 230 430 444 iox_$get_line 000056 constant entry external dcl 139 ref 837 iox_$user_input 000010 external static pointer dcl 119 set ref 837* jdx 001012 automatic fixed bin(17,0) dcl 895 set ref 897* 898 898* label based structure level 1 dcl 11-18 latest_indx 000360 automatic fixed bin(17,0) dcl 70 set ref 296* 297 298 length builtin function dcl 166 ref 837 837 880 level 212 based fixed bin(17,0) level 3 dcl 5-6 set ref 200* link_retrieval 104 based bit(1) level 3 in structure "rvce" packed packed unaligned dcl 6-22 in procedure "retv_vol_control_" set ref 707* link_retrieval 000361 automatic bit(1) packed unaligned dcl 71 in procedure "retv_vol_control_" set ref 176* 424* 707 literal_sw 1(05) 000672 automatic bit(1) initial level 3 packed packed unaligned dcl 14-7 set ref 14-7* lns 000334 automatic fixed bin(17,0) dcl 61 set ref 786* 787 789 791 794 796 796 local_rvce 000542 automatic structure level 1 dcl 105 set ref 464* 466 location 40 based structure array level 3 in structure "backup_volume_contents" dcl 7-39 in procedure "retv_vol_control_" location 36 based structure array level 3 in structure "v2_backup_volume_contents" dcl 7-26 in procedure "retv_vol_control_" lock 2016 based bit(36) level 2 in structure "backup_volume_log" dcl 8-20 in procedure "retv_vol_control_" set ref 594* 612* lock 000362 automatic bit(1) packed unaligned dcl 72 in procedure "retv_vol_control_" set ref 173* 250 255* 322 327* 449 logged 000335 automatic bit(1) packed unaligned dcl 62 set ref 185* 443 718* lsearch_name 000363 automatic char(32) packed unaligned dcl 73 set ref 548* manual 232 000110 external static bit(1) level 4 packed packed unaligned dcl 1-27 ref 242 315 315 max builtin function dcl 164 ref 296 518 mdc_$find_volname 000076 constant entry external dcl 147 ref 548 message 000102 automatic char(256) packed unaligned dcl 41 set ref 209* 211* 216* 218* 230* 232* 430* 433* 444* 446* message_segment_$update_message_index 000072 constant entry external dcl 145 ref 819 min builtin function dcl 157 ref 517 msf_manager_$close 000040 constant entry external dcl 132 ref 799 msf_manager_$get_ptr 000044 constant entry external dcl 134 ref 932 msf_manager_$open 000042 constant entry external dcl 133 ref 926 myname 000000 constant char(32) initial packed unaligned dcl 112 set ref 211* 218* 232* 247* 252* 403* 433* 440* 446* 523* 550* 555* 574* 578* 597* 637* 642* 659* 736* 755* 760* 822* 825* 919* 928* 934* 948* 950* 966* 969* 995* 998* 1014* n_entries 15 based fixed bin(17,0) level 2 dcl 6-8 set ref 460 461 692* 692 694 name_string based char packed unaligned dcl 103 ref 787 789 791 794 796 ncp 000374 automatic pointer dcl 74 set ref 948* 954 956 957 958 961 962 963 969* 972 974 975 976 977 981 982 985 987 990 993* 998* nelemt 000376 automatic fixed bin(17,0) dcl 75 set ref 837* 843 new_dirname 110 based char(168) level 4 dcl 5-6 ref 206 new_entry 000722 automatic bit(1) packed unaligned dcl 479 set ref 500* 503* 513 next based fixed bin(17,0) level 2 in structure "retv_skip_list" dcl 13-5 in procedure "retv_vol_control_" set ref 491 528* 528 529 next 22 based fixed bin(17,0) level 2 in structure "v2_backup_volume_contents" dcl 7-26 in procedure "retv_vol_control_" ref 958 next 2030 based fixed bin(17,0) level 2 in structure "backup_volume_log" dcl 8-20 in procedure "retv_vol_control_" ref 265 335 372 next 22 based fixed bin(17,0) level 2 in structure "v1_backup_volume_contents" dcl 7-17 in procedure "retv_vol_control_" ref 963 next 22 based fixed bin(17,0) level 2 in structure "backup_volume_contents" dcl 7-39 in procedure "retv_vol_control_" set ref 780 958* 963* 972 next based fixed bin(17,0) level 2 in structure "retv_volume_list" dcl 2-6 in procedure "retv_vol_control_" set ref 385* 387 494 498 499 499* no_contents_seg 104(06) based bit(1) level 3 in structure "rvce" packed packed unaligned dcl 6-22 in procedure "retv_vol_control_" set ref 708* no_contents_seg 000377 automatic bit(1) packed unaligned dcl 76 in procedure "retv_vol_control_" set ref 395* 708 nsp 000540 automatic pointer dcl 100 set ref 785* 787 789 791 794 796 null builtin function dcl 162 ref 186 187 246 317 319 394 14-7 14-7 14-7 546 559 564 572 578 634 641 658 691 733 741 745 748 753 760 784 916 923 951 968 996 1012 num 000400 automatic fixed bin(17,0) dcl 77 in procedure "retv_vol_control_" set ref 882* 884 num 0(18) 000650 automatic fixed bin(17,0) level 2 in structure "volume_id" packed packed unaligned dcl 107 in procedure "retv_vol_control_" set ref 884* nvol 4 000110 external static fixed bin(17,0) level 3 dcl 1-27 set ref 653 656 657 664* 664 665 669 673* 673 nvol_idx 000736 automatic fixed bin(17,0) dcl 622 set ref 653* 653* 656 668 669* 670 670* object_retrieval 000401 automatic bit(1) packed unaligned dcl 78 in procedure "retv_vol_control_" set ref 179* 236* 709 object_retrieval 104(02) based bit(1) level 3 in structure "rvce" packed packed unaligned dcl 6-22 in procedure "retv_vol_control_" set ref 709* offset 36(18) based fixed bin(17,0) array level 4 in structure "v2_backup_volume_contents" packed packed unaligned dcl 7-26 in procedure "retv_vol_control_" ref 980 987 offset 40(18) based fixed bin(18,0) array level 4 in structure "backup_volume_contents" packed packed unsigned unaligned dcl 7-39 in procedure "retv_vol_control_" set ref 782 785 786 976* 982* 987* old_dirname 000402 automatic char(168) packed unaligned dcl 79 set ref 427* 428* open_time 12 based fixed bin(71,0) level 2 in structure "retv_vol_control" dcl 6-8 in procedure "retv_vol_control_" set ref 651* 653 open_time 2112 based fixed bin(71,0) array level 3 in structure "backup_volume_log" dcl 8-20 in procedure "retv_vol_control_" set ref 898 open_time 12 based fixed bin(71,0) level 2 in structure "bvle" dcl 8-39 in procedure "retv_vol_control_" ref 268 273 278 507 508 514 517 896 open_time 000454 automatic fixed bin(71,0) dcl 80 in procedure "retv_vol_control_" set ref 391* 651 653 open_time 14 based fixed bin(71,0) array level 3 in structure "retv_volume_list" dcl 2-6 in procedure "retv_vol_control_" set ref 381* 391 514* 517* 517 padding 1(07) 000672 automatic bit(29) initial level 3 packed packed unaligned dcl 14-7 set ref 14-7* parent_check 000456 automatic bit(1) packed unaligned dcl 81 set ref 177* 234 425* pmode 000457 automatic bit(36) packed unaligned dcl 82 set ref 184* 200* 228 229 previous 104(05) based bit(1) level 3 in structure "rvce" packed packed unaligned dcl 6-22 in procedure "retv_vol_control_" set ref 711* previous 101 based bit(1) level 4 in structure "retv_input" dcl 5-6 in procedure "retv_vol_control_" ref 711 prompt_after_explanation 1(06) 000672 automatic bit(1) initial level 3 packed packed unaligned dcl 14-7 set ref 14-7* psearch_name 000460 automatic char(32) packed unaligned dcl 83 set ref 247* 252* 547* 548* 553* 555* 597* ptr builtin function dcl 160 ref 785 786 ptrs 234 000110 external static structure level 2 dcl 1-27 pvid 000470 automatic bit(36) packed unaligned dcl 84 in procedure "retv_vol_control_" set ref 200* 548* 566 pvid 2027 based bit(36) level 2 in structure "backup_volume_log" dcl 8-20 in procedure "retv_vol_control_" ref 566 pvname 2017 based char(32) level 2 dcl 8-20 ref 566 566 qidx 1 000110 external static fixed bin(17,0) array level 3 dcl 1-27 set ref 819* query_code 3 000672 automatic fixed bin(35,0) initial level 2 dcl 14-7 set ref 14-7* query_info 000672 automatic structure level 1 dcl 14-7 set ref 523 523 query_info_version_5 constant fixed bin(17,0) initial dcl 14-35 ref 522 question_iocbp 4 000672 automatic pointer initial level 2 dcl 14-7 set ref 14-7* queue 3 000110 external static fixed bin(17,0) level 3 in structure "retv_data_" dcl 1-27 in procedure "retv_vol_control_" ref 704 queue 74 based fixed bin(17,0) level 2 in structure "rvce" dcl 6-22 in procedure "retv_vol_control_" set ref 704* queue_msg_hdr based structure level 1 dcl 4-12 recursion_level 000471 automatic fixed bin(17,0) dcl 85 set ref 188* 207 315 423* 423 release_temp_segment_ 000032 constant entry external dcl 129 ref 969 998 repeat_time 10 000672 automatic fixed bin(71,0) initial level 2 dcl 14-7 set ref 14-7* request based structure level 2 dcl 5-6 requestor 220 based char(32) level 3 dcl 5-6 set ref 200* retriever constant fixed bin(17,0) initial dcl 1-25 ref 819 retv_data_ 000110 external static structure level 1 dcl 1-27 retv_input based structure level 1 dcl 5-6 set ref 819 retv_ms_id 75 based bit(72) level 2 in structure "rvce" dcl 6-22 in procedure "retv_vol_control_" set ref 705* retv_ms_id 176 based bit(72) level 3 in structure "retv_input" dcl 5-6 in procedure "retv_vol_control_" set ref 705 819* retv_notify_ 000026 constant entry external dcl 127 ref 211 218 232 433 446 retv_report_$error_output 000064 constant entry external dcl 142 ref 247 252 440 550 555 574 578 597 637 642 659 736 755 760 822 825 919 928 934 1014 retv_report_$online_output 000066 constant entry external dcl 143 ref 403 950 966 995 retv_request based structure level 1 dcl 3-7 retv_skip_list based structure level 1 dcl 13-5 retv_vol_control based structure level 1 dcl 6-8 retv_vol_control_version_1 constant fixed bin(17,0) initial dcl 6-6 ref 648 retv_volume_list based structure level 1 dcl 2-6 rtrim builtin function dcl 169 ref 739 787 926 rvce based structure level 1 dcl 6-22 rvcep 000656 automatic pointer dcl 6-4 set ref 186* 694* 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 713 715 rvcp 266 000110 external static pointer array level 3 in structure "retv_data_" dcl 1-27 in procedure "retv_vol_control_" set ref 653 657 659 659 665* 670* 670 672* rvcp 000654 automatic pointer dcl 6-3 in procedure "retv_vol_control_" set ref 186* 458* 460 461 462 463 463 464 465 465 466 634* 640* 641 648 649 650 651 652 658* 665 672 691 692 692 693 693 694 694 rvlx 000332 automatic fixed bin(17,0) dcl 59 set ref 387* 388 389 390 391 392 402 405* rw constant bit(3) initial packed unaligned dcl 116 ref 228 228 search builtin function dcl 163 ref 872 search_name 000472 automatic char(32) packed unaligned dcl 86 set ref 553* 563* 574* 578* 734* 739* 755* 760* 917* 926* 928* 934* seg_fault_error 000000 stack reference condition dcl 155 ref 558 740 922 seg_num 40 based fixed bin(17,0) level 2 packed packed unaligned dcl 8-39 ref 489 segment constant fixed bin(17,0) initial dcl 113 ref 215 228 segp 001022 automatic pointer dcl 1007 set ref 1011* 1012 1012* set_lock_$lock 000100 constant entry external dcl 148 ref 594 set_lock_$unlock 000102 constant entry external dcl 149 ref 612 size builtin function dcl 167 ref 819 skip 000670 automatic pointer dcl 13-3 in procedure "retv_vol_control_" set ref 191* 491 492 528 528 529 529 skip 240 000110 external static pointer level 3 in structure "retv_data_" dcl 1-27 in procedure "retv_vol_control_" ref 191 sm constant bit(3) initial packed unaligned dcl 117 ref 228 228 229 229 229 229 sortx 000725 automatic fixed bin(17,0) dcl 480 in procedure "update_volume_list" set ref 491* 492* 494* 494 494* 498 504 sortx 000502 automatic fixed bin(17,0) dcl 87 in procedure "retv_vol_control_" set ref 460* 463 464 465* sorty 000503 automatic fixed bin(17,0) dcl 88 set ref 461* 462 463 465 466* start_numeric 000504 automatic fixed bin(17,0) dcl 89 set ref 872* 873 873 878 878 880 880 startx 000756 automatic fixed bin(17,0) dcl 773 set ref 788* 791 793* 793 794 796 796 status_code 2 000672 automatic fixed bin(35,0) initial level 2 dcl 14-7 set ref 14-7* submission_time 216 based fixed bin(71,0) level 3 dcl 5-6 ref 508 substr builtin function dcl 168 ref 791 794 796 843 878 880 suffixed_name_$make 000046 constant entry external dcl 135 ref 553 635 734 917 suppress_name_sw 1(01) 000672 automatic bit(1) initial level 3 packed packed unaligned dcl 14-7 set ref 14-7* suppress_spacing 1(04) 000672 automatic bit(1) initial level 3 packed packed unaligned dcl 14-7 set ref 14-7* switches 1 000672 automatic structure level 2 dcl 14-7 sys_dir 10 000110 external static char(168) level 3 dcl 1-27 set ref 563 574* 578* 739 755* 760* 926 928* 934* tape_loc 36 based fixed bin(35,0) array level 3 dcl 7-39 set ref 977* temp 001010 automatic fixed bin(71,0) dcl 894 set ref 898* 901 test_name 000336 automatic char(32) packed unaligned dcl 63 set ref 791* 792 to_time 100 based fixed bin(71,0) level 2 in structure "rvce" dcl 6-22 in procedure "retv_vol_control_" set ref 702* to_time 104 based fixed bin(71,0) level 4 in structure "retv_input" dcl 5-6 in procedure "retv_vol_control_" ref 284 285 286 287 329 396 507 507 702 type 000505 automatic fixed bin(17,0) dcl 90 set ref 200* 215 227 228 229 229 424 uid 35 based bit(36) array level 3 in structure "v2_backup_volume_contents" dcl 7-26 in procedure "retv_vol_control_" ref 990 uid 000506 automatic bit(36) packed unaligned dcl 91 in procedure "retv_vol_control_" set ref 181* 200* 207 227 696 781 uid 23 based bit(36) array level 3 in structure "v1_backup_volume_contents" dcl 7-17 in procedure "retv_vol_control_" ref 974 uid 202 based bit(36) level 3 in structure "retv_input" dcl 5-6 in procedure "retv_vol_control_" set ref 712 715* uid 35 based bit(36) array level 3 in structure "backup_volume_contents" dcl 7-39 in procedure "retv_vol_control_" set ref 781 974* 990* uid based bit(36) level 2 in structure "rvce" dcl 6-22 in procedure "retv_vol_control_" set ref 696* 715 unspec builtin function dcl 161 ref 886 unused 21(02) based bit(34) array level 4 packed packed unaligned dcl 2-6 set ref 515* use 000723 automatic bit(1) packed unaligned dcl 479 in procedure "update_volume_list" set ref 506* 507* 508* 509* 512 use 21 based bit(1) array level 4 in structure "retv_volume_list" packed packed unaligned dcl 2-6 in procedure "retv_vol_control_" set ref 383* 388 512* 512 527* v1_backup_volume_contents based structure level 1 dcl 7-17 v2_backup_volume_contents based structure level 1 dcl 7-26 vdtd 77 based bit(36) level 2 in structure "rvce" dcl 6-22 in procedure "retv_vol_control_" set ref 698* vdtd 000507 automatic bit(36) dcl 92 in procedure "retv_vol_control_" set ref 182* 200* 698 version 000672 automatic fixed bin(17,0) level 2 in structure "query_info" dcl 14-7 in procedure "retv_vol_control_" set ref 522* version 2015 based fixed bin(17,0) level 2 in structure "backup_volume_log" dcl 8-20 in procedure "retv_vol_control_" ref 566 566 566 version based fixed bin(17,0) level 2 in structure "retv_vol_control" dcl 6-8 in procedure "retv_vol_control_" set ref 648* version 10 based fixed bin(17,0) level 2 in structure "backup_volume_contents" dcl 7-39 in procedure "retv_vol_control_" set ref 746 749 954* 955 960 966* 973 979 vlp 264 000110 external static pointer level 3 in structure "retv_data_" dcl 1-27 in procedure "retv_vol_control_" ref 192 vlp 000652 automatic pointer dcl 2-4 in procedure "retv_vol_control_" set ref 192* 381 382 383 385 387 388 389 390 391 392 402 405 494 494 494 498 499 499 510 511 512 512 514 515 515 517 517 518 518 519 527 837 837 837 837 843 843 844 847 872 878 880 880 886 vlx 000724 automatic fixed bin(17,0) dcl 480 in procedure "update_volume_list" set ref 499* 504* 510 511 512 512 514 515 515 517 517 518 518 519 527 vlx 000510 automatic fixed bin(17,0) dcl 93 in procedure "retv_vol_control_" set ref 328* 379* 381 382 383* 385 837 837 837 837 843 843 844 847 872 878 880 880 886 volid 21 based bit(36) level 2 in structure "v1_backup_volume_contents" dcl 7-17 in procedure "retv_vol_control_" ref 962 volid 21 based bit(36) level 2 in structure "v2_backup_volume_contents" dcl 7-26 in procedure "retv_vol_control_" ref 957 volid 21 based bit(36) level 2 in structure "backup_volume_contents" dcl 7-39 in procedure "retv_vol_control_" set ref 749 957* 962* volid 11 based bit(36) level 2 in structure "retv_vol_control" dcl 6-8 in procedure "retv_vol_control_" set ref 650* volid 000511 automatic bit(36) packed unaligned dcl 94 in procedure "retv_vol_control_" set ref 390* 650 749 volid 12 based bit(36) array level 3 in structure "retv_volume_list" dcl 2-6 in procedure "retv_vol_control_" set ref 390 494 511* 886* volid 16 based bit(36) level 2 in structure "bvle" dcl 8-39 in procedure "retv_vol_control_" ref 267 272 277 494 511 volname 11 based char(32) level 2 in structure "v2_backup_volume_contents" dcl 7-26 in procedure "retv_vol_control_" ref 956 volname 2 based char(32) array level 3 in structure "retv_volume_list" dcl 2-6 in procedure "retv_vol_control_" set ref 382 389 494 510* 837 837 837 837 843* 843 844 847* 872 878 880 880 volname 1 based char(32) array level 3 in structure "retv_skip_list" dcl 13-5 in procedure "retv_vol_control_" set ref 492 529* volname 11 based char(32) level 2 in structure "v1_backup_volume_contents" dcl 7-17 in procedure "retv_vol_control_" ref 961 volname 1 based char(32) level 2 in structure "retv_vol_control" dcl 6-8 in procedure "retv_vol_control_" set ref 649* volname 2 based char(32) level 2 in structure "bvle" dcl 8-39 in procedure "retv_vol_control_" set ref 299 492 494 510 523* 529 volname 000512 automatic char(32) packed unaligned dcl 95 in procedure "retv_vol_control_" set ref 389* 396 403* 635* 637* 649 734* 736* 749 917* 919* 966* volname 11 based char(32) level 2 in structure "backup_volume_contents" dcl 7-39 in procedure "retv_vol_control_" set ref 749 956* 961* volume_id 000650 automatic structure level 1 dcl 107 set ref 886 vtoce_derived_volname 000522 automatic char(32) packed unaligned dcl 96 set ref 174* 299* 396 396 710 vtoce_volid 000534 automatic bit(36) array packed unaligned dcl 98 set ref 180* 200* 242 242 242 267 267 272 272 277 277 vtoce_volname 104(03) based bit(1) level 3 packed packed unaligned dcl 6-22 set ref 710* yes_or_no_sw 1 000672 automatic bit(1) initial level 3 packed packed unaligned dcl 14-7 set ref 14-7* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. Multics_ID_String internal static char(32) initial packed unaligned dcl 11-92 STATE_BUMPED internal static fixed bin(17,0) initial dcl 4-46 STATE_DEFERRED internal static fixed bin(17,0) initial dcl 4-42 STATE_DUPT internal static fixed bin(17,0) initial dcl 4-47 STATE_ELIGIBLE internal static fixed bin(17,0) initial dcl 4-44 STATE_RUNNING internal static fixed bin(17,0) initial dcl 4-45 STATE_TRANSITION internal static fixed bin(17,0) initial dcl 4-43 STATE_UNPROCESSED internal static fixed bin(17,0) initial dcl 4-41 backup_version_1 internal static fixed bin(17,0) initial dcl 12-7 backup_volume_contents_names based structure level 1 dcl 7-56 bpvip automatic pointer dcl 10-3 contents_type internal static fixed bin(17,0) initial dcl 9-21 dir_type internal static fixed bin(17,0) initial dcl 9-16 hdp automatic pointer dcl 9-3 info_type internal static fixed bin(17,0) initial dcl 9-22 labelp automatic pointer dcl 11-16 null_type internal static fixed bin(17,0) initial dcl 9-18 pattern1 internal static bit(36) initial packed unaligned dcl 9-24 pattern2 internal static bit(36) initial packed unaligned dcl 9-25 pattern3 internal static bit(36) initial packed unaligned dcl 9-26 prev_output_log_type internal static fixed bin(17,0) initial dcl 9-20 query_info_version_3 internal static fixed bin(17,0) initial dcl 14-33 query_info_version_4 internal static fixed bin(17,0) initial dcl 14-34 query_info_version_6 internal static fixed bin(17,0) initial dcl 14-36 queue_dir internal static char(168) initial packed unaligned dcl 1-23 queue_msg_hdr_version_1 internal static fixed bin(17,0) initial dcl 4-37 requestp automatic pointer dcl 3-3 retv_data_version_1 internal static fixed bin(17,0) initial dcl 1-18 retv_request_version_2 internal static fixed bin(17,0) initial dcl 3-5 seg_type internal static fixed bin(17,0) initial dcl 9-17 user internal static fixed bin(17,0) initial dcl 1-24 volume_log_type internal static fixed bin(17,0) initial dcl 9-19 vtoce_type internal static fixed bin(17,0) initial dcl 9-15 NAMES DECLARED BY EXPLICIT CONTEXT. access_ok 001404 constant label dcl 234 ref 228 229 bad_seg 004161 constant label dcl 642 bad_volid 005577 constant label dcl 874 ref 883 convert_contents_seg 006276 constant entry internal dcl 946 ref 746 create_control_seg 004032 constant entry internal dcl 621 ref 690 find_contents_names_seg 005731 constant entry internal dcl 910 ref 783 find_contents_names_seg_ret 006275 constant label dcl 937 ref 924 find_contents_seg 004517 constant entry internal dcl 727 ref 393 find_contents_seg_ret 005024 constant label dcl 760 ref 743 find_volume_log 003273 constant entry internal dcl 540 ref 245 318 find_volume_log_ret 003633 constant label dcl 578 ref 561 finish 002460 constant label dcl 438 ref 213 220 233 248 253 434 691 get_open_time 005673 constant entry internal dcl 893 ref 345 355 362 366 get_volname 005407 constant entry internal dcl 831 ref 380 gotit 005267 constant label dcl 802 ref 792 796 lock_volume_log 003702 constant entry internal dcl 589 ref 250 323 600 log_uid 004366 constant entry internal dcl 685 ref 401 411 no_volog 001441 constant label dcl 247 ref 319 request 005410 constant label dcl 836 ref 841 848 retry_update 005303 constant label dcl 819 ref 823 retv_vol_control_ 000666 constant entry external dcl 22 search_contents_seg 005067 constant entry internal dcl 772 ref 410 set_volid_ 005554 constant entry internal dcl 858 ref 845 sort 002660 constant entry external dcl 451 status 000757 constant label dcl 200 ref 436 term_contents_segs 006667 constant entry internal dcl 1006 ref 412 unlock_volume_log 004012 constant entry internal dcl 608 ref 449 599 update_queue_message 005302 constant entry internal dcl 815 ref 716 update_volume_list 002753 constant entry internal dcl 478 ref 339 344 350 354 361 367 374 volog_lock_err 001503 constant label dcl 252 ref 324 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 7720 10032 7174 7730 Length 10650 7174 112 601 524 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME retv_vol_control_ 886 external procedure is an external procedure. update_volume_list internal procedure shares stack frame of external procedure retv_vol_control_. find_volume_log 180 internal procedure enables or reverts conditions. on unit on line 558 64 on unit lock_volume_log 92 internal procedure calls itself recursively. unlock_volume_log 70 internal procedure is called by several nonquick procedures. create_control_seg internal procedure shares stack frame of external procedure retv_vol_control_. log_uid internal procedure shares stack frame of external procedure retv_vol_control_. find_contents_seg 220 internal procedure enables or reverts conditions. on unit on line 740 64 on unit search_contents_seg internal procedure shares stack frame of external procedure retv_vol_control_. update_queue_message internal procedure shares stack frame of external procedure retv_vol_control_. get_volname internal procedure shares stack frame of external procedure retv_vol_control_. set_volid_ internal procedure shares stack frame of external procedure retv_vol_control_. get_open_time internal procedure shares stack frame of external procedure retv_vol_control_. find_contents_names_seg 164 internal procedure enables or reverts conditions. on unit on line 922 64 on unit convert_contents_seg internal procedure shares stack frame of internal procedure find_contents_seg. term_contents_segs internal procedure shares stack frame of external procedure retv_vol_control_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME find_contents_seg 000114 contents_idx convert_contents_seg retv_vol_control_ 000100 answer retv_vol_control_ 000102 message retv_vol_control_ 000202 char_num retv_vol_control_ 000212 comp_cycle_uid retv_vol_control_ 000213 found retv_vol_control_ 000214 comp_indx retv_vol_control_ 000216 comp_open_time retv_vol_control_ 000220 cons_cycle_uid retv_vol_control_ 000221 cons_indx retv_vol_control_ 000222 cons_open_time retv_vol_control_ 000224 contents_idx retv_vol_control_ 000225 control_name retv_vol_control_ 000235 dirname retv_vol_control_ 000307 done retv_vol_control_ 000310 emode retv_vol_control_ 000311 ename retv_vol_control_ 000321 entry_name retv_vol_control_ 000331 entry_retrieval retv_vol_control_ 000332 rvlx retv_vol_control_ 000333 idx retv_vol_control_ 000334 lns retv_vol_control_ 000335 logged retv_vol_control_ 000336 test_name retv_vol_control_ 000346 ignore retv_vol_control_ 000347 incr_indx retv_vol_control_ 000350 incr_close_time retv_vol_control_ 000352 cons_close_time retv_vol_control_ 000354 comp_close_time retv_vol_control_ 000356 incr_open_time retv_vol_control_ 000360 latest_indx retv_vol_control_ 000361 link_retrieval retv_vol_control_ 000362 lock retv_vol_control_ 000363 lsearch_name retv_vol_control_ 000374 ncp retv_vol_control_ 000376 nelemt retv_vol_control_ 000377 no_contents_seg retv_vol_control_ 000400 num retv_vol_control_ 000401 object_retrieval retv_vol_control_ 000402 old_dirname retv_vol_control_ 000454 open_time retv_vol_control_ 000456 parent_check retv_vol_control_ 000457 pmode retv_vol_control_ 000460 psearch_name retv_vol_control_ 000470 pvid retv_vol_control_ 000471 recursion_level retv_vol_control_ 000472 search_name retv_vol_control_ 000502 sortx retv_vol_control_ 000503 sorty retv_vol_control_ 000504 start_numeric retv_vol_control_ 000505 type retv_vol_control_ 000506 uid retv_vol_control_ 000507 vdtd retv_vol_control_ 000510 vlx retv_vol_control_ 000511 volid retv_vol_control_ 000512 volname retv_vol_control_ 000522 vtoce_derived_volname retv_vol_control_ 000532 fcbp retv_vol_control_ 000534 vtoce_volid retv_vol_control_ 000537 dump_type retv_vol_control_ 000540 nsp retv_vol_control_ 000542 local_rvce retv_vol_control_ 000650 volume_id retv_vol_control_ 000652 vlp retv_vol_control_ 000654 rvcp retv_vol_control_ 000656 rvcep retv_vol_control_ 000660 contentsp retv_vol_control_ 000662 contents_namesp retv_vol_control_ 000664 bvlp retv_vol_control_ 000666 bvlep retv_vol_control_ 000670 skip retv_vol_control_ 000672 query_info retv_vol_control_ 000722 new_entry update_volume_list 000723 use update_volume_list 000724 vlx update_volume_list 000725 sortx update_volume_list 000736 nvol_idx create_control_seg 000737 insert_idx create_control_seg 000756 startx search_contents_seg 000757 endx search_contents_seg 001010 temp get_open_time 001012 jdx get_open_time 001022 segp term_contents_segs THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as r_ne_as 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 set_chars_eis index_chars_eis THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. command_query_ cv_dec_check_ expand_pathname_ get_temp_segment_ hc_backup_$retv_status hcs_$fs_move_seg hcs_$initiate hcs_$make_seg hcs_$terminate_noname ioa_ ioa_$nnl ioa_$rsnnl iox_$get_line mdc_$find_volname message_segment_$update_message_index msf_manager_$close msf_manager_$get_ptr msf_manager_$open release_temp_segment_ retv_notify_ retv_report_$error_output retv_report_$online_output set_lock_$lock set_lock_$unlock suffixed_name_$make THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$action_not_performed error_table_$bad_segment error_table_$bad_volid error_table_$invalid_lock_reset error_table_$locked_by_this_process error_table_$segfault iox_$user_input retv_data_ LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 14 7 000630 22 000662 172 000674 173 000676 174 000677 175 000702 176 000705 177 000706 178 000707 179 000710 180 000711 181 000722 182 000723 183 000724 184 000725 185 000726 186 000727 187 000733 188 000736 191 000737 192 000743 194 000746 195 000754 200 000757 206 001047 207 001056 209 001062 211 001130 212 001152 213 001155 215 001156 216 001161 218 001227 219 001251 220 001254 227 001255 228 001262 229 001277 230 001311 231 001357 232 001362 233 001403 234 001404 236 001411 242 001413 245 001431 246 001435 247 001441 248 001471 250 001472 251 001500 252 001503 253 001536 255 001537 257 001541 258 001543 259 001544 260 001545 261 001546 262 001547 263 001550 265 001553 266 001561 267 001565 268 001572 269 001574 270 001576 271 001600 272 001601 273 001606 274 001610 275 001612 276 001614 277 001615 278 001622 279 001624 280 001626 282 001630 284 001633 285 001640 286 001643 287 001646 290 001651 291 001653 292 001656 293 001661 296 001664 297 001674 298 001676 299 001702 315 001705 317 001717 318 001723 319 001727 322 001733 323 001735 324 001741 327 001744 328 001746 329 001747 330 001756 331 001760 332 001761 333 001762 334 001763 335 001764 336 001773 337 001777 338 002002 339 002013 342 002026 344 002027 345 002030 347 002032 348 002033 349 002035 350 002037 352 002045 354 002046 355 002047 356 002051 358 002053 359 002054 360 002056 361 002060 362 002063 363 002065 365 002066 366 002070 367 002072 370 002073 371 002076 372 002077 373 002105 374 002111 375 002112 376 002115 378 002116 379 002117 380 002124 381 002125 382 002133 383 002144 384 002146 385 002150 387 002153 388 002163 389 002170 390 002174 391 002176 392 002201 393 002203 394 002207 395 002213 396 002215 401 002236 402 002237 403 002245 405 002275 408 002302 410 002303 411 002305 412 002311 415 002312 416 002314 423 002315 424 002316 425 002323 426 002325 427 002330 428 002333 429 002357 430 002362 432 002432 433 002435 434 002456 436 002457 438 002460 440 002465 441 002510 443 002512 444 002517 446 002622 447 002644 449 002647 450 002655 451 002656 458 002666 459 002672 460 002673 461 002703 462 002713 463 002721 464 002731 465 002735 466 002742 469 002746 470 002750 471 002752 478 002753 489 002754 491 002764 492 002773 493 003005 494 003007 497 003033 498 003035 499 003040 500 003044 501 003046 503 003047 504 003050 506 003051 507 003053 508 003064 509 003071 510 003076 511 003105 512 003110 513 003117 514 003122 515 003124 516 003130 517 003131 518 003136 519 003143 521 003145 522 003153 523 003155 526 003247 527 003254 528 003260 529 003261 532 003271 540 003272 546 003300 547 003303 548 003306 549 003332 550 003336 551 003362 553 003363 554 003411 555 003415 556 003444 558 003445 559 003461 560 003465 561 003470 563 003473 564 003543 565 003550 566 003552 572 003573 573 003575 574 003600 578 003633 581 003700 589 003701 594 003707 595 003726 596 003736 597 003742 598 003773 599 003776 600 004003 602 004010 608 004011 612 004017 613 004031 621 004032 634 004033 635 004035 636 004064 637 004067 638 004116 640 004117 641 004155 642 004161 644 004211 647 004212 648 004215 649 004217 650 004223 651 004225 652 004227 653 004231 655 004252 656 004254 657 004261 658 004264 659 004266 661 004320 662 004324 664 004325 665 004326 666 004332 668 004333 669 004334 670 004343 671 004351 672 004354 673 004362 677 004363 678 004365 685 004366 690 004367 691 004370 692 004374 693 004376 694 004377 695 004403 696 004405 697 004407 698 004411 699 004413 700 004416 701 004421 702 004424 703 004431 704 004433 705 004437 706 004443 707 004450 708 004454 709 004457 710 004464 711 004474 712 004501 713 004503 714 004506 715 004510 716 004512 718 004513 719 004515 727 004516 733 004524 734 004527 735 004555 736 004561 737 004610 739 004611 740 004702 741 004717 742 004723 743 004726 745 004731 746 004736 748 004743 749 004750 753 004763 754 004765 755 004771 760 005024 764 005066 772 005067 779 005071 780 005075 781 005104 782 005111 783 005117 784 005123 785 005127 786 005140 787 005153 788 005173 789 005175 790 005210 791 005212 792 005220 793 005224 794 005226 795 005245 796 005246 799 005257 800 005266 802 005267 803 005274 806 005275 807 005301 815 005302 819 005303 821 005330 822 005335 823 005360 825 005361 826 005406 831 005407 836 005410 837 005424 839 005453 840 005456 841 005474 843 005475 844 005513 845 005521 846 005522 847 005525 848 005552 850 005553 858 005554 872 005555 873 005573 874 005577 875 005603 878 005604 879 005617 880 005621 882 005636 883 005660 884 005663 886 005665 887 005672 893 005673 896 005675 897 005704 898 005711 900 005721 901 005724 910 005730 916 005736 917 005741 918 005773 919 005777 920 006026 922 006027 923 006043 924 006047 926 006052 927 006130 928 006135 930 006171 932 006172 934 006224 937 006275 946 006276 948 006277 949 006322 950 006326 951 006352 952 006355 954 006356 955 006361 956 006365 957 006370 958 006372 959 006374 960 006375 961 006377 962 006402 963 006404 964 006406 966 006407 968 006443 969 006446 970 006467 972 006470 973 006477 974 006504 975 006512 976 006515 977 006520 978 006521 979 006522 980 006524 981 006535 982 006543 983 006546 985 006547 987 006556 990 006562 992 006567 993 006571 994 006612 995 006616 996 006642 998 006645 999 006666 1006 006667 1011 006670 1012 006672 1014 006710 1017 006737 ----------------------------------------------------------- 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