arm64: Add stubs so kernel can at least link

Signed-off-by: Jaroslaw Pelczar <[email protected]>
Change-Id: I2476a6346c912c4aa0c26e4f3720ea2c2690b669
Reviewed-on: https://review.haiku-os.org/c/haiku/+/1857
Reviewed-by: Alex von Gluck IV <[email protected]>

src/system/kernel/arch/arm64/Jamfile

@@ -5,6 +5,21 @@ UsePrivateKernelHeaders ;
 
 KernelMergeObject kernel_arch_arm64.o :
 	arch_elf.cpp
+	arch_int.cpp
+	arch_commpage.cpp
+	arch_thread.cpp
+	arch_cpu.cpp
+	arch_debug_console.cpp
+	arch_debug.cpp
+	arch_user_debugger.cpp
+	arch_vm_translation_map.cpp
+	arch_vm.cpp
+	arch_timer.cpp
+	arch_system_info.cpp
+	arch_smp.cpp
+	arch_real_time_clock.cpp
+	arch_platform.cpp
+	arch_asm.S
 	
 	:
 	$(TARGET_KERNEL_PIC_CCFLAGS) -Wno-unused

src/system/kernel/arch/arm64/arch_asm.S

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2019 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#include <arch/arm/arch_cpu.h>
+#include <asm_defs.h>
+
+.text
+
+/* status_t arch_cpu_user_memcpy(void *to, const void *from, size_t size, addr_t *faultHandler) */
+FUNCTION(_arch_cpu_user_memcpy):
+	mov		x0, xzr
+	ret
+FUNCTION_END(_arch_cpu_user_memcpy)
+
+/* status_t arch_cpu_user_memset(void *to, char c, size_t count, addr_t *faultHandler) */
+FUNCTION(_arch_cpu_user_memset):
+	mov		x0, xzr
+	ret
+FUNCTION_END(_arch_cpu_user_memset)
+
+/* ssize_t arch_cpu_user_strlcpy(void *to, const void *from, size_t size, addr_t *faultHandler) */
+FUNCTION(_arch_cpu_user_strlcpy):
+	mov		x0, xzr
+	ret
+FUNCTION_END(_arch_cpu_user_strlcpy)
+
+/*!	\fn void arch_debug_call_with_fault_handler(cpu_ent* cpu,
+		jmp_buf jumpBuffer, void (*function)(void*), void* parameter)
+
+	Called by debug_call_with_fault_handler() to do the dirty work of setting
+	the fault handler and calling the function. If the function causes a page
+	fault, the arch_debug_call_with_fault_handler() calls longjmp() with the
+	given \a jumpBuffer. Otherwise it returns normally.
+
+	debug_call_with_fault_handler() has already saved the CPU's fault_handler
+	and fault_handler_stack_pointer and will reset them later, so
+	arch_debug_call_with_fault_handler() doesn't need to care about it.
+
+	\param cpu The \c cpu_ent for the current CPU.
+	\param jumpBuffer Buffer to be used for longjmp().
+	\param function The function to be called.
+	\param parameter The parameter to be passed to the function to be called.
+*/
+FUNCTION(arch_debug_call_with_fault_handler):
+	mov		x0, xzr
+	ret
+FUNCTION_END(arch_debug_call_with_fault_handler)

src/system/kernel/arch/arm64/arch_commpage.cpp

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2019 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#include <commpage.h>
+
+#include <string.h>
+
+#include <KernelExport.h>
+
+#include <cpu.h>
+#include <elf.h>
+#include <smp.h>
+
+
+status_t
+arch_commpage_init(void)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_commpage_init_post_cpus(void)
+{
+	return B_OK;
+}

