| Index: third_party/sqlite/sqlite-src-3080704/tool/showwal.c
|
| diff --git a/third_party/sqlite/sqlite-src-3080704/tool/showwal.c b/third_party/sqlite/sqlite-src-3080704/tool/showwal.c
|
| deleted file mode 100644
|
| index 35810c66a96ff875612068bf179995f43279ff77..0000000000000000000000000000000000000000
|
| --- a/third_party/sqlite/sqlite-src-3080704/tool/showwal.c
|
| +++ /dev/null
|
| @@ -1,596 +0,0 @@
|
| -/*
|
| -** A utility for printing content from a write-ahead log file.
|
| -*/
|
| -#include <stdio.h>
|
| -#include <ctype.h>
|
| -#include <sys/types.h>
|
| -#include <sys/stat.h>
|
| -#include <fcntl.h>
|
| -
|
| -#if !defined(_MSC_VER)
|
| -#include <unistd.h>
|
| -#else
|
| -#include <io.h>
|
| -#endif
|
| -
|
| -#include <stdlib.h>
|
| -#include <string.h>
|
| -
|
| -
|
| -static int pagesize = 1024; /* Size of a database page */
|
| -static int fd = -1; /* File descriptor for reading the WAL file */
|
| -static int mxFrame = 0; /* Last frame */
|
| -static int perLine = 16; /* HEX elements to print per line */
|
| -
|
| -typedef long long int i64; /* Datatype for 64-bit integers */
|
| -
|
| -/* Information for computing the checksum */
|
| -typedef struct Cksum Cksum;
|
| -struct Cksum {
|
| - int bSwap; /* True to do byte swapping on 32-bit words */
|
| - unsigned s0, s1; /* Current checksum value */
|
| -};
|
| -
|
| -/*
|
| -** extract a 32-bit big-endian integer
|
| -*/
|
| -static unsigned int getInt32(const unsigned char *a){
|
| - unsigned int x = (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3];
|
| - return x;
|
| -}
|
| -
|
| -/*
|
| -** Swap bytes on a 32-bit unsigned integer
|
| -*/
|
| -static unsigned int swab32(unsigned int x){
|
| - return (((x)&0x000000FF)<<24) + (((x)&0x0000FF00)<<8)
|
| - + (((x)&0x00FF0000)>>8) + (((x)&0xFF000000)>>24);
|
| -}
|
| -
|
| -/* Extend the checksum. Reinitialize the checksum if bInit is true.
|
| -*/
|
| -static void extendCksum(
|
| - Cksum *pCksum,
|
| - unsigned char *aData,
|
| - unsigned int nByte,
|
| - int bInit
|
| -){
|
| - unsigned int *a32;
|
| - if( bInit ){
|
| - int a = 0;
|
| - *((char*)&a) = 1;
|
| - if( a==1 ){
|
| - /* Host is little-endian */
|
| - pCksum->bSwap = getInt32(aData)!=0x377f0682;
|
| - }else{
|
| - /* Host is big-endian */
|
| - pCksum->bSwap = getInt32(aData)!=0x377f0683;
|
| - }
|
| - pCksum->s0 = 0;
|
| - pCksum->s1 = 0;
|
| - }
|
| - a32 = (unsigned int*)aData;
|
| - while( nByte>0 ){
|
| - unsigned int x0 = a32[0];
|
| - unsigned int x1 = a32[1];
|
| - if( pCksum->bSwap ){
|
| - x0 = swab32(x0);
|
| - x1 = swab32(x1);
|
| - }
|
| - pCksum->s0 += x0 + pCksum->s1;
|
| - pCksum->s1 += x1 + pCksum->s0;
|
| - nByte -= 8;
|
| - a32 += 2;
|
| - }
|
| -}
|
| -
|
| -/*
|
| -** Convert the var-int format into i64. Return the number of bytes
|
| -** in the var-int. Write the var-int value into *pVal.
|
| -*/
|
| -static int decodeVarint(const unsigned char *z, i64 *pVal){
|
| - i64 v = 0;
|
| - int i;
|
| - for(i=0; i<8; i++){
|
| - v = (v<<7) + (z[i]&0x7f);
|
| - if( (z[i]&0x80)==0 ){ *pVal = v; return i+1; }
|
| - }
|
| - v = (v<<8) + (z[i]&0xff);
|
| - *pVal = v;
|
| - return 9;
|
| -}
|
| -
|
| -/* Report an out-of-memory error and die.
|
| -*/
|
| -static void out_of_memory(void){
|
| - fprintf(stderr,"Out of memory...\n");
|
| - exit(1);
|
| -}
|
| -
|
| -/*
|
| -** Read content from the file.
|
| -**
|
| -** Space to hold the content is obtained from malloc() and needs to be
|
| -** freed by the caller.
|
| -*/
|
| -static unsigned char *getContent(int ofst, int nByte){
|
| - unsigned char *aData;
|
| - aData = malloc(nByte);
|
| - if( aData==0 ) out_of_memory();
|
| - lseek(fd, ofst, SEEK_SET);
|
| - read(fd, aData, nByte);
|
| - return aData;
|
| -}
|
| -
|
| -/*
|
| -** Print a range of bytes as hex and as ascii.
|
| -*/
|
| -static void print_byte_range(
|
| - int ofst, /* First byte in the range of bytes to print */
|
| - int nByte, /* Number of bytes to print */
|
| - unsigned char *aData, /* Content to print */
|
| - int printOfst /* Add this amount to the index on the left column */
|
| -){
|
| - int i, j;
|
| - const char *zOfstFmt;
|
| -
|
| - if( ((printOfst+nByte)&~0xfff)==0 ){
|
| - zOfstFmt = " %03x: ";
|
| - }else if( ((printOfst+nByte)&~0xffff)==0 ){
|
| - zOfstFmt = " %04x: ";
|
| - }else if( ((printOfst+nByte)&~0xfffff)==0 ){
|
| - zOfstFmt = " %05x: ";
|
| - }else if( ((printOfst+nByte)&~0xffffff)==0 ){
|
| - zOfstFmt = " %06x: ";
|
| - }else{
|
| - zOfstFmt = " %08x: ";
|
| - }
|
| -
|
| - for(i=0; i<nByte; i += perLine){
|
| - fprintf(stdout, zOfstFmt, i+printOfst);
|
| - for(j=0; j<perLine; j++){
|
| - if( i+j>nByte ){
|
| - fprintf(stdout, " ");
|
| - }else{
|
| - fprintf(stdout,"%02x ", aData[i+j]);
|
| - }
|
| - }
|
| - for(j=0; j<perLine; j++){
|
| - if( i+j>nByte ){
|
| - fprintf(stdout, " ");
|
| - }else{
|
| - fprintf(stdout,"%c", isprint(aData[i+j]) ? aData[i+j] : '.');
|
| - }
|
| - }
|
| - fprintf(stdout,"\n");
|
| - }
|
| -}
|
| -
|
| -/* Print a line of decode output showing a 4-byte integer.
|
| -*/
|
| -static void print_decode_line(
|
| - unsigned char *aData, /* Content being decoded */
|
| - int ofst, int nByte, /* Start and size of decode */
|
| - int asHex, /* If true, output value as hex */
|
| - const char *zMsg /* Message to append */
|
| -){
|
| - int i, j;
|
| - int val = aData[ofst];
|
| - char zBuf[100];
|
| - sprintf(zBuf, " %03x: %02x", ofst, aData[ofst]);
|
| - i = (int)strlen(zBuf);
|
| - for(j=1; j<4; j++){
|
| - if( j>=nByte ){
|
| - sprintf(&zBuf[i], " ");
|
| - }else{
|
| - sprintf(&zBuf[i], " %02x", aData[ofst+j]);
|
| - val = val*256 + aData[ofst+j];
|
| - }
|
| - i += (int)strlen(&zBuf[i]);
|
| - }
|
| - if( asHex ){
|
| - sprintf(&zBuf[i], " 0x%08x", val);
|
| - }else{
|
| - sprintf(&zBuf[i], " %9d", val);
|
| - }
|
| - printf("%s %s\n", zBuf, zMsg);
|
| -}
|
| -
|
| -/*
|
| -** Print an entire page of content as hex
|
| -*/
|
| -static void print_frame(int iFrame){
|
| - int iStart;
|
| - unsigned char *aData;
|
| - iStart = 32 + (iFrame-1)*(pagesize+24);
|
| - fprintf(stdout, "Frame %d: (offsets 0x%x..0x%x)\n",
|
| - iFrame, iStart, iStart+pagesize+24);
|
| - aData = getContent(iStart, pagesize+24);
|
| - print_decode_line(aData, 0, 4, 0, "Page number");
|
| - print_decode_line(aData, 4, 4, 0, "DB size, or 0 for non-commit");
|
| - print_decode_line(aData, 8, 4, 1, "Salt-1");
|
| - print_decode_line(aData,12, 4, 1, "Salt-2");
|
| - print_decode_line(aData,16, 4, 1, "Checksum-1");
|
| - print_decode_line(aData,20, 4, 1, "Checksum-2");
|
| - print_byte_range(iStart+24, pagesize, aData+24, 0);
|
| - free(aData);
|
| -}
|
| -
|
| -/*
|
| -** Summarize a single frame on a single line.
|
| -*/
|
| -static void print_oneline_frame(int iFrame, Cksum *pCksum){
|
| - int iStart;
|
| - unsigned char *aData;
|
| - unsigned int s0, s1;
|
| - iStart = 32 + (iFrame-1)*(pagesize+24);
|
| - aData = getContent(iStart, 24);
|
| - extendCksum(pCksum, aData, 8, 0);
|
| - extendCksum(pCksum, getContent(iStart+24, pagesize), pagesize, 0);
|
| - s0 = getInt32(aData+16);
|
| - s1 = getInt32(aData+20);
|
| - fprintf(stdout, "Frame %4d: %6d %6d 0x%08x,%08x 0x%08x,%08x %s\n",
|
| - iFrame,
|
| - getInt32(aData),
|
| - getInt32(aData+4),
|
| - getInt32(aData+8),
|
| - getInt32(aData+12),
|
| - s0,
|
| - s1,
|
| - (s0==pCksum->s0 && s1==pCksum->s1) ? "" : "cksum-fail"
|
| - );
|
| -
|
| - /* Reset the checksum so that a single frame checksum failure will not
|
| - ** cause all subsequent frames to also show a failure. */
|
| - pCksum->s0 = s0;
|
| - pCksum->s1 = s1;
|
| - free(aData);
|
| -}
|
| -
|
| -/*
|
| -** Decode the WAL header.
|
| -*/
|
| -static void print_wal_header(Cksum *pCksum){
|
| - unsigned char *aData;
|
| - aData = getContent(0, 32);
|
| - if( pCksum ){
|
| - extendCksum(pCksum, aData, 24, 1);
|
| - printf("Checksum byte order: %s\n", pCksum->bSwap ? "swapped" : "native");
|
| - }
|
| - printf("WAL Header:\n");
|
| - print_decode_line(aData, 0, 4,1,"Magic. 0x377f0682 (le) or 0x377f0683 (be)");
|
| - print_decode_line(aData, 4, 4, 0, "File format");
|
| - print_decode_line(aData, 8, 4, 0, "Database page size");
|
| - print_decode_line(aData, 12,4, 0, "Checkpoint sequence number");
|
| - print_decode_line(aData, 16,4, 1, "Salt-1");
|
| - print_decode_line(aData, 20,4, 1, "Salt-2");
|
| - print_decode_line(aData, 24,4, 1, "Checksum-1");
|
| - print_decode_line(aData, 28,4, 1, "Checksum-2");
|
| - if( pCksum ){
|
| - if( pCksum->s0!=getInt32(aData+24) ){
|
| - printf("**** cksum-1 mismatch: 0x%08x\n", pCksum->s0);
|
| - }
|
| - if( pCksum->s1!=getInt32(aData+28) ){
|
| - printf("**** cksum-2 mismatch: 0x%08x\n", pCksum->s1);
|
| - }
|
| - }
|
| - free(aData);
|
| -}
|
| -/*
|
| -** Describe cell content.
|
| -*/
|
| -static i64 describeContent(
|
| - unsigned char *a, /* Cell content */
|
| - i64 nLocal, /* Bytes in a[] */
|
| - char *zDesc /* Write description here */
|
| -){
|
| - int nDesc = 0;
|
| - int n, j;
|
| - i64 i, x, v;
|
| - const unsigned char *pData;
|
| - const unsigned char *pLimit;
|
| - char sep = ' ';
|
| -
|
| - pLimit = &a[nLocal];
|
| - n = decodeVarint(a, &x);
|
| - pData = &a[x];
|
| - a += n;
|
| - i = x - n;
|
| - while( i>0 && pData<=pLimit ){
|
| - n = decodeVarint(a, &x);
|
| - a += n;
|
| - i -= n;
|
| - nLocal -= n;
|
| - zDesc[0] = sep;
|
| - sep = ',';
|
| - nDesc++;
|
| - zDesc++;
|
| - if( x==0 ){
|
| - sprintf(zDesc, "*"); /* NULL is a "*" */
|
| - }else if( x>=1 && x<=6 ){
|
| - v = (signed char)pData[0];
|
| - pData++;
|
| - switch( x ){
|
| - case 6: v = (v<<16) + (pData[0]<<8) + pData[1]; pData += 2;
|
| - case 5: v = (v<<16) + (pData[0]<<8) + pData[1]; pData += 2;
|
| - case 4: v = (v<<8) + pData[0]; pData++;
|
| - case 3: v = (v<<8) + pData[0]; pData++;
|
| - case 2: v = (v<<8) + pData[0]; pData++;
|
| - }
|
| - sprintf(zDesc, "%lld", v);
|
| - }else if( x==7 ){
|
| - sprintf(zDesc, "real");
|
| - pData += 8;
|
| - }else if( x==8 ){
|
| - sprintf(zDesc, "0");
|
| - }else if( x==9 ){
|
| - sprintf(zDesc, "1");
|
| - }else if( x>=12 ){
|
| - i64 size = (x-12)/2;
|
| - if( (x&1)==0 ){
|
| - sprintf(zDesc, "blob(%lld)", size);
|
| - }else{
|
| - sprintf(zDesc, "txt(%lld)", size);
|
| - }
|
| - pData += size;
|
| - }
|
| - j = (int)strlen(zDesc);
|
| - zDesc += j;
|
| - nDesc += j;
|
| - }
|
| - return nDesc;
|
| -}
|
| -
|
| -/*
|
| -** Compute the local payload size given the total payload size and
|
| -** the page size.
|
| -*/
|
| -static i64 localPayload(i64 nPayload, char cType){
|
| - i64 maxLocal;
|
| - i64 minLocal;
|
| - i64 surplus;
|
| - i64 nLocal;
|
| - if( cType==13 ){
|
| - /* Table leaf */
|
| - maxLocal = pagesize-35;
|
| - minLocal = (pagesize-12)*32/255-23;
|
| - }else{
|
| - maxLocal = (pagesize-12)*64/255-23;
|
| - minLocal = (pagesize-12)*32/255-23;
|
| - }
|
| - if( nPayload>maxLocal ){
|
| - surplus = minLocal + (nPayload-minLocal)%(pagesize-4);
|
| - if( surplus<=maxLocal ){
|
| - nLocal = surplus;
|
| - }else{
|
| - nLocal = minLocal;
|
| - }
|
| - }else{
|
| - nLocal = nPayload;
|
| - }
|
| - return nLocal;
|
| -}
|
| -
|
| -/*
|
| -** Create a description for a single cell.
|
| -**
|
| -** The return value is the local cell size.
|
| -*/
|
| -static i64 describeCell(
|
| - unsigned char cType, /* Page type */
|
| - unsigned char *a, /* Cell content */
|
| - int showCellContent, /* Show cell content if true */
|
| - char **pzDesc /* Store description here */
|
| -){
|
| - int i;
|
| - i64 nDesc = 0;
|
| - int n = 0;
|
| - int leftChild;
|
| - i64 nPayload;
|
| - i64 rowid;
|
| - i64 nLocal;
|
| - static char zDesc[1000];
|
| - i = 0;
|
| - if( cType<=5 ){
|
| - leftChild = ((a[0]*256 + a[1])*256 + a[2])*256 + a[3];
|
| - a += 4;
|
| - n += 4;
|
| - sprintf(zDesc, "lx: %d ", leftChild);
|
| - nDesc = strlen(zDesc);
|
| - }
|
| - if( cType!=5 ){
|
| - i = decodeVarint(a, &nPayload);
|
| - a += i;
|
| - n += i;
|
| - sprintf(&zDesc[nDesc], "n: %lld ", nPayload);
|
| - nDesc += strlen(&zDesc[nDesc]);
|
| - nLocal = localPayload(nPayload, cType);
|
| - }else{
|
| - nPayload = nLocal = 0;
|
| - }
|
| - if( cType==5 || cType==13 ){
|
| - i = decodeVarint(a, &rowid);
|
| - a += i;
|
| - n += i;
|
| - sprintf(&zDesc[nDesc], "r: %lld ", rowid);
|
| - nDesc += strlen(&zDesc[nDesc]);
|
| - }
|
| - if( nLocal<nPayload ){
|
| - int ovfl;
|
| - unsigned char *b = &a[nLocal];
|
| - ovfl = ((b[0]*256 + b[1])*256 + b[2])*256 + b[3];
|
| - sprintf(&zDesc[nDesc], "ov: %d ", ovfl);
|
| - nDesc += strlen(&zDesc[nDesc]);
|
| - n += 4;
|
| - }
|
| - if( showCellContent && cType!=5 ){
|
| - nDesc += describeContent(a, nLocal, &zDesc[nDesc-1]);
|
| - }
|
| - *pzDesc = zDesc;
|
| - return nLocal+n;
|
| -}
|
| -
|
| -/*
|
| -** Decode a btree page
|
| -*/
|
| -static void decode_btree_page(
|
| - unsigned char *a, /* Content of the btree page to be decoded */
|
| - int pgno, /* Page number */
|
| - int hdrSize, /* Size of the page1-header in bytes */
|
| - const char *zArgs /* Flags to control formatting */
|
| -){
|
| - const char *zType = "unknown";
|
| - int nCell;
|
| - int i, j;
|
| - int iCellPtr;
|
| - int showCellContent = 0;
|
| - int showMap = 0;
|
| - char *zMap = 0;
|
| - switch( a[0] ){
|
| - case 2: zType = "index interior node"; break;
|
| - case 5: zType = "table interior node"; break;
|
| - case 10: zType = "index leaf"; break;
|
| - case 13: zType = "table leaf"; break;
|
| - }
|
| - while( zArgs[0] ){
|
| - switch( zArgs[0] ){
|
| - case 'c': showCellContent = 1; break;
|
| - case 'm': showMap = 1; break;
|
| - }
|
| - zArgs++;
|
| - }
|
| - printf("Decode of btree page %d:\n", pgno);
|
| - print_decode_line(a, 0, 1, 0, zType);
|
| - print_decode_line(a, 1, 2, 0, "Offset to first freeblock");
|
| - print_decode_line(a, 3, 2, 0, "Number of cells on this page");
|
| - nCell = a[3]*256 + a[4];
|
| - print_decode_line(a, 5, 2, 0, "Offset to cell content area");
|
| - print_decode_line(a, 7, 1, 0, "Fragmented byte count");
|
| - if( a[0]==2 || a[0]==5 ){
|
| - print_decode_line(a, 8, 4, 0, "Right child");
|
| - iCellPtr = 12;
|
| - }else{
|
| - iCellPtr = 8;
|
| - }
|
| - if( nCell>0 ){
|
| - printf(" key: lx=left-child n=payload-size r=rowid\n");
|
| - }
|
| - if( showMap ){
|
| - zMap = malloc(pagesize);
|
| - memset(zMap, '.', pagesize);
|
| - memset(zMap, '1', hdrSize);
|
| - memset(&zMap[hdrSize], 'H', iCellPtr);
|
| - memset(&zMap[hdrSize+iCellPtr], 'P', 2*nCell);
|
| - }
|
| - for(i=0; i<nCell; i++){
|
| - int cofst = iCellPtr + i*2;
|
| - char *zDesc;
|
| - i64 n;
|
| -
|
| - cofst = a[cofst]*256 + a[cofst+1];
|
| - n = describeCell(a[0], &a[cofst-hdrSize], showCellContent, &zDesc);
|
| - if( showMap ){
|
| - char zBuf[30];
|
| - memset(&zMap[cofst], '*', (size_t)n);
|
| - zMap[cofst] = '[';
|
| - zMap[cofst+n-1] = ']';
|
| - sprintf(zBuf, "%d", i);
|
| - j = (int)strlen(zBuf);
|
| - if( j<=n-2 ) memcpy(&zMap[cofst+1], zBuf, j);
|
| - }
|
| - printf(" %03x: cell[%d] %s\n", cofst, i, zDesc);
|
| - }
|
| - if( showMap ){
|
| - for(i=0; i<pagesize; i+=64){
|
| - printf(" %03x: %.64s\n", i, &zMap[i]);
|
| - }
|
| - free(zMap);
|
| - }
|
| -}
|
| -
|
| -int main(int argc, char **argv){
|
| - struct stat sbuf;
|
| - unsigned char zPgSz[4];
|
| - if( argc<2 ){
|
| - fprintf(stderr,"Usage: %s FILENAME ?PAGE? ...\n", argv[0]);
|
| - exit(1);
|
| - }
|
| - fd = open(argv[1], O_RDONLY);
|
| - if( fd<0 ){
|
| - fprintf(stderr,"%s: can't open %s\n", argv[0], argv[1]);
|
| - exit(1);
|
| - }
|
| - zPgSz[0] = 0;
|
| - zPgSz[1] = 0;
|
| - lseek(fd, 8, SEEK_SET);
|
| - read(fd, zPgSz, 4);
|
| - pagesize = zPgSz[1]*65536 + zPgSz[2]*256 + zPgSz[3];
|
| - if( pagesize==0 ) pagesize = 1024;
|
| - printf("Pagesize: %d\n", pagesize);
|
| - fstat(fd, &sbuf);
|
| - if( sbuf.st_size<32 ){
|
| - printf("file too small to be a WAL\n");
|
| - return 0;
|
| - }
|
| - mxFrame = (sbuf.st_size - 32)/(pagesize + 24);
|
| - printf("Available pages: 1..%d\n", mxFrame);
|
| - if( argc==2 ){
|
| - int i;
|
| - Cksum x;
|
| - print_wal_header(&x);
|
| - for(i=1; i<=mxFrame; i++){
|
| - print_oneline_frame(i, &x);
|
| - }
|
| - }else{
|
| - int i;
|
| - for(i=2; i<argc; i++){
|
| - int iStart, iEnd;
|
| - char *zLeft;
|
| - if( strcmp(argv[i], "header")==0 ){
|
| - print_wal_header(0);
|
| - continue;
|
| - }
|
| - if( !isdigit(argv[i][0]) ){
|
| - fprintf(stderr, "%s: unknown option: [%s]\n", argv[0], argv[i]);
|
| - continue;
|
| - }
|
| - iStart = strtol(argv[i], &zLeft, 0);
|
| - if( zLeft && strcmp(zLeft,"..end")==0 ){
|
| - iEnd = mxFrame;
|
| - }else if( zLeft && zLeft[0]=='.' && zLeft[1]=='.' ){
|
| - iEnd = strtol(&zLeft[2], 0, 0);
|
| - }else if( zLeft && zLeft[0]=='b' ){
|
| - int ofst, nByte, hdrSize;
|
| - unsigned char *a;
|
| - if( iStart==1 ){
|
| - hdrSize = 100;
|
| - ofst = hdrSize = 100;
|
| - nByte = pagesize-100;
|
| - }else{
|
| - hdrSize = 0;
|
| - ofst = (iStart-1)*pagesize;
|
| - nByte = pagesize;
|
| - }
|
| - ofst = 32 + hdrSize + (iStart-1)*(pagesize+24) + 24;
|
| - a = getContent(ofst, nByte);
|
| - decode_btree_page(a, iStart, hdrSize, zLeft+1);
|
| - free(a);
|
| - continue;
|
| - }else{
|
| - iEnd = iStart;
|
| - }
|
| - if( iStart<1 || iEnd<iStart || iEnd>mxFrame ){
|
| - fprintf(stderr,
|
| - "Page argument should be LOWER?..UPPER?. Range 1 to %d\n",
|
| - mxFrame);
|
| - exit(1);
|
| - }
|
| - while( iStart<=iEnd ){
|
| - print_frame(iStart);
|
| - iStart++;
|
| - }
|
| - }
|
| - }
|
| - close(fd);
|
| - return 0;
|
| -}
|
|
|