diff options
Diffstat (limited to 'toolkit/components/processtools/ProcInfo.mm')
| -rw-r--r-- | toolkit/components/processtools/ProcInfo.mm | 186 |
1 files changed, 186 insertions, 0 deletions
diff --git a/toolkit/components/processtools/ProcInfo.mm b/toolkit/components/processtools/ProcInfo.mm new file mode 100644 index 0000000000..6c98ce81f5 --- /dev/null +++ b/toolkit/components/processtools/ProcInfo.mm @@ -0,0 +1,186 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/ProcInfo.h" +#include "mozilla/ScopeExit.h" +#include "mozilla/ipc/GeckoChildProcessHost.h" + +#include "nsMemoryReporterManager.h" + +#include <cstdio> +#include <cstring> +#include <unistd.h> + +#include <libproc.h> +#include <sys/sysctl.h> +#include <mach/mach.h> +#include <mach/mach_time.h> + +static void GetTimeBase(mach_timebase_info_data_t* timebase) { + // Expected results are 125/3 on aarch64, and 1/1 on Intel CPUs. + if (mach_timebase_info(timebase) != KERN_SUCCESS) { + timebase->numer = 1; + timebase->denom = 1; + } +} + +namespace mozilla { + +nsresult GetCpuTimeSinceProcessStartInMs(uint64_t* aResult) { + struct proc_taskinfo pti; + if ((unsigned long)proc_pidinfo(getpid(), PROC_PIDTASKINFO, 0, &pti, + PROC_PIDTASKINFO_SIZE) < + PROC_PIDTASKINFO_SIZE) { + return NS_ERROR_FAILURE; + } + + mach_timebase_info_data_t timebase; + GetTimeBase(&timebase); + + *aResult = (pti.pti_total_user + pti.pti_total_system) * timebase.numer / + timebase.denom / PR_NSEC_PER_MSEC; + return NS_OK; +} + +nsresult GetGpuTimeSinceProcessStartInMs(uint64_t* aResult) { + task_power_info_v2_data_t task_power_info; + mach_msg_type_number_t count = TASK_POWER_INFO_V2_COUNT; + kern_return_t kr = task_info(mach_task_self(), TASK_POWER_INFO_V2, + (task_info_t)&task_power_info, &count); + if (kr != KERN_SUCCESS) { + return NS_ERROR_FAILURE; + } + + *aResult = task_power_info.gpu_energy.task_gpu_utilisation / PR_NSEC_PER_MSEC; + return NS_OK; +} + +int GetCycleTimeFrequencyMHz() { return 0; } + +ProcInfoPromise::ResolveOrRejectValue GetProcInfoSync( + nsTArray<ProcInfoRequest>&& aRequests) { + ProcInfoPromise::ResolveOrRejectValue result; + + HashMap<base::ProcessId, ProcInfo> gathered; + if (!gathered.reserve(aRequests.Length())) { + result.SetReject(NS_ERROR_OUT_OF_MEMORY); + return result; + } + + mach_timebase_info_data_t timebase; + GetTimeBase(&timebase); + + for (const auto& request : aRequests) { + ProcInfo info; + info.pid = request.pid; + info.childId = request.childId; + info.type = request.processType; + info.origin = std::move(request.origin); + info.windows = std::move(request.windowInfo); + info.utilityActors = std::move(request.utilityInfo); + + struct proc_taskinfo pti; + if ((unsigned long)proc_pidinfo(request.pid, PROC_PIDTASKINFO, 0, &pti, + PROC_PIDTASKINFO_SIZE) < + PROC_PIDTASKINFO_SIZE) { + // Can't read data for this process. + // Probably either a sandboxing issue or a race condition, e.g. + // the process has been just been killed. Regardless, skip process. + continue; + } + info.cpuTime = (pti.pti_total_user + pti.pti_total_system) * + timebase.numer / timebase.denom; + + mach_port_t selectedTask; + // If we did not get a task from a child process, we use mach_task_self() + if (request.childTask == MACH_PORT_NULL) { + selectedTask = mach_task_self(); + } else { + selectedTask = request.childTask; + } + + // The phys_footprint value (introduced in 10.11) of the TASK_VM_INFO data + // matches the value in the 'Memory' column of the Activity Monitor. + task_vm_info_data_t task_vm_info; + mach_msg_type_number_t count = TASK_VM_INFO_COUNT; + kern_return_t kr = task_info(selectedTask, TASK_VM_INFO, + (task_info_t)&task_vm_info, &count); + info.memory = kr == KERN_SUCCESS ? task_vm_info.phys_footprint : 0; + + // Now getting threads info + + // task_threads() gives us a snapshot of the process threads + // but those threads can go away. All the code below makes + // the assumption that thread_info() calls may fail, and + // these errors will be ignored. + thread_act_port_array_t threadList; + mach_msg_type_number_t threadCount; + kern_return_t kret = task_threads(selectedTask, &threadList, &threadCount); + if (kret != KERN_SUCCESS) { + // For some reason, we have no data on the threads for this process. + // Most likely reason is that we have just lost a race condition and + // the process is dead. + // Let's stop here and ignore the entire process. + continue; + } + + // Deallocate the thread list. + // Note that this deallocation is entirely undocumented, so the following + // code is based on guesswork and random examples found on the web. + auto guardThreadCount = MakeScopeExit([&] { + if (threadList == nullptr) { + return; + } + // Free each thread to avoid leaks. + for (mach_msg_type_number_t i = 0; i < threadCount; i++) { + mach_port_deallocate(mach_task_self(), threadList[i]); + } + vm_deallocate(mach_task_self(), /* address */ (vm_address_t)threadList, + /* size */ sizeof(thread_t) * threadCount); + }); + + for (mach_msg_type_number_t i = 0; i < threadCount; i++) { + // Basic thread info. + thread_extended_info_data_t threadInfoData; + count = THREAD_EXTENDED_INFO_COUNT; + kret = thread_info(threadList[i], THREAD_EXTENDED_INFO, + (thread_info_t)&threadInfoData, &count); + if (kret != KERN_SUCCESS) { + continue; + } + + // Getting the thread id. + thread_identifier_info identifierInfo; + count = THREAD_IDENTIFIER_INFO_COUNT; + kret = thread_info(threadList[i], THREAD_IDENTIFIER_INFO, + (thread_info_t)&identifierInfo, &count); + if (kret != KERN_SUCCESS) { + continue; + } + + // The two system calls were successful, let's add that thread + ThreadInfo* thread = info.threads.AppendElement(fallible); + if (!thread) { + result.SetReject(NS_ERROR_OUT_OF_MEMORY); + return result; + } + thread->cpuTime = + threadInfoData.pth_user_time + threadInfoData.pth_system_time; + thread->name.AssignASCII(threadInfoData.pth_name); + thread->tid = identifierInfo.thread_id; + } + + if (!gathered.put(request.pid, std::move(info))) { + result.SetReject(NS_ERROR_OUT_OF_MEMORY); + return result; + } + } + + result.SetResolve(std::move(gathered)); + return result; +} + +} // namespace mozilla |