Subversion Repositories Kolibri OS

Rev

Rev 854 | Rev 864 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 854 Rev 859
Line 3... Line 3...
3 
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
 3 
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
4 
;; Distributed under terms of the GNU General Public License    ;;
 4 
;; Distributed under terms of the GNU General Public License    ;;
5 
;;                                                              ;;
 5 
;;                                                              ;;
6 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 6 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Line 7... Line 7...
7 
 
 7 
 
Line 8... Line 8...
8 
$Revision: 854 $
 8 
$Revision: 859 $
9 
 
 9 
 
10 
 
 10 
 
Line 36... Line 36...
36 
list_bk      equ MEM_BLOCK.list_bk
 36 
list_bk      equ MEM_BLOCK.list_bk
37 
block_base   equ MEM_BLOCK.base
 37 
block_base   equ MEM_BLOCK.base
38 
block_size   equ MEM_BLOCK.size
 38 
block_size   equ MEM_BLOCK.size
39 
block_flags  equ MEM_BLOCK.flags
 39 
block_flags  equ MEM_BLOCK.flags
Line 40... Line -...
40 
 
 - 
 
41 
macro calc_index op
 - 
 
42 
{          shr op, 12
 - 
 
43 
           dec op
 - 
 
44 
           cmp op, 63
 - 
 
45 
           jna @f
 - 
 
46 
           mov op, 63
 - 
 
47 
@@:
 - 
 
48 
}
 - 
 
49 
 
 - 
 
50 
macro remove_from_list op
 - 
 
51 
{          mov edx, [op+list_fd]
 - 
 
52 
           mov ecx, [op+list_bk]
 - 
 
53 
           test edx, edx
 - 
 
54 
           jz @f
 - 
 
55 
           mov [edx+list_bk], ecx
 - 
 
56 
@@:
 - 
 
57 
           test ecx, ecx
 - 
 
58 
           jz @f
 - 
 
59 
           mov [ecx+list_fd], edx
 - 
 
60 
@@:
 - 
 
61 
           mov [op+list_fd],0
 - 
 
62 
           mov [op+list_bk],0
 - 
 
63 
}
 - 
 
64 
 
 - 
 
65 
macro remove_from_free op
 - 
 
66 
{
 - 
 
67 
           remove_from_list op
 - 
 
68 
 
 - 
 
69 
           mov eax, [op+block_size]
 - 
 
70 
           calc_index eax
 - 
 
71 
           cmp [mem_block_list+eax*4], op
 - 
 
72 
           jne @f
 - 
 
73 
           mov [mem_block_list+eax*4], edx
 - 
 
74 
@@:
 - 
 
75 
           cmp [mem_block_list+eax*4], 0
 - 
 
76 
           jne @f
 - 
 
77 
           btr [mem_block_mask], eax
 - 
 
78 
@@:
 - 
 
79 
}
 - 
 
80 
 
 - 
 
81 
macro remove_from_used op
 - 
 
82 
{
 - 
 
83 
           mov edx, [op+list_fd]
 - 
 
84 
           mov ecx, [op+list_bk]
 - 
 
85 
           mov [edx+list_bk], ecx
 - 
 
86 
           mov [ecx+list_fd], edx
 - 
 
87 
           mov [op+list_fd], 0
 - 
 
88 
           mov [op+list_bk], 0
 - 
 
89 
}
 - 
 
90 
 
 - 
 
91 
align 4
 - 
 
92 
init_kernel_heap:
 - 
 
93 
 
 - 
 
94 
           mov ecx, 64/4
 - 
 
95 
           mov edi, mem_block_list
 - 
 
96 
           xor eax, eax
 - 
 
97 
           cld
 - 
 
98 
           rep stosd
 - 
 
99 
 
 - 
 
100 
           mov ecx, 512/4
 - 
 
101 
           mov edi, mem_block_map
 - 
 
102 
           not eax
 - 
 
103 
           rep stosd
 - 
 
104 
 
 - 
 
105 
           mov ecx, 128*1024
 - 
 
106 
           fastcall _balloc
 - 
 
107 
 
 - 
 
108 
           mov [mem_block_start], mem_block_map
 - 
 
109 
           mov [mem_block_end], mem_block_map+512
 - 
 
