source: trunk/src/kernel32/dbglog.cpp@ 21958

Last change on this file since 21958 was 21958, checked in by dmik, 14 years ago

Make sure hour value doesn't exceed 23h in logs.
File size: 31.3 KB
Line 
1/* $Id: dbglog.cpp,v 1.9 2003-03-26 16:02:33 sandervl Exp $ */
2
3/*
4 * Project Odin Software License can be found in LICENSE.TXT
5 * Debug Logging procedures
6 *
7 * Copyright 1998-2002 Sander van Leeuwen (sandervl@xs4all.nl)
8 * Copyright 1998 Joel Troster
9 * Copyright 1998 Peter FitzSimmons
10 *
11 */
12
13
14/*******************************************************************************
15* Internal Functions *
16*******************************************************************************/
17
18#define INCL_MISC
19#define INCL_BASE
20#define INCL_WIN
21#define INCL_WINERRORS
22#define INCL_DOSFILEMGR
23#include <os2wrap.h> //Odin32 OS/2 api wrappers
24#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
27#include <stdarg.h>
28#include <process.h>
29#include <win32type.h>
30#include <win32api.h>
31#include <dbglog.h>
32#include "initterm.h"
33#include "logging.h"
34#include "exceptions.h"
35#include "exceptutil.h"
36#include <wprocess.h>
37#include <versionos2.h>
38#include "odinbuild.h"
39#include <cpuhlp.h>
40
41#include "asmutil.h"
42#include "WinImageBase.h"
43#include "WinDllBase.h"
44#include "WinExeBase.h"
45/*****************************************************************************
46 * PMPRINTF Version *
47 *****************************************************************************/
48
49#ifdef PMPRINTF
50
51/* ----- Customization variables ----- */
52#define PRINTFID ""
53#define PRINTFMAXLEN 300
54#define PRINTFLINELEN 100
55#define PRINTFTHREADS 54
56#define PRINTFQNAME "\\QUEUES\\PRINTF32"
57
58/* ----- Includes and externals ----- */
59#include <stddef.h> /* .. */
60#include <time.h> /* .. */
61
62extern ULONG flAllocMem; /*Tue 03.03.1998: knut */
63
64/* ----- Local defines ----- */
65#define PRINTFIDSIZE sizeof(PRINTFID)
66#define PRINTFMAXBUF PRINTFIDSIZE+PRINTFLINELEN
67
68ULONG GetPentiumTSC (QWORD * tsc);
69
70/*****************************************************************************
71 * Structures *
72 *****************************************************************************/
73
74/* ----- Per-thread output buffer and current indices into line ---- */
75struct perthread {
76 LONG lineindex; /* where next char */
77 LONG tidemark; /* rightmost char */
78 int bell; /* TRUE if line has bell */
79 UCHAR line[PRINTFMAXBUF]; /* accumulator */
80 };
81
82/* ----- Local static variables ----- */
83static ULONG ourpid=0; /* our process ID */
84static ULONG servepid=0; /* process IDs of the server */
85static HQUEUE qhandle=0; /* handle for the queue */
86static struct perthread *tps[PRINTFTHREADS+1]; /* -> per-thread data */
87
88/* ----- Local subroutine ----- */
89static int printf_(struct perthread *);
90
91
92/* ----------------------------------------------------------------- */
93/* The "printf" function. Note this has a variable number of */
94/* arguments. */
95/* ----------------------------------------------------------------- */
96int SYSTEM WriteLog(const char *f, ...)
97 {
98 TIB *ptib; /* process/thread id structures */
99 PIB *ppib; /* .. */
100 TID ourtid; /* thread ID */
101 struct perthread *tp; /* pointer to per-thread data */
102 int rc; /* returncode */
103 ULONG urc; /* returncode */
104
105 urc=DosOpenQueue(&servepid, &qhandle, PRINTFQNAME); /* Open the Q */
106 /* Non-0 RC means Q does not exist or cannot be opened */
107 if (urc==343) return 0; /* queue does not exist, so quit */
108 if (urc!=0) return -1; /* report any other error */
109
110 /* First determine our thread ID (and hence get access to the */
111 /* correct per-thread data. If the per-thread data has not been */
112 /* allocated, then allocate it now. It is never freed, once */
113 /* allocated, as PRINTF is not notified of end-of-thread. */
114 DosGetInfoBlocks(&ptib,&ppib); /* get process/thread info */
115 ourtid=ptib->tib_ptib2->tib2_ultid; /* .. and copy TID */
116 if (ourtid>PRINTFTHREADS) /* too many threads .. */
117 return 0; /* .. so quit, quietly */
118 tp=tps[ourtid]; /* copy to local pointer */
119 if (tp==NULL) { /* uninitialized (NULL=0) */
120 /* allocate a per-thread structure */
121 tp=(struct perthread *)malloc(sizeof(struct perthread));
122 if (tp==NULL) return -1; /* out of memory -- return error */
123 tps[ourtid]=tp; /* save for future calls */
124 strcpy(tp->line,PRINTFID); /* initialize: line.. */
125 tp->lineindex=PRINTFIDSIZE-1; /* ..where next char */
126 tp->tidemark =PRINTFIDSIZE-2; /* ..rightmost char */
127 tp->bell=FALSE; /* ..if line has bell */
128 if (ourpid==0) ourpid=ppib->pib_ulpid; /* save PID for all to use */
129 }
130
131 { /* Block for declarations -- only needed if queue exists, etc. */
132 LONG count; /* count of characters formatted */
133 UCHAR buffer[PRINTFMAXLEN+1]; /* formatting area */
134 LONG i, newind; /* work */
135 UCHAR ch; /* .. */
136 va_list argptr; /* -> variable argument list */
137
138 va_start(argptr, f); /* get pointer to argument list */
139 count=vsprintf(buffer, f, argptr);
140 va_end(argptr); /* done with variable arguments */
141
142 if (count<0) return count-1000;/* bad start */
143
144 if (count>PRINTFMAXLEN) {
145 /* Disaster -- we are probably "dead", but just in case we */
146 /* are not, carry on with truncated data. */
147 count=PRINTFMAXLEN;
148 }
149 buffer[count]='\0'; /* ensure terminated */
150 /* OK, ready to go with the data now in BUFFER */
151 /* We copy from the formatted string to the output (line) buffer, */
152 /* taking note of certain control characters and sending a line */
153 /* the queue whenever we see a LF control, or when the line */
154 /* fills (causing a forced break). */
155 for (i=0; ; i++) {
156 ch=buffer[i]; if (!ch) break;
157 switch(ch) {
158 case '\r': /* carriage return */
159 tp->lineindex=PRINTFIDSIZE-1; /* back to start of line */
160 break;
161 case '\n': /* new line */
162 case '\f': /* form feed */
163 rc=printf_(tp); /* print a line */
164 if (rc!=0) return rc; /* error */
165 break;
166 case '\t': /* tab */
167 newind=tp->lineindex-PRINTFIDSIZE+1; /* offset into data */
168 newind=tp->lineindex+5-newind%5; /* new index requested */
169 if (newind>=PRINTFMAXBUF) newind=PRINTFMAXBUF; /* clamp */
170 for (; tp->lineindex<newind; tp->lineindex++) {
171 if (tp->lineindex>tp->tidemark) { /* beyond current end */
172 tp->line[tp->lineindex]=' '; /* add space */
173 tp->tidemark=tp->lineindex;
174 }
175 }
176 break;
177 case '\v': /* vertical tab */
178 /* ignore it */
179 break;
180 case '\b': /* backspace */
181 tp->lineindex=max(tp->lineindex-1,PRINTFIDSIZE);
182 break;
183 case '\a': /* alert (bell) */
184 tp->bell=TRUE;
185 break;
186 default: /* ordinary character */
187 tp->line[tp->lineindex]=ch;
188 if (tp->lineindex>tp->tidemark) /* is rightmost.. */
189 tp->tidemark=tp->lineindex;
190 tp->lineindex++; /* step for next */
191 } /* switch */
192 if (tp->lineindex>=PRINTFMAXBUF) {
193 rc=printf_(tp); /* print a line */
194 if (rc!=0) return rc; /* error */
195 }
196
197 } /* copy loop */
198 return count; /* all formatted data processed */
199 } /* block */
200 } /* printf */
201
202/* ----- printf_(tp) -- Local subroutine to send a line ------------ */
203/* A line has been completed (or overflowed): write it to the queue. */
204int printf_(struct perthread *tp) /* pointer to per-thread data */
205 {
206 ULONG urc; /* unsigned returncode */
207 PSZ pszTo, pszFrom; /* character pointers */
208 PVOID addr; /* address of output data */
209 long size; /* total size of output data */
210 time_t timenow; /* holds current time */
211
212 tp->line[tp->tidemark+1]='\0'; /* add terminator */
213 size=tp->tidemark+2; /* total length of data */
214
215 /* Get some shared memory that can be given away */
216 urc=DosAllocSharedMem(&addr, NULL, (unsigned)size,
217 OBJ_GIVEABLE|PAG_WRITE|PAG_COMMIT|flAllocMem);
218 /*knut: added flAllocMem */
219
220 if (urc!=0) return -2; /* error */
221
222 pszTo=addr; /* copy for clarity */
223 pszFrom=&(tp->line[0]); /* pointer to source */
224 strcpy(pszTo,pszFrom); /* copy the string to shared memory */
225
226 if (ourpid!=servepid) { /* (no giveaway needed if to self) */
227 urc=DosGiveSharedMem(addr, servepid, PAG_READ); /* give access */
228 if (urc!=0) return -3;} /* error */
229
230 /* Write the selector, size, and timestamp to the queue */
231 if (tp->bell) size=-size; /* BELL passed by negation */
232 time(&timenow); /* optional - else use 0 */
233 urc=DosWriteQueue(qhandle, /* handle */
234 (unsigned)timenow, /* 'request' (timestamp) */
235 (unsigned)size, /* 'length' (length/bell) */
236 addr, /* 'address' (address) */
237 0); /* priority (FIFO if enabled) */
238 if (urc!=0) return -4; /* error */
239 if (ourpid!=servepid) { /* if given away.. */
240 urc=DosFreeMem(addr); /* .. *we* are done with it */
241 if (urc!=0) return -5;} /* error */
242 /* Reset the line buffer and indices */
243 tp->lineindex=PRINTFIDSIZE-1; /* where next char */
244 tp->tidemark =PRINTFIDSIZE-2; /* rightmost char */
245 tp->bell =FALSE; /* true if line has bell */
246 return 0; /* success! */
247 } /* printf_ */
248#endif
249
250
251
252/*****************************************************************************
253 * Standard Version *
254 *****************************************************************************/
255
256static FILE *flog = NULL; /*PLF Mon 97-09-08 20:00:15*/
257static BOOL init = FALSE;
258static BOOL firstTime = FALSE;
259static BOOL fLogging = TRUE;
260static int dwEnableLogging = 1;
261#ifdef __IBMC__
262static int oldcrtmsghandle = 0;
263#endif
264
265static BOOL fDisableThread[5] = {0};
266static BOOL fFlushLines = TRUE;
267
268static const char *pszLastLogEntry = NULL;
269
270//#define CHECK_ODINHEAP
271#if defined(DEBUG) && defined(CHECK_ODINHEAP)
272int checkOdinHeap = 1;
273int checkingheap = 0;
274#define ODIN_HEAPCHECK() \
275 if(checkingheap) checkOdinHeap = 0; \
276 checkingheap++; \
277 if(checkOdinHeap) _heap_check(); \
278 checkingheap--;
279#else
280#define ODIN_HEAPCHECK()
281#endif
282
283#define LOG_TIME
284//#define SHOW_FPU_CONTROLREG
285#define WIN32_IP_LOGGING
286#define WIN32_IP_LOG_PORT 5001
287
288#ifdef WIN32_IP_LOGGING
289#include <types.h>
290#include <netinet/in.h>
291#include <sys/socket.h>
292
293static int logSocket = -1;
294static struct sockaddr_in servername;
295#endif
296
297#ifdef LOG_TIME
298static DWORD startTicks = 0;
299static DWORD startTime = 0;
300VOID WINAPI GetLocalTime(LPSYSTEMTIME);
301#endif
302
303static void win32modname (ULONG eip, char *szModName, int cbModName)
304{
305 Win32ImageBase *pMod = NULL;
306 if (WinExe && WinExe->insideModule(eip))
307 pMod = WinExe;
308 else
309 pMod = Win32DllBase::findModuleByAddr(eip);
310 if (pMod != NULL)
311 {
312 szModName[0] = '\0';
313 strncat(szModName, pMod->getModuleName(), cbModName);
314 }
315}
316
317int SYSTEM WriteLog(const char *tekst, ...)
318{
319 USHORT sel = RestoreOS2FS();
320 va_list argptr;
321 TEB *teb = GetThreadTEB();
322
323 pszLastLogEntry = tekst;
324
325 ODIN_HEAPCHECK();
326
327 if (!init)
328 {
329 init = TRUE;
330 firstTime = TRUE;
331
332#ifdef LOG_TIME
333 // initialize the current time counter
334 startTicks = GetTickCount();
335 SYSTEMTIME t;
336 GetLocalTime(&t);
337 startTime = t.wHour * 3600 + t.wMinute * 60 + t.wSecond;
338 startTime = (startTime * 1000) + t.wMilliseconds;
339#endif
340
341 if(getenv("WIN32LOG_FLUSHLINES"))
342 fFlushLines = TRUE;
343
344#ifdef DEFAULT_LOGGING_OFF
345 if(getenv("WIN32LOG_ENABLED"))
346 {
347#else
348 if(!getenv("NOWIN32LOG"))
349 {
350#endif
351#ifdef WIN32_IP_LOGGING
352 char *logserver = getenv("WIN32LOG_IPSERVER");
353 if(logserver) {
354 sock_init();
355
356 memset(&servername, 0, sizeof(servername));
357 servername.sin_family = AF_INET;
358 servername.sin_addr.s_addr = inet_addr(logserver);
359 servername.sin_port = WIN32_IP_LOG_PORT;
360
361 logSocket = socket(PF_INET, SOCK_DGRAM, 0);
362 }
363#endif
364 char szLogFile[CCHMAXPATH];
365 const char *pszLogBase = getenv("WIN32LOG_FILEBASE");
366 if (!pszLogBase)
367 pszLogBase = "odin32_";
368
369 sprintf(szLogFile, "%s%d.log", pszLogBase, getpid());
370 flog = fopen(szLogFile, "w");
371 if(flog == NULL)
372 {//probably running exe on readonly device
373 sprintf(szLogFile, "%sodin32_%d.log", kernel32Path, getpid());
374 flog = fopen(szLogFile, "w");
375 }
376#ifdef __IBMC__
377 oldcrtmsghandle = _set_crt_msg_handle(fileno(flog));
378#endif
379 }
380 else
381 fLogging = FALSE;
382
383 fDisableThread[0] = getenv("DISABLE_THREAD1") != NULL;
384 fDisableThread[1] = getenv("DISABLE_THREAD2") != NULL;
385 fDisableThread[2] = getenv("DISABLE_THREAD3") != NULL;
386 fDisableThread[3] = getenv("DISABLE_THREAD4") != NULL;
387 fDisableThread[4] = getenv("DISABLE_THREAD5") != NULL;
388 }
389
390 if (teb)
391 {
392 if(teb->o.odin.threadId < 5 && fDisableThread[teb->o.odin.threadId-1] == 1)
393 {
394 SetFS(sel);
395 return 1;
396 }
397 }
398
399 if (!tekst)
400 {
401 if (flog)
402 fflush( flog);
403 SetFS(sel);
404 return 1;
405 }
406
407#ifdef LOG_TIME
408 // get human readable time values
409 DWORD time = startTime + (GetTickCount() - startTicks);
410 DWORD h = (time / 3600000) % 24;
411 DWORD m = (time %= 3600000) / 60000;
412 DWORD s = (time %= 60000) / 1000;
413 DWORD ms = time % 1000;
414#endif
415
416 if (fLogging && flog && (dwEnableLogging > 0))
417 {
418 if (firstTime)
419 {
420 firstTime = FALSE;
421
422 // print the header with the legend
423#ifdef LOG_TIME
424 fprintf(flog,
425 " /--------------------- Thread ID\n"
426 " | /----------------- Call Depth\n"
427 " | | /-------------- Flags (O = OS/2 mode (FS=150B))\n"
428 " | | | /------- Current Time\n"
429 "--- --- - ------------\n");
430#else
431#ifdef SHOW_FPU_CONTROLREG
432 fprintf(flog,
433 " /------------ Thread ID\n"
434 " | /-------- Call Depth\n"
435 " | | /----- Flags (O = OS/2 mode (FS=150B))\n"
436 " | | | /-- FPU Control Register\n"
437 "--- --- - ---\n");
438#else
439 fprintf(flog,
440 " /-------- Thread ID\n"
441 " | /---- Call Depth\n"
442 " | | /- Flags (O = OS/2 mode (FS=150B))\n"
443 "--- --- -\n");
444#endif
445#endif
446 }
447
448 va_start(argptr, tekst);
449
450#ifdef WIN32_IP_LOGGING
451 if (logSocket == -1)
452 {
453#endif
454 if (teb)
455 {
456 ULONG ulCallDepth;
457#ifdef DEBUG
458 ulCallDepth = teb->o.odin.dbgCallDepth;
459#else
460 ulCallDepth = 0;
461#endif
462
463 teb->o.odin.logfile = (DWORD)flog;
464
465#ifdef LOG_TIME
466 fprintf(flog,
467 "t%02d %03d %c %02d:%02d:%02d.%03d: ",
468 LOWORD(teb->o.odin.threadId),
469 ulCallDepth,
470 (sel == 0x150b && fSwitchTIBSel) ? 'O' : '-',
471 h, m, s, ms);
472#else
473#ifdef SHOW_FPU_CONTROLREG
474 fprintf(flog,
475 "t%02d %03d %c %03X: ",
476 LOWORD(teb->o.odin.threadId),
477 ulCallDepth,
478 (sel == 0x150b && fSwitchTIBSel) ? 'O' : '-',
479 CONTROL87(0,0));
480#else
481 fprintf(flog,
482 "t%02d %03d %c: ",
483 LOWORD(teb->o.odin.threadId),
484 ulCallDepth,
485 (sel == 0x150b && fSwitchTIBSel) ? 'O' : '-');
486#endif
487#endif
488 }
489 else
490 {
491#ifdef LOG_TIME
492 fprintf(flog,
493 "tXX --- O %02d:%02d:%02d.%03d: ",
494 h, m, s, ms);
495#else
496#ifdef SHOW_FPU_CONTROLREG
497 fprintf(flog,
498 "tXX --- O ---: ");
499#else
500 fprintf(flog,
501 "tXX --- O: ");
502#endif
503#endif
504 }
505#ifdef WIN32_IP_LOGGING
506 }
507#endif
508
509#ifdef WIN32_IP_LOGGING
510 if(logSocket != -1)
511 {
512 char logbuffer[1024];
513 int prefixlen = 0;
514
515 if (teb)
516 {
517 ULONG ulCallDepth;
518#ifdef DEBUG
519 ulCallDepth = teb->o.odin.dbgCallDepth;
520#else
521 ulCallDepth = 0;
522#endif
523#ifdef LOG_TIME
524 sprintf(logbuffer,
525 "t%02d %03d %02d:%02d:%02d.%03d [%c]: ",
526 LOWORD(teb->o.odin.threadId),
527 ulCallDepth,
528 h, m, s, ms,
529 (sel == 0x150b && fSwitchTIBSel) ? 'O' : '.');
530#else
531 sprintf(logbuffer,
532 "t%02d %03d [%c]: ",
533 LOWORD(teb->o.odin.threadId),
534 ulCallDepth,
535 (sel == 0x150b && fSwitchTIBSel) ? 'O' : '.');
536#endif
537 prefixlen = strlen(logbuffer);
538 }
539
540 vsprintf(&logbuffer[prefixlen], tekst, argptr);
541
542 int rc;
543
544 servername.sin_family = AF_INET;
545 servername.sin_port = WIN32_IP_LOG_PORT;
546
547 rc = sendto(logSocket, logbuffer, strlen(logbuffer)+1, 0, (struct sockaddr *)&servername, sizeof(servername));
548 if (rc == -1)
549 rc = sock_errno();
550 if (teb)
551 teb->o.odin.logfile = 0;
552 va_end(argptr);
553 }
554 else
555 {
556 vfprintf(flog, tekst, argptr);
557 if (teb)
558 teb->o.odin.logfile = 0;
559 va_end(argptr);
560
561 if (tekst[strlen(tekst)-1] != '\n')
562 fprintf(flog, "\n");
563#if 0
564 if (teb && LOWORD(teb->o.odin.threadId) > 1)
565 {
566 TEB *winteb = GetThreadTEB();
567 PWINEXCEPTION_FRAME pframe = (PWINEXCEPTION_FRAME)winteb->except;
568
569 fprintf(flog, "debug Win32 exception chain %08X (%08X) (teb = %08X, esp = %08X)\n", pframe, QueryExceptionChain(), teb, getESP());
570 fprintf(flog, "Top record at %08X, Prev at %08X, handler at %08X\n", (PWINEXCEPTION_FRAME)QueryExceptionChain(), ((PWINEXCEPTION_FRAME)QueryExceptionChain())->Prev, ((PWINEXCEPTION_FRAME)QueryExceptionChain())->Handler);
571 fprintf(flog, "*teb %08X %08X %08X %08X %08X %08X %08X %08X\n",
572 ((ULONG *)teb)[0],((ULONG *)teb)[1],((ULONG *)teb)[2],((ULONG *)teb)[3],
573 ((ULONG *)teb)[4],((ULONG *)teb)[5],((ULONG *)teb)[6],((ULONG *)teb)[7]);
574 while ((pframe != NULL) && ((ULONG)pframe != 0xFFFFFFFF)) {
575 if ((void *)pframe > winteb->stack_top || (void *)pframe < winteb->stack_low)
576 {
577 fprintf(flog, "Chain corrupted! Record at %08X is outside stack boundaries!\n", pframe);
578 break;
579 }
580
581 if ((ULONG)pframe < getESP())
582 {
583 fprintf(flog, "Chain corrupted! Record at %08X is below stack pointer!\n", pframe);
584 break;
585 }
586
587 char szModName[32] = "";
588 char szModName2[32] = "";
589 win32modname ((ULONG)pframe->Handler, szModName, sizeof (szModName));
590 win32modname ((ULONG)pframe->Prev, szModName2, sizeof (szModName2));
591 fprintf(flog, "Record at %08X, Prev at %08X [%s], handler at %08X [%s]\n", pframe, pframe->Prev, szModName2, pframe->Handler, szModName);
592 if (pframe == pframe->Prev) {
593 fprintf(flog, "Chain corrupted! Record at %08X pointing to itself!\n", pframe);
594 break;
595 }
596 pframe = pframe->Prev;
597 }
598 }
599#endif
600 if (fFlushLines)
601 fflush(flog);
602 }
603#else
604 vfprintf(flog, tekst, argptr);
605 if(teb) teb->o.odin.logfile = 0;
606 va_end(argptr);
607
608 if(tekst[strlen(tekst)-1] != '\n')
609 fprintf(flog, "\n");
610
611 if(fFlushLines)
612 fflush(flog);
613#endif
614 }
615
616 SetFS(sel);
617 return 1;
618}
619//******************************************************************************
620//******************************************************************************
621int SYSTEM WriteLogNoEOL(const char *tekst, ...)
622{
623 USHORT sel = RestoreOS2FS();
624 va_list argptr;
625
626 ODIN_HEAPCHECK();
627
628 if(!init)
629 {
630 init = TRUE;
631
632#ifdef DEFAULT_LOGGING_OFF
633 if(getenv("WIN32LOG_ENABLED")) {
634#else
635 if(!getenv("NOWIN32LOG")) {
636#endif
637 char logname[CCHMAXPATH];
638
639 sprintf(logname, "odin32_%d.log", getpid());
640 flog = fopen(logname, "w");
641 if(flog == NULL) {//probably running exe on readonly device
642 sprintf(logname, "%sodin32_%d.log", kernel32Path, getpid());
643 flog = fopen(logname, "w");
644 }
645 }
646 else
647 fLogging = FALSE;
648 }
649
650 if(fLogging && flog && (dwEnableLogging > 0))
651 {
652 TEB *teb = GetThreadTEB();
653
654 va_start(argptr, tekst);
655 if(teb) {
656 teb->o.odin.logfile = (DWORD)flog;
657 }
658 vfprintf(flog, tekst, argptr);
659 if(teb) teb->o.odin.logfile = 0;
660 va_end(argptr);
661 }
662 SetFS(sel);
663 return 1;
664}
665//******************************************************************************
666//******************************************************************************
667void SYSTEM DecreaseLogCount()
668{
669 dwEnableLogging--;
670}
671//******************************************************************************
672//******************************************************************************
673void SYSTEM IncreaseLogCount()
674{
675 dwEnableLogging++;
676}
677//******************************************************************************
678//******************************************************************************
679int SYSTEM WritePrivateLog(void *logfile, const char *tekst, ...)
680{
681 USHORT sel = RestoreOS2FS();
682 va_list argptr;
683
684 if(fLogging && logfile)
685 {
686 TEB *teb = GetThreadTEB();
687
688 va_start(argptr, tekst);
689 if(teb) {
690 teb->o.odin.logfile = (DWORD)flog;
691 }
692 vfprintf((FILE *)logfile, tekst, argptr);
693 if(teb) teb->o.odin.logfile = 0;
694 va_end(argptr);
695
696 if(tekst[strlen(tekst)-1] != '\n')
697 fprintf((FILE *)logfile, "\n");
698 }
699
700 SetFS(sel);
701 return 1;
702}
703//******************************************************************************
704//WriteLog has to take special care to handle dprintfs inside our os/2 exception
705//handler; if an exception occurs inside a dprintf, using dprintf in the exception
706//handler will hang the process
707//******************************************************************************
708int LogException(int state, int prevlock)
709{
710 TEB *teb = GetThreadTEB();
711 int ret = 0;
712
713 if (!teb) return 0;
714
715#if !defined(__EMX__)
716 if (teb->o.odin.logfile)
717 {
718#if (__IBMCPP__ == 300) || (__IBMC__ == 300)
719 PUSHORT lock = (USHORT *)(teb->o.odin.logfile+0x1C);
720#else
721#if __IBMC__ >= 360 || __IBMCPP__ >= 360
722//TODO: test this!!!!!!!
723 PUSHORT lock = (USHORT *)(teb->o.odin.logfile+0x1C);
724#else
725#error Check the offset of the lock count word in the file stream structure for this compiler revision!!!!!
726#endif
727#endif
728 ret = (*lock);
729 if (state == ENTER_EXCEPTION)
730 {
731 if((*lock) > 0) (*lock)--;
732 }
733 else
734 { //LEAVE_EXCEPTION
735 if(prevlock) (*lock)++;
736 }
737 }
738#else
739//kso 2001-01-29: EMX/GCC
740// we maybe should do something with the _more->rsem (_rmutex) structure but
741// I wanna have this compile, so we'll address problems later.
742#endif
743 return ret;
744}
745//******************************************************************************
746//Check if the exception occurred inside a fprintf (logging THDB member set)
747//If true, decrease the lock count for that file stream
748//NOTE: HACK: DEPENDS ON COMPILER VERSION!!!!
749//******************************************************************************
750void CheckLogException()
751{
752 TEB *teb = GetThreadTEB();
753 PUSHORT lock;
754
755 if(!teb) return;
756
757#if !defined(__EMX__)
758 if(teb->o.odin.logfile) {
759 //oops, exception in vfprintf; let's clear the lock count
760#if (__IBMCPP__ == 300) || (__IBMC__ == 300)
761 lock = (PUSHORT)(teb->o.odin.logfile+0x1C);
762#else
763#if __IBMC__ >= 360 || __IBMCPP__ >= 360
764//TODO: test this!!!!!!!
765 PUSHORT lock = (USHORT *)(teb->o.odin.logfile+0x1C);
766#else
767#error Check the offset of the lock count word in the file stream structure for this compiler revision!!!!!
768#endif
769#endif
770 (*lock)--;
771 }
772#else
773//kso 2001-01-29: EMX/GCC
774// we maybe should do something with the _more->rsem (_rmutex) structure but
775// I wanna have this compile, so we'll address problems later.
776#endif
777}
778//******************************************************************************
779//NOTE: No need to save/restore FS, as our FS selectors have already been
780// destroyed and FS == 0x150B.
781//******************************************************************************
782void CloseLogFile()
783{
784#ifdef __IBMC__
785 if(oldcrtmsghandle)
786 _set_crt_msg_handle(oldcrtmsghandle);
787#endif
788
789#ifdef WIN32_IP_LOGGING
790 if(logSocket != -1) {
791 soclose(logSocket);
792 }
793#endif
794
795 if(flog) fclose(flog);
796 flog = 0;
797}
798//******************************************************************************
799//Used to open any private logfiles used in kernel32 (for now only in winimagepeldr.cpp)
800//******************************************************************************
801void OpenPrivateLogFiles()
802{
803#ifdef DEFAULT_LOGGING_OFF
804 if(getenv("WIN32LOG_ENABLED")) {
805#else
806 if(!getenv("NOWIN32LOG")) {
807#endif
808 OpenPrivateLogFilePE();
809 }
810}
811//******************************************************************************
812//Used to close all private logfiles used in kernel32 (for now only in winimagepeldr.cpp)
813//******************************************************************************
814void ClosePrivateLogFiles()
815{
816#ifdef DEFAULT_LOGGING_OFF
817 if(getenv("WIN32LOG_ENABLED")) {
818#else
819 if(!getenv("NOWIN32LOG")) {
820#endif
821 ClosePrivateLogFilePE();
822 }
823}
824//******************************************************************************
825//******************************************************************************
826void SYSTEM CheckVersion(ULONG version, char *modname)
827{
828 dprintf(("CheckVersion of %s, %d\n", modname, version));
829 if(version != PE2LX_VERSION){
830 static char msg[300];
831 int r;
832 dprintf(("Version mismatch! %d, %d: %s\n", version, PE2LX_VERSION, modname));
833 sprintf(msg, "%s is intended for use with a different release of Odin.\n", modname);
834 do{
835 r = WinMessageBox(HWND_DESKTOP, NULLHANDLE, msg, "Version Mismatch!", 0, MB_ABORTRETRYIGNORE | MB_ICONEXCLAMATION | MB_MOVEABLE);
836 }while(r == MBID_RETRY); // giggle
837 if( r != MBID_IGNORE )
838 exit(987);
839 }
840}
841//******************************************************************************
842//******************************************************************************
843void SYSTEM CheckVersionFromHMOD(ULONG version, HMODULE hModule)
844{
845 char name[_MAX_PATH];
846
847 // query name of dll.
848 if(!DosQueryModuleName(hModule, sizeof(name), name))
849 CheckVersion(version, name);
850}
851//******************************************************************************
852//******************************************************************************
853#ifdef __WATCOMC__ /*PLF Sat 97-06-21 17:12:36*/
854 extern void interrupt3( void );
855 #pragma aux interrupt3= \
856 "int 3"
857#endif
858extern "C"
859void WIN32API DebugBreak()
860{
861 dprintf(("DebugBreak\n"));
862
863 LPSTR lpstrEnv = getenv("WIN32.DEBUGBREAK"); /* query environment */
864 if (lpstrEnv == NULL) /* if environment is not set, don't call debugger ! */
865 return;
866
867#ifdef __WATCOMC__
868 interrupt3();
869#else
870 _interrupt(3);
871#endif
872}
873//******************************************************************************
874//******************************************************************************
875
876
877/*****************************************************************************
878 * Name : DebugErrorBox
879 * Purpose : display an apprioriate error box with detailed information
880 * about the error cause
881 * Parameters: APIRET iErrorCode - OS/2 error code
882 * PSZ pszFormat - printf-format string
883 * ...
884 * Variables :
885 * Result : return code of the message box
886 * Remark :
887 * Status :
888 *
889 * Author : Patrick Haller [Tue, 1999/09/13 19:55]
890 *****************************************************************************/
891
892int SYSTEM DebugErrorBox(ULONG iErrorCode,
893 char* pszFormat,
894 ...)
895{
896 char szMessageBuffer[1024]; /* buffer for the text message */
897 char szErrorBuffer[1024]; /* buffer for the operating system text */
898 ULONG bc; /* dummy */
899 APIRET rc2; /* API returncode */
900 int iRC; /* message box return code */
901
902 USHORT sel = RestoreOS2FS();
903 va_list argptr;
904
905 // clear memory
906 memset (szMessageBuffer, 0, sizeof(szMessageBuffer));
907 memset (szErrorBuffer, 0, sizeof(szErrorBuffer));
908
909 // build message string
910 va_start(argptr, pszFormat);
911 vsprintf(szMessageBuffer, pszFormat, argptr);
912 va_end(argptr);
913
914 // query error string
915 rc2 = DosGetMessage(NULL,
916 0,
917 szErrorBuffer,
918 sizeof(szErrorBuffer),
919 iErrorCode,
920 "OSO001.MSG",
921 &bc);
922
923 // display message box
924 iRC = WinMessageBox(HWND_DESKTOP,
925 NULLHANDLE,
926 szMessageBuffer,
927 szErrorBuffer,
928 0,
929 MB_OK | MB_ICONEXCLAMATION | MB_MOVEABLE);
930 SetFS(sel);
931 return iRC;
932}
933
934
935/**
936 * Query Odin32 build number.
937 * @returns Build number.
938 * @status Completely implemented.
939 * @author knut st. osmundsen (knut.stange.osmundsen@mynd.no)
940 */
941int WIN32API Odin32GetBuildNumber(void)
942{
943 dprintf(("Odin32GetBuildNumber returned %d\n", ODIN32_BUILD_NR));
944 return ODIN32_BUILD_NR;
945}
946
Note: See TracBrowser for help on using the repository browser.