diff --git a/codereview.settings b/codereview.settings
new file mode 100644
index 0000000..aa631d7
--- /dev/null
+++ b/codereview.settings
@@ -0,0 +1,6 @@
+# This file is used by git-cl to get repository specific information.
+GERRIT_HOST: goma.googlesource.com
+GERRIT_PORT: 443
+CODE_REVIEW_SERVER: goma-review.googlesource.com
+# gerrit only accepts regiestered users for cc.
+# CC_LIST: goma+review@google.com
diff --git a/dlls/kernel32/module.c b/dlls/kernel32/module.c
index d1555f1..f3adb0a 100644
--- a/dlls/kernel32/module.c
+++ b/dlls/kernel32/module.c
@@ -904,8 +904,13 @@
         LOAD_LIBRARY_SEARCH_SYSTEM32 |
         LOAD_LIBRARY_SEARCH_DEFAULT_DIRS;
 
-    if( flags & unsupported_flags)
-        FIXME("unsupported flag(s) used (flags: 0x%08x)\n", flags);
+    if( flags & unsupported_flags) {
+        FIXME("%s unsupported flag(s) used (flags: 0x%08x)\n", debugstr_wn( libname->Buffer, libname->Length / sizeof(WCHAR) ), flags);
+	if (flags & (LOAD_LIBRARY_AS_IMAGE_RESOURCE|LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE)) {
+		flags |= LOAD_LIBRARY_AS_DATAFILE;
+		FIXME("fix flag: 0x%08x)\n", flags);
+	}
+    }
 
     load_path = MODULE_get_dll_load_path( flags & LOAD_WITH_ALTERED_SEARCH_PATH ? libname->Buffer : NULL );
 
