--- deliantra/server/common/logger.C	2006/12/30 10:16:10	1.7
+++ deliantra/server/common/logger.C	2012/10/29 23:55:52	1.29
@@ -1,65 +1,267 @@
 /*
-    CrossFire, A Multiplayer game for X-windows
+ * This file is part of Deliantra, the Roguelike Realtime MMORPG.
+ *
+ * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+ *
+ * Deliantra is free software: you can redistribute it and/or modify it under
+ * the terms of the Affero GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the Affero GNU General Public License
+ * and the GNU General Public License along with this program. If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * The authors can be reached via e-mail to <support@deliantra.net>
+ */
 
-    Copyright (C) 2002 Mark Wedel & Crossfire Development Team
-    Copyright (C) 1992 Frank Tore Johansen
+#include <cstdarg>
+#include <cstring>
 
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
+#include <vector>
 
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
+#include <sys/uio.h>
+#include <pthread.h>
 
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+#include "global.h"
+#include "dynbuf.h"
+#include "util.h"
 
-    The authors can be reached via e-mail at <crossfire@schmorp.de>
-*/
+struct logline
+{
+  struct timeval tv;
+  char *buf; // includes PREFIX_LEN garbage bytes
+  int len;
+  int flags;
+};
+
+typedef std::vector<logline, slice_allocator<logline> > logvector;
+
+static SMUTEX(mutex);
+static SMUTEX(fdlock);
+static SCOND(cond);
+static int logfd = STDERR_FILENO;
+static int logsync = 1;
+static logvector queue;
 
+int log_setfd (int fd)
+{
+  SMUTEX_LOCK (fdlock);
+  int old = logfd;
+  logfd = fd < 0 ? STDERR_FILENO : fd;
+  SMUTEX_UNLOCK (fdlock);
 
-#include <stdarg.h>
-#include <global.h>
-#include <funcpoint.h>
+  return old;
+}
 
-/*
- * Logs a message to stderr, or to file, and/or even to socket.
- * Or discards the message if it is of no importanse, and none have
- * asked to hear messages of that logLevel.
- *
- * See include/logger.h for possible logLevels.  Messages with llevInfo
- * and llevError are always printed, regardless of debug mode.
- */
+#define PREFIX_LEN sizeof ("0000-00-00 00:00:00.0000 L+") - 1
+
+static void
+log_sync (logline &line)
+{
+  static const char levelchar [16+1] = "EWIDt???????????";
+  struct tm lt;
+  char pfx [PREFIX_LEN];
+
+  localtime_r (&line.tv.tv_sec, &lt);
+
+  sprintf (pfx, "%04d-%02d-%02d %02d:%02d:%02d.%04d %c",
+    lt.tm_year + 1900,
+    lt.tm_mon + 1,
+    lt.tm_mday,
+    lt.tm_hour,
+    lt.tm_min,
+    lt.tm_sec,
+    (int)(line.tv.tv_usec / 100),
+    levelchar [line.flags & 15]
+  );
+
+  pfx [PREFIX_LEN - 1] = line.flags & logSync ? '=' : ' ';
+
+  struct iovec iov [2];
+
+  iov [0].iov_base = pfx;
+  iov [0].iov_len = PREFIX_LEN;
+
+  char *buf = line.buf;
+
+  if (logsync != 2)
+    SMUTEX_LOCK (fdlock);
+
+  while (char *end = strchr (buf, '\n'))
+    {
+      iov [1].iov_base = buf;
+      iov [1].iov_len = end - buf + 1;
+
+      writev (STDERR_FILENO, iov, 2);
+      if (logfd != STDERR_FILENO)
+        writev (logfd, iov, 2);
+
+      buf = end + 1;
+
+      if (buf == line.buf + line.len)
+        break;
+
+      pfx [PREFIX_LEN - 1] = '+';
+    }
+
+  if (logsync != 2)
+    SMUTEX_UNLOCK (fdlock);
+
+  sfree (line.buf, line.len);
+}
+
+static void *
+logthread_proc (void *arg)
+{
+  int idx = 0;
+
+  for (;;)
+    {
+      logline line;
+
+      SMUTEX_LOCK (mutex);
+
+      while (queue.empty ())
+        SCOND_WAIT (cond, mutex);
+
+      line = queue [idx++];
+
+      // this algorithm could result in an ever-increasing vector
+      // size if we log faster than we can write, but if that happens
+      // we have bigger problems.
+      if (idx == queue.size ())
+        {
+          if (idx < 32)
+            queue.clear ();
+          else
+            logvector ().swap (queue); // free memory, hopefully
+
+          idx = 0;
+        }
+
+      SMUTEX_UNLOCK (mutex);
+
+      log_sync (line);
+    }
+}
 
 void
