Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 3625 → Rev 3626

/kernel/branches/Kolibri-acpi/blkdev/disk.inc
335,8 → 335,7
push ebx esi ; save used registers to be stdcall
; 1. Allocate the DISK structure.
; 1a. Call the heap manager.
push sizeof.DISK
pop eax
movi eax, sizeof.DISK
call malloc
; 1b. Check the result. If allocation failed, return (go to 9) with eax = 0.
test eax, eax
608,15 → 607,13
 
; The default implementation of DISKFUNC.querymedia.
disk_default_querymedia:
push DISK_STATUS_INVALID_CALL
pop eax
movi eax, DISK_STATUS_INVALID_CALL
ret 8
 
; The default implementation of DISKFUNC.read and DISKFUNC.write.
disk_default_read:
disk_default_write:
push DISK_STATUS_INVALID_CALL
pop eax
movi eax, DISK_STATUS_INVALID_CALL
ret 20
 
; The default implementation of DISKFUNC.close, DISKFUNC.closemedia and
1002,8 → 999,7
jnz .success
; 3. No file system has recognized the volume, so just allocate the PARTITION
; structure without extra fields.
push sizeof.PARTITION
pop eax
movi eax, sizeof.PARTITION
call malloc
test eax, eax
jz .nothing
/kernel/branches/Kolibri-acpi/blkdev/rd.inc
1252,8 → 1252,7
stosd
pop edi
xor eax, eax
push 8
pop ebx
movi ebx, 8
lea ecx, [edi+8]
.loop:
lodsb
1538,8 → 1537,7
push ecx edi
mov ecx, 8
repnz scasb
push 1
pop eax ; 1 entry
movi eax, 1 ; 1 entry
jnz .notilde
; we need ceil(strlen(esi)/13) additional entries = floor((strlen(esi)+12+13)/13) total
xor eax, eax
1764,8 → 1762,7
add esp, 20
mov [esp+16], ebx
popad
push ERROR_DISK_FULL
pop eax
movi eax, ERROR_DISK_FULL
ret
.writedir:
mov edi, eax
1957,8 → 1954,7
jb @b
.fat_err:
pop ecx
push ERROR_FAT_TABLE
pop eax
movi eax, ERROR_FAT_TABLE
stc
ret
@@:
2033,8 → 2029,7
pop edi ecx
pop esi edx
stc
push ERROR_DISK_FULL
pop eax
movi eax, ERROR_DISK_FULL
ret
 
fat_update_datetime:
/kernel/branches/Kolibri-acpi/bootloader/extended_primary_loader/cdfs/bootsect.asm
50,8 → 50,7
; get file system information
; scan for Primary Volume Descriptor
db 66h
push 10h-1
pop eax
movi eax, 10h-1
pvd_scan_loop:
mov cx, 1
inc eax
/kernel/branches/Kolibri-acpi/bus/pci/pci32.inc
680,8 → 680,7
jmp .no_device
.has_device:
push eax
push sizeof.PCIDEV
pop eax
movi eax, sizeof.PCIDEV
call malloc
pop ecx
test eax, eax
/kernel/branches/Kolibri-acpi/bus/usb/ehci.inc
330,8 → 330,7
; 2b. Fill first 32 entries.
inc eax
inc eax ; set Type to EHCI_TYPE_QH
push 32
pop ecx
movi ecx, 32
mov edx, ecx
@@:
stosd
434,14 → 433,12
; now edi = MMIOBase2
; 6. Transfer the controller to a known state.
; 6b. Stop the controller if it is running.
push 10
pop ecx
movi ecx, 10
test dword [edi+EhciStatusReg], 1 shl 12
jnz .stopped
and dword [edi+EhciCommandReg], not 1
@@:
push 1
pop esi
movi esi, 1
call delay_ms
test dword [edi+EhciStatusReg], 1 shl 12
jnz .stopped
451,11 → 448,9
.stopped:
; 6c. Reset the controller. Wait up to 50 ms checking status every 1 ms.
or dword [edi+EhciCommandReg], 2
push 50
pop ecx
movi ecx, 50
@@:
push 1
pop esi
movi esi, 1
call delay_ms
test dword [edi+EhciCommandReg], 2
jz .reset_ok
515,8 → 510,7
test byte [esi+ehci_controller.StructuralParams-sizeof.ehci_controller], 10h
jz @f
push esi
push 20
pop esi
movi esi, 20
call delay_ms
pop esi
@@:
676,8 → 670,7
test al, 1
jz .has_ownership
push esi
push 1
pop esi
movi esi, 1
call delay_ms
pop esi
dec dword [esp]
862,8 → 855,7
push eax ecx
sub edi, ehci_pipe.SoftwarePart
xor eax, eax
push ehci_pipe.SoftwarePart/4
pop ecx
movi ecx, ehci_pipe.SoftwarePart/4
rep stosd
pop ecx eax
; 2. Setup PID in the first TD and make sure that the it is not active.
883,8 → 875,7
and eax, 3FFF0000h
; Use 1 requests per microframe for control/bulk endpoints,
; use value from the endpoint descriptor for periodic endpoints
push 1
pop edx
movi edx, 1
test [.type], 1
jz @f
mov edx, [.maxpacket]
1292,8 → 1283,7
@@:
; 3. Call the worker procedure to notify the protocol layer
; about new EHCI device. It is high-speed.
push USB_SPEED_HS
pop eax
movi eax, USB_SPEED_HS
call ehci_new_device
test eax, eax
jnz .nothing
1794,8 → 1784,7
; all corresponding bits are set. In this case, return some error code,
; the order is quite arbitrary.
pop eax ; status
push USB_STATUS_UNDERRUN
pop ecx
movi ecx, USB_STATUS_UNDERRUN
test al, 40h ; not Halted?
jz .know_error
mov cl, USB_STATUS_OVERRUN
/kernel/branches/Kolibri-acpi/bus/usb/hccommon.inc
398,8 → 398,7
jnc @f
or byte [esp], 1 shl CONTROL_PIPE
@@:
push 4
pop edx
movi edx, 4
call usb_process_one_wait_list
jnc @f
or byte [esp], 1 shl INTERRUPT_PIPE
/kernel/branches/Kolibri-acpi/bus/usb/hub.inc
253,8 → 253,7
; 2a. Save registers.
push edx
; 2b. Call the allocator.
push 40
pop eax
movi eax, 40
call malloc
; 2c. Restore registers.
pop ecx
/kernel/branches/Kolibri-acpi/bus/usb/init.inc
131,8 → 131,7
proc create_usb_thread
; 1. Create the thread.
push edi
push 1
pop ebx
movi ebx, 1
mov ecx, usb_thread_proc
xor edx, edx
call new_sys_threads
/kernel/branches/Kolibri-acpi/bus/usb/ohci.inc
351,8 → 351,7
lea esi, [eax+ohci_controller.IntEDs+32*sizeof.ohci_static_ep]
call get_pg_addr
add eax, ohci_controller.IntEDs
push 32
pop ecx
movi ecx, 32
mov edx, ecx
@@:
stosd
429,10 → 428,8
; 5c. Save FmInterval register.
pushd [edi+OhciFmIntervalReg]
; 5d. Issue software reset and wait up to 10ms, checking status every 1 ms.
push 1
pop ecx
push 10
pop edx
movi ecx, 1
movi edx, 10
mov [edi+OhciCommandStatusReg], ecx
@@:
mov esi, ecx
633,14 → 630,12
; (This should generate SMI, BIOS should release its ownership in SMI handler.)
mov dword [eax+OhciCommandStatusReg], 8
; 4c. Wait for result no more than 50 ms, checking for status every 1 ms.
push 50
pop ecx
movi ecx, 50
@@:
test dword [eax+OhciControlReg], edx
jz .has_ownership
push esi
push 1
pop esi
movi esi, 1
call delay_ms
pop esi
loop @b
984,8 → 979,7
; if so, return an error.
lea edx, [esi + ohci_controller.IntEDs - sizeof.ohci_controller]
lea eax, [esi + ohci_controller.IntEDs + 32*sizeof.ohci_static_ep - sizeof.ohci_controller]
push 64
pop ecx
movi ecx, 64
call usb1_select_interrupt_list
test edx, edx
jz .return0
/kernel/branches/Kolibri-acpi/bus/usb/scheduler.inc
206,8 → 206,7
sub ecx, 3
cmp ecx, 5 ; maximum 32ms
jbe @f
push 5
pop ecx
movi ecx, 5
@@:
; There are four nested loops,
; * Loop #4 (the innermost one) calculates the total periodic bandwidth
221,10 → 220,8
; ebx = number of iterations of loop #1
; [esp] = delta of counter for loop #3, in bytes
; [esp+4] = delta between the first group and the target group, in bytes
push 1
pop ebx
push sizeof.ehci_static_ep
pop edx
movi ebx, 1
movi edx, sizeof.ehci_static_ep
shl ebx, cl
shl edx, cl
mov eax, 64*sizeof.ehci_static_ep
282,8 → 279,7
ja @f
mov [.bandwidth], edi
mov [.target], edx
push 1
pop eax
movi eax, 1
shl eax, cl
mov [.targetsmask], eax
@@:
317,8 → 313,7
mov ecx, [.targetsmask]
add [edx+ehci_static_ep.Bandwidths+ecx*2], ax
add edx, ehci_static_ep.SoftwarePart
push 1
pop eax
movi eax, 1
shl eax, cl
pop edi ebx ; restore used registers to be stdcall
ret
371,8 → 366,7
end virtual
; 10. Select the best variant.
; edx = S-Mask = bitmask of scheduled microframes
push 0x11
pop edx
movi edx, 0x11
cmp ecx, 1
ja @f
mov dl, 0x55
/kernel/branches/Kolibri-acpi/bus/usb/uhci.inc
315,8 → 315,7
; 2b. Fill first 32 entries.
inc eax
inc eax ; set QH bit for uhci_pipe.NextQH
push 32
pop ecx
movi ecx, 32
mov edx, ecx
@@:
stosd
416,12 → 415,10
mov ax, 2
out dx, ax
; 5f. Wait up to 10ms.
push 10
pop ecx
movi ecx, 10
@@:
push esi
push 1
pop esi
movi esi, 1
call delay_ms
pop esi
in ax, dx
435,8 → 432,7
; emergency variant for tests - always wait 10 ms
; wait 10 ms
push esi
push 10
pop esi
movi esi, 10
call delay_ms
pop esi
; clear reset signal
998,8 → 994,7
; * if several non-fatal errors have occured during transaction retries,
; all corresponding bits are set. In this case, return some error code,
; the order is quite arbitrary.
push USB_STATUS_UNDERRUN
pop ecx
movi ecx, USB_STATUS_UNDERRUN
test al, 1 shl (22-16) ; not Stalled?
jz .know_error
mov cl, USB_STATUS_OVERRUN
1260,8 → 1255,7
; 2. Status bits in UHCI are invalid during reset signalling.
; Wait a millisecond while status bits become valid again.
push esi
push 1
pop esi
movi esi, 1
call delay_ms
pop esi
; 3. ConnectStatus bit is zero during reset and becomes 1 during step 2;
1458,8 → 1452,7
; if so, return an error.
lea edx, [esi + uhci_controller.IntEDs - sizeof.uhci_controller]
lea eax, [esi + uhci_controller.IntEDs + 32*sizeof.uhci_static_ep - sizeof.uhci_controller]
push 64
pop ecx
movi ecx, 64
call usb1_select_interrupt_list
test edx, edx
jz .return0
/kernel/branches/Kolibri-acpi/core/exports.inc
66,7 → 66,7
szLoadCursor db 'LoadCursor',0
 
szSysMsgBoardStr db 'SysMsgBoardStr', 0
szSysMsgBoardChar db 'SysMsgBoardChar', 0
szSysMsgBoard db 'SysMsgBoard', 0
szGetCurrentTask db 'GetCurrentTask',0
szLFBAddress db 'LFBAddress',0
szLoadFile db 'LoadFile',0
163,7 → 163,7
dd szLoadCursor , load_cursor ;stdcall
 
dd szSysMsgBoardStr , sys_msg_board_str
dd szSysMsgBoardChar , sys_msg_board
dd szSysMsgBoard , sys_msg_board
dd szGetCurrentTask , get_curr_task
dd szLoadFile , load_file ;retval eax, ebx
dd szSendEvent , send_event ;see EVENT.inc for specification
/kernel/branches/Kolibri-acpi/core/irq.inc
273,6 → 273,12
mov ecx, ebp
call irq_eoi
 
