/kernel/trunk/const.inc |
---|
645,7 → 645,7 |
end virtual |
struc MEM_STATE |
{ .mutex rd 1 |
{ .mutex MUTEX |
.smallmap rd 1 |
.treemap rd 1 |
.topsize rd 1 |
664,7 → 664,7 |
.kernel_pages dd ? |
.kernel_tables dd ? |
.sys_page_dir dd ? |
.pg_mutex dd ? |
.mutex MUTEX |
} |
;struc LIB |
/kernel/trunk/core/heap.inc |
---|
151,7 → 151,8 |
mov [mem_block_list+63*4], ebx |
mov byte [mem_block_map], 0xFC |
and [heap_mutex], 0 |
mov ecx, heap_mutex |
call mutex_init |
mov [heap_blocks], 4095 |
mov [free_blocks], 4094 |
ret |
272,14 → 273,14 |
push esi |
push edi |
mov ecx, heap_mutex |
call mutex_lock |
mov eax, [size] |
add eax, 4095 |
and eax, not 4095 |
mov [size], eax |
mov ebx, heap_mutex |
call wait_mutex ;ebx |
cmp eax, [heap_free] |
ja .error |
355,10 → 356,11 |
mov [edx+list_bk], esi |
mov [esi+block_flags], USED_BLOCK |
mov eax, [esi+block_base] |
mov ebx, [size] |
sub [heap_free], ebx |
and [heap_mutex], 0 |
mov ecx, heap_mutex |
call mutex_unlock |
mov eax, [esi+block_base] |
pop edi |
pop esi |
pop ebx |
378,17 → 380,19 |
mov [edx+list_bk], edi |
mov [edi+block_flags], USED_BLOCK |
mov eax, [edi+block_base] |
mov ebx, [size] |
sub [heap_free], ebx |
and [heap_mutex], 0 |
mov ecx, heap_mutex |
call mutex_unlock |
mov eax, [edi+block_base] |
pop edi |
pop esi |
pop ebx |
ret |
.error: |
mov ecx, heap_mutex |
call mutex_unlock |
xor eax, eax |
mov [heap_mutex], eax |
pop edi |
pop esi |
pop ebx |
400,9 → 404,10 |
push ebx |
push esi |
push edi |
mov ebx, heap_mutex |
call wait_mutex ;ebx |
mov ecx, heap_mutex |
call mutex_lock |
mov eax, [base] |
mov esi, [mem_used.fd] |
@@: |
491,9 → 496,10 |
@@: |
bts [mem_block_mask], eax |
.m_eq: |
mov ecx, heap_mutex |
call mutex_unlock |
xor eax, eax |
mov [heap_mutex], eax |
dec eax |
not eax |
pop edi |
pop esi |
pop ebx |
513,16 → 519,18 |
@@: |
bts [mem_block_mask], eax |
mov [esi+block_flags],FREE_BLOCK |
mov ecx, heap_mutex |
call mutex_unlock |
xor eax, eax |
mov [heap_mutex], eax |
dec eax |
not eax |
pop edi |
pop esi |
pop ebx |
ret |
.fail: |
mov ecx, heap_mutex |
call mutex_unlock |
xor eax, eax |
mov [heap_mutex], eax |
pop edi |
pop esi |
pop ebx |
607,8 → 615,8 |
proc kernel_free stdcall, base:dword |
push ebx esi |
mov ebx, heap_mutex |
call wait_mutex ;ebx |
mov ecx, heap_mutex |
call mutex_lock |
mov eax, [base] |
mov esi, [mem_used.fd] |
624,19 → 632,17 |
cmp [esi+block_flags], USED_BLOCK |
jne .fail |
and [heap_mutex], 0 |
call mutex_unlock |
push ecx |
mov ecx, [esi+block_size]; |
shr ecx, 12 |
call release_pages ;eax, ecx |
pop ecx |
stdcall free_kernel_space, [base] |
pop esi ebx |
ret |
.fail: |
call mutex_unlock |
xor eax, eax |
mov [heap_mutex], eax |
pop esi ebx |
ret |
endp |
/kernel/trunk/core/irq.inc |
---|
72,8 → 72,6 |
.irqh dd ? |
endl |
xchg bx, bx |
and [.irqh], 0 |
push ebx |
100,9 → 98,10 |
mov eax, [ecx] |
mov [next_irqh], eax |
mov [.irqh], ecx |
mov [irq_failed+ebx*4], 0 ;clear counter |
mov eax, [user_data] |
mov [ecx+IRQH.handler], edx |
mov [ecx+IRQH.data], eax |
109,9 → 108,8 |
lea edx, [irqh_tab+ebx*8] |
list_add_tail ecx, edx ;clobber eax |
stdcall enable_irq, ebx |
stdcall enable_irq, [irq] |
.fail: |
popfd |
.err: |
/kernel/trunk/core/malloc.inc |
---|
20,7 → 20,7 |
; esi= nb |
; ebx= idx |
; |
align 16 |
align 4 |
malloc: |
push esi |
31,8 → 31,8 |
and esi, -8 |
add esi, 8 |
mov ebx, mst.mutex |
call wait_mutex ;ebx |
mov ecx, mst.mutex |
call mutex_lock |
cmp esi, 256 |
jae .large |
92,9 → 92,13 |
pop edi |
pop ebp |
.done: |
mov esi, eax |
mov ecx, mst.mutex |
call mutex_unlock |
mov eax, esi |
pop esi |
mov [mst.mutex], 0 |
ret |
.split: |
lea ebx, [edx+8] ;ebx=mem |
133,10 → 137,10 |
mov [edx+12], eax ; F->bk = r; |
mov [eax+8], edx ; r->fd = F; |
mov [eax+12], ecx ; r->bk = B; |
mov eax, ebx |
pop esi |
mov [mst.mutex], 0 |
ret |
jmp .done |
.small: |
; if (ms.treemap != 0 && (mem = malloc_small(nb)) != 0) |
150,9 → 154,8 |
call malloc_small |
test eax, eax |
jz .from_top |
pop esi |
and [mst.mutex], 0 |
ret |
jmp .done |
.large: |
; if (ms.treemap != 0 && (mem = malloc_large(nb)) != 0) |
189,18 → 192,15 |
mov [edx+4], eax |
mov [ecx+4], esi |
lea eax, [ecx+8] |
pop esi |
and [mst.mutex], 0 |
ret |
jmp .done |
.fail: |
xor eax, eax |
pop esi |
and [mst.mutex], 0 |
ret |
jmp .done |
; param |
; eax= mem |
align 4 |
free: |
push edi |
mov edi, eax |
211,8 → 211,8 |
test byte [edi+4], 2 |
je .fail |
mov ebx, mst.mutex |
call wait_mutex ;ebx |
mov ecx, mst.mutex |
call mutex_lock |
; psize = p->head & (~3); |
289,7 → 289,10 |
mov [mst.top], edi |
mov [edi+4], eax |
.fail2: |
and [mst.mutex], 0 |
mov esi, eax |
mov ecx, mst.mutex |
call mutex_unlock |
mov eax, esi |
pop esi |
.fail: |
pop edi |
410,13 → 413,15 |
mov [esi+8], edx ;P->fd = F |
mov [esi+12], eax ;P->bk = B |
pop esi |
and [mst.mutex], 0 |
mov ecx, mst.mutex |
call mutex_unlock |
ret |
.large: |
mov ebx, eax |
call insert_large_chunk |
pop esi |
and [mst.mutex], 0 |
mov ecx, mst.mutex |
call mutex_unlock |
ret |
1025,5 → 1030,8 |
cmp eax, mst.smallbins+512 |
jb @B |
mov ecx, mst.mutex |
call mutex_init |
ret |
/kernel/trunk/core/memory.inc |
---|
214,30 → 214,32 |
align 4 |
commit_pages: |
push edi |
test ecx, ecx |
jz .fail |
push edi |
push eax |
push ecx |
mov ecx, pg_data.mutex |
call mutex_lock |
pop ecx |
pop eax |
mov edi, ebx |
mov ebx, pg_data.pg_mutex |
call wait_mutex ;ebx |
shr edi, 12 |
lea edi, [page_tabs+edi*4] |
@@: |
stosd |
invlpg [ebx] |
add eax, 0x1000 |
add ebx, 0x1000 |
loop @B |
mov edx, 0x1000 |
mov ebx, edi |
shr ebx, 12 |
@@: |
mov [page_tabs+ebx*4], eax |
; push eax |
invlpg [edi] |
; pop eax |
add edi, edx |
add eax, edx |
inc ebx |
dec ecx |
jnz @B |
mov [pg_data.pg_mutex],ecx |
pop edi |
mov ecx, pg_data.mutex |
call mutex_unlock |
.fail: |
pop edi |
ret |
248,16 → 250,22 |
align 4 |
release_pages: |
pushad |
mov ebx, pg_data.pg_mutex |
call wait_mutex ;ebx |
push ebp |
push esi |
push edi |
push ebx |
mov esi, eax |
mov edi, eax |
shr esi, 10 |
add esi, page_tabs |
shr esi, 12 |
lea esi, [page_tabs+esi*4] |
push ecx |
mov ecx, pg_data.mutex |
call mutex_lock |
pop ecx |
mov ebp, [pg_data.pages_free] |
mov ebx, [page_start] |
mov edx, sys_pgmap |
264,9 → 272,7 |
@@: |
xor eax, eax |
xchg eax, [esi] |
push eax |
invlpg [edi] |
pop eax |
test eax, 1 |
jz .next |
285,11 → 291,16 |
.next: |
add edi, 0x1000 |
add esi, 4 |
dec ecx |
jnz @B |
loop @B |
mov [pg_data.pages_free], ebp |
and [pg_data.pg_mutex],0 |
popad |
mov ecx, pg_data.mutex |
call mutex_unlock |
pop ebx |
pop edi |
pop esi |
pop ebp |
ret |
; param |
423,8 → 434,8 |
align 4 |
proc new_mem_resize stdcall, new_size:dword |
mov ebx, pg_data.pg_mutex |
call wait_mutex ;ebx |
mov ecx, pg_data.mutex |
call mutex_lock |
mov edi, [new_size] |
add edi,4095 |
464,8 → 475,10 |
mov ebx, [new_size] |
call update_mem_size |
mov ecx, pg_data.mutex |
call mutex_unlock |
xor eax, eax |
dec [pg_data.pg_mutex] |
ret |
.expand: |
539,9 → 552,11 |
pop edi |
pop esi |
.exit: |
mov ecx, pg_data.mutex |
call mutex_unlock |
xor eax, eax |
inc eax |
dec [pg_data.pg_mutex] |
ret |
endp |
/kernel/trunk/core/taskman.inc |
---|
360,8 → 360,8 |
app_tabs dd ? |
endl |
mov ebx, pg_data.pg_mutex |
call wait_mutex ;ebx |
mov ecx, pg_data.mutex |
call mutex_lock |
xor eax, eax |
mov [dir_addr], eax |
480,11 → 480,13 |
.done: |
stdcall map_page,[tmp_task_pdir],dword 0,dword PG_UNMAP |
dec [pg_data.pg_mutex] |
mov ecx, pg_data.mutex |
call mutex_unlock |
mov eax, [dir_addr] |
ret |
.fail: |
dec [pg_data.pg_mutex] |
mov ecx, pg_data.mutex |
call mutex_unlock |
cmp [dir_addr], 0 |
je @f |
stdcall destroy_app_space, [dir_addr], 0 |
554,10 → 556,10 |
jg .ret |
;if there isn't threads then clear memory. |
mov esi, [dlls_list] |
call destroy_all_hdlls |
call destroy_all_hdlls ;ecx=APPDATA |
mov ebx, pg_data.pg_mutex |
call wait_mutex ;ebx |
mov ecx, pg_data.mutex |
call mutex_lock |
mov eax, [pg_dir] |
and eax, not 0xFFF |
583,7 → 585,8 |
.exit: |
stdcall map_page,[tmp_task_ptab],0,PG_UNMAP |
stdcall map_page,[tmp_task_pdir],0,PG_UNMAP |
dec [pg_data.pg_mutex] |
mov ecx, pg_data.mutex |
call mutex_unlock |
.ret: |
ret |
endp |
956,25 → 959,7 |
ret |
endp |
; param |
; ebx=mutex |
align 4 |
wait_mutex: |
;;Maxis use atomic bts for mutex 4.4.2009 |
push eax |
push ebx |
.do_wait: |
bts dword [ebx],0 |
jnc .locked |
call change_task |
jmp .do_wait |
.locked: |
pop ebx |
pop eax |
ret |
align 4 |
tls_app_entry: |
call init_heap |
/kernel/trunk/data32.inc |
---|
310,7 → 310,7 |
mem_block_start rd 1 |
mem_block_end rd 1 |
heap_mutex rd 1 |
heap_mutex MUTEX |
heap_size rd 1 |
heap_free rd 1 |
heap_blocks rd 1 |
/kernel/trunk/fs/disk.inc |
---|
119,7 → 119,7 |
; The structure is destroyed when the reference count decrements to zero: |
; this usually occurs in 'disk_del', but can be delayed to the end of last |
; filesystem operation, if one is active. |
.MediaLock dd ? |
.MediaLock MUTEX |
; Lock to protect the MEDIA structure. See the description after |
; 'disk_list_mutex' for the locking strategy. |
; Fields of media object |
198,7 → 198,7 |
endg |
uglobal |
; This mutex guards all operations with the global list of DISK structures. |
disk_list_mutex dd 0 |
disk_list_mutex MUTEX |
; * There are two dependent objects, a disk and a media. In the simplest case |
; disk and media are both non-removable. However, in the general case both |
; can be removed at any time, simultaneously or only media, this makes things |
345,27 → 345,24 |
; 4. Initialize other fields of the DISK structure. |
; Media is not inserted, initialized state of mutex is zero, |
; reference counter is 1. |
lea ecx, [ebx+DISK.MediaLock] |
call mutex_init |
xor eax, eax |
mov dword [ebx+DISK.MediaInserted], eax |
mov [ebx+DISK.MediaLock], eax |
inc eax |
mov [ebx+DISK.RefCount], eax |
; The DISK structure is initialized. |
; 5. Insert the new structure to the global list. |
xchg eax, ebx ; now eax = pointer to DISK |
; 5a. Acquire the mutex. |
mov ebx, disk_list_mutex |
call wait_mutex |
mov ecx, disk_list_mutex |
call mutex_lock |
; 5b. Insert item to the tail of double-linked list. |
mov edx, disk_list |
mov ecx, [edx+DISK.Prev] |
mov [eax+DISK.Prev], ecx |
mov [eax+DISK.Next], edx |
mov [edx+DISK.Prev], eax |
mov [ecx+DISK.Next], eax |
list_add_tail ebx, edx ;ebx= new edx= list head |
; 5c. Release the mutex. |
mov dword [ebx], 0 |
call mutex_unlock |
; 6. Return with eax = pointer to DISK. |
xchg eax, ebx |
jmp .nothing |
.free: |
; Memory allocation for DISK structure succeeded, but for disk name failed. |
388,7 → 385,7 |
; [esp+4] = handle of the disk, i.e. the pointer to the DISK structure. |
; Return value: none. |
disk_del: |
push ebx esi ; save used registers to be stdcall |
push esi ; save used registers to be stdcall |
; 1. Force media to be removed. If the media is already removed, the |
; call does nothing. |
mov esi, [esp+4+8] ; esi = handle of the disk |
395,8 → 392,8 |
stdcall disk_media_changed, esi, 0 |
; 2. Delete the structure from the global list. |
; 2a. Acquire the mutex. |
mov ebx, disk_list_mutex |
call wait_mutex |
mov ecx, disk_list_mutex |
call mutex_lock |
; 2b. Delete item from double-linked list. |
mov eax, [esi+DISK.Next] |
mov edx, [esi+DISK.Prev] |
403,13 → 400,13 |
mov [eax+DISK.Prev], edx |
mov [edx+DISK.Next], eax |
; 2c. Release the mutex. |
mov dword [ebx], 0 |
call mutex_unlock |
; 3. The structure still has one reference created in disk_add. Remove this |
; reference. If there are no other references, disk_dereference will free the |
; structure. |
call disk_dereference |
; 4. Return. |
pop esi ebx ; restore used registers to be stdcall |
pop esi ; restore used registers to be stdcall |
ret 4 ; purge 1 dword argument to be stdcall |
; This is an internal function which removes a previously obtained reference |
502,12 → 499,12 |
jz .noremove |
; We really need to remove the media. |
; 1b. Acquire mutex. |
lea ebx, [esi+DISK.MediaLock] |
call wait_mutex |
lea ecx, [esi+DISK.MediaLock] |
call mutex_lock |
; 1c. Clear the flag. |
mov [esi+DISK.MediaInserted], 0 |
; 1d. Release mutex. |
mov dword [ebx], 0 |
call mutex_unlock |
; 1e. Remove the "lifetime" reference and possibly destroy the structure. |
call disk_media_dereference |
.noremove: |
968,19 → 965,19 |
dyndisk_handler: |
push ebx edi ; save registers used in file_system_lfn |
; 1. Acquire the mutex. |
mov ebx, disk_list_mutex |
call wait_mutex |
mov ecx, disk_list_mutex |
call mutex_lock |
; 2. Loop over the list of DISK structures. |
; 2a. Initialize. |
mov ecx, disk_list |
mov ebx, disk_list |
.scan: |
; 2b. Get the next item. |
mov ecx, [ecx+DISK.Next] |
mov ebx, [ebx+DISK.Next] |
; 2c. Check whether the list is done. If so, go to 3. |
cmp ecx, disk_list |
cmp ebx, disk_list |
jz .notfound |
; 2d. Compare names. If names match, go to 5. |
mov edi, [ecx+DISK.Name] |
mov edi, [ebx+DISK.Name] |
push esi |
@@: |
; esi points to the name from fs operation; it is terminated by zero or slash. |
1005,7 → 1002,7 |
.notfound: |
; The loop is done and no name matches. |
; 3. Release the mutex. |
mov dword [ebx], 0 |
call mutex_unlock |
; 4. Return normally. |
pop edi ebx ; restore registers used in file_system_lfn |
ret |
1018,24 → 1015,25 |
jnz .wrongname |
; We found the addressed DISK structure. |
; 5. Reference the disk. |
lock inc [ecx+DISK.RefCount] |
lock inc [ebx+DISK.RefCount] |
; 6. Now we are sure that the DISK structure is not going to die at least |
; while we are working with it, so release the global mutex. |
mov dword [ebx], 0 |
call mutex_unlock |
; 7. Acquire the mutex for media object. |
pop edi ; restore edi |
lea ebx, [ecx+DISK.MediaLock] |
call wait_mutex |
lea ecx, [ebx+DISK.MediaLock] |
call mutex_lock |
; 8. Get the media object. If it is not NULL, reference it. |
xor edx, edx |
cmp [ecx+DISK.MediaInserted], dl |
cmp [ebx+DISK.MediaInserted], dl |
jz @f |
mov edx, ecx |
inc [ecx+DISK.MediaRefCount] |
mov edx, ebx |
inc [ebx+DISK.MediaRefCount] |
@@: |
; 9. Now we are sure that the media object, if it exists, is not going to die |
; at least while we are working with it, so release the mutex for media object. |
mov dword [ebx], 0 |
call mutex_unlock |
mov ecx, ebx |
pop ebx eax ; restore ebx, pop return address |
; 10. Check whether the fs operation wants to enumerate partitions (go to 11) |
; or work with some concrete partition (go to 12). |
1152,24 → 1150,25 |
; if the driver does not support insert notifications and we are the only fs |
; operation with this disk, issue the fake insert notification; if media is |
; still not inserted, 'disk_media_changed' will detect this and do nothing |
push ebx |
lea ebx, [edx+DISK.MediaLock] |
call wait_mutex |
;;; push ebx |
lea ecx, [edx+DISK.MediaLock] |
call mutex_lock |
cmp [edx+DISK.MediaRefCount], 1 |
jnz .noluck |
mov dword [ebx], 0 |
call mutex_unlock |
push edx |
stdcall disk_media_changed, edx, 1 |
pop edx |
call wait_mutex |
lea ecx, [edx+DISK.MediaLock] |
call mutex_lock |
cmp [edx+DISK.MediaInserted], 0 |
jz .noluck |
lock inc [edx+DISK.MediaRefCount] |
mov dword [ebx], 0 |
call mutex_unlock |
xor ecx, ecx |
jmp .main |
.noluck: |
mov dword [ebx], 0 |
call mutex_unlock |
.deverror: |
mov dword [esp+32], ERROR_DEVICE |
mov esi, edx |
1185,11 → 1184,11 |
; eax != 0 => buffer pointed to by edi contains name of item |
dyndisk_enum_root: |
push ebx ; save register used in file_system_lfn |
mov ebx, disk_list_mutex ; it will be useful |
mov ecx, disk_list_mutex ; it will be useful |
; 1. If this is the first call, acquire the mutex and initialize. |
test eax, eax |
jnz .notfirst |
call wait_mutex |
call mutex_lock |
mov eax, disk_list |
.notfirst: |
; 2. Get next item. |
1211,7 → 1210,7 |
ret |
.last: |
; 6. Release the mutex and return with eax = 0. |
call mutex_unlock |
xor eax, eax |
mov dword [ebx], eax |
pop ebx ; restore register used in file_system_lfn |
ret |
/kernel/trunk/init.inc |
---|
266,7 → 266,6 |
add ebx, [pg_data.pagemap_size-OS_BASE] |
mov [page_end-OS_BASE], ebx |
mov [pg_data.pg_mutex-OS_BASE], 0 |
ret |
endp |
/kernel/trunk/kernel.asm |
---|
321,6 → 321,12 |
mov eax, cr3 |
mov cr3, eax ; flush TLB |
mov ecx, pg_data.mutex |
call mutex_init |
mov ecx, disk_list_mutex |
call mutex_init |
; SAVE REAL MODE VARIABLES |
mov ax, [BOOT_VAR + 0x9031] |
mov [IDEContrRegsBaseAddr], ax |
/kernel/trunk/network/socket.inc |
---|
54,7 → 54,7 |
.SEG_LEN dd ? ; segment length |
.SEG_WND dd ? ; segment window |
.wndsizeTimer dd ? ; window size timer |
.lock dd ? ; lock mutex |
.lock MUTEX ; lock mutex |
.rxData dd ? ; receive data buffer here |
ends |
99,6 → 99,11 |
rep stosd |
pop eax |
mov ebx, eax |
lea ecx, [eax+SOCKET.lock] |
call mutex_init |
mov eax, ebx |
; add socket to the list by changing pointers |
mov ebx, net_sockets |
push [ebx + SOCKET.NextPtr] |
703,10 → 708,10 |
or eax, eax |
jz .error |
lea ebx, [eax + SOCKET.lock] |
call wait_mutex |
mov ebx, eax |
lea ecx, [eax + SOCKET.lock] |
call mutex_lock |
mov ebx, eax |
mov eax, [ebx + SOCKET.rxDataCount] ; get count of bytes |
test eax, eax |
jz .error_release |
727,15 → 732,18 |
and ecx, 3 |
rep movsb |
mov [ebx + SOCKET.lock], 0 |
lea ecx, [ebx + SOCKET.lock] |
mov ebx, eax |
call mutex_unlock |
mov eax, ebx |
ret |
.error_release: |
mov [ebx + SOCKET.lock], 0 |
lea ecx, [ebx + SOCKET.lock] |
call mutex_unlock |
.error: |
xor ebx, ebx |
xor eax, eax |
ret |
endp |
756,10 → 764,11 |
or eax, eax |
jz .error |
lea ebx, [eax + SOCKET.lock] |
call wait_mutex |
mov ebx, eax |
mov ebx, eax |
lea ecx, [eax + SOCKET.lock] |
call mutex_lock |
mov eax, [ebx + SOCKET.rxDataCount] ; get count of bytes |
test eax, eax ; if count of bytes is zero.. |
jz .exit ; exit function (eax will be zero) |
789,7 → 798,9 |
rep movsb ; copy remaining bytes |
.exit: |
mov [ebx + SOCKET.lock], 0 |
lea ecx, [ebx + SOCKET.lock] |
call mutex_unlock |
mov eax, edx |
ret ; at last, exit |
.error: |
800,7 → 811,9 |
xor esi, esi |
mov [ebx + SOCKET.rxDataCount], esi ; store new count (zero) |
call .start_copy |
mov [ebx + SOCKET.lock], 0 |
lea ecx, [ebx + SOCKET.lock] |
call mutex_unlock |
mov eax, edx |
ret |
.start_copy: |
/kernel/trunk/network/tcp.inc |
---|
963,12 → 963,10 |
jmp .exit |
.data: |
push ebx |
add ebx, SOCKET.lock |
call wait_mutex |
pop ebx |
push ecx |
lea ecx, [ebx+SOCKET.lock] |
call mutex_lock |
push ecx |
push ebx |
mov eax, [ebx + SOCKET.rxDataCount] |
add eax, ecx |
986,8 → 984,10 |
cld |
rep movsb ; copy the data across |
mov [ebx + SOCKET.lock], 0 ; release mutex |
lea ecx,[ebx + SOCKET.lock] |
call mutex_unlock |
; flag an event to the application |
pop ebx |
call signal_network_event |
1031,8 → 1031,9 |
.overflow: |
; no place in buffer |
; so simply restore stack and exit |
lea ecx, [ebx + SOCKET.lock] |
call mutex_unlock |
pop eax ecx |
mov [ebx + SOCKET.lock], 0 |
ret |
endp |