src/system/kernel/arch/arm64/arch_cpu.cpp

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2019 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+
+#include <KernelExport.h>
+
+#include <arch/cpu.h>
+#include <boot/kernel_args.h>
+#include <commpage.h>
+#include <elf.h>
+
+
+status_t
+arch_cpu_preboot_init_percpu(kernel_args *args, int curr_cpu)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_cpu_init_percpu(kernel_args *args, int curr_cpu)
+{
+	return 0;
+}
+
+
+status_t
+arch_cpu_init(kernel_args *args)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_cpu_init_post_vm(kernel_args *args)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_cpu_init_post_modules(kernel_args *args)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_cpu_shutdown(bool reboot)
+{
+	// never reached
+	return B_ERROR;
+}
+
+
+void
+arch_cpu_sync_icache(void *address, size_t len)
+{
+}
+
+
+void
+arch_cpu_memory_read_barrier(void)
+{
+}
+
+
+void
+arch_cpu_memory_write_barrier(void)
+{
+}
+
+
+void
+arch_cpu_invalidate_TLB_range(addr_t start, addr_t end)
+{
+}
+
+
+void
+arch_cpu_invalidate_TLB_list(addr_t pages[], int num_pages)
+{
+}
+
+
+void
+arch_cpu_global_TLB_invalidate(void)
+{
+}
+
+
+void
+arch_cpu_user_TLB_invalidate(void)
+{
+}

src/system/kernel/arch/arm64/arch_debug.cpp

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2019 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#include <arch/debug.h>
+
+#include <arch_cpu.h>
+#include <debug.h>
+#include <debug_heap.h>
+#include <elf.h>
+#include <kernel.h>
+#include <kimage.h>
+#include <thread.h>
+#include <vm/vm_types.h>
+#include <vm/VMAddressSpace.h>
+#include <vm/VMArea.h>
+
+
+void
+arch_debug_save_registers(struct arch_debug_registers* registers)
+{
+}
+
+
+bool
+arch_debug_contains_call(Thread *thread, const char *symbol,
+	addr_t start, addr_t end)
+{
+	return false;
+}
+
+
+void
+arch_debug_stack_trace(void)
+{
+}
+
+
+void *
+arch_debug_get_caller(void)
+{
+	return NULL;
+}
+
+
+int32
+arch_debug_get_stack_trace(addr_t* returnAddresses, int32 maxCount,
+	int32 skipIframes, int32 skipFrames, uint32 flags)
+{
+	return 0;
+}
+
+
+void*
+arch_debug_get_interrupt_pc(bool* _isSyscall)
+{
+	return NULL;
+}
+
+
+bool
+arch_is_debug_variable_defined(const char* variableName)
+{
+	return false;
+}
+
+
+status_t
+arch_set_debug_variable(const char* variableName, uint64 value)
+{
+	return B_ENTRY_NOT_FOUND;
+}
+
+
+status_t
+arch_get_debug_variable(const char* variableName, uint64* value)
+{
+	return B_ENTRY_NOT_FOUND;
+}
+
+
+status_t
+arch_debug_init(kernel_args *args)
+{
+	return B_NO_ERROR;
+}
+
+
+void
+arch_debug_unset_current_thread(void)
+{
+}
+
+
+ssize_t
+arch_debug_gdb_get_registers(char* buffer, size_t bufferSize)
+{
+	return B_NOT_SUPPORTED;
+}

src/system/kernel/arch/arm64/arch_debug_console.cpp

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2019 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#include <arch/debug_console.h>
+#include <arch/generic/debug_uart.h>
+#include <boot/kernel_args.h>
+#include <kernel.h>
+#include <vm/vm.h>
+#include <string.h>
+
+
+void
+arch_debug_remove_interrupt_handler(uint32 line)
+{
+}
+
+
+void
+arch_debug_install_interrupt_handlers(void)
+{
+}
+
+
+int
+arch_debug_blue_screen_try_getchar(void)
+{
+	return -1;
+}
+
+
+char
+arch_debug_blue_screen_getchar(void)
+{
+	return -1;
+}
+
+
+int
+arch_debug_serial_try_getchar(void)
+{
+	return -1;
+}
+
+
+char
+arch_debug_serial_getchar(void)
+{
+	return -1;
+}
+
+
+void
+arch_debug_serial_putchar(const char c)
+{
+}
+
+
+void
+arch_debug_serial_puts(const char *s)
+{
+}
+
+
+void
+arch_debug_serial_early_boot_message(const char *string)
+{
+}
+
+
+status_t
+arch_debug_console_init(kernel_args *args)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_debug_console_init_settings(kernel_args *args)
+{
+	return B_OK;
+}

