arch/arm/include/asm/mcs_spinlock.h

13

while (!(smp_load_acquire(lock))) \

arch/arm64/include/asm/barrier.h

214

VAL = smp_load_acquire(__PTR); \

arch/arm64/include/asm/rqspinlock.h

58

VAL = smp_load_acquire(__PTR); \

arch/arm64/kvm/hyp/nvhe/ffa.c

886

!smp_load_acquire(&has_version_negotiated)) {

arch/arm64/kvm/vgic/vgic-init.c

576

if (likely(smp_load_acquire(&dist->ready)))

arch/x86/events/core.c

2901

ldt = smp_load_acquire(&current->mm->context.ldt);

arch/x86/include/asm/tlbflush.h

256

asid = smp_load_acquire(&mm->context.global_asid);

arch/x86/kvm/mmu.h

249

return smp_load_acquire(&kvm->arch.shadow_root_allocated);

arch/x86/kvm/mmu/mmu.c

2002

struct hlist_head *page_hash = smp_load_acquire(&kvm->arch.mmu_page_hash);

arch/x86/kvm/mmu/page_track.c

30

return smp_load_acquire(&kvm->arch.external_write_tracking_enabled);

arch/x86/kvm/svm/svm.c

3749

bool in_guest_mode = (smp_load_acquire(&vcpu->mode) == IN_GUEST_MODE);

block/blk-crypto-fallback.c

633

if (likely(smp_load_acquire(&tfms_inited[mode_num])))

drivers/android/binder_alloc.c

189

return smp_load_acquire(&alloc->pages[index]);

drivers/android/binder_alloc.c

231

return smp_load_acquire(&alloc->mapped);

drivers/char/hw_random/virtio-rng.c

94

if (smp_load_acquire(&vi->data_avail)) {

drivers/firmware/qcom/qcom_scm.c

2507

return !!smp_load_acquire(&__scm);

drivers/gpu/drm/scheduler/sched_fence.c

178

parent = smp_load_acquire(&fence->parent);

drivers/greybus/gb-beagleplay.c

231

int head = smp_load_acquire(&bg->tx_circ_buf.head);

drivers/infiniband/core/uverbs_main.c

105

struct ib_ucontext *ucontext = smp_load_acquire(&ufile->ucontext);

drivers/infiniband/hw/hfi1/ipoib_tx.c

167

if (!smp_load_acquire(&tx->complete))

drivers/infiniband/hw/hfi1/ipoib_tx.c

366

head = smp_load_acquire(&tx_ring->head);

drivers/infiniband/sw/rdmavt/qp.c

1929

slast = smp_load_acquire(&qp->s_last);

drivers/infiniband/sw/rxe/rxe_queue.h

108

prod = smp_load_acquire(&q->buf->producer_index);

drivers/infiniband/sw/rxe/rxe_queue.h

120

prod = smp_load_acquire(&q->buf->producer_index);

drivers/infiniband/sw/rxe/rxe_queue.h

139

cons = smp_load_acquire(&q->buf->consumer_index);

drivers/infiniband/sw/rxe/rxe_queue.h

143

cons = smp_load_acquire(&q->buf->consumer_index);

drivers/input/keyboard/applespi.c

1024

input = smp_load_acquire(&applespi->touchpad_input_dev);

drivers/md/dm-bufio.c

1497

if (!smp_load_acquire(&b->state)) /* fast case */

drivers/md/dm-bufio.c

2258

if (likely(!smp_load_acquire(&b->state))) {

drivers/md/dm-integrity.c

2561

recalc_sector = le64_to_cpu(smp_load_acquire(&ic->sb->recalc_sector));

drivers/md/raid5.c

5474

if (!did_inc || smp_load_acquire(&conf->quiesce) != 0) {

drivers/media/dvb-core/dvb_ringbuffer.c

107

smp_store_release(&rbuf->pread, smp_load_acquire(&rbuf->pwrite));

drivers/media/dvb-core/dvb_ringbuffer.c

61

return (rbuf->pread == smp_load_acquire(&rbuf->pwrite));

drivers/media/dvb-core/dvb_ringbuffer.c

91

avail = smp_load_acquire(&rbuf->pwrite) - rbuf->pread;

drivers/media/usb/uvc/uvc_ctrl.c

2021

if (smp_load_acquire(&dev->flush_status))

drivers/net/ethernet/hisilicon/hibmcge/hbg_txrx.c

137

u32 ntc = smp_load_acquire(&ring->ntc);

drivers/net/ethernet/hisilicon/hibmcge/hbg_txrx.c

199

u32 ntu = smp_load_acquire(&ring->ntu);

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

3632

int ltu = smp_load_acquire(&ring->last_to_use);

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

979

ntc = smp_load_acquire(&tx_spare->last_to_clean);

drivers/net/ethernet/hisilicon/hns3/hns3_enet.h

631

int begin = smp_load_acquire(&ring->next_to_clean);

drivers/net/ethernet/intel/e1000/e1000.h

190

unsigned int clean = smp_load_acquire(&(R)->next_to_clean); \

drivers/net/ethernet/marvell/octeontx2/nic/otx2_pf.c

2289

u16 htb_maj_id = smp_load_acquire(&pf->qos.maj_id);

drivers/net/ethernet/mellanox/mlx5/core/en_stats.c

2468

return NUM_QOS_SQ_STATS * smp_load_acquire(&priv->htb_max_qos_sqs);

drivers/net/ethernet/mellanox/mlx5/core/en_stats.c

2474

u16 max_qos_sqs = smp_load_acquire(&priv->htb_max_qos_sqs);

drivers/net/ethernet/mellanox/mlx5/core/en_stats.c

2489

max_qos_sqs = smp_load_acquire(&priv->htb_max_qos_sqs);

drivers/net/ethernet/mellanox/mlx5/core/en_stats.c

482

max_qos_sqs = smp_load_acquire(&priv->htb_max_qos_sqs);

drivers/net/ethernet/mellanox/mlx5/core/lib/clock.c

423

sign = smp_load_acquire(&clock_info->sign);

drivers/net/ethernet/qlogic/qed/qed_spq.c

75

if (smp_load_acquire(&comp_done->done) == 1) { /* ^^^ */

drivers/net/netdevsim/bus.c

112

if (!smp_load_acquire(&nsim_bus_dev->init))

drivers/net/netdevsim/bus.c

186

if (!smp_load_acquire(&nsim_bus_enable)) {

drivers/net/netdevsim/bus.c

236

if (!smp_load_acquire(&nsim_bus_enable)) {

drivers/net/netdevsim/bus.c

75

if (!smp_load_acquire(&nsim_bus_dev->init))

drivers/net/wireguard/queueing.c

82

struct sk_buff *tail = queue->tail, *next = smp_load_acquire(&NEXT(tail));

drivers/net/wireguard/queueing.c

89

next = smp_load_acquire(&NEXT(next));

drivers/net/wireguard/queueing.c

99

next = smp_load_acquire(&NEXT(tail));

drivers/nvme/target/tcp.c

598

queue_state = smp_load_acquire(&queue->rcv_state);

drivers/tty/n_tty.c

1694

size_t tail = smp_load_acquire(&ldata->read_tail);

drivers/tty/n_tty.c

1943

size_t head = smp_load_acquire(&ldata->commit_head);

drivers/tty/n_tty.c

2004

canon_head = smp_load_acquire(&ldata->canon_head);

drivers/tty/n_tty.c

2057

canon_head = smp_load_acquire(&ldata->canon_head);

drivers/tty/tty_buffer.c

233

while ((next = smp_load_acquire(&buf->head->next)) != NULL) {

drivers/tty/tty_buffer.c

410

next = smp_load_acquire(&head->next);

drivers/tty/tty_buffer.c

415

count = smp_load_acquire(&head->commit) - head->lookahead;

drivers/tty/tty_buffer.c

482

next = smp_load_acquire(&head->next);

drivers/tty/tty_buffer.c

486

count = smp_load_acquire(&head->commit) - head->read;

drivers/tty/tty_ldsem.c

196

if (!smp_load_acquire(&waiter.task))

drivers/usb/gadget/function/f_fs.c

1217

epfile = smp_load_acquire(&inode->i_private);

drivers/usb/gadget/function/f_mass_storage.c

595

bh && smp_load_acquire(&bh->state) >=

drivers/usb/gadget/function/f_mass_storage.c

599

bh && smp_load_acquire(&bh->state) >=

drivers/vfio/vfio_main.c

1320

if (!smp_load_acquire(&df->access_granted))

drivers/vfio/vfio_main.c

1368

if (!smp_load_acquire(&df->access_granted))

drivers/vfio/vfio_main.c

1385

if (!smp_load_acquire(&df->access_granted))

drivers/vfio/vfio_main.c

1400

if (!smp_load_acquire(&df->access_granted))

drivers/virt/acrn/ioreq.c

507

if (smp_load_acquire(&req->processed) ==

fs/afs/addr_prefs.c

469

smp_load_acquire(&alist->addr_pref_version) == preflist->version)

fs/afs/addr_prefs.c

527

smp_load_acquire(&net->address_pref_version) == alist->addr_pref_version)

fs/afs/cell.c

322

state = smp_load_acquire(&cell->state); /* vs error */

fs/afs/cell.c

336

state = smp_load_acquire(&cell->state); /* vs error */

fs/afs/cell.c

344

state = smp_load_acquire(&cell->state); /* vs error */

fs/afs/fs_operation.c

127

if (smp_load_acquire(&myself.have_lock) || /* The lock barrier */

fs/afs/fs_operation.c

99

if (smp_load_acquire(&myself.have_lock)) /* The lock barrier */

fs/afs/vl_rotate.c

49

dns_lookup_count = smp_load_acquire(&cell->dns_lookup_count);

fs/afs/vl_rotate.c

56

smp_load_acquire(&cell->dns_lookup_count)

fs/aio.c

1706

head = smp_load_acquire(&req->head);

fs/binfmt_misc.c

190

misc = smp_load_acquire(&user_ns->binfmt_misc);

fs/crypto/crypto.c

330

if (likely(smp_load_acquire(&fscrypt_bounce_page_pool)))

fs/crypto/fscrypt_private.h

448

return smp_load_acquire(&prep_key->blk_key) != NULL;

fs/crypto/fscrypt_private.h

449

return smp_load_acquire(&prep_key->tfm) != NULL;

fs/crypto/fscrypt_private.h

495

return smp_load_acquire(&prep_key->tfm) != NULL;

fs/crypto/keyring.c

302

keyring = smp_load_acquire(&sb->s_master_keys);

fs/crypto/keysetup.c

320

if (!smp_load_acquire(&mk->mk_ino_hash_key_initialized)) {

fs/d_path.c

98

const char *dname = smp_load_acquire(&name->name); /* ^^^ */

fs/dcache.c

2621

seq = smp_load_acquire(&parent->d_inode->i_dir_seq);

fs/eventpoll.c

674

whead = smp_load_acquire(&pwq->whead);

fs/eventpoll.c

861

if (!smp_load_acquire(&v->next))

fs/exec.c

1234

__set_task_comm(me, smp_load_acquire(&bprm->file->f_path.dentry->d_name.name),

fs/fuse/dev_uring.c

1089

struct fuse_ring *ring = smp_load_acquire(&fc->ring);

fs/inode.c

2382

cns = smp_load_acquire(&inode->i_ctime_nsec);

fs/inode.c

2851

cns = smp_load_acquire(&inode->i_ctime_nsec);

fs/inode.c

2920

cur = smp_load_acquire(&inode->i_ctime_nsec);

fs/locks.c

810

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

fs/namei.c

1585

flags = smp_load_acquire(&path->dentry->d_flags);

fs/namei.c

1614

flags = smp_load_acquire(&path->dentry->d_flags);

fs/namei.c

1633

unsigned flags = smp_load_acquire(&path->dentry->d_flags);

fs/namei.c

3268

if (!IS_ERR(ret) && d_flags_negative(smp_load_acquire(&ret->d_flags))) {

fs/namei.c

3299

if (!IS_ERR(ret) && d_flags_negative(smp_load_acquire(&ret->d_flags))) {

fs/namei.c

3351

if (!IS_ERR(ret) && d_flags_negative(smp_load_acquire(&ret->d_flags))) {

fs/netfs/internal.h

317

return smp_load_acquire(&cache->state);

fs/netfs/write_collect.c

228

if (!smp_load_acquire(&stream->active))

fs/nfs/dir.c

1842

smp_load_acquire(&dentry->d_fsdata)

fs/nfs/inode.c

1528

if (!(smp_load_acquire(&nfsi->cache_validity) & NFS_INO_INVALID_DATA))

fs/nfsd/nfsctl.c

1526

smp_load_acquire(&rqstp->rq_status_counter);

fs/nfsd/nfsctl.c

1562

if (smp_load_acquire(&rqstp->rq_status_counter) !=

fs/overlayfs/namei.c

219

if (!IS_ERR(ret) && d_flags_negative(smp_load_acquire(&ret->d_flags))) {

fs/pipe.c

294

unsigned int head = smp_load_acquire(&pipe->head);

fs/super.c

92

return smp_load_acquire(&sb->s_flags) & flags;

fs/xfs/libxfs/xfs_inode_fork.h

271

return smp_load_acquire(&ifp->if_needextents) != 0;

include/asm-generic/barrier.h

175

#ifndef smp_load_acquire

include/asm-generic/barrier.h

201

#ifndef smp_load_acquire

include/asm-generic/bitops/generic-non-atomic.h

140

return 1UL & (smp_load_acquire(p) >> (nr & (BITS_PER_LONG-1)));

include/linux/atomic/atomic-arch-fallback.h

2605

ret = smp_load_acquire(&(v)->counter);

include/linux/atomic/atomic-arch-fallback.h

479

ret = smp_load_acquire(&(v)->counter);

include/linux/filelock.h

250

if (likely(!(smp_load_acquire(&inode->i_opflags) & IOP_FLCTX)))

include/linux/fs.h

1147

return smp_load_acquire(&inode->i_size);

include/linux/fscache-cache.h

132

return smp_load_acquire(&cookie->state);

include/linux/fscrypt.h

241

return smp_load_acquire(fscrypt_inode_info_addr(inode));

include/linux/key.h

459

return smp_load_acquire(&key->state);

include/linux/list.h

417

struct list_head *next = smp_load_acquire(&head->next);

include/linux/lwq.h

104

smp_load_acquire(&q->ready) == NULL;

include/linux/lwq.h

122

smp_load_acquire(&q->ready) == NULL;

include/linux/lwq.h

51

return smp_load_acquire(&q->ready) == NULL && llist_empty(&q->new);

include/linux/objpool.h

130

uint32_t head = smp_load_acquire(&slot->head);

include/linux/seqlock.h

161

unsigned seq = smp_load_acquire(&s->seqcount.sequence); \

include/linux/seqlock.h

174

seq = smp_load_acquire(&s->seqcount.sequence); \

include/linux/seqlock.h

212

return smp_load_acquire(&s->sequence);

include/net/inet_sock.h

376

return smp_load_acquire(&sk->sk_state);

include/net/tcp.h

1558

return smp_load_acquire(&sk->sk_pacing_status) == SK_PACING_NEEDED;

include/net/tls.h

362

(smp_load_acquire(&sk->sk_validate_xmit_skb) ==

include/net/tls.h

507

smp_load_acquire(&sk->sk_destruct) != tls_device_sk_destruct)

include/rdma/rdmavt_cq.h

23

#define RDMA_READ_UAPI_ATOMIC(member) smp_load_acquire(&(member).val)

io_uring/io_uring.c

2581

if (unlikely(smp_load_acquire(&ctx->flags) & IORING_SETUP_R_DISABLED))

io_uring/io_uring.h

472

entries = smp_load_acquire(&rings->sq.tail) - ctx->cached_sq_head;

io_uring/kbuf.c

202

tail = smp_load_acquire(&br->tail);

io_uring/kbuf.c

258

tail = smp_load_acquire(&br->tail);

io_uring/msg_ring.c

127

if (smp_load_acquire(&target_ctx->flags) & IORING_SETUP_R_DISABLED)

io_uring/msg_ring.c

248

if (smp_load_acquire(&target_ctx->flags) & IORING_SETUP_R_DISABLED)

io_uring/poll.c

162

struct wait_queue_head *head = smp_load_acquire(&poll->head);

io_uring/poll.c

442

head = smp_load_acquire(&poll->head);

io_uring/rw.c

1377

if (!smp_load_acquire(&req->iopoll_completed))

io_uring/waitid.c

117

head = smp_load_acquire(&iw->head);

io_uring/zcrx.c

914

entries = smp_load_acquire(&ifq->rq_ring->tail) - ifq->cached_rq_head;

ipc/sem.c

426

if (!smp_load_acquire(&sma->use_global_lock)) {

kernel/bpf/bpf_struct_ops.c

1213

smp_load_acquire(&st_map->kvalue.common.state) == BPF_STRUCT_OPS_STATE_READY;

kernel/bpf/bpf_struct_ops.c

494

state = smp_load_acquire(&kvalue->common.state);

kernel/bpf/core.c

2272

DST = (SIZE)smp_load_acquire( \

kernel/bpf/ringbuf.c

319

cons_pos = smp_load_acquire(&rb->consumer_pos);

kernel/bpf/ringbuf.c

322

over_pos = smp_load_acquire(&rb->overwrite_pos);

kernel/bpf/ringbuf.c

323

prod_pos = smp_load_acquire(&rb->producer_pos);

kernel/bpf/ringbuf.c

326

prod_pos = smp_load_acquire(&rb->producer_pos);

kernel/bpf/ringbuf.c

476

cons_pos = smp_load_acquire(&rb->consumer_pos);

kernel/bpf/ringbuf.c

579

cons_pos = smp_load_acquire(&rb->consumer_pos) & rb->mask;

kernel/bpf/ringbuf.c

653

return smp_load_acquire(&rb->consumer_pos);

kernel/bpf/ringbuf.c

655

return smp_load_acquire(&rb->producer_pos);

kernel/bpf/ringbuf.c

657

return smp_load_acquire(&rb->overwrite_pos);

kernel/bpf/ringbuf.c

755

prod_pos = smp_load_acquire(&rb->producer_pos);

kernel/bpf/ringbuf.c

760

cons_pos = smp_load_acquire(&rb->consumer_pos);

kernel/bpf/ringbuf.c

766

hdr_len = smp_load_acquire(hdr);

kernel/events/core.c

8915

if (!smp_load_acquire(&event->ctx))

kernel/futex/core.c

1713

if (smp_load_acquire(&fph->state) == FR_PERCPU)

kernel/kcsan/kcsan_test.c

1474

func = smp_load_acquire(&access_kernels[idx]);

kernel/kcsan/kcsan_test.c

1498

func = smp_load_acquire(&access_kernels[idx]);

kernel/kcsan/kcsan_test.c

583

KCSAN_EXPECT_READ_BARRIER(smp_load_acquire(&test_var), false);

kernel/kcsan/kcsan_test.c

628

KCSAN_EXPECT_WRITE_BARRIER(smp_load_acquire(&test_var), false);

kernel/kcsan/kcsan_test.c

673

KCSAN_EXPECT_RW_BARRIER(smp_load_acquire(&test_var), false);

kernel/locking/locktorture.c

1118

if (!smp_load_acquire(&crcp->crc_stop)) {

kernel/locking/osq_lock.c

173

if (smp_load_acquire(&node->locked))

kernel/locking/percpu-rwsem.c

162

if (!smp_load_acquire(&wq_entry.private))

kernel/locking/rwsem.c

1074

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

kernel/rcu/rcutorture.c

2012

smp_load_acquire(&rtrcp->rtc_chkrdr) < 0 && // Pairs with smp_store_release below.

kernel/rcu/rcutorture.c

2014

!smp_load_acquire(&rtrcp_chker->rtc_assigner)) { // Pairs with smp_store_release below.

kernel/rcu/rcutorture.c

2026

if (!rtrcp_assigner || !smp_load_acquire(&rtrcp_assigner->rtc_ready))

kernel/rcu/rcutorture.c

2587

if (!smp_load_acquire(&rtorsup->rtorsu_inuse))

kernel/rcu/rcutorture.c

2647

j = smp_load_acquire(&jiffies); // Time before ->rtorsu_inuse.

kernel/rcu/rcutorture.c

2648

if (smp_load_acquire(&rtorsup->rtorsu_inuse)) {

kernel/rcu/rcutorture.c

3666

smp_load_acquire(&barrier_phase)) != lastphase ||

kernel/rcu/rcutorture.c

3900

wait_event(read_exit_wq, smp_load_acquire(&read_exit_child_stopped));

kernel/rcu/refscale.c

1254

wait_event(rt->wq, (atomic_read(&nreaders_exp) && smp_load_acquire(&rt->start_reader)) ||

kernel/rcu/refscale.c

730

x = smp_load_acquire(this_cpu_ptr(&test_acqrel));

kernel/rcu/refscale.c

743

x = smp_load_acquire(this_cpu_ptr(&test_acqrel));

kernel/rcu/srcutree.c

1074

if (smp_load_acquire(&sup->srcu_size_state) < SRCU_SIZE_WAIT_BARRIER)

kernel/rcu/srcutree.c

1324

ss_state = smp_load_acquire(&ssp->srcu_sup->srcu_size_state);

kernel/rcu/srcutree.c

1716

if (smp_load_acquire(&ssp->srcu_sup->srcu_size_state) < SRCU_SIZE_WAIT_BARRIER)

kernel/rcu/srcutree.c

1825

idx = rcu_seq_state(smp_load_acquire(&ssp->srcu_sup->srcu_gp_seq)); /* ^^^ */

kernel/rcu/srcutree.c

2159

if (!rcu_seq_state(smp_load_acquire(&ssp->srcu_sup->srcu_gp_seq_needed)) &&

kernel/rcu/srcutree.c

365

if (smp_load_acquire(&ssp->srcu_sup->srcu_size_state) != SRCU_SIZE_SMALL)

kernel/rcu/srcutree.c

368

if (smp_load_acquire(&ssp->srcu_sup->srcu_size_state) != SRCU_SIZE_SMALL) {

kernel/rcu/srcutree.c

441

if (!rcu_seq_state(smp_load_acquire(&ssp->srcu_sup->srcu_gp_seq_needed))) /*^^^*/

kernel/rcu/srcutree.c

951

ss_state = smp_load_acquire(&sup->srcu_size_state);

kernel/rcu/tasks.h

347

bool havekthread = smp_load_acquire(&rtp->kthread_ptr);

kernel/rcu/tasks.h

437

if (cpu >= smp_load_acquire(&rtp->percpu_dequeue_lim))

kernel/rcu/tasks.h

466

dequeue_limit = smp_load_acquire(&rtp->percpu_dequeue_lim);

kernel/rcu/tasks.h

550

if (rtpcp_next->cpu < smp_load_acquire(&rtp->percpu_dequeue_lim)) {

kernel/rcu/tasks.h

556

if (rtpcp_next->cpu < smp_load_acquire(&rtp->percpu_dequeue_lim)) {

kernel/rcu/tree.c

1670

done = smp_load_acquire(&rcu_state.srs_done_tail);

kernel/rcu/tree.c

2709

if (smp_load_acquire(this_cpu_ptr(&rcu_data.rcu_urgent_qs))) {

kernel/rcu/tree.c

3863

if (smp_load_acquire(&rdp->barrier_seq_snap) == gseq)

kernel/rcu/tree.c

4295

return smp_load_acquire(&rdp->beenonline);

kernel/rcu/tree_exp.h

83

int ncpus = smp_load_acquire(&rcu_state.ncpus); /* Order vs. locking. */

kernel/rcu/tree_plugin.h

1000

if (!smp_load_acquire(this_cpu_ptr(&rcu_data.rcu_urgent_qs)))

kernel/rcu/tree_plugin.h

977

if (!smp_load_acquire(this_cpu_ptr(&rcu_data.rcu_urgent_qs))) {

kernel/rcu/tree_stall.h

1013

!smp_load_acquire(&rcu_state.gp_kthread)) // Get stable kthread.

kernel/rcu/tree_stall.h

613

gp_state = smp_load_acquire(&rcu_state.gp_state);

kernel/resource.c

1271

struct inode *inode = smp_load_acquire(&iomem_inode);

kernel/resource.c

1311

return smp_load_acquire(&iomem_inode)->i_mapping;

kernel/sched/core.c

4215

if (smp_load_acquire(&p->on_cpu) &&

kernel/sched/ext.c

2493

smp_load_acquire(&cpu_rq(cpu)->scx.kick_sync) != ksyncs[cpu]) {

kernel/sched/ext.c

7351

if (smp_load_acquire(&rq->scx.flags) & SCX_RQ_CLK_VALID) {

kernel/sched/psi.c

1491

t = smp_load_acquire(trigger_ptr);

kernel/smp.c

275

cpu_cur_csd = smp_load_acquire(&per_cpu(cur_csd, cpux)); /* Before func and info. */

kernel/taskstats.c

571

stats = smp_load_acquire(&sig->stats);

kernel/time/tick-sched.c

72

if (ktime_before(now, smp_load_acquire(&tick_next_period)))

kernel/trace/trace_probe.h

276

return smp_load_acquire(&tp->event->flags);

kernel/trace/trace_sched_switch.c

328

int *map = smp_load_acquire(&tgid_map);

lib/llist.c

35

entry = smp_load_acquire(&head->first);

lib/llist.c

63

entry = smp_load_acquire(&head->first);

mm/filemap.c

1318

flags = smp_load_acquire(&wait->flags);

mm/filemap.c

1445

flags = smp_load_acquire(&wait->flags);

mm/kasan/kasan_test_c.c

774

KUNIT_EXPECT_KASAN_FAIL_READ(test, smp_load_acquire(i_unsafe));

mm/kfence/core.c

1083

if (!smp_load_acquire(&kfence_metadata))

mm/mmu_notifier.c

981

subscriptions = smp_load_acquire(&mm->notifier_subscriptions);

mm/page_owner.c

869

stack = smp_load_acquire(&stack_list);

mm/swap.c

835

this_gen = smp_load_acquire(&lru_drain_gen);

net/ipv4/inet_diag.c

283

icsk_pending = smp_load_acquire(&icsk->icsk_pending);

net/ipv4/tcp_bpf.c

646

if (unlikely(ops != smp_load_acquire(&tcpv6_prot_saved))) {

net/ipv4/tcp_ipv4.c

2862

icsk_pending = smp_load_acquire(&icsk->icsk_pending);

net/ipv4/tcp_output.c

1331

unsigned long flags = smp_load_acquire(&sk->sk_tsq_flags);

net/ipv4/tcp_output.c

1403

oval = smp_load_acquire(&sk->sk_tsq_flags);

net/ipv4/tcp_timer.c

370

if (!(smp_load_acquire(&icsk->icsk_ack.pending) & ICSK_ACK_TIMER) &&

net/ipv4/tcp_timer.c

734

if (!smp_load_acquire(&inet_csk(sk)->icsk_pending))

net/ipv4/udp_bpf.c

139

if (unlikely(ops != smp_load_acquire(&udpv6_prot_saved))) {

net/ipv6/tcp_ipv6.c

2147

icsk_pending = smp_load_acquire(&icsk->icsk_pending);

net/netfilter/nf_conntrack_core.c

112

if (likely(smp_load_acquire(&nf_conntrack_locks_all) == false))

net/netfilter/nft_lookup.c

61

return smp_load_acquire(&net->nft.base_seq);

net/rxrpc/ar-internal.h

1118

return smp_load_acquire(&call->_state);

net/rxrpc/ar-internal.h

1164

return smp_load_acquire(&conn->state) == RXRPC_CONN_ABORTED;

net/rxrpc/call_accept.c

263

call_head = smp_load_acquire(&b->call_backlog_head);

net/rxrpc/call_accept.c

266

conn_head = smp_load_acquire(&b->conn_backlog_head);

net/rxrpc/call_accept.c

270

peer_head = smp_load_acquire(&b->peer_backlog_head);

net/rxrpc/call_event.c

220

send_top = smp_load_acquire(&call->send_top);

net/rxrpc/call_event.c

315

abort_code = smp_load_acquire(&call->send_abort);

net/sunrpc/xprtmultipath.c

422

old = smp_load_acquire(cursor);

net/tls/tls_main.c

978

unlikely(prot != smp_load_acquire(&saved_tcpv6_prot))) {

net/tls/tls_main.c

990

unlikely(prot != smp_load_acquire(&saved_tcpv4_prot))) {

net/unix/af_unix.c

1901

addr = smp_load_acquire(&unix_sk(sk)->addr);

net/unix/af_unix.c

2544

struct unix_address *addr = smp_load_acquire(&unix_sk(sk)->addr);

net/unix/af_unix.c

3266

if (!smp_load_acquire(&unix_sk(sk)->addr))

net/unix/diag.c

19

struct unix_address *addr = smp_load_acquire(&unix_sk(sk)->addr);

net/unix/unix_bpf.c

126

if (unlikely(ops != smp_load_acquire(&unix_dgram_prot_saved))) {

net/unix/unix_bpf.c

138

if (unlikely(ops != smp_load_acquire(&unix_stream_prot_saved))) {

net/vmw_vsock/vsock_bpf.c

137

if (unlikely(ops != smp_load_acquire(&vsock_prot_saved))) {

net/xdp/xsk_queue.h

317

q->cached_prod = smp_load_acquire(&q->ring->producer); /* C, matches B */

rust/helpers/atomic_ext.c

14

return smp_load_acquire(ptr);

rust/helpers/atomic_ext.c

24

return smp_load_acquire(ptr);

security/apparmor/af_unix.c

113

addr = smp_load_acquire(&u->addr);

security/lsm_audit.c

320

addr = smp_load_acquire(&u->addr);

security/selinux/include/security.h

115

return smp_load_acquire(&selinux_state.initialized);

security/selinux/ss/services.c

2424

sid = smp_load_acquire(&c->sid[index]);

security/selinux/ss/sidtab.c

228

u32 count = smp_load_acquire(&s->count);

tools/include/asm/barrier.h

58

#ifndef smp_load_acquire

tools/include/linux/ring_buffer.h

59

return smp_load_acquire(&base->data_head);

tools/lib/bpf/ringbuf.c

243

cons_pos = smp_load_acquire(r->consumer_pos);

tools/lib/bpf/ringbuf.c

246

prod_pos = smp_load_acquire(r->producer_pos);

tools/lib/bpf/ringbuf.c

249

len = smp_load_acquire(len_ptr);

tools/lib/bpf/ringbuf.c

376

return smp_load_acquire(r->consumer_pos);

tools/lib/bpf/ringbuf.c

384

return smp_load_acquire(r->producer_pos);

tools/lib/bpf/ringbuf.c

593

cons_pos = smp_load_acquire(rb->consumer_pos);

tools/lib/bpf/ringbuf.c

595

prod_pos = smp_load_acquire(rb->producer_pos);

tools/testing/selftests/bpf/benchs/bench_ringbufs.c

354

cons_pos = smp_load_acquire(r->consumer_pos);

tools/testing/selftests/bpf/benchs/bench_ringbufs.c

357

prod_pos = smp_load_acquire(r->producer_pos);

tools/testing/selftests/bpf/benchs/bench_ringbufs.c

360

len = smp_load_acquire(len_ptr);

tools/testing/selftests/kvm/dirty_log_test.c

328

return smp_load_acquire(&gfn->flags) == KVM_DIRTY_GFN_F_DIRTY;

virt/kvm/dirty_ring.c

102

return smp_load_acquire(&gfn->flags) & KVM_DIRTY_GFN_F_RESET;