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 /* format: style3 */
 13 
 14 verify_lock:
 15      procedure;
 16 
 17 /*
 18 
 19    verify_lock: called by signal_ before we leave ring 0.
 20 
 21    USAGE: call verify_lock;
 22 
 23    NOTES:
 24    1. If an error condition exist this proc will crash the system
 25    with an appropriate error message.
 26 
 27    Modification history:
 28    75-05-30, A. Bensoussan: Initial coding
 29    76-07-26, Greenberg: Modified to avoid online-salv recursion in pdir salv
 30    79-02-03, D. Spector: Modified to log only crawl-outs which unlock locks
 31    79-07-28, W. Olin Sibert: Modified to unlock all dir locks, even if
 32      they don't correspond to real dirs -- fixes Volume_Dumper lossage
 33      which causes notify timeouts when fake dir remains locked
 34    81-04-09, J. Bongiovanni: Modified to call vtoc_man$crawlout if vtoc
 35      buffer lock held, and to correct syserr logging of history registers
 36    82-02-23, BIM: Modified for improved dir locking and other stuff.
 37    82-04-01, J. Bongiovanni: Modified for PVT locks
 38    82-04-15, JIS: Changed to cleanup system_free_seg before checking lock array
 39    82-04-28, BIM: Modified for removal of system free seg entirely.
 40    83-01-18, BIM: Modified to cleanup of write_sw in dirlockt.
 41    83-03-12, BIM: Modified for readers in the dir_lock_seg_, better messages.
 42    83-08-05, Chris Jones: Modified for ioi_verify_lock.
 43    84-10-25, WOS: Changed for syserr_seg_manager$verify
 44    83-11-08, BIM: Change for better readers in dir_lock_seg_, check for masked.
 45    84-11-01, Keith Loepere to remove unused notion of directory detectability.
 46    85-02-21, EJ Sharpe: use syserr_fault_msg include for binary messages,
 47                     added condition_nolog entrypoint for initial use by scavenger
 48    85-03-28, EJ Sharpe: chaged to log MC/HREG only if some lock unlocked for phx16862
 49    85-05-13, EJ Sharpe: added check for lock on dm_journal_seg_
 50 */
 51 
 52 /****^  HISTORY COMMENTS:
 53   1) change(86-06-05,GJohnson), approve(86-06-05,MCR7387),
 54      audit(86-06-10,Martinson), install(86-07-11,MR12.0-1091):
 55      Correct error message documentation.
 56   2) change(86-10-23,Fawcett), approve(86-10-23,MCR7517),
 57      audit(86-10-30,Beattie), install(86-11-03,MR12.0-1206):
 58      Changed to remove the word BOS from Error message documentation.
 59                                                    END HISTORY COMMENTS */
 60 
 61 dcl       1 dirs_locked       aligned,                      /* remember them here, */
 62             2 count           fixed bin,                    /* so they can all be unlocked before */
 63             2 array           (30) aligned,                 /* any are salvaged */
 64               3 seg_ptr       pointer,
 65               3 uid           bit (36) aligned;
 66 
 67 dcl       code                fixed bin (35);
 68 dcl       cond_name           char (32);
 69 
 70 dcl       check_masked        bit (1) aligned;
 71 dcl       log_condition       bit (1) aligned;              /* flag indicating we should log this condition */
 72 dcl       unlock_occurred     bit (1) aligned;              /* indicates something was force unlocked */
 73 dcl       mcptr               ptr;
 74 dcl       pvtx                fixed bin;
 75 dcl       pagex               fixed bin;
 76 dcl       p99                 pic "99";
 77 dcl       tsdw                fixed bin (71);
 78 
 79 %include hc_lock;
 80 
 81 dcl       condition_          entry (char (*), entry);
 82 dcl       ioi_verify_lock     entry () returns (bit (1) aligned);
 83 dcl       reversion_          entry (char (*));
 84 dcl       syserr              entry options (variable);
 85 dcl       syserr$binary       entry options (variable);
 86 dcl       syserr$error_code   entry options (variable);
 87 dcl       on_line_salvager    entry (ptr, fixed bin (35));
 88 dcl       lock$dir_unlock_given_uid
 89                               entry (bit (36) aligned);
 90 dcl       lock$dir_lock_salvage
 91                               entry (ptr, bit (36) aligned, fixed bin (35));
 92 dcl       lock$unlock_fast    entry (ptr);
 93 dcl       lock$lock_fast      entry (pointer);
 94 dcl       pxss$notify         entry (bit (36) aligned);
 95 dcl       get_pvtx$cleanup    entry () returns (bit (1) aligned);
 96 dcl       debug_check         entry (char (4) aligned) returns (bit (1));
 97 dcl       vtoc_man$crawlout   entry;
 98 dcl       tty_lock$verify     entry () returns (bit (1) aligned);
 99 dcl       syserr_seg_manager$verify_lock
