COMPILATION LISTING OF SEGMENT ipc_fast_ 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 1010.6 mst Sat Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* *********************************************************** */ 11 12 /* format: style3 */ 13 14 ipc_fast_$block: 15 procedure (a_event_wait_list_ptr, a_event_wait_info_ptr, a_code); 16 17 /* This procedure is a fast call to block a process and is 18* called as ipc_$block. It handles fast ipc channels only 19* and calls the full ipc mechanism if channels other than 20* fast channels are supplied. */ 21 22 /* Rewritten for new ipc by E Donner Jan 1981 */ 23 /* Modified September 1983 by Chris Jones to call the full IPC mechanism 24* when there are call events pending, not when there are any events 25* pending. */ 26 /* Modified 1984-11-02 by E. Swenson for new ipc validation */ 27 28 29 /****^ HISTORY COMMENTS: 30* 1) change(86-08-12,Kissel), approve(86-08-12,MCR7473), 31* audit(86-10-20,Fawcett), install(86-11-03,MR12.0-1206): 32* Changed to support control point management. These changes were actually 33* done in February 1985 by G. Palter. 34* END HISTORY COMMENTS */ 35 36 37 /* parameters */ 38 39 dcl a_event_wait_list_ptr 40 ptr parameter; 41 dcl a_event_wait_info_ptr 42 ptr parameter; 43 dcl a_code fixed bin (35); 44 45 /* automatic */ 46 47 dcl call_regular bit (1) aligned; /* indicates if full ipc should be called */ 48 dcl cur_ring fixed bin (3); /* current ring */ 49 dcl 1 ev_chn_name aligned like event_channel_name automatic; 50 dcl loop fixed bin; /* index */ 51 dcl validation_level fixed bin (3); /* current validation level */ 52 53 /* constants */ 54 55 dcl OFF bit (1) aligned static options (constant) init ("0"b); 56 dcl ON bit (1) aligned static options (constant) init ("1"b); 57 dcl TRUE bit (1) aligned static options (constant) init ("1"b); 58 59 /* external static */ 60 61 dcl ipc_data_$event_calls_pending 62 fixed bin ext; /* number of event call wakeups pending */ 63 dcl ipc_data_$fast_channel_events 64 bit (36) aligned ext; /* fast events pending */ 65 dcl error_table_$bad_arg 66 fixed bin (35) ext; 67 dcl error_table_$invalid_channel 68 fixed bin (35) ext; 69 70 /* external entries */ 71 72 dcl cu_$level_get entry returns (fixed bin (3)); 73 dcl cu_$level_set entry (fixed bin (3)); 74 dcl ipc_real_$full_block 75 entry (ptr, ptr, fixed bin (35)); 76 dcl get_ring_ entry returns (fixed bin (3)); 77 dcl hcs_$fblock entry (bit (36) aligned, bit (1) aligned); 78 79 /* Conditions */ 80 81 dcl cleanup condition; 82 83 /* Builtin */ 84 85 dcl length builtin; 86 dcl stackbaseptr builtin; 87 dcl substr builtin; 88 dcl unspec builtin; 89 90 /* Program */ 91 92 event_wait_list_ptr = a_event_wait_list_ptr; 93 event_wait_info_ptr = a_event_wait_info_ptr; 94 event_wait_list_n_channels = event_wait_list.n_channels; 95 96 if event_wait_list_n_channels <= 0 97 then do; 98 a_code = error_table_$bad_arg; 99 return; 100 end; 101 102 if ipc_data_$event_calls_pending ^= 0 /* we have some call wakeups pending */ 103 then go to INVOKE_FULL_BLOCK; /* call full block mechanism */ 104 105 cur_ring = get_ring_ (); 106 validation_level = cu_$level_get (); /* get validation level */ 107 108 do while (TRUE); 109 110 if have_multiple_control_points () /* more than one cotnrol point can be waiting ... */ 111 then go to INVOKE_FULL_BLOCK; /* ... on one of these channels */ 112 113 do loop = 1 to event_wait_list_n_channels; /* look for each channel */ 114 unspec (ev_chn_name) = unspec (event_wait_list.channel_id (loop)); 115 /* copy channel name into structured format */ 116 if ev_chn_name.type = REGULAR_CHANNEL_TYPE | ev_chn_name.ring ^= cur_ring 117 then go to INVOKE_FULL_BLOCK; /* if regular event channel or from another ring */ 118 119 /* do validity check on channel name */ 120 if ev_chn_name.mbz ^= "0"b | ev_chn_name.unique_id <= 0 121 | ev_chn_name.unique_id > length (ipc_data_$fast_channel_events) 122 then do; 123 a_code = error_table_$invalid_channel; 124 return; 125 end; 126 127 /* ascertained that this is fast channel in current ring */ 128 if substr (ipc_data_$fast_channel_events, ev_chn_name.unique_id, 1) = ON 129 then do; /* wakeup pending */ 130 substr (ipc_data_$fast_channel_events, ev_chn_name.unique_id, 1) = OFF; 131 /* turn off event cell */ 132 133 unspec (event_wait_info) = "0"b; 134 event_wait_info.channel_id = event_wait_list.channel_id (loop); 135 /* return messge - channel name */ 136 event_wait_info.channel_index = loop; 137 /* and index in input list */ 138 a_code = 0; /* no error */ 139 return; 140 end; 141 end; 142 143 /* no fast events already processed */ 144 145 on condition (cleanup) call cu_$level_set (validation_level); 146 147 if validation_level ^= cur_ring /* set validation level to current ring */ 148 then call cu_$level_set (cur_ring); 149 150 call hcs_$fblock (ipc_data_$fast_channel_events, call_regular); 151 /* get events from ring 0 */ 152 if validation_level ^= cur_ring /* reset validation level */ 153 then call cu_$level_set (validation_level); 154 155 revert cleanup; 156 157 if call_regular /* wakeups for regular channels must be checked ... */ 158 then go to INVOKE_FULL_BLOCK; /* ... as they could be wakeups for call channels */ 159 end; 160 161 162 /* Control arrives here iff we must invoke the full blocking mechanism */ 163 164 INVOKE_FULL_BLOCK: 165 call ipc_real_$full_block (event_wait_list_ptr, event_wait_info_ptr, a_code); 166 return; 167 168 /* Determines if more than one control point is defined in this process */ 169 170 have_multiple_control_points: 171 procedure () returns (bit (1) aligned); 172 173 if stackbaseptr () -> stack_header.cpm_enabled 174 then return (cpm_data_$n_control_points > 1); 175 else return ("0"b); 176 177 end have_multiple_control_points; 178 179 /* format: off */ 180 /* BEGIN INCLUDE FILE ... ect_structures.incl.pl1 ... Jan 1981 */ 1 2 1 3 /* Modified 1984-10-28 by E. Swenson for new ipc validation and to move 1 4* event_channel_name declarations from here to event_channel_name.incl.pl1 */ 1 5 1 6 1 7 /****^ HISTORY COMMENTS: 1 8* 1) change(86-08-12,Kissel), approve(86-08-12,MCR7473), 1 9* audit(86-10-08,Fawcett), install(86-11-03,MR12.0-1206): 1 10* Changed to support control point management. These changes were actually 1 11* done in February 1985 by G. Palter. 1 12* 2) change(86-08-12,Kissel), approve(86-08-12,MCR7479), 1 13* audit(86-10-08,Fawcett), install(86-11-03,MR12.0-1206): 1 14* Modified to eke out some flag bits by making the type fixed bin (8) in 1 15* order to support async event channels. 1 16* END HISTORY COMMENTS */ 1 17 1 18 1 19 /* format: style3 */ 1 20 1 21 1 22 /* Definition of the Event Channel Table (ECT) header */ 1 23 1 24 dcl 1 ect_header aligned based (ect_ptr), 1 25 2 ect_areap ptr, /* pointer to area in which ECT entries are allocated */ 1 26 2 ect_area_size fixed bin (19), /* number of words in ECT area */ 1 27 2 count (-1:5) fixed bin, /* totals of entries allocated */ 1 28 /* -1 = waiting control points */ 1 29 /* 0 = total entries, 1 = wait channels */ 1 30 /* 2 = call channels, 3 = call channel messages */ 1 31 /* 4 = ITT messages, 5 = wait channel messages */ 1 32 2 entry_list_ptrs (5), /* head and tail of lists in ECT */ 1 33 /* 1 = wait channels, 2 = call channels */ 1 34 /* 3 = call channel messages, 4 = ITT messages */ 1 35 /* 5 = wait channel messages */ 1 36 3 firstp ptr, /* head of list */ 1 37 3 lastp ptr, /* tail of list */ 1 38 2 meters, 1 39 3 total_wakeups fixed bin (33), /* total wakeups sent on all channels */ 1 40 3 total_wait_wakeups 1 41 fixed bin (33), /* wakeups sent on wait channels */ 1 42 3 total_call_wakeups 1 43 fixed bin (33), /* wakeups sent on call channels */ 1 44 3 ittes_tossed fixed bin (33), /* number invalid ITT messages received, ignored */ 1 45 2 seed fixed bin (33), /* used to generate uid portion of channel name */ 1 46 2 flags, 1 47 3 call_priority bit (1) unal, /* = "0"b if wait chns have priority - default */ 1 48 /* = "1"b if call chans have priority */ 1 49 3 wakeup_control_points /** ON => we must wakeup other control points before */ 1 50 bit (1) unaligned, /* ... processing any event messages */ 1 51 3 unused1 bit (16) unaligned, 1 52 3 mask_call_count 1 53 fixed bin (17) unal, /* number times event call chans masked */ 1 54 2 ecit_ptr ptr, /* pointer to the ECIT */ 1 55 2 ecit_lth fixed bin (17), /* length of the ECIT (see below) */ 1 56 2 r_offset fixed bin (18), /* operand used to encode/decode channel names */ 1 57 2 r_factor fixed bin (35), /* operand used to encode/decode channel names */ 1 58 2 last_fast_channel_events /** prior fast channel settings */ 1 59 bit (36) aligned; 1 60 1 61 dcl ect_ptr pointer; 1 62 1 63 dcl TOTAL fixed bin (8) static options (constant) init (0); 1 64 dcl WAIT fixed bin (8) static options (constant) init (1); 1 65 dcl CALL fixed bin (8) static options (constant) init (2); 1 66 dcl EV_CALL_MESSAGE fixed bin (8) static options (constant) init (3); 1 67 dcl ITT_MESSAGE fixed bin (8) static options (constant) init (4); 1 68 dcl EV_WAIT_MESSAGE fixed bin (8) static options (constant) init (5); 1 69 dcl WAITING_CP fixed bin (8) static options (constant) init (-1); 1 70 /* used to index count and entry_list_ptrs arrays */ 1 71 1 72 1 73 /* Definition of the Event Channel Index Table (ECIT) -- Given an event channel 1 74* name, ipc_validate_$decode_event_channel_name will yield an index into this 1 75* table which contains a pointer to the definition of the channel (its ECT) */ 1 76 1 77 dcl 1 ecit aligned based (ecit_ptr), 1 78 2 ecte_ptr (ecit_lth) pointer unaligned; 1 79 1 80 dcl ecit_ptr pointer; 1 81 dcl ecit_lth fixed binary (17); 1 82 1 83 1 84 /* Definition of an event wait channel */ 1 85 1 86 dcl 1 wait_channel aligned based (ectep), 1 87 2 word_0, 1 88 3 unused1 fixed bin (17) unal, 1 89 3 flags unal, 1 90 4 async_call bit (1) unal, /* Only checked for call channels. */ 1 91 4 pad bit (8) unal, 1 92 3 type fixed bin (8) unal, /* = WAIT */ 1 93 2 next_chanp ptr unal, /* pointer to next wait channel */ 1 94 2 prev_chanp ptr unal, /* pointer to previous wait channel */ 1 95 2 word_3, 1 96 3 fast_channel bit (1) unal, /* ON => this is a fast channel */ 1 97 3 inhibit_count fixed bin (16) unal, /* number of times message reception has been inhibited */ 1 98 3 wakeup_control_points /** ON => wakeup the control points waiting on this channel */ 1 99 bit (1) unaligned, 1 100 3 wakeup_count fixed bin (17) unal unsigned, /* number of wakeups received over this channel */ 1 101 2 name bit (72), /* event channel name associated with this channel */ 1 102 2 first_ev_msgp ptr unal, /* pointer to first message in queue */ 1 103 2 last_ev_msgp ptr unal, /* pointer to last message in queue */ 1 104 2 first_wcpp ptr unal, /* pointer to first control point waiting on this channel */ 1 105 2 last_wcpp ptr unal, /* pointer to last control point waiting on this channel */ 1 106 2 fast_channel_id fixed binary, /* index into ipc_data_$fast_channel_events */ 1 107 2 unused2 fixed binary; /* pad to 12 words */ 1 108 1 109 1 110 /* Definition of an event call channel */ 1 111 1 112 dcl 1 call_channel aligned based (ectep), 1 113 2 word_0, 1 114 3 priority fixed bin (17) unal, /* indicated priority relative to other call chns */ 1 115 3 flags unal, 1 116 4 async_call bit (1) unal, /* Send IPS "wkp_" on wakeup. */ 1 117 4 pad bit (8) unal, 1 118 3 type fixed bin (8) unal, /* = CALL */ 1 119 2 next_chanp ptr unal, /* pointer to next call channel */ 1 120 2 prev_chanp ptr unal, /* pointer to prev call channel */ 1 121 2 word_3, 1 122 3 call_inhibit bit (1) unal, /* = "1"b if call to associated proc in progress */ 1 123 3 inhibit_count fixed bin (16) unal, /* number of times message reception has been inhibited */ 1 124 3 wakeup_control_points /** ON => wakeup the control point waiting on this channel */ 1 125 bit (1) unaligned, 1 126 3 wakeup_count fixed bin (17) unal unsigned, /* number of wakeups received over this channel */ 1 127 2 name bit (72), /* event channel name associated with this channel */ 1 128 2 first_ev_msgp ptr unal, /* pointer to first message in queue */ 1 129 2 last_ev_msgp ptr unal, /* pointer to last message in queue */ 1 130 2 data_ptr ptr unal, /* pointer to associated data base */ 1 131 2 procedure_value, /* procedure to call when message arrives */ 1 132 3 procedure_ptr ptr unal, /* pointer to entry point */ 1 133 3 environment_ptr 1 134 ptr unal, /* pointer to stack frame */ 1 135 2 control_point_id /** ID of control point which "owns" this channel */ 1 136 bit (36) aligned; 1 137 1 138 dcl ectep pointer; 1 139 1 140 1 141 /* Definition of a message for either an event wait or an event call channel */ 1 142 1 143 dcl 1 event_message aligned based, 1 144 2 word_0, 1 145 3 priority fixed bin (17) unal, /* priority of call channel */ 1 146 3 type fixed bin (17) unal, /* = EV_CALL_MESSAGE or EV_WAIT_MESSAGE */ 1 147 2 chanp ptr unal, /* pointer to associated event channel */ 1 148 2 message_data like event_message_data aligned, 1 149 /* event message as returned from ipc_$block */ 1 150 2 next_ev_msgp ptr unal, /* pointer to next event call/wait channel message */ 1 151 2 prev_ev_msgp ptr unal, /* pointer to previous event call/wait channel message */ 1 152 2 next_chan_msgp ptr unal, /* pointer to next message for this channel */ 1 153 2 prev_chan_msgp ptr unal; /* pointer to previous message for this channel */ 1 154 1 155 1 156 /* Definition of an ITT message as returned from ring 0 */ 1 157 1 158 dcl 1 itt_message aligned based, 1 159 2 word_0, 1 160 3 unused1 fixed bin (17) unal, 1 161 3 type fixed bin (17) unal, 1 162 2 next_itt_msgp ptr unal, /* pointer to next itt message entry in ECT currently */ 1 163 2 message_data like event_message_data aligned, 1 164 2 unused2 (4) fixed bin; /* pad to 12 words */ 1 165 1 166 1 167 /* Definition of an event message as returned from ring 0 */ 1 168 1 169 dcl 1 event_message_data 1 170 aligned based, 1 171 2 channel_id fixed bin (71), /* event channel name */ 1 172 2 message fixed bin (71), /* 72 bit message associated with wakeup */ 1 173 2 sender bit (36), /* process ID of sender */ 1 174 2 origin, 1 175 3 dev_signal bit (18) unal, /* "1"b if device signal */ 1 176 /* "0"b if user event */ 1 177 3 ring fixed bin (17) unal; /* ring of sending process */ 1 178 1 179 1 180 /* Definition of a control point which is blocked on a channel */ 1 181 1 182 dcl 1 waiting_control_point 1 183 aligned based (wcpp), 1 184 2 word_0, 1 185 3 block_count fixed binary (17) unaligned, /* # of in-progress ipc_$block calls by this control point */ 1 186 3 type fixed binary (17) unaligned, /* = WAITING_CP */ 1 187 2 control_point_id /** ID of the waiting control point */ 1 188 bit (36) aligned, 1 189 2 chain, 1 190 3 next_wcpp pointer, /* pointer to previous waiting control point */ 1 191 3 prev_wcpp pointer, /* pointer to next waiting control point */ 1 192 2 unused (6) bit (36) aligned; /* pad to 12 words */ 1 193 1 194 dcl wcpp pointer; 1 195 1 196 /* END INCLUDE file ... ect_structures.incl.pl1 */ 180 181 /* Begin include file event_channel_name.incl.pl1 */ 2 2 2 3 /* format: style4 */ 2 4 2 5 /* Written 1984-11-02 by E. Swenson */ 2 6 2 7 2 8 /****^ HISTORY COMMENTS: 2 9* 1) change(86-08-09,Kissel), approve(86-08-12,MCR7479), 2 10* audit(86-10-08,Fawcett), install(86-11-03,MR12.0-1206): 2 11* Added constants for the flag values and declared a structure to describe 2 12* the encoded_index after it is decoded. This include file has also been 2 13* converted to ALM for use by pxss. 2 14* END HISTORY COMMENTS */ 2 15 2 16 2 17 dcl 1 event_channel_name structure aligned based, 2 18 2 encoded_index bit (18) unaligned, 2 19 2 verifier bit (18) unaligned, 2 20 2 ring fixed bin (3) unsigned unaligned, 2 21 2 type bit (1) unaligned, /* "1"b for regular, "0"b for fast */ 2 22 2 mbz bit (14) unaligned, 2 23 2 unique_id fixed bin (18) unsigned unaligned; 2 24 2 25 dcl FAST_CHANNEL_TYPE bit (1) aligned initial ("0"b) internal static options (constant); 2 26 dcl REGULAR_CHANNEL_TYPE bit (1) aligned initial ("1"b) internal static options (constant); 2 27 2 28 dcl NORMAL_CHANNEL_FLAGS bit (3) aligned internal static options (constant) init ("000"b); 2 29 dcl SEND_IPS_WKP_CHANNEL_FLAGS bit (3) aligned internal static options (constant) init ("001"b); 2 30 2 31 /* Structure for use after the encoded_index in the event_channel_name has been decoded. */ 2 32 2 33 dcl 1 decoded_index structure aligned based, 2 34 2 flags bit (3) unaligned, 2 35 2 index fixed bin (15) unsigned unaligned; 2 36 2 37 dcl ENCODED_INDEX_CONSTANT fixed bin (35) internal static options (constant) init (262144); 2 38 2 39 /* End include file event_channel_name.incl.pl1 */ 181 182 /* BEGIN INCLUDE FILE event_wait_info.incl.pl1 */ 3 2 3 3 /* T. Casey, May 1978 */ 3 4 3 5 dcl event_wait_info_ptr ptr; 3 6 3 7 dcl 1 event_wait_info aligned based (event_wait_info_ptr), /* argument structure filled in on return from ipc_$block */ 3 8 2 channel_id fixed bin (71), /* event channel on which wakeup occurred */ 3 9 2 message fixed bin (71), /* 72 bits of information passed by sender of wakeup */ 3 10 2 sender bit (36), /* process id of sender */ 3 11 2 origin, 3 12 3 dev_signal bit (18) unaligned, /* "1"b if device signal */ 3 13 3 ring fixed bin (17) unaligned, /* ring from which sent */ 3 14 2 channel_index fixed bin; /* index of this channel in the event wait list */ 3 15 3 16 /* END INCLUDE FILE event_wait_info.incl.pl1 */ 182 183 /* BEGIN INCLUDE FILE ... event_wait_list.incl.pl1 */ 4 2 4 3 /* ipc_$block wait list structure -- Must begin on an even word boundary. 4 4* 4 5* Written 9-May-79 by M. N. Davidoff. 4 6**/ 4 7 4 8 declare event_wait_list_n_channels 4 9 fixed binary; 4 10 declare event_wait_list_ptr pointer; 4 11 4 12 declare 1 event_wait_list aligned based (event_wait_list_ptr), 4 13 2 n_channels fixed binary, /* number of channels in wait list */ 4 14 2 pad bit (36), 4 15 2 channel_id (event_wait_list_n_channels refer (event_wait_list.n_channels)) fixed binary (71); 4 16 /* event channels to wait on */ 4 17 4 18 /* END INCLUDE FILE ... event_wait_list.incl.pl1 */ 183 184 /* BEGIN INCLUDE FILE ... stack_header.incl.pl1 .. 3/72 Bill Silver */ 5 2 /* modified 7/76 by M. Weaver for *system links and more system use of areas */ 5 3 /* modified 3/77 by M. Weaver to add rnt_ptr */ 5 4 /* Modified April 1983 by C. Hornig for tasking */ 5 5 5 6 /****^ HISTORY COMMENTS: 5 7* 1) change(86-06-24,DGHowe), approve(86-06-24,MCR7396), 5 8* audit(86-08-05,Schroth), install(86-11-03,MR12.0-1206): 5 9* added the heap_header_ptr definition. 5 10* 2) change(86-08-12,Kissel), approve(86-08-12,MCR7473), 5 11* audit(86-10-10,Fawcett), install(86-11-03,MR12.0-1206): 5 12* Modified to support control point management. These changes were actually 5 13* made in February 1985 by G. Palter. 5 14* 3) change(86-10-22,Fawcett), approve(86-10-22,MCR7473), 5 15* audit(86-10-22,Farley), install(86-11-03,MR12.0-1206): 5 16* Remove the old_lot pointer and replace it with cpm_data_ptr. Use the 18 5 17* bit pad after cur_lot_size for the cpm_enabled. This was done to save some 5 18* space int the stack header and change the cpd_ptr unal to cpm_data_ptr 5 19* (ITS pair). 5 20* END HISTORY COMMENTS */ 5 21 5 22 /* format: style2 */ 5 23 5 24 dcl sb ptr; /* the main pointer to the stack header */ 5 25 5 26 dcl 1 stack_header based (sb) aligned, 5 27 2 pad1 (4) fixed bin, /* (0) also used as arg list by outward_call_handler */ 5 28 2 cpm_data_ptr ptr, /* (4) pointer to control point which owns this stack */ 5 29 2 combined_stat_ptr ptr, /* (6) pointer to area containing separate static */ 5 30 2 clr_ptr ptr, /* (8) pointer to area containing linkage sections */ 5 31 2 max_lot_size fixed bin (17) unal, /* (10) DU number of words allowed in lot */ 5 32 2 main_proc_invoked fixed bin (11) unal, /* (10) DL nonzero if main procedure invoked in run unit */ 5 33 2 have_static_vlas bit (1) unal, /* (10) DL "1"b if (very) large arrays are being used in static */ 5 34 2 pad4 bit (2) unal, 5 35 2 run_unit_depth fixed bin (2) unal, /* (10) DL number of active run units stacked */ 5 36 2 cur_lot_size fixed bin (17) unal, /* (11) DU number of words (entries) in lot */ 5 37 2 cpm_enabled bit (18) unal, /* (11) DL non-zero if control point management is enabled */ 5 38 2 system_free_ptr ptr, /* (12) pointer to system storage area */ 5 39 2 user_free_ptr ptr, /* (14) pointer to user storage area */ 5 40 2 null_ptr ptr, /* (16) */ 5 41 2 stack_begin_ptr ptr, /* (18) pointer to first stack frame on the stack */ 5 42 2 stack_end_ptr ptr, /* (20) pointer to next useable stack frame */ 5 43 2 lot_ptr ptr, /* (22) pointer to the lot for the current ring */ 5 44 2 signal_ptr ptr, /* (24) pointer to signal procedure for current ring */ 5 45 2 bar_mode_sp ptr, /* (26) value of sp before entering bar mode */ 5 46 2 pl1_operators_ptr ptr, /* (28) pointer to pl1_operators_$operator_table */ 5 47 2 call_op_ptr ptr, /* (30) pointer to standard call operator */ 5 48 2 push_op_ptr ptr, /* (32) pointer to standard push operator */ 5 49 2 return_op_ptr ptr, /* (34) pointer to standard return operator */ 5 50 2 return_no_pop_op_ptr 5 51 ptr, /* (36) pointer to standard return / no pop operator */ 5 52 2 entry_op_ptr ptr, /* (38) pointer to standard entry operator */ 5 53 2 trans_op_tv_ptr ptr, /* (40) pointer to translator operator ptrs */ 5 54 2 isot_ptr ptr, /* (42) pointer to ISOT */ 5 55 2 sct_ptr ptr, /* (44) pointer to System Condition Table */ 5 56 2 unwinder_ptr ptr, /* (46) pointer to unwinder for current ring */ 5 57 2 sys_link_info_ptr ptr, /* (48) pointer to *system link name table */ 5 58 2 rnt_ptr ptr, /* (50) pointer to Reference Name Table */ 5 59 2 ect_ptr ptr, /* (52) pointer to event channel table */ 5 60 2 assign_linkage_ptr ptr, /* (54) pointer to storage for (obsolete) hcs_$assign_linkage */ 5 61 2 heap_header_ptr ptr, /* (56) pointer to the heap header for this ring */ 5 62 2 trace, 5 63 3 frames, 5 64 4 count fixed bin, /* (58) number of trace frames */ 5 65 4 top_ptr ptr unal, /* (59) pointer to last trace frame */ 5 66 3 in_trace bit (36) aligned, /* (60) trace antirecursion flag */ 5 67 2 pad2 bit (36), /* (61) */ 5 68 2 pad5 pointer; /* (62) pointer to future stuff */ 5 69 5 70 /* The following offset refers to a table within the pl1 operator table. */ 5 71 5 72 dcl tv_offset fixed bin init (361) internal static; 5 73 /* (551) octal */ 5 74 5 75 5 76 /* The following constants are offsets within this transfer vector table. */ 5 77 5 78 dcl ( 5 79 call_offset fixed bin init (271), 5 80 push_offset fixed bin init (272), 5 81 return_offset fixed bin init (273), 5 82 return_no_pop_offset fixed bin init (274), 5 83 entry_offset fixed bin init (275) 5 84 ) internal static; 5 85 5 86 5 87 5 88 5 89 5 90 /* The following declaration is an overlay of the whole stack header. Procedures which 5 91* move the whole stack header should use this overlay. 5 92**/ 5 93 5 94 dcl stack_header_overlay (size (stack_header)) fixed bin based (sb); 5 95 5 96 5 97 5 98 /* END INCLUDE FILE ... stack_header.incl.pl1 */ 184 185 /* BEGIN INCLUDE FILE ... cpm_data_.incl.pl1 */ 6 2 6 3 /****^ HISTORY COMMENTS: 6 4* 1) change(86-08-12,Kissel), approve(86-08-12,MCR7473), 6 5* audit(86-10-08,Fawcett), install(86-11-03,MR12.0-1206): 6 6* Written to support control point management in March 1985 by G. Palter. 6 7* END HISTORY COMMENTS */ 6 8 6 9 /* format: style3,linecom */ 6 10 6 11 /* Static data defined by the Control Point Manager for external use */ 6 12 6 13 dcl cpm_data_$n_control_points /* # of control points actually extant in the process */ 6 14 fixed binary external; 6 15 6 16 /* END INCLUDE FILE ... cpm_data_.incl.pl1 */ 185 186 /* format: on */ 187 188 end ipc_fast_$block; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/11/89 0803.3 ipc_fast_.pl1 >spec>install>1110>ipc_fast_.pl1 180 1 11/07/86 1550.3 ect_structures.incl.pl1 >ldd>include>ect_structures.incl.pl1 181 2 11/07/86 1550.3 event_channel_name.incl.pl1 >ldd>include>event_channel_name.incl.pl1 182 3 06/29/79 1727.8 event_wait_info.incl.pl1 >ldd>include>event_wait_info.incl.pl1 183 4 06/29/79 1728.0 event_wait_list.incl.pl1 >ldd>include>event_wait_list.incl.pl1 184 5 11/07/86 1550.3 stack_header.incl.pl1 >ldd>include>stack_header.incl.pl1 185 6 11/07/86 1550.3 cpm_data_.incl.pl1 >ldd>include>cpm_data_.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. OFF constant bit(1) initial dcl 55 ref 130 ON 000310 constant bit(1) initial dcl 56 ref 128 REGULAR_CHANNEL_TYPE constant bit(1) initial dcl 2-26 ref 116 TRUE constant bit(1) initial dcl 57 ref 108 a_code parameter fixed bin(35,0) dcl 43 set ref 14 98* 123* 138* 164* a_event_wait_info_ptr parameter pointer dcl 41 ref 14 93 a_event_wait_list_ptr parameter pointer dcl 39 ref 14 92 call_regular 000100 automatic bit(1) dcl 47 set ref 150* 157 channel_id 2 based fixed bin(71,0) array level 2 in structure "event_wait_list" dcl 4-12 in procedure "ipc_fast_$block" ref 114 134 channel_id based fixed bin(71,0) level 2 in structure "event_wait_info" dcl 3-7 in procedure "ipc_fast_$block" set ref 134* channel_index 6 based fixed bin(17,0) level 2 dcl 3-7 set ref 136* cleanup 000106 stack reference condition dcl 81 ref 145 155 cpm_data_$n_control_points 000032 external static fixed bin(17,0) dcl 6-13 ref 173 cpm_enabled 13(18) based bit(18) level 2 packed packed unaligned dcl 5-26 ref 173 cu_$level_get 000020 constant entry external dcl 72 ref 106 cu_$level_set 000022 constant entry external dcl 73 ref 145 147 152 cur_ring 000101 automatic fixed bin(3,0) dcl 48 set ref 105* 116 147 147* 152 error_table_$bad_arg 000014 external static fixed bin(35,0) dcl 65 ref 98 error_table_$invalid_channel 000016 external static fixed bin(35,0) dcl 67 ref 123 ev_chn_name 000102 automatic structure level 1 dcl 49 set ref 114* event_channel_name based structure level 1 dcl 2-17 event_message_data based structure level 1 dcl 1-169 event_wait_info based structure level 1 dcl 3-7 set ref 133* event_wait_info_ptr 000114 automatic pointer dcl 3-5 set ref 93* 133 134 136 164* event_wait_list based structure level 1 dcl 4-12 event_wait_list_n_channels 000116 automatic fixed bin(17,0) dcl 4-8 set ref 94* 96 113 event_wait_list_ptr 000120 automatic pointer dcl 4-10 set ref 92* 94 114 134 164* get_ring_ 000026 constant entry external dcl 76 ref 105 hcs_$fblock 000030 constant entry external dcl 77 ref 150 ipc_data_$event_calls_pending 000010 external static fixed bin(17,0) dcl 61 ref 102 ipc_data_$fast_channel_events 000012 external static bit(36) dcl 63 set ref 120 128 130* 150* ipc_real_$full_block 000024 constant entry external dcl 74 ref 164 length builtin function dcl 85 ref 120 loop 000104 automatic fixed bin(17,0) dcl 50 set ref 113* 114 134 136* mbz 1(04) 000102 automatic bit(14) level 2 packed packed unaligned dcl 49 set ref 120 n_channels based fixed bin(17,0) level 2 dcl 4-12 ref 94 ring 1 000102 automatic fixed bin(3,0) level 2 packed packed unsigned unaligned dcl 49 set ref 116 stack_header based structure level 1 dcl 5-26 stackbaseptr builtin function dcl 86 ref 173 substr builtin function dcl 87 set ref 128 130* type 1(03) 000102 automatic bit(1) level 2 packed packed unaligned dcl 49 set ref 116 unique_id 1(18) 000102 automatic fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 49 set ref 120 120 128 130 unspec builtin function dcl 88 set ref 114* 114 133* validation_level 000105 automatic fixed bin(3,0) dcl 51 set ref 106* 145* 147 152 152* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. CALL internal static fixed bin(8,0) initial dcl 1-65 ENCODED_INDEX_CONSTANT internal static fixed bin(35,0) initial dcl 2-37 EV_CALL_MESSAGE internal static fixed bin(8,0) initial dcl 1-66 EV_WAIT_MESSAGE internal static fixed bin(8,0) initial dcl 1-68 FAST_CHANNEL_TYPE internal static bit(1) initial dcl 2-25 ITT_MESSAGE internal static fixed bin(8,0) initial dcl 1-67 NORMAL_CHANNEL_FLAGS internal static bit(3) initial dcl 2-28 SEND_IPS_WKP_CHANNEL_FLAGS internal static bit(3) initial dcl 2-29 TOTAL internal static fixed bin(8,0) initial dcl 1-63 WAIT internal static fixed bin(8,0) initial dcl 1-64 WAITING_CP internal static fixed bin(8,0) initial dcl 1-69 call_channel based structure level 1 dcl 1-112 call_offset internal static fixed bin(17,0) initial dcl 5-78 decoded_index based structure level 1 dcl 2-33 ecit based structure level 1 dcl 1-77 ecit_lth automatic fixed bin(17,0) dcl 1-81 ecit_ptr automatic pointer dcl 1-80 ect_header based structure level 1 dcl 1-24 ect_ptr automatic pointer dcl 1-61 ectep automatic pointer dcl 1-138 entry_offset internal static fixed bin(17,0) initial dcl 5-78 event_message based structure level 1 dcl 1-143 itt_message based structure level 1 dcl 1-158 push_offset internal static fixed bin(17,0) initial dcl 5-78 return_no_pop_offset internal static fixed bin(17,0) initial dcl 5-78 return_offset internal static fixed bin(17,0) initial dcl 5-78 sb automatic pointer dcl 5-24 stack_header_overlay based fixed bin(17,0) array dcl 5-94 tv_offset internal static fixed bin(17,0) initial dcl 5-72 wait_channel based structure level 1 dcl 1-86 waiting_control_point based structure level 1 dcl 1-182 wcpp automatic pointer dcl 1-194 NAMES DECLARED BY EXPLICIT CONTEXT. INVOKE_FULL_BLOCK 000247 constant label dcl 164 ref 102 110 116 157 have_multiple_control_points 000264 constant entry internal dcl 170 ref 110 ipc_fast_$block 000012 constant entry external dcl 14 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 476 532 311 506 Length 1034 311 34 266 164 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME ipc_fast_$block 112 external procedure is an external procedure. on unit on line 145 68 on unit have_multiple_control_points internal procedure shares stack frame of external procedure ipc_fast_$block. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME ipc_fast_$block 000100 call_regular ipc_fast_$block 000101 cur_ring ipc_fast_$block 000102 ev_chn_name ipc_fast_$block 000104 loop ipc_fast_$block 000105 validation_level ipc_fast_$block 000114 event_wait_info_ptr ipc_fast_$block 000116 event_wait_list_n_channels ipc_fast_$block 000120 event_wait_list_ptr ipc_fast_$block THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_g_a call_ext_out return_mac enable_op ext_entry int_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. cu_$level_get cu_$level_set get_ring_ hcs_$fblock ipc_real_$full_block THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. cpm_data_$n_control_points error_table_$bad_arg error_table_$invalid_channel ipc_data_$event_calls_pending ipc_data_$fast_channel_events LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 14 000006 92 000017 93 000023 94 000026 96 000030 98 000031 99 000033 102 000034 105 000036 106 000044 108 000053 110 000054 113 000061 114 000071 116 000077 120 000110 123 000122 124 000126 128 000127 130 000140 133 000143 134 000147 136 000152 138 000154 139 000156 141 000157 145 000161 147 000205 150 000217 152 000230 155 000242 157 000243 159 000246 164 000247 166 000263 170 000264 173 000266 175 000301 ----------------------------------------------------------- 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