atomic_load_relaxed
#define _PROP_ATOMIC_LOAD(x) atomic_load_relaxed(x)
old = atomic_load_relaxed(&self->pt_cancel);
if (__predict_false(atomic_load_relaxed(&self->pt_cancel) &
(atomic_load_relaxed(&self->pt_cancel) &
old = atomic_load_relaxed(&thread->pt_cancel);
old = atomic_load_relaxed(&self->pt_cancel);
__predict_false(atomic_load_relaxed(&(id)->pt_cancel) & \
if (__predict_false(atomic_load_relaxed(&self->pt_cancel) &
!(cancel = atomic_load_relaxed(&self->pt_cancel) &
if (atomic_load_relaxed(&pp->pp_pv.pv_pmap) == NULL &&
atomic_load_relaxed(&pp->pp_pv.pv_next) == NULL) {
KASSERT(atomic_load_relaxed(&pp->pp_pv.pv_pmap) == NULL);
KASSERT(atomic_load_relaxed(&pp->pp_pv.pv_next) == NULL);
const pt_entry_t opte = atomic_load_relaxed(ptep);
if (insn_count > atomic_load_relaxed(&ts_insns_max.ev_count)) {
KASSERT(atomic_load_relaxed(&pmap->pm_count) > 0);
opte = atomic_load_relaxed(pv->pv_pte);
opte = atomic_load_relaxed(l3pte);
opte = atomic_load_relaxed(pte);
const pt_entry_t opte = atomic_load_relaxed(pte);
opte = atomic_load_relaxed(pte);
KASSERT(atomic_load_relaxed(&pmap->pm_count) > 1);
opte = atomic_load_relaxed(pte);
return (uint8_t)atomic_load_relaxed(addr);
if (atomic_load_relaxed(&__ci->ci_ipis) != 0) { \
atomic_load_relaxed(&(pg)->mdpage.pvh_physpgrefs)
if (atomic_load_relaxed(&sc->sc_task_thread) == curlwp)
if (atomic_load_relaxed(&sc->sc_task_thread) == curlwp)
if (atomic_load_relaxed(&sc->sc_polling) ||
if (atomic_load_relaxed(&sc->sc_task_thread) == curlwp)
if (atomic_load_relaxed(&sc->sc_is.is_func) != NULL) {
if (atomic_load_relaxed(&sc->sc_task_thread) == curlwp)
if ((atomic_load_relaxed(&ci->ci_request_ipis) & ipi_mask) == 0)
if ((atomic_load_relaxed(&ci->ci_request_ipis) & ipi_mask) == 0)
pt_entry_t opte = atomic_load_relaxed(ptep);
opte = atomic_load_relaxed(ptep);
KASSERT(atomic_load_relaxed(&idt_allocmap[vec]) == 1);
KASSERT(atomic_load_relaxed(&idt_allocmap[vec]) == 1);
n = atomic_load_relaxed(&n->n_next)) {
if (atomic_load_relaxed(&old_pp->pp_pte.pte_ptp) == ptp &&
atomic_load_relaxed(&old_pp->pp_pte.pte_va) == va) {
if (atomic_load_relaxed(&pp->pp_pte.pte_ptp) == ptp &&
atomic_load_relaxed(&pp->pp_pte.pte_va) == va) {
sum = (uintptr_t)atomic_load_relaxed(&pp->pp_pte.pte_va);
sum |= (uintptr_t)atomic_load_relaxed(&pp->pp_pte.pte_ptp);
sum |= (uintptr_t)atomic_load_relaxed(&pp->pp_pvlist.lh_first);
KASSERT(atomic_load_relaxed(&pp->pp_pte.pte_va) == 0);
KASSERT(atomic_load_relaxed(&pp->pp_pte.pte_ptp) == NULL);
KASSERT(atomic_load_relaxed(&pp->pp_pvlist.lh_first) == NULL);
if (atomic_load_relaxed(&pmap->pm_gc_ptp.lh_first) == NULL) {
sel = atomic_load_relaxed(&pmap->pm_ldt_sel);
ldt = atomic_load_relaxed(&pmap->pm_ldt);
uintptr_t v = atomic_load_relaxed(&(tp)->tp_store[TP_DONE]); \
KASSERT(atomic_load_relaxed(&pmap_tlb_packet) != ts);
} while (atomic_load_relaxed(&pmap_tlb_packet) != NULL);
#define TP_GET_DONE(tp) (atomic_load_relaxed(&(tp)->tp_store[TP_DONE]) & 1)
si.procs = atomic_load_relaxed(&nprocs);
si.procs = atomic_load_relaxed(&nprocs);
o = atomic_load_relaxed(p);
dying = atomic_load_relaxed(&file->dying);
tp = atomic_load_relaxed(&constty);
if (atomic_load_relaxed(&sc->sc_async) != NULL) {
if (atomic_load_relaxed(&sc->sc_state) & UHID_IMMED) {
if (atomic_load_relaxed(&sc->sc_rnddisabled))
if ((id = atomic_load_relaxed(&lockstat_probemap[LS_COMPRESS(flags)]))
if ((flags & atomic_load_relaxed(&lockstat_dev_enabled)) != flags ||
if (atomic_load_relaxed(&lockstat_dev_enabled)) {
if (!atomic_load_relaxed(&lockstat_dev_enabled))
#define LOCKSTAT_ENTER(name) name = atomic_load_relaxed(&lockstat_enabled)
if (atomic_load_relaxed(&nmachines) > 0)
KASSERT(atomic_load_relaxed(&nvmm_suspending));
if (__predict_false(atomic_load_relaxed(&nvmm_suspending))) {
ncpus = atomic_load_relaxed(&mach->ncpus);
atomic_load_relaxed(&sc->sc_debuglevel) >= 2)
if (atomic_load_relaxed(&sc->sc_debuglevel) >= 1)
dbg = atomic_load_relaxed(&sc->sc_debuglevel);
if (atomic_load_relaxed(&sc->sc_debuglevel) >= 3)
dbg = atomic_load_relaxed(&sc->sc_debuglevel);
atomic_load_relaxed(&sc->sc_debuglevel) >= 1) {
atomic_load_relaxed(&sc->sc_debuglevel) >= 1) {
dbg = atomic_load_relaxed(&sc->sc_debuglevel);
if (atomic_load_relaxed(&sc->sc_debuglevel) >= 3) {
if (atomic_load_relaxed(&work->added) != 0)
atomic_load_relaxed(&(ev)->ev_count) + 1)
atomic_load_relaxed(&(ev)->ev_count) + (val))
atomic_store_relaxed(p, atomic_load_relaxed(p) + (delta))
atomic_load_relaxed(p)
atomic_load_relaxed(&((evp)->ev_count))
atomic_load_relaxed(&((evp)->ev_count)) + (val))
return atomic_load_relaxed(&sc->sc_dying);
u_int cnconsout = atomic_load_relaxed(&cn->cn_cons_out);
while(!db_active && atomic_load_relaxed(&cn->cn_sending) == 1)
while (atomic_load_relaxed(&cn->cn_sending) == 1)
u_int cnconsout = atomic_load_relaxed(&cn->cn_cons_out);
KASSERT(db_active || atomic_load_relaxed(&cn->cn_sending) == 1);
u_int consout = atomic_load_relaxed(&cn->cn_cons_out);
KASSERT(db_active || atomic_load_relaxed(&cn->cn_sending) == 1);
if (atomic_load_relaxed(&usb_async_proc) != NULL) {
if ((proc = atomic_load_relaxed(&usb_async_proc)) != NULL)
return atomic_load_relaxed(&un->un_pri->unp_dying);
npages = atomic_load_relaxed(&vp->v_uobj.uo_npages);
if ((tflags | atomic_load_relaxed(&node->tn_tflags)) == 0) {
cur = atomic_load_relaxed(&node->tn_tflags);
iflag = atomic_load_relaxed(&vp->v_iflag);
if (__predict_true(atomic_load_relaxed(&C->needed) == 0))
return atomic_load_relaxed(&hardclock_ticks);
atomic_load_relaxed(&hardclock_ticks) + 1);
if (__predict_false(atomic_load_relaxed(&E->bitsneeded) ||
atomic_load_relaxed(&entropy_depletion)) &&
cpu_bitspending = atomic_load_relaxed(&ec->ec_bitspending);
cpu_samplespending = atomic_load_relaxed(&ec->ec_samplespending);
if (__predict_true(!atomic_load_relaxed(&entropy_depletion)) ||
if (__predict_false(atomic_load_relaxed(&entropy_depletion)) &&
if (__predict_true(atomic_load_relaxed(&E->bitsneeded) == 0 ||
atomic_load_relaxed(&E->samplesneeded) == 0) &&
__predict_true(!atomic_load_relaxed(&entropy_depletion)))
if (atomic_load_relaxed(&entropy_depletion))
flags = atomic_load_relaxed(&rs->flags);
if (!atomic_load_relaxed(&entropy_collection) ||
cpu_nbits = atomic_load_relaxed(&rc->rc_entropybits);
urs->flags = atomic_load_relaxed(&rs->flags);
atomic_load_relaxed(&rc->rc_timesamples));
atomic_load_relaxed(&rc->rc_datasamples));
if (!atomic_load_relaxed(&entropy_collection))
return atomic_load_relaxed(&E->epoch);
return atomic_load_relaxed(&E->bitsneeded) == 0;
if (__predict_true(atomic_load_relaxed(&E->bitsneeded) == 0) &&
__predict_true(!atomic_load_relaxed(&entropy_depletion)) &&
return __predict_false(atomic_load_relaxed(&fileassoc_global.inuse));
return atomic_load_relaxed(&ci->ci_heartbeat_suspend);
unsigned count = atomic_load_relaxed(&curcpu()->ci_heartbeat_count);
if (atomic_load_relaxed(&panicstr) != NULL)
if (atomic_load_relaxed(&ack))
if (atomic_load_relaxed(&ci->ci_heartbeat_suspend))
period_ticks = atomic_load_relaxed(&heartbeat_max_period_ticks);
period_secs = atomic_load_relaxed(&heartbeat_max_period_secs);
cache = atomic_load_relaxed(&curcpu()->ci_heartbeat_uptime_cache);
atomic_load_relaxed(&curcpu()->ci_heartbeat_uptime_stamp);
d = uptime - atomic_load_relaxed(&patient->ci_heartbeat_uptime_cache);
atomic_load_relaxed(&patient->ci_heartbeat_suspend) == 0)
holder = atomic_load_relaxed(&kernel_lock_holder);
then = atomic_load_relaxed(&kernel_lock_last_report);
if (__predict_true(atomic_load_relaxed(&l->l_mutex) == old))
while (__predict_false(atomic_load_relaxed(&l->l_mutex) != old)) {
if ((f = atomic_load_relaxed(&l->l_flag) & LW_USERRET) == 0) {
call_hook = atomic_load_relaxed(hooked);
return (atomic_load_relaxed(&ci->ci_biglock_wanted) != l);
if (__predict_false(atomic_load_relaxed(&l->l_proc) != p)) {
atomic_load_relaxed(&spc->spc_mcount) + 1);
atomic_load_relaxed(&spc->spc_mcount) - 1);
if (atomic_load_relaxed(&spc->spc_mcount) < (gentle ? min_catch : 1) ||
if (atomic_load_relaxed(&tspc->spc_mcount) != 0 &&
atomic_load_relaxed(&tspc->spc_mcount) < min_catch) {
flag = atomic_load_relaxed(&l->l_flag);
hi = atomic_load_relaxed(&time__second32.hi);
lo = atomic_load_relaxed(&time__second32.lo);
} while (hi != atomic_load_relaxed(&time__second32.hi));
hi = atomic_load_relaxed(&time__uptime32.hi);
lo = atomic_load_relaxed(&time__uptime32.lo);
} while (hi != atomic_load_relaxed(&time__uptime32.hi));
return atomic_load_relaxed(&time__uptime32.lo);
while ((gen = atomic_load_relaxed(&timebase.gen)) & 1)
} while (gen != atomic_load_relaxed(&timebase.gen));
while (0 < atomic_load_relaxed(&job->job_refcnt))
KASSERT(0 < atomic_load_relaxed(&job->job_refcnt));
dolock = l->l_mutex != atomic_load_relaxed(&owner->l_mutex);
if (cur->l_mutex != atomic_load_relaxed(&l->l_mutex)) {
dolock = (atomic_load_relaxed(&l->l_mutex) ==
KASSERT(atomic_load_relaxed(&ucas_critical_pausing_cpus) > 0);
if (bmajor < 0 || bmajor >= atomic_load_relaxed(&max_bdevsws))
if (cmajor < 0 || cmajor >= atomic_load_relaxed(&max_cdevsws))
if (atomic_load_relaxed(&curbdevsw[bmajor]) == bdev)
if (atomic_load_relaxed(&curcdevsw[cmajor]) == cdev)
args->nfaults = atomic_load_relaxed(&fault_global.nfaults);
args->nfaults = atomic_load_relaxed(&f->nfaults);
if (atomic_load_relaxed(&f->oneshot)) {
if (__predict_true(atomic_load_relaxed(&f->nfaults) > 0))
if (__predict_false(cnt % atomic_load_relaxed(&f->nth) == 0)) {
if (atomic_load_relaxed(&ci->ci_ipipend[i]) == 0) {
KASSERT(atomic_load_relaxed(&msg->_pending) < ncpu);
if (atomic_load_relaxed(&kd->enabled)) {
v = atomic_load_relaxed(&pcq->pcq_pc);
const uint32_t v = atomic_load_relaxed(&pcq->pcq_pc);
v = atomic_load_relaxed(&pcq->pcq_pc);
v = atomic_load_relaxed(&pcq->pcq_pc);
for (o = atomic_load_relaxed(head);; o = n) {
n = atomic_load_relaxed(head);
n = atomic_load_relaxed(&o->pcg_next);
for (o = atomic_load_relaxed(head);; o = n) {
n = atomic_load_relaxed(head);
for (o = atomic_load_relaxed(head);; o = n) {
n = atomic_load_relaxed(head);
return (atomic_load_relaxed(&node->state) & NODE_LOCKED) != 0;
s = atomic_load_relaxed(&node->state);
uint32_t s = atomic_load_relaxed(&node->state) & ~NODE_LOCKED;
ASSERT((atomic_load_relaxed(&node->state) & NODE_DELETED) == 0);
ASSERT(atomic_load_relaxed(&node->slots[slot]) == THMAP_NULL);
ASSERT(NODE_COUNT(atomic_load_relaxed(&node->state)) < LEVEL_SIZE);
atomic_load_relaxed(&node->state) + 1);
ASSERT((atomic_load_relaxed(&node->state) & NODE_DELETED) == 0);
ASSERT(atomic_load_relaxed(&node->slots[slot]) != THMAP_NULL);
ASSERT(NODE_COUNT(atomic_load_relaxed(&node->state)) > 0);
ASSERT(NODE_COUNT(atomic_load_relaxed(&node->state)) <= LEVEL_SIZE);
atomic_load_relaxed(&node->state) - 1);
if (atomic_load_relaxed(&thmap->root[i])) {
if (atomic_load_relaxed(&thmap->root[i])) {
if (atomic_load_relaxed(&parent->state) & NODE_DELETED) {
if (__predict_false(atomic_load_relaxed(&node->state) & NODE_DELETED)) {
target = atomic_load_relaxed(&node->slots[*slot]);
target = atomic_load_relaxed(&parent->slots[slot]); // tagged offset
ASSERT(THMAP_NODE(thmap, atomic_load_relaxed(&parent->slots[slot]))
NODE_COUNT(atomic_load_relaxed(&parent->state)) == 0) {
ASSERT(atomic_load_relaxed(&node->state) == NODE_LOCKED);
ASSERT((atomic_load_relaxed(&parent->state) & NODE_DELETED)
atomic_load_relaxed(&node->state) | NODE_DELETED);
atomic_load_relaxed(&parent->slots[slot])) == node);
if (NODE_COUNT(atomic_load_relaxed(&parent->state)) == 0) {
atomic_load_relaxed(&thmap->root[rslot]);
atomic_load_relaxed(&parent->state) | NODE_DELETED);
head = atomic_load_relaxed(&thmap->gc_list);
desired = atomic_load_relaxed(&vm->vm_maxbusytag);
current = atomic_load_relaxed(&vm->vm_hashsize);
KASSERT((atomic_load_relaxed(&fp->f_flag) & FHASLOCK) == 0);
KASSERT(atomic_load_relaxed(&f->fx_refcnt) == 0);
refcnt = atomic_load_relaxed(&f->fx_refcnt);
refcnt = atomic_load_relaxed(&f->fx_refcnt);
refcnt = atomic_load_relaxed(&f->fx_refcnt);
KASSERT(atomic_load_relaxed(&f->fx_refcnt) != 0);
KASSERT(atomic_load_relaxed(&f0->fx_refcnt) != 0);
KASSERT(*fp == NULL || atomic_load_relaxed(&(*fp)->fx_refcnt) != 0);
KASSERT(error || atomic_load_relaxed(&(*fp)->fx_refcnt) != 0);
if (atomic_load_relaxed(&bp->cnt) == 0 &&
(atomic_load_relaxed(&rpipe->pipe_state) & PIPE_EOF) == 0)
ctp = atomic_load_relaxed(&constty);
KASSERT(atomic_load_relaxed(&constty) == ctp ||
atomic_load_relaxed(&constty) == NULL);
old = atomic_load_relaxed(&tp->t_refcnt);
while (lock != atomic_load_relaxed(&so->so_lock)) {
if (__predict_false(lock != atomic_load_relaxed(&so->so_lock)))
if (__predict_false(lock != atomic_load_relaxed(&so->so_lock)))
if (__predict_false(lock != atomic_load_relaxed(&so->so_lock)))
atomic_load_relaxed(&VNODE_TO_VIMPL(vp)->vi_nc_mode) != VNOVAL) {
uint32_t cur = atomic_load_relaxed(&nchcpu->cur.f); \
lrulist = atomic_load_relaxed(&ncp->nc_lrulist);
lrulist = atomic_load_relaxed(&ncp->nc_lrulist);
total = atomic_load_relaxed(&cache_lru.count[LRU_ACTIVE]);
total += atomic_load_relaxed(&cache_lru.count[LRU_INACTIVE]);
chrooted = (atomic_load_relaxed(&cwdi->cwdi_rdir) != NULL);
use = atomic_load_relaxed(&vp->v_usecount);
for (use = atomic_load_relaxed(&vp->v_usecount);; use = next) {
for (use = atomic_load_relaxed(&vp->v_usecount);; use = next) {
return atomic_load_relaxed(&vp->v_usecount) & VUSECOUNT_MASK;
enum vnode_state vstate = atomic_load_relaxed(&vip->vi_state);
bool gated = (atomic_load_relaxed(&vp->v_usecount) & VUSECOUNT_GATE);
for (use = atomic_load_relaxed(&vp->v_usecount);; use = next) {
for (use = atomic_load_relaxed(&vp->v_usecount);; use = next) {
next = atomic_load_relaxed(&vp->v_usecount);
use = atomic_load_relaxed(&vp->v_usecount);
iflag = atomic_load_relaxed(&vp->v_iflag);
atomic_load_relaxed(&nprocs),
sbp->f_ffree = maxproc - atomic_load_relaxed(&nprocs); /* approx */
sbp->f_favail = maxproc - atomic_load_relaxed(&nprocs); /* approx */
iocnt = atomic_load_relaxed(&sn->sn_dev->sd_iocnt);
iocnt = atomic_load_relaxed(&sd->sd_iocnt);
if (__predict_true(atomic_load_relaxed(&sd->sd_iocnt) == 0))
while (atomic_load_relaxed(&sd->sd_iocnt) > 0)
rps_hash = atomic_load_relaxed(ðer_pktq_rps_hash_p);
rps_hash = atomic_load_relaxed(ðer_pktq_rps_hash_p);
last_activity = atomic_load_relaxed(&sp->pp_last_activity);
last_receive = atomic_load_relaxed(&sp->pp_last_receive);
rps_hash = atomic_load_relaxed(&sppp_pktq_rps_hash_p);
rps_hash = atomic_load_relaxed(&sppp_pktq_rps_hash_p);
return atomic_load_relaxed(&sp->pp_connecting);
return atomic_load_relaxed(&sp->pp_ondemand);
if (__predict_false(atomic_load_relaxed(&wgs->wgs_state) !=
return atomic_load_relaxed(&wgs->wgs_send_counter);
atomic_load_relaxed(&wgs->wgs_time_last_data_sent) == 0 &&
atomic_load_relaxed(&wgs->wgs_time_last_data_sent);
!atomic_load_relaxed(&wgs->wgs_force_rekey))
if (atomic_load_relaxed(&wgp->wgp_endpoint_changing)) {
bool altq = atomic_load_relaxed(&ifp->if_snd.altq_flags)
if (S + SLIWIN_NPKT < atomic_load_relaxed(&W->T))
o = atomic_load_relaxed(&wg_count);
return atomic_load_relaxed(&lacpp->lp_collector);
if (atomic_load_relaxed(&pport->lpp_active)) {
if (atomic_load_relaxed(&pport->lpp_active)) {
if (atomic_load_relaxed(&fovr->fo_rx_all))
count = atomic_load_relaxed(&aset->alg_count);
match_func = atomic_load_relaxed(&f->match);
count = atomic_load_relaxed(&aset->alg_count);
translate_func = atomic_load_relaxed(&f->translate);
count = atomic_load_relaxed(&aset->alg_count);
inspect_func = atomic_load_relaxed(&f->inspect);
if ((destroy_func = atomic_load_relaxed(&f->destroy)) != NULL) {
if ((onc = atomic_load_relaxed(&npf->config)) != NULL) {
KASSERT(atomic_load_relaxed(&npf->conn_tracking) == CONN_TRACKING_OFF);
KASSERT(atomic_load_relaxed(&npf->conn_tracking)
odb = atomic_load_relaxed(&npf->conn_db);
if (atomic_load_relaxed(&npf->conn_tracking) != CONN_TRACKING_ON) {
const uint32_t flags = atomic_load_relaxed(&con->c_flags);
const unsigned ifid = atomic_load_relaxed(&con->c_ifid);
KASSERT(npc->npc_proto == atomic_load_relaxed(&con->c_proto));
if (atomic_load_relaxed(&con->c_flags) & CONN_GPASS) {
KASSERT(atomic_load_relaxed(&con->c_refcnt) == 0);
KASSERT(atomic_load_relaxed(&con->c_refcnt) > 0);
flags = atomic_load_relaxed(&con->c_flags);
KASSERT(atomic_load_relaxed(&con->c_refcnt) > 0);
if (__predict_true(atomic_load_relaxed(&con->c_flags) & CONN_PASS)) {
mi->mi_retfl = atomic_load_relaxed(&con->c_retfl);
KASSERT((atomic_load_relaxed(&con->c_flags) & CONN_ACTIVE) == 0);
KASSERT(atomic_load_relaxed(&con->c_refcnt) > 0);
const unsigned flags = atomic_load_relaxed(&con->c_flags);
KASSERT(atomic_load_relaxed(&con->c_refcnt) > 0);
const unsigned flags = atomic_load_relaxed(&con->c_flags);
elapsed = (int64_t)tsnow - atomic_load_relaxed(&con->c_atime);
if ((atomic_load_relaxed(&con->c_flags) & CONN_REMOVED) == 0) {
if (atomic_load_relaxed(&npf->conn_tracking) != CONN_TRACKING_ON) {
conn_db = atomic_load_relaxed(&npf->conn_db);
flags = atomic_load_relaxed(&con->c_flags);
const unsigned flags = atomic_load_relaxed(&con->c_flags);
npf_conndb_t *cd = atomic_load_relaxed(&npf->conn_db);
head = atomic_load_relaxed(&cd->cd_new);
npf_conn_t *next = atomic_load_relaxed(&con->c_next); // union
const unsigned refcnt = atomic_load_relaxed(&con->c_refcnt);
((id) - atomic_load_relaxed(&(npf)->ifmap_off) - 1)
npf_tableset_t *ts = atomic_load_relaxed(&npf->config)->tableset;
KASSERT(atomic_load_relaxed(&np->n_refcnt) > 0);
if (atomic_load_relaxed(&np->n_refcnt) > 1) {
KASSERT(atomic_load_relaxed(&np->n_refcnt) >= 1);
KASSERT(atomic_load_relaxed(&np->n_refcnt) > 0);
atomic_load_relaxed(&np->n_refcnt) + 1);
bval = atomic_load_relaxed(&bm->bits0[i]);
const unsigned min_port = atomic_load_relaxed(&pm->min_port);
const unsigned max_port = atomic_load_relaxed(&pm->max_port);
if (atomic_load_relaxed(&ext->ext_refcnt)) {
if (atomic_load_relaxed(&ext->ext_refcnt)) {
KASSERT(atomic_load_relaxed(&rp->rp_refcnt) > 0);
KASSERT(atomic_load_relaxed(&rp->rp_refcnt) > 0);
KASSERT(atomic_load_relaxed(&ext->ext_refcnt) > 0);
rl = atomic_load_relaxed(&rg->r_subset);
for (; rl; rl = atomic_load_relaxed(&rl->r_next)) {
return atomic_load_relaxed(&ts->ts_map[tid]);
pktq_rps_hash_func_t func = atomic_load_relaxed(funcp);
DPRINTF("destroying %p %d\n", cse, atomic_load_relaxed(&cse->refcnt));
KASSERT(atomic_load_relaxed(&cse->refcnt) == 1);
if (atomic_load_relaxed(&cse->refcnt) != 1)
while (__predict_false(atomic_load_relaxed(&l->l_mutex) != old)) {
o = atomic_load_relaxed(p32);
o = atomic_load_relaxed(p32);
const __atomic_typeof_unqual(*(p)) __al_val = atomic_load_relaxed(p); \
if (__predict_false(lock != atomic_load_relaxed(&so->so_lock)))
return atomic_load_relaxed(&time__second);
return atomic_load_relaxed(&time__uptime);
pt_entry_t pte = atomic_load_relaxed(ptep);
const pt_entry_t pte = atomic_load_relaxed(ptep);
pt_entry_t opte = atomic_load_relaxed(ptep);
if (atomic_load_relaxed(ptep) != npte) {
pt_entry_t pte = atomic_load_relaxed(ptep);
const pt_entry_t opte = atomic_load_relaxed(ptep);
KASSERT(!pte_valid_p(atomic_load_relaxed(ptep)));
pt_entry_t pte = atomic_load_relaxed(ptep);
pt_entry_t pte = atomic_load_relaxed(ptep);
pt_entry_t pte = atomic_load_relaxed(ptep);
pt_entry_t opte = atomic_load_relaxed(ptep);
pt_entry_t pte = atomic_load_relaxed(ptep);
(uintptr_t)nptep, pte_value(atomic_load_relaxed(nptep)), 0, 0);
atomic_load_relaxed(ptep) : 0;
pd_entry_t opde = atomic_load_relaxed(pde_p);
ppg = pmap_pde_to_ptpage(atomic_load_relaxed(pde_p));
return (atomic_load_relaxed(&pg->pqflags) & PQ_WANTED) != 0;
KASSERT(atomic_load_relaxed(&uvmexp.paging) >= npages);
pqflags = atomic_load_relaxed(&pg->pqflags);
pqflags = atomic_load_relaxed(&pg->pqflags);
atomic_load_relaxed(&uvm_swap_encrypt)) {
if (!atomic_load_relaxed(&uvm_swap_encrypt)) {
if (!atomic_load_relaxed(&uvm_swap_encrypt)) {
swap_encrypt = atomic_load_relaxed(&uvm_swap_encrypt);
iflag = atomic_load_relaxed(&vp->v_iflag);
while (!atomic_load_relaxed(&done)) {
if (atomic_load_relaxed(&done))
if (atomic_load_relaxed(&ses) == co.ses)
while (!atomic_load_relaxed(&done)) {