COMPILATION LISTING OF SEGMENT rcprm_find_resource_ Compiled by: Multics PL/I Compiler, Release 32f, of October 9, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 11/11/89 0939.6 mst Sat Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* *********************************************************** */ 11 12 13 /* format: style4,delnl,insnl,indattr,ifthen,dclind10 */ 14 rcprm_find_resource_: 15 proc; 16 return; 17 18 /* This procedure is charged with locating specific resources in RCP resource 19* management registries. 20* 21* The register entrypoint makes a certain resource known to the system so that 22* it may be referred to by name. 23* 24* The deregister entrypoint removes a certain resource from the registries so 25* that it may no longer be used by any process. 26* 27* The acquire entrypoint finds a free resource that meets or exceeds given 28* criteria, and "acquires it to" the calling process such that this process 29* now owns/controls and is the "resource executive" for the resource. 30* 31* The release entrypoint relinquishes a resource back to the free pool, 32* providing the requestor is the owner (not just a resource executive.) 33* 34* The reserve entrypoint finds a resource that meets or exceeds the given 35* criteria, and belongs to the "system pool". The resource is then 36* temporarily allocated for the use of the calling process. This implements a 37* variant of a "scratch tape" facility. Note that this entrypoint does NOT 38* perform the actual RCP reservation, but only locates a resource suitable for 39* such a reservation in the case where the requestor does not specify a 40* resource which already belongs to him. 41* 42* The status entrypoint will find a resource given its name or UID, and return 43* all the information about it that a user needs to (or is allowed to) know. 44* 45* The set entrypoint will find a resource given its name or UID, and replace 46* various properties of it (depending on your privilege and access). 47* 48* The clear entrypoint is used to confirm to resource management that a volume 49* that has been released has had its contents destroyed (via degaussing or 50* whatever) and can return to the free pool to be acquired by someone else. 51* This is only necessary of the volume is to be locked on release, as noted 52* in the RTDT. 53* 54* The reconstruct entrypoint does all of the above things. It is used solely 55* by rcprm_journalize_$reconstruct. It includes the proper action code. 56* The main difference is that we don't try to grab the transaction control 57* file because we know it's mylocked. 58**/ 59 60 /* Written 05/09/78 by C. D. Tavares */ 61 /* Modified 11/21/79 by CDT to make privileged release use the real 62* owner's name, not that of the releaser. */ 63 /* Modified 12/10/79 by CDT to take advantage of new facility to sleep in ring 64* 1 */ 65 /* Modified 02/27/80 by CDT to make scratch selection match on potential 66* attributes, not current attributes; and to disable setting of current 67* attributes in contexts where the desired_attribute field is used only as a 68* search criterion (i.e. in an acquisition by attributes instead of by name */ 69 /* Modified 06/17/81 by CDT to detect multiple requests for same resource 70* in same call, and to complain about attempt to change owner in set entry */ 71 /* Modified 04/83 by B. Braun to: 72* 1. correct problem of RQO in the process_dir (phx11736, phx14452). 73* 2. prevent damage to the registry during aquistion of resources by 74* locking the registry record upon modification (phx11638, phx13502). 75* 3. decrement the ref_count on free key when deregistering a resource 76* (phx11636). */ 77 /* Modified 1/85 by Maria Pozzo and Chris Jones for B2 effort. */ 78 79 /****^ HISTORY COMMENTS: 80* 1) change(87-06-08,Rauschelbach), approve(87-06-26,MCR7713), 81* audit(87-07-08,Farley), install(87-07-15,MR12.1-1041): 82* Fixes: 83* 1) No longer returns awaiting-clear state for resources to which 84* the user does not have access. 85* 2) The clear operation now functions. 86* 3) A catch for when operation-type is not handled was added. 87* 4) Error reporting now returns error_table_$action_not_performed for the 88* global error code. 89* 5) Error code in the structure is now set when an error occurred on a 90* specific resource. 91* 2) change(87-07-14,Rauschelbach), approve(87-08-07,MCR7748), 92* audit(87-11-11,Farley), install(87-11-30,MR12.2-1004): 93* Removed signal to vfile_error condition as it was erroneously left in from 94* debugging. 95* END HISTORY COMMENTS */ 96 97 /* automatic */ 98 99 dcl action fixed bin; 100 dcl audit_obj_ok bit (1); 101 dcl auto_registration bit (1) aligned initial (""b); 102 dcl base_rno fixed bin; 103 dcl base_given_uid bit (1); 104 dcl base_given_name bit (1); 105 dcl base_uid bit (36); 106 dcl base_name char (32); 107 dcl base_type char (32); 108 dcl bl fixed bin (21); 109 dcl bp pointer; 110 dcl callers_rdp ptr; 111 dcl clear_ok bit (1); 112 dcl code fixed bin (35); 113 dcl cur_level fixed bin; 114 dcl requestor_owner_id char (32) varying; 115 dcl current_rew bit (3); 116 dcl found bit (1) aligned; 117 dcl is_volume bit (1); 118 dcl lock_sw bit (1) aligned; 119 dcl old_key char (256) varying; 120 dcl operation bit (36) aligned; 121 dcl operation_ptr ptr; 122 dcl priv_sw bit (1) aligned initial ("0"b); 123 dcl prev_level fixed bin; 124 dcl proxy_authorization bit (72) aligned; 125 dcl proxy_call bit (1) aligned initial ("0"b); 126 dcl proxy_group_id char (32); 127 dcl read_key char (256) varying; 128 dcl rec_len fixed bin (21); 129 dcl reconstruct_operation bit (1) aligned initial ("0"b); 130 dcl record_descrip fixed bin (35); 131 dcl registry_dir char (64); 132 dcl registry_open char (32); 133 dcl reserver_info_ptr ptr; 134 dcl resource_type char (32) defined (registry_open); 135 dcl rno fixed bin; 136 dcl seek_attr_flag bit (1) aligned; 137 dcl simple_code fixed bin (35); 138 dcl sstruc_ptr pointer; 139 dcl swno fixed bin; 140 dcl temp_acs_path char (168); 141 dcl temp_atts (2) bit (72) aligned based (addr (temp_relatts)); 142 dcl temp_bounds (2) bit (72) aligned; 143 dcl temp_bounds_based (2) bit (72) aligned based; 144 dcl temp_key char (256) varying; 145 dcl temp_non_var_key char (256); 146 dcl temp_owner_name char (32); 147 dcl temp_relatts (4) bit (72) aligned; 148 dcl temp_mode bit (3); 149 dcl transaction_time fixed bin (71); 150 dcl tsw_ptr pointer; 151 dcl validity fixed bin; 152 dcl who_am_i char (32); 153 154 dcl 1 en_access_op like encoded_access_op based (operation_ptr) aligned; 155 dcl 1 record_status aligned automatic like rs_info; 156 dcl 1 rs aligned automatic like rs_info; 157 dcl 1 res_info aligned automatic like resource_info; 158 dcl 1 req_info aligned automatic like requestor_info; 159 160 dcl 1 add_key_info automatic, 161 2 header like ak_header, 162 2 key char (256); 163 164 dcl 1 get_key_info automatic, 165 2 header like gk_header, 166 2 key char (256); 167 168 /* static */ 169 170 dcl my_owner_id char (32) varying static initial (""); 171 dcl my_group_id char (32) static initial (""); 172 173 dcl ( 174 Absolute initial (0), 175 Relative initial (1) 176 ) fixed bin static options (constant); 177 178 dcl (Move_rel, Equal) initial (0) fixed bin static options (constant); 179 180 dcl Lowest_Aim_Range (2) fixed bin (71) aligned static options (constant) initial ((2)0); 181 182 dcl sys_areap pointer static initial (null); 183 184 /* entries */ 185 186 dcl absolute_pathname_$add_suffix 187 entry (char (*), char (*), char (*), fixed bin (35)); 188 dcl admin_gate_$syserr ext entry options (variable); 189 dcl admin_gate_$syserr_error_code 190 ext entry options (variable); 191 dcl cu_$level_get ext entry (fixed bin); 192 dcl cu_$level_set ext entry (fixed bin); 193 dcl cv_rcp_attributes_$make_rel 194 ext entry (char (*), (2) bit (72) aligned, (4) bit (72) aligned, fixed bin (35)); 195 dcl cv_rcp_attributes_$modify_rel 196 ext entry ((2) bit (72) aligned, (4) bit (72) aligned, (2) bit (72) aligned); 197 dcl cv_rcp_attributes_$test_valid 198 ext entry (char (*), (2) bit (72) aligned, fixed bin, fixed bin (35)); 199 dcl rcprm_find_op ext 200 entry (fixed bin, ptr, bit (1) aligned, bit (1) aligned, bit (36) aligned, 201 bit (1) aligned, fixed bin (35)); 202 dcl hcs_$get_authorization ext entry (bit (72) aligned, bit (72) aligned); 203 dcl get_process_authorization_ 204 ext entry returns (bit (72) aligned); 205 dcl get_group_id_ ext entry returns (char (32)); 206 dcl get_ring_ ext entry returns (fixed bin); 207 dcl get_system_free_area_ ext entry returns (pointer); 208 dcl admin_gate_$make_uid ext entry (bit (36) aligned); 209 dcl rcp_access_kernel_ entry (bit (36) aligned, ptr, ptr, bit (3), fixed bin (35)); 210 dcl rcp_audit entry (char (*), bit (36) aligned, ptr, ptr, char (*), bit (3), bit (3), 211 (2) fixed bin (3), bit (1), fixed bin (35)); 212 dcl rcp_compute_aim_mode$permissible_aim 213 entry ((2) bit (72) aligned, (2) bit (72) aligned, fixed bin (35)); 214 dcl resource_info_$get_type 215 entry (char (*), bit (1), fixed bin (35)); 216 dcl resource_info_$lock_on_release 217 ext entry (char (*), bit (1) aligned, fixed bin (35)); 218 dcl resource_info_$canonicalize_name 219 entry (char (*) aligned, char (*) aligned, char (*) aligned, fixed bin (35)); 220 dcl resource_info_$default_attributes 221 ext entry (char (*) aligned, bit (72) aligned, fixed bin (35)); 222 dcl resource_info_$set_arbitrary_attributes 223 ext entry (char (*), bit (72) aligned, (2) bit (72) aligned, fixed bin (35)); 224 225 dcl rcp_reserve_$approve_schedule 226 ext entry (pointer, fixed bin, char (*), pointer, bit (18) unaligned, fixed bin (35)); 227 dcl rcp_cancel_id_$remove_schedule 228 ext entry (pointer, fixed bin, char (*), pointer, bit (18) unaligned, fixed bin (35)); 229 dcl rcprm_journalize_ ext entry (pointer, fixed bin, fixed bin (71), char (*)); 230 dcl rcprm_registry_util_$grab_transaction_control_file 231 entry (ptr, char (*), fixed bin (35)); 232 dcl rcprm_registry_util_$grab_registry 233 entry (ptr, char (*), char (*), fixed bin (35)); 234 dcl rcprm_registry_util_$release_transaction_control_file 235 entry (ptr, fixed bin (35)); 236 dcl rcprm_registry_util_$release_registry 237 entry (ptr, fixed bin (35)); 238 dcl rcprm_registry_util_$free_key 239 entry (ptr, char (*)); 240 dcl rcprm_registry_util_$system_key 241 entry (ptr, char (*)); 242 dcl rcprm_registry_util_$name_key 243 entry (char (*), ptr, char (*)); 244 dcl rcprm_registry_util_$owner_key 245 entry (char (*), ptr, char (*)); 246 dcl rcprm_registry_util_$uid_key 247 entry (bit (36) aligned, ptr, char (*)); 248 249 /* external variables */ 250 251 dcl ( 252 error_table_$action_not_performed, 253 error_table_$resource_awaiting_clear, 254 error_table_$bad_resource_spec, 255 error_table_$duplicate_request, 256 error_table_$end_of_info, 257 error_table_$namedup, 258 error_table_$no_record, 259 error_table_$not_abs_path, 260 error_table_$not_privileged, 261 error_table_$not_seg_type, 262 error_table_$rcp_attr_not_permitted, 263 error_table_$rcp_bad_attributes, 264 error_table_$resource_bad_access, 265 error_table_$resource_free, 266 error_table_$resource_locked, 267 error_table_$resource_not_free, 268 error_table_$resource_unavailable, 269 error_table_$resource_unknown, 270 error_table_$unimplemented_version, 271 error_table_$unsupported_operation 272 ) ext fixed bin (35) static; 273 274 dcl sys_info$max_seg_size fixed bin (35) ext static; 275 276 /* based variables */ 277 278 dcl based_bits bit (bl * 9) aligned based (bp); 279 dcl based_charstring char (bl) aligned based (bp); 280 dcl sys_area based (sys_areap) area (sys_info$max_seg_size); 281 282 dcl potential_attributes_based 283 bit (72) based; 284 285 dcl 1 switch_struc aligned based (sstruc_ptr), 286 2 maxno fixed bin, 287 2 usedno fixed bin initial (0), 288 2 xxx (resource_descriptions.n_items refer (switch_struc.maxno)) aligned, 289 3 registry char (32), 290 3 sw_ptr pointer; 291 292 /* builtins and conditions */ 293 294 dcl cleanup condition; 295 296 dcl (addr, clock, length, null, rtrim, size, string, substr, unspec) 297 builtin; 298 299 priv_acquire: 300 entry (p_resource_desc_ptr, p_registry_dir, p_code); 301 302 priv_sw = "1"b; 303 304 acquire: 305 entry (p_resource_desc_ptr, p_registry_dir, p_code); 306 307 dcl p_resource_desc_ptr ptr parameter; 308 dcl p_registry_dir char (*) parameter; 309 dcl p_code fixed bin (35) parameter; 310 311 action = Acquire; 312 who_am_i = "rcprm_find_resource_$acquire"; 313 goto common_2; 314 315 priv_release: 316 entry (p_resource_desc_ptr, p_registry_dir, p_code); 317 318 priv_sw = "1"b; 319 320 release: 321 entry (p_resource_desc_ptr, p_registry_dir, p_code); 322 323 action = Release; 324 who_am_i = "rcprm_find_resource_$release"; 325 goto common_2; 326 327 clear: 328 entry (p_resource_desc_ptr, p_registry_dir, p_code); 329 330 action = Clear; 331 priv_sw = "1"b; 332 who_am_i = "rcprm_find_resource_$clear"; 333 goto common_2; 334 335 priv_reserve: 336 entry (p_resource_desc_ptr, p_registry_dir, p_reserver_info_ptr, p_code); 337 338 dcl p_reserver_info_ptr pointer parameter; /* reserver passes this, what it is is up to him */ 339 340 priv_sw = "1"b; 341 342 reserve: 343 entry (p_resource_desc_ptr, p_registry_dir, p_reserver_info_ptr, p_code); 344 345 action = Reserve; 346 who_am_i = "rcprm_find_resource_$reserve"; 347 goto common_1; 348 349 reserve_proxy: 350 entry (p_resource_desc_ptr, p_registry_dir, p_reserver_info_ptr, p_proxy_group_id, p_proxy_authorization, p_code); 351 352 dcl p_proxy_group_id char (*) parameter; 353 dcl p_proxy_authorization bit (72) aligned parameter; 354 355 action = Reserve; 356 proxy_call = "1"b; 357 proxy_group_id = p_proxy_group_id; 358 proxy_authorization = p_proxy_authorization; 359 who_am_i = "rcprm_find_resource_$reserve"; 360 goto common_1; 361 362 priv_cancel: 363 entry (p_resource_desc_ptr, p_registry_dir, p_reserver_info_ptr, p_code); 364 365 priv_sw = "1"b; 366 367 cancel: 368 entry (p_resource_desc_ptr, p_registry_dir, p_reserver_info_ptr, p_code); 369 370 action = Cancel; 371 who_am_i = "rcprm_find_resource_$cancel"; 372 goto common_1; 373 374 priv_status: 375 entry (p_resource_desc_ptr, p_registry_dir, p_code); 376 377 priv_sw = "1"b; 378 379 status: 380 entry (p_resource_desc_ptr, p_registry_dir, p_code); 381 382 action = Status; 383 who_am_i = "rcprm_find_resource_$status"; 384 goto common_2; 385 386 priv_set: 387 entry (p_resource_desc_ptr, p_registry_dir, p_code); 388 389 priv_sw = "1"b; 390 391 set: 392 entry (p_resource_desc_ptr, p_registry_dir, p_code); 393 394 action = Set; 395 who_am_i = "rcprm_find_resource_$status"; 396 goto common_2; 397 398 auto_register: 399 entry (p_resource_desc_ptr, p_registry_dir, p_code); 400 401 auto_registration = "1"b; 402 403 register: 404 entry (p_resource_desc_ptr, p_registry_dir, p_code); 405 406 priv_sw = "1"b; 407 action = Register; 408 who_am_i = "rcprm_find_resource_$register"; 409 goto common_2; 410 411 deregister: 412 entry (p_resource_desc_ptr, p_registry_dir, p_code); 413 414 priv_sw = "1"b; 415 action = Deregister; 416 who_am_i = "rcprm_find_resource_$deregister"; 417 goto common_2; 418 419 reconstruct: 420 entry (p_resource_desc_ptr, p_registry_dir, p_action, p_tsw_ptr, p_code); 421 422 dcl p_action fixed bin parameter; 423 dcl p_tsw_ptr pointer parameter; 424 425 priv_sw = "1"b; 426 action = p_action; 427 reconstruct_operation = "1"b; 428 who_am_i = "rcprm_find_resource_$reconstruct"; 429 goto common_2; 430 431 common_1: 432 reserver_info_ptr = p_reserver_info_ptr; 433 434 common_2: 435 audit_obj_ok = "0"b; /* For auditing purposes, different audit calls depending on if we have retrieved the object (if it exists), etc. */ 436 registry_dir = p_registry_dir; 437 operation = ""b; 438 operation_ptr = addr (operation); 439 ops_ptr = addr (en_access_op.detailed_operation); 440 seek_attr_flag = "0"b; 441 code = 0; 442 443 call cu_$level_get (prev_level); 444 tsw_ptr, ak_info_ptr, gk_info_ptr, sstruc_ptr, resource_desc_ptr = null; 445 registry_open = ""; 446 447 unspec (record_status) = ""b; 448 record_status.version = rs_info_version_2; 449 record_status.record_ptr = null (); 450 record_ptr = null (); 451 452 if sys_areap = null then 453 sys_areap = get_system_free_area_ (); 454 if my_owner_id = "" then do; 455 my_group_id = get_group_id_ (); 456 my_owner_id = rtrim (my_group_id); 457 my_owner_id = substr (my_owner_id, 1, length (my_owner_id) - 2); 458 end; 459 460 if ^proxy_call then 461 requestor_owner_id = my_owner_id; 462 else do; 463 requestor_owner_id = proxy_group_id; 464 requestor_owner_id = rtrim (requestor_owner_id); 465 requestor_owner_id = substr (requestor_owner_id, 1, length (requestor_owner_id) - 2); 466 end; 467 468 on cleanup call clean_up (0, ""b); 469 470 /* ------------------------- */ 471 472 clean_up: 473 proc (code, error_matters); 474 475 dcl code fixed bin (35) parameter; 476 dcl error_matters bit (1) aligned parameter; 477 478 dcl i fixed bin; 479 dcl saved_code fixed bin (35); 480 481 saved_code = 0; 482 if tsw_ptr ^= null then do; 483 do i = 1 to switch_struc.usedno; 484 if sw_ptr (i) ^= null then do; 485 if ^error_matters then do; /* real abort, roll back */ 486 call iox_$control (sw_ptr (i), "rollback", null, code); 487 call save_code_if_error; 488 end; 489 call rcprm_registry_util_$release_registry (sw_ptr (i), code); 490 call save_code_if_error; 491 end; 492 end; 493 if ^reconstruct_operation then do; 494 call rcprm_registry_util_$release_transaction_control_file (tsw_ptr, code); 495 call save_code_if_error; 496 end; 497 end; 498 if sstruc_ptr ^= null then do; 499 free switch_struc; 500 sstruc_ptr = null (); 501 end; 502 if resource_desc_ptr ^= null () then do; 503 free resource_descriptions; 504 resource_desc_ptr = null (); 505 end; 506 507 if error_matters then 508 code = saved_code; 509 510 call cu_$level_set (prev_level); 511 return; 512 513 save_code_if_error: 514 proc; 515 516 if saved_code = 0 then 517 saved_code = code; 518 519 end save_code_if_error; 520 521 end clean_up; 522 523 /* ------------------------- */ 524 525 cur_level = get_ring_ (); 526 call cu_$level_set (cur_level); 527 528 call get_resource_descriptions; 529 530 if resource_descriptions.version_no ^= resource_desc_version_1 then 531 call error_return (error_table_$unimplemented_version); 532 533 /* Loop through the structure to make sure the caller didn't ask for the 534* operation to be done to the same resource more than once. Yeah, somebody 535* did it, and it screwed up the record locking. */ 536 537 do base_rno = 1 to resource_descriptions.n_items - 1; 538 base_given_uid = resource_descriptions.item (base_rno).given.uid; 539 base_given_name = resource_descriptions.item (base_rno).given.name; 540 base_uid = resource_descriptions.item (base_rno).uid; 541 base_name = resource_descriptions.item (base_rno).name; 542 base_type = resource_descriptions.item (base_rno).type; 543 544 do rno = base_rno + 1 to resource_descriptions.n_items; 545 if resource_descriptions.item (rno).type = base_type then do; 546 547 if resource_descriptions.item (rno).given.name & base_given_name 548 & (resource_descriptions.item (rno).name = base_name) then 549 call error_return_in_struc (error_table_$duplicate_request); 550 551 if resource_descriptions.item (rno).given.uid & base_given_uid 552 & (resource_descriptions.item (rno).uid = base_uid) then 553 call error_return_in_struc (error_table_$duplicate_request); 554 end; 555 end; 556 end; 557 558 /* So much for user damage. Back to work. */ 559 560 allocate switch_struc in (sys_area) set (sstruc_ptr); 561 562 transaction_time = clock (); 563 564 /* First, seize the transaction control vfile exclusively. This is a cheap 565* way to avoid deadlock, but if it proves overly contentious, we'll have to 566* implement shared transactions. */ 567 568 if reconstruct_operation then 569 tsw_ptr = p_tsw_ptr; 570 571 else do; 572 call rcprm_registry_util_$grab_transaction_control_file (tsw_ptr, registry_dir, code); 573 if code ^= 0 then 574 call error_return (code); 575 end; 576 577 /* Process the requests one by one. */ 578 579 do rno = 1 to resource_descriptions.n_items; 580 581 /* Do some initial setup */ 582 583 call setup_request (); 584 585 /* This block of code finds a resource by name or UID. */ 586 587 if ^seek_attr_flag then do; 588 call seek_specific (); 589 if code ^= 0 then 590 goto MAIN_RETURN; 591 end; 592 593 /* This block of code finds a resource by potential attributes only */ 594 595 else do; 596 call seek_attr (); 597 if code ^= 0 then 598 goto MAIN_RETURN; 599 end; 600 601 /* Now we have the (an) appropriate resource. Process it. */ 602 603 record_descrip = record_status.descriptor; /* luckily, this is always set */ 604 record_status.create_sw = ""b; 605 temp_owner_name = rtrim (requestor_owner_id);/* start out on right foot */ 606 607 if action = Register then do; 608 call register (); 609 call acquire (); 610 call subset (); /* Doesn't set AIM attributes. */ 611 call status (); 612 end; 613 else if action = Acquire then do; 614 call acquire (); 615 call subset (); /* Doesn't set AIM attributes. */ 616 call status (); 617 end; 618 else if action = Set then do; 619 call set (); /* Does set AIM attributes */ 620 call status (); 621 end; 622 else if action = Release then do; 623 call release (clear_ok); 624 if clear_ok then 625 call clear (); 626 end; 627 else if action = Status then 628 call status (); 629 else if action = Clear then 630 call clear (); 631 else if action = Reserve then 632 call reserve (); 633 else if action = Deregister then 634 call deregister (); 635 else if action = Cancel then 636 call cancel (); 637 else call error_return (error_table_$unsupported_operation); 638 MAIN_RETURN: 639 if code = 0 then 640 resource_descriptions.item (rno).status_code = code; 641 else call error_return_in_struc (code); /* that didn't hurt, now, did it? */ 642 end; 643 644 /* Auditing for registers is done here. */ 645 646 if action = Register | action = Acquire then 647 call audit ((0)); 648 call process_end (); 649 p_code = 0; 650 return; 651 652 error_return_in_struc: 653 proc (int_code); 654 655 /* the real code is shoved in the structure and a vanilla code is returned */ 656 657 dcl int_code fixed bin (35) parameter; 658 dcl bad_code fixed bin (35); 659 660 resource_descriptions.item (rno).status_code = int_code; 661 bad_code = error_table_$action_not_performed; 662 goto error_common; 663 664 error_return: 665 entry (int_code); /* the main difference is that int_code is preserved */ 666 667 bad_code = int_code; 668 669 error_common: 670 call audit (bad_code); 671 code = bad_code; 672 call put_resource_descriptions (); 673 call clean_up (0, ""b); 674 goto return_hard; 675 end error_return_in_struc; 676 677 return_hard: 678 p_code = code; 679 return; 680 681 current_auth: 682 proc returns ((2) bit (72) aligned); 683 684 dcl temp_bounds (2) bit (72) aligned; 685 686 temp_bounds (1) = get_process_authorization_ (); 687 string (addr (temp_bounds (1)) -> aim_template.privileges) = ""b; 688 temp_bounds (2) = temp_bounds (1); 689 return (temp_bounds); 690 691 end current_auth; 692 693 chase: 694 proc (descriptor, bp, bl); 695 696 dcl ( 697 descriptor fixed bin (35), 698 bp pointer, 699 bl fixed bin (21) 700 ) parameter; 701 702 if descriptor = 0 then do; 703 bp = addr (bp); /* gotta point somewhere */ 704 bl = 0; 705 return; 706 end; 707 708 unspec (rs) = ""b; 709 rs.version = rs_info_version_2; 710 rs.locate_sw = "1"b; 711 rs.descriptor = descriptor; 712 713 call iox_$control (sw_ptr (swno), "record_status", addr (rs), code); 714 if code ^= 0 then 715 call error_return_in_struc (code); 716 717 bl = rs.record_length; 718 bp = rs.record_ptr; 719 720 return; 721 722 end chase; 723 724 swap_descriptor: 725 proc (descriptor, old_key, new_key, bp, bl); 726 727 dcl descriptor fixed bin (35) parameter; 728 dcl (old_key, new_key) char (*) varying parameter; 729 dcl bp pointer parameter; 730 dcl bl fixed bin (21) parameter; 731 732 dcl test_key char (256) varying; 733 dcl found bit (1) aligned; 734 dcl based_record char (bl) based; 735 736 unspec (rs) = ""b; 737 rs.version = rs_info_version_2; 738 739 /* First find record to which old descriptor points and decrement its refcount. */ 740 741 if descriptor ^= 0 then do; /* make sure there is a record, first */ 742 743 rs.locate_sw = "1"b; 744 rs.descriptor = descriptor; 745 746 call iox_$control (sw_ptr (swno), "record_status", addr (rs), code); 747 if code ^= 0 then 748 call error_return_in_struc (code); 749 750 if bl = rs.record_length then /* check for replacement to same value */ 751 if rs.record_ptr -> based_record = bp -> based_record then do; 752 descriptor = rs.descriptor; /* no need to replace X with X */ 753 return; 754 end; 755 756 rs.dec_ref_count = "1"b; 757 758 call iox_$control (sw_ptr (swno), "record_status", addr (rs), code); 759 if code ^= 0 then 760 call error_return_in_struc (code); 761 762 if rs.ref_count = 1 then do; /* only one reference left; got to be the major key */ 763 /* means no record is using it, so garbage-collect it. */ 764 unspec (get_key_info) = ""b; 765 get_key_info.input_key = "1"b; 766 get_key_info.input_desc = "1"b; 767 get_key_info.descrip = descriptor; 768 get_key_info.key_len = length (get_key_info.key); 769 get_key_info.head_size = length (get_key_info.key); 770 get_key_info.key = old_key; 771 get_key_info.rel_type = Equal; 772 get_key_info.version = gk_info_version_0; 773 774 call iox_$control (sw_ptr (swno), "get_key", addr (get_key_info), code); 775 /* locate the record, setting the current record position to it */ 776 if code ^= 0 then 777 call error_return_in_struc (code); 778 779 call iox_$delete_record (sw_ptr (swno), code); 780 /* smash record */ 781 if code ^= 0 then 782 call error_return_in_struc (code); 783 end; 784 end; 785 786 /* Now create the new record (or find one like it) and patch it back onto that key. */ 787 788 if bl = 0 then do; /* no new record, done */ 789 descriptor = 0; 790 return; 791 end; 792 793 found = ""b; 794 795 call iox_$seek_key (sw_ptr (swno), (new_key), 0, code); 796 797 if code = 0 then do; /* some exist, try to match them */ 798 799 unspec (rs) = ""b; 800 rs.version = rs_info_version_2; 801 802 test_key = new_key; 803 804 do while (test_key = new_key & ^found); 805 806 call iox_$control (sw_ptr (swno), "record_status", addr (rs), code); 807 if code ^= 0 then 808 call error_return_in_struc (code); 809 810 if rs.record_length = bl then 811 if rs.record_ptr -> based_record = bp -> based_record then 812 found = "1"b; 813 814 if ^found then do; 815 call iox_$position (sw_ptr (swno), Move_rel, 1, code); 816 call iox_$read_key (sw_ptr (swno), test_key, 0, code); 817 if code = error_table_$end_of_info then 818 test_key = ""; 819 else if code ^= 0 then 820 call error_return_in_struc (code); 821 end; 822 end; 823 824 if ^found then 825 call iox_$seek_key (sw_ptr (swno), (new_key), 0, code); 826 /* fix key for insertion so next write works. */ 827 end; 828 else if code ^= error_table_$no_record then 829 call error_return_in_struc (code); 830 831 if ^found then do; 832 call iox_$write_record (sw_ptr (swno), bp, bl, code); 833 if code ^= 0 then 834 call error_return_in_struc (code); 835 end; 836 837 unspec (rs) = ""b; 838 rs.version = rs_info_version_2; 839 rs.inc_ref_count = "1"b; 840 841 call iox_$control (sw_ptr (swno), "record_status", addr (rs), code); 842 if code ^= 0 then 843 call error_return_in_struc (code); 844 845 descriptor = rs.descriptor; 846 847 return; 848 849 end swap_descriptor; 850 851 insert_descriptor: 852 proc (descriptor, key, bp, bl); 853 854 dcl descriptor fixed bin (35) parameter; 855 dcl key char (*) varying parameter; 856 dcl bp ptr parameter; 857 dcl bl fixed bin (21) parameter; 858 859 call swap_descriptor (descriptor, key, key, bp, bl); 860 861 end insert_descriptor; 862 863 swap_key: 864 proc (descriptor, old_key, new_key, initial_record); 865 866 dcl descriptor fixed bin (35) parameter; 867 dcl (old_key, new_key) char (256) varying; 868 dcl initial_record char (*) parameter; 869 870 unspec (add_key_info) = ""b; 871 add_key_info.input_key, add_key_info.input_desc = "1"b; 872 add_key_info.descrip = descriptor; 873 874 if old_key ^= "" then do; 875 add_key_info.key_len = length (old_key); 876 add_key_info.key = old_key; 877 878 call iox_$control (sw_ptr (swno), "delete_key", addr (add_key_info), code); 879 if code ^= 0 then 880 call error_return (code); 881 end; 882 883 call iox_$seek_key (sw_ptr (swno), (new_key), 0, code); 884 if code = error_table_$no_record then 885 if initial_record ^= "" then do; 886 887 call iox_$write_record (sw_ptr (swno), addr (initial_record), length (initial_record), code); 888 if code ^= 0 then 889 call error_return_in_struc (code); 890 end; 891 else code = 0; /* may as well be clean about it */ 892 else if code ^= 0 /* from seek_key */ then 893 call error_return_in_struc (code); 894 895 if new_key ^= "" then do; 896 add_key_info.key_len = length (new_key); 897 add_key_info.key = new_key; 898 899 call iox_$control (sw_ptr (swno), "add_key", addr (add_key_info), code); 900 if code ^= 0 then 901 call error_return (code); 902 end; 903 904 return; 905 906 end swap_key; 907 908 make_owner_key: 909 proc (owner_name) returns (char (*) varying); 910 911 dcl owner_name char (*) parameter; 912 913 dcl key char (256); 914 915 if owner_name = "system" then 916 return (REGISTRY_SYSTEM_KEY); 917 else if owner_name = "free" then 918 return (REGISTRY_FREE_KEY); 919 else do; 920 call rcprm_registry_util_$owner_key (owner_name, null (), key); 921 return (rtrim (key)); 922 end; 923 924 end make_owner_key; 925 926 setup_request: 927 proc (); 928 929 /* This internal subroutine does some initial setup necessary */ 930 /* to find the desired resource */ 931 932 if ^reconstruct_operation then 933 if resource_descriptions.item (rno).given.name then do; 934 call resource_info_$canonicalize_name (resource_descriptions.item (rno).type, 935 (resource_descriptions.item (rno).name), resource_descriptions.item (rno).name, code); 936 937 if code ^= 0 then 938 call error_return_in_struc (code); 939 end; 940 941 /* Open the correct registry, if it is not already open. */ 942 943 if registry_open = "" | registry_open ^= resource_descriptions.item (rno).type then do; 944 /* open a different registry */ 945 registry_open = resource_descriptions.item (rno).type; 946 947 do swno = 1 to switch_struc.usedno while (switch_struc.registry (swno) ^= registry_open); 948 end; 949 950 if swno > switch_struc.usedno then do; 951 call rcprm_registry_util_$grab_registry (sw_ptr (swno), registry_dir, registry_open, code); 952 if code ^= 0 then 953 call error_return_in_struc (code); 954 switch_struc.usedno = swno; 955 switch_struc.registry (swno) = registry_open; 956 957 if (^reconstruct_operation) & (action ^= Status) then do; 958 /* set the last transaction time for this registry to now */ 959 call iox_$seek_key (sw_ptr (swno), (REGISTRY_HEADER_KEY), 0, code); 960 if code = error_table_$no_record then 961 code = error_table_$not_seg_type; 962 if code ^= 0 then 963 call error_return_in_struc (code); 964 965 call iox_$control (sw_ptr (swno), "record_status", addr (record_status), code); 966 /* locate and lock the header for modification */ 967 if code ^= 0 then 968 call error_return (code); 969 970 header_ptr = record_status.record_ptr; 971 registry_header.last_transaction_time = transaction_time; 972 /* set this for edification of rcprm_journalize_ */ 973 end; 974 end; 975 end; 976 977 call rcprm_find_op (action, addr (resource_descriptions.item (rno)), reconstruct_operation, priv_sw, operation, 978 seek_attr_flag, code); 979 if code ^= 0 then 980 call error_return_in_struc (code); 981 end setup_request; 982 983 seek_specific: 984 proc (); 985 986 987 if resource_descriptions.item (rno).given.name then 988 if resource_descriptions.item (rno).name = "scratch" then 989 call error_return_in_struc (error_table_$bad_resource_spec); 990 /* scratch is a "special" name and should never get here */ 991 992 if action = Register then 993 record_status.create_sw = "1"b; 994 995 /* Create key to locate record by (in the case of register, to create it by) */ 996 997 if resource_descriptions.item (rno).given.name then 998 call rcprm_registry_util_$name_key ((resource_descriptions.item (rno).name), null (), temp_non_var_key); 999 else call rcprm_registry_util_$uid_key (resource_descriptions.item (rno).uid, null (), temp_non_var_key); 1000 1001 temp_key = rtrim (temp_non_var_key); 1002 call iox_$seek_key (sw_ptr (swno), temp_key, rec_len, code); 1003 1004 if action = Register then 1005 if code ^= error_table_$no_record then 1006 call error_return_in_struc (error_table_$namedup); 1007 else code = 0; /* good register */ 1008 else if code ^= 0 then 1009 call error_return_in_struc (error_table_$resource_unknown); 1010 1011 if action = Register then do; /* create a registry record instead of locating one */ 1012 rr_strl = length (rtrim (resource_descriptions.item (rno).name)); 1013 record_status.record_length, record_status.max_rec_len = size (null -> registry_record) * 4; 1014 end; 1015 1016 if action ^= Status then 1017 record_status.lock_sw = "1"b; /* must lock record to change it */ 1018 else record_status.lock_sw = ""b; 1019 1020 call iox_$control (sw_ptr (swno), "record_status", addr (record_status), code); 1021 /* locate (or create) record */ 1022 if code ^= 0 then 1023 call error_return (code); 1024 record_ptr = record_status.record_ptr; 1025 audit_obj_ok = "1"b; /* Now we can audit a specific object if we fail. */ 1026 1027 /* Make the simple checks first. */ 1028 1029 call simple_checks (); 1030 1031 /* Ok, see if there is enough access to return this error info. */ 1032 if code ^= 0 then do; 1033 simple_code = code; 1034 call setup_kernel_call (proxy_call, addr (req_info), addr (res_info)); 1035 call rcp_access_kernel_ (operation, addr (req_info), addr (res_info), current_rew, code); 1036 if current_rew ^= N_ACCESS then /* Has enough access to see code. */ 1037 call error_return_in_struc (simple_code); 1038 else call error_return (code); /* No, let them see the incorrect access code. */ 1039 end; 1040 else do; /* Check user's access to resource, depending on what he wants to do with it */ 1041 1042 /* If we are reserving a device, the device name was */ 1043 /* generated internally and we will not audit it until */ 1044 /* we have access. */ 1045 1046 call resource_info_$get_type ((resource_type), is_volume, code); 1047 if code ^= 0 then 1048 call error_return_in_struc (code); 1049 if action = Reserve & (^is_volume) then 1050 detailed_operation.search = "1"b; 1051 call setup_kernel_call (proxy_call, addr (req_info), addr (res_info)); 1052 call rcp_access_kernel_ (operation, addr (req_info), addr (res_info), current_rew, code); 1053 if code ^= 0 then 1054 call error_return_in_struc (error_table_$resource_bad_access); 1055 /* Ok, we have access then if it is a Reserve of a device */ 1056 /* then audit it now. */ 1057 1058 if action = Reserve & (^is_volume) then do; 1059 detailed_operation.search = "0"b; 1060 call rcp_access_kernel_ (operation, addr (req_info), addr (res_info), current_rew, code); 1061 end; 1062 end; 1063 1064 /* At this point, we know the user has enough access to find out about the device. */ 1065 1066 1067 if resource_descriptions.item (rno).given.name & resource_descriptions.item (rno).given.uid 1068 & resource_descriptions.item (rno).uid ^= registry_record.uid & ^reconstruct_operation then 1069 call error_return_in_struc (error_table_$bad_resource_spec); 1070 end seek_specific; 1071 1072 seek_attr: 1073 proc (); 1074 1075 /* Find out if the attributes of the resource matter to the user or not */ 1076 1077 if ^resource_descriptions.item (rno).given.desired_attributes then do; 1078 temp_relatts (*) = ""b; 1079 call resource_info_$default_attributes (resource_descriptions.item (rno).type, temp_relatts (1), code); 1080 if code ^= 0 then 1081 call error_return_in_struc (code); 1082 end; 1083 else temp_relatts = resource_descriptions.item (rno).desired_attributes (*); 1084 1085 /* Now decide what pool of resources we will choose a resource from. */ 1086 1087 if action = Acquire then 1088 call rcprm_registry_util_$free_key (null (), temp_non_var_key); 1089 1090 else if action = Reserve then do; 1091 if resource_descriptions.item (rno).given.owner then do; 1092 call rcprm_registry_util_$free_key (null (), temp_non_var_key); 1093 end; 1094 else call rcprm_registry_util_$system_key (null (), temp_non_var_key); 1095 end; 1096 1097 temp_key = rtrim (temp_non_var_key); 1098 call iox_$seek_key (sw_ptr (swno), temp_key, rec_len, code); 1099 if code ^= 0 then do; 1100 if code = error_table_$no_record then 1101 code = error_table_$resource_unavailable; 1102 call error_return_in_struc (code); 1103 end; 1104 1105 unspec (record_status) = ""b; 1106 record_status.version = rs_info_version_2; 1107 1108 found = ""b; 1109 1110 /* Someday there will be an outer loop here which will implement the fancy "resource best-fit backup" 1111* algorithm which will eliminate certain stupidities of the current algorithm which can cause an error 1112* of the form "no appropriate resource available" for multiple requests just because it snarfed up a very 1113* sophisticated resource for a preceding (simple) request, and now has only simple 1114* resources left to satisfy a sophisticated request. But that day is NOT today. */ 1115 1116 do while (^found); 1117 1118 audit_obj_ok = "0"b; /* if we fail, we don't have an object to audit at this point so use different methods for auditing. */ 1119 resource_descriptions.item (rno).name = ""; 1120 1121 call iox_$position (sw_ptr (swno), Move_rel, 1, code); 1122 /* move forward one key */ 1123 /* this leads the loop since the first owner record */ 1124 /* is always the owner name, not a resource record */ 1125 if code ^= 0 then 1126 call error_return_in_struc (code); 1127 1128 call iox_$read_key (sw_ptr (swno), read_key, 0, code); 1129 if code = error_table_$end_of_info then 1130 code = error_table_$resource_unavailable; 1131 if code ^= 0 then 1132 call error_return_in_struc (code); 1133 1134 if read_key ^= temp_key then 1135 call error_return_in_struc (error_table_$resource_unavailable); 1136 1137 call iox_$control (sw_ptr (swno), "record_status", addr (record_status), code); 1138 if code ^= 0 then 1139 call error_return_in_struc (code); 1140 1141 record_ptr = record_status.record_ptr; 1142 audit_obj_ok = "1"b; /* Ok, we have an object to audit if we should fail now. */ 1143 1144 /* do the most inexpensive checks first */ 1145 1146 call simple_checks (); 1147 if code ^= 0 then 1148 goto try_another_resource; 1149 1150 call chase (registry_record.potential_attributes_desc, bp, bl); 1151 if (bp -> potential_attributes_based & unspec (temp_atts)) ^= unspec (temp_atts) then 1152 goto try_another_resource; 1153 1154 /* Check the access */ 1155 1156 call setup_kernel_call (proxy_call, addr (req_info), addr (res_info)); 1157 call rcp_access_kernel_ (operation, addr (req_info), addr (res_info), current_rew, code); 1158 1159 if code ^= 0 then 1160 goto try_another_resource; 1161 1162 if action = Reserve then do; 1163 resource_descriptions.item (rno).name = registry_record.name.string; 1164 1165 call rcp_reserve_$approve_schedule (resource_desc_ptr, rno, registry_dir, reserver_info_ptr, 1166 registry_record.reserver_chain, code); 1167 if code ^= 0 then 1168 goto try_another_resource; 1169 end; 1170 1171 found = "1"b; /* got one! */ 1172 try_another_resource: 1173 code = 0; 1174 1175 end; 1176 1177 /* Auditing for search by attribute operations is */ 1178 /* performed at select time and only for successful */ 1179 /* selections. We call the kernel to do the auditing */ 1180 /* since it has the information neeeded to do so. */ 1181 1182 detailed_operation.search = "0"b; 1183 temp_mode = ""b; 1184 call rcp_access_kernel_ (operation, addr (req_info), addr (res_info), temp_mode, code); 1185 1186 1187 /* lock the registry record before updating */ 1188 record_status.lock_sw = "1"b; /* record must be locked for modification */ 1189 record_status.locate_sw = "1"b; /* previous chase altered current_position */ 1190 call iox_$control (sw_ptr (swno), "record_status", addr (record_status), code); 1191 if code ^= 0 then 1192 call error_return_in_struc (code); 1193 record_status.locate_sw = "0"b; /* clean up structure */ 1194 1195 end seek_attr; 1196 1197 register: 1198 proc (); 1199 1200 registry_record.free = "1"b; 1201 1202 registry_record.name.n = length (rtrim (resource_descriptions.item (rno).name)); 1203 registry_record.name.string = resource_descriptions.item (rno).name; 1204 1205 if ^reconstruct_operation then do; /* when reconstructing we want to use the old uid */ 1206 call admin_gate_$make_uid (registry_record.uid); 1207 resource_descriptions.item (rno).uid = registry_record.uid; 1208 end; 1209 else registry_record.uid = resource_descriptions.item (rno).uid; 1210 1211 call rcprm_registry_util_$uid_key (resource_descriptions.item (rno).uid, null (), temp_non_var_key); 1212 temp_key = rtrim (temp_non_var_key); 1213 1214 call swap_key (record_descrip, "", temp_key, ""); /* Add the key */ 1215 1216 if resource_descriptions.item (rno).given.potential_aim_range then 1217 temp_bounds (*) = resource_descriptions.item (rno).potential_aim_range (*); 1218 else temp_bounds = current_auth (); 1219 1220 /* Here we check to see whether an RCP administrator at a higher level is 1221* attempting to make a resource "appear" at a lower level. But we disable 1222* this check for auto registration; because the only alternative would be 1223* to take the max of the given lower bound (from the defaults in the RTDT) 1224* and the user's current authorization-- and this would result in really 1225* haphazard registration of resources. Generally, people who are worried 1226* about AIM security won't be using auto_registration for other reasons. */ 1227 1228 if ^auto_registration then do; 1229 call rcp_compute_aim_mode$permissible_aim (temp_bounds, temp_bounds, code); 1230 if code ^= 0 then 1231 call error_return_in_struc (code); 1232 end; 1233 1234 call insert_descriptor (registry_record.potential_aim_range_desc, REGISTRY_AIM_RANGE_KEY, addr (temp_bounds), 1235 size (temp_bounds) * 4); 1236 1237 end register; 1238 1239 acquire: 1240 proc (); 1241 if resource_descriptions.item (rno).given.owner then 1242 temp_owner_name = resource_descriptions.item (rno).owner; 1243 else if action = Register then 1244 temp_owner_name = "free"; /* free */ 1245 1246 temp_key = make_owner_key (temp_owner_name); 1247 1248 if registry_record.owner_desc = 0 then 1249 old_key = ""; 1250 else do; 1251 call rcprm_registry_util_$free_key (null (), temp_non_var_key); 1252 old_key = rtrim (temp_non_var_key); 1253 end; 1254 1255 registry_record.reserver_chain = ""b; 1256 resource_descriptions.item (rno).rew = current_rew; 1257 1258 if (action ^= Register) | (resource_descriptions.item (rno).given.owner) then do; 1259 if resource_descriptions.item (rno).given.aim_range then 1260 temp_bounds (*) = resource_descriptions.item (rno).aim_range (*); 1261 else temp_bounds (*) = current_auth (); 1262 1263 call chase (registry_record.potential_aim_range_desc, bp, bl); 1264 if bl = 0 then 1265 bp = addr (Lowest_Aim_Range); /* none found, set to lowest */ 1266 1267 call rcp_compute_aim_mode$permissible_aim (bp -> temp_bounds_based, temp_bounds, code); 1268 if code ^= 0 then 1269 call error_return_in_struc (code); 1270 1271 call insert_descriptor (registry_record.aim_range_desc, REGISTRY_AIM_RANGE_KEY, addr (temp_bounds), 1272 size (temp_bounds) * 4); 1273 end; 1274 1275 call swap_key (record_descrip, old_key, temp_key, rtrim (temp_owner_name)); 1276 call swap_descriptor (registry_record.owner_desc, old_key, temp_key, addr (temp_owner_name), 1277 length (rtrim (temp_owner_name))); 1278 registry_record.system = (temp_owner_name = "system"); 1279 registry_record.free = (temp_owner_name = "free"); 1280 1281 end acquire; 1282 1283 set: 1284 proc (); 1285 if resource_descriptions.item (rno).given.potential_aim_range then do; 1286 temp_bounds (*) = resource_descriptions.item (rno).potential_aim_range (*); 1287 if resource_descriptions.item (rno).given.aim_range then 1288 bp = addr (temp_bounds); /* don't sweat, a later check will validate this */ 1289 else do; 1290 call chase (registry_record.aim_range_desc, bp, bl); 1291 if bl = 0 then 1292 bp = addr (Lowest_Aim_Range); /* none found, set to lowest */ 1293 end; 1294 1295 /* check the new potentials against the currents */ 1296 1297 call rcp_compute_aim_mode$permissible_aim (temp_bounds, bp -> temp_bounds_based, code); 1298 if code ^= 0 then 1299 call error_return_in_struc (code); 1300 1301 call insert_descriptor (registry_record.potential_aim_range_desc, REGISTRY_AIM_RANGE_KEY, 1302 addr (temp_bounds), size (temp_bounds) * 4); 1303 end; 1304 1305 if resource_descriptions.item (rno).given.aim_range then 1306 if registry_record.free then /* free resources don't have set access classes */ 1307 call error_return_in_struc (error_table_$resource_free); 1308 else do; 1309 temp_bounds (*) = resource_descriptions.item (rno).aim_range (*); 1310 1311 call chase (registry_record.potential_aim_range_desc, bp, bl); 1312 if bl = 0 then 1313 bp = addr (Lowest_Aim_Range); /* none found, set to lowest */ 1314 /* check the potentials against the new currents */ 1315 1316 call rcp_compute_aim_mode$permissible_aim (bp -> temp_bounds_based, temp_bounds, code); 1317 if code ^= 0 then 1318 call error_return_in_struc (code); 1319 1320 call insert_descriptor (registry_record.aim_range_desc, REGISTRY_AIM_RANGE_KEY, addr (temp_bounds), 1321 size (temp_bounds) * 4); 1322 end; 1323 1324 subset: 1325 entry; 1326 if (resource_descriptions.item (rno).given.potential_attributes | (action = Register)) then do; 1327 temp_atts (*) = ""b; 1328 if resource_descriptions.item (rno).given.potential_attributes then 1329 temp_atts (1) = resource_descriptions.item (rno).potential_attributes; 1330 1331 call cv_rcp_attributes_$test_valid (resource_type, temp_atts, validity, code); 1332 if code ^= 0 then 1333 call error_return_in_struc (code); 1334 1335 call insert_descriptor (registry_record.potential_attributes_desc, REGISTRY_ATTRIBUTES_KEY, 1336 addr (temp_atts), size (temp_atts) * 2);/* chars per word, but we only want half of the array */ 1337 1338 registry_record.attributes (*) = registry_record.attributes (*) & temp_atts (1); 1339 end; 1340 1341 if resource_descriptions.item (rno).given.location then 1342 call insert_descriptor (registry_record.location_desc, REGISTRY_LOCATION_KEY, 1343 addr (resource_descriptions.item (rno).location), 1344 length (rtrim (resource_descriptions.item (rno).location))); 1345 1346 if resource_descriptions.item (rno).given.charge_type then 1347 call insert_descriptor (registry_record.charge_type_desc, REGISTRY_CHARGE_TYPE_KEY, 1348 addr (resource_descriptions.item (rno).charge_type), 1349 length (rtrim (resource_descriptions.item (rno).charge_type))); 1350 1351 if resource_descriptions.item (rno).given.usage_lock then 1352 registry_record.usage_lock = resource_descriptions.item (rno).usage_lock; 1353 1354 if resource_descriptions.item (rno).given.release_lock then 1355 registry_record.release_lock = resource_descriptions.item (rno).release_lock; 1356 1357 1358 if resource_descriptions.item (rno).given.acs_path then do; 1359 if registry_record.free then /* free resource can't have an ACS */ 1360 call error_return_in_struc (error_table_$resource_free); 1361 temp_acs_path = resource_descriptions.item (rno).acs_path; 1362 if temp_acs_path = "" then 1363 ; /* wants to have no ACS */ 1364 else if substr (temp_acs_path, 1, 1) ^= ">" then 1365 call error_return_in_struc (error_table_$not_abs_path); 1366 else do; 1367 call absolute_pathname_$add_suffix (temp_acs_path, "acs", temp_acs_path, code); 1368 if code ^= 0 then 1369 call error_return_in_struc (code); 1370 end; 1371 1372 call insert_descriptor (registry_record.acs_path_desc, REGISTRY_ACS_PATH_KEY, addr (temp_acs_path), 1373 length (rtrim (temp_acs_path))); 1374 end; 1375 1376 if resource_descriptions.item (rno).given.comment then 1377 call insert_descriptor (registry_record.comment_desc, REGISTRY_COMMENT_KEY, 1378 addr (resource_descriptions.item (rno).comment), 1379 length (rtrim (resource_descriptions.item (rno).comment))); 1380 1381 if resource_descriptions.item (rno).given.user_alloc then 1382 registry_record.user_alloc = resource_descriptions.item (rno).user_alloc; 1383 1384 if resource_descriptions.item (rno).given.desired_attributes & ^seek_attr_flag then do; 1385 1386 temp_relatts = resource_descriptions.item (rno).desired_attributes (*); 1387 1388 call cv_rcp_attributes_$test_valid (resource_type, temp_atts, validity, code); 1389 if code ^= 0 then 1390 call error_return_in_struc (code); 1391 1392 call chase (registry_record.potential_attributes_desc, bp, bl); 1393 if (bp -> potential_attributes_based | temp_atts (1)) ^= bp -> potential_attributes_based then 1394 call error_return_in_struc (error_table_$rcp_attr_not_permitted); 1395 /* some desired attribute is not a potential attribute */ 1396 1397 if validity = Absolute then 1398 registry_record.attributes = temp_atts; 1399 1400 else if validity = Relative then do; 1401 call cv_rcp_attributes_$make_rel (resource_type, (temp_atts), temp_relatts, code); 1402 if code ^= 0 then 1403 call error_return_in_struc (code); 1404 1405 call cv_rcp_attributes_$modify_rel ((registry_record.attributes), temp_relatts, 1406 registry_record.attributes); 1407 end; 1408 1409 else call error_return_in_struc (error_table_$rcp_bad_attributes); 1410 end; 1411 end set; 1412 1413 status: 1414 proc (); 1415 1416 if ^resource_descriptions.item (rno).given.name then 1417 resource_descriptions.item (rno).name = registry_record.name.string; 1418 if ^resource_descriptions.item (rno).given.uid then 1419 resource_descriptions.item (rno).uid = registry_record.uid; 1420 resource_descriptions.item (rno).user_alloc = registry_record.flags.user_alloc; 1421 resource_descriptions.item (rno).release_lock = registry_record.flags.release_lock; 1422 resource_descriptions.item (rno).usage_lock = registry_record.flags.usage_lock; 1423 resource_descriptions.item (rno).awaiting_clear = registry_record.flags.awaiting_clear; 1424 resource_descriptions.item (rno).attributes (1) = registry_record.attributes (1); 1425 resource_descriptions.item (rno).attributes (2) = registry_record.attributes (2); 1426 resource_descriptions.item (rno).rew = current_rew; 1427 1428 call chase (registry_record.location_desc, bp, bl); 1429 resource_descriptions.item (rno).location = based_charstring; 1430 1431 call chase (registry_record.comment_desc, bp, bl); 1432 resource_descriptions.item (rno).comment = based_charstring; 1433 1434 call chase (registry_record.charge_type_desc, bp, bl); 1435 resource_descriptions.item (rno).charge_type = based_charstring; 1436 1437 call chase (registry_record.owner_desc, bp, bl); 1438 resource_descriptions.item (rno).owner = based_charstring; 1439 1440 call chase (registry_record.acs_path_desc, bp, bl); 1441 resource_descriptions.item (rno).acs_path = based_charstring; 1442 1443 call chase (registry_record.potential_attributes_desc, bp, bl); 1444 resource_descriptions.item (rno).potential_attributes = based_bits; 1445 1446 call chase (registry_record.potential_aim_range_desc, bp, bl); 1447 addr (resource_descriptions.item (rno).potential_aim_range (1)) -> based_bits = based_bits; 1448 1449 if ^registry_record.free then 1450 call chase (registry_record.aim_range_desc, bp, bl); 1451 addr (resource_descriptions.item (rno).aim_range (1)) -> based_bits = based_bits; 1452 /* if free, use potential bounds as real bounds, doesn't matter */ 1453 1454 end status; 1455 1456 reserve: 1457 proc (); 1458 1459 if seek_attr_flag then do; /* only do this block if a specific resource was requested */ 1460 /* because we've already done this for "you choose one" requests */ 1461 1462 call rcp_reserve_$approve_schedule (resource_desc_ptr, rno, registry_dir, reserver_info_ptr, 1463 registry_record.reserver_chain, code); 1464 if code ^= 0 then 1465 call error_return_in_struc (code); 1466 end; 1467 1468 /* If this is a system resource, we move this entry to the tail of the system pool with the following call. 1469* This not only results in allowing us to rotate our stock, but also makes future calls to find available 1470* resources faster by keeping the most-likely-to-be-available resources at the head of the line. */ 1471 1472 if registry_record.system then 1473 call swap_key (record_descrip, (REGISTRY_SYSTEM_KEY), (REGISTRY_SYSTEM_KEY), "system"); 1474 1475 end reserve; 1476 1477 deregister: 1478 proc (); 1479 1480 1481 /* Perform violent disassembly on this poor record, tearing out of its vitals all record descriptors 1482* and freeing up (at least one usage of) the records they point to. Note that although some of the 1483* descriptors we attempt to free have no business being in a free record, we will second-guess them anyway, 1484* in case some misguided RCP administrator has unfairly visited various invocations of set_resource upon 1485* poor, innocent free resources. In any case, the swap subroutines are sufficiently robust as to know 1486* whether these descriptors really exist or not. */ 1487 1488 call insert_descriptor (registry_record.potential_aim_range_desc, REGISTRY_AIM_RANGE_KEY, null, 0); 1489 call insert_descriptor (registry_record.aim_range_desc, REGISTRY_AIM_RANGE_KEY, null, 0); 1490 call insert_descriptor (registry_record.potential_attributes_desc, REGISTRY_ATTRIBUTES_KEY, null, 0); 1491 call insert_descriptor (registry_record.acs_path_desc, REGISTRY_ACS_PATH_KEY, null, 0); 1492 call insert_descriptor (registry_record.location_desc, REGISTRY_LOCATION_KEY, null, 0); 1493 call insert_descriptor (registry_record.comment_desc, REGISTRY_COMMENT_KEY, null, 0); 1494 call insert_descriptor (registry_record.charge_type_desc, REGISTRY_CHARGE_TYPE_KEY, null, 0); 1495 call insert_descriptor (registry_record.owner_desc, REGISTRY_FREE_KEY, null, 0); 1496 1497 call swap_key (record_descrip, (REGISTRY_FREE_KEY), "", ""); 1498 1499 call rcprm_registry_util_$uid_key (registry_record.uid, null (), temp_non_var_key); 1500 temp_key = rtrim (temp_non_var_key); 1501 1502 call swap_key (record_descrip, temp_key, "", ""); 1503 1504 call rcprm_registry_util_$name_key (registry_record.name.string, null (), temp_non_var_key); 1505 temp_key = rtrim (temp_non_var_key); 1506 1507 call iox_$seek_key (sw_ptr (swno), temp_key, 0, code); 1508 if code ^= 0 then 1509 call error_return_in_struc (code); 1510 1511 call iox_$delete_record (sw_ptr (swno), code); 1512 if code ^= 0 then 1513 call error_return_in_struc (code); 1514 1515 end deregister; 1516 1517 release: 1518 proc (ok); 1519 1520 dcl ok bit (1); 1521 ok = "1"b; 1522 1523 call resource_info_$lock_on_release (resource_type, lock_sw, code); 1524 if lock_sw then do; 1525 registry_record.awaiting_clear = "1"b; 1526 registry_record.usage_lock = "1"b; 1527 resource_descriptions.item (rno).usage_lock = "1"b; 1528 resource_descriptions.item (rno).awaiting_clear = "1"b; 1529 ok = "0"b; 1530 end; 1531 if code ^= 0 then 1532 call error_return_in_struc (code); 1533 1534 end release; 1535 1536 clear: 1537 proc (); 1538 1539 /* We know the user has rew access, because this was called from Release, 1540* which checks it, or he made a privileged call to get here. */ 1541 1542 if priv_sw then do; /* Clear or privileged Release */ 1543 call chase (registry_record.owner_desc, bp, bl); 1544 temp_key = make_owner_key ((based_charstring)); 1545 end; 1546 1547 else temp_key = make_owner_key (temp_owner_name); 1548 1549 registry_record.usage_lock = ""b; 1550 registry_record.awaiting_clear = ""b; 1551 1552 temp_owner_name = "free"; 1553 call swap_descriptor (registry_record.owner_desc, temp_key, REGISTRY_FREE_KEY, addr (temp_owner_name), 1554 length ("free")); 1555 1556 call swap_key (record_descrip, temp_key, (REGISTRY_FREE_KEY), "free"); 1557 1558 call insert_descriptor (registry_record.comment_desc, REGISTRY_COMMENT_KEY, null, 0); 1559 call insert_descriptor (registry_record.acs_path_desc, REGISTRY_ACS_PATH_KEY, null, 0); 1560 call insert_descriptor (registry_record.aim_range_desc, REGISTRY_AIM_RANGE_KEY, null, 0); 1561 1562 registry_record.free = "1"b; 1563 registry_record.system = ""b; 1564 1565 /* "Degauss" the registry to prevent information passdown on a secure system; 1566* also leaves the registry clean for the next guy in general. */ 1567 1568 registry_record.flags.user_alloc = ""b; 1569 registry_record.attributes (2) = ""b; /* deprotect all attributes */ 1570 1571 call chase (registry_record.potential_attributes_desc, bp, bl); 1572 temp_atts (1) = based_bits; 1573 1574 call resource_info_$set_arbitrary_attributes (resource_type, temp_atts (1), registry_record.attributes, code); 1575 if code ^= 0 then 1576 call error_return_in_struc (code); 1577 1578 end clear; 1579 1580 cancel: 1581 proc (); 1582 1583 call rcp_cancel_id_$remove_schedule (resource_desc_ptr, rno, registry_dir, reserver_info_ptr, 1584 registry_record.reserver_chain, code); 1585 if code ^= 0 then 1586 call error_return_in_struc (code); 1587 1588 /* If this is a "scratch" or "system" resource, "degauss" the registry record so that 1589* no information may be passed to a lower authorization via this path. */ 1590 1591 if registry_record.system then do; 1592 registry_record.flags.user_alloc = ""b; 1593 1594 call chase (registry_record.potential_attributes_desc, bp, bl); 1595 temp_atts (1) = based_bits; 1596 1597 call resource_info_$set_arbitrary_attributes (resource_type, temp_atts (1), registry_record.attributes, 1598 code); 1599 if code ^= 0 then 1600 call error_return_in_struc (code); 1601 end; 1602 1603 end cancel; 1604 1605 process_end: 1606 proc (); 1607 1608 if (action ^= Status) then 1609 do swno = 1 to switch_struc.usedno; 1610 call iox_$control (sw_ptr (swno), "commit", null, code); 1611 if code ^= 0 then do; 1612 if swno > 1 then 1613 call admin_gate_$syserr_error_code (BEEP, code, 1614 "RCP: Registries may be in an inconsistent state."); 1615 call error_return (code); 1616 end; 1617 end; 1618 1619 if action = Release then 1620 do rno = 1 to resource_descriptions.n_items; 1621 if resource_descriptions.item (rno).awaiting_clear then 1622 call admin_gate_$syserr (BEEP, "RCP: Schedule ^a ^a for manual clearing.", 1623 resource_descriptions.item (rno).type, resource_descriptions.item (rno).name); 1624 end; 1625 1626 else if action = Clear then 1627 do rno = 1 to resource_descriptions.n_items; 1628 call admin_gate_$syserr (ANNOUNCE, "RCP: ^[Operator^s^;^a^] certified manual clearing of ^a ^a.", 1629 (my_group_id = "Initializer.SysDaemon.z"), my_group_id, resource_descriptions.item (rno).type, 1630 resource_descriptions.item (rno).name); 1631 end; 1632 1633 /* Journalize all successful operations that changed registry information */ 1634 1635 if action ^= Status & action ^= Reserve & action ^= Cancel & ^reconstruct_operation then 1636 /* certainly don't want to journalize those! */ 1637 call rcprm_journalize_ (resource_desc_ptr, action, transaction_time, registry_dir); 1638 1639 call put_resource_descriptions; 1640 call clean_up (code, "1"b); 1641 if code ^= 0 then 1642 call error_return (code); 1643 1644 end process_end; 1645 1646 /**** Routines to copy the resource descriptions from the caller's space, and back again. get_* allocates the storage 1647* in system_area. These must (obviously) be called in the correct order. ****/ 1648 1649 get_resource_descriptions: 1650 proc; 1651 1652 dcl based_bits (wordcount) bit (36) aligned based; 1653 dcl wordcount fixed bin (19); 1654 1655 callers_rdp = p_resource_desc_ptr; /* this is remembered for put... */ 1656 Resource_count = callers_rdp -> resource_descriptions.n_items; 1657 allocate resource_descriptions in (sys_area) set (resource_desc_ptr); 1658 wordcount = size (resource_descriptions); 1659 resource_desc_ptr -> based_bits = callers_rdp -> based_bits; 1660 resource_descriptions.n_items = Resource_count; /* prevent caller "cleverness" */ 1661 return; 1662 1663 put_resource_descriptions: 1664 entry; 1665 1666 wordcount = size (resource_descriptions); 1667 callers_rdp -> based_bits = resource_desc_ptr -> based_bits; 1668 return; 1669 1670 end get_resource_descriptions; 1671 1672 setup_kernel_call: 1673 proc (a_proxy_call, a_requestor_info_ptr, a_resource_info_ptr); 1674 1675 dcl a_proxy_call bit (1) aligned; 1676 dcl a_requestor_info_ptr ptr; 1677 dcl a_resource_info_ptr ptr; 1678 1679 if a_proxy_call then do; 1680 a_requestor_info_ptr -> requestor_info.user_id = proxy_group_id; 1681 a_requestor_info_ptr -> requestor_info.current_authorization = proxy_authorization; 1682 end; 1683 else do; 1684 a_requestor_info_ptr -> requestor_info.user_id = get_group_id_ (); 1685 call hcs_$get_authorization (a_requestor_info_ptr -> requestor_info.current_authorization, (""b)); 1686 /* a_requestor_info_ptr -> requestor_info.current_authorization = get_authorization_ (); */ 1687 end; 1688 a_requestor_info_ptr -> requestor_info.validation_level = prev_level; 1689 a_resource_info_ptr -> resource_info.registry_dir = registry_dir; 1690 a_resource_info_ptr -> resource_info.registry_switch_ptr = sw_ptr (swno); 1691 a_resource_info_ptr -> resource_info.registry_record_ptr = record_ptr; 1692 a_resource_info_ptr -> resource_info.resource_type = resource_type; 1693 if action = Register then 1694 a_resource_info_ptr -> resource_info.resource_name = resource_descriptions.item (rno).name; 1695 else a_resource_info_ptr -> resource_info.resource_name = registry_record.name.string; 1696 return; 1697 end setup_kernel_call; 1698 1699 simple_checks: 1700 proc (); 1701 1702 if registry_record.awaiting_clear & action ^= Clear & action ^= Status then 1703 code = error_table_$resource_awaiting_clear; 1704 1705 if ^registry_record.awaiting_clear & action = Clear then 1706 code = error_table_$resource_not_free; 1707 if registry_record.usage_lock & ^registry_record.awaiting_clear & ^priv_sw then 1708 code = error_table_$resource_locked; 1709 if ^registry_record.free & action = Acquire then 1710 code = error_table_$resource_not_free; 1711 if action = Reserve then 1712 if registry_record.user_alloc then 1713 code = error_table_$resource_locked; 1714 if action = Release & (registry_record.release_lock & ^priv_sw) then 1715 code = error_table_$not_privileged; 1716 if action = Release & registry_record.free then 1717 code = error_table_$resource_free; 1718 if action = Deregister & ^registry_record.free then 1719 code = error_table_$resource_not_free; 1720 return; 1721 end simple_checks; 1722 1723 audit: 1724 proc (a_code); 1725 1726 dcl a_code fixed bin (35); 1727 dcl save_code fixed bin (35); 1728 dcl based_charstring char (bl) aligned based (bp); 1729 dcl bl fixed bin (21); 1730 dcl bp ptr; 1731 dcl current_owner char (32); 1732 dcl path char (168); 1733 dcl raw_mode bit (3); 1734 dcl rcp_rbs (2) fixed bin (3); 1735 dcl local_code fixed bin (35); 1736 dcl 1 auto_event_flags like audit_event_flags aligned; 1737 dcl reg_name char (32); 1738 dcl suffixed_name_$make entry (char (*), char (*), char (32), fixed bin (35)); 1739 dcl pathname_ entry (char (*), char (*)) returns (char (168)); 1740 dcl access_audit_r1_$log_obj_path 1741 entry options (variable); /* Copy args and initialize local variables. */ 1742 1743 save_code = a_code; 1744 local_code = 0; 1745 rcp_rbs = 0; 1746 rcp_rbs (1) = -1; 1747 raw_mode = ""b; 1748 1749 /* If this is an audit of failure, most operations are audited in the kernel */ 1750 /* with the exception of registers and acquires which are audited here. */ 1751 /* Operations which fail before an object is found, particularly in the */ 1752 /* case of an error_table_$namedup, are audited here. */ 1753 1754 if save_code ^= 0 then /* It failed. */ 1755 if action ^= Acquire & action ^= Register then 1756 /* Audit these always. */ 1757 if audit_obj_ok then /* We have an object - already audited. */ 1758 return; 1759 1760 /* If we don't have an object to audit, this is a failure. Except in */ 1761 /* the case of a Register or Acquire. In the case of a Register we never */ 1762 /* had an object to audit prior to this operation, so we audit the operation */ 1763 /* on the registry. */ 1764 1765 if ^audit_obj_ok | action = Register then do; 1766 call suffixed_name_$make ((resource_type), "rcpr", reg_name, local_code); 1767 path = pathname_ ((registry_dir), reg_name); 1768 unspec (detailed_operation) = "0"b; 1769 unspec (auto_event_flags) = ""b; 1770 auto_event_flags.grant = (save_code = 0); 1771 auto_event_flags.priv_op = priv_sw; 1772 call access_audit_r1_$log_obj_path ("rcprm_find_resource_", prev_level, unspec (auto_event_flags), 1773 operation, path, save_code, null (), 0); 1774 end; 1775 1776 else do; 1777 1778 /* We have an object to audit. Get the object owner prior to */ 1779 /* this operation. If it's an acquire operation the previous owner is */ 1780 /* always "free". */ 1781 1782 if action = Acquire then 1783 current_owner = "free"; 1784 else do; 1785 call chase (registry_record.owner_desc, bp, bl); 1786 if bl = 0 then 1787 current_owner = "free"; 1788 else current_owner = based_charstring; 1789 end; 1790 1791 /* This is a failure audit. */ 1792 1793 if save_code ^= 0 then do; 1794 call setup_kernel_call (proxy_call, addr (req_info), addr (res_info)); 1795 call rcp_audit (who_am_i, operation, addr (req_info), addr (res_info), current_owner, ("000"b), 1796 raw_mode, rcp_rbs, ("1"b), (save_code)); 1797 end; 1798 1799 /* This is a success. */ 1800 1801 else call rcp_audit (who_am_i, operation, addr (req_info), addr (res_info), current_owner, (current_rew), 1802 raw_mode, rcp_rbs, ("1"b), (save_code)); 1803 end; 1804 a_code = save_code; 1805 return; 1806 end audit; 1807 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 */ 1808 1809 2 1 /* begin include file - access_audit_encoded_op.incl.pl1 */ 2 2 2 3 dcl 1 encoded_access_op aligned based, 2 4 2 audit_type unal, 2 5 3 object_type fixed bin (4) uns unal, 2 6 3 access_type fixed bin (2) uns unal, 2 7 2 operation_index fixed bin (12) uns unal, 2 8 2 detailed_operation fixed bin (18) uns unal; 2 9 2 10 /* object_type = Seg, Dir, Rcp, Admin, Special, Other 2 11* access_type = None, Modify_Acl, Modify, Read 2 12* operation_index is the index of this code in 2 13* access_operations_$oper_codes and the index of 2 14* the text descriptor in access_operations_$text_offest_table 2 15* (see access_operations_.incl.pl1) 2 16* detailed_operation is additional info inserted by the 2 17* caller of the subsystem performing the operation 2 18**/ 2 19 2 20 /* end include file - access_audit_encoded_op.incl.pl1 */ 1810 1811 3 1 /* begin include file - access_audit_eventflags.incl.pl1 */ 3 2 /* NOTE: This include file has an ALM counterpart made with cif. 3 3*Keep it up to date. */ 3 4 3 5 dcl 1 audit_event_flags based aligned, 3 6 2 special_op bit (1) unal, /* special sys operation */ 3 7 2 grant bit (1) unal, /* operation was successful */ 3 8 2 admin_op bit (1) unal, /* administrative operation */ 3 9 2 priv_op bit (1) unal, /* privileged operation */ 3 10 2 cc_1_10 bit (1) unal, /* small covert channel */ 3 11 2 cc_10_100 bit (1) unal, /* moderate covert channel */ 3 12 2 receiver bit (1) unal, /* on receiving end of channel */ 3 13 2 pad bit (29) unal; 3 14 3 15 /* end include file - access_audit_eventflags.incl.pl1 */ 1812 1813 4 1 /* --------------- BEGIN include file resource_control_desc.incl.pl1 --------------- */ 4 2 4 3 /* Written by R.J.C. Kissel 3/78. */ 4 4 /* Modified 09/28/78 by C. D. Tavares */ 4 5 4 6 dcl 1 resource_descriptions based (resource_desc_ptr) aligned, 4 7 2 version_no fixed bin, /* caller must set this to resource_desc_version_1 */ 4 8 2 n_items fixed bin, /* Number of resources described by this structure. */ 4 9 2 item (Resource_count refer (resource_descriptions.n_items)) aligned, 4 10 3 type char (32), /* e.g., "tape_drive" */ 4 11 3 name char (32), /* e.g., "tapa_03" */ 4 12 3 uid bit (36), /* The resource unique id. */ 4 13 3 potential_attributes bit (72), /* resource's permissible attributes */ 4 14 3 attributes (2) bit (72), /* RCP attribute description (output) */ 4 15 3 desired_attributes (4) bit (72), /* desired attributes (input) */ 4 16 3 potential_aim_range (2) bit (72), /* Lowest and highest possible AIM bounds for resource */ 4 17 3 aim_range (2) bit (72), /* Current AIM range */ 4 18 3 owner char (32), /* e.g., "Smith.Project" */ 4 19 3 acs_path char (168), /* Access control segment pathname. */ 4 20 3 location char (168), /* String describing location in unusual cases */ 4 21 3 comment char (168), /* User-settable comment string */ 4 22 3 charge_type char (32), /* accounting identifier for this resource */ 4 23 3 rew bit (3) unaligned, /* user's effective access to resource */ 4 24 3 (usage_lock, /* This resource may not be acquired or used. */ 4 25 release_lock, /* The owner is not allowed to release the resource. */ 4 26 awaiting_clear, /* Resource awaiting manual clear */ 4 27 user_alloc) bit (1) unaligned, /* User claims volume contains useful data */ 4 28 3 pad2 bit (29) unaligned, /* Ignored field. */ 4 29 3 given aligned, /* each of these bits says the corresponding */ 4 30 /* item is significant on input */ 4 31 (4 (name, 4 32 uid, 4 33 potential_attributes, 4 34 desired_attributes, 4 35 potential_aim_range, 4 36 aim_range, 4 37 owner, 4 38 acs_path, 4 39 location, 4 40 comment, 4 41 charge_type, 4 42 usage_lock, 4 43 release_lock, 4 44 user_alloc) bit (1), 4 45 4 pad1 bit (22)) unaligned, 4 46 3 state bit (36) aligned, /* For use of resource_control_ only */ 4 47 3 status_code fixed bin (35); /* Standard system status code for this resource. */ 4 48 4 49 4 50 /* Note that the reservation description must always be used with a resource 4 51* description structure. When they are used together the two structures must 4 52* have the same number of entries, i.e. Resource_count is the same for both. */ 4 53 4 54 4 55 dcl 1 reservation_description based (resource_res_ptr) aligned, 4 56 2 version_no fixed bin, /* The version number for this structure. */ 4 57 2 reserved_for char (32), /* Group id of reserved for process. */ 4 58 2 reserved_by char (32), /* Group id of reserved by process. */ 4 59 2 reservation_id fixed bin (71), /* Reservation id of this reservation group. */ 4 60 2 group_starting_time fixed bin (71), /* Starting time for this reservation group. */ 4 61 2 asap_duration fixed bin (71), /* Duration after which as soon as possible is no longer good. */ 4 62 2 flags aligned, 4 63 (3 auto_expire bit (1), /* Should reservation expire when this process terminates. */ 4 64 3 asap bit (1), /* Make this reservation group as soon as possible. */ 4 65 3 rel bit (1), /* Times are relative/absolute. */ 4 66 3 sec bit (1)) unaligned, /* Times are in sec/microsec. */ 4 67 2 n_items fixed bin, /* Number of resources reserved in this group. */ 4 68 2 reservation_group (Resource_count refer (reservation_description.n_items)), 4 69 3 starting_time fixed bin (71), /* When this resource res. starts in the group. */ 4 70 3 duration fixed bin (71); /* Duration of this resource res. in the group. */ 4 71 4 72 dcl (resource_desc_ptr, 4 73 resource_res_ptr) pointer; 4 74 4 75 dcl (resource_desc_version_1 initial (1), 4 76 resource_res_version_1 initial (1)) internal static options (constant); 4 77 4 78 dcl Resource_count fixed bin; /* The number of resources described in the structures. */ 4 79 4 80 /* ---------------- END include file resource_control_desc.incl.pl1 ---------------- */ 1814 1815 5 1 /* format: style4,delnl,insnl,indattr,ifthen,dclind10 */ 5 2 /* BEGIN include rcp_ops.incl.pl1 */ 5 3 5 4 /* Written 02/27/85 by Chris Jones, Maria Pozzo */ 5 5 5 6 dcl ops_ptr ptr; 5 7 5 8 dcl 1 detailed_operation unaligned based (ops_ptr), 5 9 2 given, 5 10 3 potential_attributes 5 11 bit (1), 5 12 3 desired_attributes 5 13 bit (1), 5 14 3 potential_aim_range 5 15 bit (1), 5 16 3 aim_range bit (1), 5 17 3 owner bit (1), 5 18 3 acs_path bit (1), 5 19 3 location bit (1), 5 20 3 comment bit (1), 5 21 3 charge_type bit (1), 5 22 3 usage_lock bit (1), 5 23 3 release_lock bit (1), 5 24 3 user_alloc bit (1), 5 25 2 priv_gate_call bit (1), 5 26 2 search bit (1), 5 27 2 force bit (1), 5 28 2 process bit (1), 5 29 2 owner bit (1), 5 30 2 pad bit (1); 5 31 1816 1817 6 1 /* --------------- BEGIN include file rcp_registry.incl.pl1 --------------- */ 6 2 6 3 /* Written 05/04/78 by C. D. Tavares */ 6 4 6 5 dcl 1 registry_record aligned based (record_ptr), 6 6 2 dynamic_info aligned, 6 7 3 attributes (2) bit (72) aligned, 6 8 3 (location_desc, 6 9 comment_desc, 6 10 pad (2)) fixed bin (35) aligned, 6 11 2 acquisition_info aligned, 6 12 3 (owner_desc, 6 13 acs_path_desc, 6 14 aim_range_desc) fixed bin (35) aligned, 6 15 3 flags unaligned, 6 16 4 (usage_lock, 6 17 release_lock, 6 18 awaiting_clear, 6 19 user_alloc, 6 20 system, 6 21 free) bit (1) unaligned, 6 22 4 pad bit (12) unaligned, 6 23 3 reserver_chain bit (18) unaligned, 6 24 3 pad (2) fixed bin (35) aligned, 6 25 2 registration_info aligned, 6 26 3 uid bit (36) aligned, 6 27 3 (potential_attributes_desc, 6 28 potential_aim_range_desc, 6 29 charge_type_desc, 6 30 pad (2)) fixed bin (35) aligned, 6 31 3 name unaligned, 6 32 4 n fixed bin (8) unaligned, 6 33 4 string char (rr_strl refer (registry_record.name.n)) unaligned; 6 34 6 35 dcl 1 registry_header aligned based (header_ptr), 6 36 2 rtde_size fixed bin (18), 6 37 2 rtde_copy (RTDE_SIZE refer (registry_header.rtde_size)) bit (36) aligned, 6 38 2 other aligned, 6 39 3 last_transaction_time fixed bin (71), 6 40 3 pad (18) bit (36) aligned; 6 41 6 42 dcl RTDE_SIZE fixed bin (18); 6 43 7 1 /* --------------- BEGIN include file rtdt.incl.pl1 --------------- */ 7 2 7 3 dcl 1 rtdt aligned based (rtdtp), /* resource type description table */ 8 1 /* BEGIN INCLUDE FILE author.incl.pl1 */ 8 2 8 3 /* the "author" items must always be the first ones in the table. The 8 4* module which moves the converted table to the System Control process 8 5* fills in these data items and assumes them to be at the head of the segment 8 6* regardless of the specific table's actual declaration. The variables 8 7* "lock" and "last_install_time" used to be "process_id" and "ev_channel" 8 8* respectively. For tables installed in multiple processes, these 8 9* are to be used to lock out multiple installations. */ 8 10 8 11 /* Lock should be used as a modification lock. Since, in general, 8 12* entries may not be moved in system tables, even by installations, 8 13* it is sufficient for only installers and programs that change threads 8 14* to set or respect the lock. Simply updating data in an entry 8 15* requires no such protection. 8 16* 8 17* Last_install_time is used by readers of system tables to detect 8 18* installations or other serious modifications. By checking it before 8 19* and after copying a block of data, they can be protected against 8 20* modifications. 8 21* 8 22* Modules that set the lock should save proc_group_id, and then 8 23* put their group id there for the time they hold the lock. 8 24* if they do not actually install the, they should restore the group id. 8 25**/ 8 26 8 27 2 author aligned, /* validation data about table's author */ 8 28 3 proc_group_id char (32), /* process-group-id (personid.projectid.tag) */ 8 29 3 lock bit (36), /* installation lock */ 8 30 3 update_attributes bit (1) unal, /* update/add/delete attributes */ 8 31 3 update_authorization bit (1) unal, /* update only authorizations */ 8 32 3 deferral_notified bit (1) unal, /* installer notified of deferral of installation */ 8 33 3 pad bit (33) unaligned, 8 34 3 last_install_time fixed bin (71), 8 35 3 table char (4), /* name of table, e.g., SAT MGT TTT RTDT PDT etc. */ 8 36 3 w_dir char (64), /* author's working directory */ 8 37 8 38 /* END INCLUDE FILE author.incl.pl1 */ 7 4 7 5 2 version fixed bin, /* version number */ 7 6 2 installed_under_resource_mgt bit (1) aligned, /* resource mgt. was ON when this was installed */ 7 7 2 charge_type_table_ptr offset, /* points to charge_type_table */ 7 8 2 first_resource offset, /* chain for RTDE's */ 7 9 2 rtdt_area area (RTDT_area_len); /* all following items allocated here */ 7 10 7 11 dcl 1 charge_type_table aligned based (cttp), /* describes charges for resource types */ 7 12 2 n_charge_types fixed bin, /* number of distinct charge types */ 7 13 2 charge_types (N_CHARGE_TYPES refer (charge_type_table.n_charge_types)) aligned char (32), 7 14 2 flagword fixed bin (35) aligned; /* this word simply help us set bitcount properly */ 7 15 7 16 dcl 1 rtde aligned based (rtdep), /* describes one resource type */ 7 17 2 fixed_info aligned, 7 18 3 next_resource offset, /* chains to next type, or nullo */ 7 19 3 name char (32), /* name of resource type, e.g. "tape_drive" */ 7 20 3 syn_to char (32), /* if is_synonym this is master syn */ 7 21 3 precanon_proc char (64), /* name of routine to standardize resource name */ 7 22 3 pad_1 (16) fixed bin (35), 7 23 3 flags unaligned, 7 24 4 (valid, /* resource type hasn't been deleted */ 7 25 is_volume, /* specifies volume or device type */ 7 26 manual_clear, /* volumes of this type to be "degaussed" between owners */ 7 27 addition_pending, /* bookkeeping bit for upd_rtdt_ */ 7 28 deletion_pending, 7 29 is_synonym) bit (1) unaligned, /* ditto */ 7 30 4 pad bit (12) unaligned, 7 31 3 (process_limit, /* how many can you assign at one time */ 7 32 default_time, /* implicit reservations are for how many minutes */ 7 33 max_time, /* how long can you reserve it for */ 7 34 advance_notice_time, /* warn operator to prepare mount ahead of time */ 7 35 pad2, 7 36 n_exclusion_specs, /* number of distinct "name=" fields in attributes */ 7 37 n_mates, /* number of mating devs/vols for this vol/dev */ 7 38 n_subtypes, /* number of registration subtypes */ 7 39 n_defined_attributes) fixed bin (17) unaligned, /* number of defined attributes */ 7 40 3 pad_2 (8) fixed bin (35), 7 41 3 attributes_valid bit (72) aligned, /* "1"b if corresp. attribute undeleted */ 7 42 3 attributes_to_match bit (72) aligned, /* potential mate must possess these attributes */ 7 43 3 attribute_names (72) char (12) aligned, /* all possible attributes for this resource */ 7 44 3 exclusion_specs (36) bit (72) aligned, /* each masks all attrributes of the form "key=val" */ 7 45 3 pad_3 (32) fixed bin (35), 7 46 3 registration_defaults aligned, /* applied at reg. time if none given */ 7 47 4 default_flags aligned, 7 48 5 (potential_attributes_given, /* "1"b = there are default potential_attributes */ 7 49 attributes_given, /* and similarly, etc. */ 7 50 aim_range_given, 7 51 charge_type_given) bit (1) unaligned, 7 52 5 pad bit (31) unaligned, 7 53 4 potential_attributes bit (72) aligned, /* for registration, if given */ 7 54 4 attributes bit (72) aligned, /* for registration and also for runtime "I-don't-care" */ 7 55 4 aim_range (2) bit (72) aligned, /* and similarly, etc. */ 7 56 4 charge_type fixed bin, 7 57 4 pad_4 (8) fixed bin (35) aligned, 7 58 2 mates (N_MATES refer (rtde.n_mates)) char (32) aligned, 7 59 /* the volume type that mounts on this device, or vice versa */ 7 60 2 subtypes (N_SUBTYPES refer (rtde.n_subtypes)) aligned, /* named registration default groups */ 7 61 3 subtype_name char (32), /* name of the group */ 7 62 3 subtype_defaults like rtde.registration_defaults aligned; 7 63 7 64 dcl RTDT_version_3 fixed bin static options (constant) initial (3), 7 65 RTDT_version_2 fixed bin static options (constant) initial (2), 7 66 /* same format, but without precanon_proc */ 7 67 (N_MATES, N_SUBTYPES, N_CHARGE_TYPES) fixed bin, 7 68 RTDT_area_len fixed bin (18); 7 69 7 70 dcl (rtdep, rtdtp, cttp) pointer; 7 71 7 72 /* ---------------- END include file rtdt.incl.pl1 ---------------- */ 6 44 6 45 6 46 dcl (record_ptr, header_ptr) pointer, 6 47 rr_strl fixed bin; 6 48 6 49 /* ---------------- END include file rcp_registry.incl.pl1 ---------------- */ 1818 1819 9 1 /* format: style4,delnl,insnl,indattr,ifthen,dclind10 */ 9 2 /* Begin include file rcp_requestor_info.incl.pl1 9 3* * 9 4* * This include file gives information about the subject, 9 5* * or requestor of the RCP operation. In one case, absentee 9 6* * requests, the user is the Initializer, so this piece of 9 7* * information tells us about the real requestor of the RCP 9 8* * operation. 9 9**/ 9 10 9 11 dcl requestor_info_ptr ptr; 9 12 9 13 dcl 1 requestor_info aligned based (requestor_info_ptr), 9 14 2 user_id char (32), 9 15 2 current_authorization bit (72) aligned, 9 16 2 validation_level fixed bin (3); 9 17 9 18 /* end include file .. rcp_requestor_info.incl.pl1 */ 1820 1821 10 1 /* format: style4,delnl,insnl,indattr,ifthen,dclind10 */ 10 2 /* Begin include file rcp_resource_info.incl.pl1 10 3* * 10 4* * This include file gives information about the object, 10 5* * or resource for the RCP operation. If RM is enabled this 10 6* * information will provide the registry name and switch pointer 10 7* * for the registry so additional resource information can be 10 8* * determined. If RM is disabled, this information will include 10 9* * the resource name and/or type. 10 10**/ 10 11 10 12 dcl resource_info_ptr ptr; 10 13 10 14 dcl 1 resource_info based (resource_info_ptr), 10 15 2 registry_dir aligned char (64), /* Could be a different if it is reconstruct operation */ 10 16 2 registry_switch_ptr 10 17 ptr, /* Switch to the registry */ 10 18 2 registry_record_ptr 10 19 ptr, /* Pointer to the registry record */ 10 20 2 resource_type char (32), /* Resource type */ 10 21 2 resource_name char (32); /* Resource name */ 10 22 10 23 /* end include file .. rcp_resource_info.incl.pl1 */ 1822 1823 11 1 /* --------------- BEGIN include file rcprm_action_codes.incl.pl1 --------------- */ 11 2 11 3 dcl (Register initial (1), /* Positive actions must be ODD */ 11 4 Deregister initial (2), /* Negative actions must be EVEN */ 11 5 Acquire initial (3), 11 6 Release initial (4), 11 7 Clear initial (6), 11 8 Set initial (7), 11 9 Status initial (8), 11 10 Reserve initial (9), 11 11 Cancel initial (10)) fixed bin static options (constant); 11 12 11 13 dcl Action_noun (10) char (12) static options (constant) initial 11 14 ("register", "deregister", "acquire", "release", "ERROR", "clear", "set", "status", "reserve", "cancel"); 11 15 11 16 11 17 /* ---------------- END include file rcprm_action_codes.incl.pl1 ---------------- */ 1824 1825 12 1 /* --------------- BEGIN include file iox_dcls.incl.pl1 --------------- */ 12 2 12 3 /* Written 05/04/78 by C. D. Tavares */ 12 4 /* Fixed declaration of iox_$find_iocb_n 05/07/80 by R. Holmstedt */ 12 5 /* Modified 5/83 by S. Krupp to add declarations for: iox_$open_file, 12 6* iox_$close_file, iox_$detach and iox_$attach_loud entries. */ 12 7 12 8 dcl iox_$attach_name entry (char (*), pointer, char (*), pointer, fixed bin (35)), 12 9 iox_$attach_ptr entry (pointer, char (*), pointer, fixed bin (35)), 12 10 iox_$close entry (pointer, fixed bin (35)), 12 11 iox_$control entry (pointer, char (*), pointer, fixed bin (35)), 12 12 iox_$delete_record entry (pointer, fixed bin (35)), 12 13 iox_$destroy_iocb entry (pointer, fixed bin (35)), 12 14 iox_$detach_iocb entry (pointer, fixed bin (35)), 12 15 iox_$err_not_attached entry options (variable), 12 16 iox_$err_not_closed entry options (variable), 12 17 iox_$err_no_operation entry options (variable), 12 18 iox_$err_not_open entry options (variable), 12 19 iox_$find_iocb entry (char (*), pointer, fixed bin (35)), 12 20 iox_$find_iocb_n entry (fixed bin, ptr, fixed bin(35)), 12 21 iox_$get_chars entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 12 22 iox_$get_line entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 12 23 iox_$look_iocb entry (char (*), pointer, fixed bin (35)), 12 24 iox_$modes entry (pointer, char (*), char (*), fixed bin (35)), 12 25 iox_$move_attach entry (pointer, pointer, fixed bin (35)), 12 26 iox_$open entry (pointer, fixed bin, bit (1) aligned, fixed bin (35)), 12 27 iox_$position entry (pointer, fixed bin, fixed bin (21), fixed bin (35)), 12 28 iox_$propagate entry (pointer), 12 29 iox_$put_chars entry (pointer, pointer, fixed bin (21), fixed bin (35)), 12 30 iox_$read_key entry (pointer, char (256) varying, fixed bin (21), fixed bin (35)), 12 31 iox_$read_length entry (pointer, fixed bin (21), fixed bin (35)), 12 32 iox_$read_record entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 12 33 iox_$rewrite_record entry (pointer, pointer, fixed bin (21), fixed bin (35)), 12 34 iox_$seek_key entry (pointer, char (256) varying, fixed bin (21), fixed bin (35)), 12 35 iox_$write_record entry (pointer, pointer, fixed bin (21), fixed bin (35)), 12 36 iox_$open_file entry(ptr, fixed bin, char(*), bit(1) aligned, fixed bin(35)), 12 37 iox_$close_file entry(ptr, char(*), fixed bin(35)), 12 38 iox_$detach entry(ptr, char(*), fixed bin(35)), 12 39 iox_$attach_loud entry(ptr, char(*), ptr, fixed bin(35)); 12 40 12 41 dcl (iox_$user_output, 12 42 iox_$user_input, 12 43 iox_$user_io, 12 44 iox_$error_output) external static pointer; 12 45 12 46 /* ---------------- END include file iox_dcls.incl.pl1 ---------------- */ 1826 1827 13 1 /* Begin include file ..... iox_modes.incl.pl1 */ 13 2 13 3 /* Written by C. D. Tavares, 03/17/75 */ 13 4 /* Updated 10/31/77 by CDT to include short iox mode strings */ 13 5 13 6 dcl iox_modes (13) char (24) int static options (constant) aligned initial 13 7 ("stream_input", "stream_output", "stream_input_output", 13 8 "sequential_input", "sequential_output", "sequential_input_output", "sequential_update", 13 9 "keyed_sequential_input", "keyed_sequential_output", "keyed_sequential_update", 13 10 "direct_input", "direct_output", "direct_update"); 13 11 13 12 dcl short_iox_modes (13) char (4) int static options (constant) aligned initial 13 13 ("si", "so", "sio", "sqi", "sqo", "sqio", "squ", "ksqi", "ksqo", "ksqu", "di", "do", "du"); 13 14 13 15 dcl (Stream_input initial (1), 13 16 Stream_output initial (2), 13 17 Stream_input_output initial (3), 13 18 Sequential_input initial (4), 13 19 Sequential_output initial (5), 13 20 Sequential_input_output initial (6), 13 21 Sequential_update initial (7), 13 22 Keyed_sequential_input initial (8), 13 23 Keyed_sequential_output initial (9), 13 24 Keyed_sequential_update initial (10), 13 25 Direct_input initial (11), 13 26 Direct_output initial (12), 13 27 Direct_update initial (13)) fixed bin int static options (constant); 13 28 13 29 /* End include file ..... iox_modes.incl.pl1 */ 1828 1829 14 1 /* include file for info structure used with record_status control order 14 2* created by M. Asherman 1/6/76 */ 14 3 /* modified 6/15/77 to support stationary type records */ 14 4 14 5 dcl rs_info_ptr ptr; 14 6 dcl 1 rs_info based (rs_info_ptr) aligned, 14 7 2 version fixed, /* must be set to 1 or 2 (Input) */ 14 8 2 flags aligned, 14 9 3 lock_sw bit (1) unal, /* Input -- if ="1"b try to lock record */ 14 10 3 unlock_sw bit (1) unal, /* Input -- if ="1"b try to unlock record */ 14 11 3 create_sw bit (1) unal, /* Input--if set creat new record */ 14 12 3 locate_sw bit (1) unal, /* Input--if set causes current rec to be 14 13* located outside the index by descrip, or created without key */ 14 14 3 inc_ref_count bit (1) unal, /* Input--bump reference count of record, if stationary */ 14 15 3 dec_ref_count bit (1) unal, /* Input--decrement ref count if this flag set and record stationary */ 14 16 3 locate_pos_sw bit (1) unal, /* Input--if set the record_length is taken 14 17* as an input argument specifying the absolute logical record positioni to which both the current and next positions will be set */ 14 18 3 mbz1 bit (29) unal, /* must be set to "0"b, reserved for future use */ 14 19 2 record_length fixed (21), /* length in bytes, Input if create_sw set */ 14 20 2 max_rec_len fixed (21), /* max length of contained record 14 21* Input if create_sw is set--overrides min_block_size in effect */ 14 22 2 record_ptr ptr, /* points to first byte of record--will be word aligned */ 14 23 2 descriptor fixed (35), /* Input if locate_sw set and create_sw="0"b */ 14 24 2 ref_count fixed (34), /* Output--should match number of keys on this record-- = -1 if non-stationary record */ 14 25 2 time_last_modified fixed (71), /* Output */ 14 26 2 modifier fixed (35), /* Output--also Input when locking */ 14 27 2 block_ptr ptr unal, /* Output */ 14 28 2 last_image_modifier 14 29 fixed (35), 14 30 2 mbz2 fixed; 14 31 14 32 dcl 1 rs_desc based (addr (rs_info.descriptor)), 14 33 /* record block descriptor structure */ 14 34 2 comp_num fixed (17) unal, /* msf component number */ 14 35 2 offset bit (18) unal; /* word offset of record block */ 14 36 14 37 dcl 1 seq_desc based (addr (rs_info.descriptor)), 14 38 /* for sequential files */ 14 39 2 bitno bit (6) unal, 14 40 2 comp_num fixed (11) unal, /* msf component number */ 14 41 2 wordno bit (18) unal; /* word offset */ 14 42 14 43 dcl rs_info_version_1 static internal fixed init (1); 14 44 dcl rs_info_version_2 static internal fixed init (2); 14 45 1830 1831 15 1 /* ak_info -- include file for info structures used by the following vfile_ 15 2* control orders: "add_key", "delete_key", "get_key", and "reassign_key". 15 3* Created by M. Asherman 3/23/76 15 4* Modified 5/13/77 to add separate gk_info structure */ 15 5 15 6 dcl 1 ak_info based (ak_info_ptr), 15 7 2 header like ak_header, 15 8 2 key char (ak_key_len refer (ak_info.header.key_len)); 15 9 15 10 dcl 1 ak_header based (ak_info_ptr), 15 11 2 flags aligned, 15 12 3 input_key bit (1) unal, /* set if key is input arg */ 15 13 3 input_desc bit (1) unal, /* set if descriptor is an input arg */ 15 14 3 mbz bit (34) unal, /* not used for the present */ 15 15 2 descrip fixed (35), /* record designator */ 15 16 2 key_len fixed; 15 17 15 18 dcl ak_info_ptr ptr; 15 19 dcl ak_key_len fixed; 15 20 15 21 15 22 dcl 1 rk_info based (rk_info_ptr), 15 23 2 header like rk_header, 15 24 2 key char (rk_key_len refer (rk_info.header.key_len)); 15 25 15 26 dcl 1 rk_header based (rk_info_ptr), 15 27 2 flags aligned, 15 28 3 input_key bit (1) unal, /* same as above */ 15 29 3 input_old_desc bit (1) unal, /* set if specified entry has initial descrip 15 30* given by old_descrip */ 15 31 3 input_new_desc bit (1) unal, /* set if new val for descrip is input in this struc */ 15 32 3 mbz bit (33) unal, 15 33 2 old_descrip fixed (35), /* used if first flag is set */ 15 34 2 new_descrip fixed (35), /* used only if second flag is set */ 15 35 2 key_len fixed; 15 36 15 37 dcl rk_info_ptr ptr; 15 38 dcl rk_key_len fixed; 15 39 15 40 15 41 dcl 1 gk_info based (gk_info_ptr), /* structure for get_key order */ 15 42 2 header like gk_header, 15 43 2 key char (gk_key_len refer (gk_info.header.key_len)); 15 44 /* may be Input as well as Output */ 15 45 15 46 dcl 1 gk_header based (gk_info_ptr), 15 47 2 flags aligned, 15 48 3 input_key bit (1) unal, /* if set, use key in this structure */ 15 49 3 input_desc bit (1) unal, /* if set, descriptor given in this structure */ 15 50 3 desc_code fixed (2) unal, /* 0=any, 1=current -- applies when input_desc="0"b */ 15 51 3 position_specification 15 52 unal, 15 53 4 current bit (1) unal, /* otherwise next */ 15 54 4 rel_type fixed (2) unal, /* as in seek_head, if input_key = "1"b */ 15 55 4 head_size fixed bin (9) unsigned unaligned, 15 56 /* size of head for initial seek */ 15 57 3 reset_pos bit (1) unal, /* if set, final position unchanged by this operation */ 15 58 3 pad bit (8) unal, 15 59 3 version fixed (8) unal, 15 60 2 descrip fixed (35), /* Output, except when input_desc="1"b */ 15 61 2 key_len fixed; /* Input when input_key="1"b, also Output in all cases */ 15 62 15 63 dcl gk_info_ptr ptr; 15 64 dcl gk_key_len fixed; 15 65 15 66 dcl gk_info_version_0 internal static fixed options (constant) init (0); 15 67 15 68 /* end ak_info.incl.pl1 */ 1832 1833 16 1 /* START OF: rcprm_registry_keys.incl.pl1 * * * * * * * * * * * * * * * * */ 16 2 /* Written January 1985 by Chris Jones. */ 16 3 16 4 /* format: style4,delnl,insnl,indattr,ifthen,dclind10 */ 16 5 dcl ( 16 6 REGISTRY_ACS_PATH_KEY init ("!ACS_paths"), 16 7 REGISTRY_AIM_RANGE_KEY init ("!AIM_ranges"), 16 8 REGISTRY_ATTRIBUTES_KEY 16 9 init ("!attributes"), 16 10 REGISTRY_CHARGE_TYPE_KEY 16 11 init ("!charge_types"), 16 12 REGISTRY_COMMENT_KEY init ("!comments"), 16 13 REGISTRY_FREE_KEY init ("!free"), 16 14 REGISTRY_HEADER_KEY init ("!header"), 16 15 REGISTRY_LOCATION_KEY init ("!locations"), 16 16 REGISTRY_NAME_KEY_HEAD init ("!N."), 16 17 REGISTRY_OWNER_KEY_HEAD 16 18 init ("!O."), 16 19 REGISTRY_SYSTEM_KEY init ("!system"), 16 20 REGISTRY_UID_KEY_HEAD init ("!U.") 16 21 ) static char (16) varying options (constant); 16 22 16 23 16 24 /* END OF: rcprm_registry_keys.incl.pl1 * * * * * * * * * * * * * * * * */ 1834 1835 17 1 /* BEGIN INCLUDE FILE aim_template.incl.pl1 */ 17 2 17 3 /* Created 740723 by PG */ 17 4 /* Modified 06/28/78 by C. D. Tavares to add rcp privilege */ 17 5 /* Modified 83-05-10 by E. N. Kitltitz to add communications privilege */ 17 6 17 7 /* This structure defines the components of both an access 17 8* class and an access authorization as interpreted by the 17 9* Access Isolation Mechanism. */ 17 10 17 11 17 12 dcl 1 aim_template aligned based, /* authorization/access class template */ 17 13 2 categories bit (36), /* access categories */ 17 14 2 level fixed bin (17) unaligned, /* sensitivity level */ 17 15 2 privileges unaligned, /* special access privileges (in authorization only) */ 17 16 (3 ipc, /* interprocess communication privilege */ 17 17 3 dir, /* directory privilege */ 17 18 3 seg, /* segment privilege */ 17 19 3 soos, /* security out-of-service privilege */ 17 20 3 ring1, /* ring 1 access privilege */ 17 21 3 rcp, /* RCP resource access privilege */ 17 22 3 comm) bit (1), /* communications cross-AIM privilege */ 17 23 3 pad bit (11); 17 24 17 25 17 26 /* END INCLUDE FILE aim_template.incl.pl1 */ 1836 1837 18 1 /* BEGIN INCLUDE FILE syserr_constants.incl.pl1 ... 11/11/80 W. Olin Sibert */ 18 2 /* 85-02-12, EJ Sharpe - Added sorting class constants, removed AIM_MESSAGE, added new action code names. */ 18 3 /* 85-04-24, G. Palter - Renamed SYSERR_UNUSED_10 to SYSERR_RING1_ERROR to reflect its actual use. */ 18 4 18 5 /* This include file has an ALM version. Keep 'em in sync! */ 18 6 18 7 dcl ( 18 8 18 9 /* The following constants define the message action codes. This indicates 18 10*how a message is to be handled. */ 18 11 18 12 SYSERR_CRASH_SYSTEM init (1), 18 13 CRASH init (1), /* Crash the system, and bleat plaintively. */ 18 14 18 15 SYSERR_TERMINATE_PROCESS init (2), 18 16 TERMINATE_PROCESS init (2), /* Terminate the process, print the message, and beep. */ 18 17 18 18 SYSERR_PRINT_WITH_ALARM init (3), 18 19 BEEP init (3), /* Beep and print the message on the console. */ 18 20 18 21 SYSERR_PRINT_ON_CONSOLE init (0), 18 22 ANNOUNCE init (0), /* Just print the message on the console. */ 18 23 18 24 SYSERR_LOG_OR_PRINT init (4), 18 25 LOG init (4), /* Log the message, or print it if it can't be logged */ 18 26 18 27 SYSERR_LOG_OR_DISCARD init (5), 18 28 JUST_LOG init (5), /* Just try to log the message, and discard it if it can't be */ 18 29 18 30 18 31 /* The following constants are added to the normal severities to indicate 18 32*different sorting classes of messages. */ 18 33 18 34 SYSERR_SYSTEM_ERROR init (00), /* indicates a standard level system error */ 18 35 SYSERR_RING1_ERROR init (10), /* indicates an error detected in ring 1 (mseg_, RCP) */ 18 36 SYSERR_COVERT_CHANNEL init (20), /* indicates covert channel audit trail message */ 18 37 SYSERR_UNSUCCESSFUL_ACCESS init (30), /* indicates access denial audit trail message */ 18 38 SYSERR_SUCCESSFUL_ACCESS init (40) /* indicates access grant audit trail message */ 18 39 ) fixed bin internal static options (constant); 18 40 18 41 /* END INCLUDE FILE syserr_constants.incl.pl1 */ 1838 1839 1840 /* BEGIN MESSAGE DOCUMENTATION 1841* 1842* Message: 1843* RCP: Registries may be in an inconsistent state. ERROR_CODE 1844* 1845* S: $beep 1846* 1847* T: $run 1848* 1849* M: An RCP Resource Management transaction was not properly committed to the 1850* registries. $err 1851* 1852* A: $contact 1853* 1854* 1855* Message: 1856* RCP: Schedule VOLUME for manual clearing. 1857* 1858* S: $beep 1859* 1860* T: $run 1861* 1862* M: The data contained on VOLUME is to be destroyed by the operator via 1863* degaussing or other site-mandated method. 1864* 1865* A: The operator must erase the specified resource, and must acknowledge 1866* when this has been done by issuing the clear_resource command or the 1867* appropriate site-defined "x" Initializer request. 1868* 1869* 1870* Message: 1871* RCP: Operator certified manual clearing of VOLUME. 1872* RCP: USERID certified manual clearing of VOLUME. 1873* 1874* S: $info 1875* 1876* T: In response to an operator or administrator command. 1877* 1878* M: This message is printed for auditing purposes when site-madated 1879* destruction of data is accomplished. 1880* 1881* A: $ignore 1882* 1883* END MESSAGE DOCUMENTATION */ 1884 1885 end rcprm_find_resource_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/11/89 0805.9 rcprm_find_resource_.pl1 >spec>install>1111>rcprm_find_resource_.pl1 1808 1 04/11/85 1452.6 access_mode_values.incl.pl1 >ldd>include>access_mode_values.incl.pl1 1810 2 01/30/85 1523.9 access_audit_encoded_op.incl.pl1 >ldd>include>access_audit_encoded_op.incl.pl1 1812 3 01/30/85 1523.9 access_audit_eventflags.incl.pl1 >ldd>include>access_audit_eventflags.incl.pl1 1814 4 02/13/79 1715.0 resource_control_desc.incl.pl1 >ldd>include>resource_control_desc.incl.pl1 1816 5 03/15/85 0953.1 rcp_ops.incl.pl1 >ldd>include>rcp_ops.incl.pl1 1818 6 11/20/79 2015.5 rcp_registry.incl.pl1 >ldd>include>rcp_registry.incl.pl1 6-44 7 11/20/79 2015.6 rtdt.incl.pl1 >ldd>include>rtdt.incl.pl1 7-4 8 04/21/82 1211.8 author.incl.pl1 >ldd>include>author.incl.pl1 1820 9 03/15/85 0953.1 rcp_requestor_info.incl.pl1 >ldd>include>rcp_requestor_info.incl.pl1 1822 10 03/15/85 0953.1 rcp_resource_info.incl.pl1 >ldd>include>rcp_resource_info.incl.pl1 1824 11 02/11/80 1426.1 rcprm_action_codes.incl.pl1 >ldd>include>rcprm_action_codes.incl.pl1 1826 12 05/23/83 0916.6 iox_dcls.incl.pl1 >ldd>include>iox_dcls.incl.pl1 1828 13 02/02/78 1229.7 iox_modes.incl.pl1 >ldd>include>iox_modes.incl.pl1 1830 14 07/19/79 1547.0 rs_info.incl.pl1 >ldd>include>rs_info.incl.pl1 1832 15 07/19/79 1547.0 ak_info.incl.pl1 >ldd>include>ak_info.incl.pl1 1834 16 03/15/85 0953.1 rcprm_registry_keys.incl.pl1 >ldd>include>rcprm_registry_keys.incl.pl1 1836 17 09/07/83 1610.6 aim_template.incl.pl1 >ldd>include>aim_template.incl.pl1 1838 18 05/17/85 0615.7 syserr_constants.incl.pl1 >ldd>include>syserr_constants.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. ANNOUNCE 000056 constant fixed bin(17,0) initial dcl 18-7 set ref 1628* Absolute constant fixed bin(17,0) initial dcl 173 ref 1397 Acquire constant fixed bin(17,0) initial dcl 11-3 ref 311 613 646 1087 1709 1754 1782 BEEP 000124 constant fixed bin(17,0) initial dcl 18-7 set ref 1612* 1621* Cancel constant fixed bin(17,0) initial dcl 11-3 ref 370 635 1635 Clear constant fixed bin(17,0) initial dcl 11-3 ref 330 629 1626 1702 1705 Deregister constant fixed bin(17,0) initial dcl 11-3 ref 415 633 1718 Equal constant fixed bin(17,0) initial dcl 178 ref 771 Lowest_Aim_Range 000056 constant fixed bin(71,0) initial array dcl 180 set ref 1264 1291 1312 Move_rel 000123 constant fixed bin(17,0) initial dcl 178 set ref 815* 1121* N_ACCESS constant bit(3) initial packed unaligned dcl 1-11 ref 1036 REGISTRY_ACS_PATH_KEY 000050 constant varying char(16) initial dcl 16-5 set ref 1372* 1491* 1559* REGISTRY_AIM_RANGE_KEY 000043 constant varying char(16) initial dcl 16-5 set ref 1234* 1271* 1301* 1320* 1488* 1489* 1560* REGISTRY_ATTRIBUTES_KEY 000036 constant varying char(16) initial dcl 16-5 set ref 1335* 1490* REGISTRY_CHARGE_TYPE_KEY 000031 constant varying char(16) initial dcl 16-5 set ref 1346* 1494* REGISTRY_COMMENT_KEY 000024 constant varying char(16) initial dcl 16-5 set ref 1376* 1493* 1558* REGISTRY_FREE_KEY 000017 constant varying char(16) initial dcl 16-5 set ref 917 1495* 1497 1553* 1556 REGISTRY_HEADER_KEY 000012 constant varying char(16) initial dcl 16-5 ref 959 REGISTRY_LOCATION_KEY 000005 constant varying char(16) initial dcl 16-5 set ref 1341* 1492* REGISTRY_SYSTEM_KEY 000000 constant varying char(16) initial dcl 16-5 ref 915 1472 1472 Register constant fixed bin(17,0) initial dcl 11-3 ref 407 607 646 992 1004 1011 1243 1258 1326 1693 1754 1765 Relative constant fixed bin(17,0) initial dcl 173 ref 1400 Release constant fixed bin(17,0) initial dcl 11-3 ref 323 622 1619 1714 1716 Reserve constant fixed bin(17,0) initial dcl 11-3 ref 345 355 631 1049 1058 1090 1162 1635 1711 Resource_count 001314 automatic fixed bin(17,0) dcl 4-78 set ref 1656* 1657 1657 1658 1660 1666 Set constant fixed bin(17,0) initial dcl 11-3 ref 394 618 Status constant fixed bin(17,0) initial dcl 11-3 ref 382 627 957 1016 1608 1635 1702 a_code parameter fixed bin(35,0) dcl 1726 set ref 1723 1743 1804* a_proxy_call parameter bit(1) dcl 1675 ref 1672 1679 a_requestor_info_ptr parameter pointer dcl 1676 ref 1672 1680 1681 1684 1685 1688 a_resource_info_ptr parameter pointer dcl 1677 ref 1672 1689 1690 1691 1692 1693 1695 absolute_pathname_$add_suffix 000034 constant entry external dcl 186 ref 1367 access_audit_r1_$log_obj_path 000232 constant entry external dcl 1740 ref 1772 acquisition_info 10 based structure level 2 dcl 6-5 acs_path 61 based char(168) array level 3 in structure "resource_descriptions" dcl 4-6 in procedure "rcprm_find_resource_" set ref 1361 1441* acs_path 270(07) based bit(1) array level 4 in structure "resource_descriptions" packed packed unaligned dcl 4-6 in procedure "rcprm_find_resource_" set ref 1358 acs_path_desc 11 based fixed bin(35,0) level 3 dcl 6-5 set ref 1372* 1440* 1491* 1559* action 000100 automatic fixed bin(17,0) dcl 99 set ref 311* 323* 330* 345* 355* 370* 382* 394* 407* 415* 426* 607 613 618 622 627 629 631 633 635 646 646 957 977* 992 1004 1011 1016 1049 1058 1087 1090 1162 1243 1258 1326 1608 1619 1626 1635 1635 1635 1635* 1693 1702 1702 1705 1709 1711 1714 1716 1718 1754 1754 1765 1782 add_key_info 001075 automatic structure level 1 unaligned dcl 160 set ref 870* 878 878 899 899 addr builtin function dcl 296 ref 438 439 687 703 713 713 746 746 758 758 774 774 806 806 841 841 878 878 887 887 899 899 965 965 977 977 1020 1020 1034 1034 1034 1034 1035 1035 1035 1035 1051 1051 1051 1051 1052 1052 1052 1052 1060 1060 1060 1060 1137 1137 1151 1151 1156 1156 1156 1156 1157 1157 1157 1157 1184 1184 1184 1184 1190 1190 1234 1234 1264 1271 1271 1276 1276 1287 1291 1301 1301 1312 1320 1320 1327 1328 1331 1335 1335 1335 1335 1335 1338 1341 1341 1346 1346 1372 1372 1376 1376 1388 1393 1397 1401 1447 1451 1553 1553 1572 1574 1595 1597 1794 1794 1794 1794 1795 1795 1795 1795 1801 1801 1801 1801 admin_gate_$make_uid 000070 constant entry external dcl 208 ref 1206 admin_gate_$syserr 000036 constant entry external dcl 188 ref 1621 1628 admin_gate_$syserr_error_code 000040 constant entry external dcl 189 ref 1612 aim_range 45 based bit(72) array level 3 in structure "resource_descriptions" dcl 4-6 in procedure "rcprm_find_resource_" set ref 1259 1309 1451 aim_range 270(05) based bit(1) array level 4 in structure "resource_descriptions" packed packed unaligned dcl 4-6 in procedure "rcprm_find_resource_" set ref 1259 1287 1305 aim_range_desc 12 based fixed bin(35,0) level 3 dcl 6-5 set ref 1271* 1290* 1320* 1449* 1489* 1560* aim_template based structure level 1 dcl 17-12 ak_header based structure level 1 unaligned dcl 15-10 ak_info_ptr 001326 automatic pointer dcl 15-18 set ref 444* attributes 25 based bit(72) array level 3 in structure "resource_descriptions" dcl 4-6 in procedure "rcprm_find_resource_" set ref 1424* 1425* attributes based bit(72) array level 3 in structure "registry_record" dcl 6-5 in procedure "rcprm_find_resource_" set ref 1338* 1338 1397* 1405 1405* 1424 1425 1569* 1574* 1597* audit_event_flags based structure level 1 dcl 3-5 audit_obj_ok 000101 automatic bit(1) packed unaligned dcl 100 set ref 434* 1025* 1118* 1142* 1754 1765 auto_event_flags 000173 automatic structure level 1 dcl 1736 set ref 1769* 1772 1772 auto_registration 000102 automatic bit(1) initial dcl 101 set ref 101* 401* 1228 awaiting_clear 13(02) based bit(1) level 4 in structure "registry_record" packed packed unaligned dcl 6-5 in procedure "rcprm_find_resource_" set ref 1423 1525* 1550* 1702 1705 1707 awaiting_clear 267(05) based bit(1) array level 3 in structure "resource_descriptions" packed packed unaligned dcl 4-6 in procedure "rcprm_find_resource_" set ref 1423* 1528* 1621 bad_code 000100 automatic fixed bin(35,0) dcl 658 set ref 661* 667* 669* 671 base_given_name 000105 automatic bit(1) packed unaligned dcl 104 set ref 539* 547 base_given_uid 000104 automatic bit(1) packed unaligned dcl 103 set ref 538* 551 base_name 000107 automatic char(32) packed unaligned dcl 106 set ref 541* 547 base_rno 000103 automatic fixed bin(17,0) dcl 102 set ref 537* 538 539 540 541 542 544* base_type 000117 automatic char(32) packed unaligned dcl 107 set ref 542* 545 base_uid 000106 automatic bit(36) packed unaligned dcl 105 set ref 540* 551 based_bits based bit dcl 278 in procedure "rcprm_find_resource_" set ref 1444 1447* 1447 1451* 1451 1572 1595 based_bits based bit(36) array dcl 1652 in procedure "get_resource_descriptions" set ref 1659* 1659 1667* 1667 based_charstring based char dcl 1728 in procedure "audit" ref 1788 based_charstring based char dcl 279 in procedure "rcprm_find_resource_" ref 1429 1432 1435 1438 1441 1544 based_record based char packed unaligned dcl 734 ref 750 750 810 810 bl parameter fixed bin(21,0) dcl 857 in procedure "insert_descriptor" set ref 851 859* bl parameter fixed bin(21,0) dcl 696 in procedure "chase" set ref 693 704* 717* bl parameter fixed bin(21,0) dcl 730 in procedure "swap_descriptor" set ref 724 750 750 750 788 810 810 810 832* bl 000127 automatic fixed bin(21,0) dcl 108 in procedure "rcprm_find_resource_" set ref 1150* 1263* 1264 1290* 1291 1311* 1312 1392* 1428* 1429 1431* 1432 1434* 1435 1437* 1438 1440* 1441 1443* 1444 1446* 1447 1447 1449* 1451 1451 1543* 1544 1571* 1572 1594* 1595 bl 000101 automatic fixed bin(21,0) dcl 1729 in procedure "audit" set ref 1785* 1786 1788 bp parameter pointer dcl 856 in procedure "insert_descriptor" set ref 851 859* bp 000102 automatic pointer dcl 1730 in procedure "audit" set ref 1785* 1788 bp parameter pointer dcl 729 in procedure "swap_descriptor" set ref 724 750 810 832* bp 000130 automatic pointer dcl 109 in procedure "rcprm_find_resource_" set ref 1150* 1151 1263* 1264* 1267 1287* 1290* 1291* 1297 1311* 1312* 1316 1392* 1393 1393 1428* 1429 1431* 1432 1434* 1435 1437* 1438 1440* 1441 1443* 1444 1446* 1447 1449* 1451 1543* 1544 1571* 1572 1594* 1595 bp parameter pointer dcl 696 in procedure "chase" set ref 693 703* 703 718* callers_rdp 000132 automatic pointer dcl 110 set ref 1655* 1656 1659 1667 charge_type 270(10) based bit(1) array level 4 in structure "resource_descriptions" packed packed unaligned dcl 4-6 in procedure "rcprm_find_resource_" set ref 1346 charge_type 257 based char(32) array level 3 in structure "resource_descriptions" dcl 4-6 in procedure "rcprm_find_resource_" set ref 1346 1346 1346 1346 1435* charge_type_desc 21 based fixed bin(35,0) level 3 dcl 6-5 set ref 1346* 1434* 1494* cleanup 001304 stack reference condition dcl 294 ref 468 clear_ok 000134 automatic bit(1) packed unaligned dcl 111 set ref 623* 624 clock builtin function dcl 296 ref 562 code parameter fixed bin(35,0) dcl 475 in procedure "clean_up" set ref 472 486* 489* 494* 507* 516 code 000135 automatic fixed bin(35,0) dcl 112 in procedure "rcprm_find_resource_" set ref 441* 572* 573 573* 589 597 638 638 641* 671* 677 713* 714 714* 746* 747 747* 758* 759 759* 774* 776 776* 779* 781 781* 795* 797 806* 807 807* 815* 816* 817 819 819* 824* 828 828* 832* 833 833* 841* 842 842* 878* 879 879* 883* 884 887* 888 888* 891* 892 892* 899* 900 900* 934* 937 937* 951* 952 952* 959* 960 960* 962 962* 965* 967 967* 977* 979 979* 1002* 1004 1007* 1008 1020* 1022 1022* 1032 1033 1035* 1038* 1046* 1047 1047* 1052* 1053 1060* 1079* 1080 1080* 1098* 1099 1100 1100* 1102* 1121* 1125 1125* 1128* 1129 1129* 1131 1131* 1137* 1138 1138* 1147 1157* 1159 1165* 1167 1172* 1184* 1190* 1191 1191* 1229* 1230 1230* 1267* 1268 1268* 1297* 1298 1298* 1316* 1317 1317* 1331* 1332 1332* 1367* 1368 1368* 1388* 1389 1389* 1401* 1402 1402* 1462* 1464 1464* 1507* 1508 1508* 1511* 1512 1512* 1523* 1531 1531* 1574* 1575 1575* 1583* 1585 1585* 1597* 1599 1599* 1610* 1611 1612* 1615* 1640* 1641 1641* 1702* 1705* 1707* 1709* 1711* 1714* 1716* 1718* comment 270(09) based bit(1) array level 4 in structure "resource_descriptions" packed packed unaligned dcl 4-6 in procedure "rcprm_find_resource_" set ref 1376 comment 205 based char(168) array level 3 in structure "resource_descriptions" dcl 4-6 in procedure "rcprm_find_resource_" set ref 1376 1376 1376 1376 1432* comment_desc 5 based fixed bin(35,0) level 3 dcl 6-5 set ref 1376* 1431* 1493* 1558* create_sw 1(02) 000762 automatic bit(1) level 3 packed packed unaligned dcl 155 set ref 604* 992* cu_$level_get 000042 constant entry external dcl 191 ref 443 cu_$level_set 000044 constant entry external dcl 192 ref 510 526 cur_level 000136 automatic fixed bin(17,0) dcl 113 set ref 525* 526* current_authorization 10 based bit(72) level 2 dcl 9-13 set ref 1681* 1685* current_owner 000104 automatic char(32) packed unaligned dcl 1731 set ref 1782* 1786* 1788* 1795* 1801* current_rew 000150 automatic bit(3) packed unaligned dcl 115 set ref 1035* 1036 1052* 1060* 1157* 1256 1426 1801 cv_rcp_attributes_$make_rel 000046 constant entry external dcl 193 ref 1401 cv_rcp_attributes_$modify_rel 000050 constant entry external dcl 195 ref 1405 cv_rcp_attributes_$test_valid 000052 constant entry external dcl 197 ref 1331 1388 dec_ref_count 1(05) 001000 automatic bit(1) level 3 packed packed unaligned dcl 156 set ref 756* descrip 1 001200 automatic fixed bin(35,0) level 3 in structure "get_key_info" dcl 164 in procedure "rcprm_find_resource_" set ref 767* descrip 1 001075 automatic fixed bin(35,0) level 3 in structure "add_key_info" dcl 160 in procedure "rcprm_find_resource_" set ref 872* descriptor 6 001000 automatic fixed bin(35,0) level 2 in structure "rs" dcl 156 in procedure "rcprm_find_resource_" set ref 711* 744* 752 845 descriptor parameter fixed bin(35,0) dcl 866 in procedure "swap_key" ref 863 872 descriptor parameter fixed bin(35,0) dcl 696 in procedure "chase" ref 693 702 711 descriptor parameter fixed bin(35,0) dcl 854 in procedure "insert_descriptor" set ref 851 859* descriptor parameter fixed bin(35,0) dcl 727 in procedure "swap_descriptor" set ref 724 741 744 752* 767 789* 845* descriptor 6 000762 automatic fixed bin(35,0) level 2 in structure "record_status" dcl 155 in procedure "rcprm_find_resource_" set ref 603 desired_attributes 270(03) based bit(1) array level 4 in structure "resource_descriptions" packed packed unaligned dcl 4-6 in procedure "rcprm_find_resource_" set ref 1077 1384 desired_attributes 31 based bit(72) array level 3 in structure "resource_descriptions" dcl 4-6 in procedure "rcprm_find_resource_" set ref 1083 1386 detailed_operation based structure level 1 packed packed unaligned dcl 5-8 in procedure "rcprm_find_resource_" set ref 1768* detailed_operation 0(18) based fixed bin(18,0) level 2 in structure "en_access_op" packed packed unsigned unaligned dcl 154 in procedure "rcprm_find_resource_" set ref 439 dynamic_info based structure level 2 dcl 6-5 en_access_op based structure level 1 dcl 154 encoded_access_op based structure level 1 dcl 2-3 error_matters parameter bit(1) dcl 476 ref 472 485 507 error_table_$action_not_performed 000142 external static fixed bin(35,0) dcl 251 ref 661 error_table_$bad_resource_spec 000146 external static fixed bin(35,0) dcl 251 set ref 987* 1067* error_table_$duplicate_request 000150 external static fixed bin(35,0) dcl 251 set ref 547* 551* error_table_$end_of_info 000152 external static fixed bin(35,0) dcl 251 ref 817 1129 error_table_$namedup 000154 external static fixed bin(35,0) dcl 251 set ref 1004* error_table_$no_record 000156 external static fixed bin(35,0) dcl 251 ref 828 884 960 1004 1100 error_table_$not_abs_path 000160 external static fixed bin(35,0) dcl 251 set ref 1364* error_table_$not_privileged 000162 external static fixed bin(35,0) dcl 251 ref 1714 error_table_$not_seg_type 000164 external static fixed bin(35,0) dcl 251 ref 960 error_table_$rcp_attr_not_permitted 000166 external static fixed bin(35,0) dcl 251 set ref 1393* error_table_$rcp_bad_attributes 000170 external static fixed bin(35,0) dcl 251 set ref 1409* error_table_$resource_awaiting_clear 000144 external static fixed bin(35,0) dcl 251 ref 1702 error_table_$resource_bad_access 000172 external static fixed bin(35,0) dcl 251 set ref 1053* error_table_$resource_free 000174 external static fixed bin(35,0) dcl 251 set ref 1305* 1359* 1716 error_table_$resource_locked 000176 external static fixed bin(35,0) dcl 251 ref 1707 1711 error_table_$resource_not_free 000200 external static fixed bin(35,0) dcl 251 ref 1705 1709 1718 error_table_$resource_unavailable 000202 external static fixed bin(35,0) dcl 251 set ref 1100 1129 1134* error_table_$resource_unknown 000204 external static fixed bin(35,0) dcl 251 set ref 1008* error_table_$unimplemented_version 000206 external static fixed bin(35,0) dcl 251 set ref 530* error_table_$unsupported_operation 000210 external static fixed bin(35,0) dcl 251 set ref 637* fixed_info based structure level 2 dcl 7-16 flags 13 based structure level 3 in structure "registry_record" packed packed unaligned dcl 6-5 in procedure "rcprm_find_resource_" flags 1 000762 automatic structure level 2 in structure "record_status" dcl 155 in procedure "rcprm_find_resource_" flags 001200 automatic structure level 3 in structure "get_key_info" dcl 164 in procedure "rcprm_find_resource_" flags 1 001000 automatic structure level 2 in structure "rs" dcl 156 in procedure "rcprm_find_resource_" flags 001075 automatic structure level 3 in structure "add_key_info" dcl 160 in procedure "rcprm_find_resource_" found 000151 automatic bit(1) dcl 116 in procedure "rcprm_find_resource_" set ref 1108* 1116 1171* found 001461 automatic bit(1) dcl 733 in procedure "swap_descriptor" set ref 793* 804 810* 814 824 831 free 13(05) based bit(1) level 4 packed packed unaligned dcl 6-5 set ref 1200* 1279* 1305 1359 1449 1562* 1709 1716 1718 get_group_id_ 000062 constant entry external dcl 205 ref 455 1684 get_key_info 001200 automatic structure level 1 unaligned dcl 164 set ref 764* 774 774 get_process_authorization_ 000060 constant entry external dcl 203 ref 686 get_ring_ 000064 constant entry external dcl 206 ref 525 get_system_free_area_ 000066 constant entry external dcl 207 ref 452 given 270 based structure array level 3 dcl 4-6 gk_header based structure level 1 unaligned dcl 15-46 gk_info_ptr 001330 automatic pointer dcl 15-63 set ref 444* gk_info_version_0 constant fixed bin(17,0) initial dcl 15-66 ref 772 grant 0(01) 000173 automatic bit(1) level 2 packed packed unaligned dcl 1736 set ref 1770* hcs_$get_authorization 000056 constant entry external dcl 202 ref 1685 head_size 0(09) 001200 automatic fixed bin(9,0) level 5 packed packed unsigned unaligned dcl 164 set ref 769* header 001075 automatic structure level 2 in structure "add_key_info" unaligned dcl 160 in procedure "rcprm_find_resource_" header 001200 automatic structure level 2 in structure "get_key_info" unaligned dcl 164 in procedure "rcprm_find_resource_" header_ptr 001322 automatic pointer dcl 6-46 set ref 970* 971 i 000100 automatic fixed bin(17,0) dcl 478 set ref 483* 484 486 489* inc_ref_count 1(04) 001000 automatic bit(1) level 3 packed packed unaligned dcl 156 set ref 839* initial_record parameter char packed unaligned dcl 868 set ref 863 884 887 887 887 887 input_desc 0(01) 001075 automatic bit(1) level 4 in structure "add_key_info" packed packed unaligned dcl 160 in procedure "rcprm_find_resource_" set ref 871* input_desc 0(01) 001200 automatic bit(1) level 4 in structure "get_key_info" packed packed unaligned dcl 164 in procedure "rcprm_find_resource_" set ref 766* input_key 001200 automatic bit(1) level 4 in structure "get_key_info" packed packed unaligned dcl 164 in procedure "rcprm_find_resource_" set ref 765* input_key 001075 automatic bit(1) level 4 in structure "add_key_info" packed packed unaligned dcl 160 in procedure "rcprm_find_resource_" set ref 871* int_code parameter fixed bin(35,0) dcl 657 ref 652 660 664 667 iox_$control 000212 constant entry external dcl 12-8 ref 486 713 746 758 774 806 841 878 899 965 1020 1137 1190 1610 iox_$delete_record 000214 constant entry external dcl 12-8 ref 779 1511 iox_$position 000216 constant entry external dcl 12-8 ref 815 1121 iox_$read_key 000220 constant entry external dcl 12-8 ref 816 1128 iox_$seek_key 000222 constant entry external dcl 12-8 ref 795 824 883 959 1002 1098 1507 iox_$write_record 000224 constant entry external dcl 12-8 ref 832 887 is_volume 000152 automatic bit(1) packed unaligned dcl 117 set ref 1046* 1049 1058 item 2 based structure array level 2 dcl 4-6 set ref 977 977 key 3 001200 automatic char(256) level 2 in structure "get_key_info" packed packed unaligned dcl 164 in procedure "rcprm_find_resource_" set ref 768 769 770* key 000100 automatic char(256) packed unaligned dcl 913 in procedure "make_owner_key" set ref 920* 921 key parameter varying char dcl 855 in procedure "insert_descriptor" set ref 851 859* 859* key 3 001075 automatic char(256) level 2 in structure "add_key_info" packed packed unaligned dcl 160 in procedure "rcprm_find_resource_" set ref 876* 897* key_len 2 001075 automatic fixed bin(17,0) level 3 in structure "add_key_info" dcl 160 in procedure "rcprm_find_resource_" set ref 875* 896* key_len 2 001200 automatic fixed bin(17,0) level 3 in structure "get_key_info" dcl 164 in procedure "rcprm_find_resource_" set ref 768* last_transaction_time based fixed bin(71,0) level 3 dcl 6-35 set ref 971* length builtin function dcl 296 ref 457 465 768 769 875 887 887 896 1012 1202 1276 1276 1341 1341 1346 1346 1372 1372 1376 1376 1553 1553 local_code 000172 automatic fixed bin(35,0) dcl 1735 set ref 1744* 1766* locate_sw 1(03) 001000 automatic bit(1) level 3 in structure "rs" packed packed unaligned dcl 156 in procedure "rcprm_find_resource_" set ref 710* 743* locate_sw 1(03) 000762 automatic bit(1) level 3 in structure "record_status" packed packed unaligned dcl 155 in procedure "rcprm_find_resource_" set ref 1189* 1193* location 270(08) based bit(1) array level 4 in structure "resource_descriptions" packed packed unaligned dcl 4-6 in procedure "rcprm_find_resource_" set ref 1341 location 133 based char(168) array level 3 in structure "resource_descriptions" dcl 4-6 in procedure "rcprm_find_resource_" set ref 1341 1341 1341 1341 1429* location_desc 4 based fixed bin(35,0) level 3 dcl 6-5 set ref 1341* 1428* 1492* lock_sw 000153 automatic bit(1) dcl 118 in procedure "rcprm_find_resource_" set ref 1523* 1524 lock_sw 1 000762 automatic bit(1) level 3 in structure "record_status" packed packed unaligned dcl 155 in procedure "rcprm_find_resource_" set ref 1016* 1018* 1188* max_rec_len 3 000762 automatic fixed bin(21,0) level 2 dcl 155 set ref 1013* maxno based fixed bin(17,0) level 2 dcl 285 set ref 499 560* my_group_id 000021 internal static char(32) initial packed unaligned dcl 171 set ref 455* 456 1628 1628* my_owner_id 000010 internal static varying char(32) initial dcl 170 set ref 454 456* 457* 457 457 460 n 24 based fixed bin(8,0) level 4 packed packed unaligned dcl 6-5 set ref 1163 1202* 1203 1416 1504 1504 1695 n_items 1 based fixed bin(17,0) level 2 dcl 4-6 set ref 503 537 544 560 560 579 1619 1626 1656 1657* 1660* name 24 based structure level 3 in structure "registry_record" packed packed unaligned dcl 6-5 in procedure "rcprm_find_resource_" name 12 based char(32) array level 3 in structure "resource_descriptions" dcl 4-6 in procedure "rcprm_find_resource_" set ref 541 547 934 934* 987 997 1012 1119* 1163* 1202 1203 1416* 1621* 1628* 1693 name 270 based bit(1) array level 4 in structure "resource_descriptions" packed packed unaligned dcl 4-6 in procedure "rcprm_find_resource_" set ref 539 547 932 987 997 1067 1416 new_key parameter varying char dcl 728 in procedure "swap_descriptor" ref 724 795 802 804 824 new_key parameter varying char(256) dcl 867 in procedure "swap_key" ref 863 883 895 896 897 null builtin function dcl 296 ref 444 449 450 452 482 484 486 486 498 500 502 504 920 920 997 997 999 999 1013 1087 1087 1092 1092 1094 1094 1211 1211 1251 1251 1488 1488 1489 1489 1490 1490 1491 1491 1492 1492 1493 1493 1494 1494 1495 1495 1499 1499 1504 1504 1558 1558 1559 1559 1560 1560 1610 1610 1772 1772 ok parameter bit(1) packed unaligned dcl 1520 set ref 1517 1521* 1529* old_key 000154 automatic varying char(256) dcl 119 in procedure "rcprm_find_resource_" set ref 1248* 1252* 1275* 1276* old_key parameter varying char(256) dcl 867 in procedure "swap_key" ref 863 874 875 876 old_key parameter varying char dcl 728 in procedure "swap_descriptor" ref 724 770 operation 000255 automatic bit(36) dcl 120 set ref 437* 438 977* 1035* 1052* 1060* 1157* 1184* 1772* 1795* 1801* operation_ptr 000256 automatic pointer dcl 121 set ref 438* 439 ops_ptr 001316 automatic pointer dcl 5-6 set ref 439* 1049 1059 1182 1768 other based structure level 2 dcl 6-35 owner 51 based char(32) array level 3 in structure "resource_descriptions" dcl 4-6 in procedure "rcprm_find_resource_" set ref 1241 1438* owner 270(06) based bit(1) array level 4 in structure "resource_descriptions" packed packed unaligned dcl 4-6 in procedure "rcprm_find_resource_" set ref 1091 1241 1258 owner_desc 10 based fixed bin(35,0) level 3 dcl 6-5 set ref 1248 1276* 1437* 1495* 1543* 1553* 1785* owner_name parameter char packed unaligned dcl 911 set ref 908 915 917 920* p_action parameter fixed bin(17,0) dcl 422 ref 419 426 p_code parameter fixed bin(35,0) dcl 309 set ref 299 304 315 320 327 335 342 349 362 367 374 379 386 391 398 403 411 419 649* 677* p_proxy_authorization parameter bit(72) dcl 353 ref 349 358 p_proxy_group_id parameter char packed unaligned dcl 352 ref 349 357 p_registry_dir parameter char packed unaligned dcl 308 ref 299 304 315 320 327 335 342 349 362 367 374 379 386 391 398 403 411 419 436 p_reserver_info_ptr parameter pointer dcl 338 ref 335 342 349 362 367 431 p_resource_desc_ptr parameter pointer dcl 307 ref 299 304 315 320 327 335 342 349 362 367 374 379 386 391 398 403 411 419 1655 p_tsw_ptr parameter pointer dcl 423 ref 419 568 path 000114 automatic char(168) packed unaligned dcl 1732 set ref 1767* 1772* pathname_ 000230 constant entry external dcl 1739 ref 1767 position_specification 0(05) 001200 automatic structure level 4 packed packed unaligned dcl 164 potential_aim_range 270(04) based bit(1) array level 4 in structure "resource_descriptions" packed packed unaligned dcl 4-6 in procedure "rcprm_find_resource_" set ref 1216 1285 potential_aim_range 41 based bit(72) array level 3 in structure "resource_descriptions" dcl 4-6 in procedure "rcprm_find_resource_" set ref 1216 1286 1447 potential_aim_range_desc 20 based fixed bin(35,0) level 3 dcl 6-5 set ref 1234* 1263* 1301* 1311* 1446* 1488* potential_attributes 23 based bit(72) array level 3 in structure "resource_descriptions" dcl 4-6 in procedure "rcprm_find_resource_" set ref 1328 1444* potential_attributes 270(02) based bit(1) array level 4 in structure "resource_descriptions" packed packed unaligned dcl 4-6 in procedure "rcprm_find_resource_" set ref 1326 1328 potential_attributes_based based bit(72) packed unaligned dcl 282 ref 1151 1393 1393 potential_attributes_desc 17 based fixed bin(35,0) level 3 dcl 6-5 set ref 1150* 1335* 1392* 1443* 1490* 1571* 1594* prev_level 000261 automatic fixed bin(17,0) dcl 123 set ref 443* 510* 1688 1772* priv_op 0(03) 000173 automatic bit(1) level 2 packed packed unaligned dcl 1736 set ref 1771* priv_sw 000260 automatic bit(1) initial dcl 122 set ref 122* 302* 318* 331* 340* 365* 377* 389* 406* 414* 425* 977* 1542 1707 1714 1771 privileges 1(18) based structure level 2 packed packed unaligned dcl 17-12 set ref 687* proxy_authorization 000262 automatic bit(72) dcl 124 set ref 358* 1681 proxy_call 000264 automatic bit(1) initial dcl 125 set ref 125* 356* 460 1034* 1051* 1156* 1794* proxy_group_id 000265 automatic char(32) packed unaligned dcl 126 set ref 357* 463 1680 raw_mode 000166 automatic bit(3) packed unaligned dcl 1733 set ref 1747* 1795* 1801* rcp_access_kernel_ 000072 constant entry external dcl 209 ref 1035 1052 1060 1157 1184 rcp_audit 000074 constant entry external dcl 210 ref 1795 1801 rcp_cancel_id_$remove_schedule 000114 constant entry external dcl 227 ref 1583 rcp_compute_aim_mode$permissible_aim 000076 constant entry external dcl 212 ref 1229 1267 1297 1316 rcp_rbs 000170 automatic fixed bin(3,0) array dcl 1734 set ref 1745* 1746* 1795* 1801* rcp_reserve_$approve_schedule 000112 constant entry external dcl 225 ref 1165 1462 rcprm_find_op 000054 constant entry external dcl 199 ref 977 rcprm_journalize_ 000116 constant entry external dcl 229 ref 1635 rcprm_registry_util_$free_key 000130 constant entry external dcl 238 ref 1087 1092 1251 rcprm_registry_util_$grab_registry 000122 constant entry external dcl 232 ref 951 rcprm_registry_util_$grab_transaction_control_file 000120 constant entry external dcl 230 ref 572 rcprm_registry_util_$name_key 000134 constant entry external dcl 242 ref 997 1504 rcprm_registry_util_$owner_key 000136 constant entry external dcl 244 ref 920 rcprm_registry_util_$release_registry 000126 constant entry external dcl 236 ref 489 rcprm_registry_util_$release_transaction_control_file 000124 constant entry external dcl 234 ref 494 rcprm_registry_util_$system_key 000132 constant entry external dcl 240 ref 1094 rcprm_registry_util_$uid_key 000140 constant entry external dcl 246 ref 999 1211 1499 read_key 000275 automatic varying char(256) dcl 127 set ref 1128* 1134 rec_len 000376 automatic fixed bin(21,0) dcl 128 set ref 1002* 1098* reconstruct_operation 000377 automatic bit(1) initial dcl 129 set ref 129* 427* 493 568 932 957 977* 1067 1205 1635 record_descrip 000400 automatic fixed bin(35,0) dcl 130 set ref 603* 1214* 1275* 1472* 1497* 1502* 1556* record_length 2 001000 automatic fixed bin(21,0) level 2 in structure "rs" dcl 156 in procedure "rcprm_find_resource_" set ref 717 750 810 record_length 2 000762 automatic fixed bin(21,0) level 2 in structure "record_status" dcl 155 in procedure "rcprm_find_resource_" set ref 1013* record_ptr 001320 automatic pointer dcl 6-46 in procedure "rcprm_find_resource_" set ref 450* 1024* 1067 1141* 1150 1163 1165 1200 1202 1203 1206 1207 1209 1234 1248 1255 1263 1271 1276 1278 1279 1290 1301 1305 1311 1320 1335 1338 1338 1341 1346 1351 1354 1359 1372 1376 1381 1392 1397 1405 1405 1416 1418 1420 1421 1422 1423 1424 1425 1428 1431 1434 1437 1440 1443 1446 1449 1449 1462 1472 1488 1489 1490 1491 1492 1493 1494 1495 1499 1504 1525 1526 1543 1549 1550 1553 1558 1559 1560 1562 1563 1568 1569 1571 1574 1583 1591 1592 1594 1597 1691 1695 1702 1705 1707 1707 1709 1711 1714 1716 1718 1785 record_ptr 4 000762 automatic pointer level 2 in structure "record_status" dcl 155 in procedure "rcprm_find_resource_" set ref 449* 970 1024 1141 record_ptr 4 001000 automatic pointer level 2 in structure "rs" dcl 156 in procedure "rcprm_find_resource_" set ref 718 750 810 record_status 000762 automatic structure level 1 dcl 155 set ref 447* 965 965 1020 1020 1105* 1137 1137 1190 1190 ref_count 7 001000 automatic fixed bin(34,0) level 2 dcl 156 set ref 762 reg_name 000174 automatic char(32) packed unaligned dcl 1737 set ref 1766* 1767* registration_defaults 602 based structure level 3 dcl 7-16 registration_info 16 based structure level 2 dcl 6-5 registry 2 based char(32) array level 3 dcl 285 set ref 947 955* registry_dir 000401 automatic char(64) packed unaligned dcl 131 in procedure "rcprm_find_resource_" set ref 436* 572* 951* 1165* 1462* 1583* 1635* 1689 1767 registry_dir based char(64) level 2 in structure "resource_info" dcl 10-14 in procedure "rcprm_find_resource_" set ref 1689* registry_header based structure level 1 dcl 6-35 registry_open 000421 automatic char(32) packed unaligned dcl 132 set ref 445* 943 943 945* 947 951* 955 1046 1046 1331 1331 1388 1388 1401 1401 1523 1523 1574 1574 1597 1597 1692 1692 1766 1766 registry_record based structure level 1 dcl 6-5 set ref 1013 registry_record_ptr 22 based pointer level 2 dcl 10-14 set ref 1691* registry_switch_ptr 20 based pointer level 2 dcl 10-14 set ref 1690* rel_type 0(06) 001200 automatic fixed bin(2,0) level 5 packed packed unaligned dcl 164 set ref 771* release_lock 270(12) based bit(1) array level 4 in structure "resource_descriptions" packed packed unaligned dcl 4-6 in procedure "rcprm_find_resource_" set ref 1354 release_lock 13(01) based bit(1) level 4 in structure "registry_record" packed packed unaligned dcl 6-5 in procedure "rcprm_find_resource_" set ref 1354* 1421 1714 release_lock 267(04) based bit(1) array level 3 in structure "resource_descriptions" packed packed unaligned dcl 4-6 in procedure "rcprm_find_resource_" set ref 1354 1421* req_info 001062 automatic structure level 1 dcl 158 set ref 1034 1034 1035 1035 1051 1051 1052 1052 1060 1060 1156 1156 1157 1157 1184 1184 1794 1794 1795 1795 1801 1801 requestor_info based structure level 1 dcl 9-13 requestor_owner_id 000137 automatic varying char(32) dcl 114 set ref 460* 463* 464* 464 465* 465 465 605 res_info 001016 automatic structure level 1 dcl 157 set ref 1034 1034 1035 1035 1051 1051 1052 1052 1060 1060 1156 1156 1157 1157 1184 1184 1794 1794 1795 1795 1801 1801 reserver_chain 13(18) based bit(18) level 3 packed packed unaligned dcl 6-5 set ref 1165* 1255* 1462* 1583* reserver_info_ptr 000432 automatic pointer dcl 133 set ref 431* 1165* 1462* 1583* resource_desc_ptr 001312 automatic pointer dcl 4-72 set ref 444* 502 503 504* 530 537 538 539 540 541 542 544 545 547 547 551 551 560 560 579 638 660 932 934 934 934 943 945 977 977 987 987 997 997 999 1012 1067 1067 1067 1077 1079 1083 1091 1119 1163 1165* 1202 1203 1207 1209 1211 1216 1216 1241 1241 1256 1258 1259 1259 1285 1286 1287 1305 1309 1326 1328 1328 1341 1341 1341 1341 1341 1346 1346 1346 1346 1346 1351 1351 1354 1354 1358 1361 1376 1376 1376 1376 1376 1381 1381 1384 1386 1416 1416 1418 1418 1420 1421 1422 1423 1424 1425 1426 1429 1432 1435 1438 1441 1444 1447 1451 1462* 1527 1528 1583* 1619 1621 1621 1621 1626 1628 1628 1635* 1657* 1658 1659 1660 1666 1667 1693 resource_desc_version_1 constant fixed bin(17,0) initial dcl 4-75 ref 530 resource_descriptions based structure level 1 dcl 4-6 set ref 503 1657 1658 1666 resource_info based structure level 1 unaligned dcl 10-14 resource_info_$canonicalize_name 000104 constant entry external dcl 218 ref 934 resource_info_$default_attributes 000106 constant entry external dcl 220 ref 1079 resource_info_$get_type 000100 constant entry external dcl 214 ref 1046 resource_info_$lock_on_release 000102 constant entry external dcl 216 ref 1523 resource_info_$set_arbitrary_attributes 000110 constant entry external dcl 222 ref 1574 1597 resource_name 34 based char(32) level 2 packed packed unaligned dcl 10-14 set ref 1693* 1695* resource_type defined char(32) packed unaligned dcl 134 in procedure "rcprm_find_resource_" set ref 1046 1331* 1388* 1401* 1523* 1574* 1597* 1692 1766 resource_type 24 based char(32) level 2 in structure "resource_info" packed packed unaligned dcl 10-14 in procedure "rcprm_find_resource_" set ref 1692* rew 267 based bit(3) array level 3 packed packed unaligned dcl 4-6 set ref 1256* 1426* rk_header based structure level 1 unaligned dcl 15-26 rno 000434 automatic fixed bin(17,0) dcl 135 set ref 544* 545 547 547 551 551* 579* 638* 660 932 934 934 934 943 945 977 977 987 987 997 997 999 1012 1067 1067 1067 1077 1079 1083 1091 1119 1163 1165* 1202 1203 1207 1209 1211 1216 1216 1241 1241 1256 1258 1259 1259 1285 1286 1287 1305 1309 1326 1328 1328 1341 1341 1341 1341 1341 1346 1346 1346 1346 1346 1351 1351 1354 1354 1358 1361 1376 1376 1376 1376 1376 1381 1381 1384 1386 1416 1416 1418 1418 1420 1421 1422 1423 1424 1425 1426 1429 1432 1435 1438 1441 1444 1447 1451 1462* 1527 1528 1583* 1619* 1621 1621 1621* 1626* 1628 1628* 1693 rr_strl 001324 automatic fixed bin(17,0) dcl 6-46 set ref 1012* 1013 rs 001000 automatic structure level 1 dcl 156 set ref 708* 713 713 736* 746 746 758 758 799* 806 806 837* 841 841 rs_info based structure level 1 dcl 14-6 rs_info_version_2 constant fixed bin(17,0) initial dcl 14-44 ref 448 709 737 800 838 1106 rtde based structure level 1 dcl 7-16 rtde_size based fixed bin(18,0) level 2 dcl 6-35 ref 971 rtrim builtin function dcl 296 ref 456 464 605 921 1001 1012 1097 1202 1212 1252 1275 1275 1276 1276 1341 1341 1346 1346 1372 1372 1376 1376 1500 1505 save_code 000100 automatic fixed bin(35,0) dcl 1727 set ref 1743* 1754 1770 1772* 1793 1795 1801 1804 saved_code 000101 automatic fixed bin(35,0) dcl 479 set ref 481* 507 516 516* search 0(13) based bit(1) level 2 packed packed unaligned dcl 5-8 set ref 1049* 1059* 1182* seek_attr_flag 000435 automatic bit(1) dcl 136 set ref 440* 587 977* 1384 1459 simple_code 000436 automatic fixed bin(35,0) dcl 137 set ref 1033* 1036* size builtin function dcl 296 ref 1013 1234 1271 1301 1320 1335 1658 1666 sstruc_ptr 000440 automatic pointer dcl 138 set ref 444* 483 484 486 489 498 499 500* 560* 713 746 758 774 779 795 806 815 816 824 832 841 878 883 887 899 947 947 950 951 954 955 959 965 1002 1020 1098 1121 1128 1137 1190 1507 1511 1608 1610 1690 status_code 272 based fixed bin(35,0) array level 3 dcl 4-6 set ref 638* 660* string 24(09) based char level 4 in structure "registry_record" packed packed unaligned dcl 6-5 in procedure "rcprm_find_resource_" set ref 1163 1203* 1416 1504* 1695 string builtin function dcl 296 in procedure "rcprm_find_resource_" set ref 687* substr builtin function dcl 296 ref 457 465 1364 suffixed_name_$make 000226 constant entry external dcl 1738 ref 1766 sw_ptr 12 based pointer array level 3 dcl 285 set ref 484 486* 489* 713* 746* 758* 774* 779* 795* 806* 815* 816* 824* 832* 841* 878* 883* 887* 899* 951* 959* 965* 1002* 1020* 1098* 1121* 1128* 1137* 1190* 1507* 1511* 1610* 1690 switch_struc based structure level 1 dcl 285 set ref 499 560 swno 000442 automatic fixed bin(17,0) dcl 139 set ref 713 746 758 774 779 795 806 815 816 824 832 841 878 883 887 899 947* 947* 950 951 954 955 959 965 1002 1020 1098 1121 1128 1137 1190 1507 1511 1608* 1610 1612* 1690 sys_area based area dcl 280 ref 560 1657 sys_areap 000032 internal static pointer initial dcl 182 set ref 452 452* 560 1657 system 13(04) based bit(1) level 4 packed packed unaligned dcl 6-5 set ref 1278* 1472 1563* 1591 temp_acs_path 000443 automatic char(168) packed unaligned dcl 140 set ref 1361* 1362 1364 1367* 1367* 1372 1372 1372 1372 temp_atts based bit(72) array dcl 141 set ref 1151 1151 1327* 1328* 1331* 1335 1335 1335 1338 1388* 1393 1397 1401 1572* 1574* 1595* 1597* temp_bounds 000515 automatic bit(72) array dcl 142 in procedure "rcprm_find_resource_" set ref 1216* 1218* 1229* 1229* 1234 1234 1234 1259* 1261* 1267* 1271 1271 1271 1286* 1287 1297* 1301 1301 1301 1309* 1316* 1320 1320 1320 temp_bounds 001346 automatic bit(72) array dcl 684 in procedure "current_auth" set ref 686* 687 688* 688 689 temp_bounds_based based bit(72) array dcl 143 set ref 1267* 1297* 1316* temp_key 000521 automatic varying char(256) dcl 144 set ref 1001* 1002* 1097* 1098* 1134 1212* 1214* 1246* 1275* 1276* 1500* 1502* 1505* 1507* 1544* 1547* 1553* 1556* temp_mode 000742 automatic bit(3) packed unaligned dcl 148 set ref 1183* 1184* temp_non_var_key 000622 automatic char(256) packed unaligned dcl 145 set ref 997* 999* 1001 1087* 1092* 1094* 1097 1211* 1212 1251* 1252 1499* 1500 1504* 1505 temp_owner_name 000722 automatic char(32) packed unaligned dcl 146 set ref 605* 1241* 1243* 1246* 1275 1275 1276 1276 1276 1276 1278 1279 1547* 1552* 1553 1553 temp_relatts 000732 automatic bit(72) array dcl 147 set ref 1078* 1079* 1083* 1151 1151 1327 1328 1331 1335 1335 1335 1338 1386* 1388 1393 1397 1401 1401* 1405* 1572 1574 1595 1597 test_key 001360 automatic varying char(256) dcl 732 set ref 802* 804 816* 817* transaction_time 000744 automatic fixed bin(71,0) dcl 149 set ref 562* 971 1635* tsw_ptr 000746 automatic pointer dcl 150 set ref 444* 482 494* 568* 572* type 2 based char(32) array level 3 dcl 4-6 set ref 542 545 934* 943 945 1079* 1621* 1628* uid 22 based bit(36) array level 3 in structure "resource_descriptions" dcl 4-6 in procedure "rcprm_find_resource_" set ref 540 551 999* 1067 1207* 1209 1211* 1418* uid 270(01) based bit(1) array level 4 in structure "resource_descriptions" packed packed unaligned dcl 4-6 in procedure "rcprm_find_resource_" set ref 538 551 1067 1418 uid 16 based bit(36) level 3 in structure "registry_record" dcl 6-5 in procedure "rcprm_find_resource_" set ref 1067 1206* 1207 1209* 1418 1499* unspec builtin function dcl 296 set ref 447* 708* 736* 764* 799* 837* 870* 1105* 1151 1151 1768* 1769* 1772 1772 usage_lock 270(11) based bit(1) array level 4 in structure "resource_descriptions" packed packed unaligned dcl 4-6 in procedure "rcprm_find_resource_" set ref 1351 usage_lock 267(03) based bit(1) array level 3 in structure "resource_descriptions" packed packed unaligned dcl 4-6 in procedure "rcprm_find_resource_" set ref 1351 1422* 1527* usage_lock 13 based bit(1) level 4 in structure "registry_record" packed packed unaligned dcl 6-5 in procedure "rcprm_find_resource_" set ref 1351* 1422 1526* 1549* 1707 usedno 1 based fixed bin(17,0) initial level 2 dcl 285 set ref 483 560* 947 950 954* 1608 user_alloc 270(13) based bit(1) array level 4 in structure "resource_descriptions" packed packed unaligned dcl 4-6 in procedure "rcprm_find_resource_" set ref 1381 user_alloc 13(03) based bit(1) level 4 in structure "registry_record" packed packed unaligned dcl 6-5 in procedure "rcprm_find_resource_" set ref 1381* 1420 1568* 1592* 1711 user_alloc 267(06) based bit(1) array level 3 in structure "resource_descriptions" packed packed unaligned dcl 4-6 in procedure "rcprm_find_resource_" set ref 1381 1420* user_id based char(32) level 2 dcl 9-13 set ref 1680* 1684* validation_level 12 based fixed bin(3,0) level 2 dcl 9-13 set ref 1688* validity 000750 automatic fixed bin(17,0) dcl 151 set ref 1331* 1388* 1397 1400 version 0(27) 001200 automatic fixed bin(8,0) level 4 in structure "get_key_info" packed packed unaligned dcl 164 in procedure "rcprm_find_resource_" set ref 772* version 001000 automatic fixed bin(17,0) level 2 in structure "rs" dcl 156 in procedure "rcprm_find_resource_" set ref 709* 737* 800* 838* version 000762 automatic fixed bin(17,0) level 2 in structure "record_status" dcl 155 in procedure "rcprm_find_resource_" set ref 448* 1106* version_no based fixed bin(17,0) level 2 dcl 4-6 ref 530 who_am_i 000751 automatic char(32) packed unaligned dcl 152 set ref 312* 324* 332* 346* 359* 371* 383* 395* 408* 416* 428* 1795* 1801* wordcount 000100 automatic fixed bin(19,0) dcl 1653 set ref 1658* 1659 1666* 1667 xxx 2 based structure array level 2 dcl 285 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 Action_noun internal static char(12) initial array packed unaligned dcl 11-13 CRASH internal static fixed bin(17,0) initial dcl 18-7 DIR_ACCESS_MODE_NAMES internal static char(4) initial array packed unaligned dcl 1-33 Direct_input internal static fixed bin(17,0) initial dcl 13-15 Direct_output internal static fixed bin(17,0) initial dcl 13-15 Direct_update internal static fixed bin(17,0) initial dcl 13-15 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 JUST_LOG internal static fixed bin(17,0) initial dcl 18-7 Keyed_sequential_input internal static fixed bin(17,0) initial dcl 13-15 Keyed_sequential_output internal static fixed bin(17,0) initial dcl 13-15 Keyed_sequential_update internal static fixed bin(17,0) initial dcl 13-15 LOG internal static fixed bin(17,0) initial dcl 18-7 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_BIN internal static fixed bin(5,0) initial dcl 1-36 N_CHARGE_TYPES automatic fixed bin(17,0) dcl 7-64 N_MATES automatic fixed bin(17,0) dcl 7-64 N_SUBTYPES automatic fixed bin(17,0) dcl 7-64 REGISTRY_NAME_KEY_HEAD internal static varying char(16) initial dcl 16-5 REGISTRY_OWNER_KEY_HEAD internal static varying char(16) initial dcl 16-5 REGISTRY_UID_KEY_HEAD internal static varying char(16) initial dcl 16-5 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 RE_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 RTDE_SIZE automatic fixed bin(18,0) dcl 6-42 RTDT_area_len automatic fixed bin(18,0) dcl 7-64 RTDT_version_2 internal static fixed bin(17,0) initial dcl 7-64 RTDT_version_3 internal static fixed bin(17,0) initial dcl 7-64 RW_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 RW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 R_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 R_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 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 SYSERR_COVERT_CHANNEL internal static fixed bin(17,0) initial dcl 18-7 SYSERR_CRASH_SYSTEM internal static fixed bin(17,0) initial dcl 18-7 SYSERR_LOG_OR_DISCARD internal static fixed bin(17,0) initial dcl 18-7 SYSERR_LOG_OR_PRINT internal static fixed bin(17,0) initial dcl 18-7 SYSERR_PRINT_ON_CONSOLE internal static fixed bin(17,0) initial dcl 18-7 SYSERR_PRINT_WITH_ALARM internal static fixed bin(17,0) initial dcl 18-7 SYSERR_RING1_ERROR internal static fixed bin(17,0) initial dcl 18-7 SYSERR_SUCCESSFUL_ACCESS internal static fixed bin(17,0) initial dcl 18-7 SYSERR_SYSTEM_ERROR internal static fixed bin(17,0) initial dcl 18-7 SYSERR_TERMINATE_PROCESS internal static fixed bin(17,0) initial dcl 18-7 SYSERR_UNSUCCESSFUL_ACCESS internal static fixed bin(17,0) initial dcl 18-7 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 Sequential_input internal static fixed bin(17,0) initial dcl 13-15 Sequential_input_output internal static fixed bin(17,0) initial dcl 13-15 Sequential_output internal static fixed bin(17,0) initial dcl 13-15 Sequential_update internal static fixed bin(17,0) initial dcl 13-15 Stream_input internal static fixed bin(17,0) initial dcl 13-15 Stream_input_output internal static fixed bin(17,0) initial dcl 13-15 Stream_output internal static fixed bin(17,0) initial dcl 13-15 TERMINATE_PROCESS internal static fixed bin(17,0) initial dcl 18-7 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 ak_info based structure level 1 unaligned dcl 15-6 ak_key_len automatic fixed bin(17,0) dcl 15-19 charge_type_table based structure level 1 dcl 7-11 cttp automatic pointer dcl 7-70 gk_info based structure level 1 unaligned dcl 15-41 gk_key_len automatic fixed bin(17,0) dcl 15-64 iox_$attach_loud 000000 constant entry external dcl 12-8 iox_$attach_name 000000 constant entry external dcl 12-8 iox_$attach_ptr 000000 constant entry external dcl 12-8 iox_$close 000000 constant entry external dcl 12-8 iox_$close_file 000000 constant entry external dcl 12-8 iox_$destroy_iocb 000000 constant entry external dcl 12-8 iox_$detach 000000 constant entry external dcl 12-8 iox_$detach_iocb 000000 constant entry external dcl 12-8 iox_$err_no_operation 000000 constant entry external dcl 12-8 iox_$err_not_attached 000000 constant entry external dcl 12-8 iox_$err_not_closed 000000 constant entry external dcl 12-8 iox_$err_not_open 000000 constant entry external dcl 12-8 iox_$error_output external static pointer dcl 12-41 iox_$find_iocb 000000 constant entry external dcl 12-8 iox_$find_iocb_n 000000 constant entry external dcl 12-8 iox_$get_chars 000000 constant entry external dcl 12-8 iox_$get_line 000000 constant entry external dcl 12-8 iox_$look_iocb 000000 constant entry external dcl 12-8 iox_$modes 000000 constant entry external dcl 12-8 iox_$move_attach 000000 constant entry external dcl 12-8 iox_$open 000000 constant entry external dcl 12-8 iox_$open_file 000000 constant entry external dcl 12-8 iox_$propagate 000000 constant entry external dcl 12-8 iox_$put_chars 000000 constant entry external dcl 12-8 iox_$read_length 000000 constant entry external dcl 12-8 iox_$read_record 000000 constant entry external dcl 12-8 iox_$rewrite_record 000000 constant entry external dcl 12-8 iox_$user_input external static pointer dcl 12-41 iox_$user_io external static pointer dcl 12-41 iox_$user_output external static pointer dcl 12-41 iox_modes internal static char(24) initial array dcl 13-6 requestor_info_ptr automatic pointer dcl 9-11 reservation_description based structure level 1 dcl 4-55 resource_info_ptr automatic pointer dcl 10-12 resource_res_ptr automatic pointer dcl 4-72 resource_res_version_1 internal static fixed bin(17,0) initial dcl 4-75 rk_info based structure level 1 unaligned dcl 15-22 rk_info_ptr automatic pointer dcl 15-37 rk_key_len automatic fixed bin(17,0) dcl 15-38 rs_desc based structure level 1 packed packed unaligned dcl 14-32 rs_info_ptr automatic pointer dcl 14-5 rs_info_version_1 internal static fixed bin(17,0) initial dcl 14-43 rtdep automatic pointer dcl 7-70 rtdt based structure level 1 dcl 7-3 rtdtp automatic pointer dcl 7-70 seq_desc based structure level 1 packed packed unaligned dcl 14-37 short_iox_modes internal static char(4) initial array dcl 13-12 sys_info$max_seg_size external static fixed bin(35,0) dcl 274 NAMES DECLARED BY EXPLICIT CONTEXT. MAIN_RETURN 002104 constant label dcl 638 ref 589 597 acquire 000433 constant entry external dcl 304 acquire 006755 constant entry internal dcl 1239 in procedure "rcprm_find_resource_" ref 609 614 audit 013703 constant entry internal dcl 1723 ref 646 669 auto_register 001121 constant entry external dcl 398 cancel 012634 constant entry internal dcl 1580 in procedure "rcprm_find_resource_" ref 635 cancel 000744 constant entry external dcl 367 chase 002504 constant entry internal dcl 693 ref 1150 1263 1290 1311 1392 1428 1431 1434 1437 1440 1443 1446 1449 1543 1571 1594 1785 clean_up 002150 constant entry internal dcl 472 ref 468 673 1640 clear 000535 constant entry external dcl 327 clear 012230 constant entry internal dcl 1536 in procedure "rcprm_find_resource_" ref 624 629 common_1 001263 constant label dcl 431 ref 347 360 372 common_2 001267 constant label dcl 434 ref 313 325 333 384 396 409 417 429 current_auth 002451 constant entry internal dcl 681 ref 1218 1261 deregister 001176 constant entry external dcl 411 deregister 011373 constant entry internal dcl 1477 in procedure "rcprm_find_resource_" ref 633 error_common 002413 constant label dcl 669 set ref 662 error_return 002403 constant entry internal dcl 664 ref 530 573 637 879 900 967 1022 1038 1615 1641 error_return_in_struc 002362 constant entry internal dcl 652 ref 547 551 641 714 747 759 776 781 807 819 828 833 842 888 892 937 952 962 979 987 1004 1008 1036 1047 1053 1067 1080 1102 1125 1131 1134 1138 1191 1230 1268 1298 1305 1317 1332 1359 1364 1368 1389 1393 1402 1409 1464 1508 1512 1531 1575 1585 1599 get_resource_descriptions 013341 constant entry internal dcl 1649 ref 528 insert_descriptor 003575 constant entry internal dcl 851 ref 1234 1271 1301 1320 1335 1341 1346 1372 1376 1488 1489 1490 1491 1492 1493 1494 1495 1558 1559 1560 make_owner_key 004163 constant entry internal dcl 908 ref 1246 1544 1547 priv_acquire 000407 constant entry external dcl 299 priv_cancel 000720 constant entry external dcl 362 priv_release 000462 constant entry external dcl 315 priv_reserve 000571 constant entry external dcl 335 priv_set 001046 constant entry external dcl 386 priv_status 000773 constant entry external dcl 374 process_end 012770 constant entry internal dcl 1605 ref 648 put_resource_descriptions 013403 constant entry internal dcl 1663 ref 672 1639 rcprm_find_resource_ 000374 constant entry external dcl 14 reconstruct 001232 constant entry external dcl 419 register 006455 constant entry internal dcl 1197 in procedure "rcprm_find_resource_" ref 608 register 001145 constant entry external dcl 403 release 000506 constant entry external dcl 320 release 012144 constant entry internal dcl 1517 in procedure "rcprm_find_resource_" ref 623 reserve 000615 constant entry external dcl 342 reserve 011255 constant entry internal dcl 1456 in procedure "rcprm_find_resource_" ref 631 reserve_proxy 000650 constant entry external dcl 349 return_hard 002144 constant label dcl 677 ref 674 save_code_if_error 002352 constant entry internal dcl 513 ref 487 490 495 seek_attr 005503 constant entry internal dcl 1072 ref 596 seek_specific 004666 constant entry internal dcl 983 ref 588 set 001072 constant entry external dcl 391 set 007402 constant entry internal dcl 1283 in procedure "rcprm_find_resource_" ref 619 setup_kernel_call 013425 constant entry internal dcl 1672 ref 1034 1051 1156 1794 setup_request 004271 constant entry internal dcl 926 ref 583 simple_checks 013551 constant entry internal dcl 1699 ref 1029 1146 status 001017 constant entry external dcl 379 status 010712 constant entry internal dcl 1413 in procedure "rcprm_find_resource_" ref 611 616 620 627 subset 007676 constant entry internal dcl 1324 ref 610 615 swap_descriptor 002614 constant entry internal dcl 724 ref 859 1276 1553 swap_key 003642 constant entry internal dcl 863 ref 1214 1275 1472 1497 1502 1556 try_another_resource 006342 constant label dcl 1172 ref 1147 1151 1159 1167 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 15736 16172 14413 15746 Length 17210 14413 234 1001 1323 24 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME rcprm_find_resource_ 2058 external procedure is an external procedure. on unit on line 468 74 on unit clean_up 98 internal procedure is called by several nonquick procedures. save_code_if_error internal procedure shares stack frame of internal procedure clean_up. error_return_in_struc 82 internal procedure is called by several nonquick procedures. current_auth internal procedure shares stack frame of external procedure rcprm_find_resource_. chase 90 internal procedure is called by several nonquick procedures. swap_descriptor internal procedure shares stack frame of external procedure rcprm_find_resource_. insert_descriptor internal procedure shares stack frame of external procedure rcprm_find_resource_. swap_key 158 internal procedure is called during a stack extension. make_owner_key 146 internal procedure uses returns(char(*)) or returns(bit(*)), and is called during a stack extension. setup_request internal procedure shares stack frame of external procedure rcprm_find_resource_. seek_specific internal procedure shares stack frame of external procedure rcprm_find_resource_. seek_attr internal procedure shares stack frame of external procedure rcprm_find_resource_. register internal procedure shares stack frame of external procedure rcprm_find_resource_. acquire internal procedure shares stack frame of external procedure rcprm_find_resource_. set internal procedure shares stack frame of external procedure rcprm_find_resource_. status internal procedure shares stack frame of external procedure rcprm_find_resource_. reserve internal procedure shares stack frame of external procedure rcprm_find_resource_. deregister internal procedure shares stack frame of external procedure rcprm_find_resource_. release internal procedure shares stack frame of external procedure rcprm_find_resource_. clear internal procedure shares stack frame of external procedure rcprm_find_resource_. cancel internal procedure shares stack frame of external procedure rcprm_find_resource_. process_end internal procedure shares stack frame of external procedure rcprm_find_resource_. get_resource_descriptions 65 internal procedure is called by several nonquick procedures. setup_kernel_call 79 internal procedure is called by several nonquick procedures. simple_checks internal procedure shares stack frame of external procedure rcprm_find_resource_. audit 256 internal procedure is called by several nonquick procedures. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 my_owner_id rcprm_find_resource_ 000021 my_group_id rcprm_find_resource_ 000032 sys_areap rcprm_find_resource_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME audit 000100 save_code audit 000101 bl audit 000102 bp audit 000104 current_owner audit 000114 path audit 000166 raw_mode audit 000170 rcp_rbs audit 000172 local_code audit 000173 auto_event_flags audit 000174 reg_name audit clean_up 000100 i clean_up 000101 saved_code clean_up error_return_in_struc 000100 bad_code error_return_in_struc get_resource_descriptions 000100 wordcount get_resource_descriptions make_owner_key 000100 key make_owner_key rcprm_find_resource_ 000100 action rcprm_find_resource_ 000101 audit_obj_ok rcprm_find_resource_ 000102 auto_registration rcprm_find_resource_ 000103 base_rno rcprm_find_resource_ 000104 base_given_uid rcprm_find_resource_ 000105 base_given_name rcprm_find_resource_ 000106 base_uid rcprm_find_resource_ 000107 base_name rcprm_find_resource_ 000117 base_type rcprm_find_resource_ 000127 bl rcprm_find_resource_ 000130 bp rcprm_find_resource_ 000132 callers_rdp rcprm_find_resource_ 000134 clear_ok rcprm_find_resource_ 000135 code rcprm_find_resource_ 000136 cur_level rcprm_find_resource_ 000137 requestor_owner_id rcprm_find_resource_ 000150 current_rew rcprm_find_resource_ 000151 found rcprm_find_resource_ 000152 is_volume rcprm_find_resource_ 000153 lock_sw rcprm_find_resource_ 000154 old_key rcprm_find_resource_ 000255 operation rcprm_find_resource_ 000256 operation_ptr rcprm_find_resource_ 000260 priv_sw rcprm_find_resource_ 000261 prev_level rcprm_find_resource_ 000262 proxy_authorization rcprm_find_resource_ 000264 proxy_call rcprm_find_resource_ 000265 proxy_group_id rcprm_find_resource_ 000275 read_key rcprm_find_resource_ 000376 rec_len rcprm_find_resource_ 000377 reconstruct_operation rcprm_find_resource_ 000400 record_descrip rcprm_find_resource_ 000401 registry_dir rcprm_find_resource_ 000421 registry_open rcprm_find_resource_ 000432 reserver_info_ptr rcprm_find_resource_ 000434 rno rcprm_find_resource_ 000435 seek_attr_flag rcprm_find_resource_ 000436 simple_code rcprm_find_resource_ 000440 sstruc_ptr rcprm_find_resource_ 000442 swno rcprm_find_resource_ 000443 temp_acs_path rcprm_find_resource_ 000515 temp_bounds rcprm_find_resource_ 000521 temp_key rcprm_find_resource_ 000622 temp_non_var_key rcprm_find_resource_ 000722 temp_owner_name rcprm_find_resource_ 000732 temp_relatts rcprm_find_resource_ 000742 temp_mode rcprm_find_resource_ 000744 transaction_time rcprm_find_resource_ 000746 tsw_ptr rcprm_find_resource_ 000750 validity rcprm_find_resource_ 000751 who_am_i rcprm_find_resource_ 000762 record_status rcprm_find_resource_ 001000 rs rcprm_find_resource_ 001016 res_info rcprm_find_resource_ 001062 req_info rcprm_find_resource_ 001075 add_key_info rcprm_find_resource_ 001200 get_key_info rcprm_find_resource_ 001312 resource_desc_ptr rcprm_find_resource_ 001314 Resource_count rcprm_find_resource_ 001316 ops_ptr rcprm_find_resource_ 001320 record_ptr rcprm_find_resource_ 001322 header_ptr rcprm_find_resource_ 001324 rr_strl rcprm_find_resource_ 001326 ak_info_ptr rcprm_find_resource_ 001330 gk_info_ptr rcprm_find_resource_ 001346 temp_bounds current_auth 001360 test_key swap_descriptor 001461 found swap_descriptor THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as alloc_char_temp alloc_bit_temp call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other return_mac tra_ext_1 enable_op shorten_stack ext_entry ext_entry_desc int_entry int_entry_desc return_chars_eis op_alloc_ op_freen_ clock_mac THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. absolute_pathname_$add_suffix access_audit_r1_$log_obj_path admin_gate_$make_uid admin_gate_$syserr admin_gate_$syserr_error_code cu_$level_get cu_$level_set cv_rcp_attributes_$make_rel cv_rcp_attributes_$modify_rel cv_rcp_attributes_$test_valid get_group_id_ get_process_authorization_ get_ring_ get_system_free_area_ hcs_$get_authorization iox_$control iox_$delete_record iox_$position iox_$read_key iox_$seek_key iox_$write_record pathname_ rcp_access_kernel_ rcp_audit rcp_cancel_id_$remove_schedule rcp_compute_aim_mode$permissible_aim rcp_reserve_$approve_schedule rcprm_find_op rcprm_journalize_ rcprm_registry_util_$free_key rcprm_registry_util_$grab_registry rcprm_registry_util_$grab_transaction_control_file rcprm_registry_util_$name_key rcprm_registry_util_$owner_key rcprm_registry_util_$release_registry rcprm_registry_util_$release_transaction_control_file rcprm_registry_util_$system_key rcprm_registry_util_$uid_key resource_info_$canonicalize_name resource_info_$default_attributes resource_info_$get_type resource_info_$lock_on_release resource_info_$set_arbitrary_attributes suffixed_name_$make THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$action_not_performed error_table_$bad_resource_spec error_table_$duplicate_request error_table_$end_of_info error_table_$namedup error_table_$no_record error_table_$not_abs_path error_table_$not_privileged error_table_$not_seg_type error_table_$rcp_attr_not_permitted error_table_$rcp_bad_attributes error_table_$resource_awaiting_clear error_table_$resource_bad_access error_table_$resource_free error_table_$resource_locked error_table_$resource_not_free error_table_$resource_unavailable error_table_$resource_unknown error_table_$unimplemented_version error_table_$unsupported_operation LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 101 000365 122 000366 125 000367 129 000370 14 000373 16 000402 299 000403 302 000426 304 000430 311 000452 312 000454 313 000457 315 000460 318 000501 320 000503 323 000525 324 000527 325 000532 327 000533 330 000554 331 000556 332 000560 333 000563 335 000564 340 000610 342 000612 345 000634 346 000636 347 000641 349 000642 355 000674 356 000676 357 000700 358 000706 359 000712 360 000715 362 000716 365 000737 367 000741 370 000763 371 000765 372 000770 374 000771 377 001012 379 001014 382 001036 383 001040 384 001043 386 001044 389 001065 391 001067 394 001111 395 001113 396 001116 398 001117 401 001140 403 001142 406 001164 407 001166 408 001170 409 001173 411 001174 414 001215 415 001217 416 001221 417 001224 419 001225 425 001251 426 001253 427 001256 428 001257 429 001262 431 001263 434 001267 436 001270 437 001276 438 001277 439 001301 440 001305 441 001306 443 001307 444 001316 445 001324 447 001327 448 001332 449 001334 450 001336 452 001337 454 001351 455 001357 456 001365 457 001406 460 001414 463 001425 464 001432 465 001450 468 001456 525 001507 526 001516 528 001525 530 001531 537 001543 538 001555 539 001564 540 001567 541 001571 542 001575 544 001601 545 001611 547 001620 551 001642 555 001664 556 001666 560 001670 562 001705 568 001707 572 001717 573 001740 579 001750 583 001761 587 001762 588 001765 589 001766 591 001770 596 001771 597 001772 603 001774 604 001776 605 002000 607 002015 608 002020 609 002021 610 002022 611 002023 612 002024 613 002025 614 002027 615 002030 616 002031 617 002032 618 002033 619 002035 620 002036 621 002037 622 002040 623 002042 624 002044 626 002050 627 002051 629 002055 631 002061 633 002065 635 002071 637 002075 638 002104 641 002115 642 002123 646 002125 648 002141 649 002142 650 002143 677 002144 679 002146 472 002147 481 002155 482 002156 483 002163 484 002173 485 002202 486 002206 487 002242 489 002243 490 002260 492 002261 493 002263 494 002267 495 002301 498 002302 499 002307 500 002314 502 002317 503 002323 504 002331 507 002334 510 002342 511 002351 513 002352 516 002353 519 002360 652 002361 660 002367 661 002377 662 002401 664 002402 667 002410 669 002413 671 002422 672 002425 673 002432 674 002446 681 002451 686 002453 687 002462 688 002464 689 002466 693 002503 702 002511 703 002514 704 002516 705 002517 708 002520 709 002524 710 002526 711 002530 713 002532 714 002573 717 002605 718 002611 720 002613 724 002614 736 002632 737 002635 741 002637 743 002642 744 002644 746 002645 747 002707 750 002717 752 002732 753 002734 756 002735 758 002737 759 003001 762 003011 764 003014 765 003017 766 003021 767 003023 768 003026 769 003030 770 003032 771 003037 772 003043 774 003045 776 003103 779 003113 781 003126 788 003136 789 003141 790 003142 793 003143 795 003144 797 003176 799 003200 800 003203 802 003205 804 003217 806 003234 807 003276 810 003306 814 003324 815 003326 816 003350 817 003370 819 003376 822 003406 824 003407 827 003444 828 003445 831 003456 832 003460 833 003500 837 003510 838 003513 839 003515 841 003517 842 003561 845 003571 847 003574 851 003575 859 003606 861 003640 863 003641 870 003655 871 003661 872 003665 874 003670 875 003676 876 003700 878 003704 879 003743 883 003755 884 004006 887 004022 888 004045 890 004057 891 004060 892 004062 895 004073 896 004102 897 004105 899 004111 900 004147 904 004161 908 004162 915 004176 917 004213 920 004226 921 004250 926 004271 932 004272 934 004303 937 004340 943 004350 945 004365 947 004372 948 004412 950 004414 951 004420 952 004451 954 004461 955 004464 957 004471 959 004500 960 004524 962 004532 965 004542 967 004604 970 004614 971 004616 977 004625 979 004655 981 004665 983 004666 987 004667 992 004711 997 004716 999 004755 1001 005003 1002 005023 1004 005042 1007 005060 1008 005062 1011 005073 1012 005076 1013 005115 1016 005124 1018 005132 1020 005134 1022 005176 1024 005206 1025 005210 1029 005212 1032 005213 1033 005215 1034 005216 1035 005234 1036 005257 1038 005271 1039 005277 1046 005300 1047 005324 1049 005334 1051 005346 1052 005364 1053 005407 1058 005420 1059 005426 1060 005432 1067 005455 1070 005502 1072 005503 1077 005504 1078 005513 1079 005530 1080 005555 1082 005565 1083 005566 1087 005610 1090 005633 1091 005635 1092 005644 1093 005663 1094 005664 1097 005703 1098 005723 1099 005742 1100 005744 1102 005751 1105 005757 1106 005762 1108 005764 1116 005765 1118 005770 1119 005771 1121 006000 1125 006022 1128 006032 1129 006052 1131 006060 1134 006070 1137 006105 1138 006147 1141 006157 1142 006161 1146 006163 1147 006164 1150 006166 1151 006201 1156 006216 1157 006235 1159 006260 1162 006262 1163 006265 1165 006300 1167 006336 1171 006340 1172 006342 1175 006343 1182 006344 1183 006350 1184 006351 1188 006374 1189 006376 1190 006400 1191 006442 1193 006452 1195 006454 1197 006455 1200 006456 1202 006461 1203 006501 1205 006513 1206 006517 1207 006526 1208 006534 1209 006535 1211 006540 1212 006570 1214 006610 1216 006634 1218 006667 1228 006677 1229 006701 1230 006713 1234 006723 1237 006754 1239 006755 1241 006756 1243 006772 1246 007000 1248 007026 1251 007034 1252 007053 1255 007073 1256 007076 1258 007105 1259 007115 1261 007145 1263 007155 1264 007170 1267 007174 1268 007207 1271 007217 1275 007250 1276 007313 1278 007360 1279 007371 1281 007401 1283 007402 1285 007403 1286 007411 1287 007434 1290 007443 1291 007456 1297 007462 1298 007475 1301 007505 1305 007536 1309 007560 1311 007602 1312 007615 1316 007621 1317 007634 1320 007644 1324 007675 1326 007677 1327 007713 1328 007730 1331 007737 1332 007764 1335 007774 1338 010025 1341 010047 1346 010122 1351 010175 1354 010212 1358 010223 1359 010226 1361 010241 1362 010250 1364 010255 1367 010271 1368 010317 1372 010327 1376 010370 1381 010443 1384 010460 1386 010466 1388 010510 1389 010535 1392 010545 1393 010560 1397 010602 1400 010614 1401 010616 1402 010647 1405 010657 1407 010701 1409 010702 1411 010711 1413 010712 1416 010713 1418 010732 1420 010741 1421 010747 1422 010754 1423 010761 1424 010766 1425 010772 1426 010776 1428 011002 1429 011014 1431 011025 1432 011040 1434 011051 1435 011064 1437 011075 1438 011110 1440 011121 1441 011134 1443 011145 1444 011160 1446 011173 1447 011206 1449 011221 1451 011240 1454 011253 1456 011255 1459 011256 1462 011261 1464 011320 1472 011330 1475 011372 1477 011373 1488 011374 1489 011424 1490 011454 1491 011504 1492 011534 1493 011564 1494 011614 1495 011644 1497 011674 1499 011725 1500 011751 1502 011771 1504 012015 1505 012050 1507 012070 1508 012110 1511 012120 1512 012133 1515 012143 1517 012144 1521 012146 1523 012152 1524 012173 1525 012176 1526 012201 1527 012203 1528 012210 1529 012212 1531 012217 1534 012227 1536 012230 1542 012231 1543 012234 1544 012247 1545 012305 1547 012307 1549 012335 1550 012341 1552 012343 1553 012346 1556 012402 1558 012434 1559 012464 1560 012514 1562 012544 1563 012547 1568 012551 1569 012553 1571 012556 1572 012570 1574 012576 1575 012623 1578 012633 1580 012634 1583 012635 1585 012674 1591 012704 1592 012710 1594 012712 1595 012724 1597 012732 1599 012757 1603 012767 1605 012770 1608 012771 1610 013005 1611 013043 1612 013045 1615 013074 1617 013102 1619 013104 1621 013117 1624 013160 1626 013163 1628 013175 1631 013250 1635 013252 1639 013311 1640 013315 1641 013327 1644 013337 1649 013340 1655 013346 1656 013353 1657 013355 1658 013371 1659 013374 1661 013401 1663 013402 1666 013410 1667 013415 1668 013423 1672 013424 1679 013432 1680 013436 1681 013444 1682 013447 1684 013450 1685 013464 1688 013477 1689 013505 1690 013512 1691 013517 1692 013523 1693 013530 1695 013543 1696 013550 1699 013551 1702 013552 1705 013570 1707 013602 1709 013617 1711 013634 1714 013645 1716 013662 1718 013671 1720 013701 1723 013702 1743 013710 1744 013713 1745 013714 1746 013724 1747 013726 1754 013727 1765 013741 1766 013747 1767 014001 1768 014026 1769 014033 1770 014034 1771 014042 1772 014047 1774 014123 1782 014124 1785 014132 1786 014146 1788 014154 1793 014160 1794 014162 1795 014204 1797 014274 1801 014275 1804 014366 1805 014371 ----------------------------------------------------------- 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