110 
           mov [mem_block_arr], eax
 - 
 
111 
 
 - 
 
112 
           mov ebx, mem_used.fd-MEM_LIST_OFFSET
 - 
 
113 
           mov [mem_used.fd], ebx
 - 
 
114 
           mov [mem_used.bk], ebx
 - 
 
115 
 
 - 
 
116 
           xor edx, edx
 - 
 
117 
 
 - 
 
118 
           mov [eax+block_next], edx
 - 
 
119 
           mov [eax+block_prev], edx
 - 
 
120 
           mov [eax+list_fd], edx
 - 
 
121 
           mov [eax+list_bk], edx
 - 
 
122 
           mov [eax+block_base], HEAP_BASE
 - 
 
123 
           mov [eax+block_size], page_tabs-HEAP_BASE
 - 
 
124 
           mov [eax+block_flags], FREE_BLOCK
 - 
 
125 
 
 - 
 
126 
           mov [heap_size], page_tabs-HEAP_BASE
 - 
 
127 
           mov [heap_free], page_tabs-HEAP_BASE
 - 
 
128 
 
 - 
 
129 
           mov [mem_block_mask], edx
 - 
 
130 
           mov [mem_block_mask+4],0x80000000
 - 
 
131 
 
 - 
 
132 
           mov [mem_block_list+63*4], eax
 - 
 
133 
           mov byte [mem_block_map], 0xFE
 - 
 
134 
           and [heap_mutex], 0
 - 
 
135 
           mov [heap_blocks], 4096
 - 
 
136 
           mov [free_blocks], 4096
 - 
 
137 
           ret
 - 
 
138 
 
 - 
 
139 
; param
 - 
 
140 
;  eax= required size
 - 
 
141 
;
 - 
 
142 
; retval
 - 
 
143 
;  edi= memory block descriptor
 - 
 
144 
;  ebx= descriptor index
 - 
 
145 
 
 - 
 
146 
align 4
 - 
 
147 
get_small_block:
 - 
 
148 
           mov ecx, eax
 - 
 
149 
           shr ecx, 12
 - 
 
150 
           dec ecx
 - 
 
151 
           cmp ecx, 63
 - 
 
152 
           jle .get_index
 - 
 
153 
           mov ecx, 63
 - 
 
154 
.get_index:
 - 
 
155 
           lea esi, [mem_block_mask]
 - 
 
156 
           xor ebx, ebx
 - 
 
157 
           or edx, -1
 - 
 
158 
 
 - 
 
159 
           cmp ecx, 32
 - 
 
160 
           jb .bit_test
 - 
 
161 
 
 - 
 
162 
           sub ecx, 32
 - 
 
163 
           add ebx, 32
 - 
 
164 
           add esi, 4
 - 
 
165 
.bit_test:
 - 
 
166 
           shl edx, cl
 - 
 
167 
           and edx, [esi]
 - 
 
168 
.find:
 - 
 
169 
           bsf edi, edx
 - 
 
170 
           jz .high_mask
 - 
 
171 
           add ebx, edi
 - 
 
172 
           mov edi, [mem_block_list+ebx*4]
 - 
 
173 
.check_size:
 - 
 
174 
           cmp eax, [edi+block_size]
 - 
 
175 
           ja .next
 - 
 
176 
           ret
 - 
 
177 
 
 - 
 
178 
.high_mask:
 - 
 
179 
           add esi, 4
 - 
 
180 
           cmp esi, mem_block_mask+8
 - 
 
181 
           jae .err
 - 
 
182 
           add ebx, 32
 - 
 
183 
           mov edx, [esi]
 - 
 
184 
           jmp .find
 - 
 
185 
.next:
 - 
 
186 
           mov edi, [edi+list_fd]
 - 
 
187 
           test edi, edi
 - 
 
188 
           jnz .check_size
 - 
 
189 
.err:
 - 
 
190 
           xor edi, edi
 - 
 
191 
           ret
 - 
 
192 
; param
 - 
 
193 
;  eax= required size
 - 
 
194 
;
 - 
 
195 
; retval
 - 
 
196 
;  edi= memory block descriptor
 - 
 
197 
;  ebx= descriptor index
 - 
 
198 
align 4
 - 
 
