def update_details(binary_manager: binaries_util.BinaryManager,
device: Device) -> None:
check(
device.HasField("android"),
AssertionError(f"Expected Android device: {device}"),
)
build_fingerprint = ""
try:
adb_fingerprint_result = adb_check(
device.android.serial,
["shell", "getprop ro.build.fingerprint"],
verbose=True,
)
build_fingerprint = adb_fingerprint_result.stdout
build_fingerprint = build_fingerprint.strip()
except subprocess.CalledProcessError:
log("Failed to get device fingerprint")
device_properties = ""
ensure_amber_installed(device.android.serial, binary_manager)
try:
device_properties = get_device_driver_details(device.android.serial)
except devices_util.GetDeviceDetailsError as ex:
log(f"WARNING: Failed to get device driver details: {ex}")
device.android.build_fingerprint = build_fingerprint
device.device_properties = device_properties
def _update_device_host(binary_manager: binaries_util.BinaryManager,
device: Device) -> None:
check(
device.HasField("host"),
AssertionError(f"Expected host device: {device}"),
)
amber_path = binary_manager.get_binary_path_by_name(
binaries_util.AMBER_NAME).path
driver_details = ""
try:
driver_details = host_device_util.get_driver_details(
amber_path, custom_launcher=list(device.host.custom_launcher))
except GetDeviceDetailsError as ex:
log(f"WARNING: Failed to get device driver details: {ex}")
device.device_properties = driver_details
def device_host(binary_manager: binaries_util.BinaryManager) -> Device:
amber_path = binary_manager.get_binary_path_by_name(binaries_util.AMBER_NAME).path
driver_details = ""
try:
driver_details = host_device_util.get_driver_details(amber_path)
except GetDeviceDetailsError as ex:
log(f"WARNING: Failed to get device driver details: {ex}")
return Device(name="host", host=DeviceHost(), device_properties=driver_details)
def get_device_list(
binary_manager: binaries_util.BinaryManager,
device_list: Optional[DeviceList] = None,
) -> DeviceList:
if not device_list:
device_list = DeviceList()
# We use |extend| below (instead of |append|) because you cannot append to a list of non-scalars in protobuf.
# |extend| copies the elements from the list and appends them.
# Host preprocessor.
device = device_preprocessor()
device_list.devices.extend([device])
device_list.active_device_names.append(device.name)
# SwiftShader.
device = swift_shader_device(binary_manager)
device_list.devices.extend([device])
device_list.active_device_names.append(device.name)
# Host device.
device = device_host(binary_manager)
device_list.devices.extend([device])
device_list.active_device_names.append(device.name)
try:
# Android devices.
android_devices = android_device.get_all_android_devices(binary_manager)
device_list.devices.extend(android_devices)
device_list.active_device_names.extend([d.name for d in android_devices])
except ToolNotOnPathError:
log(
"WARNING: adb was not found on PATH nor was ANDROID_HOME set; "
"Android devices will not be added to settings.json"
)
# Offline compiler.
device = Device(
name="amdllpc",
shader_compiler=DeviceShaderCompiler(
binary="amdllpc", args=["-gfxip=9.0.0", "-verify-ir", "-auto-layout-desc"]
),
binaries=[binary_manager.get_binary_path_by_name("amdllpc").binary],
)
device_list.devices.extend([device])
# Don't add to active devices, since this is mostly just an example.
return device_list
def update_device(binary_manager: binaries_util.BinaryManager,
device: Device) -> None:
"""
Updates a device.
This mostly just means setting the "device_properties" field of the device to the output of "amber -d -V".
Android devices will also have their build_fingerprint updated.
:param binary_manager:
:param device:
:return:
"""
if device.HasField("preprocess"):
pass
elif device.HasField("swift_shader"):
_update_device_swiftshader(binary_manager, device)
elif device.HasField("host"):
_update_device_host(binary_manager, device)
elif device.HasField("android"):
android_device.update_details(binary_manager, device)
elif device.HasField("shader_compiler"):
_update_device_shader_compiler(binary_manager, device)
else:
raise AssertionError(f"Unrecognized device type: {device}")
def _update_device_swiftshader(binary_manager: binaries_util.BinaryManager,
device: Device) -> None:
check(
device.HasField("swift_shader"),
AssertionError(f"Expected SwiftShader device: {device}"),
)
amber_path = binary_manager.get_binary_path_by_name(
binaries_util.AMBER_NAME).path
swift_shader_binary_and_path = binary_manager.get_binary_path_by_name(
binaries_util.SWIFT_SHADER_NAME)
driver_details = ""
try:
driver_details = host_device_util.get_driver_details(
amber_path, swift_shader_binary_and_path.path)
except GetDeviceDetailsError as ex:
log(f"WARNING: Failed to get device driver details: {ex}")
device.device_properties = driver_details
del device.binaries[:]
device.binaries.extend([swift_shader_binary_and_path.binary])
def get_all_android_devices( # pylint: disable=too-many-locals;
binary_manager: binaries_util.BinaryManager,
include_device_details: bool = True,
) -> List[Device]:
result: List[Device] = []
log("Getting the list of connected Android devices via adb\n")
adb_devices = adb_check(None, ["devices", "-l"], verbose=True)
stdout: str = adb_devices.stdout
lines: List[str] = stdout.splitlines()
# Remove empty lines.
lines = [line for line in lines if line]
check(
lines[0].startswith("List of devices"),
AssertionError("Could find list of devices from 'adb devices'"),
)
for i in range(1, len(lines)):
fields = lines[i].split()
device_serial = fields[0]
device_state = fields[1]
if device_state != "device":
log(f'Skipping adb device with serial {device_serial} as its state "{device_state}" is not "device".'
)
# Set a simple model name, but then try to find the actual model name.
device_model = "android_device"
for field_index in range(2, len(fields)):
if fields[field_index].startswith("model:"):
device_model = util.remove_start(fields[field_index], "model:")
break
log(f"Found Android device: {device_model}, {device_serial}")
device = Device(
name=f"{device_model}_{device_serial}",
android=DeviceAndroid(serial=device_serial, model=device_model),
)
if include_device_details:
update_details(binary_manager, device)
log(f"Android device details:\n{str(device)}")
else:
log(f"Skipped getting Android device details:\n{str(device)}")
result.append(device)
return result
def _update_device_shader_compiler(binary_manager: binaries_util.BinaryManager,
device: Device) -> None:
check(
device.HasField("shader_compiler"),
AssertionError(f"Expected shader_compiler device: {device}"),
)
# The only thing we can do is update the shader compiler binary if it is a built-in binary.
if binaries_util.is_built_in_binary_name(device.shader_compiler.binary):
# Remove existing binaries with this name from the device's binaries list.
binaries = list(device.binaries)
binaries = [
b for b in binaries if b.name != device.shader_compiler.binary
]
del device.binaries[:]
device.binaries.extend(binaries)
# Add our latest version of the binary.
device.binaries.extend(
[binary_manager.get_binary_by_name(device.shader_compiler.binary)])
def swift_shader_device(binary_manager: binaries_util.BinaryManager) -> Device:
amber_path = binary_manager.get_binary_path_by_name(binaries_util.AMBER_NAME).path
swift_shader_binary_and_path = binary_manager.get_binary_path_by_name(
binaries_util.SWIFT_SHADER_NAME
)
driver_details = ""
try:
driver_details = host_device_util.get_driver_details(
amber_path, swift_shader_binary_and_path.path
)
except GetDeviceDetailsError as ex:
log(f"WARNING: Failed to get device driver details: {ex}")
device = Device(
name="swift_shader",
swift_shader=DeviceSwiftShader(),
binaries=[swift_shader_binary_and_path.binary],
device_properties=driver_details,
)
return device
def main() -> None: # pylint: disable=too-many-locals,too-many-branches,too-many-statements;
parser = argparse.ArgumentParser(
description="Runs GraphicsFuzz AmberScript tests on the active devices listed in "
"the settings.json file.",
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)
parser.add_argument(
"--settings",
help="Path to the settings JSON file for this instance.",
default=str(settings_util.DEFAULT_SETTINGS_FILE_PATH),
)
parser.add_argument(
"--tests",
help="Path to the directory of AmberScript tests with shaders extracted.",
default="graphicsfuzz",
)
parser.add_argument(
"--update_ignored_signatures",
help="As the tests are run for each device, add any crash signatures to the device's ignored_crash_signatures "
"property and write out the updated settings.json file.",
action="store_true",
)
parser.add_argument(
"--results_out",
help="Output file path for the CSV results table.",
default="results.csv",
)
parsed_args = parser.parse_args(sys.argv[1:])
# Args.
tests_dir: Path = Path(parsed_args.tests)
settings_path: Path = Path(parsed_args.settings)
update_ignored_signatures: bool = parsed_args.update_ignored_signatures
results_out_path: Path = Path(parsed_args.results_out)
# Settings and devices.
settings = settings_util.read_or_create(settings_path)
active_devices = devices_util.get_active_devices(settings.device_list)
# Binaries.
binaries = binaries_util.get_default_binary_manager(settings=settings)
work_dir = Path() / "temp" / f"cts_run_{fuzz.get_random_name()[:8]}"
util.mkdirs_p(work_dir)
with util.file_open_text(results_out_path, "w") as results_handle:
def write_entry(entry: str) -> None:
results_handle.write(entry)
results_handle.write(", ")
results_handle.flush()
def write_newline() -> None:
results_handle.write("\n")
results_handle.flush()
spirv_opt_path: Optional[Path] = None
swift_shader_path: Optional[Path] = None
amber_path: Optional[Path] = None
# Small hack to ensure we have three devices for spirv-opt, each with a different name.
main_spirv_opt_device: Optional[Device] = None
if active_devices and active_devices[0].name == "host_preprocessor":
main_spirv_opt_device = active_devices[0]
main_spirv_opt_device.name = SPIRV_OPT_O
spirv_opt_custom = Device()
spirv_opt_custom.CopyFrom(main_spirv_opt_device)
spirv_opt_custom.name = SPIRV_OPT_CUSTOM
active_devices.insert(1, spirv_opt_custom)
spirv_opt_os = Device()
spirv_opt_os.CopyFrom(main_spirv_opt_device)
spirv_opt_os.name = SPIRV_OPT_OS
active_devices.insert(1, spirv_opt_os)
# Enumerate active devices, writing their name and storing binary paths if needed.
write_entry("test")
for device in active_devices:
write_entry(device.name)
if device.HasField("preprocess"):
spirv_opt_path = binaries.get_binary_path_by_name(
binaries_util.SPIRV_OPT_NAME
).path
if device.HasField("swift_shader"):
swift_shader_path = binaries.get_binary_path_by_name(
binaries_util.SWIFT_SHADER_NAME
).path
if device.HasField("swift_shader") or device.HasField("host"):
amber_path = binaries.get_binary_path_by_name(
binaries_util.AMBER_NAME
).path
write_newline()
# Enumerate tests and devices, writing the results.
for test in sorted(tests_dir.glob("*.amber")):
test_name = util.remove_end(test.name, ".amber")
write_entry(test_name)
spirv_shaders = sorted(
tests_dir.glob(util.remove_end(test.name, "amber") + "*.spv")
)
for device in active_devices:
test_run_dir = work_dir / f"{test_name}_{device.name}"
util.mkdirs_p(test_run_dir)
ignored_signatures_set: Set[str] = set(device.ignored_crash_signatures)
with util.file_open_text(test_run_dir / "log.txt", "w") as log_stream:
try:
gflogging.push_stream_for_logging(log_stream)
if device.HasField("preprocess"):
# This just means spirv-opt for now.
assert spirv_opt_path # noqa
assert main_spirv_opt_device # noqa
# Pick spirv-opt arguments based on device name.
if device.name == SPIRV_OPT_O:
spirv_opt_args = ["-O"]
elif device.name == SPIRV_OPT_OS:
spirv_opt_args = ["-Os"]
elif device.name == SPIRV_OPT_CUSTOM:
spirv_opt_args = (
spirv_opt_util.OPT_INTERESTING_SUBSET_OF_PASSES
)
else:
raise AssertionError(
f"Can't tell how to run device {device.name}; "
f"must be named host_preprocessor and be the first active device."
)
# Reset device and ignored_crash_signatures.
device = main_spirv_opt_device
ignored_signatures_set = set(
device.ignored_crash_signatures
)
try:
for spirv_shader in spirv_shaders:
spirv_opt_util.run_spirv_opt_on_spirv_shader(
spirv_shader,
test_run_dir,
spirv_opt_args,
spirv_opt_path,
)
result_util.write_status(
test_run_dir, fuzz.STATUS_SUCCESS,
)
except subprocess.CalledProcessError:
result_util.write_status(
test_run_dir, fuzz.STATUS_TOOL_CRASH,
)
except subprocess.TimeoutExpired:
result_util.write_status(
test_run_dir, fuzz.STATUS_TOOL_TIMEOUT,
)
elif device.HasField("shader_compiler"):
try:
for spirv_shader in spirv_shaders:
shader_compiler_util.run_shader(
shader_compiler_device=device.shader_compiler,
shader_path=spirv_shader,
output_dir=test_run_dir,
compiler_path=binaries.get_binary_path_by_name(
device.shader_compiler.binary
).path,
timeout=DEFAULT_TIMEOUT,
)
result_util.write_status(
test_run_dir, fuzz.STATUS_SUCCESS,
)
except subprocess.CalledProcessError:
result_util.write_status(
test_run_dir, fuzz.STATUS_CRASH,
)
except subprocess.TimeoutExpired:
result_util.write_status(
test_run_dir, fuzz.STATUS_TIMEOUT,
)
elif device.HasField("swift_shader"):
assert swift_shader_path # noqa
assert amber_path # noqa
host_device_util.run_amber(
test,
test_run_dir,
amber_path=amber_path,
dump_image=False,
dump_buffer=False,
icd=swift_shader_path,
)
elif device.HasField("host"):
assert amber_path # noqa
host_device_util.run_amber(
test,
test_run_dir,
amber_path=amber_path,
dump_image=False,
dump_buffer=False,
custom_launcher=list(device.host.custom_launcher),
)
elif device.HasField("android"):
android_device.run_amber_on_device(
test,
test_run_dir,
dump_image=False,
dump_buffer=False,
serial=device.android.serial,
)
else:
raise AssertionError(f"Unsupported device {device.name}")
finally:
gflogging.pop_stream_for_logging()
status = result_util.get_status(test_run_dir)
if status == fuzz.STATUS_SUCCESS:
write_entry("P")
elif status in (fuzz.STATUS_TIMEOUT, fuzz.STATUS_TOOL_TIMEOUT):
write_entry("T")
else:
write_entry("F")
# Update ignored signatures.
if (
status
in (
fuzz.STATUS_TOOL_CRASH,
fuzz.STATUS_CRASH,
fuzz.STATUS_UNRESPONSIVE,
)
and update_ignored_signatures
):
log_contents = util.file_read_text(
result_util.get_log_path(test_run_dir)
)
signature = signature_util.get_signature_from_log_contents(
log_contents
)
if signature == signature_util.NO_SIGNATURE:
log(f"NOT updating ignored signatures to include {signature}")
elif signature in ignored_signatures_set:
log(f"Signature is already ignored: {signature}")
else:
log(f"Adding ignored signature: {signature}")
device.ignored_crash_signatures.append(signature)
write_newline()
if update_ignored_signatures:
# Reset main_spirv_opt_device name before writing it back out.
if main_spirv_opt_device:
main_spirv_opt_device.name = "host_preprocessor"
settings_util.write(settings, settings_path)
def get_all_android_devices( # pylint: disable=too-many-locals;
binary_manager: binaries_util.BinaryManager,
) -> List[Device]:
result: List[Device] = []
log("Getting the list of connected Android devices via adb\n")
adb_devices = adb_check(None, ["devices", "-l"], verbose=True)
stdout: str = adb_devices.stdout
lines: List[str] = stdout.splitlines()
# Remove empty lines.
lines = [l for l in lines if l]
check(
lines[0].startswith("List of devices"),
AssertionError("Could find list of devices from 'adb devices'"),
)
for i in range(1, len(lines)):
fields = lines[i].split()
device_serial = fields[0]
device_state = fields[1]
if device_state != "device":
log(
f'Skipping adb device with serial {device_serial} as its state "{device_state}" is not "device".'
)
# Set a simple model name, but then try to find the actual model name.
device_model = "android_device"
for field_index in range(2, len(fields)):
if fields[field_index].startswith("model:"):
device_model = util.remove_start(fields[field_index], "model:")
break
build_fingerprint: str = ""
try:
adb_fingerprint_result = adb_check(
device_serial, ["shell", "getprop ro.build.fingerprint"]
)
build_fingerprint = adb_fingerprint_result.stdout
build_fingerprint = build_fingerprint.strip()
except subprocess.CalledProcessError:
log("Failed to get device fingerprint")
ensure_amber_installed(device_serial, binary_manager)
driver_details = ""
try:
driver_details = get_device_driver_details(device_serial)
except devices_util.GetDeviceDetailsError as ex:
log(f"WARNING: Failed to get device driver details: {ex}")
device = Device(
name=f"{device_model}_{device_serial}",
android=DeviceAndroid(
serial=device_serial,
model=device_model,
build_fingerprint=build_fingerprint,
),
device_properties=driver_details,
)
log(f"Found Android device:\n{str(device)}")
result.append(device)
return result
def device_preprocessor() -> Device:
# TODO: think about the fact that the versions of glslang, spirv-opt etc. are stored in the test and not the device.
# This might make it rather strange if you want to test many different versions of, say, spirv-opt.
# We could store version hashes in both the test and the "preprocessor device", and let the "preprocessor device"
# have higher priority.
return Device(name="host_preprocessor", preprocess=DevicePreprocess())
def main_helper( # pylint: disable=too-many-locals,too-many-branches,too-many-statements;
tests_dir: Path,
work_dir: Path,
binaries: binaries_util.BinaryManager,
settings: Settings,
active_devices: List[Device],
results_out_handle: Optional[TextIO],
updated_settings_output_path: Optional[Path],
) -> None:
util.mkdirs_p(work_dir)
def write_entry(entry: str) -> None:
if not results_out_handle:
return
results_out_handle.write(entry)
results_out_handle.write(", ")
results_out_handle.flush()
def write_newline() -> None:
if not results_out_handle:
return
results_out_handle.write("\n")
results_out_handle.flush()
spirv_opt_path: Optional[Path] = None
swift_shader_path: Optional[Path] = None
amber_path: Optional[Path] = None
# Small hack to ensure we have three devices for spirv-opt, each with a different name.
main_spirv_opt_device: Optional[Device] = None
if active_devices and active_devices[0].name == "host_preprocessor":
main_spirv_opt_device = active_devices[0]
main_spirv_opt_device.name = SPIRV_OPT_O
spirv_opt_custom = Device()
spirv_opt_custom.CopyFrom(main_spirv_opt_device)
spirv_opt_custom.name = SPIRV_OPT_CUSTOM
active_devices.insert(1, spirv_opt_custom)
spirv_opt_os = Device()
spirv_opt_os.CopyFrom(main_spirv_opt_device)
spirv_opt_os.name = SPIRV_OPT_OS
active_devices.insert(1, spirv_opt_os)
# Enumerate active devices, writing their name and storing binary paths if needed.
write_entry("test")
for device in active_devices:
write_entry(device.name)
if device.HasField("preprocess"):
spirv_opt_path = binaries.get_binary_path_by_name(
binaries_util.SPIRV_OPT_NAME).path
if device.HasField("swift_shader"):
swift_shader_path = binaries.get_binary_path_by_name(
binaries_util.SWIFT_SHADER_NAME).path
if device.HasField("swift_shader") or device.HasField("host"):
amber_path = binaries.get_binary_path_by_name(
binaries_util.AMBER_NAME).path
write_newline()
# Enumerate tests and devices, writing the results.
for test in sorted(tests_dir.glob("*.amber")):
test_name = util.remove_end(test.name, ".amber")
write_entry(test_name)
spirv_shaders = sorted(
tests_dir.glob(util.remove_end(test.name, "amber") + "*.spv"))
for device in active_devices:
test_run_dir = work_dir / f"{test_name}_{device.name}"
util.mkdirs_p(test_run_dir)
ignored_signatures_set: Set[str] = set(
device.ignored_crash_signatures)
with util.file_open_text(test_run_dir / "log.txt",
"w") as log_stream:
try:
gflogging.push_stream_for_logging(log_stream)
if device.HasField("preprocess"):
# This just means spirv-opt for now.
assert spirv_opt_path # noqa
assert main_spirv_opt_device # noqa
# Pick spirv-opt arguments based on device name.
if device.name == SPIRV_OPT_O:
spirv_opt_args = ["-O"]
elif device.name == SPIRV_OPT_OS:
spirv_opt_args = ["-Os"]
elif device.name == SPIRV_OPT_CUSTOM:
spirv_opt_args = (spirv_opt_util.
OPT_INTERESTING_SUBSET_OF_PASSES)
else:
raise AssertionError(
f"Can't tell how to run device {device.name}; "
f"must be named host_preprocessor and be the first active device."
)
# Reset device and ignored_crash_signatures.
device = main_spirv_opt_device
ignored_signatures_set = set(
device.ignored_crash_signatures)
try:
for spirv_shader in spirv_shaders:
spirv_opt_util.run_spirv_opt_on_spirv_shader(
spirv_shader,
test_run_dir,
spirv_opt_args,
spirv_opt_path,
)
result_util.write_status(
test_run_dir,
fuzz.STATUS_SUCCESS,
)
except subprocess.CalledProcessError:
result_util.write_status(
test_run_dir,
fuzz.STATUS_TOOL_CRASH,
)
except subprocess.TimeoutExpired:
result_util.write_status(
test_run_dir,
fuzz.STATUS_TOOL_TIMEOUT,
)
elif device.HasField("shader_compiler"):
try:
for spirv_shader in spirv_shaders:
shader_compiler_util.run_shader(
shader_compiler_device=device.
shader_compiler,
shader_path=spirv_shader,
output_dir=test_run_dir,
compiler_path=binaries.
get_binary_path_by_name(
device.shader_compiler.binary).path,
timeout=DEFAULT_TIMEOUT,
)
result_util.write_status(
test_run_dir,
fuzz.STATUS_SUCCESS,
)
except subprocess.CalledProcessError:
result_util.write_status(
test_run_dir,
fuzz.STATUS_CRASH,
)
except subprocess.TimeoutExpired:
result_util.write_status(
test_run_dir,
fuzz.STATUS_TIMEOUT,
)
elif device.HasField("swift_shader"):
assert swift_shader_path # noqa
assert amber_path # noqa
host_device_util.run_amber(
test,
test_run_dir,
amber_path=amber_path,
dump_image=False,
dump_buffer=False,
icd=swift_shader_path,
)
elif device.HasField("host"):
assert amber_path # noqa
host_device_util.run_amber(
test,
test_run_dir,
amber_path=amber_path,
dump_image=False,
dump_buffer=False,
custom_launcher=list(device.host.custom_launcher),
)
elif device.HasField("android"):
android_device.run_amber_on_device(
test,
test_run_dir,
dump_image=False,
dump_buffer=False,
serial=device.android.serial,
)
else:
raise AssertionError(
f"Unsupported device {device.name}")
finally:
gflogging.pop_stream_for_logging()
status = result_util.get_status(test_run_dir)
if status == fuzz.STATUS_SUCCESS:
write_entry("P")
elif status in (fuzz.STATUS_TIMEOUT, fuzz.STATUS_TOOL_TIMEOUT):
write_entry("T")
else:
write_entry("F")
# Update ignored signatures.
if (status in (
fuzz.STATUS_TOOL_CRASH,
fuzz.STATUS_CRASH,
fuzz.STATUS_UNRESPONSIVE,
) and updated_settings_output_path):
log_contents = util.file_read_text(
result_util.get_log_path(test_run_dir))
signature = signature_util.get_signature_from_log_contents(
log_contents)
if signature == signature_util.NO_SIGNATURE:
log(f"NOT updating ignored signatures to include {signature}"
)
elif signature in ignored_signatures_set:
log(f"Signature is already ignored: {signature}")
else:
log(f"Adding ignored signature: {signature}")
device.ignored_crash_signatures.append(signature)
write_newline()
if updated_settings_output_path:
# Reset main_spirv_opt_device name before writing it back out.
if main_spirv_opt_device:
main_spirv_opt_device.name = "host_preprocessor"
settings_util.write(settings, updated_settings_output_path)
def device_host(binary_manager: binaries_util.BinaryManager) -> Device:
device = Device(name="host", host=DeviceHost())
update_device(binary_manager, device)
return device
def swift_shader_device(binary_manager: binaries_util.BinaryManager) -> Device:
device = Device(name="swift_shader", swift_shader=DeviceSwiftShader())
update_device(binary_manager, device)
return device
def fuzz_and_reduce_bug(
active_device: str,
seed: int,
check_result: Callable[[], None],
settings: Optional[Settings] = None,
ignored_signatures: Optional[List[str]] = None,
) -> None:
"""
Fuzz, find a bug, reduce it.
Linux only.
"""
# Test only works on Linux.
if util.get_platform() != "Linux":
return
here = util.norm_path(Path(__file__).absolute()).parent
temp_dir: Path = here.parent / "temp"
assert temp_dir.is_dir()
os.chdir(temp_dir)
# Create ROOT file in temp/ if needed.
fuzz.try_get_root_file()
work_dir = temp_dir / fuzz.get_random_name()[:8]
util.mkdir_p_new(work_dir)
os.chdir(work_dir)
log(f"Changed to {str(work_dir)}")
if settings is None:
settings = Settings()
settings.CopyFrom(settings_util.DEFAULT_SETTINGS)
settings.device_list.CopyFrom(
DeviceList(
active_device_names=[active_device],
devices=[
Device(
name="amdllpc",
shader_compiler=DeviceShaderCompiler(
binary="amdllpc",
args=[
"-gfxip=9.0.0", "-verify-ir", "-auto-layout-desc"
],
),
binaries=[
Binary(
name="amdllpc",
tags=["Release"],
version="c21d76dceaf26361f9b6b3838a955ec3301506b5",
),
],
),
Device(
name="swift_shader",
swift_shader=DeviceSwiftShader(),
binaries=[
Binary(
name="swift_shader_icd",
tags=["Release"],
version="6d69aae0e1ab49190ea46cd1c999fd3d02e016b9",
),
],
ignored_crash_signatures=ignored_signatures,
),
],
))
spirv_tools_version = "983b5b4fccea17cab053de24d51403efb4829158"
settings.latest_binary_versions.extend([
Binary(
name="glslangValidator",
tags=["Release"],
version="1afa2b8cc57b92c6b769eb44a6854510b6921a0b",
),
Binary(name="spirv-opt", tags=["Release"],
version=spirv_tools_version),
Binary(name="spirv-dis", tags=["Release"],
version=spirv_tools_version),
Binary(name="spirv-as", tags=["Release"], version=spirv_tools_version),
Binary(name="spirv-val", tags=["Release"],
version=spirv_tools_version),
Binary(name="spirv-fuzz",
tags=["Release"],
version=spirv_tools_version),
Binary(name="spirv-reduce",
tags=["Release"],
version=spirv_tools_version),
Binary(
name="graphicsfuzz-tool",
tags=[],
version="7b143bcb3ad38b64ddc17d132886636b229b6684",
),
])
# Add default binaries; the ones above have priority.
settings.latest_binary_versions.extend(binaries_util.DEFAULT_BINARIES)
settings.extra_graphics_fuzz_generate_args.append("--small")
settings.extra_graphics_fuzz_generate_args.append("--single-pass")
settings.extra_graphics_fuzz_reduce_args.append("--max-steps")
settings.extra_graphics_fuzz_reduce_args.append("2")
settings_util.write(settings, settings_util.DEFAULT_SETTINGS_FILE_PATH)
# Add shaders.
binary_manager = binaries_util.get_default_binary_manager(settings)
graphicsfuzz_tool = binary_manager.get_binary_path_by_name(
"graphicsfuzz-tool")
sample_shaders_path: Path = graphicsfuzz_tool.path.parent.parent.parent / "shaders" / "samples" / "310es"
util.copy_dir(sample_shaders_path, Path() / fuzz.REFERENCES_DIR)
util.copy_dir(sample_shaders_path, Path() / fuzz.DONORS_DIR)
fuzz.main_helper(
settings_path=settings_util.DEFAULT_SETTINGS_FILE_PATH,
iteration_seed_override=seed,
override_sigint=False,
use_amber_vulkan_loader=True,
)
check_result()
os.chdir(here)
shutil.rmtree(work_dir)
def main_helper( # pylint: disable=too-many-locals, too-many-branches, too-many-statements;
settings_path: Path,
iteration_seed_override: Optional[int] = None,
fuzzing_tool_pattern: Optional[List[FuzzingTool]] = None,
allow_no_stack_traces: bool = False,
override_sigint: bool = True,
use_amber_vulkan_loader: bool = False,
active_device_names: Optional[List[str]] = None,
update_ignored_crash_signatures_gerrit_cookie: Optional[str] = None,
) -> None:
if not fuzzing_tool_pattern:
fuzzing_tool_pattern = [FuzzingTool.GLSL_FUZZ]
util.update_gcov_environment_variable_if_needed()
if override_sigint:
interrupt_util.override_sigint()
try_get_root_file()
settings = settings_util.read_or_create(settings_path)
binary_manager = binaries_util.get_default_binary_manager(
settings=settings)
temp_dir = Path() / "temp"
# Note: we use "is not None" so that if the user passes an empty Gerrit cookie, we still try to execute this code.
if update_ignored_crash_signatures_gerrit_cookie is not None:
git_tool = util.tool_on_path("git")
downloaded_graphicsfuzz_tests_dir = (
temp_dir / f"graphicsfuzz_cts_tests_{get_random_name()[:8]}")
work_dir = temp_dir / f"graphicsfuzz_cts_run_{get_random_name()[:8]}"
download_cts_gf_tests.download_cts_graphicsfuzz_tests(
git_tool=git_tool,
cookie=update_ignored_crash_signatures_gerrit_cookie,
output_tests_dir=downloaded_graphicsfuzz_tests_dir,
)
download_cts_gf_tests.extract_shaders(
tests_dir=downloaded_graphicsfuzz_tests_dir,
binaries=binary_manager)
with util.file_open_text(work_dir / "results.csv",
"w") as results_out_handle:
run_cts_gf_tests.main_helper(
tests_dir=downloaded_graphicsfuzz_tests_dir,
work_dir=work_dir,
binaries=binary_manager,
settings=settings,
active_devices=devices_util.get_active_devices(
settings.device_list),
results_out_handle=results_out_handle,
updated_settings_output_path=settings_path,
)
return
active_devices = devices_util.get_active_devices(
settings.device_list, active_device_names=active_device_names)
# Add host_preprocessor device from device list if it is missing.
if not active_devices[0].HasField("preprocess"):
for device in settings.device_list.devices:
if device.HasField("preprocess"):
active_devices.insert(0, device)
break
# Add host_preprocessor device (from scratch) if it is still missing.
if not active_devices[0].HasField("preprocess"):
active_devices.insert(
0, Device(name="host_preprocessor", preprocess=DevicePreprocess()))
reports_dir = Path() / "reports"
fuzz_failures_dir = reports_dir / FUZZ_FAILURES_DIR_NAME
references_dir = Path() / REFERENCES_DIR
donors_dir = Path() / DONORS_DIR
spirv_fuzz_shaders_dir = Path() / "spirv_fuzz_shaders"
# Log a warning if there is no tool on the PATH for printing stack traces.
prepended = util.prepend_catchsegv_if_available([], log_warning=True)
if not allow_no_stack_traces and not prepended:
raise AssertionError("Stopping because we cannot get stack traces.")
spirv_fuzz_shaders: List[Path] = []
references: List[Path] = []
if FuzzingTool.SPIRV_FUZZ in fuzzing_tool_pattern:
check_dir_exists(spirv_fuzz_shaders_dir)
spirv_fuzz_shaders = sorted(spirv_fuzz_shaders_dir.rglob("*.json"))
if FuzzingTool.GLSL_FUZZ in fuzzing_tool_pattern:
check_dir_exists(references_dir)
check_dir_exists(donors_dir)
# TODO: make GraphicsFuzz find donors recursively.
references = sorted(references_dir.rglob("*.json"))
# Filter to only include .json files that have at least one shader (.frag, .vert, .comp) file.
references = [
ref for ref in references if shader_job_util.get_related_files(ref)
]
if use_amber_vulkan_loader:
library_path = binary_manager.get_binary_path_by_name(
binaries_util.AMBER_VULKAN_LOADER_NAME).path.parent
util.add_library_paths_to_environ([library_path], os.environ)
fuzzing_tool_index = 0
while True:
interrupt_util.interrupt_if_needed()
# We have to use "is not None" because the seed could be 0.
if iteration_seed_override is not None:
iteration_seed = iteration_seed_override
else:
iteration_seed = secrets.randbits(ITERATION_SEED_BITS)
log(f"Iteration seed: {iteration_seed}")
random.seed(iteration_seed)
staging_name = get_random_name()[:8]
staging_dir = temp_dir / staging_name
try:
util.mkdir_p_new(staging_dir)
except FileExistsError:
if iteration_seed_override is not None:
raise
log(f"Staging directory already exists: {str(staging_dir)}")
log("Starting new iteration.")
continue
# Pseudocode:
# - Create test_dir(s) in staging directory.
# - Run test_dir(s) on all active devices (stop early if appropriate).
# - For each test failure on each device, copy the test to reports_dir, adding the device and crash signature.
# - Reduce each report (on the given device).
# - Produce a summary for each report.
fuzzing_tool = fuzzing_tool_pattern[fuzzing_tool_index]
fuzzing_tool_index = (fuzzing_tool_index +
1) % len(fuzzing_tool_pattern)
if fuzzing_tool == FuzzingTool.SPIRV_FUZZ:
fuzz_spirv_test.fuzz_spirv(
staging_dir,
reports_dir,
fuzz_failures_dir,
active_devices,
spirv_fuzz_shaders,
settings,
binary_manager,
)
elif fuzzing_tool == FuzzingTool.GLSL_FUZZ:
fuzz_glsl_test.fuzz_glsl(
staging_dir,
reports_dir,
fuzz_failures_dir,
active_devices,
references,
donors_dir,
settings,
binary_manager,
)
else:
raise AssertionError(f"Unknown fuzzing tool: {fuzzing_tool}")
if iteration_seed_override is not None:
log("Stopping due to iteration_seed")
break
shutil.rmtree(staging_dir)
def main() -> None: # pylint: disable=too-many-locals;
parser = argparse.ArgumentParser(
description="Generates an AmberScript test from a shader job.")
parser.add_argument(
"shader_job",
help="The input .json shader job file.",
)
parser.add_argument(
"--output",
help="Output directory.",
default="output",
)
parser.add_argument(
"--spirv_opt_args",
help=
"Arguments for spirv-opt as a space-separated string, or an empty string to skip running spirv-opt.",
default="",
)
parser.add_argument(
"--settings",
help=
"Path to a settings JSON file for this instance. The file will be generated if needed. ",
default="settings.json",
)
parsed_args = parser.parse_args(sys.argv[1:])
shader_job: Path = Path(parsed_args.shader_job)
out_dir: Path = Path(parsed_args.output)
spirv_opt_args_str: str = parsed_args.spirv_opt_args
settings_path: Path = Path(parsed_args.settings)
spirv_opt_args: List[str] = []
if spirv_opt_args_str:
spirv_opt_args = spirv_opt_args_str.split(" ")
settings = settings_util.read_or_create(settings_path)
binary_manager = binaries_util.get_default_binary_manager(settings)
staging_dir = out_dir / "staging"
template_source_dir = staging_dir / "source_template"
test_dir = staging_dir / "test"
run_output_dir: Path = out_dir / "run"
# Remove stale directories.
if staging_dir.is_dir():
shutil.rmtree(staging_dir)
if run_output_dir.is_dir():
shutil.rmtree(run_output_dir)
# Create source template and call |make_test|.
if shader_job_util.get_related_suffixes_that_exist(
shader_job, language_suffix=[shader_job_util.SUFFIX_SPIRV]):
# This is a SPIR-V shader job.
shader_job_util.copy(
shader_job,
template_source_dir / test_util.VARIANT_DIR / test_util.SHADER_JOB,
language_suffix=shader_job_util.SUFFIXES_SPIRV_FUZZ_INPUT,
)
fuzz_spirv_amber_test.make_test(
template_source_dir,
test_dir,
spirv_opt_args=spirv_opt_args,
binary_manager=binary_manager,
derived_from=shader_job.stem,
stable_shader=False,
common_spirv_args=list(settings.common_spirv_args),
)
elif shader_job_util.get_related_suffixes_that_exist(
shader_job, language_suffix=[shader_job_util.SUFFIX_GLSL]):
# This is a GLSL shader job.
# The "graphicsfuzz-tool" tool is designed to be on your PATH so that e.g. ".bat" will be appended on Windows.
# So we use tool_on_path with a custom PATH to get the actual file we want to execute.
graphicsfuzz_tool_path = util.tool_on_path(
"graphicsfuzz-tool",
str(
binary_manager.get_binary_path_by_name(
"graphicsfuzz-tool").path.parent),
)
with util.file_open_text(staging_dir / "log.txt", "w") as log_file:
try:
gflogging.push_stream_for_logging(log_file)
# Create the prepared (for Vulkan GLSL) reference.
glsl_generate_util.run_prepare_reference(
graphicsfuzz_tool_path,
shader_job,
template_source_dir / test_util.VARIANT_DIR /
test_util.SHADER_JOB,
legacy_graphics_fuzz_vulkan_arg=settings.
legacy_graphics_fuzz_vulkan_arg,
)
finally:
gflogging.pop_stream_for_logging()
fuzz_glsl_amber_test.make_test(
template_source_dir,
test_dir,
spirv_opt_args=spirv_opt_args,
binary_manager=binary_manager,
derived_from=shader_job.stem,
stable_shader=False,
common_spirv_args=list(settings.common_spirv_args),
)
else:
raise AssertionError(
"Unexpected shader job type; expected GLSL or SPIR-V shaders.")
preprocessor_cache = util.CommandCache()
fuzz_test_util.run_shader_job(
source_dir=test_util.get_source_dir(test_dir),
output_dir=run_output_dir,
binary_manager=binary_manager,
device=Device(host=DeviceHost()),
preprocessor_cache=preprocessor_cache,
stop_after_amber=True,
)