diff --git a/dlls/kernel32/process.c b/dlls/kernel32/process.c
index 0b70a55..796622d 100644
--- a/dlls/kernel32/process.c
+++ b/dlls/kernel32/process.c
@@ -997,6 +997,8 @@
  */
 static void start_wineboot( HANDLE handles[2] )
 {
+    if (getenv("WINENOWINEBOOT"))
+        return;
     static const WCHAR wineboot_eventW[] = {'_','_','w','i','n','e','b','o','o','t','_','e','v','e','n','t',0};
 
     handles[1] = 0;
diff --git a/dlls/kernel32/thread.c b/dlls/kernel32/thread.c
index 5d87cdd..ed3a00a 100644
--- a/dlls/kernel32/thread.c
+++ b/dlls/kernel32/thread.c
@@ -25,6 +25,9 @@
 #include <fcntl.h>
 #include <stdarg.h>
 #include <sys/types.h>
+#ifdef HAVE_SYS_SYSCALL_H
+#include <sys/syscall.h>
+#endif
 #ifdef HAVE_UNISTD_H
 # include <unistd.h>
 #endif
@@ -827,8 +830,215 @@
  */
 BOOL WINAPI GetThreadPreferredUILanguages( DWORD flags, PULONG count, PCZZWSTR buffer, PULONG buffersize )
 {
-    FIXME( "%u, %p, %p %p\n", flags, count, buffer, buffersize );
+    FIXME( "%u, %p(%d), %p %p(%d)\n", flags, count, *count, buffer, buffersize, *buffersize );
     *count = 0;
-    *buffersize = 0;
+    if (buffer == NULL) {
+	    *buffersize = 2;
+    } else {
+	    memset(buffer, 0, *buffersize*sizeof(WCHAR));
+    }
     return TRUE;
 }
+
+// TODO(ukai): move ntdlls/critsection.c?
+
+// copy from ntdlls/critsection.c
+#ifdef __linux__
+
+static int wait_op = 128; /*FUTEX_WAIT|FUTEX_PRIVATE_FLAG*/
+static int wake_op = 129; /*FUTEX_WAKE|FUTEX_PRIVATE_FLAG*/
+
+static inline int futex_wait( int *addr, int val, struct timespec *timeout )
+{
+    return syscall( SYS_futex, addr, wait_op, val, timeout, 0, 0 );
+}
+
+static inline int futex_wake( int *addr, int val )
+{
+    return syscall( SYS_futex, addr, wake_op, val, NULL, 0, 0 );
+}
+
+// srwlock->Ptr
+#define SRW_LOCKED 0x80000000
+#define SRW_WRITE_ACTIVE 0x00800000
+#define SRW_READERS_ACTIVE_MASK 0x0000FFFF
+
+void lock_srwlock(PSRWLOCK srwlock) {
+  TRACE("lock (%p %p)\n", srwlock, srwlock->Ptr);
+  DWORD oldval = 0;
+  for (;;) {
+    DWORD lockval = oldval | SRW_LOCKED;
+    DWORD val = (DWORD)interlocked_cmpxchg_ptr(&srwlock->Ptr, (void*)lockval, (void*)oldval);
+    if (val & SRW_LOCKED) {
+      // other thread holding lock
+      struct timespec ts;
+      ts.tv_sec = 0;
+      ts.tv_nsec = 1000;
+      futex_wait((int*)&srwlock->Ptr, val, &ts);
+      continue;
+    }
+    if (val != oldval) {
+      oldval = val & ~SRW_LOCKED;
+      continue;
+    }
+    TRACE("lock->(%p %p)\n", srwlock, srwlock->Ptr);
+    return;
+  }
+}
+
+void unlock_srwlock(PSRWLOCK srwlock) {
+  TRACE("unlock (%p, %p)\n", srwlock, srwlock->Ptr);
+  DWORD oldval = (DWORD)srwlock->Ptr;
+  DWORD unlockval = oldval & ~SRW_LOCKED;
+  interlocked_cmpxchg_ptr(&srwlock->Ptr, (void*)unlockval, (void*)oldval);
+  TRACE("unlock-> (%p, %p)\n", srwlock, srwlock->Ptr);
+  futex_wake((int*)&srwlock->Ptr, 1);
+}
+
+void wait_srwlock(PSRWLOCK srwlock) {
+  TRACE("wait (%p, %p)\n", srwlock, srwlock->Ptr);
+  DWORD val = 0;
+  unlock_srwlock(srwlock);
+  val = (DWORD)interlocked_cmpxchg_ptr(&srwlock->Ptr, (void*)0, (void*)0);
+  struct timespec ts;
+  ts.tv_sec = 0;
+  ts.tv_nsec = 100 * 1000 * 1000;
+  futex_wait((int*)&srwlock->Ptr, val, &ts);
+  lock_srwlock(srwlock);
+}
+
+void wake_srwlock(PSRWLOCK srwlock) {
+  TRACE("wake (%p, %p)\n", srwlock, srwlock->Ptr);
+  DWORD val = (DWORD)srwlock->Ptr;
+  futex_wake((int*)&srwlock->Ptr, 32);  // TODO(ukai): # of waiting threads?
+}
+
+void srwlock_write_active(PSRWLOCK srwlock, BOOL active) {
+  DWORD val = (DWORD)srwlock->Ptr;
+  if (active) {
+    val |= SRW_WRITE_ACTIVE;
+  } else {
+    val &= ~SRW_WRITE_ACTIVE;
+  }
+  TRACE("srwlock write (%p, %p->%p)\n", srwlock, srwlock->Ptr, val);
+  srwlock->Ptr = (void*)val;
+}
+
+BOOL srwlock_write_locked(PSRWLOCK srwlock) {
+  DWORD val = (DWORD)srwlock->Ptr;
+  return (val & SRW_WRITE_ACTIVE) != 0;
+}
+
+void srwlock_read_active(PSRWLOCK srwlock, BOOL active) {
+  DWORD val = (DWORD)srwlock->Ptr;
+  DWORD readers = val & SRW_READERS_ACTIVE_MASK;
+  val &= ~SRW_READERS_ACTIVE_MASK;
+  if (active) {
+    ++readers;
+  } else {
+    --readers;
+  }
+  val |= (readers & SRW_READERS_ACTIVE_MASK);
+  TRACE("srwlock read (%p, %p->%p)\n", srwlock, srwlock->Ptr, val);
+  srwlock->Ptr = (void*)val;
+}
+
+int srwlock_read_locked(PSRWLOCK srwlock) {
+  DWORD val = (DWORD)srwlock->Ptr;
+  return (val & SRW_READERS_ACTIVE_MASK);
+}
+
+#endif
+
+/***********************************************************************
+ *              InitializeSRWLock (KERNEL32.@)
+ */
+VOID WINAPI InitializeSRWLock( PSRWLOCK srwlock )
+{
+  TRACE("(%p)\n", srwlock);
+  srwlock->Ptr = 0;
+  TRACE("(%p, %p) initialized\n", srwlock, srwlock->Ptr);
+}
+
+/***********************************************************************
+ *              AcquireSRWLockExclusive (KERNEL32.@)
+ */
+VOID WINAPI AcquireSRWLockExclusive( PSRWLOCK srwlock )
+{
+#ifndef __linux__
+    FIXME( "(%p): stub\n", srwlock );
+#else
+    TRACE( "(%p)\n", srwlock );
+    lock_srwlock(srwlock);
+    for (;;) {
+      if (srwlock_write_locked(srwlock) || srwlock_read_locked(srwlock) > 0) {
+        TRACE( "(%p): wait write\n", srwlock );
+        wait_srwlock(srwlock);
+        continue;
+      }
+      srwlock_write_active(srwlock, 1);
+      break;
+    }
+    unlock_srwlock(srwlock);
+    TRACE( "->(%p): stub\n", srwlock );
+#endif
+}
+
+/***********************************************************************
+ *              ReleaseSRWLockExclusive (KERNEL32.@)
+ */
+VOID WINAPI ReleaseSRWLockExclusive( PSRWLOCK srwlock )
+{
+#ifndef __linux__
+    FIXME( "(%p): stub\n", srwlock );
+#else
+    TRACE( "(%p)\n", srwlock );
+    lock_srwlock(srwlock);
+    srwlock_write_active(srwlock, 0);
+    unlock_srwlock(srwlock);
+    wake_srwlock(srwlock);
+    TRACE( "->(%p): stub\n", srwlock );
+#endif
+}
+
+/***********************************************************************
+ *              AcquireSRWLockShared (KERNEL32.@)
+ */
+VOID WINAPI AcquireSRWLockShared( PSRWLOCK srwlock )
+{
+#ifndef __linux__
+    FIXME( "(%p): stub\n", srwlock );
+#else
+    TRACE( "(%p)\n", srwlock );
+    lock_srwlock(srwlock);
+    for (;;) {
+      if (srwlock_write_locked(srwlock)) {
+        TRACE( "(%p): wait read\n", srwlock );
+        wait_srwlock(srwlock);
+        continue;
+      }
+      srwlock_read_active(srwlock, 1);
+      break;
+    }
+    unlock_srwlock(srwlock);
+    TRACE( "->(%p): stub\n", srwlock );
+#endif
+}
+
+/***********************************************************************
+ *              ReleaseSRWLockShared (KERNEL32.@)
+ */
+VOID WINAPI ReleaseSRWLockShared( PSRWLOCK srwlock )
+{
+#ifndef __linux__
+    FIXME( "(%p): stub\n", srwlock );
+#else
+    TRACE( "(%p)\n", srwlock );
+    lock_srwlock(srwlock);
+    srwlock_read_active(srwlock, 0);
+    unlock_srwlock(srwlock);
+    wake_srwlock(srwlock);
+    TRACE( "->(%p): stub\n", srwlock );
+#endif
+}
+
diff --git a/dlls/ntdll/critsection.c b/dlls/ntdll/critsection.c
index 839c7ca..fe16738 100644
--- a/dlls/ntdll/critsection.c
+++ b/dlls/ntdll/critsection.c
@@ -510,6 +510,18 @@
     return ret;
 }
 
