headers/libs/agg/agg_array.h

499

const T* block(unsigned nb) const { return m_blocks[nb]; }

headers/libs/agg/agg_path_storage.h

189

unsigned block = idx >> block_shift;

headers/libs/agg/agg_path_storage.h

191

T* pv = m_coord_blocks[block] + (offset << 1);

headers/libs/agg/agg_path_storage.h

194

m_cmd_blocks[block][offset] = (int8u)cmd;

headers/os/device/scsi.h

147

off_t block;

headers/os/interface/Font.h

111

inline bool Includes(const unicode_block& block) const;

headers/os/interface/Font.h

112

inline unicode_block operator&(const unicode_block& block) const;

headers/os/interface/Font.h

113

inline unicode_block operator|(const unicode_block& block) const;

headers/os/interface/Font.h

114

inline unicode_block& operator=(const unicode_block& block);

headers/os/interface/Font.h

115

inline bool operator==(const unicode_block& block) const;

headers/os/interface/Font.h

116

inline bool operator!=(const unicode_block& block) const;

headers/os/interface/Font.h

126

const unicode_block& block;

headers/os/interface/Font.h

360

unicode_block::Includes(const unicode_block& block) const

headers/os/interface/Font.h

362

return (fData[0] & block.fData[0]) == block.fData[0]

headers/os/interface/Font.h

363

&& (fData[1] & block.fData[1]) == block.fData[1];

headers/os/interface/Font.h

368

unicode_block::operator&(const unicode_block& block) const

headers/os/interface/Font.h

371

result.fData[0] = fData[0] & block.fData[0];

headers/os/interface/Font.h

372

result.fData[1] = fData[1] & block.fData[1];

headers/os/interface/Font.h

379

unicode_block::operator|(const unicode_block& block) const

headers/os/interface/Font.h

382

result.fData[0] = fData[0] | block.fData[0];

headers/os/interface/Font.h

383

result.fData[1] = fData[1] | block.fData[1];

headers/os/interface/Font.h

390

unicode_block::operator=(const unicode_block& block)

headers/os/interface/Font.h

392

fData[0] = block.fData[0];

headers/os/interface/Font.h

393

fData[1] = block.fData[1];

headers/os/interface/Font.h

400

unicode_block::operator==(const unicode_block& block) const

headers/os/interface/Font.h

402

return fData[0] == block.fData[0] && fData[1] == block.fData[1];

headers/os/interface/Font.h

407

unicode_block::operator!=(const unicode_block& block) const

headers/os/interface/Font.h

409

return fData[0] != block.fData[0] || fData[1] != block.fData[1];

headers/os/media/SoundPlayer.h

74

void Stop(bool block = true, bool flush = true);

headers/posix/unistd.h

501

extern void encrypt(char block[64], int edflag);

headers/private/debugger/model/TeamMemoryBlock.h

71

virtual void MemoryBlockRetrieved(TeamMemoryBlock* block);

headers/private/debugger/model/TeamMemoryBlock.h

73

virtual void MemoryBlockRetrievalFailed(TeamMemoryBlock* block,

headers/private/debugger/user_interface/util/UiUtils.h

64

TeamMemoryBlock* block,

headers/private/file_systems/QueryParser.h

66

# define QUERY_D(block)

headers/private/kernel/boot/FileMapDisk.h

21

off_t block;

headers/private/kernel/boot/FileMapDisk.h

37

void AddRun(off_t offset, off_t block, off_t len);

headers/private/kernel/heap.h

34

void deferred_free(void* block);

headers/private/shared/md5.h

37

MD5_u32plus block[16];

src/add-ons/accelerants/common/decode_edid.c

266

cta_data_block* block = (cta_data_block*)&((uint8*)raw)[i];

src/add-ons/accelerants/common/decode_edid.c

268

block, block->length + 1);

src/add-ons/accelerants/common/decode_edid.c

269

i += block->length + 1;

src/add-ons/kernel/bus_managers/random/yarrow_rng.cpp

56

extern void hash_block(const unsigned char *block, const unsigned int block_byte_size, unsigned char *md);

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1354

size_t block;

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1390

block = port->rd_size-port->was_read;

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1393

