mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-24 05:11:16 +00:00
262 lines
9.3 KiB
Python
262 lines
9.3 KiB
Python
# 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/.
|
|
|
|
import json
|
|
import logging
|
|
import os
|
|
import time
|
|
|
|
import mozinfo
|
|
from mach.decorators import Command, CommandArgument
|
|
from mozbuild.base import BinaryNotFoundException
|
|
from mozbuild.base import MachCommandConditions as conditions
|
|
|
|
|
|
def is_valgrind_build(cls):
|
|
"""Must be a build with --enable-valgrind and --disable-jemalloc."""
|
|
defines = cls.config_environment.defines
|
|
return "MOZ_VALGRIND" in defines and "MOZ_MEMORY" not in defines
|
|
|
|
|
|
@Command(
|
|
"valgrind-test",
|
|
category="testing",
|
|
conditions=[conditions.is_firefox_or_thunderbird, is_valgrind_build],
|
|
description="Run the Valgrind test job (memory-related errors).",
|
|
)
|
|
@CommandArgument(
|
|
"--suppressions",
|
|
default=[],
|
|
action="append",
|
|
metavar="FILENAME",
|
|
help="Specify a suppression file for Valgrind to use. Use "
|
|
"--suppression multiple times to specify multiple suppression "
|
|
"files.",
|
|
)
|
|
def valgrind_test(command_context, suppressions):
|
|
"""
|
|
Run Valgrind tests.
|
|
"""
|
|
|
|
from mozfile import TemporaryDirectory
|
|
from mozhttpd import MozHttpd
|
|
from mozprofile import FirefoxProfile, Preferences
|
|
from mozprofile.permissions import ServerLocations
|
|
from mozrunner import FirefoxRunner
|
|
from mozrunner.utils import findInPath
|
|
from valgrind.output_handler import OutputHandler
|
|
|
|
build_dir = os.path.join(command_context.topsrcdir, "build")
|
|
|
|
# XXX: currently we just use the PGO inputs for Valgrind runs. This may
|
|
# change in the future.
|
|
httpd = MozHttpd(docroot=os.path.join(build_dir, "pgo"))
|
|
httpd.start(block=False)
|
|
|
|
with TemporaryDirectory() as profilePath:
|
|
# TODO: refactor this into mozprofile
|
|
profile_data_dir = os.path.join(
|
|
command_context.topsrcdir, "testing", "profiles"
|
|
)
|
|
with open(os.path.join(profile_data_dir, "profiles.json"), "r") as fh:
|
|
base_profiles = json.load(fh)["valgrind"]
|
|
|
|
prefpaths = [
|
|
os.path.join(profile_data_dir, profile, "user.js")
|
|
for profile in base_profiles
|
|
]
|
|
prefs = {}
|
|
for path in prefpaths:
|
|
prefs.update(Preferences.read_prefs(path))
|
|
|
|
interpolation = {
|
|
"server": "%s:%d" % httpd.httpd.server_address,
|
|
}
|
|
for k, v in prefs.items():
|
|
if isinstance(v, str):
|
|
v = v.format(**interpolation)
|
|
prefs[k] = Preferences.cast(v)
|
|
|
|
quitter = os.path.join(
|
|
command_context.topsrcdir, "tools", "quitter", "quitter@mozilla.org.xpi"
|
|
)
|
|
|
|
locations = ServerLocations()
|
|
locations.add_host(
|
|
host="127.0.0.1", port=httpd.httpd.server_port, options="primary"
|
|
)
|
|
|
|
profile = FirefoxProfile(
|
|
profile=profilePath,
|
|
preferences=prefs,
|
|
addons=[quitter],
|
|
locations=locations,
|
|
)
|
|
|
|
firefox_args = [httpd.get_url()]
|
|
|
|
env = os.environ.copy()
|
|
env["G_SLICE"] = "always-malloc"
|
|
env["MOZ_FORCE_DISABLE_E10S"] = "1"
|
|
env["MOZ_CC_RUN_DURING_SHUTDOWN"] = "1"
|
|
env["MOZ_CRASHREPORTER_NO_REPORT"] = "1"
|
|
env["MOZ_DISABLE_NONLOCAL_CONNECTIONS"] = "1"
|
|
env["XPCOM_DEBUG_BREAK"] = "warn"
|
|
|
|
outputHandler = OutputHandler(command_context.log)
|
|
kp_kwargs = {
|
|
"processOutputLine": [outputHandler],
|
|
"universal_newlines": True,
|
|
}
|
|
|
|
valgrind = "valgrind"
|
|
if not os.path.exists(valgrind):
|
|
valgrind = findInPath(valgrind)
|
|
|
|
valgrind_args = [
|
|
valgrind,
|
|
"--sym-offsets=yes",
|
|
"--smc-check=all-non-file",
|
|
"--vex-iropt-register-updates=allregs-at-mem-access",
|
|
"--gen-suppressions=all",
|
|
"--num-callers=36",
|
|
"--leak-check=full",
|
|
"--show-possibly-lost=no",
|
|
"--track-origins=yes",
|
|
"--trace-children=yes",
|
|
"--trace-children-skip=*/dbus-launch",
|
|
"-v", # Enable verbosity to get the list of used suppressions
|
|
# Avoid excessive delays in the presence of spinlocks.
|
|
# See bug 1309851.
|
|
"--fair-sched=yes",
|
|
# Keep debuginfo after library unmap. See bug 1382280.
|
|
"--keep-debuginfo=yes",
|
|
# Reduce noise level on rustc and/or LLVM compiled code.
|
|
# See bug 1365915
|
|
"--expensive-definedness-checks=yes",
|
|
# Compensate for the compiler inlining `new` but not `delete`
|
|
# or vice versa.
|
|
"--show-mismatched-frees=no",
|
|
]
|
|
|
|
for s in suppressions:
|
|
valgrind_args.append("--suppressions=" + s)
|
|
|
|
supps_dir = os.path.join(build_dir, "valgrind")
|
|
supps_file1 = os.path.join(supps_dir, "cross-architecture.sup")
|
|
valgrind_args.append("--suppressions=" + supps_file1)
|
|
|
|
if mozinfo.os == "linux":
|
|
machtype = {
|
|
"x86_64": "x86_64-pc-linux-gnu",
|
|
"x86": "i386-pc-linux-gnu",
|
|
}.get(mozinfo.processor)
|
|
if machtype:
|
|
supps_file2 = os.path.join(supps_dir, machtype + ".sup")
|
|
if os.path.isfile(supps_file2):
|
|
valgrind_args.append("--suppressions=" + supps_file2)
|
|
|
|
exitcode = None
|
|
timeout = 3600
|
|
binary_not_found_exception = None
|
|
try:
|
|
runner = FirefoxRunner(
|
|
profile=profile,
|
|
binary=command_context.get_binary_path(),
|
|
cmdargs=firefox_args,
|
|
env=env,
|
|
process_args=kp_kwargs,
|
|
)
|
|
start_time = time.monotonic()
|
|
runner.start(debug_args=valgrind_args)
|
|
exitcode = runner.wait(timeout=timeout)
|
|
end_time = time.monotonic()
|
|
if "MOZ_AUTOMATION" in os.environ:
|
|
data = {
|
|
"framework": {"name": "build_metrics"},
|
|
"suites": [
|
|
{
|
|
"name": "valgrind",
|
|
"value": end_time - start_time,
|
|
"lowerIsBetter": True,
|
|
"shouldAlert": False,
|
|
"subtests": [],
|
|
}
|
|
],
|
|
}
|
|
if "TASKCLUSTER_INSTANCE_TYPE" in os.environ:
|
|
# Include the instance type so results can be grouped.
|
|
data["suites"][0]["extraOptions"] = [
|
|
"taskcluster-%s" % os.environ["TASKCLUSTER_INSTANCE_TYPE"],
|
|
]
|
|
command_context.log(
|
|
logging.INFO,
|
|
"valgrind-perfherder",
|
|
{"data": json.dumps(data)},
|
|
"PERFHERDER_DATA: {data}",
|
|
)
|
|
except BinaryNotFoundException as e:
|
|
binary_not_found_exception = e
|
|
finally:
|
|
errs = outputHandler.error_count
|
|
supps = outputHandler.suppression_count
|
|
if errs != supps:
|
|
status = 1 # turns the TBPL job orange
|
|
command_context.log(
|
|
logging.ERROR,
|
|
"valgrind-fail-parsing",
|
|
{"errs": errs, "supps": supps},
|
|
"TEST-UNEXPECTED-FAIL | valgrind-test | error parsing: {errs} errors "
|
|
"seen, but {supps} generated suppressions seen",
|
|
)
|
|
|
|
elif errs == 0:
|
|
status = 0
|
|
command_context.log(
|
|
logging.INFO,
|
|
"valgrind-pass",
|
|
{},
|
|
"TEST-PASS | valgrind-test | valgrind found no errors",
|
|
)
|
|
else:
|
|
status = 1 # turns the TBPL job orange
|
|
# We've already printed details of the errors.
|
|
|
|
if binary_not_found_exception:
|
|
status = 2 # turns the TBPL job red
|
|
command_context.log(
|
|
logging.ERROR,
|
|
"valgrind-fail-errors",
|
|
{"error": str(binary_not_found_exception)},
|
|
"TEST-UNEXPECTED-FAIL | valgrind-test | {error}",
|
|
)
|
|
command_context.log(
|
|
logging.INFO,
|
|
"valgrind-fail-errors",
|
|
{"help": binary_not_found_exception.help()},
|
|
"{help}",
|
|
)
|
|
elif exitcode is None:
|
|
status = 2 # turns the TBPL job red
|
|
command_context.log(
|
|
logging.ERROR,
|
|
"valgrind-fail-timeout",
|
|
{"timeout": timeout},
|
|
"TEST-UNEXPECTED-FAIL | valgrind-test | Valgrind timed out "
|
|
"(reached {timeout} second limit)",
|
|
)
|
|
elif exitcode != 0:
|
|
status = 2 # turns the TBPL job red
|
|
command_context.log(
|
|
logging.ERROR,
|
|
"valgrind-fail-errors",
|
|
{"exitcode": exitcode},
|
|
"TEST-UNEXPECTED-FAIL | valgrind-test | non-zero exit code "
|
|
"from Valgrind: {exitcode}",
|
|
)
|
|
|
|
httpd.stop()
|
|
|
|
return status
|