WebSVN – Kolibri OS – Diff – /kernel/trunk/const.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2021. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 9709 $
 
 
dpl0    =  10010000b      ; data read       dpl0
drw0    =  10010010b      ; data read/write dpl0
drw3    =  11110010b      ; data read/write dpl3
cpl0    =  10011010b      ; code read dpl0
cpl3    =  11111010b      ; code read dpl3
 
D32     =  01000000b      ; 32bit segment
G32     =  10000000b      ; page gran
 
;;;;;;;;;;; task manager errors ;;;;;;;;;;
 
TASKMAN_ERROR_OUT_OF_MEMORY      = 30 ; 0x1E
TASKMAN_ERROR_NOT_A_EXECUTABLE   = 31 ; 0x1F
TASKMAN_ERROR_TOO_MANY_PROCESSES = 32 ; 0x20
 
;;;;;;;;;;;;cpu_caps flags;;;;;;;;;;;;;;;;
 
CPU_386        = 3
CPU_486        = 4
CPU_PENTIUM    = 5
CPU_P6         = 6
CPU_PENTIUM4   = 0x0F
 
CAPS_FPU       =    00 ;on-chip x87 floating point unit
CAPS_VME       =    01 ;virtual-mode enhancements
CAPS_DE        =    02 ;debugging extensions
CAPS_PSE       =    03 ;page-size extensions
CAPS_TSC       =    04 ;time stamp counter
CAPS_MSR       =    05 ;model-specific registers
CAPS_PAE       =    06 ;physical-address extensions
CAPS_MCE       =    07 ;machine check exception
CAPS_CX8       =    08 ;CMPXCHG8B instruction
CAPS_APIC      =    09 ;on-chip advanced programmable
                       ;interrupt controller
;                   10 ;unused
CAPS_SEP       =    11 ;SYSENTER and SYSEXIT instructions
CAPS_MTRR      =    12 ;memory-type range registers
CAPS_PGE       =    13 ;page global extension
CAPS_MCA       =    14 ;machine check architecture
CAPS_CMOV      =    15 ;conditional move instructions
CAPS_PAT       =    16 ;page attribute table
 
CAPS_PSE36     =    17 ;page-size extensions
CAPS_PSN       =    18 ;processor serial number
CAPS_CLFLUSH   =    19 ;CLFUSH instruction
 
CAPS_DS        =    21 ;debug store
CAPS_ACPI      =    22 ;thermal monitor and software
                       ;controlled clock supported
CAPS_MMX       =    23 ;MMX instructions
CAPS_FXSR      =    24 ;FXSAVE and FXRSTOR instructions
CAPS_SSE       =    25 ;SSE instructions
CAPS_SSE2      =    26 ;SSE2 instructions
CAPS_SS        =    27 ;self-snoop
CAPS_HTT       =    28 ;hyper-threading technology
CAPS_TM        =    29 ;thermal monitor supported
CAPS_IA64      =    30 ;IA64 capabilities
CAPS_PBE       =    31 ;pending break enable
 
;ecx
CAPS_SSE3      =    32 ;SSE3 instructions
;                   33
;                   34
CAPS_MONITOR   =    35 ;MONITOR/MWAIT instructions
CAPS_DS_CPL    =    36 ;
CAPS_VMX       =    37 ;virtual mode extensions
;                   38 ;
CAPS_EST       =    39 ;enhansed speed step
CAPS_TM2       =    40 ;thermal monitor2 supported
;                   41
CAPS_CID       =    42 ;
;                   43
;                   44
CAPS_CX16      =    45 ;CMPXCHG16B instruction
CAPS_xTPR      =    46 ;
CAPS_XSAVE     =    32 + 26 ; XSAVE and XRSTOR instructions
CAPS_OSXSAVE   =    32 + 27
; A value of 1 indicates that the OS has set CR4.OSXSAVE[bit 18] to enable
; XSETBV/XGETBV instructions to access XCR0 and to support processor extended
; state management using XSAVE/XRSTOR.
CAPS_AVX       =    32 + 28 ; not AVX2
;
;reserved
;
;ext edx /ecx
CAPS_SYSCAL    =    64 ;
CAPS_XD        =    65 ;execution disable
CAPS_FFXSR     =    66 ;
CAPS_RDTSCP    =    67 ;
CAPS_X64       =    68 ;
CAPS_3DNOW     =    69 ;
CAPS_3DNOWEXT  =    70 ;
CAPS_LAHF      =    71 ;
CAPS_CMP_LEG   =    72 ;
CAPS_SVM       =    73 ;secure virual machine
CAPS_ALTMOVCR8 =    74 ;
 
; CPU MSR names
MSR_SYSENTER_CS         =     0x174
MSR_SYSENTER_ESP        =     0x175
MSR_SYSENTER_EIP        =     0x176
MSR_CR_PAT              =     0x277
MSR_MTRR_DEF_TYPE       =     0x2FF
 
MSR_AMD_EFER            =     0xC0000080      ; Extended Feature Enable Register
MSR_AMD_STAR            =     0xC0000081      ; SYSCALL/SYSRET Target Address Register
 
CR0_PE         =    0x00000001   ;protected mode
CR0_MP         =    0x00000002   ;monitor fpu
CR0_EM         =    0x00000004   ;fpu emulation
CR0_TS         =    0x00000008   ;task switch
CR0_ET         =    0x00000010   ;extension type hardcoded to 1
CR0_NE         =    0x00000020   ;numeric error
CR0_WP         =    0x00010000   ;write protect
CR0_AM         =    0x00040000   ;alignment check
CR0_NW         =    0x20000000   ;not write-through
CR0_CD         =    0x40000000   ;cache disable
CR0_PG         =    0x80000000   ;paging
 
 
CR4_VME        =    0x000001
CR4_PVI        =    0x000002
CR4_TSD        =    0x000004
CR4_DE         =    0x000008
CR4_PSE        =    0x000010
CR4_PAE        =    0x000020
CR4_MCE        =    0x000040
CR4_PGE        =    0x000080
CR4_PCE        =    0x000100
CR4_OSFXSR     =    0x000200
CR4_OSXMMEXPT  =    0x000400
CR4_OSXSAVE    =    0x040000
 
XCR0_FPU_MMX   =    0x0001
XCR0_SSE       =    0x0002
XCR0_AVX       =    0x0004
XCR0_MPX       =    0x0018
XCR0_AVX512    =    0x00e0
 
MXCSR_IE       =    0x0001
MXCSR_DE       =    0x0002
MXCSR_ZE       =    0x0004
MXCSR_OE       =    0x0008
MXCSR_UE       =    0x0010
MXCSR_PE       =    0x0020
MXCSR_DAZ      =    0x0040
MXCSR_IM       =    0x0080
MXCSR_DM       =    0x0100
MXCSR_ZM       =    0x0200
MXCSR_OM       =    0x0400
MXCSR_UM       =    0x0800
MXCSR_PM       =    0x1000
MXCSR_FZ       =    0x8000
 
MXCSR_INIT     = MXCSR_IM + MXCSR_DM + MXCSR_ZM + MXCSR_OM + MXCSR_UM + MXCSR_PM
 
EFLAGS_CF      =    0x000001  ; carry flag
EFLAGS_PF      =    0x000004  ; parity flag
EFLAGS_AF      =    0x000010  ; auxiliary flag
EFLAGS_ZF      =    0x000040  ; zero flag
EFLAGS_SF      =    0x000080  ; sign flag
EFLAGS_TF      =    0x000100  ; trap flag
EFLAGS_IF      =    0x000200  ; interrupt flag
EFLAGS_DF      =    0x000400  ; direction flag
EFLAGS_OF      =    0x000800  ; overflow flag
EFLAGS_IOPL    =    0x003000  ; i/o priviledge level
EFLAGS_NT      =    0x004000  ; nested task flag
EFLAGS_RF      =    0x010000  ; resume flag
EFLAGS_VM      =    0x020000  ; virtual 8086 mode flag
EFLAGS_AC      =    0x040000  ; alignment check flag
EFLAGS_VIF     =    0x080000  ; virtual interrupt flag
EFLAGS_VIP     =    0x100000  ; virtual interrupt pending
EFLAGS_ID      =    0x200000  ; id flag
 
IRQ_PIC        =    0
IRQ_APIC       =    1
 
struct  TSS
        _back       rw 2
        _esp0       rd 1
        _ss0        rw 2
        _esp1       rd 1
        _ss1        rw 2
        _esp2       rd 1
        _ss2        rw 2
        _cr3        rd 1
        _eip        rd 1
        _eflags     rd 1
        _eax        rd 1
        _ecx        rd 1
        _edx        rd 1
        _ebx        rd 1
        _esp        rd 1
        _ebp        rd 1
        _esi        rd 1
        _edi        rd 1
        _es         rw 2
        _cs         rw 2
        _ss         rw 2
        _ds         rw 2
        _fs         rw 2
        _gs         rw 2
        _ldt        rw 2
        _trap       rw 1
        _io         rw 1
                    rb 24
        _io_map_0   rb 4096
        _io_map_1   rb 4096
