/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] |