diff options
Diffstat (limited to 'devtools/client/performance-new/shared/symbolication.jsm.js')
| -rw-r--r-- | devtools/client/performance-new/shared/symbolication.jsm.js | 364 |
1 files changed, 364 insertions, 0 deletions
diff --git a/devtools/client/performance-new/shared/symbolication.jsm.js b/devtools/client/performance-new/shared/symbolication.jsm.js new file mode 100644 index 0000000000..f79cffe6cb --- /dev/null +++ b/devtools/client/performance-new/shared/symbolication.jsm.js @@ -0,0 +1,364 @@ +/* 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/. */ +// @ts-check +"use strict"; + +/** @type {any} */ +const lazy = {}; + +/** + * @typedef {import("../@types/perf").Library} Library + * @typedef {import("../@types/perf").PerfFront} PerfFront + * @typedef {import("../@types/perf").SymbolTableAsTuple} SymbolTableAsTuple + * @typedef {import("../@types/perf").SymbolicationService} SymbolicationService + * @typedef {import("../@types/perf").SymbolicationWorkerInitialMessage} SymbolicationWorkerInitialMessage + */ + +/** + * @template R + * @typedef {import("../@types/perf").SymbolicationWorkerReplyData<R>} SymbolicationWorkerReplyData<R> + */ + +ChromeUtils.defineESModuleGetters(lazy, { + clearTimeout: "resource://gre/modules/Timer.sys.mjs", + setTimeout: "resource://gre/modules/Timer.sys.mjs", +}); + +/** @type {any} */ +const global = globalThis; + +// This module obtains symbol tables for binaries. +// It does so with the help of a WASM module which gets pulled in from the +// internet on demand. We're doing this purely for the purposes of saving on +// code size. The contents of the WASM module are expected to be static, they +// are checked against the hash specified below. +// The WASM code is run on a ChromeWorker thread. It takes the raw byte +// contents of the to-be-dumped binary (and of an additional optional pdb file +// on Windows) as its input, and returns a set of typed arrays which make up +// the symbol table. + +// Don't let the strange looking URLs and strings below scare you. +// The hash check ensures that the contents of the wasm module are what we +// expect them to be. +// The source code is at https://github.com/mstange/profiler-get-symbols/ . +// Documentation is at https://docs.rs/samply-api/ . +// The sha384 sum can be computed with the following command (tested on macOS): +// shasum -b -a 384 profiler_get_symbols_wasm_bg.wasm | awk '{ print $1 }' | xxd -r -p | base64 + +// Generated from https://github.com/mstange/profiler-get-symbols/commit/0373708893e45e8299e58ca692764be448e3457d +const WASM_MODULE_URL = + "https://storage.googleapis.com/firefox-profiler-get-symbols/0373708893e45e8299e58ca692764be448e3457d.wasm"; +const WASM_MODULE_INTEGRITY = + "sha384-rUGgHTg1eAKP2MB4JcX/HGROSBlRUmvpm6FFIihH0gGQ74zfJE2p7P8cxR86faQ7"; + +const EXPIRY_TIME_IN_MS = 5 * 60 * 1000; // 5 minutes + +/** @type {Promise<WebAssembly.Module> | null} */ +let gCachedWASMModulePromise = null; +let gCachedWASMModuleExpiryTimer = 0; + +// Keep active workers alive (see bug 1592227). +const gActiveWorkers = new Set(); + +function clearCachedWASMModule() { + gCachedWASMModulePromise = null; + gCachedWASMModuleExpiryTimer = 0; +} + +function getWASMProfilerGetSymbolsModule() { + if (!gCachedWASMModulePromise) { + gCachedWASMModulePromise = (async function () { + const request = new Request(WASM_MODULE_URL, { + integrity: WASM_MODULE_INTEGRITY, + credentials: "omit", + }); + return WebAssembly.compileStreaming(fetch(request)); + })(); + } + + // Reset expiry timer. + lazy.clearTimeout(gCachedWASMModuleExpiryTimer); + gCachedWASMModuleExpiryTimer = lazy.setTimeout( + clearCachedWASMModule, + EXPIRY_TIME_IN_MS + ); + + return gCachedWASMModulePromise; +} + +/** + * Handle the entire life cycle of a worker, and report its result. + * This method creates a new worker, sends the initial message to it, handles + * any errors, and accepts the result. + * Returns a promise that resolves with the contents of the (singular) result + * message or rejects with an error. + * + * @template M + * @template R + * @param {string} workerURL + * @param {M} initialMessageToWorker + * @returns {Promise<R>} + */ +async function getResultFromWorker(workerURL, initialMessageToWorker) { + return new Promise((resolve, reject) => { + const worker = new ChromeWorker(workerURL); + gActiveWorkers.add(worker); + + /** @param {MessageEvent<SymbolicationWorkerReplyData<R>>} msg */ + worker.onmessage = msg => { + gActiveWorkers.delete(worker); + if ("error" in msg.data) { + const error = msg.data.error; + if (error.name) { + // Turn the JSON error object into a real Error object. + const { name, message, fileName, lineNumber } = error; + const ErrorObjConstructor = + name in global && Error.isPrototypeOf(global[name]) + ? global[name] + : Error; + const e = new ErrorObjConstructor(message, fileName, lineNumber); + e.name = name; + reject(e); + } else { + reject(error); + } + return; + } + resolve(msg.data.result); + }; + + // Handle uncaught errors from the worker script. onerror is called if + // there's a syntax error in the worker script, for example, or when an + // unhandled exception is thrown, but not for unhandled promise + // rejections. Without this handler, mistakes during development such as + // syntax errors can be hard to track down. + worker.onerror = errorEvent => { + gActiveWorkers.delete(worker); + worker.terminate(); + if (ErrorEvent.isInstance(errorEvent)) { + const { message, filename, lineno } = errorEvent; + const error = new Error(`${message} at ${filename}:${lineno}`); + error.name = "WorkerError"; + reject(error); + } else { + reject(new Error("Error in worker")); + } + }; + + // Handle errors from messages that cannot be deserialized. I'm not sure + // how to get into such a state, but having this handler seems like a good + // idea. + worker.onmessageerror = () => { + gActiveWorkers.delete(worker); + worker.terminate(); + reject(new Error("Error in worker")); + }; + + worker.postMessage(initialMessageToWorker); + }); +} + +/** + * @param {PerfFront} perfFront + * @param {string} path + * @param {string} breakpadId + * @returns {Promise<SymbolTableAsTuple>} + */ +async function getSymbolTableFromDebuggee(perfFront, path, breakpadId) { + const [addresses, index, buffer] = await perfFront.getSymbolTable( + path, + breakpadId + ); + // The protocol transmits these arrays as plain JavaScript arrays of + // numbers, but we want to pass them on as typed arrays. Convert them now. + return [ + new Uint32Array(addresses), + new Uint32Array(index), + new Uint8Array(buffer), + ]; +} + +/** + * Profiling through the DevTools remote debugging protocol supports multiple + * different modes. This class is specialized to handle various profiling + * modes such as: + * + * 1) Profiling the same browser on the same machine. + * 2) Profiling a remote browser on the same machine. + * 3) Profiling a remote browser on a different device. + * + * It's also built to handle symbolication requests for both Gecko libraries and + * system libraries. However, it only handles cases where symbol information + * can be found in a local file on this machine. There is one case that is not + * covered by that restriction: Android system libraries. That case requires + * the help of the perf actor and is implemented in + * LocalSymbolicationServiceWithRemoteSymbolTableFallback. + */ +class LocalSymbolicationService { + /** + * @param {Library[]} sharedLibraries - Information about the shared libraries. + * This allows mapping (debugName, breakpadId) pairs to the absolute path of + * the binary and/or PDB file, and it ensures that these absolute paths come + * from a trusted source and not from the profiler UI. + * @param {string[]} objdirs - An array of objdir paths + * on the host machine that should be searched for relevant build artifacts. + */ + constructor(sharedLibraries, objdirs) { + this._libInfoMap = new Map( + sharedLibraries.map(lib => { + const { debugName, breakpadId } = lib; + const key = `${debugName}:${breakpadId}`; + return [key, lib]; + }) + ); + this._objdirs = objdirs; + } + + /** + * @param {string} debugName + * @param {string} breakpadId + * @returns {Promise<SymbolTableAsTuple>} + */ + async getSymbolTable(debugName, breakpadId) { + const module = await getWASMProfilerGetSymbolsModule(); + /** @type {SymbolicationWorkerInitialMessage} */ + const initialMessage = { + request: { + type: "GET_SYMBOL_TABLE", + debugName, + breakpadId, + }, + libInfoMap: this._libInfoMap, + objdirs: this._objdirs, + module, + }; + return getResultFromWorker( + "resource://devtools/client/performance-new/shared/symbolication-worker.js", + initialMessage + ); + } + + /** + * @param {string} path + * @param {string} requestJson + * @returns {Promise<string>} + */ + async querySymbolicationApi(path, requestJson) { + const module = await getWASMProfilerGetSymbolsModule(); + /** @type {SymbolicationWorkerInitialMessage} */ + const initialMessage = { + request: { + type: "QUERY_SYMBOLICATION_API", + path, + requestJson, + }, + libInfoMap: this._libInfoMap, + objdirs: this._objdirs, + module, + }; + return getResultFromWorker( + "resource://devtools/client/performance-new/shared/symbolication-worker.js", + initialMessage + ); + } +} + +/** + * An implementation of the SymbolicationService interface which also + * covers the Android system library case. + * We first try to get symbols from the wrapped SymbolicationService. + * If that fails, we try to get the symbol table through the perf actor. + */ +class LocalSymbolicationServiceWithRemoteSymbolTableFallback { + /** + * @param {SymbolicationService} symbolicationService - The regular symbolication service. + * @param {Library[]} sharedLibraries - Information about the shared libraries + * @param {PerfFront} perfFront - A perf actor, to obtain symbol + * tables from remote targets + */ + constructor(symbolicationService, sharedLibraries, perfFront) { + this._symbolicationService = symbolicationService; + this._libs = sharedLibraries; + this._perfFront = perfFront; + } + + /** + * @param {string} debugName + * @param {string} breakpadId + * @returns {Promise<SymbolTableAsTuple>} + */ + async getSymbolTable(debugName, breakpadId) { + try { + return await this._symbolicationService.getSymbolTable( + debugName, + breakpadId + ); + } catch (errorFromLocalFiles) { + // Try to obtain the symbol table on the debuggee. We get into this + // branch in the following cases: + // - Android system libraries + // - Firefox binaries that have no matching equivalent on the host + // machine, for example because the user didn't point us at the + // corresponding objdir, or if the build was compiled somewhere + // else, or if the build on the device is outdated. + // For now, the "debuggee" is never a Windows machine, which is why we don't + // need to pass the library's debugPath. (path and debugPath are always the + // same on non-Windows.) + const lib = this._libs.find( + l => l.debugName === debugName && l.breakpadId === breakpadId + ); + if (!lib) { + throw new Error( + `Could not find the library for "${debugName}", "${breakpadId}" after falling ` + + `back to remote symbol table querying because regular getSymbolTable failed ` + + `with error: ${errorFromLocalFiles.message}.` + ); + } + return getSymbolTableFromDebuggee(this._perfFront, lib.path, breakpadId); + } + } + + /** + * @param {string} path + * @param {string} requestJson + * @returns {Promise<string>} + */ + async querySymbolicationApi(path, requestJson) { + return this._symbolicationService.querySymbolicationApi(path, requestJson); + } +} + +/** + * Return an object that implements the SymbolicationService interface. + * + * @param {Library[]} sharedLibraries - Information about the shared libraries + * @param {string[]} objdirs - An array of objdir paths + * on the host machine that should be searched for relevant build artifacts. + * @param {PerfFront} [perfFront] - An optional perf actor, to obtain symbol + * tables from remote targets + * @return {SymbolicationService} + */ +function createLocalSymbolicationService(sharedLibraries, objdirs, perfFront) { + const service = new LocalSymbolicationService(sharedLibraries, objdirs); + if (perfFront) { + return new LocalSymbolicationServiceWithRemoteSymbolTableFallback( + service, + sharedLibraries, + perfFront + ); + } + return service; +} + +// Provide an exports object for the JSM to be properly read by TypeScript. +/** @type {any} */ +var module = {}; + +module.exports = { + createLocalSymbolicationService, +}; + +// Object.keys() confuses the linting which expects a static array expression. +// eslint-disable-next-line +var EXPORTED_SYMBOLS = Object.keys(module.exports); |