block/fops.c

121

struct task_struct *waiter;

block/fops.c

160

struct task_struct *waiter = dio->waiter;

block/fops.c

162

WRITE_ONCE(dio->waiter, NULL);

block/fops.c

163

blk_wake_io_task(waiter);

block/fops.c

199

dio->waiter = current;

block/fops.c

272

if (!READ_ONCE(dio->waiter))

drivers/gpu/drm/amd/amdkfd/kfd_events.c

264

struct kfd_event_waiter *waiter;

drivers/gpu/drm/amd/amdkfd/kfd_events.c

268

list_for_each_entry(waiter, &ev->wq.head, wait.entry)

drivers/gpu/drm/amd/amdkfd/kfd_events.c

269

WRITE_ONCE(waiter->event, NULL);

drivers/gpu/drm/amd/amdkfd/kfd_events.c

632

struct kfd_event_waiter *waiter;

drivers/gpu/drm/amd/amdkfd/kfd_events.c

646

list_for_each_entry(waiter, &ev->wq.head, wait.entry)

drivers/gpu/drm/amd/amdkfd/kfd_events.c

647

WRITE_ONCE(waiter->activated, true);

drivers/gpu/drm/amd/amdkfd/kfd_events.c

805

struct kfd_event_waiter *waiter,

drivers/gpu/drm/amd/amdkfd/kfd_events.c

814

waiter->event = ev;

drivers/gpu/drm/amd/amdkfd/kfd_events.c

815

waiter->activated = ev->signaled;

drivers/gpu/drm/amd/amdkfd/kfd_events.c

819

if (waiter->event->type == KFD_EVENT_TYPE_SIGNAL &&

drivers/gpu/drm/amd/amdkfd/kfd_events.c

821

waiter->event_age_enabled = true;

drivers/gpu/drm/amd/amdkfd/kfd_events.c

823

waiter->activated = true;

drivers/gpu/drm/amd/amdkfd/kfd_events.c

826

if (!waiter->activated)

drivers/gpu/drm/amd/amdkfd/kfd_events.c

827

add_wait_queue(&ev->wq, &waiter->wait);

drivers/gpu/drm/amd/amdkfd/kfd_events.c

875

struct kfd_event_waiter *waiter;

drivers/gpu/drm/amd/amdkfd/kfd_events.c

880

waiter = &event_waiters[i];

drivers/gpu/drm/amd/amdkfd/kfd_events.c

881

event = waiter->event;

drivers/gpu/drm/amd/amdkfd/kfd_events.c

884

if (waiter->activated) {

drivers/gpu/drm/amd/amdkfd/kfd_events.c

894

waiter->event_age_enabled) {

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

1091

container_of(p->waiter, typeof(*w), sched);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

2071

container_of(p->waiter, typeof(*w), sched);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

2172

container_of(p->waiter, typeof(*w), sched);

drivers/gpu/drm/i915/i915_scheduler.c

340

dep->waiter = node;

drivers/gpu/drm/i915/i915_scheduler_types.h

74

struct i915_sched_node *waiter;

drivers/md/dm-vdo/admin-state.c

206

if (state->waiter != NULL)

drivers/md/dm-vdo/admin-state.c

207

vdo_set_completion_result(state->waiter, result);

drivers/md/dm-vdo/admin-state.c

211

if (state->waiter != NULL)

drivers/md/dm-vdo/admin-state.c

212

vdo_launch_completion(vdo_forget(state->waiter));

drivers/md/dm-vdo/admin-state.c

229

struct vdo_completion *waiter,

drivers/md/dm-vdo/admin-state.c

240

} else if (state->waiter != NULL) {

drivers/md/dm-vdo/admin-state.c

245

state->waiter = waiter;

drivers/md/dm-vdo/admin-state.c

259

if (waiter != NULL)

drivers/md/dm-vdo/admin-state.c

260

vdo_continue_completion(waiter, result);

drivers/md/dm-vdo/admin-state.c

276

struct vdo_completion *waiter,

drivers/md/dm-vdo/admin-state.c

279

return (begin_operation(state, operation, waiter, initiator) == VDO_SUCCESS);

drivers/md/dm-vdo/admin-state.c

294

struct vdo_completion *waiter)

drivers/md/dm-vdo/admin-state.c

303

if (waiter != NULL)

drivers/md/dm-vdo/admin-state.c

304

vdo_continue_completion(waiter, result);

drivers/md/dm-vdo/admin-state.c

317

struct vdo_completion *waiter)

drivers/md/dm-vdo/admin-state.c

319

return check_code(operation->draining, operation, "drain operation", waiter);

drivers/md/dm-vdo/admin-state.c

333

struct vdo_completion *waiter, vdo_admin_initiator_fn initiator)

drivers/md/dm-vdo/admin-state.c

337

if (!assert_vdo_drain_operation(operation, waiter))

drivers/md/dm-vdo/admin-state.c

341

vdo_launch_completion(waiter);

drivers/md/dm-vdo/admin-state.c

348

vdo_continue_completion(waiter, VDO_INVALID_ADMIN_STATE);

drivers/md/dm-vdo/admin-state.c

352

return start_operation(state, operation, waiter, initiator);

drivers/md/dm-vdo/admin-state.c

386

struct vdo_completion *waiter)

drivers/md/dm-vdo/admin-state.c

388

return check_code(operation->loading, operation, "load operation", waiter);

drivers/md/dm-vdo/admin-state.c

402

struct vdo_completion *waiter, vdo_admin_initiator_fn initiator)

drivers/md/dm-vdo/admin-state.c

404

return (vdo_assert_load_operation(operation, waiter) &&

drivers/md/dm-vdo/admin-state.c

405

start_operation(state, operation, waiter, initiator));

drivers/md/dm-vdo/admin-state.c

439

struct vdo_completion *waiter)

drivers/md/dm-vdo/admin-state.c

442

"resume operation", waiter);

drivers/md/dm-vdo/admin-state.c

456

struct vdo_completion *waiter, vdo_admin_initiator_fn initiator)

drivers/md/dm-vdo/admin-state.c

458

return (assert_vdo_resume_operation(operation, waiter) &&

drivers/md/dm-vdo/admin-state.c

459

start_operation(state, operation, waiter, initiator));

drivers/md/dm-vdo/admin-state.c

525

struct vdo_completion *waiter,

drivers/md/dm-vdo/admin-state.c

528

return (check_code(operation->operating, operation, "operation", waiter) ?

drivers/md/dm-vdo/admin-state.c

529

begin_operation(state, operation, waiter, initiator) :

drivers/md/dm-vdo/admin-state.h

140

struct vdo_completion *waiter);

drivers/md/dm-vdo/admin-state.h

144

struct vdo_completion *waiter, vdo_admin_initiator_fn initiator);

drivers/md/dm-vdo/admin-state.h

152

struct vdo_completion *waiter, vdo_admin_initiator_fn initiator);

drivers/md/dm-vdo/admin-state.h

162

struct vdo_completion *waiter, vdo_admin_initiator_fn initiator);

drivers/md/dm-vdo/admin-state.h

173

struct vdo_completion *waiter,

drivers/md/dm-vdo/admin-state.h

57

struct vdo_completion *waiter;

drivers/md/dm-vdo/block-map.c

1173

