COMPILATION LISTING OF SEGMENT ring_zero_peek_ Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 11/04/82 1650.1 mst Thu Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 ring_zero_peek_: procedure (P_from_ptr, P_to_ptr, P_word_count, P_code); 12 13 /* * This routine attempts to get some specific data item from hardcore 14* * by calling phcs_$ring_0_peek or metering_ring_zero_peek_ as appropriate. 15* * There are three cases worth considering: 16* * 1) The user hasn't got access to either gate. 17* * 2) The user has access to metering_ring_zero_peek_ only. 18* * 3) The user has access to both gates. 19* * For a class 3 user, we should always call phcs_, since it is more efficient. 20* * 21* * The convoluted flow of control which tries to insure that phcs_ is always 22* * called, if possible, and that as few linkage faults as possible are taken 23* * does actually work, I believe, though considerable study is required to 24* * convince yourself of it. 25* * 26* * ring_zero_peek_$by_name, ring_zero_peek_$by_definition: 27* * 28* * There are additional entrypoints for peeking by segment name and definition. 29* * These are present so programs which need to copy from named ring zero segments 30* * or particular ring zero definitions can avoid the inconvenience of calling 31* * ring0_get_ every time, maintaining static pointers, initializing them, etc. 32* * 33* * Since it would be expensive to always call ring0_get_, ring_zero_peek_ 34* * maintains a hashed list of the segment names and definitions it has been called 35* * to look up, and uses the pointers stored therein rather than using ring0_get_ 36* * every time. 37* * 38* * This efficiency mechanism should make the additional cost of using ring_zero_peek_ 39* * to copy by name or definition quite negligible, and the interface provided is far 40* * more convenient than the usual techniques. In those occasional programs where 41* * efficiency and absolute minimum of page faults are very important, the static 42* * pointer technique will be more efficient. 43* * 44* * The hashed lookup table should always work, since it is effectively serving only 45* * as a cache on a static database, that of ring zero segments and definitions. 46* * Since this database is read off the system tape, and is never changed throughout 47* * the duration of a bootload, the cache is guaranteed to always be valid, and needs 48* * no flushing or clearing protocols. 49* * 50* * First written on January 14, 1974 by R F Mabee. 51* * Last modified on 01/17/74 at 15:05:27 by R F Mabee. 52* * Last modified on 05/26/79 W. Olin Sibert, to call phcs_ if possible 53* * Last modified on 12/24/79 W. Olin Sibert, to add $by_name and $by_definition entries. 54* * Last modified on 12/25/79 W. Olin Sibert, to add max length entrypoints. 55* * Last modified on 02/22/81 W. Olin Sibert, to clean up for installation. 56* */ 57 58 dcl (P_from_ptr pointer, 59 P_to_ptr pointer, 60 P_word_count fixed bin (19), 61 P_seg_name char (*), 62 P_seg_ptr pointer, 63 P_entrypoint_name char (*), 64 P_offset fixed bin (18), 65 P_max_length fixed bin (19), 66 P_code fixed bin (35)) parameter; 67 68 dcl (tried_phcs, tried_mrzp) bit (1) aligned; 69 dcl system_area_ptr pointer; 70 dcl system_area area based (system_area_ptr); 71 dcl def_name char (72) varying; 72 dcl temp_def_name char (72); 73 dcl def_offset fixed bin (18); 74 dcl r0_ptr pointer; 75 dcl def_ptr pointer; 76 dcl copy_ptr pointer; 77 dcl last_name_entry_ptr pointer; 78 dcl hash_index fixed bin; 79 dcl temp_word bit (36) aligned; 80 dcl ring_zero_only bit (1) aligned; 81 dcl 1 temp_sdw aligned like sdw automatic; 82 83 dcl phcs_ok bit (1) aligned internal static init ("1"b); 84 dcl hash_buckets (127) pointer unaligned internal static init ((127)(null ())); 85 86 dcl name_entry_ptr pointer; 87 dcl name_entry_lth fixed bin; 88 dcl 1 name_entry aligned based (name_entry_ptr), 89 2 next pointer unaligned, 90 2 r0_ptr pointer unaligned, 91 2 name_lth fixed bin, 92 2 name char (name_entry_lth refer (name_entry.name_lth)); 93 94 dcl get_system_free_area_ entry () returns (pointer); 95 dcl metering_ring_zero_peek_ entry (pointer, pointer, fixed binary (19), fixed bin (35)); 96 dcl phcs_$ring_0_peek entry (pointer, pointer, fixed binary (19)); 97 dcl ring0_get_$definition entry (pointer, char (*), char (*), fixed bin (18), fixed bin, fixed bin (35)); 98 dcl ring0_get_$segptr entry (char (*), char (*), pointer, fixed bin (35)); 99 dcl ring_zero_peek_ entry (pointer, pointer, fixed bin (19), fixed bin (35)); 100 dcl ring_zero_peek_$by_name entry (char (*), fixed bin (18), pointer, fixed bin (19), fixed bin (35)); 101 102 dcl (error_table_$no_info, 103 error_table_$invalidsegno, 104 error_table_$bad_arg) fixed bin (35) external static; 105 106 dcl (seg_fault_error, linkage_error) condition; 107 108 dcl (addr, addrel, baseno, binary, dimension, length, mod, null, rank, rtrim, search, size, substr) builtin; 109 110 /* */ 111 112 /* * ring_zero_peek_: procedure (P_from_ptr, P_to_ptr, P_word_count, P_code); 113* * 114* * This entry is used to merely extract words from ring zero, specified 115* * by a pointer into ring zero. */ 116 117 copy_ptr = P_from_ptr; /* generate the pointer to copy from */ 118 119 goto PERFORM_RING_ZERO_PEEK; /* and join common peeking code */ 120 121 /* */ 122 123 ring_zero_peek_$by_name: entry (P_seg_name, P_offset, P_to_ptr, P_word_count, P_code); 124 125 /* * This entry is used to copy words from the named ring zero segment, 126* * starting at P_offset. */ 127 128 if search (P_seg_name, "<>") ^= 0 then do; /* it's a pathname, reject it */ 129 P_code = error_table_$bad_arg; /* best code I could find */ 130 return; 131 end; 132 133 call lookup (P_seg_name); /* sets name_entry_ptr, last_name_entry_ptr, hash_index */ 134 135 if name_entry_ptr = null () then do; /* not there already, we must find it */ 136 call ring0_get_$segptr ("", P_seg_name, r0_ptr, P_code); /* call to find it */ 137 if P_code ^= 0 then return; /* Nope. */ 138 139 call insert (P_seg_name, r0_ptr); /* insert it */ 140 end; 141 142 else r0_ptr = name_entry.r0_ptr; /* otherwise, copy it from the found name_entry */ 143 144 copy_ptr = addrel (r0_ptr, P_offset); /* generate the pointer to copy from */ 145 146 goto PERFORM_RING_ZERO_PEEK; /* and join common peeking code */ 147 148 /* */ 149 150 ring_zero_peek_$by_definition: entry (P_seg_name, P_entrypoint_name, P_offset, P_to_ptr, P_word_count, P_code); 151 152 /* * This entry is used to copy words from the definition P_seg_name$P_entrypoint_name, 153* * in ring zero, possibly offset by P_offset. */ 154 155 if search (P_seg_name, "<>") ^= 0 then do; /* it's a pathname, reject it */ 156 P_code = error_table_$bad_arg; /* best code I could find */ 157 return; 158 end; 159 160 def_name = rtrim (P_seg_name); /* construct lookup name */ 161 def_name = def_name || "$"; 162 def_name = def_name || rtrim (P_entrypoint_name); 163 temp_def_name = def_name; 164 165 call lookup (temp_def_name); /* sets name_entry_ptr, last_name_entry_ptr, hash_index */ 166 167 if name_entry_ptr = null () then do; /* not there already, we must find it */ 168 r0_ptr = null (); /* indicate that this should be an output argument */ 169 call ring0_get_$definition (r0_ptr, P_seg_name, P_entrypoint_name, def_offset, (0), P_code); 170 if P_code ^= 0 then return; /* Nope. */ 171 172 def_ptr = addrel (r0_ptr, def_offset); /* generate a pointer to the actual definition */ 173 call insert (temp_def_name, def_ptr); /* insert it */ 174 end; 175 176 else def_ptr = name_entry.r0_ptr; /* otherwise, copy it from the found name_entry */ 177 178 copy_ptr = addrel (def_ptr, P_offset); /* add optionl offset, and generate pointer */ 179 180 goto PERFORM_RING_ZERO_PEEK; /* join common peeking code */ 181 182 /* */ 183 184 /* * This block of code is responsible for actually performing the peek. 185* * It implements the complex heuristics described above for moderating access. 186* * It tries to copy P_word_count words from the location in ring zero identified 187* * by copy_ptr out to the location identified by P_to_ptr, setting P_code to 188* * indicate success or failure. It is accessed via a goto rather than being an 189* * internal procedure for reasons of efficiency; it would have to be a nonquick 190* * procedure, since it sets up condition handlers, and it seemed worth saving 191* * the additional overhead at the expense of making the program logic somewhat 192* * more complicated. */ 193 194 PERFORM_RING_ZERO_PEEK: 195 tried_phcs = "0"b; /* indicates that we have already tried and failed */ 196 tried_mrzp = "0"b; /* indicates that m_r_z_p_ lost as well */ 197 198 if ^phcs_ok then goto NO_PHCS; /* don't bother with linkage fault if we know already */ 199 200 201 TRY_PHCS: tried_phcs = "1"b; /* don't come back */ 202 203 on linkage_error goto NO_PHCS; 204 205 call phcs_$ring_0_peek (copy_ptr, P_to_ptr, P_word_count); 206 207 phcs_ok = "1"b; /* indicate this will work in the future */ 208 P_code = 0; /* assume success */ 209 return; 210 211 212 NO_PHCS: if tried_mrzp then goto NO_MRZP; /* only try this once */ 213 214 tried_mrzp = "1"b; /* don't come back here */ 215 phcs_ok = "0"b; /* can only get here if we lost trying phcs_ */ 216 217 on linkage_error goto NO_MRZP; 218 219 call metering_ring_zero_peek_ (copy_ptr, P_to_ptr, P_word_count, P_code); 220 if P_code = 0 then return; /* it worked */ 221 /* otherwise, fall through and maybe try phcs_ */ 222 223 224 NO_MRZP: if ^tried_phcs then goto TRY_PHCS; /* we lost for m_r_z_p_, try phcs_ once */ 225 226 P_code = error_table_$no_info; /* Sorry, out of luck */ 227 return; /* end of code for peeking */ 228 229 /* */ 230 231 ring_zero_peek_$get_max_length: entry (P_seg_name, P_max_length, P_code); 232 233 /* * These entries return the max length of a selected ring zero segment, 234* * by the simple expedient of peeking at the SDW for the segment. */ 235 236 ring_zero_only = "1"b; 237 goto PERFORM_GET_MAX_LTH; /* Only genuine ring 0 segs from hardcore address space */ 238 239 240 ring_zero_peek_$get_max_length_ptr: entry (P_seg_ptr, P_max_length, P_code); 241 242 ring_zero_only = "0"b; 243 goto PERFORM_GET_MAX_LTH; /* Max length from SDW for any segment */ 244 245 246 PERFORM_GET_MAX_LTH: 247 P_max_length = -1; /* initialization */ 248 249 if ring_zero_only then do; /* get a pointer to the named segment */ 250 call ring0_get_$segptr ("", P_seg_name, r0_ptr, P_code); 251 if P_code ^= 0 then return; /* sorry, you lose */ 252 end; 253 else r0_ptr = P_seg_ptr; /* otherwise, copy the input pointer */ 254 255 call ring_zero_peek_$by_name ("dseg", (2 * binary (baseno (r0_ptr), 17)), 256 addr (temp_sdw), size (temp_sdw), P_code); /* copy the SDW from the users dseg */ 257 if P_code ^= 0 then return; /* sorry, outta luck */ 258 259 if temp_sdw.df = "0"b then do; /* not active */ 260 on condition (seg_fault_error) /* protect against nasties */ 261 goto INVALID_SEGMENT_NUMBER; 262 263 call ring_zero_peek_ (r0_ptr, addr (temp_word), size (temp_word), P_code); 264 if P_code ^= 0 then /* try to segfault on it, to get a valid SDW */ 265 return; /* Couldn't. Tough luck, Chucko. */ 266 267 revert condition (seg_fault_error); 268 269 call ring_zero_peek_$by_name ("dseg", (2 * binary (baseno (r0_ptr), 17)), 270 addr (temp_sdw), size (temp_sdw), P_code); /* try again to get the SDW */ 271 if P_code ^= 0 then 272 return; 273 274 if temp_sdw.df = "0"b then /* Still not active -- just punt */ 275 goto INVALID_SEGMENT_NUMBER; 276 end; /* at this point, we apparently have a valid SDW */ 277 278 P_max_length = 16 + (16 * binary (temp_sdw.bound, 14)); 279 280 P_code = 0; 281 return; 282 283 284 INVALID_SEGMENT_NUMBER: /* Couldn't access something */ 285 P_code = error_table_$invalidsegno; 286 return; /* all done with ring_zero_peek_$get_max_length */ 287 288 /* */ 289 290 lookup: proc (P_name); 291 292 /* * This procedure looks up P_name in the internal name hash table, and sets 293* * hash_index, name_entry_ptr, and last_name_entry_ptr appropriately. It will 294* * always set hash_index correctly. If P_name is found, name_entry_ptr points 295* * to the name_entry block for it, and last_name_entry_ptr will be invalid. 296* * If P_name is not found, name_entry_ptr will be null, and last_name_entry_ptr 297* * will either point to the last name_entry block in the chain, or be null if 298* * the chain is empty. */ 299 300 dcl P_name char (*) parameter; 301 302 dcl hash_sum fixed bin; 303 dcl idx fixed bin; 304 305 hash_sum = 43; /* This is just to start it somewhere other than zero */ 306 /* The choice of 43 is completely arbitrary */ 307 do idx = 1 to length (rtrim (P_name)); 308 hash_sum = hash_sum + rank (substr (P_name, idx, 1)); 309 end; 310 311 hash_index = 1 + mod (hash_sum, dimension (hash_buckets, 1)); 312 313 last_name_entry_ptr = null (); 314 do name_entry_ptr = hash_buckets (hash_index) 315 repeat (name_entry_ptr -> name_entry.next) 316 while (name_entry_ptr ^= null ()); 317 318 last_name_entry_ptr = name_entry_ptr; 319 320 if name_entry.name = P_name then return; /* jackpot */ 321 end; /* of loop through name_entry blocks */ 322 323 return; /* all done. the pointers are set appropriately by the loop */ 324 end lookup; 325 326 /* */ 327 328 insert: proc (P_name, P_ptr); 329 330 /* * This procedure adds another name_entry block to the appropriate chain for 331* * the association of P_name and P_ptr. It assumes that hash_index and 332* * last_name_entry_ptr have already been set properly (presumably by lookup). */ 333 334 dcl (P_name char (*), 335 P_ptr pointer) parameter; 336 337 system_area_ptr = get_system_free_area_ (); /* allocate a new name_entry */ 338 name_entry_lth = length (rtrim (P_name)); 339 340 allocate name_entry in (system_area) set (name_entry_ptr); 341 342 name_entry.next = null (); /* initialize values */ 343 name_entry.r0_ptr = P_ptr; 344 name_entry.name_lth = name_entry_lth; 345 name_entry.name = P_name; 346 347 if last_name_entry_ptr ^= null () then /* and string in -- after last one, if there was such; */ 348 last_name_entry_ptr -> name_entry.next = name_entry_ptr; 349 else hash_buckets (hash_index) = name_entry_ptr; 350 351 return; /* all done */ 352 end insert; 353 354 /* BEGIN INCLUDE FILE ... sdw.incl.pl1 ... last modified 12 May 1976 */ 1 2 1 3 dcl sdwp ptr; 1 4 1 5 dcl 1 sdw based (sdwp) aligned, /* Segment Descriptor Word */ 1 6 1 7 (2 add bit (24), /* main memory address of page table */ 1 8 2 (r1, r2, r3) bit (3), /* ring brackets for the segment */ 1 9 2 df bit (1), /* directed fault bit (0 => fault) */ 1 10 2 df_no bit (2), /* directed fault number */ 1 11 1 12 2 pad1 bit (1), 1 13 2 bound bit (14), /* boundary field (in 16 word blocks) */ 1 14 2 access, /* access bits */ 1 15 3 read bit (1), /* read permission bit */ 1 16 3 execute bit (1), /* execute permission bit */ 1 17 3 write bit (1), /* write permission bit */ 1 18 3 privileged bit (1), /* privileged bit */ 1 19 2 unpaged bit (1), /* segment is unpaged if this is 1 */ 1 20 2 entry_bound_sw bit (1), /* if this is 0 the entry bound is checked by hardware */ 1 21 2 cache bit (1), /* cache enable bit */ 1 22 2 entry_bound bit (14)) unaligned; /* entry bound */ 1 23 1 24 dcl 1 sdwa (0: 1) based (sdwp) aligned like sdw; /* SDW array (descriptor segment) */ 1 25 1 26 /* END INCLUDE FILE sdw.incl.pl1 */ 354 355 356 end ring_zero_peek_; /* External procedure */ SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/04/82 1615.5 ring_zero_peek_.pl1 >dumps>old>recomp>ring_zero_peek_.pl1 354 1 09/14/76 0759.8 sdw.incl.pl1 >ldd>include>sdw.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. P_code parameter fixed bin(35,0) dcl 58 set ref 11 123 129* 136* 137 150 156* 169* 170 208* 219* 220 226* 231 240 250* 251 255* 257 263* 264 269* 271 280* 284* P_entrypoint_name parameter char unaligned dcl 58 set ref 150 162 169* P_from_ptr parameter pointer dcl 58 ref 11 117 P_max_length parameter fixed bin(19,0) dcl 58 set ref 231 240 246* 278* P_name parameter char unaligned dcl 300 in procedure "lookup" ref 290 307 308 320 P_name parameter char unaligned dcl 334 in procedure "insert" ref 328 338 345 P_offset parameter fixed bin(18,0) dcl 58 ref 123 144 150 178 P_ptr parameter pointer dcl 334 ref 328 343 P_seg_name parameter char unaligned dcl 58 set ref 123 128 133* 136* 139* 150 155 160 169* 231 250* P_seg_ptr parameter pointer dcl 58 ref 240 253 P_to_ptr parameter pointer dcl 58 set ref 11 123 150 205* 219* P_word_count parameter fixed bin(19,0) dcl 58 set ref 11 123 150 205* 219* addr builtin function dcl 108 ref 255 255 263 263 269 269 addrel builtin function dcl 108 ref 144 172 178 baseno builtin function dcl 108 ref 255 269 binary builtin function dcl 108 ref 255 269 278 bound 1(01) 000166 automatic bit(14) level 2 packed unaligned dcl 81 set ref 278 copy_ptr 000156 automatic pointer dcl 76 set ref 117* 144* 178* 205* 219* def_name 000104 automatic varying char(72) dcl 71 set ref 160* 161* 161 162* 162 163 def_offset 000151 automatic fixed bin(18,0) dcl 73 set ref 169* 172 def_ptr 000154 automatic pointer dcl 75 set ref 172* 173* 176* 178 df 0(33) 000166 automatic bit(1) level 2 packed unaligned dcl 81 set ref 259 274 dimension builtin function dcl 108 ref 311 error_table_$bad_arg 000232 external static fixed bin(35,0) dcl 102 ref 129 156 error_table_$invalidsegno 000230 external static fixed bin(35,0) dcl 102 ref 284 error_table_$no_info 000226 external static fixed bin(35,0) dcl 102 ref 226 get_system_free_area_ 000210 constant entry external dcl 94 ref 337 hash_buckets 000011 internal static pointer initial array unaligned dcl 84 set ref 311 314 349* hash_index 000162 automatic fixed bin(17,0) dcl 78 set ref 311* 314 349 hash_sum 000226 automatic fixed bin(17,0) dcl 302 set ref 305* 308* 308 311 idx 000227 automatic fixed bin(17,0) dcl 303 set ref 307* 308* last_name_entry_ptr 000160 automatic pointer dcl 77 set ref 313* 318* 347 347 length builtin function dcl 108 ref 307 338 linkage_error 000202 stack reference condition dcl 106 ref 203 217 metering_ring_zero_peek_ 000212 constant entry external dcl 95 ref 219 mod builtin function dcl 108 ref 311 name 3 based char level 2 dcl 88 set ref 320 345* name_entry based structure level 1 dcl 88 set ref 340 name_entry_lth 000172 automatic fixed bin(17,0) dcl 87 set ref 338* 340 340 344 name_entry_ptr 000170 automatic pointer dcl 86 set ref 135 142 167 176 314* 314* 318 320* 321 340* 342 343 344 345 347 349 name_lth 2 based fixed bin(17,0) level 2 dcl 88 set ref 320 340* 344* 345 next based pointer level 2 packed unaligned dcl 88 set ref 321 342* 347* null builtin function dcl 108 ref 135 167 168 313 314 342 347 phcs_$ring_0_peek 000214 constant entry external dcl 96 ref 205 phcs_ok 000010 internal static bit(1) initial dcl 83 set ref 198 207* 215* r0_ptr 000152 automatic pointer dcl 74 in procedure "ring_zero_peek_" set ref 136* 139* 142* 144 168* 169* 172 250* 253* 255 263* 269 r0_ptr 1 based pointer level 2 in structure "name_entry" packed unaligned dcl 88 in procedure "ring_zero_peek_" set ref 142 176 343* rank builtin function dcl 108 ref 308 ring0_get_$definition 000216 constant entry external dcl 97 ref 169 ring0_get_$segptr 000220 constant entry external dcl 98 ref 136 250 ring_zero_only 000164 automatic bit(1) dcl 80 set ref 236* 242* 249 ring_zero_peek_ 000222 constant entry external dcl 99 ref 263 ring_zero_peek_$by_name 000224 constant entry external dcl 100 ref 255 269 rtrim builtin function dcl 108 ref 160 162 307 338 sdw based structure level 1 dcl 1-5 search builtin function dcl 108 ref 128 155 seg_fault_error 000174 stack reference condition dcl 106 ref 260 267 size builtin function dcl 108 ref 255 255 263 263 269 269 substr builtin function dcl 108 ref 308 system_area based area(1024) dcl 70 ref 340 system_area_ptr 000102 automatic pointer dcl 69 set ref 337* 340 temp_def_name 000127 automatic char(72) unaligned dcl 72 set ref 163* 165* 173* temp_sdw 000166 automatic structure level 1 dcl 81 set ref 255 255 255 255 269 269 269 269 temp_word 000163 automatic bit(36) dcl 79 set ref 263 263 263 263 tried_mrzp 000101 automatic bit(1) dcl 68 set ref 196* 212 214* tried_phcs 000100 automatic bit(1) dcl 68 set ref 194* 201* 224 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. sdwa based structure array level 1 dcl 1-24 sdwp automatic pointer dcl 1-3 NAMES DECLARED BY EXPLICIT CONTEXT. INVALID_SEGMENT_NUMBER 001076 constant label dcl 284 ref 260 274 NO_MRZP 000566 constant label dcl 224 ref 212 217 NO_PHCS 000522 constant label dcl 212 ref 198 203 PERFORM_GET_MAX_LTH 000637 constant label dcl 246 ref 237 243 PERFORM_RING_ZERO_PEEK 000454 constant label dcl 194 ref 119 146 180 TRY_PHCS 000461 constant label dcl 201 ref 224 insert 001206 constant entry internal dcl 328 ref 139 173 lookup 001102 constant entry internal dcl 290 ref 133 165 ring_zero_peek_ 000031 constant entry external dcl 11 ring_zero_peek_$by_definition 000226 constant entry external dcl 150 ring_zero_peek_$by_name 000056 constant entry external dcl 123 ring_zero_peek_$get_max_length 000600 constant entry external dcl 231 ring_zero_peek_$get_max_length_ptr 000625 constant entry external dcl 240 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2014 2250 1526 2024 Length 2474 1526 234 210 265 200 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME ring_zero_peek_ 227 external procedure is an external procedure. on unit on line 203 64 on unit on unit on line 217 64 on unit on unit on line 260 64 on unit lookup internal procedure shares stack frame of external procedure ring_zero_peek_. insert internal procedure shares stack frame of external procedure ring_zero_peek_. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 phcs_ok ring_zero_peek_ 000011 hash_buckets ring_zero_peek_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME ring_zero_peek_ 000100 tried_phcs ring_zero_peek_ 000101 tried_mrzp ring_zero_peek_ 000102 system_area_ptr ring_zero_peek_ 000104 def_name ring_zero_peek_ 000127 temp_def_name ring_zero_peek_ 000151 def_offset ring_zero_peek_ 000152 r0_ptr ring_zero_peek_ 000154 def_ptr ring_zero_peek_ 000156 copy_ptr ring_zero_peek_ 000160 last_name_entry_ptr ring_zero_peek_ 000162 hash_index ring_zero_peek_ 000163 temp_word ring_zero_peek_ 000164 ring_zero_only ring_zero_peek_ 000166 temp_sdw ring_zero_peek_ 000170 name_entry_ptr ring_zero_peek_ 000172 name_entry_lth ring_zero_peek_ 000226 hash_sum lookup 000227 idx lookup THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out return tra_ext mod_fx1 enable ext_entry ext_entry_desc int_entry alloc_based THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. get_system_free_area_ metering_ring_zero_peek_ phcs_$ring_0_peek ring0_get_$definition ring0_get_$segptr ring_zero_peek_ ring_zero_peek_$by_name THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$bad_arg error_table_$invalidsegno error_table_$no_info LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 11 000024 117 000045 119 000050 123 000051 128 000102 129 000117 130 000122 133 000123 135 000134 136 000140 137 000167 139 000171 140 000207 142 000210 144 000213 146 000217 150 000220 155 000257 156 000274 157 000277 160 000300 161 000320 162 000327 163 000355 165 000361 167 000364 168 000370 169 000372 170 000432 172 000434 173 000440 174 000443 176 000444 178 000447 180 000453 194 000454 196 000455 198 000456 201 000461 203 000463 205 000502 207 000515 208 000520 209 000521 212 000522 214 000524 215 000526 217 000530 219 000547 220 000564 224 000566 226 000570 227 000573 231 000574 236 000616 237 000620 240 000621 242 000635 243 000636 246 000637 249 000642 250 000644 251 000672 252 000674 253 000675 255 000700 257 000744 259 000746 260 000751 263 000770 264 001011 267 001013 269 001014 271 001060 274 001062 278 001065 280 001074 281 001075 284 001076 286 001101 290 001102 305 001113 307 001115 308 001137 309 001146 311 001150 313 001155 314 001157 318 001167 320 001171 321 001202 323 001205 328 001206 337 001217 338 001226 340 001243 342 001255 343 001257 345 001263 347 001271 349 001277 351 001302 ----------------------------------------------------------- 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