Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 2128 → Rev 2129

/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