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); }