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 /* format: style4,delnl,insnl,tree,ifthenstmt,indnoniterend */
 14 salv_directory:
 15      proc (arg_info_p, message, arg_old_dir_p, arg_old_dir_len, arg_code);
 16 
 17 /* One directory is found and salvaged.
 18    *
 19    * salv_directory           hphcs_ gate entry.  Used to invoke salvager from ring 4.
 20    *
 21    * ring0_salvage            regular call from salvager for the ring 1 salv command.
 22    *
 23    * online_salvage           Online salvager call.
 24 */
 25 
 26 /****^  HISTORY COMMENTS:
 27   1) change(77-07-01,Barr), approve(), audit(), install():
 28       Written by S.E. Barr.
 29   2) change(79-11-01,Grady), approve(), audit(), install():
 30       Modified by Mike Grady to add cleanup handler.
 31   3) change(81-11-12,Sibert), approve(), audit(), install():
 32       Modified by W. Olin Sibert to set the dir.uid properly to avoid an
 33       online salvage when locking.
 34   4) change(81-12-01,Hornig), approve(), audit(), install():
 35       Modified by C. Hornig for 205K directories.
 36   5) change(82-02-01,Margulies), approve(), audit(), install():
 37       Modified by BIM for new salv dir locking.
 38   6) change(82-03-01,Bongiovanni), approve(), audit(), install():
 39       Modified by J. Bongiovanni to eliminate use of FSDCT.
 40   7) change(82-03-01,Margulies), approve(), audit(), install():
 41       Modified for new vtoc_attributes info.
 42   8) change(84-07-01,Loepere), approve(), audit(), install():
 43       Modified by Keith Loepere to use the new dc_find.
 44   9) change(84-11-01,Loepere), approve(), audit(), install():
 45       Modified to clean up a little.
 46  10) change(84-12-05,EJSharpe), approve(), audit(), install():
 47       Modified to use access_audit_ instead of protection_audit_.
 48  11) change(86-05-23,Lippard), approve(86-06-17,MCR7433),
 49      audit(86-06-26,Hartogs), install(86-07-11,MR12.0-1091):
 50       Modified by Jim Lippard to establish cleanup handler before call to
 51       hold_segs.
 52  12) change(86-11-11,Lippard), approve(86-12-08,MCR7590),
 53      audit(87-04-16,Dickson), install(87-04-28,MR12.1-1028):
 54       Modified to copy caller name correctly for printing error messages.
 55                                                    END HISTORY COMMENTS */
 56 
 57 
 58 /* Parameters */
 59 
 60 dcl  arg_branch_p ptr;                                      /* ONLINE: ptr to branch for directory. */
 61 dcl  arg_code fixed bin (35);                               /* 0 = salvage completed. */
 62 dcl  arg_dp ptr;                                            /* ONLINE: ptr to directory. */
 63 dcl  arg_info_p ptr;                                        /* ptr to argument structure */
 64 dcl  arg_old_dir_len fixed bin;                             /* RING_4: Number of words in dump segment. */
 65 dcl  arg_old_dir_p ptr;                                     /* RING_4: Buffer for copy of directory. */
 66 dcl  message char (*) var;                                  /* RING_4: Error message segment. */
 67 
 68 /* Automatic */
 69 
 70 dcl  astep (4) ptr;                                         /* RING_4: ptrs for segments that were entry held. */
 71 dcl  branch_p ptr;                                          /* ptr to branch for directory. */
 72 dcl  caller fixed bin;                                      /* Identifies the entry point */
 73 dcl  child_dirmod bit (1) aligned;                          /* changed this dir */
 74 dcl  code fixed bin (35);
 75 dcl  1 copy_args aligned like salv_args;                    /* Copy of args for ring 4. */
 76 dcl  dir_uid bit (36) aligned;                              /* The UID in the vtoce when the dir was made known */
 77 dcl  1 event_flags aligned like audit_event_flags;          /* specifics of the operation */
 78 dcl  info_p ptr;                                            /* Copy of argument structure ptr. */
 79 dcl  new_dir_pages fixed bin;                               /* Number of pages in rebuilt directory. */
 80 dcl  parent_dirmod bit (1) aligned;                         /* changed containing dir */
 81 dcl  root bit (1) aligned;                                  /* ON, if root is being salaged. */
 82 dcl  1 root_entry aligned like entry;                       /* Dummy branch for the root. */
 83 dcl  set_security_oosw bit (1) aligned;                     /* ON, if the security_oosw in branch should be set. */
 84 dcl  should_dump bit (1) aligned;                           /* ON, if the directory has not yet been dumped. */
 85 dcl  unlock_dir bit (1) aligned;                            /* ON, if directory should be unlocked. */
 86 dcl  unlock_parent bit (1) aligned;                         /* ON, if parent directory should be unlocked. */
 87 
 88 /* Based */
 89 
 90 dcl  1 dir_branch aligned like entry based (branch_p);
 91 dcl  1 info aligned like salv_args based (info_p);
 92 
 93 /* Constants */
 94 
 95 dcl  ME char (14) int static options (constant) init ("salv_directory");
 96 dcl  MAX_MESSAGE_SIZE fixed bin (18) int static options (constant) init (16 * 1024);
 97 dcl  NEW_LINE char (1) int static options (constant) init ("
 98 ");
 99 dcl  ONLINE fixed bin int static options (constant) init (3);
100 dcl  RING_0 fixed bin int static options (constant) init (1);
101 dcl  RING_4 fixed bin int static options (constant) init (2);
102 dcl  packed_null ptr unal int static options (constant) init (null ());
103 
104 /* External */
105 
106 dcl  access_operations_$fs_obj_set_soos bit (36) aligned external;
107 dcl  error_table_$ external static;
108 dcl  error_table_$no_terminal_quota fixed bin (35) external;
109 dcl  error_table_$mylock fixed bin (35) external static;
110 dcl  pds$processid bit (36) aligned external static;
111 dcl  pvt$root_lvid bit (36) aligned external;
112 dcl  pvt$root_pvid bit (36) aligned external;
113 dcl  pvt$root_vtocx fixed bin (17) external;
114 dcl  sys_info$default_dir_max_length fixed bin (19) external;
115 
116 /* Entries */
117 
118 dcl  access_audit_$log_obj_class entry options (variable);
119 dcl  arg_count_ entry returns (fixed bin);
120 dcl  arg_list_ptr_ entry returns (pointer);
121 dcl  dir_dump entry (ptr, fixed bin);
122 dcl  formline_ entry (fixed bin, fixed bin, ptr, fixed bin, fixed bin (35));
123 dcl  grab_aste$prewithdraw entry (ptr, fixed bin (18), fixed bin (35)) returns (ptr);
124 dcl  grab_aste$release_prewithdraw entry (ptr);
125 dcl  level$get entry () returns (fixed bin);
126 dcl  lock$dir_unlock entry (pointer);
127 dcl  lock$dir_unlock_given_uid entry (bit (36) aligned);
128 dcl  salv_dir_checker_ entry (ptr, ptr, entry, bit (1) aligned, fixed bin);
129 dcl  salv_check_vtoce_ entry (ptr, char (*), bit (1) aligned, entry);
130 dcl  salv_err_msg$path entry options (variable);
131 dcl  sum$dirmod entry (pointer);
132 dcl  sum$getbranch_root_my entry (ptr, bit (1) aligned, ptr, fixed bin (35));
133 dcl  syserr entry options (variable);
134 dcl  truncate_vtoce entry (ptr, fixed bin, fixed bin (35));
135 dcl  vtoc_attributes$get_info entry (bit (36) aligned, bit (36) aligned, fixed bin, ptr, fixed bin (35));
136 dcl  vtoc_attributes$set_max_lth
137           entry (bit (36) aligned, bit (36) aligned, fixed bin, fixed bin (9), bit (1) aligned, fixed bin (35));
138 
139 /* Misc */
140 
141 dcl  cleanup condition;
142 
143 dcl  (addr, baseno, divide, hbound, length, min, null, ptr, rel, rtrim, string, substr, unspec) builtin;
144 %page;
145 /* Copy arguments and entry hold segments. */
146 
147           call setup;
148           caller = RING_4;
149           arg_old_dir_len = 0;
150           copy_args = arg_info_p -> salv_args;
151           info_p = addr (copy_args);
152 
153           goto START;
154 
155 
156 ring0_salvage:
157      entry (arg_info_p, arg_code);
158 
159           call setup;
160           caller = RING_0;
161           info_p = arg_info_p;
162           goto START;
163 
164 
165 /* ONLINE:  Already have pointers to the branch and the directory. */
166 /*          and the appropriate locks are locked */
167 
168 online_salvage:
169      entry (arg_info_p, arg_branch_p, arg_dp, arg_code);
170 
171           call setup;
172           info_p = arg_info_p;
173           branch_p = arg_branch_p;
174           dp = arg_dp;
175           caller = ONLINE;
176 
177 
178 START:
179           arg_code = 0;
180 
181 
182 /* We do not want to allow verify_lock to salvage (again) the directory */
183 /* in which the salvager has just taken a fault. This can cause locking */
184 /* difficulties, and is generally not very useful. Since salvager.pl1 */
185 /* has an any_other handler that hand-calls verify_lock, we have to */
186 /* always have a cleanup handler to unlock our locks, so that verify_lock */
187 /* will not find them. salvager makes an explicit call to the unwinder */
188 /* to insure that our cleanup handler runs. */
189 
190           unlock_dir, unlock_parent = "0"b;
191 
192           on cleanup call clean_up;
193 
194           if caller = RING_4 then do;
195                call hold_segs (code);
196                if code ^= 0 then do;
197                     arg_code = code;
198                     call rel_segs;
199                     return;
200                     end;
201                end;
202 
203           call get_dir (code);
204           if code = 0 then do;
205 
206 /* Fill information for this directory: master_dir_uid, tree depth, branch_ptr. */
207                should_dump = info.dump;
208 
209                if dir_branch.master_dir
210                then info.master_dir_uid = dir_branch.uid;
211                else info.master_dir_uid = ptr (branch_p, 0) -> dir.master_dir_uid;
212 
213                if root
214                then info.tree_depth = 0;
215                else info.tree_depth = ptr (branch_p, 0) -> dir.tree_depth + 1;
216 
217                info.branch_ptr = branch_p;
218 
219 /* current length and quota */
220 
221                call vtoc_attributes$get_info ((dir_branch.uid), (dir_branch.pvid), (dir_branch.vtocx), addr (sc_info),
222                     code);
223                if code = 0 then do;
224                     info.current_length = divide (sc_info.csl + 1023, 1024, 17, 0);
225                     if sc_info.msl ^= sys_info$default_dir_max_length then do;
226                          call vtoc_attributes$set_max_lth ((dir_branch.uid), (dir_branch.pvid), (dir_branch.vtocx),
227                               divide (sys_info$default_dir_max_length, 1024, 9, 0), "0"b, code);
228                          if code = 0
229                          then call print (SALV_LOG, ME, "Changed max length in VTOCE from ^d to ^d.", sc_info.msl,
230                                    sys_info$default_dir_max_length);
231                          else call print_code (SALV_LOG, ME, code, "Changing max length in VTOCE.");
232                          end;
233 
234                     call salv_dir_checker_ (dp, info_p, print, set_security_oosw, new_dir_pages);
235 
236 /* If the directory was rebuilt (new_dir_pages > 0), then print error message and truncate the directory. */
237                     if new_dir_pages > 0 then do;
238                          child_dirmod = "1"b;
239 
240                          if new_dir_pages < info.current_length then do;
241                               call truncate_vtoce (branch_p, new_dir_pages, code);
242                               if code ^= 0
243                               then call print_code (SALV_ANNOUNCE, ME, code, "truncate_vtoce to length ^d failed.",
244                                         new_dir_pages);
245                               code = 0;
246                               end;
247                          end;
248                     call check_upgraded_dir;
249                     if set_security_oosw then do;
250                          dir_branch.security_oosw = "1"b;
251                          parent_dirmod = "1"b;
252                          end;
253 
254                     if info.check_vtoce
255                     then call salv_check_vtoce_ (dp, (info.pathname), (info.delete_connection_failure), print_code);
256                                                             /* Call protection audit for any branches that are security out-of-service. */
257 
258                     do ep = ptr (dp, dir.entryfrp) repeat ptr (dp, entry.efrp) while (rel (ep));
259 
260                          if entry.bs
261                          then if entry.security_oosw then do;
262                                    call print (SALV_LOG, ME,
263                                         "Branch is security out-of-service: " || addr (entry.primary_name) -> names.name);
264                                    string(event_flags) = ""b;
265                                    event_flags.special_op = "1"b;
266                                    event_flags.grant = "1"b; /* we're not doing anything but auditing */
267                                    if caller = RING_4
268                                    then event_flags.priv_op = "1"b;
269                                    call access_audit_$log_obj_class ("salv_directory", level$get(),
270                                         string(event_flags), access_operations_$fs_obj_set_soos,
271                                         entry.access_class, target (info.pathname,
272                                         (addr(entry.primary_name)->names.name)), 0, null(), 0,
273                                         "switch found already on");
274 
275                                    end;
276 
277                     end;
278                     end;
279                end;
280           call clean_up;
281 
282           if code ^= 0 then do;                             /* vtoc_attributes$get_info failed */
283                call print_code (SALV_ANNOUNCE, ME, code, "Could not read VTOCE attributes.");
284                arg_code = code;
285                end;
286 
287           return;
288 %page;
289 /* AIM - Upgraded directories must have non-zero quota.  If such a directory is found, it will be
290    set security out-of-service */
291 check_upgraded_dir:
292      proc;
293 
294 dcl  1 quota_info aligned like quota_cell defined (sc_info.qcell (0));
295 
296           if root then return;
297           if ptr (branch_p, 0) -> dir.access_class = dir.access_class then return;
298           if quota_info.quota = 0 then do;
299                call print (SALV_ANNOUNCE, ME, "Upgraded dir set security out-of-service due to no quota.");
300                string(event_flags) = ""b;
301                event_flags.special_op = "1"b;
302                event_flags.grant = "1"b;
303                if caller = RING_4
304                then event_flags.priv_op = "1"b;
305                call access_audit_$log_obj_class ("salv_directory", level$get(),
306                     string(event_flags), access_operations_$fs_obj_set_soos, dir.access_class,
307                     info.pathname, error_table_$no_terminal_quota, null(), 0);
308                set_security_oosw = "1"b;
309                end;
310 
311      end check_upgraded_dir;
312 %page;
313 get_dir:
314      proc (code);
315 
316 dcl  code fixed bin (35) parameter;
317 
318           root = (info.pathname = ">");
319           code = 0;
320 
321 
322 /* Directory and parent are already locked in the online case. */
323 
324           if caller = ONLINE then do;
325                if root then call setup_root_branch;
326                return;
327                end;
328 
329 /* Find and lock directory.  If the directory is out-of-service, salvage anyway. */
330 
331           call dc_find$dir_salvage (info.pathname, dir_uid, dp, code);
332           if code ^= 0 then return;
333           unlock_dir = "1"b;
334 
335           dir.modify = pds$processid;
336 
337 /* Lock the parent directory and get the branch.  The root needs a phony branch. */
338 
339           if root
340           then call setup_root_branch;
341           else do;
342                call sum$getbranch_root_my (dp, "1"b, branch_p, code);
343                if code = 0
344                then unlock_parent = "1"b;
345                else if code ^= error_table_$mylock then return;
346                end;
347 
348           return;
349 
350      end get_dir;
351 %page;
352 hold_segs:
353      proc (code);
354 
355 dcl  code fixed bin (35) parameter;
356 
357           astep (*) = null;
358 
359 /* Message segment. */
360           astep (1) = grab_aste$prewithdraw (addr (message), MAX_MESSAGE_SIZE, code);
361           if code ^= 0 then return;
362 
363 /* Copy of directory for the case of a dump */
364           if info.dump then do;
365                astep (2) = grab_aste$prewithdraw (arg_old_dir_p, 255 * 1024, code);
366                if code ^= 0 then return;
367                end;
368 
369 /* Storage image of the directory is 1/4th of the size of the directory. */
370 
371           astep (3) = grab_aste$prewithdraw (info.temp2_ptr, 64 * 1024, code);
372           if code ^= 0 then return;
373 
374 /* Rebuilt directory. */
375 
376           astep (4) = grab_aste$prewithdraw (info.temp1_ptr, 255 * 1024, code);
377           return;
378 
379      end hold_segs;
380 %page;
381 clean_up:
382      proc;
383 
384 /* On non-RING_0 salvages we could leave it to verify_lock to */
385 /* clean things up, but that would produce salvages of parent dirs. */
386 
387           if dp ^= null then dir.modify = "0"b;
388 
389           if child_dirmod
390           then call sum$dirmod (dp);
391           else if parent_dirmod then call sum$dirmod (ptr (branch_p, 0));
392 
393           if unlock_dir then call lock$dir_unlock_given_uid (dir_uid);
394           if unlock_parent then call lock$dir_unlock (ptr (branch_p, 0));
395           if dp ^= null then call dc_find$finished (dp, "0"b);
396 
397           if caller = RING_4 then call rel_segs;
398 
399      end clean_up;
400 
401 
402 
403 rel_segs:
404      proc;
405 
406 dcl  i fixed bin;
407 
408           do i = 1 to hbound (astep, 1);
409                if astep (i) ^= null then call grab_aste$release_prewithdraw (astep (i));
410           end;
411 
412      end rel_segs;
413 %page;
414 print:
415      procedure options (variable);
416 
417 
418 dcl  arg_list_arg_count fixed bin;
419 dcl  arg_list_ptr pointer;
420 dcl  caller_name char (32);
421 dcl  copy_len fixed bin;
422 dcl  have_code bit (1) aligned;                             /* ON, if non-zero code was specified with call. */
423 dcl  line char (256);                                       /* Complete output line. */
424 dcl  line_len fixed bin;                                    /* Number of characters for output */
425 dcl  msg_len fixed bin;                                     /* Number of characters in error_table_message. */
426 dcl  msg_p ptr unal;                                        /* ptr to error_table_ message structure. */
427 dcl  pic pic "99";
428 dcl  severity fixed bin;                                    /* copy of severity level. */
429 dcl  start fixed bin;                                       /* index of 1st arg for message. */
430 dcl  string char (253) defined (line) pos (3);              /* Message from formline. */
431 
432 dcl  based_code fixed bin (35) based;
433 dcl  based_severity fixed bin based;
434 dcl  based_caller_name char (32) based;
435 dcl  copy (copy_len) bit (36) based;
436 dcl  1 et aligned based (msg_p),                            /* An error_table_ message */
437        2 len fixed bin (8) unal,                            /* Length of the message */
438        2 msg char (et.len) unal;                            /* The message */
439 %page;
440           have_code = "0"b;
441           start = 3;
442           goto FORMAT;
443 
444 print_code:
445      entry options (variable);
446 
447           have_code = "1"b;                                 /* can correct later if code = 0 */
448           start = 4;
449 
450 FORMAT:                                                     /* Format line:  <blank> <blank> <message> <new_line>    */
451           arg_list_ptr = arg_list_ptr_ ();
452           arg_list_arg_count = arg_count_ ();
453 
454           if arg_list_arg_count < 3 then call syserr (CRASH, "salv_directory: Invalid call to error message printer.");
455 
456           severity = arg_list_ptr -> arg_list_with_envptr.arg_ptrs (1) -> based_severity;
457           caller_name = substr (arg_list_ptr -> arg_list_with_envptr.arg_ptrs (2) -> based_caller_name,
458                1, arg_list_ptr -> arg_list_with_envptr.desc_ptrs (2) -> arg_descriptor.size);
459           if have_code
460           then code = arg_list_ptr -> arg_list_with_envptr.arg_ptrs (3) -> based_code;
461           else code = 0;
462           if code = 0 then have_code = "0"b;                /* dont bother to print null message */
463 
464           line_len = length (string);
465           call formline_ (start, start + 1, addr (string), line_len, (0));
466           line_len = length (rtrim (substr (string, 1, line_len)));
467           substr (line, 1, 2) = "";
468           line_len = line_len + 2;
469 
470 /* Add error_table_ message. Interpret code as a packed ptr that points to the error message. */
471 
472           if have_code then do;
473                unspec (msg_p) = unspec (code);
474                if baseno (msg_p) = baseno (packed_null) then do;
475                     msg_p = ptr (addr (error_table_$), rel (msg_p));
476                     msg_len = min (length (line) - line_len, et.len + 1);
477                     if msg_len > 0 then do;
478                          substr (line, line_len + 1, msg_len) = " " || et.msg;
479                          line_len = line_len + msg_len;
480                          end;
481                     end;
482                end;
483 
484 
485 /* Put message in ring 4 segment or call hardcore print routine */
486 
487           if caller = RING_4 then do;
488                pic = severity;
489                if length (message) + line_len < MAX_MESSAGE_SIZE then do;
490                     message = message || pic;
491                     message = message || substr (line, 1, line_len) || NEW_LINE;
492                     if (severity = SALV_DEBUG) & should_dump then do;
493                          copy_len, arg_old_dir_len = info.current_length * 1024;
494                          arg_old_dir_p -> copy = dp -> copy;
495                          should_dump = "0"b;
496                          end;
497                     end;
498                end;
499           else do;
500                call salv_err_msg$path (severity, info.pathname, rtrim (caller_name) || ": " || substr (line, 1, line_len));
501                if (severity = SALV_DEBUG) & should_dump then do;
502                     call dir_dump (dp, info.current_length);
503                     should_dump = "0"b;
504                     end;
505                end;
506 
507      end print;
508 %page;
509 setup_root_branch:
510      procedure;
511 
512           branch_p = addr (root_entry);
513           unspec (root_entry) = "0"b;
514           root_entry.uid, root_entry.owner = (36)"1"b;
515           root_entry.pvid = pvt$root_pvid;
516           root_entry.sons_lvid = pvt$root_lvid;
517           root_entry.vtocx = pvt$root_vtocx;
518           root_entry.dirsw = "1"b;
519           root_entry.master_dir = "1"b;
520           root_entry.name_frp = rel (addr (root_entry.primary_name));
521           addr (root_entry.primary_name) -> names.name = ">";
522           root_entry.per_process_sw = "0"b;
523           root_entry.bs = "1"b;
524           root_entry.access_class = "0"b;
525 
526      end setup_root_branch;
527 
528 setup:
529      procedure;
530 
531 /* Initialize here for benefit of handlers */
532 
533           dp, branch_p = null ();
534           unlock_dir, unlock_parent = "0"b;
535           parent_dirmod, child_dirmod = "0"b;
536      end setup;
537 %page;
538 target: proc (dir, ent) returns (char (*));
539 
540 dcl       dir       char (*) parameter;
541 dcl       ent       char (*) parameter;
542 
543           if dir = ">"
544           then return (">"||ent);
545           else return (rtrim(dir)||">"||ent);
546 
547      end target;
548 %page;
549 %include arg_descriptor;
550 %page;
551 %include arg_list;
552 %page;
553 %include dc_find_dcls;
554 %page;
555 %include dir_allocation_area;
556 %page;
557 %include dir_entry;
558 %page;
559 %include dir_header;
560 %page;
561 %include dir_name;
562 %page;
563 %include quota_cell;
564 %page;
565 %include salv_args;
566 %page;
567 %include salvager_severities;
568 %page;
569 %include sc_info;
570 %page;
571 %include syserr_constants;
572 %page;
573 %include access_audit_eventflags;
574 %page;
575 
576 /* BEGIN MESSAGE DOCUMENTAION
577 
578    Message:
579    AUDIT (salv_directory): GRANTED modification of security out-of-service ADDED_INFO switch found already on
580 
581    S:     $access_audit
582 
583    T:     Salvaging
584 
585    M:     At a previous time the system set the branch security out-of-service
586    because of an AIM error.
587 
588    A:     $inform_ssa
589 
590 
591    Message:
592    AUDIT (salv_directory): GRANTED modification of security out-of-service ADDED_INFO
593 
594    S:     $access_audit
595 
596    T:     Salvaging
597 
598    M:     The directory has a different access class from its parent and
599    it has no quota.  This is an AIM violation.
600 
601    A:     $inform_ssa
602 
603    Message:
604    salv_directory: Changed max length in VTOCE from LENGTH to MAXLENGTH.
605 
606    S:     $log
607 
608    T:     Salvaging
609 
610    M:     The max length of a directory was changed to the system default.
611 
612    A:     $ignore
613 
614 
615    Message:
616    salv_directory: ERROR_MESSAGE. Changing max length in VTOCE.
617 
618    S:     $log
619 
620    T:     Salvaging
621 
622    M:     An error occurred while changing a dir's max length.
623 
624    A:     $inform
625 
626 
627    Message:
628    salv_directory: ERROR_MESSAGE. truncate_vtoce to length LENGTH failed.
629 
630    S:     $log
631 
632    T:     Salvaging
633 
634    M:     An error occurred while truncating a directory.
635 
636    A:     $inform
637 
638 
639    Message:
640    salv_directory: Branch is security out-of-service: BRANCH_NAME
641 
642    S:     $log
643 
644    T:     Salvaging
645 
646    M:     A branch is security out-of-service.
647 
648    A:     $inform_ssa
649 
650 
651    Message:
652    salv_directory: ERROR_MESSAGE. Could not read VTOCE attributes.
653 
654    S:     $log
655 
656    T:     Salvaging
657 
658    M:     An error occurred while reading the VTOCE.
659 
660    A:     $inform_sa
661 
662 
663    Message:
664    salv_directory: Upgraded dir set security out-of-service due to no quota.
665 
666    S:     $log
667 
668    T:     Salvaging
669 
670    M:     An upgraded directory was set soos due to not having terminal quota.
671 
672    A:     $inform_ssa
673 
674 
675    Message:
676    salv_directory: Invalid call to error message printer.
677 
678    S:     $log
679 
680    T:     Salvaging
681 
682    M:     An programming error resulted in an invalid call to the error
683    message printing procedure.
684 
685    A:     $inform
686 
687    END MESSAGE DOCUMENTATION */
688 
689      end salv_directory;