+static BOOL IsAllZero(const void* begin, size_t size)
+{
+    const char* m = begin;
+    int i;
+
+    for (i = 0; i < size; ++i) {
+        if (m[i] != 0)
+            return FALSE;
+    }
+
+    return TRUE;
+}
 
 /***********************************************************************
  *           RtlEnterCriticalSection   (NTDLL.@)
@@ -530,6 +542,25 @@
  */
 NTSTATUS WINAPI RtlEnterCriticalSection( RTL_CRITICAL_SECTION *crit )
 {
+    // VS2013 cl.exe calls this with zero cleared crit.
+    // As far as we examined, this does not happen in real Windows.
+    // So maybe there is a wine bug that causes this. However, I have no idea
+    // about what causes this.
+    // Let's allow it to enter critical section for workaround.
+    if (IsAllZero(crit, sizeof(RTL_CRITICAL_SECTION))) {
+        if (interlocked_cmpxchg(&crit->SpinCount, 4000, 0) == 0) {
+            // OK. SpinCount was 0, and now 4000.
+            crit->LockCount = -1;
+        }
+
+        // When interlocked_cmpxchg was failed, someone changed SpinCount
+        // after IsAllZero(). With this workaround, someone will change or
+        // has changed crit->LockCount to -1. Leaving LockCount as is so that
+        // this thread (or the other thread) will wait for lock release.
+        // In usual case, cl.exe will return critical section with zero-cleared
+        // crit only once. So this shouldn't happen, though.
+    }
+
     if (crit->SpinCount)
     {
         ULONG count;
diff --git a/dlls/ntdll/directory.c b/dlls/ntdll/directory.c
index 04a5b75..c7a0b7b 100644
--- a/dlls/ntdll/directory.c
+++ b/dlls/ntdll/directory.c
@@ -1376,7 +1376,7 @@
     union file_directory_info *info;
     int i, long_len, short_len, total_len;
     struct stat st;
-    WCHAR long_nameW[MAX_DIR_ENTRY_LEN];
+    WCHAR long_nameW[MAX_DIR_ENTRY_LEN] = { (WCHAR)0 };
     WCHAR short_nameW[12];
     WCHAR *filename;
     UNICODE_STRING str;
diff --git a/include/winnls.h b/include/winnls.h
index 9ed4344..9601665 100644
--- a/include/winnls.h
+++ b/include/winnls.h
@@ -568,6 +568,10 @@
 #define LGRPID_GEORGIAN            0x10
 #define LGRPID_ARMENIAN            0x11
 
+// WINVER >= 0x0600
+#define MUI_LANGUAGE_ID            0x04
+#define MUI_LANGUAGE_NAME          0x08
+
 /* IDN defines. */
 #define IDN_ALLOW_UNASSIGNED        0x1
 #define IDN_USE_STD3_ASCII_RULES    0x2
diff --git a/loader/preloader.c b/loader/preloader.c
index f38e17a..ebf512a 100644
--- a/loader/preloader.c
+++ b/loader/preloader.c
@@ -1160,8 +1160,8 @@
 {
     long i, *pargc;
     char **argv, **p;
-    char *interp, *reserve = NULL;
-    struct wld_auxv new_av[12], delete_av[3], *av;
+    char *interp = NULL, *reserve = NULL;
+    ElfW(auxv_t) new_av[12], delete_av[3], *av;
     struct wld_link_map main_binary_map, ld_so_map;
     struct wine_preload_info **wine_main_preload_info;
 
@@ -1176,7 +1176,9 @@
     while (*p)
     {
         static const char res[] = "WINEPRELOADRESERVE=";
+        static const char elfld[] = "WINEELFLOADER=";
         if (!wld_strncmp( *p, res, sizeof(res)-1 )) reserve = *p + sizeof(res) - 1;
+        if (!wld_strncmp( *p, elfld, sizeof(elfld)-1 )) interp = *p + sizeof(elfld) - 1;
         p++;
     }
 
@@ -1224,7 +1226,8 @@
     map_so_lib( argv[1], &main_binary_map );
 
     /* load the ELF interpreter */
-    interp = (char *)main_binary_map.l_addr + main_binary_map.l_interp;
+    if (!interp)
+      interp = (char *)main_binary_map.l_addr + main_binary_map.l_interp;
     map_so_lib( interp, &ld_so_map );
 
     /* store pointer to the preload info into the appropriate main binary variable */
diff --git a/server/main.c b/server/main.c
index 7aed338..2ec98b9 100644
--- a/server/main.c
+++ b/server/main.c
@@ -41,7 +41,7 @@
 /* command-line options */
 int debug_level = 0;
 int foreground = 0;
-timeout_t master_socket_timeout = 3 * -TICKS_PER_SEC;  /* master socket timeout, default is 3 seconds */
+timeout_t master_socket_timeout = 0;
 const char *server_argv0;
 
 /* parse-line args */