199 
get_large_block:
 - 
 
200 
           mov edx, -1
 - 
 
201 
           mov ecx, eax
 - 
 
202 
           shr ecx, 22
 - 
 
203 
           dec ecx
 - 
 
204 
           cmp ecx, 31
 - 
 
205 
           jle .get_index
 - 
 
206 
           mov ecx, 31
 - 
 
207 
.get_index:
 - 
 
208 
           shl edx, cl
 - 
 
209 
           and edx, [large_block_mask]
 - 
 
210 
.find:
 - 
 
211 
           bsf edi, edx
 - 
 
212 
           mov ebx, edi
 - 
 
213 
           mov edi, [large_block_list+edi*4]
 - 
 
214 
.check_size:
 - 
 
215 
           cmp eax, [edi+block_size]
 - 
 
216 
           ja .next
 - 
 
217 
           ret
 - 
 
218 
.next:
 - 
 
219 
           mov edi, [edi+list_fd]
 - 
 
220 
           test edi, edi
 - 
 
221 
           jnz .check_size
 - 
 
222 
.fail:
 - 
 
223 
           xor edi, edi
 - 
 
224 
           ret
 - 
 
225 
 
 - 
 
226 
align 4
 - 
 
227 
alloc_mem_block:
 - 
 
228 
 
 - 
 
229 
           mov ebx, [mem_block_start]
 - 
 
230 
           mov ecx, [mem_block_end]
 - 
 
231 
.l1:
 - 
 
232 
           bsf eax,[ebx];
 - 
 
233 
           jnz found
 - 
 
234 
           add ebx,4
 - 
 
235 
           cmp ebx, ecx
 - 
 
236 
           jb .l1
 - 
 
237 
           xor eax,eax
 - 
 
238 
           ret
 - 
 
239 
 
 - 
 
240 
found:
 - 
 
241 
           btr [ebx], eax
 - 
 
242 
           mov [mem_block_start],ebx
 - 
 
243 
           sub ebx, mem_block_map
 - 
 
244 
           lea eax,[eax+ebx*8]
 - 
 
245 
           shl eax, 5
 - 
 
246 
           add eax, [mem_block_arr]
 - 
 
247 
           dec [free_blocks]
 - 
 
248 
           ret
 - 
 
249 
align 4
 - 
 
250 
free_mem_block:
 - 
 
251 
           mov dword [eax], 0
 - 
 
252 
           mov dword [eax+4], 0
 - 
 
253 
           mov dword [eax+8], 0
 - 
 
254 
           mov dword [eax+12], 0
 - 
 
255 
           mov dword [eax+16], 0
 - 
 
256 
;           mov dword [eax+20], 0
 - 
 
257 
           mov dword [eax+24], 0
 - 
 
258 
           mov dword [eax+28], 0
 - 
 
259 
 
 - 
 
260 
           sub eax, [mem_block_arr]
 - 
 
261 
           shr eax, 5
 - 
 
262 
 
 - 
 
263 
           mov ebx, mem_block_map
 - 
 
264 
           bts [ebx], eax
 - 
 
265 
           inc [free_blocks]
 - 
 
266 
           shr eax, 3
 - 
 
267 
           and eax, not 3
 - 
 
268 
           add eax, ebx
 - 
 
269 
           cmp [mem_block_start], eax
 - 
 
270 
           ja @f
 - 
 
271 
           ret
 - 
 
272 
@@:
 - 
 
273 
           mov [mem_block_start], eax
 - 
 
274 
	   ret
 - 
 
275 
.err:
 - 
 
276 
           xor eax, eax
 - 
 
277 
	   ret
 - 
 
278 
 
 - 
 
279 
align 4
 - 
 
280 
proc alloc_kernel_space stdcall, size:dword
 - 
 
281 
           local block_ind:DWORD
 - 
 
282 
 
 - 
 
283 
           push ebx
 - 
 
284 
           push esi
 - 
 
285 
           push edi
 - 
 
286 
 
 - 
 
287 
           mov eax, [size]
 - 
 
288 
           add eax, 4095
 - 
 
289 
           and eax, not 4095
 - 
 
290 
           mov [size], eax
 - 
 
291 
 
 - 
 
292 
           mov ebx, heap_mutex
 - 
 