100                               entry () returns (bit (1) aligned);
101 dcl       kstsrch             entry (bit (36) aligned, fixed bin (17), ptr);
102 dcl       page$write_volmap_page_unwired
103                               entry (ptr, fixed bin);
104 dcl       page$unlock_volmap  entry (ptr);
105 dcl       pmut$swap_sdw       entry (ptr, ptr);
106 dcl       pmut$read_mask      entry (fixed bin (71));
107 dcl       vtoce_stock_man$force_unlock
108                               entry (ptr);
109 
110 dcl       pds$process_group_id
111                               external char (32) aligned;
112 dcl       pds$processid       external bit (36) aligned;
113 dcl       pds$block_lock_count
114                               external fixed bin (17);
115 dcl       scs$sys_level       fixed bin (71) external static;
116 dcl       error_table_$salv_pdir_procterm
117                               external fixed bin (35);
118 dcl       ahd$search_rules_lock
119                               external;
120 dcl       sst$astl            bit (36) aligned external static;
121 dcl       tc_data$system_shutdown
122                               external bit (1) aligned;
123 dcl       tc_data$lock_error_severity
124                               fixed bin external static;
125 dcl       pvt$n_entries       fixed bin external static;
126 dcl       volmap_abs_seg$     external static;
127 
128 dcl       seg_fault_error     condition;
129 dcl       page_fault_error    condition;
130 dcl       subscriptrange      condition;
131 
132 dcl       (addr, addrel, baseptr, convert, hbound, null, unspec)
133                               builtin;
134 %page;
135 /* MAIN PROGRAM */
136 
137           cond_name = "r0 process termination";
138           check_masked = "0"b;
139           mcptr = null;
140           log_condition = "1"b;
141 
142 start:
143           if debug_check ("crwl")
144           then call syserr (SYSERR_CRASH_SYSTEM, "verify_lock: Crawlout stop specified on PARM card.");
145 
146           unlock_occurred = "0"b;
147           code = 0;
148 
149           if (syserr_seg_manager$verify_lock ())
150           then call NOTE_UNLOCK ("syserr_log");
151 
152           call VERIFY_PVT_LOCKS;
153 
154           call VERIFY_VTOC_BUFFERS;
155 
156           if (ioi_verify_lock ())                           /* logs own messages */
157           then unlock_occurred = "1"b;
158 
159           call VERIFY_DBM;
160 
161           call VERIFY_DM_JOURNAL_SEG;
162 
163           if (get_pvtx$cleanup ())                          /* logs own messages */
164           then unlock_occurred = "1"b;
165 
166           call VERIFY_DIR_LOCK_SEG;
167 
168           call VERIFY_AST (code);
169           if code ^= 0
170           then call syserr (SYSERR_CRASH_SYSTEM, "verify_lock: Crawlout with AST lock set.");
171 
172           call VERIFY_SEARCH_RULES;
173 
174           if (tty_lock$verify ())                           /* logs own messages */
175           then unlock_occurred = "1"b;
176 
177           dirs_locked.count = 0;
178           dirs_locked.seg_ptr (*) = null ();
179           dirs_locked.uid (*) = (36)"0"b;
180 
181           call VERIFY_DIRECTORIES (code);
182           if code ^= 0
183           then call syserr (SYSERR_CRASH_SYSTEM, "verify_lock: Crawlout error on directory cleanup.");
184 
185           call SALVAGE_DIRECTORIES;
186 
187           if pds$block_lock_count ^= 0
188           then call syserr (SYSERR_CRASH_SYSTEM, "verify_lock: block_lock_count ^d, should be 0", pds$block_lock_count);
189 
190           if check_masked
191           then call VERIFY_MASKED;
192 
193 
194           if log_condition & unlock_occurred
195           then if mcptr = null
196                then call syserr (SYSERR_LOG_OR_PRINT, "verify_lock: ^a condition by ^a", cond_name, pds$process_group_id);
197                else call make_syserr_message (cond_name, mcptr);
198 
199           return;
200 %page;
201 /* These entry points are called when hardcore wants to log a message about the condition. */
202 
203 verify_lock_bad_dir:
204      entry (a_mcptr);
205 
206           cond_name = "bad_dir_";
207           mcptr = null;
208           check_masked = "1"b;
209           log_condition = "1"b;
210           go to start;
211 
212 condition:
213      entry (a_name, a_mcptr);
214 
215 dcl       a_name              char (*);
216 dcl       a_mcptr             ptr;
217 
218           cond_name = a_name;
219           mcptr = a_mcptr;
220           check_masked = "1"b;
221           log_condition = "1"b;
222           go to start;
223 
224 
225 /* The following entrypoint is used by hardcore procedures which perform
226 their own logging of the condition. */
227 
228 condition_nolog:
229      entry (a_name, a_mcptr);
230 
231           cond_name = a_name;
232           mcptr = a_mcptr;
233           check_masked = "1"b;
234           log_condition = "0"b;
235           go to start;
236 %page;
237 VERIFY_VTOC_BUFFERS:
238      proc;
239 
240           vtoc_buffer_segp = addr (vtoc_buffer_seg$);
241           lock_ptr = addr (vtoc_buffer.lock);
242 
243           if lock.pid = pds$processid
244           then do;
245                     call vtoc_man$crawlout;
246                     call lock$unlock_fast (lock_ptr);
247                     call NOTE_UNLOCK ("vtoc_buffer_seg");
248                end;
249           else call CHECK_NOTIFY (lock_ptr);
250           return;
251      end VERIFY_VTOC_BUFFERS;
252 %page;
253 VERIFY_DBM:
254      procedure;
255 
256 %include dbm;
257 %page;
258           dbmp = addr (dbm_seg$);
259           lock_ptr = addr (dbm.lock_data);
260           if lock.pid = pds$processid
261           then do;
262                     call lock$unlock_fast (lock_ptr);
263                     call NOTE_UNLOCK ("dbm_seg");
264                end;
265           else call CHECK_NOTIFY (lock_ptr);
266           return;
267      end VERIFY_DBM;
268 %page;
269 VERIFY_DM_JOURNAL_SEG:
270      procedure;
271 
272 %include dm_journal_seg_;
273 %page;
274           dm_journal_segp = addr (dm_journal_seg_$);
275           lock_ptr = addr (dm_journal.lock);
276           if lock.pid = pds$processid
277           then do;
278                     call lock$unlock_fast (lock_ptr);
279                     call NOTE_UNLOCK ("dm_journal_seg_");
280                end;
281           else call CHECK_NOTIFY (lock_ptr);
282           return;
283      end VERIFY_DM_JOURNAL_SEG;
284 %page;
285 VERIFY_DIR_LOCK_SEG:
286      procedure;
287 
288           dir_lock_segp = addr (dir_lock_seg$);
289           lock_ptr = addr (dir_lock_seg.seg_lock);
290 
291           if lock.pid = pds$processid
292           then do;
293                     call NOTE_UNLOCK ("dir_lock_seg");
294                     call lock$unlock_fast (lock_ptr);
295                end;
296           else call CHECK_NOTIFY (lock_ptr);
297           return;
298      end VERIFY_DIR_LOCK_SEG;
299 
300 
301 
302 VERIFY_AST:
303      proc (code);
304 
305 dcl       code                fixed bin (35);
306 
307           lock_ptr = addr (sst$astl);
308 
309           if lock.pid = pds$processid
310           then do;
311                     code = 1;
312                end;
313           else call CHECK_NOTIFY (lock_ptr);
314           return;
315      end VERIFY_AST;
316 %page;
317 
318 /* Check for dir locks */
319 
320 
321 VERIFY_DIRECTORIES:
322      procedure (code);
323 
324 dcl       code                fixed bin (35);
325 dcl       i                   fixed bin (17);
326 dcl       rx                  fixed bin;
327 dcl       this_dir_locked     bit (1) aligned;
328 
329           code = 0;
330           dir_lock_segp = addr (dir_lock_seg$);
331           dir_lock_all_locksp = dir_lock_seg.header.locks_ptr;
332           dir_lock_all_readersp = dir_lock_seg.header.readers_ptr;
333 
334 LOOP_OVER_DIRS:
335           do i = 1 to dir_lock_seg.header.highest_in_use;
336                this_dir_locked = "0"b;
337                dir_lockp = addr (dir_lock_all_dir_locks (i));
338                dir_read_lockers_ptr = addr (dir_lock_all_readers (i, 1));
339                if dir_lock.lock_count ^= 0
340                then do;
341                          call lock$lock_fast (addr (dir_lock_seg.header.seg_lock));
342                                                             /* make sure this is for real */
343                          if dir_lock.lock_count > 0
344                          then if dir_lock.write_locker = pds$processid
345                               then this_dir_locked = "1"b;
346                               else ;                        /* locked exclusively to someone else */
347                          else if dir_lock.lock_count < 0
348                          then /* read locked */
349 LOOP_OVER_LOCKERS:
350                               do rx = 1 to hbound (dir_read_lockers, 1);
351                                    if dir_read_lockers (rx) = pds$processid
352                                    then this_dir_locked = "1"b;
353                               end LOOP_OVER_LOCKERS;
354 
355                          call lock$unlock_fast (addr (dir_lock_seg.header.seg_lock));
356                          if this_dir_locked
357                          then call VERIFY_DIR (dir_lock.uid, (dir_lock.salvage_sw), (dir_lock.lock_count > 0));
358                     end;
359 
360           end LOOP_OVER_DIRS;
361           return;
362 
363      end VERIFY_DIRECTORIES;
364 
365 
366 VERIFY_DIR:
367      procedure (uid, salvage_sw, write_sw) options (non_quick);
368 
369 dcl       uid                 bit (36) aligned;
370 dcl       salvage_sw          bit (1) aligned;
371 dcl       write_sw            bit (1) aligned;
372 
373           dp = GET_SEG_PTR (uid);
374 
375           if salvage_sw                                     /* Salvager had it locked */
376           then do;                                          /* Do nearly nothing */
377                     call syserr (SYSERR_LOG_OR_PRINT, "verify_lock: Crawlout while in directory salvager, dir (^w,^p).",
378                          uid, dp);
379                     go to unlock_return;
380                end;
381 
382           if dp = null                                      /* This is not the KST uid, the dir may not even be there */
383           then go to unlock_return;
384 
385           on seg_fault_error, page_fault_error go to NO_MODIFY_CHECK;
386           if (dir.modify ^= pds$processid) & (dir.modify ^= ""b)
387           then do;
388                     call syserr (tc_data$lock_error_severity, "verify_lock: dir.modify ^p ^w ^^= processid.", dp,
389                          dp -> dir.modify);
390                end;
391 
392 NO_MODIFY_CHECK:
393           revert seg_fault_error, page_fault_error;
394 
395           on subscriptrange
396                call syserr (SYSERR_CRASH_SYSTEM, "verify_lock: more than ^d directories locked to process.",
397                     hbound (dirs_locked.seg_ptr, 1));
398 
399           dirs_locked.count = dirs_locked.count + 1;
400 (subscriptrange):
401           dirs_locked.seg_ptr (dirs_locked.count) = dp;
402           revert subscriptrange;
403 
404           dirs_locked.uid (dirs_locked.count) = uid;
405 unlock_return:
406           call syserr (SYSERR_LOG_OR_PRINT, "verify_lock: Unlocking dir ^w. Locked for ^[read^]^[write^]^[, salvage^].",
407                uid, ^write_sw, write_sw, salvage_sw);
408           unlock_occurred = "1"b;
409 
410           call lock$dir_unlock_given_uid (uid);             /* we may be one of many readers */
411 
412      end VERIFY_DIR;
413 
414 SALVAGE_DIRECTORIES:
415      procedure;
416 
417 declare   dirx                fixed bin;
418 declare   uid                 bit (36) aligned;
419 
420           if dirs_locked.count = 0
421           then return;
422 
423           do dirx = 1 to dirs_locked.count;
424                call lock$dir_lock_salvage (dirs_locked.seg_ptr (dirx), uid, (0));
425                                                             /* get unique lock */
426 
427                call syserr (SYSERR_LOG_OR_PRINT, "verify_lock: Salvaging dir ^p ^w on crawlout.", dp, uid);
428 
429                call condition_ ("any_other", salvager_handler);
430 
431                code = 0;
432 
433                call on_line_salvager (dirs_locked.seg_ptr (dirx), code);
434 
435                call reversion_ ("any_other");
436 
437 
438                if code = error_table_$salv_pdir_procterm
439                then call syserr$error_code (SYSERR_TERMINATE_PROCESS, code, "Terminating user process ^a: ",
440                          pds$process_group_id);
441 
442 CONTINUE_VERIFY_LOCK:
443                call lock$dir_unlock_given_uid (uid);        /* unlock it even if it isn't a real dir */
444           end;
445           return;
446 
447 salvager_handler:
448      procedure (mc_ptr, condition_name, wc_ptr, info_ptr, continue_flag);
449 
450 declare   (mc_ptr, wc_ptr, info_ptr)
451                               pointer;
452 declare   condition_name      character (*);
453 declare   continue_flag       bit (1) aligned;
454 
455 
456           call syserr (SYSERR_PRINT_ON_CONSOLE, "verify_lock: ^a condition by ^a while salvaging directory.",
457                condition_name, pds$process_group_id);
458 
459           if mc_ptr ^= null
460           then call make_syserr_message (condition_name, mc_ptr);
461 
462           go to CONTINUE_VERIFY_LOCK;                       /* unwind stack, running cleanup handlers */
463                                                             /* in salvager subsystem */
464      end salvager_handler;
465 
466      end SALVAGE_DIRECTORIES;
467 %page;
468 VERIFY_PVT_LOCKS:
469      procedure;
470 
471           pvt_arrayp = addr (pvt$array);
472           do pvtx = 1 to pvt$n_entries;
473 
474                pvtep = addr (pvt_array (pvtx));
475 
476                if pvte.vtoc_map_lock = pds$processid
477                then do;
478                          call vtoce_stock_man$force_unlock (pvtep);
479                          call syserr (SYSERR_LOG_OR_PRINT,
480                               "verify_lock: Force unlocked VTOC Map lock (^a_^a^[^a^;^s^]) on crawlout for ^a", pvte.devname,
481                               convert (p99, pvte.logical_area_number), pvte.is_sv, pvte.sv_name, pds$process_group_id);
482                          pvte.vol_trouble_count = pvte.vol_trouble_count + 1;
483                          tsdw = 0;
484                          unlock_occurred = "1"b;
485                          call pmut$swap_sdw (addr (volmap_abs_seg$), addr (tsdw));
486                     end;
487 
488                if pvte.volmap_lock = pds$processid
489                then do;
490                          call pmut$swap_sdw (addr (volmap_abs_seg$), addr (pvte.volmap_seg_sdw));
491                          record_stockp = pvte.volmap_stock_ptr;
492                          do pagex = 0 to record_stock.n_volmap_pages;
493                               call page$write_volmap_page_unwired (pvtep, pagex);
494                          end;
495                          call page$unlock_volmap (pvtep);
496                          call syserr (SYSERR_LOG_OR_PRINT,
497                               "verify_lock: Force unlocked Volmap lock (^a_^a^[^a^;^s^]) on crawlout for ^a", pvte.devname,
498                               convert (p99, pvte.logical_area_number), pvte.is_sv, pvte.sv_name, pds$process_group_id);
499                          tsdw = 0;
500                          unlock_occurred = "1"b;
501                          call pmut$swap_sdw (addr (volmap_abs_seg$), addr (tsdw));
502                     end;
503 
504           end;
505 
506      end VERIFY_PVT_LOCKS;
507 %page;
508 VERIFY_SEARCH_RULES:
509      proc;
510 
511           if tc_data$system_shutdown
512           then return;
513           lock_ptr = addr (ahd$search_rules_lock);
514           if lock.pid = pds$processid
515           then do;
516                     call NOTE_UNLOCK ("search rules");
517                     call lock$unlock_fast (lock_ptr);
518                end;
519           else call CHECK_NOTIFY (lock_ptr);
520      end VERIFY_SEARCH_RULES;
521 
522 
523 
524 VERIFY_MASKED:
525      procedure;
526 
527 declare   mask                fixed bin (71);
528 
529           call pmut$read_mask (mask);
530           if mask = scs$sys_level
531           then call syserr (SYSERR_CRASH_SYSTEM, "verify_lock: Crawlout while masked.");
532 
533           return;
534      end VERIFY_MASKED;
535 
536 
537 CHECK_NOTIFY:
538      proc (a_lock_ptr);
539 
540 dcl       a_lock_ptr          ptr;
541 
542           lock_ptr = a_lock_ptr;
543           if lock.pid = (36)"0"b & lock.flags.notify_sw = "1"b
544           then call pxss$notify (lock.event);
545           return;
546      end CHECK_NOTIFY;
547 
548 
549 NOTE_UNLOCK:
550      procedure (What_did_we_unlock);
551 
552 declare   What_did_we_unlock  char (*);
553 
554           call syserr (SYSERR_LOG_OR_PRINT, "verify_lock: Unlocked ^a.", What_did_we_unlock);
555           unlock_occurred = "1"b;
556      end NOTE_UNLOCK;
557 
558 
559 GET_SEG_PTR:
560      proc (uid) returns (ptr);
561 
562 dcl       uid                 bit (36) aligned;
563 dcl       segptr              ptr;
564 
565           call kstsrch (uid, (0), kstep);
566           if kstep ^= null
567           then segptr = baseptr (kstep -> kste.segno);
568           else segptr = null;
569           return (segptr);
570      end GET_SEG_PTR;
571 
572 
573 make_syserr_message:
574      procedure (cond_name, mcptr);
575 
576 dcl       cond_name           character (*);
577 dcl       mcptr               pointer;
578 dcl       1 auto_fault_msg    aligned like fault_msg;       /* Machine conditions and history for syserr logging */
579 dcl       ssptr               pointer;                      /* pointer to signaller stack frame */
580 
581           ssptr = addrel (mcptr, -8);                       /* signaller_stack.pad is 8 words long! */
582                                                             /* Construct contiguous machine conditions and history registers */
583           unspec (auto_fault_msg.mach_cond) = unspec (ssptr -> signaller_stack.mach_cond);
584           auto_fault_msg.hist_reg = ssptr -> signaller_stack.history_registers;
585           call syserr$binary (SYSERR_LOG_OR_PRINT, addr (auto_fault_msg), SB_verify_lock, SBL_verify_lock,
586                "verify_lock: ^a condition by ^a", cond_name, pds$process_group_id);
587                                                             /* Save machine cond (and history) if known */
588 
589      end make_syserr_message;
590 
591 /* format: off */
592 
593 %page; %include dir_header;
594 %page; %include dir_lock_seg_;
595 %page; %include kst;
596 %page; %include pvte;
597 %page; %include signaller_stack;
598 %page; %include stock_seg;
599 %page; %include syserr_binary_def;
600 %page; %include syserr_constants;
601 %page; %include syserr_fault_msg;
602 %page; %include mc;
603 %page; %include vtoc_buffer;
604 
605 /* BEGIN MESSAGE DOCUMENTATION
606 
607    Message:
608    verify_lock: Crawlout stop specified on PARM card.
609 
610    S:     $crash
611 
612    T:     $run
613 
614    M:     The system PARM card specified the CRWL parameter.
615    A process is attempting to crawl out.
616    This message will occur so that system programmers can take a dump.
617 
618    A:     Take a dump.
619    Issuing the BCE go command
620    will cause the system to continue.
621 
622    Message:
623    verify_lock: Crawlout with AST lock set.
624 
625    S:     $crash
626 
627    T:     $run
628 
629    M:     A user process encountered
630    a condition while processing with the AST locked.
631    This condition may have been due to a
632    hardware or software failure.
633    $crashes
634 
635    A:     $recover
636 
637    Message:
638    verify_lock: Crawlout error on directory cleanup.
639 
640    S:     $crash
641 
642    T:     $run
643 
644    M:     A process encountered a signalled condition
645    with one or more directories locked.
646    Before the system causes a crawlout,
647    it unlocks and salvages
648    all locked directories for the process.
649    This process of cleanup encountered an unrecoverable error.
650    $crashes
651 
652    A:     $recover
653 
654    Message:
655    verify_lock: block_lock_count XX, should be 0
656 
657    S:     $crash
658 
659    T:     $run
660 
661    M:     A process has encountered
662    a condition in ring 0,
663    and is in the process of attempting a crawlout.
664    The system must unlock all locks
665    before it performs the crawlout;
666    all known locks have been unlocked
667    but the process' lock counter is still nonzero.
668    $err
669    $crashes
670 
671    A:     $recover
672 
673    Message:
674    verify_lock: NAME condition by PERS.PROJ
675 
676    S:     $log
677 
678    T:     $run
679 
680    M:     User PERS.PROJ encountered a NAME condition in ring 0.
681    The system attempts to unlock and reset all ring 0 data bases
682    locked by the process.
683 
684    A:     These messages almost always indicate benign errors in
685    the supervisor. They should be reported, nonetheless. They are
686    accompanied by the binary machine condition information.
687    This message is logged only when the condition occured while
688    some ring-0 lock was set.  One or more messages preceeding
689    this one will indicate which locks were held by the process
690    and forcibly reset.
691 
692    Message:
693    verify_lock: Crawlout while in directory salvager, dir (UID,PTR).
694 
695    S:     $log
696 
697    T:     $run
698 
699    M:     A process faulted while salvaging a dir on crawlout.
700 
701    A:     $ignore
702 
703    Message:
704    verify_lock: dir.modify PPPP WWWW ^^= processid.
705 
706    S:     $crash
707 
708    T:     $run
709 
710    M:     A process is attempting to crawl out.
711    The system has discovered that a directory
712    which is marked locked to the process
713    has its "modify" field
714    not equal to the processid of the process.
715    $err
716    $crashes
717 
718    A:     $recover
719 
720    Message:
721    verify_lock: more than N directory locks locked to process.
722 
723    S:     $crash
724 
725    T:     $run
726 
727    M:     The process held more dir locks than verify lock
728    could store for later salvaging. This indicates a logic error
729    in the supervisor.
730 
731    A:    $crashes
732    $recover
733 
734    Message:
735    verify_lock: Unlocking dir UUUUUUUUUUUU. Locked for READ_OR_WRITE {,salvage}.
736 
737    S:     $log
738 
739    T:     $run
740 
741    M:     The directory with UID UUUUUUUUUUUU was found locked at crawl-out
742    time. It is salvaged and then unlocked.
743 
744    A:     $inform
745 
746    Message:
747    verify_lock: Salvaging dir PTR UID on crawlout.
748 
749    S:     $log
750 
751    T:     $run
752 
753    M:     This message is displayed for each directory found locked on a
754    crawlout.  The online salvager will be called and the directory unlocked.
755 
756    A:     $ignore
757 
758    Message:
759    Terminating user process NAME: Fatal salvaging of process directory.
760 
761    S:     $term
762 
763    T:     $run
764 
765    M:     A process is attempting to crawl out. The system discovered that
766    the process was interrupted while its process directory was locked, and has
767    salvaged the process directory. Salvaging the process directory may delete
768    critical process segments and cause the process to terminate, so the process
769    is terminated cleanly instead.
770 
771    A:     $ignore
772 
773    Message:
774    verify_lock: COND condition by USER while salvaging directory.
775 
776    S:     $announce
777 
778    T:     $salvt
779 
780    M:     A fault occurred while salvaging a directory found locked at
781    crawlout. This indicates a serious problem with the directory.
782 
783    A:     $inform
784 
785    Message:
786    verify_lock: Force unlocked VTOC Map lock (dskX_NN) on crawlout for PERSON.PROJECT.TAG
787 
788    S:     $log
789 
790    T:     $run
791 
792    M:     The VTOC Map lock for the device indicated was found locked to the
793    process on crawlout. The lock has been reset, and the count of volume
794    inconsistencies has been incremented by one.
795 
796    A:     Any free records or VTOCEs lost because of the crawlout can be
797    recovered by a volume salvage.
798 
799    Message:
800    verify_lock: Force unlocked Volmap lock (dskX_NN) on crawlout for PERSON.PROJECT.TAG
801 
802    S:     $log
803 
804    T:     $run
805 
806    M:     The Volmap Lock for the device indicated was found locked to a
807    process on crawlout. The lock has been reset, and the count of volume
808    inconsistencies for the device has been incremented by one.
809 
810    A:     Any free records or VTOCEs lost because of the crawlout can
811    be recovered by a volume salvage.
812 
813    Message:
814    verify_lock: Crawlout while masked.
815 
816    S:     $crash
817 
818    T:     $run
819 
820    M:     $crashes
821 
822    A:     $inform
823 
824    Message:
825    verify_lock: Unlocked LOCK.
826 
827    S:     $log
828 
829    T:     $run
830 
831    M:     The lock LOCK was found locked at crawlout and unlocked.
832 
833    A:     $ignore
834 
835    END MESSAGE DOCUMENTATION */
836 
837      end verify_lock;