static int
fuse_readdir(const char* path, void* buf, fuse_fill_dir_t filler,
off_t offset, struct fuse_file_info* fi)
{
PRINTD("##readdir\n");
int dfp = _kern_open_dir(-1, path);
if (dfp < FSSH_B_OK)
return _ERR(dfp);
fssh_ssize_t entriesRead = 0;
struct fssh_stat f_st;
struct stat st;
char buffer[sizeof(fssh_dirent) + FSSH_B_FILE_NAME_LENGTH];
fssh_dirent* dirEntry = (fssh_dirent*)buffer;
while ((entriesRead = _kern_read_dir(dfp, dirEntry,
sizeof(buffer), 1)) == 1) {
fssh_memset(&st, 0, sizeof(st));
fssh_memset(&f_st, 0, sizeof(f_st));
fssh_status_t status = _kern_read_stat(dfp, dirEntry->d_name,
false, &f_st, sizeof(f_st));
if (status >= FSSH_B_OK) {
fromFsshStatToStat(&f_st, &st);
if (filler(buf, dirEntry->d_name, &st, 0))
break;
}
}
_kern_close(dfp);
//TODO: check _kern_close
return 0;
}
/*! Returns the writable block data for the requested blockNumber.
If \a cleared is true, the block is not read from disk; an empty block
is returned.
This is the only method to insert a block into a transaction. It makes
sure that the previous block contents are preserved in that case.
*/
static void*
get_writable_cached_block(block_cache* cache, fssh_off_t blockNumber, fssh_off_t base,
fssh_off_t length, int32_t transactionID, bool cleared)
{
TRACE(("get_writable_cached_block(blockNumber = %Ld, transaction = %d)\n",
blockNumber, transactionID));
if (blockNumber < 0 || blockNumber >= cache->max_blocks) {
fssh_panic("get_writable_cached_block: invalid block number %"
FSSH_B_PRIdOFF " (max %" FSSH_B_PRIdOFF ")", blockNumber,
cache->max_blocks - 1);
}
bool allocated;
cached_block* block = get_cached_block(cache, blockNumber, &allocated,
!cleared);
if (block == NULL)
return NULL;
block->discard = false;
// if there is no transaction support, we just return the current block
if (transactionID == -1) {
if (cleared)
fssh_memset(block->current_data, 0, cache->block_size);
block->is_dirty = true;
// mark the block as dirty
return block->current_data;
}
cache_transaction* transaction = block->transaction;
if (transaction != NULL && transaction->id != transactionID) {
// TODO: we have to wait here until the other transaction is done.
// Maybe we should even panic, since we can't prevent any deadlocks.
fssh_panic("get_writable_cached_block(): asked to get busy writable block (transaction %d)\n", (int)transaction->id);
put_cached_block(cache, block);
return NULL;
}
if (transaction == NULL && transactionID != -1) {
// get new transaction
transaction = lookup_transaction(cache, transactionID);
if (transaction == NULL) {
fssh_panic("get_writable_cached_block(): invalid transaction %d!\n",
(int)transactionID);
put_cached_block(cache, block);
return NULL;
}
if (!transaction->open) {
fssh_panic("get_writable_cached_block(): transaction already done!\n");
put_cached_block(cache, block);
return NULL;
}
block->transaction = transaction;
// attach the block to the transaction block list
block->transaction_next = transaction->first_block;
transaction->first_block = block;
transaction->num_blocks++;
}
bool wasUnchanged = block->original_data == NULL
|| block->previous_transaction != NULL;
if (!(allocated && cleared) && block->original_data == NULL) {
// we already have data, so we need to preserve it
block->original_data = cache->Allocate();
if (block->original_data == NULL) {
FATAL(("could not allocate original_data\n"));
put_cached_block(cache, block);
return NULL;
}
fssh_memcpy(block->original_data, block->current_data, cache->block_size);
}
if (block->parent_data == block->current_data) {
// remember any previous contents for the parent transaction
block->parent_data = cache->Allocate();
if (block->parent_data == NULL) {
// TODO: maybe we should just continue the current transaction in this case...
FATAL(("could not allocate parent\n"));
put_cached_block(cache, block);
return NULL;
}
fssh_memcpy(block->parent_data, block->current_data, cache->block_size);
transaction->sub_num_blocks++;
} else if (transaction != NULL && transaction->has_sub_transaction
&& block->parent_data == NULL && wasUnchanged)
transaction->sub_num_blocks++;
if (cleared)
fssh_memset(block->current_data, 0, cache->block_size);
block->is_dirty = true;
return block->current_data;
}