293 
           call wait_mutex    ;ebx
 - 
 
294 
 
 - 
 
295 
           cmp eax, [heap_free]
 - 
 
296 
           ja .error
 - 
 
297 
 
 - 
 
298 
           call get_small_block ; eax
 - 
 
299 
           test edi, edi
 - 
 
300 
           jz .error
 - 
 
301 
 
 - 
 
302 
           cmp [edi+block_flags], FREE_BLOCK
 - 
 
303 
           jne .error
 - 
 
304 
 
 - 
 
305 
           mov [block_ind], ebx   ;index of allocated block
 - 
 
306 
 
 - 
 
307 
           mov eax, [edi+block_size]
 - 
 
308 
           cmp eax, [size]
 - 
 
309 
           je .m_eq_size
 - 
 
310 
 
 - 
 
311 
           call alloc_mem_block
 - 
 
312 
           test eax, eax
 - 
 
313 
           jz .error
 - 
 
314 
 
 - 
 
315 
           mov esi, eax           ;esi - splitted block
 - 
 
316 
 
 - 
 
317 
           mov [esi+block_next], edi
 - 
 
318 
           mov eax, [edi+block_prev]
 - 
 
319 
           mov [esi+block_prev], eax
 - 
 
320 
           mov [edi+block_prev], esi
 - 
 
321 
           mov [esi+list_fd], 0
 - 
 
322 
           mov [esi+list_bk], 0
 - 
 
323 
           test eax, eax
 - 
 
324 
           jz @f
 - 
 
325 
           mov [eax+block_next], esi
 - 
 
326 
@@:
 - 
 
327 
           mov ebx, [edi+block_base]
 - 
 
328 
           mov [esi+block_base], ebx
 - 
 
329 
           mov edx, [size]
 - 
 
330 
           mov [esi+block_size], edx
 - 
 
331 
           add [edi+block_base], edx
 - 
 
332 
           sub [edi+block_size], edx
 - 
 
333 
 
 - 
 
334 
           mov eax, [edi+block_size]
 - 
 
335 
           shr eax, 12
 - 
 
336 
           sub eax, 1
 - 
 
337 
           cmp eax, 63
 - 
 
338 
           jna @f
 - 
 
339 
           mov eax, 63
 - 
 
340 
@@:
 - 
 
341 
           cmp eax, [block_ind]
 - 
 
342 
           je .m_eq_ind
 - 
 
343 
 
 - 
 
344 
           remove_from_list edi
 - 
 
345 
 
 - 
 
346 
           mov ecx, [block_ind]
 - 
 
347 
           mov [mem_block_list+ecx*4], edx
 - 
 
348 
 
 - 
 
349 
           test edx, edx
 - 
 
350 
           jnz @f
 - 
 
351 
           btr [mem_block_mask], ecx
 - 
 
352 
@@:
 - 
 
353 
           mov edx, [mem_block_list+eax*4]
 - 
 
354 
           mov [edi+list_fd], edx
 - 
 
355 
           test edx, edx
 - 
 
356 
           jz @f
 - 
 
357 
           mov [edx+list_bk], edi
 - 
 
358 
@@:
 - 
 
359 
           mov [mem_block_list+eax*4], edi
 - 
 
360 
           bts [mem_block_mask], eax
 - 
 
361 
.m_eq_ind:
 - 
 
362 
           mov ecx, mem_used.fd-MEM_LIST_OFFSET
 - 
 
363 
           mov edx, [ecx+list_fd]
 - 
 
364 
           mov [esi+list_fd], edx
 - 
 
365 
           mov [esi+list_bk], ecx
 - 
 
366 
           mov [ecx+list_fd], esi
 - 
 
367 
           mov [edx+list_bk], esi
 - 
 
368 
 
 - 
 
369 
           mov [esi+block_flags], USED_BLOCK
 - 
 
370 
           mov eax, [esi+block_base]
 - 
 
371 
           mov ebx, [size]
 - 
 
372 
           sub [heap_free], ebx
 - 
 
373 
           and [heap_mutex], 0
 - 
 
374 
           pop edi
 - 
 
375 
           pop esi
 - 
 
376 
           pop ebx
 - 
 
377 
           ret
 - 
 
378 
.m_eq_size:
 - 
 
