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

343

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

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

490

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

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

560

result = vdo_enqueue_clean_slab_waiter(zone->allocator,

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

632

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

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

642

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

2504

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

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

2511

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

2527

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

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

2557

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

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

2568

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

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

2583

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

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

2585

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

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

2600

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

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

2605

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

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

2631

struct block_allocator *allocator = slab->allocator;

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

2638

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

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

2642

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

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

2645

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

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

2647

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

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

2662

WRITE_ONCE(allocator->allocated_blocks,

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

2663

allocator->allocated_blocks - free_blocks);

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

2665

WRITE_ONCE(allocator->statistics.slabs_opened,

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

2666

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

2670

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

2756

struct block_allocator *allocator =

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

2765

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

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

2768

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

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

2786

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

2936

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

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

2976

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

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

2988

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

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

3003

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

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

3046

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

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

3056

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

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

3058

struct slab_scrubber *scrubber = &allocator->scrubber;

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

3068

vdo_is_priority_table_empty(allocator->prioritized_slabs) &&

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

3083

static void register_slab_with_allocator(struct block_allocator *allocator,

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

3086

allocator->slab_count++;

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

3087

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

3115

static struct slab_iterator get_slab_iterator(const struct block_allocator *allocator)

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

3117

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

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

3118

allocator->zone_number,

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

3119

allocator->depot->zone_count);

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

3166

struct block_allocator *allocator = listener;

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

3169

assert_on_allocator_thread(allocator->thread_id, __func__);

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

3170

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

3253

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

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

3254

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

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

3257

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

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

3258

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

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

3261

slab->allocator->open_slab = slab;

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

3270

int vdo_allocate_block(struct block_allocator *allocator,

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

3275

if (allocator->open_slab != NULL) {

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

3277

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

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

3282

prioritize_slab(allocator->open_slab);

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

3286

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

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

3293

return allocate_slab_block(allocator->open_slab, block_number_ptr);

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

3304

int vdo_enqueue_clean_slab_waiter(struct block_allocator *allocator,

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

3307

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

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

3310

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

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

3313

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

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

3346

int vdo_release_block_reference(struct block_allocator *allocator,

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

3362

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

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

3396

struct block_allocator *allocator = vdo_as_block_allocator(completion);

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

3397

struct slab_actor *actor = &allocator->slab_actor;

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

3410

struct block_allocator *allocator = vdo_as_block_allocator(completion);

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

3412

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

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

3413

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

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

3418

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

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

3422

vdo_prepare_completion(&allocator->completion, slab_action_callback,

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

3423

handle_operation_error, allocator->thread_id, NULL);

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

3424

allocator->completion.requeue = false;

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

3430

allocator->open_slab = NULL;

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

3433

allocator->slab_actor = (struct slab_actor) {

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

3438

iterator = get_slab_iterator(allocator);

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

3441

vdo_get_admin_state_code(&allocator->state);

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

3445

allocator->slab_actor.slab_action_count++;

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

3447

&allocator->completion,

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

3451

slab_action_callback(&allocator->completion);

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

3456

struct block_allocator *allocator = vdo_as_block_allocator(completion);

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

3458

vdo_get_admin_state_code(&allocator->state);

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

if (allocator->eraser != NULL)

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

3461

dm_kcopyd_client_destroy(vdo_forget(allocator->eraser));

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

3465

vdo_get_current_action_context(allocator->depot->action_manager);

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

3467

vdo_replay_into_slab_journals(allocator, context);

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

3471

vdo_finish_loading(&allocator->state);

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

3474

static void erase_next_slab_journal(struct block_allocator *allocator);

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

3478

struct block_allocator *allocator = context;

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

3482

vdo_fail_completion(&allocator->completion, result);

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

3486

erase_next_slab_journal(allocator);

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

3490

static void erase_next_slab_journal(struct block_allocator *allocator)

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

3495

struct slab_depot *depot = allocator->depot;

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

3498

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

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

3499

vdo_finish_completion(&allocator->completion);

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

3503

slab = next_slab(&allocator->slabs_to_erase);

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

3510

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

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

3516

struct block_allocator *allocator =

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

3525

vdo_prepare_completion_for_requeue(&allocator->completion,

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

3528

allocator->thread_id, NULL);

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

3529

allocator->eraser = dm_kcopyd_client_create(NULL);

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

3530

if (IS_ERR(allocator->eraser)) {

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

3531

vdo_fail_completion(&allocator->completion,

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

3532

PTR_ERR(allocator->eraser));

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

3533

allocator->eraser = NULL;

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

3536

allocator->slabs_to_erase = get_slab_iterator(allocator);

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

3538

erase_next_slab_journal(allocator);

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

3542

apply_to_slabs(allocator, finish_loading_allocator);

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

3552

struct block_allocator *allocator = vdo_as_block_allocator(completion);

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

3554

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

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

3557

static int get_slab_statuses(struct block_allocator *allocator,

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

3562

struct slab_iterator iterator = get_slab_iterator(allocator);

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

3564

result = vdo_allocate(allocator->slab_count, __func__, &statuses);

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

3575

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

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

3576

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

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

3584

static int __must_check vdo_prepare_slabs_for_allocation(struct block_allocator *allocator)

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

3590

struct slab_depot *depot = allocator->depot;

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

3592

WRITE_ONCE(allocator->allocated_blocks,

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

3593

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

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

3594

result = get_slab_statuses(allocator, &slab_statuses);

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

3601

.nr = allocator->slab_count,

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

3602

.size = allocator->slab_count,

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

3616

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

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

3652

void vdo_dump_block_allocator(const struct block_allocator *allocator)

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

3655

struct slab_iterator iterator = get_slab_iterator(allocator);

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

3656

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

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

3658

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

3736

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

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

3755

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

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

3756

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

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

3773

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

3791

struct block_allocator *allocator,

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

3795

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

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

3804

.allocator = allocator,

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

385

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

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

3872

struct block_allocator *allocator =

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

3876

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

3928

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

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

4001

static int initialize_slab_scrubber(struct block_allocator *allocator)

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

4003

struct slab_scrubber *scrubber = &allocator->scrubber;

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

4005

allocator->depot->slab_config.slab_journal_blocks;

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

4013

result = allocate_vio_components(allocator->completion.vdo,

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

4016

allocator, slab_journal_size,

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

4036

static int __must_check initialize_slab_summary_block(struct block_allocator *allocator,

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

4039

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

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

4046

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

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

4052

block->allocator = allocator;

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

4053

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

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

4063

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

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

4069

*allocator = (struct block_allocator) {

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

4076

INIT_LIST_HEAD(&allocator->dirty_slab_journals);

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

4077

vdo_set_admin_state_code(&allocator->state, VDO_ADMIN_STATE_NORMAL_OPERATION);

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

4078

result = vdo_register_read_only_listener(vdo, allocator,

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

4080

allocator->thread_id);

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

4084

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

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

4085

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

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

4087

allocator, &allocator->vio_pool);

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

4095

allocator->refcount_blocks_per_big_vio = refcount_blocks_per_vio;

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

4097

allocator->refcount_blocks_per_big_vio, allocator->thread_id,

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

4099

NULL, &allocator->refcount_big_vio_pool);

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

4103

result = initialize_slab_scrubber(allocator);

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

4107

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

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

4112

&allocator->summary_blocks);

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

4116

vdo_set_admin_state_code(&allocator->summary_state,

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

4118

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

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

4122

result = initialize_slab_summary_block(allocator, i);

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

4141

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

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

4216

register_slab_with_allocator(slab->allocator, slab);

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

4284

static void uninitialize_allocator_summary(struct block_allocator *allocator)

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

4288

if (allocator->summary_blocks == NULL)

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

4292

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

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

4293

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

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

4296

vdo_free(vdo_forget(allocator->summary_blocks));

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

4313

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

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

4315

if (allocator->eraser != NULL)

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

4316

dm_kcopyd_client_destroy(vdo_forget(allocator->eraser));

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

4318

uninitialize_allocator_summary(allocator);

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

4319

uninitialize_scrubber_vio(&allocator->scrubber);

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

4320

free_vio_pool(vdo_forget(allocator->vio_pool));

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

4321

free_vio_pool(vdo_forget(allocator->refcount_big_vio_pool));

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

4322

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

4695

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

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

4698

result = vdo_prepare_slabs_for_allocation(allocator);

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

4704

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

4813

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

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

4819

if (slab->allocator == allocator)

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

4820

register_slab_with_allocator(allocator, slab);

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

4845

static void stop_scrubbing(struct block_allocator *allocator)

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

4847

struct slab_scrubber *scrubber = &allocator->scrubber;

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

4850

vdo_finish_completion(&allocator->completion);

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

4854

&allocator->completion, NULL);

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

4867

struct block_allocator *allocator = vdo_as_block_allocator(completion);

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

4869

vdo_prepare_completion_for_requeue(&allocator->completion, do_drain_step,

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

4870

handle_operation_error, allocator->thread_id,

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

4872

switch (++allocator->drain_step) {

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

4874

stop_scrubbing(allocator);

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

4878

apply_to_slabs(allocator, do_drain_step);

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

4882

vdo_start_draining(&allocator->summary_state,

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

4883

vdo_get_admin_state_code(&allocator->state),

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

4888

VDO_ASSERT_LOG_ONLY(!is_vio_pool_busy(allocator->vio_pool),

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

4890

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

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

4894

vdo_finish_draining_with_result(&allocator->state, UDS_BAD_STATE);

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

4901

struct block_allocator *allocator =

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

4904

allocator->drain_step = VDO_DRAIN_ALLOCATOR_START;

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

4905

do_drain_step(&allocator->completion);

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

4945

static void resume_scrubbing(struct block_allocator *allocator)

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

4948

struct slab_scrubber *scrubber = &allocator->scrubber;

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

4951

vdo_finish_completion(&allocator->completion);

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

4957

vdo_fail_completion(&allocator->completion, result);

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

4962

vdo_finish_completion(&allocator->completion);

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

4967

struct block_allocator *allocator = vdo_as_block_allocator(completion);

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

4969

vdo_prepare_completion_for_requeue(&allocator->completion, do_resume_step,

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

4971

allocator->thread_id, NULL);

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

4972

switch (--allocator->drain_step) {

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

4975

vdo_resume_if_quiescent(&allocator->summary_state));

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

4979

apply_to_slabs(allocator, do_resume_step);

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

4983

resume_scrubbing(allocator);

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

4987

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

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

4991

vdo_finish_resuming_with_result(&allocator->state, UDS_BAD_STATE);

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

4998

struct block_allocator *allocator =

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

5001

allocator->drain_step = VDO_DRAIN_ALLOCATOR_STEP_FINISHED;

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

5002

do_resume_step(&allocator->completion);

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

5090

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

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

5091

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

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

5093

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

5170

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

1855

*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

247

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;