void read_chunk_file(uuid_t fid, char * path, rozofs_stor_bins_file_hdr_vall_t * hdr, int spare, uint64_t firstBlock) {
uint16_t rozofs_disk_psize;
int fd;
rozofs_stor_bins_hdr_t * pH;
int nb_read;
uint32_t bbytes = ROZOFS_BSIZE_BYTES(hdr->v0.bsize);
char crc32_string[32];
uint64_t offset;
if (dump_data == 0) {
printf ("+------------+------------------+------------+----+------+-------+--------------------------------------------\n");
printf ("| %10s | %16s | %10s | %2s | %4s | %5s | %s\n", "block#","file offset", "prj offset", "pj", "size", "crc32", "date");
printf ("+------------+------------------+------------+----+------+-------+--------------------------------------------\n");
}
// Open bins file
fd = open(path, ROZOFS_ST_NO_CREATE_FILE_FLAG, ROZOFS_ST_BINS_FILE_MODE_RO);
if (fd < 0) {
printf("open(%s) %s\n",path,strerror(errno));
return;
}
/*
** Retrieve the projection size on disk
*/
rozofs_disk_psize = rozofs_get_max_psize_in_msg(hdr->v0.layout,hdr->v0.bsize);
if (spare==0) {
/* Header version 1. Find the sid in the distribution */
if (hdr->v0.version == 2) {
int fwd = rozofs_get_rozofs_forward(hdr->v2.layout);
int idx;
for (idx=0; idx< fwd;idx++) {
if (hdr->v2.distrib[idx] != hdr->v2.sid) continue;
rozofs_disk_psize = rozofs_get_psizes_on_disk(hdr->v2.layout,hdr->v2.bsize,idx);
break;
}
}
else if (hdr->v0.version == 1) {
int fwd = rozofs_get_rozofs_forward(hdr->v1.layout);
int idx;
for (idx=0; idx< fwd;idx++) {
if (hdr->v1.dist_set_current[idx] != hdr->v1.sid) continue;
rozofs_disk_psize = rozofs_get_psizes_on_disk(hdr->v1.layout,hdr->v1.bsize,idx);
break;
}
}
/* Projection id given as parameter */
else if (prjid != -1) {
rozofs_disk_psize = rozofs_get_psizes_on_disk(hdr->v0.layout,hdr->v0.bsize,prjid);
}
/*�Version 0 without projection given as parameter*/
else {
// Read 1rst block
nb_read = pread(fd, buffer, sizeof(rozofs_stor_bins_hdr_t), 0);
if (nb_read<0) {
printf("pread(%s) %s\n",path,strerror(errno));
return;
}
pH = (rozofs_stor_bins_hdr_t*)buffer;
if (pH->s.timestamp == 0) {
printf("Can not tell projection id\n");
return;
}
rozofs_disk_psize = rozofs_get_psizes_on_disk(hdr->v0.layout,hdr->v0.bsize,pH->s.projection_id);
}
}
/*
** Where to start reading from
*/
if (first == 0) {
offset = 0;
}
else {
if (first <= firstBlock) {
offset = 0;
}
else {
offset = (first-firstBlock)*rozofs_disk_psize;
}
}
int idx;
nb_read = 1;
uint64_t bid;
/*
** Reading blocks
*/
while (nb_read) {
// Read nb_proj * (projection + header)
nb_read = pread(fd, buffer, rozofs_disk_psize*32, offset);
if (nb_read<0) {
printf("pread(%s) %s\n",path,strerror(errno));
close(fd);
return;
}
nb_read = (nb_read / rozofs_disk_psize);
pH = (rozofs_stor_bins_hdr_t*) buffer;
for (idx=0; idx<nb_read; idx++) {
pH = (rozofs_stor_bins_hdr_t*) &buffer[idx*rozofs_disk_psize];
bid = (offset/rozofs_disk_psize)+idx+firstBlock;
if (bid < first) continue;
if (bid > last) break;
uint32_t save_crc32 = pH->s.filler;
pH->s.filler = 0;
uint32_t crc32=0;
if (save_crc32 == 0) {
sprintf(crc32_string,"NONE");
}
else {
crc32 = fid2crc32((uint32_t *)fid)+bid-firstBlock;
crc32 = crc32c(crc32,(char *) pH, rozofs_disk_psize);
if (crc32 != save_crc32) sprintf(crc32_string,"ERROR");
else sprintf(crc32_string,"OK");
}
pH->s.filler = save_crc32;
if (dump_data == 0) {
printf ("| %10llu | %16llu | %10llu | %2d | %4d | %5s | %s\n",
(long long unsigned int)bid,
(long long unsigned int)bbytes * bid,
(long long unsigned int)offset+(idx*rozofs_disk_psize),
pH->s.projection_id,
pH->s.effective_length,
crc32_string,
ts2string(pH->s.timestamp));
}
else {
printf("_________________________________________________________________________________________\n");
printf("Block# %llu / file offset %llu / projection offset %llu\n",
(unsigned long long)bid, (unsigned long long)(bbytes * bid), (unsigned long long)(offset+(idx*rozofs_disk_psize)));
printf("prj id %d / length %d / CRC %s / time stamp %s\n",
pH->s.projection_id,pH->s.effective_length,crc32_string, ts2string(pH->s.timestamp));
printf("_________________________________________________________________________________________\n");
if ((pH->s.projection_id == 0)&&(pH->s.timestamp==0)) continue;
hexdump(pH, (offset+(idx*rozofs_disk_psize)), rozofs_disk_psize);
}
}
offset += (nb_read*rozofs_disk_psize);
}
if (dump_data == 0) {
printf ("+------------+------------------+------------+----+------+-------+--------------------------------------------\n");
}
close(fd);
}
int read_data_file() {
int status = -1;
uint64_t size = 0;
int block_idx = 0;
int idx =0;
int count;
rozofs_stor_bins_hdr_t * rozofs_bins_hdr_p;
rozofs_stor_bins_footer_t * rozofs_bins_foot_p;
char * loc_read_bins_p = NULL;
int forward = rozofs_get_rozofs_forward(layout);
// int inverse = rozofs_get_rozofs_inverse(layout);
uint16_t disk_block_size;
uint16_t max_block_size = (rozofs_get_max_psize(layout,bsize)*sizeof (bin_t))
+ sizeof (rozofs_stor_bins_hdr_t) + sizeof (rozofs_stor_bins_footer_t);
char * p;
int empty,valid;
int prj_id;
int nb_ts;
uint64_t ts[32];
int ts_count[32];
// Allocate memory for reading
loc_read_bins_p = xmalloc(max_block_size);
for (idx=0; idx < nb_file; idx++) {
if (strcmp(filename[idx],"NULL") == 0) {
fd[idx] = -1;
}
else {
fd[idx] = open(filename[idx],O_RDWR);
if (fd < 0) {
severe("Can not open file %s %s",filename[idx],strerror(errno));
goto out;
}
}
}
printf (" ______ __________ ");
for (idx=0; idx < nb_file; idx++) printf (" __________________ ______ ____ ");
printf ("\n");
printf("| %4s | %8s |","Blk","Offset");
for (idx=0; idx < nb_file; idx++) printf("| %16s | %4s | %2s |", "Time stamp", "lgth", "id");
printf ("\n");
printf ("|______|__________|");
for (idx=0; idx < nb_file; idx++) printf ("|__________________|______|____|");
printf ("\n");
if (block_number == -1) block_idx = 0;
else block_idx = block_number;
count = 1;
empty = 0;
while ( count ) {
valid = 0;
count = 0;
nb_ts = 0;
p = &LINE[0];
p += sprintf(p,"| %4d | %8d ",block_idx+firstBlock,(block_idx+firstBlock)*bbytes);
for (idx=0; idx < nb_file; idx++) {
if (fd[idx] == -1) {
p += sprintf(p,"%32s"," ");
continue;
}
if (idx >= forward)
disk_block_size = rozofs_get_max_psize_in_msg(layout, bsize);
else
disk_block_size = rozofs_get_psizes_on_disk(layout,bsize,idx);
size = pread(fd[idx],loc_read_bins_p,disk_block_size,block_idx*disk_block_size);
if (size != disk_block_size) {
p += sprintf(p,"|__________________|______|____|");
close(fd[idx]);
fd[idx] = -1;
}
else {
count++;
rozofs_bins_hdr_p = (rozofs_stor_bins_hdr_t *)loc_read_bins_p;
prj_id = rozofs_bins_hdr_p->s.projection_id;
if (prj_id >= forward) {
valid = 1;
p += sprintf(p,"|| xxxxxxxxxxxxxxxx | xxxx | %2d ",prj_id);
}
else {
disk_block_size = (rozofs_get_psizes(layout,bsize,prj_id)*sizeof (bin_t));
disk_block_size += sizeof (rozofs_stor_bins_hdr_t);
rozofs_bins_foot_p = (rozofs_stor_bins_footer_t *)
((char*) rozofs_bins_hdr_p + disk_block_size);
if (rozofs_bins_hdr_p->s.timestamp == 0) {
p += sprintf(p,"|| %16d | .... | %2d ",0,prj_id);
}
else if (rozofs_bins_foot_p->timestamp != rozofs_bins_hdr_p->s.timestamp) {
valid = 1;
p += sprintf(p,"|--%16.16llu----------%2d-",
(long long unsigned int)rozofs_bins_hdr_p->s.timestamp,
prj_id);
}
else if (rozofs_bins_hdr_p->s.timestamp == 0) {
p += sprintf(p,"|| %16d | .... | %2d ",0,prj_id);
}
else {
valid = 1;
p += sprintf(p,"|| %16llu | %4d | %2d ",
(unsigned long long)rozofs_bins_hdr_p->s.timestamp,
rozofs_bins_hdr_p->s.effective_length,
rozofs_bins_hdr_p->s.projection_id);
int tsidx;
for (tsidx=0; tsidx< nb_ts; tsidx++) {
if (ts[tsidx] == rozofs_bins_hdr_p->s.timestamp) {
ts_count[tsidx]++;
break;
}
}
if (tsidx == nb_ts) {
ts[tsidx] = rozofs_bins_hdr_p->s.timestamp;
ts_count[tsidx] = 1;
nb_ts++;
}
}
}
}
}
if (valid) {
if (empty) {
printf("... %d blocks...\n",empty);
empty = 0;
}
int best=-1,tsidx;
for (tsidx=0; tsidx< nb_ts; tsidx++) {
if (ts_count[tsidx] > best) best = ts_count[tsidx];
}
printf("%s%s\n",LINE, (best<forward)?"<<<<----":"|");
}
else {
empty++;
}
block_idx++;
if (block_number!=-1) break;
}
printf ("|______|__________|\n");
if (block_number!=-1) {
for (idx=0; idx < nb_file; idx++) {
if (idx < forward) {
disk_block_size = (rozofs_get_psizes(layout,bsize,idx)*sizeof (bin_t)) + sizeof (rozofs_stor_bins_hdr_t) + sizeof (rozofs_stor_bins_footer_t);
}
else {
disk_block_size = (rozofs_get_max_psize(layout,bsize)*sizeof (bin_t)) + sizeof (rozofs_stor_bins_hdr_t) + sizeof (rozofs_stor_bins_footer_t);
}
size = pread(fd[idx],loc_read_bins_p,disk_block_size,block_number*disk_block_size);
if (size != disk_block_size) {
printf("Can not read block %d of %s\n", block_number, filename[idx]);
continue;
}
FILE * f;
char fname[128];
sprintf(fname,"block_%d_dist_%d.txt", block_number, idx);
f = fopen(fname,"w");
if (f == NULL) {
printf ("Can not create file %s",fname);
continue;
}
printf("- %s\n",fname);
fprintf(f,"%s Block %d size %d\n", filename[idx], block_number, disk_block_size);
rozofs_bins_hdr_p = (rozofs_stor_bins_hdr_t *)loc_read_bins_p;
fprintf(f,"Block header : TS %llu SZ %d PRJ %d CRC32 0x%x\n",
(long long unsigned int)rozofs_bins_hdr_p->s.timestamp,
rozofs_bins_hdr_p->s.effective_length,
rozofs_bins_hdr_p->s.projection_id,
rozofs_bins_hdr_p->s.filler);
rozofs_bins_foot_p = (rozofs_stor_bins_footer_t *) (loc_read_bins_p + disk_block_size);
rozofs_bins_foot_p--;
fprintf(f,"Block footer : TS %llu %s\n",
(long long unsigned int)rozofs_bins_foot_p->timestamp,
(rozofs_bins_hdr_p->s.timestamp==rozofs_bins_foot_p->timestamp)?"":" !!!!!!");
hexdump(f,loc_read_bins_p, 0, disk_block_size);
fclose(f);
}
}
status = 0;
out:
// This spare file used to exist but is not needed any more
for (idx=0; idx < nb_file; idx++) {
if (fd[idx] != -1) close(fd[idx]);
}
if (loc_read_bins_p != NULL) {
//free(loc_read_bins_p);
loc_read_bins_p = NULL;
}
return status;
}
