COMPILATION LISTING OF SEGMENT fs_standard_object_ Compiled by: Multics PL/I Compiler, Release 33a, of May 30, 1990 Compiled at: ACTC Technologies Inc. Compiled on: 10/17/90 0817.4 mdt Wed Options: optimize map 1 /****^ ************************************************************** 2* * * 3* * Copyright, (C) BULL HN Information Systems Inc., 1990 * 4* * * 5* * Copyright, (C) Honeywell Bull Inc., 1988 * 6* * * 7* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 8* * * 9* * Copyright, (C) Massachusetts Institute of Technology, 1983 * 10* * * 11* ************************************************************** */ 12 13 14 15 16 /****^ HISTORY COMMENTS: 17* 1) change(86-05-02,Elhard), approve(86-05-02,MCR7391), 18* audit(86-11-06,GDixon), install(86-11-20,MR12.0-1222): 19* Modified to allow setting "e" access on multisegment files. 20* 2) change(86-08-05,Houck), approve(86-08-11,MCR7501), audit(86-08-15,Wong), 21* install(86-08-29,MR12.0-1140): 22* Changed program so that a copy switch can be set for a directory. 23* 3) change(88-05-05,Lippard), approve(88-05-02,MCR7881), 24* audit(88-06-16,Fawcett), install(88-08-02,MR12.2-1074): 25* Added audit_switch. 26* 4) change(90-09-20,Bubric), approve(90-10-01,MCR8211), audit(90-10-01,Itani), 27* install(90-10-17,MR12.4-1044): 28* Have the calls to the routine 'nothing' changed to calls to the routine 29* 'null_entry_'. 30* END HISTORY COMMENTS */ 31 32 33 /* format: style2,indcomtxt */ 34 /* BIM 820921 */ 35 /**** 36* fs_standard_object_ -- entrypoints that the extended object code can return 37* to do work on segments, directories, MSF's and dm_files. Sometimes, hcs_ 38* suffices. Other times, fs_acl_util_ is the ticket. */ 39 40 /**** make_entry has the knowledge of what entries belong to what. 41* since fs_util_$make_entry makes no expensive calls to hcs_$make_entry, 42* object_type_/file_system_ (whatever its name turns out to be) 43* can call it all the time once it determines that some object 44* is a standard object. */ 45 46 /**** * Modified 831022 BIM for FS_OBJECT_TYPE_LINK */ 47 /**** * Modified 840229 MAP to make these types standard with no extended ACL except for segs */ 48 /**** * Modified 841107 MAP to fix list_switch entrypoints */ 49 /**** * Modified 841129 Pierret to always return an entry for dm_files */ 50 /**** * Modified 850114 Pierret to return file_manager_$list_switches */ 51 /**** * Modified 850206 MSharpe to use (ncvd nivd) < 0 instead of = 0 for determining the state of the swtiches. */ 52 /**** * Modified 850226 MSharpe to report inconsistent msf if MSF>0 is not found */ 53 54 fs_standard_object_: 55 procedure; 56 57 make_entry: 58 entry (Type, Operation, Code) returns (entry); 59 60 declare Type fixed bin; /* index into FS_STANDARD_TYPES in file_system_operations_.incl.pl1 */ 61 declare Operation fixed bin; /* index into FS_OPERATIONS in file_system_operations_.incl.pl1 */ 62 declare Code fixed bin (35) parameter; 63 64 declare make_entry_jumpx fixed bin; 65 66 67 68 /**** Assume that the two fixed bins are within their respective bounds. 69* Now, wish that we had 2 dimensional label arrays! */ 70 71 make_entry_jumpx = ((Operation - 1) * HIGHEST_FS_STANDARD_TYPE_INDEX) + Type; 72 /* index goes through types rapidly, operations slowly */ 73 74 Code = 0; 75 go to MAKE_ENTRY_LABEL (make_entry_jumpx); /* cant just have an array of entry constants that is any use at all */ 76 77 78 /**** * 79* NOTE NOTE 80* These entries must be in the same order as the array of names 81* in file_system_operation_.incl.pl1! */ 82 83 84 85 86 /**** ADD_ACL_ENTRIES */ 87 88 MAKE_ENTRY_LABEL (1): /** directory */ 89 90 return (fs_acl_util_$add_directory); 91 MAKE_ENTRY_LABEL (2): /** dm_file */ 92 93 return (file_manager_$add_acl_entries); 94 MAKE_ENTRY_LABEL (3): /** link */ 95 96 Code = error_table_$unsupported_operation; 97 return (null_entry_); 98 MAKE_ENTRY_LABEL (4): /** msf */ 99 100 return (fs_acl_util_$add_msf); 101 MAKE_ENTRY_LABEL (5): /** segment */ 102 103 return (fs_acl_util_$add_segment); 104 105 /**** ADD_EXTENDED_ACL_ENTRIES */ 106 107 MAKE_ENTRY_LABEL (6): /** directory */ 108 109 Code = error_table_$unsupported_operation; 110 return (null_entry_); 111 MAKE_ENTRY_LABEL (7): /** dm_file */ 112 113 return (file_manager_$add_extended_acl_entries); 114 MAKE_ENTRY_LABEL (8): /** link */ 115 116 Code = error_table_$unsupported_operation; 117 return (null_entry_); 118 MAKE_ENTRY_LABEL (9): /** msf */ 119 120 return (fs_acl_util_$add_msf_extended); 121 MAKE_ENTRY_LABEL (10): /** segment */ 122 123 return (fs_acl_util_$add_segment_extended); 124 125 /**** CHNAME_FILE */ 126 127 MAKE_ENTRY_LABEL (11): /** directory */ 128 129 return (hcs_$chname_file); 130 MAKE_ENTRY_LABEL (12): /** dm_file */ 131 132 return (file_manager_$chname_file); 133 MAKE_ENTRY_LABEL (13): /** link */ 134 135 return (hcs_$chname_file); 136 MAKE_ENTRY_LABEL (14): /** msf */ 137 138 return (hcs_$chname_file); /* happens to work! */ 139 MAKE_ENTRY_LABEL (15): /** segment */ 140 141 return (hcs_$chname_file); 142 143 /**** COPY */ 144 145 MAKE_ENTRY_LABEL (16): /** directory */ 146 147 Code = error_table_$unsupported_operation; 148 return (null_entry_); 149 MAKE_ENTRY_LABEL (17): /** dm_file */ 150 151 return (file_manager_$copy); 152 MAKE_ENTRY_LABEL (18): /** link */ 153 154 Code = error_table_$unsupported_operation; 155 return (null_entry_); 156 MAKE_ENTRY_LABEL (19): /** msf */ 157 158 return (fs_copy_util_$msf); 159 MAKE_ENTRY_LABEL (20): /** segment */ 160 161 return (fs_copy_util_$segment); 162 163 /**** DELENTRY_FILE -- this is a primitive interface for delete_ */ 164 165 MAKE_ENTRY_LABEL (21): /** directory */ 166 167 Code = error_table_$unsupported_operation; /* use delete_ */ 168 return (null_entry_); 169 MAKE_ENTRY_LABEL (22): /** dm_file */ 170 171 return (file_manager_$delentry_file); 172 MAKE_ENTRY_LABEL (23): /** link */ 173 174 return (hcs_$delentry_file); 175 MAKE_ENTRY_LABEL (24): /** msf */ 176 177 Code = error_table_$unsupported_operation; 178 return (null_entry_); 179 MAKE_ENTRY_LABEL (25): /** segment */ 180 181 return (hcs_$delentry_file); 182 183 /**** DELETE_ACL_ENTRIES */ 184 185 MAKE_ENTRY_LABEL (26): /** directory */ 186 187 return (fs_acl_util_$delete_directory); 188 MAKE_ENTRY_LABEL (27): /** dm_file */ 189 190 return (file_manager_$delete_acl_entries); 191 MAKE_ENTRY_LABEL (28): /** link */ 192 193 Code = error_table_$unsupported_operation; 194 return (null_entry_); 195 MAKE_ENTRY_LABEL (29): /** msf */ 196 197 return (fs_acl_util_$delete_msf); 198 MAKE_ENTRY_LABEL (30): /** segment */ 199 200 return (fs_acl_util_$delete_segment); 201 202 /**** * GET_BIT_COUNT */ 203 204 MAKE_ENTRY_LABEL (31): /** dir */ 205 206 return (get_bc_seg_or_dir); 207 MAKE_ENTRY_LABEL (32): /** dm_file */ 208 209 return (file_manager_$get_bit_count); 210 MAKE_ENTRY_LABEL (33): /** link */ 211 212 Code = error_table_$unsupported_operation; 213 return (null_entry_); 214 MAKE_ENTRY_LABEL (34): /** msf */ 215 216 Code = error_table_$unsupported_operation; 217 return (null_entry_); 218 MAKE_ENTRY_LABEL (35): /** segment */ 219 220 return (get_bc_seg_or_dir); 221 /**** GET_MAX_LENGTH_FILE */ 222 223 MAKE_ENTRY_LABEL (36): /** directory */ 224 225 Code = error_table_$unsupported_operation; 226 return (null_entry_); 227 MAKE_ENTRY_LABEL (37): /** dm_file */ 228 229 return (file_manager_$get_max_length); 230 MAKE_ENTRY_LABEL (38): /** link */ 231 232 Code = error_table_$unsupported_operation; 233 return (null_entry_); 234 MAKE_ENTRY_LABEL (39): /** msf */ 235 236 Code = error_table_$unsupported_operation; 237 return (null_entry_); 238 MAKE_ENTRY_LABEL (40): /** segment */ 239 240 return (hcs_$get_max_length); 241 242 /**** GET_RING_BRACKETS */ 243 244 MAKE_ENTRY_LABEL (41): /** directory */ 245 246 return (get_directory_ring_brackets); 247 248 MAKE_ENTRY_LABEL (42): /** dm_file */ 249 250 return (file_manager_$get_ring_brackets); 251 252 MAKE_ENTRY_LABEL (43): /** link */ 253 254 Code = error_table_$unsupported_operation; 255 return (null_entry_); 256 MAKE_ENTRY_LABEL (44): /** msf */ 257 258 return (fs_msf_rb_util_$get); 259 260 MAKE_ENTRY_LABEL (45): /** segment */ 261 262 return (get_segment_ring_brackets); 263 264 265 /**** GET_SWITCH */ 266 267 MAKE_ENTRY_LABEL (46): /** directory */ 268 269 return (get_directory_switch); 270 MAKE_ENTRY_LABEL (47): /** dm_file */ 271 272 return (file_manager_$get_switch); 273 MAKE_ENTRY_LABEL (48): /** link */ 274 275 Code = error_table_$unsupported_operation; 276 return (null_entry_); 277 MAKE_ENTRY_LABEL (49): /** msf */ 278 279 return (get_msf_switch); 280 MAKE_ENTRY_LABEL (50): /** segment */ 281 282 return (get_segment_switch); 283 284 285 /**** GET_USER_ACCESS_MODES */ 286 287 MAKE_ENTRY_LABEL (51): /** directory */ 288 289 return (hcs_$get_user_access_modes); 290 MAKE_ENTRY_LABEL (52): /** dm_file */ 291 292 return (file_manager_$get_user_access_modes); 293 MAKE_ENTRY_LABEL (53): /** link */ 294 295 Code = error_table_$unsupported_operation; 296 return (null_entry_); 297 MAKE_ENTRY_LABEL (54): /** msf */ 298 299 return (msf_get_user_access_modes); 300 MAKE_ENTRY_LABEL (55): /** segment */ 301 302 return (hcs_$get_user_access_modes); 303 304 /**** LIST_ACL */ 305 306 MAKE_ENTRY_LABEL (56): /** directory */ 307 308 return (fs_acl_util_$list_directory); 309 MAKE_ENTRY_LABEL (57): /** dm_file */ 310 311 return (file_manager_$list_acl); 312 MAKE_ENTRY_LABEL (58): /** link */ 313 314 Code = error_table_$unsupported_operation; 315 return (null_entry_); 316 MAKE_ENTRY_LABEL (59): /** msf */ 317 318 return (fs_acl_util_$list_msf); 319 MAKE_ENTRY_LABEL (60): /** segment */ 320 321 return (fs_acl_util_$list_segment); 322 323 /**** LIST_EXTENDED_ACL */ 324 325 MAKE_ENTRY_LABEL (61): /** directory */ 326 327 Code = error_table_$unsupported_operation; 328 return (null_entry_); 329 MAKE_ENTRY_LABEL (62): /** dm_file */ 330 331 return (file_manager_$list_extended_acl); 332 MAKE_ENTRY_LABEL (63): /** link */ 333 334 Code = error_table_$unsupported_operation; 335 return (null_entry_); 336 MAKE_ENTRY_LABEL (64): /** msf */ 337 338 return (fs_acl_util_$list_msf_extended); 339 MAKE_ENTRY_LABEL (65): /** segment */ 340 341 return (fs_acl_util_$list_segment_extended); 342 343 /**** LIST_SWITCHES */ 344 345 MAKE_ENTRY_LABEL (66): /** directory */ 346 347 return (list_directory_switches); 348 MAKE_ENTRY_LABEL (67): /** dm_file */ 349 350 return (file_manager_$list_switches); 351 MAKE_ENTRY_LABEL (68): /** link */ 352 353 Code = error_table_$unsupported_operation; 354 return (null_entry_); 355 MAKE_ENTRY_LABEL (69): /** msf */ 356 357 return (list_msf_switches); 358 MAKE_ENTRY_LABEL (70): /** segments */ 359 360 return (list_segment_switches); 361 362 /**** REPLACE_ACL */ 363 364 MAKE_ENTRY_LABEL (71): /** directory */ 365 366 return (fs_acl_util_$replace_directory); 367 MAKE_ENTRY_LABEL (72): /** dm_file */ 368 369 return (file_manager_$replace_acl); 370 MAKE_ENTRY_LABEL (73): /** link */ 371 372 Code = error_table_$unsupported_operation; 373 return (null_entry_); 374 MAKE_ENTRY_LABEL (74): /** msf */ 375 376 return (fs_acl_util_$replace_msf); 377 MAKE_ENTRY_LABEL (75): /** segment */ 378 379 return (fs_acl_util_$replace_segment); 380 381 /**** REPLACE_EXTENDED_ACL */ 382 383 MAKE_ENTRY_LABEL (76): /** directory */ 384 385 Code = error_table_$unsupported_operation; 386 return (null_entry_); 387 MAKE_ENTRY_LABEL (77): /** dm_file */ 388 389 return (file_manager_$replace_extended_acl); 390 MAKE_ENTRY_LABEL (78): /** link */ 391 392 Code = error_table_$unsupported_operation; 393 return (null_entry_); 394 MAKE_ENTRY_LABEL (79): /** msf */ 395 396 return (fs_acl_util_$replace_msf_extended); 397 MAKE_ENTRY_LABEL (80): /** segment */ 398 399 return (fs_acl_util_$replace_segment_extended); 400 401 /**** SET_BIT_COUNT */ 402 403 MAKE_ENTRY_LABEL (81): /** directory */ 404 405 return (hcs_$set_bc); 406 MAKE_ENTRY_LABEL (82): /** dm_file */ 407 408 return (file_manager_$set_bit_count); 409 MAKE_ENTRY_LABEL (83): /** link */ 410 411 Code = error_table_$unsupported_operation; 412 return (null_entry_); 413 MAKE_ENTRY_LABEL (84): /** msf */ 414 415 return (hcs_$set_bc); 416 MAKE_ENTRY_LABEL (85): /** segment */ 417 418 return (hcs_$set_bc); 419 420 /**** SET_MAX_LENGTH */ 421 422 MAKE_ENTRY_LABEL (86): /* directory */ 423 424 Code = error_table_$unsupported_operation; 425 return (null_entry_); 426 MAKE_ENTRY_LABEL (87): /** dm_file */ 427 428 return (file_manager_$set_max_length); 429 MAKE_ENTRY_LABEL (88): /** link */ 430 431 Code = error_table_$unsupported_operation; 432 return (null_entry_); 433 MAKE_ENTRY_LABEL (89): /** msf */ 434 435 Code = error_table_$unsupported_operation; 436 return (null_entry_); 437 MAKE_ENTRY_LABEL (90): /** segment */ 438 439 return (hcs_$set_max_length); 440 441 /**** SET_RING_BRACKETS */ 442 443 MAKE_ENTRY_LABEL (91): /** directory */ 444 445 return (set_directory_ring_brackets); 446 MAKE_ENTRY_LABEL (92): /** dm_file */ 447 448 return (file_manager_$set_ring_brackets); 449 MAKE_ENTRY_LABEL (93): /** link */ 450 451 Code = error_table_$unsupported_operation; 452 return (null_entry_); 453 MAKE_ENTRY_LABEL (94): /** msf */ 454 455 return (fs_msf_rb_util_$set); 456 MAKE_ENTRY_LABEL (95): /** segment */ 457 458 return (set_segment_ring_brackets); 459 460 /**** SET_SWITCH */ 461 462 MAKE_ENTRY_LABEL (96): /** directory */ 463 464 return (set_directory_switch); 465 MAKE_ENTRY_LABEL (97): /** dm_file */ 466 467 return (file_manager_$set_switch); 468 MAKE_ENTRY_LABEL (98): /** link */ 469 470 Code = error_table_$unsupported_operation; 471 return (null_entry_); 472 MAKE_ENTRY_LABEL (99): /** msf */ 473 474 return (set_msf_switch); 475 MAKE_ENTRY_LABEL (100): /** segment */ 476 477 return (set_segment_switch); 478 479 /**** SUFFIX_INFO */ 480 481 MAKE_ENTRY_LABEL (101): /** directory */ 482 483 return (directory_suffix_info); 484 MAKE_ENTRY_LABEL (102): /** dm_file */ 485 486 return (file_manager_$suffix_info); 487 MAKE_ENTRY_LABEL (103): /** link */ 488 489 Code = error_table_$unsupported_operation; 490 return (null_entry_); 491 MAKE_ENTRY_LABEL (104): /** msf */ 492 493 return (msf_suffix_info); 494 MAKE_ENTRY_LABEL (105): /** segment */ 495 496 return (segment_suffix_info); 497 498 499 /**** VALIDATE */ 500 501 MAKE_ENTRY_LABEL (106): /** directory */ 502 503 return (directory_validate); 504 MAKE_ENTRY_LABEL (107): /** dm_file */ 505 506 return (dm_file_validate); 507 MAKE_ENTRY_LABEL (108): /** link */ 508 509 return (link_validate); 510 MAKE_ENTRY_LABEL (109): /** msf */ 511 512 return (msf_validate); 513 MAKE_ENTRY_LABEL (110): /** segment */ 514 515 return (segment_validate); 516 517 518 /**** 519* What follows here are the entrypoints that translate from 520* hcs_ to the standard object_type_ interfaces for things except for acls. */ 521 522 get_directory_ring_brackets: 523 entry (Dir_name, Entryname, Rings, Code); 524 525 declare Rings (*) fixed bin (3); 526 Rings = 0; 527 begin; 528 declare dir_rings (2) fixed bin (3) based (addr (Rings)); 529 declare hcs_$get_dir_ring_brackets 530 entry (char (*), char (*), (2) fixed bin (3), fixed bin (35)); 531 call hcs_$get_dir_ring_brackets (Dir_name, Entryname, dir_rings, Code); 532 end; 533 return; 534 535 536 get_segment_ring_brackets: 537 entry (Dir_name, Entryname, Rings, Code); 538 539 declare Dir_name char (*) parameter; 540 declare Entryname char (*) parameter; 541 542 begin; 543 declare seg_rings (3) fixed bin (3) based (addr (Rings)); 544 declare hcs_$get_ring_brackets entry (char (*), char (*), (3) fixed bin (3), fixed bin (35)); 545 546 call hcs_$get_ring_brackets (Dir_name, Entryname, seg_rings, Code); 547 end; 548 return; 549 550 551 get_directory_switch: 552 entry (Dir_name, Entryname, Switch_name, Switch_value, Code); 553 554 declare Switch_name char (*) parameter; 555 declare Switch_value bit (1) aligned; 556 declare switch_name char (100); 557 declare switch_value bit (1); 558 559 switch_name = Switch_name; 560 561 Code = 0; 562 call GET_DIR_SWITCH; 563 564 return; 565 566 get_segment_switch: 567 entry (Dir_name, Entryname, Switch_name, Switch_value, Code); 568 569 Code = 0; 570 switch_name = Switch_name; 571 call GET_SEG_SWITCH; 572 return; 573 574 set_directory_switch: 575 entry (Dir_name, Entryname, Switch_name, Switch_value, Code); 576 577 switch_name = Switch_name; 578 Code = 0; 579 580 call SET_DIR_SWITCH; 581 return; 582 583 set_segment_switch: 584 entry (Dir_name, Entryname, Switch_name, Switch_value, Code); 585 586 switch_name = Switch_name; 587 Code = 0; 588 589 call SET_SEG_SWITCH; 590 return; 591 592 set_msf_switch: 593 entry (Dir_name, Entryname, Switch_name, Switch_value, Code); 594 595 switch_name = Switch_name; 596 Code = 0; 597 598 call SET_MSF_SWITCH; 599 return; 600 601 get_msf_switch: 602 entry (Dir_name, Entryname, Switch_name, Switch_value, Code); 603 604 switch_name = Switch_name; 605 Code = 0; 606 607 call GET_MSF_SWITCH; 608 return; 609 610 611 612 GET_DIR_SWITCH: 613 procedure; 614 615 declare type fixed bin; 616 declare hcs_type fixed bin (2); 617 declare ( 618 SEG init (1), 619 DIR init (2), 620 MSF init (3) 621 ) fixed bin int static options (constant); 622 declare 1 sfb aligned like status_for_backup; 623 declare 1 sb aligned like status_branch; 624 declare (nivd, ncvd) fixed bin; 625 626 type = DIR; 627 go to Join; 628 629 GET_SEG_SWITCH: 630 entry; 631 632 type = SEG; 633 go to Join; 634 635 GET_MSF_SWITCH: 636 entry; 637 638 type = MSF; 639 640 Join: 641 if switch_name = "safety" 642 then do; 643 call hcs_$get_safety_sw (Dir_name, Entryname, switch_value, Code); 644 Switch_value = switch_value; 645 end; 646 647 else if switch_name = "audit" 648 then do; 649 sfb.version = status_for_backup_version_2; 650 call hcs_$status_for_backup (Dir_name, Entryname, addr (sfb), Code); 651 if Code = 0 652 then Switch_value = sfb.audit_flag; 653 end; 654 655 else if switch_name = "complete_volume_dump" | switch_name = "incremental_volume_dump" 656 then do; 657 if type = MSF 658 then do; 659 call hcs_$get_volume_dump_switches (pathname_ (Dir_name, Entryname), "0", nivd, ncvd, Code); 660 if Code = error_table_$noentry 661 then Code = error_table_$inconsistent_msf; 662 end; 663 else call hcs_$get_volume_dump_switches (Dir_name, Entryname, nivd, ncvd, Code); 664 if Code = 0 665 then do; 666 if switch_name = "complete_volume_dump" 667 then Switch_value = (ncvd < 0); 668 /* on if no_complete_vd is off */ 669 else Switch_value = (nivd < 0); 670 end; 671 end; 672 673 else if ((type = SEG) & (switch_name = "copy" | switch_name = "synchronized")) | switch_name = "damaged" 674 then do; 675 call hcs_$status_long (Dir_name, Entryname, 1, addr (sb), null (), Code); 676 if Code = 0 677 then do; 678 if switch_name = "copy" 679 then Switch_value = sb.copy_switch; 680 else if switch_name = "damaged" 681 then Switch_value = sb.damaged_switch; 682 else Switch_value = sb.synchronized_switch; 683 end; 684 end; 685 else Code = error_table_$argerr; /* We don't know this one. */ 686 687 return; 688 689 SET_DIR_SWITCH: 690 entry; 691 692 type = DIR; 693 go to Join_set; 694 695 SET_SEG_SWITCH: 696 entry; 697 698 type = SEG; 699 go to Join_set; 700 701 SET_MSF_SWITCH: 702 entry; 703 704 call hcs_$status_minf (Dir_name, Entryname, (1), hcs_type, (0), Code); 705 if Code ^= 0 706 then return; 707 if hcs_type = 2 708 /*** Dir */ 709 then type = MSF; 710 else type = SEG; 711 /*** treat SSF MSF as Segment */ 712 713 Join_set: 714 if switch_name = "safety" 715 then call hcs_$set_safety_sw (Dir_name, Entryname, (Switch_value), Code); 716 717 else if switch_name = "complete_volume_dump" & (type = MSF) 718 then ; /* do not try to set the switch on the MSF dir, but set it on the components */ 719 else if switch_name = "complete_volume_dump" 720 then do; /*** Note that the volume dumper entrypoint works like this: 721* a value of zero means, "don't change switch." 722* A value of 1 means "Set the switch," and a value of -1 means 723* "reset the switch." However, we are translating from a switch named 724* complete_volume_dump to no_complete_volume_dump, so we reverse the 725* values from the Switch_value to the flags. */ 726 if Switch_value 727 then ncvd = -1; 728 else ncvd = 1; 729 call hcs_$set_volume_dump_switches (Dir_name, Entryname, 0, ncvd, Code); 730 end; 731 else if switch_name = "incremental_volume_dump" & (type = MSF) 732 then ; /* ditto */ 733 else if switch_name = "incremental_volume_dump" 734 then do; 735 nivd, ncvd = 0; 736 if Switch_value 737 then nivd = -1; 738 else nivd = 1; 739 call hcs_$set_volume_dump_switches (Dir_name, Entryname, nivd, 0, Code); 740 end; 741 742 else if switch_name = "copy" & (type = SEG | type = DIR) 743 then call hcs_$set_copysw (Dir_name, Entryname, fixed (Switch_value, 1), Code); 744 else if switch_name = "damaged" 745 then call hcs_$set_damaged_sw (Dir_name, Entryname, (Switch_value), Code); 746 else if switch_name = "synchronized" & (type = SEG) 747 then call hcs_$set_synchronized_sw (Dir_name, Entryname, (Switch_value), Code); 748 749 else Code = error_table_$argerr; /* We don't know this one. */ 750 751 if type = MSF & Code = 0 752 then call MAP_OVER_MSF_COMPONENTS (pathname_ (Dir_name, Entryname), switch_name, Switch_value, Code); 753 return; 754 755 756 MAP_OVER_MSF_COMPONENTS: 757 procedure (dir_name, switch_name, switch_value, code); 758 759 declare dir_name char (*); 760 declare switch_name char (*); 761 declare switch_value bit (1) aligned; 762 declare code fixed bin (35); 763 declare entry_index fixed bin; 764 declare get_system_free_area_ entry () returns (ptr); 765 declare hcs_$star_ entry (char (*), char (*), fixed bin (2), ptr, fixed bin, ptr, ptr, 766 fixed bin (35)); 767 768 declare cleanup condition; 1 1 /* BEGIN INCLUDE FILE . . . star_structures.incl.pl1 */ 1 2 1 3 /* This include file contains structures for the hcs_$star_, 1 4* hcs_$star_list_ and hcs_$star_dir_list_ entry points. 1 5* 1 6* Written 23 October 1978 by Monte Davidoff. 1 7* Modified January 1979 by Michael R. Jordan to use unsigned and different pointers for different structures. 1 8* Modified June 1981 by C. Hornig to count link pathnames more efficiently. 1 9**/ 1 10 1 11 /* automatic */ 1 12 1 13 declare star_branch_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching branch count */ 1 14 declare star_entry_count fixed binary; /* hcs_$star_: number of matching entries */ 1 15 declare star_entry_ptr pointer; /* hcs_$star_: pointer to array of entry information */ 1 16 declare star_list_branch_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to array of info */ 1 17 declare star_link_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching link count */ 1 18 declare star_linkx fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: index into star_links */ 1 19 declare star_names_ptr pointer; /* hcs_$star_: pointer to array of entry names */ 1 20 declare star_list_names_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to entry names */ 1 21 declare star_select_sw fixed binary (3); /* hcs_$star_list_, hcs_$star_dir_list_: what info to return */ 1 22 1 23 /* based */ 1 24 1 25 /* hcs_$star_ entry structure */ 1 26 1 27 declare 1 star_entries (star_entry_count) aligned based (star_entry_ptr), 1 28 2 type fixed binary (2) unsigned unaligned, 1 29 /* storage system type */ 1 30 2 nnames fixed binary (16) unsigned unaligned, 1 31 /* number of names of entry that match star_name */ 1 32 2 nindex fixed binary (18) unsigned unaligned; 1 33 /* index of first name in star_names */ 1 34 1 35 /* hcs_$star_ name structure */ 1 36 1 37 declare star_names (sum (star_entries (*).nnames)) char (32) based (star_names_ptr); 1 38 1 39 /* hcs_$star_list_ branch structure */ 1 40 1 41 declare 1 star_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 1 42 2 type fixed binary (2) unsigned unaligned, 1 43 /* storage system type */ 1 44 2 nnames fixed binary (16) unsigned unaligned, 1 45 /* number of names of entry that match star_name */ 1 46 2 nindex fixed binary (18) unsigned unaligned, 1 47 /* index of first name in star_list_names */ 1 48 2 dtcm bit (36) unaligned, /* date-time contents of branch were last modified */ 1 49 2 dtu bit (36) unaligned, /* date-time branch was last used */ 1 50 2 mode bit (5) unaligned, /* user's access mode to the branch */ 1 51 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 1 52 2 master_dir bit (1) unaligned, /* is branch a master directory */ 1 53 2 pad bit (7) unaligned, 1 54 2 records fixed binary (18) unsigned unaligned; 1 55 /* records used by branch */ 1 56 1 57 /* hcs_$star_dir_list_ branch structure */ 1 58 1 59 declare 1 star_dir_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 1 60 2 type fixed binary (2) unsigned unaligned, 1 61 /* storage system type */ 1 62 2 nnames fixed binary (16) unsigned unaligned, 1 63 /* number of names of entry that match star_name */ 1 64 2 nindex fixed binary (18) unsigned unaligned, 1 65 /* index of first name in star_list_names */ 1 66 2 dtem bit (36) unaligned, /* date-time directory entry of branch was last modified */ 1 67 2 pad bit (36) unaligned, 1 68 2 mode bit (5) unaligned, /* user's access mode to the branch */ 1 69 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 1 70 2 master_dir bit (1) unaligned, /* is branch a master directory */ 1 71 2 bit_count fixed binary (24) unaligned; 1 72 /* bit count of the branch */ 1 73 1 74 /* hcs_$star_list_ and hcs_$star_dir_list_ link structure */ 1 75 1 76 declare 1 star_links (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 1 77 2 type fixed binary (2) unsigned unaligned, 1 78 /* storage system type */ 1 79 2 nnames fixed binary (16) unsigned unaligned, 1 80 /* number of names of entry that match star_name */ 1 81 2 nindex fixed binary (18) unsigned unaligned, 1 82 /* index of first name in star_list_names */ 1 83 2 dtem bit (36) unaligned, /* date-time link was last modified */ 1 84 2 dtd bit (36) unaligned, /* date-time the link was last dumped */ 1 85 2 pathname_len fixed binary (18) unsigned unaligned, 1 86 /* length of the pathname of the link */ 1 87 2 pathname_index fixed binary (18) unsigned unaligned; 1 88 /* index of start of pathname in star_list_names */ 1 89 1 90 /* hcs_$star_list_ and hcs_$star_dir_list_ name array */ 1 91 1 92 declare star_list_names char (32) based (star_list_names_ptr) 1 93 dimension (star_links (star_branch_count + star_link_count).nindex 1 94 + star_links (star_branch_count + star_link_count).nnames 1 95 + divide (star_links (star_branch_count + star_link_count).pathname_len + 31, 32, 17, 0) 1 96 * binary ( 1 97 (star_links (star_branch_count + star_link_count).type = star_LINK) 1 98 & (star_select_sw >= star_LINKS_ONLY_WITH_LINK_PATHS), 1)); 1 99 1 100 /* hcs_$star_list_ and hcs_$star_dir_list_ link pathname */ 1 101 1 102 declare star_link_pathname char (star_links (star_linkx).pathname_len) 1 103 based (addr (star_list_names (star_links (star_linkx).pathname_index))); 1 104 1 105 /* internal static */ 1 106 1 107 /* star_select_sw values */ 1 108 1 109 declare star_LINKS_ONLY fixed binary (2) internal static options (constant) initial (1); 1 110 declare star_BRANCHES_ONLY fixed binary (2) internal static options (constant) initial (2); 1 111 declare star_ALL_ENTRIES fixed binary (2) internal static options (constant) initial (3); 1 112 declare star_LINKS_ONLY_WITH_LINK_PATHS 1 113 fixed binary (3) internal static options (constant) initial (5); 1 114 declare star_ALL_ENTRIES_WITH_LINK_PATHS 1 115 fixed binary (3) internal static options (constant) initial (7); 1 116 1 117 /* storage system types */ 1 118 1 119 declare star_LINK fixed binary (2) unsigned internal static options (constant) initial (0); 1 120 declare star_SEGMENT fixed binary (2) unsigned internal static options (constant) initial (1); 1 121 declare star_DIRECTORY fixed binary (2) unsigned internal static options (constant) initial (2); 1 122 1 123 /* END INCLUDE FILE . . . star_structures.incl.pl1 */ 769 770 771 star_entry_ptr, star_names_ptr = null (); 772 on cleanup 773 begin; 774 if star_names_ptr ^= null () 775 then do; 776 free star_names; 777 star_names_ptr = null (); 778 end; 779 if star_entry_ptr ^= null () 780 then do; 781 free star_entries; 782 star_entry_ptr = null (); 783 end; 784 end; 785 786 call hcs_$star_ (dir_name, "**", star_BRANCHES_ONLY, get_system_free_area_ (), star_entry_count, star_entry_ptr, 787 star_names_ptr, code); 788 if code ^= 0 789 then return; 790 791 do entry_index = 1 to star_entry_count; 792 if star_entries (entry_index).type = star_SEGMENT 793 then call set_segment_switch (dir_name, star_names (star_entries (entry_index).nindex), switch_name, 794 switch_value, (0)); /* ignore errors */ 795 /* recurse ! */ 796 end; 797 free star_names; 798 free star_entries; 799 return; 800 end MAP_OVER_MSF_COMPONENTS; 801 end GET_DIR_SWITCH; 802 803 804 805 list_directory_switches: 806 entry (Desired_version, Area_ptr, Switch_list_ptr, Code); 807 808 declare (Area_ptr, Switch_list_ptr) 809 pointer parameter; 810 declare Desired_version char (*); 811 declare area_ptr pointer; 812 declare user_area area based (area_ptr); 813 declare switch_list_type fixed bin; 814 declare ( 815 SEG init (1), 816 DIR init (2), 817 MSF init (3) 818 ) fixed bin int static options (constant); 819 820 switch_list_type = DIR; 821 go to SWITCH_LIST_JOIN; 822 823 list_segment_switches: 824 entry (Desired_version, Area_ptr, Switch_list_ptr, Code); 825 826 switch_list_type = SEG; 827 go to SWITCH_LIST_JOIN; 828 829 list_msf_switches: 830 entry (Desired_version, Area_ptr, Switch_list_ptr, Code); 831 832 switch_list_type = MSF; 833 834 SWITCH_LIST_JOIN: 835 area_ptr = Area_ptr; 836 if Desired_version ^= SWITCH_LIST_VERSION_1 837 then do; 838 Code = error_table_$unimplemented_version; 839 return; 840 end; 841 842 if (switch_list_type = DIR) | (switch_list_type = MSF) 843 then do; 844 alloc_switch_count = 4; 845 alloc_switch_name_count = 6; 846 end; 847 else do; 848 alloc_switch_count = 6; 849 alloc_switch_name_count = 8; 850 end; 851 852 allocate switch_list in (user_area); 853 854 switch_list.version = SWITCH_LIST_VERSION_1; 855 switch_list.switches (1).name_index = 1; 856 switch_list.switches (1).name_count = 1; 857 switch_list.switches (1).default_value = "0"b; 858 859 switch_list.switches (2).name_index = 2; 860 switch_list.switches (2).name_count = 1; 861 switch_list.switches (2).default_value = "0"b; 862 863 switch_list.switches (3).name_index = 3; 864 switch_list.switches (3).name_count = 2; 865 switch_list.switches (3).default_value = "0"b; 866 867 switch_list.switches (4).name_index = 5; 868 switch_list.switches (4).name_count = 2; 869 switch_list.switches (4).default_value = "0"b; 870 871 if switch_list_type = SEG 872 then do; 873 switch_list.switches (5).name_index = 7; 874 switch_list.switches (5).name_count = 1; 875 switch_list.switches (5).default_value = "0"b; 876 877 switch_list.switches (6).name_index = 8; 878 switch_list.switches (6).name_count = 1; 879 switch_list.switches (6).default_value = "0"b; 880 end; 881 882 switch_list.names (1) = "damaged"; 883 switch_list.names (2) = "safety"; 884 switch_list.names (3) = "complete_volume_dump"; 885 switch_list.names (4) = "cvd"; 886 switch_list.names (5) = "incremental_volume_dump"; 887 switch_list.names (6) = "ivd"; 888 if switch_list_type = SEG 889 then do; 890 switch_list.names (7) = "copy"; 891 switch_list.names (8) = "synchronized"; 892 end; 893 894 Switch_list_ptr = switch_list_ptr; 895 return; 896 897 898 899 900 set_directory_ring_brackets: 901 entry (Dir_name, Entryname, Rings, Code); 902 903 begin; 904 declare dir_rings (2) fixed bin (3) based (addr (Rings)); 905 declare hcs_$set_dir_ring_brackets 906 entry (char (*), char (*), (2) fixed bin (3), fixed bin (35)); 907 call hcs_$set_dir_ring_brackets (Dir_name, Entryname, dir_rings, Code); 908 end; 909 return; 910 911 set_segment_ring_brackets: 912 entry (Dir_name, Entryname, Rings, Code); 913 914 begin; 915 declare seg_rings (3) fixed bin (3) based (addr (Rings)); 916 declare hcs_$set_ring_brackets entry (char (*), char (*), (3) fixed bin (3), fixed bin (35)); 917 918 call hcs_$set_ring_brackets (Dir_name, Entryname, seg_rings, Code); 919 end; 920 return; 921 922 923 directory_suffix_info: 924 entry (Suffix_info_ptr); 925 926 declare Suffix_info_ptr pointer; 927 928 suffix_info_ptr = Suffix_info_ptr; 929 suffix_info.type = FS_OBJECT_TYPE_DIRECTORY; 930 suffix_info.type_name = "directory"; 931 suffix_info.plural_name = "directories"; 932 suffix_info.flags = "0"b; 933 suffix_info.standard_object = "1"b; 934 suffix_info.has_switches = "1"b; 935 suffix_info.modes = "sma"; 936 suffix_info.copy_flags = "0"b; 937 suffix_info.copy_flags.names, suffix_info.copy_flags.acl, suffix_info.copy_flags.safety_switch, 938 suffix_info.copy_flags.dumper_switches = "1"b; 939 suffix_info.max_mode_len = 3; 940 suffix_info.num_ring_brackets = 2; 941 suffix_info.info_pathname = ""; /* for now, at least */ 942 return; 943 944 msf_suffix_info: 945 entry (Suffix_info_ptr); 946 947 suffix_info_ptr = Suffix_info_ptr; 948 949 suffix_info.type = FS_OBJECT_TYPE_MSF; 950 suffix_info.type_name = "multi-segment file"; 951 suffix_info.plural_name = "multi-segment files"; 952 suffix_info.flags = "0"b; 953 suffix_info.standard_object = "1"b; 954 suffix_info.extended_acl = "1"b; 955 suffix_info.modes = "rew"; 956 957 suffix_info.max_mode_len = 3; 958 suffix_info.num_ring_brackets = 2; /* who needs an msf gate? */ 959 suffix_info.copy_flags = "1"b; 960 suffix_info.max_length, suffix_info.entry_bound, suffix_info.copy_switch, suffix_info.copy_flags.mbz = ""b; 961 suffix_info.info_pathname = ""; 962 return; 963 964 segment_suffix_info: 965 entry (Suffix_info_ptr); 966 967 suffix_info_ptr = Suffix_info_ptr; 968 suffix_info.type = FS_OBJECT_TYPE_SEGMENT; 969 suffix_info.type_name = "segment"; 970 suffix_info.plural_name = "segments"; 971 suffix_info.flags = "0"b; 972 suffix_info.standard_object = "1"b; 973 suffix_info.has_switches = "1"b; 974 suffix_info.extended_acl = "1"b; 975 suffix_info.modes = "rew"; 976 suffix_info.copy_flags = "1"b; 977 suffix_info.copy_flags.mbz = "0"b; 978 suffix_info.max_mode_len = 3; 979 suffix_info.num_ring_brackets = 3; 980 suffix_info.info_pathname = ""; /* for now, at least */ 981 return; 982 983 984 985 directory_validate: 986 entry (Dir_name, Entryname, Code); 987 declare type char (32); 988 989 call fs_get_type_ (Dir_name, Entryname, type, Code); 990 if Code ^= 0 991 then return; 992 if type ^= FS_OBJECT_TYPE_DIRECTORY 993 then Code = error_table_$not_seg_type; 994 return; 995 996 segment_validate: 997 entry (Dir_name, Entryname, Code); 998 999 call fs_get_type_ (Dir_name, Entryname, type, Code); 1000 if Code ^= 0 1001 then return; 1002 if type ^= FS_OBJECT_TYPE_SEGMENT 1003 then Code = error_table_$not_seg_type; 1004 return; 1005 1006 link_validate: 1007 entry (Dir_name, Entryname, Code); 1008 1009 call fs_get_type_ (Dir_name, Entryname, type, Code); 1010 if Code ^= 0 1011 then return; 1012 if type ^= FS_OBJECT_TYPE_LINK 1013 then Code = error_table_$not_seg_type; 1014 return; 1015 1016 msf_validate: 1017 entry (Dir_name, Entryname, Code); 1018 1019 call fs_get_type_ (Dir_name, Entryname, type, Code); 1020 if Code ^= 0 1021 then return; 1022 1023 if type ^= FS_OBJECT_TYPE_MSF 1024 then Code = error_table_$not_seg_type; 1025 1026 return; 1027 1028 dm_file_validate: 1029 entry (Dir_name, Entryname, Code); 1030 1031 call fs_get_type_ (Dir_name, Entryname, type, Code); 1032 if Code ^= 0 1033 then return; 1034 1035 if type ^= FS_OBJECT_TYPE_DM_FILE 1036 then Code = error_table_$not_seg_type; 1037 return; 1038 1039 msf_get_user_access_modes: 1040 entry (Dir_name, Entryname, Username, Ring, Modes, Exmodes, Code); 1041 1042 declare Username char (*); 1043 declare Ring fixed bin (3); 1044 declare (Modes, Exmodes) bit (36) aligned; 1045 1046 call hcs_$get_user_access_modes (pathname_ (Dir_name, Entryname), "0", Username, Ring, Modes, Exmodes, Code); 1047 1048 if Code = error_table_$noentry 1049 then Code = error_table_$inconsistent_msf; 1050 else do; 1051 if Code = error_table_$notadir /* special-case SSF's */ 1052 then call hcs_$get_user_access_modes (Dir_name, Entryname, Username, Ring, Modes, Exmodes, Code); 1053 if Code = error_table_$incorrect_access /* null to the dir */ 1054 then do; 1055 Modes, Exmodes = ""b; 1056 Code = 0; 1057 return; 1058 end; 1059 end; 1060 1061 return; 1062 1063 1064 get_bc_seg_or_dir: 1065 entry (Dir_name, Entryname, Bit_count, Code); 1066 1067 declare Bit_count fixed bin (24); 1068 1069 call hcs_$status_minf (Dir_name, Entryname, (1), (0), Bit_count, Code); 1070 return; 1071 1072 2 1 /* BEGIN INCLUDE FILE: suffix_info.incl.pl1 */ 2 2 /* format: style3,indcomtxt,idind30 */ 2 3 /**** Jay Pattin 2/13/83 2 4* M. Pandolf 1984.11.30 to set FS_OBJECT_TYPE_MSF to -multisegment_file 2 5* 2 6* The include file copy_flags.incl.pl1 must be included in any program using this include file. 2 7* 2 8* This structure is returned by the suffix_XXX_$suffix_info subroutines */ 2 9 2 10 declare suffix_info_ptr ptr; 2 11 2 12 declare 1 suffix_info aligned based (suffix_info_ptr), 2 13 2 version char (8), 2 14 2 type char (32) unaligned, 2 15 2 type_name char (32) unaligned, /* Singular name of the object type, e.g. "mailbox" */ 2 16 2 plural_name char (32) unaligned, /* Plural of above, e.g. "mailboxes" */ 2 17 2 flags unaligned, 2 18 3 standard_object bit (1) unaligned, /* ON if not an extended object (no suffix_XXX_) */ 2 19 3 extended_acl bit (1) unaligned, /* ON if uses extended ACLs, off if regular ACLs */ 2 20 3 has_switches bit (1) unaligned, /* ON if supports switches for objects */ 2 21 3 mbz1 bit (33) unaligned, 2 22 2 modes char (36), /* correspondence between bits and chars for extended modes */ 2 23 2 max_mode_len fixed bin, /* maximum number of modes on an object */ 2 24 2 num_ring_brackets fixed bin, /* number of ring brackets on object */ 2 25 2 copy_flags like copy_flags, /* See copy_flags.incl.pl1 */ 2 26 2 info_pathname char (168) unaligned; 2 27 /* pathname of info segment containing more info */ 2 28 2 29 declare SUFFIX_INFO_VERSION_1 char (8) static options (constant) init ("SUFFIX01"); 2 30 2 31 /* This information is returned by the suffix_XXX_$list_switches subroutines */ 2 32 2 33 declare switch_list_ptr ptr, 2 34 alloc_switch_count fixed bin, 2 35 alloc_switch_name_count fixed bin; 2 36 2 37 declare 1 switch_list aligned based (switch_list_ptr), 2 38 2 version char (8), /* SWITCH_LIST_VERSION_1 */ 2 39 2 switch_count fixed bin, /* total number of switches */ 2 40 2 switch_name_count fixed bin, /* total number of names */ 2 41 2 switches (alloc_switch_count refer (switch_list.switch_count)), 2 42 3 name_index fixed bin, /* index of first name for this switch */ 2 43 3 name_count fixed bin, /* number of names for this switch */ 2 44 3 default_value bit (1) aligned, /* default setting for this switch */ 2 45 3 mbz1 bit (36) aligned, /* reserved for future use */ 2 46 2 names (alloc_switch_name_count refer (switch_list.switch_name_count)) char (32); 2 47 2 48 declare SWITCH_LIST_VERSION_1 char (8) static options (constant) init ("SWLIST01"); 2 49 2 50 declare ( 2 51 FS_OBJECT_TYPE_SEGMENT init ("-segment"), 2 52 FS_OBJECT_TYPE_DIRECTORY init ("-directory"), 2 53 FS_OBJECT_TYPE_MSF init ("-multisegment_file"), 2 54 FS_OBJECT_TYPE_DM_FILE init ("-dm_file"), 2 55 FS_OBJECT_TYPE_LINK init ("-link") 2 56 ) char (32) unaligned int static options (constant); 2 57 2 58 /* END INCLUDE FILE: suffix_info.incl.pl1 */ 1073 3 1 /* BEGIN INCLUDE FILE: copy_flags.incl.pl1 */ 3 2 3 3 /* Flags for attributes that should/may be copied by the copy_ subroutine. This include file is 3 4* required by suffix_info.incl.pl1 and copy_options.incl.pl1 3 5* 3 6* Jay Pattin 6/23/83 */ 3 7 3 8 declare 1 copy_flags aligned based, /* ON means that this attribute may be copied by copy_ */ 3 9 2 names bit (1) unaligned, 3 10 2 acl bit (1) unaligned, 3 11 2 ring_brackets bit (1) unaligned, 3 12 2 max_length bit (1) unaligned, 3 13 2 copy_switch bit (1) unaligned, 3 14 2 safety_switch bit (1) unaligned, 3 15 2 dumper_switches bit (1) unaligned, 3 16 2 entry_bound bit (1) unaligned, /* only for vanilla object segments */ 3 17 2 extend bit (1) unaligned, /* copy_ may append to end of existing object */ 3 18 2 update bit (1) unaligned, /* copy_ may replace contents of existing object */ 3 19 2 mbz bit (26) unaligned; 3 20 3 21 /* END INCLUDE FILE: copy_flags.incl.pl1 */ 1074 1075 1076 declare ( 1077 addr, 1078 fixed, 1079 null, 1080 sum 1081 ) builtin; 1082 declare ( 1083 error_table_$argerr, 1084 error_table_$unsupported_operation, 1085 error_table_$notadir, 1086 error_table_$not_seg_type, 1087 error_table_$incorrect_access, 1088 error_table_$noentry, 1089 error_table_$inconsistent_msf, 1090 error_table_$unimplemented_version 1091 ) fixed bin (35) external; 1092 1093 declare null_entry_ entry; 1094 1095 declare hcs_$delentry_file entry external; 1096 1097 declare ( 1098 file_manager_$add_acl_entries, 1099 file_manager_$add_extended_acl_entries, 1100 file_manager_$chname_file, 1101 file_manager_$copy, 1102 file_manager_$delentry_file, 1103 file_manager_$delete_acl_entries, 1104 file_manager_$get_bit_count, 1105 file_manager_$get_max_length, 1106 file_manager_$get_ring_brackets, 1107 file_manager_$get_switch, 1108 file_manager_$get_user_access_modes, 1109 file_manager_$list_acl, 1110 file_manager_$list_extended_acl, 1111 file_manager_$replace_acl, 1112 file_manager_$replace_extended_acl, 1113 file_manager_$set_bit_count, 1114 file_manager_$set_max_length, 1115 file_manager_$set_ring_brackets, 1116 file_manager_$set_switch, 1117 file_manager_$suffix_info 1118 ) entry external; 1119 declare ( 1120 fs_msf_rb_util_$set, 1121 fs_msf_rb_util_$get 1122 ) entry external; 1123 declare file_manager_$list_switches 1124 entry (pointer, pointer); 1125 1126 declare ( 1127 fs_acl_util_$add_segment, 1128 fs_acl_util_$add_directory, 1129 fs_acl_util_$add_msf, 1130 fs_acl_util_$delete_segment, 1131 fs_acl_util_$delete_directory, 1132 fs_acl_util_$delete_msf, 1133 fs_acl_util_$list_segment, 1134 fs_acl_util_$list_directory, 1135 fs_acl_util_$list_msf, 1136 fs_acl_util_$replace_segment, 1137 fs_acl_util_$replace_directory, 1138 fs_acl_util_$replace_msf, 1139 fs_acl_util_$list_segment_extended, 1140 fs_acl_util_$add_segment_extended, 1141 fs_acl_util_$replace_segment_extended, 1142 fs_acl_util_$list_msf_extended, 1143 fs_acl_util_$add_msf_extended, 1144 fs_acl_util_$replace_msf_extended 1145 ) entry external; 1146 1147 declare ( 1148 fs_copy_util_$msf, 1149 fs_copy_util_$segment 1150 ) external entry; 1151 1152 declare ( 1153 hcs_$chname_file, 1154 hcs_$set_bc, 1155 hcs_$set_max_length, 1156 hcs_$get_max_length 1157 ) entry external; 1158 declare hcs_$get_user_access_modes 1159 entry (char (*), char (*), char (*), fixed bin (3), bit (36) aligned, 1160 bit (36) aligned, fixed bin (35)); 1161 declare pathname_ entry (char (*), char (*)) returns (char (168)); 1162 1163 declare fs_get_type_ entry (char (*), char (*), char (*), fixed bin (35)); 1164 declare hcs_$get_safety_sw entry (char (*), char (*), bit (1), fixed bin (35)); 1165 declare hcs_$get_volume_dump_switches 1166 entry (char (*), char (*), fixed bin, fixed bin, fixed bin (35)); 1167 declare hcs_$set_safety_sw entry (char (*), char (*), bit (1), fixed bin (35)); 1168 declare hcs_$set_volume_dump_switches 1169 entry (char (*), char (*), fixed bin, fixed bin, fixed bin (35)); 1170 declare hcs_$set_synchronized_sw 1171 entry (char (*), char (*), bit (1), fixed bin (35)); 1172 declare hcs_$set_copysw entry (char (*), char (*), fixed bin (1), fixed bin (35)); 1173 declare hcs_$status_long entry (char (*), char (*), fixed bin (1), ptr, ptr, fixed bin (35)); 1174 declare hcs_$set_damaged_sw entry (char (*), char (*), bit (1), fixed bin (35)); 1175 declare hcs_$status_for_backup entry (char (*), char (*), ptr, fixed bin (35)); 1176 declare hcs_$status_minf entry (char (*), char (*), fixed bin (1), fixed bin (2), fixed bin (24), 1177 1178 fixed bin (35)); 4 1 /* --------------- BEGIN include file status_for_backup.incl.pl1 --------------- */ 4 2 4 3 4 4 /****^ HISTORY COMMENTS: 4 5* 1) change(86-05-20,Lippard), approve(86-06-02,MCR7427), 4 6* audit(86-06-17,Farley), install(86-06-17,MR12.0-1077): 4 7* Change non-returned information into pad fields. 4 8* END HISTORY COMMENTS */ 4 9 4 10 4 11 dcl 1 status_for_backup aligned based, 4 12 2 version fixed bin, 4 13 2 pad1 bit (108), 4 14 2 switches unaligned, 4 15 3 safety bit (1) unaligned, 4 16 3 entrypt bit (1) unaligned, 4 17 3 security_oosw bit (1) unaligned, 4 18 3 audit_flag bit (1) unaligned, 4 19 3 multiple_class bit (1) unaligned, 4 20 3 pad2 bit (2) unaligned, 4 21 3 master_dir bit (1) unaligned, 4 22 3 tpd bit (1) unaligned, 4 23 3 pad13 bit (13) unaligned, 4 24 2 entrypt_bound bit (14) unaligned, 4 25 2 access_class bit (72), 4 26 2 spad bit (36), 4 27 2 author char (32), 4 28 2 bc_author char (32), 4 29 2 lvid bit (36), 4 30 2 pvid bit (36), 4 31 2 pad3 bit (216); 4 32 4 33 dcl status_for_backup_version_2 fixed bin initial (2) static options (constant); 4 34 4 35 /* ---------------- END include file status_for_backup.incl.pl1 ---------------- */ 1179 5 1 /* --------------- BEGIN include file status_structures.incl.pl1 --------------- */ 5 2 5 3 /* Revised from existing include files 09/26/78 by C. D. Tavares */ 5 4 5 5 /* This include file contains branch and link structures returned by 5 6* hcs_$status_ and hcs_$status_long. */ 5 7 5 8 dcl 1 status_branch aligned based (status_ptr), 5 9 2 short aligned, 5 10 3 type fixed bin (2) unaligned unsigned, /* seg, dir, or link */ 5 11 3 nnames fixed bin (16) unaligned unsigned, /* number of names */ 5 12 3 names_relp bit (18) unaligned, /* see entry_names dcl */ 5 13 3 dtcm bit (36) unaligned, /* date/time contents last modified */ 5 14 3 dtu bit (36) unaligned, /* date/time last used */ 5 15 3 mode bit (5) unaligned, /* caller's effective access */ 5 16 3 raw_mode bit (5) unaligned, /* caller's raw "rew" modes */ 5 17 3 pad1 bit (8) unaligned, 5 18 3 records_used fixed bin (18) unaligned unsigned, /* number of NONZERO pages used */ 5 19 5 20 /* Limit of information returned by hcs_$status_ */ 5 21 5 22 2 long aligned, 5 23 3 dtd bit (36) unaligned, /* date/time last dumped */ 5 24 3 dtem bit (36) unaligned, /* date/time branch last modified */ 5 25 3 lvid bit (36) unaligned, /* logical volume ID */ 5 26 3 current_length fixed bin (12) unaligned unsigned, /* number of last page used */ 5 27 3 bit_count fixed bin (24) unaligned unsigned, /* reported length in bits */ 5 28 3 pad2 bit (8) unaligned, 5 29 3 copy_switch bit (1) unaligned, /* copy switch */ 5 30 3 tpd_switch bit (1) unaligned, /* transparent to paging device switch */ 5 31 3 mdir_switch bit (1) unaligned, /* is a master dir */ 5 32 3 damaged_switch bit (1) unaligned, /* salvager warned of possible damage */ 5 33 3 synchronized_switch bit (1) unaligned, /* DM synchronized file */ 5 34 3 pad3 bit (5) unaligned, 5 35 3 ring_brackets (0:2) fixed bin (6) unaligned unsigned, 5 36 3 uid bit (36) unaligned; /* unique ID */ 5 37 5 38 dcl 1 status_link aligned based (status_ptr), 5 39 2 type fixed bin (2) unaligned unsigned, /* as above */ 5 40 2 nnames fixed bin (16) unaligned unsigned, 5 41 2 names_relp bit (18) unaligned, 5 42 2 dtem bit (36) unaligned, 5 43 2 dtd bit (36) unaligned, 5 44 2 pathname_length fixed bin (17) unaligned, /* see pathname */ 5 45 2 pathname_relp bit (18) unaligned; /* see pathname */ 5 46 5 47 dcl status_entry_names (status_branch.nnames) character (32) aligned 5 48 based (pointer (status_area_ptr, status_branch.names_relp)), 5 49 /* array of names returned */ 5 50 status_pathname character (status_link.pathname_length) aligned 5 51 based (pointer (status_area_ptr, status_link.pathname_relp)), 5 52 /* link target path */ 5 53 status_area_ptr pointer, 5 54 status_ptr pointer; 5 55 5 56 dcl (Link initial (0), 5 57 Segment initial (1), 5 58 Directory initial (2)) fixed bin internal static options (constant); 5 59 /* values for type fields declared above */ 5 60 5 61 /* ---------------- END include file status_structures.incl.pl1 ---------------- */ 1180 6 1 /* Begin include file file_system_operations_.incl.pl1 BIM 8309 */ 6 2 /* Modified 1984.12.17 MAP: change FS_STANDARD_TYPES (4) to -multisegment_file */ 6 3 /* format: style3,indcomtxt */ 6 4 6 5 /**** Names of the operations supported by the extended object 6 6* software (file_system_/object_type_). */ 6 7 6 8 /**** These MUST be in alphabetical order! 6 9* Changes here must force recompilation of users of the include file */ 6 10 6 11 declare FS_OPERATIONS (22) char (64) unaligned init ( 6 12 /** */ 6 13 "add_acl_entries", 6 14 "add_extended_acl_entries", 6 15 "chname_file", 6 16 "copy", 6 17 "delentry_file", 6 18 "delete_acl_entries", 6 19 "get_bit_count", 6 20 "get_max_length", 6 21 "get_ring_brackets", 6 22 "get_switch", 6 23 "get_user_access_modes", 6 24 "list_acl", 6 25 "list_extended_acl", 6 26 "list_switches", 6 27 "replace_acl", 6 28 "replace_extended_acl", 6 29 "set_bit_count", 6 30 "set_max_length", 6 31 "set_ring_brackets", 6 32 "set_switch", 6 33 "suffix_info", 6 34 "validate" /** */ 6 35 ) int static options (constant); 6 36 6 37 declare HIGHEST_FS_OPERATION_INDEX fixed bin init (22) int static options (constant); 6 38 6 39 declare FS_STANDARD_TYPES (5) char (32) int static options (constant) init ( 6 40 /** */ 6 41 "-directory", /** 1 */ 6 42 "-dm_file", /** 2 */ 6 43 "-link", /** 3 */ 6 44 "-multisegment_file", /** 4 */ 6 45 "-segment" /** 5 */ 6 46 ); 6 47 6 48 declare HIGHEST_FS_STANDARD_TYPE_INDEX fixed bin init (5) int static options (constant); 6 49 6 50 /* End include file file_system_operations_.incl.pl1 */ 1181 1182 end fs_standard_object_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 10/17/90 0817.4 fs_standard_object_.pl1 >spec>install>1044>fs_standard_object_.pl1 769 1 06/10/82 1145.5 star_structures.incl.pl1 >ldd>include>star_structures.incl.pl1 1073 2 03/05/85 1907.3 suffix_info.incl.pl1 >ldd>include>suffix_info.incl.pl1 1074 3 10/14/83 1706.7 copy_flags.incl.pl1 >ldd>include>copy_flags.incl.pl1 1179 4 06/17/86 1613.1 status_for_backup.incl.pl1 >ldd>include>status_for_backup.incl.pl1 1180 5 11/22/82 1055.7 status_structures.incl.pl1 >ldd>include>status_structures.incl.pl1 1181 6 03/05/85 1907.7 file_system_operations_.incl.pl1 >ldd>include>file_system_operations_.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. Area_ptr parameter pointer dcl 808 ref 805 823 829 834 Bit_count parameter fixed bin(24,0) dcl 1067 set ref 1064 1069* Code parameter fixed bin(35,0) dcl 62 set ref 57 74* 94* 107* 114* 145* 152* 165* 175* 191* 210* 214* 223* 230* 234* 252* 273* 293* 312* 325* 332* 351* 370* 383* 390* 409* 422* 429* 433* 449* 468* 487* 522 531* 536 546* 551 561* 566 569* 574 578* 583 587* 592 596* 601 605* 643* 650* 651 659* 660 660* 663* 664 675* 676 685* 704* 705 713* 729* 739* 742* 744* 746* 749* 751 751* 805 823 829 838* 900 907* 911 918* 985 989* 990 992* 996 999* 1000 1002* 1006 1009* 1010 1012* 1016 1019* 1020 1023* 1028 1031* 1032 1035* 1039 1046* 1048 1048* 1051 1051* 1053 1056* 1064 1069* DIR constant fixed bin(17,0) initial dcl 617 in procedure "GET_DIR_SWITCH" ref 626 692 742 DIR constant fixed bin(17,0) initial dcl 814 in procedure "fs_standard_object_" ref 820 842 Desired_version parameter char packed unaligned dcl 810 ref 805 823 829 836 Dir_name parameter char packed unaligned dcl 539 set ref 522 531* 536 546* 551 566 574 583 592 601 643* 650* 659* 659* 663* 675* 704* 713* 729* 739* 742* 744* 746* 751* 751* 900 907* 911 918* 985 989* 996 999* 1006 1009* 1016 1019* 1028 1031* 1039 1046* 1046* 1051* 1064 1069* Entryname parameter char packed unaligned dcl 540 set ref 522 531* 536 546* 551 566 574 583 592 601 643* 650* 659* 659* 663* 675* 704* 713* 729* 739* 742* 744* 746* 751* 751* 900 907* 911 918* 985 989* 996 999* 1006 1009* 1016 1019* 1028 1031* 1039 1046* 1046* 1051* 1064 1069* Exmodes parameter bit(36) dcl 1044 set ref 1039 1046* 1051* 1055* FS_OBJECT_TYPE_DIRECTORY 000206 constant char(32) initial packed unaligned dcl 2-50 ref 929 992 FS_OBJECT_TYPE_DM_FILE 000166 constant char(32) initial packed unaligned dcl 2-50 ref 1035 FS_OBJECT_TYPE_LINK 000156 constant char(32) initial packed unaligned dcl 2-50 ref 1012 FS_OBJECT_TYPE_MSF 000176 constant char(32) initial packed unaligned dcl 2-50 ref 949 1023 FS_OBJECT_TYPE_SEGMENT 000216 constant char(32) initial packed unaligned dcl 2-50 ref 968 1002 HIGHEST_FS_STANDARD_TYPE_INDEX constant fixed bin(17,0) initial dcl 6-48 ref 71 MSF constant fixed bin(17,0) initial dcl 617 in procedure "GET_DIR_SWITCH" ref 638 657 707 717 731 751 MSF constant fixed bin(17,0) initial dcl 814 in procedure "fs_standard_object_" ref 832 842 Modes parameter bit(36) dcl 1044 set ref 1039 1046* 1051* 1055* Operation parameter fixed bin(17,0) dcl 61 ref 57 71 Ring parameter fixed bin(3,0) dcl 1043 set ref 1039 1046* 1051* Rings parameter fixed bin(3,0) array dcl 525 set ref 522 526* 531 536 546 900 907 911 918 SEG constant fixed bin(17,0) initial dcl 617 in procedure "GET_DIR_SWITCH" ref 632 673 698 710 742 746 SEG constant fixed bin(17,0) initial dcl 814 in procedure "fs_standard_object_" ref 826 871 888 SWITCH_LIST_VERSION_1 000226 constant char(8) initial packed unaligned dcl 2-48 ref 836 854 Suffix_info_ptr parameter pointer dcl 926 ref 923 928 944 947 964 967 Switch_list_ptr parameter pointer dcl 808 set ref 805 823 829 894* Switch_name parameter char packed unaligned dcl 554 ref 551 559 566 570 574 577 583 586 592 595 601 604 Switch_value parameter bit(1) dcl 555 set ref 551 566 574 583 592 601 644* 651* 666* 669* 678* 680* 682* 713 726 736 742 742 744 746 751* Type parameter fixed bin(17,0) dcl 60 ref 57 71 Username parameter char packed unaligned dcl 1042 set ref 1039 1046* 1051* acl 46(01) based bit(1) level 3 packed packed unaligned dcl 2-12 set ref 937* addr builtin function dcl 1076 ref 531 546 650 650 675 675 907 918 alloc_switch_count 000154 automatic fixed bin(17,0) dcl 2-33 set ref 844* 848* 852 852 alloc_switch_name_count 000155 automatic fixed bin(17,0) dcl 2-33 set ref 845* 849* 852 852 area_ptr 000134 automatic pointer dcl 811 set ref 834* 852 audit_flag 4(03) 000174 automatic bit(1) level 3 packed packed unaligned dcl 622 set ref 651 cleanup 000102 stack reference condition dcl 768 ref 772 code parameter fixed bin(35,0) dcl 762 set ref 756 786* 788 copy_flags 46 based structure level 2 in structure "suffix_info" dcl 2-12 in procedure "fs_standard_object_" set ref 936* 959* 976* copy_flags based structure level 1 dcl 3-8 in procedure "fs_standard_object_" copy_switch 46(04) based bit(1) level 3 in structure "suffix_info" packed packed unaligned dcl 2-12 in procedure "fs_standard_object_" set ref 960* copy_switch 10(08) 000234 automatic bit(1) level 3 in structure "sb" packed packed unaligned dcl 623 in procedure "GET_DIR_SWITCH" set ref 678 damaged_switch 10(11) 000234 automatic bit(1) level 3 packed packed unaligned dcl 623 set ref 680 default_value 6 based bit(1) array level 3 dcl 2-37 set ref 857* 861* 865* 869* 875* 879* dir_name parameter char packed unaligned dcl 759 set ref 756 786* 792* dir_rings based fixed bin(3,0) array dcl 528 in begin block on line 527 set ref 531* dir_rings based fixed bin(3,0) array dcl 904 in begin block on line 903 set ref 907* dumper_switches 46(06) based bit(1) level 3 packed packed unaligned dcl 2-12 set ref 937* entry_bound 46(07) based bit(1) level 3 packed packed unaligned dcl 2-12 set ref 960* entry_index 000100 automatic fixed bin(17,0) dcl 763 set ref 791* 792 792* error_table_$argerr 000010 external static fixed bin(35,0) dcl 1082 ref 685 749 error_table_$inconsistent_msf 000024 external static fixed bin(35,0) dcl 1082 ref 660 1048 error_table_$incorrect_access 000020 external static fixed bin(35,0) dcl 1082 ref 1053 error_table_$noentry 000022 external static fixed bin(35,0) dcl 1082 ref 660 1048 error_table_$not_seg_type 000016 external static fixed bin(35,0) dcl 1082 ref 992 1002 1012 1023 1035 error_table_$notadir 000014 external static fixed bin(35,0) dcl 1082 ref 1051 error_table_$unimplemented_version 000026 external static fixed bin(35,0) dcl 1082 ref 838 error_table_$unsupported_operation 000012 external static fixed bin(35,0) dcl 1082 ref 94 107 114 145 152 165 175 191 210 214 223 230 234 252 273 293 312 325 332 351 370 383 390 409 422 429 433 449 468 487 extended_acl 32(01) based bit(1) level 3 packed packed unaligned dcl 2-12 set ref 954* 974* file_manager_$add_acl_entries 000034 constant entry external dcl 1097 ref 91 file_manager_$add_extended_acl_entries 000036 constant entry external dcl 1097 ref 111 file_manager_$chname_file 000040 constant entry external dcl 1097 ref 130 file_manager_$copy 000042 constant entry external dcl 1097 ref 149 file_manager_$delentry_file 000044 constant entry external dcl 1097 ref 169 file_manager_$delete_acl_entries 000046 constant entry external dcl 1097 ref 188 file_manager_$get_bit_count 000050 constant entry external dcl 1097 ref 207 file_manager_$get_max_length 000052 constant entry external dcl 1097 ref 227 file_manager_$get_ring_brackets 000054 constant entry external dcl 1097 ref 248 file_manager_$get_switch 000056 constant entry external dcl 1097 ref 270 file_manager_$get_user_access_modes 000060 constant entry external dcl 1097 ref 290 file_manager_$list_acl 000062 constant entry external dcl 1097 ref 309 file_manager_$list_extended_acl 000064 constant entry external dcl 1097 ref 329 file_manager_$list_switches 000110 constant entry external dcl 1123 ref 348 file_manager_$replace_acl 000066 constant entry external dcl 1097 ref 367 file_manager_$replace_extended_acl 000070 constant entry external dcl 1097 ref 387 file_manager_$set_bit_count 000072 constant entry external dcl 1097 ref 406 file_manager_$set_max_length 000074 constant entry external dcl 1097 ref 426 file_manager_$set_ring_brackets 000076 constant entry external dcl 1097 ref 446 file_manager_$set_switch 000100 constant entry external dcl 1097 ref 465 file_manager_$suffix_info 000102 constant entry external dcl 1097 ref 484 fixed builtin function dcl 1076 ref 742 742 flags 32 based structure level 2 packed packed unaligned dcl 2-12 set ref 932* 952* 971* fs_acl_util_$add_directory 000114 constant entry external dcl 1126 ref 88 fs_acl_util_$add_msf 000116 constant entry external dcl 1126 ref 98 fs_acl_util_$add_msf_extended 000152 constant entry external dcl 1126 ref 118 fs_acl_util_$add_segment 000112 constant entry external dcl 1126 ref 101 fs_acl_util_$add_segment_extended 000144 constant entry external dcl 1126 ref 121 fs_acl_util_$delete_directory 000122 constant entry external dcl 1126 ref 185 fs_acl_util_$delete_msf 000124 constant entry external dcl 1126 ref 195 fs_acl_util_$delete_segment 000120 constant entry external dcl 1126 ref 198 fs_acl_util_$list_directory 000130 constant entry external dcl 1126 ref 306 fs_acl_util_$list_msf 000132 constant entry external dcl 1126 ref 316 fs_acl_util_$list_msf_extended 000150 constant entry external dcl 1126 ref 336 fs_acl_util_$list_segment 000126 constant entry external dcl 1126 ref 319 fs_acl_util_$list_segment_extended 000142 constant entry external dcl 1126 ref 339 fs_acl_util_$replace_directory 000136 constant entry external dcl 1126 ref 364 fs_acl_util_$replace_msf 000140 constant entry external dcl 1126 ref 374 fs_acl_util_$replace_msf_extended 000154 constant entry external dcl 1126 ref 394 fs_acl_util_$replace_segment 000134 constant entry external dcl 1126 ref 377 fs_acl_util_$replace_segment_extended 000146 constant entry external dcl 1126 ref 397 fs_copy_util_$msf 000156 constant entry external dcl 1147 ref 156 fs_copy_util_$segment 000160 constant entry external dcl 1147 ref 159 fs_get_type_ 000176 constant entry external dcl 1163 ref 989 999 1009 1019 1031 fs_msf_rb_util_$get 000106 constant entry external dcl 1119 ref 256 fs_msf_rb_util_$set 000104 constant entry external dcl 1119 ref 453 get_system_free_area_ 000230 constant entry external dcl 764 ref 786 786 has_switches 32(02) based bit(1) level 3 packed packed unaligned dcl 2-12 set ref 934* 973* hcs_$chname_file 000162 constant entry external dcl 1152 ref 127 133 136 139 hcs_$delentry_file 000032 constant entry external dcl 1095 ref 172 179 hcs_$get_dir_ring_brackets 000224 constant entry external dcl 529 ref 531 hcs_$get_max_length 000170 constant entry external dcl 1152 ref 238 hcs_$get_ring_brackets 000226 constant entry external dcl 544 ref 546 hcs_$get_safety_sw 000200 constant entry external dcl 1164 ref 643 hcs_$get_user_access_modes 000172 constant entry external dcl 1158 ref 287 300 1046 1051 hcs_$get_volume_dump_switches 000202 constant entry external dcl 1165 ref 659 663 hcs_$set_bc 000164 constant entry external dcl 1152 ref 403 413 416 hcs_$set_copysw 000212 constant entry external dcl 1172 ref 742 hcs_$set_damaged_sw 000216 constant entry external dcl 1174 ref 744 hcs_$set_dir_ring_brackets 000234 constant entry external dcl 905 ref 907 hcs_$set_max_length 000166 constant entry external dcl 1152 ref 437 hcs_$set_ring_brackets 000236 constant entry external dcl 916 ref 918 hcs_$set_safety_sw 000204 constant entry external dcl 1167 ref 713 hcs_$set_synchronized_sw 000210 constant entry external dcl 1170 ref 746 hcs_$set_volume_dump_switches 000206 constant entry external dcl 1168 ref 729 739 hcs_$star_ 000232 constant entry external dcl 765 ref 786 hcs_$status_for_backup 000220 constant entry external dcl 1175 ref 650 hcs_$status_long 000214 constant entry external dcl 1173 ref 675 hcs_$status_minf 000222 constant entry external dcl 1176 ref 704 1069 hcs_type 000173 automatic fixed bin(2,0) dcl 616 set ref 704* 707 info_pathname 47 based char(168) level 2 packed packed unaligned dcl 2-12 set ref 941* 961* 980* long 4 000234 automatic structure level 2 dcl 623 make_entry_jumpx 000100 automatic fixed bin(17,0) dcl 64 set ref 71* 75 max_length 46(03) based bit(1) level 3 packed packed unaligned dcl 2-12 set ref 960* max_mode_len 44 based fixed bin(17,0) level 2 dcl 2-12 set ref 939* 957* 978* mbz 46(10) based bit(26) level 3 packed packed unaligned dcl 2-12 set ref 960* 977* modes 33 based char(36) level 2 dcl 2-12 set ref 935* 955* 975* name_count 5 based fixed bin(17,0) array level 3 dcl 2-37 set ref 856* 860* 864* 868* 874* 878* name_index 4 based fixed bin(17,0) array level 3 dcl 2-37 set ref 855* 859* 863* 867* 873* 877* names based char(32) array level 2 in structure "switch_list" dcl 2-37 in procedure "fs_standard_object_" set ref 882* 883* 884* 885* 886* 887* 890* 891* names 46 based bit(1) level 3 in structure "suffix_info" packed packed unaligned dcl 2-12 in procedure "fs_standard_object_" set ref 937* ncvd 000247 automatic fixed bin(17,0) dcl 624 set ref 659* 663* 666 726* 728* 729* 735* nindex 0(18) based fixed bin(18,0) array level 2 packed packed unsigned unaligned dcl 1-27 ref 792 nivd 000246 automatic fixed bin(17,0) dcl 624 set ref 659* 663* 669 735* 736* 738* 739* nnames 0(02) based fixed bin(16,0) array level 2 packed packed unsigned unaligned dcl 1-27 ref 776 797 null builtin function dcl 1076 ref 675 675 771 774 777 779 782 null_entry_ 000030 constant entry external dcl 1093 ref 97 110 117 148 155 168 178 194 213 217 226 233 237 255 276 296 315 328 335 354 373 386 393 412 425 432 436 452 471 490 num_ring_brackets 45 based fixed bin(17,0) level 2 dcl 2-12 set ref 940* 958* 979* pathname_ 000174 constant entry external dcl 1161 ref 659 659 751 751 1046 1046 plural_name 22 based char(32) level 2 packed packed unaligned dcl 2-12 set ref 931* 951* 970* safety_switch 46(05) based bit(1) level 3 packed packed unaligned dcl 2-12 set ref 937* sb 000234 automatic structure level 1 dcl 623 set ref 675 675 seg_rings based fixed bin(3,0) array dcl 915 in begin block on line 914 set ref 918* seg_rings based fixed bin(3,0) array dcl 543 in begin block on line 542 set ref 546* sfb 000174 automatic structure level 1 dcl 622 set ref 650 650 standard_object 32 based bit(1) level 3 packed packed unaligned dcl 2-12 set ref 933* 953* 972* star_BRANCHES_ONLY 000255 constant fixed bin(2,0) initial dcl 1-110 set ref 786* star_SEGMENT constant fixed bin(2,0) initial unsigned dcl 1-120 ref 792 star_entries based structure array level 1 dcl 1-27 ref 781 798 star_entry_count 000110 automatic fixed bin(17,0) dcl 1-14 set ref 776 781 786* 791 797 798 star_entry_ptr 000112 automatic pointer dcl 1-15 set ref 771* 776 779 781 782* 786* 792 792 797 798 star_names based char(32) array packed unaligned dcl 1-37 set ref 776 792* 797 star_names_ptr 000114 automatic pointer dcl 1-19 set ref 771* 774 776 777* 786* 792 797 status_branch based structure level 1 dcl 5-8 status_for_backup based structure level 1 dcl 4-11 status_for_backup_version_2 constant fixed bin(17,0) initial dcl 4-33 ref 649 suffix_info based structure level 1 dcl 2-12 suffix_info_ptr 000150 automatic pointer dcl 2-10 set ref 928* 929 930 931 932 933 934 935 936 937 937 937 937 939 940 941 947* 949 950 951 952 953 954 955 957 958 959 960 960 960 960 961 967* 968 969 970 971 972 973 974 975 976 977 978 979 980 sum builtin function dcl 1076 ref 776 797 switch_count 2 based fixed bin(17,0) level 2 dcl 2-37 set ref 852* 882 883 884 885 886 887 890 891 switch_list based structure level 1 dcl 2-37 set ref 852 switch_list_ptr 000152 automatic pointer dcl 2-33 set ref 852* 854 855 856 857 859 860 861 863 864 865 867 868 869 873 874 875 877 878 879 882 883 884 885 886 887 890 891 894 switch_list_type 000136 automatic fixed bin(17,0) dcl 813 set ref 820* 826* 832* 842 842 871 888 switch_name parameter char packed unaligned dcl 760 in procedure "MAP_OVER_MSF_COMPONENTS" set ref 756 792* switch_name 000101 automatic char(100) packed unaligned dcl 556 in procedure "fs_standard_object_" set ref 559* 570* 577* 586* 595* 604* 640 647 655 655 666 673 673 673 678 680 713 717 719 731 733 742 744 746 751* switch_name_count 3 based fixed bin(17,0) level 2 dcl 2-37 set ref 852* switch_value 000132 automatic bit(1) packed unaligned dcl 557 in procedure "fs_standard_object_" set ref 643* 644 switch_value parameter bit(1) dcl 761 in procedure "MAP_OVER_MSF_COMPONENTS" set ref 756 792* switches 4 000174 automatic structure level 2 in structure "sfb" packed packed unaligned dcl 622 in procedure "GET_DIR_SWITCH" switches 4 based structure array level 2 in structure "switch_list" dcl 2-37 in procedure "fs_standard_object_" synchronized_switch 10(12) 000234 automatic bit(1) level 3 packed packed unaligned dcl 623 set ref 682 type 000137 automatic char(32) packed unaligned dcl 987 in procedure "fs_standard_object_" set ref 989* 992 999* 1002 1009* 1012 1019* 1023 1031* 1035 type 2 based char(32) level 2 in structure "suffix_info" packed packed unaligned dcl 2-12 in procedure "fs_standard_object_" set ref 929* 949* 968* type based fixed bin(2,0) array level 2 in structure "star_entries" packed packed unsigned unaligned dcl 1-27 in procedure "MAP_OVER_MSF_COMPONENTS" ref 792 type 000172 automatic fixed bin(17,0) dcl 615 in procedure "GET_DIR_SWITCH" set ref 626* 632* 638* 657 673 692* 698* 707* 710* 717 731 742 742 746 751 type_name 12 based char(32) level 2 packed packed unaligned dcl 2-12 set ref 930* 950* 969* user_area based area(1024) dcl 812 ref 852 version based char(8) level 2 in structure "switch_list" dcl 2-37 in procedure "fs_standard_object_" set ref 854* version 000174 automatic fixed bin(17,0) level 2 in structure "sfb" dcl 622 in procedure "GET_DIR_SWITCH" set ref 649* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. Directory internal static fixed bin(17,0) initial dcl 5-56 FS_OPERATIONS internal static char(64) initial array packed unaligned dcl 6-11 FS_STANDARD_TYPES internal static char(32) initial array packed unaligned dcl 6-39 HIGHEST_FS_OPERATION_INDEX internal static fixed bin(17,0) initial dcl 6-37 Link internal static fixed bin(17,0) initial dcl 5-56 SUFFIX_INFO_VERSION_1 internal static char(8) initial packed unaligned dcl 2-29 Segment internal static fixed bin(17,0) initial dcl 5-56 star_ALL_ENTRIES internal static fixed bin(2,0) initial dcl 1-111 star_ALL_ENTRIES_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 1-114 star_DIRECTORY internal static fixed bin(2,0) initial unsigned dcl 1-121 star_LINK internal static fixed bin(2,0) initial unsigned dcl 1-119 star_LINKS_ONLY internal static fixed bin(2,0) initial dcl 1-109 star_LINKS_ONLY_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 1-112 star_branch_count automatic fixed bin(17,0) dcl 1-13 star_dir_list_branch based structure array level 1 dcl 1-59 star_link_count automatic fixed bin(17,0) dcl 1-17 star_link_pathname based char packed unaligned dcl 1-102 star_links based structure array level 1 dcl 1-76 star_linkx automatic fixed bin(17,0) dcl 1-18 star_list_branch based structure array level 1 dcl 1-41 star_list_branch_ptr automatic pointer dcl 1-16 star_list_names based char(32) array packed unaligned dcl 1-92 star_list_names_ptr automatic pointer dcl 1-20 star_select_sw automatic fixed bin(3,0) dcl 1-21 status_area_ptr automatic pointer dcl 5-47 status_entry_names based char(32) array dcl 5-47 status_link based structure level 1 dcl 5-38 status_pathname based char dcl 5-47 status_ptr automatic pointer dcl 5-47 NAMES DECLARED BY EXPLICIT CONTEXT. GET_DIR_SWITCH 006126 constant entry internal dcl 612 ref 562 GET_MSF_SWITCH 006136 constant entry internal dcl 635 ref 607 GET_SEG_SWITCH 006132 constant entry internal dcl 629 ref 571 Join 006141 constant label dcl 640 ref 627 633 Join_set 006630 constant label dcl 713 ref 693 699 MAKE_ENTRY_LABEL 000000 constant label array(110) dcl 88 set ref 75 MAP_OVER_MSF_COMPONENTS 007261 constant entry internal dcl 756 ref 751 SET_DIR_SWITCH 006542 constant entry internal dcl 689 ref 580 SET_MSF_SWITCH 006552 constant entry internal dcl 701 ref 598 SET_SEG_SWITCH 006546 constant entry internal dcl 695 ref 589 SWITCH_LIST_JOIN 004101 constant label dcl 834 ref 821 827 directory_suffix_info 004461 constant entry external dcl 923 ref 481 directory_validate 005045 constant entry external dcl 985 ref 501 dm_file_validate 005471 constant entry external dcl 1028 ref 504 fs_standard_object_ 000361 constant entry external dcl 54 get_bc_seg_or_dir 006030 constant entry external dcl 1064 ref 204 218 get_directory_ring_brackets 003170 constant entry external dcl 522 ref 244 get_directory_switch 003400 constant entry external dcl 551 ref 267 get_msf_switch 003727 constant entry external dcl 601 ref 277 get_segment_ring_brackets 003310 constant entry external dcl 536 ref 260 get_segment_switch 003453 constant entry external dcl 566 ref 280 link_validate 005257 constant entry external dcl 1006 ref 507 list_directory_switches 004005 constant entry external dcl 805 ref 345 list_msf_switches 004057 constant entry external dcl 829 ref 355 list_segment_switches 004032 constant entry external dcl 823 ref 358 make_entry 000376 constant entry external dcl 57 msf_get_user_access_modes 005602 constant entry external dcl 1039 ref 297 msf_suffix_info 004602 constant entry external dcl 944 ref 491 msf_validate 005364 constant entry external dcl 1016 ref 510 segment_suffix_info 004725 constant entry external dcl 964 ref 494 segment_validate 005152 constant entry external dcl 996 ref 513 set_directory_ring_brackets 004306 constant entry external dcl 900 ref 443 set_directory_switch 003526 constant entry external dcl 574 ref 462 set_msf_switch 003654 constant entry external dcl 592 ref 472 set_segment_ring_brackets 004373 constant entry external dcl 911 ref 456 set_segment_switch 003601 constant entry external dcl 583 ref 475 792 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 11202 11442 7602 11212 Length 12250 7602 240 571 1377 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME fs_standard_object_ 424 external procedure is an external procedure. begin block on line 527 begin block shares stack frame of external procedure fs_standard_object_. begin block on line 542 begin block shares stack frame of external procedure fs_standard_object_. GET_DIR_SWITCH internal procedure shares stack frame of external procedure fs_standard_object_. MAP_OVER_MSF_COMPONENTS 128 internal procedure enables or reverts conditions. on unit on line 772 64 on unit begin block on line 903 begin block shares stack frame of external procedure fs_standard_object_. begin block on line 914 begin block shares stack frame of external procedure fs_standard_object_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME MAP_OVER_MSF_COMPONENTS 000100 entry_index MAP_OVER_MSF_COMPONENTS 000110 star_entry_count MAP_OVER_MSF_COMPONENTS 000112 star_entry_ptr MAP_OVER_MSF_COMPONENTS 000114 star_names_ptr MAP_OVER_MSF_COMPONENTS fs_standard_object_ 000100 make_entry_jumpx fs_standard_object_ 000101 switch_name fs_standard_object_ 000132 switch_value fs_standard_object_ 000134 area_ptr fs_standard_object_ 000136 switch_list_type fs_standard_object_ 000137 type fs_standard_object_ 000150 suffix_info_ptr fs_standard_object_ 000152 switch_list_ptr fs_standard_object_ 000154 alloc_switch_count fs_standard_object_ 000155 alloc_switch_name_count fs_standard_object_ 000172 type GET_DIR_SWITCH 000173 hcs_type GET_DIR_SWITCH 000174 sfb GET_DIR_SWITCH 000234 sb GET_DIR_SWITCH 000246 nivd GET_DIR_SWITCH 000247 ncvd GET_DIR_SWITCH THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_l_a r_e_as call_ext_in_desc call_ext_out_desc call_ext_out call_int_this_desc return_mac mpfx2 signal_op enable_op ext_entry ext_entry_desc int_entry int_entry_desc op_alloc_ op_freen_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. file_manager_$add_acl_entries file_manager_$add_extended_acl_entries file_manager_$chname_file file_manager_$copy file_manager_$delentry_file file_manager_$delete_acl_entries file_manager_$get_bit_count file_manager_$get_max_length file_manager_$get_ring_brackets file_manager_$get_switch file_manager_$get_user_access_modes file_manager_$list_acl file_manager_$list_extended_acl file_manager_$list_switches file_manager_$replace_acl file_manager_$replace_extended_acl file_manager_$set_bit_count file_manager_$set_max_length file_manager_$set_ring_brackets file_manager_$set_switch file_manager_$suffix_info fs_acl_util_$add_directory fs_acl_util_$add_msf fs_acl_util_$add_msf_extended fs_acl_util_$add_segment fs_acl_util_$add_segment_extended fs_acl_util_$delete_directory fs_acl_util_$delete_msf fs_acl_util_$delete_segment fs_acl_util_$list_directory fs_acl_util_$list_msf fs_acl_util_$list_msf_extended fs_acl_util_$list_segment fs_acl_util_$list_segment_extended fs_acl_util_$replace_directory fs_acl_util_$replace_msf fs_acl_util_$replace_msf_extended fs_acl_util_$replace_segment fs_acl_util_$replace_segment_extended fs_copy_util_$msf fs_copy_util_$segment fs_get_type_ fs_msf_rb_util_$get fs_msf_rb_util_$set get_system_free_area_ hcs_$chname_file hcs_$delentry_file hcs_$get_dir_ring_brackets hcs_$get_max_length hcs_$get_ring_brackets hcs_$get_safety_sw hcs_$get_user_access_modes hcs_$get_volume_dump_switches hcs_$set_bc hcs_$set_copysw hcs_$set_damaged_sw hcs_$set_dir_ring_brackets hcs_$set_max_length hcs_$set_ring_brackets hcs_$set_safety_sw hcs_$set_synchronized_sw hcs_$set_volume_dump_switches hcs_$star_ hcs_$status_for_backup hcs_$status_long hcs_$status_minf null_entry_ pathname_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$argerr error_table_$inconsistent_msf error_table_$incorrect_access error_table_$noentry error_table_$not_seg_type error_table_$notadir error_table_$unimplemented_version error_table_$unsupported_operation LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 54 000360 57 000370 71 000407 74 000415 75 000416 88 000417 91 000433 94 000447 97 000451 98 000465 101 000501 107 000515 110 000517 111 000533 114 000547 117 000551 118 000565 121 000601 127 000615 130 000631 133 000645 136 000661 139 000675 145 000711 148 000713 149 000727 152 000743 155 000745 156 000761 159 000775 165 001011 168 001013 169 001027 172 001043 175 001057 178 001061 179 001075 185 001111 188 001125 191 001141 194 001143 195 001157 198 001173 204 001207 207 001223 210 001237 213 001241 214 001255 217 001257 218 001273 223 001307 226 001311 227 001325 230 001341 233 001343 234 001357 237 001361 238 001375 244 001411 248 001425 252 001441 255 001443 256 001457 260 001473 267 001507 270 001523 273 001537 276 001541 277 001555 280 001571 287 001605 290 001621 293 001635 296 001637 297 001653 300 001667 306 001703 309 001717 312 001733 315 001735 316 001751 319 001765 325 002001 328 002003 329 002017 332 002033 335 002035 336 002051 339 002065 345 002101 348 002115 351 002131 354 002133 355 002147 358 002163 364 002177 367 002213 370 002227 373 002231 374 002245 377 002261 383 002275 386 002277 387 002313 390 002327 393 002331 394 002345 397 002361 403 002375 406 002411 409 002425 412 002427 413 002443 416 002457 422 002473 425 002475 426 002511 429 002525 432 002527 433 002543 436 002545 437 002561 443 002575 446 002611 449 002625 452 002627 453 002643 456 002657 462 002673 465 002707 468 002723 471 002725 472 002741 475 002755 481 002771 484 003005 487 003021 490 003023 491 003037 494 003053 501 003067 504 003103 507 003117 510 003133 513 003147 522 003163 526 003215 531 003250 533 003277 536 003306 546 003335 548 003364 551 003373 559 003432 561 003440 562 003441 564 003442 566 003451 569 003505 570 003506 571 003514 572 003515 574 003524 577 003560 578 003566 580 003567 581 003570 583 003577 586 003633 587 003641 589 003642 590 003643 592 003652 595 003706 596 003714 598 003715 599 003716 601 003725 604 003761 605 003767 607 003770 608 003771 805 004000 820 004025 821 004027 823 004030 826 004052 827 004054 829 004055 832 004077 834 004101 836 004105 838 004113 839 004116 842 004125 844 004131 845 004133 846 004135 848 004136 849 004140 852 004142 854 004161 855 004164 856 004166 857 004167 859 004170 860 004172 861 004174 863 004175 864 004177 865 004201 867 004202 868 004204 869 004206 871 004207 873 004212 874 004214 875 004216 877 004217 878 004221 879 004223 882 004224 883 004232 884 004236 885 004242 886 004246 887 004252 888 004256 890 004262 891 004267 894 004273 895 004275 900 004304 907 004333 909 004362 911 004371 918 004420 920 004447 923 004456 928 004470 929 004474 930 004477 931 004502 932 004505 933 004515 934 004517 935 004521 936 004524 937 004552 939 004562 940 004564 941 004566 942 004571 944 004600 947 004611 949 004615 950 004620 951 004623 952 004626 953 004636 954 004640 955 004642 957 004645 958 004647 959 004651 960 004701 961 004711 962 004714 964 004723 967 004734 968 004740 969 004743 970 004746 971 004751 972 004761 973 004763 974 004765 975 004767 976 004772 977 005022 978 005024 979 005026 980 005027 981 005032 985 005041 989 005072 990 005121 992 005132 994 005141 996 005150 999 005177 1000 005226 1002 005237 1004 005246 1006 005255 1009 005304 1010 005333 1012 005344 1014 005353 1016 005362 1019 005411 1020 005440 1023 005451 1026 005460 1028 005467 1031 005516 1032 005545 1035 005556 1037 005565 1039 005574 1046 005634 1048 005723 1051 005732 1053 005775 1055 006001 1056 006004 1057 006005 1061 006014 1064 006023 1069 006055 1070 006117 612 006126 626 006127 627 006131 629 006132 632 006133 633 006135 635 006136 638 006137 640 006141 643 006145 644 006174 645 006200 647 006201 649 006205 650 006207 651 006240 653 006247 655 006250 657 006260 659 006262 660 006337 662 006345 663 006346 664 006400 666 006402 669 006413 671 006417 673 006420 675 006436 676 006502 678 006504 680 006516 682 006530 684 006535 685 006536 687 006541 689 006542 692 006543 693 006545 695 006546 698 006547 699 006551 701 006552 704 006553 705 006615 707 006620 710 006626 713 006630 717 006667 719 006700 726 006704 728 006713 729 006715 730 006747 731 006750 733 006757 735 006763 736 006765 738 006774 739 006776 740 007030 742 007031 744 007077 746 007136 749 007177 751 007202 753 007257 756 007260 771 007301 772 007304 774 007320 776 007325 777 007355 779 007360 781 007364 782 007366 784 007371 786 007372 788 007450 791 007453 792 007463 796 007532 797 007534 798 007562 799 007564 ----------------------------------------------------------- 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