| Current Path : /sys/amd64/compile/hs32/modules/usr/src/sys/modules/ata/atapci/chipsets/atacyrix/@/dev/vxge/vxgehal/ |
FreeBSD hs32.drive.ne.jp 9.1-RELEASE FreeBSD 9.1-RELEASE #1: Wed Jan 14 12:18:08 JST 2015 root@hs32.drive.ne.jp:/sys/amd64/compile/hs32 amd64 |
| Current File : //sys/amd64/compile/hs32/modules/usr/src/sys/modules/ata/atapci/chipsets/atacyrix/@/dev/vxge/vxgehal/vxge-queue.c |
/*-
* Copyright(c) 2002-2011 Exar Corp.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification are permitted provided the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the Exar Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*$FreeBSD: release/9.1.0/sys/dev/vxge/vxgehal/vxge-queue.c 221167 2011-04-28 14:33:15Z gnn $*/
#include <dev/vxge/vxgehal/vxgehal.h>
/*
* vxge_queue_item_data - Get item's data.
* @item: Queue item.
*
* Returns: item data(variable size). Note that vxge_queue_t
* contains items comprized of a fixed vxge_queue_item_t "header"
* and a variable size data. This function returns the variable
* user-defined portion of the queue item.
*/
void *
vxge_queue_item_data(vxge_queue_item_t *item)
{
return (char *) item + sizeof(vxge_queue_item_t);
}
/*
* __queue_consume - (Lockless) dequeue an item from the specified queue.
*
* @queue: Event queue.
* @data_max_size: Maximum size of the data
* @item: Queue item
* See vxge_queue_consume().
*/
static vxge_queue_status_e
__queue_consume(vxge_queue_t *queue,
u32 data_max_size,
vxge_queue_item_t *item)
{
int real_size;
vxge_queue_item_t *elem;
__hal_device_t *hldev;
vxge_assert(queue != NULL);
hldev = (__hal_device_t *) queue->hldev;
vxge_hal_trace_log_queue("==> %s:%s:%d",
__FILE__, __func__, __LINE__);
vxge_hal_trace_log_queue(
"queue = 0x"VXGE_OS_STXFMT", size = %d, item = 0x"VXGE_OS_STXFMT,
(ptr_t) queue, data_max_size, (ptr_t) item);
if (vxge_list_is_empty(&queue->list_head)) {
vxge_hal_trace_log_queue("<== %s:%s:%d Result = %d",
__FILE__, __func__, __LINE__, VXGE_QUEUE_IS_EMPTY);
return (VXGE_QUEUE_IS_EMPTY);
}
elem = (vxge_queue_item_t *) queue->list_head.next;
if (elem->data_size > data_max_size) {
vxge_hal_trace_log_queue("<== %s:%s:%d Result = %d",
__FILE__, __func__, __LINE__, VXGE_QUEUE_NOT_ENOUGH_SPACE);
return (VXGE_QUEUE_NOT_ENOUGH_SPACE);
}
vxge_list_remove(&elem->item);
real_size = elem->data_size + sizeof(vxge_queue_item_t);
if (queue->head_ptr == elem) {
queue->head_ptr = (char *) queue->head_ptr + real_size;
vxge_hal_info_log_queue("event_type: %d \
removing from the head: "
"0x"VXGE_OS_STXFMT":0x"VXGE_OS_STXFMT":0x"VXGE_OS_STXFMT
":0x0x"VXGE_OS_STXFMT" elem 0x0x"VXGE_OS_STXFMT" length %d",
elem->event_type, (ptr_t) queue->start_ptr,
(ptr_t) queue->head_ptr, (ptr_t) queue->tail_ptr,
(ptr_t) queue->end_ptr, (ptr_t) elem, real_size);
} else if ((char *) queue->tail_ptr - real_size == (char *) elem) {
queue->tail_ptr = (char *) queue->tail_ptr - real_size;
vxge_hal_info_log_queue("event_type: %d \
removing from the tail: "
"0x"VXGE_OS_STXFMT":0x"VXGE_OS_STXFMT":0x"VXGE_OS_STXFMT
":0x"VXGE_OS_STXFMT" elem 0x"VXGE_OS_STXFMT" length %d",
elem->event_type, (ptr_t) queue->start_ptr,
(ptr_t) queue->head_ptr, (ptr_t) queue->tail_ptr,
(ptr_t) queue->end_ptr, (ptr_t) elem, real_size);
} else {
vxge_hal_info_log_queue("event_type: %d \
removing from the list: "
"0x"VXGE_OS_STXFMT":0x"VXGE_OS_STXFMT":0x"VXGE_OS_STXFMT
":0x"VXGE_OS_STXFMT" elem 0x"VXGE_OS_STXFMT" length %d",
elem->event_type, (ptr_t) queue->start_ptr,
(ptr_t) queue->head_ptr, (ptr_t) queue->tail_ptr,
(ptr_t) queue->end_ptr, (ptr_t) elem, real_size);
}
vxge_assert(queue->tail_ptr >= queue->head_ptr);
vxge_assert(queue->tail_ptr >= queue->start_ptr &&
queue->tail_ptr <= queue->end_ptr);
vxge_assert(queue->head_ptr >= queue->start_ptr &&
queue->head_ptr < queue->end_ptr);
vxge_os_memcpy(item, elem, sizeof(vxge_queue_item_t));
vxge_os_memcpy(vxge_queue_item_data(item), vxge_queue_item_data(elem),
elem->data_size);
if (vxge_list_is_empty(&queue->list_head)) {
/* reset buffer pointers just to be clean */
queue->head_ptr = queue->tail_ptr = queue->start_ptr;
}
vxge_hal_trace_log_queue("<== %s:%s:%d Result = 0",
__FILE__, __func__, __LINE__);
return (VXGE_QUEUE_OK);
}
/*
* vxge_queue_produce - Enqueue an item (see vxge_queue_item_t {})
* into the specified queue.
* @queueh: Queue handle.
* @event_type: Event type. One of the enumerated event types
* that both consumer and producer "understand".
* For an example, please refer to vxge_hal_event_e.
* @context: Opaque (void *) "context", for instance event producer object.
* @is_critical: For critical event, e.g. ECC.
* @data_size: Size of the @data.
* @data: User data of variable @data_size that is _copied_ into
* the new queue item (see vxge_queue_item_t {}). Upon return
* from the call the @data memory can be re-used or released.
*
* Enqueue a new item.
*
* Returns: VXGE_QUEUE_OK - success.
* VXGE_QUEUE_IS_FULL - Queue is full.
* VXGE_QUEUE_OUT_OF_MEMORY - Memory allocation failed.
*
* See also: vxge_queue_item_t {}, vxge_queue_consume().
*/
vxge_queue_status_e
vxge_queue_produce(vxge_queue_h queueh,
u32 event_type,
void *context,
u32 is_critical,
const u32 data_size,
void *data)
{
vxge_queue_t *queue = (vxge_queue_t *) queueh;
int real_size = data_size + sizeof(vxge_queue_item_t);
__hal_device_t *hldev;
vxge_queue_item_t *elem;
unsigned long flags = 0;
vxge_assert(queueh != NULL);
hldev = (__hal_device_t *) queue->hldev;
vxge_hal_trace_log_queue("==> %s:%s:%d",
__FILE__, __func__, __LINE__);
vxge_hal_trace_log_queue(
"queueh = 0x"VXGE_OS_STXFMT", event_type = %d, "
"context = 0x"VXGE_OS_STXFMT", is_critical = %d, "
"data_size = %d, data = 0x"VXGE_OS_STXFMT,
(ptr_t) queueh, event_type, (ptr_t) context,
is_critical, data_size, (ptr_t) data);
vxge_assert(real_size <= VXGE_QUEUE_BUF_SIZE);
vxge_os_spin_lock_irq(&queue->lock, flags);
if (is_critical && !queue->has_critical_event) {
unsigned char item_buf[sizeof(vxge_queue_item_t) +
VXGE_DEFAULT_EVENT_MAX_DATA_SIZE];
vxge_queue_item_t *item =
(vxge_queue_item_t *) (void *)item_buf;
while (__queue_consume(queue, VXGE_DEFAULT_EVENT_MAX_DATA_SIZE,
item) != VXGE_QUEUE_IS_EMPTY) {
} /* do nothing */
}
try_again:
if ((char *) queue->tail_ptr + real_size <= (char *) queue->end_ptr) {
elem = (vxge_queue_item_t *) queue->tail_ptr;
queue->tail_ptr = (void *)((char *) queue->tail_ptr + real_size);
vxge_hal_info_log_queue("event_type: %d adding to the tail: "
"0x"VXGE_OS_STXFMT":0x"VXGE_OS_STXFMT":0x"VXGE_OS_STXFMT
":0x"VXGE_OS_STXFMT" elem 0x"VXGE_OS_STXFMT" length %d",
event_type, (ptr_t) queue->start_ptr,
(ptr_t) queue->head_ptr, (ptr_t) queue->tail_ptr,
(ptr_t) queue->end_ptr, (ptr_t) elem, real_size);
} else if ((char *) queue->head_ptr - real_size >=
(char *) queue->start_ptr) {
elem = (vxge_queue_item_t *)
((void *)((char *) queue->head_ptr - real_size));
queue->head_ptr = elem;
vxge_hal_info_log_queue("event_type: %d adding to the head: "
"0x"VXGE_OS_STXFMT":0x"VXGE_OS_STXFMT":"
"0x"VXGE_OS_STXFMT":0x"VXGE_OS_STXFMT" length %d",
event_type, (ptr_t) queue->start_ptr,
(ptr_t) queue->head_ptr, (ptr_t) queue->tail_ptr,
(ptr_t) queue->end_ptr, real_size);
} else {
vxge_queue_status_e status;
if (queue->pages_current >= queue->pages_max) {
vxge_os_spin_unlock_irq(&queue->lock, flags);
vxge_hal_trace_log_queue("<== %s:%s:%d Result = %d",
__FILE__, __func__, __LINE__, VXGE_QUEUE_IS_FULL);
return (VXGE_QUEUE_IS_FULL);
}
if (queue->has_critical_event) {
vxge_os_spin_unlock_irq(&queue->lock, flags);
vxge_hal_trace_log_queue("<== %s:%s:%d Result = %d",
__FILE__, __func__, __LINE__, VXGE_QUEUE_IS_FULL);
return (VXGE_QUEUE_IS_FULL);
}
/* grow */
status = vxge_io_queue_grow(queueh);
if (status != VXGE_QUEUE_OK) {
vxge_os_spin_unlock_irq(&queue->lock, flags);
vxge_hal_trace_log_queue("<== %s:%s:%d Result = %d",
__FILE__, __func__, __LINE__, status);
return (status);
}
goto try_again;
}
vxge_assert(queue->tail_ptr >= queue->head_ptr);
vxge_assert(queue->tail_ptr >= queue->start_ptr &&
queue->tail_ptr <= queue->end_ptr);
vxge_assert(queue->head_ptr >= queue->start_ptr &&
queue->head_ptr < queue->end_ptr);
elem->data_size = data_size;
elem->event_type = (vxge_hal_event_e) event_type;
elem->is_critical = is_critical;
if (is_critical)
queue->has_critical_event = 1;
elem->context = context;
vxge_os_memcpy(vxge_queue_item_data(elem), data, data_size);
vxge_list_insert_before(&elem->item, &queue->list_head);
vxge_os_spin_unlock_irq(&queue->lock, flags);
/* no lock taken! */
queue->queued_func(queue->queued_data, event_type);
vxge_hal_trace_log_queue("<== %s:%s:%d Result = 0",
__FILE__, __func__, __LINE__);
return (VXGE_QUEUE_OK);
}
/*
* vxge_queue_create - Create protected first-in-first-out queue.
* @devh: HAL device handle.
* @pages_initial: Number of pages to be initially allocated at the
* time of queue creation.
* @pages_max: Max number of pages that can be allocated in the queue.
* @queued_func: Optional callback function to be called each time a new item is
* added to the queue.
* @queued_data: Argument to the callback function.
*
* Create protected (fifo) queue.
*
* Returns: Pointer to vxge_queue_t structure,
* NULL - on failure.
*
* See also: vxge_queue_item_t {}, vxge_queue_destroy().
*/
vxge_queue_h
vxge_queue_create(vxge_hal_device_h devh,
u32 pages_initial,
u32 pages_max,
vxge_queued_f queued_func,
void *queued_data)
{
vxge_queue_t *queue;
__hal_device_t *hldev = (__hal_device_t *) devh;
vxge_assert(devh != NULL);
vxge_hal_trace_log_queue("==> %s:%s:%d",
__FILE__, __func__, __LINE__);
vxge_hal_trace_log_queue(
"devh = 0x"VXGE_OS_STXFMT", pages_initial = %d, "
"pages_max = %d, queued_func = 0x"VXGE_OS_STXFMT", "
"queued_data = 0x"VXGE_OS_STXFMT, (ptr_t) devh, pages_initial,
pages_max, (ptr_t) queued_func, (ptr_t) queued_data);
if ((queue = (vxge_queue_t *) vxge_os_malloc(hldev->header.pdev,
sizeof(vxge_queue_t))) == NULL) {
vxge_hal_trace_log_queue("<== %s:%s:%d Result = %d",
__FILE__, __func__, __LINE__, VXGE_QUEUE_OUT_OF_MEMORY);
return (NULL);
}
queue->queued_func = queued_func;
queue->queued_data = queued_data;
queue->hldev = devh;
queue->pdev = hldev->header.pdev;
queue->irqh = hldev->header.irqh;
queue->pages_current = pages_initial;
queue->start_ptr = vxge_os_malloc(hldev->header.pdev,
queue->pages_current * VXGE_QUEUE_BUF_SIZE);
if (queue->start_ptr == NULL) {
vxge_os_free(hldev->header.pdev, queue, sizeof(vxge_queue_t));
vxge_hal_trace_log_queue("<== %s:%s:%d Result = %d",
__FILE__, __func__, __LINE__, VXGE_QUEUE_OUT_OF_MEMORY);
return (NULL);
}
queue->head_ptr = queue->tail_ptr = queue->start_ptr;
queue->end_ptr = (char *) queue->start_ptr +
queue->pages_current * VXGE_QUEUE_BUF_SIZE;
vxge_os_spin_lock_init_irq(&queue->lock, queue->irqh);
queue->pages_initial = pages_initial;
queue->pages_max = pages_max;
vxge_list_init(&queue->list_head);
vxge_hal_trace_log_queue("<== %s:%s:%d Result = 0",
__FILE__, __func__, __LINE__);
return (queue);
}
/*
* vxge_queue_destroy - Destroy vxge_queue_t object.
* @queueh: Queue handle.
*
* Destroy the specified vxge_queue_t object.
*
* See also: vxge_queue_item_t {}, vxge_queue_create().
*/
void
vxge_queue_destroy(vxge_queue_h queueh)
{
vxge_queue_t *queue = (vxge_queue_t *) queueh;
__hal_device_t *hldev;
vxge_assert(queueh != NULL);
hldev = (__hal_device_t *) queue->hldev;
vxge_hal_trace_log_queue("==> %s:%s:%d",
__FILE__, __func__, __LINE__);
vxge_hal_trace_log_queue("queueh = 0x"VXGE_OS_STXFMT,
(ptr_t) queueh);
vxge_os_spin_lock_destroy_irq(&queue->lock, queue->irqh);
if (!vxge_list_is_empty(&queue->list_head)) {
vxge_hal_trace_log_queue("destroying non-empty queue 0x"
VXGE_OS_STXFMT, (ptr_t) queue);
}
vxge_os_free(queue->pdev, queue->start_ptr, queue->pages_current *
VXGE_QUEUE_BUF_SIZE);
vxge_os_free(queue->pdev, queue, sizeof(vxge_queue_t));
vxge_hal_trace_log_queue("<== %s:%s:%d Result = 0",
__FILE__, __func__, __LINE__);
}
/*
* vxge_io_queue_grow - Dynamically increases the size of the queue.
* @queueh: Queue handle.
*
* This function is called in the case of no slot avaialble in the queue
* to accomodate the newly received event.
* Note that queue cannot grow beyond the max size specified for the
* queue.
*
* Returns VXGE_QUEUE_OK: On success.
* VXGE_QUEUE_OUT_OF_MEMORY : No memory is available.
*/
vxge_queue_status_e
vxge_io_queue_grow(vxge_queue_h queueh)
{
vxge_queue_t *queue = (vxge_queue_t *) queueh;
__hal_device_t *hldev;
void *newbuf, *oldbuf;
vxge_list_t *item;
vxge_queue_item_t *elem;
vxge_assert(queueh != NULL);
hldev = (__hal_device_t *) queue->hldev;
vxge_hal_trace_log_queue("==> %s:%s:%d",
__FILE__, __func__, __LINE__);
vxge_hal_trace_log_queue("queueh = 0x"VXGE_OS_STXFMT,
(ptr_t) queueh);
vxge_hal_info_log_queue("queue 0x"VXGE_OS_STXFMT":%d is growing",
(ptr_t) queue, queue->pages_current);
newbuf = vxge_os_malloc(queue->pdev,
(queue->pages_current + 1) * VXGE_QUEUE_BUF_SIZE);
if (newbuf == NULL) {
vxge_hal_trace_log_queue("<== %s:%s:%d Result = %d",
__FILE__, __func__, __LINE__, VXGE_QUEUE_OUT_OF_MEMORY);
return (VXGE_QUEUE_OUT_OF_MEMORY);
}
vxge_os_memcpy(newbuf, queue->start_ptr,
queue->pages_current * VXGE_QUEUE_BUF_SIZE);
oldbuf = queue->start_ptr;
/* adjust queue sizes */
queue->start_ptr = newbuf;
queue->end_ptr = (char *) newbuf +
(queue->pages_current + 1) * VXGE_QUEUE_BUF_SIZE;
queue->tail_ptr = (char *) newbuf +
/* LINTED */
((char *) queue->tail_ptr - (char *) oldbuf);
queue->head_ptr = (char *) newbuf +
/* LINTED */
((char *) queue->head_ptr - (char *) oldbuf);
vxge_assert(!vxge_list_is_empty(&queue->list_head));
queue->list_head.next = (vxge_list_t *) (void *)((char *) newbuf +
/* LINTED */
((char *) queue->list_head.next - (char *) oldbuf));
queue->list_head.prev = (vxge_list_t *) (void *)((char *) newbuf +
/* LINTED */
((char *) queue->list_head.prev - (char *) oldbuf));
/* adjust queue list */
vxge_list_for_each(item, &queue->list_head) {
elem = vxge_container_of(item, vxge_queue_item_t, item);
if (elem->item.next != &queue->list_head) {
elem->item.next =
(vxge_list_t *) (void *)((char *) newbuf +
/* LINTED */
((char *) elem->item.next - (char *) oldbuf));
}
if (elem->item.prev != &queue->list_head) {
elem->item.prev =
(vxge_list_t *) (void *)((char *) newbuf +
/* LINTED */
((char *) elem->item.prev - (char *) oldbuf));
}
}
vxge_os_free(queue->pdev, oldbuf,
queue->pages_current * VXGE_QUEUE_BUF_SIZE);
queue->pages_current++;
vxge_hal_trace_log_queue("<== %s:%s:%d Result = 0",
__FILE__, __func__, __LINE__);
return (VXGE_QUEUE_OK);
}
/*
* vxge_queue_consume - Dequeue an item from the specified queue.
* @queueh: Queue handle.
* @data_max_size: Maximum expected size of the item.
* @item: Memory area into which the item is _copied_ upon return
* from the function.
*
* Dequeue an item from the queue. The caller is required to provide
* enough space for the item.
*
* Returns: VXGE_QUEUE_OK - success.
* VXGE_QUEUE_IS_EMPTY - Queue is empty.
* VXGE_QUEUE_NOT_ENOUGH_SPACE - Requested item size(@data_max_size)
* is too small to accomodate an item from the queue.
*
* See also: vxge_queue_item_t {}, vxge_queue_produce().
*/
vxge_queue_status_e
vxge_queue_consume(vxge_queue_h queueh,
u32 data_max_size,
vxge_queue_item_t *item)
{
vxge_queue_t *queue = (vxge_queue_t *) queueh;
__hal_device_t *hldev;
unsigned long flags = 0;
vxge_queue_status_e status;
vxge_assert(queueh != NULL);
hldev = (__hal_device_t *) queue->hldev;
vxge_hal_trace_log_queue("==> %s:%s:%d",
__FILE__, __func__, __LINE__);
vxge_hal_trace_log_queue(
"queueh = 0x"VXGE_OS_STXFMT", data_max_size = %d, "
"item = 0x"VXGE_OS_STXFMT, (ptr_t) queueh,
data_max_size, (ptr_t) item);
vxge_os_spin_lock_irq(&queue->lock, flags);
status = __queue_consume(queue, data_max_size, item);
vxge_os_spin_unlock_irq(&queue->lock, flags);
vxge_hal_trace_log_queue("<== %s:%s:%d Result = %d",
__FILE__, __func__, __LINE__, status);
return (status);
}
/*
* vxge_queue_flush - Flush, or empty, the queue.
* @queueh: Queue handle.
*
* Flush the queue, i.e. make it empty by consuming all events
* without invoking the event processing logic (callbacks, etc.)
*/
void
vxge_queue_flush(vxge_queue_h queueh)
{
unsigned char item_buf[sizeof(vxge_queue_item_t) +
VXGE_DEFAULT_EVENT_MAX_DATA_SIZE];
vxge_queue_item_t *item = (vxge_queue_item_t *) (void *)item_buf;
vxge_queue_t *queue = (vxge_queue_t *) queueh;
__hal_device_t *hldev;
vxge_assert(queueh != NULL);
hldev = (__hal_device_t *) queue->hldev;
vxge_hal_trace_log_queue("==> %s:%s:%d",
__FILE__, __func__, __LINE__);
vxge_hal_trace_log_queue("queueh = 0x"VXGE_OS_STXFMT,
(ptr_t) queueh);
/* flush queue by consuming all enqueued items */
while (vxge_queue_consume(queueh, VXGE_DEFAULT_EVENT_MAX_DATA_SIZE,
item) != VXGE_QUEUE_IS_EMPTY) {
/* do nothing */
vxge_hal_trace_log_queue("item 0x"VXGE_OS_STXFMT"(%d) flushed",
(ptr_t) item, item->event_type);
}
(void) vxge_queue_get_reset_critical(queueh);
vxge_hal_trace_log_queue("<== %s:%s:%d Result = 0",
__FILE__, __func__, __LINE__);
}
/*
* vxge_queue_get_reset_critical - Check for critical events in the queue,
* @queueh: Queue handle.
*
* Check for critical event(s) in the queue, and reset the
* "has-critical-event" flag upon return.
* Returns: 1 - if the queue contains atleast one critical event.
* 0 - If there are no critical events in the queue.
*/
u32
vxge_queue_get_reset_critical(vxge_queue_h queueh)
{
vxge_queue_t *queue = (vxge_queue_t *) queueh;
int c = queue->has_critical_event;
__hal_device_t *hldev;
vxge_assert(queueh != NULL);
hldev = (__hal_device_t *) queue->hldev;
vxge_hal_trace_log_queue("==> %s:%s:%d",
__FILE__, __func__, __LINE__);
vxge_hal_trace_log_queue("queueh = 0x"VXGE_OS_STXFMT,
(ptr_t) queueh);
queue->has_critical_event = 0;
vxge_hal_trace_log_queue("<== %s:%s:%d Result = 0",
__FILE__, __func__, __LINE__);
return (c);
}