COMPILATION LISTING OF SEGMENT amu_fdump_mpt_ 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.5 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-17,Fawcett), install(87-07-28,MR12.1-1049): 13* Eliminate garbage in displaying process states. 14* END HISTORY COMMENTS */ 15 16 17 amu_fdump_mpt_: proc (P_amu_info_ptr, P_caller, P_code); 18 19 /* format: style4,delnl,insnl,ifthenstmt,indnoniterend,ifthendo,ifthen,^thendo */ 20 21 /* This procedure allocates and fills in the process_table for an 22* FDUMP. It is heavily dependent on the silly way that BOS (BCE) constructs 23* FDUMP images. The name stands for "Make (Manage) Process Table" 24* 09/06/80 W. Olin Sibert 25* 26* Changed by RAF SEPT 81 27* Modified by B. Braun 06/29/83 to add brief_sw parameter to amu_$fdump_mpt_fill_proc_table. 28* 29* This proc has 5 entries 30* dcl amu_fdump_mpt_ entry (ptr); 31* call amu_fdump_mpt_ (amu_info_ptr) 32* where 33* amu_info_ptr is the pointer to the main info for this erf. 34* 35* 36* This entry point will create the fdump_process_table and init the process_info 37* for each process in the fdump. 38* 39* dcl amu_$fdump_mpt_current_process entry (ptr); 40* call amu_$fdump_mpt_current_process (amu_info_ptr); 41* where 42* amu_info_ptr is the main info pointer for this erf. 43* 44* 45* This entry only prints the FDUMP process index and the dbr of the 46* current process 47* 48* 49* dcl amu_$fdump_mpt_temp_change_idx entry (ptr,fixed bin); 50* call amu_$fdump_mpt_temp_change_idx (amu_info_ptr,new_index); 51* where 52* amu_info_pointer is a pointer to the maun info. 53* new_index is the value of the index into fdump_process_table.array 54* of the new process. 55* This entry will change the amu_info data to reflect the new process. It is 56* intended to be only a temp change the old index is stored in 57* amu_info.proc_idx_hold to be used by amu_$fdump_mpt_revert_idx. 58* 59* dcl amu_$fdump_mpt_revert_idx entry (ptr); 60* call amu_$fdump_mpt_revert_idx (amu_info_ptr); 61* where 62* amu_info_ptr is the same as above. 63* 64* This entry point will revert the amu_info data to the process indicated by 65* amu_info.proc_idx_hold. This should have been set by the temp_change_idx entry. 66* 67* 68**/ 69 dcl com_err_ entry () options (variable); 70 dcl ioa_ entry () options (variable); 71 dcl ioa_$rsnnl entry() options(variable); 72 dcl P_amu_info_ptr pointer parameter; 73 dcl P_idx fixed bin; 74 dcl P_dbr fixed bin (24); 75 dcl P_cpu char (1); 76 dcl P_caller char(*); 77 dcl P_code fixed bin (35); 78 dcl brief_sw bit(1); 79 dcl t_ptr ptr; 80 dcl temp_ptr ptr; 81 dcl t_segno fixed bin; 82 dcl based_char char (32) based (t_ptr); 83 dcl af_str char (af_len) var based (af_ptr); 84 dcl ignore fixed bin (21); 85 dcl af_sw bit(1); 86 dcl index_changed bit (1) init ("0"b); 87 dcl range fixed bin (18); 88 dcl data_buf_ptr ptr; 89 dcl t_data (8) fixed bin (35); 90 dcl t_offset fixed bin (18); 91 dcl pid char(36) var; 92 dcl code fixed bin (35); 93 dcl prev_segno fixed bin; 94 dcl af_ptr ptr; 95 dcl af_len fixed bin(21); 96 dcl segx fixed bin; 97 dcl process_idx fixed bin; 98 dcl n_processes fixed bin; 99 dcl segment_ptr ptr; 100 dcl based_dbr bit (24) based; 101 dcl total_offset fixed bin (71); 102 dcl search_dbr fixed bin (24); 103 dcl cpu_name char (1); 104 dcl cpu_no fixed bin (3) based; 105 dcl cpu_tag_offset fixed bin (18); 106 dcl tag (0:7) char (1) int static options (constant) init ("a", "b", "c", "d", "e", "f", "g", "h"); 107 dcl 1 temp_translation like translation; 108 dcl version_id char (8) based (data_buf_ptr); 109 dcl system_id char (8) based (data_buf_ptr); 110 111 112 dcl RUNNING fixed bin init (1) static options (constant); 113 114 dcl amu_$do_translation entry (ptr, fixed bin, ptr, fixed bin (18), fixed bin (18), fixed bin (35)); 115 dcl amu_$definition_offset entry (ptr, char (*), char (*), fixed bin (35)) returns (fixed bin (18)); 116 dcl amu_$definition_ptr entry (ptr, char(*), char(*), fixed bin(35)) returns(ptr); 117 dcl amu_$hardcore_info_fdump entry (ptr, char(*), fixed bin (35)); 118 dcl amu_$return_val_per_process entry (ptr, fixed bin) returns(bit(1)); 119 dcl amu_$translate_allocate entry (ptr, fixed bin (17)); 120 dcl amu_$tc_data_find_apte entry (ptr, fixed bin (24), ptr, fixed bin (35)); 121 dcl amu_$fdump_mpt_revert_idx entry (ptr); 122 dcl amu_$fdump_mpt_temp_change_idx entry (ptr, fixed bin); 123 dcl amu_$fdump_translate_contiguous entry (ptr, ptr, ptr, fixed bin (35)); 124 dcl amu_$tc_data_find_first_running entry (ptr, fixed bin (24), fixed bin (35)); 125 dcl amu_$translate_add entry (ptr, ptr, fixed bin, fixed bin (35)); 126 dcl amu_$translate_force_add entry (ptr, ptr, fixed bin, fixed bin (35)); 127 dcl amu_$return_val_idx_from_dbr entry (ptr, fixed bin (24)) returns (fixed bin); 128 dcl get_temp_segment_ entry (char(*), ptr, fixed bin(35)); 129 dcl release_temp_segment_ entry (char(*), ptr, fixed bin(35)); 130 dcl (amu_et_$apte_not_found, 131 amu_et_$not_fdump, 132 amu_et_$trans_exists, 133 amu_et_$big_idx 134 ) fixed bin (35) ext; 135 136 dcl (addr, addrel, baseptr, divide, 137 fixed, null, binary, size, hbound, 138 index, mod, pointer, lbound, baseno, rel) builtin; 139 140 dcl cleanup condition; 141 142 code = 0; 143 amu_info_ptr = P_amu_info_ptr; 144 fdump_info.fdump_process_table_ptr = null (); 145 dumpptr = fdump_info.dump_seg_ptr (0); 146 data_buf_ptr = null(); 147 on condition(cleanup) begin; 148 if data_buf_ptr ^= null() then call release_temp_segment_ ("amu_fdump_mpt_", data_buf_ptr, (0)); 149 end; 150 prev_segno = -1; /* count the number of apparently separate process's in the */ 151 n_processes = 0; /* FDUMP, by looping through the array of segnos and counting */ 152 do segx = 1 to dump.num_segs; /* each decrease in segnos as a separate process, on the */ 153 if binary (dump.segno (segx), 18) < prev_segno then 154 /* grounds that all the segments in a process will */ 155 n_processes = n_processes + 1; /* have been stored in monotonically increasing order. */ 156 prev_segno = binary (dump.segno (segx)); 157 end; /* After the loop is run through, add one to the process */ 158 n_processes = n_processes + 1; /* count, since the end of last process isn't detected above */ 159 160 alloc_fdump_process_table_size = n_processes; 161 162 allocate fdump_process_table in (amu_area) set (fdump_info.fdump_process_table_ptr); 163 164 fdump_process_table.size = n_processes - 1; 165 fdump_process_table.array.process_info_ptr (*) = null (); 166 fdump_process_table.array.cpu_name (*) = ""; 167 fdump_process_table.array.dbr (*) = 0; 168 fdump_process_table.array.apte_offset (*) = 0; 169 170 process_idx = 0; /* Now, loop through the array again, finding the bounds of */ 171 prev_segno = -1; /* the dumped address space in each process. */ 172 fdump_process_table (process_idx).first_seg = 1; /* first process starts with seg #1, of course */ 173 174 total_offset = size (dump); /* set to the first segment in dump */ 175 176 /* find where this seg starts this should be seg 0 of the process 177* The first word of dseg should be the sdw for seg 0 hence the SDW.ADDR 178* is the dbr add value 179**/ 180 181 fp_table_ptr = addr (fdump_process_table.array (process_idx)); 182 fp_table.dmp_seg_indx = divide (total_offset, fdump_info.dump_seg_lth (0), 17, 0); 183 fp_table.dmp_seg_offset = mod (total_offset, fdump_info.dump_seg_lth (0)); 184 fp_table.dbr = 185 fixed (pointer (fdump_info.dump_seg_ptr (fp_table.dmp_seg_indx), fp_table.dmp_seg_offset) -> based_dbr, 24); 186 187 do segx = 1 to dump.num_segs; 188 if binary (dump.segno (segx), 18) < prev_segno then do; 189 /* we've just switched processes */ 190 fp_table.last_seg = segx - 1; /* last segment was previous iteration */ 191 process_idx = process_idx + 1; /* get the new first segment number and increment the index */ 192 fp_table_ptr = addr (fdump_process_table.array (process_idx)); 193 fp_table.first_seg = segx; /* get the dbr, we have the chance */ 194 fp_table.dmp_seg_indx = divide (total_offset, fdump_info.dump_seg_lth (0), 17, 0); 195 if (fp_table.dmp_seg_indx = fdump_info.n_dump_segs) | 196 fdump_info.dump_seg_ptr (fp_table.dmp_seg_indx) = null then do; 197 /* Problems */ 198 199 call com_err_ (0, "amu_fdump_mpt_", "Cannot complete process ^d, no more dump segs.", 200 process_idx); 201 fdump_process_table.size = process_idx - 1; 202 process_idx = process_idx - 1; 203 fp_table.dmp_seg_indx = fp_table.dmp_seg_indx -1; 204 fp_table.last_seg = segx - 1; 205 goto no_more_segs; 206 end; 207 fp_table.dmp_seg_offset = mod (total_offset, fdump_info.dump_seg_lth (0)); 208 fp_table.dbr = 209 fixed (pointer (fdump_info.dump_seg_ptr (fp_table.dmp_seg_indx), fp_table.dmp_seg_offset) 210 -> based_dbr, 24); 211 end; 212 total_offset = fixed (binary (dump.segs (segx).length, 18) * 64, 71, 0) + total_offset; 213 prev_segno = binary (dump.segno (segx), 18); 214 end; 215 fp_table.last_seg = dump.num_segs; /* and last seg of last process is last seg in dump */ 216 no_more_segs: 217 process_idx = 0; 218 amu_info.process_idx = process_idx; 219 fp_table_ptr = addr (fdump_process_table.array (process_idx)); 220 call init_process_table; 221 222 fp_table.process_info_ptr = amu_info.process_info_ptr; 223 224 call amu_$translate_allocate (amu_info_ptr, 10); /* default to 10 segs */ 225 process_info.address_map_ptr = amu_info.translation_table_ptr; 226 /* now we have a place to keep the translations for */ 227 /* the interesting hardcore segs */ 228 call amu_$hardcore_info_fdump (amu_info_ptr, P_caller, code); 229 if code ^= 0 then do; /* msg already printed */ 230 P_code = code; 231 return; 232 end; 233 234 cpu_tag_offset = amu_$definition_offset (amu_info_ptr, "prds", "processor_tag", code); 235 if code ^= 0 then return; 236 237 amu_info.type = FDUMP_PROCESS_TYPE; 238 239 do process_idx = 0 by 1 to fdump_process_table.size; 240 amu_info.process_idx = process_idx; 241 fp_table_ptr = addr (fdump_process_table.array (process_idx)); 242 call create_proc_table(); 243 244 if process_info.prds.foreign_ptr ^= null () then 245 fp_table.cpu_name = tag (addrel (process_info.prds.foreign_ptr, cpu_tag_offset) -> cpu_no); 246 else if process_info.prds.local_ptr ^= null () then 247 fp_table.cpu_name = tag (addrel (process_info.prds.local_ptr, cpu_tag_offset) -> cpu_no); 248 else fp_table.cpu_name = ""; 249 end; 250 251 /* now fine the dbr of the first running process to use as default */ 252 call amu_$tc_data_find_first_running (amu_info_ptr, search_dbr, code); 253 if code ^= 0 then 254 process_idx = 0; 255 else do; 256 process_idx = amu_$return_val_idx_from_dbr (amu_info_ptr, search_dbr); 257 if process_idx = -1 then process_idx = 0; 258 end; 259 260 call set_for_proc (process_idx); /* set the default to proc index one for now */ 261 262 call get_temp_segment_ ("amu_fdump_mpt_", data_buf_ptr, code); 263 if code ^= 0 then return; 264 265 range = 2; 266 temp_ptr = amu_$definition_ptr (amu_info_ptr, "active_all_rings_data", 267 "version_id", code); 268 if code ^= 0 then go to RET; 269 call get_data_ (data_buf_ptr, fixed (baseno (temp_ptr), 17), fixed (rel (temp_ptr), 18), range); 270 271 fdump_info.version_id = version_id; 272 273 temp_ptr = amu_$definition_ptr (amu_info_ptr, "active_all_rings_data", 274 "system_id", code); 275 if code ^= 0 then go to RET; 276 call get_data_ (data_buf_ptr, fixed (baseno (temp_ptr), 17), fixed (rel (temp_ptr), 18), range); 277 fdump_info.system_id = system_id; 278 279 RET: 280 if data_buf_ptr ^= null() then call release_temp_segment_ ("amu_fdump_mpt_", data_buf_ptr, code); 281 return; 282 283 amu_fdump_mpt_$current_process: 284 entry (P_amu_info_ptr); 285 amu_info_ptr = P_amu_info_ptr; 286 af_sw = "0"b; 287 call what_process; 288 return; 289 290 amu_fdump_mpt_$current_process_af: 291 entry (P_amu_info_ptr, af_ptr, af_len); 292 amu_info_ptr = P_amu_info_ptr; 293 af_sw = "1"b; 294 call what_process; 295 return; 296 297 amu_fdump_mpt_$temp_change_idx: 298 entry (P_amu_info_ptr, P_idx); 299 amu_info_ptr = P_amu_info_ptr; 300 if amu_info.type = SAVED_PROC_TYPE then return; 301 amu_info.proc_idx_hold = amu_info.process_idx; 302 call set_for_proc (P_idx); 303 return; 304 305 amu_fdump_mpt_$change_idx: 306 entry (P_amu_info_ptr, P_idx); 307 amu_info_ptr = P_amu_info_ptr; 308 if amu_info.type = SAVED_PROC_TYPE then return; 309 call set_for_proc (P_idx); 310 return; 311 312 313 amu_fdump_mpt_$revert_idx: 314 entry (P_amu_info_ptr); 315 amu_info_ptr = P_amu_info_ptr; 316 if amu_info.type = SAVED_PROC_TYPE then return; 317 call set_for_proc (amu_info.proc_idx_hold); 318 return; 319 320 321 amu_fdump_mpt_$fill_proc_table: 322 entry (P_amu_info_ptr, P_dbr, P_idx, P_cpu, brief_sw, P_code); 323 324 amu_info_ptr = P_amu_info_ptr; 325 if amu_info.type = FDUMP_TYPE then amu_info.type = FDUMP_PROCESS_TYPE; 326 if amu_info.type ^= FDUMP_PROCESS_TYPE then do; 327 P_code = amu_et_$not_fdump; 328 return; 329 end; 330 code = 0; 331 cpu_name = P_cpu; 332 search_dbr = P_dbr; 333 process_idx = P_idx; 334 335 if search_dbr ^= 0 & process_idx = -1 then do; 336 do process_idx = lbound (fdump_process_table.array, 1) by 1 to hbound (fdump_process_table.array, 1) 337 while (search_dbr ^= fdump_process_table.array (process_idx).dbr); 338 end; 339 if process_idx < lbound (fdump_process_table.array, 1) | process_idx > hbound (fdump_process_table.array, 1) 340 then do; 341 P_code = amu_et_$apte_not_found; 342 return; 343 end; 344 end; 345 else if cpu_name ^= "" then do; 346 do process_idx = 0 by 1 to fdump_process_table.size; 347 if cpu_name = fdump_process_table.array (process_idx).cpu_name then 348 if fdump_process_table.array (process_idx).process_info_ptr -> process_info.state = RUNNING then 349 go to get_p; 350 end; 351 call ioa_ ("No running process for cpu ^a", cpu_name); 352 P_code = 0; 353 return; 354 355 end; 356 if process_idx < lbound (fdump_process_table.array, 1) | process_idx > hbound (fdump_process_table.array, 1) 357 then do; 358 P_code = amu_et_$big_idx; 359 return; 360 end; 361 get_p: 362 call set_for_proc (process_idx); 363 if ^brief_sw then call what_process_selected; 364 return; 365 366 367 amu_fdump_mpt_$terminate: 368 entry (P_amu_info_ptr); 369 dcl i; 370 amu_info_ptr = P_amu_info_ptr; 371 if fdump_info.fdump_process_table_ptr ^= null () then do; 372 do i = lbound (fdump_process_table.array, 1) to hbound (fdump_process_table.array, 1); 373 amu_info.process_info_ptr = fdump_process_table.array (i).process_info_ptr; 374 if amu_info.process_info_ptr ^= null then free process_info in (amu_area); 375 end; 376 free fdump_process_table in (amu_area); 377 end; 378 return; 379 380 381 get_data_: 382 proc (data_ptr, seg, word, number); 383 384 385 dcl data_ptr ptr; 386 dcl seg fixed bin; 387 dcl (word, number) fixed bin (18); 388 389 if ^amu_$return_val_per_process (amu_info_ptr, seg) then do; 390 index_changed = "1"b; 391 call amu_$fdump_mpt_temp_change_idx (amu_info_ptr, lbound (fdump_process_table.array, 1)); 392 end; 393 call amu_$do_translation (amu_info_ptr, seg, data_ptr, word, number, code); 394 if index_changed = "1"b then do; 395 call amu_$fdump_mpt_revert_idx (amu_info_ptr); 396 index_changed = "0"b; 397 end; 398 end get_data_; 399 400 401 what_process: 402 proc; 403 dcl process_st (0:6) char (9) varying int static options (constant) 404 init ("empty", "running", "ready", "waiting", "blocked", "stopped", "ptlocking"); 405 t_ptr = addr (t_data); 406 t_segno = hardcore_info.segno.pds; 407 t_offset = amu_$definition_offset (amu_info_ptr, "pds", "process_group_id", code); 408 409 call amu_$do_translation (amu_info_ptr, t_segno, t_ptr, t_offset, 8, code); 410 411 if af_sw then do; 412 call ioa_$rsnnl ("^o", pid, ignore, fixed(process_info.pid)); 413 af_str = af_str || " " || pid; 414 end; 415 else do; 416 if index (based_char, ".") = 0 then based_char = ""; 417 if process_info.state = RUNNING then call ioa_ ("Proc ^3d DBR ^9o^[ running^39ton cpu ^a^]^3x^a", 418 amu_info.process_idx, fdump_process_table.array (amu_info.process_idx).dbr, 419 (process_info.state = RUNNING), fdump_process_table.array (amu_info.process_idx).cpu_name, based_char); 420 else call ioa_ ("Proc ^3d DBR ^9o ^9a last on cpu ^a^3x^a", amu_info.process_idx, 421 fdump_process_table.array (amu_info.process_idx).dbr, process_st (process_info.state), 422 fdump_process_table.array (amu_info.process_idx).cpu_name, based_char); 423 end; 424 425 end what_process; 426 427 what_process_selected: 428 proc; 429 430 t_ptr = addr (t_data); 431 t_segno = hardcore_info.segno.pds; 432 t_offset = amu_$definition_offset (amu_info_ptr, "pds", "process_group_id", code); 433 434 call amu_$do_translation (amu_info_ptr, t_segno, t_ptr, t_offset, 8, code); 435 call ioa_ ("Process ^3d, ^a, DBR ^9o", amu_info.process_idx, based_char, 436 fdump_process_table.array (amu_info.process_idx).dbr); 437 438 end what_process_selected; 439 440 441 create_proc_table: 442 proc; 443 444 445 if fp_table.process_info_ptr = null () then do; 446 call init_process_table; 447 fp_table.process_info_ptr = amu_info.process_info_ptr; 448 end; 449 else amu_info.process_info_ptr = fp_table.process_info_ptr; 450 451 call amu_$tc_data_find_apte (amu_info_ptr, fp_table.dbr, segment_ptr, code); 452 if code ^= 0 then do; 453 call ioa_ ("Could not find apte for process_idx ^d^/^5xdbr = ^o", process_idx, fp_table.dbr); 454 return; 455 end; 456 if hardcore_info.pointers.tc_data.fptr ^= null () then do; 457 process_info.apte.foreign_ptr = segment_ptr; 458 process_info.apte.local_ptr = null (); 459 fp_table.apte_offset = 460 fixed (rel (segment_ptr), 18) - fixed (rel (hardcore_info.pointers.tc_data.fptr), 18); 461 end; 462 else do; 463 process_info.apte.foreign_ptr = null (); 464 process_info.apte.local_ptr = segment_ptr; 465 fp_table.apte_offset = 466 fixed (rel (segment_ptr), 18) - fixed (rel (hardcore_info.pointers.tc_data.lptr), 18); 467 468 469 end; 470 aptep = segment_ptr; 471 process_info.dbr = apte.dbr; 472 process_info.state = fixed (apte.flags.state, 17); 473 process_info.pid = apte.processid; 474 process_info.idx = process_idx; 475 if process_info.address_map_ptr = null () then do; 476 call amu_$translate_allocate (amu_info_ptr, 10); 477 process_info.address_map_ptr = amu_info.translation_table_ptr; 478 end; 479 else amu_info.translation_table_ptr = process_info.address_map_ptr; 480 process_info.idx = process_idx; 481 segment_ptr = baseptr (hardcore_info.prds); 482 call fill_ptrs (addr (process_info.prds), segment_ptr); 483 segment_ptr = baseptr (hardcore_info.dseg); 484 call fill_ptrs (addr (process_info.dseg), segment_ptr); 485 segment_ptr = baseptr (hardcore_info.pds); 486 call fill_ptrs (addr (process_info.pds), segment_ptr); 487 segment_ptr = baseptr (hardcore_info.kst); 488 call fill_ptrs (addr (process_info.kst), segment_ptr); 489 490 491 process_info.dump_segx.first = fp_table.first_seg; 492 process_info.dump_segx.last = fp_table.last_seg; 493 494 495 496 return; 497 end create_proc_table; 498 499 500 init_process_table: 501 proc; 502 allocate process_info in (amu_area) set (amu_info.process_info_ptr); 503 process_info.address_map_ptr = null (); 504 process_info.apte.foreign_ptr = null (); 505 process_info.apte.local_ptr = null (); 506 process_info.prds = process_info.apte; 507 process_info.dseg = process_info.apte; 508 process_info.pds = process_info.apte; 509 process_info.kst = process_info.apte; 510 511 end init_process_table; 512 513 514 set_for_proc: 515 proc (p_idx); /* This proc should not change the amu_info.proc_idx_hold */ 516 dcl p_idx fixed bin; 517 518 amu_info.type = FDUMP_PROCESS_TYPE; 519 amu_info.process_idx = p_idx; 520 amu_info.process_info_ptr = fdump_process_table.array (amu_info.process_idx).process_info_ptr; 521 amu_info.translation_table_ptr = process_info.address_map_ptr; 522 end set_for_proc; 523 524 525 fill_ptrs: 526 proc (ppdp, dp); 527 dcl 1 proc_ptr_data like process_info.apte based (ppdp); 528 dcl ppdp ptr; 529 dcl dp ptr; 530 call amu_$fdump_translate_contiguous (amu_info_ptr, dp, addr (temp_translation), code); 531 if temp_translation.flags.in_dump = "1"b then do; 532 proc_ptr_data.foreign_ptr = temp_translation.part1.ptr; 533 proc_ptr_data.local_ptr = null (); 534 end; 535 else do; 536 proc_ptr_data.local_ptr = temp_translation.part1.ptr; 537 proc_ptr_data.foreign_ptr = null (); 538 end; 539 call amu_$translate_add (amu_info_ptr, addr (temp_translation), fixed (baseno (dp), 17), code); 540 if code = amu_et_$trans_exists then 541 call amu_$translate_force_add (amu_info_ptr, addr (temp_translation), fixed (baseno (dp), 17), code); 542 543 end fill_ptrs; 544 545 1 1 /* BEGIN INCLUDE FILE amu_translation.incl.pl1 */ 1 2 1 3 1 4 1 5 /****^ HISTORY COMMENTS: 1 6* 1) change(87-01-16,Parisek), approve(87-07-16,MCR7746), 1 7* audit(87-07-16,Fawcett), install(87-07-28,MR12.1-1049): 1 8* Added the "replaced" field to record whether a segment was replaced by 1 9* another segment via the "replace" request. 1 10* END HISTORY COMMENTS */ 1 11 1 12 1 13 dcl 1 translation_table aligned based (amu_info.translation_table_ptr), 1 14 2 n_entries fixed bin, 1 15 2 max_entries fixed bin, 1 16 1 17 2 valid_array aligned, /* one bit for each valid segno */ 1 18 3 valid (0 : 4095) bit (1) unaligned, 1 19 2 used_array aligned, /* one bit for each existing translation */ 1 20 3 used (0 : 4095) bit (1) unaligned, 1 21 1 22 2 array (alloc_translation_table_max_entries refer (translation_table.max_entries)) like translation; 1 23 1 24 dcl 1 translation aligned based (translation_ptr), /* a single translation */ 1 25 2 segno fixed bin (18) unsigned unaligned, /* foreign segno for this translation */ 1 26 2 flags unaligned, 1 27 3 two_part bit (1) unaligned, /* segment is in two pieces -- from an FDUMP */ 1 28 3 in_dump bit (1) unaligned, /* segment is part of an FDUMP image */ 1 29 3 in_temp_seg bit (1) unaligned, /* segment is a copy at the base of a temp segment */ 1 30 3 in_perm_seg bit (1) unaligned, /* segment is in the file system */ 1 31 3 in_dp_dir bit (1) unaligned, 1 32 3 replaced bit (1) unaligned, 1 33 3 pad bit (12) unaligned, 1 34 2 part1, /* pointer to first (possibly only) part of segment */ 1 35 3 ptr pointer unaligned, 1 36 3 lth fixed bin (19), 1 37 2 part2 like translation.part1; 1 38 1 39 dcl alloc_translation_table_max_entries fixed bin; 1 40 dcl translation_ptr pointer; 1 41 1 42 /* END INCLUDE FILE amu_translation.incl.pl1 */ 546 547 2 1 /* BEGIN INCLUDE FILE amu_info.incl.pl1 */ 2 2 2 3 dcl 1 amu_info aligned based (amu_info_ptr), 2 4 2 version char (8) aligned, /* AMU_INFO_VERSION */ 2 5 2 flags aligned, 2 6 3 early_dump bit(1) unal, 2 7 3 pad bit(35) unal, 2 8 2 type fixed bin unal, /* One of the types below */ 2 9 2 time_created fixed bin (71) aligned, /* time created -- for debugging purposes */ 2 10 2 chain, /* a chain of all the amu_info's which exist */ 2 11 3 prev pointer unaligned, 2 12 3 next pointer unaligned, 2 13 2 14 2 area_ptr pointer, /* pointer to area used for allocating things */ 2 15 2 16 2 translation_table_ptr pointer, /* pointer to address map -- always present */ 2 17 /* SEE: amu_translation.incl.pl1 */ 2 18 2 fdump_info_ptr pointer, 2 19 /* pointer to FDUMP info, present if looking at an FDUMP */ 2 20 /* SEE: amu_fdump_info.incl.pl1 */ 2 21 /* old_uid_table pointer if looking at a SAVED PROC. */ 2 22 /* See: amu_old_uid_table */ 2 23 2 24 2 25 2 hardcore_info_ptr pointer, /* pointer to hardcore information -- always present */ 2 26 /* SEE: amu_hardcore_info.incl.pl1 */ 2 27 2 copy_chain pointer, /* pointer to info about segment copies */ 2 28 /* SEE: amu_copy_info.incl.pl1 */ 2 29 2 process_info_ptr pointer, /* pointer to process info for this translation */ 2 30 /* SEE: amu_process_info.incl.pl1 */ 2 31 2 process_idx fixed bin, /* index of process in translation-specifc process table */ 2 32 2 33 2 proc_idx_hold fixed bin, /* a place to keep the index when a changing to another proc */ 2 34 2 35 2 error_info, /* various info about how amu_error_ is to behave */ 2 36 3 error_flags aligned, 2 37 4 handler_exists bit (1) unaligned, /* set to indicate existence of an amu_error handler */ 2 38 4 in_subsystem bit (1) unaligned, /* This amu_info belongs to an ssu_ maintained subsystem */ 2 39 4 pad bit (34) unaligned, 2 40 3 sci_ptr pointer, /* sci_ptr for subsystem, if in_subsystem = "1"b */ 2 41 2 definitions_info_ptr ptr; 2 42 2 43 dcl amu_area area based (amu_info.area_ptr); 2 44 2 45 dcl amu_info_ptr pointer; 2 46 2 47 dcl (FDUMP_TYPE init (1037), /* the various legitimate types of amu_info's */ 2 48 FDUMP_PROCESS_TYPE init (1038), 2 49 ONLINE_TYPE init (1039), 2 50 ONLINE_PROCESS_TYPE init (1040), 2 51 NETWORK_FDUMP_TYPE init (1041), 2 52 NETWORK_ONLINE_TYPE init (1042), 2 53 SAVED_PROC_TYPE init (1043), 2 54 INDIRECT_TYPE init (1044)) fixed bin internal static options (constant); 2 55 2 56 dcl AMU_INFO_VERSION_1 char (8) internal static options (constant) init ("amu_v1"); 2 57 dcl AMU_INFO_VERSION char (8) internal static options (constant) init ("amu_v1"); 2 58 dcl AMU_INFO_VERSION_2 char (8) internal static options (constant) init ("amu_v2"); 2 59 2 60 dcl PDIR_SUFFIX char(4) init("pdir") int static options(constant); 2 61 2 62 /* END INCLUDE FILE amu_info.incl.pl1 */ 548 549 3 1 /* BEGIN INCLUDE FILE amu_fdump_info.incl.pl1 */ 3 2 3 3 dcl 1 fdump_info aligned based (amu_info.fdump_info_ptr), 3 4 2 version char (8), 3 5 2 ref_count fixed bin, /* number of initiations */ 3 6 3 7 2 erf_name char (32), /* ERF name for this dump */ 3 8 2 dump_dname char (168), /* location of the dump */ 3 9 2 dump_ename char (32), /* ename of component zero */ 3 10 2 system_id char (8), /* the system_id of this erf */ 3 11 2 version_id char (8), /* the version id of this erf */ 3 12 2 dump_seg_0_uid bit (36) aligned, /* for determining EQ-ness and gullibility checking */ 3 13 3 14 2 n_dump_segs fixed bin, /* number of real segs in the dump */ 3 15 2 copy_block_ptr pointer, /* pointer to chain of temp segment blocks */ 3 16 3 17 2 dump_seg_ptr (0:31) pointer, /* pointer and length arrays */ 3 18 2 dump_seg_lth (0:31) fixed bin (18), 3 19 3 20 2 fdump_process_table_ptr pointer; /* pointer to array describing processes */ 3 21 3 22 3 23 dcl 1 fdump_process_table aligned based (fdump_info.fdump_process_table_ptr), 3 24 2 size fixed bin, /* number of entries */ 3 25 3 26 2 array (0:alloc_fdump_process_table_size - 1 refer (fdump_process_table.size)) like fp_table; 3 27 3 28 dcl 1 fp_table based (fp_table_ptr), 3 29 2 first_seg fixed bin, 3 30 2 last_seg fixed bin, 3 31 2 process_info_ptr pointer unaligned, /* pointer to process_info structure, if filled in */ 3 32 2 dmp_seg_indx fixed bin, /* dump seg index where process can be found */ 3 33 2 dmp_seg_offset fixed bin (24), /* offset in the segment refered to by dmp_seg_indx where process starts */ 3 34 2 cpu_name char (1), 3 35 2 dbr fixed bin (24), /* address portion of DBR */ 3 36 2 apte_offset fixed bin (18); 3 37 3 38 dcl fp_table_ptr ptr; 3 39 3 40 dcl alloc_fdump_process_table_size fixed bin; 3 41 3 42 dcl AMU_FDUMP_INFO_VERSION_1 char (8) internal static options (constant) init ("amu_erf1"); 3 43 dcl AMU_FDUMP_INFO_VERSION char (8) internal static options (constant) init ("amu_erf1"); 3 44 3 45 /* END INCLUDE FILE amu_fdump_info.incl.pl1 */ 550 551 4 1 /* BEGIN INCLUDE FILE amu_process_info.incl.pl1 */ 4 2 4 3 /* This structure describes information about a single process in an address 4 4* translation. It is only relevant for translations involving the online system 4 5* or an FDUMP. */ 4 6 4 7 dcl 1 process_info aligned based (amu_info.process_info_ptr), /* information about a single process */ 4 8 2 pid bit (36) aligned, /* process_id of this process */ 4 9 2 address_map_ptr pointer unaligned, /* pointer to address map */ 4 10 2 idx fixed bin, /* index of process in FDUMP, or apte index if online */ 4 11 2 state fixed bin, /* state, from the APTE -- only good for FDUMP */ 4 12 4 13 2 dbr fixed bin (71), /* DBR of this process */ 4 14 4 15 2 apte aligned, /* pointer to this process's APTE */ 4 16 3 foreign_ptr pointer unaligned, 4 17 3 local_ptr pointer unaligned, 4 18 2 prds aligned like process_info.apte, /* and PRDS, IFF it has one (is running) -- volatile */ 4 19 2 dseg aligned like process_info.apte, /* DSEG -- These values must be constantly recalculated */ 4 20 2 pds aligned like process_info.apte, /* PDS --- for an online process, if phcs transparency */ 4 21 2 kst aligned like process_info.apte, /* KST --- is not in use. */ 4 22 4 23 2 dump_segx, /* index of first and last seg belonging to this */ 4 24 3 first fixed bin, /* process in bos_dump.seg_array, or zero if none */ 4 25 3 last fixed bin, /* this information is only valid for a process in a dump */ 4 26 4 27 2 pad1 fixed bin; 4 28 4 29 /* END INCLUDE FILE amu_process_info.incl.pl1 */ 552 553 5 1 /* BEGIN INCLUDE FILE amu_hardcore_info.incl.pl1 */ 5 2 5 3 /* This structure contains information about the hardcore supervisor address 5 4* space for an address translation. */ 5 5 5 6 dcl 1 hardcore_info aligned based (amu_info.hardcore_info_ptr), 5 7 5 8 2 pointers, /* assorted pointers to various useful items */ 5 9 3 slt aligned, /* SLT */ 5 10 4 fptr pointer unaligned, /* address in foreign address space */ 5 11 4 lptr pointer unaligned, /* location in local address space */ 5 12 3 sltnt aligned like hardcore_info.slt, /* SLT names segment */ 5 13 3 definitions aligned like hardcore_info.slt, /* hardcore definitions_ segment */ 5 14 5 15 3 sst aligned like hardcore_info.slt, /* SST */ 5 16 3 tc_data aligned like hardcore_info.slt, /* TC_DATA */ 5 17 3 sstnt aligned like hardcore_info.slt, /* SSTNT (if any -- foreign_ptr = null if not) */ 5 18 3 upt aligned like hardcore_info.slt, /* unpaged_page_tables (if any -- foreign_ptr = null if not) */ 5 19 5 20 2 segno, /* segment numbers of various per-process/per-processor segs */ 5 21 3 prds fixed bin (15), /* segno of PRDS */ 5 22 3 dseg fixed bin (15), /* DSEG */ 5 23 3 pds fixed bin (15), /* PDS */ 5 24 3 kst fixed bin (15), /* KST */ 5 25 3 stack_0 fixed bin (15), /* segno of stack_0 -- first one in stack group */ 5 26 3 unpaged_page_tables fixed bin(15), /* segno of unpaged_page_tables if it exists */ 5 27 5 28 2 apt, /* information about the APT */ 5 29 3 foreign_ptr pointer unaligned, /* foreign and local pointers to tcm.apt */ 5 30 3 local_ptr pointer unaligned, 5 31 3 count fixed bin, /* number of APTEs */ 5 32 3 size fixed bin, /* size of a single APTE */ 5 33 5 34 2 hcs_count fixed bin, /* highest hardcore segno */ 5 35 5 36 2 pad1 fixed bin; 5 37 5 38 dcl hardcore_cur_ptr ptr; 5 39 5 40 dcl 1 hardcore_cur based (hardcore_cur_ptr), 5 41 2 sltp ptr, 5 42 2 sltntp ptr, 5 43 2 defp ptr, 5 44 2 sstp ptr, 5 45 2 tc_datap ptr, 5 46 2 sstntp ptr, 5 47 2 uptp ptr; 5 48 5 49 5 50 5 51 5 52 /* END INCLUDE FILE amu_hardcore_info.incl.pl1 */ 554 555 6 1 /* BEGIN INCLUDE FILE ... apte.incl.pl1 */ 6 2 6 3 /* Modified 1984-11-11 by E. Swenson for IPC event channel validation. */ 6 4 6 5 dcl aptep pointer; 6 6 6 7 dcl 1 apte based (aptep) aligned, /* APT entry declaration for an active (known) process */ 6 8 2 thread unaligned, /* List thread */ 6 9 3 fp bit (18), /* Forward pointer */ 6 10 3 bp bit (18), /* Backward pointer */ 6 11 2 flags unaligned, /* Flags and miscellaneous */ 6 12 3 mbz bit (1), /* This bit must be zero (sentinel bit) */ 6 13 3 wakeup_waiting bit (1), /* ON if process has received wakeup */ 6 14 3 stop_pending bit (1), /* ON if process has received stop connect */ 6 15 3 pre_empted bit (1), /* ON if process is being pre-empted by get_processor */ 6 16 3 hproc bit (1), /* ON if process is hardcore process */ 6 17 3 loaded bit (1), /* ON if required per-process pages are in memory and wired */ 6 18 3 eligible bit (1), /* ON if process is eligible */ 6 19 3 idle bit (1), /* ON if this is an idle process */ 6 20 3 interaction bit (1), /* ON if process has interacted recently */ 6 21 3 pre_empt_pending bit (1), /* ON if process has received pre-empt connect */ 6 22 3 default_procs_required bit (1), /* ON if apte.procs_required is system default */ 6 23 3 realtime_burst bit (1), /* ON if next eligibility is realtime */ 6 24 3 always_loaded bit (1), /* ON if process is not to be unloaded */ 6 25 3 dbr_loaded bit (1), /* ON if DBR is loaded on some CPU */ 6 26 3 being_loaded bit (1), /* ON if somebody loading this process */ 6 27 3 shared_stack_0 bit (1), /* ON if a shared stack_0 is assigned */ 6 28 3 page_wait_flag bit (1), /* flag ON if waiting for page */ 6 29 3 firstsw bit (1), /* OFF until process is intialized */ 6 30 3 state bit (18), /* execution state */ 6 31 2 page_faults fixed bin (35), /* total page faults for the process */ 6 32 2 processid bit (36), /* bit 0-17: offset of ATPE */ 6 33 /* bit 18-35: sequential number */ 6 34 2 te fixed bin (35), /* virtual time since eligibility award */ 6 35 2 ts fixed bin (35), /* virtual time since scheduling */ 6 36 2 ti fixed bin (35), /* virtual time since interaction */ 6 37 2 timax fixed bin (35), /* maximum value allowed for apte.ti */ 6 38 6 39 /* * * * * * * * */ 6 40 6 41 2 ipc_pointers unaligned, 6 42 3 event_thread bit (18), /* relative pointer to ITT list */ 6 43 3 pad3 bit (18), 6 44 2 ips_message bit (36), /* IPS signals pending */ 6 45 2 asteps unaligned, /* relative ASTE pointers */ 6 46 3 pds bit (18), /* PDS (per-process) */ 6 47 3 dseg bit (18), /* DSEG (per-process) */ 6 48 3 prds bit (18), /* PRDS (per-processor) */ 6 49 2 savex7 bit (18) unaligned, /* x7 at call to getwork (return point in pxss) */ 6 50 2 term_processid bit (36), /* process to send wakeup at temination */ 6 51 2 lock_id bit (36), /* File System unqieu ID associated with process */ 6 52 2 time_used_clock fixed bin (71), /* Total CPU time when process last lost CPU */ 6 53 6 54 /* * * * * * * * */ 6 55 6 56 2 wait_event bit (36) aligned, /* Event ID process awaiting */ 6 57 2 wct_index bit (18) unaligned, /* rel offset of WCTE */ 6 58 2 flags2 unaligned, 6 59 3 priority_scheduling bit (1), /* ON if guaranteed eligibility */ 6 60 3 special_wakeups bit (6), /* Special wakeup channels */ 6 61 3 pad7 bit (7), 6 62 3 batch bit (1), /* ON if absentee */ 6 63 3 pr_tag bit (3), /* CPU tag running or last run */ 6 64 2 state_change_time fixed bin (71), /* Time apte.state last changed */ 6 65 2 alarm_event fixed bin (71), /* wakeup event for alarm clock manager */ 6 66 2 alarm_time_thread bit (18) unaligned, /* thread of processes with pending alarms */ 6 67 2 alarm_time bit (54) unaligned, /* wakeup time for alarm */ 6 68 6 69 /* * * * * * */ 6 70 6 71 2 term_channel fixed bin (71), /* wakeup event for account overflow */ 6 72 2 ws_size fixed bin, /* working set estimate for the process */ 6 73 2 temax fixed bin (35), /* maximum eligibility slice (vcpu) */ 6 74 2 deadline fixed bin (71), /* time of next run */ 6 75 2 lock bit (18) unaligned, /* 0 => APTE locked, unlocked => return point of last unlock */ 6 76 2 unusable bit (18) unaligned, /* locking routines destroy */ 6 77 2 cpu_monitor fixed bin (35), /* if not 0, send wakeup to term_processid when virtual cpu 6 78* /* reaches this (units = 1/1024 sec) */ 6 79 2 paging_measure fixed bin (71), /* cumulative memory units */ 6 80 2 access_authorization bit (72), /* authorization of this process */ 6 81 2 dbr fixed bin (71), /* DBR value (constant since DSEG entry-held) */ 6 82 6 83 2 virtual_cpu_time fixed bin (71), /* cumulative virtual CPU time for the process */ 6 84 2 ittes_sent fixed bin (18), /* Unprocessed ITTs sent by this process */ 6 85 2 ittes_got fixed bin (18), /* Unprocessed ITTs received by this process */ 6 86 6 87 /* Cells used to drive and instrument finite-state model for response time 6 88* measurement. Maintained by meter_response_time */ 6 89 6 90 2 current_response_state fixed bin (17) unaligned, /* Process state in modle */ 6 91 2 pad18 bit (18) unaligned, 6 92 2 number_processing fixed bin (35), /* Number interactions */ 6 93 2 last_response_state_time fixed bin (71), /* Clock time at last response state change */ 6 94 2 total_processing_time fixed bin (71), /* Total interaction processing time */ 6 95 6 96 /* * * * * * */ 6 97 6 98 2 begin_interaction_vcpu fixed bin (71), /* Virtual cpu at beginning of last interaction */ 6 99 6 100 /* End of cells for finite-state model */ 6 101 6 102 2 saved_temax fixed bin (35), /* temax at eligibility award */ 6 103 2 procs_required bit (8) unaligned, /* bit mask of CPUs this process can run */ 6 104 2 pad4 bit (28) unaligned, 6 105 2 ipc_r_offset fixed bin (18) unsigned, 6 106 2 ipc_r_factor fixed bin (35) unsigned, 6 107 2 apad (10) fixed bin (35); 6 108 6 109 /* END INCLUDE FILE ... apte.incl.pl1 */ 556 557 7 1 /* BEGIN INCLUDE FILE ... bos_dump.incl.pl1 ... */ 7 2 /* Modified 1 September 1976 */ 7 3 /* Modified 11/11/80 by J. A. Bush for the DPS8/70M CPU */ 7 4 /* Modified 6/12/81 by Rich Coppola to extend the dps8 extended fault reg to 7 5* 15 bits */ 7 6 /* Modified 02/23/81, W. Olin Sibert, to describe old and new FDUMP styles */ 7 7 7 8 7 9 dcl dumpptr ptr; /* pointer to following structure */ 7 10 7 11 dcl 1 dump based (dumpptr) aligned, /* header of dump by fdump */ 7 12 2 dump_header aligned like dump_header, 7 13 7 14 2 segs (1008), /* segment array */ 7 15 3 segno bit (18) unal, /* segment number */ 7 16 3 length bit (18) unal, /* length of segment in sector sized blocks */ 7 17 7 18 2 amptwregs (0 : 63) bit (36), /* assoc. mem. page table word regs */ 7 19 2 amptwptrs (0 : 63) bit (36), /* assoc. mem. page table word pointers */ 7 20 2 amsdwregs (0 : 63) bit (72), /* assoc. mem. segment descriptor word registers */ 7 21 2 amsdwptrs (0 : 63) bit (36), /* assoc. mem. segment descriptor word pointers */ 7 22 7 23 2 ouhist (0 : 63) bit (72), /* operations unit history registers */ 7 24 2 cuhist (0 : 63) bit (72), /* control unit history registers */ 7 25 2 duhist (0 : 63) bit (72), /* decimal unit history registers */ 7 26 2 auhist (0 : 63) bit (72), /* appending unit history registers */ 7 27 7 28 2 prs (0 : 7) ptr, /* pointer registers */ 7 29 7 30 2 regs aligned like dump_registers, /* assorted machine registers */ 7 31 7 32 2 low_order_port bit (3), /* from which clock is read */ 7 33 2 pad4 bit (36), 7 34 2 mctime fixed bin (52), /* time conditions were taken */ 7 35 2 pad5 (0 : 3) bit (36), 7 36 7 37 2 misc_registers like dump_misc_registers, /* Assorted registers & processor data */ 7 38 7 39 2 ptrlen (0 : 7) bit (36), /* pointers and lengths for EIS */ 7 40 7 41 2 coreblocks (0 : 7), 7 42 3 num_first bit (18) unal, /* first addr in coreblock */ 7 43 3 num_blocks bit (18) unal, /* number of blocks used */ 7 44 2 pad7 (112) fixed bin; 7 45 7 46 7 47 dcl 1 dump_header aligned based, /* Standard header for FDUMP */ 7 48 2 words_dumped fixed bin (35), /* total words in dump */ 7 49 2 valid bit (1), /* = 1 if there is a 6180 dump to be had */ 7 50 2 time fixed bin (71), /* time of dump */ 7 51 2 erfno fixed bin (18), /* Error Report Form Number */ 7 52 2 num_segs fixed bin, /* number of segments dumped */ 7 53 2 valid_355 bit (1), /* = 1 if there is a dn355 dump to be had */ 7 54 2 dumped_355s bit (4), /* indicates which 355s were dumped */ 7 55 2 time_355 fixed bin (71), /* time of 355 dump */ 7 56 2 version fixed bin, /* currently 2 */ 7 57 2 pad0 (5) fixed bin; /* pad0 to 16 words */ 7 58 7 59 dcl 1 dump_registers aligned based, /* Standard (SREG) arrangement of registers in dump */ 7 60 (2 x (0 : 7) bit (18), /* index registers */ 7 61 2 a bit (36), /* the a register */ 7 62 2 q bit (36), /* the q register */ 7 63 2 e bit (8), /* the e register */ 7 64 2 pad2 bit (28), /* pad */ 7 65 2 t bit (27), /* timer register */ 7 66 2 pad3 bit (6), /* pad */ 7 67 2 ralr bit (3)) unaligned; /* ring alarm register */ 7 68 7 69 dcl 1 dump_misc_registers aligned based, 7 70 2 scu (0 : 7) bit (36), /* from store control unit instr. */ 7 71 2 mcm (0 : 7) bit (72), /* memory controller masks every 64 K */ 7 72 2 dbr bit (72), /* descriptor segment base register */ 7 73 2 intrpts bit (36), /* interrupts */ 7 74 2 bar bit (36), /* base address register */ 7 75 2 modereg bit (36), /* mode register */ 7 76 2 cmodereg bit (36), /* cache mode register */ 7 77 2 faultreg bit (36), /* fault register */ 7 78 2 ext_fault_reg bit (15) unaligned, /* DPS8 extended fault register */ 7 79 2 pad6 bit (21) unaligned; 7 80 7 81 7 82 7 83 dcl 1 v1_dump aligned based (dumpptr), /* Old version of FDUMP (pre March, 1981) */ 7 84 2 dump_header aligned like dump_header, 7 85 7 86 2 segs (688), /* segment array */ 7 87 3 segno bit (18) unal, /* segment number */ 7 88 3 length bit (18) unal, /* length of segment in sector sized blocks */ 7 89 7 90 2 amsdwregs (0 : 15) bit (72), /* assoc. mem. segment descriptor word registers */ 7 91 2 amsdwptrs (0 : 15) bit (36), /* assoc. mem. segment descriptor word pointers */ 7 92 2 amptwregs (0 : 15) bit (36), /* assoc. mem. page table word regs */ 7 93 2 amptwptrs (0 : 15) bit (36), /* assoc. mem. page table word pointers */ 7 94 2 pad1 (0 : 15) bit (36), 7 95 7 96 2 ouhist (0 : 15) bit (72), /* operations unit history registers */ 7 97 2 cuhist (0 : 15) bit (72), /* control unit history registers */ 7 98 2 auhist (0 : 15) bit (72), /* appending unit history registers */ 7 99 2 duhist (0 : 15) bit (72), /* decimal unit history registers */ 7 100 7 101 2 prs (0 : 7) ptr, /* pointer registers */ 7 102 7 103 2 regs aligned like dump_registers, /* assorted machine registers */ 7 104 7 105 2 mctime fixed bin (52), /* time conditions were taken */ 7 106 2 pad4 (0 : 5) bit (36), 7 107 7 108 2 misc_registers aligned like dump_misc_registers, /* Assorted registers */ 7 109 7 110 2 pad5 bit (36), 7 111 2 ptrlen (0 : 7) bit (36), /* pointers and lengths for EIS */ 7 112 2 pad6 (15) bit (36), 7 113 2 low_order_port bit (3), /* from which clock was read */ 7 114 7 115 2 coreblocks (0 : 7), 7 116 3 num_first bit (18) unal, /* first addr in coreblock */ 7 117 3 num_blocks bit (18) unal; /* number of blocks used */ 7 118 7 119 7 120 dcl DUMP_VERSION_1 fixed bin internal static options (constant) init (1); 7 121 dcl DUMP_VERSION_2 fixed bin internal static options (constant) init (2); 7 122 7 123 /* END INCLUDE FILE ... bos_dump.incl.pl1 ... */ 558 559 560 end amu_fdump_mpt_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 07/28/87 0924.4 amu_fdump_mpt_.pl1 >spec>install>MR12.1-1049>amu_fdump_mpt_.pl1 546 1 07/28/87 0927.3 amu_translation.incl.pl1 >spec>install>MR12.1-1049>amu_translation.incl.pl1 548 2 11/20/84 0856.1 amu_info.incl.pl1 >ldd>include>amu_info.incl.pl1 550 3 09/22/83 1102.5 amu_fdump_info.incl.pl1 >ldd>include>amu_fdump_info.incl.pl1 552 4 11/20/84 0856.2 amu_process_info.incl.pl1 >ldd>include>amu_process_info.incl.pl1 554 5 11/20/84 0854.8 amu_hardcore_info.incl.pl1 >ldd>include>amu_hardcore_info.incl.pl1 556 6 01/06/85 1422.2 apte.incl.pl1 >ldd>include>apte.incl.pl1 558 7 08/12/81 2025.8 bos_dump.incl.pl1 >ldd>include>bos_dump.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. FDUMP_PROCESS_TYPE constant fixed bin(17,0) initial dcl 2-47 ref 237 325 326 518 FDUMP_TYPE constant fixed bin(17,0) initial dcl 2-47 ref 325 P_amu_info_ptr parameter pointer dcl 72 ref 17 143 283 285 290 292 297 299 305 307 313 315 321 324 367 370 P_caller parameter char unaligned dcl 76 set ref 17 228* P_code parameter fixed bin(35,0) dcl 77 set ref 17 230* 321 327* 341* 352* 358* P_cpu parameter char(1) unaligned dcl 75 ref 321 331 P_dbr parameter fixed bin(24,0) dcl 74 ref 321 332 P_idx parameter fixed bin(17,0) dcl 73 set ref 297 302* 305 309* 321 333 RUNNING constant fixed bin(17,0) initial dcl 112 ref 347 417 417 SAVED_PROC_TYPE constant fixed bin(17,0) initial dcl 2-47 ref 300 308 316 addr builtin function dcl 136 ref 181 192 219 241 405 430 482 482 484 484 486 486 488 488 530 530 539 539 540 540 addrel builtin function dcl 136 ref 244 246 address_map_ptr 1 based pointer level 2 packed unaligned dcl 4-7 set ref 225* 475 477* 479 503* 521 af_len parameter fixed bin(21,0) dcl 95 ref 290 413 af_ptr parameter pointer dcl 94 ref 290 413 413 af_str based varying char dcl 83 set ref 413* 413 af_sw 000106 automatic bit(1) unaligned dcl 85 set ref 286* 293* 411 alloc_fdump_process_table_size 000174 automatic fixed bin(17,0) dcl 3-40 set ref 160* 162 162 amu_$definition_offset 000020 constant entry external dcl 115 ref 234 407 432 amu_$definition_ptr 000022 constant entry external dcl 116 ref 266 273 amu_$do_translation 000016 constant entry external dcl 114 ref 393 409 434 amu_$fdump_mpt_revert_idx 000034 constant entry external dcl 121 ref 395 amu_$fdump_mpt_temp_change_idx 000036 constant entry external dcl 122 ref 391 amu_$fdump_translate_contiguous 000040 constant entry external dcl 123 ref 530 amu_$hardcore_info_fdump 000024 constant entry external dcl 117 ref 228 amu_$return_val_idx_from_dbr 000050 constant entry external dcl 127 ref 256 amu_$return_val_per_process 000026 constant entry external dcl 118 ref 389 amu_$tc_data_find_apte 000032 constant entry external dcl 120 ref 451 amu_$tc_data_find_first_running 000042 constant entry external dcl 124 ref 252 amu_$translate_add 000044 constant entry external dcl 125 ref 539 amu_$translate_allocate 000030 constant entry external dcl 119 ref 224 476 amu_$translate_force_add 000046 constant entry external dcl 126 ref 540 amu_area based area(1024) dcl 2-43 ref 162 374 376 502 amu_et_$apte_not_found 000056 external static fixed bin(35,0) dcl 130 ref 341 amu_et_$big_idx 000064 external static fixed bin(35,0) dcl 130 ref 358 amu_et_$not_fdump 000060 external static fixed bin(35,0) dcl 130 ref 327 amu_et_$trans_exists 000062 external static fixed bin(35,0) dcl 130 ref 540 amu_info based structure level 1 dcl 2-3 amu_info_ptr 000170 automatic pointer dcl 2-45 set ref 143* 144 145 162 162 164 165 166 167 168 172 181 182 183 184 192 194 195 195 201 207 208 218 219 222 224* 225 225 228* 234* 237 239 240 241 244 244 246 246 252* 256* 266* 271 273* 277 285* 292* 299* 300 301 301 307* 308 315* 316 317 324* 325 325 326 336 336 336 339 339 346 347 347 356 356 370* 371 372 372 373 373 374 374 374 376 376 389* 391* 391 391 393* 395* 406 407* 409* 412 412 417 417 417 417 417 417 417 420 420 420 420 420 420 431 432* 434* 435 435 435 447 449 451* 456 457 458 459 463 464 465 471 472 473 474 475 476* 477 477 479 479 480 481 482 482 483 484 484 485 486 486 487 488 488 491 492 502 502 503 504 505 506 506 507 507 508 508 509 509 518 519 520 520 520 521 521 530* 539* 540* apte based structure level 1 dcl 6-7 in procedure "amu_fdump_mpt_" apte 6 based structure level 2 in structure "process_info" dcl 4-7 in procedure "amu_fdump_mpt_" set ref 506 507 508 509 apte_offset 10 based fixed bin(18,0) array level 3 in structure "fdump_process_table" dcl 3-23 in procedure "amu_fdump_mpt_" set ref 168* apte_offset 7 based fixed bin(18,0) level 2 in structure "fp_table" dcl 3-28 in procedure "amu_fdump_mpt_" set ref 459* 465* aptep 000176 automatic pointer dcl 6-5 set ref 470* 471 472 473 area_ptr 10 based pointer level 2 dcl 2-3 ref 162 374 376 502 array 1 based structure array level 2 dcl 3-23 set ref 181 192 219 241 336 336 339 339 356 356 372 372 391 391 based_char based char(32) unaligned dcl 82 set ref 416 416* 417* 420* 435* based_dbr based bit(24) unaligned dcl 100 ref 184 208 baseno builtin function dcl 136 ref 269 269 276 276 539 539 540 540 baseptr builtin function dcl 136 ref 481 483 485 487 binary builtin function dcl 136 ref 153 156 188 212 213 brief_sw parameter bit(1) unaligned dcl 78 ref 321 363 cleanup 000160 stack reference condition dcl 140 ref 147 code 000137 automatic fixed bin(35,0) dcl 92 set ref 142* 228* 229 230 234* 235 252* 253 262* 263 266* 268 273* 275 279* 330* 393* 407* 409* 432* 434* 451* 452 530* 539* 540 540* com_err_ 000010 constant entry external dcl 69 ref 199 cpu_name 5 based char(1) level 2 in structure "fp_table" packed unaligned dcl 3-28 in procedure "amu_fdump_mpt_" set ref 244* 246* 248* cpu_name 000151 automatic char(1) unaligned dcl 103 in procedure "amu_fdump_mpt_" set ref 331* 345 347 351* cpu_name 6 based char(1) array level 3 in structure "fdump_process_table" dcl 3-23 in procedure "amu_fdump_mpt_" set ref 166* 347 417* 420* cpu_no based fixed bin(3,0) dcl 104 ref 244 246 cpu_tag_offset 000152 automatic fixed bin(18,0) dcl 105 set ref 234* 244 246 data_buf_ptr 000112 automatic pointer dcl 88 set ref 146* 148 148* 262* 269* 271 276* 277 279 279* data_ptr parameter pointer dcl 385 set ref 381 393* dbr 44 based fixed bin(71,0) level 2 in structure "apte" dcl 6-7 in procedure "amu_fdump_mpt_" ref 471 dbr 7 based fixed bin(24,0) array level 3 in structure "fdump_process_table" dcl 3-23 in procedure "amu_fdump_mpt_" set ref 167* 336 417* 420* 435* dbr 4 based fixed bin(71,0) level 2 in structure "process_info" dcl 4-7 in procedure "amu_fdump_mpt_" set ref 471* dbr 6 based fixed bin(24,0) level 2 in structure "fp_table" dcl 3-28 in procedure "amu_fdump_mpt_" set ref 184* 208* 451* 453* divide builtin function dcl 136 ref 182 194 dmp_seg_indx 3 based fixed bin(17,0) level 2 dcl 3-28 set ref 182* 184 194* 195 195 203* 203 208 dmp_seg_offset 4 based fixed bin(24,0) level 2 dcl 3-28 set ref 183* 184 207* 208 dp parameter pointer dcl 529 set ref 525 530* 539 539 540 540 dseg 12 based structure level 2 in structure "process_info" dcl 4-7 in procedure "amu_fdump_mpt_" set ref 484 484 507* dseg 17 based fixed bin(15,0) level 3 in structure "hardcore_info" dcl 5-6 in procedure "amu_fdump_mpt_" ref 483 dump based structure level 1 dcl 7-11 ref 174 dump_header based structure level 2 in structure "dump" dcl 7-11 in procedure "amu_fdump_mpt_" dump_header based structure level 1 dcl 7-47 in procedure "amu_fdump_mpt_" dump_misc_registers based structure level 1 dcl 7-69 dump_registers based structure level 1 dcl 7-59 dump_seg_lth 206 based fixed bin(18,0) array level 2 dcl 3-3 ref 182 183 194 207 dump_seg_ptr 106 based pointer array level 2 dcl 3-3 ref 145 184 195 208 dump_segx 20 based structure level 2 dcl 4-7 dumpptr 000200 automatic pointer dcl 7-9 set ref 145* 152 153 156 174 187 188 212 213 215 fdump_info based structure level 1 dcl 3-3 fdump_info_ptr 14 based pointer level 2 dcl 2-3 ref 144 145 162 164 165 166 167 168 172 181 182 183 184 192 194 195 195 201 207 208 219 239 241 271 277 336 336 336 339 339 346 347 347 356 356 371 372 372 373 376 391 391 417 417 420 420 435 520 fdump_process_table based structure level 1 dcl 3-23 set ref 162 376 fdump_process_table_ptr 246 based pointer level 2 dcl 3-3 set ref 144* 162* 164 165 166 167 168 172 181 192 201 219 239 241 336 336 336 339 339 346 347 347 356 356 371 372 372 373 376 391 391 417 417 420 420 435 520 first 20 based fixed bin(17,0) level 3 dcl 4-7 set ref 491* first_seg based fixed bin(17,0) level 2 in structure "fp_table" dcl 3-28 in procedure "amu_fdump_mpt_" set ref 193* 491 first_seg 1 based fixed bin(17,0) array level 3 in structure "fdump_process_table" dcl 3-23 in procedure "amu_fdump_mpt_" set ref 172* fixed builtin function dcl 136 ref 184 208 212 269 269 269 269 276 276 276 276 412 412 459 459 465 465 472 539 539 540 540 flags 1 based structure level 2 in structure "apte" packed unaligned dcl 6-7 in procedure "amu_fdump_mpt_" flags 0(18) 000153 automatic structure level 2 in structure "temp_translation" packed unaligned dcl 107 in procedure "amu_fdump_mpt_" foreign_ptr 6 based pointer level 3 in structure "process_info" packed unaligned dcl 4-7 in procedure "amu_fdump_mpt_" set ref 457* 463* 504* foreign_ptr 10 based pointer level 3 in structure "process_info" packed unaligned dcl 4-7 in procedure "amu_fdump_mpt_" set ref 244 244 foreign_ptr based pointer level 2 in structure "proc_ptr_data" packed unaligned dcl 527 in procedure "fill_ptrs" set ref 532* 537* fp_table based structure level 1 unaligned dcl 3-28 fp_table_ptr 000172 automatic pointer dcl 3-38 set ref 181* 182 183 184 184 184 190 192* 193 194 195 195 203 203 204 207 208 208 208 215 219* 222 241* 244 246 248 445 447 449 451 453 459 465 491 492 fptr 10 based pointer level 4 packed unaligned dcl 5-6 ref 456 459 get_temp_segment_ 000052 constant entry external dcl 128 ref 262 hardcore_info based structure level 1 dcl 5-6 hardcore_info_ptr 16 based pointer level 2 dcl 2-3 ref 406 431 456 459 465 481 483 485 487 hbound builtin function dcl 136 ref 336 339 356 372 i 000166 automatic fixed bin(17,0) dcl 369 set ref 372* 373* idx 2 based fixed bin(17,0) level 2 dcl 4-7 set ref 474* 480* ignore 000105 automatic fixed bin(21,0) dcl 84 set ref 412* in_dump 0(19) 000153 automatic bit(1) level 3 packed unaligned dcl 107 set ref 531 index builtin function dcl 136 ref 416 index_changed 000107 automatic bit(1) initial unaligned dcl 86 set ref 86* 390* 394 396* ioa_ 000012 constant entry external dcl 70 ref 351 417 420 435 453 ioa_$rsnnl 000014 constant entry external dcl 71 ref 412 kst 16 based structure level 2 in structure "process_info" dcl 4-7 in procedure "amu_fdump_mpt_" set ref 488 488 509* kst 21 based fixed bin(15,0) level 3 in structure "hardcore_info" dcl 5-6 in procedure "amu_fdump_mpt_" ref 487 last 21 based fixed bin(17,0) level 3 dcl 4-7 set ref 492* last_seg 1 based fixed bin(17,0) level 2 dcl 3-28 set ref 190* 204* 215* 492 lbound builtin function dcl 136 ref 336 339 356 372 391 391 length 20(18) based bit(18) array level 3 packed unaligned dcl 7-11 ref 212 local_ptr 1 based pointer level 2 in structure "proc_ptr_data" packed unaligned dcl 527 in procedure "fill_ptrs" set ref 533* 536* local_ptr 11 based pointer level 3 in structure "process_info" packed unaligned dcl 4-7 in procedure "amu_fdump_mpt_" set ref 246 246 local_ptr 7 based pointer level 3 in structure "process_info" packed unaligned dcl 4-7 in procedure "amu_fdump_mpt_" set ref 458* 464* 505* lptr 11 based pointer level 4 packed unaligned dcl 5-6 ref 465 mod builtin function dcl 136 ref 183 207 n_dump_segs 102 based fixed bin(17,0) level 2 dcl 3-3 ref 195 n_processes 000143 automatic fixed bin(17,0) dcl 98 set ref 151* 153* 153 158* 158 160 164 null builtin function dcl 136 ref 144 146 148 165 195 244 246 279 371 374 445 456 458 463 475 503 504 505 533 537 num_segs 5 based fixed bin(17,0) level 3 dcl 7-11 ref 152 187 215 number parameter fixed bin(18,0) dcl 387 set ref 381 393* p_idx parameter fixed bin(17,0) dcl 516 ref 514 519 part1 1 000153 automatic structure level 2 in structure "temp_translation" unaligned dcl 107 in procedure "amu_fdump_mpt_" part1 347 based structure array level 3 in structure "translation_table" dcl 1-13 in procedure "amu_fdump_mpt_" part1 1 based structure level 2 in structure "translation" dcl 1-24 in procedure "amu_fdump_mpt_" pds 20 based fixed bin(15,0) level 3 in structure "hardcore_info" dcl 5-6 in procedure "amu_fdump_mpt_" ref 406 431 485 pds 14 based structure level 2 in structure "process_info" dcl 4-7 in procedure "amu_fdump_mpt_" set ref 486 486 508* pid 000125 automatic varying char(36) dcl 91 in procedure "amu_fdump_mpt_" set ref 412* 413 pid based bit(36) level 2 in structure "process_info" dcl 4-7 in procedure "amu_fdump_mpt_" set ref 412 412 473* pointer builtin function dcl 136 ref 184 208 pointers based structure level 2 dcl 5-6 ppdp parameter pointer dcl 528 ref 525 532 533 536 537 prds 10 based structure level 2 in structure "process_info" dcl 4-7 in procedure "amu_fdump_mpt_" set ref 482 482 506* prds 16 based fixed bin(15,0) level 3 in structure "hardcore_info" dcl 5-6 in procedure "amu_fdump_mpt_" ref 481 prev_segno 000140 automatic fixed bin(17,0) dcl 93 set ref 150* 153 156* 171* 188 213* proc_idx_hold 25 based fixed bin(17,0) level 2 dcl 2-3 set ref 301* 317* proc_ptr_data based structure level 1 packed unaligned dcl 527 process_idx 000142 automatic fixed bin(17,0) dcl 97 in procedure "amu_fdump_mpt_" set ref 170* 172 181 191* 191 192 199* 201 202* 202 216* 218 219 239* 240 241* 253* 256* 257 257* 260* 333* 335 336* 336* 339 339 346* 347 347* 356 356 361* 453* 474 480 process_idx 24 based fixed bin(17,0) level 2 in structure "amu_info" dcl 2-3 in procedure "amu_fdump_mpt_" set ref 218* 240* 301 417* 417 417 420* 420 420 435* 435 519* 520 process_info based structure level 1 dcl 4-7 set ref 374 502 process_info_ptr 2 based pointer level 2 in structure "fp_table" packed unaligned dcl 3-28 in procedure "amu_fdump_mpt_" set ref 222* 445 447* 449 process_info_ptr 22 based pointer level 2 in structure "amu_info" dcl 2-3 in procedure "amu_fdump_mpt_" set ref 222 225 244 244 246 246 373* 374 374 412 412 417 417 420 447 449* 457 458 463 464 471 472 473 474 475 477 479 480 482 482 484 484 486 486 488 488 491 492 502* 503 504 505 506 506 507 507 508 508 509 509 520* 521 process_info_ptr 3 based pointer array level 3 in structure "fdump_process_table" packed unaligned dcl 3-23 in procedure "amu_fdump_mpt_" set ref 165* 347 373 520 process_st 000000 constant varying char(9) initial array dcl 403 set ref 420* processid 3 based bit(36) level 2 dcl 6-7 ref 473 ptr 1 000153 automatic pointer level 3 packed unaligned dcl 107 set ref 532 536 range 000110 automatic fixed bin(18,0) dcl 87 set ref 265* 269* 276* rel builtin function dcl 136 ref 269 269 276 276 459 459 465 465 release_temp_segment_ 000054 constant entry external dcl 129 ref 148 279 search_dbr 000150 automatic fixed bin(24,0) dcl 102 set ref 252* 256* 332* 335 336 seg parameter fixed bin(17,0) dcl 386 set ref 381 389* 393* segment_ptr 000144 automatic pointer dcl 99 set ref 451* 457 459 464 465 470 481* 482* 483* 484* 485* 486* 487* 488* segno 20 based bit(18) array level 3 in structure "dump" packed unaligned dcl 7-11 in procedure "amu_fdump_mpt_" ref 153 156 188 213 segno 16 based structure level 2 in structure "hardcore_info" dcl 5-6 in procedure "amu_fdump_mpt_" segs 20 based structure array level 2 dcl 7-11 segx 000141 automatic fixed bin(17,0) dcl 96 set ref 152* 153 156* 187* 188 190 193 204 212 213* size based fixed bin(17,0) level 2 in structure "fdump_process_table" dcl 3-23 in procedure "amu_fdump_mpt_" set ref 162* 164* 165 166 167 168 201* 239 336 339 346 356 372 376 size builtin function dcl 136 in procedure "amu_fdump_mpt_" ref 174 slt based structure level 3 dcl 5-6 state 1(18) based bit(18) level 3 in structure "apte" packed unaligned dcl 6-7 in procedure "amu_fdump_mpt_" ref 472 state 3 based fixed bin(17,0) level 2 in structure "process_info" dcl 4-7 in procedure "amu_fdump_mpt_" set ref 347 417 417 420 472* system_id based char(8) unaligned dcl 109 in procedure "amu_fdump_mpt_" ref 277 system_id 75 based char(8) level 2 in structure "fdump_info" dcl 3-3 in procedure "amu_fdump_mpt_" set ref 277* t_data 000114 automatic fixed bin(35,0) array dcl 89 set ref 405 430 t_offset 000124 automatic fixed bin(18,0) dcl 90 set ref 407* 409* 432* 434* t_ptr 000100 automatic pointer dcl 79 set ref 405* 409* 416 416 417 420 430* 434* 435 t_segno 000104 automatic fixed bin(17,0) dcl 81 set ref 406* 409* 431* 434* tag 000034 constant char(1) initial array unaligned dcl 106 ref 244 246 tc_data 10 based structure level 3 dcl 5-6 temp_ptr 000102 automatic pointer dcl 80 set ref 266* 269 269 269 269 273* 276 276 276 276 temp_translation 000153 automatic structure level 1 unaligned dcl 107 set ref 530 530 539 539 540 540 total_offset 000146 automatic fixed bin(71,0) dcl 101 set ref 174* 182 183 194 207 212* 212 translation based structure level 1 dcl 1-24 translation_table_ptr 12 based pointer level 2 dcl 2-3 set ref 225 477 479* 521* type 3 based fixed bin(17,0) level 2 packed unaligned dcl 2-3 set ref 237* 300 308 316 325 325* 326 518* version_id based char(8) unaligned dcl 108 in procedure "amu_fdump_mpt_" ref 271 version_id 77 based char(8) level 2 in structure "fdump_info" dcl 3-3 in procedure "amu_fdump_mpt_" set ref 271* word parameter fixed bin(18,0) dcl 387 set ref 381 393* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. AMU_FDUMP_INFO_VERSION internal static char(8) initial unaligned dcl 3-43 AMU_FDUMP_INFO_VERSION_1 internal static char(8) initial unaligned dcl 3-42 AMU_INFO_VERSION internal static char(8) initial unaligned dcl 2-57 AMU_INFO_VERSION_1 internal static char(8) initial unaligned dcl 2-56 AMU_INFO_VERSION_2 internal static char(8) initial unaligned dcl 2-58 DUMP_VERSION_1 internal static fixed bin(17,0) initial dcl 7-120 DUMP_VERSION_2 internal static fixed bin(17,0) initial dcl 7-121 INDIRECT_TYPE internal static fixed bin(17,0) initial dcl 2-47 NETWORK_FDUMP_TYPE internal static fixed bin(17,0) initial dcl 2-47 NETWORK_ONLINE_TYPE internal static fixed bin(17,0) initial dcl 2-47 ONLINE_PROCESS_TYPE internal static fixed bin(17,0) initial dcl 2-47 ONLINE_TYPE internal static fixed bin(17,0) initial dcl 2-47 PDIR_SUFFIX internal static char(4) initial unaligned dcl 2-60 alloc_translation_table_max_entries automatic fixed bin(17,0) dcl 1-39 hardcore_cur based structure level 1 unaligned dcl 5-40 hardcore_cur_ptr automatic pointer dcl 5-38 translation_ptr automatic pointer dcl 1-40 translation_table based structure level 1 dcl 1-13 v1_dump based structure level 1 dcl 7-83 NAMES DECLARED BY EXPLICIT CONTEXT. RET 001402 constant label dcl 279 ref 268 275 amu_fdump_mpt_ 000237 constant entry external dcl 17 amu_fdump_mpt_$change_idx 001536 constant entry external dcl 305 amu_fdump_mpt_$current_process 001437 constant entry external dcl 283 amu_fdump_mpt_$current_process_af 001460 constant entry external dcl 290 amu_fdump_mpt_$fill_proc_table 001623 constant entry external dcl 321 amu_fdump_mpt_$revert_idx 001570 constant entry external dcl 313 amu_fdump_mpt_$temp_change_idx 001502 constant entry external dcl 297 amu_fdump_mpt_$terminate 002051 constant entry external dcl 367 create_proc_table 002721 constant entry internal dcl 441 ref 242 fill_ptrs 003254 constant entry internal dcl 525 ref 482 484 486 488 get_data_ 002127 constant entry internal dcl 381 ref 269 276 get_p 002035 constant label dcl 361 ref 347 init_process_table 003203 constant entry internal dcl 500 ref 220 446 no_more_segs 000727 constant label dcl 216 ref 205 set_for_proc 003234 constant entry internal dcl 514 ref 260 302 309 317 361 what_process 002222 constant entry internal dcl 401 ref 287 294 what_process_selected 002565 constant entry internal dcl 427 ref 363 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 4170 4256 3457 4200 Length 4662 3457 66 367 511 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME amu_fdump_mpt_ 431 external procedure is an external procedure. on unit on line 147 84 on unit get_data_ internal procedure shares stack frame of external procedure amu_fdump_mpt_. what_process internal procedure shares stack frame of external procedure amu_fdump_mpt_. what_process_selected internal procedure shares stack frame of external procedure amu_fdump_mpt_. create_proc_table internal procedure shares stack frame of external procedure amu_fdump_mpt_. init_process_table internal procedure shares stack frame of external procedure amu_fdump_mpt_. set_for_proc internal procedure shares stack frame of external procedure amu_fdump_mpt_. fill_ptrs internal procedure shares stack frame of external procedure amu_fdump_mpt_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME amu_fdump_mpt_ 000100 t_ptr amu_fdump_mpt_ 000102 temp_ptr amu_fdump_mpt_ 000104 t_segno amu_fdump_mpt_ 000105 ignore amu_fdump_mpt_ 000106 af_sw amu_fdump_mpt_ 000107 index_changed amu_fdump_mpt_ 000110 range amu_fdump_mpt_ 000112 data_buf_ptr amu_fdump_mpt_ 000114 t_data amu_fdump_mpt_ 000124 t_offset amu_fdump_mpt_ 000125 pid amu_fdump_mpt_ 000137 code amu_fdump_mpt_ 000140 prev_segno amu_fdump_mpt_ 000141 segx amu_fdump_mpt_ 000142 process_idx amu_fdump_mpt_ 000143 n_processes amu_fdump_mpt_ 000144 segment_ptr amu_fdump_mpt_ 000146 total_offset amu_fdump_mpt_ 000150 search_dbr amu_fdump_mpt_ 000151 cpu_name amu_fdump_mpt_ 000152 cpu_tag_offset amu_fdump_mpt_ 000153 temp_translation amu_fdump_mpt_ 000166 i amu_fdump_mpt_ 000170 amu_info_ptr amu_fdump_mpt_ 000172 fp_table_ptr amu_fdump_mpt_ 000174 alloc_fdump_process_table_size amu_fdump_mpt_ 000176 aptep amu_fdump_mpt_ 000200 dumpptr amu_fdump_mpt_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as alloc_char_temp cat_realloc_chars call_ext_out_desc call_ext_out return_mac mdfx3 enable_op shorten_stack ext_entry ext_entry_desc int_entry divide_fx3 op_alloc_ op_freen_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. amu_$definition_offset amu_$definition_ptr amu_$do_translation amu_$fdump_mpt_revert_idx amu_$fdump_mpt_temp_change_idx amu_$fdump_translate_contiguous amu_$hardcore_info_fdump amu_$return_val_idx_from_dbr amu_$return_val_per_process amu_$tc_data_find_apte amu_$tc_data_find_first_running amu_$translate_add amu_$translate_allocate amu_$translate_force_add com_err_ get_temp_segment_ ioa_ ioa_$rsnnl release_temp_segment_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. amu_et_$apte_not_found amu_et_$big_idx amu_et_$not_fdump amu_et_$trans_exists LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 86 000230 17 000233 142 000256 143 000257 144 000263 145 000266 146 000271 147 000272 148 000306 149 000340 150 000341 151 000343 152 000344 153 000355 156 000365 157 000370 158 000372 160 000373 162 000375 164 000412 165 000415 166 000436 167 000453 168 000470 170 000503 171 000504 172 000506 174 000515 181 000520 182 000522 183 000526 184 000531 187 000545 188 000555 190 000563 191 000567 192 000570 193 000577 194 000601 195 000606 199 000620 201 000655 202 000662 203 000664 204 000667 205 000672 207 000673 208 000676 212 000706 213 000717 214 000721 215 000723 216 000727 218 000730 219 000733 220 000740 222 000741 224 000745 225 000760 228 000765 229 001010 230 001012 231 001013 234 001014 235 001053 237 001055 239 001060 240 001067 241 001071 242 001076 244 001077 246 001117 248 001135 249 001140 252 001142 253 001155 256 001161 257 001174 260 001200 262 001202 263 001227 265 001231 266 001233 268 001276 269 001300 271 001311 273 001317 275 001361 276 001363 277 001374 279 001402 281 001433 283 001434 285 001445 286 001451 287 001452 288 001453 290 001454 292 001466 293 001472 294 001474 295 001475 297 001476 299 001513 300 001517 301 001523 302 001525 303 001533 305 001534 307 001547 308 001553 309 001557 310 001565 313 001566 315 001576 316 001602 317 001606 318 001614 321 001615 324 001636 325 001642 326 001650 327 001654 328 001657 330 001660 331 001661 332 001666 333 001670 335 001672 336 001677 338 001717 339 001721 341 001730 342 001733 344 001734 345 001735 346 001745 347 001755 350 001776 351 002000 352 002020 353 002021 356 002022 358 002031 359 002034 361 002035 363 002037 364 002046 367 002047 370 002057 371 002063 372 002070 373 002077 374 002106 375 002114 376 002116 378 002126 381 002127 389 002131 390 002150 391 002152 393 002164 394 002206 395 002211 396 002220 398 002221 401 002222 405 002223 406 002225 407 002231 409 002270 411 002313 412 002315 413 002350 414 002407 416 002411 417 002426 420 002511 425 002564 427 002565 430 002566 431 002570 432 002574 434 002633 435 002656 438 002720 441 002721 445 002722 446 002726 447 002727 448 002733 449 002734 451 002737 452 002755 453 002757 454 003004 456 003005 457 003012 458 003015 459 003017 461 003027 463 003030 464 003033 465 003035 470 003045 471 003047 472 003053 473 003056 474 003060 475 003062 476 003065 477 003100 478 003105 479 003106 480 003110 481 003114 482 003121 483 003127 484 003135 485 003143 486 003151 487 003157 488 003165 491 003173 492 003177 496 003202 500 003203 502 003204 503 003213 504 003215 505 003216 506 003217 507 003222 508 003225 509 003230 511 003233 514 003234 518 003236 519 003241 520 003243 521 003250 522 003253 525 003254 530 003256 531 003276 532 003303 533 003313 534 003320 536 003321 537 003331 539 003336 540 003363 543 003414 ----------------------------------------------------------- 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