Addresses #1936 refs[t:1936] Removed log_lsn/disk_lsn from nodes, added...

Addresses #1936 refs[t:1936] Removed log_lsn/disk_lsn from nodes, added original version and version read from disk
Backwards compatibility for version 10 upgraded to support change (read lsns into void, set original/read_from_disk versions to 10 on read)

git-svn-id: file:///svn/toku/tokudb@14457 c7de825b-a66e-492c-adef-691d508d4ae1

newbrt/backwards_10.c

@@ -486,9 +486,81 @@ deserialize_brtheader_10 (int fd, struct rbuf *rb, struct brt_header **brth) {
     return 0;
 }
 
+enum { uncompressed_magic_len_10 = (8 // tokuleaf or tokunode
+				 +4 // version
+				 +8 // lsn
+				 ) 
+};
+
 static int
 decompress_brtnode_from_raw_block_into_rbuf_10(u_int8_t *raw_block, struct rbuf *rb, BLOCKNUM blocknum) {
-    int r = decompress_brtnode_from_raw_block_into_rbuf(raw_block, rb, blocknum);
+    int r;
+    int i;
+    // get the number of compressed sub blocks
+    int n_sub_blocks;
+    int compression_header_offset;
+    {
+        n_sub_blocks = toku_dtoh32(*(u_int32_t*)(&raw_block[uncompressed_magic_len_10]));
+        compression_header_offset = uncompressed_magic_len_10 + 4;
+    }
+    assert(0 < n_sub_blocks);
+
+    // verify the sizes of the compressed sub blocks
+    if (0 && n_sub_blocks != 1) printf("%s:%d %d\n", __FUNCTION__, __LINE__, n_sub_blocks);
+
+    struct sub_block_sizes sub_block_sizes[n_sub_blocks];
+    for (i=0; i<n_sub_blocks; i++) {
+        u_int32_t compressed_size = toku_dtoh32(*(u_int32_t*)(&raw_block[compression_header_offset+8*i]));
+        if (compressed_size<=0   || compressed_size>(1<<30)) { r = toku_db_badformat(); return r; }
+        u_int32_t uncompressed_size = toku_dtoh32(*(u_int32_t*)(&raw_block[compression_header_offset+8*i+4]));
+        if (0) printf("Block %" PRId64 " Compressed size = %u, uncompressed size=%u\n", blocknum.b, compressed_size, uncompressed_size);
+        if (uncompressed_size<=0 || uncompressed_size>(1<<30)) { r = toku_db_badformat(); return r; }
+
+        sub_block_sizes[i].compressed_size = compressed_size;
+        sub_block_sizes[i].uncompressed_size = uncompressed_size;
+    }
+
+    unsigned char *compressed_data = raw_block + uncompressed_magic_len_10 + get_compression_header_size(BRT_LAYOUT_VERSION, n_sub_blocks);
+
+    size_t uncompressed_size = get_sum_uncompressed_size(n_sub_blocks, sub_block_sizes);
+    rb->size= uncompressed_magic_len_10 + uncompressed_size;
+    assert(rb->size>0);
+
+    rb->buf=toku_xmalloc(rb->size);
+
+    // construct the uncompressed block from the header and compressed sub blocks
+    memcpy(rb->buf, raw_block, uncompressed_magic_len_10);
+
+    // decompress the sub blocks
+    unsigned char *uncompressed_data = rb->buf+uncompressed_magic_len_10;
+    struct decompress_work decompress_work[n_sub_blocks];
+
+    for (i=0; i<n_sub_blocks; i++) {
+        init_decompress_work(&decompress_work[i], compressed_data, sub_block_sizes[i].compressed_size, uncompressed_data, sub_block_sizes[i].uncompressed_size);
+        if (i>0) {
+#if DO_DECOMPRESS_WORKER
+            start_decompress_work(&decompress_work[i]);
+#else
+            do_decompress_work(&decompress_work[i]);
+#endif
+        }
+        uncompressed_data += sub_block_sizes[i].uncompressed_size;
+        compressed_data += sub_block_sizes[i].compressed_size;
+    }
+    do_decompress_work(&decompress_work[0]);
+#if DO_DECOMPRESS_WORKER
+    for (i=1; i<n_sub_blocks; i++)
+        wait_decompress_work(&decompress_work[i]);
+#endif
+    toku_trace("decompress done");
+
+    if (0) printf("First 4 bytes of uncompressed data are %02x%02x%02x%02x\n",
+		  rb->buf[uncompressed_magic_len_10],   rb->buf[uncompressed_magic_len_10+1],
+		  rb->buf[uncompressed_magic_len_10+2], rb->buf[uncompressed_magic_len_10+3]);
+
+    rb->ndone=0;
+
+    r = verify_decompressed_brtnode_checksum(rb);
     return r;
 }
 
