X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fhousekeeping.c;h=54cfe11b83fa0888917d8c384c683ef4844748cb;hb=2e4e67a1f7f65568abace99d13a71024ad06ebde;hp=c0eb5d2cccdda472967732f5b62dab1a1b2ffc6b;hpb=4d2ba3513d914336f68942ec89117941c081af9d;p=citadel.git diff --git a/citadel/housekeeping.c b/citadel/housekeeping.c index c0eb5d2cc..54cfe11b8 100644 --- a/citadel/housekeeping.c +++ b/citadel/housekeeping.c @@ -1,122 +1,89 @@ /* - * $Id$ - * * This file contains miscellaneous housekeeping tasks. * + * Copyright (c) 1987-2021 by the citadel.org team + * + * This program is open source software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 3. + * + * This program 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. */ -#ifdef DLL_EXPORT -#define IN_LIBCIT -#endif - -#include "sysdep.h" -#include -#include #include -#include - -#if TIME_WITH_SYS_TIME -# include -# include -#else -# if HAVE_SYS_TIME_H -# include -# else -# include -# endif -#endif - -#include -#include -#include -#include -#include -#ifdef HAVE_SYS_SELECT_H -#include -#endif -#include "tools.h" -#include "citadel.h" -#include "server.h" +#include + +#include "ctdl_module.h" #include "serv_extensions.h" -#include "citserver.h" -#include "config.h" -#include "housekeeping.h" -#include "sysdep_decls.h" #include "room_ops.h" -#include "database.h" - - - - -/* - * Terminate idle sessions. This function pounds through the session table - * comparing the current time to each session's time-of-last-command. If an - * idle session is found it is terminated, then the search restarts at the - * beginning because the pointer to our place in the list becomes invalid. - */ -void terminate_idle_sessions(void) { - struct CitContext *ccptr; - time_t now; - int session_to_kill; - int killed = 0; - - now = time(NULL); - session_to_kill = 0; - begin_critical_section(S_SESSION_TABLE); - for (ccptr = ContextList; ccptr != NULL; ccptr = ccptr->next) { - if ( (ccptr!=CC) - && (config.c_sleeping > 0) - && (now - (ccptr->lastcmd) > config.c_sleeping) ) { - ccptr->kill_me = 1; - ++killed; - } - } - end_critical_section(S_SESSION_TABLE); - lprintf(9, "Terminated %d idle sessions\n", killed); -} - - +#include "internet_addressing.h" +#include "config.h" +#include "journaling.h" +#include "citadel_ldap.h" void check_sched_shutdown(void) { if ((ScheduledShutdown == 1) && (ContextList == NULL)) { - lprintf(3, "Scheduled shutdown initiating.\n"); - time_to_die = 1; + syslog(LOG_NOTICE, "housekeeping: scheduled shutdown initiating"); + server_shutting_down = 1; } } - /* * Check (and fix) floor reference counts. This doesn't need to be done * very often, since the counts should remain correct during normal operation. - * NOTE: this function pair should ONLY be called during startup. It is NOT - * thread safe. */ -void check_ref_counts_backend(struct quickroom *qrbuf, void *data) { - struct floor flbuf; +void check_ref_counts_backend(struct ctdlroom *qrbuf, void *data) { - getfloor(&flbuf, qrbuf->QRfloor); - ++flbuf.f_ref_count; - flbuf.f_flags = flbuf.f_flags | QR_INUSE; - putfloor(&flbuf, qrbuf->QRfloor); + int *new_refcounts; + + new_refcounts = (int *) data; + + ++new_refcounts[(int)qrbuf->QRfloor]; } + void check_ref_counts(void) { struct floor flbuf; int a; - lprintf(7, "Checking floor reference counts\n"); + int new_refcounts[MAXFLOORS]; + + syslog(LOG_DEBUG, "housekeeping: checking floor reference counts"); for (a=0; a 0) { + flbuf.f_flags = flbuf.f_flags | QR_INUSE; + } + else { + flbuf.f_flags = flbuf.f_flags & ~QR_INUSE; + } + lputfloor(&flbuf, a); + syslog(LOG_DEBUG, "housekeeping: floor %d has %d rooms", a, new_refcounts[a]); + } +} + + +/* + * Provide hints as to whether we have any memory leaks + */ +void keep_an_eye_on_memory_usage(void) { + static void *original_brk = NULL; + if (!original_brk) original_brk = sbrk(0); // Remember the original program break so we can test for leaks + syslog(LOG_DEBUG, "original_brk=%lx, current_brk=%lx, addl=%ld", (long)original_brk, (long)sbrk(0), (long)(sbrk(0)-original_brk)); // FIXME not so noisy please +} + /* * This is the housekeeping loop. Worker threads come through here after @@ -124,29 +91,39 @@ void check_ref_counts(void) { * only allow housekeeping to execute once per minute, and we only allow one * instance to run at a time. */ +static int housekeeping_in_progress = 0; +static int housekeeping_disabled = 0; +static time_t last_timer = 0L; + void do_housekeeping(void) { - static int housekeeping_in_progress = 0; - static time_t last_timer = 0L; int do_housekeeping_now = 0; + int do_perminute_housekeeping_now = 0; time_t now; + if (housekeeping_disabled) { + return; + } + /* * We do it this way instead of wrapping the whole loop in an * S_HOUSEKEEPING critical section because it eliminates the need to * potentially have multiple concurrent mutexes in progress. */ begin_critical_section(S_HOUSEKEEPING); - now = time(NULL); - if ( (now - last_timer) > (time_t)60 ) { - if (housekeeping_in_progress == 0) { - do_housekeeping_now = 1; - housekeeping_in_progress = 1; - last_timer = time(NULL); - } + if (housekeeping_in_progress == 0) { + do_housekeeping_now = 1; + housekeeping_in_progress = 1; } end_critical_section(S_HOUSEKEEPING); - if (do_housekeeping_now == 0) { + now = time(NULL); + if ( (do_housekeeping_now == 0) && (!CtdlIsSingleUser()) ) { + if ( (now - last_timer) > (time_t)300 ) { + syslog(LOG_WARNING, + "housekeeping: WARNING: housekeeping loop has not run for %ld minutes. Is something stuck?", + ((now - last_timer) / 60) + ); + } return; } @@ -155,11 +132,60 @@ void do_housekeeping(void) { * loop. Everything below this point is real work. */ - cdb_check_handles(); /* suggested by Justin Case */ - PerformSessionHooks(EVT_TIMER); /* Run any timer hooks */ + if ( (now - last_timer) > (time_t)60 ) { + do_perminute_housekeeping_now = 1; + last_timer = time(NULL); + } + + /* First, do the "as often as needed" stuff... */ + JournalRunQueue(); + PerformSessionHooks(EVT_HOUSE); + + /* Then, do the "once per minute" stuff... */ + if (do_perminute_housekeeping_now) { + cdb_check_handles(); + PerformSessionHooks(EVT_TIMER); // Run all registered TIMER hooks + + // LDAP sync isn't in a module so we can put it here + static time_t last_ldap_sync = 0L; + if ( (now - last_ldap_sync) > (time_t)CtdlGetConfigLong("c_ldap_sync_freq") ) { + CtdlSynchronizeUsersFromLDAP(); + last_ldap_sync = time(NULL); + } + + keep_an_eye_on_memory_usage(); + } /* * All done. */ + begin_critical_section(S_HOUSEKEEPING); housekeeping_in_progress = 0; + end_critical_section(S_HOUSEKEEPING); +} + + +void CtdlDisableHouseKeeping(void) { + syslog(LOG_INFO, "housekeeping: trying to disable"); + while ( (!housekeeping_disabled) && (!server_shutting_down) && (!housekeeping_in_progress) ) { + + if (housekeeping_in_progress) { + sleep(1); + } + else { + begin_critical_section(S_HOUSEKEEPING); + if (!housekeeping_in_progress) { + housekeeping_disabled = 1; + } + end_critical_section(S_HOUSEKEEPING); + } + } + syslog(LOG_INFO, "housekeeping: disabled now"); +} + + +void CtdlEnableHouseKeeping(void) { + begin_critical_section(S_HOUSEKEEPING); + housekeeping_in_progress = 0; + end_critical_section(S_HOUSEKEEPING); }