# HG changeset patch # User bears # Date 980429911 0 # Node ID 8ea6b5ddc5a5af35acc2c925c1857bdbc169b559 # Parent 94f2e5607772752090562d87c8f2e7e040141172 [svn] * src/lock.h,src/lock.c,src/noffle.c: Add lazy lock release. Only release the lock and close the databases if (a) another process signals us SIGUSR1 indicating it wants the lock, or (b) it is explicitly requested by a call to new function Lock_syncDatabases(). When waiting for the lock, SIGUSR1 the holding process every second. This is all an attempt to minimise the number of times we need to close and open the database. When (ha!) the database is replaced by something that can handle multiple simultaneous writers (with appropriate locking) this won't be necessary. diff -r 94f2e5607772 -r 8ea6b5ddc5a5 ChangeLog --- a/ChangeLog Thu Jan 25 11:00:03 2001 +0000 +++ b/ChangeLog Thu Jan 25 13:38:31 2001 +0000 @@ -1,3 +1,19 @@ +Thu Jan 25 2001 Jim Hague + + * src/client.c,src/protocol.c,src/util.h,src/util.c: Common up + repeated signal handler setting code into Utl_installSignalHandler. + * src/client.c: Ensure Client_retrieveArt always exits with the global + lock held. Previously it would be held on error, not held if OK. + * src/lock.h,src/lock.c,src/noffle.c: Add lazy lock release. Only release + the lock and close the databases if (a) another process signals us + SIGUSR1 indicating it wants the lock, or (b) it is explicitly requested by + a call to new function Lock_syncDatabases(). When waiting for the lock, + SIGUSR1 the holding process every second. This is all an attempt to + minimise the number of times we need to close and open the database. + When (ha!) the database is replaced by something that can handle + multiple simultaneous writers (with appropriate locking) this won't + be necessary. + Fri Dec 29 2000 Markus Enzenberger * src/server.c: apply bug-fix for lazy group loading by Matija Nalis @@ -30,7 +46,7 @@ packages/redhat/noffle.spec,src/configfile.h,src/configfile.c, src/noffle.c,src/post.h,src/post.c: Removed use of getopt_long, and added inews mode - the Noffle executable behaves - as inews is invoked as inews. This includes adding From: and + as inews if invoked as inews. This includes adding From: and Organization: headers if necessary - add configs to override defaults for the From: domain and specify the organization. For all my fellow trn-heads out there, and users of any other diff -r 94f2e5607772 -r 8ea6b5ddc5a5 src/lock.c --- a/src/lock.c Thu Jan 25 11:00:03 2001 +0000 +++ b/src/lock.c Thu Jan 25 13:38:31 2001 +0000 @@ -1,7 +1,7 @@ /* lock.c - $Id: lock.c 183 2000-07-25 12:14:54Z bears $ + $Id: lock.c 249 2001-01-25 13:38:31Z bears $ */ #if HAVE_CONFIG_H @@ -15,6 +15,7 @@ #include #include #include +#include #if TIME_WITH_SYS_TIME #include @@ -34,16 +35,47 @@ #include "group.h" #include "request.h" #include "portable.h" +#include "util.h" struct Lock { const char *name; int lockFd; Str lockFile; + Bool doLazyLocking; + volatile Bool lazyClose; + volatile Bool lazyLockBusy; }; -struct Lock globalLock = { "global", -1, "" }; -struct Lock fetchLock = { "fetch", -1, "" }; +static struct Lock globalLock = { "global", -1, "", TRUE }; +static struct Lock fetchLock = { "fetch", -1, "", FALSE }; + +static sig_t oldHandler = NULL; + +/* Block/unblock SIGUSR1. */ +static Bool +blockSignal( Bool block ) +{ + sigset_t sigs; + + sigemptyset(&sigs); + sigaddset(&sigs, SIGUSR1); + + for(;;) + { + if ( sigprocmask( block ? SIG_BLOCK : SIG_UNBLOCK, &sigs, NULL ) != 0 ) + { + if ( errno != EINTR ) + { + Log_err( "Can't block/unblock signal" ); + return FALSE; + } + } + else + return TRUE; + } + /* NOTREACHED */ +} /* Check the global lock held. */ static Bool @@ -52,6 +84,14 @@ return ( lock->lockFd != -1 ); } +static void +lockWaitAlarm( int sig ) +{ + UNUSED( sig ); + + return; +} + static Bool waitLock( struct Lock *lock, enum LockRequestWait wait ) { @@ -74,12 +114,37 @@ l.l_len = 0; if ( wait == LOCK_WAIT ) { - if ( fcntl( fd, F_SETLKW, &l ) < 0 ) + sig_t oldAlarmHandler; + unsigned oldAlarm; + + oldAlarmHandler = Utl_installSignalHandler( SIGALRM, lockWaitAlarm ); + oldAlarm = alarm( 1 ); + for(;;) { - Log_err( "Cannot lock %s: %s", lock->lockFile, strerror( errno ) ); - close( lock->lockFd ); - return FALSE; + alarm( 1 ); + if ( fcntl( fd, F_SETLKW, &l ) < 0 ) + if ( errno != EINTR ) + { + Utl_installSignalHandler( SIGALRM, oldAlarmHandler ); + alarm( oldAlarm ); + Log_err( "Cannot lock %s: %s", lock->lockFile, + strerror( errno ) ); + close( lock->lockFd ); + return FALSE; + } + else + { + /* Send SIGUSR1 to the process holding the lock. */ + if ( fcntl( fd, F_GETLK, &l) == 0 && l.l_type != F_UNLCK ) + if ( kill( l.l_pid, SIGUSR1 ) < 0 ) + Log_err( "Can't signal process %d: %s", l.l_pid, + strerror( errno ) ); + } + else + break; } + Utl_installSignalHandler( SIGALRM, oldAlarmHandler ); + alarm( oldAlarm ); } else { @@ -113,11 +178,10 @@ Log_dbg( "Releasing lock" ); } - -/* Open all databases and set global lock. */ -Bool -Lock_openDatabases( void ) +static Bool +openDatabases( void ) { + globalLock.lazyClose = FALSE; if ( ! waitLock( &globalLock, LOCK_WAIT ) ) { Log_err( "Could not get write lock" ); @@ -145,25 +209,98 @@ return FALSE; } + globalLock.lazyClose = globalLock.doLazyLocking; + globalLock.lazyLockBusy = TRUE; return TRUE; } +static void +closeDatabases( void ) +{ + Grp_close(); + Db_close(); + Req_close(); + releaseLock( &globalLock ); + globalLock.lazyLockBusy = FALSE; + globalLock.lazyClose = FALSE; +} + +static void +lockSignal( int sig ) +{ + UNUSED( sig ); + + if ( globalLock.lazyLockBusy ) + globalLock.lazyClose = FALSE; + else + closeDatabases(); + return; +} + +/* Open all databases and set global lock. */ +Bool +Lock_openDatabases( void ) +{ + Bool res; + + /* First time - need to initialise signal handler? */ + if ( oldHandler == NULL ) + oldHandler = Utl_installSignalHandler( SIGUSR1, lockSignal ); + + if ( ! blockSignal( TRUE ) ) + return FALSE; + + if ( ! globalLock.lazyClose ) + res = openDatabases(); + else + res = TRUE; + + globalLock.lazyLockBusy = res; + + if ( ! blockSignal( FALSE ) ) + return FALSE; + + return res; +} /* Close all databases and release global lock. */ void Lock_closeDatabases( void ) { - Grp_close(); - Db_close(); - Req_close(); - releaseLock( &globalLock ); + blockSignal( TRUE ); + + if ( ! globalLock.lazyClose ) + closeDatabases(); + else + globalLock.lazyLockBusy = FALSE; + + blockSignal( FALSE ); +} + +/* Sync al databases to disc. Maintain global lock status. */ +void +Lock_syncDatabases( void ) +{ + Bool wasOpen; + + if ( gotLock( &globalLock ) ) + { + blockSignal( TRUE ); + + wasOpen = globalLock.lazyLockBusy; + closeDatabases(); + if ( wasOpen ) + openDatabases(); + + blockSignal( FALSE ); + } } /* Check the global lock held. */ Bool Lock_gotLock( void ) { - return gotLock( &globalLock ); + return globalLock.lazyLockBusy; } /* Get fetch lock. */ diff -r 94f2e5607772 -r 8ea6b5ddc5a5 src/lock.h --- a/src/lock.h Thu Jan 25 11:00:03 2001 +0000 +++ b/src/lock.h Thu Jan 25 13:38:31 2001 +0000 @@ -5,7 +5,7 @@ articla database, groups database, outgoing articles database, requests database. Handles global lock. - $Id: lock.h 183 2000-07-25 12:14:54Z bears $ + $Id: lock.h 249 2001-01-25 13:38:31Z bears $ */ #ifndef LOCK_H @@ -27,6 +27,10 @@ void Lock_closeDatabases( void ); +/* Ensure all databases synced to disc. */ +void +Lock_syncDatabases( void ); + /* Check the global lock held. */ Bool Lock_gotLock( void ); diff -r 94f2e5607772 -r 8ea6b5ddc5a5 src/noffle.c --- a/src/noffle.c Thu Jan 25 11:00:03 2001 +0000 +++ b/src/noffle.c Thu Jan 25 13:38:31 2001 +0000 @@ -10,7 +10,7 @@ received for some seconds (to allow multiple clients connect at the same time). - $Id: noffle.c 227 2000-10-26 21:21:13Z bears $ + $Id: noffle.c 249 2001-01-25 13:38:31Z bears $ */ #if HAVE_CONFIG_H @@ -598,6 +598,7 @@ { if ( noffle.lockAtStartup ) Lock_closeDatabases(); + Lock_syncDatabases(); } static RETSIGTYPE @@ -605,6 +606,10 @@ { Log_err( "Received SIGSEGV. Please submit a bug report" ); signal( SIGSEGV, SIG_DFL ); + + /* Attempt to save database state before passing on sig. */ + Lock_syncDatabases(); + raise( sig ); } @@ -636,6 +641,10 @@ else Log_inf( "Received signal %i (%s). Aborting.", sig, name ); signal( sig, SIG_DFL ); + + /* Attempt to save database state before passing on sig. */ + Lock_syncDatabases(); + raise( sig ); }