diff options
Diffstat (limited to 'meta/recipes-graphics/xorg-xserver/xserver-xf86-dri-lite/cache-xkbcomp-output-for-fast-start-up.patch')
-rw-r--r-- | meta/recipes-graphics/xorg-xserver/xserver-xf86-dri-lite/cache-xkbcomp-output-for-fast-start-up.patch | 358 |
1 files changed, 358 insertions, 0 deletions
diff --git a/meta/recipes-graphics/xorg-xserver/xserver-xf86-dri-lite/cache-xkbcomp-output-for-fast-start-up.patch b/meta/recipes-graphics/xorg-xserver/xserver-xf86-dri-lite/cache-xkbcomp-output-for-fast-start-up.patch new file mode 100644 index 0000000000..b121bba655 --- /dev/null +++ b/meta/recipes-graphics/xorg-xserver/xserver-xf86-dri-lite/cache-xkbcomp-output-for-fast-start-up.patch @@ -0,0 +1,358 @@ +From 0f70ba9d3412b17ac4e08e33e1be3c226c06ea54 Mon Sep 17 00:00:00 2001 +From: Yan Li <yan.i.li@intel.com> +Date: Tue, 12 May 2009 17:49:07 +0800 +Subject: [PATCH] XKB: cache xkbcomp output for fast start-up v5 for 1.6.1 +Organization: Intel + +xkbcomp outputs will be cached in files with hashed keymap as +names. This saves boot time for around 1s on commodity netbooks. + +Signed-off-by: Yan Li <yan.i.li@intel.com> +--- + configure.ac | 6 +- + xkb/README.compiled | 8 +- + xkb/ddxLoad.c | 192 +++++++++++++++++++++++++++++++++++++++++--------- + 3 files changed, 164 insertions(+), 42 deletions(-) + +diff --git a/configure.ac b/configure.ac +index 4c4c797..7a5020a 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -476,9 +476,9 @@ AC_ARG_WITH(default-font-path, AS_HELP_STRING([--with-default-font-path=PATH], [ + AC_ARG_WITH(xkb-path, AS_HELP_STRING([--with-xkb-path=PATH], [Path to XKB base dir (default: ${datadir}/X11/xkb)]), + [ XKBPATH="$withval" ], + [ XKBPATH="${datadir}/X11/xkb" ]) +-AC_ARG_WITH(xkb-output, AS_HELP_STRING([--with-xkb-output=PATH], [Path to XKB output dir (default: ${datadir}/X11/xkb/compiled)]), ++AC_ARG_WITH(xkb-output, AS_HELP_STRING([--with-xkb-output=PATH], [Path to XKB output dir (default: ${localstatedir}/cache/xkb)]), + [ XKBOUTPUT="$withval" ], +- [ XKBOUTPUT="compiled" ]) ++ [ XKBOUTPUT="${localstatedir}/cache/xkb" ]) + AC_ARG_WITH(serverconfig-path, AS_HELP_STRING([--with-serverconfig-path=PATH], + [Directory where ancillary server config files are installed (default: ${libdir}/xorg)]), + [ SERVERCONFIG="$withval" ], +@@ -1757,7 +1757,7 @@ AC_DEFINE_DIR(XKB_BIN_DIRECTORY, bindir, [Path to XKB bin dir]) + XKBOUTPUT_FIRSTCHAR=`echo $XKBOUTPUT | cut -b 1` + + if [[ x$XKBOUTPUT_FIRSTCHAR != x/ ]] ; then +- XKBOUTPUT="$XKB_BASE_DIRECTORY/$XKBOUTPUT" ++ AC_MSG_ERROR([xkb-output must be an absolute path.]) + fi + + # XKM_OUTPUT_DIR (used in code) must end in / or file names get hosed +diff --git a/xkb/README.compiled b/xkb/README.compiled +index 71caa2f..a4a2ae0 100644 +--- a/xkb/README.compiled ++++ b/xkb/README.compiled +@@ -4,10 +4,10 @@ current keymap and/or any scratch keymaps used by clients. The X server + or some other tool might destroy or replace the files in this directory, + so it is not a safe place to store compiled keymaps for long periods of + time. The default keymap for any server is usually stored in: +- X<num>-default.xkm +-where <num> is the display number of the server in question, which makes +-it possible for several servers *on the same host* to share the same +-directory. ++ server-<SHA1>.xkm ++ ++where <SHA1> is the SHA1 hash of keymap source, so that compiled ++keymap of different keymap sources are stored in different files. + + Unless the X server is modified, sharing this directory between servers on + different hosts could cause problems. +diff --git a/xkb/ddxLoad.c b/xkb/ddxLoad.c +index 4d5dfb6..60a68af 100644 +--- a/xkb/ddxLoad.c ++++ b/xkb/ddxLoad.c +@@ -32,6 +32,12 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE. + #include <xkb-config.h> + #endif + ++#ifdef HAVE_SHA1_IN_LIBMD /* Use libmd for SHA1 */ ++# include <sha1.h> ++#else /* Use OpenSSL's libcrypto */ ++# include <stddef.h> /* buggy openssl/sha.h wants size_t */ ++# include <openssl/sha.h> ++#endif + #include <stdio.h> + #include <ctype.h> + #define NEED_EVENTS 1 +@@ -46,24 +52,13 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE. + #define XKBSRV_NEED_FILE_FUNCS + #include <xkbsrv.h> + #include <X11/extensions/XI.h> ++#include <errno.h> + #include "xkb.h" + + #if defined(CSRG_BASED) || defined(linux) || defined(__GNU__) + #include <paths.h> + #endif + +- /* +- * If XKM_OUTPUT_DIR specifies a path without a leading slash, it is +- * relative to the top-level XKB configuration directory. +- * Making the server write to a subdirectory of that directory +- * requires some work in the general case (install procedure +- * has to create links to /var or somesuch on many machines), +- * so we just compile into /usr/tmp for now. +- */ +-#ifndef XKM_OUTPUT_DIR +-#define XKM_OUTPUT_DIR "compiled/" +-#endif +- + #define PRE_ERROR_MSG "\"The XKEYBOARD keymap compiler (xkbcomp) reports:\"" + #define ERROR_PREFIX "\"> \"" + #define POST_ERROR_MSG1 "\"Errors from xkbcomp are not fatal to the X server\"" +@@ -179,6 +174,45 @@ OutputDirectory( + } + + static Bool ++Sha1Asc(char sha1Asc[SHA_DIGEST_LENGTH*2+1], const char * input) ++{ ++ int i; ++ unsigned char sha1[SHA_DIGEST_LENGTH]; ++ ++#ifdef HAVE_SHA1_IN_LIBMD /* Use libmd for SHA1 */ ++ SHA1_CTX ctx; ++ ++ SHA1Init (&ctx); ++ SHA1Update (&ctx, input, strlen(input)); ++ SHA1Final (sha1, &ctx); ++#else /* Use OpenSSL's libcrypto */ ++ SHA_CTX ctx; ++ int success; ++ ++ success = SHA1_Init (&ctx); ++ if (! success) ++ return BadAlloc; ++ ++ success = SHA1_Update (&ctx, input, strlen(input)); ++ if (! success) ++ return BadAlloc; ++ ++ success = SHA1_Final (sha1, &ctx); ++ if (! success) ++ return BadAlloc; ++#endif ++ ++ /* convert sha1 to sha1_asc */ ++ for(i=0; i<SHA_DIGEST_LENGTH; ++i) { ++ sprintf(sha1Asc+i*2, "%02X", sha1[i]); ++ } ++ ++ return Success; ++} ++ ++/* call xkbcomp and compile XKB keymap, return xkm file name in ++ nameRtrn */ ++static Bool + XkbDDXCompileKeymapByNames( XkbDescPtr xkb, + XkbComponentNamesPtr names, + unsigned want, +@@ -187,7 +221,11 @@ XkbDDXCompileKeymapByNames( XkbDescPtr xkb, + int nameRtrnLen) + { + FILE * out; +- char *buf = NULL, keymap[PATH_MAX], xkm_output_dir[PATH_MAX]; ++ char * buf = NULL, xkmfile[PATH_MAX], xkm_output_dir[PATH_MAX]; ++ char * tmpXkmFile = NULL; ++ char * canonicalXkmFileName = NULL; ++ char sha1Asc[SHA_DIGEST_LENGTH*2+1], xkbKeyMapBuf[100*1024]; ++ int ret, result; + + const char *emptystring = ""; + const char *xkbbasedirflag = emptystring; +@@ -198,16 +236,70 @@ XkbDDXCompileKeymapByNames( XkbDescPtr xkb, + /* WIN32 has no popen. The input must be stored in a file which is + used as input for xkbcomp. xkbcomp does not read from stdin. */ + char tmpname[PATH_MAX]; +- const char *xkmfile = tmpname; ++ const char *xkbfile = tmpname; + #else +- const char *xkmfile = "-"; ++ const char *xkbfile = "-"; + #endif + +- snprintf(keymap, sizeof(keymap), "server-%s", display); ++ /* Write keymap source (xkbfile) to memory buffer `xkbKeyMapBuf', ++ of which SHA1 is generated and used as result xkm file name */ ++ memset(xkbKeyMapBuf, 0, sizeof(xkbKeyMapBuf)); ++ out = fmemopen(xkbKeyMapBuf, sizeof(xkbKeyMapBuf), "w"); ++ if (NULL == out) { ++ ErrorF("[xkb] Open xkbKeyMapBuf for writing failed\n"); ++ return False; ++ } ++ ret = XkbWriteXKBKeymapForNames(out, names, xkb, want, need); ++ if (fclose(out) !=0) ++ { ++ ErrorF("[xkb] XkbWriteXKBKeymapForNames error, perhaps xkbKeyMapBuf is too small\n"); ++ return False; ++ } ++#ifdef DEBUG ++ if (xkbDebugFlags) { ++ ErrorF("[xkb] XkbDDXCompileKeymapByNames compiling keymap:\n"); ++ fputs(xkbKeyMapBuf, stderr); ++ } ++#endif ++ if (!ret) { ++ ErrorF("[xkb] Generating XKB Keymap failed, giving up compiling keymap\n"); ++ return False; ++ } ++ ++ DebugF("[xkb] computing SHA1 of keymap\n"); ++ if (Success == Sha1Asc(sha1Asc, xkbKeyMapBuf)) { ++ snprintf(xkmfile, sizeof(xkmfile), "server-%s", sha1Asc); ++ } ++ else { ++ ErrorF("[xkb] Computing SHA1 of keymap failed, " ++ "using display name instead as xkm file name\n"); ++ snprintf(xkmfile, sizeof(xkmfile), "server-%s", display); ++ } + +- XkbEnsureSafeMapName(keymap); ++ XkbEnsureSafeMapName(xkmfile); + OutputDirectory(xkm_output_dir, sizeof(xkm_output_dir)); + ++ /* set nameRtrn, fail if it's too small */ ++ if ((strlen(xkmfile)+1 > nameRtrnLen) && nameRtrn) { ++ ErrorF("[xkb] nameRtrn too small to hold xkmfile name\n"); ++ return False; ++ } ++ strncpy(nameRtrn, xkmfile, nameRtrnLen); ++ ++ /* if the xkm file already exists, reuse it */ ++ canonicalXkmFileName = Xprintf("%s%s.xkm", xkm_output_dir, xkmfile); ++ if (access(canonicalXkmFileName, R_OK) == 0) { ++ /* yes, we can reuse the old xkm file */ ++ LogMessage(X_INFO, "XKB: reuse xkmfile %s\n", canonicalXkmFileName); ++ result = True; ++ goto _ret; ++ } ++ LogMessage(X_INFO, "XKB: generating xkmfile %s\n", canonicalXkmFileName); ++ ++ /* continue to call xkbcomp to compile the keymap. to avoid race ++ condition, we compile it to a tmpfile then rename it to ++ xkmfile */ ++ + #ifdef WIN32 + strcpy(tmpname, Win32TempDir()); + strcat(tmpname, "\\xkb_XXXXXX"); +@@ -230,19 +322,30 @@ XkbDDXCompileKeymapByNames( XkbDescPtr xkb, + } + } + ++ if ( (tmpXkmFile = tempnam(xkm_output_dir, NULL)) == NULL ) { ++ ErrorF("[xkb] Can't generate temp xkm file name"); ++ result = False; ++ goto _ret; ++ } ++ + buf = Xprintf("\"%s%sxkbcomp\" -w %d %s -xkm \"%s\" " +- "-em1 %s -emp %s -eml %s \"%s%s.xkm\"", ++ "-em1 %s -emp %s -eml %s \"%s\"", + xkbbindir, xkbbindirsep, + ( (xkbDebugFlags < 2) ? 1 : + ((xkbDebugFlags > 10) ? 10 : (int)xkbDebugFlags) ), +- xkbbasedirflag, xkmfile, ++ xkbbasedirflag, xkbfile, + PRE_ERROR_MSG, ERROR_PREFIX, POST_ERROR_MSG1, +- xkm_output_dir, keymap); ++ tmpXkmFile); + + if (xkbbasedirflag != emptystring) { + xfree(xkbbasedirflag); + } + ++ /* there's a potential race condition between calling tempnam() ++ and invoking xkbcomp to write the result file (potential temp ++ file name conflicts), but since xkbcomp is a standalone ++ program, we have to live with this */ ++ + #ifndef WIN32 + out= Popen(buf,"w"); + #else +@@ -250,31 +353,43 @@ XkbDDXCompileKeymapByNames( XkbDescPtr xkb, + #endif + + if (out!=NULL) { +-#ifdef DEBUG +- if (xkbDebugFlags) { +- ErrorF("[xkb] XkbDDXCompileKeymapByNames compiling keymap:\n"); +- XkbWriteXKBKeymapForNames(stderr,names,xkb,want,need); ++ /* write XKBKeyMapBuf to xkbcomp */ ++ if (EOF==fputs(xkbKeyMapBuf, out)) ++ { ++ ErrorF("[xkb] Sending keymap to xkbcomp failed\n"); ++ result = False; ++ goto _ret; + } +-#endif +- XkbWriteXKBKeymapForNames(out,names,xkb,want,need); + #ifndef WIN32 + if (Pclose(out)==0) + #else + if (fclose(out)==0 && System(buf) >= 0) + #endif + { ++ /* xkbcomp success */ + if (xkbDebugFlags) + DebugF("[xkb] xkb executes: %s\n",buf); +- if (nameRtrn) { +- strncpy(nameRtrn,keymap,nameRtrnLen); +- nameRtrn[nameRtrnLen-1]= '\0'; ++ ++ /* if canonicalXkmFileName already exists now, we simply ++ overwrite it, this is OK */ ++ ret = rename(tmpXkmFile, canonicalXkmFileName); ++ if (0 != ret) { ++ ErrorF("[xkb] Can't rename %s to %s, error: %s\n", ++ tmpXkmFile, canonicalXkmFileName, ++ strerror(errno)); ++ ++ /* in case of error, don't unlink tmpXkmFile, leave it ++ for debugging */ ++ ++ result = False; ++ goto _ret; + } +- if (buf != NULL) +- xfree (buf); +- return True; ++ ++ result = True; ++ goto _ret; + } + else +- LogMessage(X_ERROR, "Error compiling keymap (%s)\n", keymap); ++ LogMessage(X_ERROR, "Error compiling keymap (%s)\n", xkbfile); + #ifdef WIN32 + /* remove the temporary file */ + unlink(tmpname); +@@ -289,9 +404,17 @@ XkbDDXCompileKeymapByNames( XkbDescPtr xkb, + } + if (nameRtrn) + nameRtrn[0]= '\0'; ++ result = False; ++ ++_ret: ++ if (tmpXkmFile) ++ free(tmpXkmFile); ++ if (canonicalXkmFileName) ++ xfree(canonicalXkmFileName); + if (buf != NULL) + xfree (buf); +- return False; ++ ++ return result; + } + + static FILE * +@@ -375,7 +498,6 @@ unsigned missing; + DebugF("Loaded XKB keymap %s, defined=0x%x\n",fileName,(*xkbRtrn)->defined); + } + fclose(file); +- (void) unlink (fileName); + return (need|want)&(~missing); + } + +-- +1.5.6.5 + |