COMPILATION LISTING OF SEGMENT meter_fnp_idle Compiled by: Multics PL/I Compiler, Release 28e, of February 14, 1985 Compiled at: Honeywell Multics Op. - System M Compiled on: 04/09/85 1211.5 mst Tue Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 /* format: style4,delnl,insnl,^ifthendo */ 12 meter_fnp_idle: 13 procedure; 14 15 /* This command causes the process to wake up at specified intervals and record the specified FNP's idle time 16* for the most recent interval. This data is stored away in a segment where the display_fnp_idle 17* command can find it. If the FNP crashes and reloads while the command is runninmg, a new data 18* segment is started. 19**/ 20 21 /* Coded January 1982 by Robert Coren */ 22 /* Modified March 1982 by Robert Coren to correct time slippage. */ 23 24 dcl fnp_name char (1); 25 dcl minutes fixed bin; 26 dcl stop bit (1); 27 dcl non_stop bit (1); 28 dcl dirname char (168); 29 dcl entryname char (32); 30 dcl code fixed bin (35); 31 dcl nargs fixed bin; 32 dcl iarg fixed bin; 33 dcl infop pointer; 34 dcl fnp_no fixed bin; 35 dcl event_message fixed bin (71); 36 dcl comm_meters_chan_name (1) char (1); 37 dcl areap pointer; 38 dcl meter_time fixed bin (71); 39 dcl next_entry fixed bin; 40 dcl idle_count fixed bin (35); 41 dcl idle_updates fixed bin (35); 42 dcl delta_idle fixed bin (35); 43 44 dcl argp pointer; 45 dcl argl fixed bin (21); 46 dcl arg char (argl) based (argp); 47 48 dcl cu_$arg_count entry (fixed bin, fixed bin (35)); 49 dcl com_err_ entry () options (variable); 50 dcl com_err_$suppress_name entry () options (variable); 51 dcl continue_to_signal_ entry (fixed bin (35)); 52 dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin (21), fixed bin (35)); 53 dcl cv_dec_check_ entry (char (*), fixed bin (35)) returns (fixed bin); 54 dcl find_condition_info_ entry (ptr, ptr, fixed bin (35)); 55 dcl expand_pathname_ entry (char (*), char (*), char (*), fixed bin (35)); 56 dcl pathname_ entry (char (*), char (*)) returns (char (168)); 57 dcl get_process_id_ entry returns (bit (36)); 58 dcl parse_fnp_name_ entry (char (*), fixed bin); 59 dcl ipc_$create_ev_chn entry (fixed bin (71), fixed bin (35)); 60 dcl convert_ipc_code_ entry (fixed bin (35)); 61 dcl ipc_$decl_ev_call_chn entry (fixed bin (71), ptr, ptr, fixed bin, fixed bin (35)); 62 dcl hcs_$wakeup entry (bit (*), fixed bin (71), fixed bin (71), fixed bin (35)); 63 dcl get_system_free_area_ entry () returns (ptr); 64 dcl comm_meters_ entry ((*) char (*), fixed bin, ptr, fixed bin, ptr, fixed bin (35)); 65 dcl comm_meters_$free entry (ptr, ptr, fixed bin (35)); 66 dcl timer_manager_$alarm_wakeup entry (fixed bin (71), bit (2), fixed bin (71)); 67 68 dcl ( 69 error_table_$action_not_performed, 70 error_table_$inconsistent, 71 error_table_$too_many_args, 72 error_table_$noarg, 73 error_table_$badopt 74 ) fixed bin (35) external static; 75 76 dcl COMMAND_NAME char (14) internal static options (constant) init ("meter_fnp_idle"); 77 78 dcl static_dirname char (168) internal static; 79 80 dcl 1 meter_fnp_idle_info_array (8) internal static aligned like meter_fnp_idle_info; 81 82 dcl 1 meter_fnp_idle_info aligned based (infop), 83 2 event_channel_name fixed bin (71), 84 2 next_cycle_sched fixed bin (71), 85 2 interval fixed bin (71), 86 2 data_seg_ptr pointer, 87 2 fnp_name char (1), 88 2 minutes fixed bin, 89 2 flags, 90 3 running bit (1) unaligned, 91 3 suspended bit (1) unaligned, 92 3 stop_requested bit (1) unaligned, 93 3 pad bit (33) unaligned; 94 95 dcl (cleanup, sub_error_) condition; 96 97 fnp_name = ""; 98 minutes = 0; 99 dirname = ""; 100 stop, non_stop = "0"b; 101 102 call cu_$arg_count (nargs, code); 103 if code ^= 0 104 then do; 105 call com_err_ (code, COMMAND_NAME); 106 return; 107 end; 108 109 if nargs = 0 110 then do; 111 call com_err_$suppress_name (0, COMMAND_NAME, "Usage: meter_fnp_idle fnp_name {-stop | -interval MINUTES}") 112 ; 113 return; 114 end; 115 116 do iarg = 1 to nargs; 117 call cu_$arg_ptr (iarg, argp, argl, code); 118 if code ^= 0 119 then do; 120 call com_err_ (code, COMMAND_NAME); 121 return; 122 end; 123 124 if substr (arg, 1, 1) ^= "-" 125 then do; /* not a control arg, must be FNP name */ 126 call parse_fnp_name_ (arg, fnp_no); 127 if fnp_no < 0 128 then do; 129 call com_err_ (0, COMMAND_NAME, "^a is not a valid FNP name.", arg); 130 return; 131 end; 132 else if fnp_name ^= "" 133 then do; 134 call com_err_ (error_table_$inconsistent, COMMAND_NAME, 135 "More than one FNP name specified: ^a and ^a", fnp_name, arg); 136 return; 137 end; 138 fnp_name = arg; 139 end; 140 141 else if arg = "-stop" | arg = "-sp" 142 then if non_stop 143 then do; 144 STOP_ERROR: 145 call com_err_ (error_table_$inconsistent, COMMAND_NAME, 146 "-stop cannot be specified with any other control argument."); 147 return; 148 end; 149 else stop = "1"b; 150 151 else if stop 152 then go to STOP_ERROR; 153 else do; 154 non_stop = "1"b; 155 156 if arg = "-directory" | arg = "-dr" 157 then do; 158 iarg = iarg + 1; 159 call cu_$arg_ptr (iarg, argp, argl, code); 160 if code ^= 0 161 then do; 162 NO_DIR: 163 call com_err_ (code, COMMAND_NAME, "No directory pathname specified."); 164 return; 165 end; 166 167 if substr (arg, 1, 1) = "-" 168 then do; 169 code = error_table_$noarg; 170 go to NO_DIR; 171 end; 172 173 call expand_pathname_ (arg, dirname, entryname, code); 174 if code ^= 0 175 then do; 176 call com_err_ (code, COMMAND_NAME, arg); 177 return; 178 end; 179 180 dirname = pathname_ (dirname, entryname); 181 end; 182 183 else if arg = "-interval" 184 then do; 185 if minutes ^= 0 186 then do; 187 call com_err_ (error_table_$inconsistent, COMMAND_NAME, "More than one interval specified.") 188 ; 189 return; 190 end; 191 iarg = iarg + 1; 192 call cu_$arg_ptr (iarg, argp, argl, code); 193 if code ^= 0 194 then do; 195 NO_INTERVAL: 196 call com_err_ (code, COMMAND_NAME, "Interval value not supplied."); 197 return; 198 end; 199 200 if substr (arg, 1, 1) = "-" 201 then do; 202 code = error_table_$noarg; 203 go to NO_INTERVAL; 204 end; 205 206 minutes = cv_dec_check_ (arg, code); 207 if code ^= 0 208 then do; 209 call com_err_ (0, COMMAND_NAME, "^a is not a valid interval specification.", arg); 210 return; 211 end; 212 end; 213 214 else do; 215 call com_err_ (error_table_$badopt, COMMAND_NAME, arg); 216 return; 217 end; 218 end; 219 end; 220 221 if fnp_name = "" 222 then do; 223 call com_err_ (error_table_$noarg, COMMAND_NAME, "No FNP name specified."); 224 return; 225 end; 226 227 static_dirname = dirname; 228 229 infop = addr (meter_fnp_idle_info_array (fnp_no)); 230 if stop 231 then do; 232 if ^meter_fnp_idle_info.running 233 then call com_err_ (0, COMMAND_NAME, "This process is not metering FNP ^a.", fnp_name); 234 else meter_fnp_idle_info.stop_requested = "1"b; 235 return; 236 end; 237 238 if meter_fnp_idle_info.running 239 then do; 240 call com_err_ (error_table_$action_not_performed, COMMAND_NAME, "This process is already metering FNP ^a.", 241 fnp_name); 242 return; 243 end; 244 245 if minutes = 0 246 then minutes = 1; /* default to one minute interval */ 247 248 meter_fnp_idle_info.minutes = minutes; /* for forming pathname */ 249 meter_fnp_idle_info.next_cycle_sched = 0; 250 meter_fnp_idle_info.interval = 60000000 * minutes;/* convert to microseconds */ 251 meter_fnp_idle_info.data_seg_ptr = null (); 252 meter_fnp_idle_info.fnp_name = fnp_name; 253 string (meter_fnp_idle_info.flags) = "0"b; 254 255 call ipc_$create_ev_chn (meter_fnp_idle_info.event_channel_name, code); 256 if code ^= 0 257 then do; 258 call convert_ipc_code_ (code); 259 call com_err_ (code, COMMAND_NAME, "Unable to create event channel."); 260 return; 261 end; 262 263 call ipc_$decl_ev_call_chn (meter_fnp_idle_info.event_channel_name, codeptr (idle_wakeup), infop, 30, code); 264 if code ^= 0 265 then do; 266 call convert_ipc_code_ (code); 267 call com_err_ (code, COMMAND_NAME, "Unable to set up event call channel."); 268 return; 269 end; 270 271 event_message = fnp_no; 272 meter_fnp_idle_info.running = "1"b; 273 call hcs_$wakeup (get_process_id_ (), meter_fnp_idle_info.event_channel_name, event_message, code); 274 if code ^= 0 275 then do; 276 call convert_ipc_code_ (code); 277 call com_err_ (code, COMMAND_NAME, "Unable to send initial wakeup."); 278 end; 279 280 return; 281 282 idle_wakeup: 283 entry (arg_event_call_info_ptr); 284 285 /* this entry, which reschedules itself for the next metering interval, does all the real work */ 286 287 dcl arg_event_call_info_ptr pointer; 288 289 event_call_info_ptr = arg_event_call_info_ptr; 290 infop = event_call_info.data_ptr; 291 if event_call_info.channel_id ^= meter_fnp_idle_info.event_channel_name 292 then return; /* not the right wakeup */ 293 294 meter_time = clock (); 295 if meter_fnp_idle_info.next_cycle_sched = 0 296 then meter_fnp_idle_info.next_cycle_sched = meter_time; 297 meter_fnp_idle_info.next_cycle_sched = meter_fnp_idle_info.next_cycle_sched + meter_fnp_idle_info.interval; 298 299 if meter_fnp_idle_info.stop_requested 300 then do; /* finished with this one */ 301 call wrapup_data_segment; 302 meter_fnp_idle_info.stop_requested, meter_fnp_idle_info.running = "0"b; 303 return; 304 end; 305 306 on sub_error_ 307 begin; 308 309 /* this is here because comm_meters_ calls sub_err_ in case of problems. Since it also 310* returns a useful error code if called with a single channel name, this handler doesn't have to explain anything */ 311 312 dcl code fixed bin (35); 313 dcl pass_on bit (1); 314 dcl 1 auto_cond_info aligned like condition_info; 315 316 pass_on = "0"b; 317 condition_info_ptr = addr (auto_cond_info); 318 call find_condition_info_ (null (), condition_info_ptr, code); 319 if code ^= 0 /* rather unlikely */ 320 then pass_on = "1"b; /* but we'll let someone else worry about it */ 321 322 else if condition_info.info_ptr = null () | condition_info.condition_name ^= "sub_error_" 323 /* we're not about to deal with this */ 324 then pass_on = "1"b; 325 326 else do; 327 sub_error_info_ptr = condition_info.info_ptr; 328 if sub_error_info.name ^= "comm_meters_" 329 /* not someone we know */ 330 then pass_on = "1"b; 331 end; 332 333 if pass_on 334 then call continue_to_signal_ (code); 335 end; 336 337 comm_meters_chan_name (1) = meter_fnp_idle_info.fnp_name; 338 areap = get_system_free_area_ (); 339 340 call comm_meters_ (comm_meters_chan_name, CHANNEL_METERS_VERSION_1, areap, (0), chan_meterp, code); 341 342 if code = 0 /* we got meters */ 343 then do; 344 on cleanup call comm_meters_$free (areap, chan_meterp, (0)); 345 fnp_meterp = channel_meters.mpx_specific_meterp; 346 if unspec (fnp_meters.from_fnp) = "0"b 347 then call wrapup_data_segment; /* oops, nothing useful */ 348 else do; 349 fnp_idle_data_ptr = meter_fnp_idle_info.data_seg_ptr; 350 if fnp_idle_data_ptr = null () 351 then do; /* no segment active at the moment */ 352 call setup_data_segment (code); /* so start one */ 353 if code ^= 0 354 then do; 355 meter_fnp_idle_info.running = "1"b; 356 return; /* we couldn't, forget it */ 357 end; 358 end; 359 360 if fnp_idle_data.entries_used >= fnp_idle_data.max_entries 361 /* we've filled this one */ 362 then do; 363 call wrapup_data_segment; 364 call setup_data_segment (code); /* start a new one */ 365 if code ^= 0 366 then do; 367 meter_fnp_idle_info.running = "0"b; 368 return; 369 end; 370 end; 371 372 next_entry = fnp_idle_data.entries_used + 1; 373 idle_count = fnp_meters.from_fnp.total_idle_count; 374 idle_updates = fnp_meters.from_fnp.idle_count_updates; 375 delta_idle = idle_count - fnp_idle_data.latest_idle_count; 376 377 fnp_idle_data.entries (next_entry).idle_count = idle_count; 378 fnp_idle_data.entries (next_entry).sample_count = idle_updates; 379 fnp_idle_data.maximum_idle_count = fnp_meters.from_fnp.max_idle_count; 380 381 if fnp_idle_data.minimum_idle_count = 0 382 | fnp_meters.from_fnp.min_idle_count < fnp_idle_data.minimum_idle_count 383 then do; 384 fnp_idle_data.minimum_idle_count = fnp_meters.from_fnp.min_idle_count; 385 fnp_idle_data.time_of_minimum_sample = meter_time; 386 end; 387 388 if fnp_idle_data.minimum_delta_idle = 0 | delta_idle < fnp_idle_data.minimum_delta_idle 389 then do; 390 fnp_idle_data.minimum_delta_idle = delta_idle; 391 fnp_idle_data.time_of_minimum_average = meter_time; 392 end; 393 394 fnp_idle_data.latest_idle_count = idle_count; 395 fnp_idle_data.latest_sample_count = idle_updates; 396 fnp_idle_data.entries_used = next_entry; 397 fnp_idle_data.last_time = meter_time; 398 399 call comm_meters_$free (areap, chan_meterp, code); 400 revert cleanup; 401 end; 402 end; 403 404 else call wrapup_data_segment; 405 406 call timer_manager_$alarm_wakeup (meter_fnp_idle_info.next_cycle_sched, "00"b, 407 meter_fnp_idle_info.event_channel_name); 408 return; 409 410 setup_data_segment: 411 procedure (a_code); 412 413 /* This subroutine creates and initializes a data segment for storing the meters accumulated consecutively for 414* a single FNP. The entryname of the segment is fnp_idle_data.FNPNAME.YYMMDD.HHMMSS.INTERVAL, 415* which makes them easy to sort. */ 416 417 dcl a_code fixed bin (35); 418 419 dcl dirname char (168); 420 dcl entryname char (32); 421 dcl month fixed bin; 422 dcl day fixed bin; 423 dcl year fixed bin; 424 dcl hour fixed bin; 425 dcl minute fixed bin; 426 dcl second fixed bin; 427 dcl pic_month pic "99"; 428 dcl pic_day pic "99"; 429 dcl pic_year pic "99"; 430 dcl pic_hour pic "99"; 431 dcl pic_minute pic "99"; 432 dcl pic_second pic "99"; 433 dcl code fixed bin (35); 434 435 dcl decode_clock_value_$date_time 436 entry (fixed bin (71), fixed bin, fixed bin, fixed bin, fixed bin, fixed bin, fixed bin, fixed bin (71), 437 fixed bin, char (3), fixed bin (35)); 438 dcl ioa_$rsnnl entry () options (variable); 439 dcl get_wdir_ entry () returns (char (168)); 440 dcl hcs_$make_seg entry (char (*), char (*), char (*), fixed bin (5), ptr, fixed bin (35)); 441 dcl hcs_$truncate_seg entry (ptr, fixed bin (19), fixed bin (35)); 442 dcl hcs_$set_max_length_seg entry (ptr, fixed bin (19), fixed bin (35)); 443 dcl hcs_$terminate_noname entry (ptr, fixed bin (35)); 444 dcl error_table_$namedup fixed bin (35) external static; 445 446 if static_dirname = "" 447 then dirname = get_wdir_ (); 448 else dirname = static_dirname; 449 450 call decode_clock_value_$date_time (meter_time, month, day, year, hour, minute, second, (0), (0), (""), (0)); 451 pic_month = month; 452 pic_day = day; 453 pic_year = mod (year, 100); 454 pic_hour = hour; 455 pic_minute = minute; 456 pic_second = second; 457 458 call ioa_$rsnnl ("fnp_idle_data.^a.^a^a^a.^a^a^a.^d", entryname, (0), meter_fnp_idle_info.fnp_name, pic_year, 459 pic_month, pic_day, pic_hour, pic_minute, pic_second, meter_fnp_idle_info.minutes); 460 461 call hcs_$make_seg (dirname, entryname, "", RW_ACCESS_BIN, fnp_idle_data_ptr, code); 462 if fnp_idle_data_ptr = null () 463 then do; 464 call com_err_ (code, COMMAND_NAME, "Could not create ^a", pathname_ (dirname, entryname)); 465 a_code = code; 466 return; 467 end; 468 469 if code = error_table_$namedup 470 then do; 471 call com_err_ (code, COMMAND_NAME, "^a exists. FNP ^a is already being metered.", 472 pathname_ (dirname, entryname), meter_fnp_idle_info.fnp_name); 473 a_code = code; 474 call hcs_$terminate_noname (fnp_idle_data_ptr, code); 475 fnp_idle_data_ptr = null (); 476 return; 477 end; 478 479 call hcs_$set_max_length_seg (fnp_idle_data_ptr, 65536, code); 480 if code ^= 0 481 then do; 482 call com_err_ (code, COMMAND_NAME, "Could not set max. length of ^a", pathname_ (dirname, entryname)); 483 a_code = code; 484 call hcs_$terminate_noname (fnp_idle_data_ptr, code); 485 return; 486 end; 487 488 fnp_idle_data.version = FNP_IDLE_DATA_VERSION_1; 489 fnp_idle_data.time_started = meter_time; 490 fnp_idle_data.sample_interval = meter_fnp_idle_info.interval; 491 fnp_idle_data.max_entries = 492 divide (65536 - bin (rel (addr (fnp_idle_data.entries (1))), 18), 493 size (fnp_idle_data_ptr -> fnp_idle_entry), 17, 0); 494 meter_fnp_idle_info.data_seg_ptr = fnp_idle_data_ptr; 495 meter_fnp_idle_info.suspended = "0"b; 496 meter_fnp_idle_info.running = "1"b; 497 a_code = 0; 498 return; 499 500 end setup_data_segment; 501 502 wrapup_data_segment: 503 procedure; 504 505 dcl hcs_$terminate_noname entry (ptr, fixed bin (35)); 506 dcl code fixed bin (35); 507 508 call hcs_$terminate_noname (meter_fnp_idle_info.data_seg_ptr, code); 509 meter_fnp_idle_info.data_seg_ptr = null (); 510 if ^meter_fnp_idle_info.stop_requested 511 then meter_fnp_idle_info.suspended = "1"b; 512 return; 513 end wrapup_data_segment; 514 1 1 /* BEGIN INCLUDE FILE...fnp_idle_data.incl.pl1 */ 1 2 1 3 /* This include file defines the structure used by meter_fnp_idle to accumulate 1 4* data reported by display_fnp_idle */ 1 5 1 6 /* Written January 7, 1982 by Robert S. Coren */ 1 7 1 8 dcl 1 fnp_idle_data aligned based (fnp_idle_data_ptr), 1 9 2 version fixed bin, 1 10 2 sample_interval fixed bin, /* in microseconds */ 1 11 2 time_started fixed bin (71), /* clock time when metering started */ 1 12 2 last_time fixed bin (71), /* time of most recent entry */ 1 13 2 time_of_minimum_sample fixed bin (71), /* time at which new minimum idle count was reported */ 1 14 2 time_of_minimum_average fixed bin (71), /* time of interval that had smallest net idle */ 1 15 2 minimum_idle_count fixed bin (35), /* count for busiest second */ 1 16 2 minimum_delta_idle fixed bin (35), /* idle count accumulated during busiest sample_interval */ 1 17 2 maximum_idle_count fixed bin (35), /* 100% idle value */ 1 18 2 latest_idle_count fixed bin (35), /* idle count most recently recorded */ 1 19 2 latest_sample_count fixed bin (35), /* number of updates during last interval */ 1 20 2 max_entries fixed bin, /* the largest number of entries that can be recorded in this segment */ 1 21 2 entries_used fixed bin, /* the number of entries that have been recorded so far */ 1 22 2 pad bit (36), /* make entries double_word aligned for neatness */ 1 23 2 entries (max_fnp_idle_entries refer (fnp_idle_data.max_entries)) like fnp_idle_entry; 1 24 1 25 dcl 1 fnp_idle_entry aligned based, 1 26 2 idle_count fixed bin (35), /* accumulated idle count reported by FNP */ 1 27 2 sample_count fixed bin (35); /* number of updates represented by idle_count */ 1 28 1 29 dcl max_fnp_idle_entries fixed bin; 1 30 dcl fnp_idle_data_ptr pointer; 1 31 1 32 dcl FNP_IDLE_DATA_VERSION_1 fixed bin internal static options (constant) init (1); 1 33 1 34 /* END INCLUDE FILE ... fnp_idle_data.incl.pl1 */ 515 516 2 1 /* BEGIN INCLUDE FILE ... access_mode_values.incl.pl1 2 2* 2 3* Values for the "access mode" argument so often used in hardcore 2 4* James R. Davis 26 Jan 81 MCR 4844 2 5* Added constants for SM access 4/28/82 Jay Pattin 2 6* Added text strings 03/19/85 Chris Jones 2 7**/ 2 8 2 9 2 10 /* format: style4,delnl,insnl,indattr,ifthen,dclind10 */ 2 11 dcl ( 2 12 N_ACCESS init ("000"b), 2 13 R_ACCESS init ("100"b), 2 14 E_ACCESS init ("010"b), 2 15 W_ACCESS init ("001"b), 2 16 RE_ACCESS init ("110"b), 2 17 REW_ACCESS init ("111"b), 2 18 RW_ACCESS init ("101"b), 2 19 S_ACCESS init ("100"b), 2 20 M_ACCESS init ("010"b), 2 21 A_ACCESS init ("001"b), 2 22 SA_ACCESS init ("101"b), 2 23 SM_ACCESS init ("110"b), 2 24 SMA_ACCESS init ("111"b) 2 25 ) bit (3) internal static options (constant); 2 26 2 27 /* The following arrays are meant to be accessed by doing either 1) bin (bit_value) or 2 28* 2) divide (bin_value, 2) to come up with an index into the array. */ 2 29 2 30 dcl SEG_ACCESS_MODE_NAMES (0:7) init ("null", "W", "E", "EW", "R", "RW", "RE", "REW") char (4) internal 2 31 static options (constant); 2 32 2 33 dcl DIR_ACCESS_MODE_NAMES (0:7) init ("null", "A", "M", "MA", "S", "SA", "SM", "SMA") char (4) internal 2 34 static options (constant); 2 35 2 36 dcl ( 2 37 N_ACCESS_BIN init (00000b), 2 38 R_ACCESS_BIN init (01000b), 2 39 E_ACCESS_BIN init (00100b), 2 40 W_ACCESS_BIN init (00010b), 2 41 RW_ACCESS_BIN init (01010b), 2 42 RE_ACCESS_BIN init (01100b), 2 43 REW_ACCESS_BIN init (01110b), 2 44 S_ACCESS_BIN init (01000b), 2 45 M_ACCESS_BIN init (00010b), 2 46 A_ACCESS_BIN init (00001b), 2 47 SA_ACCESS_BIN init (01001b), 2 48 SM_ACCESS_BIN init (01010b), 2 49 SMA_ACCESS_BIN init (01011b) 2 50 ) fixed bin (5) internal static options (constant); 2 51 2 52 /* END INCLUDE FILE ... access_mode_values.incl.pl1 */ 517 518 3 1 /* BEGIN INCLUDE FILE sub_error_info.incl.pl1 */ 3 2 /* format: style2 */ 3 3 3 4 /* The include file condition_info_header must be used with this file */ 3 5 3 6 declare sub_error_info_ptr pointer; 3 7 declare 1 sub_error_info aligned based (sub_error_info_ptr), 3 8 2 header aligned like condition_info_header, 3 9 2 retval fixed bin (35), /* return value */ 3 10 2 name char (32), /* module name */ 3 11 2 info_ptr ptr; 3 12 3 13 declare sub_error_info_version_1 3 14 internal static options (constant) fixed bin init (1); 3 15 3 16 /* END INCLUDE FILE sub_error_info.incl.pl1 */ 519 520 4 1 /* BEGIN INCLUDE FILE ... condition_info.incl.pl1 */ 4 2 4 3 /* Structure for find_condition_info_. 4 4* 4 5* Written 1-Mar-79 by M. N. Davidoff. 4 6**/ 4 7 4 8 /* automatic */ 4 9 4 10 declare condition_info_ptr pointer; 4 11 4 12 /* based */ 4 13 4 14 declare 1 condition_info aligned based (condition_info_ptr), 4 15 2 mc_ptr pointer, /* pointer to machine conditions at fault time */ 4 16 2 version fixed binary, /* Must be 1 */ 4 17 2 condition_name char (32) varying, /* name of condition */ 4 18 2 info_ptr pointer, /* pointer to the condition data structure */ 4 19 2 wc_ptr pointer, /* pointer to wall crossing machine conditions */ 4 20 2 loc_ptr pointer, /* pointer to location where condition occured */ 4 21 2 flags unaligned, 4 22 3 crawlout bit (1), /* on if condition occured in lower ring */ 4 23 3 pad1 bit (35), 4 24 2 pad2 bit (36), 4 25 2 user_loc_ptr pointer, /* ptr to most recent nonsupport loc before condition occurred */ 4 26 2 pad3 (4) bit (36); 4 27 4 28 /* internal static */ 4 29 4 30 declare condition_info_version_1 4 31 fixed binary internal static options (constant) initial (1); 4 32 4 33 /* END INCLUDE FILE ... condition_info.incl.pl1 */ 521 522 5 1 /* BEGIN INCLUDE FILE condition_info_header.incl.pl1 BIM 1981 */ 5 2 /* format: style2 */ 5 3 5 4 declare condition_info_header_ptr 5 5 pointer; 5 6 declare 1 condition_info_header 5 7 aligned based (condition_info_header_ptr), 5 8 2 length fixed bin, /* length in words of this structure */ 5 9 2 version fixed bin, /* version number of this structure */ 5 10 2 action_flags aligned, /* tell handler how to proceed */ 5 11 3 cant_restart bit (1) unaligned, /* caller doesn't ever want to be returned to */ 5 12 3 default_restart bit (1) unaligned, /* caller can be returned to with no further action */ 5 13 3 quiet_restart bit (1) unaligned, /* return, and print no message */ 5 14 3 support_signal bit (1) unaligned, /* treat this signal as if the signalling procedure had the support bit set */ 5 15 /* if the signalling procedure had the support bit set, do the same for its caller */ 5 16 3 pad bit (32) unaligned, 5 17 2 info_string char (256) varying, /* may contain printable message */ 5 18 2 status_code fixed bin (35); /* if^=0, code interpretable by com_err_ */ 5 19 5 20 /* END INCLUDE FILE condition_info_header.incl.pl1 */ 523 524 6 1 /* BEGIN INCLUDE FILE...channel_meters.incl.pl1 */ 6 2 6 3 /* Include file to define meters reported by comm_meters_ for all channels */ 6 4 6 5 /* Created February 1981 by Robert Coren */ 6 6 6 7 dcl chan_meterp pointer; 6 8 6 9 dcl CHANNEL_METERS_VERSION_1 fixed bin int static options (constant) init (1); 6 10 6 11 dcl 1 channel_meters aligned based (chan_meterp), 6 12 2 version fixed bin, 6 13 2 multiplexer_type fixed bin, /* of this channel */ 6 14 2 parent_type fixed bin, /* multiplexer type of parent (or -1 if this is level 1 */ 6 15 2 line_type fixed bin, /* line type of this channel */ 6 16 2 flags, 6 17 3 reserved bit (36) unaligned, 6 18 2 pad1 fixed bin, 6 19 2 channel_name char (32), 6 20 2 mpx_specific_meterp pointer, /* pointer to meters for this channel's multiplexer type */ 6 21 2 parent_meterp pointer, /* pointer to meters kept for channel by its parent */ 6 22 2 next_channelp pointer, /* pointer to structure for next channel in list */ 6 23 2 cumulative, /* meters accumulated since last load of parent */ 6 24 3 unconverted_input_chars fixed bin (35), /* characters input (before conversion) */ 6 25 3 converted_output_chars fixed bin (35), /* characters output (after conversion) */ 6 26 3 read_calls fixed bin, /* calls to channel_manager$read */ 6 27 3 write_calls fixed bin, /* calls to channel_manager$write */ 6 28 3 control_calls fixed bin, /* calls to channel_manager$control */ 6 29 3 software_interrupts fixed bin, /* calls to channel$manager$interrupt on behalf of this channel */ 6 30 3 read_call_time fixed bin (71), /* time accumulated in channel_manager$read */ 6 31 3 write_call_time fixed bin (71), /* time accumulated in channel_manager$write */ 6 32 3 control_call_time fixed bin (71), /* time accumulated in channel_manager$control */ 6 33 3 interrupt_time fixed bin (71), /* time spent handling software interrupts */ 6 34 3 pad (4) fixed bin, 6 35 2 saved like channel_meters.cumulative; /* meters saved when channel last dialed up */ 6 36 6 37 /* END INCLUDE FILE...channel_meters.incl.pl1 */ 525 526 7 1 7 2 /* BEGIN INCLUDE FILE...fnp_meters.incl.pl1 */ 7 3 7 4 /* This include file defines structures used to return meters when 7 5** a get_meters order is issued for a whole FNP. 7 6**/ 7 7 7 8 /* Written December 1980 by Robert Coren */ 7 9 /* Modified February 1981 by Robert Coren to split off fnp_channel_meters */ 7 10 7 11 dcl fnp_meterp pointer; 7 12 7 13 dcl 1 fnp_global_meters based aligned, /* FNP-wide meters */ 7 14 2 channels_dialed_cum fixed bin (35), 7 15 2 channels_dialed_updates fixed bin (35), /* updates to above */ 7 16 2 space_available_cum fixed bin (35), 7 17 2 space_available_updates fixed bin (35), /* updates to above */ 7 18 2 input_mbx_in_use_cum fixed bin (35), 7 19 2 input_mbx_updates fixed bin (35), /* updates to above */ 7 20 2 cur_channels_dialed fixed bin (18) unsigned unaligned, 7 21 2 space_alloc_failures fixed bin (18) unsigned unaligned, 7 22 2 abnormal_dia_status fixed bin (18) unsigned unaligned, 7 23 2 buffer_pool fixed bin (18) unsigned unaligned, 7 24 2 buffer_allocations fixed bin (35), 7 25 2 buffers_preallocated fixed bin (35), 7 26 2 used_preallocated_buffer fixed bin (35), 7 27 2 no_preallocated_available fixed bin (35), 7 28 2 time_booted fixed bin (71), 7 29 2 total_idle_count fixed bin (35), 7 30 2 idle_count_updates fixed bin (35), 7 31 2 max_idle_count fixed bin (35), 7 32 2 min_idle_count fixed bin (35), 7 33 2 memory_parity_errors fixed bin (35); 7 34 7 35 dcl 1 fnp_meters based (fnp_meterp) aligned, /* structure for returning FNP-wide meters kept by FNP and ring 0 */ 7 36 2 version fixed bin, 7 37 2 pad fixed bin, 7 38 2 from_fnp like fnp_global_meters, 7 39 2 n_channels fixed bin, 7 40 2 output_mbx_in_use_cum fixed bin (35), 7 41 2 output_mbx_updates fixed bin (35), 7 42 2 output_mbx_unavailable fixed bin (35), 7 43 2 max_output_mbx_in_use fixed bin, 7 44 2 queue_entries_made fixed bin (35), 7 45 2 input_rejects fixed bin, 7 46 2 processed_from_q fixed bin (35), 7 47 2 fnp_channel_locked fixed bin (35), 7 48 2 input_data_transactions fixed bin (35), 7 49 2 output_data_transactions fixed bin (35), 7 50 2 input_control_transactions fixed bin (35), 7 51 2 output_control_transactions fixed bin (35), 7 52 2 fnp_space_restricted_output fixed bin, 7 53 2 fnp_mem_size fixed bin, 7 54 2 iom_number fixed bin, 7 55 2 iom_chan_no fixed bin; 7 56 7 57 dcl FNP_METERS_VERSION_2 fixed bin int static options (constant) init (2); 7 58 7 59 /* END INCLUDE FILE...fnp_meters.incl.pl1 */ 527 528 8 1 /* BEGIN INCLUDE FILE event_call_info.incl.pl1 */ 8 2 8 3 /* T. Casey, May 1978 */ 8 4 8 5 dcl event_call_info_ptr ptr; 8 6 8 7 dcl 1 event_call_info aligned based (event_call_info_ptr), /* argument structure passed to event call procedure */ 8 8 2 channel_id fixed bin (71), /* event channel on which wakeup occurred */ 8 9 2 message fixed bin (71), /* 72 bits of information passed by sender of wakeup */ 8 10 2 sender bit (36), /* process id of sender */ 8 11 2 origin, 8 12 3 dev_signal bit (18) unaligned, /* "1"b if device signal */ 8 13 3 ring fixed bin (17) unaligned, /* ring from which sent */ 8 14 2 data_ptr ptr; /* ptr given to dcl_event_call_channel */ 8 15 8 16 /* END INCLUDE FILE event_call_info.incl.pl1 */ 529 530 531 end meter_fnp_idle; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 04/08/85 1134.0 meter_fnp_idle.pl1 >spec>on>41-15>meter_fnp_idle.pl1 515 1 03/26/82 1716.4 fnp_idle_data.incl.pl1 >ldd>include>fnp_idle_data.incl.pl1 517 2 04/09/85 1109.7 access_mode_values.incl.pl1 >spec>on>41-15>access_mode_values.incl.pl1 519 3 07/18/81 1100.0 sub_error_info.incl.pl1 >ldd>include>sub_error_info.incl.pl1 521 4 06/28/79 1204.8 condition_info.incl.pl1 >ldd>include>condition_info.incl.pl1 523 5 03/24/82 1347.2 condition_info_header.incl.pl1 >ldd>include>condition_info_header.incl.pl1 525 6 06/19/81 2115.0 channel_meters.incl.pl1 >ldd>include>channel_meters.incl.pl1 527 7 03/29/82 1006.8 fnp_meters.incl.pl1 >ldd>include>fnp_meters.incl.pl1 529 8 06/29/79 1728.0 event_call_info.incl.pl1 >ldd>include>event_call_info.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. CHANNEL_METERS_VERSION_1 000046 constant fixed bin(17,0) initial dcl 6-9 set ref 340* COMMAND_NAME 000001 constant char(14) initial unaligned dcl 76 set ref 105* 111* 120* 129* 134* 144* 162* 176* 187* 195* 209* 215* 223* 232* 240* 259* 267* 277* 464* 471* 482* FNP_IDLE_DATA_VERSION_1 constant fixed bin(17,0) initial dcl 1-32 ref 488 RW_ACCESS_BIN 000000 constant fixed bin(5,0) initial dcl 2-36 set ref 461* a_code parameter fixed bin(35,0) dcl 417 set ref 410 465* 473* 483* 497* areap 000202 automatic pointer dcl 37 set ref 338* 340* 344* 399* arg based char unaligned dcl 46 set ref 124 126* 129* 134* 138 141 141 156 156 167 173* 176* 183 200 206* 209* 215* arg_event_call_info_ptr parameter pointer dcl 287 ref 282 289 argl 000214 automatic fixed bin(21,0) dcl 45 set ref 117* 124 126 126 129 129 134 134 138 141 141 156 156 159* 167 173 173 176 176 183 192* 200 206 206 209 209 215 215 argp 000212 automatic pointer dcl 44 set ref 117* 124 126 129 134 138 141 141 156 156 159* 167 173 176 183 192* 200 206 209 215 auto_cond_info 000102 automatic structure level 1 dcl 314 set ref 317 chan_meterp 000240 automatic pointer dcl 6-7 set ref 340* 344* 345 399* channel_id based fixed bin(71,0) level 2 dcl 8-7 ref 291 channel_meters based structure level 1 dcl 6-11 cleanup 000216 stack reference condition dcl 95 ref 344 400 code 000100 automatic fixed bin(35,0) dcl 312 in on unit on line 306 set ref 318* 319 333* code 000166 automatic fixed bin(35,0) dcl 30 in procedure "meter_fnp_idle" set ref 102* 103 105* 117* 118 120* 159* 160 162* 169* 173* 174 176* 192* 193 195* 202* 206* 207 255* 256 258* 259* 263* 264 266* 267* 273* 274 276* 277* 340* 342 352* 353 364* 365 399* code 000354 automatic fixed bin(35,0) dcl 433 in procedure "setup_data_segment" set ref 461* 464* 465 469 471* 473 474* 479* 480 482* 483 484* code 000364 automatic fixed bin(35,0) dcl 506 in procedure "wrapup_data_segment" set ref 508* com_err_ 000224 constant entry external dcl 49 ref 105 120 129 134 144 162 176 187 195 209 215 223 232 240 259 267 277 464 471 482 com_err_$suppress_name 000226 constant entry external dcl 50 ref 111 comm_meters_ 000262 constant entry external dcl 64 ref 340 comm_meters_$free 000264 constant entry external dcl 65 ref 344 399 comm_meters_chan_name 000200 automatic char(1) array unaligned dcl 36 set ref 337* 340* condition_info based structure level 1 dcl 4-14 condition_info_header based structure level 1 dcl 5-6 condition_info_ptr 000236 automatic pointer dcl 4-10 set ref 317* 318* 322 322 327 condition_name 3 based varying char(32) level 2 dcl 4-14 ref 322 continue_to_signal_ 000230 constant entry external dcl 51 ref 333 convert_ipc_code_ 000252 constant entry external dcl 60 ref 258 266 276 cu_$arg_count 000222 constant entry external dcl 48 ref 102 cu_$arg_ptr 000232 constant entry external dcl 52 ref 117 159 192 cumulative 24 based structure level 2 dcl 6-11 cv_dec_check_ 000234 constant entry external dcl 53 ref 206 data_ptr 6 based pointer level 2 dcl 8-7 ref 290 data_seg_ptr 6 based pointer level 2 dcl 82 set ref 251* 349 494* 508* 509* day 000341 automatic fixed bin(17,0) dcl 422 set ref 450* 452 decode_clock_value_$date_time 000300 constant entry external dcl 435 ref 450 delta_idle 000211 automatic fixed bin(35,0) dcl 42 set ref 375* 388 390 dirname 000104 automatic char(168) unaligned dcl 28 in procedure "meter_fnp_idle" set ref 99* 173* 180* 180* 227 dirname 000256 automatic char(168) unaligned dcl 419 in procedure "setup_data_segment" set ref 446* 448* 461* 464* 464* 471* 471* 482* 482* entries 22 based structure array level 2 dcl 1-8 set ref 491 entries_used 20 based fixed bin(17,0) level 2 dcl 1-8 set ref 360 372 396* entryname 000156 automatic char(32) unaligned dcl 29 in procedure "meter_fnp_idle" set ref 173* 180* entryname 000330 automatic char(32) unaligned dcl 420 in procedure "setup_data_segment" set ref 458* 461* 464* 464* 471* 471* 482* 482* error_table_$action_not_performed 000270 external static fixed bin(35,0) dcl 68 set ref 240* error_table_$badopt 000276 external static fixed bin(35,0) dcl 68 set ref 215* error_table_$inconsistent 000272 external static fixed bin(35,0) dcl 68 set ref 134* 144* 187* error_table_$namedup 000314 external static fixed bin(35,0) dcl 444 ref 469 error_table_$noarg 000274 external static fixed bin(35,0) dcl 68 set ref 169 202 223* event_call_info based structure level 1 dcl 8-7 event_call_info_ptr 000244 automatic pointer dcl 8-5 set ref 289* 290 291 event_channel_name based fixed bin(71,0) level 2 dcl 82 set ref 255* 263* 273* 291 406* event_message 000176 automatic fixed bin(71,0) dcl 35 set ref 271* 273* expand_pathname_ 000240 constant entry external dcl 55 ref 173 find_condition_info_ 000236 constant entry external dcl 54 ref 318 flags 12 based structure level 2 dcl 82 set ref 253* fnp_global_meters based structure level 1 dcl 7-13 fnp_idle_data based structure level 1 dcl 1-8 fnp_idle_data_ptr 000232 automatic pointer dcl 1-30 set ref 349* 350 360 360 372 375 377 378 379 381 381 384 385 388 388 390 391 394 395 396 397 461* 462 474* 475* 479* 484* 488 489 490 491 491 491 494 fnp_idle_entry based structure level 1 dcl 1-25 ref 491 fnp_meterp 000242 automatic pointer dcl 7-11 set ref 345* 346 373 374 379 381 384 fnp_meters based structure level 1 dcl 7-35 fnp_name 10 based char(1) level 2 in structure "meter_fnp_idle_info" dcl 82 in procedure "meter_fnp_idle" set ref 252* 337 458* 471* fnp_name 000100 automatic char(1) unaligned dcl 24 in procedure "meter_fnp_idle" set ref 97* 132 134* 138* 221 232* 240* 252 fnp_no 000174 automatic fixed bin(17,0) dcl 34 set ref 126* 127 229 271 from_fnp 2 based structure level 2 dcl 7-35 ref 346 get_process_id_ 000244 constant entry external dcl 57 ref 273 273 get_system_free_area_ 000260 constant entry external dcl 63 ref 338 get_wdir_ 000304 constant entry external dcl 439 ref 446 hcs_$make_seg 000306 constant entry external dcl 440 ref 461 hcs_$set_max_length_seg 000310 constant entry external dcl 442 ref 479 hcs_$terminate_noname 000316 constant entry external dcl 505 in procedure "wrapup_data_segment" ref 508 hcs_$terminate_noname 000312 constant entry external dcl 443 in procedure "setup_data_segment" ref 474 484 hcs_$wakeup 000256 constant entry external dcl 62 ref 273 hour 000343 automatic fixed bin(17,0) dcl 424 set ref 450* 454 iarg 000170 automatic fixed bin(17,0) dcl 32 set ref 116* 117* 158* 158 159* 191* 191 192* idle_count 000207 automatic fixed bin(35,0) dcl 40 in procedure "meter_fnp_idle" set ref 373* 375 377 394 idle_count 22 based fixed bin(35,0) array level 3 in structure "fnp_idle_data" dcl 1-8 in procedure "meter_fnp_idle" set ref 377* idle_count_updates 21 based fixed bin(35,0) level 3 dcl 7-35 ref 374 idle_updates 000210 automatic fixed bin(35,0) dcl 41 set ref 374* 378 395 info_ptr 14 based pointer level 2 dcl 4-14 ref 322 327 infop 000172 automatic pointer dcl 33 set ref 229* 232 234 238 248 249 250 251 252 253 255 263 263* 272 273 290* 291 295 295 297 297 297 299 302 302 337 349 355 367 406 406 458 458 471 490 494 495 496 508 509 510 510 interval 4 based fixed bin(71,0) level 2 dcl 82 set ref 250* 297 490 ioa_$rsnnl 000302 constant entry external dcl 438 ref 458 ipc_$create_ev_chn 000250 constant entry external dcl 59 ref 255 ipc_$decl_ev_call_chn 000254 constant entry external dcl 61 ref 263 last_time 4 based fixed bin(71,0) level 2 dcl 1-8 set ref 397* latest_idle_count 15 based fixed bin(35,0) level 2 dcl 1-8 set ref 375 394* latest_sample_count 16 based fixed bin(35,0) level 2 dcl 1-8 set ref 395* max_entries 17 based fixed bin(17,0) level 2 dcl 1-8 set ref 360 491* max_idle_count 22 based fixed bin(35,0) level 3 dcl 7-35 ref 379 maximum_idle_count 14 based fixed bin(35,0) level 2 dcl 1-8 set ref 379* meter_fnp_idle_info based structure level 1 dcl 82 meter_fnp_idle_info_array 000062 internal static structure array level 1 dcl 80 set ref 229 meter_time 000204 automatic fixed bin(71,0) dcl 38 set ref 294* 295 385 391 397 450* 489 min_idle_count 23 based fixed bin(35,0) level 3 dcl 7-35 ref 381 384 minimum_delta_idle 13 based fixed bin(35,0) level 2 dcl 1-8 set ref 388 388 390* minimum_idle_count 12 based fixed bin(35,0) level 2 dcl 1-8 set ref 381 381 384* minute 000344 automatic fixed bin(17,0) dcl 425 set ref 450* 455 minutes 11 based fixed bin(17,0) level 2 in structure "meter_fnp_idle_info" dcl 82 in procedure "meter_fnp_idle" set ref 248* 458* minutes 000101 automatic fixed bin(17,0) dcl 25 in procedure "meter_fnp_idle" set ref 98* 185 206* 245 245* 248 250 month 000340 automatic fixed bin(17,0) dcl 421 set ref 450* 451 mpx_specific_meterp 16 based pointer level 2 dcl 6-11 ref 345 name 106 based char(32) level 2 dcl 3-7 ref 328 nargs 000167 automatic fixed bin(17,0) dcl 31 set ref 102* 109 116 next_cycle_sched 2 based fixed bin(71,0) level 2 dcl 82 set ref 249* 295 295* 297* 297 406* next_entry 000206 automatic fixed bin(17,0) dcl 39 set ref 372* 377 378 396 non_stop 000103 automatic bit(1) unaligned dcl 27 set ref 100* 141 154* parse_fnp_name_ 000246 constant entry external dcl 58 ref 126 pass_on 000101 automatic bit(1) unaligned dcl 313 set ref 316* 319* 322* 328* 333 pathname_ 000242 constant entry external dcl 56 ref 180 464 464 471 471 482 482 pic_day 000347 automatic picture(2) unaligned dcl 428 set ref 452* 458* pic_hour 000351 automatic picture(2) unaligned dcl 430 set ref 454* 458* pic_minute 000352 automatic picture(2) unaligned dcl 431 set ref 455* 458* pic_month 000346 automatic picture(2) unaligned dcl 427 set ref 451* 458* pic_second 000353 automatic picture(2) unaligned dcl 432 set ref 456* 458* pic_year 000350 automatic picture(2) unaligned dcl 429 set ref 453* 458* running 12 based bit(1) level 3 packed unaligned dcl 82 set ref 232 238 272* 302* 355* 367* 496* sample_count 23 based fixed bin(35,0) array level 3 dcl 1-8 set ref 378* sample_interval 1 based fixed bin(17,0) level 2 dcl 1-8 set ref 490* second 000345 automatic fixed bin(17,0) dcl 426 set ref 450* 456 static_dirname 000010 internal static char(168) unaligned dcl 78 set ref 227* 446 448 stop 000102 automatic bit(1) unaligned dcl 26 set ref 100* 149* 151 230 stop_requested 12(02) based bit(1) level 3 packed unaligned dcl 82 set ref 234* 299 302* 510 sub_error_ 000224 stack reference condition dcl 95 ref 306 sub_error_info based structure level 1 dcl 3-7 sub_error_info_ptr 000234 automatic pointer dcl 3-6 set ref 327* 328 suspended 12(01) based bit(1) level 3 packed unaligned dcl 82 set ref 495* 510* time_of_minimum_average 10 based fixed bin(71,0) level 2 dcl 1-8 set ref 391* time_of_minimum_sample 6 based fixed bin(71,0) level 2 dcl 1-8 set ref 385* time_started 2 based fixed bin(71,0) level 2 dcl 1-8 set ref 489* timer_manager_$alarm_wakeup 000266 constant entry external dcl 66 ref 406 total_idle_count 20 based fixed bin(35,0) level 3 dcl 7-35 ref 373 version based fixed bin(17,0) level 2 dcl 1-8 set ref 488* year 000342 automatic fixed bin(17,0) dcl 423 set ref 450* 453 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. A_ACCESS internal static bit(3) initial unaligned dcl 2-11 A_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 DIR_ACCESS_MODE_NAMES internal static char(4) initial array unaligned dcl 2-33 E_ACCESS internal static bit(3) initial unaligned dcl 2-11 E_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 FNP_METERS_VERSION_2 internal static fixed bin(17,0) initial dcl 7-57 M_ACCESS internal static bit(3) initial unaligned dcl 2-11 M_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 N_ACCESS internal static bit(3) initial unaligned dcl 2-11 N_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 REW_ACCESS internal static bit(3) initial unaligned dcl 2-11 REW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 RE_ACCESS internal static bit(3) initial unaligned dcl 2-11 RE_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 RW_ACCESS internal static bit(3) initial unaligned dcl 2-11 R_ACCESS internal static bit(3) initial unaligned dcl 2-11 R_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 SA_ACCESS internal static bit(3) initial unaligned dcl 2-11 SA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 SEG_ACCESS_MODE_NAMES internal static char(4) initial array unaligned dcl 2-30 SMA_ACCESS internal static bit(3) initial unaligned dcl 2-11 SMA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 SM_ACCESS internal static bit(3) initial unaligned dcl 2-11 SM_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 S_ACCESS internal static bit(3) initial unaligned dcl 2-11 S_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 W_ACCESS internal static bit(3) initial unaligned dcl 2-11 W_ACCESS_BIN internal static fixed bin(5,0) initial dcl 2-36 condition_info_header_ptr automatic pointer dcl 5-4 condition_info_version_1 internal static fixed bin(17,0) initial dcl 4-30 error_table_$too_many_args external static fixed bin(35,0) dcl 68 hcs_$truncate_seg 000000 constant entry external dcl 441 max_fnp_idle_entries automatic fixed bin(17,0) dcl 1-29 sub_error_info_version_1 internal static fixed bin(17,0) initial dcl 3-13 NAMES DECLARED BY EXPLICIT CONTEXT. NO_DIR 000752 constant label dcl 162 ref 170 NO_INTERVAL 001163 constant label dcl 195 ref 203 STOP_ERROR 000665 constant label dcl 144 ref 151 idle_wakeup 001745 constant entry external dcl 282 ref 263 263 meter_fnp_idle 000347 constant entry external dcl 12 setup_data_segment 002372 constant entry internal dcl 410 ref 352 364 wrapup_data_segment 003174 constant entry internal dcl 502 ref 301 346 363 404 NAMES DECLARED BY CONTEXT OR IMPLICATION. addr builtin function ref 229 317 491 bin builtin function ref 491 clock builtin function ref 294 codeptr builtin function ref 263 263 divide builtin function ref 491 mod builtin function ref 453 null builtin function ref 251 318 318 322 350 462 475 509 rel builtin function ref 491 size builtin function ref 491 string builtin function ref 253 substr builtin function ref 124 167 200 unspec builtin function ref 346 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 3646 4166 3234 3656 Length 4614 3234 320 412 411 212 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME meter_fnp_idle 478 external procedure is an external procedure. on unit on line 306 102 on unit on unit on line 344 74 on unit setup_data_segment internal procedure shares stack frame of external procedure meter_fnp_idle. wrapup_data_segment internal procedure shares stack frame of external procedure meter_fnp_idle. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 static_dirname meter_fnp_idle 000062 meter_fnp_idle_info_array meter_fnp_idle STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME meter_fnp_idle 000100 fnp_name meter_fnp_idle 000101 minutes meter_fnp_idle 000102 stop meter_fnp_idle 000103 non_stop meter_fnp_idle 000104 dirname meter_fnp_idle 000156 entryname meter_fnp_idle 000166 code meter_fnp_idle 000167 nargs meter_fnp_idle 000170 iarg meter_fnp_idle 000172 infop meter_fnp_idle 000174 fnp_no meter_fnp_idle 000176 event_message meter_fnp_idle 000200 comm_meters_chan_name meter_fnp_idle 000202 areap meter_fnp_idle 000204 meter_time meter_fnp_idle 000206 next_entry meter_fnp_idle 000207 idle_count meter_fnp_idle 000210 idle_updates meter_fnp_idle 000211 delta_idle meter_fnp_idle 000212 argp meter_fnp_idle 000214 argl meter_fnp_idle 000232 fnp_idle_data_ptr meter_fnp_idle 000234 sub_error_info_ptr meter_fnp_idle 000236 condition_info_ptr meter_fnp_idle 000240 chan_meterp meter_fnp_idle 000242 fnp_meterp meter_fnp_idle 000244 event_call_info_ptr meter_fnp_idle 000256 dirname setup_data_segment 000330 entryname setup_data_segment 000340 month setup_data_segment 000341 day setup_data_segment 000342 year setup_data_segment 000343 hour setup_data_segment 000344 minute setup_data_segment 000345 second setup_data_segment 000346 pic_month setup_data_segment 000347 pic_day setup_data_segment 000350 pic_year setup_data_segment 000351 pic_hour setup_data_segment 000352 pic_minute setup_data_segment 000353 pic_second setup_data_segment 000354 code setup_data_segment 000364 code wrapup_data_segment on unit on line 306 000100 code on unit on line 306 000101 pass_on on unit on line 306 000102 auto_cond_info on unit on line 306 THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out return mod_fx1 enable ext_entry int_entry clock THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ com_err_$suppress_name comm_meters_ comm_meters_$free continue_to_signal_ convert_ipc_code_ cu_$arg_count cu_$arg_ptr cv_dec_check_ decode_clock_value_$date_time expand_pathname_ find_condition_info_ get_process_id_ get_system_free_area_ get_wdir_ hcs_$make_seg hcs_$set_max_length_seg hcs_$terminate_noname hcs_$terminate_noname hcs_$wakeup ioa_$rsnnl ipc_$create_ev_chn ipc_$decl_ev_call_chn parse_fnp_name_ pathname_ timer_manager_$alarm_wakeup THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$action_not_performed error_table_$badopt error_table_$inconsistent error_table_$namedup error_table_$noarg LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 12 000346 97 000354 98 000356 99 000357 100 000362 102 000364 103 000374 105 000376 106 000413 109 000414 111 000416 113 000443 116 000444 117 000453 118 000470 120 000472 121 000507 124 000510 126 000515 127 000535 129 000537 130 000573 132 000574 134 000604 136 000643 138 000644 139 000651 141 000652 144 000665 147 000711 149 000712 151 000715 154 000717 156 000721 158 000732 159 000733 160 000750 162 000752 164 000776 167 000777 169 001004 170 001007 173 001010 174 001040 176 001042 177 001066 180 001067 181 001107 183 001110 185 001114 187 001116 189 001142 191 001143 192 001144 193 001161 195 001163 197 001207 200 001210 202 001215 203 001220 206 001221 207 001245 209 001247 210 001303 212 001304 215 001305 216 001330 219 001331 221 001333 223 001343 224 001367 227 001370 229 001374 230 001400 232 001402 234 001436 235 001440 238 001441 240 001444 242 001473 245 001474 248 001500 249 001501 250 001503 251 001506 252 001510 253 001513 255 001514 256 001524 258 001526 259 001535 260 001561 263 001562 264 001605 266 001607 267 001616 268 001642 271 001643 272 001646 273 001651 274 001704 276 001706 277 001715 280 001741 282 001742 289 001752 290 001756 291 001760 294 001763 295 001765 297 001771 299 001774 301 001777 302 002000 303 002005 306 002006 316 002022 317 002023 318 002026 319 002042 322 002047 327 002065 328 002067 333 002075 335 002106 337 002107 338 002112 340 002121 342 002155 344 002157 345 002210 346 002213 349 002221 350 002224 352 002230 353 002232 355 002234 356 002237 360 002240 363 002244 364 002245 365 002247 367 002251 368 002254 372 002255 373 002261 374 002264 375 002266 377 002274 378 002301 379 002303 381 002305 384 002311 385 002313 388 002315 390 002321 391 002323 394 002325 395 002327 396 002331 397 002333 399 002335 400 002350 402 002351 404 002352 406 002353 408 002371 410 002372 446 002374 448 002410 450 002413 451 002454 452 002464 453 002474 454 002510 455 002520 456 002530 458 002540 461 002621 462 002656 464 002662 465 002735 466 002740 469 002741 471 002745 473 003021 474 003024 475 003035 476 003037 479 003040 480 003054 482 003056 483 003126 484 003131 485 003142 488 003143 489 003145 490 003150 491 003153 494 003163 495 003164 496 003167 497 003171 498 003173 502 003174 508 003175 509 003207 510 003212 512 003220 ----------------------------------------------------------- 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