COMPILATION LISTING OF SEGMENT ipc_real_ 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.0 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 13 /* format: style3 */ 14 15 /**** THE INTERPROCESS COMMUNICATION FACILITY. This procedure is resident in 16* all non-hardcore rings (1:7) to manipulate the event channels of those 17* rings. Every ring has its own Event Channel Table (ECT) and Event 18* Channel Index Table (ECIT) which is created dynamically when 19* ipc_$create_ev_chn is invoked for the first time in that ring. 20* 21* IPC manipulates the ECT pointed to either by the validation ring number 22* or by the event channel name. Only ipc_$block refers to its 23* current-ring's ECT for event-call interrogation, all other calls to 24* IPC manipulate the ECT in which the event channel given as argument is 25* located, provided that it is not an inner ring. */ 26 27 /* format: off */ 28 29 /* 30* IPC may return one of the following error codes: 31* 32* 0 = no error 33* 34* error_table_$wrong_channel_ring 35* = ring access violation (event channel resides in other than current ring) 36* 37* error_table_$invalid_channel 38* = event channel not found in ECT (incorrect event channel name) 39* 40* error_table_$not_a_wait_channel 41* = attempting to wait for event call channel 42* 43* error_table_$event_calls_not_masked 44* = attempting to unmask event calls when event call already unmasked 45* 46* error_table_$event_channel_cutoff 47* = attempting to read a channel or go blocked on a group of channels 48* all of which have been cutoff 49* 50* error_table_$event_channel_not_cutoff 51* = attempting to reconnect a channel which has not been cutoff 52* 53* error_table_$bad_arg 54* = erroneous argument 55**/ 56 57 /* format: on */ 58 59 /* 60* Initially coded by the very hands of Michael J. Spier, August 26, 1968 61* Rewritten for new ipc by Eleanor Donner Jan 1981 62* Modified September 1981 by J. Bongiovanni to fix the most obscure bug I've 63* ever seen 64* Modified September 1983 by Chris Jones to count event calls pending, not all events pending. 65* Modified 1984-11-02 by E. Swenson for new IPC event channel validation. 66**/ 67 68 69 /****^ HISTORY COMMENTS: 70* 1) change(86-08-12,Kissel), approve(86-08-12,MCR7473), 71* audit(86-10-08,Fawcett), install(86-11-03,MR12.0-1206): 72* Changed to support control point management. These changes were actually 73* done in February 1985 by G. Palter. 74* 2) change(86-08-12,Kissel), approve(86-08-12,MCR7479), 75* audit(86-10-08,Fawcett), install(86-11-03,MR12.0-1206): 76* Changed to add the create_event_channel and run_event_calls entries to 77* support async event channels. 78* END HISTORY COMMENTS */ 79 80 81 ipc_real_: 82 procedure (); 83 return; /* not an entry */ 84 85 /* Parameters */ 86 87 dcl P_create_arg_ptr ptr parameter; 88 dcl P_event_channel_name 89 fixed bin (71) parameter; 90 dcl P_event_channel_type 91 fixed bin parameter; 92 dcl P_code fixed bin (35) parameter; 93 dcl P_fast_channel_id fixed binary (18) parameter; 94 dcl P_procedure_ptr ptr parameter; 95 dcl P_event_wait_list_ptr 96 ptr parameter; 97 dcl P_datap ptr parameter; 98 dcl P_priority fixed bin (17) parameter; 99 dcl P_procedure_entry entry (ptr) variable parameter; 100 dcl P_old_control_point_id 101 bit (36) aligned parameter; 102 dcl P_new_control_point_id 103 bit (36) aligned parameter; 104 dcl P_found_event fixed bin (17) parameter; 105 dcl P_event_wait_info_ptr 106 ptr parameter; 107 dcl P_mask bit (36) aligned parameter; 108 109 /* External Entries */ 110 111 dcl continue_to_signal_ entry (fixed bin (35)); 112 dcl cu_$level_get entry returns (fixed bin (3)); 113 dcl cu_$level_set entry (fixed bin (3)); 114 dcl cu_$make_entry_value 115 entry (ptr, entry); 116 dcl get_ring_ entry returns (fixed bin (3)); 117 dcl hcs_$assign_channel entry (fixed bin (71), fixed bin (35)); 118 dcl hcs_$delete_channel ext entry (fixed bin (71), fixed bin (35)); 119 dcl hcs_$fblock entry (bit (36) aligned, bit (1) aligned); 120 dcl hcs_$read_events entry (bit (36) aligned, bit (1) aligned); 121 dcl hcs_$reset_ips_mask entry (bit (36) aligned, bit (36) aligned); 122 dcl hcs_$set_ips_mask entry (bit (36) aligned, bit (36) aligned); 123 dcl ipc_util_$create_ect 124 entry (ptr); 125 dcl ipc_util_$delete_entry 126 entry (ptr, ptr); 127 dcl ipc_util_$ect_error_handler 128 entry (fixed bin (35)); 129 dcl ipc_util_$make_entry 130 entry (ptr, fixed bin (8), ptr, fixed bin (15)); 131 dcl ipc_util_$verify_channel 132 entry (fixed bin (71), ptr, bit (1) aligned, fixed bin (35)); 133 dcl ipc_util_$verify_regular_channel 134 entry (fixed bin (71), ptr, fixed bin (35)); 135 dcl ipc_validate_$encode_event_channel_name 136 entry (fixed bin (18), fixed bin (35), bit (3) aligned, fixed bin (15), fixed bin (3), 137 bit (1) aligned, fixed bin (18), fixed bin (71)); 138 139 /* External Static */ 140 141 dcl error_table_$bad_arg 142 fixed bin (35) ext; 143 dcl error_table_$event_calls_not_masked 144 fixed bin (35) ext; 145 dcl error_table_$event_channel_cutoff 146 fixed bin (35) ext; 147 dcl error_table_$event_channel_not_cutoff 148 fixed bin (35) ext; 149 dcl error_table_$inconsistent_ect 150 fixed bin (35) ext; 151 dcl error_table_$not_a_wait_channel 152 fixed bin (35) ext; 153 dcl error_table_$unimplemented_version 154 fixed bin (35) ext static; 155 dcl ipc_data_$fast_channel_events 156 bit (36) aligned ext; 157 dcl ipc_data_$event_calls_pending 158 fixed bin ext; 159 160 /* Automatic */ 161 162 dcl added_to_waiting_lists 163 bit (1) aligned; 164 dcl block_val fixed bin (3); 165 dcl call_channel_procedure 166 entry (ptr) variable; 167 dcl 1 call_info aligned like event_call_info; 168 dcl check_channels bit (1) aligned; 169 dcl cur_ring fixed bin (3); 170 dcl current_control_point_id 171 bit (36) aligned; 172 dcl ecit_idx fixed bin (15); 173 dcl entry_type fixed bin (8); 174 dcl 1 entry_value aligned, 175 2 ep_ptr ptr, 176 2 env_ptr ptr; 177 dcl event_call_in_progress 178 bit (1) aligned; 179 dcl ev_chn_flags bit (3) aligned; 180 dcl event_channel_type fixed bin; 181 dcl fb71 fixed bin (71); 182 dcl found_call_event bit (1) aligned; 183 dcl found_event fixed bin; 184 dcl found_wait_event bit (1) aligned; 185 dcl inhibit_count fixed bin; 186 dcl is_fast bit (1) aligned; 187 dcl last_ectep ptr; 188 dcl loop fixed bin; 189 dcl mask bit (36) aligned; 190 dcl msg_ptr ptr; 191 dcl saved_message_thread 192 pointer; 193 dcl temp_found_event fixed bin; 194 195 /* Builtins */ 196 197 dcl addr builtin; 198 dcl codeptr builtin; 199 dcl environmentptr builtin; 200 dcl null builtin; 201 dcl stackbaseptr builtin; 202 dcl substr builtin; 203 dcl unspec builtin; 204 205 /* Conditions */ 206 207 dcl any_other condition; 208 dcl cleanup condition; 209 210 /* Constants */ 211 212 dcl (ON, YES, TRUE) bit (1) aligned static options (constant) init ("1"b); 213 dcl (OFF, NO) bit (1) aligned static options (constant) init ("0"b); 214 215 create_ev_chn: 216 entry (P_event_channel_name, P_code); 217 218 /**** This entry creates an event wait channel and returns the channel 219* name. */ 220 221 call find_ectp; /* get pointer to ECT header for current ring */ 222 223 mask = ""b; /* for any_other handler */ 224 on any_other call any_other_handler (); 225 226 call mask_ips_interrupts (mask); 227 228 call ipc_util_$make_entry (ect_ptr, WAIT, ectep, ecit_idx); 229 230 /* set message and control point queue pointers to null values */ 231 232 wait_channel.first_ev_msgp, wait_channel.last_ev_msgp = null (); 233 wait_channel.first_wcpp, wait_channel.last_wcpp = null (); 234 235 ev_chn_flags = ""b; /* we don't support anything else yet. */ 236 cur_ring = get_ring_ (); 237 238 call ipc_validate_$encode_event_channel_name (ect_header.r_offset, ect_header.r_factor, ev_chn_flags, ecit_idx, 239 cur_ring, REGULAR_CHANNEL_TYPE, (ect_header.seed), fb71); 240 ect_header.seed = ect_header.seed + 1; 241 242 /* put name in channel entry and return arg */ 243 244 wait_channel.name, unspec (P_event_channel_name) = unspec (fb71); 245 246 /* thread into list of wait channels */ 247 248 call thread_channel (WAIT); 249 call unmask_ips_interrupts (mask); 250 251 P_code = 0; 252 return; 253 254 create_event_channel: 255 entry (P_create_arg_ptr, P_event_channel_name, P_code); 256 257 /**** This entry creates an event channel of the specified type. The procedure 258* entry, data pointer, and priority arguments are ignored for wait type 259* channels and used for call type channels. */ 260 261 ipc_create_arg_structure_ptr = P_create_arg_ptr; 262 263 P_event_channel_name = 0; /* Initialize the outputs. */ 264 P_code = 0; 265 266 if ipc_create_arg_structure.version ^= ipc_create_arg_structure_v1 267 then do; 268 P_code = error_table_$unimplemented_version; 269 return; 270 end; 271 272 /* Set up to create the event channel. */ 273 274 call find_ectp; /* get pointer to ECT header for current ring */ 275 276 mask = ""b; /* for any_other handler */ 277 on any_other call any_other_handler (); 278 279 call mask_ips_interrupts (mask); 280 281 /*** Create a fast event wait channel. */ 282 283 if ipc_create_arg_structure.channel_type = FAST_EVENT_CHANNEL_TYPE 284 then do; 285 call hcs_$assign_channel (P_event_channel_name, P_code); 286 end; 287 288 /*** Create a normal event wait channel. */ 289 290 else if ipc_create_arg_structure.channel_type = WAIT_EVENT_CHANNEL_TYPE 291 then do; 292 call ipc_util_$make_entry (ect_ptr, WAIT, ectep, ecit_idx); 293 294 /*** Set message and control point queue pointers to null values. */ 295 296 wait_channel.first_ev_msgp, wait_channel.last_ev_msgp = null (); 297 wait_channel.first_wcpp, wait_channel.last_wcpp = null (); 298 299 ev_chn_flags = NORMAL_CHANNEL_FLAGS; 300 cur_ring = get_ring_ (); 301 302 call ipc_validate_$encode_event_channel_name (ect_header.r_offset, ect_header.r_factor, ev_chn_flags, 303 ecit_idx, cur_ring, REGULAR_CHANNEL_TYPE, (ect_header.seed), fb71); 304 ect_header.seed = ect_header.seed + 1; 305 306 /*** Put the name in the channel entry and the return argument. */ 307 308 wait_channel.name = unspec (fb71); 309 unspec (P_event_channel_name) = unspec (fb71); 310 311 /*** Thread into the list of wait channels. */ 312 313 call thread_channel (WAIT); 314 end; 315 316 /*** Create a normal or IPS wkp_ event call channel. */ 317 318 else if ipc_create_arg_structure.channel_type = CALL_EVENT_CHANNEL_TYPE 319 | ipc_create_arg_structure.channel_type = ASYNC_CALL_EVENT_CHANNEL_TYPE 320 then do; 321 call ipc_util_$make_entry (ect_ptr, CALL, ectep, ecit_idx); 322 323 /*** Set up the call channel structure. */ 324 325 call_channel.type = CALL; 326 327 call_channel.first_ev_msgp, call_channel.last_ev_msgp = null (); 328 329 call_channel.data_ptr = ipc_create_arg_structure.call_data_ptr; 330 call_channel.procedure_ptr = codeptr (ipc_create_arg_structure.call_entry); 331 call_channel.environment_ptr = environmentptr (ipc_create_arg_structure.call_entry); 332 call_channel.priority = ipc_create_arg_structure.call_priority; 333 call_channel.control_point_id = get_control_point_id_ (); 334 call_channel.call_inhibit = OFF; 335 336 /*** Set the flag that indicates what type of call channel this is. */ 337 /*** Since this information is also encoded in the channel name */ 338 /*** we only set this flag here and it remains the way we set it */ 339 /*** for the life of this entry. */ 340 341 if ipc_create_arg_structure.channel_type = CALL_EVENT_CHANNEL_TYPE 342 then do; 343 call_channel.flags.async_call = "0"b; 344 ev_chn_flags = NORMAL_CHANNEL_FLAGS; 345 end; 346 347 else do; 348 call_channel.flags.async_call = "1"b; 349 ev_chn_flags = SEND_IPS_WKP_CHANNEL_FLAGS; 350 end; 351 352 cur_ring = get_ring_ (); 353 354 call ipc_validate_$encode_event_channel_name (ect_header.r_offset, ect_header.r_factor, ev_chn_flags, 355 ecit_idx, cur_ring, REGULAR_CHANNEL_TYPE, (ect_header.seed), fb71); 356 ect_header.seed = ect_header.seed + 1; 357 358 /*** Put the name in the channel entry and the return argument. */ 359 360 call_channel.name = unspec (fb71); 361 unspec (P_event_channel_name) = unspec (fb71); 362 363 /*** Thread into the list of call channels. */ 364 365 call thread_channel (CALL); 366 end; 367 368 /*** He wants some type we have never heard of. */ 369 370 else P_code = error_table_$bad_arg; 371 372 /* All done, unmask and return, the channel name and the code have been set. */ 373 374 call unmask_ips_interrupts (mask); 375 376 return; 377 378 create_fast_ev_chn: 379 entry (P_fast_channel_id, P_code); 380 381 /**** This entry creates a wait channel definition for a fast event channel. 382* This wait channel definition is only used when control point management 383* is enabled to track the control points which have blocked on the fast 384* channel. */ 385 386 call find_ectp; /* get pointer to ECT header for current ring */ 387 388 mask = ""b; /* for any_other handler */ 389 on any_other call any_other_handler (); 390 391 call mask_ips_interrupts (mask); 392 393 call ipc_util_$make_entry (ect_ptr, WAIT, ectep, ecit_idx); 394 if P_fast_channel_id ^= ecit_idx 395 then do; /* fast channel's ECT index must match its ID */ 396 call ipc_util_$delete_entry (ect_ptr, ectep); 397 call inconsistent_ect (); /* ... will never return */ 398 end; 399 400 wait_channel.fast_channel = YES; /* this is a fast channel ECT entry */ 401 wait_channel.fast_channel_id = P_fast_channel_id; 402 403 wait_channel.first_ev_msgp, wait_channel.last_ev_msgp = null (); 404 wait_channel.first_wcpp, wait_channel.last_wcpp = null (); 405 406 /* Create the channel's name */ 407 408 ev_chn_flags = NORMAL_CHANNEL_FLAGS; 409 cur_ring = get_ring_ (); 410 call ipc_validate_$encode_event_channel_name (ect_header.r_offset, ect_header.r_factor, ev_chn_flags, ecit_idx, 411 cur_ring, FAST_CHANNEL_TYPE, (P_fast_channel_id), fb71); 412 wait_channel.name = unspec (fb71); 413 414 /* Thread into list of wait channels */ 415 416 call thread_channel (WAIT); 417 call unmask_ips_interrupts (mask); 418 419 P_code = 0; 420 return; 421 422 decl_ev_call_chn: 423 entry (P_event_channel_name, P_procedure_ptr, P_datap, P_priority, P_code); 424 425 call find_ectp; 426 427 mask = ""b; /* for any_other handler */ 428 on any_other call any_other_handler (); 429 430 call cu_$make_entry_value (P_procedure_ptr, call_channel_procedure); 431 call MAKE_EVENT_CALL (call_channel_procedure); 432 433 return; 434 435 decl_event_call_chn: 436 entry (P_event_channel_name, P_procedure_entry, P_datap, P_priority, P_code); 437 438 call find_ectp; 439 440 mask = ""b; /* for any_other handler */ 441 on any_other call any_other_handler (); 442 443 call MAKE_EVENT_CALL (P_procedure_entry); 444 445 return; 446 447 decl_ev_wait_chn: 448 entry (P_event_channel_name, P_code); 449 450 /**** 451* This entry turns an event channel into a wait channel. It works on 452* asynchronous call channels as well as normal call channels. If the 453* channel was asynchronous, then the IPS "wkp_" will still be sent, but 454* will essentially be a no-op. 455*****/ 456 457 call find_ectp; 458 call ipc_util_$verify_channel (P_event_channel_name, ectep, is_fast, P_code); 459 460 /* return if unable to locate channel or if already a wait channel */ 461 /* fast channels are considered to be wait channels */ 462 463 if (P_code ^= 0) | (is_fast = YES) 464 then return; 465 466 if (wait_channel.type = WAIT) 467 then return; 468 469 /* On with the show. */ 470 471 mask = ""b; /* for any_other handler */ 472 on any_other call any_other_handler (); 473 474 call mask_ips_interrupts (mask); 475 476 /* Save the list of pending messages */ 477 478 call save_channel_message_thread (saved_message_thread); 479 480 /* Remove last vestiges of this channel being a call channel, but leave the 481* flags alone just in case it becomes a call channel again. */ 482 483 call_channel.priority = 0; 484 call_channel.call_inhibit = OFF; 485 call unthread_channel; 486 487 /* Complete conversion into a wait channel */ 488 489 wait_channel.type = WAIT; 490 wait_channel.first_wcpp, wait_channel.last_wcpp = null (); 491 wait_channel.fast_channel_id, wait_channel.unused2 = 0; 492 call thread_channel (WAIT); 493 494 /* Rethread any pending messages saved above */ 495 496 call rethread_channel_message_thread (saved_message_thread); 497 498 call unmask_ips_interrupts (mask); 499 500 return; 501 502 reset_ev_call_chn: 503 entry (P_event_channel_name, P_code); 504 505 /**** This entry resets a call channel's inhibit flag */ 506 507 call find_ectp; 508 call ipc_util_$verify_regular_channel (P_event_channel_name, ectep, P_code); 509 510 if P_code ^= 0 511 then return; 512 513 if call_channel.type = CALL 514 then call_channel.call_inhibit = OFF; 515 516 return; 517 518 /* Reassigns ownership of all event call channels from one control point to 519* another -- This entrypoint is called by the control point manager whenever 520* it destroys a control point. */ 521 522 reassign_call_channels: 523 entry (P_old_control_point_id, P_new_control_point_id); 524 525 call find_ectp (); 526 527 mask = ""b; /* for any_other handler */ 528 on any_other call any_other_handler (); 529 530 call mask_ips_interrupts (mask); 531 532 do ectep = ect_header.firstp (CALL) repeat (call_channel.next_chanp) while (ectep ^= null ()); 533 if call_channel.type ^= CALL 534 then call inconsistent_ect (); 535 if call_channel.control_point_id = P_old_control_point_id 536 then call_channel.control_point_id = P_new_control_point_id; 537 end; 538 539 call unmask_ips_interrupts (mask); 540 541 return; 542 543 delete_ev_chn: 544 entry (P_event_channel_name, P_code); 545 546 /**** This entry deletes an event channel */ 547 548 call find_ectp; 549 call ipc_util_$verify_channel (P_event_channel_name, ectep, is_fast, P_code); 550 if P_code ^= 0 551 then return; 552 553 call decl_ev_wait_chn (P_event_channel_name, P_code); 554 /* make it event-wait channel */ 555 if P_code ^= 0 556 then return; 557 558 call drain_chn (P_event_channel_name, P_code); /* reset channel to zero */ 559 560 mask = ""b; /* for any_other handler */ 561 on any_other call any_other_handler (); 562 563 call mask_ips_interrupts (mask); 564 565 call reset_channel_wcps (); /* any waiting control points should now get an error */ 566 567 if is_fast = YES 568 then call hcs_$delete_channel (P_event_channel_name, P_code); 569 else do; 570 call unthread_channel; 571 call ipc_util_$delete_entry (ect_ptr, ectep); 572 P_code = 0; 573 end; 574 575 call unmask_ips_interrupts (mask); 576 577 return; 578 579 drain_chn: 580 entry (P_event_channel_name, P_code); 581 582 /**** Drains all currently waiting event messages from the channel. */ 583 584 found_event = 1; /* set default values */ 585 P_code = 0; 586 587 do loop = 1 to 2; 588 do while (found_event = 1 & P_code = 0); /* read events until channel empty */ 589 call read_ev_chn (P_event_channel_name, found_event, addr (call_info), P_code); 590 end; 591 592 if loop = 1 /* drain channel even if it has been cutoff */ 593 then if P_code ^= 0 594 then if P_code = error_table_$event_channel_cutoff 595 then do; 596 call reconnect (P_event_channel_name, (0)); 597 P_code = 0; 598 end; 599 end; 600 return; 601 602 cutoff: 603 entry (P_event_channel_name, P_code); 604 605 /**** Sets a flag to temporarily disable the channel for reading 606* purposes. */ 607 608 call find_ectp; 609 call set_inhibit_switch (1); 610 return; 611 612 reconnect: 613 entry (P_event_channel_name, P_code); 614 615 /**** Resets the inhibit flag reactivating the channel. */ 616 617 call find_ectp; 618 call set_inhibit_switch (-1); 619 return; 620 621 set_call_prior: 622 entry (P_code); 623 624 /**** For this ring, set priority so that event call channels are 625* interrogated before event wait channels. */ 626 627 call find_ectp; 628 call set_priority_switch (ON); 629 return; 630 631 set_wait_prior: 632 entry (P_code); 633 634 /**** For this ring, set priority so that event wait channels are 635* interrogated before event call channels. */ 636 637 call find_ectp; 638 call set_priority_switch (OFF); 639 return; 640 641 mask_ev_calls: 642 entry (P_code); 643 644 /**** Cause calls to ipc_$block ignore event call channels in this 645* ring. */ 646 647 call find_ectp; 648 call set_mask (1); 649 return; 650 651 unmask_ev_calls: 652 entry (P_code); 653 654 /**** Cause calls to ipc_$block to respond to event call channels 655* again for this ring. */ 656 657 call find_ectp; 658 call set_mask (-1); 659 return; 660 661 read_ev_chn: 662 entry (P_event_channel_name, P_found_event, P_event_wait_info_ptr, P_code); 663 664 /**** Read an event message out of an event channel */ 665 666 call find_ectp; 667 inhibit_count, P_found_event = 0; 668 669 call ipc_util_$verify_channel (P_event_channel_name, ectep, is_fast, P_code); 670 if P_code ^= 0 671 then return; 672 673 /* Only call ring-0 if the ECT does not already have any messages for this channel */ 674 675 block_val = cu_$level_get (); /* for cleanup handler required by copy_itt_messages */ 676 cur_ring = get_ring_ (); 677 on cleanup call cu_$level_set (block_val); 678 679 mask = ""b; /* for any_other handler required by copy_itt_messages */ 680 on any_other call any_other_handler (); 681 682 if is_fast = YES 683 then do; 684 call read_fast_channel (P_event_channel_name, P_found_event, P_event_wait_info_ptr); 685 if P_found_event = 0 686 then do; /* nothing known already: ask ring 0 */ 687 call copy_itt_messages (NO); 688 call read_fast_channel (P_event_channel_name, P_found_event, P_event_wait_info_ptr); 689 end; 690 end; 691 692 else do; /* regular channel */ 693 if wait_channel.first_ev_msgp = null () 694 then call copy_itt_messages (NO); /* nothing known already: ask ring 0 */ 695 call read_channel (inhibit_count, P_found_event, P_event_wait_info_ptr); 696 if inhibit_count ^= 0 /* logical error, channel inhibited */ 697 then P_code = error_table_$event_channel_cutoff; 698 end; 699 700 return; 701 702 /**** This entry waits for events to be signalled over event channels */ 703 704 full_block: 705 entry (P_event_wait_list_ptr, P_event_wait_info_ptr, P_code); 706 707 call find_ectp (); 708 709 event_wait_list_ptr = P_event_wait_list_ptr; 710 event_wait_info_ptr = P_event_wait_info_ptr; 711 event_wait_info.channel_index = 0; /* reset channel-index to zero */ 712 713 event_wait_list_n_channels = event_wait_list.n_channels; 714 /* get number of channels to read */ 715 716 if event_wait_list_n_channels <= 0 717 then do; /* erroneous argument */ 718 P_code = error_table_$bad_arg; 719 return; 720 end; 721 722 block_val = cu_$level_get (); /* for cleanup handler requried by copy_itt_messages ... */ 723 cur_ring = get_ring_ (); /* ... and hardcore_block */ 724 725 event_call_in_progress = NO; /* for cleanup handler required by check_call_channels */ 726 727 added_to_waiting_lists = NO; /* for cleanup handler if there are multiple control points */ 728 729 on cleanup 730 begin; 731 if added_to_waiting_lists = YES /* this control point will no longer be waiting */ 732 then call delete_from_waiting_lists_caller (event_wait_list_ptr); 733 if event_call_in_progress = YES /* the event call has been aborted */ 734 then do; 735 call_channel.call_inhibit = OFF; 736 event_call_in_progress = NO; 737 end; 738 call cu_$level_set (block_val); 739 end; 740 741 mask = ""b; /* for any_other handler required by copy_itt_messages */ 742 on any_other call any_other_handler (); 743 744 current_control_point_id = get_control_point_id_ (); 745 746 747 /* Main loop of ipc_$full_block */ 748 749 do while (TRUE); 750 751 call copy_itt_messages (NO); /* get pending ITT messages */ 752 753 /* format: off */ 754 check_channels = /* we can only check for events if ... */ 755 (have_multiple_control_points () = NO) |/* ... there is only one control point or ... */ 756 (ect_header.wakeup_control_points = NO);/* ... all control points are in their proper state */ 757 /* format: on */ 758 759 /* Check the channels for a pending event to satisfy this block */ 760 761 do while (check_channels = YES); 762 763 if ect_header.call_priority = YES 764 then do; /* check call channels first */ 765 call check_call_channels (ANY_CALL_EVENT_CHANNEL_TYPE, found_call_event); 766 if found_call_event = NO 767 then do; 768 call check_wait_channels (found_wait_event); 769 if (found_wait_event = YES) | (P_code ^= 0) 770 then go to RETURN_FROM_FULL_BLOCK; 771 end; 772 end; 773 774 else do; /* check the wait channels first */ 775 call check_wait_channels (found_wait_event); 776 if (found_wait_event = YES) | (P_code ^= 0) 777 then go to RETURN_FROM_FULL_BLOCK; 778 call check_call_channels (ANY_CALL_EVENT_CHANNEL_TYPE, found_call_event); 779 end; 780 781 check_channels = 782 (found_call_event = YES) 783 & ((have_multiple_control_points () = NO) | (ect_header.wakeup_control_points = NO)); 784 end; 785 786 /* Control arrives here iff we have to block until an event arrives -- If there 787* are multiple control points in the process, this control point will now 788* relinquish control of the process to someone else. If there's only one 789* control point, we can call ring 0 to block the process directly. */ 790 791 if have_multiple_control_points () = YES 792 then do; 793 if added_to_waiting_lists = NO /* put this control point on each channel's waiting list */ 794 then do; 795 call add_to_waiting_lists (); 796 if P_code ^= 0 797 then go to RETURN_FROM_FULL_BLOCK; 798 end; 799 call block_if_no_pending_events ();/* mark us blocked unless there are available events */ 800 if P_code ^= 0 801 then go to RETURN_FROM_FULL_BLOCK; 802 if ect_header.wakeup_control_points = YES 803 then call wakeup_blocked_control_points (); 804 call cpm_$scheduler (); /* find a control point to run */ 805 end; 806 807 else call hardcore_block (); 808 end; 809 810 811 /* Control arrives here when it's time to return to our caller and we might 812* have passed through the main loop at least once */ 813 814 RETURN_FROM_FULL_BLOCK: 815 if added_to_waiting_lists = YES 816 then call delete_from_waiting_lists (); 817 818 return; 819 820 /* This entrypoint is called by the control point scheduler when there are 821* no control points in the ready state. The purpose of this entrypoint is 822* to wait for any IPC event (fast or regular) to occur and to then notify 823* the control points waiting for those events. The notification will place 824* said control points into the ready state and the scheduler will then 825* select the one with the highest priority to process its wakeup. */ 826 827 wait_for_an_event: 828 entry (); 829 830 call find_ectp (); 831 832 block_val = cu_$level_get (); /* for cleanup handler requried by copy_itt_messages ... */ 833 cur_ring = get_ring_ (); /* ... and hardcore_block */ 834 on cleanup call cu_$level_set (block_val); 835 836 mask = ""b; /* for any_other handler required by copy_itt_messages */ 837 on any_other call any_other_handler (); 838 839 call copy_itt_messages (YES); /* pick up any events that have already arrived */ 840 841 if ect_header.wakeup_control_points = YES 842 then call wakeup_blocked_control_points (); /* inform the waiting control points if we found anything */ 843 else call hardcore_block (); /* otherwise, wait for something to happen */ 844 845 return; 846 847 run_event_calls: 848 entry (P_event_channel_type, P_code); 849 850 /* 851* * This entry causes any pending event calls of the specified type to be run. 852* * It makes one pass through the chains of pending events instead of scanning 853* * from the beginning of the chain after each event is processed (like 854* * full_block). The major reason for this entry is for use by the wkp_ IPS 855* * signal, whose contract is to run any pending event calls in the process. 856**/ 857 858 event_channel_type = P_event_channel_type; 859 860 if event_channel_type ^= CALL_EVENT_CHANNEL_TYPE & event_channel_type ^= ASYNC_CALL_EVENT_CHANNEL_TYPE 861 & event_channel_type ^= ANY_CALL_EVENT_CHANNEL_TYPE 862 then do; 863 P_code = error_table_$bad_arg; 864 return; 865 end; 866 867 call find_ectp (); 868 869 block_val = cu_$level_get (); /* Save the validation ring number. */ 870 cur_ring = get_ring_ (); /* Get the current ring number for calls to ring 0. */ 871 872 event_call_in_progress = NO; /* Triggers cleanup action. */ 873 /* Prevents check_call_channels procedure from being non-quick. */ 874 on cleanup 875 begin; 876 if event_call_in_progress = YES 877 then do; 878 call_channel.call_inhibit = OFF; 879 event_call_in_progress = NO; 880 end; 881 882 call cu_$level_set (block_val); 883 end; 884 885 /* Set up an any_other handler for copy_itt_messages and current_control_point_id for check_call_channels. */ 886 887 mask = ""b; 888 on any_other call any_other_handler (); 889 890 current_control_point_id = get_control_point_id_ (); 891 892 /* 893* * Calling copy_itt_messages once will get the pending events. As long as 894* * we don't call it again we won't get any more events in the ECT. This is 895* * how we guarantee that only the events that were pending when we are called 896* * will be handled even though check_call_channels starts from the beginning 897* * of the event messages each time we call it. 898**/ 899 900 call copy_itt_messages (NO); 901 902 found_call_event = YES; /* Do the loop at least once. */ 903 904 do while (found_call_event); /* Loop until no more. */ 905 call check_call_channels (P_event_channel_type, found_call_event); 906 end; 907 908 return; 909 910 find_ectp: 911 procedure (); 912 913 /**** Internal procedure to get a pointer to the ECT for this ring. 914* If there is none, one will be created. */ 915 916 ect_ptr = stackbaseptr () -> stack_header.ect_ptr; 917 if ect_ptr = null 918 then call ipc_util_$create_ect (ect_ptr); 919 920 end find_ectp; 921 922 /* Pickup any new event messages which have arrived since we last blocked */ 923 924 copy_itt_messages: 925 procedure (p_set_wcp); 926 927 dcl p_set_wcp bit (1) aligned parameter; 928 929 dcl an_ectep pointer; 930 dcl 1 a_call_channel like call_channel aligned based (an_ectep); 931 dcl 1 a_wait_channel like wait_channel aligned based (an_ectep); 932 dcl channel_id fixed binary; 933 dcl code fixed bin (35); 934 935 936 /* Check with ring 0 if there are no ITT messages already in the ECT */ 937 938 if ect_header.firstp (ITT_MESSAGE) = null 939 then do; 940 if block_val ^= cur_ring 941 then call cu_$level_set (cur_ring); 942 call hcs_$read_events (ipc_data_$fast_channel_events, ("0"b)); 943 if block_val ^= cur_ring 944 then call cu_$level_set (block_val); 945 end; 946 947 948 /* Record newly arrived fast events if multiple control points are present 949* in this process as more than one such control point may be blocked on a 950* fast channel */ 951 952 if (p_set_wcp = YES) | (have_multiple_control_points () = YES) 953 then do; 954 955 do an_ectep = ect_header.firstp (WAIT) repeat (a_wait_channel.next_chanp) while (an_ectep ^= null ()); 956 if a_wait_channel.type ^= WAIT 957 then call inconsistent_ect (); 958 if a_wait_channel.fast_channel = YES 959 then do; 960 channel_id = a_wait_channel.fast_channel_id; 961 if (substr (ipc_data_$fast_channel_events, channel_id, 1) = YES) 962 & (substr (ect_header.last_fast_channel_events, channel_id, 1) = NO) 963 then do; /* this is a fresh event */ 964 a_wait_channel.wakeup_control_points = YES; 965 ect_header.wakeup_control_points = YES; 966 end; 967 end; 968 end; 969 970 ect_header.last_fast_channel_events = ipc_data_$fast_channel_events; 971 end; /* remember the new events */ 972 973 974 /* Process the ITT messages */ 975 976 call mask_ips_interrupts (mask); 977 978 do msg_ptr = ect_header.firstp (ITT_MESSAGE) repeat (ect_header.firstp (ITT_MESSAGE)) while (msg_ptr ^= null); 979 980 ect_header.firstp (ITT_MESSAGE) = msg_ptr -> itt_message.next_itt_msgp; 981 if ect_header.lastp (ITT_MESSAGE) = msg_ptr 982 then ect_header.lastp (ITT_MESSAGE) = null; 983 ect_header.count (ITT_MESSAGE) = ect_header.count (ITT_MESSAGE) - 1; 984 985 call ipc_util_$verify_regular_channel (msg_ptr -> itt_message.channel_id, an_ectep, code); 986 987 if code = 0 988 then do; 989 990 /* This ITT message is intended for an existing channel -- add it to the appropriate queues */ 991 992 msg_ptr -> event_message.chanp = an_ectep; 993 994 if (p_set_wcp = YES) | (have_multiple_control_points () = YES) 995 then ect_header.wakeup_control_points, a_wait_channel.wakeup_control_points = YES; 996 /* must notify all control points in the process */ 997 998 if a_call_channel.type = CALL 999 then do; 1000 msg_ptr -> event_message.priority = a_call_channel.priority; 1001 call insert_event_call_message (msg_ptr); 1002 ect_header.total_call_wakeups = ect_header.total_call_wakeups + 1; 1003 end; 1004 else do; 1005 call insert_event_wait_message (msg_ptr); 1006 ect_header.total_wait_wakeups = ect_header.total_wait_wakeups + 1; 1007 end; 1008 1009 ect_header.total_wakeups = ect_header.total_wakeups + 1; 1010 a_wait_channel.wakeup_count = a_wait_channel.wakeup_count + 1; 1011 end; 1012 1013 1014 else do; 1015 1016 /* This ITT message is not intended for an existing channel -- throw it away */ 1017 1018 call ipc_util_$delete_entry (ect_ptr, msg_ptr); 1019 ect_header.ittes_tossed = ect_header.ittes_tossed + 1; 1020 end; 1021 1022 end; 1023 1024 call unmask_ips_interrupts (mask); 1025 1026 return; 1027 1028 end copy_itt_messages; 1029 1030 /* Scans the list of outstanding event messages for call channels -- If a 1031* message is found for a channel which is not inhibited and which was declared 1032* a call channel by this control point, and the channel is the right type, 1033* the message is removed from the queue and the call handler is invoked. */ 1034 1035 check_call_channels: 1036 procedure (P_event_channel_type, P_found_call_event); 1037 1038 dcl P_event_channel_type 1039 fixed bin parameter; 1040 dcl P_found_call_event bit (1) aligned parameter; 1041 1042 dcl call_msgp ptr; 1043 dcl ev_chn_flags bit (3) aligned; 1044 dcl got_message fixed bin; 1045 dcl is_fast bit (1) aligned; 1046 dcl rcode fixed bin (35); 1047 dcl saved_channel_name fixed bin (71); 1048 1049 1050 P_found_call_event = NO; /* assume failure */ 1051 1052 if ect_header.mask_call_count > 0 /* all event calls are shut off */ 1053 then return; 1054 1055 1056 /* Scan the list of call event messages */ 1057 1058 got_message = 0; 1059 1060 do call_msgp = ect_header.firstp (EV_CALL_MESSAGE) repeat (call_msgp) 1061 while ((call_msgp ^= null ()) & (got_message = 0)); 1062 1063 ectep = call_msgp -> event_message.chanp; /* find the channel which owns this message */ 1064 if call_channel.type ^= CALL 1065 then call inconsistent_ect (); 1066 1067 if call_channel.control_point_id = current_control_point_id 1068 then do; /* It is for this control point. */ 1069 if (^call_channel.flags.async_call 1070 & (P_event_channel_type = CALL_EVENT_CHANNEL_TYPE 1071 | P_event_channel_type = ANY_CALL_EVENT_CHANNEL_TYPE)) 1072 | (call_channel.flags.async_call 1073 & (P_event_channel_type = ASYNC_CALL_EVENT_CHANNEL_TYPE 1074 | P_event_channel_type = ANY_CALL_EVENT_CHANNEL_TYPE)) 1075 then call read_channel ((0), got_message, addr (call_info)); 1076 else ; /* This one is not for us. */ 1077 end; 1078 1079 call_msgp = call_msgp -> event_message.next_ev_msgp; 1080 end; 1081 1082 if got_message = 0 /* nothing found */ 1083 then return; 1084 1085 1086 /* An acceptable message was found -- Invoke the call channel's procedure */ 1087 1088 unspec (saved_channel_name) = unspec (call_channel.name); 1089 1090 entry_value.ep_ptr = call_channel.procedure_ptr; 1091 entry_value.env_ptr = call_channel.environment_ptr; 1092 unspec (call_channel_procedure) = unspec (entry_value); 1093 1094 call_info.data_ptr = call_channel.data_ptr; 1095 1096 event_call_in_progress = YES; /* inform full_block's cleanup handler */ 1097 1098 call_channel.call_inhibit = ON; /* prevent recursive invocations of this channel's handler */ 1099 1100 1101 /*** Call the user's program */ 1102 if have_multiple_control_points () = YES /* must always use cpm_ to insure our I/O switches are OK */ 1103 then call cpm_$generate_call_preferred (current_control_point_id, call_channel_procedure, addr (call_info), (0)) 1104 ; 1105 else call call_channel_procedure (addr (call_info)); 1106 1107 call ipc_util_$verify_regular_channel (saved_channel_name, (null ()), rcode); 1108 if rcode = 0 /* channel wasn't deleted by the handler ... */ 1109 then call_channel.call_inhibit = OFF; /* ... so we can allow subsequent wakeups */ 1110 1111 event_call_in_progress = NO; /* full_block's cleanup handler need not worry about it */ 1112 1113 P_found_call_event = YES; /* keep checking channels */ 1114 1115 return; 1116 1117 end check_call_channels; 1118 1119 check_wait_channels: 1120 procedure (P_found_event_wait); 1121 1122 dcl P_found_event_wait bit (1) aligned parameter; 1123 1124 dcl temp_channel_name fixed bin (71); 1125 dcl 1 message_info aligned like event_wait_info; 1126 dcl loop fixed bin; 1127 1128 P_found_event_wait = NO; 1129 inhibit_count = 0; 1130 1131 do loop = 1 to event_wait_list_n_channels; 1132 1133 temp_channel_name = event_wait_list.channel_id (loop); 1134 1135 call ipc_util_$verify_channel (temp_channel_name, ectep, is_fast, P_code); 1136 if P_code ^= 0 1137 then return; 1138 1139 if is_fast = YES 1140 then call read_fast_channel (temp_channel_name, temp_found_event, addr (message_info)); 1141 else do; 1142 if wait_channel.type ^= WAIT 1143 then do; 1144 P_code = error_table_$not_a_wait_channel; 1145 return; 1146 end; 1147 call read_channel (inhibit_count, temp_found_event, addr (message_info)); 1148 end; 1149 if temp_found_event ^= 0 1150 then do; 1151 event_wait_info.channel_id = message_info.channel_id; 1152 event_wait_info.message = message_info.message; 1153 event_wait_info.sender = message_info.sender; 1154 event_wait_info.dev_signal = message_info.dev_signal; 1155 event_wait_info.ring = message_info.ring; 1156 event_wait_info.channel_index = loop; 1157 P_found_event_wait = YES; 1158 return; 1159 end; 1160 end; 1161 1162 if inhibit_count = event_wait_list_n_channels 1163 then do; 1164 P_code = error_table_$event_channel_cutoff; 1165 return; 1166 end; 1167 1168 end check_wait_channels; 1169 1170 read_channel: 1171 proc (P_inhibit_count, P_found_event, P_event_wait_info_ptr); 1172 1173 /**** Internal procedure to read one event message out of a channel. */ 1174 1175 dcl P_inhibit_count fixed bin parameter; 1176 dcl P_found_event fixed bin parameter; 1177 dcl P_event_wait_info_ptr 1178 ptr parameter; 1179 1180 dcl msg_ptr ptr; 1181 1182 P_found_event = 0; /* set default return values */ 1183 1184 if call_channel.type = CALL & call_channel.call_inhibit = YES 1185 then return; /* event call procedure being called */ 1186 1187 if wait_channel.inhibit_count ^= 0 /* channel inhibited, must not be read */ 1188 then do; 1189 P_inhibit_count = P_inhibit_count + 1; /* increment count of inhibited channels */ 1190 return; /* ignore inhibited channel */ 1191 end; 1192 1193 /* having reached this point, we know that we have the right to try 1194* and read the event channel. */ 1195 1196 call mask_ips_interrupts (mask); 1197 1198 msg_ptr = wait_channel.first_ev_msgp; 1199 if msg_ptr ^= null () /* there's a message waiting */ 1200 then do; 1201 call unthread_event_message (msg_ptr); /* remove it from the queue */ 1202 if wait_channel.first_ev_msgp = null () /* don't notify other control points if no events are left */ 1203 then wait_channel.wakeup_control_points = NO; 1204 1205 P_event_wait_info_ptr -> event_wait_info = msg_ptr -> event_message.message_data, by name; 1206 /* return message to caller of ipc_$block */ 1207 1208 P_found_event = 1; /* set indicator = successful */ 1209 1210 call ipc_util_$delete_entry (ect_ptr, msg_ptr); 1211 /* delete the message entry */ 1212 end; 1213 1214 call unmask_ips_interrupts (mask); 1215 1216 end read_channel; 1217 1218 read_fast_channel: 1219 proc (P_channel_name, P_found_event, P_event_wait_info_ptr); 1220 1221 dcl P_channel_name fixed bin (71) parameter; 1222 dcl P_found_event fixed bin parameter; 1223 dcl P_event_wait_info_ptr 1224 ptr parameter; 1225 1226 dcl channel_index fixed bin; 1227 dcl unspec builtin; 1228 1229 dcl 1 ev_chn_name aligned like event_channel_name automatic; 1230 1231 P_found_event = 0; 1232 unspec (ev_chn_name) = unspec (P_channel_name); 1233 if ev_chn_name.type = REGULAR_CHANNEL_TYPE 1234 then return; 1235 1236 channel_index = ev_chn_name.unique_id; 1237 if substr (ipc_data_$fast_channel_events, channel_index, 1) = NO 1238 then return; 1239 1240 /**** Indicate we've read the event out. */ 1241 1242 substr (ipc_data_$fast_channel_events, channel_index, 1) = NO; 1243 1244 wait_channel.wakeup_control_points = NO; /* don't notify other control points about this channel now */ 1245 substr (ect_header.last_fast_channel_events, channel_index, 1) = NO; 1246 /* ... but be sure later events will notify */ 1247 1248 /**** And fill in return info */ 1249 1250 P_event_wait_info_ptr -> event_wait_info.channel_id = P_channel_name; 1251 P_event_wait_info_ptr -> event_wait_info.message = 0; 1252 P_event_wait_info_ptr -> event_wait_info.sender, P_event_wait_info_ptr -> event_wait_info.dev_signal = ""b; 1253 P_event_wait_info_ptr -> event_wait_info.ring = ev_chn_name.ring; 1254 1255 P_found_event = 1; 1256 1257 return; 1258 1259 end read_fast_channel; 1260 1261 /* Insert the given message into the event call queue based on its priority */ 1262 1263 insert_event_call_message: 1264 procedure (p_msg_ptr); 1265 1266 dcl p_msg_ptr pointer parameter; 1267 1268 dcl 1 next_event_message 1269 like event_message aligned based (next_msg_ptr); 1270 dcl next_msg_ptr pointer; 1271 dcl 1 p_event_message like event_message aligned based (p_msg_ptr); 1272 dcl prev_msg_ptr pointer; 1273 1274 p_event_message.type = EV_CALL_MESSAGE; 1275 1276 prev_msg_ptr = null (); /* assume it goes at the beginning of the queue */ 1277 1278 do next_msg_ptr = ect_header.firstp (EV_CALL_MESSAGE) repeat (next_event_message.next_ev_msgp) 1279 while (next_msg_ptr ^= null ()); 1280 if next_event_message.chanp -> call_channel.type ^= CALL 1281 then call inconsistent_ect (); 1282 if next_event_message.priority > p_event_message.priority 1283 then go to INSERT_THE_MESSAGE; 1284 else prev_msg_ptr = next_msg_ptr; 1285 end; 1286 1287 INSERT_THE_MESSAGE: 1288 call thread_event_message (p_msg_ptr, prev_msg_ptr); 1289 1290 return; 1291 1292 end insert_event_call_message; 1293 1294 1295 1296 /* Insert the given message onto the tail of the event wait queue */ 1297 1298 insert_event_wait_message: 1299 procedure (p_msg_ptr); 1300 1301 dcl p_msg_ptr pointer parameter; 1302 1303 p_msg_ptr -> event_message.type = EV_WAIT_MESSAGE; 1304 1305 call thread_event_message (p_msg_ptr, ect_header.lastp (EV_WAIT_MESSAGE)); 1306 1307 return; 1308 1309 end insert_event_wait_message; 1310 1311 /* Thread an event message into the list of active messages after the 1312* specified message */ 1313 1314 thread_event_message: 1315 procedure (p_msg_ptr, p_prev_msg_ptr); 1316 1317 dcl p_msg_ptr pointer parameter; 1318 dcl p_prev_msg_ptr pointer parameter; 1319 1320 dcl message_type fixed binary; 1321 dcl 1 next_event_message 1322 like event_message aligned based (next_msg_ptr); 1323 dcl next_msg_ptr pointer; 1324 dcl owning_chanp pointer; 1325 dcl 1 p_event_message like event_message aligned based (p_msg_ptr); 1326 dcl 1 prev_event_message 1327 like event_message aligned based (prev_msg_ptr); 1328 dcl prev_msg_ptr pointer; 1329 1330 message_type = p_event_message.type; 1331 owning_chanp = p_event_message.chanp; 1332 1333 if ((message_type = EV_WAIT_MESSAGE) & (owning_chanp -> wait_channel.type ^= WAIT)) 1334 | ((message_type = EV_CALL_MESSAGE) & (owning_chanp -> call_channel.type ^= CALL)) 1335 then call inconsistent_ect (); 1336 1337 /* First add the message to the end of the per-channel thread */ 1338 1339 if owning_chanp -> wait_channel.first_ev_msgp = null () 1340 then do; /* this is the first message for the channel */ 1341 if owning_chanp -> wait_channel.last_ev_msgp ^= null () 1342 then call inconsistent_ect (); 1343 owning_chanp -> wait_channel.first_ev_msgp = p_msg_ptr; 1344 p_event_message.prev_chan_msgp = null (); 1345 end; 1346 else do; /* the per-channel thread already has something on it */ 1347 if owning_chanp -> wait_channel.last_ev_msgp = null () 1348 then call inconsistent_ect (); 1349 if owning_chanp -> wait_channel.last_ev_msgp -> event_message.next_chan_msgp ^= null () 1350 then call inconsistent_ect (); 1351 owning_chanp -> wait_channel.last_ev_msgp -> event_message.next_chan_msgp = p_msg_ptr; 1352 p_event_message.prev_chan_msgp = owning_chanp -> wait_channel.last_ev_msgp; 1353 end; 1354 1355 owning_chanp -> wait_channel.last_ev_msgp = p_msg_ptr; 1356 p_event_message.next_chan_msgp = null (); 1357 1358 /* Now add the message to the per-type thread */ 1359 1360 prev_msg_ptr = p_prev_msg_ptr; /* this parameter could be ect_header.lastp (type) and, since 1361* its passed by reference, the value would change as we set 1362* ect_header.lastp (type) when adding to end of the queue */ 1363 1364 if prev_msg_ptr = null () 1365 then do; /* add it to the beginning */ 1366 next_msg_ptr = ect_header.firstp (message_type); 1367 ect_header.firstp (message_type) = p_msg_ptr; 1368 end; 1369 else do; /* add it to the middle or the end */ 1370 if prev_event_message.type ^= message_type 1371 then call inconsistent_ect (); 1372 next_msg_ptr = prev_event_message.next_ev_msgp; 1373 prev_event_message.next_ev_msgp = p_msg_ptr; 1374 end; 1375 1376 if next_msg_ptr = null () 1377 then do; /* add it to the end */ 1378 if ect_header.lastp (message_type) ^= prev_msg_ptr 1379 then call inconsistent_ect (); 1380 ect_header.lastp (message_type) = p_msg_ptr; 1381 end; 1382 else do; /* add it to the beginning or the middle */ 1383 if next_event_message.type ^= message_type 1384 then call inconsistent_ect (); 1385 next_event_message.prev_ev_msgp = p_msg_ptr; 1386 end; 1387 1388 p_event_message.prev_ev_msgp = prev_msg_ptr; 1389 p_event_message.next_ev_msgp = next_msg_ptr; 1390 1391 /* Update the appropriate counters */ 1392 1393 ect_header.count (message_type) = ect_header.count (message_type) + 1; 1394 if message_type = EV_CALL_MESSAGE /* let ipc_fast_ know */ 1395 then ipc_data_$event_calls_pending = ipc_data_$event_calls_pending + 1; 1396 1397 return; 1398 1399 end thread_event_message; 1400 1401 /* Unthread an event message from the list of active messages */ 1402 1403 unthread_event_message: 1404 procedure (p_msg_ptr); 1405 1406 dcl p_msg_ptr pointer parameter; 1407 1408 dcl message_type fixed binary; 1409 dcl owning_chanp pointer; 1410 dcl 1 p_event_message like event_message aligned based (p_msg_ptr); 1411 1412 message_type = p_event_message.type; 1413 owning_chanp = p_event_message.chanp; 1414 1415 if ((message_type = EV_WAIT_MESSAGE) & (owning_chanp -> wait_channel.type ^= WAIT)) 1416 | ((message_type = EV_CALL_MESSAGE) & (owning_chanp -> call_channel.type ^= CALL)) 1417 then call inconsistent_ect (); 1418 1419 /* First remove this message from the per-channel thread */ 1420 1421 if p_event_message.prev_chan_msgp = null () 1422 then do; /* this is the first message for the channel */ 1423 if owning_chanp -> wait_channel.first_ev_msgp ^= p_msg_ptr 1424 then call inconsistent_ect (); 1425 owning_chanp -> wait_channel.first_ev_msgp = p_event_message.next_chan_msgp; 1426 end; 1427 else do; /* this is in the middle of the channel's thread */ 1428 if p_event_message.prev_chan_msgp -> event_message.next_chan_msgp ^= p_msg_ptr 1429 then call inconsistent_ect (); 1430 p_event_message.prev_chan_msgp -> event_message.next_chan_msgp = p_event_message.next_chan_msgp; 1431 end; 1432 1433 if p_event_message.next_chan_msgp = null () 1434 then do; /* this is the last message for the channel */ 1435 if owning_chanp -> wait_channel.last_ev_msgp ^= p_msg_ptr 1436 then call inconsistent_ect (); 1437 owning_chanp -> wait_channel.last_ev_msgp = p_event_message.prev_chan_msgp; 1438 end; 1439 else do; /* this is in the middle of the channel's thread */ 1440 if p_event_message.next_chan_msgp -> event_message.prev_chan_msgp ^= p_msg_ptr 1441 then call inconsistent_ect (); 1442 p_event_message.next_chan_msgp -> event_message.prev_chan_msgp = p_event_message.prev_chan_msgp; 1443 end; 1444 1445 p_event_message.prev_chan_msgp, p_event_message.next_chan_msgp = null (); 1446 1447 /* Now remove this message from the per-type thread */ 1448 1449 if p_event_message.prev_ev_msgp = null () 1450 then do; /* this is the first message for the type */ 1451 if ect_header.firstp (message_type) ^= p_msg_ptr 1452 then call inconsistent_ect (); 1453 ect_header.firstp (message_type) = p_event_message.next_ev_msgp; 1454 end; 1455 else do; /* this is in the middle of the type's thread */ 1456 if p_event_message.prev_ev_msgp -> event_message.next_ev_msgp ^= p_msg_ptr 1457 then call inconsistent_ect (); 1458 p_event_message.prev_ev_msgp -> event_message.next_ev_msgp = p_event_message.next_ev_msgp; 1459 end; 1460 1461 if p_event_message.next_ev_msgp = null () 1462 then do; /* this is the last message for the type */ 1463 if ect_header.lastp (message_type) ^= p_msg_ptr 1464 then call inconsistent_ect (); 1465 ect_header.lastp (message_type) = p_event_message.prev_ev_msgp; 1466 end; 1467 else do; /* this is in the middle of the type's thread */ 1468 if p_event_message.next_ev_msgp -> event_message.prev_ev_msgp ^= p_msg_ptr 1469 then call inconsistent_ect (); 1470 p_event_message.next_ev_msgp -> event_message.prev_ev_msgp = p_event_message.prev_ev_msgp; 1471 end; 1472 1473 p_event_message.prev_ev_msgp, p_event_message.next_ev_msgp = null (); 1474 1475 /* Update the appropriate counters */ 1476 1477 ect_header.count (message_type) = ect_header.count (message_type) - 1; 1478 if message_type = EV_CALL_MESSAGE /* let ipc_fast_ know */ 1479 then ipc_data_$event_calls_pending = ipc_data_$event_calls_pending - 1; 1480 1481 return; 1482 1483 end unthread_event_message; 1484 1485 /* Save the list of pending messages for the "current" channel -- The messages 1486* are unthreaded from the "active" messages */ 1487 1488 save_channel_message_thread: 1489 procedure (p_saved_message_thread); 1490 1491 dcl p_saved_message_thread 1492 pointer parameter; 1493 dcl (msg_ptr, prev_msg_ptr, next_msg_ptr) 1494 pointer; 1495 1496 p_saved_message_thread, prev_msg_ptr = null (); 1497 1498 do msg_ptr = wait_channel.first_ev_msgp repeat (next_msg_ptr) while (msg_ptr ^= null ()); 1499 next_msg_ptr = msg_ptr -> event_message.next_chan_msgp; 1500 call unthread_event_message (msg_ptr); 1501 if prev_msg_ptr = null () 1502 then p_saved_message_thread = msg_ptr; /* this is the first message in the list */ 1503 else prev_msg_ptr -> event_message.next_chan_msgp = msg_ptr; 1504 prev_msg_ptr = msg_ptr; 1505 end; 1506 1507 return; 1508 1509 end save_channel_message_thread; 1510 1511 1512 1513 /* Rethread the list of pending messages for the "current" channel */ 1514 1515 rethread_channel_message_thread: 1516 procedure (p_saved_message_thread); 1517 1518 dcl p_saved_message_thread 1519 pointer parameter; 1520 dcl next_msg_ptr pointer; 1521 1522 do msg_ptr = p_saved_message_thread repeat (next_msg_ptr) while (msg_ptr ^= null ()); 1523 next_msg_ptr = msg_ptr -> event_message.next_chan_msgp; 1524 if msg_ptr -> event_message.chanp ^= ectep 1525 then call inconsistent_ect (); 1526 if wait_channel.type = WAIT 1527 then call insert_event_wait_message (msg_ptr); 1528 else do; 1529 msg_ptr -> event_message.priority = call_channel.priority; 1530 call insert_event_call_message (msg_ptr); 1531 end; 1532 end; 1533 1534 return; 1535 1536 end rethread_channel_message_thread; 1537 1538 thread_channel: 1539 proc (P_entry_type); 1540 1541 dcl P_entry_type fixed bin (8) parameter; 1542 1543 last_ectep = ect_header.lastp (P_entry_type); 1544 1545 /* list is empty */ 1546 1547 if last_ectep = null 1548 then do; /* thread in at beginning of list */ 1549 ect_header.firstp (P_entry_type) = ectep; 1550 wait_channel.prev_chanp = null; 1551 end; 1552 else do; /* thread in at end of list */ 1553 wait_channel.prev_chanp = last_ectep; 1554 last_ectep -> wait_channel.next_chanp = ectep; 1555 end; 1556 1557 /* fill in forward thread and tail of list */ 1558 1559 wait_channel.next_chanp = null; 1560 ect_header.lastp (P_entry_type) = ectep; 1561 1562 ect_header.count (P_entry_type) = ect_header.count (P_entry_type) + 1; 1563 1564 end thread_channel; 1565 1566 unthread_channel: 1567 procedure (); 1568 1569 entry_type = wait_channel.type; /* save type of ect entry */ 1570 1571 /* if first channel adjust head of list */ 1572 1573 if wait_channel.prev_chanp = null 1574 then ect_header.firstp (entry_type) = wait_channel.next_chanp; 1575 1576 /* otherwise thread out back pointer */ 1577 else wait_channel.prev_chanp -> wait_channel.next_chanp = wait_channel.next_chanp; 1578 1579 /* if last channel in list adjust tail of list*/ 1580 if wait_channel.next_chanp = null 1581 then ect_header.lastp (entry_type) = wait_channel.prev_chanp; 1582 1583 /* otherwise thread out forward pointer */ 1584 else wait_channel.next_chanp -> wait_channel.prev_chanp = wait_channel.prev_chanp; 1585 1586 /* set threads to null in entry */ 1587 wait_channel.next_chanp, wait_channel.prev_chanp = null; 1588 1589 ect_header.count (entry_type) = ect_header.count (entry_type) - 1; 1590 1591 end unthread_channel; 1592 1593 MAKE_EVENT_CALL: 1594 procedure (P_call_procedure); 1595 1596 /**** This internal procedure is called to turn the specified event 1597* channel into an event call channel. The channel must be valid 1598* and not be a special (i.e. fast) channel. Implicit parameters are 1599* P_event_channel_name, P_datap, P_priority, and P_code. */ 1600 1601 dcl P_call_procedure entry (ptr) variable; 1602 1603 call ipc_util_$verify_regular_channel (P_event_channel_name, ectep, P_code); 1604 if P_code ^= 0 /* do not allow fast channels */ 1605 then return; 1606 1607 call mask_ips_interrupts (mask); 1608 1609 /* Save the list of any pending messages -- If the channel is already a call 1610* channel, we may still have to rethread it as its priority may be changed. 1611* In either case, leave the flag indicating whether it is an async call 1612* channel alone, since it was set when the channel was created, and should 1613* not be changed (since it is also encoded in the channel name). */ 1614 1615 call save_channel_message_thread (saved_message_thread); 1616 1617 /* Convert it into a call channel */ 1618 1619 if wait_channel.type = WAIT 1620 then do; 1621 call reset_channel_wcps (); /* any waiting control points should now get an error */ 1622 call unthread_channel; 1623 call_channel.type = CALL; 1624 call thread_channel (CALL); 1625 end; 1626 1627 call_channel.data_ptr = P_datap; 1628 call_channel.procedure_ptr = codeptr (P_call_procedure); 1629 call_channel.environment_ptr = environmentptr (P_call_procedure); 1630 call_channel.priority = P_priority; 1631 call_channel.control_point_id = get_control_point_id_ (); 1632 call_channel.call_inhibit = OFF; 1633 1634 /* Rethread any pending messages for this channel */ 1635 1636 call rethread_channel_message_thread (saved_message_thread); 1637 1638 call unmask_ips_interrupts (mask); 1639 1640 end MAKE_EVENT_CALL; 1641 1642 set_inhibit_switch: 1643 procedure (P_inhibit_value); 1644 1645 dcl P_inhibit_value fixed bin (17) parameter; 1646 1647 call ipc_util_$verify_regular_channel (P_event_channel_name, ectep, P_code); 1648 if P_code ^= 0 1649 then return; 1650 1651 wait_channel.inhibit_count = wait_channel.inhibit_count + P_inhibit_value; 1652 1653 if wait_channel.inhibit_count < 0 1654 then do; 1655 wait_channel.inhibit_count = 0; 1656 P_code = error_table_$event_channel_not_cutoff; 1657 end; 1658 1659 end set_inhibit_switch; 1660 1661 set_priority_switch: 1662 procedure (P_priority_switch); 1663 1664 dcl P_priority_switch bit (1) aligned parameter; 1665 1666 P_code = 0; 1667 ect_header.flags.call_priority = P_priority_switch; 1668 1669 end set_priority_switch; 1670 1671 set_mask: 1672 procedure (P_mask_value); 1673 1674 dcl P_mask_value fixed bin; 1675 1676 P_code = 0; 1677 ect_header.mask_call_count = ect_header.mask_call_count + P_mask_value; 1678 1679 if ect_header.mask_call_count < 0 /* logical error, unpaired mask/unmask */ 1680 then do; 1681 ect_header.mask_call_count = 0; /* reset mask to 0 */ 1682 P_code = error_table_$event_calls_not_masked; 1683 /* code = logical error in use of IPC */ 1684 end; 1685 1686 end set_mask; 1687 1688 /* Mask all IPS interrupts */ 1689 1690 mask_ips_interrupts: 1691 procedure (p_mask); 1692 1693 dcl p_mask bit (36) aligned parameter; 1694 1695 call hcs_$set_ips_mask (""b, p_mask); 1696 1697 end mask_ips_interrupts; 1698 1699 1700 1701 /* Restore the IPS mask to its state prior to calling mask_ips_interrupts */ 1702 1703 unmask_ips_interrupts: 1704 procedure (p_mask); 1705 1706 dcl p_mask bit (36) aligned parameter; 1707 1708 if substr (p_mask, 36, 1) = ON 1709 then call hcs_$reset_ips_mask (p_mask, p_mask); 1710 1711 end unmask_ips_interrupts; 1712 1713 1714 1715 /* Invoke unmask_ips_interrupts -- This entrypoint exists to prevent making 1716* the unmask_ips_interrupts internal procedure non-quick by invoking it 1717* from within an on unit. */ 1718 1719 unmask_ips_interrupts_caller: 1720 entry (P_mask); 1721 1722 call unmask_ips_interrupts (P_mask); 1723 return; 1724 1725 /* Report that the ECT is inconsistent -- This procedure will never return as 1726* ipc_util_$ect_error_handler generates a fatal process error */ 1727 1728 inconsistent_ect: 1729 procedure (); 1730 1731 call unmask_ips_interrupts (mask); 1732 call ipc_util_$ect_error_handler (error_table_$inconsistent_ect); 1733 1734 end inconsistent_ect; 1735 1736 1737 1738 /* The any_other handler established whenever we have masked IPS signals */ 1739 1740 any_other_handler: 1741 procedure (); 1742 1743 call unmask_ips_interrupts_caller (mask); 1744 1745 call continue_to_signal_ ((0)); /* be sure the error gets through */ 1746 1747 end any_other_handler; 1748 1749 hardcore_block: 1750 procedure (); 1751 1752 /**** This procedure merely calls hardcore to block the process (or not, 1753* if there are new event wakeups). It makes sure that the validation 1754* level is set to the current ring before doing so. */ 1755 1756 if cur_ring ^= block_val 1757 then call cu_$level_set (cur_ring); 1758 1759 call hcs_$fblock (ipc_data_$fast_channel_events, ("0"b)); 1760 1761 if cur_ring ^= block_val 1762 then call cu_$level_set (block_val); 1763 1764 return; 1765 1766 end hardcore_block; 1767 1768 /* Determines if more than one control point is defined in this process */ 1769 1770 have_multiple_control_points: 1771 procedure () returns (bit (1) aligned); 1772 1773 if stackbaseptr () -> stack_header.cpm_enabled 1774 then return (cpm_data_$n_control_points > 1); 1775 else return (NO); 1776 1777 end have_multiple_control_points; 1778 1779 /* Adds the current control point to the list of control points waiting for 1780* an event to be signalled on each of the channels in a call to ipc_$block */ 1781 1782 add_to_waiting_lists: 1783 procedure (); 1784 1785 dcl loop fixed binary; 1786 1787 do loop = 1 to event_wait_list_n_channels; /* insure that all the channels are OK first */ 1788 call ipc_util_$verify_channel (event_wait_list.channel_id (loop), ectep, ("0"b), P_code); 1789 if P_code ^= 0 1790 then return; 1791 if wait_channel.type ^= WAIT 1792 then do; 1793 P_code = error_table_$not_a_wait_channel; 1794 return; 1795 end; 1796 end; 1797 1798 call mask_ips_interrupts (mask); 1799 1800 do loop = 1 to event_wait_list_n_channels; 1801 1802 call ipc_util_$verify_channel (event_wait_list.channel_id (loop), ectep, ("0"b), (0)); 1803 1804 do wcpp = wait_channel.first_wcpp repeat (waiting_control_point.next_wcpp) while (wcpp ^= null ()); 1805 if waiting_control_point.control_point_id = current_control_point_id 1806 then do; /* this control point is already blocked on this channel */ 1807 waiting_control_point.block_count = waiting_control_point.block_count + 1; 1808 go to PROCESS_NEXT_CHANNEL; 1809 end; 1810 end; 1811 1812 /*** Current control point not already blocked on this channel 1813* -- Setup another waiting_control_point for the channel */ 1814 1815 call ipc_util_$make_entry (ect_ptr, WAITING_CP, wcpp, (0)); 1816 waiting_control_point.control_point_id = current_control_point_id; 1817 waiting_control_point.block_count = 1; 1818 1819 if wait_channel.first_wcpp = null () 1820 then do; /* first control point for this channel */ 1821 if wait_channel.last_wcpp ^= null () 1822 then call inconsistent_ect (); 1823 wait_channel.first_wcpp = wcpp; 1824 waiting_control_point.prev_wcpp = null (); 1825 end; 1826 else do; /* add to the end of the list for this channel */ 1827 if wait_channel.last_wcpp = null () 1828 then call inconsistent_ect (); 1829 if wait_channel.last_wcpp -> waiting_control_point.next_wcpp ^= null () 1830 then call inconsistent_ect (); 1831 wait_channel.last_wcpp -> waiting_control_point.next_wcpp = wcpp; 1832 waiting_control_point.prev_wcpp = wait_channel.last_wcpp; 1833 end; 1834 1835 wait_channel.last_wcpp = wcpp; /* this control point is now the tail of the list */ 1836 waiting_control_point.next_wcpp = null (); 1837 1838 PROCESS_NEXT_CHANNEL: 1839 end; 1840 1841 added_to_waiting_lists = YES; 1842 1843 call unmask_ips_interrupts (mask); 1844 1845 end add_to_waiting_lists; 1846 1847 /* Make the current control point BLOCKED -- If, however, there are either wait 1848* or call events pending which are destined for this control point, we must 1849* not enter the BLOCKED state. If we did block, we would remain blocked 1850* until another event arrived which could possibly never happen. */ 1851 1852 block_if_no_pending_events: 1853 procedure (); 1854 1855 dcl loop fixed binary; 1856 1857 1858 /* First check the channels on which we are blocked */ 1859 1860 do loop = 1 to event_wait_list_n_channels; 1861 1862 call ipc_util_$verify_channel (event_wait_list.channel_id (loop), ectep, ("0"b), P_code); 1863 if P_code ^= 0 1864 then return; 1865 if wait_channel.type ^= WAIT 1866 then do; 1867 P_code = error_table_$not_a_wait_channel; 1868 return; 1869 end; 1870 1871 if wait_channel.fast_channel = YES 1872 then if substr (ipc_data_$fast_channel_events, wait_channel.fast_channel_id, 1) = YES 1873 then return; 1874 else ; 1875 1876 else /*** if wait_channel.fast_channel = NO then */ 1877 if wait_channel.first_ev_msgp ^= null () 1878 then return; 1879 else ; 1880 end; 1881 1882 1883 /* No events for any of the above channels -- Check all call channels */ 1884 1885 do ectep = ect_header.firstp (CALL) repeat (call_channel.next_chanp) while (ectep ^= null ()); 1886 1887 if call_channel.type ^= CALL 1888 then call inconsistent_ect (); 1889 1890 if call_channel.control_point_id = current_control_point_id 1891 then if call_channel.first_ev_msgp ^= null () 1892 then return; 1893 end; 1894 1895 1896 /* Control arrives here iff there are no events already present for 1897* this control point -- Block. */ 1898 1899 call cpm_$block (); 1900 1901 return; 1902 1903 end block_if_no_pending_events; 1904 1905 /* Removes the current control point from the above lists -- 1906* A non-quick version of this procedure follows on the next page*/ 1907 1908 delete_from_waiting_lists: 1909 procedure (); 1910 1911 dcl code fixed binary (35); 1912 dcl loop fixed binary; 1913 1914 call mask_ips_interrupts (mask); 1915 1916 do loop = 1 to event_wait_list_n_channels; 1917 1918 call ipc_util_$verify_channel (event_wait_list.channel_id (loop), ectep, ("0"b), code); 1919 if code ^= 0 /* the channel is no longer OK: skip it */ 1920 then go to PROCESS_NEXT_CHANNEL; 1921 if wait_channel.type ^= WAIT /* the channel is no longer a wait channel: skip it */ 1922 then go to PROCESS_NEXT_CHANNEL; 1923 1924 do wcpp = wait_channel.first_wcpp repeat (waiting_control_point.next_wcpp) while (wcpp ^= null ()); 1925 1926 if waiting_control_point.control_point_id = current_control_point_id 1927 then do; /* found the proper entry */ 1928 1929 if waiting_control_point.block_count = 1 1930 then do; /* this is the only time we were waiting on this channel */ 1931 if waiting_control_point.prev_wcpp = null () 1932 then do; /* this was the first control point for this channel */ 1933 if wait_channel.first_wcpp ^= wcpp 1934 then call inconsistent_ect (); 1935 wait_channel.first_wcpp = waiting_control_point.next_wcpp; 1936 end; 1937 else do; /* remove this control point from the middle of the list */ 1938 if waiting_control_point.prev_wcpp -> waiting_control_point.next_wcpp 1939 ^= wcpp 1940 then call inconsistent_ect (); 1941 waiting_control_point.prev_wcpp -> waiting_control_point.next_wcpp = 1942 waiting_control_point.next_wcpp; 1943 end; 1944 if waiting_control_point.next_wcpp = null () 1945 then do; /* this is the last control point for this channel */ 1946 if wait_channel.last_wcpp ^= wcpp 1947 then call inconsistent_ect (); 1948 wait_channel.last_wcpp = waiting_control_point.prev_wcpp; 1949 end; 1950 else do; /* remove this control point from the middle of the list */ 1951 if waiting_control_point.next_wcpp -> waiting_control_point.prev_wcpp 1952 ^= wcpp 1953 then call inconsistent_ect (); 1954 waiting_control_point.next_wcpp -> waiting_control_point.prev_wcpp = 1955 waiting_control_point.prev_wcpp; 1956 end; 1957 call ipc_util_$delete_entry (ect_ptr, wcpp); 1958 end; 1959 1960 else waiting_control_point.block_count = waiting_control_point.block_count - 1; 1961 /* this control point is still waiting on this channel */ 1962 1963 go to PROCESS_NEXT_CHANNEL; 1964 end; 1965 end; 1966 1967 call inconsistent_ect (); /* we aren't on the channel's list but we should be */ 1968 1969 PROCESS_NEXT_CHANNEL: 1970 end; 1971 1972 added_to_waiting_lists = NO; 1973 1974 call unmask_ips_interrupts (mask); 1975 1976 end delete_from_waiting_lists; 1977 1978 1979 1980 /* Invoke delete_from_waiting_lists -- This entrypoint exists to prevent making 1981* the delete_from_waiting_lists internal procedure non-quick by invoking it 1982* from within an on unit. */ 1983 1984 delete_from_waiting_lists_caller: 1985 entry (P_event_wait_list_ptr); 1986 1987 call find_ectp (); 1988 1989 event_wait_list_ptr = P_event_wait_list_ptr; 1990 event_wait_list_n_channels = event_wait_list.n_channels; 1991 1992 current_control_point_id = get_control_point_id_ (); 1993 1994 mask = ""b; /* for any_other handler */ 1995 on any_other call any_other_handler (); 1996 1997 call delete_from_waiting_lists (); 1998 1999 return; 2000 2001 /* Wakeup blocked control points -- If a control point is blocked on an event 2002* wait channel, it must be notified when a message arrives on that channel. 2003* Further, if a message arrives for an event call channel, the control point 2004* which "owns" that channel must be notified. */ 2005 2006 wakeup_blocked_control_points: 2007 procedure (); 2008 2009 dcl 1 a_wait_channel like wait_channel aligned based (an_ectep); 2010 dcl 1 a_call_channel like call_channel aligned based (an_ectep); 2011 dcl an_ectep pointer; 2012 2013 do an_ectep = ect_header.firstp (WAIT) repeat (a_wait_channel.next_chanp) while (an_ectep ^= null ()), 2014 ect_header.firstp (CALL) repeat (a_call_channel.next_chanp) while (an_ectep ^= null ()); 2015 if a_wait_channel.wakeup_control_points = YES 2016 then call wakeup_channel_control_points (an_ectep); 2017 end; 2018 2019 ect_header.wakeup_control_points = NO; 2020 2021 return; 2022 2023 end wakeup_blocked_control_points; 2024 2025 2026 2027 /* Wakeup the control points waiting on a single channel */ 2028 2029 wakeup_channel_control_points: 2030 procedure (p_ectep); 2031 2032 dcl p_ectep pointer parameter; 2033 2034 dcl 1 p_call_channel like call_channel aligned based (p_ectep); 2035 dcl 1 p_wait_channel like wait_channel aligned based (p_ectep); 2036 2037 if p_wait_channel.type = WAIT 2038 then do; /* a wait channel */ 2039 do wcpp = p_wait_channel.first_wcpp repeat (waiting_control_point.next_wcpp) while (wcpp ^= null ()); 2040 call cpm_$wakeup (waiting_control_point.control_point_id, (0)); 2041 end; 2042 p_wait_channel.wakeup_control_points = NO; 2043 end; 2044 2045 else do; /* a call channel */ 2046 call cpm_$wakeup (p_call_channel.control_point_id, (0)); 2047 p_call_channel.wakeup_control_points = NO; 2048 end; 2049 2050 return; 2051 2052 end wakeup_channel_control_points; 2053 2054 /* Resets a channel's waiting control points -- Any control points blocked on 2055* the channel are sent wakeups so that they may run and find that the channel 2056* has either been deleted or converted to an event call channel. The list of 2057* waiting control points is then deleted from the ECT. */ 2058 2059 reset_channel_wcps: 2060 procedure (); 2061 2062 dcl next_wcpp pointer; 2063 2064 if (have_multiple_control_points () = YES) & (wait_channel.wakeup_control_points = YES) 2065 then call wakeup_channel_control_points (ectep); 2066 2067 if wait_channel.first_wcpp ^= null () 2068 then do; 2069 do wcpp = wait_channel.first_wcpp repeat (next_wcpp) while (wcpp ^= null ()); 2070 next_wcpp = waiting_control_point.next_wcpp; 2071 call ipc_util_$delete_entry (ect_ptr, wcpp); 2072 end; 2073 wait_channel.first_wcpp, wait_channel.last_wcpp = null (); 2074 end; 2075 2076 return; 2077 2078 end reset_channel_wcps; 2079 2080 /* format: off */ 2081 /* 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 */ 2081 2082 /* BEGIN INCLUDE FILE event_call_info.incl.pl1 */ 2 2 2 3 /* T. Casey, May 1978 */ 2 4 2 5 dcl event_call_info_ptr ptr; 2 6 2 7 dcl 1 event_call_info aligned based (event_call_info_ptr), /* argument structure passed to event call procedure */ 2 8 2 channel_id fixed bin (71), /* event channel on which wakeup occurred */ 2 9 2 message fixed bin (71), /* 72 bits of information passed by sender of wakeup */ 2 10 2 sender bit (36), /* process id of sender */ 2 11 2 origin, 2 12 3 dev_signal bit (18) unaligned, /* "1"b if device signal */ 2 13 3 ring fixed bin (17) unaligned, /* ring from which sent */ 2 14 2 data_ptr ptr; /* ptr given to dcl_event_call_channel */ 2 15 2 16 /* END INCLUDE FILE event_call_info.incl.pl1 */ 2082 2083 /* Begin include file event_channel_name.incl.pl1 */ 3 2 3 3 /* format: style4 */ 3 4 3 5 /* Written 1984-11-02 by E. Swenson */ 3 6 3 7 3 8 /****^ HISTORY COMMENTS: 3 9* 1) change(86-08-09,Kissel), approve(86-08-12,MCR7479), 3 10* audit(86-10-08,Fawcett), install(86-11-03,MR12.0-1206): 3 11* Added constants for the flag values and declared a structure to describe 3 12* the encoded_index after it is decoded. This include file has also been 3 13* converted to ALM for use by pxss. 3 14* END HISTORY COMMENTS */ 3 15 3 16 3 17 dcl 1 event_channel_name structure aligned based, 3 18 2 encoded_index bit (18) unaligned, 3 19 2 verifier bit (18) unaligned, 3 20 2 ring fixed bin (3) unsigned unaligned, 3 21 2 type bit (1) unaligned, /* "1"b for regular, "0"b for fast */ 3 22 2 mbz bit (14) unaligned, 3 23 2 unique_id fixed bin (18) unsigned unaligned; 3 24 3 25 dcl FAST_CHANNEL_TYPE bit (1) aligned initial ("0"b) internal static options (constant); 3 26 dcl REGULAR_CHANNEL_TYPE bit (1) aligned initial ("1"b) internal static options (constant); 3 27 3 28 dcl NORMAL_CHANNEL_FLAGS bit (3) aligned internal static options (constant) init ("000"b); 3 29 dcl SEND_IPS_WKP_CHANNEL_FLAGS bit (3) aligned internal static options (constant) init ("001"b); 3 30 3 31 /* Structure for use after the encoded_index in the event_channel_name has been decoded. */ 3 32 3 33 dcl 1 decoded_index structure aligned based, 3 34 2 flags bit (3) unaligned, 3 35 2 index fixed bin (15) unsigned unaligned; 3 36 3 37 dcl ENCODED_INDEX_CONSTANT fixed bin (35) internal static options (constant) init (262144); 3 38 3 39 /* End include file event_channel_name.incl.pl1 */ 2083 2084 /* BEGIN INCLUDE FILE event_wait_info.incl.pl1 */ 4 2 4 3 /* T. Casey, May 1978 */ 4 4 4 5 dcl event_wait_info_ptr ptr; 4 6 4 7 dcl 1 event_wait_info aligned based (event_wait_info_ptr), /* argument structure filled in on return from ipc_$block */ 4 8 2 channel_id fixed bin (71), /* event channel on which wakeup occurred */ 4 9 2 message fixed bin (71), /* 72 bits of information passed by sender of wakeup */ 4 10 2 sender bit (36), /* process id of sender */ 4 11 2 origin, 4 12 3 dev_signal bit (18) unaligned, /* "1"b if device signal */ 4 13 3 ring fixed bin (17) unaligned, /* ring from which sent */ 4 14 2 channel_index fixed bin; /* index of this channel in the event wait list */ 4 15 4 16 /* END INCLUDE FILE event_wait_info.incl.pl1 */ 2084 2085 /* BEGIN INCLUDE FILE ... event_wait_list.incl.pl1 */ 5 2 5 3 /* ipc_$block wait list structure -- Must begin on an even word boundary. 5 4* 5 5* Written 9-May-79 by M. N. Davidoff. 5 6**/ 5 7 5 8 declare event_wait_list_n_channels 5 9 fixed binary; 5 10 declare event_wait_list_ptr pointer; 5 11 5 12 declare 1 event_wait_list aligned based (event_wait_list_ptr), 5 13 2 n_channels fixed binary, /* number of channels in wait list */ 5 14 2 pad bit (36), 5 15 2 channel_id (event_wait_list_n_channels refer (event_wait_list.n_channels)) fixed binary (71); 5 16 /* event channels to wait on */ 5 17 5 18 /* END INCLUDE FILE ... event_wait_list.incl.pl1 */ 2085 2086 /*----------BEGIN ipc_create_arg.incl.pl1------------------------------------*/ 6 2 6 3 /* 6 4* This include file declares the structure which is the input argument to 6 5* ipc_$create_event_channel. 6 6**/ 6 7 6 8 /****^ HISTORY COMMENTS: 6 9* 1) change(86-08-12,Kissel), approve(86-08-12,MCR7479), 6 10* audit(86-10-08,Fawcett), install(86-11-03,MR12.0-1206): 6 11* New include file added to support async event channels. 6 12* END HISTORY COMMENTS */ 6 13 6 14 /* format: style3,linecom,ifthenstmt,indthenelse,^indnoniterdo,indnoniterend,initcol3,dclind5,idind32 */ 6 15 6 16 dcl ipc_create_arg_structure_ptr ptr; 6 17 dcl ipc_create_arg_structure_v1 char (8) internal static options (constant) init ("ipcarg01"); 6 18 6 19 dcl 1 ipc_create_arg_structure aligned based (ipc_create_arg_structure_ptr), 6 20 2 version char (8) unaligned, /* From above. */ 6 21 2 channel_type fixed bin, /* See constants below. */ 6 22 2 call_entry variable entry (ptr), /* For event call channels -- who to call. */ 6 23 2 call_data_ptr ptr, /* For event call channels -- something to tell them. */ 6 24 2 call_priority fixed bin (17); /* For event call channels -- who's first? */ 6 25 6 26 /* Constants for the event channel type. */ 6 27 6 28 dcl FAST_EVENT_CHANNEL_TYPE fixed bin internal static options (constant) init (1); 6 29 dcl WAIT_EVENT_CHANNEL_TYPE fixed bin internal static options (constant) init (2); 6 30 dcl CALL_EVENT_CHANNEL_TYPE fixed bin internal static options (constant) init (3); 6 31 dcl ASYNC_CALL_EVENT_CHANNEL_TYPE fixed bin internal static options (constant) init (4); 6 32 6 33 dcl ANY_CALL_EVENT_CHANNEL_TYPE fixed bin internal static options (constant) init (10); 6 34 6 35 /*----------END ipc_create_arg.incl.pl1--------------------------------------*/ 2086 2087 /* BEGIN INCLUDE FILE ... stack_header.incl.pl1 .. 3/72 Bill Silver */ 7 2 /* modified 7/76 by M. Weaver for *system links and more system use of areas */ 7 3 /* modified 3/77 by M. Weaver to add rnt_ptr */ 7 4 /* Modified April 1983 by C. Hornig for tasking */ 7 5 7 6 /****^ HISTORY COMMENTS: 7 7* 1) change(86-06-24,DGHowe), approve(86-06-24,MCR7396), 7 8* audit(86-08-05,Schroth), install(86-11-03,MR12.0-1206): 7 9* added the heap_header_ptr definition. 7 10* 2) change(86-08-12,Kissel), approve(86-08-12,MCR7473), 7 11* audit(86-10-10,Fawcett), install(86-11-03,MR12.0-1206): 7 12* Modified to support control point management. These changes were actually 7 13* made in February 1985 by G. Palter. 7 14* 3) change(86-10-22,Fawcett), approve(86-10-22,MCR7473), 7 15* audit(86-10-22,Farley), install(86-11-03,MR12.0-1206): 7 16* Remove the old_lot pointer and replace it with cpm_data_ptr. Use the 18 7 17* bit pad after cur_lot_size for the cpm_enabled. This was done to save some 7 18* space int the stack header and change the cpd_ptr unal to cpm_data_ptr 7 19* (ITS pair). 7 20* END HISTORY COMMENTS */ 7 21 7 22 /* format: style2 */ 7 23 7 24 dcl sb ptr; /* the main pointer to the stack header */ 7 25 7 26 dcl 1 stack_header based (sb) aligned, 7 27 2 pad1 (4) fixed bin, /* (0) also used as arg list by outward_call_handler */ 7 28 2 cpm_data_ptr ptr, /* (4) pointer to control point which owns this stack */ 7 29 2 combined_stat_ptr ptr, /* (6) pointer to area containing separate static */ 7 30 2 clr_ptr ptr, /* (8) pointer to area containing linkage sections */ 7 31 2 max_lot_size fixed bin (17) unal, /* (10) DU number of words allowed in lot */ 7 32 2 main_proc_invoked fixed bin (11) unal, /* (10) DL nonzero if main procedure invoked in run unit */ 7 33 2 have_static_vlas bit (1) unal, /* (10) DL "1"b if (very) large arrays are being used in static */ 7 34 2 pad4 bit (2) unal, 7 35 2 run_unit_depth fixed bin (2) unal, /* (10) DL number of active run units stacked */ 7 36 2 cur_lot_size fixed bin (17) unal, /* (11) DU number of words (entries) in lot */ 7 37 2 cpm_enabled bit (18) unal, /* (11) DL non-zero if control point management is enabled */ 7 38 2 system_free_ptr ptr, /* (12) pointer to system storage area */ 7 39 2 user_free_ptr ptr, /* (14) pointer to user storage area */ 7 40 2 null_ptr ptr, /* (16) */ 7 41 2 stack_begin_ptr ptr, /* (18) pointer to first stack frame on the stack */ 7 42 2 stack_end_ptr ptr, /* (20) pointer to next useable stack frame */ 7 43 2 lot_ptr ptr, /* (22) pointer to the lot for the current ring */ 7 44 2 signal_ptr ptr, /* (24) pointer to signal procedure for current ring */ 7 45 2 bar_mode_sp ptr, /* (26) value of sp before entering bar mode */ 7 46 2 pl1_operators_ptr ptr, /* (28) pointer to pl1_operators_$operator_table */ 7 47 2 call_op_ptr ptr, /* (30) pointer to standard call operator */ 7 48 2 push_op_ptr ptr, /* (32) pointer to standard push operator */ 7 49 2 return_op_ptr ptr, /* (34) pointer to standard return operator */ 7 50 2 return_no_pop_op_ptr 7 51 ptr, /* (36) pointer to standard return / no pop operator */ 7 52 2 entry_op_ptr ptr, /* (38) pointer to standard entry operator */ 7 53 2 trans_op_tv_ptr ptr, /* (40) pointer to translator operator ptrs */ 7 54 2 isot_ptr ptr, /* (42) pointer to ISOT */ 7 55 2 sct_ptr ptr, /* (44) pointer to System Condition Table */ 7 56 2 unwinder_ptr ptr, /* (46) pointer to unwinder for current ring */ 7 57 2 sys_link_info_ptr ptr, /* (48) pointer to *system link name table */ 7 58 2 rnt_ptr ptr, /* (50) pointer to Reference Name Table */ 7 59 2 ect_ptr ptr, /* (52) pointer to event channel table */ 7 60 2 assign_linkage_ptr ptr, /* (54) pointer to storage for (obsolete) hcs_$assign_linkage */ 7 61 2 heap_header_ptr ptr, /* (56) pointer to the heap header for this ring */ 7 62 2 trace, 7 63 3 frames, 7 64 4 count fixed bin, /* (58) number of trace frames */ 7 65 4 top_ptr ptr unal, /* (59) pointer to last trace frame */ 7 66 3 in_trace bit (36) aligned, /* (60) trace antirecursion flag */ 7 67 2 pad2 bit (36), /* (61) */ 7 68 2 pad5 pointer; /* (62) pointer to future stuff */ 7 69 7 70 /* The following offset refers to a table within the pl1 operator table. */ 7 71 7 72 dcl tv_offset fixed bin init (361) internal static; 7 73 /* (551) octal */ 7 74 7 75 7 76 /* The following constants are offsets within this transfer vector table. */ 7 77 7 78 dcl ( 7 79 call_offset fixed bin init (271), 7 80 push_offset fixed bin init (272), 7 81 return_offset fixed bin init (273), 7 82 return_no_pop_offset fixed bin init (274), 7 83 entry_offset fixed bin init (275) 7 84 ) internal static; 7 85 7 86 7 87 7 88 7 89 7 90 /* The following declaration is an overlay of the whole stack header. Procedures which 7 91* move the whole stack header should use this overlay. 7 92**/ 7 93 7 94 dcl stack_header_overlay (size (stack_header)) fixed bin based (sb); 7 95 7 96 7 97 7 98 /* END INCLUDE FILE ... stack_header.incl.pl1 */ 2087 2088 /* BEGIN INCLUDE FILE ... cpm_entries.incl.pl1 */ 8 2 8 3 /****^ HISTORY COMMENTS: 8 4* 1) change(86-08-12,Kissel), approve(86-08-12,MCR7473), 8 5* audit(86-10-08,Fawcett), install(86-11-03,MR12.0-1206): 8 6* Written to support control point management in March 1985 by G. Palter. 8 7* END HISTORY COMMENTS */ 8 8 8 9 /* format: style3,linecom */ 8 10 8 11 /* Control Point Manager (cpm_) entrypoint definitions */ 8 12 8 13 dcl get_control_point_id_ /* returns the ID of the currently running control point */ 8 14 entry () returns (bit (36) aligned); 8 15 8 16 dcl cpm_$create /* create a new control point */ 8 17 entry (pointer, bit (36) aligned, fixed binary (35)); 8 18 8 19 dcl ( 8 20 cpm_$destroy, /* destroy the specified control point */ 8 21 cpm_$start, /* start the specified control point if its stopped */ 8 22 cpm_$wakeup, /* make the specified control point ready if its blocked */ 8 23 cpm_$stop /* stop the specified control point if its ready or blocked */ 8 24 ) entry (bit (36) aligned, fixed binary (35)); 8 25 8 26 dcl cpm_$block entry (); /* block the current control point */ 8 27 8 28 dcl cpm_$scheduler entry (); /* find a runnable control point and let it run */ 8 29 8 30 dcl ( 8 31 cpm_$get_user_cl_intermediary, /* get the user supplied procedure to run during cu_$cl */ 8 32 cpm_$set_user_cl_intermediary /* set the user supplied procedure to run during cu_$cl */ 8 33 ) entry (bit (36) aligned, entry (bit (1) aligned), fixed binary (35)); 8 34 8 35 dcl ( 8 36 cpm_$generate_call, /* generate an immediate call */ 8 37 cpm_$generate_call_preferred, /* generate an immediate call and make it run preferred */ 8 38 cpm_$generate_call_when_ready /* generate a call when the control point is next ready */ 8 39 ) entry (bit (36) aligned, entry (pointer), pointer, fixed binary (35)); 8 40 8 41 dcl cpm_$get_preferred_control_point /* return the ID of the preferred control point */ 8 42 entry () returns (bit (36) aligned); 8 43 dcl cpm_$set_preferred_control_point /* make the specified control point preferred */ 8 44 entry (bit (36) aligned, fixed binary (35)); 8 45 dcl cpm_$push_preferred_control_point /* switch preferred control points */ 8 46 entry (bit (36) aligned, bit (1) aligned, fixed binary (35)); 8 47 dcl cpm_$pop_preferred_control_point /* restore the previous preferred control point */ 8 48 entry (bit (1) aligned); 8 49 8 50 dcl cpm_$get_control_point_meters /* get the usage meters for a specific control point */ 8 51 entry (bit (36) aligned, pointer, fixed binary (35)); 8 52 dcl cpm_$get_scheduler_meters /* get the usage meters for the control point scheduler */ 8 53 entry (pointer, fixed binary (35)); 8 54 8 55 dcl cpm_$nulle entry () options (variable); /* a "null" entry value which should never be called */ 8 56 8 57 /* END INCLUDE FILE ... cpm_entries.incl.pl1 */ 2088 2089 /* BEGIN INCLUDE FILE ... cpm_data_.incl.pl1 */ 9 2 9 3 /****^ HISTORY COMMENTS: 9 4* 1) change(86-08-12,Kissel), approve(86-08-12,MCR7473), 9 5* audit(86-10-08,Fawcett), install(86-11-03,MR12.0-1206): 9 6* Written to support control point management in March 1985 by G. Palter. 9 7* END HISTORY COMMENTS */ 9 8 9 9 /* format: style3,linecom */ 9 10 9 11 /* Static data defined by the Control Point Manager for external use */ 9 12 9 13 dcl cpm_data_$n_control_points /* # of control points actually extant in the process */ 9 14 fixed binary external; 9 15 9 16 /* END INCLUDE FILE ... cpm_data_.incl.pl1 */ 2089 2090 /* format: on */ 2091 2092 end ipc_real_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/11/89 0803.3 ipc_real_.pl1 >spec>install>1110>ipc_real_.pl1 2081 1 11/07/86 1550.3 ect_structures.incl.pl1 >ldd>include>ect_structures.incl.pl1 2082 2 06/29/79 1728.0 event_call_info.incl.pl1 >ldd>include>event_call_info.incl.pl1 2083 3 11/07/86 1550.3 event_channel_name.incl.pl1 >ldd>include>event_channel_name.incl.pl1 2084 4 06/29/79 1727.8 event_wait_info.incl.pl1 >ldd>include>event_wait_info.incl.pl1 2085 5 06/29/79 1728.0 event_wait_list.incl.pl1 >ldd>include>event_wait_list.incl.pl1 2086 6 11/07/86 1550.3 ipc_create_arg.incl.pl1 >ldd>include>ipc_create_arg.incl.pl1 2087 7 11/07/86 1550.3 stack_header.incl.pl1 >ldd>include>stack_header.incl.pl1 2088 8 11/07/86 1550.3 cpm_entries.incl.pl1 >ldd>include>cpm_entries.incl.pl1 2089 9 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. ANY_CALL_EVENT_CHANNEL_TYPE 000000 constant fixed bin(17,0) initial dcl 6-33 set ref 765* 778* 860 1069 1069 ASYNC_CALL_EVENT_CHANNEL_TYPE constant fixed bin(17,0) initial dcl 6-31 ref 318 860 1069 CALL 000014 constant fixed bin(8,0) initial dcl 1-65 set ref 321* 325 365* 513 532 533 998 1064 1184 1280 1333 1415 1623 1624* 1885 1887 2013 CALL_EVENT_CHANNEL_TYPE constant fixed bin(17,0) initial dcl 6-30 ref 318 341 860 1069 EV_CALL_MESSAGE constant fixed bin(8,0) initial dcl 1-66 ref 1060 1274 1278 1333 1394 1415 1478 EV_WAIT_MESSAGE constant fixed bin(8,0) initial dcl 1-68 ref 1303 1305 1333 1415 FAST_CHANNEL_TYPE 000007 constant bit(1) initial dcl 3-25 set ref 410* FAST_EVENT_CHANNEL_TYPE constant fixed bin(17,0) initial dcl 6-28 ref 283 ITT_MESSAGE constant fixed bin(8,0) initial dcl 1-67 ref 938 978 980 981 981 983 983 1022 NO constant bit(1) initial dcl 213 set ref 687* 693* 725 727 736 751* 754 754 766 781 781 793 872 879 900* 961 1050 1111 1128 1202 1237 1242 1244 1245 1775 1972 2019 2042 2047 NORMAL_CHANNEL_FLAGS constant bit(3) initial dcl 3-28 ref 299 344 408 OFF constant bit(1) initial dcl 213 set ref 334 484 513 638* 735 878 1108 1632 ON constant bit(1) initial dcl 212 set ref 628* 1098 1708 P_call_procedure parameter entry variable dcl 1601 ref 1593 1628 1629 P_channel_name parameter fixed bin(71,0) dcl 1221 ref 1218 1232 1250 P_code parameter fixed bin(35,0) dcl 92 set ref 215 251* 254 264* 268* 285* 370* 378 419* 422 435 447 458* 463 502 508* 510 543 549* 550 553* 555 558* 567* 572* 579 585* 588 589* 592 592 597* 602 612 621 631 641 651 661 669* 670 696* 704 718* 769 776 796 800 847 863* 1135* 1136 1144* 1164* 1603* 1604 1647* 1648 1656* 1666* 1676* 1682* 1788* 1789 1793* 1862* 1863 1867* P_create_arg_ptr parameter pointer dcl 87 ref 254 261 P_datap parameter pointer dcl 97 ref 422 435 1627 P_entry_type parameter fixed bin(8,0) dcl 1541 ref 1538 1543 1549 1560 1562 1562 P_event_channel_name parameter fixed bin(71,0) dcl 88 set ref 215 244* 254 263* 285* 309* 361* 422 435 447 458* 502 508* 543 549* 553* 558* 567* 579 589* 596* 602 612 661 669* 684* 688* 1603* 1647* P_event_channel_type parameter fixed bin(17,0) dcl 1038 in procedure "check_call_channels" ref 1035 1069 1069 1069 1069 P_event_channel_type parameter fixed bin(17,0) dcl 90 in procedure "ipc_real_" set ref 847 858 905* P_event_wait_info_ptr parameter pointer dcl 105 in procedure "ipc_real_" set ref 661 684* 688* 695* 704 710 P_event_wait_info_ptr parameter pointer dcl 1177 in procedure "read_channel" ref 1170 1205 P_event_wait_info_ptr parameter pointer dcl 1223 in procedure "read_fast_channel" ref 1218 1250 1251 1252 1252 1253 P_event_wait_list_ptr parameter pointer dcl 95 ref 704 709 1984 1989 P_fast_channel_id parameter fixed bin(18,0) dcl 93 ref 378 394 401 410 P_found_call_event parameter bit(1) dcl 1040 set ref 1035 1050* 1113* P_found_event parameter fixed bin(17,0) dcl 1222 in procedure "read_fast_channel" set ref 1218 1231* 1255* P_found_event parameter fixed bin(17,0) dcl 104 in procedure "ipc_real_" set ref 661 667* 684* 685 688* 695* P_found_event parameter fixed bin(17,0) dcl 1176 in procedure "read_channel" set ref 1170 1182* 1208* P_found_event_wait parameter bit(1) dcl 1122 set ref 1119 1128* 1157* P_inhibit_count parameter fixed bin(17,0) dcl 1175 set ref 1170 1189* 1189 P_inhibit_value parameter fixed bin(17,0) dcl 1645 ref 1642 1651 P_mask parameter bit(36) dcl 107 set ref 1719 1722* P_mask_value parameter fixed bin(17,0) dcl 1674 ref 1671 1677 P_new_control_point_id parameter bit(36) dcl 102 ref 522 535 P_old_control_point_id parameter bit(36) dcl 100 ref 522 535 P_priority parameter fixed bin(17,0) dcl 98 ref 422 435 1630 P_priority_switch parameter bit(1) dcl 1664 ref 1661 1667 P_procedure_entry parameter entry variable dcl 99 set ref 435 443* P_procedure_ptr parameter pointer dcl 94 set ref 422 430* REGULAR_CHANNEL_TYPE 000006 constant bit(1) initial dcl 3-26 set ref 238* 302* 354* 1233 SEND_IPS_WKP_CHANNEL_FLAGS constant bit(3) initial dcl 3-29 ref 349 TRUE constant bit(1) initial dcl 212 ref 749 WAIT 000021 constant fixed bin(8,0) initial dcl 1-64 set ref 228* 248* 292* 313* 393* 416* 466 489 492* 955 956 1142 1333 1415 1526 1619 1791 1865 1921 2013 2037 WAITING_CP 000005 constant fixed bin(8,0) initial dcl 1-69 set ref 1815* WAIT_EVENT_CHANNEL_TYPE constant fixed bin(17,0) initial dcl 6-29 ref 290 YES 000006 constant bit(1) initial dcl 212 set ref 400 463 567 682 731 733 761 763 769 776 781 791 802 814 839* 841 876 902 952 952 958 961 964 965 994 994 994 1096 1102 1113 1139 1157 1184 1841 1871 1871 2015 2064 2064 a_call_channel based structure level 1 dcl 2010 in procedure "wakeup_blocked_control_points" a_call_channel based structure level 1 dcl 930 in procedure "copy_itt_messages" a_wait_channel based structure level 1 dcl 931 in procedure "copy_itt_messages" a_wait_channel based structure level 1 dcl 2009 in procedure "wakeup_blocked_control_points" added_to_waiting_lists 000100 automatic bit(1) dcl 162 set ref 727* 731 793 814 1841* 1972* addr builtin function dcl 197 ref 589 589 1069 1069 1102 1102 1105 1105 1139 1139 1147 1147 an_ectep 000232 automatic pointer dcl 929 in procedure "copy_itt_messages" set ref 955* 955* 956 958 960 964* 968 985* 992 994 998 1000 1010 1010 an_ectep 000556 automatic pointer dcl 2011 in procedure "wakeup_blocked_control_points" set ref 2013* 2013 2015 2015* 2017 2017 2017* any_other 000156 stack reference condition dcl 207 ref 224 277 389 428 441 472 528 561 680 742 837 888 1995 async_call 0(18) based bit(1) level 4 packed packed unaligned dcl 1-112 set ref 343* 348* 1069 1069 block_count based fixed bin(17,0) level 3 packed packed unaligned dcl 1-182 set ref 1807* 1807 1817* 1929 1960* 1960 block_val 000101 automatic fixed bin(3,0) dcl 164 set ref 675* 677* 722* 738* 832* 834* 869* 882* 940 943 943* 1756 1761 1761* call_channel based structure level 1 dcl 1-112 call_channel_procedure 000102 automatic entry variable dcl 165 set ref 430* 431* 1092* 1102* 1105 call_data_ptr 10 based pointer level 2 dcl 6-19 ref 329 call_entry 4 based entry variable level 2 dcl 6-19 ref 330 331 call_info 000106 automatic structure level 1 dcl 167 set ref 589 589 1069 1069 1102 1102 1105 1105 call_inhibit 3 based bit(1) level 3 packed packed unaligned dcl 1-112 set ref 334* 484* 513* 735* 878* 1098* 1108* 1184 1632* call_msgp 000244 automatic pointer dcl 1042 set ref 1060* 1060* 1063 1079* 1079* 1080 call_priority 43 based bit(1) level 3 in structure "ect_header" packed packed unaligned dcl 1-24 in procedure "ipc_real_" set ref 763 1667* call_priority 12 based fixed bin(17,0) level 2 in structure "ipc_create_arg_structure" dcl 6-19 in procedure "ipc_real_" ref 332 chain 2 based structure level 2 dcl 1-182 channel_id 000234 automatic fixed bin(17,0) dcl 932 in procedure "copy_itt_messages" set ref 960* 961 961 channel_id 000262 automatic fixed bin(71,0) level 2 in structure "message_info" dcl 1125 in procedure "check_wait_channels" set ref 1151 channel_id 2 based fixed bin(71,0) array level 2 in structure "event_wait_list" dcl 5-12 in procedure "ipc_real_" set ref 1133 1788* 1802* 1862* 1918* channel_id 2 based fixed bin(71,0) level 3 in structure "itt_message" dcl 1-158 in procedure "ipc_real_" set ref 985* channel_id based fixed bin(71,0) level 2 in structure "event_wait_info" dcl 4-7 in procedure "ipc_real_" set ref 1151* 1250* channel_index 6 based fixed bin(17,0) level 2 in structure "event_wait_info" dcl 4-7 in procedure "ipc_real_" set ref 711* 1156* channel_index 000312 automatic fixed bin(17,0) dcl 1226 in procedure "read_fast_channel" set ref 1236* 1237 1242 1245 channel_type 2 based fixed bin(17,0) level 2 dcl 6-19 ref 283 290 318 318 341 chanp 1 based pointer level 2 in structure "p_event_message" packed packed unaligned dcl 1325 in procedure "thread_event_message" ref 1331 chanp 1 based pointer level 2 in structure "p_event_message" packed packed unaligned dcl 1410 in procedure "unthread_event_message" ref 1413 chanp 1 based pointer level 2 in structure "next_event_message" packed packed unaligned dcl 1268 in procedure "insert_event_call_message" ref 1280 chanp 1 based pointer level 2 in structure "event_message" packed packed unaligned dcl 1-143 in procedure "ipc_real_" set ref 992* 1063 1524 check_channels 000116 automatic bit(1) dcl 168 set ref 754* 761 781* cleanup 000164 stack reference condition dcl 208 ref 677 729 834 874 code 000544 automatic fixed bin(35,0) dcl 1911 in procedure "delete_from_waiting_lists" set ref 1918* 1919 code 000235 automatic fixed bin(35,0) dcl 933 in procedure "copy_itt_messages" set ref 985* 987 codeptr builtin function dcl 198 ref 330 1628 continue_to_signal_ 000010 constant entry external dcl 111 ref 1745 control_point_id 1 based bit(36) level 2 in structure "waiting_control_point" dcl 1-182 in procedure "ipc_real_" set ref 1805 1816* 1926 2040* control_point_id 13 based bit(36) level 2 in structure "call_channel" dcl 1-112 in procedure "ipc_real_" set ref 333* 535 535* 1067 1631* 1890 control_point_id 13 based bit(36) level 2 in structure "p_call_channel" dcl 2034 in procedure "wakeup_channel_control_points" set ref 2046* count 3 based fixed bin(17,0) array level 2 dcl 1-24 set ref 983* 983 1393* 1393 1477* 1477 1562* 1562 1589* 1589 cpm_$block 000102 constant entry external dcl 8-26 ref 1899 cpm_$generate_call_preferred 000106 constant entry external dcl 8-35 ref 1102 cpm_$scheduler 000104 constant entry external dcl 8-28 ref 804 cpm_$wakeup 000100 constant entry external dcl 8-19 ref 2040 2046 cpm_data_$n_control_points 000110 external static fixed bin(17,0) dcl 9-13 ref 1773 cpm_enabled 13(18) based bit(18) level 2 packed packed unaligned dcl 7-26 ref 1773 cu_$level_get 000012 constant entry external dcl 112 ref 675 722 832 869 cu_$level_set 000014 constant entry external dcl 113 ref 677 738 834 882 940 943 1756 1761 cu_$make_entry_value 000016 constant entry external dcl 114 ref 430 cur_ring 000117 automatic fixed bin(3,0) dcl 169 set ref 236* 238* 300* 302* 352* 354* 409* 410* 676* 723* 833* 870* 940 940* 943 1756 1756* 1761 current_control_point_id 000120 automatic bit(36) dcl 170 set ref 744* 890* 1067 1102* 1805 1816 1890 1926 1992* data_ptr 10 based pointer level 2 in structure "call_channel" packed packed unaligned dcl 1-112 in procedure "ipc_real_" set ref 329* 1094 1627* data_ptr 6 000106 automatic pointer level 2 in structure "call_info" dcl 167 in procedure "ipc_real_" set ref 1094* dev_signal 5 000262 automatic bit(18) level 3 in structure "message_info" packed packed unaligned dcl 1125 in procedure "check_wait_channels" set ref 1154 dev_signal 5 based bit(18) level 3 in structure "event_wait_info" packed packed unaligned dcl 4-7 in procedure "ipc_real_" set ref 1154* 1252* ecit_idx 000121 automatic fixed bin(15,0) dcl 172 set ref 228* 238* 292* 302* 321* 354* 393* 394 410* ect_header based structure level 1 dcl 1-24 ect_ptr 000172 automatic pointer dcl 1-61 in procedure "ipc_real_" set ref 228* 238 238 238 240 240 292* 302 302 302 304 304 321* 354 354 354 356 356 393* 396* 410 410 532 571* 754 763 781 802 841 916* 917 917* 938 955 961 965 970 978 980 981 981 983 983 994 1002 1002 1006 1006 1009 1009 1018* 1019 1019 1022 1052 1060 1210* 1245 1278 1305 1366 1367 1378 1380 1393 1393 1451 1453 1463 1465 1477 1477 1543 1549 1560 1562 1562 1573 1580 1589 1589 1667 1677 1677 1679 1681 1815* 1885 1957* 2013 2013 2019 2071* ect_ptr 64 based pointer level 2 in structure "stack_header" dcl 7-26 in procedure "ipc_real_" ref 916 ectep 000174 automatic pointer dcl 1-138 set ref 228* 232 232 233 233 244 292* 296 296 297 297 308 321* 325 327 327 329 330 331 332 333 334 343 348 360 393* 396* 400 401 403 403 404 404 412 458* 466 483 484 489 490 490 491 491 508* 513 513 532* 532* 533 535 535* 537 549* 571* 669* 693 735 878 1063* 1064 1067 1069 1069 1088 1090 1091 1094 1098 1108 1135* 1142 1184 1184 1187 1198 1202 1202 1244 1498 1524 1526 1529 1549 1550 1553 1554 1559 1560 1569 1573 1573 1577 1577 1580 1580 1584 1584 1587 1587 1603* 1619 1623 1627 1628 1629 1630 1631 1632 1647* 1651 1651 1653 1655 1788* 1791 1802* 1804 1819 1821 1823 1827 1829 1831 1832 1835 1862* 1865 1871 1871 1876 1885* 1885* 1887 1890 1890* 1893 1918* 1921 1924 1933 1935 1946 1948 2064 2064* 2067 2069 2073 2073 entry_list_ptrs 12 based structure array level 2 dcl 1-24 entry_type 000122 automatic fixed bin(8,0) dcl 173 set ref 1569* 1573 1580 1589 1589 entry_value 000124 automatic structure level 1 dcl 174 set ref 1092 env_ptr 2 000124 automatic pointer level 2 dcl 174 set ref 1091* environment_ptr 12 based pointer level 3 packed packed unaligned dcl 1-112 set ref 331* 1091 1629* environmentptr builtin function dcl 199 ref 331 1629 ep_ptr 000124 automatic pointer level 2 dcl 174 set ref 1090* error_table_$bad_arg 000054 external static fixed bin(35,0) dcl 141 ref 370 718 863 error_table_$event_calls_not_masked 000056 external static fixed bin(35,0) dcl 143 ref 1682 error_table_$event_channel_cutoff 000060 external static fixed bin(35,0) dcl 145 ref 592 696 1164 error_table_$event_channel_not_cutoff 000062 external static fixed bin(35,0) dcl 147 ref 1656 error_table_$inconsistent_ect 000064 external static fixed bin(35,0) dcl 149 set ref 1732* error_table_$not_a_wait_channel 000066 external static fixed bin(35,0) dcl 151 ref 1144 1793 1867 error_table_$unimplemented_version 000070 external static fixed bin(35,0) dcl 153 ref 268 ev_chn_flags 000131 automatic bit(3) dcl 179 set ref 235* 238* 299* 302* 344* 349* 354* 408* 410* ev_chn_name 000314 automatic structure level 1 dcl 1229 set ref 1232* event_call_in_progress 000130 automatic bit(1) dcl 177 set ref 725* 733 736* 872* 876 879* 1096* 1111* event_call_info based structure level 1 dcl 2-7 event_channel_name based structure level 1 dcl 3-17 event_channel_type 000132 automatic fixed bin(17,0) dcl 180 set ref 858* 860 860 860 event_message based structure level 1 dcl 1-143 event_message_data based structure level 1 dcl 1-169 event_wait_info based structure level 1 dcl 4-7 set ref 1205* event_wait_info_ptr 000200 automatic pointer dcl 4-5 set ref 710* 711 1151 1152 1153 1154 1155 1156 event_wait_list based structure level 1 dcl 5-12 event_wait_list_n_channels 000202 automatic fixed bin(17,0) dcl 5-8 set ref 713* 716 1131 1162 1787 1800 1860 1916 1990* event_wait_list_ptr 000204 automatic pointer dcl 5-10 set ref 709* 713 731* 1133 1788 1802 1862 1918 1989* 1990 fast_channel 3 based bit(1) level 3 in structure "wait_channel" packed packed unaligned dcl 1-86 in procedure "ipc_real_" set ref 400* 1871 fast_channel 3 based bit(1) level 3 in structure "a_wait_channel" packed packed unaligned dcl 931 in procedure "copy_itt_messages" ref 958 fast_channel_id 12 based fixed bin(17,0) level 2 in structure "a_wait_channel" dcl 931 in procedure "copy_itt_messages" ref 960 fast_channel_id 12 based fixed bin(17,0) level 2 in structure "wait_channel" dcl 1-86 in procedure "ipc_real_" set ref 401* 491* 1871 fb71 000134 automatic fixed bin(71,0) dcl 181 set ref 238* 244 302* 308 309 354* 360 361 410* 412 first_ev_msgp 6 based pointer level 2 in structure "call_channel" packed packed unaligned dcl 1-112 in procedure "ipc_real_" set ref 327* 1890 first_ev_msgp 6 based pointer level 2 in structure "wait_channel" packed packed unaligned dcl 1-86 in procedure "ipc_real_" set ref 232* 296* 403* 693 1198 1202 1339 1343* 1423 1425* 1498 1876 first_wcpp 10 based pointer level 2 in structure "p_wait_channel" packed packed unaligned dcl 2035 in procedure "wakeup_channel_control_points" ref 2039 first_wcpp 10 based pointer level 2 in structure "wait_channel" packed packed unaligned dcl 1-86 in procedure "ipc_real_" set ref 233* 297* 404* 490* 1804 1819 1823* 1924 1933 1935* 2067 2069 2073* firstp 12 based pointer array level 3 dcl 1-24 set ref 532 938 955 978 980* 1022 1060 1278 1366 1367* 1451 1453* 1549* 1573* 1885 2013 2013 flags 0(18) based structure level 3 in structure "call_channel" packed packed unaligned dcl 1-112 in procedure "ipc_real_" flags 43 based structure level 2 in structure "ect_header" dcl 1-24 in procedure "ipc_real_" found_call_event 000136 automatic bit(1) dcl 182 set ref 765* 766 778* 781 902* 904 905* found_event 000137 automatic fixed bin(17,0) dcl 183 set ref 584* 588 589* found_wait_event 000140 automatic bit(1) dcl 184 set ref 768* 769 775* 776 get_control_point_id_ 000076 constant entry external dcl 8-13 ref 333 744 890 1631 1992 get_ring_ 000020 constant entry external dcl 116 ref 236 300 352 409 676 723 833 870 got_message 000246 automatic fixed bin(17,0) dcl 1044 set ref 1058* 1060 1069* 1082 hcs_$assign_channel 000022 constant entry external dcl 117 ref 285 hcs_$delete_channel 000024 constant entry external dcl 118 ref 567 hcs_$fblock 000026 constant entry external dcl 119 ref 1759 hcs_$read_events 000030 constant entry external dcl 120 ref 942 hcs_$reset_ips_mask 000032 constant entry external dcl 121 ref 1708 hcs_$set_ips_mask 000034 constant entry external dcl 122 ref 1695 inhibit_count 3(01) based fixed bin(16,0) level 3 in structure "wait_channel" packed packed unaligned dcl 1-86 in procedure "ipc_real_" set ref 1187 1651* 1651 1653 1655* inhibit_count 000141 automatic fixed bin(17,0) dcl 185 in procedure "ipc_real_" set ref 667* 695* 696 1129* 1147* 1162 ipc_create_arg_structure based structure level 1 dcl 6-19 ipc_create_arg_structure_ptr 000206 automatic pointer dcl 6-16 set ref 261* 266 283 290 318 318 329 330 331 332 341 ipc_create_arg_structure_v1 000002 constant char(8) initial packed unaligned dcl 6-17 ref 266 ipc_data_$event_calls_pending 000074 external static fixed bin(17,0) dcl 157 set ref 1394* 1394 1478* 1478 ipc_data_$fast_channel_events 000072 external static bit(36) dcl 155 set ref 942* 961 970 1237 1242* 1759* 1871 ipc_util_$create_ect 000036 constant entry external dcl 123 ref 917 ipc_util_$delete_entry 000040 constant entry external dcl 125 ref 396 571 1018 1210 1957 2071 ipc_util_$ect_error_handler 000042 constant entry external dcl 127 ref 1732 ipc_util_$make_entry 000044 constant entry external dcl 129 ref 228 292 321 393 1815 ipc_util_$verify_channel 000046 constant entry external dcl 131 ref 458 549 669 1135 1788 1802 1862 1918 ipc_util_$verify_regular_channel 000050 constant entry external dcl 133 ref 508 985 1107 1603 1647 ipc_validate_$encode_event_channel_name 000052 constant entry external dcl 135 ref 238 302 354 410 is_fast 000142 automatic bit(1) dcl 186 set ref 458* 463 549* 567 669* 682 1135* 1139 itt_message based structure level 1 dcl 1-158 ittes_tossed 41 based fixed bin(33,0) level 3 dcl 1-24 set ref 1019* 1019 last_ectep 000144 automatic pointer dcl 187 set ref 1543* 1547 1553 1554 last_ev_msgp 7 based pointer level 2 in structure "call_channel" packed packed unaligned dcl 1-112 in procedure "ipc_real_" set ref 327* last_ev_msgp 7 based pointer level 2 in structure "wait_channel" packed packed unaligned dcl 1-86 in procedure "ipc_real_" set ref 232* 296* 403* 1341 1347 1349 1351 1352 1355* 1435 1437* last_fast_channel_events 51 based bit(36) level 2 dcl 1-24 set ref 961 970* 1245* last_wcpp 11 based pointer level 2 packed packed unaligned dcl 1-86 set ref 233* 297* 404* 490* 1821 1827 1829 1831 1832 1835* 1946 1948* 2073* lastp 14 based pointer array level 3 dcl 1-24 set ref 981 981* 1305* 1378 1380* 1463 1465* 1543 1560* 1580* loop 000522 automatic fixed bin(17,0) dcl 1785 in procedure "add_to_waiting_lists" set ref 1787* 1788* 1800* 1802* loop 000271 automatic fixed bin(17,0) dcl 1126 in procedure "check_wait_channels" set ref 1131* 1133 1156* loop 000534 automatic fixed bin(17,0) dcl 1855 in procedure "block_if_no_pending_events" set ref 1860* 1862* loop 000146 automatic fixed bin(17,0) dcl 188 in procedure "ipc_real_" set ref 587* 592* loop 000545 automatic fixed bin(17,0) dcl 1912 in procedure "delete_from_waiting_lists" set ref 1916* 1918* mask 000147 automatic bit(36) dcl 189 set ref 223* 226* 249* 276* 279* 374* 388* 391* 417* 427* 440* 471* 474* 498* 527* 530* 539* 560* 563* 575* 679* 741* 836* 887* 976* 1024* 1196* 1214* 1607* 1638* 1731* 1743* 1798* 1843* 1914* 1974* 1994* mask_call_count 43(18) based fixed bin(17,0) level 3 packed packed unaligned dcl 1-24 set ref 1052 1677* 1677 1679 1681* message 2 based fixed bin(71,0) level 2 in structure "event_wait_info" dcl 4-7 in procedure "ipc_real_" set ref 1152* 1251* message 2 000262 automatic fixed bin(71,0) level 2 in structure "message_info" dcl 1125 in procedure "check_wait_channels" set ref 1152 message_data 2 based structure level 2 in structure "event_message" dcl 1-143 in procedure "ipc_real_" ref 1205 message_data 2 based structure level 2 in structure "itt_message" dcl 1-158 in procedure "ipc_real_" message_info 000262 automatic structure level 1 dcl 1125 set ref 1139 1139 1147 1147 message_type 000362 automatic fixed bin(17,0) dcl 1408 in procedure "unthread_event_message" set ref 1412* 1415 1415 1451 1453 1463 1465 1477 1477 1478 message_type 000344 automatic fixed bin(17,0) dcl 1320 in procedure "thread_event_message" set ref 1330* 1333 1333 1366 1367 1370 1378 1380 1383 1393 1393 1394 meters 36 based structure level 2 dcl 1-24 msg_ptr 000374 automatic pointer dcl 1493 in procedure "save_channel_message_thread" set ref 1498* 1498* 1499 1500* 1501 1503 1504* msg_ptr 000302 automatic pointer dcl 1180 in procedure "read_channel" set ref 1198* 1199 1201* 1205 1210* msg_ptr 000150 automatic pointer dcl 190 in procedure "ipc_real_" set ref 978* 978* 980 981 985 992 1000 1001* 1005* 1018* 1522* 1522* 1523 1524 1526* 1529 1530* n_channels based fixed bin(17,0) level 2 dcl 5-12 ref 713 1990 name 4 based bit(72) level 2 in structure "wait_channel" dcl 1-86 in procedure "ipc_real_" set ref 244* 308* 412* name 4 based bit(72) level 2 in structure "call_channel" dcl 1-112 in procedure "ipc_real_" set ref 360* 1088 next_chan_msgp 12 based pointer level 2 in structure "p_event_message" packed packed unaligned dcl 1325 in procedure "thread_event_message" set ref 1356* next_chan_msgp 12 based pointer level 2 in structure "event_message" packed packed unaligned dcl 1-143 in procedure "ipc_real_" set ref 1349 1351* 1428 1430* 1499 1503* 1523 next_chan_msgp 12 based pointer level 2 in structure "p_event_message" packed packed unaligned dcl 1410 in procedure "unthread_event_message" set ref 1425 1430 1433 1440 1442 1445* next_chanp 1 based pointer level 2 in structure "a_call_channel" packed packed unaligned dcl 2010 in procedure "wakeup_blocked_control_points" ref 2017 next_chanp 1 based pointer level 2 in structure "call_channel" packed packed unaligned dcl 1-112 in procedure "ipc_real_" ref 537 1893 next_chanp 1 based pointer level 2 in structure "wait_channel" packed packed unaligned dcl 1-86 in procedure "ipc_real_" set ref 1554* 1559* 1573 1577* 1577 1580 1584 1587* next_chanp 1 based pointer level 2 in structure "a_wait_channel" packed packed unaligned dcl 931 in procedure "copy_itt_messages" ref 968 next_chanp 1 based pointer level 2 in structure "a_wait_channel" packed packed unaligned dcl 2009 in procedure "wakeup_blocked_control_points" ref 2017 next_ev_msgp 10 based pointer level 2 in structure "event_message" packed packed unaligned dcl 1-143 in procedure "ipc_real_" set ref 1079 1456 1458* next_ev_msgp 10 based pointer level 2 in structure "p_event_message" packed packed unaligned dcl 1410 in procedure "unthread_event_message" set ref 1453 1458 1461 1468 1470 1473* next_ev_msgp 10 based pointer level 2 in structure "p_event_message" packed packed unaligned dcl 1325 in procedure "thread_event_message" set ref 1389* next_ev_msgp 10 based pointer level 2 in structure "next_event_message" packed packed unaligned dcl 1268 in procedure "insert_event_call_message" ref 1285 next_ev_msgp 10 based pointer level 2 in structure "prev_event_message" packed packed unaligned dcl 1326 in procedure "thread_event_message" set ref 1372 1373* next_event_message based structure level 1 dcl 1321 in procedure "thread_event_message" next_event_message based structure level 1 dcl 1268 in procedure "insert_event_call_message" next_itt_msgp 1 based pointer level 2 packed packed unaligned dcl 1-158 ref 980 next_msg_ptr 000346 automatic pointer dcl 1323 in procedure "thread_event_message" set ref 1366* 1372* 1376 1383 1385 1389 next_msg_ptr 000324 automatic pointer dcl 1270 in procedure "insert_event_call_message" set ref 1278* 1278* 1280 1282 1284* 1285 next_msg_ptr 000400 automatic pointer dcl 1493 in procedure "save_channel_message_thread" set ref 1499* 1505 next_msg_ptr 000410 automatic pointer dcl 1520 in procedure "rethread_channel_message_thread" set ref 1523* 1532 next_wcpp 000576 automatic pointer dcl 2062 in procedure "reset_channel_wcps" set ref 2070* 2072 next_wcpp 2 based pointer level 3 in structure "waiting_control_point" dcl 1-182 in procedure "ipc_real_" set ref 1810 1829 1831* 1836* 1935 1938 1941* 1941 1944 1951 1954 1965 2041 2070 null builtin function dcl 200 ref 232 233 296 297 327 403 404 490 532 693 917 938 955 978 981 1060 1107 1199 1202 1276 1278 1339 1341 1344 1347 1349 1356 1364 1376 1421 1433 1445 1449 1461 1473 1496 1498 1501 1522 1547 1550 1559 1573 1580 1587 1804 1819 1821 1824 1827 1829 1836 1876 1885 1890 1924 1931 1944 2013 2017 2039 2067 2069 2073 origin 5 based structure level 2 in structure "event_wait_info" dcl 4-7 in procedure "ipc_real_" origin 5 000262 automatic structure level 2 in structure "message_info" dcl 1125 in procedure "check_wait_channels" owning_chanp 000350 automatic pointer dcl 1324 in procedure "thread_event_message" set ref 1331* 1333 1333 1339 1341 1343 1347 1349 1351 1352 1355 owning_chanp 000364 automatic pointer dcl 1409 in procedure "unthread_event_message" set ref 1413* 1415 1415 1423 1425 1435 1437 p_call_channel based structure level 1 dcl 2034 p_ectep parameter pointer dcl 2032 ref 2029 2037 2039 2042 2046 2047 p_event_message based structure level 1 dcl 1325 in procedure "thread_event_message" p_event_message based structure level 1 dcl 1410 in procedure "unthread_event_message" p_event_message based structure level 1 dcl 1271 in procedure "insert_event_call_message" p_mask parameter bit(36) dcl 1693 in procedure "mask_ips_interrupts" set ref 1690 1695* p_mask parameter bit(36) dcl 1706 in procedure "unmask_ips_interrupts" set ref 1703 1708 1708* 1708* p_msg_ptr parameter pointer dcl 1266 in procedure "insert_event_call_message" set ref 1263 1274 1282 1287* p_msg_ptr parameter pointer dcl 1301 in procedure "insert_event_wait_message" set ref 1298 1303 1305* p_msg_ptr parameter pointer dcl 1406 in procedure "unthread_event_message" ref 1403 1412 1413 1421 1423 1425 1428 1428 1430 1430 1433 1435 1437 1440 1440 1442 1442 1445 1445 1449 1451 1453 1456 1456 1458 1458 1461 1463 1465 1468 1468 1470 1470 1473 1473 p_msg_ptr parameter pointer dcl 1317 in procedure "thread_event_message" ref 1314 1330 1331 1343 1344 1351 1352 1355 1356 1367 1373 1380 1385 1388 1389 p_prev_msg_ptr parameter pointer dcl 1318 ref 1314 1360 p_saved_message_thread parameter pointer dcl 1491 in procedure "save_channel_message_thread" set ref 1488 1496* 1501* p_saved_message_thread parameter pointer dcl 1518 in procedure "rethread_channel_message_thread" ref 1515 1522 p_set_wcp parameter bit(1) dcl 927 ref 924 952 994 p_wait_channel based structure level 1 dcl 2035 prev_chan_msgp 13 based pointer level 2 in structure "p_event_message" packed packed unaligned dcl 1325 in procedure "thread_event_message" set ref 1344* 1352* prev_chan_msgp 13 based pointer level 2 in structure "event_message" packed packed unaligned dcl 1-143 in procedure "ipc_real_" set ref 1440 1442* prev_chan_msgp 13 based pointer level 2 in structure "p_event_message" packed packed unaligned dcl 1410 in procedure "unthread_event_message" set ref 1421 1428 1430 1437 1442 1445* prev_chanp 2 based pointer level 2 packed packed unaligned dcl 1-86 set ref 1550* 1553* 1573 1577 1580 1584* 1584 1587* prev_ev_msgp 11 based pointer level 2 in structure "next_event_message" packed packed unaligned dcl 1321 in procedure "thread_event_message" set ref 1385* prev_ev_msgp 11 based pointer level 2 in structure "event_message" packed packed unaligned dcl 1-143 in procedure "ipc_real_" set ref 1468 1470* prev_ev_msgp 11 based pointer level 2 in structure "p_event_message" packed packed unaligned dcl 1325 in procedure "thread_event_message" set ref 1388* prev_ev_msgp 11 based pointer level 2 in structure "p_event_message" packed packed unaligned dcl 1410 in procedure "unthread_event_message" set ref 1449 1456 1458 1465 1470 1473* prev_event_message based structure level 1 dcl 1326 prev_msg_ptr 000352 automatic pointer dcl 1328 in procedure "thread_event_message" set ref 1360* 1364 1370 1372 1373 1378 1388 prev_msg_ptr 000376 automatic pointer dcl 1493 in procedure "save_channel_message_thread" set ref 1496* 1501 1503 1504* prev_msg_ptr 000326 automatic pointer dcl 1272 in procedure "insert_event_call_message" set ref 1276* 1284* 1287* prev_wcpp 4 based pointer level 3 dcl 1-182 set ref 1824* 1832* 1931 1938 1941 1948 1951 1954* 1954 priority based fixed bin(17,0) level 3 in structure "p_event_message" packed packed unaligned dcl 1271 in procedure "insert_event_call_message" ref 1282 priority based fixed bin(17,0) level 3 in structure "next_event_message" packed packed unaligned dcl 1268 in procedure "insert_event_call_message" ref 1282 priority based fixed bin(17,0) level 3 in structure "a_call_channel" packed packed unaligned dcl 930 in procedure "copy_itt_messages" ref 1000 priority based fixed bin(17,0) level 3 in structure "event_message" packed packed unaligned dcl 1-143 in procedure "ipc_real_" set ref 1000* 1529* priority based fixed bin(17,0) level 3 in structure "call_channel" packed packed unaligned dcl 1-112 in procedure "ipc_real_" set ref 332* 483* 1529 1630* procedure_ptr 11 based pointer level 3 packed packed unaligned dcl 1-112 set ref 330* 1090 1628* procedure_value 11 based structure level 2 dcl 1-112 r_factor 50 based fixed bin(35,0) level 2 dcl 1-24 set ref 238* 302* 354* 410* r_offset 47 based fixed bin(18,0) level 2 dcl 1-24 set ref 238* 302* 354* 410* rcode 000247 automatic fixed bin(35,0) dcl 1046 set ref 1107* 1108 ring 1 000314 automatic fixed bin(3,0) level 2 in structure "ev_chn_name" packed packed unsigned unaligned dcl 1229 in procedure "read_fast_channel" set ref 1253 ring 5(18) based fixed bin(17,0) level 3 in structure "event_wait_info" packed packed unaligned dcl 4-7 in procedure "ipc_real_" set ref 1155* 1253* ring 5(18) 000262 automatic fixed bin(17,0) level 3 in structure "message_info" packed packed unaligned dcl 1125 in procedure "check_wait_channels" set ref 1155 saved_channel_name 000250 automatic fixed bin(71,0) dcl 1047 set ref 1088* 1107* saved_message_thread 000152 automatic pointer dcl 191 set ref 478* 496* 1615* 1636* seed 42 based fixed bin(33,0) level 2 dcl 1-24 set ref 238 240* 240 302 304* 304 354 356* 356 sender 4 based bit(36) level 2 in structure "event_wait_info" dcl 4-7 in procedure "ipc_real_" set ref 1153* 1252* sender 4 000262 automatic bit(36) level 2 in structure "message_info" dcl 1125 in procedure "check_wait_channels" set ref 1153 stack_header based structure level 1 dcl 7-26 stackbaseptr builtin function dcl 201 ref 916 1773 substr builtin function dcl 202 set ref 961 961 1237 1242* 1245* 1708 1871 temp_channel_name 000260 automatic fixed bin(71,0) dcl 1124 set ref 1133* 1135* 1139* temp_found_event 000154 automatic fixed bin(17,0) dcl 193 set ref 1139* 1147* 1149 total_call_wakeups 40 based fixed bin(33,0) level 3 dcl 1-24 set ref 1002* 1002 total_wait_wakeups 37 based fixed bin(33,0) level 3 dcl 1-24 set ref 1006* 1006 total_wakeups 36 based fixed bin(33,0) level 3 dcl 1-24 set ref 1009* 1009 type 0(18) based fixed bin(17,0) level 3 in structure "p_event_message" packed packed unaligned dcl 1325 in procedure "thread_event_message" ref 1330 type 1(03) 000314 automatic bit(1) level 2 in structure "ev_chn_name" packed packed unaligned dcl 1229 in procedure "read_fast_channel" set ref 1233 type 0(18) based fixed bin(17,0) level 3 in structure "p_event_message" packed packed unaligned dcl 1271 in procedure "insert_event_call_message" set ref 1274* type 0(27) based fixed bin(8,0) level 3 in structure "p_wait_channel" packed packed unaligned dcl 2035 in procedure "wakeup_channel_control_points" ref 2037 type 0(18) based fixed bin(17,0) level 3 in structure "p_event_message" packed packed unaligned dcl 1410 in procedure "unthread_event_message" ref 1412 type 0(18) based fixed bin(17,0) level 3 in structure "next_event_message" packed packed unaligned dcl 1321 in procedure "thread_event_message" ref 1383 type 0(27) based fixed bin(8,0) level 3 in structure "a_call_channel" packed packed unaligned dcl 930 in procedure "copy_itt_messages" ref 998 type 0(27) based fixed bin(8,0) level 3 in structure "wait_channel" packed packed unaligned dcl 1-86 in procedure "ipc_real_" set ref 466 489* 1142 1333 1415 1526 1569 1619 1791 1865 1921 type 0(27) based fixed bin(8,0) level 3 in structure "a_wait_channel" packed packed unaligned dcl 931 in procedure "copy_itt_messages" ref 956 type 0(27) based fixed bin(8,0) level 3 in structure "call_channel" packed packed unaligned dcl 1-112 in procedure "ipc_real_" set ref 325* 513 533 1064 1184 1280 1333 1415 1623* 1887 type 0(18) based fixed bin(17,0) level 3 in structure "event_message" packed packed unaligned dcl 1-143 in procedure "ipc_real_" set ref 1303* type 0(18) based fixed bin(17,0) level 3 in structure "prev_event_message" packed packed unaligned dcl 1326 in procedure "thread_event_message" ref 1370 unique_id 1(18) 000314 automatic fixed bin(18,0) level 2 packed packed unsigned unaligned dcl 1229 set ref 1236 unspec builtin function dcl 1227 in procedure "read_fast_channel" set ref 1232* 1232 unspec builtin function dcl 203 in procedure "ipc_real_" set ref 244 244* 308 309* 309 360 361* 361 412 1088* 1088 1092* 1092 unused2 13 based fixed bin(17,0) level 2 dcl 1-86 set ref 491* version based char(8) level 2 packed packed unaligned dcl 6-19 ref 266 wait_channel based structure level 1 dcl 1-86 waiting_control_point based structure level 1 dcl 1-182 wakeup_control_points 3(18) based bit(1) level 3 in structure "wait_channel" packed packed unaligned dcl 1-86 in procedure "ipc_real_" set ref 1202* 1244* 2064 wakeup_control_points 43(01) based bit(1) level 3 in structure "ect_header" packed packed unaligned dcl 1-24 in procedure "ipc_real_" set ref 754 781 802 841 965* 994* 2019* wakeup_control_points 3(18) based bit(1) level 3 in structure "p_wait_channel" packed packed unaligned dcl 2035 in procedure "wakeup_channel_control_points" set ref 2042* wakeup_control_points 3(18) based bit(1) level 3 in structure "a_wait_channel" packed packed unaligned dcl 2009 in procedure "wakeup_blocked_control_points" ref 2015 wakeup_control_points 3(18) based bit(1) level 3 in structure "a_wait_channel" packed packed unaligned dcl 931 in procedure "copy_itt_messages" set ref 964* 994* wakeup_control_points 3(18) based bit(1) level 3 in structure "p_call_channel" packed packed unaligned dcl 2034 in procedure "wakeup_channel_control_points" set ref 2047* wakeup_count 3(19) based fixed bin(17,0) level 3 packed packed unsigned unaligned dcl 931 set ref 1010* 1010 wcpp 000176 automatic pointer dcl 1-194 set ref 1804* 1804* 1805 1807 1807* 1810 1815* 1816 1817 1823 1824 1831 1832 1835 1836 1924* 1924* 1926 1929 1931 1933 1935 1938 1938 1941 1941 1944 1946 1948 1951 1951 1954 1954 1957* 1960 1960* 1965 2039* 2039* 2040* 2041 2069* 2069* 2070 2071* word_0 based structure level 2 in structure "a_wait_channel" dcl 931 in procedure "copy_itt_messages" word_0 based structure level 2 in structure "wait_channel" dcl 1-86 in procedure "ipc_real_" word_0 based structure level 2 in structure "prev_event_message" dcl 1326 in procedure "thread_event_message" word_0 based structure level 2 in structure "waiting_control_point" dcl 1-182 in procedure "ipc_real_" word_0 based structure level 2 in structure "p_event_message" dcl 1325 in procedure "thread_event_message" word_0 based structure level 2 in structure "event_message" dcl 1-143 in procedure "ipc_real_" word_0 based structure level 2 in structure "p_event_message" dcl 1271 in procedure "insert_event_call_message" word_0 based structure level 2 in structure "next_event_message" dcl 1321 in procedure "thread_event_message" word_0 based structure level 2 in structure "p_wait_channel" dcl 2035 in procedure "wakeup_channel_control_points" word_0 based structure level 2 in structure "next_event_message" dcl 1268 in procedure "insert_event_call_message" word_0 based structure level 2 in structure "a_call_channel" dcl 930 in procedure "copy_itt_messages" word_0 based structure level 2 in structure "call_channel" dcl 1-112 in procedure "ipc_real_" word_0 based structure level 2 in structure "p_event_message" dcl 1410 in procedure "unthread_event_message" word_3 3 based structure level 2 in structure "a_wait_channel" dcl 931 in procedure "copy_itt_messages" word_3 3 based structure level 2 in structure "wait_channel" dcl 1-86 in procedure "ipc_real_" word_3 3 based structure level 2 in structure "p_call_channel" dcl 2034 in procedure "wakeup_channel_control_points" word_3 3 based structure level 2 in structure "call_channel" dcl 1-112 in procedure "ipc_real_" word_3 3 based structure level 2 in structure "p_wait_channel" dcl 2035 in procedure "wakeup_channel_control_points" word_3 3 based structure level 2 in structure "a_wait_channel" dcl 2009 in procedure "wakeup_blocked_control_points" NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ENCODED_INDEX_CONSTANT internal static fixed bin(35,0) initial dcl 3-37 TOTAL internal static fixed bin(8,0) initial dcl 1-63 call_offset internal static fixed bin(17,0) initial dcl 7-78 cpm_$create 000000 constant entry external dcl 8-16 cpm_$destroy 000000 constant entry external dcl 8-19 cpm_$generate_call 000000 constant entry external dcl 8-35 cpm_$generate_call_when_ready 000000 constant entry external dcl 8-35 cpm_$get_control_point_meters 000000 constant entry external dcl 8-50 cpm_$get_preferred_control_point 000000 constant entry external dcl 8-41 cpm_$get_scheduler_meters 000000 constant entry external dcl 8-52 cpm_$get_user_cl_intermediary 000000 constant entry external dcl 8-30 cpm_$nulle 000000 constant entry external dcl 8-55 cpm_$pop_preferred_control_point 000000 constant entry external dcl 8-47 cpm_$push_preferred_control_point 000000 constant entry external dcl 8-45 cpm_$set_preferred_control_point 000000 constant entry external dcl 8-43 cpm_$set_user_cl_intermediary 000000 constant entry external dcl 8-30 cpm_$start 000000 constant entry external dcl 8-19 cpm_$stop 000000 constant entry external dcl 8-19 decoded_index based structure level 1 dcl 3-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 entry_offset internal static fixed bin(17,0) initial dcl 7-78 ev_chn_flags automatic bit(3) dcl 1043 event_call_info_ptr automatic pointer dcl 2-5 is_fast automatic bit(1) dcl 1045 push_offset internal static fixed bin(17,0) initial dcl 7-78 return_no_pop_offset internal static fixed bin(17,0) initial dcl 7-78 return_offset internal static fixed bin(17,0) initial dcl 7-78 sb automatic pointer dcl 7-24 stack_header_overlay based fixed bin(17,0) array dcl 7-94 tv_offset internal static fixed bin(17,0) initial dcl 7-72 NAMES DECLARED BY EXPLICIT CONTEXT. INSERT_THE_MESSAGE 004250 constant label dcl 1287 ref 1282 MAKE_EVENT_CALL 005214 constant entry internal dcl 1593 ref 431 443 PROCESS_NEXT_CHANNEL 006014 constant label dcl 1838 in procedure "add_to_waiting_lists" ref 1808 PROCESS_NEXT_CHANNEL 006344 constant label dcl 1969 in procedure "delete_from_waiting_lists" ref 1919 1921 1963 RETURN_FROM_FULL_BLOCK 002524 constant label dcl 814 ref 769 776 796 800 add_to_waiting_lists 005574 constant entry internal dcl 1782 ref 795 any_other_handler 005467 constant entry internal dcl 1740 ref 224 277 389 428 441 472 528 561 680 742 837 888 1995 block_if_no_pending_events 006023 constant entry internal dcl 1852 ref 799 check_call_channels 003461 constant entry internal dcl 1035 ref 765 778 905 check_wait_channels 003675 constant entry internal dcl 1119 ref 768 775 copy_itt_messages 003135 constant entry internal dcl 924 ref 687 693 751 839 900 create_ev_chn 000050 constant entry external dcl 215 create_event_channel 000217 constant entry external dcl 254 create_fast_ev_chn 000576 constant entry external dcl 378 cutoff 001631 constant entry external dcl 602 decl_ev_call_chn 000763 constant entry external dcl 422 decl_ev_wait_chn 001113 constant entry external dcl 447 ref 553 decl_event_call_chn 001043 constant entry external dcl 435 delete_ev_chn 001373 constant entry external dcl 543 delete_from_waiting_lists 006153 constant entry internal dcl 1908 ref 814 1997 delete_from_waiting_lists_caller 003045 constant entry external dcl 1984 ref 731 drain_chn 001533 constant entry external dcl 579 ref 558 find_ectp 003115 constant entry internal dcl 910 ref 221 274 386 425 438 457 507 525 548 608 617 627 637 647 657 666 707 830 867 1987 full_block 002214 constant entry external dcl 704 hardcore_block 005514 constant entry internal dcl 1749 ref 807 843 have_multiple_control_points 005555 constant entry internal dcl 1770 ref 754 781 791 952 994 1102 2064 inconsistent_ect 005453 constant entry internal dcl 1728 ref 397 533 956 1064 1280 1333 1341 1347 1349 1370 1378 1383 1415 1423 1428 1435 1440 1451 1456 1463 1468 1524 1821 1827 1829 1887 1933 1938 1946 1951 1967 insert_event_call_message 004202 constant entry internal dcl 1263 ref 1001 1530 insert_event_wait_message 004262 constant entry internal dcl 1298 ref 1005 1526 ipc_real_ 000036 constant entry external dcl 81 mask_ev_calls 001732 constant entry external dcl 641 mask_ips_interrupts 005413 constant entry internal dcl 1690 ref 226 279 391 474 530 563 976 1196 1607 1798 1914 read_channel 004017 constant entry internal dcl 1170 ref 695 1069 1147 read_ev_chn 001775 constant entry external dcl 661 ref 589 read_fast_channel 004121 constant entry internal dcl 1218 ref 684 688 1139 reassign_call_channels 001303 constant entry external dcl 522 reconnect 001653 constant entry external dcl 612 ref 596 reset_channel_wcps 006514 constant entry internal dcl 2059 ref 565 1621 reset_ev_call_chn 001236 constant entry external dcl 502 rethread_channel_message_thread 005041 constant entry internal dcl 1515 ref 496 1636 run_event_calls 002645 constant entry external dcl 847 save_channel_message_thread 005000 constant entry internal dcl 1488 ref 478 1615 set_call_prior 001676 constant entry external dcl 621 set_inhibit_switch 005314 constant entry internal dcl 1642 ref 609 618 set_mask 005373 constant entry internal dcl 1671 ref 648 658 set_priority_switch 005362 constant entry internal dcl 1661 ref 628 638 set_wait_prior 001714 constant entry external dcl 631 thread_channel 005104 constant entry internal dcl 1538 ref 248 313 365 416 492 1624 thread_event_message 004303 constant entry internal dcl 1314 ref 1287 1305 unmask_ev_calls 001752 constant entry external dcl 651 unmask_ips_interrupts 005432 constant entry internal dcl 1703 ref 249 374 417 498 539 575 1024 1214 1638 1722 1731 1843 1974 unmask_ips_interrupts_caller 003025 constant entry external dcl 1719 ref 1743 unthread_channel 005144 constant entry internal dcl 1566 ref 485 570 1622 unthread_event_message 004522 constant entry internal dcl 1403 ref 1201 1500 wait_for_an_event 002532 constant entry external dcl 827 wakeup_blocked_control_points 006352 constant entry internal dcl 2006 ref 802 841 wakeup_channel_control_points 006427 constant entry internal dcl 2029 ref 2015 2064 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 10036 10150 6750 10046 Length 10730 6750 112 544 1066 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME ipc_real_ 608 external procedure is an external procedure. on unit on line 224 64 on unit on unit on line 277 64 on unit on unit on line 389 64 on unit on unit on line 428 64 on unit on unit on line 441 64 on unit on unit on line 472 64 on unit on unit on line 528 64 on unit on unit on line 561 64 on unit on unit on line 677 68 on unit on unit on line 680 64 on unit on unit on line 729 68 on unit on unit on line 742 64 on unit on unit on line 834 68 on unit on unit on line 837 64 on unit on unit on line 874 68 on unit on unit on line 888 64 on unit find_ectp internal procedure shares stack frame of external procedure ipc_real_. copy_itt_messages internal procedure shares stack frame of external procedure ipc_real_. check_call_channels internal procedure shares stack frame of external procedure ipc_real_. check_wait_channels internal procedure shares stack frame of external procedure ipc_real_. read_channel internal procedure shares stack frame of external procedure ipc_real_. read_fast_channel internal procedure shares stack frame of external procedure ipc_real_. insert_event_call_message internal procedure shares stack frame of external procedure ipc_real_. insert_event_wait_message internal procedure shares stack frame of external procedure ipc_real_. thread_event_message internal procedure shares stack frame of external procedure ipc_real_. unthread_event_message internal procedure shares stack frame of external procedure ipc_real_. save_channel_message_thread internal procedure shares stack frame of external procedure ipc_real_. rethread_channel_message_thread internal procedure shares stack frame of external procedure ipc_real_. thread_channel internal procedure shares stack frame of external procedure ipc_real_. unthread_channel internal procedure shares stack frame of external procedure ipc_real_. MAKE_EVENT_CALL internal procedure shares stack frame of external procedure ipc_real_. set_inhibit_switch internal procedure shares stack frame of external procedure ipc_real_. set_priority_switch internal procedure shares stack frame of external procedure ipc_real_. set_mask internal procedure shares stack frame of external procedure ipc_real_. mask_ips_interrupts internal procedure shares stack frame of external procedure ipc_real_. unmask_ips_interrupts internal procedure shares stack frame of external procedure ipc_real_. inconsistent_ect internal procedure shares stack frame of external procedure ipc_real_. any_other_handler 69 internal procedure is called by several nonquick procedures. hardcore_block internal procedure shares stack frame of external procedure ipc_real_. have_multiple_control_points internal procedure shares stack frame of external procedure ipc_real_. add_to_waiting_lists internal procedure shares stack frame of external procedure ipc_real_. block_if_no_pending_events internal procedure shares stack frame of external procedure ipc_real_. delete_from_waiting_lists internal procedure shares stack frame of external procedure ipc_real_. on unit on line 1995 64 on unit wakeup_blocked_control_points internal procedure shares stack frame of external procedure ipc_real_. wakeup_channel_control_points internal procedure shares stack frame of external procedure ipc_real_. reset_channel_wcps internal procedure shares stack frame of external procedure ipc_real_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME ipc_real_ 000100 added_to_waiting_lists ipc_real_ 000101 block_val ipc_real_ 000102 call_channel_procedure ipc_real_ 000106 call_info ipc_real_ 000116 check_channels ipc_real_ 000117 cur_ring ipc_real_ 000120 current_control_point_id ipc_real_ 000121 ecit_idx ipc_real_ 000122 entry_type ipc_real_ 000124 entry_value ipc_real_ 000130 event_call_in_progress ipc_real_ 000131 ev_chn_flags ipc_real_ 000132 event_channel_type ipc_real_ 000134 fb71 ipc_real_ 000136 found_call_event ipc_real_ 000137 found_event ipc_real_ 000140 found_wait_event ipc_real_ 000141 inhibit_count ipc_real_ 000142 is_fast ipc_real_ 000144 last_ectep ipc_real_ 000146 loop ipc_real_ 000147 mask ipc_real_ 000150 msg_ptr ipc_real_ 000152 saved_message_thread ipc_real_ 000154 temp_found_event ipc_real_ 000172 ect_ptr ipc_real_ 000174 ectep ipc_real_ 000176 wcpp ipc_real_ 000200 event_wait_info_ptr ipc_real_ 000202 event_wait_list_n_channels ipc_real_ 000204 event_wait_list_ptr ipc_real_ 000206 ipc_create_arg_structure_ptr ipc_real_ 000232 an_ectep copy_itt_messages 000234 channel_id copy_itt_messages 000235 code copy_itt_messages 000244 call_msgp check_call_channels 000246 got_message check_call_channels 000247 rcode check_call_channels 000250 saved_channel_name check_call_channels 000260 temp_channel_name check_wait_channels 000262 message_info check_wait_channels 000271 loop check_wait_channels 000302 msg_ptr read_channel 000312 channel_index read_fast_channel 000314 ev_chn_name read_fast_channel 000324 next_msg_ptr insert_event_call_message 000326 prev_msg_ptr insert_event_call_message 000344 message_type thread_event_message 000346 next_msg_ptr thread_event_message 000350 owning_chanp thread_event_message 000352 prev_msg_ptr thread_event_message 000362 message_type unthread_event_message 000364 owning_chanp unthread_event_message 000374 msg_ptr save_channel_message_thread 000376 prev_msg_ptr save_channel_message_thread 000400 next_msg_ptr save_channel_message_thread 000410 next_msg_ptr rethread_channel_message_thread 000522 loop add_to_waiting_lists 000534 loop block_if_no_pending_events 000544 code delete_from_waiting_lists 000545 loop delete_from_waiting_lists 000556 an_ectep wakeup_blocked_control_points 000576 next_wcpp reset_channel_wcps THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_g_a r_e_as unpk_to_pk call_ent_var call_ext_in call_ext_out call_int_other return_mac enable_op ext_entry int_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. continue_to_signal_ cpm_$block cpm_$generate_call_preferred cpm_$scheduler cpm_$wakeup cu_$level_get cu_$level_set cu_$make_entry_value get_control_point_id_ get_ring_ hcs_$assign_channel hcs_$delete_channel hcs_$fblock hcs_$read_events hcs_$reset_ips_mask hcs_$set_ips_mask ipc_util_$create_ect ipc_util_$delete_entry ipc_util_$ect_error_handler ipc_util_$make_entry ipc_util_$verify_channel ipc_util_$verify_regular_channel ipc_validate_$encode_event_channel_name THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. cpm_data_$n_control_points error_table_$bad_arg error_table_$event_calls_not_masked error_table_$event_channel_cutoff error_table_$event_channel_not_cutoff error_table_$inconsistent_ect error_table_$not_a_wait_channel error_table_$unimplemented_version ipc_data_$event_calls_pending ipc_data_$fast_channel_events LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 81 000035 83 000043 215 000044 221 000062 223 000063 224 000064 226 000106 228 000110 232 000125 233 000131 235 000134 236 000135 238 000144 240 000174 244 000176 248 000205 249 000207 251 000211 252 000212 254 000213 261 000231 263 000235 264 000237 266 000240 268 000244 269 000247 274 000250 276 000251 277 000252 279 000274 283 000276 285 000302 286 000313 290 000314 292 000316 296 000333 297 000337 299 000342 300 000343 302 000352 304 000402 308 000404 309 000410 313 000413 314 000415 318 000416 321 000422 325 000437 327 000442 329 000446 330 000451 331 000454 332 000456 333 000461 334 000472 341 000475 343 000501 344 000503 345 000504 348 000505 349 000507 352 000511 354 000520 356 000550 360 000552 361 000556 365 000561 366 000563 370 000564 374 000567 376 000571 378 000572 386 000606 388 000607 389 000610 391 000632 393 000634 394 000651 396 000655 397 000666 400 000667 401 000672 403 000675 404 000700 408 000703 409 000704 410 000713 412 000744 416 000750 417 000752 419 000754 420 000755 422 000756 425 000775 427 000776 428 000777 430 001021 431 001033 433 001035 435 001036 438 001055 440 001056 441 001057 443 001101 445 001110 447 001111 457 001125 458 001126 463 001143 466 001151 471 001156 472 001157 474 001201 478 001203 483 001205 484 001210 485 001213 489 001214 490 001217 491 001223 492 001225 496 001227 498 001231 500 001233 502 001234 507 001250 508 001251 510 001264 513 001266 516 001276 522 001277 525 001310 527 001311 528 001312 530 001334 532 001336 533 001346 535 001354 537 001363 539 001366 541 001370 543 001371 548 001405 549 001406 550 001423 553 001425 555 001435 558 001437 560 001447 561 001450 563 001472 565 001474 567 001475 570 001513 571 001514 572 001525 575 001526 577 001530 579 001531 584 001545 585 001547 587 001550 588 001555 589 001563 590 001601 592 001602 596 001612 597 001623 599 001624 600 001626 602 001627 608 001643 609 001644 610 001650 612 001651 617 001665 618 001666 619 001672 621 001673 627 001706 628 001707 629 001711 631 001712 637 001724 638 001725 639 001727 641 001730 647 001742 648 001743 649 001747 651 001750 657 001762 658 001763 659 001767 661 001770 666 002011 667 002012 669 002015 670 002032 675 002034 676 002043 677 002052 679 002076 680 002077 682 002121 684 002125 685 002140 687 002143 688 002145 690 002160 693 002161 695 002167 696 002202 700 002207 704 002210 707 002226 709 002227 710 002233 711 002236 713 002237 716 002241 718 002242 719 002245 722 002246 723 002255 725 002264 727 002265 729 002266 731 002302 733 002314 735 002320 736 002323 738 002324 739 002333 741 002334 742 002335 744 002357 751 002366 754 002370 761 002404 763 002407 765 002414 766 002416 768 002421 769 002423 772 002431 775 002432 776 002434 778 002442 781 002444 784 002466 791 002467 793 002475 795 002477 796 002500 799 002502 800 002503 802 002505 804 002514 805 002521 807 002522 808 002523 814 002524 818 002530 827 002531 830 002537 832 002540 833 002547 834 002556 836 002602 837 002603 839 002625 841 002627 843 002637 845 002640 847 002641 858 002655 860 002660 863 002666 864 002671 867 002672 869 002673 870 002702 872 002711 874 002712 876 002726 878 002732 879 002735 882 002736 883 002744 887 002745 888 002746 890 002770 900 002777 902 003001 904 003003 905 003007 906 003020 908 003021 1719 003022 1722 003032 1723 003041 1984 003042 1987 003052 1989 003053 1990 003057 1992 003061 1994 003070 1995 003071 1997 003113 1999 003114 910 003115 916 003116 917 003121 920 003134 924 003135 938 003137 940 003145 942 003157 943 003172 952 003204 955 003222 956 003232 958 003240 960 003245 961 003247 964 003262 965 003264 968 003266 970 003271 976 003275 978 003277 980 003310 981 003315 983 003326 985 003332 987 003346 992 003350 994 003353 998 003405 1000 003412 1001 003415 1002 003417 1003 003421 1005 003422 1006 003424 1009 003426 1010 003427 1011 003436 1018 003437 1019 003450 1022 003452 1024 003456 1026 003460 1035 003461 1050 003463 1052 003464 1058 003472 1060 003473 1063 003504 1064 003507 1067 003515 1069 003521 1079 003554 1080 003557 1082 003561 1088 003564 1090 003570 1091 003572 1092 003574 1094 003600 1096 003602 1098 003604 1102 003607 1105 003636 1107 003646 1108 003663 1111 003670 1113 003671 1115 003674 1119 003675 1128 003677 1129 003700 1131 003701 1133 003711 1135 003714 1136 003731 1139 003734 1142 003745 1144 003752 1145 003755 1147 003756 1149 003762 1151 003764 1152 003766 1153 003771 1154 003773 1155 003775 1156 003777 1157 004001 1158 004004 1160 004005 1162 004007 1164 004012 1165 004015 1168 004016 1170 004017 1182 004021 1184 004022 1187 004035 1189 004042 1190 004043 1196 004044 1198 004046 1199 004051 1201 004055 1202 004057 1205 004065 1208 004103 1210 004105 1214 004116 1216 004120 1218 004121 1231 004123 1232 004124 1233 004130 1236 004136 1237 004141 1242 004150 1244 004153 1245 004156 1250 004162 1251 004165 1252 004170 1253 004173 1255 004177 1257 004201 1263 004202 1274 004204 1276 004210 1278 004212 1280 004222 1282 004232 1284 004243 1285 004245 1287 004250 1290 004261 1298 004262 1303 004264 1305 004270 1307 004302 1314 004303 1330 004305 1331 004312 1333 004315 1339 004335 1341 004341 1343 004345 1344 004352 1345 004354 1347 004355 1349 004361 1351 004367 1352 004375 1355 004400 1356 004405 1360 004407 1364 004412 1366 004416 1367 004423 1368 004425 1370 004426 1372 004434 1373 004437 1376 004444 1378 004450 1380 004460 1381 004467 1383 004470 1385 004476 1388 004503 1389 004507 1393 004511 1394 004514 1397 004521 1403 004522 1412 004524 1413 004531 1415 004534 1421 004554 1423 004562 1425 004570 1426 004576 1428 004577 1430 004605 1433 004613 1435 004620 1437 004626 1438 004634 1440 004635 1442 004643 1445 004651 1449 004656 1451 004661 1453 004671 1454 004701 1456 004702 1458 004710 1461 004716 1463 004723 1465 004733 1466 004743 1468 004744 1470 004752 1473 004760 1477 004765 1478 004771 1481 004777 1488 005000 1496 005002 1498 005005 1499 005014 1500 005017 1501 005021 1503 005031 1504 005034 1505 005035 1507 005040 1515 005041 1522 005043 1523 005052 1524 005055 1526 005063 1529 005073 1530 005076 1532 005100 1534 005103 1538 005104 1543 005106 1547 005113 1549 005120 1550 005124 1551 005127 1553 005130 1554 005132 1559 005133 1560 005135 1562 005140 1564 005143 1566 005144 1569 005145 1573 005151 1577 005163 1580 005166 1584 005200 1587 005203 1589 005207 1591 005213 1593 005214 1603 005216 1604 005231 1607 005234 1615 005236 1619 005240 1621 005245 1622 005246 1623 005247 1624 005252 1627 005254 1628 005261 1629 005265 1630 005270 1631 005273 1632 005304 1636 005307 1638 005311 1640 005313 1642 005314 1647 005316 1648 005331 1651 005334 1653 005346 1655 005352 1656 005356 1659 005361 1661 005362 1666 005364 1667 005365 1669 005372 1671 005373 1676 005375 1677 005376 1679 005404 1681 005405 1682 005407 1686 005412 1690 005413 1695 005415 1697 005431 1703 005432 1708 005434 1711 005452 1728 005453 1731 005454 1732 005456 1734 005465 1740 005466 1743 005474 1745 005503 1747 005513 1749 005514 1756 005515 1759 005527 1761 005542 1764 005554 1770 005555 1773 005557 1775 005572 1782 005574 1787 005575 1788 005605 1789 005625 1791 005630 1793 005635 1794 005640 1796 005641 1798 005643 1800 005645 1802 005655 1804 005676 1805 005706 1807 005712 1808 005717 1810 005720 1815 005723 1816 005741 1817 005744 1819 005746 1821 005752 1823 005756 1824 005761 1825 005763 1827 005764 1829 005770 1831 005777 1832 006003 1835 006007 1836 006012 1838 006014 1841 006016 1843 006020 1845 006022 1852 006023 1860 006024 1862 006033 1863 006053 1865 006056 1867 006063 1868 006066 1871 006067 1874 006104 1876 006105 1880 006111 1885 006113 1887 006124 1890 006132 1893 006142 1899 006145 1901 006152 1908 006153 1914 006154 1916 006156 1918 006165 1919 006205 1921 006207 1924 006214 1926 006224 1929 006230 1931 006235 1933 006241 1935 006247 1936 006253 1938 006254 1941 006262 1944 006267 1946 006274 1948 006302 1949 006306 1951 006307 1954 006315 1957 006322 1958 006333 1960 006334 1963 006337 1965 006340 1967 006343 1969 006344 1972 006346 1974 006347 1976 006351 2006 006352 2013 006353 2015 006366 2017 006376 2019 006423 2021 006426 2029 006427 2037 006431 2039 006437 2040 006446 2041 006461 2042 006465 2043 006472 2046 006473 2047 006506 2050 006513 2059 006514 2064 006515 2067 006536 2069 006542 2070 006550 2071 006553 2072 006564 2073 006567 2076 006573 ----------------------------------------------------------- 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