COMPILATION LISTING OF SEGMENT copy_erf_seg_ Compiled by: Multics PL/I Compiler, Release 28d, of October 4, 1983 Compiled at: Honeywell Multics Op. - System M Compiled on: 11/21/84 1041.8 mst Wed Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 12 /* Extract segments from a Multics dump */ 13 14 /* Created: by C. Hornig */ 15 /* Modified: 24 February 1981 by J. A. Bush for larger fdump header size */ 16 /* Modified: 29 December 1981 by G. Palter to not fault when asked about the same dump multiple times and to not reference 17* a non-existant error code */ 18 /* Modified: October 1984 by Greg Texada to use amu_ and change Erf to character. */ 19 20 /* format: style4,delnl,insnl,ifthenstmt,ifthen */ 21 22 23 copy_erf_seg_: 24 procedure (Erf, Segno, Out_ptr, Out_len, Code); 25 26 27 dcl Erf char (*) parameter; /* ERF number */ 28 29 dcl Segno fixed binary (15) unsigned parameter; /* segment to copy out */ 30 dcl Segname character (*) parameter; /* name of segment to copy out */ 31 32 dcl Out_ptr pointer parameter; /* where to copy */ 33 dcl Out_len fixed binary (19) unsigned parameter; /* how long it was */ 34 35 dcl Code fixed binary (35) parameter; 36 37 dcl cleanup condition; 38 39 dcl (addr, baseno, baseptr, binary, null, pointer) builtin; 40 41 dcl amu_$fdump_mgr_init_fdump entry(char(*), ptr, ptr, fixed bin(35)), 42 amu_$find_system_fdump entry (char(*), ptr, fixed bin(35)), 43 amu_$terminate_translation entry (ptr), 44 amu_$do_translation entry (ptr, fixed bin, ptr, fixed bin(18), fixed bin(18), fixed bin(35)), 45 amu_$hardcore_info_set_cur_ptrs entry (ptr, ptr); 46 47 dcl sys_info$max_seg_size fixed bin (35) ext static; 48 dcl hcs_$set_bc_seg entry (ptr, fixed bin(24), fixed bin(35)); 49 dcl hcs_$truncate_seg entry (ptr, uns fixed bin (19), fixed bin (35)); 50 dcl ring0_get_$segptr_given_slt entry (char (*), char (*), ptr, fixed bin (35), ptr, ptr); 51 dcl ring0_get_$segptr entry (char (*), char (*), ptr, fixed bin (35)); 52 dcl ring_zero_peek_ entry (ptr, ptr, uns fixed bin (19), fixed bin (35)); 53 54 dcl segno uns fixed bin (15); 55 dcl segname char (32); 56 dcl optr ptr; 57 dcl segp ptr; 58 dcl sdw_hold bit (72) aligned; 59 dcl seg_size uns fixed bin (19); 60 dcl offset fixed bin (18); 61 dcl range fixed bin (18); 62 63 /* */ 64 65 /* Extract a segment by segment number */ 66 /* copy_erf_seg_: 67* entry (Erf, Segno, Out_ptr, Out_len, Code); */ 68 69 segno = Segno; 70 segname = ""; /* flag that we ARE the number entry */ 71 goto common_amu; 72 73 74 /* Extract a segment by name */ 75 76 name: 77 entry (Erf, Segname, Out_ptr, Out_len, Code); 78 79 80 segname = Segname; /* Flag that we are the name entry */ 81 common_amu: 82 Code = 0; 83 optr = Out_ptr; 84 if Erf = "-1" then do; /* wants data form the running system */ 85 if Segname ^= "" then 86 goto OLD_WAY_FOR_RUNNING_SYSTEM_NAME; 87 else goto OLD_WAY_FOR_RUNNING_SYSTEM_NO; 88 89 end; 90 amu_info_ptr = null (); /* so below will make one for us */ 91 on cleanup 92 begin; 93 if amu_info_ptr ^= null () then call amu_$terminate_translation (amu_info_ptr); 94 end; 95 system_dump_info_ptr = addr (sdi); 96 sdi.version = SYSTEM_DUMP_INFO_VERSION_1; 97 sdi.dump_dir_name, sdi.dump_seg_prefix, sdi.dump_name, sdi.dump_entry_format = ""; 98 call amu_$find_system_fdump (Erf, system_dump_info_ptr, Code); 99 /* uses the dumps search list to find */ 100 if Code ^= 0 then goto return_to_caller_amu; /* the erf */ 101 call amu_$fdump_mgr_init_fdump ("copy_erf_seg_", system_dump_info_ptr, amu_info_ptr, Code); 102 if Code ^= 0 then goto return_to_caller_amu; 103 if segname ^= "" then do; /* name entry, get hardcore info */ 104 call amu_$hardcore_info_set_cur_ptrs (amu_info_ptr, addr (local_hardcore)); 105 106 call ring0_get_$segptr_given_slt ("", segname, segp, Code, local_hardcore.sltp, local_hardcore.sltntp); 107 if Code ^= 0 then goto return_to_caller_amu; 108 segno = binary (baseno (segp), 15); 109 end; 110 111 call hcs_$truncate_seg (optr, 0, (0)); /* ok, all the same from here on.. */ 112 offset = 0; 113 range = sys_info$max_seg_size; /* because amu_ wants to WRITE to it! */ 114 call amu_$do_translation (amu_info_ptr, (segno), optr, offset, range, Code); 115 if Code = 0 then call hcs_$set_bc_seg(optr, (range * 36), Code); 116 return_to_caller_amu: 117 if amu_info_ptr ^= null () then call amu_$terminate_translation (amu_info_ptr); 118 return; 119 120 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 121 122 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 123 124 125 OLD_WAY_FOR_RUNNING_SYSTEM_NO: 126 segno = Segno; 127 goto common; 128 129 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 130 131 132 OLD_WAY_FOR_RUNNING_SYSTEM_NAME: 133 segname = Segname; 134 call ring0_get_$segptr ("", segname, segp, Code); 135 if Code ^= 0 then return; 136 segno = binary (baseno (segp), 15); 137 138 common: 139 call hcs_$truncate_seg (optr, 0, (0)); 140 sdwp = addr (sdw_hold); 141 call ring_zero_peek_ (pointer (baseptr (0), 2 * segno), sdwp, 2, Code); 142 /* get SDW */ 143 if Code ^= 0 then return; 144 seg_size = 16 * (1 + binary (sdw.bound, 14)); 145 segp = baseptr (segno); 146 call ring_zero_peek_ (segp, optr, seg_size, Code); 147 if Code ^= 0 then return; 148 Out_len = seg_size; 149 return_to_caller: 150 return; 151 152 /* */ 1 1 /* BEGIN INCLUDE FILE ... sdw.incl.pl1 ... last modified 12 May 1976 */ 1 2 1 3 dcl sdwp ptr; 1 4 1 5 dcl 1 sdw based (sdwp) aligned, /* Segment Descriptor Word */ 1 6 1 7 (2 add bit (24), /* main memory address of page table */ 1 8 2 (r1, r2, r3) bit (3), /* ring brackets for the segment */ 1 9 2 df bit (1), /* directed fault bit (0 => fault) */ 1 10 2 df_no bit (2), /* directed fault number */ 1 11 1 12 2 pad1 bit (1), 1 13 2 bound bit (14), /* boundary field (in 16 word blocks) */ 1 14 2 access, /* access bits */ 1 15 3 read bit (1), /* read permission bit */ 1 16 3 execute bit (1), /* execute permission bit */ 1 17 3 write bit (1), /* write permission bit */ 1 18 3 privileged bit (1), /* privileged bit */ 1 19 2 unpaged bit (1), /* segment is unpaged if this is 1 */ 1 20 2 entry_bound_sw bit (1), /* if this is 0 the entry bound is checked by hardware */ 1 21 2 cache bit (1), /* cache enable bit */ 1 22 2 entry_bound bit (14)) unaligned; /* entry bound */ 1 23 1 24 dcl 1 sdwa (0: 1) based (sdwp) aligned like sdw; /* SDW array (descriptor segment) */ 1 25 1 26 /* END INCLUDE FILE sdw.incl.pl1 */ 153 154 2 1 /* Begin include file system_dump_info.incl.pl1 */ 2 2 /* format: style3,idind30 */ 2 3 2 4 /* Information needed to get set up on an fdump */ 2 5 2 6 declare system_dump_info_ptr pointer; 2 7 declare 1 system_dump_info aligned based (system_dump_info_ptr), 2 8 2 version char (8) aligned, 2 9 2 dump_dir_name char (168) unaligned, 2 10 2 dump_seg_prefix char (32) varying, /* includes last ., not component number */ 2 11 2 dump_name char (32) varying, /* Usually ERF number */ 2 12 2 dump_entry_format char (40) unaligned;/* ioa_ string that you feed the component number into */ 2 13 2 14 declare SYSTEM_DUMP_INFO_VERSION_1 char (8) init ("sysd0001") int static options (constant); 2 15 2 16 declare system_dump_list_ptr pointer; 2 17 declare 1 system_dump_list aligned based (system_dump_list_ptr), 2 18 2 version char (8) aligned, 2 19 2 n_dumps fixed bin, 2 20 2 per_dump (system_dump_list_n_dumps refer (system_dump_list.n_dumps)) aligned, 2 21 3 dir_name char (168) unaligned, 2 22 3 minimal_entryname char (32) unaligned,/* for non-dup's, just number */ 2 23 3 full_entryname char (32) unaligned,/* component 0 entryname */ 2 24 3 new_directory bit (1) aligned, /* first of its dir */ 2 25 3 duplicate bit (1) aligned; /* on if more than one ERF N in same directory */ 2 26 2 27 declare system_dump_list_n_dumps fixed bin; 2 28 declare SYSTEM_DUMP_LIST_VERSION_1 char (8) aligned init ("sysdl001") int static options (constant); 2 29 2 30 declare (LIST_ALL fixed bin init (1), 2 31 LIST_FDUMPS fixed bin init (2), 2 32 LIST_PDIRS fixed bin init (3)) 2 33 int static options (constant); 2 34 2 35 /* End include file system_dump_info.incl.pl1 */ 155 156 157 dcl 1 sdi like system_dump_info; 158 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 */ 159 160 161 4 1 /* BEGIN INCLUDE FILE amu_hardcore_info.incl.pl1 */ 4 2 4 3 /* This structure contains information about the hardcore supervisor address 4 4* space for an address translation. */ 4 5 4 6 dcl 1 hardcore_info aligned based (amu_info.hardcore_info_ptr), 4 7 4 8 2 pointers, /* assorted pointers to various useful items */ 4 9 3 slt aligned, /* SLT */ 4 10 4 fptr pointer unaligned, /* address in foreign address space */ 4 11 4 lptr pointer unaligned, /* location in local address space */ 4 12 3 sltnt aligned like hardcore_info.slt, /* SLT names segment */ 4 13 3 definitions aligned like hardcore_info.slt, /* hardcore definitions_ segment */ 4 14 4 15 3 sst aligned like hardcore_info.slt, /* SST */ 4 16 3 tc_data aligned like hardcore_info.slt, /* TC_DATA */ 4 17 3 sstnt aligned like hardcore_info.slt, /* SSTNT (if any -- foreign_ptr = null if not) */ 4 18 3 upt aligned like hardcore_info.slt, /* unpaged_page_tables (if any -- foreign_ptr = null if not) */ 4 19 4 20 2 segno, /* segment numbers of various per-process/per-processor segs */ 4 21 3 prds fixed bin (15), /* segno of PRDS */ 4 22 3 dseg fixed bin (15), /* DSEG */ 4 23 3 pds fixed bin (15), /* PDS */ 4 24 3 kst fixed bin (15), /* KST */ 4 25 3 stack_0 fixed bin (15), /* segno of stack_0 -- first one in stack group */ 4 26 3 unpaged_page_tables fixed bin(15), /* segno of unpaged_page_tables if it exists */ 4 27 4 28 2 apt, /* information about the APT */ 4 29 3 foreign_ptr pointer unaligned, /* foreign and local pointers to tcm.apt */ 4 30 3 local_ptr pointer unaligned, 4 31 3 count fixed bin, /* number of APTEs */ 4 32 3 size fixed bin, /* size of a single APTE */ 4 33 4 34 2 hcs_count fixed bin, /* highest hardcore segno */ 4 35 4 36 2 pad1 fixed bin; 4 37 4 38 dcl hardcore_cur_ptr ptr; 4 39 4 40 dcl 1 hardcore_cur based (hardcore_cur_ptr), 4 41 2 sltp ptr, 4 42 2 sltntp ptr, 4 43 2 defp ptr, 4 44 2 sstp ptr, 4 45 2 tc_datap ptr, 4 46 2 sstntp ptr, 4 47 2 uptp ptr; 4 48 4 49 4 50 4 51 4 52 /* END INCLUDE FILE amu_hardcore_info.incl.pl1 */ 162 163 dcl 1 local_hardcore like hardcore_cur; 164 165 166 167 168 169 170 171 end copy_erf_seg_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/21/84 1034.8 copy_erf_seg_.pl1 >spec>on>7046-11/21/84>copy_erf_seg_.pl1 153 1 09/14/76 0759.8 sdw.incl.pl1 >ldd>include>sdw.incl.pl1 155 2 11/20/84 0854.8 system_dump_info.incl.pl1 >ldd>include>system_dump_info.incl.pl1 159 3 11/20/84 0856.1 amu_info.incl.pl1 >ldd>include>amu_info.incl.pl1 162 4 11/20/84 0854.8 amu_hardcore_info.incl.pl1 >ldd>include>amu_hardcore_info.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. Code parameter fixed bin(35,0) dcl 35 set ref 23 76 81* 98* 100 101* 102 106* 107 114* 115 115* 134* 135 141* 143 146* 147 Erf parameter char unaligned dcl 27 set ref 23 76 84 98* Out_len parameter fixed bin(19,0) unsigned dcl 33 set ref 23 76 148* Out_ptr parameter pointer dcl 32 ref 23 76 83 SYSTEM_DUMP_INFO_VERSION_1 000000 constant char(8) initial unaligned dcl 2-14 ref 96 Segname parameter char unaligned dcl 30 ref 76 80 85 132 Segno parameter fixed bin(15,0) unsigned dcl 29 ref 23 69 125 addr builtin function dcl 39 ref 95 104 104 140 amu_$do_translation 000016 constant entry external dcl 41 ref 114 amu_$fdump_mgr_init_fdump 000010 constant entry external dcl 41 ref 101 amu_$find_system_fdump 000012 constant entry external dcl 41 ref 98 amu_$hardcore_info_set_cur_ptrs 000020 constant entry external dcl 41 ref 104 amu_$terminate_translation 000014 constant entry external dcl 41 ref 93 116 amu_info_ptr 000246 automatic pointer dcl 3-45 set ref 90* 93 93* 101* 104* 114* 116 116* baseno builtin function dcl 39 ref 108 136 baseptr builtin function dcl 39 ref 141 141 145 binary builtin function dcl 39 ref 108 136 144 bound 1(01) based bit(14) level 2 packed unaligned dcl 1-5 ref 144 cleanup 000100 stack reference condition dcl 37 ref 91 dump_dir_name 2 000136 automatic char(168) level 2 packed unaligned dcl 157 set ref 97* dump_entry_format 76 000136 automatic char(40) level 2 packed unaligned dcl 157 set ref 97* dump_name 65 000136 automatic varying char(32) level 2 dcl 157 set ref 97* dump_seg_prefix 54 000136 automatic varying char(32) level 2 dcl 157 set ref 97* hardcore_cur based structure level 1 unaligned dcl 4-40 hardcore_info based structure level 1 dcl 4-6 hcs_$set_bc_seg 000024 constant entry external dcl 48 ref 115 hcs_$truncate_seg 000026 constant entry external dcl 49 ref 111 138 local_hardcore 000250 automatic structure level 1 unaligned dcl 163 set ref 104 104 null builtin function dcl 39 ref 90 93 116 offset 000127 automatic fixed bin(18,0) dcl 60 set ref 112* 114* optr 000120 automatic pointer dcl 56 set ref 83* 111* 114* 115* 138* 146* pointer builtin function dcl 39 ref 141 141 pointers based structure level 2 dcl 4-6 range 000130 automatic fixed bin(18,0) dcl 61 set ref 113* 114* 115 ring0_get_$segptr 000032 constant entry external dcl 51 ref 134 ring0_get_$segptr_given_slt 000030 constant entry external dcl 50 ref 106 ring_zero_peek_ 000034 constant entry external dcl 52 ref 141 146 sdi 000136 automatic structure level 1 unaligned dcl 157 set ref 95 sdw based structure level 1 dcl 1-5 sdw_hold 000124 automatic bit(72) dcl 58 set ref 140 sdwp 000132 automatic pointer dcl 1-3 set ref 140* 141* 144 seg_size 000126 automatic fixed bin(19,0) unsigned dcl 59 set ref 144* 146* 148 segname 000107 automatic char(32) unaligned dcl 55 set ref 70* 80* 103 106* 132* 134* segno 000106 automatic fixed bin(15,0) unsigned dcl 54 set ref 69* 108* 114 125* 136* 141 141 145 segp 000122 automatic pointer dcl 57 set ref 106* 108 134* 136 145* 146* slt based structure level 3 dcl 4-6 sys_info$max_seg_size 000022 external static fixed bin(35,0) dcl 47 ref 113 system_dump_info based structure level 1 dcl 2-7 system_dump_info_ptr 000134 automatic pointer dcl 2-6 set ref 95* 98* 101* version 000136 automatic char(8) level 2 dcl 157 set ref 96* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. 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 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 LIST_ALL internal static fixed bin(17,0) initial dcl 2-30 LIST_FDUMPS internal static fixed bin(17,0) initial dcl 2-30 LIST_PDIRS internal static fixed bin(17,0) initial dcl 2-30 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 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 SAVED_PROC_TYPE internal static fixed bin(17,0) initial dcl 3-47 SYSTEM_DUMP_LIST_VERSION_1 internal static char(8) initial dcl 2-28 amu_area based area(1024) dcl 3-43 amu_info based structure level 1 dcl 3-3 hardcore_cur_ptr automatic pointer dcl 4-38 sdwa based structure array level 1 dcl 1-24 system_dump_list based structure level 1 dcl 2-17 system_dump_list_n_dumps automatic fixed bin(17,0) dcl 2-27 system_dump_list_ptr automatic pointer dcl 2-16 NAMES DECLARED BY EXPLICIT CONTEXT. OLD_WAY_FOR_RUNNING_SYSTEM_NAME 000443 constant label dcl 132 ref 85 OLD_WAY_FOR_RUNNING_SYSTEM_NO 000440 constant label dcl 125 ref 87 common 000502 constant label dcl 138 set ref 127 common_amu 000104 constant label dcl 81 ref 71 copy_erf_seg_ 000027 constant entry external dcl 23 name 000056 constant entry external dcl 76 return_to_caller 000612 constant label dcl 149 return_to_caller_amu 000424 constant label dcl 116 ref 100 102 107 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1012 1050 614 1022 Length 1326 614 36 241 175 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME copy_erf_seg_ 248 external procedure is an external procedure. on unit on line 91 68 on unit STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME copy_erf_seg_ 000106 segno copy_erf_seg_ 000107 segname copy_erf_seg_ 000120 optr copy_erf_seg_ 000122 segp copy_erf_seg_ 000124 sdw_hold copy_erf_seg_ 000126 seg_size copy_erf_seg_ 000127 offset copy_erf_seg_ 000130 range copy_erf_seg_ 000132 sdwp copy_erf_seg_ 000134 system_dump_info_ptr copy_erf_seg_ 000136 sdi copy_erf_seg_ 000246 amu_info_ptr copy_erf_seg_ 000250 local_hardcore copy_erf_seg_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out return enable ext_entry_desc int_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. amu_$do_translation amu_$fdump_mgr_init_fdump amu_$find_system_fdump amu_$hardcore_info_set_cur_ptrs amu_$terminate_translation hcs_$set_bc_seg hcs_$truncate_seg ring0_get_$segptr ring0_get_$segptr_given_slt ring_zero_peek_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. sys_info$max_seg_size LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 23 000022 69 000042 70 000045 71 000050 76 000051 80 000076 81 000104 83 000106 84 000111 85 000117 87 000125 90 000126 91 000130 93 000144 94 000157 95 000160 96 000162 97 000164 98 000174 100 000217 101 000222 102 000252 103 000255 104 000261 106 000274 107 000330 108 000333 111 000337 112 000354 113 000355 114 000360 115 000403 116 000424 118 000437 125 000440 127 000442 132 000443 134 000446 135 000473 136 000476 138 000502 140 000517 141 000521 143 000552 144 000555 145 000564 146 000570 147 000605 148 000610 149 000612 ----------------------------------------------------------- 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