COMPILATION LISTING OF SEGMENT monitor_sys_log Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Multics Op. - System M Compiled on: 11/03/86 1031.4 mst Mon Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1984 * 4* * * 5* *********************************************************** */ 6 7 /* format: style2,indcomtxt */ 8 msl: 9 monitor_sys_log: 10 procedure () options (variable); 11 12 /**** Modification History: 13* Created 1984-11-29 BIM from print_sys_log. 14* Modified 1984-12-26, BIM: Added -continuation_indent. 15* Modified 1985-01-16, BIM: Added -match/exclude/all_data_class, -pid, -data_class. 16* Modified 1985-01-25, BIM: fixed dm log name, other silly bugs. 17* Modified 1985-02-07, Steve Herbst: Changed to call dm_misc_util_$get_log_path. 18* Modified 1985-02-21, Steve Herbst: Fixed bug in -dms */ 19 20 21 22 /****^ HISTORY COMMENTS: 23* 1) change(86-04-29,Kissel), approve(86-07-31,MCR7456), audit(86-08-01,Wong), 24* install(86-11-03,MR12.0-1149): 25* Changed to support the DSA system logs using the -dsasl and -dsasal 26* control arguments. 27* END HISTORY COMMENTS */ 28 29 30 declare an_entry_ptr pointer; 31 declare 1 an_entry aligned like monitor_sys_log_array.entry based (an_entry_ptr); 32 declare code fixed bin (35); 33 declare dm_system_log_path char (168); 34 declare dsa_system_log_path char (168); 35 declare log_index fixed bin; 36 declare log_dname char (168); 37 declare log_ename char (32); 38 declare 1 log_open_info aligned like log_read_open_info; 39 declare sci_ptr pointer; 40 declare old_mask bit (36) aligned; 41 declare 1 opt1 like opt based; /* To catch unqualified references */ 42 43 declare 1 opt automatic aligned, /* Miscellaneous options for the command itself; */ 44 2 pathname char (168) unal, /* note that formatting options are kept separately */ 45 2 pointers, /* in the log_message_format structure */ 46 3 log_read_ptr pointer, 47 3 expand_select_ptr 48 pointer, 49 3 lmd_ptr pointer, 50 3 iocb_ptr pointer, 51 2 reader_procedure char (32) varying, 52 2 iocb_name char (32) unaligned, 53 2 call_command aligned, 54 3 ptr pointer, 55 3 length fixed bin (21), 56 2 time fixed bin (71), 57 2 log_number fixed bin, 58 2 flags aligned, 59 3 the_syserr_log_sw 60 bit (1), 61 3 the_as_log_sw bit (1), 62 3 the_admin_log_sw bit (1), 63 3 the_dm_log_sw bit (1), 64 3 the_dsas_log_sw bit (1), 65 3 the_dsasa_log_sw bit (1), 66 3 all_sw bit (1), 67 3 expand_sw bit (1), 68 3 octal_sw bit (1), 69 3 interpret_sw bit (1), 70 3 add_sw bit (1), 71 3 remove_sw bit (1), 72 3 on_sw bit (1), 73 3 off_sw bit (1), 74 3 status_sw bit (1), 75 3 replace_sw bit (1), 76 3 modify_sw bit (1), 77 3 time_given_sw bit (1), 78 3 prefix_given_sw bit (1), 79 3 call_given_sw bit (1), 80 3 free_from_opt bit (1), /* info in here should be freed */ 81 3 process_id_sw bit (1), 82 3 data_class_sw bit (1); 83 84 declare opt_call_command_string 85 char (opt.call_command.length) based (opt.call_command.ptr); 86 87 declare iox_$user_output ptr ext static; 88 declare error_table_$bad_arg fixed bin (35) ext static; 89 declare error_table_$namedup fixed bin (35) ext static; 90 declare error_table_$inconsistent 91 fixed bin (35) ext static; 92 declare error_table_$name_not_found 93 fixed bin (35) ext static; 94 declare error_table_$unexpected_condition 95 fixed bin (35) ext static; 96 declare error_table_$badopt fixed bin (35) external static; 97 declare error_table_$bad_conversion 98 fixed bin (35) external static; 99 declare error_table_$moderr fixed bin (35) external static; 100 declare error_table_$noarg fixed bin (35) external static; 101 declare error_table_$noentry fixed bin (35) external static; 102 declare error_table_$too_many_args 103 fixed bin (35) external static; 104 declare error_table_$no_log_message 105 fixed bin (35) external static; 106 107 108 declare log_data_$syserr_log_name 109 char (32) external static; 110 declare log_data_$syserr_log_dir 111 char (168) external static; 112 113 declare check_gate_access_ entry (char (*), ptr, fixed bin (35)); 114 declare com_err_ entry options (variable); 115 declare command_query_ entry () options (variable); 116 declare continue_to_signal_ entry (fixed binary (35)); 117 declare cv_dec_check_ entry (char (*), fixed bin (35)) returns (fixed bin (35)); 118 119 declare cu_$arg_list_ptr entry returns (pointer); 120 declare dm_misc_util_$get_log_path 121 entry (char (*)); 122 declare dsa_nit_$get_field entry (char (*), char (*), char (*), char (*), fixed bin (35)); 123 declare expand_pathname_ entry (char (*), char (*), char (*), fixed bin (35)); 124 declare format_log_message_$init 125 entry (pointer); 126 declare format_log_message_$adjust 127 entry (pointer, fixed bin (35)); 128 declare format_log_message_$free 129 entry (pointer); 130 declare get_line_length_$switch 131 entry (pointer, fixed bin (35)) returns (fixed bin); 132 declare get_system_free_area_ entry () returns (ptr); 133 declare system_area area based (get_system_free_area_ ()); 134 declare hcs_$set_ips_mask entry (bit (36) aligned, bit (36) aligned); 135 declare hcs_$reset_ips_mask entry (bit (36) aligned, bit (36) aligned); 136 declare ioa_ entry () options (variable); 137 declare iox_$look_iocb entry (char (*), pointer, fixed bin (35)); 138 declare ipc_$create_ev_chn entry (fixed bin (71), fixed bin (35)); 139 declare ipc_$decl_event_call_chn 140 entry (fixed bin (71), entry, ptr, fixed bin, fixed bin (35)); 141 declare ipc_$delete_ev_chn entry (fixed bin (71), fixed bin (35)); 142 declare ipc_$cutoff entry (fixed bin (71), fixed bin (35)); 143 declare ipc_$reconnect entry (fixed bin (71), fixed bin (35)); 144 declare log_expand_select_$add entry (pointer, character (*), fixed binary (35)); 145 declare log_expand_select_$free 146 entry (pointer); 147 declare log_expand_select_$print 148 entry (pointer, pointer, fixed binary); 149 150 declare log_match_$add_match entry (pointer, char (*)); 151 declare log_match_$add_exclude entry (pointer, char (*)); 152 declare log_match_$add_match_data 153 entry (pointer, char (*)); 154 declare log_match_$add_exclude_data 155 entry (pointer, char (*)); 156 declare log_match_$clear_text_strings 157 entry (pointer); 158 declare log_match_$clear_data_strings 159 entry (pointer); 160 declare log_match_$add_match_data_class 161 entry (pointer, character (*)); 162 declare log_match_$add_exclude_data_class 163 entry (pointer, character (*)); 164 declare log_match_$clear_data_class_strings 165 entry (pointer); 166 declare log_match_$add_severity 167 entry (pointer, fixed bin, fixed bin); 168 declare log_match_$clear_severity 169 entry (pointer); 170 declare log_match_$free entry (pointer); 171 declare log_match_$print entry (pointer, pointer, fixed binary); 172 declare log_read_$open entry (char (*), char (*), pointer, fixed bin (35)); 173 declare log_read_$open_long entry (character (*), character (*), pointer, pointer, fixed binary (35)); 174 declare log_read_$update entry (fixed binary (35), pointer, pointer, fixed binary (35)); 175 declare log_read_$close entry (pointer, fixed bin (35)); 176 declare log_read_$prev_message entry (pointer, pointer, fixed bin (35)); 177 declare log_read_$get_log_uid entry (pointer, bit (36) aligned, fixed binary (35)); 178 declare monitor_sys_log_wakeup_$timer 179 entry (pointer); 180 181 declare pathname_ entry (char (*), char (*)) returns (char (168)); 182 183 declare sub_err_ entry () options (variable); 184 declare ssu_$arg_count entry (ptr, fixed bin); 185 declare ssu_$standalone_invocation 186 entry (ptr, char (*), char (*), ptr, entry, fixed bin (35)); 187 declare ssu_$destroy_invocation 188 entry (ptr); 189 declare ssu_$arg_ptr entry (ptr, fixed bin, ptr, fixed bin (21)); 190 declare ssu_$abort_line entry () options (variable); 191 declare timer_manager_$alarm_wakeup 192 entry (fixed binary (71), bit (2), fixed binary (71)); 193 declare timer_manager_$reset_alarm_wakeup 194 entry (fixed binary (71)); 195 196 declare any_other condition; 197 declare cleanup condition; 198 199 declare COMMAND_NAME char (32) internal static options (constant) init ("monitor_sys_log"); 200 declare SYSERR_PATH char (10) internal static options (constant) init ("<>SYSERR<>"); 201 declare AS_PATH char (10) internal static options (constant) init ("<>AS_LOG<>"); 202 declare ADMIN_PATH char (10) internal static options (constant) init ("<>ADMIN<>"); 203 declare DM_PATH char (10) internal static options (constant) init ("<>DM<>"); 204 declare DSA_SL_PATH char (10) internal static options (constant) init ("<>DSASL<>"); 205 declare DSA_SAL_PATH char (10) internal static options (constant) init ("<>DSASAL<>"); 206 declare ALL_PATH char (10) internal static options (constant) init ("<>ALL<>"); 207 declare NUMBER_PATH char (10) internal static options (constant) init ("<>NUMBER<>"); 208 209 210 declare MC_LOG_DIR char (168) init (">system_control_dir>as_logs") int static options (constant); 211 212 declare DEFAULT_LINE_LENGTH fixed bin internal static options (constant) init (132); 213 /* assume a file of some sort */ 214 215 declare (abs, addr, after, before, char, codeptr, index, length, null, substr, unspec) 216 builtin; 217 218 declare DM_READER_PROCEDURE char (32) init ("dm_log_read_") int static options (constant); 219 declare DSA_READER_PROCEDURE char (32) init ("dsa_log_admin_gate_") int static options (constant); 220 221 222 call initialize_options (); 223 224 on condition (cleanup) call clean_up (); 225 226 227 call ssu_$standalone_invocation (sci_ptr, COMMAND_NAME, "1.0", cu_$arg_list_ptr (), SSU_ABORT, code); 228 if code ^= 0 229 then do; 230 call com_err_ (code, COMMAND_NAME, "Unable to create ssu invocation."); 231 return; 232 end; 233 234 235 call process_arguments$$find_log_and_action (); /* sets opt to indicate what log and what is to be done with it */ 236 237 if opt.time_given_sw 238 then /* one possible action is to set the clock */ 239 do; 240 monitor_sys_log_data_.wakeup_interval = opt.time; 241 call reset_timer; 242 end; 243 244 if opt.pathname = "" 245 then /* just the time, or the time and -status */ 246 if opt.status_sw 247 then call print_status_header (); 248 else ; 249 else call process_log; /* reparse args to do the real work */ 250 251 call ssu_$destroy_invocation (sci_ptr); 252 go to MAIN_RETURN; 253 254 255 SSU_ABORT: 256 procedure; 257 call finished (); 258 end SSU_ABORT; 259 260 261 MAIN_RETURN: /* This is the ONLY return statement for this procedure */ 262 return; 263 264 265 266 finished: /* This is a procedure in order to aid debugging; one */ 267 procedure (); /* can set a breakpoint in it to catch all error returns */ 268 269 call clean_up (); 270 271 goto MAIN_RETURN; 272 273 end finished; 274 275 276 fault_masked: 277 procedure; 278 279 if substr (old_mask, 36, 1) = "0"b 280 then call continue_to_signal_ ((0)); 281 else do; 282 call hcs_$reset_ips_mask (old_mask, old_mask); 283 monitor_sys_log_data_.initialized = "0"b; 284 call sub_err_ (error_table_$unexpected_condition, COMMAND_NAME, ACTION_CANT_RESTART, null (), (0), 285 "Error signalled while manipulating database."); 286 end; 287 return; 288 end fault_masked; 289 290 clean_up: 291 procedure (); 292 293 if opt.free_from_opt 294 then do; 295 if (opt.lmd_ptr ^= null ()) 296 then call log_match_$free (opt.lmd_ptr); 297 298 if (opt.log_read_ptr ^= null ()) 299 then call log_read_$close (opt.log_read_ptr, (0)); 300 301 if (log_message_format_ptr ^= null ()) 302 then call format_log_message_$free (log_message_format_ptr); 303 end; 304 if sci_ptr ^= null () 305 then call ssu_$destroy_invocation (sci_ptr); 306 307 return; 308 end clean_up; 309 310 reset_timer: 311 procedure; 312 313 if monitor_sys_log_data_.active & monitor_sys_log_data_.wakeup_event_channel ^= 0 314 then call timer_manager_$reset_alarm_wakeup (monitor_sys_log_data_.wakeup_event_channel); 315 monitor_sys_log_data_.active = "0"b; 316 317 if monitor_sys_log_data_.n_logs_on_timer = 0 318 then return; 319 if monitor_sys_log_data_.wakeup_event_channel = 0 320 then do; 321 call ipc_$create_ev_chn (monitor_sys_log_data_.wakeup_event_channel, code); 322 if code ^= 0 323 then call sub_err_ (code, COMMAND_NAME, ACTION_CANT_RESTART, null (), (0), 324 "Failed to create event channel for log timer."); 325 call ipc_$decl_event_call_chn (monitor_sys_log_data_.wakeup_event_channel, 326 monitor_sys_log_wakeup_$timer, null (), 0, code); 327 if code ^= 0 328 then call sub_err_ (code, COMMAND_NAME, ACTION_CANT_RESTART, null (), (0), 329 "Failed to declare event call channel for log timer."); 330 end; 331 monitor_sys_log_data_.active = "1"b; 332 call timer_manager_$alarm_wakeup (monitor_sys_log_data_.wakeup_interval, "11"b, 333 monitor_sys_log_data_.wakeup_event_channel); 334 335 return; 336 end reset_timer; 337 338 339 /**** When this is called, opt has a pathname of a log (and 340* bits for the special logs), and the opt bits that 341* specify actions are set. This procedure must determine 342* if the specified log is already being monitored. 343* If this is incompatable with the control arguments, 344* then it must abort. 345* 346* Otherwise, the action can be one of: 347* 348* replace: remove the current monitor and then do an add. 349* modify: fill up opt from an_entry, parse args changing opt, 350* and then copy back from opt to an_entry. 351**/ 352 353 process_log: 354 procedure; 355 356 declare already_monitored bit (1) aligned; 357 declare explicit_action bit (1) aligned; 358 declare explicit_modification bit (1) aligned; 359 360 explicit_action = opt.add_sw | opt.remove_sw | opt.modify_sw | opt.on_sw | opt.off_sw | opt.status_sw; 361 explicit_modification = explicit_action & ^opt.add_sw; 362 if opt.all_sw 363 then do; 364 if ^explicit_modification 365 then call ssu_$abort_line (sci_ptr, 0, "-all requires -on, -off, -remove, or -status."); 366 call process_all_logs; 367 return; 368 end; 369 370 call make_log_pathname; /* turn <> to FS path */ 371 call find_log; /* if the specified log exists, then set log_index and an_entry_ptr */ 372 373 already_monitored = (log_index ^= 0); 374 375 if opt.add_sw & already_monitored 376 then call ssu_$abort_line (sci_ptr, 0, 377 "You are already monitoring ^a. Use -replace or -modify to change its parameters.", opt.pathname); 378 379 if explicit_modification & ^already_monitored 380 then call ssu_$abort_line (sci_ptr, 0, 381 "-^[modify^]^[replace^]^[remove^]^[on^]^[off^]^[status^] specified, but you are not monitoring ^a.", 382 opt.modify_sw, opt.replace_sw, opt.remove_sw, opt.on_sw, opt.off_sw, opt.status_sw, opt.pathname); 383 384 if ^explicit_action 385 then if already_monitored 386 then opt.modify_sw = "1"b; /* The default is to modify */ 387 else opt.add_sw = "1"b; /* unless its not there at all, so we add */ 388 389 /**** Now we have enough information to know what we are doing */ 390 391 if opt.modify_sw /* an_entry is valid, guaranteed */ 392 then do; 393 opt.free_from_opt = "0"b; /* we are putting live goodies in here */ 394 opt.expand_select_ptr = an_entry.expand_select_ptr; 395 opt.lmd_ptr = an_entry.lmd_ptr; 396 log_message_format_ptr = an_entry.format_ptr; 397 opt.log_read_ptr = an_entry.log_read_ptr; 398 end; 399 if opt.replace_sw 400 then do; 401 if log_index > 0 /* its OK to -update when nothing is there, it just adds */ 402 then call remove_log; /* POOF */ 403 opt.replace_sw = "0"b; 404 opt.add_sw = "1"b; 405 end; 406 if opt.add_sw 407 then call initialize_add_options; 408 if opt.add_sw | opt.modify_sw 409 then do; 410 call process_arguments$$fill_opt_with_options (); 411 if opt.add_sw 412 then do; 413 call open_log; /* fills in opt with read_data_ptr */ 414 call make_new_entry; /* given a findable log, create a slot for it */ 415 end; 416 call fill_entry_from_opt; 417 end; 418 else call process_existing_log; /* take care of -remove, -on, -off, -status */ 419 return; 420 end process_log; 421 422 423 424 /**** This procedure sets log_index to 0 or the index of a log 425* with a pre-existing monitor. It always leaves an_entry_ptr 426* consistent with log_index. */ 427 428 find_log: 429 procedure; 430 431 log_index = 0; /* assume no match */ 432 an_entry_ptr = null (); 433 434 if monitor_sys_log_data_.initialized 435 then monitor_sys_log_array_ptr = monitor_sys_log_data_.log_array_ptr; 436 437 if ^monitor_sys_log_data_.initialized | monitor_sys_log_data_.n_logs = 0 438 | monitor_sys_log_data_.log_array_ptr = null () 439 then return; /* surely no match */ 440 441 if opt.log_number > 0 442 then do; /* asked by number */ 443 if opt.log_number > monitor_sys_log_array.n_entries 444 then return; 445 if monitor_sys_log_array.entry (opt.log_number).dir_name = "" 446 then return; 447 log_index = opt.log_number; 448 an_entry_ptr = addr (monitor_sys_log_array.entry (log_index)); 449 return; 450 end; 451 452 /*** done with the numbered case. */ 453 454 do log_index = 1 to monitor_sys_log_array.n_entries; 455 an_entry_ptr = addr (monitor_sys_log_array.entry (log_index)); 456 if an_entry.dir_name = "" 457 then ; /* not in use */ 458 else if opt.the_syserr_log_sw & an_entry.the_syserr_log 459 then return; 460 else if opt.the_as_log_sw & an_entry.the_as_log 461 then return; 462 else if opt.the_admin_log_sw & an_entry.the_admin_log 463 then return; 464 else if opt.the_dm_log_sw & an_entry.the_dm_log 465 then return; 466 else if opt.the_dsas_log_sw & an_entry.the_dsas_log 467 then return; 468 else if opt.the_dsasa_log_sw & an_entry.the_dsasa_log 469 then return; 470 else if same_pathname () 471 then return; 472 end; 473 log_index = 0; 474 return; 475 476 same_pathname: 477 procedure returns (bit (1) aligned); 478 479 declare (new_uid, old_uid) bit (36) aligned; 480 declare temp_opening pointer; 481 482 if an_entry.the_syserr_log | an_entry.the_as_log | an_entry.the_admin_log | an_entry.the_dm_log 483 | an_entry.the_dsas_log | an_entry.the_dsasa_log 484 then return ("0"b); /* already checked */ 485 486 call open_log; /* sets opt.log_read_ptr */ 487 temp_opening = opt.log_read_ptr; 488 opt.log_read_ptr = null (); 489 call log_read_$get_log_uid (temp_opening, new_uid, code); 490 call log_read_$close (temp_opening, (0)); 491 if code ^= 0 492 then return ("0"b); 493 call log_read_$update (an_entry.last_sequence, an_entry.log_read_ptr, an_entry.last_message_ptr, code); 494 call log_read_$get_log_uid (an_entry.log_read_ptr, old_uid, code); 495 if code ^= 0 496 then return ("0"b); 497 if new_uid = old_uid 498 then return ("1"b); 499 else return ("0"b); 500 501 end same_pathname; 502 end find_log; 503 504 505 print_status_header: 506 procedure; 507 508 declare select_timer fixed bin; 509 510 if ^monitor_sys_log_data_.initialized | monitor_sys_log_data_.n_logs = 0 511 then do; 512 call ioa_ ("No logs, timer wakeup interval ^d seconds.", monitor_sys_log_data_.wakeup_interval); 513 return; 514 end; 515 516 if monitor_sys_log_data_.n_logs = 0 517 then select_timer = 1; /* don't print */ 518 else if monitor_sys_log_data_.n_logs = 1 519 then if monitor_sys_log_data_.n_logs_on_timer = 1 520 then select_timer = 2; 521 else select_timer = 3; 522 else if monitor_sys_log_data_.n_logs_on_timer = monitor_sys_log_data_.n_logs 523 then select_timer = 4; /* all */ 524 else if monitor_sys_log_data_.n_logs_on_timer = 0 525 then select_timer = 5; /* none */ 526 else select_timer = 6; 527 528 call ioa_ ( 529 "^d log^[s^]^[^s^;^s on timer^;^s^;^s, all on timer wakeup^;^s, none on timer wakeup^;, ^d on timer wakeup^]. Wakeup interval ^d seconds.", 530 monitor_sys_log_data_.n_logs, monitor_sys_log_data_.n_logs ^= 1, select_timer, 531 monitor_sys_log_data_.n_logs_on_timer, monitor_sys_log_data_.wakeup_interval); 532 return; 533 end print_status_header; 534 535 536 537 process_existing_log: 538 procedure; 539 540 if opt.status_sw 541 then call status_log; 542 else if opt.off_sw 543 then call disable_log; 544 else if opt.on_sw 545 then call enable_log; 546 else if opt.remove_sw 547 then call remove_log; 548 549 return; 550 end process_existing_log; 551 552 process_all_logs: 553 procedure; 554 555 monitor_sys_log_array_ptr = monitor_sys_log_data_.log_array_ptr; 556 557 if opt.status_sw 558 then do; 559 call print_status_header; 560 if monitor_sys_log_data_.n_logs = 0 561 then return; 562 end; 563 else if monitor_sys_log_data_.n_logs = 0 564 then call ssu_$abort_line (sci_ptr, 0, "There are no monitors set."); 565 566 567 do log_index = 1 to monitor_sys_log_array.n_entries; 568 an_entry_ptr = addr (monitor_sys_log_array.entry (log_index)); 569 if an_entry.dir_name ^= "" 570 then call process_existing_log; 571 end; 572 return; 573 end process_all_logs; 574 575 status_log: 576 procedure; 577 578 call ioa_ ( 579 "# ^d: Pathname ^a^[ (the syserr log)^]^[ (the Answering Service log)^]^[ (the Admin command log)^]^[ (the DM system log)^]^[ (the DSA system log)^]^[ (the DSA system aep log)^]", 580 log_index, pathname_ (an_entry.dir_name, an_entry.entryname), an_entry.the_syserr_log, an_entry.the_as_log, 581 an_entry.the_admin_log, an_entry.the_dm_log, an_entry.the_dsas_log, an_entry.the_dsasa_log); 582 call ioa_ (" ^[Examined on timer^;Registered to receive wakeups on messages^]", ^an_entry.registered); 583 if an_entry.inhibited 584 then call ioa_ (" Currently inhibited."); 585 if an_entry.expand_select_ptr ^= null () 586 then call log_expand_select_$print (an_entry.expand_select_ptr, iox_$user_output, 3); 587 if an_entry.lmd_ptr ^= null () 588 then call log_match_$print (an_entry.lmd_ptr, iox_$user_output, 3); 589 /*** The formatting options are too hairy */ 590 call ioa_ (" Last sequence number ^d.", an_entry.last_sequence); 591 return; 592 end status_log; 593 594 disable_log: 595 procedure; 596 597 if an_entry.inhibited 598 then call ssu_$abort_line (sci_ptr, 0, "Log ^a is already off.", an_entry.entryname); 599 an_entry.inhibited = "1"b; 600 if an_entry.registered 601 then call ipc_$cutoff (an_entry.registered_wakeup_event_channel, (0)); 602 else call reset_timer; 603 return; 604 end disable_log; 605 606 enable_log: 607 procedure; 608 609 if ^an_entry.inhibited 610 then call ssu_$abort_line (sci_ptr, 0, "Log ^a is already on.", an_entry.entryname); 611 call log_read_$update (an_entry.last_sequence, an_entry.log_read_ptr, an_entry.last_message_ptr, (0)); 612 /* ignore this code */ 613 an_entry.last_message_ptr = null (); 614 call log_read_$prev_message (an_entry.log_read_ptr, an_entry.last_message_ptr, code); 615 if code ^= 0 616 then call ssu_$abort_line (sci_ptr, code, "Failed to find last message in log ^a to process -on.", 617 an_entry.entryname); 618 an_entry.last_sequence = an_entry.last_message_ptr -> log_message.sequence; 619 an_entry.prev_message_ptr = null (); 620 an_entry.inhibited = "0"b; 621 if an_entry.registered 622 then call ipc_$reconnect (an_entry.registered_wakeup_event_channel, (0)); 623 else call reset_timer; 624 return; 625 end enable_log; 626 627 remove_log: 628 procedure; 629 630 if an_entry.registered 631 then do; /* de-register, etc */ 632 end; 633 else monitor_sys_log_data_.n_logs_on_timer = monitor_sys_log_data_.n_logs_on_timer - 1; 634 monitor_sys_log_data_.n_logs = monitor_sys_log_data_.n_logs - 1; 635 636 old_mask = ""b; 637 on any_other call fault_masked; 638 on cleanup 639 begin; 640 if substr (old_mask, 36, 1) = "1"b 641 then call hcs_$reset_ips_mask (old_mask, old_mask); 642 end; 643 call hcs_$set_ips_mask (""b, old_mask); 644 an_entry.dir_name = ""; /* chase handlers away */ 645 call hcs_$reset_ips_mask (old_mask, old_mask); 646 revert any_other, cleanup; 647 648 call log_read_$close (an_entry.log_read_ptr, (0)); 649 if an_entry.expand_select_ptr ^= null () 650 then call log_expand_select_$free (an_entry.expand_select_ptr); 651 if an_entry.lmd_ptr ^= null () 652 then call log_match_$free (an_entry.lmd_ptr); 653 if an_entry.format_ptr ^= null () 654 then call format_log_message_$free (an_entry.format_ptr); 655 if an_entry.registered_wakeup_event_channel ^= 0 656 then call ipc_$delete_ev_chn (an_entry.registered_wakeup_event_channel, (0)); 657 if an_entry.call_command.ptr ^= null () 658 then begin; 659 declare call_command_string char (an_entry.call_command.length) based (an_entry.call_command.ptr); 660 free call_command_string; 661 end; 662 663 call clear_entry; 664 call reset_timer; 665 return; 666 end remove_log; 667 668 make_new_entry: 669 procedure; 670 671 if ^monitor_sys_log_data_.initialized 672 then call initialize_data (); /* sets array ptr if needed */ 673 674 /**** we have to mask IPS to avoid QUIT and foolishness */ 675 676 old_mask = ""b; 677 on any_other call fault_masked; 678 on cleanup 679 begin; 680 if substr (old_mask, 36, 1) = "1"b 681 then call hcs_$reset_ips_mask (old_mask, old_mask); 682 end; 683 call hcs_$set_ips_mask (""b, old_mask); 684 685 do log_index = 1 to monitor_sys_log_array.n_entries; 686 if monitor_sys_log_array.entry (log_index).dir_name = "" 687 then go to HAVE_EMPTY_SLOT; 688 end; 689 690 call reallocate_array (); 691 692 HAVE_EMPTY_SLOT: 693 an_entry_ptr = addr (monitor_sys_log_array.entry (log_index)); 694 /* set pointer for caller */ 695 696 call hcs_$reset_ips_mask (old_mask, old_mask); 697 revert any_other, cleanup; 698 699 end make_new_entry; 700 701 702 703 fill_entry_from_opt: 704 procedure; 705 706 declare log_last_sequence fixed bin (35); 707 declare log_last_message_ptr pointer; 708 709 if opt.add_sw 710 then call get_last_message_info (log_last_sequence, log_last_message_ptr); 711 712 if ^opt.prefix_given_sw 713 then do; 714 if opt.the_syserr_log_sw 715 then log_message_format.prefix = "SYSERR: "; 716 else if opt.the_as_log_sw 717 then log_message_format.prefix = "AS: "; 718 else if opt.the_admin_log_sw 719 then log_message_format.prefix = "ADMIN: "; 720 else if opt.the_dm_log_sw 721 then log_message_format.prefix = "DM: "; 722 else if opt.the_dsas_log_sw 723 then log_message_format.prefix = "DSASL: "; 724 else if opt.the_dsasa_log_sw 725 then log_message_format.prefix = "DSASAL: "; 726 else log_message_format.prefix = rtrim (log_ename) || ": "; 727 call adjust_log_message_format ("Adding default prefix", (log_message_format.prefix)); 728 end; 729 730 an_entry.dir_name = log_dname; 731 an_entry.entryname = log_ename; 732 an_entry.log_read_ptr = opt.log_read_ptr; 733 an_entry.the_syserr_log = opt.the_syserr_log_sw; 734 an_entry.the_as_log = opt.the_as_log_sw; 735 an_entry.the_admin_log = opt.the_admin_log_sw; 736 an_entry.the_dm_log = opt.the_dm_log_sw; 737 an_entry.the_dsas_log = opt.the_dsas_log_sw; 738 an_entry.the_dsasa_log = opt.the_dsasa_log_sw; 739 an_entry.registered = "0"b; /* not yet implemented */ 740 an_entry.inhibited = "0"b; 741 an_entry.expand_select_ptr = opt.expand_select_ptr; 742 an_entry.lmd_ptr = opt.lmd_ptr; 743 an_entry.iocb_ptr = opt.iocb_ptr; 744 an_entry.octal_sw = opt.octal_sw; 745 an_entry.interpret_sw = opt.interpret_sw; 746 an_entry.process_id_sw = opt.process_id_sw; 747 an_entry.data_class_sw = opt.data_class_sw; 748 749 an_entry.format_ptr = log_message_format_ptr; 750 if opt.add_sw 751 then do; 752 an_entry.last_sequence = log_last_sequence; 753 /* found by open_log */ 754 an_entry.last_message_ptr = log_last_message_ptr; 755 an_entry.prev_message_ptr = null (); 756 end; 757 if opt.call_given_sw 758 then begin; 759 declare copy_of_call_command char (an_entry.call_command.length) based (an_entry.call_command.ptr); 760 an_entry.call_command.length = opt.call_command.length; 761 allocate copy_of_call_command in (system_area); 762 copy_of_call_command = opt_call_command_string; 763 end; 764 765 if opt.add_sw 766 then do; /* This won't be right if we are modifying the registered status. Implementors of -registered beware */ 767 monitor_sys_log_data_.n_logs = monitor_sys_log_data_.n_logs + 1; 768 if ^an_entry.registered 769 then do; 770 monitor_sys_log_data_.n_logs_on_timer = monitor_sys_log_data_.n_logs_on_timer + 1; 771 if monitor_sys_log_data_.n_logs_on_timer = 1 772 /* first one */ 773 then call reset_timer (); 774 end; 775 776 end; 777 778 return; 779 end fill_entry_from_opt; 780 781 make_log_pathname: 782 procedure (); 783 784 if opt.all_sw 785 then return; 786 if (opt.pathname = NUMBER_PATH) 787 then return; 788 789 if (opt.pathname = SYSERR_PATH) 790 then do; 791 log_dname = log_data_$syserr_log_dir; 792 log_ename = log_data_$syserr_log_name; 793 opt.pathname = pathname_ (log_dname, log_ename); 794 end; 795 796 else if opt.pathname = AS_PATH 797 then do; 798 log_dname = ">system_control_dir>as_logs"; 799 log_ename = "log"; 800 opt.pathname = pathname_ (log_dname, log_ename); 801 end; 802 else if opt.pathname = ADMIN_PATH 803 then do; 804 log_dname = ">system_control_dir>as_logs"; 805 log_ename = "admin_log"; 806 opt.pathname = pathname_ (log_dname, log_ename); 807 end; 808 else if opt.pathname = DM_PATH 809 then do; 810 call dm_misc_util_$get_log_path (dm_system_log_path); 811 call expand_pathname_ (dm_system_log_path, log_dname, log_ename, 0); 812 opt.pathname = dm_system_log_path; 813 opt.reader_procedure = DM_READER_PROCEDURE; 814 end; 815 else if opt.pathname = DSA_SL_PATH 816 then do; 817 818 /*** Check to see if we will succeed. */ 819 820 call check_gate_access_ (DSA_READER_PROCEDURE, null (), code); 821 822 if code = error_table_$noentry 823 then call ssu_$abort_line (sci_ptr, error_table_$bad_arg, "DSA is not installed on this system."); 824 else if code = error_table_$moderr 825 then call ssu_$abort_line (sci_ptr, code, "You need e access to ^a to read the DSA log.", 826 DSA_READER_PROCEDURE); 827 else if code ^= 0 828 then call ssu_$abort_line (sci_ptr, code, "Trying to check the access to: ^a.", DSA_READER_PROCEDURE); 829 830 /*** The code was 0, proceed. */ 831 832 else call dsa_nit_$get_field ("mna_general_info", "", "dsa_system_log", dsa_system_log_path, code); 833 834 if code ^= 0 835 then call ssu_$abort_line (sci_ptr, code, "Cannot find the name of the dsa system log."); 836 837 call expand_pathname_ (dsa_system_log_path, log_dname, log_ename, 0); 838 opt.pathname = dsa_system_log_path; 839 opt.reader_procedure = DSA_READER_PROCEDURE; 840 end; 841 else if opt.pathname = DSA_SAL_PATH 842 then do; 843 844 /*** Check to see if we will succeed. */ 845 846 call check_gate_access_ (DSA_READER_PROCEDURE, null (), code); 847 848 if code = error_table_$noentry 849 then call ssu_$abort_line (sci_ptr, error_table_$bad_arg, "DSA is not installed on this system."); 850 else if code = error_table_$moderr 851 then call ssu_$abort_line (sci_ptr, code, "You need e access to ^a to read the DSA log.", 852 DSA_READER_PROCEDURE); 853 else if code ^= 0 854 then call ssu_$abort_line (sci_ptr, code, "Trying to check the access to: ^a.", DSA_READER_PROCEDURE); 855 856 /*** The code was 0, proceed. */ 857 858 else call dsa_nit_$get_field ("mna_general_info", "", "dsa_system_aep_log", dsa_system_log_path, code) 859 ; 860 861 if code ^= 0 862 then call ssu_$abort_line (sci_ptr, code, "Cannot find the name of the dsa system aep log."); 863 864 call expand_pathname_ (dsa_system_log_path, log_dname, log_ename, 0); 865 opt.pathname = dsa_system_log_path; 866 opt.reader_procedure = DSA_READER_PROCEDURE; 867 end; 868 else do; 869 call expand_pathname_ (opt.pathname, log_dname, log_ename, code); 870 if (code ^= 0) 871 then call ssu_$abort_line (sci_ptr, code, "Log pathname ^a", opt.pathname); 872 end; 873 874 return; 875 end make_log_pathname; 876 877 open_log: 878 procedure; 879 880 if opt.reader_procedure ^= "" 881 then do; 882 log_open_info.version = LOG_READ_OPEN_INFO_VERSION_1; 883 log_open_info.reader_procedure = opt.reader_procedure; 884 log_open_info.allocation_area_ptr = get_system_free_area_ (); 885 /* since we never use hold_message, it is reasonable for log_read_ to allocate the 2 copies it keeps around in here */ 886 log_open_info.allocate_copies = "0"b; /* That is the inner-ring's job */ 887 call log_read_$open_long (log_dname, log_ename, addr (log_open_info), opt.log_read_ptr, code); 888 end; 889 else call log_read_$open (log_dname, log_ename, opt.log_read_ptr, code); 890 891 if (code ^= 0) 892 then call ssu_$abort_line (sci_ptr, code, "Cannot open ^a", opt.pathname); 893 894 return; 895 end open_log; 896 897 get_last_message_info: 898 procedure (last_seq, last_msg_ptr); 899 900 declare last_seq fixed bin (35); 901 declare last_msg_ptr pointer; 902 903 last_msg_ptr = null (); 904 call log_read_$prev_message (opt.log_read_ptr, last_msg_ptr, code); 905 if code ^= 0 & code ^= error_table_$no_log_message/* no_log_message happens if the log is empty. */ 906 then call ssu_$abort_line (sci_ptr, code, "Failed to find last message in log ^a.", opt.pathname); 907 /* This may need to know about empty logs ... */ 908 if last_msg_ptr = null () 909 then last_seq = -1; 910 else last_seq = last_msg_ptr -> log_message.sequence; 911 return; 912 end get_last_message_info; 913 914 initialize_data: 915 procedure; 916 917 declare 1 init_entry aligned like monitor_sys_log_array.entry automatic; 918 919 declare new_array_ptr pointer; 920 declare x fixed bin; 921 922 msl_n_entries = 100; /* lots */ 923 allocate monitor_sys_log_array in (system_area); 924 call set_init_entry (); 925 926 monitor_sys_log_array.entry (*) = init_entry; 927 monitor_sys_log_data_.log_array_ptr = monitor_sys_log_array_ptr; 928 monitor_sys_log_data_.initialized = "1"b; 929 return; 930 931 reallocate_array: 932 entry; 933 934 msl_n_entries = 2 * monitor_sys_log_array.n_entries; 935 allocate monitor_sys_log_array in (system_area) set (new_array_ptr); 936 call set_init_entry (); 937 new_array_ptr -> monitor_sys_log_array.entry (*) = init_entry; 938 do x = 1 to monitor_sys_log_array.n_entries; 939 new_array_ptr -> monitor_sys_log_array.entry (x) = monitor_sys_log_array.entry (x); 940 end; 941 log_index = x; /* first free slot in new array */ 942 943 old_mask = ""b; 944 on any_other call fault_masked; 945 on cleanup 946 begin; 947 if substr (old_mask, 36, 1) = "1"b 948 then call hcs_$reset_ips_mask (old_mask, old_mask); 949 end; 950 call hcs_$set_ips_mask (""b, old_mask); 951 monitor_sys_log_data_.log_array_ptr = new_array_ptr; 952 free monitor_sys_log_array; 953 monitor_sys_log_array_ptr = new_array_ptr; 954 call hcs_$reset_ips_mask (old_mask, old_mask); 955 revert any_other, cleanup; 956 return; 957 958 clear_entry: 959 entry; /* assumes an_entry is the victim */ 960 961 call set_init_entry (); 962 an_entry = init_entry; 963 return; 964 965 set_init_entry: 966 procedure; 967 968 init_entry.dir_name = ""; 969 init_entry.entryname = ""; 970 init_entry.log_read_ptr = null (); 971 init_entry.the_syserr_log = "0"b; 972 init_entry.the_as_log = "0"b; 973 init_entry.the_admin_log = "0"b; 974 init_entry.the_dm_log = "0"b; 975 init_entry.the_dsas_log = "0"b; 976 init_entry.the_dsasa_log = "0"b; 977 init_entry.registered = "0"b; 978 init_entry.inhibited = "0"b; 979 init_entry.expand_select_ptr = null (); 980 init_entry.interpret_sw = "0"b; 981 init_entry.octal_sw = "0"b; 982 init_entry.lmd_ptr = null (); 983 init_entry.format_ptr = null (); 984 init_entry.iocb_ptr = null (); 985 init_entry.call_command.ptr = null (); 986 init_entry.call_command.length = 0; 987 init_entry.last_sequence = 0; 988 init_entry.last_message_ptr = null (); 989 init_entry.prev_message_ptr = null (); 990 init_entry.registered_wakeup_event_channel = 0; 991 return; 992 end set_init_entry; 993 994 end initialize_data; 995 996 997 initialize_options: 998 procedure (); 999 1000 /* This must be run before the cleanup handler gets set up */ 1001 1002 unspec (opt) = ""b; /* Turn all options off */ 1003 opt.pointers = null (); /* Aggregate assignment */ 1004 opt.free_from_opt = "1"b; 1005 opt.pathname = ""; 1006 opt.iocb_ptr = iox_$user_output; 1007 opt.call_command.ptr = null (); 1008 opt.call_command.length = 0; 1009 log_message_format_ptr = null (); 1010 opt.reader_procedure = ""; /* Default */ 1011 return; 1012 end initialize_options; 1013 1014 initialize_add_options: 1015 procedure; 1016 1017 call format_log_message_$init (log_message_format_ptr); 1018 log_message_format.continuation_indent = 3; /* economize on space */ 1019 log_message_format.caller = COMMAND_NAME; 1020 log_message_format.equal_sw = "0"b; 1021 1022 log_message_format.line_lth = get_line_length_$switch (opt.iocb_ptr, code); 1023 if (code ^= 0) 1024 then log_message_format.line_lth = DEFAULT_LINE_LENGTH; 1025 /* Pretend to be a printer, by default */ 1026 1027 call adjust_log_message_format ("Initializing log_message_format structure", ""); 1028 1029 return; 1030 end initialize_add_options; 1031 1032 1033 process_arguments$$find_log_and_action: 1034 procedure (); 1035 1036 declare arg char (arg_lth) based (arg_ptr); 1037 declare arg_lth fixed bin (21); 1038 declare arg_ptr pointer; 1039 declare arg_count fixed bin; 1040 declare arg_idx fixed bin; 1041 1042 declare looking_for fixed bin; 1043 declare saved_looking_for fixed bin; 1044 declare number_arg char (20) varying; 1045 declare iocb_arg char (32) varying; 1046 declare temp_v_string_arg char (200) varying; 1047 declare pass fixed bin; 1048 1049 declare FIND_LOG fixed bin init (1) int static options (constant); 1050 declare DO_CONTROL_ARGS fixed bin init (2) int static options (constant); 1051 1052 declare LOG_PATHNAME init (1) fixed bin internal static options (constant); 1053 declare MATCH_STRING init (2) fixed bin internal static options (constant); 1054 declare EXCLUDE_STRING init (3) fixed bin internal static options (constant); 1055 declare MATCH_DATA_STRING init (4) fixed bin internal static options (constant); 1056 declare EXCLUDE_DATA_STRING init (5) fixed bin internal static options (constant); 1057 declare SEVERITY init (6) fixed bin internal static options (constant); 1058 declare CALL_COMMAND init (7) fixed bin internal static options (constant); 1059 declare EXPAND_TYPE init (8) fixed bin internal static options (constant); 1060 declare MC_PATHNAME init (9) fixed bin internal static options (constant); 1061 declare MATCH_DATA_CLASS_STRING 1062 init (10) fixed bin internal static options (constant); 1063 declare EXCLUDE_DATA_CLASS_STRING 1064 init (11) fixed bin internal static options (constant); 1065 1066 1067 pass = FIND_LOG; 1068 go to COMMON; 1069 1070 process_arguments$$fill_opt_with_options: 1071 entry; 1072 1073 pass = DO_CONTROL_ARGS; 1074 1075 COMMON: 1076 call ssu_$arg_count (sci_ptr, arg_count); 1077 1078 looking_for = 0 - LOG_PATHNAME; /* Start out "casually" looking for a pathname */ 1079 1080 do arg_idx = 1 to arg_count; 1081 call ssu_$arg_ptr (sci_ptr, arg_idx, arg_ptr, arg_lth); 1082 1083 if (looking_for > 0) 1084 then do; /* First one after a control argument */ 1085 call process_looking_for (); /* -match -fred matches "-fred", but */ 1086 looking_for = 0 - looking_for; /* -match str -fred is an error */ 1087 end; /* "Casually" looking for signalled by negative value */ 1088 1089 else if (arg = "-match") | (arg = "-mh") 1090 then do; 1091 looking_for = MATCH_STRING; 1092 end; 1093 else if (arg = "-exclude") | (arg = "-ex") 1094 then do; 1095 looking_for = EXCLUDE_STRING; 1096 end; 1097 1098 else if (arg = "-match_data_class") | (arg = "-mdc") 1099 then do; 1100 looking_for = MATCH_DATA_CLASS_STRING; 1101 end; 1102 else if (arg = "-exclude_data_class") | (arg = "-exdc") 1103 then do; 1104 looking_for = EXCLUDE_DATA_CLASS_STRING; 1105 end; 1106 else if (arg = "-match_data") | (arg = "-md") 1107 then do; 1108 looking_for = MATCH_DATA_STRING; 1109 end; 1110 else if (arg = "-exclude_data") | (arg = "-exd") 1111 then do; 1112 looking_for = EXCLUDE_DATA_STRING; 1113 end; 1114 else if (arg = "-all_text") | (arg = "-atxt") 1115 then do; 1116 if (pass = DO_CONTROL_ARGS) 1117 then do; 1118 call log_match_$clear_text_strings (opt.lmd_ptr); 1119 end; 1120 end; 1121 else if (arg = "-all_data") | (arg = "-ad") 1122 then do; 1123 if (pass = DO_CONTROL_ARGS) 1124 then do; 1125 call log_match_$clear_data_strings (opt.lmd_ptr); 1126 end; 1127 end; 1128 1129 else if (arg = "-all_data_class") | (arg = "-adc") 1130 then do; 1131 if (pass = DO_CONTROL_ARGS) 1132 then do; 1133 call log_match_$clear_data_class_strings (opt.lmd_ptr); 1134 end; 1135 end; 1136 1137 1138 else if (arg = "-severity") | (arg = "-sv") | (arg = "-action") 1139 then do; 1140 looking_for = SEVERITY; 1141 end; 1142 1143 else if (arg = "-all_severities") | (arg = "-asv") 1144 then do; 1145 if (pass = DO_CONTROL_ARGS) 1146 then call log_match_$clear_severity (opt.lmd_ptr); 1147 end; 1148 1149 else if (arg = "-expand") | (arg = "-exp") 1150 then do; 1151 looking_for = (0 - EXPAND_TYPE); 1152 opt.expand_sw = "1"b; 1153 end; 1154 else if (arg = "-no_expand") | (arg = "-nexp") 1155 then do; 1156 if (pass = DO_CONTROL_ARGS) 1157 then do; 1158 opt.expand_sw = "0"b; 1159 opt.octal_sw = "0"b; 1160 opt.interpret_sw = "0"b; 1161 end; 1162 end; 1163 1164 else if (arg = "-octal") | (arg = "-oc") 1165 then do; 1166 if (pass = DO_CONTROL_ARGS) 1167 then do; 1168 opt.expand_sw = "1"b; 1169 opt.octal_sw = "1"b; 1170 end; 1171 end; 1172 else if (arg = "-interpret") | (arg = "-int") | (arg = "-it") 1173 then do; 1174 if (pass = DO_CONTROL_ARGS) 1175 then do; 1176 opt.expand_sw = "1"b; 1177 opt.interpret_sw = "1"b; 1178 end; 1179 end; 1180 1181 else if (arg = "-no_process_id") | (arg = "-npid") 1182 then do; 1183 if (pass = DO_CONTROL_ARGS) 1184 then opt.process_id_sw = "0"b; 1185 end; 1186 else if (arg = "-process_id") | (arg = "-pid") 1187 then do; 1188 if (pass = DO_CONTROL_ARGS) 1189 then opt.process_id_sw = "1"b; 1190 end; 1191 1192 else if (arg = "-no_data_class") | (arg = "-ndc") 1193 then do; 1194 if (pass = DO_CONTROL_ARGS) 1195 then opt.data_class_sw = "0"b; 1196 end; 1197 1198 else if (arg = "-data_class") | (arg = "-dc") 1199 then do; 1200 if (pass = DO_CONTROL_ARGS) 1201 then opt.data_class_sw = "1"b; 1202 end; 1203 1204 else if (arg = "-procedure") | (arg = "-proc") 1205 then do; 1206 call get_next_arg (opt.reader_procedure); 1207 end; 1208 1209 else if (arg = "-line_length") | (arg = "-ll") 1210 then do; 1211 call get_next_arg (number_arg); 1212 if (pass = DO_CONTROL_ARGS) 1213 then do; 1214 log_message_format.line_lth = cv_dec_check_ ((number_arg), code); 1215 if (code ^= 0) | (log_message_format.line_lth < 25) 1216 | (log_message_format.line_lth > 500) 1217 then call ssu_$abort_line (sci_ptr, error_table_$bad_conversion, 1218 "Line length must be between 25 and 500, not ^a", number_arg); 1219 1220 call adjust_log_message_format ("Processing -line_length.", arg); 1221 end; 1222 end; /* Of -line_length processing */ 1223 1224 else if (arg = "-output_switch") | (arg = "-osw") 1225 then do; 1226 call get_next_arg (iocb_arg); 1227 if (pass = DO_CONTROL_ARGS) 1228 then do; 1229 call iox_$look_iocb ((iocb_arg), opt.iocb_ptr, code); 1230 if (code ^= 0) 1231 then call ssu_$abort_line (sci_ptr, code, "I/O switch ^a", iocb_arg); 1232 log_message_format.line_lth = get_line_length_$switch (opt.iocb_ptr, code); 1233 if (code ^= 0) 1234 then /* Must reset the line length, also reapply the default */ 1235 log_message_format.line_lth = DEFAULT_LINE_LENGTH; 1236 1237 call adjust_log_message_format ("Setting line length from -output_switch", arg); 1238 end; 1239 end; /* Of -line_length processing */ 1240 1241 else if (arg = "-indent") | (arg = "-ind") | (arg = "-in") 1242 then do; 1243 call get_next_arg (number_arg); 1244 if (pass = DO_CONTROL_ARGS) 1245 then do; 1246 log_message_format.indentation = cv_dec_check_ ((number_arg), code); 1247 if (code ^= 0) | (log_message_format.indentation < 0) 1248 | (log_message_format.indentation > 50) 1249 then call ssu_$abort_line (sci_ptr, error_table_$bad_conversion, 1250 "Indentation must be between 0 and 50, not ^a", number_arg); 1251 1252 call adjust_log_message_format ("Processing -indent", arg); 1253 end; 1254 end; /* Of -indent processing */ 1255 1256 else if (arg = "-continuation_indent") | (arg = "-ci") 1257 then do; 1258 call get_next_arg (number_arg); 1259 if (pass = DO_CONTROL_ARGS) 1260 then do; 1261 if number_arg = "std" | number_arg = "standard" 1262 then log_message_format.continuation_indent = -1; 1263 else do; 1264 log_message_format.continuation_indent = cv_dec_check_ ((number_arg), code); 1265 if (code ^= 0) | (log_message_format.continuation_indent < 0) 1266 | (log_message_format.continuation_indent > 50) 1267 then call ssu_$abort_line (sci_ptr, error_table_$bad_conversion, 1268 "Continuation indent must be between 0 and 50 or ""standard"", not ^a", 1269 number_arg); 1270 end; 1271 call adjust_log_message_format ("Processing -continuation_indent", (number_arg)); 1272 end; 1273 end; /* Of -continuation_indent processing */ 1274 1275 else if (arg = "-prefix") | (arg = "-pfx") 1276 then do; 1277 call get_next_arg (temp_v_string_arg); 1278 if (pass = DO_CONTROL_ARGS) 1279 then do; 1280 opt.prefix_given_sw = "1"b; 1281 log_message_format.prefix = temp_v_string_arg; 1282 call adjust_log_message_format ("Processing -prefix", arg); 1283 end; 1284 end; /* Of -prefix processing */ 1285 1286 1287 else if (arg = "-time_format") | (arg = "-tfmt") 1288 then do; 1289 call get_next_arg (temp_v_string_arg); 1290 if (pass = DO_CONTROL_ARGS) 1291 then do; 1292 log_message_format.time_format = temp_v_string_arg; 1293 call adjust_log_message_format ("Processing -time_format", arg); 1294 end; 1295 end; 1296 1297 else if (arg = "-date_format") | (arg = "-dfmt") 1298 then do; 1299 call get_next_arg (temp_v_string_arg); 1300 if (pass = DO_CONTROL_ARGS) 1301 then do; 1302 log_message_format.date_format = temp_v_string_arg; 1303 call adjust_log_message_format ("Processing -date_format", arg); 1304 end; 1305 end; 1306 else if (arg = "-all") | (arg = "-a") 1307 then do; 1308 if (pass = FIND_LOG) 1309 then do; 1310 if opt.pathname ^= "" 1311 then call two_logs; 1312 opt.all_sw = "1"b; 1313 opt.pathname = ALL_PATH; 1314 end; 1315 end; 1316 else if (arg = "-mc_log") | (arg = "-mcl") 1317 then looking_for = MC_PATHNAME; 1318 else if (arg = "-number_format") | (arg = "-nfmt") 1319 then do; 1320 call get_next_arg (temp_v_string_arg); 1321 if (pass = DO_CONTROL_ARGS) 1322 then do; 1323 log_message_format.number_format = temp_v_string_arg; 1324 call adjust_log_message_format ("Processing -number_format", arg); 1325 end; 1326 end; 1327 1328 else if (arg = "-add") 1329 then if (pass = FIND_LOG) 1330 then opt.add_sw = "1"b; 1331 else ; 1332 else if (arg = "-remove") | (arg = "-rm") 1333 then if (pass = FIND_LOG) 1334 then opt.remove_sw = "1"b; 1335 else ; 1336 else if (arg = "-on") 1337 then if (pass = FIND_LOG) 1338 then opt.on_sw = "1"b; 1339 else ; 1340 else if (arg = "-off") 1341 then if (pass = FIND_LOG) 1342 then opt.off_sw = "1"b; 1343 else ; 1344 1345 else if (arg = "-replace") | (arg = "-rp") 1346 then if (pass = FIND_LOG) 1347 then opt.replace_sw = "1"b; 1348 else ; 1349 1350 else if (arg = "-update") | (arg = "-ud") 1351 then if (pass = FIND_LOG) 1352 then opt.replace_sw = "1"b; 1353 else ; 1354 else if (arg = "-status") | (arg = "-st") 1355 then if (pass = FIND_LOG) 1356 then opt.status_sw = "1"b; 1357 else ; 1358 1359 else if (arg = "-time") | (arg = "-tm") 1360 then do; 1361 call get_next_arg (number_arg); 1362 if (pass = FIND_LOG) 1363 then do; 1364 opt.time = cv_dec_check_ ((number_arg), code); 1365 opt.time_given_sw = "1"b; 1366 if code ^= 0 | opt.time < 1 1367 then call ssu_$abort_line (sci_ptr, error_table_$bad_conversion, 1368 "-time must be followed by a positive number of seconds."); 1369 end; 1370 end; 1371 1372 else if (arg = "-number") | (arg = "-nb") 1373 then do; 1374 call get_next_arg (number_arg); 1375 if (pass = FIND_LOG) 1376 then do; 1377 opt.log_number = cv_dec_check_ ((number_arg), code); 1378 if opt.pathname ^= "" 1379 then call two_logs; 1380 opt.pathname = NUMBER_PATH; 1381 if code ^= 0 | opt.log_number < 1 1382 then call ssu_$abort_line (sci_ptr, error_table_$bad_conversion, 1383 "-number must be followed by a positive number."); 1384 end; 1385 end; 1386 else if (arg = "-syserr") 1387 then do; 1388 if (pass = FIND_LOG) 1389 then do; 1390 opt.pathname = SYSERR_PATH; 1391 opt.the_syserr_log_sw = "1"b; 1392 end; 1393 end; 1394 1395 else if (arg = "-answering_service") | (arg = "-as") 1396 then do; 1397 if (pass = FIND_LOG) 1398 then do; 1399 opt.pathname = AS_PATH; 1400 opt.the_as_log_sw = "1"b; 1401 end; 1402 end; 1403 else if (arg = "-admin") 1404 then do; 1405 if (pass = FIND_LOG) 1406 then do; 1407 opt.pathname = ADMIN_PATH; 1408 opt.the_admin_log_sw = "1"b; 1409 end; 1410 end; 1411 1412 else if (arg = "-dm_system_log") | (arg = "-dms") 1413 then do; 1414 if (pass = FIND_LOG) 1415 then do; 1416 opt.pathname = DM_PATH; 1417 opt.the_dm_log_sw = "1"b; 1418 end; 1419 end; 1420 1421 else if (arg = "-dsa_sys_log") | (arg = "-dsasl") 1422 then do; 1423 if (pass = FIND_LOG) 1424 then do; 1425 opt.pathname = DSA_SL_PATH; 1426 opt.the_dsas_log_sw = "1"b; 1427 end; 1428 end; 1429 1430 else if (arg = "-dsa_sys_aep_log") | (arg = "-dsasal") 1431 then do; 1432 if (pass = FIND_LOG) 1433 then do; 1434 opt.pathname = DSA_SAL_PATH; 1435 opt.the_dsasa_log_sw = "1"b; 1436 end; 1437 end; 1438 1439 else if (arg = "-call") 1440 then do; 1441 opt.call_given_sw = "1"b; 1442 looking_for = CALL_COMMAND; 1443 end; 1444 1445 else if (char (arg, 1) = "-") 1446 then call ssu_$abort_line (sci_ptr, error_table_$badopt, "^a", arg); 1447 1448 else call process_looking_for (); 1449 end; /* of loop through arguments */ 1450 1451 if (pass = FIND_LOG) 1452 then call check_options (); 1453 if (pass = DO_CONTROL_ARGS) 1454 then if opt.expand_sw & ^(opt.octal_sw | opt.interpret_sw) 1455 then opt.interpret_sw = "1"b; /* If neither specified, default is -interpret */ 1456 1457 return; /* End of argument processing */ 1458 1459 1460 process_looking_for: 1461 procedure (); 1462 1463 declare really_looking_for fixed bin; 1464 declare severity1 fixed bin; 1465 declare severity2 fixed bin; 1466 1467 1468 really_looking_for = abs (looking_for); 1469 1470 if (really_looking_for = LOG_PATHNAME) 1471 then do; 1472 if (pass = FIND_LOG) 1473 then do; 1474 if (opt.pathname ^= "") 1475 then call two_logs; 1476 opt.pathname = arg; 1477 end; 1478 end; 1479 1480 else if (really_looking_for = MC_PATHNAME) 1481 then do; 1482 if (pass = FIND_LOG) 1483 then do; 1484 if (opt.pathname ^= "") 1485 then call two_logs; 1486 if search (arg, "<>") > 0 1487 then call ssu_$abort_line (sci_ptr, 0, 1488 "-log must be followed by a log entryname of a log in >sc1>as_logs."); 1489 opt.pathname = pathname_ (MC_LOG_DIR, arg); 1490 end; 1491 end; 1492 1493 else if (really_looking_for = MATCH_STRING) 1494 then if (pass = DO_CONTROL_ARGS) 1495 then call log_match_$add_match (opt.lmd_ptr, arg); 1496 else ; 1497 1498 else if (really_looking_for = EXCLUDE_STRING) 1499 then if (pass = DO_CONTROL_ARGS) 1500 then call log_match_$add_exclude (opt.lmd_ptr, arg); 1501 else ; 1502 1503 else if (really_looking_for = MATCH_DATA_CLASS_STRING) 1504 then if (pass = DO_CONTROL_ARGS) 1505 then call log_match_$add_match_data_class (opt.lmd_ptr, arg); 1506 else ; 1507 1508 else if (really_looking_for = EXCLUDE_DATA_CLASS_STRING) 1509 then if (pass = DO_CONTROL_ARGS) 1510 then call log_match_$add_exclude_data_class (opt.lmd_ptr, arg); 1511 else ; 1512 1513 else if (really_looking_for = MATCH_DATA_STRING) 1514 then if (pass = DO_CONTROL_ARGS) 1515 then call log_match_$add_match_data (opt.lmd_ptr, arg); 1516 else ; 1517 1518 else if (really_looking_for = EXCLUDE_DATA_STRING) 1519 then if (pass = DO_CONTROL_ARGS) 1520 then call log_match_$add_exclude_data (opt.lmd_ptr, arg); 1521 else ; 1522 1523 else if (really_looking_for = SEVERITY) 1524 then do; 1525 if (pass = DO_CONTROL_ARGS) 1526 then do; 1527 severity1 = cv_dec_check_ (before (arg, ":"), code); 1528 if (code ^= 0) 1529 then 1530 INVALID_SEVERITY_RANGE: 1531 call ssu_$abort_line (sci_ptr, error_table_$bad_conversion, 1532 "Invalid severity value ""^a"": must be or :", arg); 1533 1534 if (index (arg, ":") = 0) 1535 then /* Not a range, just a single number */ 1536 severity2 = severity1; 1537 else severity2 = cv_dec_check_ (after (arg, ":"), code); 1538 if (code ^= 0) 1539 then goto INVALID_SEVERITY_RANGE; 1540 1541 call log_match_$add_severity (opt.lmd_ptr, severity1, severity2); 1542 end; 1543 end; 1544 1545 else if (really_looking_for = EXPAND_TYPE) 1546 then do; 1547 if (pass = DO_CONTROL_ARGS) 1548 then do; 1549 call log_expand_select_$add (opt.expand_select_ptr, arg, code); 1550 if (code ^= 0) 1551 then call ssu_$abort_line (sci_ptr, code, "Invalid expansion type/modes: ""^a"".", arg); 1552 end; 1553 end; 1554 else if really_looking_for = CALL_COMMAND 1555 then do; 1556 if (pass = DO_CONTROL_ARGS) 1557 then do; 1558 if opt.call_command.ptr ^= null () 1559 then free opt_call_command_string; 1560 if arg ^= "" 1561 then do; 1562 opt.call_command.ptr = addr (arg); 1563 opt.call_command.length = length (arg); 1564 end; 1565 else do; 1566 opt.call_command.ptr = null (); 1567 opt.call_command.length = 0; 1568 opt.call_given_sw = "0"b; 1569 end; 1570 end; 1571 end; 1572 return; 1573 end process_looking_for; 1574 1575 two_logs: 1576 procedure; 1577 call ssu_$abort_line (sci_ptr, error_table_$too_many_args, 1578 "Only one log may be specified, and ^a is the second.", arg); 1579 return; 1580 end two_logs; 1581 1582 1583 get_next_arg: 1584 procedure (P_option); 1585 1586 declare P_option char (*) varying parameter; 1587 1588 1589 if (arg_idx >= arg_count) 1590 then call ssu_$abort_line (sci_ptr, error_table_$noarg, "Value missing after ^a", arg); 1591 1592 arg_idx = arg_idx + 1; 1593 call ssu_$arg_ptr (sci_ptr, arg_idx, arg_ptr, arg_lth); 1594 1595 P_option = arg; 1596 1597 return; 1598 end get_next_arg; 1599 1600 1601 check_options: 1602 procedure (); 1603 1604 declare action_opt (7) bit (1) unaligned; 1605 1606 if (opt.pathname = "") & ^opt.time_given_sw & ^opt.status_sw 1607 then call ssu_$abort_line (sci_ptr, error_table_$noarg, "^/Usage:^-^a LogPathname {-control_args}", 1608 COMMAND_NAME); 1609 1610 if (looking_for > 0) 1611 then call ssu_$abort_line (sci_ptr, error_table_$noarg, "After ^a", arg); 1612 1613 string (action_opt) = 1614 opt.add_sw || opt.remove_sw || opt.replace_sw || opt.modify_sw || opt.on_sw || opt.off_sw || opt.status_sw; 1615 if sum (bin (action_opt (*), 1)) > 1 1616 then call ssu_$abort_line (sci_ptr, 0, 1617 "Only one of -add, -remove, -replace, -modify, -on, -off, or -status may be given."); 1618 1619 return; 1620 end check_options; 1621 1622 end process_arguments$$find_log_and_action; 1623 1624 1625 adjust_log_message_format: 1626 procedure (P_doing_what, P_doing_it_with); 1627 1628 declare P_doing_what char (*) parameter; 1629 declare P_doing_it_with char (*) parameter; 1630 1631 1632 call format_log_message_$adjust (log_message_format_ptr, code); 1633 if (code = 0) 1634 then /* All OK */ 1635 return; 1636 1637 call ssu_$abort_line (sci_ptr, code, "^a ^a", /* Hope this identifies the source of error correctly */ 1638 P_doing_what, P_doing_it_with); /* There are many possible errors from $adjust */ 1639 1640 end adjust_log_message_format; 1641 1642 /* format: off */ 1643 /* BEGIN INCLUDE FILE ... log_message.incl.pl1 ... 84-04-25 ... W. Olin Sibert */ 1 2 1 3 declare 1 log_message_header aligned based, /* Items marked "(SET)" are set by $create_message */ 1 4 2 sentinel bit (36) aligned, /* Proper value declared in log_segment.incl.pl1 */ 1 5 2 sequence fixed bin (35), /* Sequence number for this message (SET) */ 1 6 2 severity fixed bin (8) unaligned, /* Severity of message */ 1 7 2 data_class_lth fixed bin (9) unaligned unsigned, /* Length of data class-- 0 to 16 (SET) */ 1 8 2 time fixed bin (53) unaligned, /* Time message originated */ 1 9 2 text_lth fixed bin (17) unaligned, /* Length of message text. Must be nonzero (SET) */ 1 10 2 data_lth fixed bin (17) unaligned, /* Length of binary data. May be zero (SET) */ 1 11 2 process_id bit (36) aligned; /* Process id of process writing message */ 1 12 1 13 declare 1 log_message aligned based (log_message_ptr), 1 14 2 header aligned like log_message_header, 1 15 2 text char (log_message_text_lth refer (log_message.text_lth)) unaligned, 1 16 2 data_class char (log_message_data_class_lth refer (log_message.data_class_lth)) unaligned, 1 17 2 data dim (log_message_data_lth refer (log_message.data_lth)) bit (36) aligned; 1 18 1 19 declare log_message_ptr pointer; 1 20 declare log_message_text_lth fixed bin; 1 21 declare log_message_data_class_lth fixed bin; 1 22 declare log_message_data_lth fixed bin; 1 23 1 24 /* END INCLUDE FILE ... log_message.incl.pl1 */ 1643 1644 /* BEGIN INCLUDE FILE ... log_message_format.incl.pl1 ... 84-07-03 ... W. Olin Sibert */ 2 2 2 3 declare 1 log_message_format aligned based (log_message_format_ptr), 2 4 2 caller char (32) unaligned, /* Caller name to use when printing error messages */ 2 5 2 line_lth fixed bin, /* Max length of output lines; longer messages are folded */ 2 6 2 indentation fixed bin, /* Number of spaces at beginning of each output line */ 2 7 2 equal_sw bit (1) aligned, /* Whether to suppress messages with identical text */ 2 8 2 error_sw bit (1) aligned, /* Whether to print error messages via com_err_ */ 2 9 2 prefix char (40) varying, /* Prefix for printing messages */ 2 10 2 number_format char (20) varying, /* ioa_ format for printing message numbers */ 2 11 2 time_format char (40) varying, /* date_time_$format string for message times */ 2 12 2 date_format char (40) varying, /* date_time_$format string for when date changes */ 2 13 2 continuation_indent fixed bin, /* If >= zero, value for continuation lines */ 2 14 /* Otherwise, lined up under the text by default */ 2 15 2 16 2 pad (59) bit (36) aligned, 2 17 2 18 /* ONLY format_log_message_$adjust ever changes the values below */ 2 19 2 20 2 internal_info aligned, /* Internal info, set by $adjust-- DO NOT CHANGE */ 2 21 3 area_ptr pointer, /* Where this structure is allocated */ 2 22 3 date_ioa_string char (100) varying, /* Format for date breaks,if any */ 2 23 3 message_ioa_string char (100) varying, /* Format for first lines of messages */ 2 24 3 real_continuation_indent fixed bin, /* Indentation for continuation lines */ 2 25 3 prefix_lth fixed bin, /* Length of indent + prefix + time + sequence + severity */ 2 26 3 date_modulus fixed bin (36), /* Modulus for checking whether dates are equal */ 2 27 2 28 2 end fixed bin; 2 29 2 30 declare log_message_format_ptr pointer; 2 31 2 32 /* END INCLUDE FILE ... log_message_format.incl.pl1 */ 1644 1645 /* Begin include file log_read_open_data.incl.pl1 BIM 1984-12-15 */ 3 2 /* Use this with log_read_$open_long to specify special purpose options */ 3 3 3 4 declare log_read_open_info_ptr pointer; 3 5 declare 1 log_read_open_info aligned based (log_read_open_info_ptr), 3 6 2 version char (8) aligned, 3 7 2 reader_procedure char (32) varying, /* this is an outer ring opening, and this procedure retrieves from the inner ring */ 3 8 2 allocation_area_ptr pointer, /* if reader_procedure is not "", */ 3 9 /* this is passed to it to for allocation */ 3 10 2 allocate_copies bit (1) aligned; /* incompatable with reader_procedure ^= "" */ 3 11 /* indicates that this opening must allocate copies for use by an outer ring */ 3 12 3 13 declare LOG_READ_OPEN_INFO_VERSION_1 3 14 char (8) init ("logro001") int static options (constant); 3 15 3 16 /* End include file log_read_open_info.incl.pl1 */ 1645 1646 /* Begin include file monitor_sys_log_info_.incl.pl1 */ 4 2 4 3 /****^ HISTORY COMMENTS: 4 4* 1) change(86-08-01,Ex), approve(86-08-01,MCR7456), audit(86-08-01,Wong), 4 5* install(86-11-03,MR12.0-1149): 4 6* Changed by Rick Kissel to support DSA System and system aep logs, using 4 7* the -dsasl and -dsasal control arguments. 4 8* END HISTORY COMMENTS */ 4 9 4 10 /* format: style3,idind30 */ 4 11 4 12 /***************************************************************************** 4 13* * This include file declares the monitor_sys_log_data and * 4 14* * monitor_sys_log_array structures used by monitor_sys_log as part of the * 4 15* * logging tools. * 4 16* *****************************************************************************/ 4 17 4 18 4 19 declare 1 monitor_sys_log_data_ external static, 4 20 2 initialized bit (1) init ("0"b), 4 21 2 active bit (1) init ("0"b),/* timer manager is turned on */ 4 22 2 wakeup_interval fixed bin (71) init (10), 4 23 /* seconds */ 4 24 2 n_logs fixed bin init (0), 4 25 2 n_logs_on_timer fixed bin init (0), 4 26 2 wakeup_event_channel fixed bin (71) init (0), 4 27 2 log_array_ptr pointer init (null ()); 4 28 4 29 declare monitor_sys_log_array_ptr pointer; 4 30 declare 1 monitor_sys_log_array aligned based (monitor_sys_log_array_ptr), 4 31 2 n_entries fixed bin, 4 32 2 entry (msl_n_entries refer (monitor_sys_log_array.n_entries)) aligned, 4 33 3 dir_name char (168) unal, 4 34 3 entryname char (32) unal, 4 35 3 log_read_ptr pointer, 4 36 3 the_syserr_log bit (1) aligned, 4 37 3 the_as_log bit (1) aligned, 4 38 3 the_admin_log bit (1) aligned, 4 39 3 the_dm_log bit (1) aligned, 4 40 3 the_dsas_log bit (1) aligned, 4 41 3 the_dsasa_log bit (1) aligned, 4 42 3 inhibited bit (1) aligned, /* -off in effect */ 4 43 3 interpret_sw bit (1) aligned, 4 44 3 octal_sw bit (1) aligned, 4 45 3 registered bit (1) aligned, /* don't look kere on the timer */ 4 46 3 data_class_sw bit (1) aligned, /* print data class */ 4 47 3 process_id_sw bit (1) aligned, /* print process id */ 4 48 3 expand_select_ptr pointer, /* expansion */ 4 49 3 lmd_ptr pointer, /* selection */ 4 50 3 iocb_ptr pointer, /* print here */ 4 51 3 format_ptr pointer, /* format like this */ 4 52 3 last_sequence fixed bin (35), 4 53 3 last_message_ptr pointer, /* the last one we read */ 4 54 3 prev_message_ptr pointer, /* the one before that */ 4 55 3 registered_wakeup_event_channel 4 56 fixed bin (71), 4 57 3 call_command aligned, 4 58 4 ptr pointer, 4 59 4 length fixed bin (21); 4 60 4 61 declare msl_n_entries fixed bin; 4 62 4 63 /* End include file monitor_sys_log_info_.incl.pl1 */ 1646 5 1 /* BEGIN INCLUDE FILE sub_err_flags.incl.pl1 BIM 11/81 */ 5 2 /* format: style3 */ 5 3 5 4 /* These constants are to be used for the flags argument of sub_err_ */ 5 5 /* They are just "string (condition_info_header.action_flags)" */ 5 6 5 7 declare ( 5 8 ACTION_CAN_RESTART init (""b), 5 9 ACTION_CANT_RESTART init ("1"b), 5 10 ACTION_DEFAULT_RESTART 5 11 init ("01"b), 5 12 ACTION_QUIET_RESTART 5 13 init ("001"b), 5 14 ACTION_SUPPORT_SIGNAL 5 15 init ("0001"b) 5 16 ) bit (36) aligned internal static options (constant); 5 17 5 18 /* End include file */ 1647 1648 end monitor_sys_log; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/03/86 0951.3 monitor_sys_log.pl1 >spec>install>1149>monitor_sys_log.pl1 1643 1 01/21/85 0912.2 log_message.incl.pl1 >ldd>include>log_message.incl.pl1 1644 2 01/21/85 0912.2 log_message_format.incl.pl1 >ldd>include>log_message_format.incl.pl1 1645 3 01/21/85 0912.3 log_read_open_info.incl.pl1 >ldd>include>log_read_open_info.incl.pl1 1646 4 11/03/86 0911.9 monitor_sys_log_info_.incl.pl1 >spec>install>1149>monitor_sys_log_info_.incl.pl1 1647 5 04/16/82 0958.1 sub_err_flags.incl.pl1 >ldd>include>sub_err_flags.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. ACTION_CANT_RESTART 000254 constant bit(36) initial dcl 5-7 set ref 284* 322* 327* ADMIN_PATH 000113 constant char(10) initial unaligned dcl 202 ref 802 1407 ALL_PATH 000077 constant char(10) initial unaligned dcl 206 ref 1313 AS_PATH 000116 constant char(10) initial unaligned dcl 201 ref 796 1399 CALL_COMMAND constant fixed bin(17,0) initial dcl 1058 ref 1442 1554 COMMAND_NAME 000124 constant char(32) initial unaligned dcl 199 set ref 227* 230* 284* 322* 327* 1019 1606* DEFAULT_LINE_LENGTH constant fixed bin(17,0) initial dcl 212 ref 1023 1233 DM_PATH 000110 constant char(10) initial unaligned dcl 203 ref 808 1416 DM_READER_PROCEDURE 000012 constant char(32) initial unaligned dcl 218 ref 813 DO_CONTROL_ARGS constant fixed bin(17,0) initial dcl 1050 ref 1073 1116 1123 1131 1145 1156 1166 1174 1183 1188 1194 1200 1212 1227 1244 1259 1278 1290 1300 1321 1453 1493 1498 1503 1508 1513 1518 1525 1547 1556 DSA_READER_PROCEDURE 000002 constant char(32) initial unaligned dcl 219 set ref 820* 824* 827* 839 846* 850* 853* 866 DSA_SAL_PATH 000102 constant char(10) initial unaligned dcl 205 ref 841 1434 DSA_SL_PATH 000105 constant char(10) initial unaligned dcl 204 ref 815 1425 EXCLUDE_DATA_CLASS_STRING constant fixed bin(17,0) initial dcl 1063 ref 1104 1508 EXCLUDE_DATA_STRING constant fixed bin(17,0) initial dcl 1056 ref 1112 1518 EXCLUDE_STRING constant fixed bin(17,0) initial dcl 1054 ref 1095 1498 EXPAND_TYPE constant fixed bin(17,0) initial dcl 1059 ref 1151 1545 FIND_LOG constant fixed bin(17,0) initial dcl 1049 ref 1067 1308 1328 1332 1336 1340 1345 1350 1354 1362 1375 1388 1397 1405 1414 1423 1432 1451 1472 1482 LOG_PATHNAME constant fixed bin(17,0) initial dcl 1052 ref 1078 1470 LOG_READ_OPEN_INFO_VERSION_1 000000 constant char(8) initial unaligned dcl 3-13 ref 882 MATCH_DATA_CLASS_STRING constant fixed bin(17,0) initial dcl 1061 ref 1100 1503 MATCH_DATA_STRING constant fixed bin(17,0) initial dcl 1055 ref 1108 1513 MATCH_STRING constant fixed bin(17,0) initial dcl 1053 ref 1091 1493 MC_LOG_DIR 000022 constant char(168) initial unaligned dcl 210 set ref 1489* MC_PATHNAME constant fixed bin(17,0) initial dcl 1060 ref 1316 1480 NUMBER_PATH 000074 constant char(10) initial unaligned dcl 207 ref 786 1380 P_doing_it_with parameter char unaligned dcl 1629 set ref 1625 1637* P_doing_what parameter char unaligned dcl 1628 set ref 1625 1637* P_option parameter varying char dcl 1586 set ref 1583 1595* SEVERITY constant fixed bin(17,0) initial dcl 1057 ref 1140 1523 SYSERR_PATH 000121 constant char(10) initial unaligned dcl 200 ref 789 1390 abs builtin function dcl 215 ref 1468 action_opt 001046 automatic bit(1) array unaligned dcl 1604 set ref 1613* 1615 active 0(01) 000214 external static bit(1) initial level 2 packed unaligned dcl 4-19 set ref 313 315* 331* add_sw 125 000336 automatic bit(1) level 3 dcl 43 set ref 360 361 375 387* 404* 406 408 411 709 750 765 1328* 1613 addr builtin function dcl 215 ref 448 455 568 692 887 887 1562 after builtin function dcl 215 ref 1537 1537 all_sw 121 000336 automatic bit(1) level 3 dcl 43 set ref 362 784 1312* allocate_copies 16 000312 automatic bit(1) level 2 dcl 38 set ref 886* allocation_area_ptr 14 000312 automatic pointer level 2 dcl 38 set ref 884* already_monitored 000522 automatic bit(1) dcl 356 set ref 373* 375 379 384 an_entry based structure level 1 dcl 31 set ref 962* an_entry_ptr 000100 automatic pointer dcl 30 set ref 394 395 396 397 432* 448* 455* 456 458 460 462 464 466 468 482 482 482 482 482 482 493 493 493 494 568* 569 578 578 578 578 578 578 578 578 578 578 582 583 585 585 587 587 590 597 597 599 600 600 609 609 611 611 611 613 614 614 615 618 618 619 620 621 621 630 644 648 649 649 651 651 653 653 655 655 657 660 660 660 692* 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 749 752 754 755 760 761 761 761 762 762 768 962 any_other 000000 stack reference condition dcl 196 ref 637 646 677 697 944 955 arg based char unaligned dcl 1036 set ref 1089 1089 1093 1093 1098 1098 1102 1102 1106 1106 1110 1110 1114 1114 1121 1121 1129 1129 1138 1138 1138 1143 1143 1149 1149 1154 1154 1164 1164 1172 1172 1172 1181 1181 1186 1186 1192 1192 1198 1198 1204 1204 1209 1209 1220* 1224 1224 1237* 1241 1241 1241 1252* 1256 1256 1275 1275 1282* 1287 1287 1293* 1297 1297 1303* 1306 1306 1316 1316 1318 1318 1324* 1328 1332 1332 1336 1340 1345 1345 1350 1350 1354 1354 1359 1359 1372 1372 1386 1395 1395 1403 1412 1412 1421 1421 1430 1430 1439 1445 1445* 1476 1486 1489* 1493* 1498* 1503* 1508* 1513* 1518* 1527 1527 1528* 1534 1537 1537 1549* 1550* 1560 1562 1563 1577* 1589* 1595 1610* arg_count 000702 automatic fixed bin(17,0) dcl 1039 set ref 1075* 1080 1589 arg_idx 000703 automatic fixed bin(17,0) dcl 1040 set ref 1080* 1081* 1589 1592* 1592 1593* arg_lth 000676 automatic fixed bin(21,0) dcl 1037 set ref 1081* 1089 1089 1093 1093 1098 1098 1102 1102 1106 1106 1110 1110 1114 1114 1121 1121 1129 1129 1138 1138 1138 1143 1143 1149 1149 1154 1154 1164 1164 1172 1172 1172 1181 1181 1186 1186 1192 1192 1198 1198 1204 1204 1209 1209 1220 1220 1224 1224 1237 1237 1241 1241 1241 1252 1252 1256 1256 1275 1275 1282 1282 1287 1287 1293 1293 1297 1297 1303 1303 1306 1306 1316 1316 1318 1318 1324 1324 1328 1332 1332 1336 1340 1345 1345 1350 1350 1354 1354 1359 1359 1372 1372 1386 1395 1395 1403 1412 1412 1421 1421 1430 1430 1439 1445 1445 1445 1476 1486 1489 1489 1493 1493 1498 1498 1503 1503 1508 1508 1513 1513 1518 1518 1527 1527 1528 1528 1534 1537 1537 1549 1549 1550 1550 1560 1562 1563 1577 1577 1589 1589 1593* 1595 1610 1610 arg_ptr 000700 automatic pointer dcl 1038 set ref 1081* 1089 1089 1093 1093 1098 1098 1102 1102 1106 1106 1110 1110 1114 1114 1121 1121 1129 1129 1138 1138 1138 1143 1143 1149 1149 1154 1154 1164 1164 1172 1172 1172 1181 1181 1186 1186 1192 1192 1198 1198 1204 1204 1209 1209 1220 1224 1224 1237 1241 1241 1241 1252 1256 1256 1275 1275 1282 1287 1287 1293 1297 1297 1303 1306 1306 1316 1316 1318 1318 1324 1328 1332 1332 1336 1340 1345 1345 1350 1350 1354 1354 1359 1359 1372 1372 1386 1395 1395 1403 1412 1412 1421 1421 1430 1430 1439 1445 1445 1476 1486 1489 1493 1498 1503 1508 1513 1518 1527 1527 1528 1534 1537 1537 1549 1550 1560 1562 1563 1577 1589 1593* 1595 1610 before builtin function dcl 215 ref 1527 1527 call_command 120 000100 automatic structure level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" call_command 104 000336 automatic structure level 2 in structure "opt" dcl 43 in procedure "monitor_sys_log" call_command 120 based structure level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" call_command_string based char unaligned dcl 659 ref 660 call_given_sw 136 000336 automatic bit(1) level 3 dcl 43 set ref 757 1441* 1568* caller based char(32) level 2 packed unaligned dcl 2-3 set ref 1019* char builtin function dcl 215 ref 1445 check_gate_access_ 000040 constant entry external dcl 113 ref 820 846 cleanup 000500 stack reference condition dcl 197 ref 224 638 646 678 697 945 955 code 000102 automatic fixed bin(35,0) dcl 32 set ref 227* 228 230* 321* 322 322* 325* 327 327* 489* 491 493* 494* 495 614* 615 615* 820* 822 824 824* 827 827* 832* 834 834* 846* 848 850 850* 853 853* 858* 861 861* 869* 870 870* 887* 889* 891 891* 904* 905 905 905* 1022* 1023 1214* 1215 1229* 1230 1230* 1232* 1233 1246* 1247 1264* 1265 1364* 1366 1377* 1381 1527* 1528 1537* 1538 1549* 1550 1550* 1632* 1633 1637* com_err_ 000042 constant entry external dcl 114 ref 230 continuation_indent 63 based fixed bin(17,0) level 2 dcl 2-3 set ref 1018* 1261* 1264* 1265 1265 continue_to_signal_ 000044 constant entry external dcl 116 ref 279 copy_of_call_command based char unaligned dcl 759 set ref 761 762* cu_$arg_list_ptr 000050 constant entry external dcl 119 ref 227 227 cv_dec_check_ 000046 constant entry external dcl 117 ref 1214 1246 1264 1364 1377 1527 1537 data_class_sw 141 000336 automatic bit(1) level 3 in structure "opt" dcl 43 in procedure "monitor_sys_log" set ref 747 1194* 1200* data_class_sw 76 based bit(1) level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 747* date_format 50 based varying char(40) level 2 dcl 2-3 set ref 1302* dir_name 2 based char(168) array level 3 in structure "monitor_sys_log_array" packed unaligned dcl 4-30 in procedure "monitor_sys_log" set ref 445 686 dir_name 000100 automatic char(168) level 2 in structure "init_entry" packed unaligned dcl 917 in procedure "initialize_data" set ref 968* dir_name based char(168) level 2 in structure "an_entry" packed unaligned dcl 31 in procedure "monitor_sys_log" set ref 456 569 578* 578* 644* 730* dm_misc_util_$get_log_path 000052 constant entry external dcl 120 ref 810 dm_system_log_path 000103 automatic char(168) unaligned dcl 33 set ref 810* 811* 812 dsa_nit_$get_field 000054 constant entry external dcl 122 ref 832 858 dsa_system_log_path 000155 automatic char(168) unaligned dcl 34 set ref 832* 837* 838 858* 864* 865 entry 2 based structure array level 2 dcl 4-30 set ref 448 455 568 692 926* 937* 939* 939 entryname 52 based char(32) level 2 in structure "an_entry" packed unaligned dcl 31 in procedure "monitor_sys_log" set ref 578* 578* 597* 609* 615* 731* entryname 52 000100 automatic char(32) level 2 in structure "init_entry" packed unaligned dcl 917 in procedure "initialize_data" set ref 969* equal_sw 12 based bit(1) level 2 dcl 2-3 set ref 1020* error_table_$bad_arg 000012 external static fixed bin(35,0) dcl 88 set ref 822* 848* error_table_$bad_conversion 000020 external static fixed bin(35,0) dcl 97 set ref 1215* 1247* 1265* 1366* 1381* 1528* error_table_$badopt 000016 external static fixed bin(35,0) dcl 96 set ref 1445* error_table_$moderr 000022 external static fixed bin(35,0) dcl 99 ref 824 850 error_table_$no_log_message 000032 external static fixed bin(35,0) dcl 104 ref 905 error_table_$noarg 000024 external static fixed bin(35,0) dcl 100 set ref 1589* 1606* 1610* error_table_$noentry 000026 external static fixed bin(35,0) dcl 101 ref 822 848 error_table_$too_many_args 000030 external static fixed bin(35,0) dcl 102 set ref 1577* error_table_$unexpected_condition 000014 external static fixed bin(35,0) dcl 94 set ref 284* expand_pathname_ 000056 constant entry external dcl 123 ref 811 837 864 869 expand_select_ptr 100 based pointer level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 394 585 585* 649 649* 741* expand_select_ptr 54 000336 automatic pointer level 3 in structure "opt" dcl 43 in procedure "monitor_sys_log" set ref 394* 741 1549* expand_select_ptr 100 000100 automatic pointer level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 979* expand_sw 122 000336 automatic bit(1) level 3 dcl 43 set ref 1152* 1158* 1168* 1176* 1453 explicit_action 000523 automatic bit(1) dcl 357 set ref 360* 361 384 explicit_modification 000524 automatic bit(1) dcl 358 set ref 361* 364 379 flags 113 000336 automatic structure level 2 dcl 43 format_log_message_$adjust 000062 constant entry external dcl 126 ref 1632 format_log_message_$free 000064 constant entry external dcl 128 ref 301 653 format_log_message_$init 000060 constant entry external dcl 124 ref 1017 format_ptr 106 based pointer level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 396 653 653* 749* format_ptr 106 000100 automatic pointer level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 983* free_from_opt 137 000336 automatic bit(1) level 3 dcl 43 set ref 293 393* 1004* get_line_length_$switch 000066 constant entry external dcl 130 ref 1022 1232 get_system_free_area_ 000070 constant entry external dcl 132 ref 761 884 923 935 hcs_$reset_ips_mask 000074 constant entry external dcl 135 ref 282 640 645 680 696 947 954 hcs_$set_ips_mask 000072 constant entry external dcl 134 ref 643 683 950 header based structure level 2 dcl 1-13 indentation 11 based fixed bin(17,0) level 2 dcl 2-3 set ref 1246* 1247 1247 index builtin function dcl 215 ref 1534 inhibited 72 000100 automatic bit(1) level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 978* inhibited 72 based bit(1) level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 583 597 599* 609 620* 740* init_entry 000100 automatic structure level 1 dcl 917 set ref 926 937 962 initialized 000214 external static bit(1) initial level 2 packed unaligned dcl 4-19 set ref 283* 434 437 510 671 928* interpret_sw 73 based bit(1) level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 745* interpret_sw 73 000100 automatic bit(1) level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 980* interpret_sw 124 000336 automatic bit(1) level 3 in structure "opt" dcl 43 in procedure "monitor_sys_log" set ref 745 1160* 1177* 1453 1453* ioa_ 000076 constant entry external dcl 136 ref 512 528 578 582 583 590 iocb_arg 000713 automatic varying char(32) dcl 1045 set ref 1226* 1229 1230* iocb_ptr 104 based pointer level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 743* iocb_ptr 60 000336 automatic pointer level 3 in structure "opt" dcl 43 in procedure "monitor_sys_log" set ref 743 1006* 1022* 1229* 1232* iocb_ptr 104 000100 automatic pointer level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 984* iox_$look_iocb 000100 constant entry external dcl 137 ref 1229 iox_$user_output 000010 external static pointer dcl 87 set ref 585* 587* 1006 ipc_$create_ev_chn 000102 constant entry external dcl 138 ref 321 ipc_$cutoff 000110 constant entry external dcl 142 ref 600 ipc_$decl_event_call_chn 000104 constant entry external dcl 139 ref 325 ipc_$delete_ev_chn 000106 constant entry external dcl 141 ref 655 ipc_$reconnect 000112 constant entry external dcl 143 ref 621 last_message_ptr 112 based pointer level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 493* 611* 613* 614* 618 754* last_message_ptr 112 000100 automatic pointer level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 988* last_msg_ptr parameter pointer dcl 901 set ref 897 903* 904* 908 910 last_seq parameter fixed bin(35,0) dcl 900 set ref 897 908* 910* last_sequence 110 based fixed bin(35,0) level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 493* 590* 611* 618* 752* last_sequence 110 000100 automatic fixed bin(35,0) level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 987* length builtin function dcl 215 in procedure "monitor_sys_log" ref 1563 length 106 000336 automatic fixed bin(21,0) level 3 in structure "opt" dcl 43 in procedure "monitor_sys_log" set ref 760 762 1008* 1558 1558 1563* 1567* length 122 based fixed bin(21,0) level 3 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 660 660 760* 761 761 762 length 122 000100 automatic fixed bin(21,0) level 3 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 986* line_lth 10 based fixed bin(17,0) level 2 dcl 2-3 set ref 1022* 1023* 1214* 1215 1215 1232* 1233* lmd_ptr 102 000100 automatic pointer level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 982* lmd_ptr 56 000336 automatic pointer level 3 in structure "opt" dcl 43 in procedure "monitor_sys_log" set ref 295 295* 395* 742 1118* 1125* 1133* 1145* 1493* 1498* 1503* 1508* 1513* 1518* 1541* lmd_ptr 102 based pointer level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 395 587 587* 651 651* 742* log_array_ptr 10 000214 external static pointer initial level 2 dcl 4-19 set ref 434 437 555 927* 951* log_data_$syserr_log_dir 000036 external static char(168) unaligned dcl 110 ref 791 log_data_$syserr_log_name 000034 external static char(32) unaligned dcl 108 ref 792 log_dname 000230 automatic char(168) unaligned dcl 36 set ref 730 791* 793* 798* 800* 804* 806* 811* 837* 864* 869* 887* 889* log_ename 000302 automatic char(32) unaligned dcl 37 set ref 726 731 792* 793* 799* 800* 805* 806* 811* 837* 864* 869* 887* 889* log_expand_select_$add 000114 constant entry external dcl 144 ref 1549 log_expand_select_$free 000116 constant entry external dcl 145 ref 649 log_expand_select_$print 000120 constant entry external dcl 147 ref 585 log_index 000227 automatic fixed bin(17,0) dcl 35 set ref 373 401 431* 447* 448 454* 455* 473* 567* 568* 578* 685* 686* 692 941* log_last_message_ptr 000630 automatic pointer dcl 707 set ref 709* 754 log_last_sequence 000626 automatic fixed bin(35,0) dcl 706 set ref 709* 752 log_match_$add_exclude 000124 constant entry external dcl 151 ref 1498 log_match_$add_exclude_data 000130 constant entry external dcl 154 ref 1518 log_match_$add_exclude_data_class 000140 constant entry external dcl 162 ref 1508 log_match_$add_match 000122 constant entry external dcl 150 ref 1493 log_match_$add_match_data 000126 constant entry external dcl 152 ref 1513 log_match_$add_match_data_class 000136 constant entry external dcl 160 ref 1503 log_match_$add_severity 000144 constant entry external dcl 166 ref 1541 log_match_$clear_data_class_strings 000142 constant entry external dcl 164 ref 1133 log_match_$clear_data_strings 000134 constant entry external dcl 158 ref 1125 log_match_$clear_severity 000146 constant entry external dcl 168 ref 1145 log_match_$clear_text_strings 000132 constant entry external dcl 156 ref 1118 log_match_$free 000150 constant entry external dcl 170 ref 295 651 log_match_$print 000152 constant entry external dcl 171 ref 587 log_message based structure level 1 dcl 1-13 log_message_format based structure level 1 dcl 2-3 log_message_format_ptr 000506 automatic pointer dcl 2-30 set ref 301 301* 396* 714 716 718 720 722 724 726 727 749 1009* 1017* 1018 1019 1020 1022 1023 1214 1215 1215 1232 1233 1246 1247 1247 1261 1264 1265 1265 1281 1292 1302 1323 1632* log_message_header based structure level 1 dcl 1-3 log_number 112 000336 automatic fixed bin(17,0) level 2 dcl 43 set ref 441 443 445 447 1377* 1381 log_open_info 000312 automatic structure level 1 dcl 38 set ref 887 887 log_read_$close 000162 constant entry external dcl 175 ref 298 490 648 log_read_$get_log_uid 000166 constant entry external dcl 177 ref 489 494 log_read_$open 000154 constant entry external dcl 172 ref 889 log_read_$open_long 000156 constant entry external dcl 173 ref 887 log_read_$prev_message 000164 constant entry external dcl 176 ref 614 904 log_read_$update 000160 constant entry external dcl 174 ref 493 611 log_read_open_info based structure level 1 dcl 3-5 log_read_ptr 62 000100 automatic pointer level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 970* log_read_ptr 52 000336 automatic pointer level 3 in structure "opt" dcl 43 in procedure "monitor_sys_log" set ref 298 298* 397* 487 488* 732 887* 889* 904* log_read_ptr 62 based pointer level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 397 493* 494* 611* 614* 648* 732* looking_for 000704 automatic fixed bin(17,0) dcl 1042 set ref 1078* 1083 1086* 1086 1091* 1095* 1100* 1104* 1108* 1112* 1140* 1151* 1316* 1442* 1468 1610 modify_sw 133 000336 automatic bit(1) level 3 dcl 43 set ref 360 379* 384* 391 408 1613 monitor_sys_log_array based structure level 1 dcl 4-30 set ref 923 935 952 monitor_sys_log_array_ptr 000510 automatic pointer dcl 4-29 set ref 434* 443 445 448 454 455 555* 567 568 685 686 692 923* 926 927 934 938 939 952 953* monitor_sys_log_data_ 000214 external static structure level 1 unaligned dcl 4-19 monitor_sys_log_wakeup_$timer 000170 constant entry external dcl 178 ref 325 325 msl_n_entries 000512 automatic fixed bin(17,0) dcl 4-61 set ref 922* 923 923 934* 935 935 n_entries based fixed bin(17,0) level 2 dcl 4-30 set ref 443 454 567 685 923* 926 934 935* 937 938 952 n_logs 4 000214 external static fixed bin(17,0) initial level 2 dcl 4-19 set ref 437 510 516 518 522 528* 528 560 563 634* 634 767* 767 n_logs_on_timer 5 000214 external static fixed bin(17,0) initial level 2 dcl 4-19 set ref 317 518 522 524 528* 633* 633 770* 770 771 new_array_ptr 000224 automatic pointer dcl 919 set ref 935* 937 939 951 953 new_uid 000544 automatic bit(36) dcl 479 set ref 489* 497 null builtin function dcl 215 ref 284 284 295 298 301 304 322 322 325 325 327 327 432 437 488 585 587 613 619 649 651 653 657 755 820 820 846 846 903 908 970 979 982 983 984 985 988 989 1003 1007 1009 1558 1566 number_arg 000705 automatic varying char(20) dcl 1044 set ref 1211* 1214 1215* 1243* 1246 1247* 1258* 1261 1261 1264 1265* 1271 1361* 1364 1374* 1377 number_format 27 based varying char(20) level 2 dcl 2-3 set ref 1323* octal_sw 74 000100 automatic bit(1) level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 981* octal_sw 74 based bit(1) level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 744* octal_sw 123 000336 automatic bit(1) level 3 in structure "opt" dcl 43 in procedure "monitor_sys_log" set ref 744 1159* 1169* 1453 off_sw 130 000336 automatic bit(1) level 3 dcl 43 set ref 360 379* 542 1340* 1613 old_mask 000334 automatic bit(36) dcl 40 set ref 279 282* 282* 636* 640 640* 640* 643* 645* 645* 676* 680 680* 680* 683* 696* 696* 943* 947 947* 947* 950* 954* 954* old_uid 000545 automatic bit(36) dcl 479 set ref 494* 497 on_sw 127 000336 automatic bit(1) level 3 dcl 43 set ref 360 379* 544 1336* 1613 opt 000336 automatic structure level 1 dcl 43 set ref 1002* opt_call_command_string based char unaligned dcl 84 ref 762 1558 pass 001007 automatic fixed bin(17,0) dcl 1047 set ref 1067* 1073* 1116 1123 1131 1145 1156 1166 1174 1183 1188 1194 1200 1212 1227 1244 1259 1278 1290 1300 1308 1321 1328 1332 1336 1340 1345 1350 1354 1362 1375 1388 1397 1405 1414 1423 1432 1451 1453 1472 1482 1493 1498 1503 1508 1513 1518 1525 1547 1556 pathname 000336 automatic char(168) level 2 packed unaligned dcl 43 set ref 244 375* 379* 786 789 793* 796 800* 802 806* 808 812* 815 838* 841 865* 869* 870* 891* 905* 1005* 1310 1313* 1378 1380* 1390* 1399* 1407* 1416* 1425* 1434* 1474 1476* 1484 1489* 1606 pathname_ 000172 constant entry external dcl 181 ref 578 578 793 800 806 1489 pointers 52 000336 automatic structure level 2 dcl 43 set ref 1003* prefix 14 based varying char(40) level 2 dcl 2-3 set ref 714* 716* 718* 720* 722* 724* 726* 727 1281* prefix_given_sw 135 000336 automatic bit(1) level 3 dcl 43 set ref 712 1280* prev_message_ptr 114 based pointer level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 619* 755* prev_message_ptr 114 000100 automatic pointer level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 989* process_id_sw 140 000336 automatic bit(1) level 3 in structure "opt" dcl 43 in procedure "monitor_sys_log" set ref 746 1183* 1188* process_id_sw 77 based bit(1) level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 746* ptr 120 based pointer level 3 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 657 660 761* 762 ptr 120 000100 automatic pointer level 3 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 985* ptr 104 000336 automatic pointer level 3 in structure "opt" dcl 43 in procedure "monitor_sys_log" set ref 762 1007* 1558 1558 1562* 1566* reader_procedure 62 000336 automatic varying char(32) level 2 in structure "opt" dcl 43 in procedure "monitor_sys_log" set ref 813* 839* 866* 880 883 1010* 1206* reader_procedure 2 000312 automatic varying char(32) level 2 in structure "log_open_info" dcl 38 in procedure "monitor_sys_log" set ref 883* really_looking_for 001020 automatic fixed bin(17,0) dcl 1463 set ref 1468* 1470 1480 1493 1498 1503 1508 1513 1518 1523 1545 1554 registered 75 000100 automatic bit(1) level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 977* registered 75 based bit(1) level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 582 600 621 630 739* 768 registered_wakeup_event_channel 116 000100 automatic fixed bin(71,0) level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 990* registered_wakeup_event_channel 116 based fixed bin(71,0) level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 600* 621* 655 655* remove_sw 126 000336 automatic bit(1) level 3 dcl 43 set ref 360 379* 546 1332* 1613 replace_sw 132 000336 automatic bit(1) level 3 dcl 43 set ref 379* 399 403* 1345* 1350* 1613 sci_ptr 000332 automatic pointer dcl 39 set ref 227* 251* 304 304* 364* 375* 379* 563* 597* 609* 615* 822* 824* 827* 834* 848* 850* 853* 861* 870* 891* 905* 1075* 1081* 1215* 1230* 1247* 1265* 1366* 1381* 1445* 1486* 1528* 1550* 1577* 1589* 1593* 1606* 1610* 1615* 1637* select_timer 000556 automatic fixed bin(17,0) dcl 508 set ref 516* 518* 521* 522* 524* 526* 528* sequence 1 based fixed bin(35,0) level 3 dcl 1-13 ref 618 910 severity1 001021 automatic fixed bin(17,0) dcl 1464 set ref 1527* 1534 1541* severity2 001022 automatic fixed bin(17,0) dcl 1465 set ref 1534* 1537* 1541* ssu_$abort_line 000206 constant entry external dcl 190 ref 364 375 379 563 597 609 615 822 824 827 834 848 850 853 861 870 891 905 1215 1230 1247 1265 1366 1381 1445 1486 1528 1550 1577 1589 1606 1610 1615 1637 ssu_$arg_count 000176 constant entry external dcl 184 ref 1075 ssu_$arg_ptr 000204 constant entry external dcl 189 ref 1081 1593 ssu_$destroy_invocation 000202 constant entry external dcl 187 ref 251 304 ssu_$standalone_invocation 000200 constant entry external dcl 185 ref 227 status_sw 131 000336 automatic bit(1) level 3 dcl 43 set ref 244 360 379* 540 557 1354* 1606 1613 sub_err_ 000174 constant entry external dcl 183 ref 284 322 327 substr builtin function dcl 215 ref 279 640 680 947 system_area based area(1024) dcl 133 ref 761 923 935 temp_opening 000546 automatic pointer dcl 480 set ref 487* 489* 490* temp_v_string_arg 000724 automatic varying char(200) dcl 1046 set ref 1277* 1281 1289* 1292 1299* 1302 1320* 1323 the_admin_log 66 000100 automatic bit(1) level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 973* the_admin_log 66 based bit(1) level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 462 482 578* 735* the_admin_log_sw 115 000336 automatic bit(1) level 3 dcl 43 set ref 462 718 735 1408* the_as_log 65 based bit(1) level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 460 482 578* 734* the_as_log 65 000100 automatic bit(1) level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 972* the_as_log_sw 114 000336 automatic bit(1) level 3 dcl 43 set ref 460 716 734 1400* the_dm_log 67 000100 automatic bit(1) level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 974* the_dm_log 67 based bit(1) level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 464 482 578* 736* the_dm_log_sw 116 000336 automatic bit(1) level 3 dcl 43 set ref 464 720 736 1417* the_dsas_log 70 based bit(1) level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 466 482 578* 737* the_dsas_log 70 000100 automatic bit(1) level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 975* the_dsas_log_sw 117 000336 automatic bit(1) level 3 dcl 43 set ref 466 722 737 1426* the_dsasa_log 71 based bit(1) level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 468 482 578* 738* the_dsasa_log 71 000100 automatic bit(1) level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 976* the_dsasa_log_sw 120 000336 automatic bit(1) level 3 dcl 43 set ref 468 724 738 1435* the_syserr_log 64 000100 automatic bit(1) level 2 in structure "init_entry" dcl 917 in procedure "initialize_data" set ref 971* the_syserr_log 64 based bit(1) level 2 in structure "an_entry" dcl 31 in procedure "monitor_sys_log" set ref 458 482 578* 733* the_syserr_log_sw 113 000336 automatic bit(1) level 3 dcl 43 set ref 458 714 733 1391* time 110 000336 automatic fixed bin(71,0) level 2 dcl 43 set ref 240 1364* 1366 time_format 35 based varying char(40) level 2 dcl 2-3 set ref 1292* time_given_sw 134 000336 automatic bit(1) level 3 dcl 43 set ref 237 1365* 1606 timer_manager_$alarm_wakeup 000210 constant entry external dcl 191 ref 332 timer_manager_$reset_alarm_wakeup 000212 constant entry external dcl 193 ref 313 unspec builtin function dcl 215 set ref 1002* version 000312 automatic char(8) level 2 dcl 38 set ref 882* wakeup_event_channel 6 000214 external static fixed bin(71,0) initial level 2 dcl 4-19 set ref 313 313* 319 321* 325* 332* wakeup_interval 2 000214 external static fixed bin(71,0) initial level 2 dcl 4-19 set ref 240* 332* 512* 528* x 000226 automatic fixed bin(17,0) dcl 920 set ref 938* 939 939* 941 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ACTION_CAN_RESTART internal static bit(36) initial dcl 5-7 ACTION_DEFAULT_RESTART internal static bit(36) initial dcl 5-7 ACTION_QUIET_RESTART internal static bit(36) initial dcl 5-7 ACTION_SUPPORT_SIGNAL internal static bit(36) initial dcl 5-7 codeptr builtin function dcl 215 command_query_ 000000 constant entry external dcl 115 error_table_$inconsistent external static fixed bin(35,0) dcl 90 error_table_$name_not_found external static fixed bin(35,0) dcl 92 error_table_$namedup external static fixed bin(35,0) dcl 89 log_message_data_class_lth automatic fixed bin(17,0) dcl 1-21 log_message_data_lth automatic fixed bin(17,0) dcl 1-22 log_message_ptr automatic pointer dcl 1-19 log_message_text_lth automatic fixed bin(17,0) dcl 1-20 log_read_open_info_ptr automatic pointer dcl 3-4 opt1 based structure level 1 unaligned dcl 41 saved_looking_for automatic fixed bin(17,0) dcl 1043 NAMES DECLARED BY EXPLICIT CONTEXT. COMMON 007413 constant label dcl 1075 ref 1068 HAVE_EMPTY_SLOT 004702 constant label dcl 692 ref 686 INVALID_SEVERITY_RANGE 012501 constant label dcl 1528 ref 1538 MAIN_RETURN 002044 constant label dcl 261 ref 252 271 SSU_ABORT 002046 constant entry internal dcl 255 ref 227 227 adjust_log_message_format 013337 constant entry internal dcl 1625 ref 727 1027 1220 1237 1252 1271 1282 1293 1303 1324 check_options 013123 constant entry internal dcl 1601 ref 1451 clean_up 002166 constant entry internal dcl 290 ref 224 269 clear_entry 007222 constant entry internal dcl 958 ref 663 disable_log 004013 constant entry internal dcl 594 ref 542 enable_log 004100 constant entry internal dcl 606 ref 544 fault_masked 002067 constant entry internal dcl 276 ref 637 677 944 fill_entry_from_opt 004723 constant entry internal dcl 703 ref 416 find_log 003006 constant entry internal dcl 428 ref 371 finished 002055 constant entry internal dcl 266 ref 257 get_last_message_info 006456 constant entry internal dcl 897 ref 709 get_next_arg 013017 constant entry internal dcl 1583 ref 1206 1211 1226 1243 1258 1277 1289 1299 1320 1361 1374 initialize_add_options 007325 constant entry internal dcl 1014 ref 406 initialize_data 006550 constant entry internal dcl 914 ref 671 initialize_options 007275 constant entry internal dcl 997 ref 222 make_log_pathname 005237 constant entry internal dcl 781 ref 370 make_new_entry 004544 constant entry internal dcl 668 ref 414 monitor_sys_log 001651 constant entry external dcl 8 msl 001660 constant entry external dcl 8 open_log 006313 constant entry internal dcl 877 ref 413 486 print_status_header 003315 constant entry internal dcl 505 ref 244 559 process_all_logs 003473 constant entry internal dcl 552 ref 366 process_arguments$$fill_opt_with_options 007410 constant entry internal dcl 1070 ref 410 process_arguments$$find_log_and_action 007404 constant entry internal dcl 1033 ref 235 process_existing_log 003443 constant entry internal dcl 537 ref 418 569 process_log 002510 constant entry internal dcl 353 ref 249 process_looking_for 012100 constant entry internal dcl 1460 ref 1085 1448 reallocate_array 006714 constant entry internal dcl 931 ref 690 remove_log 004262 constant entry internal dcl 627 ref 401 546 reset_timer 002261 constant entry internal dcl 310 ref 241 602 623 664 771 same_pathname 003156 constant entry internal dcl 476 ref 470 set_init_entry 007236 constant entry internal dcl 965 ref 924 936 961 status_log 003565 constant entry internal dcl 575 ref 540 two_logs 012762 constant entry internal dcl 1575 ref 1310 1378 1474 1484 NAMES DECLARED BY CONTEXT OR IMPLICATION. bin builtin function ref 1615 rtrim builtin function ref 726 search builtin function ref 1486 string builtin function ref 1613 sum builtin function ref 1615 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 15074 15312 13702 15104 Length 16062 13702 216 534 1172 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME monitor_sys_log 1495 external procedure is an external procedure. on unit on line 224 64 on unit SSU_ABORT 70 internal procedure is assigned to an entry variable. finished internal procedure shares stack frame of internal procedure SSU_ABORT. fault_masked 116 internal procedure is called by several nonquick procedures. clean_up 76 internal procedure is called by several nonquick procedures. reset_timer 142 internal procedure is called by several nonquick procedures. process_log internal procedure shares stack frame of external procedure monitor_sys_log. find_log internal procedure shares stack frame of external procedure monitor_sys_log. same_pathname internal procedure shares stack frame of external procedure monitor_sys_log. print_status_header internal procedure shares stack frame of external procedure monitor_sys_log. process_existing_log internal procedure shares stack frame of external procedure monitor_sys_log. process_all_logs internal procedure shares stack frame of external procedure monitor_sys_log. status_log internal procedure shares stack frame of external procedure monitor_sys_log. disable_log internal procedure shares stack frame of external procedure monitor_sys_log. enable_log internal procedure shares stack frame of external procedure monitor_sys_log. remove_log 84 internal procedure enables or reverts conditions. on unit on line 637 64 on unit on unit on line 638 70 on unit begin block on line 657 begin block shares stack frame of internal procedure remove_log. make_new_entry 84 internal procedure enables or reverts conditions. on unit on line 677 64 on unit on unit on line 678 70 on unit fill_entry_from_opt internal procedure shares stack frame of external procedure monitor_sys_log. begin block on line 757 begin block shares stack frame of external procedure monitor_sys_log. make_log_pathname internal procedure shares stack frame of external procedure monitor_sys_log. open_log internal procedure shares stack frame of external procedure monitor_sys_log. get_last_message_info internal procedure shares stack frame of external procedure monitor_sys_log. initialize_data 186 internal procedure enables or reverts conditions. on unit on line 944 64 on unit on unit on line 945 70 on unit set_init_entry internal procedure shares stack frame of internal procedure initialize_data. initialize_options internal procedure shares stack frame of external procedure monitor_sys_log. initialize_add_options internal procedure shares stack frame of external procedure monitor_sys_log. process_arguments$$find_log_and_action internal procedure shares stack frame of external procedure monitor_sys_log. process_looking_for internal procedure shares stack frame of external procedure monitor_sys_log. two_logs internal procedure shares stack frame of external procedure monitor_sys_log. get_next_arg internal procedure shares stack frame of external procedure monitor_sys_log. check_options internal procedure shares stack frame of external procedure monitor_sys_log. adjust_log_message_format 96 internal procedure is called during a stack extension. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME initialize_data 000100 init_entry initialize_data 000224 new_array_ptr initialize_data 000226 x initialize_data monitor_sys_log 000100 an_entry_ptr monitor_sys_log 000102 code monitor_sys_log 000103 dm_system_log_path monitor_sys_log 000155 dsa_system_log_path monitor_sys_log 000227 log_index monitor_sys_log 000230 log_dname monitor_sys_log 000302 log_ename monitor_sys_log 000312 log_open_info monitor_sys_log 000332 sci_ptr monitor_sys_log 000334 old_mask monitor_sys_log 000336 opt monitor_sys_log 000506 log_message_format_ptr monitor_sys_log 000510 monitor_sys_log_array_ptr monitor_sys_log 000512 msl_n_entries monitor_sys_log 000522 already_monitored process_log 000523 explicit_action process_log 000524 explicit_modification process_log 000544 new_uid same_pathname 000545 old_uid same_pathname 000546 temp_opening same_pathname 000556 select_timer print_status_header 000626 log_last_sequence fill_entry_from_opt 000630 log_last_message_ptr fill_entry_from_opt 000676 arg_lth process_arguments$$find_log_and_action 000700 arg_ptr process_arguments$$find_log_and_action 000702 arg_count process_arguments$$find_log_and_action 000703 arg_idx process_arguments$$find_log_and_action 000704 looking_for process_arguments$$find_log_and_action 000705 number_arg process_arguments$$find_log_and_action 000713 iocb_arg process_arguments$$find_log_and_action 000724 temp_v_string_arg process_arguments$$find_log_and_action 001007 pass process_arguments$$find_log_and_action 001020 really_looking_for process_looking_for 001021 severity1 process_looking_for 001022 severity2 process_looking_for 001046 action_opt check_options THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_ne_as alloc_char_temp call_ext_out_desc call_ext_out call_int_this_desc call_int_this call_int_other return_mac tra_ext_1 enable_op shorten_stack ext_entry int_entry int_entry_desc op_alloc_ op_freen_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. check_gate_access_ com_err_ continue_to_signal_ cu_$arg_list_ptr cv_dec_check_ dm_misc_util_$get_log_path dsa_nit_$get_field expand_pathname_ format_log_message_$adjust format_log_message_$free format_log_message_$init get_line_length_$switch get_system_free_area_ hcs_$reset_ips_mask hcs_$set_ips_mask ioa_ iox_$look_iocb ipc_$create_ev_chn ipc_$cutoff ipc_$decl_event_call_chn ipc_$delete_ev_chn ipc_$reconnect log_expand_select_$add log_expand_select_$free log_expand_select_$print log_match_$add_exclude log_match_$add_exclude_data log_match_$add_exclude_data_class log_match_$add_match log_match_$add_match_data log_match_$add_match_data_class log_match_$add_severity log_match_$clear_data_class_strings log_match_$clear_data_strings log_match_$clear_severity log_match_$clear_text_strings log_match_$free log_match_$print log_read_$close log_read_$get_log_uid log_read_$open log_read_$open_long log_read_$prev_message log_read_$update monitor_sys_log_wakeup_$timer pathname_ ssu_$abort_line ssu_$arg_count ssu_$arg_ptr ssu_$destroy_invocation ssu_$standalone_invocation sub_err_ timer_manager_$alarm_wakeup timer_manager_$reset_alarm_wakeup THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$bad_arg error_table_$bad_conversion error_table_$badopt error_table_$moderr error_table_$no_log_message error_table_$noarg error_table_$noentry error_table_$too_many_args error_table_$unexpected_condition iox_$user_output log_data_$syserr_log_dir log_data_$syserr_log_name monitor_sys_log_data_ LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 8 001650 222 001665 224 001666 227 001710 228 001760 230 001762 231 002006 235 002007 237 002010 240 002012 241 002016 244 002022 248 002032 249 002033 251 002034 252 002043 261 002044 255 002045 257 002053 258 002054 266 002055 269 002056 271 002063 276 002066 279 002074 282 002110 283 002117 284 002122 287 002164 290 002165 293 002173 295 002176 298 002210 301 002227 304 002243 307 002257 310 002260 313 002266 315 002302 317 002305 319 002310 321 002312 322 002323 325 002371 327 002421 331 002467 332 002472 335 002507 353 002510 360 002511 361 002535 362 002541 364 002543 366 002572 367 002573 370 002574 371 002575 373 002576 375 002601 379 002635 384 002715 387 002724 391 002726 393 002731 394 002732 395 002735 396 002740 397 002743 399 002746 401 002751 403 002757 404 002760 406 002762 408 002765 410 002772 411 002773 413 002775 414 002776 416 003002 417 003003 418 003004 419 003005 428 003006 431 003007 432 003010 434 003012 437 003022 441 003033 443 003035 445 003040 447 003050 448 003052 449 003056 454 003057 455 003067 456 003073 458 003100 460 003106 462 003114 464 003122 466 003130 468 003136 470 003144 472 003152 473 003154 474 003155 476 003156 482 003160 486 003205 487 003206 488 003210 489 003212 490 003225 491 003237 493 003244 494 003262 495 003276 497 003303 499 003312 505 003315 510 003316 512 003325 513 003345 516 003346 518 003352 521 003362 522 003365 524 003372 526 003377 528 003401 532 003442 537 003443 540 003444 542 003451 544 003456 546 003463 549 003472 552 003473 555 003474 557 003500 559 003503 560 003504 562 003511 563 003512 567 003541 568 003551 569 003555 571 003562 572 003564 575 003565 578 003566 582 003657 583 003703 585 003725 587 003747 590 003771 591 004012 594 004013 597 004014 599 004053 600 004056 602 004073 603 004077 606 004100 609 004101 611 004140 613 004157 614 004162 615 004175 618 004230 619 004234 620 004236 621 004237 623 004254 624 004260 627 004261 630 004267 632 004273 633 004274 634 004277 636 004302 637 004303 638 004325 640 004341 642 004356 643 004357 644 004373 645 004400 646 004410 648 004412 649 004426 651 004443 653 004460 655 004475 657 004513 660 004521 663 004530 664 004535 665 004542 668 004543 671 004551 676 004561 677 004563 678 004605 680 004621 682 004636 683 004637 685 004653 686 004664 688 004673 690 004675 692 004702 696 004710 697 004720 699 004722 703 004723 709 004724 712 004730 714 004732 716 004743 718 004753 720 004764 722 004774 724 005005 726 005016 727 005051 728 005104 730 005105 731 005111 732 005114 733 005116 734 005120 735 005122 736 005124 737 005126 738 005130 739 005132 740 005133 741 005134 742 005136 743 005140 744 005142 745 005144 746 005146 747 005150 749 005152 750 005154 752 005156 754 005160 755 005162 757 005164 760 005166 761 005171 762 005211 765 005217 767 005221 768 005224 770 005226 771 005227 778 005236 781 005237 784 005240 786 005243 789 005250 791 005254 792 005261 793 005265 794 005304 796 005305 798 005311 799 005314 800 005317 801 005337 802 005340 804 005344 805 005347 806 005352 807 005372 808 005373 810 005377 811 005410 812 005435 813 005440 814 005445 815 005446 820 005452 822 005475 824 005525 827 005557 832 005611 834 005655 837 005703 838 005730 839 005733 840 005740 841 005741 846 005745 848 005770 850 006020 853 006052 858 006104 861 006145 864 006173 865 006220 866 006223 867 006230 869 006231 870 006255 874 006312 877 006313 880 006314 882 006321 883 006323 884 006330 886 006337 887 006340 888 006372 889 006373 891 006420 894 006455 897 006456 903 006460 904 006462 905 006476 908 006532 910 006542 911 006546 914 006547 922 006555 923 006560 924 006602 926 006603 927 006705 928 006710 929 006712 931 006713 934 006721 935 006725 936 006747 937 006750 938 007052 939 007063 940 007074 941 007076 943 007100 944 007101 945 007123 947 007137 949 007154 950 007155 951 007171 952 007175 953 007203 954 007206 955 007216 956 007220 958 007221 961 007227 962 007230 963 007235 965 007236 968 007237 969 007242 970 007245 971 007247 972 007250 973 007251 974 007252 975 007253 976 007254 977 007255 978 007256 979 007257 980 007260 981 007261 982 007262 983 007263 984 007264 985 007265 986 007266 987 007267 988 007270 989 007271 990 007272 991 007274 997 007275 1002 007276 1003 007301 1004 007306 1005 007310 1006 007313 1007 007317 1008 007321 1009 007322 1010 007323 1011 007324 1014 007325 1017 007326 1018 007335 1019 007340 1020 007343 1022 007344 1023 007357 1027 007364 1029 007403 1033 007404 1067 007405 1068 007407 1070 007410 1073 007411 1075 007413 1078 007424 1080 007426 1081 007435 1083 007452 1085 007454 1086 007455 1087 007457 1089 007460 1091 007472 1092 007474 1093 007475 1095 007505 1096 007507 1098 007510 1100 007520 1101 007522 1102 007523 1104 007533 1105 007535 1106 007536 1108 007546 1109 007550 1110 007551 1112 007561 1113 007563 1114 007564 1116 007574 1118 007577 1120 007606 1121 007607 1123 007617 1125 007622 1127 007631 1129 007632 1131 007642 1133 007645 1135 007654 1138 007655 1140 007671 1141 007673 1143 007674 1145 007704 1147 007716 1149 007717 1151 007727 1152 007731 1153 007733 1154 007734 1156 007744 1158 007747 1159 007750 1160 007751 1162 007752 1164 007753 1166 007763 1168 007766 1169 007770 1171 007771 1172 007772 1174 010006 1176 010011 1177 010013 1179 010014 1181 010015 1183 010025 1185 010031 1186 010032 1188 010042 1190 010047 1192 010050 1194 010060 1196 010064 1198 010065 1200 010075 1202 010102 1204 010103 1206 010113 1207 010116 1209 010117 1211 010127 1212 010132 1214 010135 1215 010170 1220 010230 1222 010255 1224 010256 1226 010266 1227 010271 1229 010274 1230 010325 1232 010363 1233 010377 1237 010404 1239 010426 1241 010427 1243 010443 1244 010446 1246 010451 1247 010504 1252 010543 1254 010570 1256 010571 1258 010601 1259 010604 1261 010607 1264 010625 1265 010660 1271 010717 1272 010746 1273 010747 1275 010750 1277 010760 1278 010763 1280 010766 1281 010770 1282 011001 1284 011026 1287 011027 1289 011037 1290 011042 1292 011045 1293 011056 1295 011103 1297 011104 1299 011114 1300 011117 1302 011122 1303 011133 1305 011160 1306 011161 1308 011171 1310 011174 1312 011201 1313 011203 1315 011206 1316 011207 1318 011222 1320 011232 1321 011235 1323 011240 1324 011251 1326 011273 1328 011274 1331 011305 1332 011306 1335 011323 1336 011324 1339 011335 1340 011336 1343 011347 1345 011350 1348 011365 1350 011366 1353 011403 1354 011404 1357 011421 1359 011422 1361 011432 1362 011435 1364 011440 1365 011473 1366 011476 1370 011530 1372 011531 1374 011541 1375 011544 1377 011547 1378 011601 1380 011607 1381 011612 1385 011643 1386 011644 1388 011650 1390 011653 1391 011656 1393 011660 1395 011661 1397 011671 1399 011674 1400 011677 1402 011701 1403 011702 1405 011706 1407 011711 1408 011714 1410 011716 1412 011717 1414 011727 1416 011732 1417 011735 1419 011737 1421 011740 1423 011750 1425 011753 1426 011756 1428 011760 1430 011761 1432 011771 1434 011774 1435 011777 1437 012001 1439 012002 1441 012006 1442 012010 1443 012012 1445 012013 1448 012055 1449 012056 1451 012060 1453 012064 1457 012077 1460 012100 1468 012101 1470 012106 1472 012110 1474 012113 1476 012120 1478 012125 1480 012126 1482 012130 1484 012133 1486 012140 1489 012201 1491 012224 1493 012225 1496 012252 1498 012253 1501 012300 1503 012301 1506 012326 1508 012327 1511 012354 1513 012355 1516 012402 1518 012403 1521 012430 1523 012431 1525 012433 1527 012436 1528 012476 1534 012534 1537 012552 1538 012616 1541 012621 1543 012634 1545 012635 1547 012637 1549 012642 1550 012666 1553 012723 1554 012724 1556 012726 1558 012731 1560 012742 1562 012750 1563 012752 1564 012754 1566 012755 1567 012757 1568 012760 1572 012761 1575 012762 1577 012763 1579 013016 1583 013017 1589 013030 1592 013071 1593 013072 1595 013107 1597 013122 1601 013123 1606 013124 1610 013165 1613 013221 1615 013261 1619 013335 1625 013336 1632 013357 1633 013370 1637 013373 1640 013430 ----------------------------------------------------------- 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