void file_check_inode_structure(DDSTAT *ddstat)
{
INOBNO inobno;
bool found=0;
DBT *data;
DBT *blockdata;
DBT *ddbuf;
unsigned long long real_size;
inobno.blocknr=0;
inobno.inode=ddstat->stbuf.st_ino;
while (1){
data=fscheck_block_exists(inobno);
if ( NULL != data ) {
blockdata=file_tgr_read_data(data->data);
if ( NULL == blockdata ) {
printf("inode %llu-%llu\n",inobno.inode,inobno.blocknr);
inobno.blocknr--;
printhash ("hash not found, file is truncated",data->data);
purge_dbb_beyond(&inobno);
break;
}
file_get_or_set_dbu(data);
DBTfree(blockdata);
DBTfree(data);
found=1;
} else break;
inobno.blocknr++;
}
real_size=BLKSIZE * inobno.blocknr;
if ( found && real_size>ddstat->stbuf.st_size+BLKSIZE ) {
printf("inode %llu size %llu mismatch, restore size to %llu bytes\n",(unsigned long long)ddstat->stbuf.st_ino,(unsigned long long)ddstat->stbuf.st_size,real_size);
ddstat->stbuf.st_size=real_size;
ddbuf = create_ddbuf(ddstat->stbuf, ddstat->filename, real_size);
bin_write_dbdata(dbp, &inobno.inode,
sizeof(unsigned long long), (void *) ddbuf->data,
ddbuf->size);
DBTfree(ddbuf);
}
return;
}
void file_update_block(const char *blockdata, unsigned long long blocknr,
unsigned int offsetblock, unsigned long long size,
unsigned long long inode, unsigned char *chksum,
off_t offset)
{
DBT *data = NULL;
DBT *decrypted = NULL;
DBT *cachedata;
unsigned char *dbdata;
INOBNO inobno;
compr *uncompdata;
BLKCACHE *blk;
unsigned char *dtiger;
INUSE *inuse;
bool compressed = 1;
QDTA *dta;
#ifndef SHA3
word64 res[3];
#endif
FUNC;
LDEBUG
("file_update_block : inode %llu blocknr %llu offsetblock %llu, size %llu",
inode, blocknr, (unsigned long long) offsetblock,
(unsigned long long) size);
inobno.inode = inode;
inobno.blocknr = blocknr;
dbdata = (unsigned char *) s_malloc(BLKSIZE);
memset(dbdata, 0, BLKSIZE);
data = try_block_cache(inode, blocknr, 0);
if (NULL != data) {
LDEBUG("try_block_cache : HIT");
memcpy(dbdata, data->data, data->size);
memcpy(dbdata + offsetblock, blockdata, size);
add_blk_to_cache(inode, blocknr, offsetblock + size, dbdata, offset);
update_filesize(inode, size, offsetblock, blocknr, 0, 0, 0);
free(dbdata);
DBTfree(data);
return;
} else
LDEBUG("%s: block not found in cache.", __FUNCTION__);
// We don't need the old blockdata when we overwrite it completely anyway.
if (offsetblock > 0 || size < BLKSIZE) {
get_moddb_lock();
// First read the cache
decrypted = search_memhash(dbdtaq, chksum, config->hashlen);
if (NULL == decrypted) {
LDEBUG("%s: Not in dbdtaq", __FUNCTION__);
data = file_tgr_read_data(chksum);
if (NULL == data) {
LDEBUG("%s: Not found", __FUNCTION__);
cachedata =
search_memhash(blkcache, &inobno.inode,
sizeof(unsigned long long));
if (NULL != cachedata) {
blk = (BLKCACHE *) cachedata->data;
#ifdef SHA3
dtiger=sha_binhash(blk->blockdata, BLKSIZE);
#else
binhash(blk->blockdata, BLKSIZE, res);
dtiger=(unsigned char *)&res;
#endif
if (0 == memcmp(dtiger, chksum, config->hashlen)) {
LDEBUG("%s: data alloc here", __FUNCTION__);
data = s_malloc(sizeof(DBT));
data->data = s_malloc(BLKSIZE);
data->size = BLKSIZE;
memcpy(data->data, blk->blockdata, BLKSIZE);
DBTfree(cachedata);
compressed = 0;
} else {
LDEBUG
("updateBlock : Not in dbcache, out of luck.");
loghash("updateBlock : No data found to read ",
chksum);
die_dataerr
("file_update_block : No data found to read - this should never happen: inode :%llu: blocknr :%llu",
inode, blocknr);
}
#ifdef SHA3
free(dtiger);
#endif
} else {
log_fatal_hash("file_update_block : No data found to read ",
chksum);
die_dataerr
("file_update_block : No data found to read, this should never happen: inode :%llu: blocknr :%llu",
inode, blocknr);
}
}
} else {
data = s_malloc(sizeof(DBT));
dta = (QDTA *) decrypted->data;
data->data = s_malloc(dta->size);
memcpy(data->data, dta->data, dta->size);
data->size = dta->size;
DBTfree(decrypted);
LDEBUG("data->size = %lu", data->size);
}
release_moddb_lock();
if (compressed && data->size < BLKSIZE) {
#ifdef LZO
uncompdata = lzo_decompress(data->data, data->size);
#else
uncompdata = clz_decompress(data->data, data->size);
#endif
memcpy(dbdata, uncompdata->data, uncompdata->size);
comprfree(uncompdata);
} else {
memcpy(dbdata, data->data, data->size);
}
DBTfree(data);
}
memcpy(dbdata + offsetblock, blockdata, size);
add_blk_to_cache(inode, blocknr, offsetblock + size, dbdata, offset);
inuse = file_get_inuse(chksum);
if (NULL == inuse)
die_dataerr("file_update_block : hash not found");
if (inuse->inuse <= 1) {
file_delete_data_cache(chksum, &inobno);
put_on_freelist(inuse);
delete_inuse(chksum);
} else {
inuse->inuse--;
file_update_inuse(chksum, inuse);
}
free(inuse);
update_filesize(inode, size, offsetblock, blocknr, 0, 0, 0);
free(dbdata);
EFUNC;
return;
}
void file_partial_truncate_block(struct stat *stbuf,
unsigned long long blocknr, unsigned int offset)
{
unsigned char *blockdata;
compr *uncompdata;
INOBNO inobno;
DBT *data;
OFFHASH *offhash;
off_t offsetfile;
unsigned char *stiger;
INUSE *inuse;
DBT cachedata;
QDTA *dta;
FUNC;
LDEBUG("file_partial_truncate_block : inode %llu, blocknr %llu, offset %u",
stbuf->st_ino, blocknr, offset);
inobno.inode = stbuf->st_ino;
inobno.blocknr = blocknr;
get_dbb_lock();
data = search_memhash(dbbm, &inobno, sizeof(INOBNO));
if ( NULL == data ) {
data = search_dbdata(dbb, &inobno, sizeof(INOBNO));
}
release_dbb_lock();
if (NULL == data) {
LDEBUG("file_partial_truncate_block : deletion of non existent block.");
return;
}
offhash = (OFFHASH *) data->data;
stiger = s_malloc(data->size);
loghash("file_partial_truncate_block : search tiger ", stiger);
memcpy(stiger, offhash->stiger, config->hashlen);
offsetfile = offhash->offset;
DBTfree(data);
blockdata = s_malloc(BLKSIZE);
memset(blockdata, 0, BLKSIZE);
// First try the cache
get_moddb_lock();
data = search_memhash(dbdtaq, stiger, config->hashlen);
if ( NULL != data ) die_dataerr("file_partial_truncate_block : not data in cache expected");
release_moddb_lock();
if ( NULL == data ) {
data = file_tgr_read_data(stiger);
if ( NULL != data ) {
LDEBUG("file_partial_truncate_block : clz_decompress");
if (data->size != BLKSIZE) {
#ifdef LZO
uncompdata = lzo_decompress(data->data, data->size);
#else
uncompdata = clz_decompress(data->data, data->size);
#endif
memcpy(blockdata, uncompdata->data, offset);
comprfree(uncompdata);
} else {
memcpy(blockdata, data->data, offset);
}
}
} else {
dta = (QDTA *)data->data;
cachedata.data=s_malloc(dta->size);
memcpy(cachedata.data, dta->data, dta->size);
cachedata.size = dta->size;
memcpy(blockdata, cachedata.data, offset);
free(cachedata.data);
}
file_commit_block(blockdata, inobno, offsetfile);
DBTfree(data);
free(blockdata);
inuse = file_get_inuse(stiger);
if (NULL == inuse)
die_dataerr
("file_partial_truncate_block : unexpected block not found");
if (inuse->inuse == 1) {
loghash("file_partial_truncate_block : delete hash", stiger);
put_on_freelist(inuse);
delete_inuse(stiger);
} else {
if (inuse->inuse > 1)
inuse->inuse--;
file_update_inuse(stiger, inuse);
}
free(inuse);
free(stiger);
return;
}
unsigned long long file_read_block(unsigned long long blocknr,
const char *filename, char *blockdata,
unsigned long long inode)
{
unsigned long long ret = 0;
DBT *data = NULL;
DBT *decrypted = NULL;
DBT *cachedata;
unsigned char *stiger;
unsigned char *dtiger;
compr *uncompdata = NULL;
INOBNO inobno;
BLKCACHE *blk;
bool compressed = 1;
QDTA *dta;
#ifndef SHA3
word64 res[3];
#endif
FUNC;
inobno.inode = inode;
inobno.blocknr = blocknr;
data = try_block_cache(inode, blocknr, 0);
if (NULL != data) {
LDEBUG("file_read_block : block %llu - %llu found in cache", inode,
blocknr);
memcpy(blockdata, data->data, data->size);
ret = data->size;
DBTfree(data);
return (ret);
}
data = check_block_exists(inobno);
if (NULL == data) {
LDEBUG("check_block_exists : Nothing found for inode %llu - %llu",
inobno.inode, inobno.blocknr);
LDEBUG("DONE ret = %llu",ret);
return (ret);
}
// Not needed to copy this.
stiger = s_malloc(data->size);
memcpy(stiger, data->data, data->size);
DBTfree(data);
// First try the cache
get_moddb_lock();
data = search_memhash(dbdtaq, stiger, config->hashlen);
if (NULL == data) {
decrypted = file_tgr_read_data(stiger);
if (NULL != decrypted) {
LDEBUG
("file_read_block : found inode %llu - %llu file_io",
inobno.inode, inobno.blocknr);
} else {
cachedata =
search_memhash(blkcache, &inobno.inode,
sizeof(unsigned long long));
if (NULL != cachedata) {
blk = (BLKCACHE *) cachedata->data;
#ifdef SHA3
dtiger=sha_binhash(blk->blockdata, BLKSIZE);
#else
binhash(blk->blockdata, BLKSIZE,res);
dtiger=(unsigned char *)&res;
#endif
if (0 == memcmp(dtiger, stiger, config->hashlen)) {
decrypted = s_malloc(sizeof(DBT));
decrypted->data = s_malloc(BLKSIZE);
decrypted->size = BLKSIZE;
memcpy(decrypted->data, blk->blockdata, BLKSIZE);
compressed = 0;
}
#ifdef SHA3
free(dtiger);
#endif
DBTfree(cachedata);
}
}
} else {
decrypted = s_malloc(sizeof(DBT));
dta = (QDTA *) data->data;
decrypted->data = s_malloc(dta->size);
memcpy(decrypted->data, dta->data, dta->size);
decrypted->size = dta->size;
DBTfree(data);
}
release_moddb_lock();
if (decrypted->size > BLKSIZE)
die_dataerr("file_read_block : data has grown beyond blocksize %lu",
decrypted->size);
if (compressed && decrypted->size != BLKSIZE) {
#ifdef LZO
uncompdata = lzo_decompress(decrypted->data, decrypted->size);
#else
uncompdata = clz_decompress(decrypted->data, decrypted->size);
#endif
memcpy(blockdata, uncompdata->data, uncompdata->size);
ret = uncompdata->size;
comprfree(uncompdata);
} else {
memcpy(blockdata, decrypted->data, decrypted->size);
ret = decrypted->size;
}
DBTfree(decrypted);
free(stiger);
EFUNC;
return (ret);
}
