~ubuntu-branches/ubuntu/utopic/mariadb-5.5/utopic-security

#ident "Copyright (c) 2007-2013 Tokutek Inc.  All rights reserved."

#ident "The technology is licensed by the Massachusetts Institute of Technology, Rutgers State University of New Jersey, and the Research Foundation of State University of New York at Stony Brook under United States of America Serial No. 11/760379 and to the patents and/or patent applications resulting from it."

 

 

#include "cachetable.h"

#include "ft.h"

#include <inttypes.h>

#include <limits.h>

 

    time_t timer = (time_t) time_int;

    ctime_r(&timer, buf);

    assert(buf[24] == '\n');

    buf[24] = 0;

}

 

    printf("\"");

    ITEMLEN i;

    for (i=0; i<len; i++) {

    printf("\"");

}

 

    for (uint64_t i = 0; i < size; i++) {

        unsigned char c = vp[i];

        printf("%2.2X", c);

    }

}

 

    uint64_t n = size / 32;

    for (uint64_t i = 0; i < n; i++) {

        printf("%" PRIu64 ": ", offset);

    printf("\n");

}

 

    printf(" descriptor size %u ", d->dbt.size);

    simple_hex_dump((unsigned char*) d->dbt.data, d->dbt.size);

    printf("\n");

}

 

    FT ft = NULL;

    int r;

    ft->cf = cf;

    *header = ft;

}

 

    char timestr[26];

    printf("ft:\n");

    printf(" layout_version=%d\n", ft->h->layout_version);

    printf(" estimated numbytes=%" PRId64 "\n", ft->in_memory_stats.numbytes);

}

 

    print_klpair(stdout, key, keylen, le);

    printf("\n");

    return 0;

}

 

    FTNODE n;

    struct ftnode_fetch_extra bfe;

    FTNODE_DISK_DATA ndd = NULL;

    fill_bfe_for_full_read(&bfe, h);

    assert(n!=0);

    printf("ftnode\n");

    DISKOFF disksize, diskoffset;

    }

    printf(" children:\n");

    for (int i=0; i<n->n_children; i++) {

        if (n->height > 0) {

            NONLEAF_CHILDINFO bnc = BNC(n, i);

            unsigned int n_bytes = toku_bnc_nbytesinbuf(bnc); 

            int n_entries = toku_bnc_n_entries(bnc);

            if (n_bytes > 0 || n_entries > 0) {

                printf("   buffer contains %u bytes (%d items)\n", n_bytes, n_entries);

            }

                FIFO_ITERATE(bnc->buffer, key, keylen, data, datalen, typ, msn, xids, UU(is_fresh),

                             {

                                 printf("    msn=%" PRIu64 " (0x%" PRIx64 ") ", msn.msn, msn.msn);

        } else {

            printf(" n_bytes_in_buffer= %" PRIu64 "", BLB_DATA(n, i)->get_disk_size());

            printf(" items_in_buffer=%u\n", BLB_DATA(n, i)->num_klpairs());

                BLB_DATA(n, i)->iterate<void, print_le>(NULL);

            }

        }

    toku_free(ndd);

}

 

    toku_blocknum_dump_translation(h->blocktable, make_blocknum(offset));

}

 

    int64_t used_space;

    int64_t total_space;

    toku_blocktable_internal_fragmentation(h->blocktable, &total_space, &used_space);

}

 

typedef struct {

    FT h;

    uint64_t blocksizes;

    uint64_t leafsizes;

    uint64_t leafblocks;

} frag_help_extra;

 

    frag_help_extra *CAST_FROM_VOIDP(info, extra);

    FTNODE n;

    FTNODE_DISK_DATA ndd = NULL;

    struct ftnode_fetch_extra bfe;

    fill_bfe_for_full_read(&bfe, info->h);

    if (r==0) {

        info->blocksizes += size;

        if (n->height == 0) {

    return 0;

}

 

    frag_help_extra info;

    memset(&info, 0, sizeof(info));

    info.h = h;

    toku_blocktable_iterate(h->blocktable, TRANSLATION_CHECKPOINTED,

                            nodesizes_helper, &info, true, true);

    printf("leafsizes\t%" PRIu64 "\n", info.leafsizes);

}

 

    uint64_t total_space = 0;

    uint64_t used_space = 0;

    toku_ft_get_garbage(ft, &total_space, &used_space);

}

 

struct dump_sub_block {

};

 

    sb->compressed_size = toku_dtoh32(get_unaligned_uint32(sub_block_header+0));

    sb->uncompressed_size = toku_dtoh32(get_unaligned_uint32(sub_block_header+4));

    sb->xsum = toku_dtoh32(get_unaligned_uint32(sub_block_header+8));

}

 

    // verify the header checksum

    const size_t node_header = 8 + sizeof (uint32_t) + sizeof (uint32_t) + sizeof (uint32_t);

    

        printf("offset %u expected %" PRIu64 "\n", offset, size);

}

 

    DISKOFF offset, size;

    toku_translate_blocknum_to_offset_size(h->blocktable, blocknum, &offset, &size);

    printf("%" PRId64 " at %" PRId64 " size %" PRId64 "\n", blocknum.b, offset, size);

 

    unsigned char *CAST_FROM_VOIDP(vp, toku_malloc(size));

    if (r == (uint64_t)size) {

        verify_block(vp, offset, size);

    }

    toku_free(vp);

}

 

    unsigned char *XMALLOC_N(size, vp);

    if (r == size) {

        if (outfp == stdout) {

            hex_dump(vp, offset, size);

    toku_free(vp);

}

 

}

 

    int i = 0;

    int c;

    while ((c = getchar()) != EOF && c != '\n' && i < maxline) {

    return c == EOF ? EOF : i;

}

 

    int i;

    for (i=0; i<maxfields; i++)

        fields[i] = NULL;

    return i;

}

 

    fprintf(stderr, "help\n");

    fprintf(stderr, "header\n");

    fprintf(stderr, "node NUMBER\n");

    fprintf(stderr, "quit\n");

}

 

    argc--; argv++;

    while (argc>0) {

        } else if (strcmp(argv[0], "--fragmentation") == 0) {

        } else if (strcmp(argv[0], "--tsv") == 0) {

        } else if (strcmp(argv[0], "--translation-table") == 0) {

        } else {

            break;

        }

        argc--; argv++;

    }

 

    int r = toku_ft_layer_init();

    // create a cachefile for the header

    toku_cachetable_create(&ct, 1<<25, (LSN){0}, 0);

    CACHEFILE cf = NULL;

    } else {

    }

    toku_cachefile_close(&cf, false, ZERO_LSN);

    toku_cachetable_close(&ct);