; IRQ handler could make some kernel thread ready; reschedule
mov bl, SCHEDULE_HIGHER_PRIORITY
call find_next_task
jz .return ; if there is only one running process
call do_change_task
.return:
restore_ring3_context
add esp, 4
iret
/kernel/branches/Kolibri-acpi/core/sched.inc
31,6 → 31,7
call irq_eoi
; btr dword[DONT_SWITCH], 0
; jc .return
mov bl, SCHEDULE_ANY_PRIORITY
call find_next_task
jz .return ; if there is only one running process
call do_change_task
58,6 → 59,7
.find_next_task:
; \end{Mario79}
end if
mov bl, SCHEDULE_ANY_PRIORITY
call find_next_task
jz .return ; the same task -> skip switch
@@:
324,8 → 326,16
ret
endp
 
SCHEDULE_ANY_PRIORITY = 0
SCHEDULE_HIGHER_PRIORITY = 1
;info:
; Find next task to execute
;in:
; bl = SCHEDULE_ANY_PRIORITY:
; consider threads with any priority
; bl = SCHEDULE_HIGHER_PRIORITY:
; consider only threads with strictly higher priority than the current one,
; keep running the current thread if other ready threads have the same or lower priority
;retval:
; ebx = address of the APPDATA for the selected task (slot-base)
; edi = address of the TASKDATA for the selected task
337,6 → 347,18
proc find_next_task
call update_counters
spin_lock_irqsave SchedulerLock
push NR_SCHED_QUEUES
; If bl == SCHEDULE_ANY_PRIORITY = 0, loop over all NR_SCHED lists.
; Otherwise, loop over first [APPDATA.priority] lists.
test bl, bl
jz .start
mov ebx, [current_slot]
mov edi, [TASK_BASE]
mov eax, [ebx+APPDATA.priority]
test eax, eax
jz .unlock_found
mov [esp], eax
.start:
xor ecx, ecx
.priority_loop:
mov ebx, [scheduler_current+ecx*4]
370,6 → 392,18
mov [edi+TASKDATA.state], 0
.task_found:
mov [scheduler_current+ecx*4], ebx
; If we have selected a thread with higher priority
; AND rescheduling is due to IRQ,
; turn the current scheduler list one entry back,
; so the current thread will be next after high-priority thread is done.
mov ecx, [esp]
cmp ecx, NR_SCHED_QUEUES
jz .unlock_found
mov eax, [current_slot]
mov eax, [eax+APPDATA.in_schedule.prev]
mov [scheduler_current+ecx*4], eax
.unlock_found:
pop ecx
spin_unlock_irqrestore SchedulerLock
.found:
mov [CURRENT_TASK], bh
383,10 → 417,11
jnz .task_loop
.priority_next:
inc ecx
cmp ecx, NR_SCHED_QUEUES
cmp ecx, [esp]
jb .priority_loop
hlt
jmp $-1
mov ebx, [current_slot]
mov edi, [TASK_BASE]
jmp .unlock_found
endp
 
if 0
/kernel/branches/Kolibri-acpi/core/sys32.inc
160,7 → 160,11
;mov edx, [TASK_BASE]
mov [edx + TASKDATA.state], byte 4 ; terminate
call wakeup_osloop
jmp change_task ; stack - here it does not matter at all, SEE: core/shed.inc
call change_task
; If we're here, then the main OS thread has crashed before initializing IDLE thread.
; Or they both have crashed. Anyway, things are hopelessly broken.
hlt
jmp $-1
.debug:
; we are debugged process, notify debugger and suspend ourself
; eax=debugger PID
504,8 → 508,7
mov eax, [SLOT_BASE+edi*8+APPDATA.debugger_slot]
test eax, eax
jz .nodebug
push 8
pop ecx
movi ecx, 8
push dword [CURRENT_TASK+edi+TASKDATA.pid]; PID
push 2
call debugger_notify
/kernel/branches/Kolibri-acpi/core/syscall.inc
121,8 → 121,8
dd 0
dd 0
dd 0
dd 0 ; 62-PCI functions
dd sys_msg_board ; 63-System message board
dd 0
dd 0
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; NEW SYSTEM FUNCTIONS TABLE ;;
192,8 → 192,8
dd undefined_syscall ; 59-reserved
dd sys_IPC ; 60-Inter Process Communication
dd sys_gs ; 61-Direct graphics access
dd pci_api ;cross_order ; 62-PCI functions
dd cross_order ; 63-System message board
dd pci_api ; 62-PCI functions
dd sys_msg_board ; 63-System message board
dd sys_resize_app_memory ; 64-Resize application memory usage
dd sys_putimage_palette ; 65-PutImagePalette
dd sys_process_def ; 66-Process definitions - keyboard
/kernel/branches/Kolibri-acpi/core/timers.inc
82,8 → 82,7
timerFunc:dword, userData:dword
; 1. Allocate memory for the TIMER structure.
; 1a. Call the allocator.
push sizeof.TIMER
pop eax
movi eax, sizeof.TIMER
call malloc
; 1b. If allocation failed, return (go to 5) with eax = 0.
test eax, eax
/kernel/branches/Kolibri-acpi/data32.inc
323,6 → 323,8
endofcode:
gdte:
 
diff16 "end of .data segment",0,$
 
align 16
cur_saved_data:
rb 4096
336,6 → 338,7
MEM_AMOUNT rd 1
 
cpu_freq rq 1
 
heap_mutex MUTEX
heap_size rd 1
heap_free rd 1
365,18 → 368,24
_WinMapAddress rd 1
_WinMapSize rd 1
 
LFBAddress rd 1
Screen_Max_X rd 1
Screen_Max_Y rd 1
 
LFBAddress rd 1
BytesPerScanLine rd 1
SCR_MODE rw 2
 
PUTPIXEL rd 1
GETPIXEL rd 1
 
if VESA_1_2_VIDEO
BANK_SWITCH rd 1 reserved for vesa 1.2
BANK_RW rd 1
end if
 
REDRAW_BACKGROUND rb 4
 
mouseunder rd 16*24
 
MOUSE_PICTURE rd 1
 
MOUSE_SCROLL_H rw 1
429,7 → 438,6
KEY_COUNT rb 4
KEY_BUFF rb 128
 
mouseunder rd 16*24
 
SYS_SHUTDOWN rb 4
 
548,10 → 556,12
BiosDiskCaches rb 80h*(cache_ide1-cache_ide0)
BiosDiskPartitions rd 80h
 
align 16
DRIVE_DATA: rb DRIVE_DATA_SIZE
 
align 4096
 
SLOT_BASE: rb 64*1024
DRIVE_DATA: rb 64*1024
RESERVED_PORTS: rb 64*1024
FLOPPY_BUFF: rb 16*1024
BUTTON_INFO: rb 16*1024
/kernel/branches/Kolibri-acpi/detect/dev_fd.inc
15,7 → 15,7
;***************************************************
xor eax, eax
mov edi, DRIVE_DATA
mov ecx, 16384
mov ecx, DRIVE_DATA_SIZE/4
cld
rep stosd
 
/kernel/branches/Kolibri-acpi/drivers/imports.inc
75,7 → 75,7
HwCursorCreate,\
\
SysMsgBoardStr,\
SysMsgBoardChar,\
SysMsgBoard,\
GetCurrentTask,\
LoadFile,\
SendEvent,\
/kernel/branches/Kolibri-acpi/drivers/usbhid.asm
234,8 → 234,7
; 8 bytes for a packet and 8 bytes for previous packet, used by a keyboard.
; 9. Initialize device data.
mov [ebx+device_data.intpipe], eax
push 8
pop ecx
movi ecx, 8
cmp edx, ecx
jb @f
mov edx, ecx
364,8 → 363,7
jb .controlloop
.nocontrol:
; 3. Initialize before loop for normal keys. esi = index.
push 2
pop esi
movi esi, 2
.normalloop:
; 4. Process one key which was pressed in the previous packet.
; 4a. Get the next pressed key from the previous packet.
486,8 → 484,7
 
; Auxiliary procedure for keyboard_data_ready.
haskey:
push 2
pop edx
movi edx, 2
@@:
cmp byte [ecx+edx], al
jz @f
/kernel/branches/Kolibri-acpi/drivers/usbstor.asm
298,8 → 298,7
.UserData dd ? ; request_queue_item.UserData
end virtual
; 1. Allocate the memory for the request description.
push request_queue_item.sizeof
pop eax
movi eax, request_queue_item.sizeof
call Kmalloc
test eax, eax
jnz @f
1004,10 → 1003,8
; 4. Thus, create a temporary kernel thread which would do it.
mov edx, [esp+8]
push ebx ecx
push 51
pop eax
push 1
pop ebx
movi eax, 51
movi ebx, 1
mov ecx, new_disk_thread
; edx = parameter
int 0x40
1069,8 → 1066,7
cmp [edx+usb_unit_data.UnitReadyAttempts], 3
jz @f
push ecx edx esi
push 10
pop esi
movi esi, 10
call Sleep
pop esi edx ecx
stdcall queue_request, ecx, test_unit_ready_req, 0, test_unit_ready_callback, edx
1124,8 → 1120,7
mov byte [edi-1], 'd'
push eax
push -'0'
push 10
pop ecx
movi ecx, 10
@@:
cdq
div ecx
/kernel/branches/Kolibri-acpi/fdo.inc
241,10 → 241,9
debug_func fdo_debug_outchar
debug_beginf
pushad
movzx ebx, al
mov eax, 1
mov ecx, sys_msg_board
call ecx ; sys_msg_board
movzx ecx, al
mov ebx, 1
call sys_msg_board
popad
ret
debug_endf
251,15 → 250,14
 
debug_func fdo_debug_outstr
debug_beginf
mov eax, 1
mov ebx, 1
.l1:
dec esi
js .l2
movzx ebx, byte[edx]
or bl, bl
movzx ecx, byte[edx]
or cl, cl
jz .l2
mov ecx, sys_msg_board
call ecx ; sys_msg_board
call sys_msg_board
inc edx
jmp .l1
.l2:
278,8 → 276,7
call fdo_debug_outchar
pop eax
@@:
push 10
pop ecx
movi ecx, 10
push -'0'
.l1:
xor edx, edx
/kernel/branches/Kolibri-acpi/fs/fat12.inc
1311,8 → 1311,7
push ecx edi
mov ecx, 8
repnz scasb
push 1
pop eax ; 1 entry
movi eax, 1 ; 1 entry
jnz .notilde
; we need ceil(strlen(esi)/13) additional entries = floor((strlen(esi)+12+13)/13) total
xor eax, eax
1822,8 → 1821,7
jb @b
.fat_err:
pop ecx
push ERROR_FAT_TABLE
pop eax
movi eax, ERROR_FAT_TABLE
stc
ret
@@:
1885,8 → 1883,7
pop edi ecx
pop esi edx
stc
push ERROR_DISK_FULL
pop eax
movi eax, ERROR_DISK_FULL
ret
 
;----------------------------------------------------------------
/kernel/branches/Kolibri-acpi/fs/fat32.inc
167,8 → 167,7
; in the normal operation, let's hope for the best and allocate data now; if
; it will prove wrong, just deallocate it.
push ebx
push sizeof.FAT
pop eax
movi eax, sizeof.FAT
call malloc
pop ebx
test eax, eax
972,8 → 971,7
jz ntfs_HdReadFolder
cmp [fs_type], 2
jz ext2_HdReadFolder
push ERROR_UNSUPPORTED_FS
pop eax
movi eax, ERROR_UNSUPPORTED_FS
or ebx, -1
ret
@@:
1659,8 → 1657,7
push ecx edi
mov ecx, 8
repnz scasb
push 1
pop eax ; 1 entry
movi eax, 1 ; 1 entry
jnz .notilde
; we need ceil(strlen(esi)/13) additional entries = floor((strlen(esi)+12+13)/13) total
xor eax, eax
2362,8 → 2359,7
jmp .device_err2
.disk_full:
pop eax edx esi
push ERROR_DISK_FULL
pop eax
movi eax, ERROR_DISK_FULL
stc
ret
 
2390,8 → 2386,7
jz ntfs_HdSetFileEnd
cmp [fs_type], 2
jz ext2_HdSetFileEnd
push ERROR_UNKNOWN_FS
pop eax
movi eax, ERROR_UNKNOWN_FS
ret
@@:
sub ebx, 4
2566,8 → 2561,7
pop eax ecx eax edi
call update_disk
call fat_unlock
push ERROR_DEVICE
pop eax
movi eax, ERROR_DEVICE
ret
@@:
; we will zero data at the end of last sector - remember it
2640,8 → 2634,7
pop eax ecx eax edi
call update_disk
call fat_unlock
push ERROR_FAT_TABLE
pop eax
movi eax, ERROR_FAT_TABLE
ret
 