@@ -687,7 +759,7 @@ deserialize_brtnode_from_rbuf_10 (BLOCKNUM blocknum, u_int32_t fullhash, BRTNODE
     rbuf_literal_bytes(rb, &magic, 8);
     result->layout_version    = rbuf_int(rb);
     assert(result->layout_version == BRT_LAYOUT_VERSION_10);
-    result->disk_lsn.lsn = rbuf_ulonglong(rb);
+    (void)rbuf_ulonglong(rb); // BRTNODE.disk_lsn.lsn no longer exists
     {
         //Restrict scope for now since we do not support upgrades.
         struct descriptor desc;
@@ -696,7 +768,7 @@ deserialize_brtnode_from_rbuf_10 (BLOCKNUM blocknum, u_int32_t fullhash, BRTNODE
         assert(desc.version == result->desc->version); //We do not yet support upgrading the dbts.
     }
     result->nodesize = rbuf_int(rb);
-    result->log_lsn = result->disk_lsn;
+    //result->log_lsn = result->disk_lsn; //Disabled since neither variable exists anymore
 
     result->thisnodename = blocknum;
     result->flags = rbuf_int(rb);
@@ -929,7 +1001,9 @@ upgrade_brtnode_10_11 (BRTNODE *brtnode_10, BRTNODE *brtnode_11) {
         upgrade_brtnode_leaf_10_11(*brtnode_10);
     *brtnode_11 = *brtnode_10;
     *brtnode_10 = NULL;
-    (*brtnode_11)->layout_version = BRT_LAYOUT_VERSION_11;
+    (*brtnode_11)->layout_version                = BRT_LAYOUT_VERSION_11;
+    (*brtnode_11)->layout_version_original       = BRT_LAYOUT_VERSION_10;
+    (*brtnode_11)->layout_version_read_from_disk = BRT_LAYOUT_VERSION_10;
     (*brtnode_11)->dirty = 1;
     return 0;
 }

newbrt/brt-internal.h

@@ -83,16 +83,9 @@ struct brtnode {
     int ever_been_written;
     unsigned int flags;
     BLOCKNUM thisnodename;   // Which block number is this node?
-    //  These two LSNs are used to decide when to make a copy of a node instead of overwriting it.
-    //  In the TOKULOGGER is a field called checkpoint_lsn which is the lsn of the most recent checkpoint
-    LSN     disk_lsn;       // The LSN as of the most recent version on disk.  (Updated by brt-serialize)  This lsn is saved in the node.
-    LSN     log_lsn;        // The LSN of the youngest log entry that affects the current in-memory state.   The log write may not have actually made it to disk.  This lsn is not saved in disk (since the two lsns are the same for any node not in main memory.)
-    //  The checkpointing works as follows:
-    //      When we unpin a node: if it is dirty and disk_lsn<checkpoint_lsn then we need to make a new copy.
-    //      When we checkpoint:  Create a checkpoint record, and cause every dirty node to be written to disk.  The new checkpoint record is *not* incorporated into the disk_lsn of the written nodes.
-    //      While we are checkpointing, someone may modify a dirty node that has not yet been written.   In that case, when we unpin the node, we make the new copy (because the disk_lsn<checkpoint_lsn), just as we would usually.
-    //
     int    layout_version; // What version of the data structure?
+    int    layout_version_original;	// different (<) from layout_version if upgraded from a previous version (useful for debugging)
+    int    layout_version_read_from_disk;  // transient, not serialized to disk, (useful for debugging)
     int    height; /* height is always >= 0.  0 for leaf, >0 for nonleaf. */
     u_int32_t rand4fingerprint;
     u_int32_t local_fingerprint; /* For leaves this is everything in the buffer.  For nonleaves, this is everything in the buffers, but does not include child subtree fingerprints. */
@@ -240,7 +233,7 @@ struct brtenv {
 };
 
 extern void toku_brtnode_flush_callback (CACHEFILE cachefile, BLOCKNUM nodename, void *brtnode_v, void *extraargs, long size, BOOL write_me, BOOL keep_me, BOOL for_checkpoint);
-extern int toku_brtnode_fetch_callback (CACHEFILE cachefile, BLOCKNUM nodename, u_int32_t fullhash, void **brtnode_pv, long *sizep, void*extraargs, LSN *written_lsn);
+extern int toku_brtnode_fetch_callback (CACHEFILE cachefile, BLOCKNUM nodename, u_int32_t fullhash, void **brtnode_pv, long *sizep, void*extraargs);
 extern int toku_brt_alloc_init_header(BRT t);
 extern int toku_read_brt_header_and_store_in_cachefile (CACHEFILE cf, struct brt_header **header);
 extern CACHEKEY* toku_calculate_root_offset_pointer (BRT brt, u_int32_t *root_hash);

newbrt/brt-serialize.c

@@ -160,10 +160,12 @@ toku_pwrite_extend (int fd, const void *buf, size_t count, toku_off_t offset, ss
 }
 
 // Don't include the compression header
+// Overhead calculated in same order fields are written to wbuf
 static const int brtnode_header_overhead = (8+   // magic "tokunode" or "tokuleaf"
+                                            4+   // layout_version
+                                            4+   // layout_version_original
+                                            0+   // descriptor (variable, not counted here)
 					    4+   // nodesize
-					    8+   // checkpoint number
-					    4+   // target node size
 					    4+   // flags
 					    4+   // height
 					    4+   // random for fingerprint
@@ -254,8 +256,8 @@ wbufwriteleafentry (OMTVALUE lev, u_int32_t UU(idx), void *v) {
 }
 
 enum { uncompressed_magic_len = (8 // tokuleaf or tokunode
-				 +4 // version
-				 +8 // lsn
+				 +4 // layout version
+				 +4 // layout version original
 				 ) 
 };
 
@@ -263,7 +265,6 @@ enum { uncompressed_magic_len = (8 // tokuleaf or tokunode
 enum {
     uncompressed_magic_offset = 0,
     uncompressed_version_offset = 8,
-    uncompressed_lsn_offset = 12,
 };
 
 // compression header sub block sizes
@@ -361,7 +362,7 @@ int toku_serialize_brtnode_to (int fd, BLOCKNUM blocknum, BRTNODE node, struct b
     else wbuf_literal_bytes(&w, "node", 4);
     assert(node->layout_version == BRT_LAYOUT_VERSION);
     wbuf_int(&w, node->layout_version);
-    wbuf_ulonglong(&w, node->log_lsn.lsn);
+    wbuf_int(&w, node->layout_version_original);
     assert(node->desc == &h->descriptor);
     serialize_descriptor_contents_to_wbuf(&w, node->desc);
     //printf("%s:%d %lld.calculated_size=%d\n", __FILE__, __LINE__, off, calculated_size);
@@ -819,7 +820,8 @@ deserialize_brtnode_from_rbuf (BLOCKNUM blocknum, u_int32_t fullhash, BRTNODE *b
     rbuf_literal_bytes(rb, &magic, 8);
     result->layout_version    = rbuf_int(rb);
     assert(result->layout_version == BRT_LAYOUT_VERSION);
-    result->disk_lsn.lsn = rbuf_ulonglong(rb);
+    result->layout_version_original = rbuf_int(rb);
+    result->layout_version_read_from_disk = result->layout_version;
     {
         //Restrict scope for now since we do not support upgrades.
         struct descriptor desc;
@@ -828,7 +830,6 @@ deserialize_brtnode_from_rbuf (BLOCKNUM blocknum, u_int32_t fullhash, BRTNODE *b
         assert(desc.version == result->desc->version); //We do not yet support upgrading the dbts.
     }
     result->nodesize = rbuf_int(rb);
-    result->log_lsn = result->disk_lsn;
 
     result->thisnodename = blocknum;
     result->flags = rbuf_int(rb);
@@ -1018,7 +1019,7 @@ toku_deserialize_brtnode_from (int fd, BLOCKNUM blocknum, u_int32_t fullhash, BR
     // get the file offset and block size for the block
     DISKOFF offset, size;
     toku_translate_blocknum_to_offset_size(h->blocktable, blocknum, &offset, &size);
-    unsigned char *XMALLOC_N(size, raw_block);
+    u_int8_t *XMALLOC_N(size, raw_block);
     {
         // read the (partially compressed) block
         ssize_t rlen = pread(fd, raw_block, size, offset);

newbrt/brt.c

@@ -457,15 +457,13 @@ void toku_brtnode_flush_callback (CACHEFILE cachefile, BLOCKNUM nodename, void *
     //printf("%s:%d n_items_malloced=%lld\n", __FILE__, __LINE__, n_items_malloced);
 }
 
-int toku_brtnode_fetch_callback (CACHEFILE cachefile, BLOCKNUM nodename, u_int32_t fullhash, void **brtnode_pv, long *sizep, void*extraargs, LSN *written_lsn) {
+int toku_brtnode_fetch_callback (CACHEFILE cachefile, BLOCKNUM nodename, u_int32_t fullhash, void **brtnode_pv, long *sizep, void*extraargs) {
     assert(extraargs);
     struct brt_header *h = extraargs;
     BRTNODE *result=(BRTNODE*)brtnode_pv;
     int r = toku_deserialize_brtnode_from(toku_cachefile_fd(cachefile), nodename, fullhash, result, h);
-    if (r == 0) {
+    if (r == 0)
         *sizep = brtnode_memory_size(*result);
-        *written_lsn = (*result)->disk_lsn;
-    }
     //(*result)->parent_brtnode = 0; /* Don't know it right now. */
     //printf("%s:%d installed %p (offset=%lld)\n", __FILE__, __LINE__, *result, nodename);
     return r;
@@ -635,10 +633,10 @@ initialize_empty_brtnode (BRT t, BRTNODE n, BLOCKNUM nodename, int height, size_
     n->nodesize = t->h->nodesize;
     n->flags = t->flags;
     n->thisnodename = nodename;
-    n->disk_lsn.lsn = 0; // a new one can always be 0.
-    n->log_lsn = n->disk_lsn;
     assert(t->h->layout_version != 0);
-    n->layout_version = t->h->layout_version;
+    n->layout_version          = t->h->layout_version;
+    n->layout_version_original = t->h->layout_version;
+    n->layout_version_read_from_disk = t->h->layout_version;
     n->height       = height;
     n->rand4fingerprint = random();
     n->local_fingerprint = 0;

newbrt/brtdump.c

@@ -62,10 +62,11 @@ dump_node (int f, BLOCKNUM blocknum, struct brt_header *h) {
     printf(" serialize_size =%u\n", toku_serialize_brtnode_size(n));
     printf(" flags       =%u\n", n->flags);
     printf(" thisnodename=%" PRId64 "\n", n->thisnodename.b);
-    printf(" disk_lsn    =%" PRIu64 "\n", n->disk_lsn.lsn);
     //printf(" log_lsn     =%lld\n", n->log_lsn.lsn); // The log_lsn is a memory-only value.
     printf(" height      =%d\n",   n->height);
     printf(" layout_version=%d\n", n->layout_version);
+    printf(" layout_version_original=%d\n", n->layout_version_original);
+    printf(" layout_version_read_from_disk=%d\n", n->layout_version_read_from_disk);
     printf(" rand4fp     =%08x\n", n->rand4fingerprint);
     printf(" localfp     =%08x\n", n->local_fingerprint);
     if (n->height>0) {

newbrt/cachetable.c

@@ -694,13 +694,12 @@ static int cachetable_fetch_pair(CACHETABLE ct, CACHEFILE cf, PAIR p) {
 
     void *toku_value = 0;
     long size = 0;
-    LSN written_lsn = ZERO_LSN;
 
     WHEN_TRACE_CT(printf("%s:%d CT: fetch_callback(%lld...)\n", __FILE__, __LINE__, key));    
 
     cachetable_unlock(ct);
 
-    int r = fetch_callback(cf, key, fullhash, &toku_value, &size, extraargs, &written_lsn);
+    int r = fetch_callback(cf, key, fullhash, &toku_value, &size, extraargs);
 
     cachetable_lock(ct);
 
@@ -716,7 +715,6 @@ static int cachetable_fetch_pair(CACHETABLE ct, CACHEFILE cf, PAIR p) {
     } else {
         lru_touch(ct, p);
         p->value = toku_value;
-        p->written_lsn = written_lsn;
         p->size = size;
         ct->size_current += size;
         if (p->cq) {

newbrt/cachetable.h

@@ -88,7 +88,7 @@ typedef void (*CACHETABLE_FLUSH_CALLBACK)(CACHEFILE, CACHEKEY key, void *value,
 // object and it is not in the cachetable.
 // Returns: 0 if success, otherwise an error number.  The address and size of the object
 // associated with the key are returned.
-typedef int (*CACHETABLE_FETCH_CALLBACK)(CACHEFILE, CACHEKEY key, u_int32_t fullhash, void **value, long *sizep, void *extraargs, LSN *written_lsn);
+typedef int (*CACHETABLE_FETCH_CALLBACK)(CACHEFILE, CACHEKEY key, u_int32_t fullhash, void **value, long *sizep, void *extraargs);
 
 void toku_cachefile_set_userdata(CACHEFILE cf, void *userdata, int (*close_userdata)(CACHEFILE, void*, char **/*error_string*/, LSN), int (*checkpoint_userdata)(CACHEFILE, void*), int (*begin_checkpoint_userdata)(CACHEFILE, LSN, void*), int (*end_checkpoint_userdata)(CACHEFILE, void*));
 // Effect: Store some cachefile-specific user data.  When the last reference to a cachefile is closed, we call close_userdata().

newbrt/tests/brt-serialize-test.c

@@ -20,9 +20,8 @@ static void test_serialize(void) {
     sn.ever_been_written = 0;
     sn.flags = 0x11223344;
     sn.thisnodename.b = 20;
-    sn.disk_lsn.lsn = 789;
-    sn.log_lsn.lsn  = 123456;
     sn.layout_version = BRT_LAYOUT_VERSION;
+    sn.layout_version_original = BRT_LAYOUT_VERSION;
     sn.height = 1;
     sn.rand4fingerprint = randval;
     sn.local_fingerprint = 0;
@@ -99,8 +98,9 @@ static void test_serialize(void) {
 
     assert(dn->thisnodename.b==20);
 
-    assert(dn->disk_lsn.lsn==123456);
     assert(dn->layout_version ==BRT_LAYOUT_VERSION);
+    assert(dn->layout_version_original ==BRT_LAYOUT_VERSION);
+    assert(dn->layout_version_read_from_disk ==BRT_LAYOUT_VERSION);
     assert(dn->height == 1);
     assert(dn->rand4fingerprint==randval);
     assert(dn->u.n.n_children==2);

newbrt/tests/cachetable-checkpoint-pending.c

@@ -54,7 +54,7 @@ flush (CACHEFILE UU(thiscf), CACHEKEY UU(key), void *value, void *UU(extraargs),
 }
 
 static int
-fetch (CACHEFILE UU(thiscf), CACHEKEY UU(key), u_int32_t UU(fullhash), void **UU(value), long *UU(sizep), void *UU(extraargs), LSN *UU(written_lsn))
+fetch (CACHEFILE UU(thiscf), CACHEKEY UU(key), u_int32_t UU(fullhash), void **UU(value), long *UU(sizep), void *UU(extraargs))
 {
     assert(0); // should not be called
     return 0;

newbrt/tests/cachetable-checkpoint-test.c

@@ -19,8 +19,8 @@ static void flush(CACHEFILE cf, CACHEKEY key, void *value, void *extraargs, long
     if (keep_me) n_keep_me++;
 }
 
-static int fetch(CACHEFILE cf, CACHEKEY key, u_int32_t fullhash, void **value, long *sizep, void *extraargs, LSN *written_lsn) {
-    cf = cf; key = key; fullhash = fullhash; value = value; sizep = sizep; extraargs = extraargs; written_lsn = written_lsn;
+static int fetch(CACHEFILE cf, CACHEKEY key, u_int32_t fullhash, void **value, long *sizep, void *extraargs) {
+    cf = cf; key = key; fullhash = fullhash; value = value; sizep = sizep; extraargs = extraargs;
     assert(0); // should not be called
     n_fetch++;
     *value = 0;

newbrt/tests/cachetable-count-pinned-test.c

@@ -20,8 +20,7 @@ fetch (CACHEFILE f        __attribute__((__unused__)),
        u_int32_t fullhash __attribute__((__unused__)),
        void **value       __attribute__((__unused__)),
        long *sizep        __attribute__((__unused__)),
-       void *extraargs    __attribute__((__unused__)),
-       LSN *written_lsn    __attribute__((__unused__))
+       void *extraargs    __attribute__((__unused__))
        ) {
     return 0;
 }

newbrt/tests/cachetable-debug-test.c

@@ -20,8 +20,7 @@ fetch (CACHEFILE f        __attribute__((__unused__)),
        u_int32_t fullhash __attribute__((__unused__)),
        void **value       __attribute__((__unused__)),
        long *sizep        __attribute__((__unused__)),
-       void *extraargs    __attribute__((__unused__)),
-       LSN *written_lsn    __attribute__((__unused__))
+       void *extraargs    __attribute__((__unused__))
        ) {
     return 0;
 }

newbrt/tests/cachetable-flush-test.c

@@ -20,8 +20,7 @@ fetch (CACHEFILE f        __attribute__((__unused__)),
        u_int32_t fullhash __attribute__((__unused__)),
        void **value       __attribute__((__unused__)),
        long *sizep        __attribute__((__unused__)),
-       void *extraargs    __attribute__((__unused__)),
-       LSN *written_lsn    __attribute__((__unused__))
+       void *extraargs    __attribute__((__unused__))
        ) {
     return 0;
 }

newbrt/tests/cachetable-getandpin-test.c

@@ -16,8 +16,8 @@ flush (CACHEFILE cf     __attribute__((__unused__)),
 }
 
 static int
-fetch (CACHEFILE cf, CACHEKEY key, u_int32_t hash, void **vptr, long *sizep, void *extra, LSN *written_lsn) {
-    cf = cf; hash = hash; extra = extra; written_lsn = written_lsn;
+fetch (CACHEFILE cf, CACHEKEY key, u_int32_t hash, void **vptr, long *sizep, void *extra) {
+    cf = cf; hash = hash; extra = extra;
     *sizep = (long) key.b;
     *vptr = toku_malloc(*sizep);
     return 0;
@@ -29,8 +29,7 @@ fetch_error (CACHEFILE cf       __attribute__((__unused__)),
 	     u_int32_t fullhash __attribute__((__unused__)),
 	     void **value       __attribute__((__unused__)),
 	     long *sizep        __attribute__((__unused__)),
-	     void*extraargs     __attribute__((__unused__)),
-	     LSN *written_lsn   __attribute__((__unused__))
+	     void*extraargs     __attribute__((__unused__))
 	     ) {
     return -1;
 }

newbrt/tests/cachetable-prefetch-checkpoint-test.c

@@ -22,8 +22,8 @@ static void flush(CACHEFILE cf, CACHEKEY key, void *value, void *extraargs, long
     if (keep_me) n_keep_me++;
 }
 
-static int fetch(CACHEFILE cf, CACHEKEY key, u_int32_t fullhash, void **value, long *sizep, void *extraargs, LSN *written_lsn) {
-    cf = cf; key = key; fullhash = fullhash; value = value; sizep = sizep; extraargs = extraargs; written_lsn = written_lsn;
+static int fetch(CACHEFILE cf, CACHEKEY key, u_int32_t fullhash, void **value, long *sizep, void *extraargs) {
+    cf = cf; key = key; fullhash = fullhash; value = value; sizep = sizep; extraargs = extraargs;
     n_fetch++;
     sleep(10);
     *value = 0;

newbrt/tests/cachetable-prefetch-close-fail-test.c

@@ -25,8 +25,7 @@ fetch (CACHEFILE f        __attribute__((__unused__)),
        u_int32_t fullhash __attribute__((__unused__)),
        void **value       __attribute__((__unused__)),
        long *sizep        __attribute__((__unused__)),
-       void *extraargs    __attribute__((__unused__)),
-       LSN *written_lsn    __attribute__((__unused__))
+       void *extraargs    __attribute__((__unused__))
        ) {
 
     fetch_calls++;
@@ -34,7 +33,6 @@ fetch (CACHEFILE f        __attribute__((__unused__)),
 
     *value = 0;
     *sizep = 1;
-    *written_lsn = ZERO_LSN;
 
     return -42;
 }

newbrt/tests/cachetable-prefetch-close-leak-test.c

@@ -26,8 +26,7 @@ fetch (CACHEFILE f        __attribute__((__unused__)),
        u_int32_t fullhash __attribute__((__unused__)),
        void **value       __attribute__((__unused__)),
        long *sizep        __attribute__((__unused__)),
-       void *extraargs    __attribute__((__unused__)),
-       LSN *written_lsn    __attribute__((__unused__))
+       void *extraargs    __attribute__((__unused__))
        ) {
 
     fetch_calls++;
@@ -35,7 +34,6 @@ fetch (CACHEFILE f        __attribute__((__unused__)),
 
     *value = toku_malloc(1);
     *sizep = 1;
-    *written_lsn = ZERO_LSN;
 
     return 0;
 }

newbrt/tests/cachetable-prefetch-close-test.c

@@ -25,8 +25,7 @@ fetch (CACHEFILE f        __attribute__((__unused__)),
        u_int32_t fullhash __attribute__((__unused__)),
        void **value       __attribute__((__unused__)),
        long *sizep        __attribute__((__unused__)),
-       void *extraargs    __attribute__((__unused__)),
-       LSN *written_lsn    __attribute__((__unused__))
+       void *extraargs    __attribute__((__unused__))
        ) {
 
     fetch_calls++;
@@ -34,7 +33,6 @@ fetch (CACHEFILE f        __attribute__((__unused__)),
 
     *value = 0;
     *sizep = 1;
-    *written_lsn = ZERO_LSN;
 
     return 0;
 }

newbrt/tests/cachetable-prefetch-getandpin-fail-test.c

@@ -23,15 +23,13 @@ fetch (CACHEFILE f        __attribute__((__unused__)),
        u_int32_t fullhash __attribute__((__unused__)),
        void **value       __attribute__((__unused__)),
        long *sizep        __attribute__((__unused__)),
-       void *extraargs    __attribute__((__unused__)),
-       LSN *written_lsn    __attribute__((__unused__))
+       void *extraargs    __attribute__((__unused__))
        ) {
 
     sleep(10);
 
     *value = 0;
     *sizep = 1;
-    *written_lsn = ZERO_LSN;
 
     return -42;
 }

newbrt/tests/cachetable-prefetch-getandpin-test.c

@@ -23,15 +23,13 @@ fetch (CACHEFILE f        __attribute__((__unused__)),
        u_int32_t fullhash __attribute__((__unused__)),
        void **value       __attribute__((__unused__)),
        long *sizep        __attribute__((__unused__)),
-       void *extraargs    __attribute__((__unused__)),
-       LSN *written_lsn    __attribute__((__unused__))
+       void *extraargs    __attribute__((__unused__))
        ) {
 
     sleep(10);
 
     *value = 0;
     *sizep = 1;
-    *written_lsn = ZERO_LSN;
 
     return 0;
 }

newbrt/tests/cachetable-prefetch-maybegetandpin-test.c

@@ -23,15 +23,13 @@ fetch (CACHEFILE f        __attribute__((__unused__)),
        u_int32_t fullhash __attribute__((__unused__)),
        void **value       __attribute__((__unused__)),
        long *sizep        __attribute__((__unused__)),
-       void *extraargs    __attribute__((__unused__)),
-       LSN *written_lsn    __attribute__((__unused__))
+       void *extraargs    __attribute__((__unused__))
        ) {
 
     sleep(10);
 
     *value = 0;
     *sizep = 1;
-    *written_lsn = ZERO_LSN;
 
     return 0;
 }

newbrt/tests/cachetable-prefetch2-test.c

@@ -26,8 +26,7 @@ fetch (CACHEFILE f        __attribute__((__unused__)),
        u_int32_t fullhash __attribute__((__unused__)),
        void **value       __attribute__((__unused__)),
        long *sizep        __attribute__((__unused__)),
-       void *extraargs    __attribute__((__unused__)),
-       LSN *written_lsn    __attribute__((__unused__))
+       void *extraargs    __attribute__((__unused__))
        ) {
 
     fetch_calls++;
@@ -35,7 +34,6 @@ fetch (CACHEFILE f        __attribute__((__unused__)),
 
     *value = 0;
     *sizep = 1;
-    *written_lsn = ZERO_LSN;
 
     return 0;
 }

newbrt/tests/cachetable-put-test.c

@@ -20,8 +20,7 @@ fetch (CACHEFILE f        __attribute__((__unused__)),
        u_int32_t fullhash __attribute__((__unused__)),
        void **value       __attribute__((__unused__)),
        long *sizep        __attribute__((__unused__)),
-       void *extraargs    __attribute__((__unused__)),
-       LSN *written_lsn    __attribute__((__unused__))
+       void *extraargs    __attribute__((__unused__))
        ) {
     return 0;
 }

newbrt/tests/cachetable-rename-test.c

@@ -73,8 +73,7 @@ static int r_fetch (CACHEFILE f        __attribute__((__unused__)),
 		    u_int32_t fullhash __attribute__((__unused__)),
 		    void**value        __attribute__((__unused__)),
 		    long *sizep        __attribute__((__unused__)),
-		    void*extraargs     __attribute__((__unused__)),
-		    LSN *modified_lsn  __attribute__((__unused__))) {
+		    void*extraargs     __attribute__((__unused__))) {
     // fprintf(stderr, "Whoops, this should never be called");
     return -42;
 }

newbrt/tests/cachetable-scan.c

@@ -31,8 +31,7 @@ static int f_fetch (CACHEFILE f,
 		    u_int32_t fullhash __attribute__((__unused__)),
 		    void**value,
 		    long *sizep,
-		    void*extraargs     __attribute__((__unused__)),
-		    LSN *modified_lsn  __attribute__((__unused__))) {
+		    void*extraargs     __attribute__((__unused__))) {
     void *buf = toku_malloc(BLOCKSIZE);
     int r = pread(toku_cachefile_fd(f), buf, BLOCKSIZE, key.b);
     assert(r==BLOCKSIZE);

newbrt/tests/cachetable-test.c

@@ -143,14 +143,13 @@ static struct item *make_item (u_int64_t key) {
 }
 
 static CACHEKEY did_fetch={-1};
-static int fetch (CACHEFILE f, CACHEKEY key, u_int32_t fullhash __attribute__((__unused__)), void**value, long *sizep __attribute__((__unused__)), void*extraargs, LSN *written_lsn) {
+static int fetch (CACHEFILE f, CACHEKEY key, u_int32_t fullhash __attribute__((__unused__)), void**value, long *sizep __attribute__((__unused__)), void*extraargs) {
     if (verbose) printf("Fetch %" PRId64 "\n", key.b);
     assert (expect_f==f);
     assert((long)extraargs==23);
     *value = make_item(key.b);
     *sizep = test_object_size;
     did_fetch=key;
-    written_lsn->lsn = 0;
     return 0;
 }
 
@@ -308,10 +307,9 @@ static void flush_n (CACHEFILE f __attribute__((__unused__)), CACHEKEY key __att
 }
 static int fetch_n (CACHEFILE f __attribute__((__unused__)), CACHEKEY key __attribute__((__unused__)),
 		    u_int32_t fullhash  __attribute__((__unused__)),
-                    void**value, long *sizep __attribute__((__unused__)), void*extraargs, LSN *written_lsn) {
+                    void**value, long *sizep __attribute__((__unused__)), void*extraargs) {
     assert((long)extraargs==42);
     *value=0;
-    written_lsn->lsn = 0;
     return 0;
 }
 
@@ -369,19 +367,17 @@ static void null_flush (CACHEFILE cf     __attribute__((__unused__)),
                         BOOL for_checkpoint __attribute__((__unused__))) {
 }
 
-static int add123_fetch (CACHEFILE cf, CACHEKEY key, u_int32_t fullhash, void **value, long *sizep __attribute__((__unused__)), void*extraargs, LSN *written_lsn) {
+static int add123_fetch (CACHEFILE cf, CACHEKEY key, u_int32_t fullhash, void **value, long *sizep __attribute__((__unused__)), void*extraargs) {
     assert(fullhash==toku_cachetable_hash(cf,key));
     assert((long)extraargs==123);
     *value = (void*)((unsigned long)key.b+123L);
-    written_lsn->lsn = 0;
     return 0;
 }
 
-static int add222_fetch (CACHEFILE cf, CACHEKEY key, u_int32_t fullhash, void **value, long *sizep __attribute__((__unused__)), void*extraargs, LSN *written_lsn) {
+static int add222_fetch (CACHEFILE cf, CACHEKEY key, u_int32_t fullhash, void **value, long *sizep __attribute__((__unused__)), void*extraargs) {
     assert(fullhash==toku_cachetable_hash(cf,key));
     assert((long)extraargs==222);
     *value = (void*)((unsigned long)key.b+222L);
-    written_lsn->lsn = 0;
     return 0;
 }
 
@@ -444,9 +440,8 @@ static void test_dirty_flush(CACHEFILE f,
     if (verbose) printf("test_dirty_flush %p %" PRId64 " %p %ld %u %u\n", f, key.b, value, size, (unsigned)do_write, (unsigned)keep);
 }
 
-static int test_dirty_fetch(CACHEFILE f, CACHEKEY key, u_int32_t fullhash, void **value_ptr, long *size_ptr, void *arg, LSN *written_lsn) {
+static int test_dirty_fetch(CACHEFILE f, CACHEKEY key, u_int32_t fullhash, void **value_ptr, long *size_ptr, void *arg) {
     *value_ptr = arg;
-    written_lsn->lsn = 0;
     assert(fullhash==toku_cachetable_hash(f,key));
     if (verbose) printf("test_dirty_fetch %p %" PRId64 " %p %ld %p\n", f, key.b, *value_ptr, *size_ptr, arg);
     return 0;

newbrt/tests/cachetable-test2.c

@@ -111,11 +111,10 @@ static void flush_forchain (CACHEFILE f            __attribute__((__unused__)),
     //print_ints();
 }
 
-static int fetch_forchain (CACHEFILE f, CACHEKEY key, u_int32_t fullhash, void**value, long *sizep __attribute__((__unused__)), void*extraargs, LSN *written_lsn) {
+static int fetch_forchain (CACHEFILE f, CACHEKEY key, u_int32_t fullhash, void**value, long *sizep __attribute__((__unused__)), void*extraargs) {
     assert(toku_cachetable_hash(f, key)==fullhash);
     assert((long)extraargs==(long)key.b);
     *value = (void*)(long)key.b;
-    written_lsn->lsn = 0;
     return 0;
 }
 

newbrt/tests/cachetable-unpin-test.c

@@ -20,8 +20,7 @@ fetch (CACHEFILE f        __attribute__((__unused__)),
        u_int32_t fullhash __attribute__((__unused__)),
        void **value       __attribute__((__unused__)),
        long *sizep        __attribute__((__unused__)),
-       void *extraargs    __attribute__((__unused__)),
-       LSN *written_lsn    __attribute__((__unused__))
+       void *extraargs    __attribute__((__unused__))
        ) {
     return 0;
 }