crypt32: Implement CertFindCRLInStore for find type CRL_FIND_ISSUED_FOR.
[wine] / dlls / winedos / dosmem.c
1 /*
2  * DOS memory emulation
3  *
4  * Copyright 1995 Alexandre Julliard
5  * Copyright 1996 Marcus Meissner
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <signal.h>
26 #include <stdarg.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <sys/types.h>
30 #ifdef HAVE_SYS_MMAN_H
31 # include <sys/mman.h>
32 #endif
33
34 #include "windef.h"
35 #include "winbase.h"
36 #include "winreg.h"
37 #include "excpt.h"
38 #include "winternl.h"
39 #include "wine/winbase16.h"
40
41 #include "dosexe.h"
42 #include "wine/debug.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(dosmem);
45
46 /* DOS memory highest address (including HMA) */
47 #define DOSMEM_SIZE             0x110000
48 #define DOSMEM_64KB             0x10000
49
50 /* see dlls/kernel/dosmem.c for the details */
51 static char *DOSMEM_dosmem;
52 static char *DOSMEM_sysmem;
53
54 /*
55  * Memory Control Block (MCB) definition
56  * FIXME: implement Allocation Strategy
57  */
58
59 #define MCB_DUMP(mc) \
60     TRACE ("MCB_DUMP base=%p type=%02xh psp=%04xh size=%04xh\n", mc, mc->type, mc->psp , mc->size )
61  
62 #define MCB_NEXT(mc) \
63     (MCB*) ((mc->type==MCB_TYPE_LAST) ? NULL : (char*)(mc) + ((mc->size + 1) << 4) )
64
65 /* FIXME: should we check more? */
66 #define MCB_VALID(mc) \
67     ((mc->type==MCB_TYPE_NORMAL) || (mc->type==MCB_TYPE_LAST))
68
69
70 #define MCB_TYPE_NORMAL    0x4d
71 #define MCB_TYPE_LAST      0x5a
72
73 #define MCB_PSP_DOS        0x0060  
74 #define MCB_PSP_FREE       0
75
76 #include "pshpack1.h"
77 typedef struct {
78     BYTE type;
79     WORD psp;     /* segment of owner psp */
80     WORD size;    /* in paragraphs */
81     BYTE pad[3];
82     BYTE name[8];
83 } MCB;
84 #include "poppack.h"
85
86 /*
87 #define __DOSMEM_DEBUG__
88  */
89
90 #define VM_STUB(x) (0x90CF00CD|(x<<8)) /* INT x; IRET; NOP */
91 #define VM_STUB_SEGMENT 0xf000         /* BIOS segment */
92
93 /* FIXME: this should be moved to the LOL */
94 static MCB* DOSMEM_root_block;
95
96 /***********************************************************************
97  *           DOSMEM_MemoryTop
98  *
99  * Gets the DOS memory top.
100  */
101 static char *DOSMEM_MemoryTop(void)
102 {
103     return DOSMEM_dosmem+0x9FFFC; /* 640K */
104 }
105
106 /***********************************************************************
107  *           DOSMEM_FillIsrTable
108  *
109  * Fill the interrupt table with fake BIOS calls to BIOSSEG (0xf000).
110  *
111  * NOTES:
112  * Linux normally only traps INTs performed from or destined to BIOSSEG
113  * for us to handle, if the int_revectored table is empty. Filling the
114  * interrupt table with calls to INT stubs in BIOSSEG allows DOS programs
115  * to hook interrupts, as well as use their familiar retf tricks to call
116  * them, AND let Wine handle any unhooked interrupts transparently.
117  */
118 static void DOSMEM_FillIsrTable(void)
119 {
120     SEGPTR *isr = (SEGPTR*)DOSMEM_sysmem;
121     int x;
122
123     for (x=0; x<256; x++) isr[x]=MAKESEGPTR(VM_STUB_SEGMENT,x*4);
124 }
125
126 static void DOSMEM_MakeIsrStubs(void)
127 {
128     DWORD *stub = (DWORD*)(DOSMEM_dosmem + (VM_STUB_SEGMENT << 4));
129     int x;
130
131     for (x=0; x<256; x++) stub[x]=VM_STUB(x);
132 }
133
134 BIOSDATA* DOSVM_BiosData(void)
135 {
136     return (BIOSDATA *)(DOSMEM_sysmem + 0x400);
137 }
138
139 /**********************************************************************
140  *          DOSMEM_GetTicksSinceMidnight
141  *
142  * Return number of clock ticks since midnight.
143  */
144 static DWORD DOSMEM_GetTicksSinceMidnight(void)
145 {
146     SYSTEMTIME time;
147
148     /* This should give us the (approximately) correct
149      * 18.206 clock ticks per second since midnight.
150      */
151
152     GetLocalTime( &time );
153
154     return (((time.wHour * 3600 + time.wMinute * 60 +
155               time.wSecond) * 18206) / 1000) +
156              (time.wMilliseconds * 1000 / 54927);
157 }
158
159 /***********************************************************************
160  *           DOSMEM_FillBiosSegments
161  *
162  * Fill the BIOS data segment with dummy values.
163  */
164 static void DOSMEM_FillBiosSegments(void)
165 {
166     BYTE *pBiosSys = (BYTE*)DOSMEM_dosmem + 0xf0000;
167     BYTE *pBiosROMTable = pBiosSys+0xe6f5;
168     BIOSDATA *pBiosData = DOSVM_BiosData();
169     static const char bios_date[] = "13/01/99";
170
171       /* Clear all unused values */
172     memset( pBiosData, 0, sizeof(*pBiosData) );
173
174     /* FIXME: should check the number of configured drives and ports */
175     pBiosData->Com1Addr             = 0x3f8;
176     pBiosData->Com2Addr             = 0x2f8;
177     pBiosData->Lpt1Addr             = 0x378;
178     pBiosData->Lpt2Addr             = 0x278;
179     pBiosData->InstalledHardware    = 0x5463;
180     pBiosData->MemSize              = 640;
181     pBiosData->NextKbdCharPtr       = 0x1e;
182     pBiosData->FirstKbdCharPtr      = 0x1e;
183     pBiosData->VideoMode            = 3;
184     pBiosData->VideoColumns         = 80;
185     pBiosData->VideoPageSize        = 80 * 25 * 2;
186     pBiosData->VideoPageStartAddr   = 0xb800;
187     pBiosData->VideoCtrlAddr        = 0x3d4;
188     pBiosData->Ticks                = DOSMEM_GetTicksSinceMidnight();
189     pBiosData->NbHardDisks          = 2;
190     pBiosData->KbdBufferStart       = 0x1e;
191     pBiosData->KbdBufferEnd         = 0x3e;
192     pBiosData->RowsOnScreenMinus1   = 24;
193     pBiosData->BytesPerChar         = 0x10;
194     pBiosData->ModeOptions          = 0x64;
195     pBiosData->FeatureBitsSwitches  = 0xf9;
196     pBiosData->VGASettings          = 0x51;
197     pBiosData->DisplayCombination   = 0x08;
198     pBiosData->DiskDataRate         = 0;
199
200     /* fill ROM configuration table (values from Award) */
201     *(pBiosROMTable+0x0)        = 0x08; /* number of bytes following LO */
202     *(pBiosROMTable+0x1)        = 0x00; /* number of bytes following HI */
203     *(pBiosROMTable+0x2)        = 0xfc; /* model */
204     *(pBiosROMTable+0x3)        = 0x01; /* submodel */
205     *(pBiosROMTable+0x4)        = 0x00; /* BIOS revision */
206     *(pBiosROMTable+0x5)        = 0x74; /* feature byte 1 */
207     *(pBiosROMTable+0x6)        = 0x00; /* feature byte 2 */
208     *(pBiosROMTable+0x7)        = 0x00; /* feature byte 3 */
209     *(pBiosROMTable+0x8)        = 0x00; /* feature byte 4 */
210     *(pBiosROMTable+0x9)        = 0x00; /* feature byte 5 */
211
212     /* BIOS date string */
213     memcpy(pBiosSys+0xfff5, bios_date, sizeof bios_date);
214
215     /* BIOS ID */
216     *(pBiosSys+0xfffe) = 0xfc;
217
218     /* Reboot vector (f000:fff0 or ffff:0000) */
219     *(DWORD*)(pBiosSys + 0xfff0) = VM_STUB(0x19);
220 }
221
222 /***********************************************************************
223  *           BiosTick
224  *
225  * Increment the BIOS tick counter. Called by timer signal handler.
226  */
227 static void CALLBACK BiosTick( LPVOID arg, DWORD low, DWORD high )
228 {
229     BIOSDATA *pBiosData = arg;
230     pBiosData->Ticks++;
231 }
232
233 /***********************************************************************
234  *           timer_thread
235  */
236 static DWORD CALLBACK timer_thread( void *arg )
237 {
238     LARGE_INTEGER when;
239     HANDLE timer;
240
241     if (!(timer = CreateWaitableTimerA( NULL, FALSE, NULL ))) return 0;
242
243     when.u.LowPart = when.u.HighPart = 0;
244     SetWaitableTimer( timer, &when, 55 /* actually 54.925 */, BiosTick, arg, FALSE );
245     for (;;) SleepEx( INFINITE, TRUE );
246 }
247
248 /***********************************************************************
249  *           DOSMEM_Collapse
250  *
251  * Helper function for internal use only.
252  * Attach all following free blocks to this one, even if this one is not free.
253  */
254 static void DOSMEM_Collapse( MCB* mcb )
255 {
256     MCB* next = MCB_NEXT( mcb );
257
258     while (next && next->psp == MCB_PSP_FREE)
259     {
260         mcb->size = mcb->size + next->size + 1;
261         mcb->type = next->type;    /* make sure keeping MCB_TYPE_LAST */
262         next = MCB_NEXT( next );
263     }
264 }
265
266 /***********************************************************************
267  *           DOSMEM_AllocBlock
268  *
269  * Carve a chunk of the DOS memory block (without selector).
270  */
271 LPVOID DOSMEM_AllocBlock(UINT size, UINT16* pseg)
272 {
273     MCB *curr = DOSMEM_root_block;
274     MCB *next = NULL;
275     WORD psp = DOSVM_psp;
276     
277     if (!psp)
278         psp = MCB_PSP_DOS;
279     
280     *pseg = 0;
281     
282     TRACE( "(%04xh)\n", size );
283     
284     /* round up to paragraph */
285     size = (size + 15) >> 4;
286
287 #ifdef __DOSMEM_DEBUG__
288     DOSMEM_Available();     /* checks the whole MCB list */
289 #endif
290     
291     /* loop over all MCB and search the next large enough MCB */
292     while (curr)
293     {
294         if (!MCB_VALID (curr))
295         {
296             ERR( "MCB List Corrupt\n" );
297             MCB_DUMP( curr );
298             return NULL;
299         }
300         if (curr->psp == MCB_PSP_FREE)
301         {
302             DOSMEM_Collapse( curr );            
303             /* is it large enough (one paragraph for the MCB)? */
304             if (curr->size >= size)
305             {
306                 if (curr->size > size)
307                 {
308                     /* split curr */
309                     next = (MCB *) ((char*) curr + ((size+1) << 4));
310                     next->psp = MCB_PSP_FREE;
311                     next->size = curr->size - (size+1);
312                     next->type = curr->type;
313                     curr->type = MCB_TYPE_NORMAL;
314                     curr->size = size;
315                 }
316                 /* curr is the found block */
317                 curr->psp = psp;
318                 if( pseg ) *pseg = (((char*)curr) + 16 - DOSMEM_dosmem) >> 4;
319                 return (LPVOID) ((char*)curr + 16);
320             }
321         }
322         curr = MCB_NEXT(curr);
323     }
324     return NULL;
325 }
326
327 /***********************************************************************
328  *           DOSMEM_FreeBlock
329  */
330 BOOL DOSMEM_FreeBlock(void* ptr)
331 {
332     MCB* mcb = (MCB*) ((char*)ptr - 16);
333     
334     TRACE( "(%p)\n", ptr );
335
336 #ifdef __DOSMEM_DEBUG__
337     DOSMEM_Available();
338 #endif
339     
340     if (!MCB_VALID (mcb))
341     {
342         ERR( "MCB invalid\n" );
343         MCB_DUMP( mcb );
344         return FALSE;
345     }
346     
347     mcb->psp = MCB_PSP_FREE;
348     DOSMEM_Collapse( mcb );
349     return TRUE;
350 }
351
352 /***********************************************************************
353  *           DOSMEM_ResizeBlock
354  *
355  * Resize DOS memory block in place. Returns block size or -1 on error.
356  *
357  * If exact is TRUE, returned value is either old or requested block
358  * size. If exact is FALSE, block is expanded even if there is not
359  * enough space for full requested block size.
360  *
361  * TODO: return also biggest block size
362  */
363 UINT DOSMEM_ResizeBlock(void *ptr, UINT size, BOOL exact)
364 {
365     MCB* mcb = (MCB*) ((char*)ptr - 16);
366     MCB* next;
367     
368     TRACE( "(%p,%04xh,%s)\n", ptr, size, exact ? "TRUE" : "FALSE" );
369     
370     /* round up to paragraph */
371     size = (size + 15) >> 4;
372
373 #ifdef __DOSMEM_DEBUG__
374     DOSMEM_Available();
375 #endif
376     
377     if (!MCB_VALID (mcb))
378     {
379         ERR( "MCB invalid\n" );
380         MCB_DUMP( mcb );
381         return -1;
382     }
383
384     /* resize needed? */
385     if (mcb->size == size)
386         return size << 4;
387
388     /* collapse free blocks */
389     DOSMEM_Collapse( mcb );    
390     
391     /* shrink mcb ? */
392     if (mcb->size > size)
393     {
394         next = (MCB *) ((char*)mcb + ((size+1) << 4));
395         next->type = mcb->type;
396         next->psp = MCB_PSP_FREE;
397         next->size = mcb->size - (size+1);
398         mcb->type = MCB_TYPE_NORMAL;
399         mcb->size = size;
400         return size << 4;
401     }
402     
403     if (!exact)
404     {
405         return mcb->size << 4;
406     }
407     
408     return -1;
409 }
410
411 /***********************************************************************
412  *           DOSMEM_Available
413  */
414 UINT DOSMEM_Available(void)
415 {
416     UINT  available = 0;
417     UINT  total = 0;
418     MCB *curr = DOSMEM_root_block;
419     /* loop over all MCB and search the largest free MCB */
420     while (curr)
421     {
422 #ifdef __DOSMEM_DEBUG__
423         MCB_DUMP( curr );
424 #endif
425         if (!MCB_VALID (curr))
426         {
427             ERR( "MCB List Corrupt\n" );
428             MCB_DUMP( curr );
429             return 0;
430         }
431         if (curr->psp == MCB_PSP_FREE &&
432             curr->size > available )
433             available = curr->size;
434         
435         total += curr->size + 1;
436         curr = MCB_NEXT( curr );
437     }
438     TRACE( " %04xh of %04xh paragraphs available\n", available, total );
439     return available << 4;   
440 }
441
442 /***********************************************************************
443  *           DOSMEM_InitMemory
444  *
445  * Initialises the DOS memory structures.
446  */
447 static void DOSMEM_InitMemory(char* addr)
448 {
449     DOSMEM_FillBiosSegments();
450     DOSMEM_FillIsrTable();
451
452     /* align root block to paragraph */
453     DOSMEM_root_block = (MCB*) (( (DWORD_PTR)(addr+0xf) >> 4) << 4);
454     DOSMEM_root_block->type = MCB_TYPE_LAST;
455     DOSMEM_root_block->psp = MCB_PSP_FREE;
456     DOSMEM_root_block->size = (DOSMEM_MemoryTop() - ((char*)DOSMEM_root_block)) >> 4;
457
458     TRACE("DOS conventional memory initialized, %d bytes free.\n",
459           DOSMEM_Available());
460 }
461
462 /******************************************************************
463  *             DOSMEM_InitDosMemory
464  *
465  * When WineDOS is loaded, initializes the current DOS memory layout.
466  */
467 BOOL DOSMEM_InitDosMemory(void)
468 {
469     HMODULE16           hModule;
470     unsigned short      sel;
471     LDT_ENTRY           entry;
472     DWORD               reserve;
473
474     if (!(hModule = GetModuleHandle16("KERNEL"))) return FALSE;
475     /* KERNEL.194: __F000H */
476     sel = LOWORD(GetProcAddress16(hModule, (LPCSTR)(ULONG_PTR)194));
477     wine_ldt_get_entry(sel, &entry);
478     DOSMEM_dosmem = (char*)wine_ldt_get_base(&entry) - 0xF0000;
479     /* KERNEL.183: __0000H */
480     sel = LOWORD(GetProcAddress16(hModule, (LPCSTR)(DWORD_PTR)183));
481     wine_ldt_get_entry(sel, &entry);
482     DOSMEM_sysmem = wine_ldt_get_base(&entry);
483
484     /*
485      * Reserve either:
486      * - lowest 64k for NULL pointer catching (Win16)
487      * - lowest 1k for interrupt handlers and
488      *   another 0.5k for BIOS, DOS and intra-application
489      *   areas (DOS)
490      */
491     if (DOSMEM_dosmem != DOSMEM_sysmem)
492         reserve = 0x10000; /* 64k */
493     else
494         reserve = 0x600; /* 1.5k */
495
496     /*
497      * Round to paragraph boundary in order to make
498      * sure the alignment is correct.
499      */
500     reserve = ((reserve + 15) >> 4) << 4;
501
502     /*
503      * Set DOS memory base and initialize conventional memory.
504      */
505     DOSMEM_InitMemory(DOSMEM_dosmem + reserve);
506
507     CloseHandle( CreateThread( NULL, 0, timer_thread, DOSVM_BiosData(), 0, NULL ));
508     return TRUE;
509 }
510
511 /******************************************************************
512  *              DOSMEM_MapDosLayout
513  *
514  * Initialize the first MB of memory to look like a real DOS setup
515  */
516 BOOL DOSMEM_MapDosLayout(void)
517 {
518     static int already_mapped;
519
520     if (!already_mapped)
521     {
522         HMODULE16       hModule;
523         unsigned short  sel;
524         LDT_ENTRY       entry;
525
526         if (DOSMEM_dosmem || !VirtualProtect( NULL, DOSMEM_SIZE, PAGE_EXECUTE_READWRITE, NULL ))
527         {
528             ERR( "Need full access to the first megabyte for DOS mode\n" );
529             ExitProcess(1);
530         }
531         /* copy the BIOS and ISR area down */
532         memcpy( DOSMEM_dosmem, DOSMEM_sysmem, 0x400 + 0x100 );
533         DOSMEM_sysmem = DOSMEM_dosmem;
534         hModule = GetModuleHandle16("KERNEL");
535         /* selector to 0000H */
536         sel = LOWORD(GetProcAddress16(hModule, (LPCSTR)(DWORD_PTR)183));
537         wine_ldt_get_entry(sel, &entry);
538         wine_ldt_set_base(&entry, NULL);
539         wine_ldt_set_entry(sel, &entry);
540         /* selector to BiosData */
541         sel = LOWORD(GetProcAddress16(hModule, (LPCSTR)(DWORD_PTR)193));
542         wine_ldt_get_entry(sel, &entry);
543         wine_ldt_set_base(&entry, (const void*)0x400);
544         wine_ldt_set_entry(sel, &entry);
545         /* we may now need the actual interrupt stubs, and since we've just moved the
546          * interrupt vector table away, we can fill the area with stubs instead... */
547         DOSMEM_MakeIsrStubs();
548         already_mapped = 1;
549     }
550     return TRUE;
551 }