diff options
Diffstat (limited to 'sys/dev/vxge/vxgehal/vxge-queue.c')
| -rw-r--r-- | sys/dev/vxge/vxgehal/vxge-queue.c | 598 |
1 files changed, 598 insertions, 0 deletions
diff --git a/sys/dev/vxge/vxgehal/vxge-queue.c b/sys/dev/vxge/vxgehal/vxge-queue.c new file mode 100644 index 000000000000..5cf433e53156 --- /dev/null +++ b/sys/dev/vxge/vxgehal/vxge-queue.c @@ -0,0 +1,598 @@ +/*- + * 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$*/ + +#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); +} |