shm_regex lib: locks added around the regular expression

The libc locks moved to shared memory did not work on
multi-cpu machines.
Credit goes to Stefan Keller (stefan.keller at isaco.de) for
identifying the problem and for the patch.

"The code hangs in regexec() when trying to acquire the lock.
... It turns out this only happens if
the machine has more than one physical CPU core.
Reproducable on x86_64 with two CPU cores, glibc 2.3.6 (from Debian
Etch) and glibc 2.11.1 (from Ubuntu Lucid)."

lib/shm_regex/Makefile

@@ -8,6 +8,7 @@ NAME:=ser_shm_regex
 MAJOR_VER=0
 MINOR_VER=1
 BUGFIX_VER=0
+INCLUDES= -I$(CURDIR)/../..
 LIBS=
 
 include ../../Makefile.libs

lib/shm_regex/shm_regex.c

@@ -27,6 +27,8 @@
  * History
  * -------
  *  2009-04-03	Initial version (Miklos)
+ *  2010-04-25  Use own struct with locking to work-around libc locking failure
+ *              on multi-core hw (skeller)
  */
 
 #include <malloc.h>	/* hook prototypes */
@@ -75,32 +77,37 @@ static void shm_free_hook(void *ptr, const void *caller)
 		__free_hook = orig_free_hook; \
 	} while (0)
 
-int shm_regcomp(regex_t *preg, const char *regex, int cflags)
+int shm_regcomp(shm_regex_t *preg, const char *regex, int cflags)
 {
 	malloc_hook_t	*orig_malloc_hook;
 	realloc_hook_t	*orig_realloc_hook;
 	free_hook_t	*orig_free_hook;
 	int		ret;
 
+	if(!lock_init(&preg->lock)) {
+		return REG_EEND;
+	}
 	replace_malloc_hooks();
-	ret = regcomp(preg, regex, cflags);
+	ret = regcomp(&preg->regexp, regex, cflags);
 	restore_malloc_hooks();
 
+	if(ret) lock_destroy(&preg->lock);
+
 	return ret;
 }
 
-void shm_regfree(regex_t *preg)
+void shm_regfree(shm_regex_t *preg)
 {
 	malloc_hook_t	*orig_malloc_hook;
 	realloc_hook_t	*orig_realloc_hook;
 	free_hook_t	*orig_free_hook;
-
+	lock_destroy(&preg->lock);
 	replace_malloc_hooks();
-	regfree(preg);
+	regfree(&preg->regexp);
 	restore_malloc_hooks();
 }
 
-int shm_regexec(const regex_t *preg, const char *string, size_t nmatch,
+int shm_regexec(shm_regex_t *preg, const char *string, size_t nmatch,
                    regmatch_t pmatch[], int eflags)
 {
 	malloc_hook_t	*orig_malloc_hook;
@@ -118,12 +125,24 @@ int shm_regexec(const regex_t *preg, const char *string, size_t nmatch,
 	 * It is safe to call regexec() concurrently without locking,
 	 * because regexec() has its own locks.
 	 * (Miklos)
+	 *
+	 * Those locks, however, don't work with shm and multi-core hardware
+	 * causing a dead-lock. Tested with glibc 2.3.6. (skeller)
 	 */
+
+	lock_get(&preg->lock);
 	replace_malloc_hooks();
-	ret = regexec(preg, string, nmatch,
+	ret = regexec(&preg->regexp, string, nmatch,
 			pmatch, eflags);
 	restore_malloc_hooks();
-	
+	lock_release(&preg->lock);
+
 	return ret;
 }
 
+size_t shm_regerror(int errcode, const shm_regex_t *preg, char *errbuf,
+                      size_t errbuf_size)
+{
+	return regerror(errcode, &preg->regexp, errbuf, errbuf_size);
+}
+

lib/shm_regex/shm_regex.h

@@ -27,6 +27,8 @@
  * History
  * -------
  *  2009-04-03	Initial version (Miklos)
+ *  2010-04-25  Use own struct with locking to work-around libc locking failure
+ *              on multi-core hw (skeller)
  */
 
 #ifndef _SHM_REGEX_H
@@ -34,12 +36,18 @@
 
 #include <sys/types.h>
 #include <regex.h>
+#include "locking.h"
 
-int shm_regcomp(regex_t *preg, const char *regex, int cflags);
-void shm_regfree(regex_t *preg);
-int shm_regexec(const regex_t *preg, const char *string, size_t nmatch,
-                   regmatch_t pmatch[], int eflags);
+typedef struct shm_regex {
+	regex_t regexp;
+	gen_lock_t lock;
+} shm_regex_t;
 
-#define shm_regerror	regerror
+int shm_regcomp(shm_regex_t *preg, const char *regex, int cflags);
+void shm_regfree(shm_regex_t *preg);
+int shm_regexec(shm_regex_t *preg, const char *string, size_t nmatch,
+                   regmatch_t pmatch[], int eflags);
+size_t shm_regerror(int errcode, const shm_regex_t *preg, char *errbuf,
+                      size_t errbuf_size);
 
 #endif /* _SHM_REGEX_H */