COMPILATION LISTING OF SEGMENT copy_pdir_ Compiled by: Multics PL/I Compiler, Release 33e, of October 6, 1992 Compiled at: CGI Compiled on: 2000-04-17_1922.20_Mon_mdt Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1988 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1984 * 6* * * 7* *********************************************************** */ 8 9 copy_pdir_: proc(); 10 11 /* format: off */ 12 13 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 14 /* */ 15 /* This is a tool to copy process directories from the >pdd directory. */ 16 /* */ 17 /* Status: */ 18 /* */ 19 /* 0) Created: June 1984 by B. Braun */ 20 /* 1) Modified: 30 Nov 84 by B. Braun to: */ 21 /* - remove call to hcs_$get_access_class from copy_pdir. It's not needed. */ 22 /* - correct the cleanup handler to not delete the newly copied dir when it */ 23 /* can't delete the original one. */ 24 /* 2) Modified: 20 Jan 85 by B. Braun to remove write acces off the initial acl for segs. */ 25 /* */ 26 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 27 28 29 30 /****^ HISTORY COMMENTS: 31* 1) change(87-07-18,GDixon), approve(88-03-09,MCR7861), 32* audit(88-07-08,Farley), install(88-07-12,MR12.2-1055): 33* A) Add copy_pdir_$liveproc entrypoint. 34* B) Add special-casing for copying Initializer liveproc. 35* C) Correct references to names returned by hcs_$star_. 36* 2) change(87-11-11,GDixon), approve(88-03-09,MCR7861), 37* audit(88-07-08,Farley), install(88-07-12,MR12.2-1055): 38* A) Change copy_pdir internal proc to copy through links in the process 39* directory. The pdir usually does not contain links. If such links 40* exist, it probably means the user has placed them there to force 41* copy_deadproc or copy_liveproc to copy some segment not normally 42* kept in the pdir. 43* 3) change(89-02-27,TLNguyen), approve(89-02-27,MCR8049), 44* audit(89-02-28,Parisek), install(89-03-15,MR12.3-1025): 45* Replaced create_branch_version_1 with create_branch_version_2. 46* END HISTORY COMMENTS */ 47 48 49 50 dcl adjust_bit_count_ entry (char(168), char(32), bit(1) aligned, fixed bin(35), fixed bin(35)); 51 dcl amu_$dp_create_uid_hash entry (char(*), fixed bin(35)); 52 dcl com_err_ entry() options(variable); 53 dcl cv_bin_$dec entry (fixed bin, char(12) aligned); 54 dcl cv_bin_$oct entry (fixed bin, char(12) aligned); 55 dcl cv_userid_ entry (char(*)) returns(char(32)); 56 dcl delete_$path entry (char(*), char(*), bit(36) aligned, char(*), fixed bin(35)); 57 dcl delete_$ptr entry (ptr, bit(36) aligned, char(*), fixed bin(35)); 58 dcl expand_pathname_ entry (char(*), char(*), char(*), fixed bin(35)); 59 dcl get_ring_ entry() returns(fixed bin(3)); 60 dcl get_system_free_area_ entry returns (ptr); 61 dcl (hcs_$add_acl_entries, hphcs_$add_acl_entries) 62 entry (char(*), char(*), ptr, fixed bin, fixed bin(35)); 63 dcl hcs_$add_dir_acl_entries entry (char(*), char(*), ptr, fixed bin, fixed bin(35)); 64 dcl hcs_$add_dir_inacl_entries entry (char(*), char(*), ptr, fixed bin, fixed bin(3), fixed bin(35)); 65 dcl hcs_$add_inacl_entries entry (char(*), char(*), ptr, fixed bin, fixed bin(3), fixed bin(35)); 66 dcl hcs_$create_branch_ entry (char(*), char(*), ptr, fixed bin(35)); 67 dcl hcs_$fs_move_file entry (char(*), char(*), fixed bin(2), char(*), char(*), fixed bin(35)); 68 dcl hcs_$get_uid_seg entry (ptr, bit(36) aligned, fixed bin(35)); 69 dcl hcs_$make_seg entry (char(*), char(*), char(*), fixed bin(5), ptr, fixed bin(35)); 70 dcl hcs_$set_bc entry (char(*), char(*), fixed bin(24), fixed bin(35)); 71 dcl hcs_$set_dir_ring_brackets entry (char(*), char(*), (2)fixed bin(3), fixed bin(35)); 72 dcl hcs_$set_max_length_seg entry (ptr, fixed bin(19), fixed bin(35)); 73 dcl hcs_$set_ring_brackets entry (char(*), char(*), (3)fixed bin(3), fixed bin(35)); 74 dcl hcs_$star_ entry (char(*), char(*), fixed bin(2), ptr, fixed bin, ptr, ptr, fixed bin(35)); 75 dcl hcs_$status_minf entry (char (*), char (*), fixed bin (1), fixed bin (2), fixed bin (24), fixed bin (35)); 76 dcl hphcs_$set_dir_ring_brackets entry (char(*), char(*), (3)fixed bin(3), fixed bin(35)); 77 dcl hphcs_$set_ring_brackets entry (char(*), char(*), (3)fixed bin(3), fixed bin(35)); 78 dcl get_group_id_$tag_star entry() returns(char(32)); 79 dcl get_pdir_ entry() returns(char(168)); 80 dcl nd_handler_ entry (char(*), char(*), char(*), fixed bin(35)); 81 dcl pathname_ entry (char(*), char(*)) returns(char(168)); 82 dcl phcs_$initiate entry (char (*), char (*), char (*), fixed bin (1), fixed bin (2), ptr, 83 fixed bin (35)); 84 dcl ring0_get_$segptr entry (char(*), char(*), ptr, fixed bin(35)); 85 dcl ring_zero_peek_ entry (ptr, ptr, fixed bin(19), fixed bin(35)); 86 dcl ring_zero_peek_$by_definition entry (char(*), char(*), fixed bin(18), ptr, fixed bin(19), fixed bin(35)); 87 dcl system_info_$sysid entry (char(*)); 88 dcl terminate_file_ entry (ptr, fixed bin(24), bit(*), fixed bin(35)); 89 90 dcl ( 91 error_table_$action_not_performed, 92 error_table_$empty_file, 93 error_table_$infcnt_non_zero, 94 error_table_$namedup, 95 error_table_$nomatch, 96 error_table_$segknown 97 ) fixed bin(35) ext static; 98 99 /* Options Constant */ 100 101 dcl ( 102 CHASE init(1) fixed bin(1), 103 HC_SEGS (4) char(12) init("slt", "name_table", "definitions_", "dseg"), 104 NL char(1) init(" 105 "), 106 NO_CHASE init(0) fixed bin(1), 107 myname char(10) init("copy_pdir_") 108 ) int static options(constant); 109 110 dcl 1 DIR_ACL_INIT (5) aligned int static options(constant), 111 2 access_name char (32) unal 112 init("*.*.*", "*.SysMaint.*", "*.SysAdmin.*", "*.SysDaemon.*", ""), 113 2 mode bit (36) aligned /* null for *.*.*, sma access for the rest */ 114 init( (1) ((36) "0"b), (3) ("111"b || (33)"0"b), (1) ("100"b || (33)"0"b)), 115 2 status_code fixed bin (35) init((5) 0); 116 117 dcl 1 SEG_ACL_INIT (5) aligned int static options(constant), 118 2 access_name char (32) unal 119 init("*.*.*", "*.SysMaint.*", "*.SysAdmin.*", "*.SysDaemon.*", ""), 120 2 mode bit (36) aligned /* null for *.*.*, r access for the rest */ 121 init( (1) ((36) "0"b), (3) ("100"b || (33)"0"b), (1) ("100"b || (33)"0"b)), 122 2 extended_mode bit (36) aligned 123 init((5) (36)"0"b), /* we dont use this */ 124 2 status_code fixed bin (35) init((5) 0); 125 126 /* Builtins */ 127 128 dcl (addr, addrel, baseno, baseptr, binary, fixed, hbound, lbound, length, 129 ltrim, null, rtrim, size, substr, string 130 ) builtin; 131 132 /* Condition handlers */ 133 134 dcl (cleanup) condition; 135 136 /* Based variables */ 137 138 dcl system_area area based (system_area_ptr); 139 140 /* Automatic */ 141 142 dcl code fixed bin (35); 143 dcl dead_pdir_ring fixed bin(3); 144 dcl deadproc bit(1); 145 dcl dir_acl_ptr ptr; 146 dcl dir_path char(168); 147 dcl i fixed bin; 148 dcl ignore fixed bin (24); 149 dcl iocb_ptr ptr; 150 dcl live_process char(32); 151 dcl owner_acl char(32); 152 dcl owner_sw bit(1); 153 dcl pdir_path char(168); 154 dcl pdir_to_create char(32); 155 dcl process_dir char(168); 156 dcl seg_acl_ptr ptr; 157 dcl system_area_ptr ptr; 158 dcl type fixed bin (2); /* branch type from status_minf */ 159 dcl user_acl char(32); 160 161 162 copy_pdir_$deadproc: entry (caller, copy_dirname, copy_entryname, a_pdir_path, a_pdir_name, a_owner_acl, 163 a_need_hphcs, a_code); 164 165 /* This entry copies a dead processes. Arguments are: 166* 167* caller Name of who called me. (Input) 168* copy_dirname Pathname of the containing directory of the source pdir. (Input) 169* copy_entryname Name of the process directory to be copied. (Input) 170* a_pdir_path Pathname of the containing directory where the process will be copied. (Input) 171* a_pdir_name Name of the target pdir to be created. (Input) 172* a_owner_acl Person.Project to be added as an acl to the target pdir. (Input) 173* a_need_hphcs This means that the copying is being done on behalf of the owner of the pdir. (Input) 174* a_code Standard system error code. (Output) 175**/ 176 177 /* parameters */ 178 179 dcl a_code fixed bin(35); 180 dcl a_live_process char(*); 181 dcl a_owner_acl char(*); 182 dcl a_need_hphcs bit(1); 183 dcl a_pdir_path char(*); 184 dcl a_pdir_name char(*); 185 dcl caller char(*); 186 dcl copy_dirname char(168); 187 dcl copy_entryname char(32); 188 189 deadproc = "1"b; 190 live_process = ""; 191 go to COMMON; 192 193 194 copy_pdir_$liveproc: entry (caller, copy_dirname, copy_entryname, a_pdir_path, a_pdir_name, a_owner_acl, 195 a_need_hphcs, a_live_process, a_code); 196 197 deadproc = "0"b; 198 live_process = a_live_process; 199 go to COMMON; 200 201 COMMON: 202 dir_path = a_pdir_path; 203 star_entry_count = 0; /* necessary to reference to avoid a warning */ 204 pdir_to_create = a_pdir_name; 205 if a_owner_acl = "" then owner_sw = "0"b; 206 else do; 207 owner_acl = cv_userid_ (a_owner_acl); 208 owner_sw = "1"b; 209 end; 210 if a_need_hphcs then user_acl = get_group_id_$tag_star(); 211 else user_acl = ""; 212 213 code = 0; 214 iocb_ptr = null(); 215 system_area_ptr = get_system_free_area_(); 216 acl_count = 5; 217 dir_acl_ptr, seg_acl_ptr = null (); 218 process_dir = ""; 219 220 on cleanup begin; 221 call clean_up(); 222 end; 223 224 allocate directory_acl_array in (system_area) set (dir_acl_ptr); 225 allocate segment_acl_array in (system_area) set (seg_acl_ptr); 226 227 call setup_pdir_uids (pathname_(copy_dirname, copy_entryname), process_dir, iocb_ptr, code); 228 if code ^= 0 then goto END_COPY_PDIR; 229 230 call get_pdir_rbs(pdir_path, dead_pdir_ring); 231 232 call copy_pdir (copy_dirname, copy_entryname, dir_path, pdir_to_create, owner_sw, owner_acl, user_acl, 233 iocb_ptr, dead_pdir_ring, code); 234 if code ^= 0 then goto END_COPY_PDIR; 235 236 call cleanup_pdir_uids (iocb_ptr); 237 238 pdir_path = pathname_(dir_path, pdir_to_create); 239 call move_pdir_uid_seg(pdir_path, process_dir, code); 240 if code ^= 0 then goto END_COPY_PDIR; 241 242 do i = lbound(HC_SEGS,1) to hbound(HC_SEGS,1)-1, 243 hbound(HC_SEGS,1) while (live_process = "Initializer"); 244 call copy_segment ("", HC_SEGS(i), pdir_path, ""b, code); 245 if code ^= 0 then goto END_COPY_PDIR; 246 end; 247 248 call determine_stack_base (pdir_path, code); 249 if code ^= 0 then goto END_COPY_PDIR; 250 251 call amu_$dp_create_uid_hash (pdir_path, code); 252 if code ^= 0 then goto END_COPY_PDIR; 253 if owner_sw then do; 254 call set_hash_access(pdir_path, owner_acl, code); 255 if code ^= 0 then goto END_COPY_PDIR; 256 call set_owner_status (pdir_path, owner_acl, code); 257 if code ^= 0 then goto END_COPY_PDIR; 258 end; 259 260 END_COPY_PDIR: 261 a_code = code; 262 call clean_up(); 263 264 return; 265 266 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 267 268 copy_pdir_$delete: entry (caller, a_pdir_path, a_pdir_name, a_code); 269 270 /* 271* This entry deletes a dead process. Currently, it expects to be called by 272* copy_deadproc after being called by copy_pdir_$deadproc, so access and ring 273* brackets are assumed to be set up already. 274**/ 275 276 code = 0; 277 string (delete_options) = ""b; 278 delete_options.force, delete_options.directory = "1"b; 279 call delete_$path (a_pdir_path, a_pdir_name, string (delete_options), caller, code); 280 if code = error_table_$action_not_performed then /* maybe only partially deleted */ 281 call delete_$path (a_pdir_path, a_pdir_name, string (delete_options), caller, code); 282 283 if code = error_table_$infcnt_non_zero then /* The directory is successfully deleted. */ 284 code = 0; /* So, ignore the code */ 285 286 a_code = code; 287 return; 288 289 290 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 291 292 add_inacls: proc (dirname, ename, owner_sw, owner_acl, code); 293 294 dcl (dirname, ename) char(*); 295 dcl code fixed bin(35); 296 dcl owner_sw bit(1); 297 dcl owner_acl char(*); 298 299 /* set initial acls for segments */ 300 301 acl_count = 5; 302 seg_acl_ptr -> segment_acl_array(*) = SEG_ACL_INIT(*); 303 if owner_sw then seg_acl_ptr -> segment_acl_array(5).access_name = owner_acl; 304 else acl_count = 4; 305 306 call hcs_$add_inacl_entries (dirname, ename, seg_acl_ptr, acl_count, 4, code); 307 if code ^= 0 then return; 308 309 /* add initial acls for directories */ 310 311 acl_count = 5; 312 dir_acl_ptr -> directory_acl_array(*) = DIR_ACL_INIT(*); 313 if owner_sw then dir_acl_ptr -> directory_acl_array (5).access_name = owner_acl; 314 else acl_count = 4; 315 316 call hcs_$add_dir_inacl_entries (dirname, ename, dir_acl_ptr, acl_count, 4, code); 317 if code ^= 0 then return; 318 319 end add_inacls; 320 321 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 322 323 clean_up: proc(); 324 325 dcl ignore_code fixed bin (35); 326 327 if dir_acl_ptr ^= null() then free dir_acl_ptr -> directory_acl_array in (system_area); 328 if seg_acl_ptr ^= null() then free seg_acl_ptr -> segment_acl_array in (system_area); 329 330 if iocb_ptr ^= null() then do; 331 call iox_$close (iocb_ptr, ignore_code); 332 call iox_$detach_iocb (iocb_ptr, ignore_code); 333 end; 334 if process_dir ^= "" then do; 335 string (delete_options) = ""b; 336 delete_options.force, delete_options.segment = "1"b; 337 call delete_$path (process_dir, "pdir_info", string (delete_options), caller, ignore_code); 338 end; 339 340 if code ^= 0 then do; /* delete the partially copied pdir */ 341 string (delete_options) = ""b; 342 delete_options.force, delete_options.segment, delete_options.directory = "1"b; 343 call delete_$path (dir_path, pdir_to_create, string (delete_options), caller, ignore_code); 344 end; 345 346 end clean_up; 347 348 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 349 350 cleanup_pdir_uids: proc(iocb_ptr); 351 352 /* parameters */ 353 354 dcl (iocb_ptr) ptr; 355 dcl ignore_code fixed bin (35); 356 357 if iocb_ptr ^= null() then do; 358 call iox_$close (iocb_ptr, ignore_code); 359 call iox_$detach_iocb (iocb_ptr, ignore_code); 360 end; 361 362 end cleanup_pdir_uids; 363 364 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 365 366 copy_pdir: proc (dirname, ename, target_dirname, target_ename, owner_sw, owner_acl, user_acl, 367 iocbp, pdir_ring, code) recursive; 368 369 /* Parameters */ 370 371 dcl dirname char(*); 372 dcl ename char(*); 373 dcl code fixed bin(35); 374 dcl iocbp ptr; 375 dcl owner_acl char(*); 376 dcl owner_sw bit(1); 377 dcl pdir_ring fixed bin(3); 378 dcl target_dirname char(*); 379 dcl target_ename char(*); 380 dcl user_acl char(*); 381 382 /* automatic */ 383 384 dcl 1 cbi like create_branch_info; 385 dcl dir_path char(168); 386 dcl i fixed bin; 387 dcl line_ptr ptr; 388 dcl n_write fixed bin(21); 389 dcl need_to_set_rbs bit(1); 390 dcl pdir_line char(45); 391 dcl 1 s_entries (s_entry_count) aligned based (s_entry_ptr) like star_entries; 392 dcl s_entry_count; 393 dcl s_entry_ptr ptr; 394 dcl s_names_ptr ptr; 395 dcl s_names (500) char(32) aligned based ( 396 s_names_ptr); 397 dcl t_parent char(168); 398 dcl t_ename char(32); 399 dcl target_dir_path char(168); 400 dcl type fixed bin (2); /* branch type from status_minf */ 401 dcl unique_id bit(36) aligned; 402 403 need_to_set_rbs = (pdir_ring ^= get_ring_()); 404 line_ptr = addr (pdir_line); 405 n_write = length(pdir_line); 406 dir_path = pathname_(dirname, ename); 407 target_dir_path = pathname_(target_dirname, target_ename); 408 s_entry_ptr, s_names_ptr = null (); 409 code = 0; 410 on condition (cleanup) begin; 411 if s_names_ptr ^= null () then free s_names in (system_area); 412 if s_entry_ptr ^= null () then free s_entries in (system_area); 413 end; 414 415 /* create directory */ 416 417 call expand_pathname_ (target_dirname, t_parent, t_ename, code); 418 if code ^= 0 then return; 419 cbi.version = create_branch_version_2; 420 cbi.dir_sw, 421 cbi.copy_sw, 422 cbi.parent_ac_sw = "1"b; 423 cbi.chase_sw, 424 cbi.priv_upgrade_sw, 425 cbi.mbz1, cbi.mbz2 = "0"b; 426 cbi.bitcnt, cbi.quota = 0; 427 cbi.mode = SMA_ACCESS; 428 cbi.rings(*) = 4; 429 cbi.userid = get_group_id_$tag_star(); 430 cbi.access_class = ""b; 431 cbi.dir_quota = 0; 432 433 call hcs_$create_branch_ (target_dirname, target_ename, addr(cbi), code); 434 if code ^= 0 then return; 435 call add_inacls (target_dirname, target_ename, owner_sw, owner_acl, code); 436 if code ^= 0 then return; 437 438 call hcs_$star_ (dir_path, "**", star_ALL_ENTRIES, system_area_ptr, s_entry_count, s_entry_ptr, s_names_ptr, code); 439 if code ^= 0 then do; /* copy thru links in pdir. */ 440 /* an attempt to be more descriptive */ 441 if code = error_table_$nomatch then code = error_table_$empty_file; 442 goto ERROR_COPY; 443 end; 444 /* Any errors found are handled in the clean_up routine */ 445 do i = 1 to s_entry_count; 446 t_ename = s_names(s_entries(i).nindex); 447 if s_entries(i).type = star_LINK then do; /* Find type of link target. */ 448 call hcs_$status_minf (dir_path, t_ename, CHASE, type, ignore, code); 449 if code = 0 then s_entries(i).type = type; 450 end; 451 if s_entries(i).type = star_SEGMENT then do; 452 if live_process = "Initializer" & t_ename = "template_pit" then 453 t_ename = s_names(s_entries(i).nindex-1+s_entries(i).nnames); 454 /* Initializer has both template_pit and pit names */ 455 /* on its pit, but azm looks only for pit. */ 456 if user_acl ^= "" then call set_rb_and_access(dir_path, t_ename, "0"b, user_acl, code); 457 if code ^= 0 then goto ERROR_COPY; 458 call copy_segment (dir_path, t_ename, target_dir_path, 459 unique_id, code); 460 if code ^= 0 then goto ERROR_COPY; 461 if need_to_set_rbs then call set_owner_rbs (target_dir_path, t_ename, "0"b, pdir_ring, code); 462 if code ^= 0 then goto ERROR_COPY; 463 call save_pdir_uid (iocbp, unique_id, t_ename, pdir_line, line_ptr, n_write, code); 464 if code ^= 0 then goto ERROR_COPY; 465 end; 466 else if s_entries(i).type = star_DIRECTORY then do; 467 if user_acl ^= "" then call set_rb_and_access(dir_path, t_ename, "1"b, user_acl, code); 468 if code ^= 0 then goto ERROR_COPY; 469 if need_to_set_rbs then call set_owner_rbs (target_dir_path, t_ename, "1"b, pdir_ring, code); 470 if code ^= 0 then goto ERROR_COPY; 471 call copy_pdir(dir_path, t_ename, target_dir_path, t_ename, owner_sw, owner_acl, user_acl, 472 iocbp, pdir_ring, code); 473 if code ^= 0 then goto ERROR_COPY; 474 end; 475 end; 476 477 ERROR_COPY: 478 479 if s_names_ptr ^= null () then free s_names in (system_area); 480 if s_entry_ptr ^= null () then free s_entries in (system_area); 481 return; 482 483 end copy_pdir; 484 485 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 486 487 copy_segment: proc (dirname, seg_to_copy, target_dirname, unique_id, code); 488 489 /* parameters */ 490 491 dcl code fixed bin(35); 492 dcl dirname char(*); 493 dcl seg_to_copy char(*); 494 dcl target_dirname char(*); 495 dcl unique_id bit(36) aligned; 496 497 dcl bit_count fixed bin(24); 498 dcl bound fixed bin(19); 499 dcl bc_35 fixed bin(35); 500 dcl ename char(32); 501 dcl got_copy bit(1); 502 dcl segptr ptr; 503 dcl segptr0 ptr; 504 dcl test_word fixed bin (35); 505 dcl tsdw fixed bin (71); 506 507 segptr, segptr0 = null(); 508 got_copy = "0"b; 509 code = 0; 510 ename = seg_to_copy; 511 512 if dirname = "" then /* get from the system */ 513 call ring0_get_$segptr ("", ename, segptr0, code); 514 else call phcs_$initiate (dirname, ename, "", 0, 0, segptr0, code); 515 if segptr0 = null then return; 516 517 /* Get unique ID for later use. */ 518 519 if dirname = "" then 520 unique_id = ""b; 521 else 522 call hcs_$get_uid_seg (segptr0, unique_id, code); 523 524 /* Test whether copying is possible, and also cause segment fault to get sdw.bound right */ 525 526 call ring_zero_peek_ (segptr0, addr (test_word), size (test_word), code); 527 if code ^= 0 then goto RZP_ERROR; 528 529 call ring_zero_peek_ (addr (baseptr (0) -> sdwa (binary (baseno (segptr0), 15))), addr (tsdw), size (tsdw), code); 530 if code ^= 0 then goto RZP_ERROR; 531 532 bound = (binary (addr (tsdw) -> sdw.bound, 14) + 1) * 16; /* get number of words */ 533 bit_count = bound * 36; /* bit of segment */ 534 535 call ring_zero_peek_ (addrel (segptr0, bound - 1), addr (test_word), size (test_word), code); 536 if code ^= 0 then /* test whether whole segment is copyable -- in case we're */ 537 goto RZP_ERROR; /* stuck with using metering_ring_zero_peek_ */ 538 539 on cleanup call rzd_cleanup(); 540 541 CREATE: 542 /* get segment to copy data into */ 543 if live_process = "Initializer" & ename = "kst_seg" then/* Initializer has nonstandard name for its kst */ 544 ename, seg_to_copy = "kst"; 545 call hcs_$make_seg (target_dirname, ename, "", RW_ACCESS_BIN, segptr, code); 546 if code ^= 0 then 547 if code = error_table_$namedup then do; 548 call nd_handler_ (myname, dirname, ename, code); 549 if code = error_table_$action_not_performed then return; 550 goto CREATE; 551 end; 552 else if code ^= error_table_$segknown then return; 553 554 call ring_zero_peek_ (segptr0, segptr, bound, code); /* copy segment into user ring */ 555 if code ^= 0 then goto RZP_ERROR; 556 557 got_copy = "1"b; 558 /* set bit count and terminate the segment */ 559 call adjust_bit_count_((target_dirname), ename, "1"b, bc_35, code); 560 bit_count = bc_35; 561 call terminate_file_(segptr, bit_count, TERM_FILE_TRUNC_BC_TERM, (0)); 562 563 return; 564 565 RZP_ERROR: 566 567 call com_err_ (code, myname, "This operation requires access to phcs_."); 568 569 call rzd_cleanup (); 570 return; 571 572 rzd_cleanup: proc (); 573 574 if segptr ^= null & ^got_copy then do; 575 string (delete_options) = ""b; 576 delete_options.force, delete_options.segment = "1"b; 577 call delete_$path (dirname, ename, string(delete_options), myname, (0)); 578 end; 579 end rzd_cleanup; 580 581 end copy_segment; 582 583 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 584 585 determine_stack_base: proc(dirname, code); 586 587 /* This procedure determines the stack_0 segment number for this boot of the system. Then it */ 588 /* creates a segment with max length of 0 called stack0_is_NNN where NNN is the segment number. */ 589 /* This way, analyze_multics, who uses stack0 can find the correct segno for processes analyzed */ 590 /* across system boots (where the segno may change). */ 591 592 dcl dirname char(*); 593 dcl code fixed bin(35); 594 595 dcl stackbase_segno fixed bin(35); 596 dcl tbase char(12) aligned; 597 dcl stack_base char(32); 598 dcl segptr ptr; 599 600 code = 0; 601 segptr = null(); 602 stack_base, tbase = ""; 603 stackbase_segno = -1; 604 call ring_zero_peek_$by_definition ("active_all_rings_data", "stack_base_segno", 0, addr(stackbase_segno), 1, code); 605 if code ^= 0 then return; 606 607 call cv_bin_$dec (fixed(stackbase_segno, 17), tbase); 608 stack_base = "stack_base_" || ltrim(tbase); 609 610 CREATE: /* create a zero length seg with the stack base number */ 611 call hcs_$make_seg (dirname, stack_base, "", R_ACCESS_BIN, segptr, code); 612 if code ^= 0 then 613 if code = error_table_$namedup then do; 614 call nd_handler_ (myname, dirname, stack_base, code); 615 if code = error_table_$action_not_performed then return; 616 goto CREATE; 617 end; 618 else if code ^= error_table_$segknown then return; 619 620 call hcs_$set_max_length_seg (segptr, 0, code); 621 622 end determine_stack_base; 623 624 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 625 626 get_pdir_rbs: proc (dirname, pdir_ring); 627 628 /* parameters */ 629 630 dcl dirname char(*); 631 dcl pdir_ring fixed bin(3); 632 633 dcl code fixed bin(35); 634 dcl i fixed bin; 635 dcl (DEFAULT_RING fixed bin(3) init (4), 636 stacks (0:7) char(7) init("stack_0", "stack_1", "stack_2", "stack_3", "stack_4", 637 "stack_5", "stack_6", "stack_7")) 638 int static options (constant); 639 640 /* The only time ring brackets have to be set to other than what they are (which is ring 4), is 641* when the user is running in ring 5,6,7. So, we look for the existence of stack_7, stack_6, 642* stack_5 and set ring brackets accordingly. 643**/ 644 pdir_ring = DEFAULT_RING; 645 code = -1; 646 do i = hbound (stacks,1) to 0 by -1 while (code ^= 0); 647 call hcs_$status_minf (dirname, stacks(i), NO_CHASE, type, ignore, code); 648 if code = 0 then pdir_ring = i; 649 end; /* of loop */ 650 651 end get_pdir_rbs; 652 653 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 654 655 move_pdir_uid_seg: proc (dirname, process_dir, code); 656 657 dcl dirname char (*); 658 dcl code fixed bin(35); 659 dcl process_dir char(168); 660 661 dcl bc_35 fixed bin(35); 662 dcl seg_bc fixed bin(24); 663 664 code = 0; 665 call adjust_bit_count_(process_dir, "pdir_info", "1"b, bc_35, code); 666 seg_bc = bc_35; 667 call hcs_$fs_move_file (process_dir, "pdir_info", fixed("11"b), dirname, "pdir_info", code); 668 if code ^= 0 then return; 669 call hcs_$set_bc (dirname, "pdir_info", seg_bc, code); 670 if code ^= 0 then return; 671 string (delete_options) = ""b; 672 delete_options.force, delete_options.segment = "1"b; 673 call delete_$path (process_dir, "pdir_info", string (delete_options), caller, code); 674 process_dir = ""; 675 676 end move_pdir_uid_seg; 677 678 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 679 680 save_pdir_uid: proc (iocbp, unique_id, seg_name, putline, putline_ptr, n_write, code); 681 682 dcl iocbp ptr; 683 dcl code fixed bin(35); 684 dcl unique_id bit(36) aligned; 685 dcl putline_ptr ptr; 686 dcl putline char(*); 687 dcl n_write fixed bin(21); 688 dcl seg_name char(*); 689 690 dcl tuid char(12) aligned; 691 692 code = 0; 693 694 if unique_id = "0"b then return; 695 696 call cv_bin_$oct(fixed(unique_id, 35), tuid); 697 substr(putline, 1, n_write) = tuid || seg_name || NL; 698 call iox_$put_chars(iocbp, putline_ptr, n_write, code); 699 700 return; 701 end save_pdir_uid; 702 703 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 704 705 set_hash_access: proc (dir_path, owner_acl, code); 706 707 /* parameters */ 708 709 dcl code fixed bin(35); 710 dcl dir_path char(*); 711 dcl owner_acl char(*); 712 713 /* automatic */ 714 715 code = 0; 716 acl_count = 1; 717 seg_acl_ptr -> segment_acl_array(1).access_name = owner_acl; 718 seg_acl_ptr -> segment_acl_array(1).mode = R_ACCESS || (33)"0"b; 719 seg_acl_ptr -> segment_acl_array(1).extended_mode = (36)"0"b; 720 call hcs_$add_acl_entries (dir_path, "uid_hash_table", seg_acl_ptr, acl_count, code); 721 722 end set_hash_access; 723 724 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 725 726 set_owner_status: proc (dir_path, owner_acl, code); 727 728 /* parameters */ 729 730 dcl code fixed bin(35); 731 dcl dir_path char(*); 732 dcl owner_acl char(*); 733 734 /* automatic */ 735 736 dcl dirname char(168); 737 dcl entryname char(32); 738 739 /* owner needs s to the containing dir of the just created pdir dir. */ 740 741 call expand_pathname_ (dir_path, dirname, entryname, code); 742 if code ^= 0 then return; 743 744 call hcs_$status_minf (dirname, entryname, NO_CHASE, type, ignore, code); 745 if code ^= 0 then return; 746 747 acl_count = 1; 748 dir_acl_ptr -> directory_acl_array(1).access_name = owner_acl; 749 dir_acl_ptr -> directory_acl_array(1).mode = S_ACCESS || (33)"0"b; 750 call hcs_$add_dir_acl_entries (dirname, entryname, dir_acl_ptr, acl_count, code); 751 752 end set_owner_status; 753 754 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 755 756 set_owner_rbs: proc (dirname, ename, dir_sw, user_ring, code) recursive; 757 758 /* parameters */ 759 760 dcl code fixed bin(35); 761 dcl dirname char(*); 762 dcl dir_sw bit(1); 763 dcl ename char(*); 764 dcl user_ring fixed bin(3); 765 766 dcl rbs (3) fixed bin(3); 767 dcl drb (2) fixed bin(3); 768 769 code = 0; 770 if dir_sw then do; 771 drb(1), drb(2) = user_ring; 772 call hcs_$set_dir_ring_brackets(dirname, ename, drb, code); 773 end; 774 775 else do; /* segment */ 776 rbs(1), rbs(2), rbs(3) = user_ring; 777 call hcs_$set_ring_brackets(dirname, ename, rbs, code); 778 end; 779 780 end set_owner_rbs; 781 782 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 783 784 set_rb_and_access: proc(dirname, ename, dir_sw, user_acl, code); 785 786 dcl (dirname, ename) char(*); 787 dcl code fixed bin(35); 788 dcl dir_sw bit(1); 789 dcl user_acl char(*); 790 791 code = 0; 792 acl_ptr = null(); 793 794 if dir_sw then do; 795 /* set dir ring bracket if copying on behalf of owner */ 796 797 call hphcs_$set_dir_ring_brackets(dirname, ename, 7, code); 798 if code ^= 0 then return; 799 800 /* set directory acl */ 801 802 acl_count = 1; 803 dir_acl_ptr -> directory_acl_array(1).access_name = user_acl; 804 dir_acl_ptr -> directory_acl_array(1).mode = SMA_ACCESS || (33)"0"b; 805 dir_acl_ptr -> directory_acl_array(1).status_code = 0; 806 call hcs_$add_dir_acl_entries (dirname, ename, dir_acl_ptr, acl_count, code); 807 if code ^= 0 then return; 808 end; 809 810 else if deadproc then do; /* a deadproc segment */ 811 812 /* set ring brackets to 4 */ 813 814 call hphcs_$set_ring_brackets(dirname, ename, 4, code); 815 if code ^= 0 then return; 816 817 /* set access */ 818 819 acl_count = 1; 820 seg_acl_ptr -> segment_acl_array(1).access_name = user_acl; 821 seg_acl_ptr -> segment_acl_array(1).mode = R_ACCESS || (33)"0"b; 822 seg_acl_ptr -> segment_acl_array(1).extended_mode = (36)"0"b; 823 seg_acl_ptr -> segment_acl_array(1).status_code = 0; 824 call hcs_$add_acl_entries (dirname, ename, seg_acl_ptr, acl_count, code); 825 if code ^= 0 then return; 826 end; 827 828 else do; /* a liveproc segment */ 829 830 /* set access */ 831 832 acl_count = 1; 833 seg_acl_ptr -> segment_acl_array(1).access_name = user_acl; 834 seg_acl_ptr -> segment_acl_array(1).mode = R_ACCESS || (33)"0"b; 835 seg_acl_ptr -> segment_acl_array(1).extended_mode = (36)"0"b; 836 seg_acl_ptr -> segment_acl_array(1).status_code = 0; 837 call hphcs_$add_acl_entries (dirname, ename, seg_acl_ptr, acl_count, code); 838 if code ^= 0 then return; 839 end; 840 841 end set_rb_and_access; 842 843 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 844 845 setup_pdir_uids: proc (dp_dirname, process_dir, iocbp, code); 846 847 /* parameter */ 848 849 dcl iocbp ptr; 850 dcl code fixed bin(35); 851 dcl process_dir char(168); 852 dcl dp_dirname char(168); 853 854 /* automatic */ 855 856 dcl attach_desc char(200); 857 dcl line_ptr ptr; 858 dcl n_write fixed bin(21); 859 dcl pdir_line char(45); 860 dcl segptr ptr; 861 dcl sys_release char(44); 862 863 segptr, iocbp = null(); 864 code = 0; 865 process_dir = get_pdir_(); 866 on cleanup begin; 867 if segptr ^= null() then call delete_$ptr (segptr, "101100"b, myname, (0)); 868 end; 869 call hcs_$make_seg (process_dir, "pdir_info", "", RW_ACCESS_BIN, segptr, code); 870 if segptr = null() then return; 871 attach_desc = "vfile_ " || rtrim (process_dir) || ">pdir_info"; 872 call iox_$attach_name ("pdir_sw", iocbp, attach_desc, null (), code); 873 if code ^= 0 then return; 874 call iox_$open (iocbp, 2, "0"b, code); 875 if code ^= 0 then return; 876 877 /* Save the system release ID first */ 878 call system_info_$sysid(sys_release); 879 pdir_line = sys_release || NL; 880 line_ptr = addr (pdir_line); 881 n_write = length(pdir_line); 882 call iox_$put_chars(iocbp, line_ptr, n_write, code); 883 884 885 end setup_pdir_uids; 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 */ 886 2 1 /* Begin include file -- acl_structures.incl.pl1 BIM 3/82 */ 2 2 /* format: style3,indcomtxt,idind30 */ 2 3 2 4 declare acl_ptr pointer; 2 5 declare acl_count fixed bin; 2 6 2 7 declare 1 general_acl aligned based (acl_ptr), /* for fs_util_ */ 2 8 2 version char (8) aligned, 2 9 2 count fixed bin, 2 10 2 entries (acl_count refer (general_acl.count)) aligned like general_acl_entry; 2 11 2 12 declare 1 general_acl_entry based, 2 13 2 access_name character (32) unaligned, 2 14 2 mode bit (36) aligned, 2 15 2 status_code fixed bin (35); 2 16 2 17 2 18 declare 1 general_extended_acl aligned based (acl_ptr), /* for fs_util_ */ 2 19 2 version char (8) aligned, 2 20 2 count fixed bin, 2 21 2 entries (acl_count refer (general_extended_acl.count)) aligned like general_extended_acl_entry; 2 22 2 23 declare 1 general_extended_acl_entry aligned based, 2 24 2 access_name character (32) unaligned, 2 25 2 mode bit (36) aligned, 2 26 2 extended_mode bit (36) aligned, 2 27 2 status_code fixed bin (35); 2 28 2 29 2 30 declare 1 general_delete_acl aligned based (acl_ptr), /* for file_system_ */ 2 31 2 version char (8) aligned, 2 32 2 count fixed bin, 2 33 2 entries (acl_count refer (general_delete_acl.count)) aligned like delete_acl_entry; 2 34 2 35 declare 1 general_delete_acl_entry aligned based, 2 36 2 access_name character (32) unaligned, 2 37 2 status_code fixed bin (35); 2 38 2 39 2 40 declare 1 segment_acl aligned based (acl_ptr), 2 41 2 version fixed bin, 2 42 2 count fixed bin, 2 43 2 entries (acl_count refer (segment_acl.count)) aligned like segment_acl_entry; 2 44 2 45 declare 1 segment_acl_entry like general_extended_acl_entry aligned based; 2 46 declare 1 segment_acl_array (acl_count) aligned like segment_acl_entry based (acl_ptr); 2 47 2 48 2 49 declare 1 directory_acl aligned based (acl_ptr), 2 50 2 version fixed bin, 2 51 2 count fixed bin, 2 52 2 entries (acl_count refer (directory_acl.count)) aligned like directory_acl_entry; 2 53 2 54 declare 1 directory_acl_entry like general_acl_entry aligned based; 2 55 declare 1 directory_acl_array (acl_count) aligned like directory_acl_entry based (acl_ptr); 2 56 2 57 2 58 declare 1 delete_acl based (acl_ptr) aligned, 2 59 2 version fixed bin, 2 60 2 count fixed bin, 2 61 2 entries (acl_count refer (delete_acl.count)) aligned like delete_acl_entry; 2 62 2 63 declare 1 delete_acl_entry like general_delete_acl_entry aligned based; 2 64 declare 1 delete_acl_array (acl_count) aligned like delete_acl_entry based (acl_ptr); 2 65 2 66 2 67 declare (SEG_ACL_VERSION_1 init ("sga1"), 2 68 DIR_ACL_VERSION_1 init ("dra1"), 2 69 DELETE_ACL_VERSION_1 init ("dla1")) 2 70 char (4) int static options (constant); 2 71 2 72 declare (GENERAL_ACL_VERSION_1 init ("gacl001"), 2 73 GENERAL_EXTENDED_ACL_VERSION_1 init ("gxacl001"), 2 74 GENERAL_DELETE_ACL_VERSION_1 init ("gdacl001")) 2 75 char (8) internal static options (constant); 2 76 2 77 declare ACL_VERSION_1 fixed bin init (1) int static options (constant); 2 78 2 79 /* End include file acl_structures.incl.pl1 */ 887 3 1 /* BEGIN INCLUDE FILE - - - create_branch_info.incl.pl1 - - - created January 1975 */ 3 2 3 3 3 4 /****^ HISTORY COMMENTS: 3 5* 1) change(89-01-16,TLNguyen), approve(89-01-16,MCR8049), 3 6* audit(89-02-03,Parisek), install(89-03-15,MR12.3-1025): 3 7* 1. Declare version constant properly. 3 8* 2. Remove version 1 since it was never referenced and to force 3 9* callers to upgrade their programs. 3 10* END HISTORY COMMENTS */ 3 11 3 12 3 13 /* Modified December 1984 for dir_quota, Keith Loepere. */ 3 14 3 15 /* this include files gives the argument structure for create_branch_ */ 3 16 3 17 dcl 1 create_branch_info aligned based, 3 18 2 version fixed bin, /* set this to the largest value given below */ 3 19 2 switches unaligned, 3 20 3 dir_sw bit (1) unaligned, /* if on, a directory branch is wanted */ 3 21 3 copy_sw bit (1) unaligned, /* if on, initiating segment will be done by copying */ 3 22 3 chase_sw bit (1) unaligned, /* if on, if pathname is a link, it will be chased */ 3 23 3 priv_upgrade_sw bit (1) unaligned, /* privileged creation (ring 1) of upgraded object */ 3 24 3 parent_ac_sw bit (1) unaligned, /* if on, use parent's access class for seg or dir created */ 3 25 3 mbz1 bit (31) unaligned, /* pad to full word */ 3 26 2 mode bit (3) unaligned, /* segment or directory for acl for userid */ 3 27 2 mbz2 bit (33) unaligned, /* pad to full word */ 3 28 2 rings (3) fixed bin (3), /* branch's ring brackets */ 3 29 2 userid char (32), /* user's access control name */ 3 30 2 bitcnt fixed bin (24), /* bit count of the segment */ 3 31 2 quota fixed bin (18), /* for directories, this am't of quota will be moved to it */ 3 32 2 access_class bit (72), /* is the access class of the body of the branch */ 3 33 2 dir_quota fixed bin (18); /* for directories, this am't of dir quota will be moved to it */ 3 34 3 35 dcl create_branch_version_2 fixed bin int static options (constant) init (2); 3 36 3 37 /* END INCLUDE FILE - - - create_branch_info.incl.pl1 - - - */ 3 38 888 4 1 /* BEGIN INCLUDE FILE: delete_options.incl.pl1 */ 4 2 4 3 /* control flag bit string passed to delete_$path and delete_$ptr 4 4* 4 5* Jay Pattin 6/6/83 */ 4 6 4 7 declare 1 delete_options, 4 8 2 force bit (1) unaligned, /* ON = delete w/o asking is safety switch on */ 4 9 2 question bit (1) unaligned, /* ON = ask user if safety switch on */ 4 10 2 directory bit (1) unaligned, /* ON = delete directories */ 4 11 2 segment bit (1) unaligned, /* ON = delete segments */ 4 12 2 link bit (1) unaligned, /* ON = delete links */ 4 13 2 chase bit (1) unaligned, /* ON = delete through links */ 4 14 2 library bit (1) unaligned, /* ON = use installation_tools_ */ 4 15 2 raw bit (1) unaligned, /* ON = use hcs_, not object_type_ */ 4 16 2 mbz bit (28) unaligned; 4 17 4 18 /* END INCLUDE FILE: delete_options.incl.pl1 */ 889 5 1 /* --------------- BEGIN include file iox_dcls.incl.pl1 --------------- */ 5 2 5 3 /* Written 05/04/78 by C. D. Tavares */ 5 4 /* Fixed declaration of iox_$find_iocb_n 05/07/80 by R. Holmstedt */ 5 5 /* Modified 5/83 by S. Krupp to add declarations for: iox_$open_file, 5 6* iox_$close_file, iox_$detach and iox_$attach_loud entries. */ 5 7 5 8 dcl iox_$attach_name entry (char (*), pointer, char (*), pointer, fixed bin (35)), 5 9 iox_$attach_ptr entry (pointer, char (*), pointer, fixed bin (35)), 5 10 iox_$close entry (pointer, fixed bin (35)), 5 11 iox_$control entry (pointer, char (*), pointer, fixed bin (35)), 5 12 iox_$delete_record entry (pointer, fixed bin (35)), 5 13 iox_$destroy_iocb entry (pointer, fixed bin (35)), 5 14 iox_$detach_iocb entry (pointer, fixed bin (35)), 5 15 iox_$err_not_attached entry options (variable), 5 16 iox_$err_not_closed entry options (variable), 5 17 iox_$err_no_operation entry options (variable), 5 18 iox_$err_not_open entry options (variable), 5 19 iox_$find_iocb entry (char (*), pointer, fixed bin (35)), 5 20 iox_$find_iocb_n entry (fixed bin, ptr, fixed bin(35)), 5 21 iox_$get_chars entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 5 22 iox_$get_line entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 5 23 iox_$look_iocb entry (char (*), pointer, fixed bin (35)), 5 24 iox_$modes entry (pointer, char (*), char (*), fixed bin (35)), 5 25 iox_$move_attach entry (pointer, pointer, fixed bin (35)), 5 26 iox_$open entry (pointer, fixed bin, bit (1) aligned, fixed bin (35)), 5 27 iox_$position entry (pointer, fixed bin, fixed bin (21), fixed bin (35)), 5 28 iox_$propagate entry (pointer), 5 29 iox_$put_chars entry (pointer, pointer, fixed bin (21), fixed bin (35)), 5 30 iox_$read_key entry (pointer, char (256) varying, fixed bin (21), fixed bin (35)), 5 31 iox_$read_length entry (pointer, fixed bin (21), fixed bin (35)), 5 32 iox_$read_record entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 5 33 iox_$rewrite_record entry (pointer, pointer, fixed bin (21), fixed bin (35)), 5 34 iox_$seek_key entry (pointer, char (256) varying, fixed bin (21), fixed bin (35)), 5 35 iox_$write_record entry (pointer, pointer, fixed bin (21), fixed bin (35)), 5 36 iox_$open_file entry(ptr, fixed bin, char(*), bit(1) aligned, fixed bin(35)), 5 37 iox_$close_file entry(ptr, char(*), fixed bin(35)), 5 38 iox_$detach entry(ptr, char(*), fixed bin(35)), 5 39 iox_$attach_loud entry(ptr, char(*), ptr, fixed bin(35)); 5 40 5 41 dcl (iox_$user_output, 5 42 iox_$user_input, 5 43 iox_$user_io, 5 44 iox_$error_output) external static pointer; 5 45 5 46 /* ---------------- END include file iox_dcls.incl.pl1 ---------------- */ 890 6 1 /* BEGIN INCLUDE FILE ... sdw.incl.pl1 ... last modified 12 May 1976 */ 6 2 6 3 dcl sdwp ptr; 6 4 6 5 dcl 1 sdw based (sdwp) aligned, /* Segment Descriptor Word */ 6 6 6 7 (2 add bit (24), /* main memory address of page table */ 6 8 2 (r1, r2, r3) bit (3), /* ring brackets for the segment */ 6 9 2 df bit (1), /* directed fault bit (0 => fault) */ 6 10 2 df_no bit (2), /* directed fault number */ 6 11 6 12 2 pad1 bit (1), 6 13 2 bound bit (14), /* boundary field (in 16 word blocks) */ 6 14 2 access, /* access bits */ 6 15 3 read bit (1), /* read permission bit */ 6 16 3 execute bit (1), /* execute permission bit */ 6 17 3 write bit (1), /* write permission bit */ 6 18 3 privileged bit (1), /* privileged bit */ 6 19 2 unpaged bit (1), /* segment is unpaged if this is 1 */ 6 20 2 entry_bound_sw bit (1), /* if this is 0 the entry bound is checked by hardware */ 6 21 2 cache bit (1), /* cache enable bit */ 6 22 2 entry_bound bit (14)) unaligned; /* entry bound */ 6 23 6 24 dcl 1 sdwa (0: 1) based (sdwp) aligned like sdw; /* SDW array (descriptor segment) */ 6 25 6 26 /* END INCLUDE FILE sdw.incl.pl1 */ 891 7 1 /* BEGIN INCLUDE FILE . . . star_structures.incl.pl1 */ 7 2 7 3 /* This include file contains structures for the hcs_$star_, 7 4* hcs_$star_list_ and hcs_$star_dir_list_ entry points. 7 5* 7 6* Written 23 October 1978 by Monte Davidoff. 7 7* Modified January 1979 by Michael R. Jordan to use unsigned and different pointers for different structures. 7 8* Modified June 1981 by C. Hornig to count link pathnames more efficiently. 7 9**/ 7 10 7 11 /* automatic */ 7 12 7 13 declare star_branch_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching branch count */ 7 14 declare star_entry_count fixed binary; /* hcs_$star_: number of matching entries */ 7 15 declare star_entry_ptr pointer; /* hcs_$star_: pointer to array of entry information */ 7 16 declare star_list_branch_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to array of info */ 7 17 declare star_link_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching link count */ 7 18 declare star_linkx fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: index into star_links */ 7 19 declare star_names_ptr pointer; /* hcs_$star_: pointer to array of entry names */ 7 20 declare star_list_names_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to entry names */ 7 21 declare star_select_sw fixed binary (3); /* hcs_$star_list_, hcs_$star_dir_list_: what info to return */ 7 22 7 23 /* based */ 7 24 7 25 /* hcs_$star_ entry structure */ 7 26 7 27 declare 1 star_entries (star_entry_count) aligned based (star_entry_ptr), 7 28 2 type fixed binary (2) unsigned unaligned, 7 29 /* storage system type */ 7 30 2 nnames fixed binary (16) unsigned unaligned, 7 31 /* number of names of entry that match star_name */ 7 32 2 nindex fixed binary (18) unsigned unaligned; 7 33 /* index of first name in star_names */ 7 34 7 35 /* hcs_$star_ name structure */ 7 36 7 37 declare star_names (sum (star_entries (*).nnames)) char (32) based (star_names_ptr); 7 38 7 39 /* hcs_$star_list_ branch structure */ 7 40 7 41 declare 1 star_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 7 42 2 type fixed binary (2) unsigned unaligned, 7 43 /* storage system type */ 7 44 2 nnames fixed binary (16) unsigned unaligned, 7 45 /* number of names of entry that match star_name */ 7 46 2 nindex fixed binary (18) unsigned unaligned, 7 47 /* index of first name in star_list_names */ 7 48 2 dtcm bit (36) unaligned, /* date-time contents of branch were last modified */ 7 49 2 dtu bit (36) unaligned, /* date-time branch was last used */ 7 50 2 mode bit (5) unaligned, /* user's access mode to the branch */ 7 51 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 7 52 2 master_dir bit (1) unaligned, /* is branch a master directory */ 7 53 2 pad bit (7) unaligned, 7 54 2 records fixed binary (18) unsigned unaligned; 7 55 /* records used by branch */ 7 56 7 57 /* hcs_$star_dir_list_ branch structure */ 7 58 7 59 declare 1 star_dir_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 7 60 2 type fixed binary (2) unsigned unaligned, 7 61 /* storage system type */ 7 62 2 nnames fixed binary (16) unsigned unaligned, 7 63 /* number of names of entry that match star_name */ 7 64 2 nindex fixed binary (18) unsigned unaligned, 7 65 /* index of first name in star_list_names */ 7 66 2 dtem bit (36) unaligned, /* date-time directory entry of branch was last modified */ 7 67 2 pad bit (36) unaligned, 7 68 2 mode bit (5) unaligned, /* user's access mode to the branch */ 7 69 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 7 70 2 master_dir bit (1) unaligned, /* is branch a master directory */ 7 71 2 bit_count fixed binary (24) unaligned; 7 72 /* bit count of the branch */ 7 73 7 74 /* hcs_$star_list_ and hcs_$star_dir_list_ link structure */ 7 75 7 76 declare 1 star_links (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 7 77 2 type fixed binary (2) unsigned unaligned, 7 78 /* storage system type */ 7 79 2 nnames fixed binary (16) unsigned unaligned, 7 80 /* number of names of entry that match star_name */ 7 81 2 nindex fixed binary (18) unsigned unaligned, 7 82 /* index of first name in star_list_names */ 7 83 2 dtem bit (36) unaligned, /* date-time link was last modified */ 7 84 2 dtd bit (36) unaligned, /* date-time the link was last dumped */ 7 85 2 pathname_len fixed binary (18) unsigned unaligned, 7 86 /* length of the pathname of the link */ 7 87 2 pathname_index fixed binary (18) unsigned unaligned; 7 88 /* index of start of pathname in star_list_names */ 7 89 7 90 /* hcs_$star_list_ and hcs_$star_dir_list_ name array */ 7 91 7 92 declare star_list_names char (32) based (star_list_names_ptr) 7 93 dimension (star_links (star_branch_count + star_link_count).nindex 7 94 + star_links (star_branch_count + star_link_count).nnames 7 95 + divide (star_links (star_branch_count + star_link_count).pathname_len + 31, 32, 17, 0) 7 96 * binary ( 7 97 (star_links (star_branch_count + star_link_count).type = star_LINK) 7 98 & (star_select_sw >= star_LINKS_ONLY_WITH_LINK_PATHS), 1)); 7 99 7 100 /* hcs_$star_list_ and hcs_$star_dir_list_ link pathname */ 7 101 7 102 declare star_link_pathname char (star_links (star_linkx).pathname_len) 7 103 based (addr (star_list_names (star_links (star_linkx).pathname_index))); 7 104 7 105 /* internal static */ 7 106 7 107 /* star_select_sw values */ 7 108 7 109 declare star_LINKS_ONLY fixed binary (2) internal static options (constant) initial (1); 7 110 declare star_BRANCHES_ONLY fixed binary (2) internal static options (constant) initial (2); 7 111 declare star_ALL_ENTRIES fixed binary (2) internal static options (constant) initial (3); 7 112 declare star_LINKS_ONLY_WITH_LINK_PATHS 7 113 fixed binary (3) internal static options (constant) initial (5); 7 114 declare star_ALL_ENTRIES_WITH_LINK_PATHS 7 115 fixed binary (3) internal static options (constant) initial (7); 7 116 7 117 /* storage system types */ 7 118 7 119 declare star_LINK fixed binary (2) unsigned internal static options (constant) initial (0); 7 120 declare star_SEGMENT fixed binary (2) unsigned internal static options (constant) initial (1); 7 121 declare star_DIRECTORY fixed binary (2) unsigned internal static options (constant) initial (2); 7 122 7 123 /* END INCLUDE FILE . . . star_structures.incl.pl1 */ 892 8 1 /* BEGIN INCLUDE FILE ... terminate_file.incl.pl1 */ 8 2 /* format: style2,^inddcls,idind32 */ 8 3 8 4 declare 1 terminate_file_switches based, 8 5 2 truncate bit (1) unaligned, 8 6 2 set_bc bit (1) unaligned, 8 7 2 terminate bit (1) unaligned, 8 8 2 force_write bit (1) unaligned, 8 9 2 delete bit (1) unaligned; 8 10 8 11 declare TERM_FILE_TRUNC bit (1) internal static options (constant) initial ("1"b); 8 12 declare TERM_FILE_BC bit (2) internal static options (constant) initial ("01"b); 8 13 declare TERM_FILE_TRUNC_BC bit (2) internal static options (constant) initial ("11"b); 8 14 declare TERM_FILE_TERM bit (3) internal static options (constant) initial ("001"b); 8 15 declare TERM_FILE_TRUNC_BC_TERM bit (3) internal static options (constant) initial ("111"b); 8 16 declare TERM_FILE_FORCE_WRITE bit (4) internal static options (constant) initial ("0001"b); 8 17 declare TERM_FILE_DELETE bit (5) internal static options (constant) initial ("00001"b); 8 18 8 19 /* END INCLUDE FILE ... terminate_file.incl.pl1 */ 893 894 895 end copy_pdir_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 04/17/00 1922.2 copy_pdir_.pl1 >udd>sm>ds>w>ml>copy_pdir_.pl1 886 1 04/11/85 1552.6 access_mode_values.incl.pl1 >ldd>incl>access_mode_values.incl.pl1 887 2 10/14/83 1706.6 acl_structures.incl.pl1 >ldd>incl>acl_structures.incl.pl1 888 3 03/16/89 2112.8 create_branch_info.incl.pl1 >ldd>incl>create_branch_info.incl.pl1 889 4 10/14/83 1706.7 delete_options.incl.pl1 >ldd>incl>delete_options.incl.pl1 890 5 05/23/83 1016.6 iox_dcls.incl.pl1 >ldd>incl>iox_dcls.incl.pl1 891 6 09/14/76 0859.8 sdw.incl.pl1 >ldd>incl>sdw.incl.pl1 892 7 06/10/82 1145.5 star_structures.incl.pl1 >ldd>incl>star_structures.incl.pl1 893 8 04/06/83 1339.4 terminate_file.incl.pl1 >ldd>incl>terminate_file.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. CHASE 000251 constant fixed bin(1,0) initial dcl 101 set ref 448* DEFAULT_RING constant fixed bin(3,0) initial dcl 635 ref 644 DIR_ACL_INIT 000000 constant structure array level 1 dcl 110 ref 312 HC_SEGS 000173 constant char(12) initial array packed unaligned dcl 101 set ref 242 242 242 244* NL 006474 constant char(1) initial packed unaligned dcl 101 ref 697 879 NO_CHASE 000241 constant fixed bin(1,0) initial dcl 101 set ref 647* 744* RW_ACCESS_BIN 000246 constant fixed bin(5,0) initial dcl 1-36 set ref 545* 869* R_ACCESS constant bit(3) initial packed unaligned dcl 1-11 ref 718 821 834 R_ACCESS_BIN 000244 constant fixed bin(5,0) initial dcl 1-36 set ref 610* SEG_ACL_INIT 000062 constant structure array level 1 dcl 117 ref 302 SMA_ACCESS 000167 constant bit(3) initial packed unaligned dcl 1-11 ref 427 804 S_ACCESS constant bit(3) initial packed unaligned dcl 1-11 ref 749 TERM_FILE_TRUNC_BC_TERM 000167 constant bit(3) initial packed unaligned dcl 8-15 set ref 561* a_code parameter fixed bin(35,0) dcl 179 set ref 162 194 260* 268 286* a_live_process parameter char packed unaligned dcl 180 ref 194 198 a_need_hphcs parameter bit(1) packed unaligned dcl 182 ref 162 194 210 a_owner_acl parameter char packed unaligned dcl 181 set ref 162 194 205 207* a_pdir_name parameter char packed unaligned dcl 184 set ref 162 194 204 268 279* 280* a_pdir_path parameter char packed unaligned dcl 183 set ref 162 194 201 268 279* 280* access_class 20 000107 automatic bit(72) level 2 packed packed unaligned dcl 384 set ref 430* access_name based char(32) array level 2 in structure "segment_acl_array" packed packed unaligned dcl 2-46 in procedure "copy_pdir_" set ref 303* 717* 820* 833* access_name based char(32) array level 2 in structure "directory_acl_array" packed packed unaligned dcl 2-55 in procedure "copy_pdir_" set ref 313* 748* 803* acl_count 000370 automatic fixed bin(17,0) dcl 2-5 set ref 216* 224 225 301* 302 304* 306* 311* 312 314* 316* 327 328 716* 720* 747* 750* 802* 806* 819* 824* 832* 837* acl_ptr 000366 automatic pointer dcl 2-4 set ref 792* addr builtin function dcl 128 ref 404 433 433 526 526 529 529 529 529 532 535 535 604 604 880 addrel builtin function dcl 128 ref 535 535 adjust_bit_count_ 000010 constant entry external dcl 50 ref 559 665 amu_$dp_create_uid_hash 000012 constant entry external dcl 51 ref 251 attach_desc 000100 automatic char(200) packed unaligned dcl 856 set ref 871* 872* baseno builtin function dcl 128 ref 529 529 baseptr builtin function dcl 128 ref 529 529 bc_35 000102 automatic fixed bin(35,0) dcl 499 in procedure "copy_segment" set ref 559* 560 bc_35 000464 automatic fixed bin(35,0) dcl 661 in procedure "move_pdir_uid_seg" set ref 665* 666 binary builtin function dcl 128 ref 529 529 532 bit_count 000100 automatic fixed bin(24,0) dcl 497 set ref 533* 560* 561* bitcnt 16 000107 automatic fixed bin(24,0) level 2 dcl 384 set ref 426* bound 000101 automatic fixed bin(19,0) dcl 498 in procedure "copy_segment" set ref 532* 533 535 535 554* bound 1(01) based bit(14) level 2 in structure "sdw" packed packed unaligned dcl 6-5 in procedure "copy_pdir_" ref 532 caller parameter char packed unaligned dcl 185 set ref 162 194 268 279* 280* 337* 343* 673* cbi 000107 automatic structure level 1 unaligned dcl 384 set ref 433 433 chase_sw 1(02) 000107 automatic bit(1) level 3 packed packed unaligned dcl 384 set ref 423* cleanup 000100 stack reference condition dcl 134 ref 220 410 539 866 code parameter fixed bin(35,0) dcl 658 in procedure "move_pdir_uid_seg" set ref 655 664* 665* 667* 668 669* 670 673* code parameter fixed bin(35,0) dcl 760 in procedure "set_owner_rbs" set ref 756 769* 772* 777* code parameter fixed bin(35,0) dcl 373 in procedure "copy_pdir" set ref 366 409* 417* 418 433* 434 435* 436 438* 439 441 441* 448* 449 456* 457 458* 460 461* 462 463* 464 467* 468 469* 470 471* 473 code parameter fixed bin(35,0) dcl 295 in procedure "add_inacls" set ref 292 306* 307 316* 317 code 000454 automatic fixed bin(35,0) dcl 633 in procedure "get_pdir_rbs" set ref 645* 646 647* 648 code parameter fixed bin(35,0) dcl 683 in procedure "save_pdir_uid" set ref 680 692* 698* code parameter fixed bin(35,0) dcl 850 in procedure "setup_pdir_uids" set ref 845 864* 869* 872* 873 874* 875 882* code parameter fixed bin(35,0) dcl 491 in procedure "copy_segment" set ref 487 509* 512* 514* 521* 526* 527 529* 530 535* 536 545* 546 546 548* 549 552 554* 555 559* 565* code parameter fixed bin(35,0) dcl 593 in procedure "determine_stack_base" set ref 585 600* 604* 605 610* 612 612 614* 615 618 620* code parameter fixed bin(35,0) dcl 709 in procedure "set_hash_access" set ref 705 715* 720* code 000106 automatic fixed bin(35,0) dcl 142 in procedure "copy_pdir_" set ref 213* 227* 228 232* 234 239* 240 244* 245 248* 249 251* 252 254* 255 256* 257 260 276* 279* 280 280* 283 283* 286 340 code parameter fixed bin(35,0) dcl 787 in procedure "set_rb_and_access" set ref 784 791* 797* 798 806* 807 814* 815 824* 825 837* 838 code parameter fixed bin(35,0) dcl 730 in procedure "set_owner_status" set ref 726 741* 742 744* 745 750* com_err_ 000014 constant entry external dcl 52 ref 565 copy_dirname parameter char(168) packed unaligned dcl 186 set ref 162 194 227* 227* 232* copy_entryname parameter char(32) packed unaligned dcl 187 set ref 162 194 227* 227* 232* copy_sw 1(01) 000107 automatic bit(1) level 3 packed packed unaligned dcl 384 set ref 420* create_branch_info based structure level 1 dcl 3-17 create_branch_version_2 constant fixed bin(17,0) initial dcl 3-35 ref 419 cv_bin_$dec 000016 constant entry external dcl 53 ref 607 cv_bin_$oct 000020 constant entry external dcl 54 ref 696 cv_userid_ 000022 constant entry external dcl 55 ref 207 dead_pdir_ring 000107 automatic fixed bin(3,0) dcl 143 set ref 230* 232* deadproc 000110 automatic bit(1) packed unaligned dcl 144 set ref 189* 197* 810 delete_$path 000024 constant entry external dcl 56 ref 279 280 337 343 577 673 delete_$ptr 000026 constant entry external dcl 57 ref 867 delete_acl_entry based structure level 1 dcl 2-63 delete_options 000371 automatic structure level 1 packed packed unaligned dcl 4-7 set ref 277* 279 279 280 280 335* 337 337 341* 343 343 575* 577 577 671* 673 673 dir_acl_ptr 000112 automatic pointer dcl 145 set ref 217* 224* 312 313 316* 327 327 748 749 750* 803 804 805 806* dir_path 000114 automatic char(168) packed unaligned dcl 146 in procedure "copy_pdir_" set ref 201* 232* 238* 343* dir_path parameter char packed unaligned dcl 710 in procedure "set_hash_access" set ref 705 720* dir_path 000132 automatic char(168) packed unaligned dcl 385 in procedure "copy_pdir" set ref 406* 438* 448* 456* 458* 467* 471* dir_path parameter char packed unaligned dcl 731 in procedure "set_owner_status" set ref 726 741* dir_quota 22 000107 automatic fixed bin(18,0) level 2 dcl 384 set ref 431* dir_sw 1 000107 automatic bit(1) level 3 in structure "cbi" packed packed unaligned dcl 384 in procedure "copy_pdir" set ref 420* dir_sw parameter bit(1) packed unaligned dcl 788 in procedure "set_rb_and_access" ref 784 794 dir_sw parameter bit(1) packed unaligned dcl 762 in procedure "set_owner_rbs" ref 756 770 directory 0(02) 000371 automatic bit(1) level 2 packed packed unaligned dcl 4-7 set ref 278* 342* directory_acl_array based structure array level 1 dcl 2-55 set ref 224 312* 327 directory_acl_entry based structure level 1 dcl 2-54 dirname 000502 automatic char(168) packed unaligned dcl 736 in procedure "set_owner_status" set ref 741* 744* 750* dirname parameter char packed unaligned dcl 657 in procedure "move_pdir_uid_seg" set ref 655 667* 669* dirname parameter char packed unaligned dcl 786 in procedure "set_rb_and_access" set ref 784 797* 806* 814* 824* 837* dirname parameter char packed unaligned dcl 492 in procedure "copy_segment" set ref 487 512 514* 519 548* 577* dirname parameter char packed unaligned dcl 630 in procedure "get_pdir_rbs" set ref 626 647* dirname parameter char packed unaligned dcl 371 in procedure "copy_pdir" set ref 366 406* dirname parameter char packed unaligned dcl 592 in procedure "determine_stack_base" set ref 585 610* 614* dirname parameter char packed unaligned dcl 761 in procedure "set_owner_rbs" set ref 756 772* 777* dirname parameter char packed unaligned dcl 294 in procedure "add_inacls" set ref 292 306* 316* dp_dirname parameter char(168) packed unaligned dcl 852 ref 845 drb 000426 automatic fixed bin(3,0) array dcl 767 set ref 771* 771* 772* ename parameter char packed unaligned dcl 294 in procedure "add_inacls" set ref 292 306* 316* ename parameter char packed unaligned dcl 763 in procedure "set_owner_rbs" set ref 756 772* 777* ename parameter char packed unaligned dcl 372 in procedure "copy_pdir" set ref 366 406* ename 000103 automatic char(32) packed unaligned dcl 500 in procedure "copy_segment" set ref 510* 512* 514* 541 541* 545* 548* 559* 577* ename parameter char packed unaligned dcl 786 in procedure "set_rb_and_access" set ref 784 797* 806* 814* 824* 837* entryname 000554 automatic char(32) packed unaligned dcl 737 set ref 741* 744* 750* error_table_$action_not_performed 000124 external static fixed bin(35,0) dcl 90 ref 280 549 615 error_table_$empty_file 000126 external static fixed bin(35,0) dcl 90 ref 441 error_table_$infcnt_non_zero 000130 external static fixed bin(35,0) dcl 90 ref 283 error_table_$namedup 000132 external static fixed bin(35,0) dcl 90 ref 546 612 error_table_$nomatch 000134 external static fixed bin(35,0) dcl 90 ref 441 error_table_$segknown 000136 external static fixed bin(35,0) dcl 90 ref 552 618 expand_pathname_ 000030 constant entry external dcl 58 ref 417 741 extended_mode 11 based bit(36) array level 2 dcl 2-46 set ref 719* 822* 835* fixed builtin function dcl 128 ref 607 607 667 667 696 696 force 000371 automatic bit(1) level 2 packed packed unaligned dcl 4-7 set ref 278* 336* 342* 576* 672* general_acl_entry based structure level 1 unaligned dcl 2-12 general_delete_acl_entry based structure level 1 dcl 2-35 general_extended_acl_entry based structure level 1 dcl 2-23 get_group_id_$tag_star 000100 constant entry external dcl 78 ref 210 429 get_pdir_ 000102 constant entry external dcl 79 ref 865 get_ring_ 000032 constant entry external dcl 59 ref 403 get_system_free_area_ 000034 constant entry external dcl 60 ref 215 got_copy 000113 automatic bit(1) packed unaligned dcl 501 set ref 508* 557* 574 hbound builtin function dcl 128 ref 242 242 646 hcs_$add_acl_entries 000036 constant entry external dcl 61 ref 720 824 hcs_$add_dir_acl_entries 000042 constant entry external dcl 63 ref 750 806 hcs_$add_dir_inacl_entries 000044 constant entry external dcl 64 ref 316 hcs_$add_inacl_entries 000046 constant entry external dcl 65 ref 306 hcs_$create_branch_ 000050 constant entry external dcl 66 ref 433 hcs_$fs_move_file 000052 constant entry external dcl 67 ref 667 hcs_$get_uid_seg 000054 constant entry external dcl 68 ref 521 hcs_$make_seg 000056 constant entry external dcl 69 ref 545 610 869 hcs_$set_bc 000060 constant entry external dcl 70 ref 669 hcs_$set_dir_ring_brackets 000062 constant entry external dcl 71 ref 772 hcs_$set_max_length_seg 000064 constant entry external dcl 72 ref 620 hcs_$set_ring_brackets 000066 constant entry external dcl 73 ref 777 hcs_$star_ 000070 constant entry external dcl 74 ref 438 hcs_$status_minf 000072 constant entry external dcl 75 ref 448 647 744 hphcs_$add_acl_entries 000040 constant entry external dcl 61 ref 837 hphcs_$set_dir_ring_brackets 000074 constant entry external dcl 76 ref 797 hphcs_$set_ring_brackets 000076 constant entry external dcl 77 ref 814 i 000166 automatic fixed bin(17,0) dcl 147 in procedure "copy_pdir_" set ref 242* 244* i 000204 automatic fixed bin(17,0) dcl 386 in procedure "copy_pdir" set ref 445* 446 447 449 451 452 452 466* i 000455 automatic fixed bin(17,0) dcl 634 in procedure "get_pdir_rbs" set ref 646* 647 648* ignore 000167 automatic fixed bin(24,0) dcl 148 set ref 448* 647* 744* ignore_code 000100 automatic fixed bin(35,0) dcl 325 in procedure "clean_up" set ref 331* 332* 337* 343* ignore_code 000420 automatic fixed bin(35,0) dcl 355 in procedure "cleanup_pdir_uids" set ref 358* 359* iocb_ptr 000170 automatic pointer dcl 149 in procedure "copy_pdir_" set ref 214* 227* 232* 236* 330 331* 332* iocb_ptr parameter pointer dcl 354 in procedure "cleanup_pdir_uids" set ref 350 357 358* 359* iocbp parameter pointer dcl 682 in procedure "save_pdir_uid" set ref 680 698* iocbp parameter pointer dcl 374 in procedure "copy_pdir" set ref 366 463* 471* iocbp parameter pointer dcl 849 in procedure "setup_pdir_uids" set ref 845 863* 872* 874* 882* iox_$attach_name 000140 constant entry external dcl 5-8 ref 872 iox_$close 000142 constant entry external dcl 5-8 ref 331 358 iox_$detach_iocb 000144 constant entry external dcl 5-8 ref 332 359 iox_$open 000146 constant entry external dcl 5-8 ref 874 iox_$put_chars 000150 constant entry external dcl 5-8 ref 698 882 lbound builtin function dcl 128 ref 242 length builtin function dcl 128 ref 405 881 line_ptr 000162 automatic pointer dcl 857 in procedure "setup_pdir_uids" set ref 880* 882* line_ptr 000206 automatic pointer dcl 387 in procedure "copy_pdir" set ref 404* 463* live_process 000172 automatic char(32) packed unaligned dcl 150 set ref 190* 198* 246 452 541 ltrim builtin function dcl 128 ref 608 mbz1 1(05) 000107 automatic bit(31) level 3 packed packed unaligned dcl 384 set ref 423* mbz2 2(03) 000107 automatic bit(33) level 2 packed packed unaligned dcl 384 set ref 423* mode 2 000107 automatic bit(3) level 2 in structure "cbi" packed packed unaligned dcl 384 in procedure "copy_pdir" set ref 427* mode 10 based bit(36) array level 2 in structure "segment_acl_array" dcl 2-46 in procedure "copy_pdir_" set ref 718* 821* 834* mode 10 based bit(36) array level 2 in structure "directory_acl_array" dcl 2-55 in procedure "copy_pdir_" set ref 749* 804* myname 000170 constant char(10) initial packed unaligned dcl 101 set ref 548* 565* 577* 614* 867* n_write 000164 automatic fixed bin(21,0) dcl 858 in procedure "setup_pdir_uids" set ref 881* 882* n_write parameter fixed bin(21,0) dcl 687 in procedure "save_pdir_uid" set ref 680 697 698* n_write 000210 automatic fixed bin(21,0) dcl 388 in procedure "copy_pdir" set ref 405* 463* nd_handler_ 000104 constant entry external dcl 80 ref 548 614 need_to_set_rbs 000211 automatic bit(1) packed unaligned dcl 389 set ref 403* 461 469 nindex 0(18) based fixed bin(18,0) array level 2 packed packed unsigned unaligned dcl 391 ref 446 452 nnames 0(02) based fixed bin(16,0) array level 2 packed packed unsigned unaligned dcl 391 ref 452 null builtin function dcl 128 ref 214 217 327 328 330 357 408 411 412 477 480 507 515 574 601 792 863 867 870 872 872 owner_acl parameter char packed unaligned dcl 732 in procedure "set_owner_status" ref 726 748 owner_acl parameter char packed unaligned dcl 711 in procedure "set_hash_access" ref 705 717 owner_acl 000202 automatic char(32) packed unaligned dcl 151 in procedure "copy_pdir_" set ref 207* 232* 254* 256* owner_acl parameter char packed unaligned dcl 297 in procedure "add_inacls" ref 292 303 313 owner_acl parameter char packed unaligned dcl 375 in procedure "copy_pdir" set ref 366 435* 471* owner_sw parameter bit(1) packed unaligned dcl 296 in procedure "add_inacls" ref 292 303 313 owner_sw parameter bit(1) packed unaligned dcl 376 in procedure "copy_pdir" set ref 366 435* 471* owner_sw 000212 automatic bit(1) packed unaligned dcl 152 in procedure "copy_pdir_" set ref 205* 208* 232* 253 parent_ac_sw 1(04) 000107 automatic bit(1) level 3 packed packed unaligned dcl 384 set ref 420* pathname_ 000106 constant entry external dcl 81 ref 227 227 238 406 407 pdir_line 000212 automatic char(45) packed unaligned dcl 390 in procedure "copy_pdir" set ref 404 405 463* pdir_line 000165 automatic char(45) packed unaligned dcl 859 in procedure "setup_pdir_uids" set ref 879* 880 881 pdir_path 000213 automatic char(168) packed unaligned dcl 153 set ref 230* 238* 239* 244* 248* 251* 254* 256* pdir_ring parameter fixed bin(3,0) dcl 377 in procedure "copy_pdir" set ref 366 403 461* 469* 471* pdir_ring parameter fixed bin(3,0) dcl 631 in procedure "get_pdir_rbs" set ref 626 644* 648* pdir_to_create 000265 automatic char(32) packed unaligned dcl 154 set ref 204* 232* 238* 343* phcs_$initiate 000110 constant entry external dcl 82 ref 514 priv_upgrade_sw 1(03) 000107 automatic bit(1) level 3 packed packed unaligned dcl 384 set ref 423* process_dir parameter char(168) packed unaligned dcl 659 in procedure "move_pdir_uid_seg" set ref 655 665* 667* 673* 674* process_dir 000275 automatic char(168) packed unaligned dcl 155 in procedure "copy_pdir_" set ref 218* 227* 239* 334 337* process_dir parameter char(168) packed unaligned dcl 851 in procedure "setup_pdir_uids" set ref 845 865* 869* 871 putline parameter char packed unaligned dcl 686 set ref 680 697* putline_ptr parameter pointer dcl 685 set ref 680 698* quota 17 000107 automatic fixed bin(18,0) level 2 dcl 384 set ref 426* rbs 000422 automatic fixed bin(3,0) array dcl 766 set ref 776* 776* 776* 777* ring0_get_$segptr 000112 constant entry external dcl 84 ref 512 ring_zero_peek_ 000114 constant entry external dcl 85 ref 526 529 535 554 ring_zero_peek_$by_definition 000116 constant entry external dcl 86 ref 604 rings 3 000107 automatic fixed bin(3,0) array level 2 dcl 384 set ref 428* rtrim builtin function dcl 128 ref 871 s_entries based structure array level 1 dcl 391 set ref 412 480 s_entry_count 000226 automatic fixed bin(17,0) dcl 392 set ref 412 438* 445 480 s_entry_ptr 000230 automatic pointer dcl 393 set ref 408* 412 412 438* 446 447 449 451 452 452 466 480 480 s_names based char(32) array dcl 395 ref 411 446 452 477 s_names_ptr 000232 automatic pointer dcl 394 set ref 408* 411 411 438* 446 452 477 477 sdw based structure level 1 dcl 6-5 sdwa based structure array level 1 dcl 6-24 set ref 529 529 seg_acl_ptr 000350 automatic pointer dcl 156 set ref 217* 225* 302 303 306* 328 328 717 718 719 720* 820 821 822 823 824* 833 834 835 836 837* seg_bc 000465 automatic fixed bin(24,0) dcl 662 set ref 666* 669* seg_name parameter char packed unaligned dcl 688 ref 680 697 seg_to_copy parameter char packed unaligned dcl 493 set ref 487 510 541* segment 0(03) 000371 automatic bit(1) level 2 packed packed unaligned dcl 4-7 set ref 336* 342* 576* 672* segment_acl_array based structure array level 1 dcl 2-46 set ref 225 302* 328 segment_acl_entry based structure level 1 dcl 2-45 segptr 000114 automatic pointer dcl 502 in procedure "copy_segment" set ref 507* 545* 554* 561* 574 segptr 000202 automatic pointer dcl 860 in procedure "setup_pdir_uids" set ref 863* 867 867* 869* 870 segptr 000444 automatic pointer dcl 598 in procedure "determine_stack_base" set ref 601* 610* 620* segptr0 000116 automatic pointer dcl 503 set ref 507* 512* 514* 515 521* 526* 529 529 535 535 554* size builtin function dcl 128 ref 526 526 529 529 535 535 stack_base 000434 automatic char(32) packed unaligned dcl 597 set ref 602* 608* 610* 614* stackbase_segno 000430 automatic fixed bin(35,0) dcl 595 set ref 603* 604 604 607 607 stacks 000151 constant char(7) initial array packed unaligned dcl 635 set ref 646 647* star_ALL_ENTRIES 000247 constant fixed bin(2,0) initial dcl 7-111 set ref 438* star_DIRECTORY constant fixed bin(2,0) initial unsigned dcl 7-121 ref 466 star_LINK constant fixed bin(2,0) initial unsigned dcl 7-119 ref 447 star_SEGMENT constant fixed bin(2,0) initial unsigned dcl 7-120 ref 451 star_entries based structure array level 1 dcl 7-27 star_entry_count 000372 automatic fixed bin(17,0) dcl 7-14 set ref 203* status_code 12 based fixed bin(35,0) array level 2 in structure "segment_acl_array" dcl 2-46 in procedure "copy_pdir_" set ref 823* 836* status_code 11 based fixed bin(35,0) array level 2 in structure "directory_acl_array" dcl 2-55 in procedure "copy_pdir_" set ref 805* string builtin function dcl 128 set ref 277* 279 279 280 280 335* 337 337 341* 343 343 575* 577 577 671* 673 673 substr builtin function dcl 128 set ref 697* switches 1 000107 automatic structure level 2 packed packed unaligned dcl 384 sys_release 000204 automatic char(44) packed unaligned dcl 861 set ref 878* 879 system_area based area(1024) dcl 138 ref 224 225 327 328 411 412 477 480 system_area_ptr 000352 automatic pointer dcl 157 set ref 215* 224 225 327 328 411 412 438* 477 480 system_info_$sysid 000120 constant entry external dcl 87 ref 878 t_ename 000306 automatic char(32) packed unaligned dcl 398 set ref 417* 446* 448* 452 452* 456* 458* 461* 463* 467* 469* 471* 471* t_parent 000234 automatic char(168) packed unaligned dcl 397 set ref 417* target_dir_path 000316 automatic char(168) packed unaligned dcl 399 set ref 407* 458* 461* 469* 471* target_dirname parameter char packed unaligned dcl 494 in procedure "copy_segment" set ref 487 545* 559 target_dirname parameter char packed unaligned dcl 378 in procedure "copy_pdir" set ref 366 407* 417* 433* 435* target_ename parameter char packed unaligned dcl 379 set ref 366 407* 433* 435* tbase 000431 automatic char(12) dcl 596 set ref 602* 607* 608 terminate_file_ 000122 constant entry external dcl 88 ref 561 test_word 000120 automatic fixed bin(35,0) dcl 504 set ref 526 526 526 526 535 535 535 535 tsdw 000122 automatic fixed bin(71,0) dcl 505 set ref 529 529 529 529 532 tuid 000410 automatic char(12) dcl 690 set ref 696* 697 type based fixed bin(2,0) array level 2 in structure "s_entries" packed packed unsigned unaligned dcl 391 in procedure "copy_pdir" set ref 447 449* 451 466 type 000370 automatic fixed bin(2,0) dcl 400 in procedure "copy_pdir" set ref 448* 449 type 000354 automatic fixed bin(2,0) dcl 158 in procedure "copy_pdir_" set ref 647* 744* unique_id parameter bit(36) dcl 684 in procedure "save_pdir_uid" ref 680 694 696 696 unique_id 000371 automatic bit(36) dcl 401 in procedure "copy_pdir" set ref 458* 463* unique_id parameter bit(36) dcl 495 in procedure "copy_segment" set ref 487 519* 521* user_acl 000355 automatic char(32) packed unaligned dcl 159 in procedure "copy_pdir_" set ref 210* 211* 232* user_acl parameter char packed unaligned dcl 789 in procedure "set_rb_and_access" ref 784 803 820 833 user_acl parameter char packed unaligned dcl 380 in procedure "copy_pdir" set ref 366 456 456* 467 467* 471* user_ring parameter fixed bin(3,0) dcl 764 ref 756 771 776 userid 6 000107 automatic char(32) level 2 packed packed unaligned dcl 384 set ref 429* version 000107 automatic fixed bin(17,0) level 2 dcl 384 set ref 419* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ACL_VERSION_1 internal static fixed bin(17,0) initial dcl 2-77 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 DELETE_ACL_VERSION_1 internal static char(4) initial packed unaligned dcl 2-67 DIR_ACCESS_MODE_NAMES internal static char(4) initial array packed unaligned dcl 1-33 DIR_ACL_VERSION_1 internal static char(4) initial packed unaligned dcl 2-67 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 GENERAL_ACL_VERSION_1 internal static char(8) initial packed unaligned dcl 2-72 GENERAL_DELETE_ACL_VERSION_1 internal static char(8) initial packed unaligned dcl 2-72 GENERAL_EXTENDED_ACL_VERSION_1 internal static char(8) initial packed unaligned dcl 2-72 M_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 M_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 N_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 N_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 REW_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 REW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 RE_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 RE_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 RW_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 SA_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 SA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SEG_ACCESS_MODE_NAMES internal static char(4) initial array packed unaligned dcl 1-30 SEG_ACL_VERSION_1 internal static char(4) initial packed unaligned dcl 2-67 SMA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SM_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 SM_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 S_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 TERM_FILE_BC internal static bit(2) initial packed unaligned dcl 8-12 TERM_FILE_DELETE internal static bit(5) initial packed unaligned dcl 8-17 TERM_FILE_FORCE_WRITE internal static bit(4) initial packed unaligned dcl 8-16 TERM_FILE_TERM internal static bit(3) initial packed unaligned dcl 8-14 TERM_FILE_TRUNC internal static bit(1) initial packed unaligned dcl 8-11 TERM_FILE_TRUNC_BC internal static bit(2) initial packed unaligned dcl 8-13 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 delete_acl based structure level 1 dcl 2-58 delete_acl_array based structure array level 1 dcl 2-64 directory_acl based structure level 1 dcl 2-49 general_acl based structure level 1 dcl 2-7 general_delete_acl based structure level 1 dcl 2-30 general_extended_acl based structure level 1 dcl 2-18 iox_$attach_loud 000000 constant entry external dcl 5-8 iox_$attach_ptr 000000 constant entry external dcl 5-8 iox_$close_file 000000 constant entry external dcl 5-8 iox_$control 000000 constant entry external dcl 5-8 iox_$delete_record 000000 constant entry external dcl 5-8 iox_$destroy_iocb 000000 constant entry external dcl 5-8 iox_$detach 000000 constant entry external dcl 5-8 iox_$err_no_operation 000000 constant entry external dcl 5-8 iox_$err_not_attached 000000 constant entry external dcl 5-8 iox_$err_not_closed 000000 constant entry external dcl 5-8 iox_$err_not_open 000000 constant entry external dcl 5-8 iox_$error_output external static pointer dcl 5-41 iox_$find_iocb 000000 constant entry external dcl 5-8 iox_$find_iocb_n 000000 constant entry external dcl 5-8 iox_$get_chars 000000 constant entry external dcl 5-8 iox_$get_line 000000 constant entry external dcl 5-8 iox_$look_iocb 000000 constant entry external dcl 5-8 iox_$modes 000000 constant entry external dcl 5-8 iox_$move_attach 000000 constant entry external dcl 5-8 iox_$open_file 000000 constant entry external dcl 5-8 iox_$position 000000 constant entry external dcl 5-8 iox_$propagate 000000 constant entry external dcl 5-8 iox_$read_key 000000 constant entry external dcl 5-8 iox_$read_length 000000 constant entry external dcl 5-8 iox_$read_record 000000 constant entry external dcl 5-8 iox_$rewrite_record 000000 constant entry external dcl 5-8 iox_$seek_key 000000 constant entry external dcl 5-8 iox_$user_input external static pointer dcl 5-41 iox_$user_io external static pointer dcl 5-41 iox_$user_output external static pointer dcl 5-41 iox_$write_record 000000 constant entry external dcl 5-8 sdwp automatic pointer dcl 6-3 segment_acl based structure level 1 dcl 2-40 star_ALL_ENTRIES_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 7-114 star_BRANCHES_ONLY internal static fixed bin(2,0) initial dcl 7-110 star_LINKS_ONLY internal static fixed bin(2,0) initial dcl 7-109 star_LINKS_ONLY_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 7-112 star_branch_count automatic fixed bin(17,0) dcl 7-13 star_dir_list_branch based structure array level 1 dcl 7-59 star_entry_ptr automatic pointer dcl 7-15 star_link_count automatic fixed bin(17,0) dcl 7-17 star_link_pathname based char packed unaligned dcl 7-102 star_links based structure array level 1 dcl 7-76 star_linkx automatic fixed bin(17,0) dcl 7-18 star_list_branch based structure array level 1 dcl 7-41 star_list_branch_ptr automatic pointer dcl 7-16 star_list_names based char(32) array packed unaligned dcl 7-92 star_list_names_ptr automatic pointer dcl 7-20 star_names based char(32) array packed unaligned dcl 7-37 star_names_ptr automatic pointer dcl 7-19 star_select_sw automatic fixed bin(3,0) dcl 7-21 terminate_file_switches based structure level 1 packed packed unaligned dcl 8-4 NAMES DECLARED BY EXPLICIT CONTEXT. COMMON 000511 constant label dcl 201 ref 191 199 CREATE 004327 constant label dcl 610 in procedure "determine_stack_base" ref 616 CREATE 003621 constant label dcl 541 in procedure "copy_segment" ref 550 END_COPY_PDIR 001154 constant label dcl 260 ref 228 234 240 245 249 252 255 257 ERROR_COPY 003250 constant label dcl 477 ref 442 457 460 462 464 468 470 473 RZP_ERROR 004045 constant label dcl 565 ref 527 530 536 555 add_inacls 001330 constant entry internal dcl 292 ref 435 clean_up 001624 constant entry internal dcl 323 ref 221 262 cleanup_pdir_uids 002027 constant entry internal dcl 350 ref 236 copy_pdir 002062 constant entry internal dcl 366 ref 232 471 copy_pdir_ 000354 constant entry external dcl 9 copy_pdir_$deadproc 000371 constant entry external dcl 162 copy_pdir_$delete 001167 constant entry external dcl 268 copy_pdir_$liveproc 000441 constant entry external dcl 194 copy_segment 003266 constant entry internal dcl 487 ref 244 458 determine_stack_base 004157 constant entry internal dcl 585 ref 248 get_pdir_rbs 004451 constant entry internal dcl 626 ref 230 move_pdir_uid_seg 004551 constant entry internal dcl 655 ref 239 rzd_cleanup 004077 constant entry internal dcl 572 ref 539 569 save_pdir_uid 005004 constant entry internal dcl 680 ref 463 set_hash_access 005113 constant entry internal dcl 705 ref 254 set_owner_rbs 005367 constant entry internal dcl 756 ref 461 469 set_owner_status 005210 constant entry internal dcl 726 ref 256 set_rb_and_access 005501 constant entry internal dcl 784 ref 456 467 setup_pdir_uids 006056 constant entry internal dcl 845 ref 227 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 7376 7550 6475 7406 Length 10246 6475 152 461 701 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME copy_pdir_ 688 external procedure is an external procedure. on unit on line 220 64 on unit add_inacls internal procedure shares stack frame of internal procedure copy_pdir. clean_up 94 internal procedure is called by several nonquick procedures. cleanup_pdir_uids internal procedure shares stack frame of external procedure copy_pdir_. copy_pdir 556 internal procedure enables or reverts conditions. on unit on line 410 64 on unit copy_segment 190 internal procedure enables or reverts conditions. on unit on line 539 64 on unit rzd_cleanup 88 internal procedure is called by several nonquick procedures. determine_stack_base internal procedure shares stack frame of external procedure copy_pdir_. get_pdir_rbs internal procedure shares stack frame of external procedure copy_pdir_. move_pdir_uid_seg internal procedure shares stack frame of external procedure copy_pdir_. save_pdir_uid internal procedure shares stack frame of internal procedure copy_pdir. set_hash_access internal procedure shares stack frame of external procedure copy_pdir_. set_owner_status internal procedure shares stack frame of external procedure copy_pdir_. set_owner_rbs internal procedure shares stack frame of internal procedure copy_pdir. set_rb_and_access internal procedure shares stack frame of internal procedure copy_pdir. setup_pdir_uids 186 internal procedure enables or reverts conditions. on unit on line 866 84 on unit STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME clean_up 000100 ignore_code clean_up copy_pdir 000107 cbi copy_pdir 000132 dir_path copy_pdir 000204 i copy_pdir 000206 line_ptr copy_pdir 000210 n_write copy_pdir 000211 need_to_set_rbs copy_pdir 000212 pdir_line copy_pdir 000226 s_entry_count copy_pdir 000230 s_entry_ptr copy_pdir 000232 s_names_ptr copy_pdir 000234 t_parent copy_pdir 000306 t_ename copy_pdir 000316 target_dir_path copy_pdir 000370 type copy_pdir 000371 unique_id copy_pdir 000410 tuid save_pdir_uid 000422 rbs set_owner_rbs 000426 drb set_owner_rbs copy_pdir_ 000106 code copy_pdir_ 000107 dead_pdir_ring copy_pdir_ 000110 deadproc copy_pdir_ 000112 dir_acl_ptr copy_pdir_ 000114 dir_path copy_pdir_ 000166 i copy_pdir_ 000167 ignore copy_pdir_ 000170 iocb_ptr copy_pdir_ 000172 live_process copy_pdir_ 000202 owner_acl copy_pdir_ 000212 owner_sw copy_pdir_ 000213 pdir_path copy_pdir_ 000265 pdir_to_create copy_pdir_ 000275 process_dir copy_pdir_ 000350 seg_acl_ptr copy_pdir_ 000352 system_area_ptr copy_pdir_ 000354 type copy_pdir_ 000355 user_acl copy_pdir_ 000366 acl_ptr copy_pdir_ 000370 acl_count copy_pdir_ 000371 delete_options copy_pdir_ 000372 star_entry_count copy_pdir_ 000420 ignore_code cleanup_pdir_uids 000430 stackbase_segno determine_stack_base 000431 tbase determine_stack_base 000434 stack_base determine_stack_base 000444 segptr determine_stack_base 000454 code get_pdir_rbs 000455 i get_pdir_rbs 000464 bc_35 move_pdir_uid_seg 000465 seg_bc move_pdir_uid_seg 000502 dirname set_owner_status 000554 entryname set_owner_status copy_segment 000100 bit_count copy_segment 000101 bound copy_segment 000102 bc_35 copy_segment 000103 ename copy_segment 000113 got_copy copy_segment 000114 segptr copy_segment 000116 segptr0 copy_segment 000120 test_word copy_segment 000122 tsdw copy_segment setup_pdir_uids 000100 attach_desc setup_pdir_uids 000162 line_ptr setup_pdir_uids 000164 n_write setup_pdir_uids 000165 pdir_line setup_pdir_uids 000202 segptr setup_pdir_uids 000204 sys_release setup_pdir_uids THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_ne_as alloc_char_temp cat_realloc_chars call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other_desc call_int_other return_mac bound_ck_signal enable_op shorten_stack ext_entry ext_entry_desc int_entry int_entry_desc op_alloc_ op_freen_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. adjust_bit_count_ amu_$dp_create_uid_hash com_err_ cv_bin_$dec cv_bin_$oct cv_userid_ delete_$path delete_$ptr expand_pathname_ get_group_id_$tag_star get_pdir_ get_ring_ get_system_free_area_ hcs_$add_acl_entries hcs_$add_dir_acl_entries hcs_$add_dir_inacl_entries hcs_$add_inacl_entries hcs_$create_branch_ hcs_$fs_move_file hcs_$get_uid_seg hcs_$make_seg hcs_$set_bc hcs_$set_dir_ring_brackets hcs_$set_max_length_seg hcs_$set_ring_brackets hcs_$star_ hcs_$status_minf hphcs_$add_acl_entries hphcs_$set_dir_ring_brackets hphcs_$set_ring_brackets iox_$attach_name iox_$close iox_$detach_iocb iox_$open iox_$put_chars nd_handler_ pathname_ phcs_$initiate ring0_get_$segptr ring_zero_peek_ ring_zero_peek_$by_definition system_info_$sysid terminate_file_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$action_not_performed error_table_$empty_file error_table_$infcnt_non_zero error_table_$namedup error_table_$nomatch error_table_$segknown LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 9 000353 162 000361 189 000424 190 000426 191 000431 194 000432 197 000501 198 000502 199 000510 201 000511 203 000521 204 000522 205 000532 207 000543 208 000561 210 000563 211 000601 213 000604 214 000605 215 000607 216 000616 217 000620 218 000623 220 000626 221 000642 222 000647 224 000650 225 000656 227 000664 228 000721 230 000723 232 000726 234 000777 236 001001 238 001003 239 001023 240 001026 242 001030 244 001041 245 001075 246 001077 248 001113 249 001116 251 001120 252 001135 253 001137 254 001142 255 001145 256 001147 257 001152 260 001154 262 001155 264 001161 268 001162 276 001215 277 001216 278 001217 279 001223 280 001260 283 001320 286 001325 287 001327 292 001330 301 001353 302 001356 303 001414 304 001430 306 001433 307 001474 311 001500 312 001503 313 001536 314 001552 316 001555 317 001616 319 001622 323 001623 327 001631 328 001642 330 001653 331 001660 332 001671 334 001703 335 001710 336 001711 337 001715 340 001757 341 001762 342 001763 343 001771 346 002026 350 002027 357 002031 358 002035 359 002046 362 002060 366 002061 403 002126 404 002141 405 002143 406 002145 407 002167 408 002212 409 002215 410 002217 411 002233 412 002242 413 002251 417 002252 418 002301 419 002304 420 002306 423 002314 426 002324 427 002326 428 002330 429 002341 430 002350 431 002353 433 002354 434 002405 435 002410 436 002441 438 002444 439 002512 441 002515 442 002522 445 002523 446 002533 447 002544 448 002550 449 002607 451 002621 452 002630 456 002657 457 002721 458 002724 460 002754 461 002757 462 003013 463 003016 464 003055 465 003060 466 003061 467 003063 468 003125 469 003130 470 003164 471 003167 473 003243 475 003246 477 003250 480 003256 481 003264 487 003265 507 003313 508 003316 509 003317 510 003321 512 003326 514 003361 515 003424 519 003430 521 003441 526 003454 527 003476 529 003501 530 003533 532 003536 533 003544 535 003546 536 003574 539 003577 541 003621 545 003643 546 003702 548 003710 549 003735 550 003742 552 003743 554 003745 555 003762 557 003765 559 003767 560 004014 561 004016 563 004044 565 004045 569 004071 570 004075 572 004076 574 004104 575 004113 576 004115 577 004121 579 004156 585 004157 600 004170 601 004172 602 004174 603 004202 604 004204 605 004257 607 004263 608 004276 610 004327 612 004367 614 004375 615 004422 616 004430 618 004431 620 004434 622 004450 626 004451 644 004462 645 004465 646 004467 647 004476 648 004540 649 004545 651 004550 655 004551 664 004562 665 004564 666 004610 667 004612 668 004664 669 004670 670 004723 671 004727 672 004730 673 004734 674 004776 676 005003 680 005004 692 005022 694 005024 696 005027 697 005042 698 005074 700 005112 705 005113 715 005131 716 005133 717 005135 718 005143 719 005146 720 005147 722 005207 726 005210 741 005226 742 005255 744 005261 745 005316 747 005322 748 005324 749 005332 750 005335 752 005366 756 005367 769 005405 770 005407 771 005414 772 005417 773 005445 776 005446 777 005452 780 005500 784 005501 791 005524 792 005526 794 005531 797 005536 798 005576 802 005602 803 005605 804 005613 805 005616 806 005617 807 005651 808 005655 810 005656 814 005660 815 005720 819 005724 820 005727 821 005735 822 005740 823 005741 824 005742 825 005774 826 006000 832 006001 833 006003 834 006011 835 006014 836 006015 837 006016 838 006050 841 006054 845 006055 863 006063 864 006067 865 006070 866 006076 867 006112 868 006146 869 006147 870 006212 871 006216 872 006257 873 006314 874 006317 875 006340 878 006343 879 006354 880 006362 881 006364 882 006366 885 006404 ----------------------------------------------------------- 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