crypto/libressl/crypto/x509/x509_issuer_cache.c

135

TAILQ_REMOVE(&x509_issuer_lru, found, queue);

crypto/libressl/crypto/x509/x509_issuer_cache.c

136

TAILQ_INSERT_HEAD(&x509_issuer_lru, found, queue);

crypto/libressl/crypto/x509/x509_issuer_cache.c

180

TAILQ_INSERT_HEAD(&x509_issuer_lru, new, queue);

crypto/libressl/crypto/x509/x509_issuer_cache.c

89

TAILQ_REMOVE(&x509_issuer_lru, old, queue);

crypto/libressl/crypto/x509/x509_issuer_cache.h

31

TAILQ_ENTRY(x509_issuer) queue; /* LRU of entries */

crypto/libressl/ssl/d1_lib.c

108

dtls1_drain_records(pqueue queue)

crypto/libressl/ssl/d1_lib.c

113

if (queue == NULL)

crypto/libressl/ssl/d1_lib.c

116

while ((item = pqueue_pop(queue)) != NULL) {

crypto/libressl/ssl/d1_lib.c

125

dtls1_drain_fragments(pqueue queue)

crypto/libressl/ssl/d1_lib.c

129

if (queue == NULL)

crypto/libressl/ssl/d1_lib.c

132

while ((item = pqueue_pop(queue)) != NULL) {

crypto/libressl/ssl/d1_pkt.c

205

dtls1_buffer_record(SSL *s, record_pqueue *queue, unsigned char *priority)

crypto/libressl/ssl/d1_pkt.c

211

if (pqueue_size(queue->q) >= 100)

crypto/libressl/ssl/d1_pkt.c

235

if (pqueue_insert(queue->q, item) == NULL)

crypto/libressl/ssl/d1_pkt.c

252

dtls1_retrieve_buffered_record(SSL *s, record_pqueue *queue)

crypto/libressl/ssl/d1_pkt.c

256

item = pqueue_pop(queue->q);

crypto/openssh/mux.c

1506

struct sshbuf *queue;

crypto/openssh/mux.c

1514

if ((queue = sshbuf_new()) == NULL)

crypto/openssh/mux.c

1516

if ((r = sshbuf_put_stringb(queue, m)) != 0)

crypto/openssh/mux.c

1519

need = sshbuf_len(queue);

crypto/openssh/mux.c

1520

ptr = sshbuf_ptr(queue);

crypto/openssh/mux.c

1524

sshbuf_free(queue);

crypto/openssh/mux.c

1541

sshbuf_free(queue);

crypto/openssh/mux.c

1547

sshbuf_free(queue);

crypto/openssh/mux.c

1553

sshbuf_free(queue);

crypto/openssh/mux.c

1560

struct sshbuf *queue;

crypto/openssh/mux.c

1565

if ((queue = sshbuf_new()) == NULL)

crypto/openssh/mux.c

1567

if (mux_client_read(fd, queue, 4, timeout_ms) != 0) {

crypto/openssh/mux.c

1571

sshbuf_free(queue);

crypto/openssh/mux.c

1575

need = PEEK_U32(sshbuf_ptr(queue));

crypto/openssh/mux.c

1576

if (mux_client_read(fd, queue, need, timeout_ms) != 0) {

crypto/openssh/mux.c

1579

sshbuf_free(queue);

crypto/openssh/mux.c

1583

if ((r = sshbuf_get_string_direct(queue, &ptr, &have)) != 0 ||

crypto/openssh/mux.c

1586

sshbuf_free(queue);

crypto/openssh/sftp-server.c

503

get_handle(struct sshbuf *queue, int *hp)

crypto/openssh/sftp-server.c

510

if ((r = sshbuf_get_string(queue, &handle, &hlen)) != 0)

libexec/atrun/atrun.c

120

int queue;

libexec/atrun/atrun.c

292

queue = *filename;

libexec/atrun/atrun.c

296

nice(tolower(queue) - 'a');

libexec/atrun/atrun.c

441

char queue;

libexec/atrun/atrun.c

510

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

libexec/atrun/atrun.c

516

if (isupper(queue) && (strcmp(batch_name,dirent->d_name) > 0)) {

libexec/atrun/atrun.c

525

if (islower(queue))

libexec/dma/dma.c

101

set_from(struct queue *queue, const char *osender)

libexec/dma/dma.c

135

queue->sender = sender;

libexec/dma/dma.c

159

do_alias(struct queue *queue, const char *addr)

libexec/dma/dma.c

169

if (add_recp(queue, sit->str, EXPAND_ADDR) != 0)

libexec/dma/dma.c

179

add_recp(struct queue *queue, const char *str, int expand)

libexec/dma/dma.c

193

it->sender = queue->sender;

libexec/dma/dma.c

200

LIST_FOREACH(tit, &queue->queue, next) {

libexec/dma/dma.c

208

LIST_INSERT_HEAD(&queue->queue, it, next);

libexec/dma/dma.c

217

aliased = do_alias(queue, it->addr);

libexec/dma/dma.c

219

aliased = do_alias(queue, "*");

libexec/dma/dma.c

246

go_background(struct queue *queue)

libexec/dma/dma.c

262

LIST_FOREACH(it, &queue->queue, next) {

libexec/dma/dma.c

299

dropspool(queue, it);

libexec/dma/dma.c

378

run_queue(struct queue *queue)

libexec/dma/dma.c

382

if (LIST_EMPTY(&queue->queue))

libexec/dma/dma.c

385

it = go_background(queue);

libexec/dma/dma.c

391

show_queue(struct queue *queue)

libexec/dma/dma.c

396

if (LIST_EMPTY(&queue->queue)) {

libexec/dma/dma.c

401

LIST_FOREACH(it, &queue->queue, next) {

libexec/dma/dma.c

428

struct queue queue;

libexec/dma/dma.c

461

bzero(&queue, sizeof(queue));

libexec/dma/dma.c

462

LIST_INIT(&queue.queue);

libexec/dma/dma.c

585

if (load_queue(&queue) < 0)

libexec/dma/dma.c

587

show_queue(&queue);

libexec/dma/dma.c

593

if (load_queue(&queue) < 0)

libexec/dma/dma.c

595

run_queue(&queue);

libexec/dma/dma.c

605

if ((sender = set_from(&queue, sender)) == NULL)

libexec/dma/dma.c

608

if (newspoolf(&queue) != 0)

libexec/dma/dma.c

611

setlogident("%s", queue.id);

libexec/dma/dma.c

614

if (add_recp(&queue, argv[i], EXPAND_WILDCARD) != 0)

libexec/dma/dma.c

618

if (LIST_EMPTY(&queue.queue) && !recp_from_header)

libexec/dma/dma.c

621

if (readmail(&queue, nodot, recp_from_header) != 0)

libexec/dma/dma.c

624

if (LIST_EMPTY(&queue.queue))

libexec/dma/dma.c

627

if (linkspool(&queue) != 0)

libexec/dma/dma.c

635

run_queue(&queue);

libexec/dma/dma.h

123

struct queueh queue;

libexec/dma/dma.h

214

int add_recp(struct queue *, const char *, int);

libexec/dma/dma.h

215

void run_queue(struct queue *);

libexec/dma/dma.h

218

int newspoolf(struct queue *);

libexec/dma/dma.h

219

int linkspool(struct queue *);

libexec/dma/dma.h

220

int load_queue(struct queue *);

libexec/dma/dma.h

223

void dropspool(struct queue *, struct qitem *);

libexec/dma/dma.h

232

int readmail(struct queue *, int, int);

libexec/dma/mail.c

167

parse_addrs(struct parse_state *ps, char *s, struct queue *queue)

libexec/dma/mail.c

342

if (add_recp(queue, addr, EXPAND_WILDCARD) != 0)

libexec/dma/mail.c

349

writeline(struct queue *queue, const char *line, ssize_t linelen)

libexec/dma/mail.c

359

if (fwrite(line, len, 1, queue->mailf) != 1)

libexec/dma/mail.c

365

if (fwrite("\n", 1, 1, queue->mailf) != 1)

libexec/dma/mail.c

375

readmail(struct queue *queue, int nodot, int recp_from_header)

libexec/dma/mail.c

393

error = fprintf(queue->mailf,

libexec/dma/mail.c

400

queue->sender,

libexec/dma/mail.c

401

queue->id,

libexec/dma/mail.c

424

username, useruid, queue->sender);

libexec/dma/mail.c

443

if (parse_addrs(&parse_state, line, queue) < 0) {

libexec/dma/mail.c

454

if (parse_addrs(&parse_state, line, queue) < 0) {

libexec/dma/mail.c

472

queue->id,

libexec/dma/mail.c

477

snprintf(newline, sizeof(newline), "From: <%s>\n", queue->sender);

libexec/dma/mail.c

479

if (fwrite(newline, strlen(newline), 1, queue->mailf) != 1)

libexec/dma/mail.c

488

if (fwrite(newline, strlen(newline), 1, queue->mailf) != 1)

libexec/dma/mail.c

491

if (writeline(queue, line, linelen) != 0)

libexec/dma/mail.c

51

struct queue bounceq;

libexec/dma/mail.c

63

LIST_INIT(&bounceq.queue);

libexec/dma/spool.c

102

if (asprintf(&queue->id, "%"PRIxMAX, (uintmax_t)st.st_ino) < 0)

libexec/dma/spool.c

105

queue->mailf = fdopen(fd, "r+");

libexec/dma/spool.c

106

if (queue->mailf == NULL)

libexec/dma/spool.c

111

t->str = queue->tmpf;

libexec/dma/spool.c

117

if (queue->mailf != NULL)

libexec/dma/spool.c

118

fclose(queue->mailf);

libexec/dma/spool.c

157

readqueuef(struct queue *queue, char *queuefn)

libexec/dma/spool.c

160

struct queue itmqueue;

libexec/dma/spool.c

167

LIST_INIT(&itmqueue.queue);

libexec/dma/spool.c

215

it = LIST_FIRST(&itmqueue.queue);

libexec/dma/spool.c

219

LIST_INSERT_HEAD(&queue->queue, it, next);

libexec/dma/spool.c

235

linkspool(struct queue *queue)

libexec/dma/spool.c

240

if (fflush(queue->mailf) != 0 || fsync(fileno(queue->mailf)) != 0)

libexec/dma/spool.c

244

username, getuid(), queue->sender);

libexec/dma/spool.c

246

LIST_FOREACH(it, &queue->queue, next) {

libexec/dma/spool.c

247

if (asprintf(&it->queueid, "%s.%"PRIxPTR, queue->id, (uintptr_t)it) <= 0)

libexec/dma/spool.c

261

if (link(queue->tmpf, it->mailfn) != 0)

libexec/dma/spool.c

265

LIST_FOREACH(it, &queue->queue, next) {

libexec/dma/spool.c

270

unlink(queue->tmpf);

libexec/dma/spool.c

274

LIST_FOREACH(it, &queue->queue, next) {

libexec/dma/spool.c

282

load_queue(struct queue *queue)

libexec/dma/spool.c

291

bzero(queue, sizeof(*queue));

libexec/dma/spool.c

292

LIST_INIT(&queue->queue);

libexec/dma/spool.c

325

it = readqueuef(queue, queuefn);

libexec/dma/spool.c

388

dropspool(struct queue *queue, struct qitem *keep)

libexec/dma/spool.c

392

LIST_FOREACH(it, &queue->queue, next) {

libexec/dma/spool.c

75

newspoolf(struct queue *queue)

libexec/dma/spool.c

93

queue->tmpf = strdup(fn);

libexec/dma/spool.c

94

if (queue->tmpf == NULL)

sbin/natacontrol/natacontrol.c

235

ATA_QUEUE_LEN(parm->queue) : 0,

sbin/natacontrol/natacontrol.c

237

ATA_QUEUE_LEN(parm->queue) : 0);

sbin/natacontrol/natacontrol.c

242

ATA_QUEUE_LEN(parm->queue), ATA_QUEUE_LEN(parm->queue));

sys/bus/cam/cam_queue.c

101

if (queue->queue_array != NULL) {

sys/bus/cam/cam_queue.c

106

queue->queue_array++;

sys/bus/cam/cam_queue.c

107

kfree(queue->queue_array, M_CAMQ);

sys/bus/cam/cam_queue.c

112

camq_resize(struct camq *queue, int new_size)

sys/bus/cam/cam_queue.c

117

if (new_size < queue->entries)

sys/bus/cam/cam_queue.c

129

if (queue->queue_array != NULL) {

sys/bus/cam/cam_queue.c

130

queue->queue_array++;

sys/bus/cam/cam_queue.c

131

bcopy(queue->queue_array, new_array,

sys/bus/cam/cam_queue.c

132

queue->entries * sizeof(cam_pinfo *));

sys/bus/cam/cam_queue.c

133

kfree(queue->queue_array, M_CAMQ);

sys/bus/cam/cam_queue.c

135

queue->queue_array = new_array-1;

sys/bus/cam/cam_queue.c

136

queue->array_size = new_size;

sys/bus/cam/cam_queue.c

146

camq_insert(struct camq *queue, cam_pinfo *new_entry)

sys/bus/cam/cam_queue.c

149

if (queue->entries >= queue->array_size)

sys/bus/cam/cam_queue.c

152

queue->entries++;

sys/bus/cam/cam_queue.c

153

queue->queue_array[queue->entries] = new_entry;

sys/bus/cam/cam_queue.c

154

new_entry->index = queue->entries;

sys/bus/cam/cam_queue.c

155

if (queue->entries != 0)

sys/bus/cam/cam_queue.c

156

heap_up(queue->queue_array, queue->entries);

sys/bus/cam/cam_queue.c

170

camq_remove(struct camq *queue, int index)

sys/bus/cam/cam_queue.c

174

if (index == 0 || index > queue->entries)

sys/bus/cam/cam_queue.c

176

removed_entry = queue->queue_array[index];

sys/bus/cam/cam_queue.c

177

if (queue->entries != index) {

sys/bus/cam/cam_queue.c

178

queue->queue_array[index] = queue->queue_array[queue->entries];

sys/bus/cam/cam_queue.c

179

queue->queue_array[index]->index = index;

sys/bus/cam/cam_queue.c

180

heap_down(queue->queue_array, index, queue->entries - 1);

sys/bus/cam/cam_queue.c

182

queue->queue_array[queue->entries] = NULL;

sys/bus/cam/cam_queue.c

184

queue->entries--;

sys/bus/cam/cam_queue.c

195

camq_change_priority(struct camq *queue, int index, u_int32_t new_priority)

sys/bus/cam/cam_queue.c

197

if (new_priority > queue->queue_array[index]->priority) {

sys/bus/cam/cam_queue.c

198

queue->queue_array[index]->priority = new_priority;

sys/bus/cam/cam_queue.c

199

heap_down(queue->queue_array, index, queue->entries);

sys/bus/cam/cam_queue.c

202

queue->queue_array[index]->priority = new_priority;

sys/bus/cam/cam_queue.c

203

heap_up(queue->queue_array, index);

sys/bus/cam/cam_queue.c

286

camq_fini(&ccbq->queue);

sys/bus/cam/cam_queue.c

299

- ccbq->queue.entries

sys/bus/cam/cam_queue.c

313

|| camq_resize(&ccbq->queue, new_size) == CAM_REQ_CMP) {

sys/bus/cam/cam_queue.c

326

camq_init(&ccbq->queue, openings);

sys/bus/cam/cam_queue.c

90

camq_free(struct camq *queue)

sys/bus/cam/cam_queue.c

92

if (queue != NULL) {

sys/bus/cam/cam_queue.c

93

camq_fini(queue);

sys/bus/cam/cam_queue.c

94

kfree(queue, M_CAMQ);

sys/bus/cam/cam_queue.c

99

camq_fini(struct camq *queue)

sys/bus/cam/cam_queue.h

113

u_int32_t camq_resize(struct camq *queue, int new_size);

sys/bus/cam/cam_queue.h

125

void camq_free(struct camq *queue);

sys/bus/cam/cam_queue.h

130

void camq_fini(struct camq *queue);

sys/bus/cam/cam_queue.h

136

void camq_insert(struct camq *queue, cam_pinfo *new_entry);

sys/bus/cam/cam_queue.h

142

cam_pinfo *camq_remove(struct camq *queue, int index);

sys/bus/cam/cam_queue.h

152

void camq_change_priority(struct camq *queue, int index,

sys/bus/cam/cam_queue.h

171

cam_ccbq_send_ccb(struct cam_ccbq *queue, union ccb *send_ccb);

sys/bus/cam/cam_queue.h

183

return (ccbq->queue.entries);

sys/bus/cam/cam_queue.h

197

camq_insert(&ccbq->queue, &new_ccb->ccb_h.pinfo);

sys/bus/cam/cam_queue.h

203

camq_remove(&ccbq->queue, ccb->ccb_h.pinfo.index);

sys/bus/cam/cam_queue.h

209

return((union ccb *)ccbq->queue.queue_array[index]);

sys/bus/cam/cam_queue.h

59

struct camq queue;

sys/bus/cam/cam_sim.c

163

int max_tagged_dev_transactions, struct cam_devq *queue)

sys/bus/cam/cam_sim.c

182

if (queue == NULL)

sys/bus/cam/cam_sim.c

183

queue = cam_simq_alloc(max_tagged_dev_transactions);

sys/bus/cam/cam_sim.c

185

cam_devq_reference(queue);

sys/bus/cam/cam_sim.c

199

sim->devq = queue;

sys/bus/cam/cam_sim.h

78

struct cam_devq *queue);

sys/bus/cam/cam_xpt.c

3189

cgds->devq_queued = dev->ccbq.queue.entries;

sys/bus/cam/cam_xpt.c

3656

xpt_schedule_dev(struct camq *queue, cam_pinfo *pinfo,

sys/bus/cam/cam_xpt.c

3672

camq_change_priority(queue, pinfo->index,

sys/bus/cam/cam_xpt.c

3686

pinfo->generation = ++queue->generation;

sys/bus/cam/cam_xpt.c

3687

camq_insert(queue, pinfo);

sys/bus/cam/cam_xpt.c

3845

if (device->ccbq.queue.entries > 0)

sys/bus/cam/cam_xpt.c

3916

ccb_h->pinfo.generation = ++path->device->ccbq.queue.generation;

sys/bus/cam/cam_xpt.c

4841

if ((dev->ccbq.queue.entries > 0)

sys/bus/cam/cam_xpt.c

5220

camq_fini(&device->ccbq.queue);

sys/bus/cam/cam_xpt.c

7392

cam_simq_t queue;

sys/bus/cam/cam_xpt.c

7396

TAILQ_INIT(&queue);

sys/bus/cam/cam_xpt.c

7397

TAILQ_CONCAT(&queue, &cam_simq, links);

sys/bus/cam/cam_xpt.c

7400

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

sys/bus/cam/cam_xpt.c

7401

TAILQ_REMOVE(&queue, sim, links);

sys/bus/cam/cam_xpt.c

7481

if ((dev->ccbq.queue.entries > 0)

sys/bus/cam/cam_xpt.c

764

static int xpt_schedule_dev(struct camq *queue, cam_pinfo *dev_pinfo,

sys/bus/cam/cam_xpt.c

913

CAMQ_GET_HEAD(&dev->ccbq.queue)->priority);

sys/bus/u4b/uvc/uvc_buf.c

603

struct uvc_buf_queue *queue = (struct uvc_buf_queue *)kn->kn_hook;

sys/bus/u4b/uvc/uvc_buf.c

604

struct klist *klist = &queue->sel.ki_note;

sys/bus/u4b/uvc/uvc_buf.c

606

UVC_LOCK(&queue->mtx);

sys/bus/u4b/uvc/uvc_buf.c

608

UVC_UNLOCK(&queue->mtx);

sys/bus/u4b/uvc/uvc_buf.c

614

struct uvc_buf_queue *queue = (struct uvc_buf_queue *)kn->kn_hook;

sys/bus/u4b/uvc/uvc_buf.c

617

UVC_LOCK(&queue->mtx);

sys/bus/u4b/uvc/uvc_buf.c

619

if (STAILQ_FIRST(&queue->consumer))

sys/bus/u4b/uvc/uvc_buf.c

622

if ((queue->flags & UVC_BUFFER_QUEUE_WORKING) == 0) {

sys/bus/u4b/uvc/uvc_buf.c

627

UVC_UNLOCK(&queue->mtx);

sys/bus/u4b/uvc/uvc_buf.c

640

uvc_buf_queue_kqfilter(struct uvc_buf_queue *queue, struct knote *kn)

sys/bus/u4b/uvc/uvc_buf.c

647

kn->kn_hook = (caddr_t)queue;

sys/bus/u4b/uvc/uvc_buf.c

648

klist = &queue->sel.ki_note;

sys/bus/u4b/uvc/uvc_buf.c

650

UVC_LOCK(&queue->mtx);

sys/bus/u4b/uvc/uvc_buf.c

652

UVC_UNLOCK(&queue->mtx);

sys/bus/u4b/uvc/uvc_buf.c

663

uvc_buf_queue_disable(struct uvc_buf_queue *queue)

sys/bus/u4b/uvc/uvc_buf.c

669

UVC_LOCK(&queue->mtx);

sys/bus/u4b/uvc/uvc_buf.c

670

if ((queue->flags & UVC_BUFFER_QUEUE_WORKING) == 0) {

sys/bus/u4b/uvc/uvc_buf.c

671

UVC_UNLOCK(&queue->mtx);

sys/bus/u4b/uvc/uvc_buf.c

675

STAILQ_INIT(&queue->consumer);

sys/bus/u4b/uvc/uvc_buf.c

676

STAILQ_INIT(&queue->product);

sys/bus/u4b/uvc/uvc_buf.c

678

uvc_buf_queue_init_qbuf(queue->buf + i, i);

sys/bus/u4b/uvc/uvc_buf.c

680

cv_broadcast(&queue->io_cv);

sys/bus/u4b/uvc/uvc_buf.c

681

KNOTE(&queue->sel.ki_note, 0);

sys/bus/u4b/uvc/uvc_buf.c

682

queue->flags = 0;

sys/bus/u4b/uvc/uvc_buf.c

683

UVC_UNLOCK(&queue->mtx);

sys/bus/u4b/uvc/uvc_buf.c

688

uvc_buf_queue_enable(struct uvc_buf_queue *queue)

sys/bus/u4b/uvc/uvc_buf.c

692

UVC_LOCK(&queue->mtx);

sys/bus/u4b/uvc/uvc_buf.c

694

if (queue->flags & UVC_BUFFER_QUEUE_WORKING) {

sys/bus/u4b/uvc/uvc_buf.c

695

UVC_UNLOCK(&queue->mtx);

sys/bus/u4b/uvc/uvc_buf.c

699

queue->seq = 0;

sys/bus/u4b/uvc/uvc_buf.c

701

queue->flags |= UVC_BUFFER_QUEUE_WORKING;

sys/bus/u4b/uvc/uvc_buf.c

702

UVC_UNLOCK(&queue->mtx);

sys/bus/u4b/uvc/uvc_buf.h

101

extern int uvc_buf_queue_dequeue_buf(struct uvc_buf_queue *queue,

sys/bus/u4b/uvc/uvc_buf.h

86

struct uvc_buf_queue *queue);

sys/bus/u4b/uvc/uvc_buf.h

87

extern int uvc_buf_queue_enable(struct uvc_buf_queue *queue);

sys/bus/u4b/uvc/uvc_buf.h

88

extern int uvc_buf_queue_disable(struct uvc_buf_queue *queue);

sys/bus/u4b/uvc/uvc_buf.h

89

extern int uvc_buf_queue_kqfilter(struct uvc_buf_queue *queue,

sys/bus/u4b/uvc/uvc_buf.h

91

extern int uvc_buf_queue_req_bufs(struct uvc_buf_queue *queue,

sys/bus/u4b/uvc/uvc_buf.h

93

void uvc_buf_queue_free_bufs(struct uvc_buf_queue *queue);

sys/bus/u4b/uvc/uvc_buf.h

94

void uvc_buf_queue_set_drop_flag(struct uvc_buf_queue *queue);

sys/bus/u4b/uvc/uvc_buf.h

95

extern int uvc_buf_queue_query_buf(struct uvc_buf_queue *queue,

sys/bus/u4b/uvc/uvc_buf.h

97

extern int uvc_buf_queue_mmap(struct uvc_buf_queue *queue,

sys/bus/u4b/uvc/uvc_buf.h

99

extern int uvc_buf_queue_queue_buf(struct uvc_buf_queue *queue,

sys/dev/disk/advansys/adwcam.c

1305

ccb->csio.resid = acb->queue.data_cnt;

sys/dev/disk/advansys/adwcam.c

1310

if (acb->queue.host_status == QHSTA_NO_ERROR

sys/dev/disk/advansys/adwcam.c

1311

&& (acb->queue.done_status == QD_NO_ERROR

sys/dev/disk/advansys/adwcam.c

1312

|| acb->queue.done_status == QD_WITH_ERROR)) {

sys/dev/disk/advansys/adwcam.c

1313

ccb->csio.scsi_status = acb->queue.scsi_status;

sys/dev/disk/advansys/adwcam.c

1324

ccb->csio.sense_resid = acb->queue.sense_len;

sys/dev/disk/advansys/adwcam.c

1346

if (acb->queue.done_status == QD_ABORTED_BY_HOST) {

sys/dev/disk/advansys/adwcam.c

1350

switch (acb->queue.host_status) {

sys/dev/disk/advansys/adwcam.c

1409

ccb->csio.scsi_status = acb->queue.scsi_status;

sys/dev/disk/advansys/adwcam.c

1414

adw_name(adw), acb->queue.host_status);

sys/dev/disk/advansys/adwcam.c

209

next_acb->queue.scsi_req_baddr = acbvtob(adw, next_acb);

sys/dev/disk/advansys/adwcam.c

210

next_acb->queue.scsi_req_bo = acbvtobo(adw, next_acb);

sys/dev/disk/advansys/adwcam.c

211

next_acb->queue.sense_baddr =

sys/dev/disk/advansys/adwcam.c

252

acb->queue.data_addr = dm_segs[0].ds_addr;

sys/dev/disk/advansys/adwcam.c

253

acb->queue.data_cnt = ccb->csio.dxfer_len;

sys/dev/disk/advansys/adwcam.c

290

acb->queue.sg_real_addr = acb->sg_busaddr;

sys/dev/disk/advansys/adwcam.c

292

acb->queue.sg_real_addr = 0;

sys/dev/disk/advansys/adwcam.c

303

acb->queue.data_addr = 0;

sys/dev/disk/advansys/adwcam.c

304

acb->queue.data_cnt = 0;

sys/dev/disk/advansys/adwcam.c

305

acb->queue.sg_real_addr = 0;

sys/dev/disk/advansys/adwcam.c

377

acb->queue.cntl = 0;

sys/dev/disk/advansys/adwcam.c

378

acb->queue.target_cmd = 0;

sys/dev/disk/advansys/adwcam.c

379

acb->queue.target_id = ccb->ccb_h.target_id;

sys/dev/disk/advansys/adwcam.c

380

acb->queue.target_lun = ccb->ccb_h.target_lun;

sys/dev/disk/advansys/adwcam.c

382

acb->queue.mflag = 0;

sys/dev/disk/advansys/adwcam.c

383

acb->queue.sense_len =

sys/dev/disk/advansys/adwcam.c

385

acb->queue.cdb_len = csio->cdb_len;

sys/dev/disk/advansys/adwcam.c

389

acb->queue.scsi_cntl = ADW_QSC_SIMPLE_Q_TAG;

sys/dev/disk/advansys/adwcam.c

392

acb->queue.scsi_cntl = ADW_QSC_HEAD_OF_Q_TAG;

sys/dev/disk/advansys/adwcam.c

395

acb->queue.scsi_cntl = ADW_QSC_ORDERED_Q_TAG;

sys/dev/disk/advansys/adwcam.c

398

acb->queue.scsi_cntl = ADW_QSC_NO_TAGMSG;

sys/dev/disk/advansys/adwcam.c

402

acb->queue.scsi_cntl = ADW_QSC_NO_TAGMSG;

sys/dev/disk/advansys/adwcam.c

405

acb->queue.scsi_cntl |= ADW_QSC_NO_DISC;

sys/dev/disk/advansys/adwcam.c

407

acb->queue.done_status = 0;

sys/dev/disk/advansys/adwcam.c

408

acb->queue.scsi_status = 0;

sys/dev/disk/advansys/adwcam.c

409

acb->queue.host_status = 0;

sys/dev/disk/advansys/adwcam.c

410

acb->queue.sg_wk_ix = 0;

sys/dev/disk/advansys/adwcam.c

414

acb->queue.cdb, csio->cdb_len);

sys/dev/disk/advansys/adwcam.c

424

acb->queue.cdb, csio->cdb_len);

sys/dev/disk/advansys/adwlib.h

419

struct adw_scsi_req_q queue;

sys/dev/disk/advansys/adwlib.h

861

acb->queue.carrier_baddr = adw->commandq->carr_ba;

sys/dev/disk/advansys/adwlib.h

862

acb->queue.carrier_bo = adw->commandq->carr_offset;

sys/dev/disk/amd/amd.c

142

lun_id_t lun, u_int tag, struct srb_queue *queue,

sys/dev/disk/amd/amd.c

748

u_int tag, struct srb_queue *queue, cam_status status)

sys/dev/disk/amd/amd.c

753

for (srb = TAILQ_FIRST(queue); srb != NULL; srb = next_srb) {

sys/dev/disk/amd/amd.c

770

TAILQ_REMOVE(queue, srb, links);

sys/dev/disk/nata/chipsets/ata-promise.c

1126

TAILQ_INSERT_TAIL(&hpktp->queue, hp, chain);

sys/dev/disk/nata/chipsets/ata-promise.c

1142

if ((hp = TAILQ_FIRST(&hpktp->queue))) {

sys/dev/disk/nata/chipsets/ata-promise.c

1143

TAILQ_REMOVE(&hpktp->queue, hp, chain);

sys/dev/disk/nata/chipsets/ata-promise.c

255

TAILQ_INIT(&hpkt->queue);

sys/dev/disk/nata/chipsets/ata-promise.c

91

TAILQ_HEAD(, host_packet) queue;

sys/dev/disk/nvme/nvme.c

128

nvme_subqueue_t *queue = &sc->subqueues[qid];

sys/dev/disk/nvme/nvme.c

135

lockinit(&queue->lk, "nvqlk", 0, 0);

sys/dev/disk/nvme/nvme.c

136

queue->sc = sc;

sys/dev/disk/nvme/nvme.c

137

queue->nqe = sc->maxqe;

sys/dev/disk/nvme/nvme.c

138

queue->qid = qid;

sys/dev/disk/nvme/nvme.c

139

queue->subq_doorbell_reg = NVME_REG_SUBQ_BELL(qid, sc->dstrd4);

sys/dev/disk/nvme/nvme.c

145

error = bus_dmamem_alloc(sc->sque_tag, (void **)&queue->ksubq,

sys/dev/disk/nvme/nvme.c

146

BUS_DMA_ZERO, &queue->sque_map);

sys/dev/disk/nvme/nvme.c

149

error = bus_dmamap_load(sc->sque_tag, queue->sque_map,

sys/dev/disk/nvme/nvme.c

150

queue->ksubq,

sys/dev/disk/nvme/nvme.c

152

nvme_dmamem_saveseg, &queue->psubq,

sys/dev/disk/nvme/nvme.c

163

error = bus_dmamem_alloc(sc->prps_tag, (void **)&queue->kprps,

sys/dev/disk/nvme/nvme.c

164

BUS_DMA_ZERO, &queue->prps_map);

sys/dev/disk/nvme/nvme.c

167

error = bus_dmamap_load(sc->prps_tag, queue->prps_map,

sys/dev/disk/nvme/nvme.c

168

queue->kprps,

sys/dev/disk/nvme/nvme.c

170

nvme_dmamem_saveseg, &queue->pprps,

sys/dev/disk/nvme/nvme.c

179

(void **)&queue->kdatapgs,

sys/dev/disk/nvme/nvme.c

180

BUS_DMA_ZERO, &queue->adm_map);

sys/dev/disk/nvme/nvme.c

183

error = bus_dmamap_load(sc->adm_tag, queue->adm_map,

sys/dev/disk/nvme/nvme.c

184

queue->kdatapgs,

sys/dev/disk/nvme/nvme.c

186

nvme_dmamem_saveseg, &queue->pdatapgs,

sys/dev/disk/nvme/nvme.c

197

queue->reqary = kmalloc(sizeof(nvme_request_t) * queue->nqe,

sys/dev/disk/nvme/nvme.c

199

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

sys/dev/disk/nvme/nvme.c

200

req = &queue->reqary[i];

sys/dev/disk/nvme/nvme.c

205

queue->dump_req = req;

sys/dev/disk/nvme/nvme.c

210

req->next_avail = queue->first_avail;

sys/dev/disk/nvme/nvme.c

211

queue->first_avail = req;

sys/dev/disk/nvme/nvme.c

213

req->subq = queue;

sys/dev/disk/nvme/nvme.c

214

req->comq = &sc->comqueues[queue->comqid];

sys/dev/disk/nvme/nvme.c

217

req->info = &queue->kdatapgs[i];

sys/dev/disk/nvme/nvme.c

218

req->pinfo = queue->pdatapgs +

sys/dev/disk/nvme/nvme.c

235

nvme_comqueue_t *queue = &sc->comqueues[qid];

sys/dev/disk/nvme/nvme.c

242

lockinit(&queue->lk, "nvqlk", 0, 0);

sys/dev/disk/nvme/nvme.c

243

queue->sc = sc;

sys/dev/disk/nvme/nvme.c

244

queue->qid = qid;

sys/dev/disk/nvme/nvme.c

245

queue->phase = NVME_COMQ_STATUS_PHASE;

sys/dev/disk/nvme/nvme.c

246

queue->comq_doorbell_reg = NVME_REG_COMQ_BELL(qid, sc->dstrd4);

sys/dev/disk/nvme/nvme.c

249

error = bus_dmamem_alloc(sc->cque_tag, (void **)&queue->kcomq,

sys/dev/disk/nvme/nvme.c

250

BUS_DMA_ZERO, &queue->cque_map);

sys/dev/disk/nvme/nvme.c

253

error = bus_dmamap_load(sc->cque_tag, queue->cque_map,

sys/dev/disk/nvme/nvme.c

254

queue->kcomq,

sys/dev/disk/nvme/nvme.c

256

nvme_dmamem_saveseg, &queue->pcomq,

sys/dev/disk/nvme/nvme.c

266

queue->nqe = sc->maxqe;

sys/dev/disk/nvme/nvme.c

276

nvme_subqueue_t *queue = &sc->subqueues[qid];

sys/dev/disk/nvme/nvme.c

278

queue->first_avail = NULL;

sys/dev/disk/nvme/nvme.c

279

if (queue->reqary) {

sys/dev/disk/nvme/nvme.c

280

kfree(queue->reqary, M_NVME);

sys/dev/disk/nvme/nvme.c

281

queue->reqary = NULL;

sys/dev/disk/nvme/nvme.c

283

if (queue->ksubq) {

sys/dev/disk/nvme/nvme.c

284

bus_dmamem_free(sc->sque_tag, queue->ksubq, queue->sque_map);

sys/dev/disk/nvme/nvme.c

285

bus_dmamap_unload(sc->sque_tag, queue->sque_map);

sys/dev/disk/nvme/nvme.c

286

bus_dmamap_destroy(sc->sque_tag, queue->sque_map);

sys/dev/disk/nvme/nvme.c

288

if (queue->kprps) {

sys/dev/disk/nvme/nvme.c

289

bus_dmamem_free(sc->prps_tag, queue->kprps, queue->prps_map);

sys/dev/disk/nvme/nvme.c

290

bus_dmamap_unload(sc->prps_tag, queue->prps_map);

sys/dev/disk/nvme/nvme.c

291

bus_dmamap_destroy(sc->prps_tag, queue->prps_map);

sys/dev/disk/nvme/nvme.c

293

if (queue->kdatapgs) {

sys/dev/disk/nvme/nvme.c

294

bus_dmamem_free(sc->adm_tag, queue->kdatapgs, queue->adm_map);

sys/dev/disk/nvme/nvme.c

295

bus_dmamap_unload(sc->adm_tag, queue->adm_map);

sys/dev/disk/nvme/nvme.c

296

bus_dmamap_destroy(sc->adm_tag, queue->adm_map);

sys/dev/disk/nvme/nvme.c

298

bzero(queue, sizeof(*queue));

sys/dev/disk/nvme/nvme.c

304

nvme_comqueue_t *queue = &sc->comqueues[qid];

sys/dev/disk/nvme/nvme.c

309

queue->nqe = 0;

sys/dev/disk/nvme/nvme.c

311

if (queue->kcomq) {

sys/dev/disk/nvme/nvme.c

312

bus_dmamem_free(sc->cque_tag, queue->kcomq, queue->cque_map);

sys/dev/disk/nvme/nvme.c

313

bus_dmamap_unload(sc->cque_tag, queue->cque_map);

sys/dev/disk/nvme/nvme.c

314

bus_dmamap_destroy(sc->cque_tag, queue->cque_map);

sys/dev/disk/nvme/nvme.c

316

bzero(queue, sizeof(*queue));

sys/dev/disk/nvme/nvme.c

348

_nvme_fill_request(nvme_subqueue_t *queue, uint8_t opcode,

sys/dev/disk/nvme/nvme.c

383

kprptab = queue->kprps +

sys/dev/disk/nvme/nvme.c

385

pprptab = queue->pprps +

sys/dev/disk/nvme/nvme.c

426

nvme_get_request(nvme_subqueue_t *queue, uint8_t opcode,

sys/dev/disk/nvme/nvme.c

438

lockmgr(&queue->lk, LK_EXCLUSIVE);

sys/dev/disk/nvme/nvme.c

446

if ((queue->subq_tail + queue->unsubmitted + 1) % queue->nqe ==

sys/dev/disk/nvme/nvme.c

447

queue->subq_head) {

sys/dev/disk/nvme/nvme.c

448

lockmgr(&queue->lk, LK_RELEASE);

sys/dev/disk/nvme/nvme.c

449

KKASSERT(queue->qid != 0);

sys/dev/disk/nvme/nvme.c

450

atomic_swap_int(&queue->signal_requeue, 1);

sys/dev/disk/nvme/nvme.c

461

req = queue->first_avail;

sys/dev/disk/nvme/nvme.c

464

lockmgr(&queue->lk, LK_RELEASE);

sys/dev/disk/nvme/nvme.c

465

KKASSERT(queue->qid != 0);

sys/dev/disk/nvme/nvme.c

466

atomic_swap_int(&queue->signal_requeue, 1);

sys/dev/disk/nvme/nvme.c

471

if (atomic_cmpset_ptr(&queue->first_avail, req, next))

sys/dev/disk/nvme/nvme.c

480

++queue->unsubmitted;

sys/dev/disk/nvme/nvme.c

481

lockmgr(&queue->lk, LK_RELEASE);

sys/dev/disk/nvme/nvme.c

483

_nvme_fill_request(queue, opcode, kva, bytes, req);

sys/dev/disk/nvme/nvme.c

493

nvme_get_dump_request(nvme_subqueue_t *queue, uint8_t opcode,

sys/dev/disk/nvme/nvme.c

499

error = lockmgr(&queue->lk, LK_EXCLUSIVE | LK_NOWAIT);

sys/dev/disk/nvme/nvme.c

500

req = queue->dump_req;

sys/dev/disk/nvme/nvme.c

501

++queue->unsubmitted;

sys/dev/disk/nvme/nvme.c

503

lockmgr(&queue->lk, LK_RELEASE);

sys/dev/disk/nvme/nvme.c

504

_nvme_fill_request(queue, opcode, kva, bytes, req);

sys/dev/disk/nvme/nvme.c

517

nvme_subqueue_t *queue = req->subq;

sys/dev/disk/nvme/nvme.c

520

cmd = &queue->ksubq[queue->subq_tail];

sys/dev/disk/nvme/nvme.c

521

--queue->unsubmitted;

sys/dev/disk/nvme/nvme.c

522

if (++queue->subq_tail == queue->nqe)

sys/dev/disk/nvme/nvme.c

523

queue->subq_tail = 0;

sys/dev/disk/nvme/nvme.c

524

KKASSERT(queue->subq_tail != queue->subq_head);

sys/dev/disk/nvme/nvme.c

528

nvme_write(queue->sc, queue->subq_doorbell_reg, queue->subq_tail);

sys/dev/disk/nvme/nvme.c

609

nvme_subqueue_t *queue = req->subq;

sys/dev/disk/nvme/nvme.c

618

next = queue->first_avail;

sys/dev/disk/nvme/nvme.c

621

if (atomic_cmpset_ptr(&queue->first_avail, next, req))

sys/dev/disk/nvme/nvme.c

631

if (atomic_swap_int(&queue->signal_requeue, 0)) {

sys/dev/disk/nvme/nvme.c

632

atomic_set_int(&queue->sc->admin_signal, ADMIN_SIG_REQUEUE);

sys/dev/disk/nvme/nvme.c

633

wakeup(&queue->sc->admin_signal);

sys/dev/disk/nvme/nvme.h

296

nvme_request_t *nvme_get_request(nvme_subqueue_t *queue, uint8_t opcode,

sys/dev/disk/nvme/nvme.h

298

nvme_request_t *nvme_get_dump_request(nvme_subqueue_t *queue, uint8_t opcode,

sys/dev/disk/nvme/nvme.h

305

void nvme_poll_completions(nvme_comqueue_t *queue, struct lock *lk);

sys/dev/drm/amd/amdgpu/amdgpu_amdkfd.c

151

adev->gfx.kiq.ring.queue),

sys/dev/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v8.c

194

uint32_t queue, uint32_t vmid)

sys/dev/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v8.c

197

uint32_t value = PIPEID(pipe) | MEID(mec) | VMID(vmid) | QUEUEID(queue);

sys/dev/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.c

233

uint32_t queue, uint32_t vmid)

sys/dev/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.c

238

soc15_grbm_select(adev, mec, pipe, queue, vmid);

sys/dev/drm/amd/amdgpu/amdgpu_debugfs.c

106

unsigned instance_bank, sh_bank, se_bank, me, pipe, queue;

sys/dev/drm/amd/amdgpu/amdgpu_debugfs.c

109

instance_bank = sh_bank = se_bank = me = pipe = queue = 0;

sys/dev/drm/amd/amdgpu/amdgpu_debugfs.c

134

queue = (*pos & GENMASK_ULL(53, 44)) >> 44;

sys/dev/drm/amd/amdgpu/amdgpu_debugfs.c

152

amdgpu_gfx_select_me_pipe_q(adev, me, pipe, queue);

sys/dev/drm/amd/amdgpu/amdgpu_gfx.c

165

int i, queue, pipe, mec;

sys/dev/drm/amd/amdgpu/amdgpu_gfx.c

170

queue = i % adev->gfx.mec.num_queue_per_pipe;

sys/dev/drm/amd/amdgpu/amdgpu_gfx.c

182

if (mec == 0 && queue < 2)

sys/dev/drm/amd/amdgpu/amdgpu_gfx.c

205

int mec, pipe, queue;

sys/dev/drm/amd/amdgpu/amdgpu_gfx.c

215

amdgpu_gfx_bit_to_queue(adev, queue_bit, &mec, &pipe, &queue);

sys/dev/drm/amd/amdgpu/amdgpu_gfx.c

222

if ((mec == 1 && pipe > 1) || queue != 0)

sys/dev/drm/amd/amdgpu/amdgpu_gfx.c

227

ring->queue = queue;

sys/dev/drm/amd/amdgpu/amdgpu_gfx.c

259

ksprintf(ring->name, "kiq_%d.%d.%d", ring->me, ring->pipe, ring->queue);

sys/dev/drm/amd/amdgpu/amdgpu_gfx.c

37

int pipe, int queue)

sys/dev/drm/amd/amdgpu/amdgpu_gfx.c

44

bit += queue;

sys/dev/drm/amd/amdgpu/amdgpu_gfx.c

50

int *mec, int *pipe, int *queue)

sys/dev/drm/amd/amdgpu/amdgpu_gfx.c

52

*queue = bit % adev->gfx.mec.num_queue_per_pipe;

sys/dev/drm/amd/amdgpu/amdgpu_gfx.c

61

int mec, int pipe, int queue)

sys/dev/drm/amd/amdgpu/amdgpu_gfx.c

63

return test_bit(amdgpu_gfx_queue_to_bit(adev, mec, pipe, queue),

sys/dev/drm/amd/amdgpu/amdgpu_gfx.h

215

u32 queue);

sys/dev/drm/amd/amdgpu/amdgpu_gfx.h

354

int pipe, int queue);

sys/dev/drm/amd/amdgpu/amdgpu_gfx.h

356

int *mec, int *pipe, int *queue);

sys/dev/drm/amd/amdgpu/amdgpu_gfx.h

358

int pipe, int queue);

sys/dev/drm/amd/amdgpu/amdgpu_ring.h

196

u32 queue;

sys/dev/drm/amd/amdgpu/cik.c

868

u32 me, u32 pipe, u32 queue, u32 vmid)

sys/dev/drm/amd/amdgpu/cik.c

874

((queue << SRBM_GFX_CNTL__QUEUEID__SHIFT) & SRBM_GFX_CNTL__QUEUEID_MASK));

sys/dev/drm/amd/amdgpu/cik.h

30

u32 me, u32 pipe, u32 queue, u32 vmid);

sys/dev/drm/amd/amdgpu/gfx_v7_0.c

3058

cik_srbm_select(adev, ring->me, ring->pipe, ring->queue, 0);

sys/dev/drm/amd/amdgpu/gfx_v7_0.c

4468

int mec, int pipe, int queue)

sys/dev/drm/amd/amdgpu/gfx_v7_0.c

4477

ring->queue = queue;

sys/dev/drm/amd/amdgpu/gfx_v7_0.c

4482

sprintf(ring->name, "comp_%d.%d.%d", ring->me, ring->pipe, ring->queue);

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

1985

int mec, int pipe, int queue)

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

1996

ring->queue = queue;

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

2003

ksprintf(ring->name, "comp_%d.%d.%d", ring->me, ring->pipe, ring->queue);

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

4414

tmp |= (ring->me << 5) | (ring->pipe << 3) | (ring->queue);

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

4467

PACKET3_MAP_QUEUES_QUEUE(ring->queue) |

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

4704

vi_srbm_select(adev, ring->me, ring->pipe, ring->queue, 0);

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

4713

vi_srbm_select(adev, ring->me, ring->pipe, ring->queue, 0);

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

4737

vi_srbm_select(adev, ring->me, ring->pipe, ring->queue, 0);

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

5093

vi_srbm_select(adev, ring->me, ring->pipe, ring->queue, 0);

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

5189

vi_srbm_select(adev, ring->me, ring->pipe, ring->queue, 0);

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

6336

vi_srbm_select(adev, ring->me, ring->pipe, ring->queue, 0);

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

6735

if ((ring->me == me_id) && (ring->pipe == pipe_id) && (ring->queue == queue_id))

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

1668

int mec, int pipe, int queue)

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

1679

ring->queue = queue;

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

1686

sprintf(ring->name, "comp_%d.%d.%d", ring->me, ring->pipe, ring->queue);

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

2804

tmp |= (ring->me << 5) | (ring->pipe << 3) | (ring->queue);

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

2857

PACKET3_MAP_QUEUES_QUEUE(ring->queue) |

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

3180

soc15_grbm_select(adev, ring->me, ring->pipe, ring->queue, 0);

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

3189

soc15_grbm_select(adev, ring->me, ring->pipe, ring->queue, 0);

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

3213

soc15_grbm_select(adev, ring->me, ring->pipe, ring->queue, 0);

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

3431

adev->gfx.kiq.ring.queue, 0);

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

4276

soc15_grbm_select(adev, ring->me, ring->pipe, ring->queue, 0);

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

4692

if ((ring->me == me_id) && (ring->pipe == pipe_id) && (ring->queue == queue_id))

sys/dev/drm/amd/amdgpu/soc15.c

220

u32 me, u32 pipe, u32 queue, u32 vmid)

sys/dev/drm/amd/amdgpu/soc15.c

226

grbm_gfx_cntl = REG_SET_FIELD(grbm_gfx_cntl, GRBM_GFX_CNTL, QUEUEID, queue);

sys/dev/drm/amd/amdgpu/soc15.h

51

u32 me, u32 pipe, u32 queue, u32 vmid);

sys/dev/drm/amd/amdgpu/vi.c

359

u32 me, u32 pipe, u32 queue, u32 vmid)

sys/dev/drm/amd/amdgpu/vi.c

365

srbm_gfx_cntl = REG_SET_FIELD(srbm_gfx_cntl, SRBM_GFX_CNTL, QUEUEID, queue);

sys/dev/drm/amd/amdgpu/vi.h

30

u32 me, u32 pipe, u32 queue, u32 vmid);

sys/dev/drm/drm_atomic_helper.c

1400

ret = wait_event_timeout(dev->vblank[i].queue,

sys/dev/drm/drm_irq.c

202

wake_up(&vblank->queue);

sys/dev/drm/drm_vblank.c

1080

ret = wait_event_timeout(vblank->queue,

sys/dev/drm/drm_vblank.c

1140

wake_up(&vblank->queue);

sys/dev/drm/drm_vblank.c

1626

DRM_WAIT_ON(ret, vblank->queue, 3 * HZ,

sys/dev/drm/drm_vblank.c

1714

wake_up(&vblank->queue);

sys/dev/drm/drm_vblank.c

446

init_waitqueue_head(&vblank->queue);

sys/dev/drm/drm_vblank.c

484

return &crtc->dev->vblank[drm_crtc_index(crtc)].queue;

sys/dev/drm/i915/intel_engine_cs.c

1539

for (rb = rb_first_cached(&execlists->queue); rb; rb = rb_next(rb)) {

sys/dev/drm/i915/intel_engine_cs.c

470

execlists->queue = LINUX_RB_ROOT_CACHED;

sys/dev/drm/i915/intel_engine_cs.c

961

if (!RB_EMPTY_ROOT(&engine->execlists.queue.rb_root))

sys/dev/drm/i915/intel_guc_submission.c

746

while ((rb = rb_first_cached(&execlists->queue))) {

sys/dev/drm/i915/intel_guc_submission.c

771

rb_erase_cached(&p->node, &execlists->queue);

sys/dev/drm/i915/intel_guc_submission.c

786

GEM_BUG_ON(rb_first_cached(&execlists->queue) &&

sys/dev/drm/i915/intel_lrc.c

1143

GEM_BUG_ON(RB_EMPTY_ROOT(&engine->execlists.queue.rb_root));

sys/dev/drm/i915/intel_lrc.c

2014

if (!RB_EMPTY_ROOT(&execlists->queue.rb_root))

sys/dev/drm/i915/intel_lrc.c

276

parent = &execlists->queue.rb_root.rb_node;

sys/dev/drm/i915/intel_lrc.c

314

rb_insert_color_cached(&p->node, &execlists->queue, first);

sys/dev/drm/i915/intel_lrc.c

690

while ((rb = rb_first_cached(&execlists->queue))) {

sys/dev/drm/i915/intel_lrc.c

749

rb_erase_cached(&p->node, &execlists->queue);

sys/dev/drm/i915/intel_lrc.c

781

GEM_BUG_ON(rb_first_cached(&execlists->queue) &&

sys/dev/drm/i915/intel_lrc.c

883

while ((rb = rb_first_cached(&execlists->queue))) {

sys/dev/drm/i915/intel_lrc.c

893

rb_erase_cached(&p->node, &execlists->queue);

sys/dev/drm/i915/intel_lrc.c

902

execlists->queue = LINUX_RB_ROOT_CACHED;

sys/dev/drm/i915/intel_ringbuffer.h

302

struct rb_root_cached queue;

sys/dev/drm/include/drm/drm_os_linux.h

47

#define DRM_WAIT_ON( ret, queue, timeout, condition ) \

sys/dev/drm/include/drm/drm_os_linux.h

54

add_wait_queue(&(queue), &entry); \

sys/dev/drm/include/drm/drm_os_linux.h

71

remove_wait_queue(&(queue), &entry); \

sys/dev/drm/include/drm/drm_vblank.h

98

wait_queue_head_t queue; /**< VBLANK wait queue */

sys/dev/drm/include/drm/spsc_queue.h

102

WRITE_ONCE(queue->head, next);

sys/dev/drm/include/drm/spsc_queue.h

107

if (atomic_long_cmpxchg(&queue->tail,

sys/dev/drm/include/drm/spsc_queue.h

108

(long)&node->next, (long) &queue->head) != (long)&node->next) {

sys/dev/drm/include/drm/spsc_queue.h

112

} while (unlikely(!(queue->head = READ_ONCE(node->next))));

sys/dev/drm/include/drm/spsc_queue.h

116

atomic_dec(&queue->job_count);

sys/dev/drm/include/drm/spsc_queue.h

48

static inline void spsc_queue_init(struct spsc_queue *queue)

sys/dev/drm/include/drm/spsc_queue.h

50

queue->head = NULL;

sys/dev/drm/include/drm/spsc_queue.h

51

atomic_long_set(&queue->tail, (long)&queue->head);

sys/dev/drm/include/drm/spsc_queue.h

52

atomic_set(&queue->job_count, 0);

sys/dev/drm/include/drm/spsc_queue.h

55

static inline struct spsc_node *spsc_queue_peek(struct spsc_queue *queue)

sys/dev/drm/include/drm/spsc_queue.h

57

return queue->head;

sys/dev/drm/include/drm/spsc_queue.h

60

static inline int spsc_queue_count(struct spsc_queue *queue)

sys/dev/drm/include/drm/spsc_queue.h

62

return atomic_read(&queue->job_count);

sys/dev/drm/include/drm/spsc_queue.h

65

static inline bool spsc_queue_push(struct spsc_queue *queue, struct spsc_node *node)

sys/dev/drm/include/drm/spsc_queue.h

73

tail = (struct spsc_node **)atomic_long_xchg(&queue->tail, (long)&node->next);

sys/dev/drm/include/drm/spsc_queue.h

75

atomic_inc(&queue->job_count);

sys/dev/drm/include/drm/spsc_queue.h

85

return tail == &queue->head;

sys/dev/drm/include/drm/spsc_queue.h

89

static inline struct spsc_node *spsc_queue_pop(struct spsc_queue *queue)

sys/dev/drm/include/drm/spsc_queue.h

96

node = READ_ONCE(queue->head);

sys/dev/drm/radeon/cik.c

1837

u32 me, u32 pipe, u32 queue, u32 vmid)

sys/dev/drm/radeon/cik.c

1842

QUEUEID(queue & 0x7));

sys/dev/drm/radeon/cik.c

4174

cik_srbm_select(rdev, ring->me, ring->pipe, ring->queue, 0);

sys/dev/drm/radeon/cik.c

4193

cik_srbm_select(rdev, ring->me, ring->pipe, ring->queue, 0);

sys/dev/drm/radeon/cik.c

4215

cik_srbm_select(rdev, ring->me, ring->pipe, ring->queue, 0);

sys/dev/drm/radeon/cik.c

4633

rdev->ring[idx].queue, 0);

sys/dev/drm/radeon/cik.c

8443

ring->queue = 0; /* first queue */

sys/dev/drm/radeon/cik.c

8455

ring->queue = 1; /* second queue */

sys/dev/drm/radeon/radeon.h

867

u32 queue;

sys/dev/misc/psm/psm.c

2281

sc->queue.count = 0;

sys/dev/misc/psm/psm.c

2282

sc->queue.head = 0;

sys/dev/misc/psm/psm.c

2283

sc->queue.tail = 0;

sys/dev/misc/psm/psm.c

2494

while (sc->queue.count <= 0) {

sys/dev/misc/psm/psm.c

2514

while ((sc->queue.count > 0) && (uio->uio_resid > 0)) {

sys/dev/misc/psm/psm.c

2516

l = imin(sc->queue.count, uio->uio_resid);

sys/dev/misc/psm/psm.c

2519

if (l > sizeof(sc->queue.buf) - sc->queue.head) {

sys/dev/misc/psm/psm.c

2520

bcopy(&sc->queue.buf[sc->queue.head], &buf[0],

sys/dev/misc/psm/psm.c

2521

sizeof(sc->queue.buf) - sc->queue.head);

sys/dev/misc/psm/psm.c

2522

bcopy(&sc->queue.buf[0],

sys/dev/misc/psm/psm.c

2523

&buf[sizeof(sc->queue.buf) - sc->queue.head],

sys/dev/misc/psm/psm.c

2524

l - (sizeof(sc->queue.buf) - sc->queue.head));

sys/dev/misc/psm/psm.c

2526

bcopy(&sc->queue.buf[sc->queue.head], &buf[0], l);

sys/dev/misc/psm/psm.c

2527

sc->queue.count -= l;

sys/dev/misc/psm/psm.c

2528

sc->queue.head = (sc->queue.head + l) % sizeof(sc->queue.buf);

sys/dev/misc/psm/psm.c

2581

sc->queue.count = 0;

sys/dev/misc/psm/psm.c

2582

sc->queue.head = 0;

sys/dev/misc/psm/psm.c

2583

sc->queue.tail = 0;

sys/dev/misc/psm/psm.c

263

synapticspacket_t queue[SYNAPTICS_PACKETQUEUE];

sys/dev/misc/psm/psm.c

4024

dx = abs(smoother->queue[smoother->queue_cursor].x -

sys/dev/misc/psm/psm.c

4026

dy = abs(smoother->queue[smoother->queue_cursor].y -

sys/dev/misc/psm/psm.c

4243

dx = x0 - smoother->queue[cursor].x;

sys/dev/misc/psm/psm.c

4244

dy = y0 - smoother->queue[cursor].y;

sys/dev/misc/psm/psm.c

4252

smoother->queue[cursor].x = x0;

sys/dev/misc/psm/psm.c

4253

smoother->queue[cursor].y = y0;

sys/dev/misc/psm/psm.c

4298

dxp = abs(x0 - smoother->queue[peer].x) + 1;

sys/dev/misc/psm/psm.c

4299

dyp = abs(y0 - smoother->queue[peer].y) + 1;

sys/dev/misc/psm/psm.c

453

ringbuf_t queue; /* mouse status queue */

sys/dev/misc/psm/psm.c

5231

if (sc->queue.count + pb->inputbytes < sizeof(sc->queue.buf)) {

sys/dev/misc/psm/psm.c

5233

sizeof(sc->queue.buf) - sc->queue.tail);

sys/dev/misc/psm/psm.c

5234

bcopy(&pb->ipacket[0], &sc->queue.buf[sc->queue.tail], l);

sys/dev/misc/psm/psm.c

5236

bcopy(&pb->ipacket[l], &sc->queue.buf[0],

sys/dev/misc/psm/psm.c

5238

sc->queue.tail = (sc->queue.tail + pb->inputbytes) %

sys/dev/misc/psm/psm.c

5239

sizeof(sc->queue.buf);

sys/dev/misc/psm/psm.c

5240

sc->queue.count += pb->inputbytes;

sys/dev/misc/psm/psm.c

5314

if (sc->queue.count > 0)

sys/dev/netif/ath/ath_hal/ar5212/ar5212_reset.c

1137

uint32_t queue;

sys/dev/netif/ath/ath_hal/ar5212/ar5212_reset.c

1168

for (queue = 0; queue < AR_NUM_DCU; queue++) {

sys/dev/netif/ath/ath_hal/ar5212/ar5212_reset.c

1170

AR_Q0_STS + (queue * 4)) &

sys/dev/netif/bwn/bwn/if_bwnvar.h

519

#define BWN_WME_PARAMS(queue) \

sys/dev/netif/bwn/bwn/if_bwnvar.h

520

(BWN_SHARED_EDCFQ + (BWN_NR_WMEPARAMS * sizeof(uint16_t) * (queue)))

sys/dev/netif/ix/ixgbe_82599.c

1542

u8 queue)

sys/dev/netif/ix/ixgbe_82599.c

1576

fdircmd |= (u32)queue << IXGBE_FDIRCMD_RX_QUEUE_SHIFT;

sys/dev/netif/ix/ixgbe_82599.c

1588

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

sys/dev/netif/ix/ixgbe_82599.c

1876

u16 soft_id, u8 queue, bool cloud_mode)

sys/dev/netif/ix/ixgbe_82599.c

1946

if (queue == IXGBE_FDIR_DROP_QUEUE)

sys/dev/netif/ix/ixgbe_82599.c

1951

fdircmd |= (u32)queue << IXGBE_FDIRCMD_RX_QUEUE_SHIFT;

sys/dev/netif/ix/ixgbe_82599.c

2015

u16 soft_id, u8 queue, bool cloud_mode)

sys/dev/netif/ix/ixgbe_82599.c

2064

soft_id, queue, cloud_mode);

sys/dev/netif/ix/ixgbe_api.h

156

u8 queue);

sys/dev/netif/ix/ixgbe_api.h

161

u16 soft_id, u8 queue, bool cloud_mode);

sys/dev/netif/ix/ixgbe_api.h

169

u8 queue,

sys/dev/netif/mxge/mxge_mcp.h

511

uint8_t queue;

sys/dev/raid/aac/aac.c

101

static int aac_dequeue_fib(struct aac_softc *sc, int queue,

sys/dev/raid/aac/aac.c

103

static int aac_enqueue_response(struct aac_softc *sc, int queue,

sys/dev/raid/aac/aac.c

2123

aac_enqueue_fib(struct aac_softc *sc, int queue, struct aac_command *cm)

sys/dev/raid/aac/aac.c

2136

pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];

sys/dev/raid/aac/aac.c

2137

ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];

sys/dev/raid/aac/aac.c

2140

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

sys/dev/raid/aac/aac.c

2156

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

sys/dev/raid/aac/aac.c

2157

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

sys/dev/raid/aac/aac.c

2160

sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = pi + 1;

sys/dev/raid/aac/aac.c

2163

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

sys/dev/raid/aac/aac.c

2164

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

sys/dev/raid/aac/aac.c

2177

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

sys/dev/raid/aac/aac.c

2188

pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];

sys/dev/raid/aac/aac.c

2189

ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];

sys/dev/raid/aac/aac.c

2198

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

sys/dev/raid/aac/aac.c

2206

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

sys/dev/raid/aac/aac.c

2210

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

sys/dev/raid/aac/aac.c

2212

switch (queue) {

sys/dev/raid/aac/aac.c

2221

fib_index = (sc->aac_qentries[queue] + ci)->aq_fib_addr /

sys/dev/raid/aac/aac.c

2238

fib_index = (sc->aac_qentries[queue] + ci)->aq_fib_addr;

sys/dev/raid/aac/aac.c

2258

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

sys/dev/raid/aac/aac.c

2261

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

sys/dev/raid/aac/aac.c

2262

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

sys/dev/raid/aac/aac.c

2273

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

sys/dev/raid/aac/aac.c

2288

pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];

sys/dev/raid/aac/aac.c

2289

ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];

sys/dev/raid/aac/aac.c

2292

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

sys/dev/raid/aac/aac.c

2302

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

sys/dev/raid/aac/aac.c

2303

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

sys/dev/raid/aac/aac.c

2306

sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = pi + 1;

sys/dev/raid/aac/aac.c

2309

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

sys/dev/raid/aac/aac.c

2310

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

sys/dev/raid/aac/aac.c

99

static int aac_enqueue_fib(struct aac_softc *sc, int queue,

sys/dev/raid/ips/ips.c

622

ips_copper_queue_t *queue = queueptr;

sys/dev/raid/ips/ips.c

626

queue->base_phys_addr = segments[0].ds_addr;

sys/dev/raid/mfi/mfi.c

1565

TAILQ_HEAD(,mfi_evt_queue_elm) queue;

sys/dev/raid/mfi/mfi.c

1570

TAILQ_INIT(&queue);

sys/dev/raid/mfi/mfi.c

1572

TAILQ_CONCAT(&queue, &sc->mfi_evt_queue, link);

sys/dev/raid/mfi/mfi.c

1574

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

sys/dev/raid/mfi/mfi.c

1575

TAILQ_REMOVE(&queue, elm, link);

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

121

static int ena_com_admin_init_sq(struct ena_com_admin_queue *queue)

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

123

struct ena_com_admin_sq *sq = &queue->sq;

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

124

u16 size = ADMIN_SQ_SIZE(queue->q_depth);

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

126

ENA_MEM_ALLOC_COHERENT(queue->q_dmadev, size, sq->entries, sq->dma_addr,

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

143

static int ena_com_admin_init_cq(struct ena_com_admin_queue *queue)

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

145

struct ena_com_admin_cq *cq = &queue->cq;

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

146

u16 size = ADMIN_CQ_SIZE(queue->q_depth);

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

148

ENA_MEM_ALLOC_COHERENT(queue->q_dmadev, size, cq->entries, cq->dma_addr,

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

207

static inline void comp_ctxt_release(struct ena_com_admin_queue *queue,

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

211

ATOMIC32_DEC(&queue->outstanding_cmds);

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

214

static struct ena_comp_ctx *get_comp_ctxt(struct ena_com_admin_queue *queue,

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

217

if (unlikely(command_id >= queue->q_depth)) {

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

219

command_id, queue->q_depth);

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

223

if (unlikely(queue->comp_ctx[command_id].occupied && capture)) {

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

229

ATOMIC32_INC(&queue->outstanding_cmds);

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

230

queue->comp_ctx[command_id].occupied = true;

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

233

return &queue->comp_ctx[command_id];

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

296

static inline int ena_com_init_comp_ctxt(struct ena_com_admin_queue *queue)

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

298

size_t size = queue->q_depth * sizeof(struct ena_comp_ctx);

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

302

queue->comp_ctx = ENA_MEM_ALLOC(queue->q_dmadev, size);

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

303

if (unlikely(!queue->comp_ctx)) {

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

308

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

sys/dev/virtual/amazon/ena/ena-com/ena_com.c

309

comp_ctx = get_comp_ctxt(queue, i, false);

sys/dev/virtual/virtio/balloon/virtio_balloon.c

645

KASSERT(m->queue == PQ_NONE,

sys/dev/virtual/virtio/mmio/virtio_mmio.c

719

vtmmio_notify_virtqueue(device_t dev, uint16_t queue)

sys/dev/virtual/virtio/mmio/virtio_mmio.c

724

vtmmio_write_config_4(sc, VIRTIO_MMIO_QUEUE_NOTIFY, queue);

sys/dev/virtual/virtio/pci/virtio_pci.c

607

int queue, error;

sys/dev/virtual/virtio/pci/virtio_pci.c

616

for (queue = 0; queue < nvqs; queue++) {

sys/dev/virtual/virtio/pci/virtio_pci.c

617

vqx = &sc->vtpci_vqx[queue];

sys/dev/virtual/virtio/pci/virtio_pci.c

618

info = &vq_info[queue];

sys/dev/virtual/virtio/pci/virtio_pci.c

621

vtpci_write_config_2(sc, VIRTIO_PCI_QUEUE_SEL, queue);

sys/dev/virtual/virtio/pci/virtio_pci.c

624

error = virtqueue_alloc(dev, queue, vq_size,

sys/dev/virtual/virtio/pci/virtio_pci.c

822

int queue, error;

sys/dev/virtual/virtio/pci/virtio_pci.c

858

for (queue = 0; queue < sc->vtpci_nvqs; queue++) {

sys/dev/virtual/virtio/pci/virtio_pci.c

859

vqx = &sc->vtpci_vqx[queue];

sys/dev/virtual/virtio/pci/virtio_pci.c

862

KASSERT(vq != NULL, ("vq %d not allocated", queue));

sys/dev/virtual/virtio/pci/virtio_pci.c

863

vtpci_write_config_2(sc, VIRTIO_PCI_QUEUE_SEL, queue);

sys/dev/virtual/virtio/pci/virtio_pci.c

893

vtpci_notify_virtqueue(device_t dev, uint16_t queue)

sys/dev/virtual/virtio/pci/virtio_pci.c

899

vtpci_write_config_2(sc, VIRTIO_PCI_QUEUE_NOTIFY, queue);

sys/dev/virtual/virtio/virtio/virtqueue.c

144

virtqueue_alloc(device_t dev, uint16_t queue, uint16_t size, int align,

sys/dev/virtual/virtio/virtio/virtqueue.c

156

queue, info->vqai_name);

sys/dev/virtual/virtio/virtio/virtqueue.c

161

queue, info->vqai_name, size);

sys/dev/virtual/virtio/virtio/virtqueue.c

166

queue, info->vqai_name, info->vqai_maxindirsz,

sys/dev/virtual/virtio/virtio/virtqueue.c

180

vq->vq_queue_index = queue;

sys/dev/virtual/virtio/virtio/virtqueue.h

66

int virtqueue_alloc(device_t dev, uint16_t queue, uint16_t size,

sys/kern/kern_mpipe.c

104

STAILQ_INIT(&mpipe->queue);

sys/kern/kern_mpipe.c

136

wakeup(&mpipe->queue);

sys/kern/kern_mpipe.c

178

(mcb = STAILQ_FIRST(&mpipe->queue)) != NULL) {

sys/kern/kern_mpipe.c

179

STAILQ_REMOVE(&mpipe->queue, mcb, mpipe_callback, entry);

sys/kern/kern_mpipe.c

183

if (STAILQ_FIRST(&mpipe->queue))

sys/kern/kern_mpipe.c

185

tsleep(&mpipe->queue, 0, "wait", 0);

sys/kern/kern_mpipe.c

276

STAILQ_INSERT_TAIL(&mpipe->queue, mcb, entry);

sys/kern/kern_mpipe.c

302

tsleep(&mpipe->queue, 0, "wait", 0);

sys/kern/kern_mpipe.c

356

wakeup(&mpipe->queue);

sys/kern/kern_synch.c

1017

for (td = TAILQ_FIRST(&qp->queue); td != NULL; td = ntd) {

sys/kern/kern_synch.c

1050

if (TAILQ_FIRST(&qp->queue) == NULL) {

sys/kern/kern_synch.c

1512

TAILQ_INIT(&dummy_slpque.queue);

sys/kern/kern_synch.c

1537

TAILQ_FOREACH(td, &qp->queue, td_sleepq) {

sys/kern/kern_synch.c

1555

TAILQ_INIT(&gd->gd_tsleep_hash[i].queue);

sys/kern/kern_synch.c

415

TAILQ_REMOVE(&qp->queue, td, td_sleepq);

sys/kern/kern_synch.c

416

if (TAILQ_FIRST(&qp->queue) == NULL) {

sys/kern/kern_synch.c

430

TAILQ_INSERT_TAIL(&qp->queue, td, td_sleepq);

sys/kern/kern_synch.c

475

TAILQ_REMOVE(&qp->queue, td, td_sleepq);

sys/kern/kern_synch.c

476

if (TAILQ_FIRST(&qp->queue) == NULL) {

sys/kern/kern_synch.c

69

TAILQ_HEAD(, thread) queue;

sys/kern/kern_systimer.c

199

info->queue = &gd->gd_systimerq;

sys/kern/kern_systimer.c

225

TAILQ_REMOVE(info->queue, info, node);

sys/kern/kern_systimer.c

97

TAILQ_REMOVE(info->queue, info, node);

sys/kern/lwkt_msgport.c

461

lwkt_msg_queue *queue;

sys/kern/lwkt_msgport.c

467

queue = &port->mp_msgq_prio;

sys/kern/lwkt_msgport.c

469

queue = &port->mp_msgq;

sys/kern/lwkt_msgport.c

470

TAILQ_REMOVE(queue, msg, ms_node);

sys/kern/lwkt_msgport.c

482

lwkt_msg_queue *queue;

sys/kern/lwkt_msgport.c

489

queue = &port->mp_msgq_prio;

sys/kern/lwkt_msgport.c

491

queue = &port->mp_msgq;

sys/kern/lwkt_msgport.c

492

TAILQ_INSERT_TAIL(queue, msg, ms_node);

sys/kern/subr_disk.c

1388

TAILQ_INSERT_TAIL(&bioq->queue, bio, bio_act);

sys/kern/subr_disk.c

1397

TAILQ_INSERT_TAIL(&bioq->queue, bio, bio_act);

sys/kern/subr_gtaskqueue.c

112

struct gtaskqueue *queue;

sys/kern/subr_gtaskqueue.c

114

queue = kmalloc(sizeof(struct gtaskqueue),

sys/kern/subr_gtaskqueue.c

116

if (!queue) {

sys/kern/subr_gtaskqueue.c

121

STAILQ_INIT(&queue->tq_queue);

sys/kern/subr_gtaskqueue.c

122

LIST_INIT(&queue->tq_active);

sys/kern/subr_gtaskqueue.c

123

queue->tq_enqueue = enqueue;

sys/kern/subr_gtaskqueue.c

124

queue->tq_context = context;

sys/kern/subr_gtaskqueue.c

125

queue->tq_name = name ? name : "taskqueue";

sys/kern/subr_gtaskqueue.c

126

queue->tq_flags |= TQ_FLAGS_ACTIVE;

sys/kern/subr_gtaskqueue.c

128

queue->tq_flags |= TQ_FLAGS_UNLOCKED_ENQUEUE;

sys/kern/subr_gtaskqueue.c

129

lockinit(&queue->tq_lock, queue->tq_name, 0, 0);

sys/kern/subr_gtaskqueue.c

131

return (queue);

sys/kern/subr_gtaskqueue.c

148

gtaskqueue_free(struct gtaskqueue *queue)

sys/kern/subr_gtaskqueue.c

151

TQ_LOCK(queue);

sys/kern/subr_gtaskqueue.c

152

queue->tq_flags &= ~TQ_FLAGS_ACTIVE;

sys/kern/subr_gtaskqueue.c

153

gtaskqueue_terminate(queue->tq_threads, queue);

sys/kern/subr_gtaskqueue.c

154

KASSERT(LIST_EMPTY(&queue->tq_active), ("Tasks still running?"));

sys/kern/subr_gtaskqueue.c

155

KASSERT(queue->tq_callouts == 0, ("Armed timeout tasks"));

sys/kern/subr_gtaskqueue.c

156

lockuninit(&queue->tq_lock);

sys/kern/subr_gtaskqueue.c

157

kfree(queue->tq_threads, M_GTASKQUEUE);

sys/kern/subr_gtaskqueue.c

159

kfree(queue, M_GTASKQUEUE);

sys/kern/subr_gtaskqueue.c

168

struct gtaskqueue *queue = grouptask->gt_taskqueue;

sys/kern/subr_gtaskqueue.c

172

if (queue == NULL) {

sys/kern/subr_gtaskqueue.c

177

TQ_LOCK(queue);

sys/kern/subr_gtaskqueue.c

179

gtaskqueue_drain_locked(queue, gtask);

sys/kern/subr_gtaskqueue.c

180

TQ_UNLOCK(queue);

sys/kern/subr_gtaskqueue.c

186

struct gtaskqueue *queue = grouptask->gt_taskqueue;

sys/kern/subr_gtaskqueue.c

190

if (queue == NULL) {

sys/kern/subr_gtaskqueue.c

195

TQ_LOCK(queue);

sys/kern/subr_gtaskqueue.c

197

TQ_UNLOCK(queue);

sys/kern/subr_gtaskqueue.c

201

grouptaskqueue_enqueue(struct gtaskqueue *queue, struct gtask *gtask)

sys/kern/subr_gtaskqueue.c

204

if (queue == NULL) {

sys/kern/subr_gtaskqueue.c

209

TQ_LOCK(queue);

sys/kern/subr_gtaskqueue.c

211

TQ_UNLOCK(queue);

sys/kern/subr_gtaskqueue.c

215

TQ_UNLOCK(queue);

sys/kern/subr_gtaskqueue.c

218

STAILQ_INSERT_TAIL(&queue->tq_queue, gtask, ta_link);

sys/kern/subr_gtaskqueue.c

220

TQ_UNLOCK(queue);

sys/kern/subr_gtaskqueue.c

221

if ((queue->tq_flags & TQ_FLAGS_BLOCKED) == 0)

sys/kern/subr_gtaskqueue.c

222

queue->tq_enqueue(queue->tq_context);

sys/kern/subr_gtaskqueue.c

237

gtaskqueue_drain_tq_queue(struct gtaskqueue *queue)

sys/kern/subr_gtaskqueue.c

241

if (STAILQ_EMPTY(&queue->tq_queue))

sys/kern/subr_gtaskqueue.c

253

STAILQ_INSERT_TAIL(&queue->tq_queue, &t_barrier, ta_link);

sys/kern/subr_gtaskqueue.c

261

TQ_SLEEP(queue, &t_barrier, "gtq_qdrain");

sys/kern/subr_gtaskqueue.c

270

gtaskqueue_drain_tq_active(struct gtaskqueue *queue)

sys/kern/subr_gtaskqueue.c

275

if (LIST_EMPTY(&queue->tq_active))

sys/kern/subr_gtaskqueue.c

279

queue->tq_callouts++;

sys/kern/subr_gtaskqueue.c

282

seq = queue->tq_seq;

sys/kern/subr_gtaskqueue.c

284

LIST_FOREACH(tb, &queue->tq_active, tb_link) {

sys/kern/subr_gtaskqueue.c

286

TQ_SLEEP(queue, tb->tb_running, "gtq_adrain");

sys/kern/subr_gtaskqueue.c

292

queue->tq_callouts--;

sys/kern/subr_gtaskqueue.c

293

if ((queue->tq_flags & TQ_FLAGS_ACTIVE) == 0)

sys/kern/subr_gtaskqueue.c

294

wakeup_one(queue->tq_threads);

sys/kern/subr_gtaskqueue.c

298

gtaskqueue_block(struct gtaskqueue *queue)

sys/kern/subr_gtaskqueue.c

301

TQ_LOCK(queue);

sys/kern/subr_gtaskqueue.c

302

queue->tq_flags |= TQ_FLAGS_BLOCKED;

sys/kern/subr_gtaskqueue.c

303

TQ_UNLOCK(queue);

sys/kern/subr_gtaskqueue.c

307

gtaskqueue_unblock(struct gtaskqueue *queue)

sys/kern/subr_gtaskqueue.c

310

TQ_LOCK(queue);

sys/kern/subr_gtaskqueue.c

311

queue->tq_flags &= ~TQ_FLAGS_BLOCKED;

sys/kern/subr_gtaskqueue.c

312

if (!STAILQ_EMPTY(&queue->tq_queue))

sys/kern/subr_gtaskqueue.c

313

queue->tq_enqueue(queue->tq_context);

sys/kern/subr_gtaskqueue.c

314

TQ_UNLOCK(queue);

sys/kern/subr_gtaskqueue.c

318

gtaskqueue_run_locked(struct gtaskqueue *queue)

sys/kern/subr_gtaskqueue.c

327

KASSERT(queue != NULL, ("tq is NULL"));

sys/kern/subr_gtaskqueue.c

328

TQ_ASSERT_LOCKED(queue);

sys/kern/subr_gtaskqueue.c

330

LIST_INSERT_HEAD(&queue->tq_active, &tb, tb_link);

sys/kern/subr_gtaskqueue.c

335

while ((gtask = STAILQ_FIRST(&queue->tq_queue)) != NULL) {

sys/kern/subr_gtaskqueue.c

336

STAILQ_REMOVE_HEAD(&queue->tq_queue, ta_link);

sys/kern/subr_gtaskqueue.c

339

tb.tb_seq = ++queue->tq_seq;

sys/kern/subr_gtaskqueue.c

340

TQ_UNLOCK(queue);

sys/kern/subr_gtaskqueue.c

354

TQ_LOCK(queue);

sys/kern/subr_gtaskqueue.c

365

task_is_running(struct gtaskqueue *queue, struct gtask *gtask)

sys/kern/subr_gtaskqueue.c

369

TQ_ASSERT_LOCKED(queue);

sys/kern/subr_gtaskqueue.c

370

LIST_FOREACH(tb, &queue->tq_active, tb_link) {

sys/kern/subr_gtaskqueue.c

378

gtaskqueue_cancel_locked(struct gtaskqueue *queue, struct gtask *gtask)

sys/kern/subr_gtaskqueue.c

382

STAILQ_REMOVE(&queue->tq_queue, gtask, gtask, ta_link);

sys/kern/subr_gtaskqueue.c

384

return (task_is_running(queue, gtask) ? EBUSY : 0);

sys/kern/subr_gtaskqueue.c

388

gtaskqueue_cancel(struct gtaskqueue *queue, struct gtask *gtask)

sys/kern/subr_gtaskqueue.c

392

TQ_LOCK(queue);

sys/kern/subr_gtaskqueue.c

393

error = gtaskqueue_cancel_locked(queue, gtask);

sys/kern/subr_gtaskqueue.c

394

TQ_UNLOCK(queue);

sys/kern/subr_gtaskqueue.c

400

gtaskqueue_drain_locked(struct gtaskqueue *queue, struct gtask *gtask)

sys/kern/subr_gtaskqueue.c

402

while ((gtask->ta_flags & TASK_ENQUEUED) || task_is_running(queue, gtask))

sys/kern/subr_gtaskqueue.c

403

TQ_SLEEP(queue, gtask, "gtq_drain");

sys/kern/subr_gtaskqueue.c

407

gtaskqueue_drain(struct gtaskqueue *queue, struct gtask *gtask)

sys/kern/subr_gtaskqueue.c

409

TQ_LOCK(queue);

sys/kern/subr_gtaskqueue.c

410

gtaskqueue_drain_locked(queue, gtask);

sys/kern/subr_gtaskqueue.c

411

TQ_UNLOCK(queue);

sys/kern/subr_gtaskqueue.c

415

gtaskqueue_drain_all(struct gtaskqueue *queue)

sys/kern/subr_gtaskqueue.c

418

TQ_LOCK(queue);

sys/kern/subr_gtaskqueue.c

419

gtaskqueue_drain_tq_queue(queue);

sys/kern/subr_gtaskqueue.c

420

gtaskqueue_drain_tq_active(queue);

sys/kern/subr_gtaskqueue.c

421

TQ_UNLOCK(queue);

sys/kern/subr_gtaskqueue.c

48

static int task_is_running(struct gtaskqueue *queue, struct gtask *gtask);

sys/kern/subr_gtaskqueue.c

49

static void gtaskqueue_drain_locked(struct gtaskqueue *queue, struct gtask *gtask);

sys/kern/subr_sleepqueue.c

253

int flags, int queue)

sys/kern/subr_sleepqueue.c

266

++wc->wc_blocked[queue];

sys/kern/subr_sleepqueue.c

275

domain = PDOMAIN_FBSD0 + queue * PDOMAIN_FBSDINC;

sys/kern/subr_sleepqueue.c

284

td->td_sqqueue = queue;

sys/kern/subr_sleepqueue.c

309

sleepq_sleepcnt(const void *wchan, int queue)

sys/kern/subr_sleepqueue.c

314

return (wc->wc_blocked[queue]);

sys/kern/subr_sleepqueue.c

488

sleepq_signal(const void *wchan, int flags, int pri, int queue)

sys/kern/subr_sleepqueue.c

492

domain = PDOMAIN_FBSD0 + queue * PDOMAIN_FBSDINC;

sys/kern/subr_sleepqueue.c

505

sleepq_broadcast(const void *wchan, int flags, int pri, int queue)

sys/kern/subr_sleepqueue.c

509

domain = PDOMAIN_FBSD0 + queue * PDOMAIN_FBSDINC;

sys/kern/subr_taskqueue.c

118

struct taskqueue *queue;

sys/kern/subr_taskqueue.c

120

queue = kmalloc(sizeof(*queue), M_TASKQUEUE, mflags | M_ZERO);

sys/kern/subr_taskqueue.c

121

if (!queue)

sys/kern/subr_taskqueue.c

123

STAILQ_INIT(&queue->tq_queue);

sys/kern/subr_taskqueue.c

124

queue->tq_name = name;

sys/kern/subr_taskqueue.c

125

queue->tq_enqueue = enqueue;

sys/kern/subr_taskqueue.c

126

queue->tq_context = context;

sys/kern/subr_taskqueue.c

127

queue->tq_flags |= TQ_FLAGS_ACTIVE;

sys/kern/subr_taskqueue.c

128

TQ_LOCK_INIT(queue);

sys/kern/subr_taskqueue.c

131

STAILQ_INSERT_TAIL(&taskqueue_queues, queue, tq_link);

sys/kern/subr_taskqueue.c

134

return queue;

sys/kern/subr_taskqueue.c

151

taskqueue_free(struct taskqueue *queue)

sys/kern/subr_taskqueue.c

153

TQ_LOCK(queue);

sys/kern/subr_taskqueue.c

154

queue->tq_flags &= ~TQ_FLAGS_ACTIVE;

sys/kern/subr_taskqueue.c

155

taskqueue_run(queue, 1);

sys/kern/subr_taskqueue.c

156

taskqueue_terminate(queue->tq_threads, queue);

sys/kern/subr_taskqueue.c

157

TQ_UNLOCK(queue);

sys/kern/subr_taskqueue.c

160

STAILQ_REMOVE(&taskqueue_queues, queue, taskqueue, tq_link);

sys/kern/subr_taskqueue.c

163

TQ_LOCK_UNINIT(queue);

sys/kern/subr_taskqueue.c

165

kfree(queue, M_TASKQUEUE);

sys/kern/subr_taskqueue.c

171

struct taskqueue *queue;

sys/kern/subr_taskqueue.c

174

STAILQ_FOREACH(queue, &taskqueue_queues, tq_link) {

sys/kern/subr_taskqueue.c

175

if (!strcmp(queue->tq_name, name)) {

sys/kern/subr_taskqueue.c

177

return queue;

sys/kern/subr_taskqueue.c

191

taskqueue_enqueue_locked(struct taskqueue *queue, struct task *task)

sys/kern/subr_taskqueue.c

199

if ((queue->tq_flags & TQ_FLAGS_ACTIVE) == 0)

sys/kern/subr_taskqueue.c

206

KKASSERT(queue == task->ta_queue);

sys/kern/subr_taskqueue.c

210

task->ta_queue = queue;

sys/kern/subr_taskqueue.c

215

prev = STAILQ_LAST(&queue->tq_queue, task, ta_link);

sys/kern/subr_taskqueue.c

217

STAILQ_INSERT_TAIL(&queue->tq_queue, task, ta_link);

sys/kern/subr_taskqueue.c

220

for (ins = STAILQ_FIRST(&queue->tq_queue); ins;

sys/kern/subr_taskqueue.c

226

STAILQ_INSERT_AFTER(&queue->tq_queue, prev, task, ta_link);

sys/kern/subr_taskqueue.c

228

STAILQ_INSERT_HEAD(&queue->tq_queue, task, ta_link);

sys/kern/subr_taskqueue.c

232

if ((queue->tq_flags & TQ_FLAGS_BLOCKED) == 0) {

sys/kern/subr_taskqueue.c

233

if (queue->tq_enqueue)

sys/kern/subr_taskqueue.c

234

queue->tq_enqueue(queue->tq_context);

sys/kern/subr_taskqueue.c

236

queue->tq_flags |= TQ_FLAGS_PENDING;

sys/kern/subr_taskqueue.c

247

taskqueue_enqueue(struct taskqueue *queue, struct task *task)

sys/kern/subr_taskqueue.c

251

TQ_LOCK(queue);

sys/kern/subr_taskqueue.c

252

res = taskqueue_enqueue_locked(queue, task);

sys/kern/subr_taskqueue.c

253

TQ_UNLOCK(queue);

sys/kern/subr_taskqueue.c

264

taskqueue_enqueue_optq(struct taskqueue *queue, struct taskqueue **qpp,

sys/kern/subr_taskqueue.c

281

task->ta_queue = queue;

sys/kern/subr_taskqueue.c

286

if (qtmp == queue)

sys/kern/subr_taskqueue.c

305

task->ta_queue = queue;

sys/kern/subr_taskqueue.c

316

*qpp = queue;

sys/kern/subr_taskqueue.c

317

res = taskqueue_enqueue_locked(queue, task);

sys/kern/subr_taskqueue.c

318

TQ_UNLOCK(queue);

sys/kern/subr_taskqueue.c

326

struct taskqueue *queue;

sys/kern/subr_taskqueue.c

330

queue = timeout_task->t.ta_queue;

sys/kern/subr_taskqueue.c

332

TQ_LOCK(queue);

sys/kern/subr_taskqueue.c

335

queue->tq_callouts--;

sys/kern/subr_taskqueue.c

336

taskqueue_enqueue_locked(queue, &timeout_task->t);

sys/kern/subr_taskqueue.c

337

TQ_UNLOCK(queue);

sys/kern/subr_taskqueue.c

341

taskqueue_enqueue_timeout(struct taskqueue *queue,

sys/kern/subr_taskqueue.c

346

TQ_LOCK(queue);

sys/kern/subr_taskqueue.c

348

timeout_task->t.ta_queue == queue,

sys/kern/subr_taskqueue.c

350

timeout_task->t.ta_queue = queue;

sys/kern/subr_taskqueue.c

353

taskqueue_enqueue_locked(queue, &timeout_task->t);

sys/kern/subr_taskqueue.c

354

TQ_UNLOCK(queue);

sys/kern/subr_taskqueue.c

359

queue->tq_callouts++;

sys/kern/subr_taskqueue.c

362

TQ_UNLOCK(queue);

sys/kern/subr_taskqueue.c

370

taskqueue_block(struct taskqueue *queue)

sys/kern/subr_taskqueue.c

372

TQ_LOCK(queue);

sys/kern/subr_taskqueue.c

373

queue->tq_flags |= TQ_FLAGS_BLOCKED;

sys/kern/subr_taskqueue.c

374

TQ_UNLOCK(queue);

sys/kern/subr_taskqueue.c

378

taskqueue_unblock(struct taskqueue *queue)

sys/kern/subr_taskqueue.c

380

TQ_LOCK(queue);

sys/kern/subr_taskqueue.c

381

queue->tq_flags &= ~TQ_FLAGS_BLOCKED;

sys/kern/subr_taskqueue.c

382

if (queue->tq_flags & TQ_FLAGS_PENDING) {

sys/kern/subr_taskqueue.c

383

queue->tq_flags &= ~TQ_FLAGS_PENDING;

sys/kern/subr_taskqueue.c

384

if (queue->tq_enqueue)

sys/kern/subr_taskqueue.c

385

queue->tq_enqueue(queue->tq_context);

sys/kern/subr_taskqueue.c

387

TQ_UNLOCK(queue);

sys/kern/subr_taskqueue.c

391

taskqueue_run(struct taskqueue *queue, int lock_held)

sys/kern/subr_taskqueue.c

397

TQ_LOCK(queue);

sys/kern/subr_taskqueue.c

398

while (STAILQ_FIRST(&queue->tq_queue)) {

sys/kern/subr_taskqueue.c

403

task = STAILQ_FIRST(&queue->tq_queue);

sys/kern/subr_taskqueue.c

404

STAILQ_REMOVE_HEAD(&queue->tq_queue, ta_link);

sys/kern/subr_taskqueue.c

407

queue->tq_running = task;

sys/kern/subr_taskqueue.c

409

TQ_UNLOCK(queue);

sys/kern/subr_taskqueue.c

411

queue->tq_running = NULL;

sys/kern/subr_taskqueue.c

413

TQ_LOCK(queue);

sys/kern/subr_taskqueue.c

416

TQ_UNLOCK(queue);

sys/kern/subr_taskqueue.c

420

taskqueue_cancel_locked(struct taskqueue *queue, struct task *task,

sys/kern/subr_taskqueue.c

425

STAILQ_REMOVE(&queue->tq_queue, task, task, ta_link);

sys/kern/subr_taskqueue.c

429

return (task == queue->tq_running ? EBUSY : 0);

sys/kern/subr_taskqueue.c

433

taskqueue_cancel(struct taskqueue *queue, struct task *task, u_int *pendp)

sys/kern/subr_taskqueue.c

437

TQ_LOCK(queue);

sys/kern/subr_taskqueue.c

438

error = taskqueue_cancel_locked(queue, task, pendp);

sys/kern/subr_taskqueue.c

439

TQ_UNLOCK(queue);

sys/kern/subr_taskqueue.c

447

struct taskqueue *queue;

sys/kern/subr_taskqueue.c

451

queue = task->ta_queue;

sys/kern/subr_taskqueue.c

453

if (queue == NULL) {

sys/kern/subr_taskqueue.c

457

TQ_LOCK(queue);

sys/kern/subr_taskqueue.c

458

if (queue == task->ta_queue) {

sys/kern/subr_taskqueue.c

459

error = taskqueue_cancel_locked(queue, task, NULL);

sys/kern/subr_taskqueue.c

460

TQ_UNLOCK(queue);

sys/kern/subr_taskqueue.c

463

TQ_UNLOCK(queue);

sys/kern/subr_taskqueue.c

469

taskqueue_cancel_timeout(struct taskqueue *queue,

sys/kern/subr_taskqueue.c

476

TQ_LOCK(queue);

sys/kern/subr_taskqueue.c

477

error = taskqueue_cancel_locked(queue, &timeout_task->t, &pending1);

sys/kern/subr_taskqueue.c

480

queue->tq_callouts--;

sys/kern/subr_taskqueue.c

482

TQ_UNLOCK(queue);

sys/kern/subr_taskqueue.c

490

taskqueue_drain(struct taskqueue *queue, struct task *task)

sys/kern/subr_taskqueue.c

492

TQ_LOCK(queue);

sys/kern/subr_taskqueue.c

493

while (task->ta_pending != 0 || task == queue->tq_running)

sys/kern/subr_taskqueue.c

494

TQ_SLEEP(queue, task, "-");

sys/kern/subr_taskqueue.c

495

TQ_UNLOCK(queue);

sys/kern/subr_taskqueue.c

504

struct taskqueue *queue;

sys/kern/subr_taskqueue.c

507

queue = task->ta_queue;

sys/kern/subr_taskqueue.c

509

if (queue == NULL)

sys/kern/subr_taskqueue.c

511

TQ_LOCK(queue);

sys/kern/subr_taskqueue.c

512

if (task->ta_pending == 0 && task != queue->tq_running) {

sys/kern/subr_taskqueue.c

513

TQ_UNLOCK(queue);

sys/kern/subr_taskqueue.c

516

TQ_SLEEP(queue, task, "-");

sys/kern/subr_taskqueue.c

517

TQ_UNLOCK(queue);

sys/kern/subr_taskqueue.c

522

taskqueue_drain_timeout(struct taskqueue *queue,

sys/kern/subr_taskqueue.c

526

taskqueue_drain(queue, &timeout_task->t);

sys/kern/subr_taskqueue.c

72

_timeout_task_init(struct taskqueue *queue, struct timeout_task *timeout_task,

sys/kern/subr_taskqueue.c

78

timeout_task->t.ta_queue = queue;

sys/kern/subr_taskqueue.c

82

static void taskqueue_run(struct taskqueue *queue, int lock_held);

sys/kern/vfs_bio.c

2229

buf_daemon1(struct thread *td, int queue, int (*buf_limit_fn)(long),

sys/kern/vfs_bio.c

2270

if (flushbufqueues(marker, queue) == 0)

sys/net/altq/altq_fairq.c

433

qlimit(&cl->cl_buckets[i].queue) = qlimit;

sys/net/altq/altq_fairq.c

769

return rio_addq((rio_t *)cl->cl_red, &b->queue, m, cl->cl_pktattr);

sys/net/altq/altq_fairq.c

773

return red_addq(cl->cl_red, &b->queue, m, cl->cl_pktattr);

sys/net/altq/altq_fairq.c

775

if (qlen(&b->queue) >= qlimit(&b->queue)) {

sys/net/altq/altq_fairq.c

783

_addq(&b->queue, m);

sys/net/altq/altq_fairq.c

799

m = rio_getq((rio_t *)cl->cl_red, &b->queue);

sys/net/altq/altq_fairq.c

803

m = red_getq(cl->cl_red, &b->queue);

sys/net/altq/altq_fairq.c

806

m = _getq(&b->queue);

sys/net/altq/altq_fairq.c

872

m = qhead(&b->queue);

sys/net/altq/altq_fairq.c

918

if (qempty(&b->queue)) {

sys/net/altq/altq_fairq.c

965

while ((m = _getq(&b->queue)) != NULL) {

sys/net/altq/altq_fairq.c

969

KKASSERT(qlen(&b->queue) == 0);

sys/net/altq/altq_fairq.c

988

sp->qlength += qlen(&b->queue);

sys/net/altq/altq_fairq.h

86

class_queue_t queue; /* the actual queue */

sys/net/dummynet/ip_dummynet.c

1092

TAILQ_INSERT_TAIL(&q->queue, pkt, dn_next);

sys/net/dummynet/ip_dummynet.c

1096

if (TAILQ_FIRST(&q->queue) != pkt) /* Flow was not idle, we are done */

sys/net/dummynet/ip_dummynet.c

1202

while ((pkt = TAILQ_FIRST(&q->queue)) != NULL) {

sys/net/dummynet/ip_dummynet.c

1203

TAILQ_REMOVE(&q->queue, pkt, dn_next);

sys/net/dummynet/ip_dummynet.c

443

TAILQ_REMOVE(&q->queue, pkt, dn_next);

sys/net/dummynet/ip_dummynet.c

481

while ((pkt = TAILQ_FIRST(&q->queue)) != NULL) {

sys/net/dummynet/ip_dummynet.c

498

if ((pkt = TAILQ_FIRST(&q->queue)) != NULL) {

sys/net/dummynet/ip_dummynet.c

546

struct dn_pkt *pkt = TAILQ_FIRST(&q->queue);

sys/net/dummynet/ip_dummynet.c

566

len = TAILQ_FIRST(&q->queue)->dn_m->m_pkthdr.len;

sys/net/dummynet/ip_dummynet.c

718

if (!TAILQ_EMPTY(&q->queue) || q->S != q->F + 1)

sys/net/dummynet/ip_dummynet.c

761

TAILQ_INIT(&q->queue);

sys/net/dummynet/ip_dummynet.c

816

} else if (pipe_expire && TAILQ_EMPTY(&q->queue) &&

sys/net/dummynet/ip_dummynet.h

222

struct dn_pkt_queue queue; /* queue of packets */

sys/net/dummynet3/ip_dummynet3.c

1111

TAILQ_INSERT_TAIL(&q->queue, pkt, dn_next);

sys/net/dummynet3/ip_dummynet3.c

1115

if (TAILQ_FIRST(&q->queue) != pkt) /* Flow was not idle, we are done */

sys/net/dummynet3/ip_dummynet3.c

1221

while ((pkt = TAILQ_FIRST(&q->queue)) != NULL) {

sys/net/dummynet3/ip_dummynet3.c

1222

TAILQ_REMOVE(&q->queue, pkt, dn_next);

sys/net/dummynet3/ip_dummynet3.c

462

TAILQ_REMOVE(&q->queue, pkt, dn_next);

sys/net/dummynet3/ip_dummynet3.c

500

while ((pkt = TAILQ_FIRST(&q->queue)) != NULL) {

sys/net/dummynet3/ip_dummynet3.c

517

if ((pkt = TAILQ_FIRST(&q->queue)) != NULL) {

sys/net/dummynet3/ip_dummynet3.c

565

struct dn_pkt *pkt = TAILQ_FIRST(&q->queue);

sys/net/dummynet3/ip_dummynet3.c

585

len = TAILQ_FIRST(&q->queue)->dn_m->m_pkthdr.len;

sys/net/dummynet3/ip_dummynet3.c

737

if (!TAILQ_EMPTY(&q->queue) || q->S != q->F + 1)

sys/net/dummynet3/ip_dummynet3.c

780

TAILQ_INIT(&q->queue);

sys/net/dummynet3/ip_dummynet3.c

835

} else if (pipe_expire && TAILQ_EMPTY(&q->queue) &&

sys/net/dummynet3/ip_dummynet3.h

237

struct dn_pkt_queue queue; /* queue of packets */

sys/net/wg/if_wg.c

1756

struct wg_queue *queue = &sc->sc_handshake_queue;

sys/net/wg/if_wg.c

1759

while ((pkt = wg_queue_dequeue_handshake(queue)) != NULL)

sys/net/wg/if_wg.c

1943

struct wg_queue *queue = &sc->sc_encrypt_parallel;

sys/net/wg/if_wg.c

1946

while ((pkt = wg_queue_dequeue_parallel(queue)) != NULL)

sys/net/wg/if_wg.c

1954

struct wg_queue *queue = &sc->sc_decrypt_parallel;

sys/net/wg/if_wg.c

1957

while ((pkt = wg_queue_dequeue_parallel(queue)) != NULL)

sys/net/wg/if_wg.c

1991

struct wg_queue *queue = &peer->p_encrypt_serial;

sys/net/wg/if_wg.c

1999

while ((pkt = wg_queue_dequeue_serial(queue)) != NULL) {

sys/net/wg/if_wg.c

2037

struct wg_queue *queue = &peer->p_decrypt_serial;

sys/net/wg/if_wg.c

2047

while ((pkt = wg_queue_dequeue_serial(queue)) != NULL) {

sys/net/wg/if_wg.c

395

wg_queue_init(struct wg_queue *queue, const char *name)

sys/net/wg/if_wg.c

397

lockinit(&queue->q_mtx, name, 0, 0);

sys/net/wg/if_wg.c

398

STAILQ_INIT(&queue->q_queue);

sys/net/wg/if_wg.c

399

queue->q_len = 0;

sys/net/wg/if_wg.c

403

wg_queue_deinit(struct wg_queue *queue)

sys/net/wg/if_wg.c

405

wg_queue_purge(queue);

sys/net/wg/if_wg.c

406

lockuninit(&queue->q_mtx);

sys/net/wg/if_wg.c

410

wg_queue_len(const struct wg_queue *queue)

sys/net/wg/if_wg.c

412

return (queue->q_len);

sys/netgraph7/bluetooth/drivers/bt3c/ng_bt3c_pccard.c

444

switch (((ng_bt3c_node_qlen_ep *)(msg->data))->queue) {

sys/netgraph7/bluetooth/drivers/bt3c/ng_bt3c_pccard.c

446

((ng_bt3c_node_qlen_ep *)(rsp->data))->queue =

sys/netgraph7/bluetooth/drivers/bt3c/ng_bt3c_pccard.c

453

((ng_bt3c_node_qlen_ep *)(rsp->data))->queue =

sys/netgraph7/bluetooth/drivers/bt3c/ng_bt3c_pccard.c

477

switch (((ng_bt3c_node_qlen_ep *)(msg->data))->queue) {

sys/netgraph7/bluetooth/drivers/ubt/ng_ubt.c

1565

int error = 0, queue, qlen;

sys/netgraph7/bluetooth/drivers/ubt/ng_ubt.c

1631

queue = ((ng_ubt_node_qlen_ep *) (msg->data))->queue;

sys/netgraph7/bluetooth/drivers/ubt/ng_ubt.c

1634

switch (queue) {

sys/netgraph7/bluetooth/drivers/ubt/ng_ubt.c

1662

queue = ((ng_ubt_node_qlen_ep *) (msg->data))->queue;

sys/netgraph7/bluetooth/drivers/ubt/ng_ubt.c

1664

switch (queue) {

sys/netgraph7/bluetooth/drivers/ubt/ng_ubt.c

1690

((ng_ubt_node_qlen_ep *) (rsp->data))->queue = queue;

sys/netgraph7/bluetooth/include/ng_bluetooth.h

152

STAILQ_HEAD(, ng_item) queue; /* actually items queue */

sys/netgraph7/bluetooth/include/ng_bluetooth.h

162

STAILQ_INIT(&(q)->queue); \

sys/netgraph7/bluetooth/include/ng_bluetooth.h

173

#define NG_BT_ITEMQ_FIRST(q) STAILQ_FIRST(&(q)->queue)

sys/netgraph7/bluetooth/include/ng_bluetooth.h

183

STAILQ_INSERT_TAIL(&(q)->queue, (i), el_next); \

sys/netgraph7/bluetooth/include/ng_bluetooth.h

189

(i) = STAILQ_FIRST(&(q)->queue); \

sys/netgraph7/bluetooth/include/ng_bluetooth.h

191

STAILQ_REMOVE_HEAD(&(q)->queue, el_next); \

sys/netgraph7/bluetooth/include/ng_bluetooth.h

198

STAILQ_INSERT_HEAD(&(q)->queue, (i), el_next); \

sys/netgraph7/bluetooth/include/ng_bt3c.h

83

int32_t queue; /* queue index */

sys/netgraph7/bluetooth/include/ng_ubt.h

67

int32_t queue; /* queue index */

sys/netgraph7/netgraph.h

1134

int ng_snd_item(item_p item, int queue);

sys/platform/pc64/x86_64/pmap.c

2761

KKASSERT(m->queue == PQ_NONE);

sys/platform/pc64/x86_64/pmap.c

5487

if ((p->queue - p->pc) == PQ_CACHE) {

sys/platform/vkernel64/platform/pmap.c

1041

KASSERT(m->queue == PQ_NONE,

sys/platform/vkernel64/platform/pmap.c

2576

if ((p->queue - p->pc) == PQ_CACHE)

sys/sys/buf.h

356

TAILQ_HEAD(bio_queue, bio) queue;

sys/sys/buf2.h

133

TAILQ_INIT(&bioq->queue);

sys/sys/buf2.h

144

TAILQ_INSERT_TAIL(&bioq->queue, bio, bio_act);

sys/sys/buf2.h

157

TAILQ_REMOVE(&bioq->queue, bio, bio_act);

sys/sys/buf2.h

163

return (TAILQ_FIRST(&bioq->queue));

sys/sys/buf2.h

171

bp = TAILQ_FIRST(&bioq->queue);

sys/sys/gtaskqueue.h

79

void gtaskqueue_block(struct gtaskqueue *queue);

sys/sys/gtaskqueue.h

80

void gtaskqueue_unblock(struct gtaskqueue *queue);

sys/sys/gtaskqueue.h

82

int gtaskqueue_cancel(struct gtaskqueue *queue, struct gtask *gtask);

sys/sys/gtaskqueue.h

83

void gtaskqueue_drain(struct gtaskqueue *queue, struct gtask *task);

sys/sys/gtaskqueue.h

84

void gtaskqueue_drain_all(struct gtaskqueue *queue);

sys/sys/gtaskqueue.h

88

int grouptaskqueue_enqueue(struct gtaskqueue *queue, struct gtask *task);

sys/sys/mpipe.h

101

STAILQ_HEAD(, mpipe_callback) queue;

sys/sys/nata.h

112

/*075*/ u_int16_t queue;

sys/sys/sleepqueue.h

101

const char *wmesg, int flags, int queue);

sys/sys/sleepqueue.h

102

int sleepq_broadcast(const void *wchan, int flags, int pri, int queue);

sys/sys/sleepqueue.h

110

int sleepq_remove_matching(struct sleepqueue *sq, int queue,

sys/sys/sleepqueue.h

114

int sleepq_signal(const void *wchan, int flags, int pri, int queue);

sys/sys/sleepqueue.h

119

u_int sleepq_sleepcnt(const void *wchan, int queue);

sys/sys/systimer.h

58

systimerq_t queue;

sys/sys/taskqueue.h

122

void _timeout_task_init(struct taskqueue *queue,

sys/sys/taskqueue.h

125

#define TIMEOUT_TASK_INIT(queue, timeout_task, priority, func, context) \

sys/sys/taskqueue.h

126

_timeout_task_init(queue, timeout_task, priority, func, context);

sys/sys/taskqueue.h

79

int taskqueue_enqueue(struct taskqueue *queue, struct task *task);

sys/sys/taskqueue.h

80

int taskqueue_enqueue_optq(struct taskqueue *queue,

sys/sys/taskqueue.h

82

int taskqueue_enqueue_timeout(struct taskqueue *queue,

sys/sys/taskqueue.h

84

int taskqueue_cancel(struct taskqueue *queue, struct task *task,

sys/sys/taskqueue.h

87

int taskqueue_cancel_timeout(struct taskqueue *queue,

sys/sys/taskqueue.h

89

void taskqueue_drain(struct taskqueue *queue, struct task *task);

sys/sys/taskqueue.h

91

void taskqueue_drain_timeout(struct taskqueue *queue,

sys/sys/taskqueue.h

94

void taskqueue_free(struct taskqueue *queue);

sys/sys/taskqueue.h

95

void taskqueue_block(struct taskqueue *queue);

sys/sys/taskqueue.h

96

void taskqueue_unblock(struct taskqueue *queue);

sys/vm/device_pager.c

283

m->queue = PQ_NONE;

sys/vm/vm_contig.c

143

vm_contig_pg_clean(int queue, vm_pindex_t count)

sys/vm/vm_contig.c

148

struct vpgqueues *pq = &vm_page_queues[queue];

sys/vm/vm_contig.c

156

marker.queue = queue;

sys/vm/vm_contig.c

159

vm_page_queues_spin_lock(queue);

sys/vm/vm_contig.c

161

vm_page_queues_spin_unlock(queue);

sys/vm/vm_contig.c

176

KKASSERT(m->queue == queue);

sys/vm/vm_contig.c

194

if (m->queue - m->pc != queue) {

sys/vm/vm_contig.c

239

vm_page_queues_spin_lock(queue);

sys/vm/vm_contig.c

241

vm_page_queues_spin_unlock(queue);

sys/vm/vm_contig.c

311

pqtype = m->queue - m->pc;

sys/vm/vm_contig.c

379

pqtype = m->queue - m->pc;

sys/vm/vm_contig.c

407

pqtype = m->queue - m->pc;

sys/vm/vm_fault.c

1047

m->queue - m->pc != PQ_ACTIVE ||

sys/vm/vm_fault.c

1923

int queue = fs->mary[0]->queue;

sys/vm/vm_fault.c

1926

if ((queue - fs->mary[0]->pc) == PQ_CACHE &&

sys/vm/vm_fault.c

3181

if ((m->queue - m->pc) == PQ_CACHE)

sys/vm/vm_fault.c

3332

if ((m->queue - m->pc) != PQ_CACHE) {

sys/vm/vm_fault.c

3374

if ((m->queue - m->pc) == PQ_CACHE)

sys/vm/vm_fault.c

981

m->queue - m->pc != PQ_ACTIVE ||

sys/vm/vm_object.c

1092

if (p->valid == 0 || (p->queue - p->pc) == PQ_CACHE) {

sys/vm/vm_object.c

1180

if ((tp->queue - tp->pc) == PQ_CACHE) {

sys/vm/vm_object.c

1212

if ((tp->queue - tp->pc) == PQ_CACHE) {

sys/vm/vm_object.c

893

"busied page %p on queue %d\n", p, p->queue);

sys/vm/vm_object.c

905

if (p->queue != PQ_NONE) {

sys/vm/vm_object.c

907

"wired page %p on queue %d\n", p, p->queue);

sys/vm/vm_page.c

1024

u_short queue;

sys/vm/vm_page.c

1029

queue = m->queue;

sys/vm/vm_page.c

1030

if (queue != PQ_NONE) {

sys/vm/vm_page.c

1031

pq = &vm_page_queues[queue];

sys/vm/vm_page.c

1068

m->queue = PQ_NONE;

sys/vm/vm_page.c

1069

oqueue = queue;

sys/vm/vm_page.c

1070

queue -= m->pc;

sys/vm/vm_page.c

1073

return queue;

sys/vm/vm_page.c

1087

_vm_page_add_queue_spinlocked(vm_page_t m, u_short queue, int athead)

sys/vm/vm_page.c

1093

KKASSERT(m->queue == PQ_NONE &&

sys/vm/vm_page.c

1096

if (queue != PQ_NONE) {

sys/vm/vm_page.c

1097

vm_page_queues_spin_lock(queue);

sys/vm/vm_page.c

1098

pq = &vm_page_queues[queue];

sys/vm/vm_page.c

1117

m->queue = queue;

sys/vm/vm_page.c

1118

if (queue - m->pc == PQ_FREE) {

sys/vm/vm_page.c

1395

KKASSERT(m->queue - m->pc != PQ_FREE);

sys/vm/vm_page.c

1415

KASSERT(m->hold_count > 0 && m->queue - m->pc != PQ_FREE,

sys/vm/vm_page.c

1418

m, m->hold_count, m->queue - m->pc));

sys/vm/vm_page.c

1421

m->queue - m->pc == PQ_HOLD) {

sys/vm/vm_page.c

1423

if (m->hold_count == 0 && m->queue - m->pc == PQ_HOLD) {

sys/vm/vm_page.c

1449

m->queue = PQ_NONE;

sys/vm/vm_page.c

1932

if (m->queue - m->pc == PQ_CACHE)

sys/vm/vm_page.c

1960

u_short queue;

sys/vm/vm_page.c

1963

queue = _vm_page_rem_queue_spinlocked(m);

sys/vm/vm_page.c

1964

if (queue == PQ_FREE || queue == PQ_CACHE) {

sys/vm/vm_page.c

2027

KKASSERT(m->queue == basequeue + index);

sys/vm/vm_page.c

2095

KKASSERT(m->queue == basequeue + pqi);

sys/vm/vm_page.c

2141

KKASSERT(m->queue == bq1 + index);

sys/vm/vm_page.c

2225

KKASSERT(m->queue == basequeue1 + pqi);

sys/vm/vm_page.c

2261

KKASSERT(m->queue == basequeue2 + pqi);

sys/vm/vm_page.c

2414

m, m->queue, m->flags,

sys/vm/vm_page.c

2441

} else if (m->queue - m->pc == PQ_FREE) {

sys/vm/vm_page.c

2451

m, m->queue, m->flags,

sys/vm/vm_page.c

251

if (m->queue) {

sys/vm/vm_page.c

2693

KKASSERT(m->queue == PQ_NONE);

sys/vm/vm_page.c

291

m->queue = PQ_NONE;

sys/vm/vm_page.c

301

m->queue = m->pc + PQ_FREE;

sys/vm/vm_page.c

3055

if (m->queue - m->pc == PQ_ACTIVE ||

sys/vm/vm_page.c

306

vpq = &vm_page_queues[m->queue];

sys/vm/vm_page.c

3063

if (m->queue - m->pc != PQ_ACTIVE &&

sys/vm/vm_page.c

3087

if (m->queue - m->pc == PQ_ACTIVE ||

sys/vm/vm_page.c

3162

if ((m->busy_count & PBUSY_MASK) || ((m->queue - m->pc) == PQ_FREE)) {

sys/vm/vm_page.c

3166

if ((m->queue - m->pc) == PQ_FREE)

sys/vm/vm_page.c

3185

KKASSERT(m->queue == PQ_NONE);

sys/vm/vm_page.c

3340

if (m->queue - m->pc == PQ_INACTIVE ||

sys/vm/vm_page.c

3374

if (m->queue - m->pc != PQ_INACTIVE &&

sys/vm/vm_page.c

3406

m->queue - m->pc == PQ_CACHE ||

sys/vm/vm_page.c

3420

if (m->queue - m->pc == PQ_ACTIVE)

sys/vm/vm_page.c

3452

m->queue - m->pc == PQ_FREE || /* already on PQ_FREE */

sys/vm/vm_page.c

3453

m->queue - m->pc == PQ_HOLD) { /* already on PQ_HOLD */

sys/vm/vm_page.c

3503

if ((m->queue - m->pc) == PQ_CACHE) {

sys/vm/vm_page.c

3587

m->queue - m->pc == PQ_INACTIVE ||

sys/vm/vm_page.c

3588

m->queue - m->pc == PQ_CACHE

sys/vm/vm_page.c

4082

int pqtype = m->queue - m->pc;

sys/vm/vm_page.c

580

if (m->queue != PQ_NONE) {

sys/vm/vm_page.c

581

vpq = &vm_page_queues[m->queue];

sys/vm/vm_page.c

585

m->queue -= m->pc;

sys/vm/vm_page.c

589

m->queue += m->pc;

sys/vm/vm_page.c

590

vpq = &vm_page_queues[m->queue];

sys/vm/vm_page.c

687

KKASSERT(m->queue == PQ_FREE + iter);

sys/vm/vm_page.c

691

m->queue -= m->pc;

sys/vm/vm_page.c

693

m->queue += m->pc;

sys/vm/vm_page.c

916

u_short queue;

sys/vm/vm_page.c

918

queue = m->queue;

sys/vm/vm_page.c

919

if (queue != PQ_NONE) {

sys/vm/vm_page.c

920

spin_lock(&vm_page_queues[queue].spin);

sys/vm/vm_page.c

921

KKASSERT(queue == m->queue);

sys/vm/vm_page.c

929

u_short queue;

sys/vm/vm_page.c

931

queue = m->queue;

sys/vm/vm_page.c

933

if (queue != PQ_NONE)

sys/vm/vm_page.c

934

spin_unlock(&vm_page_queues[queue].spin);

sys/vm/vm_page.c

939

_vm_page_queues_spin_lock(u_short queue)

sys/vm/vm_page.c

942

if (queue != PQ_NONE)

sys/vm/vm_page.c

943

spin_lock(&vm_page_queues[queue].spin);

sys/vm/vm_page.c

949

_vm_page_queues_spin_unlock(u_short queue)

sys/vm/vm_page.c

952

if (queue != PQ_NONE)

sys/vm/vm_page.c

953

spin_unlock(&vm_page_queues[queue].spin);

sys/vm/vm_page.c

963

vm_page_queues_spin_lock(u_short queue)

sys/vm/vm_page.c

965

_vm_page_queues_spin_lock(queue);

sys/vm/vm_page.c

975

vm_page_queues_spin_unlock(u_short queue)

sys/vm/vm_page.c

977

_vm_page_queues_spin_unlock(queue);

sys/vm/vm_page.c

997

_vm_page_queues_spin_unlock(m->queue);

sys/vm/vm_page.h

193

uint16_t queue; /* page queue index */

sys/vm/vm_pageout.c

1056

if (m->queue - m->pc == PQ_INACTIVE) {

sys/vm/vm_pageout.c

1058

&vm_page_queues[m->queue].pl, m, pageq);

sys/vm/vm_pageout.c

1060

&vm_page_queues[m->queue].pl, m, pageq);

sys/vm/vm_pageout.c

1163

if (m->queue - m->pc == PQ_INACTIVE) {

sys/vm/vm_pageout.c

1165

&vm_page_queues[m->queue].pl, m, pageq);

sys/vm/vm_pageout.c

1167

&vm_page_queues[m->queue].pl, m, pageq);

sys/vm/vm_pageout.c

1206

if (m->queue - m->pc == PQ_INACTIVE) {

sys/vm/vm_pageout.c

1208

&vm_page_queues[m->queue].pl,

sys/vm/vm_pageout.c

1211

&vm_page_queues[m->queue].pl,

sys/vm/vm_pageout.c

1278

if (m->queue - m->pc != PQ_INACTIVE ||

sys/vm/vm_pageout.c

1321

if (m->queue - m->pc == PQ_INACTIVE) {

sys/vm/vm_pageout.c

1322

TAILQ_REMOVE(&vm_page_queues[m->queue].pl, m, pageq);

sys/vm/vm_pageout.c

1323

TAILQ_INSERT_TAIL(&vm_page_queues[m->queue].pl, m, pageq);

sys/vm/vm_pageout.c

1337

if (m->queue - m->pc != PQ_INACTIVE ||

sys/vm/vm_pageout.c

1452

KKASSERT(m->queue == PQ_ACTIVE + q);

sys/vm/vm_pageout.c

1476

KKASSERT(m->queue == PQ_ACTIVE + q);

sys/vm/vm_pageout.c

1486

if (m->queue - m->pc == PQ_ACTIVE) {

sys/vm/vm_pageout.c

1515

if (m->queue - m->pc == PQ_ACTIVE) {

sys/vm/vm_pageout.c

1560

if (m->queue - m->pc == PQ_ACTIVE) {

sys/vm/vm_pageout.c

1624

if (m->queue - m->pc == PQ_ACTIVE) {

sys/vm/vm_pageout.c

1730

m, m->queue - m->pc, m->dirty);

sys/vm/vm_pageout.c

1919

KKASSERT(m->queue == PQ_HOLD + q);

sys/vm/vm_pageout.c

2025

KKASSERT(m->queue == PQ_ACTIVE + q);

sys/vm/vm_pageout.c

2049

KKASSERT(m->queue == PQ_ACTIVE + q);

sys/vm/vm_pageout.c

2092

if (m->queue - m->pc == PQ_ACTIVE) {

sys/vm/vm_pageout.c

2120

if (m->queue - m->pc == PQ_ACTIVE) {

sys/vm/vm_pageout.c

2234

mark->hold.queue = PQ_HOLD + q;

sys/vm/vm_pageout.c

2244

mark->stat.queue = PQ_ACTIVE + q;

sys/vm/vm_pageout.c

2254

mark->pact.queue = PQ_ACTIVE + q;

sys/vm/vm_pageout.c

373

if ((p->queue - p->pc) == PQ_CACHE ||

sys/vm/vm_pageout.c

386

if (p->queue - p->pc != PQ_INACTIVE) {

sys/vm/vm_pageout.c

387

if (p->queue - p->pc != PQ_ACTIVE ||

sys/vm/vm_pageout.c

416

if (((p->queue - p->pc) == PQ_CACHE) ||

sys/vm/vm_pageout.c

429

if (p->queue - p->pc != PQ_INACTIVE) {

sys/vm/vm_pageout.c

430

if (p->queue - p->pc != PQ_ACTIVE ||

sys/vm/vm_pageout.c

625

if (p->queue - p->pc != PQ_ACTIVE) {

sys/vm/vm_pageout.c

627

if (p->queue - p->pc != PQ_ACTIVE) {

sys/vm/vm_pageout.c

667

if (p->queue - p->pc == PQ_ACTIVE) {

sys/vm/vm_pageout.c

670

if (p->queue - p->pc == PQ_INACTIVE) {

sys/vm/vm_pageout.c

855

marker.queue = PQ_INACTIVE + q;

sys/vm/vm_pageout.c

885

KKASSERT(m->queue == PQ_INACTIVE + q);

sys/vm/vm_pageout.c

910

KKASSERT(m->queue == PQ_INACTIVE + q);

sys/vm/vm_swap.c

467

marker.queue = PQ_ACTIVE + q;

sys/vm/vm_swap.c

471

vm_page_queues_spin_lock(marker.queue);

sys/vm/vm_swap.c

472

TAILQ_INSERT_HEAD(&vm_page_queues[marker.queue].pl,

sys/vm/vm_swap.c

476

TAILQ_REMOVE(&vm_page_queues[marker.queue].pl,

sys/vm/vm_swap.c

478

TAILQ_INSERT_AFTER(&vm_page_queues[marker.queue].pl, m,

sys/vm/vm_swap.c

484

vm_page_queues_spin_unlock(marker.queue);

sys/vm/vm_swap.c

491

vm_page_queues_spin_lock(marker.queue);

sys/vm/vm_swap.c

494

TAILQ_REMOVE(&vm_page_queues[marker.queue].pl, &marker, pageq);

sys/vm/vm_swap.c

495

vm_page_queues_spin_unlock(marker.queue);

sys/vm/vm_swap.c

497

marker.queue = PQ_INACTIVE + q;

sys/vm/vm_swap.c

499

vm_page_queues_spin_lock(marker.queue);

sys/vm/vm_swap.c

500

TAILQ_INSERT_HEAD(&vm_page_queues[marker.queue].pl,

sys/vm/vm_swap.c

505

&vm_page_queues[marker.queue].pl,

sys/vm/vm_swap.c

508

&vm_page_queues[marker.queue].pl,

sys/vm/vm_swap.c

514

vm_page_queues_spin_unlock(marker.queue);

sys/vm/vm_swap.c

521

vm_page_queues_spin_lock(marker.queue);

sys/vm/vm_swap.c

524

TAILQ_REMOVE(&vm_page_queues[marker.queue].pl,

sys/vm/vm_swap.c

526

vm_page_queues_spin_unlock(marker.queue);

sys/vm/vm_swapcache.c

202

page_marker[q].queue = PQ_INACTIVE + q;

sys/vm/vm_swapcache.c

397

vm_page_queues_spin_lock(marker->queue);

sys/vm/vm_swapcache.c

400

KKASSERT(m->queue == marker->queue);

sys/vm/vm_swapcache.c

415

&vm_page_queues[marker->queue].pl, marker, pageq);

sys/vm/vm_swapcache.c

417

&vm_page_queues[marker->queue].pl, m, marker, pageq);

sys/vm/vm_swapcache.c

427

vm_page_queues_spin_unlock(marker->queue);

sys/vm/vm_swapcache.c

431

vm_page_queues_spin_lock(marker->queue);

sys/vm/vm_swapcache.c

438

vm_page_queues_spin_lock(marker->queue);

sys/vm/vm_swapcache.c

444

vm_page_queues_spin_lock(marker->queue);

sys/vm/vm_swapcache.c

452

vm_page_queues_spin_lock(marker->queue);

sys/vm/vm_swapcache.c

467

vm_page_queues_spin_lock(marker->queue);

sys/vm/vm_swapcache.c

481

vm_page_queues_spin_lock(marker->queue);

sys/vm/vm_swapcache.c

489

vm_page_queues_spin_lock(marker->queue);

sys/vm/vm_swapcache.c

504

vm_page_queues_spin_lock(marker->queue);

sys/vm/vm_swapcache.c

510

vm_page_queues_spin_lock(marker->queue);

sys/vm/vm_swapcache.c

518

vm_page_queues_spin_lock(marker->queue);

sys/vm/vm_swapcache.c

534

vm_page_queues_spin_lock(marker->queue);

sys/vm/vm_swapcache.c

546

vm_page_queues_spin_unlock(marker->queue);

sys/vm/vm_swapcache.c

614

if (m->queue - m->pc == PQ_CACHE) {

sys/vm/vm_swapcache.c

638

if (m->queue - m->pc == PQ_CACHE) {

sys/vm/vm_zone.c

657

KKASSERT(m->queue == PQ_NONE);

test/debug/bufqueues.c

179

static const char *q2s(int queue)

test/debug/bufqueues.c

181

switch(queue) {

test/debug/bufqueues.c

96

static const char *q2s(int queue);

test/debug/vmpagehash.c

177

if (m.queue >= PQ_HOLD) {

test/debug/vmpagehash.c

179

} else if (m.queue >= PQ_CACHE) {

test/debug/vmpagehash.c

181

} else if (m.queue >= PQ_ACTIVE) {

test/debug/vmpagehash.c

183

} else if (m.queue >= PQ_INACTIVE) {

test/debug/vmpagehash.c

185

} else if (m.queue >= PQ_FREE) {

test/debug/vmpageinfo.c

198

if (m.queue >= PQ_HOLD) {

test/debug/vmpageinfo.c

200

} else if (m.queue >= PQ_CACHE) {

test/debug/vmpageinfo.c

202

} else if (m.queue >= PQ_ACTIVE) {

test/debug/vmpageinfo.c

204

} else if (m.queue >= PQ_INACTIVE) {

test/debug/vmpageinfo.c

206

} else if (m.queue >= PQ_FREE) {

test/debug/vmpageinfo.c

322

if (m.queue == PQ_NONE)

test/debug/vmpageinfo.c

324

else if (m.queue - m.pc != PQ_FREE)

test/debug/vmpqinactive.c

208

if (m.queue >= PQ_HOLD) {

test/debug/vmpqinactive.c

210

} else if (m.queue >= PQ_CACHE) {

test/debug/vmpqinactive.c

212

} else if (m.queue >= PQ_ACTIVE) {

test/debug/vmpqinactive.c

214

} else if (m.queue >= PQ_INACTIVE) {

test/debug/vmpqinactive.c

229

} else if (m.queue >= PQ_FREE) {

test/debug/vmpqinactive.c

341

if (m.queue == PQ_NONE)

test/debug/vmpqinactive.c

343

else if (m.queue - m.pc != PQ_FREE)

tools/tools/net80211/w00t/expand/expand.c

116

struct queue *q = p->q;

tools/tools/net80211/w00t/expand/expand.c

119

struct queue *last = NULL;

tools/tools/net80211/w00t/expand/expand.c

137

q = (struct queue*) malloc(sizeof(*q));

tools/tools/net80211/w00t/expand/expand.c

183

struct queue *q = p->q;

tools/tools/net80211/w00t/expand/expand.c

306

struct queue *q = p->q;

tools/tools/net80211/w00t/expand/expand.c

57

struct queue *next;

tools/tools/net80211/w00t/expand/expand.c

75

struct queue *q;

tools/tools/net80211/w00t/redir/redir.c

157

struct queue *q = p->q;

tools/tools/net80211/w00t/redir/redir.c

160

struct queue *last = NULL;

tools/tools/net80211/w00t/redir/redir.c

178

q = (struct queue*) malloc(sizeof(*q));

tools/tools/net80211/w00t/redir/redir.c

255

void send_header(struct params *p, struct queue *q)

tools/tools/net80211/w00t/redir/redir.c

323

struct queue *q = p->q;

tools/tools/net80211/w00t/redir/redir.c

336

struct queue *q = p->q;

tools/tools/net80211/w00t/redir/redir.c

479

struct queue *q = p->q;

tools/tools/net80211/w00t/redir/redir.c

480

struct queue *last = p->q;

tools/tools/net80211/w00t/redir/redir.c

59

struct queue *next;

tools/tools/net80211/w00t/redir/redir.c

84

struct queue *q;

usr.bin/at/at.c

112

static void writefile(time_t runtimer, char queue);

usr.bin/at/at.c

208

writefile(time_t runtimer, char queue)

usr.bin/at/at.c

265

snprintf(ppos, sizeof(atfile) - strlen(atfile), "%c%5lx%8lx", queue,

usr.bin/at/at.c

471

char queue;

usr.bin/at/at.c

501

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

usr.bin/at/at.c

508

if (atqueue && (queue != atqueue))

usr.bin/at/at.c

525

queue,

usr.bin/at/at.c

545

char queue;

usr.bin/at/at.c

567

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

usr.bin/at/at.c

737

char queue = DEFAULT_AT_QUEUE;

usr.bin/at/at.c

797

atqueue = queue = *optarg;

usr.bin/at/at.c

798

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

usr.bin/at/at.c

889

writefile(timer, queue);

usr.bin/at/at.c

894

queue = toupper(queue);

usr.bin/at/at.c

896

queue = DEFAULT_BATCH_QUEUE;

usr.bin/at/at.c

909

writefile(timer, queue);

usr.sbin/lpr/common_source/common.c

104

struct jobqueue *q, **queue;

usr.sbin/lpr/common_source/common.c

127

queue = (struct jobqueue **)malloc(arraysz * sizeof(struct jobqueue *));

usr.sbin/lpr/common_source/common.c

128

if (queue == NULL)

usr.sbin/lpr/common_source/common.c

155

queue = (struct jobqueue **)realloc((char *)queue,

usr.sbin/lpr/common_source/common.c

157

if (queue == NULL)

usr.sbin/lpr/common_source/common.c

160

queue[nitems-1] = q;

usr.sbin/lpr/common_source/common.c

164

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

usr.sbin/lpr/common_source/common.c

165

*namelist = queue;

usr.sbin/lpr/common_source/displayq.c

114

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

usr.sbin/lpr/common_source/displayq.c

201

q = queue[i];

usr.sbin/lpr/common_source/displayq.c

205

free(queue);

usr.sbin/lpr/common_source/displayq.c

91

struct jobqueue **queue;

usr.sbin/lpr/lpc/cmds.c

1106

struct jobqueue **queue;

usr.sbin/lpr/lpc/cmds.c

1150

nitems = getq(pp, &queue);

usr.sbin/lpr/lpc/cmds.c

1154

mtime = queue[0]->job_time;

usr.sbin/lpr/lpc/cmds.c

1163

free(queue[i]);

usr.sbin/lpr/lpc/cmds.c

1164

free(queue);

usr.sbin/lpr/lpc/cmds.c

1231

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

usr.sbin/lpr/lpc/cmds.c

1251

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

usr.sbin/lpr/lpc/cmds.c

645

struct dirent **queue;

usr.sbin/lpr/lpc/cmds.c

668

nitems = scandir(pp->spool_dir, &queue, doselect, sortq);

usr.sbin/lpr/lpc/cmds.c

693

cp = queue[i]->d_name;

usr.sbin/lpr/lpc/cmds.c

700

cp = queue[i]->d_name;

usr.sbin/lpr/lpc/cmds.c

715

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

usr.sbin/lpr/lpc/movejobs.c

210

nitems = getq(pp, &queue);

usr.sbin/lpr/lpc/movejobs.c

228

touch_info.newtime = queue[nitems - 1]->job_time + 1;

usr.sbin/lpr/lpc/movejobs.c

237

touch_info.newtime = queue[0]->job_time - nitems - 5;

usr.sbin/lpr/lpc/movejobs.c

262

free(queue[i]);

usr.sbin/lpr/lpc/movejobs.c

263

free(queue);

usr.sbin/lpr/lpc/movejobs.c

77

static struct jobqueue **queue;

usr.sbin/lpr/lpc/movejobs.c

94

matchcnt = scanq_jobspec(nitems, queue, SCQ_JSORDER, &jobs_wanted,

usr.sbin/lpr/lpd/printjob.c

143

struct jobqueue **queue;

usr.sbin/lpr/lpd/printjob.c

213

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

usr.sbin/lpr/lpd/printjob.c

247

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

usr.sbin/lpr/lpd/printjob.c

319

free(queue);

usr.sbin/lpr/lpd/printjob.c

323

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

usr.sbin/nscd/nscd.c

200

retval->queue = kqueue();

usr.sbin/nscd/nscd.c

201

assert(retval->queue != -1);

usr.sbin/nscd/nscd.c

206

kevent(retval->queue, &eventlist, 1, NULL, 0, &timeout);

usr.sbin/nscd/nscd.c

217

close(env->queue);

usr.sbin/nscd/nscd.c

265

res = kevent(env->queue, eventlist, 2, NULL, 0, &timeout);

usr.sbin/nscd/nscd.c

291

nevents = kevent(env->queue, eventlist, 1, NULL, 0, &kevent_timeout);

usr.sbin/nscd/nscd.c

451

kevent(env->queue, eventlist, 2, NULL, 0, &kevent_timeout);

usr.sbin/nscd/nscd.c

491

nevents = kevent(env->queue, NULL, 0, eventlist,

usr.sbin/nscd/nscd.c

509

kevent(s_runtime_env->queue, eventlist,

usr.sbin/nscd/singletons.h

37

int queue;

usr.sbin/pfctl/parse.y

1883

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

usr.sbin/pfctl/parse.y

1884

sizeof($$->queue)) {

usr.sbin/pfctl/parse.y

1886

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

usr.sbin/pfctl/parse.y

196

char queue[PF_QNAME_SIZE];

usr.sbin/pfctl/parse.y

411

struct node_queue *queue;

usr.sbin/pfctl/parse.y

4837

LOOP_THROUGH(struct node_queue, queue,

usr.sbin/pfctl/parse.y

4840

queue->queue);

usr.sbin/pfctl/parse.y

4874

LOOP_THROUGH(struct node_queue, queue, nqueues,

usr.sbin/pfctl/parse.y

4885

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

usr.sbin/pfctl/parse.y

4886

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

usr.sbin/pfctl/parse.y

4932

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

usr.sbin/pfctl/parse.y

494

%type <v.queue> qassign qassign_list qassign_item

usr.sbin/pfctl/parse.y

4984

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

usr.sbin/pfctl/parse.y

4998

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

usr.sbin/pfctl/parse.y

4999

sizeof(n->queue)) >=

usr.sbin/pfctl/parse.y

5000

sizeof(n->queue))

usr.sbin/pfctl/parse.y

5025

queue, nqueues,

usr.sbin/pfctl/parse.y

5027

queue->queue);

usr.sbin/pfctl/pfctl_optimize.c

813

TAILQ_HEAD( , pf_opt_rule) queue;

usr.sbin/pfctl/pfctl_optimize.c

847

TAILQ_INIT(&queue);

usr.sbin/pfctl/pfctl_optimize.c

850

TAILQ_INSERT_TAIL(&queue, por1, por_entry);

usr.sbin/pfctl/pfctl_optimize.c

853

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

usr.sbin/pfctl/pfctl_optimize.c

854

TAILQ_REMOVE(&queue, por1, por_entry);

usr.sbin/pfctl/pfctl_optimize.c

880

struct pf_opt_queue queue;

usr.sbin/pfctl/pfctl_optimize.c

885

TAILQ_INIT(&queue);

usr.sbin/pfctl/pfctl_optimize.c

914

TAILQ_INSERT_TAIL(&queue, por, por_entry);

usr.sbin/pfctl/pfctl_optimize.c

922

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

usr.sbin/ppp/ipcp.c

1431

struct mqueue *queue;

usr.sbin/ppp/ipcp.c

1448

queue = ipcp->Queue + IPCP_QUEUES(ipcp) - 1;

usr.sbin/ppp/ipcp.c

1450

if (queue->top) {

usr.sbin/ppp/ipcp.c

1451

bp = m_dequeue(queue);

usr.sbin/ppp/ipcp.c

1465

} while (queue-- != ipcp->Queue);

usr.sbin/ppp/ipv6cp.c

423

struct mqueue *queue;

usr.sbin/ppp/ipv6cp.c

440

queue = ipv6cp->Queue + IPV6CP_QUEUES(ipv6cp) - 1;

usr.sbin/ppp/ipv6cp.c

442

if (queue->top) {

usr.sbin/ppp/ipv6cp.c

443

bp = m_dequeue(queue);

usr.sbin/ppp/ipv6cp.c

457

} while (queue-- != ipv6cp->Queue);

usr.sbin/ppp/link.c

104

for (queue = l->Queue; queue < highest; queue++)

usr.sbin/ppp/link.c

105

while (queue->len)

usr.sbin/ppp/link.c

106

m_enqueue(highest, m_dequeue(queue));

usr.sbin/ppp/link.c

112

struct mqueue *queue, *highest;

usr.sbin/ppp/link.c

115

for (queue = l->Queue; queue <= highest; queue++)

usr.sbin/ppp/link.c

116

while (queue->top)

usr.sbin/ppp/link.c

117

m_freem(m_dequeue(queue));

usr.sbin/ppp/link.c

99

struct mqueue *queue, *highest;

usr.sbin/ppp/mbuf.c

366

m_enqueue(struct mqueue *queue, struct mbuf *bp)

usr.sbin/ppp/mbuf.c

369

if (queue->last) {

usr.sbin/ppp/mbuf.c

370

queue->last->m_nextpkt = bp;

usr.sbin/ppp/mbuf.c

371

queue->last = bp;

usr.sbin/ppp/mbuf.c

373

queue->last = queue->top = bp;

usr.sbin/ppp/mbuf.c

374

queue->len++;

usr.sbin/ppp/mbuf.c

375

log_Printf(LogDEBUG, "m_enqueue: len = %lu\n", (unsigned long)queue->len);

usr.sbin/ppp/mbuf.c

71

struct mbuf *queue;