ends
 
DRIVE_DATA_SIZE     = 16
 
OS_BASE             = 0x80000000
 
window_data         = OS_BASE + 0x0001000
 
;TASK_TABLE          = OS_BASE + 0x0003000
;CURRENT_TASK        = OS_BASE + 0x0003000
;TASK_COUNT          = OS_BASE + 0x0003004
;TASK_BASE           = OS_BASE + 0x0003010
;TASK_DATA           = OS_BASE + 0x0003020
;TASK_EVENT          = OS_BASE + 0x0003020
 
CDDataBuf           = OS_BASE + 0x0005000
 
;unused                 0x6000 - 0x8fff
 
BOOT_VARS           = 0x9000
 
idts                = OS_BASE + 0x000B100
WIN_STACK           = OS_BASE + 0x000C000
WIN_POS             = OS_BASE + 0x000C400
FDD_BUFF            = OS_BASE + 0x000D000     ;512
 
WIN_TEMP_XY         = OS_BASE + 0x000F300
KEY_COUNT           = OS_BASE + 0x000F400
KEY_BUFF            = OS_BASE + 0x000F401 ; 120*2 + 2*2 = 244 bytes, actually 255 bytes
 
BTN_COUNT           = OS_BASE + 0x000F500
BTN_BUFF            = OS_BASE + 0x000F501
 
 
BTN_ADDR            = OS_BASE + 0x000FE88
MEM_AMOUNT          = OS_BASE + 0x000FE8C
 
SYS_SHUTDOWN        = OS_BASE + 0x000FF00
 
 
TMP_STACK_TOP       = 0x007CC00
 
sys_proc            = OS_BASE + 0x007E000
 
SLOT_BASE           = OS_BASE + 0x0080000
 
VGABasePtr          = OS_BASE + 0x00A0000
 
virtual at            OS_BASE + 0x05FFF80
  tss  TSS
end virtual
 
HEAP_BASE           = OS_BASE + 0x0800000
HEAP_MIN_SIZE       = 0x01000000
 
page_tabs           = 0xFDC00000
app_page_tabs       = 0xFDC00000
kernel_tabs         = page_tabs + (OS_BASE shr 10)   ;0xFDE00000
master_tab          = page_tabs + (page_tabs shr 10) ;0xFDFF70000
 
LFB_BASE            = 0xFE000000
 
 
new_app_base        = 0;
 
;twdw                = TASK_TABLE - window_data
 
std_application_base_address   = new_app_base
RING0_STACK_SIZE    = 0x2000
 
REG_SS              = RING0_STACK_SIZE -  4
REG_APP_ESP         = RING0_STACK_SIZE -  8
REG_EFLAGS          = RING0_STACK_SIZE - 12
REG_CS              = RING0_STACK_SIZE - 16
REG_EIP             = RING0_STACK_SIZE - 20
REG_EAX             = RING0_STACK_SIZE - 24
REG_ECX             = RING0_STACK_SIZE - 28
REG_EDX             = RING0_STACK_SIZE - 32
REG_EBX             = RING0_STACK_SIZE - 36
REG_ESP             = RING0_STACK_SIZE - 40  ;RING0_STACK_SIZE-20
REG_EBP             = RING0_STACK_SIZE - 44
REG_ESI             = RING0_STACK_SIZE - 48
REG_EDI             = RING0_STACK_SIZE - 52
REG_RET             = RING0_STACK_SIZE - 56  ;irq0.return
 
 
PAGE_SIZE           = 4096
 
PG_UNMAP            = 0x000
PG_READ             = 0x001
PG_WRITE            = 0x002
PG_USER             = 0x004
PG_PCD              = 0x008
PG_PWT              = 0x010
PG_ACCESSED         = 0x020
PG_DIRTY            = 0x040
PG_PAT              = 0x080
PG_GLOBAL           = 0x100
PG_SHARED           = 0x200
 
PG_SWR              = 0x003 ; PG_WRITE + PG_READ
PG_UR               = 0x005 ; PG_USER + PG_READ
PG_UWR              = 0x007 ; PG_USER + PG_WRITE + PG_READ
PG_NOCACHE          = 0x018 ; PG_PCD + PG_PWT
 
PDE_LARGE           = 0x080
 
MEM_WB              = 6     ; write-back memory
MEM_WC              = 1     ; write combined memory
MEM_UC              = 0     ; uncached memory
 
PAT_WB              = 0x000
PAT_WC              = 0x008
PAT_UCM             = 0x010
PAT_UC              = 0x018
 
PAT_TYPE_UC         = 0
PAT_TYPE_WC         = 1
PAT_TYPE_WB         = 6
PAT_TYPE_UCM        = 7
 
PAT_VALUE           = 0x00070106; (UC<<24)|(UCM<<16)|(WC<<8)|WB
 
MAX_MEMMAP_BLOCKS   = 32
 
EVENT_REDRAW       = 0x00000001
EVENT_KEY          = 0x00000002
EVENT_BUTTON       = 0x00000004
EVENT_BACKGROUND   = 0x00000010
EVENT_MOUSE        = 0x00000020
EVENT_IPC          = 0x00000040
EVENT_NETWORK      = 0x00000080
EVENT_DEBUG        = 0x00000100
EVENT_NETWORK2     = 0x00000200
EVENT_EXTENDED     = 0x00000400
 
EV_INTR            = 1
 
STDIN_FILENO       = 0
STDOUT_FILENO      = 1
STDERR_FILENO      = 2
 
SYSTEM_SHUTDOWN    = 2
SYSTEM_REBOOT      = 3
SYSTEM_RESTART     = 4
 
BLIT_CLIENT_RELATIVE = 0x20000000
 
struct SYSCALL_STACK
        _eip            dd ?
        _edi            dd ?    ;  +4
        _esi            dd ?    ;  +8
        _ebp            dd ?    ; +12
        _esp            dd ?    ; +16
        _ebx            dd ?    ; +20
        _edx            dd ?    ; +24
        _ecx            dd ?    ; +28
        _eax            dd ?    ; +32
ends
 
struct  LHEAD
        next            dd ?   ;next object in list
        prev            dd ?   ;prev object in list
ends
 
struct  MUTEX_WAITER
        list    LHEAD
        task    dd ?
        type    dd ?
ends
 
struct  MUTEX
        wait_list       LHEAD
        count           dd ?
ends
 
struct  RWSEM
        wait_list       LHEAD
        count           dd ?
ends
 
struct  FUTEX
        list            LHEAD
        magic           dd ?
        handle          dd ?
        destroy         dd ?
 
        wait_list       LHEAD
        pointer         dd ?
        flags           dd ?
ends
 
FUTEX_INIT      = 0
FUTEX_DESTROY   = 1
FUTEX_WAIT      = 2
FUTEX_WAKE      = 3
 
struct  FILED
        list            LHEAD
        magic           rd 1
        handle          rd 1
        destroy         rd 1
        mode            rd 1
        file            rd 1
ends
 
struct  PIPE
        pipe_ops        rd 1
        buffer          rd 1
        readers         rd 1
        writers         rd 1
 
        pipe_lock       MUTEX
        count           rd 1
 
        read_end        rd 1
        write_end       rd 1
        rlist           LHEAD
        wlist           LHEAD
ends
 
struct  PROC
        list            LHEAD
        thr_list        LHEAD
        heap_lock       MUTEX
        heap_base       rd 1
        heap_top        rd 1
        mem_used        rd 1
        dlls_list_ptr   rd 1
        pdt_0_phys      rd 1
        pdt_1_phys      rd 1
        io_map_0        rd 1
        io_map_1        rd 1
 
        ht_lock         rd 1
        ht_free         rd 1                ;htab[0] stdin
        ht_next         rd 1                ;htab[1] stdout
        htab            rd 1024-PROC.htab/4 ;htab[2] stderr
        pdt_0           rd 1024
ends
 
struct  DBG_REGS
        dr0             dd ?
        dr1             dd ?
        dr2             dd ?
        dr3             dd ?
        dr7             dd ?
ends
 
struct  POINT
        x       dd ?
        y       dd ?
ends
 
struct  RECT
        left    dd ?
        top     dd ?
        right   dd ?
        bottom  dd ?
ends
 
struct  BOX
        left    dd ?
        top     dd ?
        width   dd ?
        height  dd ?
ends
 