fs_HdGetFileInfo:
2771,8 → 2764,7
jz ntfs_HdDelete
cmp [fs_type], 2
jz ext2_HdDelete
push ERROR_UNKNOWN_FS
pop eax
movi eax, ERROR_UNKNOWN_FS
ret
@@:
sub ebx, 4
2866,15 → 2858,13
.err2:
pop edi
call fat_unlock
push ERROR_DEVICE
pop eax
movi eax, ERROR_DEVICE
ret
.error_fat:
popad
pop edi
call fat_unlock
push ERROR_FAT_TABLE
pop eax
movi eax, ERROR_FAT_TABLE
ret
.notempty:
popad
2881,8 → 2871,7
.access_denied2:
pop edi
call fat_unlock
push ERROR_ACCESS_DENIED
pop eax
movi eax, ERROR_ACCESS_DENIED
ret
.empty:
popad
/kernel/branches/Kolibri-acpi/fs/fs_lfn.inc
683,61 → 683,43
fs_HasRamdisk:
mov al, 1 ; we always have ramdisk
ret
 
fs_HasFloppy:
cmp byte [DRIVE_DATA], 0
setnz al
ret
 
fs_HasHd0:
mov al, [DRIVE_DATA+1]
and al, 11000000b
cmp al, 01000000b
setz al
test byte [DRIVE_DATA+1], 01000000b
setnz al
ret
fs_HasHd1:
mov al, [DRIVE_DATA+1]
and al, 00110000b
cmp al, 00010000b
setz al
test byte [DRIVE_DATA+1], 00010000b
setnz al
ret
fs_HasHd2:
mov al, [DRIVE_DATA+1]
and al, 00001100b
cmp al, 00000100b
setz al
test byte [DRIVE_DATA+1], 00000100b
setnz al
ret
fs_HasHd3:
mov al, [DRIVE_DATA+1]
and al, 00000011b
cmp al, 00000001b
setz al
test byte [DRIVE_DATA+1], 00000001b
setnz al
ret
 
;*******************************************************
fs_HasCd0:
mov al, [DRIVE_DATA+1]
and al, 11000000b
cmp al, 10000000b
setz al
test byte [DRIVE_DATA+1], 10000000b
setnz al
ret
fs_HasCd1:
mov al, [DRIVE_DATA+1]
and al, 00110000b
cmp al, 00100000b
setz al
test byte [DRIVE_DATA+1], 00100000b
setnz al
ret
fs_HasCd2:
mov al, [DRIVE_DATA+1]
and al, 00001100b
cmp al, 00001000b
setz al
test byte [DRIVE_DATA+1], 00001000b
setnz al
ret
fs_HasCd3:
mov al, [DRIVE_DATA+1]
and al, 00000011b
cmp al, 00000010b
setz al
test byte [DRIVE_DATA+1], 00000010b
setnz al
ret
;*******************************************************
 
/kernel/branches/Kolibri-acpi/fs/ntfs.inc
1139,15 → 1139,13
cmp byte [esi], 0
jnz @f
or ebx, -1
push ERROR_ACCESS_DENIED
pop eax
movi eax, ERROR_ACCESS_DENIED
ret
@@:
call ntfs_find_lfn
jnc .found
or ebx, -1
push ERROR_FILE_NOT_FOUND
pop eax
movi eax, ERROR_FILE_NOT_FOUND
ret
.found:
mov [ntfs_cur_attr], 0x80 ; $DATA
1156,8 → 1154,7
call ntfs_read_attr
jnc @f
or ebx, -1
push ERROR_ACCESS_DENIED
pop eax
movi eax, ERROR_ACCESS_DENIED
ret
@@:
pushad
1171,8 → 1168,7
popad
xor ebx, ebx
.eof:
push ERROR_END_OF_FILE
pop eax
movi eax, ERROR_END_OF_FILE
ret
@@:
mov eax, [ebx]
1349,8 → 1345,7
.nomem:
popad
or ebx, -1
push 12
pop eax
movi eax, 12
ret
@@:
mov [ntfs_data.cur_index_buf], eax
1804,14 → 1799,12
ntfs_HdGetFileInfo:
cmp byte [esi], 0
jnz @f
push 2
pop eax
movi eax, 2
ret
@@:
call ntfs_find_lfn
jnc .doit
push ERROR_FILE_NOT_FOUND
pop eax
movi eax, ERROR_FILE_NOT_FOUND
cmp [hd_error], 0
jz @f
mov al, 11
/kernel/branches/Kolibri-acpi/hid/keyboard.inc
139,8 → 139,7
 
register_keyboard:
push ebx
push sizeof.KEYBOARD
pop eax
movi eax, sizeof.KEYBOARD
call malloc
test eax, eax
jz .nothing
/kernel/branches/Kolibri-acpi/kernel.asm
75,6 → 75,7
 
 
USE_COM_IRQ equ 1 ; make irq 3 and irq 4 available for PCI devices
VESA_1_2_VIDEO equ 0 ; enable vesa 1.2 bank switch functions
 
; Enabling the next line will enable serial output console
;debug_com_base equ 0x3f8 ; 0x3f8 is com1, 0x2f8 is com2, 0x3e8 is com3, 0x2e8 is com4, no irq's are used
230,6 → 231,10
 
include "data16.inc"
 
if ~ lang eq sp
diff16 "end of bootcode",0,$+0x10000
end if
 
use32
org $+0x10000
 
406,18 → 411,17
mov [Screen_Max_Y], eax
mov [screen_workarea.bottom], eax
movzx eax, word [BOOT_VAR+BOOT_VESA_MODE]; screen mode
mov [SCR_MODE], eax
mov dword [SCR_MODE], eax
; mov eax, [BOOT_VAR+0x9014] ; Vesa 1.2 bnk sw add
; mov [BANK_SWITCH], eax
mov [BytesPerScanLine], word 640*4 ; Bytes PerScanLine
mov eax, 640 *4 ; Bytes PerScanLine
cmp [SCR_MODE], word 0x13 ; 320x200
je @f
cmp [SCR_MODE], word 0x12 ; VGA 640x480
je @f
movzx eax, word[BOOT_VAR+BOOT_PITCH] ; for other modes
mov [BytesPerScanLine], ax
@@:
mov [_display.pitch], eax
@@:
mov eax, [_display.width]
mul [_display.height]
mov [_WinMapSize], eax
658,6 → 662,10
; Initialize system timer (IRQ0)
call PIT_init
 
; CALCULATE FAT CHAIN FOR RAMDISK
 
call calculatefatchain
 
mov esi, boot_initapic
call boot_log
; Try to Initialize APIC
714,10 → 722,7
;!!!!!!!!!!!!!!!!!!!!!!!
end if
; mov [dma_hdd],1
; CALCULATE FAT CHAIN FOR RAMDISK
 
call calculatefatchain
 
if 0
mov ax, [OS_BASE+0x10000+bx_from_load]
cmp ax, 'r1'; if using not ram disk, then load librares and parameters {SPraid.simba}
1241,13 → 1246,10
xor eax, eax
mov [BTN_ADDR], dword BUTTON_INFO ; address of button list
 
mov byte [MOUSE_BUFF_COUNT], al ; mouse buffer
mov byte [KEY_COUNT], al ; keyboard buffer
mov byte [BTN_COUNT], al ; button buffer
; mov [MOUSE_X],dword 100*65536+100 ; mouse x/y
 
;!! IP 04.02.2005:
; mov byte [DONT_SWITCH], al; change task if possible
pop eax
ret
 
2036,10 → 2038,9
mov [eax+TASKDATA.state], 3; terminate this program
call wakeup_osloop
 
waitterm: ; wait here for termination
mov ebx, 100
call delay_hs
jmp waitterm
.waitterm: ; wait here for termination
call change_task
jmp .waitterm
;------------------------------------------------------------------------------
align 4
restore_default_cursor_before_killing:
2325,7 → 2326,7
dec ecx
jnz exit_for_anyone
call for_all_tables
mov ecx, 16384
mov ecx, DRIVE_DATA_SIZE/4
cld
rep movsd
ret
2493,7 → 2494,7
pushfd
cli
mov eax, ecx
mov ecx, [BytesPerScanLine]
mov ecx, [_display.pitch]
mov [_display.width], eax
dec eax
mov [_display.height], edx
3519,24 → 3520,24
cmp [edi+SLOT_BASE+APPDATA.draw_bgr_x], 0
jz .set
.join:
cmp word [edi+SLOT_BASE+APPDATA.draw_bgr_x], ax
jae @f
mov word [edi+SLOT_BASE+APPDATA.draw_bgr_x], ax
@@:
shr eax, 16
cmp word [edi+SLOT_BASE+APPDATA.draw_bgr_x+2], ax
jbe @f
mov word [edi+SLOT_BASE+APPDATA.draw_bgr_x+2], ax
@@:
shr eax, 16
cmp word [edi+SLOT_BASE+APPDATA.draw_bgr_x], ax
cmp word [edi+SLOT_BASE+APPDATA.draw_bgr_y], dx
jae @f
mov word [edi+SLOT_BASE+APPDATA.draw_bgr_x], ax
mov word [edi+SLOT_BASE+APPDATA.draw_bgr_y], dx
@@:
shr edx, 16
cmp word [edi+SLOT_BASE+APPDATA.draw_bgr_y+2], dx
jbe @f
mov word [edi+SLOT_BASE+APPDATA.draw_bgr_y+2], dx
@@:
shr edx, 16
cmp word [edi+SLOT_BASE+APPDATA.draw_bgr_y], dx
jae @f
mov word [edi+SLOT_BASE+APPDATA.draw_bgr_y], dx
@@:
jmp .common
.set:
mov [edi+SLOT_BASE+APPDATA.draw_bgr_x], eax
3850,9 → 3851,37
ret
endp
 
if 1
align 4
delay_hs: ; delay in 1/100 secs
; ebx = delay time
 
pushad
push ebx
xor esi, esi
mov ecx, MANUAL_DESTROY
call create_event
test eax, eax
jz .done
 
mov ebx, edx
mov ecx, [esp]
push edx
push eax
call wait_event_timeout
pop eax
pop ebx
call destroy_event
.done:
add esp, 4
popad
ret
 
else
 
align 4
delay_hs: ; delay in 1/100 secs
; ebx = delay time
push ecx
push edx
 
3874,6 → 3903,8
pop edx
pop ecx
ret
end if
 
;-----------------------------------------------------------------------------
align 16 ;very often call this subrutine
memmove: ; memory move in bytes
4651,8 → 4682,8
@@:
cmp [esi], byte 0
je @f
mov eax, 1
movzx ebx, byte [esi]
mov ebx, 1
movzx ecx, byte [esi]
call sys_msg_board
inc esi
jmp @b
4692,9 → 4723,9
cmp al, 10
sbb al, 69h
das
mov bl, al
xor eax, eax
inc eax
mov cl, al
xor ebx, ebx
inc ebx
call sys_msg_board
pop eax
pop ecx
4711,9 → 4742,13
 
sys_msg_board:
 
; eax=1 : write : bl byte to write
; eax=2 : read : ebx=0 -> no data, ebx=1 -> data in al
; ebx=1 : write : bl byte to write
; ebx=2 : read : ebx=0 -> no data, ebx=1 -> data in al
 
push eax ebx ; Save eax and ebx, since we're restoring their order required.
mov eax, ebx
mov ebx, ecx
 
mov ecx, [msg_board_count]
cmp eax, 1
jne .smbl1
4754,7 → 4789,7
jnz @f
mov word [msg_board_pos+2], 234
add word [msg_board_pos], 10
mov ax, [Screen_Max_Y]
mov ax, word [Screen_Max_Y]
cmp word [msg_board_pos], ax
jbe @f
mov word [msg_board_pos], 10
4770,6 → 4805,8
inc ecx
and ecx, msg_board_data_size - 1
mov [msg_board_count], ecx
 
pop ebx eax
ret
.smbl1:
cmp eax, 2
4776,18 → 4813,21
jne .smbl2
test ecx, ecx
jz .smbl21
 
add esp, 8 ; Returning data in ebx and eax, so no need to restore them.
mov eax, msg_board_data+1
mov ebx, msg_board_data
movzx edx, byte [ebx]
call memmove
dec [msg_board_count]
mov [esp + 36], edx ;eax
mov [esp + 24], dword 1
mov [esp + 32], edx ;eax
mov [esp + 20], dword 1
ret
.smbl21:
mov [esp+36], ecx
mov [esp+24], ecx
mov [esp+32], ecx
mov [esp+20], ecx
.smbl2:
pop ebx eax
ret
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4969,7 → 5009,7
.1: ; resolution
mov eax, [Screen_Max_X]
shl eax, 16
mov ax, [Screen_Max_Y]
mov ax, word [Screen_Max_Y]
add eax, 0x00010001
mov [esp+32], eax
ret
4978,7 → 5018,7
mov [esp+32], eax
ret
.3: ; bytes per scanline
mov eax, [BytesPerScanLine]
mov eax, [_display.pitch]
mov [esp+32], eax
ret
 
