COMPILATION LISTING OF SEGMENT amu_hardcore_info_ Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Bull, Phx. Az., Sys-M Compiled on: 07/28/87 0932.8 mst Tue Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 6* * * 7* *********************************************************** */ 8 9 10 /****^ HISTORY COMMENTS: 11* 1) change(87-07-09,Parisek), approve(87-07-09,MCR7746), 12* audit(87-07-20,Fawcett), install(87-07-28,MR12.1-1049): 13* Check for early dump based on existence of certain hardcore referencing, 14* then return pointer values based on that information. 15* END HISTORY COMMENTS */ 16 17 18 amu_hardcore_info_: proc; 19 return; 20 21 /* format: style4,delnl,insnl,ifthenstmt,indnoniterend,ifthendo,ifthen,^thendo */ 22 23 /* 24* This proc will set up the hadrcore_info data 25* 26* dcl amu_$hardcore_info_deadproc entry (ptr,char(168),fixed bin (35); 27* call amu_$hardcore_info_deadproc (amu_info_ptr,deadproc_dir,code); 28* 29* 30* dcl amu_$hardcore_info_fdump entry (ptr,fixed bin (35)); 31* call amu_$hardcore_info_fdump (amu_info_ptr,code); 32* where 33* amu_info_ptr is a pointer to this amu_info (input) 34* code is the error code 0 if ok . (output) 35* 36* dcl amu_$hardcore_info_set_cur_ptrs entry (ptr,ptr); 37* call amu_$hardcore_info_set_cur_ptrs (amu_info_ptr,hardcore_cur_ptr); 38* where 39* amu_info_ptr as above (input) 40* hardcore_cur_ptr is a pointer to where the hardcore_cur 41* strcuture will be stored (input) 42* 43* Modified July 84 by B. Braun to add knowledge of unpaged_page_tables. 44* Modified Sept 84 by B. Braun to use inzr_stk0 when active_all_rings_data_ doesnt exist. 45**/ 46 47 /* Parameters */ 48 49 dcl P_amu_info_ptr ptr; 50 dcl P_caller char(*); 51 dcl P_code fixed bin (35); 52 dcl P_ptr ptr; 53 dcl P_dp_dir char (168); 54 55 /* External entries */ 56 57 dcl amu_$error_for_caller entry options (variable); 58 dcl amu_$fdump_translate_to_temp_seg entry (ptr, ptr, ptr, fixed bin (35)); 59 dcl amu_$do_translation entry (ptr, fixed bin, ptr, fixed bin (18), fixed bin (18), fixed bin (35)); 60 dcl amu_$definition_ptr entry (ptr, char (*), char (*), fixed bin (35)) returns (ptr); 61 dcl amu_$translate_add entry (ptr, ptr, fixed bin, fixed bin (35)); 62 dcl amu_$translate_force_add entry (ptr, ptr, fixed bin, fixed bin (35)); 63 dcl amu_$fdump_translate_contiguous entry (ptr, ptr, ptr, fixed bin (35)); 64 dcl amu_$slt_search_seg_ptr entry (ptr, ptr, char (32), ptr, fixed bin (35)); 65 dcl amu_$slt_search_init_seg_ptr entry (ptr, ptr, char (32), ptr, fixed bin (35)); 66 dcl amu_$slt_search_last_sup_seg entry (ptr, fixed bin); 67 dcl initiate_file_ entry (char(*), char(*), bit(*), ptr, fixed bin(24), fixed bin(35)); 68 dcl pathname_ entry (char(*), char(*)) returns(char(168)); 69 70 /* External static */ 71 dcl amu_et_$no_def fixed bin (35) ext; 72 dcl amu_et_$no_dseg fixed bin (35) ext; 73 dcl amu_et_$no_slt fixed bin (35) ext; 74 dcl amu_et_$no_sltnt fixed bin (35) ext; 75 dcl amu_et_$trans_exists fixed bin (35) ext; 76 dcl error_table_$action_not_performed fixed bin (35) ext; 77 78 /* Builtins */ 79 80 dcl (addr, addrel, baseno, baseptr, binary, 81 divide, fixed, null, rel) builtin; 82 83 /* Automatic */ 84 85 dcl bitcount fixed bin (24); 86 dcl bound fixed bin(19); 87 dcl (code, ecode) fixed bin (35); 88 dcl deadproc_dir char (168); 89 dcl dseg_ptr ptr; 90 dcl 1 temp_translation like translation; 91 dcl segment_ptr ptr; 92 dcl temp_ptr ptr; 93 94 /*****************************************************************************/ 95 96 amu_hardcore_info_$deadproc: 97 entry (P_caller, P_amu_info_ptr, P_dp_dir, P_code); 98 99 amu_info_ptr = P_amu_info_ptr; 100 deadproc_dir = P_dp_dir; 101 102 hardcore_info.pointers.sst.fptr = null (); 103 hardcore_info.pointers.sst.lptr = null (); 104 hardcore_info.pointers.sstnt.fptr = null (); 105 hardcore_info.pointers.sstnt.lptr = null (); 106 hardcore_info.pointers.tc_data.fptr = null (); 107 hardcore_info.pointers.tc_data.lptr = null (); 108 hardcore_info.pointers.upt.fptr = null (); 109 hardcore_info.pointers.upt.lptr = null (); 110 hardcore_info.apt.foreign_ptr = null (); 111 hardcore_info.apt.local_ptr = null (); 112 hardcore_info.apt.count = 0; 113 hardcore_info.apt.size = 0; 114 115 process_info.pid = "0"b; 116 process_info.address_map_ptr = amu_info.translation_table_ptr; 117 process_info.state, process_info.idx, process_info.dbr = -1; 118 process_info.apte.foreign_ptr, process_info.apte.local_ptr = null (); 119 process_info.prds = process_info.apte; 120 process_info.pds = process_info.apte; 121 process_info.dseg = process_info.apte; 122 process_info.kst = process_info.apte; 123 124 process_info.dump_segx.first, process_info.dump_segx.last = 0; 125 126 127 translation_ptr = addr(temp_translation); 128 translation.flags = ""b; 129 translation.in_perm_seg = "1"b; 130 translation.in_dp_dir = "1"b; 131 translation.part2.ptr = null (); 132 translation.part2.lth = 0; 133 134 /* get the slt */ 135 136 call initiate_file_ (deadproc_dir, "slt", R_ACCESS, temp_ptr, bitcount, code); 137 if temp_ptr = null () then do; 138 if code = 0 then P_code = amu_et_$no_slt; 139 else do; 140 P_code = error_table_$action_not_performed; 141 call amu_$error_for_caller (amu_info_ptr, code, P_caller, 142 "Initiating ^a.", pathname_ (deadproc_dir, "slt")); 143 end; 144 return; 145 end; 146 code = 0; 147 sltp = temp_ptr; 148 segment_ptr = baseptr(7); 149 translation.part1.ptr = temp_ptr; 150 translation.part1.lth = divide(bitcount,36,18); 151 translation.segno = fixed (baseno (segment_ptr), 17); 152 call fill_ptrs_no_trans (addr (hardcore_info.pointers.slt), segment_ptr); 153 call amu_$translate_add (amu_info_ptr, translation_ptr, fixed (baseno (segment_ptr), 17), code); 154 if code ^= 0 then do; 155 P_code = code; 156 return; 157 end; 158 159 /* get the name_table */ 160 161 call initiate_file_ (deadproc_dir, "name_table", R_ACCESS, temp_ptr, bitcount, code); 162 if temp_ptr = null () then do; 163 if code = 0 then P_code = amu_et_$no_sltnt; 164 else do; 165 P_code = error_table_$action_not_performed; 166 call amu_$error_for_caller (amu_info_ptr, code, P_caller, 167 "Initiating ^a.", pathname_ (deadproc_dir, "name_table")); 168 end; 169 return; 170 end; 171 code = 0; 172 segment_ptr = baseptr (8); 173 names_ptr = temp_ptr; 174 translation.part1.ptr = temp_ptr; 175 translation.part1.lth = divide(bitcount,36,18); 176 translation.segno = fixed (baseno (segment_ptr), 17); 177 call fill_ptrs_no_trans (addr (hardcore_info.pointers.sltnt), segment_ptr); 178 call amu_$translate_add (amu_info_ptr, translation_ptr, fixed (baseno (segment_ptr), 17), code); 179 if code ^= 0 then do; 180 P_code = code; 181 return; 182 end; 183 184 /* get definitions_ */ 185 186 call initiate_file_ (deadproc_dir, "definitions_", R_ACCESS, temp_ptr, bitcount, code); 187 if temp_ptr = null () then do; 188 if code = 0 then P_code = amu_et_$no_def; 189 else do; 190 P_code = error_table_$action_not_performed; 191 call amu_$error_for_caller (amu_info_ptr, code, P_caller, 192 "Initiating ^a.", pathname_ (deadproc_dir, "definitions_")); 193 end; 194 return; 195 end; 196 call get_ptr_from_slt ("definitions_", segment_ptr); 197 translation.part1.ptr = temp_ptr; 198 translation.part1.lth = divide(bitcount,36,18); 199 translation.segno = fixed (baseno (segment_ptr), 17); 200 call fill_ptrs_no_trans (addr (hardcore_info.pointers.definitions), segment_ptr); 201 call amu_$translate_add (amu_info_ptr, translation_ptr, fixed (baseno (segment_ptr), 17), code); 202 if code ^= 0 then do; 203 P_code = code; 204 return; 205 end; 206 207 call initiate_file_ (deadproc_dir, "dseg", R_ACCESS, temp_ptr, bitcount, code); 208 if temp_ptr = null () then do; 209 if code = 0 then P_code = amu_et_$no_dseg; 210 else do; 211 P_code = error_table_$action_not_performed; 212 call amu_$error_for_caller (amu_info_ptr, code, P_caller, 213 "Initiating ^a.", pathname_ (deadproc_dir, "dseg")); 214 end; 215 return; 216 end; 217 call get_ptr_from_slt ("dseg", segment_ptr); 218 hardcore_info.dseg = fixed (baseno (segment_ptr), 15); 219 dseg_ptr = temp_ptr; 220 sdwp = dseg_ptr; 221 bound = (binary (sdwp->sdw.bound, 14) +1) * 16; /* get number of words */ 222 translation.part1.ptr = dseg_ptr; 223 translation.part1.lth = bound; 224 translation.segno = fixed (baseno (segment_ptr), 17); 225 call amu_$translate_add (amu_info_ptr, translation_ptr, (translation.segno), code); 226 if code ^= 0 then do; 227 P_code = code; 228 return; 229 end; 230 process_info.dseg.local_ptr = translation.part1.ptr; 231 232 call get_and_set (dseg_ptr, "pds", hardcore_info.pds, code); 233 if code ^= 0 then do; 234 call amu_$error_for_caller (amu_info_ptr, code, P_caller, "Initiating ^a.", pathname_ (deadproc_dir, "pds")); 235 P_code = error_table_$action_not_performed; 236 return; 237 end; 238 239 process_info.pds.local_ptr = translation.part1.ptr; 240 241 call get_and_set (dseg_ptr, "kst", hardcore_info.kst, code); 242 if code ^= 0 then do; 243 call amu_$error_for_caller (amu_info_ptr, code, P_caller, "Initiating ^a.", pathname_ (deadproc_dir, "kst")); 244 P_code = error_table_$action_not_performed; 245 return; 246 end; 247 248 process_info.kst.local_ptr = translation.part1.ptr; 249 250 call amu_$slt_search_last_sup_seg (sltp, hardcore_info.hcs_count); 251 252 P_code = 0; 253 return; 254 255 /*****************************************************************************/ 256 257 amu_hardcore_info_$fdump: 258 entry (P_amu_info_ptr, P_caller, P_code); 259 260 amu_info_ptr = P_amu_info_ptr; /* copy the amu_info ptr */ 261 process_idx = 0; /* all hardcore segs are in first process dumped */ 262 263 264 /* guess at the slt seg number */ 265 segment_ptr = baseptr (7); 266 ecode = 0; 267 call amu_$fdump_translate_contiguous (amu_info_ptr, segment_ptr, addr (temp_translation), ecode); 268 if ecode ^= 0 then goto error_ret; 269 sltp = temp_translation.part1.ptr; 270 if temp_translation.flags.in_dump = "1"b then do; 271 hardcore_info.slt.fptr = temp_translation.part1.ptr; 272 hardcore_info.slt.lptr = null (); 273 end; 274 else do; 275 hardcore_info.slt.lptr = temp_translation.part1.ptr; 276 hardcore_info.slt.fptr = null (); 277 end; 278 call amu_$translate_add (amu_info_ptr, addr (temp_translation), fixed (baseno (segment_ptr), 17), code); 279 if code = amu_et_$trans_exists then 280 call amu_$translate_force_add (amu_info_ptr, addr (temp_translation), fixed (baseno (segment_ptr), 17), 281 code); 282 283 /* now guess at the slt name seg 284* segment_ptr = baseptr (8); */ 285 286 segment_ptr = slt.name_seg_ptr; 287 ecode = 0; 288 call amu_$fdump_translate_contiguous (amu_info_ptr, segment_ptr, addr (temp_translation), ecode); 289 if ecode ^= 0 then goto error_ret; 290 names_ptr = temp_translation.part1.ptr; 291 if temp_translation.flags.in_dump = "1"b then do; 292 hardcore_info.sltnt.fptr = temp_translation.part1.ptr; 293 hardcore_info.sltnt.lptr = null (); 294 end; 295 else do; 296 hardcore_info.sltnt.lptr = temp_translation.part1.ptr; 297 hardcore_info.sltnt.fptr = null (); 298 299 end; 300 call amu_$translate_add (amu_info_ptr, addr (temp_translation), fixed (baseno (segment_ptr), 17), code); 301 if code = amu_et_$trans_exists then 302 call amu_$translate_force_add (amu_info_ptr, addr (temp_translation), fixed (baseno (segment_ptr), 17), 303 code); 304 305 segment_ptr = slt.name_seg_ptr; 306 307 call get_ptr_from_slt ("tc_data", segment_ptr); 308 call fill_ptrs (addr (hardcore_info.pointers.tc_data), segment_ptr); 309 if hardcore_info.tc_data.fptr ^= null () then do; 310 tcmp = hardcore_info.tc_data.fptr; 311 hardcore_info.apt.foreign_ptr = addrel (hardcore_info.tc_data.fptr, fixed (tcm.apt_offset, 18)); 312 hardcore_info.apt.local_ptr = null (); 313 end; 314 else do; 315 tcmp = hardcore_info.tc_data.lptr; 316 hardcore_info.apt.local_ptr = addrel (hardcore_info.tc_data.lptr, fixed (tcm.apt_offset, 18)); 317 hardcore_info.apt.foreign_ptr = null (); 318 end; 319 call amu_$translate_add (amu_info_ptr, addr (temp_translation), fixed (baseno (segment_ptr), 17), code); 320 if code = amu_et_$trans_exists then 321 call amu_$translate_force_add (amu_info_ptr, addr (temp_translation), fixed (baseno (segment_ptr), 17), 322 code); 323 324 hardcore_info.apt.count = tcm.apt_size; 325 hardcore_info.apt.size = apt_entry_size; 326 327 /* definitions_ */ 328 call get_ptr_from_slt ("definitions_", segment_ptr); 329 call fill_ptrs (addr (hardcore_info.pointers.definitions), segment_ptr); 330 call amu_$fdump_translate_contiguous (amu_info_ptr, segment_ptr, addr (temp_translation), ecode); 331 call amu_$translate_add (amu_info_ptr, addr (temp_translation), fixed (baseno (segment_ptr), 17), code); 332 if code = amu_et_$trans_exists then 333 call amu_$translate_force_add (amu_info_ptr, addr (temp_translation), fixed (baseno (segment_ptr), 17), 334 code); 335 336 /* sst_seg */ 337 call get_ptr_from_slt ("sst_seg", segment_ptr); 338 call amu_$fdump_translate_to_temp_seg (amu_info_ptr, segment_ptr, addr (temp_translation), ecode); 339 call fill_ptrs_no_trans (addr (hardcore_info.sst), segment_ptr); 340 call amu_$translate_add (amu_info_ptr, addr (temp_translation), fixed (baseno (segment_ptr), 17), code); 341 if code = amu_et_$trans_exists then 342 call amu_$translate_force_add (amu_info_ptr, addr (temp_translation), fixed (baseno (segment_ptr), 17), 343 code); 344 345 /* sst_names_ */ 346 call get_ptr_from_slt ("sst_names_", segment_ptr); 347 call fill_ptrs (addr (hardcore_info.sstnt), segment_ptr); 348 call amu_$translate_add (amu_info_ptr, addr (temp_translation), fixed (baseno (segment_ptr), 17), code); 349 if code = amu_et_$trans_exists then 350 call amu_$translate_force_add (amu_info_ptr, addr (temp_translation), fixed (baseno (segment_ptr), 17), 351 code); 352 353 call get_ptr_from_slt ("prds", segment_ptr); 354 hardcore_info.prds = fixed (baseno (segment_ptr), 15); 355 call get_ptr_from_slt ("dseg", segment_ptr); 356 hardcore_info.dseg = fixed (baseno (segment_ptr), 15); 357 358 call get_ptr_from_slt ("pds", segment_ptr); 359 hardcore_info.pds = fixed (baseno (segment_ptr), 15); 360 361 if exists_unpaged_page_table (segment_ptr) then do; 362 call fill_ptrs (addr (hardcore_info.upt), segment_ptr); 363 call amu_$translate_add (amu_info_ptr, addr (temp_translation), fixed (baseno (segment_ptr), 17), code); 364 if code = amu_et_$trans_exists then 365 call amu_$translate_force_add (amu_info_ptr, addr (temp_translation), fixed (baseno (segment_ptr), 17), code); 366 hardcore_info.unpaged_page_tables = fixed (baseno (segment_ptr),15); 367 end; 368 else do; 369 hardcore_info.upt.fptr, hardcore_info.upt.lptr = null(); 370 end; 371 372 call get_ptr_from_slt ("kst_seg", segment_ptr); 373 hardcore_info.kst = fixed (baseno (segment_ptr), 15); 374 call amu_$slt_search_last_sup_seg (sltp, hardcore_info.hcs_count); 375 376 segment_ptr = amu_$definition_ptr (amu_info_ptr, "active_all_rings_data", "stack_base_segno", code); 377 if code = 0 then do; 378 call amu_$do_translation (amu_info_ptr, fixed (baseno (segment_ptr), 17), addr (hardcore_info.segno.stack_0), 379 fixed (rel (segment_ptr), 18), 1, code); 380 if code ^= 0 then do; 381 P_code = code; 382 return; 383 end; 384 end; 385 else do; 386 /* may be an early dump, check for inzr_stk0 */ 387 call amu_$slt_search_seg_ptr (sltp, names_ptr, "inzr_stk0", segment_ptr, code); 388 if code ^= 0 then do; 389 call amu_$slt_search_init_seg_ptr (sltp, names_ptr, "inzr_stk0", segment_ptr, code); 390 code = 0; /* Totaly ignore this error code */ 391 end; 392 hardcore_info.segno.stack_0 = fixed(baseno (segment_ptr),17); 393 amu_info.early_dump = "1"b; 394 end; 395 396 P_code = 0; 397 return; 398 399 error_ret: 400 P_code = ecode; 401 return; 402 403 /*****************************************************************************/ 404 405 amu_hardcore_info_$set_cur_ptrs: 406 entry (P_amu_info_ptr, P_ptr); 407 amu_info_ptr = P_amu_info_ptr; 408 hardcore_cur_ptr = P_ptr; 409 410 if hardcore_info.pointers.upt.lptr ^= null then 411 hardcore_cur.uptp = hardcore_info.pointers.upt.lptr; 412 else hardcore_cur.uptp = hardcore_info.pointers.upt.fptr; 413 414 if hardcore_info.pointers.slt.lptr ^= null then 415 hardcore_cur.sltp = hardcore_info.pointers.slt.lptr; 416 else hardcore_cur.sltp = hardcore_info.pointers.slt.fptr; 417 418 if hardcore_info.pointers.sltnt.lptr ^= null then 419 hardcore_cur.sltntp = hardcore_info.pointers.sltnt.lptr; 420 else hardcore_cur.sltntp = hardcore_info.pointers.sltnt.fptr; 421 422 if hardcore_info.pointers.definitions.lptr ^= null then 423 hardcore_cur.defp = hardcore_info.pointers.definitions.lptr; 424 else hardcore_cur.defp = hardcore_info.pointers.definitions.fptr; 425 426 if hardcore_info.pointers.sst.lptr ^= null then 427 hardcore_cur.sstp = hardcore_info.pointers.sst.lptr; 428 else hardcore_cur.sstp = hardcore_info.pointers.sst.fptr; 429 430 if hardcore_info.pointers.tc_data.lptr ^= null then 431 hardcore_cur.tc_datap = hardcore_info.pointers.tc_data.lptr; 432 else hardcore_cur.tc_datap = hardcore_info.pointers.tc_data.fptr; 433 434 if hardcore_info.pointers.sstnt.lptr ^= null then 435 hardcore_cur.sstntp = hardcore_info.pointers.sstnt.lptr; 436 else hardcore_cur.sstntp = hardcore_info.pointers.sstnt.fptr; 437 438 return; 439 440 /*****************************************************************************/ 441 442 fill_ptrs: 443 proc (hpdp, dp); 444 dcl 1 hard_ptr_data like hardcore_info.pointers.slt based (hpdp); 445 dcl hpdp ptr; 446 dcl dp ptr; 447 call amu_$fdump_translate_contiguous (amu_info_ptr, dp, addr (temp_translation), ecode); 448 go to fill_ptrs_common; 449 450 /*****************************************************************************/ 451 452 fill_ptrs_no_trans: 453 entry (hpdp, dp); 454 455 fill_ptrs_common: 456 if temp_translation.flags.in_dump = "1"b then do; 457 hard_ptr_data.fptr = temp_translation.part1.ptr; 458 hard_ptr_data.lptr = null (); 459 end; 460 else do; 461 hard_ptr_data.lptr = temp_translation.part1.ptr; 462 hard_ptr_data.fptr = null (); 463 end; 464 end fill_ptrs; 465 466 /*****************************************************************************/ 467 468 exists_unpaged_page_table: proc(segment_ptr) returns(bit(1)); 469 470 dcl segment_ptr ptr; 471 dcl code fixed bin(35); 472 473 segment_ptr = null(); 474 code = 0; 475 call amu_$slt_search_seg_ptr (sltp, names_ptr, "unpaged_page_tables", segment_ptr, code); 476 if code = 0 then return("1"b); 477 else return("0"b); 478 479 end exists_unpaged_page_table; 480 481 /*****************************************************************************/ 482 483 get_and_set: 484 proc (dseg_ptr, temp_name,hardcore_num, code); 485 486 dcl code fixed bin(35); 487 dcl dseg_ptr ptr; 488 dcl temp_name char (32); 489 dcl hardcore_num fixed bin (15); 490 491 dcl bound fixed bin(19); 492 dcl sdwp ptr; 493 494 code = 0; 495 call initiate_file_ (deadproc_dir, temp_name, R_ACCESS, temp_ptr, bitcount, code); 496 if temp_ptr = null () then do; 497 return; 498 end; 499 if temp_name = "kst" then temp_name = "kst_seg"; 500 call get_ptr_from_slt (temp_name, segment_ptr); 501 hardcore_num = fixed (baseno (segment_ptr), 15); 502 sdwp = addrel(dseg_ptr, hardcore_num*2); 503 bound = (binary (sdwp->sdw.bound, 14) +1) * 16; /* get number of words */ 504 translation.part1.lth = bound; 505 translation.part1.ptr = temp_ptr; 506 translation.segno = fixed (baseno (segment_ptr), 17); 507 call amu_$translate_add (amu_info_ptr, translation_ptr, (translation.segno), code); 508 if code ^= 0 then do; 509 return; 510 end; 511 code = 0; 512 end get_and_set; 513 514 /*****************************************************************************/ 515 516 get_ptr_from_slt: 517 proc (segment_name, temp_ptr); 518 dcl test_name char (32); 519 dcl temp_ptr ptr; 520 dcl segment_name char (*); 521 dcl seg_ptr ptr; 522 temp_ptr = null (); 523 test_name = segment_name; 524 525 call amu_$slt_search_seg_ptr 526 (sltp, names_ptr, test_name, temp_ptr, ecode); 527 528 if ecode ^= 0 then do; 529 seg_ptr = amu_$definition_ptr (amu_info_ptr, "active_all_rings_data", "stack_base_segno", code); 530 if code = 0 then do; 531 call amu_$do_translation (amu_info_ptr, fixed (baseno (seg_ptr), 17), addr (hardcore_info.segno.stack_0), 532 fixed (rel (seg_ptr), 18), 1, code); 533 if code ^= 0 then do; 534 P_code = code; 535 return; 536 end; 537 end; 538 else do; 539 /* may be an early dump, check for inzr_stk0 */ 540 call amu_$slt_search_seg_ptr (sltp, names_ptr, "inzr_stk0", seg_ptr, code); 541 if code ^= 0 then do; 542 call amu_$slt_search_init_seg_ptr (sltp, names_ptr, "inzr_stk0", seg_ptr, code); 543 code = 0; /* Totaly ignore this code */ 544 end; 545 end; 546 hardcore_info.segno.stack_0 = fixed(baseno (segment_ptr),17); 547 amu_info.early_dump = "1"b; 548 if amu_info.early_dump then return; 549 else goto error_ret; 550 end; 551 552 end get_ptr_from_slt; 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 */ 553 2 1 /* BEGIN INCLUDE FILE amu_hardcore_info.incl.pl1 */ 2 2 2 3 /* This structure contains information about the hardcore supervisor address 2 4* space for an address translation. */ 2 5 2 6 dcl 1 hardcore_info aligned based (amu_info.hardcore_info_ptr), 2 7 2 8 2 pointers, /* assorted pointers to various useful items */ 2 9 3 slt aligned, /* SLT */ 2 10 4 fptr pointer unaligned, /* address in foreign address space */ 2 11 4 lptr pointer unaligned, /* location in local address space */ 2 12 3 sltnt aligned like hardcore_info.slt, /* SLT names segment */ 2 13 3 definitions aligned like hardcore_info.slt, /* hardcore definitions_ segment */ 2 14 2 15 3 sst aligned like hardcore_info.slt, /* SST */ 2 16 3 tc_data aligned like hardcore_info.slt, /* TC_DATA */ 2 17 3 sstnt aligned like hardcore_info.slt, /* SSTNT (if any -- foreign_ptr = null if not) */ 2 18 3 upt aligned like hardcore_info.slt, /* unpaged_page_tables (if any -- foreign_ptr = null if not) */ 2 19 2 20 2 segno, /* segment numbers of various per-process/per-processor segs */ 2 21 3 prds fixed bin (15), /* segno of PRDS */ 2 22 3 dseg fixed bin (15), /* DSEG */ 2 23 3 pds fixed bin (15), /* PDS */ 2 24 3 kst fixed bin (15), /* KST */ 2 25 3 stack_0 fixed bin (15), /* segno of stack_0 -- first one in stack group */ 2 26 3 unpaged_page_tables fixed bin(15), /* segno of unpaged_page_tables if it exists */ 2 27 2 28 2 apt, /* information about the APT */ 2 29 3 foreign_ptr pointer unaligned, /* foreign and local pointers to tcm.apt */ 2 30 3 local_ptr pointer unaligned, 2 31 3 count fixed bin, /* number of APTEs */ 2 32 3 size fixed bin, /* size of a single APTE */ 2 33 2 34 2 hcs_count fixed bin, /* highest hardcore segno */ 2 35 2 36 2 pad1 fixed bin; 2 37 2 38 dcl hardcore_cur_ptr ptr; 2 39 2 40 dcl 1 hardcore_cur based (hardcore_cur_ptr), 2 41 2 sltp ptr, 2 42 2 sltntp ptr, 2 43 2 defp ptr, 2 44 2 sstp ptr, 2 45 2 tc_datap ptr, 2 46 2 sstntp ptr, 2 47 2 uptp ptr; 2 48 2 49 2 50 2 51 2 52 /* END INCLUDE FILE amu_hardcore_info.incl.pl1 */ 554 3 1 /* BEGIN INCLUDE FILE amu_info.incl.pl1 */ 3 2 3 3 dcl 1 amu_info aligned based (amu_info_ptr), 3 4 2 version char (8) aligned, /* AMU_INFO_VERSION */ 3 5 2 flags aligned, 3 6 3 early_dump bit(1) unal, 3 7 3 pad bit(35) unal, 3 8 2 type fixed bin unal, /* One of the types below */ 3 9 2 time_created fixed bin (71) aligned, /* time created -- for debugging purposes */ 3 10 2 chain, /* a chain of all the amu_info's which exist */ 3 11 3 prev pointer unaligned, 3 12 3 next pointer unaligned, 3 13 3 14 2 area_ptr pointer, /* pointer to area used for allocating things */ 3 15 3 16 2 translation_table_ptr pointer, /* pointer to address map -- always present */ 3 17 /* SEE: amu_translation.incl.pl1 */ 3 18 2 fdump_info_ptr pointer, 3 19 /* pointer to FDUMP info, present if looking at an FDUMP */ 3 20 /* SEE: amu_fdump_info.incl.pl1 */ 3 21 /* old_uid_table pointer if looking at a SAVED PROC. */ 3 22 /* See: amu_old_uid_table */ 3 23 3 24 3 25 2 hardcore_info_ptr pointer, /* pointer to hardcore information -- always present */ 3 26 /* SEE: amu_hardcore_info.incl.pl1 */ 3 27 2 copy_chain pointer, /* pointer to info about segment copies */ 3 28 /* SEE: amu_copy_info.incl.pl1 */ 3 29 2 process_info_ptr pointer, /* pointer to process info for this translation */ 3 30 /* SEE: amu_process_info.incl.pl1 */ 3 31 2 process_idx fixed bin, /* index of process in translation-specifc process table */ 3 32 3 33 2 proc_idx_hold fixed bin, /* a place to keep the index when a changing to another proc */ 3 34 3 35 2 error_info, /* various info about how amu_error_ is to behave */ 3 36 3 error_flags aligned, 3 37 4 handler_exists bit (1) unaligned, /* set to indicate existence of an amu_error handler */ 3 38 4 in_subsystem bit (1) unaligned, /* This amu_info belongs to an ssu_ maintained subsystem */ 3 39 4 pad bit (34) unaligned, 3 40 3 sci_ptr pointer, /* sci_ptr for subsystem, if in_subsystem = "1"b */ 3 41 2 definitions_info_ptr ptr; 3 42 3 43 dcl amu_area area based (amu_info.area_ptr); 3 44 3 45 dcl amu_info_ptr pointer; 3 46 3 47 dcl (FDUMP_TYPE init (1037), /* the various legitimate types of amu_info's */ 3 48 FDUMP_PROCESS_TYPE init (1038), 3 49 ONLINE_TYPE init (1039), 3 50 ONLINE_PROCESS_TYPE init (1040), 3 51 NETWORK_FDUMP_TYPE init (1041), 3 52 NETWORK_ONLINE_TYPE init (1042), 3 53 SAVED_PROC_TYPE init (1043), 3 54 INDIRECT_TYPE init (1044)) fixed bin internal static options (constant); 3 55 3 56 dcl AMU_INFO_VERSION_1 char (8) internal static options (constant) init ("amu_v1"); 3 57 dcl AMU_INFO_VERSION char (8) internal static options (constant) init ("amu_v1"); 3 58 dcl AMU_INFO_VERSION_2 char (8) internal static options (constant) init ("amu_v2"); 3 59 3 60 dcl PDIR_SUFFIX char(4) init("pdir") int static options(constant); 3 61 3 62 /* END INCLUDE FILE amu_info.incl.pl1 */ 555 4 1 /* BEGIN INCLUDE FILE amu_fdump_info.incl.pl1 */ 4 2 4 3 dcl 1 fdump_info aligned based (amu_info.fdump_info_ptr), 4 4 2 version char (8), 4 5 2 ref_count fixed bin, /* number of initiations */ 4 6 4 7 2 erf_name char (32), /* ERF name for this dump */ 4 8 2 dump_dname char (168), /* location of the dump */ 4 9 2 dump_ename char (32), /* ename of component zero */ 4 10 2 system_id char (8), /* the system_id of this erf */ 4 11 2 version_id char (8), /* the version id of this erf */ 4 12 2 dump_seg_0_uid bit (36) aligned, /* for determining EQ-ness and gullibility checking */ 4 13 4 14 2 n_dump_segs fixed bin, /* number of real segs in the dump */ 4 15 2 copy_block_ptr pointer, /* pointer to chain of temp segment blocks */ 4 16 4 17 2 dump_seg_ptr (0:31) pointer, /* pointer and length arrays */ 4 18 2 dump_seg_lth (0:31) fixed bin (18), 4 19 4 20 2 fdump_process_table_ptr pointer; /* pointer to array describing processes */ 4 21 4 22 4 23 dcl 1 fdump_process_table aligned based (fdump_info.fdump_process_table_ptr), 4 24 2 size fixed bin, /* number of entries */ 4 25 4 26 2 array (0:alloc_fdump_process_table_size - 1 refer (fdump_process_table.size)) like fp_table; 4 27 4 28 dcl 1 fp_table based (fp_table_ptr), 4 29 2 first_seg fixed bin, 4 30 2 last_seg fixed bin, 4 31 2 process_info_ptr pointer unaligned, /* pointer to process_info structure, if filled in */ 4 32 2 dmp_seg_indx fixed bin, /* dump seg index where process can be found */ 4 33 2 dmp_seg_offset fixed bin (24), /* offset in the segment refered to by dmp_seg_indx where process starts */ 4 34 2 cpu_name char (1), 4 35 2 dbr fixed bin (24), /* address portion of DBR */ 4 36 2 apte_offset fixed bin (18); 4 37 4 38 dcl fp_table_ptr ptr; 4 39 4 40 dcl alloc_fdump_process_table_size fixed bin; 4 41 4 42 dcl AMU_FDUMP_INFO_VERSION_1 char (8) internal static options (constant) init ("amu_erf1"); 4 43 dcl AMU_FDUMP_INFO_VERSION char (8) internal static options (constant) init ("amu_erf1"); 4 44 4 45 /* END INCLUDE FILE amu_fdump_info.incl.pl1 */ 556 5 1 /* BEGIN INCLUDE FILE amu_process_info.incl.pl1 */ 5 2 5 3 /* This structure describes information about a single process in an address 5 4* translation. It is only relevant for translations involving the online system 5 5* or an FDUMP. */ 5 6 5 7 dcl 1 process_info aligned based (amu_info.process_info_ptr), /* information about a single process */ 5 8 2 pid bit (36) aligned, /* process_id of this process */ 5 9 2 address_map_ptr pointer unaligned, /* pointer to address map */ 5 10 2 idx fixed bin, /* index of process in FDUMP, or apte index if online */ 5 11 2 state fixed bin, /* state, from the APTE -- only good for FDUMP */ 5 12 5 13 2 dbr fixed bin (71), /* DBR of this process */ 5 14 5 15 2 apte aligned, /* pointer to this process's APTE */ 5 16 3 foreign_ptr pointer unaligned, 5 17 3 local_ptr pointer unaligned, 5 18 2 prds aligned like process_info.apte, /* and PRDS, IFF it has one (is running) -- volatile */ 5 19 2 dseg aligned like process_info.apte, /* DSEG -- These values must be constantly recalculated */ 5 20 2 pds aligned like process_info.apte, /* PDS --- for an online process, if phcs transparency */ 5 21 2 kst aligned like process_info.apte, /* KST --- is not in use. */ 5 22 5 23 2 dump_segx, /* index of first and last seg belonging to this */ 5 24 3 first fixed bin, /* process in bos_dump.seg_array, or zero if none */ 5 25 3 last fixed bin, /* this information is only valid for a process in a dump */ 5 26 5 27 2 pad1 fixed bin; 5 28 5 29 /* END INCLUDE FILE amu_process_info.incl.pl1 */ 557 6 1 /* BEGIN INCLUDE FILE amu_translation.incl.pl1 */ 6 2 6 3 6 4 6 5 /****^ HISTORY COMMENTS: 6 6* 1) change(87-01-16,Parisek), approve(87-07-16,MCR7746), 6 7* audit(87-07-16,Fawcett), install(87-07-28,MR12.1-1049): 6 8* Added the "replaced" field to record whether a segment was replaced by 6 9* another segment via the "replace" request. 6 10* END HISTORY COMMENTS */ 6 11 6 12 6 13 dcl 1 translation_table aligned based (amu_info.translation_table_ptr), 6 14 2 n_entries fixed bin, 6 15 2 max_entries fixed bin, 6 16 6 17 2 valid_array aligned, /* one bit for each valid segno */ 6 18 3 valid (0 : 4095) bit (1) unaligned, 6 19 2 used_array aligned, /* one bit for each existing translation */ 6 20 3 used (0 : 4095) bit (1) unaligned, 6 21 6 22 2 array (alloc_translation_table_max_entries refer (translation_table.max_entries)) like translation; 6 23 6 24 dcl 1 translation aligned based (translation_ptr), /* a single translation */ 6 25 2 segno fixed bin (18) unsigned unaligned, /* foreign segno for this translation */ 6 26 2 flags unaligned, 6 27 3 two_part bit (1) unaligned, /* segment is in two pieces -- from an FDUMP */ 6 28 3 in_dump bit (1) unaligned, /* segment is part of an FDUMP image */ 6 29 3 in_temp_seg bit (1) unaligned, /* segment is a copy at the base of a temp segment */ 6 30 3 in_perm_seg bit (1) unaligned, /* segment is in the file system */ 6 31 3 in_dp_dir bit (1) unaligned, 6 32 3 replaced bit (1) unaligned, 6 33 3 pad bit (12) unaligned, 6 34 2 part1, /* pointer to first (possibly only) part of segment */ 6 35 3 ptr pointer unaligned, 6 36 3 lth fixed bin (19), 6 37 2 part2 like translation.part1; 6 38 6 39 dcl alloc_translation_table_max_entries fixed bin; 6 40 dcl translation_ptr pointer; 6 41 6 42 /* END INCLUDE FILE amu_translation.incl.pl1 */ 558 7 1 /* BEGIN INCLUDE FILE ... sdw.incl.pl1 ... last modified 12 May 1976 */ 7 2 7 3 dcl sdwp ptr; 7 4 7 5 dcl 1 sdw based (sdwp) aligned, /* Segment Descriptor Word */ 7 6 7 7 (2 add bit (24), /* main memory address of page table */ 7 8 2 (r1, r2, r3) bit (3), /* ring brackets for the segment */ 7 9 2 df bit (1), /* directed fault bit (0 => fault) */ 7 10 2 df_no bit (2), /* directed fault number */ 7 11 7 12 2 pad1 bit (1), 7 13 2 bound bit (14), /* boundary field (in 16 word blocks) */ 7 14 2 access, /* access bits */ 7 15 3 read bit (1), /* read permission bit */ 7 16 3 execute bit (1), /* execute permission bit */ 7 17 3 write bit (1), /* write permission bit */ 7 18 3 privileged bit (1), /* privileged bit */ 7 19 2 unpaged bit (1), /* segment is unpaged if this is 1 */ 7 20 2 entry_bound_sw bit (1), /* if this is 0 the entry bound is checked by hardware */ 7 21 2 cache bit (1), /* cache enable bit */ 7 22 2 entry_bound bit (14)) unaligned; /* entry bound */ 7 23 7 24 dcl 1 sdwa (0: 1) based (sdwp) aligned like sdw; /* SDW array (descriptor segment) */ 7 25 7 26 /* END INCLUDE FILE sdw.incl.pl1 */ 559 8 1 /* BEGIN INCLUDE FILE slt.incl.pl1 --- Last modified 2/76 SHW */ 8 2 8 3 /* Declarations for Segment Loading Table header and array. 8 4* 8 5* Used by Initialization and MST Checker subroutines */ 8 6 8 7 dcl sltp ptr, /* pointer to base of SLT segment */ 8 8 names_ptr ptr, /* pointer to base of SLT names segment */ 8 9 namep ptr, /* pointer to segment name list block */ 8 10 pathp ptr, /* pointer to segment's directory path name */ 8 11 aclp ptr; /* pointer to acl structure */ 8 12 8 13 declare 1 slt based (sltp) aligned, /* declaration of Segment Loading Table (SLT) */ 8 14 2 name_seg_ptr ptr, /* words 0-1, pointer (ITS pair) to name segment */ 8 15 2 free_core_start fixed bin (24), /* word 2, start of free core after perm-wired */ 8 16 2 first_sup_seg fixed bin (18), /* word 3, first supervisor segment number */ 8 17 2 last_sup_seg fixed bin (18), /* word 4, last supervisor segment number */ 8 18 2 first_init_seg fixed bin (18), /* word 5, first initializer segment number */ 8 19 2 last_init_seg fixed bin (18), /* word 6, last initializer segment number */ 8 20 2 free_core_size fixed bin (24), /* size (in words) of free core after perm-wired */ 8 21 2 seg (0:8191) aligned, /* segment entries (4 words each) */ 8 22 3 slte (4) fixed bin (35); /* Space for SLT entries */ 8 23 8 24 /* auxiliary segment of SLT for storing of segment names and directory path names */ 8 25 8 26 declare 1 name_seg based (names_ptr) aligned, /* name segment header */ 8 27 2 pad bit (18) unal, 8 28 2 next_loc bit (18) unal, /* Next available free location in name seg */ 8 29 2 ht (0:127) bit (18) aligned; /* Names hash table */ 8 30 8 31 declare 1 segnam based (namep) aligned, /* declaration for segment name block */ 8 32 2 count fixed bin (17), /* number of segment names in this block */ 8 33 2 names (50 refer (segnam.count)), /* segment name array */ 8 34 3 hp bit (18) unal, /* hash thread pointer */ 8 35 3 ref bit (1) unal, /* "1"b if name referenced */ 8 36 3 pad bit (5) unal, 8 37 3 segno bit (12) unal, /* segment number associated with this name */ 8 38 3 name char (32) unal; /* space for name (max 32 characters) */ 8 39 8 40 declare 1 path based (pathp) aligned, /* declaration for directory path name */ 8 41 2 size fixed bin (17), /* length of pathname */ 8 42 2 name char (168 refer (path.size)) unal, /* directory path name */ 8 43 2 acls fixed bin; /* ACL list starts here */ 8 44 8 45 declare 1 acls based (aclp) aligned, /* declaration for acl list */ 8 46 2 count fixed bin, /* number of entries in acl list */ 8 47 2 acl (50 refer (acls.count)), /* array of acl entries */ 8 48 3 userid char (32), /* user specification */ 8 49 3 mode bit (36) aligned, /* mode for the specified user */ 8 50 3 pad bit (36) aligned, 8 51 3 code fixed bin; 8 52 8 53 8 54 /* END INCLUDE FILE slt.incl.pl1 */ 560 9 1 /* BEGIN INCLUDE FILE ... tcm.incl.pl1 ... used to generate tc_data cds */ 9 2 /* NOTE -- This include file has TWO counterparts in ALM: tc_meters.incl.alm and */ 9 3 /* wcte.incl.alm. They cannot be produced with cif, and must be kept up to date manually. */ 9 4 /* Modified 830914 to replace tty_polling_time with opc_polling_time... -E. A. Ranzenbach */ 9 5 /* Modified 1984.05.21 by M. Pandolf to add tc_suspend_lock */ 9 6 /* Modified 1984.11.26 by Keith Loepere for uid_array. */ 9 7 /* Modified 1984.12.06 by Keith Loepere for page create delaying. */ 9 8 9 9 dcl tcmp ptr; 9 10 9 11 dcl 1 tcm aligned based (tcmp), 9 12 2 tc_suspend_lock like lock, /* when locked, tc is suspended */ 9 13 2 cid2 fixed bin (18), 9 14 2 cid3 fixed bin (18), 9 15 2 cid4 fixed bin (18), 9 16 2 depth_count fixed bin (18), /* depth last process run */ 9 17 2 loadings fixed bin (18), /* number of process loadings */ 9 18 9 19 2 blocks fixed bin (18), /* number of calls to block */ 9 20 2 wakeups fixed bin (18), /* number of calls to wakeup */ 9 21 2 waits fixed bin (18), /* number of calls to wait */ 9 22 2 notifies fixed bin (18), /* number of calls to notify */ 9 23 2 schedulings fixed bin (18), 9 24 2 interactions fixed bin (18), /* number of interactive schedulings */ 9 25 2 avequeue fixed bin (35, 18), /* recent time average of number in queue */ 9 26 2 te_wait fixed bin (18), /* times te called from wait */ 9 27 9 28 2 te_block fixed bin (18), /* times te updated from block */ 9 29 2 te_i_stop fixed bin (18), /* times te updated from i_stop */ 9 30 2 te_pre_empt fixed bin (18), /* times te updated from pre_empt */ 9 31 2 p_interactions fixed bin, /* times interaction bit turned off because of high priority */ 9 32 2 idle fixed bin (71), /* total idle time */ 9 33 2 mp_idle fixed bin (71), /* multi-programming idle */ 9 34 9 35 2 nmp_idle fixed bin (71), /* non-multi-programming idle time */ 9 36 2 zero_idle fixed bin (71), /* zero idle time */ 9 37 2 last_time fixed bin (71), /* last time a process was run */ 9 38 2 loop_locks fixed bin (18), /* times looped on the APT lock */ 9 39 2 loop_lock_time fixed bin (18), /* time looping on the APT lock */ 9 40 2 ave_eligible fixed bin (35, 18), /* average length of eligible queue */ 9 41 2 sort_to_elhead fixed bin (18), /* 0=> no one,1 => int've only, 2 => everybody */ 9 42 2 processor_time fixed bin (71), /* total processor time on system */ 9 43 2 response_time fixed bin (71), /* estimate of response time */ 9 44 2 eligible_time fixed bin (71), /* estimate of eligible time */ 9 45 2 response_count fixed bin, /* count of response meters */ 9 46 2 eligible_count fixed bin, /* count of eligible meters */ 9 47 2 quit_counts (0:5) fixed bin, /* array of buckets indexed by state */ 9 48 2 loading_idle fixed bin (71), /* loading_idle time */ 9 49 2 delta_vcpu fixed bin (71), /* delta virtual CPU time for the system */ 9 50 2 post_purge_switch fixed bin, /* ON if post purging is to be done */ 9 51 2 time_out_severity fixed bin, /* syserr first arg for notify time outs */ 9 52 2 notify_check fixed bin, /* obsolete */ 9 53 2 quit_priority fixed bin, /* factor for scheduler quit response */ 9 54 2 iobm_polling_time fixed bin (71), /* time to poll iobm */ 9 55 2 end_of_time fixed bin (71), /* very large time */ 9 56 2 gp_at_notify fixed bin (18), /* 0 => just do get_idle_processor */ 9 57 2 gp_at_ptlnotify fixed bin (18), /* 0 => just do get_idle_processor */ 9 58 2 int_q_enabled fixed bin (18), /* 0 => no intv q in percent mode */ 9 59 2 fnp_buffer_threshold fixed bin (18), /* if fewer free buffs then stingy alloc strategy */ 9 60 /* set this to >= half n_ttylines/fnp for safety */ 9 61 9 62 /* 100 octal */ 9 63 9 64 2 depths (8) fixed bin (18), /* histogram of run depths */ 9 65 2 tdepths (8) fixed bin (71), /* histogram of times run per depth */ 9 66 2 pfdepth (8) fixed bin (18), /* histogram of page faults per depth */ 9 67 9 68 2 ptl_not_waits fixed bin (18), /* times ptl_wait noticed ptl was unlocked */ 9 69 2 gw_gp_window_count fixed bin (18), /* times window noticed */ 9 70 2 metering_lock fixed bin (18), /* 0=locked, else unlocked */ 9 71 2 ptl_waits fixed bin (18), /* num calls to ptl_wait */ 9 72 2 gp_start_count fixed bin (18), /* to detect gw_gp window lossage */ 9 73 2 gp_done_count fixed bin (18), 9 74 2 nto_check_time fixed bin (71), /* next time at which nto code will be called */ 9 75 2 nto_delta fixed bin (35), /* microsec between nto checks */ 9 76 2 nto_count fixed bin (18), /* number of times nto detected */ 9 77 2 tcpu_scheduling fixed bin (18), /* obsolete */ 9 78 2 nto_event bit (36), /* last event which NTO'd */ 9 79 2 page_notifies fixed bin (18), 9 80 2 notify_nobody_count fixed bin (18), 9 81 2 notify_nobody_event bit (36), 9 82 2 system_type fixed bin, /* used to be tcm.inter */ 9 83 9 84 2 stat (0:15) fixed bin (18), /* num apte's in each state */ 9 85 9 86 /* 200 octal */ 9 87 9 88 2 wait (8), 9 89 3 time fixed bin (18), /* histogram of page fault waiting times versus did */ 9 90 3 count fixed bin (18), 9 91 9 92 2 ready (8), 9 93 3 time fixed bin (18), /* histogram of times in ready queue */ 9 94 3 count fixed bin (18), 9 95 9 96 2 total_pf_time fixed bin (71), /* total time spent from start to end of 9 97* all page faults */ 9 98 2 total_pf_count fixed bin (18), /* total number of page faults metered */ 9 99 2 auto_tune_ws fixed bin (18), /* 0=> dont, atherwise compensate for quantum len */ 9 100 2 ocore_delta fixed bin (18), /* number of pages reserved for int users */ 9 101 2 ws_sum fixed bin (18), /* total of eligible's ws_sizes */ 9 102 2 nonidle_force_count fixed bin (18), /* count of eligibilities forced */ 9 103 2 itt_list_lock bit (36) aligned, /* Lock on ITT free list */ 9 104 2 cpu_pf_time fixed bin (71), /* total cpu time spent handling page faults */ 9 105 2 cpu_pf_count fixed bin (18), /* total count of cpu time meterings */ 9 106 2 special_offsets unaligned, 9 107 3 apt_offset bit (18), 9 108 3 pad bit (18), 9 109 2 getwork_time fixed bin (71), /* total time spent in getwork */ 9 110 2 getwork_count fixed bin (18), /* total times through getwork */ 9 111 2 short_pf_count fixed bin (18), /* number of short page faults */ 9 112 2 interrupt_time fixed bin (71), /* total time spent in interrupt */ 9 113 2 interrupt_count fixed bin (71), /* total number of metered interrupts */ 9 114 2 ocore fixed bin (35, 18), /* fraction of core for int've users */ 9 115 2 pre_empt_flag bit (36) aligned, /* controls whether preempting at done time */ 9 116 2 cumulative_memory_usage fixed binary (71), /* total number of memory usage units */ 9 117 2 processor_time_at_define_wc fixed bin (71), /* value of processor_time when WC's last defined */ 9 118 2 boost_priority fixed bin, /* number of times priority process given high priority */ 9 119 2 lost_priority fixed bin, /* number of times priority process lost eligibility */ 9 120 2 total_clock_lag fixed bin (71), /* sum of all simulated clock delays */ 9 121 2 clock_simulations fixed bin, /* number of times alarm clock interrupt was simulated */ 9 122 2 max_clock_lag fixed bin, /* largest simulated alarm clock delay */ 9 123 9 124 /* 300 octal */ 9 125 9 126 2 pdscopyl fixed bin (18), /* amount of pds to copy for new process */ 9 127 2 max_hproc_segno fixed bin, /* largest allowed hardcore segment number */ 9 128 2 prds_length fixed bin (18), /* length of PRDS */ 9 129 2 pds_length fixed bin (18), /* length of PDS */ 9 130 2 lock fixed bin (18), /* process id generator lock */ 9 131 2 id bit (36) aligned, /* next uid to be added to uid_array */ 9 132 2 system_shutdown fixed bin (18), 9 133 2 working_set_factor fixed bin (35, 18), /* working set factor */ 9 134 9 135 2 ncpu fixed bin (18), /* number of processors currently being used */ 9 136 2 last_eligible bit (18), /* last process to gain eligibility */ 9 137 2 apt_lock fixed bin (35), /* + write; 0 hidden; -1 unlocked; -(N+1) Nreaders */ 9 138 2 apt_size fixed bin (18), /* number of APT entries */ 9 139 2 realtime_q aligned like based_sentinel, /* processes with realtime deadlines */ 9 140 2 aht_size fixed bin (18), /* APT hash table size */ 9 141 2 itt_size fixed bin (18), /* number of ITT entries */ 9 142 9 143 2 dst_size fixed bin (18), /* number of allowed DST entries */ 9 144 2 itt_free_list bit (18), /* pointer to ITT free list */ 9 145 2 used_itt fixed bin (18), /* number of used ITT entries */ 9 146 2 initializer_id bit (36) aligned, /* process id of initializer */ 9 147 2 n_eligible fixed bin (18), /* number of processes eligible */ 9 148 2 max_eligible fixed bin (30), /* maximum allowed number of eligible processes */ 9 149 2 wait_enable fixed bin (18), /* turned on when waiting mechanism works */ 9 150 2 apt_entry_size fixed bin (18), /* size of an APT entry */ 9 151 9 152 2 interactive_q aligned like based_sentinel, /* head of interactive queue */ 9 153 2 dst_ptr ptr, /* pointer to device signal table */ 9 154 2 old_user ptr, /* last process to run (apt ptr ) */ 9 155 2 initialize_time fixed bin (71), /* time of initialization */ 9 156 9 157 2 init_event fixed bin (18), /* wait event during initialization */ 9 158 2 oldt fixed bin (18), /* timer reading from previous process */ 9 159 2 newt fixed bin (18), /* timer setting for new process */ 9 160 2 tefirst fixed bin (30), /* first eligible time */ 9 161 2 telast fixed bin (30), /* last eligible time */ 9 162 2 timax fixed bin (35), /* time in queue for lowest level */ 9 163 2 empty_q bit (18), /* thread of empty APT entries */ 9 164 2 working_set_addend fixed bin (18), /* additive working set parameter */ 9 165 2 ready_q_head bit (0) aligned, /* for added segdef */ 9 166 2 eligible_q_head aligned like based_sentinel, /* head of eligible queue */ 9 167 2 ready_q_tail bit (0) aligned, /* for added segdef */ 9 168 2 eligible_q_tail aligned like based_sentinel, /* tail of eligible queue */ 9 169 2 idle_tail aligned like based_sentinel, /* tail of idle list */ 9 170 2 min_eligible fixed bin (30), 9 171 2 alarm_timer_list bit (18) aligned, /* rel pointer to apt entry for next alarm timer */ 9 172 2 guaranteed_elig_inc fixed bin (35), /* amount of guaranteed eligibility time in microsecs. */ 9 173 2 priority_sched_inc fixed bin (35), /* amount of block time before process is given priority */ 9 174 2 next_alarm_time fixed bin (71), /* clock time for next alarm timer */ 9 175 2 priority_sched_time fixed bin (71), /* time for priority process to be given priority */ 9 176 2 opc_polling_time fixed bin (71), /* time to poll console DIM */ 9 177 2 disk_polling_time fixed bin (71), /* time to poll disk DIM */ 9 178 2 tape_polling_time fixed bin (71), /* time to poll tape DIM */ 9 179 2 imp_polling_time fixed bin (71), /* time to poll imp */ 9 180 2 imp_polling_lock fixed bin (18), /* do not poll if lock set */ 9 181 2 max_channels fixed bin (18), /* num special channels per process */ 9 182 9 183 /* 400 octal */ 9 184 9 185 2 system_virtual_time fixed bin (71), /* non-idle virtual time */ 9 186 2 credit_bank fixed bin (71), /* credits not yet passed out */ 9 187 2 min_wct_index bit (18) aligned, /* offset of initializer work class table entry */ 9 188 2 max_wct_index bit (18) aligned, /* offset of highest wcte currently defined */ 9 189 2 delta_vt fixed bin (71), /* temp used by pxss.compute_virtual_clocks */ 9 190 2 gross_idle_time fixed bin (71), /* idle time_used_clock */ 9 191 2 credits_per_scatter fixed bin (35), /* total number of credits awarded at once */ 9 192 2 best_credit_value fixed bin (18), /* temp for pxss.find_next_eligible */ 9 193 2 define_wc_time fixed bin (71), /* clock time when workclasses last degined */ 9 194 2 max_batch_elig fixed bin (35), 9 195 2 num_batch_elig fixed bin (35), 9 196 2 deadline_mode fixed bin (35), /* 0=> ti sorts, else deadline sorts */ 9 197 2 credits_scattered fixed bin (35), 9 198 2 max_max_eligible fixed bin (30), /* Maximum of maxe */ 9 199 2 max_stopped_stack_0 fixed bin (35), /* Maximum stack_0's suspended by stopped procs */ 9 200 2 stopped_stack_0 fixed bin (35), /* Number stack_0's suspended by stopped procs */ 9 201 2 mos_polling_interval fixed bin (35), /* for heals */ 9 202 2 mos_polling_time fixed bin (71), /* for heals */ 9 203 2 vcpu_response_bounds (VCPU_RESPONSE_BOUNDS) fixed bin (35), 9 204 2 vcpu_response_bounds_size fixed bin (35), 9 205 2 meter_response_time_calls fixed bin (35), 9 206 2 meter_response_time_invalid fixed bin (35), 9 207 2 meter_response_time_overhead fixed bin (71), 9 208 2 init_wait_time fixed bin (71), /* used by wait/notify during initialization */ 9 209 2 init_wait_timeout fixed bin (71), /* notify-timeout interval during initialization */ 9 210 2 init_timeout_severity fixed bin, /* notify-timeout severity during initialization */ 9 211 2 init_timeout_recurse fixed bin, /* count of NTO recursion during initialization */ 9 212 2 max_timer_register fixed bin (71), /* max cpu burst = # cpus x pre_empt_sample_time */ 9 213 2 pre_empt_sample_time fixed bin (35), /* tuning parameter - max time between samples */ 9 214 2 governing_credit_bank fixed bin (35), /* used for limiting eligibility on governed work classes*/ 9 215 2 process_initial_quantum fixed bin (35), /* eligibility quantum first eligibility */ 9 216 2 default_procs_required bit (8) aligned, /* default mask of CPUs required */ 9 217 2 work_class_idle fixed bin (71), /* idle time due to work class restrictions */ 9 218 9 219 /* Tuning Parameters for Stack Truncation */ 9 220 9 221 2 stk_truncate bit (1) aligned, 9 222 2 stk_truncate_always bit (1) aligned, 9 223 2 stk_trunc_avg_f1 fixed bin (35, 18), 9 224 2 stk_trunc_avg_f2 fixed bin (35, 18), 9 225 2 lock_error_severity fixed bin, /* syserr severity */ 9 226 9 227 2 gv_integration fixed bin (35), /* Integration interval for governing */ 9 228 2 gv_integration_set bit (1) aligned, /* ON => gv_integration set by ctp */ 9 229 2 pauses fixed bin (35), /* Calls to pause (reschedule) */ 9 230 2 volmap_polling_time fixed bin (71), 9 231 2 next_ring0_timer fixed bin (71), /* next time that ring 0 timer goes off */ 9 232 2 realtime_io_priority_switch fixed bin, /* 0 => give I/O interrupt wakeups realtime priotiry */ 9 233 2 realtime_io_deadline fixed bin (35), /* Delta to clock for I/O realtime deadline */ 9 234 2 realtime_io_quantum fixed bin (35), /* Quantum for I/O realtime burst */ 9 235 2 realtime_priorities fixed bin (35), /* Count for metering */ 9 236 2 relinquishes fixed bin (35), /* Calls to relinquish_priority */ 9 237 2 abort_ips_mask bit (36) aligned, /* IPS mask for tc_util$check_abort */ 9 238 9 239 /* 500 octal */ 9 240 9 241 2 uid_array (0:15) bit (36) aligned, /* array from which a uid is chosen (randomly) */ 9 242 2 pad5 (176) fixed bin (35), /* room for expansion compatibly */ 9 243 9 244 /* 1000 octal */ 9 245 9 246 2 pad7 (64) fixed bin (35), 9 247 9 248 /* 1100 octal */ 9 249 9 250 2 pad6 (8) fixed bin (35), 9 251 2 work_class_table aligned, /* array of per workclass information */ 9 252 3 wcte (0:16) aligned like wct_entry, 9 253 9 254 /* 3000 octal */ 9 255 9 256 2 apt fixed bin; 9 257 9 258 dcl wctep ptr; 9 259 9 260 dcl 1 wct_entry aligned based (wctep), /* Work class entry */ 9 261 2 thread unaligned, /* Ready list */ 9 262 3 fp bit (18), /* Head of ready list */ 9 263 3 bp bit (18), /* Tail of ready list */ 9 264 2 flags unaligned, 9 265 3 mnbz bit (1), /* Sentinel bit must not be zero. */ 9 266 3 defined bit (1), 9 267 3 io_priority bit (1), 9 268 3 governed bit (1), 9 269 3 interactive_q bit (1), 9 270 3 pad bit (31), 9 271 2 credits fixed bin (35), /* Current worthiness of group */ 9 272 2 minf fixed bin (35), /* min fraction of cpu */ 9 273 2 pin_weight fixed bin (35), /* number of cycles to pin pages */ 9 274 2 eligibilities fixed bin (35), /* Count of eligibilities awarded */ 9 275 2 cpu_sum fixed bin (71), /* CPU used by members */ 9 276 2 resp1 fixed bin (71), 9 277 2 resp2 fixed bin (71), 9 278 2 quantum1 fixed bin (35), 9 279 2 quantum2 fixed bin (35), 9 280 2 rmeter1 fixed bin (71), 9 281 2 rmeter2 fixed bin (71), 9 282 2 rcount1 fixed bin (35), 9 283 2 rcount2 fixed bin (35), 9 284 2 realtime fixed bin (35), 9 285 2 purging fixed bin (35), 9 286 2 maxel fixed bin (35), 9 287 2 nel fixed bin (35), 9 288 2 number_thinks fixed bin (35), /* number times process entered "think" state */ 9 289 2 number_queues fixed bin (35), /* number times process entered "queued" state */ 9 290 2 total_think_time fixed bin (71), 9 291 2 total_queue_time fixed bin (71), 9 292 9 293 /* The next three arrays correspond to the array vcpu_response_bounds */ 9 294 9 295 2 number_processing (VCPU_RESPONSE_BOUNDS+1) fixed bin (35), /* number times entered "processing" state */ 9 296 2 total_processing_time (VCPU_RESPONSE_BOUNDS+1) fixed bin (71), 9 297 2 total_vcpu_time (VCPU_RESPONSE_BOUNDS+1) fixed bin (71), 9 298 2 maxf fixed bin (35), /* maximum fraction of cpu time */ 9 299 2 governing_credits fixed bin (35), /* for limiting cpu resources */ 9 300 2 pad1 (4) fixed bin (35); 9 301 9 302 9 303 dcl 1 based_sentinel aligned based, /* format of pxss-style sentinel */ 9 304 2 fp bit (18) unal, 9 305 2 bp bit (18) unal, 9 306 2 sentinel bit (36) aligned; 9 307 9 308 dcl VCPU_RESPONSE_BOUNDS fixed bin init (3) int static options (constant); 9 309 9 310 /* END INCLUDE FILE tcm.incl.pl1 */ 561 10 1 /* Begin include file hc_lock.incl.pl1 BIM 2/82 */ 10 2 /* Replaced by hc_fast_lock.incl.pl1 RSC 11/84 because name of structure 10 3* encourages name conflicts. 10 4* USE HC_FAST_LOCK INSTEAD! 10 5**/ 10 6 10 7 /* Lock format suitable for use with lock$lock_fast, unlock_fast */ 10 8 10 9 /* format: style3 */ 10 10 10 11 declare lock_ptr pointer; 10 12 declare 1 lock aligned based (lock_ptr), 10 13 2 pid bit (36) aligned, /* holder of lock */ 10 14 2 event bit (36) aligned, /* event associated with lock */ 10 15 2 flags aligned, 10 16 3 notify_sw bit (1) unaligned, 10 17 3 pad bit (35) unaligned; /* certain locks use this pad, like dirs */ 10 18 10 19 /* End include file hc_lock.incl.pl1 */ 562 563 564 end amu_hardcore_info_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 07/28/87 0924.4 amu_hardcore_info_.pl1 >spec>install>MR12.1-1049>amu_hardcore_info_.pl1 553 1 04/11/85 1452.6 access_mode_values.incl.pl1 >ldd>include>access_mode_values.incl.pl1 554 2 11/20/84 0854.8 amu_hardcore_info.incl.pl1 >ldd>include>amu_hardcore_info.incl.pl1 555 3 11/20/84 0856.1 amu_info.incl.pl1 >ldd>include>amu_info.incl.pl1 556 4 09/22/83 1102.5 amu_fdump_info.incl.pl1 >ldd>include>amu_fdump_info.incl.pl1 557 5 11/20/84 0856.2 amu_process_info.incl.pl1 >ldd>include>amu_process_info.incl.pl1 558 6 07/28/87 0927.3 amu_translation.incl.pl1 >spec>install>MR12.1-1049>amu_translation.incl.pl1 559 7 09/14/76 0759.8 sdw.incl.pl1 >ldd>include>sdw.incl.pl1 560 8 05/24/82 1005.0 slt.incl.pl1 >ldd>include>slt.incl.pl1 561 9 01/30/85 1523.9 tcm.incl.pl1 >ldd>include>tcm.incl.pl1 562 10 01/06/85 1422.1 hc_lock.incl.pl1 >ldd>include>hc_lock.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_amu_info_ptr parameter pointer dcl 49 ref 96 99 257 260 405 407 P_caller parameter char unaligned dcl 50 set ref 96 141* 166* 191* 212* 234* 243* 257 P_code parameter fixed bin(35,0) dcl 51 set ref 96 138* 140* 155* 163* 165* 180* 188* 190* 203* 209* 211* 227* 235* 244* 252* 257 381* 396* 399* 534* P_dp_dir parameter char(168) unaligned dcl 53 ref 96 100 P_ptr parameter pointer dcl 52 ref 405 408 R_ACCESS 000022 constant bit(3) initial unaligned dcl 1-11 set ref 136* 161* 186* 207* 495* addr builtin function dcl 80 ref 127 152 152 177 177 200 200 267 267 278 278 279 279 288 288 300 300 301 301 308 308 319 319 320 320 329 329 330 330 331 331 332 332 338 338 339 339 340 340 341 341 347 347 348 348 349 349 362 362 363 363 364 364 378 378 447 447 531 531 addrel builtin function dcl 80 ref 311 316 502 address_map_ptr 1 based pointer level 2 packed unaligned dcl 5-7 set ref 116* amu_$definition_ptr 000016 constant entry external dcl 60 ref 376 529 amu_$do_translation 000014 constant entry external dcl 59 ref 378 531 amu_$error_for_caller 000010 constant entry external dcl 57 ref 141 166 191 212 234 243 amu_$fdump_translate_contiguous 000024 constant entry external dcl 63 ref 267 288 330 447 amu_$fdump_translate_to_temp_seg 000012 constant entry external dcl 58 ref 338 amu_$slt_search_init_seg_ptr 000030 constant entry external dcl 65 ref 389 542 amu_$slt_search_last_sup_seg 000032 constant entry external dcl 66 ref 250 374 amu_$slt_search_seg_ptr 000026 constant entry external dcl 64 ref 387 475 525 540 amu_$translate_add 000020 constant entry external dcl 61 ref 153 178 201 225 278 300 319 331 340 348 363 507 amu_$translate_force_add 000022 constant entry external dcl 62 ref 279 301 320 332 341 349 364 amu_et_$no_def 000040 external static fixed bin(35,0) dcl 71 ref 188 amu_et_$no_dseg 000042 external static fixed bin(35,0) dcl 72 ref 209 amu_et_$no_slt 000044 external static fixed bin(35,0) dcl 73 ref 138 amu_et_$no_sltnt 000046 external static fixed bin(35,0) dcl 74 ref 163 amu_et_$trans_exists 000050 external static fixed bin(35,0) dcl 75 ref 279 301 320 332 341 349 364 amu_info based structure level 1 dcl 3-3 amu_info_ptr 000174 automatic pointer dcl 3-45 set ref 99* 102 103 104 105 106 107 108 109 110 111 112 113 115 116 116 117 117 117 118 118 119 119 120 120 121 121 122 122 124 124 141* 152 152 153* 166* 177 177 178* 191* 200 200 201* 212* 218 225* 230 232 234* 239 241 243* 248 250 260* 261 267* 271 272 275 276 278* 279* 288* 292 293 296 297 300* 301* 308 308 309 310 311 311 312 315 316 316 317 319* 320* 324 325 329 329 330* 331* 332* 338* 339 339 340* 341* 347 347 348* 349* 354 356 359 362 362 363* 364* 366 369 369 373 374 376* 378* 378 378 392 393 407* 410 410 412 414 414 416 418 418 420 422 422 424 426 426 428 430 430 432 434 434 436 447* 507* 529* 531* 531 531 546 547 548 apt 24 based structure level 2 dcl 2-6 apt_entry_size 327 based fixed bin(18,0) level 2 dcl 9-11 ref 325 apt_offset 253 based bit(18) level 3 packed unaligned dcl 9-11 ref 311 316 apt_size 313 based fixed bin(18,0) level 2 dcl 9-11 ref 324 apte 6 based structure level 2 dcl 5-7 set ref 119 120 121 122 based_sentinel based structure level 1 dcl 9-303 baseno builtin function dcl 80 ref 151 153 153 176 178 178 199 201 201 218 224 278 278 279 279 300 300 301 301 319 319 320 320 331 331 332 332 340 340 341 341 348 348 349 349 354 356 359 363 363 364 364 366 373 378 378 392 501 506 531 531 546 baseptr builtin function dcl 80 ref 148 172 265 binary builtin function dcl 80 ref 221 503 bitcount 000100 automatic fixed bin(24,0) dcl 85 set ref 136* 150 161* 175 186* 198 207* 495* bound 1(01) based bit(14) level 2 in structure "sdw" packed unaligned dcl 7-5 in procedure "amu_hardcore_info_" ref 221 503 bound 000244 automatic fixed bin(19,0) dcl 491 in procedure "get_and_set" set ref 503* 504 bound 000101 automatic fixed bin(19,0) dcl 86 in procedure "amu_hardcore_info_" set ref 221* 223 code parameter fixed bin(35,0) dcl 486 in procedure "get_and_set" set ref 483 494* 495* 507* 508 511* code 000234 automatic fixed bin(35,0) dcl 471 in procedure "exists_unpaged_page_table" set ref 474* 475* 476 code 000102 automatic fixed bin(35,0) dcl 87 in procedure "amu_hardcore_info_" set ref 136* 138 141* 146* 153* 154 155 161* 163 166* 171* 178* 179 180 186* 188 191* 201* 202 203 207* 209 212* 225* 226 227 232* 233 234* 241* 242 243* 278* 279 279* 300* 301 301* 319* 320 320* 331* 332 332* 340* 341 341* 348* 349 349* 363* 364 364* 376* 377 378* 380 381 387* 388 389* 390* 529* 530 531* 533 534 540* 541 542* 543* count 26 based fixed bin(17,0) level 3 dcl 2-6 set ref 112* 324* dbr 4 based fixed bin(71,0) level 2 dcl 5-7 set ref 117* deadproc_dir 000104 automatic char(168) unaligned dcl 88 set ref 100* 136* 141* 141* 161* 166* 166* 186* 191* 191* 207* 212* 212* 234* 234* 243* 243* 495* definitions 4 based structure level 3 dcl 2-6 set ref 200 200 329 329 defp 4 based pointer level 2 dcl 2-40 set ref 422* 424* divide builtin function dcl 80 ref 150 175 198 dp parameter pointer dcl 446 set ref 442 447* 452 dseg 12 based structure level 2 in structure "process_info" dcl 5-7 in procedure "amu_hardcore_info_" set ref 121* dseg 17 based fixed bin(15,0) level 3 in structure "hardcore_info" dcl 2-6 in procedure "amu_hardcore_info_" set ref 218* 356* dseg_ptr parameter pointer dcl 487 in procedure "get_and_set" ref 483 502 dseg_ptr 000156 automatic pointer dcl 89 in procedure "amu_hardcore_info_" set ref 219* 220 222 232* 241* dump_segx 20 based structure level 2 dcl 5-7 early_dump 2 based bit(1) level 3 packed unaligned dcl 3-3 set ref 393* 547* 548 ecode 000103 automatic fixed bin(35,0) dcl 87 set ref 266* 267* 268 287* 288* 289 330* 338* 399 447* 525* 528 error_table_$action_not_performed 000052 external static fixed bin(35,0) dcl 76 ref 140 165 190 211 235 244 first 20 based fixed bin(17,0) level 3 dcl 5-7 set ref 124* fixed builtin function dcl 80 ref 151 153 153 176 178 178 199 201 201 218 224 278 278 279 279 300 300 301 301 311 316 319 319 320 320 331 331 332 332 340 340 341 341 348 348 349 349 354 356 359 363 363 364 364 366 373 378 378 378 378 392 501 506 531 531 531 531 546 flags 0(18) based structure level 2 in structure "translation" packed unaligned dcl 6-24 in procedure "amu_hardcore_info_" set ref 128* flags 0(18) 000160 automatic structure level 2 in structure "temp_translation" packed unaligned dcl 90 in procedure "amu_hardcore_info_" flags 2 based structure level 2 in structure "amu_info" dcl 3-3 in procedure "amu_hardcore_info_" foreign_ptr 6 based pointer level 3 in structure "process_info" packed unaligned dcl 5-7 in procedure "amu_hardcore_info_" set ref 118* foreign_ptr 24 based pointer level 3 in structure "hardcore_info" packed unaligned dcl 2-6 in procedure "amu_hardcore_info_" set ref 110* 311* 317* fp_table based structure level 1 unaligned dcl 4-28 fptr 6 based pointer level 4 in structure "hardcore_info" packed unaligned dcl 2-6 in procedure "amu_hardcore_info_" set ref 102* 428 fptr based pointer level 2 in structure "hard_ptr_data" packed unaligned dcl 444 in procedure "fill_ptrs" set ref 457* 462* fptr 14 based pointer level 4 in structure "hardcore_info" packed unaligned dcl 2-6 in procedure "amu_hardcore_info_" set ref 108* 369* 412 fptr 4 based pointer level 4 in structure "hardcore_info" packed unaligned dcl 2-6 in procedure "amu_hardcore_info_" set ref 424 fptr 2 based pointer level 4 in structure "hardcore_info" packed unaligned dcl 2-6 in procedure "amu_hardcore_info_" set ref 292* 297* 420 fptr 10 based pointer level 4 in structure "hardcore_info" packed unaligned dcl 2-6 in procedure "amu_hardcore_info_" set ref 106* 309 310 311 432 fptr 12 based pointer level 4 in structure "hardcore_info" packed unaligned dcl 2-6 in procedure "amu_hardcore_info_" set ref 104* 436 fptr based pointer level 4 in structure "hardcore_info" packed unaligned dcl 2-6 in procedure "amu_hardcore_info_" set ref 271* 276* 416 hard_ptr_data based structure level 1 packed unaligned dcl 444 hardcore_cur based structure level 1 unaligned dcl 2-40 hardcore_cur_ptr 000172 automatic pointer dcl 2-38 set ref 408* 410 412 414 416 418 420 422 424 426 428 430 432 434 436 hardcore_info based structure level 1 dcl 2-6 hardcore_info_ptr 16 based pointer level 2 dcl 3-3 ref 102 103 104 105 106 107 108 109 110 111 112 113 152 152 177 177 200 200 218 232 241 250 271 272 275 276 292 293 296 297 308 308 309 310 311 311 312 315 316 316 317 324 325 329 329 339 339 347 347 354 356 359 362 362 366 369 369 373 374 378 378 392 410 410 412 414 414 416 418 418 420 422 422 424 426 426 428 430 430 432 434 434 436 531 531 546 hardcore_num parameter fixed bin(15,0) dcl 489 set ref 483 501* 502 hcs_count 30 based fixed bin(17,0) level 2 dcl 2-6 set ref 250* 374* hpdp parameter pointer dcl 445 ref 442 452 457 458 461 462 idx 2 based fixed bin(17,0) level 2 dcl 5-7 set ref 117* in_dp_dir 0(22) based bit(1) level 3 packed unaligned dcl 6-24 set ref 130* in_dump 0(19) 000160 automatic bit(1) level 3 packed unaligned dcl 90 set ref 270 291 455 in_perm_seg 0(21) based bit(1) level 3 packed unaligned dcl 6-24 set ref 129* initiate_file_ 000034 constant entry external dcl 67 ref 136 161 186 207 495 kst 21 based fixed bin(15,0) level 3 in structure "hardcore_info" dcl 2-6 in procedure "amu_hardcore_info_" set ref 241* 373* kst 16 based structure level 2 in structure "process_info" dcl 5-7 in procedure "amu_hardcore_info_" set ref 122* last 21 based fixed bin(17,0) level 3 dcl 5-7 set ref 124* local_ptr 25 based pointer level 3 in structure "hardcore_info" packed unaligned dcl 2-6 in procedure "amu_hardcore_info_" set ref 111* 312* 316* local_ptr 13 based pointer level 3 in structure "process_info" packed unaligned dcl 5-7 in procedure "amu_hardcore_info_" set ref 230* local_ptr 15 based pointer level 3 in structure "process_info" packed unaligned dcl 5-7 in procedure "amu_hardcore_info_" set ref 239* local_ptr 7 based pointer level 3 in structure "process_info" packed unaligned dcl 5-7 in procedure "amu_hardcore_info_" set ref 118* local_ptr 17 based pointer level 3 in structure "process_info" packed unaligned dcl 5-7 in procedure "amu_hardcore_info_" set ref 248* lock based structure level 1 dcl 10-12 lptr 3 based pointer level 4 in structure "hardcore_info" packed unaligned dcl 2-6 in procedure "amu_hardcore_info_" set ref 293* 296* 418 418 lptr 7 based pointer level 4 in structure "hardcore_info" packed unaligned dcl 2-6 in procedure "amu_hardcore_info_" set ref 103* 426 426 lptr 13 based pointer level 4 in structure "hardcore_info" packed unaligned dcl 2-6 in procedure "amu_hardcore_info_" set ref 105* 434 434 lptr 1 based pointer level 2 in structure "hard_ptr_data" packed unaligned dcl 444 in procedure "fill_ptrs" set ref 458* 461* lptr 1 based pointer level 4 in structure "hardcore_info" packed unaligned dcl 2-6 in procedure "amu_hardcore_info_" set ref 272* 275* 414 414 lptr 15 based pointer level 4 in structure "hardcore_info" packed unaligned dcl 2-6 in procedure "amu_hardcore_info_" set ref 109* 369* 410 410 lptr 11 based pointer level 4 in structure "hardcore_info" packed unaligned dcl 2-6 in procedure "amu_hardcore_info_" set ref 107* 315 316 430 430 lptr 5 based pointer level 4 in structure "hardcore_info" packed unaligned dcl 2-6 in procedure "amu_hardcore_info_" set ref 422 422 lth 4 based fixed bin(19,0) level 3 in structure "translation" dcl 6-24 in procedure "amu_hardcore_info_" set ref 132* lth 2 based fixed bin(19,0) level 3 in structure "translation" dcl 6-24 in procedure "amu_hardcore_info_" set ref 150* 175* 198* 223* 504* name_seg_ptr based pointer level 2 dcl 8-13 ref 286 305 names_ptr 000204 automatic pointer dcl 8-7 set ref 173* 290* 387* 389* 475* 525* 540* 542* null builtin function dcl 80 ref 102 103 104 105 106 107 108 109 110 111 118 131 137 162 187 208 272 276 293 297 309 312 317 369 410 414 418 422 426 430 434 458 462 473 496 522 part1 1 000160 automatic structure level 2 in structure "temp_translation" unaligned dcl 90 in procedure "amu_hardcore_info_" part1 1 based structure level 2 in structure "translation" dcl 6-24 in procedure "amu_hardcore_info_" part1 347 based structure array level 3 in structure "translation_table" dcl 6-13 in procedure "amu_hardcore_info_" part2 3 based structure level 2 dcl 6-24 pathname_ 000036 constant entry external dcl 68 ref 141 141 166 166 191 191 212 212 234 234 243 243 pds 20 based fixed bin(15,0) level 3 in structure "hardcore_info" dcl 2-6 in procedure "amu_hardcore_info_" set ref 232* 359* pds 14 based structure level 2 in structure "process_info" dcl 5-7 in procedure "amu_hardcore_info_" set ref 120* pid based bit(36) level 2 dcl 5-7 set ref 115* pointers based structure level 2 dcl 2-6 prds 10 based structure level 2 in structure "process_info" dcl 5-7 in procedure "amu_hardcore_info_" set ref 119* prds 16 based fixed bin(15,0) level 3 in structure "hardcore_info" dcl 2-6 in procedure "amu_hardcore_info_" set ref 354* process_idx 24 based fixed bin(17,0) level 2 dcl 3-3 set ref 261* process_info based structure level 1 dcl 5-7 process_info_ptr 22 based pointer level 2 dcl 3-3 ref 115 116 117 117 117 118 118 119 119 120 120 121 121 122 122 124 124 230 239 248 ptr 1 based pointer level 3 in structure "translation" packed unaligned dcl 6-24 in procedure "amu_hardcore_info_" set ref 149* 174* 197* 222* 230 239 248 505* ptr 3 based pointer level 3 in structure "translation" packed unaligned dcl 6-24 in procedure "amu_hardcore_info_" set ref 131* ptr 1 000160 automatic pointer level 3 in structure "temp_translation" packed unaligned dcl 90 in procedure "amu_hardcore_info_" set ref 269 271 275 290 292 296 457 461 rel builtin function dcl 80 ref 378 378 531 531 sdw based structure level 1 dcl 7-5 sdwp 000200 automatic pointer dcl 7-3 in procedure "amu_hardcore_info_" set ref 220* 221 sdwp 000246 automatic pointer dcl 492 in procedure "get_and_set" set ref 502* 503 seg_ptr 000266 automatic pointer dcl 521 set ref 529* 531 531 531 531 540* 542* segment_name parameter char unaligned dcl 520 ref 516 523 segment_ptr parameter pointer dcl 470 in procedure "exists_unpaged_page_table" set ref 468 473* 475* segment_ptr 000166 automatic pointer dcl 91 in procedure "amu_hardcore_info_" set ref 148* 151 152* 153 153 172* 176 177* 178 178 196* 199 200* 201 201 217* 218 224 265* 267* 278 278 279 279 286* 288* 300 300 301 301 305* 307* 308* 319 319 320 320 328* 329* 330* 331 331 332 332 337* 338* 339* 340 340 341 341 346* 347* 348 348 349 349 353* 354 355* 356 358* 359 361* 362* 363 363 364 364 366 372* 373 376* 378 378 378 378 387* 389* 392 500* 501 506 546 segno 16 based structure level 2 in structure "hardcore_info" dcl 2-6 in procedure "amu_hardcore_info_" segno based fixed bin(18,0) level 2 in structure "translation" packed unsigned unaligned dcl 6-24 in procedure "amu_hardcore_info_" set ref 151* 176* 199* 224* 225 506* 507 size 27 based fixed bin(17,0) level 3 dcl 2-6 set ref 113* 325* slt based structure level 3 in structure "hardcore_info" dcl 2-6 in procedure "amu_hardcore_info_" set ref 152 152 slt based structure level 1 dcl 8-13 in procedure "amu_hardcore_info_" sltnt 2 based structure level 3 dcl 2-6 set ref 177 177 sltntp 2 based pointer level 2 dcl 2-40 set ref 418* 420* sltp based pointer level 2 in structure "hardcore_cur" dcl 2-40 in procedure "amu_hardcore_info_" set ref 414* 416* sltp 000202 automatic pointer dcl 8-7 in procedure "amu_hardcore_info_" set ref 147* 250* 269* 286 305 374* 387* 389* 475* 525* 540* 542* special_offsets 253 based structure level 2 packed unaligned dcl 9-11 sst 6 based structure level 3 dcl 2-6 set ref 339 339 sstnt 12 based structure level 3 dcl 2-6 set ref 347 347 sstntp 12 based pointer level 2 dcl 2-40 set ref 434* 436* sstp 6 based pointer level 2 dcl 2-40 set ref 426* 428* stack_0 22 based fixed bin(15,0) level 3 dcl 2-6 set ref 378 378 392* 531 531 546* state 3 based fixed bin(17,0) level 2 dcl 5-7 set ref 117* tc_data 10 based structure level 3 dcl 2-6 set ref 308 308 tc_datap 10 based pointer level 2 dcl 2-40 set ref 430* 432* tcm based structure level 1 dcl 9-11 tcmp 000206 automatic pointer dcl 9-9 set ref 310* 311 315* 316 324 325 temp_name parameter char(32) unaligned dcl 488 set ref 483 495* 499 499* 500* temp_ptr 000170 automatic pointer dcl 92 in procedure "amu_hardcore_info_" set ref 136* 137 147 149 161* 162 173 174 186* 187 197 207* 208 219 495* 496 505 temp_ptr parameter pointer dcl 519 in procedure "get_ptr_from_slt" set ref 516 522* 525* temp_translation 000160 automatic structure level 1 unaligned dcl 90 set ref 127 267 267 278 278 279 279 288 288 300 300 301 301 319 319 320 320 330 330 331 331 332 332 338 338 340 340 341 341 348 348 349 349 363 363 364 364 447 447 test_name 000256 automatic char(32) unaligned dcl 518 set ref 523* 525* translation based structure level 1 dcl 6-24 translation_ptr 000176 automatic pointer dcl 6-40 set ref 127* 128 129 130 131 132 149 150 151 153* 174 175 176 178* 197 198 199 201* 222 223 224 225* 225 230 239 248 504 505 506 507* 507 translation_table_ptr 12 based pointer level 2 dcl 3-3 ref 116 unpaged_page_tables 23 based fixed bin(15,0) level 3 dcl 2-6 set ref 366* upt 14 based structure level 3 dcl 2-6 set ref 362 362 uptp 14 based pointer level 2 dcl 2-40 set ref 410* 412* wct_entry based structure level 1 dcl 9-260 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. AMU_FDUMP_INFO_VERSION internal static char(8) initial unaligned dcl 4-43 AMU_FDUMP_INFO_VERSION_1 internal static char(8) initial unaligned dcl 4-42 AMU_INFO_VERSION internal static char(8) initial unaligned dcl 3-57 AMU_INFO_VERSION_1 internal static char(8) initial unaligned dcl 3-56 AMU_INFO_VERSION_2 internal static char(8) initial unaligned dcl 3-58 A_ACCESS internal static bit(3) initial unaligned dcl 1-11 A_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 DIR_ACCESS_MODE_NAMES internal static char(4) initial array unaligned dcl 1-33 E_ACCESS internal static bit(3) initial unaligned dcl 1-11 E_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 FDUMP_PROCESS_TYPE internal static fixed bin(17,0) initial dcl 3-47 FDUMP_TYPE internal static fixed bin(17,0) initial dcl 3-47 INDIRECT_TYPE internal static fixed bin(17,0) initial dcl 3-47 M_ACCESS internal static bit(3) initial unaligned dcl 1-11 M_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 NETWORK_FDUMP_TYPE internal static fixed bin(17,0) initial dcl 3-47 NETWORK_ONLINE_TYPE internal static fixed bin(17,0) initial dcl 3-47 N_ACCESS internal static bit(3) initial unaligned dcl 1-11 N_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 ONLINE_PROCESS_TYPE internal static fixed bin(17,0) initial dcl 3-47 ONLINE_TYPE internal static fixed bin(17,0) initial dcl 3-47 PDIR_SUFFIX internal static char(4) initial unaligned dcl 3-60 REW_ACCESS internal static bit(3) initial unaligned dcl 1-11 REW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 RE_ACCESS internal static bit(3) initial unaligned dcl 1-11 RE_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 RW_ACCESS internal static bit(3) initial unaligned dcl 1-11 RW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 R_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SAVED_PROC_TYPE internal static fixed bin(17,0) initial dcl 3-47 SA_ACCESS internal static bit(3) initial unaligned dcl 1-11 SA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SEG_ACCESS_MODE_NAMES internal static char(4) initial array unaligned dcl 1-30 SMA_ACCESS internal static bit(3) initial unaligned dcl 1-11 SMA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SM_ACCESS internal static bit(3) initial unaligned dcl 1-11 SM_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 S_ACCESS internal static bit(3) initial unaligned dcl 1-11 S_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 VCPU_RESPONSE_BOUNDS internal static fixed bin(17,0) initial dcl 9-308 W_ACCESS internal static bit(3) initial unaligned dcl 1-11 W_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 aclp automatic pointer dcl 8-7 acls based structure level 1 dcl 8-45 alloc_fdump_process_table_size automatic fixed bin(17,0) dcl 4-40 alloc_translation_table_max_entries automatic fixed bin(17,0) dcl 6-39 amu_area based area(1024) dcl 3-43 fdump_info based structure level 1 dcl 4-3 fdump_process_table based structure level 1 dcl 4-23 fp_table_ptr automatic pointer dcl 4-38 lock_ptr automatic pointer dcl 10-11 name_seg based structure level 1 dcl 8-26 namep automatic pointer dcl 8-7 path based structure level 1 dcl 8-40 pathp automatic pointer dcl 8-7 sdwa based structure array level 1 dcl 7-24 segnam based structure level 1 dcl 8-31 translation_table based structure level 1 dcl 6-13 wctep automatic pointer dcl 9-258 NAMES DECLARED BY EXPLICIT CONTEXT. amu_hardcore_info_ 000102 constant entry external dcl 18 amu_hardcore_info_$deadproc 000115 constant entry external dcl 96 amu_hardcore_info_$fdump 001570 constant entry external dcl 257 amu_hardcore_info_$set_cur_ptrs 003063 constant entry external dcl 405 error_ret 003054 constant label dcl 399 ref 268 289 548 exists_unpaged_page_table 003311 constant entry internal dcl 468 ref 361 fill_ptrs 003223 constant entry internal dcl 442 ref 308 329 347 362 fill_ptrs_common 003250 constant label dcl 455 ref 448 fill_ptrs_no_trans 003246 constant entry internal dcl 452 ref 152 177 200 339 get_and_set 003357 constant entry internal dcl 483 ref 232 241 get_ptr_from_slt 003531 constant entry internal dcl 516 ref 196 217 307 328 337 346 353 355 358 372 500 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 4434 4510 4110 4444 Length 5162 4110 54 436 324 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME amu_hardcore_info_ 403 external procedure is an external procedure. fill_ptrs internal procedure shares stack frame of external procedure amu_hardcore_info_. exists_unpaged_page_table internal procedure shares stack frame of external procedure amu_hardcore_info_. get_and_set internal procedure shares stack frame of external procedure amu_hardcore_info_. get_ptr_from_slt internal procedure shares stack frame of external procedure amu_hardcore_info_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME amu_hardcore_info_ 000100 bitcount amu_hardcore_info_ 000101 bound amu_hardcore_info_ 000102 code amu_hardcore_info_ 000103 ecode amu_hardcore_info_ 000104 deadproc_dir amu_hardcore_info_ 000156 dseg_ptr amu_hardcore_info_ 000160 temp_translation amu_hardcore_info_ 000166 segment_ptr amu_hardcore_info_ 000170 temp_ptr amu_hardcore_info_ 000172 hardcore_cur_ptr amu_hardcore_info_ 000174 amu_info_ptr amu_hardcore_info_ 000176 translation_ptr amu_hardcore_info_ 000200 sdwp amu_hardcore_info_ 000202 sltp amu_hardcore_info_ 000204 names_ptr amu_hardcore_info_ 000206 tcmp amu_hardcore_info_ 000234 code exists_unpaged_page_table 000244 bound get_and_set 000246 sdwp get_and_set 000256 test_name get_ptr_from_slt 000266 seg_ptr get_ptr_from_slt THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out return_mac ext_entry ext_entry_desc THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. amu_$definition_ptr amu_$do_translation amu_$error_for_caller amu_$fdump_translate_contiguous amu_$fdump_translate_to_temp_seg amu_$slt_search_init_seg_ptr amu_$slt_search_last_sup_seg amu_$slt_search_seg_ptr amu_$translate_add amu_$translate_force_add initiate_file_ pathname_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. amu_et_$no_def amu_et_$no_dseg amu_et_$no_slt amu_et_$no_sltnt amu_et_$trans_exists error_table_$action_not_performed LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 18 000101 19 000107 96 000110 99 000134 100 000137 102 000144 103 000147 104 000150 105 000151 106 000152 107 000153 108 000154 109 000155 110 000156 111 000157 112 000160 113 000161 115 000162 116 000163 117 000166 118 000173 119 000176 120 000201 121 000204 122 000207 124 000212 127 000214 128 000216 129 000234 130 000236 131 000240 132 000242 136 000243 137 000302 138 000306 140 000314 141 000317 144 000375 146 000376 147 000377 148 000401 149 000405 150 000407 151 000412 152 000417 153 000424 154 000445 155 000447 156 000450 161 000451 162 000513 163 000517 165 000525 166 000530 169 000611 171 000612 172 000613 173 000617 174 000621 175 000623 176 000626 177 000633 178 000641 179 000662 180 000664 181 000665 186 000666 187 000727 188 000733 190 000741 191 000744 194 001024 196 001025 197 001034 198 001037 199 001042 200 001047 201 001055 202 001076 203 001100 204 001101 207 001102 208 001141 209 001145 211 001153 212 001156 215 001234 217 001235 218 001242 219 001251 220 001253 221 001255 222 001264 223 001266 224 001267 225 001273 226 001313 227 001315 228 001316 230 001317 232 001324 233 001344 234 001346 235 001425 236 001430 239 001431 241 001436 242 001456 243 001460 244 001537 245 001542 248 001543 250 001550 252 001562 253 001563 257 001564 260 001607 261 001612 265 001613 266 001617 267 001620 268 001637 269 001641 270 001643 271 001650 272 001653 273 001656 275 001657 276 001663 278 001665 279 001711 286 001735 287 001740 288 001741 289 001760 290 001762 291 001764 292 001771 293 001775 294 001777 296 002000 297 002004 300 002006 301 002032 305 002056 307 002061 308 002066 309 002074 310 002101 311 002103 312 002111 313 002113 315 002114 316 002116 317 002124 318 002126 319 002130 320 002154 324 002200 325 002205 328 002207 329 002216 330 002224 331 002243 332 002267 337 002313 338 002320 339 002337 340 002345 341 002371 346 002415 347 002425 348 002433 349 002457 353 002503 354 002510 355 002516 356 002523 358 002531 359 002536 361 002544 362 002551 363 002557 364 002604 366 002630 367 002635 369 002636 372 002643 373 002650 374 002656 376 002667 377 002726 378 002730 380 002766 381 002770 382 002771 384 002772 387 002773 388 003015 389 003017 390 003041 392 003042 393 003050 396 003052 397 003053 399 003054 401 003056 405 003057 407 003073 408 003076 410 003102 412 003112 414 003115 416 003125 418 003127 420 003137 422 003142 424 003153 426 003156 428 003167 430 003172 432 003203 434 003206 436 003217 438 003222 442 003223 447 003225 448 003245 452 003246 455 003250 457 003255 458 003265 459 003272 461 003273 462 003303 464 003310 468 003311 473 003313 474 003315 475 003316 476 003341 477 003351 483 003357 494 003361 495 003362 496 003420 497 003424 499 003425 500 003436 501 003452 502 003460 503 003465 504 003473 505 003475 506 003477 507 003503 508 003523 509 003526 511 003527 512 003530 516 003531 522 003542 523 003545 525 003552 528 003571 529 003573 530 003632 531 003634 533 003672 534 003674 535 003675 537 003676 540 003677 541 003721 542 003723 543 003745 546 003746 547 003754 548 003756 552 003761 ----------------------------------------------------------- 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