; Fields, marked as R now not used, but will be used soon,
; when legacy TASKDATA structure will be deleted
struct  APPDATA
        app_name        rb 11
                        rb 5
 
        list            LHEAD           ;+16
        process         dd ?            ;+24
        fpu_state       dd ?            ;+28
        exc_handler     dd ?            ;+32
        except_mask     dd ?            ;+36
        pl0_stack       dd ?            ;+40
        cursor          dd ?            ;+44
        fd_ev           dd ?            ;+48
        bk_ev           dd ?            ;+52
        fd_obj          dd ?            ;+56
        bk_obj          dd ?            ;+60
        saved_esp       dd ?            ;+64
        io_map          rd 2            ;+68
        dbg_state       dd ?            ;+76
        cur_dir         dd ?            ;+80
        wait_timeout    dd ?            ;+84
        saved_esp0      dd ?            ;+88
        wait_begin      dd ?            ;+92   +++
        wait_test       dd ?            ;+96   +++
        wait_param      dd ?            ;+100  +++
        tls_base        dd ?            ;+104
        event_mask      dd ?            ;+108   stores event types allowed for task
        tid             dd ?            ;+112   thread id
        draw_bgr_x      dd ?            ;+116
        draw_bgr_y      dd ?            ;+120
        state           db ?            ;+124   thread state
        wnd_number      db ?            ;+125
                        dw ?            ;+126
        wnd_shape       dd ?            ;+128
        wnd_shape_scale dd ?            ;+132
        mem_start       dd ?            ;+136
        counter_sum     dd ?            ;+140  ; R
        saved_box       BOX             ;+144
        ipc_start       dd ?            ;+160
        ipc_size        dd ?            ;+164
        occurred_events dd ?            ;+168  ; mask which accumulates occurred events
        debugger_slot   dd ?            ;+172
        terminate_protection dd ?       ;+176
        keyboard_mode   db ?            ;+180
        captionEncoding db ?
                        rb 2
        exec_params     dd ?            ;+184
        dbg_event_mem   dd ?            ;+188
        dbg_regs        DBG_REGS        ;+192
        wnd_caption     dd ?            ;+212
        wnd_clientbox   BOX             ;+216
        priority        dd ?            ;+232
        in_schedule     LHEAD           ;+236
        counter_add     dd ?            ;+244  ; R
        cpu_usage       dd ?            ;+248  ; R
                        dd ?            ;+252
ends
 
assert sizeof.APPDATA = 256
 
APP_OBJ_OFFSET  = 48
APP_EV_OFFSET   = 40
 
; Note: in future TASKDATA will be merged into APPDATA
;struct  TASKDATA
;        event_mask      dd ? ;+0 mask which stores event types allowed for task
;        pid             dd ? ;+4
;                        dw ? ;+8
;        state           db ? ;+10
;                        db ? ;+11
;                        dw ? ;+12
;        wnd_number      db ? ;+14
;                        db ? ;+15
;        mem_start       dd ? ;+16
;        counter_sum     dd ? ;+20
;        counter_add     dd ? ;+24
;        cpu_usage       dd ? ;+28
;ends
 
; Thread states:
TSTATE_RUNNING        = 0
TSTATE_RUN_SUSPENDED  = 1
TSTATE_WAIT_SUSPENDED = 2
TSTATE_ZOMBIE         = 3
TSTATE_TERMINATING    = 4
TSTATE_WAITING        = 5
TSTATE_FREE           = 9
 
; Window constants:
WSTATE_NORMAL    = 00000000b
WSTATE_MAXIMIZED = 00000001b
WSTATE_MINIMIZED = 00000010b
WSTATE_ROLLEDUP  = 00000100b
 
WSTATE_REDRAW    = 00000001b
WSTATE_WNDDRAWN  = 00000010b
 
WSTYLE_HASCAPTION     = 00010000b
WSTYLE_CLIENTRELATIVE = 00100000b
 
ZPOS_DESKTOP            = -2
ZPOS_ALWAYS_BACK        = -1
ZPOS_NORMAL             = 0
ZPOS_ALWAYS_TOP         = 1     ;ZPOS_ALWAYS_TOP is always last and has max number!
 
; Window structure:
struct  WDATA
        box             BOX
        cl_workarea     dd ?
        cl_titlebar     dd ?
        cl_frames       dd ?
        z_modif         db ?
        fl_wstate       db ?
        fl_wdrawn       db ?
        fl_redraw       db ?
ends
 
label WDATA.fl_wstyle byte at WDATA.cl_workarea + 3
 
assert sizeof.WDATA = 32
 
struct  SYS_VARS
        bpp             dd ?
        scanline        dd ?
        vesa_mode       dd ?
        x_res           dd ?
        y_res           dd ?
ends
 
struct  APPOBJ                  ; common object header
        magic           dd ?    ;
        destroy         dd ?    ; internal destructor
        fd              dd ?    ; next object in list
        bk              dd ?    ; prev object in list
        pid             dd ?    ; owner id
ends
 
struct  CURSOR          APPOBJ
        base            dd ?   ;allocated memory
        hot_x           dd ?   ;hotspot coords
        hot_y           dd ?
 
        list_next       dd ?   ;next cursor in cursor list
        list_prev       dd ?   ;prev cursor in cursor list
        dev_obj         dd ?   ;device depended data
ends
 
 
struct  EVENT           APPOBJ
        id              dd ?   ;event uid
        state           dd ?   ;internal flags
        code            dd ?
                        rd 5
ends
 
 
struct  SMEM
        bk              dd ?
        fd              dd ?    ;+4
        base            dd ?    ;+8
        size            dd ?    ;+12
        access          dd ?    ;+16
        refcount        dd ?    ;+20
        name            rb 32   ;+24
ends
 
struct  SMAP            APPOBJ
        base            dd ?   ;mapped base
        parent          dd ?   ;SMEM
ends
 
struct  DLLDESCR
        bk              dd ?
        fd              dd ?    ;+4
        data            dd ?    ;+8
        size            dd ?    ;+12
        timestamp       dq ?
        refcount        dd ?
        defaultbase     dd ?
        coff_hdr        dd ?
        symbols_ptr     dd ?
        symbols_num     dd ?
        symbols_lim     dd ?
        exports         dd ?   ;export table
        name            rb 260
ends
 
struct  HDLL
        fd              dd ?   ;next object in list
        bk              dd ?   ;prev object in list
        pid             dd ?   ;owner id
 
        base            dd ?   ;mapped base
        size            dd ?   ;mapped size
        refcount        dd ?   ;reference counter for this process and this lib
        parent          dd ?   ;DLLDESCR
ends
 
struct DQ
        lo dd ?
        hi dd ?
ends
 
struct e820entry
        addr DQ ?
        size DQ ?
        type dd ?
ends
 
RD_LOAD_FROM_FLOPPY = 1
RD_LOAD_FROM_HD     = 2
RD_LOAD_FROM_MEMORY = 3
RD_LOAD_FROM_FORMAT = 4
RD_LOAD_FROM_NONE   = 5
 
struct boot_pci_data
        access_mechanism db ?
        last_bus         db ?
        version          dw ?   ; bcd minor, then major
        pm_entry         dd ?   ; physical address of protected-mode entry point
ends
 
struct  boot_data
        bpp             db ?    ; bits per pixel
        pitch           dw ?    ; scanline length
                        db ?
                        dd ?
        vesa_mode       dw ?
        x_res           dw ?
        y_res           dw ?
                        dw ?
                        dd ?
        bank_switch     dd ?    ; Vesa 1.2 pm bank switch
        lfb             dd ?    ; Vesa 2.0 LFB address
        mtrr            db ?    ; 0 or 1: enable MTRR graphics acceleration
        launcher_start  db ?    ; 0 or 1: start the first app (right now it's
                                ; LAUNCHER) after kernel is loaded
        debug_print     db ?    ; if nonzero, duplicates debug output to the screen
        dma             db ?    ; DMA write: 1=yes, 2=no
        pci_data        boot_pci_data
                        rb 8
        shutdown_type   db ?    ; see sysfn 18.9
                        rb 15
        apm_entry       dd ?    ; entry point of APM BIOS
        apm_version     dw ?    ; BCD
        apm_flags       dw ?
                        rb 8
        apm_code_32     dw ?
        apm_code_16     dw ?
        apm_data_16     dw ?
        rd_load_from    db ?    ; Device to load ramdisk from, RD_LOAD_FROM_*
                        db ?
        kernel_restart  dw ?
        sys_disk        dw ?    ; Device to mount on /sys/, see loader_doc.txt for details
        acpi_rsdp       dd ?
        syspath         rb 0x17
        devicesdat_data dd ?
        devicesdat_size dd ?
        bios_hd_cnt     db ?    ; number of BIOS hard disks
        bios_hd         rb 0x80 ; BIOS hard disks
        memmap_block_cnt dd ?   ; available physical memory map: number of blocks
        memmap_blocks   e820entry
                        rb sizeof.e820entry * (MAX_MEMMAP_BLOCKS - 1)
ends
 
