crypto/openssl/crypto/property/property_string.c

126

OSSL_PROPERTY_IDX *pidx)

crypto/openssl/crypto/property/property_string.c

134

ps->idx = ++*pidx;

crypto/openssl/crypto/property/property_string.c

148

OSSL_PROPERTY_IDX *pidx;

crypto/openssl/crypto/property/property_string.c

168

pidx = name ? &propdata->prop_name_idx : &propdata->prop_value_idx;

crypto/openssl/crypto/property/property_string.c

170

if (ps == NULL && (ps_new = new_property_string(s, pidx)) != NULL) {

crypto/openssl/crypto/property/property_string.c

191

--*pidx;

crypto/openssl/ssl/ssl_cert.c

1303

int ssl_cert_lookup_by_nid(int nid, size_t *pidx, SSL_CTX *ctx)

crypto/openssl/ssl/ssl_cert.c

1309

*pidx = i;

crypto/openssl/ssl/ssl_cert.c

1315

*pidx = SSL_PKEY_NUM + i;

crypto/openssl/ssl/ssl_cert.c

1322

const SSL_CERT_LOOKUP *ssl_cert_lookup_by_pkey(const EVP_PKEY *pk, size_t *pidx, SSL_CTX *ctx)

crypto/openssl/ssl/ssl_cert.c

1332

if (pidx != NULL)

crypto/openssl/ssl/ssl_cert.c

1333

*pidx = i;

crypto/openssl/ssl/ssl_cert.c

1343

if (pidx != NULL)

crypto/openssl/ssl/ssl_cert.c

1344

*pidx = SSL_PKEY_NUM + i;

crypto/openssl/ssl/ssl_local.h

2605

__owur int ssl_cert_lookup_by_nid(int nid, size_t *pidx, SSL_CTX *ctx);

crypto/openssl/ssl/ssl_local.h

2607

size_t *pidx,

sys/amd64/sgx/sgx.c

196

vm_pindex_t pidx, struct pctrie_iter *pages)

sys/amd64/sgx/sgx.c

202

vm_page_iter_insert(page, object, pidx, pages);

sys/amd64/sgx/sgx.c

238

vm_pindex_t pidx, struct pctrie_iter *pages)

sys/amd64/sgx/sgx.c

249

va_page_idx = pidx / SGX_VA_PAGE_SLOTS;

sys/amd64/sgx/sgx.c

625

vm_pindex_t pidx;

sys/amd64/sgx/sgx.c

630

pidx = OFF_TO_IDX(addr);

sys/amd64/sgx/sgx.c

633

sgx_insert_epc_page_by_index(page, enclave->object, pidx, pages);

sys/amd64/sgx/sgx.c

797

uint64_t pidx;

sys/amd64/sgx/sgx.c

855

pidx = OFF_TO_IDX(addr);

sys/amd64/sgx/sgx.c

859

p = vm_radix_iter_lookup(&pages, pidx);

sys/amd64/sgx/sgx.c

867

ret = sgx_va_slot_init(sc, enclave, pidx, &pages);

sys/compat/linuxkpi/common/src/linux_compat.c

490

linux_cdev_pager_populate(vm_object_t vm_obj, vm_pindex_t pidx, int fault_type,

sys/compat/linuxkpi/common/src/linux_compat.c

512

vmf.virtual_address = (void *)(uintptr_t)IDX_TO_OFF(pidx);

sys/dev/aq/aq_ring.c

242

qidx_t i, pidx;

sys/dev/aq/aq_ring.c

248

pidx = iru->iru_pidx;

sys/dev/aq/aq_ring.c

251

rx_desc = (aq_rx_desc_t *) &ring->rx_descs[pidx];

sys/dev/aq/aq_ring.c

255

pidx=aq_next(pidx, ring->rx_size - 1);

sys/dev/aq/aq_ring.c

262

aq_isc_rxd_flush(void *arg, uint16_t rxqid, uint8_t flid __unused, qidx_t pidx)

sys/dev/aq/aq_ring.c

267

AQ_DBG_ENTERA("[%d] tail=%u", ring->index, pidx);

sys/dev/aq/aq_ring.c

268

reg_rx_dma_desc_tail_ptr_set(&aq_dev->hw, pidx, ring->index);

sys/dev/aq/aq_ring.c

479

qidx_t pidx;

sys/dev/aq/aq_ring.c

488

pidx = pi->ipi_pidx;

sys/dev/aq/aq_ring.c

489

txc = (aq_txc_desc_t *)&ring->tx_descs[pidx];

sys/dev/aq/aq_ring.c

501

trace_aq_tx_context_descr(ring->index, pidx,

sys/dev/aq/aq_ring.c

504

pidx = aq_next(pidx, ring->tx_size - 1);

sys/dev/aq/aq_ring.c

506

txd = &ring->tx_descs[pidx];

sys/dev/aq/aq_ring.c

530

txd = &ring->tx_descs[pidx];

sys/dev/aq/aq_ring.c

540

trace_aq_tx_descr(ring->index, pidx,

sys/dev/aq/aq_ring.c

543

pidx = aq_next(pidx, ring->tx_size - 1);

sys/dev/aq/aq_ring.c

551

trace_aq_tx_descr(ring->index, pidx, (volatile void*)txd);

sys/dev/aq/aq_ring.c

552

ring->tx_tail = pidx;

sys/dev/aq/aq_ring.c

557

pi->ipi_new_pidx = pidx;

sys/dev/aq/aq_ring.c

564

aq_isc_txd_flush(void *arg, uint16_t txqid, qidx_t pidx)

sys/dev/aq/aq_ring.c

568

AQ_DBG_ENTERA("[%d] tail=%d", ring->index, pidx);

sys/dev/aq/aq_ring.c

571

aq_ring_tx_tail_update(&aq_dev->hw, ring, pidx);

sys/dev/aq/aq_ring.c

61

static void aq_isc_txd_flush(void *arg, uint16_t txqid, qidx_t pidx);

sys/dev/aq/aq_ring.c

64

static void aq_isc_rxd_flush(void *arg, uint16_t rxqid, uint8_t flid __unused, qidx_t pidx);

sys/dev/axgbe/xgbe-txrx.c

369

axgbe_isc_txd_flush(void *arg, uint16_t txqid, qidx_t pidx)

sys/dev/axgbe/xgbe-txrx.c

375

struct xgbe_ring_data *rdata = XGBE_GET_DESC_DATA(ring, pidx);

sys/dev/axgbe/xgbe-txrx.c

378

__func__, txqid, pidx, ring->cur, ring->dirty);

sys/dev/axgbe/xgbe-txrx.c

534

axgbe_isc_rxd_flush(void *arg, uint16_t qsidx, uint8_t flidx, qidx_t pidx)

sys/dev/axgbe/xgbe-txrx.c

543

__func__, qsidx, flidx, pidx, ring->cur, ring->dirty);

sys/dev/axgbe/xgbe-txrx.c

545

rdata = XGBE_GET_DESC_DATA(ring, pidx);

sys/dev/bnxt/bnxt_en/bnxt_txrx.c

210

bnxt_isc_txd_flush(void *sc, uint16_t txqid, qidx_t pidx)

sys/dev/bnxt/bnxt_en/bnxt_txrx.c

216

softc->db_ops.bnxt_db_tx(tx_ring, pidx);

sys/dev/bnxt/bnxt_en/bnxt_txrx.c

302

uint32_t pidx;

sys/dev/bnxt/bnxt_en/bnxt_txrx.c

309

pidx = iru->iru_pidx;

sys/dev/bnxt/bnxt_en/bnxt_txrx.c

325

rxbd[pidx].flags_type = htole16(type);

sys/dev/bnxt/bnxt_en/bnxt_txrx.c

326

rxbd[pidx].len = htole16(softc->rx_buf_size);

sys/dev/bnxt/bnxt_en/bnxt_txrx.c

328

rxbd[pidx].opaque = (((rxqid & 0xff) << 24) | (flid << 16)

sys/dev/bnxt/bnxt_en/bnxt_txrx.c

330

rxbd[pidx].addr = htole64(paddrs[i]);

sys/dev/bnxt/bnxt_en/bnxt_txrx.c

333

if (++pidx == rx_ring->ring_size) {

sys/dev/bnxt/bnxt_en/bnxt_txrx.c

334

pidx = 0;

sys/dev/bnxt/bnxt_en/bnxt_txrx.c

337

if (pidx < EPOCH_ARR_SZ)

sys/dev/bnxt/bnxt_en/bnxt_txrx.c

338

rx_ring->epoch_arr[pidx] = rx_ring->epoch_bit;

sys/dev/bnxt/bnxt_en/bnxt_txrx.c

346

qidx_t pidx)

sys/dev/bnxt/bnxt_en/bnxt_txrx.c

362

softc->db_ops.bnxt_db_rx(rx_ring, pidx);

sys/dev/bnxt/bnxt_en/bnxt_txrx.c

48

static void bnxt_isc_txd_flush(void *sc, uint16_t txqid, qidx_t pidx);

sys/dev/bnxt/bnxt_en/bnxt_txrx.c

58

qidx_t pidx);

sys/dev/cxgb/cxgb_adapter.h

207

uint32_t pidx;

sys/dev/cxgb/cxgb_adapter.h

235

uint32_t pidx;

sys/dev/cxgb/cxgb_sge.c

1139

txqs->pidx = txq->pidx;

sys/dev/cxgb/cxgb_sge.c

1140

txq->pidx += ndesc;

sys/dev/cxgb/cxgb_sge.c

1142

if (((txqs->pidx > txq->cidx) &&

sys/dev/cxgb/cxgb_sge.c

1143

(txq->pidx < txqs->pidx) &&

sys/dev/cxgb/cxgb_sge.c

1144

(txq->pidx >= txq->cidx)) ||

sys/dev/cxgb/cxgb_sge.c

1145

((txqs->pidx < txq->cidx) &&

sys/dev/cxgb/cxgb_sge.c

1146

(txq->pidx >= txq-> cidx)) ||

sys/dev/cxgb/cxgb_sge.c

1147

((txqs->pidx < txq->cidx) &&

sys/dev/cxgb/cxgb_sge.c

1148

(txq->cidx < txqs->pidx)))

sys/dev/cxgb/cxgb_sge.c

1150

txqs->pidx, txq->pidx, txq->cidx);

