COMPILATION LISTING OF SEGMENT update_heals_log Compiled by: Multics PL/I Compiler, Release 28d, of October 4, 1983 Compiled at: Honeywell Multics Op. - System M Compiled on: 09/27/84 0746.7 mst Thu Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* *********************************************************** */ 6 7 /* update_heals_log copies messages from the syserr_log 8* into the heals_log. Coded by A. Downing 09/76 as part of 9* Multics HEALS */ 10 /* Modified by A. Downing March 1978 to 11* repair cleanup handling */ 12 /* Modified by A. Downing Dec. 1978 to make several 13* minor bug fixes. */ 14 /* Modified by F. W. Martinson 10/82 to correct bugs and add standard 15* locking strategy. */ 16 update_heals_log: proc; 1 1 /* heals_arg_info.incl.pl1 contains the declaration 1 2* of the argument structure passed between heals releated utilities. 1 3* Created January 1976 by A. R. Downing */ 1 4 dcl 1 heals_arg_info aligned, 1 5 2 iocbp ptr, 1 6 2 report_iocbp ptr, 1 7 2 err_nb fixed bin (35), 1 8 2 info_selection bit (72) unal, 1 9 2 report_name char (64) varying, 1 10 2 heals_log_path_name char (168), /* path name of the heals log */ 1 11 2 system_id char (32) varying, 1 12 2 installation_id char (32) varying, 1 13 2 from_seq fixed bin (35), /* beginning seq_num */ 1 14 2 to_seq fixed bin (35), /* ending seq_num */ 1 15 2 from_time fixed bin (71), /* beginning of desired time period */ 1 16 2 to_time fixed bin (71); /* end of desired time period */ 1 17 /* end heals_arg_info. */ 17 2 1 /* begin heals_state.incl.pl1 */ 2 2 /* Produced March 1976 by A. Downing. */ 2 3 2 4 dcl 1 heals_state aligned based (heals_state_p), 2 5 2 last_message_time fixed bin (71), 2 6 2 last_message_seq_num fixed bin (35), 2 7 2 busy bit (36) aligned; 2 8 dcl heals_state_p ptr; 2 9 dcl heals_log_info$ ext static fixed bin (35) aligned dim (64000); 2 10 /* end heals_state.incl.pl1 */ 18 3 1 /* begin heals_message.incl.pl1 */ 3 2 /* Produced March 1976 by A. Downing. */ 3 3 dcl 1 heals_message based (heals_message_p) aligned, 3 4 2 tally fixed bin (35), 3 5 2 rest_of_record aligned, 3 6 3 seq_num fixed bin (35), /* Sequence number of this message. */ 3 7 3 time fixed bin (71) unal, /* Time message logged at */ 3 8 3 code fixed bin (11) unal, /* Syserr code associated with this message. */ 3 9 3 text_len fixed bin (11) unal, /* Length of message text in ASCII characters. */ 3 10 3 data_size fixed bin (11) unal, /* Size of binary data */ 3 11 3 data_code fixed bin (11) unal, /* format type code */ 3 12 3 pad bit (60) unal, 3 13 3 text char (0 refer (heals_message.text_len)), /* Text of expanded message - kept in ASCII. */ 3 14 3 data (0 refer (heals_message.data_size)) bit (36); /* Binary data area */ 3 15 dcl heals_message_p ptr; 3 16 /* end heals_message.incl.pl1 */ 19 20 dcl hcs_$make_seg entry (char (*), char (*), char (*), 21 fixed bin (5), ptr, fixed bin (35)); 22 dcl hcs_$status_minf entry 23 (char (*), char (*), fixed bin (1), fixed bin (2), fixed bin (24), fixed bin (35)); 24 dcl hcs_$initiate entry (char (*), char (*), char (*), 25 fixed bin (1), fixed bin (2), ptr, fixed bin (35)); 26 dcl convert_date_to_binary_ entry (char (*), fixed bin (71), fixed bin (35)); 27 dcl clock_ entry returns (fixed bin (71)); 28 dcl get_pdir_ entry returns (char (168)); 29 dcl heals_collect_data_ entry (ptr, fixed bin (35)); 30 dcl (com_err_, ioa_) entry options (variable); 31 dcl (iox_$close, iox_$detach_iocb) entry (ptr, fixed bin (35)); 32 dcl iox_$position entry (ptr, fixed bin, fixed bin (21), fixed bin (35)); 33 dcl iox_$read_record entry (ptr, ptr, fixed bin (21), fixed bin (21), fixed bin (35)); 34 dcl iox_$delete_record entry (ptr, fixed bin (35)); 35 dcl iox_$open entry (ptr, fixed bin, bit (1) aligned, fixed bin (35)); 36 dcl iox_$attach_ioname entry (char (*), ptr, char (*), fixed bin (35)); 37 dcl set_lock_$lock entry (bit (36) aligned, fixed bin, fixed bin (35)); 38 dcl set_lock_$unlock entry (bit (36) aligned, fixed bin (35)); 39 dcl log_path char (168) ext static aligned init (">system_control_1>heals_dir>heals_log"); /* default log */ 40 dcl error_table_$noentry ext static fixed bin (35); 41 dcl error_table_$lock_wait_time_exceeded ext static fixed bin (35); 42 dcl error_table_$end_of_info ext static fixed bin (35); 43 dcl code fixed bin (35); 44 dcl ind fixed bin; 45 dcl temp_date_time fixed bin (71); 46 dcl one_day fixed bin (71) int static init (86400000000); /* one day of micro/sec */ 47 dcl chase fixed bin (1) init (1); 48 dcl type fixed bin (2); 49 dcl bit_count fixed bin (24); 50 dcl save_seq_num fixed bin (35); 51 dcl cleanup condition; 52 dcl me char (32) varying; 53 dcl (abs, addr, before, bin, null, verify) builtin; 54 55 me = "update_heals_log"; 56 heals_arg_info.iocbp = null (); 57 heals_arg_info.heals_log_path_name = log_path; 58 ind = index (reverse (heals_log_path_name), ">"); 59 ind = length (heals_log_path_name) - ind ; 60 call hcs_$initiate 61 (substr (heals_log_path_name, 1, ind), 62 "heals_log_info", "", 0, 0, heals_state_p, code); 63 if heals_state_p = null () then do; 64 call hcs_$make_seg 65 (substr (heals_log_path_name, 1, ind), 66 "heals_log_info", "", 01010b, heals_state_p, code); 67 if heals_state_p = null () then do; 68 call com_err_ (code, me, "could not initiate heals_log_info."); 69 return; 70 end; 71 end; 72 call set_lock_$lock (heals_state.busy, 0, code); 73 if code = error_table_$lock_wait_time_exceeded then do; 74 call com_err_ (code, me, "heals log busy"); 75 call clean_up; 76 return; 77 end; 78 79 on cleanup call clean_up; 80 save_seq_num = last_message_seq_num; 81 call hcs_$status_minf 82 (substr (heals_log_path_name, 1, ind), 83 substr (heals_log_path_name, ind +2), 84 chase, type, bit_count, code); 85 if code = error_table_$noentry | 86 type ^= 2 then do; /* must create */ 87 call ioa_ ("^a: Creating heals_log^/^a", me, heals_log_path_name); 88 call iox_$attach_ioname ("heals_io", heals_arg_info.iocbp, 89 "vfile_ " || before (heals_log_path_name, " "), code); 90 if code ^= 0 then do; 91 call com_err_ (code, me, "could not create ^a.", heals_log_path_name); 92 call clean_up; 93 return; 94 end; 95 end; 96 else do; /* heals log exists ok */ 97 call iox_$attach_ioname ("heals_io", heals_arg_info.iocbp, 98 "vfile_ " || before (heals_log_path_name, " ") || " -extend", code); 99 if code ^= 0 then do; 100 call com_err_ (code, me, "could not attach to heals_io stream."); 101 call clean_up; 102 return; 103 end; 104 end; 105 106 from_time = last_message_time+1; 107 to_time = clock_ (); 108 info_selection = "0"b; /* init */ 109 substr (info_selection, 1, 7) = (7)"1"b; 110 call heals_collect_data_ (addr (heals_arg_info), code); 111 if heals_arg_info.err_nb ^= 0 | code ^= 0 then do; 112 call com_err_ (code, me, "heals_log could not be completely updated."); 113 call clean_up; 114 return; 115 end; 116 call ioa_ ( 117 "^5x^d message^v(s^) processed,^/^5xsyserr seq_num ^d through^/^5xsyserr seq_num ^d.", 118 abs (last_message_seq_num - save_seq_num), bin (abs (last_message_seq_num - save_seq_num) ^= 1, 17), 119 save_seq_num, last_message_seq_num); 120 121 call clean_up; 122 return; 123 /* */ 124 /* truncate_heals_log truncates messages from the 125* heals_log */ 126 truncate_heals_log: entry; 127 dcl reset_last_msg bit (1) init ("0"b); 128 dcl no_deleted fixed bin (35) init (0); 129 dcl error_table_$badopt ext static fixed bin (35); 130 dcl i fixed bin init (1); 131 dcl buffer char (2048) aligned; 132 dcl length builtin; 133 dcl act_len fixed bin (21); 134 dcl cu_$arg_count entry returns (fixed bin); 135 dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin, fixed bin (35)); 136 dcl arg char (arg_len) based (arg_p); 137 dcl arg_len fixed bin; 138 dcl arg_p ptr; 139 me = "truncate_heals_log"; 140 heals_arg_info.iocbp = null (); 141 heals_arg_info.heals_log_path_name = log_path; 142 ind = index (reverse (heals_log_path_name), ">"); 143 ind = length (heals_log_path_name) - ind ; 144 call hcs_$initiate 145 (substr (heals_log_path_name, 1, ind), 146 "heals_log_info", "", 0, 0, heals_state_p, code); 147 if heals_state_p = null () then do; 148 call com_err_ (code, me, "could not initiate heals_log_info"); 149 return; 150 end; 151 152 call set_lock_$lock (heals_state.busy, 0, code); 153 if code = error_table_$lock_wait_time_exceeded then do; 154 call com_err_ (code, me, "heals log busy"); 155 call clean_up; 156 return; 157 end; 158 heals_message_p = addr (buffer); 159 heals_state.busy = "1"b; 160 on cleanup call clean_up; 161 to_time = clock_ (); 162 from_time = 0; 163 if cu_$arg_count () < 1 then do; 164 call com_err_ (0, me, "Usage: 165 truncate_heals_log -from TIME -to TIME | 166 truncate_heals_log Ndays"); 167 call clean_up; 168 return; 169 end; 170 else do while (i <= cu_$arg_count ()); 171 call cu_$arg_ptr (i, arg_p, arg_len, code); 172 if code ^= 0 then go to arg_error; 173 if arg = "-from" | arg = "-fm" then do; 174 i = i + 1; 175 call cu_$arg_ptr (i, arg_p, arg_len, code); 176 if code ^= 0 then do; 177 arg_error: call com_err_ (code, me, "error while analyzing argument ^d.", i); 178 call clean_up; 179 return; 180 end; 181 call convert_date_to_binary_ (arg, temp_date_time, code); 182 if code ^= 0 then go to arg_error; 183 else from_time = temp_date_time; 184 end; 185 else if arg = "-to" then do; 186 i = i + 1; 187 call cu_$arg_ptr (i, arg_p, arg_len, code); 188 if code ^= 0 then go to arg_error; 189 call convert_date_to_binary_ (arg, temp_date_time, code); 190 if code ^= 0 then go to arg_error; 191 else to_time = temp_date_time; 192 end; 193 else if verify (arg, "0123456789") = 0 then do; /* number of days */ 194 from_time = 0; 195 to_time = clock_ () - (bin (arg, 17) * one_day); 196 end; 197 else do; /* bad_arg */ 198 call com_err_ (error_table_$badopt, me, "^a.", arg); 199 call clean_up; 200 return; 201 end; 202 i = i + 1; 203 end; /* end of argument parsing loop */ 204 call iox_$attach_ioname 205 ("heals_io", iocbp, 206 "vfile_ " || before (heals_log_path_name, " ") || " -extend", code); 207 if code ^= 0 then do; 208 could_not_truncate: 209 call com_err_ (code, me, 210 "could not truncate ^a as requested.", 211 before (heals_log_path_name, " ")); 212 call clean_up; 213 return; 214 end; 215 call iox_$open (iocbp, 7 /* seq update */, "0"b, code); 216 if code ^= 0 then go to could_not_truncate; 217 call iox_$read_record (iocbp, heals_message_p, length (buffer), act_len, code); 218 if code ^= 0 then do; 219 call com_err_ (code, me, "error while positioning heals_io."); 220 call clean_up; 221 return; 222 end; 223 do while (code = 0 & heals_message.time < from_time); 224 call iox_$read_record (iocbp, heals_message_p, length (buffer), act_len, code); 225 if code ^= 0 then 226 if code ^= error_table_$end_of_info then 227 go to could_not_truncate; 228 else call clean_up; 229 return; 230 end; 231 deletion_loop: 232 do while (code = 0 & heals_message.time < to_time); 233 if last_message_time = heals_message.time then 234 reset_last_msg = "1"b; 235 call iox_$delete_record (iocbp, code); 236 if code = 0 then 237 no_deleted = no_deleted + 1; 238 call iox_$read_record (iocbp, heals_message_p, 239 length (buffer), act_len, code); 240 end; 241 if no_deleted > 0 then 242 call ioa_ ("^4x^d record^v(s^) deleted from:^/^a.", 243 no_deleted, bin (no_deleted > 1, 1, 0), 244 before (heals_log_path_name, " ")); 245 else call ioa_ ("^4xNo records were deleted from:^/^a.", 246 before (heals_log_path_name, " ")); 247 if reset_last_msg | code = error_table_$end_of_info then do; 248 call iox_$position (iocbp, 1, 0, code); 249 call iox_$position (iocbp, 0, -1, code); 250 if code = error_table_$end_of_info then do; 251 last_message_seq_num = 0; 252 last_message_time = 0; 253 end; 254 else do; 255 call iox_$read_record (iocbp, heals_message_p, 256 length (buffer), act_len, code); 257 last_message_seq_num = heals_message.seq_num; 258 last_message_time = heals_message.time; 259 end; 260 code = 0; 261 reset_last_msg = "0"b; 262 end; 263 if code ^= 0 then call com_err_ (me, code); 264 call clean_up; 265 return; 266 /* */ 267 clean_up: proc; 268 if iocbp ^= null () then do; 269 call iox_$close (iocbp, code); 270 call iox_$detach_iocb (iocbp, code); 271 end; 272 call set_lock_$unlock (heals_state.busy, code); 273 return; 274 end clean_up; 275 /* 276* The test entry sets the value of log_path to allow the use of 277* several different heals logs. 278* Added Nov. 1976 by A. Downing. */ 279 test: entry; 280 dcl expand_path_ entry (ptr, fixed bin, ptr, ptr, fixed bin (35)); 281 if cu_$arg_count () = 0 then do; 282 log_path = ">system_control_1>heals_dir>heals_log"; /* default value */ 283 call ioa_ 284 ("Resetting heals_log path to:^/^168a", 285 before (log_path, " ")); 286 end; 287 else do; /* get path name from argument list */ 288 call cu_$arg_ptr (1, arg_p, arg_len, code); 289 call expand_path_ (arg_p, (arg_len), addr (log_path), null (), code); 290 if code ^= 0 then do; 291 call com_err_ (code, "update_heals_log", "could not assign log path name ^a", arg); 292 return; 293 end; 294 else call ioa_ ("Setting heals_log path to:^/^168a", log_path); 295 end; 296 return; 297 298 end update_heals_log; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 09/27/84 0745.3 update_heals_log.pl1 >spec>on>heals>update_heals_log.pl1 17 1 11/02/76 1752.0 heals_arg_info.incl.pl1 >ldd>include>heals_arg_info.incl.pl1 18 2 11/10/82 1749.8 heals_state.incl.pl1 >ldd>include>heals_state.incl.pl1 19 3 10/25/77 1258.3 heals_message.incl.pl1 >ldd>include>heals_message.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. abs builtin function dcl 53 ref 116 116 116 116 act_len 001270 automatic fixed bin(21,0) dcl 133 set ref 217* 224* 238* 255* addr builtin function dcl 53 ref 110 110 158 289 289 arg based char unaligned dcl 136 set ref 173 173 181* 185 189* 193 195 198* 291* arg_len 001271 automatic fixed bin(17,0) dcl 137 set ref 171* 173 173 175* 181 181 185 187* 189 189 193 195 198 198 288* 289 291 291 arg_p 001272 automatic pointer dcl 138 set ref 171* 173 173 175* 181 185 187* 189 193 195 198 288* 289* 291 before builtin function dcl 53 ref 88 97 204 208 208 241 241 245 245 283 283 bin builtin function dcl 53 ref 116 116 195 241 241 bit_count 000244 automatic fixed bin(24,0) dcl 49 set ref 81* buffer 000270 automatic char(2048) dcl 131 set ref 158 217 217 224 224 238 238 255 255 busy 3 based bit(36) level 2 dcl 2-4 set ref 72* 152* 159* 272* chase 000242 automatic fixed bin(1,0) initial dcl 47 set ref 47* 81* cleanup 000246 stack reference condition dcl 51 ref 79 160 clock_ 000020 constant entry external dcl 27 ref 107 161 195 code 000236 automatic fixed bin(35,0) dcl 43 set ref 60* 64* 68* 72* 73 74* 81* 85 88* 90 91* 97* 99 100* 110* 111 112* 144* 148* 152* 153 154* 171* 172 175* 176 177* 181* 182 187* 188 189* 190 204* 207 208* 215* 216 217* 218 219* 223 224* 225 225 231 235* 236 238* 247 248* 249* 250 255* 260* 263 263* 269* 270* 272* 288* 289* 290 291* com_err_ 000024 constant entry external dcl 30 ref 68 74 91 100 112 148 154 164 177 198 208 219 263 291 convert_date_to_binary_ 000016 constant entry external dcl 26 ref 181 189 cu_$arg_count 000064 constant entry external dcl 134 ref 163 170 281 cu_$arg_ptr 000066 constant entry external dcl 135 ref 171 175 187 288 err_nb 4 000100 automatic fixed bin(35,0) level 2 dcl 1-4 set ref 111 error_table_$badopt 000062 external static fixed bin(35,0) dcl 129 set ref 198* error_table_$end_of_info 000060 external static fixed bin(35,0) dcl 42 ref 225 247 250 error_table_$lock_wait_time_exceeded 000056 external static fixed bin(35,0) dcl 41 ref 73 153 error_table_$noentry 000054 external static fixed bin(35,0) dcl 40 ref 85 expand_path_ 000070 constant entry external dcl 280 ref 289 from_time 126 000100 automatic fixed bin(71,0) level 2 dcl 1-4 set ref 106* 162* 183* 194* 223 hcs_$initiate 000014 constant entry external dcl 24 ref 60 144 hcs_$make_seg 000010 constant entry external dcl 20 ref 64 hcs_$status_minf 000012 constant entry external dcl 22 ref 81 heals_arg_info 000100 automatic structure level 1 dcl 1-4 set ref 110 110 heals_collect_data_ 000022 constant entry external dcl 29 ref 110 heals_log_path_name 30 000100 automatic char(168) level 2 dcl 1-4 set ref 57* 58 59 60 60 64 64 81 81 81 81 87* 88 91* 97 141* 142 143 144 144 204 208 208 241 241 245 245 heals_message based structure level 1 dcl 3-3 heals_message_p 000234 automatic pointer dcl 3-15 set ref 158* 217* 223 224* 231 233 238* 255* 257 258 heals_state based structure level 1 dcl 2-4 heals_state_p 000232 automatic pointer dcl 2-8 set ref 60* 63 64* 67 72 80 106 116 116 116 116 116 144* 147 152 159 233 251 252 257 258 272 i 000267 automatic fixed bin(17,0) initial dcl 130 set ref 130* 170 171* 174* 174 175* 177* 186* 186 187* 202* 202 ind 000237 automatic fixed bin(17,0) dcl 44 set ref 58* 59* 59 60 60 64 64 81 81 81 81 142* 143* 143 144 144 info_selection 5 000100 automatic bit(72) level 2 packed unaligned dcl 1-4 set ref 108* 109* ioa_ 000026 constant entry external dcl 30 ref 87 116 241 245 283 294 iocbp 000100 automatic pointer level 2 dcl 1-4 set ref 56* 88* 97* 140* 204* 215* 217* 224* 235* 238* 248* 249* 255* 268 269* 270* iox_$attach_ioname 000044 constant entry external dcl 36 ref 88 97 204 iox_$close 000030 constant entry external dcl 31 ref 269 iox_$delete_record 000040 constant entry external dcl 34 ref 235 iox_$detach_iocb 000032 constant entry external dcl 31 ref 270 iox_$open 000042 constant entry external dcl 35 ref 215 iox_$position 000034 constant entry external dcl 32 ref 248 249 iox_$read_record 000036 constant entry external dcl 33 ref 217 224 238 255 last_message_seq_num 2 based fixed bin(35,0) level 2 dcl 2-4 set ref 80 116 116 116 116 116* 251* 257* last_message_time based fixed bin(71,0) level 2 dcl 2-4 set ref 106 233 252* 258* length builtin function dcl 132 ref 59 143 217 217 224 224 238 238 255 255 log_path 000052 external static char(168) initial dcl 39 set ref 57 141 282* 283 283 289 289 294* me 000254 automatic varying char(32) dcl 52 set ref 55* 68* 74* 87* 91* 100* 112* 139* 148* 154* 164* 177* 198* 208* 219* 263* no_deleted 000266 automatic fixed bin(35,0) initial dcl 128 set ref 128* 236* 236 241 241* 241 241 null builtin function dcl 53 ref 56 63 67 140 147 268 289 289 one_day 000000 constant fixed bin(71,0) initial dcl 46 ref 195 reset_last_msg 000265 automatic bit(1) initial unaligned dcl 127 set ref 127* 233* 247 261* rest_of_record 1 based structure level 2 dcl 3-3 save_seq_num 000245 automatic fixed bin(35,0) dcl 50 set ref 80* 116 116 116 116 116* seq_num 1 based fixed bin(35,0) level 3 dcl 3-3 ref 257 set_lock_$lock 000046 constant entry external dcl 37 ref 72 152 set_lock_$unlock 000050 constant entry external dcl 38 ref 272 temp_date_time 000240 automatic fixed bin(71,0) dcl 45 set ref 181* 183 189* 191 time 2 based fixed bin(71,0) level 3 packed unaligned dcl 3-3 ref 223 231 233 258 to_time 130 000100 automatic fixed bin(71,0) level 2 dcl 1-4 set ref 107* 161* 191* 195* 231 type 000243 automatic fixed bin(2,0) dcl 48 set ref 81* 85 verify builtin function dcl 53 ref 193 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. get_pdir_ 000000 constant entry external dcl 28 heals_log_info$ external static fixed bin(35,0) array dcl 2-9 NAMES DECLARED BY EXPLICIT CONTEXT. arg_error 002055 constant label dcl 177 ref 172 182 188 190 clean_up 003367 constant entry internal dcl 267 ref 75 79 92 101 113 121 155 160 167 178 199 212 220 228 264 could_not_truncate 002407 constant label dcl 208 ref 216 225 deletion_loop 002623 constant label dcl 231 test 003153 constant entry external dcl 279 truncate_heals_log 001444 constant entry external dcl 126 update_heals_log 000373 constant entry external dcl 16 NAMES DECLARED BY CONTEXT OR IMPLICATION. index builtin function ref 58 142 reverse builtin function ref 58 142 substr builtin function set ref 60 60 64 64 81 81 81 81 109* 144 144 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 4244 4336 3637 4254 Length 4652 3637 72 300 405 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME update_heals_log 938 external procedure is an external procedure. on unit on line 79 64 on unit on unit on line 160 64 on unit clean_up 70 internal procedure is called by several nonquick procedures. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME update_heals_log 000100 heals_arg_info update_heals_log 000232 heals_state_p update_heals_log 000234 heals_message_p update_heals_log 000236 code update_heals_log 000237 ind update_heals_log 000240 temp_date_time update_heals_log 000242 chase update_heals_log 000243 type update_heals_log 000244 bit_count update_heals_log 000245 save_seq_num update_heals_log 000254 me update_heals_log 000265 reset_last_msg update_heals_log 000266 no_deleted update_heals_log 000267 i update_heals_log 000270 buffer update_heals_log 001270 act_len update_heals_log 001271 arg_len update_heals_log 001272 arg_p update_heals_log THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_g_a r_ne_as alloc_cs cat_realloc_cs call_ext_out_desc call_ext_out call_int_this call_int_other return mpfx2 enable shorten_stack ext_entry int_entry any_to_any_tr THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. clock_ com_err_ convert_date_to_binary_ cu_$arg_count cu_$arg_ptr expand_path_ hcs_$initiate hcs_$make_seg hcs_$status_minf heals_collect_data_ ioa_ iox_$attach_ioname iox_$close iox_$delete_record iox_$detach_iocb iox_$open iox_$position iox_$read_record set_lock_$lock set_lock_$unlock THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$badopt error_table_$end_of_info error_table_$lock_wait_time_exceeded error_table_$noentry log_path LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 47 000362 127 000364 128 000365 130 000366 16 000372 55 000401 56 000406 57 000410 58 000415 59 000426 60 000430 63 000507 64 000514 67 000570 68 000575 69 000621 72 000622 73 000637 74 000643 75 000671 76 000675 79 000676 80 000720 81 000723 85 001004 87 001014 88 001037 90 001110 91 001113 92 001146 93 001152 95 001153 97 001154 99 001234 100 001237 101 001263 102 001267 106 001270 107 001273 108 001302 109 001305 110 001307 111 001322 112 001326 113 001352 114 001356 116 001357 121 001436 122 001442 126 001443 139 001452 140 001457 141 001461 142 001466 143 001477 144 001501 147 001560 148 001565 149 001611 152 001612 153 001627 154 001633 155 001661 156 001665 158 001666 159 001670 160 001673 161 001715 162 001724 163 001726 164 001740 167 001765 168 001771 170 001772 171 002004 172 002021 173 002023 174 002035 175 002036 176 002053 177 002055 178 002105 179 002111 181 002112 182 002136 183 002140 184 002142 185 002143 186 002147 187 002150 188 002165 189 002167 190 002213 191 002215 192 002217 193 002220 194 002232 195 002234 196 002261 198 002262 199 002314 200 002320 202 002321 203 002322 204 002323 207 002404 208 002407 212 002453 213 002460 215 002461 216 002502 217 002504 218 002525 219 002527 220 002553 221 002557 223 002560 224 002570 225 002611 228 002616 229 002622 231 002623 233 002636 235 002642 236 002653 238 002661 240 002702 241 002703 245 002757 247 003014 248 003023 249 003043 250 003063 251 003067 252 003071 253 003073 255 003074 257 003114 258 003120 260 003124 261 003125 263 003126 264 003145 265 003151 279 003152 281 003161 282 003172 283 003177 286 003233 288 003235 289 003254 290 003301 291 003303 292 003344 294 003345 296 003365 267 003366 268 003374 269 003401 270 003411 272 003423 273 003436 ----------------------------------------------------------- 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