5068,9 → 5108,9
 
align 4
syscall_getscreensize: ; GetScreenSize
mov ax, [Screen_Max_X]
mov ax, word [Screen_Max_X]
shl eax, 16
mov ax, [Screen_Max_Y]
mov ax, word [Screen_Max_Y]
mov [esp + 32], eax
ret
 
5389,7 → 5429,7
cld
@@:
stosd
add eax, [BytesPerScanLine]
add eax, [_display.pitch]
dec ecx
jnz @r
ret
5412,7 → 5452,7
 
mov [Screen_Max_X], eax
mov [Screen_Max_Y], edx
mov [BytesPerScanLine], ecx
mov [_display.pitch], ecx
 
mov [screen_workarea.right], eax
mov [screen_workarea.bottom], edx
5538,8 → 5578,7
ret
@@:
call stop_all_services
push 3 ; stop playing cd
pop eax
movi eax, 3
call sys_cd_audio
 
yes_shutdown_param:
5547,8 → 5586,7
 
if ~ defined extended_primary_loader
mov eax, kernel_file ; load kernel.mnt to 0x7000:0
push 12
pop esi
movi esi, 12
xor ebx, ebx
or ecx, -1
mov edx, OS_BASE+0x70000
5770,6 → 5808,10
ret
end if
 
if ~ lang eq sp
diff16 "end of .text segment",0,$
end if
 
include "data32.inc"
 
__REV__ = __REV
/kernel/branches/Kolibri-acpi/macros.inc
117,3 → 117,16
mov [ecx+list_fd], edx
}
 
; MOV Immediate.
; Useful for things like movi eax,10:
; shorter than regular mov, but slightly slower,
; do not use it in performance-critical places.
macro movi dst, imm
{
if imm >= -0x80 & imm <= 0x7F
push imm
pop dst
else
mov dst, imm
end if
}
/kernel/branches/Kolibri-acpi/network/ARP.inc
58,13 → 58,13
align 4
uglobal
 
NumARP dd ?
 
ARP_table rb ARP_TABLE_SIZE * sizeof.ARP_entry ; TODO: separate ARP table and stats per interface
ARP_table rb NET_DEVICES_MAX*(ARP_TABLE_SIZE * sizeof.ARP_entry)
 
ARP_PACKETS_TX rd MAX_NET_DEVICES
ARP_PACKETS_RX rd MAX_NET_DEVICES
ARP_CONFLICTS rd MAX_NET_DEVICES
ARP_entries_num rd NET_DEVICES_MAX
ARP_PACKETS_TX rd NET_DEVICES_MAX
ARP_PACKETS_RX rd NET_DEVICES_MAX
ARP_CONFLICTS rd NET_DEVICES_MAX
 
 
endg
81,10 → 81,8
macro ARP_init {
 
xor eax, eax
mov [NumARP], eax
 
mov edi, ARP_PACKETS_TX
mov ecx, 3*MAX_NET_DEVICES
mov edi, ARP_entries_num
mov ecx, 4*NET_DEVICES_MAX
rep stosd
 
}
111,11 → 109,15
; The last status value is provided to allow the network layer to delete
; a packet that is queued awaiting an ARP response
 
mov ecx, [NumARP]
xor edi, edi
.loop_outer:
mov ecx, [ARP_entries_num + 4*edi]
test ecx, ecx
jz .exit
 
mov esi, ARP_table
mov esi, (ARP_TABLE_SIZE * sizeof.ARP_entry)
imul esi, edi
add esi, ARP_table
.loop:
cmp [esi + ARP_entry.TTL], ARP_STATIC_ENTRY
je .next
133,9 → 135,9
cmp [esi + ARP_entry.Status], ARP_AWAITING_RESPONSE
je .response_timeout
 
push esi ecx
push esi edi ecx
call ARP_del_entry
pop ecx esi
pop ecx edi esi
 
jmp .next
 
146,6 → 148,9
jmp .next
 
.exit:
inc edi
cmp edi, NET_DEVICES_MAX
jb .loop_outer
 
}
 
196,11 → 201,13
 
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: It's a reply\n"
 
mov ecx, [NumARP]
mov ecx, [ARP_entries_num + 4*edi]
test ecx, ecx
jz .exit
 
mov esi, ARP_table
mov esi, (ARP_TABLE_SIZE * sizeof.ARP_entry)
imul esi, edi
add esi, ARP_table
.loop:
cmp [esi + ARP_entry.IP], eax
je .gotit
298,32 → 305,27
;
; ARP_output_request
;
; IN: ip in eax
; device in edi
; IN: ebx = device ptr
; eax = IP
; OUT: /
; scratched: probably everything
;
;---------------------------------------------------------------------------
align 4
ARP_output_request:
 
push eax ; DestIP
pushd [IP_LIST + edi] ; SenderIP
inc [ARP_PACKETS_TX + edi] ; assume we will succeed
push eax
 
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_output_request: ip=%u.%u.%u.%u\n",\
[esp + 4]:1, [esp + 5]:1, [esp + 6]:1, [esp + 7]:1
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_output_request: ip=%u.%u.%u.%u device=0x%x\n",\
[esp]:1, [esp + 1]:1, [esp + 2]:1, [esp + 3]:1, ebx
 
mov ebx, [NET_DRV_LIST + edi] ; device ptr
 
lea eax, [ebx + ETH_DEVICE.mac] ; local device mac
mov edx, ETH_BROADCAST ; broadcast mac
mov ecx, sizeof.ARP_header
mov di, ETHER_ARP
mov di, ETHER_PROTO_ARP
call ETH_output
jz .exit
 
mov ecx, eax
 
mov [edi + ARP_header.HardwareType], 0x0100 ; Ethernet
mov [edi + ARP_header.ProtocolType], 0x0008 ; IP
mov [edi + ARP_header.HardwareSize], 6 ; MAC-addr length
331,29 → 333,29
mov [edi + ARP_header.Opcode], ARP_REQ_OPCODE ; Request
 
add edi, ARP_header.SenderMAC
 
lea esi, [ebx + ETH_DEVICE.mac] ; SenderMac
movsw ;
movsd ;
pop eax ; SenderIP
stosd ;
 
mov eax, -1 ; DestMac
stosd ;
stosw ;
pop eax ; DestIP
stosd ;
; mov esi, [ebx + NET_DEVICE.number]
xor esi, esi ;;;; FIXME
inc esi ;;;;;;;;;
inc [ARP_PACKETS_TX + 4*esi] ; assume we will succeed
lea esi, [IP_LIST + 4*esi] ; SenderIP
movsd
 
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_output_request: device=%x\n", ebx
mov esi, ETH_BROADCAST ; DestMac
movsw ;
movsd ;
popd [edi] ; DestIP
 
push edx ecx
push edx eax
call [ebx + NET_DEVICE.transmit]
ret
 
.exit:
add esp, 4 + 4
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_output_request: failed\n"
sub eax, eax
add esp, 4
DEBUGF DEBUG_NETWORK_ERROR, "ARP_output_request: send failed\n"
ret
 
 
362,50 → 364,64
; ARP_add_entry (or update)
;
; IN: esi = ptr to entry (can easily be made on the stack)
; edi = device num
; OUT: eax = entry #, -1 on error
; edi = ptr to newly created entry
; esi = ptr to newly created entry
;
;----------------------------------------------------------------- ; TODO: use a mutex
align 4
ARP_add_entry:
 
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_add_entry: "
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_add_entry: device=%u\n", edi
 
mov ecx, [NumARP]
mov ecx, [ARP_entries_num + 4*edi]
cmp ecx, ARP_TABLE_SIZE ; list full ?
jae .error
jae .full
 
xor eax, eax
mov edi, ARP_table
mov ecx, [esi + ARP_entry.IP]
; From this point on, we can only fail if IP has a static entry, or if table is corrupt.
 
inc [ARP_entries_num + 4*edi] ; assume we will succeed
 
push edi
xor ecx, ecx
imul edi, ARP_TABLE_SIZE*sizeof.ARP_entry
add edi, ARP_table
mov eax, [esi + ARP_entry.IP]
.loop:
cmp [edi + ARP_entry.Status], ARP_NO_ENTRY ; is this slot empty?
je .add
 
cmp [edi + ARP_entry.IP], ecx ; if not, check if it doesnt collide
cmp [edi + ARP_entry.IP], eax ; if not, check if it doesnt collide
jne .maybe_next
 
cmp [edi + ARP_entry.TTL], ARP_STATIC_ENTRY ; ok, its the same IP, update it if not static
jne .add
 
DEBUGF DEBUG_NETWORK_ERROR, "ARP_add_entry: failed, IP already has a static entry\n"
jmp .error
 
.maybe_next: ; try the next slot
add edi, sizeof.ARP_entry
inc eax
cmp eax, ARP_TABLE_SIZE
jae .error
jmp .loop
inc ecx
cmp ecx, ARP_TABLE_SIZE
jb .loop
 
.add:
push ecx
mov ecx, sizeof.ARP_entry/2
rep movsw
inc [NumARP]
sub edi, sizeof.ARP_entry
DEBUGF DEBUG_NETWORK_VERBOSE, "entry=%u\n", eax
pop ecx
lea esi, [edi - sizeof.ARP_entry]
pop edi
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_add_entry: entry=%u\n", ecx
 
ret
 
.error:
DEBUGF DEBUG_NETWORK_VERBOSE, "failed\n"
pop edi
dec [ARP_entries_num + 4*edi]
DEBUGF DEBUG_NETWORK_ERROR, "ARP_add_entry_failed\n"
.full:
mov eax, -1
ret
 
415,6 → 431,7
; ARP_del_entry
;
; IN: esi = ptr to arp entry
; edi = device number
; OUT: /
;
;-----------------------------------------------------------------
421,23 → 438,28
align 4
ARP_del_entry:
 
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_del_entry: entry=%x entrys=%u\n", esi, [NumARP]
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_del_entry: entry=%x entrys=%u\n", esi, [ARP_entries_num + 4*edi]
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_del_entry: IP=%u.%u.%u.%u\n", \
[esi + ARP_entry.IP]:1, [esi + ARP_entry.IP + 1]:1, [esi + ARP_entry.IP + 2]:1, [esi + ARP_entry.IP + 3]:1
 
mov ecx, ARP_table + (ARP_TABLE_SIZE - 1) * sizeof.ARP_entry
push edi
imul edi, (ARP_TABLE_SIZE) * sizeof.ARP_entry
lea ecx, [ARP_table + (ARP_TABLE_SIZE - 1) * sizeof.ARP_entry + edi]
sub ecx, esi
shr ecx, 1
 
; move all trailing entries, sizeof.ARP_entry bytes to left.
mov edi, esi
add esi, sizeof.ARP_entry
rep movsw
 
; now add an empty entry to the end (erasing previous one)
xor eax, eax
mov ecx, sizeof.ARP_entry/2
rep stosw
 
dec [NumARP]
pop edi
dec [ARP_entries_num + 4*edi]
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_del_entry: success\n"
 
ret
465,7 → 487,7
 
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_IP_to_MAC: %u.%u", al, ah
rol eax, 16
DEBUGF DEBUG_NETWORK_VERBOSE, ".%u.%u\n", al, ah
DEBUGF DEBUG_NETWORK_VERBOSE, ".%u.%u device: %u\n", al, ah, edi
rol eax, 16
 
cmp eax, 0xffffffff
474,25 → 496,24
;--------------------------------
; Try to find the IP in ARP_table
 
mov ecx, [NumARP]
mov ecx, [ARP_entries_num + 4*edi]
test ecx, ecx
jz .not_in_list
mov esi, ARP_table + ARP_entry.IP
mov esi, edi
imul esi, sizeof.ARP_entry * ARP_TABLE_SIZE
add esi, ARP_table + ARP_entry.IP
.scan_loop:
cmp [esi], eax
je .found_it
add esi, sizeof.ARP_entry
loop .scan_loop
dec ecx
jnz .scan_loop
 
.not_in_list:
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_IP_to_MAC: preparing for ARP request\n"
 
;--------------------
; Send an ARP request
 
push eax edi ; save IP for ARP_output_request
 
