mirror of
https://github.com/freebsd/freebsd-src.git
synced 2024-12-04 10:19:26 +00:00
45d426a34e
mips32r2 and mips64r2 (and close relatives) processors. There presently is support for ADMtek ADM5120, A mips 4Kc in a malta board, the RB533 routerboard (based on IDT RC32434) and some preliminary support for sibtye/broadcom designs. Other hardware support will be forthcomcing. This port boots multiuser under gxemul emulating the malta board and also bootstraps on the hardware whose support is forthcoming... Oleksandr Tymoshenko, Wojciech Koszek, Warner Losh, Olivier Houchard, Randall Stewert and others that have contributed to the mips2 and/or mips2-jnpr perforce branches. Juniper contirbuted a generic mips port late in the life cycle of the misp2 branch. Warner Losh merged the mips2 and Juniper code bases, and others list above have worked for the past several months to get to multiuser. In addition, the mips2 work owe a debt to the trail blazing efforts of the original mips branch in perforce done by Juli Mallett.
172 lines
4.2 KiB
C
172 lines
4.2 KiB
C
/*-
|
|
* Copyright (c) 1996-1997, 2001, 2005, Juniper Networks, Inc.
|
|
* All rights reserved.
|
|
* Jim Hayes, November 1996
|
|
*
|
|
* queue.h - Description of uKernel queues, for the Juniper Kernel
|
|
*
|
|
* JNPR: queue.h,v 1.1 2006/08/07 05:38:57 katta
|
|
* $FreeBSD$
|
|
*
|
|
*/
|
|
|
|
#ifndef __QUEUE_H__
|
|
#define __QUEUE_H__
|
|
|
|
/*---------------------------------------------------------------------------
|
|
* QUEUE MANAGEMENT DOCUMENTATION
|
|
*/
|
|
|
|
/*
|
|
--------
|
|
Q_INIT()
|
|
--------
|
|
|
|
void q_init(void)
|
|
|
|
Initialize the queue management system for the microkernel.
|
|
This initializes the debugging flags and sets up accounting.
|
|
|
|
---------
|
|
Q_ALLOC()
|
|
---------
|
|
|
|
queue_t *q_alloc()
|
|
|
|
Allocates a queue from kernel memory, and initializes it for you.
|
|
|
|
The default initialization provides a queue that is unbounded.
|
|
|
|
If you want to be bounded with special features, use q_control
|
|
after initialization.
|
|
|
|
q_alloc() returns NULL in the face of peril or low memory.
|
|
|
|
--------
|
|
Q_FREE()
|
|
--------
|
|
|
|
void *q_free(queue_t *queue_pointer)
|
|
|
|
Returns a queue to kernel memory, and frees the queue contents
|
|
for you using free() and complains (with a traceback) that you
|
|
tried to kill of a non-empty queue.
|
|
|
|
If any threads are waiting on the queue, wake them up.
|
|
|
|
-----------
|
|
Q_CONTROL()
|
|
-----------
|
|
void q_control(queue_t *queue_pointer, queue_size_t max_queue_size);
|
|
|
|
For now, allows you to limit queue growth.
|
|
|
|
----------------
|
|
Q_DEQUEUE_WAIT() ** MAY CAUSE THREAD TO BLOCK/CANNOT BE CALLED FROM ISRs **
|
|
----------------
|
|
|
|
void *q_dequeue_wait(queue_t *queue_pointer, wakeup_mask_t *mask)
|
|
|
|
Removes and returns a pointer to the next message in the specified
|
|
queue. If the queue is empty, the calling thread goes to sleep
|
|
until something is queued to the queue. If this call returns NULL,
|
|
then an extraordinary event requires this thread's attention--
|
|
check errno in this case.
|
|
|
|
---------
|
|
Q_DEQUEUE ** CAN BE CALLED FROM ISRs **
|
|
---------
|
|
|
|
void *q_dequeue(queue_t *queue_pointer)
|
|
|
|
Just like q_dequeue_wait(), but instead of blocking, return NULL.
|
|
|
|
-----------
|
|
Q_ENQUEUE() ** CAN BE CALLED FROM ISRs **
|
|
-----------
|
|
|
|
boolean q_enqueue(queue_t *queue_pointer, void *element_pointer)
|
|
|
|
Add the element to the end of the named queue. If the add fails
|
|
because a limit has been reached, return TRUE. Otherwise return
|
|
FALSE if everything went OK.
|
|
|
|
----------
|
|
Q_URGENT()
|
|
----------
|
|
|
|
boolean q_urgent(queue_t *queue_pointer, void *element_pointer)
|
|
|
|
Same as q_enqueue(), except this element will be placed at the top
|
|
of the queue, and will be picked off at the next q_dequeue_wait()
|
|
operation.
|
|
|
|
--------
|
|
Q_PEEK() ** CAN BE CALLED FROM ISRs **
|
|
--------
|
|
|
|
void *q_peek(queue_t *queue_pointer)
|
|
|
|
Returns a pointer to the top element of the queue without actually
|
|
dequeuing it. Returns NULL of the queue is empty.
|
|
|
|
This routine will never block.
|
|
|
|
----------
|
|
Q_DELETE()
|
|
----------
|
|
|
|
void q_delete(queue_t *queue_pointer, void *element_pointer)
|
|
|
|
Delete the element_pointer from the queue, if it exists. This
|
|
isn't speedy, and isn't meant for tasks requiring performance.
|
|
It's primary use is to pull something off the queue when you know
|
|
in the common case that it's gonna be at or near the top of the
|
|
list. (I.e. waking a thread from a wake list when extraordinary
|
|
conditions exist, and you have to pluck it from the middle of the
|
|
list.)
|
|
|
|
This routine does not block or return anything.
|
|
|
|
--------
|
|
Q_SIZE()
|
|
--------
|
|
|
|
queue_size_t q_size(queue_t *queue_pointer)
|
|
|
|
Returns the number of elements in the queue.
|
|
|
|
------------
|
|
Q_MAX_SIZE()
|
|
------------
|
|
|
|
queue_size_t q_max_size(queue_t *queue_pointer);
|
|
|
|
Returns the maximum size of this queue, or 0 if this queue is
|
|
unbounded.
|
|
|
|
*/
|
|
|
|
/*-------------------------------------------------------------------------
|
|
* Basic queue management structures.
|
|
*/
|
|
|
|
/*
|
|
* Typedefs
|
|
*/
|
|
|
|
typedef u_int32_t queue_size_t;
|
|
|
|
/*
|
|
* Prototypes
|
|
*/
|
|
|
|
void q_init(void);
|
|
queue_t *q_alloc(void);
|
|
void *q_peek(queue_t *queue);
|
|
void *q_dequeue(queue_t *queue);
|
|
boolean q_enqueue(queue_t *queue, void *item);
|
|
boolean q_urgent(queue_t *queue, void *item);
|
|
|
|
#endif /* __QUEUE_H__ */
|