virtual at BOOT_VARS
        BOOT_LO boot_data
end virtual
virtual at OS_BASE + BOOT_VARS
        BOOT boot_data
end virtual
 
MAX_SCREEN_WIDTH  = 3840
MAX_SCREEN_HEIGHT = 2160
 
struct  display_t
        x               dd ?
        y               dd ?
        width           dd ?
        height          dd ?
        bits_per_pixel  dd ?
        vrefresh        dd ?
        current_lfb     dd ?
        lfb_pitch       dd ?
 
        win_map_lock    RWSEM
        win_map         dd ?
        win_map_pitch   dd ?
        win_map_size    dd ?
 
        modes           dd ?
        ddev            dd ?
        connector       dd ?
        crtc            dd ?
 
        cr_list.next    dd ?
        cr_list.prev    dd ?
 
        cursor          dd ?
 
        init_cursor     dd ?
        select_cursor   dd ?
        show_cursor     dd ?
        move_cursor     dd ?
        restore_cursor  dd ?
        disable_mouse   dd ?
        mask_seqno      dd ?
        check_mouse     dd ?
        check_m_pixel   dd ?
 
        bytes_per_pixel dd ?
ends
 
struct  DISPMODE
        width   dw ?
        height  dw ?
        bpp     dw ?
        freq    dw ?
ends
 
 
struct  PCIDEV
        bk              dd ?
        fd              dd ?
        vendor_device_id dd ?
        class           dd ?
        devfn           db ?
        bus             db ?
                        rb 2
        owner           dd ? ; pointer to SRV or 0
ends
 
struct  IDE_DATA
        ProgrammingInterface dd ?
        Interrupt            dw ?
        RegsBaseAddres       dw ?
        BAR0_val             dw ?
        BAR1_val             dw ?
        BAR2_val             dw ?
        BAR3_val             dw ?
        dma_hdd_channel_1    db ?
        dma_hdd_channel_2    db ?
        pcidev               dd ?       ; pointer to corresponding PCIDEV structure
ends
 
struct  IDE_CACHE
        pointer              dd ?
        size                 dd ?   ; not use
        data_pointer         dd ?
        system_data_size     dd ?   ; not use
        appl_data_size       dd ?   ; not use
        system_data          dd ?
        appl_data            dd ?
        system_sad_size      dd ?
        appl_sad_size        dd ?
        search_start         dd ?
        appl_search_start    dd ?
ends
 
struct  IDE_DEVICE
        UDMA_possible_modes  db ?
        UDMA_set_mode        db ?
ends
 
; The following macro assume that we are on uniprocessor machine.
; Serious work is needed for multiprocessor machines.
macro spin_lock_irqsave spinlock
{
        pushf
        cli
}
macro spin_unlock_irqrestore spinlock
{
        popf
}
macro spin_lock_irq spinlock
{
        cli
}
macro spin_unlock_irq spinlock
{
        sti
}
 
struct  MEM_STATE
        mutex           MUTEX
        smallmap        dd ?
        treemap         dd ?
        topsize         dd ?
        top             dd ?
        smallbins       rd 4*32
        treebins        rd 32
ends
 
struct  PG_DATA
        mem_amount      dd ?
        vesa_mem        dd ?
        pages_count     dd ?
        pages_free      dd ?
        pages_faults    dd ?
        pagemap_size    dd ?
        kernel_pages    dd ?
        kernel_tables   dd ?
        sys_page_dir    dd ?
        mutex           MUTEX
ends
 
struct  SRV
        srv_name        rb 16    ;ASCIIZ string
        magic           dd ?     ;+0x10 ;'SRV '
        size            dd ?     ;+0x14 ;size of structure SRV
        fd              dd ?     ;+0x18 ;next SRV descriptor
        bk              dd ?     ;+0x1C ;prev SRV descriptor
        base            dd ?     ;+0x20 ;service base address
        entry           dd ?     ;+0x24 ;service START function
        srv_proc        dd ?     ;+0x28 ;user mode service handler
        srv_proc_ex     dd ?     ;+0x2C ;kernel mode service handler
ends
 
struct USBSRV
        srv             SRV
        usb_func        dd ?
ends
 
struct USBFUNC
        strucsize       dd ?
        add_device      dd ?
        device_disconnect dd ?
ends
 
DRV_ENTRY    =  1
DRV_EXIT     = -1
 
struct  COFF_HEADER
        machine         dw ?
        nSections       dw ?
        DataTime        dd ?
        pSymTable       dd ?
        nSymbols        dd ?
        optHeader       dw ?
        flags           dw ?
ends
 
struct  COFF_SECTION
        Name            rb 8
        VirtualSize     dd ?
        VirtualAddress  dd ?
        SizeOfRawData   dd ?
        PtrRawData      dd ?
        PtrReloc        dd ?
        PtrLinenumbers  dd ?
        NumReloc        dw ?
        NumLinenum      dw ?
        Characteristics dd ?
ends
 
struct  COFF_RELOC
        VirtualAddress  dd ?
        SymIndex        dd ?
        Type            dw ?
ends
 
struct  COFF_SYM
        Name            rb 8
        Value           dd ?
        SectionNumber   dw ?
        Type            dw ?
        StorageClass    db ?
        NumAuxSymbols   db ?
ends
 
struct  STRIPPED_PE_HEADER
        Signature           dw ?
        Characteristics     dw ?
        AddressOfEntryPoint dd ?
        ImageBase           dd ?
        SectionAlignmentLog db ?
        FileAlignmentLog    db ?
        MajorOSVersion      db ?
        MinorOSVersion      db ?
        SizeOfImage         dd ?
        SizeOfStackReserve  dd ?
        SizeOfHeapReserve   dd ?
        SizeOfHeaders       dd ?
        Subsystem           db ?
        NumberOfRvaAndSizes db ?
        NumberOfSections    dw ?
ends
STRIPPED_PE_SIGNATURE = 0x4503 ; 'PE' xor 'S'
SPE_DIRECTORY_IMPORT    = 0
SPE_DIRECTORY_EXPORT    = 1
SPE_DIRECTORY_BASERELOC = 2
 
struct  IOCTL
        handle          dd ?
        io_code         dd ?
        input           dd ?
        inp_size        dd ?
        output          dd ?
        out_size        dd ?
ends
 
struct  IRQH
        list            LHEAD
        handler         dd ?   ;handler roututine
        data            dd ?   ;user-specific data
        num_ints        dd ?   ;how many times handled
ends
 
MAX_MEMMAP_BLOCKS>
 
MAX_MEMMAP_BLOCKS>
 
MAX_MEMMAP_BLOCKS>
 
MAX_MEMMAP_BLOCKS>
 
MAX_MEMMAP_BLOCKS>
 
MAX_MEMMAP_BLOCKS>