; Now create the ARP entry
; Now craft the ARP entry on the stack
pushw ARP_REQUEST_TTL ; TTL
pushw ARP_AWAITING_RESPONSE ; status
pushd 0 ; mac
499,21 → 520,27
pushw 0
pushd eax ; ip
mov esi, esp
 
; Add it to the list
call ARP_add_entry
 
; Delete the temporary entry
add esp, sizeof.ARP_entry ; clear the entry from stack
 
; If we could not add it to the list, give up
cmp eax, -1 ; did ARP_add_entry fail?
je .full
 
mov esi, edi
pop edi eax ; IP in eax, device number in edi, for ARP_output_request
;-----------------------------------------------
; At this point, we got an ARP entry in the list
 
; Now send a request packet on the network
pop edi eax ; IP in eax, device number in ebx, for ARP_output_request
 
push esi edi
call ARP_output_request ; And send a request
mov ebx, [NET_DRV_LIST + 4*edi]
call ARP_output_request
pop edi esi
 
;-----------------------------------------------
; At this point, we got an ARP entry in the list
.found_it:
cmp [esi + ARP_entry.Status], ARP_VALID_MAPPING ; Does it have a MAC assigned?
je .valid
558,7 → 585,7
;
; ARP_API
;
; This function is called by system function 75
; This function is called by system function 76
;
; IN: subfunction number in bl
; device number in bh
606,17 → 633,19
ret
 
.entries:
mov eax, [NumARP]
mov eax, [ARP_entries_num + eax]
ret
 
.read:
cmp ecx, [NumARP]
cmp ecx, [ARP_entries_num + eax]
jae .error
shr eax, 2
imul eax, sizeof.ARP_entry*ARP_TABLE_SIZE
add eax, ARP_table
; edi = pointer to buffer
; ecx = # entry
imul ecx, sizeof.ARP_entry
add ecx, ARP_table
mov esi, ecx
lea esi, [eax + ecx]
mov ecx, sizeof.ARP_entry/2
rep movsw
 
625,20 → 654,24
 
.write:
; esi = pointer to buffer
mov edi, eax
shr edi, 2
call ARP_add_entry ; out: eax = entry number, -1 on error
ret
 
.remove:
; ecx = # entry
cmp ecx, [NumARP]
cmp ecx, [ARP_entries_num + eax]
jae .error
imul ecx, sizeof.ARP_entry
lea esi, [ARP_table + ecx]
mov edi, eax
shr edi, 2
call ARP_del_entry
ret
 
.send_announce:
mov edi, eax
mov ebx, [NET_DRV_LIST + eax]
mov eax, [IP_LIST + eax]
call ARP_output_request ; now send a gratuitous ARP
ret
/kernel/branches/Kolibri-acpi/network/IPv4.inc
58,15 → 58,15
align 4
uglobal
 
IP_LIST rd MAX_NET_DEVICES
SUBNET_LIST rd MAX_NET_DEVICES
DNS_LIST rd MAX_NET_DEVICES
GATEWAY_LIST rd MAX_NET_DEVICES
BROADCAST_LIST rd MAX_NET_DEVICES
IP_LIST rd NET_DEVICES_MAX
SUBNET_LIST rd NET_DEVICES_MAX
DNS_LIST rd NET_DEVICES_MAX
GATEWAY_LIST rd NET_DEVICES_MAX
BROADCAST_LIST rd NET_DEVICES_MAX
 
IP_packets_tx rd MAX_NET_DEVICES
IP_packets_rx rd MAX_NET_DEVICES
IP_packets_dumped rd MAX_NET_DEVICES
IP_packets_tx rd NET_DEVICES_MAX
IP_packets_rx rd NET_DEVICES_MAX
IP_packets_dumped rd NET_DEVICES_MAX
 
FRAGMENT_LIST rb MAX_FRAGMENTS * sizeof.FRAGMENT_slot
endg
83,7 → 83,7
 
xor eax, eax
mov edi, IP_LIST
mov ecx, 7*MAX_NET_DEVICES + (sizeof.FRAGMENT_slot*MAX_FRAGMENTS)/4
mov ecx, 7*NET_DEVICES_MAX + (sizeof.FRAGMENT_slot*MAX_FRAGMENTS)/4
rep stosd
 
}
568,7 → 568,7
align 4
IPv4_output:
 
DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_output: size=%u\n", ecx
DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_output: size=%u ip=0x%x\n", ecx, eax
 
cmp ecx, 65500 ; Max IPv4 packet size
ja .too_large
575,10 → 575,11
 
push ecx eax edx di
 
cmp eax, 1 shl 24 + 127
je .loopback
call IPv4_route ; outputs device number in edi, dest ip in eax
 
call IPv4_route ; outputs device number in edi, dest ip in eax
test edi, edi
jz .loopback
 
call ARP_IP_to_MAC
test eax, 0xffff0000 ; error bits
jnz .arp_error
585,14 → 586,14
push ebx ; push the mac onto the stack
push ax
 
inc [IP_packets_tx + edi] ; update stats
inc [IP_packets_tx + 4*edi] ; update stats
 
mov ebx, [NET_DRV_LIST + edi]
mov ebx, [NET_DRV_LIST + 4*edi]
lea eax, [ebx + ETH_DEVICE.mac]
mov edx, esp
mov ecx, [esp + 10 + 6]
add ecx, sizeof.IPv4_header
mov di, ETHER_IPv4
mov di, ETHER_PROTO_IPv4
call ETH_output
jz .eth_error
add esp, 6 ; pop the mac out of the stack
618,13 → 619,13
ret
 
.eth_error:
DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_output: ethernet error\n"
DEBUGF DEBUG_NETWORK_ERROR, "IPv4_output: ethernet error\n"
add esp, 3*4+2+6
xor edi, edi
ret
 
.arp_error:
DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_output: ARP error=%x\n", eax
DEBUGF DEBUG_NETWORK_ERROR, "IPv4_output: ARP error=%x\n", eax
add esp, 3*4+2
xor edi, edi
ret
635,9 → 636,10
ret
 
.loopback:
mov dword [esp + 2], eax
mov dword [esp + 2], eax ; change source IP to dest IP
mov ecx, [esp + 10]
add ecx, sizeof.IPv4_header
mov di, ETHER_IPv4
mov edi, AF_INET4
call LOOP_output
jmp .continue
 
675,13 → 677,13
push ebx ; push the mac
push ax
 
inc [IP_packets_tx + edi]
mov ebx, [NET_DRV_LIST + edi]
inc [IP_packets_tx + 4*edi]
mov ebx, [NET_DRV_LIST + 4*edi]
lea eax, [ebx + ETH_DEVICE.mac]
mov edx, esp
mov ecx, [esp + 6 + 4]
add ecx, sizeof.IPv4_header
mov di, ETHER_IPv4
mov di, ETHER_PROTO_IPv4
call ETH_output
jz .error
 
775,7 → 777,7
 
mov eax, [esp + 3*4]
lea ebx, [esp + 4*4]
mov di , ETHER_IPv4
mov di , ETHER_PROTO_IPv4
call ETH_output
 
cmp edi, -1
855,7 → 857,7
; IPv4_route
;
; IN: eax = Destination IP
; OUT: edi = device id * 4
; OUT: edi = device number
; eax = ip of gateway if nescessary, unchanged otherwise
;
;---------------------------------------------------------------------------
866,7 → 868,7
je .broadcast
 
xor edi, edi
mov ecx, MAX_NET_DEVICES
mov ecx, NET_DEVICES_MAX
.loop:
mov ebx, [IP_LIST+edi]
and ebx, [SUBNET_LIST+edi]
875,7 → 877,11
and edx, [SUBNET_LIST+edi]
 
cmp ebx, edx
je .found_it
jne .next
 
DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_route: %u\n", edi
ret
 
.next:
add edi, 4
dec ecx
882,15 → 888,10
jnz .loop
 
.invalid:
xor edi, edi ; if none found, use device 0 as default
mov eax, [GATEWAY_LIST]
 
.found_it:
DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_route: %u\n", edi
ret
 
mov eax, [GATEWAY_LIST+4] ;;; FIXME
.broadcast:
xor edi, edi
xor edi, edi ; if none found, use device 1 as default ;;;; FIXME
inc di
ret
 
 
973,7 → 974,8
or ebx, ecx
mov [BROADCAST_LIST + eax], ebx
 
mov eax, ecx
mov ebx, [NET_DRV_LIST + eax]
mov eax, [IP_LIST + eax]
call ARP_output_request ; now send a gratuitous ARP
 
call NET_send_event
/kernel/branches/Kolibri-acpi/network/IPv6.inc
34,13 → 34,13
uglobal
 
IPv6:
.addresses rd 4*MAX_NET_DEVICES
.subnet rd 4*MAX_NET_DEVICES
.dns rd 4*MAX_NET_DEVICES
.gateway rd 4*MAX_NET_DEVICES
.addresses rd 4*NET_DEVICES_MAX
.subnet rd 4*NET_DEVICES_MAX
.dns rd 4*NET_DEVICES_MAX
.gateway rd 4*NET_DEVICES_MAX
 
.packets_tx rd MAX_NET_DEVICES
.packets_rx rd MAX_NET_DEVICES
.packets_tx rd NET_DEVICES_MAX
.packets_rx rd NET_DEVICES_MAX
 
endg
 
/kernel/branches/Kolibri-acpi/network/PPPoE.inc
113,7 → 113,7
; Check that device exists and is ethernet device
mov ebx, [eax + SOCKET.device]
 
cmp ebx, MAX_NET_DEVICES
cmp ebx, NET_DEVICES_MAX
ja .bad
 
mov ebx, [NET_DRV_LIST + 4*ebx]
120,7 → 120,7
test ebx, ebx
jz .bad
 
cmp [ebx + NET_DEVICE.type], NET_TYPE_ETH
cmp [ebx + NET_DEVICE.device_type], NET_DEVICE_ETH
jne .bad
 
DEBUGF DEBUG_NETWORK_VERBOSE, "PPPoE_discovery_output: device=%x\n", ebx
148,9 → 148,9
lea esi, [ebx + ETH_DEVICE.mac]
movsd
movsw
cmp word[edi], ETHER_PPP_SESSION ; Allow only PPP_discovery, or LCP
cmp word[edi], ETHER_PROTO_PPP_SESSION ; Allow only PPP_discovery, or LCP
je @f
mov ax, ETHER_PPP_DISCOVERY
mov ax, ETHER_PROTO_PPP_DISCOVERY
stosw
@@:
 
200,10 → 200,10
mov ax, word [edx + PPPoE_frame.Payload]
add edx, PPPoE_frame.Payload + 2
 
cmp ax, PPP_IPv4
cmp ax, PPP_PROTO_IPv4
je IPv4_input
 
; cmp ax, PPP_IPv6
; cmp ax, PPP_PROTO_IPv6
; je IPv6_input
 
jmp PPPoE_discovery_input ; Send LCP,CHAP,CBCP,... packets to the PPP dialer
246,7 → 246,7
lea eax, [ebx + ETH_DEVICE.mac]
lea edx, [PPPoE_MAC]
add ecx, PPPoE_frame.Payload + 2
mov di, ETHER_PPP_SESSION
mov di, ETHER_PROTO_PPP_SESSION
call ETH_output
jz .eth_error
 
/kernel/branches/Kolibri-acpi/network/ethernet.inc
64,19 → 64,19
lea edx, [eax + sizeof.ETH_header]
mov ax, [eax + ETH_header.Type]
 
cmp ax, ETHER_IPv4
cmp ax, ETHER_PROTO_IPv4
je IPv4_input
 
cmp ax, ETHER_ARP
cmp ax, ETHER_PROTO_ARP
je ARP_input
 
cmp ax, ETHER_IPv6
cmp ax, ETHER_PROTO_IPv6
je IPv6_input
 
cmp ax, ETHER_PPP_DISCOVERY
cmp ax, ETHER_PROTO_PPP_DISCOVERY
je PPPoE_discovery_input
 
cmp ax, ETHER_PPP_SESSION
cmp ax, ETHER_PROTO_PPP_SESSION
je PPPoE_session_input
 
DEBUGF DEBUG_NETWORK_ERROR, "ETH_input: Unknown packet type=%x\n", ax
162,7 → 162,7
;
; ETH_API
;
; This function is called by system function 75
; This function is called by system function 76
;
; IN: subfunction number in bl
; device number in bh
174,11 → 174,11
align 4
ETH_api:
 
cmp bh, MAX_NET_DEVICES
cmp bh, NET_DEVICES_MAX
ja .error
movzx eax, bh
mov eax, dword [NET_DRV_LIST + 4*eax]
cmp [eax + NET_DEVICE.type], NET_TYPE_ETH
cmp [eax + NET_DEVICE.device_type], NET_DEVICE_ETH
jne .error
 
