COMPILATION LISTING OF SEGMENT rcp_rcse_ Compiled by: Multics PL/I Compiler, Release 32f, of October 9, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 11/11/89 0943.8 mst Sat Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* *********************************************************** */ 11 12 13 rcp_rcse_: procedure; 14 15 /* This program is an internal interface of RCP. 16** Created on 11/20/74 by Bill Silver. 17** 18** This program manages the entries in RCS. It also keeps a list of 19** the RCS entries used by this process. There is a separate list for 20** attachments and assignments. This program has the following entries: 21** 1. get - Gets a free entry and assigns it to the calling process. 22** 2. free - Frees an entry and puts it back onto the free list. 23** 3. info - Returns the offset of the first entry and the total 24** number of entries in the attach and assign lists. 25**/ 26 27 28 /* ARGUMENT DATA */ 29 30 dcl arg_assign_off bit(18); /* (O) Offset of first entry in assign list. */ 31 dcl arg_attach_off bit(18); /* (O) Offset of first entry in attach list. */ 32 dcl arg_ecode fixed bin(35); /* (O) error_table_ code. */ 33 dcl arg_num_assign fixed bin; /* (O) Number of assignment RCS entries. */ 34 dcl arg_num_attach fixed bin; /* (O) Number of attachment RCS entries. */ 35 dcl arg_rcse_ptr ptr; /* (I/O) Pointer to the RCSE we are dealing with. */ 36 37 38 /* AUTOMATIC DATA */ 39 40 dcl ecode fixed bin(35); /* error_table_ code. */ 41 dcl frcse_off bit(18); /* Offset of RCS entry being freed. */ 42 dcl id_count fixed bin; /* Unique ID count. */ 43 dcl rcse_off bit(18); /* Offset of specified RCS entry. */ 44 dcl kind fixed bin; /* RCS entry kind. */ 45 dcl trcse_ptr ptr; /* Pointer to template RCSE. */ 46 dcl urcse_off bit(18); /* Offset of next entry on process list. */ 47 48 49 /* BASED DATA */ 50 51 dcl 1 trcse like rcse based(trcse_ptr) aligned; /* Used to copy template RCSE. */ 52 53 54 /* INTERNAL STATIC DATA ** Used to keep per process RCP info. */ 55 56 dcl attach_off bit(18) /* Top of attach RCS entry list for this process. */ 57 internal static init ("0"b); 58 dcl num_attach fixed bin /* Number of attach RCS entries for process. */ 59 internal static init(0); 60 dcl max_attach fixed bin /* Maximum number of attach entries allowed. */ 61 internal static init (16); 62 63 dcl assign_off bit(18) /* Top of assign list. */ 64 internal static init ("0"b); 65 dcl num_assign fixed bin /* Number of assign entries. */ 66 internal static init (0); 67 dcl max_assign fixed bin /* Max number of assign entries. */ 68 internal static init (16); 69 70 71 /* EXTERNAL ENTRIES CALLED */ 72 73 dcl cleanup condition; /* Cleanup handler needed to reset lock. */ 74 75 dcl ( addr, null, ptr, rel, string ) builtin; 76 77 dcl ( error_table_$bad_index, 78 error_table_$fatal_error, 79 error_table_$noalloc ) fixed bin(35) external; 80 81 dcl clock_ entry returns (fixed bin(71)); 82 dcl rcp_lock_$lock entry (ptr, fixed bin(35)); 83 dcl rcp_lock_$unlock entry (ptr); 84 dcl rcp_pointers_$com_seg entry returns (ptr); 85 /* */ 1 1 /* Begin include file ... rcp_com_seg.incl.pl1 1 2* * 1 3* * Created on 11/20/74 by Bill Silver. 1 4* * Modified on 09/19/77 by R.J.C. Kissel to add label authentication bits. 1 5* * Modified on 12/09/78 by Michael R. Jordan to add removable media bit and label_type. 1 6* * Modified 1/79 by R.J.C. Kissel to add disk label authentication bits. 1 7* * Modified 2/79 by Michael R. Jordan to add volume_density. 1 8* * Modified 11/84 by Paul Farley to add fips flag. 1 9* * Modified 1/3/85 by Fawcett to allow room for mca device type 1 10* * Modified 02/85 by Paul Farley to add no_protect and opr_int_available flags. 1 11* * This include file defines the Resource Control Package communication segment. 1 12* * This segment is used to communicate requests between the various internal 1 13* * parts of RCP. 1 14**/ 1 15 1 16 /****^ HISTORY COMMENTS: 1 17* 1) change(85-09-09,Farley), approve(85-09-09,MCR6979), 1 18* audit(85-12-09,CLJones), install(86-03-21,MR12.0-1033): 1 19* Support MCA and FIPS. 1 20* END HISTORY COMMENTS */ 1 21 1 22 dcl lock_info_ptr ptr; /* Pointer to lock info structure. */ 1 23 dcl rcs_ptr ptr; /* Pointer to base of RCS. */ 1 24 dcl rcse_ptr ptr; /* Pointer to an RCS entry. */ 1 25 1 26 dcl 1 based_rcp_id based aligned, /* Overlay of an rcp_id. */ 1 27 (2 id_count fixed bin (17), /* Unique count index. */ 1 28 2 rcse_off bit (18)) unaligned; /* Offset of rcp_com_seg entry. */ 1 29 1 30 dcl 1 rcs based (rcs_ptr) aligned, /* Begin at word zero of rcp_com_seg. */ 1 31 2 lock_info like lock_info, /* Data used to lock this segment. */ 1 32 2 ws_maxs (8) fixed bin (19), /* Max IOI workspace size in words. */ 1 33 2 ws_pmaxs (8) fixed bin (19), /* Max IOI workspace size for priv attachments. */ 1 34 2 to_maxs (8) fixed bin (71), /* Max IOI time-out intervals in microseconds. */ 1 35 2 sys_directory char (32), /* Directory used to define a system process. */ 1 36 2 sys_acs char (32), /* Entry name used to define a system process. */ 1 37 2 acs_directory char (32), /* Directory containing device ACSs. */ 1 38 2 id_count fixed bin (35), /* Counter used to form rcp_id. */ 1 39 2 max_entries fixed bin, /* Maximum number of entries allowed. */ 1 40 2 num_entries fixed bin, /* Total number of entries. */ 1 41 2 first_free_off bit (18), /* Offset of first free entry. */ 1 42 2 entry (0 refer (rcs.num_entries)) /* Array of request entries. */ 1 43 like rcse, /* See structure below. */ 1 44 2 end bit (36); /* End of rcp_com_seg. */ 1 45 1 46 dcl 1 lock_info based (lock_info_ptr) aligned, /* Used to meter locking. */ 1 47 2 lock bit (36), /* The lock itself. */ 1 48 2 num_locks fixed bin (35), /* Number of times locked. */ 1 49 2 num_lock_waits fixed bin (35), /* Number of lock waits. */ 1 50 2 time_of_lock fixed bin (71), /* Time of last lock. */ 1 51 2 tot_lock_time fixed bin (71), /* Total time locked. */ 1 52 2 tot_wait_time fixed bin (71), /* Total time waiting for lock. */ 1 53 2 starting_time fixed bin (71); /* Time metering started. */ 1 54 1 55 dcl 1 rcse based (rcse_ptr) aligned, /* Up to state must = rcpd.device. */ 1 56 2 device_name char (8), /* Name of device associated with this entry. */ 1 57 2 volume_name char (32), /* Volume name. Blank => no volume. */ 1 58 2 dtypex fixed bin, /* Device type index. */ 1 59 2 model fixed bin, /* Device model number. */ 1 60 2 num_qualifiers fixed bin, /* Number of device qualifiers. */ 1 61 2 qualifiers (4) fixed bin (35), /* Device qualifiers. */ 1 62 2 state_time fixed bin (71), /* Time device put into current state. */ 1 63 2 state fixed bin, /* 0 - free 1 - assigning 2 - assigned */ 1 64 /* 3 - attaching 4 - attached 5 - completed. */ 1 65 1 66 /* * * * * ** Following fields are unique to RCS entry. */ 1 67 2 kind fixed bin, /* 1 => attach, 2 => assign */ 1 68 2 free_off bit (18), /* Offset of next free entry. 0 => not free. */ 1 69 2 user_off bit (18), /* Offset of next entry in user list. */ 1 70 2 device_off bit (18), /* Offset of device entry in RCPD. */ 1 71 2 volume_off bit (18), /* Offset of volume entry in RCPD. */ 1 72 2 rcse_off bit (18), /* Offset of associated RCS entry. */ 1 73 2 caller_level fixed bin, /* Caller's validation level. */ 1 74 2 disposition bit (1), /* ON => retain, OFF => unassign. */ 1 75 2 flags, /* Special info flags. */ 1 76 (3 device bit (1), /* ON => assigning a specific device. */ 1 77 3 priv bit (1), /* ON => attached with IOI privilege. */ 1 78 3 system bit (1), /* ON => assigned to a system process. */ 1 79 3 t_and_d bit (1), /* ON => T&D attachment. */ 1 80 3 volume bit (1), /* ON => volume associated with this device. */ 1 81 3 writing bit (1), /* ON => writing on volume. */ 1 82 3 have_auth bit (1), /* ON => tape volume authenticated. */ 1 83 3 need_auth bit (1), /* ON => tape volume needs authentication. */ 1 84 3 auth_set bit (1), /* ON => "have_auth" has been set. */ 1 85 3 preload_allowed bit (1), /* ON => preloading of volumes is allowed. */ 1 86 3 preloaded bit (1), /* ON => volume may be loaded on device. */ 1 87 3 not_removable_media bit (1), /* ON => cannot remove volume from device. */ 1 88 3 disk_ss_pack bit (1), /* ON => disk is a storage system volume. */ 1 89 3 disk_copy_of_ss_pack bit (1), /* ON => disk is a copy of a storage system volume. */ 1 90 3 disk_io_pack bit (1), /* ON => disk has label but is not storage system. */ 1 91 3 disk_unregistered bit (1), /* ON => disk is unregistered storage system volume. */ 1 92 3 disk_unreadable bit (1), /* ON => io error reading disk label. */ 1 93 3 must_auto_register bit (1), /* ON => unregistered volume requested */ 1 94 3 fips bit (1), /* ON => FIPS device. */ 1 95 3 no_protect bit (1), /* ON => device has no protect sw. */ 1 96 3 opr_int_available bit (1), /* ON => device connected to MPC with OI button. */ 1 97 3 unused bit (6), 1 98 3 volume_density_index fixed bin (3) unsigned, /* Density of volume */ 1 99 3 label_type fixed bin (6) unsigned)unaligned, /* Type of label read by RCP. */ 1 100 2 rcp_id bit (36), /* ID of this entry. */ 1 101 2 event_id fixed bin (71), /* Caller's event channel ID. */ 1 102 2 process_id bit (36), /* ID of calling process. */ 1 103 2 group_id char (32), /* Group ID of calling process. */ 1 104 2 ecode fixed bin (35), /* Assignment error code. */ 1 105 2 version_num fixed bin, /* Device info version number. */ 1 106 2 workspace_max fixed bin (19), /* Max size of IOI workspace buffer. */ 1 107 2 timeout_max fixed bin (71), /* Max IOI time-out interval. */ 1 108 2 ioi_index fixed bin, /* IOI device index. */ 1 109 2 workspace_ptr ptr, /* Pointer to IOI workspace buffer. */ 1 110 2 caller_comment char (64); /* Caller's comment. */ 1 111 1 112 /* End of include file ... rcp_com_seg.incl.pl1 */ 86 87 /* */ 88 get: entry (arg_rcse_ptr, arg_ecode); 89 90 /* This entry will get a free RCS entry and assign it to the calling process. 91** It will initialize the fields in this entry that are common to all kinds 92** of requests. It will add this entry to the correct list of RCS entries 93** maintained for this process. 94**/ 95 trcse_ptr = arg_rcse_ptr; /* Get pointer to template RCSE. */ 96 rcs_ptr = rcp_pointers_$com_seg (); /* Get pointer to base of RCS. */ 97 rcse_ptr = null(); /* No entry assigned yet. */ 98 lock_info_ptr = addr(rcs.lock_info); /* Get pointer to lock structure. */ 99 kind = trcse.kind; /* Get kind of RCSE to be allocated. */ 100 101 if kind = 1 /* Has process RCS entry limit been reached? */ 102 then if num_attach = max_attach 103 then do; /* Yes, too many attach RCS entries. */ 104 arg_ecode = error_table_$noalloc; 105 return; 106 end; 107 else; 108 else if num_assign = max_assign 109 then do; /* Yes, too many assign RCS entries. */ 110 arg_ecode = error_table_$noalloc; 111 return; 112 end; 113 114 on cleanup begin; /* Must unlock RCS if trouble. */ 115 call rcp_lock_$unlock (lock_info_ptr); 116 end; 117 118 call rcp_lock_$lock (lock_info_ptr, ecode); 119 if ecode ^= 0 /* Can't get entry if error in locking. */ 120 then goto GET_RETURN; 121 122 call GET_FREE_ENTRY; /* Get pointer and offset of next free entry. */ 123 if ecode ^= 0 /* Did we get one? */ 124 then do; /* No, unlock RCS. */ 125 call rcp_lock_$unlock (lock_info_ptr); 126 goto GET_RETURN; 127 end; 128 129 rcse = trcse; /* Copy template RCSE into its real entry slot. */ 130 rcse.free_off = "0"b; /* Not on free list now. */ 131 rcse.state = 1; /* 1 => entry no longer free. */ 132 133 id_count, /* Get next unique ID index. */ 134 rcs.id_count = rcs.id_count + 1; 135 136 call rcp_lock_$unlock (lock_info_ptr); 137 revert cleanup; 138 139 rcse.state_time = clock_(); /* Now fill in other RCS entry fields. */ 140 addr(rcse.rcp_id)->based_rcp_id.id_count = id_count; 141 addr(rcse.rcp_id)->based_rcp_id.rcse_off = rcse_off; 142 143 /* Put this RCS entry at the top of the correct process entry list. 144**/ 145 if kind = 1 /* Which list should we add it to? */ 146 then do; /* Attachment list. */ 147 rcse.user_off = attach_off; /* Link to previous first entry. */ 148 attach_off = rcse_off; /* Set up new first entry. */ 149 num_attach = num_attach + 1; /* Update count of attach RCS entries. */ 150 end; 151 else do; /* Assignment list. */ 152 rcse.user_off = assign_off; /* Link up the same way. */ 153 assign_off = rcse_off; 154 num_assign = num_assign + 1; 155 end; 156 157 GET_RETURN: 158 arg_rcse_ptr = rcse_ptr; /* Return arguments. */ 159 arg_ecode = ecode; 160 return; 161 /* */ 162 free: entry (arg_rcse_ptr, arg_ecode); 163 164 /* This entry will put the specified RCS entry back onto the free list. 165** It will remove it from the correct RCP entries list maintained for 166** the process. 167**/ 168 rcse_ptr = arg_rcse_ptr; /* Argument points to specified entry. */ 169 kind = rcse.kind; /* Get entry kind. */ 170 171 rcs_ptr = ptr(rcse_ptr, "0"b); /* Get pointer to base of RCS. */ 172 lock_info_ptr = addr(rcs.lock_info); 173 frcse_off = rel(rcse_ptr); /* Get offset of RCS entry to be freed. */ 174 urcse_off = rcse.user_off; /* Offset of next RCS entry on process list. */ 175 176 on cleanup begin; /* Must unlock RCS if trouble. */ 177 call rcp_lock_$unlock (lock_info_ptr); 178 end; 179 180 call rcp_lock_$lock (lock_info_ptr, ecode); 181 if ecode ^= 0 /* Can't free if there is an error in locking. */ 182 then goto FREE_RETURN; 183 184 /* Reset entry values and put it back on free list. 185**/ 186 rcse.state = 0; /* Entry free. */ 187 rcse.kind = 0; /* Free => no kind of RCS entry. */ 188 rcse.free_off = rcs.first_free_off; /* Get offset of next free entry. */ 189 rcs.first_free_off = frcse_off; /* Put on top of free list. */ 190 rcse.process_id = "0"b; /* Process no longer owns this entry. */ 191 192 call rcp_lock_$unlock (lock_info_ptr); 193 revert cleanup; 194 195 /* Take this entry out of the process list that it is in. 196**/ 197 if kind = 1 /* Which list is it in? */ 198 then do; /* Attach list. */ 199 rcse_off = attach_off; /* Get first attach RCS entry. */ 200 num_attach = num_attach - 1; /* Update count of attach RCS entries. */ 201 end; 202 else do; /* Assign list. */ 203 rcse_off = assign_off; 204 num_assign = num_assign - 1; 205 end; 206 207 if rcse_off = frcse_off /* Are we freeing first entry on list? */ 208 then do; /* Yes, get new first entry. */ 209 if kind = 1 /* Again, decide which list. */ 210 then attach_off = urcse_off; 211 else assign_off = urcse_off; 212 goto FREE_RETURN; 213 end; 214 215 do while (rcse_off ^= "0"b); /* Not first entry. Look through list. */ 216 rcse_ptr = ptr(rcs_ptr, rcse_off); /* Get pointer to current entry. */ 217 if rcse.user_off = frcse_off /* Is next entry the one? */ 218 then do; /* Yes, update value in next user offset. */ 219 rcse.user_off = urcse_off; 220 goto FREE_RETURN; 221 end; 222 rcse_off = rcse.user_off; /* No, get next entry in this list. */ 223 end; 224 225 ecode = error_table_$bad_index; /* Bad trouble, entry not on list. */ 226 227 FREE_RETURN: 228 arg_ecode = ecode; 229 return; 230 /* */ 231 info: entry (arg_attach_off, arg_num_attach, arg_assign_off, arg_num_assign); 232 233 /* This entry is called to get the offsets of the first RCS entry 234** on each of the process lists. It will also return the number 235** of each kind of RCS entries. 236**/ 237 arg_attach_off = attach_off; /* Just get them from internal static. */ 238 arg_num_attach = num_attach; 239 240 arg_assign_off = assign_off; 241 arg_num_assign = num_assign; 242 243 return; 244 245 246 247 248 249 GET_FREE_ENTRY: procedure; 250 251 /* This procedure is called to get the pointer and offset of a free RCS entry. 252** We will always get the first free entry. If there are no free entries we 253** will add a new entry to RCS. 254**/ 255 rcse_off = rcs.first_free_off; /* Get offset of first free entry. */ 256 if rcse_off ^= "0"b /* Is there a free entry? */ 257 then do; /* Yes. */ 258 rcse_ptr = ptr(rcs_ptr,rcse_off); /* Get pointer to this free entry. */ 259 rcs.first_free_off = rcse.free_off; /* Get next first free entry. */ 260 return; 261 end; 262 263 if rcs.num_entries = rcs.max_entries /* No, is there room for another entry? */ 264 then do; /* No, we cannot get a free entry. */ 265 ecode = error_table_$fatal_error; 266 return; 267 end; 268 269 rcs.num_entries = rcs.num_entries + 1; /* Room for another entry. */ 270 rcse_ptr = addr(rcs.entry(rcs.num_entries)); 271 rcse_off = rel(rcse_ptr); /* Get pointer and offset of new entry. */ 272 273 end GET_FREE_ENTRY; 274 275 end rcp_rcse_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/11/89 0807.0 rcp_rcse_.pl1 >spec>install>1111>rcp_rcse_.pl1 86 1 03/27/86 1120.0 rcp_com_seg.incl.pl1 >ldd>include>rcp_com_seg.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. addr builtin function dcl 75 ref 98 140 141 172 270 arg_assign_off parameter bit(18) packed unaligned dcl 30 set ref 231 240* arg_attach_off parameter bit(18) packed unaligned dcl 31 set ref 231 237* arg_ecode parameter fixed bin(35,0) dcl 32 set ref 88 104* 110* 159* 162 227* arg_num_assign parameter fixed bin(17,0) dcl 33 set ref 231 241* arg_num_attach parameter fixed bin(17,0) dcl 34 set ref 231 238* arg_rcse_ptr parameter pointer dcl 35 set ref 88 95 157* 162 168 assign_off 000012 internal static bit(18) initial packed unaligned dcl 63 set ref 152 153* 203 211* 240 attach_off 000010 internal static bit(18) initial packed unaligned dcl 56 set ref 147 148* 199 209* 237 based_rcp_id based structure level 1 dcl 1-26 cleanup 000112 stack reference condition dcl 73 ref 114 137 176 193 clock_ 000022 constant entry external dcl 81 ref 139 ecode 000100 automatic fixed bin(35,0) dcl 40 set ref 118* 119 123 159 180* 181 225* 227 265* entry 110 based structure array level 2 dcl 1-30 set ref 270 error_table_$bad_index 000014 external static fixed bin(35,0) dcl 77 ref 225 error_table_$fatal_error 000016 external static fixed bin(35,0) dcl 77 ref 265 error_table_$noalloc 000020 external static fixed bin(35,0) dcl 77 ref 104 110 first_free_off 107 based bit(18) level 2 dcl 1-30 set ref 188 189* 255 259* frcse_off 000101 automatic bit(18) packed unaligned dcl 41 set ref 173* 189 207 217 free_off 26 based bit(18) level 2 dcl 1-55 set ref 130* 188* 259 id_count 104 based fixed bin(35,0) level 2 in structure "rcs" dcl 1-30 in procedure "rcp_rcse_" set ref 133 133* id_count 000102 automatic fixed bin(17,0) dcl 42 in procedure "rcp_rcse_" set ref 133* 140 id_count based fixed bin(17,0) level 2 in structure "based_rcp_id" packed packed unaligned dcl 1-26 in procedure "rcp_rcse_" set ref 140* kind 25 based fixed bin(17,0) level 2 in structure "rcse" dcl 1-55 in procedure "rcp_rcse_" set ref 169 187* kind 25 based fixed bin(17,0) level 2 in structure "trcse" dcl 51 in procedure "rcp_rcse_" ref 99 kind 000104 automatic fixed bin(17,0) dcl 44 in procedure "rcp_rcse_" set ref 99* 101 145 169* 197 209 lock_info based structure level 2 in structure "rcs" dcl 1-30 in procedure "rcp_rcse_" set ref 98 172 lock_info based structure level 1 dcl 1-46 in procedure "rcp_rcse_" lock_info_ptr 000120 automatic pointer dcl 1-22 set ref 98* 115* 118* 125* 136* 172* 177* 180* 192* max_assign constant fixed bin(17,0) initial dcl 67 ref 108 max_attach constant fixed bin(17,0) initial dcl 60 ref 101 max_entries 105 based fixed bin(17,0) level 2 dcl 1-30 ref 263 null builtin function dcl 75 ref 97 num_assign 000013 internal static fixed bin(17,0) initial dcl 65 set ref 108 154* 154 204* 204 241 num_attach 000011 internal static fixed bin(17,0) initial dcl 58 set ref 101 149* 149 200* 200 238 num_entries 106 based fixed bin(17,0) level 2 dcl 1-30 set ref 263 269* 269 270 process_id 42 based bit(36) level 2 dcl 1-55 set ref 190* ptr builtin function dcl 75 ref 171 216 258 rcp_id 36 based bit(36) level 2 dcl 1-55 set ref 140 141 rcp_lock_$lock 000024 constant entry external dcl 82 ref 118 180 rcp_lock_$unlock 000026 constant entry external dcl 83 ref 115 125 136 177 192 rcp_pointers_$com_seg 000030 constant entry external dcl 84 ref 96 rcs based structure level 1 dcl 1-30 rcs_ptr 000122 automatic pointer dcl 1-23 set ref 96* 98 133 133 171* 172 188 189 216 255 258 259 263 263 269 269 270 270 rcse based structure level 1 dcl 1-55 set ref 129* rcse_off 0(18) based bit(18) level 2 in structure "based_rcp_id" packed packed unaligned dcl 1-26 in procedure "rcp_rcse_" set ref 141* rcse_off 000103 automatic bit(18) packed unaligned dcl 43 in procedure "rcp_rcse_" set ref 141 148 153 199* 203* 207 215 216 222* 255* 256 258 271* rcse_ptr 000124 automatic pointer dcl 1-24 set ref 97* 129 130 131 139 140 141 147 152 157 168* 169 171 173 174 186 187 188 190 216* 217 219 222 258* 259 270* 271 rel builtin function dcl 75 ref 173 271 state 24 based fixed bin(17,0) level 2 dcl 1-55 set ref 131* 186* state_time 22 based fixed bin(71,0) level 2 dcl 1-55 set ref 139* trcse based structure level 1 dcl 51 ref 129 trcse_ptr 000106 automatic pointer dcl 45 set ref 95* 99 129 urcse_off 000110 automatic bit(18) packed unaligned dcl 46 set ref 174* 209 211 219 user_off 27 based bit(18) level 2 dcl 1-55 set ref 147* 152* 174 217 219* 222 NAME DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. string builtin function dcl 75 NAMES DECLARED BY EXPLICIT CONTEXT. FREE_RETURN 000422 constant label dcl 227 ref 181 212 220 GET_FREE_ENTRY 000457 constant entry internal dcl 249 ref 122 GET_RETURN 000235 constant label dcl 157 ref 119 126 free 000245 constant entry external dcl 162 get 000025 constant entry external dcl 88 info 000433 constant entry external dcl 231 rcp_rcse_ 000013 constant entry external dcl 13 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 650 702 511 660 Length 1112 511 32 173 136 4 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME rcp_rcse_ 102 external procedure is an external procedure. on unit on line 114 68 on unit on unit on line 176 68 on unit GET_FREE_ENTRY internal procedure shares stack frame of external procedure rcp_rcse_. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 attach_off rcp_rcse_ 000011 num_attach rcp_rcse_ 000012 assign_off rcp_rcse_ 000013 num_assign rcp_rcse_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME rcp_rcse_ 000100 ecode rcp_rcse_ 000101 frcse_off rcp_rcse_ 000102 id_count rcp_rcse_ 000103 rcse_off rcp_rcse_ 000104 kind rcp_rcse_ 000106 trcse_ptr rcp_rcse_ 000110 urcse_off rcp_rcse_ 000120 lock_info_ptr rcp_rcse_ 000122 rcs_ptr rcp_rcse_ 000124 rcse_ptr rcp_rcse_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out return_mac enable_op ext_entry int_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. clock_ rcp_lock_$lock rcp_lock_$unlock rcp_pointers_$com_seg THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$bad_index error_table_$fatal_error error_table_$noalloc LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 13 000012 88 000020 95 000032 96 000036 97 000044 98 000046 99 000050 101 000053 104 000061 105 000064 107 000065 108 000066 110 000072 111 000075 114 000076 115 000112 116 000121 118 000122 119 000133 122 000135 123 000136 125 000140 126 000147 129 000150 130 000155 131 000156 133 000160 136 000166 137 000175 139 000176 140 000206 141 000212 145 000215 147 000220 148 000223 149 000225 150 000226 152 000227 153 000232 154 000234 157 000235 159 000240 160 000242 162 000243 168 000252 169 000256 171 000260 172 000262 173 000264 174 000266 176 000270 177 000304 178 000313 180 000314 181 000325 186 000327 187 000331 188 000332 189 000335 190 000337 192 000340 193 000347 197 000350 199 000353 200 000356 201 000360 203 000361 204 000364 207 000366 209 000370 211 000376 212 000400 215 000401 216 000404 217 000407 219 000412 220 000414 222 000415 223 000416 225 000417 227 000422 229 000425 231 000426 237 000440 238 000446 240 000450 241 000454 243 000456 249 000457 255 000460 256 000463 258 000464 259 000467 260 000471 263 000472 265 000475 266 000500 269 000501 270 000502 271 000506 273 000510 ----------------------------------------------------------- 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