THIS FILE IS DAMAGED COMPILATION LISTING OF SEGMENT backup_load_dir_list 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 0934.5 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 14 /* Creates entries for the hierarhcy reloader/retriever and also processes the "directory_list" record */ 15 16 /* Modified: 17 June 1970 by R. H. Campbell */ 17 /* Modified: 16 November 1972 by M. A. Meer */ 18 /* Modified: 20 December 1972 by A. Downing to make calls to old area package */ 19 /* Modified: 21 October 1974 by A. Kobziar to add access_class arg to $build_tree */ 20 /* Modified: 21 July 1975 by R. Bratt to fix bug in setting code and to remove pre 18-0 stuff */ 21 /* Modified: Fall 1975 by R. E. Mullen for interim NSS reloader */ 22 /* Modified: Winter 1976 by R. E. Mullen to speed up reloading for NSS by calling list_dir_fast */ 23 /* Modified: February 1976 by T. VanVleck to remove change made by A. Kobziar to move quota on retrievals */ 24 /* Modified: April 1976 by R. Bratt to reload sons_lvid and to expunge dir quota reloading krock */ 25 /* Modified: 9 November 1977 by Steve Herbst */ 26 /* Modified: 21 January 1982 by S. Herbst to not cross-retrieve a segment in place of an existing directory */ 27 /* Modified: July 1982 by G. Palter to add features for IMFT support of AIM: enforce a minimum ring for all created 28* branches, restore the access class of the branch even if in debug mode, and translate access classes between systems */ 29 /* Fixed to use default rb's of 7,7 for dirs, 5,5,5 for segs 01/03/83 S. Herbst */ 30 /* Modified to set dir_quota when appending on 12/84 by Keith Loepere. */ 31 32 /* format: style4,delnl,insnl,ifthenstmt,ifthen */ 33 34 35 backup_load_dir_list: 36 procedure (hp1, code2) options (rename ((area_, old_area_), (alloc_, old_alloc_), (freen_, old_freen_))); 37 38 dcl hp1 ptr, /* Pointer to preamble header structure. */ 39 code2 fixed bin (35); /* Returned error code. */ 40 41 dcl dname char (168) aligned, /* Directory path name. */ 42 ename char (32) aligned, /* entry name */ 43 pname char (*) aligned, /* Link path name if link. */ 44 (code3, saved_code) fixed bin (35), /* Error code */ 45 bit_count fixed bin (24), /* segment bit count */ 46 optionsw fixed bin (2); /* Entry option switch. */ 47 48 dcl dtp fixed bin (52); /* Times. */ 49 50 dcl access_class bit (72) aligned; 51 dcl (access_class_octal, tape_access_class_octal) character (32) aligned; 52 dcl (access_class_text, tape_access_class_text) character (256); 53 54 dcl ( 55 hp, /* Pointer to preamble header. */ 56 pp, /* Pointer to link path name. */ 57 dqip, /* Pointer to dirquota info */ 58 nip, /* pointer to nss_info */ 59 sys_bp, 60 tape_bp, /* Pointers to branch info arrays. */ 61 sys_lp, 62 tape_lp,5), fixed bin, fixed bin (1), fixed bin (35)), 177 hphcs_$dir_quota_restor 178 entry (char (*) aligned, fixed bin, fixed bin (71), bit (36) aligned, fixed bin, fixed bin (1), fixed bin (35)), 179 hphcs_$set_auth external entry (char (*) aligned, char (*) aligned, fixed bin, char (*) aligned, fixed bin (35)), 180 hphcs_$set_sons_lvid entry (char (*) aligned, char (*) aligned, bit (36) aligned, fixed bin (35)), 181 mdc_$find_lvname entry (bit (36) aligned, char (*), fixed bin (35)), 182 ioa_$rsnnl entry options (variable), 183 pathname_ entry (char (*), char (*)) returns (char (168)), 184 system_privilege_$aim_check_soos external entry (char (*) aligned, char (*) aligned, fixed bin (35)); 185 186 187 dcl (addr, bit, char, divide, fixed, length, max, null, pointer, ptr, rel, rtrim, substr, unspec) builtin; 188 3 1 /* BEGIN: backup_record_types.incl.pl1 * * * * * */ 3 2 3 3 3 4 /****^ HISTORY COMMENTS: 3 5* 1) change(87-01-05,GDixon), approve(87-04-15,MCR7617), 3 6* audit(87-06-22,RBarstad), install(87-07-15,MR12.1-1040): 3 7* Converted internal static variables to named constants. Renamed 3 8* record_type array to RECORD_TYPE, to avoid naming conflict with 3 9* backup_preamble_header.incl.pl1's h.record_type variable. 3 10* END HISTORY COMMENTS */ 3 11 3 12 3 13 /* Created June 1970, R H Campbell. */ 3 14 /* Modified 1/16/73 by N. I. Morris */ 3 15 /* Modified 7/17/75 by R. Bratt */ 3 16 /* Modified 11/04/83 by G. Dixon - better comments */ 3 17 3 18 dcl ndc_segment fixed binary int static options(constant) initial (1); 3 19 /* Record of segment with NDC attributes */ 3 20 dcl ndc_directory fixed binary int static options(constant) initial (2); 3 21 /* Record of directory with NDC attributes */ 3 22 dcl ndc_directory_list fixed binary int static options(constant) initial (3); 3 23 /* Record of directory list with initial ACL */ 3 24 dcl sec_seg fixed binary int static options(constant) initial(19); 3 25 /* Seg with security & call_limiter */ 3 26 dcl sec_dir fixed binary int static options(constant) initial(20); 3 27 /* Dir with security & call_limiter */ 3 28 3 29 dcl RECORD_TYPE (0: 20) character (10) aligned /* Name of the record types. */ 3 30 int static options(constant) 3 31 initial (*, "NDC seg", "NDC dir", "NDC dirlst", *, *, *, *, 3 32 *, *, *, *, *, *, *, *, 3 33 *, *, *, "SEG", "DIR"); 3 34 3 35 /* The following is an excerpt from a backup map showing the relationship 3 36* between entries in the backup map and the named constants given above. 3 37* I don't know under what conditions the ndc_seg and ndc_dir named constants 3 38* are ever used. (G. Dixon) 3 39* 3 40* Map Excerpt 3 41* --------------------------------------------- 3 42*Named Constant ENTRY NAME BLOCKS REC_TYPE 3 43* 3 44*sec_dir >library_dir_dir>system_library_unbundled 3 45* object 0 directory 3 46* o 3 47*sec_dir source 0 directory 3 48* s 3 49* 3 50*ndc_directory_list >library_dir_dir>system_library_unbundled>object 3 51* 0 directory 3 52*sec_seg bound_gcos_tss_.1.archive 104 segment 3 53* 3 54* 3 55*ndc_directory_list >library_dir_dir>system_library_unbundled>source 3 56* 0 directory 3 57*sec_seg bound_gcos_tss_.1.s.archive 134 segment 3 58* 3 59* 3 60* */ 3 61 3 62 3 63 /* END OF: backup_record_types.incl.pl1 * * * * * */ 189 4 1 /* include backup_dir_list */ 4 2 /* Created by R H, /* Record quota for directory_list record. */ 6 28 2 trp fixed binary (35), /* Time-record product .. */ 6 29 2 tlu fixed binary (35), /* Time last updated .. */ 6 30 2 inf_acct fixed binary, /* Inferior account switch .. */ 6 31 2 term_acct fixed binary (1), /* Terminal account switch .. */ 6 32 2 pad1 (3), /* To even out area to 0 mod 8 */ 6 33 6 34 2 max_length fixed bin (18), /* Max. length of segment */ 6 35 2 switches unal, 6 36 3 safety_sw bit (1) unal, /* Segment safety switch */ 6 37 3 entrypt_sw bit (1) unal, /* "1"b -> call limiter enabled */ 6 38 3 security_oosw bit(1) unal, /* security out-of-service */ 6 39 3 audit_flag bit(1) unal, /* flag for seg reference auditing */ 6 40 3 multiple_class bit (1) unal, /* system segment: access class may be higher than parent's */ 6 41 3 pad2 bit(2) unal, /* =pad2 in dir_entry */ 6 42 3 master_dir bit (1) unal, /* "1"b => was master dir */ 6 43 3 tpd bit (1) unal, /* TRUE => never put on paging device */ 6 44 3 sw_pad bit (13) unal, /* padding in this structure */ 6 45 2 entrypt_bound bit (14) unal, /* Call limiter. */ 6 46 2 access_class bit(72), /* access class of entry */ 6 47 2 spad bit(36), /* last word of dir entry */ 6 48 2 status_version fixed bin, /* version of status_for_backup struct */ 6 49 2 nss_info_relp bit (18) aligned, /* NONZERO => NSS INFO */ 6 50 2 dq_info_relp bit (18) aligned, /* NONZERO => DIRQUOTA INFO */ 6 51 6 52 2 inaclp (0:7) bit (18), /* Pointer to initial ACL for each ring. */ 6 53 2 inaclc (0:7) fixed bin, /* Initial ACL count for each ring. */ 6 54 2 dir_inaclp (0:7) bit (18), /* Directory initial ACL pointer for each ring. */ 6 55 2 dir_inaclc (0:7) fixed bin, /* Directory initial ACL count for each ring. */ 6 56 6 57 2 bitcount_author char (32), /* last modifier of the bit count */ 6 58 6 59 2 list_area /* area */ (65408); /* Area for list_dir and readacl. */ 6 60 6 61 dcl author char (32) aligned based; /* Author of entry */ 6 62 /* N. B. Author is an overlay starting at h.quota */ 6 63 6 64 /* End of include file ... backup_preamble_header.incl.pl1 */ 6 65 192 193 194 /* */ 195 /* ENTRY to backup_load_dir_list it begins here */ 196 197 code2 = 0; 198 hp = hp1; /* Copy pointer to preamble header. */ 199 current_user = get_group_id_ (); 200 current_ring = cu_$level_get (); 201 202 rtype = hp -> h.record_type; 203 if rtype = ETYPE_DIR | rtype = ETYPE_PARENT_DIR | rtype = ETYPE_UPGRADED_DIR then 204 rings (1), rings (2), rings (3) = 7; /* default for directories */ 205 else rings (1), rings (2), rings (3) = 5; /* default for segments */ 206 207 dtp = hp -> h.dtd; /* Copy time dumped from header. */ 208 tape_bp = pointer (hp, hp -> h.bp); /* Make pointer to branch array. */ 209 tape_bc = hp -> h.bc; /* Copy branch count from header. */ 210 tape_lp = pointer (hp, hp -> h.lp); /* Make pointer to link array. */ 211 212 tape_lc = hp -> h.lc; /* Copy link count from header. */ 213 214 if bk_ss_$trimsw then do; /* Are we to prune excess entry names? */ 215 if listp = null then do; /* Have we been had before? */ 216 call hcs_$make_seg ("", "reload_area", "", 01011b, listp, code); 217 /* Get segment for area. */ 218 if listp = null then do; /* Successful? */ 219 code2 = code; /* Return error code. */ 220 go to check_ac_class; /* Skip to check parent section. */ 221 end; 222 end; 223 call old_area_ (65536, listp); /* Clear area and get contents of system directory. */ 224 call hcs_$list_dir_fast (hp -> h.dname, listp -> list_area, sys_bp, sys_bc, sys_lp, sys_lc, code); 225 if code = 0 then do; /* Was call successful? */ 226 if sys_lc > 0 then do; /* Are there any links in the system? */ 227 call chain_links (sys_lp, sys_lc, sys_links, sys_links_names, 0); 228 /* Chain all their names together. */ 229 call chain_links (tape_lp, tape_lc, tape_links, tape_links_names, 1); 230 /* Chain the names from the tape. */ 231 call prune (sys_links, sys_links_names, tape_links, tape_links_names); 232 /* Compare them and remove excess. */ 233 end; 234 if sys_bc > 0 then do; /* Are there any branches in the system? */ 235 call chain_branches (sys_bp, sys_bc, sys_dirs, sys_dirs_names, sys_segs, sys_segs_names, 0); 236 /* Chain names into two lists. */ 237 call chain_branches (tape_bp, tape_bc, tape_dirs, tape_dirs_names, tape_segs, tape_segs_names, 1) 238 ; /* Chain names from tape. */ 239 if sys_dirs ^= null then 240 if bk_ss_$dir_trim then /* Are there any directory names on line */ 241 call prune (sys_dirs, sys_dirs_names, tape_dirs, tape_dirs_names); 242 if sys_segs ^= null then /* Are there any segments in the system? */ 243 call prune (sys_segs, sys_segs_names, tape_segs, tape_segs_names); 244 /* Yes, examine and prune them. */ 245 end; 246 end; 247 else if code ^= error_table_$no_dir then /* Gripe if unsuccessful (no access: no directory). */ 248 call backup_map_$fs_error_line (code, "hcs_$list_dir_fast", hp -> h.dname, ""); 249 code2 = code; /* Save error code. */ 250 call hcs_$truncate_seg (listp, 0, code); /* Free up pages of segment. */ 251 end; 252 253 /* */ 254 255 check_ac_class: /* See if should do the work */ 256 if (hp -> h.access_class & (^sys_info$access_class_ceiling)) ^= "0"b then do; 257 hp -> h.access_class, hp -> h.multiple_class = "0"b; 258 /* old values */ 259 end; 260 rtype = ETYPE_DIR; /* assume regular directory */ 261 if hp -> h.record_type = ndc_directory_list then 262 if hp -> h.multiple_class then rtype = ETYPE_UPGRADED_DIR; 263 /* an upgraded directory */ 264 call hcs_$get_access_class (hp -> h.dname, "", access_class, code); 265 if code ^= 0 then do; /* try creating parent(s) */ 266 if hp -> h.record_type = ndc_directory_list then 267 access_class = hp -> h.access_class; 268 else access_class = "0"b; 269 call backup_load_dir_list$build_tree (hp -> h.dname, "", rtype, 0, 0, "", access_class, code); 270 if code ^= 0 then do; /* print error and give up */ 271 call backup_map_$fs_error_line (code, "backup_load_dir_list$build_tree", hp -> h.dname, ""); 272 code2 = code; /* return code */ 273 go to bldl_ret; 274 end; 275 end; 276 else if (current_ring <= 1) | bk_ss_$restore_access_class then do; 277 /* insure that online branch has the same access class */ 278 if hp -> h.record_type = ndc_directory_list then do; 279 if ^aim_check_$equal (hp -> h.access_class, access_class) then do; 280 call convert_authorization_$to_string_short (access_class, access_class_text, code); 281 if code ^= 0 then do; 282 call convert_aim_attributes_ (access_class, access_class_octal); 283 access_class_text = access_class_octal; 284 end; 285 call convert_authorization_$to_string_short (bk_ss_$hp -> h.access_class, tape_access_class_text, 286 code); 287 if code ^= 0 then do; 288 call convert_aim_attributes_ (bk_ss_$hp -> h.access_class, tape_access_class_octal); 289 tape_access_class_text = tape_access_class_octal; 290 end; 291 call backup_map_$error_line (error_table_$ai_restricted, bk_ss_$myname, 292 "Access class of branch ^a online (^[^a^;^ssystem_low^]) is not equal to access class on (^[^a^;^ssystem_low^])." 293 , hp -> h.dname, (access_class_text ^= ""), access_class_text, 294 (tape_access_class_text ^= ""), tape_access_class_text); 295 code2 = error_table_$ai_restricted; 296 go to bldl_ret; /* can't do this */ 297 end; 298 else go to reload_links; /* great match! */ 299 end; /* use the access class in the parent */ 300 end; 301 302 /* */ 303 304 reload_links: 305 do tape_i = 1 to tape_lc; /* Reload each link. */ 306 tape_ix = addr (tape_lp -> lk (tape_i)); /* Get pointer to this element. */ 307 tape_np = pointer (tape_lp, tape_ix -> lk (1).namerp); 308 /* Get first name. */ 309 pp = pointer (tape_lp, tape_ix -> lk (1).pathnamerp); 310 /* Get path name. */ 311 call backup_load_dir_list$build_tree (hp -> h.dname, tape_np -> name (1).string, ETYPE_LINK, 0, 0, 312 substr (pp -> path.name, 1, fixed (path.size, 17)), access_class, code); 313 if code ^= 0 then do; /* If unsuccessful, print error comment. */ 314 call backup_map_$fs_error_line (code, "backup_load_dir_list$build_tree", hp -> h.dname, 315 tape_np -> name (1).string); 316 go to next_link; /* Go get next link. */ 317 end; 318 319 call backup_util$add_names (hp -> h.dname, tape_np -> name (1).string, tape_np, 320 fixed (tape_ix -> lk (1).nnames, 17), 0); 321 /* if no_reload will simply print names in the map */ 322 323 if ^bk_ss_$no_reload then do; 324 times.dtem = fixed (tape_ix -> lk (1).dtm, 52); 325 /* Copy time entry modified. */ 326 times.dtd = dtp; /* Get new dump time. */ 327 if ^bk_ss_$debugsw then 328 call hphcs_$set_backup_times (hp -> h.dname, tape_np -> name (1).string, times, code); 329 else code = 0; /* don't try */ 330 if code ^= 0 then 331 call backup_map_$fs_error_line /* If error reported, give comment. */ 332 (code, "hphcs_$set_backup_times", hp -> h.dname, tape_np -> name (1).string); 333 if hp -> h.record_type = ndc_directory_list then 334 if ^(bk_ss_$debugsw) then do; 335 call hphcs_$set_auth (hp -> h.dname, tape_np -> name (1).string, 0, pp -> path.author, code) 336 ; 337 if code ^= 0 then 338 call backup_map_$fs_error_line (code, "hphcs_$set_auth", hp -> h.dname, 339 tape_np -> name (1).string); 340 end; 341 end; 342 343 next_link: 344 end; 345 346 if ^bk_ss_$no_reload & ^bk_ss_$debugsw then do; 347 if (hp -> h.nss_info_relp ^= "0"b) & hp -> h.master_dir & ^bk_ss_$no_setlvid then do; 348 /* must set sons lvid */ 349 nip = ptr (hp, hp -> h.nss_info_relp); 350 call mdc_$find_lvname (nip -> bk_nss_info.lvid, (""), code); 351 if code = 0 then call hphcs_$set_sons_lvid (hp -> h.dname, "", nip -> bk_nss_info.lvid, code); 352 if code ^= 0 then call backup_map_$fs_error_line (code, "hphcs_$set_sons_lvid", hp -> h.dname, ""); 353 end; 354 if bk_ss_$quotasw then do; /* Are we to restor quotas? */ 355 call hphcs_$quota_reload (hp -> h.dname, hp -> h.quota, 356 /* Reload secondary storage quotas. */ 357 hp -> h.trp, hp -> h.tlu, hp -> h.inf_acct, hp -> h.term_acct, code); 358 if code ^= 0 then call backup_map_$fs_error_line (code, "hphcs_$quota_reload", hp -> h.dname, ""); 359 if hp -> dq_info_relp ^= ""b then do; /* if dirquota info is on tape */ 360 dqip = ptr (hp, hp -> h.dq_info_relp); 361 /* get ptr to dirquota info */ 362 call hphcs_$dir_quota_restor (hp -> h.dname, dqip -> bk_dq_info.quota, dqip -> bk_dq_info.ltrp, 363 dqip -> bk_dq_info.tlu, dqip -> bk_dq_info.inf_acct, dqip -> bk_dq_info.term_acct, code); 364 end; 365 if code ^= 0 then call backup_map_$fs_error_line (code, "hphcs_$dir_quota_restor", hp -> h.dname, ""); 366 end; 367 else if hp -> h.quota ^= 0 then do; /* -noquota was specified */ 368 call ioa_$rsnnl ("Created directory ^a, quota should be ^d but -noquota specified", access_class_text, 369 j, hp -> h.dname, hp -> h.quota); 370 call backup_map_$directory_line (addr (access_class_text), j); 371 end; 372 if rtype = ETYPE_UPGRADED_DIR then do; /* a upgraded directory, created oos, so turn off now */ 373 call system_privilege_$aim_check_soos (hp -> h.dname, "", code); 374 if code ^= 0 then 375 call backup_map_$fs_error_line (code, "system_privilege_$aim_check_soos", hp -> h.dname, ""); 376 end; 377 end; 378 379 bldl_ret: 380 return; /* Return to caller. */ 381 382 383 /* */ 384 /* Make branch in heirarchy for reloader * * * * * * * * * * * * */ 385 386 387 build_tree: 388 entry (dname, ename, type, bit_count, optionsw, pname, class, code3); 389 390 dcl blank char (1) init (""), /* For blank line on map */ 391 dir character (168) aligned, /* New directory path name. */ 392 entry character (32) aligned, /* New entry name. */ 393 dirsw fixed binary (1), 394 class bit (72) aligned, /* access_class for append */ 395 sys_type fixed binary (2), /* 0 = link, 1 = segment, 2 = directory. */ 396 type fixed bin, 397 branch_ptr pointer; 398 399 dcl 1 status_info aligned, /* structure filled by hcs_$status_ */ 400 ( 401 2 type bit (2), 402 2 nnames bit (16), 403 2 nrp bit (18), 404 2 dtm bit (36), 405 2 dtu bit (36), 406 2 mode bit (5), 407 2 pad bit (13), 408 2 records bit (18) 409 ) unal; 410 411 /* type : 0=seg, 1=link, 2=dir, 3=parent_dir, 4=upgraded_segment, 5=upgraded_directory */ 412 7 1 /* BEGIN INCLUDE FILE - - - create_branch_info.incl.pl1 - - - created January 1975 */ 7 2 7 3 7 4 /****^ HISTORY COMMENTS: 7 5* 1) change(89-01-16,TLNguyen), approve(89-01-16,MCR8049), 7 6* audit(89-02-03,Parisek), install(89-03-15,MR12.3-1025): 7 7* 1. Declare version constant properly. 7 8* 2. Remove version 1 since it was never referenced and to force 7 9* callers to upgrade their programs. 7 10* END HISTORY COMMENTS */ 7 11 7 12 7 13 /* Modified December 1984 for dir_quota, Keith Loepere. */ 7 14 7 15 /* this include files gives the argument structure for create_branch_ */ 7 16 7 17 dcl 1 create_branch_info aligned based, 7 18 2 version fixed bin, /* set this to the largest value given below */ 7 19 2 switches unaligned, 7 20 3 dir_sw bit (1) unaligned, /* if on, a directory branch is wanted */ 7 21 3 copy_sw bit (1) unaligned, /* if on, initiating segment will be done by copying */ 7 22 3 chase_sw bit (1) unaligned, /* if on, if pathname is a link, it will be chased */ 7 23 3 priv_upgrade_sw bit (1) unaligned, /* privileged creation (ring 1) of upgraded object */ 7 24 3 parent_ac_sw bit (1) unaligned, /* if on, use parent's access class for seg or dir created */ 7 25 3 mbz1 bit (31) unaligned, /* pad to full word */ 7 26 2 mode bit (3) unaligned, /* segment or directory for acl for userid */ 7 27 2 mbz2 bit (33) unaligned, /* pad to full word */ 7 28 2 rings (3) fixed bin (3), /* branch's ring brackets */ 7 29 2 userid char (32), /* user's access control name */ 7 30 2 bitcnt fixed bin (24), /* bit count of the segment */ 7 31 2 quota fixed bin (18), /* for directories, this am't of quota will be moved to it */ 7 32 2 access_class bit (72), /* is the access class of the body of the branch */ 7 33 2 dir_quota fixed bin (18); /* for directories, this am't of dir quota will be moved to it */ 7 34 7 35 dcl create_branch_version_2 fixed bin int static options (constant) init (2); 7 36 7 37 /* END INCLUDE FILE - - - create_branch_info.incl.pl1 - - - */ 7 38 413 414 dcl 1 branch_info like create_branch_info aligned; /* need auto stor for the structure */ 415 current_user = get_group_id_ (); 416 current_ring = cu_$level_get (); 417 if type = ETYPE_DIR | type = ETYPE_PARENT_DIR | type = ETYPE_UPGRADED_DIR then 418 rings (1), rings (2), rings (3) = 7; /* default for directories */ 419 else rings (1), rings (2), rings (3) = 5; /* default for segments */ 420 421 dirsw = fixed ((type = ETYPE_DIR) | (type = ETYPE_UPGRADED_DIR), 1); 422 /* get dirsw into bin (1) format */ 423 if type = ETYPE_PARENT_DIR then go to no_access; /* Is only superior directory wanted? */ 424 425 retry: 426 attempt = attempt + 1; /* Count this call to append. */ 427 428 if bk_ss_$no_reload then do; /* If debuging on line, skip below */ 429 430 code3 = 0; /* Zero out code before returning */ 431 go to bt_ret; 432 end; 433 434 if attempt > 3 then go to failed; /* Too many (noaccess, namedup, success)? */ 435 if type ^= ETYPE_LINK then do; /* Try to append in specified directory */ 436 if (current_ring > 1) & ^bk_ss_$restore_access_class then do; 437 if bk_ss_$enforce_minimum_ring then do; 438 rings (1) = max (bk_ss_$minimum_ring, rings (1)); 439 rings (2) = max (bk_ss_$minimum_ring, rings (2)); 440 rings (3) = max (bk_ss_$minimum_ring, rings (3)); 441 end; 442 call hcs_$append_branchx (dname, ename, 01111b, rings, current_user, dirsw, optionsw, bit_count, 443 code3); 444 end; 445 else do; 446 unspec (branch_info) = "0"b; 447 branch_info.version = create_branch_version_2; 448 branch_info.mode = "111"b; 449 if type = ETYPE_SEG | type = ETYPE_UPGRADED_SEG then do; 450 /* segment */ 451 if bk_ss_$hp = null then go to default_rb; 452 branch_ptr = ptr (bk_ss_$hp, bk_ss_$hp -> h.bp); 453 if branch_ptr -> br (1).rb1 = "0"b then go to default_rb; 454 branch_info.rings (1) = fixed (branch_ptr -> br (1).rb1, 6); 455 branch_info.rings (2) = fixed (branch_ptr -> br (1).rb2, 6); 456 branch_info.rings (3) = fixed (branch_ptr -> br (1).rb3, 6); 457 end; 458 else do; 459 default_rb: 460 branch_info.rings (1) = rings (1); 461 branch_info.rings (2) = rings (2); 462 branch_info.rings (3) = rings (3); 463 end; 464 if bk_ss_$enforce_minimum_ring then do; 465 branch_info.rings (1) = max (bk_ss_$minimum_ring, branch_info.rings (1)); 466 branch_info.rings (2) = max (bk_ss_$minimum_ring, branch_info.rings (2)); 467 branch_info.rings (3) = max (bk_ss_$minimum_ring, branch_info.rings (3)); 468 end; 469 branch_info.userid = current_user; 470 branch_info.switches.dir_sw = bit (dirsw, 1); 471 branch_info.switches.copy_sw = substr (bit (optionsw, 2), 1, 1); 472 branch_info.switches.chase_sw = "0"b; /* don't chase links */ 473 if (type = ETYPE_UPGRADED_SEG) | (type = ETYPE_UPGRADED_DIR) then 474 /* set for upgraded creation */ 475 branch_info.switches.priv_upgrade_sw = "1"b; 476 else branch_info.switches.priv_upgrade_sw = "0"b; 477 branch_info.quota = 0; 478 branch_info.dir_quota = 0; 479 branch_info.bitcnt = bit_count; 480 branch_info.access_class = class; 481 call hcs_$create_branch_ (dname, ename, addr (branch_info), code3); 482 if code3 ^= 0 then 483 if code3 = error_table_$ai_restricted then do; 484 call convert_authorization_$to_string_short (class, access_class_text, code); 485 if code ^= 0 then do; 486 call convert_aim_attributes_ (class, access_class_octal); 487 access_class_text = access_class_octal; 488 end; 489 call backup_map_$error_line (code3, bk_ss_$myname, 490 "Can not create branch ^a with access class ^[^a^;^ssystem_low^].", 491 pathname_ ((dname), (ename)), (access_class_text ^= ""), access_class_text); 492 go to bt_ret; 493 end; 494 end; 495 end; 496 else call hcs_$append_link (dname, ename, pname, code3); 497 /* No, it's a link, try to append it. */ 498 499 if code3 = error_table_$no_dir then do; 500 no_access: 501 if char (dname, 4) = "> " then do; /* Is it the root directory? */ 502 code3 = error_table_$root; /* Set error code3. */ 503 go to bt_ret; /* Give up. */ 504 end; 505 call expand_pathname_ (dname, dir, entry, code); 506 /* Separate last entry from path */ 507 if code ^= 0 then do; /* OK? */ 508 call backup_map_$fs_error_line (code, "expand_pathname_", dname, ename); 509 /* Gripe. */ 510 go to bt_ret; /* Give up. */ 511 end; 512 if type ^= ETYPE_PARENT_DIR then 513 if bk_ss_$mapsw then do; /* Is request to create superior directory? */ 514 call backup_map_$directory_line (addr (blank), 1); 515 /* Skip a line. */ 516 call backup_map_$directory_line (addr (creating_directory), length (creating_directory)); 517 call backup_map_$directory_line (addr (dname), length (rtrim (dname))); 518 end; 519 call backup_load_dir_list$build_tree (dir, entry, ETYPE_DIR, 0, 0, "", class, code3); 520 /* Try creating directory */ 521 if code3 = 0 then do; /* Successful? */ 522 if type = ETYPE_PARENT_DIR then go to bt_ret; 523 /* Do we have to create an entry? */ 524 code3 = error_table_$noaccess; /* Set up error code3. */ 525 go to retry; /* Retry creating original branch. */ 526 end; 527 else if code3 = error_table_$root then code3 = error_table_$badpath; 528 end; 529 530 else if code3 = error_table_$namedup then do; /* Did name already exist in directory? */ 531 saved_code = code3; 532 if (type = ETYPE_DIR) | (type = ETYPE_UPGRADED_DIR) then do; 533 /* Were we trying to create directory? */ 534 call hcs_$status_ (dname, ename, 0, addr (status_info), null (), code3); 535 /* Don't chase links. */ 536 sys_type = fixed (status_info.type); 537 if code3 ^= 0 then /* Was call successful? */ 538 if code3 = error_table_$no_info | code3 = error_table_$incorrect_access then do; 539 give_acc: /* If no access, then recurse to get it. */ 540 call backup_util$give_access (dname, ename, code3); 541 if code3 = 0 then 542 go to retry; /* Recurse to give ourselves access. */ 543 else do; 544 code3 = saved_code; 545 go to bt_ret; 546 end; 547 end; 548 else do; 549 code3 = saved_code; 550 go to bt_ret; /* Don't muddle about, it may be a directory. */ 551 end; 552 if sys_type = ETYPE_DIR then /* If name conflict, then dir already created. */ 553 if (status_info.mode & "01011"b) ^= "01011"b then 554 go to give_acc; /* If no access, then recurse to get it. */ 555 else go to bt_ret; /* Directory is there. */ 556 end; 557 if bk_ss_$retrievesw & bk_ss_$cross_retrievesw & ^bk_ss_$allow_dir_overwrite then do; 558 call hcs_$status_minf (dname, ename, 1, sys_type, 0, 0); 559 if sys_type = ETYPE_DIR then do; 560 call backup_map_$fs_error_line (code3, 561 rtrim (bk_ss_$myname) || ": Attempt to cross-retrieve a segment in place of a directory or 562 link to a directory.", dname, ename); 563 go to bt_ret; 564 end; 565 end; 566 if ^bk_ss_$no_reload then /* really loading something */ 567 call backup_util$delete_name (dname, ename, code3); 568 /* Not a directory, try to remove name. */ 569 else code3 = 0; /* Don't create errors if not reloading. */ 570 if code3 = 0 then do; /* Was name removed successfully? */ 571 code3 = error_table_$namedup; /* Set up error code3 */ 572 go to retry; /* Try append again. */ 573 end; 574 end; 575 576 else if code3 = error_table_$no_info | code3 = error_table_$incorrect_access then do; 577 saved_code = code3; 578 call backup_load_dir_list$build_tree (dname, "", ETYPE_PARENT_DIR, 0, 0, "", class, code3); 579 if code3 = 0 then 580 go to retry; /* Recurse to get access to parent. */ 581 else code3 = saved_code; /* end of recursion */ 582 end; 583 584 else if code3 ^= 0 then /* Was, perchance, all OK? */ 585 failed: 586 call backup_map_$fs_error_line (code3, routine (type), dname, ename); 587 588 bt_ret: 589 return; 590 591 /* */ 592 chain_branches: 593 procedure (abp, bc, dir_root, dir_root_count, seg_root, seg_root_count, sys_tape_sw); 594 /* proc to chain two branch lists */ 595 596 dcl (abp, bp, dir_root, seg_root, prev_dir, prev_seg, ix, np, jx) pointer; 597 598 dcl (bc, i, j, dir_root_count, seg_root_count, sys_tape_sw, sw, ic, dc, sc) fixed binary; 599 600 bp = abp; /* Copy pointer to branch array. */ 601 dc, sc = 0; /* Initialize directory, segment counts. */ 602 if sys_tape_sw = 0 then 603 sw = bc + 1; /* names from system */ 604 else sw = 0; /* names from tape */ 605 prev_dir, prev_seg = null; /* Indicate no previous names. */ 606 do i = 1 to bc; /* Scan all branches. */ 607 if sw = 0 then 608 ic = i; /* link foward if from tape */ 609 else ic = sw - i; /* link backward if in system */ 610 ix = addr (bp -> br (ic)); /* Get pointer to this entry. */ 611 np = pointer (ix, ix -> br (1).namerp); /* Get pointer to name array. */ 612 if ix -> br (1).dirsw then /* Is this a directory? */ 613 do j = 1 to fixed (ix -> br (1).nnames, 17); 614 /* Yes, scan all its names. */ 615 jx = addr (np -> name (j)); /* Get pointer to this name. */ 616 if prev_dir = null then 617 dir_root = jx; /* Were there any previous names? */ 618 else prev_dir -> name1_np = rel (jx); /* Yes, point previous name to this. */ 619 prev_dir = jx; /* Save this pointer for next time. */ 620 dc = dc + 1; /* Count one directory name. */ 621 end; 622 else do j = 1 to fixed (ix -> br (1).nnames, 17); 623 /* No, scan all its names. */ 624 jx = addr (np -> name (j)); /* Get pointer to this name. */ 625 if prev_seg = null then 626 seg_root = jx; /* Were there any previous names? */ 627 else prev_seg -> name1_np = rel (jx); /* Yes, chain previous name to this one. */ 628 prev_seg = jx; /* Save this pointer for next time. */ 629 sc = sc + 1; /* Count one segment name. */ 630 end; 631 end; 632 if prev_dir = null then 633 dir_root = null; /* Were there any directory names? */ 634 else prev_dir -> name1_np = ""b; /* Yes, clear pointer in last name. */ 635 if prev_seg = null then 636 seg_root = null; /* Were there any segment names? */ 637 else prev_seg -> name1_np = ""b; /* Yes, clear pointer in last name. */ 638 dir_root_count = dc; /* Return count of directory names. */ 639 seg_root_count = sc; /* Return count of segment names. */ 640 641 end chain_branches; 642 643 644 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 645 646 647 chain_links: 648 procedure (alp, lc, root, root_count, sys_tape_sw); /* Proc to chain one link list */ 649 650 dcl (alp, lp, root, previous, ix, np, jx) pointer; 651 652 dcl (i, j, lc, root_count, sys_tape_sw, sw, ic, rc) fixed bin; 653 654 lp = alp; /* Copy pointer to link array. */ 655 rc = 0; /* Initialize count of number of names. */ 656 if sys_tape_sw = 0 then 657 sw = lc + 1; /* names from system */ 658 else sw = 0; /* names from tape */ 659 previous = null; /* Indicate no previous name. */ 660 do i = 1 to lc; /* Scan all links. */ 661 if sw = 0 then 662 ic = i; /* names from tape thread foward */ 663 else ic = sw - i; /* names in system thread backward */ 664 ix = addr (lp -> lk (ic)); /* Get pointer to this entry. */ 665 np = pointer (ix, ix -> lk (1).namerp); /* Extract pointer to its name array. */ 666 do j = 1 to fixed (ix -> lk (1).nnames, 17); /* Scan each name. */ 667 jx = addr (np -> name (j)); /* Get pointer to this name. */ 668 if previous = null then 669 root = jx; /* Any prevoius name? */ 670 else previous -> name1_np = rel (jx); /* Yes, chain it to this one. */ 671 previous = jx; /* Save this name for next time. */ 672 rc = rc + 1; /* Count one name. */ 673 end; 674 end; 675 if previous = null then 676 root = null; /* Were there any names? */ 677 else previous -> name1_np = ""b; /* Yes, clear final pointer. */ 678 root_count = rc; /* Return count of number of names. */ 679 680 end chain_links; 681 682 683 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 684 685 686 prune: 687 procedure (sys_root, sys_count, tape_root, tape_count);/* Procedure to prune excess entry names. */ 688 689 dcl ( 690 sys_root, 691 tape_root, /* Pointers to the name lists. */ 692 sys_np, 693 tape_np 694 ) pointer; /* Pointers to current names. */ 695 696 dcl (k, sys_count, tape_count) fixed bin; 697 dcl code fixed bin (35); 698 699 if sys_root ^= null then do; /* If there are system names, */ 700 if tape_root = null then do; /* If there are names on the tape, */ 701 sys_np = sys_root; /* Copy pointer to system names. */ 702 tape_np = pointer (tape_root, ""b); /* Fix pointer for end-of-names condition. */ 703 go to force_delete; /* Start removal of all names in system. */ 704 end; 705 call sort_name_list (sys_root, sys_count); /* We must sort both lists. */ 706 call sort_name_list (tape_root, tape_count); /* .. */ 707 sys_np = sys_root; /* Copy pointer to system names. */ 708 tape_np = tape_root; /* Copy pointer to names from tape. */ 709 compare: 710 do while (rel (sys_np)); /* Examine all system names. */ 711 if rel (tape_np) then 712 do k = 1 to 8; /* Have we finished all tape names? */ 713 if sys_np -> chars (k) < tape_np -> chars (k) then do; 714 /* If true, name in system not on tape */ 715 force_delete: 716 if bk_ss_$no_reload then 717 code = 0; /* Not really reloading */ 718 else call backup_util$delete_name (hp -> h.dname, sys_np -> name (1).string, code); 719 if code ^= 0 then 720 call backup_map_$fs_error_line 721 /* If unsuccessful, error comment. */ 722 (code, "backup_util$delete_name", hp -> h.dname, sys_np -> name (1).string); 723 else if bk_ss_$mapsw then /* If all OK, write map_ if enabled. */ 724 call backup_map_$detail_line2 (sys_np -> name (1).string, -1, "deleted", dtp, 725 blank_time, -1, blank_time, blank_time); 726 sys_np = pointer (sys_np, sys_np -> name1_np); 727 /* Walk to next system name. */ 728 go to compare; /* Go check for termination condition. */ 729 end; 730 if sys_np -> chars (k) > tape_np -> chars (k) then do; 731 /* Name on tape not in system. */ 732 tape_np = pointer (tape_np, tape_np -> name1_np); 733 /* Walk to next tape name. */ 734 go to compare; /* Go check terminating condition. */ 735 end; 736 end; /* No more names on tape, */ 737 else go to force_delete; /* Force deletion of remaining system names. */ 738 /* Name in system matches name on tape; leave it. */ 739 sys_np = pointer (sys_np, sys_np -> name1_np); 740 /* Walk to next name in system. */ 741 tape_np = pointer (tape_np, tape_np -> name1_np); 742 /* Walk to next name on tape. */ 743 end; 744 end; 745 746 747 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 748 749 750 sort_name_list: 751 procedure (root, count); /* Procedure to sort chained name list. */ 752 753 dcl root ptr, 754 (count, i, j, k, l, m, n, q, xi, xj, xk, xl, xq) fixed bin, 755 ( 756 vxi, 757 vxj, 758 vxk, 759 vxq, 760 v (count), 761 np 762 ) ptr, 763 Cut fixed bin int static init (12), 764 x (count) fixed bin, 765 stacki (18) fixed bin, 766 stackj (18) fixed bin; 767 768 769 dcl 1 name_structure based aligned, 770 2 relnp bit (18) aligned, /* relative pointer to next name */ 771 2 name_string char (32) aligned; /* this is the name */ 772 773 774 /* Set up arrays of pointers to names and indices of pointers */ 775 776 777 778 if root = null then go to sort_ret; 779 780 np = root; /* get pointer to first name structure */ 781 782 if count = 1 then do; /* Not much to do here */ 783 np -> relnp = ""b; 784 go to sort_ret; /* Return */ 785 end; 786 787 do n = 1 to count; 788 v (n) = np; 789 x (n) = n; 790 np = ptr (np, np -> name1_np); 791 end; 792 793 794 n = count; 795 796 if n <= 15 then do; /* Do a fast shell sort for few names */ 797 798 i = n; /* Initialize interval for shell sort */ 799 do; 800 down: 801 i = 2 * divide (i, 4, 17, 0) + 1; /* Set the interval size for the sort */ 802 do j = 1 to n - i; /* In steps of i so don't overshoot array */ 803 k = j + i; /* Next higher index */ 804 xk = x (k); /* Index from index array */ 805 vxk = v (xk); /* Pointer for name comparison */ 806 up: 807 l = k - i; /* Lower index (will change inside the loop) */ 808 xl = x (l); /* Lower index from index array */ 809 if v (xl) -> name_string <= vxk -> name_string then go to in_order; 810 x (k) = xl; /* Out of order so swap in index array */ 811 k = l; /* Check next lower element in steps of size i */ 812 if k > i then go to up; /* If there is a lower element then try it */ 813 in_order: 814 x (k) = xk; /* Put highest index away */ 815 end; 816 817 if i > 1 then go to down; /* Try next smaller interval size */ 818 819 go to thread; /* Now thread the names */ 820 821 end; 822 823 end; 824 825 826 i, m = 1; 827 j = n; 828 829 /* Now sort */ 830 831 /* Start by getting and ordering first middle and last elements in current list */ 832 /* Arrange indices accordingly since only they get sorted and set test value to middle value */ 833 834 sloop: 835 k = i; 836 l = j; 837 q = divide (i + j, 2, 17, 0); 838 839 xi = x (i); 840 xj = x (j); 841 xq = x (q); 842 843 vxi = v (xi); 844 vxj = v (xj); 845 vxq = v (xq); 846 847 848 849 if vxq -> name_string < vxi -> name_string then 850 if vxj -> name_string < vxi -> name_string then 851 if vxq -> name_string < vxj -> name_string then do; 852 x (i) = xq; 853 x (q) = xj; 854 x (j) = xi; 855 vxq = vxj; 856 end; 857 858 else do; 859 x (i) = xj; 860 x (j) = xi; 861 end; 862 863 else do; 864 x (i) = xq; 865 x (q) = xi; 866 vxq = vxi; 867 end; 868 869 else if vxj -> name_string < vxq -> name_string then 870 if vxi -> name_string < vxj -> name_string then do; 871 x (q) = xj; 872 x (j) = xq; 873 vxq = vxj; 874 end; 875 876 else do; 877 x (q) = xi; 878 x (i) = xj; 879 x (j) = xq; 880 vxq = vxi; 881 end; 882 883 /* Now order into lists above and below the test value */ 884 885 lloop: 886 l = l - 1; 887 xl = x (l); 888 889 890 891 if v (xl) -> name_string > vxq -> name_string then go to lloop; 892 893 kloop: 894 k = k + 1; 895 xk = x (k); 896 897 898 899 if v (xk) -> name_string < vxq -> name_string then go to kloop; 900 901 902 903 if k <= l then do; 904 x (k) = xl; 905 x (l) = xk; 906 go to lloop; 907 end; 908 909 910 911 if l - i < j - k then do; 912 stacki (m) = k; 913 stackj (m) = j; 914 j = l; 915 end; 916 917 else do; 918 stacki (m) = i; 919 stackj (m) = l; 920 i = k; 921 end; 922 923 m = m + 1; 924 925 926 test: 927 if j - i > Cut then go to sloop; 928 929 930 931 if i = 1 then 932 if i < j then go to sloop; 933 934 /* Bubble sort if small number of names in this list */ 935 /* Note that we do this for the lists headed by stacki(n) */ 936 937 do i = i + 1 by 1 while (i <= j); 938 k = i; 939 xk = x (k); 940 vxk = v (xk); 941 bubble: 942 l = k - 1; 943 xl = x (l); 944 if v (xl) -> name_string <= vxk -> name_string then go to ok; 945 x (k) = xl; 946 x (l) = xk; 947 k = l; 948 go to bubble; 949 ok: 950 end; 951 952 /* Start work on the next list */ 953 954 955 m = m - 1; 956 957 958 if m = 0 then go to thread; 959 960 961 962 i = stacki (m); 963 964 j = stackj (m); 965 966 967 968 go to test; 969 970 971 972 thread: /* rethread the names in correct order */ 973 xi = x (1); /* get first index */ 974 975 np = v (xi); /* get first pointer */ 976 977 root = np; /* point root to first name */ 978 979 980 981 do i = 1 to n; /* now loop doing the rethread */ 982 983 xi = x (i); 984 985 np -> relnp = rel (v (xi)); /* np points to current and v(xi) points to next */ 986 987 np = v (xi); 988 989 end; 990 991 992 993 994 np -> relnp = ""b; /* zero out last */ 995 996 997 998 sort_ret: 999 return; 1000 1001 1002 end sort_name_list; 1003 1004 end prune; 1005 1006 end backup_load_dir_list; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/11/89 0809.5 backup_load_dir_list.pl1 >spec>install>1111>backup_load_dir_list.pl1 96 1 04/02/87 2006.7 bk_ss_.incl.pl1 >ldd>include>bk_ss_.incl.pl1 97 2 06/11/76 1057.9 bk_nss_info.incl.pl1 >ldd>include>bk_nss_info.incl.pl1 189 3 07/16/87 1755.4 backup_record_types.incl.pl1 >ldd>include>backup_record_types.incl.pl1 190 4 12/07/76 1740.3 backup_dir_list.incl.pl1 >ldd>include>backup_dir_list.incl.pl1 191 5 05/06/74 1741.7 backup_fs_times.incl.pl1 >ldd>include>backup_fs_times.incl.pl1 192 6 04/29/76 1058.2 backup_preamble_header.incl.pl1 >ldd>include>backup_preamble_header.incl.pl1 413 7 03/16/89 2012.8 create_branch_info.incl.pl1 >ldd>include>create_branch_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. Cut constant fixed bin(17,0) initial dcl 753 ref 926 ETYPE_DIR 000135 constant fixed bin(17,0) initial dcl 121 set ref 203 260 417 421 519* 532 552 559 ETYPE_LINK 000137 constant fixed bin(17,0) initial dcl 120 set ref 311* 435 ETYPE_PARENT_DIR 000124 constant fixed bin(17,0) initial dcl 122 set ref 203 417 423 512 522 578* ETYPE_SEG constant fixed bin(17,0) initial dcl 119 ref 449 ETYPE_UPGRADED_DIR constant fixed bin(17,0) initial dcl 124 ref 203 261 372 417 421 473 532 ETYPE_UPGRADED_SEG constant fixed bin(17,0) initial dcl 123 ref 449 473 abp parameter pointer dcl 596 ref 592 600 access_class 122 based bit(72) level 2 in structure "h" dcl 6-7 in procedure "backup_load_dir_list" set ref 255 257* 266 279* 285* 288* access_class 000104 automatic bit(72) dcl 50 in procedure "backup_load_dir_list" set ref 264* 266* 268* 269* 279* 280* 282* 311* access_class 20 000522 automatic bit(72) level 2 in structure "branch_info" dcl 414 in procedure "backup_load_dir_list" set ref 480* access_class_octal 000106 automatic char(32) dcl 51 set ref 282* 283 486* 487 access_class_text 000126 automatic char(256) packed unaligned dcl 52 set ref 280* 283* 291 291* 368* 370 370 484* 487* 489 489* addr builtin function dcl 187 ref 306 370 370 481 481 514 514 516 516 517 517 534 534 610 615 624 664 667 aim_check_$equal 000132 constant entry external dcl 151 ref 279 alp parameter pointer dcl 650 ref 647 654 attempt 000404 automatic fixed bin(17,0) initial dcl 115 set ref 115* 425* 425 434 author 1 based char(32) level 2 dcl 4-37 set ref 335* backup_load_dir_list$build_tree 000100 constant entry external dcl 136 ref 269 311 519 578 backup_map_$detail_line2 000102 constant entry external dcl 136 ref 723 backup_map_$directory_line 000104 constant entry external dcl 136 ref 370 514 516 517 backup_map_$error_line 000106 constant entry external dcl 136 ref 291 489 backup_map_$fs_error_line 000110 constant entry external dcl 136 ref 247 271 314 330 337 352 358 365 374 508 560 584 719 backup_util$add_names 000112 constant entry external dcl 136 ref 319 backup_util$delete_name 000114 constant entry external dcl 136 ref 566 718 backup_util$give_access 000116 constant entry external dcl 136 ref 539 bc 101 based fixed bin(17,0) level 2 in structure "h" dcl 6-7 in procedure "backup_load_dir_list" ref 209 bc parameter fixed bin(17,0) dcl 598 in procedure "chain_branches" ref 592 602 606 bit builtin function dcl 187 ref 470 471 bit_count parameter fixed bin(24,0) dcl 41 set ref 387 442* 479 bitcnt 16 000522 automatic fixed bin(24,0) level 2 dcl 414 set ref 479* bk_dq_info based structure level 1 dcl 2-15 bk_nss_info based structure level 1 dcl 2-7 bk_ss_$allow_dir_overwrite 000016 external static bit(1) dcl 1-17 ref 557 bk_ss_$cross_retrievesw 000020 external static bit(1) dcl 1-17 ref 557 bk_ss_$debugsw 000022 external static bit(1) dcl 1-17 ref 327 333 346 bk_ss_$dir_trim 000024 external static bit(1) dcl 1-17 ref 239 bk_ss_$enforce_minimum_ring 000050 external static bit(1) dcl 1-17 ref 437 464 bk_ss_$hp 000026 external static pointer dcl 1-17 ref 285 288 451 452 452 bk_ss_$mapsw 000030 external static bit(1) dcl 1-17 ref 512 723 bk_ss_$minimum_ring 000052 external static fixed bin(17,0) dcl 1-17 ref 438 439 440 465 466 467 bk_ss_$myname 000032 external static char(16) packed unaligned dcl 1-17 set ref 291* 489* 560 bk_ss_$no_reload 000034 external static bit(1) dcl 1-17 ref 323 346 428 566 715 bk_ss_$no_setlvid 000036 external static bit(1) dcl 1-17 ref 347 bk_ss_$quotasw 000040 external static bit(1) dcl 1-17 ref 354 bk_ss_$restore_access_class 000046 external static bit(1) dcl 1-17 ref 276 436 bk_ss_$retrievesw 000042 external static bit(1) dcl 1-17 ref 557 bk_ss_$trimsw 000044 external static bit(1) dcl 1-17 ref 214 blank 000426 automatic char(1) initial packed unaligned dcl 390 set ref 390* 514 514 blank_time 000074 constant fixed bin(52,0) initial dcl 94 set ref 723* 723* 723* bp 000554 automatic pointer dcl 596 in procedure "chain_branches" set ref 600* 610 bp 100 based bit(18) level 2 in structure "h" dcl 6-7 in procedure "backup_load_dir_list" ref 208 452 br based structure array level 1 dcl 4-6 set ref 610 branch_info 000522 automatic structure level 1 dcl 414 set ref 446* 481 481 branch_ptr 000514 automatic pointer dcl 390 set ref 452* 453 454 455 456 char builtin function dcl 187 ref 500 chars based fixed bin(17,0) array dcl 112 ref 713 713 730 730 chase_sw 1(02) 000522 automatic bit(1) level 3 packed packed unaligned dcl 414 set ref 472* class parameter bit(72) dcl 390 set ref 387 480 484* 486* 519* 578* code 000645 automatic fixed bin(35,0) dcl 697 in procedure "prune" set ref 715* 718* 719 719* code 000403 automatic fixed bin(35,0) dcl 89 in procedure "backup_load_dir_list" set ref 216* 219 224* 225 247 247* 249 250* 264* 265 269* 270 271* 272 280* 281 285* 287 311* 313 314* 327* 329* 330 330* 335* 337 337* 350* 351 351* 352 352* 355* 358 358* 362* 365 365* 373* 374 374* 484* 485 505* 507 508* code2 parameter fixed bin(35,0) dcl 38 set ref 35 197* 219* 249* 272* 295* code3 parameter fixed bin(35,0) dcl 41 set ref 387 430* 442* 481* 482 482 489* 496* 499 502* 519* 521 524* 527 527* 530 531 534* 537 537 537 539* 541 544* 549* 560* 566* 569* 570 571* 576 576 577 578* 579 581* 584 584* convert_aim_attributes_ 000130 constant entry external dcl 151 ref 282 288 486 convert_authorization_$to_string_short 000126 constant entry external dcl 151 ref 280 285 484 copy_sw 1(01) 000522 automatic bit(1) level 3 packed packed unaligned dcl 414 set ref 471* count parameter fixed bin(17,0) dcl 753 ref 750 753 753 782 787 794 create_branch_info based structure level 1 dcl 7-17 create_branch_version_2 constant fixed bin(17,0) initial dcl 7-35 ref 447 creating_directory 000000 constant char(19) initial packed unaligned dcl 129 set ref 516 516 516 516 cu_$level_get 000120 constant entry external dcl 151 ref 200 416 current_ring 000415 automatic fixed bin(17,0) dcl 132 set ref 200* 276 416* 436 current_user 000405 automatic char(32) dcl 131 set ref 199* 415* 442* 469 dc 000574 automatic fixed bin(17,0) dcl 598 set ref 601* 620* 620 638 dir 000427 automatic char(168) dcl 390 set ref 505* 519* dir_quota 22 000522 automatic fixed bin(18,0) level 2 dcl 414 set ref 478* dir_root parameter pointer dcl 596 set ref 592 616* 632* dir_root_count parameter fixed bin(17,0) dcl 598 set ref 592 638* dir_sw 1 000522 automatic bit(1) level 3 packed packed unaligned dcl 414 set ref 470* dirsw 000511 automatic fixed bin(1,0) dcl 390 in procedure "backup_load_dir_list" set ref 421* 442* 470 dirsw 14 based bit(1) array level 2 in structure "br" packed packed unaligned dcl 4-6 in procedure "backup_load_dir_list" set ref 612 divide builtin function dcl 187 ref 800 837 dname parameter char(168) dcl 41 in procedure "backup_load_dir_list" set ref 387 442* 481* 489 489 496* 500 505* 508* 517 517 517 517 534* 539* 558* 560* 566* 578* 584* dname 1 based char(168) level 2 in structure "h" dcl 6-7 in procedure "backup_load_dir_list" set ref 224* 247* 264* 269* 271* 291* 311* 314* 319* 327* 330* 335* 337* 351* 352* 355* 358* 362* 365* 368* 373* 374* 718* 719* dq_info_relp 127 based bit(18) level 2 dcl 6-7 ref 359 360 dqip 000332 automatic pointer dcl 54 set ref 360* 362 362 362 362 362 dtd 2 000416 automatic fixed bin(52,0) level 2 in structure "times" dcl 5-4 in procedure "backup_load_dir_list" set ref 326* dtd 66 based fixed bin(52,0) level 2 in structure "h" dcl 6-7 in procedure "backup_load_dir_list" ref 207 dtem 000416 automatic fixed bin(52,0) level 2 dcl 5-4 set ref 324* dtm 4(20) based bit(52) array level 2 packed packed unaligned dcl 4-29 set ref 324 dtp 000102 automatic fixed bin(52,0) dcl 48 set ref 207* 326 723* ename parameter char(32) dcl 41 set ref 387 442* 481* 489 489 496* 508* 534* 539* 558* 560* 566* 584* entry 000501 automatic char(32) dcl 390 set ref 505* 519* error_table_$ai_restricted 000072 external static fixed bin(35,0) dcl 99 set ref 291* 295 482 error_table_$badpath 000060 external static fixed bin(35,0) dcl 99 ref 527 error_table_$incorrect_access 000070 external static fixed bin(35,0) dcl 99 ref 537 576 error_table_$namedup 000056 external static fixed bin(35,0) dcl 99 ref 530 571 error_table_$no_dir 000064 external static fixed bin(35,0) dcl 99 ref 247 499 error_table_$no_info 000066 external static fixed bin(35,0) dcl 99 ref 537 576 error_table_$noaccess 000054 external static fixed bin(35,0) dcl 99 ref 524 error_table_$root 000062 external static fixed bin(35,0) dcl 99 ref 502 527 expand_pathname_ 000124 constant entry external dcl 151 ref 505 fixed builtin function dcl 187 ref 311 311 319 319 324 421 454 455 456 536 612 622 666 get_group_id_ 000122 constant entry external dcl 151 ref 199 415 h based structure level 1 dcl 6-7 hcs_$append_branchx 000134 constant entry external dcl 151 ref 442 hcs_$append_link 000140 constant entry external dcl 151 ref 496 hcs_$create_branch_ 000136 constant entry external dcl 151 ref 481 hcs_$get_access_class 000154 constant entry external dcl 151 ref 264 hcs_$list_dir_fast 000142 constant entry external dcl 151 ref 224 hcs_$make_seg 000144 constant entry external dcl 151 ref 216 hcs_$status_ 000150 constant entry external dcl 151 ref 534 hcs_$status_minf 000152 constant entry external dcl 151 ref 558 hcs_$truncate_seg 000156 constant entry external dcl 151 ref 250 hp 000326 automatic pointer dcl 54 set ref 198* 202 207 208 208 209 210 210 212 224 247 255 257 257 261 261 264 266 266 269 271 278 279 291 311 314 319 327 330 333 335 337 347 347 349 349 351 352 355 355 355 355 355 355 358 359 360 360 362 365 367 368 368 373 374 718 719 hp1 parameter pointer dcl 38 ref 35 198 hphcs_$dir_quota_restor 000162 constant entry external dcl 175 ref 362 hphcs_$quota_reload 000160 constant entry external dcl 175 ref 355 hphcs_$set_auth 000164 constant entry external dcl 175 ref 335 hphcs_$set_backup_times 000146 constant entry external dcl 151 ref 327 hphcs_$set_sons_lvid 000166 constant entry external dcl 175 ref 351 i 000570 automatic fixed bin(17,0) dcl 598 in procedure "chain_branches" set ref 606* 607 609* i 000100 automatic fixed bin(17,0) dcl 753 in procedure "sort_name_list" set ref 798* 800* 800 802 803 806 812 817 826* 834 837 839 852 859 864 878 911 918 920* 926 931 931 937* 937 937* 938* 962* 981* 983* i 000622 automatic fixed bin(17,0) dcl 652 in procedure "chain_links" set ref 660* 661 663* ic 000625 automatic fixed bin(17,0) dcl 652 in procedure "chain_links" set ref 661* 663* 664 ic 000573 automatic fixed bin(17,0) dcl 598 in procedure "chain_branches" set ref 607* 609* 610 inf_acct 113 based fixed bin(17,0) level 2 in structure "h" dcl 6-7 in procedure "backup_load_dir_list" set ref 355* inf_acct 5 based fixed bin(17,0) level 2 in structure "bk_dq_info" dcl 2-15 in procedure "backup_load_dir_list" set ref 362* ioa_$rsnnl 000172 constant entry external dcl 175 ref 368 ix 000614 automatic pointer dcl 650 in procedure "chain_links" set ref 664* 665 665 666 ix 000562 automatic pointer dcl 596 in procedure "chain_branches" set ref 610* 611 611 612 612 622 j 000101 automatic fixed bin(17,0) dcl 753 in procedure "sort_name_list" set ref 802* 803* 827* 836 837 840 854 860 872 879 911 913 914* 926 931 937 964* j 000571 automatic fixed bin(17,0) dcl 598 in procedure "chain_branches" set ref 612* 615* 622* 624* j 000623 automatic fixed bin(17,0) dcl 652 in procedure "chain_links" set ref 666* 667* j 000402 automatic fixed bin(17,0) dcl 73 in procedure "backup_load_dir_list" set ref 368* 370* jx 000566 automatic pointer dcl 596 in procedure "chain_branches" set ref 615* 616 618 619 624* 625 627 628 jx 000620 automatic pointer dcl 650 in procedure "chain_links" set ref 667* 668 670 671 k 000102 automatic fixed bin(17,0) dcl 753 in procedure "sort_name_list" set ref 803* 804 806 810 811* 812 813 834* 893* 893 895 903 904 911 912 920 938* 939 941 945 947* k 000644 automatic fixed bin(17,0) dcl 696 in procedure "prune" set ref 711* 713 713 730 730* l 000103 automatic fixed bin(17,0) dcl 753 set ref 806* 808 811 836* 885* 885 887 903 905 911 914 919 941* 943 946 947 lc 103 based fixed bin(17,0) level 2 in structure "h" dcl 6-7 in procedure "backup_load_dir_list" ref 212 lc parameter fixed bin(17,0) dcl 652 in procedure "chain_links" ref 647 656 660 length builtin function dcl 187 ref 516 516 517 517 list_area based fixed bin(17,0) array dcl 91 set ref 224* listp 000010 internal static pointer initial dcl 91 set ref 215 216* 218 223* 224 250* lk based structure array level 1 dcl 4-29 set ref 306 664 lp 102 based bit(18) level 2 in structure "h" dcl 6-7 in procedure "backup_load_dir_list" ref 210 lp 000610 automatic pointer dcl 650 in procedure "chain_links" set ref 654* 664 ltrp 2 based fixed bin(71,0) level 2 dcl 2-15 set ref 362* lvid 21 based bit(36) level 2 dcl 2-7 set ref 350* 351* m 000104 automatic fixed bin(17,0) dcl 753 set ref 826* 912 913 918 919 923* 923 955* 955 958 962 964 master_dir 121(07) based bit(1) level 3 packed packed unaligned dcl 6-7 ref 347 max builtin function dcl 187 ref 438 439 440 465 466 467 mdc_$find_lvname 000170 constant entry external dcl 175 ref 350 mode 2 000522 automatic bit(3) level 2 in structure "branch_info" packed packed unaligned dcl 414 in procedure "backup_load_dir_list" set ref 448* mode 3 000516 automatic bit(5) level 2 in structure "status_info" packed packed unaligned dcl 399 in procedure "backup_load_dir_list" set ref 552 multiple_class 121(04) based bit(1) level 3 packed packed unaligned dcl 6-7 set ref 257* 261 n 000105 automatic fixed bin(17,0) dcl 753 set ref 787* 788 789 789* 794* 796 798 802 827 981 name 11 based char(168) level 2 in structure "path" dcl 4-37 in procedure "backup_load_dir_list" ref 311 311 name based structure array level 1 dcl 4-25 in procedure "backup_load_dir_list" set ref 615 624 667 name1_np based bit(18) dcl 112 set ref 618* 627* 634* 637* 670* 677* 726 732 739 741 790 name_string 1 based char(32) level 2 dcl 769 ref 809 809 849 849 849 849 849 849 869 869 869 869 891 891 899 899 944 944 name_structure based structure level 1 dcl 769 namerp 21(18) based bit(18) array level 2 in structure "br" packed packed unaligned dcl 4-6 in procedure "backup_load_dir_list" set ref 611 namerp 10(18) based bit(18) array level 2 in structure "lk" packed packed unaligned dcl 4-29 in procedure "backup_load_dir_list" set ref 307 665 ndc_directory_list constant fixed bin(17,0) initial dcl 3-22 ref 261 266 278 333 nip 000334 automatic pointer dcl 54 set ref 349* 350 351 nnames 11(19) based bit(17) array level 2 in structure "lk" packed packed unaligned dcl 4-29 in procedure "backup_load_dir_list" set ref 319 319 666 nnames 22(19) based bit(17) array level 2 in structure "br" packed packed unaligned dcl 4-6 in procedure "backup_load_dir_list" set ref 612 622 np 000124 automatic pointer dcl 753 in procedure "sort_name_list" set ref 780* 783 788 790* 790 790 975* 977 985 987* 994 np 000564 automatic pointer dcl 596 in procedure "chain_branches" set ref 611* 615 624 np 000616 automatic pointer dcl 650 in procedure "chain_links" set ref 665* 667 nss_info_relp 126 based bit(18) level 2 dcl 6-7 ref 347 349 null builtin function dcl 187 ref 215 218 239 242 451 534 534 605 616 625 632 632 635 635 659 668 675 675 699 700 778 old_area_ 000076 constant entry external dcl 134 ref 223 optionsw parameter fixed bin(2,0) dcl 41 set ref 387 442* 471 path based structure level 1 dcl 4-37 pathname_ 000174 constant entry external dcl 175 ref 489 489 pathnamerp 10 based bit(18) array level 2 packed packed unaligned dcl 4-29 set ref 309 pname parameter char dcl 41 set ref 387 496* pointer builtin function dcl 187 ref 208 210 307 309 611 665 702 726 732 739 741 pp 000330 automatic pointer dcl 54 set ref 309* 311 311 311 311 335 prev_dir 000556 automatic pointer dcl 596 set ref 605* 616 618 619* 632 634 prev_seg 000560 automatic pointer dcl 596 set ref 605* 625 627 628* 635 637 previous 000612 automatic pointer dcl 650 set ref 659* 668 670 671* 675 677 priv_upgrade_sw 1(03) 000522 automatic bit(1) level 3 packed packed unaligned dcl 414 set ref 473* 476* ptr builtin function dcl 187 ref 349 360 452 790 q 000106 automatic fixed bin(17,0) dcl 753 set ref 837* 841 853 865 871 877 quota 1 based fixed bin(17,0) level 2 in structure "bk_dq_info" dcl 2-15 in procedure "backup_load_dir_list" set ref 362* quota 110 based fixed bin(17,0) level 2 in structure "h" dcl 6-7 in procedure "backup_load_dir_list" set ref 355* 367 368* quota 17 000522 automatic fixed bin(18,0) level 2 in structure "branch_info" dcl 414 in procedure "backup_load_dir_list" set ref 477* rb1 20 based bit(6) array level 2 packed packed unaligned dcl 4-6 set ref 453 454 rb2 20(06) based bit(6) array level 2 packed packed unaligned dcl 4-6 set ref 455 rb3 20(12) based bit(6) array level 2 packed packed unaligned dcl 4-6 set ref 456 rc 000626 automatic fixed bin(17,0) dcl 652 set ref 655* 672* 672 678 record_type 65 based fixed bin(17,0) level 2 dcl 6-7 ref 202 261 266 278 333 rel builtin function dcl 187 ref 618 627 670 709 711 985 relnp based bit(18) level 2 dcl 769 set ref 783* 985* 994* rings 3 000522 automatic fixed bin(3,0) array level 2 in structure "branch_info" dcl 414 in procedure "backup_load_dir_list" set ref 454* 455* 456* 459* 461* 462* 465* 465 466* 466 467* 467 rings 000012 internal static fixed bin(6,0) array dcl 117 in procedure "backup_load_dir_list" set ref 203* 203* 203* 205* 205* 205* 417* 417* 417* 419* 419* 419* 438* 438 439* 439 440* 440 442* 459 461 462 root parameter pointer dcl 753 in procedure "sort_name_list" set ref 750 778 780 977* root parameter pointer dcl 650 in procedure "chain_links" set ref 647 668* 675* root_count parameter fixed bin(17,0) dcl 652 set ref 647 678* routine 000005 constant char(34) initial array dcl 126 set ref 584* rtrim builtin function dcl 187 ref 517 517 560 rtype 000401 automatic fixed bin(17,0) dcl 73 set ref 202* 203 203 203 260* 261* 269* 372 saved_code 000100 automatic fixed bin(35,0) dcl 41 set ref 531* 544 549 577* 581 sc 000575 automatic fixed bin(17,0) dcl 598 set ref 601* 629* 629 639 seg_root parameter pointer dcl 596 set ref 592 625* 635* seg_root_count parameter fixed bin(17,0) dcl 598 set ref 592 639* size based bit(17) level 2 dcl 4-37 ref 311 311 stacki 000126 automatic fixed bin(17,0) array dcl 753 set ref 912* 918* 962 stackj 000150 automatic fixed bin(17,0) array dcl 753 set ref 913* 919* 964 status_info 000516 automatic structure level 1 dcl 399 set ref 534 534 string 1 based char(32) array level 2 dcl 4-25 set ref 311* 314* 319* 327* 330* 335* 337* 718* 719* 723* substr builtin function dcl 187 ref 311 311 471 sw 000624 automatic fixed bin(17,0) dcl 652 in procedure "chain_links" set ref 656* 658* 661 663 sw 000572 automatic fixed bin(17,0) dcl 598 in procedure "chain_branches" set ref 602* 604* 607 609 switches 1 000522 automatic structure level 2 in structure "branch_info" packed packed unaligned dcl 414 in procedure "backup_load_dir_list" switches 121 based structure level 2 in structure "h" packed packed unaligned dcl 6-7 in procedure "backup_load_dir_list" sys_bc 000366 automatic fixed bin(17,0) dcl 73 set ref 224* 234 235* sys_bp 000336 automatic pointer dcl 54 set ref 224* 235* sys_count parameter fixed bin(17,0) dcl 696 set ref 686 705* sys_dirs 000352 automatic pointer dcl 54 set ref 235* 239 239* sys_dirs_names 000374 automatic fixed bin(17,0) dcl 73 set ref 235* 239* sys_info$access_class_ceiling 000074 external static bit(72) dcl 110 ref 255 sys_lc 000370 automatic fixed bin(17,0) dcl 73 set ref 224* 226 227* sys_links 000346 automatic pointer dcl 54 set ref 227* 231* sys_links_names 000376 automatic fixed bin(17,0) dcl 73 set ref 227* 231* sys_lp 000342 automatic pointer dcl 54 set ref 224* 227* sys_np 000640 automatic pointer dcl 689 set ref 701* 707* 709 713 718 719 723 726* 726 726 730 739* 739 739 sys_root parameter pointer dcl 689 set ref 686 699 701 705* 707 sys_segs 000356 automatic pointer dcl 54 set ref 235* 242 242* sys_segs_names 000372 automatic fixed bin(17,0) dcl 73 set ref 235* 242* sys_tape_sw parameter fixed bin(17,0) dcl 598 in procedure "chain_branches" ref 592 602 sys_tape_sw parameter fixed bin(17,0) dcl 652 in procedure "chain_links" ref 647 656 sys_type 000512 automatic fixed bin(2,0) dcl 390 set ref 536* 552 558* 559 system_privilege_$aim_check_soos 000176 constant entry external dcl 175 ref 373 tape_access_class_octal 000116 automatic char(32) dcl 51 set ref 288* 289 tape_access_class_text 000226 automatic char(256) packed unaligned dcl 52 set ref 285* 289* 291 291* tape_bc 000367 automatic fixed bin(17,0) dcl 73 set ref 209* 237* tape_bp 000340 automatic pointer dcl 54 set ref 208* 237* tape_count parameter fixed bin(17,0) dcl 696 set ref 686 706* tape_dirs 000354 automatic pointer dcl 54 set ref 237* 239* tape_dirs_names 000375 automatic fixed bin(17,0) dcl 73 set ref 237* 239* tape_i 000400 automatic fixed bin(17,0) dcl 73 set ref 304* 306* tape_ix 000362 automatic pointer dcl 54 set ref 306* 307 309 319 319 324 tape_lc 000371 automatic fixed bin(17,0) dcl 73 set ref 212* 229* 304 tape_links 000350 automatic pointer dcl 54 set ref 229* 231* tape_links_names 000377 automatic fixed bin(17,0) dcl 73 set ref 229* 231* tape_lp 000344 automatic pointer dcl 54 set ref 210* 229* 306 307 309 tape_np 000364 automatic pointer dcl 54 in procedure "backup_load_dir_list" set ref 307* 311 314 319 319* 327 330 335 337 tape_np 000642 automatic pointer dcl 689 in procedure "prune" set ref 702* 708* 711 713 730 732* 732 732 741* 741 741 tape_root parameter pointer dcl 689 set ref 686 700 702 706* 708 tape_segs 000360 automatic pointer dcl 54 set ref 237* 242* tape_segs_names 000373 automatic fixed bin(17,0) dcl 73 set ref 237* 242* term_acct 6 based fixed bin(1,0) level 2 in structure "bk_dq_info" dcl 2-15 in procedure "backup_load_dir_list" set ref 362* term_acct 114 based fixed bin(1,0) level 2 in structure "h" dcl 6-7 in procedure "backup_load_dir_list" set ref 355* times 000416 automatic structure level 1 unaligned dcl 5-4 set ref 327* tlu 112 based fixed bin(35,0) level 2 in structure "h" dcl 6-7 in proc ----------------------------------------------------------- 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