; SPDX-License-Identifier: GPL-2.0-or-later ; ; UMKa - User-Mode KolibriOS developer tools ; ; Copyright (C) 2017-2023 Ivan Baravy ; Copyright (C) 2021 Magomed Kostoev if HOST eq windows format MS COFF else if HOST eq linux format ELF else error "Your HOST is not supported" end if ; win32: ; pubsym name -> public name as "_name" ; pubsym name, 20 -> public name as "_name@20" ; pubsym name, no_mangle -> public name ; pubsym name, "name" -> public name as "_name" ; pubsym name, "name", 20 -> public name as "_name@20" ; pubsym name, "name", no_mangle -> public name as "name" ; linux: ; pubsym name -> public name ; pubsym name, 20 -> public name ; pubsym name, no_mangle -> public name ; pubsym name, "name" -> public name as "name" ; pubsym name, "name", 20 -> public name as "name" ; pubsym name, "name", no_mangle -> public name as "name" macro pubsym name, marg1, marg2 { if HOST eq windows if marg1 eq no_mangle public name else if marg1 eqtype 20 public name as '_' # `name # '@' # `marg1 else if marg1 eqtype 'string' if marg2 eq no_mangle public name as marg1 else if marg2 eqtype 20 public name as '_' # marg1 # '@' # `marg2 else public name as '_' # marg1 end if else public name as '_' # `name end if else if HOST eq linux if marg1 eqtype 'string' public name as marg1 else public name end if else error "Your HOST is not supported" end if } ; win32: ; extrn name -> extrn _name ; extrn name, 20 -> extrn _name@20 ; linux: ; extrn name -> extrn name ; extrn name, 20 -> extrn name macro extrn name, argsize, asname { if HOST eq windows if argsize eqtype 0 & argsize > 0 if asname eqtype 'string' extrn '_' # `name # '@' # `argsize as asname else extrn '_' # `name # '@' # `argsize as name end if else if asname eqtype extrn '_' # `name as name else extrn '_' # `name as asname end if end if else if HOST eq linux if asname eqtype extrn name else extrn name as asname end if else error "Your HOST is not supported" end if } __DEBUG__ = 1 __DEBUG_LEVEL__ = 1 UMKA_SHELL = 1 UMKA_FUSE = 2 UMKA_OS = 3 UMKA_MEMORY_BYTES = 256 SHL 20 UMKA_BOOT_DEFAULT_DISPLAY_BPP = 32 UMKA_BOOT_DEFAULT_DISPLAY_WIDTH = 400 UMKA_BOOT_DEFAULT_DISPLAY_HEIGHT = 300 public idle_reached pubsym irq_serv.irq_10, 'kos_irq_serv_irq10' pubsym idts, 'kos_idts' pubsym attach_int_handler, 'kos_attach_int_handler', 12 pubsym fs_execute, 'kos_fs_execute', 4 pubsym set_keyboard_data, 'kos_set_keyboard_data', no_mangle pubsym KEY_COUNT, 'kos_key_count' pubsym KEY_BUFF, 'kos_key_buff' pubsym keyboard_mode, 'kos_keyboard_mode' pubsym sys_getkey, 'kos_get_key' pubsym syslang, 'kos_syslang' pubsym keyboard, 'kos_keyboard' pubsym disk_add, 16 pubsym disk_del, 4 pubsym disk_list pubsym disk_media_changed, 8 pubsym xfs._.user_functions, 'xfs_user_functions' pubsym ext_user_functions pubsym fat_user_functions pubsym exFAT_user_functions, 'exfat_user_functions' pubsym ntfs_user_functions pubsym i40, no_mangle pubsym coverage_begin pubsym coverage_end pubsym sha3_256_oneshot, 'hash_oneshot' pubsym kos_time_to_epoch pubsym umka_init, 4 pubsym umka_close, 4 pubsym umka_boot pubsym current_process, 'kos_current_process' pubsym current_slot, 'kos_current_slot' pubsym current_slot_idx, 'kos_current_slot_idx' pubsym thread_count, 'kos_thread_count' pubsym SLOT_BASE, 'kos_slot_base' pubsym window_data, 'kos_window_data' pubsym WIN_STACK, 'kos_win_stack' pubsym WIN_POS, 'kos_win_pos' pubsym lfb_base, 'kos_lfb_base' pubsym RAMDISK, 'kos_ramdisk' pubsym ramdisk_init, 'kos_ramdisk_init' pubsym enable_acpi, no_mangle pubsym acpi.call_name, no_mangle pubsym acpi_ssdt_cnt, 'kos_acpi_ssdt_cnt' pubsym acpi_ssdt_base, 'kos_acpi_ssdt_base' pubsym acpi_ssdt_size, 'kos_acpi_ssdt_size' pubsym acpi_ctx pubsym acpi_usage, 'kos_acpi_usage' pubsym acpi_node_alloc_cnt, 'kos_acpi_node_alloc_cnt' pubsym acpi_node_free_cnt, 'kos_acpi_node_free_cnt' pubsym acpi.count_nodes, 'kos_acpi_count_nodes', 4 pubsym stack_init, 'kos_stack_init', no_mangle pubsym net_add_device, no_mangle pubsym draw_data pubsym img_background pubsym mem_BACKGROUND pubsym sys_background pubsym REDRAW_BACKGROUND, 'kos_redraw_background' pubsym new_sys_threads, '_kos_new_sys_threads', no_mangle pubsym osloop, 'kos_osloop', no_mangle pubsym set_mouse_data, 'kos_set_mouse_data', 20 pubsym scheduler_current, 'kos_scheduler_current' pubsym kos_eth_input pubsym net_buff_alloc, 'kos_net_buff_alloc', 4 pubsym mem_block_list pubsym pci_root, "kos_pci_root" pubsym acpi.aml.init, "kos_acpi_aml_init" pubsym acpi_root, "kos_acpi_root" pubsym aml._.attach, "kos_aml_attach" pubsym acpi.fill_pci_irqs, "kos_acpi_fill_pci_irqs" pubsym pci.walk_tree, "kos_pci_walk_tree", 16 pubsym acpi.aml.new_thread, "kos_acpi_aml_new_thread" pubsym aml._.alloc_node, "kos_aml_alloc_node" pubsym aml._.constructor.integer, "kos_aml_constructor_integer" pubsym aml._.constructor.package, "kos_aml_constructor_package" pubsym acpi._.lookup_node, "kos_acpi_lookup_node" pubsym acpi._.print_tree, "kos_acpi_print_tree" pubsym acpi_dev_data, "kos_acpi_dev_data" pubsym acpi_dev_size, "kos_acpi_dev_size" pubsym acpi_dev_next, "kos_acpi_dev_next" pubsym kernel_alloc, "kos_kernel_alloc" pubsym create_event, "_kos_create_event" pubsym destroy_event, "_kos_destroy_event" pubsym wait_event, "_kos_wait_event" pubsym Wait_events, "_kos_wait_events" pubsym window._.set_screen, 'kos_window_set_screen' pubsym _display, 'kos_display' pubsym msg_board_data, "kos_msg_board_data" pubsym msg_board_count, "kos_msg_board_count" pubsym BOOT, 'kos_boot' EFLAGS.ID = 1 SHL 21 macro lidt x { } macro invlpg addr { } macro cli { pushfd bts dword[esp], BSF EFLAGS.ID popfd } macro sti { pushfd btr dword[esp], BSF EFLAGS.ID popfd } iretd equ retd iret equ ret lang fix en macro int n { if n eq 0x40 call i40 else int n end if } section '.app' executable writable align 64 rb 64*1024 section '.text' executable align 64 coverage_begin: include 'macros.inc' macro diff16 msg,blah2,blah3 { if msg eq "end of .data segment" ; fasm doesn't align on 1MiB, but ld script does section '.bss.1M' writeable align 0x1000 bss_base: end if } include 'proc32.inc' include 'struct.inc' macro BOOT_LO a {} macro BOOT a {} window_data equ __pew01 CDDataBuf equ __pew06 idts equ __pew07 WIN_STACK equ __pew08 WIN_POS equ __pew09 FDD_BUFF equ __pew10 WIN_TEMP_XY equ __pew11 KEY_COUNT equ __pew12 KEY_BUFF equ __pew13 BTN_COUNT equ __pew14 BTN_BUFF equ __pew15 BTN_ADDR equ __pew16 MEM_AMOUNT equ __pew17 SYS_SHUTDOWN equ __pew18 SLOT_BASE equ __pew20 sys_proc equ __pew21 VGABasePtr equ __pew22 HEAP_BASE equ __pew23 page_tabs equ page_tabs_pew ;macro OS_BASE [x] { ; OS_BASE equ os_base ;} struct idt_entry addr_lo dw ? seg dw ? flags dw ? addr_hi dw ? ends NUM_EXCEPTIONS = 32 macro tss pew {} include 'const.inc' purge tss restore window_data restore CDDataBuf,idts,WIN_STACK,WIN_POS restore FDD_BUFF,WIN_TEMP_XY,KEY_COUNT,KEY_BUFF,BTN_COUNT,BTN_BUFF,BTN_ADDR restore MEM_AMOUNT,SYS_SHUTDOWN,SLOT_BASE,sys_proc,VGABasePtr restore HEAP_BASE restore page_tabs purge BOOT_LO,BOOT LFB_BASE = lfb_base macro save_ring3_context { pushad } macro restore_ring3_context { popad } macro stdcall target, [args] { common if target eq is_region_userspace cmp esp, esp ; ZF else if target eq is_string_userspace cmp esp, esp ; ZF else stdcall target, args end if } include 'system.inc' include 'fdo.inc' OS_BASE equ 0 ;OS_BASE equ os_base macro mov target, source { if source eq (HEAP_BASE - OS_BASE + HEAP_MIN_SIZE)/PAGE_SIZE push eax eax mov eax, HEAP_BASE add eax, HEAP_MIN_SIZE shr eax, 12 mov [esp+4], eax pop eax pop target else if target eq dword [sys_proc-OS_BASE+PROC.pdt_0+(page_tabs shr 20)] push eax ecx mov eax, page_tabs shr eax, 20 add eax, PROC.pdt_0 add eax, sys_proc mov ecx, sys_proc+PROC.pdt_0+PG_SWR mov [eax], ecx pop ecx eax else if target eq [(pci_code_32 - OS_BASE)] else if target eq [(pci_data_32 - OS_BASE)] else if target eq [(pci_code_32 - OS_BASE)+2] else if target eq [(pci_data_32 - OS_BASE)+2] else if target eq [(pci_code_32 - OS_BASE)+4] else if target eq [(pci_data_32 - OS_BASE)+4] else if target eq [(pci_code_32 - OS_BASE)+6] else if target eq [(pci_data_32 - OS_BASE)+6] else if target eq [(pci_bios_entry - OS_BASE)] else if source eq (OS_BASE/PAGE_SIZE) push ecx mov ecx, OS_BASE shr ecx, 12 mov target, ecx pop ecx else if target eq dword [sys_proc-OS_BASE+PROC.pdt_0+(page_tabs shr 20)] else if source eq (sys_proc - OS_BASE + PROC.pdt_0) + (OS_BASE shr 20) push ecx mov ecx, OS_BASE shr ecx, 20 add ecx, sys_proc add ecx, PROC.pdt_0 sub ecx, OS_BASE mov target, ecx pop ecx else mov target, source end if } macro cmp target, source { if source eq (HEAP_BASE - OS_BASE + HEAP_MIN_SIZE)/PAGE_SIZE push eax eax mov eax, HEAP_BASE add eax, HEAP_MIN_SIZE shr eax, 12 mov [esp], eax mov eax, [esp+4] cmp target, [esp] pop eax eax else if source eq (OS_BASE/PAGE_SIZE) push ecx mov ecx, OS_BASE shr ecx, 12 cmp target, ecx pop ecx else cmp target, source end if } macro lea target, source { if source eq [edi + (OS_BASE shr 20)] push ecx mov ecx, OS_BASE shr ecx, 20 add ecx, edi mov target, ecx pop ecx else lea target, source end if } include 'init.inc' purge mov purge cmp purge lea restore OS_BASE include 'core/sync.inc' macro call target { if target eq do_change_task call _do_change_task else if target eq page_fault_handler call _page_fault_handler else call target end if } include 'core/sys32.inc' do_change_task equ hjk irq0 equ irq0_pew tss._io_map_0 equ 0 tss._io_map_1 equ 0 include 'core/sched.inc' restore tss._io_map_0 restore tss._io_map_1 ;purge mov restore irq0 include 'core/syscall.inc' ;include 'core/fpu.inc' map_io_mem equ map_io_mem_pew create_trampoline_pgmap equ create_trampoline_pgmap_pew alloc_page equ alloc_page_pew alloc_pages equ alloc_pages_pew free_page equ free_page_pew include 'core/memory.inc' restore map_io_mem, free_page, create_trampoline_pgmap, alloc_page, alloc_pages ;include 'core/mtrr.inc' ;user_alloc_at equ user_alloc_at_pew include 'core/heap.inc' ;restore user_alloc_at include 'core/malloc.inc' macro mov target, source { if target eq [edi - 4096 + (page_tabs shr 20)] push eax ebx mov ebx, eax mov eax, page_tabs shr eax, 20 sub eax, 4096 add eax, edi mov [eax], ebx pop ebx eax else mov target, source end if } include 'core/taskman.inc' purge mov include 'core/dll.inc' macro call target { if target eq pci_read_reg call _pci_read_reg else call target end if } include 'bus/pci/pci32.inc' purge call ;include 'core/peload.inc' ;include 'core/exports.inc' include 'core/string.inc' ;include 'core/v86.inc' macro mov dst, src { if dst eq ds else if dst eq es else mov dst, src end if } include 'core/irq.inc' purge mov purge call include 'core/apic.inc' include 'core/hpet.inc' include 'core/timers.inc' include 'core/clipboard.inc' include 'core/slab.inc' include 'posix/posix.inc' ;include 'boot/shutdown.inc' include 'video/vesa20.inc' include 'video/blitter.inc' include 'video/vga.inc' include 'video/cursors.inc' include 'video/framebuffer.inc' include 'gui/window.inc' include 'gui/event.inc' include 'gui/font.inc' include 'gui/button.inc' include 'gui/mouse.inc' include 'gui/skincode.inc' include 'gui/background.inc' include 'hid/keyboard.inc' include 'hid/mousedrv.inc' include 'hid/set_dtc.inc' ; setting date,time,clock and alarm-clock include 'sound/playnote.inc' ;include 'bus/pci/pci32.inc' ;include 'bus/usb/init.inc' ;include 'blkdev/flp_drv.inc' ; floppy driver ;include 'blkdev/fdc.inc' ;include 'blkdev/cd_drv.inc' ; CD driver ;include 'blkdev/ide_cache.inc' ; CD cache ;include 'blkdev/hd_drv.inc' ; HDD driver ;include 'blkdev/bd_drv.inc' ; BIOS disks driver include 'blkdev/rd.inc' ; ramdisk driver include 'blkdev/disk.inc' include 'blkdev/disk_cache.inc' include 'fs/fs_lfn.inc' include 'network/stack.inc' include 'crc.inc' include 'unicode.inc' include 'acpi/acpi.inc' include 'unpacker.inc' LIBCRASH_CTX_LEN = 0x500 ; FIXME include 'sha3.asm' ; TODO: stdcall attribute in umka.h proc sha3_256_oneshot c uses ebx esi edi ebp, _ctx, _data, _len stdcall sha3_256.oneshot, [_ctx], [_data], [_len] ret endp proc kos_time_to_epoch c uses ebx esi edi ebp, _time mov esi, [_time] call fsCalculateTime xor edx, edx add eax, UNIXTIME_TO_KOS_OFFSET adc edx, 0 ret endp proc umka._.check_alignment mov eax, HEAP_BASE and eax, PAGE_SIZE - 1 jz @f mov ecx, PAGE_SIZE sub ecx, eax DEBUGF 4, "HEAP_BASE must be aligned on PAGE_SIZE: 0x%x", HEAP_BASE DEBUGF 4, ", add 0x%x or sub 0x%x\n", ecx, eax mov eax, SLOT_BASE and eax, 0x10000 - 1 jz @f mov eax, os_base and eax, 0x100000 - 1 jz @f int3 @@: ret endp pubsym i40_asm ;void i40_asm(uint32_t _eax, ; uint32_t _ebx, ; uint32_t _ecx, ; uint32_t _edx, ; uint32_t _esi, ; uint32_t _edi, ; uint32_t _ebp, ; uint32_t *_eax_out, ; uint32_t _ebx_out) i40_asm: ; Return address: esp ; First argument: esp + 4 push eax ebx ecx edx esi edi ebp ; First argument: esp + 4 + 7 * sizeof(dword) = esp + 8 + 7 * 4 = esp + 4 + 28 = esp + 32 mov eax, [esp + 32] mov ebx, [esp + 36] mov ecx, [esp + 40] mov edx, [esp + 44] mov esi, [esp + 48] mov edi, [esp + 52] mov ebp, [esp + 56] call i40 mov edi, [esp + 60] mov [edi], eax mov edi, [esp + 64] mov [edi], ebx pop ebp edi esi edx ecx ebx eax ret pubsym set_eflags_tf proc set_eflags_tf c uses ebx esi edi ebp, tf mov ecx, [tf] pushfd pop eax ror eax, 8 mov edx, eax and edx, 1 and eax, 0xfffffffe or eax, ecx rol eax, 8 push eax popfd mov eax, edx ret endp proc kos_eth_input c uses ebx esi edi ebp, buffer_ptr push .retaddr push [buffer_ptr] jmp eth_input .retaddr: ret endp struct umka_ctx booted dd ? running dd ? ends proc umka_init c uses ebx esi edi ebp, _running call umka._.check_alignment ; init boot vars mov eax, BOOT mov [eax + boot_data.x_res], UMKA_BOOT_DEFAULT_DISPLAY_WIDTH mov [eax + boot_data.y_res], UMKA_BOOT_DEFAULT_DISPLAY_HEIGHT mov [eax + boot_data.bpp], UMKA_BOOT_DEFAULT_DISPLAY_BPP mov [eax + boot_data.pitch], UMKA_BOOT_DEFAULT_DISPLAY_BPP * \ UMKA_BOOT_DEFAULT_DISPLAY_WIDTH / 8 mov [eax + boot_data.memmap_block_cnt], 1 lea ecx, [eax + boot_data.memmap_blocks] mov [ecx + e820entry.addr.lo], mem_block mov [ecx + e820entry.addr.hi], 0 mov [ecx + e820entry.size.lo], 256*0x10000 mov [ecx + e820entry.size.hi], 0 mov [ecx + e820entry.type], 1 ; init umka context mov eax, umka mov [eax+umka_ctx.booted], 0 mov ecx, [_running] mov [eax+umka_ctx.running], ecx ret endp proc umka_close c, _ctx xor eax, eax ret endp proc umka_boot uses ebx esi edi ebp mov [umka.booted], 1 mov edi, endofcode mov ecx, uglobals_size xor eax, eax rep stosb call mem_test ; call init_mem ; call init_page_map mov [irq_mode], IRQ_APIC mov [IOAPIC_base], ioapic_data mov [LAPIC_BASE], lapic_data mov [ioapic_cnt], 1 mov [xsave_area_size], 0x1000 mov ecx, pg_data.mutex call mutex_init mov ecx, disk_list_mutex call mutex_init mov ecx, keyboard_list_mutex call mutex_init mov ecx, unpack_mutex call mutex_init mov ecx, application_table_mutex call mutex_init mov ecx, ide_mutex call mutex_init mov ecx, ide_channel1_mutex call mutex_init mov ecx, ide_channel2_mutex call mutex_init mov ecx, ide_channel3_mutex call mutex_init mov ecx, ide_channel4_mutex call mutex_init mov ecx, ide_channel5_mutex call mutex_init mov ecx, ide_channel6_mutex call mutex_init mov [pg_data.mem_amount], UMKA_MEMORY_BYTES mov [pg_data.pages_count], UMKA_MEMORY_BYTES / PAGE_SIZE mov [pg_data.pages_free], UMKA_MEMORY_BYTES / PAGE_SIZE mov eax, UMKA_MEMORY_BYTES SHR 12 mov [pg_data.kernel_pages], eax shr eax, 10 mov [pg_data.kernel_tables], eax call build_interrupt_table call init_kernel_heap call init_malloc mov eax, sys_proc list_init eax add eax, PROC.thr_list list_init eax mov [BOOT.lfb], LFB_BASE call init_video stdcall alloc_kernel_space, 0x50000 ; FIXME check size mov [default_io_map], eax add eax, 0x2000 mov [ipc_tmp], eax mov ebx, 0x1000 add eax, 0x40000 mov [proc_mem_map], eax add eax, 0x8000 mov [proc_mem_pdir], eax add eax, ebx mov [proc_mem_tab], eax add eax, ebx mov [tmp_task_ptab], eax add eax, ebx mov [ipc_pdir], eax add eax, ebx mov [ipc_ptab], eax stdcall kernel_alloc, (unpack.LZMA_BASE_SIZE+(unpack.LZMA_LIT_SIZE shl \ (unpack.lc+unpack.lp)))*4 mov [unpack.p], eax call init_events mov eax, srv.fd-SRV.fd mov [srv.fd], eax mov [srv.bk], eax stdcall kernel_alloc, [_display.win_map_size] mov [_display.win_map], eax ; set background movi eax, 1 mov [BgrDrawMode], eax mov [BgrDataWidth], eax mov [BgrDataHeight], eax mov [mem_BACKGROUND], 4 mov [img_background], static_background_data ; set clipboard xor eax, eax mov [clipboard_slots], eax mov [clipboard_write_lock], eax stdcall kernel_alloc, 4096 test eax, eax jnz @f dec eax @@: mov [clipboard_main_list], eax mov dword[sysdir_name], 'sys' mov dword[sysdir_path], 'RD/1' mov word[sysdir_path+4], 0 ;call ramdisk_init mov [X_UNDER], 500 mov [Y_UNDER], 500 mov eax, -1 mov edi, thr_slot_map+4 mov [edi-4], dword 0xFFFFFFF8 stosd stosd stosd stosd stosd stosd stosd mov [current_process], sys_proc mov [current_slot_idx], 0 mov [thread_count], 0 mov eax, [xsave_area_size] add eax, RING0_STACK_SIZE stdcall kernel_alloc, eax mov ebx, eax mov edx, SLOT_BASE+256*1 call setup_os_slot mov dword[edx], 'IDLE' sub [edx+APPDATA.saved_esp], 4 mov eax, [edx+APPDATA.saved_esp] mov dword[eax], idle mov ecx, IDLE_PRIORITY call scheduler_add_thread mov eax, [xsave_area_size] add eax, RING0_STACK_SIZE stdcall kernel_alloc, eax mov ebx, eax mov edx, SLOT_BASE+sizeof.APPDATA*2 call setup_os_slot mov dword[edx], 'OS' sub [edx+APPDATA.saved_esp], 4 mov eax, [edx+APPDATA.saved_esp] mov dword[eax], 0 movi ecx, MAX_PRIORITY call scheduler_add_thread mov [current_slot_idx], 2 mov [thread_count], 2 mov [current_slot], SLOT_BASE+2*sizeof.APPDATA mov [SLOT_BASE + 2*sizeof.APPDATA + APPDATA.tid], 2 call set_window_defaults call init_background call calculatebackground call init_display mov eax, [def_cursor] mov [SLOT_BASE+APPDATA.cursor+sizeof.APPDATA], eax mov [SLOT_BASE+APPDATA.cursor+sizeof.APPDATA*2], eax ; from set_variables mov ax, [BOOT.y_res] shr ax, 1 shl eax, 16 mov ax, [BOOT.x_res] shr ax, 1 mov [MOUSE_X], eax call wakeup_osloop xor eax, eax mov [BTN_ADDR], dword BUTTON_INFO ; address of button list mov byte [KEY_COUNT], al ; keyboard buffer mov byte [BTN_COUNT], al ; button buffer mov ebx, SLOT_BASE + 2*sizeof.APPDATA mov word[cur_dir.path], '/' mov [ebx+APPDATA.cur_dir], cur_dir ; end of set_variables call init_irqs ret endp pubsym skin_udata proc idle uses ebx esi edi extrn "pause", 0, libc_pause sti @@: mov [idle_reached], 1 sfence call libc_pause jmp @b ret endp extrn pci_read, 20 proc _pci_read_reg uses ebx esi edi mov ecx, eax and ecx, 3 movi edx, 1 shl edx, cl push edx ; len movzx edx, bl push edx ; offset movzx edx, bh and edx, 7 push edx ; fun movzx edx, bh shr edx, 3 push edx ; dev movzx edx, ah push edx ; bus call pci_read ret endp proc _page_fault_handler ret endp proc delay_ms ret endp pubsym umka_cli proc umka_cli cli ; macro ret endp pubsym umka_sti proc umka_sti sti ; macro ret endp extrn reset_procmask extrn get_fake_if pubsym irq0 proc irq0 c, _signo, _info, _context DEBUGF 1, "### irq0\n" pushfd cli pushad inc [timer_ticks] call updatecputimes ccall reset_procmask ; kind of irq_eoi:ta ccall get_fake_if, [_context] test eax, eax jnz @f DEBUGF 1, "### cli\n" jmp .done @@: mov bl, SCHEDULE_ANY_PRIORITY call find_next_task jz .done ; if there is only one running process call _do_change_task .done: popad popfd ret endp proc _do_change_task mov eax, [current_slot] sub eax, SLOT_BASE shr eax, 8 mov ecx, ebx sub ecx, SLOT_BASE shr ecx, 8 DEBUGF 1, "### switching task from %d to %d\n",eax,ecx mov esi, ebx xchg esi, [current_slot] ; set new stack after saving old mov [esi+APPDATA.saved_esp], esp mov esp, [ebx+APPDATA.saved_esp] ret endp proc map_io_mem _base, _size, _flags mov eax, [_base] ret endp ;proc user_alloc_at stdcall, address:dword, alloc_size:dword ; xor eax, eax ; ret ;endp extrn system_shutdown sysfn_saveramdisk: ;sysfn_meminfo: check_fdd_motor_status: check_ATAPI_device_event: check_fdd_motor_status_has_work?: check_ATAPI_device_event_has_work?: LoadMedium: clear_CD_cache: allow_medium_removal: EjectMedium: save_image: init_sys_v86: ;load_pe_driver: usb_init: fdc_init: mtrr_validate: v86_exc_c: except_7: ReadCDWRetr: WaitUnitReady: prevent_medium_removal: Read_TOC: free_page: init_fpu: init_mtrr: create_trampoline_pgmap: alloc_page: ;sys_IPC: ;f68: v86_irq: ;test_cpu: ;acpi_locate: ;init_BIOS32: ;mem_test: ;init_mem: ;init_page_map: ahci_init: enable_acpi: acpi.call_name: acpi.count_nodes: acpi.aml.init: aml._.attach: acpi.fill_pci_irqs: pci.walk_tree: acpi.aml.new_thread: aml._.alloc_node: aml._.constructor.integer: aml._.constructor.package: acpi._.lookup_node: acpi._.print_tree: ret load_PE: alloc_pages: ret 4 ;create_ring_buffer: ret 8 ;map_page: ret 12 ;map_memEx: ret 20 uglobal acpi_ctx dd ? acpi_usage dd ? acpi_node_alloc_cnt dd ? acpi_node_free_cnt dd ? pci_root dd ? acpi_root dd ? acpi_dev_next dd ? endg delay_ms equ __pex1 include fix pew macro pew x {} macro pew x {inclu#de `x} macro org x {} macro format [x] {} UMKA_RUNNIGS_NEVER = 0 UMKA_RUNNIGS_NOT_YET = 1 UMKA_RUNNIGS_YES = 2 bios32_entry equ bios32_entry_pew tmp_page_tabs equ tmp_page_tabs_pew macro jmp target { if target eq osloop cmp [umka.running], UMKA_RUNNIGS_YES jz osloop ret else jmp target end if } include 'kernel.asm' purge jmp restore bios32_entry, tmp_page_tabs purge org,delay_ms restore org,delay_ms coverage_end: ; cov for coverage; otherwide fasm complains with 'name too long' for MS COFF section '.bss.cov' executable writable align 64 struct coverage_branch to_cnt DQ ? from_cnt DQ ? ends COVERAGE_TABLE_SIZE = 512*1024 ; 512k should be enough for the kernel coverage_table rb COVERAGE_TABLE_SIZE * sizeof.coverage_branch pubsym coverage_table ; bt for boot; otherwide fasm complains with 'name too long' for MS COFF section '.data.bt' writeable align 0x1000 BOOT boot_data virtual at BOOT BOOT_LO boot_data end virtual ; fasm doesn't align on 65536, but ld script does ; 64 for align on 64k; otherwide fasm complains with 'name too long' for MS COFF section '.data.64' writeable align 0x1000 umka umka_ctx fpu_owner dd ? idle_reached dd ? ; mem for memory; otherwide fasm complains with 'name too long' for MS COFF section '.bss.mem' writeable align 0x1000 mem_block rb 256*0x10000 uglobal align 64 rb 0x100000 - (($-bss_base) AND (0x100000-1)) ; align on 1MiB os_base: rb PAGE_SIZE window_data: rb sizeof.WDATA * 256 CDDataBuf: rb 0x1000 idts rb (NUM_EXCEPTIONS + IRQ_RESERVED) * sizeof.idt_entry WIN_STACK rw 0x200 ; why not 0x100? WIN_POS rw 0x200 FDD_BUFF: rb 0x400 WIN_TEMP_XY rb 0x100 KEY_COUNT db ? KEY_BUFF rb 244 ; 120*2 + 2*2 = 244 bytes, actually 255 bytes BTN_COUNT db ? BTN_BUFF rd 0x261 BTN_ADDR dd ? MEM_AMOUNT rd 0x1d SYS_SHUTDOWN db ? sys_proc: rb sizeof.PROC * 256 rb 0x10000 - (($-bss_base) AND (0x10000-1)) ; align on 0x10000 SLOT_BASE: rb sizeof.APPDATA * 256 VGABasePtr rb 640*480 rb PAGE_SIZE - (($-bss_base) AND (PAGE_SIZE-1)) ; align on page HEAP_BASE rb UMKA_MEMORY_BYTES - (HEAP_BASE - os_base + \ PAGE_SIZE * sizeof.MEM_BLOCK) endg uglobal align 4 bios32_entry dd ? tmp_page_tabs dd ? page_tabs: rb 256*1024*1024 v86_irqhooks rd IRQ_RESERVED*2 cache_ide0 IDE_CACHE cache_ide1 IDE_CACHE DiskNumber db ? ChannelNumber db ? DevErrorCode dd ? CDSectorAddress dd ? CDDataBuf_pointer dd ? allow_dma_access db ? ide_mutex MUTEX ide_channel1_mutex MUTEX ide_channel2_mutex MUTEX ide_channel3_mutex MUTEX ide_channel4_mutex MUTEX ide_channel5_mutex MUTEX ide_channel6_mutex MUTEX ide_channel7_mutex MUTEX ide_channel8_mutex MUTEX ioapic_data rb 0x400 lapic_data rb 0x400 tss TSS lfb_base rd MAX_SCREEN_WIDTH*MAX_SCREEN_HEIGHT align 4096 cur_dir: .encoding rb 1 .path rb maxPathLength BgrAuxTable rb 32768 BgrAuxTable equ SB16Buffer rb 65536 SB16Buffer equ BUTTON_INFO rb 64*1024 BUTTON_INFO equ endg macro org x { if x eq (OS_BASE+0x0100000) else org x end if } macro align x { if x eq 65536 else if x eq 4096 else align x end if } macro assert [x] {} macro dw [x] { forward if x eq tss and 0xFFFF dw 0 else if x eq (tss shr 16) and 0xFF00 dw 0 else if x eq i40 and 0xFFFF dw 0 else if x eq i40 shr 16 dw 0 else dw x end if } macro db [x] { forward if x eq (tss shr 16) and 0xFF db 0 else db x end if } include 'data32.inc'