COMPILATION LISTING OF SEGMENT call_outer_ring_ Compiled by: Multics PL/I Compiler, Release 32f, of October 9, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 11/11/89 0958.6 mst Sat Options: optimize map 1 /****^ ****************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright (c) 1987 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* * Copyright (c) 1972 by Massachusetts Institute of * 9* * Technology and Honeywell Information Systems, Inc. * 10* * * 11* ****************************************************** */ 12 13 /* format: style2 */ 14 /* call_outer_ring_ -- prepares faked outward call via rtcd */ 15 /* From outward_call_handler Benson I. Margulies April 1981 */ 16 17 /* 830529 BIM Fixed not to try to set validation level < execution level. */ 18 19 call_outer_ring_: 20 procedure (a_ref_ptr, a_segname, a_entrypoint, a_ring_to_call, a_code); 21 22 declare a_ref_ptr pointer; 23 declare (a_segname, a_entrypoint) 24 character (*); 25 declare a_ring_to_call fixed bin (3); 26 declare a_code fixed bin (35); 27 28 dcl 1 arglist_and_ptr aligned based, /* argument list header FOUR WORDS LONG */ 29 2 arg_count fixed bin (17) unal, 30 2 code fixed bin (17) unal, 31 2 desc_count fixed bin (17) unal, 32 2 pad fixed bin (17) unal, 33 2 rtcd_ptr aligned like its_unsigned; 34 35 dcl 1 given_its aligned like its_unsigned; 36 37 /* goodies in case we are in ring 0 */ 38 39 dcl pds$highest_ring fixed bin (3) external; 40 /* highest permissable ring for process */ 41 dcl pds$initial_ring fixed bin (3) ext; /* initial non-hardcore ring for process */ 42 dcl pds$ips_mask (0:7) bit (36) aligned ext; 43 /* IPS mask for each ring */ 44 dcl pds$stacks (0:7) pointer external; 45 dcl pds$first_call fixed bin ext; /* non-zero until first call from Ring 0 */ 46 dcl active_all_rings_data$stack_base_segno 47 fixed bin (18) ext;/* segno of base of array of 8 stacks */ 48 49 dcl get_ring_ entry () returns (fixed bin (3)); 50 dcl hcs_$level_set entry (fixed bin (3)); 51 dcl hcs_$get_max_length_seg 52 entry (pointer, fixed bin (19), fixed bin (35)); 53 dcl hcs_$level_get entry returns (fixed bin (3)); 54 dcl hcs_$set_ips_mask entry (bit (36) aligned, bit (36) aligned); 55 dcl hcs_$make_ptr entry (ptr, char (*), char (*), ptr, fixed bin (35)); 56 dcl rtcd_util_ entry (pointer, pointer); 57 58 dcl (addrel, addr, baseptr, max, null) 59 builtin; 60 61 dcl ref_ptr pointer; 62 dcl segname character (32); 63 dcl entrypoint character (32); 64 dcl thing_to_call pointer; 65 dcl ring_to_call fixed bin (3); 66 dcl ap pointer; 67 dcl calling_ring fixed bin (3); 68 dcl calling_level fixed bin (3); 69 dcl code fixed bin (35); 70 dcl r fixed bin (3); 71 dcl stack_segno fixed bin; 72 dcl target_sb pointer; 73 dcl bit36 bit (36) aligned; 74 dcl based_bit36 based bit (36) aligned; 75 76 dcl ( 77 error_table_$badringno, 78 error_table_$action_not_performed, 79 error_table_$outward_call_failed 80 ) external static fixed bin (35); 81 82 dcl cleanup condition; 83 dcl any_other condition; 84 1 1 /* BEGIN INCLUDE FILE ... stack_header.incl.pl1 .. 3/72 Bill Silver */ 1 2 /* modified 7/76 by M. Weaver for *system links and more system use of areas */ 1 3 /* modified 3/77 by M. Weaver to add rnt_ptr */ 1 4 /* Modified April 1983 by C. Hornig for tasking */ 1 5 1 6 /****^ HISTORY COMMENTS: 1 7* 1) change(86-06-24,DGHowe), approve(86-06-24,MCR7396), 1 8* audit(86-08-05,Schroth), install(86-11-03,MR12.0-1206): 1 9* added the heap_header_ptr definition. 1 10* 2) change(86-08-12,Kissel), approve(86-08-12,MCR7473), 1 11* audit(86-10-10,Fawcett), install(86-11-03,MR12.0-1206): 1 12* Modified to support control point management. These changes were actually 1 13* made in February 1985 by G. Palter. 1 14* 3) change(86-10-22,Fawcett), approve(86-10-22,MCR7473), 1 15* audit(86-10-22,Farley), install(86-11-03,MR12.0-1206): 1 16* Remove the old_lot pointer and replace it with cpm_data_ptr. Use the 18 1 17* bit pad after cur_lot_size for the cpm_enabled. This was done to save some 1 18* space int the stack header and change the cpd_ptr unal to cpm_data_ptr 1 19* (ITS pair). 1 20* END HISTORY COMMENTS */ 1 21 1 22 /* format: style2 */ 1 23 1 24 dcl sb ptr; /* the main pointer to the stack header */ 1 25 1 26 dcl 1 stack_header based (sb) aligned, 1 27 2 pad1 (4) fixed bin, /* (0) also used as arg list by outward_call_handler */ 1 28 2 cpm_data_ptr ptr, /* (4) pointer to control point which owns this stack */ 1 29 2 combined_stat_ptr ptr, /* (6) pointer to area containing separate static */ 1 30 2 clr_ptr ptr, /* (8) pointer to area containing linkage sections */ 1 31 2 max_lot_size fixed bin (17) unal, /* (10) DU number of words allowed in lot */ 1 32 2 main_proc_invoked fixed bin (11) unal, /* (10) DL nonzero if main procedure invoked in run unit */ 1 33 2 have_static_vlas bit (1) unal, /* (10) DL "1"b if (very) large arrays are being used in static */ 1 34 2 pad4 bit (2) unal, 1 35 2 run_unit_depth fixed bin (2) unal, /* (10) DL number of active run units stacked */ 1 36 2 cur_lot_size fixed bin (17) unal, /* (11) DU number of words (entries) in lot */ 1 37 2 cpm_enabled bit (18) unal, /* (11) DL non-zero if control point management is enabled */ 1 38 2 system_free_ptr ptr, /* (12) pointer to system storage area */ 1 39 2 user_free_ptr ptr, /* (14) pointer to user storage area */ 1 40 2 null_ptr ptr, /* (16) */ 1 41 2 stack_begin_ptr ptr, /* (18) pointer to first stack frame on the stack */ 1 42 2 stack_end_ptr ptr, /* (20) pointer to next useable stack frame */ 1 43 2 lot_ptr ptr, /* (22) pointer to the lot for the current ring */ 1 44 2 signal_ptr ptr, /* (24) pointer to signal procedure for current ring */ 1 45 2 bar_mode_sp ptr, /* (26) value of sp before entering bar mode */ 1 46 2 pl1_operators_ptr ptr, /* (28) pointer to pl1_operators_$operator_table */ 1 47 2 call_op_ptr ptr, /* (30) pointer to standard call operator */ 1 48 2 push_op_ptr ptr, /* (32) pointer to standard push operator */ 1 49 2 return_op_ptr ptr, /* (34) pointer to standard return operator */ 1 50 2 return_no_pop_op_ptr 1 51 ptr, /* (36) pointer to standard return / no pop operator */ 1 52 2 entry_op_ptr ptr, /* (38) pointer to standard entry operator */ 1 53 2 trans_op_tv_ptr ptr, /* (40) pointer to translator operator ptrs */ 1 54 2 isot_ptr ptr, /* (42) pointer to ISOT */ 1 55 2 sct_ptr ptr, /* (44) pointer to System Condition Table */ 1 56 2 unwinder_ptr ptr, /* (46) pointer to unwinder for current ring */ 1 57 2 sys_link_info_ptr ptr, /* (48) pointer to *system link name table */ 1 58 2 rnt_ptr ptr, /* (50) pointer to Reference Name Table */ 1 59 2 ect_ptr ptr, /* (52) pointer to event channel table */ 1 60 2 assign_linkage_ptr ptr, /* (54) pointer to storage for (obsolete) hcs_$assign_linkage */ 1 61 2 heap_header_ptr ptr, /* (56) pointer to the heap header for this ring */ 1 62 2 trace, 1 63 3 frames, 1 64 4 count fixed bin, /* (58) number of trace frames */ 1 65 4 top_ptr ptr unal, /* (59) pointer to last trace frame */ 1 66 3 in_trace bit (36) aligned, /* (60) trace antirecursion flag */ 1 67 2 pad2 bit (36), /* (61) */ 1 68 2 pad5 pointer; /* (62) pointer to future stuff */ 1 69 1 70 /* The following offset refers to a table within the pl1 operator table. */ 1 71 1 72 dcl tv_offset fixed bin init (361) internal static; 1 73 /* (551) octal */ 1 74 1 75 1 76 /* The following constants are offsets within this transfer vector table. */ 1 77 1 78 dcl ( 1 79 call_offset fixed bin init (271), 1 80 push_offset fixed bin init (272), 1 81 return_offset fixed bin init (273), 1 82 return_no_pop_offset fixed bin init (274), 1 83 entry_offset fixed bin init (275) 1 84 ) internal static; 1 85 1 86 1 87 1 88 1 89 1 90 /* The following declaration is an overlay of the whole stack header. Procedures which 1 91* move the whole stack header should use this overlay. 1 92**/ 1 93 1 94 dcl stack_header_overlay (size (stack_header)) fixed bin based (sb); 1 95 1 96 1 97 1 98 /* END INCLUDE FILE ... stack_header.incl.pl1 */ 85 2 1 /* BEGIN INCLUDE FILE its.incl.pl1 2 2* modified 27 July 79 by JRDavis to add its_unsigned 2 3* Internal format of ITS pointer, including ring-number field for follow-on processor */ 2 4 2 5 dcl 1 its based aligned, /* declaration for ITS type pointer */ 2 6 2 pad1 bit (3) unaligned, 2 7 2 segno bit (15) unaligned, /* segment number within the pointer */ 2 8 2 ringno bit (3) unaligned, /* ring number within the pointer */ 2 9 2 pad2 bit (9) unaligned, 2 10 2 its_mod bit (6) unaligned, /* should be 43(8) */ 2 11 2 12 2 offset bit (18) unaligned, /* word offset within the addressed segment */ 2 13 2 pad3 bit (3) unaligned, 2 14 2 bit_offset bit (6) unaligned, /* bit offset within the word */ 2 15 2 pad4 bit (3) unaligned, 2 16 2 mod bit (6) unaligned; /* further modification */ 2 17 2 18 dcl 1 itp based aligned, /* declaration for ITP type pointer */ 2 19 2 pr_no bit (3) unaligned, /* number of pointer register to use */ 2 20 2 pad1 bit (27) unaligned, 2 21 2 itp_mod bit (6) unaligned, /* should be 41(8) */ 2 22 2 23 2 offset bit (18) unaligned, /* word offset from pointer register word offset */ 2 24 2 pad2 bit (3) unaligned, 2 25 2 bit_offset bit (6) unaligned, /* bit offset relative to new word offset */ 2 26 2 pad3 bit (3) unaligned, 2 27 2 mod bit (6) unaligned; /* further modification */ 2 28 2 29 2 30 dcl 1 its_unsigned based aligned, /* just like its, but with unsigned binary */ 2 31 2 pad1 bit (3) unaligned, 2 32 2 segno fixed bin (15) unsigned unaligned, 2 33 2 ringno fixed bin (3) unsigned unaligned, 2 34 2 pad2 bit (9) unaligned, 2 35 2 its_mod bit (6) unaligned, 2 36 2 37 2 offset fixed bin (18) unsigned unaligned, 2 38 2 pad3 bit (3) unaligned, 2 39 2 bit_offset fixed bin (6) unsigned unaligned, 2 40 2 pad4 bit (3) unaligned, 2 41 2 mod bit (6) unaligned; 2 42 2 43 dcl 1 itp_unsigned based aligned, /* just like itp, but with unsigned binary where appropriate */ 2 44 2 pr_no fixed bin (3) unsigned unaligned, 2 45 2 pad1 bit (27) unaligned, 2 46 2 itp_mod bit (6) unaligned, 2 47 2 48 2 offset fixed bin (18) unsigned unaligned, 2 49 2 pad2 bit (3) unaligned, 2 50 2 bit_offset fixed bin (6) unsigned unaligned, 2 51 2 pad3 bit (3) unaligned, 2 52 2 mod bit (6) unaligned; 2 53 2 54 2 55 dcl ITS_MODIFIER bit (6) unaligned internal static options (constant) init ("43"b3); 2 56 dcl ITP_MODIFIER bit (6) unaligned internal static options (constant) init ("41"b3); 2 57 2 58 /* END INCLUDE FILE its.incl.pl1 */ 86 87 88 ref_ptr = a_ref_ptr; 89 segname = a_segname; 90 entrypoint = a_entrypoint; 91 ring_to_call = a_ring_to_call; 92 code = 0; 93 94 calling_ring = get_ring_ (); 95 calling_level = hcs_$level_get (); 96 on cleanup call clean_up; 97 98 if ring_to_call <= calling_ring 99 then do; 100 code = error_table_$badringno; 101 go to return_; 102 end; 103 104 if calling_ring = 0 105 then do; /* Call out from ring 0 */ 106 107 /* A process may make only one outward call from Ring 0 during its existence. 108* The target ring number of this call must be no less than the value 109* contained in pds$initial_ring. 110**/ 111 112 if pds$first_call = 0 113 then /* If this is not the first call from Ring 0 ... */ 114 do; 115 code = error_table_$action_not_performed; 116 go to return_; 117 end; 118 pds$first_call = 0; /* Indicate first call from Ring 0 is being accomplished. */ 119 if ring_to_call < pds$initial_ring 120 then do; 121 code = error_table_$badringno; 122 go to return_; 123 124 /* Don't allow call inside initial ring. */ 125 end; 126 end; 127 128 /* first insure existence of outer ring stack so we can snap links */ 129 130 stack_segno = active_all_rings_data$stack_base_segno + ring_to_call; 131 target_sb = baseptr (stack_segno); 132 bit36 = target_sb -> based_bit36; 133 134 /* now run make_ptr to get a link snapped to it so it has linkage in the 135* right ring */ 136 137 call hcs_$level_set (ring_to_call); 138 thing_to_call = null (); 139 call hcs_$make_ptr (ref_ptr, segname, entrypoint, thing_to_call, code); 140 if thing_to_call = null () /* no such luck */ 141 then go to return_; 142 code = 0; 143 call hcs_$level_set (calling_ring); /* back in for a while */ 144 do r = calling_ring to ring_to_call - 1; /* mask IPS signals in all lower rings */ 145 call hcs_$level_set (r); 146 call hcs_$set_ips_mask (""b, (""b)); 147 end; 148 149 call hcs_$level_set (ring_to_call); 150 151 /* once we enter this do loop we cannot return, regardless of 152* what happens. There is no stack history behind us. Oh well ... */ 153 154 on any_other go to terminate_the_process; 155 156 do r = calling_ring to ring_to_call; 157 if calling_ring = 0 158 then sb = pds$stacks (r); 159 else do; 160 stack_segno = active_all_rings_data$stack_base_segno + r; 161 sb = baseptr (stack_segno); 162 call hcs_$get_max_length_seg (sb, (0), code); 163 if code ^= 0 164 then do; 165 sb = null (); 166 code = 0; 167 end; 168 end; 169 if sb ^= null () 170 then /* If stack exists for ring ... */ 171 sb -> stack_header.stack_end_ptr = sb -> stack_header.stack_begin_ptr; 172 /* Reset stack. */ 173 end; 174 175 ap = target_sb; /* There are four words at the beginning reserved for this */ 176 177 ap -> arglist_and_ptr.arg_count, ap -> arglist_and_ptr.desc_count, ap -> arglist_and_ptr.pad = 0; 178 ap -> arglist_and_ptr.code = 4; /* Make a null argument list. */ 179 180 unspec (given_its) = unspec (thing_to_call); 181 ap -> arglist_and_ptr.rtcd_ptr = given_its; /* we must set ringno to tell rtcd where to go */ 182 ap -> arglist_and_ptr.rtcd_ptr.ringno = ring_to_call; 183 /* we go there */ 184 185 /* This program should be bound together with rtcd_util_ to insure 186* this call works. */ 187 188 call rtcd_util_ (addr (ap -> arglist_and_ptr.rtcd_ptr), ap); 189 190 go to terminate_the_process; 191 192 return_: 193 call clean_up; 194 a_code = code; 195 return; 196 clean_up: 197 procedure; 198 call hcs_$level_set (calling_level); 199 end clean_up; 200 201 terminate_the_process: 202 begin; 203 204 declare (baseptr, pointer) builtin; 205 declare other_deadly_reference fixed bin (35) based; 206 declare deadly_reference fixed bin (35); 207 208 nowhere_fast: 209 deadly_reference = pointer (baseptr (-2), -5) -> other_deadly_reference; 210 /* bang */ 211 go to nowhere_fast; /* what else is there to do? */ 212 213 end terminate_the_process; 214 215 end call_outer_ring_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/11/89 0804.7 call_outer_ring_.pl1 >spec>install>1110>call_outer_ring_.pl1 85 1 11/07/86 1550.3 stack_header.incl.pl1 >ldd>include>stack_header.incl.pl1 86 2 11/26/79 1320.6 its.incl.pl1 >ldd>include>its.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. a_code parameter fixed bin(35,0) dcl 26 set ref 19 194* a_entrypoint parameter char packed unaligned dcl 23 ref 19 90 a_ref_ptr parameter pointer dcl 22 ref 19 88 a_ring_to_call parameter fixed bin(3,0) dcl 25 ref 19 91 a_segname parameter char packed unaligned dcl 23 ref 19 89 active_all_rings_data$stack_base_segno 000016 external static fixed bin(18,0) dcl 46 ref 130 160 addr builtin function dcl 58 ref 188 188 any_other 000152 stack reference condition dcl 83 ref 154 ap 000130 automatic pointer dcl 66 set ref 175* 177 177 177 178 181 182 188 188 188* arg_count based fixed bin(17,0) level 2 packed packed unaligned dcl 28 set ref 177* arglist_and_ptr based structure level 1 dcl 28 based_bit36 based bit(36) dcl 74 ref 132 baseptr builtin function dcl 204 in begin block on line 201 ref 208 baseptr builtin function dcl 58 in procedure "call_outer_ring_" ref 131 161 bit36 000142 automatic bit(36) dcl 73 set ref 132* calling_level 000133 automatic fixed bin(3,0) dcl 68 set ref 95* 198* calling_ring 000132 automatic fixed bin(3,0) dcl 67 set ref 94* 98 104 143* 144 156 157 cleanup 000144 stack reference condition dcl 82 ref 96 code 000134 automatic fixed bin(35,0) dcl 69 in procedure "call_outer_ring_" set ref 92* 100* 115* 121* 139* 142* 162* 163 166* 194 code 0(18) based fixed bin(17,0) level 2 in structure "arglist_and_ptr" packed packed unaligned dcl 28 in procedure "call_outer_ring_" set ref 178* deadly_reference 000164 automatic fixed bin(35,0) dcl 206 set ref 208* desc_count 1 based fixed bin(17,0) level 2 packed packed unaligned dcl 28 set ref 177* entrypoint 000114 automatic char(32) packed unaligned dcl 63 set ref 90* 139* error_table_$action_not_performed 000040 external static fixed bin(35,0) dcl 76 ref 115 error_table_$badringno 000036 external static fixed bin(35,0) dcl 76 ref 100 121 get_ring_ 000020 constant entry external dcl 49 ref 94 given_its 000100 automatic structure level 1 dcl 35 set ref 180* 181 hcs_$get_max_length_seg 000024 constant entry external dcl 51 ref 162 hcs_$level_get 000026 constant entry external dcl 53 ref 95 hcs_$level_set 000022 constant entry external dcl 50 ref 137 143 145 149 198 hcs_$make_ptr 000032 constant entry external dcl 55 ref 139 hcs_$set_ips_mask 000030 constant entry external dcl 54 ref 146 its_unsigned based structure level 1 dcl 2-30 null builtin function dcl 58 ref 138 140 165 169 other_deadly_reference based fixed bin(35,0) dcl 205 ref 208 pad 1(18) based fixed bin(17,0) level 2 packed packed unaligned dcl 28 set ref 177* pds$first_call 000014 external static fixed bin(17,0) dcl 45 set ref 112 118* pds$initial_ring 000010 external static fixed bin(3,0) dcl 41 ref 119 pds$stacks 000012 external static pointer array dcl 44 ref 157 pointer builtin function dcl 204 ref 208 r 000135 automatic fixed bin(3,0) dcl 70 set ref 144* 145* 156* 157 160* ref_ptr 000102 automatic pointer dcl 61 set ref 88* 139* ring_to_call 000126 automatic fixed bin(3,0) dcl 65 set ref 91* 98 119 130 137* 144 149* 156 182 ringno 2(18) based fixed bin(3,0) level 3 packed packed unsigned unaligned dcl 28 set ref 182* rtcd_ptr 2 based structure level 2 dcl 28 set ref 181* 188 188 rtcd_util_ 000034 constant entry external dcl 56 ref 188 sb 000160 automatic pointer dcl 1-24 set ref 157* 161* 162* 165* 169 169 169 segname 000104 automatic char(32) packed unaligned dcl 62 set ref 89* 139* stack_begin_ptr 22 based pointer level 2 dcl 1-26 ref 169 stack_end_ptr 24 based pointer level 2 dcl 1-26 set ref 169* stack_header based structure level 1 dcl 1-26 stack_segno 000136 automatic fixed bin(17,0) dcl 71 set ref 130* 131 160* 161 target_sb 000140 automatic pointer dcl 72 set ref 131* 132 175 thing_to_call 000124 automatic pointer dcl 64 set ref 138* 139* 140 180 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ITP_MODIFIER internal static bit(6) initial packed unaligned dcl 2-56 ITS_MODIFIER internal static bit(6) initial packed unaligned dcl 2-55 addrel builtin function dcl 58 call_offset internal static fixed bin(17,0) initial dcl 1-78 entry_offset internal static fixed bin(17,0) initial dcl 1-78 error_table_$outward_call_failed external static fixed bin(35,0) dcl 76 itp based structure level 1 dcl 2-18 itp_unsigned based structure level 1 dcl 2-43 its based structure level 1 dcl 2-5 max builtin function dcl 58 pds$highest_ring external static fixed bin(3,0) dcl 39 pds$ips_mask external static bit(36) array dcl 42 push_offset internal static fixed bin(17,0) initial dcl 1-78 return_no_pop_offset internal static fixed bin(17,0) initial dcl 1-78 return_offset internal static fixed bin(17,0) initial dcl 1-78 stack_header_overlay based fixed bin(17,0) array dcl 1-94 tv_offset internal static fixed bin(17,0) initial dcl 1-72 NAMES DECLARED BY EXPLICIT CONTEXT. call_outer_ring_ 000022 constant entry external dcl 19 clean_up 000462 constant entry internal dcl 196 ref 96 192 nowhere_fast 000450 constant label dcl 208 set ref 211 return_ 000440 constant label dcl 192 ref 101 116 122 140 terminate_the_process 000450 constant label dcl 201 ref 154 190 NAME DECLARED BY CONTEXT OR IMPLICATION. unspec builtin function ref 180 180 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 712 754 477 722 Length 1202 477 42 211 213 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME call_outer_ring_ 150 external procedure is an external procedure. on unit on line 96 64 on unit on unit on line 154 64 on unit clean_up 68 internal procedure is called by several nonquick procedures. begin block on line 201 begin block shares stack frame of external procedure call_outer_ring_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME call_outer_ring_ 000100 given_its call_outer_ring_ 000102 ref_ptr call_outer_ring_ 000104 segname call_outer_ring_ 000114 entrypoint call_outer_ring_ 000124 thing_to_call call_outer_ring_ 000126 ring_to_call call_outer_ring_ 000130 ap call_outer_ring_ 000132 calling_ring call_outer_ring_ 000133 calling_level call_outer_ring_ 000134 code call_outer_ring_ 000135 r call_outer_ring_ 000136 stack_segno call_outer_ring_ 000140 target_sb call_outer_ring_ 000142 bit36 call_outer_ring_ 000160 sb call_outer_ring_ 000164 deadly_reference begin block on line 201 THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out call_int_this call_int_other return_mac tra_ext_1 enable_op ext_entry_desc int_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. get_ring_ hcs_$get_max_length_seg hcs_$level_get hcs_$level_set hcs_$make_ptr hcs_$set_ips_mask rtcd_util_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. active_all_rings_data$stack_base_segno error_table_$action_not_performed error_table_$badringno pds$first_call pds$initial_ring pds$stacks LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 19 000015 88 000042 89 000046 90 000053 91 000057 92 000061 94 000062 95 000070 96 000077 98 000121 100 000124 101 000127 104 000130 112 000132 115 000135 116 000137 118 000140 119 000141 121 000144 122 000146 130 000147 131 000153 132 000156 137 000160 138 000166 139 000170 140 000217 142 000223 143 000224 144 000233 145 000243 146 000252 147 000266 149 000270 154 000277 156 000316 157 000325 160 000336 161 000342 162 000345 163 000360 165 000362 166 000364 169 000365 173 000375 175 000377 177 000401 178 000410 180 000412 181 000414 182 000417 188 000424 190 000437 192 000440 194 000444 195 000447 208 000450 211 000457 215 000460 196 000461 198 000467 199 000476 ----------------------------------------------------------- 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