From addd527e11aede788a91c46533d1a04c2f114b9a Mon Sep 17 00:00:00 2001 From: Adam Dickmeiss Date: Mon, 23 Oct 2006 11:37:10 +0000 Subject: [PATCH 1/1] Fixed bug #529: multiple simultaneous updates by extended services trashes register files. This bug is already fixed in Zebra 2. util/flock.c is a back port of Zebra 2's revision 1.18. --- NEWS | 3 + configure.in | 4 +- include/zebra-flock.h | 7 +- index/zebraapi.c | 4 +- util/.cvsignore | 4 + util/Makefile.am | 6 +- util/flock.c | 345 ++++++++++++++++++++++++++++++++++++++++++------- util/tstflock.c | 272 ++++++++++++++++++++++++++++++++++++++ 8 files changed, 590 insertions(+), 55 deletions(-) create mode 100644 util/tstflock.c diff --git a/NEWS b/NEWS index dc65fed..13f44de 100644 --- a/NEWS +++ b/NEWS @@ -1,3 +1,6 @@ +Fixed bug #529: multiple simultaneous updates by extended services trashes +register files. + --- 1.3.42 2006/10/16 Fixed bug #47: Commit needs to check for roll-back. diff --git a/configure.in b/configure.in index dd3f75e..e61f7bf 100644 --- a/configure.in +++ b/configure.in @@ -1,5 +1,5 @@ dnl Zebra, Index Data Aps, 1995-2006 -dnl $Id: configure.in,v 1.91.2.30 2006-10-16 11:02:09 adam Exp $ +dnl $Id: configure.in,v 1.91.2.31 2006-10-23 11:37:10 adam Exp $ dnl AC_INIT(include/zebraver.h) AM_INIT_AUTOMAKE(idzebra,1.3.42) @@ -85,7 +85,7 @@ else fi dnl dnl ------ times -AC_CHECK_HEADERS(sys/times.h) +AC_CHECK_HEADERS(sys/times.h sys/time.h) dnl dnl ------ crypt AC_CHECK_LIB(crypt, crypt) diff --git a/include/zebra-flock.h b/include/zebra-flock.h index 48e99b5..c6904ab 100644 --- a/include/zebra-flock.h +++ b/include/zebra-flock.h @@ -1,4 +1,4 @@ -/* $Id: zebra-flock.h,v 1.1.2.2 2006-08-14 10:38:56 adam Exp $ +/* $Id: zebra-flock.h,v 1.1.2.3 2006-10-23 11:37:10 adam Exp $ Copyright (C) 1995-2005 Index Data ApS @@ -27,7 +27,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA YAZ_BEGIN_CDECL -typedef struct zebra_lock_info *ZebraLockHandle; +typedef struct zebra_lock_handle *ZebraLockHandle; YAZ_EXPORT ZebraLockHandle zebra_lock_create(const char *dir, const char *file); @@ -45,6 +45,9 @@ int zebra_lock_w (ZebraLockHandle h); YAZ_EXPORT int zebra_lock_r (ZebraLockHandle h); +YAZ_EXPORT +void zebra_flock_init(void); + YAZ_END_CDECL #endif diff --git a/index/zebraapi.c b/index/zebraapi.c index eebf263..b9b6210 100644 --- a/index/zebraapi.c +++ b/index/zebraapi.c @@ -1,4 +1,4 @@ -/* $Id: zebraapi.c,v 1.120.2.16 2006-10-12 13:05:59 adam Exp $ +/* $Id: zebraapi.c,v 1.120.2.17 2006-10-23 11:37:11 adam Exp $ Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004 Index Data Aps @@ -152,6 +152,8 @@ ZebraService zebra_start_res (const char *configName, Res def_res, Res over_res) yaz_log(LOG_LOG,"zebra_start %s %s", configName, ZEBRAVER); + zebra_flock_init(); + if ((res = res_open (configName, def_res, over_res))) { const char *passwd_plain = 0; diff --git a/util/.cvsignore b/util/.cvsignore index 99acd1c..16087d0 100644 --- a/util/.cvsignore +++ b/util/.cvsignore @@ -2,3 +2,7 @@ Makefile Makefile.in passtest +*.log +my.LCK +tstflock +tstflock.out diff --git a/util/Makefile.am b/util/Makefile.am index f03f3a8..bfcdab6 100644 --- a/util/Makefile.am +++ b/util/Makefile.am @@ -1,9 +1,11 @@ -## $Id: Makefile.am,v 1.8.2.1 2006-03-24 13:47:30 adam Exp $ +## $Id: Makefile.am,v 1.8.2.2 2006-10-23 11:37:11 adam Exp $ noinst_LIBRARIES = libutil.a noinst_PROGRAMS = passtest +check_PROGRAMS = tstflock + EXTRA_DIST = zebrasrv.rh AM_CPPFLAGS = -I$(srcdir)/../include $(YAZINC) -DDEFAULT_PROFILE_PATH=\"$(pkgdatadir)/tab\" @@ -12,3 +14,5 @@ LDADD = libutil.a $(YAZLIB) $(TCL_LIB) libutil_a_SOURCES = res.c flock.c charmap.c zebramap.c passwddb.c zebra-lock.c dirent.c xpath.c passtest_SOURCES = passtest.c + +tstflock_SOURCES = tstflock.c diff --git a/util/flock.c b/util/flock.c index 8972d97..01c702f 100644 --- a/util/flock.c +++ b/util/flock.c @@ -1,5 +1,5 @@ -/* $Id: flock.c,v 1.4.2.3 2006-08-14 10:39:24 adam Exp $ - Copyright (C) 1995-2005 +/* $Id: flock.c,v 1.4.2.4 2006-10-23 11:37:11 adam Exp $ + Copyright (C) 1995-2006 Index Data ApS This file is part of the Zebra server. @@ -35,130 +35,377 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA #include #endif +#include #include #include #include +/** have this module (mutex) been initialized? */ +static int initialized = 0; + +/** whether fcntl locks are shared for all threads in a process (POSIX) */ +static int posix_locks = 1; + +/** mutex for lock_list below */ +Zebra_mutex lock_list_mutex; + +/** our list of file locked files */ +static struct zebra_lock_info *lock_list = 0; + +/** the internal handle, with a pointer to each lock file info */ +struct zebra_lock_handle { +#ifndef WIN32 + /** so we can call zebra_lock_rdwr_wunlock or zebra_lock_lock_runlock */ + int write_flag; +#endif + struct zebra_lock_info *p; +}; + struct zebra_lock_info { + /** file descriptor */ int fd; + /** full path (xmalloc'ed) */ char *fname; + /** reference counter: number of zebra_lock_handles pointing to us */ + int ref_count; +#ifndef WIN32 + /** number of file write locks/read locks */ + int no_file_write_lock; + int no_file_read_lock; + Zebra_lock_rdwr rdwr_lock; + Zebra_mutex file_mutex; +#endif + /** next in lock list */ + struct zebra_lock_info *next; }; -static int log_level = 0 /* YLOG_LOG|YLOG_FLUSH */; +static int log_level = 0; -char *zebra_mk_fname (const char *dir, const char *name) +char *zebra_mk_fname(const char *dir, const char *name) { int dlen = dir ? strlen(dir) : 0; - char *fname = xmalloc (dlen + strlen(name) + 3); - + char *fname = xmalloc(dlen + strlen(name) + 3); + #ifdef WIN32 if (dlen) { int last_one = dir[dlen-1]; - - if (!strchr ("/\\:", last_one)) - sprintf (fname, "%s\\%s", dir, name); + + if (!strchr("/\\:", last_one)) + sprintf(fname, "%s\\%s", dir, name); else - sprintf (fname, "%s%s", dir, name); + sprintf(fname, "%s%s", dir, name); } else - sprintf (fname, "%s", name); + sprintf(fname, "%s", name); #else if (dlen) { int last_one = dir[dlen-1]; - if (!strchr ("/", last_one)) - sprintf (fname, "%s/%s", dir, name); + if (!strchr("/", last_one)) + sprintf(fname, "%s/%s", dir, name); else - sprintf (fname, "%s%s", dir, name); + sprintf(fname, "%s%s", dir, name); } else - sprintf (fname, "%s", name); + sprintf(fname, "%s", name); #endif return fname; } -ZebraLockHandle zebra_lock_create (const char *dir, const char *name) +ZebraLockHandle zebra_lock_create(const char *dir, const char *name) { char *fname = zebra_mk_fname(dir, name); - ZebraLockHandle h = (ZebraLockHandle) xmalloc (sizeof(*h)); + struct zebra_lock_info *p = 0; + ZebraLockHandle h = 0; + + assert(initialized); - h->fd = -1; + zebra_mutex_lock(&lock_list_mutex); + /* see if we have the same filename in a global list of "lock files" */ +#ifndef WIN32 + if (posix_locks) + { + for (p = lock_list; p ; p = p->next) + if (!strcmp(p->fname, fname)) + break; + } +#endif + if (!p) + { /* didn't match (or we didn't want it to match! */ + p = (struct zebra_lock_info *) xmalloc(sizeof(*p)); + + p->ref_count = 0; #ifdef WIN32 - h->fd = open (name, O_BINARY|O_RDONLY); - if (h->fd == -1) - h->fd = open (fname, (O_BINARY|O_CREAT|O_RDWR), 0666); + p->fd = open(name, O_BINARY|O_RDONLY); + if (p->fd == -1) + p->fd = open(fname, (O_BINARY|O_CREAT|O_RDWR), 0666); #else - h->fd= open (fname, (O_BINARY|O_CREAT|O_RDWR), 0666); + p->fd = open(fname, (O_BINARY|O_CREAT|O_RDWR), 0666); +#endif + if (p->fd == -1) + { + xfree(p); + logf(LOG_WARN | LOG_ERRNO, + "zebra_lock_create fail fname=%s", fname); + p = 0; + } + else + { + p->fname = fname; + fname = 0; /* fname buffer now owned by p->fname */ +#ifndef WIN32 + if (posix_locks) + zebra_lock_rdwr_init(&p->rdwr_lock); + + zebra_mutex_init(&p->file_mutex); + p->no_file_write_lock = 0; + p->no_file_read_lock = 0; #endif - if (h->fd == -1) + p->next = lock_list; + lock_list = p; + } + } + if (p) { - xfree (h); - h = 0; + /* we have lock info so we can make a handle pointing to that */ + p->ref_count++; + h = (ZebraLockHandle) xmalloc(sizeof(*h)); + h->p = p; +#ifndef WIN32 + h->write_flag = 0; +#endif + logf(log_level, "zebra_lock_create fd=%d p=%p fname=%s", + h->p->fd, h, p->fname); } - h->fname = fname; - yaz_log(log_level, "zebra_lock_create fd=%d p=%p fname=%s", h->fd, h, h->fname); + zebra_mutex_unlock(&lock_list_mutex); + xfree(fname); /* free it - if it's still there */ + return h; } -void zebra_lock_destroy (ZebraLockHandle h) +void zebra_lock_destroy(ZebraLockHandle h) { if (!h) return; - yaz_log(log_level, "zebra_lock_destroy fd=%d p=%p fname=%s", h->fd, h, h->fname); - if (h->fd != -1) - close (h->fd); - xfree (h->fname); - xfree (h); + logf(log_level, "zebra_lock_destroy fd=%d p=%p fname=%s", + h->p->fd, h, h->p->fname); + zebra_mutex_lock(&lock_list_mutex); + logf(log_level, "zebra_lock_destroy fd=%d p=%p fname=%s refcount=%d", + h->p->fd, h, h->p->fname, h->p->ref_count); + assert(h->p->ref_count > 0); + --(h->p->ref_count); + if (h->p->ref_count == 0) + { + /* must remove shared info from lock_list */ + struct zebra_lock_info **hp = &lock_list; + while (*hp) + { + if (*hp == h->p) + { + *hp = h->p->next; + break; + } + else + hp = &(*hp)->next; + } + + logf(log_level, "zebra_lock_destroy fd=%d p=%p fname=%s remove", + h->p->fd, h, h->p->fname); + +#ifndef WIN32 + if (posix_locks) + zebra_lock_rdwr_destroy(&h->p->rdwr_lock); + zebra_mutex_destroy(&h->p->file_mutex); +#endif + if (h->p->fd != -1) + close(h->p->fd); + xfree(h->p->fname); + xfree(h->p); + } + xfree(h); + zebra_mutex_unlock(&lock_list_mutex); } #ifndef WIN32 -static int unixLock (int fd, int type, int cmd) +static int unixLock(int fd, int type, int cmd) { struct flock area; + int r; area.l_type = type; area.l_whence = SEEK_SET; area.l_len = area.l_start = 0L; - return fcntl (fd, cmd, &area); + + logf(log_level, "fcntl begin type=%d fd=%d", type, fd); + r = fcntl(fd, cmd, &area); + if (r == -1) + logf(LOG_WARN|LOG_ERRNO, "fcntl FAIL type=%d fd=%d", type, fd); + else + logf(log_level, "fcntl type=%d OK fd=%d", type, fd); + + return r; } #endif -int zebra_lock_w (ZebraLockHandle h) +int zebra_lock_w(ZebraLockHandle h) { int r; - yaz_log(log_level, "zebra_lock_w fd=%d p=%p fname=%s", h->fd, h, h->fname); + int do_lock = 0; + logf(log_level, "zebra_lock_w fd=%d p=%p fname=%s begin", + h->p->fd, h, h->p->fname); + #ifdef WIN32 - while ((r = _locking (h->fd, _LK_LOCK, 1))) + while ((r = _locking(h->p->fd, _LK_LOCK, 1))) ; #else - r = unixLock (h->fd, F_WRLCK, F_SETLKW); + if (posix_locks) + zebra_lock_rdwr_wlock(&h->p->rdwr_lock); + + zebra_mutex_lock(&h->p->file_mutex); + if (h->p->no_file_write_lock == 0) + do_lock = 1; + h->p->no_file_write_lock++; + if (do_lock) + { + /* if there is already a read lock.. upgrade to write lock */ + r = unixLock(h->p->fd, F_WRLCK, F_SETLKW); + } + else + { + assert(posix_locks); + } + zebra_mutex_unlock(&h->p->file_mutex); + + h->write_flag = 1; #endif - yaz_log(log_level, "zebra_lock_w fd=%d p=%p fname=%s OK", h->fd, h, h->fname); + logf(log_level, "zebra_lock_w fd=%d p=%p fname=%s end", + h->p->fd, h, h->p->fname); + return r; } -int zebra_lock_r (ZebraLockHandle h) +int zebra_lock_r(ZebraLockHandle h) { int r; - yaz_log(log_level, "zebra_lock_r fd=%d p=%p fname=%s", h->fd, h, h->fname); + int do_lock = 0; + + logf(log_level, "zebra_lock_r fd=%d p=%p fname=%s begin", + h->p->fd, h, h->p->fname); #ifdef WIN32 - while ((r = _locking (h->fd, _LK_LOCK, 1))) + while ((r = _locking(h->p->fd, _LK_LOCK, 1))) ; #else - r = unixLock (h->fd, F_RDLCK, F_SETLKW); + if (posix_locks) + zebra_lock_rdwr_rlock(&h->p->rdwr_lock); + + zebra_mutex_lock(&h->p->file_mutex); + if (h->p->no_file_read_lock == 0 && h->p->no_file_write_lock == 0) + do_lock = 1; + h->p->no_file_read_lock++; + if (do_lock) + { + /* only read lock if no write locks already */ + r = unixLock(h->p->fd, F_RDLCK, F_SETLKW); + } + else + { + assert(posix_locks); + } + zebra_mutex_unlock(&h->p->file_mutex); + + h->write_flag = 0; #endif - yaz_log(log_level, "zebra_lock_r fd=%d p=%p fname=%s OK", h->fd, h, h->fname); + logf(log_level, "zebra_lock_r fd=%d p=%p fname=%s end", + h->p->fd, h, h->p->fname); return r; } -int zebra_unlock (ZebraLockHandle h) +int zebra_unlock(ZebraLockHandle h) { - yaz_log(log_level, "zebra_unlock fd=%d p=%p fname=%s", h->fd, h, h->fname); + int r = 0; + logf(log_level, "zebra_unlock fd=%d p=%p fname=%s begin", + h->p->fd, h, h->p->fname); #ifdef WIN32 - return _locking (h->fd, _LK_UNLCK, 1); + r = _locking(h->p->fd, _LK_UNLCK, 1); #else - return unixLock (h->fd, F_UNLCK, F_SETLKW); + zebra_mutex_lock(&h->p->file_mutex); + if (h->write_flag) + { + if (h->p->no_file_write_lock > 0) + h->p->no_file_write_lock--; + } + else + { + if (h->p->no_file_read_lock > 0) + h->p->no_file_read_lock--; + } + if (h->p->no_file_read_lock == 0 && h->p->no_file_write_lock == 0) + r = unixLock(h->p->fd, F_UNLCK, F_SETLKW); + else + { + r = 0; + assert(posix_locks); + } + + zebra_mutex_unlock(&h->p->file_mutex); + + if (posix_locks) + { + if (h->write_flag) + zebra_lock_rdwr_wunlock(&h->p->rdwr_lock); + else + zebra_lock_rdwr_runlock(&h->p->rdwr_lock); + } #endif + logf(log_level, "zebra_unlock fd=%d p=%p fname=%s end", + h->p->fd, h, h->p->fname); + return r; } +/** \brief see if the fcntl locking is not POSIX + * + * The default posix_locks=1 is assumed.. This function sets posix_locks + * to zero if linuxthreads is in use. + */ +static int check_for_linuxthreads() +{ +#if __linux +#ifdef _CS_GNU_LIBPTHREAD_VERSION + char conf_buf[512]; + size_t r = confstr(_CS_GNU_LIBPTHREAD_VERSION, conf_buf, sizeof(conf_buf)); + if (r == 0) + { + logf(LOG_WARN|LOG_ERRNO, "confstr failed"); + return -1; + } + if (strncmp(conf_buf, "linuxthreads", 12) == 0) + posix_locks = 0; /* Using linuxthreads.. */ +#else + posix_locks = 0; /* Old GLIBC on Linux. Assume linuxthreads */ +#endif +#endif + return 0; +} + +void zebra_flock_init() +{ + if (!initialized) + { + initialized = 1; + log_level = yaz_log_module_level("flock"); + logf(log_level, "zebra_flock_init"); + check_for_linuxthreads(); + zebra_mutex_init(&lock_list_mutex); + logf(log_level, "posix_locks: %d", posix_locks); + } +} + +/* + * Local variables: + * c-basic-offset: 4 + * indent-tabs-mode: nil + * End: + * vim: shiftwidth=4 tabstop=8 expandtab + */ + diff --git a/util/tstflock.c b/util/tstflock.c new file mode 100644 index 0000000..d44b7a8 --- /dev/null +++ b/util/tstflock.c @@ -0,0 +1,272 @@ +/* $Id: tstflock.c,v 1.16.2.1 2006-10-23 11:37:11 adam Exp $ + Copyright (C) 1995-2006 + Index Data ApS + +This file is part of the Zebra server. + +Zebra is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 2, or (at your option) any later +version. + +Zebra is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +*/ + +#include +#include +#include +#include +#if HAVE_SYS_TIME_H +#include +#endif +#include + +#if HAVE_SYS_STAT_H +#include +#endif +#if HAVE_SYS_TYPES_H +#include +#endif +#if HAVE_UNISTD_H +#include +#endif +#if HAVE_SYS_WAIT_H +#include +#endif + +#include + +#ifdef WIN32 +#include +#endif + +#if YAZ_POSIX_THREADS +#include +#endif +#ifdef WIN32 +#include +#include +#endif + +#include +#include + +static char seq[1000]; +static char *seqp = 0; + +#define NUM_THREADS 100 + +#if YAZ_POSIX_THREADS +pthread_cond_t sleep_cond = PTHREAD_COND_INITIALIZER; +pthread_mutex_t sleep_mutex = PTHREAD_MUTEX_INITIALIZER; +#endif + +int test_fd = 0; + +static void small_sleep() +{ +#ifdef WIN32 + Sleep(2); +#else +#if YAZ_POSIX_THREADS + struct timespec abstime; + struct timeval now; + + gettimeofday(&now, 0); + abstime.tv_sec = now.tv_sec; + abstime.tv_nsec = 1000000 + now.tv_usec * 1000; + if (abstime.tv_nsec > 1000000000) /* 1s = 1e9 ns */ + { + abstime.tv_nsec -= 1000000000; + abstime.tv_sec++; + } + pthread_mutex_lock(&sleep_mutex); + pthread_cond_timedwait(&sleep_cond, &sleep_mutex, &abstime); + pthread_mutex_unlock(&sleep_mutex); +#endif +#endif +} + +void *run_func(void *arg) +{ + int i; + int *pdata = (int*) arg; + int use_write_lock = *pdata; + ZebraLockHandle lh = zebra_lock_create(0, "my.LCK"); + for (i = 0; i<2; i++) + { + int write_lock = use_write_lock; + + if (use_write_lock == 2) /* random lock */ + write_lock = (rand() & 3) == 3 ? 1 : 0; + + if (write_lock) + { + zebra_lock_w(lh); + + write(test_fd, "L", 1); + *seqp++ = 'L'; + small_sleep(); + *seqp++ = 'U'; + write(test_fd, "U", 1); + + zebra_unlock(lh); + } + else + { + zebra_lock_r(lh); + + write(test_fd, "l", 1); + *seqp++ = 'l'; + small_sleep(); + *seqp++ = 'u'; + write(test_fd, "u", 1); + + zebra_unlock(lh); + } + } + zebra_lock_destroy(lh); + *pdata = 123; + return 0; +} + +#ifdef WIN32 +DWORD WINAPI ThreadProc(void *p) +{ + run_func(p); + return 0; +} +#endif + +static void tst_thread(int num, int write_flag) +{ +#ifdef WIN32 + HANDLE handles[NUM_THREADS]; + DWORD dwThreadId[NUM_THREADS]; +#endif +#if YAZ_POSIX_THREADS + pthread_t child_thread[NUM_THREADS]; +#endif + int i, id[NUM_THREADS]; + + seqp = seq; + assert (num <= NUM_THREADS); + for (i = 0; i < num; i++) + { + id[i] = write_flag; +#if YAZ_POSIX_THREADS + pthread_create(&child_thread[i], 0 /* attr */, run_func, &id[i]); +#endif +#ifdef WIN32 + if (1) + { + void *pData = &id[i]; + handles[i] = CreateThread( + NULL, /* default security attributes */ + 0, /* use default stack size */ + ThreadProc, /* thread function */ + pData, /* argument to thread function */ + 0, /* use default creation flags */ + &dwThreadId[i]); /* returns the thread identifier */ + } + +#endif + } +#if YAZ_POSIX_THREADS + for (i = 0; i