//---------------------------------------------------------------------------
Boolean IOHIDEventSystemQueue::enqueue(void *data, UInt32 dataSize)
{
Boolean result = false;
_didSendNotificationForLastEnqueue = false;
result = super::enqueue(data, dataSize);
if (!_didSendNotificationForLastEnqueue) {
//kprintf("IOHIDEventSystemQueue sending notification for IOSharedDataQueue.\n");
sendDataAvailableNotification();
}
return result;
}
bool IOSharedEventQueue::EnqueueTracker(DataArgs * data)
{
uint32_t singleTrackerLen = sizeof(DataArgs);
const UInt32 head = dataQueue->head;
const UInt32 tail = dataQueue->tail;
LOG(LOG_DEBUG, "head=%d", dataQueue->head);
LOG(LOG_DEBUG, "tail=%d", dataQueue->tail);
const UInt32 entrySize = singleTrackerLen+DATA_QUEUE_ENTRY_HEADER_SIZE;
IODataQueueEntry *entry;
if(singleTrackerLen>UINT32_MAX-DATA_QUEUE_ENTRY_HEADER_SIZE)
{
return false;
}
LOG(LOG_DEBUG, "this->getQueueSize()=%d", this->getQueueSize());
if(this->getQueueSize()<tail)
{
return false;
}
if(tail>=head)
{
if(entrySize<=UINT32_MAX-DATA_QUEUE_ENTRY_HEADER_SIZE &&
tail+entrySize<=this->getQueueSize())
{
entry = (IODataQueueEntry*)((uint8_t*)dataQueue->queue+dataQueue->tail);
entry->size=singleTrackerLen;
memcpy(entry->data, data, singleTrackerLen);
OSAddAtomic(entrySize, (SInt32*)&(dataQueue->tail));
}
else if(head>singleTrackerLen)
{
dataQueue->queue->size = singleTrackerLen;
if ( ( getQueueSize() - tail ) >= DATA_QUEUE_ENTRY_HEADER_SIZE )
{
((IODataQueueEntry *)((UInt8 *)dataQueue->queue + tail))->size = entrySize;
}
memcpy(&dataQueue->queue->data, data, singleTrackerLen);
OSCompareAndSwap(dataQueue->tail, entrySize, &dataQueue->tail);
}
else
{
return false;
}
}
else
{
if ( (head - tail) > entrySize )
{
entry = (IODataQueueEntry *)((UInt8 *)dataQueue->queue + tail);
entry->size = singleTrackerLen;
memcpy(&entry->data, data, singleTrackerLen);
OSAddAtomic(entrySize, (SInt32 *)&dataQueue->tail);
}
else
{
return false; // queue is full
}
}
if(head==tail) return true;
//send notification to port if any data is added to queue.
//if ( (this->_status&kSharedEventQueueNotifyWhenAddData) || ( head == tail ) || ( dataQueue->head == tail ))
{
sendDataAvailableNotification();
}
return true;
}
Boolean IODataQueue::enqueue(void * data, UInt32 dataSize)
{
const UInt32 head = dataQueue->head; // volatile
const UInt32 tail = dataQueue->tail;
const UInt32 entrySize = dataSize + DATA_QUEUE_ENTRY_HEADER_SIZE;
IODataQueueEntry * entry;
// Check for overflow of entrySize
if (dataSize > UINT32_MAX - DATA_QUEUE_ENTRY_HEADER_SIZE) {
return false;
}
// Check for underflow of (dataQueue->queueSize - tail)
if (dataQueue->queueSize < tail) {
return false;
}
if ( tail >= head )
{
// Is there enough room at the end for the entry?
if ((entrySize <= UINT32_MAX - tail) &&
((tail + entrySize) <= dataQueue->queueSize) )
{
entry = (IODataQueueEntry *)((UInt8 *)dataQueue->queue + tail);
entry->size = dataSize;
memcpy(&entry->data, data, dataSize);
// The tail can be out of bound when the size of the new entry
// exactly matches the available space at the end of the queue.
// The tail can range from 0 to dataQueue->queueSize inclusive.
OSAddAtomic(entrySize, (SInt32 *)&dataQueue->tail);
}
else if ( head > entrySize ) // Is there enough room at the beginning?
{
// Wrap around to the beginning, but do not allow the tail to catch
// up to the head.
dataQueue->queue->size = dataSize;
// We need to make sure that there is enough room to set the size before
// doing this. The user client checks for this and will look for the size
// at the beginning if there isn't room for it at the end.
if ( ( dataQueue->queueSize - tail ) >= DATA_QUEUE_ENTRY_HEADER_SIZE )
{
((IODataQueueEntry *)((UInt8 *)dataQueue->queue + tail))->size = dataSize;
}
memcpy(&dataQueue->queue->data, data, dataSize);
OSCompareAndSwap(dataQueue->tail, entrySize, &dataQueue->tail);
}
else
{
return false; // queue is full
}
}
else
{
// Do not allow the tail to catch up to the head when the queue is full.
// That's why the comparison uses a '>' rather than '>='.
if ( (head - tail) > entrySize )
{
entry = (IODataQueueEntry *)((UInt8 *)dataQueue->queue + tail);
entry->size = dataSize;
memcpy(&entry->data, data, dataSize);
OSAddAtomic(entrySize, (SInt32 *)&dataQueue->tail);
}
else
{
return false; // queue is full
}
}
// Send notification (via mach message) that data is available.
if ( ( head == tail ) /* queue was empty prior to enqueue() */
|| ( dataQueue->head == tail ) ) /* queue was emptied during enqueue() */
{
sendDataAvailableNotification();
}
return true;
}
Boolean IOSharedDataQueue::enqueue(void * data, UInt32 dataSize)
{
UInt32 head;
UInt32 tail;
UInt32 newTail;
const UInt32 entrySize = dataSize + DATA_QUEUE_ENTRY_HEADER_SIZE;
IODataQueueEntry * entry;
// Force a single read of head and tail
// See rdar://problem/40780584 for an explanation of relaxed/acquire barriers
tail = __c11_atomic_load((_Atomic UInt32 *)&dataQueue->tail, __ATOMIC_RELAXED);
head = __c11_atomic_load((_Atomic UInt32 *)&dataQueue->head, __ATOMIC_ACQUIRE);
// Check for overflow of entrySize
if (dataSize > UINT32_MAX - DATA_QUEUE_ENTRY_HEADER_SIZE) {
return false;
}
// Check for underflow of (getQueueSize() - tail)
if (getQueueSize() < tail || getQueueSize() < head) {
return false;
}
if ( tail >= head )
{
// Is there enough room at the end for the entry?
if ((entrySize <= UINT32_MAX - tail) &&
((tail + entrySize) <= getQueueSize()) )
{
entry = (IODataQueueEntry *)((UInt8 *)dataQueue->queue + tail);
entry->size = dataSize;
memcpy(&entry->data, data, dataSize);
// The tail can be out of bound when the size of the new entry
// exactly matches the available space at the end of the queue.
// The tail can range from 0 to dataQueue->queueSize inclusive.
newTail = tail + entrySize;
}
else if ( head > entrySize ) // Is there enough room at the beginning?
{
// Wrap around to the beginning, but do not allow the tail to catch
// up to the head.
dataQueue->queue->size = dataSize;
// We need to make sure that there is enough room to set the size before
// doing this. The user client checks for this and will look for the size
// at the beginning if there isn't room for it at the end.
if ( ( getQueueSize() - tail ) >= DATA_QUEUE_ENTRY_HEADER_SIZE )
{
((IODataQueueEntry *)((UInt8 *)dataQueue->queue + tail))->size = dataSize;
}
memcpy(&dataQueue->queue->data, data, dataSize);
newTail = entrySize;
}
else
{
return false; // queue is full
}
}
else
{
// Do not allow the tail to catch up to the head when the queue is full.
// That's why the comparison uses a '>' rather than '>='.
if ( (head - tail) > entrySize )
{
entry = (IODataQueueEntry *)((UInt8 *)dataQueue->queue + tail);
entry->size = dataSize;
memcpy(&entry->data, data, dataSize);
newTail = tail + entrySize;
}
else
{
return false; // queue is full
}
}
// Publish the data we just enqueued
__c11_atomic_store((_Atomic UInt32 *)&dataQueue->tail, newTail, __ATOMIC_RELEASE);
if (tail != head) {
//
// The memory barrier below paris with the one in ::dequeue
// so that either our store to the tail cannot be missed by
// the next dequeue attempt, or we will observe the dequeuer
// making the queue empty.
//
// Of course, if we already think the queue is empty,
// there's no point paying this extra cost.
//
__c11_atomic_thread_fence(__ATOMIC_SEQ_CST);
head = __c11_atomic_load((_Atomic UInt32 *)&dataQueue->head, __ATOMIC_RELAXED);
}
if (tail == head) {
// Send notification (via mach message) that data is now available.
sendDataAvailableNotification();
}
return true;
}
Boolean IOHIDEventServiceQueue::enqueueEvent( IOHIDEvent * event )
{
IOByteCount dataSize = event->getLength();
const UInt32 head = dataQueue->head; // volatile
const UInt32 tail = dataQueue->tail;
const UInt32 entrySize = dataSize + DATA_QUEUE_ENTRY_HEADER_SIZE;
IODataQueueEntry * entry;
if ( tail >= head )
{
// Is there enough room at the end for the entry?
if ( (tail + entrySize) <= dataQueue->queueSize )
{
entry = (IODataQueueEntry *)((UInt8 *)dataQueue->queue + tail);
entry->size = dataSize;
event->readBytes(&entry->data, dataSize);
// The tail can be out of bound when the size of the new entry
// exactly matches the available space at the end of the queue.
// The tail can range from 0 to dataQueue->queueSize inclusive.
dataQueue->tail += entrySize;
}
else if ( head > entrySize ) // Is there enough room at the beginning?
{
// Wrap around to the beginning, but do not allow the tail to catch
// up to the head.
dataQueue->queue->size = dataSize;
// We need to make sure that there is enough room to set the size before
// doing this. The user client checks for this and will look for the size
// at the beginning if there isn't room for it at the end.
if ( ( dataQueue->queueSize - tail ) >= DATA_QUEUE_ENTRY_HEADER_SIZE )
{
((IODataQueueEntry *)((UInt8 *)dataQueue->queue + tail))->size = dataSize;
}
event->readBytes(&dataQueue->queue->data, dataSize);
dataQueue->tail = entrySize;
}
else
{
return false; // queue is full
}
}
else
{
// Do not allow the tail to catch up to the head when the queue is full.
// That's why the comparison uses a '>' rather than '>='.
if ( (head - tail) > entrySize )
{
entry = (IODataQueueEntry *)((UInt8 *)dataQueue->queue + tail);
entry->size = dataSize;
event->readBytes(&entry->data, dataSize);
dataQueue->tail += entrySize;
}
else
{
return false; // queue is full
}
}
// Send notification (via mach message) that data is available if either the
// queue was empty prior to enqueue() or queue was emptied during enqueue()
if ( ( head == tail ) || ( dataQueue->head == tail ) )
sendDataAvailableNotification();
return true;
}
void IOHIDEventServiceQueue::setNotificationPort(mach_port_t port) {
super::setNotificationPort(port);
if (dataQueue->head != dataQueue->tail)
sendDataAvailableNotification();
}
