raphiaura/KytyPS5
1
0
Fork 0
mirror of https://github.com/KytyPS5/KytyPS5.git synced 2026-10-28 13:56:59 +01:00
Code Issues Packages Projects Releases Wiki Activity

Fix linux compilation

Browse Source
This commit is contained in:
nmzik
2026-07-27 05:07:16 +02:00
parent 31fb3ec5af
commit c86d4b1f0d
14 changed files with 121 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/CMakeLists.txt
+3
View File
@@ -17,6 +17,7 @@ endif()
set(CMAKE_CXX_STANDARD 20) set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF) set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_CXX_SCAN_FOR_MODULES OFF)
include(utils.cmake) include(utils.cmake)
include(CTest) include(CTest)
@@ -114,6 +115,7 @@ add_custom_target( KytyGitVersion
-D INPUT_FILE=${CMAKE_CURRENT_SOURCE_DIR}/kytyGitVersion.h.in -D INPUT_FILE=${CMAKE_CURRENT_SOURCE_DIR}/kytyGitVersion.h.in
-D OUTPUT_FILE=${CMAKE_CURRENT_BINARY_DIR}/kytyGitVersion.h -D OUTPUT_FILE=${CMAKE_CURRENT_BINARY_DIR}/kytyGitVersion.h
-D GIT_EXECUTABLE=${GIT_EXECUTABLE} -D GIT_EXECUTABLE=${GIT_EXECUTABLE}
-D GIT_WORKING_DIRECTORY=${CMAKE_CURRENT_SOURCE_DIR}
-P ${CMAKE_CURRENT_SOURCE_DIR}/generate_version.cmake -P ${CMAKE_CURRENT_SOURCE_DIR}/generate_version.cmake
COMMENT "Generate kytyGitVersion.h" COMMENT "Generate kytyGitVersion.h"
) )
@@ -357,6 +359,7 @@ target_include_directories(event_queue_lifetime_tests PRIVATE ${inc_headers})
add_executable(image_page_table_tests EXCLUDE_FROM_ALL add_executable(image_page_table_tests EXCLUDE_FROM_ALL
../tests/ImagePageTableTests.cpp ../tests/ImagePageTableTests.cpp
) )
target_link_libraries(image_page_table_tests common fmt::fmt)
target_include_directories(image_page_table_tests PRIVATE ${inc_headers}) target_include_directories(image_page_table_tests PRIVATE ${inc_headers})
add_kyty_full_emulator_test(shader_recompiler_compute_tests ../tests/ShaderRecompilerComputeTests.cpp) add_kyty_full_emulator_test(shader_recompiler_compute_tests ../tests/ShaderRecompilerComputeTests.cpp)
src/common/byteBuffer.h
+1
View File
@@ -6,6 +6,7 @@
#include <algorithm> #include <algorithm>
#include <cstddef> // IWYU pragma: export #include <cstddef> // IWYU pragma: export
#include <cstring>
#include <utility> #include <utility>
#include <vector> #include <vector>
src/common/debug.h
+1
View File
@@ -5,6 +5,7 @@
#include "common/stringUtils.h" #include "common/stringUtils.h"
#include <array> #include <array>
#include <cstring>
namespace Common { namespace Common {
src/generate_version.cmake
+12 -5
View File
@@ -1,8 +1,15 @@
#message("${GIT_EXECUTABLE}") set(KYTY_GIT_VERSION "unknown")
if(GIT_EXECUTABLE) if(GIT_EXECUTABLE)
execute_process(COMMAND ${GIT_EXECUTABLE} describe --tags --always OUTPUT_VARIABLE KYTY_GIT_VERSION) execute_process(
else() COMMAND "${GIT_EXECUTABLE}" describe --tags --always
WORKING_DIRECTORY "${GIT_WORKING_DIRECTORY}"
OUTPUT_VARIABLE KYTY_GIT_VERSION
OUTPUT_STRIP_TRAILING_WHITESPACE
RESULT_VARIABLE GIT_RESULT
ERROR_QUIET
)
if(NOT GIT_RESULT EQUAL 0)
set(KYTY_GIT_VERSION "unknown") set(KYTY_GIT_VERSION "unknown")
endif()
endif() endif()
string(STRIP ${KYTY_GIT_VERSION} KYTY_GIT_VERSION) configure_file("${INPUT_FILE}" "${OUTPUT_FILE}")
configure_file(${INPUT_FILE} ${OUTPUT_FILE})
src/graphics/host_gpu/pageManager.cpp
+19 -8
View File
@@ -30,6 +30,16 @@ constexpr uint64_t ADDRESS_SIZE = TRACKER_ADDRESS_SIZE;
constexpr uint64_t REGION_COUNT = ADDRESS_SIZE / REGION_SIZE; constexpr uint64_t REGION_COUNT = ADDRESS_SIZE / REGION_SIZE;
constexpr uint64_t REGION_PAGES = REGION_SIZE / PAGE_SIZE; constexpr uint64_t REGION_PAGES = REGION_SIZE / PAGE_SIZE;
#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
constexpr uint32_t NO_ACCESS_PROTECTION = PAGE_NOACCESS;
constexpr uint32_t READ_ONLY_PROTECTION = PAGE_READONLY;
constexpr uint32_t READ_WRITE_PROTECTION = PAGE_READWRITE;
#else
constexpr uint32_t NO_ACCESS_PROTECTION = 0;
constexpr uint32_t READ_ONLY_PROTECTION = 1;
constexpr uint32_t READ_WRITE_PROTECTION = 2;
#endif
thread_local bool g_in_fault_resolution = false; thread_local bool g_in_fault_resolution = false;
[[noreturn]] void FailFast(const char* reason = nullptr) noexcept { [[noreturn]] void FailFast(const char* reason = nullptr) noexcept {
@@ -184,21 +194,22 @@ struct PageManager::Impl {
static uint32_t WatcherProtection(const PageState& page) { static uint32_t WatcherProtection(const PageState& page) {
if (page.access_watchers != 0) { if (page.access_watchers != 0) {
return PAGE_NOACCESS; return NO_ACCESS_PROTECTION;
} }
if (page.write_watchers != 0) { if (page.write_watchers != 0) {
return PAGE_READONLY; return READ_ONLY_PROTECTION;
} }
return page.original_protection; return page.original_protection;
} }
static void PublishDelayedFaults(PageState& page, uint32_t old_protection, static void PublishDelayedFaults(PageState& page, uint32_t old_protection,
uint32_t new_protection) { uint32_t new_protection) {
if (old_protection == PAGE_NOACCESS && new_protection != PAGE_NOACCESS) { if (old_protection == NO_ACCESS_PROTECTION && new_protection != NO_ACCESS_PROTECTION) {
page.late_read_pending = true; page.late_read_pending = true;
} }
if ((old_protection == PAGE_NOACCESS || old_protection == PAGE_READONLY) && if ((old_protection == NO_ACCESS_PROTECTION ||
new_protection == PAGE_READWRITE) { old_protection == READ_ONLY_PROTECTION) &&
new_protection == READ_WRITE_PROTECTION) {
page.late_write_pending = true; page.late_write_pending = true;
} }
} }
@@ -397,11 +408,11 @@ void PageManager::UpdatePageWatchers(bool track, uint64_t vaddr, uint64_t size,
Impl::Protect(page_vaddr, new_protection, old_protection, false); Impl::Protect(page_vaddr, new_protection, old_protection, false);
} }
switch (new_protection) { switch (new_protection) {
case PAGE_NOACCESS: case NO_ACCESS_PROTECTION:
page.late_read_pending = false; page.late_read_pending = false;
page.late_write_pending = false; page.late_write_pending = false;
break; break;
case PAGE_READONLY: page.late_write_pending = false; break; case READ_ONLY_PROTECTION: page.late_write_pending = false; break;
default: break; default: break;
} }
} else { } else {
@@ -566,7 +577,7 @@ void PageManager::EndBackingWrite(uint64_t vaddr, uint64_t size) noexcept {
if (!page.resolving || page.backing_writer != writer) { if (!page.resolving || page.backing_writer != writer) {
FailFast("backing write ended without matching owner and resolving state"); FailFast("backing write ended without matching owner and resolving state");
} }
const auto old_protection = PAGE_NOACCESS; const auto old_protection = NO_ACCESS_PROTECTION;
const auto new_protection = Impl::WatcherProtection(page); const auto new_protection = Impl::WatcherProtection(page);
if (new_protection != old_protection) { if (new_protection != old_protection) {
Impl::Protect(address, new_protection, old_protection, false); Impl::Protect(address, new_protection, old_protection, false);
src/graphics/host_gpu/renderer/multiLevelPageTable.h
+3 -2
View File
@@ -1,13 +1,14 @@
#ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_MULTILEVELPAGETABLE_H_ #ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_MULTILEVELPAGETABLE_H_
#define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_MULTILEVELPAGETABLE_H_ #define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_MULTILEVELPAGETABLE_H_
#include "common/assert.h"
#include <algorithm> #include <algorithm>
#include <array> #include <array>
#include <cstddef> #include <cstddef>
#include <cstdint> #include <cstdint>
#include <list> #include <list>
#include <memory> #include <memory>
#include <stdexcept>
#include <utility> #include <utility>
#include <vector> #include <vector>
@@ -59,7 +60,7 @@ public:
[[nodiscard]] Entry& GetOrCreate(size_t page) { [[nodiscard]] Entry& GetOrCreate(size_t page) {
if (!IsValidPage(page)) { if (!IsValidPage(page)) {
throw std::out_of_range("MultiLevelPageTable page is outside the guest address space"); EXIT("MultiLevelPageTable page is outside the guest address space");
} }
auto& bucket = m_first_level[FirstLevelIndex(page)]; auto& bucket = m_first_level[FirstLevelIndex(page)];
if (bucket == nullptr) { if (bucket == nullptr) {
src/kernel/memory.cpp
+28 -27
View File
@@ -1910,20 +1910,21 @@ int32_t KYTY_SYSV_ABI KernelMapNamedFlexibleMemory(void** addr_in_out, size_t le
constexpr size_t PAGE_SIZE = 0x4000; constexpr size_t PAGE_SIZE = 0x4000;
constexpr size_t MAXIMUM_NAME_SIZE = 32; constexpr size_t MAXIMUM_NAME_SIZE = 32;
constexpr uint64_t DEFAULT_PS5_BASE = 0x200000000; constexpr uint64_t DEFAULT_PS5_BASE = 0x200000000;
constexpr int MAP_FIXED = 0x10; constexpr int GUEST_MAP_FIXED = 0x10;
constexpr int MAP_SHARED = 0x01; constexpr int GUEST_MAP_SHARED = 0x01;
constexpr int MAP_PRIVATE = 0x02; constexpr int GUEST_MAP_PRIVATE = 0x02;
constexpr int MAP_NO_OVERWRITE = 0x80; constexpr int GUEST_MAP_NO_OVERWRITE = 0x80;
constexpr int MAP_VOID = 0x100; constexpr int GUEST_MAP_VOID = 0x100;
constexpr int MAP_STACK = 0x400; constexpr int GUEST_MAP_STACK = 0x400;
constexpr int MAP_NO_SYNC = 0x800; constexpr int GUEST_MAP_NO_SYNC = 0x800;
constexpr int MAP_ANON = 0x1000; constexpr int GUEST_MAP_ANON = 0x1000;
constexpr int MAP_UNKNOWN_8000 = 0x8000; constexpr int GUEST_MAP_UNKNOWN_8000 = 0x8000;
constexpr int MAP_NO_CORE = 0x20000; constexpr int GUEST_MAP_NO_CORE = 0x20000;
constexpr int MAP_NO_COALESCE = 0x400000; constexpr int GUEST_MAP_NO_COALESCE = 0x400000;
constexpr int SUPPORTED_MAP_BITS = MAP_SHARED | MAP_PRIVATE | MAP_FIXED | MAP_NO_OVERWRITE | constexpr int SUPPORTED_MAP_BITS =
MAP_VOID | MAP_STACK | MAP_NO_SYNC | MAP_ANON | GUEST_MAP_SHARED | GUEST_MAP_PRIVATE | GUEST_MAP_FIXED | GUEST_MAP_NO_OVERWRITE |
MAP_UNKNOWN_8000 | MAP_NO_CORE | MAP_NO_COALESCE; GUEST_MAP_VOID | GUEST_MAP_STACK | GUEST_MAP_NO_SYNC | GUEST_MAP_ANON |
GUEST_MAP_UNKNOWN_8000 | GUEST_MAP_NO_CORE | GUEST_MAP_NO_COALESCE;
if (len == 0 || (len & (PAGE_SIZE - 1)) != 0) { if (len == 0 || (len & (PAGE_SIZE - 1)) != 0) {
return KERNEL_ERROR_EINVAL; return KERNEL_ERROR_EINVAL;
@@ -1956,11 +1957,11 @@ int32_t KYTY_SYSV_ABI KernelMapNamedFlexibleMemory(void** addr_in_out, size_t le
bool consumed_reserved = false; bool consumed_reserved = false;
VirtualRanges::Range consumed_range {}; VirtualRanges::Range consumed_range {};
if ((flags & MAP_FIXED) != 0) { if ((flags & GUEST_MAP_FIXED) != 0) {
if (in_addr == 0 || (in_addr & (PAGE_SIZE - 1)) != 0) { if (in_addr == 0 || (in_addr & (PAGE_SIZE - 1)) != 0) {
return KERNEL_ERROR_EINVAL; return KERNEL_ERROR_EINVAL;
} }
if ((flags & MAP_NO_OVERWRITE) != 0 && g_virtual_ranges->HasOverlap(in_addr, len)) { if ((flags & GUEST_MAP_NO_OVERWRITE) != 0 && g_virtual_ranges->HasOverlap(in_addr, len)) {
return KERNEL_ERROR_ENOMEM; return KERNEL_ERROR_ENOMEM;
} }
if (g_virtual_ranges->Query(in_addr, 0, &consumed_range) && if (g_virtual_ranges->Query(in_addr, 0, &consumed_range) &&
@@ -2005,7 +2006,7 @@ int32_t KYTY_SYSV_ABI KernelMapNamedFlexibleMemory(void** addr_in_out, size_t le
} }
const auto range_type = const auto range_type =
((flags & MAP_STACK) != 0 ? VirtualRangeType::Stack : VirtualRangeType::Flexible); ((flags & GUEST_MAP_STACK) != 0 ? VirtualRangeType::Stack : VirtualRangeType::Flexible);
if (!g_virtual_ranges->Add(out_addr, len, 0, prot, 0, range_type, name, if (!g_virtual_ranges->Add(out_addr, len, 0, prot, 0, range_type, name,
committed_from_reserved)) { committed_from_reserved)) {
GpuAccessMode rollback_gpu_mode = GpuAccessMode::NoAccess; GpuAccessMode rollback_gpu_mode = GpuAccessMode::NoAccess;
@@ -2673,11 +2674,11 @@ int KYTY_SYSV_ABI KernelMapDirectMemory(void** addr, size_t len, int prot, int f
std::lock_guard<std::recursive_mutex> memory_operation_lock(g_memory_operation_mutex); std::lock_guard<std::recursive_mutex> memory_operation_lock(g_memory_operation_mutex);
EXIT_NOT_IMPLEMENTED(addr == nullptr); EXIT_NOT_IMPLEMENTED(addr == nullptr);
constexpr int MAP_FIXED = 0x10; constexpr int GUEST_MAP_FIXED = 0x10;
constexpr int MAP_NO_OVERWRITE = 0x80; constexpr int GUEST_MAP_NO_OVERWRITE = 0x80;
bool fixed = ((flags & MAP_FIXED) != 0); bool fixed = ((flags & GUEST_MAP_FIXED) != 0);
bool no_overwrite = ((flags & MAP_NO_OVERWRITE) != 0); bool no_overwrite = ((flags & GUEST_MAP_NO_OVERWRITE) != 0);
VirtualMemory::Mode mode = VirtualMemory::Mode::NoAccess; VirtualMemory::Mode mode = VirtualMemory::Mode::NoAccess;
GpuAccessMode gpu_mode = GpuAccessMode::NoAccess; GpuAccessMode gpu_mode = GpuAccessMode::NoAccess;
@@ -3279,8 +3280,8 @@ int KYTY_SYSV_ABI KernelReserveVirtualRange(void** addr, size_t len, int flags,
in_addr, len, flags, alignment); in_addr, len, flags, alignment);
constexpr size_t PAGE_SIZE = 0x4000; constexpr size_t PAGE_SIZE = 0x4000;
constexpr int MAP_FIXED = 0x10; constexpr int GUEST_MAP_FIXED = 0x10;
constexpr int MAP_NO_OVERWRITE = 0x80; constexpr int GUEST_MAP_NO_OVERWRITE = 0x80;
if (addr == nullptr || len == 0 || (len & (PAGE_SIZE - 1)) != 0) { if (addr == nullptr || len == 0 || (len & (PAGE_SIZE - 1)) != 0) {
return KERNEL_ERROR_EINVAL; return KERNEL_ERROR_EINVAL;
@@ -3292,11 +3293,11 @@ int KYTY_SYSV_ABI KernelReserveVirtualRange(void** addr, size_t len, int flags,
uint64_t out_addr = 0; uint64_t out_addr = 0;
bool range_already_added = false; bool range_already_added = false;
bool placeholder_backed = false; bool placeholder_backed = false;
if ((flags & MAP_FIXED) != 0) { if ((flags & GUEST_MAP_FIXED) != 0) {
if (in_addr == 0 || (in_addr & (PAGE_SIZE - 1)) != 0) { if (in_addr == 0 || (in_addr & (PAGE_SIZE - 1)) != 0) {
return KERNEL_ERROR_EINVAL; return KERNEL_ERROR_EINVAL;
} }
if ((flags & MAP_NO_OVERWRITE) != 0 && g_virtual_ranges->HasOverlap(in_addr, len)) { if ((flags & GUEST_MAP_NO_OVERWRITE) != 0 && g_virtual_ranges->HasOverlap(in_addr, len)) {
return KERNEL_ERROR_ENOMEM; return KERNEL_ERROR_ENOMEM;
} }
if (ReplaceFixedRangeWithReserved(in_addr, len, &placeholder_backed)) { if (ReplaceFixedRangeWithReserved(in_addr, len, &placeholder_backed)) {
@@ -3710,8 +3711,8 @@ int KYTY_SYSV_ABI KernelBatchMap2(KernelBatchMapEntry* entries, int num_entries,
int KYTY_SYSV_ABI KernelBatchMap(KernelBatchMapEntry* entries, int num_entries, int KYTY_SYSV_ABI KernelBatchMap(KernelBatchMapEntry* entries, int num_entries,
int* num_entries_out) { int* num_entries_out) {
constexpr int MAP_FIXED = 0x10; constexpr int GUEST_MAP_FIXED = 0x10;
return KernelBatchMap2(entries, num_entries, num_entries_out, MAP_FIXED); return KernelBatchMap2(entries, num_entries, num_entries_out, GUEST_MAP_FIXED);
} }
static bool IsAligned(uint64_t value, uint64_t alignment) { static bool IsAligned(uint64_t value, uint64_t alignment) {
src/kernel/memoryAddressSpace.inc
+1 -1
View File
@@ -1382,8 +1382,8 @@ private:
} }
} }
uint64_t m_granularity = 0x10000;
std::mutex m_mutex; std::mutex m_mutex;
std::map<uint64_t, uint64_t> m_free; std::map<uint64_t, uint64_t> m_free;
#endif #endif
uint64_t m_granularity = 0x10000;
}; };
src/kernel/pthread.cpp
+12 -12
View File
@@ -61,7 +61,7 @@ LIB_NAME("libkernel", "libkernel");
constexpr int KEYS_MAX = 256; constexpr int KEYS_MAX = 256;
constexpr int DESTRUCTOR_ITERATIONS = 4; constexpr int DESTRUCTOR_ITERATIONS = 4;
constexpr size_t PTHREAD_STACK_DEFAULT = 0x100000; constexpr size_t PTHREAD_STACK_DEFAULT = 0x100000;
constexpr size_t PTHREAD_STACK_MIN = 0x4000; constexpr size_t GUEST_PTHREAD_STACK_MIN = 0x4000;
constexpr size_t PTHREAD_STACK_PAGE = 0x4000; constexpr size_t PTHREAD_STACK_PAGE = 0x4000;
constexpr size_t PTHREAD_STACK_GRANULARITY = 0x10000; constexpr size_t PTHREAD_STACK_GRANULARITY = 0x10000;
constexpr size_t PTHREAD_STACK_INITIAL = 0x200000; constexpr size_t PTHREAD_STACK_INITIAL = 0x200000;
@@ -290,12 +290,12 @@ static bool KernelClockGettimeSpecial(KernelClockid clock_id, KernelTimespec* tp
} }
} }
#else #else
static bool kernel_clock_gettime_special(KernelClockid clock_id, KernelTimespec* tp, int* error) { static bool KernelClockGettimeSpecial(KernelClockid clock_id, KernelTimespec* tp, int* error) {
EXIT_IF(tp == nullptr); EXIT_IF(tp == nullptr);
EXIT_IF(error == nullptr); EXIT_IF(error == nullptr);
if (clock_id == KERNEL_CLOCK_PROCTIME) { if (clock_id == KERNEL_CLOCK_PROCTIME) {
kernel_us_to_timespec(kernel_get_process_time_us_native(), tp); KernelUsToTimespec(KernelGetProcessTimeUsNative(), tp);
return true; return true;
} }
@@ -709,15 +709,15 @@ static int CreateGuestStack(PthreadAttr attr) {
void* mapped_addr = reinterpret_cast<void*>(stack_addr); void* mapped_addr = reinterpret_cast<void*>(stack_addr);
constexpr int PROT_READ_WRITE = 0x03; constexpr int GUEST_PROT_READ_WRITE = 0x03;
constexpr int MAP_PRIVATE = 0x02; constexpr int GUEST_MAP_PRIVATE = 0x02;
constexpr int MAP_FIXED = 0x10; constexpr int GUEST_MAP_FIXED = 0x10;
constexpr int MAP_STACK = 0x400; constexpr int GUEST_MAP_STACK = 0x400;
constexpr int MAP_ANON = 0x1000; constexpr int GUEST_MAP_ANON = 0x1000;
int result = Memory::KernelMapNamedFlexibleMemory( int result = Memory::KernelMapNamedFlexibleMemory(
&mapped_addr, map_size, PROT_READ_WRITE, MAP_PRIVATE | MAP_FIXED | MAP_STACK | MAP_ANON, &mapped_addr, map_size, GUEST_PROT_READ_WRITE,
"stack"); GUEST_MAP_PRIVATE | GUEST_MAP_FIXED | GUEST_MAP_STACK | GUEST_MAP_ANON, "stack");
if (result != OK) { if (result != OK) {
return KERNEL_ERROR_EAGAIN; return KERNEL_ERROR_EAGAIN;
} }
@@ -2177,7 +2177,7 @@ int KYTY_SYSV_ABI PthreadAttrSetstack(PthreadAttr* attr, void* addr, size_t size
// PRINT_NAME(); // PRINT_NAME();
auto* attr_value = GetPthreadAttrValue(attr, "PthreadAttrSetstack"); auto* attr_value = GetPthreadAttrValue(attr, "PthreadAttrSetstack");
if (addr == nullptr || size < PTHREAD_STACK_MIN || attr_value == nullptr) { if (addr == nullptr || size < GUEST_PTHREAD_STACK_MIN || attr_value == nullptr) {
return KERNEL_ERROR_EINVAL; return KERNEL_ERROR_EINVAL;
} }
@@ -2210,7 +2210,7 @@ int KYTY_SYSV_ABI PthreadAttrSetstacksize(PthreadAttr* attr, size_t stack_size)
// PRINT_NAME(); // PRINT_NAME();
auto* attr_value = GetPthreadAttrValue(attr, "PthreadAttrSetstacksize"); auto* attr_value = GetPthreadAttrValue(attr, "PthreadAttrSetstacksize");
if (stack_size < PTHREAD_STACK_MIN || attr_value == nullptr) { if (stack_size < GUEST_PTHREAD_STACK_MIN || attr_value == nullptr) {
return KERNEL_ERROR_EINVAL; return KERNEL_ERROR_EINVAL;
} }
src/kernel/semaphore.cpp
+1
View File
@@ -9,6 +9,7 @@
#include "libs/libs.h" #include "libs/libs.h"
#include <algorithm> #include <algorithm>
#include <atomic>
#include <limits> #include <limits>
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
src/launcher/CMakeLists.txt
+1
View File
@@ -24,6 +24,7 @@ if(WIN32)
target_link_libraries(launcher setupapi) target_link_libraries(launcher setupapi)
endif() endif()
if (CLANG AND NOT KYTY_CLANG_CL) if (CLANG AND NOT KYTY_CLANG_CL)
target_compile_options(launcher PRIVATE -frtti)
target_link_libraries(launcher pthread) target_link_libraries(launcher pthread)
endif() endif()
target_include_directories(launcher PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/include" "${CMAKE_CURRENT_SOURCE_DIR}/src") target_include_directories(launcher PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/include" "${CMAKE_CURRENT_SOURCE_DIR}/src")
src/libs/libC.cpp
+4 -4
View File
@@ -772,19 +772,19 @@ int KYTY_SYSV_ABI atoi(const char* str) {
} }
float KYTY_SYSV_ABI sinf(float x) { float KYTY_SYSV_ABI sinf(float x) {
return std::sinf(x); return std::sin(x);
} }
float KYTY_SYSV_ABI cosf(float x) { float KYTY_SYSV_ABI cosf(float x) {
return std::cosf(x); return std::cos(x);
} }
void KYTY_SYSV_ABI sincosf(float x, float* sinp, float* cosp) { void KYTY_SYSV_ABI sincosf(float x, float* sinp, float* cosp) {
if (sinp != nullptr) { if (sinp != nullptr) {
*sinp = std::sinf(x); *sinp = std::sin(x);
} }
if (cosp != nullptr) { if (cosp != nullptr) {
*cosp = std::cosf(x); *cosp = std::cos(x);
} }
} }
src/libs/network.cpp
+33 -29
View File
@@ -812,13 +812,17 @@ struct NetEtherAddr {
uint8_t data[6] = {0}; uint8_t data[6] = {0};
}; };
#if defined(_WIN32)
using NativeSocket = SOCKET;
static constexpr NativeSocket INVALID_NATIVE_SOCKET = INVALID_SOCKET;
#else
using NativeSocket = int;
static constexpr NativeSocket INVALID_NATIVE_SOCKET = -1;
#endif
struct SocketSlot { struct SocketSlot {
bool used = false; bool used = false;
#if defined(_WIN32) NativeSocket socket = INVALID_NATIVE_SOCKET;
SOCKET socket = INVALID_SOCKET;
#else
int socket = -1;
#endif
}; };
struct NetTimeval { struct NetTimeval {
@@ -1050,7 +1054,7 @@ static int ConvertHostSockaddr(const sockaddr_storage* addr, int addrlen, void*
} }
#endif #endif
static bool GetSocketBackend(int guest_fd, SOCKET* out) { static bool GetSocketBackend(int guest_fd, NativeSocket* out) {
EXIT_IF(out == nullptr); EXIT_IF(out == nullptr);
if (guest_fd < 0 || guest_fd >= SOCKET_FD_MAX) { if (guest_fd < 0 || guest_fd >= SOCKET_FD_MAX) {
@@ -1075,7 +1079,7 @@ bool KYTY_SYSV_ABI IsSocket(int s) {
return g_sockets[static_cast<size_t>(s)].used; return g_sockets[static_cast<size_t>(s)].used;
} }
static bool TakeSocketBackend(int guest_fd, SOCKET* out) { static bool TakeSocketBackend(int guest_fd, NativeSocket* out) {
EXIT_IF(out == nullptr); EXIT_IF(out == nullptr);
if (guest_fd < 0 || guest_fd >= SOCKET_FD_MAX) { if (guest_fd < 0 || guest_fd >= SOCKET_FD_MAX) {
@@ -1093,7 +1097,7 @@ static bool TakeSocketBackend(int guest_fd, SOCKET* out) {
return true; return true;
} }
static int AllocSocketFd(SOCKET socket) { static int AllocSocketFd(NativeSocket socket) {
Common::LockGuard lock(g_socket_mutex); Common::LockGuard lock(g_socket_mutex);
for (int fd = SOCKET_FD_MIN; fd < SOCKET_FD_MAX; fd++) { for (int fd = SOCKET_FD_MIN; fd < SOCKET_FD_MAX; fd++) {
auto& slot = g_sockets[static_cast<size_t>(fd)]; auto& slot = g_sockets[static_cast<size_t>(fd)];
@@ -1472,7 +1476,7 @@ int KYTY_SYSV_ABI EpollWait(int eid, NetEpollEvent* events, int maxevents, int t
#if defined(_WIN32) #if defined(_WIN32)
struct HostRegistration { struct HostRegistration {
EpollRegistration guest; EpollRegistration guest;
SOCKET socket = INVALID_SOCKET; NativeSocket socket = INVALID_NATIVE_SOCKET;
}; };
fd_set host_read {}; fd_set host_read {};
@@ -1485,7 +1489,7 @@ int KYTY_SYSV_ABI EpollWait(int eid, NetEpollEvent* events, int maxevents, int t
std::vector<HostRegistration> host_registrations; std::vector<HostRegistration> host_registrations;
host_registrations.reserve(registrations.size()); host_registrations.reserve(registrations.size());
for (const auto& registration: registrations) { for (const auto& registration: registrations) {
SOCKET socket = INVALID_SOCKET; NativeSocket socket = INVALID_NATIVE_SOCKET;
if (!GetSocketBackend(registration.id, &socket)) { if (!GetSocketBackend(registration.id, &socket)) {
continue; continue;
} }
@@ -1573,7 +1577,7 @@ int KYTY_SYSV_ABI SocketClose(int s) {
LOGF("\t s = %d\n", s); LOGF("\t s = %d\n", s);
SOCKET socket = INVALID_SOCKET; NativeSocket socket = INVALID_NATIVE_SOCKET;
if (!TakeSocketBackend(s, &socket)) { if (!TakeSocketBackend(s, &socket)) {
return NET_ERROR_EBADF; return NET_ERROR_EBADF;
} }
@@ -1609,8 +1613,8 @@ int KYTY_SYSV_ABI Socket(int family, int type, int protocol) {
} }
#if defined(_WIN32) #if defined(_WIN32)
SOCKET socket = ::socket(host_family, type, protocol); NativeSocket socket = ::socket(host_family, type, protocol);
if (socket == INVALID_SOCKET) { if (socket == INVALID_NATIVE_SOCKET) {
return SetPosixSocketError(); return SetPosixSocketError();
} }
@@ -1637,7 +1641,7 @@ int KYTY_SYSV_ABI Bind(int s, const void* addr, uint32_t addrlen) {
"\t addrlen = %" PRIu32 "\n", "\t addrlen = %" PRIu32 "\n",
s, reinterpret_cast<uint64_t>(addr), addrlen); s, reinterpret_cast<uint64_t>(addr), addrlen);
SOCKET socket = INVALID_SOCKET; NativeSocket socket = INVALID_NATIVE_SOCKET;
if (addr == nullptr || !GetSocketBackend(s, &socket)) { if (addr == nullptr || !GetSocketBackend(s, &socket)) {
*Posix::GetErrorAddr() = (addr == nullptr ? Posix::POSIX_EFAULT : Posix::POSIX_EBADF); *Posix::GetErrorAddr() = (addr == nullptr ? Posix::POSIX_EFAULT : Posix::POSIX_EBADF);
return -1; return -1;
@@ -1670,7 +1674,7 @@ int KYTY_SYSV_ABI Connect(int s, const void* addr, uint32_t addrlen) {
"\t addrlen = %" PRIu32 "\n", "\t addrlen = %" PRIu32 "\n",
s, reinterpret_cast<uint64_t>(addr), addrlen); s, reinterpret_cast<uint64_t>(addr), addrlen);
SOCKET socket = INVALID_SOCKET; NativeSocket socket = INVALID_NATIVE_SOCKET;
if (addr == nullptr || !GetSocketBackend(s, &socket)) { if (addr == nullptr || !GetSocketBackend(s, &socket)) {
*Posix::GetErrorAddr() = (addr == nullptr ? Posix::POSIX_EFAULT : Posix::POSIX_EBADF); *Posix::GetErrorAddr() = (addr == nullptr ? Posix::POSIX_EFAULT : Posix::POSIX_EBADF);
return -1; return -1;
@@ -1702,7 +1706,7 @@ int KYTY_SYSV_ABI Listen(int s, int backlog) {
"\t backlog = %d\n", "\t backlog = %d\n",
s, backlog); s, backlog);
SOCKET socket = INVALID_SOCKET; NativeSocket socket = INVALID_NATIVE_SOCKET;
if (!GetSocketBackend(s, &socket)) { if (!GetSocketBackend(s, &socket)) {
*Posix::GetErrorAddr() = Posix::POSIX_EBADF; *Posix::GetErrorAddr() = Posix::POSIX_EBADF;
return -1; return -1;
@@ -1728,7 +1732,7 @@ int KYTY_SYSV_ABI Accept(int s, void* addr, uint32_t* addrlen) {
"\t addrlen = 0x%016" PRIx64 "\n", "\t addrlen = 0x%016" PRIx64 "\n",
s, reinterpret_cast<uint64_t>(addr), reinterpret_cast<uint64_t>(addrlen)); s, reinterpret_cast<uint64_t>(addr), reinterpret_cast<uint64_t>(addrlen));
SOCKET socket = INVALID_SOCKET; NativeSocket socket = INVALID_NATIVE_SOCKET;
if (!GetSocketBackend(s, &socket)) { if (!GetSocketBackend(s, &socket)) {
*Posix::GetErrorAddr() = Posix::POSIX_EBADF; *Posix::GetErrorAddr() = Posix::POSIX_EBADF;
return -1; return -1;
@@ -1737,8 +1741,8 @@ int KYTY_SYSV_ABI Accept(int s, void* addr, uint32_t* addrlen) {
#if defined(_WIN32) #if defined(_WIN32)
sockaddr_storage host_addr {}; sockaddr_storage host_addr {};
int host_addrlen = sizeof(host_addr); int host_addrlen = sizeof(host_addr);
SOCKET accepted = ::accept(socket, reinterpret_cast<sockaddr*>(&host_addr), &host_addrlen); NativeSocket accepted = ::accept(socket, reinterpret_cast<sockaddr*>(&host_addr), &host_addrlen);
if (accepted == INVALID_SOCKET) { if (accepted == INVALID_NATIVE_SOCKET) {
return SetPosixSocketError(); return SetPosixSocketError();
} }
@@ -1775,7 +1779,7 @@ int KYTY_SYSV_ABI Shutdown(int s, int how) {
"\t how = %d\n", "\t how = %d\n",
s, how); s, how);
SOCKET socket = INVALID_SOCKET; NativeSocket socket = INVALID_NATIVE_SOCKET;
if (!GetSocketBackend(s, &socket)) { if (!GetSocketBackend(s, &socket)) {
*Posix::GetErrorAddr() = Posix::POSIX_EBADF; *Posix::GetErrorAddr() = Posix::POSIX_EBADF;
return -1; return -1;
@@ -1806,7 +1810,7 @@ int KYTY_SYSV_ABI Getsockname(int s, void* addr, uint32_t* addrlen) {
"\t addrlen = 0x%016" PRIx64 "\n", "\t addrlen = 0x%016" PRIx64 "\n",
s, reinterpret_cast<uint64_t>(addr), reinterpret_cast<uint64_t>(addrlen)); s, reinterpret_cast<uint64_t>(addr), reinterpret_cast<uint64_t>(addrlen));
SOCKET socket = INVALID_SOCKET; NativeSocket socket = INVALID_NATIVE_SOCKET;
const bool socket_ok = GetSocketBackend(s, &socket); const bool socket_ok = GetSocketBackend(s, &socket);
if (addr == nullptr || addrlen == nullptr || !socket_ok) { if (addr == nullptr || addrlen == nullptr || !socket_ok) {
*Posix::GetErrorAddr() = (!socket_ok ? Posix::POSIX_EBADF : Posix::POSIX_EFAULT); *Posix::GetErrorAddr() = (!socket_ok ? Posix::POSIX_EBADF : Posix::POSIX_EFAULT);
@@ -1836,7 +1840,7 @@ int KYTY_SYSV_ABI Getsockopt(int s, int level, int optname, void* optval, uint32
"\t optname = 0x%08" PRIx32 "\n", "\t optname = 0x%08" PRIx32 "\n",
s, static_cast<uint32_t>(level), static_cast<uint32_t>(optname)); s, static_cast<uint32_t>(level), static_cast<uint32_t>(optname));
SOCKET socket = INVALID_SOCKET; NativeSocket socket = INVALID_NATIVE_SOCKET;
const bool socket_ok = GetSocketBackend(s, &socket); const bool socket_ok = GetSocketBackend(s, &socket);
if (optval == nullptr || optlen == nullptr || !socket_ok) { if (optval == nullptr || optlen == nullptr || !socket_ok) {
*Posix::GetErrorAddr() = (!socket_ok ? Posix::POSIX_EBADF : Posix::POSIX_EFAULT); *Posix::GetErrorAddr() = (!socket_ok ? Posix::POSIX_EBADF : Posix::POSIX_EFAULT);
@@ -1866,7 +1870,7 @@ int KYTY_SYSV_ABI Setsockopt(int s, int level, int optname, const void* optval,
"\t optlen = %" PRIu32 "\n", "\t optlen = %" PRIu32 "\n",
s, static_cast<uint32_t>(level), static_cast<uint32_t>(optname), optlen); s, static_cast<uint32_t>(level), static_cast<uint32_t>(optname), optlen);
SOCKET socket = INVALID_SOCKET; NativeSocket socket = INVALID_NATIVE_SOCKET;
if (optval == nullptr || !GetSocketBackend(s, &socket)) { if (optval == nullptr || !GetSocketBackend(s, &socket)) {
*Posix::GetErrorAddr() = (optval == nullptr ? Posix::POSIX_EFAULT : Posix::POSIX_EBADF); *Posix::GetErrorAddr() = (optval == nullptr ? Posix::POSIX_EFAULT : Posix::POSIX_EBADF);
return -1; return -1;
@@ -1904,7 +1908,7 @@ int64_t KYTY_SYSV_ABI Send(int s, const void* buf, uint64_t len, int flags) {
"\t flags = 0x%08" PRIx32 "\n", "\t flags = 0x%08" PRIx32 "\n",
s, reinterpret_cast<uint64_t>(buf), len, static_cast<uint32_t>(flags)); s, reinterpret_cast<uint64_t>(buf), len, static_cast<uint32_t>(flags));
SOCKET socket = INVALID_SOCKET; NativeSocket socket = INVALID_NATIVE_SOCKET;
if (buf == nullptr || !GetSocketBackend(s, &socket)) { if (buf == nullptr || !GetSocketBackend(s, &socket)) {
*Posix::GetErrorAddr() = (buf == nullptr ? Posix::POSIX_EFAULT : Posix::POSIX_EBADF); *Posix::GetErrorAddr() = (buf == nullptr ? Posix::POSIX_EFAULT : Posix::POSIX_EBADF);
return -1; return -1;
@@ -1938,7 +1942,7 @@ int64_t KYTY_SYSV_ABI Recv(int s, void* buf, uint64_t len, int flags) {
"\t flags = 0x%08" PRIx32 "\n", "\t flags = 0x%08" PRIx32 "\n",
s, reinterpret_cast<uint64_t>(buf), len, static_cast<uint32_t>(flags)); s, reinterpret_cast<uint64_t>(buf), len, static_cast<uint32_t>(flags));
SOCKET socket = INVALID_SOCKET; NativeSocket socket = INVALID_NATIVE_SOCKET;
if (buf == nullptr || !GetSocketBackend(s, &socket)) { if (buf == nullptr || !GetSocketBackend(s, &socket)) {
*Posix::GetErrorAddr() = (buf == nullptr ? Posix::POSIX_EFAULT : Posix::POSIX_EBADF); *Posix::GetErrorAddr() = (buf == nullptr ? Posix::POSIX_EFAULT : Posix::POSIX_EBADF);
return -1; return -1;
@@ -2010,7 +2014,7 @@ int KYTY_SYSV_ABI Select(int nfds, void* readfds, void* writefds, void* exceptfd
int except_count = 0; int except_count = 0;
for (int fd = 0; fd < nfds; fd++) { for (int fd = 0; fd < nfds; fd++) {
SOCKET socket = INVALID_SOCKET; NativeSocket socket = INVALID_NATIVE_SOCKET;
if (!GetSocketBackend(fd, &socket)) { if (!GetSocketBackend(fd, &socket)) {
continue; continue;
} }
@@ -2061,21 +2065,21 @@ int KYTY_SYSV_ABI Select(int nfds, void* readfds, void* writefds, void* exceptfd
GuestFdZero(writefds, nfds); GuestFdZero(writefds, nfds);
GuestFdZero(exceptfds, nfds); GuestFdZero(exceptfds, nfds);
for (int i = 0; i < read_count; i++) { for (int i = 0; i < read_count; i++) {
SOCKET socket = INVALID_SOCKET; NativeSocket socket = INVALID_NATIVE_SOCKET;
if (GetSocketBackend(read_map[static_cast<size_t>(i)], &socket) && if (GetSocketBackend(read_map[static_cast<size_t>(i)], &socket) &&
FD_ISSET(socket, &host_read)) { FD_ISSET(socket, &host_read)) {
GuestFdSet(readfds, read_map[static_cast<size_t>(i)]); GuestFdSet(readfds, read_map[static_cast<size_t>(i)]);
} }
} }
for (int i = 0; i < write_count; i++) { for (int i = 0; i < write_count; i++) {
SOCKET socket = INVALID_SOCKET; NativeSocket socket = INVALID_NATIVE_SOCKET;
if (GetSocketBackend(write_map[static_cast<size_t>(i)], &socket) && if (GetSocketBackend(write_map[static_cast<size_t>(i)], &socket) &&
FD_ISSET(socket, &host_write)) { FD_ISSET(socket, &host_write)) {
GuestFdSet(writefds, write_map[static_cast<size_t>(i)]); GuestFdSet(writefds, write_map[static_cast<size_t>(i)]);
} }
} }
for (int i = 0; i < except_count; i++) { for (int i = 0; i < except_count; i++) {
SOCKET socket = INVALID_SOCKET; NativeSocket socket = INVALID_NATIVE_SOCKET;
if (GetSocketBackend(except_map[static_cast<size_t>(i)], &socket) && if (GetSocketBackend(except_map[static_cast<size_t>(i)], &socket) &&
FD_ISSET(socket, &host_except)) { FD_ISSET(socket, &host_except)) {
GuestFdSet(exceptfds, except_map[static_cast<size_t>(i)]); GuestFdSet(exceptfds, except_map[static_cast<size_t>(i)]);
tests/ImagePageTableTests.cpp
-8
View File
@@ -3,7 +3,6 @@
#include <cstdint> #include <cstdint>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <stdexcept>
#include <vector> #include <vector>
namespace { namespace {
@@ -69,13 +68,6 @@ void TestAddressSpaceBoundaries() {
table.GetOrCreate(Table::kPageCount - 1).push_back(99); table.GetOrCreate(Table::kPageCount - 1).push_back(99);
Check(table.Find(Table::kPageCount - 1) != nullptr && table.Find(Table::kPageCount - 1)->front() == 99, Check(table.Find(Table::kPageCount - 1) != nullptr && table.Find(Table::kPageCount - 1)->front() == 99,
"final page supports allocating and nonallocating access"); "final page supports allocating and nonallocating access");
bool threw = false;
try {
(void)table.GetOrCreate(Table::kPageCount);
} catch (const std::out_of_range&) {
threw = true;
}
Check(threw, "allocating access hard-fails outside the guest address space");
} }
void TestMultiRangeRegistrationDeduplicatesPages() { void TestMultiRangeRegistrationDeduplicatesPages() {