-LOG (LogLevel logLevel, const char *format, ...)
+log_cleanup ()
 {
-  if (logLevel <= settings.debug)
+  logsync = 1;
+  SMUTEX_UNLOCK (fdlock);
+
+  for (;;)
     {
-      char buf[20480];              /* This needs to be really really big - larger
-                                     * than any other buffer, since that buffer may
-                                     * need to be put in this one.
-                                     */
-      char tbuf[20480];
+      int done;
+
+      SMUTEX_LOCK (mutex);
+      done = queue.empty ();
+      SMUTEX_UNLOCK (mutex);
+
+      if (done)
+        break;
+
+      usleep (10000);
+      SMUTEX_LOCK (fdlock);
+      SMUTEX_UNLOCK (fdlock);
+    }
+}
+
+static void
+af_child ()
+{
+  logsync = 2;
+}
+
+static struct logthread : thread
+{
+  logthread ()
+  {
+    pthread_atfork (0, 0, af_child);
+    start (logthread_proc);
+    logsync = 0;
+  }
+} logthread;
+
+void
+LOG (int flags, const_utf8_string format, ...)
+{
+  int level = flags & 15;
+
+  if (level > settings.debug)
+    return;
+
+  logline line;
+  gettimeofday (&line.tv, 0);
+
+  static dynbuf_text buf;
+
+  va_list ap;
+  va_start (ap, format);
+  buf.vprintf (format, ap);
+  va_end (ap);
 
-      time_t curtime = time (NULL);
-      struct tm *ptime = localtime (&curtime);
+  buf << '\n';
 
-      strftime (tbuf, 256, "%Y-%m-%d %H:%M:%S ", ptime);
+  line.buf = buf.linearise ();
+  line.len = buf.size ();
 
-      va_list ap;
+  if (line.buf [line.len - 2] == '\n')
+    --line.len;
 
-      va_start (ap, format);
+  line.buf = salloc<char> (line.len, line.buf);
 
-      vsnprintf (buf, sizeof (buf), format, ap);
-      strncat (tbuf, buf, 20460);
-      fputs (tbuf, logfile);
-      fputs (tbuf, stderr);
+  buf.clear ();
 
-      va_end (ap);
+  if (logsync)
+    flags |= logSync;
+
+  if (flags & logBacktrace)
+    {
+      line.buf [line.len - 1] = 0;
+      log_backtrace (line.buf);
+      line.buf [line.len - 1] = '\n';
+    }
+
+  line.flags = flags;
+
+  if (line.flags & logSync)
+    log_sync (line);
+  else
+    {
+      SMUTEX_LOCK (mutex);
+      queue.push_back (line);
+      SMUTEX_UNLOCK (mutex);
+      SCOND_SIGNAL (cond);
+    }
+}
+
+static int suspended;
+
+void
+log_suspend ()
+{
+  if (!suspended++)
+    {
+      LOG (llevDebug, "logging suspended.");
+      SMUTEX_LOCK (fdlock);
+    }
+}
+
+void
+log_resume ()
+{
+  if (!--suspended)
+    {
+      SMUTEX_UNLOCK (fdlock);
+      LOG (llevDebug, "logging resumed.");
     }
 }
+