mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-21 13:55:58 +00:00
Merge #602 into the non-Adreno test branch
This commit is contained in:
commit
e9f8f9d717
21 files changed
+2186
No files matched your search
Executable
+42
@@ -0,0 +1,42 @@
|
||||
#!/usr/bin/env bash
|
||||
# CI component build; this does not change the APK or an installed Proton depot.
|
||||
set -euo pipefail
|
||||
root=$(cd "$(dirname "$0")/../.." && pwd)
|
||||
. "$root/tools/dxvk/source.env"
|
||||
mkdir -p "${1:?output directory required}"
|
||||
out=$(cd "$1" && pwd)
|
||||
# Refuse to mix a pinned build with prior DLLs or an incomplete previous build.
|
||||
# Include dotfiles in the check and leave all existing contents untouched.
|
||||
shopt -s nullglob dotglob
|
||||
existing=("$out"/*)
|
||||
if ((${#existing[@]})); then
|
||||
printf '%s\n' 'output directory must be empty; use a fresh build directory' >&2
|
||||
exit 1
|
||||
fi
|
||||
shopt -u nullglob dotglob
|
||||
work=$(mktemp -d)
|
||||
trap 'rm -rf "$work"' EXIT
|
||||
git init -q "$work/source"
|
||||
git -C "$work/source" fetch --depth=1 https://github.com/doitsujin/dxvk.git "$DXVK_REVISION"
|
||||
git -C "$work/source" checkout -q --detach FETCH_HEAD
|
||||
test "$(git -C "$work/source" rev-parse HEAD)" = "$DXVK_REVISION"
|
||||
git -C "$work/source" submodule update --init --recursive --depth=1
|
||||
for patch in "$root"/tools/dxvk/patches/*.patch; do
|
||||
git -C "$work/source" apply --check "$patch"
|
||||
git -C "$work/source" apply "$patch"
|
||||
done
|
||||
python3 "$root/tools/dxvk/check_present_sync.py" "$work/source/src/dxvk/dxvk_presenter.cpp"
|
||||
python3 "$root/tools/dxvk/check_hud_storage_format.py" "$work/source/src/dxvk/hud/shaders/hud_frame_time_eval.comp"
|
||||
python3 "$root/tools/dxvk/check_d3d9_single_sample.py" "$work/source"
|
||||
for arch in 32 64; do
|
||||
meson setup "$work/build$arch" "$work/source" --cross-file "$work/source/build-win$arch.txt" \
|
||||
--buildtype release --prefix "$out" --bindir "x$arch" --libdir "x$arch" -Db_ndebug=if-release --strip
|
||||
meson compile -C "$work/build$arch" -j 4
|
||||
meson install -C "$work/build$arch"
|
||||
done
|
||||
cp "$work/source/LICENSE" "$out/LICENSE"
|
||||
printf '%s\n' "$DXVK_REVISION" > "$out/source-commit"
|
||||
git -C "$work/source" submodule status --recursive > "$out/submodules.txt"
|
||||
git -C "$work/source" diff > "$out/downstream.patch"
|
||||
tar --exclude-vcs --zstd -cf "$out/source.tar.zst" -C "$work/source" .
|
||||
(cd "$out" && find x32 x64 -name '*.dll' -type f -print0 | sort -z | xargs -0 sha256sum > SHA256SUMS)
|
||||
@@ -0,0 +1,112 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Compile pinned DXVK's actual descriptor paths against a controlled backend.
|
||||
|
||||
This checks CPU control flow, not GPU rendering. No Wine/game/device is started.
|
||||
"""
|
||||
import argparse
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
|
||||
CASES = ('forced_msaa_depth', 'default_msaa_depth', 'forced_nonmaskable',
|
||||
'default_nonmaskable', 'forced_already_single', 'forced_no_depth',
|
||||
'forced_unsupported', 'forced_invalid_type', 'forced_lockable_msaa',
|
||||
'forced_lockable_single', 'forced_allocation_failure',
|
||||
'default_allocation_failure', 'forced_recreate', 'ordinary_surface',
|
||||
'ordinary_invalid_lockable')
|
||||
|
||||
|
||||
def function(text, signature):
|
||||
start = text.index(signature)
|
||||
opening = text.index('{', start)
|
||||
# Ignore braces in comments and strings while preserving source positions.
|
||||
stripped = re.sub(r'//[^\n]*|/\*.*?\*/|"(?:\\.|[^"\\])*"|\'(?:\\.|[^\'\\])*\'',
|
||||
lambda m: ' ' * len(m.group()), text, flags=re.S)
|
||||
depth = 0
|
||||
for index in range(opening, len(stripped)):
|
||||
depth += (stripped[index] == '{') - (stripped[index] == '}')
|
||||
if depth == 0:
|
||||
return text[start:index + 1]
|
||||
raise ValueError('Unterminated source function: ' + signature)
|
||||
|
||||
|
||||
def production(source):
|
||||
base = source / 'src/d3d9'
|
||||
common = (base / 'd3d9_common_texture.cpp').read_text()
|
||||
header = (base / 'd3d9_common_texture.h').read_text()
|
||||
swap = (base / 'd3d9_swapchain.cpp').read_text()
|
||||
device = (base / 'd3d9_device.cpp').read_text()
|
||||
util = (base / 'd3d9_util.cpp').read_text()
|
||||
pieces = {
|
||||
'decode': function(util, 'HRESULT DecodeMultiSampleType('),
|
||||
'normalize': function(common, 'HRESULT D3D9CommonTexture::NormalizeTextureProperties('),
|
||||
'backbuffers': function(swap, 'HRESULT D3D9SwapChainEx::CreateBackBuffers('),
|
||||
'uses_image': function(header, 'static bool TextureUsesImage('),
|
||||
}
|
||||
reset = function(device, 'HRESULT D3D9DeviceEx::ResetSwapChain(')
|
||||
begin = reset.index('D3D9_COMMON_TEXTURE_DESC desc;', reset.index('if (pPresentationParameters->EnableAutoDepthStencil)'))
|
||||
end = reset.index('m_autoDepthStencil =', begin)
|
||||
pieces['auto_depth'] = reset[begin:end].rstrip()
|
||||
framebuffer = function(device, 'void D3D9DeviceEx::BindFramebuffer(')
|
||||
begin = framebuffer.index('const bool mismatch =')
|
||||
end = framebuffer.index(';', framebuffer.index('const bool bindDS =', begin)) + 1
|
||||
pieces['depth_binding'] = framebuffer[begin:end]
|
||||
return pieces
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('source', type=Path, help='Pinned DXVK tree with downstream patches applied')
|
||||
parser.add_argument('--cxx', default=os.environ.get('CXX', 'c++'))
|
||||
parser.add_argument('--sanitize', action='store_true', help='Enable ASan/UBSan on the CPU harness')
|
||||
args = parser.parse_args()
|
||||
pieces = production(args.source)
|
||||
harness = (Path(__file__).parent / 'tests/d3d9_single_sample.cpp').read_text()
|
||||
harness = harness.replace('/* PRODUCTION_USES_IMAGE */', pieces['uses_image'])
|
||||
with tempfile.TemporaryDirectory(prefix='dxvk-d3d9-') as directory:
|
||||
out = Path(directory)
|
||||
(out / 'harness.cpp').write_text(harness)
|
||||
include = '\n\n'.join(pieces[key] for key in ('decode', 'normalize', 'backbuffers'))
|
||||
include += '\nHRESULT auto_depth(D3D9DeviceEx* device, D3DPRESENT_PARAMETERS* pPresentationParameters, D3D9_COMMON_TEXTURE_DESC* output) {\n'
|
||||
include += 'auto* self = device;\n' + pieces['auto_depth'].replace('(this,', '(self,')
|
||||
include += '\n*output = desc; return D3D_OK;\n}\n'
|
||||
include += '\nbool depth_binds(const ImageInfo& color, const ImageInfo& dsInfo) {\n'
|
||||
include += 'auto sampleCount = color.sampleCount; auto renderArea = color.extent;\n'
|
||||
include += 'const bool noRT0Bound = false, ignoreRT0 = false;\n'
|
||||
include += pieces['depth_binding'] + '\nreturn bindDS;\n}\n'
|
||||
(out / 'd3d9_production.inc').write_text(include)
|
||||
command = [args.cxx, '-std=c++17', '-Wall', '-Wextra', '-Werror',
|
||||
'-Wno-unused-parameter', str(out / 'harness.cpp'), '-o', str(out / 'check')]
|
||||
# The original CreateBackBuffers does not use Flags; that known baseline
|
||||
# warning must not turn a negative control into a compiler-fixture error.
|
||||
if args.sanitize:
|
||||
command[1:1] = ['-fsanitize=address,undefined', '-fno-omit-frame-pointer']
|
||||
compilation = subprocess.run(command, capture_output=True, text=True)
|
||||
if compilation.returncode:
|
||||
raise SystemExit(compilation.stderr)
|
||||
results = []
|
||||
for case in CASES:
|
||||
process = subprocess.run([str(out / 'check'), case], capture_output=True,
|
||||
text=True, timeout=10, cwd=out,
|
||||
env={'ASAN_OPTIONS': 'detect_leaks=' +
|
||||
('0' if sys.platform == 'darwin' else '1')})
|
||||
results.append({'case': case, 'passed': process.returncode == 0,
|
||||
'exit': process.returncode, 'detail': process.stderr.strip()[-800:]})
|
||||
result = {'cases': results, 'passed': sum(row['passed'] for row in results),
|
||||
'failed': sum(not row['passed'] for row in results),
|
||||
'production_sha256': {key: hashlib.sha256(value.encode()).hexdigest()
|
||||
for key, value in pieces.items()},
|
||||
'backend_and_adapter_mocked': True, 'GPU_test': False,
|
||||
'sanitizers': args.sanitize,
|
||||
'leak_detection': args.sanitize and sys.platform != 'darwin'}
|
||||
print(json.dumps(result, indent=2))
|
||||
return bool(result['failed'])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,73 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Compile the actual HUD shader and verify its binding-3 R8_UINT contract.
|
||||
|
||||
The frame-time HUD binds an R8_UINT texel-buffer view. An Unknown SPIR-V image
|
||||
format requires STORAGE_WRITE_WITHOUT_FORMAT, which PowerVR does not report
|
||||
for that buffer format. Static spirv-val alone accepts both declarations;
|
||||
this check validates the shader against the known host-side binding contract.
|
||||
"""
|
||||
import argparse
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import struct
|
||||
import subprocess
|
||||
import tempfile
|
||||
|
||||
|
||||
def check(shader):
|
||||
compiler = shutil.which('glslangValidator')
|
||||
validator = shutil.which('spirv-val')
|
||||
if not compiler or not validator:
|
||||
raise RuntimeError('glslangValidator and spirv-val required')
|
||||
with tempfile.TemporaryDirectory(prefix='dxvk-hud-contract-') as directory:
|
||||
output = Path(directory) / 'hud.spv'
|
||||
for command in ([compiler, '-V', '--target-env', 'vulkan1.3', str(shader), '-o', str(output)],
|
||||
[validator, '--target-env', 'vulkan1.3', str(output)]):
|
||||
process = subprocess.run(command, capture_output=True, text=True, timeout=30)
|
||||
if process.returncode:
|
||||
raise RuntimeError('HUD shader compilation/SPIR-V validation failed')
|
||||
raw = output.read_bytes()
|
||||
if len(raw) < 20 or len(raw) % 4:
|
||||
raise RuntimeError('Malformed SPIR-V')
|
||||
words = struct.unpack('<' + str(len(raw) // 4) + 'I', raw)
|
||||
if words[0] != 0x07230203:
|
||||
raise RuntimeError('Unexpected SPIR-V magic')
|
||||
bindings, sets, variables, pointers, images = {}, {}, {}, {}, {}
|
||||
offset = 5
|
||||
while offset < len(words):
|
||||
size, opcode = words[offset] >> 16, words[offset] & 0xffff
|
||||
if not size or size > len(words) - offset:
|
||||
raise RuntimeError('Malformed SPIR-V instruction')
|
||||
instruction = words[offset:offset + size]
|
||||
if opcode == 71 and size == 4: # OpDecorate
|
||||
if instruction[2] == 33:
|
||||
bindings[instruction[1]] = instruction[3]
|
||||
elif instruction[2] == 34:
|
||||
sets[instruction[1]] = instruction[3]
|
||||
elif opcode == 59 and size >= 4: # OpVariable
|
||||
variables[instruction[2]] = instruction[1]
|
||||
elif opcode == 32 and size == 4: # OpTypePointer
|
||||
pointers[instruction[1]] = instruction[3]
|
||||
elif opcode == 25 and size >= 9: # OpTypeImage
|
||||
images[instruction[1]] = (instruction[3], instruction[7], instruction[8])
|
||||
offset += size
|
||||
targets = [images.get(pointers.get(variables.get(identifier)))
|
||||
for identifier, binding in bindings.items()
|
||||
if binding == 3 and sets.get(identifier) == 0]
|
||||
if targets != [(5, 2, 39)]: # DimBuffer, storage image, ImageFormatR8ui
|
||||
raise RuntimeError('HUD binding 3 must compile to a storage texel buffer with ImageFormatR8ui')
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('shader', type=Path)
|
||||
args = parser.parse_args()
|
||||
try:
|
||||
check(args.shader)
|
||||
except RuntimeError as error:
|
||||
parser.exit(1, str(error) + '\n')
|
||||
print('HUD binding 3: SPIR-V valid, explicit R8ui storage texel-buffer format')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -0,0 +1,116 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Replay asynchronous WSI ownership using the pinned presenter's actual selections.
|
||||
|
||||
This checks semaphore selection, not the full Vulkan presenter. Real Vulkan
|
||||
validation and device testing remain separate gates. Requires a native C++ compiler.
|
||||
"""
|
||||
import argparse
|
||||
import os
|
||||
from pathlib import Path
|
||||
import re
|
||||
import subprocess
|
||||
import tempfile
|
||||
|
||||
|
||||
def selection_code(source):
|
||||
match = re.search(
|
||||
r"// Return relevant Vulkan objects for the acquired image\s*"
|
||||
r"(?P<acquire>.*?)\s*m_presentPending = true;", source, re.S)
|
||||
wait = re.search(r"info\.pWaitSemaphores\s*=.*?;", source, re.S)
|
||||
if not match or not wait:
|
||||
raise ValueError("unsupported pinned presenter layout")
|
||||
return match["acquire"], wait[0]
|
||||
|
||||
|
||||
HARNESS = r'''
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
#include <cstdio>
|
||||
#include <vector>
|
||||
using VkSemaphore = uint64_t;
|
||||
struct Sync { VkSemaphore acquire, present; };
|
||||
struct Info { const VkSemaphore* pWaitSemaphores; };
|
||||
|
||||
struct Presenter {
|
||||
std::vector<Sync> m_semaphores;
|
||||
std::vector<unsigned> m_images = {0, 1, 2, 3};
|
||||
unsigned m_frameIndex = 0, m_imageIndex = 0;
|
||||
bool m_hasSwapchainMaintenance1;
|
||||
explicit Presenter(bool maintenance): m_hasSwapchainMaintenance1(maintenance) {
|
||||
for (unsigned i = 0; i < (maintenance ? 4u : 8u); ++i)
|
||||
m_semaphores.push_back({100 + i, 1 + i});
|
||||
}
|
||||
Sync acquire() {
|
||||
Sync sync{}; unsigned image;
|
||||
ACQUIRE_SELECTION
|
||||
(void)image;
|
||||
return sync;
|
||||
}
|
||||
VkSemaphore present() {
|
||||
auto& currSync = m_semaphores.at(m_frameIndex);
|
||||
Info info{};
|
||||
PRESENT_SELECTION
|
||||
return *info.pWaitSemaphores;
|
||||
}
|
||||
};
|
||||
|
||||
int replay(bool maintenance) {
|
||||
Presenter p(maintenance);
|
||||
std::array<VkSemaphore, 4> outstandingByImage{};
|
||||
std::array<VkSemaphore, 4> outstandingByFence{};
|
||||
// Deliberately delay reacquisition of image 2 beyond a full frame-ring cycle.
|
||||
const std::array<unsigned, 21> imageOrder = {
|
||||
2,0,3,0,1,3,0,1,1,2,3,1,0,3,2,2,0,1,3,0,2
|
||||
};
|
||||
for (unsigned iteration = 0; iteration < 200; ++iteration) {
|
||||
p.m_imageIndex = imageOrder[iteration % imageOrder.size()];
|
||||
if (maintenance) {
|
||||
// The existing fence path waits this frame's previous present fence.
|
||||
const auto completed = outstandingByFence.at(p.m_frameIndex);
|
||||
for (auto& pending : outstandingByImage)
|
||||
if (pending == completed) pending = 0;
|
||||
}
|
||||
// Acquisition and its GPU wait complete the last present of THIS image.
|
||||
outstandingByImage.at(p.m_imageIndex) = 0;
|
||||
const auto signal = p.acquire().present;
|
||||
const auto wait = p.present();
|
||||
if (signal != wait) {
|
||||
std::fprintf(stderr, "FAIL: render signal differs from present wait\n");
|
||||
return 2;
|
||||
}
|
||||
for (auto pending : outstandingByImage) {
|
||||
if (pending == signal) {
|
||||
std::fprintf(stderr, "FAIL: semaphore reused before presentation completion at frame %u\n", iteration);
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
outstandingByImage.at(p.m_imageIndex) = signal;
|
||||
if (maintenance) outstandingByFence.at(p.m_frameIndex) = signal;
|
||||
p.m_frameIndex = (p.m_frameIndex + 1) % p.m_semaphores.size();
|
||||
}
|
||||
std::printf("PASS: %s, 200 out-of-order acquisitions\n", maintenance ? "present-fence path" : "no-present-fence path");
|
||||
return 0;
|
||||
}
|
||||
int main() {
|
||||
if (int status = replay(false)) return status;
|
||||
return replay(true);
|
||||
}
|
||||
'''
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("source", type=Path, help="pinned dxvk_presenter.cpp, after patching")
|
||||
args = parser.parse_args()
|
||||
acquire, present = selection_code(args.source.read_text())
|
||||
code = HARNESS.replace("ACQUIRE_SELECTION", acquire).replace("PRESENT_SELECTION", present)
|
||||
with tempfile.TemporaryDirectory(prefix="dxvk-present-sync-") as directory:
|
||||
cpp = Path(directory) / "replay.cpp"
|
||||
exe = Path(directory) / "replay"
|
||||
cpp.write_text(code)
|
||||
subprocess.run([os.environ.get("HOST_CXX", "c++"), "-std=c++17", "-Wall", "-Wextra", str(cpp), "-o", str(exe)], check=True)
|
||||
return subprocess.run([str(exe)]).returncode
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,53 @@
|
||||
diff --git a/src/dxvk/dxvk_device_info.cpp b/src/dxvk/dxvk_device_info.cpp
|
||||
index db09fba..8e9a76e 100644
|
||||
--- a/src/dxvk/dxvk_device_info.cpp
|
||||
+++ b/src/dxvk/dxvk_device_info.cpp
|
||||
@@ -118,6 +118,17 @@ namespace dxvk {
|
||||
initQueueProperties(instance, adapter, deviceInfo);
|
||||
initMemoryProperties(instance, adapter);
|
||||
|
||||
+ m_hasBcFormats = true;
|
||||
+ for (uint32_t value = VK_FORMAT_BC1_RGBA_UNORM_BLOCK; value <= VK_FORMAT_BC7_SRGB_BLOCK; value++) {
|
||||
+ VkFormatProperties properties = { };
|
||||
+ vk->vkGetPhysicalDeviceFormatProperties(adapter, VkFormat(value), &properties);
|
||||
+ constexpr VkFormatFeatureFlags required = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
|
||||
+ | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
|
||||
+ | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
|
||||
+ if ((properties.optimalTilingFeatures & required) != required)
|
||||
+ m_hasBcFormats = false;
|
||||
+ }
|
||||
+
|
||||
disableUnusedFeatures(instance, safeMode);
|
||||
|
||||
enableFeaturesAndExtensions();
|
||||
@@ -785,6 +796,9 @@ namespace dxvk {
|
||||
}
|
||||
}
|
||||
|
||||
+ if (!m_hasBcFormats)
|
||||
+ return std::string("Device does not support the BC formats required by Direct3D");
|
||||
+
|
||||
if (!m_featuresEnabled.extDescriptorHeap.descriptorHeap && m_properties.core.properties.limits.maxPushConstantsSize < MaxTotalPushDataSize)
|
||||
return str::format("Device does not support ", MaxTotalPushDataSize, " of push data");
|
||||
|
||||
@@ -886,7 +900,7 @@ namespace dxvk {
|
||||
ENABLE_FEATURE(core.features, shaderResourceResidency, false),
|
||||
ENABLE_FEATURE(core.features, shaderResourceMinLod, false),
|
||||
ENABLE_FEATURE(core.features, tessellationShader, false),
|
||||
- ENABLE_FEATURE(core.features, textureCompressionBC, true),
|
||||
+ ENABLE_FEATURE(core.features, textureCompressionBC, false),
|
||||
ENABLE_FEATURE(core.features, variableMultisampleRate, false),
|
||||
ENABLE_FEATURE(core.features, vertexPipelineStoresAndAtomics, false),
|
||||
ENABLE_FEATURE(core.features, wideLines, false),
|
||||
diff --git a/src/dxvk/dxvk_device_info.h b/src/dxvk/dxvk_device_info.h
|
||||
index 0a55f90..8bbc770 100644
|
||||
--- a/src/dxvk/dxvk_device_info.h
|
||||
+++ b/src/dxvk/dxvk_device_info.h
|
||||
@@ -394,6 +394,7 @@ namespace dxvk {
|
||||
|
||||
DxvkDeviceQueueMapping m_queueMapping = { };
|
||||
|
||||
+ bool m_hasBcFormats = false;
|
||||
bool m_hasMeshShader = false;
|
||||
bool m_hasFmask = false;
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
diff --git a/src/dxvk/dxvk_presenter.cpp b/src/dxvk/dxvk_presenter.cpp
|
||||
index 643f7c5..4dc8c4d 100644
|
||||
--- a/src/dxvk/dxvk_presenter.cpp
|
||||
+++ b/src/dxvk/dxvk_presenter.cpp
|
||||
@@ -161,6 +161,10 @@ namespace dxvk {
|
||||
|
||||
// Return relevant Vulkan objects for the acquired image
|
||||
sync = m_semaphores.at(m_frameIndex);
|
||||
+ // Without a present fence, reacquiring this image is the only guarantee
|
||||
+ // that its previous presentation has consumed the wait semaphore.
|
||||
+ if (!m_hasSwapchainMaintenance1)
|
||||
+ sync.present = m_semaphores.at(m_imageIndex).present;
|
||||
image = m_images.at(m_imageIndex);
|
||||
|
||||
m_presentPending = true;
|
||||
@@ -239,7 +243,9 @@ namespace dxvk {
|
||||
|
||||
VkPresentInfoKHR info = { VK_STRUCTURE_TYPE_PRESENT_INFO_KHR };
|
||||
info.waitSemaphoreCount = 1;
|
||||
- info.pWaitSemaphores = &currSync.present;
|
||||
+ info.pWaitSemaphores = m_hasSwapchainMaintenance1
|
||||
+ ? &currSync.present
|
||||
+ : &m_semaphores.at(m_imageIndex).present;
|
||||
info.swapchainCount = 1;
|
||||
info.pSwapchains = &m_swapchain;
|
||||
info.pImageIndices = &m_imageIndex;
|
||||
@@ -0,0 +1,12 @@
|
||||
--- a/src/dxvk/hud/shaders/hud_frame_time_eval.comp
|
||||
+++ b/src/dxvk/hud/shaders/hud_frame_time_eval.comp
|
||||
@@ -41,7 +41,8 @@
|
||||
draw_info_t draw_infos[];
|
||||
};
|
||||
|
||||
-layout(binding = 3)
|
||||
+// The bound text view is VK_FORMAT_R8_UINT; do not require formatless writes.
|
||||
+layout(binding = 3, r8ui)
|
||||
uniform writeonly uimageBuffer text_buffer;
|
||||
|
||||
layout(push_constant)
|
||||
@@ -0,0 +1,86 @@
|
||||
diff --git a/dxvk.conf b/dxvk.conf
|
||||
index ba4bc20..26d3127 100644
|
||||
--- a/dxvk.conf
|
||||
+++ b/dxvk.conf
|
||||
@@ -336,6 +336,15 @@
|
||||
|
||||
# d3d11.disableMsaa = False
|
||||
|
||||
+# Forces D3D9 surfaces to single-sample after validating the original request.
|
||||
+# The effective surface description reports D3DMULTISAMPLE_NONE; MSAA quality,
|
||||
+# alpha-to-coverage and per-sample masks are consequently disabled. This is an
|
||||
+# opt-in compatibility override for games with broken MSAA rendering.
|
||||
+#
|
||||
+# Supported values: True, False
|
||||
+
|
||||
+# d3d9.forceSingleSample = False
|
||||
+
|
||||
|
||||
# Forces insertion of memory and control barriers after writes to group-shared
|
||||
# memory in compute shaders. This is only intended to be used as a workaround
|
||||
diff --git a/src/d3d9/d3d9_common_texture.cpp b/src/d3d9/d3d9_common_texture.cpp
|
||||
index 9d5fe38..629fea3 100644
|
||||
--- a/src/d3d9/d3d9_common_texture.cpp
|
||||
+++ b/src/d3d9/d3d9_common_texture.cpp
|
||||
@@ -212,6 +212,15 @@ namespace dxvk {
|
||||
return D3DERR_INVALIDCALL;
|
||||
}
|
||||
|
||||
+ // Keep original request validation above. This opt-in override changes
|
||||
+ // the effective surface description as well as the backing image.
|
||||
+ // All surface descriptors and resolves then see the actual sample count.
|
||||
+ if (ResourceType == D3DRTYPE_SURFACE && options->forceSingleSample
|
||||
+ && sampleCount != VK_SAMPLE_COUNT_1_BIT) {
|
||||
+ pDesc->MultiSample = D3DMULTISAMPLE_NONE;
|
||||
+ pDesc->MultisampleQuality = 0;
|
||||
+ }
|
||||
+
|
||||
// Using MANAGED pool with DYNAMIC usage is illegal
|
||||
if (IsPoolManaged(pDesc->Pool) && (pDesc->Usage & D3DUSAGE_DYNAMIC))
|
||||
return D3DERR_INVALIDCALL;
|
||||
diff --git a/src/d3d9/d3d9_options.cpp b/src/d3d9/d3d9_options.cpp
|
||||
index e46864e..0cab7dc 100644
|
||||
--- a/src/d3d9/d3d9_options.cpp
|
||||
+++ b/src/d3d9/d3d9_options.cpp
|
||||
@@ -59,6 +59,7 @@ namespace dxvk {
|
||||
this->memoryTrackTest = config.getOption<bool> ("d3d9.memoryTrackTest", false);
|
||||
this->forceSamplerTypeSpecConstants = config.getOption<bool> ("d3d9.forceSamplerTypeSpecConstants", false);
|
||||
this->forceSampleRateShading = config.getOption<bool> ("d3d9.forceSampleRateShading", false);
|
||||
+ this->forceSingleSample = config.getOption<bool> ("d3d9.forceSingleSample", false);
|
||||
this->forceAspectRatio = config.getOption<std::string> ("d3d9.forceAspectRatio", "");
|
||||
this->forceRefreshRate = config.getOption<int32_t> ("d3d9.forceRefreshRate", 0u);
|
||||
this->modeCountCompatibility = config.getOption<bool> ("d3d9.modeCountCompatibility", false);
|
||||
diff --git a/src/d3d9/d3d9_options.h b/src/d3d9/d3d9_options.h
|
||||
index e69a39a..4478420 100644
|
||||
--- a/src/d3d9/d3d9_options.h
|
||||
+++ b/src/d3d9/d3d9_options.h
|
||||
@@ -113,6 +113,9 @@ namespace dxvk {
|
||||
/// Forces sample rate shading
|
||||
bool forceSampleRateShading;
|
||||
|
||||
+ /// Optional compatibility override: report and render surfaces as single-sample.
|
||||
+ bool forceSingleSample;
|
||||
+
|
||||
/// Allow D3DLOCK_DISCARD
|
||||
bool allowDiscard;
|
||||
|
||||
diff --git a/src/d3d9/d3d9_swapchain.cpp b/src/d3d9/d3d9_swapchain.cpp
|
||||
--- a/src/d3d9/d3d9_swapchain.cpp
|
||||
+++ b/src/d3d9/d3d9_swapchain.cpp
|
||||
@@ -1055,1 +1055,16 @@ namespace dxvk {
|
||||
+ if (m_parent->GetOptions()->forceSingleSample) {
|
||||
+ // Backbuffers bypass the normal surface-creation entry points. Validate
|
||||
+ // the application's request, then apply the same effective sample count.
|
||||
+ // IsLockable above is an internal GDI fallback requirement, not the
|
||||
+ // application's lockability request used by MSAA validation.
|
||||
+ auto requestedDesc = desc;
|
||||
+ requestedDesc.IsLockable = (Flags & D3DPRESENTFLAG_LOCKABLE_BACKBUFFER) != 0;
|
||||
+ HRESULT hr = D3D9CommonTexture::NormalizeTextureProperties(
|
||||
+ m_parent, D3DRTYPE_SURFACE, &requestedDesc);
|
||||
+ if (FAILED(hr))
|
||||
+ return hr;
|
||||
+ desc.MultiSample = requestedDesc.MultiSample;
|
||||
+ desc.MultisampleQuality = requestedDesc.MultisampleQuality;
|
||||
+ }
|
||||
+
|
||||
const bool isExtended = m_parent->IsD3DCompatibile(D3DCompatibility::D3D9Ex);
|
||||
@@ -0,0 +1 @@
|
||||
DXVK_REVISION=25ca63f17f34bdc05a39873ee63907d3cbbfa030
|
||||
@@ -0,0 +1,214 @@
|
||||
// Backend/adapter fixture for the verbatim DXVK functions in d3d9_production.inc.
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <cstdint>
|
||||
#include <memory>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
using HRESULT = int32_t;
|
||||
using DWORD = uint32_t;
|
||||
using UINT = uint32_t;
|
||||
using VkSampleCountFlagBits = uint32_t;
|
||||
constexpr HRESULT D3D_OK = 0, D3DERR_INVALIDCALL = -1,
|
||||
D3DERR_NOTAVAILABLE = -2, D3DERR_OUTOFVIDEOMEMORY = -3;
|
||||
constexpr uint32_t VK_SAMPLE_COUNT_1_BIT = 1, VK_IMAGE_ASPECT_COLOR_BIT = 1;
|
||||
constexpr bool FALSE = false, TRUE = true;
|
||||
#define FAILED(x) ((x) < 0)
|
||||
#define unlikely(x) (x)
|
||||
enum D3DMULTISAMPLE_TYPE { D3DMULTISAMPLE_NONE, D3DMULTISAMPLE_NONMASKABLE,
|
||||
D3DMULTISAMPLE_16_SAMPLES = 16 };
|
||||
enum D3DRESOURCETYPE { D3DRTYPE_SURFACE, D3DRTYPE_CUBETEXTURE, D3DRTYPE_VOLUMETEXTURE };
|
||||
enum D3DPOOL { D3DPOOL_DEFAULT, D3DPOOL_MANAGED, D3DPOOL_SYSTEMMEM, D3DPOOL_SCRATCH };
|
||||
enum class D3DCompatibility { D3D9Ex };
|
||||
enum class D3D9Format { X8R8G8B8, D24S8, A8, NULL_FORMAT, ATI2,
|
||||
D32_LOCKABLE, D32F_LOCKABLE, D16_LOCKABLE, S8_LOCKABLE };
|
||||
constexpr DWORD D3DUSAGE_RENDERTARGET = 1, D3DUSAGE_DEPTHSTENCIL = 2,
|
||||
D3DUSAGE_DYNAMIC = 4, D3DUSAGE_WRITEONLY = 8, D3DUSAGE_AUTOGENMIPMAP = 16;
|
||||
constexpr DWORD D3DPRESENTFLAG_LOCKABLE_BACKBUFFER = 1, D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL = 2;
|
||||
constexpr int D3DDEVTYPE_HAL = 1, VK_IMAGE_LAYOUT_UNDEFINED = 0;
|
||||
struct Extent { uint32_t width, height, depth = 1; };
|
||||
namespace util {
|
||||
uint32_t computeMipLevelCount(Extent e) {
|
||||
uint32_t n = std::max({e.width, e.height, e.depth}), levels = 0;
|
||||
do { ++levels; n >>= 1; } while (n);
|
||||
return levels;
|
||||
}
|
||||
}
|
||||
bool IsPoolManaged(D3DPOOL pool) { return pool == D3DPOOL_MANAGED; }
|
||||
bool IsDXTFormat(D3D9Format) { return false; }
|
||||
bool IsDepthStencilFormat(D3D9Format format) { return format == D3D9Format::D24S8; }
|
||||
bool IsLockableDepthStencilFormat(D3D9Format) { return false; }
|
||||
struct D3D9_FORMAT_BLOCK_SIZE { uint32_t Width, Height; };
|
||||
D3D9_FORMAT_BLOCK_SIZE GetFormatAlignedBlockSize(D3D9Format) { return {1, 1}; }
|
||||
D3D9Format EnumerateFormat(D3D9Format format) { return format; }
|
||||
struct D3D9_COMMON_TEXTURE_DESC {
|
||||
uint32_t Width = 1280, Height = 720, Depth = 1, MipLevels = 1, ArraySize = 1;
|
||||
D3D9Format Format = D3D9Format::X8R8G8B8;
|
||||
D3DMULTISAMPLE_TYPE MultiSample = D3DMULTISAMPLE_NONE;
|
||||
DWORD MultisampleQuality = 0;
|
||||
D3DPOOL Pool = D3DPOOL_DEFAULT;
|
||||
DWORD Usage = D3DUSAGE_RENDERTARGET;
|
||||
bool Discard = false, IsBackBuffer = false, IsAttachmentOnly = false, IsLockable = false;
|
||||
};
|
||||
struct D3DPRESENT_PARAMETERS {
|
||||
uint32_t BackBufferWidth = 1280, BackBufferHeight = 720;
|
||||
D3D9Format BackBufferFormat = D3D9Format::X8R8G8B8;
|
||||
D3DMULTISAMPLE_TYPE MultiSampleType = D3DMULTISAMPLE_TYPE(4);
|
||||
DWORD MultiSampleQuality = 0, Flags = 0;
|
||||
D3D9Format AutoDepthStencilFormat = D3D9Format::D24S8;
|
||||
};
|
||||
struct Options {
|
||||
bool forceSingleSample = false, extraFrontbuffer = false,
|
||||
disableA8RT = false, supportCubeDepthFormats = false;
|
||||
};
|
||||
struct FormatMapping {
|
||||
uint32_t Aspect;
|
||||
bool IsValid() const { return true; }
|
||||
};
|
||||
struct Adapter {
|
||||
bool supported = true;
|
||||
std::vector<D3DMULTISAMPLE_TYPE> checked;
|
||||
HRESULT CheckDeviceMultiSampleType(int, D3D9Format, bool, D3DMULTISAMPLE_TYPE samples, void*) {
|
||||
checked.push_back(samples);
|
||||
return supported ? D3D_OK : D3DERR_NOTAVAILABLE;
|
||||
}
|
||||
};
|
||||
struct ImageInfo { Extent extent; VkSampleCountFlagBits sampleCount; };
|
||||
struct DxvkImage { ImageInfo info; };
|
||||
template<typename T> using Rc = std::shared_ptr<T>;
|
||||
template<typename T, unsigned N> using small_vector = std::vector<T>;
|
||||
struct DxvkContext {
|
||||
unsigned initialized = 0;
|
||||
void initImage(const Rc<DxvkImage>&, int) { ++initialized; }
|
||||
};
|
||||
struct D3D9DeviceEx {
|
||||
Options options;
|
||||
Adapter adapter;
|
||||
DxvkContext context;
|
||||
unsigned attempts = 0, failAt = 0, losable = 0, live = 0, injected = 0;
|
||||
std::vector<D3D9_COMMON_TEXTURE_DESC> created;
|
||||
Options* GetOptions() { return &options; }
|
||||
Adapter* GetAdapter() { return &adapter; }
|
||||
FormatMapping LookupFormat(D3D9Format format) { return {IsDepthStencilFormat(format) ? 2u : 1u}; }
|
||||
struct Unsupported { unsigned elementSize = 0; };
|
||||
Unsupported unsupported;
|
||||
const Unsupported* UnsupportedFormatInfo(D3D9Format) { return &unsupported; }
|
||||
bool IsD3DCompatibile(D3DCompatibility) { return false; }
|
||||
void IncrementLosableCounter() { ++losable; }
|
||||
template<typename F> void InjectCs(F function) { ++injected; function(&context); }
|
||||
};
|
||||
HRESULT DecodeMultiSampleType(D3DMULTISAMPLE_TYPE, DWORD, VkSampleCountFlagBits*);
|
||||
struct D3D9CommonTexture {
|
||||
Rc<DxvkImage> image;
|
||||
const Rc<DxvkImage>& GetImage() const { return image; }
|
||||
static HRESULT NormalizeTextureProperties(D3D9DeviceEx*, D3DRESOURCETYPE, D3D9_COMMON_TEXTURE_DESC*);
|
||||
/* PRODUCTION_USES_IMAGE */
|
||||
};
|
||||
class DxvkError : public std::runtime_error {
|
||||
public:
|
||||
using std::runtime_error::runtime_error;
|
||||
std::string message() const { return what(); }
|
||||
};
|
||||
struct Logger { static void err(const std::string&) {} };
|
||||
struct D3D9SwapChainEx;
|
||||
struct D3D9Surface {
|
||||
D3D9CommonTexture texture;
|
||||
D3D9DeviceEx* device;
|
||||
D3D9Surface(D3D9DeviceEx* d, D3D9_COMMON_TEXTURE_DESC* desc, bool, D3D9SwapChainEx*, void*) : device(d) {
|
||||
if (++d->attempts == d->failAt) throw DxvkError("controlled allocation failure");
|
||||
VkSampleCountFlagBits samples;
|
||||
if (FAILED(DecodeMultiSampleType(desc->MultiSample, desc->MultisampleQuality, &samples)))
|
||||
throw DxvkError("invalid backend sample count");
|
||||
texture.image = std::make_shared<DxvkImage>(DxvkImage{{{desc->Width, desc->Height}, samples}});
|
||||
d->created.push_back(*desc); ++d->live;
|
||||
}
|
||||
~D3D9Surface() { --device->live; }
|
||||
D3D9CommonTexture* GetCommonTexture() { return &texture; }
|
||||
};
|
||||
struct D3D9SwapChainEx {
|
||||
D3D9DeviceEx* m_parent;
|
||||
D3DPRESENT_PARAMETERS m_presentParams;
|
||||
std::vector<std::unique_ptr<D3D9Surface>> m_backBuffers;
|
||||
bool flip = false;
|
||||
unsigned destroys = 0;
|
||||
bool SwapWithFrontBuffer() { return flip; }
|
||||
void DestroyBackBuffers() { ++destroys; m_backBuffers.clear(); }
|
||||
HRESULT CreateBackBuffers(uint32_t, DWORD);
|
||||
};
|
||||
#include "d3d9_production.inc"
|
||||
|
||||
void paired(bool enabled, D3DMULTISAMPLE_TYPE type, DWORD quality) {
|
||||
D3D9DeviceEx device; device.options.forceSingleSample = enabled;
|
||||
device.options.extraFrontbuffer = true;
|
||||
D3D9SwapChainEx chain{&device, {}, {}};
|
||||
chain.m_presentParams.MultiSampleType = type; chain.m_presentParams.MultiSampleQuality = quality;
|
||||
assert(chain.CreateBackBuffers(2, 0) == D3D_OK);
|
||||
D3D9_COMMON_TEXTURE_DESC depth;
|
||||
assert(auto_depth(&device, &chain.m_presentParams, &depth) == D3D_OK);
|
||||
VkSampleCountFlagBits requested, dsSamples;
|
||||
assert(DecodeMultiSampleType(type, quality, &requested) == D3D_OK);
|
||||
assert(DecodeMultiSampleType(depth.MultiSample, depth.MultisampleQuality, &dsSamples) == D3D_OK);
|
||||
assert(chain.m_backBuffers.size() == 3 && device.context.initialized == 3);
|
||||
for (const auto& surface : chain.m_backBuffers) {
|
||||
const auto& image = surface->GetCommonTexture()->GetImage()->info;
|
||||
assert(image.sampleCount == (enabled ? 1u : requested));
|
||||
assert(depth_binds(image, {{depth.Width, depth.Height}, dsSamples}));
|
||||
}
|
||||
for (const auto& desc : device.created) {
|
||||
assert(desc.IsLockable && desc.IsBackBuffer && !desc.IsAttachmentOnly);
|
||||
assert(desc.MultiSample == (enabled ? D3DMULTISAMPLE_NONE : type));
|
||||
assert(desc.MultisampleQuality == (enabled ? 0u : quality));
|
||||
}
|
||||
// Original presentation parameters remain available for reset/auto-depth validation.
|
||||
assert(chain.m_presentParams.MultiSampleType == type && chain.m_presentParams.MultiSampleQuality == quality);
|
||||
if (enabled && requested > 1) assert(device.adapter.checked.front() == D3DMULTISAMPLE_TYPE(requested));
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
assert(argc == 2); std::string name = argv[1];
|
||||
if (name == "forced_msaa_depth") paired(true, D3DMULTISAMPLE_TYPE(4), 0);
|
||||
else if (name == "default_msaa_depth") paired(false, D3DMULTISAMPLE_TYPE(4), 0);
|
||||
else if (name == "forced_nonmaskable") paired(true, D3DMULTISAMPLE_NONMASKABLE, 2);
|
||||
else if (name == "default_nonmaskable") paired(false, D3DMULTISAMPLE_NONMASKABLE, 2);
|
||||
else if (name == "forced_already_single") paired(true, D3DMULTISAMPLE_NONE, 0);
|
||||
else if (name == "forced_no_depth" || name == "forced_lockable_single") {
|
||||
D3D9DeviceEx d; d.options.forceSingleSample = true;
|
||||
D3D9SwapChainEx c{&d, {}, {}};
|
||||
if (name == "forced_lockable_single") c.m_presentParams.MultiSampleType = D3DMULTISAMPLE_NONE;
|
||||
assert(c.CreateBackBuffers(1, name == "forced_lockable_single" ? D3DPRESENTFLAG_LOCKABLE_BACKBUFFER : 0) == D3D_OK);
|
||||
assert(c.m_backBuffers.size() == 1 && d.created[0].MultiSample == D3DMULTISAMPLE_NONE);
|
||||
assert(d.created[0].IsLockable && d.context.initialized == 1);
|
||||
} else if (name == "forced_unsupported" || name == "forced_invalid_type" || name == "forced_lockable_msaa") {
|
||||
D3D9DeviceEx d; d.options.forceSingleSample = true;
|
||||
D3D9SwapChainEx c{&d, {}, {}};
|
||||
if (name == "forced_unsupported") d.adapter.supported = false;
|
||||
if (name == "forced_invalid_type") c.m_presentParams.MultiSampleType = D3DMULTISAMPLE_TYPE(17);
|
||||
HRESULT expected = name == "forced_unsupported" ? D3DERR_NOTAVAILABLE : D3DERR_INVALIDCALL;
|
||||
assert(c.CreateBackBuffers(2, name == "forced_lockable_msaa" ? D3DPRESENTFLAG_LOCKABLE_BACKBUFFER : 0) == expected);
|
||||
assert(d.attempts == 0 && d.losable == 0 && d.injected == 0 && c.m_backBuffers.empty());
|
||||
} else if (name == "forced_allocation_failure" || name == "default_allocation_failure") {
|
||||
D3D9DeviceEx d; d.options.forceSingleSample = name == "forced_allocation_failure"; d.failAt = 2;
|
||||
D3D9SwapChainEx c{&d, {}, {}};
|
||||
assert(c.CreateBackBuffers(3, 0) == D3DERR_OUTOFVIDEOMEMORY);
|
||||
assert(d.attempts == 2 && d.losable == 1 && d.live == 0 && d.injected == 0 && c.m_backBuffers.empty());
|
||||
} else if (name == "forced_recreate") {
|
||||
D3D9DeviceEx d; d.options.forceSingleSample = true;
|
||||
D3D9SwapChainEx c{&d, {}, {}};
|
||||
assert(c.CreateBackBuffers(3, 0) == D3D_OK);
|
||||
c.m_presentParams.MultiSampleType = D3DMULTISAMPLE_TYPE(8);
|
||||
assert(c.CreateBackBuffers(1, 0) == D3D_OK);
|
||||
assert(d.live == 1 && c.m_backBuffers.size() == 1 && c.destroys == 2);
|
||||
assert(d.adapter.checked.size() == 2 && d.adapter.checked.back() == D3DMULTISAMPLE_TYPE(8));
|
||||
assert(c.m_backBuffers[0]->GetCommonTexture()->GetImage()->info.sampleCount == 1);
|
||||
} else if (name == "ordinary_surface" || name == "ordinary_invalid_lockable") {
|
||||
D3D9DeviceEx d; d.options.forceSingleSample = true;
|
||||
D3D9_COMMON_TEXTURE_DESC desc; desc.MultiSample = D3DMULTISAMPLE_TYPE(4);
|
||||
desc.IsLockable = name == "ordinary_invalid_lockable";
|
||||
assert(D3D9CommonTexture::NormalizeTextureProperties(&d, D3DRTYPE_SURFACE, &desc)
|
||||
== (desc.IsLockable ? D3DERR_INVALIDCALL : D3D_OK));
|
||||
if (!desc.IsLockable) assert(desc.MultiSample == D3DMULTISAMPLE_NONE && desc.MultisampleQuality == 0);
|
||||
} else assert(false);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
# Opt-in device-backed low mappings for Wine WoW64
|
||||
|
||||
On the tested Pixel PowerVR stack, Vulkan maps host-visible GPU allocations
|
||||
above 4 GiB. Wine's 32-bit WoW64 Vulkan bridge rejects those pointers. This
|
||||
caused American Nightmare (202750) to stop at D3D9 vertex-buffer creation even
|
||||
after the separate PowerVR BC texture profile passed device initialization.
|
||||
|
||||
`low32.c` is an experimental native Linux/glibc preload adapter. It is off by
|
||||
default. It applies only to anonymous-address, non-executable `MAP_SHARED`
|
||||
mappings of one explicitly selected character device. It retains the original
|
||||
device FD, offset, protection, flags, and actual GPU backing, and searches low
|
||||
address space with `MAP_FIXED_NOREPLACE`. It never truncates a pointer, copies
|
||||
into shadow storage, replaces existing mappings, or disables Wine's guard.
|
||||
Caller-specified/fixed mappings, regular files, private/anonymous memory and
|
||||
other devices retain their original behavior. Failure to find a suitable low
|
||||
hole fails with ENOMEM. The mmap and mmap64 preload chains are independently
|
||||
resolved and called through their respective RTLD_NEXT symbols;
|
||||
only resolver bootstrap uses the raw syscall. A compact atomic cursor avoids
|
||||
wasting large address slots on thousands of small driver control allocations.
|
||||
If the compact probe collides, a bounded address-range walk of
|
||||
/proc/self/maps finds page-sized holes and uses NOREPLACE again to handle races.
|
||||
The walk runs before coarse fallback, so small allocations do not fragment
|
||||
large available ranges. A game load had 2.3 GB free below 4 GiB but no hole as large as 4 MiB; the
|
||||
coarse-only version falsely failed even 4 KiB mappings. Mapping failures are
|
||||
reported even after the ordinary 256-event trace limit.
|
||||
|
||||
## Build and verify
|
||||
|
||||
Use a native 64-bit Linux/glibc compiler, not the Android NDK or macOS compiler:
|
||||
|
||||
```sh
|
||||
tools/hybris/low32/build.sh /absolute/build-dir /path/to/Vulkan-Headers/include
|
||||
```
|
||||
|
||||
The native library and unit test are always built. GPU probes are optional when
|
||||
headers are provided; `gpu-copy-native` uses the selected native host compiler
|
||||
and has the host's architecture, while the Windows x86 probe also needs
|
||||
i686-w64-mingw32-gcc. Copy a native probe to a device only when their architectures match.
|
||||
The unit test uses /dev/zero and proves CPU data integrity, collision handling,
|
||||
concurrency, 2000 simultaneous small mappings, invalid offsets, forwarding and
|
||||
opt-out. A fragmented-address-space regression reserves the low region, opens
|
||||
64 off-grid page holes, and verifies all 64 mappings and their data. The old
|
||||
coarse adapter fails that regression; the address-range fallback passes. An
|
||||
additional density regression fills 64 existing page holes while preserving a
|
||||
separate contiguous 16 MiB interval for a later complete data-readback map; the
|
||||
prior gap-after-coarse implementation fails and the gap-first strategy passes. These
|
||||
CPU tests do not by themselves prove GPU correctness.
|
||||
The build also tests both preload orders with a second library that hooks mmap
|
||||
and mmap64 independently. Opt-out, tracing and adaptation must each preserve
|
||||
the selected symbol's chain, invalid-offset errno and file offsets above 4 GiB.
|
||||
|
||||
`gpu-copy.c` tests actual Vulkan transfer operations on vendor 0x1010. It maps
|
||||
two 32 MiB device allocations, runs four copies of full deterministic patterns,
|
||||
including offset/unmap/remap, uses flush/invalidate and barriers/fences, and
|
||||
compares every word. It can require each full CPU range to fit below 4 GiB:
|
||||
|
||||
```sh
|
||||
./gpu-copy-native 32 --require-low32
|
||||
# Through a separate Proton ARM64/WoW64 test prefix:
|
||||
proton run gpu-copy-x86.exe 32 --require-low32 'Z:\path\probe-output.txt'
|
||||
```
|
||||
|
||||
The Windows output file avoids Wine's detached console hiding probe results.
|
||||
Run with Khronos synchronization validation. Keep raw Steam/account logs local;
|
||||
export only controlled PROBE results, validation IDs and counts. The tested
|
||||
memory type was device-local, host-visible and coherent; noncoherent physical
|
||||
memory is not covered by that run.
|
||||
|
||||
## Activation scope
|
||||
|
||||
Set only the target game's overrides, after identifying the render device's
|
||||
`st_rdev` and validating the installed library's hash:
|
||||
|
||||
```text
|
||||
LD_PRELOAD=/absolute/guest/path/libdroiddeck-low32.so
|
||||
DROIDDECK_LOW32_MODE=low32
|
||||
DROIDDECK_LOW32_RDEV=<verified decimal st_rdev>
|
||||
```
|
||||
|
||||
Preserve any existing target-game preload rather than replacing it. The tested
|
||||
Pixel's /dev/dri/renderD128 was character device major226/minor128, st_rdev57984.
|
||||
Do not hardcode that value for other machines. BC emulation and the repaired
|
||||
DXVK presentation component remain separate prerequisites; this adapter does
|
||||
not implement them. No global Steam profile, managed graphics pack, Android
|
||||
security setting or unrelated game's overrides should change.
|
||||
|
||||
Before activating, back up the exact game-environment bytes and only the target
|
||||
prefix's graphics DLLs, preserving symlinks. Rollback must check for concurrent
|
||||
edits. Keep original backups in the app; do not copy account files or an entire
|
||||
Steam prefix to a report. Removing these three overrides disables the adapter.
|
||||
|
||||
## Compatibility limits
|
||||
|
||||
This initial binary was built on Ubuntu24.04 ARM64 and needs glibc2.38. The
|
||||
tested guest supports it. This is not yet a universal runtime component; other
|
||||
glibc versions, page sizes, drivers, GPU families, native32-bit processes and
|
||||
general game stability require their own tests. Bounded native and Windows GPU
|
||||
copies prove data integrity for those workloads, not unrestricted gameplay.
|
||||
Never enable globally based on successful testing of one game.
|
||||
Executable
+27
@@ -0,0 +1,27 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# Run on native 64-bit Linux/glibc. This is not an Android/Bionic library.
|
||||
base=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
|
||||
output=${1:?usage: build.sh /absolute/build-directory [Vulkan-header-directory]}
|
||||
mkdir -p "$output"
|
||||
cc=${CC:-cc}
|
||||
"$cc" -std=gnu11 -Wall -Wextra -Werror -O2 -fPIC -shared -s \
|
||||
"$base/low32.c" -ldl -o "$output/libdroiddeck-low32.so"
|
||||
"$cc" -std=gnu11 -Wall -Wextra -Werror -O2 "$base/test-low32.c" -pthread -o "$output/test-low32"
|
||||
LD_PRELOAD="$output/libdroiddeck-low32.so" "$output/test-low32"
|
||||
"$cc" -std=gnu11 -Wall -Wextra -Werror -O2 -fPIC -shared \
|
||||
"$base/test-chain-hook.c" -ldl -o "$output/test-chain-hook.so"
|
||||
"$cc" -std=gnu11 -Wall -Wextra -Werror -O2 "$base/test-preload-chain.c" -ldl -o "$output/test-preload-chain"
|
||||
for preloads in "$output/libdroiddeck-low32.so:$output/test-chain-hook.so" \
|
||||
"$output/test-chain-hook.so:$output/libdroiddeck-low32.so"; do
|
||||
for mode in off trace low32; do
|
||||
LD_PRELOAD="$preloads" "$output/test-preload-chain" "$mode"
|
||||
done
|
||||
done
|
||||
if [ "$#" -ge 2 ]; then
|
||||
"$cc" -std=gnu11 -Wall -Wextra -Werror -O2 -s -I"$2" "$base/gpu-copy.c" -ldl -o "$output/gpu-copy-native"
|
||||
if command -v i686-w64-mingw32-gcc >/dev/null 2>&1; then
|
||||
i686-w64-mingw32-gcc -std=gnu11 -Wall -Wextra -Werror -O2 -s -I"$2" \
|
||||
"$base/gpu-copy.c" -o "$output/gpu-copy-x86.exe"
|
||||
fi
|
||||
fi
|
||||
@@ -0,0 +1,166 @@
|
||||
/* Same standalone GPU-copy probe built as Linux AArch64 and Windows x86.
|
||||
* Tests actual Vulkan buffers, complete data comparison, noncoherent cache
|
||||
* operations, remapping with an offset and queue completion. No Steam API.
|
||||
*/
|
||||
#define VK_NO_PROTOTYPES
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#else
|
||||
#include <dlfcn.h>
|
||||
#endif
|
||||
#include <inttypes.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <vulkan/vulkan.h>
|
||||
|
||||
#define IFNS(X) X(DestroyInstance) X(EnumeratePhysicalDevices) X(GetPhysicalDeviceProperties) \
|
||||
X(GetPhysicalDeviceMemoryProperties) X(GetPhysicalDeviceQueueFamilyProperties) X(CreateDevice) X(GetDeviceProcAddr)
|
||||
#define DFNS(X) X(DestroyDevice) X(GetDeviceQueue) X(CreateBuffer) X(DestroyBuffer) \
|
||||
X(GetBufferMemoryRequirements) X(AllocateMemory) X(FreeMemory) X(BindBufferMemory) \
|
||||
X(MapMemory) X(UnmapMemory) X(FlushMappedMemoryRanges) X(InvalidateMappedMemoryRanges) \
|
||||
X(CreateCommandPool) X(DestroyCommandPool) X(AllocateCommandBuffers) X(ResetCommandBuffer) \
|
||||
X(BeginCommandBuffer) X(EndCommandBuffer) X(CmdCopyBuffer) X(CmdPipelineBarrier) \
|
||||
X(CreateFence) X(DestroyFence) X(ResetFences) X(QueueSubmit) X(WaitForFences)
|
||||
#define DECL(n) static PFN_vk##n p##n;
|
||||
IFNS(DECL)
|
||||
DFNS(DECL)
|
||||
#undef DECL
|
||||
#define CHECK(x) do { VkResult rc=(x); if(rc!=VK_SUCCESS){printf("PROBE_FAIL stage=%s vk_result=%d\n",#x,rc);goto cleanup;} }while(0)
|
||||
#define REQUIRE(x,msg) do {if(!(x)){puts("PROBE_FAIL " msg);goto cleanup;}}while(0)
|
||||
|
||||
int main(int argc,char **argv)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
/* Wine/Proton can detach the Windows console from the Linux pipe. */
|
||||
if(argc>3 && !freopen(argv[3],"w",stdout)) return 4;
|
||||
#endif
|
||||
setvbuf(stdout,NULL,_IONBF,0);
|
||||
puts("PROBE_STAGE main");
|
||||
unsigned mib=argc>1?(unsigned)strtoul(argv[1],NULL,10):32;
|
||||
int require_low=argc>2&&!strcmp(argv[2],"--require-low32");
|
||||
if(mib<1||mib>256)return 2;
|
||||
const VkDeviceSize bytes=(VkDeviceSize)mib*1024*1024;
|
||||
VkInstance instance=VK_NULL_HANDLE;VkDevice device=VK_NULL_HANDLE;
|
||||
VkBuffer buffers[2]={0};VkDeviceMemory memories[2]={0};
|
||||
VkDeviceSize allocated[2]={0};void *mapped[2]={0};
|
||||
VkCommandPool pool=VK_NULL_HANDLE;VkFence fence=VK_NULL_HANDLE;
|
||||
int success=0,pending=0;uint64_t mismatches=0;unsigned iterations=0;
|
||||
int low_all=1;uint32_t memory_flags[2]={0};
|
||||
PFN_vkGetInstanceProcAddr gipa;
|
||||
#ifdef _WIN32
|
||||
HMODULE loader=LoadLibraryA("vulkan-1.dll");
|
||||
REQUIRE(loader,"load_vulkan_failed");
|
||||
gipa=(PFN_vkGetInstanceProcAddr)(void *)GetProcAddress(loader,"vkGetInstanceProcAddr");
|
||||
#else
|
||||
void *loader=dlopen("libvulkan.so.1",RTLD_NOW|RTLD_LOCAL);
|
||||
REQUIRE(loader,"load_vulkan_failed");
|
||||
gipa=(PFN_vkGetInstanceProcAddr)dlsym(loader,"vkGetInstanceProcAddr");
|
||||
#endif
|
||||
REQUIRE(gipa,"missing_gipa");
|
||||
puts("PROBE_STAGE vulkan_loader");
|
||||
PFN_vkCreateInstance create=(PFN_vkCreateInstance)gipa(NULL,"vkCreateInstance");
|
||||
REQUIRE(create,"missing_create_instance");
|
||||
VkApplicationInfo app={.sType=VK_STRUCTURE_TYPE_APPLICATION_INFO,
|
||||
.pApplicationName="DroidDeck low32 buffer integrity probe",.apiVersion=VK_API_VERSION_1_1};
|
||||
VkInstanceCreateInfo ici={.sType=VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,.pApplicationInfo=&app};
|
||||
CHECK(create(&ici,NULL,&instance));
|
||||
puts("PROBE_STAGE instance_created");
|
||||
#define LOADI(n) p##n=(PFN_vk##n)gipa(instance,"vk" #n);REQUIRE(p##n,"missing_" #n);
|
||||
IFNS(LOADI)
|
||||
#undef LOADI
|
||||
uint32_t count=0;CHECK(pEnumeratePhysicalDevices(instance,&count,NULL));
|
||||
puts("PROBE_STAGE physical_device_enumeration");
|
||||
REQUIRE(count&&count<=16,"physical_device_count");
|
||||
VkPhysicalDevice physicals[16],physical=VK_NULL_HANDLE;
|
||||
CHECK(pEnumeratePhysicalDevices(instance,&count,physicals));
|
||||
VkPhysicalDeviceProperties properties;
|
||||
for(uint32_t i=0;i<count;i++){
|
||||
pGetPhysicalDeviceProperties(physicals[i],&properties);
|
||||
if(properties.vendorID==0x1010&&properties.deviceType!=VK_PHYSICAL_DEVICE_TYPE_CPU){physical=physicals[i];break;}
|
||||
}
|
||||
REQUIRE(physical,"no_real_powervr");
|
||||
printf("PROBE_DEVICE vendor=%x device=%x api=%x pointer_bits=%zu\n",
|
||||
properties.vendorID,properties.deviceID,properties.apiVersion,sizeof(void *)*8);
|
||||
uint32_t qcount=0;pGetPhysicalDeviceQueueFamilyProperties(physical,&qcount,NULL);
|
||||
REQUIRE(qcount&&qcount<=64,"queue_count");
|
||||
VkQueueFamilyProperties qp[64];pGetPhysicalDeviceQueueFamilyProperties(physical,&qcount,qp);
|
||||
uint32_t family=UINT32_MAX;
|
||||
for(uint32_t i=0;i<qcount;i++)if(qp[i].queueCount&&(qp[i].queueFlags&VK_QUEUE_GRAPHICS_BIT)){family=i;break;}
|
||||
REQUIRE(family!=UINT32_MAX,"no_graphics_queue");float priority=1.0f;
|
||||
VkDeviceQueueCreateInfo qci={.sType=VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,.queueFamilyIndex=family,.queueCount=1,.pQueuePriorities=&priority};
|
||||
VkDeviceCreateInfo dci={.sType=VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,.queueCreateInfoCount=1,.pQueueCreateInfos=&qci};
|
||||
CHECK(pCreateDevice(physical,&dci,NULL,&device));
|
||||
#define LOADD(n) p##n=(PFN_vk##n)pGetDeviceProcAddr(device,"vk" #n);REQUIRE(p##n,"missing_" #n);
|
||||
DFNS(LOADD)
|
||||
#undef LOADD
|
||||
VkPhysicalDeviceMemoryProperties mp;pGetPhysicalDeviceMemoryProperties(physical,&mp);
|
||||
for(unsigned j=0;j<2;j++){
|
||||
VkBufferCreateInfo bci={.sType=VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,.size=bytes,
|
||||
.usage=VK_BUFFER_USAGE_TRANSFER_SRC_BIT|VK_BUFFER_USAGE_TRANSFER_DST_BIT,.sharingMode=VK_SHARING_MODE_EXCLUSIVE};
|
||||
CHECK(pCreateBuffer(device,&bci,NULL,&buffers[j]));VkMemoryRequirements mr;
|
||||
pGetBufferMemoryRequirements(device,buffers[j],&mr);
|
||||
uint32_t type=UINT32_MAX;
|
||||
for(uint32_t i=0;i<mp.memoryTypeCount;i++)if((mr.memoryTypeBits&(1u<<i))&&(mp.memoryTypes[i].propertyFlags&VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)){type=i;break;}
|
||||
REQUIRE(type!=UINT32_MAX,"no_host_visible_memory");memory_flags[j]=mp.memoryTypes[type].propertyFlags;
|
||||
VkMemoryAllocateInfo mai={.sType=VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,.allocationSize=mr.size,.memoryTypeIndex=type};
|
||||
allocated[j]=mr.size;CHECK(pAllocateMemory(device,&mai,NULL,&memories[j]));
|
||||
CHECK(pBindBufferMemory(device,buffers[j],memories[j],0));
|
||||
}
|
||||
VkCommandPoolCreateInfo pci={.sType=VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
|
||||
.flags=VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,.queueFamilyIndex=family};
|
||||
CHECK(pCreateCommandPool(device,&pci,NULL,&pool));VkCommandBuffer command;
|
||||
VkCommandBufferAllocateInfo cai={.sType=VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
|
||||
.commandPool=pool,.level=VK_COMMAND_BUFFER_LEVEL_PRIMARY,.commandBufferCount=1};
|
||||
CHECK(pAllocateCommandBuffers(device,&cai,&command));
|
||||
VkFenceCreateInfo fci={.sType=VK_STRUCTURE_TYPE_FENCE_CREATE_INFO};
|
||||
CHECK(pCreateFence(device,&fci,NULL,&fence));VkQueue queue;pGetDeviceQueue(device,family,0,&queue);
|
||||
for(unsigned k=0;k<4;k++){
|
||||
/* Alternate full mapping and a 64KiB aligned offset, preserving every word. */
|
||||
VkDeviceSize offset=(k&1)?65536:0,span=bytes-offset;
|
||||
for(unsigned j=0;j<2;j++){
|
||||
CHECK(pMapMemory(device,memories[j],offset,VK_WHOLE_SIZE,0,&mapped[j]));
|
||||
int low=(uint64_t)(uintptr_t)mapped[j]+(allocated[j]-offset)<=UINT64_C(0x100000000);
|
||||
low_all&=low;
|
||||
printf("PROBE_MAP iteration=%u buffer=%u offset=%" PRIu64 " bytes=%" PRIu64 " ptr=%p low32=%d flags=%x\n",
|
||||
k,j,(uint64_t)offset,(uint64_t)(allocated[j]-offset),mapped[j],low,memory_flags[j]);
|
||||
REQUIRE(!require_low||low,"mapping_not_low32");
|
||||
}
|
||||
uint32_t *src=mapped[0],*dst=mapped[1];size_t words=(size_t)(span/4);
|
||||
for(size_t i=0;i<words;i++){src[i]=((uint32_t)i*2654435761u)^(0xa5a50000u+k);dst[i]=0;}
|
||||
VkMappedMemoryRange ranges[2];memset(ranges,0,sizeof(ranges));
|
||||
for(unsigned j=0;j<2;j++)ranges[j]=(VkMappedMemoryRange){.sType=VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,.memory=memories[j],.offset=offset,.size=VK_WHOLE_SIZE};
|
||||
CHECK(pFlushMappedMemoryRanges(device,2,ranges));
|
||||
if(k){CHECK(pResetFences(device,1,&fence));CHECK(pResetCommandBuffer(command,0));}
|
||||
VkCommandBufferBeginInfo cbi={.sType=VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,.flags=VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT};
|
||||
CHECK(pBeginCommandBuffer(command,&cbi));
|
||||
VkMemoryBarrier before={.sType=VK_STRUCTURE_TYPE_MEMORY_BARRIER,.srcAccessMask=VK_ACCESS_HOST_WRITE_BIT,.dstAccessMask=VK_ACCESS_TRANSFER_READ_BIT|VK_ACCESS_TRANSFER_WRITE_BIT};
|
||||
pCmdPipelineBarrier(command,VK_PIPELINE_STAGE_HOST_BIT,VK_PIPELINE_STAGE_TRANSFER_BIT,0,1,&before,0,NULL,0,NULL);
|
||||
VkBufferCopy copy={.srcOffset=offset,.dstOffset=offset,.size=span};pCmdCopyBuffer(command,buffers[0],buffers[1],1,©);
|
||||
VkMemoryBarrier after={.sType=VK_STRUCTURE_TYPE_MEMORY_BARRIER,.srcAccessMask=VK_ACCESS_TRANSFER_WRITE_BIT,.dstAccessMask=VK_ACCESS_HOST_READ_BIT};
|
||||
pCmdPipelineBarrier(command,VK_PIPELINE_STAGE_TRANSFER_BIT,VK_PIPELINE_STAGE_HOST_BIT,0,1,&after,0,NULL,0,NULL);
|
||||
CHECK(pEndCommandBuffer(command));VkSubmitInfo si={.sType=VK_STRUCTURE_TYPE_SUBMIT_INFO,.commandBufferCount=1,.pCommandBuffers=&command};
|
||||
CHECK(pQueueSubmit(queue,1,&si,fence));pending=1;
|
||||
VkResult waited=pWaitForFences(device,1,&fence,VK_TRUE,UINT64_C(10000000000));
|
||||
if(waited!=VK_SUCCESS){printf("PROBE_FAIL GPU_COMPLETION_UNCONFIRMED result=%d\n",waited);goto cleanup;}
|
||||
pending=0;CHECK(pInvalidateMappedMemoryRanges(device,1,&ranges[1]));
|
||||
for(size_t i=0;i<words;i++)if(dst[i]!=(((uint32_t)i*2654435761u)^(0xa5a50000u+k)))mismatches++;
|
||||
for(unsigned j=0;j<2;j++){pUnmapMemory(device,memories[j]);mapped[j]=NULL;}
|
||||
iterations++;REQUIRE(!mismatches,"data_mismatch");
|
||||
}
|
||||
success=1;
|
||||
cleanup:
|
||||
printf("PROBE_RESULT success=%d mib=%u iterations=%u mismatches=%" PRIu64 " all_mappings_low32=%d\n",success,mib,iterations,mismatches,low_all);
|
||||
if(pending)return 3; /* Do not explicitly destroy objects with unknown GPU completion. */
|
||||
if(device){
|
||||
if(pUnmapMemory)for(unsigned j=0;j<2;j++)if(mapped[j])pUnmapMemory(device,memories[j]);
|
||||
if(fence&&pDestroyFence)pDestroyFence(device,fence,NULL);
|
||||
if(pool&&pDestroyCommandPool)pDestroyCommandPool(device,pool,NULL);
|
||||
for(unsigned j=0;j<2;j++)if(buffers[j]&&pDestroyBuffer)pDestroyBuffer(device,buffers[j],NULL);
|
||||
for(unsigned j=0;j<2;j++)if(memories[j]&&pFreeMemory)pFreeMemory(device,memories[j],NULL);
|
||||
if(pDestroyDevice)pDestroyDevice(device,NULL);
|
||||
}
|
||||
if(instance&&pDestroyInstance)pDestroyInstance(instance,NULL);
|
||||
return success?0:1;
|
||||
}
|
||||
@@ -0,0 +1,256 @@
|
||||
/* Experimental per-process PowerVR device-backed low-address mmap adapter.
|
||||
* No copied/shadow memory, changed device offset or MAP_FIXED replacement.
|
||||
* Default is off. Enable only for the identified render-device rdev and the
|
||||
* target x86/WoW64 game. Native 64-bit Linux/glibc preload, not an Android ABI DLL.
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#define _LARGEFILE64_SOURCE
|
||||
#include <dlfcn.h>
|
||||
#include <errno.h>
|
||||
#include <inttypes.h>
|
||||
#include <stdatomic.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/mman.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/syscall.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#ifndef MAP_FIXED_NOREPLACE
|
||||
#define MAP_FIXED_NOREPLACE 0x100000
|
||||
#endif
|
||||
|
||||
static _Atomic uint64_t cursor;
|
||||
static _Atomic unsigned logged;
|
||||
typedef void *(*map_function)(void *,size_t,int,int,int,off_t);
|
||||
typedef void *(*map64_function)(void *,size_t,int,int,int,off64_t);
|
||||
static _Atomic(map_function) next_map;
|
||||
static _Atomic(map64_function) next_map64;
|
||||
_Static_assert(sizeof(off_t) == sizeof(off64_t) && sizeof(off_t) == 8,
|
||||
"64-bit host required");
|
||||
static __thread int resolving __attribute__((tls_model("initial-exec")));
|
||||
static __thread int active __attribute__((tls_model("initial-exec")));
|
||||
static void *native_map(void *addr, size_t length, int prot, int flags, int fd, off_t offset)
|
||||
{
|
||||
map_function next=atomic_load(&next_map);
|
||||
if (!next && !resolving) {
|
||||
resolving=1;
|
||||
next=(map_function)dlsym(RTLD_NEXT,"mmap");
|
||||
atomic_store(&next_map,next);
|
||||
resolving=0;
|
||||
}
|
||||
/* Bootstrap only while resolving; otherwise preserve existing preload hooks. */
|
||||
if (next) return next(addr,length,prot,flags,fd,offset);
|
||||
return (void *)syscall(SYS_mmap, addr, length, prot, flags, fd, offset);
|
||||
}
|
||||
|
||||
static void *native_map64(void *addr, size_t length, int prot, int flags, int fd, off_t offset)
|
||||
{
|
||||
map64_function next=atomic_load(&next_map64);
|
||||
if (!next && !resolving) {
|
||||
resolving=1;
|
||||
next=(map64_function)dlsym(RTLD_NEXT,"mmap64");
|
||||
atomic_store(&next_map64,next);
|
||||
resolving=0;
|
||||
}
|
||||
if (next) return next(addr,length,prot,flags,fd,(off64_t)offset);
|
||||
return (void *)syscall(SYS_mmap, addr, length, prot, flags, fd, offset);
|
||||
}
|
||||
|
||||
static void trace_map(const char *kind, size_t n, int prot, int flags, int fd,
|
||||
off_t off, const struct stat *st, void *p, int error)
|
||||
{
|
||||
int saved = errno;
|
||||
unsigned count = atomic_fetch_add(&logged, 1);
|
||||
if (count < 256 || error != 0) {
|
||||
char text[320];
|
||||
int nbytes = snprintf(text, sizeof(text),
|
||||
"DD_LOW32 %s pid=%ld len=%zu prot=%x flags=%x fd=%d off=%jd mode=%o rdev=%ju ptr=%p errno=%d\n",
|
||||
kind, (long)getpid(), n, prot, flags, fd, (intmax_t)off, st ? st->st_mode : 0,
|
||||
st ? (uintmax_t)st->st_rdev : 0, p, error);
|
||||
if (nbytes > 0) {
|
||||
ssize_t written = write(STDERR_FILENO, text,
|
||||
(size_t)nbytes < sizeof(text) ? (size_t)nbytes : sizeof(text)-1);
|
||||
(void)written;
|
||||
}
|
||||
}
|
||||
errno = saved;
|
||||
}
|
||||
|
||||
static int target_device(int fd, struct stat *st)
|
||||
{
|
||||
const char *value = getenv("DROIDDECK_LOW32_RDEV");
|
||||
char *end = NULL;
|
||||
if (!value || !*value || fd < 0) return 0;
|
||||
int saved = errno;
|
||||
errno = 0;
|
||||
uintmax_t expected = strtoumax(value, &end, 10);
|
||||
int valid = !errno && end && !*end && expected > 0 &&
|
||||
fstat(fd, st) == 0 && S_ISCHR(st->st_mode) &&
|
||||
(uintmax_t)st->st_rdev == expected;
|
||||
errno = saved;
|
||||
return valid;
|
||||
}
|
||||
|
||||
static void *adapted_map(map_function forward, void *addr, size_t length, int prot,
|
||||
int flags, int fd, off_t offset)
|
||||
{
|
||||
const char *mode = getenv("DROIDDECK_LOW32_MODE");
|
||||
struct stat st = {0};
|
||||
if (mode && !strcmp(mode, "trace")) {
|
||||
void *p = forward(addr, length, prot, flags, fd, offset);
|
||||
if (fd >= 0 && (prot & PROT_WRITE) && !(prot & PROT_EXEC) &&
|
||||
(flags & MAP_TYPE) == MAP_SHARED) {
|
||||
int saved=errno;
|
||||
(void)fstat(fd,&st);
|
||||
errno=saved;
|
||||
trace_map("trace", length, prot, flags, fd, offset, &st, p,
|
||||
p == MAP_FAILED ? errno : 0);
|
||||
}
|
||||
return p;
|
||||
}
|
||||
if (!mode || strcmp(mode, "low32") || addr || !length ||
|
||||
(flags & (MAP_ANONYMOUS | MAP_FIXED | MAP_FIXED_NOREPLACE)) ||
|
||||
(prot & PROT_EXEC) || (flags & MAP_TYPE) != MAP_SHARED ||
|
||||
!target_device(fd, &st))
|
||||
return forward(addr, length, prot, flags, fd, offset);
|
||||
|
||||
const uintptr_t lower = 0x10000000u, upper = 0xffff0000u;
|
||||
const uintptr_t step = 0x00400000u;
|
||||
if (length > upper-lower) {
|
||||
errno = ENOMEM;
|
||||
trace_map("too_large", length, prot, flags, fd, offset, &st, MAP_FAILED, errno);
|
||||
return MAP_FAILED;
|
||||
}
|
||||
long page_value=sysconf(_SC_PAGESIZE);
|
||||
uintptr_t page=page_value>0?(uintptr_t)page_value:4096;
|
||||
uintptr_t rounded=(length+page-1)&~(page-1);
|
||||
uintptr_t span=upper-lower;
|
||||
uintptr_t compact=(uintptr_t)(atomic_fetch_add(&cursor,rounded)%span);
|
||||
if (rounded>span-compact) compact=0;
|
||||
unsigned slots = (unsigned)((span-length)/step)+1;
|
||||
unsigned start = (unsigned)(compact/step)%slots;
|
||||
int original_errno = errno;
|
||||
for (unsigned i = 0; i < 1; i++) {
|
||||
/* Compact first: hundreds of small driver mappings must not waste a
|
||||
* 4MiB address slot each. Coarse search is only for existing Wine holes. */
|
||||
uintptr_t hint = lower + (i==0?compact:(uintptr_t)((start+i-1)%slots)*step);
|
||||
void *p = forward((void *)hint, length, prot,
|
||||
flags|MAP_FIXED_NOREPLACE, fd, offset);
|
||||
if (p != MAP_FAILED) {
|
||||
uintptr_t first = (uintptr_t)p;
|
||||
if (first >= lower && first < upper && length <= upper-first) {
|
||||
errno = original_errno;
|
||||
trace_map("mapped", length, prot, flags, fd, offset, &st, p, 0);
|
||||
return p;
|
||||
}
|
||||
/* Older kernels can ignore NOREPLACE; never return a high mapping. */
|
||||
int saved = errno;
|
||||
(void)syscall(SYS_munmap, p, length);
|
||||
errno = saved;
|
||||
} else if (errno != EEXIST && errno != ENOMEM && errno != EAGAIN) {
|
||||
trace_map("rejected", length, prot, flags, fd, offset, &st, p, errno);
|
||||
return p;
|
||||
}
|
||||
}
|
||||
/* Pack small allocations into address holes before coarse probing can
|
||||
* fragment large holes. Walk
|
||||
* this process's current mappings, then use NOREPLACE to tolerate races.
|
||||
* No pointer paths or contents are read; only address ranges are used. */
|
||||
for (unsigned pass = 0; pass < 2; ++pass) {
|
||||
FILE *maps = fopen("/proc/self/maps", "r");
|
||||
if (!maps) break;
|
||||
char line[512];
|
||||
uintptr_t gap_start = lower;
|
||||
unsigned lines = 0;
|
||||
while (fgets(line, sizeof(line), maps) && ++lines < 65536) {
|
||||
uintptr_t first, last;
|
||||
if (sscanf(line, "%" SCNxPTR "-%" SCNxPTR, &first, &last) != 2) continue;
|
||||
if (last <= gap_start) continue;
|
||||
uintptr_t gap_end = first < upper ? first : upper;
|
||||
if (gap_end > gap_start && rounded <= gap_end - gap_start) {
|
||||
void *p = forward((void *)gap_start, length, prot,
|
||||
flags | MAP_FIXED_NOREPLACE, fd, offset);
|
||||
if (p != MAP_FAILED) {
|
||||
uintptr_t address = (uintptr_t)p;
|
||||
if (address >= lower && address < upper && length <= upper - address) {
|
||||
fclose(maps);
|
||||
errno = original_errno;
|
||||
trace_map("mapped_gap", length, prot, flags, fd, offset, &st, p, 0);
|
||||
return p;
|
||||
}
|
||||
(void)syscall(SYS_munmap, p, length);
|
||||
} else if (errno != EEXIST && errno != ENOMEM && errno != EAGAIN) {
|
||||
int saved = errno;
|
||||
fclose(maps);
|
||||
errno = saved;
|
||||
trace_map("rejected", length, prot, flags, fd, offset, &st, MAP_FAILED, errno);
|
||||
return MAP_FAILED;
|
||||
}
|
||||
}
|
||||
if (last > gap_start) gap_start = last;
|
||||
if (gap_start >= upper) break;
|
||||
}
|
||||
if (gap_start < upper && rounded <= upper - gap_start) {
|
||||
void *p = forward((void *)gap_start, length, prot,
|
||||
flags | MAP_FIXED_NOREPLACE, fd, offset);
|
||||
if (p != MAP_FAILED) {
|
||||
uintptr_t address = (uintptr_t)p;
|
||||
if (address >= lower && address < upper && length <= upper - address) {
|
||||
fclose(maps);
|
||||
errno = original_errno;
|
||||
trace_map("mapped_gap", length, prot, flags, fd, offset, &st, p, 0);
|
||||
return p;
|
||||
}
|
||||
(void)syscall(SYS_munmap, p, length);
|
||||
}
|
||||
}
|
||||
fclose(maps);
|
||||
}
|
||||
for (unsigned i = 1; i <= slots; i++) {
|
||||
/* Last resort if address walking was unavailable or raced. */
|
||||
uintptr_t hint = lower + (i==0?compact:(uintptr_t)((start+i-1)%slots)*step);
|
||||
void *p = forward((void *)hint, length, prot,
|
||||
flags|MAP_FIXED_NOREPLACE, fd, offset);
|
||||
if (p != MAP_FAILED) {
|
||||
uintptr_t first = (uintptr_t)p;
|
||||
if (first >= lower && first < upper && length <= upper-first) {
|
||||
errno = original_errno;
|
||||
trace_map("mapped", length, prot, flags, fd, offset, &st, p, 0);
|
||||
return p;
|
||||
}
|
||||
/* Older kernels can ignore NOREPLACE; never return a high mapping. */
|
||||
int saved = errno;
|
||||
(void)syscall(SYS_munmap, p, length);
|
||||
errno = saved;
|
||||
} else if (errno != EEXIST && errno != ENOMEM && errno != EAGAIN) {
|
||||
trace_map("rejected", length, prot, flags, fd, offset, &st, p, errno);
|
||||
return p;
|
||||
}
|
||||
}
|
||||
errno = ENOMEM;
|
||||
trace_map("no_low_hole", length, prot, flags, fd, offset, &st, MAP_FAILED, errno);
|
||||
return MAP_FAILED;
|
||||
}
|
||||
|
||||
static void *intercept_map(map_function forward, void *addr, size_t length,
|
||||
int prot, int flags, int fd, off_t offset)
|
||||
{
|
||||
if (active) return forward(addr,length,prot,flags,fd,offset);
|
||||
active=1;
|
||||
void *p=adapted_map(forward,addr,length,prot,flags,fd,offset);
|
||||
active=0;
|
||||
return p;
|
||||
}
|
||||
|
||||
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset)
|
||||
{
|
||||
return intercept_map(native_map,addr,length,prot,flags,fd,offset);
|
||||
}
|
||||
|
||||
void *mmap64(void *addr, size_t length, int prot, int flags, int fd, off64_t offset)
|
||||
{
|
||||
return intercept_map(native_map64,addr,length,prot,flags,fd,(off_t)offset);
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
/* Controlled second preload: distinct mmap/mmap64 counters and 64-bit offsets. */
|
||||
#define _GNU_SOURCE
|
||||
#define _LARGEFILE64_SOURCE
|
||||
#include <dlfcn.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/mman.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
static int selected_fd = -2;
|
||||
static unsigned calls[2];
|
||||
static int64_t offsets[2];
|
||||
|
||||
void chain_clear(int fd)
|
||||
{
|
||||
selected_fd = fd;
|
||||
calls[0] = calls[1] = 0;
|
||||
offsets[0] = offsets[1] = -1;
|
||||
}
|
||||
|
||||
unsigned chain_calls(unsigned channel) { return calls[channel]; }
|
||||
int64_t chain_offset(unsigned channel) { return offsets[channel]; }
|
||||
|
||||
void *mmap(void *addr, size_t len, int prot, int flags, int fd, off_t off)
|
||||
{
|
||||
static void *(*next)(void *, size_t, int, int, int, off_t);
|
||||
if (!next) next = dlsym(RTLD_NEXT, "mmap");
|
||||
if (fd == selected_fd) { ++calls[0]; offsets[0] = off; }
|
||||
return next(addr, len, prot, flags, fd, off);
|
||||
}
|
||||
|
||||
void *mmap64(void *addr, size_t len, int prot, int flags, int fd, off64_t off)
|
||||
{
|
||||
static void *(*next)(void *, size_t, int, int, int, off64_t);
|
||||
if (!next) next = dlsym(RTLD_NEXT, "mmap64");
|
||||
if (fd == selected_fd) { ++calls[1]; offsets[1] = off; }
|
||||
return next(addr, len, prot, flags, fd, off);
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
#define _GNU_SOURCE
|
||||
#include <assert.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <pthread.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <sys/mman.h>
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#define N (32u*1024u*1024u)
|
||||
static int zero_fd;
|
||||
static void *thread_test(void *arg)
|
||||
{
|
||||
unsigned seed = (unsigned)(uintptr_t)arg;
|
||||
uint32_t *p = mmap(NULL,N,PROT_READ|PROT_WRITE,MAP_SHARED,zero_fd,0);
|
||||
assert(p != MAP_FAILED && (uintptr_t)p+N <= 0x100000000ull);
|
||||
for (size_t i=0;i<N/4;i++) p[i]=(uint32_t)i^seed;
|
||||
for (size_t i=0;i<N/4;i++) assert(p[i]==((uint32_t)i^seed));
|
||||
assert(!munmap(p,N));
|
||||
return NULL;
|
||||
}
|
||||
int main(void)
|
||||
{
|
||||
zero_fd=open("/dev/zero",O_RDWR|O_CLOEXEC); assert(zero_fd>=0);
|
||||
struct stat st; assert(!fstat(zero_fd,&st)); char value[48];
|
||||
snprintf(value,sizeof(value),"%ju",(uintmax_t)st.st_rdev);
|
||||
assert(!setenv("DROIDDECK_LOW32_RDEV",value,1));
|
||||
assert(!setenv("DROIDDECK_LOW32_MODE","low32",1));
|
||||
/* Existing low-address memory must survive device mappings. */
|
||||
uint32_t *guard=mmap((void *)0x10000000,128u*1024u*1024u,PROT_READ|PROT_WRITE,
|
||||
MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED_NOREPLACE,-1,0);
|
||||
assert(guard==(void *)0x10000000);guard[0]=0xdeadbeef;guard[32767]=0xcafef00d;
|
||||
pthread_t threads[8];
|
||||
for (uintptr_t i=0;i<8;i++) assert(!pthread_create(&threads[i],NULL,thread_test,(void *)i));
|
||||
for (unsigned i=0;i<8;i++) assert(!pthread_join(threads[i],NULL));
|
||||
assert(guard[0]==0xdeadbeef && guard[32767]==0xcafef00d);
|
||||
puts("PASS concurrent 32MiB mappings, full pattern readback and occupied-memory preservation");
|
||||
assert(!munmap(guard,128u*1024u*1024u));
|
||||
/* Caller-specified address and MAP_FIXED semantics are preserved. */
|
||||
void *explicit=mmap((void *)0x30000000,4096,PROT_READ|PROT_WRITE,
|
||||
MAP_SHARED|MAP_FIXED_NOREPLACE,zero_fd,0);
|
||||
assert(explicit==(void *)0x30000000); assert(!munmap(explicit,4096));
|
||||
int mem=memfd_create("low32-nontarget",0);assert(mem>=0);assert(!ftruncate(mem,N));
|
||||
uint32_t *q=mmap((void *)0x500000000ull,N,PROT_READ|PROT_WRITE,MAP_SHARED,mem,0);
|
||||
assert(q==(void *)0x500000000ull);q[0]=123;assert(q[0]==123);assert(!munmap(q,N));close(mem);
|
||||
puts("PASS unrelated regular-file mapping and explicit-address forwarding");
|
||||
errno=0;
|
||||
void *bad=mmap(NULL,4096,PROT_READ|PROT_WRITE,MAP_SHARED,zero_fd,1);
|
||||
assert(bad==MAP_FAILED && errno==EINVAL);
|
||||
puts("PASS invalid device offset retains EINVAL");
|
||||
/* Real game initialization creates many small control/buffer mappings. */
|
||||
void *small[2000];
|
||||
for(unsigned i=0;i<2000;i++) {
|
||||
small[i]=mmap(NULL,4096,PROT_READ|PROT_WRITE,MAP_SHARED,zero_fd,0);
|
||||
assert(small[i]!=MAP_FAILED && (uintptr_t)small[i]+4096<=0x100000000ull);
|
||||
*(uint32_t *)small[i]=i;
|
||||
}
|
||||
for(unsigned i=0;i<2000;i++){
|
||||
assert(*(uint32_t *)small[i]==i);assert(!munmap(small[i],4096));
|
||||
}
|
||||
puts("PASS 2000 simultaneous small mappings without address-slot exhaustion");
|
||||
/* A fragmented Wine address space has usable holes away from every
|
||||
* 4MiB probe location. The mapping walk must find them without clobbering. */
|
||||
const uintptr_t lo=0x10000000u, hi=0xffff0000u;
|
||||
void *reservation=mmap((void *)lo,hi-lo,PROT_NONE,
|
||||
MAP_PRIVATE|MAP_ANONYMOUS|MAP_NORESERVE|MAP_FIXED_NOREPLACE,-1,0);
|
||||
assert(reservation==(void *)lo);
|
||||
void *holes[64], *fragmented[64];
|
||||
for (unsigned i=0;i<64;i++) {
|
||||
holes[i]=(void *)(lo+0x12345000u+(uintptr_t)i*0x10000u);
|
||||
assert(!munmap(holes[i],4096));
|
||||
}
|
||||
for (unsigned i=0;i<64;i++) {
|
||||
fragmented[i]=mmap(NULL,4096,PROT_READ|PROT_WRITE,MAP_SHARED,zero_fd,0);
|
||||
assert(fragmented[i]!=MAP_FAILED);
|
||||
int found=0;for(unsigned j=0;j<64;j++)found|=fragmented[i]==holes[j];assert(found);
|
||||
*(uint32_t *)fragmented[i]=i+77;
|
||||
}
|
||||
for (unsigned i=0;i<64;i++) assert(*(uint32_t *)fragmented[i]==i+77);
|
||||
for (unsigned i=0;i<64;i++) assert(!munmap(fragmented[i],4096));
|
||||
assert(!munmap(reservation,hi-lo));
|
||||
puts("PASS fragmented low32 mappings find 64 page holes beyond coarse probes");
|
||||
/* Small allocations must consume existing page holes rather than punch
|
||||
* coarse-grid holes into the only large interval needed by a later map. */
|
||||
reservation=mmap((void *)lo,hi-lo,PROT_NONE,
|
||||
MAP_PRIVATE|MAP_ANONYMOUS|MAP_NORESERVE|MAP_FIXED_NOREPLACE,-1,0);
|
||||
assert(reservation==(void *)lo);
|
||||
for (unsigned i=0;i<64;i++) assert(!munmap(holes[i],4096));
|
||||
const uintptr_t large_address=0x70000000u;
|
||||
const size_t large_size=16u*1024u*1024u;
|
||||
assert(!munmap((void *)large_address,large_size));
|
||||
for (unsigned i=0;i<64;i++) {
|
||||
fragmented[i]=mmap(NULL,4096,PROT_READ|PROT_WRITE,MAP_SHARED,zero_fd,0);
|
||||
assert(fragmented[i]!=MAP_FAILED);
|
||||
int found=0;for(unsigned j=0;j<64;j++)found|=fragmented[i]==holes[j];assert(found);
|
||||
*(uint32_t *)fragmented[i]=i+99;
|
||||
}
|
||||
uint32_t *large=mmap(NULL,large_size,PROT_READ|PROT_WRITE,MAP_SHARED,zero_fd,0);
|
||||
assert(large==(void *)large_address);
|
||||
for(size_t i=0;i<large_size/4;i++)large[i]=(uint32_t)i^0xa5a5a5a5u;
|
||||
for(size_t i=0;i<large_size/4;i++)assert(large[i]==((uint32_t)i^0xa5a5a5a5u));
|
||||
for(unsigned i=0;i<64;i++){
|
||||
assert(*(uint32_t *)fragmented[i]==i+99);assert(!munmap(fragmented[i],4096));
|
||||
}
|
||||
assert(!munmap(large,large_size));assert(!munmap(reservation,hi-lo));
|
||||
puts("PASS page-sized mapping density preserves subsequent contiguous 16MiB allocation");
|
||||
assert(!setenv("DROIDDECK_LOW32_RDEV","999999999",1));
|
||||
q=mmap((void *)0x510000000ull,4096,PROT_READ|PROT_WRITE,MAP_SHARED,zero_fd,0);
|
||||
assert(q==(void *)0x510000000ull);assert(!munmap(q,4096));
|
||||
puts("PASS mismatched device remains untouched");
|
||||
assert(!unsetenv("DROIDDECK_LOW32_MODE"));
|
||||
q=mmap((void *)0x520000000ull,4096,PROT_READ|PROT_WRITE,MAP_SHARED,zero_fd,0);
|
||||
assert(q==(void *)0x520000000ull);assert(!munmap(q,4096));
|
||||
puts("PASS opt-in disabled by default");
|
||||
close(zero_fd);return 0;
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
#define _GNU_SOURCE
|
||||
#define _LARGEFILE64_SOURCE
|
||||
#include <assert.h>
|
||||
#include <dlfcn.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <inttypes.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/mman.h>
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
assert(argc == 2);
|
||||
void (*clear)(int) = dlsym(RTLD_DEFAULT, "chain_clear");
|
||||
unsigned (*calls)(unsigned) = dlsym(RTLD_DEFAULT, "chain_calls");
|
||||
int64_t (*offset)(unsigned) = dlsym(RTLD_DEFAULT, "chain_offset");
|
||||
assert(clear && calls && offset);
|
||||
if (strcmp(argv[1], "off")) assert(!setenv("DROIDDECK_LOW32_MODE", argv[1], 1));
|
||||
else assert(!unsetenv("DROIDDECK_LOW32_MODE"));
|
||||
int fd = open("/dev/zero", O_RDWR | O_CLOEXEC);
|
||||
assert(fd >= 0);
|
||||
struct stat st;
|
||||
assert(!fstat(fd, &st));
|
||||
char rdev[48];
|
||||
snprintf(rdev, sizeof(rdev), "%ju", (uintmax_t)st.st_rdev);
|
||||
assert(!setenv("DROIDDECK_LOW32_RDEV", rdev, 1));
|
||||
for (unsigned channel = 0; channel < 2; ++channel) {
|
||||
clear(fd);
|
||||
void *p = channel ? mmap64(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)
|
||||
: mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
|
||||
assert(p != MAP_FAILED);
|
||||
assert(calls(channel) == 1 && calls(1 - channel) == 0 && offset(channel) == 0);
|
||||
if (!strcmp(argv[1], "low32")) assert((uintptr_t)p + 4096 <= UINT64_C(0x100000000));
|
||||
*(unsigned *)p = 0xcafef00d;
|
||||
assert(*(unsigned *)p == 0xcafef00d && !munmap(p, 4096));
|
||||
clear(fd);
|
||||
errno = 0;
|
||||
p = channel ? mmap64(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 1)
|
||||
: mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 1);
|
||||
assert(p == MAP_FAILED && errno == EINVAL);
|
||||
assert(calls(channel) == 1 && calls(1 - channel) == 0 && offset(channel) == 1);
|
||||
}
|
||||
close(fd);
|
||||
/* Regular-file forwarding must preserve an mmap64 offset above 4 GiB. */
|
||||
fd = memfd_create("preload-chain-test", 0);
|
||||
const off64_t large_offset = INT64_C(0x200001000);
|
||||
assert(fd >= 0 && !ftruncate64(fd, large_offset + 4096));
|
||||
unsigned value = 0x1234abcd;
|
||||
assert(pwrite64(fd, &value, sizeof(value), large_offset) == (ssize_t)sizeof(value));
|
||||
clear(fd);
|
||||
unsigned *p = mmap64(NULL, 4096, PROT_READ, MAP_SHARED, fd, large_offset);
|
||||
assert(p != MAP_FAILED && *p == value);
|
||||
assert(calls(1) == 1 && calls(0) == 0 && offset(1) == large_offset);
|
||||
assert(!munmap(p, 4096));
|
||||
close(fd);
|
||||
printf("PASS separate mmap/mmap64 chains (%s), EINVAL and >4GiB offset readback\n", argv[1]);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,152 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Read-only reboot projection. Never writes raw Android logs or account data.
|
||||
|
||||
This is evidence collection, not a GPU fault injector or a root-cause oracle.
|
||||
The optional kernel projection reads only SYSTEM_LAST_KMSG after user unlock.
|
||||
It emits fixed categories and numeric hardware fields, never arbitrary log lines.
|
||||
"""
|
||||
import argparse
|
||||
from datetime import datetime, timezone
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import re
|
||||
import subprocess
|
||||
from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
|
||||
|
||||
ENTRY = re.compile(r'^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\s+(SYSTEM_LAST_KMSG)\b', re.M)
|
||||
CATEGORIES = ('GNOC', 'PVRSRV', 'watchdog', 'IOMMU', 'S2MPU', 'access control', 'Kernel panic', 'HWR', 'GPU fault')
|
||||
PRIMARY_USER_STATES = frozenset(('RUNNING_LOCKED', 'RUNNING_UNLOCKING', 'RUNNING_UNLOCKED'))
|
||||
# Exact canonical reasons plus the vendor reason observed in the bounded Pixel
|
||||
# tests. Unrecognized/custom suffixes are not diagnostic output categories.
|
||||
BOOT_REASONS = frozenset(('cold', 'hard', 'warm', 'reboot', 'shutdown',
|
||||
'recovery', 'bootloader', 'kernel_panic', 'watchdog',
|
||||
'reset,warm,gnoc_error'))
|
||||
|
||||
|
||||
def primary_state(text):
|
||||
match = re.search(r'Started users state: \[0=([A-Z_]+)(?=[,\]])', text)
|
||||
return match.group(1) if match and match.group(1) in PRIMARY_USER_STATES else 'unknown'
|
||||
|
||||
|
||||
def safe_reason(text):
|
||||
value = text.strip()
|
||||
return value if value in BOOT_REASONS else 'unknown'
|
||||
|
||||
|
||||
def kernel_projection(text, device_timezone, after=None):
|
||||
entries = list(ENTRY.finditer(text))
|
||||
result = {'metadata_dates': [m.group(1) for m in entries], 'raw_body_saved': False,
|
||||
'root_cause_proven': False}
|
||||
if not entries:
|
||||
result['status'] = 'no_accessible_entry'
|
||||
return result
|
||||
latest = max(enumerate(entries), key=lambda row: row[1].group(1))
|
||||
index, match = latest
|
||||
body = text[match.end():entries[index + 1].start() if index + 1 < len(entries) else len(text)]
|
||||
result['entry_date_device_local'] = match.group(1)
|
||||
try:
|
||||
naive = datetime.strptime(match.group(1), '%Y-%m-%d %H:%M:%S')
|
||||
zone = ZoneInfo(device_timezone)
|
||||
except (ValueError, ZoneInfoNotFoundError):
|
||||
result['status'] = 'unknown_device_timezone'
|
||||
return result
|
||||
# Dropbox supplies a local wall clock without an offset. Round-trip both
|
||||
# folds: a repeated hour has two possible instants; a skipped hour has none.
|
||||
instants = {local.astimezone(timezone.utc)
|
||||
for fold in (0, 1)
|
||||
for local in (naive.replace(tzinfo=zone, fold=fold),)
|
||||
if local.astimezone(timezone.utc).astimezone(zone).replace(tzinfo=None) == naive}
|
||||
if len(instants) != 1:
|
||||
result['status'] = ('ambiguous_device_local_time' if instants
|
||||
else 'nonexistent_device_local_time')
|
||||
return result
|
||||
local = instants.pop()
|
||||
result['entry_date_utc'] = local.isoformat()
|
||||
if after is not None and local < after:
|
||||
result['status'] = 'stale_entry_not_attributed_to_current_trial'
|
||||
return result
|
||||
result['status'] = 'projected_entry_not_a_root_cause'
|
||||
result['categories'] = {key: len(re.findall(re.escape(key), body, re.I)) for key in CATEGORIES}
|
||||
patterns = {
|
||||
'gnoc_addresses': r'Error from GNOC at addr (0x[0-9a-fA-F]+)',
|
||||
'gnoc_error_types': r'GNOC error type (0x[0-9a-fA-F]+)',
|
||||
'firmware_reboot_codes': r'Reboot reason:\s+(0x[0-9a-fA-F]+)',
|
||||
'access_control_addresses': r'Access Control Error \((0x[0-9a-fA-F]+)',
|
||||
}
|
||||
result['hardware_fields'] = {key: sorted(set(re.findall(pattern, body))) for key, pattern in patterns.items()}
|
||||
# Read the complete value, not just a recognized-looking prefix. Apply the
|
||||
# same fixed projection as getprop; no arbitrary kernel reason text escapes.
|
||||
reasons = re.findall(r'Last boot reason:[ \t]*([^\r\n]*)', body)
|
||||
result['last_boot_reasons'] = sorted({safe_reason(reason) for reason in reasons})
|
||||
return result
|
||||
|
||||
|
||||
def collect(adb, serial, include_kernel=False, after=None):
|
||||
def shell(*args):
|
||||
try:
|
||||
process = subprocess.run([adb, '-s', serial, 'shell', *args], capture_output=True,
|
||||
text=True, timeout=20)
|
||||
except (OSError, subprocess.TimeoutExpired):
|
||||
return None, ''
|
||||
# No command stderr is copied to output: it may contain unrelated data.
|
||||
return process.returncode, process.stdout if process.returncode == 0 else ''
|
||||
|
||||
result = {'at': datetime.now(timezone.utc).isoformat(), 'read_only': True,
|
||||
'raw_logs_saved': False, 'credentials_collected': False}
|
||||
code, value = shell('settings', 'get', 'global', 'boot_count')
|
||||
result['boot_count'] = int(value.strip()) if code == 0 and value.strip().isdigit() else None
|
||||
code, value = shell('getprop', 'ro.boot.bootreason')
|
||||
result['bootloader_reason'] = safe_reason(value)
|
||||
code, value = shell('getprop', 'sys.boot.reason')
|
||||
result['system_boot_reason'] = safe_reason(value)
|
||||
code, value = shell('dumpsys', 'user')
|
||||
result['primary_user_state'] = primary_state(value)
|
||||
code, value = shell('getprop', 'persist.sys.timezone')
|
||||
device_timezone = value.strip()
|
||||
try:
|
||||
ZoneInfo(device_timezone)
|
||||
result['device_timezone'] = device_timezone
|
||||
except (ValueError, ZoneInfoNotFoundError):
|
||||
result['device_timezone'] = 'unknown'
|
||||
code, value = shell('dumpsys', 'dropbox', 'SYSTEM_LAST_KMSG')
|
||||
result['kernel_metadata_dates'] = [m.group(1) for m in ENTRY.finditer(value)]
|
||||
if include_kernel:
|
||||
if result['primary_user_state'] != 'RUNNING_UNLOCKED':
|
||||
result['kernel'] = {'status': 'requires_user_unlock', 'raw_body_saved': False}
|
||||
else:
|
||||
code, value = shell('dumpsys', 'dropbox', '--print', 'SYSTEM_LAST_KMSG')
|
||||
result['kernel'] = kernel_projection(value, result['device_timezone'], after)
|
||||
result['kernel']['read_exit_code'] = code
|
||||
return result
|
||||
|
||||
|
||||
def write_private_output(path, output):
|
||||
# Exclusive creation also rejects existing symlinks. Set the private mode
|
||||
# before any bytes are written, rather than chmod after exposing the data.
|
||||
flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, 'O_NOFOLLOW', 0)
|
||||
descriptor = os.open(path, flags, 0o600)
|
||||
with os.fdopen(descriptor, 'w', encoding='utf-8') as stream:
|
||||
stream.write(output)
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('--adb', default='adb')
|
||||
parser.add_argument('--serial', required=True)
|
||||
parser.add_argument('--kernel', action='store_true')
|
||||
parser.add_argument('--after', help='Earliest relevant UTC ISO timestamp; excludes stale kernel entries')
|
||||
parser.add_argument('--output', type=Path, help='New JSON file; refuses to overwrite')
|
||||
args = parser.parse_args()
|
||||
after = datetime.fromisoformat(args.after.replace('Z', '+00:00')) if args.after else None
|
||||
if after is not None and after.tzinfo is None:
|
||||
parser.error('--after must include a timezone')
|
||||
result = collect(args.adb, args.serial, args.kernel, after)
|
||||
output = json.dumps(result, indent=2) + '\n'
|
||||
if args.output:
|
||||
write_private_output(args.output, output)
|
||||
print(output, end='')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -0,0 +1,121 @@
|
||||
"""Exercise output isolation with a synthetic toolchain; no network/DLL build."""
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
|
||||
# Substitute only external source/compiler/archive commands. The real build.sh
|
||||
# owns output checks, architecture iteration and manifest inputs.
|
||||
FAKE_TOOL = r'''
|
||||
import hashlib, json, os
|
||||
from pathlib import Path
|
||||
import sys
|
||||
name = Path(sys.argv[0]).name
|
||||
args = sys.argv[1:]
|
||||
with open(os.environ['TOOL_CALLS'], 'a') as stream:
|
||||
stream.write(name + '\n')
|
||||
if name == 'git':
|
||||
if args[0] == 'init':
|
||||
Path(args[-1]).mkdir()
|
||||
(Path(args[-1]) / 'LICENSE').write_text('synthetic public license')
|
||||
elif 'rev-parse' in args:
|
||||
print(os.environ['TEST_REVISION'])
|
||||
elif name == 'meson':
|
||||
if args[0] == 'setup':
|
||||
p = Path(args[1]); p.mkdir()
|
||||
p.joinpath('config.json').write_text(json.dumps({
|
||||
'out': args[args.index('--prefix') + 1],
|
||||
'arch': args[args.index('--bindir') + 1]}))
|
||||
elif args[0] == 'install':
|
||||
config = json.loads(Path(args[2], 'config.json').read_text())
|
||||
out = Path(config['out'], config['arch']); out.mkdir(exist_ok=True)
|
||||
out.joinpath('current.dll').write_bytes(b'synthetic current pinned DLL')
|
||||
if config['arch'] == os.environ.get('FAIL_INSTALL_ARCH'):
|
||||
sys.exit(5)
|
||||
elif name == 'tar':
|
||||
Path(args[args.index('-cf') + 1]).write_bytes(b'synthetic source archive')
|
||||
elif name == 'sha256sum':
|
||||
for arg in args:
|
||||
print(hashlib.sha256(Path(arg).read_bytes()).hexdigest() + ' ' + arg)
|
||||
elif name != 'python3':
|
||||
raise AssertionError(name)
|
||||
'''
|
||||
|
||||
|
||||
class DxvkBuildTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.temporary = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.temporary.cleanup)
|
||||
self.base = Path(self.temporary.name)
|
||||
self.bin = self.base / 'bin'; self.bin.mkdir()
|
||||
executable = self.bin / 'fake-tool'
|
||||
executable.write_text('#!' + sys.executable + '\n' + FAKE_TOOL)
|
||||
executable.chmod(0o755)
|
||||
for name in ('git', 'meson', 'tar', 'sha256sum', 'python3'):
|
||||
(self.bin / name).symlink_to(executable)
|
||||
self.calls = self.base / 'calls'
|
||||
self.env = dict(os.environ, PATH=str(self.bin) + os.pathsep + os.environ['PATH'],
|
||||
TOOL_CALLS=str(self.calls))
|
||||
source_env = ROOT / 'tools/dxvk/source.env'
|
||||
self.env['TEST_REVISION'] = next(line.split('=', 1)[1].strip('"\'')
|
||||
for line in source_env.read_text().splitlines()
|
||||
if line.startswith('DXVK_REVISION='))
|
||||
self.output = self.base / 'component'
|
||||
|
||||
def build(self):
|
||||
return subprocess.run(['bash', str(ROOT / 'tools/dxvk/build.sh'), str(self.output)],
|
||||
env=self.env, capture_output=True, text=True, timeout=10)
|
||||
|
||||
def test_stale_dll_is_rejected_untouched_before_fetch(self):
|
||||
stale = self.output / 'x32/stale.dll'; stale.parent.mkdir(parents=True)
|
||||
stale.write_bytes(b'prior pinned build')
|
||||
result = self.build()
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertIn('output directory must be empty', result.stderr)
|
||||
self.assertEqual(stale.read_bytes(), b'prior pinned build')
|
||||
self.assertFalse(self.calls.exists())
|
||||
self.assertFalse((self.output / 'SHA256SUMS').exists())
|
||||
|
||||
def test_hidden_contents_are_also_rejected(self):
|
||||
self.output.mkdir(); (self.output / '.previous').write_text('retained')
|
||||
self.assertNotEqual(self.build().returncode, 0)
|
||||
self.assertFalse(self.calls.exists())
|
||||
self.assertEqual((self.output / '.previous').read_text(), 'retained')
|
||||
|
||||
def test_empty_or_new_output_contains_only_current_dlls(self):
|
||||
for existing in (False, True):
|
||||
with self.subTest(existing=existing):
|
||||
self.output = self.base / ('existing' if existing else 'new')
|
||||
if existing: self.output.mkdir()
|
||||
result = self.build()
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
rows = (self.output / 'SHA256SUMS').read_text().splitlines()
|
||||
self.assertEqual([row.split(' ')[1] for row in rows],
|
||||
['x32/current.dll', 'x64/current.dll'])
|
||||
for row in rows:
|
||||
digest, path = row.split(' ')
|
||||
self.assertEqual(digest, hashlib.sha256((self.output / path).read_bytes()).hexdigest())
|
||||
|
||||
def test_partial_build_is_not_reused_or_deleted(self):
|
||||
self.env['FAIL_INSTALL_ARCH'] = 'x64'
|
||||
result = self.build()
|
||||
self.assertEqual(result.returncode, 5, result.stderr)
|
||||
before = {str(p.relative_to(self.output)): p.read_bytes()
|
||||
for p in self.output.rglob('*') if p.is_file()}
|
||||
self.calls.unlink(); del self.env['FAIL_INSTALL_ARCH']
|
||||
result = self.build()
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertFalse(self.calls.exists())
|
||||
after = {str(p.relative_to(self.output)): p.read_bytes()
|
||||
for p in self.output.rglob('*') if p.is_file()}
|
||||
self.assertEqual(after, before)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,215 @@
|
||||
"""Test freshness, narrow output, and lock handling without accessing a device."""
|
||||
from datetime import datetime, timezone
|
||||
import importlib.util
|
||||
import json
|
||||
import io
|
||||
import os
|
||||
from pathlib import Path
|
||||
import stat
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
|
||||
spec = importlib.util.spec_from_file_location('reset_projection', Path(__file__).resolve().parents[1] / 'pixel_reset_diagnostics.py')
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(module)
|
||||
|
||||
|
||||
class ResetProjectionTest(unittest.TestCase):
|
||||
def test_only_primary_state(self):
|
||||
self.assertEqual(module.primary_state('Private space secret\nStarted users state: [0=RUNNING_UNLOCKED, 10=STOPPED]'), 'RUNNING_UNLOCKED')
|
||||
self.assertEqual(module.primary_state('State: RUNNING_UNLOCKED'), 'unknown')
|
||||
|
||||
def test_stale_body_not_used(self):
|
||||
raw = '2026-10-10 20:10:09 SYSTEM_LAST_KMSG (text, 1024 bytes)\nGNOC error type 0x2000'
|
||||
result = module.kernel_projection(raw, 'America/Toronto', datetime(2026, 10, 11, 21, tzinfo=timezone.utc))
|
||||
self.assertEqual(result['status'], 'stale_entry_not_attributed_to_current_trial')
|
||||
self.assertNotIn('categories', result)
|
||||
|
||||
def test_repeated_dst_hour_is_ambiguous_before_freshness(self):
|
||||
raw = '2026-11-01 01:30:00 SYSTEM_LAST_KMSG\nGNOC error type 0x2000'
|
||||
for after in (None, datetime(2026, 11, 1, 6, tzinfo=timezone.utc)):
|
||||
with self.subTest(after=after):
|
||||
result = module.kernel_projection(raw, 'America/Toronto', after)
|
||||
self.assertEqual(result['status'], 'ambiguous_device_local_time')
|
||||
self.assertNotIn('entry_date_utc', result)
|
||||
self.assertNotIn('categories', result)
|
||||
self.assertNotIn('hardware_fields', result)
|
||||
|
||||
def test_skipped_dst_hour_is_not_a_real_instant(self):
|
||||
raw = '2026-03-08 02:30:00 SYSTEM_LAST_KMSG\nGNOC error type 0x2000'
|
||||
result = module.kernel_projection(raw, 'America/Toronto')
|
||||
self.assertEqual(result['status'], 'nonexistent_device_local_time')
|
||||
self.assertNotIn('entry_date_utc', result)
|
||||
self.assertNotIn('categories', result)
|
||||
|
||||
def test_unambiguous_times_keep_correct_offsets_and_cutoff(self):
|
||||
for stamp, expected in (('2026-11-01 00:30:00', '2026-11-01T04:30:00+00:00'),
|
||||
('2026-11-01 02:30:00', '2026-11-01T07:30:00+00:00'),
|
||||
('2026-03-08 03:30:00', '2026-03-08T07:30:00+00:00')):
|
||||
with self.subTest(stamp=stamp):
|
||||
raw = stamp + ' SYSTEM_LAST_KMSG\nGNOC'
|
||||
result = module.kernel_projection(raw, 'America/Toronto')
|
||||
self.assertEqual(result['entry_date_utc'], expected)
|
||||
self.assertEqual(result['status'], 'projected_entry_not_a_root_cause')
|
||||
cutoff = datetime.fromisoformat(expected)
|
||||
self.assertEqual(module.kernel_projection(raw, 'America/Toronto', cutoff)['status'],
|
||||
'projected_entry_not_a_root_cause')
|
||||
|
||||
def test_latest_entry_and_no_arbitrary_body(self):
|
||||
raw = ('2026-10-10 20:10:09 SYSTEM_LAST_KMSG (text)\nGNOC error type 0x1111\n'
|
||||
'2026-10-11 17:35:01 SYSTEM_LAST_KMSG (text)\n'
|
||||
'PRIVATE_TEST_VALUE=a_secret_that_must_not_be_emitted\n'
|
||||
'Error from GNOC at addr 0x28220000\nGNOC error type 0x2000\n'
|
||||
'Reboot reason: 0xc005 - Secret arbitrary description\nLast boot reason: reset,warm,gnoc_error\n')
|
||||
result = module.kernel_projection(raw, 'America/Toronto', datetime(2026, 10, 11, 21, tzinfo=timezone.utc))
|
||||
self.assertEqual(result['entry_date_utc'], '2026-10-11T21:35:01+00:00')
|
||||
self.assertEqual(result['hardware_fields']['gnoc_error_types'], ['0x2000'])
|
||||
self.assertNotIn('0x1111', json.dumps(result))
|
||||
self.assertNotIn('a_secret', json.dumps(result))
|
||||
self.assertNotIn('arbitrary description', json.dumps(result))
|
||||
self.assertFalse(result['root_cause_proven'])
|
||||
|
||||
def test_missing_entry_and_timezone(self):
|
||||
self.assertEqual(module.kernel_projection('Permission denied', 'America/Toronto')['status'], 'no_accessible_entry')
|
||||
self.assertEqual(module.kernel_projection('2026-10-11 17:00:00 SYSTEM_LAST_KMSG\nGNOC', 'Unknown/Region')['status'], 'unknown_device_timezone')
|
||||
|
||||
def test_reason_rejects_paths_and_urls(self):
|
||||
self.assertEqual(module.safe_reason('reset,warm,gnoc_error\n'), 'reset,warm,gnoc_error')
|
||||
self.assertEqual(module.safe_reason('https://private.invalid/login?secret=abc'), 'unknown')
|
||||
self.assertEqual(module.safe_reason('/data/private'), 'unknown')
|
||||
|
||||
def test_reason_only_recognized_exact_values(self):
|
||||
for reason in ('cold', 'hard', 'warm', 'reboot', 'shutdown', 'recovery',
|
||||
'bootloader', 'kernel_panic', 'watchdog', 'reset,warm,gnoc_error'):
|
||||
with self.subTest(reason=reason):
|
||||
self.assertEqual(module.safe_reason(reason + '\n'), reason)
|
||||
for reason in ('PRIVATE TEST VALUE', 'private_test_value', '123456',
|
||||
'reboot,private_test_value', 'reset,warm,gnoc_error,private_test_value',
|
||||
'reset,warm,gnoc_error trailing_private_test_value', ''):
|
||||
with self.subTest(reason=reason):
|
||||
self.assertEqual(module.safe_reason(reason), 'unknown')
|
||||
|
||||
def test_kernel_reason_uses_same_fixed_projection(self):
|
||||
raw = ('2026-10-11 17:35:01 SYSTEM_LAST_KMSG (text)\n'
|
||||
'Last boot reason: private_test_value\n'
|
||||
'Last boot reason: reset,warm,gnoc_error trailing_private_test_value\n'
|
||||
'Last boot reason: reset,warm,gnoc_error\n'
|
||||
'Last boot reason:\nPRIVATE TEST VALUE\n')
|
||||
result = module.kernel_projection(raw, 'America/Toronto')
|
||||
self.assertEqual(result['last_boot_reasons'], ['reset,warm,gnoc_error', 'unknown'])
|
||||
self.assertNotIn('private_test_value', json.dumps(result))
|
||||
self.assertNotIn('PRIVATE TEST VALUE', json.dumps(result))
|
||||
|
||||
def test_primary_state_uses_fixed_categories(self):
|
||||
for state in ('RUNNING_LOCKED', 'RUNNING_UNLOCKING', 'RUNNING_UNLOCKED'):
|
||||
self.assertEqual(module.primary_state('Started users state: [0=' + state + ']'), state)
|
||||
for state in ('RUNNING_PRIVATE_TEST_VALUE', 'RUNNING_UNLOCKED_PRIVATE',
|
||||
'RUNNING_UNLOCKED=private_test_value'):
|
||||
self.assertEqual(module.primary_state('Started users state: [0=' + state + ']'), 'unknown')
|
||||
|
||||
def test_property_reason_never_exports_custom_text(self):
|
||||
def run(argv, **kwargs):
|
||||
if argv[-2:] == ['getprop', 'ro.boot.bootreason']:
|
||||
text = 'PRIVATE TEST VALUE'
|
||||
elif argv[-2:] == ['getprop', 'sys.boot.reason']:
|
||||
text = 'reset,warm,gnoc_error,private_test_value'
|
||||
elif argv[-1] == 'persist.sys.timezone':
|
||||
text = 'America/Toronto'
|
||||
else:
|
||||
text = ''
|
||||
return subprocess.CompletedProcess(argv, 0, text, '')
|
||||
with patch.object(module.subprocess, 'run', side_effect=run):
|
||||
result = module.collect('adb', 'test-device')
|
||||
self.assertEqual(result['bootloader_reason'], 'unknown')
|
||||
self.assertEqual(result['system_boot_reason'], 'unknown')
|
||||
self.assertNotIn('PRIVATE TEST VALUE', json.dumps(result))
|
||||
self.assertNotIn('private_test_value', json.dumps(result))
|
||||
|
||||
@unittest.skipUnless(os.name == 'posix', 'POSIX private file modes')
|
||||
def test_cli_output_is_private_before_writing(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
output = Path(directory) / 'diagnostics.json'
|
||||
saved_umask = os.umask(0)
|
||||
original_fdopen = os.fdopen
|
||||
original_path_open = Path.open
|
||||
creation_modes = []
|
||||
def inspect_stream(stream):
|
||||
try:
|
||||
creation_modes.append(stat.S_IMODE(os.fstat(stream.fileno()).st_mode))
|
||||
self.assertEqual(os.fstat(stream.fileno()).st_size, 0)
|
||||
self.assertEqual(creation_modes[-1], 0o600)
|
||||
except BaseException:
|
||||
stream.close()
|
||||
raise
|
||||
return stream
|
||||
def inspect_fd(fd, *args, **kwargs):
|
||||
return inspect_stream(original_fdopen(fd, *args, **kwargs))
|
||||
def inspect_path(path, *args, **kwargs):
|
||||
stream = original_path_open(path, *args, **kwargs)
|
||||
return inspect_stream(stream) if path == output else stream
|
||||
try:
|
||||
with patch.object(sys, 'argv', ['diagnostics', '--serial', 'test-device',
|
||||
'--output', str(output)]), \
|
||||
patch.object(module, 'collect', return_value={'boot_count': 12}), \
|
||||
patch.object(os, 'fdopen', side_effect=inspect_fd), \
|
||||
patch.object(Path, 'open', new=inspect_path), \
|
||||
patch('sys.stdout', new_callable=io.StringIO):
|
||||
module.main()
|
||||
finally:
|
||||
os.umask(saved_umask)
|
||||
self.assertEqual(creation_modes, [0o600])
|
||||
self.assertEqual(stat.S_IMODE(output.stat().st_mode), 0o600)
|
||||
self.assertEqual(json.loads(output.read_text()), {'boot_count': 12})
|
||||
|
||||
def test_output_refuses_existing_file(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
output = Path(directory) / 'diagnostics.json'
|
||||
output.write_text('existing controlled test data')
|
||||
with self.assertRaises(FileExistsError):
|
||||
module.write_private_output(output, '{"replacement":true}\n')
|
||||
self.assertEqual(output.read_text(), 'existing controlled test data')
|
||||
|
||||
@unittest.skipUnless(os.name == 'posix', 'POSIX symlink behavior')
|
||||
def test_output_refuses_symlink_without_touching_target(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
target = Path(directory) / 'target.json'
|
||||
target.write_text('existing controlled test data')
|
||||
output = Path(directory) / 'diagnostics.json'
|
||||
output.symlink_to(target)
|
||||
with self.assertRaises(FileExistsError):
|
||||
module.write_private_output(output, '{"replacement":true}\n')
|
||||
self.assertTrue(output.is_symlink())
|
||||
self.assertEqual(target.read_text(), 'existing controlled test data')
|
||||
|
||||
def test_locked_skips_kernel_body(self):
|
||||
commands = []
|
||||
def run(argv, **kwargs):
|
||||
commands.append(argv)
|
||||
if argv[-2:] == ['dumpsys', 'user']:
|
||||
text = 'Started users state: [0=RUNNING_LOCKED]'
|
||||
elif argv[-1] == 'persist.sys.timezone':
|
||||
text = 'America/Toronto'
|
||||
elif argv[-3:] == ['get', 'global', 'boot_count']:
|
||||
text = '12'
|
||||
else:
|
||||
text = ''
|
||||
return subprocess.CompletedProcess(argv, 0, text, 'PRIVATE_STDERR')
|
||||
with patch.object(module.subprocess, 'run', side_effect=run):
|
||||
result = module.collect('adb', 'test-device', True)
|
||||
self.assertEqual(result['kernel']['status'], 'requires_user_unlock')
|
||||
self.assertFalse(any('--print' in command for command in commands))
|
||||
self.assertNotIn('PRIVATE_STDERR', json.dumps(result))
|
||||
|
||||
def test_command_failure_does_not_export_stderr(self):
|
||||
with patch.object(module.subprocess, 'run', return_value=subprocess.CompletedProcess([], 1, 'UNRELATED_DATA', 'PRIVATE_STDERR')):
|
||||
result = module.collect('adb', 'test-device', True)
|
||||
self.assertIsNone(result['boot_count'])
|
||||
self.assertNotIn('UNRELATED_DATA', json.dumps(result))
|
||||
self.assertNotIn('PRIVATE_STDERR', json.dumps(result))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
Reference in new issue
Block a user