#include <IOKit/assert.h>
#include <IOKit/IOLib.h> // IOLog
#include <IOKit/network/IOPacketQueue.h>
#include "IOMbufQueue.h"
#define super OSObject
OSDefineMetaClassAndStructors( IOPacketQueue, OSObject )
OSMetaClassDefineReservedUnused( IOPacketQueue, 0);
OSMetaClassDefineReservedUnused( IOPacketQueue, 1);
OSMetaClassDefineReservedUnused( IOPacketQueue, 2);
OSMetaClassDefineReservedUnused( IOPacketQueue, 3);
OSMetaClassDefineReservedUnused( IOPacketQueue, 4);
OSMetaClassDefineReservedUnused( IOPacketQueue, 5);
OSMetaClassDefineReservedUnused( IOPacketQueue, 6);
OSMetaClassDefineReservedUnused( IOPacketQueue, 7);
OSMetaClassDefineReservedUnused( IOPacketQueue, 8);
OSMetaClassDefineReservedUnused( IOPacketQueue, 9);
OSMetaClassDefineReservedUnused( IOPacketQueue, 10);
OSMetaClassDefineReservedUnused( IOPacketQueue, 11);
OSMetaClassDefineReservedUnused( IOPacketQueue, 12);
OSMetaClassDefineReservedUnused( IOPacketQueue, 13);
OSMetaClassDefineReservedUnused( IOPacketQueue, 14);
OSMetaClassDefineReservedUnused( IOPacketQueue, 15);
#define LOCK IOSimpleLockLock(_lock)
#define UNLOCK IOSimpleLockUnlock(_lock)
bool IOPacketQueue::initWithCapacity(UInt32 capacity)
{
if (super::init() == false)
{
IOLog("IOPacketQueue: super::init() failed\n");
return false;
}
_queue = IONew(IOMbufQueue, 1);
if (_queue == 0)
return false;
IOMbufQueueInit(_queue, capacity);
if ((_lock = IOSimpleLockAlloc()) == 0)
return false;
IOSimpleLockInit(_lock);
return true;
}
IOPacketQueue * IOPacketQueue::withCapacity(UInt32 capacity)
{
IOPacketQueue * queue = new IOPacketQueue;
if (queue && !queue->initWithCapacity(capacity))
{
queue->release();
queue = 0;
}
return queue;
}
void IOPacketQueue::free()
{
if (_lock)
{
IOSimpleLockFree(_lock);
_lock = 0;
}
if (_queue)
{
flush();
IODelete(_queue, IOMbufQueue, 1);
_queue = 0;
}
super::free();
}
UInt32 IOPacketQueue::getSize() const
{
return IOMbufQueueGetSize(_queue);
}
bool IOPacketQueue::setCapacity(UInt32 capacity)
{
IOMbufQueueSetCapacity(_queue, capacity);
return true;
}
UInt32 IOPacketQueue::getCapacity() const
{
return IOMbufQueueGetCapacity(_queue);
}
const mbuf_t IOPacketQueue::peek() const
{
return IOMbufQueuePeek(_queue);
}
void IOPacketQueue::prepend(mbuf_t m)
{
IOMbufQueuePrepend(_queue, m);
}
void IOPacketQueue::prepend(IOPacketQueue * queue)
{
IOMbufQueuePrepend(_queue, queue->_queue);
}
bool IOPacketQueue::enqueue(mbuf_t m)
{
return IOMbufQueueEnqueue(_queue, m);
}
bool IOPacketQueue::enqueue(IOPacketQueue * queue)
{
return IOMbufQueueEnqueue(_queue, queue->_queue);
}
UInt32 IOPacketQueue::enqueueWithDrop(mbuf_t m)
{
return IOMbufQueueEnqueue(_queue, m) ? 0 : IOMbufFree(m);
}
mbuf_t IOPacketQueue::dequeue()
{
return IOMbufQueueDequeue(_queue);
}
mbuf_t IOPacketQueue::dequeueAll()
{
return IOMbufQueueDequeueAll(_queue);
}
UInt32 IOPacketQueue::flush()
{
return IOMbufFree(IOMbufQueueDequeueAll(_queue));
}
void IOPacketQueue::lockPrepend(mbuf_t m)
{
LOCK;
IOMbufQueuePrepend(_queue, m);
UNLOCK;
}
bool IOPacketQueue::lockEnqueue(mbuf_t m)
{
bool ok;
LOCK;
ok = IOMbufQueueEnqueue(_queue, m);
UNLOCK;
return ok;
}
UInt32 IOPacketQueue::lockEnqueueWithDrop(mbuf_t m)
{
bool ok;
LOCK;
ok = IOMbufQueueEnqueue(_queue, m);
UNLOCK;
return ok ? 0 : IOMbufFree(m);
}
mbuf_t IOPacketQueue::lockDequeue()
{
mbuf_t m;
LOCK;
m = IOMbufQueueDequeue(_queue);
UNLOCK;
return m;
}
mbuf_t IOPacketQueue::lockDequeueAll()
{
mbuf_t m;
LOCK;
m = IOMbufQueueDequeueAll(_queue);
UNLOCK;
return m;
}
UInt32 IOPacketQueue::lockFlush()
{
mbuf_t m;
LOCK;
m = IOMbufQueueDequeueAll(_queue);
UNLOCK;
return IOMbufFree(m);
}