THIS FILE IS DAMAGED ror_$fm_too_many_openings 290 fixed bin (35) ext; 291 dcl dm_error_$fm_xring_brackets_mismatch 292 fixed bin (35) ext; 293 dcl dm_error_$programming_error 294 fixed bin (35) ext; 295 dcl error_table_$bigarg fixed bin (35) ext; 296 dcl error_table_$invalid_ring_brackets 297 fixed bin (35) ext; 298 dcl error_table_$namedup fixed bin (35) ext; 299 dcl error_table_$noentry fixed bin (35) ext; 300 dcl error_table_$not_dm_ring 301 fixed bin (35) ext; 302 dcl error_table_$not_seg_type 303 fixed bin (35) ext; 304 dcl error_table_$no_r_permission 305 fixed bin (35) ext; 306 307 dcl sys_info$data_management_ringno 308 fixed bin ext; 309 310 311 /* External Entries */ 312 313 dcl before_journal_manager_$write_fm_rollback_handler 314 entry (bit (36) aligned, bit (36) aligned, 315 ptr, fixed bin, fixed bin (27), 316 fixed bin (71), fixed bin (35)); 317 dcl cu_$level_get entry (fixed bin); 318 dcl cu_$level_set entry (fixed bin); 319 dcl dm_misc_util_$log entry options (variable); 320 dcl expand_pathname_ entry (char (*), char (*), char (*), 321 fixed bin (35)); 322 dcl fm_error_util_$signal entry options (variable); 323 dcl fm_error_util_$get_code 324 entry () returns (fixed bin (35)); 325 dcl fm_get_$internal_get entry (bit (36) aligned, uns fixed bin (24), 326 ptr, fixed bin (35)); 327 dcl fm_put_$internal_put entry (bit (36) aligned, uns fixed bin (24), 328 ptr, fixed bin (35)); 329 dcl fm_sys_pn_tbl_util_$insert 330 entry (bit (36) aligned, char (*), ptr, 331 fixed bin (17)); 332 dcl fm_validate_$get_ring_brackets 333 entry (char (*), char (*), (2) fixed bin (3), 334 fixed bin (35)); 335 dcl get_group_id_$tag_star entry () returns (char (32)); 336 dcl get_ring_ entry () returns (fixed bin (3)); 337 dcl hcs_$add_dir_acl_entries 338 entry (char (*), char (*), ptr, fixed bin, 339 fixed bin (35)); 340 dcl hcs_$chname_seg entry (ptr, char (*), char (*), 341 fixed bin (35)); 342 dcl hcs_$get_uid_seg entry (ptr, bit (36) aligned, fixed bin (35)) 343 ; 344 dcl hcs_$list_inacl entry (char (*), char (*), ptr, ptr, ptr, 345 fixed bin, fixed bin (3), fixed bin (35)); 346 dcl hcs_$set_bc entry (char (*), char (*), fixed bin (24), 347 fixed bin (35)); 348 dcl hcs_$set_bc_seg entry (ptr, fixed bin (24), fixed bin (35)); 349 dcl hcs_$set_dir_ring_brackets 350 entry (char (*), char (*), (2) fixed bin (3), 351 fixed bin (35)); 352 dcl hcs_$set_ring_brackets entry (char (*), char (*), (3) fixed bin (3), 353 fixed bin (35)); 354 dcl hcs_$set_safety_sw entry (char (*), char (*), bit (1), 355 fixed bin (35)); 356 dcl hcs_$set_synchronized_sw 357 entry (char (*), char (*), bit aligned, 358 fixed bin (35)); 359 dcl ioa_$rsnnl entry () options (variable); 360 dcl lock_manager_$lock entry (bit (36) aligned, fixed bin (27), 361 fixed bin, fixed bin (71), fixed bin, 362 fixed bin (35)); 363 dcl msf_manager_$acl_add entry (ptr, ptr, fixed bin, fixed bin (35)); 364 dcl msf_manager_$acl_delete 365 entry (ptr, ptr, fixed bin, fixed bin (35)); 366 dcl msf_manager_$close entry (ptr); 367 dcl msf_manager_$msf_get_ptr 368 entry (ptr, fixed bin, bit (1), ptr, 369 fixed bin (24), fixed bin (35)); 370 dcl msf_manager_$open entry (char (*), char (*), ptr, 371 fixed bin (35)); 372 dcl pathname_ entry (char (*), char (*)) 373 returns (char (168)); 374 dcl signal_ entry () options (variable); 375 dcl transaction_manager_$abort_txn 376 entry (bit (36) aligned, fixed bin (35)); 377 378 /* END OF DECLARATIONS */ 379 380 /* DESCRIPTION OF fm_create_open_$create_open: 381* 382* This entry creates a Data Management file and opens that file, 383* returing the opening id of the file to the caller. The file is 384* identified by pathname, p_dir_path and p_entry_name. Attributes of 385* the file are specified in the file_create_info structure, pointed to 386* by the p_file_create_info_ptr parameter. This parameter may be null, 387* in which case a series of default values are used. 388* 389* Data Management files are MSFs with special values for two storage 390* system attributes: an add-name on component 0 and the bit count on 391* component 0. The add-name on component has the canonical value held in the 392* constant DM_FILE_VALIDATION_NAME. This is used to validate that an 393* apparent MSF is in reality a DM file without having to access the file or 394* invoke any code which would cause Data Management to be initialized in the 395* process. The bit count on component has a value which is the encoded 396* representation of the extended ring brackets of the file. The bit count is 397* used for the same reasons as the add-name. The extended ring brackets are 398* also stored in the file attributes for verification, and always takes 399* precedence over the encoded ring brackets, should they differ. The 400* encoding function is contained in the internal subroutine 401* ENCODE_RING_BRACKETS. The encoded ring brackets in the bit count are 402* preserved as long as msf_manager_$adjust is not called to adjust the 403* file MSF, and the Data Management system does not do so. The extended 404* ring brackets must satisfy the constraints: 405* max(DM-ring, caller-validation-level) <= write bracket <= read bracket 406* 407* The actual ring brackets recognized by the file system are set so 408* that only code in the DM ring can manipulate the contents of a file. 409* The file's MSF directory ring brackets are both set to the DM ring, which 410* is also the current ring of execution. In this module, the DM ring, the 411* ring fo excution and the current validation level (CVL) are all the same. 412* So the file's MSF directory has ring brackets CVL, CVL. The ring brackets 413* on component 0 of the file's MSF are CVL, RB, RB, where RB is the specified 414* or default extended read bracket. This is to allow processes to directly 415* read the contents of a file rather than obtaining local copies of file data. 416* The ring brackets on component 0 are propogated to all components. 417* 418* Data Management files are uniquely indentified by the file system 419* unique id of component 0 of the file's MSF. 420* 421* If the file is to be protected (the default case), some special 422* conditions exist. First, a transaction must be in progress. If not, 423* dm_error_$no_current_transaction is returned. Second, rw access to the 424* file is granted to Data_Management.Daemon. This allows the daemon to 425* rollback modifications to the file if a transaction does not complete 426* successfully. Third, the creation of the file is also protected. 427* 428**/ 429 /* 430*create_open: 431* entry (p_dir_path, p_entry_name, p_file_create_info_ptr, p_output_file_oid, p_code); 432**/ 433 434 call INIT; 435 create_sw = "1"b; 436 437 go to CREATE_OPEN_JOIN; 438 439 /* DESCRIPTION OF fm_create_open_$open: 440* 441* This entry opens a DM file, returning an opening id for the file. 442* The file is identified by pathname, p_dir_path and p_entry_name. The 443* opening id is in p_output_file_oid. Opening a file consists of inserting 444* its pathname in the sys_pn_tbl so that, if necessary, a different process 445* can find it during a rollback, and setting up a file_access_info 446* structure as an entry in the file_access_table. This is per-process 447* information, the information for it retrieved from the file_attributes 448* stored in control interval 0 of the file. 449**/ 450 451 open: 452 entry (p_dir_path, p_entry_name, p_output_file_oid, p_code); 453 454 call INIT; 455 create_sw = "0"b; 456 457 go to CREATE_OPEN_JOIN; 458 459 CREATE_OPEN_JOIN: 460 unspec (my_file_oid) = ""b; /* set for FINISH */ 461 462 on fm_sub_error_ call RETURN (fm_error_util_$get_code ()); 463 464 p_output_file_oid = ""b; 465 dir_path = p_dir_path; 466 entry_name = rtrim (p_entry_name); 467 if entry_name ^= p_entry_name 468 then call ERROR_RETURN (error_table_$bigarg, 469 " The entry name argument is longer than 32 characters. ^a^s", 470 p_entry_name, ""); /* Subroutines will check the length of file_pathname */ 471 file_pathname = pathname_ (dir_path, entry_name); 472 473 unspec (my_file_access_info) = ""b; 474 my_file_access_info.msf_ptr = null (); 475 476 /* Validate the file and get its extended ring brackets. If we are */ 477 /* are creating the file we expect to get the code error_table_$noentry. */ 478 /* However, if the file already exists, (code = 0), do not abort as we */ 479 /* still have to open the file. The extended ring brackets are those */ 480 /* that are encoded in the bit count of the first component of the file. */ 481 /* We get them so that we can verify their correctness later when we get */ 482 /* the file attributes. The call is made now because fm_validate_ expects*/ 483 /* the validation level to be the caller's validation level. The */ 484 /* validation level will be changed to the data management ring shortly. */ 485 486 call fm_validate_$get_ring_brackets (dir_path, entry_name, 487 extended_ring_brackets, code); 488 if create_sw 489 then if code ^= 0 490 then 491 do; 492 if code = error_table_$noentry 493 then code = 0; 494 else if code = error_table_$not_seg_type 495 then call ERROR_RETURN (error_table_$namedup, " ^a^s", 496 file_pathname, ""); 497 else call ERROR_RETURN (code, " ^a^s.", file_pathname, ""); 498 end; 499 else /* code already equal to 0 */ 500 ; 501 else if code ^= 0 502 then if code = error_table_$noentry 503 then call RETURN (code); 504 else call ERROR_RETURN (code, " ^a^s.", file_pathname, ""); 505 else /* code = 0 */ 506 ; 507 508 /* Save the caller's validation level. It will be needed later to restore */ 509 /* the validation level to the caller's. Set the validation level to the */ 510 /* current ring of execution, i.e., the data management ring, so that */ 511 /* the process is in an appropriately priviledged state. */ 512 513 call cu_$level_get (saved_validation_level); 514 on cleanup call FINISH (); 515 current_validation_level = get_ring_ (); 516 call cu_$level_set (current_validation_level); 517 518 call msf_manager_$open (dir_path, entry_name, msf_fcb_ptr, code); 519 if msf_fcb_ptr = null () 520 then call ERROR_RETURN (code, " Returned by msf_manager_$open (^a).", 521 pathname_ (dir_path, entry_name), ""); 522 523 524 525 if create_sw & code = error_table_$noentry 526 then 527 CREATE: 528 do; 529 file_already_exists = "0"b; 530 531 /* Set up and verify the local my_file_create_info. A local copy is */ 532 /* used for efficiency. If the caller supplied a file_create_info */ 533 /* it is copied; otherwise a default my_create_info is used. The */ 534 /* non-zero default value is the protected flag, which defaults to */ 535 /* on. */ 536 537 if p_file_create_info_ptr ^= null () 538 then my_create_info = p_file_create_info_ptr -> file_create_info; 539 else 540 do; 541 unspec (my_create_info) = ""b; 542 my_create_info.version = FILE_CREATE_INFO_VERSION_2; 543 my_create_info.protected = "1"b; 544 end; 545 546 if my_create_info.version ^= FILE_CREATE_INFO_VERSION_2 547 then call ERROR_RETURN (dm_error_$bad_file_cr_info_ver, 548 " Supplied version was ^a. It should have been ^a.", 549 (my_create_info.version), (FILE_CREATE_INFO_VERSION_2)); 550 551 if my_create_info.mbz_1 ^= ""b | unspec (my_create_info.mbz_2) ^= ""b 552 | unspec (my_create_info.mbz_3) ^= ""b 553 then call ERROR_RETURN (dm_error_$file_cr_info_mbz_nz, "", "", ""); 554 555 if my_create_info.ci_size_in_bytes = 0 556 then my_create_info.ci_size_in_bytes = DEFAULT_CI_SIZE_IN_BYTES; 557 558 if my_create_info.ci_size_in_bytes ^= DEFAULT_CI_SIZE_IN_BYTES 559 then call ERROR_RETURN (dm_error_$bad_file_cr_ci_size, 560 " File_create_info.ci_size_in_bytes was ^a. It should have been ^a.", 561 char (my_create_info.ci_size_in_bytes), 562 char (DEFAULT_CI_SIZE_IN_BYTES)); 563 564 if my_create_info.blocking_factor = 0 565 then my_create_info.blocking_factor = 255; 566 567 if my_create_info.blocking_factor ^= 64 568 & my_create_info.blocking_factor ^= 255 569 then call ERROR_RETURN (dm_error_$bad_file_cr_blocking_factor, 570 " Supplied blocking_factor was ^a. It should have been 64 or 255.", 571 char (my_create_info.blocking_factor), ""); 572 573 if my_create_info.ring_brackets (FCI_WRITE_BRACKET_IDX) = 0 574 then my_create_info.ring_brackets (FCI_WRITE_BRACKET_IDX) = 575 max (current_validation_level, saved_validation_level); 576 if my_create_info.ring_brackets (FCI_READ_BRACKET_IDX) = 0 577 then my_create_info.ring_brackets (FCI_READ_BRACKET_IDX) = 578 max (current_validation_level, saved_validation_level); 579 lowest_ring_bracket = 580 max (current_validation_level, saved_validation_level); 581 if my_create_info.ring_brackets (FCI_WRITE_BRACKET_IDX) 582 < lowest_ring_bracket 583 | my_create_info.ring_brackets (FCI_WRITE_BRACKET_IDX) > 7 584 | my_create_info.ring_brackets (FCI_READ_BRACKET_IDX) 585 < lowest_ring_bracket 586 | my_create_info.ring_brackets (FCI_READ_BRACKET_IDX) > 7 587 | my_create_info.ring_brackets (FCI_READ_BRACKET_IDX) 588 < my_create_info.ring_brackets (FCI_WRITE_BRACKET_IDX) 589 then call ERROR_RETURN (error_table_$invalid_ring_brackets, 590 " The supplied ring_brackets were ^a,^a.", 591 char (my_create_info.ring_brackets (FCI_WRITE_BRACKET_IDX)), 592 char (my_create_info.ring_brackets (FCI_READ_BRACKET_IDX))); 593 594 /* Now set the values in file_attributes from those in my_create_info. */ 595 596 file_attributes_ptr = addr (my_file_attributes); 597 unspec (file_attributes) = ""b; 598 file_attributes.version = FILE_ATTRIBUTES_VERSION_2; 599 file_attributes.ci_size_in_bytes = my_create_info.ci_size_in_bytes; 600 file_attributes.blocking_factor = my_create_info.blocking_factor; 601 file_attributes.flags.protected = my_create_info.protected; 602 if my_create_info.protected 603 then 604 do; 605 file_attributes.no_concurrency = my_create_info.no_concurrency; 606 file_attributes.no_rollback = my_create_info.no_rollback; 607 end; 608 file_attributes.ring_brackets.write = 609 my_create_info.ring_brackets (FCI_WRITE_BRACKET_IDX); 610 file_attributes.ring_brackets.read = 611 my_create_info.ring_brackets (FCI_READ_BRACKET_IDX); 612 613 614 /* If the file is to be protected, verify that a transaction is in progress. */ 615 /* Also, give Data_Management.Daemon access to the containing directory if */ 616 /* the containing directory is not the process directory. */ 617 618 if file_attributes.flags.protected 619 then 620 do; 621 if dm_data_$current_txn_id = ""b 622 then call RETURN (dm_error_$no_current_transaction); 623 624 if substr (dir_path, 1, 4) ^= ">pdd" 625 & substr (dir_path, 1, 16) ^= ">process_dir_dir" 626 then call GIVE_DAEMON_ACCESS_TO_CONTAINING_DIR (dir_path); 627 end; 628 629 /* Now create the MSF by getting a pointer to the first component. */ 630 631 call msf_manager_$msf_get_ptr (msf_fcb_ptr, 0, CREATE_MSF, seg_0_ptr, 632 (0), code); 633 if seg_0_ptr = null () 634 then call ERROR_RETURN (code, 635 " Returned by msf_manager_$msf_get_ptr for component 0 of ^a.", 636 pathname_ (dir_path, entry_name), ""); 637 638 /* Get the uid of the file, the same as the uid of the first component. */ 639 640 call hcs_$get_uid_seg (seg_0_ptr, seg_0_uid, code); 641 if code ^= 0 642 then call ERROR_RETURN (code, 643 " Unable to get the Multics file system uid of ^a.", 644 pathname_ (pathname_ (dir_path, entry_name), "0"), ""); 645 646 file_attributes.unique_id = seg_0_uid; 647 my_file_access_info.uid = seg_0_uid; 648 649 /* Reserve an entry in the file_access_table. */ 650 651 my_file_access_info.state.entry_state = FILE_ACCESS_INFO_IN_USE; 652 my_file_access_info.state.file_state = FILE_EXISTS; 653 654 call ADD_FILE_ACCESS_TABLE_ENTRY (); /* This sets my_file_oid */ 655 656 /* Setup for possible rollback of the file creation. */ 657 /* The rollback handler requires the unique id of the file, its pathame and */ 658 /* index in the sys_pn_tbl and its opening id. */ 659 660 if file_attributes.flags.protected & ^file_attributes.flags.no_rollback 661 then 662 do; 663 on transaction_bj_full_ goto TRANSACTION_BJ_FULL_HANDLER; 664 call fm_sys_pn_tbl_util_$insert (seg_0_uid, file_pathname, seg_0_ptr, 665 sys_pn_tbl_index); 666 my_create_rollback_info.header.version = ROLLBACK_INFO_VERSION_1; 667 my_create_rollback_info.header.operation = CREATE_ROLLBACK_OPERATION; 668 my_create_rollback_info.sys_pn_tbl_index = sys_pn_tbl_index; 669 my_create_rollback_info.dir_path = dir_path; 670 my_create_rollback_info.file_name = entry_name; 671 call before_journal_manager_$write_fm_rollback_handler (seg_0_uid, 672 unspec (my_file_oid), addr (my_create_rollback_info), 673 size (my_create_rollback_info) * BYTES_PER_WORD, NO_CI_HELD, 674 time_stamp, code); 675 if code ^= 0 676 then call ERROR_RETURN (code, 677 " Unable to write rollback handler while creating ^a.", 678 pathname_ (dir_path, entry_name), ""); 679 end; 680 681 /* Convert MSF into a Data Management file */ 682 683 /* Add a canonical name to the first component of the MSF to indicate */ 684 /* that this is a Data Management file. */ 685 686 call hcs_$chname_seg (seg_0_ptr, "" /* don't remove a name */, 687 DM_FILE_VALIDATION_NAME, code); 688 if code ^= 0 689 then call ERROR_RETURN (code, " Unable to add ^a to ^a.", 690 DM_FILE_VALIDATION_NAME, pathname_ (file_pathname, "0")); 691 692 /* Set the extended ring brackets on the file. This is done by encoding the */ 693 /* specified ring brackets into one value, and setting the bit count of the */ 694 /* first component to that value. */ 695 696 encoded_ring_brackets = 697 ENCODE_RING_BRACKETS ((file_attributes.ring_brackets.write), 698 (file_attributes.ring_brackets.read)); 699 700 call hcs_$set_bc_seg (seg_0_ptr, encoded_ring_brackets, code); 701 if code ^= 0 702 then call ERROR_RETURN (code, " Could not set the bit count on ^a.", 703 pathname_ (file_pathname, "0"), ""); 704 705 /* Set the actual ring brackets on the MSF directory and first MSF component.*/ 706 707 dir_ring_brackets (1) = current_validation_level; 708 dir_ring_brackets (2) = current_validation_level; 709 710 call hcs_$set_dir_ring_brackets (dir_path, entry_name, dir_ring_brackets, 711 code); 712 if code ^= 0 713 then call ERROR_RETURN (code, " Attempting to set ring brackets on ^a.", 714 pathname_ (dir_path, entry_name), ""); 715 716 ring_brackets (1) = current_validation_level; 717 ring_brackets (2) = file_attributes.ring_brackets.read; 718 ring_brackets (3) = file_attributes.ring_brackets.read; 719 720 call hcs_$set_ring_brackets (file_pathname, FIRST_COMPONENT_NAME, 721 ring_brackets, code); 722 if code ^= 0 723 then call ERROR_RETURN (code, " Attempting to set ring brackets on ^a.", 724 pathname_ (file_pathname, FIRST_COMPONENT_NAME), ""); 725 726 /* Ensure that future components' ring brackets will be set correctly by */ 727 /* closing and re-opening the MSF. This resets fcb.rbs to the new values. */ 728 729 call msf_manager_$close (msf_fcb_ptr); /* Reset fcb.rbs */ 730 call msf_manager_$open (dir_path, entry_name, msf_fcb_ptr, code); 731 if code ^= 0 732 then call ERROR_RETURN (code, 733 " Unable to re-open ^a after setting ring_brackets.", 734 pathname_ (dir_path, entry_name), ""); 735 seg_0_ptr = null; /* Reset the seg_0_ptr - it was terminated by msf_manager_$close */ 736 call msf_manager_$msf_get_ptr (msf_fcb_ptr, 0, DONT_CREATE_MSF, 737 seg_0_ptr, (0), code); 738 if seg_0_ptr = null () 739 then call ERROR_RETURN (code, 740 " Unable to get pointer for component 0 of ^a.", 741 pathname_ (dir_path, entry_name), ""); 742 743 /* Set the safety switch on the file (MSF directory). */ 744 745 call hcs_$set_safety_sw (dir_path, entry_name, "1"b, code); 746 if code ^= 0 747 then call ERROR_RETURN (code, 748 " Unable to turn on the safety switch of ^a.", 749 pathname_ (dir_path, entry_name), ""); 750 751 call ADJUST_IACL (dir_path, entry_name, (current_validation_level), 752 (file_attributes.ring_brackets.write), msf_fcb_ptr); 753 754 /* Because of a bug in the msf_manager_, we must explicitly add an ACL */ 755 /* term for the creator in order to carry the term to new components. Also,*/ 756 /* if the protected attribute is in force, add the Data Management daemon */ 757 /* to the access control list such that it is able to access the file for */ 758 /* rollback. */ 759 760 unspec (my_msf_acl_list) = ""b; 761 number_of_msf_acl_terms = 1; 762 my_msf_acl_list (1).access_name = get_group_id_$tag_star (); 763 my_msf_acl_list (1).mode = RW_ACCESS; 764 if file_attributes.flags.protected 765 then 766 do; 767 number_of_msf_acl_terms = 2; 768 my_msf_acl_list (2).access_name = dm_system_data_$initializer_name; 769 my_msf_acl_list (2).mode = RW_ACCESS; 770 end; 771 call msf_manager_$acl_add (msf_fcb_ptr, addr (my_msf_acl_list), 772 number_of_msf_acl_terms, code); 773 if code ^= 0 774 then 775 do msf_acl_list_idx = 1 to number_of_msf_acl_terms; 776 if my_msf_acl_list (msf_acl_list_idx).status_code ^= 0 777 then code = my_msf_acl_list (msf_acl_list_idx).status_code; 778 call ERROR_RETURN (code, 779 " Unable to add 'rw' acl term to ^a for ^a.", file_pathname, 780 (my_msf_acl_list (msf_acl_list_idx).access_name)); 781 end; 782 783 784 /* Fill in the file_access_info entry for this file for this process and add */ 785 /* it to the file_access_table. The file_access_info is roughly similar */ 786 /* to opening information or an MSF fcb. */ 787 788 my_file_access_info.seg_0_num = baseno (seg_0_ptr); 789 my_file_access_info.blocking_factor = file_attributes.blocking_factor; 790 my_file_access_info.msf_ptr = msf_fcb_ptr; 791 msf_fcb_ptr = null (); 792 my_file_access_info.ring_brackets.write = 793 file_attributes.ring_brackets.write; 794 my_file_access_info.ring_brackets.read = 795 file_attributes.ring_brackets.read; 796 797 do file_access_table_idx = lbound (file_access_table.e, 1) 798 to file_access_table.h.last_entry; 799 if file_access_table.e (file_access_table_idx).seg_0_num 800 = my_file_access_info.seg_0_num 801 & file_access_table.e (file_access_table_idx).state.entry_state 802 ^= 0 803 then 804 do; /* unexpected dl */ 805 unspec (file_access_table.e (file_access_table_idx).seg_0_num) = 806 ""b; 807 file_access_table.e (file_access_table_idx).msf_ptr = null (); 808 do idx = lbound (my_file_access_info.seg_nums, 1) 809 to hbound (my_file_access_info.seg_nums, 1); 810 unspec (file_access_table.e (file_access_table_idx) 811 .seg_nums (idx)) = ""b; 812 end; 813 end; 814 end; 815 816 my_file_access_info.integrity_switches.record_time_modified = "1"b; 817 my_file_access_info.integrity_switches.transaction = 818 file_attributes.flags.protected; 819 my_file_access_info.integrity_switches.lock = 820 my_file_access_info.integrity_switches.transaction 821 & ^file_attributes.flags.no_concurrency; 822 my_file_access_info.integrity_switches.bj = 823 my_file_access_info.integrity_switches.transaction 824 & ^file_attributes.flags.no_rollback; 825 826 if my_file_access_info.integrity_switches.lock 827 then 828 do; 829 call lock_manager_$lock (my_file_access_info.uid, LOCK_ENTIRE_FILE, 830 LOCK_MODE_X, 1e9, (0), code); 831 if code ^= 0 832 then call ERROR_RETURN (code, 833 " Unable to lock file ^a, with file uid ^a, exclusively.", 834 file_pathname, char (my_file_access_info.uid)); 835 end; 836 837 if my_file_access_info.integrity_switches.bj 838 then 839 do; 840 call hcs_$set_synchronized_sw (file_pathname, "0", "1"b, code); 841 if code ^= 0 842 then 843 do; 844 if code = error_table_$not_dm_ring 845 & sys_info$data_management_ringno ^= get_ring_ () 846 then code = 0; 847 else call ERROR_RETURN (code, 848 " Unable to turn on the synchronized switch of ^a.", 849 pathname_ (pathname_ (dir_path, entry_name), "0"), ""); 850 end; 851 end; 852 853 file_attributes.date_time_created = clock (); 854 file_attributes.length_of_attributes = 4 * size (file_attributes) - 2; 855 856 call INIT_ATTR_CI_PARTS (addr (my_attr_ci_parts), file_attributes_ptr); 857 858 if my_attr_ci_parts.part (1).length_in_bytes 859 ^= file_attributes.length_of_attributes + 2 860 then call ERROR_RETURN (dm_error_$programming_error, 861 " The length of the file attributes, ^a, and the length of the ci_part, ^a, used to store the attributes differ.", 862 char (file_attributes.length_of_attributes + 2), 863 char (my_attr_ci_parts.part (1).length_in_bytes)); 864 865 my_file_access_info.pn_tbl_idx = sys_pn_tbl_index; 866 my_file_access_info.opens = 1; 867 868 file_access_table.e (my_file_oid.file_access_table_idx) = 869 my_file_access_info; 870 871 call fm_put_$internal_put (unspec (my_file_oid), 0, 872 addr (my_attr_ci_parts), code); 873 if code ^= 0 874 then call RETURN (code); 875 876 p_output_file_oid = unspec (my_file_oid); 877 unspec (my_file_oid) = ""b; /* must be set for FINISH */ 878 879 call RETURN (WITH_NO_ERRORS); 880 881 end CREATE; 882 883 /* if create_sw & code = error_table_$noentry */ 884 /* then CREATE: ... */ 885 886 else if code ^= 0 887 then call ERROR_RETURN (code, " ^a^s.", file_pathname, ""); 888 else 889 OPEN: 890 do; 891 if create_sw 892 then file_already_exists = "1"b; 893 else file_already_exists = "0"b; 894 895 call msf_manager_$msf_get_ptr (msf_fcb_ptr, 0, DONT_CREATE_MSF, 896 seg_0_ptr, (0), code); 897 if seg_0_ptr = null () 898 then call ERROR_RETURN (code, " Unable to get pointer to ^a.^s", 899 pathname_ (file_pathname, "0"), ""); 900 901 /* Make sure that CI zero looks reasonable. */ 902 903 my_ci_header = seg_0_ptr -> ci_header; 904 905 if my_ci_header.stamp.version ^= CI_HEADER_STAMP_VERSION_1 906 | unspec (my_ci_header.id.size_code) ^= CI_SIZE_CODE_1024_WORDS 907 | my_ci_header.id.num ^= 0 | my_ci_header.id.uid = ""b 908 then call RETURN (dm_error_$file_not_dm_type); 909 910 my_file_access_info.blocking_factor = 255; 911 my_file_access_info.uid = my_ci_header.id.uid; 912 my_file_access_info.seg_0_num = baseno (seg_0_ptr); 913 914 /* SEE IF IT IS ALREADY IN THE PROCESS TABLE */ 915 916 do file_access_table_idx = lbound (file_access_table.e, 1) 917 to file_access_table.h.last_entry 918 while (file_access_table.e (file_access_table_idx).seg_0_num 919 ^= my_file_access_info.seg_0_num 920 | file_access_table.e (file_access_table_idx).state.entry_state = 0) 921 ; 922 end; 923 924 if file_access_table_idx <= file_access_table.h.last_entry 925 then 926 do; 927 if file_access_table.e (file_access_table_idx).uid 928 ^= my_file_access_info.uid 929 then 930 do; /* unexpected dl */ 931 unspec (file_access_table.e (file_access_table_idx).seg_0_num) = 932 ""b; 933 file_access_table.e (file_access_table_idx).msf_ptr = null (); 934 do idx = lbound (my_file_access_info.seg_nums, 1) 935 to hbound (my_file_access_info.seg_nums, 1); 936 unspec (file_access_table.e (file_access_table_idx) 937 .seg_nums (idx)) = ""b; 938 end; 939 end; 940 else 941 do; 942 call msf_manager_$close (msf_fcb_ptr); 943 msf_fcb_ptr = null (); 944 945 my_file_access_info = file_access_table.e (file_access_table_idx); 946 947 if my_file_access_info.opens >= MAXIMUM_NUMBER_OF_FILE_OPENINGS 948 then call ERROR_RETURN (dm_error_$fm_too_many_openings, 949 "For ^a^s.", file_pathname, ""); 950 else my_file_access_info.opens = my_file_access_info.opens + 1; 951 952 file_access_table.e (file_access_table_idx) = my_file_access_info; 953 954 my_file_oid.file_access_table_idx = file_access_table_idx; 955 my_file_oid.uid_tail = substr (my_file_access_info.uid, 19, 18); 956 957 p_output_file_oid = unspec (my_file_oid); 958 unspec (my_file_oid) = ""b; /* must be set for FINISH */ 959 960 if my_file_access_info.opens > 1 961 then call RETURN (dm_error_$file_already_open); 962 963 call RETURN (WITH_NO_ERRORS); 964 end; 965 end; 966 967 my_file_access_info.msf_ptr = msf_fcb_ptr; 968 msf_fcb_ptr = null (); /* don't cleanup */ 969 970 /* We will soon get the file_attributes by calling fm_get_$internal_get, */ 971 /* which relies on the information in file_access_info. All of the info */ 972 /* upon which it relies has already been set with the exception of the */ 973 /* read ring bracket, the value of which is not yet known. So that we can */ 974 /* get the file_attributes, set the read ring bracket to the current ring */ 975 /* of execution. Afterward, we will be able to set the ring bracket in */ 976 /* file_access_info to its true value. */ 977 978 my_file_access_info.ring_brackets.read = get_ring_ (); 979 980 /* Insert the file access info in the file_access_table, where it can be */ 981 /* found by fm_get_$internal_get. The entry in which the file access info */ 982 /* is placed is recorded in file_oid.file_access_table_idx. */ 983 984 my_file_access_info.state.entry_state = FILE_ACCESS_INFO_IN_USE; 985 my_file_access_info.state.file_state = FILE_EXISTS; 986 call ADD_FILE_ACCESS_TABLE_ENTRY (); 987 988 /* Now, actually get the file_attributes from control interval 0. */ 989 990 unspec (my_file_attributes) = ""b; 991 file_attributes_ptr = addr (my_file_attributes); 992 993 call INIT_ATTR_CI_PARTS (addr (my_attr_ci_parts), file_attributes_ptr); 994 995 call fm_get_$internal_get (unspec (my_file_oid), 0, 996 addr (my_attr_ci_parts), code); 997 if code ^= 0 998 then call RETURN (code); 999 1000 /* Verify the consistency of the values in the file_attributes structure. */ 1001 1002 if file_attributes.length_of_attributes 1003 ^= CI_ADDRESSABLE_LENGTH - CI_0_ADDRESSABLE_LENGTH - 2 1004 then call ERROR_RETURN (dm_error_$bad_file_atrs_length, 1005 " The file_attributes length " || rtrim (file_pathname) 1006 || " is ^a. It should be ^a.", 1007 char (file_attributes.length_of_attributes), 1008 char (CI_ADDRESSABLE_LENGTH - CI_0_ADDRESSABLE_LENGTH - 2)); 1009 1010 if file_attributes.version ^= FILE_ATTRIBUTES_VERSION_2 1011 then call ERROR_RETURN (dm_error_$bad_file_atrs_ver, 1012 " The version of the file attributes is ^a. It should be ^a.", 1013 (file_attributes.version), (FILE_ATTRIBUTES_VERSION_2)); 1014 1015 if file_attributes.unique_id ^= my_file_access_info.uid 1016 then call ERROR_RETURN (dm_error_$bad_file_atrs_uid, 1017 " The unique identifier in the file attributes of " 1018 || rtrim (file_pathname) || " is ^a. The UID in CI 0 is ^a.", 1019 char (file_attributes.unique_id), 1020 char (my_file_access_info.uid)); 1021 1022 if file_attributes.ring_brackets.write 1023 ^= extended_ring_brackets (FCI_WRITE_BRACKET_IDX) 1024 | file_attributes.ring_brackets.read 1025 ^= extended_ring_brackets (FCI_READ_BRACKET_IDX) 1026 then 1027 do; /* Stored and encoded ring brackets are out of synch. Try to */ 1028 /* resynch them. If unsuccessful, it is safe to continue. */ 1029 call dm_misc_util_$log (LOG_SV, dm_error_$fm_xring_brackets_mismatch, 1030 MYNAME, 1031 " The stored ring brackets for ^a are ^d,^d, the encoded are ^d,^d.", 1032 file_pathname, file_attributes.ring_brackets.write, 1033 file_attributes.ring_brackets.read, 1034 extended_ring_brackets (FCI_WRITE_BRACKET_IDX), 1035 extended_ring_brackets (FCI_READ_BRACKET_IDX)); 1036 1037 encoded_ring_brackets = 1038 ENCODE_RING_BRACKETS ((file_attributes.ring_brackets.write), 1039 (file_attributes.ring_brackets.read)); 1040 call hcs_$set_bc (dir_path, entry_name, encoded_ring_brackets, code); 1041 if code ^= 0 1042 then call dm_misc_util_$log (LOG_SV, code, MYNAME, 1043 " Could not resynch extended ring brackets for ^a.", 1044 file_pathname); 1045 else call dm_misc_util_$log (INFORM_SV, 0, MYNAME, 1046 " Resynched ring brackets for ^a.", file_pathname); 1047 end; 1048 1049 my_file_access_info.ring_brackets.write = 1050 file_attributes.ring_brackets.write; 1051 my_file_access_info.ring_brackets.read = 1052 file_attributes.ring_brackets.read; 1053 1054 if my_file_access_info.ring_brackets.read < saved_validation_level 1055 then call RETURN (error_table_$no_r_permission); 1056 1057 if file_attributes.flags.protected & ^file_attributes.flags.no_rollback 1058 then call fm_sys_pn_tbl_util_$insert (file_attributes.unique_id, 1059 file_pathname, seg_0_ptr, sys_pn_tbl_index); 1060 1061 my_file_access_info.blocking_factor = file_attributes.blocking_factor; 1062 my_file_access_info.integrity_switches.record_time_modified = "1"b; 1063 my_file_access_info.integrity_switches.transaction = 1064 file_attributes.flags.protected; 1065 my_file_access_info.integrity_switches.lock = 1066 my_file_access_info.integrity_switches.transaction 1067 & ^file_attributes.flags.no_concurrency; 1068 my_file_access_info.integrity_switches.bj = 1069 my_file_access_info.integrity_switches.transaction 1070 & ^file_attributes.flags.no_rollback; 1071 my_file_access_info.pn_tbl_idx = sys_pn_tbl_index; 1072 my_file_access_info.opens = 1; 1073 1074 file_access_table.e (file_access_table_idx) = my_file_access_info; 1075 1076 p_output_file_oid = unspec (my_file_oid); 1077 unspec (my_file_oid) = ""b; /* must be set for FINISH */ 1078 1079 if file_already_exists 1080 then call RETURN (dm_error_$file_already_exists); 1081 else call RETURN (WITH_NO_ERRORS); 1082 1083 end OPEN; 1084 1085 /* All returns from the main procedure go through this statement. */ 1086 1087 MAIN_RETURN: 1088 return; 1089 1090 TRANSACTION_BJ_FULL_HANDLER: 1091 /**** Cannot call bj_report_err_ to do this since BJ cannot be called recursively. */ 1092 /**** See also fm_(delete_close put), which need to handle this condition. */ 1093 revert transaction_bj_full_; 1094 my_signal_structure.length = size (my_signal_structure); 1095 my_signal_structure.version = 1; 1096 string (my_signal_structure.action_flags) = "0"b; 1097 call ioa_$rsnnl ("Creating DM file UID ^w ^a", 1098 my_signal_structure.info_string, (0), seg_0_uid, 1099 pathname_ (dir_path, entry_name)); 1100 my_signal_structure.status_code = dm_error_$bj_journal_full; 1101 1102 call transaction_manager_$abort_txn (dm_data_$current_txn_id, code); 1103 call signal_ ("transaction_bj_full_", null (), addr (my_signal_structure)); 1104 call RETURN (dm_error_$bj_journal_full); /* should never get here */ 1105 1106 /* SUBROUTINES */ 1107 1108 RETURN: 1109 proc (r_p_code); 1110 1111 /* DESCRIPTION of RETURN: 1112* This routine is called to exit the main procedure. It is called in 1113* three cases: to return without errors, to return with a minor error 1114* which should not be logged, and to return from the fm_sub_error_ 1115* condition handler. 1116**/ 1117 1118 dcl r_p_code fixed bin (35); 1119 1120 p_code = r_p_code; 1121 call FINISH (); 1122 go to MAIN_RETURN; 1123 1124 end RETURN; 1125 1126 1127 ERROR_RETURN: 1128 proc (er_p_code, er_p_error_message, er_p_error_message_argument_1, 1129 er_p_error_message_argument_2); 1130 1131 /* DESCRIPTION of ERROR_RETURN: 1132* This routine is called to exit the main procedure when a major error 1133* has occurred requiring logging. It call fm_error_util_$signal, 1134* which logs the error message and signals fm_sub_error_. The condition 1135* is caught by fm_create_open_'s fm_sub_error_ handler, which returns 1136* by calling RETURN. 1137**/ 1138 1139 dcl er_p_code fixed bin (35) parameter; 1140 dcl (er_p_error_message, er_p_error_message_argument_1, 1141 er_p_error_message_argument_2) 1142 char (*) parameter; 1143 1144 call fm_error_util_$signal (er_p_code, MYNAME, 1145 (FM_ACTION_CANT_RESTART | FM_ACTION_LOG), LOG_SV, er_p_error_message, 1146 er_p_error_message_argument_1, er_p_error_message_argument_2); 1147 1148 end ERROR_RETURN; 1149 1150 1151 FINISH: 1152 proc; 1153 1154 1155 if msf_fcb_ptr ^= null () 1156 then call msf_manager_$close (msf_fcb_ptr); 1157 if saved_validation_level ^= -1 1158 then call cu_$level_set (saved_validation_level); 1159 if my_file_oid.file_access_table_idx > 0 1160 then file_access_table.e (my_file_oid.file_access_table_idx).state 1161 .entry_state = FILE_ACCESS_INFO_NOT_IN_USE; 1162 1163 end FINISH; 1164 1165 INIT: 1166 proc; 1167 1168 /* THE LOGIC DOES NOT DEPEND ON THE INITIALIZATIONS BELOW */ 1169 1170 ci_header_ptr = null (); 1171 ci_trailer_ptr = null (); 1172 file_create_info_ptr = null (); 1173 1174 unspec (my_ci_header) = ""b; 1175 unspec (my_create_info) = ""b; 1176 unspec (my_file_attributes) = ""b; 1177 1178 /* THE LOGIC DOES NOT DEPEND ON THE INITIALIZATIONS ABOVE */ 1179 1180 end INIT; 1181 1182 INIT_ATTR_CI_PARTS: 1183 proc (iacp_p_ci_parts_ptr, iacp_p_local_ptr); 1184 1185 /* DESCRIPTION of INIT_ATTR_CI_PARTS: 1186* Initializes the ci_parts structure pointed to by iacp_p_ci_parts_ptr 1187* such that it has the correct offset and length for accessing the 1188* file_attributes in control interval 0. Sets the local_ptr in the 1189* ci_parts structure to iacp_p_local_ptr. This can be used to 1190* initialize the ci_parts structure for read or write. 1191**/ 1192 1193 dcl iacp_p_ci_parts_ptr ptr parameter; 1194 dcl iacp_p_local_ptr ptr parameter; 1195 1196 iacp_p_ci_parts_ptr -> ci_parts.number_of_parts = 1; 1197 iacp_p_ci_parts_ptr -> ci_parts.part (1).offset_in_bytes = 1198 CI_0_ADDRESSABLE_LENGTH; 1199 iacp_p_ci_parts_ptr -> ci_parts.part (1).length_in_bytes = 1200 CI_ADDRESSABLE_LENGTH - CI_0_ADDRESSABLE_LENGTH; 1201 iacp_p_ci_parts_ptr -> ci_parts.part (1).local_ptr = iacp_p_local_ptr; 1202 1203 return; 1204 1205 end INIT_ATTR_CI_PARTS; 1206 1207 ENCODE_RING_BRACKETS: 1208 proc (erb_p_write_bracket, erb_p_read_bracket) returns (fixed bin); 1209 1210 dcl erb_p_write_bracket fixed bin (3); 1211 dcl erb_p_read_bracket fixed bin (3); 1212 1213 return ((8 * erb_p_write_bracket + erb_p_read_bracket)); 1214 1215 end ENCODE_RING_BRACKETS; 1216 1217 ADD_FILE_ACCESS_TABLE_ENTRY: 1218 proc (); 1219 1220 1221 do file_access_table_idx = lbound (file_access_table.e, 1) 1222 to file_access_table.h.last_entry 1223 while (file_access_table.e (file_access_table_idx).state.entry_state 1224 ^= 0); 1225 end; 1226 1227 if file_access_table_idx > file_access_table.h.last_entry 1228 then 1229 do; 1230 if file_access_table.h.last_entry = hbound (file_access_table.e, 1) 1231 then call RETURN (dm_error_$fm_proc_tbl_full); 1232 file_access_table.h.last_entry = file_access_table_idx; 1233 end; 1234 1235 file_access_table.e (file_access_table_idx) = my_file_access_info; 1236 1237 my_file_oid.file_access_table_idx = file_access_table_idx; 1238 my_file_oid.uid_tail = substr (my_file_access_info.uid, 19, 18); 1239 1240 end ADD_FILE_ACCESS_TABLE_ENTRY; 1241 1242 GIVE_DAEMON_ACCESS_TO_CONTAINING_DIR: 1243 proc (gda_p_path); 1244 1245 dcl gda_p_path char (168) parm; 1246 1247 dcl gda_dir_path char (168); 1248 dcl gda_effective_mode fixed bin (5); 1249 dcl gda_entry_name char (32); 1250 1251 dcl 1 gda_dir_acl_list (1) aligned like general_acl_entry; 1252 1253 dcl hcs_$get_user_effmode entry (char (*), char (*), char (*), 1254 fixed bin, fixed bin (5), fixed bin (35)); 1255 1256 1257 call expand_pathname_ (gda_p_path, gda_dir_path, gda_entry_name, code); 1258 if code ^= 0 1259 then call ERROR_RETURN (code, " Unable to expand pathname ^a.^s.", 1260 gda_p_path, ""); 1261 1262 call hcs_$get_user_effmode (gda_dir_path, gda_entry_name, 1263 dm_system_data_$initializer_name, get_ring_ (), gda_effective_mode, 1264 code); 1265 if code ^= 0 1266 then call ERROR_RETURN (code, 1267 " Unable to determine the access of ^a to ^a.", 1268 dm_system_data_$initializer_name, 1269 pathname_ (gda_dir_path, gda_entry_name)); 1270 1271 if gda_effective_mode ^= SMA_ACCESS_BIN 1272 then 1273 do; 1274 unspec (gda_dir_acl_list) = ""b; 1275 gda_dir_acl_list (1).access_name = dm_system_data_$initializer_name; 1276 gda_dir_acl_list (1).mode = SMA_ACCESS; 1277 1278 call hcs_$add_dir_acl_entries (gda_dir_path, gda_entry_name, 1279 addr (gda_dir_acl_list), dim (gda_dir_acl_list, 1), code); 1280 if code ^= 0 1281 then 1282 do; 1283 if gda_dir_acl_list (1).status_code ^= 0 1284 then code = gda_dir_acl_list (1).status_code; 1285 call ERROR_RETURN (code, 1286 " Unable to add 'sma' directory acl term to ^a for ^a.", 1287 pathname_ (gda_dir_path, gda_entry_name), 1288 (gda_dir_acl_list (1).access_name)); 1289 end; 1290 end; 1291 1292 return; 1293 1294 1295 end GIVE_DAEMON_ACCESS_TO_CONTAINING_DIR; 1296 1297 ADJUST_IACL: 1298 proc (ai_p_dir_path, ai_p_entry, ai_p_validation_level, ai_p_write_bracket, 1299 ai_p_msf_fcb_ptr); 1300 dcl ai_p_dir_path char (*) parm; 1301 dcl ai_p_entry char (*) parm; 1302 dcl ai_p_validation_level fixed bin (3) parm; 1303 dcl ai_p_write_bracket fixed bin (3) parm; 1304 dcl ai_p_msf_fcb_ptr ptr parm; 1305 1306 dcl ai_acl_idx fixed bin init (0); 1307 dcl ai_code fixed bin (35) init (0); 1308 dcl 1 ai_delete_acl_array (ai_delete_acl_count) aligned 1309 based (ai_delete_acl_array_ptr) 1310 like general_delete_acl_entry; 1311 dcl ai_delete_acl_count fixed bin init (0); 1312 dcl ai_delete_acl_array_ptr 1313 ptr init (null ()); 1314 dcl ai_dir_dir char (168); 1315 dcl ai_dir_entry char (32); 1316 dcl ai_iacl_count fixed bin init (0); 1317 dcl 1 ai_iacl_array (ai_iacl_count) aligned 1318 based (ai_iacl_array_ptr) 1319 like segment_acl_entry; 1320 dcl ai_iacl_array_ptr ptr init (null ()); 1321 1322 on cleanup call AI_FINISH (); 1323 1324 call expand_pathname_ (ai_p_dir_path, ai_dir_dir, ai_dir_entry, ai_code); 1325 if ai_code ^= 0 1326 then call ERROR_RETURN (ai_code, 1327 "^/Unable to expand the pathname of the directory, ^a, which is to contain the new DM file.", 1328 ai_p_dir_path, ""); 1329 1330 1331 /* The IACLs applied by msf_manager_ at creation time are those for the ring 1332*of the validation level. However, the IACLs which should be applied are those 1333*for the ring of the write_bracket. Hence, it's necessary to delete the IACLs 1334*for the validation level, then apply the (adjusted) IACLs for the 1335*write_bracket ring. 1336**/ 1337 1338 call hcs_$list_inacl (ai_dir_dir, ai_dir_entry, dm_data_$area_ptr, 1339 ai_iacl_array_ptr, null (), ai_iacl_count, ai_p_validation_level, 1340 ai_code); 1341 if ai_code ^= 0 1342 then call ERROR_RETURN (ai_code, 1343 "^/Unable to list the initial segment ACL for ^a for the validation level ^a.", 1344 pathname_ (ai_dir_dir, ai_dir_entry), 1345 ltrim (char (ai_p_validation_level))); 1346 if ai_iacl_count > 0 1347 then 1348 do; 1349 ai_delete_acl_count = ai_iacl_count; 1350 alloc ai_delete_acl_array in (dm_area); 1351 do ai_acl_idx = 1 to ai_delete_acl_count; 1352 ai_delete_acl_array (ai_acl_idx).access_name = 1353 ai_iacl_array (ai_acl_idx).access_name; 1354 ai_delete_acl_array (ai_acl_idx).status_code = 0; 1355 end; 1356 1357 free ai_iacl_array; 1358 ai_iacl_array_ptr = null (); 1359 1360 call msf_manager_$acl_delete (ai_p_msf_fcb_ptr, ai_delete_acl_array_ptr, 1361 ai_delete_acl_count, ai_code); 1362 if ai_code ^= 0 1363 then call ERROR_RETURN (ai_code, 1364 "^/Unable to delete the IACLs for the validation level (^a) while creating ^a.", 1365 ltrim (char (ai_p_validation_level)), 1366 pathname_ (ai_p_dir_path, ai_p_entry)); 1367 free ai_delete_acl_array; 1368 ai_delete_acl_array_ptr = null (); 1369 end; 1370 1371 /* Add the IACL for the write_bracket ring, after first turning off any use of the "e" 1372*access bit. 1373**/ 1374 1375 call hcs_$list_inacl (ai_dir_dir, ai_dir_entry, dm_data_$area_ptr, 1376 ai_iacl_array_ptr, null (), ai_iacl_count, ai_p_write_bracket, ai_code) 1377 ; 1378 if ai_code ^= 0 1379 then call ERROR_RETURN (ai_code, 1380 "^/Unable to list the initial segment ACL for ^a for the write_bracket ring ^a.", 1381 pathname_ (ai_dir_dir, ai_dir_entry), 1382 ltrim (char (ai_p_write_bracket))); 1383 1384 do ai_acl_idx = 1 to ai_iacl_count; 1385 if (ai_iacl_array (ai_acl_idx).mode & E_ACCESS) 1386 then ai_iacl_array (ai_acl_idx).mode = 1387 ai_iacl_array (ai_acl_idx).mode & RW_ACCESS; 1388 end; 1389 1390 if ai_iacl_count > 0 1391 then 1392 do; 1393 call msf_manager_$acl_add (ai_p_msf_fcb_ptr, ai_iacl_array_ptr, 1394 ai_iacl_count, ai_code); 1395 if ai_code ^= 0 1396 then call ERROR_RETURN (ai_code, 1397 "^/Unable to add the ACL entries developed from the seg IACL with a set of those ACL terms with the ""e"" access removed while attempting to create ^a.", 1398 pathname_ (ai_p_dir_path, ai_p_entry), ""); 1399 end; 1400 1401 call AI_FINISH (); 1402 return; 1403 1404 AI_FINISH: 1405 proc (); 1406 if ai_iacl_array_ptr ^= null () 1407 then free ai_iacl_array; 1408 if ai_delete_acl_array_ptr ^= null () 1409 then free ai_delete_acl_array; 1410 end AI_FINISH; 1411 end ADJUST_IACL; 1412 1413 1414 /* ***************** START OF INCLUDE FILES ********************** */ 1415 1416 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 */ 1417 1418 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 */ 1419 1420 3 1 /* BEGIN INCLUDE FILE: dm_ci_header.incl.pl1 */ 3 2 3 3 /* DESCRIPTION: 3 4* 3 5* This include file contains various structures which make up the 3 6* header and trailer of a control interval. 3 7* 3 8* **** NOTE: The include file dm_ci.incl.pl1 is heavily dependent **** 3 9* **** on this include file. When changing this include file, **** 3 10* **** check dm_ci.incl.pl1 to see if it is affected. **** 3 11**/ 3 12 3 13 /* HISTORY: 3 14*Written by Jeffrey D. Ives, 03/02/82. 3 15* (Design by Andre Bensoussan and Jeffrey D. Ives) 3 16*Modified: 3 17*11/02/84 by Matthew Pierret: Re-organized so that dm_ci.incl.pl1 and 3 18* dm_ci_header.incl.pl1 do not duplicate structures or constants. 3 19**/ 3 20 3 21 /* format: style2,ind3 */ 3 22 3 23 /* ci_header is the first four words of a control interval. Its contents 3 24* are used to verify that a control interval is in an expected format, 3 25* to identify the control interval and the file to which the control 3 26* interval belongs, and to maintain information for the synchronization 3 27* of disk I/O between DM file control intervals and associated before 3 28* journal control intervals. The first two words are the time stamp for 3 29* synchronization; the latter two identify the control interval. */ 3 30 3 31 dcl ci_header_ptr ptr; 3 32 dcl 1 ci_header aligned based (ci_header_ptr), 3 33 2 stamp like ci_stamp, 3 34 2 id like ci_id; 3 35 3 36 /* ci_trailer is the last two words of a control interval and must match 3 37* the first two words (ci_header.stamp). */ 3 38 3 39 dcl ci_trailer_ptr ptr; 3 40 dcl 1 ci_trailer like ci_header.stamp aligned based (ci_trailer_ptr); 3 41 3 42 3 43 /* ci_stamp is a two-word date/time modified stamp, consisting of: 3 44* version: a 9-bit version string for the structure 3 45* bj_idx: before journal index for I/O synchronization 3 46* time_modified: Multics clock time of last modification */ 3 47 3 48 dcl 1 ci_stamp aligned based, 3 49 3 version bit (9) unal, 3 50 3 bj_idx fixed bin (9) uns unal, 3 51 3 time_modified fixed bin (53) unal; 3 52 3 53 dcl CI_HEADER_STAMP_VERSION_1 3 54 bit (9) aligned static options (constant) init ("641"b3); 3 55 3 56 /* ci_id is a two-word identification of the control interval, which 3 57* rarely changes and consists of: 3 58* uid: DM file unique identifier 3 59* size_code: the control interval size in bytes, in an encoded 3 60* form (see ci_size_code below). 3 61* num: the control interval number. 0 is the number of the first 3 62* control interval of a file. */ 3 63 3 64 dcl 1 ci_id aligned based, 3 65 3 uid bit (36), 3 66 3 size_code bit (9) unal, 3 67 3 num fixed bin (27) uns unal; 3 68 3 69 /* ci_size_code is the structure which defines the content of ci_id.size_code. 3 70* The size in bytes of a control interval is equal to 3 71* (2 ** ci_size_code.exponent * (64 + 8 * ci_size_code.addon)). */ 3 72 3 73 dcl 1 ci_size_code aligned based, 3 74 2 exponent fixed bin (6) uns unal, 3 75 2 addon fixed bin (3) uns unal; 3 76 3 77 /* ci_header_chunks is a structure which can be used to update the 3 78* ci_stamp or ci_id in one memory cycle. */ 3 79 3 80 dcl 1 ci_header_chunks aligned based (ci_header_ptr), 3 81 2 stamp fixed bin (71), 3 82 2 id fixed bin (71); 3 83 3 84 /* ci_trailer_chunk is a structure which can e used to update the 3 85* ci_trailer in one memory cycle. */ 3 86 3 87 dcl 1 ci_trailer_chunk aligned based, 3 88 2 stamp fixed bin (71); 3 89 3 90 3 91 /* END INCLUDE FILE: dm_ci_header.incl.pl1 */ 1421 1422 4 1 /* BEGIN INCLUDE FILE dm_ci_lengths.incl.pl1 */ 4 2 4 3 /* DESCRIPTION: 4 4* This include file contains constants which are the length in bytes 4 5* of the addressable portion of a control interval. The addressable portion 4 6* is that part of the control interval which callers of file_manager_ 4 7* may access, specifically, everything between the end of the control 4 8* interval header (ci_header) and the control interval trailer (ci_trailer). 4 9* Control interval 0 is slightly different, as it also contains an 4 10* unaddressable portion in which it maintains the file attributes. For 4 11* control interval 0 the addressable portion is everything between the end 4 12* of the control interval header and the beginning of the file attributes. 4 13**/ 4 14 4 15 /* HISTORY: 4 16*Written by Matthew Pierret, 11/02/84. 4 17*Modified: 4 18**/ 4 19 4 20 /* format: style2,ind3 */ 4 21 4 22 dcl CONTROL_INTERVAL_ADDRESSABLE_LENGTH_IN_BYTES 4 23 fixed bin (17) init (4072) int static options (constant); 4 24 4 25 dcl CONTROL_INTERVAL_ZERO_ADDRESSABLE_LENGTH_IN_BYTES 4 26 fixed bin (17) init (3176) int static options (constant); 4 27 4 28 4 29 dcl CI_ADDRESSABLE_LENGTH fixed bin (17) init (4072) int static options (constant); 4 30 4 31 dcl CI_0_ADDRESSABLE_LENGTH 4 32 fixed bin (17) init (3176) int static options (constant); 4 33 4 34 /* END INCLUDE FILE dm_ci_lengths.incl.pl1 */ 1423 1424 1425 5 1 /* BEGIN INCLUDE FILE dm_ci_constants.incl.pl1 */ 5 2 5 3 /* DESCRIPTION: 5 4* 5 5* This include file contains constants used with the ci and 5 6* ci_header structures. 5 7**/ 5 8 5 9 /* HISTORY: 5 10*Written by Matthew Pierret, 11/07/84. 5 11*Modified: 5 12**/ 5 13 5 14 /* format: style2,ind3 */ 5 15 5 16 5 17 dcl MAX_CI_NUM fixed bin (27) static options (constant) init (134217727); 5 18 dcl CI_STAMP_VERSION_1 bit (9) aligned static options (constant) init ("641"b3); 5 19 dcl TEMPLATE_CI_STAMP_1 fixed bin (71) static options (constant) init (-876220343501203701760); 5 20 dcl (SIZE_CODE_1024_WORDS, CI_SIZE_CODE_1024_WORDS) 5 21 bit (9) aligned static options (constant) init ("060"b3); 5 22 5 23 /* END INCLUDE FILE dm_ci_constants.incl.pl1 */ 1426 1427 6 1 /* BEGIN INCLUDE FILE: dm_ci_parts.incl.pl1 */ 6 2 6 3 /* DESCRIPTION: 6 4* 6 5* This include file contains the ci_parts structure. This structure 6 6* is used across the file_manager_ interface to specify the parts of a 6 7* control interval to get or put. If the number_of parts is equal to 0, 6 8* modules which take ci_parts interpret this case to mean to do everything 6 9* except the actual requested operation, i.e., lock the control interval 6 10* but don't get anything. offset_in_bytes is the 0-originned offset in 6 11* bytes from the beginning of the addressable portion of the control interval. 6 12* An offset_in_bytes which is in the addressable portion is in error. 6 13* Likewise, if offset_in_bytes + length_in_bytes is outside of the addressable 6 14* portion, it is in error. 6 15**/ 6 16 6 17 /* HISTORY: 6 18*Written by Matthew Pierret, 01/28/82. 6 19* (01/28/82 Andre Bensoussan, Design.) 6 20*Modified: 6 21*11/07/84 by Matthew Pierret: To add must_be_zero, initial attributes on 6 22* automatic storge. 6 23**/ 6 24 6 25 /* format: style2,ind3 */ 6 26 6 27 dcl 1 ci_parts aligned based (ci_parts_ptr), 6 28 2 number_of_parts fixed bin (17), 6 29 2 must_be_zero fixed bin, 6 30 2 part (cip_number_of_parts refer (ci_parts.number_of_parts)), 6 31 3 offset_in_bytes fixed bin (17), 6 32 3 length_in_bytes fixed bin (17), 6 33 3 local_ptr ptr; 6 34 6 35 dcl ci_parts_ptr ptr init (null ()); 6 36 dcl cip_number_of_parts fixed bin (17) init (0); 6 37 6 38 6 39 /* BEGIN INCLUDE FILE: dm_ci_parts.incl.pl1 */ 1428 1429 7 1 /* START OF: dm_lock_modes.incl.pl1 * * * * * * * * * * * * * * * * */ 7 2 7 3 /* DESCRIPTION: 7 4* 7 5* Hierarchical lock modes for Data Management control interval locking. In 7 6*addition to conventional read and write locks, intention locks are provided 7 7*for finer locking granularity. 7 8**/ 7 9 7 10 /* HISTORY: 7 11*Written by Jeffrey D. Ives, 04/30/82. 7 12*Modified: 7 13*12/05/84 by Stanford S. Cox: Added Description. 7 14**/ 7 15 /* format: style3,idind25 */ 7 16 7 17 dcl LOCK_MODE_S fixed bin static options (constant) init (2); 7 18 dcl LOCK_MODE_X fixed bin static options (constant) init (3); 7 19 dcl LOCK_MODE_IS fixed bin static options (constant) init (4); 7 20 dcl LOCK_MODE_IX fixed bin static options (constant) init (5); 7 21 dcl LOCK_MODE_SIX fixed bin static options (constant) init (6); 7 22 7 23 dcl LOCK_ENTIRE_FILE fixed bin (27) static options (constant) init (-1); 7 24 7 25 dcl LOCK_MODE_NAMES (2:6) char (3) int static options (constant) 7 26 init (" S", " X", " IS", " IX", "SIX"); 7 27 7 28 /* 7 29* S Share Let others read it but not modify it. 7 30* X Exclusive Let nobody else read or modify it. 7 31* IS Intention Share I am only using S locks, because I am only reading CIs. 7 32* IX Intention Exclusive I am using S and X locks, because I am reading and modifying CIs. 7 33* SIX Share with Intention Exclusive I am reading control intervals, but only locking the ones I modify. 7 34**/ 7 35 7 36 /* END OF: dm_lock_modes.incl.pl1 * * * * * * * * * * * * * * * * */ 1430 1431 8 1 /* BEGIN INCLUDE FILE: dm_file_create_info.incl.pl1 */ 8 2 8 3 /* DESCRIPTION: 8 4* This include file contains the declaration of the file_create_info 8 5* structure. This structure is used to specify to file_manager_ 8 6* attributes a file is to have. 8 7**/ 8 8 8 9 /* HISTORY: 8 10*Written by Jeffery D. Ives, 09/16/82. 8 11* (Original concept by Lindsey L. Spratt.) 8 12*Modified: 8 13*06/15/84 by Matthew Pierret: Added ring_brackets. Changed to a char (8) 8 14* version. 8 15*11/07/84 by Matthew Pierret: Extended mbz_3 to by one word to cover the 8 16* gap caused by the double-word alignment of mbz_2. 8 17**/ 8 18 8 19 /* format: style2,ind3 */ 8 20 8 21 dcl 1 file_create_info aligned based (file_create_info_ptr), 8 22 2 version char (8) aligned, 8 23 2 ci_size_in_bytes fixed bin (35) init (4096), 8 24 /* control interval physical size, must be 4096 */ 8 25 2 blocking_factor fixed bin init (255), /* # of cis in each msf seg, must be 64 or 255 */ 8 26 2 flags unal, 8 27 3 protected bit (1) unal init ("1"b), 8 28 /* protected against inconsistency */ 8 29 3 no_concurrency bit (1) unal init ("0"b), 8 30 /* don't protect against concurrent access */ 8 31 3 no_rollback bit (1) unal init ("0"b), 8 32 /* don't protect against system failure */ 8 33 3 mbz_1 bit (15) unal init ("0"b), 8 34 /* must be zero for future compatability */ 8 35 2 ring_brackets (2) fixed bin (3) unal init (0, 0), 8 36 /* write bracket is first element, read bracket is second */ 8 37 2 mbz_3 bit (46) unal init ("0"b), 8 38 /* must be zero for future compatability */ 8 39 2 mbz_2 (30) fixed bin (71); /* must be zero for future compatability */ 8 40 8 41 dcl file_create_info_ptr ptr; 8 42 8 43 dcl FILE_CREATE_INFO_VERSION_2 8 44 char (8) aligned static options (constant) init ("FileCr 2"); 8 45 dcl ( 8 46 FCI_WRITE_BRACKET_IDX init (1), 8 47 FCI_READ_BRACKET_IDX init (2) 8 48 ) internal static options (constant); 8 49 8 50 /* ************ END OF INCLUDE FILE: dm_file_create_info.incl.pl1 ********** */ 1432 1433 9 1 /* BEGIN INCLUDE FILE dm_file_validation_name.incl.pl1 */ 9 2 9 3 /* DESCRIPTION: 9 4* 9 5* This include file contains the file validation name which is 9 6* added to the first component of each DM file and is used to 9 7* determine if an MSF is a DM file. 9 8**/ 9 9 9 10 /* HISTORY: 9 11*Written by Matthew Pierret, 11/07/84. 9 12*Modified: 9 13**/ 9 14 9 15 /* format: style2,ind3 */ 9 16 9 17 dcl DM_FILE_VALIDATION_NAME 9 18 init ("_Data_Management_file_._") char (24) internal static options (constant); 9 19 9 20 9 21 /* END INCLUDE FILE dm_file_validation_name.incl.pl1 */ 1434 1435 10 1 /* BEGIN INCULE FILE dm_fm_file_attributes.incl.pl1 */ 10 2 10 3 /* DESCRIPTION: 10 4* 10 5* This include file contains the declaration of the file_attributes 10 6* structure. An instance of this structure is stored in control interval 10 7* zero of each DM file. It describes the attributes of the file. 10 8* 10 9* The structure is 896 bytes, or 224 words, long. 10 10**/ 10 11 10 12 /* HISTORY: 10 13*Written by Matthew Pierret, 06/15/84. 10 14* (Structure designed by Jeff Ives.) 10 15*Modified: 10 16*11/06/84 by Matthew Pierret: Changed mbz_rb1 from bit (28) to bit (30). 10 17* Removed the un-used version overlay and related constants. 10 18**/ 10 19 10 20 /* format: style2,ind3 */ 10 21 10 22 dcl 1 file_attributes aligned based (file_attributes_ptr), 10 23 2 version char (8) aligned, 10 24 2 unique_id bit (36), 10 25 2 ci_size_in_bytes fixed bin (35), /* control interval physical size, must be 4096 */ 10 26 2 blocking_factor fixed bin, /* # of cis in each msf seg, must be 64 or 255 */ 10 27 2 flags aligned, 10 28 3 protected bit unal, /* protected against inconsistency */ 10 29 3 no_concurrency bit unal, /* don't protect against concurrent access */ 10 30 3 no_rollback bit unal, /* don't protect against system failure */ 10 31 3 mbz_f1 bit (33) unal, 10 32 2 date_time_created fixed bin (71), 10 33 2 ring_brackets aligned, 10 34 3 write fixed bin (3) uns unal, 10 35 3 read fixed bin (3) uns unal, 10 36 3 mbz_rb1 bit (30) bit unal, 10 37 2 mbz_1 fixed bin (35), /* 10 words so far */ 10 38 2 mbz_2 (9) fixed bin (71), /* 28 words so far */ 10 39 2 time_last_dumped fixed bin (71), /* Not yet used */ 10 40 2 dump_file_path char (168), /* Not yet used */ 10 41 2 mbz_3 (4) fixed bin (71), /* 80 words so far */ 10 42 2 after_journal_path char (168), /* Not yet used */ 10 43 2 mbz_4 (50) fixed bin (71), /* 222 words so far */ 10 44 2 mbz_5 bit (54) unal, /* 223.5 words so far */ 10 45 2 length_of_attributes 10 46 fixed bin (17) unal; /* 224 words total */ 10 47 10 48 10 49 dcl file_attributes_ptr ptr init (null ()); 10 50 10 51 dcl FILE_ATTRIBUTES_VERSION_2 10 52 init ("FilAtt02") char (8) aligned internal static options (constant); 10 53 10 54 10 55 /* END INCLUDE FILE dm_fm_file_attributes.incl.pl1 */ 1436 1437 11 1 /* BEGIN INCLUDE FILE: dm_fm_file_access_info.incl.pl1 */ 11 2 11 3 /* DESCRIPTION: 11 4* The file_access_info structure contains per-process information 11 5* about a DM file. Each file_access_info structure is one entry in 11 6* the file_access_table.e array. The entry can be in one of three states: 11 7* not-in-use (file_access_info.entry_state is 0), in-use (entry_state is 11 8* -1) or still in-use, but to be discarded at the end of the transaction 11 9* (any number > 0). An entry needs to be discarded when the file is 11 10* completely closed by the user. This last state is useful because it is 11 11* better not to discard the entry when it is completely closed until the 11 12* end of the current transaction, so that if the transaction is aborted, the 11 13* file need not be re-opened to apply the before images. A list of entries 11 14* to be discarded is maintained using the entry_state variable. 11 15* The file can be in one of three states: exists (file_state = 1), 11 16* does not exist (file_state = 0), and logically_deleted (file_state = 3). 11 17**/ 11 18 11 19 /* HISTORY: 11 20*Written by Jeffrey D. Ives, 10/11/82. 11 21* (Original design by Andre Bensoussan, 01/28/82.) 11 22*Modified: 11 23*10/05/83 Jeffrey D. Ives: Added fields for lock advice and expanded seg_nums. 11 24*07/12/84 by Matthew Pierret: Re-named proc_ad to file_access_info. 11 25*12/17/84 by Matthew Pierret: Changed post_transaction_actions sub-structure 11 26* to state, with entry_state (replacing thread) and the new 11 27* file_state. Added a DESCRIPTION section. Added constants for 11 28* possible file_state values. 11 29**/ 11 30 11 31 /* format: style2,^inddcls,dclind5 */ 11 32 11 33 dcl 1 file_access_info aligned based (file_access_info_ptr), 11 34 2 state aligned, 11 35 3 entry_state fixed bin (17) unal, 11 36 3 file_state fixed bin (17) unal, 11 37 2 uid bit (36), 11 38 2 blocking_factor fixed bin (17) unal, 11 39 2 ring_brackets unal, 11 40 3 write fixed bin (3) unsigned unal, 11 41 3 read fixed bin (3) unsigned unal, 11 42 3 mbz_rb fixed bin (3) unsigned unal, 11 43 2 integrity_switches unal, 11 44 3 record_time_modified 11 45 bit (1) unal, /* record time modified in ci_header and trailer */ 11 46 3 transaction bit (1) unal, /* permit access only during a transaction */ 11 47 3 lock bit (1) unal, /* lock control intervals before accessing them */ 11 48 3 bj bit (1) unal, /* put undo records in the before journal */ 11 49 3 aj bit (1) unal, /* put redo records in the after journal */ 11 50 3 mbz_is bit (4) unal, 11 51 2 last_transaction_id 11 52 bit (36), 11 53 2 msf_ptr ptr unal, 11 54 2 pn_tbl_idx fixed bin (17) unal, 11 55 2 lock_advice fixed bin (17) unal, 11 56 2 opens fixed bin (17) unal, 11 57 2 seg_0_num bit (18) unal, 11 58 2 seg_nums (27) fixed bin (12) uns unal; 11 59 11 60 11 61 dcl file_access_info_ptr ptr init (null ()); 11 62 11 63 dcl ( 11 64 FILE_ACCESS_INFO_IN_USE 11 65 init (-1), 11 66 FILE_ACCESS_INFO_NOT_IN_USE 11 67 init (0), 11 68 FILE_DOES_NOT_EXIST init (0), 11 69 FILE_EXISTS init (1), 11 70 FILE_LOGICALLY_DELETED init (3) 11 71 ) fixed bin internal static options (constant); 11 72 11 73 11 74 /* END INCLUDE FILE: dm_fm_file_access_info.incl.pl1 */ 1438 1439 12 1 /* BEGIN INCLUDE FILE: dm_fm_file_access_tbl.incl.pl1 */ 12 2 12 3 /* DESCRIPTION: 12 4* 12 5* This include file contains the file_access_table structure. This 12 6* is a per-process table which contains one entry for each file which the 12 7* process has open. The table is set up during per-process initialization 12 8* and is pointed to by fm_data_$file_access_table_ptr. The bounds limit 12 9* on the array of entries is abritrary and can be changed. 12 10**/ 12 11 12 12 /* HISTORY: 12 13*Written by Jeffrey D. Ives, 10/11/82. 12 14* (01/28/82 Andre Bensoussan, Design.) 12 15*Modified: 12 16*07/11/84 by Matthew Pierret: Changed name of structure from proc_ad_tbl to 12 17* file_access_table. 12 18*11/07/84 by Matthew Pierret: Removed the un-used post_commit_actions element. 12 19* Removed the now-obsolete oid structure. It has been replaced by 12 20* file_oid in dm_fm_file_oid.incl.pl1. 12 21**/ 12 22 12 23 /* format: style2,ind3 */ 12 24 12 25 12 26 dcl fm_data_$file_access_table_ptr 12 27 ptr ext; 12 28 12 29 dcl 1 file_access_table aligned based (fm_data_$file_access_table_ptr), 12 30 2 h, 12 31 3 version char (8) aligned, 12 32 3 last_entry fixed bin, 12 33 3 post_transaction_actions 12 34 fixed bin, 12 35 3 mbz_1 (6) fixed bin (71), 12 36 2 e (1024) like file_access_info; 12 37 12 38 12 39 dcl FILE_ACCESS_TABLE_VERSION_1 12 40 init ("FileAT 1") char (8) aligned static options (constant); 12 41 12 42 /* END INCLUDE FILE: dm_fm_file_access_tbl.incl.pl1 */ 1440 1441 13 1 /* BEGIN INCLUDE FILE: dm_fm_file_oid.incl.pl1 */ 13 2 13 3 /* DESCRIPTION: 13 4* This include file contains the file_oid (file opening identifier) 13 5* structure. File opening ids are passed across the file_manager_ 13 6* interface as bit(36)aligned strings. The file_oid structure defines 13 7* the contents of the string. Two components make up a file opening id: 13 8* the index of the file opening in the file_access_table structure, which 13 9* contains per-process information on each file which is open, and the 13 10* last 18 bits of the file's unique id, used for verification of the entry 13 11* in the file_access_table. 13 12**/ 13 13 13 14 /* 13 15*HISTORY: 13 16*Written by Matthew Pierret, 07/16/84. 13 17*Modified: 13 18*11/02/84 by Matthew Pierret: Made file_oid based. 13 19**/ 13 20 13 21 /* format: style2,ind3 */ 13 22 13 23 dcl 1 file_oid aligned based, 13 24 2 file_access_table_idx 13 25 fixed bin (17) unal, /* index into file_access_table */ 13 26 2 uid_tail bit (18) unal; /* Last 18 bits of file unique id */ 13 27 13 28 13 29 /* END INCLUDE FILE: dm_fm_file_oid.incl.pl1 */ 1442 1443 14 1 /* BEGIN INCLUDE FILE dm_fm_rollback_info.incl.pl1 */ 14 2 14 3 /* DESCRIPTION: 14 4* 14 5* This include file contains the structures which define the rollback 14 6* handlers for the creation and deletion of files. They are used by 14 7* file_manager_$undo. 14 8* 14 9* All structure elements are unaligned because we don't trust 14 10* before_journal_manager_ to align the buffer in which it places 14 11* the structure. 14 12**/ 14 13 14 14 /* HISTORY: 14 15*Written by Matthew Pierret, 10/16/84. 14 16*Modified: 14 17**/ 14 18 14 19 /* format: style2,ind3 */ 14 20 14 21 dcl 1 rollback_info_header based (rollback_info_ptr), 14 22 2 version char (8) unal, 14 23 2 operation char (8) unal; 14 24 14 25 dcl 1 delete_rollback_info based (rollback_info_ptr), 14 26 2 header like rollback_info_header, 14 27 2 sys_pn_tbl_index fixed bin unal, 14 28 2 dir_path char (168) unal, 14 29 2 predelete_name char (32) unal, 14 30 2 postdelete_name char (32) unal; 14 31 14 32 dcl 1 create_rollback_info based (rollback_info_ptr), 14 33 2 header like rollback_info_header, 14 34 2 sys_pn_tbl_index fixed bin unal, 14 35 2 dir_path char (168) unal, 14 36 2 file_name char (32) unal; 14 37 14 38 dcl rollback_info_ptr ptr init (null ()); 14 39 dcl ( 14 40 ROLLBACK_INFO_VERSION_1 14 41 init ("RBInfo 1"), 14 42 DELETE_ROLLBACK_OPERATION 14 43 init ("deletion"), 14 44 CREATE_ROLLBACK_OPERATION 14 45 init ("creation") 14 46 ) char (8) internal static options (constant); 14 47 14 48 14 49 /* END INCLUDE FILE dm_fm_rollback_info.incl.pl1 */ 1444 1445 15 1 /* ******* BEGIN INCLUDE FILE dm_fm_sub_error_flags.incl.pl1 ******** */ 15 2 15 3 /* format: style2,ind3 */ 15 4 15 5 /* HISTORY: 15 6*Written by Matthew Pierret, 07/02/83. 15 7*Modified: 15 8**/ 15 9 15 10 dcl 1 fm_error_flags aligned based, 15 11 2 action unal, 15 12 3 cant_restart bit (1) unal, 15 13 3 default_restart bit (1) unal, 15 14 3 quiet_restart bit (1) unal, 15 15 3 support_signal bit (1) unal, 15 16 3 mbz_1 bit (14) unal, 15 17 2 log unal, 15 18 3 system bit (1) unal, 15 19 3 mbz_2 bit (1) unal, 15 20 2 mbz_3 bit (16) unal; 15 21 15 22 dcl ( 15 23 FM_ACTION_CANT_RESTART init ("1000"b || (32)"0"b), 15 24 FM_ACTION_CAN_RESTART init ("0000"b || (32)"0"b), 15 25 FM_ACTION_DEFAULT_RESTART 15 26 init ("0100"b || (32)"0"b), 15 27 FM_ACTION_QUIET_RESTART 15 28 init ("0010"b || (32)"0"b), 15 29 FM_ACTION_LOG init ((18)"0"b || "10"b || (16)"0"b) 15 30 ) bit (36) aligned internal static options (constant); 15 31 15 32 /* ********* END INCLUDE FILE dm_fm_sub_error_flags.incl.pl1 ******** */ 1446 1447 16 1 /* BEGIN INCLUDE FILE dm_log_sv_codes.incl.pl1 */ 16 2 16 3 /* format: ^indcom */ 16 4 16 5 /* DESCRIPTION: 16 6* These are the severity codes used by the dms daemon when calling its logger. 16 7* The severity is ranked thusly: 16 8* 16 9* severity log write situation 16 10* -------- --- ----- --------- 16 11* 0 no yes standard output, query, etc. 16 12* 1 yes yes fatal error, terminate dms daemon. 16 13* 2 yes yes nonfatal error. 16 14* 3 yes yes informative message. 16 15* 4 yes no log information only. 16 16**/ 16 17 16 18 /* HISTORY: 16 19* 16 20*Written by M. Pandolf, 10/06/82. 16 21*Modified: 16 22*12/10/84 by R. Michael Tague: Rename and reformat description/history. 16 23*01/13/85 by Lee A. Newcomb: Renamed to dm_log_sv_codes from 16 24* dm_daemon_sv_codes as the severity codes for the DM log are not 16 25* restrained to the DM Daemon's use. 16 26*01/24/85 by Lee A. Newcomb: Fixed to say dm_log_sv_codes.incl.pl1 in the 16 27* BEGIN and END INCLUDE comments, instead of dm_daemon_sv_codes.==. 16 28**/ 16 29 16 30 /* format: style5 */ 16 31 16 32 dcl (PRINT_SV, QUERY_SV) fixed bin internal static 16 33 options (constant) init (0); 16 34 dcl (CRASH_SV, FATAL_SV) fixed bin internal static 16 35 options (constant) init (1); 16 36 dcl ERROR_SV fixed bin internal static 16 37 options (constant) init (2); 16 38 dcl INFORM_SV fixed bin internal static 16 39 options (constant) init (3); 16 40 dcl LOG_SV fixed bin internal static 16 41 options (constant) init (4); 16 42 16 43 /* END INCLUDE FILE dm_log_sv_codes.incl.pl1 */ 1448 1449 17 1 /* BEGIN INCLUDE FILE condition_info_header.incl.pl1 BIM 1981 */ 17 2 /* format: style2 */ 17 3 17 4 declare condition_info_header_ptr 17 5 pointer; 17 6 declare 1 condition_info_header 17 7 aligned based (condition_info_header_ptr), 17 8 2 length fixed bin, /* length in words of this structure */ 17 9 2 version fixed bin, /* version number of this structure */ 17 10 2 action_flags aligned, /* tell handler how to proceed */ 17 11 3 cant_restart bit (1) unaligned, /* caller doesn't ever want to be returned to */ 17 12 3 default_restart bit (1) unaligned, /* caller can be returned to with no further action */ 17 13 3 quiet_restart bit (1) unaligned, /* return, and print no message */ 17 14 3 support_signal bit (1) unaligned, /* treat this signal as if the signalling procedure had the support bit set */ 17 15 /* if the signalling procedure had the support bit set, do the same for its caller */ 17 16 3 pad bit (32) unaligned, 17 17 2 info_string char (256) varying, /* may contain printable message */ 17 18 2 status_code fixed bin (35); /* if^=0, code interpretable by com_err_ */ 17 19 17 20 /* END INCLUDE FILE condition_info_header.incl.pl1 */ 1450 1451 1452 end fm_create_open_$create_open; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 12/09/86 1236.6 fm_create_open_.pl1 >spec>install>1237>fm_create_open_.pl1 1417 1 04/11/85 1452.6 access_mode_values.incl.pl1 >ldd>include>access_mode_values.incl.pl1 1419 2 10/14/83 1606.6 acl_structures.incl.pl1 >ldd>include>acl_structures.incl.pl1 1421 3 01/07/85 0900.5 dm_ci_header.incl.pl1 >ldd>include>dm_ci_header.incl.pl1 1423 4 01/07/85 0900.7 dm_ci_lengths.incl.pl1 >ldd>include>dm_ci_lengths.incl.pl1 1426 5 01/07/85 0900.3 dm_ci_constants.incl.pl1 >ldd>include>dm_ci_constants.incl.pl1 1428 6 01/07/85 0900.8 dm_ci_parts.incl.pl1 >ldd>include>dm_ci_parts.incl.pl1 1430 7 01/07/85 0901.4 dm_lock_modes.incl.pl1 >ldd>include>dm_lock_modes.incl.pl1 1432 8 01/07/85 0901.1 dm_file_create_info.incl.pl1 >ldd>include>dm_file_create_info.incl.pl1 1434 9 01/07/85 0901.0 dm_file_validation_name.incl.pl1 >ldd>include>dm_file_validation_name.incl.pl1 1436 10 01/07/85 0901.0 dm_fm_file_attributes.incl.pl1 >ldd>include>dm_fm_file_attributes.incl.pl1 1438 11 03/06/85 1031.2 dm_fm_file_access_info.incl.pl1 >ldd>include>dm_fm_file_access_info.incl.pl1 1440 12 01/07/85 0901.1 dm_fm_file_access_tbl.incl.pl1 >ldd>include>dm_fm_file_access_tbl.incl.pl1 1442 13 01/07/85 0900.9 dm_fm_file_oid.incl.pl1 >ldd>include>dm_fm_file_oid.incl.pl1 1444 14 01/07/85 0900.4 dm_fm_rollback_info.incl.pl1 >ldd>include>dm_fm_rollback_info.incl.pl1 1446 15 01/07/85 0858.8 dm_fm_sub_error_flags.incl.pl1 >ldd>include>dm_fm_sub_error_flags.incl.pl1 1448 16 03/06/85 1031.1 dm_log_sv_codes.incl.pl1 >ldd>include>dm_log_sv_codes.incl.pl1 1450 17 03/24/82 1347.2 condition_info_header.incl.pl1 >ldd>include>condition_info_header.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. BYTES_PER_WORD constant fixed bin(17,0) initial dcl 235 ref 671 CI_0_ADDRESSABLE_LENGTH constant fixed bin(17,0) initial dcl 4-31 ref 1002 1002 1002 1197 1199 CI_ADDRESSABLE_LENGTH constant fixed bin(17,0) initial dcl 4-29 ref 1002 1002 1002 1199 CI_HEADER_STAMP_VERSION_1 constant bit(9) initial dcl 3-53 ref 905 CI_SIZE_CODE_1024_WORDS constant bit(9) initial dcl 5-20 ref 905 CREATE_MSF 000107 constant bit(1) initial unaligned dcl 235 set ref 631* CREATE_ROLLBACK_OPERATION 000000 constant char(8) initial unaligned dcl 14-39 ref 667 DEFAULT_CI_SIZE_IN_BYTES 010640 constant fixed bin(17,0) initial dcl 235 ref 555 558 558 558 DM_FILE_VALIDATION_NAME 000006 constant char(24) initial unaligned dcl 9-17 set ref 686* 688* DONT_CREATE_MSF 000115 constant bit(1) initial unaligned dcl 235 set ref 736* 895* E_ACCESS constant bit(3) initial unaligned dcl 1-11 ref 1385 FCI_READ_BRACKET_IDX constant fixed bin(17,0) initial dcl 8-45 ref 576 576 581 581 581 581 581 610 1022 1029 FCI_WRITE_BRACKET_IDX constant fixed bin(17,0) initial dcl 8-45 ref 573 573 581 581 581 581 581 608 1022 1029 FILE_ACCESS_INFO_IN_USE constant fixed bin(17,0) initial dcl 11-63 ref 651 984 FILE_ACCESS_INFO_NOT_IN_USE constant fixed bin(17,0) initial dcl 11-63 ref 1159 FILE_ATTRIBUTES_VERSION_2 000004 constant char(8) initial dcl 10-51 ref 598 1010 1010 FILE_CREATE_INFO_VERSION_2 000014 constant char(8) initial dcl 8-43 ref 542 546 546 FILE_EXISTS constant fixed bin(17,0) initial dcl 11-63 ref 652 985 FIRST_COMPONENT_NAME 000067 constant char(1) initial unaligned dcl 235 set ref 720* 722* 722* FM_ACTION_CANT_RESTART constant bit(36) initial dcl 15-22 ref 1144 FM_ACTION_LOG constant bit(36) initial dcl 15-22 ref 1144 INFORM_SV 000116 constant fixed bin(17,0) initial dcl 16-38 set ref 1045* LEVEL_NOT_SET constant fixed bin(17,0) initial dcl 235 ref 174 192 LOCK_ENTIRE_FILE 000054 constant fixed bin(27,0) initial dcl 7-23 set ref 829* LOCK_MODE_X 000116 constant fixed bin(17,0) initial dcl 7-18 set ref 829* LOG_SV 000114 constant fixed bin(17,0) initial dcl 16-40 set ref 1029* 1041* 1144* MAXIMUM_NUMBER_OF_FILE_OPENINGS constant fixed bin(17,0) initial dcl 235 ref 947 MYNAME 000016 constant varying char(32) initial dcl 233 set ref 1029* 1041* 1045* 1144* NO_CI_HELD 000115 constant fixed bin(27,0) initial dcl 235 set ref 671* ROLLBACK_INFO_VERSION_1 000002 constant char(8) initial unaligned dcl 14-39 ref 666 RW_ACCESS constant bit(3) initial unaligned dcl 1-11 ref 763 769 1385 SMA_ACCESS constant bit(3) initial unaligned dcl 1-11 ref 1276 SMA_ACCESS_BIN constant fixed bin(5,0) initial dcl 1-36 ref 1271 WITH_NO_ERRORS 000115 constant fixed bin(35,0) initial dcl 235 set ref 879* 963* 1081* access_name 000470 automatic char(32) array level 2 in structure "my_msf_acl_list" packed unaligned dcl 207 in procedure "fm_create_open_$create_open" set ref 762* 768* 778 access_name based char(32) array level 2 in structure "ai_delete_acl_array" packed unaligned dcl 1308 in procedure "ADJUST_IACL" set ref 1352* access_name 001411 automatic char(32) array level 2 in structure "gda_dir_acl_list" packed unaligned dcl 1251 in procedure "GIVE_DAEMON_ACCESS_TO_CONTAINING_DIR" set ref 1275* 1285 access_name based char(32) array level 2 in structure "ai_iacl_array" packed unaligned dcl 1317 in procedure "ADJUST_IACL" ref 1352 action_flags 2 001104 automatic structure level 2 dcl 217 set ref 1096* addr builtin function dcl 221 ref 596 671 671 771 771 856 856 871 871 991 993 993 995 995 1103 1103 1278 1278 ai_acl_idx 000100 automatic fixed bin(17,0) initial dcl 1306 set ref 1306* 1351* 1352 1352 1354* 1384* 1385 1385 1385* ai_code 000101 automatic fixed bin(35,0) initial dcl 1307 set ref 1307* 1324* 1325 1325* 1338* 1341 1341* 1360* 1362 1362* 1375* 1378 1378* 1393* 1395 1395* ai_delete_acl_array based structure array level 1 dcl 1308 set ref 1350 1367 1408 ai_delete_acl_array_ptr 000104 automatic pointer initial dcl 1312 set ref 1312* 1350* 1352 1354 1360* 1367 1368* 1408 1408 ai_delete_acl_count 000102 automatic fixed bin(17,0) initial dcl 1311 set ref 1311* 1349* 1350 1351 1360* 1367 1408 ai_dir_dir 000106 automatic char(168) unaligned dcl 1314 set ref 1324* 1338* 1341* 1341* 1375* 1378* 1378* ai_dir_entry 000160 automatic char(32) unaligned dcl 1315 set ref 1324* 1338* 1341* 1341* 1375* 1378* 1378* ai_iacl_array based structure array level 1 dcl 1317 set ref 1357 1406 ai_iacl_array_ptr 000172 automatic pointer initial dcl 1320 set ref 1320* 1338* 1352 1357 1358* 1375* 1385 1385 1385 1393* 1406 1406 ai_iacl_count 000170 automatic fixed bin(17,0) initial dcl 1316 set ref 1316* 1338* 1346 1349 1357 1375* 1384 1390 1393* 1406 ai_p_dir_path parameter char unaligned dcl 1300 set ref 1297 1324* 1325* 1362* 1362* 1395* 1395* ai_p_entry parameter char unaligned dcl 1301 set ref 1297 1362* 1362* 1395* 1395* ai_p_msf_fcb_ptr parameter pointer dcl 1304 set ref 1297 1360* 1393* ai_p_validation_level parameter fixed bin(3,0) dcl 1302 set ref 1297 1338* 1341 1341 1362 1362 ai_p_write_bracket parameter fixed bin(3,0) dcl 1303 set ref 1297 1375* 1378 1378 baseno builtin function dcl 221 ref 788 912 before_journal_manager_$write_fm_rollback_handler 000076 constant entry external dcl 313 ref 671 bj 2(30) 000524 automatic bit(1) level 3 packed unaligned dcl 214 set ref 822* 837 1068* blocking_factor 4 based fixed bin(17,0) level 2 in structure "file_attributes" dcl 10-22 in procedure "fm_create_open_$create_open" set ref 600* 789 1061 blocking_factor 3 000272 automatic fixed bin(17,0) initial level 2 in structure "my_create_info" dcl 198 in procedure "fm_create_open_$create_open" set ref 198* 564 564* 567 567 567 567 600 blocking_factor 2 000524 automatic fixed bin(17,0) level 2 in structure "my_file_access_info" packed unaligned dcl 214 in procedure "fm_create_open_$create_open" set ref 789* 910* 1061* char builtin function dcl 221 ref 558 558 558 558 567 567 581 581 581 581 831 831 858 858 858 858 1002 1002 1002 1002 1015 1015 1015 1015 1341 1341 1362 1362 1378 1378 ci_header based structure level 1 dcl 3-32 ref 903 ci_header_ptr 001234 automatic pointer dcl 3-31 set ref 1170* ci_id based structure level 1 dcl 3-64 ci_parts based structure level 1 dcl 6-27 ci_parts_ptr 001240 automatic pointer initial dcl 6-35 set ref 6-35* ci_size_in_bytes 2 000272 automatic fixed bin(35,0) initial level 2 in structure "my_create_info" dcl 198 in procedure "fm_create_open_$create_open" set ref 198* 555 555* 558 558 558 599 ci_size_in_bytes 3 based fixed bin(35,0) level 2 in structure "file_attributes" dcl 10-22 in procedure "fm_create_open_$create_open" set ref 599* ci_stamp based structure level 1 dcl 3-48 ci_trailer_ptr 001236 automatic pointer dcl 3-39 set ref 1171* cip_number_of_parts 001242 automatic fixed bin(17,0) initial dcl 6-36 set ref 6-36* cleanup 001212 stack reference condition dcl 227 ref 514 1322 clock builtin function dcl 221 ref 853 code 000100 automatic fixed bin(35,0) initial dcl 172 set ref 172* 486* 488 492 492* 494 497* 501 501 501* 504* 518* 519* 525 631* 633* 640* 641 641* 671* 675 675* 686* 688 688* 700* 701 701* 710* 712 712* 720* 722 722* 730* 731 731* 736* 738* 745* 746 746* 771* 773 776* 778* 829* 831 831* 840* 841 844 844* 847* 871* 873 873* 886 886* 895* 897* 995* 997 997* 1040* 1041 1041* 1102* 1257* 1258 1258* 1262* 1265 1265* 1278* 1280 1283* 1285* condition_info_header based structure level 1 dcl 17-6 create_rollback_info based structure level 1 packed unaligned dcl 14-32 create_sw 000101 automatic bit(1) initial dcl 173 set ref 173* 435* 455* 488 525 891 cu_$level_get 000100 constant entry external dcl 317 ref 513 cu_$level_set 000102 constant entry external dcl 318 ref 516 1157 current_validation_level 000102 automatic fixed bin(17,0) initial dcl 174 set ref 174* 515* 516* 573 576 579 707 708 716 751 date_time_created 6 based fixed bin(71,0) level 2 dcl 10-22 set ref 853* delete_acl_entry based structure level 1 dcl 2-63 dim builtin function dcl 221 ref 1278 1278 dir_path 4(18) 000374 automatic char(168) level 2 in structure "my_create_rollback_info" packed unaligned dcl 200 in procedure "fm_create_open_$create_open" set ref 669* dir_path 000103 automatic char(168) initial unaligned dcl 176 in procedure "fm_create_open_$create_open" set ref 176* 465* 471* 486* 518* 519* 519* 624 624 624* 633* 633* 641* 641* 641* 641* 669 675* 675* 710* 712* 712* 730* 731* 731* 738* 738* 745* 746* 746* 751* 847* 847* 847* 847* 1040* 1097* 1097* dir_ring_brackets 000156 automatic fixed bin(3,0) array dcl 177 set ref 707* 708* 710* directory_acl_entry based structure level 1 dcl 2-54 dm_area based area(1024) dcl 251 ref 1350 dm_data_$area_ptr 000012 external static pointer dcl 258 set ref 1338* 1350 1375* dm_data_$current_txn_id 000010 external static bit(36) dcl 256 set ref 621 1102* dm_error_$bad_file_atrs_length 000016 external static fixed bin(35,0) dcl 263 set ref 1002* dm_error_$bad_file_atrs_uid 000020 external static fixed bin(35,0) dcl 265 set ref 1015* dm_error_$bad_file_atrs_ver 000022 external static fixed bin(35,0) dcl 267 set ref 1010* dm_error_$bad_file_cr_blocking_factor 000024 external static fixed bin(35,0) dcl 269 set ref 567* dm_error_$bad_file_cr_ci_size 000026 external static fixed bin(35,0) dcl 271 set ref 558* dm_error_$bad_file_cr_info_ver 000030 external static fixed bin(35,0) dcl 273 set ref 546* dm_error_$bj_journal_full 000032 external static fixed bin(35,0) dcl 275 set ref 1100 1104* dm_error_$file_already_exists 000034 external static fixed bin(35,0) dcl 277 set ref 1079* dm_error_$file_already_open 000036 external static fixed bin(35,0) dcl 279 set ref 960* dm_error_$file_cr_info_mbz_nz 000042 external static fixed bin(35,0) dcl 283 set ref 551* dm_error_$file_not_dm_type 000040 external static fixed bin(35,0) dcl 281 set ref 905* dm_error_$fm_proc_tbl_full 000046 external static fixed bin(35,0) dcl 287 set ref 1230* dm_error_$fm_too_many_openings 000050 external static fixed bin(35,0) dcl 289 set ref 947* dm_error_$fm_xring_brackets_mismatch 000052 external static fixed bin(35,0) dcl 291 set ref 1029* dm_error_$no_current_transaction 000044 external static fixed bin(35,0) dcl 285 set ref 621* dm_error_$programming_error 000054 external static fixed bin(35,0) dcl 293 set ref 858* dm_misc_util_$log 000104 constant entry external dcl 319 ref 1029 1041 1045 dm_system_data_$initializer_name 000014 external static char(32) unaligned dcl 260 set ref 768 1262* 1265* 1275 e 20 based structure array level 2 dcl 12-29 set ref 797 868* 916 945 952* 1074* 1221 1230 1235* encoded_ring_brackets 000160 automatic fixed bin(24,0) initial dcl 178 set ref 178* 696* 700* 1037* 1040* entry_name 000161 automatic char(32) unaligned dcl 179 set ref 466* 467 471* 486* 518* 519* 519* 633* 633* 641* 641* 641* 641* 670 675* 675* 710* 712* 712* 730* 731* 731* 738* 738* 745* 746* 746* 751* 847* 847* 847* 847* 1040* 1097* 1097* entry_state 000524 automatic fixed bin(17,0) level 3 in structure "my_file_access_info" packed unaligned dcl 214 in procedure "fm_create_open_$create_open" set ref 651* 984* entry_state 20 based fixed bin(17,0) array level 4 in structure "file_access_table" packed unaligned dcl 12-29 in procedure "fm_create_open_$create_open" set ref 799 916 1159* 1221 er_p_code parameter fixed bin(35,0) dcl 1139 set ref 1127 1144* er_p_error_message parameter char unaligned dcl 1140 set ref 1127 1144* er_p_error_message_argument_1 parameter char unaligned dcl 1140 set ref 1127 1144* er_p_error_message_argument_2 parameter char unaligned dcl 1140 set ref 1127 1144* erb_p_read_bracket parameter fixed bin(3,0) dcl 1211 ref 1207 1213 erb_p_write_bracket parameter fixed bin(3,0) dcl 1210 ref 1207 1213 error_table_$bigarg 000056 external static fixed bin(35,0) dcl 295 set ref 467* error_table_$invalid_ring_brackets 000060 external static fixed bin(35,0) dcl 296 set ref 581* error_table_$namedup 000062 external static fixed bin(35,0) dcl 298 set ref 494* error_table_$no_r_permission 000072 external static fixed bin(35,0) dcl 304 set ref 1054* error_table_$noentry 000064 external static fixed bin(35,0) dcl 299 ref 492 501 525 error_table_$not_dm_ring 000066 external static fixed bin(35,0) dcl 300 ref 844 error_table_$not_seg_type 000070 external static fixed bin(35,0) dcl 302 ref 494 expand_pathname_ 000106 constant entry external dcl 320 ref 1257 1324 extended_ring_brackets 000172 automatic fixed bin(3,0) initial array dcl 180 set ref 180* 180* 486* 1022 1022 1029* 1029* file_access_info based structure level 1 dcl 11-33 file_access_info_ptr 001250 automatic pointer initial dcl 11-61 set ref 11-61* file_access_table based structure level 1 dcl 12-29 file_access_table_idx 000174 automatic fixed bin(17,0) initial dcl 181 in procedure "fm_create_open_$create_open" set ref 181* 797* 799 799 805 807 810* 916* 916 916* 924 927 931 933 936 945 952 954 1074 1221* 1221* 1227 1232 1235 1237 file_access_table_idx 000467 automatic fixed bin(17,0) level 2 in structure "my_file_oid" packed unaligned dcl 205 in procedure "fm_create_open_$create_open" set ref 868 954* 1159 1159 1237* file_already_exists 000175 automatic bit(1) initial dcl 182 set ref 182* 529* 891* 893* 1079 file_attributes based structure level 1 dcl 10-22 set ref 597* 854 file_attributes_ptr 001246 automatic pointer initial dcl 10-49 set ref 596* 597 598 599 600 601 605 606 608 610 618 646 660 660 696 696 717 718 751 764 789 792 794 817 819 822 853 854 854 856* 858 858 858 991* 993* 1002 1002 1002 1010 1010 1015 1015 1015 1022 1022 1029 1029 1037 1037 1049 1051 1057 1057 1057 1061 1063 1065 1068 10-49* file_create_info based structure level 1 dcl 8-21 ref 537 file_create_info_ptr 001244 automatic pointer dcl 8-41 set ref 1172* file_name 56(18) 000374 automatic char(32) level 2 packed unaligned dcl 200 set ref 670* file_oid based structure level 1 dcl 13-23 file_pathname 000176 automatic char(168) unaligned dcl 183 set ref 471* 494* 497* 504* 664* 688* 688* 701* 701* 720* 722* 722* 778* 831* 840* 886* 897* 897* 947* 1002 1015 1029* 1041* 1045* 1057* file_state 0(18) 000524 automatic fixed bin(17,0) level 3 packed unaligned dcl 214 set ref 652* 985* flags 4 000272 automatic structure level 2 in structure "my_create_info" packed unaligned dcl 198 in procedure "fm_create_open_$create_open" flags 5 based structure level 2 in structure "file_attributes" dcl 10-22 in procedure "fm_create_open_$create_open" fm_data_$file_access_table_ptr 000200 external static pointer dcl 12-26 ref 797 797 799 799 805 807 810 868 916 916 916 916 924 927 931 933 936 945 952 1074 1159 1221 1221 1221 1227 1230 1230 1232 1235 fm_error_util_$get_code 000112 constant entry external dcl 323 ref 462 462 fm_error_util_$signal 000110 constant entry external dcl 322 ref 1144 fm_get_$int initial dcl 187 set ref 187* 518* 519 631* 729* 730* 736* 751* 771* 790 791* 895* 942* 943* 967 968* 1155 1155* msf_manager_$acl_add 000160 constant entry external dcl 363 ref 771 1393 msf_manager_$acl_delete 000162 constant entry external dcl 364 ref 1360 msf_manager_$close 000164 constant entry external dcl 366 ref 729 942 1155 msf_manager_$msf_get_ptr 000166 constant entry external dcl 367 ref 631 736 895 msf_manager_$open 000170 constant entry external dcl 370 ref 518 730 msf_ptr 4 000524 automatic pointer level 2 in structure "my_file_access_info" packed unaligned dcl 214 in procedure "fm_create_open_$create_open" set ref 474* 790* 967* msf_ptr 24 based pointer array level 3 in structure "file_access_table" packed unaligned dcl 12-29 in procedure "fm_create_open_$create_open" set ref 807* 933* must_be_zero 1 000516 automatic fixed bin(17,0) initial level 2 dcl 209 set ref 209* my_attr_ci_parts 000516 automatic structure level 1 dcl 209 set ref 856 856 871 871 993 993 995 995 my_ci_header 000463 automatic structure level 1 dcl 203 set ref 903* 1174* my_create_info 000272 automatic structure level 1 dcl 198 set ref 537* 541* 1175* my_create_rollback_info 000374 automatic structure level 1 dcl 200 set ref 671 671 671 my_file_access_info 000524 automatic structure level 1 dcl 214 set ref 473* 868 945* 952 1074 1235 my_file_attributes 000544 automatic structure level 1 dcl 216 set ref 596 990* 991 1176* my_file_oid 000467 automatic structure level 1 dcl 205 set ref 459* 671 671 871 871 876 877* 957 958* 995 995 1076 1077* my_msf_acl_list 000470 automatic structure array level 1 dcl 207 set ref 760* 771 771 my_signal_structure 001104 automatic structure level 1 dcl 217 set ref 1094 1103 1103 no_concurrency 5(01) based bit(1) level 3 in structure "file_attributes" packed unaligned dcl 10-22 in procedure "fm_create_open_$create_open" set ref 605* 819 1065 no_concurrency 4(01) 000272 automatic bit(1) initial level 3 in structure "my_create_info" packed unaligned dcl 198 in procedure "fm_create_open_$create_open" set ref 198* 605 no_rollback 5(02) based bit(1) level 3 in structure "file_attributes" packed unaligned dcl 10-22 in procedure "fm_create_open_$create_open" set ref 606* 660 822 1057 1068 no_rollback 4(02) 000272 automatic bit(1) initial level 3 in structure "my_create_info" packed unaligned dcl 198 in procedure "fm_create_open_$create_open" set ref 198* 606 null builtin function dcl 221 ref 187 193 474 519 537 633 735 738 791 807 897 933 943 968 1103 1103 6-35 10-49 11-61 14-38 1155 1170 1171 1172 1312 1320 1338 1338 1358 1368 1375 1375 1406 1408 num 3(09) 000463 automatic fixed bin(27,0) level 3 packed unsigned unaligned dcl 203 set ref 905 number_of_msf_acl_terms 000256 automatic fixed bin(17,0) initial dcl 189 set ref 189* 761* 767* 771* 773 number_of_parts 000516 automatic fixed bin(17,0) initial level 2 in structure "my_attr_ci_parts" dcl 209 in procedure "fm_create_open_$create_open" set ref 209* number_of_parts based fixed bin(17,0) level 2 in structure "ci_parts" dcl 6-27 in procedure "fm_create_open_$create_open" set ref 1196* offset_in_bytes 2 based fixed bin(17,0) array level 3 dcl 6-27 set ref 1197* opens 6 000524 automatic fixed bin(17,0) level 2 packed unaligned dcl 214 set ref 866* 947 950* 950 960 1072* operation 2 000374 automatic char(8) level 3 packed unaligned dcl 200 set ref 667* p_code parameter fixed bin(35,0) dcl 164 set ref 155 451 1120* p_dir_path parameter char unaligned dcl 165 ref 155 451 465 p_entry_name parameter char unaligned dcl 166 set ref 155 451 466 467 467* p_file_create_info_ptr parameter pointer dcl 168 ref 155 537 537 p_output_file_oid parameter bit(36) dcl 167 set ref 155 451 464* 876* 957* 1076* part 2 000516 automatic structure array level 2 in structure "my_attr_ci_parts" dcl 209 in procedure "fm_create_open_$create_open" part 2 based structure array level 2 in structure "ci_parts" dcl 6-27 in procedure "fm_create_open_$create_open" pathname_ 000172 constant entry external dcl 372 ref 471 519 519 633 633 641 641 641 641 641 641 675 675 688 688 701 701 712 712 722 722 731 731 738 738 746 746 847 847 847 847 847 847 897 897 1097 1097 1265 1265 1285 1285 1341 1341 1362 1362 1378 1378 1395 1395 pn_tbl_idx 5 000524 automatic fixed bin(17,0) level 2 packed unaligned dcl 214 set ref 865* 1071* protected 5 based bit(1) level 3 in structure "file_attributes" packed unaligned dcl 10-22 in procedure "fm_create_open_$create_open" set ref 601* 618 660 764 817 1057 1063 protected 4 000272 automatic bit(1) initial level 3 in structure "my_create_info" packed unaligned dcl 198 in procedure "fm_create_open_$create_open" set ref 198* 543* 601 602 r_p_code parameter fixed bin(35,0) dcl 1118 ref 1108 1120 read 10(03) based fixed bin(3,0) level 3 in structure "file_attributes" packed unsigned unaligned dcl 10-22 in procedure "fm_create_open_$create_open" set ref 610* 696 717 718 794 1022 1029* 1037 1051 read 2(21) 000524 automatic fixed bin(3,0) level 3 in structure "my_file_access_info" packed unsigned unaligned dcl 214 in procedure "fm_create_open_$create_open" set ref 794* 978* 1051* 1054 record_time_modified 2(27) 000524 automatic bit(1) level 3 packed unaligned dcl 214 set ref 816* 1062* ring_brackets 2(18) 000524 automatic structure level 2 in structure "my_file_access_info" packed unaligned dcl 214 in procedure "fm_create_open_$create_open" ring_brackets 4(18) 000272 automatic fixed bin(3,0) initial array level 2 in structure "my_create_info" packed unaligned dcl 198 in procedure "fm_create_open_$create_open" set ref 198* 198* 573 573* 576 576* 581 581 581 581 581 581 581 581 581 581 608 610 ring_brackets 000257 automatic fixed bin(3,0) array dcl 191 in procedure "fm_create_open_$create_open" set ref 716* 717* 718* 720* ring_brackets 10 based structure level 2 in structure "file_attributes" dcl 10-22 in procedure "fm_create_open_$create_open" rollback_info_header based structure level 1 packed unaligned dcl 14-21 rollback_info_ptr 001252 automatic pointer initial dcl 14-38 set ref 14-38* rtrim builtin function dcl 221 ref 466 1002 1015 saved_validation_level 000262 automatic fixed bin(17,0) initial dcl 192 set ref 192* 513* 573 576 579 1054 1157 1157* seg_0_num 26(18) based bit(18) array level 3 in structure "file_access_table" packed unaligned dcl 12-29 in procedure "fm_create_open_$create_open" set ref 799 805* 916 931* seg_0_num 6(18) 000524 automatic bit(18) level 2 in structure "my_file_access_info" packed unaligned dcl 214 in procedure "fm_create_open_$create_open" set ref 788* 799 912* 916 seg_0_ptr 000264 automatic pointer initial dcl 193 set ref 193* 631* 633 640* 664* 686* 700* 735* 736* 738 788 895* 897 903 912 1057* seg_0_uid 000266 automatic bit(36) initial dcl 194 set ref 194* 640* 646 647 664* 671* 1097* seg_nums 7 000524 automatic fixed bin(12,0) array level 2 in structure "my_file_access_info" packed unsigned unaligned dcl 214 in procedure "fm_create_open_$create_open" set ref 808 808 934 934 seg_nums 27 based fixed bin(12,0) array level 3 in structure "file_access_table" packed unsigned unaligned dcl 12-29 in procedure "fm_create_open_$create_open" set ref 810* 936* segment_acl_entry based structure level 1 dcl 2-45 signal_ 000174 constant entry external dcl 374 ref 1103 size builtin function dcl 221 ref 671 854 1094 size_code 3 000463 automatic bit(9) level 3 packed unaligned dcl 203 set ref 905 stamp 000463 automatic structure level 2 in structure "my_ci_header" dcl 203 in procedure "fm_create_open_$create_open" stamp based structure level 2 in structure "ci_header" dcl 3-32 in procedure "fm_create_open_$create_open" state 20 based structure array level 3 in structure "file_access_table" dcl 12-29 in procedure "fm_create_open_$create_open" state 000524 automatic structure level 2 in structure "my_file_access_info" dcl 214 in procedure "fm_create_open_$create_open" status_code 12 000470 automatic fixed bin(35,0) array level 2 in structure "my_msf_acl_list" dcl 207 in procedure "fm_create_open_$create_open" set ref 776 776 status_code 104 001104 automatic fixed bin(35,0) level 2 in structure "my_signal_structure" dcl 217 in procedure "fm_create_open_$create_open" set ref 1100* status_code 11 001411 automatic fixed bin(35,0) array level 2 in structure "gda_dir_acl_list" dcl 1251 in procedure "GIVE_DAEMON_ACCESS_TO_CONTAINING_DIR" set ref 1283 1283 status_code 10 based fixed bin(35,0) array level 2 in structure "ai_delete_acl_array" dcl 1308 in procedure "ADJUST_IACL" set ref 1354* string builtin function dcl 221 set ref 1096* substr builtin function dcl 221 ref 624 624 955 1238 sys_info$data_management_ringno 000074 external static fixed bin(17,0) dcl 307 ref 844 sys_pn_tbl_index 4 000374 automatic fixed bin(17,0) level 2 in structure "my_create_rollback_info" packed unaligned dcl 200 in procedure "fm_create_open_$create_open" set ref 668* sys_pn_tbl_index 000267 automatic fixed bin(17,0) initial dcl 195 in procedure "fm_create_open_$create_open" set ref 195* 664* 668 865 1057* 1071 time_stamp 000270 automatic fixed bin(71,0) dcl 196 set ref 671* transaction 2(28) 000524 automatic bit(1) level 3 packed unaligned dcl 214 set ref 817* 819 822 1063* 1065 1068 transaction_bj_full_ 001226 stack reference condition dcl 229 ref 663 1090 transaction_manager_$abort_txn 000176 constant entry external dcl 375 ref 1102 uid 2 000463 automatic bit(36) level 3 in structure "my_ci_header" dcl 203 in procedure "fm_create_open_$create_open" set ref 905 911 uid 1 000524 automatic bit(36) level 2 in structure "my_file_access_info" dcl 214 in procedure "fm_create_open_$create_open" set ref 647* 829* 831 831 911* 927 955 1015 1015 1015 1238 uid 21 based bit(36) array level 3 in structure "file_access_table" dcl 12-29 in procedure "fm_create_open_$create_open" set ref 927 uid_tail 0(18) 000467 automatic bit(18) level 2 packed unaligned dcl 205 set ref 955* 1238* unique_id 2 based bit(36) level 2 dcl 10-22 set ref 646* 1015 1015 1015 1057* unspec builtin function dcl 221 set ref 459* 473* 541* 551 551 597* 671 671 760* 805* 810* 871 871 876 877* 905 931* 936* 957 958* 990* 995 995 1076 1077* 1174* 1175* 1176* 1274* version 000463 automatic bit(9) level 3 in structure "my_ci_header" packed unaligned dcl 203 in procedure "fm_create_open_$create_open" set ref 905 version 000272 automatic char(8) level 2 in structure "my_create_info" dcl 198 in procedure "fm_create_open_$create_open" set ref 542* 546 546 version based char(8) level 2 in structure "file_attributes" dcl 10-22 in procedure "fm_create_open_$create_open" set ref 598* 1010 1010 version 1 001104 automatic fixed bin(17,0) level 2 in structure "my_signal_structure" dcl 217 in procedure "fm_create_open_$create_open" set ref 1095* version 000374 automatic char(8) level 3 in structure "my_create_rollback_info" packed unaligned dcl 200 in procedure "fm_create_open_$create_open" set ref 666* write 2(18) 000524 automatic fixed bin(3,0) level 3 in structure "my_file_access_info" packed unsigned unaligned dcl 214 in procedure "fm_create_open_$create_open" set ref 792* 1049* write 10 based fixed bin(3,0) level 3 in structure "file_attributes" packed unsigned unaligned dcl 10-22 in procedure "fm_create_open_$create_open" set ref 608* 696 751 792 1022 1029* 1037 1049 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 unaligned dcl 1-11 A_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 CI_STAMP_VERSI cu_$level_set dm_misc_util_$log expand_pathname_ fm_error_util_$get_code fm_error_util_$signal fm_get_$internal_get fm_put_$internal_put fm_sys_pn_tbl_util_$insert fm_validate_$get_ring_brackets get_group_id_$tag_star get_ring_ hcs_$add_dir_acl_entries hcs_$chname_seg hcs_$get_uid_seg hcs_$get_user_effmode hcs_$list_inacl hcs_$set_bc hcs_$set_bc_seg hcs_$set_dir_ring_brackets hcs_$set_ring_brackets hcs_$set_safety_sw hcs_$set_synchronized_sw ioa_$rsnnl lock_manager_$lock msf_manager_$acl_add msf_manager_$acl_delete msf_manager_$close msf_manager_$msf_get_ptr msf_manager_$open pathname_ signal_ transaction_manager_$abort_txn THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. dm_data_$area_ptr dm_data_$current_txn_id dm_error_$bad_file_atrs_length dm_error_$bad_file_atrs_uid dm_error_$bad_file_atrs_ver dm_error_$bad_file_cr_blocking_factor dm_error_$bad_file_cr_ci_size dm_error_$bad_file_cr_info_ver dm_error_$bj_journal_full dm_error_$file_already_exists dm_error_$file_already_open dm_error_$file_cr_info_mbz_nz dm_error_$file_not_dm_type dm_error_$fm_proc_tbl_full dm_error_$fm_too_many_openings dm_error_$fm_xring_brackets_mismatch dm_error_$no_current_transaction dm_error_$programming_error dm_system_data_$initializer_name error_table_$bigarg error_table_$invalid_ring_brackets error_table_$namedup error_table_$no_r_permission error_table_$noentry error_table_$not_dm_ring error_table_$not_seg_type fm_data_$file_access_table_ptr sys_info$data_management_ringno LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 172 001170 173 001171 174 001172 176 001174 178 001177 180 001200 181 001210 182 001211 184 001212 185 001213 186 001215 187 001216 189 001220 192 001221 193 001223 194 001225 195 001226 198 001230 209 001264 6 35 001267 6 36 001271 10 49 001272 11 61 001273 14 38 001274 155 001277 434 001332 435 001333 437 001335 451 001336 454 001371 455 001372 457 001373 459 001374 462 001375 464 001427 465 001430 466 001436 467 001454 471 001512 473 001532 474 001535 486 001537 488 001564 492 001570 494 001575 497 001626 499 001654 501 001655 504 001671 513 001717 514 001726 515 001750 516 001761 518 001770 519 002015 525 002070 529 002076 537 002077 541 002112 542 002115 543 002117 546 002121 551 002155 555 002212 558 002216 564 002266 567 002272 573 002335 576 002357 579 002401 581 002406 596 002507 597 002511 598 002514 599 002517 600 002521 601 002523 602 002531 605 002533 606 002537 608 002543 610 002554 618 002565 621 002570 624 002601 631 002612 633 002635 640 002710 641 002723 646 003017 647 003022 651 003023 652 003025 654 003027 660 003030 663 003037 664 003056 666 003103 667 003105 668 003107 669 003112 670 003115 671 003120 675 003152 686 003223 688 003250 696 003326 700 003342 701 003355 707 003430 708 003432 710 003433 712 003460 716 003531 717 003533 718 003540 720 003541 722 003566 729 003637 730 003646 731 003673 735 00374 ----------------------------------------------------------- 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