citadel/server/housekeeping.c

   1 // This file contains miscellaneous housekeeping tasks.
   2 //
   3 // Copyright (c) 1987-2021 by the citadel.org team
   4 //
   5 // This program is open source software.  Use, duplication, or disclosure
   6 // is subject to the terms of the GNU General Public License, version 3.
   7
   8
   9 #include <stdio.h>
  10 #include <libcitadel.h>
  11
  12 #include "ctdl_module.h"
  13 #include "serv_extensions.h"
  14 #include "room_ops.h"
  15 #include "internet_addressing.h"
  16 #include "config.h"
  17 #include "journaling.h"
  18 #include "citadel_ldap.h"
  19
  20 void check_sched_shutdown(void) {
  21         if ((ScheduledShutdown == 1) && (ContextList == NULL)) {
  22                 syslog(LOG_NOTICE, "housekeeping: scheduled shutdown initiating");
  23                 server_shutting_down = 1;
  24         }
  25 }
  26
  27
  28 // Check (and fix) floor reference counts.  This doesn't need to be done
  29 // very often, since the counts should remain correct during normal operation.
  30 void check_ref_counts_backend(struct ctdlroom *qrbuf, void *data) {
  31
  32         int *new_refcounts;
  33
  34         new_refcounts = (int *) data;
  35
  36         ++new_refcounts[(int)qrbuf->QRfloor];
  37 }
  38
  39
  40 void check_ref_counts(void) {
  41         struct floor flbuf;
  42         int a;
  43
  44         int new_refcounts[MAXFLOORS];
  45
  46         syslog(LOG_DEBUG, "housekeeping: checking floor reference counts");
  47         for (a=0; a<MAXFLOORS; ++a) {
  48                 new_refcounts[a] = 0;
  49         }
  50
  51         cdb_begin_transaction();
  52         CtdlForEachRoom(check_ref_counts_backend, (void *)new_refcounts );
  53         cdb_end_transaction();
  54
  55         for (a=0; a<MAXFLOORS; ++a) {
  56                 lgetfloor(&flbuf, a);
  57                 flbuf.f_ref_count = new_refcounts[a];
  58                 if (new_refcounts[a] > 0) {
  59                         flbuf.f_flags = flbuf.f_flags | QR_INUSE;
  60                 }
  61                 else {
  62                         flbuf.f_flags = flbuf.f_flags & ~QR_INUSE;
  63                 }
  64                 lputfloor(&flbuf, a);
  65                 syslog(LOG_DEBUG, "housekeeping: floor %d has %d rooms", a, new_refcounts[a]);
  66         }
  67 }
  68
  69
  70 // Provide hints as to whether we have any memory leaks
  71 void keep_an_eye_on_memory_usage(void) {
  72         static void *original_brk = NULL;
  73         if (!original_brk) original_brk = sbrk(0);      // Remember the original program break so we can test for leaks
  74         syslog(LOG_DEBUG, "original_brk=%lx, current_brk=%lx, addl=%ld", (long)original_brk, (long)sbrk(0), (long)(sbrk(0)-original_brk));
  75 }
  76
  77
  78 // This is the housekeeping loop.  Worker threads come through here after
  79 // processing client requests but before jumping back into the pool.  We
  80 // only allow housekeeping to execute once per minute, and we only allow one
  81 // instance to run at a time.
  82 static int housekeeping_in_progress = 0;
  83 static int housekeeping_disabled = 0;
  84 static time_t last_timer = 0L;
  85
  86 void do_housekeeping(void) {
  87         int do_housekeeping_now = 0;
  88         int do_perminute_housekeeping_now = 0;
  89         time_t now;
  90
  91         if (housekeeping_disabled) {
  92                 return;
  93         }
  94
  95         // We do it this way instead of wrapping the whole loop in an
  96         // S_HOUSEKEEPING critical section because it eliminates the need to
  97         // potentially have multiple concurrent mutexes in progress.
  98         begin_critical_section(S_HOUSEKEEPING);
  99         if (housekeeping_in_progress == 0) {
 100                 do_housekeeping_now = 1;
 101                 housekeeping_in_progress = 1;
 102         }
 103         end_critical_section(S_HOUSEKEEPING);
 104
 105         now = time(NULL);
 106         if ( (do_housekeeping_now == 0) && (!CtdlIsSingleUser()) && ((now - last_timer) > (time_t)3600) ) {
 107                 if ( (now - last_timer) > (time_t)3600 ) {
 108                         syslog(LOG_WARNING,
 109                                 "housekeeping: WARNING: housekeeping loop has not run for %ld minutes.  Is something stuck?",
 110                                 ((now - last_timer) / 60)
 111                         );
 112                 }
 113                 return;
 114         }
 115
 116         // Ok, at this point we've made the decision to run the housekeeping
 117         // loop.  Everything below this point is real work.
 118
 119         if ( (now - last_timer) > (time_t)60 ) {
 120                 do_perminute_housekeeping_now = 1;
 121                 last_timer = time(NULL);
 122         }
 123
 124         // First, do the "as often as needed" stuff...
 125         JournalRunQueue();
 126         PerformSessionHooks(EVT_HOUSE);
 127
 128         // Then, do the "once per minute" stuff...
 129         if (do_perminute_housekeeping_now) {
 130                 cdb_check_handles();
 131                 PerformSessionHooks(EVT_TIMER);         // Run all registered TIMER hooks
 132
 133                 // LDAP sync isn't in a module so we can put it here
 134                 static time_t last_ldap_sync = 0L;
 135                 if ( (now - last_ldap_sync) > (time_t)CtdlGetConfigLong("c_ldap_sync_freq") ) {
 136                         CtdlSynchronizeUsersFromLDAP();
 137                         last_ldap_sync = time(NULL);
 138                 }
 139
 140         keep_an_eye_on_memory_usage();
 141         }
 142
 143         // All done.
 144         begin_critical_section(S_HOUSEKEEPING);
 145         housekeeping_in_progress = 0;
 146         end_critical_section(S_HOUSEKEEPING);
 147 }
 148
 149
 150 void CtdlDisableHouseKeeping(void) {
 151         syslog(LOG_INFO, "housekeeping: trying to disable");
 152         while ( (!housekeeping_disabled) && (!server_shutting_down) && (!housekeeping_in_progress) ) {
 153
 154                 if (housekeeping_in_progress) {
 155                         sleep(1);
 156                 }
 157                 else {
 158                         begin_critical_section(S_HOUSEKEEPING);
 159                         if (!housekeeping_in_progress) {
 160                                 housekeeping_disabled = 1;
 161                         }
 162                         end_critical_section(S_HOUSEKEEPING);
 163                 }
 164         }
 165         syslog(LOG_INFO, "housekeeping: disabled now");
 166 }
 167
 168
 169 void CtdlEnableHouseKeeping(void) {
 170         begin_critical_section(S_HOUSEKEEPING);
 171         housekeeping_in_progress = 0;
 172         end_critical_section(S_HOUSEKEEPING);
 173 }