4 * Copyright 1998 Ove Kåven
6 * This code hasn't been completely cleaned up yet.
18 #include <sys/types.h>
22 #include "wine/winbase16.h"
27 #include "selectors.h"
32 #include "debugtools.h"
39 DEFAULT_DEBUG_CHANNEL(module
)
43 #ifdef HAVE_SYS_MMAN_H
44 # include <sys/mman.h>
47 /* define this to try mapping through /proc/pid/mem instead of a temp file,
48 but Linus doesn't like mmapping /proc/pid/mem, so it doesn't work for me */
51 #define BIOS_DATA_SEGMENT 0x40
52 #define START_OFFSET 0
55 #define SEG16(ptr,seg) ((LPVOID)((BYTE*)ptr+((DWORD)(seg)<<4)))
56 #define SEGPTR16(ptr,segptr) ((LPVOID)((BYTE*)ptr+((DWORD)SELECTOROF(segptr)<<4)+OFFSETOF(segptr)))
58 static void MZ_InitPSP( LPVOID lpPSP
, LPCSTR cmdline
, WORD env
)
61 const char*cmd
=cmdline
?strchr(cmdline
,' '):NULL
;
63 psp
->int20
=0x20CD; /* int 20 */
64 /* some programs use this to calculate how much memory they need */
65 psp
->nextParagraph
=0x9FFF;
70 /* command.com doesn't do this */
71 while (*cmd
== ' ') cmd
++;
73 psp
->cmdLine
[0]=strlen(cmd
);
74 strcpy(psp
->cmdLine
+1,cmd
);
75 psp
->cmdLine
[psp
->cmdLine
[0]+1]='\r';
76 } else psp
->cmdLine
[1]='\r';
77 /* FIXME: integrate the memory stuff from Wine (msdos/dosmem.c) */
78 /* FIXME: integrate the PDB stuff from Wine (loader/task.c) */
81 /* default INT 08 handler: increases timer tick counter but not much more */
83 0xCD,0x1C, /* int $0x1c */
86 0xB8,0x40,0x00, /* movw $0x40,%ax */
87 0x8E,0xD8, /* movw %ax,%ds */
89 0x83,0x06,0x6C,0x00,0x01, /* addw $1,(0x6c) */
90 0x83,0x16,0x6E,0x00,0x00, /* adcw $0,(0x6e) */
92 0x66,0xFF,0x06,0x6C,0x00, /* incl (0x6c) */
94 0xB0,0x20, /* movb $0x20,%al */
95 0xE6,0x20, /* outb %al,$0x20 */
101 static void MZ_InitHandlers( LPDOSTASK lpDosTask
)
104 LPBYTE start
=DOSMEM_GetBlock(lpDosTask
->hModule
,sizeof(int08
),&seg
);
105 memcpy(start
,int08
,sizeof(int08
));
106 /* INT 08: point it at our tick-incrementing handler */
107 ((SEGPTR
*)(lpDosTask
->img
))[0x08]=PTR_SEG_OFF_TO_SEGPTR(seg
,0);
108 /* INT 1C: just point it to IRET, we don't want to handle it ourselves */
109 ((SEGPTR
*)(lpDosTask
->img
))[0x1C]=PTR_SEG_OFF_TO_SEGPTR(seg
,sizeof(int08
)-1);
112 static char enter_xms
[]={
113 /* XMS hookable entry point */
114 0xEB,0x03, /* jmp entry */
115 0x90,0x90,0x90, /* nop;nop;nop */
117 /* real entry point */
118 /* for simplicity, we'll just use the same hook as DPMI below */
119 0xCD,0x31, /* int $0x31 */
123 static void MZ_InitXMS( LPDOSTASK lpDosTask
)
125 LPBYTE start
=DOSMEM_GetBlock(lpDosTask
->hModule
,sizeof(enter_xms
),&(lpDosTask
->xms_seg
));
126 memcpy(start
,enter_xms
,sizeof(enter_xms
));
129 static char enter_pm
[]={
130 0x50, /* pushw %ax */
131 0x52, /* pushw %dx */
132 0x55, /* pushw %bp */
133 0x89,0xE5, /* movw %sp,%bp */
135 0x8B,0x56,0x08, /* movw 8(%bp),%dx */
136 /* just call int 31 here to get into protected mode... */
137 /* it'll check whether it was called from dpmi_seg... */
138 0xCD,0x31, /* int $0x31 */
139 /* we are now in the context of a 16-bit relay call */
140 /* need to fixup our stack;
141 * 16-bit relay return address will be lost, but we won't worry quite yet */
142 0x8E,0xD0, /* movw %ax,%ss */
143 0x66,0x0F,0xB7,0xE5, /* movzwl %bp,%esp */
145 0x89,0x56,0x08, /* movw %dx,8(%bp) */
152 static void MZ_InitDPMI( LPDOSTASK lpDosTask
)
154 unsigned size
=sizeof(enter_pm
);
155 LPBYTE start
=DOSMEM_GetBlock(lpDosTask
->hModule
,size
,&(lpDosTask
->dpmi_seg
));
157 lpDosTask
->dpmi_sel
= SELECTOR_AllocBlock( start
, size
, SEGMENT_CODE
, FALSE
, FALSE
);
159 memcpy(start
,enter_pm
,sizeof(enter_pm
));
162 static WORD
MZ_InitEnvironment( LPDOSTASK lpDosTask
, LPCSTR env
, LPCSTR name
)
169 /* get size of environment block */
170 while (env
[sz
++]) sz
+=strlen(env
+sz
)+1;
173 envblk
=DOSMEM_GetBlock(lpDosTask
->hModule
,sz
+sizeof(WORD
)+strlen(name
)+1,&seg
);
176 memcpy(envblk
,env
,sz
);
178 /* DOS 3.x: the block contains 1 additional string */
179 *(WORD
*)(envblk
+sz
)=1;
180 /* being the program name itself */
181 strcpy(envblk
+sz
+sizeof(WORD
),name
);
185 static BOOL
MZ_InitMemory( LPDOSTASK lpDosTask
, NE_MODULE
*pModule
)
189 if (lpDosTask
->img
) return TRUE
; /* already allocated */
191 /* allocate 1MB+64K shared memory */
192 lpDosTask
->img_ofs
=START_OFFSET
;
194 lpDosTask
->img
=VirtualAlloc(NULL
,0x110000,MEM_COMMIT
,PAGE_READWRITE
);
195 /* make sure mmap accepts it */
196 ((char*)lpDosTask
->img
)[0x10FFFF]=0;
198 tmpnam(lpDosTask
->mm_name
);
199 /* strcpy(lpDosTask->mm_name,"/tmp/mydosimage"); */
200 lpDosTask
->mm_fd
=open(lpDosTask
->mm_name
,O_RDWR
|O_CREAT
/* |O_TRUNC */,S_IRUSR
|S_IWUSR
);
201 if (lpDosTask
->mm_fd
<0) ERR("file %s could not be opened\n",lpDosTask
->mm_name
);
202 /* expand file to 1MB+64K */
203 lseek(lpDosTask
->mm_fd
,0x110000-1,SEEK_SET
);
204 x
=0; write(lpDosTask
->mm_fd
,&x
,1);
206 lpDosTask
->img
=mmap(NULL
,0x110000-START_OFFSET
,PROT_READ
|PROT_WRITE
,MAP_SHARED
,lpDosTask
->mm_fd
,0);
208 if (lpDosTask
->img
==(LPVOID
)-1) {
209 ERR("could not map shared memory, error=%s\n",strerror(errno
));
212 TRACE("DOS VM86 image mapped at %08lx\n",(DWORD
)lpDosTask
->img
);
213 pModule
->dos_image
=lpDosTask
->img
;
215 /* initialize the memory */
216 TRACE("Initializing DOS memory structures\n");
217 DOSMEM_Init(lpDosTask
->hModule
);
218 MZ_InitHandlers(lpDosTask
);
219 MZ_InitXMS(lpDosTask
);
220 MZ_InitDPMI(lpDosTask
);
224 static BOOL
MZ_LoadImage( HANDLE hFile
, LPCSTR filename
, LPCSTR cmdline
,
225 LPCSTR env
, LPDOSTASK lpDosTask
, NE_MODULE
*pModule
)
227 IMAGE_DOS_HEADER mz_header
;
228 DWORD image_start
,image_size
,min_size
,max_size
,avail
;
229 BYTE
*psp_start
,*load_start
;
235 SetFilePointer(hFile
,0,NULL
,FILE_BEGIN
);
236 if ( !ReadFile(hFile
,&mz_header
,sizeof(mz_header
),&len
,NULL
)
237 || len
!= sizeof(mz_header
)
238 || mz_header
.e_magic
!= IMAGE_DOS_SIGNATURE
) {
239 old_com
=1; /* assume .COM file */
241 image_size
=GetFileSize(hFile
,NULL
);
242 min_size
=0x10000; max_size
=0x100000;
244 mz_header
.e_ss
=0; mz_header
.e_sp
=0xFFFE;
245 mz_header
.e_cs
=0; mz_header
.e_ip
=0x100;
247 /* calculate load size */
248 image_start
=mz_header
.e_cparhdr
<<4;
249 image_size
=mz_header
.e_cp
<<9; /* pages are 512 bytes */
250 if ((mz_header
.e_cblp
!=0)&&(mz_header
.e_cblp
!=4)) image_size
-=512-mz_header
.e_cblp
;
251 image_size
-=image_start
;
252 min_size
=image_size
+((DWORD
)mz_header
.e_minalloc
<<4)+(PSP_SIZE
<<4);
253 max_size
=image_size
+((DWORD
)mz_header
.e_maxalloc
<<4)+(PSP_SIZE
<<4);
256 MZ_InitMemory(lpDosTask
,pModule
);
258 /* allocate environment block */
259 env_seg
=MZ_InitEnvironment(lpDosTask
,env
,filename
);
261 /* allocate memory for the executable */
262 TRACE("Allocating DOS memory (min=%ld, max=%ld)\n",min_size
,max_size
);
263 avail
=DOSMEM_Available(lpDosTask
->hModule
);
264 if (avail
<min_size
) {
265 ERR("insufficient DOS memory\n");
266 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
269 if (avail
>max_size
) avail
=max_size
;
270 psp_start
=DOSMEM_GetBlock(lpDosTask
->hModule
,avail
,&lpDosTask
->psp_seg
);
272 ERR("error allocating DOS memory\n");
273 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
276 lpDosTask
->load_seg
=lpDosTask
->psp_seg
+(old_com
?0:PSP_SIZE
);
277 load_start
=psp_start
+(PSP_SIZE
<<4);
278 MZ_InitPSP(psp_start
, cmdline
, env_seg
);
280 /* load executable image */
281 TRACE("loading DOS %s image, %08lx bytes\n",old_com
?"COM":"EXE",image_size
);
282 SetFilePointer(hFile
,image_start
,NULL
,FILE_BEGIN
);
283 if (!ReadFile(hFile
,load_start
,image_size
,&len
,NULL
) || len
!= image_size
) {
284 SetLastError(ERROR_BAD_FORMAT
);
288 if (mz_header
.e_crlc
) {
289 /* load relocation table */
290 TRACE("loading DOS EXE relocation table, %d entries\n",mz_header
.e_crlc
);
291 /* FIXME: is this too slow without read buffering? */
292 SetFilePointer(hFile
,mz_header
.e_lfarlc
,NULL
,FILE_BEGIN
);
293 for (x
=0; x
<mz_header
.e_crlc
; x
++) {
294 if (!ReadFile(hFile
,&reloc
,sizeof(reloc
),&len
,NULL
) || len
!= sizeof(reloc
)) {
295 SetLastError(ERROR_BAD_FORMAT
);
298 *(WORD
*)SEGPTR16(load_start
,reloc
)+=lpDosTask
->load_seg
;
302 lpDosTask
->init_cs
=lpDosTask
->load_seg
+mz_header
.e_cs
;
303 lpDosTask
->init_ip
=mz_header
.e_ip
;
304 lpDosTask
->init_ss
=lpDosTask
->load_seg
+mz_header
.e_ss
;
305 lpDosTask
->init_sp
=mz_header
.e_sp
;
307 TRACE("entry point: %04x:%04x\n",lpDosTask
->init_cs
,lpDosTask
->init_ip
);
311 LPDOSTASK
MZ_AllocDPMITask( HMODULE16 hModule
)
313 LPDOSTASK lpDosTask
= calloc(1, sizeof(DOSTASK
));
317 lpDosTask
->hModule
= hModule
;
319 pModule
= (NE_MODULE
*)GlobalLock16(hModule
);
320 pModule
->lpDosTask
= lpDosTask
;
322 lpDosTask
->img
=NULL
; lpDosTask
->mm_name
[0]=0; lpDosTask
->mm_fd
=-1;
324 MZ_InitMemory(lpDosTask
, pModule
);
326 GlobalUnlock16(hModule
);
331 static void MZ_InitTimer( LPDOSTASK lpDosTask
, int ver
)
334 /* can't make timer ticks */
339 /* start dosmod timer at 55ms (18.2Hz) */
340 func
=DOSMOD_SET_TIMER
;
341 tim
.tv_sec
=0; tim
.tv_usec
=54925;
342 write(lpDosTask
->write_pipe
,&func
,sizeof(func
));
343 write(lpDosTask
->write_pipe
,&tim
,sizeof(tim
));
347 BOOL
MZ_InitTask( LPDOSTASK lpDosTask
)
349 int write_fd
[2],x_fd
;
351 char *fname
,*farg
,arg
[16],fproc
[64],path
[256],*fpath
;
352 SECURITY_ATTRIBUTES attr
={sizeof(attr
),NULL
,TRUE
};
353 struct get_read_fd_request
*r_req
= get_req_buffer();
354 struct get_write_fd_request
*w_req
= get_req_buffer();
356 if (!lpDosTask
) return FALSE
;
358 /* this happens in the wrong process context, so we have to let the new process
359 inherit it... (FIXME: call MZ_InitTask in the right process context) */
360 if (!CreatePipe(&(lpDosTask
->hReadPipe
),&(lpDosTask
->hXPipe
),&attr
,0)) return FALSE
;
361 if (pipe(write_fd
)<0) {
362 CloseHandle(lpDosTask
->hReadPipe
);
363 CloseHandle(lpDosTask
->hXPipe
);
366 r_req
->handle
= lpDosTask
->hReadPipe
;
367 server_call_fd( REQ_GET_READ_FD
, -1, &lpDosTask
->read_pipe
);
368 w_req
->handle
= lpDosTask
->hXPipe
;
369 server_call_fd( REQ_GET_WRITE_FD
, -1, &x_fd
);
371 TRACE("win32 pipe: read=%d, write=%d, unix pipe: read=%d, write=%d\n",
372 lpDosTask
->hReadPipe
,lpDosTask
->hXPipe
,lpDosTask
->read_pipe
,x_fd
);
373 TRACE("outbound unix pipe: read=%d, write=%d, pid=%d\n",write_fd
[0],write_fd
[1],getpid());
375 lpDosTask
->write_pipe
=write_fd
[1];
377 lpDosTask
->hConInput
=GetStdHandle(STD_INPUT_HANDLE
);
378 lpDosTask
->hConOutput
=GetStdHandle(STD_OUTPUT_HANDLE
);
380 /* if we have a mapping file, use it */
381 fname
=lpDosTask
->mm_name
; farg
=NULL
;
383 /* otherwise, map our own memory image */
384 sprintf(fproc
,"/proc/%d/mem",getpid());
385 sprintf(arg
,"%ld",(unsigned long)lpDosTask
->img
);
386 fname
=fproc
; farg
=arg
;
389 TRACE("Loading DOS VM support module (hmodule=%04x)\n",lpDosTask
->hModule
);
390 if ((child
=fork())<0) {
392 close(lpDosTask
->read_pipe
);
393 close(lpDosTask
->write_pipe
);
395 CloseHandle(lpDosTask
->hReadPipe
);
396 CloseHandle(lpDosTask
->hXPipe
);
405 lpDosTask
->task
=child
;
406 /* wait for child process to signal readiness */
408 if (read(lpDosTask
->read_pipe
,&ret
,sizeof(ret
))==sizeof(ret
)) break;
409 if ((errno
==EINTR
)||(errno
==EAGAIN
)) continue;
411 ERR("dosmod has failed to initialize\n");
412 if (lpDosTask
->mm_name
[0]!=0) unlink(lpDosTask
->mm_name
);
415 /* the child has now mmaped the temp file, it's now safe to unlink.
416 * do it here to avoid leaving a mess in /tmp if/when Wine crashes... */
417 if (lpDosTask
->mm_name
[0]!=0) unlink(lpDosTask
->mm_name
);
418 /* start simulated system timer */
419 MZ_InitTimer(lpDosTask
,ret
);
421 ERR("dosmod version too old! Please install newer dosmod properly\n");
422 ERR("If you don't, the new dosmod event handling system will not work\n");
424 /* all systems are now go */
427 close(lpDosTask
->read_pipe
);
428 close(lpDosTask
->write_pipe
);
429 /* put our pipes somewhere dosmod can find them */
430 dup2(write_fd
[0],0); /* stdin */
431 dup2(x_fd
,1); /* stdout */
432 /* now load dosmod */
433 /* check argv[0]-derived paths first, since the newest dosmod is most likely there
434 * (at least it was once for Andreas Mohr, so I decided to make it easier for him) */
435 fpath
=strrchr(strcpy(path
,argv0
),'/');
437 strcpy(fpath
,"/dosmod");
438 execl(path
,fname
,farg
,NULL
);
439 strcpy(fpath
,"/loader/dos/dosmod");
440 execl(path
,fname
,farg
,NULL
);
442 /* okay, it wasn't there, try in the path */
443 execlp("dosmod",fname
,farg
,NULL
);
444 /* last desperate attempts: current directory */
445 execl("dosmod",fname
,farg
,NULL
);
446 /* and, just for completeness... */
447 execl("loader/dos/dosmod",fname
,farg
,NULL
);
448 /* if failure, exit */
449 ERR("Failed to spawn dosmod, error=%s\n",strerror(errno
));
456 BOOL
MZ_CreateProcess( HANDLE hFile
, LPCSTR filename
, LPCSTR cmdline
, LPCSTR env
,
457 LPSECURITY_ATTRIBUTES psa
, LPSECURITY_ATTRIBUTES tsa
,
458 BOOL inherit
, DWORD flags
, LPSTARTUPINFOA startup
,
459 LPPROCESS_INFORMATION info
)
461 LPDOSTASK lpDosTask
= NULL
; /* keep gcc from complaining */
463 PDB
*pdb
= PROCESS_Current();
464 TDB
*pTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
465 NE_MODULE
*pModule
= pTask
? NE_GetPtr( pTask
->hModule
) : NULL
;
466 int alloc
= !(pModule
&& pModule
->dos_image
);
468 if (alloc
&& (lpDosTask
= calloc(1, sizeof(DOSTASK
))) == NULL
) {
469 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
473 if ((!env
)&&pdb
) env
= pdb
->env_db
->environ
;
475 if ((hModule
= MODULE_CreateDummyModule(filename
, 0)) < 32) {
476 SetLastError(hModule
);
479 lpDosTask
->hModule
= hModule
;
481 pModule
= (NE_MODULE
*)GlobalLock16(hModule
);
482 pModule
->lpDosTask
= lpDosTask
;
484 lpDosTask
->img
=NULL
; lpDosTask
->mm_name
[0]=0; lpDosTask
->mm_fd
=-1;
485 } else lpDosTask
=pModule
->lpDosTask
;
486 if (!MZ_LoadImage( hFile
, filename
, cmdline
, env
, lpDosTask
, pModule
)) {
488 if (lpDosTask
->mm_name
[0]!=0) {
489 if (lpDosTask
->img
!=NULL
) munmap(lpDosTask
->img
,0x110000-START_OFFSET
);
490 if (lpDosTask
->mm_fd
>=0) close(lpDosTask
->mm_fd
);
491 unlink(lpDosTask
->mm_name
);
493 if (lpDosTask
->img
!=NULL
) VirtualFree(lpDosTask
->img
,0x110000,MEM_RELEASE
);
498 pModule
->dos_image
= lpDosTask
->img
;
499 if (!MZ_InitTask( lpDosTask
)) {
500 MZ_KillModule( lpDosTask
);
501 /* FIXME: cleanup hModule */
502 SetLastError(ERROR_GEN_FAILURE
);
505 inherit
= TRUE
; /* bad hack for inheriting the CreatePipe... */
506 if (!PROCESS_Create( pModule
, hFile
, cmdline
, env
,
507 psa
, tsa
, inherit
, flags
, startup
, info
))
514 void MZ_KillModule( LPDOSTASK lpDosTask
)
516 DOSEVENT
*event
,*p_event
;
517 DOSSYSTEM
*sys
,*p_sys
;
519 TRACE("killing DOS task\n");
521 if (lpDosTask
->mm_name
[0]!=0) {
522 munmap(lpDosTask
->img
,0x110000-START_OFFSET
);
523 close(lpDosTask
->mm_fd
);
524 } else VirtualFree(lpDosTask
->img
,0x110000,MEM_RELEASE
);
525 close(lpDosTask
->read_pipe
);
526 close(lpDosTask
->write_pipe
);
527 CloseHandle(lpDosTask
->hReadPipe
);
528 CloseHandle(lpDosTask
->hXPipe
);
529 kill(lpDosTask
->task
,SIGTERM
);
530 /* free memory allocated for events and systems */
531 #define DFREE(var,pvar,svar) \
532 var = lpDosTask->svar; \
534 if (var->data) free(var->data); \
535 pvar = var->next; free(var); var = pvar; \
538 DFREE(event
,p_event
,pending
)
539 DFREE(event
,p_event
,current
)
545 /* FIXME: this seems to crash */
546 if (lpDosTask
->dpmi_sel
)
547 SELECTOR_FreeBlock(lpDosTask
->dpmi_sel
, 1);
551 LPDOSTASK
MZ_Current( void )
553 TDB
*pTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
554 NE_MODULE
*pModule
= pTask
? NE_GetPtr( pTask
->hModule
) : NULL
;
556 GlobalUnlock16( GetCurrentTask() );
559 return pModule
->lpDosTask
;
564 #else /* !MZ_SUPPORTED */
566 BOOL
MZ_CreateProcess( HANDLE hFile
, LPCSTR filename
, LPCSTR cmdline
, LPCSTR env
,
567 LPSECURITY_ATTRIBUTES psa
, LPSECURITY_ATTRIBUTES tsa
,
568 BOOL inherit
, DWORD flags
, LPSTARTUPINFOA startup
,
569 LPPROCESS_INFORMATION info
)
571 WARN("DOS executables not supported on this architecture\n");
572 SetLastError(ERROR_BAD_FORMAT
);
576 LPDOSTASK
MZ_Current( void )