FreeBSD/Linux Kernel Cross Reference
sys/mips/include/queue.h

     /*-
      * 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: releng/8.1/sys/mips/include/queue.h 178172 2008-04-13 07:27:37Z imp $
     *
     */
    
    #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__ */

Cache object: 0ff1ff9a319f696f1adb81adc9291540