COMPILATION LISTING OF SEGMENT manage_volume_pool Compiled by: Multics PL/I Compiler, Release 33e, of October 6, 1992 Compiled at: ACTC Technologies Inc. Compiled on: 10/19/92 1555.9 mdt Mon Options: optimize map 1 /****^ ********************************************************* 2* * * 3* * Copyright, (C) BULL HN Information Systems Inc., 1991 * 4* * * 5* * Copyright, (C) Honeywell Bull Inc., 1988 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* ********************************************************* */ 11 12 manage_volume_pool: mvp: mvp_: manage_volume_pool_: proc; 13 14 /* 15* 16* Written 02/18/76 by Richard Bratt 17* 18* Last Modified: 19* 20* 09/10/76 by R. Bratt to add use and print requests. 21* 2/1/77 by D. Vinograd to lock data base, interface to volume dumper, and to be a bit more 22* 9/79 by D. Vinograd to add entries list and check for consistences uses by volume dumper 23* and to reformat volume pool. 24* 11/81 by B. Braun to add subroutine move_to_head so volumes are kept in descending order. 25* 08/03/82 by B. Braun to correct fatal error (phx13239 phx13215), to correct $set_pool_path entry (phx11528), 26* correct $check_reserved (phx11548). 27* 12/01/82 by B. Braun to extensively change the command interface as defined by MCRs 5898 and 6056. This 28* includes new keys, new control arguments and support of volume sets. 29* 10/31/83 by B. Braun to fix error in convert routine resulting in trashed volume pools. 30* 11/22/83 by B. Braun to fix another error in convert routine resulting in the list key printing a garbage line (phx16394). 31* 12/02/83 by B. Braun to fix the bit_count calculation and truncate the pool int finish procedure. 32* 12/05/83 by B. Braun to change volume_pool structure to take up less room (version 3). Fix a SERIOUS 33* bug in add_key where set secondary_idx and primary_idx to no_link. 34* 12/21/83 by B. Braun to set variable retl to chars not words. 35* 04/16/84 by B. Braun to improve list performance by not buffering to a temp seg first (phx17312). 36* This also fixes a possible size condition bug as the temp seg is not used (mcr6783). 37* 04/18/84 by B. Braun to add control args -allocate and -reserve to the list key. To complain about 38* incompatable args with the "list -total". Fix bug so "[mvp ls -com -edt]" works. 39**/ 40 41 42 /****^ HISTORY COMMENTS: 43* 1) change(88-07-02,GDixon), approve(88-07-25,MCR7937), 44* audit(88-07-28,Lippard), install(88-08-01,MR12.2-1072): 45* Change the set key to add -state_date, allowing the user to set the 46* state_date field to an explicit value. This can be important to the reuse 47* operation. 48* 2) change(91-10-25,Schroth), approve(91-11-28,MECR0015), 49* audit(91-11-25,WAAnderson), install(91-11-28,MR12.5-1001): 50* Correct MR12.4 source code corruption. 51* 3) change(92-05-14,Schroth), approve(91-11-25,MCR8251), 52* audit(92-09-22,WAAnderson), install(92-09-24,MR12.5-1016): 53* Replace MECR0015: Correct MR12.4 source code corruption. 54* 4) change(92-09-16,WAAnderson), approve(92-09-16,MCR8262), 55* audit(92-10-06,Vu), install(92-10-19,MR12.5-1028): 56* The active function call [mvp l -tt] on very large volume pools failed due 57* to insufficient stack space. This occurred due to a misplaced call to 58* shorten_stack. Also checked to make sure request was made as an active 59* function and the totals were not wanted before adding volume names into 60* the return string. 61* END HISTORY COMMENTS */ 62 63 64 /* 65* manage_volume_pool provides a simple librarian to keep track of a user's volumes. It uses a segment named 66* .volumes in the user's home directory. as its data base. 67* 68* USAGE: manage_volume_pool {key} {-control_args} 69* 70* where key may be: 71* 72* "add" or "a" to add volumes to the library. 73* "allocate" or "alloc" marks volumes as in use. 74* "append_volume_set" or "appvs" to increase the size of a volume set. 75* "delete" or "dl" to delete volumes from the library. 76* "free" returns volumes to the free pool. 77* "list" or "l" to list specific volumes in the library. If no arguments are 78* given then all volumes owned by the user are listed. 79* "print" or "pr" or "p" prints the pathname of the volume pool currently in use. 80* "pv_expire" or "pvexp" marks volumes as physically expired in the pool. 81* "remove_volume_set" or "rmvs" removes volumes from a volume set thereby shrinking the volume set. 82* "reserve" or "rsv" marks a volume as reserved. A reserved volume is not free and can be allocated 83* in the normal manner. 84* "reuse" frees and re-allocates an allocated volume set. 85* "set" is the means to set the expiration dates and comment fields of a volume set. 86* "test" tests whether a volume is in a given state. 87* "use" or "u" specifies that a different volume pool is to be used. 88* 89* The state of a volume is validated to be consistent with a request before 90* the request is honored. To facilitate use of this proc, all the entries 91* may be invoked as an active functions. 92* 93* USAGE: [manage_volume_pool alloc volume_requested] returns the volume assigned 94* 95* A volume may also be tested to see if it is free by using the test entry which returns "true" or "false". 96* 97* USAGE: [manage_volume_pool test volume_requested] returns "true" or "false" 98* 99**/ 100 101 102 dcl Plisted ptr; 103 dcl Pvolume ptr; 104 dcl Ptvol ptr; 105 dcl a_code fixed bin (35); 106 dcl a_comment char (*); 107 dcl a_match_str char (*) varying; 108 dcl a_most_recent bit(1); 109 dcl a_number fixed bin; 110 dcl a_path char (*); 111 dcl a_requested char (*); 112 dcl a_state fixed bin; 113 dcl a_time fixed bin (71); 114 dcl a_volid bit (36); 115 dcl a_volname char (*); 116 dcl a_volumes char (*) var; 117 dcl a_vpp ptr; 118 dcl abort_sw bit(1); 119 dcl ac fixed bin; 120 dcl active_fnc bit (1); 121 dcl al fixed bin(21); 122 dcl ala fixed bin(21); 123 dcl all_states bit (1); 124 dcl all_sw bit(1); 125 dcl alloc_sw bit (1); 126 dcl alp ptr; 127 dcl ap ptr; 128 dcl apa ptr; 129 dcl areap ptr; 130 dcl arg char (al) based (ap); 131 dcl arg2 char (ala) based (apa); 132 dcl asterisk_cnt fixed bin; 133 dcl asterisk_sw bit(1); 134 dcl based_area area based (areap); 135 dcl bit_count fixed bin(24); 136 dcl brief_sw bit(1); 137 dcl code fixed bin (35); 138 dcl com_len fixed bin(21); 139 dcl com_ptr ptr; 140 dcl comment_str char(com_len) based (com_ptr); 141 dcl comment_sw bit(1); 142 dcl compare char (64); 143 dcl dfmt_sw bit(1); 144 dcl ecode fixed bin (35); 145 dcl edt_sw bit(1); 146 dcl expire_len fixed bin(21); 147 dcl expire_ptr ptr; 148 dcl expire_str char(expire_len) based (expire_ptr); 149 dcl expire_sw bit(1); 150 dcl first_sw bit(1); 151 dcl first_last_sw bit(1); 152 dcl fexp_sw bit(1); 153 dcl force_sw bit(1); 154 dcl free_sw bit (1); 155 dcl header_output char (256) var; 156 dcl header_len fixed bin; 157 dcl header_to_be_printed bit(1); 158 dcl header_sw bit (1); 159 dcl ignore fixed bin (35); 160 dcl last_sw bit(1); 161 dcl listed_flag (1:volume_pool.n_vol) bit(1) based (Plisted); 162 dcl lock bit (1); 163 dcl match_string char (64) var; 164 dcl match_sw bit (1); 165 dcl most_recent bit(1); 166 dcl myname char (32); 167 dcl name_sw bit (1); 168 dcl narg fixed bin init(-1); 169 dcl new_vpp ptr; 170 dcl noaction_msg char(256) var; 171 dcl noaction_cnt fixed bin; 172 dcl noaction_str bit(volume_cnt) based (addr(volume.noaction)); 173 dcl none_sw bit(1); 174 dcl output char (256) var; 175 dcl output_len fixed bin; 176 dcl pvedt_sw bit(1); 177 dcl pvexp_str char(pvexp_len) based (pvexp_ptr); 178 dcl pvexp_len fixed bin(21); 179 dcl pvexp_ptr ptr; 180 dcl pvexp_sw bit(1); 181 dcl requoted_output char (512) var; 182 dcl reserve_sw bit(1); 183 dcl ret char (retl) var based (retp); 184 dcl retl fixed bin(21); 185 dcl retp ptr; 186 dcl sdt_sw bit (1); 187 dcl state_dt_clock fixed bin(71); 188 dcl state_dt_str char(state_dt_len) based (state_dt_ptr); 189 dcl state_dt_len fixed bin(21); 190 dcl state_dt_ptr ptr; 191 dcl state_dt_sw bit (1); 192 dcl state_sw bit (1); 193 dcl tcnt fixed bin; 194 dcl total_cnt fixed bin; 195 dcl totals_wanted bit(1); 196 dcl vol_msg_list char(256) var; 197 dcl vol_msg_cnt fixed bin; 198 dcl volume_cnt fixed bin; 199 dcl vs_sw bit(1); 200 dcl vs_size fixed bin; 201 dcl specified_states(4) bit(1) unal; 202 dcl state_string bit(4) unal based (addr(specified_states)); 203 dcl svol_sw bit(1); 204 dcl subroutine bit (1); 205 dcl tdir char (168); 206 dcl tname char (32); 207 dcl tvlx fixed bin; 208 dcl vlx fixed bin (17); 209 dcl vol_cnt fixed bin; 210 dcl volume_sw bit(1); 211 dcl volume_state fixed bin; 212 dcl vp_bc fixed bin(24); 213 dcl vpp ptr; 214 dcl want_str bit(volume_cnt) based (addr(volume.want_it)); 215 dcl word_count fixed bin(19); 216 dcl yes_sw bit(1); 217 218 dcl 1 vol_list(1:17) aligned, 219 2 name char(256) var, 220 2 cnt fixed bin; 221 222 dcl 1 tvol aligned based (Ptvol), 223 2 name(tcnt) char(32), 224 2 indx(tcnt) fixed bin, 225 2 switches, 226 3 noaction(tcnt) bit(1) unal, 227 3 want_it(tcnt) bit(1)unal; 228 229 dcl 1 volume aligned based (Pvolume), 230 2 name(volume_cnt) char(32), 231 2 indx(volume_cnt) fixed bin, 232 2 switches, 233 3 noaction(volume_cnt) bit(1) unal, 234 3 want_it(volume_cnt) bit(1)unal; 235 236 dcl 1 volume_pool_header aligned, 237 2 version fixed bin, /* version 3 structure */ 238 2 lock bit (36), 239 2 n_vol fixed bin (17), /* number of volume slots in the pool, free and occupied */ 240 2 volume_count fixed bin(17), /* number of volumes in the pool */ 241 2 head fixed bin (17), /* index into first volume in pool */ 242 2 tail fixed bin (17), /* index to last volume in pool */ 243 2 free_head fixed bin (17), /* index to first empty slot in array */ 244 2 pad bit (36); 245 246 dcl 1 volume_pool_entry aligned, /* volume pool entry. each volume has one assoc. with it */ 247 2 name char (32), /* name of volume set */ 248 2 id bit (36), /* used by volume dumper only */ 249 2 state fixed bin, /* state of the volume */ 250 2 state_date fixed bin (71), /* date the volume was last acted upon */ 251 2 pv_expire_date fixed bin(71), /* physical volume expiration date */ 252 2 expire_date fixed bin(71), /* allocated volume expiration date */ 253 2 processid bit (36), /* used when reserving volume */ 254 2 comment char (64), 255 2 switches unaligned, 256 3 secondary_vol bit(1), /* true if volume is a part of a multiple volume set */ 257 3 pv_expire bit(1), /* true if a physical volume expiration date is assoc. with the volume */ 258 3 expire bit(1), /* true if an expire date is associated with the volume */ 259 3 already_printed bit(1), /* used in listing purposes */ 260 3 pad1 bit(32), 261 2 vs_count fixed bin, /* volume set count, includes primary and secondary volumes */ 262 2 next fixed bin(17), /* index to next node or volume in the pool */ 263 2 previous fixed bin(17), /* index to previous volume in pool */ 264 2 primary_idx fixed bin(17), /* index of primary volume in a set */ 265 2 secondary_idx fixed bin(17), /* index to next secondary volume in a set */ 266 2 pad2 bit (36); 267 268 dcl 1 volume_pool aligned based (vpp), /* This is the CURRENT volume pool structure */ 269 2 header like volume_pool_header, 270 2 vpe (divide(sys_info$max_seg_size - size(volume_pool_header), size(volume_pool_entry), 17) 271 refer (volume_pool.header.n_vol)) like volume_pool_entry; 272 273 /* internal static variables */ 274 275 dcl vol_ename char (32) int static init (""); 276 dcl vol_dir char (168) int static init (""); 277 278 dcl (ascii_state (4) char (5) int init ("FREE", "ALOC", "RESV", "PVEXP"), 279 blank_NL char (2) int init(" 280 "), 281 allocated_state fixed bin int init (2), 282 free_state fixed bin int init (1), 283 reserved_state fixed bin int init (3), 284 pvexp_state fixed bin int init (4), 285 no_link fixed bin int init (-1), 286 paired_args bit (1) int init ("1"b), 287 single_arg bit (1) int init ("0"b), 288 volume_pool_version_3 fixed bin init (3), 289 volume_pool_version_2 fixed bin init (2), 290 volume_pool_version_1 fixed bin init (1), 291 use char (3) init ("use"), 292 truebits bit(4) int init ("1111"b) unal, 293 True bit(1) int init ("1"b), 294 False bit(1) int init ("0"b), 295 lock_interval fixed bin int init (60)) 296 static options (constant); 297 298 dcl (already_alloc init("1000000000000000"b), 299 already_free init("0100000000000000"b), 300 already_reg init("0010000000000000"b), 301 already_sec_vol init("0001000000000000"b), 302 cant_delete init("0000100000000000"b), 303 cant_pvexp init("0000010000000000"b), 304 not_alloc init("0000001000000000"b), 305 not_free init("0000000100000000"b), 306 not_exp init("0000000010000000"b), 307 not_reg init("0000000001000000"b), 308 not_updated init("0000000000100000"b), 309 rsv_by_another init("0000000000010000"b), 310 sec_not_found init("0000000000001000"b), 311 check_pvexp init("0000000000000100"b), 312 vol_pvexp init("0000000000000010"b), 313 sec_vol init("0000000000000001"b)) 314 bit(16) unal int static options(constant); 315 dcl (fb_already_alloc init(1), 316 fb_already_free init(2), 317 fb_already_reg init(3), 318 fb_already_sec_vol init(4), 319 fb_cant_delete init(5), 320 fb_cant_pvexp init(6), 321 fb_not_alloc init(7), 322 fb_not_free init(8), 323 fb_not_exp init(9), 324 fb_not_reg init(10), 325 fb_not_updated init(11), 326 fb_rsv_by_another init(12), 327 fb_sec_not_found init(13), 328 fb_check_pvexp init(14), 329 fb_vol_pvexp init(15), 330 fb_prim_name init(17)) 331 fixed bin unal int static options(constant); 332 333 dcl err_msg(1:15) char(100)var int static options(constant) init( 334 " Volume set^[s^] ^a ^[are^;is^] already allocated.", 335 " Volume set^[s^] ^a ^[are^;is^] already free.", 336 " Volume set^[s^] ^a ^[are^;is^] already registered in the pool.", 337 " Volume^[s^] ^a ^[are^;is a^] secondary volume^[s^] of volume set ^a.", 338 " Volume set^[s^] ^a ^[are^;is^] allocated and can not be deleted.", 339 " Volume set^[s^] ^a ^[are^;is^] allocated and can not be physically expired.", 340 " Volume set^[s^] ^a ^[are^;is^] not allocated.", 341 " Volume set^[s^] ^a ^[are^;is^] not free.", 342 " Allocated volume set^[s^] ^a ^[are^;is^] not expired.", 343 " Volume^[s^] ^a ^[are^;is^] not registered.", 344 " Volume set^[s^] ^a ^[are^;is^] not allocated. It has not been updated.", 345 " Volume set^[s^] ^a ^[are^;is^] not reserved by your process.", 346 " Secondary volume^[s^] ^a not found in set ^a.", 347 " Physical volume^[s^] ^a ^[have^;has^] expired.", 348 " Volume set^[s^] ^a ^[are^;is^] physically expired."); 349 350 351 dcl cleanup condition; 352 353 /* Entries */ 354 355 dcl clock_ entry() returns(fixed bin(71)), 356 command_query_$yes_no entry() options(variable), 357 convert_date_to_binary_ entry (char(*), fixed bin(71), fixed bin(35)), 358 cu_$af_arg_ptr_rel entry (fixed bin, ptr, fixed bin, fixed bin (35), ptr), 359 cu_$af_return_arg entry (fixed bin, ptr, fixed bin(21), fixed bin(35)), 360 cu_$arg_list_ptr entry (ptr), 361 cu_$arg_ptr_rel entry (fixed bin, ptr, fixed bin(21), fixed bin (35), ptr), 362 date_time_ entry (fixed bin (71), char (*) aligned), 363 expand_pathname_ entry (char (*), char (*), char (*), fixed bin (35)), 364 get_arg variable entry (fixed bin, ptr, fixed bin(21), fixed bin (35), ptr), 365 get_process_id_ entry returns (bit (36) aligned), 366 get_ring_ entry() returns(fixed bin(3)), 367 get_system_free_area_ entry returns (ptr), 368 get_temp_segment_ entry (char (*), ptr, fixed bin (35)), 369 hcs_$fs_move_seg entry (ptr, ptr, fixed bin, fixed bin (35)), 370 hcs_$fs_get_path_name entry (ptr, char (*), fixed bin, char (*), fixed bin (35)), 371 hcs_$get_user_effmode entry (char(*), char(*), char(*), fixed bin, fixed bin(5), fixed bin(35)), 372 hcs_$make_seg entry (char (*), char (*), char (*), fixed bin (5), ptr, fixed bin (35)), 373 hcs_$set_bc entry (char(*), char(*), fixed bin(24), fixed bin(35)), 374 hcs_$terminate_noname entry (ptr, fixed bin (35)), 375 hcs_$truncate_file entry (char(*), char(*), fixed bin(19), fixed bin(35)), 376 hcs_$validate_processid entry (bit (36) aligned, fixed bin (35)), 377 initiate_file_ entry (char(*), char(*), bit(*), ptr, fixed bin(24), fixed bin(35)), 378 ioa_$general_rs entry (ptr, fixed bin, fixed bin, char (*), fixed bin, bit (1), bit (1)), 379 release_temp_segment_ entry (char (*), ptr, fixed bin (35)), 380 requote_string_ entry (char (*)) returns (char (*)), 381 set_lock_$lock entry (bit (36) aligned, fixed bin, fixed bin (35)), 382 set_lock_$unlock entry (bit (36) aligned, fixed bin (35)), 383 suffixed_name_$make entry (char (*), char (*), char (*), fixed bin (35)), 384 user_info_$homedir entry (char (*)); 385 386 dcl (active_fnc_err_, 387 com_err_, 388 ioa_, 389 ioa_$nnl, 390 ioa_$rsnnl, 391 user_info_) entry options (variable); 392 dcl (a_error_rnt, 393 abort_proc, 394 error_rnt, 395 msg_proc) entry variable options (variable); 396 397 dcl (error_table_$action_not_performed, 398 error_table_$badopt, 399 error_table_$boundviol, 400 error_table_$inconsistent, 401 error_table_$invalid_lock_reset, 402 error_table_$locked_by_this_process, 403 error_table_$lock_not_locked, 404 error_table_$noarg, 405 error_table_$process_unknown, 406 error_table_$unimplemented_version) 407 ext fixed bin (35); 408 409 /* builtins */ 410 411 dcl (addr, clock, convert, currentsize, hbound, index, 412 length, max, mod, null, 413 rtrim, substr, verify) builtin; 414 415 416 subroutine = False; 417 call setup; 418 on cleanup call finish; 419 call get_arg (1, ap, al, (0), alp); 420 if arg = "l" | arg = "ls" | arg = "list" then call list_key(); 421 else if arg = "al" | arg = "alloc" | arg = "allocate" then call determine_alloc_version(); 422 else if arg = "f" | arg = "free" then call free_key(); 423 else if arg = "a" | arg = "add" then call add_key(); 424 else if arg = "d" | arg = "dl" | arg = "delete" then call delete_key(); 425 else if arg = "r" | arg = "rsv" | arg = "reserve" then call reserve_key(); 426 else if arg = "t" | arg = "test" then call test_key(); 427 else if arg = "appvs" | arg = "append_volume_set" then call append_volume_set(); 428 else if arg = "rmvs" | arg = "remove_volume_set" then call remove_volume_set(); 429 else if arg = "reuse" then call reuse(); 430 else if arg = "set" then call set_key(); 431 else if arg = "pvexp" | arg = "pv_expire" then call pv_expire_key(); 432 else if arg = "u" | arg = "use" then call use_key(); 433 else if arg = "c" | arg = "change" /* obsolete key */ 434 then call process (paired_args, change); 435 else if arg = "cm" | arg = "comment" /* obsolete key */ 436 then call process (single_arg, comment); 437 else if arg = "p" | arg = "pr" | arg = "print" 438 then do; 439 if active_fnc then ret = path(vol_dir,vol_ename); 440 else call msg_proc (-1, "^a", path (vol_dir, vol_ename)); 441 end; 442 else call abort_proc (error_table_$badopt, arg); 443 return_to_caller: 444 call finish; 445 446 return; 447 448 449 reserve: entry (a_vpp, a_error_rnt, a_requested, a_comment, a_volname, a_code); 450 451 volume_state = reserved_state; 452 goto alloc_common; 453 454 allocate: entry (a_vpp, a_error_rnt, a_requested, a_comment, a_volname, a_code); 455 456 volume_state = allocated_state; 457 alloc_common: 458 subroutine = True; 459 call setup; 460 on cleanup call finish; 461 ap = addr (a_requested); 462 al = length (rtrim (a_requested)); 463 apa = addr (a_comment); 464 ala = length (rtrim (a_comment)); 465 call search (arg); 466 if vlx = 0 467 then if arg ^= "*" then call add; 468 else call abort_proc (0, "No free volumes."); 469 call allocate; 470 a_volname = vpe (vlx).name; 471 goto return_to_caller; 472 473 force_allocate: entry (a_vpp, a_error_rnt, a_number, a_most_recent, a_match_str, a_volumes, a_code); 474 475 /* This entry point is to facilitate TR backup and retrievals of the Trouble Report system */ 476 477 dcl volx fixed bin; 478 479 subroutine = True; 480 call setup; 481 on cleanup call finish; 482 if volume_pool.volume_count < a_number then do; /* asking for too many? */ 483 a_code = error_table_$boundviol; 484 goto return_to_caller; 485 end; 486 vol_cnt = 0; 487 volume_cnt = a_number; 488 if a_match_str = "" then match_sw = False; 489 else match_sw = True; 490 areap = get_system_free_area_(); 491 allocate volume in (based_area) set (Pvolume); 492 if a_most_recent then do; 493 volx = volume_pool.head; 494 do while ((volx ^= no_link) & (vol_cnt < volume_cnt)); /* like -first N means return the "latest" N */ 495 if vpe(volx).state = allocated_state & vpe(volx).vs_count = 1 then do; 496 if match_sw then do; 497 if (index (vpe(volx).comment, a_match_str) > 0) then do; 498 vol_cnt = vol_cnt + 1; 499 volume(vol_cnt).indx = volx; 500 volume(vol_cnt).name = vpe(volx).name; 501 end; 502 end; 503 504 else do; /* no match str specified */ 505 vol_cnt = vol_cnt + 1; 506 volume(vol_cnt).indx = volx; 507 volume(vol_cnt).name = vpe(volx).name; 508 end; 509 end; 510 volx = vpe(volx).next; 511 end; 512 end; 513 514 else do; 515 volx = volume_pool.tail; 516 do while ((volx ^= no_link) & (vol_cnt < volume_cnt)); /* got to be like -last reuse oldest N */ 517 if vpe(volx).state = allocated_state & vpe(volx).vs_count = 1 then do; 518 if match_sw then do; 519 if (index (vpe(volx).comment, a_match_str) > 0) then do; 520 vol_cnt = vol_cnt + 1; 521 volume(vol_cnt).indx = volx; 522 volume(vol_cnt).name = vpe(volx).name; 523 end; 524 end; 525 526 else do; /* no match str specified */ 527 vol_cnt = vol_cnt + 1; 528 volume(vol_cnt).indx = volx; 529 volume(vol_cnt).name = vpe(volx).name; 530 end; 531 end; 532 volx = vpe(volx).previous; 533 end; 534 end; 535 536 if (vol_cnt = 0) | (vol_cnt < volume_cnt) then do; 537 a_code = error_table_$action_not_performed; 538 goto return_to_caller; 539 end; 540 541 a_volumes = ""; 542 do volx = 1 to vol_cnt; 543 a_volumes = a_volumes || rtrim(volume(volx).name) || " "; 544 call move_to_head(volume(volx).indx); 545 end; 546 547 goto return_to_caller; 548 549 free: entry (a_vpp, a_error_rnt, a_requested, a_code); 550 subroutine = True; 551 call setup; 552 on cleanup call finish; 553 ap = addr (a_requested); 554 al = length (rtrim (a_requested)); 555 call search (arg); 556 call free; 557 goto return_to_caller; 558 559 delete: entry (a_vpp, a_error_rnt, a_requested, a_code); 560 subroutine = True; 561 call setup; 562 on cleanup call finish; 563 ap = addr (a_requested); 564 al = length (rtrim (a_requested)); 565 call search (arg); 566 call delete; 567 goto return_to_caller; 568 569 set_volid: entry (a_vpp, a_error_rnt, a_volname, a_volid, a_code); 570 571 /* This entry point is used by Volume Dumper */ 572 573 subroutine = True; 574 call setup; 575 on cleanup call finish; 576 ap = addr (a_volname); 577 al = length (rtrim (a_volname)); 578 call search (arg); 579 if vlx = 0 then call abort_proc (0, "Volume ^a is not registered.", arg); 580 vpe (vlx).id = a_volid; 581 goto return_to_caller; 582 583 check_reserved: entry (a_vpp, a_error_rnt, a_code); 584 subroutine = True; 585 call setup; 586 on cleanup call finish; 587 vlx = volume_pool.head; 588 do while (vlx ^= no_link); 589 if vpe (vlx).state = reserved_state then do; 590 if reserved_by_another_process(vlx) then; /* skip it */ 591 else do; 592 vpe (vlx).state = free_state; 593 vpe (vlx).processid = "0"b; 594 call move_to_head(vlx); 595 end; 596 end; 597 vlx = vpe(vlx).next; 598 end; 599 goto return_to_caller; 600 601 status: entry (a_vpp, a_error_rnt, a_requested, a_comment, a_time, a_state, a_code); 602 subroutine = True; 603 call setup; 604 on cleanup call finish; 605 ap = addr (a_requested); 606 al = length (rtrim (a_requested)); 607 call search (arg); 608 if vlx = 0 then 609 call abort_proc (0, "Volume ^a is not registered.", arg); 610 a_comment = vpe (vlx).comment; 611 a_time = vpe (vlx).state_date; 612 a_state = vpe (vlx).state; 613 goto return_to_caller; 614 615 set_pool_path: entry (a_error_rnt, a_path, a_vpp, a_code); 616 617 /* Returns a pointer to the volume pool specified by pathname. */ 618 619 subroutine = True; 620 a_vpp = null; 621 ap = addr (use); 622 al = length (use); 623 call setup; 624 on cleanup call finish; 625 ap = addr (a_path); 626 al = length (rtrim (a_path)); 627 call setup_pool_path("1"b); 628 goto return_to_caller; 629 630 get_pool_path: entry (a_vpp, a_error_rnt, a_path, a_code); 631 632 /* Returns the pathname of volume pool given a pointer */ 633 634 subroutine = True; 635 call setup; 636 on cleanup call finish; 637 call hcs_$fs_get_path_name (vpp, tdir, (0), tname, code); 638 if code ^= 0 639 then call abort_proc (code, "Unable to deterime pool pathname."); 640 else call ioa_$rsnnl ("^a", a_path, (0), path (tdir, tname)); 641 goto return_to_caller; 642 643 abort: proc (err) ; 644 dcl argp ptr; 645 dcl err fixed bin (35); 646 dcl str char (256); 647 dcl str_len fixed bin; 648 649 if subroutine 650 then do; 651 if err = 0 then a_code = error_table_$action_not_performed; 652 else a_code = err; 653 end; 654 call cu_$arg_list_ptr (argp); 655 /* convert args to message */ 656 call ioa_$general_rs (argp, 2, 3, str, str_len, "0"b, "0"b); 657 if lock then call set_lock_$unlock (volume_pool.lock, ignore); 658 call error_rnt (err, myname, substr (str, 1, str_len)); 659 goto return_to_caller; 660 end abort; 661 662 663 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 664 665 add: proc(); 666 667 /* old add used for subroutines only */ 668 669 if vlx ^= 0 then call abort_proc(0, "Volume ^a is already registered.", arg); 670 vlx = get_node(); 671 vpe (vlx).name = arg; 672 vpe (vlx).state = free_state; 673 vpe (vlx).comment = ""; 674 vpe (vlx).switches = False; 675 vpe (vlx).expire_date = 0; 676 vpe (vlx).pv_expire_date = 0; 677 vpe (vlx).secondary_idx, vpe (vlx).primary_idx = no_link; 678 vpe (vlx).vs_count = 1; 679 call insert_node(vlx); 680 return; 681 end add; 682 683 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 684 685 add_key: proc(); 686 687 /* Used by the command, add_key adds volumes to the pool */ 688 689 dcl pv_clock fixed bin(71), 690 (volx, vol_cnt, i) fixed bin; 691 692 /* The structure below describes the control arguments allowed for a given key. 693* A control arg is valid when the bit is "1"b. */ 694 695 dcl 1 args_allowed unaligned static int options(constant), 696 (2 first init ("0"b), 697 2 last init ("0"b), 698 2 force init ("1"b), 699 2 vs init ("0"b), 700 2 com init ("0"b), 701 2 expire init ("0"b), 702 2 brief init ("0"b), 703 2 fexp init ("0"b), 704 2 match init ("0"b), 705 2 all init ("0"b), 706 2 pvexp init ("1"b), 707 2 alloc init ("0"b), 708 2 reserve init ("0"b), 709 2 free init ("0"b), 710 2 svol init ("0"b), 711 2 asterisk init ("0"b), 712 2 exp_dt init ("0"b), 713 2 pvexp_dt init ("1"b), /* requires a date after -pvexp */ 714 2 state_dt init ("0"b)) bit(1); 715 716 if narg < 2 then call abort_proc (error_table_$noarg, "^/Usage: add volume_names {-control_arg}"); 717 718 pv_clock = 0; 719 720 call process_ctl_args(addr(args_allowed), 2, vol_cnt); 721 722 if vol_cnt = 0 then call abort_proc(0, "No volume names specified."); 723 if pvexp_sw then do; 724 call convert_date_to_binary_(pvexp_str, pv_clock, code); 725 if code ^= 0 then call abort_proc(code, pvexp_str); 726 end; 727 728 call check_for_errors(Pvolume, volume_cnt, vol_cnt, 0, already_reg); 729 730 call evaluate_volumes_wanted("added", Pvolume, volume_cnt, vol_cnt, none_sw, abort_sw); 731 if none_sw | abort_sw then do; 732 if active_fnc then do; 733 ret = "false"; 734 return; 735 end; 736 if none_sw then call abort_proc(error_table_$action_not_performed, 737 "Volume set^[s^] specified ^[are^;is^] not registered in the pool.", (vol_cnt > 1), (vol_cnt > 1)); 738 else if abort_sw then call abort_proc(error_table_$action_not_performed, "^a", noaction_msg); 739 end; 740 741 /* add volumes specified */ 742 743 do i = 1 to vol_cnt; 744 if volume(i).want_it then do; 745 if volume(i).noaction then; /* skip */ 746 else do; 747 volx = get_node(); 748 vpe (volx).name = volume(i).name; 749 vpe (volx).state = free_state; 750 vpe (volx).comment = ""; 751 vpe (volx).switches = False; 752 vpe (volx).pv_expire = pvexp_sw; 753 vpe (volx).pv_expire_date = pv_clock; 754 vpe (volx).expire_date = 0; 755 vpe (volx).secondary_idx, vpe (volx).primary_idx = no_link; 756 vpe (volx).vs_count = 1; 757 call insert_node(volx); 758 end; 759 end; 760 end; 761 762 if active_fnc then ret = "true"; 763 else if noaction_msg ^= "" then call msg_proc(0, "^a", noaction_msg); 764 765 return; 766 767 end add_key; 768 769 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 770 771 allocate: proc; 772 773 /* old allocate used by subroutine allocate and "mvp al vol_name1 comment_1 vol_name2 comment_2 ... vol_nameN comment_N" 774* command line */ 775 776 if vlx = 0 777 then if arg = "*" 778 then call abort_proc (0, "No free volumes."); 779 else call abort_proc (0, "Volume ^a is not registered.", arg); 780 if vpe (vlx).state = allocated_state then call abort_proc (0, "Volume ^a is already allocated.", arg); 781 vpe (vlx).comment = arg2; 782 if subroutine then do; 783 vpe (vlx).state = volume_state; 784 if volume_state = reserved_state then 785 vpe (vlx).processid = get_process_id_ (); 786 else vpe (vlx).processid = "0"b; 787 end; 788 else do; 789 vpe (vlx).state = allocated_state; 790 vpe (vlx).processid = "0"b; 791 end; 792 if active_fnc then ret = vpe (vlx).name; 793 else if arg = "*" & ^subroutine then call msg_proc (0, "Volume ^a allocated", vpe (vlx).name); 794 call move_to_head(vlx); 795 return; 796 end allocate; 797 798 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 799 800 allocate_key: proc(); 801 802 /* Used by the mvp command to allocate volume sets in the pool. */ 803 804 dcl exp_clock fixed bin (71); 805 dcl (i, vol_cnt, volx) fixed bin; 806 807 /* The structure below describes the control arguments allowed for a given key. 808* A control arg is valid when the bit is "1"b. */ 809 810 dcl 1 args_allowed unaligned static int options(constant), 811 (2 first init ("1"b), 812 2 last init ("1"b), 813 2 force init ("1"b), 814 2 vs init ("1"b), 815 2 com init ("1"b), 816 2 expire init ("1"b), 817 2 brief init ("0"b), 818 2 fexp init ("0"b), 819 2 match init ("0"b), 820 2 all init ("0"b), 821 2 pvexp init ("0"b), 822 2 alloc init ("0"b), 823 2 reserve init ("0"b), 824 2 free init ("0"b), 825 2 svol init ("0"b), 826 2 asterisk init ("0"b), 827 2 exp_dt init ("1"b), /* requires a date after -exp */ 828 2 pvexp_dt init ("0"b), 829 2 state_dt init ("0"b)) bit(1); 830 831 /* first process list control args */ 832 833 exp_clock = 0; 834 835 call process_ctl_args(addr(args_allowed), 2, vol_cnt); 836 837 if volume_sw & (vs_sw | first_last_sw) then call abort_proc(error_table_$inconsistent, 838 "volume_names ^[-volume_size^;^]^[-first^;-last^]", vs_sw, most_recent); 839 840 if expire_sw then do; 841 call convert_date_to_binary_(expire_str, exp_clock, code); 842 if code ^= 0 then call abort_proc(code, expire_str); 843 end; 844 845 if vol_cnt = 0 then vol_cnt = 1; /* vol_cnt hasn't been set yet. */ 846 847 if ^(volume_sw) then do; /* structure needs to be allocated */ 848 specified_states(free_state) = True; 849 volume_cnt = vol_cnt; 850 allocate volume in (based_area) set (Pvolume); 851 volume.want_it = False; 852 call get_volumes_specified ("allocated", specified_states, Pvolume, vol_cnt, vs_size, most_recent); 853 end; 854 855 else do; /* volume names were specified */ 856 857 call check_for_errors(Pvolume, volume_cnt, vol_cnt, 0, 858 not_reg | rsv_by_another | already_alloc | vol_pvexp | sec_vol | check_pvexp); 859 end; 860 861 call evaluate_volumes_wanted("allocated", Pvolume, volume_cnt, vol_cnt, none_sw, abort_sw); 862 if none_sw then call abort_proc(error_table_$action_not_performed, 863 "Volume set^[s^] specified ^[are^;is^] not registered in the pool.", (vol_cnt > 1), (vol_cnt > 1)); 864 else if abort_sw then call abort_proc(error_table_$action_not_performed, "^a", noaction_msg); 865 866 /* allocate volumes specified */ 867 868 vol_msg_list = ""; 869 do i = 1 to vol_cnt; 870 if volume(i).want_it then do; /* else just skip over it */ 871 if ^(volume(i).noaction) then do; 872 volx = volume(i).indx; 873 if vpe(volx).secondary_vol then volx = vpe(volx).primary_idx; 874 if vpe(volx).state = reserved_state then vpe(volx).processid = "0"b; 875 vpe (volx).state = allocated_state; 876 if comment_sw then vpe (volx).comment = comment_str; 877 else vpe (volx).comment = ""; 878 vpe (volx).expire_date = exp_clock; 879 vpe (volx).expire = expire_sw; 880 if active_fnc then ret = ret || " " || rtrim(vpe(volx).name); 881 else if (first_last_sw) then vol_msg_list = vol_msg_list || " " || rtrim(vpe(volx).name); 882 call move_to_head(volx); 883 end; 884 end; 885 end; 886 887 if ^active_fnc then do; 888 if vol_msg_list ^= "" then 889 call msg_proc(0, "Volume set^[s^] ^a ^[has^;have^] been allocated. ^[^a^;^s^]", 890 (vol_cnt > 1), vol_msg_list, (vol_cnt = 1), noaction_msg ^= "", noaction_msg); 891 else if noaction_msg ^= "" then call msg_proc(0, "^a", noaction_msg ); 892 end; 893 894 end allocate_key; 895 896 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 897 898 append_secondary_volumes: proc(old_primary_idx, new_primary_idx, last_volume_idx); 899 900 /* called by append_volume_set when appending a multiple volume set. 901* old_primary_idx: references the volume set to be appended. (input) 902* new_primary_idx: is the volume set to be appended to. (input) 903* last_volume_idx: index to the last volume in the volume set after the set is appended on. (output) 904**/ 905 906 dcl (old_primary_idx, 907 new_primary_idx, 908 last_vol, 909 next_vol, 910 last_volume_idx) fixed bin; 911 912 next_vol = vpe(old_primary_idx).secondary_idx; 913 last_vol = old_primary_idx; 914 do while (next_vol > 0); 915 if active_fnc then ret = ret || " " || rtrim(vpe(next_vol).name); 916 vpe(last_vol).secondary_idx = next_vol; 917 vpe(last_vol).vs_count = 1; 918 vpe(last_vol).previous, vpe(last_vol).next = no_link; 919 vpe(next_vol).primary_idx = new_primary_idx; 920 /* update volume set count of volume set appending to. */ 921 vpe(new_primary_idx).vs_count = vpe(new_primary_idx).vs_count + 1; 922 last_vol = next_vol; 923 next_vol = vpe(next_vol).secondary_idx; 924 end; 925 926 vpe(last_vol).secondary_idx = no_link; 927 vpe(last_vol).vs_count = 1; 928 vpe(last_vol).previous, vpe(last_vol).next = no_link; 929 last_volume_idx = last_vol; 930 931 end append_secondary_volumes; 932 933 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 934 935 append_volume_set: proc(); 936 937 /* procedure called for key append_volume_set. Appends volume sets to the set designated by the primary volume name */ 938 939 dcl i, 940 vol_cnt, 941 last_vol, 942 next_vol, 943 primary_idx fixed bin; 944 945 /* The structure below describes the control arguments allowed for a given key. 946* A control arg is valid when the bit is "1"b. */ 947 948 dcl 1 args_allowed unaligned static int options(constant), 949 (2 first init ("1"b), 950 2 last init ("1"b), 951 2 force init ("1"b), 952 2 vs init ("1"b), 953 2 com init ("0"b), 954 2 expire init ("0"b), 955 2 brief init ("0"b), 956 2 fexp init ("0"b), 957 2 match init ("0"b), 958 2 all init ("0"b), 959 2 pvexp init ("0"b), 960 2 alloc init ("0"b), 961 2 reserve init ("0"b), 962 2 free init ("0"b), 963 2 svol init ("0"b), 964 2 asterisk init ("0"b), 965 2 exp_dt init ("0"b), 966 2 pvexp_dt init ("0"b), 967 2 state_dt init ("0"b)) bit(1); 968 969 if narg < 3 then call abort_proc (error_table_$noarg, 970 "^/Usage: mvp appvs primary_volume_name {secondary_volume_names} {-control_args} "); 971 972 /* first get primary_volume_name */ 973 974 ac = 2; 975 call get_arg (ac, ap, al, (0), alp); 976 if ^(volume_in_pool((arg), primary_idx)) then call abort_proc(error_table_$action_not_performed, 977 "Specified primary volume is not in the pool. " || arg); 978 else if vpe(primary_idx).secondary_vol then call abort_proc(error_table_$action_not_performed, 979 "^/Specified primary volume ^a is a secondary volume of set ^a.", arg, 980 vpe(vpe(primary_idx).primary_idx).name); 981 982 /* now look at secondary volumes specified or control args */ 983 984 call process_ctl_args(addr(args_allowed), 3, vol_cnt); 985 986 if (vs_sw | first_last_sw) & volume_sw then call abort_proc(error_table_$inconsistent, 987 "secondary_volumes and -control_args"); 988 989 if vol_cnt = 0 then vol_cnt = 1; /* vol_cnt hasn't been set yet. */ 990 991 if ^(volume_sw) then do; /* structure needs to be allocated */ 992 specified_states(free_state) = True; 993 volume_cnt = vol_cnt; 994 allocate volume in (based_area) set (Pvolume); 995 volume.want_it = False; 996 call get_volumes_specified ("freed", specified_states, Pvolume, vol_cnt, vs_size, most_recent); 997 end; 998 999 else do; /* secondary volumes were specified */ 1000 /* validate volumes and label whether we want them or not */ 1001 1002 call check_for_errors(Pvolume, volume_cnt, vol_cnt, 0, not_reg | not_free | already_sec_vol | check_pvexp); 1003 end; 1004 1005 call evaluate_volumes_wanted("appended", Pvolume, narg, vol_cnt, none_sw, abort_sw); 1006 if none_sw then call abort_proc(error_table_$action_not_performed, 1007 "Volume set^[s^] specified ^[are^;is^] not registered in the pool.", (vol_cnt > 1), (vol_cnt > 1)); 1008 else if abort_sw then call abort_proc(error_table_$action_not_performed, "^a", noaction_msg); 1009 1010 /* append the volumes */ 1011 1012 vol_msg_list = ""; 1013 last_vol = last_volume_in_set(primary_idx); 1014 do i = 1 to vol_cnt; 1015 if volume(i).want_it then do; 1016 if ^(volume(i).noaction) then do; 1017 if active_fnc then ret = ret || " " || rtrim(volume(i).name); 1018 next_vol = volume(i).indx; 1019 vpe(last_vol).secondary_idx = next_vol; 1020 vpe(next_vol).primary_idx = primary_idx; 1021 vpe(next_vol).secondary_vol = True; 1022 if next_vol = volume_pool.head then volume_pool.head = vpe(next_vol).next; 1023 else if vpe(next_vol).previous ^= no_link then vpe(vpe(next_vol).previous).next = vpe(next_vol).next; 1024 if next_vol = volume_pool.tail then volume_pool.tail = vpe(next_vol).previous; 1025 else if vpe(next_vol).next ^= no_link then vpe(vpe(next_vol).next).previous = vpe(next_vol).previous; 1026 vpe(next_vol).next, vpe(next_vol).previous = no_link; 1027 if (first_last_sw) then do; 1028 vol_msg_list = vol_msg_list || " " || rtrim(vpe(next_vol).name); 1029 end; 1030 if vpe(next_vol).vs_count > 1 then call append_secondary_volumes(next_vol, primary_idx, last_vol); 1031 else last_vol = next_vol; 1032 vpe(primary_idx).vs_count = vpe(primary_idx).vs_count + 1; 1033 end; 1034 end; 1035 end; 1036 1037 vpe(last_vol).secondary_idx = no_link; 1038 call move_to_head(primary_idx); 1039 1040 if ^active_fnc then do; 1041 if vol_msg_list ^= "" then 1042 call msg_proc(0, "Volume^[s^] ^a ^[has^;have^] been appended.", 1043 (vol_cnt > 1), vol_msg_list, (vol_cnt = 1)); 1044 1045 if noaction_msg ^= "" then call msg_proc(0, "^a", noaction_msg); 1046 end; 1047 1048 end append_volume_set; 1049 1050 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1051 1052 bad_arg: proc (arg) returns (bit (1)); 1053 1054 /* used in key verification */ 1055 1056 dcl arg char (*); 1057 dcl keyx fixed bin; 1058 dcl keys (35) char (32) static options (constant) init ("a", "add", "l", "ls", "list", "p", "pr", "print", "al", 1059 "alloc", "allocate", "f", "free", "d", "dl", "delete", "c", "change", "r", "rsv", "reserve", "t", "test", 1060 "cm", "comment", "u", "use", "appvs", "append_volume_set", "reuse", "pv_expire", 1061 "pvexp", "remove_volume_set", "rmvs", "set"); 1062 1063 do keyx = 1 to hbound (keys, 1); 1064 if arg = keys (keyx) then return (False); 1065 end; 1066 return (True); 1067 1068 end bad_arg; 1069 1070 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1071 1072 change: proc; 1073 1074 /* obselete key that must still be supported. change changes the comment of a volume specified by volume name */ 1075 1076 if vlx = 0 then call abort_proc (0, "Volume ^a is not registered.", arg); 1077 if vpe (vlx).state = free_state then call abort_proc (0, "Volume ^a is free.", arg); 1078 vpe (vlx).comment = arg2; 1079 call move_to_head(vlx); 1080 return; 1081 end change; 1082 1083 1084 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1085 1086 check_first_then_convert: proc(); 1087 1088 dcl VERSION_MSG char(171) int init( 1089 "Most likely an older version of mvp is being used which doesn't recognize all mvp structure versions.^/Recommendation is to copy the pool before converting or answer 'no'.") static options(constant); 1090 1091 1092 if volume_pool.version = volume_pool_version_1 | volume_pool.version = volume_pool_version_2 then 1093 call convert_volume_pool(); 1094 else do; 1095 /* before assuming this is the original old volume_pool structure with no version associated with it, 1096* we will ask the user, and then go merrily along converting it */ 1097 1098 /* but before we query the user, is this just a zero length seg? */ 1099 1100 if vp_bc = 0 then do; /* must be zero seg */ 1101 call convert_volume_pool(); 1102 return; 1103 end; 1104 1105 if subroutine then /* report problem, dont query */ 1106 call abort_proc(error_table_$action_not_performed, "Unrecognizable volume_pool version ^d.", volume_pool.version); 1107 1108 call command_query_$yes_no (yes_sw, 0, "mvp", VERSION_MSG, 1109 "The volume pool ^a ^/has an unrecognizable mvp structure version ^d.^/Do you want to TRY converting to the current version ^d?", 1110 path(vol_dir, vol_ename), volume_pool.version, volume_pool_version_3 ); 1111 1112 if yes_sw then call convert_volume_pool(); 1113 else call abort_proc(error_table_$unimplemented_version, "Unrecognizable volume_pool version ^d", volume_pool.version); 1114 end; 1115 1116 end check_first_then_convert; 1117 1118 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1119 1120 check_for_errors: proc(aptr, asize, vol_cnt, primary_idx, check); 1121 1122 /* checks for preliminary errors for various keys */ 1123 /* aptr: pointer to volume structure containing the volume names (input). 1124* asize: size of structure volume (input). 1125* vol_cnt: actual count of valid volume names in the structure (input). 1126* primary_idx: primary_idx of the set if its a secondary volume, else its just 0 (input). 1127* check: 16-bit code specifying which errors to check for. 1128**/ 1129 1130 dcl check bit(16); 1131 dcl error_found bit(16); 1132 dcl 1 volume aligned based (aptr), 1133 2 name(asize) char(32), 1134 2 indx(asize) fixed bin, 1135 2 switches, 1136 3 noaction(asize) bit(1) unal, 1137 3 want_it(asize) bit(1)unal; 1138 1139 dcl (asize, vol_cnt, 1140 primary_idx, i, volx) fixed bin; 1141 dcl aptr ptr; 1142 dcl just_expired bit(1); 1143 1144 error_found = "0000000000000000"b; 1145 just_expired = False; 1146 volume.want_it = True; 1147 volume.noaction = False; 1148 1149 do i = 1 to vol_cnt by 1; 1150 if ^(volume_in_pool ((volume(i).name), volx)) then do; 1151 if check & not_reg then do; 1152 volume(i).noaction = True; 1153 substr(error_found, fb_not_reg, 1) = True; 1154 vol_list.name(fb_not_reg) = vol_list.name(fb_not_reg) || " " || rtrim(volume(i).name); 1155 vol_list.cnt(fb_not_reg) = vol_list.cnt(fb_not_reg) + 1; 1156 end; 1157 end; 1158 else do; 1159 volume(i).indx = volx; 1160 1161 if (check & sec_not_found) then do; 1162 if ^(volume_in_volume_set((volume(i).name), primary_idx, volx)) then do; 1163 volume(i).noaction = True; 1164 substr(error_found, fb_sec_not_found, 1) = True; 1165 vol_list.name(fb_sec_not_found) = vol_list.name(fb_sec_not_found) || " " || rtrim(volume(i).name); 1166 vol_list.cnt(fb_sec_not_found) = vol_list.cnt(fb_sec_not_found) + 1; 1167 vol_list.name(fb_prim_name) = rtrim(vpe(primary_idx).name); 1168 goto END_CHECK; 1169 end; 1170 end; 1171 1172 if check & already_reg then do; 1173 volume(i).noaction = True; 1174 substr(error_found, fb_already_reg, 1) = True; 1175 vol_list.name(fb_already_reg) = vol_list.name(fb_already_reg) || " " || rtrim(volume(i).name); 1176 vol_list.cnt(fb_already_reg) = vol_list.cnt(fb_already_reg) + 1; 1177 goto END_CHECK; 1178 end; 1179 1180 if vpe(volx).secondary_vol then do; 1181 if (check & sec_vol) then volx = vpe(volx).primary_idx; 1182 else if (check & already_sec_vol)then do; 1183 volume(i).noaction = True; 1184 substr(error_found, fb_already_sec_vol, 1) = True; 1185 vol_list.name(fb_already_sec_vol) = vol_list.name(fb_already_sec_vol) || " " || rtrim(volume(i).name); 1186 vol_list.cnt(fb_already_sec_vol) = vol_list.cnt(fb_already_sec_vol) + 1; 1187 vol_list.name(fb_prim_name) = rtrim(vpe(vpe(volx).primary_idx).name); 1188 goto END_CHECK; 1189 end; 1190 end; 1191 1192 if (check & rsv_by_another) then if vpe (volx).state = reserved_state then do; 1193 if reserved_by_another_process(volx) then do; 1194 volume(i).noaction = True; 1195 substr(error_found, fb_rsv_by_another, 1) = True; 1196 vol_list.name(fb_rsv_by_another) = vol_list.name(fb_rsv_by_another) || " " || rtrim(volume(i).name); 1197 vol_list.cnt(fb_rsv_by_another) = vol_list.cnt(fb_rsv_by_another) + 1; 1198 goto END_CHECK; 1199 end; 1200 end; 1201 1202 if vpe (volx).state = allocated_state then do; 1203 if (check & already_alloc) then do; 1204 volume(i).noaction = True; 1205 substr(error_found, fb_already_alloc, 1) = True; 1206 vol_list.name(fb_already_alloc) = vol_list.name(fb_already_alloc) || " " || rtrim(volume(i).name); 1207 vol_list.cnt(fb_already_alloc) = vol_list.cnt(fb_already_alloc) + 1; 1208 goto END_CHECK; 1209 end; 1210 else if (check & cant_delete) then do; 1211 volume(i).noaction = True; 1212 substr(error_found, fb_cant_delete, 1) = True; 1213 vol_list.name(fb_cant_delete) = vol_list.name(fb_cant_delete) || " " || rtrim(volume(i).name); 1214 vol_list.cnt(fb_cant_delete) = vol_list.cnt(fb_cant_delete) + 1; 1215 goto END_CHECK; 1216 end; 1217 1218 else if (check & cant_pvexp) then do; 1219 volume(i).noaction = True; 1220 substr(error_found, fb_cant_pvexp, 1) = True; 1221 vol_list.name(fb_cant_pvexp) = vol_list.name(fb_cant_pvexp) || " " || rtrim(volume(i).name); 1222 vol_list.cnt(fb_cant_pvexp) = vol_list.cnt(fb_cant_pvexp)+ 1; 1223 goto END_CHECK; 1224 end; 1225 1226 if (check & not_exp) then if vpe(volx).expire then do; 1227 if vpe(volx).expire_date < clock() | fexp_sw then do; 1228 call check_for_pvexp(volx, brief_sw, just_expired); 1229 if just_expired then do; 1230 volume(i).noaction = True; 1231 goto END_CHECK; 1232 end; 1233 end; 1234 else do; /* allocated volume hasn't expired yet */ 1235 volume(i).noaction = True; 1236 if brief_sw then do; 1237 if active_fnc then do; 1238 substr(error_found, fb_not_exp, 1) = True; 1239 vol_list.name(fb_not_exp) = vol_list.name(fb_not_exp) || " " || rtrim(volume(i).name); 1240 vol_list.cnt(fb_not_exp) = vol_list.cnt(fb_not_exp)+ 1; 1241 goto END_CHECK; 1242 end; 1243 end; 1244 else do; 1245 substr(error_found, fb_not_exp, 1) = True; 1246 vol_list.name(fb_not_exp) = vol_list.name(fb_not_exp) || " " || rtrim(volume(i).name); 1247 vol_list.cnt(fb_not_exp) = vol_list.cnt(fb_not_exp)+ 1; 1248 goto END_CHECK; 1249 end; 1250 end; 1251 end; 1252 end; 1253 1254 if (check & vol_pvexp) then if vpe(volx).state = pvexp_state then do; 1255 volume(i).noaction = True; 1256 substr(error_found, fb_vol_pvexp, 1) = True; 1257 vol_list.name(fb_vol_pvexp) = vol_list.name(fb_vol_pvexp) || " " || rtrim(volume(i).name); 1258 vol_list.cnt(fb_vol_pvexp) = vol_list.cnt(fb_vol_pvexp) + 1; 1259 goto END_CHECK; 1260 end; 1261 1262 if (check & not_free) then if vpe(volx).state ^= free_state then do; 1263 volume(i).noaction = True; 1264 substr(error_found, fb_not_free, 1) = True; 1265 vol_list.name(fb_not_free) = vol_list.name(fb_not_free) || " " || rtrim(volume(i).name); 1266 vol_list.cnt(fb_not_free) = vol_list.cnt(fb_not_free) + 1; 1267 goto END_CHECK; 1268 end; 1269 1270 if (check & not_alloc) then if vpe(volx).state ^= allocated_state then do; 1271 volume(i).noaction = True; 1272 substr(error_found, fb_not_alloc, 1) = True; 1273 vol_list.name(fb_not_alloc) = vol_list.name(fb_not_alloc) || " " || rtrim(volume(i).name); 1274 vol_list.cnt(fb_not_alloc) = vol_list.cnt(fb_not_alloc) + 1; 1275 goto END_CHECK; 1276 end; 1277 1278 if (check & already_free) then if vpe(volx).state = free_state then do; 1279 volume(i).noaction = True; 1280 substr(error_found, fb_already_free, 1) = True; 1281 vol_list.name(fb_already_free) = vol_list.name(fb_already_free) || " " || rtrim(volume(i).name); 1282 vol_list.cnt(fb_already_free) = vol_list.cnt(fb_already_free) + 1; 1283 goto END_CHECK; 1284 end; 1285 1286 if (check & not_updated) then if (expire_sw & vpe(volx).state ^= allocated_state) then do; 1287 volume(i).noaction = True; 1288 substr(error_found, fb_not_updated, 1) = True; 1289 vol_list.name(fb_not_updated) = vol_list.name(fb_not_updated) || " " || rtrim(volume(i).name); 1290 vol_list.cnt(fb_not_updated) = vol_list.cnt(fb_not_updated) + 1; 1291 goto END_CHECK; 1292 end; 1293 1294 if (check & check_pvexp) then do; 1295 call check_for_pvexp(volx, False, just_expired); 1296 if just_expired then do; 1297 volume(i).noaction = True; 1298 substr(error_found, fb_check_pvexp, 1) = True; 1299 end; 1300 end; 1301 end; 1302 END_CHECK: 1303 end; /* end of do loop */ 1304 1305 call construct_msg(error_found); 1306 1307 end check_for_errors; 1308 1309 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1310 1311 check_for_pvexp: proc(vol_idx, no_print, just_expired); 1312 1313 /* checks to see if a volume is physically expired. 1314* vol_idx: index of volume to be checked. (input) 1315* no_print: designates whether to report the expiration or not. (input) 1316* just_expired: set to true if the volume 1317* is physically expired, ie. the pv_expire date is less than the current date/time. (output) 1318**/ 1319 1320 dcl vol_idx fixed bin; 1321 dcl (no_print, just_expired) bit(1); 1322 1323 just_expired = False; /* assume not expired */ 1324 1325 if vpe(vol_idx).pv_expire then do; 1326 if vpe(vol_idx).pv_expire_date < clock() | pvexp_secondary_vol_check(vol_idx) then do; 1327 if active_fnc then do; /* always want message flagged when AF whether no_print is specified or not */ 1328 vol_list.name(fb_check_pvexp) = vol_list.name(fb_check_pvexp) || " " || rtrim(vpe(vol_idx).name); 1329 vol_list.cnt(fb_check_pvexp) = vol_list.cnt(fb_check_pvexp) + 1; 1330 end; 1331 else if ^no_print then do; 1332 vol_list.name(fb_check_pvexp) = vol_list.name(fb_check_pvexp) || " " || rtrim(vpe(vol_idx).name); 1333 vol_list.cnt(fb_check_pvexp) = vol_list.cnt(fb_check_pvexp) + 1; 1334 end; 1335 call pvexp_volume(vol_idx); 1336 just_expired = True; 1337 end; 1338 end; 1339 1340 end check_for_pvexp; 1341 1342 1343 1344 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1345 1346 comment: proc; 1347 1348 /* obselete key that must still be supported. It prints the comment of a specified volume name. */ 1349 1350 if vlx = 0 then call abort_proc (0, "Volume ^a is not registered.", arg); 1351 if active_fnc then ret = vpe (vlx).comment; 1352 else call msg_proc (0, "Volume ^a", vpe (vlx).comment); 1353 end comment; 1354 1355 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1356 1357 construct_msg: proc(a_check); 1358 1359 /* called by check_for_errors. Constructs the actual error messages if errors were found. 1360* a_check: 16 bit code which maps to err_msg array and flags the errors found */ 1361 1362 dcl position fixed bin; 1363 dcl a_check bit(16); 1364 dcl check bit(16); 1365 dcl output_msg char(256) var; 1366 dcl output_len fixed bin; 1367 1368 check = a_check; 1369 position = index(check, "1"b); 1370 do while (position ^= 0); 1371 if position = fb_sec_not_found then 1372 call ioa_$rsnnl(err_msg(position), output_msg, output_len, (vol_list.cnt(position) > 1), 1373 vol_list.name(position), vol_list.name(fb_prim_name)); 1374 1375 else if position = fb_already_sec_vol then 1376 call ioa_$rsnnl(err_msg(position), output_msg, output_len, (vol_list.cnt(position) > 1), 1377 vol_list.name(position), vol_list.cnt(position) > 1, vol_list.cnt(position) > 1, 1378 vol_list.name(fb_prim_name)); 1379 1380 else if (position = fb_not_exp | position = fb_check_pvexp) & brief_sw then do; 1381 if active_fnc then /* print msg when its an active function regardless brief_sw specified */ 1382 call ioa_$rsnnl(err_msg(position), output_msg, output_len, vol_list.cnt(position) > 1, 1383 vol_list.name(position), vol_list.cnt(position) > 1); 1384 end; 1385 else call ioa_$rsnnl(err_msg(position), output_msg, output_len, vol_list.cnt(position) > 1, 1386 vol_list.name(position), vol_list.cnt(position) > 1); 1387 1388 noaction_msg = noaction_msg || output_msg; 1389 substr(check, position, 1) = False; 1390 position = index(check, "1"b); 1391 end; 1392 1393 end construct_msg; 1394 1395 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1396 1397 convert_volume_pool: proc; 1398 1399 /* This procedure converts a volume pool to the new format */ 1400 1401 dcl 1 volume_pool_old aligned based (vpp), 1402 2 lock bit (36), 1403 2 pad (7) bit (36), 1404 2 n_vol fixed bin (17), 1405 2 vpe_old (1:1 refer (volume_pool_old.n_vol)) aligned, 1406 3 name char (32), 1407 3 id bit (36), 1408 3 state fixed bin (8) unaligned, 1409 3 flags bit (27) unaligned, 1410 3 time char (16) unaligned, 1411 3 comment char (64); 1412 1413 dcl 1 volume_pool_old_1 aligned based (vpp), 1414 2 version fixed bin, 1415 2 lock bit (36), 1416 2 n_vol fixed bin (17), 1417 2 pad (5) bit (36), 1418 2 vpe_old_1 (1:1 refer (volume_pool_old_1.n_vol)) aligned, 1419 3 name char (32), 1420 3 id bit (36), 1421 3 state fixed bin, 1422 3 processid bit (36), 1423 3 time fixed bin (71), 1424 3 comment char (64), 1425 3 pad1 (8) bit (36); 1426 1427 dcl 1 volume_pool_header_2 aligned, 1428 2 version fixed bin, /* version 2 structure */ 1429 2 lock bit (36), 1430 2 n_vol fixed bin (17), /* number of volume slots in the pool, free and occupied */ 1431 2 volume_count fixed bin(17), /* number of volumes in the pool */ 1432 2 head fixed bin (17), /* index into first volume in pool */ 1433 2 tail fixed bin (17), /* index to last volume in pool */ 1434 2 free_head fixed bin (17), /* index to first empty slot in array */ 1435 2 pad (2) bit (36); 1436 1437 dcl 1 volume_pool_entry_2 aligned, /* volume pool entry. each volume has one assoc. with it */ 1438 2 name char (32), /* name of volume set */ 1439 2 id bit (36), /* used by volume dumper only */ 1440 2 state fixed bin, /* state of the volume */ 1441 2 processid bit (36), /* used when reserving volume */ 1442 2 state_date fixed bin (71), /* date the volume was last acted upon */ 1443 2 comment char (64), 1444 2 switches unaligned, 1445 3 secondary_vol bit(1), /* true if volume is a part of a multiple volume set */ 1446 3 pv_expire bit(1), /* true if a physical volume expiration date is assoc. with the volume */ 1447 3 expire bit(1), /* true if an expire date is associated with the volume */ 1448 3 already_printed bit(1), /* used in listing purposes */ 1449 3 pad1 bit(31), 1450 2 pv_expire_date fixed bin(71), /* physical volume expiration date */ 1451 2 expire_date fixed bin(71), /* allocated volume expiration date */ 1452 2 vs_count fixed bin, /* volume set count, includes primary and secondary volumes */ 1453 2 next fixed bin(17), /* index to next node or volume in the pool */ 1454 2 previous fixed bin(17), /* index to previous volume in pool */ 1455 2 primary_idx fixed bin(17), /* index of primary volume in a set */ 1456 2 secondary_idx fixed bin(17); /* index to next secondary volume in a set */ 1457 1458 dcl 1 volume_pool_2 aligned based(vpp), /* This is the CURRENT volume pool structure */ 1459 2 header like volume_pool_header_2, 1460 2 vpe_2 (divide(sys_info$max_seg_size - size(volume_pool_header_2), size(volume_pool_entry_2), 17) 1461 refer (volume_pool_2.header.n_vol)) like volume_pool_entry_2; 1462 1463 1464 if volume_pool.version = volume_pool_version_2 then 1465 /* convert version_2 to version_3 */ 1466 call set_lock_$lock (volume_pool_2.lock, lock_interval, code); 1467 1468 else if volume_pool.version = volume_pool_version_1 then 1469 /* convert version_1 to version_3 */ 1470 call set_lock_$lock (volume_pool_old_1.lock, lock_interval, code); 1471 1472 else /* convert old version to version 3 */ 1473 call set_lock_$lock (volume_pool_old.lock, lock_interval, code); 1474 1475 if code ^= 0 then do; 1476 if ^(code = error_table_$invalid_lock_reset | code = error_table_$locked_by_this_process) then 1477 call abort_proc (code, "Attempting to convert volume pool.^/Contact owner of pool ^a", path(vol_dir, vol_ename)); 1478 end; 1479 1480 if ^(subroutine | active_fnc) then call ioa_("Converting volume pool ^a from version ^d to version ^d.", vol_ename, volume_pool.version, volume_pool_version_3 ); 1481 call get_temp_segment_ (myname, new_vpp, code); 1482 if code ^= 0 then call abort_proc (code, "Unable to get temp seg - volume pool conversion of ^a failed", 1483 path (vol_dir, vol_ename)); 1484 1485 new_vpp -> volume_pool.version = volume_pool_version_3; 1486 new_vpp -> volume_pool.header.pad = "0"b; 1487 1488 if volume_pool.version = volume_pool_version_2 then do; 1489 /* convert header stuff first */ 1490 new_vpp -> volume_pool.head = vpp -> volume_pool_2.head; 1491 new_vpp -> volume_pool.volume_count = vpp -> volume_pool_2.volume_count; 1492 new_vpp -> volume_pool.tail = vpp -> volume_pool_2.tail; 1493 new_vpp -> volume_pool.free_head = vpp -> volume_pool_2.free_head; 1494 new_vpp -> volume_pool.n_vol = vpp -> volume_pool_2.n_vol; 1495 /* now copy each entry */ 1496 do vlx = 1 to new_vpp -> volume_pool_2.n_vol; 1497 new_vpp -> vpe (vlx).name = vpp -> vpe_2(vlx).name; 1498 new_vpp -> vpe (vlx).id = vpp -> vpe_2(vlx).id; 1499 new_vpp -> vpe (vlx).state = vpp -> vpe_2(vlx).state; 1500 new_vpp -> vpe (vlx).state_date = vpp -> vpe_2(vlx).state_date; 1501 new_vpp -> vpe (vlx).comment = vpp -> vpe_2(vlx).comment; 1502 new_vpp -> vpe (vlx).vs_count = vpp -> vpe_2(vlx).vs_count; 1503 new_vpp -> vpe (vlx).pv_expire = vpp -> vpe_2(vlx).pv_expire; 1504 new_vpp -> vpe (vlx).expire = vpp -> vpe_2(vlx).expire; 1505 new_vpp -> vpe (vlx).pv_expire_date = vpp -> vpe_2(vlx).pv_expire_date; 1506 new_vpp -> vpe (vlx).expire_date = vpp -> vpe_2(vlx).expire_date; 1507 new_vpp -> vpe (vlx).secondary_idx = vpp -> vpe_2(vlx).secondary_idx; 1508 new_vpp -> vpe (vlx).primary_idx = vpp -> vpe_2(vlx).primary_idx; 1509 new_vpp -> vpe (vlx).next = vpp -> vpe_2(vlx).next; 1510 new_vpp -> vpe (vlx).previous = vpp -> vpe_2(vlx).previous; 1511 1512 new_vpp -> vpe (vlx).secondary_vol = vpp -> vpe_2(vlx).secondary_vol; 1513 new_vpp -> vpe (vlx).pv_expire = vpp -> vpe_2(vlx).pv_expire; 1514 new_vpp -> vpe (vlx).expire = vpp -> vpe_2(vlx).expire; 1515 new_vpp -> vpe (vlx).already_printed = vpp -> vpe_2(vlx).already_printed; 1516 new_vpp -> vpe (vlx).pad2 = "0"b; 1517 end; 1518 goto CONVERT_FINISH; 1519 end; 1520 1521 if volume_pool.version = volume_pool_version_1 then do; 1522 /* convert version_1 to version_3 */ 1523 1524 new_vpp -> volume_pool.head = 1; 1525 new_vpp -> volume_pool.volume_count = volume_pool_old_1.n_vol; 1526 new_vpp -> volume_pool.tail = volume_pool_old_1.n_vol; 1527 new_vpp -> volume_pool.free_head, 1528 new_vpp -> volume_pool.n_vol = volume_pool_old_1.n_vol + 1; 1529 do vlx = 1 to new_vpp -> volume_pool.volume_count; 1530 new_vpp -> vpe (vlx).name = vpe_old_1 (vlx).name; 1531 new_vpp -> vpe (vlx).id = vpe_old_1 (vlx).id; 1532 new_vpp -> vpe (vlx).state = vpe_old_1 (vlx).state; 1533 new_vpp -> vpe (vlx).state_date = vpe_old_1 (vlx).time; 1534 new_vpp -> vpe (vlx).comment = vpe_old_1 (vlx).comment; 1535 new_vpp -> vpe (vlx).switches = False; 1536 new_vpp -> vpe (vlx).vs_count = 1; 1537 new_vpp -> vpe (vlx).pv_expire, new_vpp -> vpe (vlx).expire = False; 1538 new_vpp -> vpe (vlx).pv_expire_date, new_vpp -> vpe (vlx).expire_date = 0; 1539 new_vpp -> vpe (vlx).secondary_idx = no_link; 1540 new_vpp -> vpe (vlx).primary_idx = no_link; 1541 new_vpp -> vpe (vlx).next = vlx + 1; 1542 new_vpp -> vpe (vlx).previous = vlx - 1; 1543 new_vpp -> vpe (vlx).pad2 = "0"b; 1544 end; 1545 end; 1546 1547 else do; /* converting from old version to version 3 */ 1548 new_vpp -> volume_pool.head = 1; 1549 new_vpp -> volume_pool.volume_count = volume_pool_old.n_vol; 1550 new_vpp -> volume_pool.tail = volume_pool_old.n_vol; 1551 new_vpp -> volume_pool.free_head, 1552 new_vpp -> volume_pool.n_vol = volume_pool_old.n_vol + 1; 1553 if volume_pool_old.n_vol = 0 then do; 1554 /* the volume pool is either empty or initially created via the create command, not by mvp use */ 1555 new_vpp -> volume_pool.n_vol = 1; 1556 new_vpp -> volume_pool.volume_count = 0; 1557 new_vpp -> volume_pool.tail = 1; 1558 new_vpp -> volume_pool.free_head = 1; 1559 new_vpp -> volume_pool.head = no_link; 1560 new_vpp -> vpe(new_vpp ->volume_pool.n_vol).next = no_link; 1561 new_vpp -> vpe(new_vpp ->volume_pool.n_vol).previous = no_link; 1562 goto CONVERT_FINISH; 1563 end; 1564 do vlx = 1 to new_vpp -> volume_pool.volume_count; 1565 new_vpp -> vpe (vlx).name = vpe_old (vlx).name; 1566 new_vpp -> vpe (vlx).id = vpe_old (vlx).id; 1567 new_vpp -> vpe (vlx).state = vpe_old (vlx).state; 1568 call convert_date_to_binary_ (vpe_old (vlx).time, new_vpp -> vpe (vlx).state_date, code); 1569 if code ^= 0 then do; 1570 new_vpp -> vpe (vlx).state_date = clock_(); 1571 if ^(subroutine | active_fnc) then 1572 call msg_proc (code, "Unable to convert state date of volume ^a. It will be set to the current date.", 1573 new_vpp -> vpe(vlx).name); 1574 end; 1575 new_vpp -> vpe (vlx).comment = vpe_old (vlx).comment; 1576 new_vpp -> vpe (vlx).switches = False; 1577 new_vpp -> vpe (vlx).vs_count = 1; 1578 new_vpp -> vpe (vlx).pv_expire, new_vpp -> vpe (vlx).expire = False; 1579 new_vpp -> vpe (vlx).pv_expire_date, new_vpp -> vpe (vlx).expire_date = 0; 1580 new_vpp -> vpe (vlx).secondary_idx = no_link; 1581 new_vpp -> vpe (vlx).primary_idx = no_link; 1582 new_vpp -> vpe (vlx).next = vlx + 1; /* need to link all the volumes together */ 1583 new_vpp -> vpe (vlx).previous = vlx - 1; 1584 new_vpp -> vpe (vlx).pad2 = "0"b; 1585 end; 1586 end; 1587 1588 /* initialize the free (ie. next available) node in the volume_pool */ 1589 new_vpp -> vpe(new_vpp->volume_pool.n_vol).next = no_link; /* designates end of volume list */ 1590 new_vpp -> vpe(new_vpp->volume_pool.n_vol).previous = no_link; 1591 new_vpp -> vpe(new_vpp->volume_pool.n_vol).secondary_idx = no_link; 1592 new_vpp -> vpe(1).previous = no_link; /* start of volume list, no previous volume */ 1593 /* end of volume list, no next volume */ 1594 new_vpp -> vpe(new_vpp->volume_pool.volume_count).next = no_link; 1595 1596 CONVERT_FINISH: 1597 call hcs_$fs_move_seg (new_vpp, vpp, 1, code); 1598 if code ^= 0 then call abort_proc (code, "Unable to move temp file.- volume pool conversion of ^a failed", 1599 path (vol_dir, vol_ename)); 1600 call release_temp_segment_ (myname, new_vpp, (0)); 1601 return; 1602 1603 end convert_volume_pool; 1604 1605 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1606 1607 1608 create_pool: proc(); 1609 1610 call hcs_$make_seg (vol_dir, vol_ename, "", RW_ACCESS_BIN, vpp, code); 1611 if code = 0 then do; 1612 if subroutine then call ioa_ ("^a: Volume pool ^a created.", myname, path (vol_dir, vol_ename)); 1613 else call msg_proc (0, "Volume pool ^a created", path (vol_dir, vol_ename)); 1614 vpp -> volume_pool.version = volume_pool_version_3; 1615 vpp -> volume_pool.n_vol, vpp -> volume_pool.free_head = 1; 1616 vpp -> vpe(vpp ->volume_pool.n_vol).next = no_link; 1617 vpp -> vpe(vpp ->volume_pool.n_vol).previous = no_link; 1618 vpp -> volume_pool.head = no_link; 1619 vpp -> volume_pool.tail = 1; 1620 vpp -> volume_pool.volume_count = 0; 1621 end; 1622 else do; 1623 if vpp = null then call abort_proc (code, "Unable to create ^a", path (vol_dir, vol_ename)); 1624 end; 1625 1626 end create_pool; 1627 1628 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1629 1630 delete: proc; 1631 1632 /* used only for subroutine delete only */ 1633 1634 if vlx = 0 then call abort_proc (0, "Volume ^a is not registered.", arg); 1635 if vpe (vlx).state = allocated_state then 1636 call abort_proc (0, "Volume ^a is in use and can not be deleted.", arg); 1637 call free_node(vlx); 1638 return; 1639 end delete; 1640 1641 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1642 1643 delete_key: proc(); 1644 1645 /* Used by mvp command, it deletes the designated volumes from the pool. */ 1646 1647 dcl (volx, i, vol_cnt) fixed bin; 1648 1649 /* The structure below describes the control arguments allowed for a given key. 1650* A control arg is valid when the bit is "1"b. */ 1651 1652 dcl 1 args_allowed unaligned static int options(constant), 1653 (2 first init ("0"b), 1654 2 last init ("0"b), 1655 2 force init ("1"b), 1656 2 vs init ("0"b), 1657 2 com init ("0"b), 1658 2 expire init ("0"b), 1659 2 brief init ("0"b), 1660 2 fexp init ("0"b), 1661 2 match init ("0"b), 1662 2 all init ("0"b), 1663 2 pvexp init ("0"b), 1664 2 alloc init ("0"b), 1665 2 reserve init ("0"b), 1666 2 free init ("0"b), 1667 2 svol init ("0"b), 1668 2 asterisk init ("0"b), 1669 2 exp_dt init ("0"b), 1670 2 pvexp_dt init ("0"b), 1671 2 state_dt init ("0"b)) bit(1); 1672 1673 if narg < 2 then call abort_proc (error_table_$noarg, "^/Usage: delete volume_names {-control_arg}"); 1674 1675 call process_ctl_args(addr(args_allowed), 2, vol_cnt); 1676 if vol_cnt = 0 & ^asterisk_sw then call abort_proc (0, "No volumes specified."); 1677 1678 if asterisk_sw then do; 1679 call msg_proc(-1, "The asterisk '*' is obsolete."); 1680 specified_states(free_state) = True; 1681 specified_states(pvexp_state) = True; 1682 specified_states(reserved_state) = True; 1683 tcnt = asterisk_cnt; 1684 allocate tvol in (based_area) set (Ptvol); 1685 tvol.want_it = False; 1686 call get_volumes_specified ("deleted", specified_states, Ptvol, tcnt, vs_size, most_recent); 1687 end; 1688 1689 if volume_sw then 1690 call check_for_errors(Pvolume, volume_cnt, vol_cnt, 0, not_reg | cant_delete | sec_vol | check_pvexp); 1691 1692 if asterisk_sw then do; 1693 if ^(volume_sw) then do; 1694 vol_cnt = 0; 1695 volume_cnt = tcnt; 1696 allocate volume in (based_area) set (Pvolume); 1697 end; 1698 do i = 1 to tcnt; 1699 volume(vol_cnt + 1).name = tvol(i).name; 1700 volume(vol_cnt + 1).indx = tvol(i).indx; 1701 volume(vol_cnt + 1).want_it = tvol(i).want_it; 1702 vol_cnt = vol_cnt + 1; 1703 end; 1704 end; 1705 1706 call evaluate_volumes_wanted("deleted", Pvolume, volume_cnt, vol_cnt, none_sw, abort_sw); 1707 if none_sw | abort_sw then do; 1708 if active_fnc then do; 1709 ret = "false"; 1710 return; 1711 end; 1712 if none_sw then call abort_proc(error_table_$action_not_performed, 1713 "Volume set^[s^] specified ^[are^;is^] not registered in the pool.", (vol_cnt > 1), (vol_cnt > 1)); 1714 else if abort_sw then call abort_proc(error_table_$action_not_performed, "^a", noaction_msg); 1715 end; 1716 1717 1718 /* delete volumes specified */ 1719 1720 do i = 1 to vol_cnt; 1721 if volume(i).want_it then do; 1722 if ^(volume(i).noaction) then do; 1723 volx = volume(i).indx; 1724 if vpe(volx).secondary_vol then volx = vpe(volx).primary_idx; 1725 call free_node(volx); 1726 end; 1727 end; 1728 end; 1729 1730 if active_fnc then ret = "true"; 1731 else if noaction_msg ^= "" then call msg_proc(0, "^a", noaction_msg); 1732 1733 end delete_key; 1734 1735 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1736 1737 determine_alloc_version: proc(); 1738 1739 /* as the old allocate format is supported but undocumented, this procedure determines whether we are dealing with 1740* the new or old format. This is determined by the following guidelines: 1741* 1742* (a) If first argument is an asterisk "*", assume old version. 1743* (b) Check for an odd or even number of arguments. If an odd 1744* number, then assume new version. 1745* (c) If control arguments -comment, -com, -volume_set, -vs, -first, 1746* -ft, -last, -lt are specified, assume new version. 1747* (d) If any even argument (the key "alloc" is not considered an arg) 1748* is a volume existing in the pool, assume new version. 1749* (e) If any argument is an asterisk (*), assume old version. 1750**/ 1751 1752 dcl even_arg bit(1); 1753 1754 if narg < 2 then call abort_proc (error_table_$noarg, "Usage: mvp alloc {volume_names} {-control_args}"); 1755 1756 /* first check for an asterisk '*' arg. If found then assume old version. */ 1757 1758 call get_arg (2, ap, al, (0), alp); 1759 if arg = "*" then goto old_version; 1760 1761 /* Do we have an odd number of args? Use narg - 1 as the key "alloc" isn't included as an argument */ 1762 1763 if mod(narg-1, 2) = 1 then goto new_version; 1764 1765 /* check further for which version */ 1766 even_arg = False; 1767 do ac=2 to narg; 1768 call get_arg (ac, ap, al, (0), alp); 1769 if arg = "-com" | arg = "-comment" 1770 | arg = "-vs" | arg = "-volume_size" 1771 | arg = "-ft" | arg = "-first" 1772 | arg = "-lt" | arg = "-last" then goto new_version; 1773 else if even_arg then do; 1774 if volume_in_pool(arg, 0) then goto new_version; 1775 end; 1776 else if arg = "*" then goto old_version; 1777 even_arg = ^(even_arg); 1778 end; 1779 1780 1781 /* if we get here it means we fell out of loop by default and it's most likely the old version */ 1782 /* ie. essentially the even args specified were not volumes known to the pool so we assume it's a comment */ 1783 1784 old_version: 1785 call process (paired_args, allocate); 1786 return; 1787 1788 new_version: 1789 call allocate_key(); 1790 return; 1791 1792 end determine_alloc_version; 1793 1794 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1795 1796 evaluate_volumes_wanted: proc(action, aptr, asize, vol_cnt, none_sw, abort_sw); 1797 1798 /* called by various keys to determine, out of the volumes specified, which ones are to be acted upon and whether 1799* to query the user or not . 1800* action: action requested in query message. (input) 1801* aptr: pointer to volume structure (input) 1802* asize: size of the volume array (input) 1803* vol_cnt: number of volumes to be considered. (input) 1804* none_sw: true when no volumes are found. (output) 1805* abort_sw: true when all volumes specified cannot be acted upon or when the response to the query is no . (output) 1806**/ 1807 1808 dcl action char(*); 1809 dcl (abort_sw, none_sw) bit(1); 1810 dcl aptr ptr, 1811 (asize, 1812 i, 1813 vol_cnt, 1814 want_cnt, 1815 noaction_cnt) fixed bin; 1816 1817 dcl 1 volume aligned based (aptr), 1818 2 name(asize) char(32), 1819 2 indx(asize) fixed bin, 1820 2 switches, 1821 3 noaction(asize) bit(1) unal, 1822 3 want_it(asize) bit(1)unal; 1823 dcl continue bit(1); 1824 1825 none_sw, abort_sw = False; 1826 if index(want_str, "1"b) = 0 then do; 1827 none_sw = True; 1828 return; 1829 end; 1830 1831 if (index (want_str & noaction_str, "1"b) > 0) then do; 1832 1833 /* only query when some of the volumes wanted, some have noaction bit True, and others have noaction bit false */ 1834 1835 continue = False; 1836 if asize > 1 then do; 1837 want_cnt = 0; 1838 noaction_cnt = 0; 1839 do i = 1 to vol_cnt; 1840 if volume(i).want_it then do; 1841 want_cnt = want_cnt + 1; 1842 if volume(i).noaction then noaction_cnt = noaction_cnt + 1; 1843 end; 1844 end; 1845 1846 if (want_cnt = noaction_cnt) then do; 1847 abort_sw = True; 1848 return; 1849 end; 1850 else call query_to_continue(action, "", force_sw, continue); 1851 end; 1852 1853 if ^(continue) then abort_sw = True; 1854 end; 1855 1856 end evaluate_volumes_wanted; 1857 1858 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1859 1860 finish: proc(); 1861 1862 if lock then do; 1863 if vpp ^= null() then do; 1864 word_count = currentsize(volume_pool); 1865 bit_count = word_count*36; 1866 call hcs_$set_bc(vol_dir, vol_ename, bit_count, code); 1867 if code ^= 0 then call abort_proc (code, "Unable to set bit count of volume pool ^a", path (vol_dir, vol_ename)); 1868 call hcs_$truncate_file (vol_dir, vol_ename, word_count, code); 1869 if code ^= 0 then call abort_proc (code, "Unable to trucncate volume pool ^a", path (vol_dir, vol_ename)); 1870 end; 1871 1872 call set_lock_$unlock (volume_pool.lock, ignore); 1873 end; 1874 1875 if vpp ^= null & ^subroutine then call hcs_$terminate_noname (vpp, ignore); 1876 if Pvolume ^= null() then free volume in (based_area); 1877 if Ptvol ^= null() then free tvol in (based_area); 1878 1879 end finish; 1880 1881 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 1882 1883 format_print_output: proc(vol_idx, secondary_volume); 1884 1885 /* formats all the many flavors of outputing the volume pool info via the list key. 1886* vol_idx: index to the volume to be listed. (input) 1887* secondary_volume: true when the volume is a secondary volume of a set. (input) 1888**/ 1889 1890 dcl vol_idx fixed bin parameter; 1891 dcl (go_ahead, secondary_volume) bit(1); 1892 1893 go_ahead = True; 1894 if secondary_volume then do; 1895 if pvedt_sw & vpe(vol_idx).pv_expire then; 1896 else do; /* secondary volumes are listed only when -dfmt, -nm are */ 1897 output = ""; /* specified, and when the volume has a pvexp date associated */ 1898 go_ahead = False; /* with it and -pvedt was specified. */ 1899 end; 1900 end; 1901 1902 if dfmt_sw & ^(pvedt_sw | edt_sw) then do; 1903 if header_to_be_printed & ^active_fnc then do; 1904 call ioa_$rsnnl("^/Volume^1-^5xState Date^1-^5xState^3xComment", header_output, header_len); 1905 header_to_be_printed = False; 1906 end; 1907 if secondary_volume then call ioa_$rsnnl ("^1x^a", output, output_len, vpe(vol_idx).name); 1908 else call ioa_$rsnnl ("^a^[^/^]^[^1x^;^13t^]^20a^[^1x^;^36t^]^a^[^1x^;^44t^]^a", output, output_len, 1909 vpe (vol_idx).name, 1910 (index(vpe(vol_idx).name, " ") > 12) & ^active_fnc, 1911 active_fnc, time_string_ (vpe (vol_idx).state_date), 1912 active_fnc, ascii_state (vpe (vol_idx).state), 1913 active_fnc, vpe (vol_idx).comment); 1914 end; 1915 1916 else if dfmt_sw & ((pvedt_sw | edt_sw ) & ^(pvedt_sw & edt_sw )) then do; 1917 /* one or the other.....but not both */ 1918 if header_to_be_printed & ^active_fnc then do; 1919 call ioa_$rsnnl ("^/Volume^1-^5xState Date^1-^5xState^7x^[Expires Date^;PV Expires ^]^6xComment", 1920 header_output, header_len, edt_sw); 1921 header_to_be_printed = False; 1922 end; 1923 if secondary_volume then 1924 call ioa_$rsnnl ("^1x^a^[^[^1x^;^13t^31x^]^a^;^2s^]", output, output_len, vpe(vol_idx).name, go_ahead, 1925 active_fnc, time_string_(vpe(vol_idx).pv_expire_date)); 1926 else call ioa_$rsnnl 1927 ("^a^[^/^]^[^1x^;^13t^]^20a^[^1x^;^36t^]^a^[^1x^;^44t^]^[^20a^;^s^]^[^1x^s^;^[^20x^]^]^[^20a^;^s^]^[^1x^s^;^[^20x^]^]^[^1x^;^2x^]^a", 1928 output, output_len, 1929 vpe (vol_idx).name, 1930 (index(vpe(vol_idx).name, " ") > 12) & ^active_fnc, 1931 active_fnc, time_string_ (vpe (vol_idx).state_date), 1932 active_fnc, ascii_state (vpe (vol_idx).state), 1933 active_fnc, ^(pvedt_sw) & (edt_sw & vpe (vol_idx).expire), 1934 (time_string_ (vpe (vol_idx).expire_date)), 1935 active_fnc, ^(pvedt_sw) & (edt_sw & ^(vpe (vol_idx).expire)), 1936 ^(edt_sw) & (pvedt_sw & vpe (vol_idx).pv_expire), 1937 (time_string_ (vpe (vol_idx).pv_expire_date)), 1938 active_fnc, ^(edt_sw) & (pvedt_sw & ^(vpe (vol_idx).pv_expire)), 1939 active_fnc, vpe (vol_idx).comment); 1940 end; 1941 1942 else if dfmt_sw & pvedt_sw & edt_sw then do; 1943 if header_to_be_printed & ^active_fnc then do; 1944 call ioa_$rsnnl ("^/Volume^1-^5xState Date^1-^9xExpires Date^1-^1xPV Expires^/^13tState^34tComment", header_output, header_len); 1945 header_to_be_printed = False; 1946 end; 1947 if secondary_volume then 1948 call ioa_$rsnnl ("^1x^a^[^[^1x^;^59t^]^a^;^2s^]", output, output_len, vpe(vol_idx).name, go_ahead, 1949 active_fnc, time_string_(vpe(vol_idx).pv_expire_date)); 1950 else call ioa_$rsnnl 1951 ("^a^[^/^]^[^1x^;^13t^]^20a^[^1x^s^;^[^3x^]^]^[^20a^s^;^s^[^23x^]^]^[^1x^s^;^[^3x^]^]^[^20a^s^;^s^[^23x^]^]^[^1x^;^/^13t^]^a^[^1x^;^34t^]^a", 1952 output, output_len, 1953 vpe (vol_idx).name, 1954 (index(vpe(vol_idx).name, " ") > 12) & ^active_fnc, 1955 active_fnc, time_string_ (vpe (vol_idx).state_date), 1956 active_fnc, (vpe (vol_idx).expire), (vpe (vol_idx).expire), 1957 (time_string_ (vpe (vol_idx).expire_date)), 1958 ^active_fnc, active_fnc, 1959 (vpe (vol_idx).pv_expire), (vpe (vol_idx).pv_expire), 1960 (time_string_ (vpe (vol_idx).pv_expire_date)), 1961 ^active_fnc, active_fnc, 1962 ascii_state (vpe (vol_idx).state), 1963 active_fnc, vpe (vol_idx).comment); 1964 end; 1965 1966 else if ^(dfmt_sw) then do; /* only individual output fields specified */ 1967 if header_to_be_printed & ^active_fnc then do; 1968 call ioa_$rsnnl 1969 ("^/^[Volume^1-^5x^]^[State Date^1-^5x^]^[State^3x^]^[Expires Date^1-^6x^]^[PV Expires ^9x^]^[Comment^]", 1970 header_output, header_len, name_sw, sdt_sw, state_sw, edt_sw, pvedt_sw, comment_sw); 1971 header_to_be_printed = False; 1972 end; 1973 1974 if name_sw then do; 1975 call ioa_$rsnnl("^[^1x^]^a^[^/^]", output, output_len, secondary_volume, vpe(vol_idx).name, 1976 (index(vpe(vol_idx).name, " ") > 12) & (sdt_sw | comment_sw | pvedt_sw | edt_sw | state_sw) & (^active_fnc)); 1977 if sdt_sw & go_ahead then 1978 call ioa_$rsnnl("^a^[^1x^;^13t^]^20a^[^1x^;^3x^]", output, output_len, (output), active_fnc, 1979 time_string_ (vpe (vol_idx).state_date), active_fnc); 1980 if state_sw & go_ahead then 1981 call ioa_$rsnnl("^a^[^1x^s^;^[^36t^;^16t^]^]^a", output, output_len, (output), active_fnc, sdt_sw, 1982 ascii_state (vpe (vol_idx).state)); 1983 if edt_sw & go_ahead then call ioa_$rsnnl 1984 ("^a^[^1x^s^;^[^43t^]^]^[^1x^s^;^[^35t^]^]^[^1x^s^;^[^22t^;^13t^]^]^[^20a^[^1x^;^3x^]^;^s^[^1x^;^29x^]^]", 1985 output, output_len, (output), 1986 active_fnc, sdt_sw & state_sw, 1987 active_fnc, sdt_sw & ^state_sw, 1988 active_fnc, state_sw & ^sdt_sw, 1989 vpe (vol_idx).expire, 1990 time_string_ (vpe (vol_idx).expire_date), 1991 active_fnc); 1992 if pvedt_sw & go_ahead then call ioa_$rsnnl 1993 ("^a^[^1x^s^;^[^22t^]^]^[^1x^s^;^[^43t^]^]^[^1x^s^;^[^58t^]^]^[^1x^s^;^[^36t^;^13t^]^]^[^20a^[^1x^;^3x^]^;^s^[^1x^;^29x^]^]", 1994 output, output_len, (output), 1995 active_fnc, state_sw & ^(sdt_sw & edt_sw), 1996 active_fnc, state_sw & sdt_sw & ^edt_sw, 1997 active_fnc, sdt_sw & edt_sw & ^state_sw, 1998 active_fnc, (sdt_sw | edt_sw) & ^state_sw, 1999 vpe (vol_idx).pv_expire, 2000 time_string_ (vpe (vol_idx).pv_expire_date), 2001 active_fnc); 2002 2003 if comment_sw & go_ahead then 2004 call ioa_$rsnnl 2005 ("^a^[^1x^3s^;^[^66t^2s^;^[^58t^1s^;^[^37t^]^]^]^]^[^1x^2s^;^[^43t^1s^;^[^67t^]^]^]^[^1x^3s^;^[^24t^2s^;^[^45t^s^;^[^67t^;^16t^]^]^]^]^a", 2006 output, output_len, (output), 2007 active_fnc, ^state_sw & (sdt_sw & pvedt_sw & edt_sw), 2008 ^state_sw & ((sdt_sw & edt_sw) | (sdt_sw & pvedt_sw) | (pvedt_sw & edt_sw)), 2009 ^state_sw & (sdt_sw | pvedt_sw | edt_sw), 2010 active_fnc, 2011 sdt_sw & state_sw & ^(pvedt_sw | edt_sw), 2012 sdt_sw & state_sw & (pvedt_sw | edt_sw), 2013 active_fnc, state_sw & ^(sdt_sw | pvedt_sw | edt_sw), 2014 ^sdt_sw & state_sw & (pvedt_sw | edt_sw), 2015 ^sdt_sw & state_sw & (pvedt_sw & edt_sw), 2016 vpe(vol_idx).comment); 2017 end; /* end if name_sw */ 2018 2019 else if sdt_sw then do; 2020 if go_ahead then call ioa_$rsnnl("^20a", output, output_len, time_string_ (vpe (vol_idx).state_date)); 2021 if state_sw & go_ahead then call ioa_$rsnnl("^a^[^1x^;^26t^]^a", output, output_len, (output), 2022 active_fnc, ascii_state (vpe (vol_idx).state)); 2023 if edt_sw & go_ahead then call ioa_$rsnnl 2024 ("^a^[^1x^s^;^[^32t^;^24t^]^]^[^20a^[^1x^;^3x^]^;^s^[^1x^;^29x^]^]", output, output_len, (output), 2025 active_fnc, state_sw, 2026 vpe (vol_idx).expire, 2027 time_string_ (vpe (vol_idx).expire_date), 2028 active_fnc); 2029 if pvedt_sw & go_ahead then call ioa_$rsnnl 2030 ("^a^[^1x^s^;^[^32t^]^]^[^1x^s^;^[^55t^]^]^[^1x^s^;^[^46t^]^]^[^1x^s^;^[^24t^]^]^[^20a^[^1x^;^3x^]^;^s^[^1x^;^29x^]^]", 2031 output, output_len, (output), 2032 active_fnc, state_sw & ^edt_sw, 2033 active_fnc, state_sw & edt_sw, 2034 active_fnc, ^state_sw & edt_sw, 2035 active_fnc, ^state_sw & ^edt_sw, 2036 vpe (vol_idx).pv_expire, 2037 time_string_ (vpe (vol_idx).pv_expire_date), active_fnc); 2038 if comment_sw & go_ahead then do; 2039 if active_fnc then call ioa_$rsnnl("^a^1x^a", output, output_len, (output), vpe(vol_idx).comment); 2040 else call ioa_$rsnnl("^a^[^34t^]^[^70t^]^[^70t^]^[^59t^]^[^57t^]^[^47t^]^[^26t^]^a", 2041 output, output_len, (output), 2042 state_sw & ^(pvedt_sw | edt_sw), 2043 state_sw & pvedt_sw & edt_sw, 2044 ^state_sw & (pvedt_sw & edt_sw), 2045 state_sw & edt_sw, 2046 state_sw & pvedt_sw, 2047 ^state_sw & (pvedt_sw | edt_sw), 2048 ^state_sw & ^pvedt_sw & ^edt_sw, 2049 vpe(vol_idx).comment); 2050 end; 2051 2052 end; /* end if sdt_sw */ 2053 2054 else if state_sw then do; 2055 if go_ahead then call ioa_$rsnnl("^[^1x^]^5a^[^1x^;^3x^]", output, output_len, active_fnc, 2056 ascii_state (vpe (vol_idx).state), active_fnc); 2057 if edt_sw & go_ahead then call ioa_$rsnnl("^a^[^1x^;^9t^]^[^20a^[^1x^;^3x^]^;^s^[^1x^;^23x^]^]", 2058 output, output_len, (output), 2059 active_fnc, vpe (vol_idx).expire, 2060 time_string_ (vpe (vol_idx).expire_date), active_fnc); 2061 if pvedt_sw & go_ahead then 2062 call ioa_$rsnnl("^a^[^1x^s^;^[^36t^;^9t^]^]^[^20a^[^1x^;^3x^]^;^s^[^1x^;^23x^]^]", 2063 output, output_len, (output), 2064 active_fnc, edt_sw, 2065 vpe (vol_idx).pv_expire, 2066 time_string_ (vpe (vol_idx).pv_expire_date), 2067 active_fnc); 2068 if comment_sw & go_ahead then 2069 call ioa_$rsnnl("^a^[^1x^s^;^[^57t^]^]^[^1x^2s^;^[^37t^s^;^[^31t^;^9t^]^]^]^a", 2070 output, output_len, (output), 2071 active_fnc, edt_sw & pvedt_sw, 2072 active_fnc, edt_sw, pvedt_sw, 2073 vpe(vol_idx).comment); 2074 end; /* end if state_sw */ 2075 2076 else if edt_sw then do; 2077 if go_ahead then call ioa_$rsnnl("^[^20a^[^1x^;^3x^]^;^s^[^1x^;^23x^]^]", output, output_len, 2078 vpe (vol_idx).expire, 2079 time_string_ (vpe (vol_idx).expire_date), active_fnc); 2080 2081 if pvedt_sw & go_ahead then call ioa_$rsnnl("^a^[^1x^;^24t^]^[^20a^[^1x^;^3x^]^;^s^[^1x^;^23x^]^]", 2082 output, output_len, (output), 2083 active_fnc, vpe (vol_idx).pv_expire, 2084 time_string_ (vpe (vol_idx).pv_expire_date), active_fnc); 2085 if comment_sw & go_ahead then call ioa_$rsnnl("^a^[^1x^s^;^[^48t^;^27t^]^]^a", 2086 output, output_len, (output), 2087 active_fnc, pvedt_sw, 2088 vpe(vol_idx).comment); 2089 2090 end; /* of edt_sw */ 2091 2092 else if pvedt_sw & go_ahead then do; 2093 call ioa_$rsnnl("^[^20a^[^1x^;^3x^]^;^s^[^1x^;^23x^]^]", output, output_len, 2094 vpe (vol_idx).pv_expire, 2095 time_string_ (vpe (vol_idx).pv_expire_date), active_fnc); 2096 2097 if comment_sw & go_ahead then call ioa_$rsnnl("^a^[^1x^;^22t^]^a", output, output_len, (output), 2098 active_fnc, vpe(vol_idx).comment); 2099 2100 end; /* of if pvedt_sw */ 2101 2102 else if comment_sw & go_ahead then do; 2103 call ioa_$rsnnl("^a^[^1x^]", output, output_len, vpe (vol_idx).comment, active_fnc); 2104 end; 2105 end; 2106 2107 end format_print_output; 2108 2109 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2110 2111 free: proc(); 2112 2113 /* called by free subroutine only */ 2114 2115 if vlx = 0 then call abort_proc (0, "Volume ^a is not registered", arg); 2116 if vpe (vlx).state = free_state then call abort_proc (0, "Volume ^a is already free.", arg); 2117 vpe (vlx).state = free_state; 2118 vpe (vlx).expire = False; 2119 call move_to_head(vlx); 2120 return; 2121 end free; 2122 2123 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2124 2125 free_key: proc(); 2126 2127 /* Used by the mvp command, it frees volumes by changing the state to free */ 2128 2129 dcl (found, just_expired) bit(1); 2130 dcl (i, volx, vol_idx, vol_cnt) fixed bin; 2131 2132 /* The structure below describes the control arguments allowed for a given key. 2133* A control arg is valid when the bit is "1"b. */ 2134 2135 dcl 1 args_allowed unaligned static int options(constant), 2136 (2 first init ("0"b), 2137 2 last init ("0"b), 2138 2 force init ("1"b), 2139 2 vs init ("0"b), 2140 2 com init ("0"b), 2141 2 expire init ("1"b), 2142 2 brief init ("1"b), 2143 2 fexp init ("1"b), 2144 2 match init ("1"b), 2145 2 all init ("0"b), 2146 2 pvexp init ("0"b), 2147 2 alloc init ("0"b), 2148 2 reserve init ("0"b), 2149 2 free init ("0"b), 2150 2 svol init ("0"b), 2151 2 asterisk init ("0"b), 2152 2 exp_dt init ("0"b), 2153 2 pvexp_dt init ("0"b), 2154 2 state_dt init ("0"b)) bit(1); 2155 2156 if narg < 2 then call abort_proc (error_table_$noarg, "Usage: mvp free {volume_names} {-control_args}"); 2157 2158 /* process control arguments */ 2159 2160 call process_ctl_args(addr(args_allowed), 2, vol_cnt); 2161 2162 if volume_sw & (expire_sw | match_sw) then call abort_proc(error_table_$inconsistent, 2163 "volume names and ^[-expire^;^] ^[-match^;^]", expire_sw, match_sw); 2164 2165 /* -expire control arg case */ 2166 2167 if expire_sw then do; 2168 2169 volume_cnt = volume_pool.n_vol; 2170 allocate volume in (based_area) set (Pvolume); 2171 volume.want_it, volume.noaction = False; 2172 2173 do vol_idx = 1 to volume_pool.n_vol by 1; 2174 if vpe(vol_idx).state = allocated_state then do; /* check expires date */ 2175 if vpe(vol_idx).expire then do; 2176 if vpe(vol_idx).expire_date < clock() | fexp_sw then do; 2177 call check_for_pvexp(vol_idx, brief_sw, just_expired); 2178 if ^(just_expired) then do; 2179 vol_cnt = vol_cnt +1; 2180 volume(vol_cnt).name = vpe(vol_idx).name; 2181 volume(vol_cnt).indx = vol_idx; 2182 volume(vol_cnt).want_it =True; 2183 end; 2184 end; 2185 end; 2186 end; /* end if allocate state */ 2187 end; /* loop */ 2188 if vol_cnt = 0 then call abort_proc(error_table_$action_not_performed, 2189 "No allocated volume sets found with overdue expiration dates."); 2190 if just_expired then call construct_msg(check_pvexp); 2191 end; 2192 2193 if match_sw then do; 2194 if vol_cnt = 0 then do; /* -expire wasn't specified */ 2195 volume_cnt = volume_pool.n_vol; 2196 allocate volume in (based_area) set (Pvolume); 2197 volume(*).want_it = False; 2198 2199 do i = 1 to volume_pool.n_vol; 2200 if index (vpe(i).comment, match_string) > 0 then do; /* found a match */ 2201 call check_for_pvexp(i, brief_sw, just_expired); 2202 if ^(just_expired) then do; /* not expired? we want it */ 2203 vol_cnt = vol_cnt + 1; 2204 volume(vol_cnt).name = vpe(i).name; 2205 volume(vol_cnt).indx = i; 2206 volume(vol_cnt).want_it = True; 2207 end; 2208 end; 2209 end; /* do loop */ 2210 if vol_cnt = 0 then call abort_proc(error_table_$action_not_performed, 2211 "^/No volume sets found with comment string matching ^a.", match_string); 2212 if just_expired then call construct_msg(check_pvexp); 2213 end; 2214 else do; /* -expire was specified and -expire criteria has already been met successfully */ 2215 volume(*).want_it, found = False; 2216 do i = 1 to vol_cnt; 2217 if index (vpe(i).comment, match_string) > 0 then volume(i).want_it, found = True; 2218 end; 2219 if ^(found) then call abort_proc(error_table_$action_not_performed, 2220 "^/No expired volume sets found with comment string matching ^a.", match_string); 2221 end; 2222 end; /* if match_sw */ 2223 2224 /* here's the case where volume names were specified */ 2225 2226 else if volume_sw then call check_for_errors 2227 (Pvolume, volume_cnt, vol_cnt, 0, not_reg | sec_vol | rsv_by_another | already_free | not_exp | check_pvexp); 2228 2229 call evaluate_volumes_wanted("freed", Pvolume, narg, vol_cnt, none_sw, abort_sw); 2230 if none_sw then call abort_proc(error_table_$action_not_performed, 2231 "Volume set^[s^] specified ^[are^;is^] not registered in the pool.", (vol_cnt > 1), (vol_cnt > 1)); 2232 else if abort_sw then if noaction_msg ^= "" then call abort_proc(error_table_$action_not_performed, "^a", noaction_msg); 2233 2234 2235 /* now free the volumes */ 2236 2237 vol_msg_list = ""; 2238 do i = 1 to vol_cnt; 2239 if volume(i).want_it then do; 2240 if ^(volume(i).noaction) then do; 2241 volx = volume(i).indx; 2242 if vpe(volx).secondary_vol then volx = vpe(volx).primary_idx; 2243 if active_fnc then ret = ret || " " || rtrim(vpe(volx).name); 2244 vpe(volx).state = free_state; 2245 vpe(volx).expire = False; 2246 if vpe(volx).state = pvexp_state then vpe(volx).pv_expire = False; 2247 if ((expire_sw | match_sw | first_last_sw) & ^brief_sw) then 2248 vol_msg_list = vol_msg_list || " " || rtrim(vpe(volx).name); 2249 call move_to_head(volx); 2250 end; 2251 end; 2252 end; 2253 2254 if ^active_fnc then do; 2255 if vol_msg_list ^= "" then 2256 call msg_proc(0, "Volume set^[s^] ^a ^[has^;have^] been freed. ^[^a^;^s^]", 2257 (vol_cnt > 1), vol_msg_list, (vol_cnt = 1), (noaction_msg ^= ""), noaction_msg ); 2258 else if noaction_msg ^= "" then call msg_proc(0, "^a", noaction_msg ); 2259 end; 2260 2261 end free_key; 2262 2263 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2264 2265 free_node: proc(volx); 2266 2267 /* free_node unlinks the volume_pool array entry specified by volx from the volume list 2268* and relinks it into the free list of array nodes available for reuse. This effectively 2269* deletes a volume from the pool. 2270**/ 2271 2272 dcl volx fixed bin; 2273 2274 if volume_pool.head = volume_pool.tail then do; 2275 /* freeing the last volume set in the pool, so set conditions as for an empty pool */ 2276 volume_pool.n_vol = 1; 2277 volume_pool.volume_count = 0; 2278 volume_pool.tail = 1; 2279 volume_pool.free_head = 1; 2280 volume_pool.head = no_link; 2281 vpe(volume_pool.n_vol).next = no_link; 2282 vpe(volume_pool.n_vol).previous = no_link; 2283 goto END_FREE_NODE; 2284 end; 2285 2286 if volx = volume_pool.tail then do; 2287 volume_pool.tail = vpe(volx).previous; 2288 vpe(volume_pool.tail).next = vpe(volx).next; 2289 end; 2290 else if volx = volume_pool.head then do; 2291 volume_pool.head = vpe(volx).next; 2292 vpe(volume_pool.head).previous = vpe(volx).previous; 2293 end; 2294 else do; /* in middle of volume list chain, relink it to exclude volume specified by volx */ 2295 vpe(vpe(volx).previous).next = vpe(volx).next; 2296 vpe(vpe(volx).next).previous = vpe(volx).previous; 2297 end; 2298 2299 /* now chain the just freed node into the free node list */ 2300 2301 vpe(volx).next = volume_pool.free_head; 2302 vpe(volx).previous = no_link; /* backwards index references are not used in the free node linked list */ 2303 volume_pool.free_head = volx; 2304 volume_pool.volume_count = volume_pool.volume_count - 1; 2305 2306 END_FREE_NODE: 2307 return; 2308 end free_node; 2309 2310 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2311 2312 get_list_names: proc(aptr, asize, vs_size, most_recent); 2313 2314 /* Called by list_key procedure, get_list_names fills in the volume 2315* structure with the name and index 2316* of the desired volumes. 2317* aptr: Pointer to volume structure (input). 2318* asize: Size of structure (input). 2319* vs_size: Specifies what size of volume sets to look for (input). 2320* most_recent: true when the most recently updated volumes are wanted. 2321**/ 2322 2323 dcl 1 volume aligned based (aptr), 2324 2 name(asize) char(32), 2325 2 indx(asize) fixed bin, 2326 2 switches, 2327 3 noaction(asize) bit(1) unal, 2328 3 want_it(asize) bit(1)unal; 2329 2330 dcl (asize, vs_size, volx, vol_idx) fixed bin; 2331 dcl aptr ptr; 2332 dcl most_recent bit(1); 2333 2334 if most_recent then do; /* -first */ 2335 vol_idx = 0; 2336 volx = volume_pool.head; 2337 do while ((volx ^= no_link) & (vol_idx < asize)); 2338 if get_names_check_switches(volx, vs_size) then do; 2339 vol_idx = vol_idx + 1; 2340 volume(vol_idx).name = vpe(volx).name; 2341 volume(vol_idx).indx = volx; 2342 volume(vol_idx).want_it = True; 2343 end; 2344 volx = vpe(volx).next; 2345 end; 2346 end; 2347 else do; /* -last specified */ 2348 vol_idx = asize; 2349 volx = volume_pool.tail; 2350 do while ((volx ^= no_link) & (vol_idx > 0)); 2351 if get_names_check_switches(volx, vs_size) then do; 2352 volume(vol_idx).name = vpe(volx).name; 2353 volume(vol_idx).indx = volx; 2354 volume(vol_idx).want_it = True; 2355 vol_idx = vol_idx - 1; 2356 end; 2357 volx = vpe(volx).previous; 2358 end; 2359 end; 2360 2361 end get_list_names; 2362 2363 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2364 2365 get_names_check_switches: proc(volx, vs_size) returns(bit(1)); 2366 2367 /* Called by get_list_names, this procedure determines whether a volume meets the criteria specifed and 2368* returns true, else false. 2369* volx: Index of volume to look at. 2370* vs_size: Size of volume set to be considered. 2371**/ 2372 2373 dcl (volx, vidx, vs_size) fixed bin; 2374 2375 if listed_flag(volx) then return(False); /* did we already print this? */ 2376 vidx = volx; 2377 if vpe(vidx).secondary_vol then /* set vidx to primary volume as he has all the info. */ 2378 vidx = vpe(vidx).primary_idx; 2379 2380 if ^(specified_states(vpe (vidx).state)) then return(False); 2381 2382 if vs_size = -1 then; /* get volume_sets of any size */ 2383 else if (vpe(vidx).vs_count) ^= vs_size then return(False); 2384 2385 if expire_sw then do; 2386 /* want only those whose expire_date is < clock */ 2387 if ^(vpe(vidx).expire) then return(False); 2388 if vpe(vidx).expire_date > clock() then return(False); 2389 end; 2390 2391 if match_sw then do; 2392 compare = vpe (vidx).comment; 2393 if ((index (compare, match_string) = 0) | (index (compare, match_string) = 64)) then return(False); 2394 end; 2395 2396 return(True); 2397 2398 end get_names_check_switches; 2399 2400 2401 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2402 2403 get_next_arg: proc(Arg_expected, ap1, al1); 2404 2405 /* This guy gets the next argument from the argument string, complaining if it's not there */ 2406 2407 dcl Arg_expected char(*); 2408 dcl (ap1 ptr, 2409 al1 fixed bin(21)); 2410 2411 if (ac + 1) > narg then do; 2412 call abort_proc(error_table_$noarg, "A ^a expected after ^a.", Arg_expected, arg); 2413 return; 2414 end; 2415 ac = ac + 1; 2416 call get_arg (ac, ap1, al1, (0), alp); 2417 2418 end get_next_arg; 2419 2420 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2421 2422 get_node: proc() returns (fixed bin); 2423 2424 /* Called by add procedures, get_node looks for the next available, or empty node in the volume pool structure, 2425* and returns the index of this node to the caller. */ 2426 2427 dcl volx fixed bin; 2428 2429 volx = volume_pool.free_head; 2430 volume_pool.free_head = vpe(volume_pool.free_head).next; 2431 if volume_pool.free_head = no_link then do; 2432 volume_pool.free_head, volume_pool.n_vol = volume_pool.n_vol + 1; 2433 vpe(volume_pool.free_head).next = no_link; 2434 vpe(volume_pool.free_head).previous = no_link; 2435 vpe(volume_pool.free_head).secondary_idx = no_link; 2436 end; 2437 2438 return(volx); 2439 end get_node; 2440 2441 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2442 2443 get_number: proc() returns(fixed bin); 2444 2445 /* Called when processing arguments for various keys, get_number returns the number specified for 2446* control args -first, -last, -vs_size. */ 2447 2448 dcl arg_fb fixed bin; 2449 2450 if ac = narg then return(1); /* this is the default */ 2451 ac = ac + 1; 2452 call get_arg (ac, ap, al, (0), alp); 2453 if verify(arg, "0123456789") = 0 then do; 2454 arg_fb = convert(arg_fb, arg); 2455 if arg_fb = 0 then call abort_proc(error_table_$action_not_performed, " 0 volume set size specified."); 2456 return(arg_fb); 2457 end; 2458 else do; 2459 ac = ac - 1; /* reset arg pointer */ 2460 return(1); 2461 end; 2462 2463 end get_number; 2464 2465 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2466 2467 get_volumes_specified: proc(requestor, a_states, aptr, asize, vs_size, most_recent); 2468 2469 /* Called by the various key procedures, get_volumes_specified fills in the volume structure with volumes 2470* meeting specified criteria, querying the user and reporting errors when appropriate. 2471* requestor: The action required by the caller, used in querying (input). 2472* a_states: Defines the states possible for a volume to be considered (input). 2473**/ 2474 dcl requestor char(*); 2475 dcl a_states(4) bit(1) parameter; 2476 dcl 1 volume aligned based (aptr), 2477 2 name(asize) char(32), 2478 2 indx(asize) fixed bin, 2479 2 switches, 2480 3 noaction(asize) bit(1) unal, 2481 3 want_it(asize) bit(1)unal; 2482 2483 dcl (asize, vs_size, i, vol_idx) fixed bin; 2484 dcl aptr ptr; 2485 dcl (continue, 2486 most_recent, 2487 just_expired) bit(1); 2488 dcl msg char(256); 2489 dcl msg_len fixed bin; 2490 2491 vol_idx = 0; 2492 if most_recent then do; 2493 i = volume_pool.head; 2494 do while ((i ^= no_link) & (vol_idx < asize)); 2495 call get_volumes_specified_loop(); 2496 i = vpe(i).next; 2497 end; 2498 end; 2499 else do; /* get the volumes with the oldest state_date */ 2500 i = volume_pool.tail; 2501 do while ((i ^= no_link) & (vol_idx < asize)); 2502 call get_volumes_specified_loop(); 2503 i = vpe(i).previous; 2504 end; 2505 end; 2506 2507 if just_expired then call construct_msg(check_pvexp); 2508 2509 if vol_idx = 0 then call abort_proc(0, 2510 "No ^[free^s^;^[allocated^]^] volume sets ^[of size ^d^;specified^] exist in the pool.^[ Allocate reserved volumes by name.^]", 2511 a_states(free_state), a_states(allocated_state), vs_size > 0, vs_size, requestor = "allocated" ); 2512 2513 else if vol_idx < asize then do; 2514 /* query when some but not all volumes specified are found for -lt and -ft */ 2515 continue = False; 2516 call ioa_$rsnnl("Only ^d volume set^[s^] ^[of size ^d ^;^s^]can be ^a.", msg, msg_len, vol_idx, vol_idx > 1, 2517 vs_size > 0, vs_size, requestor); 2518 2519 call query_to_continue("", msg, force_sw, continue); 2520 if ^(continue) then call abort_proc(0, 2521 "The ^d volume sets specified ^[of size ^d ^]are not in the pool. ", asize, vs_size > 0, vs_size); 2522 end; 2523 2524 2525 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2526 2527 get_volumes_specified_loop: proc(); 2528 2529 if a_states(vpe(i).state) then do; 2530 if (vpe(i).vs_count = vs_size) | vs_size = -1 then do; 2531 if vpe(i).state = free_state then do; 2532 call check_for_pvexp(i, brief_sw, just_expired); 2533 if ^just_expired then do; 2534 vol_idx = vol_idx + 1; 2535 volume(vol_idx).indx = i; 2536 volume(vol_idx).name = vpe(i).name; 2537 volume(vol_idx).want_it = True; 2538 end; 2539 end; 2540 else do; 2541 vol_idx = vol_idx + 1; 2542 volume(vol_idx).name = vpe(i).name; 2543 volume(vol_idx).indx = i; 2544 volume(vol_idx).want_it = True; 2545 end; 2546 end; 2547 end; 2548 2549 end get_volumes_specified_loop; 2550 2551 end get_volumes_specified; 2552 2553 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2554 2555 insert_node: proc(volx); 2556 2557 /* Called by the add procedures, insert_node puts a new node into the linked volume list 2558* contained in volume_pool.vpe 2559* volx: index to the node to be linked (input). */ 2560 2561 dcl volx fixed bin; 2562 2563 vpe(volx).state_date = clock(); 2564 vpe(volx).next = volume_pool.head; 2565 if volume_pool.head ^= no_link then vpe(volume_pool.head).previous = volx; 2566 vpe(volx).previous = no_link; 2567 volume_pool.head = volx; 2568 volume_pool.volume_count = volume_pool.volume_count + 1; 2569 2570 end insert_node; 2571 2572 2573 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2574 2575 last_volume_in_set: proc(primary_idx) returns(fixed bin); 2576 2577 /* Determines the last volume in a volume set and returns the index of this last volume 2578* primary_idx: index of the primary volume of the set (input). 2579**/ 2580 dcl (primary_idx, vol_idx) fixed bin; 2581 2582 if vpe(primary_idx).vs_count = 1 then return(primary_idx); 2583 vol_idx = vpe(primary_idx).secondary_idx; 2584 do while (vpe(vol_idx).secondary_idx ^= no_link); 2585 vol_idx = vpe(vol_idx).secondary_idx; 2586 end; 2587 return (vol_idx); 2588 2589 end last_volume_in_set; 2590 2591 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2592 2593 list_key: proc(); 2594 2595 /* Lists volume sets in the pool. */ 2596 2597 dcl (volx, i) fixed bin; 2598 dcl total_char char(256) var; 2599 dcl (get_area, not_in_pool) bit(1); 2600 2601 if volume_pool.volume_count = 0 then call abort_proc (0, "Volume pool is empty."); 2602 vs_size = -1; 2603 most_recent = False; 2604 allocate listed_flag in (based_area) set (Plisted); 2605 listed_flag = False; 2606 2607 if narg = 1 then do; /* No control args. Print the default. */ 2608 i = volume_pool.head; 2609 do while (i ^= no_link); 2610 if active_fnc then do; 2611 ret = ret || " " || rtrim(vpe(i).name); 2612 end; 2613 else do; 2614 dfmt_sw = True; 2615 specified_states = "1"b; 2616 call print (i, vs_size); 2617 end; 2618 i = vpe(i).next; 2619 end; 2620 goto END_LIST; 2621 end; 2622 2623 /* first process list control args */ 2624 2625 vol_cnt = 0; 2626 get_area = True; 2627 do ac = 2 to narg; 2628 call get_arg (ac, ap, al, (0), alp); 2629 if arg = "-match" then do; 2630 ac = ac + 1; 2631 call get_arg (ac, ap, al, code, alp); 2632 if code ^= 0 then call abort_proc (code, "Unable to get arg after ^a", arg); 2633 match_sw = True; 2634 match_string = arg; 2635 end; 2636 else if arg = "-free" then do; 2637 specified_states(free_state), free_sw = True; 2638 all_states = False; 2639 end; 2640 else if arg = "-alloc" | arg = "-allocate" | arg = "-allocated" then do; 2641 specified_states(allocated_state), alloc_sw = True; 2642 all_states = False; 2643 end; 2644 else if arg = "-pvexp" | arg = "-pv_expire" then do; 2645 specified_states(pvexp_state), pvexp_sw = True; 2646 all_states = False; 2647 end; 2648 else if arg = "-rsv" | arg = "-reserve" | arg = "-reserved" then do; 2649 specified_states(reserved_state), reserve_sw = True; 2650 all_states = False; 2651 end; 2652 else if arg = "-exp" | arg = "-expire" then expire_sw = True; 2653 else if arg = "-ft" | arg = "-first" then do; 2654 first_last_sw, first_sw, most_recent = True; 2655 vol_cnt = get_number(); 2656 end; 2657 else if arg = "-lt" | arg = "-last" then do; 2658 first_last_sw, last_sw = True; 2659 most_recent = False; 2660 vol_cnt = get_number(); 2661 end; 2662 else if arg = "-vs" | arg = "-volume_size" then do; 2663 vs_sw = True; 2664 vs_size = get_number(); 2665 end; 2666 else if arg = "-nm" | arg = "-name" then name_sw = True; 2667 else if arg = "-edt" | arg = "expire_date" then edt_sw = True; 2668 else if arg = "-pvedt" | arg = "pv_expire_date" then pvedt_sw = True; 2669 else if arg = "-com" | arg = "-comment" then comment_sw = True; 2670 else if arg = "-sdt" | arg = "state_date" | arg = "-time" then sdt_sw= True; 2671 else if arg = "-state" then state_sw = True; 2672 else if arg = "-nhe" | arg = "-no_header" then header_sw, header_to_be_printed = False; 2673 else if arg = "-ast" | arg = "-all_states" | arg = "-all" then all_states = True; 2674 else if arg = "-dfmt" | arg = "-default_format" then dfmt_sw = True; 2675 else if arg = "-he" | arg = "-header" then header_sw, header_to_be_printed = True; 2676 else if arg = "-tt" | arg = "-total" then do; 2677 totals_wanted = True; 2678 header_sw, header_to_be_printed = False; 2679 end; 2680 else do; /* assume a volume name */ 2681 if get_area then do; 2682 get_area = False; 2683 volume_cnt = narg; 2684 allocate volume in (based_area) set (Pvolume); 2685 end; 2686 volume_sw = True; 2687 vol_cnt = vol_cnt + 1; 2688 volume(vol_cnt).name = arg; 2689 end; 2690 end; 2691 2692 if totals_wanted & (header_sw | state_sw | sdt_sw | name_sw | edt_sw | pvedt_sw | dfmt_sw | comment_sw | first_last_sw) 2693 then call abort_proc(error_table_$inconsistent, 2694 "-total^[ -header^;^]^[ -state^;^]^[ -state_date^;^]^[ -name^;^]^[ -edt^;^]^[ -pvedt^;^]^[ -dfmt^;^]^[ -first^;^]^[ -last^;^]", 2695 header_sw, state_sw, sdt_sw, name_sw, edt_sw, pvedt_sw, dfmt_sw, first_sw, last_sw); 2696 2697 if volume_sw & (match_sw | vs_sw | expire_sw | reserve_sw | pvexp_sw | free_sw | alloc_sw | first_last_sw) 2698 then call abort_proc(error_table_$inconsistent, 2699 "volume_names ^[ -match^;^]^[ -volume_size^;^]^[ -expire^;^]^[ -rsv^;^]^[ -pvexp^;^]^[ -free^;^]^[ -alloc^;^]^[ -first^;^]^[ -last^;^]", 2700 match_sw, vs_sw, expire_sw, reserve_sw, pvexp_sw, free_sw, alloc_sw, first_sw, last_sw); 2701 2702 if ^(name_sw | sdt_sw | state_sw | comment_sw | pvedt_sw | edt_sw) then dfmt_sw = True; 2703 if (name_sw & sdt_sw & state_sw & comment_sw) then dfmt_sw = True; 2704 2705 if index(state_string, "1"b) = 0 then /* set the default to consider all states */ 2706 specified_states(*) = True; 2707 2708 if volume_sw then do; 2709 not_in_pool = False; 2710 do i = 1 to vol_cnt; 2711 if volume_in_pool ((volume(i).name), volx) then call print(volx, vs_size); 2712 else do; 2713 not_in_pool = True; 2714 vol_list.name(fb_not_reg) = vol_list.name(fb_not_reg) || " " || rtrim(volume(i).name); 2715 vol_list.cnt(fb_not_reg) = vol_list.cnt(fb_not_reg) + 1; 2716 end; 2717 end; 2718 if not_in_pool then call construct_msg(not_reg); 2719 end; 2720 2721 else if (vs_sw | first_last_sw) then do; 2722 if vol_cnt = 0 then vol_cnt = volume_pool.n_vol; /* -ft or -lt not specified, set default */ 2723 volume_cnt = vol_cnt; 2724 allocate volume in (based_area) set (Pvolume); 2725 volume(*).want_it = False; 2726 call get_list_names(Pvolume, vol_cnt, vs_size, most_recent); 2727 if vol_cnt = 0 then call abort_proc(0, "No volumes met the list criteria specified."); 2728 do i = 1 to vol_cnt; 2729 if volume(i).want_it then call print (volume(i).indx, vs_size); 2730 end; 2731 end; 2732 2733 else do; 2734 i = volume_pool.head; 2735 do while (i ^= no_link); 2736 call print (i, vs_size); 2737 i = vpe(i).next; 2738 end; 2739 end; 2740 2741 if totals_wanted then do; 2742 if active_fnc then ret = convert(total_char, total_cnt); 2743 else do; 2744 if total_cnt = 0 then call msg_proc(0, "No volume sets met the list criteria specified."); 2745 else call msg_proc(0, "A total of ^d volume set^[s^].", total_cnt, total_cnt > 1); 2746 end; 2747 goto END_LIST; 2748 end; 2749 2750 if total_cnt = 0 then call msg_proc(0, "No volume sets met the list criteria specified."); 2751 else if ^active_fnc then 2752 if noaction_msg ^= "" then call ioa_$nnl("^/^a", noaction_msg); 2753 2754 END_LIST: 2755 return; 2756 end list_key; 2757 2758 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2759 2760 lock_required: proc() returns(bit(1)); 2761 2762 /* lock_required determines whether the pool has to be locked or not, depending on the requested action 2763* and the effective access of the caller 2764**/ 2765 2766 dcl code fixed bin(35); 2767 dcl mode fixed bin(5); 2768 2769 code = 0; 2770 if arg = "l" | arg = "ls" | arg = "list" | 2771 arg = "p" | arg = "pr" | arg = "print" | 2772 arg = "t" | arg = "test" then do; 2773 call hcs_$get_user_effmode (vol_dir, vol_ename, "", (get_ring_()), mode, code); 2774 if code ^= 0 then call abort_proc(code, "^/Unable to determine access of ^a", path(vol_dir, vol_ename)); 2775 if mode = R_ACCESS_BIN | mode = RE_ACCESS_BIN then return(False); 2776 end; 2777 2778 return(True); 2779 2780 end lock_required; 2781 2782 2783 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2784 2785 lock_volume_pool: proc; 2786 2787 /* Locks the volume pool */ 2788 2789 lock = False; 2790 call set_lock_$lock (volume_pool.lock, lock_interval, code); 2791 if code ^= 0 2792 then do; 2793 if code = error_table_$invalid_lock_reset then code = 0; 2794 else if code = error_table_$locked_by_this_process then code = 0; 2795 else call abort_proc (code, " ^a", 2796 path (vol_dir, vol_ename)); 2797 end; 2798 lock = (code = 0); 2799 end lock_volume_pool; 2800 2801 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2802 2803 msg: proc (err); 2804 2805 /* msg is a semi all-purpose message reporting facility. 2806* err = 0 means print the "manage_volume_pool:" header before the message. 2807* err = -1 says don't identify myself before the message. 2808**/ 2809 2810 dcl err fixed bin (35); 2811 dcl str char (256); 2812 dcl argp ptr; 2813 dcl str_len fixed bin; 2814 2815 if subroutine then do; 2816 if err = 0 | err = -1 then a_code = error_table_$action_not_performed; 2817 else a_code = err; 2818 if lock then call unlock_volume_pool; 2819 end; 2820 2821 call cu_$arg_list_ptr (argp); /* convert args to message */ 2822 call ioa_$general_rs (argp, 2, 3, str, str_len, "0"b, "0"b); 2823 if (err = 0 | err = -1) & ^subroutine & ^active_fnc then 2824 call ioa_ ("^[^a: ^;^s^]^a", err = 0, myname, substr (str, 1, str_len)); 2825 else call error_rnt (err, myname, substr (str, 1, str_len)); 2826 if subroutine then goto return_to_caller; 2827 2828 end msg; 2829 2830 2831 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2832 2833 move_into_state_date_order: 2834 proc(volx); 2835 2836 /* move_into_state_date_order moves the volume entry specified by volx to the appropriate 2837* location in the volume_pool list (based upon its state_date) by relinking the volume list. 2838**/ 2839 2840 dcl volx fixed bin; 2841 dcl voli fixed bin; 2842 2843 if volume_pool.head = volx & /* volume is alone in the list.*/ 2844 volume_pool.tail = volx then return; 2845 2846 if volume_pool.head = volx then do; /* first, remove volume from the list. */ 2847 volume_pool.head = vpe(volx).next; 2848 vpe(vpe(volx).next).previous = no_link; 2849 end; 2850 else if volume_pool.tail = volx then do; 2851 volume_pool.tail = vpe(volx).previous; 2852 vpe(vpe(volx).previous).next = no_link; 2853 end; 2854 else do; 2855 vpe(vpe(volx).previous).next = vpe(volx).next; 2856 vpe(vpe(volx).next).previous = vpe(volx).previous; 2857 end; 2858 2859 do voli = volume_pool.head repeat vpe(voli).next /* then skip over volumes with more */ 2860 while (voli ^= no_link & vpe(voli).state_date > vpe(volx).state_date); 2861 end; /* state date than our volume. */ 2862 2863 if voli = no_link then do; /* put volume at tail of list. */ 2864 voli = volume_pool.tail; 2865 vpe(voli).next = volx; 2866 vpe(volx).previous = voli; 2867 vpe(volx).next = no_link; 2868 volume_pool.tail = volx; 2869 end; 2870 else if voli = volume_pool.head then do; /* put volume at head of list. */ 2871 voli = volume_pool.head; 2872 vpe(voli).previous = volx; 2873 vpe(volx).next = voli; 2874 vpe(volx).previous = no_link; 2875 volume_pool.head = volx; 2876 end; 2877 else do; /* put volume in front of voli */ 2878 vpe(vpe(voli).previous).next = volx; 2879 vpe(volx).previous = vpe(voli).previous; 2880 vpe(volx).next = voli; 2881 vpe(voli).previous = volx; 2882 end; 2883 2884 end move_into_state_date_order; 2885 2886 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2887 2888 move_to_head: proc(volx); 2889 2890 /* move_to_head moves the volume entry specified by volx to the head of the volume_pool list by 2891* relinking the volume list. 2892**/ 2893 2894 dcl volx fixed bin; 2895 2896 vpe(volx).state_date = clock(); 2897 if volx = volume_pool.head then goto END_MOVE_TO_HEAD; /* Volume is already at head of pool */ 2898 if vpe(volx).previous ^= no_link then do; 2899 vpe(vpe(volx).previous).next = vpe(volx).next; 2900 if volx = volume_pool.tail then volume_pool.tail = vpe(volx).previous; 2901 end; 2902 if vpe(volx).next ^= no_link then vpe(vpe(volx).next).previous = vpe(volx).previous; 2903 vpe(volx).previous = no_link; 2904 vpe(volx).next = volume_pool.head; 2905 vpe(volume_pool.head).previous = volx; 2906 volume_pool.head = volx; 2907 2908 END_MOVE_TO_HEAD: 2909 return; 2910 end move_to_head; 2911 2912 2913 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2914 2915 path: proc (dirname, ename) returns (char (168)); 2916 2917 /* Constructs a pathname given the directory name and the entry name. */ 2918 2919 dcl dirname char (*); 2920 dcl ename char (*); 2921 dcl pathname char (168); 2922 call ioa_$rsnnl ("^a^[>^]^a", pathname, (0), dirname, dirname ^= ">", ename); 2923 return (pathname); 2924 end path; 2925 2926 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2927 2928 print: proc(vidx, vs_size); 2929 2930 /* Called by list_key, print determines whether a volume is to be printed. 2931* vidx: Index to volume. 2932* vs_size: Size of volumes to be printed. */ 2933 2934 dcl (vs_size, printx, vidx) fixed bin; 2935 2936 printx = vidx; 2937 if listed_flag(printx) then goto END_PRINT; 2938 2939 if vpe(printx).secondary_vol then /* set printx to primary volume as he has all the info. */ 2940 printx = vpe(printx).primary_idx; 2941 2942 if ^(specified_states(vpe (printx).state)) then goto END_PRINT; 2943 2944 if vs_size = -1 then; /* get volume_sets of any size */ 2945 else if (vpe(printx).vs_count) ^= vs_size then goto END_PRINT; 2946 2947 if expire_sw then do; 2948 /* print only those whose expire_date is < clock */ 2949 if ^(vpe(printx).expire) then goto END_PRINT; 2950 if vpe(printx).expire_date > clock() then goto END_PRINT; 2951 end; 2952 2953 if match_sw then do; 2954 compare = vpe (printx).comment; 2955 if ((index (compare, match_string) = 0) | (index (compare, match_string) = 64)) then goto END_PRINT; 2956 end; 2957 2958 /* At this point, all initial criteria to print has been met */ 2959 2960 call format_print_output(printx, False); 2961 2962 if verify(output, blank_NL) = 0 then; /* don't print if no output is found */ 2963 else do; 2964 if active_fnc & ^totals_wanted then do; 2965 requoted_output = requote_string_ (substr (output, 1, length(output))); 2966 ret = ret || " "; 2967 ret = ret || requoted_output; 2968 end; 2969 else do; 2970 if header_sw then do; /* did we print the header yet? */ 2971 call ioa_("^a", header_output); 2972 header_sw = False; 2973 end; 2974 if ^totals_wanted then call ioa_("^a", output); 2975 end; 2976 total_cnt = total_cnt + 1; 2977 end; 2978 2979 if vpe(printx).vs_count > 1 then call print_secondary_volumes(printx); 2980 2981 END_PRINT: 2982 return; 2983 end print; 2984 2985 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2986 2987 print_secondary_volumes: proc(printx); 2988 2989 /* Called by print, this procedure prints secondary volumes of a set. */ 2990 2991 dcl printx fixed bin parameter; 2992 2993 /* printx is the index to the primary volume. we want to now print the secondary volumes only */ 2994 2995 listed_flag(printx) = True; 2996 2997 printx = vpe(printx).secondary_idx; 2998 do while (printx ^= no_link); 2999 call format_print_output(printx, True); 3000 listed_flag(printx) = True; 3001 if output ^= "" then do; 3002 if active_fnc & ^totals_wanted then do; 3003 requoted_output = requote_string_ (substr (output, 1, length(output))); 3004 ret = ret || " "; 3005 ret = ret || requoted_output; 3006 end; 3007 else if ^totals_wanted then call ioa_("^a", output); 3008 end; 3009 printx = vpe(printx).secondary_idx; 3010 end; 3011 3012 end print_secondary_volumes; 3013 3014 3015 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 3016 3017 process: proc (fetch, routine); 3018 3019 /* Used by obselete keys change, comment and the old version of allocate. */ 3020 3021 dcl fetch bit (1) ; 3022 dcl routine entry; 3023 if narg < 2 then call abort_proc (error_table_$noarg, ""); 3024 ac = 2; 3025 do while (ac <= narg); 3026 call get_arg (ac, ap, al, (0), alp); 3027 if arg = "" then call abort_proc (error_table_$noarg, ""); 3028 call search (arg); 3029 if fetch then do; 3030 ac = ac + 1; 3031 call get_arg (ac, apa, ala, code, alp); 3032 if code ^= 0 then call abort_proc (code, "No comment specified."); 3033 end; 3034 call routine; 3035 ac = ac + 1; 3036 end; 3037 return; 3038 end process; 3039 3040 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 3041 3042 process_ctl_args: proc(Pargs_allowed, begin_arg, vol_cnt); 3043 3044 /* Called by various keys to process their control arguments. Also fills in the volume structure when 3045* volume names are specified. 3046* Pargs_allowed: Pointer to structure which specifies which arguments are allowed for the given 3047* key procedure caller (input). 3048* begin_arg: Where to start argument processing (input). 3049* vol_cnt: The number of volumes to be acted upon (output). 3050**/ 3051 dcl begin_arg fixed bin; 3052 dcl get_area bit(1); 3053 dcl vol_cnt fixed bin; 3054 dcl Pargs_allowed ptr; 3055 3056 dcl 1 args_allowed unaligned based (Pargs_allowed), 3057 2 first bit(1), 3058 2 last bit(1), 3059 2 force bit(1), 3060 2 volume_size bit(1), 3061 2 comment bit(1), 3062 2 expire bit(1), 3063 2 brief bit(1), 3064 2 fexp bit(1), 3065 2 match bit(1), 3066 2 all bit(1), 3067 2 pvexp bit(1), 3068 2 alloc bit(1), 3069 2 reserve bit(1), 3070 2 free bit(1), 3071 2 svol bit(1), 3072 2 asterisk bit(1), 3073 2 exp_dt bit(1), /* requires a date after -exp */ 3074 2 pvexp_dt bit(1), /* requires a date after -pvexp */ 3075 2 state_dt bit(1); 3076 3077 vs_size = -1; /* default is any size volume set if -vs isn't specified */ 3078 vol_cnt = 0; 3079 asterisk_cnt = 0; 3080 get_area = True; 3081 most_recent = False; 3082 3083 do ac = begin_arg to narg; 3084 call get_arg (ac, ap, al, (0), alp); 3085 if arg = "-exp" | arg = "-expire" then do; 3086 if ^(args_allowed.expire) then goto bad_ctl; 3087 expire_sw = True; 3088 if (args_allowed.exp_dt) then /* some keys require a date */ 3089 call get_next_arg("date", expire_ptr, expire_len); 3090 end; 3091 3092 else if arg = "-fc" | arg = "-force" then do; 3093 if ^(args_allowed.force) then goto bad_ctl; 3094 force_sw = True; 3095 end; 3096 3097 else if arg = "-ft" | arg = "-first" then do; 3098 if ^(args_allowed.first) then goto bad_ctl; 3099 first_last_sw, first_sw, most_recent = True; 3100 vol_cnt = get_number(); 3101 end; 3102 3103 else if arg = "-lt" | arg = "-last" then do; 3104 if ^(args_allowed.last) then goto bad_ctl; 3105 first_last_sw, last_sw = True; 3106 most_recent = False; 3107 vol_cnt = get_number(); 3108 end; 3109 3110 else if arg = "*" then do; /* have to support obsolete '*' use for test, delete, reserve. Same as -last 1 */ 3111 if ^(args_allowed.asterisk) then goto bad_ctl; 3112 asterisk_sw = True; 3113 most_recent = False; 3114 asterisk_cnt = asterisk_cnt + 1; 3115 end; 3116 3117 else if arg = "-vs" | arg = "-volume_size" then do; 3118 if ^(args_allowed.volume_size) then goto bad_ctl; 3119 vs_sw = True; 3120 vs_size = get_number(); 3121 end; 3122 3123 else if arg = "-com" | arg = "-comment" then do; 3124 if ^(args_allowed.comment) then goto bad_ctl; 3125 comment_sw = True; 3126 call get_next_arg("comment", com_ptr, com_len); 3127 end; 3128 3129 else if arg = "-bf" | arg = "-brief" then do; 3130 if ^(args_allowed.brief) then goto bad_ctl; 3131 brief_sw = True; 3132 end; 3133 3134 else if arg = "-fexp" | arg = "-force_expire" then do; 3135 if ^(args_allowed.fexp) then goto bad_ctl; 3136 fexp_sw = True; 3137 end; 3138 3139 else if arg = "-a" | arg = "-all" then do; 3140 if ^(args_allowed.all) then goto bad_ctl; 3141 all_sw = True; 3142 end; 3143 3144 else if arg = "-pvexp" | arg = "-pv_expire" then do; 3145 if ^(args_allowed.pvexp) then goto bad_ctl; 3146 pvexp_sw = True; 3147 if (args_allowed.pvexp_dt) then /* add and set keys require a date */ 3148 call get_next_arg("date", pvexp_ptr, pvexp_len); 3149 end; 3150 3151 else if arg = "-stdt" | arg = "-state_date" then do; 3152 if ^(args_allowed.state_dt) then go to bad_ctl; 3153 state_dt_sw = True; 3154 call get_next_arg("date", state_dt_ptr, state_dt_len); 3155 end; 3156 3157 else if arg = "-free" then do; 3158 if ^(args_allowed.free) then goto bad_ctl; 3159 free_sw = True; 3160 end; 3161 3162 else if arg = "-alloc" | arg = "-allocate" | arg = "-allocated" then do; 3163 if ^(args_allowed.alloc) then goto bad_ctl; 3164 alloc_sw = True; 3165 end; 3166 3167 else if arg = "-rsv" | arg = "-reserved" | arg = "-reserve" then do; 3168 if ^(args_allowed.reserve) then goto bad_ctl; 3169 reserve_sw = True; 3170 end; 3171 3172 else if arg = "-match" then do; 3173 if ^(args_allowed.match) then goto bad_ctl; 3174 ac = ac + 1; 3175 call get_arg (ac, ap, al, code, alp); 3176 if code ^= 0 then call abort_proc (code, "Unable to get arg after ^a", arg); 3177 match_sw = True; 3178 match_string = arg; 3179 end; 3180 3181 else if arg = "-svol" | arg = "-secondary_volumes" then do; 3182 if ^(args_allowed.svol) then goto bad_ctl; 3183 svol_sw = True; 3184 end; 3185 3186 else do; /* assume a volume name */ 3187 if get_area then do; 3188 get_area = False; 3189 volume_cnt = narg; 3190 allocate volume in (based_area) set (Pvolume); 3191 end; 3192 volume_sw = True; 3193 vol_cnt = vol_cnt + 1; 3194 volume(vol_cnt).name = arg; 3195 end; 3196 end; 3197 3198 return; 3199 3200 bad_ctl: 3201 call abort_proc(error_table_$badopt, " ^a", arg); 3202 3203 end process_ctl_args; 3204 3205 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 3206 3207 pv_expire_key: proc(); 3208 3209 /* Procedure which handles the pv_expire key */ 3210 3211 dcl primary_idx fixed bin; 3212 dcl (i, volx, vol_cnt) fixed bin; 3213 3214 /* The structure below describes the control arguments allowed for a given key. 3215* A control arg is valid when the bit is "1"b. */ 3216 3217 dcl 1 args_allowed unaligned static int options(constant), 3218 (2 first init ("0"b), 3219 2 last init ("0"b), 3220 2 force init ("1"b), 3221 2 vs init ("0"b), 3222 2 com init ("0"b), 3223 2 expire init ("0"b), 3224 2 brief init ("0"b), 3225 2 fexp init ("0"b), 3226 2 match init ("0"b), 3227 2 all init ("0"b), 3228 2 pvexp init ("0"b), 3229 2 alloc init ("0"b), 3230 2 reserve init ("0"b), 3231 2 free init ("0"b), 3232 2 svol init ("0"b), 3233 2 asterisk init ("0"b), 3234 2 exp_dt init ("0"b), 3235 2 pvexp_dt init ("0"b), 3236 2 state_dt init ("0"b)) bit(1); 3237 3238 if narg < 2 then call abort_proc (error_table_$noarg, "Usage: mvp pvexp volume_names {-control_arg}"); 3239 3240 /* get volume_names */ 3241 3242 call process_ctl_args(addr(args_allowed), 2, vol_cnt); 3243 3244 if vol_cnt = 0 then call abort_proc (error_table_$noarg, "No volume names specified."); 3245 3246 call check_for_errors(Pvolume, volume_cnt, vol_cnt, 0, not_reg | sec_vol | check_pvexp); 3247 3248 call evaluate_volumes_wanted("physically expired", Pvolume, volume_cnt, vol_cnt, none_sw, abort_sw); 3249 if none_sw | abort_sw then do; 3250 if active_fnc then do; 3251 ret = "false"; 3252 return; 3253 end; 3254 if none_sw then call abort_proc(error_table_$action_not_performed, 3255 "Volume set^[s^] specified ^[are^;is^] not registered in the pool.", (vol_cnt > 1), (vol_cnt > 1)); 3256 else if abort_sw then call abort_proc(error_table_$action_not_performed, "^a", noaction_msg); 3257 end; 3258 3259 /* expire the volumes */ 3260 3261 do i = 1 to vol_cnt; 3262 if volume(i).want_it then do; 3263 if ^(volume(i).noaction) then do; 3264 volx = volume(i).indx; 3265 if vpe(volx).secondary_vol then volx = vpe(volx).primary_idx; 3266 vpe(volx).state = pvexp_state; 3267 vpe(volx).pv_expire = False; 3268 if vpe(volx).vs_count > 1 then do; /* multiple volume set */ 3269 primary_idx = volx; 3270 do while (volx ^= no_link); 3271 vpe(volx).pv_expire = False; 3272 volx = vpe(volx).secondary_idx; 3273 end; 3274 volx = primary_idx; 3275 end; 3276 call move_to_head(volx); 3277 end; 3278 end; 3279 end; 3280 3281 if active_fnc then ret = "true"; 3282 else if noaction_msg ^= "" then call msg_proc(0, "^a", noaction_msg); 3283 3284 end pv_expire_key; 3285 3286 3287 3288 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 3289 3290 pvexp_secondary_vol_check: proc(a_idx) returns(bit(1)); 3291 3292 /* Called by check_for_pvexp, this procedure determines whether any secondary volumes of a set have 3293* physically expired. If so, true is returned, else false. */ 3294 3295 dcl (a_idx, vol_idx) fixed bin; 3296 3297 vol_idx = a_idx; 3298 if vpe(vol_idx).vs_count = 1 then return(False); /* Not a multiple volume set */ 3299 if vpe(vol_idx).state = allocated_state then return(False); /* allocated volumes cannot be expired */ 3300 3301 vol_idx = vpe(vol_idx).secondary_idx; 3302 do while (vol_idx ^= no_link); 3303 if vpe(vol_idx).pv_expire & vpe(vol_idx).pv_expire_date < clock() then return(True); 3304 vol_idx = vpe(vol_idx).secondary_idx; 3305 end; 3306 3307 return(False); 3308 3309 end pvexp_secondary_vol_check; 3310 3311 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 3312 3313 pvexp_volume: proc(vol_idx); 3314 3315 /* Called by check_for_pvexp, pvexp_volume does the actual work of physically expiring a volume as 3316* specified by vol_idx. */ 3317 3318 dcl (primary_idx, vol_idx) fixed bin; 3319 3320 vpe(vol_idx).state = pvexp_state; 3321 vpe(vol_idx).pv_expire = False; 3322 if vpe(vol_idx).vs_count > 1 then do; /* multiple volume set, reset secondary volumes too */ 3323 primary_idx = vol_idx; 3324 do while (vol_idx ^= no_link); 3325 vpe(vol_idx).pv_expire = False; 3326 vol_idx = vpe(vol_idx).secondary_idx; 3327 end; 3328 vol_idx = primary_idx; 3329 end; 3330 call move_to_head(vol_idx); 3331 3332 end pvexp_volume; 3333 3334 3335 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 3336 3337 query_to_continue: proc(requestor, msg, force, continue); 3338 3339 /* Determines whether to query or not. 3340* requestor: The action required by the caller, used in querying (input). 3341* msg: The message specified by the caller (input). 3342* force: Specifies whether to query the user or not (input). 3343* continue: Continue or abort the request? (output). 3344**/ 3345 dcl (continue, force) bit(1); 3346 dcl (requestor, msg) char(*); 3347 3348 if force then continue = True; 3349 else if active_fnc then continue = False; 3350 else continue = yes_to_query(requestor, msg); 3351 return; 3352 3353 end query_to_continue; 3354 3355 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 3356 3357 remove_volume_set: proc(); 3358 3359 /* This procedure handles the rmvs key of the mvp command */ 3360 3361 dcl (done, just_expired, found) bit(1); 3362 dcl i, 3363 volx, 3364 current_idx, 3365 remove_cnt, 3366 prev_idx, 3367 primary_idx, 3368 set_state fixed bin; 3369 3370 /* The structure below describes the control arguments allowed for a given key. 3371* A control arg is valid when the bit is "1"b. */ 3372 3373 dcl 1 args_allowed unaligned static int options(constant), 3374 (2 first init ("0"b), 3375 2 last init ("0"b), 3376 2 force init ("1"b), 3377 2 vs init ("0"b), 3378 2 com init ("0"b), 3379 2 expire init ("0"b), 3380 2 brief init ("1"b), 3381 2 fexp init ("1"b), 3382 2 match init ("0"b), 3383 2 all init ("1"b), 3384 2 pvexp init ("1"b), 3385 2 alloc init ("0"b), 3386 2 reserve init ("0"b), 3387 2 free init ("0"b), 3388 2 svol init ("0"b), 3389 2 asterisk init ("0"b), 3390 2 exp_dt init ("0"b), 3391 2 pvexp_dt init ("0"b), 3392 2 state_dt init ("0"b)) bit(1); 3393 3394 if narg < 3 then call abort_proc (error_table_$noarg, 3395 "^/Usage: mvp rmvs primary_volume_name {secondary_volume_names} {-control_args} "); 3396 3397 /* first get primary_volume_name */ 3398 3399 ac = 2; 3400 call get_arg (ac, ap, al, (0), alp); 3401 if ^(volume_in_pool((arg), primary_idx)) then call abort_proc(error_table_$action_not_performed, 3402 "Primary volume specified is not in the pool. " || arg); 3403 else if vpe(primary_idx).secondary_vol then call abort_proc(error_table_$action_not_performed, 3404 "^/Primary volume specified ^a is a secondary volume of set ^a.", arg, 3405 vpe(vpe(primary_idx).primary_idx).name); 3406 3407 /* now look at secondary volumes specified or control args */ 3408 3409 call process_ctl_args(addr(args_allowed), 3, vol_cnt); 3410 3411 if pvexp_sw then set_state = pvexp_state; 3412 else set_state = free_state; 3413 3414 if (pvexp_sw & all_sw) then call abort_proc(error_table_$inconsistent, "-pvexp -all"); 3415 if (pvexp_sw | all_sw) & volume_sw then call abort_proc(error_table_$inconsistent, 3416 "secondary_volumes and -control_args"); 3417 3418 if vpe(primary_idx).state = allocated_state & ^(fexp_sw) then do; 3419 /* check -expire date */ 3420 if vpe(primary_idx).expire & (vpe(primary_idx).expire_date > clock()) then do; 3421 /* hasn't expired, abort request */ 3422 if brief_sw then do; 3423 if active_fnc then call abort_proc(error_table_$action_not_performed, 3424 "^/Volume set ^a is not expired. ^a", vpe(primary_idx).name, 3425 time_string_(vpe(primary_idx).expire_date)); 3426 end; 3427 else call abort_proc(error_table_$action_not_performed, 3428 "^/Volume set ^a is not expired. ^a", vpe(primary_idx).name, 3429 time_string_(vpe(primary_idx).expire_date)); 3430 end; 3431 end; 3432 3433 if ^(volume_sw) then do; 3434 vol_cnt, volume_cnt = max( 1, vpe(primary_idx).vs_count - 1); 3435 allocate volume in (based_area) set (Pvolume); 3436 volume.want_it, volume.noaction = False; 3437 3438 if vpe(primary_idx).vs_count = 1 then /* volume set is size one */ 3439 volx = primary_idx; 3440 else /* set index to first secondary volume. primary volume stays unchanged */ 3441 volx = vpe(primary_idx).secondary_idx; 3442 3443 do i = 1 to vol_cnt while (volx >= 1); /* fill volume array with volumes to be removed */ 3444 volume(i).name = vpe(volx).name; 3445 volume(i).indx = volx; 3446 volume(i).want_it = True; 3447 volx = vpe(volx).secondary_idx; 3448 end; 3449 3450 if pvexp_sw then do; 3451 volume.want_it = False; 3452 do i = 1 to vol_cnt; 3453 if vpe(volume(i).indx).pv_expire & (vpe(volume(i).indx).pv_expire_date < clock()) then 3454 volume(i).want_it = True; 3455 end; 3456 end; 3457 end; 3458 3459 else do; /* secondary volume names were specified, verify them. */ 3460 call check_for_errors(Pvolume, volume_cnt, vol_cnt, primary_idx, not_reg | sec_not_found); 3461 end; 3462 3463 call evaluate_volumes_wanted("removed", Pvolume, volume_cnt, vol_cnt, none_sw, abort_sw); 3464 if none_sw then call abort_proc(error_table_$action_not_performed, 3465 "No physically expired volumes found in set ^a.", vpe(primary_idx).name); 3466 else if abort_sw then if noaction_msg ^= "" then call abort_proc(error_table_$action_not_performed, "^a", 3467 noaction_msg); 3468 3469 /* now remove the volumes */ 3470 3471 remove_cnt = 0; 3472 prev_idx = primary_idx; 3473 if vpe(primary_idx).vs_count = 1 then current_idx = primary_idx; 3474 else current_idx = vpe(primary_idx).secondary_idx; 3475 done = False; 3476 do while (^done); 3477 if vpe(current_idx).secondary_idx <= 0 then done = True; 3478 found = False; 3479 do i = 1 to vol_cnt while (^found); 3480 if volume(i).want_it & (volume(i).name = vpe(current_idx).name) then found = True; 3481 end; 3482 if found then call remove_volume(); 3483 else do; /* update prev_idx */ 3484 prev_idx = current_idx; 3485 current_idx = vpe(current_idx).secondary_idx; 3486 end; 3487 end; /* do loop */ 3488 3489 vpe(primary_idx).vs_count = max(1, vpe(primary_idx).vs_count - remove_cnt); 3490 if all_sw then do; /* remove primary volume also */ 3491 current_idx, prev_idx = primary_idx; 3492 call remove_volume(); 3493 end; 3494 if just_expired then do; 3495 call construct_msg(check_pvexp); 3496 if ^active_fnc & noaction_msg ^= "" then call msg_proc(0, "^a", noaction_msg); 3497 end; 3498 3499 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 3500 3501 remove_volume: proc(); 3502 3503 /* Internal procedure to remove_volume_set procedure, this guy does the actual removing of volumes */ 3504 3505 dcl save_idx fixed bin; 3506 3507 /* first check pvexp date to print message */ 3508 call check_for_pvexp(current_idx, brief_sw, just_expired); 3509 3510 remove_cnt = remove_cnt + 1; 3511 3512 /* relink the volume set chain */ 3513 vpe(prev_idx).secondary_idx = vpe(current_idx).secondary_idx; 3514 3515 /* reset the vpe being removed */ 3516 if active_fnc & ^just_expired then ret = ret || " " || rtrim(vpe(current_idx).name); 3517 vpe(current_idx).comment = ""; 3518 vpe(current_idx).secondary_vol = False; 3519 vpe(current_idx).expire = False; 3520 vpe(current_idx).expire_date = 0; 3521 vpe(current_idx).primary_idx = no_link; 3522 if ^just_expired then do; 3523 vpe(current_idx).state = free_state; 3524 vpe(current_idx).state_date = clock(); 3525 call move_to_head(current_idx); 3526 end; 3527 if vpe(current_idx).secondary_idx > 0 then do; 3528 save_idx = current_idx; 3529 current_idx = vpe(current_idx).secondary_idx; 3530 vpe(save_idx).secondary_idx = no_link; 3531 end; 3532 3533 end remove_volume; 3534 3535 end remove_volume_set; 3536 3537 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 3538 3539 reserved_by_another_process: proc(vol_idx) returns (bit(1)); 3540 3541 /* Returns true when a volume specified by vol_idx is reserved by another process */ 3542 3543 dcl vol_idx fixed bin; 3544 3545 if vpe(vol_idx).processid ^= get_process_id_() then do; /* reserved by another process */ 3546 call hcs_$validate_processid (vpe (vol_idx).processid, code); 3547 if code = error_table_$process_unknown then return(False); /* other process is not active */ 3548 else return(True); 3549 end; 3550 3551 return(False); 3552 3553 end reserved_by_another_process; 3554 3555 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 3556 3557 reserve_key: proc(); 3558 3559 /* Procedure which handles the mvp command reserve key. */ 3560 3561 dcl (i, vol_cnt, volx) fixed bin; 3562 dcl just_expired bit(1); 3563 3564 /* The structure below describes the control arguments allowed for a given key. 3565* A control arg is valid when the bit is "1"b. */ 3566 3567 dcl 1 args_allowed unaligned static int options(constant), 3568 (2 first init ("1"b), 3569 2 last init ("1"b), 3570 2 force init ("1"b), 3571 2 vs init ("1"b), 3572 2 com init ("1"b), 3573 2 expire init ("0"b), 3574 2 brief init ("0"b), 3575 2 fexp init ("0"b), 3576 2 match init ("0"b), 3577 2 all init ("0"b), 3578 2 pvexp init ("0"b), 3579 2 alloc init ("0"b), 3580 2 reserve init ("0"b), 3581 2 free init ("0"b), 3582 2 svol init ("0"b), 3583 2 asterisk init ("1"b), 3584 2 exp_dt init ("0"b), 3585 2 pvexp_dt init ("0"b), 3586 2 state_dt init ("0"b)) bit(1); 3587 3588 /* first process control args */ 3589 3590 if narg < 2 then call abort_proc (error_table_$noarg, "Usage: reserve {volume_names} {-control_args}"); 3591 3592 specified_states(free_state) = True; 3593 just_expired = False; 3594 3595 call process_ctl_args(addr(args_allowed), 2, vol_cnt); 3596 3597 if asterisk_sw then 3598 if (vs_sw | first_last_sw) then call abort_proc(error_table_$inconsistent, 3599 "The asterisk '*' is obsolete. Use '-last'"); 3600 else call msg_proc(-1, "The asterisk '*' is obsolete. Use '-last'"); 3601 3602 if volume_sw & (vs_sw | first_last_sw) then call abort_proc(error_table_$inconsistent, 3603 "volume_names ^[-volume_size^;^]^[-first^;-last^]", vs_sw, most_recent); 3604 3605 if asterisk_sw then do; 3606 tcnt = asterisk_cnt; 3607 allocate tvol in (based_area) set (Ptvol); 3608 tvol.want_it = False; 3609 call get_volumes_specified ("reserved", specified_states, Ptvol, tcnt, vs_size, most_recent); 3610 end; 3611 3612 else if ^(volume_sw) then do; /* -first or -last or -vs were specified */ 3613 if vol_cnt = 0 then vol_cnt = 1; 3614 volume_cnt = vol_cnt; 3615 allocate volume in (based_area) set (Pvolume); 3616 call get_volumes_specified ("reserved", specified_states, Pvolume, vol_cnt, vs_size, most_recent); 3617 end; 3618 3619 if volume_sw then 3620 call check_for_errors(Pvolume, volume_cnt, vol_cnt, 0, not_reg | sec_vol | not_free | check_pvexp); 3621 3622 if asterisk_sw then do; 3623 if ^(volume_sw) then do; 3624 vol_cnt = 0; 3625 volume_cnt = tcnt; 3626 allocate volume in (based_area) set (Pvolume); 3627 end; 3628 do i = 1 to tcnt; 3629 volume(vol_cnt + 1).name = tvol(i).name; 3630 volume(vol_cnt + 1).indx = tvol(i).indx; 3631 volume(vol_cnt + 1).want_it = tvol(i).want_it; 3632 vol_cnt = vol_cnt + 1; 3633 end; 3634 end; 3635 3636 call evaluate_volumes_wanted("reserved", Pvolume, volume_cnt, vol_cnt, none_sw, abort_sw); 3637 if none_sw then call abort_proc(error_table_$action_not_performed, 3638 "Volume set^[s^] specified ^[are^;is^] not registered in the pool.", (vol_cnt > 1), (vol_cnt > 1)); 3639 else if abort_sw then call abort_proc(error_table_$action_not_performed, "^a", noaction_msg); 3640 3641 /* reserve volumes specified */ 3642 3643 vol_msg_list = ""; 3644 vol_msg_cnt = 0; 3645 do i = 1 to vol_cnt; 3646 if volume(i).want_it then do; 3647 if ^(volume(i).noaction) then do; 3648 volx = volume(i).indx; 3649 if vpe(volx).secondary_vol then volx = vpe(volx).primary_idx; 3650 if active_fnc then ret = ret || " " || rtrim(vpe(volx).name); 3651 vpe (volx).state = reserved_state; 3652 vpe(volx).processid = get_process_id_ (); 3653 if comment_sw then vpe (volx).comment = comment_str; 3654 else vpe (volx).comment = ""; 3655 if (first_last_sw | asterisk_sw) then do; 3656 vol_msg_list = vol_msg_list || " " || rtrim(vpe(volx).name); 3657 vol_msg_cnt = vol_msg_cnt + 1; 3658 end; 3659 call move_to_head(volx); 3660 end; 3661 end; 3662 end; 3663 3664 if ^active_fnc then do; 3665 if vol_msg_list ^= "" then 3666 call msg_proc (0, "Volume set^[s^] ^a ^[has^;have^] been reserved. ^[^a^;^s^]", 3667 (vol_msg_cnt > 1), vol_msg_list, (vol_msg_cnt = 1), (noaction_msg ^=""), noaction_msg); 3668 else if noaction_msg ^= "" then call msg_proc(0, "^a", noaction_msg ); 3669 end; 3670 3671 end reserve_key; 3672 3673 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 3674 3675 reuse: proc(); 3676 3677 /* Procedure which handles the mvp command reuse key. */ 3678 3679 dcl (i, vol_cnt, volx) fixed bin; 3680 dcl just_expired bit(1); 3681 3682 /* The structure below describes the control arguments allowed for a given key. 3683* A control arg is valid when the bit is "1"b. */ 3684 3685 dcl 1 args_allowed unaligned static int options(constant), 3686 (2 first init ("1"b), 3687 2 last init ("1"b), 3688 2 force init ("1"b), 3689 2 vs init ("1"b), 3690 2 com init ("0"b), 3691 2 expire init ("0"b), 3692 2 brief init ("1"b), 3693 2 fexp init ("1"b), 3694 2 match init ("1"b), 3695 2 all init ("0"b), 3696 2 pvexp init ("0"b), 3697 2 alloc init ("0"b), 3698 2 reserve init ("0"b), 3699 2 free init ("0"b), 3700 2 svol init ("0"b), 3701 2 asterisk init ("0"b), 3702 2 exp_dt init ("0"b), 3703 2 pvexp_dt init ("0"b), 3704 2 state_dt init ("0"b)) bit(1); 3705 3706 /* first process list control args */ 3707 3708 call process_ctl_args(addr(args_allowed), 2, vol_cnt); 3709 3710 if volume_sw & (vs_sw | match_sw | first_last_sw) then call abort_proc(error_table_$inconsistent, 3711 "volume_names ^[-volume_size^;^]^[-match^;^]^[-first^;-last^]", vs_sw, match_sw, most_recent); 3712 3713 if first_last_sw | vs_sw then do; 3714 if vol_cnt = 0 then volume_cnt, vol_cnt = 1; 3715 else volume_cnt = vol_cnt; 3716 allocate volume in (based_area) set (Pvolume); 3717 volume.want_it, volume.noaction = False; 3718 specified_states(allocated_state) = True; 3719 call get_volumes_specified("re-allocated", specified_states, Pvolume, vol_cnt, vs_size, most_recent); 3720 end; 3721 3722 if match_sw then do; 3723 if vol_cnt = 0 then do; 3724 volume_cnt, vol_cnt = volume_pool.n_vol; 3725 allocate volume in (based_area) set (Pvolume); 3726 end; 3727 volume.want_it, volume.noaction = False; 3728 do i = 1 to vol_cnt; 3729 if (index (vpe(i).comment, match_string) > 0) & (vpe(i).state = allocated_state) then do; 3730 volume(i).name = vpe(i).name; 3731 volume(i).indx = i; 3732 volume(i).want_it = True; 3733 if (vpe(i).expire & vpe(i).expire_date < clock()) & ^fexp_sw then volume(i).noaction = True; 3734 call check_for_pvexp(i, brief_sw, just_expired); 3735 if just_expired then volume(i).noaction = True; 3736 end; 3737 end; /* do loop */ 3738 3739 if index(want_str, "1"b) = 0 then if ^(brief_sw) then call abort_proc(error_table_$action_not_performed, 3740 "^/No allocated volumes found with comment string matching ^a.", match_string); 3741 if just_expired then call construct_msg(check_pvexp); 3742 end; /* if match_sw */ 3743 3744 /* here's the case where volume names were specified */ 3745 3746 else if volume_sw then do; 3747 call check_for_errors(Pvolume, volume_cnt, vol_cnt, 0, not_reg | not_alloc | already_sec_vol | not_exp | check_pvexp); 3748 end; 3749 3750 call evaluate_volumes_wanted("reused", Pvolume, volume_cnt, vol_cnt, none_sw, abort_sw); 3751 if none_sw then call abort_proc(error_table_$action_not_performed, 3752 "Volume set^[s^] specified ^[are^;is^] not registered in the pool.", (vol_cnt > 1), (vol_cnt > 1)); 3753 else if abort_sw then if noaction_msg ^= "" then call abort_proc(error_table_$action_not_performed, "^a", noaction_msg); 3754 3755 /* now free and re-allocate the volumes */ 3756 3757 vol_msg_list = ""; 3758 vol_msg_cnt = 0; 3759 do i = 1 to vol_cnt; 3760 if volume(i).want_it then do; 3761 if ^(volume(i).noaction) then do; 3762 volx = volume(i).indx; 3763 if active_fnc then ret = ret || " " || rtrim(vpe(volx).name); 3764 if (( match_sw | first_last_sw) & ^brief_sw) then do; 3765 vol_msg_cnt = vol_msg_cnt +1; 3766 vol_msg_list = vol_msg_list || " " || rtrim(vpe(volx).name); 3767 end; 3768 call move_to_head(volx); 3769 end; 3770 end; 3771 end; 3772 3773 if ^active_fnc then do; 3774 if vol_msg_list ^= "" then 3775 call msg_proc(-1, "^a: Volume set^[s^] ^a ^[has^;have^] been re-allocated. ^[^a^;^s^]", 3776 myname, (vol_msg_cnt > 1), vol_msg_list, (vol_msg_cnt = 1), (noaction_msg ^= ""), noaction_msg); 3777 end; 3778 3779 end reuse; 3780 3781 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 3782 3783 search: proc (name); 3784 3785 /* Used by obselete keys and subroutine entry points. */ 3786 3787 dcl name char (*); 3788 3789 vlx = 0; 3790 if name = "*" then do; 3791 tvlx = volume_pool.tail; 3792 do while ((tvlx ^= no_link) & (vlx = 0)); 3793 if vpe(tvlx).state = free_state & vpe(tvlx).vs_count = 1 then vlx = tvlx; 3794 tvlx = vpe(tvlx).previous; 3795 end; 3796 end; 3797 else do; 3798 if volume_in_pool(arg, tvlx) then do; 3799 if vpe(tvlx).secondary_vol then vlx = vpe(tvlx).primary_idx; 3800 else vlx = tvlx; 3801 end; 3802 end; 3803 3804 return; 3805 end search; 3806 3807 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 3808 3809 set_key: proc(); 3810 3811 /* Procedure which handles the mvp command set key. */ 3812 3813 dcl (exp_clock, pv_clock) fixed bin(71); 3814 dcl i, vol_idx fixed bin; 3815 3816 /* The structure below describes the control arguments allowed for a given key. 3817* A control arg is valid when the bit is "1"b. */ 3818 3819 dcl 1 args_allowed unaligned static int options(constant), 3820 (2 first init ("0"b), 3821 2 last init ("0"b), 3822 2 force init ("0"b), 3823 2 vs init ("0"b), 3824 2 com init ("1"b), 3825 2 expire init ("1"b), 3826 2 brief init ("0"b), 3827 2 fexp init ("0"b), 3828 2 match init ("0"b), 3829 2 all init ("0"b), 3830 2 pvexp init ("1"b), 3831 2 alloc init ("0"b), 3832 2 reserve init ("0"b), 3833 2 free init ("0"b), 3834 2 svol init ("1"b), 3835 2 asterisk init ("0"b), 3836 2 exp_dt init ("1"b), 3837 2 pvexp_dt init ("1"b), 3838 2 state_dt init ("1"b)) bit(1); 3839 3840 if narg < 3 then call abort_proc (error_table_$noarg, 3841 "^/Usage: mvp set volume_names -control_args "); 3842 3843 pv_clock = 0; 3844 call process_ctl_args(addr(args_allowed), 2, vol_cnt); 3845 3846 if vol_cnt = 0 then call abort_proc(0, "No volume names specified."); 3847 if ^(comment_sw | pvexp_sw | expire_sw | state_dt_sw) then call abort_proc(0, "No -control_args specified."); 3848 if (svol_sw & ^(pvexp_sw | state_dt_sw)) then 3849 call abort_proc(error_table_$inconsistent, 3850 "-svol is used only in conjuction with -pvexp or -state_date"); 3851 3852 if pvexp_sw then do; 3853 call convert_date_to_binary_(pvexp_str, pv_clock, code); 3854 if code ^= 0 then call abort_proc(code, pvexp_str); 3855 end; 3856 3857 if expire_sw then do; 3858 call convert_date_to_binary_(expire_str, exp_clock, code); 3859 if code ^= 0 then call abort_proc(code, expire_str); 3860 end; 3861 3862 if state_dt_sw then do; 3863 call convert_date_to_binary_(state_dt_str, state_dt_clock, code); 3864 if code ^= 0 then call abort_proc(code, state_dt_str); 3865 end; 3866 3867 call check_for_errors(Pvolume, volume_cnt, vol_cnt, 0, not_reg | not_updated | check_pvexp); 3868 3869 if vol_list.name(fb_not_updated) ^= "" then do; /* this is the only case to abort the request */ 3870 if active_fnc then do; 3871 ret = "false"; 3872 return; 3873 end; 3874 else call abort_proc(error_table_$action_not_performed, "^a", noaction_msg); 3875 end; 3876 3877 /* process volumes specified */ 3878 3879 do i = 1 to vol_cnt; 3880 if volume(i).want_it then do; 3881 if ^(volume(i).noaction) then do; 3882 vol_idx = volume(i).indx; 3883 if pvexp_sw then do; 3884 if svol_sw then do; 3885 if vpe(vol_idx).secondary_vol then vol_idx = vpe(vol_idx).primary_idx; 3886 do while (vol_idx ^= no_link); 3887 vpe(vol_idx).pv_expire_date = pv_clock; 3888 vpe(vol_idx).pv_expire = True; 3889 vol_idx = vpe(vol_idx).secondary_idx; 3890 end; 3891 end; 3892 else do; 3893 vpe(vol_idx).pv_expire = pvexp_sw; 3894 vpe(vol_idx).pv_expire_date = pv_clock; 3895 end; 3896 vol_idx = volume(i).indx; 3897 end; 3898 if state_dt_sw then do; 3899 if vpe(vol_idx).secondary_vol then vol_idx = vpe(vol_idx).primary_idx; 3900 do while (vol_idx ^= no_link); 3901 vpe(vol_idx).state_date = state_dt_clock; 3902 vol_idx = vpe(vol_idx).secondary_idx; 3903 end; 3904 vol_idx = volume(i).indx; 3905 call move_into_state_date_order (vol_idx); 3906 end; 3907 if vpe(vol_idx).secondary_vol then vol_idx = vpe(vol_idx).primary_idx; 3908 if expire_sw & vpe(vol_idx).state = allocated_state then do; 3909 vpe(vol_idx).expire = True; 3910 vpe(vol_idx).expire_date = exp_clock; 3911 end; 3912 if comment_sw then vpe (vol_idx).comment = comment_str; 3913 end; 3914 end; 3915 end; 3916 3917 if active_fnc then ret = "true"; 3918 else if noaction_msg ^= "" then call msg_proc(0, "^a", noaction_msg); 3919 3920 end set_key; 3921 3922 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 3923 3924 setup: proc ; 3925 3926 /* Called by just about everyone to initialize things */ 3927 3928 Pvolume, Ptvol, areap, retp, vpp = null(); 3929 lock = False; 3930 code, ecode = 0; 3931 active_fnc = False; 3932 abort_proc = abort; 3933 msg_proc = msg; 3934 if subroutine then do; 3935 a_code = 0; 3936 myname = "manage_volume_pool_"; 3937 error_rnt = a_error_rnt; 3938 vpp = a_vpp; 3939 if vpp ^= null() then do; 3940 if volume_pool.version ^= volume_pool_version_3 then call check_first_then_convert(); 3941 call lock_volume_pool; 3942 end; 3943 end; 3944 else do; 3945 noaction_cnt, total_cnt = 0; 3946 vol_msg_list, noaction_msg = ""; 3947 vol_list.name = ""; 3948 vol_list.cnt = 0; 3949 free_sw, match_sw, most_recent, asterisk_sw = False; 3950 name_sw, sdt_sw, comment_sw, state_sw, alloc_sw, reserve_sw, free_sw, 3951 force_sw, fexp_sw, brief_sw, pvedt_sw, edt_sw, first_sw, last_sw, expire_sw, first_last_sw, 3952 pvexp_sw, state_dt_sw, all_sw, totals_wanted, svol_sw, volume_sw, vs_sw, dfmt_sw, specified_states(*) = False; 3953 all_states, header_sw, header_to_be_printed = True; 3954 call cu_$arg_list_ptr (alp); 3955 call cu_$af_return_arg (narg, retp, retl, code); 3956 active_fnc = (code = 0); 3957 if active_fnc then error_rnt = active_fnc_err_; 3958 else error_rnt = com_err_; 3959 myname = "manage_volume_pool"; 3960 if active_fnc then get_arg = cu_$af_arg_ptr_rel; 3961 else get_arg = cu_$arg_ptr_rel; 3962 3963 if narg = 0 then 3964 arg_err: call abort_proc (0, "USAGE: manage_volume_pool key {-control_args}"); 3965 call get_arg (1, ap, al, (0), alp); 3966 if bad_arg (arg) then goto arg_err; 3967 if arg = "use" | arg = "u" then goto END_SETUP; 3968 else call setup_pool_path("0"b); 3969 if volume_pool.version ^= volume_pool_version_3 then call check_first_then_convert(); 3970 if lock_required() then call lock_volume_pool(); 3971 areap = get_system_free_area_(); 3972 end; 3973 END_SETUP: 3974 return; 3975 end setup; 3976 3977 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 3978 3979 setup_pool_path: proc(have_pool_path); 3980 3981 /* Two cases: */ 3982 /* 1) have_pool_path is FALSE */ 3983 /* Called by setup and use_key procedures. Sets the default volume pool, which is person_id.volumes in */ 3984 /* the user's home_dir, */ 3985 /* creating the pool if it doesn't exist. */ 3986 /* 2) have_pool_path is TRUE */ 3987 /* Called by use_key procedure and set_pool_path entry. Initiates the volume pool specified by arg */ 3988 /* creating the pool if it doesn't exist. */ 3989 /* */ 3990 /* Variables vol_dir and vol_ename are set. */ 3991 3992 dcl have_pool_path bit(1); 3993 3994 if have_pool_path then do; 3995 call expand_pathname_ (arg, vol_dir, vol_ename, code); 3996 if code ^= 0 then call abort_proc (code, "Unable to expand ^a", arg); 3997 end; 3998 3999 else do; /* Use volume pool last referenced */ 4000 if vol_dir = "" then do; /* no previous volume pool was referenced; set to default pool, */ 4001 call user_info_$homedir (vol_dir); 4002 call user_info_ (vol_ename, "", ""); 4003 end; /* if vol_dir = "" */ 4004 end; 4005 4006 call suffixed_name_$make (vol_ename, "volumes", vol_ename, code); 4007 if code ^= 0 then call abort_proc (code, "Unable to construct volume pool name ^a.volumes.", vol_ename); 4008 4009 call initiate_file_ (vol_dir, vol_ename, RW_ACCESS, vpp, vp_bc, code); 4010 if vpp = null then call create_pool(); 4011 4012 if subroutine then a_vpp = vpp; 4013 4014 end setup_pool_path; 4015 4016 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4017 4018 test_key: proc(); 4019 4020 /* Procedure which handles the mvp command test key. */ 4021 4022 dcl (volx, list_cnt, list_no_cnt, 4023 vol_cnt, i) fixed bin; 4024 dcl (yes, no) bit(1); 4025 dcl (test_vol_list, 4026 test_no_vol_list) char(256) var; 4027 4028 /* The structure below describes the control arguments allowed for a given key. 4029* A control arg is valid when the bit is "1"b. */ 4030 4031 dcl 1 args_allowed unaligned static int options(constant), 4032 (2 first init ("1"b), 4033 2 last init ("1"b), 4034 2 force init ("0"b), 4035 2 vs init ("1"b), 4036 2 com init ("0"b), 4037 2 expire init ("0"b), 4038 2 brief init ("0"b), 4039 2 fexp init ("0"b), 4040 2 match init ("1"b), 4041 2 all init ("0"b), 4042 2 pvexp init ("1"b), 4043 2 alloc init ("1"b), 4044 2 reserve init ("1"b), 4045 2 free init ("1"b), 4046 2 svol init ("0"b), 4047 2 asterisk init ("1"b), 4048 2 exp_dt init ("0"b), 4049 2 pvexp_dt init ("0"b), 4050 2 state_dt init ("0"b)) bit(1); 4051 4052 /* process control args */ 4053 4054 if narg < 2 then call abort_proc (error_table_$noarg, "^/Usage: mvp test {volume_names} {-control_args}"); 4055 4056 call process_ctl_args(addr(args_allowed), 2, vol_cnt); 4057 4058 if asterisk_sw then 4059 if (vs_sw | first_last_sw) then call abort_proc(error_table_$inconsistent, 4060 "The asterisk '*' is obsolete. Use '-last'"); 4061 else call msg_proc(-1, "The asterisk '*' is obsolete. Use '-last'"); 4062 4063 if volume_sw & (vs_sw | first_last_sw ) then call abort_proc(error_table_$inconsistent, 4064 "volumes and ^[-vs ^]^[-first^;-last ^]", vs_sw, most_recent); 4065 4066 specified_states(free_state) = free_sw; 4067 specified_states(allocated_state) = alloc_sw; 4068 specified_states(reserved_state) = reserve_sw; 4069 specified_states(pvexp_state) = pvexp_sw; 4070 4071 if state_string = truebits then call abort_proc(error_table_$inconsistent, 4072 "^[ -free ^]^[-alloc ^]^[-reserve ^]^[-pvexp ^]", specified_states(free_state), specified_states(allocated_state), 4073 specified_states(reserved_state), specified_states(pvexp_state)); 4074 4075 if index(state_string, "1"b) = 0 then /* set default */ 4076 specified_states(free_state) = True; 4077 4078 force_sw = True; /* query feature is not used with test key */ 4079 if vol_cnt = 0 then vol_cnt = 1; 4080 4081 if asterisk_sw then do; 4082 tcnt = asterisk_cnt; 4083 allocate tvol in (based_area) set (Ptvol); 4084 tvol.want_it = False; 4085 call get_volumes_specified ("tested", specified_states, Ptvol, tcnt, vs_size, most_recent); 4086 end; 4087 4088 else if ^(volume_sw) then do; 4089 volume_cnt = vol_cnt; 4090 allocate volume in (based_area) set (Pvolume); 4091 call get_volumes_specified("tested", specified_states, Pvolume, vol_cnt, vs_size, most_recent); 4092 end; 4093 4094 if volume_sw then do; /* volume names were specified */ 4095 call check_for_errors(Pvolume, volume_cnt, vol_cnt, 0, not_reg | sec_vol | check_pvexp); 4096 end; 4097 4098 if asterisk_sw then do; 4099 if ^(volume_sw) then do; 4100 vol_cnt = 0; 4101 volume_cnt = tcnt; 4102 allocate volume in (based_area) set (Pvolume); 4103 end; 4104 do i = 1 to tcnt; 4105 volume(vol_cnt + 1).name = tvol(i).name; 4106 volume(vol_cnt + 1).indx = tvol(i).indx; 4107 volume(vol_cnt + 1).want_it = tvol(i).want_it; 4108 vol_cnt = vol_cnt + 1; 4109 end; 4110 end; 4111 4112 yes, no = False; 4113 test_vol_list, test_no_vol_list = ""; 4114 list_cnt, list_no_cnt = 0; 4115 4116 do i = 1 to vol_cnt; 4117 if volume(i).want_it & ^(volume(i).noaction) then do; 4118 volx = volume(i).indx; 4119 if vpe(volx).secondary_vol then volx = vpe(volx).primary_idx; 4120 if specified_states (vpe(volx).state) then do; 4121 yes = True; 4122 test_vol_list = test_vol_list || " " || rtrim(volume(i).name); 4123 list_cnt = list_cnt +1; 4124 end; 4125 else do; 4126 no = True; 4127 test_no_vol_list = test_no_vol_list || " " || rtrim(volume(i).name); 4128 list_no_cnt = list_no_cnt + 1; 4129 end; 4130 end; 4131 end; 4132 4133 if active_fnc then do; 4134 if yes & no then ret = "false"; 4135 else if yes then ret = "true"; 4136 else ret = "false"; /* no */ 4137 end; 4138 else do; 4139 if noaction_msg ^= "" then call msg_proc (0, "^a", noaction_msg); 4140 4141 if yes then 4142 call msg_proc 4143 (-1, "^[^a: ^;^s^]Volume set^[s^]^a ^[are^;is^] ^[free^;^[reserved^;^[allocated^;pv_expired^]^]^].", 4144 (noaction_msg = ""), myname, 4145 (list_cnt > 1), test_vol_list, (list_cnt > 1), 4146 specified_states(free_state), specified_states(reserved_state), 4147 specified_states(allocated_state), specified_states(pvexp_state)); 4148 4149 if no then 4150 call msg_proc 4151 (-1, "^[^a: ^;^s^]Volume set^[s^]^a ^[is^;are^] not ^[free^;^[reserved^;^[allocated^;pv_expired^]^]^].", 4152 (^yes), myname, (list_no_cnt > 1), test_no_vol_list, (list_no_cnt = 1), 4153 specified_states(free_state), specified_states(reserved_state), 4154 specified_states(allocated_state), specified_states(pvexp_state)); 4155 end; 4156 4157 end test_key; 4158 4159 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4160 4161 time_string_: proc (time) returns (char (20)); 4162 4163 dcl time fixed bin (71); 4164 dcl time_char char (24) aligned; 4165 4166 call date_time_ (time, time_char); 4167 return (substr(time_char, 1, 20)); 4168 4169 end time_string_; 4170 4171 4172 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4173 4174 unlock_volume_pool: proc; 4175 4176 /* unlocks the volume pool */ 4177 4178 call set_lock_$unlock (volume_pool.lock, ecode); 4179 if ecode ^= 0 then do; 4180 if ecode = error_table_$lock_not_locked then ecode = 0; 4181 else call abort_proc (ecode, "Error unlocking volume pool ^a.", 4182 path (vol_dir, vol_ename)); 4183 end; 4184 lock = ^(ecode = 0); 4185 return; 4186 end unlock_volume_pool; 4187 4188 4189 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4190 4191 use_key: proc(); 4192 4193 /* Procedure which handles the mvp command use key. */ 4194 4195 if narg > 2 then call abort_proc (0, "USAGE: manage_volume_pool use {pathname}."); 4196 if narg = 1 then do; 4197 vol_dir, vol_ename = ""; 4198 call setup_pool_path("0"b); 4199 end; 4200 else do; 4201 call get_arg (2, ap, al, code, alp); 4202 call setup_pool_path("1"b); 4203 end; 4204 4205 if active_fnc then ret = path(vol_dir, vol_ename); 4206 4207 end use_key; 4208 4209 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4210 4211 volume_in_pool: proc(vol_name, vol_idx) returns(bit(1)); 4212 4213 /* Determines whether the volume specified by vol_name is in the pool, and returns true. 4214* vol_name: name of the volume to be looked for. (input) 4215* vol_idx: index of the volume found in the pool(output) 4216**/ 4217 4218 dcl vol_name char(*), 4219 (i, vol_idx) fixed bin; 4220 4221 if volume_pool.volume_count = 0 then return(False); /* no volumes yet in the pool */ 4222 vol_idx = volume_pool.head; 4223 do while (vol_idx ^= no_link); 4224 if vpe (vol_idx).name = vol_name then return(True); 4225 if vpe(vol_idx).vs_count > 1 then do; 4226 i = vpe(vol_idx).secondary_idx; 4227 do while (i ^= no_link); 4228 if vpe (i).name = vol_name then do; 4229 vol_idx = i; /* return secondary volume index */ 4230 return(True); 4231 end; 4232 i = vpe(i).secondary_idx; 4233 end; 4234 end; 4235 vol_idx = vpe(vol_idx).next; 4236 end; 4237 return(False); 4238 4239 end volume_in_pool; 4240 4241 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4242 4243 volume_in_volume_set: proc(vol_name, primary_idx, vol_idx) returns(bit(1)); 4244 4245 /* determines whether a volume specified by vol_name is in a given volume set. 4246* vol_name: name of the volume to be looked for. (input) 4247* primary_idx: idx of primary volume of the set to be searched (input) 4248* vol_idx: index of the secondary volume found in the pool (output) 4249**/ 4250 4251 dcl vol_name char(*), 4252 (primary_idx, vol_idx) fixed bin; 4253 4254 vol_idx = vpe(primary_idx).secondary_idx; 4255 do while (vol_idx ^= no_link); 4256 if vpe (vol_idx).name = vol_name then return(True); 4257 vol_idx = vpe(vol_idx).secondary_idx; 4258 end; 4259 return(False); 4260 4261 end volume_in_volume_set; 4262 4263 4264 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 4265 4266 yes_to_query: proc(request_type, msg) returns(bit(1)); 4267 4268 /* Initializes the query_info structure and querys the user about continuing a */ 4269 /* given request or not. */ 4270 4271 dcl (request_type, msg) char(*); 4272 dcl EXPLAIN_FORCE_MSG char(163) int static options(constant) init( 4273 "A no reply aborts the key request. A yes will perform the request on eligible 4274 volume sets and a message printed listing the ones upon which no action was taken."); 4275 4276 4277 if msg = "" then 4278 call command_query_$yes_no(yes_sw, 0, "mvp", EXPLAIN_FORCE_MSG, 4279 "Some volumes requested cannot be ^a. Do you wish to continue?", request_type); 4280 4281 else 4282 call command_query_$yes_no(yes_sw, 0, "mvp", EXPLAIN_FORCE_MSG, "^a Do you wish to continue?", msg); 4283 4284 return (yes_sw); 4285 4286 end yes_to_query; 4287 1 1 /* BEGIN INCLUDE FILE ... access_mode_values.incl.pl1 1 2* 1 3* Values for the "access mode" argument so often used in hardcore 1 4* James R. Davis 26 Jan 81 MCR 4844 1 5* Added constants for SM access 4/28/82 Jay Pattin 1 6* Added text strings 03/19/85 Chris Jones 1 7**/ 1 8 1 9 1 10 /* format: style4,delnl,insnl,indattr,ifthen,dclind10 */ 1 11 dcl ( 1 12 N_ACCESS init ("000"b), 1 13 R_ACCESS init ("100"b), 1 14 E_ACCESS init ("010"b), 1 15 W_ACCESS init ("001"b), 1 16 RE_ACCESS init ("110"b), 1 17 REW_ACCESS init ("111"b), 1 18 RW_ACCESS init ("101"b), 1 19 S_ACCESS init ("100"b), 1 20 M_ACCESS init ("010"b), 1 21 A_ACCESS init ("001"b), 1 22 SA_ACCESS init ("101"b), 1 23 SM_ACCESS init ("110"b), 1 24 SMA_ACCESS init ("111"b) 1 25 ) bit (3) internal static options (constant); 1 26 1 27 /* The following arrays are meant to be accessed by doing either 1) bin (bit_value) or 1 28* 2) divide (bin_value, 2) to come up with an index into the array. */ 1 29 1 30 dcl SEG_ACCESS_MODE_NAMES (0:7) init ("null", "W", "E", "EW", "R", "RW", "RE", "REW") char (4) internal 1 31 static options (constant); 1 32 1 33 dcl DIR_ACCESS_MODE_NAMES (0:7) init ("null", "A", "M", "MA", "S", "SA", "SM", "SMA") char (4) internal 1 34 static options (constant); 1 35 1 36 dcl ( 1 37 N_ACCESS_BIN init (00000b), 1 38 R_ACCESS_BIN init (01000b), 1 39 E_ACCESS_BIN init (00100b), 1 40 W_ACCESS_BIN init (00010b), 1 41 RW_ACCESS_BIN init (01010b), 1 42 RE_ACCESS_BIN init (01100b), 1 43 REW_ACCESS_BIN init (01110b), 1 44 S_ACCESS_BIN init (01000b), 1 45 M_ACCESS_BIN init (00010b), 1 46 A_ACCESS_BIN init (00001b), 1 47 SA_ACCESS_BIN init (01001b), 1 48 SM_ACCESS_BIN init (01010b), 1 49 SMA_ACCESS_BIN init (01011b) 1 50 ) fixed bin (5) internal static options (constant); 1 51 1 52 /* END INCLUDE FILE ... access_mode_values.incl.pl1 */ 4288 4289 end manage_volume_pool; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 10/19/92 1555.9 manage_volume_pool.pl1 >spec>install>1028>manage_volume_pool.pl1 4288 1 04/11/85 1552.6 access_mode_values.incl.pl1 >ldd>include>access_mode_values.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. Arg_expected parameter char packed unaligned dcl 2407 set ref 2403 2412* EXPLAIN_FORCE_MSG 000013 constant char(163) initial packed unaligned dcl 4272 set ref 4277* 4281* False constant bit(1) initial packed unaligned dcl 278 set ref 416 488 674 751 851 995 1064 1145 1147 1295* 1323 1389 1535 1537 1576 1578 1685 1766 1825 1835 1898 1905 1921 1945 1971 2118 2171 2197 2215 2245 2246 2375 2380 2383 2387 2388 2393 2515 2603 2605 2638 2642 2646 2650 2659 2672 2678 2682 2709 2725 2775 2789 2960* 2972 3081 3106 3113 3188 3267 3271 3298 3299 3307 3321 3325 3349 3436 3451 3475 3478 3518 3519 3547 3551 3593 3608 3717 3727 3929 3931 3949 3950 4084 4112 4221 4237 4259 Pargs_allowed parameter pointer dcl 3054 ref 3042 3086 3088 3093 3098 3104 3111 3118 3124 3130 3135 3140 3145 3147 3152 3158 3163 3168 3173 3182 Plisted 000100 automatic pointer dcl 102 set ref 2375 2604* 2605 2937 2995 3000 Ptvol 000104 automatic pointer dcl 104 set ref 1684* 1685 1686* 1699 1700 1701 1877 1877 3607* 3608 3609* 3629 3630 3631 3928* 4083* 4084 4085* 4105 4106 4107 Pvolume 000102 automatic pointer dcl 103 set ref 491* 499 500 506 507 521 522 528 529 543 544 728* 730* 744 745 748 850* 851 852* 857* 861* 870 871 872 994* 995 996* 1002* 1005* 1015 @€ÜêLÛ ‡÷àý°¡~rÈp¶ô@=LÿÿÿÿSñ¹Ý(™ÿ&H‚ &Úz€ÜêLÒ&€q\Lgªzz¶Äar,Attendees €q\RyÔKàý°„’Ö ¶Äa€ÜêL® *@€q\ZœSiteSA €ÜêL˜6>*@€q\ÈLeskiw €ÜêL†>Multics €ÜêLr&€q å@vàÜÚÚ¶ÄaÒTransactions €q åIlðàý°„g’øø¶Äa€ÜêL*@€q å6hZ*@€q\Ò&€q Ë@vàܶÄa.Proceedings.1 €q ËIlð}Ûî2® š’..¶Äa€ÜêL*@€q Ë®L*@€q\ÄÞMSGD €ÜêLœ†PLASTICS €ÜêLô TOBSWE €ÜêL~p*@€q\DEVM €ÜêLh”†*@€q\LÄNMLPROD €ÜêL~ªœ*@€q\ LSTDSPPT €ÜêL” ²*@€q\ÞEngAdmin €ÜêL Ö¶*@À€q\¶Dickson €ÜêLÀÈ*@€q\>²Guest €ÜêL *@€q\ZTolts €ÜêLì˜ô*@€q\ªÀÞ*@€q\²pDPS-E €ÜêLì*@€€q\ packed unaligned dcl 1363 ref 1357 1368 a_code parameter fixed bin(35,0) dcl 105 set ref 449 454 473 483* 537* 549 559 569 583 601 615 630 651* 652* 2816* 2817* 3935* a_comment parameter char packed unaligned dcl 106 set ref 449 454 463 464 601 610* a_error_rnt parameter entry variable dcl 392 ref 449 454 473 549 559 569 583 601 615 630 3937 a_idx parameter fixed bin(17,0) dcl 3295 ref 3290 3297 a_match_str parameter varying char dcl 107 ref 473 488 497 519 a_most_recent parameter bit(1) packed unaligned dcl 108 ref 473 492 a_number parameter fixed bin(17,0) dcl 109 ref 473 482 487 a_path parameter char packed unaligned dcl 110 set ref 615 625 626 630 640* a_requested parameter char packed unaligned dcl 111 set ref 449 454 461 462 549 553 554 559 563 564 601 605 606 a_state parameter fixed bin(17,0) dcl 112 set ref 601 612* a_states parameter bit(1) array packed unaligned dcl 2475 set ref 2467 2509* 2509* 2529 a_time parameter fixed bin(71,0) dcl 113 set ref 601 611* a_volid parameter bit(36) packed unaligned dcl 114 ref 569 580 a_volname parameter char packed unaligned dcl 115 set ref 449 454 470* 569 576 577 a_volumes parameter varying char dcl 116 set ref 473 541* 543* 543 a_vpp parameter pointer dcl 117 set ref 449 454 473 549 559 569 583 601 615 620* 630 3938 4012* abort_proc 003440 automatic entry variable dcl 392 set ref 442 468 579 608 638 669 716 722 725 736 738 776 779 780 837 842 862 864 969 976 978 986 1006 1008 1076 1077 1105 1113 1350 1476 1482 1598 1623 1634 1635 1673 1676 1712 1714 1754 1867 1869 2115 2116 2156 2162 2188 2210 2219 2230 2232 2412 2455 2509 2520 2601 2632 2692 2697 2727 2774 2795 3023 3027 3032 3176 3200 3238 3244 3254 3256 3394 3401 3403 3414 3415 3423 3427 3464 3466 3590 3597 3602 3637 3639 3710 3739 3751 3753 3840 3846 3847 3848 3854 3859 3864 3874 3932* 3963 3996 4007 4054 4058 4063 4071 4181 4195 abort_sw 000106 automatic bit(1) packed unaligned dcl 118 in procedure "manage_volume_pool_" set ref 730* 731 738 861* 864 1005* 1008 1706* 1707 1714 2229* 2232 3248* 3249 3256 3463* 3466 3636* 3639 3750* 3753 abort_sw parameter bit(1) packed unaligned dcl 1809 in procedure "evaluate_volumes_wanted" set ref 1796 1825* 1847* 1853* ac 000107 automatic fixed bin(17,0) dcl 119 set ref 974* 975* 1767* 1768* 2411 2415* 2415 2416* 2450 2451* 2451 2452* 2459* 2459 2627* 2628* 2630* 2630 2631* 3024* 3025 3026* 3030* 3030 3031* 3035* 3035 3083* 3084* 3174* 3174 3175* 3399* 3400* action parameter char packed unaligned dcl 1808 set ref 1796 1850* active_fnc 000110 automatic bit(1) packed unaligned dcl 120 set ref 439 732 762 792 880 887 915 1017 1040 1237 1327 1351 1381 1480 1571 1708 1730 1903 1908 1908* 1908* 1908* 1918 1923* 1926 1926* 1926* 1926* 1926* 1926* 1926* 1943 1947* 1950 1950* 1950* 1950 1950* 1950 1950* 1950* 1967 1975 1977* 1977* 1980* 1983* 1983* 1983* 1983* 1992* 1992* 1992* 1992* 1992* 2003* 2003* 2003* 2021* 2023* 2023* 2029* 2029* 2029* 2029* 2029* 2039 2055* 2055* 2057* 2057* 2061* 2061* 2068* 2068* 2077* 2081* 2081* 2085* 2093* 2097* 2103* 2243 2254 2610 2742 2751 2823 2964 3002 3250 3281 3349 3423 3496 3516 3650 3664 3763 3773 3870 3917 3931* 3956* 3957 3960 4133 4205 active_fnc_err_ 000164 constant entry external dcl 386 ref 3957 addr builtin function dcl 411 ref 461 463 553 563 576 605 621 625 720 720 835 835 984 984 1675 1675 1826 1831 1831 2160 2160 2705 3242 3242 3409 3409 3595 3595 3708 3708 3739 3844 3844 4056 4056 4071 4075 al 000111 automatic fixed bin(21,0) dcl 121 set ref 419* 420 420 420 421 421 421 422 422 423 423 424 424 424 425 425 425 426 426 427 427 428 428 429 430 431 431 432 432 433 433 435 435 437 437 437 442 442 462* 465 465 466 554* 555 555 564* 565 565 577* 578 578 579 579 606* 607 607 608 608 622* 626* 669 669 671 776 779 779 780 780 793 975* 976 976 978 978 1076 1076 1077 1077 1350 1350 1634 1634 1635 1635 1758* 1759 1768* 1769 1769 1769 1769 1769 1769 1769 1769 1774 1774 1776 2115 2115 2116 2116 2412 2412 2452* 2453 2454 2628* 2629 2631* 2632 2632 2634 2636 2640 2640 2640 2644 2644 2648 2648 2648 2652 2652 2653 2653 2657 2657 2662 2662 2666 2666 2667 2667 2668 2668 2669 2669 2670 2670 2670 2671 2672 2672 2673 2673 2673 2674 2674 2675 2675 2676 2676 2688 2770 2770 2770 2770 2770 2770 2770 2770 3026* 3027 3028 3028 3084* 3085 3085 3092 3092 3097 3097 3103 3103 3110 3117 3117 3123 3123 3129 3129 3134 3134 3139 3139 3144 3144 3151 3151 3157 3162 3162 3162 3167 3167 3167 3172 3175* 3176 3176 3178 3181 3181 3194 3200 3200 3400* 3401 3401 3403 3403 3798 3798 3965* 3966 3966 3967 3967 3995 3995 3996 3996 4201* al1 parameter fixed bin(21,0) dcl 2408 set ref 2403 2416* ala 000112 automatic fixed bin(21,0) dcl 122 set ref 464* 781 1078 3031* all 0(09) based bit(1) level 2 packed packed unaligned dcl 3056 ref 3140 all_states 000113 automatic bit(1) packed unaligned dcl 123 set ref 2638* 2642* 2646* 2650* 2673* 3953* all_sw 000114 automatic bit(1) packed unaligned dcl 124 set ref 3141* 3414 3415 3490 3950* alloc 0(11) based bit(1) level 2 packed packed unaligned dcl 3056 ref 3163 alloc_sw 000115 automatic bit(1) packed unaligned dcl 125 set ref 2641* 2697 2697* 3164* 3950* 4067 allocated_state constant fixed bin(17,0) initial dcl 278 ref 456 495 517 780 789 875 1202 1270 1286 1635 2174 2509 2641 3299 3418 3718 3729 3908 4067 4071 4141 4149 alp 000116 automatic pointer dcl 126 set ref 419* 975* 1758* 1768* 2416* 2452* 2628* 2631* 3026* 3031* 3084* 3175* 3400* 3954* 3965* 4201* already_alloc constant bit(16) initial packed unaligned dcl 298 ref 857 1203 already_free constant bit(16) initial packed unaligned dcl 298 ref 1278 2226 already_printed 51(03) based bit(1) array level 4 in structure "volume_pool" packed packed unaligned dcl 268 in procedure "manage_volume_pool_" set ref 1515* already_printed 50(03) based bit(1) array level 4 in structure "volume_pool_2" packed packed unaligned dcl 1458 in procedure "convert_volume_pool" ref 1515 already_reg 001377 constant bit(16) initial packed unaligned dcl 298 set ref 728* 1172 already_sec_vol constant bit(16) initial packed unaligned dcl 298 ref 1002 1182 3747 ap 000120 automatic pointer dcl 127 set ref 419* 420 420 420 421 421 421 422 422 423 423 424 424 424 425 425 425 426 426 427 427 428 428 429 430 431 431 432 432 433 433 435 435 437 437 437 442 461* 465 466 553* 555 563* 565 576* 578 579 605* 607 608 621* 625* 669 671 776 779 780 793 975* 976 976 978 1076 1077 1350 1634 1635 1758* 1759 1768* 1769 1769 1769 1769 1769 1769 1769 1769 1774 1776 2115 2116 2412 2452* 2453 2454 2628* 2629 2631* 2632 2634 2636 2640 2640 2640 2644 2644 2648 2648 2648 2652 2652 2653 2653 2657 2657 2662 2662 2666 2666 2667 2667 2668 2668 2669 2669 2670 2670 2670 2671 2672 2672 2673 2673 2673 2674 2674 2675 2675 2676 2676 2688 2770 2770 2770 2770 2770 2770 2770 2770 3026* 3027 3028 3084* 3085 3085 3092 3092 3097 3097 3103 3103 3110 3117 3117 3123 3123 3129 3129 3134 3134 3139 3139 3144 3144 3151 3151 3157 3162 3162 3162 3167 3167 3167 3172 3175* 3176 3178 3181 3181 3194 3200 3400* 3401 3401 3403 3798 3965* 3966 3967 3967 3995 3996 4201* ap1 parameter pointer dcl 2408 set ref 2403 2416* apa 000122 automatic pointer dcl 128 set ref 463* 781 1078 3031* aptr parameter pointer dcl 2484 in procedure "get_volumes_specified" ref 2467 2535 2536 2537 2542 2543 2544 aptr parameter pointer dcl 1141 in procedure "check_for_errors" ref 1120 1146 1147 1150 1152 1154 1159 1162 1163 1165 1173 1175 1183 1185 1194 1196 1204 1206 1211 1213 1219 1221 1230 1235 1239 1246 1255 1257 1263 1265 1271 1273 1279 1281 1287 1289 1297 aptr parameter pointer dcl 1810 in procedure "evaluate_volumes_wanted" ref 1796 1840 1842 aptr parameter pointer dcl 2331 in procedure "get_list_names" ref 2312 2340 2341 2342 2352 2353 2354 areap 000124 automatic pointer dcl 129 set ref 490* 491 850 994 1684 1696 1876 1877 2170 2196 2604 2684 2724 3190 3435 3607 3615 3626 3716 3725 3928* 3971* 4083 4090 4102 arg based char packed unaligned dcl 130 in procedure "manage_volume_pool_" set ref 420 420 420 421 421 421 422 422 423 423 424 424 424 425 425 425 426 426 427 427 428 428 429 430 431 431 432 432 433 433 435 435 437 437 437 442* 465* 466 555* 565* 578* 579* 607* 608* 669* 671 776 779* 780* 793 976 976 978* 1076* 1077* 1350* 1634* 1635* 1759 1769 1769 1769 1769 1769 1769 1769 1769 1774* 1776 2115* 2116* 2412* 2453 2454 2629 2632* 2634 2636 2640 2640 2640 2644 2644 2648 2648 2648 2652 2652 2653 2653 2657 2657 2662 2662 2666 2666 2667 2667 2668 2668 2669 2669 2670 2670 2670 2671 2672 2672 2673 2673 2673 2674 2674 2675 2675 2676 2676 2688 2770 2770 2770 2770 2770 2770 2770 2770 3027 3028* 3085 3085 3092 3092 3097 3097 3103 3103 3110 3117 3117 3123 3123 3129 3129 3134 3134 3139 3139 3144 3144 3151 3151 3157 3162 3162 3162 3167 3167 3167 3172 3176* 3178 3181 3181 3194 3200* 3401 3401 3403* 3798* 3966* 3967 3967 3995* 3996* arg parameter char packed unaligned dcl 1056 in procedure "bad_arg" ref 1052 1064 arg2 based char packed unaligned dcl 131 ref 781 1078 arg_fb 004220 automatic fixed bin(17,0) dcl 2448 set ref 2454* 2454 2455 2456 argp 000100 automatic pointer dcl 644 in procedure "abort" set ref 654* 656* argp 000200 automatic pointer dcl 2812 in procedure "msg" set ref 2821* 2822* args_allowed 000005 constant structure level 1 packed packed unaligned dcl 3217 in procedure "pv_expire_key" set ref 3242 3242 args_allowed 000000 constant structure level 1 packed packed unaligned dcl 695 in procedure "add_key" set ref 720 720 args_allowed 000003 constant structure level 1 packed packed unaligned dcl 1652 in procedure "delete_key" set ref 1675 1675 args_allowed based structure level 1 packed packed unaligned dcl 3056 in procedure "process_ctl_args" args_allowed 000002 constant structure level 1 packed packed unaligned dcl 948 in procedure "append_volume_set" set ref 984 984 args_allowed 000004 constant structure level 1 packed packed unaligned dcl 2135 in procedure "free_key" set ref 2160 2160 args_allowed 000010 constant structure level 1 packed packed unaligned dcl 3685 in procedure "reuse" set ref 3708 3708 args_allowed 000012 constant structure level 1 packed packed unaligned dcl 4031 in procedure "test_key" set ref 4056 4056 args_allowed 000007 constant structure level 1 packed packed unaligned dcl 3567 in procedure "reserve_key" set ref 3595 3595 args_allowed 000006 constant structure level 1 packed packed unaligned dcl 3373 in procedure "remove_volume_set" set ref 3409 3409 args_allowed 000011 constant structure level 1 packed packed unaligned dcl 3819 in procedure "set_key" set ref 3844 3844 args_allowed 000001 constant structure level 1 packed packed unaligned dcl 810 in procedure "allocate_key" set ref 835 835 ascii_state 001401 constant char(5) initial array packed unaligned dcl 278 set ref 1908* 1926* 1950* 1980* 2021* 2055* asize parameter fixed bin(17,0) dcl 1810 in procedure "evaluate_volumes_wanted" ref 1796 1836 1840 1840 1840 1842 1842 asize parameter fixed bin(17,0) dcl 1139 in procedure "check_for_errors" ref 1120 1146 1146 1146 1146 1146 1146 1146 1147 1147 1147 1147 1147 1152 1152 1159 1163 1163 1173 1173 1183 1183 1194 1194 1204 1204 1211 1211 1219 1219 1230 1230 1235 1235 1255 1255 1263 1263 1271 1271 1279 1279 1287 1287 1297 1297 asize parameter fixed bin(17,0) dcl 2483 in procedure "get_volumes_specified" set ref 2467 2494 2501 2513 2520* 2535 2537 2537 2537 2543 2544 2544 2544 asize parameter fixed bin(17,0) dcl 2330 in procedure "get_list_names" ref 2312 2337 2341 2342 2342 2342 2348 2353 2354 2354 2354 asterisk 0(15) based bit(1) level 2 packed packed unaligned dcl 3056 ref 3111 asterisk_cnt 000126 automatic fixed bin(17,0) dcl 132 set ref 1683 3079* 3114* 3114 3606 4082 asterisk_sw 000127 automatic bit(1) packed unaligned dcl 133 set ref 1676 1678 1692 3112* 3597 3605 3622 3655 3949* 4058 4081 4098 based_area based area(1024) dcl 134 ref 491 850 994 1684 1696 1876 1877 2170 2196 2604 2684 2724 3190 3435 3607 3615 3626 3716 3725 4083 4090 4102 begin_arg parameter fixed bin(17,0) dcl 3051 ref 3042 3083 bit_count 000130 automatic fixed bin(24,0) dcl 135 set ref 1865* 1866* blank_NL constant char(2) initial packed unaligned dcl 278 ref 2962 brief 0(06) based bit(1) level 2 packed packed unaligned dcl 3056 ref 3130 brief_sw 000131 automatic bit(1) packed unaligned dcl 136 set ref 1228* 1236 1380 2177* 2201* 2247 2532* 3131* 3422 3508* 3734* 3739 3764 3950* cant_delete constant bit(16) initial packed unaligned dcl 298 ref 1210 1689 cant_pvexp constant bit(16) initial packed unaligned dcl 298 ref 1218 check 003633 automatic bit(16) packed unaligned dcl 1364 in procedure "construct_msg" set ref 1368* 1369 1389* 1390 check parameter bit(16) packed unaligned dcl 1130 in procedure "check_for_errors" ref 1120 1151 1161 1172 1181 1182 1192 1203 1210 1218 1226 1254 1262 1270 1278 1286 1294 check_pvexp 001375 constant bit(16) initial packed unaligned dcl 298 set ref 857 1002 1294 1689 2190* 2212* 2226 2507* 3246 3495* 3619 3741* 3747 3867 4095 cleanup 003426 stack reference condition dcl 351 ref 418 460 481 552 562 575 586 604 624 636 clock builtin function dcl 411 ref 1227 1326 2176 2388 2563 2896 2950 3303 3420 3453 3524 3733 clock_ 000072 constant entry external dcl 355 ref 1570 cnt 101 001204 automatic fixed bin(17,0) array level 2 dcl 218 set ref 1155* 1155 1166* 1166 1176* 1176 1186* 1186 1197* 1197 1207* 1207 1214* 1214 1222* 1222 1240* 1240 1247* 1247 1258* 1258 1266* 1266 1274* 1274 1282* 1282 1290* 1290 1329* 1329 1333* 1333 1371 1375 1375 1375 1381 1381 1385 1385 2715* 2715 3948* code 004406 automatic fixed bin(35,0) dcl 2766 in procedure "lock_required" set ref 2769* 2773* 2774 2774* code 000132 automatic fixed bin(35,0) dcl 137 in procedure "manage_volume_pool_" set ref 637* 638 638* 724* 725 725* 841* 842 842* 1464* 1468* 1472* 1475 1476 1476 1476* 1481* 1482 1482* 1568* 1569 1571* 1596* 1598 1598* 1610* 1611 1623* 1866* 1867 1867* 1868* 1869 1869* 2631* 2632 2632* 2790* 2791 2793 2793* 2794 2794* 2795* 2798 3031* 3032 3032* 3175* 3176 3176* 3546* 3547 3853* 3854 3854* 3858* 3859 3859* 3863* 3864 3864* 3930* 3955* 3956 3995* 3996 3996* 4006* 4007 4007* 4009* 4201* com_err_ 000166 constant entry external dcl 386 ref 3958 com_len 000133 automatic fixed bin(21,0) dcl 138 set ref 876 3126* 3653 3912 com_ptr 000134 automatic pointer dcl 139 set ref 876 3126* 3653 3912 command_query_$yes_no 000074 constant entry external dcl 355 ref 1108 4277 4281 comment 30 based char(64) array level 3 in structure "volume_pool_2" dcl 1458 in procedure "convert_volume_pool" ref 1501 comment 27 based char(64) array level 3 in structure "volume_pool_old" dcl 1401 in procedure "convert_volume_pool" ref 1575 comment 0(04) based bit(1) level 2 in structure "args_allowed" packed packed unaligned dcl 3056 in procedure "process_ctl_args" ref 3124 comment 31 based char(64) array level 3 in structure "volume_pool" dcl 268 in procedure "manage_volume_pool_" set ref 497 519 610 673* 750* 781* 876* 877* 1078* 1351 1352* 1501* 1534* 1575* 1908* 1926* 1950* 2003* 2039* 2040* 2068* 2085* 2097* 2103* 2200 2217 2392 2954 3517* 3653* 3654* 3729 3912* comment 26 based char(64) array level 3 in structure "volume_pool_old_1" dcl 1413 in procedure "convert_volume_pool" ref 1534 comment_str based char packed unaligned dcl 140 ref 876 3653 3912 comment_sw 000136 automatic bit(1) packed unaligned dcl 141 set ref 876 1968* 1975 2003 2038 2068 2085 2097 2102 2669* 2692 2702 2703 3125* 3653 3847 3912 3950* compare 000137 automatic char(64) packed unaligned dcl 142 set ref 2392* 2393 2393 2954* 2955 2955 continue parameter bit(1) packed unaligned dcl 3345 in procedure "query_to_continue" set ref 3337 3348* 3349* 3350* continue 004103 automatic bit(1) packed unaligned dcl 1823 in procedure "evaluate_volumes_wanted" set ref 1835* 1850* 1853 continue 004232 automatic bit(1) packed unaligned dcl 2485 in procedure "get_volumes_specified" set ref 2515* 2519* 2520 convert builtin function dcl 411 ref 2454 2742 convert_date_to_binary_ 000076 constant entry external dcl 355 ref 724 841 1568 3853 3858 3863 cu_$af_arg_ptr_rel 000100 constant entry external dcl 355 ref 3960 cu_$af_return_arg 000102 constant entry external dcl 355 ref 3955 cu_$arg_list_ptr 000104 constant entry external dcl 355 ref 654 2821 3954 cu_$arg_ptr_rel 000106 constant entry external dcl 355 ref 3961 current_idx 004537 automatic fixed bin(17,0) dcl 3362 set ref 3473* 3474* 3477 3480 3484 3485* 3485 3491* 3508* 3513 3516 3517 3518 3519 3520 3521 3523 3524 3525* 3527 3528 3529* 3529 currentsize builtin function dcl 411 ref 1864 date_time_ 000110 constant entry external dcl 355 ref 4166 dfmt_sw 000157 automatic bit(1) packed unaligned dcl 143 set ref 1902 1916 1942 1966 2614* 2674* 2692 2692* 2702* 2703* 3950* dirname parameter char packed unaligned dcl 2919 set ref 2915 2922* 2922 done 004532 automatic bit(1) packed unaligned dcl 3361 set ref 3475* 3476 3477* ecode 000160 automatic fixed bin(35,0) dcl 144 set ref 3930* 4178* 4179 4180 4180* 4181* 4184 edt_sw 000161 automatic bit(1) packed unaligned dcl 145 set ref 1902 1916 1916 1919* 1926 1926 1926 1926 1942 1968* 1975 1983 1992 1992 1992 1992 2003 2003 2003 2003 2003 2003 2003 2003 2003 2023 2029 2029 2029 2029 2040 2040 2040 2040 2040 2040 2057 2061* 2068 2068* 2076 2667* 2692 2692* 2702 3950* ename parameter char packed unaligned dcl 2920 set ref 2915 2922* err parameter fixed bin(35,0) dcl 645 in procedure "abort" set ref 643 651 652 658* err parameter fixed bin(35,0) dcl 2810 in procedure "msg" set ref 2803 2816 2816 2817 2823 2823 2823 2825* err_msg 000567 constant varying char(100) initial array dcl 333 set ref 1371* 1375* 1381* 1385* error_found 003610 automatic bit(16) packed unaligned dcl 1131 set ref 1144* 1153* 1164* 1174* 1184* 1195* 1205* 1212* 1220* 1238* 1245* 1256* 1264* 1272* 1280* 1288* 1298* 1305* error_rnt 003444 automatic entry variable dcl 392 set ref 658 2825 3937* 3957* 3958* error_table_$action_not_performed 000200 external static fixed bin(35,0) dcl 397 set ref 537 651 736* 738* 862* 864* 976* 978* 1006* 1008* 1105* 1712* 1714* 2188* 2210* 2219* 2230* 2232* 2455* 2816 3254* 3256* 3401* 3403* 3423* 3427* 3464* 3466* 3637* 3639* 3739* 3751* 3753* 3874* error_table_$badopt 000202 external static fixed bin(35,0) dcl 397 set ref 442* 3200* error_table_$boundviol 000204 external static fixed bin(35,0) dcl 397 ref 483 error_table_$inconsistent 000206 external static fixed bin(35,0) dcl 397 set ref 837* 986* 2162* 2692* 2697* 3414* 3415* 3597* 3602* 3710* 3848* 4058* 4063* 4071* error_table_$invalid_lock_reset 000210 external static fixed bin(35,0) dcl 397 ref 1476 2793 error_table_$lock_not_locked 000214 external static fixed bin(35,0) dcl 397 ref 4180 error_table_$locked_by_this_process 000212 external static fixed bin(35,0) dcl 397 ref 1476 2794 error_table_$noarg 000216 external static fixed bin(35,0) dcl 397 set ref 716* 969* 1673* 1754* 2156* 2412* 3023* 3027* 3238* 3244* 3394* 3590* 3840* 4054* error_table_$process_unknown 000220 external static fixed bin(35,0) dcl 397 ref 3547 error_table_$unimplemented_version 000222 external static fixed bin(35,0) dcl 397 set ref 1113* even_arg 004070 automatic bit(1) packed unaligned dcl 1752 set ref 1766* 1773 1777* 1777 exp_clock 004636 automatic fixed bin(71,0) dcl 3813 in procedure "set_key" set ref 3858* 3910 exp_clock 003526 automatic fixed bin(71,0) dcl 804 in procedure "allocate_key" set ref 833* 841* 878 exp_dt 0(16) based bit(1) level 2 packed packed unaligned dcl 3056 ref 3088 expand_pathname_ 000112 constant entry external dcl 355 ref 3995 expire 51(02) based bit(1) array level 4 in structure "volume_pool" packed packed unaligned dcl 268 in procedure "manage_volume_pool_" set ref 879* 1226 1504* 1514* 1537* 1578* 1926 1926 1950 1950 1983* 2023* 2057* 2077* 2118* 2175 2245* 2387 2949 3420 3519* 3733 3909* expire 0(05) based bit(1) level 2 in structure "args_allowed" packed packed unaligned dcl 3056 in procedure "process_ctl_args" ref 3086 expire 50(02) based bit(1) array level 4 in structure "volume_pool_2" packed packed unaligned dcl 1458 in procedure "convert_volume_pool" ref 1504 1514 expire_date 54 based fixed bin(71,0) array level 3 in structure "volume_pool_2" dcl 1458 in procedure "convert_volume_pool" ref 1506 expire_date 26 based fixed bin(71,0) array level 3 in structure "volume_pool" dcl 268 in procedure "manage_volume_pool_" set ref 675* 754* 878* 1227 1506* 1538* 1579* 1926* 1950* 1983* 1983* 2023* 2023* 2057* 2057* 2077* 2077* 2176 2388 2950 3420 3423* 3423* 3427* 3427* 3520* 3733 3910* expire_len 000162 automatic fixed bin(21,0) dcl 146 set ref 841 841 842 842 3088* 3858 3858 3859 3859 expire_ptr 000164 automatic pointer dcl 147 set ref 841 842 3088* 3858 3859 expire_str based char packed unaligned dcl 148 set ref 841* 842* 3858* 3859* expire_sw 000166 automatic bit(1) packed unaligned dcl 149 set ref 840 879 1286 2162 2162* 2167 2247 2385 2652* 2697 2697* 2947 3087* 3847 3857 3908 3950* fb_already_alloc constant fixed bin(17,0) initial packed unaligned dcl 315 ref 1205 1206 1206 1207 1207 fb_already_free constant fixed bin(17,0) initial packed unaligned dcl 315 ref 1280 1281 1281 1282 1282 fb_already_reg constant fixed bin(17,0) initial packed unaligned dcl 315 ref 1174 1175 1175 1176 1176 fb_already_sec_vol constant fixed bin(17,0) initial packed unaligned dcl 315 ref 1184 1185 1185 1186 1186 1375 fb_cant_delete constant fixed bin(17,0) initial packed unaligned dcl 315 ref 1212 1213 1213 1214 1214 fb_cant_pvexp constant fixed bin(17,0) initial packed unaligned dcl 315 ref 1220 1221 1221 1222 1222 fb_check_pvexp constant fixed bin(17,0) initial packed unaligned dcl 315 ref 1298 1328 1328 1329 1329 1332 1332 1333 1333 1380 fb_not_alloc constant fixed bin(17,0) initial packed unaligned dcl 315 ref 1272 1273 1273 1274 1274 fb_not_exp constant fixed bin(17,0) initial packed unaligned dcl 315 ref 1238 1239 1239 1240 1240 1245 1246 1246 1247 1247 1380 fb_not_free constant fixed bin(17,0) initial packed unaligned dcl 315 ref 1264 1265 1265 1266 1266 fb_not_reg constant fixed bin(17,0) initial packed unaligned dcl 315 ref 1153 1154 1154 1155 1155 2714 2714 2715 2715 fb_not_updated constant fixed bin(17,0) initial packed unaligned dcl 315 ref 1288 1289 1289 1290 1290 3869 fb_prim_name constant fixed bin(17,0) initial packed unaligned dcl 315 ref 1167 1187 1371 1375 fb_rsv_by_another constant fixed bin(17,0) initial packed unaligned dcl 315 ref 1195 1196 1196 1197 1197 fb_sec_not_found constant fixed bin(17,0) initial packed unaligned dcl 315 ref 1164 1165 1165 1166 1166 1371 fb_vol_pvexp constant fixed bin(17,0) initial packed unaligned dcl 315 ref 1256 1257 1257 1258 1258 fetch parameter bit(1) packed unaligned dcl 3021 ref 3017 3029 fexp 0(07) based bit(1) level 2 packed packed unaligned dcl 3056 ref 3135 fexp_sw 000171 automatic bit(1) packed unaligned dcl 152 set ref 1227 2176 3136* 3418 3733 3950* first based bit(1) level 2 packed packed unaligned dcl 3056 ref 3098 first_last_sw 000170 automatic bit(1) packed unaligned dcl 151 set ref 837 881 986 1027 2247 2654* 2658* 2692 2697 2721 3099* 3105* 3597 3602 3655 3710 3713 3764 3950* 4058 4063 first_sw 000167 automatic bit(1) packed unaligned dcl 150 set ref 2654* 2692* 2697* 3099* 3950* force parameter bit(1) packed unaligned dcl 3345 in procedure "query_to_continue" ref 3337 3348 force 0(02) based bit(1) level 2 in structure "args_allowed" packed packed unaligned dcl 3056 in procedure "process_ctl_args" ref 3093 force_sw 000172 automatic bit(1) packed unaligned dcl 153 set ref 1850* 2519* 3094* 3950* 4078* found 004534 automatic bit(1) packed unaligned dcl 3361 in procedure "remove_volume_set" set ref 3478* 3479 3480* 3482 found 004132 automatic bit(1) packed unaligned dcl 2129 in procedure "free_key" set ref 2215* 2217* 2219 free 0(13) based bit(1) level 2 packed packed unaligned dcl 3056 ref 3158 free_head 6 based fixed bin(17,0) level 3 in structure "volume_pool_2" dcl 1458 in procedure "convert_volume_pool" ref 1493 free_head 6 based fixed bin(17,0) level 3 in structure "volume_pool" dcl 268 in procedure "manage_volume_pool_" set ref 1493* 1527* 1551* 1558* 1615* 2279* 2301 2303* 2429 2430* 2430 2431 2432* 2433 2434 2435 free_state constant fixed bin(17,0) initial dcl 278 ref 592 672 749 848 992 1077 1262 1278 1680 2116 2117 2244 2509 2531 2637 3412 3523 3592 3793 4066 4071 4075 4141 4149 free_sw 000173 automatic bit(1) packed unaligned dcl 154 set ref 2637* 2697 2697* 3159* 3949* 3950* 4066 get_area 004460 automatic bit(1) packed unaligned dcl 3052 in procedure "process_ctl_args" set ref 3080* 3187 3188* get_area 004372 automatic bit(1) packed unaligned dcl 2599 in procedure "list_key" set ref 2626* 2681 2682* get_arg 003434 automatic entry variable dcl 355 set ref 419 975 1758 1768 2416 2452 2628 2631 3026 3031 3084 3175 3400 3960* 3961* 3965 4201 get_process_id_ 000114 constant entry external dcl 355 ref 784 3545 3652 get_ring_ 000116 constant entry external dcl 355 ref 2773 get_system_free_area_ 000120 constant entry external dcl 355 ref 490 3971 get_temp_segment_ 000122 constant entry external dcl 355 ref 1481 go_ahead 004114 automatic bit(1) packed unaligned dcl 1891 set ref 1893* 1898* 1923* 1947* 1977 1980 1983 1992 2003 2020 2021 2023 2029 2038 2055 2057 2061 2068 2077 2081 2085 2092 2097 2102 have_pool_path parameter bit(1) packed unaligned dcl 3992 ref 3979 3994 hbound builtin function dcl 411 ref 1063 hcs_$fs_get_path_name 000126 constant entry external dcl 355 ref 637 hcs_$fs_move_seg 000124 constant entry external dcl 355 ref 1596 hcs_$get_user_effmode 000130 constant entry external dcl 355 ref 2773 hcs_$make_seg 000132 constant entry external dcl 355 ref 1610 hcs_$set_bc 000134 constant entry external dcl 355 ref 1866 hcs_$terminate_noname 000136 constant entry external dcl 355 ref 1875 hcs_$truncate_file 000140 constant entry external dcl 355 ref 1868 hcs_$validate_processid 000142 constant entry external dcl 355 ref 3546 head 4 based fixed bin(17,0) level 3 in structure "volume_pool" dcl 268 in procedure "manage_volume_pool_" set ref 493 587 1022 1022* 1490* 1524* 1548* 1559* 1618* 2274 2280* 2290 2291* 2292 2336 2493 2564 2565 2565 2567* 2608 2734 2843 2846 2847* 2859 2870 2871 2875* 2897 2904 2905 2906* 4222 head 4 based fixed bin(17,0) level 3 in structure "volume_pool_2" dcl 1458 in procedure "convert_volume_pool" ref 1490 header based structure level 2 in structure "volume_pool_2" dcl 1458 in procedure "convert_volume_pool" header based structure level 2 in structure "volume_pool" dcl 268 in procedure "manage_volume_pool_" header_len 000275 automatic fixed bin(17,0) dcl 156 set ref 1904* 1919* 1944* 1968* header_output 000174 automatic varying char(256) dcl 155 set ref 1904* 1919* 1944* 1968* 2971* header_sw 000277 automatic bit(1) packed unaligned dcl 158 set ref 2672* 2675* 2678* 2692 2692* 2970 2972* 3953* header_to_be_printed 000276 automatic bit(1) packed unaligned dcl 157 set ref 1903 1905* 1918 1921* 1943 1945* 1967 1971* 2672* 2675* 2678* 3953* i 004055 automatic fixed bin(17,0) dcl 1647 in procedure "delete_key" set ref 1698* 1699 1700 1701* 1720* 1721 1722 1723* i 004230 automatic fixed bin(17,0) dcl 2483 in procedure "get_volumes_specified" set ref 2493* 2494 2496* 2496 2500* 2501 2503* 2503 2529 2530 2531 2532* 2535 2536 2542 2543 i 003554 automatic fixed bin(17,0) dcl 939 in procedure "append_volume_set" set ref 1014* 1015 1016 1017 1018* i 003611 automatic fixed bin(17,0) dcl 1139 in procedure "check_for_errors" set ref 1149* 1150 1152 1154 1159 1162 1163 1165 1173 1175 1183 1185 1194 1196 1204 1206 1211 1213 1219 1221 1230 1235 1239 1246 1255 1257 1263 1265 1271 1273 1279 1281 1287 1289 1297* i 003530 automatic fixed bin(17,0) dcl 805 in procedure "allocate_key" set ref 869* 870 871 872* i 004642 automatic fixed bin(17,0) dcl 3814 in procedure "set_key" set ref 3879* 3880 3881 3882 3896 3904* i 004471 automatic fixed bin(17,0) dcl 3212 in procedure "pv_expire_key" set ref 3261* 3262 3263 3264* i 004676 automatic fixed bin(17,0) dcl 4022 in procedure "test_key" set ref 4104* 4105 4106 4107* 4116* 4117 4117 4118 4122 4127* i 004371 automatic fixed bin(17,0) dcl 2597 in procedure "list_key" set ref 2608* 2609 2611 2616* 2618* 2618 2710* 2711 2714* 2728* 2729 2729* 2734* 2735 2736* 2737* 2737 i 004535 automatic fixed bin(17,0) dcl 3362 in procedure "remove_volume_set" set ref 3443* 3444 3445 3446* 3452* 3453 3453 3453* 3479* 3480 3480* i 000100 automatic fixed bin(17,0) dcl 4218 in procedure "volume_in_pool" set ref 4226* 4227 4228 4229 4232* 4232 i 003516 automatic fixed bin(17,0) dcl 689 in procedure "add_key" set ref 743* 744 745 748* i 004612 automatic fixed bin(17,0) dcl 3679 in procedure "reuse" set ref 3728* 3729 3729 3730 3730 3731 3731 3732 3733 3733 3733 3734* 3735* 3759* 3760 3761 3762* i 004134 automatic fixed bin(17,0) dcl 2130 in procedure "free_key" set ref 2199* 2200 2201* 2204 2205* 2216* 2217 2217* 2238* 2239 2240 2241* i 004574 automatic fixed bin(17,0) dcl 3561 in procedure "reserve_key" set ref 3628* 3629 3630 3631* 3645* 3646 3647 3648* i 004100 automatic fixed bin(17,0) dcl 1810 in procedure "evaluate_volumes_wanted" set ref 1839* 1840 1842* id 20 based bit(36) array level 3 in structure "volume_pool_old_1" dcl 1413 in procedure "convert_volume_pool" ref 1531 id 22 based bit(36) array level 3 in structure "volume_pool_2" dcl 1458 in procedure "convert_volume_pool" ref 1498 id 21 based bit(36) array level 3 in structure "volume_pool_old" dcl 1401 in procedure "convert_volume_pool" ref 1566 id 20 based bit(36) array level 3 in structure "volume_pool" dcl 268 in procedure "manage_volume_pool_" set ref 580* 1498* 1531* 1566* ignore 000300 automatic fixed bin(35,0) dcl 159 set ref 657* 1872* 1875* index builtin function dcl 411 ref 497 519 1369 1390 1826 1831 1908 1926 1950 1975 2200 2217 2393 2393 2705 2955 2955 3729 3739 4075 indx based fixed bin(17,0) array level 2 in structure "volume" dcl 229 in procedure "manage_volume_pool_" set ref 499* 506* 521* 528* 544* 872 1018 1700* 1723 2181* 2205* 2241 2729* 3264 3445* 3453 3453 3630* 3648 3731* 3762 3882 3896 3904 4106* 4118 indx based fixed bin(17,0) array level 2 in structure "tvol" dcl 222 in procedure "manage_volume_pool_" ref 1700 3630 4106 indx based fixed bin(17,0) array level 2 in structure "volume" dcl 2323 in procedure "get_list_names" set ref 2341* 2353* indx based fixed bin(17,0) array level 2 in structure "volume" dcl 1132 in procedure "check_for_errors" set ref 1159* indx based fixed bin(17,0) array level 2 in structure "volume" dcl 2476 in procedure "get_volumes_specified" set ref 2535* 2543* initiate_file_ 000144 constant entry external dcl 355 ref 4009 ioa_ 000170 constant entry external dcl 386 ref 1480 1612 2823 2971 2974 3007 ioa_$general_rs 000146 constant entry external dcl 355 ref 656 2822 ioa_$nnl 000172 constant entry external dcl 386 ref 2751 ioa_$rsnnl 000174 constant entry external dcl 386 ref 640 1371 1375 1381 1385 1904 1907 1908 1919 1923 1926 1944 1947 1950 1968 1975 1977 1980 1983 1992 2003 2020 2021 2023 2029 2039 2040 2055 2057 2061 2068 2077 2081 2085 2093 2097 2103 2516 2922 just_expired 004533 automatic bit(1) packed unaligned dcl 3361 in procedure "remove_volume_set" set ref 3494 3508* 3516 3522 just_expired 003613 automatic bit(1) packed unaligned dcl 1142 in procedure "check_for_errors" set ref 1145* 1228* 1229 1295* 1296 just_expired 004133 automatic bit(1) packed unaligned dcl 2129 in procedure "free_key" set ref 2177* 2178 2190 2201* 2202 2212 just_expired 004233 automatic bit(1) packed unaligned dcl 2485 in procedure "get_volumes_specified" set ref 2507 2532* 2533 just_expired 004615 automatic bit(1) packed unaligned dcl 3680 in procedure "reuse" set ref 3734* 3735 3741 just_expired parameter bit(1) packed unaligned dcl 1321 in procedure "check_for_pvexp" set ref 1311 1323* 1336* just_expired 004577 automatic bit(1) packed unaligned dcl 3562 in procedure "reserve_key" set ref 3593* keys 000137 constant char(32) initial array packed unaligned dcl 1058 ref 1063 1064 keyx 003572 automatic fixed bin(17,0) dcl 1057 set ref 1063* 1064* last 0(01) based bit(1) level 2 packed packed unaligned dcl 3056 ref 3104 last_sw 000301 automatic bit(1) packed unaligned dcl 160 set ref 2658* 2692* 2697* 3105* 3950* last_vol 003544 automatic fixed bin(17,0) dcl 906 in procedure "append_secondary_volumes" set ref 913* 916 917 918 918 922* 926 927 928 928 929 last_vol 003556 automatic fixed bin(17,0) dcl 939 in procedure "append_volume_set" set ref 1013* 1019 1030* 1031* 1037 last_volume_idx parameter fixed bin(17,0) dcl 906 set ref 898 929* length builtin function dcl 411 ref 462 464 554 564 577 606 622 626 2965 2965 3003 3003 list_cnt 004673 automatic fixed bin(17,0) dcl 4022 set ref 4114* 4123* 4123 4141 4141 list_no_cnt 004674 automatic fixed bin(17,0) dcl 4022 set ref 4114* 4128* 4128 4149 4149 listed_flag based bit(1) array packed unaligned dcl 161 set ref 2375 2604 2605* 2937 2995* 3000* lock 1 based bit(36) level 3 in structure "volume_pool" dcl 268 in procedure "manage_volume_pool_" set ref 657* 1872* 2790* 4178* lock 1 based bit(36) level 2 in structure "volume_pool_old_1" dcl 1413 in procedure "convert_volume_pool" set ref 1468* lock based bit(36) level 2 in structure "volume_pool_old" dcl 1401 in procedure "convert_volume_pool" set ref 1472* lock 1 based bit(36) level 3 in structure "volume_pool_2" dcl 1458 in procedure "convert_volume_pool" set ref 1464* lock 000302 automatic bit(1) packed unaligned dcl 162 in procedure "manage_volume_pool_" set ref 657 1862 2789* 2798* 2818 3929* 4184* lock_interval 001400 constant fixed bin(17,0) initial dcl 278 set ref 1464* 1468* 1472* 2790* match 0(08) based bit(1) level 2 packed packed unaligned dcl 3056 ref 3173 match_string 000303 automatic varying char(64) dcl 163 set ref 2200 2210* 2217 2219* 2393 2393 2634* 2955 2955 3178* 3729 3739* match_sw 000324 automatic bit(1) packed unaligned dcl 164 set ref 488* 489* 496 518 2162 2162* 2193 2247 2391 2633* 2697 2697* 2953 3177* 3710 3710* 3722 3764 3949* max builtin function dcl 411 ref 3434 3489 mod builtin function dcl 411 ref 1763 mode 004407 automatic fixed bin(5,0) dcl 2767 set ref 2773* 2775 2775 most_recent parameter bit(1) packed unaligned dcl 2332 in procedure "get_list_names" ref 2312 2334 most_recent parameter bit(1) packed unaligned dcl 2485 in procedure "get_volumes_specified" ref 2467 2492 most_recent 000325 automatic bit(1) packed unaligned dcl 165 in procedure "manage_volume_pool_" set ref 837* 852* 996* 1686* 2603* 2654* 2659* 2726* 3081* 3099* 3106* 3113* 3602* 3609* 3616* 3710* 3719* 3949* 4063* 4085* 4091* msg parameter char packed unaligned dcl 4271 in procedure "yes_to_query" set ref 4266 4277 4281* msg 004234 automatic char(256) packed unaligned dcl 2488 in procedure "get_volumes_specified" set ref 2516* 2519* msg parameter char packed unaligned dcl 3346 in procedure "query_to_continue" set ref 3337 3350* msg_len 004334 automatic fixed bin(17,0) dcl 2489 set ref 2516* msg_proc 003450 automatic entry variable dcl 392 set ref 440 763 793 888 891 1041 1045 1352 1571 1613 1679 1731 2255 2258 2744 2745 2750 3282 3496 3600 3665 3668 3774 3918 3933* 4061 4139 4141 4149 myname 000326 automatic char(32) packed unaligned dcl 166 set ref 658* 1481* 1600* 1612* 2823* 2825* 3774* 3936* 3959* 4141* 4149* n_vol 10 based fixed bin(17,0) level 2 in structure "volume_pool_old" dcl 1401 in procedure "convert_volume_pool" ref 1549 1550 1551 1553 n_vol 2 based fixed bin(17,0) level 3 in structure "volume_pool" dcl 268 in procedure "manage_volume_pool_" set ref 1494* 1527* 1551* 1555* 1560 1561 1589 1590 1591 1615* 1616 1617 1864 2169 2173 2195 2199 2276* 2281 2282 2432 2432* 2604 2605 2722 3724 n_vol 2 based fixed bin(17,0) level 3 in structure "volume_pool_2" dcl 1458 in procedure "convert_volume_pool" ref 1494 1496 n_vol 2 based fixed bin(17,0) level 2 in structure "volume_pool_old_1" dcl 1413 in procedure "convert_volume_pool" ref 1525 1526 1527 name 10 based char(32) array level 3 in structure "volume_pool" dcl 268 in procedure "manage_volume_pool_" set ref 470 500 507 522 529 671* 748* 792 793* 880 881 915 978* 1028 1167 1187 1328 1332 1497* 1530* 1565* 1571* 1907* 1908* 1908 1923* 1926* 1926 1947* 1950* 1950 1975* 1975 2180 2204 2243 2247 2340 2352 2536 2542 2611 3403* 3423* 3427* 3444 3464* 3480 3516 3650 3656 3730 3763 3766 4224 4228 4256 name based char(32) array level 2 in structure "volume" dcl 229 in procedure "manage_volume_pool_" set ref 500* 507* 522* 529* 543 748 1017 1699* 2180* 2204* 2688* 2711 2714 3194* 3444* 3480 3629* 3730* 4105* 4122 4127 name based char(32) array level 2 in structure "tvol" dcl 222 in procedure "manage_volume_pool_" ref 1699 3629 4105 name based char(32) array level 2 in structure "volume" dcl 2476 in procedure "get_volumes_specified" set ref 2536* 2542* name based char(32) array level 2 in structure "volume" dcl 1132 in procedure "check_for_errors" ref 1150 1154 1162 1165 1175 1185 1196 1206 1213 1221 1239 1246 1257 1265 1273 1281 1289 name 12 based char(32) array level 3 in structure "volume_pool_2" dcl 1458 in procedure "convert_volume_pool" ref 1497 name based char(32) array level 2 in structure "volume" dcl 2323 in procedure "get_list_names" set ref 2340* 2352* name 11 based char(32) array level 3 in structure "volume_pool_old" dcl 1401 in procedure "convert_volume_pool" ref 1565 name 10 based char(32) array level 3 in structure "volume_pool_old_1" dcl 1413 in procedure "convert_volume_pool" ref 1530 name 001204 automatic varying char(256) array level 2 in structure "vol_list" dcl 218 in procedure "manage_volume_pool_" set ref 1154* 1154 1165* 1165 1167* 1175* 1175 1185* 1185 1187* 1196* 1196 1206* 1206 1213* 1213 1221* 1221 1239* 1239 1246* 1246 1257* 1257 1265* 1265 1273* 1273 1281* 1281 1289* 1289 1328* 1328 1332* 1332 1371* 1371* 1375* 1375* 1381* 1385* 2714* 2714 3869 3947* name parameter char packed unaligned dcl 3787 in procedure "search" ref 3783 3790 name_sw 000336 automatic bit(1) packed unaligned dcl 167 set ref 1968* 1974 2666* 2692 2692* 2702 2703 3950* narg 000337 automatic fixed bin(17,0) initial dcl 168 set ref 168* 716 969 1005* 1673 1754 1763 1767 2156 2229* 2411 2450 2607 2627 2683 3023 3025 3083 3189 3238 3394 3590 3840 3955* 3963 4054 4195 4196 new_primary_idx parameter fixed bin(17,0) dcl 906 ref 898 919 921 921 new_vpp 000340 automatic pointer dcl 169 set ref 1481* 1485 1486 1490 1491 1492 1493 1494 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1512 1513 1514 1515 1516 1524 1525 1526 1527 1527 1529 1530 1531 1532 1533 1534 1535 1536 1537 1537 1538 1538 1539 1540 1541 1542 1543 1548 1549 1550 1551 1551 1555 1556 1557 1558 1559 1560 1560 1561 1561 1564 1565 1566 1567 1568 1570 1571 1575 1576 1577 1578 1578 1579 1579 1580 1581 1582 1583 1584 1589 1589 1590 1590 1591 1591 1592 1594 1594 1596* 1600* next 57 based fixed bin(17,0) array level 3 in structure "volume_pool_2" dcl 1458 in procedure "convert_volume_pool" ref 1509 next 53 based fixed bin(17,0) array level 3 in structure "volume_pool" dcl 268 in procedure "manage_volume_pool_" set ref 510 597 918* 928* 1022 1023* 1023 1025 1025 1026* 1509* 1541* 1560* 1582* 1589* 1594* 1616* 2281* 2288* 2288 2291 2295* 2295 2296 2301* 2344 2430 2433* 2496 2564* 2618 2737 2847 2848 2852* 2855* 2855 2856 2861 2865* 2867* 2873* 2878* 2880* 2899* 2899 2902 2902 2904* 4235 next_vol 003557 automatic fixed bin(17,0) dcl 939 in procedure "append_volume_set" set ref 1018* 1019 1020 1021 1022 1022 1023 1023 1023 1024 1024 1025 1025 1025 1026 1026 1028 1030 1030* 1031 next_vol 003545 automatic fixed bin(17,0) dcl 906 in procedure "append_secondary_volumes" set ref 912* 914 915 916 919 922 923* 923 no 004700 automatic bit(1) packed unaligned dcl 4024 set ref 4112* 4126* 4134 4149 no_link 053116 constant fixed bin(17,0) initial dcl 278 ref 494 516 588 677 755 918 926 928 1023 1025 1026 1037 1539 1540 1559 1560 1561 1580 1581 1589 1590 1591 1592 1594 1616 1617 1618 2280 2281 2282 2302 2337 2350 2431 2433 2434 2435 2494 2501 2565 2566 2584 2609 2735 2848 2852 2859 2863 2867 2874 2898 2902 2903 2998 3270 3302 3324 3521 3530 3792 3886 3900 4223 4227 4255 no_print parameter bit(1) packed unaligned dcl 1321 ref 1311 1331 noaction based bit(1) array level 3 in structure "volume" packed packed unaligned dcl 1817 in procedure "evaluate_volumes_wanted" ref 1842 noaction based bit(1) array level 3 in structure "volume" packed packed unaligned dcl 1132 in procedure "check_for_errors" set ref 1147* 1152* 1163* 1173* 1183* 1194* 1204* 1211* 1219* 1230* 1235* 1255* 1263* 1271* 1279* 1287* 1297* noaction based bit(1) array level 3 in structure "volume" packed packed unaligned dcl 229 in procedure "manage_volume_pool_" set ref 745 871 1016 1722 1831 2171* 2240 3263 3436* 3647 3717* 3727* 3733* 3735* 3761 3881 4117 noaction_cnt 000443 automatic fixed bin(17,0) dcl 171 in procedure "manage_volume_pool_" set ref 3945* noaction_cnt 004102 automatic fixed bin(17,0) dcl 1810 in procedure "evaluate_volumes_wanted" set ref 1838* 1842* 1842 1846 noaction_msg 000342 automatic varying char(256) dcl 170 set ref 738* 763 763* 864* 888 888* 891 891* 1008* 1045 1045* 1388* 1388 1714* 1731 1731* 2232 2232* 2255 2255* 2258 2258* 2751 2751* 3256* 3282 3282* 3466 3466* 3496 3496* 3639* 3665 3665* 3668 3668* 3753 3753* 3774 3774* 3874* 3918 3918* 3946* 4139 4139* 4141 noaction_str based bit packed unaligned dcl 172 ref 1831 none_sw parameter bit(1) packed unaligned dcl 1809 in procedure "evaluate_volumes_wanted" set ref 1796 1825* 1827* none_sw 000444 automatic bit(1) packed unaligned dcl 173 in procedure "manage_volume_pool_" set ref 730* 731 736 861* 862 1005* 1006 1706* 1707 1712 2229* 2230 3248* 3249 3254 3463* 3464 3636* 3637 3750* 3751 not_alloc constant bit(16) initial packed unaligned dcl 298 ref 1270 3747 not_exp constant bit(16) initial packed unaligned dcl 298 ref 1226 2226 3747 not_free constant bit(16) initial packed unaligned dcl 298 ref 1002 1262 3619 not_in_pool 004373 automatic bit(1) packed unaligned dcl 2599 set ref 2709* 2713* 2718 not_reg 001376 constant bit(16) initial packed unaligned dcl 298 set ref 857 1002 1151 1689 2226 2718* 3246 3460 3619 3747 3867 4095 not_updated constant bit(16) initial packed unaligned dcl 298 ref 1286 3867 null builtin function dcl 411 ref 620 1623 1863 1875 1876 1877 3928 3939 4010 old_primary_idx parameter fixed bin(17,0) dcl 906 ref 898 912 913 output 000445 automatic varying char(256) dcl 174 set ref 1897* 1907* 1908* 1923* 1926* 1947* 1950* 1975* 1977* 1977 1980* 1980 1983* 1983 1992* 1992 2003* 2003 2020* 2021* 2021 2023* 2023 2029* 2029 2039* 2039 2040* 2040 2055* 2057* 2057 2061* 2061 2068* 2068 2077* 2081* 2081 2085* 2085 2093* 2097* 2097 2103* 2962 2965 2965 2965 2965 2974* 3001 3003 3003 3003 3003 3007* output_len 000546 automatic fixed bin(17,0) dcl 175 in procedure "manage_volume_pool_" set ref 1907* 1908* 1923* 1926* 1947* 1950* 1975* 1977* 1980* 1983* 1992* 2003* 2020* 2021* 2023* 2029* 2039* 2040* 2055* 2057* 2061* 2068* 2077* 2081* 2085* 2093* 2097* 2103* output_len 003735 automatic fixed bin(17,0) dcl 1366 in procedure "construct_msg" set ref 1371* 1375* 1381* 1385* output_msg 003634 automatic varying char(256) dcl 1365 set ref 1371* 1375* 1381* 1385* 1388 pad 7 based bit(36) level 3 dcl 268 set ref 1486* pad2 57 based bit(36) array level 3 dcl 268 set ref 1516* 1543* 1584* paired_args constant bit(1) initial packed unaligned dcl 278 set ref 433* 1784* pathname 000100 automatic char(168) packed unaligned dcl 2921 set ref 2922* 2923 position 003632 automatic fixed bin(17,0) dcl 1362 set ref 1369* 1370 1371 1371 1371 1371 1375 1375 1375 1375 1375 1375 1380 1380 1381 1381 1381 1381 1385 1385 1385 1385 1389 1390* prev_idx 004541 automatic fixed bin(17,0) dcl 3362 set ref 3472* 3484* 3491* 3513 previous 60 based fixed bin(17,0) array level 3 in structure "volume_pool_2" dcl 1458 in procedure "convert_volume_pool" ref 1510 previous 54 based fixed bin(17,0) array level 3 in structure "volume_pool" dcl 268 in procedure "manage_volume_pool_" set ref 532 918* 928* 1023 1023 1024 1025* 1025 1026* 1510* 1542* 1561* 1583* 1590* 1592* 1617* 2282* 2287 2292* 2292 2295 2296* 2296 2302* 2357 2434* 2503 2565* 2566* 2848* 2851 2852 2855 2856* 2856 2866* 2872* 2874* 2878 2879* 2879 2881* 2898 2899 2900 2902* 2902 2903* 2905* 3794 primary_idx parameter fixed bin(17,0) dcl 4251 in procedure "volume_in_volume_set" ref 4243 4254 primary_idx 003560 automatic fixed bin(17,0) dcl 939 in procedure "append_volume_set" set ref 976* 978 978 1013* 1020 1030* 1032 1032 1038* primary_idx 004470 automatic fixed bin(17,0) dcl 3211 in procedure "pv_expire_key" set ref 3269* 3274 primary_idx parameter fixed bin(17,0) dcl 1139 in procedure "check_for_errors" set ref 1120 1162* 1167 primary_idx parameter fixed bin(17,0) dcl 2580 in procedure "last_volume_in_set" ref 2575 2582 2582 2583 primary_idx 55 based fixed bin(17,0) array level 3 in structure "volume_pool" dcl 268 in procedure "manage_volume_pool_" set ref 677* 755* 873 919* 978 1020* 1181 1187 1508* 1540* 1581* 1724 2242 2377 2939 3265 3403 3521* 3649 3799 3885 3899 3907 4119 primary_idx 61 based fixed bin(17,0) array level 3 in structure "volume_pool_2" dcl 1458 in procedure "convert_volume_pool" ref 1508 primary_idx 004542 automatic fixed bin(17,0) dcl 3362 in procedure "remove_volume_set" set ref 3401* 3403 3403 3418 3420 3420 3423 3423 3423 3427 3427 3427 3434 3438 3438 3440 3460* 3464 3472 3473 3473 3474 3489 3489 3491 primary_idx 004514 automatic fixed bin(17,0) dcl 3318 in procedure "pvexp_volume" set ref 3323* 3328 printx parameter fixed bin(17,0) dcl 2991 in procedure "print_secondary_volumes" set ref 2987 2995 2997* 2997 2998 2999* 3000 3009* 3009 printx 004434 automatic fixed bin(17,0) dcl 2934 in procedure "print" set ref 2936* 2937 2939 2939* 2939 2942 2945 2949 2950 2954 2960* 2979 2979* processid 30 based bit(36) array level 3 dcl 268 set ref 593* 784* 786* 790* 874* 3545 3546* 3652* pv_clock 003512 automatic fixed bin(71,0) dcl 689 in procedure "add_key" set ref 718* 724* 753 pv_clock 004640 automatic fixed bin(71,0) dcl 3813 in procedure "set_key" set ref 3843* 3853* 3887 3894 pv_expire 50(01) based bit(1) array level 4 in structure "volume_pool_2" packed packed unaligned dcl 1458 in procedure "convert_volume_pool" ref 1503 1513 pv_expire 51(01) based bit(1) array level 4 in structure "volume_pool" packed packed unaligned dcl 268 in procedure "manage_volume_pool_" set ref 752* 1325 1503* 1513* 1537* 1578* 1895 1926 1926 1950 1950 1992* 2029* 2061* 2081* 2093* 2246* 3267* 3271* 3303 3321* 3325* 3453 3888* 3893* pv_expire_date 52 based fixed bin(71,0) array level 3 in structure "volume_pool_2" dcl 1458 in procedure "convert_volume_pool" ref 1505 pv_expire_date 24 based fixed bin(71,0) array level 3 in structure "volume_pool" dcl 268 in procedure "manage_volume_pool_" set ref 676* 753* 1326 1505* 1538* 1579* 1923* 1923* 1926* 1947* 1947* 1950* 1992* 1992* 2029* 2029* 2061* 2061* 2081* 2081* 2093* 2093* 3303 3453 3887* 3894* pvedt_sw 000547 automatic bit(1) packed unaligned dcl 176 set ref 1895 1902 1916 1916 1926 1926 1926 1926 1942 1968* 1975 1992 2003 2003 2003 2003 2003 2003 2003 2003 2003 2029 2040 2040 2040 2040 2040 2040 2061 2068 2068* 2081 2085* 2092 2668* 2692 2692* 2702 3950* pvexp 0(10) based bit(1) level 2 packed packed unaligned dcl 3056 ref 3145 pvexp_dt 0(17) based bit(1) level 2 packed packed unaligned dcl 3056 ref 3147 pvexp_len 000550 automatic fixed bin(21,0) dcl 178 set ref 724 724 725 725 3147* 3853 3853 3854 3854 pvexp_ptr 000552 automatic pointer dcl 179 set ref 724 725 3147* 3853 3854 pvexp_state constant fixed bin(17,0) initial dcl 278 ref 1254 1681 2246 2645 3266 3320 3411 4069 4071 4141 4149 pvexp_str based char packed unaligned dcl 177 set ref 724* 725* 3853* 3854* pvexp_sw 000554 automatic bit(1) packed unaligned dcl 180 set ref 723 752 2645* 2697 2697* 3146* 3411 3414 3415 3450 3847 3848 3852 3883 3893 3950* 4069 release_temp_segment_ 000150 constant entry external dcl 355 ref 1600 remove_cnt 004540 automatic fixed bin(17,0) dcl 3362 set ref 3471* 3489 3510* 3510 request_type parameter char packed unaligned dcl 4271 set ref 4266 4277* requestor parameter char packed unaligned dcl 3346 in procedure "query_to_continue" set ref 3337 3350* requestor parameter char packed unaligned dcl 2474 in procedure "get_volumes_specified" set ref 2467 2509 2516* requote_string_ 000152 constant entry external dcl 355 ref 2965 3003 requoted_output 000555 automatic varying char(512) dcl 181 set ref 2965* 2967 3003* 3005 reserve 0(12) based bit(1) level 2 packed packed unaligned dcl 3056 ref 3168 reserve_sw 000756 automatic bit(1) packed unaligned dcl 182 set ref 2649* 2697 2697* 3169* 3950* 4068 reserved_state constant fixed bin(17,0) initial dcl 278 ref 451 589 784 874 1192 1682 2649 3651 4068 4071 4141 4149 ret based varying char dcl 183 set ref 439* 733* 762* 792* 880* 880 915* 915 1017* 1017 1351* 1709* 1730* 2243* 2243 2611* 2611 2742* 2966* 2966 2967* 2967 3004* 3004 3005* 3005 3251* 3281* 3516* 3516 3650* 3650 3763* 3763 3871* 3917* 4134* 4135* 4136* 4205* retl 000757 automatic fixed bin(21,0) dcl 184 set ref 439 733 762 792 880 915 1017 1351 1709 1730 2243 2611 2742 2966 2967 3004 3005 3251 3281 3516 3650 3763 3871 3917 3955* 4134 4135 4136 4205 retp 000760 automatic pointer dcl 185 set ref 439 733 762 792 880 880 915 915 1017 1017 1351 1709 1730 2243 2243 2611 2611 2742 2966 2966 2967 2967 3004 3004 3005 3005 3251 3281 3516 3516 3650 3650 3763 3763 3871 3917 3928* 3955* 4134 4135 4136 4205 routine parameter entry variable dcl 3022 ref 3017 3034 rsv_by_another constant bit(16) initial packed unaligned dcl 298 ref 857 1192 2226 rtrim builtin function dcl 411 ref 462 464 543 554 564 577 606 626 880 881 915 1017 1028 1154 1165 1167 1175 1185 1187 1196 1206 1213 1221 1239 1246 1257 1265 1273 1281 1289 1328 1332 2243 2247 2611 2714 3516 3650 3656 3763 3766 4122 4127 save_idx 004556 automatic fixed bin(17,0) dcl 3505 set ref 3528* 3530 sdt_sw 000762 automatic bit(1) packed unaligned dcl 186 set ref 1968* 1975 1977 1980* 1983 1983 1983 1992 1992 1992 1992 2003 2003 2003 2003 2003 2003 2003 2003 2003 2019 2670* 2692 2692* 2702 2703 3950* sec_not_found constant bit(16) initial packed unaligned dcl 298 ref 1161 3460 sec_vol constant bit(16) initial packed unaligned dcl 298 ref 857 1181 1689 2226 3246 3619 4095 secondary_idx 62 based fixed bin(17,0) array level 3 in structure "volume_pool_2" dcl 1458 in procedure "convert_volume_pool" ref 1507 secondary_idx 56 based fixed bin(17,0) array level 3 in structure "volume_pool" dcl 268 in procedure "manage_volume_pool_" set ref 677* 755* 912 916* 923 926* 1019* 1037* 1507* 1539* 1580* 1591* 2435* 2583 2584 2585 2997 3009 3272 3301 3304 3326 3440 3447 3474 3477 3485 3513* 3513 3527 3529 3530* 3889 3902 4226 4232 4254 4257 secondary_vol 51 based bit(1) array level 4 in structure "volume_pool" packed packed unaligned dcl 268 in procedure "manage_volume_pool_" set ref 873 978 1021* 1180 1512* 1724 2242 2377 2939 3265 3403 3518* 3649 3799 3885 3899 3907 4119 secondary_vol 50 based bit(1) array level 4 in structure "volume_pool_2" packed packed unaligned dcl 1458 in procedure "convert_volume_pool" ref 1512 secondary_volume parameter bit(1) packed unaligned dcl 1891 set ref 1883 1894 1907 1923 1947 1975* set_lock_$lock 000154 constant entry external dcl 355 ref 1464 1468 1472 2790 set_lock_$unlock 000156 constant entry external dcl 355 ref 657 1872 4178 set_state 004543 automatic fixed bin(17,0) dcl 3362 set ref 3411* 3412* single_arg constant bit(1) initial packed unaligned dcl 278 set ref 435* specified_states 001104 automatic bit(1) array packed unaligned dcl 201 set ref 848* 852* 992* 996* 1680* 1681* 1682* 1686* 2380 2615* 2637* 2641* 2645* 2649* 2705 2705* 2942 3592* 3609* 3616* 3718* 3719* 3950* 4066* 4067* 4068* 4069* 4071 4071* 4071* 4071* 4071* 4075 4075* 4085* 4091* 4120 4141* 4141* 4141* 4141* 4149* 4149* 4149* 4149* state 22 based fixed bin(8,0) array level 3 in structure "volume_pool_old" packed packed unaligned dcl 1401 in procedure "convert_volume_pool" ref 1567 state 21 based fixed bin(17,0) array level 3 in structure "volume_pool" dcl 268 in procedure "manage_volume_pool_" set ref 495 517 589 592* 612 672* 749* 780 783* 789* 874 875* 1077 1192 1202 1254 1262 1270 1278 1286 1499* 1532* 1567* 1635 1908 1926 1950 1980 2021 2055 2116 2117* 2174 2244* 2246 2380 2529 2531 2942 3266* 3299 3320* 3418 3523* 3651* 3729 3793 3908 4120 state 21 based fixed bin(17,0) array level 3 in structure "volume_pool_old_1" dcl 1413 in procedure "convert_volume_pool" ref 1532 state 23 based fixed bin(17,0) array level 3 in structure "volume_pool_2" dcl 1458 in procedure "convert_volume_pool" ref 1499 state_date 22 based fixed bin(71,0) array level 3 in structure "volume_pool" dcl 268 in procedure "manage_volume_pool_" set ref 611 1500* 1533* 1568* 1570* 1908* 1908* 1926* 1926* 1950* 1950* 1977* 1977* 2020* 2020* 2563* 2859 2859 2896* 3524* 3901* state_date 26 based fixed bin(71,0) array level 3 in structure "volume_pool_2" dcl 1458 in procedure "convert_volume_pool" ref 1500 state_dt 0(18) based bit(1) level 2 packed packed unaligned dcl 3056 ref 3152 state_dt_clock 000764 automatic fixed bin(71,0) dcl 187 set ref 3863* 3901 state_dt_len 000766 automatic fixed bin(21,0) dcl 189 set ref 3154* 3863 3863 3864 3864 state_dt_ptr 000770 automatic pointer dcl 190 set ref 3154* 3863 3864 state_dt_str based char packed unaligned dcl 188 set ref 3863* 3864* state_dt_sw 000772 automatic bit(1) packed unaligned dcl 191 set ref 3153* 3847 3848 3862 3898 3950* state_string based bit(4) packed unaligned dcl 202 ref 2705 4071 4075 state_sw 000773 automatic bit(1) packed unaligned dcl 192 set ref 1968* 1975 1980 1983 1983 1983 1992 1992 1992 1992 2003 2003 2003 2003 2003 2003 2003 2003 2021 2023* 2029 2029 2029 2029 2040 2040 2040 2040 2040 2040 2040 2054 2671* 2692 2692* 2702 2703 3950* str 000100 automatic char(256) packed unaligned dcl 2811 in procedure "msg" set ref 2822* 2823 2823 2825 2825 str 000102 automatic char(256) packed unaligned dcl 646 in procedure "abort" set ref 656* 658 658 str_len 000202 automatic fixed bin(17,0) dcl 2813 in procedure "msg" set ref 2822* 2823 2823 2825 2825 str_len 000202 automatic fixed bin(17,0) dcl 647 in procedure "abort" set ref 656* 658 658 subroutine 001106 automatic bit(1) packed unaligned dcl 204 set ref 416* 457* 479* 550* 560* 573* 584* 602* 619* 634* 649 782 793 1105 1480 1571 1612 1875 2815 2823 2826 3934 4012 substr builtin function dcl 411 set ref 658 658 1153* 1164* 1174* 1184* 1195* 1205* 1212* 1220* 1238* 1245* 1256* 1264* 1272* 1280* 1288* 1298* 1389* 2823 2823 2825 2825 2965 2965 3003 3003 4167 suffixed_name_$make 000160 constant entry external dcl 355 ref 4006 svol 0(14) based bit(1) level 2 packed packed unaligned dcl 3056 ref 3182 svol_sw 001105 automatic bit(1) packed unaligned dcl 203 set ref 3183* 3848 3884 3950* switches based structure level 2 in structure "volume" dcl 2476 in procedure "get_volumes_specified" switches based structure level 2 in structure "volume" dcl 229 in procedure "manage_volume_pool_" switches based structure level 2 in structure "volume" dcl 1817 in procedure "evaluate_volumes_wanted" switches 51 based structure array level 3 in structure "volume_pool" packed packed unaligned dcl 268 in procedure "manage_volume_pool_" set ref 674* 751* 1535* 1576* switches based structure level 2 in structure "tvol" dcl 222 in procedure "manage_volume_pool_" switches 50 based structure array level 3 in structure "volume_pool_2" packed packed unaligned dcl 1458 in procedure "convert_volume_pool" switches based structure level 2 in structure "volume" dcl 2323 in procedure "get_list_names" switches based structure level 2 in structure "volume" dcl 1132 in procedure "check_for_errors" tail 5 based fixed bin(17,0) level 3 in structure "volume_pool" dcl 268 in procedure "manage_volume_pool_" set ref 515 1024 1024* 1492* 1526* 1550* 1557* 1619* 2274 2278* 2286 2287* 2288 2349 2500 2843 2850 2851* 2864 2868* 2900 2900* 3791 tail 5 based fixed bin(17,0) level 3 in structure "volume_pool_2" dcl 1458 in procedure "convert_volume_pool" ref 1492 tcnt 000774 automatic fixed bin(17,0) dcl 193 set ref 1683* 1684 1684 1684 1684 1685 1685 1685 1685 1685 1685 1685 1686* 1695 1698 1700 1701 1701 1701 1877 1877 1877 1877 3606* 3607 3607 3607 3607 3608 3608 3608 3608 3608 3608 3608 3609* 3625 3628 3630 3631 3631 3631 4082* 4083 4083 4083 4083 4084 4084 4084 4084 4084 4084 4084 4085* 4101 4104 4106 4107 4107 4107 tdir 001107 automatic char(168) packed unaligned dcl 205 set ref 637* 640* 640* test_no_vol_list 005002 automatic varying char(256) dcl 4025 set ref 4113* 4127* 4127 4149* test_vol_list 004701 automatic varying char(256) dcl 4025 set ref 4113* 4122* 4122 4141* time 24 based fixed bin(71,0) array level 3 in structure "volume_pool_old_1" dcl 1413 in procedure "convert_volume_pool" ref 1533 time 23 based char(16) array level 3 in structure "volume_pool_old" packed packed unaligned dcl 1401 in procedure "convert_volume_pool" set ref 1568* time parameter fixed bin(71,0) dcl 4163 in procedure "time_string_" set ref 4161 4166* time_char 000100 automatic char(24) dcl 4164 set ref 4166* 4167 tname 001161 automatic char(32) packed unaligned dcl 206 set ref 637* 640* 640* total_char automatic varying char(256) dcl 2598 ref 2742 total_cnt 000775 automatic fixed bin(17,0) dcl 194 set ref 2742 2744 2745* 2745 2750 2976* 2976 3945* totals_wanted 000776 automatic bit(1) packed unaligned dcl 195 set ref 2677* 2692 2741 2964 2974 3002 3007 3950* truebits constant bit(4) initial packed unaligned dcl 278 ref 4071 tvlx 001171 automatic fixed bin(17,0) dcl 207 set ref 3791* 3792 3793 3793 3793 3794* 3794 3798* 3799 3799 3800 tvol based structure level 1 dcl 222 set ref 1684 1877 3607 4083 use 001566 constant char(3) initial packed unaligned dcl 278 set ref 621 622 user_info_ 000176 constant entry external dcl 386 ref 4002 user_info_$homedir 000162 constant entry external dcl 355 ref 4001 verify builtin function dcl 411 ref 2453 2962 version based fixed bin(17,0) level 3 dcl 268 set ref 1092 1092 1105* 1108* 1113* 1464 1468 1480* 1485* 1488 1521 1614* 3940 3969 vidx 004172 automatic fixed bin(17,0) dcl 2373 in procedure "get_names_check_switches" set ref 2376* 2377 2377* 2377 2380 2383 2387 2388 2392 vidx parameter fixed bin(17,0) dcl 2934 in procedure "print" ref 2928 2936 vlx 001172 automatic fixed bin(17,0) dcl 208 set ref 466 470 579 580 587* 588 589 590* 592 593 594* 597* 597 608 610 611 612 669 670* 671 672 673 674 674 674 674 674 675 676 677 677 678 679* 776 780 781 783 784 786 789 790 792 793 794* 1076 1077 1078 1079* 1350 1351 1352 1496* 1497 1497 1498 1498 1499 1499 1500 1500 1501 1501 1502 1502 1503 1503 1504 1504 1505 1505 1506 1506 1507 1507 1508 1508 1509 1509 1510 1510 1512 1512 1513 1513 1514 1514 1515 1515 1516* 1529* 1530 1530 1531 1531 1532 1532 1533 1533 1534 1534 1535 1535 1535 1535 1535 1536 1537 1537 1538 1538 1539 1540 1541 1541 1542 1542 1543* 1564* 1565 1565 1566 1566 1567 1567 1568 1568 1570 1571 1575 1575 1576 1576 1576 1576 1576 1577 1578 1578 1579 1579 1580 1581 1582 1582 1583 1583 1584* 1634 1635 1637* 2115 2116 2117 2118 2119* 3789* 3792 3793* 3799* 3800* vol_cnt 003555 automatic fixed bin(17,0) dcl 939 in procedure "append_volume_set" set ref 984* 989 989* 993 996* 1002* 1005* 1006 1006 1014 1041 1041 vol_cnt 004056 automatic fixed bin(17,0) dcl 1647 in procedure "delete_key" set ref 1675* 1676 1689* 1694* 1699 1700 1701 1702* 1702 1706* 1712 1712 1720 vol_cnt 003515 automatic fixed bin(17,0) dcl 689 in procedure "add_key" set ref 720* 722 728* 730* 736 736 743 vol_cnt parameter fixed bin(17,0) dcl 3053 in procedure "process_ctl_args" set ref 3042 3078* 3100* 3107* 3193* 3193 3194 vol_cnt parameter fixed bin(17,0) dcl 1810 in procedure "evaluate_volumes_wanted" ref 1796 1839 vol_cnt parameter fixed bin(17,0) dcl 1139 in procedure "check_for_errors" ref 1120 1149 vol_cnt 001173 automatic fixed bin(17,0) dcl 209 in procedure "manage_volume_pool_" set ref 486* 494 498* 498 499 500 505* 505 506 507 516 520* 520 521 522 527* 527 528 529 536 536 542 2625* 2655* 2660* 2687* 2687 2688 2710 2722 2722* 2723 2726* 2727 2728 3409* 3434* 3443 3452 3460* 3463* 3479 3844* 3846 3867* 3879 vol_cnt 004473 automatic fixed bin(17,0) dcl 3212 in procedure "pv_expire_key" set ref 3242* 3244 3246* 3248* 3254 3254 3261 vol_cnt 003531 automatic fixed bin(17,0) dcl 805 in procedure "allocate_key" set ref 835* 845 845* 849 852* 857* 861* 862 862 869 888 888 vol_cnt 004137 automatic fixed bin(17,0) dcl 2130 in procedure "free_key" set ref 2160* 2179* 2179 2180 2181 2182 2188 2194 2203* 2203 2204 2205 2206 2210 2216 2226* 2229* 2230 2230 2238 2255 2255 vol_cnt 004575 automatic fixed bin(17,0) dcl 3561 in procedure "reserve_key" set ref 3595* 3613 3613* 3614 3616* 3619* 3624* 3629 3630 3631 3632* 3632 3636* 3637 3637 3645 vol_cnt 004675 automatic fixed bin(17,0) dcl 4022 in procedure "test_key" set ref 4056* 4079 4079* 4089 4091* 4095* 4100* 4105 4106 4107 4108* 4108 4116 vol_cnt 004613 automatic fixed bin(17,0) dcl 3679 in procedure "reuse" set ref 3708* 3714 3714* 3715 3719* 3723 3724* 3728 3747* 3750* 3751 3751 3759 vol_dir 000020 internal static char(168) initial packed unaligned dcl 276 set ref 439* 440* 440* 1108* 1108* 1476* 1476* 1482* 1482* 1598* 1598* 1610* 1612* 1612* 1613* 1613* 1623* 1623* 1866* 1867* 1867* 1868* 1869* 1869* 2773* 2774* 2774* 2795* 2795* 3995* 4000 4001* 4009* 4181* 4181* 4197* 4205* vol_ename 000010 internal static char(32) initial packed unaligned dcl 275 set ref 439* 440* 440* 1108* 1108* 1476* 1476* 1480* 1482* 1482* 1598* 1598* 1610* 1612* 1612* 1613* 1613* 1623* 1623* 1866* 1867* 1867* 1868* 1869* 1869* 2773* 2774* 2774* 2795* 2795* 3995* 4002* 4006* 4006* 4007* 4009* 4181* 4181* 4197* 4205* vol_idx parameter fixed bin(17,0) dcl 1890 in procedure "format_print_output" ref 1883 1895 1907 1908 1908 1908 1908 1908 1908 1923 1923 1923 1926 1926 1926 1926 1926 1926 1926 1926 1926 1926 1926 1926 1947 1947 1947 1950 1950 1950 1950 1950 1950 1950 1950 1950 1950 1950 1950 1975 1975 1977 1977 1980 1983 1983 1983 1992 1992 1992 2003 2020 2020 2021 2023 2023 2023 2029 2029 2029 2039 2040 2055 2057 2057 2057 2061 2061 2061 2068 2077 2077 2077 2081 2081 2081 2085 2093 2093 2093 2097 2103 vol_idx 004504 automatic fixed bin(17,0) dcl 3295 in procedure "pvexp_secondary_vol_check" set ref 3297* 3298 3299 3301* 3301 3302 3303 3303 3304* 3304 vol_idx 004231 automatic fixed bin(17,0) dcl 2483 in procedure "get_volumes_specified" set ref 2491* 2494 2501 2509 2513 2516* 2516 2534* 2534 2535 2536 2537 2541* 2541 2542 2543 2544 vol_idx 004360 automatic fixed bin(17,0) dcl 2580 in procedure "last_volume_in_set" set ref 2583* 2584 2585* 2585 2587 vol_idx 004643 automatic fixed bin(17,0) dcl 3814 in procedure "set_key" set ref 3882* 3885 3885* 3885 3886 3887 3888 3889* 3889 3893 3894 3896* 3899 3899* 3899 3900 3901 3902* 3902 3904* 3905* 3907 3907* 3907 3908 3909 3910 3912 vol_idx 004136 automatic fixed bin(17,0) dcl 2130 in procedure "free_key" set ref 2173* 2174 2175 2176 2177* 2180 2181* vol_idx parameter fixed bin(17,0) dcl 1320 in procedure "check_for_pvexp" set ref 1311 1325 1326 1326* 1328 1332 1335* vol_idx 004163 automatic fixed bin(17,0) dcl 2330 in procedure "get_list_names" set ref 2335* 2337 2339* 2339 2340 2341 2342 2348* 2350 2352 2353 2354 2355* 2355 vol_idx parameter fixed bin(17,0) dcl 4218 in procedure "volume_in_pool" set ref 4211 4222* 4223 4224 4225 4226 4229* 4235* 4235 vol_idx parameter fixed bin(17,0) dcl 3318 in procedure "pvexp_volume" set ref 3313 3320 3321 3322 3323 3324 3325 3326* 3326 3328* 3330* vol_idx parameter fixed bin(17,0) dcl 4251 in procedure "volume_in_volume_set" set ref 4243 4254* 4255 4256 4257* 4257 vol_idx parameter fixed bin(17,0) dcl 3543 in procedure "reserved_by_another_process" ref 3539 3545 3546 vol_list 001204 automatic structure array level 1 dcl 218 vol_msg_cnt 001100 automatic fixed bin(17,0) dcl 197 set ref 3644* 3657* 3657 3665 3665 3758* 3765* 3765 3774 3774 vol_msg_list 000777 automatic varying char(256) dcl 196 set ref 868* 881* 881 888 888* 1012* 1028* 1028 1041 1041* 2237* 2247* 2247 2255 2255* 3643* 3656* 3656 3665 3665* 3757* 3766* 3766 3774 3774* 3946* vol_name parameter char packed unaligned dcl 4251 in procedure "volume_in_volume_set" ref 4243 4256 vol_name parameter char packed unaligned dcl 4218 in procedure "volume_in_pool" ref 4211 4224 4228 vol_pvexp constant bit(16) initial packed unaligned dcl 298 ref 857 1254 voli 004424 automatic fixed bin(17,0) dcl 2841 set ref 2859* 2859 2859* 2861 2863 2864* 2865 2866 2870 2871* 2872 2873 2878 2879 2880 2881 volume based structure level 1 dcl 2323 in procedure "get_list_names" volume based structure level 1 dcl 229 in procedure "manage_volume_pool_" set ref 491 850 994 1696 1876 2170 2196 2684 2724 3190 3435 3615 3626 3716 3725 4090 4102 volume based structure level 1 dcl 1132 in procedure "check_for_errors" volume based structure level 1 dcl 1817 in procedure "evaluate_volumes_wanted" volume based structure level 1 dcl 2476 in procedure "get_volumes_specified" volume_cnt 001101 automatic fixed bin(17,0) dcl 198 set ref 487* 491 491 491 491 494 499 506 516 521 528 536 544 728* 730* 744 744 744 745 745 849* 850 850 850 850 851 851 851 851 851 851 851 857* 861* 870 870 870 871 871 872 993* 994 994 994 994 995 995 995 995 995 995 995 1002* 1015 1015 1015 1016 1016 1018 1689* 1695* 1696 1696 1696 1696 1700 1701 1701 1701 1706* 1721 1721 1721 1722 1722 1723 1826 1826 1826 1826 1831 1831 1831 1831 1831 1831 1831 1876 1876 1876 1876 2169* 2170 2170 2170 2170 2171 2171 2171 2171 2171 2171 2171 2171 2171 2171 2171 2171 2181 2182 2182 2182 2195* 2196 2196 2196 2196 2197 2197 2197 2197 2205 2206 2206 2206 2215 2215 2215 2215 2217 2217 2217 2226* 2239 2239 2239 2240 2240 2241 2683* 2684 2684 2684 2684 2723* 2724 2724 2724 2724 2725 2725 2725 2725 2729 2729 2729 2729 3189* 3190 3190 3190 3190 3246* 3248* 3262 3262 3262 3263 3263 3264 3434* 3435 3435 3435 3435 3436 3436 3436 3436 3436 3436 3436 3436 3436 3436 3436 3436 3445 3446 3446 3446 3451 3451 3451 3451 3451 3451 3451 3453 3453 3453 3453 3453 3460* 3463* 3480 3480 3480 3614* 3615 3615 3615 3615 3619* 3625* 3626 3626 3626 3626 3630 3631 3631 3631 3636* 3646 3646 3646 3647 3647 3648 3714* 3715* 3716 3716 3716 3716 3717 3717 3717 3717 3717 3717 3717 3717 3717 3717 3717 3717 3724* 3725 3725 3725 3725 3727 3727 3727 3727 3727 3727 3727 3727 3727 3727 3727 3727 3731 3732 3732 3732 3733 3733 3735 3735 3739 3739 3739 3739 3747* 3750* 3760 3760 3760 3761 3761 3762 3867* 3880 3880 3880 3881 3881 3882 3896 3904 4089* 4090 4090 4090 4090 4095* 4101* 4102 4102 4102 4102 4106 4107 4107 4107 4117 4117 4117 4117 4117 4118 volume_count 3 based fixed bin(17,0) level 3 in structure "volume_pool" dcl 268 in procedure "manage_volume_pool_" set ref 482 1491* 1525* 1529 1549* 1556* 1564 1594 1620* 2277* 2304* 2304 2568* 2568 2601 4221 volume_count 3 based fixed bin(17,0) level 3 in structure "volume_pool_2" dcl 1458 in procedure "convert_volume_pool" ref 1491 volume_pool based structure level 1 dcl 268 set ref 1864 volume_pool_2 based structure level 1 dcl 1458 volume_pool_entry 003356 automatic structure level 1 dcl 246 volume_pool_entry_2 003756 automatic structure level 1 dcl 1437 volume_pool_header 003346 automatic structure level 1 dcl 236 volume_pool_header_2 003744 automatic structure level 1 dcl 1427 volume_pool_old based structure level 1 dcl 1401 volume_pool_old_1 based structure level 1 dcl 1413 volume_pool_version_1 constant fixed bin(17,0) initial dcl 278 ref 1092 1468 1521 volume_pool_version_2 constant fixed bin(17,0) initial dcl 278 ref 1092 1464 1488 volume_pool_version_3 001607 constant fixed bin(17,0) initial dcl 278 set ref 1108* 1480* 1485 1614 3940 3969 volume_size 0(03) based bit(1) level 2 packed packed unaligned dcl 3056 ref 3118 volume_state 001175 automatic fixed bin(17,0) dcl 211 set ref 451* 456* 783 784 volume_sw 001174 automatic bit(1) packed unaligned dcl 210 set ref 837 847 986 991 1689 1693 2162 2226 2686* 2697 2708 3192* 3415 3433 3602 3612 3619 3623 3710 3746 3950* 4063 4088 4094 4099 volx 003612 automatic fixed bin(17,0) dcl 1139 in procedure "check_for_errors" set ref 1150* 1159 1162* 1180 1181* 1181 1187 1192 1193* 1202 1226 1227 1228* 1254 1262 1270 1278 1286 1295* volx 003532 automatic fixed bin(17,0) dcl 805 in procedure "allocate_key" set ref 872* 873 873* 873 874 874 875 876 877 878 879 880 881 882* volx 004576 automatic fixed bin(17,0) dcl 3561 in procedure "reserve_key" set ref 3648* 3649 3649* 3649 3650 3651 3652 3653 3654 3656 3659* volx 004370 automatic fixed bin(17,0) dcl 2597 in procedure "list_key" set ref 2711* 2711* volx 003514 automatic fixed bin(17,0) dcl 689 in procedure "add_key" set ref 747* 748 749 750 751 751 751 751 751 752 753 754 755 755 756 757* volx 004135 automatic fixed bin(17,0) dcl 2130 in procedure "free_key" set ref 2241* 2242 2242* 2242 2243 2244 2245 2246 2246 2247 2249* volx 004210 automatic fixed bin(17,0) dcl 2427 in procedure "get_node" set ref 2429* 2438 volx parameter fixed bin(17,0) dcl 2373 in procedure "get_names_check_switches" ref 2365 2375 2376 volx 004054 automatic fixed bin(17,0) dcl 1647 in procedure "delete_key" set ref 1723* 1724 1724* 1724 1725* volx parameter fixed bin(17,0) dcl 2894 in procedure "move_to_head" ref 2888 2896 2897 2898 2899 2899 2900 2900 2902 2902 2902 2903 2904 2905 2906 volx 004536 automatic fixed bin(17,0) dcl 3362 in procedure "remove_volume_set" set ref 3438* 3440* 3443 3444 3445 3447* 3447 volx parameter fixed bin(17,0) dcl 2561 in procedure "insert_node" ref 2555 2563 2564 2565 2566 2567 volx 004614 automatic fixed bin(17,0) dcl 3679 in procedure "reuse" set ref 3762* 3763 3766 3768* volx 004162 automatic fixed bin(17,0) dcl 2330 in procedure "get_list_names" set ref 2336* 2337 2338* 2340 2341 2344* 2344 2349* 2350 2351* 2352 2353 2357* 2357 volx 004672 automatic fixed bin(17,0) dcl 4022 in procedure "test_key" set ref 4118* 4119 4119* 4119 4120 volx parameter fixed bin(17,0) dcl 2840 in procedure "move_into_state_date_order" ref 2833 2843 2843 2846 2847 2848 2850 2851 2852 2855 2855 2856 2856 2859 2865 2866 2867 2868 2872 2873 2874 2875 2878 2879 2880 2881 volx parameter fixed bin(17,0) dcl 2272 in procedure "free_node" ref 2265 2286 2287 2288 2290 2291 2292 2295 2295 2296 2296 2301 2302 2303 volx 003454 automatic fixed bin(17,0) dcl 477 in procedure "manage_volume_pool_" set ref 493* 494 495 495 497 499 500 506 507 510* 510 515* 516 517 517 519 521 522 528 529 532* 532 542* 543 544* volx 004472 automatic fixed bin(17,0) dcl 3212 in procedure "pv_expire_key" set ref 3264* 3265 3265* 3265 3266 3267 3268 3269 3270 3271 3272* 3272 3274* 3276* vp_bc 001176 automatic fixed bin(24,0) dcl 212 set ref 1100 4009* vpe 10 based structure array level 2 dcl 268 vpe_2 12 based structure array level 2 dcl 1458 vpe_old 11 based structure array level 2 dcl 1401 vpe_old_1 10 based structure array level 2 dcl 1413 vpp 001200 automatic pointer dcl 213 set ref 470 482 493 495 495 497 500 507 510 515 517 517 519 522 529 532 580 587 589 592 593 597 610 611 612 637* 657 671 672 673 674 675 676 677 677 678 748 749 750 751 752 753 754 755 755 756 780 781 783 784 786 789 790 792 793 873 873 874 874 875 876 877 878 879 880 881 912 915 916 917 918 918 919 921 921 923 926 927 928 928 978 978 978 1019 1020 1021 1022 1022 1022 1023 1023 1023 1023 1024 1024 1024 1025 1025 1025 1025 1026 1026 1028 1030 1032 1032 1037 1077 1078 1092 1092 1105 1108 1113 1167 1180 1181 1187 1187 1192 1202 1226 1227 1254 1262 1270 1278 1286 1325 1326 1328 1332 1351 1352 1464 1464 1468 1468 1472 1480 1488 1490 1491 1492 1493 1494 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1512 1513 1514 1515 1521 1525 1526 1527 1530 1531 1532 1533 1534 1549 1550 1551 1553 1565 1566 1567 1568 1575 1596* 1610* 1614 1615 1615 1616 1616 1617 1617 1618 1619 1620 1623 1635 1724 1724 1863 1864 1872 1875 1875* 1895 1907 1908 1908 1908 1908 1908 1908 1923 1923 1923 1926 1926 1926 1926 1926 1926 1926 1926 1926 1926 1926 1926 1947 1947 1947 1950 1950 1950 1950 1950 1950 1950 1950 1950 1950 1950 1950 1975 1975 1977 1977 1980 1983 1983 1983 1992 1992 1992 2003 2020 2020 2021 2023 2023 2023 2029 2029 2029 2039 2040 2055 2057 2057 2057 2061 2061 2061 2068 2077 2077 2077 2081 2081 2081 2085 2093 2093 2093 2097 2103 2116 2117 2118 2169 2173 2174 2175 2176 2180 2195 2199 2200 2204 2217 2242 2242 2243 2244 2245 2246 2246 2247 2274 2274 2276 2277 2278 2279 2280 2281 2281 2282 2282 2286 2287 2287 2288 2288 2288 2290 2291 2291 2292 2292 2292 2295 2295 2295 2296 2296 2296 2301 2301 2302 2303 2304 2304 2336 2340 2344 2349 2352 2357 2377 2377 2380 2383 2387 2388 2392 2429 2430 2430 2430 2431 2432 2432 2432 2433 2433 2434 2434 2435 2435 2493 2496 2500 2503 2529 2530 2531 2536 2542 2563 2564 2564 2565 2565 2565 2566 2567 2568 2568 2582 2583 2584 2585 2601 2604 2605 2608 2611 2618 2722 2734 2737 2790 2843 2843 2846 2847 2847 2848 2848 2850 2851 2851 2852 2852 2855 2855 2855 2856 2856 2856 2859 2859 2859 2861 2864 2865 2866 2867 2868 2870 2871 2872 2873 2874 2875 2878 2878 2879 2879 2880 2881 2896 2897 2898 2899 2899 2899 2900 2900 2900 2902 2902 2902 2902 2903 2904 2904 2905 2905 2906 2939 2939 2942 2945 2949 2950 2954 2979 2997 3009 3265 3265 3266 3267 3268 3271 3272 3298 3299 3301 3303 3303 3304 3320 3321 3322 3325 3326 3403 3403 3403 3418 3420 3420 3423 3423 3423 3427 3427 3427 3434 3438 3440 3444 3447 3453 3453 3464 3473 3474 3477 3480 3485 3489 3489 3513 3513 3516 3517 3518 3519 3520 3521 3523 3524 3527 3529 3530 3545 3546 3649 3649 3650 3651 3652 3653 3654 3656 3724 3729 3729 3730 3733 3733 3763 3766 3791 3793 3793 3794 3799 3799 3885 3885 3887 3888 3889 3893 3894 3899 3899 3901 3902 3907 3907 3908 3909 3910 3912 3928* 3938* 3939 3940 3969 4009* 4010 4012 4119 4119 4120 4178 4221 4222 4224 4225 4226 4228 4232 4235 4254 4256 4257 vs_count 56 based fixed bin(17,0) array level 3 in structure "volume_pool_2" dcl 1458 in procedure "convert_volume_pool" ref 1502 vs_count 52 based fixed bin(17,0) array level 3 in structure "volume_pool" dcl 268 in procedure "manage_volume_pool_" set ref 495 517 678* 756* 917* 921* 921 927* 1030 1032* 1032 1502* 1536* 1577* 2383 2530 2582 2945 2979 3268 3298 3322 3434 3438 3473 3489* 3489 3793 4225 vs_size parameter fixed bin(17,0) dcl 2483 in procedure "get_volumes_specified" set ref 2467 2509 2509* 2516 2516* 2520 2520* 2530 2530 vs_size parameter fixed bin(17,0) dcl 2373 in procedure "get_names_check_switches" ref 2365 2382 2383 vs_size 001103 automatic fixed bin(17,0) dcl 200 in procedure "manage_volume_pool_" set ref 852* 996* 1686* 2602* 2616* 2664* 2711* 2726* 2729* 2736* 3077* 3120* 3609* 3616* 3719* 4085* 4091* vs_size parameter fixed bin(17,0) dcl 2330 in procedure "get_list_names" set ref 2312 2338* 2351* vs_size parameter fixed bin(17,0) dcl 2934 in procedure "print" ref 2928 2944 2945 vs_sw 001102 automatic bit(1) packed unaligned dcl 199 set ref 837 837* 986 2663* 2697 2697* 2721 3119* 3597 3602 3602* 3710 3710* 3713 3950* 4058 4063 4063* want_cnt 004101 automatic fixed bin(17,0) dcl 1810 set ref 1837* 1841* 1841 1846 want_it based bit(1) array level 3 in structure "volume" packed packed unaligned dcl 1817 in procedure "evaluate_volumes_wanted" ref 1840 want_it based bit(1) array level 3 in structure "tvol" packed packed unaligned dcl 222 in procedure "manage_volume_pool_" set ref 1685* 1701 3608* 3631 4084* 4107 want_it based bit(1) array level 3 in structure "volume" packed packed unaligned dcl 2476 in procedure "get_volumes_specified" set ref 2537* 2544* want_it based bit(1) array level 3 in structure "volume" packed packed unaligned dcl 2323 in procedure "get_list_names" set ref 2342* 2354* want_it based bit(1) array level 3 in structure "volume" packed packed unaligned dcl 229 in procedure "manage_volume_pool_" set ref 744 851* 870 995* 1015 1701* 1721 1826 1831 2171* 2182* 2197* 2206* 2215* 2217* 2239 2725* 2729 3262 3436* 3446* 3451* 3453* 3480 3631* 3646 3717* 3727* 3732* 3739 3760 3880 4107* 4117 want_it based bit(1) array level 3 in structure "volume" packed packed unaligned dcl 1132 in procedure "check_for_errors" set ref 1146* want_str based bit packed unaligned dcl 214 ref 1826 1831 3739 word_count 001202 automatic fixed bin(19,0) dcl 215 set ref 1864* 1865 1868* yes 004677 automatic bit(1) packed unaligned dcl 4024 set ref 4112* 4121* 4134 4135 4141 4149 yes_sw 001203 automatic bit(1) packed unaligned dcl 216 set ref 1108* 1112 4277* 4281* 4284 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. A_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 A_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 DIR_ACCESS_MODE_NAMES internal static char(4) initial array packed unaligned dcl 1-33 E_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 E_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 M_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 M_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 N_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 N_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 REW_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 REW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 RE_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 R_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 SA_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 SA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SEG_ACCESS_MODE_NAMES internal static char(4) initial array packed unaligned dcl 1-30 SMA_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 SMA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SM_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 SM_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 S_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 S_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 W_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 W_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 NAMES DECLARED BY EXPLICIT CONTEXT. CONVERT_FINISH 020621 constant label dcl 1596 set ref 1518 1562 END_CHECK 016513 constant label dcl 1302 ref 1168 1177 1188 1198 1208 1215 1223 1231 1241 1248 1259 1267 1275 1283 1291 END_FREE_NODE 031540 constant label dcl 2306 ref 2283 END_LIST 035112 constant label dcl 2754 ref 2620 2747 END_MOVE_TO_HEAD 036146 constant label dcl 2908 ref 2897 END_PRINT 036527 constant label dcl 2981 ref 2937 2942 2945 2949 2950 2955 END_SETUP 046300 constant label dcl 3973 ref 3967 abort 007744 constant entry internal dcl 643 ref 3932 add 010110 constant entry internal dcl 665 ref 466 add_key 010225 constant entry internal dcl 685 ref 423 alloc_common 005673 constant label dcl 457 ref 452 allocate 010661 constant entry internal dcl 771 in procedure "manage_volume_pool_" ref 469 1784 1784 allocate 005634 constant entry external dcl 454 allocate_key 011153 constant entry internal dcl 800 ref 1788 append_secondary_volumes 012074 constant entry internal dcl 898 ref 1030 append_volume_set 012246 constant entry internal dcl 935 ref 427 arg_err 046156 constant label dcl 3963 ref 3966 bad_arg 013313 constant entry internal dcl 1052 ref 3966 bad_ctl 040042 constant label dcl 3200 ref 3086 3093 3098 3104 3111 3118 3124 3130 3135 3140 3145 3152 3158 3163 3168 3173 3182 change 013361 constant entry internal dcl 1072 ref 433 433 check_first_then_convert 013503 constant entry internal dcl 1086 ref 3940 3969 check_for_errors 013671 constant entry internal dcl 1120 ref 728 857 1002 1689 2226 3246 3460 3619 3747 3867 4095 check_for_pvexp 016520 constant entry internal dcl 1311 ref 1228 1295 2177 2201 2532 3508 3734 check_reserved 007140 constant entry external dcl 583 comment 016767 constant entry internal dcl 1346 ref 435 435 construct_msg 017105 constant entry internal dcl 1357 ref 1305 2190 2212 2507 2718 3495 3741 convert_volume_pool 017462 constant entry internal dcl 1397 ref 1092 1101 1112 create_pool 020730 constant entry internal dcl 1608 ref 4010 delete 006660 constant entry external dcl 559 delete 021203 constant entry internal dcl 1630 in procedure "manage_volume_pool_" ref 566 delete_key 021275 constant entry internal dcl 1643 ref 424 determine_alloc_version 022051 constant entry internal dcl 1737 ref 421 evaluate_volumes_wanted 022300 constant entry internal dcl 1796 ref 730 861 1005 1706 2229 3248 3463 3636 3750 finish 022510 constant entry internal dcl 1860 ref 418 443 460 481 552 562 575 586 604 624 636 force_allocate 006054 constant entry external dcl 473 format_print_output 023021 constant entry internal dcl 1883 ref 2960 2999 free 027770 constant entry internal dcl 2111 in procedure "manage_volume_pool_" ref 556 free 006554 constant entry external dcl 549 free_key 030100 constant entry internal dcl 2125 ref 422 free_node 031422 constant entry internal dcl 2265 ref 1637 1725 get_list_names 031541 constant entry internal dcl 2312 ref 2726 get_names_check_switches 031743 constant entry internal dcl 2365 ref 2338 2351 get_next_arg 032104 constant entry internal dcl 2403 ref 3088 3126 3147 3154 get_node 032204 constant entry internal dcl 2422 ref 670 747 get_number 032244 constant entry internal dcl 2443 ref 2655 2660 2664 3100 3107 3120 get_pool_path 007550 constant entry external dcl 630 get_volumes_specified 032354 constant entry internal dcl 2467 ref 852 996 1686 3609 3616 3719 4085 4091 get_volumes_specified_loop 032663 constant entry internal dcl 2527 ref 2495 2502 insert_node 033012 constant entry internal dcl 2555 ref 679 757 last_volume_in_set 033044 constant entry internal dcl 2575 ref 1013 list_key 033101 constant entry internal dcl 2593 ref 420 lock_required 035113 constant entry internal dcl 2760 ref 3970 lock_volume_pool 035314 constant entry internal dcl 2785 ref 3941 3970 manage_volume_pool 005076 constant entry external dcl 12 manage_volume_pool_ 005046 constant entry external dcl 12 move_into_state_date_order 035633 constant entry internal dcl 2833 ref 3905 move_to_head 036054 constant entry internal dcl 2888 ref 544 594 794 882 1038 1079 2119 2249 3276 3330 3525 3659 3768 msg 035413 constant entry internal dcl 2803 ref 3933 mvp 005066 constant entry external dcl 12 mvp_ 005056 constant entry external dcl 12 new_version 022276 constant label dcl 1788 ref 1763 1769 1774 old_version 022270 constant label dcl 1784 ref 1759 1776 path 036150 constant entry internal dcl 2915 ref 439 440 440 640 640 1108 1108 1476 1476 1482 1482 1598 1598 1612 1612 1613 1613 1623 1623 1867 1867 1869 1869 2774 2774 2795 2795 4181 4181 4205 print 036250 constant entry internal dcl 2928 ref 2616 2711 2729 2736 print_secondary_volumes 036530 constant entry internal dcl 2987 ref 2979 process 036717 constant entry internal dcl 3017 ref 433 435 1784 process_ctl_args 037105 constant entry internal dcl 3042 ref 720 835 984 1675 2160 3242 3409 3595 3708 3844 4056 pv_expire_key 040071 constant entry internal dcl 3207 ref 431 pvexp_secondary_vol_check 040452 constant entry internal dcl 3290 ref 1326 pvexp_volume 040543 constant entry internal dcl 3313 ref 1335 query_to_continue 040611 constant entry internal dcl 3337 ref 1850 2519 remove_volume 042114 constant entry internal dcl 3501 ref 3482 3492 remove_volume_set 040674 constant entry internal dcl 3357 ref 428 reserve 005572 constant entry external dcl 449 reserve_key 042367 constant entry internal dcl 3557 ref 425 reserved_by_another_process 042304 constant entry internal dcl 3539 ref 590 1193 return_to_caller 005557 constant label dcl 443 ref 471 484 538 547 557 567 581 599 613 628 641 659 2826 reuse 043475 constant entry internal dcl 3675 ref 429 search 044604 constant entry internal dcl 3783 ref 465 555 565 578 607 3028 set_key 044723 constant entry internal dcl 3809 ref 430 set_pool_path 007442 constant entry external dcl 615 set_volid 006767 constant entry external dcl 569 setup 045607 constant entry internal dcl 3924 ref 417 459 480 551 561 574 585 603 623 635 setup_pool_path 046301 constant entry internal dcl 3979 ref 627 3968 4198 4202 status 007256 constant entry external dcl 601 test_key 046554 constant entry internal dcl 4018 ref 426 time_string_ 050036 constant entry internal dcl 4161 ref 1908 1908 1923 1923 1926 1926 1926 1926 1947 1947 1950 1950 1950 1950 1977 1977 1983 1983 1992 1992 2020 2020 2023 2023 2029 2029 2057 2057 2061 2061 2077 2077 2081 2081 2093 2093 3423 3423 3427 3427 unlock_volume_pool 050066 constant entry internal dcl 4174 ref 2818 use_key 050164 constant entry internal dcl 4191 ref 432 volume_in_pool 050311 constant entry internal dcl 4211 ref 976 1150 1774 2711 3401 3798 volume_in_volume_set 050442 constant entry internal dcl 4243 ref 1162 yes_to_query 050516 constant entry internal dcl 4266 ref 3350 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 54164 54410 53142 54174 Length 55202 53142 224 555 1022 62 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME manage_volume_pool_ 5728 external procedure is an external procedure. on unit on line 418 64 on unit on unit on line 460 64 on unit on unit on line 481 64 on unit on unit on line 552 64 on unit on unit on line 562 64 on unit on unit on line 575 64 on unit on unit on line 586 64 on unit on unit on line 604 64 on unit on unit on line 624 64 on unit on unit on line 636 64 on unit abort 172 internal procedure is assigned to an entry variable. add internal procedure shares stack frame of external procedure manage_volume_pool_. add_key internal procedure shares stack frame of external procedure manage_volume_pool_. allocate 98 internal procedure is assigned to an entry variable. allocate_key internal procedure shares stack frame of external procedure manage_volume_pool_. append_secondary_volumes internal procedure shares stack frame of external procedure manage_volume_pool_. append_volume_set internal procedure shares stack frame of external procedure manage_volume_pool_. bad_arg internal procedure shares stack frame of external procedure manage_volume_pool_. change 90 internal procedure is assigned to an entry variable. check_first_then_convert internal procedure shares stack frame of external procedure manage_volume_pool_. check_for_errors internal procedure shares stack frame of external procedure manage_volume_pool_. check_for_pvexp internal procedure shares stack frame of external procedure manage_volume_pool_. comment 90 internal procedure is assigned to an entry variable. construct_msg internal procedure shares stack frame of external procedure manage_volume_pool_. convert_volume_pool internal procedure shares stack frame of external procedure manage_volume_pool_. create_pool internal procedure shares stack frame of external procedure manage_volume_pool_. delete internal procedure shares stack frame of external procedure manage_volume_pool_. delete_key internal procedure shares stack frame of external procedure manage_volume_pool_. determine_alloc_version internal procedure shares stack frame of external procedure manage_volume_pool_. evaluate_volumes_wanted internal procedure shares stack frame of external procedure manage_volume_pool_. finish 141 internal procedure is called by several nonquick procedures. format_print_output internal procedure shares stack frame of external procedure manage_volume_pool_. free internal procedure shares stack frame of external procedure manage_volume_pool_. free_key internal procedure shares stack frame of external procedure manage_volume_pool_. free_node internal procedure shares stack frame of external procedure manage_volume_pool_. get_list_names internal procedure shares stack frame of external procedure manage_volume_pool_. get_names_check_switches internal procedure shares stack frame of external procedure manage_volume_pool_. get_next_arg internal procedure shares stack frame of external procedure manage_volume_pool_. get_node internal procedure shares stack frame of external procedure manage_volume_pool_. get_number internal procedure shares stack frame of external procedure manage_volume_pool_. get_volumes_specified internal procedure shares stack frame of external procedure manage_volume_pool_. get_volumes_specified_loop internal procedure shares stack frame of external procedure manage_volume_pool_. insert_node internal procedure shares stack frame of external procedure manage_volume_pool_. last_volume_in_set internal procedure shares stack frame of external procedure manage_volume_pool_. list_key internal procedure shares stack frame of external procedure manage_volume_pool_. lock_required internal procedure shares stack frame of external procedure manage_volume_pool_. lock_volume_pool internal procedure shares stack frame of external procedure manage_volume_pool_. msg 250 internal procedure is assigned to an entry variable. move_into_state_date_order internal procedure shares stack frame of external procedure manage_volume_pool_. move_to_head 66 internal procedure is called by several nonquick procedures. path 140 internal procedure is called by several nonquick procedures. print internal procedure shares stack frame of external procedure manage_volume_pool_. print_secondary_volumes internal procedure shares stack frame of external procedure manage_volume_pool_. process internal procedure shares stack frame of external procedure manage_volume_pool_. process_ctl_args internal procedure shares stack frame of external procedure manage_volume_pool_. pv_expire_key internal procedure shares stack frame of external procedure manage_volume_pool_. pvexp_secondary_vol_check internal procedure shares stack frame of external procedure manage_volume_pool_. pvexp_volume internal procedure shares stack frame of external procedure manage_volume_pool_. query_to_continue internal procedure shares stack frame of external procedure manage_volume_pool_. remove_volume_set internal procedure shares stack frame of external procedure manage_volume_pool_. remove_volume internal procedure shares stack frame of external procedure manage_volume_pool_. reserved_by_another_process internal procedure shares stack frame of external procedure manage_volume_pool_. reserve_key internal procedure shares stack frame of external procedure manage_volume_pool_. reuse internal procedure shares stack frame of external procedure manage_volume_pool_. search internal procedure shares stack frame of external procedure manage_volume_pool_. set_key internal procedure shares stack frame of external procedure manage_volume_pool_. setup internal procedure shares stack frame of external procedure manage_volume_pool_. setup_pool_path internal procedure shares stack frame of external procedure manage_volume_pool_. test_key internal procedure shares stack frame of external procedure manage_volume_pool_. time_string_ 80 internal procedure is called during a stack extension. unlock_volume_pool internal procedure shares stack frame of internal procedure msg. use_key internal procedure shares stack frame of external procedure manage_volume_pool_. volume_in_pool 67 internal procedure is called during a stack extension. volume_in_volume_set internal procedure shares stack frame of external procedure manage_volume_pool_. yes_to_query internal procedure shares stack frame of external procedure manage_volume_pool_. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 vol_ename manage_volume_pool_ 000020 vol_dir manage_volume_pool_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME abort 000100 argp abort 000102 str abort 000202 str_len abort manage_volume_pool_ 000100 Plisted manage_volume_pool_ 000102 Pvolume manage_volume_pool_ 000104 Ptvol manage_volume_pool_ 000106 abort_sw manage_volume_pool_ 000107 ac manage_volume_pool_ 000110 active_fnc manage_volume_pool_ 000111 al manage_volume_pool_ 000112 ala manage_volume_pool_ 000113 all_states manage_volume_pool_ 000114 all_sw manage_volume_pool_ 000115 alloc_sw manage_volume_pool_ 000116 alp manage_volume_pool_ 000120 ap manage_volume_pool_ 000122 apa manage_volume_pool_ 000124 areap manage_volume_pool_ 000126 asterisk_cnt manage_volume_pool_ 000127 asterisk_sw manage_volume_pool_ 000130 bit_count manage_volume_pool_ 000131 brief_sw manage_volume_pool_ 000132 code manage_volume_pool_ 000133 com_len manage_volume_pool_ 000134 com_ptr manage_volume_pool_ 000136 comment_sw manage_volume_pool_ 000137 compare manage_volume_pool_ 000157 dfmt_sw manage_volume_pool_ 000160 ecode manage_volume_pool_ 000161 edt_sw manage_volume_pool_ 000162 expire_len manage_volume_pool_ 000164 expire_ptr manage_volume_pool_ 000166 expire_sw manage_volume_pool_ 000167 first_sw manage_volume_pool_ 000170 first_last_sw manage_volume_pool_ 000171 fexp_sw manage_volume_pool_ 000172 force_sw manage_volume_pool_ 000173 free_sw manage_volume_pool_ 000174 header_output manage_volume_pool_ 000275 header_len manage_volume_pool_ 000276 header_to_be_printed manage_volume_pool_ 000277 header_sw manage_volume_pool_ 000300 ignore manage_volume_pool_ 000301 last_sw manage_volume_pool_ 000302 lock manage_volume_pool_ 000303 match_string manage_volume_pool_ 000324 match_sw manage_volume_pool_ 000325 most_recent manage_volume_pool_ 000326 myname manage_volume_pool_ 000336 name_sw manage_volume_pool_ 000337 narg manage_volume_pool_ 000340 new_vpp manage_volume_pool_ 000342 noaction_msg manage_volume_pool_ 000443 noaction_cnt manage_volume_pool_ 000444 none_sw manage_volume_pool_ 000445 output manage_volume_pool_ 000546 output_len manage_volume_pool_ 000547 pvedt_sw manage_volume_pool_ 000550 pvexp_len manage_volume_pool_ 000552 pvexp_ptr manage_volume_pool_ 000554 pvexp_sw manage_volume_pool_ 000555 requoted_output manage_volume_pool_ 000756 reserve_sw manage_volume_pool_ 000757 retl manage_volume_pool_ 000760 retp manage_volume_pool_ 000762 sdt_sw manage_volume_pool_ 000764 state_dt_clock manage_volume_pool_ 000766 state_dt_len manage_volume_pool_ 000770 state_dt_ptr manage_volume_pool_ 000772 state_dt_sw manage_volume_pool_ 000773 state_sw manage_volume_pool_ 000774 tcnt manage_volume_pool_ 000775 total_cnt manage_volume_pool_ 000776 totals_wanted manage_volume_pool_ 000777 vol_msg_list manage_volume_pool_ 001100 vol_msg_cnt manage_volume_pool_ 001101 volume_cnt manage_volume_pool_ 001102 vs_sw manage_volume_pool_ 001103 vs_size manage_volume_pool_ 001104 specified_states manage_volume_pool_ 001105 svol_sw manage_volume_pool_ 001106 subroutine manage_volume_pool_ 001107 tdir manage_volume_pool_ 001161 tname manage_volume_pool_ 001171 tvlx manage_volume_pool_ 001172 vlx manage_volume_pool_ 001173 vol_cnt manage_volume_pool_ 001174 volume_sw manage_volume_pool_ 001175 volume_state manage_volume_pool_ 001176 vp_bc manage_volume_pool_ 001200 vpp manage_volume_pool_ 001202 word_count manage_volume_pool_ 001203 yes_sw manage_volume_pool_ 001204 vol_list manage_volume_pool_ 003346 volume_pool_header manage_volume_pool_ 003356 volume_pool_entry manage_volume_pool_ 003434 get_arg manage_volume_pool_ 003440 abort_proc manage_volume_pool_ 003444 error_rnt manage_volume_pool_ 003450 msg_proc manage_volume_pool_ 003454 volx manage_volume_pool_ 003512 pv_clock add_key 003514 volx add_key 003515 vol_cnt add_key 003516 i add_key 003526 exp_clock allocate_key 003530 i allocate_key 003531 vol_cnt allocate_key 003532 volx allocate_key 003544 last_vol append_secondary_volumes 003545 next_vol append_secondary_volumes 003554 i append_volume_set 003555 vol_cnt append_volume_set 003556 last_vol append_volume_set 003557 next_vol append_volume_set 003560 primary_idx append_volume_set 003572 keyx bad_arg 003610 error_found check_for_errors 003611 i check_for_errors 003612 volx check_for_errors 003613 just_expired check_for_errors 003632 position construct_msg 003633 check construct_msg 003634 output_msg construct_msg 003735 output_len construct_msg 003744 volume_pool_header_2 convert_volume_pool 003756 volume_pool_entry_2 convert_volume_pool 004054 volx delete_key 004055 i delete_key 004056 vol_cnt delete_key 004070 even_arg determine_alloc_version 004100 i evaluate_volumes_wanted 004101 want_cnt evaluate_volumes_wanted 004102 noaction_cnt evaluate_volumes_wanted 004103 continue evaluate_volumes_wanted 004114 go_ahead format_print_output 004132 found free_key 004133 just_expired free_key 004134 i free_key 004135 volx free_key 004136 vol_idx free_key 004137 vol_cnt free_key 004162 volx get_list_names 004163 vol_idx get_list_names 004172 vidx get_names_check_switches 004210 volx get_node 004220 arg_fb get_number 004230 i get_volumes_specified 004231 vol_idx get_volumes_specified 004232 continue get_volumes_specified 004233 just_expired get_volumes_specified 004234 msg get_volumes_specified 004334 msg_len get_volumes_specified 004360 vol_idx last_volume_in_set 004370 volx list_key 004371 i list_key 004372 get_area list_key 004373 not_in_pool list_key 004406 code lock_required 004407 mode lock_required 004424 voli move_into_state_date_order 004434 printx print 004460 get_area process_ctl_args 004470 primary_idx pv_expire_key 004471 i pv_expire_key 004472 volx pv_expire_key 004473 vol_cnt pv_expire_key 004504 vol_idx pvexp_secondary_vol_check 004514 primary_idx pvexp_volume 004532 done remove_volume_set 004533 just_expired remove_volume_set 004534 found remove_volume_set 004535 i remove_volume_set 004536 volx remove_volume_set 004537 current_idx remove_volume_set 004540 remove_cnt remove_volume_set 004541 prev_idx remove_volume_set 004542 primary_idx remove_volume_set 004543 set_state remove_volume_set 004556 save_idx remove_volume 004574 i reserve_key 004575 vol_cnt reserve_key 004576 volx reserve_key 004577 just_expired reserve_key 004612 i reuse 004613 vol_cnt reuse 004614 volx reuse 004615 just_expired reuse 004636 exp_clock set_key 004640 pv_clock set_key 004642 i set_key 004643 vol_idx set_key 004672 volx test_key 004673 list_cnt test_key 004674 list_no_cnt test_key 004675 vol_cnt test_key 004676 i test_key 004677 yes test_key 004700 no test_key 004701 test_vol_list test_key 005002 test_no_vol_list test_key msg 000100 str msg 000200 argp msg 000202 str_len msg path 000100 pathname path time_string_ 000100 time_char time_string_ volume_in_pool 000100 i volume_in_pool THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_l_a r_g_a r_e_as r_ne_as alloc_char_temp alloc_bit_temp cat_realloc_chars call_ent_var_desc call_ent_var call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other_desc call_int_other return_mac tra_ext_1 mdfx1 enable_op shorten_stack ext_entry ext_entry_desc int_entry int_entry_desc set_chars_eis index_chars_eis index_bs_1_eis any_to_any_truncate_op_alloc_ op_freen_ clock_mac THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. active_fnc_err_ clock_ com_err_ command_query_$yes_no convert_date_to_binary_ cu_$af_arg_ptr_rel cu_$af_return_arg cu_$arg_list_ptr cu_$arg_ptr_rel date_time_ expand_pathname_ get_process_id_ get_ring_ get_system_free_area_ get_temp_segment_ hcs_$fs_get_path_name hcs_$fs_move_seg hcs_$get_user_effmode hcs_$make_seg hcs_$set_bc hcs_$terminate_noname hcs_$truncate_file hcs_$validate_processid initiate_file_ ioa_ ioa_$general_rs ioa_$nnl ioa_$rsnnl release_temp_segment_ requote_string_ set_lock_$lock set_lock_$unlock suffixed_name_$make user_info_ user_info_$homedir THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$action_not_performed error_table_$badopt error_table_$boundviol error_table_$inconsistent error_table_$invalid_lock_reset error_table_$lock_not_locked error_table_$locked_by_this_process error_table_$noarg error_table_$process_unknown error_table_$unimplemented_version LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 168 005041 12 005045 416 005104 417 005105 418 005106 419 005130 420 005151 421 005171 422 005207 423 005221 424 005233 425 005251 426 005267 427 005301 428 005313 429 005325 430 005333 431 005341 432 005353 433 005365 435 005403 437 005421 439 005435 440 005472 441 005536 442 005537 443 005557 446 005563 449 005564 451 005627 452 005631 454 005632 456 005671 457 005673 459 005675 460 005676 461 005720 462 005723 463 005737 464 005741 465 005755 466 005770 468 006002 469 006023 470 006027 471 006045 473 006046 479 006104 480 006106 481 006107 482 006131 483 006136 484 006141 486 006142 487 006143 488 006145 489 006155 490 006157 491 006166 492 006203 493 006211 494 006214 495 006222 496 006235 497 006240 498 006251 499 006252 500 006261 502 006270 505 006271 506 006272 507 006301 510 006310 511 006314 512 006315 515 006316 516 006321 517 006330 518 006343 519 006346 520 006357 521 006360 522 006367 524 006376 527 006377 528 006400 529 006407 532 006416 533 006422 536 006423 537 006427 538 006432 541 006433 542 006436 543 006445 544 006531 545 006544 547 006546 549 006547 550 006577 551 006601 552 006602 553 006624 554 006627 555 006643 556 006654 557 006655 559 006656 560 006703 561 006705 562 006706 563 006730 564 006733 565 006747 566 006760 567 006761 569 006762 573 007011 574 007013 575 007014 576 007036 577 007040 578 007060 579 007071 580 007122 581 007133 583 007134 584 007155 585 007157 586 007160 587 007202 588 007205 589 007211 590 007216 592 007224 593 007232 594 007233 597 007241 598 007246 599 007247 601 007250 602 007306 603 007310 604 007311 605 007333 606 007336 607 007352 608 007363 610 007414 611 007426 612 007432 613 007434 615 007435 619 007464 620 007466 621 007470 622 007472 623 007474 624 007475 625 007517 626 007521 627 007541 628 007545 630 007546 634 007572 635 007574 636 007575 637 007617 638 007651 640 007673 641 007742 643 007743 649 007751 651 007754 652 007762 654 007763 656 007771 657 010036 658 010053 659 010104 665 010110 669 010111 670 010142 671 010144 672 010155 673 010161 674 010167 675 010201 676 010204 677 010205 678 010215 679 010222 680 010224 685 010225 716 010226 718 010251 720 010253 722 010261 723 010303 724 010306 725 010332 728 010353 730 010356 731 010363 732 010371 733 010374 734 010405 736 010406 738 010450 743 010476 744 010505 745 010521 747 010531 748 010533 749 010547 750 010552 751 010556 752 010570 753 010575 754 010577 755 010601 756 010604 757 010606 760 010610 762 010612 763 010627 765 010657 771 010660 776 010666 779 010721 780 010750 781 011006 782 011020 783 011023 784 011027 786 011043 787 011046 789 011047 790 011053 792 011056 793 011101 794 011142 795 011152 800 011153 833 011154 835 011156 837 011164 840 011222 841 011225 842 011251 845 011272 847 011276 848 011300 849 011304 850 011305 851 011322 852 011344 853 011353 857 011354 861 011366 862 011375 864 011437 868 011465 869 011466 870 011475 871 011511 872 011517 873 011524 874 011533 875 011543 876 011546 877 011560 878 011564 879 011566 880 011573 881 011660 882 011743 885 011752 887 011754 888 011757 891 012043 894 012073 898 012074 912 012076 913 012103 914 012105 915 012110 916 012175 917 012204 918 012206 919 012211 921 012217 922 012222 923 012224 924 012226 926 012227 927 012235 928 012237 929 012242 931 012245 935 012246 969 012247 974 012272 975 012274 976 012313 978 012402 984 012451 986 012457 989 012506 991 012512 992 012514 993 012520 994 012521 995 012536 996 012560 997 012565 1002 012566 1005 012576 1006 012603 1008 012645 1012 012673 1013 012674 1014 012676 1015 012705 1016 012721 1017 012727 1018 013013 1019 013021 1020 013027 1021 013033 1022 013035 1023 013044 1024 013053 1025 013061 1026 013070 1027 013073 1028 013075 1029 013155 1030 013156 1031 013164 1032 013166 1035 013172 1037 013174 1038 013202 1040 013210 1041 013213 1045 013262 1048 013312 1052 013313 1063 013324 1064 013331 1065 013350 1066 013352 1072 013360 1076 013366 1077 013420 1078 013461 1079 013473 1080 013502 1086 013503 1092 013504 1100 013513 1101 013515 1102 013516 1105 013517 1108 013545 1112 013637 1113 013644 1116 013670 1120 013671 1144 013673 1145 013674 1146 013675 1147 013722 1149 013745 1150 013755 1151 014010 1152 014020 1153 014032 1154 014036 1155 014124 1157 014126 1159 014127 1161 014140 1162 014147 1163 014203 1164 014216 1165 014222 1166 014310 1167 014312 1168 014353 1172 014354 1173 014364 1174 014376 1175 014402 1176 014470 1177 014472 1180 014473 1181 014501 1182 014510 1183 014512 1184 014524 1185 014530 1186 014616 1187 014620 1188 014660 1192 014661 1193 014671 1194 014676 1195 014711 1196 014715 1197 015003 1198 015005 1202 015006 1203 015015 1204 015025 1205 015037 1206 015043 1207 015131 1208 015133 1210 015134 1211 015136 1212 015150 1213 015154 1214 015242 1215 015244 1218 015245 1219 015247 1220 015261 1221 015265 1222 015353 1223 015355 1226 015356 1227 015364 1228 015372 1229 015374 1230 015377 1231 015412 1233 015413 1235 015414 1236 015426 1237 015431 1238 015434 1239 015440 1240 015526 1241 015530 1243 015531 1245 015532 1246 015536 1247 015624 1248 015626 1254 015627 1255 015646 1256 015660 1257 015664 1258 015752 1259 015754 1262 015755 1263 015767 1264 016001 1265 016005 1266 016073 1267 016075 1270 016076 1271 016110 1272 016122 1273 016126 1274 016214 1275 016216 1278 016217 1279 016231 1280 016243 1281 016247 1282 016335 1283 016337 1286 016340 1287 016355 1288 016367 1289 016373 1290 016461 1291 016463 1294 016464 1295 016467 1296 016471 1297 016474 1298 016507 1302 016513 1305 016515 1307 016517 1311 016520 1323 016522 1325 016526 1326 016534 1327 016557 1328 016562 1329 016651 1330 016653 1331 016654 1332 016662 1333 016750 1335 016752 1336 016760 1340 016765 1346 016766 1350 016774 1351 017026 1352 017051 1353 017104 1357 017105 1368 017107 1369 017114 1370 017121 1371 017124 1375 017202 1380 017274 1381 017307 1384 017363 1385 017364 1388 017435 1389 017447 1390 017453 1391 017460 1393 017461 1397 017462 1464 017463 1468 017503 1472 017522 1475 017535 1476 017537 1480 017606 1481 017642 1482 017663 1485 017730 1486 017732 1488 017734 1490 017737 1491 017742 1492 017744 1493 017746 1494 017750 1496 017752 1497 017761 1498 017774 1499 020000 1500 020002 1501 020012 1502 020017 1503 020021 1504 020032 1505 020036 1506 020041 1507 020043 1508 020045 1509 020054 1510 020063 1512 020072 1513 020103 1514 020107 1515 020113 1516 020117 1517 020120 1518 020122 1521 020123 1524 020125 1525 020127 1526 020132 1527 020134 1529 020140 1530 020147 1531 020162 1532 020166 1533 020170 1534 020200 1535 020205 1536 020217 1537 020221 1538 020237 1539 020243 1540 020245 1541 020252 1542 020260 1543 020266 1544 020271 1545 020273 1548 020274 1549 020276 1550 020301 1551 020303 1553 020307 1555 020311 1556 020313 1557 020314 1558 020315 1559 020316 1560 020320 1561 020325 1562 020332 1564 020333 1565 020343 1566 020356 1567 020362 1568 020365 1569 020417 1570 020421 1571 020434 1575 020470 1576 020504 1577 020517 1578 020521 1579 020537 1580 020543 1581 020545 1582 020552 1583 020560 1584 020566 1585 020571 1589 020573 1590 020601 1591 020606 1592 020613 1594 020614 1596 020621 1598 020640 1600 020705 1601 020727 1608 020730 1610 020731 1611 020766 1612 020770 1613 021037 1614 021106 1615 021110 1616 021114 1617 021121 1618 021126 1619 021127 1620 021131 1621 021132 1623 021133 1626 021202 1630 021203 1634 021204 1635 021235 1637 021272 1638 021274 1643 021275 1673 021276 1675 021321 1676 021327 1678 021356 1679 021360 1680 021401 1681 021405 1682 021411 1683 021415 1684 021417 1685 021434 1686 021456 1689 021463 1692 021475 1693 021477 1694 021501 1695 021502 1696 021504 1698 021521 1699 021531 1700 021544 1701 021562 1702 021606 1703 021607 1706 021611 1707 021616 1708 021624 1709 021627 1710 021640 1712 021641 1714 021703 1720 021731 1721 021741 1722 021755 1723 021763 1724 021770 1725 021777 1728 022001 1730 022003 1731 022020 1733 022050 1737 022051 1754 022052 1758 022075 1759 022116 1763 022124 1766 022132 1767 022133 1768 022143 1769 022162 1773 022224 1774 022226 1775 022255 1776 022256 1777 022263 1778 022266 1784 022270 1786 022275 1788 022276 1790 022277 1796 022300 1825 022311 1826 022324 1827 022340 1828 022343 1831 022344 1835 022367 1836 022371 1837 022374 1838 022375 1839 022376 1840 022406 1841 022425 1842 022426 1844 022436 1846 022440 1847 022443 1848 022450 1850 022451 1853 022476 1856 022506 1860 022507 1862 022515 1863 022520 1864 022524 1865 022531 1866 022533 1867 022557 1868 022627 1869 022655 1872 022725 1875 022740 1876 022760 1877 023000 1879 023020 1883 023021 1893 023023 1894 023025 1895 023032 1897 023045 1898 023046 1902 023050 1903 023064 1904 023071 1905 023115 1907 023116 1908 023161 1914 023320 1916 023321 1918 023334 1919 023341 1921 023371 1923 023372 1926 023464 1940 024000 1942 024001 1943 024012 1944 024017 1945 024043 1947 024044 1950 024136 1964 024407 1966 024410 1967 024413 1968 024420 1971 024467 1974 024470 1975 024473 1977 024611 1980 024710 1983 025002 1992 025164 2003 025374 2017 025651 2019 025653 2020 025656 2021 025724 2023 026015 2029 026133 2038 026327 2039 026336 2040 026413 2050 026614 2052 026615 2054 026616 2055 026621 2057 026676 2061 027010 2068 027126 2074 027237 2076 027241 2077 027244 2081 027332 2085 027444 2090 027534 2092 027536 2093 027544 2097 027627 2100 027713 2102 027715 2103 027723 2107 027767 2111 027770 2115 027771 2116 030022 2117 030057 2118 030065 2119 030071 2120 030077 2125 030100 2156 030101 2160 030124 2162 030132 2167 030171 2169 030174 2170 030177 2171 030214 2173 030255 2174 030265 2175 030273 2176 030277 2177 030305 2178 030307 2179 030312 2180 030313 2181 030327 2182 030336 2187 030347 2188 030351 2190 030373 2193 030400 2194 030403 2195 030405 2196 030410 2197 030425 2199 030450 2200 030461 2201 030473 2202 030475 2203 030500 2204 030501 2205 030515 2206 030524 2209 030535 2210 030537 2212 030565 2213 030572 2215 030573 2216 030620 2217 030627 2218 030657 2219 030661 2222 030707 2226 030710 2229 030724 2230 030731 2232 030773 2237 031026 2238 031027 2239 031037 2240 031053 2241 031061 2242 031066 2243 031075 2244 031161 2245 031167 2246 031171 2247 031176 2249 031271 2252 031300 2254 031302 2255 031305 2258 031371 2261 031421 2265 031422 2274 031424 2276 031430 2277 031432 2278 031433 2279 031434 2280 031435 2281 031437 2282 031444 2283 031451 2286 031452 2287 031455 2288 031460 2289 031466 2290 031467 2291 031471 2292 031474 2293 031502 2295 031503 2296 031512 2301 031522 2302 031527 2303 031534 2304 031536 2306 031540 2312 031541 2334 031543 2335 031550 2336 031551 2337 031554 2338 031563 2339 031600 2340 031601 2341 031617 2342 031625 2344 031636 2345 031643 2346 031644 2348 031645 2349 031647 2350 031652 2351 031657 2352 031675 2353 031713 2354 031721 2355 031732 2357 031734 2358 031741 2361 031742 2365 031743 2375 031745 2376 031760 2377 031762 2380 031771 2382 032006 2383 032012 2385 032022 2387 032025 2388 032036 2391 032046 2392 032051 2393 032056 2396 032076 2403 032104 2411 032115 2412 032121 2413 032161 2415 032162 2416 032163 2418 032203 2422 032204 2429 032206 2430 032211 2431 032214 2432 032216 2433 032222 2434 032227 2435 032234 2438 032241 2443 032244 2450 032246 2451 032254 2452 032255 2453 032274 2454 032310 2455 032320 2456 032342 2459 032346 2460 032350 2467 032354 2491 032365 2492 032366 2493 032374 2494 032377 2495 032407 2496 032410 2497 032415 2498 032416 2500 032417 2501 032422 2502 032431 2503 032432 2504 032437 2507 032440 2509 032445 2513 032535 2515 032540 2516 032541 2519 032615 2520 032620 2551 032662 2527 032663 2529 032664 2530 032676 2531 032705 2532 032711 2533 032713 2534 032716 2535 032717 2536 032730 2537 032743 2539 032754 2541 032755 2542 032756 2543 032772 2544 033000 2549 033011 2555 033012 2563 033014 2564 033022 2565 033024 2566 033033 2567 033040 2568 033042 2570 033043 2575 033044 2582 033046 2583 033060 2584 033063 2585 033073 2586 033074 2587 033075 2593 033101 2601 033102 2602 033130 2603 033132 2604 033134 2605 033144 2607 033162 2608 033165 2609 033167 2610 033173 2611 033176 2612 033260 2614 033262 2615 033264 2616 033276 2618 033300 2619 033305 2620 033306 2625 033307 2626 033310 2627 033312 2628 033321 2629 033340 2630 033346 2631 033347 2632 033365 2633 033415 2634 033417 2635 033430 2636 033431 2637 033435 2638 033444 2639 033445 2640 033446 2641 033462 2642 033471 2643 033472 2644 033473 2645 033503 2646 033514 2647 033515 2648 033516 2649 033532 2650 033541 2651 033542 2652 033543 2653 033556 2654 033566 2655 033574 2656 033576 2657 033577 2658 033607 2659 033612 2660 033614 2661 033616 2662 033617 2663 033627 2664 033631 2665 033633 2666 033634 2667 033647 2668 033662 2669 033675 2670 033710 2671 033727 2672 033736 2673 033752 2674 033771 2675 034004 2676 034024 2677 034034 2678 034036 2679 034045 2681 034046 2682 034050 2683 034051 2684 034053 2686 034070 2687 034072 2688 034073 2690 034104 2692 034106 2697 034216 2702 034323 2703 034347 2705 034365 2708 034404 2709 034406 2710 034407 2711 034417 2713 034453 2714 034455 2715 034545 2717 034547 2718 034551 2719 034555 2721 034556 2722 034563 2723 034570 2724 034571 2725 034606 2726 034630 2727 034632 2728 034654 2729 034663 2730 034711 2731 034713 2734 034714 2735 034717 2736 034723 2737 034725 2738 034732 2741 034733 2742 034735 2744 034761 2745 035004 2747 035037 2750 035040 2751 035063 2754 035112 2760 035113 2769 035115 2770 035116 2773 035160 2774 035226 2775 035273 2778 035306 2785 035314 2789 035315 2790 035316 2791 035332 2793 035334 2794 035341 2795 035345 2798 035406 2799 035411 2803 035412 2815 035420 2816 035423 2817 035433 2818 035434 2821 035437 2822 035446 2823 035513 2825 035572 2826 035623 2828 035632 2833 035633 2843 035635 2846 035645 2847 035650 2848 035654 2849 035663 2850 035664 2851 035667 2852 035673 2853 035702 2855 035703 2856 035713 2859 035723 2861 035745 2863 035750 2864 035753 2865 035756 2866 035763 2867 035770 2868 035775 2869 035777 2870 036000 2871 036003 2872 036005 2873 036012 2874 036017 2875 036024 2876 036026 2878 036027 2879 036036 2880 036043 2881 036050 2884 036052 2888 036053 2896 036061 2897 036071 2898 036075 2899 036100 2900 036104 2902 036112 2903 036125 2904 036132 2905 036137 2906 036144 2908 036146 2915 036147 2922 036170 2923 036242 2928 036250 2936 036252 2937 036254 2939 036261 2942 036270 2944 036277 2945 036304 2947 036307 2949 036312 2950 036316 2953 036321 2954 036324 2955 036331 2960 036342 2962 036344 2964 036360 2965 036365 2966 036425 2967 036436 2968 036450 2970 036451 2971 036454 2972 036473 2974 036475 2976 036516 2979 036517 2981 036527 2987 036530 2995 036532 2997 036537 2998 036544 2999 036550 3000 036560 3001 036566 3002 036573 3003 036602 3004 036642 3005 036653 3006 036665 3007 036666 3009 036707 3010 036715 3012 036716 3017 036717 3023 036721 3024 036741 3025 036743 3026 036747 3027 036766 3028 037011 3029 037024 3030 037032 3031 037033 3032 037051 3034 037075 3035 037102 3036 037103 3037 037104 3042 037105 3077 037107 3078 037111 3079 037112 3080 037113 3081 037115 3083 037117 3084 037127 3085 037146 3086 037160 3087 037167 3088 037171 3090 037202 3092 037203 3093 037213 3094 037222 3095 037224 3097 037225 3098 037235 3099 037244 3100 037256 3101 037264 3103 037265 3104 037275 3105 037304 3106 037311 3107 037313 3108 037321 3110 037322 3111 037326 3112 037335 3113 037337 3114 037341 3115 037342 3117 037343 3118 037353 3119 037362 3120 037364 3121 037366 3123 037367 3124 037377 3125 037406 3126 037410 3127 037415 3129 037416 3130 037426 3131 037435 3132 037437 3134 037440 3135 037450 3136 037457 3137 037461 3139 037462 3140 037472 3141 037501 3142 037503 3144 037504 3145 037514 3146 037523 3147 037525 3149 037536 3151 037537 3152 037547 3153 037556 3154 037560 3155 037565 3157 037566 3158 037572 3159 037601 3160 037603 3162 037604 3163 037620 3164 037627 3165 037631 3167 037632 3168 037646 3169 037655 3170 037657 3172 037660 3173 037664 3174 037673 3175 037674 3176 037712 3177 037742 3178 037744 3179 037755 3181 037756 3182 037766 3183 037775 3184 037777 3187 040000 3188 040002 3189 040003 3190 040005 3192 040022 3193 040024 3194 040026 3196 040037 3198 040041 3200 040042 3203 040070 3207 040071 3238 040072 3242 040115 3244 040123 3246 040145 3248 040154 3249 040162 3250 040170 3251 040173 3252 040204 3254 040205 3256 040247 3261 040275 3262 040305 3263 040321 3264 040327 3265 040334 3266 040343 3267 040350 3268 040352 3269 040355 3270 040357 3271 040363 3272 040367 3273 040371 3274 040372 3276 040374 3279 040402 3281 040404 3282 040421 3284 040451 3290 040452 3297 040454 3298 040456 3299 040471 3301 040502 3302 040504 3303 040507 3304 040532 3305 040534 3307 040535 3313 040543 3320 040545 3321 040553 3322 040557 3323 040562 3324 040564 3325 040570 3326 040574 3327 040576 3328 040577 3330 040601 3332 040610 3337 040611 3348 040627 3349 040642 3350 040652 3351 040673 3357 040674 3394 040675 3399 040720 3400 040722 3401 040741 3403 041030 3409 041077 3411 041105 3412 041113 3414 041115 3415 041143 3418 041172 3420 041203 3422 041216 3423 041221 3426 041270 3427 041271 3433 041335 3434 041337 3435 041352 3436 041367 3438 041431 3440 041441 3443 041443 3444 041456 3445 041472 3446 041502 3447 041513 3448 041516 3450 041520 3451 041523 3452 041546 3453 041555 3455 041610 3457 041612 3460 041613 3463 041620 3464 041625 3466 041662 3471 041715 3472 041716 3473 041720 3474 041731 3475 041734 3476 041735 3477 041740 3478 041750 3479 041751 3480 041763 3481 042016 3482 042020 3484 042024 3485 042026 3487 042032 3489 042033 3490 042045 3491 042047 3492 042052 3494 042053 3495 042056 3496 042060 3535 042113 3501 042114 3508 042115 3510 042117 3513 042120 3516 042130 3517 042217 3518 042226 3519 042230 3520 042232 3521 042235 3522 042237 3523 042242 3524 042247 3525 042255 3527 042263 3528 042271 3529 042273 3530 042276 3533 042303 3539 042304 3545 042306 3546 042325 3547 042341 3548 042353 3551 042361 3557 042367 3590 042370 3592 042413 3593 042417 3595 042420 3597 042426 3600 042456 3602 042477 3605 042535 3606 042537 3607 042541 3608 042556 3609 042600 3610 042605 3612 042606 3613 042610 3614 042614 3615 042615 3616 042632 3619 042637 3622 042651 3623 042653 3624 042655 3625 042656 3626 042660 3628 042675 3629 042705 3630 042720 3631 042736 3632 042762 3633 042763 3636 042765 3637 042772 3639 043034 3643 043062 3644 043063 3645 043064 3646 043073 3647 043107 3648 043115 3649 043122 3650 043131 3651 043215 3652 043223 3653 043233 3654 043247 3655 043255 3656 043261 3657 043343 3659 043345 3662 043353 3664 043355 3665 043360 3668 043444 3671 043474 3675 043475 3708 043476 3710 043504 3713 043550 3714 043555 3715 043563 3716 043564 3717 043601 3718 043643 3719 043647 3722 043656 3723 043661 3724 043663 3725 043667 3727 043704 3728 043745 3729 043755 3730 043772 3731 044002 3732 044011 3733 044023 3734 044047 3735 044051 3737 044065 3739 044067 3741 044132 3742 044137 3746 044140 3747 044142 3750 044153 3751 044160 3753 044222 3757 044255 3758 044256 3759 044257 3760 044267 3761 044303 3762 044311 3763 044316 3764 044403 3765 044414 3766 044415 3767 044477 3768 044500 3771 044506 3773 044510 3774 044513 3779 044603 3783 044604 3789 044615 3790 044616 3791 044624 3792 044627 3793 044635 3794 044652 3795 044656 3796 044657 3798 044660 3799 044706 3800 044720 3804 044722 3809 044723 3840 044724 3843 044747 3844 044751 3846 044757 3847 045001 3848 045034 3852 045063 3853 045066 3854 045112 3857 045133 3858 045136 3859 045162 3862 045203 3863 045205 3864 045231 3867 045252 3869 045261 3870 045272 3871 045275 3872 045306 3874 045307 3879 045332 3880 045341 3881 045355 3882 045363 3883 045370 3884 045373 3885 045375 3886 045404 3887 045407 3888 045414 3889 045416 3890 045420 3891 045421 3893 045422 3894 045431 3896 045434 3898 045442 3899 045444 3900 045453 3901 045457 3902 045464 3903 045466 3904 045467 3905 045475 3907 045477 3908 045507 3909 045520 3910 045523 3912 045525 3915 045537 3917 045541 3918 045556 3920 045606 3924 045607 3928 045610 3929 045616 3930 045617 3931 045621 3932 045623 3933 045626 3934 045631 3935 045633 3936 045634 3937 045637 3938 045644 3939 045647 3940 045653 3941 045657 3943 045660 3945 045661 3946 045663 3947 045665 3948 045677 3949 045711 3950 045730 3953 046056 3954 046066 3955 046075 3956 046112 3957 046117 3958 046130 3959 046135 3960 046140 3961 046150 3963 046154 3965 046176 3966 046217 3967 046241 3968 046253 3969 046257 3970 046263 3971 046271 3973 046300 3979 046301 3994 046303 3995 046310 3996 046340 3997 046373 4000 046374 4001 046401 4002 046411 4006 046431 4007 046457 4009 046505 4010 046542 4012 046547 4014 046553 4018 046554 4054 046555 4056 046600 4058 046606 4061 046636 4063 046657 4066 046715 4067 046721 4068 046725 4069 046731 4071 046735 4075 047007 4078 047020 4079 047022 4081 047026 4082 047030 4083 047032 4084 047047 4085 047072 4086 047077 4088 047100 4089 047102 4090 047103 4091 047120 4094 047125 4095 047127 4098 047136 4099 047140 4100 047142 4101 047143 4102 047145 4104 047162 4105 047171 4106 047204 4107 047222 4108 047246 4109 047247 4112 047251 4113 047254 4114 047256 4116 047260 4117 047267 4118 047313 4119 047320 4120 047327 4121 047337 4122 047341 4123 047421 4124 047423 4126 047424 4127 047426 4128 047506 4131 047510 4133 047512 4134 047515 4135 047533 4136 047547 4137 047560 4139 047561 4141 047611 4149 047724 4157 050034 4161 050035 4166 050043 4167 050060 4174 050066 4178 050067 4179 050102 4180 050105 4181 050112 4184 050156 4185 050163 4191 050164 4195 050165 4196 050210 4197 050213 4198 050222 4199 050226 4201 050227 4202 050247 4205 050253 4207 050307 4211 050310 4221 050324 4222 050336 4223 050341 4224 050346 4225 050366 4226 050371 4227 050374 4228 050377 4229 050413 4230 050415 4232 050422 4233 050424 4235 050425 4236 050434 4237 050435 4243 050442 4254 050453 4255 050461 4256 050466 4257 050505 4258 050510 4259 050511 4266 050516 4277 050534 4281 050607 4284 050653 ----------------------------------------------------------- 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