379 
           remove_from_list edi
 - 
 
380 
           mov [mem_block_list+ebx*4], edx
 - 
 
381 
           and edx, edx
 - 
 
382 
           jnz @f
 - 
 
383 
           btr [mem_block_mask], ebx
 - 
 
384 
@@:
 - 
 
385 
           mov ecx, mem_used.fd-MEM_LIST_OFFSET
 - 
 
386 
           mov edx, [ecx+list_fd]
 - 
 
387 
           mov [edi+list_fd], edx
 - 
 
388 
           mov [edi+list_bk], ecx
 - 
 
389 
           mov [ecx+list_fd], edi
 - 
 
390 
           mov [edx+list_bk], edi
 - 
 
391 
 
 - 
 
392 
           mov [edi+block_flags], USED_BLOCK
 - 
 
393 
           mov eax, [edi+block_base]
 - 
 
394 
           mov ebx, [size]
 - 
 
395 
           sub [heap_free], ebx
 - 
 
396 
           and [heap_mutex], 0
 - 
 
397 
           pop edi
 - 
 
398 
           pop esi
 - 
 
399 
           pop ebx
 - 
 
400 
           ret
 - 
 
401 
.error:
 - 
 
402 
           xor eax, eax
 - 
 
403 
           mov [heap_mutex], eax
 - 
 
404 
           pop edi
 - 
 
405 
           pop esi
 - 
 
406 
           pop ebx
 - 
 
407 
           ret
 - 
 
Line 408... Line 40...
408 
endp
 40 
 
409 
 
 41 
 
410 
align 4
 - 
 
411 
proc free_kernel_space stdcall uses ebx ecx edx esi edi, base:dword
 - 
 
412 
           push ebx
 - 
 
413 
           push esi
 - 
 
414 
           push edi
 - 
 
415 
           mov ebx, heap_mutex
 - 
 
416 
           call wait_mutex    ;ebx
 - 
 
417 
 
 - 
 
418 
           mov eax, [base]
 - 
 
419 
           mov esi, [mem_used.fd]
 - 
 
420 
@@:
 - 
 
421 
           cmp esi, mem_used.fd-MEM_LIST_OFFSET
 - 
 
422 
           je .fail
 - 
 
423 
 
 - 
 
424 
           cmp [esi+block_base], eax
 - 
 
425 
           je .found
 - 
 
426 
           mov esi, [esi+list_fd]
 - 
 
427 
           jmp @b
 - 
 
428 
.found:
 - 
 
429 
           cmp [esi+block_flags], USED_BLOCK
 - 
 
430 
           jne .fail
 - 
 
431 
 
 - 
 
432 
           mov eax, [esi+block_size]
 - 
 
433 
           add [heap_free], eax
 - 
 
434 
 
 - 
 
435 
           mov edi, [esi+block_next]
 - 
 
436 
           test edi, edi
 - 
 
437 
           jz .prev
 - 
 
438 
 
 - 
 
439 
           cmp [edi+block_flags], FREE_BLOCK
 - 
 
440 
           jne .prev
 - 
 
441 
 
 - 
 
442 
           remove_from_free edi
 - 
 
443 
 
 - 
 
444 
           mov edx, [edi+block_next]
 - 
 
445 
           mov [esi+block_next], edx
 - 
 
446 
           test edx, edx
 - 
 
447 
           jz @f
 - 
 
448 
 
 - 
 
449 
           mov [edx+block_prev], esi
 - 
 
450 
@@:
 - 
 
451 
           mov ecx, [edi+block_size]
 - 
 
452 
           add [esi+block_size], ecx
 - 
 
453 
 
 - 
 
454 
           mov eax, edi
 - 
 
455 
           call free_mem_block
 - 
 
456 
.prev:
 - 
 
457 
           mov edi, [esi+block_prev]
 - 
 
458 
           test edi, edi
 - 
 
459 
           jz .insert
 - 
 
460 
 
 - 
 
461 
           cmp [edi+block_flags], FREE_BLOCK
 - 
 
462 
           jne .insert
 - 
 
463 
 
 - 
 
464 
           remove_from_used esi
 - 
 
465 
 
 - 
 
466 
           mov edx, [esi+block_next]
 - 
 