sys/dev/cxgb/cxgb_sge.c

1152

if (txq->pidx >= txq->size) {

sys/dev/cxgb/cxgb_sge.c

1153

txq->pidx -= txq->size;

sys/dev/cxgb/cxgb_sge.c

1315

if (++txqs->pidx == txq->size) {

sys/dev/cxgb/cxgb_sge.c

1316

txqs->pidx = 0;

sys/dev/cxgb/cxgb_sge.c

1373

txd = &txq->desc[txq->pidx];

sys/dev/cxgb/cxgb_sge.c

1374

txsd = &txq->sdesc[txq->pidx];

sys/dev/cxgb/cxgb_sge.c

1908

write_imm(&q->desc[q->pidx], m->m_data, m->m_len, q->gen);

sys/dev/cxgb/cxgb_sge.c

1911

if (++q->pidx >= q->size) {

sys/dev/cxgb/cxgb_sge.c

1912

q->pidx = 0;

sys/dev/cxgb/cxgb_sge.c

193

unsigned int pidx;

sys/dev/cxgb/cxgb_sge.c

1945

write_imm(&q->desc[q->pidx], m->m_data, m->m_len, q->gen);

sys/dev/cxgb/cxgb_sge.c

1948

if (++q->pidx >= q->size) {

sys/dev/cxgb/cxgb_sge.c

1949

q->pidx = 0;

sys/dev/cxgb/cxgb_sge.c

2196

unsigned int pidx, unsigned int gen, unsigned int ndesc)

sys/dev/cxgb/cxgb_sge.c

2202

struct tx_desc *d = &q->desc[pidx];

sys/dev/cxgb/cxgb_sge.c

2247

txqs.pidx = pidx;

sys/dev/cxgb/cxgb_sge.c

2267

unsigned int pidx, gen;

sys/dev/cxgb/cxgb_sge.c

2286

pidx = q->pidx;

sys/dev/cxgb/cxgb_sge.c

2287

q->pidx += ndesc;

sys/dev/cxgb/cxgb_sge.c

2288

if (q->pidx >= q->size) {

sys/dev/cxgb/cxgb_sge.c

2289

q->pidx -= q->size;

sys/dev/cxgb/cxgb_sge.c

2293

write_ofld_wr(adap, m, q, pidx, gen, ndesc);

sys/dev/cxgb/cxgb_sge.c

2317

unsigned int gen, pidx;

sys/dev/cxgb/cxgb_sge.c

2332

pidx = q->pidx;

sys/dev/cxgb/cxgb_sge.c

2333

q->pidx += ndesc;

sys/dev/cxgb/cxgb_sge.c

2334

if (q->pidx >= q->size) {

sys/dev/cxgb/cxgb_sge.c

2335

q->pidx -= q->size;

sys/dev/cxgb/cxgb_sge.c

2341

write_ofld_wr(adap, m, q, pidx, gen, ndesc);

sys/dev/cxgb/cxgb_sge.c

3563

CTLFLAG_RD, &txq->pidx,

sys/dev/cxgb/cxgb_sge.c

705

struct rx_sw_desc *sd = &q->sdesc[q->pidx];

sys/dev/cxgb/cxgb_sge.c

706

struct rx_desc *d = &q->desc[q->pidx];

sys/dev/cxgb/cxgb_sge.c

762

if (++q->pidx == q->size) {

sys/dev/cxgb/cxgb_sge.c

763

q->pidx = 0;

sys/dev/cxgb/cxgb_sge.c

844

struct rx_desc *to = &q->desc[q->pidx];

sys/dev/cxgb/cxgb_sge.c

846

q->sdesc[q->pidx] = q->sdesc[idx];

sys/dev/cxgb/cxgb_sge.c

854

if (++q->pidx == q->size) {

sys/dev/cxgb/cxgb_sge.c

855

q->pidx = 0;

sys/dev/cxgbe/adapter.h

514

uint16_t pidx; /* producer idx (desc idx) */

sys/dev/cxgbe/adapter.h

590

uint32_t pidx; /* producer index */

sys/dev/cxgbe/adapter.h

772

int pidx;

sys/dev/cxgbe/adapter.h

881

uint16_t pidx;

sys/dev/cxgbe/common/t4_hw.h

110

volatile __be16 pidx;

sys/dev/cxgbe/common/t4_msg.h

4607

__be16 pidx;

sys/dev/cxgbe/crypto/t6_kern_tls.c

1110

u_int available, u_int pidx)

sys/dev/cxgbe/crypto/t6_kern_tls.c

1196

txsd = &txq->sdesc[pidx];

sys/dev/cxgbe/crypto/t6_kern_tls.c

1205

struct mbuf *m_tls, u_int available, tcp_seq tcp_seqno, u_int pidx)

sys/dev/cxgbe/crypto/t6_kern_tls.c

1301

txsd = &txq->sdesc[pidx];

sys/dev/cxgbe/crypto/t6_kern_tls.c

1316

tcp_seq tcp_seqno, uint32_t *tsopt, u_int pidx, bool set_l2t_idx)

sys/dev/cxgbe/crypto/t6_kern_tls.c

1347

using_scratch = (eq->sidx - pidx < SGE_MAX_WR_LEN / EQ_ESIZE);

sys/dev/cxgbe/crypto/t6_kern_tls.c

1366

tcp_seqno, pidx));

sys/dev/cxgbe/crypto/t6_kern_tls.c

1595

txsd = &txq->sdesc[pidx];

sys/dev/cxgbe/crypto/t6_kern_tls.c

1598

IDXINCR(pidx, ndesc, eq->sidx);

sys/dev/cxgbe/crypto/t6_kern_tls.c

1599

dst = &eq->desc[pidx];

sys/dev/cxgbe/crypto/t6_kern_tls.c

1608

using_scratch = (eq->sidx - pidx <

sys/dev/cxgbe/crypto/t6_kern_tls.c

1844

txsd = &txq->sdesc[pidx];

sys/dev/cxgbe/crypto/t6_kern_tls.c

1856

u_int available, tcp_seq tcp_seqno, u_int pidx)

sys/dev/cxgbe/crypto/t6_kern_tls.c

1942

txsd = &txq->sdesc[pidx];

sys/dev/cxgbe/crypto/t6_kern_tls.c

1960

u_int ndesc, pidx, totdesc;

sys/dev/cxgbe/crypto/t6_kern_tls.c

1973

pidx = eq->pidx;

sys/dev/cxgbe/crypto/t6_kern_tls.c

1981

ndesc = ktls_write_tcp_options(txq, dst, m, available, pidx);

sys/dev/cxgbe/crypto/t6_kern_tls.c

1983

IDXINCR(pidx, ndesc, eq->sidx);

sys/dev/cxgbe/crypto/t6_kern_tls.c

1984

dst = &eq->desc[pidx];

sys/dev/cxgbe/crypto/t6_kern_tls.c

2013

txsd = &txq->sdesc[pidx];

sys/dev/cxgbe/crypto/t6_kern_tls.c

2017

IDXINCR(pidx, ndesc, eq->sidx);

sys/dev/cxgbe/crypto/t6_kern_tls.c

2018

dst = &eq->desc[pidx];

sys/dev/cxgbe/crypto/t6_kern_tls.c

2045

available - totdesc, tcp_seqno, tsopt, pidx, set_l2t_idx);

sys/dev/cxgbe/crypto/t6_kern_tls.c

2047

IDXINCR(pidx, ndesc, eq->sidx);

sys/dev/cxgbe/crypto/t6_kern_tls.c

2048

dst = &eq->desc[pidx];

sys/dev/cxgbe/crypto/t6_kern_tls.c

2064

tlsp->prev_seq, pidx);

sys/dev/cxgbe/crypto/t7_kern_tls.c

1149

const void *src, u_int len, u_int available, tcp_seq tcp_seqno, u_int pidx,

sys/dev/cxgbe/crypto/t7_kern_tls.c

1230

txsd = &txq->sdesc[pidx];

sys/dev/cxgbe/crypto/t7_kern_tls.c

1243

u_int available, tcp_seq tcp_seqno, u_int pidx, uint16_t eh_type,

sys/dev/cxgbe/crypto/t7_kern_tls.c

1298

m_tls->m_len, available, tcp_seqno, pidx, eh_type,

sys/dev/cxgbe/crypto/t7_kern_tls.c

1390

pidx, eh_type, last_wr));

sys/dev/cxgbe/crypto/t7_kern_tls.c

1541

using_scratch = (eq->sidx - pidx < ndesc);

sys/dev/cxgbe/crypto/t7_kern_tls.c

2009

txsd = &txq->sdesc[pidx];

sys/dev/cxgbe/crypto/t7_kern_tls.c

2029

u_int ndesc, pidx, totdesc;

sys/dev/cxgbe/crypto/t7_kern_tls.c

2048

pidx = eq->pidx;

sys/dev/cxgbe/crypto/t7_kern_tls.c

2076

available - totdesc, tcp_seqno, pidx, eh_type, mss);

sys/dev/cxgbe/crypto/t7_kern_tls.c

2078

IDXINCR(pidx, ndesc, eq->sidx);

sys/dev/cxgbe/crypto/t7_kern_tls.c

2079

dst = &eq->desc[pidx];

sys/dev/cxgbe/iw_cxgbe/cq.c

270

