Update to xserver 1.12.2. tested by naddy@, krw@, mpi@.

1 files changed, 141 insertions, 144 deletions

diff --git a/xserver/os/osinit.c b/xserver/os/osinit.c
index d1b7e737e..143e872e7 100644
--- a/xserver/os/osinit.c
+++ b/xserver/os/osinit.c
@@ -22,7 +22,6 @@ Except as contained in this notice, the name of The Open Group shall not be
 used in advertising or otherwise to promote the sale, use or other dealings
 in this Software without prior written authorization from The Open Group.
 
-
 Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
 
                         All Rights Reserved
@@ -57,7 +56,7 @@ SOFTWARE.
 #include <signal.h>
 #include <errno.h>
 #ifdef HAVE_DLFCN_H
-# include <dlfcn.h>
+#include <dlfcn.h>
 #endif
 #ifdef HAVE_BACKTRACE
 #include <execinfo.h>
@@ -67,8 +66,7 @@ SOFTWARE.
 
 #include "dixstruct.h"
 
-
-#if !defined(SYSV) && !defined(WIN32) 
+#if !defined(SYSV) && !defined(WIN32)
 #include <sys/resource.h>
 #endif
 
@@ -77,6 +75,7 @@ SOFTWARE.
 #endif
 
 extern char *display;
+
 #ifdef RLIMIT_DATA
 int limitDataSpace = -1;
 #endif
@@ -105,188 +104,187 @@ OsRegisterSigWrapper(OsSigWrapperPtr newSigWrapper)
  */
 static void
 #ifdef SA_SIGINFO