467 
           mov [edi+block_next], edx
 - 
 
468 
           test edx, edx
 - 
 
469 
           jz @f
 - 
 
470 
           mov [edx+block_prev], edi
 - 
 
471 
@@:
 - 
 
472 
           mov eax, esi
 - 
 
473 
           call free_mem_block
 - 
 
474 
 
 - 
 
475 
           mov ecx, [edi+block_size]
 - 
 
476 
           mov eax, [esi+block_size]
 - 
 
477 
           add eax, ecx
 - 
 
478 
           mov [edi+block_size], eax
 - 
 
479 
 
 - 
 
480 
           calc_index eax
 - 
 
481 
           calc_index ecx
 - 
 
482 
           cmp eax, ecx
 - 
 
483 
           je .m_eq
 - 
 
484 
 
 - 
 
485 
           push ecx
 - 
 
486 
           remove_from_list edi
 - 
 
487 
           pop ecx
 - 
 
488 
 
 - 
 
489 
           cmp [mem_block_list+ecx*4], edi
 - 
 
490 
           jne @f
 - 
 
491 
           mov [mem_block_list+ecx*4], edx
 - 
 
492 
@@:
 - 
 
493 
           cmp [mem_block_list+ecx*4], 0
 - 
 
494 
           jne @f
 - 
 
495 
           btr [mem_block_mask], ecx
 - 
 
496 
@@:
 - 
 
497 
           mov esi, [mem_block_list+eax*4]
 - 
 
498 
           mov [mem_block_list+eax*4], edi
 - 
 
499 
           mov [edi+list_fd], esi
 - 
 
500 
           test esi, esi
 - 
 
501 
           jz @f
 - 
 
502 
           mov [esi+list_bk], edi
 - 
 
503 
@@:
 - 
 
504 
           bts [mem_block_mask], eax
 - 
 
505 
.m_eq:
 - 
 
506 
           xor eax, eax
 - 
 
507 
           mov [heap_mutex], eax
 - 
 
508 
           dec eax
 - 
 
509 
           pop edi
 - 
 
510 
           pop esi
 - 
 
511 
           pop ebx
 - 
 
512 
           ret
 - 
 
Line 513... Line -...
513 
.insert:
 - 
 
514 
           remove_from_used esi
 - 
 
515 
 
 - 
 
516 
           mov eax, [esi+block_size]
 - 
 
517 
           calc_index eax
 - 
 
518 
 
 - 
 
519 
           mov edi, [mem_block_list+eax*4]
 - 
 
520 
           mov [mem_block_list+eax*4], esi
 - 
 
521 
           mov [esi+list_fd], edi
 - 
 
522 
           test edi, edi
 - 
 
523 
           jz @f
 - 
 
524 
           mov [edi+list_bk], esi
 - 
 
525 
@@:
 - 
 
526 
           bts [mem_block_mask], eax
 - 
 
527 
           mov [esi+block_flags],FREE_BLOCK
 - 
 
528 
           xor eax, eax
 - 
 
529 
           mov [heap_mutex], eax
 - 
 
530 
           dec eax
 - 
 
531 
           pop edi
 - 
 
532 
           pop esi
 - 
 
533 
           pop ebx
 - 
 
534 
           ret
 - 
 
535 
.fail:
 - 
 
536 
           xor eax, eax
 - 
 
537 
           mov [heap_mutex], eax
 - 
 
538 
           pop edi
 42 
align 4
539 
           pop esi
 43 
proc free_kernel_space stdcall uses ebx ecx edx esi edi, base:dword
Line 540... Line 44...
540 
           pop ebx
 44 
 
541 
           ret
 45 
           ret
Line 553... Line 57...
553 
 
 57 
 
554 
           mov eax, [size]
 58 
           mov eax, [size]
555 
           add eax, 4095
 59 
           add eax, 4095
556 
           and eax, not 4095;
 60 
           and eax, not 4095;
557 
           mov [size], eax
 61 
           mov [size], eax
558 
           and eax, eax
 62 
           test eax, eax
- 
 
 63 
           jz .err
559 
           jz .err
 64 
 
560 
           mov ebx, eax
 65 
           mov ebx, eax
561 
           shr ebx, 12
 66 
           shr ebx, 12
