| OLD | NEW |
|---|
| (Empty) |
| 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 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2363173002:
[sqlite] Remove obsolete reference version 3.8.7.4. (Closed)
