COMPILATION LISTING OF SEGMENT mdc_util_ 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 1019.6 mst Sat Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* *********************************************************** */ 11 12 13 /* MDC_UTIL_: Collection of primitives for maintaining Master Directory Control Segments */ 14 /* All the functions of allocating and freeing items in an MDCS, or threading and unthreading them, 15* are located in this module */ 16 17 /* Written March 1976 by Larry Johnson */ 18 19 mdc_util_: proc; 20 21 22 /* Parameters */ 23 24 dcl arg_code fixed bin (35); /* A standard status code */ 25 dcl arg_mdcsp ptr; /* Pointer to MDCS */ 26 dcl arg_mdirp ptr; /* Pointer to directory entry in mdcs */ 27 dcl arg_acctp ptr; /* Pointer to account entry in mdcs */ 28 dcl arg_person char (*); /* Person part of quota account name */ 29 dcl arg_project char (*); /* Project part of quota account name */ 30 dcl arg_uidpath (0:15) bit (36) aligned; /* UID pathname of master directory */ 31 dcl arg_pathhead bit (18) aligned; /* Rel pointer to first entry in pathname list */ 32 dcl arg_pathp ptr; 33 34 /* Automatic storage */ 35 36 dcl (i, j) fixed bin; 37 dcl tacctp ptr; /* Temp pointer to account entry */ 38 dcl prev_offset bit (18); /* Used while following threads */ 39 40 41 42 dcl (addr, null, ptr, unspec, rel) builtin; 43 44 dcl error_table_$file_is_full ext fixed bin (35); 45 dcl error_table_$mdc_path_restrict ext fixed bin (35); 46 47 dcl area condition; 48 49 50 1 1 /* Begin include file ..... mdcs.incl.pl1 */ 1 2 /* Modified to give quota enough precision BIM 83-12-07 */ 1 3 1 4 /* Format of a master directory control segment */ 1 5 1 6 dcl mdcsp ptr; /* Pointer to structure */ 1 7 1 8 dcl 1 mdcs aligned based (mdcsp), /* A master directory control segment */ 1 9 2 head like mdcs_head, /* First the header */ 1 10 2 area area (0 refer (mdcs.area_size)); /* Followed by an area for allocating data */ 1 11 1 12 dcl 1 mdcs_head aligned based, /* The header portion of the mdcs */ 1 13 2 version fixed bin, /* Version of structure */ 1 14 2 init bit (1) unal, /* Set when mdcs created */ 1 15 2 free_bits bit (35) unal, 1 16 2 time_checked fixed bin (71), /* Time this MDCS last checked for consistency */ 1 17 2 volume char (32), /* Name of volume */ 1 18 2 uid bit (36), /* Unique id of volume */ 1 19 2 acct_offset bit (18), /* Offset to first account entry */ 1 20 2 dir_offset bit (18), /* Pointer to first directory entry */ 1 21 2 backup (3) fixed bin (35), /* Statistics for backup */ 1 22 2 area_size fixed bin (18), /* Size of the area (rest of segment) */ 1 23 2 restrict_path bit (18), /* List of pathnames in volume restict list */ 1 24 2 default_path bit (18), /* List of pathnames in volume default list */ 1 25 2 fill (43) bit (36) aligned; /* Pad to octal 100 */ 1 26 1 27 dcl mdcs_version fixed bin int static options (constant) init (1); /* Latest version */ 1 28 1 29 dcl mdirp ptr; /* Pointer to directory entry */ 1 30 1 31 dcl 1 mdirent aligned based (mdirp), 1 32 2 next bit (18) unal, /* Pointer to next entry */ 1 33 2 fill bit (18) unal, 1 34 2 uidpath (0:15) bit (36), /* Uid pathname of master dir */ 1 35 2 owner, /* Owner of directory */ 1 36 3 person char (22) unal, 1 37 3 project char (9) unal, 1 38 2 quota_offset bit (18), /* Rel pointer to quota account */ 1 39 2 quota fixed bin (18), /* The quota */ 1 40 2 backup (3) fixed bin (35), /* Statistics for backup */ 1 41 2 fill2 (10) bit (36) aligned; 1 42 1 43 dcl acctp ptr; /* Pointer to account entry */ 1 44 1 45 dcl 1 acctent aligned based (acctp), 1 46 2 next bit (18) unal, /* Relative pointer to next entry */ 1 47 2 fill bit (18) unal, 1 48 2 name, /* Name of quota account */ 1 49 3 person char (22) unal, 1 50 3 project char (9) unal, 1 51 2 quota fixed bin (35), /* Total quota for account */ 1 52 2 quota_used fixed bin (35), /* Amount of quota assigned to master dirs */ 1 53 2 trp fixed bin (71) unal, /* Time record product for deleted dirs */ 1 54 2 backup (3) fixed bin (35), /* Backup accounting data */ 1 55 2 restrict_path bit (18), /* List of restricting paths for account */ 1 56 2 fill2 (7) bit (36) aligned; 1 57 1 58 dcl pathp ptr; /* Pointer to uid pathname entry */ 1 59 1 60 dcl 1 pathent aligned based (pathp), /* Entry in a list of pathnames */ 1 61 2 next bit (18) unal, 1 62 2 fill bit (18) unal, 1 63 2 uidpath (0:15) bit (36); 1 64 1 65 1 66 /* End include file ..... mdcs.incl.pl1 */ 51 52 53 /* Entry to get a free directory entry in the mdcs */ 54 55 get_mdirent: entry (arg_mdcsp, arg_mdirp, arg_code); 56 57 mdcsp = arg_mdcsp; 58 arg_mdirp = null; /* In case error return */ 59 60 on area go to full_file; 61 allocate mdirent in (mdcs.area) set (mdirp); /* Create new directory entry */ 62 63 unspec (mdirent) = "0"b; /* Return an empty entry */ 64 arg_mdirp = mdirp; /* Set return pointer */ 65 arg_code = 0; 66 return; 67 full_file: arg_code = error_table_$file_is_full; 68 return; 69 70 71 /* Entry to thread in a completed directory entry */ 72 73 thread_mdirent: entry (arg_mdirp); 74 75 mdirp = arg_mdirp; 76 mdcsp = ptr (mdirp, 0); /* Header at start of segment */ 77 mdirent.next = mdcs.dir_offset; /* Make next old list head */ 78 mdcs.dir_offset = rel (mdirp); /* And set new head */ 79 return; 80 81 /* Entry to find the directory entry for a given uid pathname */ 82 83 find_mdirent: entry (arg_mdcsp, arg_uidpath, arg_mdirp); 84 85 mdcsp = arg_mdcsp; 86 arg_mdirp = null; 87 mdirp = ptr (mdcsp, mdcs.dir_offset); /* Head of list */ 88 do while (rel (mdirp) ^= "0"b); 89 if unspec (mdirent.uidpath) = unspec (arg_uidpath) then do; 90 arg_mdirp = mdirp; /* Found it */ 91 return; 92 end; 93 mdirp = ptr (mdcsp, mdirent.next); 94 end; 95 return; 96 97 /* Entry to free a directory entry */ 98 99 free_mdirent: entry (arg_mdirp); 100 101 mdirp = arg_mdirp; 102 mdcsp = ptr (mdirp, 0); 103 104 call unthread (mdcs.dir_offset, mdirp); /* Unthread if from list */ 105 106 unspec (mdirent) = "0"b; /* Clear out entry */ 107 free mdirent in (mdcs.area); 108 arg_mdirp = null; /* Invalidate callers pointer */ 109 return; 110 111 /* Entry to get a free account entry */ 112 113 get_acctent: entry (arg_mdcsp, arg_acctp, arg_code); 114 115 mdcsp = arg_mdcsp; 116 arg_acctp = null; 117 118 on area go to full_file; 119 allocate acctent in (mdcs.area) set (acctp); 120 121 unspec (acctent) = "0"b; /* Clear new entry */ 122 arg_acctp = acctp; 123 arg_code = 0; 124 return; 125 126 /* Entry to free an account entry */ 127 128 free_acctent: entry (arg_acctp); 129 130 acctp = arg_acctp; 131 mdcsp = ptr (acctp, 0); 132 133 call unthread (mdcs.acct_offset, acctp); /* Remove from list */ 134 135 unspec (acctent) = "0"b; /* Clear free entry */ 136 free acctent in (mdcs.area); 137 arg_acctp = null; 138 return; 139 140 /* Entry to thread an account entry into the list according to the account name. 141* Account names are divided into classes as for acls: 142* 0. Person.Project 143* 1. Person.* 144* 2. *.Project 145* 3. *.* 146* All entries are ordered by class, and new entries go at the end of their class. */ 147 148 thread_acctent: entry (arg_acctp); 149 150 acctp = arg_acctp; 151 mdcsp = ptr (acctp, 0); 152 153 if mdcs.acct_offset = "0"b then do; /* If list is empty, thread at head */ 154 acctent.next = "0"b; /* This is last */ 155 mdcs.acct_offset = rel (acctp); 156 return; 157 end; 158 159 i = 0; /* Compute class of new account name */ 160 if acctent.name.person = "*" then i = i + 2; 161 if acctent.name.project = "*" then i = i + 1; 162 163 prev_offset = "0"b; /* Save previous pointer here when scanning list */ 164 tacctp = ptr (mdcsp, mdcs.acct_offset); /* Head of list */ 165 thacct_loop: j = 0; /* Compute class of entry */ 166 if tacctp -> acctent.name.person = "*" then j = j + 2; 167 if tacctp -> acctent.name.project = "*" then j = j + 1; 168 if i < j then do; /* New class less than old, so it goes here */ 169 acctent.next = rel (tacctp); /* Next pointer of new entry */ 170 if prev_offset = "0"b then /* If inserting at head of list */ 171 mdcs.acct_offset = rel (acctp); 172 else do; /* Inserting in middle */ 173 tacctp = ptr (mdcsp, prev_offset); 174 tacctp -> acctent.next = rel (acctp); 175 end; 176 end; 177 else if tacctp -> acctent.next = "0"b then do; /* Reached end of list */ 178 acctent.next = "0"b; /* Thread on end */ 179 tacctp -> acctent.next = rel (acctp); 180 end; 181 else do; /* Step to next one */ 182 prev_offset = rel (tacctp); 183 tacctp = ptr (mdcsp, tacctp -> acctent.next); 184 go to thacct_loop; 185 end; 186 return; 187 188 /* Entry to find an account entry in the mdcs */ 189 190 find_acctent: entry (arg_mdcsp, arg_person, arg_project, arg_acctp); 191 192 arg_acctp = null; 193 mdcsp = arg_mdcsp; 194 195 acctp = ptr (mdcsp, mdcs.acct_offset); 196 do while (rel (acctp) ^= "0"b); 197 if acctent.name.person = arg_person & 198 acctent.name.project = arg_project then do; 199 arg_acctp = acctp; 200 return; 201 end; 202 acctp = ptr (mdcsp, acctent.next); 203 end; 204 return; 205 206 207 /* Entry to find the proper quota account given person and project names */ 208 209 find_matching_acctent: entry (arg_mdcsp, arg_person, arg_project, arg_acctp); 210 211 mdcsp = arg_mdcsp; 212 arg_acctp = null; 213 acctp = ptr (mdcsp, mdcs.acct_offset); /* First in list */ 214 do while (rel (acctp) ^= "0"b); 215 if (arg_person = acctent.person | acctent.person = "*") & 216 (arg_project = acctent.project | acctent.project = "*") then do; 217 arg_acctp = acctp; 218 return; 219 end; 220 acctp = ptr (mdcsp, acctent.next); 221 end; 222 return; 223 224 /* Entry to get a free pathname entry */ 225 226 get_pathent: entry (arg_mdcsp, arg_pathp, arg_code); 227 228 mdcsp = arg_mdcsp; 229 arg_pathp = null; 230 231 on area go to full_file; 232 233 allocate pathent in (mdcs.area) set (pathp); 234 235 unspec (pathent) = "0"b; 236 arg_code = 0; 237 arg_pathp = pathp; 238 return; 239 240 /* Entry to thread in a new pathname entry */ 241 242 thread_pathent: entry (arg_pathhead, arg_pathp); 243 244 pathp = arg_pathp; 245 246 pathent.next = arg_pathhead; /* Make new entry point at current head */ 247 arg_pathhead = rel (pathp); /* And make the head the new entry */ 248 return; 249 250 /* Entry that will search a pathent list for a given pathname */ 251 252 find_pathent: entry (arg_pathhead, arg_uidpath, arg_pathp); 253 254 arg_pathp = null; 255 mdcsp = ptr (addr (arg_pathhead), 0); 256 pathp = ptr (mdcsp, arg_pathhead); /* First in list */ 257 do while (rel (pathp) ^= "0"b); /* Scan entire list */ 258 if unspec (pathent.uidpath) = unspec (arg_uidpath) then do; 259 arg_pathp = pathp; /* Go it */ 260 return; 261 end; 262 pathp = ptr (mdcsp, pathent.next); 263 end; 264 return; /* Failed */ 265 266 /* Entry to unthread and free a pathname entry */ 267 268 free_pathent: entry (arg_pathhead, arg_pathp); 269 270 pathp = arg_pathp; 271 272 mdcsp = ptr (pathp, 0); 273 call unthread (arg_pathhead, pathp); 274 unspec (pathent) = "0"b; 275 free pathent in (mdcs.area); 276 arg_pathp = null; 277 return; 278 279 /* Entry to check a pathname to see if it matches some element in a list */ 280 281 check_pathent: entry (arg_pathhead, arg_uidpath, arg_code); 282 283 arg_code = 0; 284 if arg_pathhead = "0"b then return; /* Everything matches an empty list */ 285 mdcsp = ptr (addr (arg_pathhead), 0); 286 287 pathp = ptr (mdcsp, arg_pathhead); /* First element in list */ 288 do while (rel (pathp) ^= "0"b); 289 do i = 0 to 15 while (pathent.uidpath (i) ^= "0"b); 290 if pathent.uidpath (i) ^= arg_uidpath (i) then go to check_next; 291 end; 292 return; 293 check_next: pathp = ptr (mdcsp, pathent.next); 294 end; 295 arg_code = error_table_$mdc_path_restrict; 296 return; 297 298 /* Internal procedure that unthreads something from a list */ 299 300 unthread: proc (head, p); 301 302 dcl head bit (18) aligned; /* Rel pointer to head of list */ 303 dcl p ptr; /* The element to unthread */ 304 dcl q ptr; 305 306 dcl 1 list aligned based, /* All lists look like this */ 307 2 next bit (18) unal, 308 2 fill bit (18) unal; 309 310 if head = "0"b then return; /* Empty list is no problem */ 311 312 if head = rel (p) then do; /* Unthreading first thing in list */ 313 head = p -> list.next; /* Make head second thing list */ 314 return; 315 end; 316 317 q = ptr (mdcsp, head); /* Start of list */ 318 do while (q -> list.next ^= "0"b); /* Do until end */ 319 if q -> list.next = rel (p) then do; /* Found entry before the one being removed */ 320 q -> list.next = p -> list.next; /* This does the unthreading */ 321 return; /* Done */ 322 end; 323 q = ptr (mdcsp, q -> list.next); 324 end; 325 return; /* Wasn't in list */ 326 327 end unthread; 328 329 end mdc_util_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/11/89 0802.6 mdc_util_.pl1 >spec>install>1111>mdc_util_.pl1 51 1 11/20/84 1944.9 mdcs.incl.pl1 >ldd>include>mdcs.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. acct_offset 15 based bit(18) level 3 dcl 1-8 set ref 133* 153 155* 164 170* 195 213 acctent based structure level 1 dcl 1-45 set ref 119 121* 135* 136 acctp 000120 automatic pointer dcl 1-43 set ref 119* 121 122 130* 131 133* 135 136 150* 151 154 155 160 161 169 170 174 178 179 195* 196 197 197 199 202* 202 213* 214 215 215 215 215 217 220* 220 addr builtin function dcl 42 ref 255 285 area 100 based area level 2 in structure "mdcs" dcl 1-8 in procedure "mdc_util_" ref 61 107 119 136 233 275 area 000106 stack reference condition dcl 47 in procedure "mdc_util_" ref 60 118 231 arg_acctp parameter pointer dcl 27 set ref 113 116* 122* 128 130 137* 148 150 190 192* 199* 209 212* 217* arg_code parameter fixed bin(35,0) dcl 24 set ref 55 65* 67* 113 123* 226 236* 281 283* 295* arg_mdcsp parameter pointer dcl 25 ref 55 57 83 85 113 115 190 193 209 211 226 228 arg_mdirp parameter pointer dcl 26 set ref 55 58* 64* 73 75 83 86* 90* 99 101 108* arg_pathhead parameter bit(18) dcl 31 set ref 242 246 247* 252 255 256 268 273* 281 284 285 287 arg_pathp parameter pointer dcl 32 set ref 226 229* 237* 242 244 252 254* 259* 268 270 276* arg_person parameter char packed unaligned dcl 28 ref 190 197 209 215 arg_project parameter char packed unaligned dcl 29 ref 190 197 209 215 arg_uidpath parameter bit(36) array dcl 30 ref 83 89 252 258 281 290 dir_offset 16 based bit(18) level 3 dcl 1-8 set ref 77 78* 87 104* error_table_$file_is_full 000010 external static fixed bin(35,0) dcl 44 ref 67 error_table_$mdc_path_restrict 000012 external static fixed bin(35,0) dcl 45 ref 295 head based structure level 2 in structure "mdcs" dcl 1-8 in procedure "mdc_util_" head parameter bit(18) dcl 302 in procedure "unthread" set ref 300 310 312 313* 317 i 000100 automatic fixed bin(17,0) dcl 36 set ref 159* 160* 160 161* 161 168 289* 289* 290 290* j 000101 automatic fixed bin(17,0) dcl 36 set ref 165* 166* 166 167* 167 168 list based structure level 1 dcl 306 mdcs based structure level 1 dcl 1-8 mdcs_head based structure level 1 dcl 1-12 mdcsp 000114 automatic pointer dcl 1-6 set ref 57* 61 76* 77 78 85* 87 87 93 102* 104 107 115* 119 131* 133 136 151* 153 155 164 164 170 173 183 193* 195 195 202 211* 213 213 220 228* 233 255* 256 262 272* 275 285* 287 293 317 323 mdirent based structure level 1 dcl 1-31 set ref 61 63* 106* 107 mdirp 000116 automatic pointer dcl 1-29 set ref 61* 63 64 75* 76 77 78 87* 88 89 90 93* 93 101* 102 104* 106 107 name 1 based structure level 2 dcl 1-45 next based bit(18) level 2 in structure "acctent" packed packed unaligned dcl 1-45 in procedure "mdc_util_" set ref 154* 169* 174* 177 178* 179* 183 202 220 next based bit(18) level 2 in structure "pathent" packed packed unaligned dcl 1-60 in procedure "mdc_util_" set ref 246* 262 293 next based bit(18) level 2 in structure "mdirent" packed packed unaligned dcl 1-31 in procedure "mdc_util_" set ref 77* 93 next based bit(18) level 2 in structure "list" packed packed unaligned dcl 306 in procedure "unthread" set ref 313 318 319 320* 320 323 null builtin function dcl 42 ref 58 86 108 116 137 192 212 229 254 276 p parameter pointer dcl 303 ref 300 312 313 319 320 pathent based structure level 1 dcl 1-60 set ref 233 235* 274* 275 pathp 000122 automatic pointer dcl 1-58 set ref 233* 235 237 244* 246 247 256* 257 258 259 262* 262 270* 272 273* 274 275 287* 288 289 290 293* 293 person 1 based char(22) level 3 packed packed unaligned dcl 1-45 set ref 160 166 197 215 215 prev_offset 000104 automatic bit(18) packed unaligned dcl 38 set ref 163* 170 173 182* project 6(18) based char(9) level 3 packed packed unaligned dcl 1-45 set ref 161 167 197 215 215 ptr builtin function dcl 42 ref 76 87 93 102 131 151 164 173 183 195 202 213 220 255 256 262 272 285 287 293 317 323 q 000140 automatic pointer dcl 304 set ref 317* 318 319 320 323* 323 rel builtin function dcl 42 ref 78 88 155 169 170 174 179 182 196 214 247 257 288 312 319 tacctp 000102 automatic pointer dcl 37 set ref 164* 166 167 169 173* 174 177 179 182 183* 183 uidpath 1 based bit(36) array level 2 in structure "pathent" dcl 1-60 in procedure "mdc_util_" set ref 258 289 290 uidpath 1 based bit(36) array level 2 in structure "mdirent" dcl 1-31 in procedure "mdc_util_" set ref 89 unspec builtin function dcl 42 set ref 63* 89 89 106* 121* 135* 235* 258 258 274* NAME DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. mdcs_version internal static fixed bin(17,0) initial dcl 1-27 NAMES DECLARED BY EXPLICIT CONTEXT. check_next 001170 constant label dcl 293 ref 290 check_pathent 001130 constant entry external dcl 281 find_acctent 000516 constant entry external dcl 190 find_matching_acctent 000607 constant entry external dcl 209 find_mdirent 000137 constant entry external dcl 83 find_pathent 001014 constant entry external dcl 252 free_acctent 000322 constant entry external dcl 128 free_mdirent 000206 constant entry external dcl 99 free_pathent 001065 constant entry external dcl 268 full_file 000101 constant label dcl 67 ref 60 118 231 get_acctent 000246 constant entry external dcl 113 get_mdirent 000027 constant entry external dcl 55 get_pathent 000711 constant entry external dcl 226 mdc_util_ 000015 constant entry external dcl 19 thacct_loop 000431 constant label dcl 165 ref 184 thread_acctent 000362 constant entry external dcl 148 thread_mdirent 000111 constant entry external dcl 73 thread_pathent 000767 constant entry external dcl 242 unthread 001203 constant entry internal dcl 300 ref 104 133 273 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1504 1520 1255 1514 Length 1734 1255 14 177 227 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME mdc_util_ 115 external procedure is an external procedure. on unit on line 60 64 on unit on unit on line 118 64 on unit on unit on line 231 64 on unit unthread internal procedure shares stack frame of external procedure mdc_util_. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME mdc_util_ 000100 i mdc_util_ 000101 j mdc_util_ 000102 tacctp mdc_util_ 000104 prev_offset mdc_util_ 000114 mdcsp mdc_util_ 000116 mdirp mdc_util_ 000120 acctp mdc_util_ 000122 pathp mdc_util_ 000140 q unthread THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. return_mac tra_ext_1 enable_op ext_entry ext_entry_desc int_entry op_alloc_ op_freen_ NO EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$file_is_full error_table_$mdc_path_restrict LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 19 000014 55 000022 57 000037 58 000043 60 000045 61 000064 63 000072 64 000075 65 000076 66 000100 67 000101 68 000105 73 000106 75 000121 76 000124 77 000126 78 000130 79 000132 83 000133 85 000147 86 000153 87 000155 88 000162 89 000164 90 000173 91 000174 93 000175 94 000202 95 000203 99 000204 101 000216 102 000221 104 000223 106 000233 107 000237 108 000241 109 000243 113 000244 115 000256 116 000262 118 000264 119 000303 121 000311 122 000314 123 000315 124 000317 128 000320 130 000332 131 000335 133 000337 135 000347 136 000353 137 000355 138 000357 148 000360 150 000372 151 000375 153 000377 154 000403 155 000405 156 000407 159 000410 160 000411 161 000417 163 000424 164 000425 165 000431 166 000432 167 000441 168 000446 169 000451 170 000454 173 000462 174 000465 176 000467 177 000470 178 000474 179 000476 180 000500 182 000501 183 000503 184 000507 186 000510 190 000511 192 000541 193 000543 195 000547 196 000554 197 000556 199 000574 200 000575 202 000576 203 000603 204 000604 209 000605 211 000632 212 000636 213 000640 214 000645 215 000650 217 000676 218 000677 220 000700 221 000705 222 000706 226 000707 228 000721 229 000725 231 000727 233 000746 235 000754 236 000757 237 000761 238 000762 242 000763 244 000777 246 001002 247 001005 248 001007 252 001010 254 001024 255 001026 256 001032 257 001037 258 001043 259 001052 260 001053 262 001054 263 001061 264 001062 268 001063 270 001075 272 001100 273 001102 274 001113 275 001117 276 001121 277 001123 281 001124 283 001135 284 001137 285 001142 287 001145 288 001150 289 001153 290 001162 291 001165 292 001167 293 001170 294 001175 295 001176 296 001202 300 001203 310 001205 312 001212 313 001217 314 001222 317 001223 318 001227 319 001234 320 001242 321 001245 323 001246 324 001252 325 001253 ----------------------------------------------------------- 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