Line 562... Line 67...
562 
           mov [pages_count], ebx
 67 
           mov [pages_count], ebx
Line 615... Line 120...
615 
           ret
 120 
           ret
616 
endp
 121 
endp
Line 617... Line 122...
617 
 
 122 
 
618 
align 4
 123 
align 4
619 
proc kernel_free stdcall, base:dword
 - 
 
620 
           push ebx esi
 - 
 
621 
 
 - 
 
622 
           mov ebx, heap_mutex
 - 
 
623 
           call wait_mutex    ;ebx
 - 
 
624 
 
 - 
 
625 
           mov eax, [base]
 - 
 
626 
           mov esi, [mem_used.fd]
 - 
 
627 
@@:
 - 
 
628 
           cmp esi, mem_used.fd-MEM_LIST_OFFSET
 - 
 
629 
           je .fail
 - 
 
630 
 
 - 
 
631 
           cmp [esi+block_base], eax
 - 
 
632 
           je .found
 - 
 
633 
           mov esi, [esi+list_fd]
 - 
 
634 
           jmp @b
 - 
 
635 
.found:
 - 
 
636 
           cmp [esi+block_flags], USED_BLOCK
 - 
 
Line 637... Line -...
637 
           jne .fail
 - 
 
638 
 
 - 
 
639 
           and [heap_mutex], 0
 - 
 
640 
 
 - 
 
641 
           push ecx
 - 
 
642 
           mov ecx, [esi+block_size];
 - 
 
643 
           shr ecx, 12
 - 
 
644 
           call release_pages   ;eax, ecx
 - 
 
645 
           pop ecx
 - 
 
646 
           stdcall free_kernel_space, [base]
 - 
 
647 
           pop esi ebx
 - 
 
648 
           ret
 - 
 
649 
.fail:
 - 
 
650 
           and [heap_mutex], 0
 124 
proc kernel_free stdcall, base:dword
651 
           pop esi ebx
 125 
 
Line 652... Line -...
652 
           ret
 - 
 
653 
endp
 - 
 
654 
 
 - 
 
655 
 
 - 
 
656 
align 4
 - 
 
657 
proc alloc_large stdcall, size:dword
 - 
 
658 
           local block_ind:DWORD
 - 
 
659 
 
 - 
 
660 
           push ebx
 - 
 
661 
           push esi
 - 
 
662 
           push edi
 - 
 
663 
 
 - 
 
664 
           mov eax, [size]
 - 
 
665 
           add eax, 0x3FFFFF
 - 
 
666 
           and eax, not 0x3FFFFF
 - 
 
667 
           mov [size], eax
 - 
 
668 
 
 - 
 
669 
         ;  mov ebx, heap_mutex
 - 
 
670 
         ;  call wait_mutex    ;ebx
 - 
 
671 
 
 - 
 
672 
         ;  cmp eax, [heap_free]
 - 
 
673 
         ;  ja .error
 - 
 
674 
 
 - 
 
675 
           call get_large_block ; eax
 - 
 
676 
           test edi, edi
 - 
 
677 
           jz .error
 - 
 
678 
 
 - 
 
679 
           cmp [edi+block_flags], FREE_BLOCK
 - 
 
680 
           jne .error
 - 
 
681 
 
 - 
 
682 
           mov [block_ind], ebx   ;index of allocated block
 - 
 
683 
 
 - 
 
684 
           mov eax, [edi+block_size]
 - 
 
685 
           cmp eax, [size]
 - 
 
686 
           je .m_eq_size
 - 
 
687 
 
 - 
 
688 
           call alloc_mem_block
 - 
 
689 
           and eax, eax
 - 
 
690 
           jz .error
 - 
 
691 
 
 - 
 
692 
           mov esi, eax           ;esi - splitted block
 - 
 
693 
 
 - 
 
694 
           mov [esi+block_next], edi
 - 
 
695 
           mov eax, [edi+block_prev]
 - 
 
696 
           mov [esi+block_prev], eax
 - 
 
697 
           mov [edi+block_prev], esi
 - 
 
698 
           mov [esi+list_fd], 0
 - 
 
699 
           mov [esi+list_bk], 0
 - 
 
700 
           test eax, eax
 - 
 
701 
           jz @f
 - 
 
