iokit/Kernel/IOFilterInterruptEventSource.cpp

   1 /*
   2  * Copyright (c) 1998-2010 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28
  29 #define IOKIT_ENABLE_SHARED_PTR
  30
  31 #include <IOKit/IOFilterInterruptEventSource.h>
  32 #include <IOKit/IOService.h>
  33 #include <IOKit/IOKitDebug.h>
  34 #include <IOKit/IOTimeStamp.h>
  35 #include <IOKit/IOWorkLoop.h>
  36 #include <IOKit/IOInterruptAccountingPrivate.h>
  37 #include <libkern/Block.h>
  38
  39 #if IOKITSTATS
  40
  41 #define IOStatisticsInitializeCounter() \
  42 do { \
  43         IOStatistics::setCounterType(IOEventSource::reserved->counter, kIOStatisticsFilterInterruptEventSourceCounter); \
  44 } while (0)
  45
  46 #define IOStatisticsInterrupt() \
  47 do { \
  48         IOStatistics::countInterrupt(IOEventSource::reserved->counter); \
  49 } while (0)
  50
  51 #else
  52
  53 #define IOStatisticsInitializeCounter()
  54 #define IOStatisticsInterrupt()
  55
  56 #endif /* IOKITSTATS */
  57
  58 #define super IOInterruptEventSource
  59
  60 OSDefineMetaClassAndStructors
  61 (IOFilterInterruptEventSource, IOInterruptEventSource)
  62 OSMetaClassDefineReservedUnused(IOFilterInterruptEventSource, 0);
  63 OSMetaClassDefineReservedUnused(IOFilterInterruptEventSource, 1);
  64 OSMetaClassDefineReservedUnused(IOFilterInterruptEventSource, 2);
  65 OSMetaClassDefineReservedUnused(IOFilterInterruptEventSource, 3);
  66 OSMetaClassDefineReservedUnused(IOFilterInterruptEventSource, 4);
  67 OSMetaClassDefineReservedUnused(IOFilterInterruptEventSource, 5);
  68 OSMetaClassDefineReservedUnused(IOFilterInterruptEventSource, 6);
  69 OSMetaClassDefineReservedUnused(IOFilterInterruptEventSource, 7);
  70
  71 /*
  72  * Implement the call throughs for the private protection conversion
  73  */
  74 bool
  75 IOFilterInterruptEventSource::init(OSObject *inOwner,
  76     Action inAction,
  77     IOService *inProvider,
  78     int inIntIndex)
  79 {
  80         return false;
  81 }
  82
  83 OSSharedPtr<IOInterruptEventSource>
  84 IOFilterInterruptEventSource::interruptEventSource(OSObject *inOwner,
  85     Action inAction,
  86     IOService *inProvider,
  87     int inIntIndex)
  88 {
  89         return NULL;
  90 }
  91
  92 bool
  93 IOFilterInterruptEventSource::init(OSObject *inOwner,
  94     Action inAction,
  95     Filter inFilterAction,
  96     IOService *inProvider,
  97     int inIntIndex)
  98 {
  99         if (!super::init(inOwner, inAction, inProvider, inIntIndex)) {
 100                 return false;
 101         }
 102
 103         if (!inFilterAction) {
 104                 return false;
 105         }
 106
 107         filterAction = inFilterAction;
 108
 109         IOStatisticsInitializeCounter();
 110
 111         return true;
 112 }
 113
 114 OSSharedPtr<IOFilterInterruptEventSource>
 115 IOFilterInterruptEventSource
 116 ::filterInterruptEventSource(OSObject *inOwner,
 117     Action inAction,
 118     Filter inFilterAction,
 119     IOService *inProvider,
 120     int inIntIndex)
 121 {
 122         OSSharedPtr<IOFilterInterruptEventSource> me = OSMakeShared<IOFilterInterruptEventSource>();
 123
 124         if (me
 125             && !me->init(inOwner, inAction, inFilterAction, inProvider, inIntIndex)) {
 126                 return nullptr;
 127         }
 128
 129         return me;
 130 }
 131
 132
 133 OSSharedPtr<IOFilterInterruptEventSource>
 134 IOFilterInterruptEventSource
 135 ::filterInterruptEventSource(OSObject *inOwner,
 136     IOService *inProvider,
 137     int inIntIndex,
 138     ActionBlock inAction,
 139     FilterBlock inFilterAction)
 140 {
 141         OSSharedPtr<IOFilterInterruptEventSource> me = OSMakeShared<IOFilterInterruptEventSource>();
 142
 143         FilterBlock filter = Block_copy(inFilterAction);
 144         if (!filter) {
 145                 return nullptr;
 146         }
 147
 148         if (me
 149             && !me->init(inOwner, (Action) NULL, (Filter) filter, inProvider, inIntIndex)) {
 150                 Block_release(filter);
 151                 return nullptr;
 152         }
 153         me->flags |= kFilterBlock;
 154         me->setActionBlock((IOEventSource::ActionBlock) inAction);
 155
 156         return me;
 157 }
 158
 159
 160 void
 161 IOFilterInterruptEventSource::free( void )
 162 {
 163         if ((kFilterBlock & flags) && filterActionBlock) {
 164                 Block_release(filterActionBlock);
 165         }
 166
 167         super::free();
 168 }
 169
 170 void
 171 IOFilterInterruptEventSource::signalInterrupt()
 172 {
 173         bool trace = (gIOKitTrace & kIOTraceIntEventSource) ? true : false;
 174
 175         IOStatisticsInterrupt();
 176         producerCount++;
 177
 178         if (trace) {
 179                 IOTimeStampStartConstant(IODBG_INTES(IOINTES_SEMA), VM_KERNEL_ADDRHIDE(this), VM_KERNEL_ADDRHIDE(owner));
 180         }
 181
 182         signalWorkAvailable();
 183
 184         if (trace) {
 185                 IOTimeStampEndConstant(IODBG_INTES(IOINTES_SEMA), VM_KERNEL_ADDRHIDE(this), VM_KERNEL_ADDRHIDE(owner));
 186         }
 187 }
 188
 189
 190 IOFilterInterruptEventSource::Filter
 191 IOFilterInterruptEventSource::getFilterAction() const
 192 {
 193         if (kFilterBlock & flags) {
 194                 return NULL;
 195         }
 196         return filterAction;
 197 }
 198
 199 IOFilterInterruptEventSource::FilterBlock
 200 IOFilterInterruptEventSource::getFilterActionBlock() const
 201 {
 202         if (kFilterBlock & flags) {
 203                 return filterActionBlock;
 204         }
 205         return NULL;
 206 }
 207
 208 void
 209 IOFilterInterruptEventSource::normalInterruptOccurred
 210 (void */*refcon*/, IOService */*prov*/, int /*source*/)
 211 {
 212         bool        filterRes;
 213         uint64_t    startTime = 0;
 214         uint64_t    endTime = 0;
 215         bool    trace = (gIOKitTrace & kIOTraceIntEventSource) ? true : false;
 216
 217         if (trace) {
 218                 IOTimeStampStartConstant(IODBG_INTES(IOINTES_FILTER),
 219                     VM_KERNEL_UNSLIDE(filterAction), VM_KERNEL_ADDRHIDE(owner), VM_KERNEL_ADDRHIDE(this), VM_KERNEL_ADDRHIDE(workLoop));
 220         }
 221
 222         if (IOInterruptEventSource::reserved->statistics) {
 223                 if (IA_GET_STATISTIC_ENABLED(kInterruptAccountingFirstLevelTimeIndex)
 224                     || IOInterruptEventSource::reserved->statistics->enablePrimaryTimestamp) {
 225                         startTime = mach_absolute_time();
 226                 }
 227                 if (IOInterruptEventSource::reserved->statistics->enablePrimaryTimestamp) {
 228                         IOInterruptEventSource::reserved->statistics->primaryTimestamp = startTime;
 229                 }
 230         }
 231
 232         // Call the filter.
 233         if (kFilterBlock & flags) {
 234                 filterRes = (filterActionBlock)(this);
 235         } else {
 236                 filterRes = (*filterAction)(owner, this);
 237         }
 238
 239         if (IOInterruptEventSource::reserved->statistics) {
 240                 if (IA_GET_STATISTIC_ENABLED(kInterruptAccountingFirstLevelCountIndex)) {
 241                         IA_ADD_VALUE(&IOInterruptEventSource::reserved->statistics->interruptStatistics[kInterruptAccountingFirstLevelCountIndex], 1);
 242                 }
 243
 244                 if (IA_GET_STATISTIC_ENABLED(kInterruptAccountingFirstLevelTimeIndex)) {
 245                         endTime = mach_absolute_time();
 246                         IA_ADD_VALUE(&IOInterruptEventSource::reserved->statistics->interruptStatistics[kInterruptAccountingFirstLevelTimeIndex], endTime - startTime);
 247                 }
 248         }
 249
 250         if (trace) {
 251                 IOTimeStampEndConstant(IODBG_INTES(IOINTES_FILTER),
 252                     VM_KERNEL_ADDRHIDE(filterAction), VM_KERNEL_ADDRHIDE(owner),
 253                     VM_KERNEL_ADDRHIDE(this), VM_KERNEL_ADDRHIDE(workLoop));
 254         }
 255
 256         if (filterRes) {
 257                 signalInterrupt();
 258         }
 259 }
 260
 261 void
 262 IOFilterInterruptEventSource::disableInterruptOccurred
 263 (void */*refcon*/, IOService *prov, int source)
 264 {
 265         bool        filterRes;
 266         uint64_t    startTime = 0;
 267         uint64_t    endTime = 0;
 268         bool    trace = (gIOKitTrace & kIOTraceIntEventSource) ? true : false;
 269
 270         if (trace) {
 271                 IOTimeStampStartConstant(IODBG_INTES(IOINTES_FILTER),
 272                     VM_KERNEL_UNSLIDE(filterAction), VM_KERNEL_ADDRHIDE(owner), VM_KERNEL_ADDRHIDE(this), VM_KERNEL_ADDRHIDE(workLoop));
 273         }
 274
 275         if (IOInterruptEventSource::reserved->statistics) {
 276                 if (IA_GET_STATISTIC_ENABLED(kInterruptAccountingFirstLevelTimeIndex)
 277                     || IOInterruptEventSource::reserved->statistics->enablePrimaryTimestamp) {
 278                         startTime = mach_absolute_time();
 279                 }
 280                 if (IOInterruptEventSource::reserved->statistics->enablePrimaryTimestamp) {
 281                         IOInterruptEventSource::reserved->statistics->primaryTimestamp = startTime;
 282                 }
 283         }
 284
 285         // Call the filter.
 286         if (kFilterBlock & flags) {
 287                 filterRes = (filterActionBlock)(this);
 288         } else {
 289                 filterRes = (*filterAction)(owner, this);
 290         }
 291
 292         if (IOInterruptEventSource::reserved->statistics) {
 293                 if (IA_GET_STATISTIC_ENABLED(kInterruptAccountingFirstLevelCountIndex)) {
 294                         IA_ADD_VALUE(&IOInterruptEventSource::reserved->statistics->interruptStatistics[kInterruptAccountingFirstLevelCountIndex], 1);
 295                 }
 296
 297                 if (IA_GET_STATISTIC_ENABLED(kInterruptAccountingFirstLevelTimeIndex)) {
 298                         endTime = mach_absolute_time();
 299                         IA_ADD_VALUE(&IOInterruptEventSource::reserved->statistics->interruptStatistics[kInterruptAccountingFirstLevelTimeIndex], endTime - startTime);
 300                 }
 301         }
 302
 303         if (trace) {
 304                 IOTimeStampEndConstant(IODBG_INTES(IOINTES_FILTER),
 305                     VM_KERNEL_UNSLIDE(filterAction), VM_KERNEL_ADDRHIDE(owner), VM_KERNEL_ADDRHIDE(this), VM_KERNEL_ADDRHIDE(workLoop));
 306         }
 307
 308         if (filterRes) {
 309                 prov->disableInterrupt(source); /* disable the interrupt */
 310                 signalInterrupt();
 311         }
 312 }