src/system/kernel/arch/arm64/arch_elf.cpp

@@ -1,7 +1,6 @@
 /*
- * Copyright 2004-2018, Haiku Inc. All Rights Reserved.
- * Distributed under the terms of the MIT license.
- *
+ * Copyright 2004-2018 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
  * Copyright 2002, Travis Geiselbrecht. All rights reserved.
  * Distributed under the terms of the NewOS License.
  */

src/system/kernel/arch/arm64/arch_int.cpp

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2019 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#include <int.h>
+
+#include <arch/smp.h>
+#include <boot/kernel_args.h>
+#include <device_manager.h>
+#include <kscheduler.h>
+#include <interrupt_controller.h>
+#include <smp.h>
+#include <thread.h>
+#include <timer.h>
+#include <util/DoublyLinkedList.h>
+#include <util/kernel_cpp.h>
+#include <vm/vm.h>
+#include <vm/vm_priv.h>
+#include <vm/VMAddressSpace.h>
+#include <string.h>
+
+#define TRACE_ARCH_INT
+#ifdef TRACE_ARCH_INT
+#	define TRACE(x) dprintf x
+#else
+#	define TRACE(x) ;
+#endif
+
+
+void
+arch_int_enable_io_interrupt(int irq)
+{
+}
+
+
+void
+arch_int_disable_io_interrupt(int irq)
+{
+}
+
+
+void
+arch_int_assign_to_cpu(int32 irq, int32 cpu)
+{
+	// intentionally left blank; no SMP support (yet)
+}
+
+
+status_t
+arch_int_init(kernel_args *args)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_int_init_post_vm(kernel_args *args)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_int_init_io(kernel_args* args)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_int_init_post_device_manager(struct kernel_args *args)
+{
+	return B_ENTRY_NOT_FOUND;
+}

src/system/kernel/arch/arm64/arch_platform.cpp

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2019 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#include <KernelExport.h>
+#include <arch/platform.h>
+#include <boot/kernel_args.h>
+
+
+status_t
+arch_platform_init(struct kernel_args *kernelArgs)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_platform_init_post_vm(struct kernel_args *kernelArgs)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_platform_init_post_thread(struct kernel_args *kernelArgs)
+{
+	return B_OK;
+}

src/system/kernel/arch/arm64/arch_real_time_clock.cpp

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2019 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#include <arch/real_time_clock.h>
+
+#include <real_time_clock.h>
+#include <real_time_data.h>
+#include <smp.h>
+
+
+status_t
+arch_rtc_init(kernel_args *args, struct real_time_data *data)
+{
+	return B_OK;
+}
+
+
+uint32
+arch_rtc_get_hw_time(void)
+{
+	return 0;
+}
+
+
+void
+arch_rtc_set_hw_time(uint32 seconds)
+{
+}
+
+
+void
+arch_rtc_set_system_time_offset(struct real_time_data *data, bigtime_t offset)
+{
+}
+
+
+bigtime_t
+arch_rtc_get_system_time_offset(struct real_time_data *data)
+{
+	return 0;
+}

src/system/kernel/arch/arm64/arch_smp.cpp

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2019 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#include <KernelExport.h>
+
+#include <boot/stage2.h>
+#include <arch/smp.h>
+#include <debug.h>
+#include <int.h>
+
+
+status_t
+arch_smp_init(kernel_args *args)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_smp_per_cpu_init(kernel_args *args, int32 cpu)
+{
+	return B_OK;
+}
+
+
+void
+arch_smp_send_multicast_ici(CPUSet& cpuSet)
+{
+}
+
+
+void
+arch_smp_send_ici(int32 target_cpu)
+{
+}
+
+
+void
+arch_smp_send_broadcast_ici()
+{
+}

src/system/kernel/arch/arm64/arch_system_info.cpp

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2019 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#include <OS.h>
+
+#include <arch_cpu.h>
+#include <arch/system_info.h>
+#include <boot/kernel_args.h>
+
+
+status_t
+arch_get_system_info(system_info *info, size_t size)
+{
+	return B_OK;
+}
+
+
+void
+arch_fill_topology_node(cpu_topology_node_info* node, int32 cpu)
+{
+}
+
+
+status_t
+arch_system_info_init(struct kernel_args *args)
+{
+	return B_OK;
+}

