/* clear record */
void lnf_rec_clear(lnf_rec_t *rec) {
if (rec != NULL) {
bit_array_clear(rec->extensions_arr);
memset(rec->master_record, 0x0, sizeof(master_record_t));
}
}
void pmt_cache_set_dirty(UINT32 const pmt_idx, BOOL8 const is_dirty)
{
UINT32 page_idx = get_page(pmt_idx);
ASSERT(page_idx != NULL_PAGE_IDX);
if (is_dirty)
bit_array_set(cached_pmt_is_dirty, page_idx);
else
bit_array_clear(cached_pmt_is_dirty, page_idx);
}
void release_block_reservation(int block_offset, int blocks_used) {
int j;
sem_wait(BLOCK_BITMAP_LOCK);
for (j = 0; j < blocks_used; j++) bit_array_clear(SHM_BLOCK_BITMAP, block_offset + j);
sem_post(BLOCK_BITMAP_LOCK);
}
void keydb_unlock(int64_t pos) {
char key[1024] = "";
int hash_number;
sprintf(key, "%llu", pos); // turn pos into a string.
hash_number = get_hash_val(10, key); // 2^10 = 1024. See SHM_KEYDB_BITMAP.
sem_wait(KEYDB_LOCK);
bit_array_clear(SHM_KEYDB_BITMAP, hash_number);
sem_post(KEYDB_LOCK);
}
static inline void free_page(UINT32 const page_idx)
{
ASSERT(page_idx < NUM_PC_SUB_PAGES);
cached_pmt_idxes[page_idx] = NULL_PMT_IDX;
cached_pmt_timestamps[page_idx] = NULL_TIMESTAMP;
bit_array_clear(cached_pmt_is_dirty, page_idx);
if (last_page_idx == page_idx) {
last_page_idx = NULL_PAGE_IDX;
last_pmt_idx = NULL_PMT_IDX;
}
num_free_sub_pages++;
}
/* status of read and fill pre-prepared structure lnf_rec */
int lnf_read(lnf_file_t *lnf_file, lnf_rec_t *lnf_rec) {
//master_record_t *master_record;
int ret;
uint32_t map_id;
extension_map_t *map;
int i;
#ifdef COMPAT15
int v1_map_done = 0;
#endif
begin:
if (lnf_file->blk_record_remains == 0) {
/* all records in block have been processed, we are going to load nex block */
// get next data block from file
if (lnf_file->nffile) {
ret = ReadBlock(lnf_file->nffile);
lnf_file->processed_blocks++;
} else {
ret = NF_EOF; /* the firt file in the list */
}
switch (ret) {
case NF_CORRUPT:
return LNF_ERR_CORRUPT;
case NF_ERROR:
return LNF_ERR_READ;
case NF_EOF:
return LNF_EOF;
default:
// successfully read block
lnf_file->processed_bytes += ret;
}
/* block types to be skipped -> goto begin */
/* block types that are unknown -> return */
switch (lnf_file->nffile->block_header->id) {
case DATA_BLOCK_TYPE_1: /* old record type - nfdump 1.5 */
lnf_file->skipped_blocks++;
goto begin;
return LNF_ERR_COMPAT15;
break;
case DATA_BLOCK_TYPE_2: /* common record type - normally processed */
break;
case Large_BLOCK_Type:
lnf_file->skipped_blocks++;
goto begin;
break;
default:
lnf_file->skipped_blocks++;
return LNF_ERR_UNKBLOCK;
}
lnf_file->flow_record = lnf_file->nffile->buff_ptr;
lnf_file->blk_record_remains = lnf_file->nffile->block_header->NumRecords;
} /* reading block */
/* there are some records to process - we are going continue reading next record */
lnf_file->blk_record_remains--;
switch (lnf_file->flow_record->type) {
case ExporterRecordType:
case SamplerRecordype:
case ExporterInfoRecordType:
case ExporterStatRecordType:
case SamplerInfoRecordype:
/* just skip */
FLOW_RECORD_NEXT(lnf_file->flow_record);
goto begin;
break;
case ExtensionMapType:
map = (extension_map_t *)lnf_file->flow_record;
//Insert_Extension_Map(&instance->extension_map_list, map);
Insert_Extension_Map(lnf_file->extension_map_list, map);
FLOW_RECORD_NEXT(lnf_file->flow_record);
goto begin;
break;
case CommonRecordV0Type:
case CommonRecordType:
/* data record type - go ahead */
break;
default:
FLOW_RECORD_NEXT(lnf_file->flow_record);
return LNF_ERR_UNKREC;
}
/* we are sure that record is CommonRecordType */
map_id = lnf_file->flow_record->ext_map;
if ( map_id >= MAX_EXTENSION_MAPS ) {
FLOW_RECORD_NEXT(lnf_file->flow_record);
return LNF_ERR_EXTMAPB;
}
if ( lnf_file->extension_map_list->slot[map_id] == NULL ) {
FLOW_RECORD_NEXT(lnf_file->flow_record);
return LNF_ERR_EXTMAPM;
}
// changed in 1.6.8 - added exporter info
// ExpandRecord_v2( flow_record, extension_map_list.slot[map_id], master_record);
ExpandRecord_v2(lnf_file->flow_record, lnf_file->extension_map_list->slot[map_id], NULL, lnf_rec->master_record);
// update number of flows matching a given map
lnf_file->extension_map_list->slot[map_id]->ref_count++;
// Move pointer by number of bytes for netflow record
FLOW_RECORD_NEXT(lnf_file->flow_record);
/*
{
char *s;
PrintExtensionMap(instance->extension_map_list.slot[map_id]->map);
format_file_block_record(master_record, &s, 0);
printf("READ: %s\n", s);
}
*/
// processing map
//bit_array_clear(&lnf_file->extensions_arr);
bit_array_clear(lnf_rec->extensions_arr);
i = 0;
while (lnf_rec->master_record->map_ref->ex_id[i]) {
__bit_array_set(lnf_rec->extensions_arr, lnf_rec->master_record->map_ref->ex_id[i], 1);
i++;
}
// lnf_rec->extensions_arr = &(lnf_file->extensions_arr);
/* the record seems OK. We prepare hash reference with items */
// lnf_file->lnf_rec = lnf_rec; /* XXX temporary */
return LNF_OK;
} /* end of _readfnction */
void hash_write_unlock(int hash_number) {
sem_wait(HASHBUCKET_LOCK);
bit_array_clear(SHM_HASHBUCKET_BITMAP, hash_number);
sem_post(HASHBUCKET_LOCK);
}
