COMPILATION LISTING OF SEGMENT set_privileges Compiled by: Multics PL/I Compiler, Release 32f, of October 9, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 11/11/89 1042.3 mst Sat Options: optimize map 1 /****^ ****************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright (c) 1987 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* * Copyright (c) 1972 by Massachusetts Institute of * 9* * Technology and Honeywell Information Systems, Inc. * 10* * * 11* ****************************************************** */ 12 13 /* format: style2,indcomtxt */ 14 set_privileges: 15 procedure; 16 17 /* Modified 1985-03-04, EJ Sharpe: remove special_op event flags and auditing for ring-1 TCB calls */ 18 /* Modified 1985-01-21, BIM: ring 1 (admin) privilege manipulation. */ 19 /* Modified 84-12-05 by EJ Sharpe to use access_audit_ instead of protection_audit_ */ 20 /* Modified 84-11 BIM, changed to set all privs in apte */ 21 /* Modified May 1983 by E. N. Kittlitz to add communication privilege */ 22 /* Modified 760309 by L.Scheffler to fix excessive auditing calls */ 23 /* Modified by E. Stone on Sept 1975 to change kst when setting directory privileges */ 24 /* Coded 16 Oct. 1974 by D. H. Hunt */ 25 26 /* This ring 0 procedure is expected to be invoked only by the */ 27 /* system security administrator and by certain SysDaemon processes */ 28 /* which need to bypass the access isolation mechanism (AIM) checks */ 29 30 /* A process grants itself a particular privilege to bypass AIM checks */ 31 /* by calling one of the "---priv_on" entry points. This sets the */ 32 /* corresponding privilege bit on (="1"b) */ 33 34 /* A process rescinds a particular privilege for bypassing AIM checks */ 35 /* by calling one of the "---priv_off" entry points. This sets the */ 36 /* corresponding privilege bit off (="0"b) */ 37 38 39 declare access_audit_$log_general 40 entry external options (variable); 41 declare access_operations_$system_privilege_modify 42 bit (36) aligned external; 43 declare 1 pds$access_authorization 44 aligned like aim_template external; 45 declare pds$admin_privileges bit (36) aligned external; 46 declare pds$apt_ptr pointer external; 47 declare 1 event_flags aligned like audit_event_flags; 48 declare level$get entry returns (fixed bin (3)); 49 declare ring_alarm$reset entry; 50 declare setfaults$disconnect entry (fixed bin); 51 declare ME char (14) aligned internal static initial ("set_privileges") options (constant); 52 declare P_code fixed bin (35) parameter; 53 declare P_set_privs bit (36) aligned parameter; 54 declare P_old_privs bit (36) aligned parameter; 55 56 declare changed bit (1) aligned; 57 declare set_privs bit (36) aligned; 58 declare old_privs bit (36) aligned; 59 60 declare (addr, bit, bool, hbound, length, null, rtrim, string, substr) 61 builtin; 62 63 64 admin_set: 65 entry (P_set_privs, P_old_privs); 66 67 set_privs = P_set_privs; 68 call set_admin_privileges (set_privs, old_privs); /* fixes the KST */ 69 P_old_privs = old_privs; 70 return; 71 72 admin_reset: 73 entry (P_set_privs); 74 75 set_privs = P_set_privs; 76 call reset_admin_privileges (set_privs); /* fixes the KST */ 77 P_set_privs = set_privs; 78 return; 79 80 81 admin_ring_alarm: /* Called on a ring alarm to get rid of these */ 82 entry; 83 84 set_privs = bit (string (pds$access_authorization.privileges), 36) & ^pds$admin_privileges; 85 /* construct appropriate priv set */ 86 substr (set_privs, 36, 1) = "1"b; /* Give it something to do */ 87 call reset_admin_privileges (set_privs); 88 pds$admin_privileges = ""b; /* double sure */ 89 return; 90 91 92 /* In managing its log buffers, syserr may send a wakeup to the initializer */ 93 /* process. Everything will work OK, since if the wakeup is sent from the */ 94 /* initializer to itself, the wakeup will be allowed regardless of the state */ 95 /* of the IPC privilege bits. If another process sends the wakeup to the */ 96 /* initializer, it will be allowed since the initializer will have IPC privilege */ 97 /* on before other processes are allowed to log in. */ 98 99 ipc_priv_on: /* disables the AIM check for interprocess communication */ 100 entry (P_code); 101 102 call set_one_privilege (IPC_PRIVILEGE_X, IPC_PRIVILEGE, changed); 103 104 if changed 105 then P_code = 0; 106 else P_code = 1; 107 return; 108 109 110 ipc_priv_off: /* enables the AIM check for interprocess communication */ 111 entry (P_code); 112 113 call clear_one_privilege (IPC_PRIVILEGE_X, ^IPC_PRIVILEGE, changed); 114 115 if changed 116 then P_code = 0; 117 else P_code = 1; 118 return; 119 120 dir_priv_on: /* disables the AIM checks for directories */ 121 entry (P_code); 122 123 call set_one_privilege (DIR_PRIVILEGE_X, DIR_PRIVILEGE, changed); 124 if changed 125 then do; 126 call fix_kst; /* cause access to directories to be recalculated */ 127 P_code = 0; 128 end; 129 else P_code = 1; 130 return; 131 132 dir_priv_off: /* enables the AIM checks for directories */ 133 entry (P_code); 134 135 call clear_one_privilege (DIR_PRIVILEGE_X, ^DIR_PRIVILEGE, changed); 136 137 if changed 138 then do; 139 call fix_kst; /* cause access to directories to be recalculated */ 140 P_code = 0; 141 end; 142 else P_code = 1; 143 return; 144 145 seg_priv_on: /* disables the AIM checks for segments */ 146 entry (P_code); 147 148 call set_one_privilege (SEG_PRIVILEGE_X, SEG_PRIVILEGE, changed); 149 150 if changed 151 then do; 152 P_code = 0; 153 call fix_kst_seg; 154 end; 155 else P_code = 1; 156 return; 157 158 seg_priv_off: /* enables the AIM checks for segments */ 159 entry (P_code); 160 161 call clear_one_privilege (SEG_PRIVILEGE_X, ^SEG_PRIVILEGE, changed); 162 if changed 163 then do; 164 P_code = 0; 165 call fix_kst_seg; 166 end; 167 else P_code = 1; 168 169 return; 170 171 soos_priv_on: /* prevents access to directories which have the */ 172 entry (P_code); /* security out of service attribute turned on */ 173 174 call set_one_privilege (SOOS_PRIVILEGE_X, SOOS_PRIVILEGE, changed); 175 if changed 176 then P_code = 0; 177 else P_code = 1; 178 return; 179 180 soos_priv_off: /* allows access to directories which have the */ 181 entry (P_code); /* security out of service attribute turned on */ 182 call clear_one_privilege (SOOS_PRIVILEGE_X, ^SOOS_PRIVILEGE, changed); 183 184 if changed 185 then P_code = 0; 186 else P_code = 1; 187 return; 188 189 ring1_priv_on: /* disables the interpretive AIM */ 190 entry (P_code); /* checks in ring one */ 191 call set_one_privilege (RING1_PRIVILEGE_X, RING1_PRIVILEGE, changed); 192 if changed 193 then P_code = 0; 194 else P_code = 1; 195 return; 196 197 ring1_priv_off: /* enables the interpretive AIM */ 198 entry (P_code); /* checks in ring one */ 199 200 call clear_one_privilege (RING1_PRIVILEGE_X, ^RING1_PRIVILEGE, changed); 201 if changed 202 then P_code = 0; 203 else P_code = 1; 204 return; 205 206 rcp_priv_on: /* disables the interpretive AIM */ 207 entry (P_code); /* checks in RCP */ 208 209 call set_one_privilege (RCP_PRIVILEGE_X, RCP_PRIVILEGE, changed); 210 if changed 211 then P_code = 0; 212 else P_code = 1; 213 return; 214 215 rcp_priv_off: /* enables the interpretive AIM */ 216 entry (P_code); /* checks in RCP */ 217 call clear_one_privilege (RCP_PRIVILEGE_X, ^RCP_PRIVILEGE, changed); 218 if changed 219 then P_code = 0; 220 else P_code = 1; 221 return; 222 223 comm_priv_on: /* disables the interpretive AIM */ 224 entry (P_code); /* checks in TCP and dial_ctl_ */ 225 226 call set_one_privilege (COMM_PRIVILEGE_X, COMM_PRIVILEGE, changed); 227 if changed 228 then P_code = 0; 229 else P_code = 1; 230 return; 231 232 comm_priv_off: /* enables the interpretive AIM */ 233 entry (P_code); /* checks in comm */ 234 call clear_one_privilege (COMM_PRIVILEGE_X, ^COMM_PRIVILEGE, changed); 235 if changed 236 then P_code = 0; 237 else P_code = 1; 238 return; 239 240 241 fix_kst: 242 procedure; 243 244 dcl segno fixed bin; 245 dcl seg_flag bit (1) aligned; 246 dcl faulted_one bit (1) aligned; 247 248 seg_flag = "0"b; 249 go to COMMON; 250 251 fix_kst_seg: 252 entry; 253 254 seg_flag = "1"b; 255 256 COMMON: 257 kstp = pds$kstp; /* get pointer to kst */ 258 faulted_one = "0"b; 259 do segno = kstp -> kst.lowseg to kstp -> kst.highest_used_segno; 260 /* whip thru kst looking for dirs */ 261 kstep = addr (kstp -> kst.kst_entry (segno)); 262 if kste.uid ^= ""b 263 then if (kste.dirsw & ^seg_flag) | (^kste.dirsw & ^kste.priv_init & seg_flag) 264 then do; 265 kstep -> kste.dtbm = (36)"1"b;/* set dtbm so that access will be recalculated as needed */ 266 if seg_flag 267 then call setfaults$disconnect (segno); 268 end; 269 270 end; 271 272 end fix_kst; 273 274 275 set_one_privilege: 276 procedure (privilege_index, privilege_mask, changed); 277 278 declare changed bit (1) aligned; 279 declare privilege_index fixed bin; 280 declare privilege_mask bit (36) aligned; 281 declare new_privs bit (18) aligned; 282 declare old_privs bit (18) aligned; 283 declare apte_auth_ptr pointer; 284 declare 1 apte_auth aligned like aim_template based (apte_auth_ptr); 285 declare turn_on bit (1) aligned; 286 287 turn_on = "1"b; 288 go to COMMON; 289 290 clear_one_privilege: 291 entry (privilege_index, privilege_mask, changed); 292 293 turn_on = "0"b; 294 295 COMMON: 296 changed = "0"b; 297 old_privs = string (pds$access_authorization.privileges); 298 /* starts same as old */ 299 if turn_on 300 then new_privs = old_privs | privilege_mask; 301 else new_privs = old_privs & privilege_mask; /* caller ^'s to get ^'ed form in as text constant */ 302 303 if new_privs = old_privs 304 then return; /* with changed = "0"b */ 305 306 changed = "1"b; 307 apte_auth_ptr = addr (pds$apt_ptr -> apte.access_authorization); 308 string (apte_auth.privileges), string (pds$access_authorization.privileges) = new_privs; 309 string (event_flags) = ""b; 310 event_flags.grant = "1"b; 311 event_flags.priv_op = "1"b; 312 call access_audit_$log_general (ME, level$get (), string (event_flags), 313 access_operations_$system_privilege_modify, "", 0, null (), 0, "^a turned ^[on^;off^]", 314 system_privilege_names (privilege_index).long, turn_on); 315 return; 316 317 end set_one_privilege; 318 319 set_admin_privileges: 320 procedure (new_privileges, old_privileges); 321 322 declare (new_privileges, old_privileges) 323 bit (36) aligned; 324 declare apte_auth_ptr pointer; 325 declare 1 apte_auth aligned like aim_template based (apte_auth_ptr); 326 declare priv_value bit (18); 327 declare name_string char (100) varying; 328 declare x fixed bin; 329 declare privs_before_set bit (18) aligned; 330 declare different_privs_mask bit (18) aligned; 331 332 old_privileges = string (pds$access_authorization.privileges); 333 substr (old_privileges, 36, 1) = "1"b; /* Mark the setting */ 334 priv_value = substr (old_privileges, 1, 18) | substr (new_privileges, 1, 18); 335 /* Turn on the new ones */ 336 name_string = ""; 337 do x = 1 to hbound (system_privilege_names, 1); 338 if substr (new_privileges, x, 1) 339 then do; 340 if length (name_string) > 0 341 then name_string = name_string || ","; 342 name_string = name_string || rtrim (system_privilege_names.short (x)); 343 end; 344 end; 345 346 apte_auth_ptr = addr (pds$apt_ptr -> apte.access_authorization); 347 privs_before_set = string (pds$access_authorization.privileges); 348 349 different_privs_mask = bool (privs_before_set, new_privileges, "0110"b); 350 /* XOR */ 351 pds$admin_privileges = pds$admin_privileges | (new_privileges & different_privs_mask); 352 /* mark */ 353 call ring_alarm$reset; 354 355 string (apte_auth.privileges), string (pds$access_authorization.privileges) = priv_value; 356 357 if ((priv_value & DIR_PRIVILEGE) ^= ""b) /* We only turn ON here */ & ((privs_before_set & DIR_PRIVILEGE) = ""b) 358 then call fix_kst; 359 if ((priv_value & SEG_PRIVILEGE) ^= ""b) & ((privs_before_set & SEG_PRIVILEGE) = ""b) 360 then call fix_kst_seg; 361 362 /**** The following code would usually audit the event. However, setting 363* /**** privileges temporarily is a normal function of the ring-1 TCB. 364* /**** Therefore, we elect to avoid many unnecessary audit messages. 365* /**** Besides, there's no associated object or event flag on which to decide 366* /**** upon auditing. 367* /**** string (event_flags) = ""b; 368* /**** event_flags.grant = "1"b; 369* /**** event_flags.WHAT? = "1"b; HAVE to have an event flag here - admin_op is NOT the correct one 370* /**** call access_audit_$log_general (ME, level$get (), string (event_flags), 371* /**** access_operations_$system_privilege_modify, "", 0, null (), 0, "^a turned on", name_string); 372* / ****/ 373 return; 374 375 376 reset_admin_privileges: 377 entry (old_privileges); 378 379 if ^substr (old_privileges, 36, 1) 380 then return; /* Not anything to reset. */ 381 382 substr (old_privileges, 36, 1) = "0"b; 383 privs_before_set = string (pds$access_authorization.privileges); 384 priv_value = substr (old_privileges, 1, 18); 385 386 apte_auth_ptr = addr (pds$apt_ptr -> apte.access_authorization); 387 388 different_privs_mask = bool (privs_before_set, old_privileges, "0110"b); 389 /* XOR */ 390 pds$admin_privileges = pds$admin_privileges & ^(^old_privileges & different_privs_mask); 391 /* Zero out privs zero'd out by the reset */ 392 393 string (apte_auth.privileges), string (pds$access_authorization.privileges) = priv_value; 394 call ring_alarm$reset; 395 396 if (priv_value & DIR_PRIVILEGE) ^= (privs_before_set & DIR_PRIVILEGE) 397 then call fix_kst; 398 if (priv_value & SEG_PRIVILEGE) ^= (privs_before_set & SEG_PRIVILEGE) 399 then call fix_kst_seg; 400 401 name_string = ""; 402 do x = 1 to hbound (system_privilege_names, 1); 403 if substr (privs_before_set, x, 1) ^= substr (priv_value, x, 1) 404 then do; 405 if length (name_string) > 0 406 then name_string = name_string || ","; 407 name_string = name_string || rtrim (system_privilege_names (x).short); 408 if substr (priv_value, x, 1) 409 then name_string = name_string || "(set)"; 410 else name_string = name_string || "(reset)"; 411 end; 412 end; 413 414 415 /**** The following code would usually audit the event. However, setting 416* /**** privileges temporarily is a normal function of the ring-1 TCB. 417* /**** Therefore, we elect to avoid many unnecessary audit messages. 418* /**** Besides, there's no associated object or event flag on which to decide 419* /**** upon auditing. 420* /**** string (event_flags) = ""b; 421* /**** event_flags.grant = "1"b; 422* /**** event_flags.WHAT? = "1"b; HAVE to have an event flag here - admin_op is NOT the correct one 423* /**** call access_audit_$log_general (ME, level$get (), string (event_flags), 424* /**** access_operations_$system_privilege_modify, "", 0, null (), 0, "change: ^a", name_string); 425* / ****/ 426 return; 427 428 end set_admin_privileges; 429 430 /* format: off */ 431 /* Begin include file aim_privileges.incl.pl1 BIM 831206 */ 1 2 /* format: style3 */ 1 3 1 4 declare aim_privileges_ptr pointer; 1 5 declare 1 aim_privileges unaligned based (aim_privileges_ptr), 1 6 ( 2 ipc, /** interprocess communication privilege */ 1 7 2 dir, /** directory privilege */ 1 8 2 seg, /** segment privilege */ 1 9 2 soos, /** security out-of-service privilege */ 1 10 2 ring1, /** ring 1 access privilege */ 1 11 2 rcp, /** RCP resource access privilege */ 1 12 2 comm /** communications cross-AIM privilege */ 1 13 ) bit (1), 1 14 2 pad bit (29); 1 15 1 16 declare ( 1 17 IPC_PRIVILEGE init ("1"b), 1 18 DIR_PRIVILEGE init ("01"b), 1 19 SEG_PRIVILEGE init ("001"b), 1 20 SOOS_PRIVILEGE init ("0001"b), 1 21 RING1_PRIVILEGE init ("00001"b), 1 22 RCP_PRIVILEGE init ("000001"b), 1 23 COMM_PRIVILEGE init ("0000001"b), 1 24 ALL_PRIVILEGES init ("1111111"b) 1 25 ) bit (36) int static aligned options (constant); 1 26 1 27 1 28 /* End include file aim_privileges.incl.pl1 */ 431 432 /* BEGIN INCLUDE FILE aim_template.incl.pl1 */ 2 2 2 3 /* Created 740723 by PG */ 2 4 /* Modified 06/28/78 by C. D. Tavares to add rcp privilege */ 2 5 /* Modified 83-05-10 by E. N. Kitltitz to add communications privilege */ 2 6 2 7 /* This structure defines the components of both an access 2 8* class and an access authorization as interpreted by the 2 9* Access Isolation Mechanism. */ 2 10 2 11 2 12 dcl 1 aim_template aligned based, /* authorization/access class template */ 2 13 2 categories bit (36), /* access categories */ 2 14 2 level fixed bin (17) unaligned, /* sensitivity level */ 2 15 2 privileges unaligned, /* special access privileges (in authorization only) */ 2 16 (3 ipc, /* interprocess communication privilege */ 2 17 3 dir, /* directory privilege */ 2 18 3 seg, /* segment privilege */ 2 19 3 soos, /* security out-of-service privilege */ 2 20 3 ring1, /* ring 1 access privilege */ 2 21 3 rcp, /* RCP resource access privilege */ 2 22 3 comm) bit (1), /* communications cross-AIM privilege */ 2 23 3 pad bit (11); 2 24 2 25 2 26 /* END INCLUDE FILE aim_template.incl.pl1 */ 432 433 /* BEGIN INCLUDE FILE ... apte.incl.pl1 */ 3 2 3 3 /* Modified 1984-11-11 by E. Swenson for IPC event channel validation. */ 3 4 3 5 dcl aptep pointer; 3 6 3 7 dcl 1 apte based (aptep) aligned, /* APT entry declaration for an active (known) process */ 3 8 2 thread unaligned, /* List thread */ 3 9 3 fp bit (18), /* Forward pointer */ 3 10 3 bp bit (18), /* Backward pointer */ 3 11 2 flags unaligned, /* Flags and miscellaneous */ 3 12 3 mbz bit (1), /* This bit must be zero (sentinel bit) */ 3 13 3 wakeup_waiting bit (1), /* ON if process has received wakeup */ 3 14 3 stop_pending bit (1), /* ON if process has received stop connect */ 3 15 3 pre_empted bit (1), /* ON if process is being pre-empted by get_processor */ 3 16 3 hproc bit (1), /* ON if process is hardcore process */ 3 17 3 loaded bit (1), /* ON if required per-process pages are in memory and wired */ 3 18 3 eligible bit (1), /* ON if process is eligible */ 3 19 3 idle bit (1), /* ON if this is an idle process */ 3 20 3 interaction bit (1), /* ON if process has interacted recently */ 3 21 3 pre_empt_pending bit (1), /* ON if process has received pre-empt connect */ 3 22 3 default_procs_required bit (1), /* ON if apte.procs_required is system default */ 3 23 3 realtime_burst bit (1), /* ON if next eligibility is realtime */ 3 24 3 always_loaded bit (1), /* ON if process is not to be unloaded */ 3 25 3 dbr_loaded bit (1), /* ON if DBR is loaded on some CPU */ 3 26 3 being_loaded bit (1), /* ON if somebody loading this process */ 3 27 3 shared_stack_0 bit (1), /* ON if a shared stack_0 is assigned */ 3 28 3 page_wait_flag bit (1), /* flag ON if waiting for page */ 3 29 3 firstsw bit (1), /* OFF until process is intialized */ 3 30 3 state bit (18), /* execution state */ 3 31 2 page_faults fixed bin (35), /* total page faults for the process */ 3 32 2 processid bit (36), /* bit 0-17: offset of ATPE */ 3 33 /* bit 18-35: sequential number */ 3 34 2 te fixed bin (35), /* virtual time since eligibility award */ 3 35 2 ts fixed bin (35), /* virtual time since scheduling */ 3 36 2 ti fixed bin (35), /* virtual time since interaction */ 3 37 2 timax fixed bin (35), /* maximum value allowed for apte.ti */ 3 38 3 39 /* * * * * * * * */ 3 40 3 41 2 ipc_pointers unaligned, 3 42 3 event_thread bit (18), /* relative pointer to ITT list */ 3 43 3 pad3 bit (18), 3 44 2 ips_message bit (36), /* IPS signals pending */ 3 45 2 asteps unaligned, /* relative ASTE pointers */ 3 46 3 pds bit (18), /* PDS (per-process) */ 3 47 3 dseg bit (18), /* DSEG (per-process) */ 3 48 3 prds bit (18), /* PRDS (per-processor) */ 3 49 2 savex7 bit (18) unaligned, /* x7 at call to getwork (return point in pxss) */ 3 50 2 term_processid bit (36), /* process to send wakeup at temination */ 3 51 2 lock_id bit (36), /* File System unqieu ID associated with process */ 3 52 2 time_used_clock fixed bin (71), /* Total CPU time when process last lost CPU */ 3 53 3 54 /* * * * * * * * */ 3 55 3 56 2 wait_event bit (36) aligned, /* Event ID process awaiting */ 3 57 2 wct_index bit (18) unaligned, /* rel offset of WCTE */ 3 58 2 flags2 unaligned, 3 59 3 priority_scheduling bit (1), /* ON if guaranteed eligibility */ 3 60 3 special_wakeups bit (6), /* Special wakeup channels */ 3 61 3 pad7 bit (7), 3 62 3 batch bit (1), /* ON if absentee */ 3 63 3 pr_tag bit (3), /* CPU tag running or last run */ 3 64 2 state_change_time fixed bin (71), /* Time apte.state last changed */ 3 65 2 alarm_event fixed bin (71), /* wakeup event for alarm clock manager */ 3 66 2 alarm_time_thread bit (18) unaligned, /* thread of processes with pending alarms */ 3 67 2 alarm_time bit (54) unaligned, /* wakeup time for alarm */ 3 68 3 69 /* * * * * * */ 3 70 3 71 2 term_channel fixed bin (71), /* wakeup event for account overflow */ 3 72 2 ws_size fixed bin, /* working set estimate for the process */ 3 73 2 temax fixed bin (35), /* maximum eligibility slice (vcpu) */ 3 74 2 deadline fixed bin (71), /* time of next run */ 3 75 2 lock bit (18) unaligned, /* 0 => APTE locked, unlocked => return point of last unlock */ 3 76 2 unusable bit (18) unaligned, /* locking routines destroy */ 3 77 2 cpu_monitor fixed bin (35), /* if not 0, send wakeup to term_processid when virtual cpu 3 78* /* reaches this (units = 1/1024 sec) */ 3 79 2 paging_measure fixed bin (71), /* cumulative memory units */ 3 80 2 access_authorization bit (72), /* authorization of this process */ 3 81 2 dbr fixed bin (71), /* DBR value (constant since DSEG entry-held) */ 3 82 3 83 2 virtual_cpu_time fixed bin (71), /* cumulative virtual CPU time for the process */ 3 84 2 ittes_sent fixed bin (18), /* Unprocessed ITTs sent by this process */ 3 85 2 ittes_got fixed bin (18), /* Unprocessed ITTs received by this process */ 3 86 3 87 /* Cells used to drive and instrument finite-state model for response time 3 88* measurement. Maintained by meter_response_time */ 3 89 3 90 2 current_response_state fixed bin (17) unaligned, /* Process state in modle */ 3 91 2 pad18 bit (18) unaligned, 3 92 2 number_processing fixed bin (35), /* Number interactions */ 3 93 2 last_response_state_time fixed bin (71), /* Clock time at last response state change */ 3 94 2 total_processing_time fixed bin (71), /* Total interaction processing time */ 3 95 3 96 /* * * * * * */ 3 97 3 98 2 begin_interaction_vcpu fixed bin (71), /* Virtual cpu at beginning of last interaction */ 3 99 3 100 /* End of cells for finite-state model */ 3 101 3 102 2 saved_temax fixed bin (35), /* temax at eligibility award */ 3 103 2 procs_required bit (8) unaligned, /* bit mask of CPUs this process can run */ 3 104 2 pad4 bit (28) unaligned, 3 105 2 ipc_r_offset fixed bin (18) unsigned, 3 106 2 ipc_r_factor fixed bin (35) unsigned, 3 107 2 apad (10) fixed bin (35); 3 108 3 109 /* END INCLUDE FILE ... apte.incl.pl1 */ 433 434 /* START OF: kst.incl.pl1 * * * * * */ 4 2 4 3 /* 4 4*Modified March 1976 by R. Bratt 4 5*Modified November 1984 to remove hdr, Keith Loepere. */ 4 6 4 7 4 8 /****^ HISTORY COMMENTS: 4 9* 1) change(86-08-08,GDixon), approve(86-08-08,MCR7388), 4 10* audit(86-09-02,Farley), install(86-09-08,MR12.0-1150): 4 11* Add warning on use of kste.entryp. 4 12* END HISTORY COMMENTS */ 4 13 4 14 4 15 dcl pds$kstp ext ptr, 4 16 (kstp, kstep) ptr; 4 17 4 18 dcl 1 kst aligned based (kstp), /* KST header declaration */ 4 19 2 lowseg fixed bin (17), /* lowest segment number described by kst */ 4 20 2 highseg fixed bin (17), /* highest segment number described by kst */ 4 21 2 highest_used_segno fixed bin (17), /* highest segment number yet used */ 4 22 2 lvs fixed bin (8), /* number of private LVs this process is connected to */ 4 23 2 time_of_bootload fixed bin (71), /* bootload time during prelinking */ 4 24 2 garbage_collections fixed bin (17) unaligned, /* KST garbage collections */ 4 25 2 entries_collected fixed bin (17) unaligned, /* KST entries recovered by garbage collection */ 4 26 2 free_list bit (18) unaligned, /* relative pointer to first free kste */ 4 27 2 prelinked_ring (7) bit (1) unaligned, /* rings prelinked in process */ 4 28 2 template bit (1) unaligned, /* this is a template kst if set */ 4 29 2 allow_256K_connect bit (1) unaligned, /* can use 256K segments */ 4 30 2 unused_2 bit (9) unaligned, 4 31 2 uid_hash_bucket (0 : 127) bit (18) unaligned, /* hash buckets */ 4 32 2 kst_entry (0 refer (kst.lowseg):0 refer (kst.highseg)) aligned like kste, /* kst entries */ 4 33 2 lv (1:256) bit (36), /* private logical volume connection list */ 4 34 2 end_of_kst bit (36); 4 35 4 36 dcl 1 kste based (kstep) aligned, /* KST entry declaration */ 4 37 2 fp bit (18) unaligned, /* forward rel pointer */ 4 38 2 segno fixed bin (17) unaligned, /* segment number of this kste */ 4 39 2 usage_count (0:7) fixed bin (8) unaligned, /* outstanding initiates/ring */ 4 40 2 entryp ptr unaligned, /* branch pointer */ 4 41 /* See WARNING below for requirements to use entryp. */ 4 42 2 uid bit (36) aligned, /* unique identifier */ 4 43 2 access_information unaligned, 4 44 3 dtbm bit (36), /* date time branch modified */ 4 45 3 extended_access bit (33), /* extended access from the branch */ 4 46 3 access bit (3), /* rew */ 4 47 3 ex_rb (3) bit (3), /* ring brackets from branch */ 4 48 2 pad1 bit (3) unaligned, 4 49 2 flags unaligned, 4 50 3 dirsw bit (1), /* directory switch */ 4 51 3 allow_write bit (1), /* set if initiated with write permission */ 4 52 3 priv_init bit (1), /* privileged initiation */ 4 53 3 tms bit (1), /* transparent modification switch */ 4 54 3 tus bit (1), /* transparent usage switch */ 4 55 3 tpd bit (1), /* transparent paging device switch */ 4 56 3 audit bit (1), /* audit switch */ 4 57 3 explicit_deact_ok bit (1), /* set if I am willing to have a user force deactivate */ 4 58 3 pad bit (3), 4 59 2 infcount fixed bin (12) unaligned; /* _i_f dirsw _t_h_e_n inferior count _e_l_s_e lv index */ 4 60 4 61 4 62 /* * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 63 /* */ 4 64 /* WARNING: Before using kste.entryp to get a pointer to the directory */ 4 65 /* entry associated with the kst entry, you must first validate its value */ 4 66 /* by calling sum$getbranch or sum$getbranch_root_my. This call also locks */ 4 67 /* the containing directory. The containing directory must remain locked */ 4 68 /* during the entire period when kste.entryp and the directory entry are */ 4 69 /* being referenced. Once the directory is unlocked, kste.entryp can no */ 4 70 /* longer be used to get a pointer to the entry within the unlocked */ 4 71 /* directory since the dir entry could have been moved within the directory */ 4 72 /* by another processor. */ 4 73 /* */ 4 74 /* If you only need a pointer to the directory containing the associated */ 4 75 /* dir entry (but not to the dir entry itself), you can use: */ 4 76 /* pointer (kste.entryp, 0) */ 4 77 /* without calling sum to lock the directory and validate entryp. GDixon */ 4 78 /* */ 4 79 /* * * * * * * * * * * * * * * * * * * * * * * * * * */ 4 80 4 81 /* END OF: kst.incl.pl1 * * * * * */ 434 435 /* Begin include file system_privileges.incl.pl1 BIM 84-05-07 */ 5 2 5 3 /* Numerical indices and names of the privileges. Bit strings 5 4* live in aim_privileges.incl.pl1 */ 5 5 5 6 /* format: style3 */ 5 7 5 8 declare ( 5 9 IPC_PRIVILEGE_X init (1), 5 10 DIR_PRIVILEGE_X init (2), 5 11 SEG_PRIVILEGE_X init (3), 5 12 SOOS_PRIVILEGE_X init (4), 5 13 RING1_PRIVILEGE_X init (5), 5 14 RCP_PRIVILEGE_X init (6), 5 15 COMM_PRIVILEGE_X init (7), 5 16 LAST_PRIVILEGE_X init (7) 5 17 ) fixed bin int static options (constant); 5 18 5 19 declare 1 system_privilege_names 5 20 (7) aligned internal static options (constant), 5 21 2 long char (40) 5 22 init ("IPC", "directory", "segment", "security out of service", "ring one", "RCP", 5 23 "communications"), 5 24 2 short char (8) init ("ipc", "dir", "seg", "soos", "ring1", "rcp", "comm"); 5 25 5 26 /* End include file system_privileges.incl.pl1 */ 5 27 5 28 435 436 /* begin include file - access_audit_eventflags.incl.pl1 */ 6 2 /* NOTE: This include file has an ALM counterpart made with cif. 6 3*Keep it up to date. */ 6 4 6 5 dcl 1 audit_event_flags based aligned, 6 6 2 special_op bit (1) unal, /* special sys operation */ 6 7 2 grant bit (1) unal, /* operation was successful */ 6 8 2 admin_op bit (1) unal, /* administrative operation */ 6 9 2 priv_op bit (1) unal, /* privileged operation */ 6 10 2 cc_1_10 bit (1) unal, /* small covert channel */ 6 11 2 cc_10_100 bit (1) unal, /* moderate covert channel */ 6 12 2 receiver bit (1) unal, /* on receiving end of channel */ 6 13 2 pad bit (29) unal; 6 14 6 15 /* end include file - access_audit_eventflags.incl.pl1 */ 436 437 /* format: on */ 438 439 /* BEGIN MESSAGE DOCUMENTATION 440* 441* 442* Message: 443* AUDIT (set_privileges): GRANTED modification of system AIM privilege ADDED_INFO 444* 445* S: $access_audit 446* 447* T: $run 448* 449* M: The specified user made a privileged call for modifying the 450* process AIM privileges 451* 452* A: $ignore 453* 454* 455* END MESSAGE DOCUMENTATION */ 456 457 end set_privileges; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/11/89 0800.6 set_privileges.pl1 >spec>install>1110>set_privileges.pl1 431 1 08/19/84 1445.6 aim_privileges.incl.pl1 >ldd>include>aim_privileges.incl.pl1 432 2 09/07/83 1610.6 aim_template.incl.pl1 >ldd>include>aim_template.incl.pl1 433 3 01/06/85 1422.2 apte.incl.pl1 >ldd>include>apte.incl.pl1 434 4 09/18/86 1308.1 kst.incl.pl1 >ldd>include>kst.incl.pl1 435 5 08/19/84 1445.6 system_privileges.incl.pl1 >ldd>include>system_privileges.incl.pl1 436 6 01/30/85 1523.9 access_audit_eventflags.incl.pl1 >ldd>include>access_audit_eventflags.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. COMM_PRIVILEGE 000125 constant bit(36) initial dcl 1-16 set ref 226* 234 COMM_PRIVILEGE_X constant fixed bin(17,0) initial dcl 5-8 set ref 226* 234* DIR_PRIVILEGE 000131 constant bit(36) initial dcl 1-16 set ref 123* 135 357 357 396 396 DIR_PRIVILEGE_X constant fixed bin(17,0) initial dcl 5-8 set ref 123* 135* IPC_PRIVILEGE constant bit(36) initial dcl 1-16 set ref 102* 113 IPC_PRIVILEGE_X constant fixed bin(17,0) initial dcl 5-8 set ref 102* 113* ME 000132 constant char(14) initial dcl 51 set ref 312* P_code parameter fixed bin(35,0) dcl 52 set ref 99 104* 106* 110 115* 117* 120 127* 129* 132 140* 142* 145 152* 155* 158 164* 167* 171 175* 177* 180 184* 186* 189 192* 194* 197 201* 203* 206 210* 212* 215 218* 220* 223 227* 229* 232 235* 237* P_old_privs parameter bit(36) dcl 54 set ref 64 69* P_set_privs parameter bit(36) dcl 53 set ref 64 67 72 75 77* RCP_PRIVILEGE 000126 constant bit(36) initial dcl 1-16 set ref 209* 217 RCP_PRIVILEGE_X 000124 constant fixed bin(17,0) initial dcl 5-8 set ref 209* 217* RING1_PRIVILEGE 000127 constant bit(36) initial dcl 1-16 set ref 191* 200 RING1_PRIVILEGE_X constant fixed bin(17,0) initial dcl 5-8 set ref 191* 200* SEG_PRIVILEGE 000130 constant bit(36) initial dcl 1-16 set ref 148* 161 359 359 398 398 SEG_PRIVILEGE_X constant fixed bin(17,0) initial dcl 5-8 set ref 148* 161* SOOS_PRIVILEGE constant bit(36) initial dcl 1-16 set ref 174* 182 SOOS_PRIVILEGE_X constant fixed bin(17,0) initial dcl 5-8 set ref 174* 182* access_audit_$log_general 000010 constant entry external dcl 39 ref 312 access_authorization 42 based bit(72) level 2 dcl 3-7 set ref 307 346 386 access_information 5 based structure level 2 packed packed unaligned dcl 4-36 access_operations_$system_privilege_modify 000012 external static bit(36) dcl 41 set ref 312* addr builtin function dcl 60 ref 261 307 346 386 aim_template based structure level 1 dcl 2-12 apte based structure level 1 dcl 3-7 apte_auth based structure level 1 dcl 284 in procedure "set_one_privilege" apte_auth based structure level 1 dcl 325 in procedure "set_admin_privileges" apte_auth_ptr 000144 automatic pointer dcl 324 in procedure "set_admin_privileges" set ref 346* 355 386* 393 apte_auth_ptr 000132 automatic pointer dcl 283 in procedure "set_one_privilege" set ref 307* 308 audit_event_flags based structure level 1 dcl 6-5 bit builtin function dcl 60 ref 84 bool builtin function dcl 60 ref 349 388 changed 000101 automatic bit(1) dcl 56 in procedure "set_privileges" set ref 102* 104 113* 115 123* 124 135* 137 148* 150 161* 162 174* 175 182* 184 191* 192 200* 201 209* 210 217* 218 226* 227 234* 235 changed parameter bit(1) dcl 278 in procedure "set_one_privilege" set ref 275 290 295* 306* different_privs_mask 000203 automatic bit(18) dcl 330 set ref 349* 351 388* 390 dirsw 7(12) based bit(1) level 3 packed packed unaligned dcl 4-36 ref 262 262 dtbm 5 based bit(36) level 3 packed packed unaligned dcl 4-36 set ref 265* event_flags 000100 automatic structure level 1 dcl 47 set ref 309* 312 312 faulted_one 000120 automatic bit(1) dcl 246 set ref 258* flags 7(12) based structure level 2 packed packed unaligned dcl 4-36 grant 0(01) 000100 automatic bit(1) level 2 packed packed unaligned dcl 47 set ref 310* hbound builtin function dcl 60 ref 337 402 highest_used_segno 2 based fixed bin(17,0) level 2 dcl 4-18 ref 259 kst based structure level 1 dcl 4-18 kst_entry 110 based structure array level 2 dcl 4-18 set ref 261 kste based structure level 1 dcl 4-36 kstep 000106 automatic pointer dcl 4-15 set ref 261* 262 262 262 262 265 kstp 000104 automatic pointer dcl 4-15 set ref 256* 259 259 261 length builtin function dcl 60 ref 340 405 level$get 000022 constant entry external dcl 48 ref 312 312 long 000000 constant char(40) initial array level 2 dcl 5-19 set ref 312* lowseg based fixed bin(17,0) level 2 dcl 4-18 ref 259 261 name_string 000147 automatic varying char(100) dcl 327 set ref 336* 340 340* 340 342* 342 401* 405 405* 405 407* 407 408* 408 410* 410 new_privileges parameter bit(36) dcl 322 ref 319 334 338 349 351 new_privs 000130 automatic bit(18) dcl 281 set ref 299* 301* 303 308 null builtin function dcl 60 ref 312 312 old_privileges parameter bit(36) dcl 322 set ref 319 332* 333* 334 376 379 382* 384 388 390 old_privs 000103 automatic bit(36) dcl 58 in procedure "set_privileges" set ref 68* 69 old_privs 000131 automatic bit(18) dcl 282 in procedure "set_one_privilege" set ref 297* 299 301 303 pds$access_authorization 000014 external static structure level 1 dcl 43 pds$admin_privileges 000016 external static bit(36) dcl 45 set ref 84 88* 351* 351 390* 390 pds$apt_ptr 000020 external static pointer dcl 46 ref 307 346 386 pds$kstp 000030 external static pointer dcl 4-15 ref 256 priv_init 7(14) based bit(1) level 3 packed packed unaligned dcl 4-36 ref 262 priv_op 0(03) 000100 automatic bit(1) level 2 packed packed unaligned dcl 47 set ref 311* priv_value 000146 automatic bit(18) packed unaligned dcl 326 set ref 334* 355 357 359 384* 393 396 398 403 408 privilege_index parameter fixed bin(17,0) dcl 279 ref 275 290 312 privilege_mask parameter bit(36) dcl 280 ref 275 290 299 301 privileges 1(18) based structure level 2 in structure "apte_auth" packed packed unaligned dcl 325 in procedure "set_admin_privileges" set ref 355* 393* privileges 1(18) 000014 external static structure level 2 in structure "pds$access_authorization" packed packed unaligned dcl 43 in procedure "set_privileges" set ref 84 297 308* 332 347 355* 383 393* privileges 1(18) based structure level 2 in structure "apte_auth" packed packed unaligned dcl 284 in procedure "set_one_privilege" set ref 308* privs_before_set 000202 automatic bit(18) dcl 329 set ref 347* 349 357 359 383* 388 396 398 403 ring_alarm$reset 000024 constant entry external dcl 49 ref 353 394 rtrim builtin function dcl 60 ref 342 407 seg_flag 000117 automatic bit(1) dcl 245 set ref 248* 254* 262 262 266 segno 000116 automatic fixed bin(17,0) dcl 244 set ref 259* 261 266* set_privs 000102 automatic bit(36) dcl 57 set ref 67* 68* 75* 76* 77 84* 86* 87* setfaults$disconnect 000026 constant entry external dcl 50 ref 266 short 12 000000 constant char(8) initial array level 2 dcl 5-19 ref 342 407 string builtin function dcl 60 set ref 84 297 308* 308* 309* 312 312 332 347 355* 355* 383 393* 393* substr builtin function dcl 60 set ref 86* 333* 334 334 338 379 382* 384 403 403 408 system_privilege_names 000000 constant structure array level 1 dcl 5-19 set ref 337 402 turn_on 000134 automatic bit(1) dcl 285 set ref 287* 293* 299 312* uid 4 based bit(36) level 2 dcl 4-36 ref 262 x 000201 automatic fixed bin(17,0) dcl 328 set ref 337* 338 342* 402* 403 403 407 408* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ALL_PRIVILEGES internal static bit(36) initial dcl 1-16 LAST_PRIVILEGE_X internal static fixed bin(17,0) initial dcl 5-8 aim_privileges based structure level 1 packed packed unaligned dcl 1-5 aim_privileges_ptr automatic pointer dcl 1-4 aptep automatic pointer dcl 3-5 NAMES DECLARED BY EXPLICIT CONTEXT. COMMON 000750 constant label dcl 256 in procedure "fix_kst" set ref 249 COMMON 001044 constant label dcl 295 in procedure "set_one_privilege" ref 288 admin_reset 000232 constant entry external dcl 72 admin_ring_alarm 000251 constant entry external dcl 81 admin_set 000211 constant entry external dcl 64 clear_one_privilege 001041 constant entry internal dcl 290 ref 113 135 161 182 200 217 234 comm_priv_off 000716 constant entry external dcl 232 comm_priv_on 000673 constant entry external dcl 223 dir_priv_off 000376 constant entry external dcl 132 dir_priv_on 000352 constant entry external dcl 120 fix_kst 000742 constant entry internal dcl 241 ref 126 139 357 396 fix_kst_seg 000745 constant entry internal dcl 251 ref 153 165 359 398 ipc_priv_off 000324 constant entry external dcl 110 ipc_priv_on 000301 constant entry external dcl 99 rcp_priv_off 000645 constant entry external dcl 215 rcp_priv_on 000622 constant entry external dcl 206 reset_admin_privileges 001374 constant entry internal dcl 376 ref 76 87 ring1_priv_off 000574 constant entry external dcl 197 ring1_priv_on 000551 constant entry external dcl 189 seg_priv_off 000451 constant entry external dcl 158 seg_priv_on 000425 constant entry external dcl 145 set_admin_privileges 001216 constant entry internal dcl 319 ref 68 set_one_privilege 001034 constant entry internal dcl 275 ref 102 123 148 174 191 209 226 set_privileges 000177 constant entry external dcl 14 soos_priv_off 000523 constant entry external dcl 180 soos_priv_on 000500 constant entry external dcl 171 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2316 2350 1774 2326 Length 2722 1774 32 336 322 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME set_privileges 207 external procedure is an external procedure. fix_kst internal procedure shares stack frame of external procedure set_privileges. set_one_privilege internal procedure shares stack frame of external procedure set_privileges. set_admin_privileges internal procedure shares stack frame of external procedure set_privileges. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME set_privileges 000100 event_flags set_privileges 000101 changed set_privileges 000102 set_privs set_privileges 000103 old_privs set_privileges 000104 kstp set_privileges 000106 kstep set_privileges 000116 segno fix_kst 000117 seg_flag fix_kst 000120 faulted_one fix_kst 000130 new_privs set_one_privilege 000131 old_privs set_one_privilege 000132 apte_auth_ptr set_one_privilege 000134 turn_on set_one_privilege 000144 apte_auth_ptr set_admin_privileges 000146 priv_value set_admin_privileges 000147 name_string set_admin_privileges 000201 x set_admin_privileges 000202 privs_before_set set_admin_privileges 000203 different_privs_mask set_admin_privileges THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out return_mac ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. access_audit_$log_general level$get ring_alarm$reset setfaults$disconnect THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. access_operations_$system_privilege_modify pds$access_authorization pds$admin_privileges pds$apt_ptr pds$kstp LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 14 000176 64 000204 67 000216 68 000221 69 000223 70 000226 72 000227 75 000237 76 000242 77 000244 78 000247 81 000250 84 000256 86 000267 87 000271 88 000273 89 000275 99 000276 102 000306 104 000310 106 000316 107 000321 110 000322 113 000331 115 000336 117 000344 118 000347 120 000350 123 000357 124 000361 126 000364 127 000365 128 000367 129 000370 130 000373 132 000374 135 000403 137 000410 139 000413 140 000414 141 000416 142 000417 143 000422 145 000423 148 000432 150 000434 152 000437 153 000441 154 000442 155 000443 156 000446 158 000447 161 000456 162 000463 164 000466 165 000470 166 000471 167 000472 169 000475 171 000476 174 000505 175 000507 177 000515 178 000520 180 000521 182 000530 184 000535 186 000543 187 000546 189 000547 191 000556 192 000560 194 000566 195 000571 197 000572 200 000601 201 000606 203 000614 204 000617 206 000620 209 000627 210 000631 212 000637 213 000642 215 000643 217 000652 218 000657 220 000665 221 000670 223 000671 226 000700 227 000702 229 000710 230 000713 232 000714 234 000723 235 000730 237 000736 238 000741 241 000742 248 000743 249 000744 251 000745 254 000746 256 000750 258 000754 259 000755 261 000765 262 000776 265 001016 266 001020 270 001031 272 001033 275 001034 287 001036 288 001040 290 001041 293 001043 295 001044 297 001046 299 001053 301 001063 303 001067 306 001072 307 001074 308 001100 309 001104 310 001105 311 001107 312 001111 315 001215 319 001216 332 001222 333 001230 334 001232 336 001241 337 001242 338 001247 340 001255 342 001266 344 001321 346 001323 347 001330 349 001334 351 001340 353 001342 355 001346 357 001355 359 001364 373 001373 376 001374 379 001400 382 001404 383 001406 384 001413 386 001416 388 001422 390 001426 393 001433 394 001437 396 001443 398 001453 401 001463 402 001464 403 001471 405 001500 407 001511 408 001544 410 001561 412 001573 426 001575 ----------------------------------------------------------- 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