while (idx != wq->sq.pidx) {

sys/dev/cxgbe/iw_cxgbe/cq.c

299

while (cidx != wq->sq.pidx) {

sys/dev/cxgbe/iw_cxgbe/cq.c

345

while (rptr != wq->sq.pidx) {

sys/dev/cxgbe/iw_cxgbe/qp.c

819

swsqe = &qhp->wq.sq.sw_sq[qhp->wq.sq.pidx];

sys/dev/cxgbe/iw_cxgbe/qp.c

892

swsqe->idx = qhp->wq.sq.pidx;

sys/dev/cxgbe/iw_cxgbe/qp.c

899

init_wr_hdr(wqe, qhp->wq.sq.pidx, fw_opcode, fw_flags, len16);

sys/dev/cxgbe/iw_cxgbe/qp.c

903

__func__, (unsigned long long)wr->wr_id, qhp->wq.sq.pidx,

sys/dev/cxgbe/iw_cxgbe/qp.c

960

qhp->wq.rq.sw_rq[qhp->wq.rq.pidx].wr_id = wr->wr_id;

sys/dev/cxgbe/iw_cxgbe/qp.c

964

wqe->recv.wrid = qhp->wq.rq.pidx;

sys/dev/cxgbe/iw_cxgbe/qp.c

970

(unsigned long long) wr->wr_id, qhp->wq.rq.pidx);

sys/dev/cxgbe/iw_cxgbe/t4.h

326

u16 pidx;

sys/dev/cxgbe/iw_cxgbe/t4.h

354

u16 pidx;

sys/dev/cxgbe/iw_cxgbe/t4.h

389

if (++wq->rq.pidx == wq->rq.size)

sys/dev/cxgbe/iw_cxgbe/t4.h

390

wq->rq.pidx = 0;

sys/dev/cxgbe/iw_cxgbe/t4.h

437

if (++wq->sq.pidx == wq->sq.size)

sys/dev/cxgbe/iw_cxgbe/t4.h

438

wq->sq.pidx = 0;

sys/dev/cxgbe/iw_cxgbe/t4.h

488

__func__, wq->sq.pidx);

sys/dev/cxgbe/iw_cxgbe/t4.h

494

__func__, wq->sq.pidx);

sys/dev/cxgbe/iw_cxgbe/t4.h

513

__func__, wq->rq.pidx);

sys/dev/cxgbe/iw_cxgbe/t4.h

518

__func__, wq->rq.pidx);

sys/dev/cxgbe/iw_cxgbe/t4.h

75

__be16 pidx;

sys/dev/cxgbe/t4_main.c

7374

while (spg->cidx != htobe16(eq->pidx))

sys/dev/cxgbe/t4_main.c

7376

while (eq->cidx != eq->pidx)

sys/dev/cxgbe/t4_main.c

7384

while (eq->cidx != eq->pidx) {

sys/dev/cxgbe/t4_main.c

7396

spg->pidx = spg->cidx = htobe16(eq->cidx);

sys/dev/cxgbe/t4_mp_ring.c

120

uint16_t pidx;

sys/dev/cxgbe/t4_mp_ring.c

129

pidx = os.pidx_tail;

sys/dev/cxgbe/t4_mp_ring.c

130

MPASS(cidx != pidx);

sys/dev/cxgbe/t4_mp_ring.c

135

while (cidx != pidx) {

sys/dev/cxgbe/t4_mp_ring.c

138

n = r->drain(r, cidx, pidx, &coalescing);

sys/dev/cxgbe/t4_mp_ring.c

212

pidx = ns.pidx_tail;

sys/dev/cxgbe/t4_mp_ring.c

231

uint16_t pidx = os.pidx_tail;

sys/dev/cxgbe/t4_mp_ring.c

236

MPASS(cidx == pidx);

sys/dev/cxgbe/t4_mp_ring.c

238

r->drain(r, cidx, pidx, &coalescing);

sys/dev/cxgbe/t4_netmap.c

1022

nm_txq->pidx += npkt_to_ndesc(n);

sys/dev/cxgbe/t4_netmap.c

1023

MPASS(nm_txq->pidx <= nm_txq->sidx);

sys/dev/cxgbe/t4_netmap.c

1024

if (__predict_false(nm_txq->pidx == nm_txq->sidx)) {

sys/dev/cxgbe/t4_netmap.c

1030

nm_txq->pidx = 0;

sys/dev/cxgbe/t4_netmap.c

1039

nm_txq->equeqidx = nm_txq->pidx;

sys/dev/cxgbe/t4_netmap.c

1040

nm_txq->equiqidx = nm_txq->pidx;

sys/dev/cxgbe/t4_netmap.c

1043

nm_txq->equeqidx = nm_txq->pidx;

sys/dev/cxgbe/t4_netmap.c

1051

nm_txq->equeqidx = nm_txq->pidx;

sys/dev/cxgbe/t4_netmap.c

1066

if (nm_txq->cidx > nm_txq->pidx)

sys/dev/cxgbe/t4_netmap.c

1067

return (nm_txq->cidx - nm_txq->pidx - 1);

sys/dev/cxgbe/t4_netmap.c

1069

return (nm_txq->sidx - nm_txq->pidx);

sys/dev/cxgbe/t4_netmap.c

1071

return (nm_txq->sidx - nm_txq->pidx - 1);

sys/dev/cxgbe/t4_netmap.c

1156

MPASS(nm_txq->dbidx == nm_txq->pidx);

sys/dev/cxgbe/t4_netmap.c

230

nm_txq->pidx = nm_txq->cidx = 0;

sys/dev/cxgbe/t4_netmap.c

253

&nm_txq->pidx, 0, "producer index");

sys/dev/cxgbe/t4_netmap.c

462

nm_txq->pidx = nm_txq->cidx = 0;

sys/dev/cxgbe/t4_netmap.c

912

#define NMIDXDIFF(q, idx) IDXDIFF((q)->pidx, (q)->idx, (q)->sidx)

sys/dev/cxgbe/t4_netmap.c

920

MPASS(nm_txq->pidx != nm_txq->dbidx);

sys/dev/cxgbe/t4_netmap.c

942

__func__, nm_txq->doorbells, n, nm_txq->pidx, nm_txq));

sys/dev/cxgbe/t4_netmap.c

963

nm_txq->dbidx = nm_txq->pidx;

sys/dev/cxgbe/t4_netmap.c

977

struct fw_eth_tx_pkts_wr *wr = (void *)&nm_txq->desc[nm_txq->pidx];

sys/dev/cxgbe/t4_netmap.c

988

wr = (void *)&nm_txq->desc[nm_txq->pidx];

sys/dev/cxgbe/t4_sge.c

2207

MPASS(eq->pidx == eq->dbidx);

sys/dev/cxgbe/t4_sge.c

2212

if (eq->pidx == eq->cidx)

sys/dev/cxgbe/t4_sge.c

2215

available = IDXDIFF(eq->cidx, eq->pidx, eq->sidx) - 1;

sys/dev/cxgbe/t4_sge.c

2222

dst = (void *)&eq->desc[eq->pidx];

sys/dev/cxgbe/t4_sge.c

2223

