atomic_read
if (atomic_read(wp->fd, (void *)&got, sizeof got)
if (atomic_read(workers[i].fd,
if (atomic_read(workers[f].fd, (void *)&got, sizeof got)
if (atomic_read(wp->fd, (void *)&got, sizeof got)
static int atomic_read(int, void *, int);
if ((nread = atomic_read(cmd, (void *)&nextworker, sizeof nextworker))
while ((nread = atomic_read(cmd, (void *)wp->req, reqsiz)) == reqsiz) {
if (p->count != 1 || atomic_read(cmd,
*value = atomic_read(atomic_data);
int c = atomic_read(v);
int c = atomic_read(v);
old = atomic_read(v);
return atomic_read(ref);
#define get_task_state(task) atomic_read(&(task)->state)
return (atomic_read(&task->kthread_flags) & KTHREAD_SHOULD_PARK_MASK);
return (atomic_read(&task->kthread_flags) & KTHREAD_SHOULD_STOP_MASK);
return (atomic_read(¤t->kthread_flags) & KTHREAD_SHOULD_STOP_MASK);
if ((atomic_read(&task->state) & state) != 0) {
if (atomic_read(&task->state) != TASK_WAKING) {
state = atomic_read(&task->state);
if (atomic_read(a) == 0) {
if (atomic_read(&ts->count))
if (!atomic_read(&ts->count)) {
if (atomic_read(&wq->draining) != 0)
if (atomic_read(&wq->draining) != 0)
MPASS(atomic_read(&work->state) != WORK_ST_TIMER);
MPASS(atomic_read(&work->state) != WORK_ST_CANCEL);
switch (atomic_read(&work->state)) {
switch (atomic_read(&dwork->work.state)) {
switch (atomic_read(&work->state)) {
switch (atomic_read(&work->state)) {
while (atomic_read(&ulp->ref_count) != 0 && i < 10) {
return (atomic_read(&rdev->stats.rsors.mr_count) +
atomic_read(&rdev->stats.rsors.mw_count));
"Hold ref_count = 0x%x", atomic_read(&rdev->ref_count));
"Put ref_count = 0x%x", atomic_read(&rdev->ref_count));
rc = atomic_read(&resolve_dmac_work->status_wait) & 0xFF;
if (atomic_read(&resolve_dmac_work->status_wait)) {
max_ah_count = atomic_read(&rdev->stats.rsors.ah_count);
if (max_ah_count > atomic_read(&rdev->stats.rsors.max_ah_count))
if (atomic_read(&rdev->stats.rsors.srq_count) >= dev_attr->max_srq) {
max_srq_count = atomic_read(&rdev->stats.rsors.srq_count);
if (max_srq_count > atomic_read(&rdev->stats.rsors.max_srq_count))
atomic_read(&rdev->stats.rsors.max_qp_count));
if (atomic_read(&rdev->stats.rsors.qp_count) >= dev_attr->max_qp) {
atomic_read(&rdev->stats.rsors.qp_count), dev_attr->max_qp);
active_qps = atomic_read(&rdev->stats.rsors.qp_count);
if (active_qps > atomic_read(&rdev->stats.rsors.max_qp_count))
if (tmp_qps > atomic_read(&rdev->stats.rsors.max_rc_qp_count))
if (tmp_qps > atomic_read(&rdev->stats.rsors.max_ud_qp_count))
if (atomic_read(&rdev->stats.rsors.cq_count) >= dev_attr->max_cq) {
max_active_cqs = atomic_read(&rdev->stats.rsors.cq_count);
if (max_active_cqs > atomic_read(&rdev->stats.rsors.max_cq_count))
max_mr_count = atomic_read(&rdev->stats.rsors.mr_count);
if (max_mr_count > atomic_read(&rdev->stats.rsors.max_mr_count))
max_mr_count = atomic_read(&rdev->stats.rsors.mr_count);
if (max_mr_count > atomic_read(&rdev->stats.rsors.max_mr_count))
max_mw_count = atomic_read(&rdev->stats.rsors.mw_count);
if (max_mw_count > atomic_read(&rdev->stats.rsors.max_mw_count))
max_mr_count = atomic_read(&rdev->stats.rsors.mr_count);
if (max_mr_count > atomic_read(&rdev->stats.rsors.max_mr_count))
max_mr_count = atomic_read(&rdev->stats.rsors.mr_count);
if (max_mr_count > (atomic_read(&rdev->stats.rsors.max_mr_count)))
max_pd_count = atomic_read(&rdev->stats.rsors.pd_count);
if (max_pd_count > atomic_read(&rdev->stats.rsors.max_pd_count))
netdev, atomic_read(&rdev->ref_count));
while ((atomic_read(&rdev->ref_count) > 1) && i--)
if (atomic_read(&rdev->ref_count) > 1)
atomic_read(&rdev->ref_count));
if (handle->destroyed || !atomic_read(&cq->ibcq.usecnt)) {
while (atomic_read(&rdev->stats.rsors.cq_count) && --wait_count)
atomic_read(&rdev->stats.rsors.cq_count));
if (atomic_read(&rdev->sched_count) > 0)
if (atomic_read(&rcfw->rcfw_intr_enabled) > 1) {
atomic_read(&rcfw->rcfw_intr_enabled));
if (atomic_read(&rcfw->rcfw_intr_enabled) > 0) {
atomic_read(&rcfw->rcfw_intr_enabled));
atomic_read(&rcfw->timeout_send));
else if (atomic_read(&rcfw->rcfw_intr_enabled))
stats->value[BNXT_RE_ACTIVE_QP] = atomic_read(&rdev->stats.rsors.qp_count);
stats->value[BNXT_RE_ACTIVE_RC_QP] = atomic_read(&rdev->stats.rsors.rc_qp_count);
stats->value[BNXT_RE_ACTIVE_UD_QP] = atomic_read(&rdev->stats.rsors.ud_qp_count);
stats->value[BNXT_RE_ACTIVE_SRQ] = atomic_read(&rdev->stats.rsors.srq_count);
stats->value[BNXT_RE_ACTIVE_CQ] = atomic_read(&rdev->stats.rsors.cq_count);
stats->value[BNXT_RE_ACTIVE_MR] = atomic_read(&rdev->stats.rsors.mr_count);
stats->value[BNXT_RE_ACTIVE_MW] = atomic_read(&rdev->stats.rsors.mw_count);
stats->value[BNXT_RE_ACTIVE_AH] = atomic_read(&rdev->stats.rsors.ah_count);
stats->value[BNXT_RE_ACTIVE_PD] = atomic_read(&rdev->stats.rsors.pd_count);
stats->value[BNXT_RE_QP_WATERMARK] = atomic_read(&rdev->stats.rsors.max_qp_count);
stats->value[BNXT_RE_RC_QP_WATERMARK] = atomic_read(&rdev->stats.rsors.max_rc_qp_count);
stats->value[BNXT_RE_UD_QP_WATERMARK] = atomic_read(&rdev->stats.rsors.max_ud_qp_count);
stats->value[BNXT_RE_SRQ_WATERMARK] = atomic_read(&rdev->stats.rsors.max_srq_count);
stats->value[BNXT_RE_CQ_WATERMARK] = atomic_read(&rdev->stats.rsors.max_cq_count);
stats->value[BNXT_RE_MR_WATERMARK] = atomic_read(&rdev->stats.rsors.max_mr_count);
stats->value[BNXT_RE_MW_WATERMARK] = atomic_read(&rdev->stats.rsors.max_mw_count);
stats->value[BNXT_RE_AH_WATERMARK] = atomic_read(&rdev->stats.rsors.max_ah_count);
stats->value[BNXT_RE_PD_WATERMARK] = atomic_read(&rdev->stats.rsors.max_pd_count);
stats->value[BNXT_RE_RESIZE_CQ_COUNT] = atomic_read(&rdev->stats.rsors.resize_count);
wait_event(chp->wait, !atomic_read(&chp->refcnt));
if (atomic_read(&obj->handle_count) == 0)
if (atomic_read(&obj->handle_count) == 0)
if (atomic_read(&dev->buf_alloc)) {
if (atomic_read(&dev->buf_alloc)) {
if (atomic_read(&dev->ioctl_count)) {
atomic_read(&dev->ioctl_count));
stats->data[i].value = atomic_read(&dev->counts[i]);
vblcount = atomic_read(&dev->_vblank_count[crtc]);
vblcount = atomic_read(&dev->_vblank_count[crtc]);
if (atomic_read(&dev->vblank_refcount[i]) == 0 &&
return atomic_read(&dev->_vblank_count[crtc]);
cur_vblank = atomic_read(&dev->_vblank_count[crtc]);
} while (cur_vblank != atomic_read(&dev->_vblank_count[crtc]));
tslot = atomic_read(&dev->_vblank_count[crtc]) + diff;
BUG_ON(atomic_read(&dev->vblank_refcount[crtc]) == 0);
atomic_read(&dma->bufs[i]
(unsigned long) atomic_read(&glob->bo_count));
MPASS(atomic_read(&bo->list_kref) == 0);
MPASS(atomic_read(&bo->kref) == 0);
MPASS(atomic_read(&bo->cpu_writers) == 0);
return atomic_read(&bo->reserved);
if (unlikely(atomic_read(&bo->cpu_writers) > 0)) {
if (unlikely(atomic_read(&bo->cpu_writers) > 0)) {
atomic_read(&iwdev->rf->dev_ctx.event_rfcnt));
!atomic_read(&iwdev->vsi.qp_suspend_reqs),
!atomic_read(&rf->dev_ctx.event_rfcnt),
if (atomic_read(&rf->dev_ctx.event_rfcnt) != 0) {
atomic_read(&rf->dev_ctx.event_rfcnt));
if (atomic_read(&cm_node->listener->pend_accepts_cnt) >
iwqp->ae_src, atomic_read(&ae_info->ae_cnt));
iwqp->ae_src, atomic_read(&ae_info->ae_cnt));
if (atomic_read(&iwqp->flush_issued) ||
if (!atomic_read(&iwqp->flush_issued))
if (!atomic_read(&iwqp->flush_issued))
if (atomic_read(&iwqp->close_timer_started))
if (atomic_read(&cq->armed)) {
if (!atomic_read(&rf->arp_table[arp_index].refcnt)) {
if (!atomic_read(&rf->arp_table[arp_index].refcnt))
atomic_read(&cqp_request->refcnt) == 1, 1000);
!atomic_read(&iwqp->flush_issued)) {
wait_event(iwqp->mod_qp_waitq, !atomic_read(&iwqp->hw_mod_qp_pend));
if (!atomic_read(&iwqp->flush_issued)) {
if (atomic_read(&iwqp->flush_issued))
wait_event(iwqp->mod_qp_waitq, !atomic_read(&iwqp->hw_mod_qp_pend));
if ((pending_sends = atomic_read(&txq->pending_sends)) > 0) {
while (atomic_read(&txq->pending_sends) > 0)
int num_tasks = atomic_read(&priv->opreq_count);
if (atomic_read(&pf_loading)) {
if (res->com.state == RES_QP_BUSY || atomic_read(&res->ref_count) ||
res->com.state, atomic_read(&res->ref_count));
atomic_read(&res->ref_count)) {
atomic_read(&res->ref_count));
else if (atomic_read(&r->ref_count))
else if (atomic_read(&r->ref_count))
if (cq->com.owner == slave && !atomic_read(&cq->ref_count)) {
atomic_read(&group->refcount),
if (atomic_read(&group->refcount))
mcg_warn_group(group, "group refcount %d!!! (pointer %p)\n", atomic_read(&group->refcount), group);
if (atomic_read(&group->refcount)) {
wait_event(ctx->wait, atomic_read(&ctx->num_inflight) == 0);
do_lock = atomic_read(&table->writercount) != 0;
do_lock = atomic_read(&table->writercount) != 0;
version += (u64)atomic_read(&iter->g->node.version);
if (atomic_read(&ft->node.version) != ft_version) {
version = atomic_read(&ft->node.version);
version != atomic_read(&ft->node.version))
return sprintf(buf, "%d\n", atomic_read(&dev->mdev->priv.reg_pages));
} else if (!atomic_read(&pd->sqp_count) &&
qdepth = atomic_read(&ioerr_queue_count);
if (atomic_read(&outstanding_encrypted_io_count) != 0)
if (wait_event_interruptible(ioerr_waitq, (atomic_read(&ioerr_queue_count)))) {
if(atomic_read (&outstanding_encrypted_io_count) > 0)
printf("%s: WARNING: %d outstanding encrypted IOs !\n", __FUNCTION__, atomic_read(&outstanding_encrypted_io_count));
return ((int64_t)atomic_read((QatUtilsAtomic *)pAtomicVar));
return atomic_read(&accel_dev->ref_count) != 0;
counter = atomic_read(&accel_dev->ras_counters[ADF_RAS_CORR]);
counter = atomic_read(&accel_dev->ras_counters[ADF_RAS_UNCORR]);
counter = atomic_read(&accel_dev->ras_counters[ADF_RAS_FATAL]);
if (WARN_ON_ONCE(atomic_read(&cq->usecnt) != 0))
if (atomic_read(&pool->flush_ser) - atomic_read(&pool->req_ser) < 0) {
if (atomic_read(&pool->flush_ser) - atomic_read(&pool->req_ser) >= 0 &&
atomic_read(&pool->flush_ser) - serial >= 0))
BUG_ON(atomic_read(&cm_id_priv->refcount)==0);
if (atomic_read(&qp_info->snoop_count))
if (atomic_read(&qp_info->snoop_count))
if (atomic_read(&recv_mad_agent->qp_info->snoop_count))
if (atomic_read(&mad_agent_priv->qp_info->snoop_count))
WARN_ON(atomic_read(&uobj->usecnt) <= 0);
WARN_ON(atomic_read(&uobj->usecnt) != -1);
if (!atomic_read(&context->notifier_count)) {
if (likely(!atomic_read(&context->notifier_count)) ||
if (!atomic_read(&counters->usecnt))
if (atomic_read(&real_qp->usecnt) == 0)
if (atomic_read(&qp->usecnt))
if (atomic_read(&cq->usecnt))
if (atomic_read(&xrcd->usecnt))
if (atomic_read(&wq->usecnt))
if (atomic_read(&rwq_ind_table->usecnt))
WARN_ON(atomic_read(&pd->usecnt));
if (atomic_read(&srq->usecnt))
#define ring_head(ring) (atomic_read(&(ring).head))
#define ring_tail(ring) (atomic_read(&(ring).tail))
#define tx_credits(ssk) (atomic_read(&ssk->tx_ring.credits))
#define rcv_nxt(ssk) atomic_read(&(ssk->rcv_nxt))
#define mseq_ack(ssk) (atomic_read(&ssk->mseq_ack))
#define remote_credits(ssk) (atomic_read(&ssk->remote_credits))
if (atomic_read(usecnt) && ib_is_destroy_retryable(-EBUSY, why, uobj))