X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fhousekeeping.c;h=108410af29a79a7924526d2f214ba5dea868ffea;hb=aa7365c86de8e26e796d3aa3fd605c85d8c26220;hp=8ede483c6497f60dabba23c9da7e68f4329aaccf;hpb=098337ce1d9d2c29e8e824fd8d2d650226c91138;p=citadel.git diff --git a/citadel/housekeeping.c b/citadel/housekeeping.c index 8ede483c6..108410af2 100644 --- a/citadel/housekeeping.c +++ b/citadel/housekeeping.c @@ -1,116 +1,164 @@ /* - * This file contains housekeeping tasks which periodically - * need to be executed. + * This file contains miscellaneous housekeeping tasks. * - * $Id$ + * Copyright (c) 1987-2011 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. */ +#include "sysdep.h" #include #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 +#include +#ifdef HAVE_SYS_SELECT_H +#include +#endif +#include +#include #include "citadel.h" #include "server.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" +#include "msgbase.h" +#include "journaling.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; - - do { - now = time(NULL); - session_to_kill = 0; - lprintf(9, "Scanning for timed out sessions...\n"); - 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) ) { - session_to_kill = ccptr->cs_pid; - } - } - end_critical_section(S_SESSION_TABLE); - lprintf(9, "...done scanning.\n"); - if (session_to_kill > 0) { - lprintf(3, "Session %d timed out. Terminating it...\n", - ccptr->cs_pid); - kill_session(ccptr->cs_pid); - lprintf(9, "...done terminating it.\n"); - } - } while(session_to_kill > 0); - } +#include "ctdl_module.h" +#include "threads.h" - -/* - * Main housekeeping function. This gets run whenever a session terminates. - */ -void do_housekeeping(void) { - - lprintf(9, "--- begin housekeeping ---\n"); - begin_critical_section(S_HOUSEKEEPING); - /* - * Terminate idle sessions. - */ - lprintf(7, "Calling terminate_idle_sessions()\n"); - terminate_idle_sessions(); - lprintf(9, "Done with terminate_idle_sessions()\n"); - - /* - * If the server is scheduled to shut down the next time all - * users are logged out, now's the time to do it. - */ +void check_sched_shutdown(void) { if ((ScheduledShutdown == 1) && (ContextList == NULL)) { - lprintf(3, "Scheduled shutdown initiating.\n"); - master_cleanup(); - } - end_critical_section(S_HOUSEKEEPING); - lprintf(9, "--- end housekeeping ---\n"); + syslog(LOG_NOTICE, "Scheduled shutdown initiating.\n"); + 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) { - struct floor flbuf; +void check_ref_counts_backend(struct ctdlroom *qrbuf, void *data) { - lgetfloor(&flbuf, qrbuf->QRfloor); - ++flbuf.f_ref_count; - flbuf.f_flags = flbuf.f_flags | QR_INUSE; - lputfloor(&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; + int new_refcounts[MAXFLOORS]; + + syslog(LOG_DEBUG, "Checking floor reference counts\n"); + 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, "Floor %d: %d rooms\n", a, new_refcounts[a]); + } +} - ForEachRoom(check_ref_counts_backend); - } +/* + * This is the housekeeping loop. Worker threads come through here after + * processing client requests but before jumping back into the pool. We + * 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 time_t last_timer = 0L; +void do_housekeeping(void) { + int do_housekeeping_now = 0; + int do_perminute_housekeeping_now = 0; + time_t now; + + /* + * 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); + if (housekeeping_in_progress == 0) { + do_housekeeping_now = 1; + housekeeping_in_progress = 1; + } + end_critical_section(S_HOUSEKEEPING); + if (do_housekeeping_now == 0) { + return; + } + + /* + * Ok, at this point we've made the decision to run the housekeeping + * loop. Everything below this point is real work. + */ + + now = time(NULL); + 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(); /* suggested by Justin Case */ + PerformSessionHooks(EVT_TIMER); /* Run any timer hooks */ + } + + /* + * All done. + */ + begin_critical_section(S_HOUSEKEEPING); + housekeeping_in_progress = 0; + end_critical_section(S_HOUSEKEEPING); +}