threaded-logging-20050619
[openafs.git] / src / util / serverLog.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*  serverLog.c     - Server logging                                      */
11 /*                                                                        */
12 /*  Information Technology Center                                         */
13 /*  Date: 05/21/97                                                        */
14 /*                                                                        */
15 /*  Function    - These routiens implement logging from the servers       */
16 /*                                                                        */
17 /* ********************************************************************** */
18
19 #include <afsconfig.h>
20 #include <afs/param.h>
21
22 RCSID
23     ("$Header$");
24
25 #include <stdio.h>
26 #ifdef AFS_NT40_ENV
27 #include <io.h>
28 #include <time.h>
29 #else
30 #ifdef AFS_AIX_ENV
31 #include <time.h>
32 #endif
33 #include <sys/param.h>
34 #include <sys/time.h>
35 #include <syslog.h>
36 #endif
37 #include <afs/procmgmt.h>       /* signal(), kill(), wait(), etc. */
38 #include <fcntl.h>
39 #include <afs/stds.h>
40 #ifdef HAVE_STRING_H
41 #include <string.h>
42 #else
43 #ifdef HAVE_STRINGS_H
44 #include <strings.h>
45 #endif
46 #endif
47 #include <sys/stat.h>
48 #include "afsutil.h"
49 #include "fileutil.h"
50 #if defined(AFS_PTHREAD_ENV)
51 #include <assert.h>
52 #include <pthread.h>
53 static pthread_mutex_t serverLogMutex;
54 #define LOCK_SERVERLOG() assert(pthread_mutex_lock(&serverLogMutex)==0)
55 #define UNLOCK_SERVERLOG() assert(pthread_mutex_unlock(&serverLogMutex)==0)
56
57 #ifdef AFS_NT40_ENV
58 #define NULLDEV "NUL"
59 #else
60 #define NULLDEV "/dev/null"
61 #endif
62
63 #else /* AFS_PTHREAD_ENV */
64 #define LOCK_SERVERLOG()
65 #define UNLOCK_SERVERLOG()
66 #endif /* AFS_PTHREAD_ENV */
67
68 #ifdef AFS_NT40_ENV
69 #define F_OK 0
70 #define O_NONBLOCK 0
71 #endif
72
73 static char *(*threadNameProgram) () = NULL;
74
75 static int serverLogFD = -1;
76
77 #ifndef AFS_NT40_ENV
78 int serverLogSyslog = 0;
79 int serverLogSyslogFacility = LOG_DAEMON;
80 char *serverLogSyslogTag = 0;
81 #endif
82
83 #include <stdarg.h>
84 int LogLevel;
85 int mrafsStyleLogs = 0;
86 static int threadIdLogs = 0;
87 int printLocks = 0;
88 static char ourName[MAXPATHLEN];
89
90 void
91 SetLogThreadNameProgram(char *(*func) () )
92 {
93     threadNameProgram = func;
94 }
95
96 void
97 WriteLogBuffer(char *buf, afs_uint32 len)
98 {
99     LOCK_SERVERLOG();
100     if (serverLogFD > 0)
101         (void)write(serverLogFD, buf, len);
102     UNLOCK_SERVERLOG();
103 }
104
105 void
106 vFSLog(const char *format, va_list args)
107 {
108     time_t currenttime;
109     char *timeStamp;
110     char tbuffer[1024];
111     char *info;
112     int len;
113     char *name;
114
115     currenttime = time(0);
116     timeStamp = afs_ctime(&currenttime, tbuffer, sizeof(tbuffer));
117     timeStamp[24] = ' ';        /* ts[24] is the newline, 25 is the null */
118     info = &timeStamp[25];
119
120     if (mrafsStyleLogs || threadIdLogs) {
121         name = (*threadNameProgram) ();
122         if (name) {
123         (void)afs_snprintf(info, (sizeof tbuffer) - strlen(tbuffer), "[%s] ",
124                            name);
125         info += strlen(info);
126     }
127     }
128
129     (void)afs_vsnprintf(info, (sizeof tbuffer) - strlen(tbuffer), format,
130                         args);
131
132     len = strlen(tbuffer);
133     LOCK_SERVERLOG();
134 #ifndef AFS_NT40_ENV
135     if (serverLogSyslog) {
136         syslog(LOG_INFO, "%s", info);
137     } else
138 #endif
139     if (serverLogFD > 0)
140         (void)write(serverLogFD, tbuffer, len);
141     UNLOCK_SERVERLOG();
142
143 #if !defined(AFS_PTHREAD_ENV) && !defined(AFS_NT40_ENV)
144     if (!serverLogSyslog) {
145         fflush(stdout);
146         fflush(stderr);         /* in case they're sharing the same FD */
147     }
148 #endif
149 }                               /*vFSLog */
150
151 /* VARARGS1 */
152 /*@printflike@*/
153 void
154 FSLog(const char *format, ...)
155 {
156     va_list args;
157
158     va_start(args, format);
159     vFSLog(format, args);
160     va_end(args);
161 }                               /*FSLog */
162
163 static int
164 DebugOn(int loglevel)
165 {
166     if (loglevel == 0) {
167         ViceLog(0, ("Reset Debug levels to 0\n"));
168     } else {
169         ViceLog(0, ("Set Debug On level = %d\n", loglevel));
170     }
171     return 0;
172 }                               /*DebugOn */
173
174
175
176 void
177 SetDebug_Signal(int signo)
178 {
179 /*    extern int IOMGR_SoftSig();*/
180
181     if (LogLevel > 0) {
182         LogLevel *= 5;
183
184 #if defined(AFS_PTHREAD_ENV)
185         if (LogLevel > 999 && threadNameProgram != NULL && 
186             threadIdLogs == 0) {
187             threadIdLogs = 1;
188         }
189 #endif
190     } else {
191         LogLevel = 1;
192
193 #if defined(AFS_PTHREAD_ENV)
194         if (threadIdLogs == 1)
195             threadIdLogs = 0;
196 #endif
197     }
198     printLocks = 2;
199 #if defined(AFS_PTHREAD_ENV)
200     DebugOn(LogLevel);
201 #else /* AFS_PTHREAD_ENV */
202     IOMGR_SoftSig(DebugOn, LogLevel);
203 #endif /* AFS_PTHREAD_ENV */
204
205     (void)signal(signo, SetDebug_Signal);       /* on some platforms, this
206                                                  * signal handler needs to
207                                                  * be set again */
208 }                               /*SetDebug_Signal */
209
210 void
211 ResetDebug_Signal(int signo)
212 {
213     LogLevel = 0;
214
215     if (printLocks > 0)
216         --printLocks;
217 #if defined(AFS_PTHREAD_ENV)
218     DebugOn(LogLevel);
219 #else /* AFS_PTHREAD_ENV */
220     IOMGR_SoftSig(DebugOn, (void *)LogLevel);
221 #endif /* AFS_PTHREAD_ENV */
222
223     (void)signal(signo, ResetDebug_Signal);     /* on some platforms,
224                                                  * this signal handler
225                                                  * needs to be set
226                                                  * again */
227 #if defined(AFS_PTHREAD_ENV)
228     if (threadIdLogs == 1)
229         threadIdLogs = 0;
230 #endif
231     if (mrafsStyleLogs)
232         OpenLog((char *)&ourName);
233 }                               /*ResetDebug_Signal */
234
235
236 void
237 SetupLogSignals(void)
238 {
239     (void)signal(SIGHUP, ResetDebug_Signal);
240     /* Note that we cannot use SIGUSR1 -- Linux stole it for pthreads! */
241     (void)signal(SIGTSTP, SetDebug_Signal);
242 #ifndef AFS_NT40_ENV
243     (void)signal(SIGPIPE, SIG_IGN);
244 #endif
245 }
246
247 int
248 OpenLog(const char *fileName)
249 {
250     /*
251      * This function should allow various libraries that inconsistently
252      * use stdout/stderr to all go to the same place
253      */
254     int tempfd, isfifo = 0;
255     char oldName[MAXPATHLEN];
256     struct timeval Start;
257     struct tm *TimeFields;
258     char FileName[MAXPATHLEN];
259
260 #ifndef AFS_NT40_ENV
261     struct stat statbuf;
262
263     if (serverLogSyslog) {
264         openlog(serverLogSyslogTag, LOG_PID, serverLogSyslogFacility);
265         return (0);
266     }
267
268     /* Support named pipes as logs by not rotating them */
269     if ((lstat(fileName, &statbuf) == 0)  && (S_ISFIFO(statbuf.st_mode))) {
270         isfifo = 1;
271     }
272 #endif
273
274     if (mrafsStyleLogs) {
275         time_t t;
276         TM_GetTimeOfDay(&Start, 0);
277         t = Start.tv_sec;       
278         TimeFields = localtime(&t);
279         if (fileName) {
280             if (strncmp(fileName, (char *)&ourName, strlen(fileName)))
281                 strcpy((char *)&ourName, (char *)fileName);
282         }
283         afs_snprintf(FileName, MAXPATHLEN, "%s.%d%02d%02d%02d%02d%02d",
284                      ourName, TimeFields->tm_year + 1900,
285                      TimeFields->tm_mon + 1, TimeFields->tm_mday,
286                      TimeFields->tm_hour, TimeFields->tm_min,
287                      TimeFields->tm_sec);
288         if (!isfifo)
289             renamefile(fileName, FileName);     /* don't check error code */
290         tempfd = open(fileName, O_WRONLY | O_TRUNC | O_CREAT | (isfifo?O_NONBLOCK:0), 0666);
291     } else {
292         strcpy(oldName, fileName);
293         strcat(oldName, ".old");
294
295         /* don't check error */
296         if (!isfifo)
297             renamefile(fileName, oldName);
298         tempfd = open(fileName, O_WRONLY | O_TRUNC | O_CREAT | (isfifo?O_NONBLOCK:0), 0666);
299     }
300
301     if (tempfd < 0) {
302         printf("Unable to open log file %s\n", fileName);
303         return -1;
304     }
305 #if defined(AFS_PTHREAD_ENV)
306     /* redirect stdout and stderr so random printf's don't write to data */
307     assert(freopen(NULLDEV, "w", stdout) != NULL);
308     assert(freopen(NULLDEV, "w", stderr) != NULL);
309
310     assert(pthread_mutex_init(&serverLogMutex, NULL) == 0);
311
312     serverLogFD = tempfd;
313 #else
314     close(tempfd);              /* just checking.... */
315     (void)freopen(fileName, "w", stdout);
316     (void)freopen(fileName, "w", stderr);
317     serverLogFD = fileno(stdout);
318 #endif /* AFS_PTHREAD_ENV */
319
320     return 0;
321 }                               /*OpenLog */
322
323 int
324 ReOpenLog(const char *fileName)
325 {
326     int isfifo = 0;
327 #if !defined(AFS_PTHREAD_ENV)
328     int tempfd;
329 #endif
330 #if !defined(AFS_NT40_ENV)
331     struct stat statbuf;
332 #endif
333
334     if (access(fileName, F_OK) == 0)
335         return 0;               /* exists, no need to reopen. */
336
337 #if !defined(AFS_NT40_ENV)
338     if (serverLogSyslog) {
339         return 0;
340     }
341
342     /* Support named pipes as logs by not rotating them */
343     if ((lstat(fileName, &statbuf) == 0)  && (S_ISFIFO(statbuf.st_mode))) {
344         isfifo = 1;
345     }
346 #endif
347
348 #if defined(AFS_PTHREAD_ENV)
349     LOCK_SERVERLOG();
350     if (serverLogFD > 0)
351         close(serverLogFD);
352     serverLogFD = open(fileName, O_WRONLY | O_APPEND | O_CREAT | (isfifo?O_NONBLOCK:0), 0666);
353     UNLOCK_SERVERLOG();
354     return serverLogFD < 0 ? -1 : 0;
355 #else
356
357     tempfd = open(fileName, O_WRONLY | O_APPEND | O_CREAT | (isfifo?O_NONBLOCK:0), 0666);
358     if (tempfd < 0) {
359         printf("Unable to open log file %s\n", fileName);
360         return -1;
361     }
362     close(tempfd);
363
364     (void)freopen(fileName, "a", stdout);
365     (void)freopen(fileName, "a", stderr);
366     serverLogFD = fileno(stdout);
367
368
369     return 0;
370 #endif /* AFS_PTHREAD_ENV */
371 }