VDO_ASSERT_LOG_ONLY((page_completion->waiter.next_waiter == NULL),

drivers/md/dm-vdo/block-map.c

1199

vdo_waitq_enqueue_waiter(&info->waiting, &vdo_page_comp->waiter);

drivers/md/dm-vdo/block-map.c

1233

VDO_ASSERT_LOG_ONLY((page_completion->waiter.next_waiter == NULL),

drivers/md/dm-vdo/block-map.c

1265

vdo_waitq_enqueue_waiter(&info->waiting, &page_completion->waiter);

drivers/md/dm-vdo/block-map.c

1495

bool decrement_old = vdo_waiter_is_waiting(&page->waiter);

drivers/md/dm-vdo/block-map.c

1517

static void write_page_callback(struct vdo_waiter *waiter, void *context)

drivers/md/dm-vdo/block-map.c

1519

write_page(container_of(waiter, struct tree_page, waiter), context);

drivers/md/dm-vdo/block-map.c

1522

static void acquire_vio(struct vdo_waiter *waiter, struct block_map_zone *zone)

drivers/md/dm-vdo/block-map.c

1524

waiter->callback = write_page_callback;

drivers/md/dm-vdo/block-map.c

1525

acquire_vio_from_pool(zone->vio_pool, waiter);

drivers/md/dm-vdo/block-map.c

1545

acquire_vio(&page->waiter, zone);

drivers/md/dm-vdo/block-map.c

1549

vdo_waitq_enqueue_waiter(&zone->flush_waiters, &page->waiter);

drivers/md/dm-vdo/block-map.c

1552

static void write_page_if_not_dirtied(struct vdo_waiter *waiter, void *context)

drivers/md/dm-vdo/block-map.c

1554

struct tree_page *page = container_of(waiter, struct tree_page, waiter);

drivers/md/dm-vdo/block-map.c

1558

acquire_vio(waiter, write_context->zone);

drivers/md/dm-vdo/block-map.c

1610

struct tree_page, waiter);

drivers/md/dm-vdo/block-map.c

163

static inline struct vdo_page_completion *page_completion_from_waiter(struct vdo_waiter *waiter)

drivers/md/dm-vdo/block-map.c

167

if (waiter == NULL)

drivers/md/dm-vdo/block-map.c

170

completion = container_of(waiter, struct vdo_page_completion, waiter);

drivers/md/dm-vdo/block-map.c

1742

static void abort_lookup_for_waiter(struct vdo_waiter *waiter, void *context)

drivers/md/dm-vdo/block-map.c

1744

struct data_vio *data_vio = vdo_waiter_as_data_vio(waiter);

drivers/md/dm-vdo/block-map.c

1832

static void continue_load_for_waiter(struct vdo_waiter *waiter, void *context)

drivers/md/dm-vdo/block-map.c

1834

struct data_vio *data_vio = vdo_waiter_as_data_vio(waiter);

drivers/md/dm-vdo/block-map.c

1889

static void load_page(struct vdo_waiter *waiter, void *context)

drivers/md/dm-vdo/block-map.c

1892

struct data_vio *data_vio = vdo_waiter_as_data_vio(waiter);

drivers/md/dm-vdo/block-map.c

1934

vdo_waitq_enqueue_waiter(&lock_holder->waiters, &data_vio->waiter);

drivers/md/dm-vdo/block-map.c

1950

data_vio->waiter.callback = load_page;

drivers/md/dm-vdo/block-map.c

1951

acquire_vio_from_pool(zone->vio_pool, &data_vio->waiter);

drivers/md/dm-vdo/block-map.c

1966

static void continue_allocation_for_waiter(struct vdo_waiter *waiter, void *context)

drivers/md/dm-vdo/block-map.c

1968

struct data_vio *data_vio = vdo_waiter_as_data_vio(waiter);

drivers/md/dm-vdo/block-map.c

2028

result = VDO_ASSERT(!vdo_waiter_is_waiting(&page->waiter),

drivers/md/dm-vdo/block-map.c

2107

if (vdo_waiter_is_waiting(&tree_page->waiter)) {

drivers/md/dm-vdo/block-map.c

2343

bool waiting = vdo_waiter_is_waiting(&page->waiter);

drivers/md/dm-vdo/block-map.c

2652

static void launch_cursor(struct vdo_waiter *waiter, void *context)

drivers/md/dm-vdo/block-map.c

2654

struct cursor *cursor = container_of(waiter, struct cursor, waiter);

drivers/md/dm-vdo/block-map.c

2732

cursor->waiter.callback = launch_cursor;

drivers/md/dm-vdo/block-map.c

2733

acquire_vio_from_pool(cursors->pool, &cursor->waiter);

drivers/md/dm-vdo/block-map.c

515

static void complete_waiter_with_error(struct vdo_waiter *waiter, void *result_ptr)

drivers/md/dm-vdo/block-map.c

519

vdo_fail_completion(&page_completion_from_waiter(waiter)->completion, *result);

drivers/md/dm-vdo/block-map.c

529

static void complete_waiter_with_page(struct vdo_waiter *waiter, void *page_info)

drivers/md/dm-vdo/block-map.c

531

complete_with_page(page_info, page_completion_from_waiter(waiter));

drivers/md/dm-vdo/block-map.c

88

struct vdo_waiter waiter;

drivers/md/dm-vdo/block-map.c

893

static bool completion_needs_page(struct vdo_waiter *waiter, void *context)

drivers/md/dm-vdo/block-map.c

897

return (page_completion_from_waiter(waiter)->pbn == *pbn);

drivers/md/dm-vdo/block-map.c

985

vdo_waitq_enqueue_waiter(&cache->free_waiters, &vdo_page_comp->waiter);

drivers/md/dm-vdo/block-map.h

171

struct vdo_waiter waiter;

drivers/md/dm-vdo/block-map.h

185

struct vdo_waiter waiter;

drivers/md/dm-vdo/data-vio.c

472

vdo_waitq_enqueue_waiter(&lock_holder->logical.waiters, &data_vio->waiter);

drivers/md/dm-vdo/data-vio.h

172

struct vdo_waiter waiter;

drivers/md/dm-vdo/data-vio.h

178

struct vdo_waiter waiter;

drivers/md/dm-vdo/data-vio.h

292

static inline struct data_vio *vdo_waiter_as_data_vio(struct vdo_waiter *waiter)

drivers/md/dm-vdo/data-vio.h

294

if (waiter == NULL)

drivers/md/dm-vdo/data-vio.h

297

return container_of(waiter, struct data_vio, waiter);

drivers/md/dm-vdo/dedupe.c

1522

vdo_waitq_enqueue_waiter(&temp_queue, &data_vio->waiter);

drivers/md/dm-vdo/dedupe.c

1536

vdo_waitq_enqueue_waiter(&lock->waiters, &lock->agent->waiter);

drivers/md/dm-vdo/dedupe.c

542

vdo_waitq_enqueue_waiter(&lock->waiters, &data_vio->waiter);

drivers/md/dm-vdo/dedupe.c

568

static void abort_waiter(struct vdo_waiter *waiter, void __always_unused *context)

drivers/md/dm-vdo/dedupe.c

570

write_data_vio(vdo_waiter_as_data_vio(waiter));

drivers/md/dm-vdo/dedupe.c

926

static void enter_forked_lock(struct vdo_waiter *waiter, void *context)

drivers/md/dm-vdo/dedupe.c

928

struct data_vio *data_vio = vdo_waiter_as_data_vio(waiter);

drivers/md/dm-vdo/dump.c

154

struct vdo_waiter *waiter, *first = vdo_waitq_get_first_waiter(waitq);

drivers/md/dm-vdo/dump.c

166

for (waiter = first->next_waiter; waiter != first; waiter = waiter->next_waiter) {

drivers/md/dm-vdo/dump.c

167

data_vio = vdo_waiter_as_data_vio(waiter);

drivers/md/dm-vdo/dump.c

195

if (data_vio->waiter.next_waiter != NULL)

drivers/md/dm-vdo/flush.c

285

vdo_waitq_enqueue_waiter(&flusher->notifiers, &flush->waiter);

drivers/md/dm-vdo/flush.c

96

static struct vdo_flush *vdo_waiter_as_flush(struct vdo_waiter *waiter)

drivers/md/dm-vdo/flush.c

98

return container_of(waiter, struct vdo_flush, waiter);

drivers/md/dm-vdo/flush.h

21

struct vdo_waiter waiter;

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

521

static void retry_allocation(struct vdo_waiter *waiter, void __always_unused *context)

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

523

struct data_vio *data_vio = vdo_waiter_as_data_vio(waiter);

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

561

data_vio->waiter.callback = retry_allocation;

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

563

&data_vio->waiter);

drivers/md/dm-vdo/recovery-journal.c

1088

static void assign_entry(struct vdo_waiter *waiter, void *context)

drivers/md/dm-vdo/recovery-journal.c

1090

struct data_vio *data_vio = vdo_waiter_as_data_vio(waiter);

drivers/md/dm-vdo/recovery-journal.c

1106

vdo_waitq_enqueue_waiter(&block->entry_waiters, &data_vio->waiter);

drivers/md/dm-vdo/recovery-journal.c

1177

static void continue_committed_waiter(struct vdo_waiter *waiter, void *context)

drivers/md/dm-vdo/recovery-journal.c

1179

struct data_vio *data_vio = vdo_waiter_as_data_vio(waiter);

drivers/md/dm-vdo/recovery-journal.c

1365

vdo_waitq_enqueue_waiter(&block->commit_waiters, &data_vio->waiter);

drivers/md/dm-vdo/recovery-journal.c

1376

static void write_block(struct vdo_waiter *waiter, void __always_unused *context)

drivers/md/dm-vdo/recovery-journal.c

1379

container_of(waiter, struct recovery_journal_block, write_waiter);

drivers/md/dm-vdo/recovery-journal.c

1471

vdo_waitq_enqueue_waiter(&journal->entry_waiters, &data_vio->waiter);

drivers/md/dm-vdo/recovery-journal.c

269

static void continue_waiter(struct vdo_waiter *waiter, void *context)

drivers/md/dm-vdo/recovery-journal.c

271

continue_data_vio_with_error(vdo_waiter_as_data_vio(waiter), *((int *) context));

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

1015

static void finish_summary_update(struct vdo_waiter *waiter, void *context)

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

1017

struct vdo_slab *slab = container_of(waiter, struct vdo_slab, summary_waiter);

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

1030

static void write_reference_block(struct vdo_waiter *waiter, void *context);

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

1041

static void launch_reference_block_write(struct vdo_waiter *waiter, void *context)

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

1049

container_of(waiter, struct reference_block, waiter)->is_writing = true;

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

1050

waiter->callback = write_reference_block;

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

1051

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

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

1094

vdo_waitq_enqueue_waiter(&block->slab->dirty_blocks, &block->waiter);

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

1185

static void write_reference_block(struct vdo_waiter *waiter, void *context)

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

1191

struct reference_block *block = container_of(waiter, struct reference_block,

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

1192

waiter);

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

126

static void release_journal_locks(struct vdo_waiter *waiter, void *context);

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

1274

vdo_waitq_enqueue_waiter(&block->slab->dirty_blocks, &block->waiter);

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

1691

static void add_entry_from_waiter(struct vdo_waiter *waiter, void *context)

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

1695

container_of(waiter, struct reference_updater, waiter);

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

1757

struct vdo_waiter *waiter = vdo_waitq_get_first_waiter(&journal->entry_waiters);

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

1759

container_of(waiter, struct reference_updater, waiter);

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

2344

static void load_reference_block_group(struct vdo_waiter *waiter, void *context)

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

2349

container_of(waiter, struct reference_block, waiter);

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

2379

struct vdo_waiter *waiter = &slab->reference_blocks[i].waiter;

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

2381

waiter->callback = load_reference_block_group;

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

2382

acquire_vio_from_pool(pool, waiter);

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

2551

static void read_slab_journal_tail(struct vdo_waiter *waiter, void *context)

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

2554

container_of(waiter, struct slab_journal, resource_waiter);

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

3150

static void abort_waiter(struct vdo_waiter *waiter, void __always_unused *context)

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

3153

container_of(waiter, struct reference_updater, waiter);

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

3307

struct vdo_waiter *waiter)

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

3315

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

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

3340

vdo_waitq_enqueue_waiter(&slab->journal.entry_waiters, &updater->waiter);

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

361

static void update_slab_summary_entry(struct vdo_slab *slab, struct vdo_waiter *waiter,

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

374

waiter->callback(waiter, &result);

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

381

waiter->callback(waiter, &result);

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

392

vdo_waitq_enqueue_waiter(&block->next_update_waiters, waiter);

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

450

static void flush_for_reaping(struct vdo_waiter *waiter, void *context)

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

453

container_of(waiter, struct slab_journal, flush_waiter);

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

559

static void release_journal_locks(struct vdo_waiter *waiter, void *context)

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

563

container_of(waiter, struct slab_journal, slab_summary_waiter);

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

744

static void write_slab_journal_block(struct vdo_waiter *waiter, void *context)

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

749

container_of(waiter, struct slab_journal, resource_waiter);

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

165

struct vdo_waiter waiter;

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

542

struct vdo_waiter *waiter);

drivers/md/dm-vdo/vdo.c

1080

if (notifier->waiter != NULL) {

drivers/md/dm-vdo/vdo.c

1087

notifier->waiter = parent;

drivers/md/dm-vdo/vdo.c

1092

if (notifier->waiter == NULL) {

drivers/md/dm-vdo/vdo.c

1128

if (notifier->waiter != NULL)

drivers/md/dm-vdo/vdo.c

1129

vdo_continue_completion(vdo_forget(notifier->waiter),

drivers/md/dm-vdo/vdo.c

1208

if (notifier->waiter != NULL) {

drivers/md/dm-vdo/vdo.c

1219

notifier->waiter = parent;

drivers/md/dm-vdo/vdo.c

1224

if (notifier->waiter == NULL) {

drivers/md/dm-vdo/vdo.h

112

struct vdo_completion *waiter;

drivers/md/dm-vdo/vio.c

415

void acquire_vio_from_pool(struct vio_pool *pool, struct vdo_waiter *waiter)

drivers/md/dm-vdo/vio.c

423

vdo_waitq_enqueue_waiter(&pool->waiting, waiter);

drivers/md/dm-vdo/vio.c

430

(*waiter->callback)(waiter, pooled);

drivers/md/dm-vdo/vio.h

203

void acquire_vio_from_pool(struct vio_pool *pool, struct vdo_waiter *waiter);

drivers/md/dm-vdo/wait-queue.c

138

struct vdo_waiter *waiter = vdo_waitq_dequeue_waiter(&iteration_waitq);

drivers/md/dm-vdo/wait-queue.c

140

vdo_waitq_enqueue_waiter((waiter_match(waiter, match_context) ?

drivers/md/dm-vdo/wait-queue.c

141

matched_waitq : waitq), waiter);

drivers/md/dm-vdo/wait-queue.c

195

struct vdo_waiter *waiter = vdo_waitq_dequeue_waiter(waitq);

drivers/md/dm-vdo/wait-queue.c

197

if (waiter == NULL)

drivers/md/dm-vdo/wait-queue.c

201

callback = waiter->callback;

drivers/md/dm-vdo/wait-queue.c

202

callback(waiter, context);

drivers/md/dm-vdo/wait-queue.c

21

void vdo_waitq_enqueue_waiter(struct vdo_wait_queue *waitq, struct vdo_waiter *waiter)

drivers/md/dm-vdo/wait-queue.c

23

BUG_ON(waiter->next_waiter != NULL);

drivers/md/dm-vdo/wait-queue.c

30

waiter->next_waiter = waiter;

drivers/md/dm-vdo/wait-queue.c

33

waiter->next_waiter = waitq->last_waiter->next_waiter;

drivers/md/dm-vdo/wait-queue.c

34

waitq->last_waiter->next_waiter = waiter;

drivers/md/dm-vdo/wait-queue.c

38

waitq->last_waiter = waiter;

drivers/md/dm-vdo/wait-queue.h

107

struct vdo_waiter *waiter);

drivers/md/dm-vdo/wait-queue.h

51

typedef void (*vdo_waiter_callback_fn)(struct vdo_waiter *waiter, void *context);

drivers/md/dm-vdo/wait-queue.h

58

typedef bool (*vdo_waiter_match_fn)(struct vdo_waiter *waiter, void *context);

drivers/md/dm-vdo/wait-queue.h

78

static inline bool vdo_waiter_is_waiting(struct vdo_waiter *waiter)

drivers/md/dm-vdo/wait-queue.h

80

return (waiter->next_waiter != NULL);

drivers/md/persistent-data/dm-block-manager.c

122

static void __wait(struct waiter *w)

drivers/md/persistent-data/dm-block-manager.c

136

static void __wake_waiter(struct waiter *w)

drivers/md/persistent-data/dm-block-manager.c

152

struct waiter *w, *tmp;

drivers/md/persistent-data/dm-block-manager.c

196

struct waiter w;

drivers/md/persistent-data/dm-block-manager.c

259

struct waiter w;

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

385

struct bulk_waiter_node *waiter, *next;

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

387

list_for_each_entry_safe(waiter, next,

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

389

list_del(&waiter->list);

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

392

waiter, waiter->pid);

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

393

kfree(waiter);

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

584

struct bulk_waiter_node *waiter = NULL, *iter;

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

597

waiter = iter;

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

603

if (waiter) {

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

604

struct vchiq_bulk *bulk = waiter->bulk_waiter.bulk;

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

616

bulk->waiter = NULL;

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

621

waiter = kzalloc_obj(*waiter);

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

622

if (!waiter)

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

626

bulk_params->waiter = &waiter->bulk_waiter;

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

629

if ((ret != -EAGAIN) || fatal_signal_pending(current) || !waiter->bulk_waiter.bulk) {

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

630

struct vchiq_bulk *bulk = waiter->bulk_waiter.bulk;

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

635

bulk->waiter = NULL;

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

638

kfree(waiter);

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

640

waiter->pid = current->pid;

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

642

list_add(&waiter->list, &instance->bulk_waiter_list);

drivers/platform/raspberrypi/vchiq-interface/vchiq_arm.c

645

waiter, current->pid);

drivers/platform/raspberrypi/vchiq-interface/vchiq_core.c

1341

struct bulk_waiter *waiter;

drivers/platform/raspberrypi/vchiq-interface/vchiq_core.c

1344

waiter = bulk->waiter;

drivers/platform/raspberrypi/vchiq-interface/vchiq_core.c

1345

if (waiter) {

drivers/platform/raspberrypi/vchiq-interface/vchiq_core.c

1346

waiter->actual = bulk->actual;

drivers/platform/raspberrypi/vchiq-interface/vchiq_core.c

1347

complete(&waiter->event);

drivers/platform/raspberrypi/vchiq-interface/vchiq_core.c

3048

bulk_waiter = bulk_params->waiter;

drivers/platform/raspberrypi/vchiq-interface/vchiq_core.c

3077

bulk->waiter = bulk_params->waiter;

drivers/platform/raspberrypi/vchiq-interface/vchiq_core.c

3547

unsigned int handle, struct bulk_waiter *waiter)

drivers/platform/raspberrypi/vchiq-interface/vchiq_core.c

3556

if (!waiter)

drivers/platform/raspberrypi/vchiq-interface/vchiq_core.c

3565

bulk_waiter = waiter;

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

291

struct bulk_waiter_node *waiter = NULL, *iter;

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

301

waiter = kzalloc_obj(*waiter);

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

302

if (!waiter) {

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

311

bulk_params.waiter = &waiter->bulk_waiter;

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

321

waiter = iter;

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

326

if (!waiter) {

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

333

waiter, current->pid);

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

336

&waiter->bulk_waiter);

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

348

if (!waiter) {

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

354

!waiter->bulk_waiter.bulk) {

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

355

if (waiter->bulk_waiter.bulk) {

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

358

waiter->bulk_waiter.bulk->waiter = NULL;

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

361

kfree(waiter);

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

366

waiter->pid = current->pid;

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

368

list_add(&waiter->list, &instance->bulk_waiter_list);

drivers/platform/raspberrypi/vchiq-interface/vchiq_dev.c

371

waiter, current->pid);

drivers/tty/tty_ldsem.c

121

struct ldsem_waiter *waiter;

drivers/tty/tty_ldsem.c

123

waiter = list_entry(sem->write_wait.next, struct ldsem_waiter, list);

drivers/tty/tty_ldsem.c

124

wake_up_process(waiter->task);

drivers/tty/tty_ldsem.c

158

struct ldsem_waiter waiter;

drivers/tty/tty_ldsem.c

180

list_add_tail(&waiter.list, &sem->read_wait);

drivers/tty/tty_ldsem.c

183

waiter.task = current;

drivers/tty/tty_ldsem.c

196

if (!smp_load_acquire(&waiter.task))

drivers/tty/tty_ldsem.c

212

if (waiter.task) {

drivers/tty/tty_ldsem.c

215

list_del(&waiter.list);

drivers/tty/tty_ldsem.c

217

put_task_struct(waiter.task);

drivers/tty/tty_ldsem.c

232

struct ldsem_waiter waiter;

drivers/tty/tty_ldsem.c

253

list_add_tail(&waiter.list, &sem->write_wait);

drivers/tty/tty_ldsem.c

255

waiter.task = current;

drivers/tty/tty_ldsem.c

272

list_del(&waiter.list);

drivers/tty/tty_ldsem.c

76

struct ldsem_waiter *waiter, *next;

drivers/tty/tty_ldsem.c

94

list_for_each_entry_safe(waiter, next, &sem->read_wait, list) {

drivers/tty/tty_ldsem.c

95

tsk = waiter->task;

drivers/tty/tty_ldsem.c

96

smp_store_release(&waiter->task, NULL);

fs/direct-io.c

136

struct task_struct *waiter; /* waiting task (NULL if none) */

fs/direct-io.c

346

if (remaining == 1 && dio->waiter)

fs/direct-io.c

347

wake_up_process(dio->waiter);

fs/direct-io.c

388

if (--dio->refcount == 1 && dio->waiter)

fs/direct-io.c

389

wake_up_process(dio->waiter);

fs/direct-io.c

481

dio->waiter = current;

fs/direct-io.c

486

dio->waiter = NULL;

fs/iomap/direct-io.c

191

struct task_struct *waiter = dio->submit.waiter;

fs/iomap/direct-io.c

193

WRITE_ONCE(dio->submit.waiter, NULL);

fs/iomap/direct-io.c

194

blk_wake_io_task(waiter);

fs/iomap/direct-io.c

43

struct task_struct *waiter;

fs/iomap/direct-io.c

707

dio->submit.waiter = current;

fs/iomap/direct-io.c

865

if (!READ_ONCE(dio->submit.waiter))

fs/locks.c

734

static void locks_insert_global_blocked(struct file_lock_core *waiter)

fs/locks.c

738

hash_add(blocked_hash, &waiter->flc_link, posix_owner_key(waiter));

fs/locks.c

741

static void locks_delete_global_blocked(struct file_lock_core *waiter)

fs/locks.c

745

hash_del(&waiter->flc_link);

fs/locks.c

753

static void __locks_unlink_block(struct file_lock_core *waiter)

fs/locks.c

755

locks_delete_global_blocked(waiter);

fs/locks.c

756

list_del_init(&waiter->flc_blocked_member);

fs/locks.c

762

struct file_lock_core *waiter;

fs/locks.c

765

waiter = list_first_entry(&blocker->flc_blocked_requests,

fs/locks.c

768

fl = file_lock(waiter);

fs/locks.c

769

__locks_unlink_block(waiter);

fs/locks.c

770

if ((waiter->flc_flags & (FL_POSIX | FL_FLOCK)) &&

fs/locks.c

774

locks_wake_up_waiter(waiter);

fs/locks.c

781

smp_store_release(&waiter->flc_blocker, NULL);

fs/locks.c

785

static int __locks_delete_block(struct file_lock_core *waiter)

fs/locks.c

810

if (!smp_load_acquire(&waiter->flc_blocker) &&

fs/locks.c

811

list_empty(&waiter->flc_blocked_requests))

fs/locks.c

815

if (waiter->flc_blocker)

fs/locks.c

817

__locks_wake_up_blocks(waiter);

fs/locks.c

818

__locks_unlink_block(waiter);

fs/locks.c

824

smp_store_release(&waiter->flc_blocker, NULL);

fs/locks.c

835

int locks_delete_block(struct file_lock *waiter)

fs/locks.c

837

return __locks_delete_block(&waiter->c);

fs/locks.c

857

struct file_lock_core *waiter,

fs/locks.c

863

BUG_ON(!list_empty(&waiter->flc_blocked_member));

fs/locks.c

866

if (conflict(flc, waiter)) {

fs/locks.c

870

waiter->flc_blocker = blocker;

fs/locks.c

871

list_add_tail(&waiter->flc_blocked_member,

fs/locks.c

875

locks_insert_global_blocked(waiter);

fs/locks.c

881

__locks_wake_up_blocks(waiter);

fs/locks.c

886

struct file_lock_core *waiter,

fs/locks.c

891

__locks_insert_block(blocker, waiter, conflict);

fs/nfs/nfs4proc.c

7632

struct nfs4_lock_waiter *waiter =

fs/nfs/nfs4proc.c

7639

*wowner = &waiter->owner;

fs/nfs/nfs4proc.c

7646

if (nfs_compare_fh(NFS_FH(waiter->inode), &cbnl->cbnl_fh))

fs/nfs/nfs4proc.c

7660

struct nfs4_lock_waiter waiter = {

fs/nfs/nfs4proc.c

7672

init_wait(&waiter.wait);

fs/nfs/nfs4proc.c

7673

waiter.wait.func = nfs4_wake_lock_waiter;

fs/nfs/nfs4proc.c

7674

add_wait_queue(q, &waiter.wait);

fs/nfs/nfs4proc.c

7682

wait_woken(&waiter.wait, TASK_INTERRUPTIBLE|TASK_FREEZABLE,

fs/nfs/nfs4proc.c

7686

remove_wait_queue(q, &waiter.wait);

include/linux/blkdev.h

1691

static inline void blk_wake_io_task(struct task_struct *waiter)

include/linux/blkdev.h

1698

if (waiter == current)

include/linux/blkdev.h

1701

wake_up_process(waiter);

include/linux/filelock.h

366

static inline int locks_delete_block(struct file_lock *waiter)

include/linux/raspberrypi/vchiq_core.h

119

struct bulk_waiter *waiter;

kernel/locking/mutex-debug.c

29

void debug_mutex_lock_common(struct mutex *lock, struct mutex_waiter *waiter)

kernel/locking/mutex-debug.c

31

memset(waiter, MUTEX_DEBUG_INIT, sizeof(*waiter));

kernel/locking/mutex-debug.c

32

waiter->magic = waiter;

kernel/locking/mutex-debug.c

33

INIT_LIST_HEAD(&waiter->list);

kernel/locking/mutex-debug.c

34

waiter->ww_ctx = MUTEX_POISON_WW_CTX;

kernel/locking/mutex-debug.c

37

void debug_mutex_wake_waiter(struct mutex *lock, struct mutex_waiter *waiter)

kernel/locking/mutex-debug.c

41

DEBUG_LOCKS_WARN_ON(waiter->magic != waiter);

kernel/locking/mutex-debug.c

42

DEBUG_LOCKS_WARN_ON(list_empty(&waiter->list));

kernel/locking/mutex-debug.c

45

void debug_mutex_free_waiter(struct mutex_waiter *waiter)

kernel/locking/mutex-debug.c

47

DEBUG_LOCKS_WARN_ON(!list_empty(&waiter->list));

kernel/locking/mutex-debug.c

48

memset(waiter, MUTEX_DEBUG_FREE, sizeof(*waiter));

kernel/locking/mutex-debug.c

51

void debug_mutex_add_waiter(struct mutex *lock, struct mutex_waiter *waiter,

kernel/locking/mutex-debug.c

60

void debug_mutex_remove_waiter(struct mutex *lock, struct mutex_waiter *waiter,

kernel/locking/mutex-debug.c

65

DEBUG_LOCKS_WARN_ON(list_empty(&waiter->list));

kernel/locking/mutex-debug.c

66

DEBUG_LOCKS_WARN_ON(waiter->task != task);

kernel/locking/mutex-debug.c

69

INIT_LIST_HEAD(&waiter->list);

kernel/locking/mutex-debug.c

70

waiter->task = NULL;

kernel/locking/mutex.c

197

static inline bool __mutex_waiter_is_first(struct mutex *lock, struct mutex_waiter *waiter)

kernel/locking/mutex.c

199

return list_first_entry(&lock->wait_list, struct mutex_waiter, list) == waiter;

kernel/locking/mutex.c

207

__mutex_add_waiter(struct mutex *lock, struct mutex_waiter *waiter,

kernel/locking/mutex.c

211

debug_mutex_add_waiter(lock, waiter, current);

kernel/locking/mutex.c

213

list_add_tail(&waiter->list, list);

kernel/locking/mutex.c

214

if (__mutex_waiter_is_first(lock, waiter))

kernel/locking/mutex.c

219

__mutex_remove_waiter(struct mutex *lock, struct mutex_waiter *waiter)

kernel/locking/mutex.c

221

list_del(&waiter->list);

kernel/locking/mutex.c

225

debug_mutex_remove_waiter(lock, waiter, current);

kernel/locking/mutex.c

309

struct mutex_waiter *waiter)

kernel/locking/mutex.c

336

if (!waiter && (atomic_long_read(&lock->owner) & MUTEX_FLAG_WAITERS))

kernel/locking/mutex.c

343

if (waiter && !__mutex_waiter_is_first(lock, waiter))

kernel/locking/mutex.c

357

struct ww_acquire_ctx *ww_ctx, struct mutex_waiter *waiter)

kernel/locking/mutex.c

382

if (ww_ctx && !ww_mutex_spin_on_owner(lock, ww_ctx, waiter)) {

kernel/locking/mutex.c

446

struct mutex_waiter *waiter)

kernel/locking/mutex.c

448

if (!waiter) {

kernel/locking/mutex.c

480

if (!mutex_spin_on_owner(lock, owner, ww_ctx, waiter))

kernel/locking/mutex.c

492

if (!waiter)

kernel/locking/mutex.c

499

if (!waiter)

kernel/locking/mutex.c

522

struct mutex_waiter *waiter)

kernel/locking/mutex.c

583

struct mutex_waiter waiter;

kernel/locking/mutex.c

639

debug_mutex_lock_common(lock, &waiter);

kernel/locking/mutex.c

640

waiter.task = current;

kernel/locking/mutex.c

642

waiter.ww_ctx = ww_ctx;

kernel/locking/mutex.c

648

__mutex_add_waiter(lock, &waiter, &lock->wait_list);

kernel/locking/mutex.c

654

ret = __ww_mutex_add_waiter(&waiter, lock, ww_ctx, &wake_q);

kernel/locking/mutex.c

685

ret = __ww_mutex_check_kill(lock, &waiter, ww_ctx);

kernel/locking/mutex.c

694

first = __mutex_waiter_is_first(lock, &waiter);

kernel/locking/mutex.c

719

if (mutex_optimistic_spin(lock, ww_ctx, &waiter))

kernel/locking/mutex.c

738

!__mutex_waiter_is_first(lock, &waiter))

kernel/locking/mutex.c

742

__mutex_remove_waiter(lock, &waiter);

kernel/locking/mutex.c

744

debug_mutex_free_waiter(&waiter);

kernel/locking/mutex.c

761

__mutex_remove_waiter(lock, &waiter);

kernel/locking/mutex.c

766

debug_mutex_free_waiter(&waiter);

kernel/locking/mutex.c

967

struct mutex_waiter *waiter =

kernel/locking/mutex.c

971

next = waiter->task;

kernel/locking/mutex.c

973

debug_mutex_wake_waiter(lock, waiter);

kernel/locking/mutex.h

52

struct mutex_waiter *waiter);

kernel/locking/mutex.h

54

struct mutex_waiter *waiter);

kernel/locking/mutex.h

55

extern void debug_mutex_free_waiter(struct mutex_waiter *waiter);

kernel/locking/mutex.h

57

struct mutex_waiter *waiter,

kernel/locking/mutex.h

59

extern void debug_mutex_remove_waiter(struct mutex *lock, struct mutex_waiter *waiter,

kernel/locking/mutex.h

64

# define debug_mutex_lock_common(lock, waiter) do { } while (0)

kernel/locking/mutex.h

65

# define debug_mutex_wake_waiter(lock, waiter) do { } while (0)

kernel/locking/mutex.h

66

# define debug_mutex_free_waiter(waiter) do { } while (0)

kernel/locking/mutex.h

67

# define debug_mutex_add_waiter(lock, waiter, ti) do { } while (0)

kernel/locking/mutex.h

68

# define debug_mutex_remove_waiter(lock, waiter, ti) do { } while (0)

kernel/locking/rtmutex.c

1000

waiter_clone_prio(waiter, task);

kernel/locking/rtmutex.c

1001

rt_mutex_enqueue_pi(task, waiter);

kernel/locking/rtmutex.c

1004

} else if (prerequeue_top_waiter == waiter) {

kernel/locking/rtmutex.c

1015

rt_mutex_dequeue_pi(task, waiter);

kernel/locking/rtmutex.c

1016

waiter = rt_mutex_top_waiter(lock);

kernel/locking/rtmutex.c

1017

waiter_clone_prio(waiter, task);

kernel/locking/rtmutex.c

1018

rt_mutex_enqueue_pi(task, waiter);

kernel/locking/rtmutex.c

1063

if (!detect_deadlock && waiter != top_waiter)

kernel/locking/rtmutex.c

1088

struct rt_mutex_waiter *waiter)

kernel/locking/rtmutex.c

1122

if (waiter) {

kernel/locking/rtmutex.c

1129

if (waiter == top_waiter || rt_mutex_steal(waiter, top_waiter)) {

kernel/locking/rtmutex.c

1134

rt_mutex_dequeue(lock, waiter);

kernel/locking/rtmutex.c

1204

struct rt_mutex_waiter *waiter,

kernel/locking/rtmutex.c

1211

struct rt_mutex_waiter *top_waiter = waiter;

kernel/locking/rtmutex.c

1233

waiter->task = task;

kernel/locking/rtmutex.c

1234

waiter->lock = lock;

kernel/locking/rtmutex.c

1235

waiter_update_prio(waiter, task);

kernel/locking/rtmutex.c

1236

waiter_clone_prio(waiter, task);

kernel/locking/rtmutex.c

1241

rt_mutex_enqueue(lock, waiter);

kernel/locking/rtmutex.c

1243

task->pi_blocked_on = waiter;

kernel/locking/rtmutex.c

1252

res = __ww_mutex_add_waiter(waiter, rtm, ww_ctx, wake_q);

kernel/locking/rtmutex.c

1255

rt_mutex_dequeue(lock, waiter);

kernel/locking/rtmutex.c

1266

if (waiter == rt_mutex_top_waiter(lock)) {

kernel/locking/rtmutex.c

1268

rt_mutex_enqueue_pi(owner, waiter);

kernel/locking/rtmutex.c

1273

} else if (rt_mutex_cond_detect_deadlock(waiter, chwalk)) {

kernel/locking/rtmutex.c

1299

next_lock, waiter, task);

kernel/locking/rtmutex.c

1315

struct rt_mutex_waiter *waiter;

kernel/locking/rtmutex.c

1321

waiter = rt_mutex_top_waiter(lock);

kernel/locking/rtmutex.c

1330

rt_mutex_dequeue_pi(current, waiter);

kernel/locking/rtmutex.c

1354

rt_mutex_wake_q_add(wqh, waiter);

kernel/locking/rtmutex.c

1482

struct rt_mutex_waiter *waiter,

kernel/locking/rtmutex.c

1508

!rt_mutex_waiter_is_top_waiter(lock, waiter)) {

kernel/locking/rtmutex.c

1519

struct rt_mutex_waiter *waiter,

kernel/locking/rtmutex.c

1540

struct rt_mutex_waiter *waiter)

kernel/locking/rtmutex.c

1542

bool is_top_waiter = (waiter == rt_mutex_top_waiter(lock));

kernel/locking/rtmutex.c

1549

rt_mutex_dequeue(lock, waiter);

kernel/locking/rtmutex.c

1562

rt_mutex_dequeue_pi(owner, waiter);

kernel/locking/rtmutex.c

1608

struct rt_mutex_waiter *waiter,

kernel/locking/rtmutex.c

1619

if (try_to_take_rt_mutex(lock, current, waiter)) {

kernel/locking/rtmutex.c

1634

ret = __ww_mutex_check_kill(rtm, waiter, ww_ctx);

kernel/locking/rtmutex.c

1639

if (waiter == rt_mutex_top_waiter(lock))

kernel/locking/rtmutex.c

1645

if (!owner || !rtmutex_spin_on_owner(lock, waiter, owner)) {

kernel/locking/rtmutex.c

1695

struct rt_mutex_waiter *waiter,

kernel/locking/rtmutex.c

1719

ret = task_blocks_on_rt_mutex(lock, waiter, current, ww_ctx, chwalk, wake_q);

kernel/locking/rtmutex.c

1721

ret = rt_mutex_slowlock_block(lock, ww_ctx, state, NULL, waiter, wake_q);

kernel/locking/rtmutex.c

1733

remove_waiter(lock, waiter);

kernel/locking/rtmutex.c

1734

rt_mutex_handle_deadlock(ret, chwalk, lock, waiter);

kernel/locking/rtmutex.c

1754

struct rt_mutex_waiter waiter;

kernel/locking/rtmutex.c

1757

rt_mutex_init_waiter(&waiter);

kernel/locking/rtmutex.c

1758

waiter.ww_ctx = ww_ctx;

kernel/locking/rtmutex.c

1761

&waiter, wake_q);

kernel/locking/rtmutex.c

1763

debug_rt_mutex_free_waiter(&waiter);

kernel/locking/rtmutex.c

1833

struct rt_mutex_waiter waiter;

kernel/locking/rtmutex.c

1844

rt_mutex_init_rtlock_waiter(&waiter);

kernel/locking/rtmutex.c

1851

task_blocks_on_rt_mutex(lock, &waiter, current, NULL, RT_MUTEX_MIN_CHAINWALK, wake_q);

kernel/locking/rtmutex.c

1855

if (try_to_take_rt_mutex(lock, current, &waiter)) {

kernel/locking/rtmutex.c

1860

if (&waiter == rt_mutex_top_waiter(lock))

kernel/locking/rtmutex.c

1866

if (!owner || !rtmutex_spin_on_owner(lock, &waiter, owner)) {

kernel/locking/rtmutex.c

1883

debug_rt_mutex_free_waiter(&waiter);

kernel/locking/rtmutex.c

36

static inline int __ww_mutex_add_waiter(struct rt_mutex_waiter *waiter,

kernel/locking/rtmutex.c

363

waiter_update_prio(struct rt_mutex_waiter *waiter, struct task_struct *task)

kernel/locking/rtmutex.c

365

lockdep_assert_held(&waiter->lock->wait_lock);

kernel/locking/rtmutex.c

366

lockdep_assert(RB_EMPTY_NODE(&waiter->tree.entry));

kernel/locking/rtmutex.c

368

waiter->tree.prio = __waiter_prio(task);

kernel/locking/rtmutex.c

369

waiter->tree.deadline = task->dl.deadline;

kernel/locking/rtmutex.c

376

waiter_clone_prio(struct rt_mutex_waiter *waiter, struct task_struct *task)

kernel/locking/rtmutex.c

378

lockdep_assert_held(&waiter->lock->wait_lock);

kernel/locking/rtmutex.c

380

lockdep_assert(RB_EMPTY_NODE(&waiter->pi_tree.entry));

kernel/locking/rtmutex.c

382

waiter->pi_tree.prio = waiter->tree.prio;

kernel/locking/rtmutex.c

383

waiter->pi_tree.deadline = waiter->tree.deadline;

kernel/locking/rtmutex.c

430

static inline bool rt_mutex_steal(struct rt_mutex_waiter *waiter,

kernel/locking/rtmutex.c

433

if (rt_waiter_node_less(&waiter->tree, &top_waiter->tree))

kernel/locking/rtmutex.c

441

if (rt_or_dl_prio(waiter->tree.prio))

kernel/locking/rtmutex.c

444

return rt_waiter_node_equal(&waiter->tree, &top_waiter->tree);

kernel/locking/rtmutex.c

480

rt_mutex_enqueue(struct rt_mutex_base *lock, struct rt_mutex_waiter *waiter)

kernel/locking/rtmutex.c

484

rb_add_cached(&waiter->tree.entry, &lock->waiters, __waiter_less);

kernel/locking/rtmutex.c

488

rt_mutex_dequeue(struct rt_mutex_base *lock, struct rt_mutex_waiter *waiter)

kernel/locking/rtmutex.c

492

if (RB_EMPTY_NODE(&waiter->tree.entry))

kernel/locking/rtmutex.c

495

rb_erase_cached(&waiter->tree.entry, &lock->waiters);

kernel/locking/rtmutex.c

496

RB_CLEAR_NODE(&waiter->tree.entry);

kernel/locking/rtmutex.c

508

rt_mutex_enqueue_pi(struct task_struct *task, struct rt_mutex_waiter *waiter)

kernel/locking/rtmutex.c

512

rb_add_cached(&waiter->pi_tree.entry, &task->pi_waiters, __pi_waiter_less);

kernel/locking/rtmutex.c

516

rt_mutex_dequeue_pi(struct task_struct *task, struct rt_mutex_waiter *waiter)

kernel/locking/rtmutex.c

520

if (RB_EMPTY_NODE(&waiter->pi_tree.entry))

kernel/locking/rtmutex.c

523

rb_erase_cached(&waiter->pi_tree.entry, &task->pi_waiters);

kernel/locking/rtmutex.c

524

RB_CLEAR_NODE(&waiter->pi_tree.entry);

kernel/locking/rtmutex.c

56

struct rt_mutex_waiter *waiter,

kernel/locking/rtmutex.c

592

rt_mutex_cond_detect_deadlock(struct rt_mutex_waiter *waiter,

kernel/locking/rtmutex.c

596

return waiter != NULL;

kernel/locking/rtmutex.c

685

struct rt_mutex_waiter *waiter, *top_waiter = orig_waiter;

kernel/locking/rtmutex.c

737

waiter = task->pi_blocked_on;

kernel/locking/rtmutex.c

748

if (!waiter)

kernel/locking/rtmutex.c

767

if (next_lock != waiter->lock)

kernel/locking/rtmutex.c

792

if (IS_ENABLED(CONFIG_PREEMPT_RT) && waiter->ww_ctx && detect_deadlock)

kernel/locking/rtmutex.c

824

if (rt_waiter_node_equal(&waiter->tree, task_to_waiter_node(task))) {

kernel/locking/rtmutex.c

835

lock = waiter->lock;

kernel/locking/rtmutex.c

935

rt_mutex_dequeue(lock, waiter);

kernel/locking/rtmutex.c

948

waiter_update_prio(waiter, task);

kernel/locking/rtmutex.c

950

rt_mutex_enqueue(lock, waiter);

kernel/locking/rtmutex.c

992

if (waiter == rt_mutex_top_waiter(lock)) {

kernel/locking/rtmutex_api.c

312

struct rt_mutex_waiter *waiter,

kernel/locking/rtmutex_api.c

324

ret = task_blocks_on_rt_mutex(lock, waiter, task, NULL,

kernel/locking/rtmutex_api.c

360

struct rt_mutex_waiter *waiter,

kernel/locking/rtmutex_api.c

367

ret = __rt_mutex_start_proxy_lock(lock, waiter, task, &wake_q);

kernel/locking/rtmutex_api.c

369

remove_waiter(lock, waiter);

kernel/locking/rtmutex_api.c

397

struct rt_mutex_waiter *waiter)

kernel/locking/rtmutex_api.c

404

ret = rt_mutex_slowlock_block(lock, NULL, TASK_INTERRUPTIBLE, to, waiter, NULL);

kernel/locking/rtmutex_api.c

436

struct rt_mutex_waiter *waiter)

kernel/locking/rtmutex_api.c

452

try_to_take_rt_mutex(lock, current, waiter);

kernel/locking/rtmutex_api.c

458

remove_waiter(lock, waiter);

kernel/locking/rtmutex_api.c

479

struct rt_mutex_waiter *waiter;

kernel/locking/rtmutex_api.c

485

waiter = task->pi_blocked_on;

kernel/locking/rtmutex_api.c

486

if (!waiter || rt_waiter_node_equal(&waiter->tree, task_to_waiter_node(task))) {

kernel/locking/rtmutex_api.c

490

next_lock = waiter->lock;

kernel/locking/rtmutex_common.h

122

struct rt_mutex_waiter *waiter)

kernel/locking/rtmutex_common.h

126

return rb_entry(leftmost, struct rt_mutex_waiter, tree.entry) == waiter;

kernel/locking/rtmutex_common.h

191

static inline void debug_rt_mutex_init_waiter(struct rt_mutex_waiter *waiter)

kernel/locking/rtmutex_common.h

194

memset(waiter, 0x11, sizeof(*waiter));

kernel/locking/rtmutex_common.h

197

static inline void debug_rt_mutex_free_waiter(struct rt_mutex_waiter *waiter)

kernel/locking/rtmutex_common.h

200

memset(waiter, 0x22, sizeof(*waiter));

kernel/locking/rtmutex_common.h

203

static inline void rt_mutex_init_waiter(struct rt_mutex_waiter *waiter)

kernel/locking/rtmutex_common.h

205

debug_rt_mutex_init_waiter(waiter);

kernel/locking/rtmutex_common.h

206

RB_CLEAR_NODE(&waiter->pi_tree.entry);

kernel/locking/rtmutex_common.h

207

RB_CLEAR_NODE(&waiter->tree.entry);

kernel/locking/rtmutex_common.h

208

waiter->wake_state = TASK_NORMAL;

kernel/locking/rtmutex_common.h

209

waiter->task = NULL;

kernel/locking/rtmutex_common.h

212

static inline void rt_mutex_init_rtlock_waiter(struct rt_mutex_waiter *waiter)

kernel/locking/rtmutex_common.h

214

rt_mutex_init_waiter(waiter);

kernel/locking/rtmutex_common.h

215

waiter->wake_state = TASK_RTLOCK_WAIT;

kernel/locking/rtmutex_common.h

85

struct rt_mutex_waiter *waiter,

kernel/locking/rtmutex_common.h

89

struct rt_mutex_waiter *waiter,

kernel/locking/rtmutex_common.h

93

struct rt_mutex_waiter *waiter);

kernel/locking/rtmutex_common.h

95

struct rt_mutex_waiter *waiter);

kernel/locking/rwsem.c

1032

waiter.task = current;

kernel/locking/rwsem.c

1033

waiter.type = RWSEM_WAITING_FOR_READ;

kernel/locking/rwsem.c

1034

waiter.timeout = jiffies + RWSEM_WAIT_TIMEOUT;

kernel/locking/rwsem.c

1035

waiter.handoff_set = false;

kernel/locking/rwsem.c

1055

rwsem_add_waiter(sem, &waiter);

kernel/locking/rwsem.c

1074

if (!smp_load_acquire(&waiter.task)) {

kernel/locking/rwsem.c

1080

if (waiter.task)

kernel/locking/rwsem.c

1100

rwsem_del_wake_waiter(sem, &waiter, &wake_q);

kernel/locking/rwsem.c

1113

struct rwsem_waiter waiter;

kernel/locking/rwsem.c

1126

waiter.task = current;

kernel/locking/rwsem.c

1127

waiter.type = RWSEM_WAITING_FOR_WRITE;

kernel/locking/rwsem.c

1128

waiter.timeout = jiffies + RWSEM_WAIT_TIMEOUT;

kernel/locking/rwsem.c

1129

waiter.handoff_set = false;

kernel/locking/rwsem.c

1132

rwsem_add_waiter(sem, &waiter);

kernel/locking/rwsem.c

1135

if (rwsem_first_waiter(sem) != &waiter) {

kernel/locking/rwsem.c

1159

if (rwsem_try_write_lock(sem, &waiter)) {

kernel/locking/rwsem.c

1177

if (waiter.handoff_set) {

kernel/locking/rwsem.c

1204

rwsem_del_wake_waiter(sem, &waiter, &wake_q);

kernel/locking/rwsem.c

369

rwsem_add_waiter(struct rw_semaphore *sem, struct rwsem_waiter *waiter)

kernel/locking/rwsem.c

372

list_add_tail(&waiter->list, &sem->wait_list);

kernel/locking/rwsem.c

385

rwsem_del_waiter(struct rw_semaphore *sem, struct rwsem_waiter *waiter)

kernel/locking/rwsem.c

388

list_del(&waiter->list);

kernel/locking/rwsem.c

414

struct rwsem_waiter *waiter, *tmp;

kernel/locking/rwsem.c

424

waiter = rwsem_first_waiter(sem);

kernel/locking/rwsem.c

426

if (waiter->type == RWSEM_WAITING_FOR_WRITE) {

kernel/locking/rwsem.c

435

wake_q_add(wake_q, waiter->task);

kernel/locking/rwsem.c

464

if (time_after(jiffies, waiter->timeout)) {

kernel/locking/rwsem.c

469

waiter->handoff_set = true;

kernel/locking/rwsem.c

481

owner = waiter->task;

kernel/locking/rwsem.c

509

list_for_each_entry_safe(waiter, tmp, &sem->wait_list, list) {

kernel/locking/rwsem.c

510

if (waiter->type == RWSEM_WAITING_FOR_WRITE)

kernel/locking/rwsem.c

514

list_move_tail(&waiter->list, &wlist);

kernel/locking/rwsem.c

548

list_for_each_entry_safe(waiter, tmp, &wlist, list) {

kernel/locking/rwsem.c

551

tsk = waiter->task;

kernel/locking/rwsem.c

560

smp_store_release(&waiter->task, NULL);

kernel/locking/rwsem.c

576

rwsem_del_wake_waiter(struct rw_semaphore *sem, struct rwsem_waiter *waiter,

kernel/locking/rwsem.c

580

bool first = rwsem_first_waiter(sem) == waiter;

kernel/locking/rwsem.c

589

if (rwsem_del_waiter(sem, waiter) && first)

kernel/locking/rwsem.c

604

struct rwsem_waiter *waiter)

kernel/locking/rwsem.c

621

if (first->handoff_set && (waiter != first))

kernel/locking/rwsem.c

633

if (has_handoff || (!rt_or_dl_task(waiter->task) &&

kernel/locking/rwsem.c

634

!time_after(jiffies, waiter->timeout)))

kernel/locking/rwsem.c

662

list_del(&waiter->list);

kernel/locking/rwsem.c

997

struct rwsem_waiter waiter;

kernel/locking/semaphore.c

255

struct semaphore_waiter waiter;

kernel/locking/semaphore.c

257

list_add_tail(&waiter.list, &sem->wait_list);

kernel/locking/semaphore.c

258

waiter.task = current;

kernel/locking/semaphore.c

259

waiter.up = false;

kernel/locking/semaphore.c

270

if (waiter.up) {

kernel/locking/semaphore.c

277

list_del(&waiter.list);

kernel/locking/semaphore.c

281

list_del(&waiter.list);

kernel/locking/semaphore.c

324

struct semaphore_waiter *waiter = list_first_entry(&sem->wait_list,

kernel/locking/semaphore.c

326

list_del(&waiter->list);

kernel/locking/semaphore.c

327

waiter->up = true;

kernel/locking/semaphore.c

328

wake_q_add(wake_q, waiter->task);

kernel/locking/ww_mutex.h

130

__ww_waiter_add(struct rt_mutex *lock, struct rt_mutex_waiter *waiter, struct rt_mutex_waiter *pos)

kernel/locking/ww_mutex.h

277

__ww_mutex_die(struct MUTEX *lock, struct MUTEX_WAITER *waiter,

kernel/locking/ww_mutex.h

283

if (waiter->ww_ctx->acquired > 0 && __ww_ctx_less(waiter->ww_ctx, ww_ctx)) {

kernel/locking/ww_mutex.h

285

debug_mutex_wake_waiter(lock, waiter);

kernel/locking/ww_mutex.h

292

__clear_task_blocked_on(waiter->task, lock);

kernel/locking/ww_mutex.h

293

wake_q_add(wake_q, waiter->task);

kernel/locking/ww_mutex.h

465

__ww_mutex_check_kill(struct MUTEX *lock, struct MUTEX_WAITER *waiter,

kernel/locking/ww_mutex.h

489

for (cur = __ww_waiter_prev(lock, waiter); cur;

kernel/locking/ww_mutex.h

513

__ww_mutex_add_waiter(struct MUTEX_WAITER *waiter,

kernel/locking/ww_mutex.h

522

__ww_waiter_add(lock, waiter, NULL);

kernel/locking/ww_mutex.h

53

__ww_waiter_add(struct mutex *lock, struct mutex_waiter *waiter, struct mutex_waiter *pos)

kernel/locking/ww_mutex.h

563

__ww_waiter_add(lock, waiter, pos);

kernel/locking/ww_mutex.h

58

__mutex_add_waiter(lock, waiter, p);

kernel/printk/printk.c

1923

int waiter;

kernel/printk/printk.c

1942

waiter = READ_ONCE(console_waiter);

kernel/printk/printk.c

1946

if (!waiter) {

kernel/printk/printk.c

1983

bool waiter;

kernel/printk/printk.c

2004

waiter = READ_ONCE(console_waiter);

kernel/printk/printk.c

2005

if (!waiter && owner && owner != current) {

lib/klist.c

185

struct klist_waiter *waiter, *tmp;

lib/klist.c

191

list_for_each_entry_safe(waiter, tmp, &klist_remove_waiters, list) {

lib/klist.c

192

if (waiter->node != n)

lib/klist.c

195

list_del(&waiter->list);

lib/klist.c

196

waiter->woken = 1;

lib/klist.c

198

wake_up_process(waiter->process);

lib/klist.c

240

struct klist_waiter waiter;

lib/klist.c

242

waiter.node = n;

lib/klist.c

243

waiter.process = current;

lib/klist.c

244

waiter.woken = 0;

lib/klist.c

246

list_add(&waiter.list, &klist_remove_waiters);

lib/klist.c

253

if (waiter.woken)

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1217

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1223

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1269

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1275

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1321

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1327

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1373

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1379

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1425

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1431

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1476

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1482

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1527

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1533

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1578

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1584

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1629

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1635

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1681

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1o, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1687

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1733

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1739

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1785

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1o, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1791

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1838

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1848

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1895

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1o, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1905

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1952

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

1962

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2009

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1o, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2019

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2065

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2071

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2117

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1op, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2123

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2169

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2175

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2221

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1op, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2227

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2274

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2284

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

23

pthread_t waiter;

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2330

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1op, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2336

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2383

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2393

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2439

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1op, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2445

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2733

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2739

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2798

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2804

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2863

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2869

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2928

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2934

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

2994

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

3004

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

3064

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

3074

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

3461

pthread_t waiter[2];

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

3480

ASSERT_EQ(pthread_create(&waiter[0], NULL, waiter_entry1a, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

3481

ASSERT_EQ(pthread_create(&waiter[1], NULL, waiter_entry1a, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

3486

ASSERT_EQ(pthread_join(waiter[0], NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

3487

ASSERT_EQ(pthread_join(waiter[1], NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

47

pthread_kill(ctx->waiter, SIGUSR1);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

489

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

495

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

532

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

538

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

579

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry2a, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

585

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

628

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

634

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

673

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

679

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

716

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

722

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

763

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry2ap, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

769

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

812

ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

818

ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);

tools/testing/selftests/futex/functional/futex_requeue.c

36

pthread_t waiter[10];

tools/testing/selftests/futex/functional/futex_requeue.c

44

if (pthread_create(&waiter[0], NULL, waiterfn, NULL))

tools/testing/selftests/futex/functional/futex_requeue.c

71

pthread_t waiter[10];

tools/testing/selftests/futex/functional/futex_requeue.c

81

if (pthread_create(&waiter[i], NULL, waiterfn, NULL))

tools/testing/selftests/futex/functional/futex_requeue_pi.c

323

pthread_t waiter[THREAD_MAX], waker, blocker;

tools/testing/selftests/futex/functional/futex_requeue_pi.c

365

if (create_rt_thread(&waiter[i], waiterfn, (void *)&args[i],

tools/testing/selftests/futex/functional/futex_requeue_pi.c

380

pthread_join(waiter[i],

tools/testing/selftests/futex/functional/futex_requeue_pi_signal_restart.c

102

pthread_t waiter;

tools/testing/selftests/futex/functional/futex_requeue_pi_signal_restart.c

113

res = create_rt_thread(&waiter, waiterfn, NULL, SCHED_FIFO, 1);

tools/testing/selftests/futex/functional/futex_requeue_pi_signal_restart.c

129

pthread_kill(waiter, SIGUSR1);

tools/testing/selftests/futex/functional/futex_requeue_pi_signal_restart.c

158

pthread_kill(waiter, SIGUSR1);

tools/testing/selftests/futex/functional/futex_requeue_pi_signal_restart.c

160

pthread_join(waiter, NULL);

tools/testing/selftests/futex/functional/futex_wait.c

106

pthread_t waiter;

tools/testing/selftests/futex/functional/futex_wait.c

127

if (pthread_create(&waiter, NULL, waiterfn, NULL))

tools/testing/selftests/futex/functional/futex_wait.c

43

pthread_t waiter;

tools/testing/selftests/futex/functional/futex_wait.c

50

if (pthread_create(&waiter, NULL, waiterfn, (void *) &flags))

tools/testing/selftests/futex/functional/futex_wait.c

68

pthread_t waiter;

tools/testing/selftests/futex/functional/futex_wait.c

86

if (pthread_create(&waiter, NULL, waiterfn, NULL))

tools/testing/selftests/futex/functional/futex_waitv.c

104

if (pthread_create(&waiter, NULL, waiterfn, NULL))

tools/testing/selftests/futex/functional/futex_waitv.c

53

pthread_t waiter;

tools/testing/selftests/futex/functional/futex_waitv.c

64

if (pthread_create(&waiter, NULL, waiterfn, NULL))

tools/testing/selftests/futex/functional/futex_waitv.c

81

pthread_t waiter;