COMPILATION LISTING OF SEGMENT cross_ring_ Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 11/04/82 1837.0 mst Thu 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 /* format: style2 */ 12 cross_ring_: 13 procedure; 14 return; 15 16 /* CROSS_RING_ - cross-ring iox attachment. 17* 18* This program runs in the outer ring. It attaches the outer ring IOCB to a gate 19* into the appropriate inner ring. 20* 21* THVV 2/77 22* April 1981: 23* Fixed bug whereby inner ring close entrypoint was called instead 24* of cross_ring_close entry in this program. --Benson I. Margulies. 25* 26* November 1981: 27* Fixed to use newer inner/outer ring protocol, cleaned up -- BIM */ 28 /* 10/82 BIM: fixed att_err to use c instead of code uniformly */ 29 30 /* parameters */ 31 32 dcl iocb_ptr ptr; /* pointer to cross_ring_ iocb */ 33 dcl attach_param (*) char (*) varying; 34 /* param list for attach */ 35 dcl com_err_sw bit (1); /* call com_err on error if "1"b */ 36 dcl return_code fixed bin (35); /* return error to caller */ 37 dcl open_mode fixed bin; /* open mode for open call only */ 38 dcl dummy bit (1); /* extend sw for open call only */ 39 40 /* automatic storage */ 41 42 dcl target_ring fixed bin; 43 dcl save_mask bit (36) aligned; /* save ips mask here */ 44 dcl code fixed bin (35); /* for error codes */ 45 dcl inner_index bit (72) aligned; 46 dcl myname char (11) static options (constant) init ("cross_ring_"); 47 dcl act_iocb_ptr ptr; /* store actual iocb pointer here on most calls */ 48 49 dcl system_free_area area based (get_system_free_area_ ()); 50 51 /* entry variables */ 52 53 dcl cv_dec_check_ entry (char (*), fixed bin (35)) returns (fixed bin); 54 dcl cu_$level_get entry () returns (fixed bin); 55 dcl ( 56 hcs_$set_ips_mask, 57 hcs_$reset_ips_mask 58 ) entry (bit (36) aligned, bit (36) aligned); 59 dcl com_err_ entry options (variable); 60 dcl sub_err_ entry () options (variable); 61 dcl get_system_free_area_ entry () returns (ptr); 62 63 64 65 dcl cross_ring_gates_ptr_ external static pointer unaligned init (null ()); 66 67 INIT_GATES: 68 procedure () returns (pointer unaligned); 69 dcl gp pointer unaligned; 70 71 allocate gates set (gp); 72 gp -> gates (*) = null_entry; 73 return (gp); 74 end INIT_GATES; 75 76 null_entry: /* Used to initialize entry variables to known state */ 77 entry; 78 return; 79 80 dcl 1 gates (7) aligned based (cross_ring_gates_ptr_), 81 2 dispatch_find_attachment 82 variable entry (char (*), bit (72) aligned, fixed bin (35)), 83 2 dispatch_release_attachment 84 variable entry (bit (72) aligned, fixed bin (35)), 85 2 dispatch_open variable entry (bit (72) aligned, fixed bin, bit (1), fixed bin (35)), 86 2 dispatch_close variable entry (bit (72) aligned, fixed bin (35)), 87 2 dispatch_modes variable entry, 88 2 dispatch_control variable entry, 89 2 dispatch_position variable entry, 90 2 dispatch_put_chars variable entry, 91 2 dispatch_get_line variable entry, 92 2 dispatch_get_chars variable entry, 93 2 dispatch_read_length 94 variable entry, 95 2 dispatch_seek_key variable entry, 96 2 dispatch_read_key variable entry, 97 2 dispatch_write_record 98 variable entry, 99 2 dispatch_read_record 100 variable entry, 101 2 dispatch_rewrite_record 102 variable entry, 103 2 dispatch_delete_record 104 variable entry; 105 106 107 108 /* Conditions */ 109 110 declare (cleanup, area, bad_area_format) 111 condition; 112 113 /* external variables */ 114 115 dcl ( 116 error_table_$bad_mode, 117 error_table_$not_open, 118 error_table_$smallarg, 119 error_table_$bad_conversion, 120 error_table_$badringno, 121 error_table_$noalloc 122 ) ext static fixed bin (35); 123 dcl error_table_$bad_arg fixed bin (35) ext; 124 dcl error_table_$not_detached 125 external fixed bin (35); 126 dcl error_table_$wrong_no_of_args 127 external fixed bin (35); 128 129 /* built in fuctions */ 130 131 dcl (size, hbound, addr, length, null, index, search, substr, ptr, fixed) 132 builtin; 133 1 1 /* begin include file cross_ring_attach_data_ */ 1 2 /* BIM November 1981 */ 1 3 /*format: style3 */ 1 4 1 5 declare attach_data_ptr pointer; 1 6 declare 1 attach_data aligned based (attach_data_ptr), 1 7 2 atd char (200) varying, 1 8 2 open char (20) varying, 1 9 2 inner_index bit (72) aligned, 1 10 2 target_ring fixed bin, 1 11 2 open_mode fixed bin; 1 12 1 13 /* End include file cross_ring_attach_data_ */ 134 135 2 1 /* BEGIN INCLUDE FILE ..... iocb.incl.pl1 ..... 13 Feb 1975, M. Asherman */ 2 2 /* format: style2 */ 2 3 2 4 dcl 1 iocb aligned based, /* I/O control block. */ 2 5 2 version character (4) aligned, 2 6 2 name char (32), /* I/O name of this block. */ 2 7 2 actual_iocb_ptr ptr, /* IOCB ultimately SYNed to. */ 2 8 2 attach_descrip_ptr ptr, /* Ptr to printable attach description. */ 2 9 2 attach_data_ptr ptr, /* Ptr to attach data structure. */ 2 10 2 open_descrip_ptr ptr, /* Ptr to printable open description. */ 2 11 2 open_data_ptr ptr, /* Ptr to open data structure (old SDB). */ 2 12 2 reserved bit (72), /* Reserved for future use. */ 2 13 2 detach_iocb entry (ptr, fixed (35)),/* detach_iocb(p,s) */ 2 14 2 open entry (ptr, fixed, bit (1) aligned, fixed (35)), 2 15 /* open(p,mode,not_used,s) */ 2 16 2 close entry (ptr, fixed (35)),/* close(p,s) */ 2 17 2 get_line entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 2 18 /* get_line(p,bufptr,buflen,actlen,s) */ 2 19 2 get_chars entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 2 20 /* get_chars(p,bufptr,buflen,actlen,s) */ 2 21 2 put_chars entry (ptr, ptr, fixed (21), fixed (35)), 2 22 /* put_chars(p,bufptr,buflen,s) */ 2 23 2 modes entry (ptr, char (*), char (*), fixed (35)), 2 24 /* modes(p,newmode,oldmode,s) */ 2 25 2 position entry (ptr, fixed, fixed (21), fixed (35)), 2 26 /* position(p,u1,u2,s) */ 2 27 2 control entry (ptr, char (*), ptr, fixed (35)), 2 28 /* control(p,order,infptr,s) */ 2 29 2 read_record entry (ptr, ptr, fixed (21), fixed (21), fixed (35)), 2 30 /* read_record(p,bufptr,buflen,actlen,s) */ 2 31 2 write_record entry (ptr, ptr, fixed (21), fixed (35)), 2 32 /* write_record(p,bufptr,buflen,s) */ 2 33 2 rewrite_record entry (ptr, ptr, fixed (21), fixed (35)), 2 34 /* rewrite_record(p,bufptr,buflen,s) */ 2 35 2 delete_record entry (ptr, fixed (35)),/* delete_record(p,s) */ 2 36 2 seek_key entry (ptr, char (256) varying, fixed (21), fixed (35)), 2 37 /* seek_key(p,key,len,s) */ 2 38 2 read_key entry (ptr, char (256) varying, fixed (21), fixed (35)), 2 39 /* read_key(p,key,len,s) */ 2 40 2 read_length entry (ptr, fixed (21), fixed (35)); 2 41 /* read_length(p,len,s) */ 2 42 2 43 declare iox_$iocb_version_sentinel 2 44 character (4) aligned external static; 2 45 2 46 /* END INCLUDE FILE ..... iocb.incl.pl1 ..... */ 136 137 3 1 /* Begin include file ..... iox_modes.incl.pl1 */ 3 2 3 3 /* Written by C. D. Tavares, 03/17/75 */ 3 4 /* Updated 10/31/77 by CDT to include short iox mode strings */ 3 5 3 6 dcl iox_modes (13) char (24) int static options (constant) aligned initial 3 7 ("stream_input", "stream_output", "stream_input_output", 3 8 "sequential_input", "sequential_output", "sequential_input_output", "sequential_update", 3 9 "keyed_sequential_input", "keyed_sequential_output", "keyed_sequential_update", 3 10 "direct_input", "direct_output", "direct_update"); 3 11 3 12 dcl short_iox_modes (13) char (4) int static options (constant) aligned initial 3 13 ("si", "so", "sio", "sqi", "sqo", "sqio", "squ", "ksqi", "ksqo", "ksqu", "di", "do", "du"); 3 14 3 15 dcl (Stream_input initial (1), 3 16 Stream_output initial (2), 3 17 Stream_input_output initial (3), 3 18 Sequential_input initial (4), 3 19 Sequential_output initial (5), 3 20 Sequential_input_output initial (6), 3 21 Sequential_update initial (7), 3 22 Keyed_sequential_input initial (8), 3 23 Keyed_sequential_output initial (9), 3 24 Keyed_sequential_update initial (10), 3 25 Direct_input initial (11), 3 26 Direct_output initial (12), 3 27 Direct_update initial (13)) fixed bin int static options (constant); 3 28 3 29 /* End include file ..... iox_modes.incl.pl1 */ 138 4 1 /* --------------- BEGIN include file iox_dcls.incl.pl1 --------------- */ 4 2 4 3 /* Written 05/04/78 by C. D. Tavares */ 4 4 /* Fixed declaration of iox_$find_iocb_n 05/07/80 by R. Holmstedt */ 4 5 4 6 dcl iox_$attach_name entry (char (*), pointer, char (*), pointer, fixed bin (35)), 4 7 iox_$attach_ptr entry (pointer, char (*), pointer, fixed bin (35)), 4 8 iox_$close entry (pointer, fixed bin (35)), 4 9 iox_$control entry (pointer, char (*), pointer, fixed bin (35)), 4 10 iox_$delete_record entry (pointer, fixed bin (35)), 4 11 iox_$destroy_iocb entry (pointer, fixed bin (35)), 4 12 iox_$detach_iocb entry (pointer, fixed bin (35)), 4 13 iox_$err_not_attached entry options (variable), 4 14 iox_$err_not_closed entry options (variable), 4 15 iox_$err_no_operation entry options (variable), 4 16 iox_$err_not_open entry options (variable), 4 17 iox_$find_iocb entry (char (*), pointer, fixed bin (35)), 4 18 iox_$find_iocb_n entry (fixed bin, ptr, fixed bin(35)), 4 19 iox_$get_chars entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 4 20 iox_$get_line entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 4 21 iox_$look_iocb entry (char (*), pointer, fixed bin (35)), 4 22 iox_$modes entry (pointer, char (*), char (*), fixed bin (35)), 4 23 iox_$move_attach entry (pointer, pointer, fixed bin (35)), 4 24 iox_$open entry (pointer, fixed bin, bit (1) aligned, fixed bin (35)), 4 25 iox_$position entry (pointer, fixed bin, fixed bin (21), fixed bin (35)), 4 26 iox_$propagate entry (pointer), 4 27 iox_$put_chars entry (pointer, pointer, fixed bin (21), fixed bin (35)), 4 28 iox_$read_key entry (pointer, char (256) varying, fixed bin (21), fixed bin (35)), 4 29 iox_$read_length entry (pointer, fixed bin (21), fixed bin (35)), 4 30 iox_$read_record entry (pointer, pointer, fixed bin (21), fixed bin (21), fixed bin (35)), 4 31 iox_$rewrite_record entry (pointer, pointer, fixed bin (21), fixed bin (35)), 4 32 iox_$seek_key entry (pointer, char (256) varying, fixed bin (21), fixed bin (35)), 4 33 iox_$write_record entry (pointer, pointer, fixed bin (21), fixed bin (35)) ; 4 34 4 35 dcl (iox_$user_output, 4 36 iox_$user_input, 4 37 iox_$user_io, 4 38 iox_$error_output) external static pointer; 4 39 4 40 /* ---------------- END include file iox_dcls.incl.pl1 ---------------- */ 139 140 141 142 143 /* cross_ring_attach entry point to attach cross_ring_ to a switch. sample command call would be: 144* 145* io_call attach x cross_ring_ target ringno 146* 147* cross_ring_ sets the pointers in the iocb to a gate, dispatch_ which 148* crosses into inner ring, and calls a pl1 program cross_ring_ring_io_ to drop validation level and forward. 149**/ 150 151 cross_ring_attach: 152 entry (iocb_ptr, attach_param, com_err_sw, return_code); 153 154 if cross_ring_gates_ptr_ = null 155 then cross_ring_gates_ptr_ = INIT_GATES (); 156 157 save_mask = ""b; 158 attach_data_ptr = null; 159 inner_index = ""b; 160 target_ring = 0; 161 162 on cleanup call clean_up_attach; 163 164 if hbound (attach_param, 1) ^= 2 165 then call att_err (error_table_$wrong_no_of_args, "Usage: cross_ring_ target_switch ringno."); 166 167 target_ring = cv_dec_check_ ((attach_param (2)), code); 168 if code ^= 0 169 then call att_err (error_table_$bad_conversion, attach_param (2) || " is not a valid integer."); 170 if target_ring < 1 171 then call att_err (error_table_$smallarg, 172 attach_param (2) || " is less than one. Cross Ring I/O to ring zero is not possible."); 173 if target_ring > cu_$level_get () 174 then call att_err (error_table_$badringno, 175 attach_param (2) || " is not less than or equal to the current validation level."); 176 177 /* We initialize only one ring's worth of entry variables because the 178* system only provides the gates r1_io_ through r4_io_. We would take 179* linkage errors on any others, but the user might have provided them. */ 180 181 call init_one_ring (target_ring, return_code); 182 if return_code ^= 0 183 then call att_err (return_code, "No cross ring I/O available for ring " || attach_param (2)); 184 185 /* Locate the inner ring switch (which must exist already) */ 186 187 call dispatch_find_attachment (target_ring) ((attach_param (1)), inner_index, code); 188 if code ^= 0 189 then call att_err (code, attach_param (1) || " is not a valid inner ring switch."); 190 191 /* Prevent multiple attachment */ 192 193 call hcs_$set_ips_mask ("0"b, save_mask); 194 if iocb_ptr -> iocb.attach_descrip_ptr ^= null 195 then call att_err (error_table_$not_detached, ""); 196 197 198 on area, bad_area_format 199 begin; 200 goto NO_ALLOC; 201 end; 202 203 allocate attach_data set (attach_data_ptr) in (system_free_area); 204 205 /* fill in iocb with things required by attach */ 206 207 iocb_ptr -> iocb.attach_data_ptr = attach_data_ptr; 208 iocb_ptr -> iocb.attach_descrip_ptr = addr (attach_data.atd); 209 iocb_ptr -> iocb.open = cross_ring_open; 210 iocb_ptr -> iocb.detach_iocb = cross_ring_detach; 211 iocb_ptr -> iocb.modes = dispatch_modes (target_ring); 212 iocb_ptr -> iocb.control = dispatch_control (target_ring); 213 attach_data.atd = myname || " " || attach_param (1) || " " || attach_param (2); 214 attach_data.inner_index = inner_index; 215 attach_data.target_ring = target_ring; 216 217 call iox_$propagate (iocb_ptr); 218 call hcs_$reset_ips_mask (save_mask, save_mask); 219 220 return_code = 0; 221 return; 222 223 NO_ALLOC: 224 call att_err (error_table_$noalloc, "Could not allocate space for attach data."); 225 226 /* some error occured during cross_ring_attach */ 227 228 att_err: 229 procedure (c, r); 230 declare c fixed bin (35); 231 declare r character (*); 232 233 if save_mask ^= ""b 234 then call hcs_$reset_ips_mask (save_mask, save_mask); 235 236 if com_err_sw 237 then call com_err_ (c, myname, "^a", r); 238 else call sub_err_ (c, myname, "c", null (), (0), "^a", r); 239 return_code = c; 240 go to RETURN; 241 end att_err; 242 RETURN: 243 return; 244 245 /* entry point to detach cross_ring_ */ 246 247 cross_ring_detach: 248 entry (iocb_ptr, return_code); 249 250 save_mask = ""b; 251 on cleanup call clean_up; 252 253 call hcs_$set_ips_mask (""b, save_mask); 254 act_iocb_ptr = iocb_ptr -> iocb.actual_iocb_ptr; 255 attach_data_ptr = act_iocb_ptr -> iocb.attach_data_ptr; 256 inner_index = attach_data.inner_index; 257 target_ring = attach_data.target_ring; 258 iocb_ptr -> iocb.attach_descrip_ptr = null; 259 call iox_$propagate (iocb_ptr); 260 call hcs_$reset_ips_mask (save_mask, save_mask); 261 call dispatch_release_attachment (target_ring) (inner_index, code); 262 return_code = 0; 263 return; 264 265 /* entry point to open cross_ring_ */ 266 267 cross_ring_open: 268 entry (iocb_ptr, open_mode, dummy, return_code); 269 270 if (open_mode < lbound (iox_modes, 1)) | (open_mode > hbound (iox_modes, 1)) 271 then do; 272 return_code = error_table_$bad_mode; 273 return; 274 end; 275 save_mask = ""b; 276 on cleanup call clean_up; 277 278 if return_code ^= 0 279 then return; 280 281 call hcs_$set_ips_mask (""b, save_mask); 282 act_iocb_ptr = iocb_ptr -> iocb.actual_iocb_ptr; 283 attach_data_ptr = act_iocb_ptr -> iocb.attach_data_ptr; 284 target_ring = attach_data.target_ring; 285 286 act_iocb_ptr -> iocb.close = cross_ring_close; /* close up shop inside too */ 287 act_iocb_ptr -> iocb.position = dispatch_position (target_ring); 288 if (open_mode = Stream_output) | (open_mode = Stream_input_output) 289 then act_iocb_ptr -> iocb.put_chars = dispatch_put_chars (target_ring); 290 if (open_mode = Stream_input) | (open_mode = Stream_input_output) 291 then act_iocb_ptr -> iocb.get_line = dispatch_get_line (target_ring); 292 if (open_mode = Stream_input) | (open_mode = Stream_input_output) 293 then act_iocb_ptr -> iocb.get_chars = dispatch_get_chars (target_ring); 294 if open_mode > Stream_input_output 295 then do; 296 act_iocb_ptr -> iocb.read_length = dispatch_read_length (target_ring); 297 act_iocb_ptr -> iocb.seek_key = dispatch_seek_key (target_ring); 298 act_iocb_ptr -> iocb.read_key = dispatch_read_key (target_ring); 299 act_iocb_ptr -> iocb.write_record = dispatch_write_record (target_ring); 300 act_iocb_ptr -> iocb.read_record = dispatch_read_record (target_ring); 301 act_iocb_ptr -> iocb.rewrite_record = dispatch_rewrite_record (target_ring); 302 act_iocb_ptr -> iocb.delete_record = dispatch_delete_record (target_ring); 303 end; 304 attach_data.open = iox_modes (open_mode); 305 attach_data.open_mode = open_mode; 306 act_iocb_ptr -> iocb.open_descrip_ptr = addr (attach_data.open); 307 inner_index = attach_data.inner_index; 308 call iox_$propagate (act_iocb_ptr); 309 call hcs_$reset_ips_mask (save_mask, save_mask); 310 311 call dispatch_open (target_ring) (inner_index, open_mode, dummy, return_code); 312 313 return; 314 315 /* entry to close cross_ring_ */ 316 317 cross_ring_close: 318 entry (iocb_ptr, return_code); 319 320 save_mask = ""b; 321 on cleanup call clean_up; 322 323 call hcs_$set_ips_mask (""b, save_mask); 324 act_iocb_ptr = iocb_ptr -> iocb.actual_iocb_ptr; 325 act_iocb_ptr -> iocb.open_descrip_ptr = null; 326 act_iocb_ptr -> iocb.open = cross_ring_open; 327 act_iocb_ptr -> iocb.detach_iocb = cross_ring_detach; 328 attach_data_ptr = act_iocb_ptr -> iocb.attach_data_ptr; 329 inner_index = attach_data.inner_index; 330 target_ring = attach_data.target_ring; 331 call iox_$propagate (act_iocb_ptr); 332 call hcs_$reset_ips_mask (save_mask, save_mask); 333 334 call dispatch_close (target_ring) (inner_index, return_code); 335 if return_code = error_table_$not_open 336 then return_code = 0; 337 return; 338 339 clean_up_attach: 340 procedure; 341 if inner_index ^= ""b 342 then call dispatch_release_attachment (target_ring) (inner_index, (0)); 343 clean_up: 344 entry; 345 if save_mask ^= ""b 346 then call hcs_$reset_ips_mask (save_mask, save_mask); 347 end clean_up_attach; 348 349 init_one_ring: 350 procedure (ring, code); 351 declare ring fixed bin; 352 declare code fixed bin (35); 353 declare hbound builtin; 354 declare entrypoints (17) character (32) 355 init ("find_attachment", "release_attachment", "open", "close", "modes", 356 "control", "position", "put_chars", "get_line", "get_chars", "read_length", 357 "seek_key", "read_key", "write_record", "read_record", "rewrite_record", 358 "delete_record") internal static options (constant); 359 360 declare 1 segname unaligned, 361 2 r character (1) init ("r"), 362 2 N picture "9", 363 2 io character (4) init ("_io_"); 364 365 /* Warning, the following is marginal (tho probably legal) PL/I */ 366 367 declare 1 gates_as_arrays (7) aligned based (cross_ring_gates_ptr_), 368 2 entries (17) entry variable; 369 370 declare ex fixed bin; 371 declare hcs_$make_entry entry (ptr, char (*), char (*), entry, fixed bin (35)); 372 373 segname.N = ring; 374 code = 0; 375 376 do ex = 1 to hbound (entrypoints, 1); 377 call hcs_$make_entry (null (), string (segname), entrypoints (ex), gates_as_arrays (ring).entries (ex), 378 code); 379 if code ^= 0 380 then return; 381 end; 382 383 end init_one_ring; 384 end cross_ring_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/04/82 1610.3 cross_ring_.pl1 >dumps>old>recomp>cross_ring_.pl1 134 1 02/08/82 2101.5 cross_ring_attach_data_.incl.pl1 >ldd>include>cross_ring_attach_data_.incl.pl1 136 2 07/28/81 1333.4 iocb.incl.pl1 >ldd>include>iocb.incl.pl1 138 3 02/02/78 1229.7 iox_modes.incl.pl1 >ldd>include>iox_modes.incl.pl1 139 4 07/22/80 1335.1 iox_entries.incl.pl1 >ldd>include>iox_dcls.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. N 0(09) 000154 automatic picture(1) level 2 packed unaligned dcl 360 set ref 373* Stream_input constant fixed bin(17,0) initial dcl 3-15 ref 290 292 Stream_input_output constant fixed bin(17,0) initial dcl 3-15 ref 288 290 292 294 Stream_output constant fixed bin(17,0) initial dcl 3-15 ref 288 act_iocb_ptr 000106 automatic pointer dcl 47 set ref 254* 255 282* 283 286 287 288 290 292 296 297 298 299 300 301 302 306 308* 324* 325 326 327 328 331* actual_iocb_ptr 12 based pointer level 2 dcl 2-4 ref 254 282 324 addr builtin function dcl 131 ref 208 306 area 000116 stack reference condition dcl 110 ref 198 atd based varying char(200) level 2 dcl 1-6 set ref 208 213* attach_data based structure level 1 dcl 1-6 set ref 203 attach_data_ptr 000132 automatic pointer dcl 1-5 in procedure "cross_ring_" set ref 158* 203* 207 208 213 214 215 255* 256 257 283* 284 304 305 306 307 328* 329 330 attach_data_ptr 16 based pointer level 2 in structure "iocb" dcl 2-4 in procedure "cross_ring_" set ref 207* 255 283 328 attach_descrip_ptr 14 based pointer level 2 dcl 2-4 set ref 194 208* 258* attach_param parameter varying char array dcl 33 ref 151 164 167 168 170 173 182 187 188 213 213 bad_area_format 000124 stack reference condition dcl 110 ref 198 c parameter fixed bin(35,0) dcl 230 set ref 228 236* 238* 239 cleanup 000110 stack reference condition dcl 110 ref 162 251 276 321 close 36 based entry variable level 2 dcl 2-4 set ref 286* code 000102 automatic fixed bin(35,0) dcl 44 in procedure "cross_ring_" set ref 167* 168 187* 188 188* 261* code parameter fixed bin(35,0) dcl 352 in procedure "init_one_ring" set ref 349 374* 377* 379 com_err_ 000020 constant entry external dcl 59 ref 236 com_err_sw parameter bit(1) unaligned dcl 35 ref 151 236 control 66 based entry variable level 2 dcl 2-4 set ref 212* cross_ring_gates_ptr_ 000026 external static pointer initial unaligned dcl 65 set ref 154 154* 187 211 212 261 287 288 290 292 296 297 298 299 300 301 302 311 334 341 377 cu_$level_get 000012 constant entry external dcl 54 ref 173 cv_dec_check_ 000010 constant entry external dcl 53 ref 167 delete_record 106 based entry variable level 2 dcl 2-4 set ref 302* detach_iocb 26 based entry variable level 2 dcl 2-4 set ref 210* 327* dispatch_close 14 based entry variable array level 2 dcl 80 set ref 334 dispatch_control 24 based entry variable array level 2 dcl 80 set ref 212 dispatch_delete_record 100 based entry variable array level 2 dcl 80 set ref 302 dispatch_find_attachment based entry variable array level 2 dcl 80 set ref 187 dispatch_get_chars 44 based entry variable array level 2 dcl 80 set ref 292 dispatch_get_line 40 based entry variable array level 2 dcl 80 set ref 290 dispatch_modes 20 based entry variable array level 2 dcl 80 set ref 211 dispatch_open 10 based entry variable array level 2 dcl 80 set ref 311 dispatch_position 30 based entry variable array level 2 dcl 80 set ref 287 dispatch_put_chars 34 based entry variable array level 2 dcl 80 set ref 288 dispatch_read_key 60 based entry variable array level 2 dcl 80 set ref 298 dispatch_read_length 50 based entry variable array level 2 dcl 80 set ref 296 dispatch_read_record 70 based entry variable array level 2 dcl 80 set ref 300 dispatch_release_attachment 4 based entry variable array level 2 dcl 80 set ref 261 341 dispatch_rewrite_record 74 based entry variable array level 2 dcl 80 set ref 301 dispatch_seek_key 54 based entry variable array level 2 dcl 80 set ref 297 dispatch_write_record 64 based entry variable array level 2 dcl 80 set ref 299 dummy parameter bit(1) unaligned dcl 38 set ref 267 311* entries based entry variable array level 2 dcl 367 set ref 377* entrypoints 000000 constant char(32) initial array unaligned dcl 354 set ref 376 377* error_table_$bad_conversion 000036 external static fixed bin(35,0) dcl 115 set ref 168* error_table_$bad_mode 000030 external static fixed bin(35,0) dcl 115 ref 272 error_table_$badringno 000040 external static fixed bin(35,0) dcl 115 set ref 173* error_table_$noalloc 000042 external static fixed bin(35,0) dcl 115 set ref 223* error_table_$not_detached 000044 external static fixed bin(35,0) dcl 124 set ref 194* error_table_$not_open 000032 external static fixed bin(35,0) dcl 115 ref 335 error_table_$smallarg 000034 external static fixed bin(35,0) dcl 115 set ref 170* error_table_$wrong_no_of_args 000046 external static fixed bin(35,0) dcl 126 set ref 164* ex 000156 automatic fixed bin(17,0) dcl 370 set ref 376* 377 377* gates based structure array level 1 dcl 80 set ref 71 72* gates_as_arrays based structure array level 1 dcl 367 get_chars 46 based entry variable level 2 dcl 2-4 set ref 292* get_line 42 based entry variable level 2 dcl 2-4 set ref 290* get_system_free_area_ 000024 constant entry external dcl 61 ref 203 gp 000144 automatic pointer unaligned dcl 69 set ref 71* 72 73 hbound builtin function dcl 131 in procedure "cross_ring_" ref 164 270 hbound builtin function dcl 353 in procedure "init_one_ring" ref 376 hcs_$make_entry 000052 constant entry external dcl 371 ref 377 hcs_$reset_ips_mask 000016 constant entry external dcl 55 ref 218 233 260 309 332 345 hcs_$set_ips_mask 000014 constant entry external dcl 55 ref 193 253 281 323 inner_index 71 based bit(72) level 2 in structure "attach_data" dcl 1-6 in procedure "cross_ring_" set ref 214* 256 307 329 inner_index 000104 automatic bit(72) dcl 45 in procedure "cross_ring_" set ref 159* 187* 214 256* 261* 307* 311* 329* 334* 341 341* io 0(18) 000154 automatic char(4) initial level 2 packed unaligned dcl 360 set ref 360* iocb based structure level 1 dcl 2-4 iocb_ptr parameter pointer dcl 32 set ref 151 194 207 208 209 210 211 212 217* 247 254 258 259* 267 282 317 324 iox_$propagate 000050 constant entry external dcl 4-6 ref 217 259 308 331 iox_modes 000210 constant char(24) initial array dcl 3-6 ref 270 270 304 modes 56 based entry variable level 2 dcl 2-4 set ref 211* myname 000326 constant char(11) initial unaligned dcl 46 set ref 213 236* 238* null builtin function dcl 131 ref 154 158 194 238 238 258 325 377 377 open 63 based varying char(20) level 2 in structure "attach_data" dcl 1-6 in procedure "cross_ring_" set ref 304* 306 open 32 based entry variable level 2 in structure "iocb" dcl 2-4 in procedure "cross_ring_" set ref 209* 326* open_descrip_ptr 20 based pointer level 2 dcl 2-4 set ref 306* 325* open_mode 74 based fixed bin(17,0) level 2 in structure "attach_data" dcl 1-6 in procedure "cross_ring_" set ref 305* open_mode parameter fixed bin(17,0) dcl 37 in procedure "cross_ring_" set ref 267 270 270 288 288 290 290 292 292 294 304 305 311* position 62 based entry variable level 2 dcl 2-4 set ref 287* put_chars 52 based entry variable level 2 dcl 2-4 set ref 288* r 000154 automatic char(1) initial level 2 in structure "segname" packed unaligned dcl 360 in procedure "init_one_ring" set ref 360* r parameter char unaligned dcl 231 in procedure "att_err" set ref 228 236* 238* read_key 116 based entry variable level 2 dcl 2-4 set ref 298* read_length 122 based entry variable level 2 dcl 2-4 set ref 296* read_record 72 based entry variable level 2 dcl 2-4 set ref 300* return_code parameter fixed bin(35,0) dcl 36 set ref 151 181* 182 182* 220* 239* 247 262* 267 272* 278 311* 317 334* 335 335* rewrite_record 102 based entry variable level 2 dcl 2-4 set ref 301* ring parameter fixed bin(17,0) dcl 351 ref 349 373 377 save_mask 000101 automatic bit(36) dcl 43 set ref 157* 193* 218* 218* 233 233* 233* 250* 253* 260* 260* 275* 281* 309* 309* 320* 323* 332* 332* 345 345* 345* seek_key 112 based entry variable level 2 dcl 2-4 set ref 297* segname 000154 automatic structure level 1 packed unaligned dcl 360 set ref 377 377 sub_err_ 000022 constant entry external dcl 60 ref 238 system_free_area based area(1024) dcl 49 ref 203 target_ring 73 based fixed bin(17,0) level 2 in structure "attach_data" dcl 1-6 in procedure "cross_ring_" set ref 215* 257 284 330 target_ring 000100 automatic fixed bin(17,0) dcl 42 in procedure "cross_ring_" set ref 160* 167* 170 173 181* 187 211 212 215 257* 261 284* 287 288 290 292 296 297 298 299 300 301 302 311 330* 334 341 write_record 76 based entry variable level 2 dcl 2-4 set ref 299* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. Direct_input internal static fixed bin(17,0) initial dcl 3-15 Direct_output internal static fixed bin(17,0) initial dcl 3-15 Direct_update internal static fixed bin(17,0) initial dcl 3-15 Keyed_sequential_input internal static fixed bin(17,0) initial dcl 3-15 Keyed_sequential_output internal static fixed bin(17,0) initial dcl 3-15 Keyed_sequential_update internal static fixed bin(17,0) initial dcl 3-15 Sequential_input internal static fixed bin(17,0) initial dcl 3-15 Sequential_input_output internal static fixed bin(17,0) initial dcl 3-15 Sequential_output internal static fixed bin(17,0) initial dcl 3-15 Sequential_update internal static fixed bin(17,0) initial dcl 3-15 error_table_$bad_arg external static fixed bin(35,0) dcl 123 fixed builtin function dcl 131 index builtin function dcl 131 iox_$attach_name 000000 constant entry external dcl 4-6 iox_$attach_ptr 000000 constant entry external dcl 4-6 iox_$close 000000 constant entry external dcl 4-6 iox_$control 000000 constant entry external dcl 4-6 iox_$delete_record 000000 constant entry external dcl 4-6 iox_$destroy_iocb 000000 constant entry external dcl 4-6 iox_$detach_iocb 000000 constant entry external dcl 4-6 iox_$err_no_operation 000000 constant entry external dcl 4-6 iox_$err_not_attached 000000 constant entry external dcl 4-6 iox_$err_not_closed 000000 constant entry external dcl 4-6 iox_$err_not_open 000000 constant entry external dcl 4-6 iox_$error_output external static pointer dcl 4-35 iox_$find_iocb 000000 constant entry external dcl 4-6 iox_$find_iocb_n 000000 constant entry external dcl 4-6 iox_$get_chars 000000 constant entry external dcl 4-6 iox_$get_line 000000 constant entry external dcl 4-6 iox_$iocb_version_sentinel external static char(4) dcl 2-43 iox_$look_iocb 000000 constant entry external dcl 4-6 iox_$modes 000000 constant entry external dcl 4-6 iox_$move_attach 000000 constant entry external dcl 4-6 iox_$open 000000 constant entry external dcl 4-6 iox_$position 000000 constant entry external dcl 4-6 iox_$put_chars 000000 constant entry external dcl 4-6 iox_$read_key 000000 constant entry external dcl 4-6 iox_$read_length 000000 constant entry external dcl 4-6 iox_$read_record 000000 constant entry external dcl 4-6 iox_$rewrite_record 000000 constant entry external dcl 4-6 iox_$seek_key 000000 constant entry external dcl 4-6 iox_$user_input external static pointer dcl 4-35 iox_$user_io external static pointer dcl 4-35 iox_$user_output external static pointer dcl 4-35 iox_$write_record 000000 constant entry external dcl 4-6 length builtin function dcl 131 ptr builtin function dcl 131 search builtin function dcl 131 short_iox_modes internal static char(4) initial array dcl 3-12 size builtin function dcl 131 substr builtin function dcl 131 NAMES DECLARED BY EXPLICIT CONTEXT. INIT_GATES 002367 constant entry internal dcl 67 ref 154 NO_ALLOC 001567 constant label dcl 223 ref 200 RETURN 001607 constant label dcl 242 ref 240 att_err 002464 constant entry internal dcl 228 ref 164 168 170 173 182 188 194 223 clean_up 002663 constant entry internal dcl 343 ref 251 276 321 clean_up_attach 002634 constant entry internal dcl 339 ref 162 cross_ring_ 000510 constant entry external dcl 12 cross_ring_attach 000532 constant entry external dcl 151 cross_ring_close 002232 constant entry external dcl 317 ref 286 cross_ring_detach 001614 constant entry external dcl 247 ref 210 327 cross_ring_open 001743 constant entry external dcl 267 ref 209 326 init_one_ring 002704 constant entry internal dcl 349 ref 181 null_entry 000517 constant entry external dcl 76 ref 72 NAMES DECLARED BY CONTEXT OR IMPLICATION. lbound builtin function ref 270 string builtin function ref 377 377 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 3400 3454 3020 3410 Length 3774 3020 54 304 357 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME cross_ring_ 206 external procedure is an external procedure. INIT_GATES internal procedure shares stack frame of external procedure cross_ring_. on unit on line 162 64 on unit on unit on line 198 64 on unit att_err 124 internal procedure is called during a stack extension. on unit on line 251 64 on unit on unit on line 276 64 on unit on unit on line 321 64 on unit clean_up_attach 74 internal procedure is called by several nonquick procedures. init_one_ring internal procedure shares stack frame of external procedure cross_ring_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME cross_ring_ 000100 target_ring cross_ring_ 000101 save_mask cross_ring_ 000102 code cross_ring_ 000104 inner_index cross_ring_ 000106 act_iocb_ptr cross_ring_ 000132 attach_data_ptr cross_ring_ 000144 gp INIT_GATES 000154 segname init_one_ring 000156 ex init_one_ring THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as alloc_cs cat_realloc_cs call_var_desc call_var call_ext_out_desc call_ext_out call_int_this_desc call_int_other return tra_ext enable shorten_stack ext_entry ext_entry_desc int_entry int_entry_desc alloc_based alloc_based_storage THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ cu_$level_get cv_dec_check_ get_system_free_area_ hcs_$make_entry hcs_$reset_ips_mask hcs_$set_ips_mask iox_$propagate sub_err_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. cross_ring_gates_ptr_ error_table_$bad_conversion error_table_$bad_mode error_table_$badringno error_table_$noalloc error_table_$not_detached error_table_$not_open error_table_$smallarg error_table_$wrong_no_of_args LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 12 000507 14 000515 76 000516 78 000524 151 000525 154 000550 157 000562 158 000563 159 000565 160 000567 162 000570 164 000612 167 000637 168 000704 170 000756 173 001031 181 001113 182 001124 187 001173 188 001244 193 001314 194 001330 198 001354 200 001370 198 001373 203 001400 207 001414 208 001420 209 001424 210 001432 211 001435 212 001445 213 001451 214 001541 215 001545 217 001547 218 001555 220 001565 221 001566 223 001567 242 001607 247 001610 250 001624 251 001625 253 001647 254 001662 255 001667 256 001671 257 001674 258 001676 259 001700 260 001707 261 001717 262 001734 263 001735 267 001736 270 001753 272 001761 273 001764 275 001765 276 001766 278 002010 281 002012 282 002025 283 002032 284 002034 286 002036 287 002042 288 002052 290 002070 292 002102 294 002111 296 002113 297 002120 298 002124 299 002130 300 002134 301 002140 302 002144 304 002150 305 002160 306 002162 307 002164 308 002167 309 002175 311 002205 313 002227 317 002230 320 002242 321 002243 323 002265 324 002300 325 002305 326 002307 327 002313 328 002316 329 002320 330 002323 331 002325 332 002334 334 002344 335 002361 337 002366 67 002367 71 002371 72 002375 73 002453 228 002463 233 002477 236 002511 238 002552 239 002624 240 002630 339 002633 341 002641 343 002661 345 002670 347 002703 349 002704 360 002706 373 002713 374 002723 376 002724 377 002731 379 003002 381 003006 383 003010 ----------------------------------------------------------- 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