COMPILATION LISTING OF SEGMENT dm_log_read_inner_ Compiled by: Multics PL/I Compiler, Release 33e, of October 6, 1992 Compiled at: CGI Compiled on: 2000-04-17_1932.05_Mon_mdt Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1985 * 4* * * 5* *********************************************************** */ 6 /* format: style4,ifthenstmt,^indproc */ 7 /* --------------- */ 8 9 dm_log_read_inner_: procedure; 10 11 /* DESCRIPTION: 12* 13* This procedure contains entry points with the same calling sequences 14* as log_read_, but used instead to read ring-2 DM log segments. 15**/ 16 17 /* HISTORY: 18* 19* Written by Steve Herbst, 11/30/84 20* Modified: 21* 12/06/84 by Steve Herbst: Added $get_log_uid, $free_message, $register, and $deregister. 22* 1984-12-12, BIM: corrected open calling sequence. 23* 1985-01-11, Steve Herbst: Alphabetized internal procedures. 24* 1985-02-07, Steve Herbst: Changed to call dm_misc_util_$get_log_path instead of $get_aim_dir. 25* 1985-03-07, Steve Herbst: Changed in response to audit. Replaced FINISHED 26* and FINISHED_NO_CODE procs with ERROR_RETURN proc and RETURN label; 27* changed to compare log uid's not pathnames. 28* 1985-03-11, Steve Herbst: Fixed $(next prev)_message to make a real 29* inner-ring copy of P_log_message_ptr to pass to log_read_. 30* 1985-03-13, Steve Herbst: Fixed $update, $(hold free)_message to do same. 31* 1985-03-20, Steve Herbst: Fixed to allow up to 10 openings of the DM log per process. 32**/ 33 34 35 /* DECLARATIONS */ 36 37 /* Parameters */ 38 39 dcl P_log_dname char (*); 40 dcl P_log_ename char (*); 41 dcl P_area_ptr ptr; 42 dcl P_log_read_data_ptr ptr; 43 dcl P_log_message_ptr ptr; 44 dcl P_message_sequence fixed bin (35); 45 dcl P_message_time fixed bin (71); 46 dcl P_event_channel fixed bin (71); 47 dcl P_search_direction bit (1) aligned; 48 dcl P_log_uid bit (36) aligned; 49 dcl P_process_id bit (36) aligned; 50 dcl P_code fixed bin (35); 51 52 53 /* Constants */ 54 55 dcl ME char (32) int static options (constant) init ("dm_log_read_inner_"); 56 57 /* Static */ 58 59 dcl static_log_read_ptr (10) ptr int static init ((10)null); 60 61 /* Automatic */ 62 63 dcl 1 auto_status_branch aligned like status_branch; 64 65 dcl log_dname char (168); 66 dcl log_ename char (32); 67 dcl log_read_data_ptr pointer; 68 dcl log_message_ptr pointer; 69 dcl search_direction bit (1) aligned; 70 dcl opening_index fixed bin; 71 dcl message_sequence fixed bin (35); 72 dcl message_time fixed bin (71); 73 dcl process_id bit (36) aligned; 74 dcl event_channel fixed bin (71); 75 dcl (log_uid, true_uid) bit (36) aligned; 76 dcl area_ptr ptr; 77 dcl code fixed bin (35); 78 dcl (dm_system_log_path, true_dir_name) char (168); 79 dcl true_entryname char (32); 80 dcl saved_validation fixed bin (3); 81 82 dcl 1 log_open_info aligned like log_read_open_info; 83 84 /* External */ 85 86 dcl error_table_$badcall fixed bin (35) ext; 87 dcl error_table_$not_closed fixed bin (35) ext static; 88 dcl error_table_$not_open fixed bin (35) ext static; 89 dcl error_table_$not_seg_type fixed bin (35) ext static; 90 dcl error_table_$null_info_ptr fixed bin (35) ext static; 91 dcl error_table_$out_of_sequence fixed bin (35) ext; 92 93 /* Entries */ 94 95 declare cu_$level_get entry returns (fixed bin (3)); 96 declare cu_$level_set entry (fixed bin (3)); 97 declare expand_pathname_ entry (char(*), char(*), char(*), fixed bin(35)); 98 declare get_ring_ entry () returns (fixed bin (3)); 99 declare dm_misc_util_$get_log_path entry (char (*)); 100 declare hcs_$status_long entry (char(*), char(*), fixed bin(1), ptr, ptr, fixed bin(35)); 101 declare log_read_$open_long entry (character (*), character (*), pointer, pointer, fixed binary (35)); 102 declare log_read_$close entry (pointer, fixed binary (35)); 103 declare log_read_$position_time entry (pointer, fixed binary (71), bit (1) aligned, pointer, fixed binary (35)); 104 declare log_read_$position_sequence entry (pointer, fixed binary (35), bit (1) aligned, pointer, 105 fixed binary (35)); 106 declare log_read_$next_message entry (pointer, pointer, fixed binary (35)); 107 declare log_read_$prev_message entry (pointer, pointer, fixed binary (35)); 108 declare log_read_$get_log_uid entry (pointer, bit (36) aligned, fixed binary (35)); 109 declare log_read_$update entry (fixed binary (35), pointer, pointer, fixed binary (35)); 110 declare log_read_$register entry (pointer, bit (36) aligned, fixed binary (71), fixed binary (35)); 111 declare log_read_$deregister entry (pointer, bit (36) aligned, fixed binary (71), fixed binary (35)); 112 declare log_read_$hold_message entry (pointer, pointer); 113 declare log_read_$free_message entry (pointer, pointer); 114 declare sub_err_ entry() options(variable); 115 116 /* Builtins */ 117 118 dcl (addr, baseno, baseptr, hbound, null, pointer, rel) builtin; 119 120 /* Conditions */ 121 122 dcl cleanup condition; 123 124 /* END OF DECLARATIONS */ 125 126 dm_log_read_inner_$open: 127 entry (P_log_dname, P_log_ename, P_area_ptr, P_log_read_data_ptr, P_code); 128 129 /* Opens a log for reading */ 130 131 log_dname = P_log_dname; 132 log_ename = P_log_ename; 133 area_ptr = P_area_ptr; 134 P_log_read_data_ptr = null; 135 code = 0; 136 137 saved_validation = -1; 138 on cleanup call CLEAN_UP; 139 saved_validation = cu_$level_get (); 140 141 do opening_index = 1 to hbound (static_log_read_ptr, 1) 142 while (static_log_read_ptr (opening_index) ^= null); 143 end; 144 if opening_index > hbound (static_log_read_ptr, 1) then 145 call sub_err_ (error_table_$not_closed, ME, ACTION_CANT_RESTART, null, 0, 146 "The DM system log can only be opened ^d times per process.", hbound (static_log_read_ptr, 1)); 147 148 call cu_$level_set (get_ring_ ()); 149 150 call dm_misc_util_$get_log_path (dm_system_log_path); 151 call expand_pathname_ (dm_system_log_path, true_dir_name, true_entryname, 0); 152 call hcs_$status_long (true_dir_name, true_entryname, 0, addr (auto_status_branch), null, 0); 153 true_uid = auto_status_branch.uid; 154 call hcs_$status_long (log_dname, log_ename, 0, addr (auto_status_branch), null, 0); 155 if auto_status_branch.uid ^= true_uid 156 then call ERROR_RETURN (error_table_$not_seg_type); 157 /* Only permit opens of the current DM system log for now */ 158 159 if area_ptr = null () 160 then call ERROR_RETURN (error_table_$null_info_ptr); 161 162 log_open_info.version = LOG_READ_OPEN_INFO_VERSION_1; 163 log_open_info.reader_procedure = ""; 164 log_open_info.allocation_area_ptr = area_ptr; 165 log_open_info.allocate_copies = "1"b; 166 167 call log_read_$open_long (log_dname, log_ename, addr (log_open_info), 168 static_log_read_ptr (opening_index), code); 169 if code = 0 then P_log_read_data_ptr = static_log_read_ptr (opening_index); 170 P_code = code; 171 RETURN: 172 call CLEAN_UP; 173 174 return; 175 176 dm_log_read_inner_$close: 177 entry (P_log_read_data_ptr, P_code); 178 179 /* Closes a log */ 180 181 saved_validation = -1; 182 on cleanup call CLEAN_UP; 183 184 call VALIDATE (); 185 186 call log_read_$close (log_read_data_ptr, code); 187 if code = 0 then static_log_read_ptr (opening_index) = null; 188 else call ERROR_RETURN (code); 189 190 P_code = 0; 191 go to RETURN; 192 193 dm_log_read_inner_$next_message: 194 entry (P_log_read_data_ptr, P_log_message_ptr, P_code); 195 196 /* Positions to the next message after P_log_message_ptr */ 197 198 saved_validation = -1; 199 on cleanup call CLEAN_UP; 200 201 call VALIDATE (); 202 203 log_message_ptr = INNER_RING_POINTER (P_log_message_ptr); 204 /* OK to do this because log_read_ validates the ptr */ 205 206 call log_read_$next_message (log_read_data_ptr, log_message_ptr, code); 207 if code ^= 0 then call ERROR_RETURN (code); 208 209 P_log_message_ptr = log_message_ptr; 210 P_code = 0; 211 go to RETURN; 212 213 dm_log_read_inner_$prev_message: 214 entry (P_log_read_data_ptr, P_log_message_ptr, P_code); 215 216 /* Positions to the message previous to P_log_message_ptr */ 217 218 saved_validation = -1; 219 on cleanup call CLEAN_UP; 220 221 call VALIDATE (); 222 223 log_message_ptr = INNER_RING_POINTER (P_log_message_ptr); 224 /* OK to do this because log_read_ validates the ptr */ 225 226 call log_read_$prev_message (log_read_data_ptr, log_message_ptr, code); 227 if code ^= 0 then call ERROR_RETURN (code); 228 229 P_log_message_ptr = log_message_ptr; 230 P_code = 0; 231 go to RETURN; 232 233 dm_log_read_inner_$position_sequence: 234 entry (P_log_read_data_ptr, P_message_sequence, P_search_direction, P_log_message_ptr, P_code); 235 236 /* Positions to the first/last message in sequence */ 237 238 saved_validation = -1; 239 on cleanup call CLEAN_UP; 240 241 call VALIDATE (); 242 243 message_sequence = P_message_sequence; 244 search_direction = P_search_direction; 245 246 call log_read_$position_sequence (log_read_data_ptr, message_sequence, 247 search_direction, log_message_ptr, code); 248 if code ^= 0 then call ERROR_RETURN (code); 249 250 P_log_message_ptr = log_message_ptr; 251 P_code = 0; 252 go to RETURN; 253 254 dm_log_read_inner_$position_time: 255 entry (P_log_read_data_ptr, P_message_time, P_search_direction, P_log_message_ptr, P_code); 256 257 /* Positions to the first/last message before/after a specified time */ 258 259 saved_validation = -1; 260 on cleanup call CLEAN_UP; 261 262 call VALIDATE (); 263 264 message_time = P_message_time; 265 search_direction = P_search_direction; 266 267 call log_read_$position_time (log_read_data_ptr, message_time, 268 search_direction, log_message_ptr, code); 269 if code ^= 0 then call ERROR_RETURN (code); 270 271 P_log_message_ptr = log_message_ptr; 272 P_code = 0; 273 go to RETURN; 274 275 dm_log_read_inner_$update: 276 entry (P_message_sequence, P_log_read_data_ptr, P_log_message_ptr, P_code); 277 278 /* Interface to log_read_$update */ 279 280 saved_validation = -1; 281 on cleanup call CLEAN_UP; 282 283 call VALIDATE (); 284 285 message_sequence = P_message_sequence; 286 log_message_ptr = INNER_RING_POINTER (P_log_message_ptr); 287 /* OK to do this because log_read_ validates the ptr */ 288 289 call log_read_$update (message_sequence, log_read_data_ptr, log_message_ptr, code); 290 if code ^= 0 then call ERROR_RETURN (code); 291 292 P_log_read_data_ptr, static_log_read_ptr (opening_index) = log_read_data_ptr; 293 P_log_message_ptr = log_message_ptr; 294 P_code = 0; 295 go to RETURN; 296 297 dm_log_read_inner_$hold_message: 298 entry (P_log_read_data_ptr, P_log_message_ptr); 299 300 /* Saves message so that it can be referenced by a call to $prev_message or $next_message */ 301 302 saved_validation = -1; 303 on cleanup call CLEAN_UP; 304 305 call VALIDATE (); 306 307 log_message_ptr = INNER_RING_POINTER (P_log_message_ptr); 308 /* OK to do this because log_read_ validates the ptr */ 309 310 call log_read_$hold_message (log_read_data_ptr, log_message_ptr); 311 go to RETURN; 312 313 dm_log_read_inner_$free_message: 314 entry (P_log_read_data_ptr, P_log_message_ptr); 315 316 /* Frees message held by $hold_message */ 317 318 saved_validation = -1; 319 on cleanup call CLEAN_UP; 320 321 call VALIDATE (); 322 323 log_message_ptr = INNER_RING_POINTER (P_log_message_ptr); 324 /* OK to do this because log_read_ validates the ptr */ 325 326 call log_read_$free_message (log_read_data_ptr, log_message_ptr); 327 go to RETURN; 328 329 dm_log_read_inner_$get_log_uid: 330 entry (P_log_read_data_ptr, P_log_uid, P_code); 331 332 /* Returns the uid of the log segment */ 333 334 saved_validation = -1; 335 on cleanup call CLEAN_UP; 336 337 call VALIDATE (); 338 339 call log_read_$get_log_uid (log_read_data_ptr, log_uid, code); 340 if code ^= 0 then call ERROR_RETURN (code); 341 342 P_log_uid = log_uid; 343 P_code = 0; 344 go to RETURN; 345 346 dm_log_read_inner_$register: 347 entry (P_log_read_data_ptr, P_process_id, P_event_channel, P_code); 348 349 /* Interface to log_read_$register */ 350 351 saved_validation = -1; 352 on cleanup call CLEAN_UP; 353 354 call VALIDATE (); 355 356 process_id = P_process_id; 357 event_channel = P_event_channel; 358 359 call log_read_$register (log_read_data_ptr, process_id, event_channel, code); 360 if code ^= 0 then call ERROR_RETURN (code); 361 362 P_code = 0; 363 go to RETURN; 364 365 dm_log_read_inner_$deregister: 366 entry (P_log_read_data_ptr, P_process_id, P_event_channel, P_code); 367 368 /* Interface to log_read_$deregister */ 369 370 saved_validation = -1; 371 on cleanup call CLEAN_UP; 372 373 call VALIDATE (); 374 375 process_id = P_process_id; 376 event_channel = P_event_channel; 377 378 call log_read_$deregister (log_read_data_ptr, process_id, event_channel, code); 379 if code ^= 0 then call ERROR_RETURN (code); 380 381 P_code = 0; 382 go to RETURN; 383 384 CLEAN_UP: proc; 385 386 if saved_validation ^= -1 then 387 call cu_$level_set (saved_validation); 388 389 end CLEAN_UP; 390 391 ERROR_RETURN: proc (P_local_code); 392 393 dcl P_local_code fixed bin (35); 394 395 P_code = P_local_code; 396 go to RETURN; 397 398 end ERROR_RETURN; 399 400 INNER_RING_POINTER: proc (P_ptr) returns (ptr); 401 402 dcl (P_ptr, inner_ring_ptr) ptr; 403 dcl (offset, segno) bit (18); 404 405 segno = baseno (P_ptr); 406 offset = rel (P_ptr); 407 inner_ring_ptr = pointer (baseptr (segno), offset); 408 return (inner_ring_ptr); 409 410 end INNER_RING_POINTER; 411 412 VALIDATE: 413 procedure; 414 415 log_read_data_ptr = P_log_read_data_ptr; 416 417 do opening_index = 1 to hbound (static_log_read_ptr, 1) 418 while (static_log_read_ptr (opening_index) ^= log_read_data_ptr); 419 end; 420 if opening_index > hbound (static_log_read_ptr, 1) then 421 call sub_err_ (error_table_$not_open, ME, ACTION_CANT_RESTART, null, 0, 422 "Invalid log_read_data_ptr ^p.", log_read_data_ptr); 423 424 saved_validation = cu_$level_get (); 425 call cu_$level_set (get_ring_ ()); 426 427 log_read_data_ptr = static_log_read_ptr (opening_index); /* take inner ring copy */ 428 429 return; 430 431 end VALIDATE; 432 1 1 /* Begin include file log_read_open_data.incl.pl1 BIM 1984-12-15 */ 1 2 /* Use this with log_read_$open_long to specify special purpose options */ 1 3 1 4 declare log_read_open_info_ptr pointer; 1 5 declare 1 log_read_open_info aligned based (log_read_open_info_ptr), 1 6 2 version char (8) aligned, 1 7 2 reader_procedure char (32) varying, /* this is an outer ring opening, and this procedure retrieves from the inner ring */ 1 8 2 allocation_area_ptr pointer, /* if reader_procedure is not "", */ 1 9 /* this is passed to it to for allocation */ 1 10 2 allocate_copies bit (1) aligned; /* incompatable with reader_procedure ^= "" */ 1 11 /* indicates that this opening must allocate copies for use by an outer ring */ 1 12 1 13 declare LOG_READ_OPEN_INFO_VERSION_1 1 14 char (8) init ("logro001") int static options (constant); 1 15 1 16 /* End include file log_read_open_info.incl.pl1 */ 433 434 2 1 /* --------------- BEGIN include file status_structures.incl.pl1 --------------- */ 2 2 2 3 /* Revised from existing include files 09/26/78 by C. D. Tavares */ 2 4 2 5 /* This include file contains branch and link structures returned by 2 6* hcs_$status_ and hcs_$status_long. */ 2 7 2 8 dcl 1 status_branch aligned based (status_ptr), 2 9 2 short aligned, 2 10 3 type fixed bin (2) unaligned unsigned, /* seg, dir, or link */ 2 11 3 nnames fixed bin (16) unaligned unsigned, /* number of names */ 2 12 3 names_relp bit (18) unaligned, /* see entry_names dcl */ 2 13 3 dtcm bit (36) unaligned, /* date/time contents last modified */ 2 14 3 dtu bit (36) unaligned, /* date/time last used */ 2 15 3 mode bit (5) unaligned, /* caller's effective access */ 2 16 3 raw_mode bit (5) unaligned, /* caller's raw "rew" modes */ 2 17 3 pad1 bit (8) unaligned, 2 18 3 records_used fixed bin (18) unaligned unsigned, /* number of NONZERO pages used */ 2 19 2 20 /* Limit of information returned by hcs_$status_ */ 2 21 2 22 2 long aligned, 2 23 3 dtd bit (36) unaligned, /* date/time last dumped */ 2 24 3 dtem bit (36) unaligned, /* date/time branch last modified */ 2 25 3 lvid bit (36) unaligned, /* logical volume ID */ 2 26 3 current_length fixed bin (12) unaligned unsigned, /* number of last page used */ 2 27 3 bit_count fixed bin (24) unaligned unsigned, /* reported length in bits */ 2 28 3 pad2 bit (8) unaligned, 2 29 3 copy_switch bit (1) unaligned, /* copy switch */ 2 30 3 tpd_switch bit (1) unaligned, /* transparent to paging device switch */ 2 31 3 mdir_switch bit (1) unaligned, /* is a master dir */ 2 32 3 damaged_switch bit (1) unaligned, /* salvager warned of possible damage */ 2 33 3 synchronized_switch bit (1) unaligned, /* DM synchronized file */ 2 34 3 pad3 bit (5) unaligned, 2 35 3 ring_brackets (0:2) fixed bin (6) unaligned unsigned, 2 36 3 uid bit (36) unaligned; /* unique ID */ 2 37 2 38 dcl 1 status_link aligned based (status_ptr), 2 39 2 type fixed bin (2) unaligned unsigned, /* as above */ 2 40 2 nnames fixed bin (16) unaligned unsigned, 2 41 2 names_relp bit (18) unaligned, 2 42 2 dtem bit (36) unaligned, 2 43 2 dtd bit (36) unaligned, 2 44 2 pathname_length fixed bin (17) unaligned, /* see pathname */ 2 45 2 pathname_relp bit (18) unaligned; /* see pathname */ 2 46 2 47 dcl status_entry_names (status_branch.nnames) character (32) aligned 2 48 based (pointer (status_area_ptr, status_branch.names_relp)), 2 49 /* array of names returned */ 2 50 status_pathname character (status_link.pathname_length) aligned 2 51 based (pointer (status_area_ptr, status_link.pathname_relp)), 2 52 /* link target path */ 2 53 status_area_ptr pointer, 2 54 status_ptr pointer; 2 55 2 56 dcl (Link initial (0), 2 57 Segment initial (1), 2 58 Directory initial (2)) fixed bin internal static options (constant); 2 59 /* values for type fields declared above */ 2 60 2 61 /* ---------------- END include file status_structures.incl.pl1 ---------------- */ 435 436 3 1 /* BEGIN INCLUDE FILE sub_err_flags.incl.pl1 BIM 11/81 */ 3 2 /* format: style3 */ 3 3 3 4 /* These constants are to be used for the flags argument of sub_err_ */ 3 5 /* They are just "string (condition_info_header.action_flags)" */ 3 6 3 7 declare ( 3 8 ACTION_CAN_RESTART init (""b), 3 9 ACTION_CANT_RESTART init ("1"b), 3 10 ACTION_DEFAULT_RESTART 3 11 init ("01"b), 3 12 ACTION_QUIET_RESTART 3 13 init ("001"b), 3 14 ACTION_SUPPORT_SIGNAL 3 15 init ("0001"b) 3 16 ) bit (36) aligned internal static options (constant); 3 17 3 18 /* End include file */ 437 438 439 440 end dm_log_read_inner_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 04/17/00 1932.0 dm_log_read_inner_.pl1 >udd>sm>ds>w>ml>dm_log_read_inner_.pl1 433 1 01/21/85 1012.3 log_read_open_info.incl.pl1 >ldd>incl>log_read_open_info.incl.pl1 435 2 11/22/82 1055.7 status_structures.incl.pl1 >ldd>incl>status_structures.incl.pl1 437 3 04/16/82 1058.1 sub_err_flags.incl.pl1 >ldd>incl>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 000013 constant bit(36) initial dcl 3-7 set ref 144* 420* LOG_READ_OPEN_INFO_VERSION_1 000000 constant char(8) initial packed unaligned dcl 1-13 ref 162 ME 000002 constant char(32) initial packed unaligned dcl 55 set ref 144* 420* P_area_ptr parameter pointer dcl 41 ref 126 133 P_code parameter fixed bin(35,0) dcl 50 set ref 126 170* 176 190* 193 210* 213 230* 233 251* 254 272* 275 294* 329 343* 346 362* 365 381* 395* P_event_channel parameter fixed bin(71,0) dcl 46 ref 346 357 365 376 P_local_code parameter fixed bin(35,0) dcl 393 ref 391 395 P_log_dname parameter char packed unaligned dcl 39 ref 126 131 P_log_ename parameter char packed unaligned dcl 40 ref 126 132 P_log_message_ptr parameter pointer dcl 43 set ref 193 203* 209* 213 223* 229* 233 250* 254 271* 275 286* 293* 297 307* 313 323* P_log_read_data_ptr parameter pointer dcl 42 set ref 126 134* 169* 176 193 213 233 254 275 292* 297 313 329 346 365 415 P_log_uid parameter bit(36) dcl 48 set ref 329 342* P_message_sequence parameter fixed bin(35,0) dcl 44 ref 233 243 275 285 P_message_time parameter fixed bin(71,0) dcl 45 ref 254 264 P_process_id parameter bit(36) dcl 49 ref 346 356 365 375 P_ptr parameter pointer dcl 402 ref 400 405 406 P_search_direction parameter bit(1) dcl 47 ref 233 244 254 265 addr builtin function dcl 118 ref 152 152 154 154 167 167 allocate_copies 16 000354 automatic bit(1) level 2 dcl 82 set ref 165* allocation_area_ptr 14 000354 automatic pointer level 2 dcl 82 set ref 164* area_ptr 000214 automatic pointer dcl 76 set ref 133* 159 164 auto_status_branch 000100 automatic structure level 1 dcl 63 set ref 152 152 154 154 baseno builtin function dcl 118 ref 405 baseptr builtin function dcl 118 ref 407 cleanup 000374 stack reference condition dcl 122 ref 138 182 199 219 239 260 281 303 319 335 352 371 code 000216 automatic fixed bin(35,0) dcl 77 set ref 135* 167* 169 170 186* 187 188* 206* 207 207* 226* 227 227* 246* 248 248* 267* 269 269* 289* 290 290* 339* 340 340* 359* 360 360* 378* 379 379* cu_$level_get 000044 constant entry external dcl 95 ref 139 424 cu_$level_set 000046 constant entry external dcl 96 ref 148 386 425 dm_misc_util_$get_log_path 000054 constant entry external dcl 99 ref 150 dm_system_log_path 000217 automatic char(168) packed unaligned dcl 78 set ref 150* 151* error_table_$not_closed 000034 external static fixed bin(35,0) dcl 87 set ref 144* error_table_$not_open 000036 external static fixed bin(35,0) dcl 88 set ref 420* error_table_$not_seg_type 000040 external static fixed bin(35,0) dcl 89 set ref 155* error_table_$null_info_ptr 000042 external static fixed bin(35,0) dcl 90 set ref 159* event_channel 000210 automatic fixed bin(71,0) dcl 74 set ref 357* 359* 376* 378* expand_pathname_ 000050 constant entry external dcl 97 ref 151 get_ring_ 000052 constant entry external dcl 98 ref 148 148 425 425 hbound builtin function dcl 118 ref 141 144 144 144 417 420 hcs_$status_long 000056 constant entry external dcl 100 ref 152 154 inner_ring_ptr 000426 automatic pointer dcl 402 set ref 407* 408 log_dname 000112 automatic char(168) packed unaligned dcl 65 set ref 131* 154* 167* log_ename 000164 automatic char(32) packed unaligned dcl 66 set ref 132* 154* 167* log_message_ptr 000176 automatic pointer dcl 68 set ref 203* 206* 209 223* 226* 229 246* 250 267* 271 286* 289* 293 307* 310* 323* 326* log_open_info 000354 automatic structure level 1 dcl 82 set ref 167 167 log_read_$close 000062 constant entry external dcl 102 ref 186 log_read_$deregister 000102 constant entry external dcl 111 ref 378 log_read_$free_message 000106 constant entry external dcl 113 ref 326 log_read_$get_log_uid 000074 constant entry external dcl 108 ref 339 log_read_$hold_message 000104 constant entry external dcl 112 ref 310 log_read_$next_message 000070 constant entry external dcl 106 ref 206 log_read_$open_long 000060 constant entry external dcl 101 ref 167 log_read_$position_sequence 000066 constant entry external dcl 104 ref 246 log_read_$position_time 000064 constant entry external dcl 103 ref 267 log_read_$prev_message 000072 constant entry external dcl 107 ref 226 log_read_$register 000100 constant entry external dcl 110 ref 359 log_read_$update 000076 constant entry external dcl 109 ref 289 log_read_data_ptr 000174 automatic pointer dcl 67 set ref 186* 206* 226* 246* 267* 289* 292 310* 326* 339* 359* 378* 415* 417 420* 427* log_read_open_info based structure level 1 dcl 1-5 log_uid 000212 automatic bit(36) dcl 75 set ref 339* 342 long 4 000100 automatic structure level 2 dcl 63 message_sequence 000202 automatic fixed bin(35,0) dcl 71 set ref 243* 246* 285* 289* message_time 000204 automatic fixed bin(71,0) dcl 72 set ref 264* 267* null builtin function dcl 118 ref 134 141 144 144 152 152 154 154 159 187 420 420 offset 000430 automatic bit(18) packed unaligned dcl 403 set ref 406* 407 opening_index 000201 automatic fixed bin(17,0) dcl 70 set ref 141* 141* 144 167 169 187 292 417* 417* 420 427 pointer builtin function dcl 118 ref 407 process_id 000206 automatic bit(36) dcl 73 set ref 356* 359* 375* 378* reader_procedure 2 000354 automatic varying char(32) level 2 dcl 82 set ref 163* rel builtin function dcl 118 ref 406 saved_validation 000353 automatic fixed bin(3,0) dcl 80 set ref 137* 139* 181* 198* 218* 238* 259* 280* 302* 318* 334* 351* 370* 386 386* 424* search_direction 000200 automatic bit(1) dcl 69 set ref 244* 246* 265* 267* segno 000431 automatic bit(18) packed unaligned dcl 403 set ref 405* 407 static_log_read_ptr 000010 internal static pointer initial array dcl 59 set ref 141 141 144 144 144 167* 169 187* 292* 417 417 420 427 status_branch based structure level 1 dcl 2-8 sub_err_ 000110 constant entry external dcl 114 ref 144 420 true_dir_name 000271 automatic char(168) packed unaligned dcl 78 set ref 151* 152* true_entryname 000343 automatic char(32) packed unaligned dcl 79 set ref 151* 152* true_uid 000213 automatic bit(36) dcl 75 set ref 153* 155 uid 11 000100 automatic bit(36) level 3 packed packed unaligned dcl 63 set ref 153 155 version 000354 automatic char(8) level 2 dcl 82 set ref 162* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ACTION_CAN_RESTART internal static bit(36) initial dcl 3-7 ACTION_DEFAULT_RESTART internal static bit(36) initial dcl 3-7 ACTION_QUIET_RESTART internal static bit(36) initial dcl 3-7 ACTION_SUPPORT_SIGNAL internal static bit(36) initial dcl 3-7 Directory internal static fixed bin(17,0) initial dcl 2-56 Link internal static fixed bin(17,0) initial dcl 2-56 Segment internal static fixed bin(17,0) initial dcl 2-56 error_table_$badcall external static fixed bin(35,0) dcl 86 error_table_$out_of_sequence external static fixed bin(35,0) dcl 91 log_read_open_info_ptr automatic pointer dcl 1-4 status_area_ptr automatic pointer dcl 2-47 status_entry_names based char(32) array dcl 2-47 status_link based structure level 1 dcl 2-38 status_pathname based char dcl 2-47 status_ptr automatic pointer dcl 2-47 NAMES DECLARED BY EXPLICIT CONTEXT. CLEAN_UP 002024 constant entry internal dcl 384 ref 138 171 182 199 219 239 260 281 303 319 335 352 371 ERROR_RETURN 002044 constant entry internal dcl 391 ref 155 159 188 207 227 248 269 290 340 360 379 INNER_RING_POINTER 002051 constant entry internal dcl 400 ref 203 223 286 307 323 RETURN 000556 constant label dcl 171 ref 191 211 231 252 273 295 311 327 344 363 382 396 VALIDATE 002073 constant entry internal dcl 412 ref 184 201 221 241 262 283 305 321 337 354 373 dm_log_read_inner_ 000066 constant entry external dcl 9 dm_log_read_inner_$close 000567 constant entry external dcl 176 dm_log_read_inner_$deregister 001734 constant entry external dcl 365 dm_log_read_inner_$free_message 001466 constant entry external dcl 313 dm_log_read_inner_$get_log_uid 001553 constant entry external dcl 329 dm_log_read_inner_$hold_message 001403 constant entry external dcl 297 dm_log_read_inner_$next_message 000660 constant entry external dcl 193 dm_log_read_inner_$open 000101 constant entry external dcl 126 dm_log_read_inner_$position_sequence 001057 constant entry external dcl 233 dm_log_read_inner_$position_time 001164 constant entry external dcl 254 dm_log_read_inner_$prev_message 000756 constant entry external dcl 213 dm_log_read_inner_$register 001643 constant entry external dcl 346 dm_log_read_inner_$update 001267 constant entry external dcl 275 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 3106 3220 2227 3116 Length 3574 2227 112 337 656 24 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME dm_log_read_inner_ 388 external procedure is an external procedure. on unit on line 138 64 on unit on unit on line 182 64 on unit on unit on line 199 64 on unit on unit on line 219 64 on unit on unit on line 239 64 on unit on unit on line 260 64 on unit on unit on line 281 64 on unit on unit on line 303 64 on unit on unit on line 319 64 on unit on unit on line 335 64 on unit on unit on line 352 64 on unit on unit on line 371 64 on unit CLEAN_UP 68 internal procedure is called by several nonquick procedures. ERROR_RETURN internal procedure shares stack frame of external procedure dm_log_read_inner_. INNER_RING_POINTER internal procedure shares stack frame of external procedure dm_log_read_inner_. VALIDATE internal procedure shares stack frame of external procedure dm_log_read_inner_. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 static_log_read_ptr dm_log_read_inner_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME dm_log_read_inner_ 000100 auto_status_branch dm_log_read_inner_ 000112 log_dname dm_log_read_inner_ 000164 log_ename dm_log_read_inner_ 000174 log_read_data_ptr dm_log_read_inner_ 000176 log_message_ptr dm_log_read_inner_ 000200 search_direction dm_log_read_inner_ 000201 opening_index dm_log_read_inner_ 000202 message_sequence dm_log_read_inner_ 000204 message_time dm_log_read_inner_ 000206 process_id dm_log_read_inner_ 000210 event_channel dm_log_read_inner_ 000212 log_uid dm_log_read_inner_ 000213 true_uid dm_log_read_inner_ 000214 area_ptr dm_log_read_inner_ 000216 code dm_log_read_inner_ 000217 dm_system_log_path dm_log_read_inner_ 000271 true_dir_name dm_log_read_inner_ 000343 true_entryname dm_log_read_inner_ 000353 saved_validation dm_log_read_inner_ 000354 log_open_info dm_log_read_inner_ 000426 inner_ring_ptr INNER_RING_POINTER 000430 offset INNER_RING_POINTER 000431 segno INNER_RING_POINTER THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out call_int_this call_int_other return_mac enable_op ext_entry ext_entry_desc int_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. cu_$level_get cu_$level_set dm_misc_util_$get_log_path expand_pathname_ get_ring_ hcs_$status_long log_read_$close log_read_$deregister log_read_$free_message log_read_$get_log_uid log_read_$hold_message log_read_$next_message log_read_$open_long log_read_$position_sequence log_read_$position_time log_read_$prev_message log_read_$register log_read_$update sub_err_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$not_closed error_table_$not_open error_table_$not_seg_type error_table_$null_info_ptr LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 9 000065 126 000073 131 000126 132 000134 133 000141 134 000144 135 000146 137 000147 138 000151 139 000173 141 000202 143 000215 144 000217 148 000273 150 000311 151 000322 152 000347 153 000411 154 000413 155 000455 159 000467 162 000502 163 000504 164 000505 165 000507 167 000511 169 000545 170 000554 171 000556 174 000562 176 000563 181 000601 182 000603 184 000625 186 000626 187 000637 188 000650 190 000652 191 000653 193 000654 198 000674 199 000676 201 000720 203 000721 206 000731 207 000744 209 000750 210 000752 211 000753 213 000754 218 000772 219 000774 221 001016 223 001017 226 001027 227 001042 229 001046 230 001050 231 001051 233 001052 238 001075 239 001077 241 001121 243 001122 244 001124 246 001130 248 001147 250 001153 251 001155 252 001156 254 001157 259 001200 260 001202 262 001224 264 001225 265 001230 267 001233 269 001252 271 001256 272 001260 273 001261 275 001262 280 001305 281 001307 283 001331 285 001332 286 001334 289 001344 290 001361 292 001365 293 001373 294 001375 295 001376 297 001377 302 001415 303 001417 305 001441 307 001442 310 001452 311 001463 313 001464 318 001500 319 001502 321 001524 323 001525 326 001535 327 001546 329 001547 334 001565 335 001567 337 001611 339 001612 340 001625 342 001631 343 001634 344 001635 346 001636 351 001655 352 001657 354 001701 356 001702 357 001705 359 001707 360 001724 362 001730 363 001731 365 001732 370 001746 371 001750 373 001772 375 001773 376 001776 378 002000 379 002015 381 002021 382 002022 384 002023 386 002031 389 002043 391 002044 395 002046 396 002050 400 002051 405 002053 406 002060 407 002062 408 002071 412 002073 415 002074 417 002077 419 002113 420 002115 424 002166 425 002175 427 002213 429 002220 ----------------------------------------------------------- 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