-OsSigHandler(int signo, siginfo_t *sip, void *unused)
+OsSigHandler(int signo, siginfo_t * sip, void *unused)
 #else
 OsSigHandler(int signo)
 #endif
 {
 #ifdef RTLD_DI_SETSIGNAL
-  const char *dlerr = dlerror();
+    const char *dlerr = dlerror();
 
-  if (dlerr) {
-      LogMessage(X_ERROR, "Dynamic loader error: %s\n", dlerr);
-  }
-#endif /* RTLD_DI_SETSIGNAL */
+    if (dlerr) {
+        LogMessage(X_ERROR, "Dynamic loader error: %s\n", dlerr);
+    }
+#endif                          /* RTLD_DI_SETSIGNAL */
 
-  if (OsSigWrapper != NULL) {
-      if (OsSigWrapper(signo) == 0) {
-	  /* ddx handled signal and wants us to continue */
-	  return;
-      }
-  }
+    if (OsSigWrapper != NULL) {
+        if (OsSigWrapper(signo) == 0) {
+            /* ddx handled signal and wants us to continue */
+            return;
+        }
+    }
 
-  /* log, cleanup, and abort */
-  xorg_backtrace();
+    /* log, cleanup, and abort */
+    xorg_backtrace();
 
 #ifdef SA_SIGINFO
-  if (sip->si_code == SI_USER) {
-      ErrorF("Recieved signal %d sent by process %ld, uid %ld\n",
-	     signo, (long) sip->si_pid, (long) sip->si_uid);
-  } else {
-      switch (signo) {
-          case SIGSEGV:
-          case SIGBUS:
-          case SIGILL:
-          case SIGFPE:
-	      ErrorF("%s at address %p\n", strsignal(signo), sip->si_addr);
-      }
-  }
+    if (sip->si_code == SI_USER) {
+        ErrorF("Recieved signal %d sent by process %ld, uid %ld\n",
+               signo, (long) sip->si_pid, (long) sip->si_uid);
+    }
+    else {
+        switch (signo) {
+        case SIGSEGV:
+        case SIGBUS:
+        case SIGILL:
+        case SIGFPE:
+            ErrorF("%s at address %p\n", strsignal(signo), sip->si_addr);
+        }
+    }
 #endif
 
-  FatalError("Caught signal %d (%s). Server aborting\n",
-	     signo, strsignal(signo));
+    FatalError("Caught signal %d (%s). Server aborting\n",
+               signo, strsignal(signo));
 }
 
 void
 OsInit(void)
 {
     static Bool been_here = FALSE;
-    static char* devnull = "/dev/null";
+    static const char *devnull = "/dev/null";
     char fname[PATH_MAX];
 
     if (!been_here) {
-	struct sigaction act, oact;
-	int i;
-	int siglist[] = { SIGSEGV, SIGQUIT, SIGILL, SIGFPE, SIGBUS,
-			  SIGSYS,
-			  SIGXCPU,
-			  SIGXFSZ,
+        struct sigaction act, oact;
+        int i;
+
+        int siglist[] = { SIGSEGV, SIGQUIT, SIGILL, SIGFPE, SIGBUS,
+            SIGSYS,
+            SIGXCPU,
+            SIGXFSZ,
 #ifdef SIGEMT
-			  SIGEMT,
+            SIGEMT,
 #endif
-			  0 /* must be last */ };
-	sigemptyset(&act.sa_mask);
+            0 /* must be last */
+        };
+        sigemptyset(&act.sa_mask);
 #ifdef SA_SIGINFO
-	act.sa_sigaction = OsSigHandler;
-	act.sa_flags = SA_SIGINFO;
+        act.sa_sigaction = OsSigHandler;
+        act.sa_flags = SA_SIGINFO;
 #else
         act.sa_handler = OsSigHandler;
         act.sa_flags = 0;
 #endif
-	for (i = 0; siglist[i] != 0; i++) {
-	    if (sigaction(siglist[i], &act, &oact)) {
-		ErrorF("failed to install signal handler for signal %d: %s\n",
-		       siglist[i], strerror(errno));
-	    }
-	}
+        for (i = 0; siglist[i] != 0; i++) {
+            if (sigaction(siglist[i], &act, &oact)) {
+                ErrorF("failed to install signal handler for signal %d: %s\n",
+                       siglist[i], strerror(errno));
+            }
+        }
 #ifdef HAVE_BACKTRACE
-	/*
-	 * initialize the backtracer, since the ctor calls dlopen(), which
-	 * calls malloc(), which isn't signal-safe.
-	 */
-	do {
-	    void *array;
-	    backtrace(&array, 1);
-	} while (0);
+        /*
+         * initialize the backtracer, since the ctor calls dlopen(), which
+         * calls malloc(), which isn't signal-safe.
+         */
+        do {
+            void *array;
+
+            backtrace(&array, 1);
+        } while (0);
 #endif
 
 #ifdef RTLD_DI_SETSIGNAL
-	/* Tell runtime linker to send a signal we can catch instead of SIGKILL
-	 * for failures to load libraries/modules at runtime so we can clean up
-	 * after ourselves.
-	 */
-	int failure_signal = SIGQUIT;
-	dlinfo(RTLD_SELF, RTLD_DI_SETSIGNAL, &failure_signal);
+        /* Tell runtime linker to send a signal we can catch instead of SIGKILL
+         * for failures to load libraries/modules at runtime so we can clean up
+         * after ourselves.
+         */
+        int failure_signal = SIGQUIT;
+
+        dlinfo(RTLD_SELF, RTLD_DI_SETSIGNAL, &failure_signal);
 #endif
 
-#if !defined(__CYGWIN__) 
-	fclose(stdin);
-	fclose(stdout);
+#if !defined(__CYGWIN__)
+        fclose(stdin);
+        fclose(stdout);
 #endif
-	/* 
-	 * If a write of zero bytes to stderr returns non-zero, i.e. -1, 
-	 * then writing to stderr failed, and we'll write somewhere else 
-	 * instead. (Apparently this never happens in the Real World.)
-	 */
-	if (write (2, fname, 0) == -1) 
-	{
-	    FILE *err;
-
-	    if (strlen (display) + strlen (ADMPATH) + 1 < sizeof fname)
-		snprintf (fname, sizeof(fname), ADMPATH, display);
-	    else
-		strlcpy (fname, devnull, sizeof(fname));
-	    /*
-	     * uses stdio to avoid os dependencies here,
-	     * a real os would use
- 	     *  open (fname, O_WRONLY|O_APPEND|O_CREAT, 0666)
-	     */
-	    if (!(err = fopen (fname, "a+")))
-		err = fopen (devnull, "w");
-	    if (err && (fileno(err) != 2)) {
-		dup2 (fileno (err), 2);
-		fclose (err);
-	    }
+        /* 
+         * If a write of zero bytes to stderr returns non-zero, i.e. -1, 
+         * then writing to stderr failed, and we'll write somewhere else 
+         * instead. (Apparently this never happens in the Real World.)
+         */
+        if (write(2, fname, 0) == -1) {
+            FILE *err;
+
+            if (strlen(display) + strlen(ADMPATH) + 1 < sizeof fname)
+                snprintf(fname, sizeof(fname), ADMPATH, display);
+            else
+                strlcpy(fname, devnull, sizeof(fname));
+            /*
+             * uses stdio to avoid os dependencies here,
+             * a real os would use
+             *  open (fname, O_WRONLY|O_APPEND|O_CREAT, 0666)
+             */
+            if (!(err = fopen(fname, "a+")))
+                err = fopen(devnull, "w");
+            if (err && (fileno(err) != 2)) {
+                dup2(fileno(err), 2);
+                fclose(err);
+            }
 #if defined(SYSV) || defined(SVR4) || defined(WIN32) || defined(__CYGWIN__)
-	    {
-	    static char buf[BUFSIZ];
-	    setvbuf (stderr, buf, _IOLBF, BUFSIZ);
-	    }
+            {
+                static char buf[BUFSIZ];
+
+                setvbuf(stderr, buf, _IOLBF, BUFSIZ);
+            }
 #else
-	    setlinebuf(stderr);
+            setlinebuf(stderr);
 #endif
-	}
+        }
 
-	if (getpgrp () == 0)
-	    setpgid (0, 0);
+        if (getpgrp() == 0)
+            setpgid(0, 0);
 
 #ifdef RLIMIT_DATA
-	if (limitDataSpace >= 0)
-	{
-	    struct rlimit	rlim;
-
-	    if (!getrlimit(RLIMIT_DATA, &rlim))
-	    {
-		if ((limitDataSpace > 0) && (limitDataSpace < rlim.rlim_max))
-		    rlim.rlim_cur = limitDataSpace;
-		else
-		    rlim.rlim_cur = rlim.rlim_max;
-		(void)setrlimit(RLIMIT_DATA, &rlim);
-	    }
-	}
+        if (limitDataSpace >= 0) {
+            struct rlimit rlim;
+
+            if (!getrlimit(RLIMIT_DATA, &rlim)) {
+                if ((limitDataSpace > 0) && (limitDataSpace < rlim.rlim_max))
+                    rlim.rlim_cur = limitDataSpace;
+                else
+                    rlim.rlim_cur = rlim.rlim_max;
+                (void) setrlimit(RLIMIT_DATA, &rlim);
+            }
+        }
 #endif
 #ifdef RLIMIT_STACK
-	if (limitStackSpace >= 0)
-	{
-	    struct rlimit	rlim;
-
-	    if (!getrlimit(RLIMIT_STACK, &rlim))
-	    {
-		if ((limitStackSpace > 0) && (limitStackSpace < rlim.rlim_max))
-		    rlim.rlim_cur = limitStackSpace;
-		else
-		    rlim.rlim_cur = rlim.rlim_max;
-		(void)setrlimit(RLIMIT_STACK, &rlim);
-	    }
-	}
+        if (limitStackSpace >= 0) {
+            struct rlimit rlim;
+
+            if (!getrlimit(RLIMIT_STACK, &rlim)) {
+                if ((limitStackSpace > 0) && (limitStackSpace < rlim.rlim_max))
+                    rlim.rlim_cur = limitStackSpace;
+                else
+                    rlim.rlim_cur = rlim.rlim_max;
+                (void) setrlimit(RLIMIT_STACK, &rlim);
+            }
+        }
 #endif
 #ifdef RLIMIT_NOFILE
-	if (limitNoFile >= 0)
-	{
-	    struct rlimit	rlim;
-
-	    if (!getrlimit(RLIMIT_NOFILE, &rlim))
-	    {
-		if ((limitNoFile > 0) && (limitNoFile < rlim.rlim_max))
-		    rlim.rlim_cur = limitNoFile;
-		else
-		    rlim.rlim_cur = rlim.rlim_max;
-		(void)setrlimit(RLIMIT_NOFILE, &rlim);
-	    }
-	}
+        if (limitNoFile >= 0) {
+            struct rlimit rlim;
+
+            if (!getrlimit(RLIMIT_NOFILE, &rlim)) {
+                if ((limitNoFile > 0) && (limitNoFile < rlim.rlim_max))
+                    rlim.rlim_cur = limitNoFile;
+                else
+                    rlim.rlim_cur = rlim.rlim_max;
+                (void) setrlimit(RLIMIT_NOFILE, &rlim);
+            }
+        }
 #endif
-	LockServer();
-	been_here = TRUE;
+        LockServer();
+        been_here = TRUE;
     }
     TimerInit();
     OsVendorInit();
@@ -295,14 +293,13 @@ OsInit(void)
      * log file name if logging to a file is desired.
      */
     LogInit(NULL, NULL);
-    SmartScheduleInit ();
+    SmartScheduleInit();
 }
 
 void
 OsCleanup(Bool terminating)
 {
-    if (terminating)
-    {
-	UnlockServer();
+    if (terminating) {
+        UnlockServer();
     }
 }