arch/arm/mm/dma-mapping.c

576

buf->allocator = &cma_allocator;

arch/arm/mm/dma-mapping.c

578

buf->allocator = &simple_allocator;

arch/arm/mm/dma-mapping.c

580

buf->allocator = &remap_allocator;

arch/arm/mm/dma-mapping.c

582

buf->allocator = &pool_allocator;

arch/arm/mm/dma-mapping.c

584

addr = buf->allocator->alloc(&args, &page);

arch/arm/mm/dma-mapping.c

623

buf->allocator->free(&args);

arch/arm/mm/dma-mapping.c

71

struct arm_dma_allocator *allocator;

drivers/md/dm-vdo/message-stats.c

353

write_block_allocator_statistics("allocator : ", &stats->allocator,

drivers/md/dm-vdo/physical-zone.c

158

struct block_allocator *allocator)

drivers/md/dm-vdo/physical-zone.c

165

result = vdo_release_block_reference(allocator, locked_pbn);

drivers/md/dm-vdo/physical-zone.c

344

zone->allocator = &vdo->depot->allocators[zone_number];

drivers/md/dm-vdo/physical-zone.c

492

result = vdo_allocate_block(allocation->zone->allocator, &allocation->pbn);

drivers/md/dm-vdo/physical-zone.c

562

result = vdo_enqueue_clean_slab_waiter(zone->allocator,

drivers/md/dm-vdo/physical-zone.c

634

release_pbn_lock_provisional_reference(lock, locked_pbn, zone->allocator);

drivers/md/dm-vdo/physical-zone.c

644

vdo_dump_block_allocator(zone->allocator);

drivers/md/dm-vdo/physical-zone.h

66

struct block_allocator *allocator;

drivers/md/dm-vdo/repair.c

799

struct block_allocator *allocator = vdo_as_block_allocator(completion);

drivers/md/dm-vdo/repair.c

831

if (slab->allocator != allocator)

drivers/md/dm-vdo/repair.c

851

void vdo_replay_into_slab_journals(struct block_allocator *allocator, void *context)

drivers/md/dm-vdo/repair.c

853

struct vdo_completion *completion = &allocator->completion;

drivers/md/dm-vdo/repair.c

857

vdo_assert_on_physical_zone_thread(vdo, allocator->zone_number, __func__);

drivers/md/dm-vdo/repair.c

878

allocator->zone_number);

drivers/md/dm-vdo/repair.h

11

void vdo_replay_into_slab_journals(struct block_allocator *allocator, void *context);

drivers/md/dm-vdo/slab-depot.c

1024

vdo_enter_read_only_mode(slab->allocator->depot->vdo, result);

drivers/md/dm-vdo/slab-depot.c

1045

if (vdo_is_read_only(slab->allocator->depot->vdo))

drivers/md/dm-vdo/slab-depot.c

1051

acquire_vio_from_pool(slab->allocator->vio_pool, waiter);

drivers/md/dm-vdo/slab-depot.c

1112

offset = slab->allocator->summary_entries[slab->slab_number].tail_block_offset;

drivers/md/dm-vdo/slab-depot.c

1157

thread_id_t thread_id = block->slab->allocator->thread_id;

drivers/md/dm-vdo/slab-depot.c

1175

vdo_enter_read_only_mode(slab->allocator->depot->vdo, result);

drivers/md/dm-vdo/slab-depot.c

1212

WRITE_ONCE(block->slab->allocator->ref_counts_statistics.blocks_written,

drivers/md/dm-vdo/slab-depot.c

1213

block->slab->allocator->ref_counts_statistics.blocks_written + 1);

drivers/md/dm-vdo/slab-depot.c

1307

if (slab_block_number >= slab->allocator->depot->slab_config.data_blocks)

drivers/md/dm-vdo/slab-depot.c

1338

unsigned int unopened_slab_priority = slab->allocator->unopened_slab_priority;

drivers/md/dm-vdo/slab-depot.c

1379

vdo_priority_table_enqueue(slab->allocator->prioritized_slabs,

drivers/md/dm-vdo/slab-depot.c

1390

struct block_allocator *allocator = slab->allocator;

drivers/md/dm-vdo/slab-depot.c

1392

WRITE_ONCE(allocator->allocated_blocks,

drivers/md/dm-vdo/slab-depot.c

1393

allocator->allocated_blocks + (incremented ? -1 : 1));

drivers/md/dm-vdo/slab-depot.c

1396

if (slab == allocator->open_slab)

drivers/md/dm-vdo/slab-depot.c

1407

vdo_priority_table_remove(allocator->prioritized_slabs, &slab->allocq_entry);

drivers/md/dm-vdo/slab-depot.c

151

struct list_head *dirty_list = &journal->slab->allocator->dirty_slab_journals;

drivers/md/dm-vdo/slab-depot.c

1712

zone_count_t zone_number = journal->slab->allocator->zone_number;

drivers/md/dm-vdo/slab-depot.c

187

read_only = vdo_is_read_only(slab->allocator->depot->vdo);

drivers/md/dm-vdo/slab-depot.c

233

static void check_summary_drain_complete(struct block_allocator *allocator)

drivers/md/dm-vdo/slab-depot.c

2335

block->slab->allocator->thread_id);

drivers/md/dm-vdo/slab-depot.c

235

if (!vdo_is_state_draining(&allocator->summary_state) ||

drivers/md/dm-vdo/slab-depot.c

236

(allocator->summary_write_count > 0))

drivers/md/dm-vdo/slab-depot.c

2368

u64 blocks_per_vio = slab->allocator->refcount_blocks_per_big_vio;

drivers/md/dm-vdo/slab-depot.c

2369

struct vio_pool *pool = slab->allocator->refcount_big_vio_pool;

drivers/md/dm-vdo/slab-depot.c

