third_party/sqlite/src/tool/showwal.c

   1 /*
   2 ** A utility for printing content from a write-ahead log file.
   3 */
   4 #include <stdio.h>
   5 #include <ctype.h>
   6 #include <sys/types.h>
   7 #include <sys/stat.h>
   8 #include <fcntl.h>
   9 #include <unistd.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12
  13
  14 static int pagesize = 1024;     /* Size of a database page */
  15 static int fd = -1;             /* File descriptor for reading the WAL file */
  16 static int mxFrame = 0;         /* Last frame */
  17 static int perLine = 16;        /* HEX elements to print per line */
  18
  19 typedef long long int i64;      /* Datatype for 64-bit integers */
  20
  21
  22 /*
  23 ** Convert the var-int format into i64.  Return the number of bytes
  24 ** in the var-int.  Write the var-int value into *pVal.
  25 */
  26 static int decodeVarint(const unsigned char *z, i64 *pVal){
  27   i64 v = 0;
  28   int i;
  29   for(i=0; i<8; i++){
  30     v = (v<<7) + (z[i]&0x7f);
  31     if( (z[i]&0x80)==0 ){ *pVal = v; return i+1; }
  32   }
  33   v = (v<<8) + (z[i]&0xff);
  34   *pVal = v;
  35   return 9;
  36 }
  37
  38 /* Report an out-of-memory error and die.
  39 */
  40 static void out_of_memory(void){
  41   fprintf(stderr,"Out of memory...\n");
  42   exit(1);
  43 }
  44
  45 /*
  46 ** Read content from the file.
  47 **
  48 ** Space to hold the content is obtained from malloc() and needs to be
  49 ** freed by the caller.
  50 */
  51 static unsigned char *getContent(int ofst, int nByte){
  52   unsigned char *aData;
  53   aData = malloc(nByte);
  54   if( aData==0 ) out_of_memory();
  55   lseek(fd, ofst, SEEK_SET);
  56   read(fd, aData, nByte);
  57   return aData;
  58 }
  59
  60 /*
  61 ** Print a range of bytes as hex and as ascii.
  62 */
  63 static void print_byte_range(
  64   int ofst,              /* First byte in the range of bytes to print */
  65   int nByte,             /* Number of bytes to print */
  66   unsigned char *aData,  /* Content to print */
  67   int printOfst          /* Add this amount to the index on the left column */
  68 ){
  69   int i, j;
  70   const char *zOfstFmt;
  71
  72   if( ((printOfst+nByte)&~0xfff)==0 ){
  73     zOfstFmt = " %03x: ";
  74   }else if( ((printOfst+nByte)&~0xffff)==0 ){
  75     zOfstFmt = " %04x: ";
  76   }else if( ((printOfst+nByte)&~0xfffff)==0 ){
  77     zOfstFmt = " %05x: ";
  78   }else if( ((printOfst+nByte)&~0xffffff)==0 ){
  79     zOfstFmt = " %06x: ";
  80   }else{
  81     zOfstFmt = " %08x: ";
  82   }
  83
  84   for(i=0; i<nByte; i += perLine){
  85     fprintf(stdout, zOfstFmt, i+printOfst);
  86     for(j=0; j<perLine; j++){
  87       if( i+j>nByte ){
  88         fprintf(stdout, "   ");
  89       }else{
  90         fprintf(stdout,"%02x ", aData[i+j]);
  91       }
  92     }
  93     for(j=0; j<perLine; j++){
  94       if( i+j>nByte ){
  95         fprintf(stdout, " ");
  96       }else{
  97         fprintf(stdout,"%c", isprint(aData[i+j]) ? aData[i+j] : '.');
  98       }
  99     }
 100     fprintf(stdout,"\n");
 101   }
 102 }
 103
 104 /* Print a line of decode output showing a 4-byte integer.
 105 */
 106 static void print_decode_line(
 107   unsigned char *aData,      /* Content being decoded */
 108   int ofst, int nByte,       /* Start and size of decode */
 109   int asHex,                 /* If true, output value as hex */
 110   const char *zMsg           /* Message to append */
 111 ){
 112   int i, j;
 113   int val = aData[ofst];
 114   char zBuf[100];
 115   sprintf(zBuf, " %03x: %02x", ofst, aData[ofst]);
 116   i = strlen(zBuf);
 117   for(j=1; j<4; j++){
 118     if( j>=nByte ){
 119       sprintf(&zBuf[i], "   ");
 120     }else{
 121       sprintf(&zBuf[i], " %02x", aData[ofst+j]);
 122       val = val*256 + aData[ofst+j];
 123     }
 124     i += strlen(&zBuf[i]);
 125   }
 126   if( asHex ){
 127     sprintf(&zBuf[i], "  0x%08x", val);
 128   }else{
 129     sprintf(&zBuf[i], "   %9d", val);
 130   }
 131   printf("%s  %s\n", zBuf, zMsg);
 132 }
 133
 134 /*
 135 ** Print an entire page of content as hex
 136 */
 137 static void print_frame(int iFrame){
 138   int iStart;
 139   unsigned char *aData;
 140   iStart = 32 + (iFrame-1)*(pagesize+24);
 141   fprintf(stdout, "Frame %d:   (offsets 0x%x..0x%x)\n",
 142           iFrame, iStart, iStart+pagesize+24);
 143   aData = getContent(iStart, pagesize+24);
 144   print_decode_line(aData, 0, 4, 0, "Page number");
 145   print_decode_line(aData, 4, 4, 0, "DB size, or 0 for non-commit");
 146   print_decode_line(aData, 8, 4, 1, "Salt-1");
 147   print_decode_line(aData,12, 4, 1, "Salt-2");
 148   print_decode_line(aData,16, 4, 1, "Checksum-1");
 149   print_decode_line(aData,20, 4, 1, "Checksum-2");
 150   print_byte_range(iStart+24, pagesize, aData+24, 0);
 151   free(aData);
 152 }
 153
 154 /*
 155 ** extract a 32-bit big-endian integer
 156 */
 157 static unsigned int getInt32(const unsigned char *a){
 158   unsigned int x = (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3];
 159   return x;
 160 }
 161
 162 /*
 163 ** Print an entire page of content as hex
 164 */
 165 static void print_oneline_frame(int iFrame){
 166   int iStart;
 167   unsigned char *aData;
 168   iStart = 32 + (iFrame-1)*(pagesize+24);
 169   aData = getContent(iStart, 24);
 170   fprintf(stdout, "Frame %4d: %6d %6d 0x%08x 0x%08x 0x%08x 0x%08x\n",
 171           iFrame,
 172           getInt32(aData),
 173           getInt32(aData+4),
 174           getInt32(aData+8),
 175           getInt32(aData+12),
 176           getInt32(aData+16),
 177           getInt32(aData+20)
 178   );
 179   free(aData);
 180 }
 181
 182 /*
 183 ** Decode the WAL header.
 184 */
 185 static void print_wal_header(void){
 186   unsigned char *aData;
 187   aData = getContent(0, 32);
 188   printf("WAL Header:\n");
 189   print_decode_line(aData, 0, 4,1,"Magic.  0x377f0682 (le) or 0x377f0683 (be)");
 190   print_decode_line(aData, 4, 4, 0, "File format");
 191   print_decode_line(aData, 8, 4, 0, "Database page size");
 192   print_decode_line(aData, 12,4, 0, "Checkpoint sequence number");
 193   print_decode_line(aData, 16,4, 1, "Salt-1");
 194   print_decode_line(aData, 20,4, 1, "Salt-2");
 195   print_decode_line(aData, 24,4, 1, "Checksum-1");
 196   print_decode_line(aData, 28,4, 1, "Checksum-2");
 197   free(aData);
 198 }
 199
 200 /*
 201 ** Create a description for a single cell.
 202 */
 203 static int describeCell(unsigned char cType, unsigned char *a, char **pzDesc){
 204   int i;
 205   int nDesc = 0;
 206   int n = 0;
 207   int leftChild;
 208   i64 nPayload;
 209   i64 rowid;
 210   static char zDesc[100];
 211   i = 0;
 212   if( cType<=5 ){
 213     leftChild = ((a[0]*256 + a[1])*256 + a[2])*256 + a[3];
 214     a += 4;
 215     n += 4;
 216     sprintf(zDesc, "left-child: %d ", leftChild);
 217     nDesc = strlen(zDesc);
 218   }
 219   if( cType!=5 ){
 220     i = decodeVarint(a, &nPayload);
 221     a += i;
 222     n += i;
 223     sprintf(&zDesc[nDesc], "sz: %lld ", nPayload);
 224     nDesc += strlen(&zDesc[nDesc]);
 225   }
 226   if( cType==5 || cType==13 ){
 227     i = decodeVarint(a, &rowid);
 228     a += i;
 229     n += i;
 230     sprintf(&zDesc[nDesc], "rowid: %lld ", rowid);
 231     nDesc += strlen(&zDesc[nDesc]);
 232   }
 233   *pzDesc = zDesc;
 234   return n;
 235 }
 236
 237 /*
 238 ** Decode a btree page
 239 */
 240 static void decode_btree_page(unsigned char *a, int pgno, int hdrSize){
 241   const char *zType = "unknown";
 242   int nCell;
 243   int i;
 244   int iCellPtr;
 245   switch( a[0] ){
 246     case 2:  zType = "index interior node";  break;
 247     case 5:  zType = "table interior node";  break;
 248     case 10: zType = "index leaf";           break;
 249     case 13: zType = "table leaf";           break;
 250   }
 251   printf("Decode of btree page %d:\n", pgno);
 252   print_decode_line(a, 0, 1, 0, zType);
 253   print_decode_line(a, 1, 2, 0, "Offset to first freeblock");
 254   print_decode_line(a, 3, 2, 0, "Number of cells on this page");
 255   nCell = a[3]*256 + a[4];
 256   print_decode_line(a, 5, 2, 0, "Offset to cell content area");
 257   print_decode_line(a, 7, 1, 0, "Fragmented byte count");
 258   if( a[0]==2 || a[0]==5 ){
 259     print_decode_line(a, 8, 4, 0, "Right child");
 260     iCellPtr = 12;
 261   }else{
 262     iCellPtr = 8;
 263   }
 264   for(i=0; i<nCell; i++){
 265     int cofst = iCellPtr + i*2;
 266     char *zDesc;
 267     cofst = a[cofst]*256 + a[cofst+1];
 268     describeCell(a[0], &a[cofst-hdrSize], &zDesc);
 269     printf(" %03x: cell[%d] %s\n", cofst, i, zDesc);
 270   }
 271 }
 272
 273 int main(int argc, char **argv){
 274   struct stat sbuf;
 275   unsigned char zPgSz[2];
 276   if( argc<2 ){
 277     fprintf(stderr,"Usage: %s FILENAME ?PAGE? ...\n", argv[0]);
 278     exit(1);
 279   }
 280   fd = open(argv[1], O_RDONLY);
 281   if( fd<0 ){
 282     fprintf(stderr,"%s: can't open %s\n", argv[0], argv[1]);
 283     exit(1);
 284   }
 285   zPgSz[0] = 0;
 286   zPgSz[1] = 0;
 287   lseek(fd, 10, SEEK_SET);
 288   read(fd, zPgSz, 2);
 289   pagesize = zPgSz[0]*256 + zPgSz[1];
 290   if( pagesize==0 ) pagesize = 1024;
 291   printf("Pagesize: %d\n", pagesize);
 292   fstat(fd, &sbuf);
 293   if( sbuf.st_size<32 ){
 294     printf("file too small to be a WAL\n");
 295     return 0;
 296   }
 297   mxFrame = (sbuf.st_size - 32)/(pagesize + 24);
 298   printf("Available pages: 1..%d\n", mxFrame);
 299   if( argc==2 ){
 300     int i;
 301     print_wal_header();
 302     for(i=1; i<=mxFrame; i++) print_oneline_frame(i);
 303   }else{
 304     int i;
 305     for(i=2; i<argc; i++){
 306       int iStart, iEnd;
 307       char *zLeft;
 308       if( strcmp(argv[i], "header")==0 ){
 309         print_wal_header();
 310         continue;
 311       }
 312       if( !isdigit(argv[i][0]) ){
 313         fprintf(stderr, "%s: unknown option: [%s]\n", argv[0], argv[i]);
 314         continue;
 315       }
 316       iStart = strtol(argv[i], &zLeft, 0);
 317       if( zLeft && strcmp(zLeft,"..end")==0 ){
 318         iEnd = mxFrame;
 319       }else if( zLeft && zLeft[0]=='.' && zLeft[1]=='.' ){
 320         iEnd = strtol(&zLeft[2], 0, 0);
 321 #if 0
 322       }else if( zLeft && zLeft[0]=='b' ){
 323         int ofst, nByte, hdrSize;
 324         unsigned char *a;
 325         if( iStart==1 ){
 326           ofst = hdrSize = 100;
 327           nByte = pagesize-100;
 328         }else{
 329           hdrSize = 0;
 330           ofst = (iStart-1)*pagesize;
 331           nByte = pagesize;
 332         }
 333         a = getContent(ofst, nByte);
 334         decode_btree_page(a, iStart, hdrSize);
 335         free(a);
 336         continue;
 337 #endif
 338       }else{
 339         iEnd = iStart;
 340       }
 341       if( iStart<1 || iEnd<iStart || iEnd>mxFrame ){
 342         fprintf(stderr,
 343           "Page argument should be LOWER?..UPPER?.  Range 1 to %d\n",
 344           mxFrame);
 345         exit(1);
 346       }
 347       while( iStart<=iEnd ){
 348         print_frame(iStart);
 349         iStart++;
 350       }
 351     }
 352   }
 353   close(fd);
 354   return 0;
 355 }