source: trunk/src/kernel32/misc.cpp@ 3889

Last change on this file since 3889 was 3889, checked in by sandervl, 25 years ago

print fs when ..= 0x150b
File size: 19.7 KB
Line 
1/* $Id: misc.cpp,v 1.24 2000-07-22 12:52:45 sandervl Exp $ */
2
3/*
4 * Project Odin Software License can be found in LICENSE.TXT
5 * Logging procedures
6 *
7 * Copyright 1998 Sander van Leeuwen (sandervl@xs4all.nl)
8 * Copyright 1998 Joel Troster
9 * Copyright 1998 Peter FitzSimmons
10 *
11 */
12
13
14/*****************************************************************************
15 * Includes *
16 *****************************************************************************/
17
18#define INCL_BASE
19#define INCL_WIN
20#define INCL_WINERRORS
21#define INCL_DOSFILEMGR
22#include <os2wrap.h> //Odin32 OS/2 api wrappers
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26#include <stdarg.h>
27#include <win32type.h>
28#include <misc.h>
29#include "initterm.h"
30#include "logging.h"
31#include <wprocess.h>
32
33/*****************************************************************************
34 * PMPRINTF Version *
35 *****************************************************************************/
36
37#ifdef PMPRINTF
38
39/* ----- Customization variables ----- */
40#define PRINTFID ""
41#define PRINTFMAXLEN 300
42#define PRINTFLINELEN 100
43#define PRINTFTHREADS 54
44#define PRINTFQNAME "\\QUEUES\\PRINTF32"
45
46/* ----- Includes and externals ----- */
47#include <stddef.h> /* .. */
48#include <time.h> /* .. */
49
50extern ULONG flAllocMem; /*Tue 03.03.1998: knut */
51
52/* ----- Local defines ----- */
53#define PRINTFIDSIZE sizeof(PRINTFID)
54#define PRINTFMAXBUF PRINTFIDSIZE+PRINTFLINELEN
55
56
57/*****************************************************************************
58 * Structures *
59 *****************************************************************************/
60
61/* ----- Per-thread output buffer and current indices into line ---- */
62struct perthread {
63 LONG lineindex; /* where next char */
64 LONG tidemark; /* rightmost char */
65 int bell; /* TRUE if line has bell */
66 UCHAR line[PRINTFMAXBUF]; /* accumulator */
67 };
68
69/* ----- Local static variables ----- */
70static ULONG ourpid=0; /* our process ID */
71static ULONG servepid=0; /* process IDs of the server */
72static HQUEUE qhandle=0; /* handle for the queue */
73static struct perthread *tps[PRINTFTHREADS+1]; /* -> per-thread data */
74
75/* ----- Local subroutine ----- */
76static int printf_(struct perthread *);
77
78
79/* ----------------------------------------------------------------- */
80/* The "printf" function. Note this has a variable number of */
81/* arguments. */
82/* ----------------------------------------------------------------- */
83int SYSTEM EXPORT WriteLog(char *f, ...)
84 {
85 TIB *ptib; /* process/thread id structures */
86 PIB *ppib; /* .. */
87 TID ourtid; /* thread ID */
88 struct perthread *tp; /* pointer to per-thread data */
89 int rc; /* returncode */
90 ULONG urc; /* returncode */
91
92 urc=DosOpenQueue(&servepid, &qhandle, PRINTFQNAME); /* Open the Q */
93 /* Non-0 RC means Q does not exist or cannot be opened */
94 if (urc==343) return 0; /* queue does not exist, so quit */
95 if (urc!=0) return -1; /* report any other error */
96
97 /* First determine our thread ID (and hence get access to the */
98 /* correct per-thread data. If the per-thread data has not been */
99 /* allocated, then allocate it now. It is never freed, once */
100 /* allocated, as PRINTF is not notified of end-of-thread. */
101 DosGetInfoBlocks(&ptib,&ppib); /* get process/thread info */
102 ourtid=ptib->tib_ptib2->tib2_ultid; /* .. and copy TID */
103 if (ourtid>PRINTFTHREADS) /* too many threads .. */
104 return 0; /* .. so quit, quietly */
105 tp=tps[ourtid]; /* copy to local pointer */
106 if (tp==NULL) { /* uninitialized (NULL=0) */
107 /* allocate a per-thread structure */
108 tp=(struct perthread *)malloc(sizeof(struct perthread));
109 if (tp==NULL) return -1; /* out of memory -- return error */
110 tps[ourtid]=tp; /* save for future calls */
111 strcpy(tp->line,PRINTFID); /* initialize: line.. */
112 tp->lineindex=PRINTFIDSIZE-1; /* ..where next char */
113 tp->tidemark =PRINTFIDSIZE-2; /* ..rightmost char */
114 tp->bell=FALSE; /* ..if line has bell */
115 if (ourpid==0) ourpid=ppib->pib_ulpid; /* save PID for all to use */
116 }
117
118 { /* Block for declarations -- only needed if queue exists, etc. */
119 LONG count; /* count of characters formatted */
120 UCHAR buffer[PRINTFMAXLEN+1]; /* formatting area */
121 LONG i, newind; /* work */
122 UCHAR ch; /* .. */
123 va_list argptr; /* -> variable argument list */
124
125 va_start(argptr, f); /* get pointer to argument list */
126 count=vsprintf(buffer, f, argptr);
127 va_end(argptr); /* done with variable arguments */
128
129 if (count<0) return count-1000;/* bad start */
130
131 if (count>PRINTFMAXLEN) {
132 /* Disaster -- we are probably "dead", but just in case we */
133 /* are not, carry on with truncated data. */
134 count=PRINTFMAXLEN;
135 }
136 buffer[count]='\0'; /* ensure terminated */
137 /* OK, ready to go with the data now in BUFFER */
138 /* We copy from the formatted string to the output (line) buffer, */
139 /* taking note of certain control characters and sending a line */
140 /* the queue whenever we see a LF control, or when the line */
141 /* fills (causing a forced break). */
142 for (i=0; ; i++) {
143 ch=buffer[i]; if (!ch) break;
144 switch(ch) {
145 case '\r': /* carriage return */
146 tp->lineindex=PRINTFIDSIZE-1; /* back to start of line */
147 break;
148 case '\n': /* new line */
149 case '\f': /* form feed */
150 rc=printf_(tp); /* print a line */
151 if (rc!=0) return rc; /* error */
152 break;
153 case '\t': /* tab */
154 newind=tp->lineindex-PRINTFIDSIZE+1; /* offset into data */
155 newind=tp->lineindex+5-newind%5; /* new index requested */
156 if (newind>=PRINTFMAXBUF) newind=PRINTFMAXBUF; /* clamp */
157 for (; tp->lineindex<newind; tp->lineindex++) {
158 if (tp->lineindex>tp->tidemark) { /* beyond current end */
159 tp->line[tp->lineindex]=' '; /* add space */
160 tp->tidemark=tp->lineindex;
161 }
162 }
163 break;
164 case '\v': /* vertical tab */
165 /* ignore it */
166 break;
167 case '\b': /* backspace */
168 tp->lineindex=max(tp->lineindex-1,PRINTFIDSIZE);
169 break;
170 case '\a': /* alert (bell) */
171 tp->bell=TRUE;
172 break;
173 default: /* ordinary character */
174 tp->line[tp->lineindex]=ch;
175 if (tp->lineindex>tp->tidemark) /* is rightmost.. */
176 tp->tidemark=tp->lineindex;
177 tp->lineindex++; /* step for next */
178 } /* switch */
179 if (tp->lineindex>=PRINTFMAXBUF) {
180 rc=printf_(tp); /* print a line */
181 if (rc!=0) return rc; /* error */
182 }
183
184 } /* copy loop */
185 return count; /* all formatted data processed */
186 } /* block */
187 } /* printf */
188
189/* ----- printf_(tp) -- Local subroutine to send a line ------------ */
190/* A line has been completed (or overflowed): write it to the queue. */
191int printf_(struct perthread *tp) /* pointer to per-thread data */
192 {
193 ULONG urc; /* unsigned returncode */
194 PSZ pszTo, pszFrom; /* character pointers */
195 PVOID addr; /* address of output data */
196 long size; /* total size of output data */
197 time_t timenow; /* holds current time */
198
199 tp->line[tp->tidemark+1]='\0'; /* add terminator */
200 size=tp->tidemark+2; /* total length of data */
201
202 /* Get some shared memory that can be given away */
203 urc=DosAllocSharedMem(&addr, NULL, (unsigned)size,
204 OBJ_GIVEABLE|PAG_WRITE|PAG_COMMIT|flAllocMem);
205 /*knut: added flAllocMem */
206
207 if (urc!=0) return -2; /* error */
208
209 pszTo=addr; /* copy for clarity */
210 pszFrom=&(tp->line[0]); /* pointer to source */
211 strcpy(pszTo,pszFrom); /* copy the string to shared memory */
212
213 if (ourpid!=servepid) { /* (no giveaway needed if to self) */
214 urc=DosGiveSharedMem(addr, servepid, PAG_READ); /* give access */
215 if (urc!=0) return -3;} /* error */
216
217 /* Write the selector, size, and timestamp to the queue */
218 if (tp->bell) size=-size; /* BELL passed by negation */
219 time(&timenow); /* optional - else use 0 */
220 urc=DosWriteQueue(qhandle, /* handle */
221 (unsigned)timenow, /* 'request' (timestamp) */
222 (unsigned)size, /* 'length' (length/bell) */
223 addr, /* 'address' (address) */
224 0); /* priority (FIFO if enabled) */
225 if (urc!=0) return -4; /* error */
226 if (ourpid!=servepid) { /* if given away.. */
227 urc=DosFreeMem(addr); /* .. *we* are done with it */
228 if (urc!=0) return -5;} /* error */
229 /* Reset the line buffer and indices */
230 tp->lineindex=PRINTFIDSIZE-1; /* where next char */
231 tp->tidemark =PRINTFIDSIZE-2; /* rightmost char */
232 tp->bell =FALSE; /* true if line has bell */
233 return 0; /* success! */
234 } /* printf_ */
235#endif
236
237
238
239/*****************************************************************************
240 * Standard Version *
241 *****************************************************************************/
242
243static FILE *flog = NULL; /*PLF Mon 97-09-08 20:00:15*/
244static BOOL init = FALSE;
245static BOOL fLogging = TRUE;
246static int dwEnableLogging = 1;
247static int oldcrtmsghandle = 0;
248
249//#define CHECK_ODINHEAP
250#if defined(DEBUG) && defined(CHECK_ODINHEAP)
251int checkOdinHeap = 1;
252#define ODIN_HEAPCHECK() if(checkOdinHeap) _heap_check();
253#else
254#define ODIN_HEAPCHECK()
255#endif
256
257int SYSTEM EXPORT WriteLog(char *tekst, ...)
258{
259 USHORT sel = RestoreOS2FS();
260 va_list argptr;
261
262 ODIN_HEAPCHECK();
263
264 if(!init)
265 {
266 init = TRUE;
267
268#ifdef DEFAULT_LOGGING_OFF
269 if(getenv("WIN32LOG_ENABLED")) {
270#else
271 if(!getenv("NOWIN32LOG")) {
272#endif
273 char logname[CCHMAXPATH];
274
275 sprintf(logname, "odin32_%d.log", loadNr);
276 flog = fopen(logname, "w");
277 if(flog == NULL) {//probably running exe on readonly device
278 sprintf(logname, "%sodin32_%d.log", kernel32Path, loadNr);
279 flog = fopen(logname, "w");
280 }
281 oldcrtmsghandle = _set_crt_msg_handle(fileno(flog));
282 }
283 else
284 fLogging = FALSE;
285 }
286
287 if(fLogging && flog && (dwEnableLogging > 0))
288 {
289 THDB *thdb = GetThreadTHDB();
290
291 va_start(argptr, tekst);
292 if(thdb) {
293 thdb->logfile = (DWORD)flog;
294 if(sel == 0x150b) {
295 fprintf(flog, "t%d: (FS=150B) ", thdb->threadId);
296 }
297 else fprintf(flog, "t%d: ", thdb->threadId);
298 }
299 vfprintf(flog, tekst, argptr);
300 if(thdb) thdb->logfile = 0;
301 va_end(argptr);
302
303 if(tekst[strlen(tekst)-1] != '\n')
304 fprintf(flog, "\n");
305 }
306 SetFS(sel);
307 return 1;
308}
309//******************************************************************************
310//******************************************************************************
311int SYSTEM EXPORT WriteLogNoEOL(char *tekst, ...)
312{
313 USHORT sel = RestoreOS2FS();
314 va_list argptr;
315
316 ODIN_HEAPCHECK();
317
318 if(!init)
319 {
320 init = TRUE;
321
322#ifdef DEFAULT_LOGGING_OFF
323 if(getenv("WIN32LOG_ENABLED")) {
324#else
325 if(!getenv("NOWIN32LOG")) {
326#endif
327 char logname[CCHMAXPATH];
328
329 sprintf(logname, "odin32_%d.log", loadNr);
330 flog = fopen(logname, "w");
331 if(flog == NULL) {//probably running exe on readonly device
332 sprintf(logname, "%sodin32_%d.log", kernel32Path, loadNr);
333 flog = fopen(logname, "w");
334 }
335 }
336 else
337 fLogging = FALSE;
338 }
339
340 if(fLogging && flog && (dwEnableLogging > 0))
341 {
342 THDB *thdb = GetThreadTHDB();
343
344 va_start(argptr, tekst);
345 if(thdb) {
346 thdb->logfile = (DWORD)flog;
347 }
348 vfprintf(flog, tekst, argptr);
349 if(thdb) thdb->logfile = 0;
350 va_end(argptr);
351 }
352 SetFS(sel);
353 return 1;
354}
355//******************************************************************************
356//******************************************************************************
357void SYSTEM DecreaseLogCount()
358{
359 dwEnableLogging--;
360}
361//******************************************************************************
362//******************************************************************************
363void SYSTEM IncreaseLogCount()
364{
365 dwEnableLogging++;
366}
367//******************************************************************************
368//******************************************************************************
369int SYSTEM EXPORT WritePrivateLog(void *logfile, char *tekst, ...)
370{
371 USHORT sel = RestoreOS2FS();
372 va_list argptr;
373
374 if(fLogging && logfile)
375 {
376 THDB *thdb = GetThreadTHDB();
377
378 va_start(argptr, tekst);
379 vfprintf((FILE *)logfile, tekst, argptr);
380 if(thdb) thdb->logfile = 0;
381 va_end(argptr);
382
383 if(tekst[strlen(tekst)-1] != '\n')
384 fprintf((FILE *)logfile, "\n");
385 }
386
387 SetFS(sel);
388 return 1;
389}
390//******************************************************************************
391//Check if the exception occurred inside a fprintf (logging THDB member set)
392//If true, decrease the lock count for that file stream
393//NOTE: HACK: DEPENDS ON COMPILER VERSION!!!!
394//******************************************************************************
395void CheckLogException()
396{
397 THDB *thdb = GetThreadTHDB();
398 USHORT *lock;
399
400 if(!thdb) return;
401
402 if(thdb->logfile) {
403 //oops, exception in vfprintf; let's clear the lock count
404#if (__IBMCPP__ == 300) || (__IBMC__ == 300)
405 lock = (USHORT *)(thdb->logfile+0x1C);
406#else
407#error Check the offset of the lock count word in the file stream structure for this compiler revision!!!!!
408#endif
409 (*lock)--;
410 }
411}
412//******************************************************************************
413//NOTE: No need to save/restore FS, as our FS selectors have already been
414// destroyed and FS == 0x150B.
415//******************************************************************************
416void CloseLogFile()
417{
418 if(oldcrtmsghandle)
419 _set_crt_msg_handle(oldcrtmsghandle);
420
421 fclose(flog);
422 flog = 0;
423}
424//******************************************************************************
425//Used to open any private logfiles used in kernel32 (for now only in winimagepeldr.cpp)
426//******************************************************************************
427void OpenPrivateLogFiles()
428{
429#ifdef DEFAULT_LOGGING_OFF
430 if(getenv("WIN32LOG_ENABLED")) {
431#else
432 if(!getenv("NOWIN32LOG")) {
433#endif
434 OpenPrivateLogFilePE();
435 }
436}
437//******************************************************************************
438//Used to close all private logfiles used in kernel32 (for now only in winimagepeldr.cpp)
439//******************************************************************************
440void ClosePrivateLogFiles()
441{
442#ifdef DEFAULT_LOGGING_OFF
443 if(getenv("WIN32LOG_ENABLED")) {
444#else
445 if(!getenv("NOWIN32LOG")) {
446#endif
447 ClosePrivateLogFilePE();
448 }
449}
450//******************************************************************************
451//******************************************************************************
452int SYSTEM EXPORT WriteLogError(char *tekst, ...)
453{
454 USHORT sel = RestoreOS2FS();
455 va_list argptr;
456
457 va_start(argptr, tekst);
458 printf("ERROR: ");
459 vprintf(tekst, argptr);
460 va_end(argptr);
461 if(tekst[strlen(tekst)-1] != '\n')
462 printf("\n");
463
464 SetFS(sel);
465 return 1;
466}
467//******************************************************************************
468//******************************************************************************
469void SYSTEM CheckVersion(ULONG version, char *modname)
470{
471 dprintf(("CheckVersion of %s, %d\n", modname, version));
472 if(version != PE2LX_VERSION){
473 static char msg[300];
474 int r;
475 dprintf(("Version mismatch! %d, %d: %s\n", version, PE2LX_VERSION, modname));
476 sprintf(msg, "%s is intended for use with a different release of PE2LX.\n", modname);
477 do{
478 r = WinMessageBox(HWND_DESKTOP, NULLHANDLE, msg, "Version Mismatch!", 0, MB_ABORTRETRYIGNORE | MB_ICONEXCLAMATION | MB_MOVEABLE);
479 }while(r == MBID_RETRY); // giggle
480 if( r != MBID_IGNORE )
481 exit(987);
482 }
483}
484//******************************************************************************
485//******************************************************************************
486void SYSTEM CheckVersionFromHMOD(ULONG version, HMODULE hModule)
487{
488 char name[_MAX_PATH];
489
490 // query name of dll.
491 if(!DosQueryModuleName(hModule, sizeof(name), name))
492 CheckVersion(version, name);
493}
494//******************************************************************************
495//******************************************************************************
496#ifdef __WATCOMC__ /*PLF Sat 97-06-21 17:12:36*/
497 extern void interrupt3( void );
498 #pragma aux interrupt3= \
499 "int 3"
500#endif
501void WIN32API DebugBreak()
502{
503 dprintf(("DebugBreak\n"));
504
505 LPSTR lpstrEnv = getenv("WIN32.DEBUGBREAK"); /* query environment */
506 if (lpstrEnv == NULL) /* if environment is not set, don't call debugger ! */
507 return;
508
509#ifdef __WATCOMC__
510 interrupt3();
511#else
512 _interrupt(3);
513#endif
514}
515//******************************************************************************
516//******************************************************************************
517
518
519/*****************************************************************************
520 * Name : DebugErrorBox
521 * Purpose : display an apprioriate error box with detailed information
522 * about the error cause
523 * Parameters: APIRET iErrorCode - OS/2 error code
524 * PSZ pszFormat - printf-format string
525 * ...
526 * Variables :
527 * Result : return code of the message box
528 * Remark :
529 * Status :
530 *
531 * Author : Patrick Haller [Tue, 1999/09/13 19:55]
532 *****************************************************************************/
533
534int SYSTEM EXPORT DebugErrorBox(ULONG iErrorCode,
535 char* pszFormat,
536 ...)
537{
538 char szMessageBuffer[1024]; /* buffer for the text message */
539 char szErrorBuffer[1024]; /* buffer for the operating system text */
540 ULONG bc; /* dummy */
541 APIRET rc2; /* API returncode */
542 int iRC; /* message box return code */
543
544 USHORT sel = RestoreOS2FS();
545 va_list argptr;
546
547 // clear memory
548 memset (szMessageBuffer, 0, sizeof(szMessageBuffer));
549 memset (szErrorBuffer, 0, sizeof(szErrorBuffer));
550
551 // build message string
552 va_start(argptr, pszFormat);
553 vsprintf(szMessageBuffer, pszFormat, argptr);
554 va_end(argptr);
555
556 // query error string
557 rc2 = DosGetMessage(NULL,
558 0,
559 szErrorBuffer,
560 sizeof(szErrorBuffer),
561 iErrorCode,
562 "OSO001.MSG",
563 &bc);
564
565 // display message box
566 iRC = WinMessageBox(HWND_DESKTOP,
567 NULLHANDLE,
568 szMessageBuffer,
569 szErrorBuffer,
570 0,
571 MB_OK | MB_ICONEXCLAMATION | MB_MOVEABLE);
572 SetFS(sel);
573 return iRC;
574}
Note: See TracBrowser for help on using the repository browser.