if (__predict_true(eq->sidx - eq->pidx > n)) {

sys/dev/cxgbe/t4_sge.c

2226

eq->pidx += n;

sys/dev/cxgbe/t4_sge.c

2228

int first_portion = (eq->sidx - eq->pidx) * EQ_ESIZE;

sys/dev/cxgbe/t4_sge.c

2235

eq->pidx = n - (eq->sidx - eq->pidx);

sys/dev/cxgbe/t4_sge.c

2293

MPASS(eq->pidx == eq->dbidx);

sys/dev/cxgbe/t4_sge.c

2989

cookie->pidx = -1;

sys/dev/cxgbe/t4_sge.c

2995

if (eq->pidx == eq->cidx)

sys/dev/cxgbe/t4_sge.c

2998

available = IDXDIFF(eq->cidx, eq->pidx, eq->sidx) - 1;

sys/dev/cxgbe/t4_sge.c

3002

cookie->pidx = eq->pidx;

sys/dev/cxgbe/t4_sge.c

3006

w = &eq->desc[eq->pidx];

sys/dev/cxgbe/t4_sge.c

3007

IDXINCR(eq->pidx, ndesc, eq->sidx);

sys/dev/cxgbe/t4_sge.c

3008

if (__predict_false(cookie->pidx + ndesc > eq->sidx)) {

sys/dev/cxgbe/t4_sge.c

3010

wrq->ss_pidx = cookie->pidx;

sys/dev/cxgbe/t4_sge.c

3024

int ndesc, pidx;

sys/dev/cxgbe/t4_sge.c

3027

if (cookie->pidx == -1) {

sys/dev/cxgbe/t4_sge.c

3046

pidx = cookie->pidx;

sys/dev/cxgbe/t4_sge.c

3047

MPASS(pidx >= 0 && pidx < eq->sidx);

sys/dev/cxgbe/t4_sge.c

3051

MPASS(pidx == eq->dbidx);

sys/dev/cxgbe/t4_sge.c

3061

dst = (void *)&eq->desc[pidx];

sys/dev/cxgbe/t4_sge.c

3062

available = IDXDIFF(eq->cidx, eq->pidx, eq->sidx) - 1;

sys/dev/cxgbe/t4_sge.c

3079

MPASS(IDXDIFF(next->pidx, pidx, eq->sidx) == ndesc);

sys/dev/cxgbe/t4_sge.c

3080

next->pidx = pidx;

sys/dev/cxgbe/t4_sge.c

3084

MPASS(IDXDIFF(pidx, prev->pidx, eq->sidx) == prev->ndesc);

sys/dev/cxgbe/t4_sge.c

3095

MPASS(wrq->eq.pidx == wrq->eq.dbidx);

sys/dev/cxgbe/t4_sge.c

3152

eq->equeqidx = eq->pidx;

sys/dev/cxgbe/t4_sge.c

3153

} else if (IDXDIFF(eq->pidx, eq->equeqidx, eq->sidx) >= 32) {

sys/dev/cxgbe/t4_sge.c

3155

eq->equeqidx = eq->pidx;

sys/dev/cxgbe/t4_sge.c

3184

eth_tx(struct mp_ring *r, u_int cidx, u_int pidx, bool *coalescing)

sys/dev/cxgbe/t4_sge.c

3202

remaining = IDXDIFF(pidx, cidx, r->size);

sys/dev/cxgbe/t4_sge.c

3207

while (cidx != pidx) {

sys/dev/cxgbe/t4_sge.c

3219

if (eq->pidx == eq->cidx)

sys/dev/cxgbe/t4_sge.c

3222

avail = IDXDIFF(eq->cidx, eq->pidx, eq->sidx) - 1;

sys/dev/cxgbe/t4_sge.c

3284

wr = &eq->desc[eq->pidx];

sys/dev/cxgbe/t4_sge.c

3285

IDXINCR(eq->pidx, n, eq->sidx);

sys/dev/cxgbe/t4_sge.c

3313

wr = &eq->desc[eq->pidx];

sys/dev/cxgbe/t4_sge.c

3337

IDXINCR(eq->pidx, n, eq->sidx);

sys/dev/cxgbe/t4_sge.c

3357

} else if (eq->pidx == eq->cidx && txp->npkt > 0 &&

sys/dev/cxgbe/t4_sge.c

3383

wr = &eq->desc[eq->pidx];

sys/dev/cxgbe/t4_sge.c

3384

IDXINCR(eq->pidx, n, eq->sidx);

sys/dev/cxgbe/t4_sge.c

3696

fl->pidx = fl->cidx = fl->hw_cidx = fl->dbidx = 0;

sys/dev/cxgbe/t4_sge.c

3816

SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "pidx", CTLFLAG_RD, &fl->pidx,

sys/dev/cxgbe/t4_sge.c

4561

MPASS(eq->pidx == eq->cidx);

sys/dev/cxgbe/t4_sge.c

4585

SYSCTL_ADD_U16(ctx, children, OID_AUTO, "pidx", CTLFLAG_RD, &eq->pidx,

sys/dev/cxgbe/t4_sge.c

4599

eq->pidx = eq->cidx = eq->dbidx = 0;

sys/dev/cxgbe/t4_sge.c

5147

n = IDXDIFF(fl->pidx >> 3, fl->dbidx, fl->sidx);

sys/dev/cxgbe/t4_sge.c

5186

if (fl->pidx == max_pidx * 8)

sys/dev/cxgbe/t4_sge.c

5189

d = &fl->desc[fl->pidx];

sys/dev/cxgbe/t4_sge.c

5190

sd = &fl->sdesc[fl->pidx];

sys/dev/cxgbe/t4_sge.c

5253

if (__predict_false((++fl->pidx & 7) == 0)) {

sys/dev/cxgbe/t4_sge.c

5254

uint16_t pidx = fl->pidx >> 3;

sys/dev/cxgbe/t4_sge.c

5256

if (__predict_false(pidx == fl->sidx)) {

sys/dev/cxgbe/t4_sge.c

5257

fl->pidx = 0;

sys/dev/cxgbe/t4_sge.c

5258

pidx = 0;

sys/dev/cxgbe/t4_sge.c

5262

if (n < 8 || pidx == max_pidx)

sys/dev/cxgbe/t4_sge.c

5265

if (IDXDIFF(pidx, fl->dbidx, fl->sidx) >= 4)

sys/dev/cxgbe/t4_sge.c

5270

if ((fl->pidx >> 3) != fl->dbidx)

sys/dev/cxgbe/t4_sge.c

5658

wr = (void *)&eq->desc[eq->pidx];

sys/dev/cxgbe/t4_sge.c

5715

write_gl_to_txd(txq, m0, &dst, eq->sidx - ndesc < eq->pidx);

sys/dev/cxgbe/t4_sge.c

5719

txsd = &txq->sdesc[eq->pidx];

sys/dev/cxgbe/t4_sge.c

5752

txsd = &txq->sdesc[eq->pidx];

sys/dev/cxgbe/t4_sge.c

5804

wr = (void *)&eq->desc[eq->pidx];

sys/dev/cxgbe/t4_sge.c

5852

write_gl_to_txd(txq, m0, &dst, eq->sidx - ndesc < eq->pidx);

sys/dev/cxgbe/t4_sge.c

5871

txsd = &txq->sdesc[eq->pidx];

sys/dev/cxgbe/t4_sge.c

6048

wr = (void *)&eq->desc[eq->pidx];

sys/dev/cxgbe/t4_sge.c

6064

checkwrap = eq->sidx - ndesc < eq->pidx;

sys/dev/cxgbe/t4_sge.c

6135

txsd = &txq->sdesc[eq->pidx];

sys/dev/cxgbe/t4_sge.c

6161

wr = (void *)&eq->desc[eq->pidx];

sys/dev/cxgbe/t4_sge.c

6216

txsd = &txq->sdesc[eq->pidx];

sys/dev/cxgbe/t4_sge.c

6388

uint16_t hw_cidx, pidx;

sys/dev/cxgbe/t4_sge.c

6391

pidx = eq->pidx;

sys/dev/cxgbe/t4_sge.c

6393

if (pidx == hw_cidx)

sys/dev/cxgbe/t4_sge.c

6396

return (IDXDIFF(hw_cidx, pidx, eq->sidx) - 1);

sys/dev/cxgbe/t4_sge.c

6461

if (eq->cidx == eq->pidx)

sys/dev/cxgbe/t4_sge.c

6462

eq->equeqidx = eq->pidx;

sys/dev/e1000/em_txrx.c

472

em_isc_txd_flush(void *arg, uint16_t txqid, qidx_t pidx)

sys/dev/e1000/em_txrx.c

478

E1000_WRITE_REG(&sc->hw, E1000_TDT(txr->me), pidx);

sys/dev/e1000/em_txrx.c

547

uint32_t next_pidx, pidx;

sys/dev/e1000/em_txrx.c

552

pidx = iru->iru_pidx;

sys/dev/e1000/em_txrx.c

555

for (i = 0, next_pidx = pidx; i < count; i++) {

sys/dev/e1000/em_txrx.c

576

uint32_t next_pidx, pidx;

sys/dev/e1000/em_txrx.c

581

pidx = iru->iru_pidx;

sys/dev/e1000/em_txrx.c

584

for (i = 0, next_pidx = pidx; i < count; i++) {

sys/dev/e1000/em_txrx.c

597

qidx_t pidx)

sys/dev/e1000/em_txrx.c

603

E1000_WRITE_REG(&sc->hw, E1000_RDT(rxr->me), pidx);

sys/dev/e1000/igb_txrx.c

300

igb_isc_txd_flush(void *arg, uint16_t txqid, qidx_t pidx)

sys/dev/e1000/igb_txrx.c

306

E1000_WRITE_REG(&sc->hw, E1000_TDT(txr->me), pidx);

sys/dev/e1000/igb_txrx.c

372

uint32_t next_pidx, pidx;

sys/dev/e1000/igb_txrx.c

377

pidx = iru->iru_pidx;

sys/dev/e1000/igb_txrx.c

380

for (i = 0, next_pidx = pidx; i < count; i++) {

sys/dev/e1000/igb_txrx.c

391

qidx_t pidx)

sys/dev/e1000/igb_txrx.c

397

E1000_WRITE_REG(&sc->hw, E1000_RDT(rxr->me), pidx);

sys/dev/enetc/enetc.h

58

qidx_t pidx;

sys/dev/enetc/if_enetc.c

1097

qidx_t pidx, queue_len;

sys/dev/enetc/if_enetc.c

1102

pidx = ipi->ipi_pidx;

sys/dev/enetc/if_enetc.c

1109

desc = &queue->ring[pidx];

sys/dev/enetc/if_enetc.c

1118

if (++pidx == queue_len)

sys/dev/enetc/if_enetc.c

1119

pidx = 0;

sys/dev/enetc/if_enetc.c

1124

desc = &queue->ring[pidx];

sys/dev/enetc/if_enetc.c

1128

if (++pidx == queue_len)

sys/dev/enetc/if_enetc.c

1129

pidx = 0;

sys/dev/enetc/if_enetc.c

1134

desc = &queue->ring[pidx];

sys/dev/enetc/if_enetc.c

1139

if (++pidx == queue_len)

sys/dev/enetc/if_enetc.c

1140

pidx = 0;

sys/dev/enetc/if_enetc.c

1144

ipi->ipi_new_pidx = pidx;

sys/dev/enetc/if_enetc.c

1150

enetc_isc_txd_flush(void *data, uint16_t qid, qidx_t pidx)

sys/dev/enetc/if_enetc.c

1154

ENETC_TXQ_WR4(sc, qid, ENETC_TBPIR, pidx);

sys/dev/enetc/if_enetc.c

1194

enetc_isc_rxd_available(void *data, uint16_t qid, qidx_t pidx, qidx_t budget)

sys/dev/enetc/if_enetc.c

1203

desc = &queue->ring[pidx];

sys/dev/enetc/if_enetc.c

1213

while (pidx != hw_pidx && count < budget) {

sys/dev/enetc/if_enetc.c

1214

desc = &queue->ring[pidx];

sys/dev/enetc/if_enetc.c

1218

if (++pidx == queue_len)

sys/dev/enetc/if_enetc.c

1219

pidx = 0;

sys/dev/enetc/if_enetc.c

1295

qidx_t pidx, queue_len;

sys/dev/enetc/if_enetc.c

1301

pidx = iru->iru_pidx;

sys/dev/enetc/if_enetc.c

1306

desc = &queue->ring[pidx];

sys/dev/enetc/if_enetc.c

1310

if (++pidx == queue_len)

sys/dev/enetc/if_enetc.c

1311

pidx = 0;

sys/dev/enetc/if_enetc.c

1319

if (!queue->enabled && pidx >= 8) {

sys/dev/enetc/if_enetc.c

1326

enetc_isc_rxd_flush(void *data, uint16_t qid, uint8_t flid, qidx_t pidx)

sys/dev/enetc/if_enetc.c

1330

ENETC_RXQ_WR4(sc, qid, ENETC_RBCIR, pidx);

sys/dev/enetc/if_enetc.c

653

desc = &queue->ring[queue->pidx];

sys/dev/enetc/if_enetc.c

655

if (++queue->pidx == ENETC_MIN_DESC)

sys/dev/enetc/if_enetc.c

656

queue->pidx = 0;

sys/dev/enetc/if_enetc.c

670

ENETC_WR4(sc, ENETC_SICBDRPIR, queue->pidx);

sys/dev/enetc/if_enetc.c

674

if (ENETC_RD4(sc, ENETC_SICBDRCIR) == queue->pidx)

sys/dev/enetc/if_enetc.c

732

queue->pidx = 0;

sys/dev/enetc/if_enetc.c

733

ENETC_WR4(sc, ENETC_SICBDRPIR, queue->pidx);

sys/dev/enetc/if_enetc.c

734

ENETC_WR4(sc, ENETC_SICBDRCIR, queue->pidx);

sys/dev/enetc/if_enetc.c

959

qidx_t cidx, pidx;

sys/dev/enetc/if_enetc.c

963

pidx = ENETC_TXQ_RD4(sc, qid, ENETC_TBPIR);

sys/dev/enetc/if_enetc.c

966

while (pidx != cidx && timeout--) {

sys/dev/enic/enic_txrx.c

150

enic_isc_txd_flush(void *vsc, uint16_t txqid, qidx_t pidx)

sys/dev/enic/enic_txrx.c

269

uint32_t pidx;

sys/dev/enic/enic_txrx.c

277

pidx = iru->iru_pidx;

sys/dev/enic/enic_txrx.c

283

idx = pidx;

sys/dev/enic/enic_txrx.c

304

enic_isc_rxd_flush(void *vsc, uint16_t rxqid, uint8_t flid, qidx_t pidx)

sys/dev/enic/enic_txrx.c

320

ENIC_BUS_WRITE_4(rq->ctrl, RX_POSTED_INDEX, pidx);

sys/dev/iavf/iavf_txrx_iflib.c

410

iavf_isc_txd_flush(void *arg, uint16_t txqid, qidx_t pidx)

sys/dev/iavf/iavf_txrx_iflib.c

416

MPASS(pidx < vsi->shared->isc_ntxd[0]);

sys/dev/iavf/iavf_txrx_iflib.c

417

wr32(vsi->hw, txr->tail, pidx);

sys/dev/iavf/iavf_txrx_iflib.c

50

static void iavf_isc_txd_flush(void *arg, uint16_t txqid, qidx_t pidx);

sys/dev/iavf/iavf_txrx_iflib.c

56

qidx_t pidx);

sys/dev/iavf/iavf_txrx_iflib.c

576

uint16_t next_pidx, pidx;

sys/dev/iavf/iavf_txrx_iflib.c

581

pidx = iru->iru_pidx;

sys/dev/iavf/iavf_txrx_iflib.c

584

for (i = 0, next_pidx = pidx; i < count; i++) {

sys/dev/iavf/iavf_txrx_iflib.c

602

iavf_isc_rxd_flush(void * arg, uint16_t rxqid, uint8_t flid __unused, qidx_t pidx)

sys/dev/iavf/iavf_txrx_iflib.c

607

wr32(vsi->hw, rxr->tail, pidx);

sys/dev/ice/ice_iflib_recovery_txrx.c

100

qidx_t __unused pidx)

sys/dev/ice/ice_iflib_recovery_txrx.c

137

qidx_t __unused pidx, qidx_t __unused budget)

sys/dev/ice/ice_iflib_recovery_txrx.c

184

uint8_t flidx __unused, qidx_t __unused pidx)

sys/dev/ice/ice_iflib_recovery_txrx.c

49

static void ice_recovery_txd_flush(void *arg, uint16_t txqid, qidx_t pidx);

sys/dev/ice/ice_iflib_recovery_txrx.c

51

static int ice_recovery_rxd_available(void *arg, uint16_t rxqid, qidx_t pidx, qidx_t budget);

sys/dev/ice/ice_iflib_recovery_txrx.c

52

static void ice_recovery_rxd_flush(void *arg, uint16_t rxqid, uint8_t flidx, qidx_t pidx);

sys/dev/ice/ice_iflib_txrx.c

226

ice_ift_txd_flush(void *arg, uint16_t txqid, qidx_t pidx)

sys/dev/ice/ice_iflib_txrx.c

232

wr32(hw, txq->tail, pidx);

sys/dev/ice/ice_iflib_txrx.c

323

_ice_ift_rxd_available(struct ice_rx_queue *rxq, qidx_t pidx, qidx_t budget)

sys/dev/ice/ice_iflib_txrx.c

331

for (cnt = 0, i = pidx; cnt < nrxd - 1 && cnt < budget;) {

sys/dev/ice/ice_iflib_txrx.c

357

ice_ift_rxd_available(void *arg, uint16_t rxqid, qidx_t pidx, qidx_t budget)

sys/dev/ice/ice_iflib_txrx.c

362

return _ice_ift_rxd_available(rxq, pidx, budget);

sys/dev/ice/ice_iflib_txrx.c

475

uint32_t pidx;

sys/dev/ice/ice_iflib_txrx.c

479

pidx = iru->iru_pidx;

sys/dev/ice/ice_iflib_txrx.c

485

_ice_ift_rxd_refill(rxq, pidx, paddrs, count);

sys/dev/ice/ice_iflib_txrx.c

499

_ice_ift_rxd_refill(struct ice_rx_queue *rxq, uint32_t pidx,

sys/dev/ice/ice_iflib_txrx.c

505

for (i = 0, next_pidx = pidx; i < count; i++) {

sys/dev/ice/ice_iflib_txrx.c

52

static int _ice_ift_rxd_available(struct ice_rx_queue *rxq, qidx_t pidx, qidx_t budget);

sys/dev/ice/ice_iflib_txrx.c

524

qidx_t pidx)

sys/dev/ice/ice_iflib_txrx.c

529

_ice_ift_rxd_flush(sc, rxq, (uint32_t)pidx);

sys/dev/ice/ice_iflib_txrx.c

54

static void _ice_ift_rxd_refill(struct ice_rx_queue *rxq, uint32_t pidx,

sys/dev/ice/ice_iflib_txrx.c

542

_ice_ift_rxd_flush(struct ice_softc *sc, struct ice_rx_queue *rxq, uint32_t pidx)

sys/dev/ice/ice_iflib_txrx.c

544

wr32(&sc->hw, rxq->tail, pidx);

sys/dev/ice/ice_iflib_txrx.c

57

uint32_t pidx);

sys/dev/ice/ice_iflib_txrx.c

64

static void ice_ift_txd_flush(void *arg, uint16_t txqid, qidx_t pidx);

sys/dev/ice/ice_iflib_txrx.c

66

static int ice_ift_rxd_available(void *arg, uint16_t rxqid, qidx_t pidx, qidx_t budget);

sys/dev/ice/ice_iflib_txrx.c

660

ice_ift_txd_flush_subif(void *arg, uint16_t txqid, qidx_t pidx)

sys/dev/ice/ice_iflib_txrx.c

666

wr32(hw, txq->tail, pidx);

sys/dev/ice/ice_iflib_txrx.c

67

static void ice_ift_rxd_flush(void *arg, uint16_t rxqid, uint8_t flidx, qidx_t pidx);

sys/dev/ice/ice_iflib_txrx.c

682

ice_ift_rxd_available_subif(void *arg, uint16_t rxqid, qidx_t pidx, qidx_t budget)

sys/dev/ice/ice_iflib_txrx.c

687

return _ice_ift_rxd_available(rxq, pidx, budget);

sys/dev/ice/ice_iflib_txrx.c

72

static void ice_ift_txd_flush_subif(void *arg, uint16_t txqid, qidx_t pidx);

sys/dev/ice/ice_iflib_txrx.c

722

uint32_t pidx;

sys/dev/ice/ice_iflib_txrx.c

726

pidx = iru->iru_pidx;

sys/dev/ice/ice_iflib_txrx.c

729

_ice_ift_rxd_refill(rxq, pidx, paddrs, count);

sys/dev/ice/ice_iflib_txrx.c

73

static int ice_ift_rxd_available_subif(void *arg, uint16_t rxqid, qidx_t pidx, qidx_t budget);

sys/dev/ice/ice_iflib_txrx.c

744

qidx_t pidx)

sys/dev/ice/ice_iflib_txrx.c

749

_ice_ift_rxd_flush(mif->back, rxq, pidx);

sys/dev/ice/ice_iflib_txrx.c

76

static void ice_ift_rxd_flush_subif(void *arg, uint16_t rxqid, uint8_t flidx, qidx_t pidx);

sys/dev/igc/igc_txrx.c

328

igc_isc_txd_flush(void *arg, uint16_t txqid, qidx_t pidx)

sys/dev/igc/igc_txrx.c

334

IGC_WRITE_REG(&sc->hw, IGC_TDT(txr->me), pidx);

sys/dev/igc/igc_txrx.c

400

uint32_t next_pidx, pidx;

sys/dev/igc/igc_txrx.c

405

pidx = iru->iru_pidx;

sys/dev/igc/igc_txrx.c

408

for (i = 0, next_pidx = pidx; i < count; i++) {

sys/dev/igc/igc_txrx.c

419

qidx_t pidx)

sys/dev/igc/igc_txrx.c

425

IGC_WRITE_REG(&sc->hw, IGC_RDT(rxr->me), pidx);

sys/dev/ixgbe/ix_txrx.c

254

ixgbe_isc_txd_flush(void *arg, uint16_t txqid, qidx_t pidx)

sys/dev/ixgbe/ix_txrx.c

260

IXGBE_WRITE_REG(&sc->hw, txr->tail, pidx);

sys/dev/ixgbe/ix_txrx.c

331

uint32_t next_pidx, pidx;

sys/dev/ixgbe/ix_txrx.c

335

pidx = iru->iru_pidx;

sys/dev/ixgbe/ix_txrx.c

338

for (i = 0, next_pidx = pidx; i < count; i++) {

sys/dev/ixgbe/ix_txrx.c

350

qidx_t pidx)

sys/dev/ixgbe/ix_txrx.c

356

IXGBE_WRITE_REG(&sc->hw, rxr->tail, pidx);

sys/dev/ixgbe/ix_txrx.c

363

ixgbe_isc_rxd_available(void *arg, uint16_t qsidx, qidx_t pidx, qidx_t budget)

sys/dev/ixgbe/ix_txrx.c

373

for (cnt = 0, i = pidx; cnt < nrxd && cnt <= budget;) {

sys/dev/ixl/ixl_txrx.c

414

ixl_isc_txd_flush(void *arg, uint16_t txqid, qidx_t pidx)

sys/dev/ixl/ixl_txrx.c

424

MPASS(pidx < vsi->shared->isc_ntxd[0]);

sys/dev/ixl/ixl_txrx.c

425

wr32(vsi->hw, txr->tail, pidx);

sys/dev/ixl/ixl_txrx.c

553

uint32_t next_pidx, pidx;

sys/dev/ixl/ixl_txrx.c

558

pidx = iru->iru_pidx;

sys/dev/ixl/ixl_txrx.c

56

static void ixl_isc_txd_flush(void *arg, uint16_t txqid, qidx_t pidx);

sys/dev/ixl/ixl_txrx.c

561

for (i = 0, next_pidx = pidx; i < count; i++) {

sys/dev/ixl/ixl_txrx.c

569

ixl_isc_rxd_flush(void * arg, uint16_t rxqid, uint8_t flid __unused, qidx_t pidx)

sys/dev/ixl/ixl_txrx.c

574

wr32(vsi->hw, rxr->tail, pidx);

sys/dev/ixl/ixl_txrx.c

62

qidx_t pidx);

sys/dev/mgb/if_mgb.c

1003

mgb_isc_txd_flush(void *xsc, uint16_t txqid, qidx_t pidx)

sys/dev/mgb/if_mgb.c

1012

if (rdata->last_tail != pidx) {

sys/dev/mgb/if_mgb.c

1013

rdata->last_tail = pidx;

sys/dev/mgb/if_mgb.c

1165

mgb_isc_rxd_flush(void *xsc, uint16_t rxqid, uint8_t flid, qidx_t pidx)

sys/dev/mgb/if_mgb.c

1177

sc->rx_ring_data.last_tail = MGB_PREV_RING_IDX(pidx);

sys/dev/mgb/if_mgb.c

965

qidx_t pidx, nsegs;

sys/dev/mgb/if_mgb.c

973

pidx = ipi->ipi_pidx;

sys/dev/mgb/if_mgb.c

980

txd = &rdata->ring[pidx];

sys/dev/mgb/if_mgb.c

996

pidx = MGB_NEXT_RING_IDX(pidx);

sys/dev/mgb/if_mgb.c

998

ipi->ipi_new_pidx = pidx;

sys/dev/mlx4/mlx4_core/mlx4_cmd.c

911

int vidx, pidx;

sys/dev/mlx4/mlx4_core/mlx4_cmd.c

946

pidx = priv->virt2phys_pkey[slave][port - 1][vidx];

sys/dev/mlx4/mlx4_core/mlx4_cmd.c

947

outtab[vidx % 32] = cpu_to_be16(table[pidx]);

sys/dev/ntb/ntb.c

263

ntb_peer_port_number(device_t ntb, int pidx)

sys/dev/ntb/ntb.c

265

return (NTB_PEER_PORT_NUMBER(device_get_parent(ntb), pidx));

sys/dev/ntb/ntb.h

94

int ntb_peer_port_number(device_t ntb, int pidx);

sys/dev/ntb/ntb_hw/ntb_hw_amd.c

185

amd_ntb_peer_port_number(device_t dev, int pidx)

sys/dev/ntb/ntb_hw/ntb_hw_amd.c

190

__func__, pidx, ntb->conn_type);

sys/dev/ntb/ntb_hw/ntb_hw_amd.c

192

if (pidx != NTB_DEF_PEER_IDX)

sys/dev/ntb/ntb_hw/ntb_hw_intel.c

2577

intel_ntb_peer_port_number(device_t dev, int pidx)

sys/dev/ntb/ntb_hw/ntb_hw_intel.c

2581

if (pidx != 0)

sys/dev/ntb/ntb_hw/ntb_hw_plx.c

517

ntb_plx_peer_port_number(device_t dev, int pidx)

sys/dev/ntb/ntb_hw/ntb_hw_plx.c

521

if (pidx != 0)

sys/dev/ntb/test/ntb_tool.c

1000

int widx, pidx, rc;

sys/dev/ntb/test/ntb_tool.c

1003

for (pidx = 0; pidx < tc->peer_cnt; pidx++) {

sys/dev/ntb/test/ntb_tool.c

1004

tc->peers[pidx].inmw_cnt = ntb_mw_count(tc->dev);

sys/dev/ntb/test/ntb_tool.c

1005

tc->peers[pidx].inmws = malloc(tc->peers[pidx].inmw_cnt *

sys/dev/ntb/test/ntb_tool.c

1006

sizeof(*tc->peers[pidx].inmws), M_NTB_TOOL,

sys/dev/ntb/test/ntb_tool.c

1009

for (widx = 0; widx < tc->peers[pidx].inmw_cnt; widx++) {

sys/dev/ntb/test/ntb_tool.c

1010

mw = &tc->peers[pidx].inmws[widx];

sys/dev/ntb/test/ntb_tool.c

1014

mw->pidx = pidx;

sys/dev/ntb/test/ntb_tool.c

1212

int sidx, pidx;

sys/dev/ntb/test/ntb_tool.c

1221

tc->inspads[sidx].pidx = -1;

sys/dev/ntb/test/ntb_tool.c

1226

for (pidx = 0; pidx < tc->peer_cnt; pidx++) {

sys/dev/ntb/test/ntb_tool.c

1227

tc->peers[pidx].outspad_cnt = ntb_spad_count(tc->dev);

sys/dev/ntb/test/ntb_tool.c

1228

tc->peers[pidx].outspads = malloc(tc->peers[pidx].outspad_cnt *

sys/dev/ntb/test/ntb_tool.c

1229

sizeof(*tc->peers[pidx].outspads), M_NTB_TOOL, M_WAITOK |

sys/dev/ntb/test/ntb_tool.c

1232

for (sidx = 0; sidx < tc->peers[pidx].outspad_cnt; sidx++) {

sys/dev/ntb/test/ntb_tool.c

1233

tc->peers[pidx].outspads[sidx].sidx = sidx;

sys/dev/ntb/test/ntb_tool.c

1234

tc->peers[pidx].outspads[sidx].pidx = pidx;

sys/dev/ntb/test/ntb_tool.c

1235

tc->peers[pidx].outspads[sidx].tc = tc;

sys/dev/ntb/test/ntb_tool.c

1243

int pidx;

sys/dev/ntb/test/ntb_tool.c

1249

for (pidx = 0; pidx < tc->peer_cnt; pidx++)

sys/dev/ntb/test/ntb_tool.c

1250

free(tc->peers[pidx].outspads, M_NTB_TOOL);

sys/dev/ntb/test/ntb_tool.c

1311

unsigned int pidx, sidx, widx;

sys/dev/ntb/test/ntb_tool.c

1360

for (pidx = 0; pidx < tc->peer_cnt; pidx++) {

sys/dev/ntb/test/ntb_tool.c

1361

snprintf(buf, sizeof(buf), "peer%d", pidx);

sys/dev/ntb/test/ntb_tool.c

1368

CTLTYPE_UINT | CTLFLAG_RDTUN | CTLFLAG_MPSAFE, tc, pidx,

sys/dev/ntb/test/ntb_tool.c

1372

CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, tc, pidx,

sys/dev/ntb/test/ntb_tool.c

1376

CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, tc, pidx,

sys/dev/ntb/test/ntb_tool.c

1379

for (widx = 0; widx < tc->peers[pidx].inmw_cnt; widx++) {

sys/dev/ntb/test/ntb_tool.c

1385

&tc->peers[pidx].inmws[widx], 0,

sys/dev/ntb/test/ntb_tool.c

1393

&tc->peers[pidx].inmws[widx], 0,

sys/dev/ntb/test/ntb_tool.c

1401

&tc->peers[pidx].inmws[widx], 0,

sys/dev/ntb/test/ntb_tool.c

1405

for (sidx = 0; sidx < tc->peers[pidx].outspad_cnt; sidx++) {

sys/dev/ntb/test/ntb_tool.c

213

int pidx;

sys/dev/ntb/test/ntb_tool.c

243

int pidx;

sys/dev/ntb/test/ntb_tool.c

248

int pidx;

sys/dev/ntb/test/ntb_tool.c

643

int rc, pidx = arg2, peer_port;

sys/dev/ntb/test/ntb_tool.c

645

peer_port = ntb_peer_port_number(tc->dev, pidx);

sys/dev/ntb/test/ntb_tool.c

651

tc->peers[pidx].port_no = peer_port;

sys/dev/ntb/test/ntb_tool.c

676

int pidx;

sys/dev/ntb/test/ntb_tool.c

681

for (pidx = 0; pidx < tc->peer_cnt; pidx++) {

sys/dev/ntb/test/ntb_tool.c

682

tc->peers[pidx].pidx = pidx;

sys/dev/ntb/test/ntb_tool.c

683

tc->peers[pidx].tc = tc;

sys/dev/ntb/test/ntb_tool.c

730

int up = 0, pidx = arg2;

sys/dev/ntb/test/ntb_tool.c

738

if (up & (1UL << pidx))

sys/dev/ntb/test/ntb_tool.c

751

int rc, pidx = arg2;

sys/dev/ntb/test/ntb_tool.c

763

tc->link_mask = (1ULL << ((pidx) % 64));

sys/dev/ntb/test/ntb_tool.c

802

tool_setup_mw(struct tool_ctx *tc, unsigned int pidx, unsigned int widx,

sys/dev/ntb/test/ntb_tool.c

805

struct tool_mw *inmw = &tc->peers[pidx].inmws[widx];

sys/dev/ntb/test/ntb_tool.c

869

tool_free_mw(struct tool_ctx *tc, int pidx, int widx)

sys/dev/ntb/test/ntb_tool.c

871

struct tool_mw *inmw = &tc->peers[pidx].inmws[widx];

sys/dev/ntb/test/ntb_tool.c

905

ntb_peer_port_number(inmw->tc->dev, inmw->pidx), inmw->pidx);

sys/dev/ntb/test/ntb_tool.c

936

tool_free_mw(tc, inmw->pidx, inmw->widx);

sys/dev/ntb/test/ntb_tool.c

938

rc = tool_setup_mw(tc, inmw->pidx, inmw->widx, wsize);

sys/dev/ntb/test/ntb_tool.c

986

int widx, pidx;

sys/dev/ntb/test/ntb_tool.c

989

for (pidx = 0; pidx < tc->peer_cnt; pidx++) {

sys/dev/ntb/test/ntb_tool.c

990

for (widx = 0; widx < tc->peers[pidx].inmw_cnt; widx++)

sys/dev/ntb/test/ntb_tool.c

991

tool_free_mw(tc, pidx, widx);

sys/dev/ntb/test/ntb_tool.c

992

free(tc->peers[pidx].inmws, M_NTB_TOOL);

sys/dev/oce/oce_if.c

1159

pd->wqe_idx = wq->ring->pidx;

sys/dev/oce/oce_if.c

1171

pd->wqe_idx = wq->ring->pidx;

sys/dev/oce/oce_if.c

1518

if (rq->ring->cidx == rq->ring->pidx) {

sys/dev/oce/oce_if.c

1760

if (rq->ring->cidx == rq->ring->pidx) {

sys/dev/oce/oce_if.c

1876

pd = &rq->pckts[rq->ring->pidx];

sys/dev/oce/oce_if.h

296

ring->pidx = GET_Q_NEXT(ring->pidx, n, ring->num_items)

sys/dev/oce/oce_if.h

303

(void *)(((type *)DBUF_VA(&ring->dma)) + ring->pidx)

sys/dev/oce/oce_if.h

305

(uint64_t)(((type *)DBUF_PA(ring->dbuf)) + ring->pidx)

sys/dev/oce/oce_if.h

325

uint16_t pidx; /* Put Ptr */

sys/dev/oce/oce_queue.c

1303

rq->ring->pidx = 0;

sys/dev/oce/oce_queue.c

334

wq->ring->pidx = 0;

sys/dev/oce/oce_queue.c

505

rq->ring->pidx = 0;

sys/dev/ocs_fc/ocs_utils.c

421

uint32_t pidx; /*<< producer index */

sys/dev/ocs_fc/ocs_utils.c

451

cbuf->pidx = 0;

sys/dev/ocs_fc/ocs_utils.c

534

cbuf->array[cbuf->pidx] = elem;

sys/dev/ocs_fc/ocs_utils.c

535

if (unlikely(++cbuf->pidx >= cbuf->entry_count)) {

sys/dev/ocs_fc/ocs_utils.c

536

cbuf->pidx = 0;

sys/dev/vmware/vmxnet3/if_vmx.c

1289

int pidx;

sys/dev/vmware/vmxnet3/if_vmx.c

1299

pidx = pi->ipi_pidx;

sys/dev/vmware/vmxnet3/if_vmx.c

1304

sop = &txr->vxtxr_txd[pidx];

sys/dev/vmware/vmxnet3/if_vmx.c

1308

txd = &txr->vxtxr_txd[pidx];

sys/dev/vmware/vmxnet3/if_vmx.c

1322

if (++pidx == txr->vxtxr_ndesc) {

sys/dev/vmware/vmxnet3/if_vmx.c

1323

pidx = 0;

sys/dev/vmware/vmxnet3/if_vmx.c

1330

pi->ipi_new_pidx = pidx;

sys/dev/vmware/vmxnet3/if_vmx.c

1366

vmxnet3_isc_txd_flush(void *vsc, uint16_t txqid, qidx_t pidx)

sys/dev/vmware/vmxnet3/if_vmx.c

1383

if (txq->vxtxq_last_flush == pidx)

sys/dev/vmware/vmxnet3/if_vmx.c

1385

txq->vxtxq_last_flush = pidx;

sys/dev/vmware/vmxnet3/if_vmx.c

1386

vmxnet3_write_bar0(sc, VMXNET3_BAR0_TXH(txq->vxtxq_id), pidx);

sys/dev/vmware/vmxnet3/if_vmx.c

1712

vmxnet3_isc_rxd_flush(void *vsc, uint16_t rxqid, uint8_t flid, qidx_t pidx)

sys/dev/vmware/vmxnet3/if_vmx.c

1724

vmxnet3_write_bar0(sc, r, pidx);

sys/dev/xen/gntdev/gntdev.c

789

vm_pindex_t pidx, ridx;

sys/dev/xen/gntdev/gntdev.c

798

pidx = OFF_TO_IDX(offset);

sys/dev/xen/gntdev/gntdev.c

816

vm_page_replace(page, object, pidx, *mres);

sys/dev/xen/gntdev/gntdev.c

818

vm_page_insert(page, object, pidx);

sys/dev/xen/privcmd/privcmd.c

149

vm_pindex_t pidx;

sys/dev/xen/privcmd/privcmd.c

155

pidx = OFF_TO_IDX(offset);

sys/dev/xen/privcmd/privcmd.c

156

if (pidx >= map->size || BIT_ISSET(map->size, pidx, map->err))

sys/dev/xen/privcmd/privcmd.c

172

vm_page_replace(page, object, pidx, *mres);

sys/dev/xen/privcmd/privcmd.c

174

vm_page_insert(page, object, pidx);

sys/kern/uipc_shm.c

281

shm_largepage_phys_populate(vm_object_t object, vm_pindex_t pidx,

sys/kern/uipc_shm.c

288

if (psind == 0 || pidx >= object->size)

sys/kern/uipc_shm.c

290

*first = rounddown2(pidx, pagesizes[psind] / PAGE_SIZE);

sys/kern/vfs_bio.c

5101

int pidx;

sys/kern/vfs_bio.c

5107

pidx = vm_fault_quick_hold_pages(&curproc->p_vmspace->vm_map,

sys/kern/vfs_bio.c

5109

if (pidx < 0)

sys/kern/vfs_bio.c

5112

bp->b_npages = pidx;

sys/kern/vfs_bio.c

5115

pmap_qenter((vm_offset_t)bp->b_kvabase, bp->b_pages, pidx);

sys/net/iflib.c

2074

int err, frag_idx, i, idx, n, pidx;

sys/net/iflib.c

2083

pidx = fl->ifl_pidx;

sys/net/iflib.c

2084

idx = pidx;

sys/net/iflib.c

2093

if (pidx < fl->ifl_cidx)

sys/net/iflib.c

2094

MPASS(pidx + n <= fl->ifl_cidx);

sys/net/iflib.c

2095

if (pidx == fl->ifl_cidx && (credits < fl->ifl_size))

sys/net/iflib.c

2097

if (pidx > fl->ifl_cidx)

sys/net/iflib.c

2098

MPASS(n <= fl->ifl_size - pidx + fl->ifl_cidx);

sys/net/iflib.c

2167

iru.iru_pidx = pidx;

sys/net/iflib.c

2172

pidx = idx;

sys/net/iflib.c

2179

iru.iru_pidx = pidx;

sys/net/iflib.c

3415

int ntxd, pidx;

sys/net/iflib.c

3420

pidx = txq->ift_pidx & (ntxd - 1);

sys/net/iflib.c

3422

m = IFLIB_GET_MBUF(ifsd_m[pidx]);

sys/net/iflib.c

3423

ifsd_m[pidx] = NULL;

sys/net/iflib.c

3424

bus_dmamap_unload(txq->ift_buf_tag, txq->ift_sds.ifsd_map[pidx]);

sys/net/iflib.c

3427

txq->ift_sds.ifsd_tso_map[pidx]);

sys/net/iflib.c

3491

int err, nsegs, ndesc, max_segs, pidx;

sys/net/iflib.c

3503

pidx = txq->ift_pidx;

sys/net/iflib.c

3504

map = txq->ift_sds.ifsd_map[pidx];

sys/net/iflib.c

3510

map = txq->ift_sds.ifsd_tso_map[pidx];

sys/net/iflib.c

3517

map = txq->ift_sds.ifsd_map[pidx];

sys/net/iflib.c

3532

pi.ipi_pidx = pidx;

sys/net/iflib.c

3591

ifsd_m[pidx] = IFLIB_SAVE_MBUF(m_head, flags);

sys/net/iflib.c

3635

MPASS(pidx >= 0 && pidx < txq->ift_size);

sys/net/iflib.c

3653

MPASS(pi.ipi_new_pidx != pidx);

sys/net/iflib.c

3833

iflib_txq_drain(struct ifmp_ring *r, uint32_t cidx, uint32_t pidx)

sys/net/iflib.c

3850

avail = IDXDIFF(pidx, cidx, r->size);

sys/net/iflib.c

3947

iflib_txq_drain_free(struct ifmp_ring *r, uint32_t cidx, uint32_t pidx)

sys/net/iflib.c

3960

avail = IDXDIFF(pidx, cidx, r->size);

sys/net/iflib.c

451

get_inuse(int size, qidx_t cidx, qidx_t pidx, uint8_t gen)

sys/net/iflib.c

455

if (pidx > cidx)

sys/net/iflib.c

456

used = pidx - cidx;

sys/net/iflib.c

457

else if (pidx < cidx)

sys/net/iflib.c

458

used = size - cidx + pidx;

sys/net/iflib.c

459

else if (gen == 0 && pidx == cidx)

sys/net/iflib.c

461

else if (gen == 1 && pidx == cidx)

sys/net/iflib.h

179

void (*ift_txd_flush) (void *, uint16_t, qidx_t pidx);

sys/net/iflib.h

182

int (*ift_rxd_available) (void *, uint16_t qsidx, qidx_t pidx, qidx_t budget);

sys/net/iflib.h

185

void (*ift_rxd_flush) (void *, uint16_t qsidx, uint8_t flidx, qidx_t pidx);

sys/net/mp_ring.c

101

MPASS(cidx != pidx);

sys/net/mp_ring.c

108

while (cidx != pidx) {

sys/net/mp_ring.c

110

n = r->drain(r, cidx, pidx);

sys/net/mp_ring.c

133

if (cidx != pidx && pending < 64 && total < budget)

sys/net/mp_ring.c

157

pidx = ns.pidx_tail;

sys/net/mp_ring.c

172

uint16_t pidx = os.pidx_tail;

sys/net/mp_ring.c

175

MPASS(cidx != pidx);

sys/net/mp_ring.c

182

while (cidx != pidx) {

sys/net/mp_ring.c

184

n = r->drain(r, cidx, pidx);

sys/net/mp_ring.c

212

if (cidx != pidx && pending < 64 && total < budget)

sys/net/mp_ring.c

240

pidx = ns.pidx_tail;

sys/net/mp_ring.c

98

uint16_t pidx = os.pidx_tail;

sys/net/route/nhop_utils.c

135

bitmask_swap(struct bitmask_head *bh, void *new_idx, uint32_t new_items, void **pidx)

sys/net/route/nhop_utils.c

144

if (pidx != NULL)

sys/net/route/nhop_utils.c

145

*pidx = old_ptr;

sys/net/route/nhop_utils.c

153

bitmask_alloc_idx(struct bitmask_head *bi, uint16_t *pidx)

sys/net/route/nhop_utils.c

172

*pidx = v;

sys/net/route/nhop_utils.h

176

void bitmask_swap(struct bitmask_head *bh, void *new_idx, uint32_t new_items, void **pidx);

sys/net/route/nhop_utils.h

179

int bitmask_alloc_idx(struct bitmask_head *bi, uint16_t *pidx);

sys/netipsec/ipsec_output.c

115

struct secpolicy *sp, u_int *pidx, int *error)

sys/netipsec/ipsec_output.c

126

isr = sp->req[*pidx];

sys/netipsec/ipsec_output.c

159

saidx = &sp->req[*pidx]->saidx;

sys/netipsec/ipsec_output.c

168

if (ipsec_get_reqlevel(sp, *pidx) != IPSEC_LEVEL_REQUIRE) {

sys/netipsec/ipsec_output.c

175

if (sp->tcount > ++(*pidx))

sys/netipsec/ipsec_output.c

540

u_int *pidx, int *error)

sys/netipsec/ipsec_output.c

552

isr = sp->req[*pidx];

sys/netipsec/ipsec_output.c

598

saidx = &sp->req[*pidx]->saidx;

sys/netipsec/ipsec_output.c

607

if (ipsec_get_reqlevel(sp, *pidx) != IPSEC_LEVEL_REQUIRE) {

sys/netipsec/ipsec_output.c

614

if (sp->tcount > ++(*pidx))

sys/netpfil/ipfw/ip_fw_sockopt.c

153

struct tid_info *ti, struct obj_idx *pidx, int *unresolved);

sys/netpfil/ipfw/ip_fw_sockopt.c

2021

struct obj_idx *oib, struct obj_idx *pidx, struct tid_info *ti)

sys/netpfil/ipfw/ip_fw_sockopt.c

2032

for (p = oib; p < pidx; p++) {

sys/netpfil/ipfw/ip_fw_sockopt.c

2058

unref_oib_objects(ch, cmd, oib, pidx);

sys/netpfil/ipfw/ip_fw_sockopt.c

2151

struct obj_idx *pidx, int *unresolved)

sys/netpfil/ipfw/ip_fw_sockopt.c

2163

pidx->uidx = ti->uidx;

sys/netpfil/ipfw/ip_fw_sockopt.c

2164

pidx->type = ti->type;

sys/netpfil/ipfw/ip_fw_sockopt.c

2203

struct obj_idx *pidx;

sys/netpfil/ipfw/ip_fw_sockopt.c

2207

pidx = oib;

sys/netpfil/ipfw/ip_fw_sockopt.c

2220

error = ref_opcode_object(ch, cmd, ti, pidx, &unresolved);

sys/netpfil/ipfw/ip_fw_sockopt.c

2228

pidx->off = rule->cmd_len - l;

sys/netpfil/ipfw/ip_fw_sockopt.c

2229

pidx++;

sys/netpfil/ipfw/ip_fw_sockopt.c

2235

unref_oib_objects(ch, rule->cmd, oib, pidx);

sys/netpfil/ipfw/ip_fw_sockopt.c

2240

if (pidx != oib)

sys/netpfil/ipfw/ip_fw_sockopt.c

2241

error = create_objects_compat(ch, rule->cmd, oib, pidx, ti);

sys/netpfil/ipfw/ip_fw_sockopt.c

2244

ci->object_opcodes = (uint16_t)(pidx - oib);

sys/netpfil/ipfw/ip_fw_sockopt.c

3735

ipfw_objhash_alloc_idx(void *n, uint32_t *pidx)

sys/netpfil/ipfw/ip_fw_sockopt.c

3757

*pidx = v;

sys/netpfil/pf/pf_table.c

2317

pfr_pool_get(struct pfr_ktable *kt, int *pidx, struct pf_addr *counter,

sys/netpfil/pf/pf_table.c

2325

MPASS(pidx != NULL);

sys/netpfil/pf/pf_table.c

2347

idx = *pidx;

sys/netpfil/pf/pf_table.c

2395

*pidx = idx;

sys/netpfil/pf/pf_table.c

2419

*pidx = idx;

sys/powerpc/booke/pmap_32.c

242

unsigned int pidx;

sys/powerpc/booke/pmap_32.c

263

pidx = (PTBL_PAGES * pdir_idx) + i;

sys/powerpc/booke/pmap_32.c

278

m->pindex = pidx;

sys/sys/mbuf.h

415

m_epg_pagelen(const struct mbuf *m, int pidx, int pgoff)

sys/sys/mbuf.h

418

KASSERT(pgoff == 0 || pidx == 0,

sys/sys/mbuf.h

419

("page %d with non-zero offset %d in %p", pidx, pgoff, m));

sys/sys/mbuf.h

421

if (pidx == m->m_epg_npgs - 1) {

sys/vm/device_pager.c

398

dev_pager_populate(vm_object_t object, vm_pindex_t pidx, int fault_type,

sys/vm/device_pager.c

405

return (object->un_pager.devp.ops->cdev_pg_populate(object, pidx,

sys/vm/device_pager.c

67

static int dev_pager_populate(vm_object_t object, vm_pindex_t pidx,

sys/vm/phys_pager.c

230

default_phys_pager_populate(vm_object_t object, vm_pindex_t pidx,

sys/vm/phys_pager.c

240

base = rounddown(pidx, phys_pager_cluster);

sys/vm/phys_pager.c

265

phys_pager_populate(vm_object_t object, vm_pindex_t pidx, int fault_type,

sys/vm/phys_pager.c

268

return (object->un_pager.phys.ops->phys_pg_populate(object, pidx,

sys/vm/phys_pager.c

55

static int default_phys_pager_populate(vm_object_t object, vm_pindex_t pidx,

sys/vm/vm_fault.c

521

vm_pindex_t map_first, map_last, pager_first, pager_last, pidx;

sys/vm/vm_fault.c

645

for (pidx = pager_first; pidx <= pager_last; pidx += npages) {

sys/vm/vm_fault.c

648

m = vm_page_lookup(fs->first_object, pidx);

sys/vm/vm_fault.c

649

vaddr = fs->entry->start + IDX_TO_OFF(pidx) - fs->entry->offset;

sys/vm/vm_fault.c

650

KASSERT(m != NULL && m->pindex == pidx,

sys/vm/vm_fault.c

654

pidx + OFF_TO_IDX(pagesizes[psind]) - 1 > pager_last ||

sys/vm/vm_map.c

2154

int gap, pidx, rv, try;

sys/vm/vm_map.c

2227

pidx = 0;

sys/vm/vm_map.c

2239

pidx = VM_NRESERVLEVEL;

sys/vm/vm_map.c

2240

while (pidx > 0 && length < pagesizes[pidx])

sys/vm/vm_map.c

2241

pidx--;

sys/vm/vm_map.c

2246

aslr_pages_rnd_64[pidx] : aslr_pages_rnd_32[pidx];

sys/vm/vm_map.c

2248

length + gap * pagesizes[pidx]);

sys/vm/vm_map.c

2249

if (*addr + length + gap * pagesizes[pidx] >

sys/vm/vm_map.c

2253

*addr += (arc4random() % gap) * pagesizes[pidx];

sys/vm/vm_object.c

2277

vm_pindex_t pidx;

sys/vm/vm_object.c

2279

pidx = swap_pager_seek_data(prev_object, next_pindex);

sys/vm/vm_object.c

2280

KASSERT(pidx >= next_end,

sys/vm/vm_object.c

2282

prev_object, pidx, (uintmax_t)prev_offset,

sys/vm/vm_pager.h

178

vm_pager_populate(vm_object_t object, vm_pindex_t pidx, int fault_type,

sys/vm/vm_pager.h

183

MPASS(pidx < object->size);

sys/vm/vm_pager.h

185

return ((*pagertab[object->type]->pgo_populate)(object, pidx,

sys/vm/vm_pager.h

290

int (*cdev_pg_populate)(vm_object_t vm_obj, vm_pindex_t pidx,

sys/vm/vm_pager.h

311

int (*phys_pg_populate)(vm_object_t vm_obj, vm_pindex_t pidx,

sys/x86/iommu/iommu_utils.c

704

vm_pindex_t idx, pidx;

sys/x86/iommu/iommu_utils.c

710

for (pidx = idx = 0, i = 0; i < lvl; i++, pidx = idx) {

sys/x86/iommu/iommu_utils.c

712

pidx * IOMMU_NPTEPG + 1;