Rev 9608	Rev 9709
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2021. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2021. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 9608 $	8	$Revision: 9709 $
9		9
10		10
11	dpl0 = 10010000b ; data read dpl0	11	dpl0 = 10010000b ; data read dpl0
12	drw0 = 10010010b ; data read/write dpl0	12	drw0 = 10010010b ; data read/write dpl0
13	drw3 = 11110010b ; data read/write dpl3	13	drw3 = 11110010b ; data read/write dpl3
14	cpl0 = 10011010b ; code read dpl0	14	cpl0 = 10011010b ; code read dpl0
15	cpl3 = 11111010b ; code read dpl3	15	cpl3 = 11111010b ; code read dpl3
16		16
17	D32 = 01000000b ; 32bit segment	17	D32 = 01000000b ; 32bit segment
18	G32 = 10000000b ; page gran	18	G32 = 10000000b ; page gran
19		19
20	;;;;;;;;;;; task manager errors ;;;;;;;;;;	20	;;;;;;;;;;; task manager errors ;;;;;;;;;;
21		21
22	TASKMAN_ERROR_OUT_OF_MEMORY = 30 ; 0x1E	22	TASKMAN_ERROR_OUT_OF_MEMORY = 30 ; 0x1E
23	TASKMAN_ERROR_NOT_A_EXECUTABLE = 31 ; 0x1F	23	TASKMAN_ERROR_NOT_A_EXECUTABLE = 31 ; 0x1F
24	TASKMAN_ERROR_TOO_MANY_PROCESSES = 32 ; 0x20	24	TASKMAN_ERROR_TOO_MANY_PROCESSES = 32 ; 0x20
25		25
26	;;;;;;;;;;;;cpu_caps flags;;;;;;;;;;;;;;;;	26	;;;;;;;;;;;;cpu_caps flags;;;;;;;;;;;;;;;;
27		27
28	CPU_386 = 3	28	CPU_386 = 3
29	CPU_486 = 4	29	CPU_486 = 4
30	CPU_PENTIUM = 5	30	CPU_PENTIUM = 5
31	CPU_P6 = 6	31	CPU_P6 = 6
32	CPU_PENTIUM4 = 0x0F	32	CPU_PENTIUM4 = 0x0F
33		33
34	CAPS_FPU = 00 ;on-chip x87 floating point unit	34	CAPS_FPU = 00 ;on-chip x87 floating point unit
35	CAPS_VME = 01 ;virtual-mode enhancements	35	CAPS_VME = 01 ;virtual-mode enhancements
36	CAPS_DE = 02 ;debugging extensions	36	CAPS_DE = 02 ;debugging extensions
37	CAPS_PSE = 03 ;page-size extensions	37	CAPS_PSE = 03 ;page-size extensions
38	CAPS_TSC = 04 ;time stamp counter	38	CAPS_TSC = 04 ;time stamp counter
39	CAPS_MSR = 05 ;model-specific registers	39	CAPS_MSR = 05 ;model-specific registers
40	CAPS_PAE = 06 ;physical-address extensions	40	CAPS_PAE = 06 ;physical-address extensions
41	CAPS_MCE = 07 ;machine check exception	41	CAPS_MCE = 07 ;machine check exception
42	CAPS_CX8 = 08 ;CMPXCHG8B instruction	42	CAPS_CX8 = 08 ;CMPXCHG8B instruction
43	CAPS_APIC = 09 ;on-chip advanced programmable	43	CAPS_APIC = 09 ;on-chip advanced programmable
44	;interrupt controller	44	;interrupt controller
45	; 10 ;unused	45	; 10 ;unused
46	CAPS_SEP = 11 ;SYSENTER and SYSEXIT instructions	46	CAPS_SEP = 11 ;SYSENTER and SYSEXIT instructions
47	CAPS_MTRR = 12 ;memory-type range registers	47	CAPS_MTRR = 12 ;memory-type range registers
48	CAPS_PGE = 13 ;page global extension	48	CAPS_PGE = 13 ;page global extension
49	CAPS_MCA = 14 ;machine check architecture	49	CAPS_MCA = 14 ;machine check architecture
50	CAPS_CMOV = 15 ;conditional move instructions	50	CAPS_CMOV = 15 ;conditional move instructions
51	CAPS_PAT = 16 ;page attribute table	51	CAPS_PAT = 16 ;page attribute table
52		52
53	CAPS_PSE36 = 17 ;page-size extensions	53	CAPS_PSE36 = 17 ;page-size extensions
54	CAPS_PSN = 18 ;processor serial number	54	CAPS_PSN = 18 ;processor serial number
55	CAPS_CLFLUSH = 19 ;CLFUSH instruction	55	CAPS_CLFLUSH = 19 ;CLFUSH instruction
56		56
57	CAPS_DS = 21 ;debug store	57	CAPS_DS = 21 ;debug store
58	CAPS_ACPI = 22 ;thermal monitor and software	58	CAPS_ACPI = 22 ;thermal monitor and software
59	;controlled clock supported	59	;controlled clock supported
60	CAPS_MMX = 23 ;MMX instructions	60	CAPS_MMX = 23 ;MMX instructions
61	CAPS_FXSR = 24 ;FXSAVE and FXRSTOR instructions	61	CAPS_FXSR = 24 ;FXSAVE and FXRSTOR instructions
62	CAPS_SSE = 25 ;SSE instructions	62	CAPS_SSE = 25 ;SSE instructions
63	CAPS_SSE2 = 26 ;SSE2 instructions	63	CAPS_SSE2 = 26 ;SSE2 instructions
64	CAPS_SS = 27 ;self-snoop	64	CAPS_SS = 27 ;self-snoop
65	CAPS_HTT = 28 ;hyper-threading technology	65	CAPS_HTT = 28 ;hyper-threading technology
66	CAPS_TM = 29 ;thermal monitor supported	66	CAPS_TM = 29 ;thermal monitor supported
67	CAPS_IA64 = 30 ;IA64 capabilities	67	CAPS_IA64 = 30 ;IA64 capabilities
68	CAPS_PBE = 31 ;pending break enable	68	CAPS_PBE = 31 ;pending break enable
69		69
70	;ecx	70	;ecx
71	CAPS_SSE3 = 32 ;SSE3 instructions	71	CAPS_SSE3 = 32 ;SSE3 instructions
72	; 33	72	; 33
73	; 34	73	; 34
74	CAPS_MONITOR = 35 ;MONITOR/MWAIT instructions	74	CAPS_MONITOR = 35 ;MONITOR/MWAIT instructions
75	CAPS_DS_CPL = 36 ;	75	CAPS_DS_CPL = 36 ;
76	CAPS_VMX = 37 ;virtual mode extensions	76	CAPS_VMX = 37 ;virtual mode extensions
77	; 38 ;	77	; 38 ;
78	CAPS_EST = 39 ;enhansed speed step	78	CAPS_EST = 39 ;enhansed speed step
79	CAPS_TM2 = 40 ;thermal monitor2 supported	79	CAPS_TM2 = 40 ;thermal monitor2 supported
80	; 41	80	; 41
81	CAPS_CID = 42 ;	81	CAPS_CID = 42 ;
82	; 43	82	; 43
83	; 44	83	; 44
84	CAPS_CX16 = 45 ;CMPXCHG16B instruction	84	CAPS_CX16 = 45 ;CMPXCHG16B instruction
85	CAPS_xTPR = 46 ;	85	CAPS_xTPR = 46 ;
86	CAPS_XSAVE = 32 + 26 ; XSAVE and XRSTOR instructions	86	CAPS_XSAVE = 32 + 26 ; XSAVE and XRSTOR instructions
87	CAPS_OSXSAVE = 32 + 27	87	CAPS_OSXSAVE = 32 + 27
88	; A value of 1 indicates that the OS has set CR4.OSXSAVE[bit 18] to enable	88	; A value of 1 indicates that the OS has set CR4.OSXSAVE[bit 18] to enable
89	; XSETBV/XGETBV instructions to access XCR0 and to support processor extended	89	; XSETBV/XGETBV instructions to access XCR0 and to support processor extended
90	; state management using XSAVE/XRSTOR.	90	; state management using XSAVE/XRSTOR.
91	CAPS_AVX = 32 + 28 ; not AVX2	91	CAPS_AVX = 32 + 28 ; not AVX2
92	;	92	;
93	;reserved	93	;reserved
94	;	94	;
95	;ext edx /ecx	95	;ext edx /ecx
96	CAPS_SYSCAL = 64 ;	96	CAPS_SYSCAL = 64 ;
97	CAPS_XD = 65 ;execution disable	97	CAPS_XD = 65 ;execution disable
98	CAPS_FFXSR = 66 ;	98	CAPS_FFXSR = 66 ;
99	CAPS_RDTSCP = 67 ;	99	CAPS_RDTSCP = 67 ;
100	CAPS_X64 = 68 ;	100	CAPS_X64 = 68 ;
101	CAPS_3DNOW = 69 ;	101	CAPS_3DNOW = 69 ;
102	CAPS_3DNOWEXT = 70 ;	102	CAPS_3DNOWEXT = 70 ;
103	CAPS_LAHF = 71 ;	103	CAPS_LAHF = 71 ;
104	CAPS_CMP_LEG = 72 ;	104	CAPS_CMP_LEG = 72 ;
105	CAPS_SVM = 73 ;secure virual machine	105	CAPS_SVM = 73 ;secure virual machine
106	CAPS_ALTMOVCR8 = 74 ;	106	CAPS_ALTMOVCR8 = 74 ;
107		107
108	; CPU MSR names	108	; CPU MSR names
109	MSR_SYSENTER_CS = 0x174	109	MSR_SYSENTER_CS = 0x174
110	MSR_SYSENTER_ESP = 0x175	110	MSR_SYSENTER_ESP = 0x175
111	MSR_SYSENTER_EIP = 0x176	111	MSR_SYSENTER_EIP = 0x176
112	MSR_CR_PAT = 0x277	112	MSR_CR_PAT = 0x277
113	MSR_MTRR_DEF_TYPE = 0x2FF	113	MSR_MTRR_DEF_TYPE = 0x2FF
114		114
115	MSR_AMD_EFER = 0xC0000080 ; Extended Feature Enable Register	115	MSR_AMD_EFER = 0xC0000080 ; Extended Feature Enable Register
116	MSR_AMD_STAR = 0xC0000081 ; SYSCALL/SYSRET Target Address Register	116	MSR_AMD_STAR = 0xC0000081 ; SYSCALL/SYSRET Target Address Register
117		117
118	CR0_PE = 0x00000001 ;protected mode	118	CR0_PE = 0x00000001 ;protected mode
119	CR0_MP = 0x00000002 ;monitor fpu	119	CR0_MP = 0x00000002 ;monitor fpu
120	CR0_EM = 0x00000004 ;fpu emulation	120	CR0_EM = 0x00000004 ;fpu emulation
121	CR0_TS = 0x00000008 ;task switch	121	CR0_TS = 0x00000008 ;task switch
122	CR0_ET = 0x00000010 ;extension type hardcoded to 1	122	CR0_ET = 0x00000010 ;extension type hardcoded to 1
123	CR0_NE = 0x00000020 ;numeric error	123	CR0_NE = 0x00000020 ;numeric error
124	CR0_WP = 0x00010000 ;write protect	124	CR0_WP = 0x00010000 ;write protect
125	CR0_AM = 0x00040000 ;alignment check	125	CR0_AM = 0x00040000 ;alignment check
126	CR0_NW = 0x20000000 ;not write-through	126	CR0_NW = 0x20000000 ;not write-through
127	CR0_CD = 0x40000000 ;cache disable	127	CR0_CD = 0x40000000 ;cache disable
128	CR0_PG = 0x80000000 ;paging	128	CR0_PG = 0x80000000 ;paging
129		129
130		130
131	CR4_VME = 0x000001	131	CR4_VME = 0x000001
132	CR4_PVI = 0x000002	132	CR4_PVI = 0x000002
133	CR4_TSD = 0x000004	133	CR4_TSD = 0x000004
134	CR4_DE = 0x000008	134	CR4_DE = 0x000008
135	CR4_PSE = 0x000010	135	CR4_PSE = 0x000010
136	CR4_PAE = 0x000020	136	CR4_PAE = 0x000020
137	CR4_MCE = 0x000040	137	CR4_MCE = 0x000040
138	CR4_PGE = 0x000080	138	CR4_PGE = 0x000080
139	CR4_PCE = 0x000100	139	CR4_PCE = 0x000100
140	CR4_OSFXSR = 0x000200	140	CR4_OSFXSR = 0x000200
141	CR4_OSXMMEXPT = 0x000400	141	CR4_OSXMMEXPT = 0x000400
142	CR4_OSXSAVE = 0x040000	142	CR4_OSXSAVE = 0x040000
143		143
144	XCR0_FPU_MMX = 0x0001	144	XCR0_FPU_MMX = 0x0001
145	XCR0_SSE = 0x0002	145	XCR0_SSE = 0x0002
146	XCR0_AVX = 0x0004	146	XCR0_AVX = 0x0004
147	XCR0_MPX = 0x0018	147	XCR0_MPX = 0x0018
148	XCR0_AVX512 = 0x00e0	148	XCR0_AVX512 = 0x00e0
149		149
150	MXCSR_IE = 0x0001	150	MXCSR_IE = 0x0001
151	MXCSR_DE = 0x0002	151	MXCSR_DE = 0x0002
152	MXCSR_ZE = 0x0004	152	MXCSR_ZE = 0x0004
153	MXCSR_OE = 0x0008	153	MXCSR_OE = 0x0008
154	MXCSR_UE = 0x0010	154	MXCSR_UE = 0x0010
155	MXCSR_PE = 0x0020	155	MXCSR_PE = 0x0020
156	MXCSR_DAZ = 0x0040	156	MXCSR_DAZ = 0x0040
157	MXCSR_IM = 0x0080	157	MXCSR_IM = 0x0080
158	MXCSR_DM = 0x0100	158	MXCSR_DM = 0x0100
159	MXCSR_ZM = 0x0200	159	MXCSR_ZM = 0x0200
160	MXCSR_OM = 0x0400	160	MXCSR_OM = 0x0400
161	MXCSR_UM = 0x0800	161	MXCSR_UM = 0x0800
162	MXCSR_PM = 0x1000	162	MXCSR_PM = 0x1000
163	MXCSR_FZ = 0x8000	163	MXCSR_FZ = 0x8000
164		164
165	MXCSR_INIT = MXCSR_IM + MXCSR_DM + MXCSR_ZM + MXCSR_OM + MXCSR_UM + MXCSR_PM	165	MXCSR_INIT = MXCSR_IM + MXCSR_DM + MXCSR_ZM + MXCSR_OM + MXCSR_UM + MXCSR_PM
166		166
167	EFLAGS_CF = 0x000001 ; carry flag	167	EFLAGS_CF = 0x000001 ; carry flag
168	EFLAGS_PF = 0x000004 ; parity flag	168	EFLAGS_PF = 0x000004 ; parity flag
169	EFLAGS_AF = 0x000010 ; auxiliary flag	169	EFLAGS_AF = 0x000010 ; auxiliary flag
170	EFLAGS_ZF = 0x000040 ; zero flag	170	EFLAGS_ZF = 0x000040 ; zero flag
171	EFLAGS_SF = 0x000080 ; sign flag	171	EFLAGS_SF = 0x000080 ; sign flag
172	EFLAGS_TF = 0x000100 ; trap flag	172	EFLAGS_TF = 0x000100 ; trap flag
173	EFLAGS_IF = 0x000200 ; interrupt flag	173	EFLAGS_IF = 0x000200 ; interrupt flag
174	EFLAGS_DF = 0x000400 ; direction flag	174	EFLAGS_DF = 0x000400 ; direction flag
175	EFLAGS_OF = 0x000800 ; overflow flag	175	EFLAGS_OF = 0x000800 ; overflow flag
176	EFLAGS_IOPL = 0x003000 ; i/o priviledge level	176	EFLAGS_IOPL = 0x003000 ; i/o priviledge level
177	EFLAGS_NT = 0x004000 ; nested task flag	177	EFLAGS_NT = 0x004000 ; nested task flag
178	EFLAGS_RF = 0x010000 ; resume flag	178	EFLAGS_RF = 0x010000 ; resume flag
179	EFLAGS_VM = 0x020000 ; virtual 8086 mode flag	179	EFLAGS_VM = 0x020000 ; virtual 8086 mode flag
180	EFLAGS_AC = 0x040000 ; alignment check flag	180	EFLAGS_AC = 0x040000 ; alignment check flag
181	EFLAGS_VIF = 0x080000 ; virtual interrupt flag	181	EFLAGS_VIF = 0x080000 ; virtual interrupt flag
182	EFLAGS_VIP = 0x100000 ; virtual interrupt pending	182	EFLAGS_VIP = 0x100000 ; virtual interrupt pending
183	EFLAGS_ID = 0x200000 ; id flag	183	EFLAGS_ID = 0x200000 ; id flag
184		184
185	IRQ_PIC = 0	185	IRQ_PIC = 0
186	IRQ_APIC = 1	186	IRQ_APIC = 1
187		187
188	struct TSS	188	struct TSS
189	_back rw 2	189	_back rw 2
190	_esp0 rd 1	190	_esp0 rd 1
191	_ss0 rw 2	191	_ss0 rw 2
192	_esp1 rd 1	192	_esp1 rd 1
193	_ss1 rw 2	193	_ss1 rw 2
194	_esp2 rd 1	194	_esp2 rd 1
195	_ss2 rw 2	195	_ss2 rw 2
196	_cr3 rd 1	196	_cr3 rd 1
197	_eip rd 1	197	_eip rd 1
198	_eflags rd 1	198	_eflags rd 1
199	_eax rd 1	199	_eax rd 1
200	_ecx rd 1	200	_ecx rd 1
201	_edx rd 1	201	_edx rd 1
202	_ebx rd 1	202	_ebx rd 1
203	_esp rd 1	203	_esp rd 1
204	_ebp rd 1	204	_ebp rd 1
205	_esi rd 1	205	_esi rd 1
206	_edi rd 1	206	_edi rd 1
207	_es rw 2	207	_es rw 2
208	_cs rw 2	208	_cs rw 2
209	_ss rw 2	209	_ss rw 2
210	_ds rw 2	210	_ds rw 2
211	_fs rw 2	211	_fs rw 2
212	_gs rw 2	212	_gs rw 2
213	_ldt rw 2	213	_ldt rw 2
214	_trap rw 1	214	_trap rw 1
215	_io rw 1	215	_io rw 1
216	rb 24	216	rb 24
217	_io_map_0 rb 4096	217	_io_map_0 rb 4096
218	_io_map_1 rb 4096	218	_io_map_1 rb 4096
219	ends	219	ends
220		220
221	DRIVE_DATA_SIZE = 16	221	DRIVE_DATA_SIZE = 16
222		222
223	OS_BASE = 0x80000000	223	OS_BASE = 0x80000000
224		224
225	window_data = OS_BASE + 0x0001000	225	window_data = OS_BASE + 0x0001000
226		226
227	TASK_TABLE = OS_BASE + 0x0003000	227	;TASK_TABLE = OS_BASE + 0x0003000
228	;CURRENT_TASK = OS_BASE + 0x0003000	228	;CURRENT_TASK = OS_BASE + 0x0003000
229	;TASK_COUNT = OS_BASE + 0x0003004	229	;TASK_COUNT = OS_BASE + 0x0003004
230	TASK_BASE = OS_BASE + 0x0003010	230	;TASK_BASE = OS_BASE + 0x0003010
231	TASK_DATA = OS_BASE + 0x0003020	231	;TASK_DATA = OS_BASE + 0x0003020
232	;TASK_EVENT = OS_BASE + 0x0003020	232	;TASK_EVENT = OS_BASE + 0x0003020
233		233
234	CDDataBuf = OS_BASE + 0x0005000	234	CDDataBuf = OS_BASE + 0x0005000
235		235
236	;unused 0x6000 - 0x8fff	236	;unused 0x6000 - 0x8fff
237		237
238	BOOT_VARS = 0x9000	238	BOOT_VARS = 0x9000
239		239
240	idts = OS_BASE + 0x000B100	240	idts = OS_BASE + 0x000B100
241	WIN_STACK = OS_BASE + 0x000C000	241	WIN_STACK = OS_BASE + 0x000C000
242	WIN_POS = OS_BASE + 0x000C400	242	WIN_POS = OS_BASE + 0x000C400
243	FDD_BUFF = OS_BASE + 0x000D000 ;512	243	FDD_BUFF = OS_BASE + 0x000D000 ;512
244		244
245	WIN_TEMP_XY = OS_BASE + 0x000F300	245	WIN_TEMP_XY = OS_BASE + 0x000F300
246	KEY_COUNT = OS_BASE + 0x000F400	246	KEY_COUNT = OS_BASE + 0x000F400
247	KEY_BUFF = OS_BASE + 0x000F401 ; 1202 + 22 = 244 bytes, actually 255 bytes	247	KEY_BUFF = OS_BASE + 0x000F401 ; 1202 + 22 = 244 bytes, actually 255 bytes
248		248
249	BTN_COUNT = OS_BASE + 0x000F500	249	BTN_COUNT = OS_BASE + 0x000F500
250	BTN_BUFF = OS_BASE + 0x000F501	250	BTN_BUFF = OS_BASE + 0x000F501
251		251
252		252
253	BTN_ADDR = OS_BASE + 0x000FE88	253	BTN_ADDR = OS_BASE + 0x000FE88
254	MEM_AMOUNT = OS_BASE + 0x000FE8C	254	MEM_AMOUNT = OS_BASE + 0x000FE8C
255		255
256	SYS_SHUTDOWN = OS_BASE + 0x000FF00	256	SYS_SHUTDOWN = OS_BASE + 0x000FF00
257		257
258		258
259	TMP_STACK_TOP = 0x007CC00	259	TMP_STACK_TOP = 0x007CC00
260		260
261	sys_proc = OS_BASE + 0x007E000	261	sys_proc = OS_BASE + 0x007E000
262		262
263	SLOT_BASE = OS_BASE + 0x0080000	263	SLOT_BASE = OS_BASE + 0x0080000
264		264
265	VGABasePtr = OS_BASE + 0x00A0000	265	VGABasePtr = OS_BASE + 0x00A0000
266		266
267	virtual at OS_BASE + 0x05FFF80	267	virtual at OS_BASE + 0x05FFF80
268	tss TSS	268	tss TSS
269	end virtual	269	end virtual
270		270
271	HEAP_BASE = OS_BASE + 0x0800000	271	HEAP_BASE = OS_BASE + 0x0800000
272	HEAP_MIN_SIZE = 0x01000000	272	HEAP_MIN_SIZE = 0x01000000
273		273
274	page_tabs = 0xFDC00000	274	page_tabs = 0xFDC00000
275	app_page_tabs = 0xFDC00000	275	app_page_tabs = 0xFDC00000
276	kernel_tabs = page_tabs + (OS_BASE shr 10) ;0xFDE00000	276	kernel_tabs = page_tabs + (OS_BASE shr 10) ;0xFDE00000
277	master_tab = page_tabs + (page_tabs shr 10) ;0xFDFF70000	277	master_tab = page_tabs + (page_tabs shr 10) ;0xFDFF70000
278		278
279	LFB_BASE = 0xFE000000	279	LFB_BASE = 0xFE000000
280		280
281		281
282	new_app_base = 0;	282	new_app_base = 0;
283		283
284	twdw = TASK_TABLE - window_data	284	;twdw = TASK_TABLE - window_data
285		285
286	std_application_base_address = new_app_base	286	std_application_base_address = new_app_base
287	RING0_STACK_SIZE = 0x2000	287	RING0_STACK_SIZE = 0x2000
288		288
289	REG_SS = RING0_STACK_SIZE - 4	289	REG_SS = RING0_STACK_SIZE - 4
290	REG_APP_ESP = RING0_STACK_SIZE - 8	290	REG_APP_ESP = RING0_STACK_SIZE - 8
291	REG_EFLAGS = RING0_STACK_SIZE - 12	291	REG_EFLAGS = RING0_STACK_SIZE - 12
292	REG_CS = RING0_STACK_SIZE - 16	292	REG_CS = RING0_STACK_SIZE - 16
293	REG_EIP = RING0_STACK_SIZE - 20	293	REG_EIP = RING0_STACK_SIZE - 20
294	REG_EAX = RING0_STACK_SIZE - 24	294	REG_EAX = RING0_STACK_SIZE - 24
295	REG_ECX = RING0_STACK_SIZE - 28	295	REG_ECX = RING0_STACK_SIZE - 28
296	REG_EDX = RING0_STACK_SIZE - 32	296	REG_EDX = RING0_STACK_SIZE - 32
297	REG_EBX = RING0_STACK_SIZE - 36	297	REG_EBX = RING0_STACK_SIZE - 36
298	REG_ESP = RING0_STACK_SIZE - 40 ;RING0_STACK_SIZE-20	298	REG_ESP = RING0_STACK_SIZE - 40 ;RING0_STACK_SIZE-20
299	REG_EBP = RING0_STACK_SIZE - 44	299	REG_EBP = RING0_STACK_SIZE - 44
300	REG_ESI = RING0_STACK_SIZE - 48	300	REG_ESI = RING0_STACK_SIZE - 48
301	REG_EDI = RING0_STACK_SIZE - 52	301	REG_EDI = RING0_STACK_SIZE - 52
302	REG_RET = RING0_STACK_SIZE - 56 ;irq0.return	302	REG_RET = RING0_STACK_SIZE - 56 ;irq0.return
303		303
304		304
305	PAGE_SIZE = 4096	305	PAGE_SIZE = 4096
306		306
307	PG_UNMAP = 0x000	307	PG_UNMAP = 0x000
308	PG_READ = 0x001	308	PG_READ = 0x001
309	PG_WRITE = 0x002	309	PG_WRITE = 0x002
310	PG_USER = 0x004	310	PG_USER = 0x004
311	PG_PCD = 0x008	311	PG_PCD = 0x008
312	PG_PWT = 0x010	312	PG_PWT = 0x010
313	PG_ACCESSED = 0x020	313	PG_ACCESSED = 0x020
314	PG_DIRTY = 0x040	314	PG_DIRTY = 0x040
315	PG_PAT = 0x080	315	PG_PAT = 0x080
316	PG_GLOBAL = 0x100	316	PG_GLOBAL = 0x100
317	PG_SHARED = 0x200	317	PG_SHARED = 0x200
318		318
319	PG_SWR = 0x003 ; PG_WRITE + PG_READ	319	PG_SWR = 0x003 ; PG_WRITE + PG_READ
320	PG_UR = 0x005 ; PG_USER + PG_READ	320	PG_UR = 0x005 ; PG_USER + PG_READ
321	PG_UWR = 0x007 ; PG_USER + PG_WRITE + PG_READ	321	PG_UWR = 0x007 ; PG_USER + PG_WRITE + PG_READ
322	PG_NOCACHE = 0x018 ; PG_PCD + PG_PWT	322	PG_NOCACHE = 0x018 ; PG_PCD + PG_PWT
323		323
324	PDE_LARGE = 0x080	324	PDE_LARGE = 0x080
325		325
326	MEM_WB = 6 ; write-back memory	326	MEM_WB = 6 ; write-back memory
327	MEM_WC = 1 ; write combined memory	327	MEM_WC = 1 ; write combined memory
328	MEM_UC = 0 ; uncached memory	328	MEM_UC = 0 ; uncached memory
329		329
330	PAT_WB = 0x000	330	PAT_WB = 0x000
331	PAT_WC = 0x008	331	PAT_WC = 0x008
332	PAT_UCM = 0x010	332	PAT_UCM = 0x010
333	PAT_UC = 0x018	333	PAT_UC = 0x018
334		334
335	PAT_TYPE_UC = 0	335	PAT_TYPE_UC = 0
336	PAT_TYPE_WC = 1	336	PAT_TYPE_WC = 1
337	PAT_TYPE_WB = 6	337	PAT_TYPE_WB = 6
338	PAT_TYPE_UCM = 7	338	PAT_TYPE_UCM = 7
339		339
340	PAT_VALUE = 0x00070106; (UC<<24)\|(UCM<<16)\|(WC<<8)\|WB	340	PAT_VALUE = 0x00070106; (UC<<24)\|(UCM<<16)\|(WC<<8)\|WB
341		341
342	MAX_MEMMAP_BLOCKS = 32	342	MAX_MEMMAP_BLOCKS = 32
343		343
344	EVENT_REDRAW = 0x00000001	344	EVENT_REDRAW = 0x00000001
345	EVENT_KEY = 0x00000002	345	EVENT_KEY = 0x00000002
346	EVENT_BUTTON = 0x00000004	346	EVENT_BUTTON = 0x00000004
347	EVENT_BACKGROUND = 0x00000010	347	EVENT_BACKGROUND = 0x00000010
348	EVENT_MOUSE = 0x00000020	348	EVENT_MOUSE = 0x00000020
349	EVENT_IPC = 0x00000040	349	EVENT_IPC = 0x00000040
350	EVENT_NETWORK = 0x00000080	350	EVENT_NETWORK = 0x00000080
351	EVENT_DEBUG = 0x00000100	351	EVENT_DEBUG = 0x00000100
352	EVENT_NETWORK2 = 0x00000200	352	EVENT_NETWORK2 = 0x00000200
353	EVENT_EXTENDED = 0x00000400	353	EVENT_EXTENDED = 0x00000400
354		354
355	EV_INTR = 1	355	EV_INTR = 1
356		356
357	STDIN_FILENO = 0	357	STDIN_FILENO = 0
358	STDOUT_FILENO = 1	358	STDOUT_FILENO = 1
359	STDERR_FILENO = 2	359	STDERR_FILENO = 2
360		360
361	SYSTEM_SHUTDOWN = 2	361	SYSTEM_SHUTDOWN = 2
362	SYSTEM_REBOOT = 3	362	SYSTEM_REBOOT = 3
363	SYSTEM_RESTART = 4	363	SYSTEM_RESTART = 4
364		364
365	BLIT_CLIENT_RELATIVE = 0x20000000	365	BLIT_CLIENT_RELATIVE = 0x20000000
366		366
367	struct SYSCALL_STACK	367	struct SYSCALL_STACK
368	_eip dd ?	368	_eip dd ?
369	_edi dd ? ; +4	369	_edi dd ? ; +4
370	_esi dd ? ; +8	370	_esi dd ? ; +8
371	_ebp dd ? ; +12	371	_ebp dd ? ; +12
372	_esp dd ? ; +16	372	_esp dd ? ; +16
373	_ebx dd ? ; +20	373	_ebx dd ? ; +20
374	_edx dd ? ; +24	374	_edx dd ? ; +24
375	_ecx dd ? ; +28	375	_ecx dd ? ; +28
376	_eax dd ? ; +32	376	_eax dd ? ; +32
377	ends	377	ends
378		378
379	struct LHEAD	379	struct LHEAD
380	next dd ? ;next object in list	380	next dd ? ;next object in list
381	prev dd ? ;prev object in list	381	prev dd ? ;prev object in list
382	ends	382	ends
383		383
384	struct MUTEX_WAITER	384	struct MUTEX_WAITER
385	list LHEAD	385	list LHEAD
386	task dd ?	386	task dd ?
387	type dd ?	387	type dd ?
388	ends	388	ends
389		389
390	struct MUTEX	390	struct MUTEX
391	wait_list LHEAD	391	wait_list LHEAD
392	count dd ?	392	count dd ?
393	ends	393	ends
394		394
395	struct RWSEM	395	struct RWSEM
396	wait_list LHEAD	396	wait_list LHEAD
397	count dd ?	397	count dd ?
398	ends	398	ends
399		399
400	struct FUTEX	400	struct FUTEX
401	list LHEAD	401	list LHEAD
402	magic dd ?	402	magic dd ?
403	handle dd ?	403	handle dd ?
404	destroy dd ?	404	destroy dd ?
405		405
406	wait_list LHEAD	406	wait_list LHEAD
407	pointer dd ?	407	pointer dd ?
408	flags dd ?	408	flags dd ?
409	ends	409	ends
410		410
411	FUTEX_INIT = 0	411	FUTEX_INIT = 0
412	FUTEX_DESTROY = 1	412	FUTEX_DESTROY = 1
413	FUTEX_WAIT = 2	413	FUTEX_WAIT = 2
414	FUTEX_WAKE = 3	414	FUTEX_WAKE = 3
415		415
416	struct FILED	416	struct FILED
417	list LHEAD	417	list LHEAD
418	magic rd 1	418	magic rd 1
419	handle rd 1	419	handle rd 1
420	destroy rd 1	420	destroy rd 1
421	mode rd 1	421	mode rd 1
422	file rd 1	422	file rd 1
423	ends	423	ends
424		424
425	struct PIPE	425	struct PIPE
426	pipe_ops rd 1	426	pipe_ops rd 1
427	buffer rd 1	427	buffer rd 1
428	readers rd 1	428	readers rd 1
429	writers rd 1	429	writers rd 1
430		430
431	pipe_lock MUTEX	431	pipe_lock MUTEX
432	count rd 1	432	count rd 1
433		433
434	read_end rd 1	434	read_end rd 1
435	write_end rd 1	435	write_end rd 1
436	rlist LHEAD	436	rlist LHEAD
437	wlist LHEAD	437	wlist LHEAD
438	ends	438	ends
439		439
440	struct PROC	440	struct PROC
441	list LHEAD	441	list LHEAD
442	thr_list LHEAD	442	thr_list LHEAD
443	heap_lock MUTEX	443	heap_lock MUTEX
444	heap_base rd 1	444	heap_base rd 1
445	heap_top rd 1	445	heap_top rd 1
446	mem_used rd 1	446	mem_used rd 1
447	dlls_list_ptr rd 1	447	dlls_list_ptr rd 1
448	pdt_0_phys rd 1	448	pdt_0_phys rd 1
449	pdt_1_phys rd 1	449	pdt_1_phys rd 1
450	io_map_0 rd 1	450	io_map_0 rd 1
451	io_map_1 rd 1	451	io_map_1 rd 1
452		452
453	ht_lock rd 1	453	ht_lock rd 1
454	ht_free rd 1 ;htab[0] stdin	454	ht_free rd 1 ;htab[0] stdin
455	ht_next rd 1 ;htab[1] stdout	455	ht_next rd 1 ;htab[1] stdout
456	htab rd 1024-PROC.htab/4 ;htab[2] stderr	456	htab rd 1024-PROC.htab/4 ;htab[2] stderr
457	pdt_0 rd 1024	457	pdt_0 rd 1024
458	ends	458	ends
459		459
460	struct DBG_REGS	460	struct DBG_REGS
461	dr0 dd ?	461	dr0 dd ?
462	dr1 dd ?	462	dr1 dd ?
463	dr2 dd ?	463	dr2 dd ?
464	dr3 dd ?	464	dr3 dd ?
465	dr7 dd ?	465	dr7 dd ?
466	ends	466	ends
467		467
468	struct POINT	468	struct POINT
469	x dd ?	469	x dd ?
470	y dd ?	470	y dd ?
471	ends	471	ends
472		472
473	struct RECT	473	struct RECT
474	left dd ?	474	left dd ?
475	top dd ?	475	top dd ?
476	right dd ?	476	right dd ?
477	bottom dd ?	477	bottom dd ?
478	ends	478	ends
479		479
480	struct BOX	480	struct BOX
481	left dd ?	481	left dd ?
482	top dd ?	482	top dd ?
483	width dd ?	483	width dd ?
484	height dd ?	484	height dd ?
485	ends	485	ends
486		486
487	; Fields, marked as R now not used, but will be used soon,	487	; Fields, marked as R now not used, but will be used soon,
488	; when legacy TASKDATA structure will be deleted	488	; when legacy TASKDATA structure will be deleted
489	struct APPDATA	489	struct APPDATA
490	app_name rb 11	490	app_name rb 11
491	rb 5	491	rb 5
492		492
493	list LHEAD ;+16	493	list LHEAD ;+16
494	process dd ? ;+24	494	process dd ? ;+24
495	fpu_state dd ? ;+28	495	fpu_state dd ? ;+28
496	exc_handler dd ? ;+32	496	exc_handler dd ? ;+32
497	except_mask dd ? ;+36	497	except_mask dd ? ;+36
498	pl0_stack dd ? ;+40	498	pl0_stack dd ? ;+40
499	cursor dd ? ;+44	499	cursor dd ? ;+44
500	fd_ev dd ? ;+48	500	fd_ev dd ? ;+48

Subversion Repositories Kolibri OS

(root)/kernel/trunk/const.inc – Rev 9608 → 9709