+
+/*
+ * Control the CPU usage monitor for a task.
+ */
+kern_return_t
+task_cpu_usage_monitor_ctl(task_t task, uint32_t *flags)
+{
+ int error = KERN_SUCCESS;
+
+ if (*flags & CPUMON_MAKE_FATAL) {
+ task->rusage_cpu_flags |= TASK_RUSECPU_FLAGS_FATAL_CPUMON;
+ } else {
+ error = KERN_INVALID_ARGUMENT;
+ }
+
+ return error;
+}
+
+/*
+ * Control the wakeups monitor for a task.
+ */
+kern_return_t
+task_wakeups_monitor_ctl(task_t task, uint32_t *flags, int32_t *rate_hz)
+{
+ ledger_t ledger = task->ledger;
+
+ task_lock(task);
+ if (*flags & WAKEMON_GET_PARAMS) {
+ ledger_amount_t limit;
+ uint64_t period;
+
+ ledger_get_limit(ledger, task_ledgers.interrupt_wakeups, &limit);
+ ledger_get_period(ledger, task_ledgers.interrupt_wakeups, &period);
+
+ if (limit != LEDGER_LIMIT_INFINITY) {
+ /*
+ * An active limit means the wakeups monitor is enabled.
+ */
+ *rate_hz = (int32_t)(limit / (int64_t)(period / NSEC_PER_SEC));
+ *flags = WAKEMON_ENABLE;
+ if (task->rusage_cpu_flags & TASK_RUSECPU_FLAGS_FATAL_WAKEUPSMON) {
+ *flags |= WAKEMON_MAKE_FATAL;
+ }
+ } else {
+ *flags = WAKEMON_DISABLE;
+ *rate_hz = -1;
+ }
+
+ /*
+ * If WAKEMON_GET_PARAMS is present in flags, all other flags are ignored.
+ */
+ task_unlock(task);
+ return KERN_SUCCESS;
+ }
+
+ if (*flags & WAKEMON_ENABLE) {
+ if (*flags & WAKEMON_SET_DEFAULTS) {
+ *rate_hz = task_wakeups_monitor_rate;
+ }
+
+#ifndef CONFIG_NOMONITORS
+ if (*flags & WAKEMON_MAKE_FATAL) {
+ task->rusage_cpu_flags |= TASK_RUSECPU_FLAGS_FATAL_WAKEUPSMON;
+ }
+#endif /* CONFIG_NOMONITORS */
+
+ if (*rate_hz < 0) {
+ task_unlock(task);
+ return KERN_INVALID_ARGUMENT;
+ }
+
+#ifndef CONFIG_NOMONITORS
+ ledger_set_limit(ledger, task_ledgers.interrupt_wakeups, *rate_hz * task_wakeups_monitor_interval,
+ task_wakeups_monitor_ustackshots_trigger_pct);
+ ledger_set_period(ledger, task_ledgers.interrupt_wakeups, task_wakeups_monitor_interval * NSEC_PER_SEC);
+ ledger_enable_callback(ledger, task_ledgers.interrupt_wakeups);
+#endif /* CONFIG_NOMONITORS */
+ } else if (*flags & WAKEMON_DISABLE) {
+ /*
+ * Caller wishes to disable wakeups monitor on the task.
+ *
+ * Disable telemetry if it was triggered by the wakeups monitor, and
+ * remove the limit & callback on the wakeups ledger entry.
+ */
+#if CONFIG_TELEMETRY
+ telemetry_task_ctl_locked(current_task(), TF_WAKEMON_WARNING, 0);
+#endif
+ ledger_disable_refill(ledger, task_ledgers.interrupt_wakeups);
+ ledger_disable_callback(ledger, task_ledgers.interrupt_wakeups);
+ }
+
+ task_unlock(task);
+ return KERN_SUCCESS;
+}
+
+void
+task_wakeups_rate_exceeded(int warning, __unused const void *param0, __unused const void *param1)
+{
+ if (warning == LEDGER_WARNING_ROSE_ABOVE) {
+#if CONFIG_TELEMETRY
+ /*
+ * This task is in danger of violating the wakeups monitor. Enable telemetry on this task
+ * so there are micro-stackshots available if and when EXC_RESOURCE is triggered.
+ */
+ telemetry_task_ctl(current_task(), TF_WAKEMON_WARNING, 1);
+#endif
+ return;
+ }
+
+#if CONFIG_TELEMETRY
+ /*
+ * If the balance has dipped below the warning level (LEDGER_WARNING_DIPPED_BELOW) or
+ * exceeded the limit, turn telemetry off for the task.
+ */
+ telemetry_task_ctl(current_task(), TF_WAKEMON_WARNING, 0);
+#endif
+
+ if (warning == 0) {
+ THIS_PROCESS_IS_CAUSING_TOO_MANY_WAKEUPS__SENDING_EXC_RESOURCE();
+ }
+}
+
+void __attribute__((noinline))
+THIS_PROCESS_IS_CAUSING_TOO_MANY_WAKEUPS__SENDING_EXC_RESOURCE(void)
+{
+ task_t task = current_task();
+ int pid = 0;
+ char *procname = (char *) "unknown";
+ uint64_t observed_wakeups_rate;
+ uint64_t permitted_wakeups_rate;
+ uint64_t observation_interval;
+ mach_exception_data_type_t code[EXCEPTION_CODE_MAX];
+ struct ledger_entry_info lei;
+
+#ifdef MACH_BSD
+ pid = proc_selfpid();
+ if (task->bsd_info != NULL)
+ procname = proc_name_address(current_task()->bsd_info);
+#endif
+
+ ledger_get_entry_info(task->ledger, task_ledgers.interrupt_wakeups, &lei);
+
+ /*
+ * Disable the exception notification so we don't overwhelm
+ * the listener with an endless stream of redundant exceptions.
+ */
+ uint32_t flags = WAKEMON_DISABLE;
+ task_wakeups_monitor_ctl(task, &flags, NULL);
+
+ observed_wakeups_rate = (lei.lei_balance * (int64_t)NSEC_PER_SEC) / lei.lei_last_refill;
+ permitted_wakeups_rate = lei.lei_limit / task_wakeups_monitor_interval;
+ observation_interval = lei.lei_refill_period / NSEC_PER_SEC;
+
+ if (disable_exc_resource) {
+ printf("process %s[%d] caught causing excessive wakeups. EXC_RESOURCE "
+ "supressed by a boot-arg\n", procname, pid);
+ return;
+ }
+ if (audio_active) {
+ printf("process %s[%d] caught causing excessive wakeups. EXC_RESOURCE "
+ "supressed due to audio playback\n", procname, pid);
+ return;
+ }
+ printf("process %s[%d] caught causing excessive wakeups. Observed wakeups rate "
+ "(per sec): %lld; Maximum permitted wakeups rate (per sec): %lld; Observation "
+ "period: %lld seconds; Task lifetime number of wakeups: %lld\n",
+ procname, pid, observed_wakeups_rate, permitted_wakeups_rate,
+ observation_interval, lei.lei_credit);
+
+ code[0] = code[1] = 0;
+ EXC_RESOURCE_ENCODE_TYPE(code[0], RESOURCE_TYPE_WAKEUPS);
+ EXC_RESOURCE_ENCODE_FLAVOR(code[0], FLAVOR_WAKEUPS_MONITOR);
+ EXC_RESOURCE_CPUMONITOR_ENCODE_WAKEUPS_PERMITTED(code[0], task_wakeups_monitor_rate);
+ EXC_RESOURCE_CPUMONITOR_ENCODE_OBSERVATION_INTERVAL(code[0], observation_interval);
+ EXC_RESOURCE_CPUMONITOR_ENCODE_WAKEUPS_OBSERVED(code[1], lei.lei_balance * (int64_t)NSEC_PER_SEC / lei.lei_last_refill);
+ exception_triage(EXC_RESOURCE, code, EXCEPTION_CODE_MAX);
+
+ if (task->rusage_cpu_flags & TASK_RUSECPU_FLAGS_FATAL_WAKEUPSMON) {
+ task_terminate_internal(task);
+ }
+}
projects / apple / xnu.git / blobdiff