702 
           mov [eax+block_next], esi
 - 
 
703 
@@:
 - 
 
704 
           mov ebx, [edi+block_base]
 - 
 
705 
           mov [esi+block_base], ebx
 - 
 
706 
           mov edx, [size]
 - 
 
707 
           mov [esi+block_size], edx
 - 
 
708 
           add [edi+block_base], edx
 - 
 
709 
           sub [edi+block_size], edx
 - 
 
710 
 
 - 
 
711 
           mov eax, [edi+block_size]
 - 
 
712 
           shr eax, 22
 - 
 
713 
           dec eax
 - 
 
714 
           cmp eax, 31
 - 
 
715 
           jna @f
 - 
 
716 
           mov eax, 31
 - 
 
717 
@@:
 - 
 
718 
           cmp eax, [block_ind]
 - 
 
719 
           je .m_eq_ind
 - 
 
720 
 
 - 
 
721 
           remove_from_list edi
 - 
 
722 
 
 - 
 
723 
           mov ecx, [block_ind]
 - 
 
724 
           mov [large_block_list+ecx*4], edx
 - 
 
725 
 
 - 
 
726 
           test edx, edx
 - 
 
727 
           jnz @f
 - 
 
728 
           btr [large_block_mask], ecx
 - 
 
729 
@@:
 - 
 
730 
           mov edx, [large_block_list+eax*4]
 - 
 
731 
           mov [edi+list_fd], edx
 - 
 
732 
           test edx, edx
 - 
 
733 
           jz @f
 - 
 
734 
           mov [edx+list_bk], edi
 - 
 
735 
@@:
 - 
 
736 
           mov [large_block_list+eax*4], edi
 - 
 
737 
           bts [large_block_mask], eax
 - 
 
738 
.m_eq_ind:
 - 
 
739 
           mov ecx, mem_used.fd-MEM_LIST_OFFSET
 - 
 
740 
           mov edx, [ecx+list_fd]
 - 
 
741 
           mov [esi+list_fd], edx
 - 
 
742 
           mov [esi+list_bk], ecx
 - 
 
743 
           mov [ecx+list_fd], esi
 - 
 
744 
           mov [edx+list_bk], esi
 - 
 
745 
 
 - 
 
746 
           mov [esi+block_flags], USED_BLOCK
 - 
 
747 
           mov eax, [esi+block_base]
 - 
 
748 
           mov ebx, [size]
 - 
 
749 
           sub [heap_free], ebx
 - 
 
750 
           and [heap_mutex], 0
 - 
 
751 
           pop edi
 - 
 
752 
           pop esi
 - 
 
753 
           pop ebx
 - 
 
754 
           ret
 - 
 
755 
.m_eq_size:
 - 
 
756 
           remove_from_list edi
 - 
 
757 
           mov [large_block_list+ebx*4], edx
 - 
 
758 
           and edx, edx
 - 
 
759 
           jnz @f
 - 
 
760 
           btr [large_block_mask], ebx
 - 
 
761 
@@:
 - 
 
762 
           mov ecx, mem_used.fd-MEM_LIST_OFFSET
 - 
 
763 
           mov edx, [ecx+list_fd]
 - 
 
764 
           mov [edi+list_fd], edx
 - 
 
765 
           mov [edi+list_bk], ecx
 - 
 
766 
           mov [ecx+list_fd], edi
 - 
 
767 
           mov [edx+list_bk], edi
 - 
 
768 
 
 - 
 
769 
           mov [edi+block_flags], USED_BLOCK
 - 
 
770 
           mov eax, [edi+block_base]
 - 
 
771 
           mov ebx, [size]
 - 
 
772 
           sub [heap_free], ebx
 - 
 
773 
           and [heap_mutex], 0
 - 
 
774 
           pop edi
 - 
 
775 
           pop esi
 - 
 
776 
           pop ebx
 - 
 
777 
           ret
 - 
 
778 
.error:
 - 
 
779 
           xor eax, eax
 - 
 
780 
           mov [heap_mutex], eax
 - 
 
781 
           pop edi
 - 
 
Line 782... Line 126...
782 
           pop esi
 126 
           ret
783 
           pop ebx
 127 
endp
784 
           ret
 128 
 
785 
endp
 129