COMPILATION LISTING OF SEGMENT lm_copy_data_ Compiled by: Multics PL/I Compiler, Release 28e, of February 14, 1985 Compiled at: Honeywell Multics Op. - System M Compiled on: 03/05/85 0908.1 mst Tue Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 4* * * 5* *********************************************************** */ 6 7 /* DESCRIPTION: 8* lm_copy_data_ --Program to copy all the data segments under the log 9**/ 10 11 /* HISTORY: 12* 13*Written by Benson I. Margulies, 04/29/83. 14*Modified: 15*05/01/84 by R. Michael Tague: Added the History section. Added 16* %include dm_lm_meters. 17*10/17/84 by Stanford S. Cox: For DM program standards. 18*12/04/84 by Stanford S. Cox: system_segment_count: Chg to return (0) 19**/ 20 21 /* format: style2,^inddcls,ifthenstmt,ifthendo,^indnoniterdo,^inditerdo,ind3,idind32 */ 22 lm_copy_data_: 23 procedure (p_copy_info_ptr, p_code); 24 25 declare p_copy_info_ptr pointer; 26 declare p_code fixed bin (35); 27 28 dcl ME char (13) int static options (constant) init ("lm_copy_data_"); 29 30 declare lock_manager_$lock_lock_data entry (fixed bin (35)); 31 declare lock_manager_$unlock_lock_data entry (fixed bin (35)); 32 33 declare error_table_$smallarg fixed bin (35) ext static; 34 declare error_table_$unimplemented_version 35 fixed bin (35) ext static; 36 37 declare dm_system_data_$max_n_transactions 38 fixed bin ext static; 39 declare lm_data_$lock_seg_ptr pointer ext static; 40 declare lm_data_$lock_segments_ptr pointer ext static; 41 declare lm_data_$n_lock_segments fixed bin external; 42 declare cleanup condition; 43 44 declare sx fixed bin; 45 dcl sub_err_ entry () options (variable); 46 47 48 lm_copy_data_ptr = p_copy_info_ptr; 49 p_code = 0; 50 call CHECK_VERSION (LM_COPY_DATA_VERSION_1, lm_copy_data.version, "lm_copy_data"); 51 52 on cleanup call lock_manager_$unlock_lock_data (0); 53 call lock_manager_$lock_lock_data (p_code); 54 if p_code ^= 0 then return; 55 56 lock_seg_ptr = lm_data_$lock_seg_ptr; 57 call CHECK_VERSION (LOCK_SEG_VERSION_1, lock_seg.version, "lock_seg"); 58 lock_segments_ptr = lm_data_$lock_segments_ptr; 59 60 do sx = 1 to min (lm_copy_data.n_segments, lm_data_$n_lock_segments); 61 call COPY_SEGMENT ((lock_segments.seg_baseptr (sx)), lm_copy_data.segment_ptrs (sx)); 62 end; 63 64 lm_copy_data.n_system_segments = lm_data_$n_lock_segments; 65 if lm_copy_data.n_segments < lm_copy_data.n_system_segments then p_code = error_table_$smallarg; 66 call lock_manager_$unlock_lock_data (0); 67 return; 68 69 70 system_segment_count: 71 entry (p_code) returns (fixed bin); 72 73 p_code = 0; 74 lock_seg_ptr = lm_data_$lock_seg_ptr; 75 on cleanup call lock_manager_$unlock_lock_data (0); 76 call lock_manager_$lock_lock_data (p_code); /* this will make lm_data_$n_lock_segments up to date */ 77 if p_code ^= 0 then return (0); 78 call lock_manager_$unlock_lock_data (0); 79 return (lm_data_$n_lock_segments); 80 81 82 COPY_SEGMENT: 83 procedure (cs_p_from, cs_p_to); 84 85 declare cs_p_from pointer; 86 declare cs_p_to pointer; 87 declare cs_max_length fixed bin (19); 88 declare cs_copy_template (lock_seg.lock_seg_size) bit (36) aligned based; 89 90 /* no business failing */ 91 cs_p_to -> cs_copy_template = cs_p_from -> cs_copy_template; 92 return; 93 end COPY_SEGMENT; 94 95 CHECK_VERSION: 96 proc (cv_p_expected_version, cv_p_received_version, cv_p_structure_name); 97 98 dcl cv_p_expected_version char (8) aligned parameter; 99 dcl cv_p_received_version char (8) aligned parameter; 100 dcl cv_p_structure_name char (32) aligned parameter; 101 102 if cv_p_expected_version ^= cv_p_received_version 103 then call sub_err_ (error_table_$unimplemented_version, ME, ACTION_CANT_RESTART, null (), 0, 104 "^/Expected version ^a of the ^a structure." || "^/Received version ^a instead.", cv_p_expected_version, 105 cv_p_structure_name, cv_p_received_version); 106 end CHECK_VERSION; 107 108 1 1 /* START OF: dm_lm_copy_data.incl.pl1 * * * * * * * * * * * * * * * * * * * */ 1 2 1 3 /* DESCRIPTION: 1 4* 1 5* Pointers to copied lock segments data. 1 6**/ 1 7 1 8 /* HISTORY: 1 9* 1 10*Written by Benson Margulies, 04/29/83. 1 11*Modified: 1 12*12/04/84 by Stanford S. Cox: Added Description. 1 13**/ 1 14 /* format:style3 */ 1 15 1 16 declare lm_copy_data_ptr pointer; 1 17 declare 1 lm_copy_data aligned based (lm_copy_data_ptr), 1 18 2 version char (8) aligned, 1 19 2 n_system_segments fixed bin, /* Output, for convienience */ 1 20 2 n_segments fixed bin, /* Input */ 1 21 2 segment_ptrs (lm_copy_data_n_segments refer (lm_copy_data.n_segments)) 1 22 pointer; 1 23 1 24 declare lm_copy_data_n_segments fixed bin; 1 25 declare LM_COPY_DATA_VERSION_1 char (8) aligned init ("lmdt0001") int static options (constant); 1 26 1 27 1 28 /* END OF: dm_lm_copy_data.incl.pl1 * * * * * * * * * * * * * * * * * * * */ 109 2 1 /* BEGIN INCLUDE FILE - dm_lm_system_data.incl.pl1 */ 2 2 2 3 /* format: style3,idind25 */ 2 4 /* HISTORY: 2 5* 2 6*Written by Benson Margulies, 4/83. 2 7*Modified: 2 8*04/24/84 by R. Michael Tague: moved the meters structure definition to 2 9* dm_lm_meters.incl.pl1. Added this history section. 2 10*05/01/84 by R. Michael Tague: removed the %include dm_lm_meters. 2 11*10/17/84 by Stanford S. Cox: Added version constant, and changed 2 12* transaction_table to use a refer extent (to allow outer ring reference). 2 13**/ 2 14 2 15 dcl lock_seg_ptr ptr; 2 16 dcl lock_transaction_table_ptr 2 17 ptr; 2 18 dcl lock_hash_table_ptr ptr; 2 19 dcl lock_aux_seg_ptr ptr; 2 20 dcl lock_block_ptr ptr; 2 21 dcl lock_block_array_ptr ptr; 2 22 dcl lock_free_block_ptr ptr; 2 23 dcl lock_object_ptr ptr; 2 24 dcl lock_owner_ptr ptr; 2 25 dcl lock_segments_ptr ptr; 2 26 dcl lock_waiter_ptr ptr; 2 27 dcl lock_deadlock_ptr ptr; 2 28 2 29 dcl n_lock_blocks fixed bin; 2 30 dcl n_lock_deadlock fixed bin; 2 31 2 32 dcl LOCK_SEG_VERSION_1 char (8) aligned init ("locksg 1") int static options (constant); 2 33 2 34 dcl 1 lock_seg aligned based (lock_seg_ptr), 2 35 /* Per-system lock data */ 2 36 2 version char (8) aligned, 2 37 2 header aligned, 2 38 3 lock fixed bin (71), /* Fast Lock on system lock operations */ 2 39 3 n_lock_segments fixed bin, /* Number of segments in system lock data */ 2 40 3 lock_seg_size fixed bin (19), /* Number of words per segment */ 2 41 3 max_lock_segments fixed bin, /* Maximum number of segments */ 2 42 3 n_transaction_table_entries 2 43 fixed bin, /* Size of transaction table */ 2 44 3 n_hash_table_entries 2 45 fixed bin, /* Size of hash table */ 2 46 3 hash_mask bit (36) aligned, /* Used by hashing routine */ 2 47 3 free_list_ptr aligned like lock_virtual_ptr, 2 48 /* Thread of free blocks */ 2 49 3 transaction_table_offset 2 50 fixed bin (18) unsigned aligned, 2 51 /* Offset of transaction table */ 2 52 3 hash_table_offset fixed bin (18) unsigned aligned, 2 53 /* Offset of hash table */ 2 54 3 n_lock_blocks fixed bin, /* Number of blocks crated */ 2 55 3 lock_array_offset fixed bin (18) unsigned aligned, 2 56 /* Offset of block array */ 2 57 2 transaction_table (0 refer (lock_seg.n_transaction_table_entries)) aligned like lock_transaction_table, 2 58 2 hash_table aligned like lock_hash_table, 2 59 2 meters aligned like lock_meters, 2 60 2 free fixed bin (71); /* Free space */ 2 61 2 62 dcl 1 lock_aux_seg aligned based (lock_aux_seg_ptr), 2 63 /* Other than first segment */ 2 64 2 n_lock_blocks fixed bin, /* Number of blocks in this segment */ 2 65 2 lock_array_offset fixed bin (18) unsigned aligned, 2 66 /* Offset of block array */ 2 67 2 free fixed bin (71); /* Free space */ 2 68 2 69 dcl 1 lock_transaction_table aligned based (lock_transaction_table_ptr), 2 70 /* Process table entry */ 2 71 2 deadlock_inx fixed bin, /* Index used for deadlock detection */ 2 72 2 process_id bit (36) aligned, /* Multics process identifier */ 2 73 2 txn_id bit (36) aligned, /* Current transaction ID */ 2 74 2 ev_channel fixed bin (71), 2 75 2 own_ptr aligned like lock_virtual_ptr, 2 76 /* First in thread of owning blocks */ 2 77 2 wait_ptr aligned like lock_virtual_ptr; 2 78 /* Waiting block */ 2 79 2 80 dcl 1 lock_hash_table aligned based (lock_hash_table_ptr), 2 81 2 buckets (lock_seg.n_hash_table_entries) aligned like lock_virtual_ptr; 2 82 2 83 2 84 dcl 1 lock_block aligned based (lock_block_ptr), 2 85 /* Generic block */ 2 86 2 seg_inx fixed bin unal, 2 87 2 type fixed bin unal, 2 88 2 pad (5) bit (36) aligned; 2 89 2 90 dcl 1 lock_block_array (n_lock_blocks) aligned like lock_block based (lock_block_array_ptr); 2 91 2 92 dcl 1 lock_free_block aligned based (lock_free_block_ptr), 2 93 /* Free block */ 2 94 2 seg_inx fixed bin unal, 2 95 2 type fixed bin unal, /* TYPE_FREE */ 2 96 2 free_fp aligned like lock_virtual_ptr, 2 97 /* Thread of free blocks */ 2 98 2 pad (4) bit (36) aligned; 2 99 2 100 dcl 1 lock_object aligned based (lock_object_ptr), 2 101 /* That which is locked */ 2 102 2 seg_inx fixed bin unal, 2 103 2 type fixed bin unal, /* TYPE_OBJECT */ 2 104 2 uid bit (36) aligned, /* Page File UID */ 2 105 2 ci_no fixed bin (35), /* Control Interval (-1 => Page File) */ 2 106 2 owners_ptr aligned like lock_virtual_ptr, 2 107 /* First in thread of owning blocks */ 2 108 2 waiters_ptr aligned like lock_virtual_ptr, 2 109 /* First in thread of waiting blocks */ 2 110 2 ht_fp aligned like lock_virtual_ptr; 2 111 /* Hash Table thread */ 2 112 2 113 dcl 1 lock_owner aligned based (lock_owner_ptr), 2 114 /* Owner of a lock */ 2 115 2 seg_inx fixed bin unal, 2 116 2 type fixed bin unal, /* TYPE_OWNER */ 2 117 2 lock_ptr aligned like lock_virtual_ptr, 2 118 /* Pointer to lock_object */ 2 119 2 mode fixed bin, /* Type of lock */ 2 120 2 owners_fp aligned like lock_virtual_ptr, 2 121 /* Thread of owners */ 2 122 2 transaction_fp aligned like lock_virtual_ptr, 2 123 /* Thread of locks owned by this transaction */ 2 124 2 transaction_ptr aligned like lock_virtual_ptr; 2 125 /* Pointer to transaction table entry */ 2 126 2 127 2 128 dcl 1 lock_waiter aligned based (lock_waiter_ptr), 2 129 /* Waiter for a lock */ 2 130 2 seg_inx fixed bin unal, 2 131 2 type fixed bin unal, /* TYPE_WAITER */ 2 132 2 lock_ptr aligned like lock_virtual_ptr, 2 133 /* Pointer to lock_object */ 2 134 2 mode fixed bin, /* Desired mode */ 2 135 2 waiters_fp aligned like lock_virtual_ptr, 2 136 /* Thread of waiters */ 2 137 2 transaction_ptr aligned like lock_virtual_ptr, 2 138 /* Process table entry of this proces */ 2 139 2 pad bit (36) aligned; 2 140 2 141 2 142 dcl 1 lock_segments aligned based (lock_segments_ptr), 2 143 2 seg_baseptr (lock_seg.n_lock_segments) ptr unal; 2 144 2 145 dcl 1 lock_virtual_ptr aligned based, 2 146 2 seg_inx fixed bin unal, 2 147 2 offset fixed bin (18) unsigned unal; 2 148 2 149 dcl 1 lock_deadlock aligned based (lock_deadlock_ptr), 2 150 2 wait_own (n_lock_deadlock, n_lock_deadlock) bit (1) unaligned; 2 151 2 152 declare 1 lock_deadlock_36 aligned based (lock_deadlock_ptr), 2 153 2 wait_own (36, 36) bit (1) unaligned; 2 154 2 155 declare 1 lock_deadlock_72 aligned based (lock_deadlock_ptr), 2 156 2 wait_own (72, 72) bit (1) unaligned; 2 157 /* (x,y) ON => x waiting for lock owned by y */ 2 158 2 159 declare lock_deadlock_txn_ids_ptr 2 160 pointer; 2 161 declare lock_deadlock_txn_ids (n_lock_deadlock) bit (36) aligned based (lock_deadlock_txn_ids_ptr); 2 162 dcl ( 2 163 TYPE_FREE init (1), 2 164 TYPE_OBJECT init (2), 2 165 TYPE_OWNER init (3), 2 166 TYPE_WAITER init (4), 2 167 MAX_TYPE init (4) 2 168 ) fixed bin int static options (constant); 2 169 2 170 2 171 dcl 1 NULL_VPTR aligned int static options (constant), 2 172 2 seg_inx fixed bin unal init (-1), 2 173 2 offset fixed bin (18) unsigned unal init (0); 2 174 2 175 2 176 dcl LOCK_BLOCK_SIZE fixed bin int static options (constant) init (6); 2 177 /* Size of all lock blocks */ 2 178 2 179 dcl LOCK_SEGNAME char (9) int static options (constant) init ("lock_seg_"); 2 180 2 181 dcl lock_segno pic "999"; 2 182 2 183 dcl ( 2 184 LOCK_MESSAGE_DEADLOCK init (1243657) 2 185 ) fixed bin (71) int static options (constant); 2 186 2 187 2 188 /* END INCLUDE FILE - dm_lm_system_data.incl.pl1 */ 110 3 1 /* BEGIN INCLUDE FILE - dm_lm_meters.incl.pl1 * 3 2* 3 3*/* format: style3,idind25 */ 3 4 3 5 /* DESCRIPTION: 3 6* 3 7* This is the lock manager meters structure. 3 8**/ 3 9 /* HISTORY: 3 10*Written by R. Michael Tague, 4/24/84. 3 11*Modified: 3 12*05/01/84 by R. Michael Tague: Collected all of the meters together into 3 13* the meters structure. 3 14**/ 3 15 3 16 dcl lock_meters_ptr ptr; 3 17 dcl LOCK_METERS_VERSION_1 char (8) aligned int static options (constant) 3 18 init ("LMMETER1"); 3 19 3 20 dcl 1 lock_meters aligned based (lock_meters_ptr), 3 21 2 version char (8), 3 22 2 lm_meters aligned, 3 23 3 lock_calls fixed bin (35), 3 24 3 unlock_all_calls fixed bin (35), 3 25 3 waits fixed bin (35), 3 26 3 deadlock_checks fixed bin (35), 3 27 3 real_deadlock_checks 3 28 fixed bin (35), 3 29 3 deadlock_checks_36 fixed bin (35), 3 30 3 deadlock_checks_72 fixed bin (35), 3 31 3 deadlock_self_youngest 3 32 fixed bin (35), 3 33 3 deadlock_other_youngest 3 34 fixed bin (35), 3 35 3 file_locks_by_mode (2:6) fixed bin (35), 3 36 3 ci_locks_by_mode (2:3) fixed bin (35), 3 37 3 allocates fixed bin (35), 3 38 3 frees fixed bin (35), 3 39 3 dup_file_locks_by_mode 3 40 (2:6) fixed bin (35), 3 41 3 dup_ci_locks_by_mode 3 42 (2:3) fixed bin (35), 3 43 3 pad (11) fixed bin (35); 3 44 3 45 /* END INCLUDE FILE - dm_lm_meters.incl.pl1 */ 111 4 1 /* BEGIN INCLUDE FILE sub_err_flags.incl.pl1 BIM 11/81 */ 4 2 /* format: style3 */ 4 3 4 4 /* These constants are to be used for the flags argument of sub_err_ */ 4 5 /* They are just "string (condition_info_header.action_flags)" */ 4 6 4 7 declare ( 4 8 ACTION_CAN_RESTART init (""b), 4 9 ACTION_CANT_RESTART init ("1"b), 4 10 ACTION_DEFAULT_RESTART 4 11 init ("01"b), 4 12 ACTION_QUIET_RESTART 4 13 init ("001"b), 4 14 ACTION_SUPPORT_SIGNAL 4 15 init ("0001"b) 4 16 ) bit (36) aligned internal static options (constant); 4 17 4 18 /* End include file */ 112 113 114 end lm_copy_data_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 03/05/85 0759.5 lm_copy_data_.pl1 >spec>on>7138.pbf>lm_copy_data_.pl1 109 1 01/07/85 0901.2 dm_lm_copy_data.incl.pl1 >ldd>include>dm_lm_copy_data.incl.pl1 110 2 01/07/85 0859.2 dm_lm_system_data.incl.pl1 >ldd>include>dm_lm_system_data.incl.pl1 111 3 01/07/85 0859.1 dm_lm_meters.incl.pl1 >ldd>include>dm_lm_meters.incl.pl1 112 4 04/16/82 0958.1 sub_err_flags.incl.pl1 >ldd>include>sub_err_flags.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. ACTION_CANT_RESTART 000000 constant bit(36) initial dcl 4-7 set ref 102* LM_COPY_DATA_VERSION_1 000004 constant char(8) initial dcl 1-25 set ref 50* LOCK_SEG_VERSION_1 000002 constant char(8) initial dcl 2-32 set ref 57* ME 000006 constant char(13) initial unaligned dcl 28 set ref 102* cleanup 000100 stack reference condition dcl 42 ref 52 75 cs_copy_template based bit(36) array dcl 88 set ref 91* 91 cs_p_from parameter pointer dcl 85 ref 82 91 cs_p_to parameter pointer dcl 86 ref 82 91 cv_p_expected_version parameter char(8) dcl 98 set ref 95 102 102* cv_p_received_version parameter char(8) dcl 99 set ref 95 102 102* cv_p_structure_name parameter char(32) dcl 100 set ref 95 102* error_table_$smallarg 000014 external static fixed bin(35,0) dcl 33 ref 65 error_table_$unimplemented_version 000016 external static fixed bin(35,0) dcl 34 set ref 102* header 2 based structure level 2 dcl 2-34 lm_copy_data based structure level 1 dcl 1-17 lm_copy_data_ptr 000110 automatic pointer dcl 1-16 set ref 48* 50 60 61 64 65 65 lm_data_$lock_seg_ptr 000020 external static pointer dcl 39 ref 56 74 lm_data_$lock_segments_ptr 000022 external static pointer dcl 40 ref 58 lm_data_$n_lock_segments 000024 external static fixed bin(17,0) dcl 41 ref 60 64 79 lock_block based structure level 1 dcl 2-84 lock_hash_table based structure level 1 dcl 2-80 lock_manager_$lock_lock_data 000010 constant entry external dcl 30 ref 53 76 lock_manager_$unlock_lock_data 000012 constant entry external dcl 31 ref 52 66 75 78 lock_meters based structure level 1 dcl 3-20 lock_seg based structure level 1 dcl 2-34 lock_seg_ptr 000112 automatic pointer dcl 2-15 set ref 56* 57 74* 91 lock_seg_size 5 based fixed bin(19,0) level 3 dcl 2-34 ref 91 lock_segments based structure level 1 dcl 2-142 lock_segments_ptr 000114 automatic pointer dcl 2-25 set ref 58* 61 lock_transaction_table based structure level 1 dcl 2-69 lock_virtual_ptr based structure level 1 dcl 2-145 n_segments 3 based fixed bin(17,0) level 2 dcl 1-17 ref 60 65 n_system_segments 2 based fixed bin(17,0) level 2 dcl 1-17 set ref 64* 65 p_code parameter fixed bin(35,0) dcl 26 set ref 22 49* 53* 54 65* 70 73* 76* 77 p_copy_info_ptr parameter pointer dcl 25 ref 22 48 seg_baseptr based pointer array level 2 packed unaligned dcl 2-142 ref 61 segment_ptrs 4 based pointer array level 2 dcl 1-17 set ref 61* sub_err_ 000026 constant entry external dcl 45 ref 102 sx 000106 automatic fixed bin(17,0) dcl 44 set ref 60* 61 61* version based char(8) level 2 in structure "lock_seg" dcl 2-34 in procedure "lm_copy_data_" set ref 57* version based char(8) level 2 in structure "lm_copy_data" dcl 1-17 in procedure "lm_copy_data_" set ref 50* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ACTION_CAN_RESTART internal static bit(36) initial dcl 4-7 ACTION_DEFAULT_RESTART internal static bit(36) initial dcl 4-7 ACTION_QUIET_RESTART internal static bit(36) initial dcl 4-7 ACTION_SUPPORT_SIGNAL internal static bit(36) initial dcl 4-7 LOCK_BLOCK_SIZE internal static fixed bin(17,0) initial dcl 2-176 LOCK_MESSAGE_DEADLOCK internal static fixed bin(71,0) initial dcl 2-183 LOCK_METERS_VERSION_1 internal static char(8) initial dcl 3-17 LOCK_SEGNAME internal static char(9) initial unaligned dcl 2-179 MAX_TYPE internal static fixed bin(17,0) initial dcl 2-162 NULL_VPTR internal static structure level 1 dcl 2-171 TYPE_FREE internal static fixed bin(17,0) initial dcl 2-162 TYPE_OBJECT internal static fixed bin(17,0) initial dcl 2-162 TYPE_OWNER internal static fixed bin(17,0) initial dcl 2-162 TYPE_WAITER internal static fixed bin(17,0) initial dcl 2-162 cs_max_length automatic fixed bin(19,0) dcl 87 dm_system_data_$max_n_transactions external static fixed bin(17,0) dcl 37 lm_copy_data_n_segments automatic fixed bin(17,0) dcl 1-24 lock_aux_seg based structure level 1 dcl 2-62 lock_aux_seg_ptr automatic pointer dcl 2-19 lock_block_array based structure array level 1 dcl 2-90 lock_block_array_ptr automatic pointer dcl 2-21 lock_block_ptr automatic pointer dcl 2-20 lock_deadlock based structure level 1 dcl 2-149 lock_deadlock_36 based structure level 1 dcl 2-152 lock_deadlock_72 based structure level 1 dcl 2-155 lock_deadlock_ptr automatic pointer dcl 2-27 lock_deadlock_txn_ids based bit(36) array dcl 2-161 lock_deadlock_txn_ids_ptr automatic pointer dcl 2-159 lock_free_block based structure level 1 dcl 2-92 lock_free_block_ptr automatic pointer dcl 2-22 lock_hash_table_ptr automatic pointer dcl 2-18 lock_meters_ptr automatic pointer dcl 3-16 lock_object based structure level 1 dcl 2-100 lock_object_ptr automatic pointer dcl 2-23 lock_owner based structure level 1 dcl 2-113 lock_owner_ptr automatic pointer dcl 2-24 lock_segno automatic picture(3) unaligned dcl 2-181 lock_transaction_table_ptr automatic pointer dcl 2-16 lock_waiter based structure level 1 dcl 2-128 lock_waiter_ptr automatic pointer dcl 2-26 n_lock_blocks automatic fixed bin(17,0) dcl 2-29 n_lock_deadlock automatic fixed bin(17,0) dcl 2-30 NAMES DECLARED BY EXPLICIT CONTEXT. CHECK_VERSION 000426 constant entry internal dcl 95 ref 50 57 COPY_SEGMENT 000411 constant entry internal dcl 82 ref 61 lm_copy_data_ 000071 constant entry external dcl 22 system_segment_count 000302 constant entry external dcl 70 NAMES DECLARED BY CONTEXT OR IMPLICATION. min builtin function ref 60 null builtin function ref 102 102 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 700 730 520 710 Length 1206 520 30 241 157 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME lm_copy_data_ 176 external procedure is an external procedure. on unit on line 52 70 on unit on unit on line 75 70 on unit COPY_SEGMENT internal procedure shares stack frame of external procedure lm_copy_data_. CHECK_VERSION internal procedure shares stack frame of external procedure lm_copy_data_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME lm_copy_data_ 000106 sx lm_copy_data_ 000110 lm_copy_data_ptr lm_copy_data_ 000112 lock_seg_ptr lm_copy_data_ 000114 lock_segments_ptr lm_copy_data_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out return signal enable ext_entry int_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. lock_manager_$lock_lock_data lock_manager_$unlock_lock_data sub_err_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$smallarg error_table_$unimplemented_version lm_data_$lock_seg_ptr lm_data_$lock_segments_ptr lm_data_$n_lock_segments LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 22 000065 48 000103 49 000106 50 000107 52 000124 53 000150 54 000157 56 000170 57 000174 58 000211 60 000215 61 000231 62 000246 64 000250 65 000254 66 000260 67 000267 70 000276 73 000313 74 000314 75 000320 76 000344 77 000353 78 000366 79 000376 82 000411 91 000413 92 000425 95 000426 102 000430 106 000517 ----------------------------------------------------------- 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