and ebx, 0xff
187,12 → 187,7
jmp dword [.table + 4*ebx]
 
.table:
dd .packets_tx ; 0
dd .packets_rx ; 1
dd .bytes_tx ; 2
dd .bytes_rx ; 3
dd .read_mac ; 4
dd .state ; 5
dd .read_mac ; 0
.number = ($ - .table) / 4 - 1
 
.error:
199,28 → 194,7
or eax, -1
ret
 
.packets_tx:
mov eax, [eax + NET_DEVICE.packets_tx]
 
ret
 
.packets_rx:
mov eax, [eax + NET_DEVICE.packets_rx]
ret
 
.bytes_tx:
mov ebx, dword [eax + NET_DEVICE.bytes_tx + 4]
mov eax, dword [eax + NET_DEVICE.bytes_tx]
mov [esp+20+4], ebx ; TODO: fix this ugly code
ret
 
.bytes_rx:
mov ebx, dword [eax + NET_DEVICE.bytes_rx + 4]
mov eax, dword [eax + NET_DEVICE.bytes_rx]
mov [esp+20+4], ebx ; TODO: fix this ugly code
ret
 
 
.read_mac:
movzx ebx, word [eax + ETH_DEVICE.mac]
mov eax, dword [eax + ETH_DEVICE.mac + 2]
227,7 → 201,4
mov [esp+20+4], ebx ; TODO: fix this ugly code
ret
 
.state:
mov eax, [eax + NET_DEVICE.state]
ret
 
/kernel/branches/Kolibri-acpi/network/icmp.inc
16,7 → 16,6
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
$Revision$
 
; ICMP types & codes
100,8 → 99,8
 
align 4
uglobal
ICMP_PACKETS_TX rd MAX_NET_DEVICES
ICMP_PACKETS_RX rd MAX_NET_DEVICES
ICMP_PACKETS_TX rd NET_DEVICES_MAX
ICMP_PACKETS_RX rd NET_DEVICES_MAX
endg
 
 
116,7 → 115,7
 
xor eax, eax
mov edi, ICMP_PACKETS_TX
mov ecx, 2*MAX_NET_DEVICES
mov ecx, 2*NET_DEVICES_MAX
rep stosd
 
}
168,9 → 167,6
 
mov esi, [esp] ; Start of buffer
 
cmp dword[edi + 4], 1 shl 24 + 127
je .loopback
 
; Update stats (and validate device ptr)
call NET_ptr_to_num
cmp edi,-1
178,6 → 174,11
inc [ICMP_PACKETS_RX + 4*edi]
inc [ICMP_PACKETS_TX + 4*edi]
 
cmp ebx, LOOPBACK_DEVICE
je .loopback
 
; FIXME: dont assume device is an ethernet device!
 
; exchange dest and source address in IP header
; exchange dest and source MAC in ETH header
push dword [esi + ETH_header.DstMAC]
188,10 → 189,10
push word [esi + ETH_header.SrcMAC + 4]
pop word [esi + ETH_header.DstMAC + 4]
pop word [esi + ETH_header.SrcMAC + 4]
add esi, sizeof.ETH_header-2
add esi, sizeof.ETH_header-4
 
.loopback:
add esi, 2
add esi, 4
push [esi + IPv4_header.SourceAddress]
push [esi + IPv4_header.DestinationAddress]
pop [esi + IPv4_header.SourceAddress]
/kernel/branches/Kolibri-acpi/network/loopback.inc
1,6 → 1,6
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Copyright (C) KolibriOS team 2004-2010. All rights reserved. ;;
;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;;
;; ;;
;; loopback.inc ;;
19,7 → 19,8
iglobal
 
LOOPBACK_DEVICE:
.type dd NET_TYPE_LOOPBACK
 
.device_type dd NET_DEVICE_LOOPBACK
.mtu dd 4096
.name dd .namestr
 
32,6 → 33,9
.packets_tx dd 0
.packets_rx dd 0
 
.link_state dd -1
.hwacc dd 0
 
.namestr db 'loopback', 0
 
.dummy_fn:
39,6 → 43,23
 
endg
 
 
macro LOOP_init {
local .fail
 
mov ebx, LOOPBACK_DEVICE
call NET_add_device
 
cmp eax, -1
je .fail
 
mov [IP_LIST], 127 + 1 shl 24
mov [SUBNET_LIST], 255
mov [BROADCAST_LIST], 0xffffff00 + 127
 
.fail:
}
 
;-----------------------------------------------------------------
;
; LOOP_input
59,12 → 80,16
push ecx
push eax
 
inc [LOOPBACK_DEVICE.packets_rx]
add dword[LOOPBACK_DEVICE.bytes_rx], ecx
adc dword[LOOPBACK_DEVICE.bytes_rx + 4], 0
 
DEBUGF DEBUG_NETWORK_VERBOSE, "LOOP_input: size=%u\n", ecx
lea edx, [eax + 2]
mov ax, word[eax]
lea edx, [eax + 4]
mov eax, dword[eax]
mov ebx, LOOPBACK_DEVICE
 
cmp ax, ETHER_IPv4
cmp eax, AF_INET4
je IPv4_input
 
DEBUGF DEBUG_NETWORK_VERBOSE, "LOOP_input: Unknown packet type=%x\n", ax
81,7 → 106,7
;
; IN:
; ecx = packet size
; di = protocol
; edi = address family
;
; OUT: edi = 0 on error, pointer to buffer otherwise
; eax = buffer start
96,9 → 121,9
DEBUGF DEBUG_NETWORK_VERBOSE, "LOOP_output\n"
 
push ecx
push di
push edi
 
add ecx, 2
add ecx, 4
cmp ecx, [LOOPBACK_DEVICE.mtu]
ja .out_of_ram
stdcall kernel_alloc, ecx
105,22 → 130,25
test eax, eax
jz .out_of_ram
mov edi, eax
pop ax
stosw
pop eax
stosd
 
lea eax, [edi - 2] ; Set eax to buffer start
lea eax, [edi - 4] ; Set eax to buffer start
pop ecx
lea edx, [ecx + 2] ; Set edx to complete buffer size
lea edx, [ecx + 4] ; Set edx to complete buffer size
mov ebx, LOOPBACK_DEVICE
 
.done:
inc [LOOPBACK_DEVICE.packets_tx]
add dword[LOOPBACK_DEVICE.bytes_tx], ecx
adc dword[LOOPBACK_DEVICE.bytes_tx + 4], 0
 
DEBUGF DEBUG_NETWORK_VERBOSE, "LOOP_output: ptr=%x size=%u\n", eax, edx
ret
 
.out_of_ram:
DEBUGF DEBUG_NETWORK_VERBOSE, "LOOP_output: failed\n"
add esp, 2+4
sub edi, edi
DEBUGF DEBUG_NETWORK_ERROR, "LOOP_output: out of memory\n"
add esp, 4+4
xor edi, edi
ret
 
 
/kernel/branches/Kolibri-acpi/network/socket.inc
127,6 → 127,7
 
;-------
; Timers
timer_flags dd ?
timer_retransmission dd ? ; rexmt
timer_persist dd ?
timer_keepalive dd ? ; keepalive/syn timeout
215,9 → 216,9
 
@@:
pseudo_random eax
cmp ax, MIN_EPHEMERAL_PORT
cmp ax, EPHEMERAL_PORT_MIN
jb @r
cmp ax, MAX_EPHEMERAL_PORT
cmp ax, EPHEMERAL_PORT_MAX
ja @r
xchg al, ah
mov [last_UDP_port], ax
224,9 → 225,9
 
@@:
pseudo_random eax
cmp ax, MIN_EPHEMERAL_PORT
cmp ax, EPHEMERAL_PORT_MIN
jb @r
cmp ax, MAX_EPHEMERAL_PORT
cmp ax, EPHEMERAL_PORT_MAX
ja @r
xchg al, ah
mov [last_TCP_port], ax
432,11 → 433,10
.tcp:
.udp:
 
mov ebx, [edx + 4] ; First, fill in the IP
cmp ebx, [edx + 4] ; First, fill in the IP
test ebx, ebx ; If IP is 0, use default
jnz @f
mov ebx, [NET_DEFAULT]
mov ebx, [IP_LIST + 4*ebx]
mov ebx, [IP_LIST + 4] ;;;;; FIXME !i!i!i
@@:
mov [eax + IP_SOCKET.LocalIP], ebx
 
483,7 → 483,7
.af_inet4:
cmp [eax + IP_SOCKET.LocalIP], 0
jne @f
push [IP_LIST] ; FIXME
push [IP_LIST + 4] ; FIXME !i!i!i!
pop [eax + IP_SOCKET.LocalIP]
@@:
 
632,7 → 632,7
 
cmp [eax + IP_SOCKET.LocalIP], 0
jne @f
push [IP_LIST]
push [IP_LIST + 4] ;;; fixme!!!!
pop [eax + IP_SOCKET.LocalIP]
@@:
 
1121,7 → 1121,7
je .unbind
 
movzx edx, byte [edx + 9]
cmp edx, MAX_NET_DEVICES
cmp edx, NET_DEVICES_MAX
ja s_error
 
mov edx, [NET_DRV_LIST + 4*edx]
/kernel/branches/Kolibri-acpi/network/stack.inc
31,24 → 31,31
DEBUG_NETWORK_ERROR = 1
DEBUG_NETWORK_VERBOSE = 0
 
MAX_NET_DEVICES = 16
NET_DEVICES_MAX = 16
ARP_BLOCK = 1 ; true or false
 
MIN_EPHEMERAL_PORT = 49152
EPHEMERAL_PORT_MIN = 49152
EPHEMERAL_PORT_MAX = 61000
MIN_EPHEMERAL_PORT_N = 0x00C0 ; same in Network byte order (FIXME)
MAX_EPHEMERAL_PORT = 61000
MAX_EPHEMERAL_PORT_N = 0x48EE ; same in Network byte order (FIXME)
 
; Ethernet protocol numbers
ETHER_ARP = 0x0608
ETHER_IPv4 = 0x0008
ETHER_IPv6 = 0xDD86
ETHER_PPP_DISCOVERY = 0x6388
ETHER_PPP_SESSION = 0x6488
ETHER_PROTO_ARP = 0x0608
ETHER_PROTO_IPv4 = 0x0008
ETHER_PROTO_IPv6 = 0xDD86
ETHER_PROTO_PPP_DISCOVERY = 0x6388
ETHER_PROTO_PPP_SESSION = 0x6488
 
; Internet protocol numbers
IP_PROTO_IP = 0
IP_PROTO_ICMP = 1
IP_PROTO_TCP = 6
IP_PROTO_UDP = 17
 
; PPP protocol numbers
PPP_IPv4 = 0x2100
PPP_IPV6 = 0x5780
PPP_PROTO_IPv4 = 0x2100
PPP_PROTO_IPV6 = 0x5780
PPP_PROTO_ETHERNET = 666 ; FIXME
 
;Protocol family
AF_UNSPEC = 0
55,17 → 62,8
AF_LOCAL = 1
AF_INET4 = 2
AF_INET6 = 10
AF_PPP = 777
AF_PPP = 777 ; FIXME
 
; Internet protocol numbers
IP_PROTO_IP = 0
IP_PROTO_ICMP = 1
IP_PROTO_TCP = 6
IP_PROTO_UDP = 17
 
; PPP protocol number
PPP_PROTO_ETHERNET = 666
 
; Socket types
SOCK_STREAM = 1
SOCK_DGRAM = 2
114,12 → 112,6
 
 
SOCKET_MAXDATA = 4096*32 ; must be 4096*(power of 2) where 'power of 2' is at least 8
 
; Network driver types
NET_TYPE_LOOPBACK = 0
NET_TYPE_ETH = 1
NET_TYPE_SLIP = 2
 
MAX_backlog = 20 ; maximum backlog for stream sockets
 
; Error Codes
139,11 → 131,23
API_PPPOE = 6
API_IPv6 = 7
 
; Network device types
NET_DEVICE_LOOPBACK = 0
NET_DEVICE_ETH = 1
NET_DEVICE_SLIP = 2
 
; Network link types (link protocols)
NET_LINK_LOOPBACK = 0 ;;; Really a link type?
NET_LINK_MAC = 1 ; Media access control (ethernet, isdn, ...)
NET_LINK_PPP = 2 ; Point to Point Protocol (PPPoE, ...)
NET_LINK_IEEE802.11 = 3 ; IEEE 802.11 (WiFi)
 
; Hardware acceleration bits
HWACC_TCP_IPv4 = 1 shl 0
 
struct NET_DEVICE
 
