BlockCache
void* cache = fTree->fStream->GetVolume()->BlockCache();
block_cache_put(fTree->fStream->GetVolume()->BlockCache(),
if (block_cache_make_writable(transaction.GetVolume()->BlockCache(),
block = fBlock = (uint8*)block_cache_get_writable(volume->BlockCache(),
block = fBlock = (uint8*)block_cache_get(volume->BlockCache(), newBlockNumber);
block_cache_discard(fVolume->BlockCache(), fVolume->ToBlock(run),
block_cache_put(fVolume->BlockCache(), fBlockNumber);
return block_cache_get_etc(fVolume->BlockCache(), block, (const void**)&fBlock);
fBlock = (uint8*)block_cache_get_empty(fVolume->BlockCache(),
return block_cache_get_writable_etc(fVolume->BlockCache(),
return block_cache_make_writable(fVolume->BlockCache(), fBlockNumber,
kprintf("block cache: %p\n", volume->BlockCache());
set_debug_variable("_cache", (addr_t)volume->BlockCache());
status = block_cache_sync_etc(fVolume->BlockCache(),
status = block_cache_sync_etc(fVolume->BlockCache(),
status = block_cache_sync_etc(fVolume->BlockCache(),
cache_add_transaction_listener(volume->BlockCache(), fTransaction->ID(),
cache_start_sub_transaction(fVolume->BlockCache(), fTransactionID);
fTransactionID = cache_start_transaction(fVolume->BlockCache());
cache_add_transaction_listener(fVolume->BlockCache(), fTransactionID,
int32 count = cache_blocks_in_transaction(fVolume->BlockCache(),
cache_abort_sub_transaction(fVolume->BlockCache(), fTransactionID);
cache_abort_transaction(fVolume->BlockCache(), fTransactionID);
cache_sync_transaction(fVolume->BlockCache(), fTransactionID);
return cache_blocks_in_sub_transaction(fVolume->BlockCache(),
return cache_blocks_in_main_transaction(fVolume->BlockCache(),
fVolume->BlockCache(), fTransactionID) < (int32)fLogSize) {
while (cache_next_block_in_transaction(fVolume->BlockCache(),
fTransactionID = cache_detach_sub_transaction(fVolume->BlockCache(),
cache_end_transaction(fVolume->BlockCache(), fTransactionID, NULL,
cache_sync_transaction(fVolume->BlockCache(), fTransactionID);
const void* data = block_cache_get(fVolume->BlockCache(),
block_cache_put(fVolume->BlockCache(), blockNumber + j);
fTransactionID = cache_detach_sub_transaction(fVolume->BlockCache(),
cache_end_transaction(fVolume->BlockCache(), fTransactionID,
void* cache = GetVolume()->BlockCache();
void* BlockCache() { return fBlockCache; }
block_cache_put(fVolume->BlockCache(), fBlockNumber);
fNode = (btrfs_stream*)block_cache_get(fVolume->BlockCache(), block);
fNode = (btrfs_stream*)block_cache_get_empty(fVolume->BlockCache(),
fNode = (btrfs_stream*)block_cache_get_writable(fVolume->BlockCache(),
return fBlock = (uint8*)block_cache_get(fVolume->BlockCache(), block);
fBlock = (uint8*)block_cache_get_empty(fVolume->BlockCache(),
fBlock = (uint8*)block_cache_get_writable(fVolume->BlockCache(),
block_cache_put(fVolume->BlockCache(), fBlockNumber);
return cache_has_block_in_transaction(fJournal->GetVolume()->BlockCache(),
cache_abort_transaction(fVolume->BlockCache(), fTransactionID);
cache_end_transaction(fVolume->BlockCache(), fTransactionID,
fTransactionID = cache_start_transaction(fVolume->BlockCache());
void* BlockCache() { return fBlockCache; }
block_cache_put(fVolume->BlockCache(), fBlockNumber);
return fBlock = (uint8 *)block_cache_get(fVolume->BlockCache(), block);
void* BlockCache() { return fBlockCache; }
return fBlock = (uint8 *)block_cache_get(fVolume->BlockCache(), block);
fBlock = (uint8*)block_cache_get_empty(fVolume->BlockCache(),
fBlock = (uint8*)block_cache_get_writable(fVolume->BlockCache(),
block_cache_put(fVolume->BlockCache(), fBlockNumber);
cache_add_transaction_listener(volume->BlockCache(),
fFilesystemBlockCache = volume->BlockCache();
fJournalBlockCache = volume->BlockCache();
fJournalBlockCache(jVolume->BlockCache()),
fFilesystemBlockCache(fsVolume->BlockCache()),
fFilesystemBlockCache = volume->BlockCache();
void* cache = GetVolume()->BlockCache();
cache_start_sub_transaction(fJournal->GetFilesystemVolume()->BlockCache(),
void* BlockCache() { return fBlockCache; }
Block::_SetTo(BlockCache *cache, uint64 number)
BlockCache *
BlockCache *GetCache() const;
status_t _SetTo(BlockCache *cache, uint64 number);
friend class BlockCache;
BlockCache *fCache;
BlockCache::GetBlock(Block *block)
BlockCache::GetBlock(uint64 number, Block **result)
BlockCache::PutBlock(Block *block)
BlockCache::_FindBlock(uint64 number)
BlockCache::_ReadBlock(uint64 number, Block **result)
BlockCache::_GetBlock(off_t number) const
BlockCache::_ReleaseBlock(off_t number, void *data) const
BlockCache::BlockCache()
BlockCache::~BlockCache()
BlockCache::Init(int device, uint64 blockCount, uint32 blockSize)
class BlockCache {
BlockCache();
~BlockCache();
BlockCache *
class BlockCache;
BlockCache *GetBlockCache() const;
BlockCache *fBlockCache;
fBlockCache = new(nothrow) BlockCache;
class BlockCache;
BlockCache *GetBlockCache() const { return fBlockCache; }
BlockCache *fBlockCache;
return block_cache_get_etc(fVolume->BlockCache(), block,
block_cache_put(fVolume->BlockCache(), fBlockNumber);
status = block_cache_get_etc(volume->BlockCache(),
block_cache_put(volume->BlockCache(), diskBlock);
void *BlockCache() {return fBlockCache; }
void *BlockCache() { return fFile; }
block_cache_put(fVolume->BlockCache(), fIndex);
block_cache_get(volume->BlockCache(), blockIndex), NULL);
block_cache_get_writable(volume->BlockCache(), blockIndex,
block_cache_get_empty(volume->BlockCache(), blockIndex,
error = block_cache_make_writable(fVolume->BlockCache(), fIndex,
block_cache_discard(GetVolume()->BlockCache(), blockIndex, 1);
status_t error = block_cache_sync(fVolume->BlockCache());
error = cache_end_transaction(fVolume->BlockCache(), fID, NULL, NULL);
cache_abort_transaction(fVolume->BlockCache(), fID);
block_cache_put(fVolume->BlockCache(),
info->data = block_cache_get(fVolume->BlockCache(), blockIndex);
block_cache_put(fVolume->BlockCache(),
fID = cache_start_transaction(fVolume->BlockCache());
inline void* BlockCache() const { return fBlockCache; }
return block_cache_sync(volume->BlockCache());