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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2022. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 9848 $
 
 
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;
 
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 ?    ;  +0
        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
                        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
        temp_cursor     dd 0            ;+252  ; temporary place to save cursor
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 9831	Rev 9848
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2022. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2022. 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: 9831 $	8	$Revision: 9848 $
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	std_application_base_address = new_app_base	284	std_application_base_address = new_app_base
285	RING0_STACK_SIZE = 0x2000	285	RING0_STACK_SIZE = 0x2000
286		286
287	REG_SS = RING0_STACK_SIZE - 4	287	REG_SS = RING0_STACK_SIZE - 4
288	REG_APP_ESP = RING0_STACK_SIZE - 8	288	REG_APP_ESP = RING0_STACK_SIZE - 8
289	REG_EFLAGS = RING0_STACK_SIZE - 12	289	REG_EFLAGS = RING0_STACK_SIZE - 12
290	REG_CS = RING0_STACK_SIZE - 16	290	REG_CS = RING0_STACK_SIZE - 16
291	REG_EIP = RING0_STACK_SIZE - 20	291	REG_EIP = RING0_STACK_SIZE - 20
292	REG_EAX = RING0_STACK_SIZE - 24	292	REG_EAX = RING0_STACK_SIZE - 24
293	REG_ECX = RING0_STACK_SIZE - 28	293	REG_ECX = RING0_STACK_SIZE - 28
294	REG_EDX = RING0_STACK_SIZE - 32	294	REG_EDX = RING0_STACK_SIZE - 32
295	REG_EBX = RING0_STACK_SIZE - 36	295	REG_EBX = RING0_STACK_SIZE - 36
296	REG_ESP = RING0_STACK_SIZE - 40 ;RING0_STACK_SIZE-20	296	REG_ESP = RING0_STACK_SIZE - 40 ;RING0_STACK_SIZE-20
297	REG_EBP = RING0_STACK_SIZE - 44	297	REG_EBP = RING0_STACK_SIZE - 44
298	REG_ESI = RING0_STACK_SIZE - 48	298	REG_ESI = RING0_STACK_SIZE - 48
299	REG_EDI = RING0_STACK_SIZE - 52	299	REG_EDI = RING0_STACK_SIZE - 52
300	REG_RET = RING0_STACK_SIZE - 56 ;irq0.return	300	REG_RET = RING0_STACK_SIZE - 56 ;irq0.return
301		301
302		302
303	PAGE_SIZE = 4096	303	PAGE_SIZE = 4096
304		304
305	PG_UNMAP = 0x000	305	PG_UNMAP = 0x000
306	PG_READ = 0x001	306	PG_READ = 0x001
307	PG_WRITE = 0x002	307	PG_WRITE = 0x002
308	PG_USER = 0x004	308	PG_USER = 0x004
309	PG_PCD = 0x008	309	PG_PCD = 0x008
310	PG_PWT = 0x010	310	PG_PWT = 0x010
311	PG_ACCESSED = 0x020	311	PG_ACCESSED = 0x020
312	PG_DIRTY = 0x040	312	PG_DIRTY = 0x040
313	PG_PAT = 0x080	313	PG_PAT = 0x080
314	PG_GLOBAL = 0x100	314	PG_GLOBAL = 0x100
315	PG_SHARED = 0x200	315	PG_SHARED = 0x200
316		316
317	PG_SWR = 0x003 ; PG_WRITE + PG_READ	317	PG_SWR = 0x003 ; PG_WRITE + PG_READ
318	PG_UR = 0x005 ; PG_USER + PG_READ	318	PG_UR = 0x005 ; PG_USER + PG_READ
319	PG_UWR = 0x007 ; PG_USER + PG_WRITE + PG_READ	319	PG_UWR = 0x007 ; PG_USER + PG_WRITE + PG_READ
320	PG_NOCACHE = 0x018 ; PG_PCD + PG_PWT	320	PG_NOCACHE = 0x018 ; PG_PCD + PG_PWT
321		321
322	PDE_LARGE = 0x080	322	PDE_LARGE = 0x080
323		323
324	MEM_WB = 6 ; write-back memory	324	MEM_WB = 6 ; write-back memory
325	MEM_WC = 1 ; write combined memory	325	MEM_WC = 1 ; write combined memory
326	MEM_UC = 0 ; uncached memory	326	MEM_UC = 0 ; uncached memory
327		327
328	PAT_WB = 0x000	328	PAT_WB = 0x000
329	PAT_WC = 0x008	329	PAT_WC = 0x008
330	PAT_UCM = 0x010	330	PAT_UCM = 0x010
331	PAT_UC = 0x018	331	PAT_UC = 0x018
332		332
333	PAT_TYPE_UC = 0	333	PAT_TYPE_UC = 0
334	PAT_TYPE_WC = 1	334	PAT_TYPE_WC = 1
335	PAT_TYPE_WB = 6	335	PAT_TYPE_WB = 6
336	PAT_TYPE_UCM = 7	336	PAT_TYPE_UCM = 7
337		337
338	PAT_VALUE = 0x00070106; (UC<<24)\|(UCM<<16)\|(WC<<8)\|WB	338	PAT_VALUE = 0x00070106; (UC<<24)\|(UCM<<16)\|(WC<<8)\|WB
339		339
340	MAX_MEMMAP_BLOCKS = 32	340	MAX_MEMMAP_BLOCKS = 32
341		341
342	EVENT_REDRAW = 0x00000001	342	EVENT_REDRAW = 0x00000001
343	EVENT_KEY = 0x00000002	343	EVENT_KEY = 0x00000002
344	EVENT_BUTTON = 0x00000004	344	EVENT_BUTTON = 0x00000004
345	EVENT_BACKGROUND = 0x00000010	345	EVENT_BACKGROUND = 0x00000010
346	EVENT_MOUSE = 0x00000020	346	EVENT_MOUSE = 0x00000020
347	EVENT_IPC = 0x00000040	347	EVENT_IPC = 0x00000040
348	EVENT_NETWORK = 0x00000080	348	EVENT_NETWORK = 0x00000080
349	EVENT_DEBUG = 0x00000100	349	EVENT_DEBUG = 0x00000100
350	EVENT_NETWORK2 = 0x00000200	350	EVENT_NETWORK2 = 0x00000200
351	EVENT_EXTENDED = 0x00000400	351	EVENT_EXTENDED = 0x00000400
352		352
353	EV_INTR = 1	353	EV_INTR = 1
354		354
355	STDIN_FILENO = 0	355	STDIN_FILENO = 0
356	STDOUT_FILENO = 1	356	STDOUT_FILENO = 1
357	STDERR_FILENO = 2	357	STDERR_FILENO = 2
358		358
359	SYSTEM_SHUTDOWN = 2	359	SYSTEM_SHUTDOWN = 2
360	SYSTEM_REBOOT = 3	360	SYSTEM_REBOOT = 3
361	SYSTEM_RESTART = 4	361	SYSTEM_RESTART = 4
362		362
363	BLIT_CLIENT_RELATIVE = 0x20000000	363	BLIT_CLIENT_RELATIVE = 0x20000000
364		364
365	struct SYSCALL_STACK	365	struct SYSCALL_STACK
366	eip dd ? ; +0	366	eip dd ? ; +0
367	edi dd ? ; +4	367	edi dd ? ; +4
368	esi dd ? ; +8	368	esi dd ? ; +8
369	ebp dd ? ; +12	369	ebp dd ? ; +12
370	esp dd ? ; +16	370	esp dd ? ; +16
371	ebx dd ? ; +20	371	ebx dd ? ; +20
372	edx dd ? ; +24	372	edx dd ? ; +24
373	ecx dd ? ; +28	373	ecx dd ? ; +28
374	eax dd ? ; +32	374	eax dd ? ; +32
375	ends	375	ends
376		376
377	struct LHEAD	377	struct LHEAD
378	next dd ? ;next object in list	378	next dd ? ;next object in list
379	prev dd ? ;prev object in list	379	prev dd ? ;prev object in list
380	ends	380	ends
381		381
382	struct MUTEX_WAITER	382	struct MUTEX_WAITER
383	list LHEAD	383	list LHEAD
384	task dd ?	384	task dd ?
385	type dd ?	385	type dd ?
386	ends	386	ends
387		387
388	struct MUTEX	388	struct MUTEX
389	wait_list LHEAD	389	wait_list LHEAD
390	count dd ?	390	count dd ?
391	ends	391	ends
392		392
393	struct RWSEM	393	struct RWSEM
394	wait_list LHEAD	394	wait_list LHEAD
395	count dd ?	395	count dd ?
396	ends	396	ends
397		397
398	struct FUTEX	398	struct FUTEX
399	list LHEAD	399	list LHEAD
400	magic dd ?	400	magic dd ?
401	handle dd ?	401	handle dd ?
402	destroy dd ?	402	destroy dd ?
403		403
404	wait_list LHEAD	404	wait_list LHEAD
405	pointer dd ?	405	pointer dd ?
406	flags dd ?	406	flags dd ?
407	ends	407	ends
408		408
409	FUTEX_INIT = 0	409	FUTEX_INIT = 0
410	FUTEX_DESTROY = 1	410	FUTEX_DESTROY = 1
411	FUTEX_WAIT = 2	411	FUTEX_WAIT = 2
412	FUTEX_WAKE = 3	412	FUTEX_WAKE = 3
413		413
414	struct FILED	414	struct FILED
415	list LHEAD	415	list LHEAD
416	magic rd 1	416	magic rd 1
417	handle rd 1	417	handle rd 1
418	destroy rd 1	418	destroy rd 1
419	mode rd 1	419	mode rd 1
420	file rd 1	420	file rd 1
421	ends	421	ends
422		422
423	struct PIPE	423	struct PIPE
424	pipe_ops rd 1	424	pipe_ops rd 1
425	buffer rd 1	425	buffer rd 1
426	readers rd 1	426	readers rd 1
427	writers rd 1	427	writers rd 1
428		428
429	pipe_lock MUTEX	429	pipe_lock MUTEX
430	count rd 1	430	count rd 1
431		431
432	read_end rd 1	432	read_end rd 1
433	write_end rd 1	433	write_end rd 1
434	rlist LHEAD	434	rlist LHEAD
435	wlist LHEAD	435	wlist LHEAD
436	ends	436	ends
437		437
438	struct PROC	438	struct PROC
439	list LHEAD	439	list LHEAD
440	thr_list LHEAD	440	thr_list LHEAD
441	heap_lock MUTEX	441	heap_lock MUTEX
442	heap_base rd 1	442	heap_base rd 1
443	heap_top rd 1	443	heap_top rd 1
444	mem_used rd 1	444	mem_used rd 1
445	dlls_list_ptr rd 1	445	dlls_list_ptr rd 1
446	pdt_0_phys rd 1	446	pdt_0_phys rd 1
447	pdt_1_phys rd 1	447	pdt_1_phys rd 1
448	io_map_0 rd 1	448	io_map_0 rd 1
449	io_map_1 rd 1	449	io_map_1 rd 1
450		450
451	ht_lock rd 1	451	ht_lock rd 1
452	ht_free rd 1 ;htab[0] stdin	452	ht_free rd 1 ;htab[0] stdin
453	ht_next rd 1 ;htab[1] stdout	453	ht_next rd 1 ;htab[1] stdout
454	htab rd 1024-PROC.htab/4 ;htab[2] stderr	454	htab rd 1024-PROC.htab/4 ;htab[2] stderr
455	pdt_0 rd 1024	455	pdt_0 rd 1024
456	ends	456	ends
457		457
458	struct DBG_REGS	458	struct DBG_REGS
459	dr0 dd ?	459	dr0 dd ?
460	dr1 dd ?	460	dr1 dd ?
461	dr2 dd ?	461	dr2 dd ?
462	dr3 dd ?	462	dr3 dd ?
463	dr7 dd ?	463	dr7 dd ?
464	ends	464	ends
465		465
466	struct POINT	466	struct POINT
467	x dd ?	467	x dd ?
468	y dd ?	468	y dd ?
469	ends	469	ends
470		470
471	struct RECT	471	struct RECT
472	left dd ?	472	left dd ?
473	top dd ?	473	top dd ?
474	right dd ?	474	right dd ?
475	bottom dd ?	475	bottom dd ?
476	ends	476	ends
477		477
478	struct BOX	478	struct BOX
479	left dd ?	479	left dd ?
480	top dd ?	480	top dd ?
481	width dd ?	481	width dd ?
482	height dd ?	482	height dd ?
483	ends	483	ends
484		484
485	; Fields, marked as R now not used, but will be used soon,	485	; Fields, marked as R now not used, but will be used soon,
486	; when legacy TASKDATA structure will be deleted	486	; when legacy TASKDATA structure will be deleted
487	struct APPDATA	487	struct APPDATA
488	app_name rb 11	488	app_name rb 11
489	rb 5	489	rb 5
490		490
491	list LHEAD ;+16	491	list LHEAD ;+16
492	process dd ? ;+24	492	process dd ? ;+24
493	fpu_state dd ? ;+28	493	fpu_state dd ? ;+28
494	exc_handler dd ? ;+32	494	exc_handler dd ? ;+32
495	except_mask dd ? ;+36	495	except_mask dd ? ;+36
496	pl0_stack dd ? ;+40	496	pl0_stack dd ? ;+40
497	cursor dd ? ;+44	497	cursor dd ? ;+44
498	fd_ev dd ? ;+48	498	fd_ev dd ? ;+48
499	bk_ev dd ? ;+52	499	bk_ev dd ? ;+52
500	fd_obj dd ? ;+56	500	fd_obj dd ? ;+56

Subversion Repositories Kolibri OS

(root)/kernel/trunk/const.inc – Rev 9831 → 9848