type dd ? ; Type field
device_type dd ? ; Type field
mtu dd ? ; Maximal Transmission Unit
name dd ? ; Ptr to 0 terminated string
 
156,7 → 160,7
packets_tx dd ? ;
packets_rx dd ? ;
 
state dd ? ; link state (0 = no link)
link_state dd ? ; link state (0 = no link)
hwacc dd ? ; bitmask stating enabled HW accelerations (offload engines)
 
ends
213,8 → 217,7
uglobal
 
NET_RUNNING dd ?
NET_DEFAULT dd ?
NET_DRV_LIST rd MAX_NET_DEVICES
NET_DRV_LIST rd NET_DEVICES_MAX
 
endg
 
235,7 → 238,7
; Init the network drivers list
xor eax, eax
mov edi, NET_RUNNING
mov ecx, (MAX_NET_DEVICES + 2)
mov ecx, (NET_DEVICES_MAX + 2)
rep stosd
 
PPPoE_init
250,6 → 253,8
 
SOCKET_init
 
LOOP_init
 
mov [net_tmr_count], 0
 
ret
308,7 → 313,7
align 4
NET_link_changed:
 
DEBUGF DEBUG_NETWORK_VERBOSE, "NET_link_changed device=0x%x status=0x%x\n", ebx, [ebx + NET_DEVICE.state]
DEBUGF DEBUG_NETWORK_VERBOSE, "NET_link_changed device=0x%x status=0x%x\n", ebx, [ebx + NET_DEVICE.link_state]
 
align 4
NET_send_event:
345,13 → 350,13
 
DEBUGF DEBUG_NETWORK_VERBOSE, "NET_Add_Device: %x\n", ebx ;;; TODO: use mutex to lock net device list
 
cmp [NET_RUNNING], MAX_NET_DEVICES
cmp [NET_RUNNING], NET_DEVICES_MAX
jae .error
 
;----------------------------------
; Check if device is already listed
mov eax, ebx
mov ecx, MAX_NET_DEVICES ; We need to check whole list because a device may be removed without re-organizing list
mov ecx, NET_DEVICES_MAX ; We need to check whole list because a device may be removed without re-organizing list
mov edi, NET_DRV_LIST
 
repne scasd ; See if device is already in the list
360,7 → 365,7
;----------------------------
; Find empty slot in the list
xor eax, eax
mov ecx, MAX_NET_DEVICES
mov ecx, NET_DEVICES_MAX
mov edi, NET_DRV_LIST
 
repne scasd
378,13 → 383,6
 
inc [NET_RUNNING] ; Indicate that one more network device is up and running
 
cmp eax, 1 ; If it's the first network device, try to set it as default
jne @f
push eax
call NET_set_default
pop eax
@@:
 
call NET_send_event
 
DEBUGF DEBUG_NETWORK_VERBOSE, "Device number: %u\n", eax
399,41 → 397,9
 
;-----------------------------------------------------------------
;
; NET_set_default
;
; API to set the default interface
;
; IN: Device num in eax
; OUT: Device num in eax, -1 on error
;
;-----------------------------------------------------------------
align 4
NET_set_default:
 
DEBUGF DEBUG_NETWORK_VERBOSE, "NET_set_default: device=%x\n", eax
 
cmp eax, MAX_NET_DEVICES
jae .error
 
cmp [NET_DRV_LIST+eax*4], 0
je .error
 
mov [NET_DEFAULT], eax
 
DEBUGF DEBUG_NETWORK_VERBOSE, "NET_set_default: succes\n"
ret
 
.error:
or eax, -1
DEBUGF DEBUG_NETWORK_ERROR, "NET_set_default: failed\n"
ret
 
 
;-----------------------------------------------------------------
;
; NET_Remove_Device:
;
; This function is called by etwork drivers,
; This function is called by network drivers,
; to unregister network devices from the kernel
;
; IN: Pointer to device structure in ebx
446,28 → 412,12
cmp [NET_RUNNING], 0
je .error
 
cmp [NET_DRV_LIST], ebx
jne @f
mov [NET_DRV_LIST], 0
cmp [NET_RUNNING], 1
je @f
; there are still active devices, find one and make it default
xor eax, eax
mov ecx, MAX_NET_DEVICES
mov edi, NET_DRV_LIST
repe scasd
je @f
shr edi, 2
dec edi
mov [NET_DEFAULT], edi
@@:
 
;----------------------------
; Find the driver in the list
 
mov eax, ebx
mov ecx, MAX_NET_DEVICES
mov edi, NET_DRV_LIST+4
mov ecx, NET_DEVICES_MAX
mov edi, NET_DRV_LIST
 
repne scasd
jnz .error
477,10 → 427,11
 
xor eax, eax
mov dword [edi-4], eax
dec [NET_RUNNING]
 
call NET_send_event
 
dec [NET_RUNNING]
xor eax, eax
ret
 
.error:
501,7 → 452,7
NET_ptr_to_num:
push ecx
 
mov ecx, MAX_NET_DEVICES
mov ecx, NET_DEVICES_MAX
mov edi, NET_DRV_LIST
 
.loop:
645,20 → 596,21
 
;----------------------------------------------------------------
;
; System function to work with network devices (75)
; System function to work with network devices (74)
;
;----------------------------------------------------------------
align 4
sys_network: ; FIXME: make default device easily accessible
sys_network:
 
cmp ebx, -1
jne @f
 
mov eax, [NET_RUNNING]
jmp .return
mov [esp+32], eax
ret
 
@@:
cmp bh, MAX_NET_DEVICES ; Check if device number exists
cmp bh, NET_DEVICES_MAX ; Check if device number exists
jae .doesnt_exist
 
mov esi, ebx
682,17 → 634,20
dd .stop ; 3
dd .get_ptr ; 4
dd .get_drv_name ; 5
dd .set_default ; 6
 
dd .packets_tx ; 6
dd .packets_rx ; 7
dd .bytes_tx ; 8
dd .bytes_rx ; 9
dd .state ; 10
.number = ($ - .table) / 4 - 1
 
.get_type: ; 0 = Get device type (ethernet/token ring/...)
.get_type:
mov eax, [eax + NET_DEVICE.device_type]
mov [esp+32], eax
ret
 
mov eax, [eax + NET_DEVICE.type]
jmp .return
 
 
.get_dev_name: ; 1 = Get device name
 
.get_dev_name:
mov esi, [eax + NET_DEVICE.name]
mov edi, ecx
 
700,43 → 655,66
rep movsd
 
xor eax, eax
jmp .return
mov [esp+32], eax
ret
 
.reset: ; 2 = Reset the device
 
.reset:
call [eax + NET_DEVICE.reset]
jmp .return
mov [esp+32], eax
ret
 
.stop: ; 3 = Stop driver for this device
 
.stop:
call [eax + NET_DEVICE.unload]
jmp .return
mov [esp+32], eax
ret
 
 
.get_ptr: ; 4 = Get driver pointer
.get_ptr:
mov [esp+32], eax
ret
 
jmp .return
 
 
.get_drv_name: ; 5 = Get driver name
 
.get_drv_name:
xor eax, eax
jmp .return
mov [esp+32], eax
ret
 
.packets_tx:
mov eax, [eax + NET_DEVICE.packets_tx]
mov [esp+32], eax
ret
 
.set_default: ; 6 = Set default device
.packets_rx:
mov eax, [eax + NET_DEVICE.packets_rx]
mov [esp+32], eax
ret
 
call NET_set_default
jmp .return
.bytes_tx:
mov ebx, dword [eax + NET_DEVICE.bytes_tx + 4]
mov [esp+20], ebx
mov eax, dword [eax + NET_DEVICE.bytes_tx]
mov [esp+32], eax
ret
 
.doesnt_exist:
mov eax, -1
.bytes_rx:
mov ebx, dword [eax + NET_DEVICE.bytes_rx + 4]
mov [esp+20], ebx
mov eax, dword [eax + NET_DEVICE.bytes_rx]
mov [esp+32], eax
ret
 
.return:
.state:
mov eax, [eax + NET_DEVICE.link_state]
mov [esp+32], eax
ret
 
 
.doesnt_exist:
mov dword[esp+32], -1
ret
 
 
 
;----------------------------------------------------------------
;
; System function to work with protocols (76)
744,7 → 722,7
;----------------------------------------------------------------
align 4
sys_protocols:
cmp bh, MAX_NET_DEVICES ; Check if device number exists
cmp bh, NET_DEVICES_MAX ; Check if device number exists
jae .doesnt_exist
 
mov esi, ebx
/kernel/branches/Kolibri-acpi/network/tcp.inc
129,12 → 129,12
 
align 4
uglobal
TCP_segments_tx rd MAX_NET_DEVICES
TCP_segments_rx rd MAX_NET_DEVICES
TCP_segments_missed rd MAX_NET_DEVICES
TCP_segments_dumped rd MAX_NET_DEVICES
; TCP_bytes_rx rq MAX_NET_DEVICES
; TCP_bytes_tx rq MAX_NET_DEVICES
TCP_segments_tx rd NET_DEVICES_MAX
TCP_segments_rx rd NET_DEVICES_MAX
TCP_segments_missed rd NET_DEVICES_MAX
TCP_segments_dumped rd NET_DEVICES_MAX
; TCP_bytes_rx rq NET_DEVICES_MAX
; TCP_bytes_tx rq NET_DEVICES_MAX
TCP_sequence_num dd ?
TCP_queue rd TCP_QUEUE_SIZE*sizeof.TCP_queue_entry/4
TCP_input_event dd ?
152,7 → 152,7
 
xor eax, eax
mov edi, TCP_segments_tx
mov ecx, (6*MAX_NET_DEVICES)
mov ecx, (6*NET_DEVICES_MAX)
rep stosd
 
pseudo_random eax
160,8 → 160,7
 
init_queue TCP_queue
 
push 1
pop ebx
movi ebx, 1
mov ecx, TCP_process_input
call new_sys_threads
 
/kernel/branches/Kolibri-acpi/network/tcp_input.inc
253,6 → 253,7
 
mov [ebx + TCP_SOCKET.t_idle], 0
mov [ebx + TCP_SOCKET.timer_keepalive], TCP_time_keep_idle
or [ebx + TCP_SOCKET.timer_flags], timer_flag_keepalive
 
;--------------------
; Process TCP options
488,7 → 489,7
mov [ebx + TCP_SOCKET.SND_UNA], eax
 
; Stop retransmit timer
mov [ebx + TCP_SOCKET.timer_retransmission], 0
and [ebx + TCP_SOCKET.timer_flags], not timer_flag_retransmission
 
; Unlock the socket
pusha
852,8 → 853,8
; (window info didnt change) The ACK is the biggest we've seen and we've seen exactly our rexmt threshold of them,
; assume a packet has been dropped and retransmit it. Kludge snd_nxt & the congestion window so we send only this one packet.
 
cmp [ebx + TCP_SOCKET.timer_retransmission], 0 ;;;; FIXME
jg @f
test [ebx + TCP_SOCKET.timer_flags], timer_flag_retransmission
jz @f
 
mov eax, [edx + TCP_header.AckNumber]
cmp eax, [ebx + TCP_SOCKET.SND_UNA]
886,7 → 887,7
pop edx
mov [ebx + TCP_SOCKET.SND_SSTHRESH], eax
 
mov [ebx + TCP_SOCKET.timer_retransmission], 0 ; turn off retransmission timer
and [ebx + TCP_SOCKET.timer_flags], not timer_flag_retransmission ; turn off retransmission timer
mov [ebx + TCP_SOCKET.t_rtt], 0
mov eax, [edx + TCP_header.AckNumber]
mov [ebx + TCP_SOCKET.SND_NXT], eax
1017,16 → 1018,16
mov eax, [ebx + TCP_SOCKET.SND_MAX]
cmp eax, [edx + TCP_header.AckNumber]
jne .more_data
mov [ebx + TCP_SOCKET.timer_retransmission], 0
and [ebx + TCP_SOCKET.timer_flags], not timer_flag_retransmission
or [ebx + TCP_SOCKET.temp_bits], TCP_BIT_NEEDOUTPUT
jmp .no_restart
.more_data:
cmp [ebx + TCP_SOCKET.timer_persist], 0
jne .no_restart
test [ebx + TCP_SOCKET.timer_flags], timer_flag_persist
jnz .no_restart
 
mov eax, [ebx + TCP_SOCKET.t_rxtcur]
mov [ebx + TCP_SOCKET.timer_retransmission], eax
 
