Return to getlock.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / tool

Annotation of embedaddon/sqlite3/tool/getlock.c, revision 1.1.1.1

1.1       misho       1: /*
                      2: ** This utility program looks at an SQLite database and determines whether
                      3: ** or not it is locked, the kind of lock, and who is holding this lock.
                      4: **
                      5: ** This only works on unix when the posix advisory locking method is used
                      6: ** (which is the default on unix) and when the PENDING_BYTE is in its
                      7: ** usual place.
                      8: */
                      9: #include <sys/types.h>
                     10: #include <sys/stat.h>
                     11: #include <unistd.h>
                     12: #include <fcntl.h>
                     13: #include <string.h>
                     14: #include <stdio.h>
                     15: #include <stdlib.h>
                     16: #include <errno.h>
                     17: 
                     18: static void usage(const char *argv0){
                     19:   fprintf(stderr, "Usage: %s database\n", argv0);
                     20:   exit(1);
                     21: }
                     22: 
                     23: /* Check for a conflicting lock.  If one is found, print an this
                     24: ** on standard output using the format string given and return 1.
                     25: ** If there are no conflicting locks, return 0.
                     26: */
                     27: static int isLocked(
                     28:   int h,                /* File descriptor to check */
                     29:   int type,             /* F_RDLCK or F_WRLCK */
                     30:   unsigned int iOfst,   /* First byte of the lock */
                     31:   unsigned int iCnt,    /* Number of bytes in the lock range */
                     32:   const char *zType     /* Type of lock */
                     33: ){
                     34:   struct flock lk;
                     35: 
                     36:   memset(&lk, 0, sizeof(lk));
                     37:   lk.l_type = type;
                     38:   lk.l_whence = SEEK_SET;
                     39:   lk.l_start = iOfst;
                     40:   lk.l_len = iCnt;
                     41:   if( fcntl(h, F_GETLK, &lk)==(-1) ){
                     42:     fprintf(stderr, "fcntl(%d) failed: errno=%d\n", h, errno);
                     43:     exit(1);
                     44:   }
                     45:   if( lk.l_type==F_UNLCK ) return 0;
                     46:   printf("%s lock held by %d\n", zType, (int)lk.l_pid);
                     47:   return 1;
                     48: }
                     49: 
                     50: /*
                     51: ** Location of locking bytes in the database file
                     52: */
                     53: #define PENDING_BYTE      (0x40000000)
                     54: #define RESERVED_BYTE     (PENDING_BYTE+1)
                     55: #define SHARED_FIRST      (PENDING_BYTE+2)
                     56: #define SHARED_SIZE       510
                     57: 
                     58: /*
                     59: ** Lock locations for shared-memory locks used by WAL mode.
                     60: */
                     61: #define SHM_BASE          120
                     62: #define SHM_WRITE         SHM_BASE
                     63: #define SHM_CHECKPOINT    (SHM_BASE+1)
                     64: #define SHM_RECOVER       (SHM_BASE+2)
                     65: #define SHM_READ_FIRST    (SHM_BASE+3)
                     66: #define SHM_READ_SIZE     5
                     67: 
                     68: 
                     69: int main(int argc, char **argv){
                     70:   int hDb;        /* File descriptor for the open database file */
                     71:   int hShm;       /* File descriptor for WAL shared-memory file */
                     72:   char *zShm;     /* Name of the shared-memory file for WAL mode */
                     73:   ssize_t got;    /* Bytes read from header */
                     74:   int isWal;                 /* True if in WAL mode */
                     75:   int nName;                 /* Length of filename */
                     76:   unsigned char aHdr[100];   /* Database header */
                     77:   int nLock = 0;             /* Number of locks held */
                     78:   int i;                     /* Loop counter */
                     79: 
                     80:   if( argc!=2 ) usage(argv[0]);
                     81:   hDb = open(argv[1], O_RDONLY, 0);
                     82:   if( hDb<0 ){
                     83:     fprintf(stderr, "cannot open %s\n", argv[1]);
                     84:     return 1;
                     85:   }
                     86: 
                     87:   /* Make sure we are dealing with an database file */
                     88:   got = read(hDb, aHdr, 100);
                     89:   if( got!=100 || memcmp(aHdr, "SQLite format 3",16)!=0 ){
                     90:     fprintf(stderr, "not an SQLite database: %s\n", argv[1]);
                     91:     exit(1);
                     92:   }
                     93: 
                     94:   /* First check for an exclusive lock */
                     95:   if( isLocked(hDb, F_RDLCK, SHARED_FIRST, SHARED_SIZE, "EXCLUSIVE") ){
                     96:     return 0;
                     97:   }
                     98:   isWal = aHdr[18]==2;
                     99:   if( isWal==0 ){
                    100:     /* Rollback mode */
                    101:     if( isLocked(hDb, F_RDLCK, PENDING_BYTE, 1, "PENDING") ) return 0;
                    102:     if( isLocked(hDb, F_RDLCK, RESERVED_BYTE, 1, "RESERVED") ) return 0;
                    103:     if( isLocked(hDb, F_WRLCK, SHARED_FIRST, SHARED_SIZE, "SHARED") ){
                    104:       return 0;
                    105:     }
                    106:   }else{
                    107:     /* WAL mode */
                    108:     nName = (int)strlen(argv[1]);
                    109:     zShm = malloc( nName + 100 );
                    110:     if( zShm==0 ){
                    111:       fprintf(stderr, "out of memory\n");
                    112:       exit(1);
                    113:     }
                    114:     memcpy(zShm, argv[1], nName);
                    115:     memcpy(&zShm[nName], "-shm", 5);
                    116:     hShm = open(zShm, O_RDONLY, 0);
                    117:     if( hShm<0 ){
                    118:       fprintf(stderr, "cannot open %s\n", zShm);
                    119:       return 1;
                    120:     }
                    121:     if( isLocked(hShm, F_RDLCK, SHM_RECOVER, 1, "WAL-RECOVERY") ){
                    122:       return 0;
                    123:     }
                    124:     nLock += isLocked(hShm, F_RDLCK, SHM_CHECKPOINT, 1, "WAL-CHECKPOINT");
                    125:     nLock += isLocked(hShm, F_RDLCK, SHM_WRITE, 1, "WAL-WRITE");
                    126:     for(i=0; i<SHM_READ_SIZE; i++){
                    127:       nLock += isLocked(hShm, F_WRLCK, SHM_READ_FIRST+i, 1, "WAL-READ");
                    128:     }
                    129:   }
                    130:   if( nLock==0 ){
                    131:     printf("file is not locked\n");
                    132:   }
                    133:   return 0;
                    134: }