if (block > (to_read>>1)) { /* floats expand by factor 2 */

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1394

block = to_read>>1;

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1397

else if (block > to_read) {

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1398

block = to_read;

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1403

block, !B_HOST_IS_LENDIAN == !port->config.big_endian);

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1404

bytes_xferred = block * 2;

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1409

swap_copy((short *)data, (const short *)(port->rd_cur+port->was_read), block);

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1410

bytes_xferred = block;

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1416

memcpy(data, (void *)(port->rd_cur+port->was_read), block);

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1417

bytes_xferred = block;

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1420

port->was_read += block;

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1460

int block;

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1509

block = port->wr_size-port->was_written;

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1510

if (block > to_write) {

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1518

block = to_write;

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1520

else if (block < to_write) {

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1526

block, !B_HOST_IS_LENDIAN == !port->config.big_endian);

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1527

bytes_xferred = block * 2;

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1532

swap_copy((short *)(port->wr_cur+port->was_written), (const short *)data, block);

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1533

bytes_xferred = block;

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1539

memcpy((void *)(port->wr_cur+port->was_written), data, block);

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1540

bytes_xferred = block;

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1543

port->was_written += block;

src/add-ons/kernel/drivers/audio/cmedia/pcm.c

1551

to_write -= block;

src/add-ons/kernel/drivers/graphics/common/memory_manager.c

262

mem_block *block;

src/add-ons/kernel/drivers/graphics/common/memory_manager.c

278

block = &mem->heap[blockID];

src/add-ons/kernel/drivers/graphics/common/memory_manager.c

279

if (!block->allocated || block->tag != tag) {

src/add-ons/kernel/drivers/graphics/common/memory_manager.c

284

freeblock(mem, block);

src/add-ons/kernel/drivers/graphics/common/memory_manager.c

56

merge(mem_info *mem, mem_block *block)

src/add-ons/kernel/drivers/graphics/common/memory_manager.c

58

mem_block *next = block->next;

src/add-ons/kernel/drivers/graphics/common/memory_manager.c

60

block->size += next->size;

src/add-ons/kernel/drivers/graphics/common/memory_manager.c

63

next->next->prev = block;

src/add-ons/kernel/drivers/graphics/common/memory_manager.c

65

block->next = next->next;

src/add-ons/kernel/drivers/graphics/common/memory_manager.c

74

freeblock(mem_info *mem, mem_block *block)

src/add-ons/kernel/drivers/graphics/common/memory_manager.c

78

block->allocated = false;

src/add-ons/kernel/drivers/graphics/common/memory_manager.c

79

prev = block->prev;

src/add-ons/kernel/drivers/graphics/common/memory_manager.c

82

block = prev;

src/add-ons/kernel/drivers/graphics/common/memory_manager.c

86

next = block->next;

src/add-ons/kernel/drivers/graphics/common/memory_manager.c

89

merge(mem, block);

src/add-ons/kernel/drivers/graphics/common/memory_manager.c

91

return block;

src/add-ons/kernel/file_systems/bfs/BPlusTree.cpp

455

uint8* block = NULL;

src/add-ons/kernel/file_systems/bfs/BPlusTree.cpp

458

block = fBlock;

src/add-ons/kernel/file_systems/bfs/BPlusTree.cpp

465

block = fBlock = (uint8*)block_cache_get_writable(volume->BlockCache(),

src/add-ons/kernel/file_systems/bfs/BPlusTree.cpp

469

block = fBlock = (uint8*)block_cache_get(volume->BlockCache(), newBlockNumber);

src/add-ons/kernel/file_systems/bfs/BPlusTree.cpp

481

block = fBlock;

src/add-ons/kernel/file_systems/bfs/BPlusTree.cpp

491

if (block != NULL) {

src/add-ons/kernel/file_systems/bfs/BPlusTree.cpp

494

fNode = (bplustree_node*)(block + offset

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

1158

for (int32 block = run.Start(); block < end; block++) {

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

1159

if (cached.SetTo(group, block / bitsPerBlock) < B_OK)

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

1162

if (cached.IsUsed(block % bitsPerBlock))

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

1252

for (uint32 block = 0; block < group.NumBlocks(); block++) {

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

1255

if (cached.SetToWritable(transaction, group, block) != B_OK)

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

1284

for (uint32 block = 0; block < group.NumBlocks(); block++) {

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

1285

if (cached.SetTo(group, block) < B_OK) {

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

1286

panic("setting group block %d failed\n", (int)block);

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

132

BlockChange(const char* label, int32 block, uint32 oldData, uint32 newData)

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

134

fBlock(block),

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

1381

for (uint32 block = firstBlock; block < group.NumBitmapBlocks(); block++) {

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

1382

cached.SetTo(group, block);

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

1436

off_t block = start;

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

1451

blockOffset++, length--, block++) {

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

1459

*firstError = block;

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

1604

off_t block = parse_expression(argv[2]);

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

1616

if (block >= first && block <= last) {

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

1624

if (block >= first && block <= last) {

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

176

inline bool IsUsed(uint16 block);

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

179

status_t SetTo(AllocationGroup& group, uint16 block);

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

181

uint16 block);

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

231

AllocationBlock::SetTo(AllocationGroup& group, uint16 block)

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

236

if ((block + 1) * fNumBits > group.NumBits())

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

242

return CachedBlock::SetTo(group.Start() + block);

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

248

uint16 block)

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

253

if ((block + 1) * fNumBits > group.NumBits())

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

259

return CachedBlock::SetToWritable(transaction, group.Start() + block);

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

264

AllocationBlock::IsUsed(uint16 block)

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

266

if (block > fNumBits)

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

270

return Chunk(block >> 5) & HOST_ENDIAN_TO_BFS_INT32(1UL << (block % 32));

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

310

int32 block = start >> 5;

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

317

T(BlockChange("b-alloc", block, Chunk(block),

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

318

Block(block) | HOST_ENDIAN_TO_BFS_INT32(mask)));

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

322

if (HOST_ENDIAN_TO_BFS_INT32(mask) & ((uint32*)fBlock)[block]) {

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

329

Chunk(block++) |= HOST_ENDIAN_TO_BFS_INT32(mask);

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

346

int32 block = start >> 5;

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

353

T(BlockChange("b-free", block, Chunk(block),

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

354

Block(block) & HOST_ENDIAN_TO_BFS_INT32(~mask)));

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

356

Chunk(block++) &= HOST_ENDIAN_TO_BFS_INT32(~mask);

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

440

uint32 block = start / bitsPerBlock;

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

446

if (cached.SetToWritable(transaction, *this, block) < B_OK) {

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

459

block++;

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

501

uint32 block = start / bitsPerBlock;

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

507

if (cached.SetToWritable(transaction, *this, block) < B_OK)

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

510

T(Block("free-1", block, cached.Block(), volume->BlockSize()));

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

519

T(Block("free-2", block, cached.Block(), volume->BlockSize()));

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

520

block++;

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

909

uint32 block = start / bitsPerFullBlock;

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

923

for (; block <= lastBlock; block++) {

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

924

if (cached.SetTo(group, block) < B_OK)

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

927

T(Block("alloc-in", group.Start() + block, cached.Block(),

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

931

if (block == lastBlock)

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

969

block = lastBlock + 1;

src/add-ons/kernel/file_systems/bfs/BlockAllocator.cpp

982

T(Block("alloc-out", block, cached.Block(),

src/add-ons/kernel/file_systems/bfs/CachedBlock.h

110

CachedBlock::SetTo(off_t block)

src/add-ons/kernel/file_systems/bfs/CachedBlock.h

113

fBlockNumber = block;

src/add-ons/kernel/file_systems/bfs/CachedBlock.h

114

return block_cache_get_etc(fVolume->BlockCache(), block, (const void**)&fBlock);

src/add-ons/kernel/file_systems/bfs/CachedBlock.h

126

CachedBlock::SetToWritable(Transaction& transaction, off_t block, bool empty)

src/add-ons/kernel/file_systems/bfs/CachedBlock.h

129

fBlockNumber = block;

src/add-ons/kernel/file_systems/bfs/CachedBlock.h

133

block, transaction.ID());

src/add-ons/kernel/file_systems/bfs/CachedBlock.h

138

block, transaction.ID(), (void**)&fBlock);

src/add-ons/kernel/file_systems/bfs/CachedBlock.h

33

inline status_t SetTo(off_t block);

src/add-ons/kernel/file_systems/bfs/CachedBlock.h

36

off_t block, bool empty = false);

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

123

off_t block = 0;

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

129

if (cached.IsUsed(k) != _CheckBitmapIsUsedAt(block)) {

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

130

dprintf("differ block %lld (should be %d)\n", block,

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

131

_CheckBitmapIsUsedAt(block));

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

133

block++;

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

440

CheckVisitor::_CheckBitmapIsUsedAt(off_t block) const

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

443

uint32 index = block / 32; // 32bit resolution

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

448

& (1UL << (block & 0x1f));

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

453

CheckVisitor::_SetCheckBitmapAt(off_t block)

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

456

uint32 index = block / 32; // 32bit resolution

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

460

fCheckBitmap[index] |= HOST_ENDIAN_TO_BFS_INT32(1UL << (block & 0x1f));

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

514

off_t block = GetVolume()->ToBlock(data->indirect);

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

517

status = cached.SetTo(block + i);

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

626

off_t block = start;

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

628

while (block < end) {

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

630

status = allocator.CheckBlocks(block, end - block, true, &firstMissing);

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

651

block = afterLastMissing;

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

657

for (block = start; block < end; block++) {

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

658

if (_CheckBitmapIsUsedAt(block)) {

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

660

firstSet = block;

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

669

firstSet, block - 1));

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

672

_SetCheckBitmapAt(block);

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

68

for (off_t block = GetVolume()->ToBlock(GetVolume()->Log())

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

69

+ GetVolume()->Log().Length(); block-- > 0;) {

src/add-ons/kernel/file_systems/bfs/CheckVisitor.cpp

70

_SetCheckBitmapAt(block);

src/add-ons/kernel/file_systems/bfs/CheckVisitor.h

55

bool _CheckBitmapIsUsedAt(off_t block) const;

src/add-ons/kernel/file_systems/bfs/CheckVisitor.h

56

void _SetCheckBitmapAt(off_t block);

src/add-ons/kernel/file_systems/bfs/Debug.cpp

279

bool block = false;

src/add-ons/kernel/file_systems/bfs/Debug.cpp

281

block = true;

src/add-ons/kernel/file_systems/bfs/Debug.cpp

283

if (argc != 2 + (block ? 1 : 0) || !strcmp(argv[1], "--help")) {

src/add-ons/kernel/file_systems/bfs/Debug.cpp

292

if (block)

src/add-ons/kernel/file_systems/bfs/Inode.cpp

1523

off_t block = fVolume->ToBlock(data->indirect);

src/add-ons/kernel/file_systems/bfs/Inode.cpp

1526

status_t status = cached.SetTo(block + i);

src/add-ons/kernel/file_systems/bfs/Inode.cpp

1707

off_t block = fVolume->ToBlock(run);

src/add-ons/kernel/file_systems/bfs/Inode.cpp

1710

status = cached.SetToWritable(transaction, block + i, true);

src/add-ons/kernel/file_systems/bfs/Inode.cpp

1775

off_t block;

src/add-ons/kernel/file_systems/bfs/Inode.cpp

1793

block = fVolume->ToBlock(data->indirect);

src/add-ons/kernel/file_systems/bfs/Inode.cpp

1798

status = cached.SetTo(block + i);

src/add-ons/kernel/file_systems/bfs/Inode.cpp

1899

uint32 block = indirectIndex / runsPerBlock;

src/add-ons/kernel/file_systems/bfs/Inode.cpp

1900

if (block >= doubleIndirectBlockLength)

src/add-ons/kernel/file_systems/bfs/Inode.cpp

1904

data->double_indirect) + block);

src/add-ons/kernel/file_systems/bfs/Inode.cpp

2278

off_t block = fVolume->ToBlock(data->indirect);

src/add-ons/kernel/file_systems/bfs/Inode.cpp

2282

status = cached.SetToWritable(transaction, block + i);

src/add-ons/kernel/file_systems/bfs/Inode.cpp

2470

off_t block = fVolume->ToBlock(data->indirect);

src/add-ons/kernel/file_systems/bfs/Inode.cpp

2474

status = cached.SetTo(block + j);

src/add-ons/kernel/file_systems/bfs/Inode.cpp

2510

block = fVolume->ToBlock(indirectRuns[k]);

src/add-ons/kernel/file_systems/bfs/Inode.cpp

2512

status = directCached.SetTo(block + j);

src/add-ons/kernel/file_systems/bfs/Journal.h

177

void* block = block_cache_get_empty(cache, blockNumber + i,

src/add-ons/kernel/file_systems/bfs/Journal.h

179

if (block == NULL)

src/add-ons/kernel/file_systems/bfs/Journal.h

182

memcpy(block, buffer, blockSize);

src/add-ons/kernel/file_systems/bfs/Volume.cpp

161

Volume::IsValidInodeBlock(off_t block) const

src/add-ons/kernel/file_systems/bfs/Volume.cpp

163

return block > fSuperBlock.LogEnd() && block < NumBlocks();

src/add-ons/kernel/file_systems/bfs/Volume.cpp

346

Volume::ToBlockRun(off_t block) const

src/add-ons/kernel/file_systems/bfs/Volume.cpp

350

block >> AllocationGroupShift());

src/add-ons/kernel/file_systems/bfs/Volume.cpp

352

block & ((1LL << AllocationGroupShift()) - 1));

src/add-ons/kernel/file_systems/bfs/Volume.h

45

bool IsValidInodeBlock(off_t block) const;

src/add-ons/kernel/file_systems/bfs/Volume.h

90

block_run ToBlockRun(off_t block) const;

src/add-ons/kernel/file_systems/bfs/Volume.h

95

off_t ToVnode(off_t block) const { return block; }

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

331

BTree::Path::SetNode(off_t block, int slot)

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

333

Node node(fTree->SystemVolume(), block);

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

35

BTree::Node::Node(Volume* volume, off_t block)

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

42

SetTo(block);

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

436

fsblock_t block;

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

437

status = fTree->SystemVolume()->GetNewBlock(address, block);

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

445

fNodes[level]->SetToWritable(block, transaction.ID(), true);

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

63

BTree::Node::SetTo(off_t block)

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

66

fBlockNumber = block;

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

67

fNode = (btrfs_stream*)block_cache_get(fVolume->BlockCache(), block);

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

72

BTree::Node::SetToWritable(off_t block, int32 transactionId, bool empty)

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

75

fBlockNumber = block;

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

79

block, transactionId);

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

82

block, transactionId);

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

841

BTree::SetRoot(off_t logical, fsblock_t* block)

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

843

if (block != NULL) {

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

844

fRootBlock = *block;

src/add-ons/kernel/file_systems/btrfs/BTree.h

101

status_t SetRoot(off_t logical, fsblock_t* block);

src/add-ons/kernel/file_systems/btrfs/BTree.h

136

Node(Volume* volume, off_t block);

src/add-ons/kernel/file_systems/btrfs/BTree.h

171

void SetTo(off_t block);

src/add-ons/kernel/file_systems/btrfs/BTree.h

172

void SetToWritable(off_t block, int32 transactionId, bool empty);

src/add-ons/kernel/file_systems/btrfs/BTree.h

228

Node* SetNode(off_t block, int slot);

src/add-ons/kernel/file_systems/btrfs/CachedBlock.h

104

CachedBlock::SetTo(off_t block)

src/add-ons/kernel/file_systems/btrfs/CachedBlock.h

107

fBlockNumber = block;

src/add-ons/kernel/file_systems/btrfs/CachedBlock.h

108

return fBlock = (uint8*)block_cache_get(fVolume->BlockCache(), block);

src/add-ons/kernel/file_systems/btrfs/CachedBlock.h

113

CachedBlock::SetToWritable(off_t block, int32 transactionId, bool empty)

src/add-ons/kernel/file_systems/btrfs/CachedBlock.h

116

fBlockNumber = block;

src/add-ons/kernel/file_systems/btrfs/CachedBlock.h

120

block, transactionId);

src/add-ons/kernel/file_systems/btrfs/CachedBlock.h

123

block, transactionId);

src/add-ons/kernel/file_systems/btrfs/CachedBlock.h

26

CachedBlock(Volume* volume, off_t block);

src/add-ons/kernel/file_systems/btrfs/CachedBlock.h

32

const uint8* SetTo(off_t block);

src/add-ons/kernel/file_systems/btrfs/CachedBlock.h

33

uint8* SetToWritable(off_t block, int32 transactionId,

src/add-ons/kernel/file_systems/btrfs/CachedBlock.h

68

CachedBlock::CachedBlock(Volume* volume, off_t block)

src/add-ons/kernel/file_systems/btrfs/CachedBlock.h

75

SetTo(block);

src/add-ons/kernel/file_systems/btrfs/Volume.cpp

464

const uint8* block = cached.SetTo(BTRFS_SUPER_BLOCK_OFFSET / fBlockSize);

src/add-ons/kernel/file_systems/btrfs/Volume.cpp

466

if (block == NULL)

src/add-ons/kernel/file_systems/btrfs/Volume.cpp

469

memcpy(&fSuperBlock, block + BTRFS_SUPER_BLOCK_OFFSET % fBlockSize,

src/add-ons/kernel/file_systems/exfat/CachedBlock.h

17

CachedBlock(Volume* volume, off_t block);

src/add-ons/kernel/file_systems/exfat/CachedBlock.h

23

const uint8* SetTo(off_t block);

src/add-ons/kernel/file_systems/exfat/CachedBlock.h

54

CachedBlock::CachedBlock(Volume* volume, off_t block)

src/add-ons/kernel/file_systems/exfat/CachedBlock.h

60

SetTo(block);

src/add-ons/kernel/file_systems/exfat/CachedBlock.h

89

CachedBlock::SetTo(off_t block)

src/add-ons/kernel/file_systems/exfat/CachedBlock.h

92

fBlockNumber = block;

src/add-ons/kernel/file_systems/exfat/CachedBlock.h

93

return fBlock = (uint8 *)block_cache_get(fVolume->BlockCache(), block);

src/add-ons/kernel/file_systems/exfat/DataStream.cpp

54

fsblock_t block;

src/add-ons/kernel/file_systems/exfat/DataStream.cpp

55

if (fVolume->ClusterToBlock(cluster, block) != B_OK)

src/add-ons/kernel/file_systems/exfat/DataStream.cpp

57

physical = block * kBlockSize + offset;

src/add-ons/kernel/file_systems/exfat/DirectoryIterator.cpp

272

fsblock_t block;

src/add-ons/kernel/file_systems/exfat/DirectoryIterator.cpp

273

if (fInode->GetVolume()->ClusterToBlock(fCluster, block) != B_OK)

src/add-ons/kernel/file_systems/exfat/DirectoryIterator.cpp

275

block += (fOffset / fInode->GetVolume()->EntriesPerBlock())

src/add-ons/kernel/file_systems/exfat/DirectoryIterator.cpp

278

block);

src/add-ons/kernel/file_systems/exfat/DirectoryIterator.cpp

279

fCurrent = (struct exfat_entry*)fBlock.SetTo(block)

src/add-ons/kernel/file_systems/exfat/DirectoryIterator.cpp

282

fsblock_t block;

src/add-ons/kernel/file_systems/exfat/DirectoryIterator.cpp

288

if (fInode->GetVolume()->ClusterToBlock(fCluster, block) != B_OK)

src/add-ons/kernel/file_systems/exfat/DirectoryIterator.cpp

291

block = fBlock.BlockNumber() + 1;

src/add-ons/kernel/file_systems/exfat/DirectoryIterator.cpp

293

TRACE("DirectoryIterator::_NextEntry() block %" B_PRIu64 "\n", block);

src/add-ons/kernel/file_systems/exfat/DirectoryIterator.cpp

294

fCurrent = (struct exfat_entry*)fBlock.SetTo(block);

src/add-ons/kernel/file_systems/exfat/Volume.cpp

235

const uint8* block = cached.SetTo(EXFAT_SUPER_BLOCK_OFFSET / fBlockSize);

src/add-ons/kernel/file_systems/exfat/Volume.cpp

237

if (block == NULL)

src/add-ons/kernel/file_systems/exfat/Volume.cpp

240

memcpy(&fSuperBlock, block + EXFAT_SUPER_BLOCK_OFFSET % fBlockSize,

src/add-ons/kernel/file_systems/exfat/Volume.cpp

248

Volume::ClusterToBlock(cluster_t cluster, fsblock_t &block)

src/add-ons/kernel/file_systems/exfat/Volume.cpp

254

block = ((fsblock_t)(cluster - EXFAT_FIRST_DATA_CLUSTER)

src/add-ons/kernel/file_systems/exfat/Volume.cpp

260

block, SuperBlock().FirstFatBlock());

src/add-ons/kernel/file_systems/exfat/Volume.cpp

269

CachedBlock block(this);

src/add-ons/kernel/file_systems/exfat/Volume.cpp

272

cluster_t *cluster = (cluster_t *)block.SetTo(blockNum);

src/add-ons/kernel/file_systems/exfat/Volume.h

137

fsblock_t &block);

src/add-ons/kernel/file_systems/ext2/BitmapBlock.cpp

44

BitmapBlock::SetTo(off_t block)

src/add-ons/kernel/file_systems/ext2/BitmapBlock.cpp

47

fReadOnlyData = (uint32*)CachedBlock::SetTo(block);

src/add-ons/kernel/file_systems/ext2/BitmapBlock.cpp

54

BitmapBlock::SetToWritable(Transaction& transaction, off_t block, bool empty)

src/add-ons/kernel/file_systems/ext2/BitmapBlock.cpp

57

fData = (uint32*)CachedBlock::SetToWritable(transaction, block, empty);

src/add-ons/kernel/file_systems/ext2/BitmapBlock.h

20

bool SetTo(off_t block);

src/add-ons/kernel/file_systems/ext2/BitmapBlock.h

22

off_t block, bool empty = false);

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

179

BitmapBlock block(fVolume, fNumBits);

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

181

if (!block.SetTo(fBitmapBlock))

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

184

if (verify && !_VerifyBlockBitmapChecksum(block)) {

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

195

block.FindNextUnmarked(start);

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

196

ASSERT(block.CheckMarked(end, start - end));

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

199

if (start != block.NumBits()) {

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

200

block.FindNextMarked(end);

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

202

ASSERT(block.CheckUnmarked(fLargestStart, fLargestLength));

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

235

BitmapBlock block(fVolume, fNumBits);

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

237

if (!block.SetToWritable(transaction, fBitmapBlock))

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

242

ASSERT(block.CheckUnmarked(fLargestStart, fLargestLength));

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

244

if (!block.Mark(start, length)) {

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

252

_SetBlockBitmapChecksum(block);

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

282

ASSERT(block.CheckUnmarked(fLargestStart, fLargestLength));

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

285

block.FindLargestUnmarkedRange(fLargestStart, fLargestLength);

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

286

ASSERT(block.CheckUnmarked(fLargestStart, fLargestLength));

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

310

BitmapBlock block(fVolume, fNumBits);

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

312

if (!block.SetToWritable(transaction, fBitmapBlock))

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

317

ASSERT(block.CheckUnmarked(fLargestStart, fLargestLength));

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

319

if (!block.Unmark(start, length)) {

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

338

block.FindNextMarked(newEnd);

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

341

block.FindPreviousMarked(newStart);

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

352

ASSERT(block.CheckUnmarked(fLargestStart, fLargestLength));

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

356

_SetBlockBitmapChecksum(block);

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

526

AllocationBlockGroup::_SetBlockBitmapChecksum(BitmapBlock& block)

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

529

uint32 checksum = block.Checksum(fVolume->BlocksPerGroup());

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

540

AllocationBlockGroup::_VerifyBlockBitmapChecksum(BitmapBlock& block) {

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

542

uint32 checksum = block.Checksum(fVolume->BlocksPerGroup());

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

66

void _SetBlockBitmapChecksum(BitmapBlock& block);

src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp

67

bool _VerifyBlockBitmapChecksum(BitmapBlock& block);

src/add-ons/kernel/file_systems/ext2/CachedBlock.h

101

fBlockNumber = block;

src/add-ons/kernel/file_systems/ext2/CachedBlock.h

102

return fBlock = (uint8 *)block_cache_get(fVolume->BlockCache(), block);

src/add-ons/kernel/file_systems/ext2/CachedBlock.h

107

CachedBlock::SetToWritable(Transaction& transaction, off_t block, bool empty)

src/add-ons/kernel/file_systems/ext2/CachedBlock.h

109

return _SetToWritableEtc(transaction.ID(), block, empty);

src/add-ons/kernel/file_systems/ext2/CachedBlock.h

114

CachedBlock::SetToWritableWithoutTransaction(off_t block, bool empty)

src/add-ons/kernel/file_systems/ext2/CachedBlock.h

116

return _SetToWritableEtc((int32)-1, block, empty);

src/add-ons/kernel/file_systems/ext2/CachedBlock.h

120

CachedBlock::_SetToWritableEtc(int32 transaction, off_t block, bool empty)

src/add-ons/kernel/file_systems/ext2/CachedBlock.h

123

fBlockNumber = block;

src/add-ons/kernel/file_systems/ext2/CachedBlock.h

127

block, transaction);

src/add-ons/kernel/file_systems/ext2/CachedBlock.h

130

block, transaction);

src/add-ons/kernel/file_systems/ext2/CachedBlock.h

19

CachedBlock(Volume* volume, off_t block);

src/add-ons/kernel/file_systems/ext2/CachedBlock.h

25

const uint8* SetTo(off_t block);

src/add-ons/kernel/file_systems/ext2/CachedBlock.h

27

off_t block, bool empty = false);

src/add-ons/kernel/file_systems/ext2/CachedBlock.h

28

uint8* SetToWritableWithoutTransaction(off_t block,

src/add-ons/kernel/file_systems/ext2/CachedBlock.h

39

uint8* _SetToWritableEtc(int32 transaction, off_t block,

src/add-ons/kernel/file_systems/ext2/CachedBlock.h

63

CachedBlock::CachedBlock(Volume* volume, off_t block)

src/add-ons/kernel/file_systems/ext2/CachedBlock.h

69

SetTo(block);

src/add-ons/kernel/file_systems/ext2/CachedBlock.h

98

CachedBlock::SetTo(off_t block)

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

108

block = 0;

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

114

block = B_LENDIAN_TO_HOST_INT32(

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

118

uint32 nextBlock = block;

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

125

ASSERT(block != 0);

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

138

block = 0;

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

148

block = 0;

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

154

block = B_LENDIAN_TO_HOST_INT32(

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

158

uint32 nextBlock = block;

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

166

ASSERT(block != 0);

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

174

block, _count != NULL ? *_count : 1);

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

428

DataStream::_AddBlocks(Transaction& transaction, uint32* block, off_t _count)

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

439

*(block++) = B_HOST_TO_LENDIAN_INT32(blockNum);

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

450

DataStream::_AddBlocks(Transaction& transaction, uint32* block, off_t start,

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

458

status_t status = _PrepareBlock(transaction, block, blockNum, clear);

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

56

DataStream::FindBlock(off_t offset, fsblock_t& block, uint32 *_count)

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

608

DataStream::_MarkBlockForRemoval(Transaction& transaction, uint32* block)

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

612

"): free start: %" B_PRIu32 ", free count: %" B_PRIu32 "\n", block,

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

613

B_LENDIAN_TO_HOST_INT32(*block), fFreeStart, fFreeCount);

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

614

uint32 blockNum = B_LENDIAN_TO_HOST_INT32(*block);

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

615

*block = 0;

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

636

DataStream::_FreeBlocks(Transaction& transaction, uint32* block, uint32 _count)

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

639

TRACE("DataStream::_FreeBlocks(%p, %" B_PRIu32 ")\n", block, count);

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

642

status_t status = _MarkBlockForRemoval(transaction, block);

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

646

block++;

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

657

DataStream::_FreeBlocks(Transaction& transaction, uint32* block, off_t start,

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

662

", %c, %d)\n", block, start, end, freeParent ? 't' : 'f', recursion);

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

664

uint32 blockNum = B_LENDIAN_TO_HOST_INT32(*block);

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

667

status_t status = _MarkBlockForRemoval(transaction, block);

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

70

block = B_LENDIAN_TO_HOST_INT32(fStream->direct[index]);

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

71

ASSERT(block != 0);

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

74

uint32 nextBlock = block;

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

87

block = B_LENDIAN_TO_HOST_INT32(indirectBlocks[index]);

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

88

ASSERT(block != 0);

src/add-ons/kernel/file_systems/ext2/DataStream.cpp

91

uint32 nextBlock = block;

src/add-ons/kernel/file_systems/ext2/DataStream.h

26

status_t FindBlock(off_t offset, fsblock_t& block,

src/add-ons/kernel/file_systems/ext2/DataStream.h

34

status_t _GetBlock(Transaction& transaction, uint32& block);

src/add-ons/kernel/file_systems/ext2/DataStream.h

38

status_t _AddBlocks(Transaction& transaction, uint32* block,

src/add-ons/kernel/file_systems/ext2/DataStream.h

40

status_t _AddBlocks(Transaction& transaction, uint32* block,

src/add-ons/kernel/file_systems/ext2/DataStream.h

54

uint32* block);

src/add-ons/kernel/file_systems/ext2/DataStream.h

56

status_t _FreeBlocks(Transaction& transaction, uint32* block,

src/add-ons/kernel/file_systems/ext2/DataStream.h

58

status_t _FreeBlocks(Transaction& transaction, uint32* block,

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

102

ASSERT(_CheckBlock(block) == B_OK);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

106

const ext2_dir_entry* entry = (const ext2_dir_entry*)&block[fDisplacement];

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

167

const uint8* block = cached.SetTo(fPhysicalBlock);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

168

if (block == NULL)

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

171

ASSERT(_CheckBlock(block) == B_OK);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

173

entry = (ext2_dir_entry*)(block + fDisplacement);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

208

block = cached.SetTo(fPhysicalBlock);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

209

if (block == NULL)

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

211

ASSERT(_CheckBlock(block) == B_OK);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

219

entry = (ext2_dir_entry*)(block + fDisplacement);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

357

uint8* block = cached.SetToWritable(transaction, fPhysicalBlock);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

361

previousEntry = (ext2_dir_entry*)&block[fDisplacement];

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

376

dirEntry = (ext2_dir_entry*)&block[fDisplacement];

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

377

memcpy(&block[fPreviousDisplacement], &block[fDisplacement],

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

383

fDirectory->SetDirEntryChecksum(block);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

385

ASSERT(_CheckBlock(block) == B_OK);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

396

dirEntry = (ext2_dir_entry*)&block[fDisplacement];

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

408

previousEntry = (ext2_dir_entry*)&block[fPreviousDisplacement];

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

409

dirEntry = (ext2_dir_entry*)&block[fDisplacement];

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

413

memset(&block[fDisplacement], 0,

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

416

fDirectory->SetDirEntryChecksum(block);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

418

ASSERT(_CheckBlock(block) == B_OK);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

430

uint8* block = cached.SetToWritable(transaction, fPhysicalBlock);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

431

if (block == NULL)

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

434

ext2_dir_entry* dirEntry = (ext2_dir_entry*)&block[fDisplacement];

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

438

fDirectory->SetDirEntryChecksum(block);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

440

ASSERT(_CheckBlock(block) == B_OK);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

452

const uint8* block = cached.SetTo(fPhysicalBlock);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

454

ASSERT(_CheckBlock(block) == B_OK);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

465

dirEntry = (ext2_dir_entry*)&block[pos];

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

466

if (!_CheckDirEntry(dirEntry, block)) {

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

514

uint8* block = cached.SetToWritable(transaction, fPhysicalBlock);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

515

if (block == NULL)

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

518

ext2_dir_entry* dirEntry = (ext2_dir_entry*)&block[pos];

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

524

dirEntry = (ext2_dir_entry*)&block[pos + newLength];

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

534

fDirectory->SetDirEntryChecksum(block);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

536

ASSERT(_CheckBlock(block) == B_OK);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

884

DirectoryIterator::_HTreeEntryTail(uint8* block, uint16 offset) const

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

886

HTreeEntry* entries = (HTreeEntry*)block;

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

890

TRACE("DirectoryIterator::_HTreeEntryTail() %p %p\n", block, &entries[firstEntry + limit]);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

896

DirectoryIterator::_HTreeRootChecksum(uint8* block, uint16 offset, uint16 count) const

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

903

checksum = calculate_crc32c(checksum, block,

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

914

DirectoryIterator::_SetHTreeEntryChecksum(uint8* block, uint16 offset, uint16 count)

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

918

ext2_htree_tail* tail = _HTreeEntryTail(block, offset);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

920

tail->checksum = _HTreeRootChecksum(block, offset, count);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

98

const uint8* block = cached.SetTo(fPhysicalBlock);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp

99

if (block == NULL)

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.h

71

ext2_dir_entry_tail* _DirEntryTail(uint8* block) const;

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.h

72

uint32 _Checksum(uint8* block) const;

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.h

73

void _SetDirEntryChecksum(uint8* block);

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.h

75

ext2_htree_tail* _HTreeEntryTail(uint8* block, uint16 offset) const;

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.h

76

uint32 _HTreeRootChecksum(uint8* block, uint16 offset, uint16 count) const;

src/add-ons/kernel/file_systems/ext2/DirectoryIterator.h

77

void _SetHTreeEntryChecksum(uint8* block, uint16 offset, uint16 count);

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

116

block = 0;

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

134

block = 0;

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

143

block = extent.PhysicalBlock() + diff;

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

148

"\n", offset, block, _count != NULL ? *_count : 1);

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

428

fsblock_t block = last.PhysicalBlock() + last.Length() - length;

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

429

TRACE("Shrink() free block %" B_PRIu64 " length %d\n", block,

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

431

status = fVolume->FreeBlocks(transaction, block, length);

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

498

ExtentStream::_Check(ext2_extent_stream *stream, fileblock_t &block)

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

507

if (entry.LogicalBlock() < block) {

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

509

"\n", i, block, entry.LogicalBlock());

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

51

ExtentStream::FindBlock(off_t offset, fsblock_t& block, uint32 *_count)

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

512

block = entry.LogicalBlock() + entry.Length();

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

520

if (index.LogicalBlock() < block) {

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

522

"\n", i, block, index.LogicalBlock());

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

528

|| _Check(child, block) != B_OK)

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

538

fileblock_t block = 0;

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

539

return _Check(fStream, block) == B_OK;

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

544

ExtentStream::_CheckBlock(ext2_extent_stream *stream, fsblock_t block)

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

549

if (entry.PhysicalBlock() <= block

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

550

&& (entry.PhysicalBlock() + entry.Length()) > block) {

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

552

B_PRIu64 " %d\n", i, block, entry.PhysicalBlock(),

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

563

if (index.PhysicalBlock() == block) {

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

564

panic("_CheckBlock() index %" B_PRId32 " %" B_PRIu64 "\n", i, block);

src/add-ons/kernel/file_systems/ext2/ExtentStream.cpp

570

|| _CheckBlock(child, block) != B_OK)

src/add-ons/kernel/file_systems/ext2/ExtentStream.h

27

status_t FindBlock(off_t offset, fsblock_t& block,

src/add-ons/kernel/file_systems/ext2/ExtentStream.h

36

status_t _Check(ext2_extent_stream *stream, fileblock_t &block);

src/add-ons/kernel/file_systems/ext2/ExtentStream.h

37

status_t _CheckBlock(ext2_extent_stream *stream, fsblock_t block);

src/add-ons/kernel/file_systems/ext2/HTree.h

63

uint32 block;

src/add-ons/kernel/file_systems/ext2/HTree.h

68

{ return B_LENDIAN_TO_HOST_INT32(block); }

src/add-ons/kernel/file_systems/ext2/HTree.h

74

{ block = B_HOST_TO_LENDIAN_INT32(newBlock); }

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

144

const uint8* block = cached.SetTo(fBlockNum);

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

145

if (block == NULL) {

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

157

HTreeEntry* start = (HTreeEntry*)block + fCurrentEntry + 1;

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

158

HTreeEntry* end = (HTreeEntry*)block + fCount + fFirstEntry - 1;

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

184

fCurrentEntry = ((uint8*)start - block) / sizeof(HTreeEntry);

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

262

const uint8* block = cached.SetTo(fBlockNum);

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

263

if (block == NULL)

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

266

HTreeEntry* entry = &((HTreeEntry*)block)[fCurrentEntry];

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

394

HTreeEntryIterator::_HTreeEntryTail(uint8* block) const

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

396

HTreeEntry* entries = (HTreeEntry*)block;

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

404

HTreeEntryIterator::_Checksum(uint8* block) const

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

411

checksum = calculate_crc32c(checksum, block,

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

420

HTreeEntryIterator::_SetHTreeEntryChecksum(uint8* block)

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

423

ext2_htree_tail* tail = _HTreeEntryTail(block);

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

425

tail->checksum = _Checksum(block);

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

53

HTreeEntryIterator::HTreeEntryIterator(uint32 block, uint32 blockSize,

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

64

fBlockNum(block),

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

72

B_PRIu32 ", parent: %p\n", this, block, fParent);

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

86

const uint8* block = cached.SetTo(fBlockNum);

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

87

if (block == NULL) {

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp

94

&((HTreeEntry*)block)[fFirstEntry]);

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.h

37

uint32 hash, off_t block,

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.h

40

HTreeEntryIterator(uint32 block,

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.h

45

ext2_htree_tail* _HTreeEntryTail(uint8* block) const;

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.h

46

uint32 _Checksum(uint8* block) const;

src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.h

47

void _SetHTreeEntryChecksum(uint8* block);

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

104

HashRevokeManager::Lookup(uint32 block, uint32 commitID)

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

106

RevokeElement* element = fHash->Lookup(block);

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

119

uint32 block = *(uint32*)_block;

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

121

if (revoked->block == block)

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

124

return (revoked->block > block) ? 1 : -1;

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

136

return revoked->block % range;

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

138

uint32 block = *(uint32*)_block;

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

139

return block % range;

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

144

HashRevokeManager::_ForceInsert(uint32 block, uint32 commitID)

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

151

element->block = block;

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

63

HashRevokeManager::Insert(uint32 block, uint32 commitID)

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

65

RevokeElement* element = fHash->Lookup(block);

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

83

return _ForceInsert(block, commitID);

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

88

HashRevokeManager::Remove(uint32 block)

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp

90

RevokeElement* element = fHash->Lookup(block);

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.h

18

uint32 block;

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.h

34

return HashKey(value->block);

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.h

39

return value->block == key;

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.h

59

virtual status_t Insert(uint32 block, uint32 commitID);

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.h

60

virtual status_t Remove(uint32 block);

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.h

61

virtual bool Lookup(uint32 block, uint32 commitID);

src/add-ons/kernel/file_systems/ext2/HashRevokeManager.h

67

status_t _ForceInsert(uint32 block, uint32 commitID);

src/add-ons/kernel/file_systems/ext2/Inode.cpp

227

Inode::FindBlock(off_t offset, fsblock_t& block, uint32 *_count)

src/add-ons/kernel/file_systems/ext2/Inode.cpp

231

return stream.FindBlock(offset, block, _count);

src/add-ons/kernel/file_systems/ext2/Inode.cpp

234

return stream.FindBlock(offset, block, _count);

src/add-ons/kernel/file_systems/ext2/Inode.cpp

418

uint8* block = cached.SetToWritable(transaction, blockNum, true);

src/add-ons/kernel/file_systems/ext2/Inode.cpp

420

HTreeRoot* root = (HTreeRoot*)block;

src/add-ons/kernel/file_systems/ext2/Inode.cpp

960

Inode::_DirEntryTail(uint8* block) const

src/add-ons/kernel/file_systems/ext2/Inode.cpp

962

return (ext2_dir_entry_tail*)(block + fVolume->BlockSize()

src/add-ons/kernel/file_systems/ext2/Inode.cpp

968

Inode::_DirEntryChecksum(uint8* block, uint32 id, uint32 gen) const

src/add-ons/kernel/file_systems/ext2/Inode.cpp

974

checksum = calculate_crc32c(checksum, block,

src/add-ons/kernel/file_systems/ext2/Inode.cpp

981

Inode::SetDirEntryChecksum(uint8* block, uint32 id, uint32 gen)

src/add-ons/kernel/file_systems/ext2/Inode.cpp

984

ext2_dir_entry_tail* tail = _DirEntryTail(block);

src/add-ons/kernel/file_systems/ext2/Inode.cpp

989

tail->checksum = _DirEntryChecksum(block, id, gen);

src/add-ons/kernel/file_systems/ext2/Inode.cpp

995

Inode::SetDirEntryChecksum(uint8* block)

src/add-ons/kernel/file_systems/ext2/Inode.cpp

997

SetDirEntryChecksum(block, fID, fNode.generation);

src/add-ons/kernel/file_systems/ext2/Inode.h

124

void SetDirEntryChecksum(uint8* block, uint32 id, uint32 gen);

src/add-ons/kernel/file_systems/ext2/Inode.h

125

void SetDirEntryChecksum(uint8* block);

src/add-ons/kernel/file_systems/ext2/Inode.h

150

ext2_dir_entry_tail* _DirEntryTail(uint8* block) const;

src/add-ons/kernel/file_systems/ext2/Inode.h

151

uint32 _DirEntryChecksum(uint8* block, uint32 id,

src/add-ons/kernel/file_systems/ext2/Inode.h

88

status_t FindBlock(off_t offset, fsblock_t& block,

src/add-ons/kernel/file_systems/ext2/InodeAllocator.cpp

139

fsblock_t block = group->InodeBitmap(fVolume->Has64bitFeature());

src/add-ons/kernel/file_systems/ext2/InodeAllocator.cpp

140

if (block == 0) {

src/add-ons/kernel/file_systems/ext2/InodeAllocator.cpp

146

_InitGroup(transaction, group, block, fVolume->InodesPerGroup());

src/add-ons/kernel/file_systems/ext2/InodeAllocator.cpp

161

status = _MarkInBitmap(transaction, block, blockGroup,

src/add-ons/kernel/file_systems/ext2/Journal.cpp

1221

Journal::_WrapAroundLog(uint32 block)

src/add-ons/kernel/file_systems/ext2/Journal.cpp

1224

if (block >= fLogSize)

src/add-ons/kernel/file_systems/ext2/Journal.cpp

1225

return block - fLogSize + fFirstLogBlock;

src/add-ons/kernel/file_systems/ext2/Journal.cpp

1227

return block;

src/add-ons/kernel/file_systems/ext2/Journal.cpp

843

Journal::_Checksum(uint8* block, bool set)

src/add-ons/kernel/file_systems/ext2/Journal.cpp

845

JournalBlockTail *tail = (JournalBlockTail*)(block + fBlockSize

src/add-ons/kernel/file_systems/ext2/Journal.cpp

849

uint32 checksum = calculate_crc32c(0xffffffff, block, fBlockSize);

src/add-ons/kernel/file_systems/ext2/Journal.h

118

void SetBlockNumber(uint64 block, bool has64bits)

src/add-ons/kernel/file_systems/ext2/Journal.h

120

block_number = B_HOST_TO_BENDIAN_INT32(block & 0xffffffff);

src/add-ons/kernel/file_systems/ext2/Journal.h

122

block_number_high = B_HOST_TO_BENDIAN_INT32(block >> 32);

src/add-ons/kernel/file_systems/ext2/Journal.h

308

bool _Checksum(uint8 *block, bool set = false);

src/add-ons/kernel/file_systems/ext2/Journal.h

318

inline uint32 _WrapAroundLog(uint32 block);

src/add-ons/kernel/file_systems/ext2/Journal.h

90

void SetBlockNumber(uint32 block)

src/add-ons/kernel/file_systems/ext2/Journal.h

91

{ block_number = B_HOST_TO_BENDIAN_INT32(block); }

src/add-ons/kernel/file_systems/ext2/RevokeManager.h

21

virtual status_t Insert(uint32 block, uint32 commitID) = 0;

src/add-ons/kernel/file_systems/ext2/RevokeManager.h

22

virtual status_t Remove(uint32 block) = 0;

src/add-ons/kernel/file_systems/ext2/RevokeManager.h

23

virtual bool Lookup(uint32 block, uint32 commitID) = 0;

src/add-ons/kernel/file_systems/ext2/Transaction.cpp

129

void* block = block_cache_get_empty(cache, blockNumber + i, ID());

src/add-ons/kernel/file_systems/ext2/Transaction.cpp

130

if (block == NULL)

src/add-ons/kernel/file_systems/ext2/Transaction.cpp

133

memcpy(block, buffer, blockSize);

src/add-ons/kernel/file_systems/ext2/Volume.cpp

370

Volume::GetInodeBlock(ino_t id, off_t& block)

src/add-ons/kernel/file_systems/ext2/Volume.cpp

378

block = group->InodeTable(Has64bitFeature())

src/add-ons/kernel/file_systems/ext2/Volume.cpp

380

if (block < 0)

src/add-ons/kernel/file_systems/ext2/Volume.cpp

502

const uint8* block = cached.SetTo(_GroupDescriptorBlock(blockIndex));

src/add-ons/kernel/file_systems/ext2/Volume.cpp

503

if (block == NULL)

src/add-ons/kernel/file_systems/ext2/Volume.cpp

510

memcpy(fGroupBlocks[blockIndex], block, fBlockSize);

src/add-ons/kernel/file_systems/ext2/Volume.cpp

553

uint8* block = cached.SetToWritable(transaction,

src/add-ons/kernel/file_systems/ext2/Volume.cpp

555

if (block == NULL)

src/add-ons/kernel/file_systems/ext2/Volume.cpp

558

memcpy(block, (const uint8*)fGroupBlocks[blockIndex], fBlockSize);

src/add-ons/kernel/file_systems/ext2/Volume.cpp

670

const uint8* block = cached.SetTo(fFirstDataBlock);

src/add-ons/kernel/file_systems/ext2/Volume.cpp

672

if (block == NULL)

src/add-ons/kernel/file_systems/ext2/Volume.cpp

676

memcpy(&fSuperBlock, block + 1024, sizeof(fSuperBlock));

src/add-ons/kernel/file_systems/ext2/Volume.cpp

678

memcpy(&fSuperBlock, block, sizeof(fSuperBlock));

src/add-ons/kernel/file_systems/ext2/Volume.cpp

705

uint8* block = cached.SetToWritable(transaction, fFirstDataBlock);

src/add-ons/kernel/file_systems/ext2/Volume.cpp

707

if (block == NULL)

src/add-ons/kernel/file_systems/ext2/Volume.cpp

711

" %p, superblock: %p\n", fFirstDataBlock, block, &fSuperBlock);

src/add-ons/kernel/file_systems/ext2/Volume.cpp

714

memcpy(block + 1024, &fSuperBlock, sizeof(fSuperBlock));

src/add-ons/kernel/file_systems/ext2/Volume.cpp

716

memcpy(block, &fSuperBlock, sizeof(fSuperBlock));

src/add-ons/kernel/file_systems/ext2/Volume.h

71

status_t GetInodeBlock(ino_t id, off_t& block);

src/add-ons/kernel/file_systems/ext2/ext2.h

259

uint64 block = B_LENDIAN_TO_HOST_INT32(block_bitmap);

src/add-ons/kernel/file_systems/ext2/ext2.h

261

block |=

src/add-ons/kernel/file_systems/ext2/ext2.h

263

return block;

src/add-ons/kernel/file_systems/ext2/ext2.h

401

void SetLogicalBlock(uint32 block) {

src/add-ons/kernel/file_systems/ext2/ext2.h

402

logical_block = B_HOST_TO_LENDIAN_INT32(block); }

src/add-ons/kernel/file_systems/ext2/ext2.h

403

void SetPhysicalBlock(uint64 block) {

src/add-ons/kernel/file_systems/ext2/ext2.h

404

physical_block = B_HOST_TO_LENDIAN_INT32(block & 0xffffffff);

src/add-ons/kernel/file_systems/ext2/ext2.h

405

physical_block_high = B_HOST_TO_LENDIAN_INT16((block >> 32) & 0xffff); }

src/add-ons/kernel/file_systems/ext2/ext2.h

419

void SetLogicalBlock(uint32 block) {

src/add-ons/kernel/file_systems/ext2/ext2.h

420

logical_block = B_HOST_TO_LENDIAN_INT32(block); }

src/add-ons/kernel/file_systems/ext2/ext2.h

423

void SetPhysicalBlock(uint64 block) {

src/add-ons/kernel/file_systems/ext2/ext2.h

424

physical_block = B_HOST_TO_LENDIAN_INT32(block & 0xffffffff);

src/add-ons/kernel/file_systems/ext2/ext2.h

425

physical_block_high = B_HOST_TO_LENDIAN_INT16((block >> 32) & 0xffff); }

src/add-ons/kernel/file_systems/ext2/ext2.h

662

void SetExtendedAttributesBlock(uint32 block)

src/add-ons/kernel/file_systems/ext2/ext2.h

664

file_access_control = B_HOST_TO_LENDIAN_INT32(block);

src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp

386

fsblock_t block;

src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp

388

status_t status = inode->FindBlock(offset, block, &count);

src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp

392

if (block > volume->NumBlocks()) {

src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp

394

B_PRIdOFF "\n", block, offset);

src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp

397

off_t blockOffset = block << volume->BlockShift();

src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp

402

|| (vecs[index - 1].offset == -1 && block == 0))) {

src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp

412

if (block != 0)

src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp

511

uint8* block = cached.SetToWritable(transaction, blockNum);

src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp

512

memset(block, 0, blockSize);

src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp

537

fsblock_t block;

src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp

539

status_t status = inode->FindBlock(*offset, block, &count);

src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp

542

if ((block != 0 && cmd == FIOSEEKDATA)

src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp

543

|| (block == 0 && cmd == FIOSEEKHOLE)) {

src/add-ons/kernel/file_systems/fat/dosfs.h

37

#define BLOCK_TO_SECTOR(fat_volume, block) ((block * DEV_BSIZE) / fat_volume->pm_BytesPerSec)

src/add-ons/kernel/file_systems/iso9660/iso9660.cpp

759

off_t totalRead = cookie->pos + (cookie->block - cookie->startBlock)

src/add-ons/kernel/file_systems/iso9660/iso9660.cpp

766

= (char*)block_cache_get(volume->fBlockCache, cookie->block);

src/add-ons/kernel/file_systems/iso9660/iso9660.cpp

769

block_cache_put(volume->fBlockCache, cookie->block);

src/add-ons/kernel/file_systems/iso9660/iso9660.cpp

774

cookie->block++;

src/add-ons/kernel/file_systems/iso9660/iso9660.cpp

782

off_t cacheBlock = cookie->block;

src/add-ons/kernel/file_systems/iso9660/iso9660.cpp

798

dirent->d_ino = ((ino_t)cookie->block << 30)

src/add-ons/kernel/file_systems/iso9660/iso9660.cpp

806

"pos %lld, inode id %lld\n", dirent->d_name, cookie->block,

src/add-ons/kernel/file_systems/iso9660/iso9660.cpp

823

cookie->block++;

src/add-ons/kernel/file_systems/iso9660/iso9660.h

145

off_t block; // Current block

src/add-ons/kernel/file_systems/iso9660/kernel_interface.cpp

276

off_t block = baseNode->startLBN[FS_DATA_FORMAT];

src/add-ons/kernel/file_systems/iso9660/kernel_interface.cpp

280

off_t cachedBlock = block;

src/add-ons/kernel/file_systems/iso9660/kernel_interface.cpp

281

char* blockData = (char*)block_cache_get(volume->fBlockCache, block);

src/add-ons/kernel/file_systems/iso9660/kernel_interface.cpp

291

"%p.\n", block, blockData));

src/add-ons/kernel/file_systems/iso9660/kernel_interface.cpp

308

"%lld\n", block, blockBytesRead));

src/add-ons/kernel/file_systems/iso9660/kernel_interface.cpp

310

*_vnodeID = (block << 30) + (blockBytesRead & 0xffffffff);

src/add-ons/kernel/file_systems/iso9660/kernel_interface.cpp

335

block++;

src/add-ons/kernel/file_systems/iso9660/kernel_interface.cpp

338

block, (unsigned)totalRead));

src/add-ons/kernel/file_systems/iso9660/kernel_interface.cpp

359

uint32 block = vnodeID >> 30;

src/add-ons/kernel/file_systems/iso9660/kernel_interface.cpp

362

(unsigned)block, (unsigned) pos, vnodeID, newNode));

src/add-ons/kernel/file_systems/iso9660/kernel_interface.cpp

369

char* data = (char*)block_cache_get(volume->fBlockCache, block);

src/add-ons/kernel/file_systems/iso9660/kernel_interface.cpp

376

block_cache_put(volume->fBlockCache, block);

src/add-ons/kernel/file_systems/iso9660/kernel_interface.cpp

592

dirCookie->block = node->startLBN[FS_DATA_FORMAT];

src/add-ons/kernel/file_systems/iso9660/kernel_interface.cpp

635

cookie->block = cookie->startBlock;

src/add-ons/kernel/file_systems/ntfs/utils/mkntfs.c

486

static BOOL append_to_bad_blocks(unsigned long long block)

src/add-ons/kernel/file_systems/ntfs/utils/mkntfs.c

500

g_bad_blocks[g_num_bad_blocks++] = block;

src/add-ons/kernel/file_systems/packagefs/nodes/UnpackingDirectory.h

17

static void operator delete(void* block);

src/add-ons/kernel/file_systems/packagefs/nodes/UnpackingDirectory.h

62

static void operator delete(void* block);

src/add-ons/kernel/file_systems/packagefs/nodes/UnpackingLeafNode.h

17

static void operator delete(void* block);

src/add-ons/kernel/file_systems/packagefs/package/PackageDirectory.h

18

static void operator delete(void* block);

src/add-ons/kernel/file_systems/packagefs/package/PackageFile.h

16

static void operator delete(void* block);

src/add-ons/kernel/file_systems/packagefs/package/PackageNodeAttribute.h

23

static void operator delete(void* block);

src/add-ons/kernel/file_systems/packagefs/package/PackageSymlink.h

15

static void operator delete(void* block);

src/add-ons/kernel/file_systems/packagefs/util/ClassCache.h

29

CLASS::operator delete(void* block) \

src/add-ons/kernel/file_systems/packagefs/util/ClassCache.h

31

object_cache_free(s##CLASS##Cache, block, 0); \

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

106

BlockCache::GetBlock(Block *block)

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

108

status_t error = (block ? B_OK : B_BAD_VALUE);

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

111

if (fBlocks.HasItem(block))

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

112

block->_Get();

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

132

Block *block = _FindBlock(number);

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

133

if (!block) {

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

135

error = _ReadBlock(number, &block);

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

137

fBlocks.AddItem(block);

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

142

block->_Get();

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

143

*result = block;

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

152

BlockCache::PutBlock(Block *block)

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

155

if (block && fBlocks.HasItem(block)) {

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

156

if (block->_Put()) {

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

157

fBlocks.RemoveItem(block);

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

158

delete block;

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

168

for (int32 i = 0; Block *block = fBlocks.ItemAt(i); i++) {

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

169

if (block->GetNumber() == number)

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

170

return block;

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

182

Block *block = new(nothrow) Block;

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

183

if (!block)

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

186

status_t error = block->_SetTo(this, number);

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

190

*result = block;

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

191

else if (block)

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

192

delete block;

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

70

for (int32 i = 0; Block *block = fBlocks.ItemAt(i); i++) {

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

71

if (block->_GetRefCount() > 0) {

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

73

block, block->_GetRefCount()));

src/add-ons/kernel/file_systems/reiserfs/BlockCache.cpp

75

delete block;

src/add-ons/kernel/file_systems/reiserfs/BlockCache.h

44

status_t GetBlock(Block *block);

src/add-ons/kernel/file_systems/reiserfs/BlockCache.h

45

status_t GetBlock(uint64 number, Block **block);

src/add-ons/kernel/file_systems/reiserfs/BlockCache.h

46

void PutBlock(Block *block);

src/add-ons/kernel/file_systems/reiserfs/BlockCache.h

50

status_t _ReadBlock(uint64 number, Block **block);

src/add-ons/kernel/file_systems/reiserfs/Iterators.cpp

1518

Block *block = NULL;

src/add-ons/kernel/file_systems/reiserfs/Iterators.cpp

1519

error = GetTree()->GetBlock(indirect.BlockNumberAt(i), &block);

src/add-ons/kernel/file_systems/reiserfs/Iterators.cpp

1526

reinterpret_cast<uint8*>(block->GetData()) + localOffset,

src/add-ons/kernel/file_systems/reiserfs/Iterators.cpp

1529

block->Put();

src/add-ons/kernel/file_systems/reiserfs/Tree.cpp

123

Tree::GetBlock(uint64 blockNumber, Block **block)

src/add-ons/kernel/file_systems/reiserfs/Tree.cpp

125

status_t error = (block ? InitCheck() : B_BAD_VALUE);

src/add-ons/kernel/file_systems/reiserfs/Tree.cpp

127

error = fBlockCache->GetBlock(blockNumber, block);

src/add-ons/kernel/file_systems/reiserfs/Tree.cpp

137

Block *block;

src/add-ons/kernel/file_systems/reiserfs/Tree.cpp

138

error = fBlockCache->GetBlock(blockNumber, &block);

src/add-ons/kernel/file_systems/reiserfs/Tree.cpp

140

if (block->GetKind() == Block::KIND_UNKNOWN)

src/add-ons/kernel/file_systems/reiserfs/Tree.cpp

141

block->SetKind(Block::KIND_FORMATTED);

src/add-ons/kernel/file_systems/reiserfs/Tree.cpp

142

if (block->GetKind() == Block::KIND_FORMATTED) {

src/add-ons/kernel/file_systems/reiserfs/Tree.cpp

143

*node = block->ToNode();

src/add-ons/kernel/file_systems/reiserfs/Tree.cpp

156

block->Put();

src/add-ons/kernel/file_systems/reiserfs/Tree.h

53

status_t GetBlock(uint64 blockNumber, Block **block);

src/add-ons/kernel/file_systems/udf/AllocationDescriptorList.h

264

return descriptor.block();

src/add-ons/kernel/file_systems/udf/AllocationDescriptorList.h

293

return descriptor.block();

src/add-ons/kernel/file_systems/udf/CachedBlock.h

100

fBlockNumber = block;

src/add-ons/kernel/file_systems/udf/CachedBlock.h

101

return block_cache_get_etc(fVolume->BlockCache(), block,

src/add-ons/kernel/file_systems/udf/CachedBlock.h

109

off_t block;

src/add-ons/kernel/file_systems/udf/CachedBlock.h

110

if (fVolume->MapBlock(address, &block) == B_OK)

src/add-ons/kernel/file_systems/udf/CachedBlock.h

111

return SetTo(block);

src/add-ons/kernel/file_systems/udf/CachedBlock.h

38

inline status_t SetTo(off_t block);

src/add-ons/kernel/file_systems/udf/CachedBlock.h

97

CachedBlock::SetTo(off_t block)

src/add-ons/kernel/file_systems/udf/Icb.cpp

116

"%d, length = %" B_PRIu32 ")\n", volume, address.block(),

src/add-ons/kernel/file_systems/udf/Icb.cpp

124

off_t block;

src/add-ons/kernel/file_systems/udf/Icb.cpp

125

status_t status = fVolume->MapBlock(address, &block);

src/add-ons/kernel/file_systems/udf/Icb.cpp

127

status = fData.SetTo(block);

src/add-ons/kernel/file_systems/udf/Icb.cpp

142

status = header->tag().init_check(address.block());

src/add-ons/kernel/file_systems/udf/Icb.cpp

225

Icb::FindBlock(uint32 logicalBlock, off_t &block, bool &recorded)

src/add-ons/kernel/file_systems/udf/Icb.cpp

229

block = -1;

src/add-ons/kernel/file_systems/udf/Icb.cpp

292

block = extent.block();

src/add-ons/kernel/file_systems/udf/Icb.cpp

294

TRACE(("Icb::FindBlock: block %" B_PRIdOFF "\n", block));

src/add-ons/kernel/file_systems/udf/Icb.cpp

301

Icb::Read(off_t pos, void *buffer, size_t *length, uint32 *block)

src/add-ons/kernel/file_systems/udf/Icb.cpp

325

RETURN(_Read(list, pos, buffer, length, block));

src/add-ons/kernel/file_systems/udf/Icb.cpp

333

RETURN(_Read(list, pos, buffer, length, block));

src/add-ons/kernel/file_systems/udf/Icb.cpp

367

Icb::_Read(DescriptorList &list, off_t pos, void *_buffer, size_t *length, uint32 *block)

src/add-ons/kernel/file_systems/udf/Icb.cpp

397

pos, extent.block(), extent.partition(), extent.length(),

src/add-ons/kernel/file_systems/udf/Icb.cpp

424

if (block)

src/add-ons/kernel/file_systems/udf/Icb.cpp

425

*block = extent.block();

src/add-ons/kernel/file_systems/udf/Icb.cpp

45

uint32 block = 0;

src/add-ons/kernel/file_systems/udf/Icb.cpp

52

status = Parent()->Read(offset, entry, &entryLength, &block);

src/add-ons/kernel/file_systems/udf/Icb.cpp

54

&& entry->tag().init_check(block) == B_OK) {

src/add-ons/kernel/file_systems/udf/Icb.h

108

status_t FindBlock(uint32 logicalBlock, off_t &block,

src/add-ons/kernel/file_systems/udf/Icb.h

111

uint32 *block = NULL);

src/add-ons/kernel/file_systems/udf/Icb.h

144

void *buffer, size_t *length, uint32 *block);

src/add-ons/kernel/file_systems/udf/MetadataPartition.cpp

59

off_t block = 0;

src/add-ons/kernel/file_systems/udf/MetadataPartition.cpp

61

status_t status = fMetadataIcb->FindBlock(logicalBlock, block, isRecorded);

src/add-ons/kernel/file_systems/udf/MetadataPartition.cpp

65

status = fMetadataMirrorIcb->FindBlock(logicalBlock, block, isRecorded);

src/add-ons/kernel/file_systems/udf/MetadataPartition.cpp

71

return fParentPartition.MapBlock(block, physicalBlock);

src/add-ons/kernel/file_systems/udf/Recognition.cpp

127

for (uint32 block = 16; true; block++) {

src/add-ons/kernel/file_systems/udf/Recognition.cpp

128

off_t address = (offset + block) << blockShift;

src/add-ons/kernel/file_systems/udf/Recognition.cpp

130

"address = %" B_PRIdOFF ", ", block, address));

src/add-ons/kernel/file_systems/udf/Recognition.cpp

187

off_t block = avds_locations[i];

src/add-ons/kernel/file_systems/udf/Recognition.cpp

188

off_t address = (offset + block) << blockShift;

src/add-ons/kernel/file_systems/udf/Recognition.cpp

199

block, address, blockSize, bytesRead));

src/add-ons/kernel/file_systems/udf/Recognition.cpp

204

anchorErr = anchor->tag().init_check(block + offset);

src/add-ons/kernel/file_systems/udf/Recognition.cpp

206

PRINT(("block %" B_PRIdOFF ": invalid anchor\n", block));

src/add-ons/kernel/file_systems/udf/Recognition.cpp

208

PRINT(("block %" B_PRIdOFF ": valid anchor\n", block));

src/add-ons/kernel/file_systems/udf/Recognition.cpp

212

PRINT(("block %" B_PRIdOFF ": anchor:\n", block));

src/add-ons/kernel/file_systems/udf/Recognition.cpp

243

walk_tagid_partition_descriptor(descriptor_tag *tag, off_t block,

src/add-ons/kernel/file_systems/udf/Recognition.cpp

252

if (partition->tag().init_check(block) == B_OK) {

src/add-ons/kernel/file_systems/udf/Recognition.cpp

344

off_t block = descriptorSequence.location()+i;

src/add-ons/kernel/file_systems/udf/Recognition.cpp

345

off_t address = block << blockShift;

src/add-ons/kernel/file_systems/udf/Recognition.cpp

349

PRINT(("descriptor #%" PRIu32 " (block %" B_PRIdOFF "):\n", i, block));

src/add-ons/kernel/file_systems/udf/Recognition.cpp

359

block, address, blockSize, bytesRead));

src/add-ons/kernel/file_systems/udf/Recognition.cpp

364

loopError = tag->init_check(block);

src/add-ons/kernel/file_systems/udf/Recognition.cpp

394

if (impUse->tag().init_check(block) == B_OK

src/add-ons/kernel/file_systems/udf/Recognition.cpp

405

tag, block, uniquePartitions, partitionDescriptors);

src/add-ons/kernel/file_systems/udf/Recognition.cpp

498

off_t block = descriptorSequence.location()+i;

src/add-ons/kernel/file_systems/udf/Recognition.cpp

499

off_t address = block << blockShift;

src/add-ons/kernel/file_systems/udf/Recognition.cpp

505

sequenceNumber, i, block));

src/add-ons/kernel/file_systems/udf/Recognition.cpp

514

block, address, blockSize, bytesRead));

src/add-ons/kernel/file_systems/udf/Recognition.cpp

519

loopError = tag->init_check(block);

src/add-ons/kernel/file_systems/udf/UdfStructures.cpp

473

PRINT(("block: %" B_PRIu32 "\n", block()));

src/add-ons/kernel/file_systems/udf/UdfStructures.cpp

477

logical_block_address::logical_block_address(uint16 partition, uint32 block)

src/add-ons/kernel/file_systems/udf/UdfStructures.cpp

480

set_block(block);

src/add-ons/kernel/file_systems/udf/UdfStructures.cpp

487

long_address::long_address(uint16 partition, uint32 block, uint32 length,

src/add-ons/kernel/file_systems/udf/UdfStructures.cpp

491

set_block(block);

src/add-ons/kernel/file_systems/udf/UdfStructures.cpp

502

PRINT(("block: %" B_PRIu32 "\n", block()));

src/add-ons/kernel/file_systems/udf/UdfStructures.cpp

546

descriptor_tag::init_check(uint32 block, bool calculateCrc)

src/add-ons/kernel/file_systems/udf/UdfStructures.cpp

550

block, bool_to_string(calculateCrc)));

src/add-ons/kernel/file_systems/udf/UdfStructures.cpp

551

PRINT(("location (parameter) == %" B_PRIu32 "\n", block));

src/add-ons/kernel/file_systems/udf/UdfStructures.cpp

563

status_t error = (block == location()) ? B_OK : B_NO_INIT;

src/add-ons/kernel/file_systems/udf/UdfStructures.h

393

logical_block_address(uint16 partition = 0, uint32 block = 0);

src/add-ons/kernel/file_systems/udf/UdfStructures.h

395

uint32 block() const { return B_LENDIAN_TO_HOST_INT32(_block); }

src/add-ons/kernel/file_systems/udf/UdfStructures.h

398

void set_block(uint32 block) { _block = B_HOST_TO_LENDIAN_INT32(block); }

src/add-ons/kernel/file_systems/udf/UdfStructures.h

448

uint32 block() const { return B_LENDIAN_TO_HOST_INT32(_block); }

src/add-ons/kernel/file_systems/udf/UdfStructures.h

462

void set_block(uint32 block) { _block = B_HOST_TO_LENDIAN_INT32(block); }

src/add-ons/kernel/file_systems/udf/UdfStructures.h

487

long_address(uint16 partition = 0, uint32 block = 0, uint32 length = 0,

src/add-ons/kernel/file_systems/udf/UdfStructures.h

503

uint32 block() const { return _location.block(); }

src/add-ons/kernel/file_systems/udf/UdfStructures.h

524

void set_block(uint32 block) { _location.set_block(block); }

src/add-ons/kernel/file_systems/udf/UdfStructures.h

530

void set_to(uint32 block, uint16 partition, uint32 length = 1,

src/add-ons/kernel/file_systems/udf/UdfStructures.h

533

set_block(block);

src/add-ons/kernel/file_systems/udf/UdfStructures.h

574

status_t init_check(uint32 block, bool calculateCrc = true);

src/add-ons/kernel/file_systems/udf/Utils.cpp

171

ino_t result = address.block();

src/add-ons/kernel/file_systems/udf/Utils.cpp

174

TRACE(("block: %" B_PRIu32 ", 0x%" B_PRIx32 "\n", address.block(),

src/add-ons/kernel/file_systems/udf/Utils.cpp

175

address.block()));

src/add-ons/kernel/file_systems/udf/Utils.cpp

70

uint32 block = blockSize & (uint32(1) << i);

src/add-ons/kernel/file_systems/udf/Utils.cpp

71

if (block) {

src/add-ons/kernel/file_systems/udf/Volume.cpp

283

logicalVolumeDescriptor.file_set_address().block());

src/add-ons/kernel/file_systems/udf/Volume.cpp

337

", mappedBlock = %p\n", address.partition(), address.block(),

src/add-ons/kernel/file_systems/udf/Volume.cpp

340

", mappedBlock = %p", address.partition(), address.block(),

src/add-ons/kernel/file_systems/udf/Volume.cpp

347

error = partition->MapBlock(address.block(), *mappedBlock);

src/add-ons/kernel/file_systems/ufs2/Volume.h

30

bool IsValidInodeBlock(off_t block) const;

src/add-ons/kernel/file_systems/xfs/Inode.cpp

452

ssize_t& len, size_t DirBlockSize, char* block) {

src/add-ons/kernel/file_systems/xfs/Inode.cpp

487

if (read_pos(volume->Device(), readPos, block, len)

src/add-ons/kernel/file_systems/xfs/Inode.cpp

516

char* block = new(std::nothrow) char[len];

src/add-ons/kernel/file_systems/xfs/Inode.cpp

517

if (block == NULL)

src/add-ons/kernel/file_systems/xfs/Inode.cpp

520

ArrayDeleter<char> blockDeleter(block);

src/add-ons/kernel/file_systems/xfs/Inode.cpp

522

GetNodefromTree(levelsInTree, volume, len, DirBlockSize(), block);

src/add-ons/kernel/file_systems/xfs/Inode.cpp

531

char* leafBuffer = block;

src/add-ons/kernel/file_systems/xfs/Inode.cpp

556

if (read_pos(volume->Device(), readPos, block, len)

src/add-ons/kernel/file_systems/xfs/Inode.cpp

624

char* block = new(std::nothrow) char[lengthOfBlock];

src/add-ons/kernel/file_systems/xfs/Inode.cpp

625

if (block == NULL)

src/add-ons/kernel/file_systems/xfs/Inode.cpp

628

ArrayDeleter<char> blockDeleter(block);

src/add-ons/kernel/file_systems/xfs/Inode.cpp

669

if (read_pos(GetVolume()->Device(), readPos, block, lengthOfBlock)

src/add-ons/kernel/file_systems/xfs/Inode.cpp

676

(void*)(block + offsetIntoBlock), lengthToRead) < B_OK)

src/add-ons/kernel/file_systems/xfs/Inode.cpp

739

Inode::FileSystemBlockToAddr(uint64 block)

src/add-ons/kernel/file_systems/xfs/Inode.cpp

743

uint64 agNo = FSBLOCKS_TO_AGNO(block, fVolume);

src/add-ons/kernel/file_systems/xfs/Inode.cpp

744

uint64 agBlockNo = FSBLOCKS_TO_AGBLOCKNO(block, fVolume);

src/add-ons/kernel/file_systems/xfs/Inode.h

313

uint64 FileSystemBlockToAddr(uint64 block);

src/add-ons/kernel/file_systems/xfs/Inode.h

320

size_t DirBlockSize, char* block);

src/add-ons/kernel/file_systems/xfs/NodeAttribute.cpp

118

NodeAttribute::_FillBuffer(char* buffer, xfs_fsblock_t block)

src/add-ons/kernel/file_systems/xfs/NodeAttribute.cpp

123

fInode->FileSystemBlockToAddr(block);

src/add-ons/kernel/file_systems/xfs/NodeAttribute.cpp

283

xfs_fsblock_t block = _LogicalToFileSystemBlock(logicalBlock);

src/add-ons/kernel/file_systems/xfs/NodeAttribute.cpp

284

_FillBuffer(fLeafBuffer, block);

src/add-ons/kernel/file_systems/xfs/NodeAttribute.cpp

355

xfs_fsblock_t block = _LogicalToFileSystemBlock(logicalBlock);

src/add-ons/kernel/file_systems/xfs/NodeAttribute.cpp

356

_FillBuffer(fLeafBuffer, block);

src/add-ons/kernel/file_systems/xfs/NodeAttribute.h

33

status_t _FillBuffer(char* buffer, xfs_fsblock_t block);

src/add-ons/kernel/generic/scsi_periph/block.cpp

649

void* block = malloc(device->block_size);

src/add-ons/kernel/generic/scsi_periph/block.cpp

650

if (block == NULL)

src/add-ons/kernel/generic/scsi_periph/block.cpp

652

MemoryDeleter deleter(block);

src/add-ons/kernel/generic/scsi_periph/block.cpp

653

memset(block, 0, device->block_size);

src/add-ons/kernel/generic/scsi_periph/block.cpp

668

request->data = (uint8*)block;

src/add-ons/kernel/generic/scsi_periph/block.cpp

729

void* block = malloc(device->block_size);

src/add-ons/kernel/generic/scsi_periph/block.cpp

730

if (block == NULL)

src/add-ons/kernel/generic/scsi_periph/block.cpp

732

MemoryDeleter deleter(block);

src/add-ons/kernel/generic/scsi_periph/block.cpp

733

memset(block, 0, device->block_size);

src/add-ons/kernel/generic/scsi_periph/block.cpp

747

request->data = (uint8*)block;

src/add-ons/kernel/partitioning_systems/apple/apple.cpp

60

uint32 block = cookie;

src/add-ons/kernel/partitioning_systems/apple/apple.cpp

65

ssize_t bytesRead = read_pos(fd, (off_t)block * descriptor.BlockSize(),

src/add-ons/kernel/partitioning_systems/apple/apple.cpp

70

block++;

src/add-ons/kernel/partitioning_systems/apple/apple.cpp

71

} while (cookie == 0 && block < 64 && !partition.HasValidSignature());

src/add-ons/kernel/partitioning_systems/apple/apple.cpp

88

cookie = block;

src/add-ons/kernel/partitioning_systems/gpt/Header.cpp

335

Header::_IsHeaderValid(gpt_table_header& header, uint64 block)

src/add-ons/kernel/partitioning_systems/gpt/Header.cpp

339

&& header.AbsoluteBlock() == block;

src/add-ons/kernel/partitioning_systems/gpt/Header.h

60

uint64 block);

src/add-ons/kernel/partitioning_systems/gpt/gpt.h

100

{ start_block = B_HOST_TO_LENDIAN_INT64(block); }

src/add-ons/kernel/partitioning_systems/gpt/gpt.h

103

void SetEndBlock(uint64 block)

src/add-ons/kernel/partitioning_systems/gpt/gpt.h

104

{ end_block = B_HOST_TO_LENDIAN_INT64(block); }

src/add-ons/kernel/partitioning_systems/gpt/gpt.h

47

void SetAbsoluteBlock(uint64 block)

src/add-ons/kernel/partitioning_systems/gpt/gpt.h

48

{ absolute_block = B_HOST_TO_LENDIAN_INT64(block); }

src/add-ons/kernel/partitioning_systems/gpt/gpt.h

51

void SetAlternateBlock(uint64 block)

src/add-ons/kernel/partitioning_systems/gpt/gpt.h

52

{ alternate_block = B_HOST_TO_LENDIAN_INT64(block); }

src/add-ons/kernel/partitioning_systems/gpt/gpt.h

55

void SetFirstUsableBlock(uint64 block)

src/add-ons/kernel/partitioning_systems/gpt/gpt.h

56

{ first_usable_block = B_HOST_TO_LENDIAN_INT64(block); }

src/add-ons/kernel/partitioning_systems/gpt/gpt.h

59

void SetLastUsableBlock(uint64 block)

src/add-ons/kernel/partitioning_systems/gpt/gpt.h

60

{ last_usable_block = B_HOST_TO_LENDIAN_INT64(block); }

src/add-ons/kernel/partitioning_systems/gpt/gpt.h

64

void SetEntriesBlock(uint64 block)

src/add-ons/kernel/partitioning_systems/gpt/gpt.h

65

{ entries_block = B_HOST_TO_LENDIAN_INT64(block); }

src/add-ons/kernel/partitioning_systems/gpt/gpt.h

99

void SetStartBlock(uint64 block)

src/add-ons/kernel/partitioning_systems/intel/PartitionMapParser.cpp

72

PartitionMapParser::Parse(const uint8* block, PartitionMap* map)

src/add-ons/kernel/partitioning_systems/intel/PartitionMapParser.cpp

83

if (block) {

src/add-ons/kernel/partitioning_systems/intel/PartitionMapParser.cpp

84

const partition_table* table = (const partition_table*)block;

src/add-ons/kernel/partitioning_systems/intel/PartitionMapParser.h

35

status_t Parse(const uint8* block, PartitionMap* map);

src/add-ons/kernel/partitioning_systems/intel/write_support.cpp

1382

void* block = malloc(blockSize);

src/add-ons/kernel/partitioning_systems/intel/write_support.cpp

1383

if (block == NULL)

src/add-ons/kernel/partitioning_systems/intel/write_support.cpp

1385

MemoryDeleter blockDeleter(block);

src/add-ons/kernel/partitioning_systems/intel/write_support.cpp

1387

memset(block, 0, blockSize);

src/add-ons/kernel/partitioning_systems/intel/write_support.cpp

1389

if (write_pos(fd, 0, block, blockSize) < 0)

src/add-ons/mail_daemon/inbound_protocols/pop3/md5c.c

189

static void MD5Transform (UINT4 state[4], unsigned char block[64])

src/add-ons/mail_daemon/inbound_protocols/pop3/md5c.c

193

Decode (x, block, 64);

src/add-ons/mail_daemon/outbound_protocols/smtp/md5c.c

189

static void MD5_Transform (UINT4 state[4], unsigned char block[64])

src/add-ons/mail_daemon/outbound_protocols/smtp/md5c.c

193

Decode (x, block, 64);

src/add-ons/translators/gif/GIFLoad.cpp

568

Memblock* block = fHeadMemblock;

src/add-ons/translators/gif/GIFLoad.cpp

570

while (block != NULL) {

src/add-ons/translators/gif/GIFLoad.cpp

571

if (ENTRY_COUNT - block->offset > size) {

src/add-ons/translators/gif/GIFLoad.cpp

572

unsigned char* value = block->data + block->offset;

src/add-ons/translators/gif/GIFLoad.cpp

573

block->offset += size;

src/add-ons/translators/gif/GIFLoad.cpp

577

last = block;

src/add-ons/translators/gif/GIFLoad.cpp

578

block = block->next;

src/add-ons/translators/gif/GIFLoad.cpp

581

block = (Memblock*)malloc(sizeof(Memblock));

src/add-ons/translators/gif/GIFLoad.cpp

582

if (block == NULL)

src/add-ons/translators/gif/GIFLoad.cpp

585

unsigned char* value = block->data;

src/add-ons/translators/gif/GIFLoad.cpp

586

block->offset = size;

src/add-ons/translators/gif/GIFLoad.cpp

587

block->next = NULL;

src/add-ons/translators/gif/GIFLoad.cpp

589

last->next = block;

src/add-ons/translators/gif/GIFLoad.cpp

599

Memblock* block = NULL;

src/add-ons/translators/gif/GIFLoad.cpp

603

block = fHeadMemblock->next;

src/add-ons/translators/gif/GIFLoad.cpp

605

fHeadMemblock = block;

src/add-ons/translators/psd/PSDWriter.h

50

uint8 *block, size_t count);

src/add-ons/translators/raw/RAW.cpp

2498

for (uint32 block = 0; block < rawWidth >> 3; block++) {

src/add-ons/translators/raw/RAW.cpp

2532

pixel[(block << 6) + i] = (base[i & 1] += diffbuf[i]);

src/apps/bootmanager/LegacyBootMenu.cpp

632

uint8* block = buffer;

src/apps/bootmanager/LegacyBootMenu.cpp

633

for (size_t i = 0; i < blocks; i ++, block += kBlockSize) {

src/apps/bootmanager/LegacyBootMenu.cpp

634

if (read(fd, block, kBlockSize) != (ssize_t)kBlockSize)

src/apps/bootmanager/LegacyBootMenu.cpp

650

const uint8* block = buffer;

src/apps/bootmanager/LegacyBootMenu.cpp

651

for (size_t i = 0; i < blocks; i ++, block += kBlockSize) {

src/apps/bootmanager/LegacyBootMenu.cpp

652

if (write(fd, block, kBlockSize) != (ssize_t)kBlockSize)

src/apps/charactermap/CharacterView.cpp

107

if (kUnicodeBlocks[blockIndex].block != kNoBlock)

src/apps/charactermap/CharacterView.cpp

108

return (fUnicodeBlocks & kUnicodeBlocks[blockIndex].block) != kNoBlock;

src/apps/charactermap/CharacterView.cpp

157

CharacterView::IsBlockVisible(int32 block) const

src/apps/charactermap/CharacterView.cpp

162

if (block >= topBlock && block <= bottomBlock)

src/apps/charactermap/CharacterView.h

37

bool IsBlockVisible(int32 block) const;

src/apps/charactermap/UnicodeBlockView.cpp

155

BlockListItem* block = fBlocks.ItemAt(blockNumber);

src/apps/charactermap/UnicodeBlockView.cpp

157

int32 blockIndex = IndexOf(block);

src/apps/charactermap/UnicodeBlockView.cpp

96

if (kUnicodeBlocks[blockIndex].block != kNoBlock)

src/apps/charactermap/UnicodeBlockView.cpp

97

return (fUnicodeBlocks & kUnicodeBlocks[blockIndex].block) != kNoBlock;

src/apps/charactermap/UnicodeBlocks.h

17

const unicode_block& block;

src/apps/debugger/user_interface/cli/CliContext.cpp

32

Event(int type, ::Thread* thread = NULL, TeamMemoryBlock* block = NULL,

src/apps/debugger/user_interface/cli/CliContext.cpp

335

CliContext::GetMemoryBlock(target_addr_t address, TeamMemoryBlock*& block)

src/apps/debugger/user_interface/cli/CliContext.cpp

345

block = fCurrentBlock;

src/apps/debugger/user_interface/cli/CliContext.cpp

38

fMemoryBlockReference(block),

src/apps/debugger/user_interface/cli/CliContext.cpp

438

TeamMemoryBlock* block = NULL;

src/apps/debugger/user_interface/cli/CliContext.cpp

440

reinterpret_cast<void **>(&block)) != B_OK) {

src/apps/debugger/user_interface/cli/CliContext.cpp

449

fCurrentBlock = block;

src/apps/debugger/user_interface/cli/CliContext.cpp

572

CliContext::MemoryBlockRetrieved(TeamMemoryBlock* block)

src/apps/debugger/user_interface/cli/CliContext.cpp

574

if (block != NULL)

src/apps/debugger/user_interface/cli/CliContext.cpp

575

block->AcquireReference();

src/apps/debugger/user_interface/cli/CliContext.cpp

578

message.AddPointer("block", block);

src/apps/debugger/user_interface/cli/CliContext.h

120

virtual void MemoryBlockRetrieved(TeamMemoryBlock* block);

src/apps/debugger/user_interface/cli/CliContext.h

89

TeamMemoryBlock*& block);

src/apps/debugger/user_interface/cli/commands/CliDumpMemoryCommand.cpp

77

TeamMemoryBlock* block = NULL;

src/apps/debugger/user_interface/cli/commands/CliDumpMemoryCommand.cpp

78

if (context.GetMemoryBlock(address, block) != B_OK)

src/apps/debugger/user_interface/cli/commands/CliDumpMemoryCommand.cpp

94

UiUtils::DumpMemory(output, 0, block, address, itemSize, displayWidth,

src/apps/debugger/user_interface/cli/commands/CliDumpStringCommand.cpp

66

TeamMemoryBlock* block = NULL;

src/apps/debugger/user_interface/cli/commands/CliDumpStringCommand.cpp

67

if (context.GetMemoryBlock(address, block) != B_OK)

src/apps/debugger/user_interface/cli/commands/CliDumpStringCommand.cpp

74

while (block->Contains(offset)) {

src/apps/debugger/user_interface/cli/commands/CliDumpStringCommand.cpp

75

c = *(block->Data() + offset - block->BaseAddress());

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

319

TeamMemoryBlock* block = NULL;

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

322

reinterpret_cast<void **>(&block)) != B_OK

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

328

_SetCurrentBlock(block);

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

334

": %s", block->BaseAddress(), strerror(result));

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

342

block->ReleaseReference();

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

427

InspectorWindow::MemoryBlockRetrieved(TeamMemoryBlock* block)

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

430

message.AddPointer("block", block);

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

437

InspectorWindow::MemoryBlockRetrievalFailed(TeamMemoryBlock* block,

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

441

message.AddPointer("block", block);

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

622

InspectorWindow::_SetCurrentBlock(TeamMemoryBlock* block)

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

630

fCurrentBlock = block;

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.h

53

virtual void MemoryBlockRetrieved(TeamMemoryBlock* block);

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.h

55

TeamMemoryBlock* block, status_t result);

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.h

83

void _SetCurrentBlock(TeamMemoryBlock* block);

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.cpp

101

if (block != fTargetBlock) {

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.cpp

105

fTargetBlock = block;

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.cpp

106

if (block != NULL)

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.cpp

98

MemoryView::SetTargetAddress(TeamMemoryBlock* block, target_addr_t address)

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.h

58

void SetTargetAddress(TeamMemoryBlock* block,

src/apps/deskbar/ResourceSet.cpp

126

StringBlockTypeItem(const void* block, size_t size)

src/apps/deskbar/ResourceSet.cpp

127

: TStringBlock(block, size)

src/apps/deskbar/ResourceSet.cpp

313

TStringBlock::TStringBlock(const void* block, size_t size)

src/apps/deskbar/ResourceSet.cpp

320

fIndex = (size_t*)const_cast<void*>(block);

src/apps/deskbar/ResourceSet.cpp

321

fStrings = (char*)const_cast<void*>(block);

src/apps/deskbar/ResourceSet.h

61

TStringBlock(const void* block, size_t size);

src/apps/diskprobe/DataView.cpp

536

BRect block, lastLine;

src/apps/diskprobe/DataView.cpp

563

block = SelectionFrame(which, first, last - 1);

src/apps/diskprobe/DataView.cpp

564

block.right += spacing;

src/apps/diskprobe/DataView.cpp

584

bottom = block.bottom;

src/apps/diskprobe/DataView.cpp

599

rect = block;

src/apps/diskprobe/DataView.cpp

604

rect.bottom = block.bottom;

src/apps/diskprobe/ProbeView.cpp

1526

off_t block = message->FindInt64("block");

src/apps/diskprobe/ProbeView.cpp

1530

snprintf(buffer, sizeof(buffer), B_TRANSLATE("Block 0x%Lx"), (long long unsigned)block);

src/apps/diskprobe/ProbeView.cpp

1533

(long long int)block, (long long unsigned)block);

src/apps/diskprobe/ProbeView.cpp

1553

off_t block = position / fEditor.BlockSize();

src/apps/diskprobe/ProbeView.cpp

1561

if (block <= bookmark)

src/apps/diskprobe/ProbeView.cpp

1567

if (block == bookmark)

src/apps/diskprobe/ProbeView.cpp

1572

snprintf(buffer, sizeof(buffer), B_TRANSLATE("Block 0x%Lx"), (long long unsigned)block);

src/apps/diskprobe/ProbeView.cpp

1575

(long long int)block, (long long unsigned)block);

src/apps/diskprobe/ProbeView.cpp

1583

message->AddInt64("block", block);

src/apps/haikudepot/tar/TarArchiveService.cpp

179

TarArchiveService::_CalculateBlockChecksum(const uint8* block)

src/apps/haikudepot/tar/TarArchiveService.cpp

187

result += static_cast<uint32>(block[i]);

src/apps/haikudepot/tar/TarArchiveService.cpp

195

TarArchiveService::_ReadHeader(const uint8* block, TarArchiveHeader& header)

src/apps/haikudepot/tar/TarArchiveService.cpp

197

uint32 actualChecksum = _CalculateBlockChecksum(block);

src/apps/haikudepot/tar/TarArchiveService.cpp

198

uint32 expectedChecksum = _ReadHeaderNumeric(&block[OFFSET_CHECKSUM], LENGTH_CHECKSUM);

src/apps/haikudepot/tar/TarArchiveService.cpp

207

_ReadHeaderString(&block[OFFSET_FILENAME], LENGTH_FILENAME, fileName);

src/apps/haikudepot/tar/TarArchiveService.cpp

210

header.SetLength(_ReadHeaderNumeric(&block[OFFSET_LENGTH], LENGTH_LENGTH));

src/apps/haikudepot/tar/TarArchiveService.cpp

211

header.SetFileType(_ReadHeaderFileType(block[OFFSET_FILETYPE]));

src/apps/sudoku/SudokuView.cpp

1119

float block = fWidth * fBlockSize + kStrongLineSize;

src/apps/sudoku/SudokuView.cpp

1120

x = (uint32)floor(where.x / block);

src/apps/sudoku/SudokuView.cpp

1121

uint32 offsetX = (uint32)floor((where.x - x * block) / fWidth);

src/apps/sudoku/SudokuView.cpp

1124

block = fHeight * fBlockSize + kStrongLineSize;

src/apps/sudoku/SudokuView.cpp

1125

y = (uint32)floor(where.y / block);

src/apps/sudoku/SudokuView.cpp

1126

uint32 offsetY = (uint32)floor((where.y - y * block) / fHeight);

src/bin/badblocks.cpp

22

off_t block = startBlock;

src/bin/badblocks.cpp

23

off_t at = block * blockSize;

src/bin/badblocks.cpp

46

for (; block <= endBlock; block += group, at += len) {

src/bin/badblocks.cpp

49

fprintf(stderr, "checking block %lld\x1b[1A\n", block);

src/bin/badblocks.cpp

56

block, at, got, len);

src/bin/badblocks.cpp

60

fprintf(stderr, "block %lld: error: %s\n", block, strerror(errno));

src/bin/badblocks.cpp

75

fprintf(stderr, "block %lld: error: %s\n", block + i, strerror(errno));

src/bin/badblocks.cpp

77

fprintf(stderr, "block %lld: read %d bytes\n", block + i, got);

src/bin/badblocks.cpp

78

fprintf(outputFile, "%lld\n", block + i);

src/bin/bfs_tools/bfswhich.cpp

301

off_t block = disk.ToBlock(run);

src/bin/bfs_tools/bfswhich.cpp

310

} else if (block < 1) {

src/bin/bfs_tools/bfswhich.cpp

312

} else if (block < 1 + disk.BitmapSize()) {

src/bin/bfs_tools/lib/Bitmap.cpp

116

Bitmap::UsedAt(off_t block) const

src/bin/bfs_tools/lib/Bitmap.cpp

118

uint32 index = block / 32; // 32bit resolution, (beginning with block 1?)

src/bin/bfs_tools/lib/Bitmap.cpp

122

return fBitmap[index] & (1L << (block & 0x1f));

src/bin/bfs_tools/lib/Bitmap.cpp

127

Bitmap::BackupUsedAt(off_t block) const

src/bin/bfs_tools/lib/Bitmap.cpp

129

uint32 index = block / 32; // 32bit resolution, (beginning with block 1?)

src/bin/bfs_tools/lib/Bitmap.cpp

133

return fBackupBitmap[index] & (1L << (block & 0x1f));

src/bin/bfs_tools/lib/Bitmap.cpp

138

Bitmap::BackupSetAt(off_t block, bool used)

src/bin/bfs_tools/lib/Bitmap.cpp

140

uint32 index = block / 32;

src/bin/bfs_tools/lib/Bitmap.cpp

143

"bitmap!\n", block);

src/bin/bfs_tools/lib/Bitmap.cpp

147

int32 mask = 1L << (block & 0x1f);

src/bin/bfs_tools/lib/Bitmap.cpp

184

for (off_t block = start; block < end; block++) {

src/bin/bfs_tools/lib/Bitmap.cpp

185

if (!BackupSetAt(block, used)) {

src/bin/bfs_tools/lib/Bitmap.cpp

221

for (off_t block = start; block < end; block++) {

src/bin/bfs_tools/lib/Bitmap.cpp

223

if (!BackupSetAt(block, used))

src/bin/bfs_tools/lib/Bitmap.cpp

68

for (off_t block = 0; block < end; block++) {

src/bin/bfs_tools/lib/Bitmap.cpp

69

if (!BackupSetAt(block, true))

src/bin/bfs_tools/lib/Bitmap.h

27

bool UsedAt(off_t block) const;

src/bin/bfs_tools/lib/Bitmap.h

28

bool BackupUsedAt(off_t block) const;

src/bin/bfs_tools/lib/Bitmap.h

29

bool BackupSetAt(off_t block,bool used);

src/bin/bfs_tools/lib/Bitmap.h

34

bool TrustBlockContaining(off_t block) const;

src/bin/network/ftpd/md5c.c

237

MD5Transform (state, block)

src/bin/network/ftpd/md5c.c

239

const unsigned char block[64];

src/bin/network/ftpd/md5c.c

243

Decode (x, block, 64);

src/bin/network/telnet/telnet.c

2060

Scheduler(int block)

src/bin/network/telnet/telnet.c

2089

returnValue = process_rings(netin, netout, netex, ttyin, ttyout, !block);

src/kits/debugger/controllers/DebugReportGenerator.cpp

198

DebugReportGenerator::MemoryBlockRetrieved(TeamMemoryBlock* block)

src/kits/debugger/controllers/DebugReportGenerator.cpp

200

_HandleMemoryBlockRetrieved(block, B_OK);

src/kits/debugger/controllers/DebugReportGenerator.cpp

205

DebugReportGenerator::MemoryBlockRetrievalFailed(TeamMemoryBlock* block,

src/kits/debugger/controllers/DebugReportGenerator.cpp

208

_HandleMemoryBlockRetrieved(block, result);

src/kits/debugger/controllers/DebugReportGenerator.cpp

824

DebugReportGenerator::_HandleMemoryBlockRetrieved(TeamMemoryBlock* block,

src/kits/debugger/controllers/DebugReportGenerator.cpp

834

fCurrentBlock = block;

src/kits/debugger/controllers/DebugReportGenerator.h

56

virtual void MemoryBlockRetrieved(TeamMemoryBlock* block);

src/kits/debugger/controllers/DebugReportGenerator.h

58

TeamMemoryBlock* block, status_t result);

src/kits/debugger/controllers/DebugReportGenerator.h

86

TeamMemoryBlock* block, status_t result);

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

1129

DIELexicalBlock* block = dynamic_cast<DIELexicalBlock*>(it.Next());) {

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

1131

TRACE_LOCALS(" lexical block: %p\n", block);

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

1134

if (block->LowPC() != 0) {

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

1138

if (instructionPointer < block->LowPC()

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

1139

|| instructionPointer >= block->HighPC()) {

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

1147

block->AddressRangesOffset());

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

1163

instructionPointer, lowPC, block->Variables(), block->Blocks());

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

128

if (entry->block->AcquireReference() != 0)

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

129

return entry->block;

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

141

TeamMemoryBlock* block = new(std::nothrow) TeamMemoryBlock(address,

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

143

if (block == NULL)

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

145

ObjectDeleter<TeamMemoryBlock> blockDeleter(block);

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

147

entry = new(std::nothrow) MemoryBlockEntry(block);

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

155

return entry->block;

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

183

fDeadBlocks->Insert(entry->block);

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

202

TeamMemoryBlock* block = iterator.Next();

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

203

if (block->BaseAddress() == address) {

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

204

fDeadBlocks->Remove(block);

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

224

TeamMemoryBlockOwner::RemoveBlock(TeamMemoryBlock* block)

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

226

fBlockManager->_RemoveBlock(block->BaseAddress());

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

39

TeamMemoryBlock* block;

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

42

MemoryBlockEntry(TeamMemoryBlock* block)

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

44

Key(block->BaseAddress()),

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

45

block(block)

src/kits/debugger/debug_managers/TeamMemoryBlockManager.h

60

void RemoveBlock(TeamMemoryBlock* block);

src/kits/debugger/dwarf/AttributeClasses.cpp

202

{ ENTRY(block), AC_BLOCK },

src/kits/debugger/dwarf/AttributeValue.cpp

21

snprintf(buffer, size, "(%p, %#" B_PRIx64 ")", block.data,

src/kits/debugger/dwarf/AttributeValue.cpp

22

block.length);

src/kits/debugger/dwarf/AttributeValue.h

160

} block;

src/kits/debugger/dwarf/AttributeValue.h

190

block.data = data;

src/kits/debugger/dwarf/AttributeValue.h

191

block.length = length;

src/kits/debugger/dwarf/AttributeValue.h

204

} block;

src/kits/debugger/dwarf/AttributeValue.h

21

} block;

src/kits/debugger/dwarf/AttributeValue.h

233

block.data = data;

src/kits/debugger/dwarf/AttributeValue.h

234

block.length = length;

src/kits/debugger/dwarf/AttributeValue.h

62

block.data = data;

src/kits/debugger/dwarf/AttributeValue.h

63

block.length = length;

src/kits/debugger/dwarf/CfaRule.h

146

CfaRule::SetToLocationExpression(const void* block, size_t size)

src/kits/debugger/dwarf/CfaRule.h

149

fExpression.block = block;

src/kits/debugger/dwarf/CfaRule.h

155

CfaRule::SetToValueExpression(const void* block, size_t size)

src/kits/debugger/dwarf/CfaRule.h

158

fExpression.block = block;

src/kits/debugger/dwarf/CfaRule.h

190

CfaCfaRule::SetToExpression(const void* block, size_t size)

src/kits/debugger/dwarf/CfaRule.h

193

fExpression.block = block;

src/kits/debugger/dwarf/CfaRule.h

31

const void* block;

src/kits/debugger/dwarf/CfaRule.h

51

inline void SetToLocationExpression(const void* block,

src/kits/debugger/dwarf/CfaRule.h

53

inline void SetToValueExpression(const void* block,

src/kits/debugger/dwarf/CfaRule.h

80

inline void SetToExpression(const void* block, size_t size);

src/kits/debugger/dwarf/DebugInfoEntries.cpp

1495

fUseLocation.SetToExpression(value.block.data, value.block.length);

src/kits/debugger/dwarf/DebugInfoEntries.cpp

2088

fFrameBase.SetToExpression(value.block.data, value.block.length);

src/kits/debugger/dwarf/DebugInfoEntry.cpp

209

location->SetToExpression(value.block.data, value.block.length);

src/kits/debugger/dwarf/DebugInfoEntry.cpp

374

toSet.SetTo(value.block.data, value.block.length);

src/kits/debugger/dwarf/DebugInfoEntry.cpp

394

toSet.SetTo(value.block.data, value.block.length);

src/kits/debugger/dwarf/DebugInfoEntry.cpp

411

toSet.SetToExpression(value.block.data, value.block.length);

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

794

const void* block;

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

796

if (fContext->GetCallTarget(offset, refType, block, size) != B_OK)

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

800

if (block == NULL)

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

807

fDataReader.SetTo(block, size, savedReader.AddressSize(), savedReader.IsBigEndian());

src/kits/debugger/dwarf/DwarfFile.cpp

2409

cfaCfaRule->Expression().block,

src/kits/debugger/dwarf/DwarfFile.cpp

2484

rule->Expression().block,

src/kits/debugger/dwarf/DwarfFile.cpp

2503

rule->Expression().block,

src/kits/debugger/dwarf/DwarfFile.cpp

2826

uint8* block = (uint8*)dataReader.Data();

src/kits/debugger/dwarf/DwarfFile.cpp

2830

"\n", block, blockLength);

src/kits/debugger/dwarf/DwarfFile.cpp

2832

context.GetCfaCfaRule()->SetToExpression(block,

src/kits/debugger/dwarf/DwarfFile.cpp

2840

uint8* block = (uint8*)dataReader.Data();

src/kits/debugger/dwarf/DwarfFile.cpp

2844

"block: %p, %" B_PRIu64 "\n", reg, block, blockLength);

src/kits/debugger/dwarf/DwarfFile.cpp

2847

rule->SetToLocationExpression(block, blockLength);

src/kits/debugger/dwarf/DwarfFile.cpp

2923

uint8* block = (uint8*)dataReader.Data();

src/kits/debugger/dwarf/DwarfFile.cpp

2927

"block: %p, %" B_PRIu64 "\n", reg, block, blockLength);

src/kits/debugger/dwarf/DwarfFile.cpp

2930

rule->SetToValueExpression(block, blockLength);

src/kits/debugger/dwarf/DwarfFile.cpp

848

subprogramEntry, value->block.data, value->block.length,

src/kits/debugger/dwarf/DwarfFile.cpp

961

subprogramEntry, value->block.data, value->block.length,

src/kits/debugger/model/TeamMemoryBlock.cpp

126

TeamMemoryBlock::Listener::MemoryBlockRetrieved(TeamMemoryBlock* block)

src/kits/debugger/model/TeamMemoryBlock.cpp

132

TeamMemoryBlock::Listener::MemoryBlockRetrievalFailed(TeamMemoryBlock* block,

src/kits/debugger/user_interface/util/UiUtils.cpp

351

TeamMemoryBlock* block, target_addr_t address, int32 itemSize,

src/kits/debugger/user_interface/util/UiUtils.cpp

359

if (!block->Contains(address + i * itemSize))

src/kits/debugger/user_interface/util/UiUtils.cpp

375

c = *(block->Data() + address - block->BaseAddress()

src/kits/debugger/user_interface/util/UiUtils.cpp

390

value = block->Data() + address - block->BaseAddress()

src/kits/media/SoundPlayer.cpp

228

BSoundPlayer::Stop(bool block, bool flush)

src/kits/media/SoundPlayer.cpp

232

TRACE("BSoundPlayer::Stop: block %d, flush %d\n", (int)block, (int)flush);

src/kits/media/SoundPlayer.cpp

251

if (block) {

src/kits/package/hpkg/BlockBufferPoolImpl.cpp

42

while (PoolBuffer* block = fCachedBuffers.RemoveHead())

src/kits/package/hpkg/BlockBufferPoolImpl.cpp

43

delete block;

src/kits/package/hpkg/BlockBufferPoolImpl.cpp

45

while (PoolBuffer* block = fUnusedBuffers.RemoveHead())

src/kits/package/hpkg/BlockBufferPoolImpl.cpp

46

delete block;

src/kits/shared/md5.cpp

79

(ctx->block[(n)] = \

src/kits/shared/md5.cpp

85

(ctx->block[(n)])

src/kits/support/BlockCache.cpp

146

_FreeBlock *block = reinterpret_cast<_FreeBlock *>(pointer);

src/kits/support/BlockCache.cpp

147

block->next = fFreeList;

src/kits/support/BlockCache.cpp

148

fFreeList = block;

src/kits/support/BlockCache.cpp

150

DEBUG_ONLY(block->magic1 = MAGIC1);

src/kits/support/BlockCache.cpp

151

DEBUG_ONLY(block->magic2 = MAGIC2 + (uint32)(addr_t)block->next);

src/kits/support/BlockCache.cpp

77

_FreeBlock *block = reinterpret_cast<_FreeBlock *>(fAlloc(blockSize));

src/kits/support/BlockCache.cpp

78

if (!block)

src/kits/support/BlockCache.cpp

81

block->next = fFreeList;

src/kits/support/BlockCache.cpp

82

fFreeList = block;

src/kits/support/BlockCache.cpp

83

DEBUG_ONLY(block->magic1 = MAGIC1);

src/kits/support/BlockCache.cpp

84

DEBUG_ONLY(block->magic2 = MAGIC2 + (uint32)(addr_t)block->next);

src/kits/tracker/FSUtils.h

105

virtual void ChecksumChunk(const char* block, size_t size);

src/libs/compat/freebsd_iflib/md5c.c

235

MD5Transform (state, block)

src/libs/compat/freebsd_iflib/md5c.c

237

const unsigned char block[64];

src/libs/compat/freebsd_iflib/md5c.c

241

Decode (x, block, 64);

src/libs/compat/openbsd_wlan/crypto/md5.c

145

MD5Transform(u_int32_t state[4], const u_int8_t block[MD5_BLOCK_LENGTH])

src/libs/compat/openbsd_wlan/crypto/md5.c

150

memcpy(in, block, sizeof(in));

src/libs/compat/openbsd_wlan/crypto/md5.c

154

(u_int32_t)(block[a * 4 + 0]) |

src/libs/compat/openbsd_wlan/crypto/md5.c

155

(u_int32_t)(block[a * 4 + 1]) << 8 |

src/libs/compat/openbsd_wlan/crypto/md5.c

156

(u_int32_t)(block[a * 4 + 2]) << 16 |

src/libs/compat/openbsd_wlan/crypto/md5.c

157

(u_int32_t)(block[a * 4 + 3]) << 24);

src/libs/compat/openbsd_wlan/crypto/sha1.c

32

#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \

src/libs/compat/openbsd_wlan/crypto/sha1.c

33

|(rol(block->l[i],8)&0x00FF00FF))

src/libs/compat/openbsd_wlan/crypto/sha1.c

35

#define blk0(i) block->l[i]

src/libs/compat/openbsd_wlan/crypto/sha1.c

37

#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \

src/libs/compat/openbsd_wlan/crypto/sha1.c

38

^block->l[(i+2)&15]^block->l[i&15],1))

src/libs/compat/openbsd_wlan/crypto/sha1.c

57

CHAR64LONG16* block;

src/libs/compat/openbsd_wlan/crypto/sha1.c

61

block = (CHAR64LONG16 *)workspace;

src/libs/compat/openbsd_wlan/crypto/sha1.c

62

memcpy(block, buffer, SHA1_BLOCK_LENGTH);

src/libs/compat/openbsd_wlan/crypto/sha1.c

64

block = (CHAR64LONG16 *)buffer;

src/libs/libsolv/solv/md5.c

56

(ctx->block[(n)] = \

src/libs/libsolv/solv/md5.c

62

(ctx->block[(n)])

src/libs/libsolv/solv/md5.h

16

MD5_u32plus block[16];

src/libs/libsolv/solv/sha1.c

116

CHAR64LONG16 block;

src/libs/libsolv/solv/sha1.c

118

memcpy(&block, buffer, 64);

src/libs/libsolv/solv/sha1.c

92

#define blk0(i) block.l[i]

src/libs/libsolv/solv/sha1.c

94

#define blk0(i) (block.l[i] = (rol(block.l[i],24)&0xFF00FF00) \

src/libs/libsolv/solv/sha1.c

95

|(rol(block.l[i],8)&0x00FF00FF))

src/libs/libsolv/solv/sha1.c

97

#define blk(i) (block.l[i&15] = rol(block.l[(i+13)&15]^block.l[(i+8)&15] \

src/libs/libsolv/solv/sha1.c

98

^block.l[(i+2)&15]^block.l[i&15],1))

src/libs/libsolv/solv/util.h

43

static inline void *solv_extend(void *buf, size_t len, size_t nmemb, size_t size, size_t block)

src/libs/libsolv/solv/util.h

47

if ((len & block) == 0)

src/libs/libsolv/solv/util.h

48

buf = solv_realloc2(buf, len + (1 + block), size);

src/libs/libsolv/solv/util.h

52

if (((len - 1) | block) != ((len + nmemb - 1) | block))

src/libs/libsolv/solv/util.h

53

buf = solv_realloc2(buf, (len + (nmemb + block)) & ~block, size);

src/libs/libsolv/solv/util.h

66

static inline void *solv_zextend(void *buf, size_t len, size_t nmemb, size_t size, size_t block)

src/libs/libsolv/solv/util.h

68

buf = solv_extend(buf, len, nmemb, size, block);

src/libs/libsolv/solv/util.h

73

static inline void *solv_extend_resize(void *buf, size_t len, size_t size, size_t block)

src/libs/libsolv/solv/util.h

76

buf = solv_realloc2(buf, (len + block) & ~block, size);

src/libs/libsolv/solv/util.h

80

static inline void *solv_calloc_block(size_t len, size_t size, size_t block)

src/libs/libsolv/solv/util.h

85

buf = solv_malloc2((len + block) & ~block, size);

src/libs/libsolv/solv/util.h

86

memset(buf, 0, ((len + block) & ~block) * size);

src/servers/app/ClientMemoryAllocator.cpp

108

struct block* usedBlock = (struct block*)malloc(sizeof(struct block));

src/servers/app/ClientMemoryAllocator.cpp

125

ClientMemoryAllocator::Free(block* freeBlock)

src/servers/app/ClientMemoryAllocator.cpp

135

struct block* before = NULL;

src/servers/app/ClientMemoryAllocator.cpp

136

struct block* after = NULL;

src/servers/app/ClientMemoryAllocator.cpp

144

while (struct block* block = iterator.Next()) {

src/servers/app/ClientMemoryAllocator.cpp

145

if (block->chunk != freeBlock->chunk)

src/servers/app/ClientMemoryAllocator.cpp

148

if (block->base + block->size == freeBlock->base)

src/servers/app/ClientMemoryAllocator.cpp

149

before = block;

src/servers/app/ClientMemoryAllocator.cpp

151

if (block->base == freeBlock->base + freeBlock->size)

src/servers/app/ClientMemoryAllocator.cpp

152

after = block;

src/servers/app/ClientMemoryAllocator.cpp

219

while (struct block* block = blockIterator.Next()) {

src/servers/app/ClientMemoryAllocator.cpp

221

i++, block, block->chunk, block->base, block->size);

src/servers/app/ClientMemoryAllocator.cpp

226

struct block*

src/servers/app/ClientMemoryAllocator.cpp

244

struct block* block;

src/servers/app/ClientMemoryAllocator.cpp

258

block = (struct block*)malloc(sizeof(struct block));

src/servers/app/ClientMemoryAllocator.cpp

259

if (block == NULL) {

src/servers/app/ClientMemoryAllocator.cpp

274

free(block);

src/servers/app/ClientMemoryAllocator.cpp

288

block = (struct block *)malloc(sizeof(struct block));

src/servers/app/ClientMemoryAllocator.cpp

289

if (block == NULL)

src/servers/app/ClientMemoryAllocator.cpp

298

block->chunk = chunk;

src/servers/app/ClientMemoryAllocator.cpp

299

block->base = address;

src/servers/app/ClientMemoryAllocator.cpp

300

block->size = size;

src/servers/app/ClientMemoryAllocator.cpp

302

fFreeBlocks.Add(block);

src/servers/app/ClientMemoryAllocator.cpp

304

return block;

src/servers/app/ClientMemoryAllocator.cpp

49

struct block* block = fFreeBlocks.RemoveHead();

src/servers/app/ClientMemoryAllocator.cpp

50

if (block == NULL)

src/servers/app/ClientMemoryAllocator.cpp

53

free(block);

src/servers/app/ClientMemoryAllocator.cpp

68

ClientMemoryAllocator::Allocate(size_t size, block** _address)

src/servers/app/ClientMemoryAllocator.cpp

79

struct block* block;

src/servers/app/ClientMemoryAllocator.cpp

80

struct block* best = NULL;

src/servers/app/ClientMemoryAllocator.cpp

82

while ((block = iterator.Next()) != NULL) {

src/servers/app/ClientMemoryAllocator.cpp

83

if (block->size >= size && (best == NULL || block->size < best->size))

src/servers/app/ClientMemoryAllocator.cpp

84

best = block;

src/servers/app/ClientMemoryAllocator.h

20

struct block;

src/servers/app/ClientMemoryAllocator.h

28

struct block : DoublyLinkedListLinkImpl<struct block> {

src/servers/app/ClientMemoryAllocator.h

34

typedef DoublyLinkedList<block> block_list;

src/servers/app/ClientMemoryAllocator.h

43

void* Allocate(size_t size, block** _address);

src/servers/app/ClientMemoryAllocator.h

44

void Free(block* cookie);

src/servers/app/ClientMemoryAllocator.h

51

struct block* _AllocateChunk(size_t size);

src/servers/app/ClientMemoryAllocator.h

87

block* fBlock;

src/servers/app/ServerFont.cpp

525

uint32 block = 0;

src/servers/app/ServerFont.cpp

539

currentCodePoint = baseCodePoint + block;

src/servers/app/ServerFont.cpp

552

| kUnicodeBlockMap[startBlock].block;

src/servers/app/ServerFont.cpp

570

| kUnicodeBlockMap[startBlock].block;

src/servers/app/ServerFont.cpp

600

| kUnicodeBlockMap[startBlock].block;

src/servers/app/ServerFont.cpp

605

block += BITS_PER_BLOCK;

src/servers/launch/Utility.cpp

88

BlockMedia(const char* path, bool block)

src/servers/launch/Utility.cpp

90

return IssueDeviceCommand(path, B_SCSI_PREVENT_ALLOW, &block,

src/servers/launch/Utility.cpp

91

sizeof(block));

src/servers/launch/Utility.h

16

status_t BlockMedia(const char* path, bool block);

src/servers/registrar/ShutdownProcess.cpp

1225

bool block)

src/servers/registrar/ShutdownProcess.cpp

1229

if (block) {

src/servers/registrar/ShutdownProcess.h

50

int32& phase, bool block);

src/system/boot/loader/file_systems/amiga_ffs/Directory.cpp

102

int32 block;

src/system/boot/loader/file_systems/amiga_ffs/Directory.cpp

103

while ((node = iterator.GetNext(block)) != NULL) {

src/system/boot/loader/file_systems/amiga_ffs/Directory.cpp

108

return new(nothrow) File(fVolume, block);

src/system/boot/loader/file_systems/amiga_ffs/Directory.cpp

110

return new(nothrow) Directory(fVolume, block);

src/system/boot/loader/file_systems/amiga_ffs/Directory.cpp

123

int32 block;

src/system/boot/loader/file_systems/amiga_ffs/Directory.cpp

125

NodeBlock *node = iterator->GetNext(block);

src/system/boot/loader/file_systems/amiga_ffs/Directory.cpp

24

Directory::Directory(Volume &volume, int32 block)

src/system/boot/loader/file_systems/amiga_ffs/Directory.cpp

32

if (read_pos(volume.Device(), block * volume.BlockSize(), data, volume.BlockSize()) == volume.BlockSize())

src/system/boot/loader/file_systems/amiga_ffs/Directory.h

22

Directory(Volume &volume, int32 block);

src/system/boot/loader/file_systems/amiga_ffs/File.cpp

132

int32 block;

src/system/boot/loader/file_systems/amiga_ffs/File.cpp

134

block = fNode.DataBlock(BlockIndex(offset));

src/system/boot/loader/file_systems/amiga_ffs/File.cpp

136

block = fBlock.DataBlock(BlockIndex(offset));

src/system/boot/loader/file_systems/amiga_ffs/File.cpp

143

ssize_t bytesRead = read_pos(fDevice, block * fNode.BlockSize() + blockOffset,

src/system/boot/loader/file_systems/amiga_ffs/File.cpp

160

File::File(Volume &volume, int32 block)

src/system/boot/loader/file_systems/amiga_ffs/File.cpp

168

if (read_pos(volume.Device(), block * volume.BlockSize(), data, volume.BlockSize()) == volume.BlockSize())

src/system/boot/loader/file_systems/amiga_ffs/File.h

18

File(Volume &volume, int32 block);

src/system/boot/loader/file_systems/amiga_ffs/amiga_ffs.cpp

170

HashIterator::GetNext(int32 &block)

src/system/boot/loader/file_systems/amiga_ffs/amiga_ffs.cpp

182

block = fBlock;

src/system/boot/loader/file_systems/amiga_ffs/amiga_ffs.h

149

NodeBlock *GetNext(int32 &block);

src/system/boot/loader/file_systems/bfs/Stream.cpp

244

off_t block = fVolume.ToBlock(data.indirect);

src/system/boot/loader/file_systems/bfs/Stream.cpp

247

block_run* indirect = (block_run *)cached.SetTo(block + i);

src/system/boot/loader/file_systems/bfs/Stream.cpp

322

uint8* block;

src/system/boot/loader/file_systems/bfs/Stream.cpp

335

if ((block = cached.Block()) == NULL) {

src/system/boot/loader/file_systems/bfs/Stream.cpp

344

memcpy(buffer, block + (pos % blockSize), bytesRead);

src/system/boot/loader/file_systems/bfs/Stream.cpp

375

if ((block = cached.Block()) == NULL) {

src/system/boot/loader/file_systems/bfs/Stream.cpp

379

memcpy(buffer + bytesRead, block, length);

src/system/boot/loader/file_systems/bfs/Stream.cpp

81

CachedBlock::SetTo(off_t block)

src/system/boot/loader/file_systems/bfs/Stream.cpp

83

if (block == fBlockNumber)

src/system/boot/loader/file_systems/bfs/Stream.cpp

91

fBlockNumber = block;

src/system/boot/loader/file_systems/bfs/Stream.cpp

92

if (read_pos(fVolume.Device(), block << BlockShift(), fBlock, BlockSize())

src/system/boot/loader/file_systems/bfs/Volume.h

49

off_t ToOffset(off_t block) const { return block << BlockShift(); }

src/system/boot/loader/file_systems/bfs/Volume.h

51

block_run ToBlockRun(off_t block) const;

src/system/boot/loader/file_systems/bfs/Volume.h

55

off_t ToVnode(off_t block) const { return block; }

src/system/boot/loader/file_systems/bfs/bfs.cpp

124

Volume::ToBlockRun(off_t block) const

src/system/boot/loader/file_systems/bfs/bfs.cpp

127

run.allocation_group = HOST_ENDIAN_TO_BFS_INT32(block >> fSuperBlock.AllocationGroupShift());

src/system/boot/loader/file_systems/bfs/bfs.cpp

128

run.start = HOST_ENDIAN_TO_BFS_INT16(block & ~((1LL << fSuperBlock.AllocationGroupShift()) - 1));

src/system/boot/loader/file_systems/fat/CachedBlock.cpp

32

CachedBlock::CachedBlock(Volume &volume, off_t block)

src/system/boot/loader/file_systems/fat/CachedBlock.cpp

38

SetTo(block);

src/system/boot/loader/file_systems/fat/CachedBlock.cpp

49

CachedBlock::SetTo(off_t block)

src/system/boot/loader/file_systems/fat/CachedBlock.cpp

51

status_t error = SetTo(block, READ);

src/system/boot/loader/file_systems/fat/CachedBlock.h

28

CachedBlock(Volume &volume, off_t block);

src/system/boot/loader/file_systems/fat/CachedBlock.h

31

uint8 *SetTo(off_t block);

src/system/boot/loader/file_systems/fat/Directory.cpp

498

off_t block = volume.ToBlock(dirEntryOffset);

src/system/boot/loader/file_systems/fat/Directory.cpp

500

status_t error = cachedBlock.SetTo(block, CachedBlock::READ);

src/system/boot/loader/file_systems/fat/Stream.cpp

121

if (fClusterMapCache[i].block == index) {

src/system/boot/loader/file_systems/fat/Stream.cpp

145

fClusterMapCache[fClusterMapCacheLast].block = index;

src/system/boot/loader/file_systems/fat/Stream.cpp

212

Stream::FindBlock(off_t pos, off_t &block, off_t &offset)

src/system/boot/loader/file_systems/fat/Stream.cpp

224

block = fVolume.ToBlock(offset);

src/system/boot/loader/file_systems/fat/Stream.cpp

272

uint8 *block;

src/system/boot/loader/file_systems/fat/Stream.cpp

280

if ((block = cached.Block()) == NULL) {

src/system/boot/loader/file_systems/fat/Stream.cpp

289

memcpy(buffer, block + (pos % blockSize), bytesRead);

src/system/boot/loader/file_systems/fat/Stream.cpp

313

if ((block = cached.Block()) == NULL) {

src/system/boot/loader/file_systems/fat/Stream.cpp

317

memcpy(buffer + bytesRead, block, length);

src/system/boot/loader/file_systems/fat/Stream.cpp

379

off_t block = fVolume.ToBlock(offset);

src/system/boot/loader/file_systems/fat/Stream.cpp

388

fVolume.BlockToOffset(block), buffer, fVolume.BlockSize());

src/system/boot/loader/file_systems/fat/Stream.cpp

399

error = cachedBlock.SetTo(block, CachedBlock::READ);

src/system/boot/loader/file_systems/fat/Stream.cpp

48

fClusterMapCache[i].block = -1;

src/system/boot/loader/file_systems/fat/Stream.cpp

86

runs[i].block = fVolume.ToBlock(cluster);

src/system/boot/loader/file_systems/fat/Stream.h

49

status_t FindBlock(off_t pos, off_t &block, off_t &offset);

src/system/boot/loader/file_systems/fat/Stream.h

56

off_t block;

src/system/boot/loader/file_systems/fat/Volume.h

57

off_t BlockToOffset(off_t block) const

src/system/boot/loader/file_systems/fat/Volume.h

58

{ return block << BlockShift(); }

src/system/boot/loader/file_systems/tarfs/tarfs.cpp

678

char* block = (char*)regionDeleter.Get();

src/system/boot/loader/file_systems/tarfs/tarfs.cpp

684

tar_header* header = (tar_header*)(block + blockIndex * BLOCK_SIZE);

src/system/boot/loader/kernel_args.cpp

436

void* block = NULL;

src/system/boot/loader/kernel_args.cpp

437

if (platform_allocate_region(&block, alignedSize,

src/system/boot/loader/kernel_args.cpp

444

platform_bootloader_address_to_kernel_address(block, &translated_block);

src/system/boot/loader/kernel_args.cpp

448

return (void*)ALIGN((addr_t)block, alignment);

src/system/boot/loader/kernel_args.cpp

452

void* block = NULL;

src/system/boot/loader/kernel_args.cpp

453

if (platform_allocate_region(&block, kChunkSize, B_READ_AREA | B_WRITE_AREA) != B_OK)

src/system/boot/loader/kernel_args.cpp

456

sFirstFree = (void*)((addr_t)block + alignedSize);

src/system/boot/loader/kernel_args.cpp

457

sLast = block;

src/system/boot/loader/kernel_args.cpp

462

platform_bootloader_address_to_kernel_address(block, &translated_block);

src/system/boot/loader/kernel_args.cpp

466

return (void*)ALIGN((addr_t)block, alignment);

src/system/boot/loader/kernel_args.cpp

475

kernel_args_free(void* block)

src/system/boot/loader/kernel_args.cpp

477

if (sLast != block) {

src/system/boot/loader/kernel_args.cpp

483

sFirstFree = block;

src/system/boot/platform/bios_ia32/mmu.cpp

298

extended_memory *block = (extended_memory *)kExtraSegmentScratch;

src/system/boot/platform/bios_ia32/mmu.cpp

305

regs.edi = (uint32)block;

src/system/boot/platform/bios_ia32/mmu.cpp

319

*_extendedMemory = block;

src/system/boot/platform/bios_ia32/mmu.cpp

325

block[i].base_addr, block[i].length,

src/system/boot/platform/bios_ia32/mmu.cpp

326

block[i].type, e820_memory_type(block[i].type));

src/system/kernel/cache/block_cache.cpp

1110

cached_block* block = transaction->first_block;

src/system/kernel/cache/block_cache.cpp

1111

for (; block != NULL; block = block->transaction_next) {

src/system/kernel/cache/block_cache.cpp

1112

if (block->previous_transaction != NULL) {

src/system/kernel/cache/block_cache.cpp

1114

writer.Add(block);

src/system/kernel/cache/block_cache.cpp

1162

BlockWriter::Add(cached_block* block, cache_transaction* transaction)

src/system/kernel/cache/block_cache.cpp

1164

ASSERT(block->CanBeWritten());

src/system/kernel/cache/block_cache.cpp

1193

fBlocks[fCount++] = block;

src/system/kernel/cache/block_cache.cpp

1195

block->busy_writing = true;

src/system/kernel/cache/block_cache.cpp

1197

if (block->previous_transaction != NULL)

src/system/kernel/cache/block_cache.cpp

1198

block->previous_transaction->busy_writing_count++;

src/system/kernel/cache/block_cache.cpp

1220

while (cached_block* block = blockIterator.Next()) {

src/system/kernel/cache/block_cache.cpp

1221

if (!block->CanBeWritten()) {

src/system/kernel/cache/block_cache.cpp

1227

if (!Add(block, transaction))

src/system/kernel/cache/block_cache.cpp

129

static inline void operator delete(void* block);

src/system/kernel/cache/block_cache.cpp

1306

BlockWriter::WriteBlock(block_cache* cache, cached_block* block)

src/system/kernel/cache/block_cache.cpp

1310

writer.Add(block);

src/system/kernel/cache/block_cache.cpp

1316

BlockWriter::_Data(cached_block* block) const

src/system/kernel/cache/block_cache.cpp

1318

return block->previous_transaction != NULL && block->original_data != NULL

src/system/kernel/cache/block_cache.cpp

1319

? block->original_data : block->current_data;

src/system/kernel/cache/block_cache.cpp

1331

cached_block* block = blocks[i];

src/system/kernel/cache/block_cache.cpp

1332

ASSERT(block->busy_writing);

src/system/kernel/cache/block_cache.cpp

1333

ASSERT(i == 0 || block->block_number == (blocks[i - 1]->block_number + 1));

src/system/kernel/cache/block_cache.cpp

1336

block->block_number, count));

src/system/kernel/cache/block_cache.cpp

1337

TB(Write(fCache, block));

src/system/kernel/cache/block_cache.cpp

1338

TB2(BlockData(fCache, block, "before write"));

src/system/kernel/cache/block_cache.cpp

1340

vecs[i].iov_base = _Data(block);

src/system/kernel/cache/block_cache.cpp

1348

TB(Error(fCache, block->block_number, "write failed", written));

src/system/kernel/cache/block_cache.cpp

1362

BlockWriter::_BlockDone(cached_block* block,

src/system/kernel/cache/block_cache.cpp

1365

if (block == NULL) {

src/system/kernel/cache/block_cache.cpp

1373

if (_Data(block) == block->current_data)

src/system/kernel/cache/block_cache.cpp

1374

block->is_dirty = false;

src/system/kernel/cache/block_cache.cpp

1376

_UnmarkWriting(block);

src/system/kernel/cache/block_cache.cpp

1378

cache_transaction* previous = block->previous_transaction;

src/system/kernel/cache/block_cache.cpp

1380

previous->blocks.Remove(block);

src/system/kernel/cache/block_cache.cpp

1381

block->previous_transaction = NULL;

src/system/kernel/cache/block_cache.cpp

1383

if (block->original_data != NULL && block->transaction == NULL) {

src/system/kernel/cache/block_cache.cpp

1386

fCache->Free(block->original_data);

src/system/kernel/cache/block_cache.cpp

1387

block->original_data = NULL;

src/system/kernel/cache/block_cache.cpp

1411

if (block->transaction == NULL && block->ref_count == 0 && !block->unused) {

src/system/kernel/cache/block_cache.cpp

1413

ASSERT(block->original_data == NULL && block->parent_data == NULL);

src/system/kernel/cache/block_cache.cpp

1414

block->unused = true;

src/system/kernel/cache/block_cache.cpp

1415

fCache->unused_blocks.Add(block);

src/system/kernel/cache/block_cache.cpp

1419

TB2(BlockData(fCache, block, "after write"));

src/system/kernel/cache/block_cache.cpp

1424

BlockWriter::_UnmarkWriting(cached_block* block)

src/system/kernel/cache/block_cache.cpp

1426

block->busy_writing = false;

src/system/kernel/cache/block_cache.cpp

1427

if (block->previous_transaction != NULL)

src/system/kernel/cache/block_cache.cpp

1428

block->previous_transaction->busy_writing_count--;

src/system/kernel/cache/block_cache.cpp

1432

|| block->busy_writing_waiters) {

src/system/kernel/cache/block_cache.cpp

1434

block->busy_writing_waiters = false;

src/system/kernel/cache/block_cache.cpp

1500

cached_block* block = fCache->hash.Lookup(blockNumIter);

src/system/kernel/cache/block_cache.cpp

1501

if (block != NULL) {

src/system/kernel/cache/block_cache.cpp

1513

cached_block* block = fCache->NewBlock(fBlockNumber + i);

src/system/kernel/cache/block_cache.cpp

1514

if (block == NULL) {

src/system/kernel/cache/block_cache.cpp

1518

fCache->hash.Insert(block);

src/system/kernel/cache/block_cache.cpp

1520

block->unused = true;

src/system/kernel/cache/block_cache.cpp

1521

fCache->unused_blocks.Add(block);

src/system/kernel/cache/block_cache.cpp

1524

fBlocks[i] = block;

src/system/kernel/cache/block_cache.cpp

167

cache_notification::operator delete(void* block)

src/system/kernel/cache/block_cache.cpp

169

object_cache_free(sCacheNotificationCache, block, 0);

src/system/kernel/cache/block_cache.cpp

1711

void* block = object_cache_alloc(buffer_cache, 0);

src/system/kernel/cache/block_cache.cpp

1712

if (block != NULL)

src/system/kernel/cache/block_cache.cpp

1713

return block;

src/system/kernel/cache/block_cache.cpp

1723

block_cache::FreeBlock(cached_block* block)

src/system/kernel/cache/block_cache.cpp

1725

Free(block->current_data);

src/system/kernel/cache/block_cache.cpp

1727

if (block->original_data != NULL || block->parent_data != NULL) {

src/system/kernel/cache/block_cache.cpp

1729

block->block_number, block->original_data, block->parent_data);

src/system/kernel/cache/block_cache.cpp

1733

Free(block->compare);

src/system/kernel/cache/block_cache.cpp

1736

object_cache_free(sBlockCache, block, 0);

src/system/kernel/cache/block_cache.cpp

1744

cached_block* block = NULL;

src/system/kernel/cache/block_cache.cpp

1749

block = _GetUnusedBlock();

src/system/kernel/cache/block_cache.cpp

1751

if (block == NULL) {

src/system/kernel/cache/block_cache.cpp

1752

block = (cached_block*)object_cache_alloc(sBlockCache, 0);

src/system/kernel/cache/block_cache.cpp

1753

if (block != NULL) {

src/system/kernel/cache/block_cache.cpp

1754

block->current_data = Allocate();

src/system/kernel/cache/block_cache.cpp

1755

if (block->current_data == NULL) {

src/system/kernel/cache/block_cache.cpp

1756

object_cache_free(sBlockCache, block, 0);

src/system/kernel/cache/block_cache.cpp

1765

block = _GetUnusedBlock();

src/system/kernel/cache/block_cache.cpp

1766

if (block == NULL) {

src/system/kernel/cache/block_cache.cpp

1774

block->block_number = blockNumber;

src/system/kernel/cache/block_cache.cpp

1775

block->ref_count = 0;

src/system/kernel/cache/block_cache.cpp

1776

block->last_accessed = 0;

src/system/kernel/cache/block_cache.cpp

1777

block->transaction_next = NULL;

src/system/kernel/cache/block_cache.cpp

1778

block->transaction = block->previous_transaction = NULL;

src/system/kernel/cache/block_cache.cpp

1779

block->original_data = NULL;

src/system/kernel/cache/block_cache.cpp

1780

block->parent_data = NULL;

src/system/kernel/cache/block_cache.cpp

1781

block->busy_reading = false;

src/system/kernel/cache/block_cache.cpp

1782

block->busy_writing = false;

src/system/kernel/cache/block_cache.cpp

1783

block->is_writing = false;

src/system/kernel/cache/block_cache.cpp

1784

block->is_dirty = false;

src/system/kernel/cache/block_cache.cpp

1785

block->unused = false;

src/system/kernel/cache/block_cache.cpp

1786

block->discard = false;

src/system/kernel/cache/block_cache.cpp

1787

block->busy_reading_waiters = false;

src/system/kernel/cache/block_cache.cpp

1788

block->busy_writing_waiters = false;

src/system/kernel/cache/block_cache.cpp

1790

block->compare = NULL;

src/system/kernel/cache/block_cache.cpp

1793

return block;

src/system/kernel/cache/block_cache.cpp

1798

block_cache::FreeBlockParentData(cached_block* block)

src/system/kernel/cache/block_cache.cpp

1800

ASSERT(block->parent_data != NULL);

src/system/kernel/cache/block_cache.cpp

1801

if (block->parent_data != block->current_data)

src/system/kernel/cache/block_cache.cpp

1802

Free(block->parent_data);

src/system/kernel/cache/block_cache.cpp

1803

block->parent_data = NULL;

src/system/kernel/cache/block_cache.cpp

1813

cached_block* block = iterator.Next();) {

src/system/kernel/cache/block_cache.cpp

1814

if (minSecondsOld >= block->LastAccess()) {

src/system/kernel/cache/block_cache.cpp

1818

if (block->busy_reading || block->busy_writing)

src/system/kernel/cache/block_cache.cpp

182

size_t Hash(ValueType* block) const

src/system/kernel/cache/block_cache.cpp

1821

TB(Flush(this, block));

src/system/kernel/cache/block_cache.cpp

1823

block->block_number, block->last_accessed));

src/system/kernel/cache/block_cache.cpp

1826

if (block->is_dirty && !block->discard) {

src/system/kernel/cache/block_cache.cpp

1827

if (block->busy_writing)

src/system/kernel/cache/block_cache.cpp

1830

BlockWriter::WriteBlock(this, block);

src/system/kernel/cache/block_cache.cpp

1836

RemoveBlock(block);

src/system/kernel/cache/block_cache.cpp

184

return block->block_number;

src/system/kernel/cache/block_cache.cpp

1845

block_cache::RemoveBlock(cached_block* block)

src/system/kernel/cache/block_cache.cpp

1847

hash.Remove(block);

src/system/kernel/cache/block_cache.cpp

1848

FreeBlock(block);

src/system/kernel/cache/block_cache.cpp

1856

block_cache::DiscardBlock(cached_block* block)

src/system/kernel/cache/block_cache.cpp

1858

ASSERT(block->discard);

src/system/kernel/cache/block_cache.cpp

1859

ASSERT(block->previous_transaction == NULL);

src/system/kernel/cache/block_cache.cpp

1861

if (block->parent_data != NULL)

src/system/kernel/cache/block_cache.cpp

1862

FreeBlockParentData(block);

src/system/kernel/cache/block_cache.cpp

1864

if (block->original_data != NULL) {

src/system/kernel/cache/block_cache.cpp

1865

Free(block->original_data);

src/system/kernel/cache/block_cache.cpp

1866

block->original_data = NULL;

src/system/kernel/cache/block_cache.cpp

1869

RemoveBlock(block);

src/system/kernel/cache/block_cache.cpp

187

bool Compare(KeyType key, ValueType* block) const

src/system/kernel/cache/block_cache.cpp

189

return block->block_number == key;

src/system/kernel/cache/block_cache.cpp

1930

cached_block* block = iterator.Next();) {

src/system/kernel/cache/block_cache.cpp

1931

TB(Flush(this, block, true));

src/system/kernel/cache/block_cache.cpp

1934

if (block->is_dirty && !block->busy_writing && !block->discard)

src/system/kernel/cache/block_cache.cpp

1935

BlockWriter::WriteBlock(this, block);

src/system/kernel/cache/block_cache.cpp

1940

hash.Remove(block);

src/system/kernel/cache/block_cache.cpp

1942

ASSERT(block->original_data == NULL && block->parent_data == NULL);

src/system/kernel/cache/block_cache.cpp

1943

block->unused = false;

src/system/kernel/cache/block_cache.cpp

1947

if (block->compare != NULL)

src/system/kernel/cache/block_cache.cpp

1948

Free(block->compare);

src/system/kernel/cache/block_cache.cpp

1950

return block;

src/system/kernel/cache/block_cache.cpp

1963

mark_block_busy_reading(block_cache* cache, cached_block* block)

src/system/kernel/cache/block_cache.cpp

1965

block->busy_reading = true;

src/system/kernel/cache/block_cache.cpp

1973

mark_block_unbusy_reading(block_cache* cache, cached_block* block)

src/system/kernel/cache/block_cache.cpp

1975

block->busy_reading = false;

src/system/kernel/cache/block_cache.cpp

1979

|| block->busy_reading_waiters) {

src/system/kernel/cache/block_cache.cpp

1981

block->busy_reading_waiters = false;

src/system/kernel/cache/block_cache.cpp

1990

wait_for_busy_reading_block(block_cache* cache, cached_block* block)

src/system/kernel/cache/block_cache.cpp

1992

while (block->busy_reading) {

src/system/kernel/cache/block_cache.cpp

1996

block->busy_reading_waiters = true;

src/system/kernel/cache/block_cache.cpp

2026

wait_for_busy_writing_block(block_cache* cache, cached_block* block)

src/system/kernel/cache/block_cache.cpp

2028

while (block->busy_writing) {

src/system/kernel/cache/block_cache.cpp

2032

block->busy_writing_waiters = true;

src/system/kernel/cache/block_cache.cpp

2065

put_cached_block(block_cache* cache, cached_block* block, WriteLocker* writeLocker = NULL)

src/system/kernel/cache/block_cache.cpp

2068

if (block->compare != NULL

src/system/kernel/cache/block_cache.cpp

2069

&& memcmp(block->current_data, block->compare, cache->block_size) != 0) {

src/system/kernel/cache/block_cache.cpp

2076

dump_block((const char*)block->current_data, 256, " ");

src/system/kernel/cache/block_cache.cpp

2078

dump_block((const char*)block->compare, 256, " ");

src/system/kernel/cache/block_cache.cpp

2079

BlockWriter::WriteBlock(cache, block);

src/system/kernel/cache/block_cache.cpp

2082

cache->Free(block->compare);

src/system/kernel/cache/block_cache.cpp

2083

block->compare = NULL;

src/system/kernel/cache/block_cache.cpp

2086

TB(Put(cache, block));

src/system/kernel/cache/block_cache.cpp

2091

if (!block->discard && !block->is_writing

src/system/kernel/cache/block_cache.cpp

2092

&& block->transaction == NULL

src/system/kernel/cache/block_cache.cpp

2093

&& block->previous_transaction == NULL) {

src/system/kernel/cache/block_cache.cpp

2094

if (atomic_add(&block->ref_count, -1) == 1) {

src/system/kernel/cache/block_cache.cpp

2096

if (atomic_get(&block->ref_count) == 0 && !block->unused) {

src/system/kernel/cache/block_cache.cpp

2097

cache->unused_blocks.Add(block);

src/system/kernel/cache/block_cache.cpp

2099

block->unused = true;

src/system/kernel/cache/block_cache.cpp

2110

if (block->ref_count < 1) {

src/system/kernel/cache/block_cache.cpp

2111

panic("Invalid ref_count for block %p, cache %p\n", block, cache);

src/system/kernel/cache/block_cache.cpp

2115

if (--block->ref_count == 0

src/system/kernel/cache/block_cache.cpp

2116

&& block->transaction == NULL

src/system/kernel/cache/block_cache.cpp

2117

&& block->previous_transaction == NULL) {

src/system/kernel/cache/block_cache.cpp

2119

block->is_writing = false;

src/system/kernel/cache/block_cache.cpp

2121

if (block->discard) {

src/system/kernel/cache/block_cache.cpp

2122

cache->RemoveBlock(block);

src/system/kernel/cache/block_cache.cpp

2125

ASSERT(!block->unused);

src/system/kernel/cache/block_cache.cpp

2126

block->unused = true;

src/system/kernel/cache/block_cache.cpp

2128

ASSERT(block->original_data == NULL && block->parent_data == NULL);

src/system/kernel/cache/block_cache.cpp

2129

cache->unused_blocks.Add(block);

src/system/kernel/cache/block_cache.cpp

2144

cached_block* block = cache->hash.Lookup(blockNumber);

src/system/kernel/cache/block_cache.cpp

2145

if (block != NULL) {

src/system/kernel/cache/block_cache.cpp

2146

put_cached_block(cache, block, writeLocker);

src/system/kernel/cache/block_cache.cpp

2177

cached_block* block = cache->hash.Lookup(blockNumber);

src/system/kernel/cache/block_cache.cpp

2180

if (block == NULL) {

src/system/kernel/cache/block_cache.cpp

2182

block = cache->NewBlock(blockNumber);

src/system/kernel/cache/block_cache.cpp

2183

if (block == NULL)

src/system/kernel/cache/block_cache.cpp

2186

cache->hash.Insert(block);

src/system/kernel/cache/block_cache.cpp

2188

} else if (block->busy_reading) {

src/system/kernel/cache/block_cache.cpp

2190

wait_for_busy_reading_block(cache, block);

src/system/kernel/cache/block_cache.cpp

2197

if (block->unused) {

src/system/kernel/cache/block_cache.cpp

2199

block->unused = false;

src/system/kernel/cache/block_cache.cpp

2200

cache->unused_blocks.Remove(block);

src/system/kernel/cache/block_cache.cpp

2208

mark_block_busy_reading(cache, block);

src/system/kernel/cache/block_cache.cpp

2212

block->current_data, blockSize);

src/system/kernel/cache/block_cache.cpp

2216

cache->RemoveBlock(block);

src/system/kernel/cache/block_cache.cpp

2226

TB(Read(cache, block));

src/system/kernel/cache/block_cache.cpp

2228

mark_block_unbusy_reading(cache, block);

src/system/kernel/cache/block_cache.cpp

2231

block->ref_count++;

src/system/kernel/cache/block_cache.cpp

2232

block->last_accessed = system_time() / 1000000L;

src/system/kernel/cache/block_cache.cpp

2234

*_block = block;

src/system/kernel/cache/block_cache.cpp

2260

cached_block* block;

src/system/kernel/cache/block_cache.cpp

2262

!cleared, &block);

src/system/kernel/cache/block_cache.cpp

2266

if (block->busy_writing)

src/system/kernel/cache/block_cache.cpp

2267

wait_for_busy_writing_block(cache, block);

src/system/kernel/cache/block_cache.cpp

2269

block->discard = false;

src/system/kernel/cache/block_cache.cpp

2274

mark_block_busy_reading(cache, block);

src/system/kernel/cache/block_cache.cpp

2277

memset(block->current_data, 0, cache->block_size);

src/system/kernel/cache/block_cache.cpp

2280

mark_block_unbusy_reading(cache, block);

src/system/kernel/cache/block_cache.cpp

2283

block->is_writing = true;

src/system/kernel/cache/block_cache.cpp

2285

if (!block->is_dirty) {

src/system/kernel/cache/block_cache.cpp

2287

block->is_dirty = true;

src/system/kernel/cache/block_cache.cpp

2291

if (block->compare != NULL) {

src/system/kernel/cache/block_cache.cpp

2292

cache->Free(block->compare);

src/system/kernel/cache/block_cache.cpp

2293

block->compare = NULL;

src/system/kernel/cache/block_cache.cpp

2298

TB(Get(cache, block));

src/system/kernel/cache/block_cache.cpp

2299

*_block = block->current_data;

src/system/kernel/cache/block_cache.cpp

2303

cache_transaction* transaction = block->transaction;

src/system/kernel/cache/block_cache.cpp

2309

"(transaction %" B_PRId32 ")\n", block->transaction->id);

src/system/kernel/cache/block_cache.cpp

2310

put_cached_block(cache, block);

src/system/kernel/cache/block_cache.cpp

2319

put_cached_block(cache, block);

src/system/kernel/cache/block_cache.cpp

2324

put_cached_block(cache, block);

src/system/kernel/cache/block_cache.cpp

2328

block->transaction = transaction;

src/system/kernel/cache/block_cache.cpp

2331

block->transaction_next = transaction->first_block;

src/system/kernel/cache/block_cache.cpp

2332

transaction->first_block = block;

src/system/kernel/cache/block_cache.cpp

2338

bool wasUnchanged = block->original_data == NULL

src/system/kernel/cache/block_cache.cpp

2339

|| block->previous_transaction != NULL;

src/system/kernel/cache/block_cache.cpp

2341

if (!(allocated && cleared) && block->original_data == NULL) {

src/system/kernel/cache/block_cache.cpp

2343

block->original_data = cache->Allocate();

src/system/kernel/cache/block_cache.cpp

2344

if (block->original_data == NULL) {

src/system/kernel/cache/block_cache.cpp

2347

put_cached_block(cache, block);

src/system/kernel/cache/block_cache.cpp

2351

mark_block_busy_reading(cache, block);

src/system/kernel/cache/block_cache.cpp

2354

memcpy(block->original_data, block->current_data, cache->block_size);

src/system/kernel/cache/block_cache.cpp

2357

mark_block_unbusy_reading(cache, block);

src/system/kernel/cache/block_cache.cpp

2359

if (block->parent_data == block->current_data) {

src/system/kernel/cache/block_cache.cpp

2361

block->parent_data = cache->Allocate();

src/system/kernel/cache/block_cache.cpp

2362

if (block->parent_data == NULL) {

src/system/kernel/cache/block_cache.cpp

2367

put_cached_block(cache, block);

src/system/kernel/cache/block_cache.cpp

2371

mark_block_busy_reading(cache, block);

src/system/kernel/cache/block_cache.cpp

2374

memcpy(block->parent_data, block->current_data, cache->block_size);

src/system/kernel/cache/block_cache.cpp

2377

mark_block_unbusy_reading(cache, block);

src/system/kernel/cache/block_cache.cpp

2381

&& block->parent_data == NULL && wasUnchanged)

src/system/kernel/cache/block_cache.cpp

2385

mark_block_busy_reading(cache, block);

src/system/kernel/cache/block_cache.cpp

2388

memset(block->current_data, 0, cache->block_size);

src/system/kernel/cache/block_cache.cpp

2391

mark_block_unbusy_reading(cache, block);

src/system/kernel/cache/block_cache.cpp

2394

block->is_dirty = true;

src/system/kernel/cache/block_cache.cpp

2397

if (block->compare != NULL) {

src/system/kernel/cache/block_cache.cpp

2398

cache->Free(block->compare);

src/system/kernel/cache/block_cache.cpp

2399

block->compare = NULL;

src/system/kernel/cache/block_cache.cpp

2402

TB(Get(cache, block));

src/system/kernel/cache/block_cache.cpp

2403

TB2(BlockData(cache, block, "get writable"));

src/system/kernel/cache/block_cache.cpp

2405

*_block = block->current_data;

src/system/kernel/cache/block_cache.cpp

2414

dump_block(cached_block* block)

src/system/kernel/cache/block_cache.cpp

2418

(addr_t)block, block->block_number,

src/system/kernel/cache/block_cache.cpp

2419

(addr_t)block->current_data, (addr_t)block->original_data,

src/system/kernel/cache/block_cache.cpp

2420

(addr_t)block->parent_data, block->ref_count, block->LastAccess(),

src/system/kernel/cache/block_cache.cpp

2421

block->busy_reading ? 'r' : '-', block->busy_writing ? 'w' : '-',

src/system/kernel/cache/block_cache.cpp

2422

block->is_writing ? 'W' : '-', block->is_dirty ? 'D' : '-',

src/system/kernel/cache/block_cache.cpp

2423

block->unused ? 'U' : '-', block->discard ? 'D' : '-',

src/system/kernel/cache/block_cache.cpp

2424

(addr_t)block->transaction,

src/system/kernel/cache/block_cache.cpp

2425

(addr_t)block->previous_transaction);

src/system/kernel/cache/block_cache.cpp

2430

dump_block_long(cached_block* block)

src/system/kernel/cache/block_cache.cpp

2432

kprintf("BLOCK %p\n", block);

src/system/kernel/cache/block_cache.cpp

2433

kprintf(" current data: %p\n", block->current_data);

src/system/kernel/cache/block_cache.cpp

2434

kprintf(" original data: %p\n", block->original_data);

src/system/kernel/cache/block_cache.cpp

2435

kprintf(" parent data: %p\n", block->parent_data);

src/system/kernel/cache/block_cache.cpp

2437

kprintf(" compare data: %p\n", block->compare);

src/system/kernel/cache/block_cache.cpp

2439

kprintf(" ref_count: %" B_PRId32 "\n", block->ref_count);

src/system/kernel/cache/block_cache.cpp

2440

kprintf(" accessed: %" B_PRId32 "\n", block->LastAccess());

src/system/kernel/cache/block_cache.cpp

2442

if (block->busy_reading)

src/system/kernel/cache/block_cache.cpp

2444

if (block->busy_writing)

src/system/kernel/cache/block_cache.cpp

2446

if (block->is_writing)

src/system/kernel/cache/block_cache.cpp

2448

if (block->is_dirty)

src/system/kernel/cache/block_cache.cpp

2450

if (block->unused)

src/system/kernel/cache/block_cache.cpp

2452

if (block->discard)

src/system/kernel/cache/block_cache.cpp

2455

if (block->transaction != NULL) {

src/system/kernel/cache/block_cache.cpp

2456

kprintf(" transaction: %p (%" B_PRId32 ")\n", block->transaction,

src/system/kernel/cache/block_cache.cpp

2457

block->transaction->id);

src/system/kernel/cache/block_cache.cpp

2458

if (block->transaction_next != NULL) {

src/system/kernel/cache/block_cache.cpp

2460

block->transaction_next->block_number);

src/system/kernel/cache/block_cache.cpp

2463

if (block->previous_transaction != NULL) {

src/system/kernel/cache/block_cache.cpp

2465

block->previous_transaction,

src/system/kernel/cache/block_cache.cpp

2466

block->previous_transaction->id);

src/system/kernel/cache/block_cache.cpp

2469

set_debug_variable("_current", (addr_t)block->current_data);

src/system/kernel/cache/block_cache.cpp

2470

set_debug_variable("_original", (addr_t)block->original_data);

src/system/kernel/cache/block_cache.cpp

2471

set_debug_variable("_parent", (addr_t)block->parent_data);

src/system/kernel/cache/block_cache.cpp

2525

cached_block* block = cache->hash.Lookup(blockNumber);

src/system/kernel/cache/block_cache.cpp

2526

if (block != NULL)

src/system/kernel/cache/block_cache.cpp

2527

dump_block_long(block);

src/system/kernel/cache/block_cache.cpp

258

void FreeBlock(cached_block* block);

src/system/kernel/cache/block_cache.cpp

2587

cached_block* block = iterator.Next();

src/system/kernel/cache/block_cache.cpp

2589

dump_block(block);

src/system/kernel/cache/block_cache.cpp

2591

if (block->is_dirty)

src/system/kernel/cache/block_cache.cpp

2593

if (block->discard)

src/system/kernel/cache/block_cache.cpp

2595

if (block->ref_count)

src/system/kernel/cache/block_cache.cpp

260

void FreeBlockParentData(cached_block* block);

src/system/kernel/cache/block_cache.cpp

263

void RemoveBlock(cached_block* block);

src/system/kernel/cache/block_cache.cpp

264

void DiscardBlock(cached_block* block);

src/system/kernel/cache/block_cache.cpp

2666

cached_block* block = transaction->first_block;

src/system/kernel/cache/block_cache.cpp

2667

while (block != NULL) {

src/system/kernel/cache/block_cache.cpp

2668

dump_block(block);

src/system/kernel/cache/block_cache.cpp

2669

block = block->transaction_next;

src/system/kernel/cache/block_cache.cpp

2676

block = blockIterator.Next();

src/system/kernel/cache/block_cache.cpp

2677

dump_block(block);

src/system/kernel/cache/block_cache.cpp

2896

cached_block* block = iterator.Next();

src/system/kernel/cache/block_cache.cpp

2897

if (block->CanBeWritten() && !writer.Add(block)) {

src/system/kernel/cache/block_cache.cpp

296

bool Add(cached_block* block,

src/system/kernel/cache/block_cache.cpp

308

cached_block* block);

src/system/kernel/cache/block_cache.cpp

311

void* _Data(cached_block* block) const;

src/system/kernel/cache/block_cache.cpp

313

void _BlockDone(cached_block* block,

src/system/kernel/cache/block_cache.cpp

315

void _UnmarkWriting(cached_block* block);

src/system/kernel/cache/block_cache.cpp

3190

for (cached_block* block = transaction->first_block; block != NULL;

src/system/kernel/cache/block_cache.cpp

3191

block = next) {

src/system/kernel/cache/block_cache.cpp

3192

next = block->transaction_next;

src/system/kernel/cache/block_cache.cpp

3193

ASSERT(block->previous_transaction == NULL);

src/system/kernel/cache/block_cache.cpp

3195

if (block->discard) {

src/system/kernel/cache/block_cache.cpp

3197

cache->DiscardBlock(block);

src/system/kernel/cache/block_cache.cpp

3202

if (block->original_data != NULL) {

src/system/kernel/cache/block_cache.cpp

3203

cache->Free(block->original_data);

src/system/kernel/cache/block_cache.cpp

3204

block->original_data = NULL;

src/system/kernel/cache/block_cache.cpp

3206

if (block->parent_data != NULL) {

src/system/kernel/cache/block_cache.cpp

3208

cache->FreeBlockParentData(block);

src/system/kernel/cache/block_cache.cpp

3212

transaction->blocks.Add(block);

src/system/kernel/cache/block_cache.cpp

3214

block->previous_transaction = transaction;

src/system/kernel/cache/block_cache.cpp

3215

block->transaction_next = NULL;

src/system/kernel/cache/block_cache.cpp

3216

block->transaction = NULL;

src/system/kernel/cache/block_cache.cpp

3243

cached_block* block = transaction->first_block;

src/system/kernel/cache/block_cache.cpp

3245

for (; block != NULL; block = next) {

src/system/kernel/cache/block_cache.cpp

3246

next = block->transaction_next;

src/system/kernel/cache/block_cache.cpp

3248

if (block->original_data != NULL) {

src/system/kernel/cache/block_cache.cpp

3250

"block %" B_PRIdOFF "\n", transaction->id, block->block_number));

src/system/kernel/cache/block_cache.cpp

3251

memcpy(block->current_data, block->original_data,

src/system/kernel/cache/block_cache.cpp

3253

cache->Free(block->original_data);

src/system/kernel/cache/block_cache.cpp

3254

block->original_data = NULL;

src/system/kernel/cache/block_cache.cpp

3256

if (transaction->has_sub_transaction && block->parent_data != NULL)

src/system/kernel/cache/block_cache.cpp

3257

cache->FreeBlockParentData(block);

src/system/kernel/cache/block_cache.cpp

3259

block->transaction_next = NULL;

src/system/kernel/cache/block_cache.cpp

3260

block->transaction = NULL;

src/system/kernel/cache/block_cache.cpp

3261

block->discard = false;

src/system/kernel/cache/block_cache.cpp

3262

if (block->previous_transaction == NULL)

src/system/kernel/cache/block_cache.cpp

3263

block->is_dirty = false;

src/system/kernel/cache/block_cache.cpp

3317

for (cached_block* block = transaction->first_block; block != NULL;

src/system/kernel/cache/block_cache.cpp

3318

block = next) {

src/system/kernel/cache/block_cache.cpp

3319

next = block->transaction_next;

src/system/kernel/cache/block_cache.cpp

3320

ASSERT(block->previous_transaction == NULL);

src/system/kernel/cache/block_cache.cpp

3322

if (block->discard) {

src/system/kernel/cache/block_cache.cpp

3323

cache->DiscardBlock(block);

src/system/kernel/cache/block_cache.cpp

3328

if (block->parent_data != NULL) {

src/system/kernel/cache/block_cache.cpp

3331

ASSERT(block->original_data != NULL);

src/system/kernel/cache/block_cache.cpp

3332

cache->Free(block->original_data);

src/system/kernel/cache/block_cache.cpp

3334

if (block->parent_data != block->current_data) {

src/system/kernel/cache/block_cache.cpp

3336

block->original_data = block->parent_data;

src/system/kernel/cache/block_cache.cpp

3339

block->original_data = NULL;

src/system/kernel/cache/block_cache.cpp

3341

block->parent_data = NULL;

src/system/kernel/cache/block_cache.cpp

3344

transaction->blocks.Add(block);

src/system/kernel/cache/block_cache.cpp

3345

block->previous_transaction = transaction;

src/system/kernel/cache/block_cache.cpp

3348

if (block->original_data != NULL) {

src/system/kernel/cache/block_cache.cpp

3351

ASSERT(block->parent_data == NULL);

src/system/kernel/cache/block_cache.cpp

3354

newTransaction->first_block = block;

src/system/kernel/cache/block_cache.cpp

3356

last->transaction_next = block;

src/system/kernel/cache/block_cache.cpp

3358

block->transaction = newTransaction;

src/system/kernel/cache/block_cache.cpp

3359

last = block;

src/system/kernel/cache/block_cache.cpp

3361

block->transaction = NULL;

src/system/kernel/cache/block_cache.cpp

3363

block->transaction_next = NULL;

src/system/kernel/cache/block_cache.cpp

3401

cached_block* block = transaction->first_block;

src/system/kernel/cache/block_cache.cpp

3404

for (; block != NULL; block = next) {

src/system/kernel/cache/block_cache.cpp

3405

next = block->transaction_next;

src/system/kernel/cache/block_cache.cpp

3407

if (block->parent_data == NULL) {

src/system/kernel/cache/block_cache.cpp

3411

if (block->original_data != NULL) {

src/system/kernel/cache/block_cache.cpp

3413

memcpy(block->current_data, block->original_data,

src/system/kernel/cache/block_cache.cpp

3422

block->transaction_next = NULL;

src/system/kernel/cache/block_cache.cpp

3423

block->transaction = NULL;

src/system/kernel/cache/block_cache.cpp

3426

if (block->previous_transaction == NULL) {

src/system/kernel/cache/block_cache.cpp

3427

cache->Free(block->original_data);

src/system/kernel/cache/block_cache.cpp

3428

block->original_data = NULL;

src/system/kernel/cache/block_cache.cpp

3429

block->is_dirty = false;

src/system/kernel/cache/block_cache.cpp

3431

if (block->ref_count == 0) {

src/system/kernel/cache/block_cache.cpp

3433

block->unused = true;

src/system/kernel/cache/block_cache.cpp

3434

cache->unused_blocks.Add(block);

src/system/kernel/cache/block_cache.cpp

3439

if (block->parent_data != block->current_data) {

src/system/kernel/cache/block_cache.cpp

3444

transaction->id, block->block_number));

src/system/kernel/cache/block_cache.cpp

3445

memcpy(block->current_data, block->parent_data,

src/system/kernel/cache/block_cache.cpp

3447

cache->Free(block->parent_data);

src/system/kernel/cache/block_cache.cpp

3450

block->parent_data = NULL;

src/system/kernel/cache/block_cache.cpp

3451

last = block;

src/system/kernel/cache/block_cache.cpp

3454

block->discard = false;

src/system/kernel/cache/block_cache.cpp

3484

cached_block* block = transaction->first_block;

src/system/kernel/cache/block_cache.cpp

3486

for (; block != NULL; block = next) {

src/system/kernel/cache/block_cache.cpp

3487

next = block->transaction_next;

src/system/kernel/cache/block_cache.cpp

3489

if (block->parent_data != NULL) {

src/system/kernel/cache/block_cache.cpp

3493

cache->FreeBlockParentData(block);

src/system/kernel/cache/block_cache.cpp

3495

if (block->discard) {

src/system/kernel/cache/block_cache.cpp

3499

ASSERT(block->previous_transaction == NULL);

src/system/kernel/cache/block_cache.cpp

3500

if (block->original_data != NULL) {

src/system/kernel/cache/block_cache.cpp

3501

memcpy(block->current_data, block->original_data,

src/system/kernel/cache/block_cache.cpp

3504

cache->Free(block->original_data);

src/system/kernel/cache/block_cache.cpp

3505

block->original_data = NULL;

src/system/kernel/cache/block_cache.cpp

3512

block->parent_data = block->current_data;

src/system/kernel/cache/block_cache.cpp

3579

cached_block* block = (cached_block*)*_cookie;

src/system/kernel/cache/block_cache.cpp

3587

if (block == NULL)

src/system/kernel/cache/block_cache.cpp

3588

block = transaction->first_block;

src/system/kernel/cache/block_cache.cpp

3590

block = block->transaction_next;

src/system/kernel/cache/block_cache.cpp

3595

while (block != NULL && block->parent_data == NULL)

src/system/kernel/cache/block_cache.cpp

3596

block = block->transaction_next;

src/system/kernel/cache/block_cache.cpp

3599

while (block != NULL && block->discard)

src/system/kernel/cache/block_cache.cpp

3600

block = block->transaction_next;

src/system/kernel/cache/block_cache.cpp

3604

if (block == NULL)

src/system/kernel/cache/block_cache.cpp

3608

*_blockNumber = block->block_number;

src/system/kernel/cache/block_cache.cpp

3610

*_data = mainOnly ? block->parent_data : block->current_data;

src/system/kernel/cache/block_cache.cpp

3612

*_unchangedData = block->original_data;

src/system/kernel/cache/block_cache.cpp

3614

*_cookie = (addr_t)block;

src/system/kernel/cache/block_cache.cpp

3676

cached_block* block = cache->hash.Lookup(blockNumber);

src/system/kernel/cache/block_cache.cpp

3678

return (block != NULL && block->transaction != NULL

src/system/kernel/cache/block_cache.cpp

3679

&& block->transaction->id == id);

src/system/kernel/cache/block_cache.cpp

3706

cached_block* block = cache->hash.Clear(true);

src/system/kernel/cache/block_cache.cpp

3707

while (block != NULL) {

src/system/kernel/cache/block_cache.cpp

3708

cached_block* next = block->next;

src/system/kernel/cache/block_cache.cpp

3709

cache->FreeBlock(block);

src/system/kernel/cache/block_cache.cpp

3710

block = next;

src/system/kernel/cache/block_cache.cpp

3760

cached_block* block = iterator.Next();

src/system/kernel/cache/block_cache.cpp

3761

if (block->CanBeWritten())

src/system/kernel/cache/block_cache.cpp

3762

writer.Add(block);

src/system/kernel/cache/block_cache.cpp

3795

cached_block* block = cache->hash.Lookup(blockNumber);

src/system/kernel/cache/block_cache.cpp

3796

if (block == NULL)

src/system/kernel/cache/block_cache.cpp

3799

if (block->CanBeWritten())

src/system/kernel/cache/block_cache.cpp

3800

writer.Add(block);

src/system/kernel/cache/block_cache.cpp

3829

cached_block* block = cache->hash.Lookup(blockNumber);

src/system/kernel/cache/block_cache.cpp

3830

if (block != NULL && block->previous_transaction != NULL)

src/system/kernel/cache/block_cache.cpp

3831

writer.Add(block);

src/system/kernel/cache/block_cache.cpp

3841

cached_block* block = cache->hash.Lookup(blockNumber);

src/system/kernel/cache/block_cache.cpp

3842

if (block == NULL)

src/system/kernel/cache/block_cache.cpp

3845

ASSERT(block->previous_transaction == NULL);

src/system/kernel/cache/block_cache.cpp

3847

if (block->unused) {

src/system/kernel/cache/block_cache.cpp

3848

cache->unused_blocks.Remove(block);

src/system/kernel/cache/block_cache.cpp

3850

cache->RemoveBlock(block);

src/system/kernel/cache/block_cache.cpp

3852

if (block->transaction != NULL && block->parent_data != NULL

src/system/kernel/cache/block_cache.cpp

3853

&& block->parent_data != block->current_data) {

src/system/kernel/cache/block_cache.cpp

3859

block->discard = true;

src/system/kernel/cache/block_cache.cpp

3877

void* block;

src/system/kernel/cache/block_cache.cpp

3879

transaction, false, &block);

src/system/kernel/cache/block_cache.cpp

3909

void* block;

src/system/kernel/cache/block_cache.cpp

3911

transaction, &block) == B_OK)

src/system/kernel/cache/block_cache.cpp

3912

return block;

src/system/kernel/cache/block_cache.cpp

3929

void* block;

src/system/kernel/cache/block_cache.cpp

3931

transaction, true, &block) == B_OK)

src/system/kernel/cache/block_cache.cpp

3932

return block;

src/system/kernel/cache/block_cache.cpp

3946

cached_block* block;

src/system/kernel/cache/block_cache.cpp

3950

cached_block* block = cache->hash.Lookup(blockNumber);

src/system/kernel/cache/block_cache.cpp

3951

if (block != NULL && !block->busy_reading) {

src/system/kernel/cache/block_cache.cpp

3953

if (atomic_add(&block->ref_count, 1) == 0) {

src/system/kernel/cache/block_cache.cpp

3955

if (block->unused) {

src/system/kernel/cache/block_cache.cpp

3956

cache->unused_blocks.Remove(block);

src/system/kernel/cache/block_cache.cpp

3958

block->unused = false;

src/system/kernel/cache/block_cache.cpp

3961

atomic_set(&block->last_accessed, system_time() / 1000000L);

src/system/kernel/cache/block_cache.cpp

3970

&block);

src/system/kernel/cache/block_cache.cpp

3976

if (block->compare == NULL) {

src/system/kernel/cache/block_cache.cpp

3980

if (block->compare == NULL && !block->is_dirty) {

src/system/kernel/cache/block_cache.cpp

3981

block->compare = cache->Allocate();

src/system/kernel/cache/block_cache.cpp

3982

if (block->compare != NULL)

src/system/kernel/cache/block_cache.cpp

3983

memcpy(block->compare, block->current_data, cache->block_size);

src/system/kernel/cache/block_cache.cpp

3987

TB(Get(cache, block));

src/system/kernel/cache/block_cache.cpp

3989

*_block = block->current_data;

src/system/kernel/cache/block_cache.cpp

3997

const void* block;

src/system/kernel/cache/block_cache.cpp

3998

if (block_cache_get_etc(_cache, blockNumber, &block) == B_OK)

src/system/kernel/cache/block_cache.cpp

3999

return block;

src/system/kernel/cache/block_cache.cpp

4019

cached_block* block = cache->hash.Lookup(blockNumber);

src/system/kernel/cache/block_cache.cpp

4020

if (block == NULL)

src/system/kernel/cache/block_cache.cpp

4022

if (block->is_dirty == dirty) {

src/system/kernel/cache/block_cache.cpp

404

Action(block_cache* cache, cached_block* block)

src/system/kernel/cache/block_cache.cpp

407

fBlockNumber(block->block_number),

src/system/kernel/cache/block_cache.cpp

408

fIsDirty(block->is_dirty),

src/system/kernel/cache/block_cache.cpp

409

fHasOriginal(block->original_data != NULL),

src/system/kernel/cache/block_cache.cpp

410

fHasParent(block->parent_data != NULL),

src/system/kernel/cache/block_cache.cpp

414

if (block->transaction != NULL)

src/system/kernel/cache/block_cache.cpp

415

fTransactionID = block->transaction->id;

src/system/kernel/cache/block_cache.cpp

416

if (block->previous_transaction != NULL)

src/system/kernel/cache/block_cache.cpp

417

fPreviousID = block->previous_transaction->id;

src/system/kernel/cache/block_cache.cpp

442

Get(block_cache* cache, cached_block* block)

src/system/kernel/cache/block_cache.cpp

444

Action(cache, block)

src/system/kernel/cache/block_cache.cpp

454

Put(block_cache* cache, cached_block* block)

src/system/kernel/cache/block_cache.cpp

456

Action(cache, block)

src/system/kernel/cache/block_cache.cpp

466

Read(block_cache* cache, cached_block* block)

src/system/kernel/cache/block_cache.cpp

468

Action(cache, block)

src/system/kernel/cache/block_cache.cpp

478

Write(block_cache* cache, cached_block* block)

src/system/kernel/cache/block_cache.cpp

480

Action(cache, block)

src/system/kernel/cache/block_cache.cpp

490

Flush(block_cache* cache, cached_block* block, bool getUnused = false)

src/system/kernel/cache/block_cache.cpp

492

Action(cache, block),

src/system/kernel/cache/block_cache.cpp

541

BlockData(block_cache* cache, cached_block* block, const char* message)

src/system/kernel/cache/block_cache.cpp

545

fBlockNumber(block->block_number),

src/system/kernel/cache/block_cache.cpp

548

_Allocate(fCurrent, block->current_data);

src/system/kernel/cache/block_cache.cpp

549

_Allocate(fParent, block->parent_data);

src/system/kernel/cache/block_cache.cpp

550

_Allocate(fOriginal, block->original_data);

src/system/kernel/cache/block_cache.cpp

752

cached_block* block = transaction->first_block;

src/system/kernel/cache/block_cache.cpp

753

for (int32 i = 0; block != NULL && i < fNumBlocks;

src/system/kernel/cache/block_cache.cpp

754

block = block->transaction_next) {

src/system/kernel/cache/block_cache.cpp

755

fBlocks[i++] = block->block_number;

src/system/kernel/cache/block_cache.cpp

816

static void mark_block_busy_reading(block_cache* cache, cached_block* block);

src/system/kernel/cache/block_cache.cpp

817

static void mark_block_unbusy_reading(block_cache* cache, cached_block* block);

src/system/kernel/heap.cpp

81

deferred_free(void *block)

src/system/kernel/heap.cpp

83

if (block == NULL)

src/system/kernel/heap.cpp

86

DeferredFreeListEntry *entry = new(block) DeferredFreeListEntry;

src/system/kernel/slab/allocator.cpp

117

void* block;

src/system/kernel/slab/allocator.cpp

118

if (MemoryManager::AllocateRaw(size, flags, block) != B_OK)

src/system/kernel/slab/allocator.cpp

121

return block;

src/system/kernel/slab/allocator.cpp

135

void* block;

src/system/kernel/slab/allocator.cpp

136

if (MemoryManager::AllocateRaw(size, 0, block) != B_OK)

src/system/kernel/slab/allocator.cpp

139

return block;

src/system/kernel/slab/allocator.cpp

146

void* block;

src/system/kernel/slab/allocator.cpp

147

if (MemoryManager::AllocateRaw(SLAB_CHUNK_SIZE_SMALL, 0, block) != B_OK)

src/system/kernel/slab/allocator.cpp

149

sBootStrapMemory = (addr_t)block;

src/system/kernel/slab/allocator.cpp

157

void* block = (void*)(sBootStrapMemory + sUsedBootStrapMemory);

src/system/kernel/slab/allocator.cpp

160

return block;

src/system/kernel/slab/allocator.cpp

165

block_free(void* block, uint32 flags)

src/system/kernel/slab/allocator.cpp

167

if (block == NULL)

src/system/kernel/slab/allocator.cpp

170

ObjectCache* cache = MemoryManager::FreeRawOrReturnCache(block, flags);

src/system/kernel/slab/allocator.cpp

176

object_cache_free(cache, block, flags);

src/system/libroot/posix/glibc/extensions/obstack.h

226

void obstack_free (struct obstack *obstack, void *block);

src/system/libroot/posix/malloc/hoard2/block.h

104

setNext(block * b)

src/system/libroot/posix/malloc/hoard2/block.h

109

block *

src/system/libroot/posix/malloc/hoard2/block.h

150

block *_next; // The next block in a linked-list of blocks.

src/system/libroot/posix/malloc/hoard2/block.h

166

block *_next; // The next block in a linked-list of blocks.

src/system/libroot/posix/malloc/hoard2/block.h

189

block(const block &);

src/system/libroot/posix/malloc/hoard2/block.h

197

STATIC_ASSERT(sizeof(block) % HAIKU_MEMORY_ALIGNMENT == 0);

src/system/libroot/posix/malloc/hoard2/block.h

202

block::getSuperblock(void)

src/system/libroot/posix/malloc/hoard2/block.h

213

block::markFree(void)

src/system/libroot/posix/malloc/hoard2/block.h

223

block::markAllocated(void)

src/system/libroot/posix/malloc/hoard2/block.h

233

block::isValid(void) const

src/system/libroot/posix/malloc/hoard2/block.h

33

class block {

src/system/libroot/posix/malloc/hoard2/block.h

35

block(superblock * sb)

src/system/libroot/posix/malloc/hoard2/block.h

44

block &

src/system/libroot/posix/malloc/hoard2/block.h

45

operator=(const block & b)

src/system/libroot/posix/malloc/hoard2/heap.cpp

183

const int blksize = align(sizeof(block) + s);

src/system/libroot/posix/malloc/hoard2/heap.cpp

330

hoardHeap::freeBlock(block * &b, superblock * &sb,

src/system/libroot/posix/malloc/hoard2/heap.cpp

346

const int blksize = align(sizeof(block) + s);

src/system/libroot/posix/malloc/hoard2/heap.cpp

383

const int blksize = align(sizeof(block) + s);

src/system/libroot/posix/malloc/hoard2/heap.h

107

block * &b, processHeap * pHeap);

src/system/libroot/posix/malloc/hoard2/heap.h

127

int freeBlock(block * &b, superblock * &sb, int sizeclass,

src/system/libroot/posix/malloc/hoard2/heap.h

299

block * &b, processHeap * pHeap)

src/system/libroot/posix/malloc/hoard2/heap.h

424

const int blksize = align(sizeof(block) + s);

src/system/libroot/posix/malloc/hoard2/processheap.cpp

172

block *b = (block *) ptr - 1;

src/system/libroot/posix/malloc/hoard2/processheap.cpp

178

b = (block *) ((unsigned long)b->getNext() & ~1);

src/system/libroot/posix/malloc/hoard2/superblock.cpp

100

+ (hoardHeap::align(sizeof(block)

src/system/libroot/posix/malloc/hoard2/superblock.cpp

109

size_t blksize = hoardHeap::align(sizeof(block)

src/system/libroot/posix/malloc/hoard2/superblock.cpp

57

const int blksize = hoardHeap::align(sizeof(block)

src/system/libroot/posix/malloc/hoard2/superblock.cpp

64

block *b = (block *) hoardHeap::align((unsigned long)(this + 1));

src/system/libroot/posix/malloc/hoard2/superblock.cpp

71

new(b) block(this);

src/system/libroot/posix/malloc/hoard2/superblock.cpp

75

b = (block *)((char *)b + blksize);

src/system/libroot/posix/malloc/hoard2/superblock.h

133

block *_freeList; // A pointer to the first free block.

src/system/libroot/posix/malloc/hoard2/superblock.h

163

block *

src/system/libroot/posix/malloc/hoard2/superblock.h

176

block *b = _freeList;

src/system/libroot/posix/malloc/hoard2/superblock.h

188

superblock::putBlock(block *b)

src/system/libroot/posix/malloc/hoard2/superblock.h

62

inline block *getBlock(void);

src/system/libroot/posix/malloc/hoard2/superblock.h

65

inline void putBlock(block *b);

src/system/libroot/posix/malloc/hoard2/threadheap.cpp

55

block *b = NULL;

src/system/libroot/posix/malloc/hoard2/threadheap.h

102

if ((unsigned long)newptr - (unsigned long)ptr < sizeof(block))

src/system/libroot/posix/malloc/hoard2/threadheap.h

108

block *b = ((block *)ptr - 1);

src/system/libroot/posix/malloc/hoard2/threadheap.h

115

sizeof(block));

src/system/libroot/posix/malloc/hoard2/threadheap.h

117

block *p = ((block *)newptr - 1);

src/system/libroot/posix/malloc/hoard2/threadheap.h

120

assert(((unsigned long)p - sizeof(block)) >= (unsigned long)b);

src/system/libroot/posix/malloc/hoard2/threadheap.h

131

p->setNext((block *)((unsigned long)b | 1));

src/system/libroot/posix/malloc/hoard2/threadheap.h

146

block *b = ((block *)ptr - 1);

src/system/libroot/posix/malloc/hoard2/threadheap.h

79

if (alignment < sizeof(block))

src/system/libroot/posix/malloc/hoard2/threadheap.h

80

alignment = sizeof(block);

src/system/libroot/posix/malloc/hoard2/threadheap.h

86

newSize = size + sizeof(block) + alignment;

src/system/libroot/posix/malloc/hoard2/wrapper.cpp

103

dump_block(block* b)

src/system/libroot/posix/malloc/hoard2/wrapper.cpp

134

block* b = sUsedList;

src/system/libroot/posix/malloc/hoard2/wrapper.cpp

148

block *b = (block *)address - 1;

src/system/libroot/posix/malloc/hoard2/wrapper.cpp

182

block* b = (block *)address - 1;

src/system/libroot/posix/malloc/hoard2/wrapper.cpp

190

block* last = sUsedList;

src/system/libroot/posix/malloc/hoard2/wrapper.cpp

48

static block* sUsedList = NULL;

src/system/libroot/posix/musl/crypt/encrypt.c

23

void encrypt(char *block, int edflag)

src/system/libroot/posix/musl/crypt/encrypt.c

30

p = block;

src/system/libroot/posix/musl/crypt/encrypt.c

48

p = block;

src/system/libroot/posix/stdlib/exit.cpp

165

if (info->block->IsEmpty())

src/system/libroot/posix/stdlib/exit.cpp

166

sAtExitInfoBlocks.Add(info->block);

src/system/libroot/posix/stdlib/exit.cpp

168

info->block->FreeInfo(info);

src/system/libroot/posix/stdlib/exit.cpp

200

AtExitInfoBlock* block = sAtExitInfoBlocks.Head();

src/system/libroot/posix/stdlib/exit.cpp

201

if (block == NULL) {

src/system/libroot/posix/stdlib/exit.cpp

204

block = &sInitialAtExitInfoBlock;

src/system/libroot/posix/stdlib/exit.cpp

208

block = new(std::nothrow) AtExitInfoBlock;

src/system/libroot/posix/stdlib/exit.cpp

209

if (block == NULL) {

src/system/libroot/posix/stdlib/exit.cpp

215

sAtExitInfoBlocks.Add(block);

src/system/libroot/posix/stdlib/exit.cpp

219

AtExitInfo* info = block->AllocateInfo();

src/system/libroot/posix/stdlib/exit.cpp

222

if (block->IsEmpty())

src/system/libroot/posix/stdlib/exit.cpp

223

sAtExitInfoBlocks.Remove(block);

src/system/libroot/posix/stdlib/exit.cpp

259

if (info->block->IsEmpty())

src/system/libroot/posix/stdlib/exit.cpp

260

sAtExitInfoBlocks.Add(info->block);

src/system/libroot/posix/stdlib/exit.cpp

262

info->block->FreeInfo(info);

src/system/libroot/posix/stdlib/exit.cpp

37

AtExitInfoBlock* block;

src/system/libroot/posix/stdlib/exit.cpp

64

info->block = this;

src/system/runtime_loader/elf_tls.cpp

109

TLSBlockTemplates::Register(const TLSBlockTemplate& block)

src/system/runtime_loader/elf_tls.cpp

116

fTemplates[dso] = block;

src/system/runtime_loader/elf_tls.cpp

119

fTemplates.push_back(block);

src/system/runtime_loader/elf_tls.cpp

221

TLSBlock& block = (*fVector)[i + 1];

src/system/runtime_loader/elf_tls.cpp

222

if (!block.IsInvalid())

src/system/runtime_loader/elf_tls.cpp

223

block.Destroy();

src/system/runtime_loader/elf_tls.cpp

241

TLSBlock& block = (*fVector)[dsoIndex + 1];

src/system/runtime_loader/elf_tls.cpp

245

block.Destroy();

src/system/runtime_loader/elf_tls.cpp

257

TLSBlock& block = (*fVector)[dso + 1];

src/system/runtime_loader/elf_tls.cpp

258

if (block.IsInvalid()) {

src/system/runtime_loader/elf_tls.cpp

259

status_t result = block.Initialize(dso);

src/system/runtime_loader/elf_tls.cpp

264

return block;

src/system/runtime_loader/elf_tls.cpp

309

TLSBlock& block = dynamicThreadVector[dso];

src/system/runtime_loader/elf_tls.cpp

310

if (block.IsInvalid())

src/system/runtime_loader/elf_tls.cpp

312

return block + offset;

src/system/runtime_loader/elf_tls.h

41

unsigned Register(const TLSBlockTemplate& block);

src/tests/add-ons/kernel/file_systems/bfs/btree/Volume.h

33

block_run ToBlockRun(off_t block) const

src/tests/add-ons/kernel/file_systems/bfs/btree/Volume.h

35

return block_run::Run(0, 0, block);

src/tests/add-ons/kernel/file_systems/bfs/dump_log/dump_log.cpp

102

dumpLogEntry(int device, disk_super_block &superBlock, int32 &start, uint8 *block)

src/tests/add-ons/kernel/file_systems/bfs/dump_log/dump_log.cpp

123

block, blockSize) != blockSize) {

src/tests/add-ons/kernel/file_systems/bfs/dump_log/dump_log.cpp

128

off_t *array = (off_t *)block;

src/tests/add-ons/kernel/file_systems/bfs/dump_log/dump_log.cpp

231

uint8 *block = (uint8 *)malloc(superBlock.BlockSize());

src/tests/add-ons/kernel/file_systems/bfs/dump_log/dump_log.cpp

232

if (block == NULL) {

src/tests/add-ons/kernel/file_systems/bfs/dump_log/dump_log.cpp

247

dumpLogEntry(device, superBlock, start, block);

src/tests/add-ons/kernel/file_systems/bfs/fragmenter/fragmenter.cpp

182

uint8 *block = new uint8[blockSize];

src/tests/add-ons/kernel/file_systems/bfs/fragmenter/fragmenter.cpp

191

read_from(fd, offset, block, blockSize);

src/tests/add-ons/kernel/file_systems/bfs/fragmenter/fragmenter.cpp

199

occupiedBlocks += count_bits(~block[k] & patternChar);

src/tests/add-ons/kernel/file_systems/bfs/fragmenter/fragmenter.cpp

200

block[k] |= patternChar;

src/tests/add-ons/kernel/file_systems/bfs/fragmenter/fragmenter.cpp

204

write_to(fd, offset, block, blockSize);

src/tests/add-ons/kernel/file_systems/shared/queries/QueryParserTest.cpp

13

#define QUERY_D(block) block

src/tests/add-ons/kernel/file_systems/shared/random_file_actions.cpp

295

block_identifier* block = (block_identifier*)buffer;

src/tests/add-ons/kernel/file_systems/shared/random_file_actions.cpp

296

block->offset = offset;

src/tests/add-ons/kernel/file_systems/shared/random_file_actions.cpp

297

block->identifier = entry.identifier;

src/tests/add-ons/kernel/file_systems/shared/random_file_actions.cpp

303

block->data[i] = offset + i * 2;

src/tests/add-ons/kernel/file_systems/shared/random_file_actions.cpp

335

char block[kBlockSize];

src/tests/add-ons/kernel/file_systems/shared/random_file_actions.cpp

336

generate_block(block, entry, offset - blockOffset);

src/tests/add-ons/kernel/file_systems/shared/random_file_actions.cpp

339

ssize_t bytesWritten = write(fd, block + blockOffset, toWrite);

src/tests/add-ons/kernel/file_systems/shared/random_file_actions.cpp

421

char block[kBlockSize];

src/tests/add-ons/kernel/file_systems/shared/random_file_actions.cpp

423

ssize_t bytesRead = read(fd, block, toRead);

src/tests/add-ons/kernel/file_systems/shared/random_file_actions.cpp

433

if (memcmp(generatedBlock, block, bytesRead) != 0) {

src/tests/add-ons/kernel/file_systems/shared/random_file_actions.cpp

435

dump_block(block, bytesRead, "read: ");

src/tests/system/kernel/cache/block_cache_test.cpp

100

or_block(void* block, int32 value)

src/tests/system/kernel/cache/block_cache_test.cpp

102

int32* data = (int32*)block;

src/tests/system/kernel/cache/block_cache_test.cpp

108

set_block(void* block, int32 value)

src/tests/system/kernel/cache/block_cache_test.cpp

110

int32* data = (int32*)block;

src/tests/system/kernel/cache/block_cache_test.cpp

116

reset_block(void* block, int32 index)

src/tests/system/kernel/cache/block_cache_test.cpp

118

int32* data = (int32*)block;

src/tests/system/kernel/cache/block_cache_test.cpp

192

cached_block* block = (cached_block*)hash_lookup(gCache->hash, &number);

src/tests/system/kernel/cache/block_cache_test.cpp

193

if (block == NULL) {

src/tests/system/kernel/cache/block_cache_test.cpp

201

if (block->is_dirty != gBlocks[number].is_dirty) {

src/tests/system/kernel/cache/block_cache_test.cpp

203

number, block->is_dirty, gBlocks[number].is_dirty);

src/tests/system/kernel/cache/block_cache_test.cpp

206

if (block->unused != gBlocks[number].unused) {

src/tests/system/kernel/cache/block_cache_test.cpp

208

block->unused, gBlocks[number].unused);

src/tests/system/kernel/cache/block_cache_test.cpp

211

if (block->discard != gBlocks[number].discard) {

src/tests/system/kernel/cache/block_cache_test.cpp

213

number, block->discard, gBlocks[number].discard);

src/tests/system/kernel/cache/block_cache_test.cpp

218

TEST_BLOCK_DATA(block, number, current);

src/tests/system/kernel/cache/block_cache_test.cpp

219

TEST_BLOCK_DATA(block, number, original);

src/tests/system/kernel/cache/block_cache_test.cpp

220

TEST_BLOCK_DATA(block, number, parent);

src/tests/system/kernel/cache/block_cache_test.cpp

26

#define TEST_BLOCK_DATA(block, number, type) \

src/tests/system/kernel/cache/block_cache_test.cpp

27

if ((block)->type ## _data != NULL && gBlocks[(number)]. type == 0) \

src/tests/system/kernel/cache/block_cache_test.cpp

272

void* block = block_cache_get_writable(gCache, 1, id);

src/tests/system/kernel/cache/block_cache_test.cpp

273

or_block(block, BLOCK_CHANGED_IN_MAIN);

src/tests/system/kernel/cache/block_cache_test.cpp

283

block = block_cache_get_empty(gCache, 2, id);

src/tests/system/kernel/cache/block_cache_test.cpp

284

reset_block(block, 2);

src/tests/system/kernel/cache/block_cache_test.cpp

285

or_block(block, BLOCK_CHANGED_IN_MAIN);

src/tests/system/kernel/cache/block_cache_test.cpp

29

if ((block)->type ## _data != NULL && gBlocks[(number)]. type != 0 \

src/tests/system/kernel/cache/block_cache_test.cpp

30

&& *(int32*)(block)->type ## _data != gBlocks[(number)]. type) { \

src/tests/system/kernel/cache/block_cache_test.cpp

304

block = block_cache_get_writable(gCache, 0, id);

src/tests/system/kernel/cache/block_cache_test.cpp

305

or_block(block, BLOCK_CHANGED_IN_SUB);

src/tests/system/kernel/cache/block_cache_test.cpp

32

(number), *(int32*)(block)->type ## _data, \

src/tests/system/kernel/cache/block_cache_test.cpp

343

void* block = block_cache_get_empty(gCache, 0, id);

src/tests/system/kernel/cache/block_cache_test.cpp

344

or_block(block, BLOCK_CHANGED_IN_PREVIOUS);

src/tests/system/kernel/cache/block_cache_test.cpp

347

block = block_cache_get_writable(gCache, 1, id);

src/tests/system/kernel/cache/block_cache_test.cpp

348

or_block(block, BLOCK_CHANGED_IN_PREVIOUS);

src/tests/system/kernel/cache/block_cache_test.cpp

360

block = block_cache_get_writable(gCache, 0, id);

src/tests/system/kernel/cache/block_cache_test.cpp

361

or_block(block, BLOCK_CHANGED_IN_MAIN);

src/tests/system/kernel/cache/block_cache_test.cpp

363

block = block_cache_get_writable(gCache, 1, id);

src/tests/system/kernel/cache/block_cache_test.cpp

364

or_block(block, BLOCK_CHANGED_IN_MAIN);

src/tests/system/kernel/cache/block_cache_test.cpp

395

void* block = block_cache_get_empty(gCache, 0, id);

src/tests/system/kernel/cache/block_cache_test.cpp

396

or_block(block, BLOCK_CHANGED_IN_PREVIOUS);

src/tests/system/kernel/cache/block_cache_test.cpp

399

block = block_cache_get_writable(gCache, 1, id);

src/tests/system/kernel/cache/block_cache_test.cpp

400

or_block(block, BLOCK_CHANGED_IN_PREVIOUS);

src/tests/system/kernel/cache/block_cache_test.cpp

413

block = block_cache_get_writable(gCache, 1, id);

src/tests/system/kernel/cache/block_cache_test.cpp

414

or_block(block, BLOCK_CHANGED_IN_MAIN);

src/tests/system/kernel/cache/block_cache_test.cpp

436

block = block_cache_get_writable(gCache, 1, id);

src/tests/system/kernel/cache/block_cache_test.cpp

437

or_block(block, BLOCK_CHANGED_IN_PREVIOUS);

src/tests/system/kernel/cache/block_cache_test.cpp

452

block = block_cache_get_empty(gCache, 0, id);

src/tests/system/kernel/cache/block_cache_test.cpp

453

or_block(block, BLOCK_CHANGED_IN_SUB);

src/tests/system/kernel/cache/block_cache_test.cpp

494

void* block = block_cache_get_writable(gCache, 1, id);

src/tests/system/kernel/cache/block_cache_test.cpp

500

block = block_cache_get_empty(gCache, 2, id);

src/tests/system/kernel/cache/block_cache_test.cpp

603

block = block_cache_get_writable(gCache, 0, id);

src/tests/system/kernel/cache/block_cache_test.cpp

604

or_block(block, BLOCK_CHANGED_IN_MAIN);

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

107

CheckSumBlock* block = new(std::nothrow) CheckSumBlock;

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

108

if (block == NULL)

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

111

fBlocks.Add(block);

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

123

CheckSumBlock* block;

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

125

fBlockCount + blockIndex / kCheckSumsPerBlock, block);

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

129

checkSum = block->checkSums[blockIndex % kCheckSumsPerBlock];

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

140

CheckSumBlock* block;

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

142

fBlockCount + blockIndex / kCheckSumsPerBlock, block);

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

146

block->checkSums[blockIndex % kCheckSumsPerBlock] = checkSum;

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

147

block->dirty = true;

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

168

CheckSumBlock* block = it.Next();) {

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

169

if (block->used && blockIndex == block->blockIndex) {

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

172

fBlocks.Add(block);

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

173

_block = block;

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

179

CheckSumBlock* block = fBlocks.Head();

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

180

status_t error = _FlushBlock(block);

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

184

error = _ReadBlock(block, blockIndex);

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

189

fBlocks.Remove(block);

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

190

fBlocks.Add(block);

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

192

_block = block;

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

196

status_t _FlushBlock(CheckSumBlock* block)

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

198

if (!block->used || !block->dirty)

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

201

ssize_t written = pwrite(fFD, block->checkSums, B_PAGE_SIZE,

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

202

block->blockIndex * B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

208

block->dirty = false;

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

212

status_t _ReadBlock(CheckSumBlock* block, uint64 blockIndex)

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

215

block->used = false;

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

217

ssize_t bytesRead = pread(fFD, block->checkSums, B_PAGE_SIZE,

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

224

block->blockIndex = blockIndex;

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

225

block->used = true;

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

226

block->dirty = false;

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

95

while (CheckSumBlock* block = fBlocks.RemoveHead())

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

96

delete block;

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

100

if (!block.GetZero(fVolume, fBitmapBlock + i, transaction))

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

108

Block block;

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

109

if (!block.GetZero(fVolume, fBitmapBlock + fBitmapBlockCount - 1,

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

115

uint32* bits = (uint32*)block.Data();

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

129

Block block;

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

130

if (!block.GetZero(fVolume, fAllocationGroupBlock + i, transaction))

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

133

uint16* counts = (uint16*)block.Data();

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

367

Block block;

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

368

if (!block.GetWritable(fVolume,

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

373

uint16* counts = (uint16*)block.Data();

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

494

Block block;

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

495

if (!block.GetWritable(fVolume,

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

500

uint32* bits = (uint32*)block.Data()

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

502

uint32* const bitsEnd = (uint32*)block.Data() + kBlocksPerBitmapBlock / 32;

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

630

Block block;

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

631

if (!block.GetWritable(fVolume,

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

636

uint16* counts = (uint16*)block.Data();

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

674

Block block;

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

675

if (!block.GetWritable(fVolume,

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

680

uint32* bits = (uint32*)block.Data() + base % kBlocksPerBitmapBlock / 32;

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

726

Block block;

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

727

if (!block.GetWritable(fVolume, kCheckSumFSSuperBlockOffset / B_PAGE_SIZE,

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

732

SuperBlock* superBlock = (SuperBlock*)block.Data();

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

735

block.Put();

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

99

Block block;

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1017

info.block.Index(), 1, transaction);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1027

if (!nextInfo.block.GetReadable(fDirectory->GetVolume(),

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1033

(checksumfs_dir_entry_block*)nextInfo.block.Data(),

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1152

error = info.block.MakeWritable(transaction);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1179

tempBlockUpdate.TransferFrom(info.block);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1222

tempBlockUpdate.TransferFrom(info.block);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1229

info.block.TransferFrom(newBlock);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1231

(checksumfs_dir_entry_block*)info.block.Data(),

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1276

tempBlockUpdate.TransferFrom(info.block);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1323

tempBlockUpdate.TransferFrom(info.block);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1368

if (!newInfo.block.GetZero(fDirectory->GetVolume(),

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1376

(checksumfs_dir_entry_block*)newInfo.block.Data(), B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1387

newInfo.block.Index());

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1389

PRINT(" -> new block: %" B_PRIu64 "\n", newInfo.block.Index());

src/tests/system/kernel/file_corruption/fs/Directory.cpp

566

Block block;

src/tests/system/kernel/file_corruption/fs/Directory.cpp

604

if (!block.GetReadable(fDirectory->GetVolume(), blockIndex))

src/tests/system/kernel/file_corruption/fs/Directory.cpp

607

entryBlock.SetTo((checksumfs_dir_entry_block*)block.Data(),

src/tests/system/kernel/file_corruption/fs/Directory.cpp

674

if (!nextInfo.block.GetReadable(fDirectory->GetVolume(),

src/tests/system/kernel/file_corruption/fs/Directory.cpp

680

(checksumfs_dir_entry_block*)nextInfo.block.Data(),

src/tests/system/kernel/file_corruption/fs/Directory.cpp

715

if (!info.block.GetReadable(fDirectory->GetVolume(),

src/tests/system/kernel/file_corruption/fs/Directory.cpp

721

(checksumfs_dir_entry_block*)info.block.Data(), B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

796

level == 0 ? fDirectory->BlockIndex() : info.block.Index(),

src/tests/system/kernel/file_corruption/fs/Directory.cpp

818

if (!nextInfo.block.GetReadable(fDirectory->GetVolume(),

src/tests/system/kernel/file_corruption/fs/Directory.cpp

824

(checksumfs_dir_entry_block*)nextInfo.block.Data(),

src/tests/system/kernel/file_corruption/fs/Directory.cpp

85

Block block;

src/tests/system/kernel/file_corruption/fs/Directory.cpp

886

level == 0 ? fDirectory->BlockIndex() : info.block.Index(),

src/tests/system/kernel/file_corruption/fs/Directory.cpp

913

if (!nextInfo.block.GetReadable(fDirectory->GetVolume(),

src/tests/system/kernel/file_corruption/fs/Directory.cpp

919

(checksumfs_dir_entry_block*)nextInfo.block.Data(),

src/tests/system/kernel/file_corruption/fs/Directory.cpp

939

error = info.block.MakeWritable(transaction);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

958

info.block.Index(), 1, transaction);

src/tests/system/kernel/file_corruption/fs/File.cpp

343

if (!info.block.GetReadable(GetVolume(), blockIndex))

src/tests/system/kernel/file_corruption/fs/File.cpp

347

info.blockData = (uint64*)((uint8*)info.block.Data()

src/tests/system/kernel/file_corruption/fs/File.cpp

350

info.blockData = (uint64*)info.block.Data();

src/tests/system/kernel/file_corruption/fs/File.cpp

388

if (!infos[level].block.GetReadable(GetVolume(), blockIndex))

src/tests/system/kernel/file_corruption/fs/File.cpp

391

infos[level].blockData = (uint64*)infos[level].block.Data();

src/tests/system/kernel/file_corruption/fs/File.cpp

499

if (!infos[0].block.GetWritable(GetVolume(), BlockIndex(), transaction))

src/tests/system/kernel/file_corruption/fs/File.cpp

501

infos[0].blockData = (uint64*)((uint8*)infos[0].block.Data()

src/tests/system/kernel/file_corruption/fs/File.cpp

534

if (!info.block.GetWritable(GetVolume(), blockIndex, transaction))

src/tests/system/kernel/file_corruption/fs/File.cpp

536

info.blockData = (uint64*)info.block.Data();

src/tests/system/kernel/file_corruption/fs/File.cpp

57

Block block;

src/tests/system/kernel/file_corruption/fs/File.cpp

575

Block block;

src/tests/system/kernel/file_corruption/fs/File.cpp

576

if (!block.GetReadable(GetVolume(), blockIndex))

src/tests/system/kernel/file_corruption/fs/File.cpp

580

const uint64* blockData = (uint64*)infos[i].block.Data();

src/tests/system/kernel/file_corruption/fs/File.cpp

584

block.Put();

src/tests/system/kernel/file_corruption/fs/File.cpp

610

Block& rootBlock = infos[0].block;

src/tests/system/kernel/file_corruption/fs/File.cpp

659

if (!infos[i + 1].block.GetWritable(GetVolume(),

src/tests/system/kernel/file_corruption/fs/File.cpp

663

infos[i + 1].blockData = (uint64*)infos[i + 1].block.Data();

src/tests/system/kernel/file_corruption/fs/File.cpp

693

if (!infos[level].block.GetZero(GetVolume(), blockIndex,

src/tests/system/kernel/file_corruption/fs/File.cpp

698

infos[level].blockData = (uint64*)infos[level].block.Data();

src/tests/system/kernel/file_corruption/fs/Node.cpp

264

Block block;

src/tests/system/kernel/file_corruption/fs/Node.cpp

265

if (!block.GetWritable(fVolume, fBlockIndex, transaction))

src/tests/system/kernel/file_corruption/fs/Node.cpp

268

memcpy(block.Data(), &fNode, sizeof(fNode));

src/tests/system/kernel/file_corruption/fs/SymLink.cpp

55

Block block;

src/tests/system/kernel/file_corruption/fs/SymLink.cpp

56

if (!block.GetReadable(GetVolume(), BlockIndex()))

src/tests/system/kernel/file_corruption/fs/SymLink.cpp

59

const char* data = (char*)block.Data() + kSymLinkDataOffset;

src/tests/system/kernel/file_corruption/fs/SymLink.cpp

83

Block block;

src/tests/system/kernel/file_corruption/fs/SymLink.cpp

84

if (!block.GetWritable(GetVolume(), BlockIndex(), transaction))

src/tests/system/kernel/file_corruption/fs/SymLink.cpp

87

char* data = (char*)block.Data() + kSymLinkDataOffset;

src/tests/system/kernel/file_corruption/fs/Volume.cpp

134

Block block;

src/tests/system/kernel/file_corruption/fs/Volume.cpp

135

if (!block.GetReadable(this, kCheckSumFSSuperBlockOffset / B_PAGE_SIZE))

src/tests/system/kernel/file_corruption/fs/Volume.cpp

138

SuperBlock* superBlock = (SuperBlock*)block.Data();

src/tests/system/kernel/file_corruption/fs/Volume.cpp

213

Block block;

src/tests/system/kernel/file_corruption/fs/Volume.cpp

214

if (!block.GetZero(this, kCheckSumFSSuperBlockOffset / B_PAGE_SIZE,

src/tests/system/kernel/file_corruption/fs/Volume.cpp

219

SuperBlock* superBlock = (SuperBlock*)block.Data();

src/tests/system/kernel/file_corruption/fs/Volume.cpp

222

block.Put();

src/tests/system/kernel/file_corruption/fs/Volume.cpp

299

Block block;

src/tests/system/kernel/file_corruption/fs/Volume.cpp

300

if (!block.GetReadable(this, blockIndex))

src/tests/system/kernel/file_corruption/fs/Volume.cpp

303

checksumfs_node* nodeData = (checksumfs_node*)block.Data();

src/tests/system/kernel/file_corruption/fs/Volume.cpp

436

Block block;

src/tests/system/kernel/file_corruption/fs/Volume.cpp

437

if (!block.GetWritable(this, kCheckSumFSSuperBlockOffset / B_PAGE_SIZE,

src/tests/system/kernel/file_corruption/fs/Volume.cpp

442

SuperBlock* superBlock = (SuperBlock*)block.Data();

src/tests/system/kernel/file_corruption/fs/Volume.cpp

445

block.Put();

src/tests/system/kernel/file_corruption/fs/Volume.cpp

499

Block block;

src/tests/system/kernel/file_corruption/fs/Volume.cpp

500

if (!block.GetZero(this, allocatedBlock.Index(), transaction))

src/tools/fs_shell/block_cache.cpp

1065

cached_block* block = transaction->first_block;

src/tools/fs_shell/block_cache.cpp

1067

for (; block != NULL; block = next) {

src/tools/fs_shell/block_cache.cpp

1068

next = block->transaction_next;

src/tools/fs_shell/block_cache.cpp

1070

if (block->previous_transaction != NULL) {

src/tools/fs_shell/block_cache.cpp

1072

write_cached_block(cache, block);

src/tools/fs_shell/block_cache.cpp

1074

if (block->discard) {

src/tools/fs_shell/block_cache.cpp

1076

cache->DiscardBlock(block);

src/tools/fs_shell/block_cache.cpp

1081

if (block->original_data != NULL) {

src/tools/fs_shell/block_cache.cpp

1082

cache->Free(block->original_data);

src/tools/fs_shell/block_cache.cpp

1083

block->original_data = NULL;

src/tools/fs_shell/block_cache.cpp

1086

if (block->parent_data != block->current_data)

src/tools/fs_shell/block_cache.cpp

1087

cache->Free(block->parent_data);

src/tools/fs_shell/block_cache.cpp

1088

block->parent_data = NULL;

src/tools/fs_shell/block_cache.cpp

1092

transaction->blocks.Add(block);

src/tools/fs_shell/block_cache.cpp

1094

block->previous_transaction = transaction;

src/tools/fs_shell/block_cache.cpp

1095

block->transaction_next = NULL;

src/tools/fs_shell/block_cache.cpp

1096

block->transaction = NULL;

src/tools/fs_shell/block_cache.cpp

1122

cached_block* block = transaction->first_block;

src/tools/fs_shell/block_cache.cpp

1124

for (; block != NULL; block = next) {

src/tools/fs_shell/block_cache.cpp

1125

next = block->transaction_next;

src/tools/fs_shell/block_cache.cpp

1127

if (block->original_data != NULL) {

src/tools/fs_shell/block_cache.cpp

1129

transaction->id, block->block_number));

src/tools/fs_shell/block_cache.cpp

1130

fssh_memcpy(block->current_data, block->original_data, cache->block_size);

src/tools/fs_shell/block_cache.cpp

1131

cache->Free(block->original_data);

src/tools/fs_shell/block_cache.cpp

1132

block->original_data = NULL;

src/tools/fs_shell/block_cache.cpp

1135

if (block->parent_data != block->current_data)

src/tools/fs_shell/block_cache.cpp

1136

cache->Free(block->parent_data);

src/tools/fs_shell/block_cache.cpp

1137

block->parent_data = NULL;

src/tools/fs_shell/block_cache.cpp

1140

block->transaction_next = NULL;

src/tools/fs_shell/block_cache.cpp

1141

block->transaction = NULL;

src/tools/fs_shell/block_cache.cpp

1142

block->discard = false;

src/tools/fs_shell/block_cache.cpp

1189

cached_block* block = transaction->first_block;

src/tools/fs_shell/block_cache.cpp

1192

for (; block != NULL; block = next) {

src/tools/fs_shell/block_cache.cpp

1193

next = block->transaction_next;

src/tools/fs_shell/block_cache.cpp

1195

if (block->previous_transaction != NULL) {

src/tools/fs_shell/block_cache.cpp

1197

write_cached_block(cache, block);

src/tools/fs_shell/block_cache.cpp

1199

if (block->discard) {

src/tools/fs_shell/block_cache.cpp

1200

cache->DiscardBlock(block);

src/tools/fs_shell/block_cache.cpp

1205

if (block->original_data != NULL && block->parent_data != NULL) {

src/tools/fs_shell/block_cache.cpp

1208

cache->Free(block->original_data);

src/tools/fs_shell/block_cache.cpp

1209

block->original_data = NULL;

src/tools/fs_shell/block_cache.cpp

1211

if (block->parent_data == NULL

src/tools/fs_shell/block_cache.cpp

1212

|| block->parent_data != block->current_data) {

src/tools/fs_shell/block_cache.cpp

1214

block->original_data = block->parent_data;

src/tools/fs_shell/block_cache.cpp

1216

newTransaction->first_block = block;

src/tools/fs_shell/block_cache.cpp

1218

last->transaction_next = block;

src/tools/fs_shell/block_cache.cpp

1220

block->transaction = newTransaction;

src/tools/fs_shell/block_cache.cpp

1221

last = block;

src/tools/fs_shell/block_cache.cpp

1223

block->transaction = NULL;

src/tools/fs_shell/block_cache.cpp

1225

if (block->parent_data != NULL) {

src/tools/fs_shell/block_cache.cpp

1227

transaction->blocks.Add(block);

src/tools/fs_shell/block_cache.cpp

1228

block->previous_transaction = transaction;

src/tools/fs_shell/block_cache.cpp

1229

block->parent_data = NULL;

src/tools/fs_shell/block_cache.cpp

1232

block->transaction_next = NULL;

src/tools/fs_shell/block_cache.cpp

1269

cached_block* block = transaction->first_block;

src/tools/fs_shell/block_cache.cpp

1271

for (; block != NULL; block = next) {

src/tools/fs_shell/block_cache.cpp

1272

next = block->transaction_next;

src/tools/fs_shell/block_cache.cpp

1274

if (block->parent_data == NULL) {

src/tools/fs_shell/block_cache.cpp

1275

if (block->original_data != NULL) {

src/tools/fs_shell/block_cache.cpp

1278

fssh_memcpy(block->current_data, block->original_data,

src/tools/fs_shell/block_cache.cpp

1281

} else if (block->parent_data != block->current_data) {

src/tools/fs_shell/block_cache.cpp

1284

transaction->id, block->block_number));

src/tools/fs_shell/block_cache.cpp

1285

fssh_memcpy(block->current_data, block->parent_data,

src/tools/fs_shell/block_cache.cpp

1287

cache->Free(block->parent_data);

src/tools/fs_shell/block_cache.cpp

129

void RemoveBlock(cached_block* block);

src/tools/fs_shell/block_cache.cpp

1290

block->parent_data = NULL;

src/tools/fs_shell/block_cache.cpp

1291

block->discard = false;

src/tools/fs_shell/block_cache.cpp

130

void DiscardBlock(cached_block* block);

src/tools/fs_shell/block_cache.cpp

131

void FreeBlock(cached_block* block);

src/tools/fs_shell/block_cache.cpp

1320

cached_block* block = transaction->first_block;

src/tools/fs_shell/block_cache.cpp

1323

for (; block != NULL; block = next) {

src/tools/fs_shell/block_cache.cpp

1324

next = block->transaction_next;

src/tools/fs_shell/block_cache.cpp

1326

if (block->discard) {

src/tools/fs_shell/block_cache.cpp

1333

cache->DiscardBlock(block);

src/tools/fs_shell/block_cache.cpp

1338

&& block->parent_data != NULL

src/tools/fs_shell/block_cache.cpp

1339

&& block->parent_data != block->current_data) {

src/tools/fs_shell/block_cache.cpp

1342

cache->Free(block->parent_data);

src/tools/fs_shell/block_cache.cpp

1347

block->parent_data = block->current_data;

src/tools/fs_shell/block_cache.cpp

1348

last = block;

src/tools/fs_shell/block_cache.cpp

1387

cached_block* block = (cached_block*)*_cookie;

src/tools/fs_shell/block_cache.cpp

1396

if (block == NULL)

src/tools/fs_shell/block_cache.cpp

1397

block = transaction->first_block;

src/tools/fs_shell/block_cache.cpp

1399

block = block->transaction_next;

src/tools/fs_shell/block_cache.cpp

1404

while (block != NULL && block->parent_data == NULL)

src/tools/fs_shell/block_cache.cpp

1405

block = block->transaction_next;

src/tools/fs_shell/block_cache.cpp

1408

while (block != NULL && block->discard)

src/tools/fs_shell/block_cache.cpp

1409

block = block->transaction_next;

src/tools/fs_shell/block_cache.cpp

1413

if (block == NULL)

src/tools/fs_shell/block_cache.cpp

1417

*_blockNumber = block->block_number;

src/tools/fs_shell/block_cache.cpp

1419

*_data = mainOnly ? block->parent_data : block->current_data;

src/tools/fs_shell/block_cache.cpp

1421

*_unchangedData = block->original_data;

src/tools/fs_shell/block_cache.cpp

1423

*_cookie = (fssh_addr_t)block;

src/tools/fs_shell/block_cache.cpp

1477

cached_block* block = (cached_block*)hash_lookup(cache->hash, &blockNumber);

src/tools/fs_shell/block_cache.cpp

1479

return (block != NULL && block->transaction != NULL

src/tools/fs_shell/block_cache.cpp

1480

&& block->transaction->id == id);

src/tools/fs_shell/block_cache.cpp

1500

cached_block* block;

src/tools/fs_shell/block_cache.cpp

1501

while ((block = (cached_block*)hash_remove_first(cache->hash,

src/tools/fs_shell/block_cache.cpp

1503

cache->FreeBlock(block);

src/tools/fs_shell/block_cache.cpp

1548

cached_block* block;

src/tools/fs_shell/block_cache.cpp

1549

while ((block = (cached_block*)hash_next(cache->hash, &iterator)) != NULL) {

src/tools/fs_shell/block_cache.cpp

1550

if (block->previous_transaction != NULL

src/tools/fs_shell/block_cache.cpp

1551

|| (block->transaction == NULL && block->is_dirty)) {

src/tools/fs_shell/block_cache.cpp

1552

fssh_status_t status = write_cached_block(cache, block);

src/tools/fs_shell/block_cache.cpp

1581

cached_block* block = (cached_block*)hash_lookup(cache->hash,

src/tools/fs_shell/block_cache.cpp

1583

if (block == NULL)

src/tools/fs_shell/block_cache.cpp

1586

if (block->previous_transaction != NULL

src/tools/fs_shell/block_cache.cpp

1587

|| (block->transaction == NULL && block->is_dirty)) {

src/tools/fs_shell/block_cache.cpp

1588

fssh_status_t status = write_cached_block(cache, block);

src/tools/fs_shell/block_cache.cpp

1606

cached_block* block = (cached_block*)hash_lookup(cache->hash,

src/tools/fs_shell/block_cache.cpp

1608

if (block == NULL)

src/tools/fs_shell/block_cache.cpp

1611

if (block->previous_transaction != NULL)

src/tools/fs_shell/block_cache.cpp

1612

write_cached_block(cache, block);

src/tools/fs_shell/block_cache.cpp

1614

if (block->unused) {

src/tools/fs_shell/block_cache.cpp

1615

cache->unused_blocks.Remove(block);

src/tools/fs_shell/block_cache.cpp

1616

cache->RemoveBlock(block);

src/tools/fs_shell/block_cache.cpp

1618

if (block->transaction != NULL && block->parent_data != NULL

src/tools/fs_shell/block_cache.cpp

1619

&& block->parent_data != block->current_data) {

src/tools/fs_shell/block_cache.cpp

1625

block->discard = true;

src/tools/fs_shell/block_cache.cpp

1642

void* block;

src/tools/fs_shell/block_cache.cpp

1644

transaction, false, &block);

src/tools/fs_shell/block_cache.cpp

166

static fssh_status_t write_cached_block(block_cache* cache, cached_block* block,

src/tools/fs_shell/block_cache.cpp

1675

void* block;

src/tools/fs_shell/block_cache.cpp

1677

blockNumber, transaction, &block);

src/tools/fs_shell/block_cache.cpp

1679

return block;

src/tools/fs_shell/block_cache.cpp

1697

void* block;

src/tools/fs_shell/block_cache.cpp

1699

transaction, true, &block) == FSSH_B_OK)

src/tools/fs_shell/block_cache.cpp

1700

return block;

src/tools/fs_shell/block_cache.cpp

1713

cached_block* block;

src/tools/fs_shell/block_cache.cpp

1715

true, &block);

src/tools/fs_shell/block_cache.cpp

1720

if (block->compare == NULL)

src/tools/fs_shell/block_cache.cpp

1721

block->compare = cache->Allocate();

src/tools/fs_shell/block_cache.cpp

1722

if (block->compare != NULL)

src/tools/fs_shell/block_cache.cpp

1723

memcpy(block->compare, block->current_data, cache->block_size);

src/tools/fs_shell/block_cache.cpp

1725

*_block = block->current_data;

src/tools/fs_shell/block_cache.cpp

1733

const void* block;

src/tools/fs_shell/block_cache.cpp

1734

if (fssh_block_cache_get_etc(_cache, blockNumber, &block)

src/tools/fs_shell/block_cache.cpp

1736

return block;

src/tools/fs_shell/block_cache.cpp

1756

cached_block* block = (cached_block*)hash_lookup(cache->hash,

src/tools/fs_shell/block_cache.cpp

1758

if (block == NULL)

src/tools/fs_shell/block_cache.cpp

1760

if (block->is_dirty == dirty) {

src/tools/fs_shell/block_cache.cpp

444

const fssh_off_t* block = (const fssh_off_t*)_block;

src/tools/fs_shell/block_cache.cpp

446

fssh_off_t diff = cacheEntry->block_number - *block;

src/tools/fs_shell/block_cache.cpp

459

const fssh_off_t* block = (const fssh_off_t*)_block;

src/tools/fs_shell/block_cache.cpp

464

return (uint64_t)*block % range;

src/tools/fs_shell/block_cache.cpp

535

block_cache::FreeBlock(cached_block* block)

src/tools/fs_shell/block_cache.cpp

537

Free(block->current_data);

src/tools/fs_shell/block_cache.cpp

539

if (block->original_data != NULL || block->parent_data != NULL) {

src/tools/fs_shell/block_cache.cpp

541

", original %p, parent %p\n", block->block_number,

src/tools/fs_shell/block_cache.cpp

542

block->original_data, block->parent_data);

src/tools/fs_shell/block_cache.cpp

546

Free(block->compare);

src/tools/fs_shell/block_cache.cpp

549

delete block;

src/tools/fs_shell/block_cache.cpp

557

cached_block* block = new(nothrow) cached_block;

src/tools/fs_shell/block_cache.cpp

558

if (block == NULL) {

src/tools/fs_shell/block_cache.cpp

569

block->current_data = Allocate();

src/tools/fs_shell/block_cache.cpp

570

if (block->current_data == NULL) {

src/tools/fs_shell/block_cache.cpp

572

delete block;

src/tools/fs_shell/block_cache.cpp

576

block->block_number = blockNumber;

src/tools/fs_shell/block_cache.cpp

577

block->ref_count = 0;

src/tools/fs_shell/block_cache.cpp

578

block->accessed = 0;

src/tools/fs_shell/block_cache.cpp

579

block->transaction_next = NULL;

src/tools/fs_shell/block_cache.cpp

580

block->transaction = block->previous_transaction = NULL;

src/tools/fs_shell/block_cache.cpp

581

block->original_data = NULL;

src/tools/fs_shell/block_cache.cpp

582

block->parent_data = NULL;

src/tools/fs_shell/block_cache.cpp

583

block->is_dirty = false;

src/tools/fs_shell/block_cache.cpp

584

block->unused = false;

src/tools/fs_shell/block_cache.cpp

585

block->discard = false;

src/tools/fs_shell/block_cache.cpp

587

block->compare = NULL;

src/tools/fs_shell/block_cache.cpp

592

return block;

src/tools/fs_shell/block_cache.cpp

602

cached_block *block = iterator.Next();) {

src/tools/fs_shell/block_cache.cpp

603

if (maxAccessed < block->accessed)

src/tools/fs_shell/block_cache.cpp

607

block->block_number, block->accessed));

src/tools/fs_shell/block_cache.cpp

610

if (block->is_dirty && !block->discard)

src/tools/fs_shell/block_cache.cpp

611

write_cached_block(this, block, false);

src/tools/fs_shell/block_cache.cpp

615

RemoveBlock(block);

src/tools/fs_shell/block_cache.cpp

624

block_cache::RemoveBlock(cached_block* block)

src/tools/fs_shell/block_cache.cpp

626

hash_remove(hash, block);

src/tools/fs_shell/block_cache.cpp

627

FreeBlock(block);

src/tools/fs_shell/block_cache.cpp

635

block_cache::DiscardBlock(cached_block* block)

src/tools/fs_shell/block_cache.cpp

637

if (block->parent_data != NULL && block->parent_data != block->current_data)

src/tools/fs_shell/block_cache.cpp

638

Free(block->parent_data);

src/tools/fs_shell/block_cache.cpp

640

block->parent_data = NULL;

src/tools/fs_shell/block_cache.cpp

642

if (block->original_data != NULL) {

src/tools/fs_shell/block_cache.cpp

643

Free(block->original_data);

src/tools/fs_shell/block_cache.cpp

644

block->original_data = NULL;

src/tools/fs_shell/block_cache.cpp

647

RemoveBlock(block);

src/tools/fs_shell/block_cache.cpp

660

put_cached_block(block_cache* cache, cached_block* block)

src/tools/fs_shell/block_cache.cpp

663

if (!block->is_dirty && block->compare != NULL

src/tools/fs_shell/block_cache.cpp

664

&& memcmp(block->current_data, block->compare, cache->block_size)) {

src/tools/fs_shell/block_cache.cpp

666

fssh_dump_block((const char*)block->current_data, 256, " ");

src/tools/fs_shell/block_cache.cpp

668

fssh_dump_block((const char*)block->compare, 256, " ");

src/tools/fs_shell/block_cache.cpp

669

write_cached_block(cache, block);

src/tools/fs_shell/block_cache.cpp

672

cache->Free(block->compare);

src/tools/fs_shell/block_cache.cpp

673

block->compare = NULL;

src/tools/fs_shell/block_cache.cpp

677

if (--block->ref_count == 0

src/tools/fs_shell/block_cache.cpp

678

&& block->transaction == NULL && block->previous_transaction == NULL) {

src/tools/fs_shell/block_cache.cpp

680

if (block->discard) {

src/tools/fs_shell/block_cache.cpp

681

cache->RemoveBlock(block);

src/tools/fs_shell/block_cache.cpp

684

block->unused = true;

src/tools/fs_shell/block_cache.cpp

685

cache->unused_blocks.Add(block);

src/tools/fs_shell/block_cache.cpp

704

cached_block* block = (cached_block*)hash_lookup(cache->hash, &blockNumber);

src/tools/fs_shell/block_cache.cpp

705

if (block != NULL)

src/tools/fs_shell/block_cache.cpp

706

put_cached_block(cache, block);

src/tools/fs_shell/block_cache.cpp

729

cached_block* block = (cached_block*)hash_lookup(cache->hash,

src/tools/fs_shell/block_cache.cpp

733

if (block == NULL) {

src/tools/fs_shell/block_cache.cpp

735

block = cache->NewBlock(blockNumber);

src/tools/fs_shell/block_cache.cpp

736

if (block == NULL)

src/tools/fs_shell/block_cache.cpp

739

hash_insert(cache->hash, block);

src/tools/fs_shell/block_cache.cpp

746

if (fssh_read_pos(cache->fd, blockNumber * blockSize, block->current_data,

src/tools/fs_shell/block_cache.cpp

748

cache->RemoveBlock(block);

src/tools/fs_shell/block_cache.cpp

754

if (block->unused) {

src/tools/fs_shell/block_cache.cpp

756

block->unused = false;

src/tools/fs_shell/block_cache.cpp

757

cache->unused_blocks.Remove(block);

src/tools/fs_shell/block_cache.cpp

760

block->ref_count++;

src/tools/fs_shell/block_cache.cpp

761

block->accessed++;

src/tools/fs_shell/block_cache.cpp

763

*_block = block;

src/tools/fs_shell/block_cache.cpp

790

cached_block* block;

src/tools/fs_shell/block_cache.cpp

792

!cleared, &block);

src/tools/fs_shell/block_cache.cpp

796

block->discard = false;

src/tools/fs_shell/block_cache.cpp

801

fssh_memset(block->current_data, 0, cache->block_size);

src/tools/fs_shell/block_cache.cpp

803

block->is_dirty = true;

src/tools/fs_shell/block_cache.cpp

806

*_block = block->current_data;

src/tools/fs_shell/block_cache.cpp

810

cache_transaction* transaction = block->transaction;

src/tools/fs_shell/block_cache.cpp

816

put_cached_block(cache, block);

src/tools/fs_shell/block_cache.cpp

825

put_cached_block(cache, block);

src/tools/fs_shell/block_cache.cpp

830

put_cached_block(cache, block);

src/tools/fs_shell/block_cache.cpp

834

block->transaction = transaction;

src/tools/fs_shell/block_cache.cpp

837

block->transaction_next = transaction->first_block;

src/tools/fs_shell/block_cache.cpp

838

transaction->first_block = block;

src/tools/fs_shell/block_cache.cpp

842

bool wasUnchanged = block->original_data == NULL

src/tools/fs_shell/block_cache.cpp

843

|| block->previous_transaction != NULL;

src/tools/fs_shell/block_cache.cpp

845

if (!(allocated && cleared) && block->original_data == NULL) {

src/tools/fs_shell/block_cache.cpp

847

block->original_data = cache->Allocate();

src/tools/fs_shell/block_cache.cpp

848

if (block->original_data == NULL) {

src/tools/fs_shell/block_cache.cpp

850

put_cached_block(cache, block);

src/tools/fs_shell/block_cache.cpp

854

fssh_memcpy(block->original_data, block->current_data, cache->block_size);

src/tools/fs_shell/block_cache.cpp

856

if (block->parent_data == block->current_data) {

src/tools/fs_shell/block_cache.cpp

858

block->parent_data = cache->Allocate();

src/tools/fs_shell/block_cache.cpp

859

if (block->parent_data == NULL) {

src/tools/fs_shell/block_cache.cpp

862

put_cached_block(cache, block);

src/tools/fs_shell/block_cache.cpp

866

fssh_memcpy(block->parent_data, block->current_data, cache->block_size);

src/tools/fs_shell/block_cache.cpp

869

&& block->parent_data == NULL && wasUnchanged)

src/tools/fs_shell/block_cache.cpp

873

fssh_memset(block->current_data, 0, cache->block_size);

src/tools/fs_shell/block_cache.cpp

875

block->is_dirty = true;

src/tools/fs_shell/block_cache.cpp

877

*_block = block->current_data;

src/tools/fs_shell/block_cache.cpp

889

write_cached_block(block_cache* cache, cached_block* block,

src/tools/fs_shell/block_cache.cpp

892

cache_transaction* previous = block->previous_transaction;

src/tools/fs_shell/block_cache.cpp

895

void* data = previous && block->original_data

src/tools/fs_shell/block_cache.cpp

896

? block->original_data : block->current_data;

src/tools/fs_shell/block_cache.cpp

899

TRACE(("write_cached_block(block %lld)\n", block->block_number));

src/tools/fs_shell/block_cache.cpp

901

fssh_ssize_t written = fssh_write_pos(cache->fd, block->block_number * blockSize,

src/tools/fs_shell/block_cache.cpp

906

block->block_number, fssh_strerror(fssh_get_errno())));

src/tools/fs_shell/block_cache.cpp

910

if (data == block->current_data)

src/tools/fs_shell/block_cache.cpp

911

block->is_dirty = false;

src/tools/fs_shell/block_cache.cpp

914

previous->blocks.Remove(block);

src/tools/fs_shell/block_cache.cpp

915

block->previous_transaction = NULL;

src/tools/fs_shell/block_cache.cpp

917

if (block->original_data != NULL && block->transaction == NULL) {

src/tools/fs_shell/block_cache.cpp

920

cache->Free(block->original_data);

src/tools/fs_shell/block_cache.cpp

921

block->original_data = NULL;

src/tools/fs_shell/block_cache.cpp

936

if (block->transaction == NULL && block->ref_count == 0 && !block->unused) {

src/tools/fs_shell/block_cache.cpp

938

block->unused = true;

src/tools/fs_shell/block_cache.cpp

939

cache->unused_blocks.Add(block);