or [ebx + TCP_SOCKET.timer_flags], timer_flag_retransmission
.no_restart:
 
 
1140,6 → 1141,7
mov eax, ebx
call SOCKET_is_disconnected
mov [ebx + TCP_SOCKET.timer_timed_wait], TCP_time_max_idle
or [ebx + TCP_SOCKET.timer_flags], timer_flag_wait
@@:
mov [ebx + TCP_SOCKET.t_state], TCPS_FIN_WAIT_2
jmp .ack_processed
1151,6 → 1153,7
mov eax, ebx
call TCP_cancel_timers
mov [ebx + TCP_SOCKET.timer_timed_wait], 2 * TCP_time_MSL
or [ebx + TCP_SOCKET.timer_flags], timer_flag_wait
mov eax, ebx
call SOCKET_is_disconnected
jmp .ack_processed
1164,6 → 1167,7
 
.ack_tw:
mov [ebx + TCP_SOCKET.timer_timed_wait], 2 * TCP_time_MSL
or [ebx + TCP_SOCKET.timer_flags], timer_flag_wait
jmp .drop_after_ack
 
.reset_dupacks: ; We got a new ACK, reset duplicate ACK counter
1209,6 → 1213,7
mov [ebx + TCP_SOCKET.t_state], TCPS_SYN_RECEIVED
mov [ebx + TCP_SOCKET.t_flags], TF_ACKNOW
mov [ebx + TCP_SOCKET.timer_keepalive], TCP_time_keep_interval ;;;; macro
or [ebx + TCP_SOCKET.timer_flags], timer_flag_keepalive
 
lea eax, [ebx + STREAM_SOCKET.snd]
call SOCKET_ring_create
1272,7 → 1277,7
@@:
 
.no_syn_ack:
mov [ebx + TCP_SOCKET.timer_retransmission], 0 ; disable retransmission
and [ebx + TCP_SOCKET.timer_flags], not timer_flag_retransmission ; disable retransmission timer
 
push [edx + TCP_header.SequenceNumber]
pop [ebx + TCP_SOCKET.IRS]
1525,11 → 1530,13
mov eax, ebx
call TCP_cancel_timers
mov [ebx + TCP_SOCKET.timer_timed_wait], 2 * TCP_time_MSL
or [ebx + TCP_SOCKET.timer_flags], timer_flag_wait
call SOCKET_is_disconnected
jmp .final_processing
 
.fin_timed:
mov [ebx + TCP_SOCKET.timer_timed_wait], 2 * TCP_time_MSL
or [ebx + TCP_SOCKET.timer_flags], timer_flag_wait
jmp .final_processing
 
 
/kernel/branches/Kolibri-acpi/network/tcp_output.inc
93,7 → 93,7
jmp .no_force
 
.no_zero_window:
mov [eax + TCP_SOCKET.timer_persist], 0
and [eax + TCP_SOCKET.timer_flags], not timer_flag_persist
mov [eax + TCP_SOCKET.t_rxtshift], 0
 
.no_force:
125,7 → 125,7
jnz @f
 
; cancel pending retransmit
mov [eax + TCP_SOCKET.timer_retransmission], 0
and [eax + TCP_SOCKET.timer_flags], not timer_flag_retransmission
 
; pull SND_NXT back to (closed) window, We will enter persist state below.
push [eax + TCP_SOCKET.SND_UNA]
268,11 → 268,12
 
cmp [eax + STREAM_SOCKET.snd.size], 0 ; Data ready to send?
jne @f
cmp [eax + TCP_SOCKET.timer_retransmission], 0
and [eax + TCP_SOCKET.timer_flags], not timer_flag_retransmission
jne @f
cmp [eax + TCP_SOCKET.timer_persist], 0 ; Persist timer already expired?
jne @f
 
test [eax + TCP_SOCKET.timer_flags], timer_flag_persist ; Persist timer already expired?
jnz @f
 
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_output: Entering persist state\n"
 
mov [eax + TCP_SOCKET.t_rxtshift], 0
512,19 → 513,19
@@:
 
; set retransmission timer if not already set, and not doing an ACK or keepalive probe
test [eax + TCP_SOCKET.timer_flags], timer_flag_retransmission
jnz .retransmit_set
 
cmp [eax + TCP_SOCKET.timer_retransmission], 0 ;;;; FIXME
ja .retransmit_set
 
cmp edx, [eax + TCP_SOCKET.SND_UNA] ; edx is still [eax + TCP_SOCKET.SND_NXT]
je .retransmit_set
 
mov edx, [eax + TCP_SOCKET.t_rxtcur]
mov [eax + TCP_SOCKET.timer_retransmission], edx
or [eax + TCP_SOCKET.timer_flags], timer_flag_retransmission
 
cmp [eax + TCP_SOCKET.timer_persist], 0
jne .retransmit_set
mov [eax + TCP_SOCKET.timer_persist], 0
test [eax + TCP_SOCKET.timer_flags], timer_flag_persist
jz .retransmit_set
and [eax + TCP_SOCKET.timer_flags], not timer_flag_persist
mov [eax + TCP_SOCKET.t_rxtshift], 0
 
.retransmit_set:
593,11 → 594,12
pop eax
 
mov [eax + TCP_SOCKET.timer_retransmission], TCP_time_re_min
or [eax + TCP_SOCKET.timer_flags], timer_flag_retransmission
 
lea ecx, [eax + SOCKET.mutex]
call mutex_unlock
 
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_send: IP error\n"
DEBUGF DEBUG_NETWORK_ERROR, "TCP_send: IP error\n"
 
or eax, -1
ret
609,7 → 611,7
lea ecx, [eax + SOCKET.mutex]
call mutex_unlock
 
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_send: sending failed\n"
DEBUGF DEBUG_NETWORK_ERROR, "TCP_send: sending failed\n"
 
or eax, -2
ret
/kernel/branches/Kolibri-acpi/network/tcp_subr.inc
420,8 → 420,8
 
; First, check if retransmit timer is not set, retransmit and persist are mutually exclusive
 
cmp [eax + TCP_SOCKET.timer_retransmission], 0
ja @f
test [eax + TCP_SOCKET.timer_flags], timer_flag_retransmission
jnz .exit
 
; calculate RTO
push ebx
436,7 → 436,7
; Start/restart persistance timer.
 
TCPT_RANGESET [eax + TCP_SOCKET.timer_persist], ebx, TCP_time_pers_min, TCP_time_pers_max
 
or [ebx + TCP_SOCKET.timer_flags], timer_flag_persist
pop ebx
 
cmp [eax + TCP_SOCKET.t_rxtshift], TCP_max_rxtshift
443,6 → 443,7
jae @f
inc [eax + TCP_SOCKET.t_rxtshift]
@@:
.exit:
 
ret
 
/kernel/branches/Kolibri-acpi/network/tcp_timer.inc
1,6 → 1,6
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;
;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;;
;; ;;
;; Part of the TCP/IP network stack for KolibriOS ;;
16,6 → 16,13
 
$Revision: 3143 $
 
timer_flag_retransmission = 1 shl 0
timer_flag_keepalive = 1 shl 1
timer_flag_2msl = 1 shl 2
timer_flag_persist = 1 shl 3
timer_flag_wait = 1 shl 4
 
 
;----------------------
; 160 ms timer
;----------------------
27,17 → 34,16
mov ebx, net_sockets
.loop:
mov ebx, [ebx + SOCKET.NextPtr]
or ebx, ebx
test ebx, ebx
jz .exit
 
cmp [ebx + SOCKET.Domain], AF_INET4
jne .loop
 
cmp [ebx + SOCKET.Protocol], IP_PROTO_TCP
jne .loop
 
test [ebx + TCP_SOCKET.t_flags], TF_DELACK
jz .loop
 
and [ebx + TCP_SOCKET.t_flags], not (TF_DELACK)
 
push ebx
58,7 → 64,7
;----------------------
; 640 ms timer
;----------------------
macro TCP_timer_640ms {
macro TCP_timer_640ms { ; TODO: implement timed wait timer!
 
local .loop
local .exit
68,7 → 74,7
add [TCP_sequence_num], 64000
 
; scan through all the active TCP sockets, decrementing ALL timers
; timers do not have the chance to wrap because the keepalive timer will kill the socket when it expires
; When a timer reaches zero, we'll check wheter it was active or not
 
mov eax, net_sockets
.loop:
84,8 → 90,11
jne .loop
 
inc [eax + TCP_SOCKET.t_idle]
 
dec [eax + TCP_SOCKET.timer_retransmission]
jnz .check_more2
test [eax + TCP_SOCKET.timer_flags], timer_flag_retransmission
jz .check_more2
 
DEBUGF DEBUG_NETWORK_VERBOSE, "socket %x: Retransmission timer expired\n", eax
 
96,6 → 105,8
.check_more2:
dec [eax + TCP_SOCKET.timer_keepalive]
jnz .check_more3
test [eax + TCP_SOCKET.timer_flags], timer_flag_keepalive
jz .check_more3
 
DEBUGF DEBUG_NETWORK_VERBOSE, "socket %x: Keepalive expired\n", eax
 
125,6 → 136,8
.check_more3:
dec [eax + TCP_SOCKET.timer_timed_wait]
jnz .check_more5
test [eax + TCP_SOCKET.timer_flags], timer_flag_2msl
jz .check_more5
 
DEBUGF DEBUG_NETWORK_VERBOSE, "socket %x: 2MSL timer expired\n", eax
 
131,6 → 144,8
.check_more5:
dec [eax + TCP_SOCKET.timer_persist]
jnz .loop
test [eax + TCP_SOCKET.timer_flags], timer_flag_persist
jz .loop
 
DEBUGF DEBUG_NETWORK_VERBOSE, "socket %x: persist timer expired\n", eax
 
152,17 → 167,6
 
TCP_cancel_timers:
 
push eax edi
mov [eax + TCP_SOCKET.timer_flags], 0
 
lea edi, [eax + TCP_SOCKET.timer_retransmission]
xor eax, eax
stosd
stosd
stosd
stosd
stosd
 
pop edi eax
 
 
ret
/kernel/branches/Kolibri-acpi/network/udp.inc
29,8 → 29,8
 
align 4
uglobal
UDP_PACKETS_TX rd MAX_NET_DEVICES
UDP_PACKETS_RX rd MAX_NET_DEVICES
UDP_PACKETS_TX rd NET_DEVICES_MAX
UDP_PACKETS_RX rd NET_DEVICES_MAX
endg
 
 
45,7 → 45,7
 
xor eax, eax
mov edi, UDP_PACKETS_TX
mov ecx, 2*MAX_NET_DEVICES
mov ecx, 2*NET_DEVICES_MAX
rep stosd
}
 
/kernel/branches/Kolibri-acpi/video/cursors.inc
524,7 → 524,7
align 4
@@:
mov edi, ebx
add ebx, [BytesPerScanLine]
add ebx, [_display.pitch]
 
mov ecx, [esp]
rep movsb
559,7 → 559,7
align 4
@@:
mov edi, ebx
add ebx, [BytesPerScanLine]
add ebx, [_display.pitch]
 
mov ecx, [cur.w]
rep movsd
650,7 → 650,7
align 4
@@:
mov esi, edx
add edx, [BytesPerScanLine]
add edx, [_display.pitch]
mov ecx, [cur.w]
lea ecx, [ecx+ecx*2]
rep movsb
673,7 → 673,7
mov esi, edx
mov edi, ebx
add edx, 32*4
add ebx, [BytesPerScanLine]
add ebx, [_display.pitch]
;--------------------------------------
align 4
.pix:
768,7 → 768,7
align 4
@@:
mov esi, edx
add edx, [BytesPerScanLine]
add edx, [_display.pitch]
mov ecx, [cur.w]
rep movsd
dec eax
790,7 → 790,7
mov esi, edx
mov edi, ebx
add edx, 32*4
add ebx, [BytesPerScanLine]
add ebx, [_display.pitch]
;--------------------------------------
align 4
.pix:
/kernel/branches/Kolibri-acpi/video/vesa20.inc
230,7 → 230,7
sub eax, [putimg.real_sx]
mov [putimg.winmap_newline], eax
; screen new line increment
mov eax, [BytesPerScanLine]
mov eax, [_display.pitch]
mov ebx, [_display.bpp]
shr ebx, 3
imul ecx, ebx
1233,7 → 1233,7
shr ebx, 3
imul eax, ebx
neg eax
add eax, [BytesPerScanLine]
add eax, [_display.pitch]
mov [drbar.line_inc_scr], eax
; pointer to screen
mov edx, [drbar.abs_cy]
1950,7 → 1950,7
;--------------------------------------
align 4
@@:
add edi, [BytesPerScanLine]
add edi, [_display.pitch]
; restore ecx,edx; advance esi to next background line
mov eax, [esp+28]
mov ebx, [esp+32]