src/system/kernel/arch/arm64/arch_thread.cpp

@@ -0,0 +1,120 @@
+/*
+ * Copyright 2019 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#include <thread.h>
+#include <arch_thread.h>
+
+#include <arch_cpu.h>
+#include <arch/thread.h>
+#include <boot/stage2.h>
+#include <kernel.h>
+#include <thread.h>
+#include <tls.h>
+#include <vm/vm_types.h>
+#include <vm/VMAddressSpace.h>
+#include <arch_vm.h>
+#include <arch/vm_translation_map.h>
+
+#include <string.h>
+
+//#define TRACE_ARCH_THREAD
+#ifdef TRACE_ARCH_THREAD
+#	define TRACE(x) dprintf x
+#else
+#	define TRACE(x) ;
+#endif
+
+
+status_t
+arch_thread_init(struct kernel_args *args)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_team_init_team_struct(Team *team, bool kernel)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_thread_init_thread_struct(Thread *thread)
+{
+	return B_OK;
+}
+
+
+void
+arch_thread_init_kthread_stack(Thread* thread, void* _stack, void* _stackTop,
+	void (*function)(void*), const void* data)
+{
+}
+
+
+status_t
+arch_thread_init_tls(Thread *thread)
+{
+	return 0;
+}
+
+
+void
+arch_thread_context_switch(Thread *from, Thread *to)
+{
+}
+
+void
+arch_thread_dump_info(void *info)
+{
+}
+
+
+status_t
+arch_thread_enter_userspace(Thread *thread, addr_t entry,
+	void *arg1, void *arg2)
+{
+	return B_ERROR;
+}
+
+
+bool
+arch_on_signal_stack(Thread *thread)
+{
+	return false;
+}
+
+
+status_t
+arch_setup_signal_frame(Thread *thread, struct sigaction *sa,
+	struct signal_frame_data *signalFrameData)
+{
+	return B_ERROR;
+}
+
+
+int64
+arch_restore_signal_frame(struct signal_frame_data* signalFrameData)
+{
+	return 0;
+}
+
+
+void
+arch_check_syscall_restart(Thread *thread)
+{
+}
+
+
+void
+arch_store_fork_frame(struct arch_fork_arg *arg)
+{
+}
+
+
+void
+arch_restore_fork_frame(struct arch_fork_arg *arg)
+{
+}

src/system/kernel/arch/arm64/arch_timer.cpp

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2019 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#include <boot/stage2.h>
+#include <kernel.h>
+#include <debug.h>
+
+#include <timer.h>
+#include <arch/timer.h>
+#include <arch/cpu.h>
+
+
+void
+arch_timer_set_hardware_timer(bigtime_t timeout)
+{
+}
+
+
+void
+arch_timer_clear_hardware_timer()
+{
+}
+
+
+int
+arch_init_timer(kernel_args *args)
+{
+	return B_OK;
+}
+
+
+bigtime_t
+system_time(void)
+{
+	return 0;
+}

src/system/kernel/arch/arm64/arch_user_debugger.cpp

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2019 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#include <debugger.h>
+#include <int.h>
+#include <thread.h>
+#include <arch/user_debugger.h>
+
+
+void
+arch_clear_team_debug_info(struct arch_team_debug_info *info)
+{
+}
+
+
+void
+arch_destroy_team_debug_info(struct arch_team_debug_info *info)
+{
+}
+
+
+void
+arch_clear_thread_debug_info(struct arch_thread_debug_info *info)
+{
+}
+
+
+void
+arch_destroy_thread_debug_info(struct arch_thread_debug_info *info)
+{
+}
+
+
+void
+arch_update_thread_single_step()
+{
+}
+
+
+void
+arch_set_debug_cpu_state(const debug_cpu_state *cpuState)
+{
+}
+
+
+void
+arch_get_debug_cpu_state(debug_cpu_state *cpuState)
+{
+}
+
+
+status_t
+arch_get_thread_debug_cpu_state(Thread *thread, debug_cpu_state *cpuState)
+{
+	return B_ERROR;
+}
+
+
+status_t
+arch_set_breakpoint(void *address)
+{
+	return B_ERROR;
+}
+
+
+status_t
+arch_clear_breakpoint(void *address)
+{
+	return B_ERROR;
+}
+
+
+status_t
+arch_set_watchpoint(void *address, uint32 type, int32 length)
+{
+	return B_ERROR;
+}
+
+
+status_t
+arch_clear_watchpoint(void *address)
+{
+	return B_ERROR;
+}
+
+
+bool
+arch_has_breakpoints(struct arch_team_debug_info *info)
+{
+	return false;
+}

src/system/kernel/arch/arm64/arch_vm.cpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2019 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#include <KernelExport.h>
+
+#include <kernel.h>
+#include <boot/kernel_args.h>
+
+#include <vm/vm.h>
+#include <vm/vm_types.h>
+#include <arch/vm.h>
+
+
+status_t
+arch_vm_init(kernel_args *args)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_vm_init2(kernel_args *args)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_vm_init_post_area(kernel_args *args)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_vm_init_end(kernel_args *args)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_vm_init_post_modules(kernel_args *args)
+{
+	return B_OK;
+}
+
+
+void
+arch_vm_aspace_swap(struct VMAddressSpace *from, struct VMAddressSpace *to)
+{
+}
+
+
+bool
+arch_vm_supports_protection(uint32 protection)
+{
+	return false;
+}
+
+
+void
+arch_vm_unset_memory_type(VMArea *area)
+{
+}
+
+
+status_t
+arch_vm_set_memory_type(VMArea *area, phys_addr_t physicalBase, uint32 type)
+{
+	return B_OK;
+}

src/system/kernel/arch/arm64/arch_vm_translation_map.cpp

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2019 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#include <arch/vm_translation_map.h>
+#include <boot/kernel_args.h>
+
+
+status_t
+arch_vm_translation_map_create_map(bool kernel, VMTranslationMap** _map)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_vm_translation_map_init(kernel_args *args,
+	VMPhysicalPageMapper** _physicalPageMapper)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_vm_translation_map_init_post_sem(kernel_args *args)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_vm_translation_map_init_post_area(kernel_args *args)
+{
+	return B_OK;
+}
+
+
+status_t
+arch_vm_translation_map_early_map(kernel_args *args, addr_t va, phys_addr_t pa,
+	uint8 attributes, phys_addr_t (*get_free_page)(kernel_args *))
+{
+	return B_OK;
+}
+
+
+bool
+arch_vm_translation_map_is_kernel_page_accessible(addr_t virtualAddress,
+	uint32 protection)
+{
+	return false;
+}

src/system/kernel/lib/arch/arm64/Jamfile

@@ -20,8 +20,14 @@ SEARCH_SOURCE += [ FDirName $(posixSources) string arch generic ] ;
 SEARCH_SOURCE += [ FDirName $(posixSources) string arch $(TARGET_ARCH) ] ;
 
 KernelMergeObject kernel_lib_posix_arch_$(TARGET_ARCH).o :
+	siglongjmp.S
+	sigsetjmp.S
+	kernel_longjmp_return.c
+	kernel_setjmp_save_sigs.c
+	
 	arch_string.S
 	memset.c
+	memcpy.c
 
 	: $(TARGET_KERNEL_PIC_CCFLAGS)
 ;

src/system/libroot/os/arch/arm64/Jamfile

@@ -15,6 +15,7 @@ for architectureObject in [ MultiArchSubDirSetup arm64 ] {
 		MergeObject <$(architecture)>os_arch_$(TARGET_ARCH).o :
 			tls.c
 			thread.c
+			system_time.c
 
 			generic_atomic.cpp
 			generic_stack_trace.cpp

src/system/libroot/os/arch/arm64/system_time.c

@@ -0,0 +1,16 @@
+/*
+ * Copyright 2019 Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#include <OS.h>
+
+#include <arch_cpu.h>
+#include <libroot_private.h>
+#include <real_time_data.h>
+
+
+bigtime_t
+system_time(void)
+{
+	return 0;
+}