COMPILATION LISTING OF SEGMENT rcp_op_cmnd_ Compiled by: Multics PL/I Compiler, Release 28b, of April 11, 1983 Compiled at: Honeywell LCPD Phoenix, System M Compiled on: 06/08/83 1338.7 mst Wed 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 rcp_op_cmnd_: proc (); 12 13 14 /* 15* * This subroutine implements the following operator commands: 16* * 17* * preload {-user } 18* * unload { | -all} 19* * 20* * 21* * Created on 04/28/78 by Michael R. Jordan. 22* * Modified on 12/09/78 by Michael R. Jordan for version 2 rcp_data info. 23* * Modified 6/79 by Michael R. Jordan for MR7.0R. 24* * Modified May 1983 by Art Beattie to fix unload usage message. 25* * 26* * 27**/ 28 29 dcl addr builtin; 30 dcl arg char (arg_len) based (arg_ptr); /* value of command argument */ 31 dcl arg_len fixed bin; /* length of command argument */ 32 dcl arg_num fixed bin; /* index for argument processing */ 33 dcl arg_ptr ptr; /* pointer to command argument */ 34 dcl code fixed bin (35); /* status code */ 35 dcl com_err_ entry options (variable); 36 dcl cu_$arg_count entry (fixed bin); 37 dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin, fixed bin (35)); 38 dcl device_name char (32); /* the device on which to operate */ 39 dcl error_table_$badopt fixed bin (35) ext; 40 dcl error_table_$bigarg fixed bin (35) ext; 41 dcl error_table_$device_busy fixed bin (35) ext; 42 dcl error_table_$incorrect_device_type fixed bin (35) ext; 43 dcl error_table_$incorrect_volume_type fixed bin (35) ext; 44 dcl error_table_$media_not_removable fixed bin (35) ext; 45 dcl error_table_$noarg fixed bin (35) ext; 46 dcl error_table_$resource_unknown fixed bin (35) ext; 47 dcl error_table_$volume_busy fixed bin (35) ext; 48 dcl error_table_$volume_not_loaded fixed bin (35) ext; 49 dcl error_table_$wrong_no_of_args fixed bin (35) ext static; 50 dcl hbound builtin; 51 dcl hcs_$make_seg entry (char (*), char (*), char (*), fixed bin (5), ptr, fixed bin (35)); 52 dcl i fixed bin; 53 dcl length builtin; 54 dcl me char (16); 55 dcl mess char (32); 56 dcl nargs fixed bin; /* number of command arguments */ 57 dcl null builtin; 58 dcl rcp_sys_$copy_data entry (ptr, fixed bin (19), fixed bin (35)); 59 dcl rcp_sys_$preload entry (char (32), char (32), char (32), fixed bin (35)); 60 dcl rcp_sys_$unload entry (char (32), char (32), fixed bin (35)); 61 dcl resource_info_$get_vtypex entry (char (*), char (*), fixed bin, fixed bin (35)); 62 dcl temp_seg_ptr ptr static init (null ()); 63 dcl user_id char (32); /* the user for whom we are preloading */ 64 dcl volume_name char (32); /* the volume to be preloaded */ 65 dcl volume_type char (32); /* type of volume being preloaded */ 66 dcl vtypex fixed bin; /* volume type index */ 67 68 /* 69* 70* This entry implements the operator preload command. The command syntax is: 71* 72* preload device_name volume_name {-user XX} 73* 74* The user name is required if Resource Management is not enabled. It serves 75* to identify the user for whom the volume is being preloaded. 76* 77**/ 78 79 80 preload: entry (); 81 82 me = "preload"; 83 84 85 /* 86* 87* See how many arguments there are. If not enough, then complain. 88* 89**/ 90 91 92 call cu_$arg_count (nargs); 93 if nargs < 2 then do; 94 NO_ARG: call com_err_ (error_table_$noarg, me, 95 "^/Usage: preload DEVICE VOLUME -user USERID"); 96 return; 97 end; 98 99 100 /* 101* 102* Now get the volume and device names and save them away. 103* 104**/ 105 106 107 call cu_$arg_ptr (1, arg_ptr, arg_len, code); 108 if code ^= 0 then do; 109 BAD_ARG: call com_err_ (code, me); 110 return; 111 end; 112 if length (arg) > length (device_name) then do; 113 LONG_ARG: call com_err_ (error_table_$bigarg, me, "^a", arg); 114 return; 115 end; 116 device_name = arg; 117 118 119 call cu_$arg_ptr (2, arg_ptr, arg_len, code); 120 if code ^= 0 then goto BAD_ARG; 121 if length (arg) > length (volume_name) then goto LONG_ARG; 122 volume_name = arg; 123 124 125 /* 126* 127* Now process any control arguments. 128* 129**/ 130 131 132 user_id = ""; /* no user_id yet */ 133 arg_num = 3; /* first control argument */ 134 135 136 do while (arg_num <= nargs); 137 138 call GET_ARG (); 139 140 if arg = "-user" then do; 141 if arg_num > nargs then goto NO_ARG; 142 call GET_ARG (); 143 if length (arg) > length (user_id) then goto LONG_ARG; 144 user_id = arg; 145 end; 146 147 else do; 148 call com_err_ (error_table_$badopt, me, "^a", arg); 149 return; 150 end; 151 152 end; 153 154 155 /* 156* 157* Do the preload! 158* 159**/ 160 161 162 call rcp_sys_$preload (device_name, volume_name, user_id, code); 163 if code ^= 0 then do; 164 if code = error_table_$incorrect_device_type | 165 code = error_table_$device_busy | 166 code = error_table_$resource_unknown then 167 mess = device_name; 168 else if code = error_table_$volume_busy then 169 mess = volume_name; 170 else if code = error_table_$noarg then 171 mess = "-user NAME required."; 172 else mess = ""; 173 call com_err_ (code, me, "^a", mess); 174 end; 175 176 return; 177 178 /* 179* 180* This entry implements the operator unload command. The command syntax is: 181* 182* unload volume_type {volume_name | -all} 183* 184**/ 185 186 187 unload: entry (); 188 189 me = "unload"; 190 191 192 /* 193* 194* See how many arguments there are. If not enough, then complain. 195* 196**/ 197 198 199 call cu_$arg_count (nargs); 200 if nargs ^= 2 then do; 201 call com_err_ (error_table_$wrong_no_of_args, me, 202 "^/Usage: unload VOLUME_TYPE "); 203 return; 204 end; 205 206 207 /* 208* 209* Now get the type of volume to be unloaded. 210* 211**/ 212 213 214 call cu_$arg_ptr (1, arg_ptr, arg_len, code); 215 if code ^= 0 then goto BAD_ARG; 216 if length (arg) > length (volume_type) then goto LONG_ARG; 217 volume_type = arg; 218 219 220 /* 221* 222* Now see if this is an unload -all or an unload volume-name. 223* 224**/ 225 226 227 GOT_VTYPEX: 228 229 call cu_$arg_ptr (2, arg_ptr, arg_len, code); 230 if code ^= 0 then goto BAD_ARG; 231 232 233 if arg = "-all" | arg = "-a" 234 then call UNLOAD_ALL (); 235 else do; /* Just do this one volume. */ 236 if length (arg) > length (volume_name) then goto LONG_ARG; 237 volume_name = arg; 238 call UNLOAD_VOLUME (); 239 end; 240 241 242 return; 243 244 GET_ARG: proc (); 245 246 247 if arg_num > nargs then do; 248 arg_ptr = null (); 249 return; 250 end; 251 252 253 call cu_$arg_ptr (arg_num, arg_ptr, arg_len, code); 254 if code ^= 0 then goto BAD_ARG; 255 256 257 arg_num = arg_num+1; 258 259 260 return; 261 262 263 end GET_ARG; 264 265 /* 266* 267* This internal procedure attempts to unload all unattached, loaded volumes. 268* It does so by getting the names of these volumes from the info returned 269* by rcp_sys_$copy_data and calling UNLOAD_VOLUME for each one. 270* 271**/ 272 273 274 UNLOAD_ALL: proc (); 275 276 277 /* 278* 279* First we must get the rdi structure from RCP. 280* 281**/ 282 283 284 if temp_seg_ptr = null () then do; /* If we don't have a temp seg then get one. */ 285 call hcs_$make_seg ("", "rcp_unload_seg", "", 01010b, temp_seg_ptr, code); 286 if temp_seg_ptr = null () then do; 287 call com_err_ (code, me, "Error making rcp_unload_seg."); 288 return; 289 end; 290 end; 291 292 rdi_ptr = temp_seg_ptr; /* Put RCP data in temp seg. */ 293 rdi.version_num = rdi_version_3; /* Specify version number of the structure. */ 294 295 call rcp_sys_$copy_data (rdi_ptr, 64*1024, code); /* Get the data. */ 296 if code ^= 0 then do; 297 call com_err_ (code, me, "Error getting data from RCP."); 298 return; 299 end; 300 301 302 /* 303* 304* Now get the device type ptr for this volume type. 305* 306**/ 307 308 309 call resource_info_$get_vtypex (volume_type, volume_type, vtypex, code); 310 if code ^= 0 then do; 311 call com_err_ (code, me, "^a", volume_type); 312 return; 313 end; 314 315 ddtype_ptr = addr (rdi.ddtypes (vtypex)); 316 317 318 /* 319* 320* Now process each unattached device entry of this type. 321* 322**/ 323 324 325 do i = ddtype.first_devicex to (ddtype.first_devicex+ddtype.num_devices-1); 326 ddevice_ptr = addr (rdi.ddevices (i)); 327 if ^ddevice.flags.attached then do; /* This one is not attached ... */ 328 volume_name = ddevice.volume_name; /* ... so get the volume name and ... */ 329 if volume_name ^= "" then /* ... if its not blank then ... */ 330 call UNLOAD_VOLUME (); /* ... unload it. */ 331 end; 332 end; 333 334 335 return; 336 337 338 end UNLOAD_ALL; 339 340 /* 341* 342* This internal procedure attempts to unload the volume specified by 343* volume_name. If an error occurs, a message will be printed also. 344* 345**/ 346 347 348 UNLOAD_VOLUME: proc (); 349 350 351 call rcp_sys_$unload (volume_type, volume_name, code); 352 if code ^= 0 then do; 353 if code = error_table_$incorrect_volume_type then 354 mess = volume_type; 355 else if code = error_table_$volume_not_loaded | 356 code = error_table_$media_not_removable | 357 code = error_table_$volume_busy then 358 mess = volume_name; 359 else mess = ""; 360 call com_err_ (code, me, "^a", mess); 361 end; 362 363 return; 364 365 366 end UNLOAD_VOLUME; 367 1 1 /* Begin include file ... rcp_data_info.incl.pl1 1 2* * 1 3* * Created on 04/03/75 by Bill Silver. 1 4* * Modified on 04/24/78 by Michael R. Jordan to add the attached and loaded bits. 1 5* * Modified on 11/19/78 by Michael R. Jordan to add reservation information and volume entries (version 2). 1 6* * Modified 6/79 by Michael R. Jordan for 32 character device types (version 3). 1 7* * This include file is used to copy data from rcp_data. 1 8**/ 1 9 dcl rdi_ptr ptr; /* Pointer to base of the rdi structure. */ 1 10 dcl ddtype_ptr ptr; /* Points to a ddtype entry. */ 1 11 dcl ddevice_ptr ptr; /* Points to a ddevice entry. */ 1 12 dcl dvolume_ptr ptr; /* Points to a dvolume entry. */ 1 13 1 14 dcl rdi_version_3 fixed bin static internal options (constant) init (3); /* Version number of this structure. */ 1 15 1 16 dcl 1 rdi based (rdi_ptr) aligned, /* Beginning of rcp_data_info structure. */ 1 17 2 head like rdi_header, /* Header of this structure. */ 1 18 2 ddtypes (0 refer (rdi.tot_ddtypes)) /* One entry per device type. */ 1 19 like ddtype, /* See structure below. */ 1 20 2 ddevices (0 refer (rdi.tot_ddevices)) /* One entry per configured device. */ 1 21 like ddevice, /* See structure below. */ 1 22 2 dvolumes (0 refer (rdi.tot_dvolumes)) /* One entry per "known" volume. */ 1 23 like dvolume, /* See structure below. */ 1 24 2 end bit (36) aligned; /* End of rcp_data_info. */ 1 25 1 26 dcl 1 rdi_header based aligned, /* Header of RCP Data Info structure. */ 1 27 2 version_num fixed bin, /* The version number of this structure. */ 1 28 2 tot_ddtypes fixed bin, /* Total number of ddtype entries. */ 1 29 2 tot_ddevices fixed bin, /* Total number of ddevice entries. */ 1 30 2 tot_dvolumes fixed bin; /* Total number of dvolume entries. */ 1 31 1 32 dcl 1 ddtype based (ddtype_ptr) aligned, /* Entry for one device type. */ 1 33 2 device_type char (32), /* Name of this device type. */ 1 34 2 max_concurrent fixed bin, /* Max num of concurrently assigned devices. */ 1 35 2 num_reserved fixed bin, /* Num of devices reserved for system processes. */ 1 36 2 num_devices fixed bin, /* Num of devices of this type that are configured. */ 1 37 2 first_devicex fixed bin; /* Index of first device of this type. */ 1 38 1 39 dcl 1 ddevice based (ddevice_ptr) aligned, /* Entry for one device. */ 1 40 2 device_name char (8), /* Name of device associated with this entry. */ 1 41 2 volume_name char (32), /* Volume name. Blank => no volume. */ 1 42 2 dtypex fixed bin, /* Device type index. */ 1 43 2 model fixed bin, /* Device model number. */ 1 44 2 num_qualifiers fixed bin, /* Number of device qualifiers. */ 1 45 2 qualifiers (4) fixed bin (35), /* Device qualifiers. */ 1 46 2 state_time fixed bin (71), /* Time device put into current state. */ 1 47 2 state fixed bin, /* 0 => free, 1 => assigned, 2 => deleted. */ 1 48 2 iom_num fixed bin, /* IOM number for this device. */ 1 49 2 chan_num fixed bin, /* Channel number for this device. */ 1 50 2 num_channels fixed bin, /* Num channels that may address device. */ 1 51 2 flags, /* Special info flags. */ 1 52 (3 reservable bit (1), /* ON => may be reserved for system process. */ 1 53 3 reserved bit (1), /* ON => assigned to a system process. */ 1 54 3 mounting bit (1), /* ON => mount pending. */ 1 55 3 writing bit (1), /* ON => mounting for writing. */ 1 56 3 attached bit (1), /* ON => device is attached. */ 1 57 3 loaded bit (1)) unal, /* ON => device is loaded. */ 1 58 2 group_id char (32), /* Process group ID. */ 1 59 2 reservation_id fixed bin (71), /* Reservation id. */ 1 60 2 reserved_by char (32); /* Group id of user who reserved this device. */ 1 61 1 62 dcl 1 dvolume based (dvolume_ptr) aligned, /* Entry for one volume. */ 1 63 2 process_id bit (36), /* "0"b => unassigned. */ 1 64 2 volume_name char (32), /* Volume name. */ 1 65 2 vtypex fixed bin, /* Volume type index. */ 1 66 2 group_id char (32), /* This is used for the reserved_for field. */ 1 67 2 reserved_by char (32), 1 68 2 reservation_id fixed bin (71), 1 69 2 state_time fixed bin (71), /* Same as for a device. */ 1 70 2 state fixed bin, /* Same as for a device. */ 1 71 2 unassign_state fixed bin, /* State to return when unassigning. */ 1 72 2 current_authorization bit (72) aligned; /* Authorization of process using this volume. */ 1 73 1 74 /* End of include file ... rcp_data_info.incl.pl1 */ 368 369 370 371 end rcp_op_cmnd_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 06/08/83 1338.7 rcp_op_cmnd_.pl1 >special_ldd>on>06/08/83>rcp_op_cmnd_.pl1 368 1 11/21/79 1510.7 rcp_data_info.incl.pl1 >ldd>include>rcp_data_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. addr builtin function dcl 29 ref 315 326 arg based char unaligned dcl 30 set ref 112 113* 116 121 122 140 143 144 148* 216 217 233 233 236 237 arg_len 000100 automatic fixed bin(17,0) dcl 31 set ref 107* 112 113 113 116 119* 121 122 140 143 144 148 148 214* 216 217 227* 233 233 236 237 253* arg_num 000101 automatic fixed bin(17,0) dcl 32 set ref 133* 136 141 247 253* 257* 257 arg_ptr 000102 automatic pointer dcl 33 set ref 107* 112 113 116 119* 121 122 140 143 144 148 214* 216 217 227* 233 233 236 237 248* 253* attached 30(04) based bit(1) level 3 packed unaligned dcl 1-39 ref 327 code 000104 automatic fixed bin(35,0) dcl 34 set ref 107* 108 109* 119* 120 162* 163 164 164 164 168 170 173* 214* 215 227* 230 253* 254 285* 287* 295* 296 297* 309* 310 311* 351* 352 353 355 355 355 360* com_err_ 000012 constant entry external dcl 35 ref 94 109 113 148 173 201 287 297 311 360 cu_$arg_count 000014 constant entry external dcl 36 ref 92 199 cu_$arg_ptr 000016 constant entry external dcl 37 ref 107 119 214 227 253 ddevice based structure level 1 dcl 1-39 ddevice_ptr 000170 automatic pointer dcl 1-11 set ref 326* 327 328 ddevices based structure array level 2 dcl 1-16 set ref 326 ddtype based structure level 1 dcl 1-32 ddtype_ptr 000166 automatic pointer dcl 1-10 set ref 315* 325 325 325 ddtypes 4 based structure array level 2 dcl 1-16 set ref 315 device_name 000105 automatic char(32) unaligned dcl 38 set ref 112 116* 162* 164 dvolume based structure level 1 dcl 1-62 error_table_$badopt 000020 external static fixed bin(35,0) dcl 39 set ref 148* error_table_$bigarg 000022 external static fixed bin(35,0) dcl 40 set ref 113* error_table_$device_busy 000024 external static fixed bin(35,0) dcl 41 ref 164 error_table_$incorrect_device_type 000026 external static fixed bin(35,0) dcl 42 ref 164 error_table_$incorrect_volume_type 000030 external static fixed bin(35,0) dcl 43 ref 353 error_table_$media_not_removable 000032 external static fixed bin(35,0) dcl 44 ref 355 error_table_$noarg 000034 external static fixed bin(35,0) dcl 45 set ref 94* 170 error_table_$resource_unknown 000036 external static fixed bin(35,0) dcl 46 ref 164 error_table_$volume_busy 000040 external static fixed bin(35,0) dcl 47 ref 168 355 error_table_$volume_not_loaded 000042 external static fixed bin(35,0) dcl 48 ref 355 error_table_$wrong_no_of_args 000044 external static fixed bin(35,0) dcl 49 set ref 201* first_devicex 13 based fixed bin(17,0) level 2 dcl 1-32 ref 325 325 flags 30 based structure level 2 dcl 1-39 hcs_$make_seg 000046 constant entry external dcl 51 ref 285 head based structure level 2 dcl 1-16 i 000115 automatic fixed bin(17,0) dcl 52 set ref 325* 326* length builtin function dcl 53 ref 112 112 121 121 143 143 216 216 236 236 me 000116 automatic char(16) unaligned dcl 54 set ref 82* 94* 109* 113* 148* 173* 189* 201* 287* 297* 311* 360* mess 000122 automatic char(32) unaligned dcl 55 set ref 164* 168* 170* 172* 173* 353* 355* 359* 360* nargs 000132 automatic fixed bin(17,0) dcl 56 set ref 92* 93 136 141 199* 200 247 null builtin function dcl 57 ref 248 284 286 num_devices 12 based fixed bin(17,0) level 2 dcl 1-32 ref 325 rcp_sys_$copy_data 000050 constant entry external dcl 58 ref 295 rcp_sys_$preload 000052 constant entry external dcl 59 ref 162 rcp_sys_$unload 000054 constant entry external dcl 60 ref 351 rdi based structure level 1 dcl 1-16 rdi_header based structure level 1 dcl 1-26 rdi_ptr 000164 automatic pointer dcl 1-9 set ref 292* 293 295* 315 326 rdi_version_3 constant fixed bin(17,0) initial dcl 1-14 ref 293 resource_info_$get_vtypex 000056 constant entry external dcl 61 ref 309 temp_seg_ptr 000010 internal static pointer initial dcl 62 set ref 284 285* 286 292 tot_ddtypes 1 based fixed bin(17,0) level 3 dcl 1-16 ref 326 user_id 000133 automatic char(32) unaligned dcl 63 set ref 132* 143 144* 162* version_num based fixed bin(17,0) level 3 dcl 1-16 set ref 293* volume_name 000143 automatic char(32) unaligned dcl 64 in procedure "rcp_op_cmnd_" set ref 121 122* 162* 168 236 237* 328* 329 351* 355 volume_name 2 based char(32) level 2 in structure "ddevice" dcl 1-39 in procedure "rcp_op_cmnd_" ref 328 volume_type 000153 automatic char(32) unaligned dcl 65 set ref 216 217* 309* 309* 311* 351* 353 vtypex 000163 automatic fixed bin(17,0) dcl 66 set ref 309* 315 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. dvolume_ptr automatic pointer dcl 1-12 hbound builtin function dcl 50 NAMES DECLARED BY EXPLICIT CONTEXT. BAD_ARG 000203 constant label dcl 109 ref 120 215 230 254 GET_ARG 000647 constant entry internal dcl 244 ref 138 142 GOT_VTYPEX 000602 constant label dcl 227 LONG_ARG 000224 constant label dcl 113 ref 121 143 216 236 NO_ARG 000135 constant label dcl 94 ref 141 UNLOAD_ALL 000677 constant entry internal dcl 274 ref 233 UNLOAD_VOLUME 001172 constant entry internal dcl 348 ref 238 329 preload 000114 constant entry external dcl 80 rcp_op_cmnd_ 000105 constant entry external dcl 11 unload 000503 constant entry external dcl 187 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1530 1610 1264 1540 Length 2040 1264 60 213 243 2 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME rcp_op_cmnd_ 278 external procedure is an external procedure. GET_ARG internal procedure shares stack frame of external procedure rcp_op_cmnd_. UNLOAD_ALL internal procedure shares stack frame of external procedure rcp_op_cmnd_. UNLOAD_VOLUME internal procedure shares stack frame of external procedure rcp_op_cmnd_. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 temp_seg_ptr rcp_op_cmnd_ STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME rcp_op_cmnd_ 000100 arg_len rcp_op_cmnd_ 000101 arg_num rcp_op_cmnd_ 000102 arg_ptr rcp_op_cmnd_ 000104 code rcp_op_cmnd_ 000105 device_name rcp_op_cmnd_ 000115 i rcp_op_cmnd_ 000116 me rcp_op_cmnd_ 000122 mess rcp_op_cmnd_ 000132 nargs rcp_op_cmnd_ 000133 user_id rcp_op_cmnd_ 000143 volume_name rcp_op_cmnd_ 000153 volume_type rcp_op_cmnd_ 000163 vtypex rcp_op_cmnd_ 000164 rdi_ptr rcp_op_cmnd_ 000166 ddtype_ptr rcp_op_cmnd_ 000170 ddevice_ptr rcp_op_cmnd_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out return ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ cu_$arg_count cu_$arg_ptr hcs_$make_seg rcp_sys_$copy_data rcp_sys_$preload rcp_sys_$unload resource_info_$get_vtypex THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$badopt error_table_$bigarg error_table_$device_busy error_table_$incorrect_device_type error_table_$incorrect_volume_type error_table_$media_not_removable error_table_$noarg error_table_$resource_unknown error_table_$volume_busy error_table_$volume_not_loaded error_table_$wrong_no_of_args LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 11 000104 80 000112 82 000121 92 000124 93 000132 94 000135 96 000161 107 000162 108 000201 109 000203 110 000220 112 000221 113 000224 114 000256 116 000257 119 000263 120 000302 121 000304 122 000307 132 000313 133 000316 136 000320 138 000323 140 000324 141 000332 142 000335 143 000336 144 000341 145 000345 148 000346 149 000400 152 000401 162 000402 163 000417 164 000421 168 000434 170 000442 172 000450 173 000453 176 000501 187 000502 189 000510 199 000513 200 000522 201 000525 203 000551 214 000552 215 000571 216 000573 217 000576 227 000602 230 000621 233 000623 236 000637 237 000642 238 000645 242 000646 244 000647 247 000650 248 000653 249 000655 253 000656 254 000673 257 000675 260 000676 274 000677 284 000700 285 000705 286 000746 287 000753 288 000776 292 000777 293 001001 295 001003 296 001017 297 001021 298 001045 309 001046 310 001071 311 001073 312 001122 315 001123 325 001130 326 001141 327 001154 328 001157 329 001162 332 001167 335 001171 348 001172 351 001173 352 001206 353 001210 355 001217 359 001231 360 001234 363 001262 ----------------------------------------------------------- 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