errno_t IOWebFilterClass::tl_data_in_func(void *cookie, socket_t so,
const struct sockaddr *from, mbuf_t *data, mbuf_t *control,
sflt_data_flag_t flags)
{
SocketTracker *tracker = (SocketTracker*)cookie;
// __asm__("int3");
LOG(LOG_DEBUG, "I am in, %s, magic=%ld", tracker->proc_name, tracker->magic);
if(tracker==NULL || data==NULL || (tracker->magic&(kSocketTrackerInvalid|kSocketTrackerDetach))!=0)
{
LOG(LOG_DEBUG, "in return process");
return 0;
}
if(tracker->lock==NULL)
{
tracker->magic=kSocketTrackerInvalid;
return 0;
}
IOLockLock(tracker->lock);
mbuf_t head = *data;
uint64_t len=0;
if(head==NULL)
{
tracker->magic=kSocketTrackerInvalid;
IOLockUnlock(tracker->lock);
return 0;
}
while(head)
{
len += mbuf_len(head);
head = mbuf_next(head);
}
if(len>sizeof(tracker->request_meg)-1)
{
tracker->magic=kSocketTrackerInvalid;
IOLockUnlock(tracker->lock);
return 0;
}
bzero(tracker->request_meg, sizeof(tracker->request_meg));
mbuf_copydata(*data, 0, len, tracker->request_meg);
//todo: sync to shared memory， record a new request
if(_queue)
{
LOG(LOG_DEBUG, "enter queue");
_queue->EnqueueTracker((DataArgs*)tracker);
}
IOLockUnlock(tracker->lock);
return 0;
}
void
SCSIPressurePathManager::ActivatePath ( IOSCSIProtocolServices * interface )
{
bool result = false;
SCSITargetDevicePath * path = NULL;
STATUS_LOG ( ( "SCSIPressurePathManager::ActivatePath\n" ) );
require_nonzero ( interface, ErrorExit );
IOLockLock ( fLock );
result = fInactivePathSet->member ( interface );
if ( result == true )
{
path = fInactivePathSet->getObjectWithInterface ( interface );
if ( path != NULL )
{
path->retain ( );
path->Activate ( );
fInactivePathSet->removeObject ( interface );
fPathSet->setObject ( path );
path->release ( );
path = NULL;
}
}
else
{
result = fPathSet->member ( interface );
if ( result == false )
{
IOLockUnlock ( fLock );
AddPath ( interface );
goto Exit;
}
}
IOLockUnlock ( fLock );
ErrorExit:
Exit:
return;
}
//
// false is returned when there are no entries left,
// the header of the retrurned enrty must not be changed
// and the entry must be provided as a parameter for
// dequeueEntry when the entry is no longer needed
//
bool DldIODataQueue::dequeueDataInPlace( __out DldIODataQueueEntry** inPlaceEntry )
{
DldIODataQueueEntry * entry = 0;
assert( dataQueue );
IOLockLock( this->lock );
{// start of the lock
UInt32 newHeadOffset = 0;
if( dataQueue->validDataHead != dataQueue->validDataTail ){
DldIODataQueueEntry* head;
UInt32 headOffset;
headOffset = dataQueue->validDataHead;
head = (DldIODataQueueEntry *)((char *)dataQueue->queue + headOffset);
//
// we wraped around to beginning, so read from there
// either there was not even room for the header
//
if( (dataQueue->head + DLD_DATA_QUEUE_ENTRY_HEADER_SIZE > dataQueue->queueSize) ||
// or there was room for the header, but not for the data
((dataQueue->head + head->dataSize + DLD_DATA_QUEUE_ENTRY_HEADER_SIZE) > dataQueue->queueSize)) {
entry = dataQueue->queue;
newHeadOffset = entry->dataSize + DLD_DATA_QUEUE_ENTRY_HEADER_SIZE;
// else it is at the end
} else {
entry = head;
newHeadOffset = headOffset + entry->dataSize + DLD_DATA_QUEUE_ENTRY_HEADER_SIZE;
}
}// else if( dataQueue->validDataHead != dataQueue->validDataTail )
if (entry) {
assert( DLD_QUEUE_SIGNATURE == entry->signature );
assert( false == entry->intermediate );
*inPlaceEntry = entry;
dataQueue->validDataHead = newHeadOffset;
}
}// end of the lock
IOLockUnlock( this->lock );
return ( NULL != entry );
}
IOReturn AppleRAIDMemoryDescriptor::complete(IODirection forDirection)
{
IOReturn result;
IOLockLock(mdMemoryDescriptorLock);
result = mdMemoryDescriptor->complete(forDirection);
IOLockUnlock(mdMemoryDescriptorLock);
return result;
}
void IOHIDEventQueue::setOptions(IOHIDQueueOptionsType flags)
{
if ( _lock )
IOLockLock(_lock);
_options = flags;
if ( _lock )
IOLockUnlock(_lock);
}
/* wait for the pet thread to finish a run */
void
kperf_pet_thread_wait(void)
{
if( !pet_lock )
return;
/* acquire the lock to ensure the thread is parked. */
IOLockLock(pet_lock);
IOLockUnlock(pet_lock);
}
void IOHIDEventQueue::stop()
{
if ( _lock )
IOLockLock(_lock);
_state &= ~kHIDQueueStarted;
if ( _lock )
IOLockUnlock(_lock);
}
void IOHIDEventQueue::disable()
{
if ( _lock )
IOLockLock(_lock);
_state |= kHIDQueueDisabled;
if ( _lock )
IOLockUnlock(_lock);
}
void IOHIKeyboard::dispatchKeyboardEvent(unsigned int keyCode,
/* direction */ bool goingDown,
/* timeStamp */ AbsoluteTime time)
// Description: This method is the heart of event dispatching. The overlying
// subclass invokes this method with each event. We then
// get the event xlated and dispatched using a _keyMap instance.
// The event structure passed in by reference should not be freed.
{
IOHIKeyboardMapper * theKeyMap;
KeyboardReserved *tempReservedStruct = GetKeyboardReservedStructEventForService(this);
IOLockLock( _deviceLock);
_lastEventTime = time;
// Post the event to the HID Manager
if (tempReservedStruct)
{
if (tempReservedStruct->keyboardNub )
{
tempReservedStruct->keyboardNub->postKeyboardEvent(keyCode, goingDown);
}
if (tempReservedStruct->isSeized)
{
IOLockUnlock( _deviceLock);
return;
}
}
if (tempReservedStruct) tempReservedStruct->dispatchEventCalled = true;
if (_keyMap) _keyMap->translateKeyCode(keyCode,
/* direction */ goingDown,
/* keyBits */ _keyState);
// remember the keymap while we hold the lock
theKeyMap = _keyMap;
if (tempReservedStruct) tempReservedStruct->dispatchEventCalled = false;
IOLockUnlock( _deviceLock);
// outside the lock (because of possible recursion), give the
// keymap a chance to do some post processing
// since it is possible we will be entered reentrantly and
// release the keymap, we will add a retain here.
if (theKeyMap)
{
theKeyMap->retain();
theKeyMap->keyEventPostProcess();
theKeyMap->release();
}
}
OSMetaClass::~OSMetaClass()
{
OSKext * myKext = (OSKext *)reserved; // do not release
/* Hack alert: 'className' is a C string during early C++ init, and
* is converted to a real OSSymbol only when we record the OSKext in
* OSMetaClass::postModLoad(). So only do this bit if we have an OSKext.
* We can't safely cast or check 'className'.
*
* Also, release className *after* calling into the kext,
* as removeClass() may access className.
*/
IOLockLock(sAllClassesLock);
if (sAllClassesDict) {
if (myKext) {
sAllClassesDict->removeObject(className);
} else {
sAllClassesDict->removeObject((char *)className);
}
}
IOLockUnlock(sAllClassesLock);
if (myKext) {
if (myKext->removeClass(this) != kOSReturnSuccess) {
// xxx - what can we do?
}
className->release();
}
// sStalledClassesLock taken in preModLoad
if (sStalled) {
unsigned int i;
/* First pass find class in stalled list. If we find it that means
* we started C++ init with constructors but now we're tearing down
* because of some failure.
*/
for (i = 0; i < sStalled->count; i++) {
if (this == sStalled->classes[i]) {
break;
}
}
/* Remove this metaclass from the stalled list so postModLoad() doesn't
* try to register it.
*/
if (i < sStalled->count) {
sStalled->count--;
if (i < sStalled->count) {
memmove(&sStalled->classes[i], &sStalled->classes[i+1],
(sStalled->count - i) * sizeof(OSMetaClass *));
}
}
}
}
IOReturn SPFramebuffer::disable() {
IOLockLock(lock);
if (!isEnabled) {
IOLockUnlock(lock);
return kIOReturnNotOpen;
}
isEnabled = false;
connectChangeInterrupt(this, NULL);
IOLockUnlock(lock);
return kIOReturnSuccess;
}
void IOHIKeyboard::setRepeatMode(bool repeat)
{
KeyboardReserved *tempReservedStruct = GetKeyboardReservedStructEventForService(this);
IOLockLock( _deviceLock);
if (tempReservedStruct)
{
tempReservedStruct->repeatMode = repeat;
}
IOLockUnlock( _deviceLock);
}
bool AppleGPIO::amRegistered(void)
{
bool result;
IOLockLock(fAmRegisteredLock);
result = fAmRegistered;
IOLockUnlock(fAmRegisteredLock);
return(result);
}
IODataQueue *
IOHIDEventSystemUserClient::copyDataQueueWithID(UInt32 queueID)
{
IODataQueue * eventQueue;
IOLockLock(gAllUserQueuesLock);
eventQueue = OSDynamicCast(IODataQueue, gAllUserQueues->getObject(queueID - kIOHIDEventSystemUserQueueID));
if (eventQueue)
eventQueue->retain();
IOLockUnlock(gAllUserQueuesLock);
return (eventQueue);
}
void GlobalLock::terminate(void) {
if (!lock_) return;
IOLockLock(lock_);
IOLock* tmp = lock_;
lock_ = NULL;
IOLockUnlock(tmp);
// roughly sleep:
IOSleep(200);
IOLockFree(tmp);
}
void AppleNForceATARoot::pciConfigWrite32( UInt8 offset, UInt32 data, UInt32 mask )
{
UInt8 u32;
IOLockLock( fPCILock );
u32 = fProvider->configRead32( offset );
u32 &= ~mask;
u32 |= (mask & data);
fProvider->configWrite32( offset, u32 );
IOLockUnlock( fPCILock );
}
void AppleNForceATARoot::pciConfigWrite8( UInt8 offset, UInt8 data, UInt8 mask )
{
UInt8 u8;
IOLockLock( fPCILock );
u8 = fProvider->configRead8( offset );
u8 &= ~mask;
u8 |= (mask & data);
fProvider->configWrite8( offset, u8 );
IOLockUnlock( fPCILock );
}
IOReturn IOCatalogue::terminateDrivers(OSDictionary * matching)
{
IOReturn ret;
ret = _terminateDrivers(matching);
IOLockLock(lock);
if (kIOReturnSuccess == ret)
ret = _removeDrivers(array, matching);
kernelTables->reset();
IOLockUnlock(lock);
return ret;
}
IOReturn IOPlatformExpert::registerInterruptController(OSSymbol *name, IOInterruptController *interruptController)
{
IOLockLock(gIOInterruptControllersLock);
gIOInterruptControllers->setObject(name, interruptController);
IOLockWakeup(gIOInterruptControllersLock,
gIOInterruptControllers, /* one-thread */ false);
IOLockUnlock(gIOInterruptControllersLock);
return kIOReturnSuccess;
}
Boolean IOHIDEventQueue::isStarted()
{
bool ret;
if ( _lock )
IOLockLock(_lock);
ret = (_state & kHIDQueueStarted) != 0;
if ( _lock )
IOLockUnlock(_lock);
return ret;
}
IOReturn IOSharedInterruptController::unregisterInterrupt(IOService *nub,
int source)
{
IOInterruptVectorNumber vectorNumber;
IOInterruptVector *vector;
IOInterruptState interruptState;
for (vectorNumber = 0; vectorNumber < kIOSharedInterruptControllerDefaultVectors; vectorNumber++) {
vector = &vectors[vectorNumber];
// Get the lock for this vector.
IOLockLock(vector->interruptLock);
// Return success if it is not already registered
if (!vector->interruptRegistered
|| (vector->nub != nub) || (vector->source != source)) {
IOLockUnlock(vector->interruptLock);
continue;
}
// Soft disable the source and the controller too.
disableInterrupt(nub, source);
// Clear all the storage for the vector except for interruptLock.
vector->interruptActive = 0;
vector->interruptDisabledSoft = 0;
vector->interruptDisabledHard = 0;
vector->interruptRegistered = 0;
vector->nub = 0;
vector->source = 0;
vector->handler = 0;
vector->target = 0;
vector->refCon = 0;
interruptState = IOSimpleLockLockDisableInterrupt(controllerLock);
vectorsRegistered--;
IOSimpleLockUnlockEnableInterrupt(controllerLock, interruptState);
// Move along to the next one.
IOLockUnlock(vector->interruptLock);
}
// Re-enable the controller if all vectors are enabled.
if (vectorsEnabled == vectorsRegistered) {
controllerDisabled = 0;
provider->enableInterrupt(0);
}
return kIOReturnSuccess;
}
/* make sure the thread takes a new period value */
void
kperf_pet_timer_config( unsigned timerid, unsigned actionid )
{
/* hold the lock so pet thread doesn't run while we do this */
IOLockLock(pet_lock);
BUF_INFO1(PERF_PET_THREAD, 3);
/* set values */
pet_timerid = timerid;
pet_actionid = actionid;
/* done */
IOLockUnlock(pet_lock);
}
void AppleIntelPIIXATARoot::pciConfigWrite16( UInt8 offset,
UInt16 data,
UInt16 mask )
{
UInt16 u16;
IOLockLock( _pciConfigLock );
u16 = _provider->configRead16( offset );
u16 &= ~mask;
u16 |= (mask & data);
_provider->configWrite16( offset, u16 );
IOLockUnlock( _pciConfigLock );
}
void AppleIntelPIIXATARoot::pciConfigWrite8( UInt8 offset,
UInt8 data,
UInt8 mask )
{
UInt8 u8;
IOLockLock( _pciConfigLock );
u8 = _provider->configRead8( offset );
u8 &= ~mask;
u8 |= (mask & data);
_provider->configWrite8( offset, u8 );
IOLockUnlock( _pciConfigLock );
}
bool IOHIKeyboard::resetKeyboard()
// Description: Reset the keymapping to the default value and reconfigure
// the keyboards.
{
const unsigned char *defaultKeymap;
UInt32 defaultKeymapLength;
IOLockLock( _deviceLock);
if ( _keyMap )
_keyMap->release();
// Set up default keymapping.
defaultKeymap = defaultKeymapOfLength(&defaultKeymapLength);
_keyMap = IOHIKeyboardMapper::keyboardMapper( this,
defaultKeymap,
defaultKeymapLength,
false );
if (_keyMap)
{
// point the new keymap to the IOHIDSystem, so it can set properties in it
_keyMap->setKeyboardTarget((IOService *) _keyboardEventTarget);
clock_interval_to_absolutetime_interval( EV_DEFAULTKEYREPEAT,
kNanosecondScale, &_keyRepeat);
clock_interval_to_absolutetime_interval( EV_DEFAULTINITIALREPEAT,
kNanosecondScale, &_initialKeyRepeat);
}
updateProperties();
_interfaceType = interfaceID();
_deviceType = deviceType();
_guid = getGUID();
if (getProperty("HIDKeyboardKeysDefined"))
{
KeyboardReserved * reservedStruct = GetKeyboardReservedStructEventForService(this);
if ( reservedStruct && !reservedStruct->keyboardNub)
reservedStruct->keyboardNub = IOHIDKeyboardDevice::newKeyboardDeviceAndStart(this);
}
IOLockUnlock( _deviceLock);
return (_keyMap) ? true : false;
}
SCSIServiceResponse
SCSIPressurePathManager::LogicalUnitReset ( SCSILogicalUnitNumber theLogicalUnit )
{
SCSITargetDevicePath * path = NULL;
IOLockLock ( fLock );
path = fPathSet->getAnyObject ( );
IOLockUnlock ( fLock );
if ( path == NULL )
return kSCSIServiceResponse_FUNCTION_REJECTED;
return path->GetInterface ( )->LogicalUnitReset ( theLogicalUnit );
}
SCSIServiceResponse
SCSIPressurePathManager::TargetReset ( void )
{
SCSITargetDevicePath * path = NULL;
IOLockLock ( fLock );
path = fPathSet->getAnyObject ( );
IOLockUnlock ( fLock );
if ( path == NULL )
return kSCSIServiceResponse_FUNCTION_REJECTED;
return path->GetInterface ( )->TargetReset ( );
}
void IOHIDEventQueue::start()
{
if ( _lock )
IOLockLock(_lock);
if ( _state & kHIDQueueStarted )
goto START_END;
if ( _currentEntrySize != _maxEntrySize )
{
mach_port_t port = notifyMsg ? ((mach_msg_header_t *)notifyMsg)->msgh_remote_port : MACH_PORT_NULL;
// Free the existing queue data
if (dataQueue) {
IOFreeAligned(dataQueue, round_page_32(getQueueSize() + DATA_QUEUE_MEMORY_HEADER_SIZE));
dataQueue = NULL;
}
if (_descriptor) {
_descriptor->release();
_descriptor = 0;
}
// init the queue again. This will allocate the appropriate data.
if ( !initWithEntries(_numEntries, _maxEntrySize) ) {
goto START_END;
}
_currentEntrySize = _maxEntrySize;
// RY: since we are initing the queue, we should reset the port as well
if ( port )
setNotificationPort(port);
}
else if ( dataQueue )
{
dataQueue->head = 0;
dataQueue->tail = 0;
}
_state |= kHIDQueueStarted;
START_END:
if ( _lock )
IOLockUnlock(_lock);
}
const OSMetaClass *
OSMetaClass::getMetaClassWithName(const OSSymbol * name)
{
OSMetaClass * retMeta = 0;
if (!name) {
return 0;
}
IOLockLock(sAllClassesLock);
if (sAllClassesDict) {
retMeta = (OSMetaClass *) sAllClassesDict->getObject(name);
}
IOLockUnlock(sAllClassesLock);
return retMeta;
}
UInt32
IOHIDEventSystemUserClient::createIDForDataQueue(IODataQueue * eventQueue)
{
UInt32 queueIdx;
if (!eventQueue)
return (0);
IOLockLock(gAllUserQueuesLock);
for (queueIdx = 0;
OSDynamicCast(IODataQueue, gAllUserQueues->getObject(queueIdx));
queueIdx++) {}
gAllUserQueues->setObject(queueIdx, eventQueue);
IOLockUnlock(gAllUserQueuesLock);
return (queueIdx + kIOHIDEventSystemUserQueueID);
}
