smp_load_acquire

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/clock.c

54

u64 bank = smp_load_acquire(&clock->cur);

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

902

!smp_load_acquire(&has_version_negotiated)) {

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

270

hyp_vcpu = smp_load_acquire(&hyp_vm->vcpus[vcpu_idx]);

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

628

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

arch/x86/events/core.c

2904

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

arch/x86/include/asm/tlbflush.h

278

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

arch/x86/kvm/mmu.h

261

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

arch/x86/kvm/mmu/mmu.c

2018

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

3906

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

block/blk-crypto-fallback.c

631

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

113

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

drivers/dma/switchtec_dma.c

430

phase_tag = smp_load_acquire(&ce->phase_tag);

drivers/firmware/qcom/qcom_scm.c

2562

return !!smp_load_acquire(&__scm);

drivers/firmware/samsung/exynos-acpm.c

339

if (smp_load_acquire(&achan->rx_data[seqnum - 1].completed)) {

drivers/gpu/drm/msm/msm_perfcntr.c

24

(CIRC_CNT_TO_END(smp_load_acquire(&(stream)->fifo.head), (stream)->fifo.tail, (stream)->fifo_size))

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/greybus/gb-beagleplay.c

368

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

drivers/infiniband/core/ib_core_uverbs.c

516

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/hw/mlx5/main.c

3339

if (smp_load_acquire(&devr->c0))

drivers/infiniband/hw/mlx5/main.c

3383

if (smp_load_acquire(&devr->s1))

drivers/infiniband/hw/mlx5/umr.c

150

if (smp_load_acquire(&dev->umrc.qp))

drivers/infiniband/sw/rdmavt/qp.c

1926

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

2260

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

5496

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

2195

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

3645

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

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

993

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

2285

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

drivers/net/ethernet/mellanox/mlx5/core/en.h

992

return smp_load_acquire(&priv->stats_nch);

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

2497

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

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

2503

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

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

2518

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

424

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/platform/x86/intel/pmc/ssram_telemetry.c

343

state = smp_load_acquire(&pmc_ssram_state[pmc_idx]);

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

240

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

drivers/tty/tty_buffer.c

417

next = smp_load_acquire(&head->next);

drivers/tty/tty_buffer.c

422

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

drivers/tty/tty_buffer.c

489

next = smp_load_acquire(&head->next);

drivers/tty/tty_buffer.c

493

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

1220

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

1357

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

drivers/vfio/vfio_main.c

1405

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

drivers/vfio/vfio_main.c

1422

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

drivers/vfio/vfio_main.c

1437

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

324

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

fs/afs/cell.c

338

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

fs/afs/cell.c

346

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

1760

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/keyring.c

281

keyring = smp_load_acquire(&sb->s_master_keys);

fs/crypto/keysetup.c

351

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

2777

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

fs/eventpoll.c

1118

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

fs/eventpoll.c

906

whead = smp_load_acquire(&pwq->whead);

fs/exec.c

1253

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

fs/fuse/dev_uring.c

1176

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

fs/fuse/dev_uring_i.h

172

return ring && smp_load_acquire(&ring->ready);

fs/fuse/fuse_dev_i.h

347

return smp_load_acquire(&fud->chan);

fs/inode.c

2441

cns = smp_load_acquire(&inode->i_ctime_nsec);

fs/inode.c

2909

cns = smp_load_acquire(&inode->i_ctime_nsec);

fs/inode.c

2978

cur = smp_load_acquire(&inode->i_ctime_nsec);

fs/locks.c

810

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

fs/namei.c

1590

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

fs/namei.c

1619

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

fs/namei.c

1638

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

fs/namei.c

3280

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

fs/namei.c

3315

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

fs/namei.c

3375

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

fs/netfs/internal.h

332

return smp_load_acquire(&cache->state);

fs/netfs/locking.c

236

if (smp_load_acquire(&waiter.waiter) == NULL)

fs/netfs/read_retry.c

103

next = smp_load_acquire(&next->next);

fs/netfs/write_collect.c

231

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

fs/netfs/write_retry.c

77

next = smp_load_acquire(&next->next);

fs/nfs/dir.c

1840

smp_load_acquire(&dentry->d_fsdata)

fs/nfs/inode.c

1511

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

fs/nfsd/nfsctl.c

1542

smp_load_acquire(&rqstp->rq_status_counter);

fs/nfsd/nfsctl.c

1578

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

386

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

fs/smb/client/file.c

3296

tlw = smp_load_acquire(&cifsInode->time_last_write);

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

257

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

include/linux/fs.h

1143

return smp_load_acquire(&inode->i_size);

include/linux/fscache-cache.h

132

return smp_load_acquire(&cookie->state);

include/linux/fscrypt.h

243

return smp_load_acquire(fscrypt_inode_info_addr(inode));

include/linux/key.h

459

return smp_load_acquire(&key->state);

include/linux/list.h

440

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

include/linux/list.h

680

struct list_head *pos__ = 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/netfs.h

516

remote_i_size = smp_load_acquire(&ictx->_remote_i_size);

include/linux/netfs.h

591

zero_point = smp_load_acquire(&ictx->_zero_point);

include/linux/netfs.h

674

*i_size = smp_load_acquire(&inode->i_size);

include/linux/netfs.h

676

*remote_i_size = smp_load_acquire(&ictx->_remote_i_size);

include/linux/netfs.h

678

*zero_point = smp_load_acquire(&ictx->_zero_point);

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

1616

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

include/net/tcp.h

383

if (unlikely(smp_load_acquire(&sk->sk_tsq_flags) & TCP_DEFERRED_ALL))

include/net/tls.h

366

(smp_load_acquire(&sk->sk_validate_xmit_skb) ==

include/net/tls.h

511

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)

include/rv/da_monitor.h

127

return smp_load_acquire(&da_mon->monitoring);

include/rv/ha_monitor.h

315

curr_state = smp_load_acquire(&ha_mon->da_mon.curr_state);

io_uring/io_uring.c

2615

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

io_uring/io_uring.h

474

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

263

tail = smp_load_acquire(&br->tail);

io_uring/msg_ring.c

146

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

io_uring/msg_ring.c

268

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

446

head = smp_load_acquire(&poll->head);

io_uring/rw.c

1385

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

io_uring/waitid.c

117

head = smp_load_acquire(&iw->head);

io_uring/zcrx.c

1087

entries = smp_load_acquire(&rq->ring->tail) - rq->cached_head;

ipc/sem.c

426

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

kernel/bpf/bpf_struct_ops.c

1251

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

2348

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

8984

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

kernel/futex/core.c

1729

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/liveupdate/luo_flb.c

92

if (smp_load_acquire(&private->initialized))

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

1102

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

kernel/rcu/rcutorture.c

2097

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

kernel/rcu/rcutorture.c

2099

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

kernel/rcu/rcutorture.c

2111

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

kernel/rcu/rcutorture.c

2672

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

kernel/rcu/rcutorture.c

2732

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

kernel/rcu/rcutorture.c

2733

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

kernel/rcu/rcutorture.c

3751

smp_load_acquire(&barrier_phase)) != lastphase ||

kernel/rcu/rcutorture.c

3985

wait_event(read_exit_wq, smp_load_acquire(&read_exit_child_stopped));

kernel/rcu/refscale.c

1244

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

kernel/rcu/refscale.c

720

x = smp_load_acquire(this_cpu_ptr(&test_acqrel));

kernel/rcu/refscale.c

733

x = smp_load_acquire(this_cpu_ptr(&test_acqrel));

kernel/rcu/srcutree.c

1072

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

kernel/rcu/srcutree.c

1322

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

949

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

438

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

kernel/rcu/tasks.h

467

dequeue_limit = smp_load_acquire(&rtp->percpu_dequeue_lim);

kernel/rcu/tasks.h

551

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

kernel/rcu/tasks.h

557

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

kernel/rcu/tree.c

1680

done = smp_load_acquire(&rcu_state.srs_done_tail);

kernel/rcu/tree.c

2737

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

kernel/rcu/tree.c

3892

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

kernel/rcu/tree.c

4324

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

1012

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

kernel/rcu/tree_stall.h

612

gp_state = smp_load_acquire(&rcu_state.gp_state);

kernel/rcu/update.c

555

while (smp_load_acquire(&t->rcu_trivial_preempt_nesting))

kernel/resource.c

1272

struct inode *inode = smp_load_acquire(&iomem_inode);

kernel/resource.c

1312

return smp_load_acquire(&iomem_inode)->i_mapping;

kernel/sched/core.c

4378

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

kernel/sched/ext/ext.c

10342

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

kernel/sched/ext/ext.c

3158

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

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

575

stats = smp_load_acquire(&sig->stats);

kernel/time/tick-sched.c

72

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

kernel/trace/simple_ring_buffer.c

102

link = (unsigned long)smp_load_acquire(&head->link.prev->next);

kernel/trace/trace_probe.h

277

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

1094

if (!smp_load_acquire(&kfence_metadata))

mm/mmu_notifier.c

1029

subscriptions = smp_load_acquire(&mm->notifier_subscriptions);

mm/page_owner.c

869

stack = smp_load_acquire(&stack_list);

mm/swap.c

886

this_gen = smp_load_acquire(&lru_drain_gen);

net/can/isotp.c

1045

u32 old_state = smp_load_acquire(&so->tx.state);

net/can/isotp.c

1352

if (smp_load_acquire(&so->tx.state) == ISOTP_SHUTDOWN &&

net/can/isotp.c

243

u32 state = smp_load_acquire(&so->tx.state);

net/ipv4/inet_diag.c

283

icsk_pending = smp_load_acquire(&icsk->icsk_pending);

net/ipv4/tcp_bpf.c

660

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

net/ipv4/tcp_ipv4.c

2786

icsk_pending = smp_load_acquire(&icsk->icsk_pending);

net/ipv4/tcp_output.c

1339

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

net/ipv4/tcp_output.c

1410

oval = smp_load_acquire(&sk->sk_tsq_flags);

net/ipv4/tcp_timer.c

371

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

net/ipv4/tcp_timer.c

735

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

net/ipv4/udp_bpf.c

146

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

net/ipv6/tcp_ipv6.c

2145

icsk_pending = smp_load_acquire(&icsk->icsk_pending);