Loading...
--- xnu/xnu-12377.121.6/iokit/Kernel/IOPerfControl.cpp
+++ xnu/xnu-6153.121.1/iokit/Kernel/IOPerfControl.cpp
@@ -7,9 +7,6 @@
#include <stdatomic.h>
#include <kern/thread_group.h>
-#include <kern/task.h>
-#include <sys/coalition.h>
-#include <kern/coalition.h>
#undef super
#define super OSObject
@@ -32,7 +29,7 @@
shared = atomic_load_explicit(&gIOPerfControlClientShared, memory_order_acquire);
if (shared == nullptr) {
IOPerfControlClient::IOPerfControlClientShared *expected = shared;
- shared = kalloc_type(IOPerfControlClientShared, Z_WAITOK);
+ shared = reinterpret_cast<IOPerfControlClient::IOPerfControlClientShared*>(kalloc(sizeof(IOPerfControlClientShared)));
if (!shared) {
return false;
}
@@ -40,7 +37,7 @@
atomic_init(&shared->maxDriverIndex, 0);
shared->interface = PerfControllerInterface{
- .version = PERFCONTROL_INTERFACE_VERSION_NONE,
+ .version = 0,
.registerDevice =
[](IOService *device) {
return kIOReturnSuccess;
@@ -62,9 +59,6 @@
.workEnd =
[](IOService *device, uint64_t token, PerfControllerInterface::WorkState *state, WorkEndArgs *args, bool done) {
},
- .workUpdate =
- [](IOService *device, uint64_t token, PerfControllerInterface::WorkState *state, WorkUpdateArgs *args) {
- },
};
shared->interfaceLock = IOLockAlloc();
@@ -81,24 +75,23 @@
memory_order_acquire)) {
IOLockFree(shared->interfaceLock);
shared->deviceRegistrationList->release();
- kfree_type(IOPerfControlClientShared, shared);
+ kfree(shared, sizeof(*shared));
shared = expected;
}
}
- workTable = NULL;
- workTableLock = NULL;
-
- // Note: driverIndex is not guaranteed to be unique if maxDriverIndex wraps around. It is intended for debugging only.
+
driverIndex = atomic_fetch_add_explicit(&shared->maxDriverIndex, 1, memory_order_relaxed) + 1;
+ assertf(driverIndex != 0, "Overflow in driverIndex. Too many IOPerfControlClients created.\n");
// + 1 since index 0 is unused for kIOPerfControlClientWorkUntracked
workTableLength = maxWorkCapacity + 1;
assertf(workTableLength <= kWorkTableMaxSize, "%zu exceeds max allowed capacity of %zu", workTableLength, kWorkTableMaxSize);
if (maxWorkCapacity > 0) {
- workTable = kalloc_type(WorkTableEntry, workTableLength, Z_WAITOK_ZERO);
+ workTable = reinterpret_cast<WorkTableEntry*>(kalloc(workTableLength * sizeof(WorkTableEntry)));
if (!workTable) {
goto error;
}
+ bzero(workTable, workTableLength * sizeof(WorkTableEntry));
workTableNextIndex = 1;
workTableLock = IOSimpleLockAlloc();
@@ -107,18 +100,14 @@
}
}
- bzero(&clientData, sizeof(clientData));
-
return true;
error:
if (workTable) {
- kfree_type(WorkTableEntry, workTableLength, workTable);
- workTable = NULL;
+ kfree(workTable, maxWorkCapacity * sizeof(WorkTableEntry));
}
if (workTableLock) {
IOSimpleLockFree(workTableLock);
- workTableLock = NULL;
}
return false;
shared_init_error:
@@ -129,54 +118,20 @@
if (shared->deviceRegistrationList) {
shared->deviceRegistrationList->release();
}
- kfree_type(IOPerfControlClientShared, shared);
+ kfree(shared, sizeof(*shared));
shared = nullptr;
}
return false;
}
-void
-IOPerfControlClient::free()
-{
- if (workTable) {
- kfree_type(WorkTableEntry, workTableLength, workTable);
- }
- if (workTableLock) {
- IOSimpleLockFree(workTableLock);
- }
- super::free();
-}
-
-void
-IOPerfControlClient::setDeviceType(IOPCDeviceType newDeviceType)
-{
- if (newDeviceType >= IOPCDeviceTypeMax) {
- panic("unknown device type %d", newDeviceType);
- }
-
- if (deviceType != IOPCDeviceTypeUnknown) {
- panic("deviceType already set to %d", deviceType);
- }
-
- deviceType = newDeviceType;
-}
-
-
IOPerfControlClient *
-IOPerfControlClient::copyClientForDeviceType(IOService *driver, uint64_t maxWorkCapacity, IOPCDeviceType deviceType)
+IOPerfControlClient::copyClient(IOService *driver, uint64_t maxWorkCapacity)
{
IOPerfControlClient *client = new IOPerfControlClient;
if (!client || !client->init(driver, maxWorkCapacity)) {
panic("could not create IOPerfControlClient");
}
- client->setDeviceType(deviceType);
return client;
-}
-
-IOPerfControlClient *
-IOPerfControlClient::copyClient(IOService *driver, uint64_t maxWorkCapacity)
-{
- return copyClientForDeviceType(driver, maxWorkCapacity, IOPCDeviceTypeUnknown);
}
/* Convert the per driver token into a globally unique token for the performance
@@ -192,26 +147,6 @@
return token | (static_cast<uint64_t>(driverIndex) << kWorkTableIndexBits);
}
-/* Accounting resources used in a work item to the containing coalition.
- * Contigent upon the PerfController signaling that it wants resource accounting
- * in the registerDevice()/registerDriverDevice calls. More device types can
- * be added here in the future.
- */
-void
-IOPerfControlClient::accountResources(coalition_t coal, PerfControllerInterface::PerfDeviceID device_type, PerfControllerInterface::ResourceAccounting *resources)
-{
- switch (device_type) {
- case PerfControllerInterface::PerfDeviceID::kANE:
- if (coal != nullptr) {
- coalition_update_ane_stats(coal, resources->mach_time_delta, resources->energy_nj_delta);
- }
- break;
-
- default:
- assertf(false, "Unexpected device type for IOPerfControlClient::accountResources: %llu", static_cast<uint64_t>(device_type));
- }
-}
-
/* With this implementation, tokens returned to the driver differ from tokens
* passed to the performance controller. This implementation has the nice
* property that tokens returns to the driver will aways be between 1 and
@@ -224,90 +159,30 @@
{
uint64_t token = kIOPerfControlClientWorkUntracked;
-#if CONFIG_THREAD_GROUPS
- auto s = IOSimpleLockLockDisableInterrupt(workTableLock);
-
- uint64_t num_tries = 0;
- size_t index = workTableNextIndex;
- // - 1 since entry 0 is for kIOPerfControlClientWorkUntracked
- while (num_tries < workTableLength - 1) {
- if (workTable[index].thread_group == nullptr) {
- thread_group_retain(thread_group);
- workTable[index].thread_group = thread_group;
- if (clientData.driverState.resource_accounting) {
- auto *coalition = task_get_coalition(current_task(), COALITION_TYPE_RESOURCE);
- assert(coalition != nullptr);
- coalition_retain(coalition);
- workTable[index].coal = coalition;
- }
- token = index;
- // next integer between 1 and workTableLength - 1
- workTableNextIndex = (index % (workTableLength - 1)) + 1;
- break;
- }
- // next integer between 1 and workTableLength - 1
- index = (index % (workTableLength - 1)) + 1;
- num_tries += 1;
- }
-#if (DEVELOPMENT || DEBUG)
+
+ return token;
+}
+
+void
+IOPerfControlClient::deallocateToken(uint64_t token)
+{
+}
+
+bool
+IOPerfControlClient::getEntryForToken(uint64_t token, IOPerfControlClient::WorkTableEntry &entry)
+{
if (token == kIOPerfControlClientWorkUntracked) {
- /* When investigating a panic here, first check that the driver is not leaking tokens.
- * If the driver is not leaking tokens and maximum is less than kMaxWorkTableNumEntries,
- * the driver should be modified to pass a larger value to copyClient.
- * If the driver is not leaking tokens and maximum is equal to kMaxWorkTableNumEntries,
- * this code will have to be modified to support dynamic table growth to support larger
- * numbers of tokens.
- */
- panic("Tokens allocated for this device exceeded maximum of %zu.",
- workTableLength - 1); // - 1 since entry 0 is for kIOPerfControlClientWorkUntracked
- }
-#endif
-
- IOSimpleLockUnlockEnableInterrupt(workTableLock, s);
-#endif
-
- return token;
-}
-
-void
-IOPerfControlClient::deallocateToken(uint64_t token)
-{
-#if CONFIG_THREAD_GROUPS
- assertf(token != kIOPerfControlClientWorkUntracked, "Attempt to deallocate token kIOPerfControlClientWorkUntracked\n");
- assertf(token <= workTableLength, "Attempt to deallocate token %llu which is greater than the table size of %zu\n", token, workTableLength);
- auto s = IOSimpleLockLockDisableInterrupt(workTableLock);
-
- auto &entry = workTable[token];
- auto *thread_group = entry.thread_group;
- auto *coal = entry.coal;
- bzero(&entry, sizeof(entry));
- workTableNextIndex = token;
-
- IOSimpleLockUnlockEnableInterrupt(workTableLock, s);
-
- // This can call into the performance controller if the last reference is dropped here. Are we sure
- // the driver isn't holding any locks? If not, we may want to async this to another context.
- thread_group_release(thread_group);
- if (coal != nullptr) {
- coalition_release(coal);
- }
-#endif
-}
-
-IOPerfControlClient::WorkTableEntry *
-IOPerfControlClient::getEntryForToken(uint64_t token)
-{
- if (token == kIOPerfControlClientWorkUntracked) {
- return nullptr;
+ return false;
}
if (token >= workTableLength) {
panic("Invalid work token (%llu): index out of bounds.", token);
}
- WorkTableEntry *entry = &workTable[token];
- assertf(entry->thread_group, "Invalid work token: %llu", token);
- return entry;
+ entry = workTable[token];
+ auto *thread_group = entry.thread_group;
+ assertf(thread_group, "Invalid work token: %llu", token);
+ return thread_group != nullptr;
}
void
@@ -324,548 +199,81 @@
workTable[token].started = started;
}
-#if CONFIG_THREAD_GROUPS
-
-static struct thread_group *
-threadGroupForDextService(IOService *device)
-{
- assert(device);
-
- if (!device->hasUserServer()) {
- return NULL;
- }
-
- // Devices associated with a dext driver, must be called from dext
- // context to ensure that thread_group reference is valid.
- thread_t thread = current_thread();
- assert(get_threadtask(thread) != kernel_task);
- struct thread_group * thread_group = thread_group_get(thread);
- assert(thread_group != nullptr);
- return thread_group;
-}
-
-#endif /* CONFIG_THREAD_GROUPS */
-
IOReturn
-IOPerfControlClient::registerDevice(IOService *driver, IOService *device)
+IOPerfControlClient::registerDevice(__unused IOService *driver, IOService *device)
{
IOReturn ret = kIOReturnSuccess;
-#if CONFIG_THREAD_GROUPS
+
IOLockLock(shared->interfaceLock);
- clientData.device = device;
-
- if (device) {
- struct thread_group *dext_thread_group = threadGroupForDextService(device);
- if (dext_thread_group) {
- if (clientData.driverState.has_target_thread_group) {
- panic("driverState has already been initialized");
- }
- clientData.driverState.has_target_thread_group = true;
- clientData.driverState.target_thread_group_id = thread_group_get_id(dext_thread_group);
- clientData.driverState.target_thread_group_data = thread_group_get_machine_data(dext_thread_group);
-
- clientData.target_thread_group = dext_thread_group;
- thread_group_retain(dext_thread_group);
- }
- }
-
- if (shared->interface.version >= PERFCONTROL_INTERFACE_VERSION_3) {
- ret = shared->interface.registerDriverDevice(driver, device, &clientData.driverState);
- } else if (shared->interface.version >= PERFCONTROL_INTERFACE_VERSION_1) {
+ if (shared->interface.version > 0) {
ret = shared->interface.registerDevice(device);
} else {
- shared->deviceRegistrationList->setObject(this);
+ shared->deviceRegistrationList->setObject(device);
}
IOLockUnlock(shared->interfaceLock);
-#endif
+
return ret;
}
void
-IOPerfControlClient::unregisterDevice(IOService *driver, IOService *device)
-{
-#if CONFIG_THREAD_GROUPS
+IOPerfControlClient::unregisterDevice(__unused IOService *driver, IOService *device)
+{
IOLockLock(shared->interfaceLock);
- if (shared->interface.version >= PERFCONTROL_INTERFACE_VERSION_3) {
- shared->interface.unregisterDriverDevice(driver, device, &clientData.driverState);
- } else if (shared->interface.version >= PERFCONTROL_INTERFACE_VERSION_1) {
+ if (shared->interface.version > 0) {
shared->interface.unregisterDevice(device);
} else {
- shared->deviceRegistrationList->removeObject(this);
- }
-
- if (clientData.driverState.has_target_thread_group) {
- thread_group_release(clientData.target_thread_group);
- clientData.target_thread_group = nullptr;
-
- clientData.driverState.has_target_thread_group = false;
- clientData.driverState.target_thread_group_id = ~0ull;
- clientData.driverState.target_thread_group_data = nullptr;
- }
-
- clientData.device = nullptr;
+ shared->deviceRegistrationList->removeObject(device);
+ }
IOLockUnlock(shared->interfaceLock);
-#endif
}
uint64_t
IOPerfControlClient::workSubmit(IOService *device, WorkSubmitArgs *args)
{
-#if CONFIG_THREAD_GROUPS
- auto *thread_group = thread_group_get(current_thread());
- if (!thread_group) {
- return kIOPerfControlClientWorkUntracked;
- }
-
- PerfControllerInterface::WorkState state{
- .thread_group_id = thread_group_get_id(thread_group),
- .thread_group_data = thread_group_get_machine_data(thread_group),
- .work_data = nullptr,
- .work_data_size = 0,
- .started = false,
- .driver_state = &clientData.driverState
- };
- if (!shared->interface.workCanSubmit(device, &state, args)) {
- return kIOPerfControlClientWorkUntracked;
- }
-
- uint64_t token = allocateToken(thread_group);
- if (token != kIOPerfControlClientWorkUntracked) {
- state.work_data = &workTable[token].perfcontrol_data;
- state.work_data_size = sizeof(workTable[token].perfcontrol_data);
- shared->interface.workSubmit(device, tokenToGlobalUniqueToken(token), &state, args);
- }
- return token;
-#else
return kIOPerfControlClientWorkUntracked;
-#endif
}
uint64_t
IOPerfControlClient::workSubmitAndBegin(IOService *device, WorkSubmitArgs *submitArgs, WorkBeginArgs *beginArgs)
{
-#if CONFIG_THREAD_GROUPS
- auto *thread_group = thread_group_get(current_thread());
- if (!thread_group) {
- return kIOPerfControlClientWorkUntracked;
- }
-
- PerfControllerInterface::WorkState state{
- .thread_group_id = thread_group_get_id(thread_group),
- .thread_group_data = thread_group_get_machine_data(thread_group),
- .work_data = nullptr,
- .work_data_size = 0,
- .started = false,
- .driver_state = &clientData.driverState
- };
- if (!shared->interface.workCanSubmit(device, &state, submitArgs)) {
- return kIOPerfControlClientWorkUntracked;
- }
-
- uint64_t token = allocateToken(thread_group);
- if (token != kIOPerfControlClientWorkUntracked) {
- auto &entry = workTable[token];
- state.work_data = &entry.perfcontrol_data;
- state.work_data_size = sizeof(workTable[token].perfcontrol_data);
- shared->interface.workSubmit(device, tokenToGlobalUniqueToken(token), &state, submitArgs);
- state.started = true;
- shared->interface.workBegin(device, tokenToGlobalUniqueToken(token), &state, beginArgs);
- markEntryStarted(token, true);
- }
- return token;
-#else
return kIOPerfControlClientWorkUntracked;
-#endif
}
void
IOPerfControlClient::workBegin(IOService *device, uint64_t token, WorkBeginArgs *args)
{
-#if CONFIG_THREAD_GROUPS
- WorkTableEntry *entry = getEntryForToken(token);
- if (entry == nullptr) {
- return;
- }
-
- assertf(!entry->started, "Work for token %llu was already started", token);
-
- PerfControllerInterface::WorkState state{
- .thread_group_id = thread_group_get_id(entry->thread_group),
- .thread_group_data = thread_group_get_machine_data(entry->thread_group),
- .work_data = &entry->perfcontrol_data,
- .work_data_size = sizeof(entry->perfcontrol_data),
- .started = true,
- .driver_state = &clientData.driverState
- };
- shared->interface.workBegin(device, tokenToGlobalUniqueToken(token), &state, args);
- markEntryStarted(token, true);
-#endif
}
void
IOPerfControlClient::workEnd(IOService *device, uint64_t token, WorkEndArgs *args, bool done)
{
-#if CONFIG_THREAD_GROUPS
- WorkTableEntry *entry = getEntryForToken(token);
- if (entry == nullptr) {
- return;
- }
-
- PerfControllerInterface::WorkState state{
- .thread_group_id = thread_group_get_id(entry->thread_group),
- .thread_group_data = thread_group_get_machine_data(entry->thread_group),
- .work_data = &entry->perfcontrol_data,
- .work_data_size = sizeof(entry->perfcontrol_data),
- .started = entry->started,
- .driver_state = &clientData.driverState
- };
-
- if (shared->interface.version >= PERFCONTROL_INTERFACE_VERSION_4) {
- PerfControllerInterface::ResourceAccounting resources;
- shared->interface.workEndWithResources(device, tokenToGlobalUniqueToken(token), &state, args, &resources, done);
- if (clientData.driverState.resource_accounting) {
- accountResources(workTable[token].coal, clientData.driverState.device_type, &resources);
- }
- } else {
- shared->interface.workEnd(device, tokenToGlobalUniqueToken(token), &state, args, done);
- }
-
- if (done) {
- deallocateToken(token);
- } else {
- markEntryStarted(token, false);
- }
-#endif
-}
-
-static _Atomic uint64_t unique_work_context_id = 1ull;
-
-class IOPerfControlWorkContext : public OSObject
-{
- OSDeclareDefaultStructors(IOPerfControlWorkContext);
-
-public:
- uint64_t id;
- struct thread_group *thread_group;
- coalition_t coal;
- bool started;
- uint8_t perfcontrol_data[32];
-
- bool init() override;
- void reset();
- void free() override;
-};
-
-OSDefineMetaClassAndStructors(IOPerfControlWorkContext, OSObject);
-
-bool
-IOPerfControlWorkContext::init()
-{
- if (!super::init()) {
- return false;
- }
- id = atomic_fetch_add_explicit(&unique_work_context_id, 1, memory_order_relaxed) + 1;
- reset();
- return true;
-}
-
-void
-IOPerfControlWorkContext::reset()
-{
- thread_group = nullptr;
- coal = nullptr;
- started = false;
- bzero(perfcontrol_data, sizeof(perfcontrol_data));
-}
-
-void
-IOPerfControlWorkContext::free()
-{
- assertf(thread_group == nullptr, "IOPerfControlWorkContext ID %llu being released without calling workEnd!\n", id);
- assertf(coal == nullptr, "IOPerfControlWorkContext ID %llu being released without calling workEnd!\n", id);
- super::free();
-}
-
-OSObject *
-IOPerfControlClient::copyWorkContext()
-{
- IOPerfControlWorkContext *context = new IOPerfControlWorkContext;
-
- if (context == nullptr) {
- return nullptr;
- }
-
- if (!context->init()) {
- context->free();
- return nullptr;
- }
-
- return context;
-}
-
-bool
-IOPerfControlClient::workSubmitAndBeginWithContext(IOService *device, OSObject *context, WorkSubmitArgs *submitArgs, WorkBeginArgs *beginArgs)
-{
-#if CONFIG_THREAD_GROUPS
-
- if (workSubmitWithContext(device, context, submitArgs) == false) {
- return false;
- }
-
- IOPerfControlWorkContext *work_context = OSDynamicCast(IOPerfControlWorkContext, context);
-
- PerfControllerInterface::WorkState state{
- .thread_group_id = thread_group_get_id(work_context->thread_group),
- .thread_group_data = thread_group_get_machine_data(work_context->thread_group),
- .work_data = &work_context->perfcontrol_data,
- .work_data_size = sizeof(work_context->perfcontrol_data),
- .started = true,
- .driver_state = &clientData.driverState
- };
-
- shared->interface.workBegin(device, work_context->id, &state, beginArgs);
-
- work_context->started = true;
-
- return true;
-#else
- return false;
-#endif
-}
-
-bool
-IOPerfControlClient::workSubmitWithContext(IOService *device, OSObject *context, WorkSubmitArgs *args)
-{
-#if CONFIG_THREAD_GROUPS
- IOPerfControlWorkContext *work_context = OSDynamicCast(IOPerfControlWorkContext, context);
-
- if (work_context == nullptr) {
- return false;
- }
-
- auto *thread_group = thread_group_get(current_thread());
- assert(thread_group != nullptr);
-
- assertf(!work_context->started, "IOPerfControlWorkContext ID %llu was already started", work_context->id);
- assertf(work_context->thread_group == nullptr, "IOPerfControlWorkContext ID %llu has already taken a refcount on TG 0x%p \n", work_context->id, (void *)(work_context->thread_group));
-
- PerfControllerInterface::WorkState state{
- .thread_group_id = thread_group_get_id(thread_group),
- .thread_group_data = thread_group_get_machine_data(thread_group),
- .work_data = nullptr,
- .work_data_size = 0,
- .started = false,
- .driver_state = &clientData.driverState
- };
- if (!shared->interface.workCanSubmit(device, &state, args)) {
- return false;
- }
-
- work_context->thread_group = thread_group_retain(thread_group);
- if (clientData.driverState.resource_accounting) {
- auto *coalition = task_get_coalition(current_task(), COALITION_TYPE_RESOURCE);
- assert(coalition != nullptr);
- work_context->coal = coalition;
- coalition_retain(coalition);
- }
-
- state.work_data = &work_context->perfcontrol_data;
- state.work_data_size = sizeof(work_context->perfcontrol_data);
-
- shared->interface.workSubmit(device, work_context->id, &state, args);
-
- return true;
-#else
- return false;
-#endif
-}
-
-void
-IOPerfControlClient::workUpdateWithContext(IOService *device, OSObject *context, WorkUpdateArgs *args)
-{
-#if CONFIG_THREAD_GROUPS
- IOPerfControlWorkContext *work_context = OSDynamicCast(IOPerfControlWorkContext, context);
-
- if (work_context == nullptr) {
- return;
- }
-
- if (work_context->thread_group == nullptr) {
- // This Work Context has not taken a refcount on a TG
- return;
- }
-
- PerfControllerInterface::WorkState state{
- .thread_group_id = thread_group_get_id(work_context->thread_group),
- .thread_group_data = thread_group_get_machine_data(work_context->thread_group),
- .work_data = &work_context->perfcontrol_data,
- .work_data_size = sizeof(work_context->perfcontrol_data),
- .driver_state = &clientData.driverState
- };
- shared->interface.workUpdate(device, work_context->id, &state, args);
-#endif
-}
-
-void
-IOPerfControlClient::workBeginWithContext(IOService *device, OSObject *context, WorkBeginArgs *args)
-{
-#if CONFIG_THREAD_GROUPS
- IOPerfControlWorkContext *work_context = OSDynamicCast(IOPerfControlWorkContext, context);
-
- if (work_context == nullptr) {
- return;
- }
-
- if (work_context->thread_group == nullptr) {
- // This Work Context has not taken a refcount on a TG
- return;
- }
-
- assertf(!work_context->started, "IOPerfControlWorkContext %llu was already started", work_context->id);
-
- PerfControllerInterface::WorkState state{
- .thread_group_id = thread_group_get_id(work_context->thread_group),
- .thread_group_data = thread_group_get_machine_data(work_context->thread_group),
- .work_data = &work_context->perfcontrol_data,
- .work_data_size = sizeof(work_context->perfcontrol_data),
- .started = true,
- .driver_state = &clientData.driverState
- };
- shared->interface.workBegin(device, work_context->id, &state, args);
-
- work_context->started = true;
-#endif
-}
-
-void
-IOPerfControlClient::workEndWithContext(IOService *device, OSObject *context, WorkEndArgs *args, bool done)
-{
-#if CONFIG_THREAD_GROUPS
- IOPerfControlWorkContext *work_context = OSDynamicCast(IOPerfControlWorkContext, context);
-
- if (work_context == nullptr) {
- return;
- }
-
- if (work_context->thread_group == nullptr) {
- return;
- }
-
- PerfControllerInterface::WorkState state{
- .thread_group_id = thread_group_get_id(work_context->thread_group),
- .thread_group_data = thread_group_get_machine_data(work_context->thread_group),
- .work_data = &work_context->perfcontrol_data,
- .work_data_size = sizeof(work_context->perfcontrol_data),
- .started = work_context->started,
- .driver_state = &clientData.driverState
- };
-
- if (shared->interface.version >= PERFCONTROL_INTERFACE_VERSION_4) {
- PerfControllerInterface::ResourceAccounting resources;
- shared->interface.workEndWithResources(device, work_context->id, &state, args, &resources, done);
- if (clientData.driverState.resource_accounting) {
- accountResources(work_context->coal, clientData.driverState.device_type, &resources);
- }
- } else {
- shared->interface.workEnd(device, work_context->id, &state, args, done);
- }
-
- if (done) {
- thread_group_release(work_context->thread_group);
- if (work_context->coal != nullptr) {
- coalition_release(work_context->coal);
- }
- work_context->reset();
- } else {
- work_context->started = false;
- }
-
- return;
-#else
- return;
-#endif
}
IOReturn
-IOPerfControlClient::querySubmitterRole(IOService *device, task_t clientTask, uint32_t* role_out)
-{
- IOReturn result = kIOReturnNotFound;
-
- uint32_t role;
-
- switch (deviceType) {
- case IOPCDeviceTypeGPU:
- role = task_get_gpu_role(clientTask);
-
- KDBG(IMPORTANCE_CODE(IMP_QUERY_GPU_ROLE, 0), role);
-
- *role_out = role;
-
- result = kIOReturnSuccess;
- break;
- default:
- result = kIOReturnNotFound;
- }
-
- return result;
-}
-
-IOReturn
-IOPerfControlClient::registerPerformanceController(PerfControllerInterface *pci)
+IOPerfControlClient::registerPerformanceController(PerfControllerInterface pci)
{
IOReturn result = kIOReturnError;
IOLockLock(shared->interfaceLock);
- if (shared->interface.version == PERFCONTROL_INTERFACE_VERSION_NONE) {
- shared->interface.version = pci->version;
-
- if (pci->version >= PERFCONTROL_INTERFACE_VERSION_1) {
- assert(pci->registerDevice && pci->unregisterDevice && pci->workCanSubmit && pci->workSubmit && pci->workBegin && pci->workEnd);
- shared->interface.registerDevice = pci->registerDevice;
- shared->interface.unregisterDevice = pci->unregisterDevice;
- shared->interface.workCanSubmit = pci->workCanSubmit;
- shared->interface.workSubmit = pci->workSubmit;
- shared->interface.workBegin = pci->workBegin;
- shared->interface.workEnd = pci->workEnd;
- }
-
- if (pci->version >= PERFCONTROL_INTERFACE_VERSION_2) {
- if (pci->workUpdate != nullptr) {
- shared->interface.workUpdate = pci->workUpdate;
- }
- }
-
- if (pci->version >= PERFCONTROL_INTERFACE_VERSION_3) {
- assert(pci->registerDriverDevice && pci->unregisterDriverDevice);
- shared->interface.registerDriverDevice = pci->registerDriverDevice;
- shared->interface.unregisterDriverDevice = pci->unregisterDriverDevice;
- }
-
- if (pci->version >= PERFCONTROL_INTERFACE_VERSION_4) {
- assert(pci->workEndWithResources);
- shared->interface.workEndWithResources = pci->workEndWithResources;
- }
-
+ if (shared->interface.version == 0 && pci.version > 0) {
+ assert(pci.registerDevice && pci.unregisterDevice && pci.workCanSubmit && pci.workSubmit && pci.workBegin && pci.workEnd);
result = kIOReturnSuccess;
OSObject *obj;
while ((obj = shared->deviceRegistrationList->getAnyObject())) {
- IOPerfControlClient *client = OSDynamicCast(IOPerfControlClient, obj);
- IOPerfControlClientData *clientData = client->getClientData();
- if (clientData && clientData->device) {
- if (pci->version >= PERFCONTROL_INTERFACE_VERSION_3) {
- pci->registerDriverDevice(clientData->device->getProvider(), clientData->device, &(clientData->driverState));
- } else if (pci->version >= PERFCONTROL_INTERFACE_VERSION_1) {
- pci->registerDevice(clientData->device);
- }
+ IOService *device = OSDynamicCast(IOService, obj);
+ if (device) {
+ pci.registerDevice(device);
}
shared->deviceRegistrationList->removeObject(obj);
}
+
+ shared->interface = pci;
}
IOLockUnlock(shared->interfaceLock);