2372

pool = slab->allocator->vio_pool;

drivers/md/dm-vdo/slab-depot.c

239

vdo_finish_operation(&allocator->summary_state,

drivers/md/dm-vdo/slab-depot.c

240

(vdo_is_read_only(allocator->depot->vdo) ?

drivers/md/dm-vdo/slab-depot.c

2410

load = slab->allocator->summary_entries[slab->slab_number].load_ref_counts;

drivers/md/dm-vdo/slab-depot.c

2427

block_count_t data_blocks = slab->allocator->depot->slab_config.data_blocks;

drivers/md/dm-vdo/slab-depot.c

249

static void notify_summary_waiters(struct block_allocator *allocator,

drivers/md/dm-vdo/slab-depot.c

2506

(header.nonce == slab->allocator->nonce)) {

drivers/md/dm-vdo/slab-depot.c

2513

journal->head = (slab->allocator->summary_entries[slab->slab_number].is_dirty ?

drivers/md/dm-vdo/slab-depot.c

252

int result = (vdo_is_read_only(allocator->depot->vdo) ?

drivers/md/dm-vdo/slab-depot.c

2529

journal->slab->allocator->thread_id);

drivers/md/dm-vdo/slab-depot.c

2559

slab->allocator->summary_entries[slab->slab_number].tail_block_offset;

drivers/md/dm-vdo/slab-depot.c

2570

vio->completion.callback_thread_id = slab->allocator->thread_id;

drivers/md/dm-vdo/slab-depot.c

2585

last_commit_point = slab->allocator->summary_entries[slab->slab_number].tail_block_offset;

drivers/md/dm-vdo/slab-depot.c

2587

!slab->allocator->summary_entries[slab->slab_number].load_ref_counts) {

drivers/md/dm-vdo/slab-depot.c

2602

acquire_vio_from_pool(slab->allocator->vio_pool, &journal->resource_waiter);

drivers/md/dm-vdo/slab-depot.c

2607

struct slab_scrubber *scrubber = &slab->allocator->scrubber;

drivers/md/dm-vdo/slab-depot.c

2633

struct block_allocator *allocator = slab->allocator;

drivers/md/dm-vdo/slab-depot.c

2640

if (vdo_is_read_only(allocator->depot->vdo))

drivers/md/dm-vdo/slab-depot.c

2644

result = VDO_ASSERT((free_blocks <= allocator->depot->slab_config.data_blocks),

drivers/md/dm-vdo/slab-depot.c

2647

(unsigned long long) allocator->depot->slab_config.data_blocks);

drivers/md/dm-vdo/slab-depot.c

2649

vdo_enter_read_only_mode(allocator->depot->vdo, result);

drivers/md/dm-vdo/slab-depot.c

2664

WRITE_ONCE(allocator->allocated_blocks,

drivers/md/dm-vdo/slab-depot.c

2665

allocator->allocated_blocks - free_blocks);

drivers/md/dm-vdo/slab-depot.c

2667

WRITE_ONCE(allocator->statistics.slabs_opened,

drivers/md/dm-vdo/slab-depot.c

2668

allocator->statistics.slabs_opened + 1);

drivers/md/dm-vdo/slab-depot.c

267

notify_summary_waiters(block->allocator, &block->current_update_waiters);

drivers/md/dm-vdo/slab-depot.c

2672

if (allocator->depot->vdo->suspend_type == VDO_ADMIN_STATE_SAVING)

drivers/md/dm-vdo/slab-depot.c

269

block->allocator->summary_write_count--;

drivers/md/dm-vdo/slab-depot.c

273

check_summary_drain_complete(block->allocator);

drivers/md/dm-vdo/slab-depot.c

2758

struct block_allocator *allocator =

drivers/md/dm-vdo/slab-depot.c

2767

} else if (done && (atomic_add_return(-1, &allocator->depot->zones_to_scrub) == 0)) {

drivers/md/dm-vdo/slab-depot.c

2770

atomic_cmpxchg(&allocator->depot->vdo->state, VDO_RECOVERING,

drivers/md/dm-vdo/slab-depot.c

2788

free_vio_pool(vdo_forget(allocator->refcount_big_vio_pool));

drivers/md/dm-vdo/slab-depot.c

285

atomic64_inc(&block->allocator->depot->summary_statistics.blocks_written);

drivers/md/dm-vdo/slab-depot.c

2938

if ((header.nonce != slab->allocator->nonce) ||

drivers/md/dm-vdo/slab-depot.c

2978

slab->allocator->thread_id, completion->parent);

drivers/md/dm-vdo/slab-depot.c

2990

scrubber->slab->allocator->thread_id);

drivers/md/dm-vdo/slab-depot.c

3005

if (!slab->allocator->summary_entries[slab->slab_number].is_dirty) {

drivers/md/dm-vdo/slab-depot.c

3048

slab->allocator->thread_id, completion->parent);

drivers/md/dm-vdo/slab-depot.c

3058

static void scrub_slabs(struct block_allocator *allocator, struct vdo_completion *parent)

drivers/md/dm-vdo/slab-depot.c

3060

struct slab_scrubber *scrubber = &allocator->scrubber;

drivers/md/dm-vdo/slab-depot.c

3070

vdo_is_priority_table_empty(allocator->prioritized_slabs) &&

drivers/md/dm-vdo/slab-depot.c

3085

static void register_slab_with_allocator(struct block_allocator *allocator,

drivers/md/dm-vdo/slab-depot.c

3088

allocator->slab_count++;

drivers/md/dm-vdo/slab-depot.c

3089

allocator->last_slab = slab->slab_number;

drivers/md/dm-vdo/slab-depot.c

309

continue_vio_after_io(vio, finish_update, block->allocator->thread_id);

drivers/md/dm-vdo/slab-depot.c

3117

static struct slab_iterator get_slab_iterator(const struct block_allocator *allocator)

drivers/md/dm-vdo/slab-depot.c

3119

return get_depot_slab_iterator(allocator->depot, allocator->last_slab,

drivers/md/dm-vdo/slab-depot.c

3120

allocator->zone_number,

drivers/md/dm-vdo/slab-depot.c

3121

allocator->depot->zone_count);

drivers/md/dm-vdo/slab-depot.c

3168

struct block_allocator *allocator = listener;

drivers/md/dm-vdo/slab-depot.c

3171

assert_on_allocator_thread(allocator->thread_id, __func__);

drivers/md/dm-vdo/slab-depot.c

3172

iterator = get_slab_iterator(allocator);

drivers/md/dm-vdo/slab-depot.c

318

struct block_allocator *allocator = block->allocator;

drivers/md/dm-vdo/slab-depot.c

319

struct slab_depot *depot = allocator->depot;

drivers/md/dm-vdo/slab-depot.c

325

allocator->summary_write_count++;

drivers/md/dm-vdo/slab-depot.c

3255

WRITE_ONCE(slab->allocator->statistics.slabs_opened,

drivers/md/dm-vdo/slab-depot.c

3256

slab->allocator->statistics.slabs_opened + 1);

drivers/md/dm-vdo/slab-depot.c

3259

WRITE_ONCE(slab->allocator->statistics.slabs_reopened,

drivers/md/dm-vdo/slab-depot.c

3260

slab->allocator->statistics.slabs_reopened + 1);

drivers/md/dm-vdo/slab-depot.c

3263

slab->allocator->open_slab = slab;

drivers/md/dm-vdo/slab-depot.c

3272

int vdo_allocate_block(struct block_allocator *allocator,

drivers/md/dm-vdo/slab-depot.c

3277

if (allocator->open_slab != NULL) {

drivers/md/dm-vdo/slab-depot.c

3279

result = allocate_slab_block(allocator->open_slab, block_number_ptr);

drivers/md/dm-vdo/slab-depot.c

3284

prioritize_slab(allocator->open_slab);

drivers/md/dm-vdo/slab-depot.c

3288

open_slab(list_entry(vdo_priority_table_dequeue(allocator->prioritized_slabs),

drivers/md/dm-vdo/slab-depot.c

3295

return allocate_slab_block(allocator->open_slab, block_number_ptr);

drivers/md/dm-vdo/slab-depot.c

3306

int vdo_enqueue_clean_slab_waiter(struct block_allocator *allocator,

drivers/md/dm-vdo/slab-depot.c

3309

if (vdo_is_read_only(allocator->depot->vdo))

drivers/md/dm-vdo/slab-depot.c

3312

if (vdo_is_state_quiescent(&allocator->scrubber.admin_state))

drivers/md/dm-vdo/slab-depot.c

3315

vdo_waitq_enqueue_waiter(&allocator->scrubber.waiters, waiter);

drivers/md/dm-vdo/slab-depot.c

3348

int vdo_release_block_reference(struct block_allocator *allocator,

drivers/md/dm-vdo/slab-depot.c

3364

return adjust_reference_count(vdo_get_slab(allocator->depot, pbn),

drivers/md/dm-vdo/slab-depot.c

3398

struct block_allocator *allocator = vdo_as_block_allocator(completion);

drivers/md/dm-vdo/slab-depot.c

3399

struct slab_actor *actor = &allocator->slab_actor;

drivers/md/dm-vdo/slab-depot.c

3412

struct block_allocator *allocator = vdo_as_block_allocator(completion);

drivers/md/dm-vdo/slab-depot.c

3414

if (allocator->state.waiter != NULL)

drivers/md/dm-vdo/slab-depot.c

3415

vdo_set_completion_result(allocator->state.waiter, completion->result);

drivers/md/dm-vdo/slab-depot.c

3420

static void apply_to_slabs(struct block_allocator *allocator, vdo_action_fn callback)

drivers/md/dm-vdo/slab-depot.c

3424

vdo_prepare_completion(&allocator->completion, slab_action_callback,

drivers/md/dm-vdo/slab-depot.c

3425

handle_operation_error, allocator->thread_id, NULL);

drivers/md/dm-vdo/slab-depot.c

3426

allocator->completion.requeue = false;

drivers/md/dm-vdo/slab-depot.c

3432

allocator->open_slab = NULL;

drivers/md/dm-vdo/slab-depot.c

3435

allocator->slab_actor = (struct slab_actor) {

drivers/md/dm-vdo/slab-depot.c

3440

iterator = get_slab_iterator(allocator);

drivers/md/dm-vdo/slab-depot.c

3443

vdo_get_admin_state_code(&allocator->state);

drivers/md/dm-vdo/slab-depot.c

3447

allocator->slab_actor.slab_action_count++;

drivers/md/dm-vdo/slab-depot.c

3449

&allocator->completion,

drivers/md/dm-vdo/slab-depot.c

3453

slab_action_callback(&allocator->completion);

drivers/md/dm-vdo/slab-depot.c

3458

struct block_allocator *allocator = vdo_as_block_allocator(completion);

drivers/md/dm-vdo/slab-depot.c

346

(VDO_SLAB_SUMMARY_BLOCKS_PER_ZONE * allocator->zone_number) +

drivers/md/dm-vdo/slab-depot.c

3460

vdo_get_admin_state_code(&allocator->state);

drivers/md/dm-vdo/slab-depot.c

3462

if (allocator->eraser != NULL)

drivers/md/dm-vdo/slab-depot.c

3463

dm_kcopyd_client_destroy(vdo_forget(allocator->eraser));

drivers/md/dm-vdo/slab-depot.c

3467

vdo_get_current_action_context(allocator->depot->action_manager);

drivers/md/dm-vdo/slab-depot.c

3469

vdo_replay_into_slab_journals(allocator, context);

drivers/md/dm-vdo/slab-depot.c

3473

vdo_finish_loading(&allocator->state);

drivers/md/dm-vdo/slab-depot.c

3476

static void erase_next_slab_journal(struct block_allocator *allocator);

drivers/md/dm-vdo/slab-depot.c

3480

struct block_allocator *allocator = context;

drivers/md/dm-vdo/slab-depot.c

3484

vdo_fail_completion(&allocator->completion, result);

drivers/md/dm-vdo/slab-depot.c

3488

erase_next_slab_journal(allocator);

drivers/md/dm-vdo/slab-depot.c

3492

static void erase_next_slab_journal(struct block_allocator *allocator)

drivers/md/dm-vdo/slab-depot.c

3497

struct slab_depot *depot = allocator->depot;

drivers/md/dm-vdo/slab-depot.c

3500

if (allocator->slabs_to_erase.next == NULL) {

drivers/md/dm-vdo/slab-depot.c

3501

vdo_finish_completion(&allocator->completion);

drivers/md/dm-vdo/slab-depot.c

3505

slab = next_slab(&allocator->slabs_to_erase);

drivers/md/dm-vdo/slab-depot.c

3512

dm_kcopyd_zero(allocator->eraser, 1, regions, 0, copy_callback, allocator);

drivers/md/dm-vdo/slab-depot.c

3518

struct block_allocator *allocator =

drivers/md/dm-vdo/slab-depot.c

3527

vdo_prepare_completion_for_requeue(&allocator->completion,

drivers/md/dm-vdo/slab-depot.c

3530

allocator->thread_id, NULL);

drivers/md/dm-vdo/slab-depot.c

3531

allocator->eraser = dm_kcopyd_client_create(NULL);

drivers/md/dm-vdo/slab-depot.c

3532

if (IS_ERR(allocator->eraser)) {

drivers/md/dm-vdo/slab-depot.c

3533

vdo_fail_completion(&allocator->completion,

drivers/md/dm-vdo/slab-depot.c

3534

PTR_ERR(allocator->eraser));

drivers/md/dm-vdo/slab-depot.c

3535

allocator->eraser = NULL;

drivers/md/dm-vdo/slab-depot.c

3538

allocator->slabs_to_erase = get_slab_iterator(allocator);

drivers/md/dm-vdo/slab-depot.c

3540

erase_next_slab_journal(allocator);

drivers/md/dm-vdo/slab-depot.c

3544

apply_to_slabs(allocator, finish_loading_allocator);

drivers/md/dm-vdo/slab-depot.c

3554

struct block_allocator *allocator = vdo_as_block_allocator(completion);

drivers/md/dm-vdo/slab-depot.c

3556

vdo_finish_loading_with_result(&allocator->state, completion->result);

drivers/md/dm-vdo/slab-depot.c

3559

static int get_slab_statuses(struct block_allocator *allocator,

drivers/md/dm-vdo/slab-depot.c

3564

struct slab_iterator iterator = get_slab_iterator(allocator);

drivers/md/dm-vdo/slab-depot.c

3566

result = vdo_allocate(allocator->slab_count, struct slab_status, __func__,

drivers/md/dm-vdo/slab-depot.c

3578

.is_clean = !allocator->summary_entries[slab_number].is_dirty,

drivers/md/dm-vdo/slab-depot.c

3579

.emptiness = allocator->summary_entries[slab_number].fullness_hint,

drivers/md/dm-vdo/slab-depot.c

3587

static int __must_check vdo_prepare_slabs_for_allocation(struct block_allocator *allocator)

drivers/md/dm-vdo/slab-depot.c

3593

struct slab_depot *depot = allocator->depot;

drivers/md/dm-vdo/slab-depot.c

3595

WRITE_ONCE(allocator->allocated_blocks,

drivers/md/dm-vdo/slab-depot.c

3596

allocator->slab_count * depot->slab_config.data_blocks);

drivers/md/dm-vdo/slab-depot.c

3597

result = get_slab_statuses(allocator, &slab_statuses);

drivers/md/dm-vdo/slab-depot.c

3604

.nr = allocator->slab_count,

drivers/md/dm-vdo/slab-depot.c

3605

.size = allocator->slab_count,

drivers/md/dm-vdo/slab-depot.c

3619

(!allocator->summary_entries[slab->slab_number].load_ref_counts &&

drivers/md/dm-vdo/slab-depot.c

3655

void vdo_dump_block_allocator(const struct block_allocator *allocator)

drivers/md/dm-vdo/slab-depot.c

3658

struct slab_iterator iterator = get_slab_iterator(allocator);

drivers/md/dm-vdo/slab-depot.c

3659

const struct slab_scrubber *scrubber = &allocator->scrubber;

drivers/md/dm-vdo/slab-depot.c

3661

vdo_log_info("block_allocator zone %u", allocator->zone_number);

drivers/md/dm-vdo/slab-depot.c

367

struct block_allocator *allocator = slab->allocator;

drivers/md/dm-vdo/slab-depot.c

368

struct slab_summary_block *block = &allocator->summary_blocks[index];

drivers/md/dm-vdo/slab-depot.c

3739

const struct slab_config *slab_config = &slab->allocator->depot->slab_config;

drivers/md/dm-vdo/slab-depot.c

3759

journal->events = &slab->allocator->slab_journal_statistics;

drivers/md/dm-vdo/slab-depot.c

3760

journal->recovery_journal = slab->allocator->depot->vdo->recovery_journal;

drivers/md/dm-vdo/slab-depot.c

3777

journal->tail_header.nonce = slab->allocator->nonce;

drivers/md/dm-vdo/slab-depot.c

378

if (vdo_is_state_draining(&allocator->summary_state) ||

drivers/md/dm-vdo/slab-depot.c

379

vdo_is_state_quiescent(&allocator->summary_state)) {

drivers/md/dm-vdo/slab-depot.c

3795

struct block_allocator *allocator,

drivers/md/dm-vdo/slab-depot.c

3799

const struct slab_config *slab_config = &allocator->depot->slab_config;

drivers/md/dm-vdo/slab-depot.c

3808

.allocator = allocator,

drivers/md/dm-vdo/slab-depot.c

385

entry = &allocator->summary_entries[slab->slab_number];

drivers/md/dm-vdo/slab-depot.c

3877

struct block_allocator *allocator =

drivers/md/dm-vdo/slab-depot.c

3881

result = make_slab(slab_origin, allocator, depot->new_slab_count,

drivers/md/dm-vdo/slab-depot.c

390

.fullness_hint = compute_fullness_hint(allocator->depot, free_blocks),

drivers/md/dm-vdo/slab-depot.c

3933

vdo_is_read_only(journal->slab->allocator->depot->vdo))

drivers/md/dm-vdo/slab-depot.c

4006

static int initialize_slab_scrubber(struct block_allocator *allocator)

drivers/md/dm-vdo/slab-depot.c

4008

struct slab_scrubber *scrubber = &allocator->scrubber;

drivers/md/dm-vdo/slab-depot.c

4010

allocator->depot->slab_config.slab_journal_blocks;

drivers/md/dm-vdo/slab-depot.c

4019

result = allocate_vio_components(allocator->completion.vdo,

drivers/md/dm-vdo/slab-depot.c

4022

allocator, slab_journal_size,

drivers/md/dm-vdo/slab-depot.c

4042

static int __must_check initialize_slab_summary_block(struct block_allocator *allocator,

drivers/md/dm-vdo/slab-depot.c

4045

struct slab_summary_block *block = &allocator->summary_blocks[index];

drivers/md/dm-vdo/slab-depot.c

4052

result = allocate_vio_components(allocator->depot->vdo, VIO_TYPE_SLAB_SUMMARY,

drivers/md/dm-vdo/slab-depot.c

4058

block->allocator = allocator;

drivers/md/dm-vdo/slab-depot.c

4059

block->entries = &allocator->summary_entries[VDO_SLAB_SUMMARY_ENTRIES_PER_BLOCK * index];

drivers/md/dm-vdo/slab-depot.c

4069

struct block_allocator *allocator = &depot->allocators[zone];

drivers/md/dm-vdo/slab-depot.c

4075

*allocator = (struct block_allocator) {

drivers/md/dm-vdo/slab-depot.c

4082

INIT_LIST_HEAD(&allocator->dirty_slab_journals);

drivers/md/dm-vdo/slab-depot.c

4083

vdo_set_admin_state_code(&allocator->state, VDO_ADMIN_STATE_NORMAL_OPERATION);

drivers/md/dm-vdo/slab-depot.c

4084

result = vdo_register_read_only_listener(vdo, allocator,

drivers/md/dm-vdo/slab-depot.c

4086

allocator->thread_id);

drivers/md/dm-vdo/slab-depot.c

4090

vdo_initialize_completion(&allocator->completion, vdo, VDO_BLOCK_ALLOCATOR_COMPLETION);

drivers/md/dm-vdo/slab-depot.c

4091

result = make_vio_pool(vdo, BLOCK_ALLOCATOR_VIO_POOL_SIZE, 1, allocator->thread_id,

drivers/md/dm-vdo/slab-depot.c

4093

allocator, &allocator->vio_pool);

drivers/md/dm-vdo/slab-depot.c

4101

allocator->refcount_blocks_per_big_vio = refcount_blocks_per_vio;

drivers/md/dm-vdo/slab-depot.c

4103

allocator->refcount_blocks_per_big_vio, allocator->thread_id,

drivers/md/dm-vdo/slab-depot.c

4105

NULL, &allocator->refcount_big_vio_pool);

drivers/md/dm-vdo/slab-depot.c

4109

result = initialize_slab_scrubber(allocator);

drivers/md/dm-vdo/slab-depot.c

4113

result = vdo_make_priority_table(max_priority, &allocator->prioritized_slabs);

drivers/md/dm-vdo/slab-depot.c

4119

&allocator->summary_blocks);

drivers/md/dm-vdo/slab-depot.c

4123

vdo_set_admin_state_code(&allocator->summary_state,

drivers/md/dm-vdo/slab-depot.c

4125

allocator->summary_entries = depot->summary_entries + (MAX_VDO_SLABS * zone);

drivers/md/dm-vdo/slab-depot.c

4129

result = initialize_slab_summary_block(allocator, i);

drivers/md/dm-vdo/slab-depot.c

4148

allocator->unopened_slab_priority = (1 + ilog2((max_free_blocks * 3) / 4));

drivers/md/dm-vdo/slab-depot.c

4224

register_slab_with_allocator(slab->allocator, slab);

drivers/md/dm-vdo/slab-depot.c

4289

static void uninitialize_allocator_summary(struct block_allocator *allocator)

drivers/md/dm-vdo/slab-depot.c

4293

if (allocator->summary_blocks == NULL)

drivers/md/dm-vdo/slab-depot.c

4297

free_vio_components(&allocator->summary_blocks[i].vio);

drivers/md/dm-vdo/slab-depot.c

4298

vdo_free(vdo_forget(allocator->summary_blocks[i].outgoing_entries));

drivers/md/dm-vdo/slab-depot.c

4301

vdo_free(vdo_forget(allocator->summary_blocks));

drivers/md/dm-vdo/slab-depot.c

4318

struct block_allocator *allocator = &depot->allocators[zone];

drivers/md/dm-vdo/slab-depot.c

4320

if (allocator->eraser != NULL)

drivers/md/dm-vdo/slab-depot.c

4321

dm_kcopyd_client_destroy(vdo_forget(allocator->eraser));

drivers/md/dm-vdo/slab-depot.c

4323

uninitialize_allocator_summary(allocator);

drivers/md/dm-vdo/slab-depot.c

4324

uninitialize_scrubber_vio(&allocator->scrubber);

drivers/md/dm-vdo/slab-depot.c

4325

free_vio_pool(vdo_forget(allocator->vio_pool));

drivers/md/dm-vdo/slab-depot.c

4326

free_vio_pool(vdo_forget(allocator->refcount_big_vio_pool));

drivers/md/dm-vdo/slab-depot.c

4327

vdo_free_priority_table(vdo_forget(allocator->prioritized_slabs));

drivers/md/dm-vdo/slab-depot.c

441

journal->slab->allocator->thread_id);

drivers/md/dm-vdo/slab-depot.c

4700

struct block_allocator *allocator = &depot->allocators[zone_number];

drivers/md/dm-vdo/slab-depot.c

4703

result = vdo_prepare_slabs_for_allocation(allocator);

drivers/md/dm-vdo/slab-depot.c

4709

scrub_slabs(allocator, parent);

drivers/md/dm-vdo/slab-depot.c

476

vdo_is_read_only(journal->slab->allocator->depot->vdo)) {

drivers/md/dm-vdo/slab-depot.c

4818

struct block_allocator *allocator = &depot->allocators[zone_number];

drivers/md/dm-vdo/slab-depot.c

4824

if (slab->allocator == allocator)

drivers/md/dm-vdo/slab-depot.c

4825

register_slab_with_allocator(allocator, slab);

drivers/md/dm-vdo/slab-depot.c

4850

static void stop_scrubbing(struct block_allocator *allocator)

drivers/md/dm-vdo/slab-depot.c

4852

struct slab_scrubber *scrubber = &allocator->scrubber;

drivers/md/dm-vdo/slab-depot.c

4855

vdo_finish_completion(&allocator->completion);

drivers/md/dm-vdo/slab-depot.c

4859

&allocator->completion, NULL);

drivers/md/dm-vdo/slab-depot.c

4872

struct block_allocator *allocator = vdo_as_block_allocator(completion);

drivers/md/dm-vdo/slab-depot.c

4874

vdo_prepare_completion_for_requeue(&allocator->completion, do_drain_step,

drivers/md/dm-vdo/slab-depot.c

4875

handle_operation_error, allocator->thread_id,

drivers/md/dm-vdo/slab-depot.c

4877

switch (++allocator->drain_step) {

drivers/md/dm-vdo/slab-depot.c

4879

stop_scrubbing(allocator);

drivers/md/dm-vdo/slab-depot.c

4883

apply_to_slabs(allocator, do_drain_step);

drivers/md/dm-vdo/slab-depot.c

4887

vdo_start_draining(&allocator->summary_state,

drivers/md/dm-vdo/slab-depot.c

4888

vdo_get_admin_state_code(&allocator->state),

drivers/md/dm-vdo/slab-depot.c

4893

VDO_ASSERT_LOG_ONLY(!is_vio_pool_busy(allocator->vio_pool),

drivers/md/dm-vdo/slab-depot.c

4895

vdo_finish_draining_with_result(&allocator->state, completion->result);

drivers/md/dm-vdo/slab-depot.c

4899

vdo_finish_draining_with_result(&allocator->state, UDS_BAD_STATE);

drivers/md/dm-vdo/slab-depot.c

4906

struct block_allocator *allocator =

drivers/md/dm-vdo/slab-depot.c

4909

allocator->drain_step = VDO_DRAIN_ALLOCATOR_START;

drivers/md/dm-vdo/slab-depot.c

4910

do_drain_step(&allocator->completion);

drivers/md/dm-vdo/slab-depot.c

4950

static void resume_scrubbing(struct block_allocator *allocator)

drivers/md/dm-vdo/slab-depot.c

4953

struct slab_scrubber *scrubber = &allocator->scrubber;

drivers/md/dm-vdo/slab-depot.c

4956

vdo_finish_completion(&allocator->completion);

drivers/md/dm-vdo/slab-depot.c

4962

vdo_fail_completion(&allocator->completion, result);

drivers/md/dm-vdo/slab-depot.c

4967

vdo_finish_completion(&allocator->completion);

drivers/md/dm-vdo/slab-depot.c

4972

struct block_allocator *allocator = vdo_as_block_allocator(completion);

drivers/md/dm-vdo/slab-depot.c

4974

vdo_prepare_completion_for_requeue(&allocator->completion, do_resume_step,

drivers/md/dm-vdo/slab-depot.c

4976

allocator->thread_id, NULL);

drivers/md/dm-vdo/slab-depot.c

4977

switch (--allocator->drain_step) {

drivers/md/dm-vdo/slab-depot.c

4980

vdo_resume_if_quiescent(&allocator->summary_state));

drivers/md/dm-vdo/slab-depot.c

4984

apply_to_slabs(allocator, do_resume_step);

drivers/md/dm-vdo/slab-depot.c

4988

resume_scrubbing(allocator);

drivers/md/dm-vdo/slab-depot.c

4992

vdo_finish_resuming_with_result(&allocator->state, completion->result);

drivers/md/dm-vdo/slab-depot.c

4996

vdo_finish_resuming_with_result(&allocator->state, UDS_BAD_STATE);

drivers/md/dm-vdo/slab-depot.c

5003

struct block_allocator *allocator =

drivers/md/dm-vdo/slab-depot.c

5006

allocator->drain_step = VDO_DRAIN_ALLOCATOR_STEP_FINISHED;

drivers/md/dm-vdo/slab-depot.c

5007

do_resume_step(&allocator->completion);

drivers/md/dm-vdo/slab-depot.c

5095

const struct block_allocator *allocator = &depot->allocators[zone];

drivers/md/dm-vdo/slab-depot.c

5096

const struct block_allocator_statistics *stats = &allocator->statistics;

drivers/md/dm-vdo/slab-depot.c

5098

totals.slab_count += allocator->slab_count;

drivers/md/dm-vdo/slab-depot.c

510

acquire_vio_from_pool(journal->slab->allocator->vio_pool,

drivers/md/dm-vdo/slab-depot.c

5175

stats->allocator = get_block_allocator_statistics(depot);

drivers/md/dm-vdo/slab-depot.c

577

vdo_enter_read_only_mode(journal->slab->allocator->depot->vdo, result);

drivers/md/dm-vdo/slab-depot.c

595

zone_count_t zone_number = journal->slab->allocator->zone_number;

drivers/md/dm-vdo/slab-depot.c

629

vdo_is_read_only(journal->slab->allocator->depot->vdo) ||

drivers/md/dm-vdo/slab-depot.c

636

u8 hint = slab->allocator->summary_entries[slab->slab_number].fullness_hint;

drivers/md/dm-vdo/slab-depot.c

638

free_block_count = ((block_count_t) hint) << slab->allocator->depot->hint_shift;

drivers/md/dm-vdo/slab-depot.c

709

vdo_enter_read_only_mode(journal->slab->allocator->depot->vdo, result);

drivers/md/dm-vdo/slab-depot.c

734

continue_vio_after_io(vio, complete_write, journal->slab->allocator->thread_id);

drivers/md/dm-vdo/slab-depot.c

793

(vdo_is_read_only(journal->slab->allocator->depot->vdo) ?

drivers/md/dm-vdo/slab-depot.c

815

if (vdo_is_read_only(journal->slab->allocator->depot->vdo) ||

drivers/md/dm-vdo/slab-depot.c

834

acquire_vio_from_pool(journal->slab->allocator->vio_pool,

drivers/md/dm-vdo/slab-depot.c

918

vdo_enter_read_only_mode(journal->slab->allocator->depot->vdo, result);

drivers/md/dm-vdo/slab-depot.c

927

vdo_enter_read_only_mode(journal->slab->allocator->depot->vdo,

drivers/md/dm-vdo/slab-depot.h

219

struct block_allocator *allocator;

drivers/md/dm-vdo/slab-depot.h

351

struct block_allocator *allocator;

drivers/md/dm-vdo/slab-depot.h

538

int __must_check vdo_allocate_block(struct block_allocator *allocator,

drivers/md/dm-vdo/slab-depot.h

541

int vdo_enqueue_clean_slab_waiter(struct block_allocator *allocator,

drivers/md/dm-vdo/slab-depot.h

547

int __must_check vdo_release_block_reference(struct block_allocator *allocator,

drivers/md/dm-vdo/slab-depot.h

552

void vdo_dump_block_allocator(const struct block_allocator *allocator);

drivers/md/dm-vdo/statistics.h

228

struct block_allocator_statistics allocator;

drivers/md/dm-vdo/vdo.c

1722

*zone_ptr = &vdo->physical_zones->zones[slab->allocator->zone_number];

drivers/media/test-drivers/vimc/vimc-core.c

20

module_param_named(allocator, vimc_allocator, uint, 0444);

drivers/media/test-drivers/vimc/vimc-core.c

21

MODULE_PARM_DESC(allocator, " memory allocator selection, default is 0.\n"

drivers/net/ethernet/freescale/fec_main.c

3818

void *allocator;

drivers/net/ethernet/freescale/fec_main.c

3827

allocator = rxq->xsk_pool ? NULL : rxq->page_pool;

drivers/net/ethernet/freescale/fec_main.c

3829

err = xdp_rxq_info_reg_mem_model(&rxq->xdp_rxq, type, allocator);

drivers/net/ethernet/mellanox/mlx4/alloc.c

216

struct mlx4_zone_allocator *allocator;

drivers/net/ethernet/mellanox/mlx4/alloc.c

264

zone->allocator = zone_alloc;

drivers/net/ethernet/mellanox/mlx4/alloc.c

287

struct mlx4_zone_allocator *zone_alloc = entry->allocator;

drivers/net/ethernet/mellanox/mlx4/alloc.c

341

struct mlx4_zone_allocator *zone_alloc = zone->allocator;

include/net/xdp.h

495

enum xdp_mem_type type, void *allocator);

include/net/xdp.h

498

enum xdp_mem_type type, void *allocator);

include/net/xdp_priv.h

12

void *allocator;

include/trace/events/xdp.h

314

__field(const void *, allocator)

include/trace/events/xdp.h

321

__entry->allocator = xa->allocator;

include/trace/events/xdp.h

327

__entry->allocator

include/trace/events/xdp.h

342

__field(const void *, allocator)

include/trace/events/xdp.h

351

__entry->allocator = xa->allocator;

include/trace/events/xdp.h

360

__entry->allocator,

lib/tests/fortify_kunit.c

209

#define DEFINE_ALLOC_SIZE_TEST_PAIR(allocator) \

lib/tests/fortify_kunit.c

210

static void fortify_test_alloc_size_##allocator##_const(struct kunit *test) \

lib/tests/fortify_kunit.c

212

CONST_TEST_BODY(TEST_##allocator); \

lib/tests/fortify_kunit.c

214

static void fortify_test_alloc_size_##allocator##_dynamic(struct kunit *test) \

lib/tests/fortify_kunit.c

216

DYNAMIC_TEST_BODY(TEST_##allocator); \

lib/zstd/decompress/zstd_ddict.c

170

ZSTD_customMem const allocator = { NULL, NULL, NULL };

lib/zstd/decompress/zstd_ddict.c

171

return ZSTD_createDDict_advanced(dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto, allocator);

lib/zstd/decompress/zstd_ddict.c

180

ZSTD_customMem const allocator = { NULL, NULL, NULL };

lib/zstd/decompress/zstd_ddict.c

181

return ZSTD_createDDict_advanced(dictBuffer, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto, allocator);

net/core/xdp.c

105

if (xa->allocator == allocator)

net/core/xdp.c

273

void *allocator)

net/core/xdp.c

285

if (!allocator) {

net/core/xdp.c

312

xdp_alloc->allocator = allocator;

net/core/xdp.c

324

page_pool_use_xdp_mem(allocator, mem_allocator_disconnect, mem);

net/core/xdp.c

336

enum xdp_mem_type type, void *allocator)

net/core/xdp.c

340

xdp_alloc = __xdp_reg_mem_model(mem, type, allocator);

net/core/xdp.c

348

enum xdp_mem_type type, void *allocator)

net/core/xdp.c

357

xdp_alloc = __xdp_reg_mem_model(&xdp_rxq->mem, type, allocator);

net/core/xdp.c

361

if (type == MEM_TYPE_XSK_BUFF_POOL && allocator)

net/core/xdp.c

362

xsk_pool_set_rxq_info(allocator, xdp_rxq);

net/core/xdp.c

93

static void mem_allocator_disconnect(void *allocator)

tools/mm/page_owner_sort.c

170

return l1->allocator - l2->allocator;

tools/mm/page_owner_sort.c

39

int allocator;

tools/mm/page_owner_sort.c

413

int allocator = 0;

tools/mm/page_owner_sort.c

416

allocator |= ALLOCATOR_CMA;

tools/mm/page_owner_sort.c

418

allocator |= ALLOCATOR_SLAB;

tools/mm/page_owner_sort.c

430

allocator |= ALLOCATOR_VMALLOC;

tools/mm/page_owner_sort.c

432

if (allocator == 0)

tools/mm/page_owner_sort.c

433

allocator = ALLOCATOR_OTHERS;

tools/mm/page_owner_sort.c

434

return allocator;

tools/mm/page_owner_sort.c

501

list[list_size].allocator = get_allocator(buf, ext_buf);

tools/mm/page_owner_sort.c

622

static void print_allocator(FILE *out, int allocator)

tools/mm/page_owner_sort.c

625

if (allocator & ALLOCATOR_CMA)

tools/mm/page_owner_sort.c

627

if (allocator & ALLOCATOR_SLAB)

tools/mm/page_owner_sort.c

629

if (allocator & ALLOCATOR_VMALLOC)

tools/mm/page_owner_sort.c

631

if (allocator & ALLOCATOR_OTHERS)

tools/mm/page_owner_sort.c

852

print_allocator(fout, list[i].allocator);

tools/mm/page_owner_sort.c

866

print_allocator(fout, list[i].allocator);

tools/testing/selftests/ublk/kublk.h

241

struct allocator commit_buf_alloc;

tools/testing/selftests/ublk/utils.h

30

static inline int allocator_init(struct allocator *a, unsigned size)

tools/testing/selftests/ublk/utils.h

40

static inline void allocator_deinit(struct allocator *a)

tools/testing/selftests/ublk/utils.h

47

static inline int allocator_get(struct allocator *a)

tools/testing/selftests/ublk/utils.h

63

static inline void allocator_put(struct allocator *a, int i)

tools/testing/selftests/ublk/utils.h

71

static inline int allocator_get_val(struct allocator *a, int i)

tools/testing/selftests/vfio/lib/include/libvfio/iova_allocator.h

19

void iova_allocator_cleanup(struct iova_allocator *allocator);

tools/testing/selftests/vfio/lib/include/libvfio/iova_allocator.h

20

iova_t iova_allocator_alloc(struct iova_allocator *allocator, size_t size);

tools/testing/selftests/vfio/lib/iova_allocator.c

25

struct iova_allocator *allocator;

tools/testing/selftests/vfio/lib/iova_allocator.c

32

allocator = malloc(sizeof(*allocator));

tools/testing/selftests/vfio/lib/iova_allocator.c

33

VFIO_ASSERT_NOT_NULL(allocator);

tools/testing/selftests/vfio/lib/iova_allocator.c

35

*allocator = (struct iova_allocator){

tools/testing/selftests/vfio/lib/iova_allocator.c

42

return allocator;

tools/testing/selftests/vfio/lib/iova_allocator.c

45

void iova_allocator_cleanup(struct iova_allocator *allocator)

tools/testing/selftests/vfio/lib/iova_allocator.c

47

free(allocator->ranges);

tools/testing/selftests/vfio/lib/iova_allocator.c

48

free(allocator);

tools/testing/selftests/vfio/lib/iova_allocator.c

51

iova_t iova_allocator_alloc(struct iova_allocator *allocator, size_t size)

tools/testing/selftests/vfio/lib/iova_allocator.c

60

VFIO_ASSERT_LT(allocator->range_idx, allocator->nranges,

tools/testing/selftests/vfio/lib/iova_allocator.c

63

range = &allocator->ranges[allocator->range_idx];

tools/testing/selftests/vfio/lib/iova_allocator.c

64

iova = range->start + allocator->range_offset;

tools/testing/selftests/vfio/lib/iova_allocator.c

80

allocator->range_idx++;

tools/testing/selftests/vfio/lib/iova_allocator.c

81

allocator->range_offset = 0;

tools/testing/selftests/vfio/lib/iova_allocator.c

83

allocator->range_offset = last - range->start + 1;

tools/testing/selftests/vfio/lib/iova_allocator.c

89

allocator->range_idx++;

tools/testing/selftests/vfio/lib/iova_allocator.c

90

allocator->range_offset = 0;