bin/stty/key.c

150

print(&ip->t, &ip->win, ip->queue, ip->ldisc, STTY_BSD);

bin/stty/key.c

189

print(&ip->t, &ip->win, ip->queue, ip->ldisc, STTY_BSD);

bin/stty/print.c

55

print(struct termios *tp, struct winsize *wp, int queue, const char *ldisc,

bin/stty/print.c

76

if (queue)

bin/stty/print.c

77

cnt += printf(" queue = %d;", queue);

bin/stty/stty.c

106

if (ioctl(i.fd, TIOCGQSIZE, &i.queue) < 0)

bin/stty/stty.c

116

print(&i.t, &i.win, i.queue, i.ldisc, fmt);

bin/stty/stty.h

43

int queue; /* queue size */

dist/pf/sbin/pfctl/parse.y

1647

if (strlcpy($$->queue, $1, sizeof($$->queue)) >=

dist/pf/sbin/pfctl/parse.y

1648

sizeof($$->queue)) {

dist/pf/sbin/pfctl/parse.y

165

char queue[PF_QNAME_SIZE];

dist/pf/sbin/pfctl/parse.y

1650

"%d chars)", $1, sizeof($$->queue)-1);

dist/pf/sbin/pfctl/parse.y

389

struct node_queue *queue;

dist/pf/sbin/pfctl/parse.y

4429

LOOP_THROUGH(struct node_queue, queue,

dist/pf/sbin/pfctl/parse.y

4432

queue->queue);

dist/pf/sbin/pfctl/parse.y

4466

LOOP_THROUGH(struct node_queue, queue, nqueues,

dist/pf/sbin/pfctl/parse.y

4476

if (strlcpy(n->queue, queue->queue,

dist/pf/sbin/pfctl/parse.y

4477

sizeof(n->queue)) >= sizeof(n->queue))

dist/pf/sbin/pfctl/parse.y

4523

if (!strncmp(a->qname, tqueue->queue, PF_QNAME_SIZE) &&

dist/pf/sbin/pfctl/parse.y

4578

if (!strcmp(a->qname, nq->queue)) {

dist/pf/sbin/pfctl/parse.y

459

%type <v.queue> qassign qassign_list qassign_item

dist/pf/sbin/pfctl/parse.y

4592

if (strlcpy(n->queue, nq->queue,

dist/pf/sbin/pfctl/parse.y

4593

sizeof(n->queue)) >=

dist/pf/sbin/pfctl/parse.y

4594

sizeof(n->queue))

dist/pf/sbin/pfctl/parse.y

4619

queue, nqueues,

dist/pf/sbin/pfctl/parse.y

4621

queue->queue);

dist/pf/sbin/pfctl/pfctl_optimize.c

812

TAILQ_HEAD( , pf_opt_rule) queue;

dist/pf/sbin/pfctl/pfctl_optimize.c

846

TAILQ_INIT(&queue);

dist/pf/sbin/pfctl/pfctl_optimize.c

849

TAILQ_INSERT_TAIL(&queue, por1, por_entry);

dist/pf/sbin/pfctl/pfctl_optimize.c

852

while ((por1 = TAILQ_FIRST(&queue)) != NULL) {

dist/pf/sbin/pfctl/pfctl_optimize.c

853

TAILQ_REMOVE(&queue, por1, por_entry);

dist/pf/sbin/pfctl/pfctl_optimize.c

879

struct pf_opt_queue queue;

dist/pf/sbin/pfctl/pfctl_optimize.c

884

TAILQ_INIT(&queue);

dist/pf/sbin/pfctl/pfctl_optimize.c

914

TAILQ_INSERT_TAIL(&queue, por, por_entry);

dist/pf/sbin/pfctl/pfctl_optimize.c

922

if (construct_superblocks(pf, &queue, &prof_superblocks))

lib/libpthread/pthread.c

1214

pthread_queue_t *queue, const struct timespec *abstime,

lib/libpthread/pthread.c

1271

pthread__unpark(pthread_queue_t *queue, pthread_t self,

lib/libpthread/pthread.c

1276

target = PTQ_FIRST(queue);

lib/libpthread/pthread.c

1278

PTQ_REMOVE(queue, target, pt_sleep);

lib/libpthread/pthread.c

1283

pthread__unpark_all(pthread_queue_t *queue, pthread_t self,

lib/libpthread/pthread.c

1291

PTQ_FOREACH(target, queue, pt_sleep) {

lib/libpthread/pthread.c

1299

PTQ_INIT(queue);

lib/libpthread/pthread_rwlock.c

579

pthread_queue_t *queue;

lib/libpthread/pthread_rwlock.c

582

if ((queue = self->pt_sleepobj) == NULL) {

lib/libpthread/pthread_rwlock.c

586

PTQ_REMOVE(queue, self, pt_sleep);

libexec/atrun/atrun.c

156

int queue;

libexec/atrun/atrun.c

323

queue = *filename;

libexec/atrun/atrun.c

325

if (queue > 'b')

libexec/atrun/atrun.c

326

nice(queue - 'b');

libexec/atrun/atrun.c

392

char queue;

libexec/atrun/atrun.c

482

if (sscanf(dirent->d_name, "%c%5x%8lx", &queue, &jobno,

libexec/atrun/atrun.c

489

if (isupper((unsigned char)queue) &&

libexec/atrun/atrun.c

499

if (islower((unsigned char)queue))

sys/altq/altq_wfq.c

117

wfq *queue;

sys/altq/altq_wfq.c

138

queue = malloc(sizeof(wfq) * DEFAULT_QSIZE, M_DEVBUF, M_WAITOK|M_ZERO);

sys/altq/altq_wfq.c

139

if (queue == NULL) {

sys/altq/altq_wfq.c

150

new_wfqp->queue = queue;

sys/altq/altq_wfq.c

154

for (i = 0; i < new_wfqp->nums; i++, queue++) {

sys/altq/altq_wfq.c

155

queue->next = queue->prev = NULL;

sys/altq/altq_wfq.c

156

queue->head = queue->tail = NULL;

sys/altq/altq_wfq.c

157

queue->bytes = queue->quota = 0;

sys/altq/altq_wfq.c

158

queue->weight = 100;

sys/altq/altq_wfq.c

167

free(queue, M_DEVBUF);

sys/altq/altq_wfq.c

209

free(wfqp->queue, M_DEVBUF);

sys/altq/altq_wfq.c

247

return (&wfqp->queue[(*wfqp->hash_func)(&flow, wfqp->nums)]);

sys/altq/altq_wfq.c

254

wfq *queue;

sys/altq/altq_wfq.c

261

if ((queue = mp->m_pkthdr.pattr_class) == NULL)

sys/altq/altq_wfq.c

262

queue = &wfqp->queue[0];

sys/altq/altq_wfq.c

264

if (queue->tail == NULL)

sys/altq/altq_wfq.c

265

queue->head = mp;

sys/altq/altq_wfq.c

267

queue->tail->m_nextpkt = mp;

sys/altq/altq_wfq.c

268

queue->tail = mp;

sys/altq/altq_wfq.c

270

queue->bytes += byte;

sys/altq/altq_wfq.c

274

if (queue->next == NULL) {

sys/altq/altq_wfq.c

278

queue->next = queue->prev = queue;

sys/altq/altq_wfq.c

279

wfqp->rrp = queue;

sys/altq/altq_wfq.c

280

WFQ_ADDQUOTA(queue);

sys/altq/altq_wfq.c

283

queue->prev = wfqp->rrp->prev;

sys/altq/altq_wfq.c

284

wfqp->rrp->prev->next = queue;

sys/altq/altq_wfq.c

285

wfqp->rrp->prev = queue;

sys/altq/altq_wfq.c

286

queue->next = wfqp->rrp;

sys/altq/altq_wfq.c

287

queue->quota = 0;

sys/altq/altq_wfq.c

307

if(drop_queue == queue)

sys/altq/altq_wfq.c

418

wfq *queue, *max_queue = NULL;

sys/altq/altq_wfq.c

420

if((queue = wfqp->rrp) == NULL)

sys/altq/altq_wfq.c

424

if ((byte = queue->bytes * 100 / queue->weight) > max_byte) {

sys/altq/altq_wfq.c

425

max_queue = queue;

sys/altq/altq_wfq.c

428

} while ((queue = queue->next) != wfqp->rrp);

sys/altq/altq_wfq.c

438

wfq *queue;

sys/altq/altq_wfq.c

444

if ((wfqp->bytes == 0) || ((queue = wfqp->rrp) == NULL))

sys/altq/altq_wfq.c

449

if (queue->quota > 0) {

sys/altq/altq_wfq.c

450

if (queue->bytes <= 0) {

sys/altq/altq_wfq.c

453

if (queue->next == queue){

sys/altq/altq_wfq.c

457

queue->next = queue->prev = NULL;

sys/altq/altq_wfq.c

461

queue->prev->next = queue->next;

sys/altq/altq_wfq.c

462

queue->next->prev = queue->prev;

sys/altq/altq_wfq.c

465

wfqp->rrp = queue->next;

sys/altq/altq_wfq.c

466

queue->next = queue->prev = NULL;

sys/altq/altq_wfq.c

467

queue = wfqp->rrp;

sys/altq/altq_wfq.c

468

WFQ_ADDQUOTA(queue);

sys/altq/altq_wfq.c

474

mp = queue->head;

sys/altq/altq_wfq.c

476

if((queue->head = mp->m_nextpkt) == NULL)

sys/altq/altq_wfq.c

477

queue->tail = NULL;

sys/altq/altq_wfq.c

480

queue->quota -= byte;

sys/altq/altq_wfq.c

481

queue->bytes -= byte;

sys/altq/altq_wfq.c

482

PKTCNTR_ADD(&queue->xmit_cnt, byte);

sys/altq/altq_wfq.c

495

queue = wfqp->rrp = queue->next;

sys/altq/altq_wfq.c

496

WFQ_ADDQUOTA(queue);

sys/altq/altq_wfq.c

517

wfq *queue;

sys/altq/altq_wfq.c

529

queue = &wfqp->queue[swp->qid];

sys/altq/altq_wfq.c

530

old = queue->weight;

sys/altq/altq_wfq.c

531

queue->weight = swp->weight;

sys/altq/altq_wfq.c

541

wfq *queue;

sys/altq/altq_wfq.c

550

queue = &wfqp->queue[gsp->qid];

sys/altq/altq_wfq.c

553

stats->bytes = queue->bytes;

sys/altq/altq_wfq.c

554

stats->weight = queue->weight;

sys/altq/altq_wfq.c

555

stats->xmit_cnt = queue->xmit_cnt;

sys/altq/altq_wfq.c

556

stats->drop_cnt = queue->drop_cnt;

sys/altq/altq_wfq.c

566

wfq *queue;

sys/altq/altq_wfq.c

578

free(wfqp->queue, M_DEVBUF);

sys/altq/altq_wfq.c

580

queue = malloc(sizeof(wfq) * cf->nqueues, M_DEVBUF,

sys/altq/altq_wfq.c

582

if (queue == NULL)

sys/altq/altq_wfq.c

588

wfqp->queue = queue;

sys/altq/altq_wfq.c

589

for (i = 0; i < wfqp->nums; i++, queue++) {

sys/altq/altq_wfq.c

590

queue->next = queue->prev = NULL;

sys/altq/altq_wfq.c

591

queue->head = queue->tail = NULL;

sys/altq/altq_wfq.c

592

queue->bytes = queue->quota = 0;

sys/altq/altq_wfq.c

593

queue->weight = 100;

sys/altq/altq_wfq.h

121

wfq *queue; /* pointer to queue list */

sys/arch/arc/arc/bus_dma.c

603

m = TAILQ_NEXT(m, pageq.queue);

sys/arch/arc/arc/bus_dma.c

605

for (; m != NULL; m = TAILQ_NEXT(m, pageq.queue)) {

sys/arch/arc/arc/bus_dma.c

651

TAILQ_INSERT_TAIL(&mlist, m, pageq.queue);

sys/arch/arm/arm32/bus_dma.c

1439

TAILQ_INSERT_TAIL(&mlist, m, pageq.queue);

sys/arch/arm/arm32/bus_dma.c

1792

m = TAILQ_NEXT(m, pageq.queue);

sys/arch/arm/arm32/bus_dma.c

1794

for (; m != NULL; m = TAILQ_NEXT(m, pageq.queue)) {

sys/arch/arm/arm32/pmap.c

6764

pg = TAILQ_NEXT(pg, pageq.queue);

sys/arch/arm/arm32/pmap.c

6855

m = TAILQ_NEXT(m, pageq.queue);

sys/arch/arm/nvidia/tegra_drm.c

248

SIMPLEQ_REMOVE_HEAD(&sc->sc_tasks, tdt_u.queue);

sys/arch/arm/nvidia/tegra_drm.c

307

SIMPLEQ_INSERT_TAIL(&sc->sc_tasks, task, tdt_u.queue);

sys/arch/arm/nvidia/tegra_drm.h

137

SIMPLEQ_ENTRY(tegra_drm_task) queue;

sys/arch/arm/rockchip/rk_drm.c

205

SIMPLEQ_REMOVE_HEAD(&sc->sc_tasks, rdt_u.queue);

sys/arch/arm/rockchip/rk_drm.c

504

SIMPLEQ_INSERT_TAIL(&sc->sc_tasks, task, rdt_u.queue);

sys/arch/arm/rockchip/rk_drm.h

102

SIMPLEQ_ENTRY(rk_drm_task) queue;

sys/arch/arm/sunxi/sunxi_drm.c

212

SIMPLEQ_REMOVE_HEAD(&sc->sc_tasks, sdt_u.queue);

sys/arch/arm/sunxi/sunxi_drm.c

554

SIMPLEQ_INSERT_TAIL(&sc->sc_tasks, task, sdt_u.queue);

sys/arch/arm/sunxi/sunxi_drm.h

105

SIMPLEQ_ENTRY(sunxi_drm_task) queue;

sys/arch/arm/ti/ti_lcdc.c

474

SIMPLEQ_REMOVE_HEAD(&sc->sc_tasks, tdt_u.queue);

sys/arch/arm/ti/ti_lcdc.c

697

SIMPLEQ_INSERT_TAIL(&sc->sc_tasks, task, tdt_u.queue);

sys/arch/arm/ti/ti_lcdc.h

112

SIMPLEQ_ENTRY(tilcdc_drm_task) queue;

sys/arch/arm/xscale/pxa2x0_dmac.c

903

struct dmac_xfer_state_head *queue;

sys/arch/arm/xscale/pxa2x0_dmac.c

909

queue = dxs->dxs_queue;

sys/arch/arm/xscale/pxa2x0_dmac.c

917

if (queue == NULL) {

sys/arch/arm/xscale/pxa2x0_dmac.c

923

SIMPLEQ_REMOVE(queue, dxs, dmac_xfer_state, dxs_link);

sys/arch/arm/xscale/pxa2x0_dmac.c

964

queue == &sc->sc_periph[dxs->dxs_peripheral].sp_queue)

sys/arch/atari/atari/bus.c

1068

m = TAILQ_NEXT(m, pageq.queue);

sys/arch/atari/atari/bus.c

1070

for (; m != NULL; m = TAILQ_NEXT(m, pageq.queue)) {

sys/arch/atari/atari/bus.c

839

TAILQ_INSERT_TAIL(&mlist, m, pageq.queue);

sys/arch/dreamcast/dev/g2/gapspci_dma.c

548

m = TAILQ_NEXT(m, pageq.queue);

sys/arch/dreamcast/dev/g2/gapspci_dma.c

550

for (; m != NULL; m = TAILQ_NEXT(m, pageq.queue)) {

sys/arch/dreamcast/dev/g2/gapspci_dma.c

584

TAILQ_INSERT_TAIL(&mlist, m, pageq.queue);

sys/arch/dreamcast/dev/maple/maple.c

404

TAILQ_INSERT_TAIL(&mlist, m, pageq.queue);

sys/arch/evbsh3/evbsh3/bus_dma.c

602

while ((m = TAILQ_NEXT(m, pageq.queue)) != NULL) {

sys/arch/evbsh3/evbsh3/bus_dma.c

655

TAILQ_INSERT_TAIL(&mlist, m, pageq.queue);

sys/arch/hppa/dev/astro.c

300

for (; m != NULL; m = TAILQ_NEXT(m, pageq.queue)) {

sys/arch/hppa/hppa/mainbus.c

1099

TAILQ_FOREACH(m, mlist, pageq.queue) {

sys/arch/hppa/hppa/mainbus.c

945

for (m = TAILQ_FIRST(mlist); m != NULL; m = TAILQ_NEXT(m,pageq.queue)) {

sys/arch/landisk/landisk/bus_dma.c

602

while ((m = TAILQ_NEXT(m, pageq.queue)) != NULL) {

sys/arch/landisk/landisk/bus_dma.c

655

TAILQ_INSERT_TAIL(&mlist, m, pageq.queue);

sys/arch/m68k/m68k/bus_dma.c

766

m = m->pageq.queue.tqe_next;

sys/arch/m68k/m68k/bus_dma.c

768

for (; m != NULL; m = m->pageq.queue.tqe_next) {

sys/arch/m68k/m68k/bus_dma.c

835

TAILQ_INSERT_TAIL(&mlist, m, pageq.queue);

sys/arch/mips/mips/bus_dma.c

1040

m = TAILQ_NEXT(m, pageq.queue);

sys/arch/mips/mips/bus_dma.c

1042

for (; m != NULL; m = TAILQ_NEXT(m, pageq.queue)) {

sys/arch/mips/mips/bus_dma.c

1087

TAILQ_INSERT_TAIL(&mlist, m, pageq.queue);

sys/arch/mips/mips/vm_machdep.c

225

TAILQ_FOREACH_REVERSE(pglv, &pglist, pglist, pageq.queue) {

sys/arch/playstation2/playstation2/sifbios.c

412

sifrpc_establish(struct sifrpc_server_system *queue, void (*end_func)(void *),

sys/arch/playstation2/playstation2/sifbios.c

416

struct sifrpc_server_system *queue;

sys/arch/playstation2/playstation2/sifbios.c

420

queue: queue,

sys/arch/playstation2/playstation2/sifbios.c

429

sifrpc_register_service(struct sifrpc_server_system *queue,

sys/arch/playstation2/playstation2/sifbios.c

449

receive_queue: queue,

sys/arch/playstation2/playstation2/sifbios.c

456

sifrpc_unregister_service(struct sifrpc_server_system *queue,

sys/arch/playstation2/playstation2/sifbios.c

464

receive_queue: queue,

sys/arch/playstation2/playstation2/sifbios.c

471

sifrpc_disestablish(struct sifrpc_server_system *queue)

sys/arch/playstation2/playstation2/sifbios.c

473

void *sifbios_arg = queue;

sys/arch/playstation2/playstation2/sifbios.c

479

sifrpc_dequeue(struct sifrpc_server_system *queue)

sys/arch/playstation2/playstation2/sifbios.c

481

void *sifbios_arg = queue;

sys/arch/powerpc/powerpc/bus_dma.c

711

TAILQ_INSERT_TAIL(&mlist, m, pageq.queue);

sys/arch/powerpc/powerpc/bus_dma.c

889

m = m->pageq.queue.tqe_next;

sys/arch/powerpc/powerpc/bus_dma.c

891

for (; m != NULL; m = m->pageq.queue.tqe_next) {

sys/arch/riscv/riscv/bus_dma.c

1394

TAILQ_INSERT_TAIL(&mlist, m, pageq.queue);

sys/arch/riscv/riscv/bus_dma.c

1692

m = TAILQ_NEXT(m, pageq.queue);

sys/arch/riscv/riscv/bus_dma.c

1694

for (; m != NULL; m = TAILQ_NEXT(m, pageq.queue)) {

sys/arch/sparc/sparc/iommu.c

235

for (; m != NULL; m = TAILQ_NEXT(m,pageq.queue)) {

sys/arch/sparc/sparc/iommu.c

693

for (m = TAILQ_FIRST(mlist); m != NULL; m = TAILQ_NEXT(m,pageq.queue)) {

sys/arch/sparc/sparc/iommu.c

789

for (m = TAILQ_FIRST(mlist); m != NULL; m = TAILQ_NEXT(m,pageq.queue)) {

sys/arch/sparc/sparc/machdep.c

1695

for (m = TAILQ_FIRST(mlist); m != NULL; m = TAILQ_NEXT(m,pageq.queue)) {

sys/arch/sparc/sparc/machdep.c

1788

TAILQ_FOREACH(m, mlist, pageq.queue) {

sys/arch/sparc/sparc/machdep.c

240

TAILQ_FOREACH(m, &mlist ,pageq.queue) {

sys/arch/sparc/sparc/msiiep.c

709

TAILQ_FOREACH(m, mlist, pageq.queue) {

sys/arch/sparc64/dev/iommu.c

1031

TAILQ_FOREACH(pg, pglist, pageq.queue) {

sys/arch/sparc64/dev/iommu.c

1259

TAILQ_FOREACH(pg, pglist, pageq.queue) {

sys/arch/sparc64/dev/iommu.c

177

TAILQ_FOREACH(pg, &pglist, pageq.queue) {

sys/arch/sparc64/include/hypervisor.h

61

int64_t hv_cpu_qconf(uint64_t queue, uint64_t base, uint64_t nentries);

sys/arch/sparc64/sparc64/machdep.c

1283

TAILQ_FOREACH(pg, pglist, pageq.queue) {

sys/arch/sparc64/sparc64/machdep.c

1332

TAILQ_FOREACH(pg, pglist, pageq.queue) {

sys/arch/sparc64/sparc64/pmap.c

1355

TAILQ_FOREACH(pg, &pglist, pageq.queue) {

sys/arch/sparc64/sparc64/pmap.c

1543

TAILQ_REMOVE(&pm->pm_ptps, pg, pageq.queue);

sys/arch/sparc64/sparc64/pmap.c

1900

TAILQ_INSERT_TAIL(&pm->pm_ptps, ptpg, pageq.queue);

sys/arch/sparc64/sparc64/pmap.c

1912

TAILQ_INSERT_TAIL(&pm->pm_ptps, ptpg, pageq.queue);

sys/arch/sun2/sun2/machdep.c

698

for (m = TAILQ_FIRST(mlist); m != NULL; m = TAILQ_NEXT(m,pageq.queue)) {

sys/arch/sun68k/sun68k/bus.c

346

for (m = TAILQ_FIRST(mlist); m != NULL; m = TAILQ_NEXT(m,pageq.queue)) {

sys/arch/vax/vax/bus_dma.c

415

TAILQ_INSERT_TAIL(&mlist, m, pageq.queue);

sys/arch/vax/vax/bus_dma.c

698

m = m->pageq.queue.tqe_next;

sys/arch/vax/vax/bus_dma.c

700

for (; m != NULL; m = m->pageq.queue.tqe_next) {

sys/arch/x86/x86/bus_dma.c

1157

TAILQ_INSERT_TAIL(&mlist, m, pageq.queue);

sys/arch/x86/x86/bus_dma.c

240

m = m->pageq.queue.tqe_next;

sys/arch/x86/x86/bus_dma.c

242

for (; m != NULL; m = m->pageq.queue.tqe_next) {

sys/arch/x86/x86/vga_post.c

183

TAILQ_FOREACH(pg, &sc->ram_backing, pageq.queue) {

sys/arch/xen/x86/xen_bus_dma.c

104

for (pg = mlistp->tqh_first; pg != NULL; pg = pg->pageq.queue.tqe_next) {

sys/arch/xen/x86/xen_bus_dma.c

146

pgnext = pg->pageq.queue.tqe_next;

sys/arch/xen/x86/xen_bus_dma.c

156

pgnext = pg->pageq.queue.tqe_next;

sys/arch/xen/x86/xen_bus_dma.c

158

TAILQ_REMOVE(mlistp, pg, pageq.queue);

sys/arch/xen/x86/xen_bus_dma.c

175

pgnext = pg->pageq.queue.tqe_next;

sys/arch/xen/x86/xen_bus_dma.c

176

TAILQ_REMOVE(mlistp, pg, pageq.queue);

sys/arch/xen/x86/xen_bus_dma.c

182

pgnext = pg->pageq.queue.tqe_next;

sys/arch/xen/x86/xen_bus_dma.c

199

TAILQ_REMOVE(mlistp, pg, pageq.queue);

sys/arch/xen/x86/xen_bus_dma.c

263

m = m->pageq.queue.tqe_next;

sys/arch/xen/x86/xen_bus_dma.c

267

for (; m != NULL; m = m->pageq.queue.tqe_next) {

sys/dev/bus_dma/bus_dmamem_common.c

127

TAILQ_INSERT_TAIL(&mlist, m, pageq.queue);

sys/dev/bus_dma/bus_dmamem_common.c

85

m = TAILQ_NEXT(m, pageq.queue);

sys/dev/bus_dma/bus_dmamem_common.c

87

for (; m != NULL; m = TAILQ_NEXT(m, pageq.queue)) {

sys/dev/ic/aac.c

1493

aac_enqueue_fib(struct aac_softc *sc, int queue, struct aac_ccb *ac)

sys/dev/ic/aac.c

1506

pi = le32toh(sc->sc_queues->qt_qindex[queue][AAC_PRODUCER_INDEX]);

sys/dev/ic/aac.c

1507

ci = le32toh(sc->sc_queues->qt_qindex[queue][AAC_CONSUMER_INDEX]);

sys/dev/ic/aac.c

1510

if (pi >= aac_qinfo[queue].size)

sys/dev/ic/aac.c

1518

(sc->sc_qentries[queue] + pi)->aq_fib_size = htole32(fib_size);

sys/dev/ic/aac.c

1519

(sc->sc_qentries[queue] + pi)->aq_fib_addr = htole32(fib_addr);

sys/dev/ic/aac.c

1522

sc->sc_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = htole32(pi + 1);

sys/dev/ic/aac.c

1530

if (aac_qinfo[queue].notify != 0)

sys/dev/ic/aac.c

1531

AAC_QNOTIFY(sc, aac_qinfo[queue].notify);

sys/dev/ic/aac.c

1541

aac_dequeue_fib(struct aac_softc *sc, int queue, u_int32_t *fib_size,

sys/dev/ic/aac.c

1555

pi = le32toh(sc->sc_queues->qt_qindex[queue][AAC_PRODUCER_INDEX]);

sys/dev/ic/aac.c

1556

ci = le32toh(sc->sc_queues->qt_qindex[queue][AAC_CONSUMER_INDEX]);

sys/dev/ic/aac.c

1567

if (ci >= aac_qinfo[queue].size)

sys/dev/ic/aac.c

1571

*fib_size = le32toh((sc->sc_qentries[queue] + ci)->aq_fib_size);

sys/dev/ic/aac.c

1573

switch (queue) {

sys/dev/ic/aac.c

1576

idx = le32toh((sc->sc_qentries[queue] + ci)->aq_fib_addr);

sys/dev/ic/aac.c

1582

idx = le32toh((sc->sc_qentries[queue] + ci)->aq_fib_addr);

sys/dev/ic/aac.c

1603

sc->sc_queues->qt_qindex[queue][AAC_CONSUMER_INDEX] = ci + 1;

sys/dev/ic/aac.c

1611

if (notify && (aac_qinfo[queue].notify != 0))

sys/dev/ic/aac.c

1612

AAC_QNOTIFY(sc, aac_qinfo[queue].notify);

sys/dev/ic/aac.c

1621

aac_enqueue_response(struct aac_softc *sc, int queue, struct aac_fib *fib)

sys/dev/ic/aac.c

1635

pi = le32toh(sc->sc_queues->qt_qindex[queue][AAC_PRODUCER_INDEX]);

sys/dev/ic/aac.c

1636

ci = le32toh(sc->sc_queues->qt_qindex[queue][AAC_CONSUMER_INDEX]);

sys/dev/ic/aac.c

1639

if (pi >= aac_qinfo[queue].size)

sys/dev/ic/aac.c

1647

(sc->sc_qentries[queue] + pi)->aq_fib_size = htole32(fib_size);

sys/dev/ic/aac.c

1648

(sc->sc_qentries[queue] + pi)->aq_fib_addr = htole32(fib_addr);

sys/dev/ic/aac.c

1651

sc->sc_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = htole32(pi + 1);

sys/dev/ic/aac.c

1659

if (aac_qinfo[queue].notify != 0)

sys/dev/ic/aac.c

1660

AAC_QNOTIFY(sc, aac_qinfo[queue].notify);

sys/dev/ic/aic7xxx.c

382

ahc_run_untagged_queue(struct ahc_softc *ahc, struct scb_tailq *queue)

sys/dev/ic/aic7xxx.c

389

if ((scb = TAILQ_FIRST(queue)) != NULL

sys/dev/kloader.c

471

kloader.cur_pg = TAILQ_NEXT(pg, pageq.queue);

sys/dev/marvell/if_mvxpe.c

2503

mvxpe_rx_queue_select(struct mvxpe_softc *sc, uint32_t queues, int *queue)

sys/dev/marvell/if_mvxpe.c

2509

KASSERT(queue != NULL);

sys/dev/marvell/if_mvxpe.c

2524

*queue = q;

sys/dev/marvell/if_mvxpe.c

2886

if (arg->queue < 0 || arg->queue > MVXPE_RX_RING_CNT)

sys/dev/marvell/if_mvxpe.c

2899

mvxpe_rx_lockq(sc, arg->queue);

sys/dev/marvell/if_mvxpe.c

2900

rx = MVXPE_RX_RING(sc, arg->queue);

sys/dev/marvell/if_mvxpe.c

2902

mvxpe_rx_unlockq(sc, arg->queue);

sys/dev/marvell/if_mvxpe.c

2905

mvxpe_tx_lockq(sc, arg->queue);

sys/dev/marvell/if_mvxpe.c

2906

tx = MVXPE_TX_RING(sc, arg->queue);

sys/dev/marvell/if_mvxpe.c

2908

mvxpe_tx_unlockq(sc, arg->queue);

sys/dev/marvell/if_mvxpe.c

2926

mvxpe_rx_lockq(sc, arg->queue);

sys/dev/marvell/if_mvxpe.c

2935

MVXPE_WRITE(sc, MVXPE_PRXDQTH(arg->queue), reg);

sys/dev/marvell/if_mvxpe.c

2937

mvxpe_rx_unlockq(sc, arg->queue);

sys/dev/marvell/if_mvxpe.c

2940

mvxpe_tx_lockq(sc, arg->queue);

sys/dev/marvell/if_mvxpe.c

2947

MVXPE_WRITE(sc, MVXPE_PTXDQS(arg->queue), reg);

sys/dev/marvell/if_mvxpe.c

2949

mvxpe_tx_unlockq(sc, arg->queue);

sys/dev/marvell/if_mvxpe.c

2974

if (arg->queue < 0 || arg->queue > MVXPE_RX_RING_CNT)

sys/dev/marvell/if_mvxpe.c

2985

mvxpe_rx_lockq(sc, arg->queue);

sys/dev/marvell/if_mvxpe.c

2986

rx = MVXPE_RX_RING(sc, arg->queue);

sys/dev/marvell/if_mvxpe.c

2991

arg->queue, MVXPE_READ(sc, MVXPE_PRXITTH(arg->queue)));

sys/dev/marvell/if_mvxpe.c

2994

mvxpe_rx_unlockq(sc, arg->queue);

sys/dev/marvell/if_mvxpe.c

3001

mvxpe_rx_unlockq(sc, arg->queue);

sys/dev/marvell/if_mvxpe.c

3009

MVXPE_WRITE(sc, MVXPE_PRXITTH(arg->queue), reg);

sys/dev/marvell/if_mvxpe.c

3010

DPRINTSC(sc, 1, "RXITTH(%d) => %#x\n", arg->queue, reg);

sys/dev/marvell/if_mvxpe.c

3011

mvxpe_rx_unlockq(sc, arg->queue);

sys/dev/marvell/if_mvxpe.c

3132

rxarg->queue = txarg->queue = q;

sys/dev/marvell/if_mvxpevar.h

375

int queue;

sys/dev/marvell/mvxpsec.c

1209

SIMPLEQ_FOREACH(mv_p, &sc->sc_run_queue, queue)

sys/dev/marvell/mvxpsec.c

1676

SIMPLEQ_INSERT_TAIL(&sc->sc_wait_queue, mv_p, queue);

sys/dev/marvell/mvxpsec.c

1682

last_packet = SIMPLEQ_LAST(&sc->sc_wait_queue, mvxpsec_packet, queue);

sys/dev/marvell/mvxpsec.c

1683

SIMPLEQ_INSERT_TAIL(&sc->sc_wait_queue, mv_p, queue);

sys/dev/marvell/mvxpsec.c

2150

SIMPLEQ_INSERT_TAIL(&sc->sc_wait_queue, mv_p, queue);

sys/dev/marvell/mvxpsec.c

2191

SIMPLEQ_REMOVE_HEAD(&ret_queue, queue);

sys/dev/marvell/mvxpsec.c

2264

mv_p = SIMPLEQ_LAST(&sc->sc_run_queue, mvxpsec_packet, queue);

sys/dev/marvell/mvxpsec.c

592

SIMPLEQ_REMOVE_HEAD(&sc->sc_run_queue, queue);

sys/dev/marvell/mvxpsecvar.h

315

SIMPLEQ_ENTRY(mvxpsec_packet) queue;

sys/dev/pci/if_aq.c

5105

struct aq_queue *queue = arg;

sys/dev/pci/if_aq.c

5106

struct aq_softc *sc = queue->sc;

sys/dev/pci/if_aq.c

5107

struct aq_txring *txring = &queue->txring;

sys/dev/pci/if_aq.c

5108

struct aq_rxring *rxring = &queue->rxring;

sys/dev/pci/if_ena.c

1843

struct ena_que *queue = arg;

sys/dev/pci/if_ena.c

1844

struct ena_ring *rx_ring = queue->rx_ring;

sys/dev/pci/if_ena.c

431

ena_alloc_counters_rx(struct ena_adapter *adapter, struct ena_stats_rx *st, int queue)

sys/dev/pci/if_ena.c

434

device_xname(adapter->pdev), queue);

sys/dev/pci/if_ena.c

452

ena_alloc_counters_tx(struct ena_adapter *adapter, struct ena_stats_tx *st, int queue)

sys/dev/pci/if_ena.c

455

device_xname(adapter->pdev), queue);

sys/dev/pci/if_ena.c

474

ena_alloc_counters_dev(struct ena_adapter *adapter, struct ena_stats_dev *st, int queue)

sys/dev/pci/if_ena.c

477

device_xname(adapter->pdev), queue);

sys/dev/pci/if_ena.c

490

ena_alloc_counters_hwstats(struct ena_adapter *adapter, struct ena_hw_stats *st, int queue)

sys/dev/pci/if_ena.c

493

device_xname(adapter->pdev), queue);

sys/dev/pci/if_ixlvar.h

462

uint16_t queue;

sys/dev/pci/ixgbe/ixgbe.c

2715

u64 queue = 1ULL << vector;

sys/dev/pci/ixgbe/ixgbe.c

2723

mask = (IXGBE_EIMS_RTX_QUEUE & queue);

sys/dev/pci/ixgbe/ixgbe.c

2726

mask = (queue & 0xFFFFFFFF);

sys/dev/pci/ixgbe/ixgbe.c

2729

mask = (queue >> 32);

sys/dev/pci/ixgbe/ixgbe.c

2745

u64 queue = 1ULL << vector;

sys/dev/pci/ixgbe/ixgbe.c

2758

mask = (IXGBE_EIMS_RTX_QUEUE & queue);

sys/dev/pci/ixgbe/ixgbe.c

2761

mask = (queue & 0xFFFFFFFF);

sys/dev/pci/ixgbe/ixgbe.c

2764

mask = (queue >> 32);

sys/dev/pci/ixgbe/ixgbe_82599.c

1562

u8 queue)

sys/dev/pci/ixgbe/ixgbe_82599.c

1596

fdircmd |= (u32)queue << IXGBE_FDIRCMD_RX_QUEUE_SHIFT;

sys/dev/pci/ixgbe/ixgbe_82599.c

1608

DEBUGOUT2("Tx Queue=%x hash=%x\n", queue, (u32)fdirhashcmd);

sys/dev/pci/ixgbe/ixgbe_82599.c

1897

u16 soft_id, u8 queue, bool cloud_mode)

sys/dev/pci/ixgbe/ixgbe_82599.c

1967

if (queue == IXGBE_FDIR_DROP_QUEUE)

sys/dev/pci/ixgbe/ixgbe_82599.c

1972

fdircmd |= (u32)queue << IXGBE_FDIRCMD_RX_QUEUE_SHIFT;

sys/dev/pci/ixgbe/ixgbe_82599.c

2036

u16 soft_id, u8 queue, bool cloud_mode)

sys/dev/pci/ixgbe/ixgbe_82599.c

2085

soft_id, queue, cloud_mode);

sys/dev/pci/ixgbe/ixgbe_api.h

160

u8 queue);

sys/dev/pci/ixgbe/ixgbe_api.h

165

u16 soft_id, u8 queue, bool cloud_mode);

sys/dev/pci/ixgbe/ixgbe_api.h

173

u8 queue,

sys/dev/pci/ixgbe/ixv.c

834

u32 queue = 1UL << vector;

sys/dev/pci/ixgbe/ixv.c

841

mask = (IXGBE_EIMS_RTX_QUEUE & queue);

sys/dev/pci/ixgbe/ixv.c

855

u32 queue = 1UL << vector;

sys/dev/pci/ixgbe/ixv.c

862

mask = (IXGBE_EIMS_RTX_QUEUE & queue);

sys/dev/pci/viomb.c

299

TAILQ_FOREACH(p, &b->bl_pglist, pageq.queue) {

sys/dev/pci/viomb.c

366

TAILQ_REMOVE(&b->bl_pglist, p, pageq.queue);

sys/dev/pci/viomb.c

367

TAILQ_INSERT_TAIL(&sc->sc_balloon_pages, p, pageq.queue);

sys/dev/pci/viomb.c

405

TAILQ_REMOVE(&sc->sc_balloon_pages, p, pageq.queue);

sys/dev/pci/viomb.c

406

TAILQ_INSERT_TAIL(&b->bl_pglist, p, pageq.queue);

sys/dev/pci/viomb.c

414

TAILQ_FOREACH_REVERSE(p, &b->bl_pglist, pglist, pageq.queue) {

sys/dev/pci/viomb.c

415

TAILQ_REMOVE(&b->bl_pglist, p, pageq.queue);

sys/dev/pci/viomb.c

417

pageq.queue);

sys/dev/pci/viomb.c

424

TAILQ_FOREACH_REVERSE(p, &b->bl_pglist, pglist, pageq.queue) {

sys/dev/pci/viomb.c

425

TAILQ_REMOVE(&b->bl_pglist, p, pageq.queue);

sys/dev/pci/viomb.c

427

pageq.queue);

sys/dev/pci/xmm7360.c

1216

BUG_ON(skb_queue_empty(&xn->queue));

sys/dev/pci/xmm7360.c

1351

skb_queue_purge(&xn->queue);

sys/dev/pci/xmm7360.c

1380

if (!skb_queue_empty(&xn->queue) && xmm7360_qp_can_write(xn->qp))

sys/dev/pci/xmm7360.c

1410

skb_queue_tail(&xn->queue, skb);

sys/dev/pci/xmm7360.c

1455

while ((skb = skb_dequeue(&xn->queue))) {

sys/dev/pci/xmm7360.c

1487

skb_queue_head_init(&xn->queue);

sys/dev/pci/xmm7360.c

571

struct sk_buff_head queue;

sys/dev/raidframe/rf_diskqueue.c

293

rf_DiskIOEnqueue(RF_DiskQueue_t *queue, RF_DiskQueueData_t *req, int pri)

sys/dev/raidframe/rf_diskqueue.c

304

RF_LOCK_QUEUE_MUTEX(queue, "DiskIOEnqueue");

sys/dev/raidframe/rf_diskqueue.c

305

if (RF_OK_TO_DISPATCH(queue, req)) {

sys/dev/raidframe/rf_diskqueue.c

306

Dprintf2("Dispatching pri %d regular op to c %d (ok to dispatch)\n", pri, queue->col);

sys/dev/raidframe/rf_diskqueue.c

307

rf_DispatchKernelIO(queue, req);

sys/dev/raidframe/rf_diskqueue.c

309

queue->queueLength++; /* increment count of number of requests waiting in this queue */

sys/dev/raidframe/rf_diskqueue.c

310

Dprintf2("Enqueueing pri %d regular op to c %d (not ok to dispatch)\n", pri, queue->col);

sys/dev/raidframe/rf_diskqueue.c

311

req->queue = (void *) queue;

sys/dev/raidframe/rf_diskqueue.c

312

(queue->qPtr->Enqueue) (queue->qHdr, req, pri);

sys/dev/raidframe/rf_diskqueue.c

314

RF_UNLOCK_QUEUE_MUTEX(queue, "DiskIOEnqueue");

sys/dev/raidframe/rf_diskqueue.c

320

rf_DiskIOComplete(RF_DiskQueue_t *queue, RF_DiskQueueData_t *req, int status)

sys/dev/raidframe/rf_diskqueue.c

324

RF_LOCK_QUEUE_MUTEX(queue, "DiskIOComplete");

sys/dev/raidframe/rf_diskqueue.c

325

queue->numOutstanding--;

sys/dev/raidframe/rf_diskqueue.c

326

RF_ASSERT(queue->numOutstanding >= 0);

sys/dev/raidframe/rf_diskqueue.c

332

while (!done && !RF_QUEUE_FULL(queue)) {

sys/dev/raidframe/rf_diskqueue.c

333

req = (queue->qPtr->Dequeue) (queue->qHdr);

sys/dev/raidframe/rf_diskqueue.c

335

Dprintf2("DiskIOComplete: extracting pri %d req from queue at c %d\n", req->priority, queue->col);

sys/dev/raidframe/rf_diskqueue.c

336

queue->queueLength--; /* decrement count of number of requests waiting in this queue */

sys/dev/raidframe/rf_diskqueue.c

337

RF_ASSERT(queue->queueLength >= 0);

sys/dev/raidframe/rf_diskqueue.c

338

if (RF_OK_TO_DISPATCH(queue, req)) {

sys/dev/raidframe/rf_diskqueue.c

339

Dprintf2("DiskIOComplete: dispatching pri %d regular req to c %d (ok to dispatch)\n", req->priority, queue->col);

sys/dev/raidframe/rf_diskqueue.c

340

rf_DispatchKernelIO(queue, req);

sys/dev/raidframe/rf_diskqueue.c

344

Dprintf2("DiskIOComplete: re-enqueueing pri %d regular req to c %d\n", req->priority, queue->col);

sys/dev/raidframe/rf_diskqueue.c

345

queue->queueLength++;

sys/dev/raidframe/rf_diskqueue.c

346

(queue->qPtr->Enqueue) (queue->qHdr, req, req->priority);

sys/dev/raidframe/rf_diskqueue.c

355

RF_UNLOCK_QUEUE_MUTEX(queue, "DiskIOComplete");

sys/dev/raidframe/rf_diskqueue.c

363

rf_DiskIOPromote(RF_DiskQueue_t *queue, RF_StripeNum_t parityStripeID,

sys/dev/raidframe/rf_diskqueue.c

368

if (!queue->qPtr->Promote)

sys/dev/raidframe/rf_diskqueue.c

370

RF_LOCK_QUEUE_MUTEX(queue, "DiskIOPromote");

sys/dev/raidframe/rf_diskqueue.c

371

retval = (queue->qPtr->Promote) (queue->qHdr, parityStripeID, which_ru);

sys/dev/raidframe/rf_diskqueue.c

372

RF_UNLOCK_QUEUE_MUTEX(queue, "DiskIOPromote");

sys/dev/raidframe/rf_diskqueue.h

73

RF_DiskQueue_t *queue; /* the disk queue to which this req is

sys/dev/raidframe/rf_engine.c

877

rf_DiskIOComplete(req->queue, req, req->error);

sys/dev/raidframe/rf_fifo.c

102

if ((q->hq_count + q->lq_count) != elem->queue->queueLength) {

sys/dev/raidframe/rf_fifo.c

104

q->hq_count, q->lq_count, (int) elem->queue->queueLength);

sys/dev/raidframe/rf_fifo.c

106

(int) elem->queue->numOutstanding,

sys/dev/raidframe/rf_fifo.c

107

(int) elem->queue->maxOutstanding,

sys/dev/raidframe/rf_fifo.c

108

(int) elem->queue->col);

sys/dev/raidframe/rf_fifo.c

110

RF_ASSERT((q->hq_count + q->lq_count) == elem->queue->queueLength);

sys/dev/raidframe/rf_kintf.h

44

int rf_DispatchKernelIO(RF_DiskQueue_t * queue, RF_DiskQueueData_t * req);

sys/dev/raidframe/rf_netbsdkintf.c

2130

rf_DispatchKernelIO(RF_DiskQueue_t *queue, RF_DiskQueueData_t *req)

sys/dev/raidframe/rf_netbsdkintf.c

2135

req->queue = queue;

sys/dev/raidframe/rf_netbsdkintf.c

2144

queue->numOutstanding++;

sys/dev/raidframe/rf_netbsdkintf.c

2159

InitBP(bp, queue->rf_cinfo->ci_vp,

sys/dev/raidframe/rf_netbsdkintf.c

2160

op, queue->rf_cinfo->ci_dev,

sys/dev/raidframe/rf_netbsdkintf.c

2163

queue->raidPtr->logBytesPerSector);

sys/dev/raidframe/rf_netbsdkintf.c

2169

queue->numOutstanding++;

sys/dev/raidframe/rf_netbsdkintf.c

2170

queue->last_deq_sector = req->sectorOffset;

sys/dev/raidframe/rf_netbsdkintf.c

2173

queue->curPriority = req->priority;

sys/dev/raidframe/rf_netbsdkintf.c

2176

req->type, queue->raidPtr->raidid,

sys/dev/raidframe/rf_netbsdkintf.c

2177

queue->col));

sys/dev/raidframe/rf_netbsdkintf.c

2181

queue->raidPtr->logBytesPerSector),

sys/dev/raidframe/rf_netbsdkintf.c

2182

(int) queue->raidPtr->logBytesPerSector));

sys/dev/raidframe/rf_netbsdkintf.c

2190

RF_UNLOCK_QUEUE_MUTEX(queue, "unusedparam");

sys/dev/raidframe/rf_netbsdkintf.c

2192

RF_LOCK_QUEUE_MUTEX(queue, "unusedparam");

sys/dev/raidframe/rf_netbsdkintf.c

2209

RF_DiskQueue_t *queue;

sys/dev/raidframe/rf_netbsdkintf.c

2215

queue = (RF_DiskQueue_t *) req->queue;

sys/dev/raidframe/rf_netbsdkintf.c

2217

rf_lock_mutex2(queue->raidPtr->iodone_lock);

sys/dev/raidframe/rf_netbsdkintf.c

2239

if (((queue->raidPtr->Disks[queue->col].status ==

sys/dev/raidframe/rf_netbsdkintf.c

2241

(queue->raidPtr->Disks[queue->col].status ==

sys/dev/raidframe/rf_netbsdkintf.c

2243

(queue->raidPtr->numFailures <

sys/dev/raidframe/rf_netbsdkintf.c

2244

queue->raidPtr->Layout.map->faultsTolerated)) {

sys/dev/raidframe/rf_netbsdkintf.c

2246

queue->raidPtr->raidid,

sys/dev/raidframe/rf_netbsdkintf.c

2248

queue->raidPtr->Disks[queue->col].devname);

sys/dev/raidframe/rf_netbsdkintf.c

2249

queue->raidPtr->Disks[queue->col].status =

sys/dev/raidframe/rf_netbsdkintf.c

2251

queue->raidPtr->status = rf_rs_degraded;

sys/dev/raidframe/rf_netbsdkintf.c

2252

queue->raidPtr->numFailures++;

sys/dev/raidframe/rf_netbsdkintf.c

2253

queue->raidPtr->numNewFailures++;

sys/dev/raidframe/rf_netbsdkintf.c

2264

TAILQ_INSERT_TAIL(&(queue->raidPtr->iodone), req, iodone_entries);

sys/dev/raidframe/rf_netbsdkintf.c

2267

rf_signal_cond2(queue->raidPtr->iodone_cv);

sys/dev/raidframe/rf_netbsdkintf.c

2269

rf_unlock_mutex2(queue->raidPtr->iodone_lock);

sys/dev/raidframe/rf_paritylogging.c

529

FreeRegionBufferQueue(RF_RegionBufferQueue_t * queue)

sys/dev/raidframe/rf_paritylogging.c

533

if (queue->availableBuffers != queue->totalBuffers) {

sys/dev/raidframe/rf_paritylogging.c

537

for (i = 0; i < queue->totalBuffers; i++)

sys/dev/raidframe/rf_paritylogging.c

538

RF_Free(queue->buffers[i], queue->bufferSize);

sys/dev/raidframe/rf_paritylogging.c

539

RF_Free(queue->buffers, queue->totalBuffers * sizeof(void *));

sys/dev/raidframe/rf_paritylogging.c

540

rf_destroy_mutex2(queue->mutex);

sys/dev/raidframe/rf_paritylogging.c

541

rf_destroy_cond2(queue->cond);

sys/dev/raidframe/rf_sstf.c

120

_r_ = (_q_)->queue; \

sys/dev/raidframe/rf_sstf.c

122

(_q_)->queue = (_r_)->next; \

sys/dev/raidframe/rf_sstf.c

126

RF_ASSERT((_q_)->queue == NULL); \

sys/dev/raidframe/rf_sstf.c

130

RF_ASSERT((_q_)->queue->prev == (_r_)); \

sys/dev/raidframe/rf_sstf.c

131

(_q_)->queue->prev = NULL; \

sys/dev/raidframe/rf_sstf.c

142

RF_ASSERT((_r_) == (_q_)->queue); \

sys/dev/raidframe/rf_sstf.c

144

(_q_)->queue = NULL; \

sys/dev/raidframe/rf_sstf.c

153

if (SNUM_DIFF((_q_)->queue->sectorOffset,_l_) \

sys/dev/raidframe/rf_sstf.c

164

closest_to_arm(RF_SstfQ_t *queue, RF_SectorNum_t arm_pos, int *dir, int allow_reverse)

sys/dev/raidframe/rf_sstf.c

171

for (r = queue->queue; r; r = r->next) {

sys/dev/raidframe/rf_sstf.c

238

return (queue->queue);

sys/dev/raidframe/rf_sstf.c

293

dq = (RF_DiskQueue_t *) req->queue;

sys/dev/raidframe/rf_sstf.c

301

do_sstf_ord_q(&sstfq->lopri.queue, &sstfq->lopri.qtail, req);

sys/dev/raidframe/rf_sstf.c

305

do_sstf_ord_q(&sstfq->left.queue, &sstfq->left.qtail, req);

sys/dev/raidframe/rf_sstf.c

308

do_sstf_ord_q(&sstfq->right.queue, &sstfq->right.qtail, req);

sys/dev/raidframe/rf_sstf.c

315

do_dequeue(RF_SstfQ_t *queue, RF_DiskQueueData_t *req)

sys/dev/raidframe/rf_sstf.c

324

if (req == queue->queue) {

sys/dev/raidframe/rf_sstf.c

325

DO_HEAD_DEQ(req2, queue);

sys/dev/raidframe/rf_sstf.c

328

if (req == queue->qtail) {

sys/dev/raidframe/rf_sstf.c

329

DO_TAIL_DEQ(req2, queue);

sys/dev/raidframe/rf_sstf.c

335

queue->qlen--;

sys/dev/raidframe/rf_sstf.c

353

dq = (RF_DiskQueue_t *) req->queue;

sys/dev/raidframe/rf_sstf.c

360

if (sstfq->left.queue == NULL) {

sys/dev/raidframe/rf_sstf.c

362

if (sstfq->right.queue == NULL) {

sys/dev/raidframe/rf_sstf.c

364

if (sstfq->lopri.queue == NULL) {

sys/dev/raidframe/rf_sstf.c

389

if (sstfq->right.queue == NULL) {

sys/dev/raidframe/rf_sstf.c

393

if (SNUM_DIFF(sstfq->last_sector, sstfq->right.queue->sectorOffset)

sys/dev/raidframe/rf_sstf.c

417

dq = (RF_DiskQueue_t *) req->queue;

sys/dev/raidframe/rf_sstf.c

424

if (scanq->left.queue == NULL) {

sys/dev/raidframe/rf_sstf.c

426

if (scanq->right.queue == NULL) {

sys/dev/raidframe/rf_sstf.c

428

if (scanq->lopri.queue == NULL) {

sys/dev/raidframe/rf_sstf.c

442

if (scanq->right.queue == NULL) {

sys/dev/raidframe/rf_sstf.c

444

RF_ASSERT(scanq->left.queue);

sys/dev/raidframe/rf_sstf.c

448

RF_ASSERT(scanq->right.queue);

sys/dev/raidframe/rf_sstf.c

449

RF_ASSERT(scanq->left.queue);

sys/dev/raidframe/rf_sstf.c

473

dq = (RF_DiskQueue_t *) req->queue;

sys/dev/raidframe/rf_sstf.c

481

if (cscanq->right.queue) {

sys/dev/raidframe/rf_sstf.c

485

if (cscanq->left.queue == NULL) {

sys/dev/raidframe/rf_sstf.c

487

if (cscanq->lopri.queue == NULL) {

sys/dev/raidframe/rf_sstf.c

503

cscanq->left.queue = cscanq->left.qtail = NULL;

sys/dev/raidframe/rf_sstf.c

522

for (r = sstfq->lopri.queue; r; r = next) {

sys/dev/raidframe/rf_sstf.h

35

RF_DiskQueueData_t *queue;

sys/dev/scsipi/scsipi_base.c

2108

SDT_PROBE1(scsi, base, queue, batch__start, chan);

sys/dev/scsipi/scsipi_base.c

2202

SDT_PROBE2(scsi, base, queue, run, chan, xs);

sys/dev/scsipi/scsipi_base.c

2205

SDT_PROBE1(scsi, base, queue, batch__done, chan);

sys/dev/scsipi/scsipi_base.c

82

SDT_PROBE_DEFINE1(scsi, base, queue, batch__start,

sys/dev/scsipi/scsipi_base.c

84

SDT_PROBE_DEFINE2(scsi, base, queue, run,

sys/dev/scsipi/scsipi_base.c

87

SDT_PROBE_DEFINE1(scsi, base, queue, batch__done,

sys/dev/usb/usb.c

565

usb_add_task(struct usbd_device *dev, struct usb_task *task, int queue)

sys/dev/usb/usb.c

570

SDT_PROBE3(usb, kernel, task, add, dev, task, queue);

sys/dev/usb/usb.c

572

KASSERT(0 <= queue);

sys/dev/usb/usb.c

573

KASSERT(queue < USB_NUM_TASKQS);

sys/dev/usb/usb.c

574

taskq = &usb_taskq[queue];

sys/dev/usb/usb.c

576

if (atomic_cas_uint(&task->queue, USB_NUM_TASKQS, queue) ==

sys/dev/usb/usb.c

602

unsigned queue;

sys/dev/usb/usb.c

607

while ((queue = task->queue) != USB_NUM_TASKQS) {

sys/dev/usb/usb.c

608

struct usb_taskq *taskq = &usb_taskq[queue];

sys/dev/usb/usb.c

610

if (__predict_true(task->queue == queue)) {

sys/dev/usb/usb.c

612

task->queue = USB_NUM_TASKQS;

sys/dev/usb/usb.c

644

usb_rem_task_wait(struct usbd_device *dev, struct usb_task *task, int queue,

sys/dev/usb/usb.c

653

dev, task, queue, interlock);

sys/dev/usb/usb.c

655

KASSERT(0 <= queue);

sys/dev/usb/usb.c

656

KASSERT(queue < USB_NUM_TASKQS);

sys/dev/usb/usb.c

658

taskq = &usb_taskq[queue];

sys/dev/usb/usb.c

660

queue1 = task->queue;

sys/dev/usb/usb.c

677

KASSERTMSG(queue1 == queue, "task %p on q%d expected on q%d",

sys/dev/usb/usb.c

678

task, queue1, queue);

sys/dev/usb/usb.c

680

task->queue = USB_NUM_TASKQS;

sys/dev/usb/usb.c

693

dev, task, queue, interlock, removed);

sys/dev/usb/usb.c

711

return task->queue != USB_NUM_TASKQS;

sys/dev/usb/usb.c

794

task->queue = USB_NUM_TASKQS;

sys/dev/usb/usbdi.h

214

volatile unsigned queue;

sys/dev/usb/usbdi.h

228

#define usb_init_task(t, f, a, fl) ((t)->fun = (f), (t)->arg = (a), (t)->queue = USB_NUM_TASKQS, (t)->flags = (fl))

sys/fs/udf/udf_strat_direct.c

251

int what, class __diagused, queue;

sys/fs/udf/udf_strat_direct.c

258

queue = UDF_SHED_READING;

sys/fs/udf/udf_strat_direct.c

261

queue = UDF_SHED_SEQWRITING;

sys/fs/udf/udf_strat_direct.c

263

queue = UDF_SHED_WRITING;

sys/fs/udf/udf_strat_direct.c

265

queue = UDF_SHED_WRITING;

sys/fs/udf/udf_strat_direct.c

267

queue = UDF_SHED_WRITING;

sys/fs/udf/udf_strat_direct.c

279

if (queue == UDF_SHED_READING) {

sys/fs/udf/udf_strat_direct.c

289

if (queue == UDF_SHED_WRITING) {

sys/fs/udf/udf_strat_direct.c

303

KASSERT(queue == UDF_SHED_SEQWRITING);

sys/fs/udf/udf_strat_rmw.c

784

int eccsect, what, queue, error;

sys/fs/udf/udf_strat_rmw.c

794

queue = UDF_SHED_READING;

sys/fs/udf/udf_strat_rmw.c

797

queue = UDF_SHED_SEQWRITING;

sys/fs/udf/udf_strat_rmw.c

799

queue = UDF_SHED_WRITING;

sys/fs/udf/udf_strat_rmw.c

801

queue = UDF_SHED_WRITING;

sys/fs/udf/udf_strat_rmw.c

803

queue = UDF_SHED_WRITING;

sys/fs/udf/udf_strat_rmw.c

806

if (queue == UDF_SHED_READING) {

sys/fs/udf/udf_strat_rmw.c

850

if (queue == UDF_SHED_WRITING) {

sys/fs/udf/udf_strat_rmw.c

908

KASSERT(queue == UDF_SHED_SEQWRITING);

sys/fs/udf/udf_strat_sequential.c

266

int queue;

sys/fs/udf/udf_strat_sequential.c

274

queue = UDF_SHED_READING;

sys/fs/udf/udf_strat_sequential.c

277

queue = UDF_SHED_SEQWRITING;

sys/fs/udf/udf_strat_sequential.c

279

queue = UDF_SHED_WRITING;

sys/fs/udf/udf_strat_sequential.c

284

bufq_put(priv->queues[queue], nestbuf);

sys/fs/udf/udf_strat_sequential.c

285

vfs_timestamp(&priv->last_queued[queue]);

sys/fs/udf/udf_strat_sequential.c

375

udf_issue_buf(struct udf_mount *ump, int queue, struct buf *buf)

sys/fs/udf/udf_strat_sequential.c

390

if (queue == UDF_SHED_READING) {

sys/fs/udf/udf_strat_sequential.c

399

if (queue == UDF_SHED_WRITING) {

sys/fs/udf/udf_strat_sequential.c

411

KASSERT(queue == UDF_SHED_SEQWRITING);

sys/kern/kern_rwlock.c

287

int queue;

sys/kern/kern_rwlock.c

320

queue = TS_READER_Q;

sys/kern/kern_rwlock.c

326

queue = TS_WRITER_Q;

sys/kern/kern_rwlock.c

402

turnstile_block(ts, queue, rw, &rw_syncobj);

sys/kern/subr_autoconf.c

2686

config_process_deferred(struct deferred_config_head *queue, device_t parent)

sys/kern/subr_autoconf.c

2693

dc = TAILQ_FIRST(queue);

sys/kern/subr_autoconf.c

2696

TAILQ_REMOVE(queue, dc, dc_queue);

sys/kern/subr_autoconf.c

2705

dc = TAILQ_FIRST(queue);

sys/kern/sys_aio.c

1148

TAILQ_FOREACH(job, &st->fg->queue, list) {

sys/kern/sys_aio.c

473

TAILQ_INIT(&fg->queue);

sys/kern/sys_aio.c

505

TAILQ_INSERT_TAIL(&fg->queue, job, list);

sys/kern/sys_aio.c

778

job = TAILQ_FIRST(&fg->queue);

sys/kern/sys_aio.c

780

TAILQ_REMOVE(&fg->queue, job, list);

sys/kern/sys_aio.c

892

job = TAILQ_FIRST(&fg->queue);

sys/kern/sys_aio.c

894

TAILQ_REMOVE(&fg->queue, job, list);

sys/net/if.c

2215

uint16_t queue;

sys/net/if.c

2234

queue = ifp->if_link_queue;

sys/net/if.c

2238

queue &= ~LINK_QUEUE_UP;

sys/net/if.c

2239

queue |= LINK_QUEUE_UNKNOWN;

sys/net/if.c

2243

queue &= ~(LINK_QUEUE_UNKNOWN | LINK_QUEUE_UP);

sys/net/if.c

2244

queue |= LINK_QUEUE_DOWN;

sys/net/if.c

2247

queue |= LINK_QUEUE_UP;

sys/net/if.c

2257

if (ifp->if_link_queue == queue)

sys/net/if.c

2260

ifp->if_link_queue = queue;

sys/net/route.c

1928

struct rttimer_queue *queue)

sys/net/route.c

1962

r->rtt_queue = queue;

sys/net/route.c

1964

TAILQ_INSERT_TAIL(&queue->rtq_head, r, rtt_next);

sys/net/route.c

263

SLIST_HEAD(, rtentry) queue;

sys/net/route.c

476

SLIST_INIT(&rt_free_global.queue);

sys/net/route.c

721

if ((rt = SLIST_FIRST(&rt_free_global.queue)) == NULL) {

sys/net/route.c

726

SLIST_REMOVE_HEAD(&rt_free_global.queue, rt_free);

sys/net/route.c

746

SLIST_INSERT_HEAD(&rt_free_global.queue, rt, rt_free);

sys/netinet/sctputil.c

3377

int reason, struct sctpchunk_listhead *queue)

sys/netinet/sctputil.c

3396

if (queue == &stcb->asoc.send_queue) {

sys/netinet/sctputil.c

3418

if ((foundeom == 0) && (queue == &stcb->asoc.sent_queue)) {

sys/rump/librump/rumpkern/vm.c

1224

TAILQ_FOREACH(pg, &vmpage_lruqueue, pageq.queue) {

sys/rump/librump/rumpkern/vm.c

221

TAILQ_INSERT_TAIL(&vmpage_lruqueue, pg, pageq.queue);

sys/rump/librump/rumpkern/vm.c

253

TAILQ_REMOVE(&vmpage_lruqueue, pg, pageq.queue);

sys/rump/librump/rumpkern/vm.c

679

TAILQ_REMOVE(&vmpage_lruqueue, pg, pageq.queue);

sys/rump/librump/rumpkern/vm.c

680

TAILQ_INSERT_TAIL(&vmpage_lruqueue, pg, pageq.queue);

sys/sys/aio.h

143

TAILQ_HEAD(, aio_job) queue;

sys/ufs/chfs/chfs.h

297

TAILQ_ENTRY(chfs_eraseblock) queue; /* queue entry */

sys/ufs/chfs/chfs_build.c

229

&chmp->chm_blocks[i], queue);

sys/ufs/chfs/chfs_build.c

239

&chmp->chm_blocks[i], queue);

sys/ufs/chfs/chfs_build.c

243

&chmp->chm_blocks[i], queue);

sys/ufs/chfs/chfs_build.c

278

&chmp->chm_blocks[i], queue);

sys/ufs/chfs/chfs_erase.c

118

TAILQ_INSERT_TAIL(&chmp->chm_free_queue, cheb, queue);

sys/ufs/chfs/chfs_erase.c

68

TAILQ_REMOVE(&chmp->chm_erasable_pending_wbuf_queue, cheb, queue);

sys/ufs/chfs/chfs_erase.c

74

TAILQ_INSERT_TAIL(&chmp->chm_erase_pending_queue, cheb, queue);

sys/ufs/chfs/chfs_erase.c

83

TAILQ_REMOVE(&chmp->chm_erase_pending_queue, cheb, queue);

sys/ufs/chfs/chfs_gc.c

195

TAILQ_FOREACH(cheb, &chmp->chm_very_dirty_queue, queue) {

sys/ufs/chfs/chfs_gc.c

403

TAILQ_REMOVE(nextqueue, ret, queue);

sys/ufs/chfs/chfs_gc.c

683

chmp->chm_gcblock, queue);

sys/ufs/chfs/chfs_nodeops.c

348

TAILQ_FOREACH_SAFE(eb, &chmp->chm_free_queue, queue, tmpeb) {

sys/ufs/chfs/chfs_nodeops.c

350

TAILQ_REMOVE(&chmp->chm_free_queue, cheb, queue);

sys/ufs/chfs/chfs_nodeops.c

356

TAILQ_FOREACH_SAFE(eb, &chmp->chm_dirty_queue, queue, tmpeb) {

sys/ufs/chfs/chfs_nodeops.c

358

TAILQ_REMOVE(&chmp->chm_dirty_queue, cheb, queue);

sys/ufs/chfs/chfs_nodeops.c

365

TAILQ_FOREACH_SAFE(eb, &chmp->chm_very_dirty_queue, queue, tmpeb) {

sys/ufs/chfs/chfs_nodeops.c

367

TAILQ_REMOVE(&chmp->chm_very_dirty_queue, cheb, queue);

sys/ufs/chfs/chfs_nodeops.c

374

TAILQ_FOREACH_SAFE(eb, &chmp->chm_clean_queue, queue, tmpeb) {

sys/ufs/chfs/chfs_nodeops.c

376

TAILQ_REMOVE(&chmp->chm_clean_queue, cheb, queue);

sys/ufs/chfs/chfs_nodeops.c

386

cheb, queue);

sys/ufs/chfs/chfs_nodeops.c

389

cheb, queue);

sys/ufs/chfs/chfs_nodeops.c

399

TAILQ_REMOVE(&chmp->chm_clean_queue, cheb, queue);

sys/ufs/chfs/chfs_nodeops.c

400

TAILQ_INSERT_TAIL(&chmp->chm_dirty_queue, cheb, queue);

sys/ufs/chfs/chfs_nodeops.c

405

TAILQ_REMOVE(&chmp->chm_dirty_queue, cheb, queue);

sys/ufs/chfs/chfs_nodeops.c

406

TAILQ_INSERT_TAIL(&chmp->chm_very_dirty_queue, cheb, queue);

sys/ufs/chfs/chfs_nodeops.c

443

TAILQ_INSERT_TAIL(&chmp->chm_clean_queue, cheb, queue);

sys/ufs/chfs/chfs_nodeops.c

445

TAILQ_INSERT_TAIL(&chmp->chm_very_dirty_queue, cheb, queue);

sys/ufs/chfs/chfs_nodeops.c

447

TAILQ_INSERT_TAIL(&chmp->chm_dirty_queue, cheb, queue);

sys/ufs/chfs/chfs_nodeops.c

587

TAILQ_REMOVE(&chmp->chm_free_queue, cheb, queue);

sys/ufs/chfs/ebh.c

1184

struct scan_leb_queue *queue)

sys/ufs/chfs/ebh.c

1192

TAILQ_INSERT_TAIL(queue, sleb, u.queue);

sys/ufs/chfs/ebh.c

1476

struct chfs_scan_leb, u.queue);

sys/ufs/chfs/ebh.c

1479

struct chfs_scan_leb, u.queue);

sys/ufs/chfs/ebh.c

1482

struct chfs_scan_leb, u.queue);

sys/ufs/chfs/ebh.c

1485

struct chfs_scan_leb, u.queue);

sys/ufs/chfs/ebh.c

1553

TAILQ_FOREACH(sleb, &si->erased, u.queue) {

sys/ufs/chfs/ebh.c

1560

TAILQ_FOREACH(sleb, &si->erase, u.queue) {

sys/ufs/chfs/ebh.c

1567

TAILQ_FOREACH(sleb, &si->free, u.queue) {

sys/ufs/chfs/ebh.c

1573

TAILQ_FOREACH(sleb, &si->corrupted, u.queue) {

sys/ufs/chfs/ebh.c

1692

EBH_QUEUE_DESTROY(&ebh->fully_erased, struct chfs_peb, u.queue);

sys/ufs/chfs/ebh.c

1693

EBH_QUEUE_DESTROY(&ebh->to_erase, struct chfs_peb, u.queue);

sys/ufs/chfs/ebh.c

60

int add_peb_to_erase_queue(struct chfs_ebh *ebh, int pebnr, int ec,struct peb_queue *queue);

sys/ufs/chfs/ebh.c

775

struct peb_queue *queue)

sys/ufs/chfs/ebh.c

784

TAILQ_INSERT_TAIL(queue, peb, u.queue);

sys/ufs/chfs/ebh.c

942

TAILQ_REMOVE(&ebh->fully_erased, peb, u.queue);

sys/ufs/chfs/ebh.c

954

TAILQ_REMOVE(&ebh->to_erase, peb, u.queue);

sys/ufs/chfs/ebh.h

139

TAILQ_ENTRY(chfs_scan_leb) queue;

sys/ufs/chfs/ebh.h

184

TAILQ_ENTRY(chfs_peb) queue;

sys/uvm/pmap/pmap_segtab.c

375

TAILQ_INSERT_TAIL(pglist, pg, pageq.queue);

sys/uvm/pmap/pmap_segtab.c

409

TAILQ_REMOVE(list, pg, pageq.queue);

sys/uvm/uvm_object.c

189

TAILQ_INSERT_TAIL(list, pgs[i], pageq.queue);

sys/uvm/uvm_page.h

162

TAILQ_ENTRY(vm_page) queue; /* w: wired page queue

sys/uvm/uvm_pglist.c

107

TAILQ_INSERT_TAIL(rlist, pg, pageq.queue);

sys/uvm/uvm_pglist.c

330

TAILQ_INSERT_HEAD(&tmp, pg, pageq.queue);

sys/uvm/uvm_pglist.c

426

TAILQ_REMOVE(&tmp, pg, pageq.queue);

sys/uvm/uvm_pglist.c

428

TAILQ_INSERT_TAIL(rlist, pg, pageq.queue);

sys/uvm/uvm_pglist.c

442

TAILQ_REMOVE(&tmp, pg, pageq.queue);

sys/uvm/uvm_pglist.c

746

TAILQ_REMOVE(list, pg, pageq.queue);

usr.bin/at/at.c

167

writefile(time_t runtimer, unsigned char queue)

usr.bin/at/at.c

236

"%c%5x%8lx", queue, jobno, (unsigned long) (runtimer/60));

usr.bin/at/at.c

432

unsigned char queue;

usr.bin/at/at.c

460

if (sscanf(dirent->d_name, "%c%5x%8lx", &queue, &jobno, &ctm) != 3)

usr.bin/at/at.c

463

if (atqueue && queue != atqueue)

usr.bin/at/at.c

490

queue,

usr.bin/at/at.c

507

unsigned char queue;

usr.bin/at/at.c

528

if (sscanf(dirent->d_name, "%c%5x%8lx", &queue, &jobno, &ctm) !=3)

usr.bin/at/at.c

585

unsigned char queue = DEFAULT_AT_QUEUE;

usr.bin/at/at.c

635

atqueue = queue = *optarg;

usr.bin/at/at.c

636

if (!(islower(queue) || isupper(queue)))

usr.bin/at/at.c

724

writefile(timer, queue);

usr.bin/at/at.c

729

queue = toupper(queue);

usr.bin/at/at.c

731

queue = DEFAULT_BATCH_QUEUE;

usr.bin/at/at.c

750

writefile(timer, queue);

usr.bin/grep/queue.c

54

static STAILQ_HEAD(, qentry) queue = STAILQ_HEAD_INITIALIZER(queue);

usr.bin/grep/queue.c

72

STAILQ_INSERT_TAIL(&queue, item, list);

usr.bin/grep/queue.c

86

item = STAILQ_FIRST(&queue);

usr.bin/grep/queue.c

90

STAILQ_REMOVE_HEAD(&queue, list);

usr.sbin/acpitools/aml/aml_obj.h

175

STAILQ_HEAD(, aml_mutex_queue) queue;

usr.sbin/acpitools/aml/aml_parse.c

1205

STAILQ_INIT(&mut->queue);

usr.sbin/lpr/common_source/common.c

236

getq(struct queue **namelist[])

usr.sbin/lpr/common_source/common.c

239

struct queue *q, **queue = NULL, **nqueue;

usr.sbin/lpr/common_source/common.c

257

queue = calloc(arraysz, sizeof(struct queue *));

usr.sbin/lpr/common_source/common.c

258

if (queue == NULL)

usr.sbin/lpr/common_source/common.c

271

q = (struct queue *)malloc(sizeof(time_t)+strlen(d->d_name)+1);

usr.sbin/lpr/common_source/common.c

281

nqueue = (struct queue **)realloc(queue,

usr.sbin/lpr/common_source/common.c

282

arraysz * 2 * sizeof(struct queue *));

usr.sbin/lpr/common_source/common.c

289

queue = nqueue;

usr.sbin/lpr/common_source/common.c

292

queue[nitems-1] = q;

usr.sbin/lpr/common_source/common.c

296

qsort(queue, nitems, sizeof(struct queue *), compar);

usr.sbin/lpr/common_source/common.c

297

*namelist = queue;

usr.sbin/lpr/common_source/common.c

301

freeq(queue, nitems);

usr.sbin/lpr/common_source/common.c

307

freeq(struct queue **namelist, u_int nitems)

usr.sbin/lpr/common_source/common.c

324

const struct queue *const *q1 = p1;

usr.sbin/lpr/common_source/common.c

325

const struct queue *const *q2 = p2;

usr.sbin/lpr/common_source/displayq.c

116

if ((nitems = getq(&queue)) < 0)

usr.sbin/lpr/common_source/displayq.c

203

q = queue[i];

usr.sbin/lpr/common_source/displayq.c

207

freeq(queue, nitems);

usr.sbin/lpr/common_source/displayq.c

96

struct queue *q;

usr.sbin/lpr/common_source/displayq.c

99

struct queue **queue;

usr.sbin/lpr/common_source/lp.h

112

int getq(struct queue *(*[]));

usr.sbin/lpr/common_source/lp.h

113

void freeq(struct queue **, u_int);

usr.sbin/lpr/lpc/cmds.c

285

struct dirent **queue;

usr.sbin/lpr/lpc/cmds.c

299

nitems = scandir(SD, &queue, doselect, sortq);

usr.sbin/lpr/lpc/cmds.c

309

cp = queue[i]->d_name;

usr.sbin/lpr/lpc/cmds.c

313

cp1 = queue[i + 1]->d_name;

usr.sbin/lpr/lpc/cmds.c

80

static int touch(struct queue *);

usr.sbin/lpr/lpc/cmds.c

853

struct queue **queue;

usr.sbin/lpr/lpc/cmds.c

886

nitems = getq(&queue);

usr.sbin/lpr/lpc/cmds.c

890

mtime = queue[0]->q_time;

usr.sbin/lpr/lpc/cmds.c

899

free(queue[i]);

usr.sbin/lpr/lpc/cmds.c

900

free(queue);

usr.sbin/lpr/lpc/cmds.c

922

touch(struct queue *q)

usr.sbin/lpr/lpc/cmds.c

942

struct queue **qq;

usr.sbin/lpr/lpc/cmds.c

968

for (qq = queue + nitems; --qq >= queue; ) {

usr.sbin/lpr/lpc/cmds.c

988

for (qq = queue + nitems; --qq >= queue; ) {

usr.sbin/lpr/lpd/printjob.c

148

struct queue *q, **qp;

usr.sbin/lpr/lpd/printjob.c

149

struct queue **queue;

usr.sbin/lpr/lpd/printjob.c

223

if ((nitems = getq(&queue)) < 0) {

usr.sbin/lpr/lpd/printjob.c

241

for (qp = queue; nitems--; free((char *) q)) {

usr.sbin/lpr/lpd/printjob.c

299

free(queue);

usr.sbin/lpr/lpd/printjob.c

300

queue = NULL;

usr.sbin/lpr/lpd/printjob.c

304

if ((nitems = getq(&queue)) < 0) {

usr.sbin/rpc.pcnfsd/extern.h

5

extern pr_queue queue;

usr.sbin/rpc.pcnfsd/pcnfsd_print.c

649

if (queue) {

usr.sbin/rpc.pcnfsd/pcnfsd_print.c

650

free_pr_queue_item(queue);

usr.sbin/rpc.pcnfsd/pcnfsd_print.c

651

queue = NULL;

usr.sbin/rpc.pcnfsd/pcnfsd_print.c

703

queue = curr;

usr.sbin/rpc.pcnfsd/pcnfsd_print.c

729

if (queue) {

usr.sbin/rpc.pcnfsd/pcnfsd_print.c

730

free_pr_queue_item(queue);

usr.sbin/rpc.pcnfsd/pcnfsd_print.c

731

queue = NULL;

usr.sbin/rpc.pcnfsd/pcnfsd_print.c

802

queue = curr;

usr.sbin/rpc.pcnfsd/pcnfsd_print.c

99

pr_queue queue = NULL;

usr.sbin/rpc.pcnfsd/pcnfsd_v2.c

214

res.jobs = queue;