From aad2fba0fc475162b566f1577d8e7a020cd9e80d Mon Sep 17 00:00:00 2001 From: root Date: Sun, 20 May 2012 00:04:49 +0000 Subject: Sun May 20 00:04:49 UTC 2012 --- extra/xorg-server/PKGBUILD | 17 +- extra/xorg-server/git-fixes.patch | 1812 ++++++++++++++++++++++++++++++++++--- 2 files changed, 1693 insertions(+), 136 deletions(-) (limited to 'extra/xorg-server') diff --git a/extra/xorg-server/PKGBUILD b/extra/xorg-server/PKGBUILD index 0ab1942fa..27d16ef44 100644 --- a/extra/xorg-server/PKGBUILD +++ b/extra/xorg-server/PKGBUILD @@ -1,10 +1,10 @@ -# $Id: PKGBUILD 158860 2012-05-12 13:09:37Z andyrtr $ +# $Id: PKGBUILD 159237 2012-05-18 15:27:59Z andyrtr $ # Maintainer: Jan de Groot pkgbase=xorg-server pkgname=('xorg-server' 'xorg-server-xephyr' 'xorg-server-xdmx' 'xorg-server-xvfb' 'xorg-server-xnest' 'xorg-server-common' 'xorg-server-devel') -pkgver=1.12.1 -pkgrel=2 +pkgver=1.12.1.901 +pkgrel=3 arch=('i686' 'x86_64') license=('custom') url="http://xorg.freedesktop.org" @@ -17,14 +17,15 @@ source=(${url}/releases/individual/xserver/${pkgbase}-${pkgver}.tar.bz2 autoconfig-nvidia.patch autoconfig-sis.patch EXA_Fall_back_earlier_and_more_thoroughly_from_exaGlyphsV2.diff - #git-fixes.patch + git-fixes.patch xvfb-run xvfb-run.1 10-quirks.conf) -sha1sums=('922b963901f4711449b53fb32ce3e14f5b642766' +sha1sums=('bb9985bae271aa896de7fa12e49a0dbd8e244d2c' '63836e5cfb4ae7353fb2e31239a544409c7ead32' '175de5630b43dbc97778adfba5563b7fdd77f11f' '4acb39587f73bcbb9a331377d6ef99cb73eb95a8' + '526cbffbc742dc3449065e3501d290a607d80aa3' 'c94f742d3f9cabf958ae58e4015d9dd185aabedc' '6838fc00ef4618c924a77e0fb03c05346080908a' '993798f3d22ad672d769dae5f48d1fa068d5578f') @@ -41,10 +42,10 @@ build() { # fix glitches and crashes with EXA and cairo 1.12 # taken from https://bugs.freedesktop.org/show_bug.cgi?id=47266 # and reworked for 1.12.1 changes - patch -Np1 -i ${srcdir}/EXA_Fall_back_earlier_and_more_thoroughly_from_exaGlyphsV2.diff +# patch -Np1 -i ${srcdir}/EXA_Fall_back_earlier_and_more_thoroughly_from_exaGlyphsV2.diff - # Add post-release patches from 1.11 branch -# patch -Np1 -i "${srcdir}/git-fixes.patch" + # Add post-release patches from 1.12 branch + patch -Np1 -i ${srcdir}/git-fixes.patch autoreconf -fi ./configure --prefix=/usr \ diff --git a/extra/xorg-server/git-fixes.patch b/extra/xorg-server/git-fixes.patch index 27da61eca..f6ca2426b 100644 --- a/extra/xorg-server/git-fixes.patch +++ b/extra/xorg-server/git-fixes.patch @@ -1,161 +1,1717 @@ -From 89626304ea1ad316c5b7145a40f09377148cff21 Mon Sep 17 00:00:00 2001 -From: Dave Airlie -Date: Thu, 20 Oct 2011 13:43:01 +0000 -Subject: xf86Crtc: handle no outputs with no modes harder. +From b5bf0ac5405eab77f26bb2f8726644232af17178 Mon Sep 17 00:00:00 2001 +From: Keith Packard +Date: Wed, 11 Apr 2012 16:28:21 +0000 +Subject: hw/xfree86: Spurious ');' in xf86vmode.c messed up indentation badly -If you started an X server with no connected outputs, we pick a default -1024x768 mode, however if you then ran an xvidmode using app against that -server it would segfault the server due to not finding any valid modes. +Inside the unfinished XF86VIDMODE_EVENTS #ifdef block the +function definition for xf86VidModeNotifyEvent had an extra ');' +before the prototype argument declarations. This was harmless for the +compiler as the code never gets used, but completely messed up the +file re-indentation. This patch removes the spurious characters in +preparation for re-indenting the file. -This was due to the no output mode set code, only adding the modes to the -scrn->modes once, when something called randr 1.2 xf86SetScrnInfoModes would -get called and remove all the modes and we'd end up with 0. - -This change fixes xf86SetScrnInfoModes to always report a scrn mode of at -least 1024x768, and pushes the initial configuration to just call it instead -of setting up the mode itself. - -Fixes: https://bugzilla.redhat.com/show_bug.cgi?id=746926 +Signed-off-by: Keith Packard +(cherry picked from commit 592bd0ae2b60cd6f6afd3efc40f5f659b12900b4) +--- +diff --git a/hw/xfree86/dixmods/extmod/xf86vmode.c b/hw/xfree86/dixmods/extmod/xf86vmode.c +index 6e2a8e9..9f64f8e 100644 +--- a/hw/xfree86/dixmods/extmod/xf86vmode.c ++++ b/hw/xfree86/dixmods/extmod/xf86vmode.c +@@ -75,7 +75,7 @@ static unsigned char XF86VidModeReqCode = 0; + #ifdef XF86VIDMODE_EVENTS + static int XF86VidModeEventBase = 0; + +-static void SXF86VidModeNotifyEvent(); ++static void SXF86VidModeNotifyEvent( + xXF86VidModeNotifyEvent * /* from */ , xXF86VidModeNotifyEvent * /* to */ + ); + +-- +cgit v0.9.0.2-2-gbebe +From 3ad72a80088fe3236f38bd0696b04f399e24fe3d Mon Sep 17 00:00:00 2001 +From: Keith Packard +Date: Wed, 11 Apr 2012 16:33:54 +0000 +Subject: hw/xfree86: Re-indent xf86vmode.c -I've seen other bugs like this on other distros so it might also actually fix them. +This is the result of re-running the 'x-indent.sh' script over +xf86vmode.c to clean up the disaster caused by broken syntax in the +file. -Signed-off-by: Dave Airlie -Reviewed-by: Keith Packard Signed-off-by: Keith Packard -(cherry picked from commit 17416e88dcfcc584fe5f87580d5d2b719b3521c3) +(cherry picked from commit 9779b904c7c0b49c74054c22c420012c40595cdc) --- -diff --git a/hw/xfree86/modes/xf86Crtc.c b/hw/xfree86/modes/xf86Crtc.c -index d75cd77..8906806 100644 ---- a/hw/xfree86/modes/xf86Crtc.c -+++ b/hw/xfree86/modes/xf86Crtc.c -@@ -1915,19 +1915,25 @@ xf86SetScrnInfoModes (ScrnInfoPtr scrn) - break; +diff --git a/hw/xfree86/dixmods/extmod/xf86vmode.c b/hw/xfree86/dixmods/extmod/xf86vmode.c +index 9f64f8e..68c4b58 100644 +--- a/hw/xfree86/dixmods/extmod/xf86vmode.c ++++ b/hw/xfree86/dixmods/extmod/xf86vmode.c +@@ -75,8 +75,7 @@ static unsigned char XF86VidModeReqCode = 0; + #ifdef XF86VIDMODE_EVENTS + static int XF86VidModeEventBase = 0; + +-static void SXF86VidModeNotifyEvent( +-xXF86VidModeNotifyEvent * /* from */ , xXF86VidModeNotifyEvent * /* to */ ++static void SXF86VidModeNotifyEvent(xXF86VidModeNotifyEvent * /* from */ , xXF86VidModeNotifyEvent * /* to */ + ); + + static RESTYPE EventType; /* resource type for event masks */ +@@ -117,20 +116,22 @@ static DevPrivateKeyRec ScreenPrivateKeyRec; + #define DEBUG_P(x) /**/ + #endif + static int +- ClientMajorVersion(ClientPtr client) { ++ClientMajorVersion(ClientPtr client) ++{ + VidModePrivPtr pPriv; + +- pPriv = VM_GETPRIV(client); ++ pPriv = VM_GETPRIV(client); + if (!pPriv) +- return 0; ++ return 0; + else +- return pPriv->major; ++ return pPriv->major; + } ++ + #ifdef XF86VIDMODE_EVENTS + static void +- CheckScreenPrivate(pScreen) ++CheckScreenPrivate(pScreen) + ScreenPtr +- pScreen; ++ pScreen; + { + SetupScreen(pScreen); + +@@ -142,9 +143,10 @@ ScreenPtr + } + } + +-static XF86VidModeScreenPrivatePtr MakeScreenPrivate(pScreen) ++static XF86VidModeScreenPrivatePtr ++MakeScreenPrivate(pScreen) + ScreenPtr +- pScreen; ++ pScreen; + { + SetupScreen(pScreen); + +@@ -160,18 +162,22 @@ ScreenPtr + } + + static unsigned long +- getEventMask(ScreenPtr pScreen, ClientPtr client) { ++getEventMask(ScreenPtr pScreen, ClientPtr client) ++{ + SetupScreen(pScreen); + XF86VidModeEventPtr pEv; + + if (!pPriv) +- return 0; ++ return 0; + for (pEv = pPriv->events; pEv; pEv = pEv->next) + if (pEv->client == client) + return pEv->mask; +- return 0; +-} static Bool +- setEventMask(ScreenPtr pScreen, ClientPtr client, unsigned long mask) { ++ return 0; ++} ++ ++static Bool ++setEventMask(ScreenPtr pScreen, ClientPtr client, unsigned long mask) ++{ + SetupScreen(pScreen); + XF86VidModeEventPtr pEv, *pPrev; + +@@ -181,7 +187,8 @@ static unsigned long + pPriv = MakeScreenPrivate(pScreen); + if (!pPriv) + return FALSE; +- } for (pPrev = &pPriv->events; pEv = *pPrev; pPrev = &pEv->next) ++ } ++ for (pPrev = &pPriv->events; pEv = *pPrev; pPrev = &pEv->next) + if (pEv->client == client) + break; + if (mask == 0) { +@@ -208,38 +215,43 @@ static unsigned long + } + + static int +- XF86VidModeFreeEvents(pointer value, XID id) { ++XF86VidModeFreeEvents(pointer value, XID id) ++{ + XF86VidModeEventPtr pOld = (XF86VidModeEventPtr) value; + ScreenPtr pScreen = pOld->screen; +- SetupScreen(pScreen); ++ ++ SetupScreen(pScreen); + XF86VidModeEventPtr pEv, *pPrev; + + if (!pPriv) +- return TRUE; ++ return TRUE; + for (pPrev = &pPriv->events; pEv = *pPrev; pPrev = &pEv->next) + if (pEv == pOld) + break; + if (!pEv) +- return TRUE; ++ return TRUE; + *pPrev = pEv->next; +- free(pEv); +- CheckScreenPrivate(pScreen); +- return TRUE; +-} static void +- SendXF86VidModeNotify(ScreenPtr pScreen, int state, Bool forced) { ++ free(pEv); ++ CheckScreenPrivate(pScreen); ++ return TRUE; ++} ++ ++static void ++SendXF86VidModeNotify(ScreenPtr pScreen, int state, Bool forced) ++{ + XF86VidModeScreenPrivatePtr pPriv; + XF86VidModeEventPtr pEv; + unsigned long mask; + xXF86VidModeNotifyEvent ev; + int kind; + +- UpdateCurrentTimeIf(); +- mask = XF86VidModeNotifyMask; +- pScreen = screenInfo.screens[pScreen->myNum]; +- pPriv = GetScreenPrivate(pScreen); ++ UpdateCurrentTimeIf(); ++ mask = XF86VidModeNotifyMask; ++ pScreen = screenInfo.screens[pScreen->myNum]; ++ pPriv = GetScreenPrivate(pScreen); + if (!pPriv) +- return; +- kind = XF86VidModeModeChange; ++ return; ++ kind = XF86VidModeModeChange; + for (pEv = pPriv->events; pEv; pEv = pEv->next) { + if (!(pEv->mask & mask)) + continue; +@@ -251,8 +263,10 @@ static int + ev.forced = forced; + WriteEventsToClient(pEv->client, 1, (xEvent *) &ev); + }} static void +- SXF86VidModeNotifyEvent(xXF86VidModeNotifyEvent * from, +- xXF86VidModeNotifyEvent * to) { ++ ++SXF86VidModeNotifyEvent(xXF86VidModeNotifyEvent * from, ++ xXF86VidModeNotifyEvent * to) ++{ + to->type = from->type; + to->state = from->state; + cpswaps(from->sequenceNumber, to->sequenceNumber); +@@ -264,29 +278,31 @@ static int + #endif + + static int +- ProcXF86VidModeQueryVersion(ClientPtr client) { ++ProcXF86VidModeQueryVersion(ClientPtr client) ++{ + xXF86VidModeQueryVersionReply rep; + +- DEBUG_P("XF86VidModeQueryVersion"); ++ DEBUG_P("XF86VidModeQueryVersion"); + +- REQUEST_SIZE_MATCH(xXF86VidModeQueryVersionReq); +- rep.type = X_Reply; +- rep.length = 0; +- rep.sequenceNumber = client->sequence; +- rep.majorVersion = SERVER_XF86VIDMODE_MAJOR_VERSION; +- rep.minorVersion = SERVER_XF86VIDMODE_MINOR_VERSION; ++ REQUEST_SIZE_MATCH(xXF86VidModeQueryVersionReq); ++ rep.type = X_Reply; ++ rep.length = 0; ++ rep.sequenceNumber = client->sequence; ++ rep.majorVersion = SERVER_XF86VIDMODE_MAJOR_VERSION; ++ rep.minorVersion = SERVER_XF86VIDMODE_MINOR_VERSION; + if (client->swapped) { + swaps(&rep.sequenceNumber); + swapl(&rep.length); + swaps(&rep.majorVersion); + swaps(&rep.minorVersion); +- } WriteToClient(client, sizeof(xXF86VidModeQueryVersionReply), +- (char *) &rep); ++ } ++ WriteToClient(client, sizeof(xXF86VidModeQueryVersionReply), (char *) &rep); + return Success; + } + + static int +- ProcXF86VidModeGetModeLine(ClientPtr client) { ++ProcXF86VidModeGetModeLine(ClientPtr client) ++{ + REQUEST(xXF86VidModeGetModeLineReq); + xXF86VidModeGetModeLineReply rep; + xXF86OldVidModeGetModeLineReply oldrep; +@@ -294,11 +310,11 @@ static int + int dotClock; + int ver; + +- DEBUG_P("XF86VidModeGetModeline"); ++ DEBUG_P("XF86VidModeGetModeline"); + +- ver = ClientMajorVersion(client); +- REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq); +- rep.type = X_Reply; ++ ver = ClientMajorVersion(client); ++ REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq); ++ rep.type = X_Reply; + if (ver < 2) { + rep.length = bytes_to_int32(SIZEOF(xXF86OldVidModeGetModeLineReply) - + SIZEOF(xGenericReply)); +@@ -386,7 +402,8 @@ static int + } + + static int +- ProcXF86VidModeGetAllModeLines(ClientPtr client) { ++ProcXF86VidModeGetAllModeLines(ClientPtr client) ++{ + REQUEST(xXF86VidModeGetAllModeLinesReq); + xXF86VidModeGetAllModeLinesReply rep; + xXF86VidModeModeInfo mdinf; +@@ -395,38 +412,39 @@ static int + int modecount, dotClock; + int ver; + +- DEBUG_P("XF86VidModeGetAllModelines"); ++ DEBUG_P("XF86VidModeGetAllModelines"); + +- REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq); ++ REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq); + + if (stuff->screen >= screenInfo.numScreens) +- return BadValue; ++ return BadValue; + +- ver = ClientMajorVersion(client); ++ ver = ClientMajorVersion(client); + +- modecount = VidModeGetNumOfModes(stuff->screen); ++ modecount = VidModeGetNumOfModes(stuff->screen); + if (modecount < 1) +- return VidModeErrorBase + XF86VidModeExtensionDisabled; ++ return VidModeErrorBase + XF86VidModeExtensionDisabled; + + if (!VidModeGetFirstModeline(stuff->screen, &mode, &dotClock)) +- return BadValue; ++ return BadValue; + +- rep.type = X_Reply; +- rep.length = SIZEOF(xXF86VidModeGetAllModeLinesReply) - ++ rep.type = X_Reply; ++ rep.length = SIZEOF(xXF86VidModeGetAllModeLinesReply) - + SIZEOF(xGenericReply); + if (ver < 2) +- rep.length += modecount * sizeof(xXF86OldVidModeModeInfo); ++ rep.length += modecount * sizeof(xXF86OldVidModeModeInfo); + else +- rep.length += modecount * sizeof(xXF86VidModeModeInfo); +- rep.length >>= 2; +- rep.sequenceNumber = client->sequence; +- rep.modecount = modecount; ++ rep.length += modecount * sizeof(xXF86VidModeModeInfo); ++ rep.length >>= 2; ++ rep.sequenceNumber = client->sequence; ++ rep.modecount = modecount; + if (client->swapped) { + swaps(&rep.sequenceNumber); + swapl(&rep.length); + swapl(&rep.modecount); +- } WriteToClient(client, sizeof(xXF86VidModeGetAllModeLinesReply), +- (char *) &rep); ++ } ++ WriteToClient(client, sizeof(xXF86VidModeGetAllModeLinesReply), ++ (char *) &rep); + + do { + mdinf.dotclock = dotClock; +@@ -492,7 +510,8 @@ static int + && VidModeGetModeValue(mode, VIDMODE_FLAGS) == stuff->flags ) + + static int +- ProcXF86VidModeAddModeLine(ClientPtr client) { ++ProcXF86VidModeAddModeLine(ClientPtr client) ++{ + REQUEST(xXF86VidModeAddModeLineReq); + xXF86OldVidModeAddModeLineReq *oldstuff = + (xXF86OldVidModeAddModeLineReq *) client->requestBuffer; +@@ -502,9 +521,9 @@ static int + int dotClock; + int ver; + +- DEBUG_P("XF86VidModeAddModeline"); ++ DEBUG_P("XF86VidModeAddModeline"); + +- ver = ClientMajorVersion(client); ++ ver = ClientMajorVersion(client); + if (ver < 2) { + /* convert from old format */ + stuff = &newstuff; +@@ -533,7 +552,8 @@ static int + stuff->after_vsyncend = oldstuff->after_vsyncend; + stuff->after_vtotal = oldstuff->after_vtotal; + stuff->after_flags = oldstuff->after_flags; +- } if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) { ++ } ++ if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) { + ErrorF("AddModeLine - scrn: %d clock: %ld\n", + (int) stuff->screen, (unsigned long) stuff->dotclock); + ErrorF("AddModeLine - hdsp: %d hbeg: %d hend: %d httl: %d\n", +@@ -654,7 +674,8 @@ static int + } + + static int +- ProcXF86VidModeDeleteModeLine(ClientPtr client) { ++ProcXF86VidModeDeleteModeLine(ClientPtr client) ++{ + REQUEST(xXF86VidModeDeleteModeLineReq); + xXF86OldVidModeDeleteModeLineReq *oldstuff = + (xXF86OldVidModeDeleteModeLineReq *) client->requestBuffer; +@@ -663,9 +684,9 @@ static int + int len, dotClock; + int ver; + +- DEBUG_P("XF86VidModeDeleteModeline"); ++ DEBUG_P("XF86VidModeDeleteModeline"); + +- ver = ClientMajorVersion(client); ++ ver = ClientMajorVersion(client); + if (ver < 2) { + /* convert from old format */ + stuff = &newstuff; +@@ -683,7 +704,8 @@ static int + stuff->vtotal = oldstuff->vtotal; + stuff->flags = oldstuff->flags; + stuff->privsize = oldstuff->privsize; +- } if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) { ++ } ++ if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) { + ErrorF("DeleteModeLine - scrn: %d clock: %ld\n", + (int) stuff->screen, (unsigned long) stuff->dotclock); + ErrorF(" hdsp: %d hbeg: %d hend: %d httl: %d\n", +@@ -777,7 +799,8 @@ static int + } + + static int +- ProcXF86VidModeModModeLine(ClientPtr client) { ++ProcXF86VidModeModModeLine(ClientPtr client) ++{ + REQUEST(xXF86VidModeModModeLineReq); + xXF86OldVidModeModModeLineReq *oldstuff = + (xXF86OldVidModeModModeLineReq *) client->requestBuffer; +@@ -786,9 +809,9 @@ static int + int len, dotClock; + int ver; + +- DEBUG_P("XF86VidModeModModeline"); ++ DEBUG_P("XF86VidModeModModeline"); + +- ver = ClientMajorVersion(client); ++ ver = ClientMajorVersion(client); + if (ver < 2) { + /* convert from old format */ + stuff = &newstuff; +@@ -805,7 +828,8 @@ static int + stuff->vtotal = oldstuff->vtotal; + stuff->flags = oldstuff->flags; + stuff->privsize = oldstuff->privsize; +- } if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) { ++ } ++ if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) { + ErrorF("ModModeLine - scrn: %d hdsp: %d hbeg: %d hend: %d httl: %d\n", + (int) stuff->screen, stuff->hdisplay, stuff->hsyncstart, + stuff->hsyncend, stuff->htotal); +@@ -903,7 +927,8 @@ static int + } + + static int +- ProcXF86VidModeValidateModeLine(ClientPtr client) { ++ProcXF86VidModeValidateModeLine(ClientPtr client) ++{ + REQUEST(xXF86VidModeValidateModeLineReq); + xXF86OldVidModeValidateModeLineReq *oldstuff = + (xXF86OldVidModeValidateModeLineReq *) client->requestBuffer; +@@ -913,9 +938,9 @@ static int + int len, status, dotClock; + int ver; + +- DEBUG_P("XF86VidModeValidateModeline"); ++ DEBUG_P("XF86VidModeValidateModeline"); + +- ver = ClientMajorVersion(client); ++ ver = ClientMajorVersion(client); + if (ver < 2) { + /* convert from old format */ + stuff = &newstuff; +@@ -933,7 +958,8 @@ static int + stuff->vtotal = oldstuff->vtotal; + stuff->flags = oldstuff->flags; + stuff->privsize = oldstuff->privsize; +- } if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) { ++ } ++ if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) { + ErrorF("ValidateModeLine - scrn: %d clock: %ld\n", + (int) stuff->screen, (unsigned long) stuff->dotclock); + ErrorF(" hdsp: %d hbeg: %d hend: %d httl: %d\n", +@@ -1022,7 +1048,8 @@ static int + } + + static int +- ProcXF86VidModeSwitchMode(ClientPtr client) { ++ProcXF86VidModeSwitchMode(ClientPtr client) ++{ + REQUEST(xXF86VidModeSwitchModeReq); + + DEBUG_P("XF86VidModeSwitchMode"); +@@ -1035,8 +1062,11 @@ static int + VidModeZoomViewport(stuff->screen, (short) stuff->zoom); + + return Success; +-} static int +- ProcXF86VidModeSwitchToMode(ClientPtr client) { ++} ++ ++static int ++ProcXF86VidModeSwitchToMode(ClientPtr client) ++{ + REQUEST(xXF86VidModeSwitchToModeReq); + xXF86OldVidModeSwitchToModeReq *oldstuff = + (xXF86OldVidModeSwitchToModeReq *) client->requestBuffer; +@@ -1045,9 +1075,9 @@ static int + int len, dotClock; + int ver; + +- DEBUG_P("XF86VidModeSwitchToMode"); ++ DEBUG_P("XF86VidModeSwitchToMode"); + +- ver = ClientMajorVersion(client); ++ ver = ClientMajorVersion(client); + if (ver < 2) { + /* convert from old format */ + stuff = &newstuff; +@@ -1065,7 +1095,8 @@ static int + stuff->vtotal = oldstuff->vtotal; + stuff->flags = oldstuff->flags; + stuff->privsize = oldstuff->privsize; +- } if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) { ++ } ++ if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) { + ErrorF("SwitchToMode - scrn: %d clock: %ld\n", + (int) stuff->screen, (unsigned long) stuff->dotclock); + ErrorF(" hdsp: %d hbeg: %d hend: %d httl: %d\n", +@@ -1138,7 +1169,8 @@ static int + } + + static int +- ProcXF86VidModeLockModeSwitch(ClientPtr client) { ++ProcXF86VidModeLockModeSwitch(ClientPtr client) ++{ + REQUEST(xXF86VidModeLockModeSwitchReq); + + REQUEST_SIZE_MATCH(xXF86VidModeLockModeSwitchReq); +@@ -1152,53 +1184,57 @@ static int + return VidModeErrorBase + XF86VidModeZoomLocked; + + return Success; +-} static int +- ProcXF86VidModeGetMonitor(ClientPtr client) { ++} ++ ++static int ++ProcXF86VidModeGetMonitor(ClientPtr client) ++{ + REQUEST(xXF86VidModeGetMonitorReq); + xXF86VidModeGetMonitorReply rep; + CARD32 *hsyncdata, *vsyncdata; + int i, nHsync, nVrefresh; + pointer monitor; + +- DEBUG_P("XF86VidModeGetMonitor"); ++ DEBUG_P("XF86VidModeGetMonitor"); + +- REQUEST_SIZE_MATCH(xXF86VidModeGetMonitorReq); ++ REQUEST_SIZE_MATCH(xXF86VidModeGetMonitorReq); + + if (stuff->screen >= screenInfo.numScreens) +- return BadValue; ++ return BadValue; + + if (!VidModeGetMonitor(stuff->screen, &monitor)) +- return BadValue; ++ return BadValue; + +- nHsync = VidModeGetMonitorValue(monitor, VIDMODE_MON_NHSYNC, 0).i; +- nVrefresh = VidModeGetMonitorValue(monitor, VIDMODE_MON_NVREFRESH, 0).i; ++ nHsync = VidModeGetMonitorValue(monitor, VIDMODE_MON_NHSYNC, 0).i; ++ nVrefresh = VidModeGetMonitorValue(monitor, VIDMODE_MON_NVREFRESH, 0).i; + +- rep.type = X_Reply; ++ rep.type = X_Reply; + if ((char *) (VidModeGetMonitorValue(monitor, VIDMODE_MON_VENDOR, 0)).ptr) +- rep.vendorLength = strlen((char *) (VidModeGetMonitorValue(monitor, +- VIDMODE_MON_VENDOR, +- 0)).ptr); ++ rep.vendorLength = strlen((char *) (VidModeGetMonitorValue(monitor, ++ VIDMODE_MON_VENDOR, ++ 0)).ptr); + else +- rep.vendorLength = 0; ++ rep.vendorLength = 0; + if ((char *) (VidModeGetMonitorValue(monitor, VIDMODE_MON_MODEL, 0)).ptr) +- rep.modelLength = strlen((char *) (VidModeGetMonitorValue(monitor, +- VIDMODE_MON_MODEL, +- 0)).ptr); ++ rep.modelLength = strlen((char *) (VidModeGetMonitorValue(monitor, ++ VIDMODE_MON_MODEL, ++ 0)).ptr); + else +- rep.modelLength = 0; +- rep.length = ++ rep.modelLength = 0; ++ rep.length = + bytes_to_int32(SIZEOF(xXF86VidModeGetMonitorReply) - + SIZEOF(xGenericReply) + (nHsync + + nVrefresh) * sizeof(CARD32) + + pad_to_int32(rep.vendorLength) + + pad_to_int32(rep.modelLength)); +- rep.sequenceNumber = client->sequence; +- rep.nhsync = nHsync; +- rep.nvsync = nVrefresh; +- hsyncdata = malloc(nHsync * sizeof(CARD32)); ++ rep.sequenceNumber = client->sequence; ++ rep.nhsync = nHsync; ++ rep.nvsync = nVrefresh; ++ hsyncdata = malloc(nHsync * sizeof(CARD32)); + if (!hsyncdata) { + return BadAlloc; +- } vsyncdata = malloc(nVrefresh * sizeof(CARD32)); ++ } ++ vsyncdata = malloc(nVrefresh * sizeof(CARD32)); + + if (!vsyncdata) { + free(hsyncdata); +@@ -1208,19 +1244,18 @@ static int + for (i = 0; i < nHsync; i++) { + hsyncdata[i] = (unsigned short) (VidModeGetMonitorValue(monitor, + VIDMODE_MON_HSYNC_LO, +- i)). +- f | (unsigned +- short) (VidModeGetMonitorValue(monitor, VIDMODE_MON_HSYNC_HI, +- i)).f << 16; ++ i)).f | ++ (unsigned ++ short) (VidModeGetMonitorValue(monitor, VIDMODE_MON_HSYNC_HI, ++ i)).f << 16; + } + for (i = 0; i < nVrefresh; i++) { + vsyncdata[i] = (unsigned short) (VidModeGetMonitorValue(monitor, + VIDMODE_MON_VREFRESH_LO, +- i)). +- f | (unsigned +- short) (VidModeGetMonitorValue(monitor, +- VIDMODE_MON_VREFRESH_HI, +- i)).f << 16; ++ i)).f | ++ (unsigned ++ short) (VidModeGetMonitorValue(monitor, VIDMODE_MON_VREFRESH_HI, ++ i)).f << 16; + } + + if (client->swapped) { +@@ -1249,38 +1284,40 @@ static int + } + + static int +- ProcXF86VidModeGetViewPort(ClientPtr client) { ++ProcXF86VidModeGetViewPort(ClientPtr client) ++{ + REQUEST(xXF86VidModeGetViewPortReq); + xXF86VidModeGetViewPortReply rep; + int x, y; + +- DEBUG_P("XF86VidModeGetViewPort"); ++ DEBUG_P("XF86VidModeGetViewPort"); + +- REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq); ++ REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq); + + if (stuff->screen >= screenInfo.numScreens) +- return BadValue; ++ return BadValue; + +- rep.type = X_Reply; +- rep.length = 0; +- rep.sequenceNumber = client->sequence; ++ rep.type = X_Reply; ++ rep.length = 0; ++ rep.sequenceNumber = client->sequence; + +- VidModeGetViewPort(stuff->screen, &x, &y); +- rep.x = x; +- rep.y = y; ++ VidModeGetViewPort(stuff->screen, &x, &y); ++ rep.x = x; ++ rep.y = y; + + if (client->swapped) { + swaps(&rep.sequenceNumber); + swapl(&rep.length); + swapl(&rep.x); + swapl(&rep.y); +- } WriteToClient(client, SIZEOF(xXF86VidModeGetViewPortReply), +- (char *) &rep); ++ } ++ WriteToClient(client, SIZEOF(xXF86VidModeGetViewPortReply), (char *) &rep); + return Success; + } + + static int +- ProcXF86VidModeSetViewPort(ClientPtr client) { ++ProcXF86VidModeSetViewPort(ClientPtr client) ++{ + REQUEST(xXF86VidModeSetViewPortReq); + + DEBUG_P("XF86VidModeSetViewPort"); +@@ -1294,8 +1331,11 @@ static int + return BadValue; + + return Success; +-} static int +- ProcXF86VidModeGetDotClocks(ClientPtr client) { ++} ++ ++static int ++ProcXF86VidModeGetDotClocks(ClientPtr client) ++{ + REQUEST(xXF86VidModeGetDotClocksReq); + xXF86VidModeGetDotClocksReply rep; + int n; +@@ -1304,31 +1344,33 @@ static int + int *Clocks = NULL; + Bool ClockProg; + +- DEBUG_P("XF86VidModeGetDotClocks"); ++ DEBUG_P("XF86VidModeGetDotClocks"); + +- REQUEST_SIZE_MATCH(xXF86VidModeGetDotClocksReq); ++ REQUEST_SIZE_MATCH(xXF86VidModeGetDotClocksReq); + + if (stuff->screen >= screenInfo.numScreens) +- return BadValue; ++ return BadValue; + +- numClocks = VidModeGetNumOfClocks(stuff->screen, &ClockProg); ++ numClocks = VidModeGetNumOfClocks(stuff->screen, &ClockProg); + +- rep.type = X_Reply; +- rep.length = bytes_to_int32(SIZEOF(xXF86VidModeGetDotClocksReply) +- - SIZEOF(xGenericReply) + numClocks); +- rep.sequenceNumber = client->sequence; +- rep.clocks = numClocks; +- rep.maxclocks = MAXCLOCKS; +- rep.flags = 0; ++ rep.type = X_Reply; ++ rep.length = bytes_to_int32(SIZEOF(xXF86VidModeGetDotClocksReply) ++ - SIZEOF(xGenericReply) + numClocks); ++ rep.sequenceNumber = client->sequence; ++ rep.clocks = numClocks; ++ rep.maxclocks = MAXCLOCKS; ++ rep.flags = 0; + + if (!ClockProg) { + Clocks = malloc(numClocks * sizeof(int)); + if (!Clocks) +- return BadValue; ++ return BadValue; + if (!VidModeGetClocks(stuff->screen, Clocks)) { + free(Clocks); + return BadValue; +- }} if (ClockProg) { ++ } ++ } ++ if (ClockProg) { + rep.flags |= CLKFLAG_PROGRAMABLE; } + if (client->swapped) { +@@ -1356,7 +1398,8 @@ static int + } + + static int +- ProcXF86VidModeSetGamma(ClientPtr client) { ++ProcXF86VidModeSetGamma(ClientPtr client) ++{ + REQUEST(xXF86VidModeSetGammaReq); + + DEBUG_P("XF86VidModeSetGamma"); +@@ -1372,79 +1415,89 @@ static int + return BadValue; + + return Success; +-} static int +- ProcXF86VidModeGetGamma(ClientPtr client) { ++} ++ ++static int ++ProcXF86VidModeGetGamma(ClientPtr client) ++{ + REQUEST(xXF86VidModeGetGammaReq); + xXF86VidModeGetGammaReply rep; + float red, green, blue; + +- DEBUG_P("XF86VidModeGetGamma"); ++ DEBUG_P("XF86VidModeGetGamma"); + +- REQUEST_SIZE_MATCH(xXF86VidModeGetGammaReq); ++ REQUEST_SIZE_MATCH(xXF86VidModeGetGammaReq); + + if (stuff->screen >= screenInfo.numScreens) +- return BadValue; ++ return BadValue; + +- rep.type = X_Reply; +- rep.length = 0; +- rep.sequenceNumber = client->sequence; ++ rep.type = X_Reply; ++ rep.length = 0; ++ rep.sequenceNumber = client->sequence; + if (!VidModeGetGamma(stuff->screen, &red, &green, &blue)) +- return BadValue; +- rep.red = (CARD32) (red * 10000.); +- rep.green = (CARD32) (green * 10000.); +- rep.blue = (CARD32) (blue * 10000.); ++ return BadValue; ++ rep.red = (CARD32) (red * 10000.); ++ rep.green = (CARD32) (green * 10000.); ++ rep.blue = (CARD32) (blue * 10000.); + if (client->swapped) { + swaps(&rep.sequenceNumber); + swapl(&rep.length); + swapl(&rep.red); + swapl(&rep.green); + swapl(&rep.blue); +- } WriteToClient(client, sizeof(xXF86VidModeGetGammaReply), (char *) &rep); ++ } ++ WriteToClient(client, sizeof(xXF86VidModeGetGammaReply), (char *) &rep); + + return Success; + } + + static int +- ProcXF86VidModeSetGammaRamp(ClientPtr client) { ++ProcXF86VidModeSetGammaRamp(ClientPtr client) ++{ + CARD16 *r, *g, *b; + int length; +- REQUEST(xXF86VidModeSetGammaRampReq); ++ ++ REQUEST(xXF86VidModeSetGammaRampReq); + + if (stuff->screen >= screenInfo.numScreens) +- return BadValue; ++ return BadValue; + + if (stuff->size != VidModeGetGammaRampSize(stuff->screen)) +- return BadValue; ++ return BadValue; + +- length = (stuff->size + 1) & ~1; ++ length = (stuff->size + 1) & ~1; + +- REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length * 6); ++ REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length * 6); + +- r = (CARD16 *) &stuff[1]; +- g = r + length; +- b = g + length; ++ r = (CARD16 *) &stuff[1]; ++ g = r + length; ++ b = g + length; + + if (!VidModeSetGammaRamp(stuff->screen, stuff->size, r, g, b)) +- return BadValue; ++ return BadValue; + +- return Success; +-} static int +- ProcXF86VidModeGetGammaRamp(ClientPtr client) { ++ return Success; ++} ++ ++static int ++ProcXF86VidModeGetGammaRamp(ClientPtr client) ++{ + CARD16 *ramp = NULL; + int length; + size_t ramplen = 0; + xXF86VidModeGetGammaRampReply rep; +- REQUEST(xXF86VidModeGetGammaRampReq); ++ ++ REQUEST(xXF86VidModeGetGammaRampReq); + + if (stuff->screen >= screenInfo.numScreens) +- return BadValue; ++ return BadValue; + + if (stuff->size != VidModeGetGammaRampSize(stuff->screen)) +- return BadValue; ++ return BadValue; + +- REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq); ++ REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq); + +- length = (stuff->size + 1) & ~1; ++ length = (stuff->size + 1) & ~1; + + if (stuff->size) { + ramplen = length * 3 * sizeof(CARD16); +@@ -1455,7 +1508,9 @@ static int + ramp, ramp + length, ramp + (length * 2))) { + free(ramp); + return BadValue; +- }} rep.type = X_Reply; ++ } ++ } ++ rep.type = X_Reply; + rep.length = (length >> 1) * 3; + rep.sequenceNumber = client->sequence; + rep.size = stuff->size; +@@ -1476,47 +1531,53 @@ static int + } + + static int +- ProcXF86VidModeGetGammaRampSize(ClientPtr client) { ++ProcXF86VidModeGetGammaRampSize(ClientPtr client) ++{ + xXF86VidModeGetGammaRampSizeReply rep; +- REQUEST(xXF86VidModeGetGammaRampSizeReq); ++ ++ REQUEST(xXF86VidModeGetGammaRampSizeReq); + + if (stuff->screen >= screenInfo.numScreens) +- return BadValue; ++ return BadValue; + +- REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq); ++ REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq); -- if (scrn->modes != NULL) { -- /* For some reason, scrn->modes is circular, unlike the other mode -- * lists. How great is that? -- */ -- for (last = scrn->modes; last && last->next; last = last->next) -- ; -- last->next = scrn->modes; -- scrn->modes->prev = last; -- if (mode) { -- while (scrn->modes != mode) -- scrn->modes = scrn->modes->next; -- } -+ if (!scrn->modes) { -+ scrn->modes = xf86ModesAdd(scrn->modes, -+ xf86CVTMode(scrn->display->virtualX, -+ scrn->display->virtualY, -+ 60, 0, 0)); -+ } -+ -+ /* For some reason, scrn->modes is circular, unlike the other mode -+ * lists. How great is that? -+ */ -+ for (last = scrn->modes; last && last->next; last = last->next) -+ ; -+ last->next = scrn->modes; -+ scrn->modes->prev = last; -+ if (mode) { -+ while (scrn->modes != mode) -+ scrn->modes = scrn->modes->next; +- rep.type = X_Reply; +- rep.length = 0; +- rep.sequenceNumber = client->sequence; +- rep.size = VidModeGetGammaRampSize(stuff->screen); ++ rep.type = X_Reply; ++ rep.length = 0; ++ rep.sequenceNumber = client->sequence; ++ rep.size = VidModeGetGammaRampSize(stuff->screen); + if (client->swapped) { + swaps(&rep.sequenceNumber); + swapl(&rep.length); + swaps(&rep.size); +- } WriteToClient(client, sizeof(xXF86VidModeGetGammaRampSizeReply), +- (char *) &rep); ++ } ++ WriteToClient(client, sizeof(xXF86VidModeGetGammaRampSizeReply), ++ (char *) &rep); + + return Success; + } + + static int +- ProcXF86VidModeGetPermissions(ClientPtr client) { ++ProcXF86VidModeGetPermissions(ClientPtr client) ++{ + xXF86VidModeGetPermissionsReply rep; +- REQUEST(xXF86VidModeGetPermissionsReq); ++ ++ REQUEST(xXF86VidModeGetPermissionsReq); + + if (stuff->screen >= screenInfo.numScreens) +- return BadValue; ++ return BadValue; + +- REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq); ++ REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq); + +- rep.type = X_Reply; +- rep.length = 0; +- rep.sequenceNumber = client->sequence; +- rep.permissions = XF86VM_READ_PERMISSION; ++ rep.type = X_Reply; ++ rep.length = 0; ++ rep.sequenceNumber = client->sequence; ++ rep.permissions = XF86VM_READ_PERMISSION; + if (xf86GetVidModeEnabled() && + (xf86GetVidModeAllowNonLocal() || LocalClient(client))) { + rep.permissions |= XF86VM_WRITE_PERMISSION; +- } if (client->swapped) { ++ } ++ if (client->swapped) { + swaps(&rep.sequenceNumber); + swapl(&rep.length); + swapl(&rep.permissions); +@@ -1528,21 +1589,23 @@ static int + } + + static int +- ProcXF86VidModeSetClientVersion(ClientPtr client) { ++ProcXF86VidModeSetClientVersion(ClientPtr client) ++{ + REQUEST(xXF86VidModeSetClientVersionReq); + + VidModePrivPtr pPriv; + +- DEBUG_P("XF86VidModeSetClientVersion"); ++ DEBUG_P("XF86VidModeSetClientVersion"); + +- REQUEST_SIZE_MATCH(xXF86VidModeSetClientVersionReq); ++ REQUEST_SIZE_MATCH(xXF86VidModeSetClientVersionReq); + + if ((pPriv = VM_GETPRIV(client)) == NULL) { + pPriv = malloc(sizeof(VidModePrivRec)); + if (!pPriv) + return BadAlloc; + VM_SETPRIV(client, pPriv); +- } pPriv->major = stuff->major; ++ } ++ pPriv->major = stuff->major; + + pPriv->minor = stuff->minor; + +@@ -1550,85 +1613,103 @@ static int + } + + static int +- ProcXF86VidModeDispatch(ClientPtr client) { ++ProcXF86VidModeDispatch(ClientPtr client) ++{ + REQUEST(xReq); + switch (stuff->data) { + case X_XF86VidModeQueryVersion: + return ProcXF86VidModeQueryVersion(client); +- case X_XF86VidModeGetModeLine:return ProcXF86VidModeGetModeLine(client); +- case X_XF86VidModeGetMonitor:return ProcXF86VidModeGetMonitor(client); +- case X_XF86VidModeGetAllModeLines:return +- ProcXF86VidModeGetAllModeLines(client); +- case X_XF86VidModeValidateModeLine:return +- ProcXF86VidModeValidateModeLine(client); +- case X_XF86VidModeGetViewPort:return ProcXF86VidModeGetViewPort(client); +- case X_XF86VidModeGetDotClocks:return +- ProcXF86VidModeGetDotClocks(client); +- case X_XF86VidModeSetClientVersion:return +- ProcXF86VidModeSetClientVersion(client); +- case X_XF86VidModeGetGamma:return ProcXF86VidModeGetGamma(client); +- case X_XF86VidModeGetGammaRamp:return +- ProcXF86VidModeGetGammaRamp(client); +- case X_XF86VidModeGetGammaRampSize:return +- ProcXF86VidModeGetGammaRampSize(client); +- case X_XF86VidModeGetPermissions:return +- ProcXF86VidModeGetPermissions(client); +- default:if (!xf86GetVidModeEnabled()) ++ case X_XF86VidModeGetModeLine: ++ return ProcXF86VidModeGetModeLine(client); ++ case X_XF86VidModeGetMonitor: ++ return ProcXF86VidModeGetMonitor(client); ++ case X_XF86VidModeGetAllModeLines: ++ return ProcXF86VidModeGetAllModeLines(client); ++ case X_XF86VidModeValidateModeLine: ++ return ProcXF86VidModeValidateModeLine(client); ++ case X_XF86VidModeGetViewPort: ++ return ProcXF86VidModeGetViewPort(client); ++ case X_XF86VidModeGetDotClocks: ++ return ProcXF86VidModeGetDotClocks(client); ++ case X_XF86VidModeSetClientVersion: ++ return ProcXF86VidModeSetClientVersion(client); ++ case X_XF86VidModeGetGamma: ++ return ProcXF86VidModeGetGamma(client); ++ case X_XF86VidModeGetGammaRamp: ++ return ProcXF86VidModeGetGammaRamp(client); ++ case X_XF86VidModeGetGammaRampSize: ++ return ProcXF86VidModeGetGammaRampSize(client); ++ case X_XF86VidModeGetPermissions: ++ return ProcXF86VidModeGetPermissions(client); ++ default: ++ if (!xf86GetVidModeEnabled()) + return VidModeErrorBase + XF86VidModeExtensionDisabled; + if (xf86GetVidModeAllowNonLocal() || LocalClient(client)) { + switch (stuff->data) { + case X_XF86VidModeAddModeLine: + return ProcXF86VidModeAddModeLine(client); +- case X_XF86VidModeDeleteModeLine:return +- ProcXF86VidModeDeleteModeLine(client); +- case X_XF86VidModeModModeLine:return +- ProcXF86VidModeModModeLine(client); +- case X_XF86VidModeSwitchMode:return +- ProcXF86VidModeSwitchMode(client); +- case X_XF86VidModeSwitchToMode:return +- ProcXF86VidModeSwitchToMode(client); +- case X_XF86VidModeLockModeSwitch:return +- ProcXF86VidModeLockModeSwitch(client); +- case X_XF86VidModeSetViewPort:return +- ProcXF86VidModeSetViewPort(client); +- case X_XF86VidModeSetGamma:return +- ProcXF86VidModeSetGamma(client); +- case X_XF86VidModeSetGammaRamp:return +- ProcXF86VidModeSetGammaRamp(client); +- default:return BadRequest; +- }} ++ case X_XF86VidModeDeleteModeLine: ++ return ProcXF86VidModeDeleteModeLine(client); ++ case X_XF86VidModeModModeLine: ++ return ProcXF86VidModeModModeLine(client); ++ case X_XF86VidModeSwitchMode: ++ return ProcXF86VidModeSwitchMode(client); ++ case X_XF86VidModeSwitchToMode: ++ return ProcXF86VidModeSwitchToMode(client); ++ case X_XF86VidModeLockModeSwitch: ++ return ProcXF86VidModeLockModeSwitch(client); ++ case X_XF86VidModeSetViewPort: ++ return ProcXF86VidModeSetViewPort(client); ++ case X_XF86VidModeSetGamma: ++ return ProcXF86VidModeSetGamma(client); ++ case X_XF86VidModeSetGammaRamp: ++ return ProcXF86VidModeSetGammaRamp(client); ++ default: ++ return BadRequest; ++ } ++ } + else +- return VidModeErrorBase + XF86VidModeClientNotLocal; ++ return VidModeErrorBase + XF86VidModeClientNotLocal; } + } + + static int +- SProcXF86VidModeQueryVersion(ClientPtr client) { ++SProcXF86VidModeQueryVersion(ClientPtr client) ++{ + REQUEST(xXF86VidModeQueryVersionReq); + swaps(&stuff->length); + return ProcXF86VidModeQueryVersion(client); +-} static int +- SProcXF86VidModeGetModeLine(ClientPtr client) { ++} ++ ++static int ++SProcXF86VidModeGetModeLine(ClientPtr client) ++{ + REQUEST(xXF86VidModeGetModeLineReq); + swaps(&stuff->length); + REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq); + swaps(&stuff->screen); + return ProcXF86VidModeGetModeLine(client); +-} static int +- SProcXF86VidModeGetAllModeLines(ClientPtr client) { ++} ++ ++static int ++SProcXF86VidModeGetAllModeLines(ClientPtr client) ++{ + REQUEST(xXF86VidModeGetAllModeLinesReq); + swaps(&stuff->length); + REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq); + swaps(&stuff->screen); + return ProcXF86VidModeGetAllModeLines(client); +-} static int +- SProcXF86VidModeAddModeLine(ClientPtr client) { ++} ++ ++static int ++SProcXF86VidModeAddModeLine(ClientPtr client) ++{ + xXF86OldVidModeAddModeLineReq *oldstuff = + (xXF86OldVidModeAddModeLineReq *) client->requestBuffer; + int ver; + +- REQUEST(xXF86VidModeAddModeLineReq); +- ver = ClientMajorVersion(client); ++ REQUEST(xXF86VidModeAddModeLineReq); ++ ver = ClientMajorVersion(client); + if (ver < 2) { + swaps(&oldstuff->length); + REQUEST_AT_LEAST_SIZE(xXF86OldVidModeAddModeLineReq); +@@ -1666,13 +1747,14 @@ static int + } + + static int +- SProcXF86VidModeDeleteModeLine(ClientPtr client) { ++SProcXF86VidModeDeleteModeLine(ClientPtr client) ++{ + xXF86OldVidModeDeleteModeLineReq *oldstuff = + (xXF86OldVidModeDeleteModeLineReq *) client->requestBuffer; + int ver; + +- REQUEST(xXF86VidModeDeleteModeLineReq); +- ver = ClientMajorVersion(client); ++ REQUEST(xXF86VidModeDeleteModeLineReq); ++ ver = ClientMajorVersion(client); + if (ver < 2) { + swaps(&oldstuff->length); + REQUEST_AT_LEAST_SIZE(xXF86OldVidModeDeleteModeLineReq); +@@ -1710,13 +1792,14 @@ static int + } + + static int +- SProcXF86VidModeModModeLine(ClientPtr client) { ++SProcXF86VidModeModModeLine(ClientPtr client) ++{ + xXF86OldVidModeModModeLineReq *oldstuff = + (xXF86OldVidModeModModeLineReq *) client->requestBuffer; + int ver; + +- REQUEST(xXF86VidModeModModeLineReq); +- ver = ClientMajorVersion(client); ++ REQUEST(xXF86VidModeModModeLineReq); ++ ver = ClientMajorVersion(client); + if (ver < 2) { + swaps(&oldstuff->length); + REQUEST_AT_LEAST_SIZE(xXF86OldVidModeModModeLineReq); +@@ -1754,13 +1837,14 @@ static int + } + + static int +- SProcXF86VidModeValidateModeLine(ClientPtr client) { ++SProcXF86VidModeValidateModeLine(ClientPtr client) ++{ + xXF86OldVidModeValidateModeLineReq *oldstuff = + (xXF86OldVidModeValidateModeLineReq *) client->requestBuffer; + int ver; + +- REQUEST(xXF86VidModeValidateModeLineReq); +- ver = ClientMajorVersion(client); ++ REQUEST(xXF86VidModeValidateModeLineReq); ++ ver = ClientMajorVersion(client); + if (ver < 2) { + swaps(&oldstuff->length); + REQUEST_AT_LEAST_SIZE(xXF86OldVidModeValidateModeLineReq); +@@ -1798,44 +1882,60 @@ static int + } + + static int +- SProcXF86VidModeSwitchMode(ClientPtr client) { ++SProcXF86VidModeSwitchMode(ClientPtr client) ++{ + REQUEST(xXF86VidModeSwitchModeReq); + swaps(&stuff->length); + REQUEST_SIZE_MATCH(xXF86VidModeSwitchModeReq); + swaps(&stuff->screen); + swaps(&stuff->zoom); + return ProcXF86VidModeSwitchMode(client); +-} static int +- SProcXF86VidModeSwitchToMode(ClientPtr client) { ++} ++ ++static int ++SProcXF86VidModeSwitchToMode(ClientPtr client) ++{ + REQUEST(xXF86VidModeSwitchToModeReq); + swaps(&stuff->length); + REQUEST_SIZE_MATCH(xXF86VidModeSwitchToModeReq); + swapl(&stuff->screen); + return ProcXF86VidModeSwitchToMode(client); +-} static int +- SProcXF86VidModeLockModeSwitch(ClientPtr client) { ++} ++ ++static int ++SProcXF86VidModeLockModeSwitch(ClientPtr client) ++{ + REQUEST(xXF86VidModeLockModeSwitchReq); + swaps(&stuff->length); + REQUEST_SIZE_MATCH(xXF86VidModeLockModeSwitchReq); + swaps(&stuff->screen); + swaps(&stuff->lock); + return ProcXF86VidModeLockModeSwitch(client); +-} static int +- SProcXF86VidModeGetMonitor(ClientPtr client) { ++} ++ ++static int ++SProcXF86VidModeGetMonitor(ClientPtr client) ++{ + REQUEST(xXF86VidModeGetMonitorReq); + swaps(&stuff->length); + REQUEST_SIZE_MATCH(xXF86VidModeGetMonitorReq); + swaps(&stuff->screen); + return ProcXF86VidModeGetMonitor(client); +-} static int +- SProcXF86VidModeGetViewPort(ClientPtr client) { ++} ++ ++static int ++SProcXF86VidModeGetViewPort(ClientPtr client) ++{ + REQUEST(xXF86VidModeGetViewPortReq); + swaps(&stuff->length); + REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq); + swaps(&stuff->screen); + return ProcXF86VidModeGetViewPort(client); +-} static int +- SProcXF86VidModeSetViewPort(ClientPtr client) { ++} ++ ++static int ++SProcXF86VidModeSetViewPort(ClientPtr client) ++{ + REQUEST(xXF86VidModeSetViewPortReq); + swaps(&stuff->length); + REQUEST_SIZE_MATCH(xXF86VidModeSetViewPortReq); +@@ -1843,23 +1943,32 @@ static int + swapl(&stuff->x); + swapl(&stuff->y); + return ProcXF86VidModeSetViewPort(client); +-} static int +- SProcXF86VidModeGetDotClocks(ClientPtr client) { ++} ++ ++static int ++SProcXF86VidModeGetDotClocks(ClientPtr client) ++{ + REQUEST(xXF86VidModeGetDotClocksReq); + swaps(&stuff->length); + REQUEST_SIZE_MATCH(xXF86VidModeGetDotClocksReq); + swaps(&stuff->screen); + return ProcXF86VidModeGetDotClocks(client); +-} static int +- SProcXF86VidModeSetClientVersion(ClientPtr client) { ++} ++ ++static int ++SProcXF86VidModeSetClientVersion(ClientPtr client) ++{ + REQUEST(xXF86VidModeSetClientVersionReq); + swaps(&stuff->length); + REQUEST_SIZE_MATCH(xXF86VidModeSetClientVersionReq); + swaps(&stuff->major); + swaps(&stuff->minor); + return ProcXF86VidModeSetClientVersion(client); +-} static int +- SProcXF86VidModeSetGamma(ClientPtr client) { ++} + - scrn->currentMode = scrn->modes; - #ifdef XFreeXDGA - if (scrn->pScreen) -@@ -2529,16 +2535,7 @@ xf86InitialConfiguration (ScrnInfoPtr scrn, Bool canGrow) - width, height); ++static int ++SProcXF86VidModeSetGamma(ClientPtr client) ++{ + REQUEST(xXF86VidModeSetGammaReq); + swaps(&stuff->length); + REQUEST_SIZE_MATCH(xXF86VidModeSetGammaReq); +@@ -1868,120 +1977,145 @@ static int + swapl(&stuff->green); + swapl(&stuff->blue); + return ProcXF86VidModeSetGamma(client); +-} static int +- SProcXF86VidModeGetGamma(ClientPtr client) { ++} ++ ++static int ++SProcXF86VidModeGetGamma(ClientPtr client) ++{ + REQUEST(xXF86VidModeGetGammaReq); + swaps(&stuff->length); + REQUEST_SIZE_MATCH(xXF86VidModeGetGammaReq); + swaps(&stuff->screen); + return ProcXF86VidModeGetGamma(client); +-} static int +- SProcXF86VidModeSetGammaRamp(ClientPtr client) { ++} ++ ++static int ++SProcXF86VidModeSetGammaRamp(ClientPtr client) ++{ + int length; +- REQUEST(xXF86VidModeSetGammaRampReq); +- swaps(&stuff->length); +- REQUEST_AT_LEAST_SIZE(xXF86VidModeSetGammaRampReq); +- swaps(&stuff->size); +- swaps(&stuff->screen); +- length = ((stuff->size + 1) & ~1) * 6; +- REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length); +- SwapRestS(stuff); +- return ProcXF86VidModeSetGammaRamp(client); +-} static int +- SProcXF86VidModeGetGammaRamp(ClientPtr client) { ++ ++ REQUEST(xXF86VidModeSetGammaRampReq); ++ swaps(&stuff->length); ++ REQUEST_AT_LEAST_SIZE(xXF86VidModeSetGammaRampReq); ++ swaps(&stuff->size); ++ swaps(&stuff->screen); ++ length = ((stuff->size + 1) & ~1) * 6; ++ REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length); ++ SwapRestS(stuff); ++ return ProcXF86VidModeSetGammaRamp(client); ++} ++ ++static int ++SProcXF86VidModeGetGammaRamp(ClientPtr client) ++{ + REQUEST(xXF86VidModeGetGammaRampReq); + swaps(&stuff->length); + REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq); + swaps(&stuff->size); + swaps(&stuff->screen); + return ProcXF86VidModeGetGammaRamp(client); +-} static int +- SProcXF86VidModeGetGammaRampSize(ClientPtr client) { ++} ++ ++static int ++SProcXF86VidModeGetGammaRampSize(ClientPtr client) ++{ + REQUEST(xXF86VidModeGetGammaRampSizeReq); + swaps(&stuff->length); + REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq); + swaps(&stuff->screen); + return ProcXF86VidModeGetGammaRampSize(client); +-} static int +- SProcXF86VidModeGetPermissions(ClientPtr client) { ++} ++ ++static int ++SProcXF86VidModeGetPermissions(ClientPtr client) ++{ + REQUEST(xXF86VidModeGetPermissionsReq); + swaps(&stuff->length); + REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq); + swaps(&stuff->screen); + return ProcXF86VidModeGetPermissions(client); +-} static int +- SProcXF86VidModeDispatch(ClientPtr client) { ++} ++ ++static int ++SProcXF86VidModeDispatch(ClientPtr client) ++{ + REQUEST(xReq); + switch (stuff->data) { + case X_XF86VidModeQueryVersion: + return SProcXF86VidModeQueryVersion(client); +- case X_XF86VidModeGetModeLine:return +- SProcXF86VidModeGetModeLine(client); +- case X_XF86VidModeGetMonitor:return SProcXF86VidModeGetMonitor(client); +- case X_XF86VidModeGetAllModeLines:return +- SProcXF86VidModeGetAllModeLines(client); +- case X_XF86VidModeGetViewPort:return +- SProcXF86VidModeGetViewPort(client); +- case X_XF86VidModeValidateModeLine:return +- SProcXF86VidModeValidateModeLine(client); +- case X_XF86VidModeGetDotClocks:return +- SProcXF86VidModeGetDotClocks(client); +- case X_XF86VidModeSetClientVersion:return +- SProcXF86VidModeSetClientVersion(client); +- case X_XF86VidModeGetGamma:return SProcXF86VidModeGetGamma(client); +- case X_XF86VidModeGetGammaRamp:return +- SProcXF86VidModeGetGammaRamp(client); +- case X_XF86VidModeGetGammaRampSize:return +- SProcXF86VidModeGetGammaRampSize(client); +- case X_XF86VidModeGetPermissions:return +- SProcXF86VidModeGetPermissions(client); +- default:if (!xf86GetVidModeEnabled()) ++ case X_XF86VidModeGetModeLine: ++ return SProcXF86VidModeGetModeLine(client); ++ case X_XF86VidModeGetMonitor: ++ return SProcXF86VidModeGetMonitor(client); ++ case X_XF86VidModeGetAllModeLines: ++ return SProcXF86VidModeGetAllModeLines(client); ++ case X_XF86VidModeGetViewPort: ++ return SProcXF86VidModeGetViewPort(client); ++ case X_XF86VidModeValidateModeLine: ++ return SProcXF86VidModeValidateModeLine(client); ++ case X_XF86VidModeGetDotClocks: ++ return SProcXF86VidModeGetDotClocks(client); ++ case X_XF86VidModeSetClientVersion: ++ return SProcXF86VidModeSetClientVersion(client); ++ case X_XF86VidModeGetGamma: ++ return SProcXF86VidModeGetGamma(client); ++ case X_XF86VidModeGetGammaRamp: ++ return SProcXF86VidModeGetGammaRamp(client); ++ case X_XF86VidModeGetGammaRampSize: ++ return SProcXF86VidModeGetGammaRampSize(client); ++ case X_XF86VidModeGetPermissions: ++ return SProcXF86VidModeGetPermissions(client); ++ default: ++ if (!xf86GetVidModeEnabled()) + return VidModeErrorBase + XF86VidModeExtensionDisabled; + if (xf86GetVidModeAllowNonLocal() || LocalClient(client)) { + switch (stuff->data) { + case X_XF86VidModeAddModeLine: + return SProcXF86VidModeAddModeLine(client); +- case X_XF86VidModeDeleteModeLine:return +- SProcXF86VidModeDeleteModeLine(client); +- case X_XF86VidModeModModeLine:return +- SProcXF86VidModeModModeLine(client); +- case X_XF86VidModeSwitchMode:return +- SProcXF86VidModeSwitchMode(client); +- case X_XF86VidModeSwitchToMode:return +- SProcXF86VidModeSwitchToMode(client); +- case X_XF86VidModeLockModeSwitch:return +- SProcXF86VidModeLockModeSwitch(client); +- case X_XF86VidModeSetViewPort:return +- SProcXF86VidModeSetViewPort(client); +- case X_XF86VidModeSetGamma:return +- SProcXF86VidModeSetGamma(client); +- case X_XF86VidModeSetGammaRamp:return +- SProcXF86VidModeSetGammaRamp(client); +- default:return BadRequest; +- }} ++ case X_XF86VidModeDeleteModeLine: ++ return SProcXF86VidModeDeleteModeLine(client); ++ case X_XF86VidModeModModeLine: ++ return SProcXF86VidModeModModeLine(client); ++ case X_XF86VidModeSwitchMode: ++ return SProcXF86VidModeSwitchMode(client); ++ case X_XF86VidModeSwitchToMode: ++ return SProcXF86VidModeSwitchToMode(client); ++ case X_XF86VidModeLockModeSwitch: ++ return SProcXF86VidModeLockModeSwitch(client); ++ case X_XF86VidModeSetViewPort: ++ return SProcXF86VidModeSetViewPort(client); ++ case X_XF86VidModeSetGamma: ++ return SProcXF86VidModeSetGamma(client); ++ case X_XF86VidModeSetGammaRamp: ++ return SProcXF86VidModeSetGammaRamp(client); ++ default: ++ return BadRequest; ++ } ++ } + else +- return VidModeErrorBase + XF86VidModeClientNotLocal; ++ return VidModeErrorBase + XF86VidModeClientNotLocal; + } + } + + void +- XFree86VidModeExtensionInit(void) { ++XFree86VidModeExtensionInit(void) ++{ + ExtensionEntry *extEntry; + ScreenPtr pScreen; + int i; + Bool enabled = FALSE; + +- DEBUG_P("XFree86VidModeExtensionInit"); ++ DEBUG_P("XFree86VidModeExtensionInit"); + + if (!dixRegisterPrivateKey(&VidModeClientPrivateKeyRec, PRIVATE_CLIENT, 0)) +- return; ++ return; + #ifdef XF86VIDMODE_EVENTS + if (!dixRegisterPrivateKey(&ScreenPrivateKeyRec, PRIVATE_SCREEN, 0)) +- return; ++ return; + #endif + + #ifdef XF86VIDMODE_EVENTS +- EventType = CreateNewResourceType(XF86VidModeFreeEvents, "VidModeEvent"); ++ EventType = CreateNewResourceType(XF86VidModeFreeEvents, "VidModeEvent"); + #endif + + for (i = 0; i < screenInfo.numScreens; i++) { +@@ -1990,8 +2124,8 @@ void + enabled = TRUE; } + /* This means that the DDX doesn't want the vidmode extension enabled */ +- if (!enabled) +- return; ++ if (!enabled) ++ return; -- if (have_outputs) { -- /* Mirror output modes to scrn mode list */ -- xf86SetScrnInfoModes (scrn); -- } else { -- /* Clear any existing modes from scrn->modes */ -- while (scrn->modes != NULL) -- xf86DeleteMode(&scrn->modes, scrn->modes); -- scrn->modes = xf86ModesAdd(scrn->modes, -- xf86CVTMode(width, height, 60, 0, 0)); -- } -+ xf86SetScrnInfoModes (scrn); - - success = TRUE; - bailout: + if ( + #ifdef XF86VIDMODE_EVENTS -- cgit v0.9.0.2-2-gbebe -From 97f2ae60fc0cc755abd8b88df826fcb1a20464fe Mon Sep 17 00:00:00 2001 -From: Christopher Yeleighton -Date: Tue, 25 Oct 2011 01:47:06 +0000 -Subject: Bug 38420: Xvfb crashes in miInitVisuals() when started with depth=2 +From 15607cf2dc87405606b20113011f1ebd97637d32 Mon Sep 17 00:00:00 2001 +From: Daniel Kurtz +Date: Thu, 12 Apr 2012 00:11:10 +0000 +Subject: dix: don't BUG_WARN for button events from button-only device -https://bugs.freedesktop.org/show_bug.cgi?id=38420 +Events from button-only devices still need coordinates, and they get them +from scale_to_desktop(). Therefore, a dev without valuators is not a bug. +However, a dev with valuators, but less than two of them still is a bug. -Exit with fatal error message, not segfault. +This was noticed when unplugging a "Creative Technology SB Arena Headset", +which has some BTNs and some KEYs, but no REL or ABS valuators. +It emits [BTN_3] = 0 on unplug, which would trigger the BUG_WARN. -Signed-off-by: Alan Coopersmith -Reviewed-by: Jeremy Huddleston -Signed-off-by: Keith Packard -(cherry picked from commit 7d50211ab57a35910d79fc3f67ae89aff91fa995) +Signed-off-by: Daniel Kurtz +Reviewed-by: Chase Douglas +Signed-off-by: Peter Hutterer +(cherry picked from commit c5a45b0f7658c77725adce2b64a0fbd62f208328) --- -diff --git a/hw/vfb/InitOutput.c b/hw/vfb/InitOutput.c -index 31ed505..dce3f84 100644 ---- a/hw/vfb/InitOutput.c -+++ b/hw/vfb/InitOutput.c -@@ -864,6 +864,8 @@ vfbScreenInit(int index, ScreenPtr pScreen, int argc, char **argv) - (1 << DirectColor)), - 10, TrueColor, 0x3ff00000, 0x000ffc00, 0x000003ff); - break; -+ default: -+ return FALSE; - } +diff --git a/dix/getevents.c b/dix/getevents.c +index 4e0af45..9dc9617 100644 +--- a/dix/getevents.c ++++ b/dix/getevents.c +@@ -842,7 +842,7 @@ scale_to_desktop(DeviceIntPtr dev, ValuatorMask *mask, + ScreenPtr scr = miPointerGetScreen(dev); + double x, y; - miSetPixmapDepths (); +- BUG_WARN(!dev->valuator || dev->valuator->numAxes < 2); ++ BUG_WARN(dev->valuator && dev->valuator->numAxes < 2); + if (!dev->valuator || dev->valuator->numAxes < 2) { + /* if we have no axes, last.valuators must be in screen coords + * anyway */ -- cgit v0.9.0.2-2-gbebe -From 34bb83b9df20ff63dbb147ed661f39efb8bae8e4 Mon Sep 17 00:00:00 2001 +From f8d2ca759ad37d5e99d462f21a2259ce17bb1a00 Mon Sep 17 00:00:00 2001 From: Peter Hutterer -Date: Mon, 24 Oct 2011 02:00:32 +0000 -Subject: dix: block signals when closing all devices +Date: Wed, 18 Apr 2012 05:56:37 +0000 +Subject: dix: indentation fix -When closing down all devices, we manually unset master for all attached -devices, but the device's sprite info still points to the master's sprite -info. This leaves us a window where the master is freed already but the -device isn't yet. A signal during that window causes dereference of the -already freed spriteInfo in mieqEnqueue's EnqueueScreen macro. - -Simply block signals when removing all devices. It's not like we're really -worrying about high-responsive input at this stage. +Signed-off-by: Peter Hutterer +(cherry picked from commit ebf214876a4885a98ded4f5525925b69005fae05) +--- +diff --git a/dix/dispatch.c b/dix/dispatch.c +index 9a2e22f..d971805 100644 +--- a/dix/dispatch.c ++++ b/dix/dispatch.c +@@ -416,8 +416,8 @@ Dispatch(void) + if (XSERVER_REQUEST_START_ENABLED()) + XSERVER_REQUEST_START(LookupMajorName(client->majorOp), + client->majorOp, +- ((xReq *) client->requestBuffer)-> +- length, client->index, ++ ((xReq *) client->requestBuffer)->length, ++ client->index, + client->requestBuffer); + #endif + if (result > (maxBigRequestSize << 2)) +-- +cgit v0.9.0.2-2-gbebe +From f012f0c48dedba4df69cc1a1ecdf8ee5d37daca9 Mon Sep 17 00:00:00 2001 +From: Michal Suchanek +Date: Thu, 26 Apr 2012 13:11:20 +0000 +Subject: dmx: Annotate dmxlog.c with _X_ATTRIBUTE_PRINTF and _X_NORETURN -https://bugzilla.redhat.com/show_bug.cgi?id=737031 +and fix resulting printf warning in dmxLogVisual +Signed-off-by: Michal Suchanek +Reviewed-by: Peter Hutterer Signed-off-by: Peter Hutterer -Reviewed-by: Julien Cristau -(cherry picked from commit d7c44a7c9760449bef263413ad3b20f19b1dc95a) +(cherry picked from commit d662fa2450856777b59c4b62b912395a8bfd52fd) +--- +diff --git a/hw/dmx/dmxlog.c b/hw/dmx/dmxlog.c +index b56bb93..151f672 100644 +--- a/hw/dmx/dmxlog.c ++++ b/hw/dmx/dmxlog.c +@@ -86,6 +86,8 @@ ErrorF(const char *format, ...) + + /** Provide an VFatalError function when used stand-alone. */ + static void ++VFatalError(const char *format, va_list args) _X_ATTRIBUTE_PRINTF(1, 0) _X_NORETURN; ++static void + VFatalError(const char *format, va_list args) + { + vfprintf(stderr, format, args); /* RATS: We assume the format string +@@ -104,7 +106,9 @@ VErrorF(const char *format, va_list args) + } + #else + /** This function was removed between XFree86 4.3.0 and XFree86 4.4.0. */ +-extern void AbortServer(void); ++extern void AbortServer(void) _X_NORETURN; ++static void ++VFatalError(const char *format, va_list args) _X_ATTRIBUTE_PRINTF(1, 0) _X_NORETURN; + static void + VFatalError(const char *format, va_list args) + { +@@ -166,6 +170,8 @@ dmxHeader(dmxLogLevel logLevel, DMXInputInfo * dmxInput, + /* Prints the error message with the appropriate low-level X output + * routine. */ + static void ++dmxMessage(dmxLogLevel logLevel, const char *format, va_list args) _X_ATTRIBUTE_PRINTF(2, 0); ++static void + dmxMessage(dmxLogLevel logLevel, const char *format, va_list args) + { + if (logLevel == dmxFatal || logLevel >= dmxCurrentLogLevel) { +@@ -303,10 +309,11 @@ dmxLogVisual(DMXScreenInfo * dmxScreen, XVisualInfo * vi, int defaultVisual) + class = "DirectColor"; + break; + } ++#define VisualLogFormat "0x%02lx %s %2db %db/rgb %3d 0x%04lx 0x%04lx 0x%04lx%s\n" + + if (dmxScreen) { + dmxLogOutput(dmxScreen, +- "0x%02x %s %2db %db/rgb %3d 0x%04x 0x%04x 0x%04x%s\n", ++ VisualLogFormat, + vi->visualid, class, vi->depth, vi->bits_per_rgb, + vi->colormap_size, + vi->red_mask, vi->green_mask, vi->blue_mask, +@@ -314,7 +321,7 @@ dmxLogVisual(DMXScreenInfo * dmxScreen, XVisualInfo * vi, int defaultVisual) + } + else { + dmxLog(dmxInfo, +- " 0x%02x %s %2db %db/rgb %3d 0x%04x 0x%04x 0x%04x%s\n", ++ " " VisualLogFormat, + vi->visualid, class, vi->depth, vi->bits_per_rgb, + vi->colormap_size, + vi->red_mask, vi->green_mask, vi->blue_mask, +diff --git a/hw/dmx/dmxlog.h b/hw/dmx/dmxlog.h +index 4d4cd26..162484b 100644 +--- a/hw/dmx/dmxlog.h ++++ b/hw/dmx/dmxlog.h +@@ -55,18 +55,23 @@ typedef enum { + /* Logging functions used by Xserver/hw/dmx routines. */ + extern dmxLogLevel dmxSetLogLevel(dmxLogLevel newLevel); + extern dmxLogLevel dmxGetLogLevel(void); +-extern void dmxLog(dmxLogLevel logLevel, const char *format, ...); +-extern void dmxLogCont(dmxLogLevel logLevel, const char *format, ...); ++extern void dmxLog(dmxLogLevel logLevel, const char *format, ++ ...) _X_ATTRIBUTE_PRINTF(2, 3); ++extern void dmxLogCont(dmxLogLevel logLevel, const char *format, ++ ...) _X_ATTRIBUTE_PRINTF(2, 3); + extern const char *dmxEventName(int type); + + #ifndef DMX_LOG_STANDALONE +-extern void dmxLogOutput(DMXScreenInfo * dmxScreen, const char *format, ...); ++extern void dmxLogOutput(DMXScreenInfo * dmxScreen, const char *format, ++ ...) _X_ATTRIBUTE_PRINTF(2, 3); + extern void dmxLogOutputCont(DMXScreenInfo * dmxScreen, const char *format, +- ...); ++ ...) _X_ATTRIBUTE_PRINTF(2, 3); + extern void dmxLogOutputWarning(DMXScreenInfo * dmxScreen, const char *format, +- ...); +-extern void dmxLogInput(DMXInputInfo * dmxInput, const char *format, ...); +-extern void dmxLogInputCont(DMXInputInfo * dmxInput, const char *format, ...); ++ ...) _X_ATTRIBUTE_PRINTF(2, 3); ++extern void dmxLogInput(DMXInputInfo * dmxInput, const char *format, ++ ...) _X_ATTRIBUTE_PRINTF(2, 3); ++extern void dmxLogInputCont(DMXInputInfo * dmxInput, const char *format, ++ ...) _X_ATTRIBUTE_PRINTF(2, 3); + extern void dmxLogArgs(dmxLogLevel logLevel, int argc, char **argv); + extern void dmxLogVisual(DMXScreenInfo * dmxScreen, XVisualInfo * vi, + int defaultVisual); +-- +cgit v0.9.0.2-2-gbebe +From 58dfb13953af71021317b9d85230b1163198f031 Mon Sep 17 00:00:00 2001 +From: Jeremy Huddleston +Date: Thu, 10 May 2012 07:53:20 +0000 +Subject: Revert "dix: when disabling a device, release all buttons and keys" + +This reverts commit 90299556db24543bb7365e8c2897deca3aa219e7. + +The commit being reverted triggered a segfault on server shutdown when a +device posts raw events after the root windows are forced to NULL. + +https://lists.debian.org/debian-x/2012/05/msg00240.html + +Signed-off-by: Jeremy Huddleston --- diff --git a/dix/devices.c b/dix/devices.c -index 0ccf252..cbdd4ea 100644 +index d0e99bd..0125504 100644 --- a/dix/devices.c +++ b/dix/devices.c -@@ -982,6 +982,8 @@ CloseDownDevices(void) - { - DeviceIntPtr dev; - -+ OsBlockSignals(); -+ - /* Float all SDs before closing them. Note that at this point resources - * (e.g. cursors) have been freed already, so we can't just call - * AttachDevice(NULL, dev, NULL). Instead, we have to forcibly set master -@@ -1004,6 +1006,8 @@ CloseDownDevices(void) - inputInfo.keyboard = NULL; - inputInfo.pointer = NULL; - XkbDeleteRulesDflts(); -+ -+ OsReleaseSignals(); - } +@@ -432,8 +432,6 @@ DisableDevice(DeviceIntPtr dev, BOOL sendevent) + if (*prev != dev) + return FALSE; - /** +- ReleaseButtonsAndKeys(dev); +- + /* float attached devices */ + if (IsMaster(dev)) { + for (other = inputInfo.devices; other; other = other->next) { -- cgit v0.9.0.2-2-gbebe -- cgit v1.2.3-54-g00ecf