home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 5 / 05.iso / a / a523 / 22.ddi / LOCKTREE.SQL < prev    next >
Encoding:
Text File  |  1989-11-01  |  5.1 KB  |  126 lines
  1. Rem Copyright (c) 1989 by Oracle Corporation
  2. Rem NAME
  3. Rem    locktree.sql
  4. Rem  FUNCTION   - Print out the lock wait-for graph in tree structured fashion.
  5. Rem               This is useful for diagnosing systems that are hung on locks.
  6. Rem  NOTES
  7. Rem  MODIFIED
  8. Rem   Loaiza     11/01/89 - Creation
  9. Rem
  10.  
  11. /* Print out the lock wait-for graph in a tree structured fashion.
  12.  *  
  13.  * This script prints  the  processes in   the system  that  are waiting for
  14.  * locks,  and the locks that they  are waiting for.   The  printout is tree
  15.  * structured.  If a processid is printed immediately below and to the right
  16.  * of another process, then it is waiting for that process.  The process ids
  17.  * printed at the left hand side of the page are  the ones  that everyone is
  18.  * waiting for.
  19.  *  
  20.  * For example, in the following printout process 9 is waiting for
  21.  * process 8, 7 is waiting for 9, and 10 is waiting for 9.
  22.  *  
  23.  * PROCESS WAITING   TYPE MODE REQUESTED    MODE HELD         LOCK ID1 LOCK ID2
  24.  * ----------------- ---- ----------------- ----------------- -------- --------
  25.  * 8                 NONE None              None              0         0
  26.  *    9              TX   Share (S)         Exclusive (X)     65547     16
  27.  *       7           RW   Exclusive (X)     S/Row-X (SSX)     33554440  2
  28.  *       10          RW   Exclusive (X)     S/Row-X (SSX)     33554440  2
  29.  *  
  30.  * The lock information to the right of the process id describes the lock
  31.  * that the process is waiting for (not the lock it is holding).
  32.  *  
  33.  * You must have the blocking.sql script loaded for this script to work.
  34.  *  
  35.  * Note that  this is a  script and not a  set  of view  definitions because
  36.  * connect-by is used in the implementation and therefore  a temporary table
  37.  * is created and dropped since you cannot do a join in a connect-by.
  38.  *  
  39.  * This script has two  small disadvantages.  One, a  table is created  when
  40.  * this  script is run.   To create  a table   a  number of   locks must  be
  41.  * acquired. This  might cause the process running  the script to get caught
  42.  * in the lock problem it is trying to diagnose.  Two, if a process waits on
  43.  * a lock held by more than one process (share lock) then the wait-for graph
  44.  * is no longer a tree  and the  conenct-by will show the process  (and  any
  45.  * processes waiting on it) several times.
  46.  */
  47.  
  48.  
  49. /* Select all pids waiting for a lock, the lock they are waiting on, and the
  50.  * pid of the process that holds the lock.
  51.  *  UNION
  52.  * The pids of all processes holding locks that someone is waiting on that
  53.  * are not themselves waiting for locks. These are included so that the roots
  54.  * of the wait for graph (the processes holding things up) will be displayed.
  55.  *  
  56.  *    pid    - pid of requesting process
  57.  *    type   - type of lock being requested
  58.  *    id1    - id1 of lock being requested (value is lock type specific)
  59.  *    id2    - id2 of lock being requested (value is lock type specific)
  60.  *    req    - mode lock is being requested in
  61.  *    hpid   - pid of process holding the lock
  62.  *    hmod   - mode the lock is held in
  63.  */
  64. create table LOCK_HOLDERS 
  65. (
  66.   pid number(18),
  67.   type char(4),
  68.   id1 char(10),
  69.   id2 char(10),
  70.   req number,
  71.   hpid number,
  72.   hmod number
  73. );
  74.  
  75. insert into lock_holders 
  76. select r.pid, r.type, r.id1, r.id2, r.request req, h.pid hpid, h.lmode hmod
  77.   from all_locks_view h, all_locks_view r
  78.  where  r.request  >  1            /* R is waiting for (requesting) the lock */
  79.   and   h.lmode    >  1                             /* H is holding the lock */
  80.   and   h.type     =  r.type        /* H is holding the lock R is requesting */
  81.   and   h.id1      =  r.id1
  82.   and   h.id2      =  r.id2
  83. union
  84. select unique
  85.        h.pid, 'NONE', '0', '0', 0, -1, 0
  86.   from v$process p, all_locks_view h, all_locks_view r
  87.  where  r.request  >  1            /* R is waiting for (requesting) the lock */
  88.   and   h.lmode    >  1                             /* h is holding the lock */
  89.   and   h.type     =  r.type        /* H is holding the lock R is requesting */
  90.   and   h.id1      =  r.id1
  91.   and   h.id2      =  r.id2
  92.   and   h.pid      =  p.pid                                /* H is process P */
  93.   and   p.lockwait is null                    /* P is not waiting for a lock */
  94.   and   p.latchwait is null;
  95.  
  96. set charwidth 17;
  97.  
  98. /* Print out the result in a tree structured fashion */
  99.  
  100. select lpad(' ',3*(level-1)) || pid "PROCESS WAITING",
  101.        type type, 
  102.        decode( req, 
  103.         0, 'None',           /* Mon Lock equivalent */
  104.                 1, 'Null Mode',      /* N */
  105.         2, 'Row-S (SS)',     /* L */
  106.         3, 'Row-X (SX)',     /* R */
  107.         4, 'Share (S)',      /* S */
  108.         5, 'S/Row-X (SSX)',  /* C */
  109.         6, 'Exclusive (X)',  /* X */
  110.         req) "MODE REQUESTED",
  111.        decode( hmod, 
  112.         0, 'None',           /* Mon Lock equivalent */
  113.                 1, 'Null Mode',      /* N */
  114.         2, 'Row-S (SS)',     /* L */
  115.         3, 'Row-X (SX)',     /* R */
  116.         4, 'Share (S)',      /* S */
  117.         5, 'S/Row-X (SSX)',  /* C */
  118.         6, 'Exclusive (X)',  /* X */
  119.         hmod) "MODE HELD",
  120.        id1 "LOCK ID1", id2 "LOCK ID2"
  121.  from lock_holders
  122. connect by  prior pid = hpid
  123.   start with hpid = -1;
  124.  
  125. drop table lock_holders;
  126.