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 init_branches:
 14      procedure;
 15 
 16 /* init_branches is called during system initialization to create directories
 17    and branches for all segments already loaded. The AST entries for these
 18    segments are linked to the AST entries of their parents and the newly created
 19    branches.
 20 
 21    Last Modified: (Date and Reason)
 22    12/27/84 by Keith Loepere for pdd dir_quota.
 23    10/19/84 by Keith Loepere to set soos on old >sl1.
 24    6/2/82 by J. Bongiovanni to remove restriction of >sl1 to RPV, save UID
 25           of >sl1 and >pdd in active_hardcore_data
 26    3/82 BIM to unalign strings in call to asd_
 27    3/82 CAH for salvaging of dirs and recreating >sl1
 28    04/22/81, WOS, for ADP SDWs
 29    04/19/81, W. Olin Sibert, to stop maintaining aste.ic
 30    May 1978 by T. Casey to set initial quota of >pdd to largest possible value.
 31    6/23/76 by B. Greenberg for reverse-deciduous >online_salvager_output
 32    2/24/76 by R. Bratt to set per-process-sw in >pdd
 33    4/24/75, 11/4/75 by B. Greenberg for NSS
 34    741115 by PG to add name sl1 to >system_library_1.
 35    740821 by PG to remove status permission on >pdd and >pdd>!zzzzzzzbBBBBBB to *.*.*
 36    03/74  by Greenberg to remove hardcore gate kludge in favor of a real mechanism.
 37    02/74  by E Stone to set the max length of segments created during system initialization.
 38    10/73  by Steve Webber to add KLUDGE for hardcore gate entry bounds.
 39    09/03/71 by Richard H. Gumpertz for page multi-level
 40 
 41    USAGE: call init_branches;
 42    DOCUMENTED IN: AN70
 43 
 44 */
 45 
 46           dcl     (ntp, segp, pastep)    ptr,
 47                   relp                   bit (18) aligned,
 48                   write_lock             bit (36) aligned,
 49                   (fi, i, pddq)          fixed bin,
 50                   ustr                   char (15),
 51                   (code, ercode)         fixed bin (35),
 52                   ename                  char (32),
 53                   next_astep             ptr,
 54                   rb                     (3) fixed bin (3),
 55                   correct_max_length     fixed bin (9),
 56                   pds$process_group_id   char (32) aligned ext,
 57                   pds$                   ext,
 58                   dseg$                  (0:4095) fixed bin (71) external static,
 59                   (
 60                   slt$,
 61                   name_table$
 62                   )                      fixed bin ext;
 63 
 64           dcl     1 sdwi                 aligned like sdw_info automatic;
 65 
 66           dcl     zzBB                   char (15) static options (constant) init ("!zzzzzzzbBBBBBB");
 67                                                             /* From Heb., "Directory of Flies" */
 68           dcl     No_daemon              bit (1) aligned static options (constant) init ("1"b);
 69                                                             /* Don't put *.SysDaemon on ACL */
 70                                                             /* Name of Initializer's Pdir */
 71 
 72           dcl     (
 73                   error_table_$noentry,
 74                   error_table_$namedup
 75                   )                      fixed bin (35) external static,
 76                   active_hardcore_data$sl1_uid bit (36) aligned ext,
 77                   active_hardcore_data$pdd_uid bit (36) aligned ext,
 78                   active_hardcore_data$pdir_quota fixed bin ext,
 79                   active_hardcore_data$pdir_dir_quota fixed bin ext;
 80           dcl     pvt$rlv_needs_salv     bit (1) aligned external;
 81 
 82           dcl     1 dir_acl              (2) aligned like directory_acl_entry;
 83           dcl     1 del_acl              (1) aligned like delete_acl_entry;
 84 
 85           dcl     1 branch               aligned like status_branch;
 86 
 87           dcl     update_vtoce           entry (ptr),
 88                   thread$out             ext entry (ptr, bit (18)),
 89                   search_ast$hash_in     entry (ptr),
 90                   quota$dqset            entry (char (*), fixed bin, fixed bin (35)),
 91                   quota$dqmove           entry (char (*), char (*), fixed bin, fixed bin (35)),
 92                   quota$qset             entry (char (*), fixed bin, fixed bin (35)),
 93                   quota$qmove            entry (char (*), char (*), fixed bin, fixed bin (35)),
 94                   get_ptrs_$given_segno  ext entry (fixed bin (18)) returns (ptr),
 95                   sum$getbranch_root_my  entry (ptr, bit (36) aligned, ptr, fixed bin (35)),
 96                   asd_$del_sentries      entry (char (*), char (*), ptr, fixed bin, fixed bin (35)),
 97                   asd_$replace_dall      entry (char (*), char (*), ptr, fixed bin, bit (1) aligned, fixed bin (35)),
 98                   unique_chars_          entry (bit (*)) returns (char (15)),
 99                   append$branchx         entry (char (*), char (*), fixed bin (5), (3) fixed bin (3), char (*), fixed bin (1),
100                                          fixed bin (1), fixed bin (24), fixed bin (35)),
101                   sdw_util_$dissect      entry (pointer, pointer),
102                   syserr                 entry options (variable),
103                   syserr$error_code      entry options (variable),
104                   (addr, baseno, binary, bin, bit, divide, fixed, max, null, ptr, rel, rtrim) builtin,
105                   lock$dir_unlock        ext entry (ptr),
106                   chname$cfile           entry (char (*), char (*), char (*), char (*), fixed bin (35)),
107                   get_ptrs_$given_astep  entry (ptr, fixed bin (71)),
108                   initiate               entry (char (*), char (*), char (*), fixed bin, fixed bin, ptr, fixed bin (35)),
109                   make_branches          entry (ptr, ptr, fixed bin (24), ptr, (3) fixed bin (3), bit (3), fixed bin (35)),
110                   set$max_length_path    entry (char (*), char (*), fixed bin (19), fixed bin (35)),
111                   status_$long           entry (char (*), char (*), fixed bin (1), ptr, ptr, fixed bin (35)),
112                   terminate_$teseg       entry (ptr, fixed bin, fixed bin (35));
113           dcl     salvager$dir_salv_boot entry (char (*));
114 ^L
115 
116 
117 /*  Rename the previous instance of process_dir_dir.  This allows the old
118    one to be deleted without regard to name conflicts, and gives the Initializer
119    a clean slate in the new zzBB. */
120 
121           ustr = unique_chars_ (""b);                       /* Make up some stuff */
122           call chname$cfile (">", "process_dir_dir", "process_dir_dir", "process_dir_dir." || ustr, code);
123                                                             /* rename long name */
124           if (code ^= 0) & (code ^= error_table_$noentry)
125           then call syserr$error_code (CRASH, code, "init_branches: renaming process_dir_dir:");
126 
127           call chname$cfile (">", "pdd", "pdd", "pdd." || ustr, code);
128                                                             /* drop the short name if there */
129           if (code ^= 0) & (code ^= error_table_$noentry)
130           then call syserr$error_code (CRASH, code, "init_branches: renaming old pdd:");
131 
132           rb (*) = 7;
133 
134           dir_acl (1).access_name = pds$process_group_id;
135           dir_acl (1).mode = SMA_ACCESS;                    /* sma for initializer */
136 
137 /* Make a new process_dir_dir */
138 
139           call append$branchx (">", "process_dir_dir", SMA_ACCESS_BIN, rb, (pds$process_group_id), 1, 0, 0, code);
140           if code ^= 0 then call syserr$error_code (CRASH, code, "init_branches: unable to make process_dir_dir:");
141 
142           call chname$cfile (">", "process_dir_dir", "", "pdd", ercode);
143                                                             /* add name pdd to process_dir_dir */
144           if ercode ^= 0
145           then call syserr$error_code (ANNOUNCE, ercode, "init_branches: couldn't add name pdd to process_dir_dir:");
146 
147 /* now force on per-process-sw */
148 
149           call initiate (">", "process_dir_dir", "", 0, 1, dp, code);
150           if code ^= 0 then call syserr$error_code (CRASH, code, "init_branches: unable to initiate >pdd:");
151           dp -> dir.per_process_sw = "1"b;                  /* yeh, i know i dont have it locked */
152           active_hardcore_data$pdd_uid = dp -> dir.uid;
153 
154           pddq = 131071;                                    /* give >pdd largest possible quota (2**17-1), to start with; answering
155                                                                service must keep track of it, and set it back up higher if
156                                                                it is in danger of running out because of lots of processes */
157           call quota$qset (">process_dir_dir", pddq, code); /* give PDD quota (makes it terminal) */
158           if code ^= 0 then call syserr$error_code (ANNOUNCE, code, "init_branches: couldn't set quota on >pdd to ^d ", pddq);
159           call quota$dqset (">process_dir_dir", pddq, code);/* give PDD quota (makes it terminal) */
160           if code ^= 0 then call syserr$error_code (ANNOUNCE, code, "init_branches: couldn't set dir quota on >pdd to ^d ", pddq);
161 
162 /* Create >system_library_1 */
163 
164           ename = "";                                       /* name to set soos on */
165           call chname$cfile (">", "system_library_1", "system_library_1", "system_library_1." || ustr, code);
166                                                             /* rename the old one */
167           if code = 0 then ename = "system_library_1." || ustr;
168           else if code ^= error_table_$noentry
169           then call syserr$error_code (CRASH, code, "init_branches: Renaming >system_library_1.");
170 
171           call chname$cfile (">", "sl1", "sl1", "sl1." || ustr, code);
172           if code = 0 then ename = "sl1." || ustr;
173           else if code ^= error_table_$noentry
174           then call syserr$error_code (CRASH, code, "init_branches: Renaming >sl1.");
175 
176           if ename ^= "" then do;
177                     call dc_find$obj_status_write_priv (">", ename, DC_FIND_NO_CHASE, FS_OBJ_SOOS_MOD, ep, code);
178                     if code ^= 0
179                     then call syserr$error_code (CRASH, code, "init_branches: Setting security_oosw for old >system_library_1.");
180                     ep -> entry.security_oosw = "1"b;
181                     call dc_find$finished (ptr (ep, 0), DC_FIND_UNLOCK_DIR);
182                end;
183 
184           call append$branchx (">", "system_library_1", SMA_ACCESS_BIN, rb, (pds$process_group_id), 1, 0, 0, code);
185           if code ^= 0 then call syserr$error_code (CRASH, code, "init_branches: unable to make >system_library_1:");
186 
187 /* give everyone access to >system_library_1 */
188 
189           dir_acl (2).access_name = "*.*.*";
190           dir_acl (2).mode = S_ACCESS;                      /* s to all */
191           call asd_$replace_dall (">", "system_library_1", addr (dir_acl), 2, No_daemon, ercode);
192           if ercode ^= 0 then call syserr$error_code (ANNOUNCE, ercode, "init_branches: error in replacing acl of >sl1.");
193 
194 /* Add name "sl1" to "system_library_1" */
195 
196           call chname$cfile (">", "system_library_1", "", "sl1", ercode);
197           if ercode ^= 0
198           then call syserr$error_code (ANNOUNCE, ercode, "init_branches: couldn't add name sl1 to system_library_1:");
199 
200 /* Save off the unique ID of >sl1 */
201 
202           call initiate (">", "sl1", "", 0, 1, dp, code);
203           if code ^= 0 then call syserr$error_code (CRASH, code, "init_branches: unable to initiate >sl1");
204           active_hardcore_data$sl1_uid = dp -> dir.uid;
205 
206 /* Create a branch for every segment in the SLT which needs one */
207 
208           sltp = addr (slt$);                               /* Pointer to the SLT. */
209           ntp = addr (name_table$);                         /* Pointer to names segment. */
210           sstp = addr (sst_seg$);                           /* Pointer to SST. */
211           write_lock = "1"b;                                /* directories will be locked for write */
212           do fi = 0 to 3;                                   /* loop through all AST lists */
213                relp = sstp -> sst.ausedp (fi);              /* Rel. pointer to start of circular list. */
214                if relp ^= "0"b then do;                     /* Do for all segs. on the list. */
215                          astep = ptr (sstp, relp);          /* Pointer to first entry. */
216 back:
217                          next_astep = ptr (astep, aste.fp); /* I might just unthread this one */
218                          if astep -> aste.usedf & /* if entry is free skip it */
219                               astep -> aste.hc_sdw then do; /* We only want prodigy of make_sdw */
220                                    i = fixed (astep -> aste.strp, 18); /* segno left for us by make_sdw */
221                                    astep -> aste.strp = ""b;/* zero strp field so that legitimate trailers can be made */
222                                    sltep = addr (sltp -> slt.seg (i)); /* Pointer to SLT entry. */
223 
224 /* Here we mask off the P bit, since append is not interested. */
225 
226                                    call create_branch (ptr (ntp, sltep -> slte.path_ptr), ptr (ntp, sltep -> slte.names_ptr),
227                                         sltep, bit (sltep -> slte.access, 3), segp, correct_max_length);
228                                                             /* Call to set up segment. */
229                                    call sum$getbranch_root_my (segp, write_lock, ep, ercode);
230                                                             /* get pointer to directory */
231                                    if ercode ^= 0 then call syserr$error_code (CRASH, ercode, "init_branches: getting dir entry pointer:");
232                                    dp = ptr (ep, 0);        /* Generate pointer to directory. */
233                                    pastep = get_ptrs_$given_segno (fixed (baseno (dp), 18));
234                                                             /* Get parent astep */
235                                    if pastep = null then call syserr (CRASH, "init_branches: Mysterious directory deactivation ");
236                                    astep -> aste.par_astep = rel (pastep); /* Thread active to father */
237                                    astep -> aste.infl = pastep -> aste.infp;
238                                                             /* thread into inferior list */
239                                    pastep -> aste.infp = rel (astep); /* ditto */
240                                                             /* it is ok to touch the parent dir here - we have assured its
241                                                                activity via the ic field and infl thread */
242                                    astep -> aste.per_process = ep -> entry.per_process_sw;
243                                                             /* Set per-process sw */
244                                    astep -> aste.msl = bit (correct_max_length, 9);
245                                                             /* take what i_b$b left */
246                                    astep -> aste.uid = ep -> entry.uid; /* Get uid into aste, so that segfault can find it. */
247                                    call thread$out (astep, sst.ausedp (fixed (aste.ptsi, 2)));
248                                                             /* No need to have him threaded. */
249                                    call search_ast$hash_in (astep); /* Make aste locatable */
250                                    astep -> aste.vtocx = ep -> entry.vtocx; /* Set up for update_vtoce */
251 
252                                    call sdw_util_$dissect (addr (dseg$ (i)), addr (sdwi));
253                                                             /* Set entrypoint bound, etc. */
254                                    ep -> entrypt_sw = (sdwi.gate_entry_bound > 0);
255                                    if sdwi.gate_entry_bound > 0
256                                    then ep -> entrypt_bound = bit (binary (sdwi.gate_entry_bound - 1, 14), 14);
257                                    else ep -> entrypt_bound = ""b;
258 
259                                    nm_astep = astep;        /* update sstnt */
260                                    temp_entry_name = (addr (ep -> entry.primary_name) -> names.name);
261 %include make_sstnt_entry;
262                                    call update_vtoce (astep); /* Update the vtoc, get seg ctl working here */
263                                    call lock$dir_unlock (dp); /* Unlock the directory now. */
264                                    call terminate_$teseg (segp, 0, ercode);
265                                                             /* remove seg. from KST. */
266                                    if ercode ^= 0 then call syserr$error_code (CRASH, ercode, "init_branches: error from terminate_:");
267                               end;
268                          astep = next_astep;                /* Bump ptr to next AST */
269                          if rel (astep) ^= relp then go to back; /* Go back for more. */
270                     end;
271           end;
272 
273 
274 /* Now find the ASTE for >pdd, and turn on aste.per_process, so that activate can
275    turn it on for sons activated off of that. */
276 
277           astep = get_ptrs_$given_segno (fixed (baseno (addr (pds$)), 18));
278                                                             /* I K^H_N^H_O^H_W^H_ that pds is in >pdd>zzz... */
279           astep = ptr (sstp, astep -> aste.par_astep);      /* Now this is >pdd>!zzz..... */
280           astep -> aste.per_process = "1"b;                 /* activate won't do this for me */
281           ptr (sstp, astep -> aste.par_astep) -> aste.per_process = "1"b;
282                                                             /* do this for >pdd */
283           do astep = ptr (sstp, astep -> aste.infp) /* Walk the sons of zzzzzbBBBBB */
284                repeat ptr (sstp, astep -> aste.infl) while (astep ^= sstp);
285 
286                astep -> aste.per_process = "1"b;
287           end;
288 
289           call set_ml ("slt");                              /* special case setting max length of slt and name table */
290           call set_ml ("name_table");                       /* since the lengths in their SLTEs are not accurate */
291 
292           call quota$qmove (">process_dir_dir", zzBB, active_hardcore_data$pdir_quota, code);
293           if code ^= 0 then call syserr$error_code (ANNOUNCE, code, "init_branches: quotas for pdir:");
294           call quota$dqmove (">process_dir_dir", zzBB, active_hardcore_data$pdir_dir_quota, code);
295           if code ^= 0 then call syserr$error_code (ANNOUNCE, code, "init_branches: dir quotas for pdir:");
296 
297           call asd_$replace_dall (">", "process_dir_dir", addr (dir_acl), 1, No_daemon, ercode);
298           if ercode ^= 0 then call syserr$error_code (ANNOUNCE, ercode, "init_branches: replacing >pdd acl:");
299 
300 /* Give Initializer access to its own process directory. */
301 
302           call asd_$replace_dall (">process_dir_dir", zzBB, addr (dir_acl), 1, No_daemon, ercode);
303           if ercode ^= 0 then call syserr$error_code (ANNOUNCE, ercode, "init_branches: replacing acl of >pdd for Initializer:");
304 
305 /* create >dumps and set access */
306           rb (1), rb (2), rb (3) = 7;
307           call append$branchx (">", "dumps", A_ACCESS_BIN, rb, "*.*.*", 1, 0, 0, code);
308           if code ^= 0
309           then if code ^= error_table_$namedup
310                then call syserr$error_code (BEEP, code, "init_branches: unable to append dumps directory.");
311                else if pvt$rlv_needs_salv then call salvager$dir_salv_boot (">dumps");
312 
313 
314           return;
315 ^L
316 
317 /* Internal Procedure to set the max length based on the current length */
318 
319 set_ml:
320      proc (entry_name);
321 
322           dcl     entry_name             char (*);
323 
324           call status_$long (">system_library_1", entry_name, 0, addr (branch), (null), ercode);
325           if ercode ^= 0 then call syserr$error_code (CRASH, ercode, "init_branches: From status_$long.");
326 
327           call set$max_length_path (">system_library_1", entry_name, branch.current_length * 1024, ercode);
328           if ercode ^= 0 then call syserr$error_code (CRASH, ercode, "init_branches: From set$max_length: ");
329 
330      end set_ml;
331 ^L
332 
333 branch:
334      entry (a_dirp, a_namep, a_sltep, a_access, a_segp);
335 
336           dcl     (a_dirp, a_namep, a_sltep, a_segp) pointer;
337           dcl     a_access               bit (3);
338 
339           call create_branch (a_dirp, a_namep, a_sltep, a_access, a_segp, (0)); /* max length unneeded for callers of this */
340           return;
341 
342 /* Subroutine to create and makeknown a branch */
343 
344 /*   USAGE:         call init_branches$branch (dirp, namep, sltep, access, segp);
345 
346    1) dirp ptr --- pointer the the directory name of the segment's parent
347    2) namep ptr --- pointer to the name of the segment
348    3) sltep ptr --- pointer to an SLT entry for the segment
349    4) access bit (3) --- an access field for the segment's SDW
350    5) segp ptr --- pointer to the segment (output)
351 
352 */
353 create_branch:
354      procedure (pp, a_np, slep, access, sp, ml_to_return);  /* Entry to append and makeknown a seg. */
355 
356           dcl     (pp, a_np, slep, sp)   ptr,
357                   access                 bit (3);
358           dcl     rb                     (3) fixed bin (3);
359           dcl     pname                  char (168);
360           dcl     ename                  char (32);
361           dcl     bc                     fixed bin (24);
362           dcl     max_length             fixed bin (19);
363           dcl     ml_to_return           fixed bin (9);
364 
365           rb (1) = fixed (slep -> slte.ringbrack (1), 6);   /* Copy ring brackets into fixed array. */
366           rb (2) = fixed (slep -> slte.ringbrack (2), 6);
367           rb (3) = fixed (slep -> slte.ringbrack (3), 6);
368           pname = pp -> path.name;                          /* PL/1 may be smarter than you think. */
369           ename = a_np -> segnam.names (1).name;            /* Put name on even boundary */
370           if slep -> slte.acl_provided
371           then aclp = addr (pp -> path.acls);
372           else aclp = null;                                 /* Generate pointer to ACL structure if present. */
373           bc = fixed (slep -> slte.bit_count, 24);
374           call make_branches (pp, a_np, bc, aclp, rb, access, 0);
375 
376 /* If no acl was specified on the header/slte, then there is an acl like:
377     rw *.SysDaemon.*
378     mode-from-slte *.*.*
379 
380    So we delete the SysDaemon acl.
381 */
382 
383           if aclp = null then do;                           /* remove *.SysDaemon.* entry if acl was not replaced */
384                     del_acl (1).access_name = "*.SysDaemon.*"; /* this acl is placed when the branch is created */
385                     aclp = addr (del_acl);
386                     call asd_$del_sentries (pname, ename, aclp, 1, ercode);
387                     if ercode ^= 0 then call syserr$error_code (ANNOUNCE, ercode, "init_branches: $branch From asd_$del_sentries: ");
388                end;
389           call initiate (pname, ename, "", 0, 1, sp, ercode);
390           if sp = null then call syserr$error_code (CRASH, ercode, "init_branches: error from initiate. ");
391           max_length =
392                max (divide (divide (bc + 35, 36, 19, 0) + 1023, 1024, 9, 0), fixed (slep -> slte.cur_length, 9),
393                fixed (slep -> slte.max_length, 9));         /* Calculate max length */
394           if max_length = 0 then max_length = 4;            /* As a last resort. */
395           call set$max_length_path (pname, ename, max_length * 1024, ercode);
396                                                             /* Prevent the segment from growing more than it should. */
397           if ercode ^= 0 then call syserr$error_code (CRASH, ercode, "init_branches: error from set$max_length ");
398           ml_to_return = max_length;
399           return;
400      end create_branch;
401 
402 %page;
403 %include acl_structures;
404 %page;
405 %include access_mode_values;
406 %page;
407 %include aste;
408 %page;
409 %include dc_find_dcls;
410 %page;
411 %include dir_entry;
412 %page;
413 %include dir_name;
414 %page;
415 %include dir_header;
416 %page;
417 %include fs_obj_access_codes;
418 %page;
419 %include sdw_info;
420 %page;
421 %include slt;
422 %page;
423 %include slte;
424 %page;
425 %include sst;
426 %page;
427 %include sstnt;
428 %page;
429 %include status_structures;
430 %page;
431 %include syserr_constants;
432 %page;
433 
434 /* BEGIN MESSAGE DOCUMENTATION
435 
436    Message:
437    init_branches: $branch From asd_:  ERRORMESSAGE
438 
439    S:     $info
440 
441    T:     $init
442 
443    M:     $err
444    Initialization continues.
445 
446    A:     $notify
447 
448 
449    Message:
450    init_branches: From set$max_length:  ERRORMESSAGE
451 
452    S:     $crash
453 
454    T:     $init
455 
456    M:     $err
457 
458    A:     $recover
459 
460 
461    Message:
462    init_branches: From status_$long:  ERRORMESSAGE
463 
464    S:     $crash
465 
466    T:     $init
467 
468    M:     $err
469 
470    A:     $recover
471 
472 
473    Message:
474    init_branches: Mysterious directory deactivation
475 
476    S:     $crash
477 
478    T:     $init
479 
480    M:     $err
481 
482    A:     $recover
483 
484 
485    Message:
486    init_branches: couldn't add name pdd to process_dir_dir: ERRORMESSAGE
487 
488    S:     $info
489 
490    T:     $init
491 
492    M:     $err
493    Initialization continues.
494    Certain application programs may fail to work.
495 
496    A:     $notify
497 
498 
499    Message:
500    init_branches: couldn't add name sl1 to system_library_1: ERRORMESSAGE
501 
502    S:     $info
503 
504    T:     $init
505 
506    M:     $err
507    Initialization continues.
508    Certain application programs may fail to work.
509 
510    A:     $notify
511 
512 
513    Message:
514    init_branches: couldn't set {dir}quota on >pdd to XXXX: ERRORMESSAGE
515 
516    S:     $info
517 
518    T:     $init
519 
520    M:     $err
521    Initialization continues.
522    The answering service may encounter trouble in creating processes.
523 
524    A:     $notify
525 
526 
527    Message:
528    init_branches: deleting old pdd: ERRORMESSAGE
529 
530    S:     $crash
531 
532    T:     $init
533 
534    M: The name pdd could not be removed from >pdd.
535    $err
536 
537    A:     $recover
538 
539 
540    Message:
541    init_branches: error from initiate.  ERRORMESSAGE
542 
543    S:     $crash
544 
545    T:     $init
546 
547    M: A deciduous segment could not be made known.
548    $err
549 
550    A:     $recover
551 
552 
553    Message:
554    init_branches: error from terminate_: ERRORMESSAGE
555 
556    S:     $crash
557 
558    T:     $init
559 
560    M:     $err
561 
562    A:     $recover
563 
564 
565    Message:
566    init_branches: error from set$max_length  ERRORMESSAGE
567 
568    S:     $crash
569 
570    T:     $init
571 
572    M:     $err
573 
574    A:     $recover
575 
576 
577    Message:
578    init_branches: error in adding acl of dumps: ERRORMESSAGE
579 
580    S:     $info
581 
582    T:     $init
583 
584    M:     $err
585    Initialization continues.
586    The copy_fdump command may fail.
587    The online  salvager may fail to make stack and directory copies in >dumps.
588 
589    A:     $notify
590 
591 
592    Message:
593    init_branches: error in replacing acl of >sl1. ERRORMESSAGE
594 
595    S:     $info
596 
597    T:     $init
598 
599    M:     $err
600    Initialization continues.
601    User and daemon processes may malfunction.
602 
603    A:     $notify
604 
605 
606    Message:
607    init_branches: getting dir entry pointer: ERRORMESSAGE
608 
609    S:     $crash
610 
611    T:     $init
612 
613    M:     $err
614 
615    A:     $recover
616 
617 
618    Message:
619    init_branches: {dir}quotas for pdir: ERRORMESSAGE
620 
621    S:     $info
622 
623    T:     $init
624 
625    M:     $err
626    Initialization continues.
627 
628    A:     $notify
629 
630 
631    Message:
632    init_branches: renaming old pdd: ERRORMESSAGE
633 
634    S:     $crash
635 
636    T:     $init
637 
638    M:     $err
639 
640    A:     $recover
641 
642 
643    Message:
644    init_branches: renaming process_dir_dir: ERRORMESSAGE
645 
646    S:     $crash
647 
648    T:     $init
649 
650    M:     $err
651 
652    A:     $recover
653 
654 
655    Message:
656    init_branches: replacing >pdd acl: ERRORMESSAGE
657 
658    S:     $info
659 
660    T:     $init
661 
662    M:     $err
663    Initialization continues.
664 
665    A:     $notify
666 
667 
668    Message:
669    init_branches: replacing acl of >pdd for Initializer: ERRORMESSAGE
670 
671    S:     $info
672 
673    T:     $init
674 
675    M:     $err
676    Initialization continues.
677 
678    A:     $notify
679 
680 
681    Message:
682    init_branches: unable to append dumps directory. ERRORMESSAGE
683 
684    S:     $beep
685 
686    T:     $init
687 
688    M:     $err
689    Initialization continues.
690 
691    A:     $notify
692 
693 
694    Message:
695    init_branches: unable to initiate >DIRNAME: ERRORMESSAGE
696 
697    S:     $crash
698 
699    T:     $init
700 
701    M:     $err
702 
703    A:     $recover
704 
705 
706    Message:
707    init_branches: unable to make >system_library_1: ERRORMESSAGE
708 
709    S:     $crash
710 
711    T:     $init
712 
713    M:     $err
714 
715    A:     $recover
716 
717 
718    Message:
719    init_branches: unable to make process_dir_dir: ERRORMESSAGE
720 
721    S:     $crash
722 
723    T:     $init
724 
725    M:     $err
726 
727    A:     $recover
728 
729 
730    END MESSAGE DOCUMENTATION */
731 
732      end init_branches;