From 69af412d42acccac660037e1f4026a6a6717634c Mon Sep 17 00:00:00 2001

From: Mark Reynolds <mreynolds@redhat.com>

Date: Thu, 17 Dec 2020 15:25:42 -0500

Subject: [PATCH 2/2] Issue 4384 - Separate eventq into REALTIME and MONOTONIC

Description:  The recent changes to the eventq "when" time changed

              internally from REALTIME to MONOTONIC, and this broke

              the API.  Create a new API for MONOTONIC clocks, and

              keep the original API intact for REALTIME clocks.

Relates:  https://github.com/389ds/389-ds-base/issues/4384

Reviewed by: firstyear(Thanks!)

---

 Makefile.am                                   |   1 +

 docs/slapi.doxy.in                            |   1 -

 ldap/servers/plugins/chainingdb/cb_instance.c |   6 +-

 ldap/servers/plugins/dna/dna.c                |   4 +-

 .../plugins/replication/repl5_backoff.c       |  12 +-

 .../plugins/replication/repl5_connection.c    |  10 +-

 .../plugins/replication/repl5_mtnode_ext.c    |   4 +-

 .../plugins/replication/repl5_replica.c       |  24 +-

 .../plugins/replication/repl5_schedule.c      |   4 +-

 .../plugins/replication/windows_connection.c  |  12 +-

 .../replication/windows_inc_protocol.c        |   7 +-

 ldap/servers/plugins/retrocl/retrocl_trim.c   |  10 +-

 ldap/servers/slapd/daemon.c                   |   3 +-

 ldap/servers/slapd/eventq-deprecated.c        | 483 ++++++++++++++++++

 ldap/servers/slapd/eventq.c                   | 236 ++++-----

 ldap/servers/slapd/main.c                     |  18 +-

 ldap/servers/slapd/proto-slap.h               |   6 +-

 ldap/servers/slapd/slapi-plugin.h             |  62 ++-

 ldap/servers/slapd/slapi2runtime.c            |  23 +-

 ldap/servers/slapd/snmp_collator.c            |   7 +-

 ldap/servers/slapd/task.c                     |   2 +-

 ldap/servers/slapd/uuid.c                     |   3 +-

 22 files changed, 750 insertions(+), 188 deletions(-)

 create mode 100644 ldap/servers/slapd/eventq-deprecated.c

diff --git a/Makefile.am b/Makefile.am

index f7bf1c44c..ece1ad41a 100644

--- a/Makefile.am

+++ b/Makefile.am

@@ -1408,6 +1408,7 @@ libslapd_la_SOURCES = ldap/servers/slapd/add.c \

 	ldap/servers/slapd/entrywsi.c \

 	ldap/servers/slapd/errormap.c \

 	ldap/servers/slapd/eventq.c \

+	ldap/servers/slapd/eventq-deprecated.c \

 	ldap/servers/slapd/factory.c \

 	ldap/servers/slapd/features.c \

 	ldap/servers/slapd/fileio.c \

diff --git a/docs/slapi.doxy.in b/docs/slapi.doxy.in

index b1e4810ab..1cafc50ce 100644

--- a/docs/slapi.doxy.in

+++ b/docs/slapi.doxy.in

@@ -759,7 +759,6 @@ WARN_LOGFILE           =

 # Note: If this tag is empty the current directory is searched.

 INPUT                  = src/libsds/include/sds.h \

-                         docs/job-safety.md \

                          # ldap/servers/slapd/slapi-plugin.h \

 # This tag can be used to specify the character encoding of the source files

diff --git a/ldap/servers/plugins/chainingdb/cb_instance.c b/ldap/servers/plugins/chainingdb/cb_instance.c

index bc1864c1a..7fd85deb0 100644

--- a/ldap/servers/plugins/chainingdb/cb_instance.c

+++ b/ldap/servers/plugins/chainingdb/cb_instance.c

@@ -217,7 +217,7 @@ cb_instance_free(cb_backend_instance *inst)

         slapi_rwlock_wrlock(inst->rwl_config_lock);

         if (inst->eq_ctx != NULL) {

-            slapi_eq_cancel(inst->eq_ctx);

+            slapi_eq_cancel_rel(inst->eq_ctx);

             inst->eq_ctx = NULL;

         }

@@ -1947,8 +1947,8 @@ cb_instance_add_config_callback(Slapi_PBlock *pb __attribute__((unused)),

          * we can't call recursively into the DSE to do more adds, they'll

          * silently fail.  instead, schedule the adds to happen in 1 second.

          */

-        inst->eq_ctx = slapi_eq_once(cb_instance_add_monitor_later, (void *)inst,

-                                     slapi_current_rel_time_t() + 1);

+        inst->eq_ctx = slapi_eq_once_rel(cb_instance_add_monitor_later, (void *)inst,

+                                         slapi_current_rel_time_t() + 1);

     }

     /* Get the list of operational attrs defined in the schema */

diff --git a/ldap/servers/plugins/dna/dna.c b/ldap/servers/plugins/dna/dna.c

index 1cb54580b..b46edfcbb 100644

--- a/ldap/servers/plugins/dna/dna.c

+++ b/ldap/servers/plugins/dna/dna.c

@@ -688,7 +688,7 @@ dna_close(Slapi_PBlock *pb __attribute__((unused)))

     slapi_log_err(SLAPI_LOG_TRACE, DNA_PLUGIN_SUBSYSTEM,

                   "--> dna_close\n");

-    slapi_eq_cancel(eq_ctx);

+    slapi_eq_cancel_rel(eq_ctx);

     dna_delete_config(NULL);

     slapi_ch_free((void **)&dna_global_config);

     slapi_destroy_rwlock(g_dna_cache_lock);

@@ -908,7 +908,7 @@ dna_load_plugin_config(Slapi_PBlock *pb, int use_eventq)

          * starting up  would cause the change to not

          * get changelogged. */

         now = slapi_current_rel_time_t();

-        eq_ctx = slapi_eq_once(dna_update_config_event, NULL, now + 30);

+        eq_ctx = slapi_eq_once_rel(dna_update_config_event, NULL, now + 30);

     } else {

         dna_update_config_event(0, NULL);

     }

diff --git a/ldap/servers/plugins/replication/repl5_backoff.c b/ldap/servers/plugins/replication/repl5_backoff.c

index 40ec75dd7..8c851beb2 100644

--- a/ldap/servers/plugins/replication/repl5_backoff.c

+++ b/ldap/servers/plugins/replication/repl5_backoff.c

@@ -99,7 +99,7 @@ backoff_reset(Backoff_Timer *bt, slapi_eq_fn_t callback, void *callback_data)

     bt->callback_arg = callback_data;

     /* Cancel any pending events in the event queue */

     if (NULL != bt->pending_event) {

-        slapi_eq_cancel(bt->pending_event);

+        slapi_eq_cancel_rel(bt->pending_event);

         bt->pending_event = NULL;

     }

     /* Compute the first fire time */

@@ -112,8 +112,8 @@ backoff_reset(Backoff_Timer *bt, slapi_eq_fn_t callback, void *callback_data)

     /* Schedule the callback */

     bt->last_fire_time = slapi_current_rel_time_t();

     return_value = bt->last_fire_time + bt->next_interval;

-    bt->pending_event = slapi_eq_once(bt->callback, bt->callback_arg,

-                                      return_value);

+    bt->pending_event = slapi_eq_once_rel(bt->callback, bt->callback_arg,

+                                          return_value);

     PR_Unlock(bt->lock);

     return return_value;

 }

@@ -159,8 +159,8 @@ backoff_step(Backoff_Timer *bt)

         /* Schedule the callback, if any */

         bt->last_fire_time += previous_interval;

         return_value = bt->last_fire_time + bt->next_interval;

-        bt->pending_event = slapi_eq_once(bt->callback, bt->callback_arg,

-                                          return_value);

+        bt->pending_event = slapi_eq_once_rel(bt->callback, bt->callback_arg,

+                                              return_value);

     }

     PR_Unlock(bt->lock);

     return return_value;

@@ -196,7 +196,7 @@ backoff_delete(Backoff_Timer **btp)

     PR_Lock(bt->lock);

     /* Cancel any pending events in the event queue */

     if (NULL != bt->pending_event) {

-        slapi_eq_cancel(bt->pending_event);

+        slapi_eq_cancel_rel(bt->pending_event);

     }

     PR_Unlock(bt->lock);

     PR_DestroyLock(bt->lock);

diff --git a/ldap/servers/plugins/replication/repl5_connection.c b/ldap/servers/plugins/replication/repl5_connection.c

index bc9ca424b..2dd74f9e7 100644

--- a/ldap/servers/plugins/replication/repl5_connection.c

+++ b/ldap/servers/plugins/replication/repl5_connection.c

@@ -272,7 +272,7 @@ conn_delete(Repl_Connection *conn)

     PR_ASSERT(NULL != conn);

     PR_Lock(conn->lock);

     if (conn->linger_active) {

-        if (slapi_eq_cancel(conn->linger_event) == 1) {

+        if (slapi_eq_cancel_rel(conn->linger_event) == 1) {

             /* Event was found and cancelled. Destroy the connection object. */

             destroy_it = PR_TRUE;

         } else {

@@ -961,7 +961,7 @@ conn_cancel_linger(Repl_Connection *conn)

                       "conn_cancel_linger - %s - Canceling linger on the connection\n",

                       agmt_get_long_name(conn->agmt));

         conn->linger_active = PR_FALSE;

-        if (slapi_eq_cancel(conn->linger_event) == 1) {

+        if (slapi_eq_cancel_rel(conn->linger_event) == 1) {

             conn->refcnt--;

         }

         conn->linger_event = NULL;

@@ -1030,7 +1030,7 @@ conn_start_linger(Repl_Connection *conn)

                       agmt_get_long_name(conn->agmt));

     } else {

         conn->linger_active = PR_TRUE;

-        conn->linger_event = slapi_eq_once(linger_timeout, conn, now + conn->linger_time);

+        conn->linger_event = slapi_eq_once_rel(linger_timeout, conn, now + conn->linger_time);

         conn->status = STATUS_LINGERING;

     }

     PR_Unlock(conn->lock);

@@ -1990,7 +1990,7 @@ repl5_start_debug_timeout(int *setlevel)

     Slapi_Eq_Context eqctx = 0;

     if (s_debug_timeout && s_debug_level) {

         time_t now = slapi_current_rel_time_t();

-        eqctx = slapi_eq_once(repl5_debug_timeout_callback, setlevel,

+        eqctx = slapi_eq_once_rel(repl5_debug_timeout_callback, setlevel,

                               s_debug_timeout + now);

     }

     return eqctx;

@@ -2002,7 +2002,7 @@ repl5_stop_debug_timeout(Slapi_Eq_Context eqctx, int *setlevel)

     char buf[20];

     if (eqctx && !*setlevel) {

-        (void)slapi_eq_cancel(eqctx);

+        (void)slapi_eq_cancel_rel(eqctx);

     }

     if (s_debug_timeout && s_debug_level && *setlevel) {

diff --git a/ldap/servers/plugins/replication/repl5_mtnode_ext.c b/ldap/servers/plugins/replication/repl5_mtnode_ext.c

index 82e230958..2967a47f8 100644

--- a/ldap/servers/plugins/replication/repl5_mtnode_ext.c

+++ b/ldap/servers/plugins/replication/repl5_mtnode_ext.c

@@ -82,8 +82,8 @@ multimaster_mtnode_construct_replicas()

                 }

             }

             /* Wait a few seconds for everything to startup before resuming any replication tasks */

-            slapi_eq_once(replica_check_for_tasks, (void *)replica_get_root(r),

-                          slapi_current_rel_time_t() + 5);

+            slapi_eq_once_rel(replica_check_for_tasks, (void *)replica_get_root(r),

+                              slapi_current_rel_time_t() + 5);

         }

     }

 }

diff --git a/ldap/servers/plugins/replication/repl5_replica.c b/ldap/servers/plugins/replication/repl5_replica.c

index c1d376c72..7102e0606 100644

--- a/ldap/servers/plugins/replication/repl5_replica.c

+++ b/ldap/servers/plugins/replication/repl5_replica.c

@@ -231,17 +231,17 @@ replica_new_from_entry(Slapi_Entry *e, char *errortext, PRBool is_add_operation,

     /* ONREPL - the state update can occur before the entry is added to the DIT.

        In that case the updated would fail but nothing bad would happen. The next

        scheduled update would save the state */

-    r->repl_eqcxt_rs = slapi_eq_repeat(replica_update_state, r->repl_name,

-                                       slapi_current_rel_time_t() + START_UPDATE_DELAY, RUV_SAVE_INTERVAL);

+    r->repl_eqcxt_rs = slapi_eq_repeat_rel(replica_update_state, r->repl_name,

+                                           slapi_current_rel_time_t() + START_UPDATE_DELAY, RUV_SAVE_INTERVAL);

     if (r->tombstone_reap_interval > 0) {

         /*

          * Reap Tombstone should be started some time after the plugin started.

          * This will allow the server to fully start before consuming resources.

          */

-        r->repl_eqcxt_tr = slapi_eq_repeat(eq_cb_reap_tombstones, r->repl_name,

-                                           slapi_current_rel_time_t() + r->tombstone_reap_interval,

-                                           1000 * r->tombstone_reap_interval);

+        r->repl_eqcxt_tr = slapi_eq_repeat_rel(eq_cb_reap_tombstones, r->repl_name,

+                                               slapi_current_rel_time_t() + r->tombstone_reap_interval,

+                                               1000 * r->tombstone_reap_interval);

     }

 done:

@@ -303,12 +303,12 @@ replica_destroy(void **arg)

      */

     if (r->repl_eqcxt_rs) {

-        slapi_eq_cancel(r->repl_eqcxt_rs);

+        slapi_eq_cancel_rel(r->repl_eqcxt_rs);

         r->repl_eqcxt_rs = NULL;

     }

     if (r->repl_eqcxt_tr) {

-        slapi_eq_cancel(r->repl_eqcxt_tr);

+        slapi_eq_cancel_rel(r->repl_eqcxt_tr);

         r->repl_eqcxt_tr = NULL;

     }

@@ -1511,14 +1511,14 @@ replica_set_enabled(Replica *r, PRBool enable)

     if (enable) {

         if (r->repl_eqcxt_rs == NULL) /* event is not already registered */

         {

-            r->repl_eqcxt_rs = slapi_eq_repeat(replica_update_state, r->repl_name,

-                                               slapi_current_rel_time_t() + START_UPDATE_DELAY, RUV_SAVE_INTERVAL);

+            r->repl_eqcxt_rs = slapi_eq_repeat_rel(replica_update_state, r->repl_name,

+                                                   slapi_current_rel_time_t() + START_UPDATE_DELAY, RUV_SAVE_INTERVAL);

         }

     } else /* disable */

     {

         if (r->repl_eqcxt_rs) /* event is still registerd */

         {

-            slapi_eq_cancel(r->repl_eqcxt_rs);

+            slapi_eq_cancel_rel(r->repl_eqcxt_rs);

             r->repl_eqcxt_rs = NULL;

         }

     }

@@ -3628,7 +3628,7 @@ replica_set_tombstone_reap_interval(Replica *r, long interval)

     if (interval > 0 && r->repl_eqcxt_tr && r->tombstone_reap_interval != interval) {

         int found;

-        found = slapi_eq_cancel(r->repl_eqcxt_tr);

+        found = slapi_eq_cancel_rel(r->repl_eqcxt_tr);

         slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,

                       "replica_set_tombstone_reap_interval - tombstone_reap event (interval=%" PRId64 ") was %s\n",

                       r->tombstone_reap_interval, (found ? "cancelled" : "not found"));

@@ -3636,7 +3636,7 @@ replica_set_tombstone_reap_interval(Replica *r, long interval)

     }

     r->tombstone_reap_interval = interval;

     if (interval > 0 && r->repl_eqcxt_tr == NULL) {

-        r->repl_eqcxt_tr = slapi_eq_repeat(eq_cb_reap_tombstones, r->repl_name,

+        r->repl_eqcxt_tr = slapi_eq_repeat_rel(eq_cb_reap_tombstones, r->repl_name,

                                            slapi_current_rel_time_t() + r->tombstone_reap_interval,

                                            1000 * r->tombstone_reap_interval);

         slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,

diff --git a/ldap/servers/plugins/replication/repl5_schedule.c b/ldap/servers/plugins/replication/repl5_schedule.c

index 9539f4031..ca42df561 100644

--- a/ldap/servers/plugins/replication/repl5_schedule.c

+++ b/ldap/servers/plugins/replication/repl5_schedule.c

@@ -550,7 +550,7 @@ schedule_window_state_change_event(Schedule *sch)

         wakeup_time = PRTime2time_t(tm);

         /* schedule the event */

-        sch->pending_event = slapi_eq_once(window_state_changed, sch, wakeup_time);

+        sch->pending_event = slapi_eq_once_rel(window_state_changed, sch, wakeup_time);

         timestr = get_timestring(&wakeup_time);

         slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name, "%s: Update window will %s at %s\n",

@@ -593,7 +593,7 @@ static void

 unschedule_window_state_change_event(Schedule *sch)

 {

     if (sch->pending_event) {

-        slapi_eq_cancel(sch->pending_event);

+        slapi_eq_cancel_rel(sch->pending_event);

         sch->pending_event = NULL;

     }

 }

diff --git a/ldap/servers/plugins/replication/windows_connection.c b/ldap/servers/plugins/replication/windows_connection.c

index ce0662544..5eca5fad1 100644

--- a/ldap/servers/plugins/replication/windows_connection.c

+++ b/ldap/servers/plugins/replication/windows_connection.c

@@ -204,7 +204,7 @@ windows_conn_delete(Repl_Connection *conn)

     PR_ASSERT(NULL != conn);

     PR_Lock(conn->lock);

     if (conn->linger_active) {

-        if (slapi_eq_cancel(conn->linger_event) == 1) {

+        if (slapi_eq_cancel_rel(conn->linger_event) == 1) {

             /* Event was found and cancelled. Destroy the connection object. */

             PR_Unlock(conn->lock);

             destroy_it = PR_TRUE;

@@ -1052,7 +1052,7 @@ windows_conn_cancel_linger(Repl_Connection *conn)

                       "windows_conn_cancel_linger - %s: Cancelling linger on the connection\n",

                       agmt_get_long_name(conn->agmt));

         conn->linger_active = PR_FALSE;

-        if (slapi_eq_cancel(conn->linger_event) == 1) {

+        if (slapi_eq_cancel_rel(conn->linger_event) == 1) {

             conn->refcnt--;

         }

         conn->linger_event = NULL;

@@ -1129,7 +1129,7 @@ windows_conn_start_linger(Repl_Connection *conn)

                       agmt_get_long_name(conn->agmt));

     } else {

         conn->linger_active = PR_TRUE;

-        conn->linger_event = slapi_eq_once(linger_timeout, conn, now + conn->linger_time);

+        conn->linger_event = slapi_eq_once_rel(linger_timeout, conn, now + conn->linger_time);

         conn->status = STATUS_LINGERING;

     }

     PR_Unlock(conn->lock);

@@ -1822,8 +1822,8 @@ repl5_start_debug_timeout(int *setlevel)

     if (s_debug_timeout && s_debug_level) {

         time_t now = time(NULL);

-        eqctx = slapi_eq_once(repl5_debug_timeout_callback, setlevel,

-                              s_debug_timeout + now);

+        eqctx = slapi_eq_once_rel(repl5_debug_timeout_callback, setlevel,

+                                  s_debug_timeout + now);

     }

     slapi_log_err(SLAPI_LOG_TRACE, windows_repl_plugin_name, "<= repl5_start_debug_timeout\n");

     return eqctx;

@@ -1837,7 +1837,7 @@ repl5_stop_debug_timeout(Slapi_Eq_Context eqctx, int *setlevel)

     slapi_log_err(SLAPI_LOG_TRACE, windows_repl_plugin_name, "=> repl5_stop_debug_timeout\n");

     if (eqctx && !*setlevel) {

-        (void)slapi_eq_cancel(eqctx);

+        (void)slapi_eq_cancel_rel(eqctx);

     }

     if (s_debug_timeout && s_debug_level && *setlevel) {

diff --git a/ldap/servers/plugins/replication/windows_inc_protocol.c b/ldap/servers/plugins/replication/windows_inc_protocol.c

index 3d548e5ed..c07a8180a 100644

--- a/ldap/servers/plugins/replication/windows_inc_protocol.c

+++ b/ldap/servers/plugins/replication/windows_inc_protocol.c

@@ -132,7 +132,7 @@ windows_inc_delete(Private_Repl_Protocol **prpp)

     slapi_log_err(SLAPI_LOG_TRACE, windows_repl_plugin_name, "=> windows_inc_delete\n");

     /* First, stop the protocol if it isn't already stopped */

     /* Then, delete all resources used by the protocol */

-    rc = slapi_eq_cancel(dirsync);

+    rc = slapi_eq_cancel_rel(dirsync);

     slapi_log_err(SLAPI_LOG_REPL, windows_repl_plugin_name,

                   "windows_inc_delete - dirsync: %p, rval: %d\n", dirsync, rc);

     /* if backoff is set, delete it (from EQ, as well) */

@@ -324,12 +324,13 @@ windows_inc_run(Private_Repl_Protocol *prp)

             if (interval != current_interval) {

                 current_interval = interval;

                 if (dirsync) {

-                    int rc = slapi_eq_cancel(dirsync);

+                    int rc = slapi_eq_cancel_rel(dirsync);

                     slapi_log_err(SLAPI_LOG_REPL, windows_repl_plugin_name,

                                   "windows_inc_run - Cancelled dirsync: %p, rval: %d\n",

                                   dirsync, rc);

                 }

-                dirsync = slapi_eq_repeat(periodic_dirsync, (void *)prp, (time_t)0, interval);

+                dirsync = slapi_eq_repeat_rel(periodic_dirsync, (void *)prp,

+                                              slapi_current_rel_time_t(), interval);

                 slapi_log_err(SLAPI_LOG_REPL, windows_repl_plugin_name,

                               "windows_inc_run - New dirsync: %p\n", dirsync);

             }

diff --git a/ldap/servers/plugins/retrocl/retrocl_trim.c b/ldap/servers/plugins/retrocl/retrocl_trim.c

index a3e16c4e1..12a395210 100644

--- a/ldap/servers/plugins/retrocl/retrocl_trim.c

+++ b/ldap/servers/plugins/retrocl/retrocl_trim.c

@@ -460,10 +460,10 @@ retrocl_init_trimming(void)

     ts.ts_s_initialized = 1;

     retrocl_trimming = 1;

-    retrocl_trim_ctx = slapi_eq_repeat(retrocl_housekeeping,

-                                       NULL, (time_t)0,

-                                       /* in milliseconds */

-                                       trim_interval * 1000);

+    retrocl_trim_ctx = slapi_eq_repeat_rel(retrocl_housekeeping,

+                                           NULL, (time_t)0,

+                                           /* in milliseconds */

+                                           trim_interval * 1000);

 }

 /*

@@ -487,7 +487,7 @@ retrocl_stop_trimming(void)

          */

         retrocl_trimming = 0;

         if (retrocl_trim_ctx) {

-            slapi_eq_cancel(retrocl_trim_ctx);

+            slapi_eq_cancel_rel(retrocl_trim_ctx);

             retrocl_trim_ctx = NULL;

         }

         PR_DestroyLock(ts.ts_s_trim_mutex);

diff --git a/ldap/servers/slapd/daemon.c b/ldap/servers/slapd/daemon.c

index 0071ed86a..7681e88ea 100644

--- a/ldap/servers/slapd/daemon.c

+++ b/ldap/servers/slapd/daemon.c

@@ -1240,7 +1240,8 @@ slapd_daemon(daemon_ports_t *ports)

     slapi_log_err(SLAPI_LOG_TRACE, "slapd_daemon",

                   "slapd shutting down - waiting for backends to close down\n");

-    eq_stop();

+    eq_stop(); /* deprecated */

+    eq_stop_rel();

     if (!in_referral_mode) {

         task_shutdown();

         uniqueIDGenCleanup();

diff --git a/ldap/servers/slapd/eventq-deprecated.c b/ldap/servers/slapd/eventq-deprecated.c

new file mode 100644

index 000000000..71a7bf8f5

--- /dev/null

+++ b/ldap/servers/slapd/eventq-deprecated.c

@@ -0,0 +1,483 @@

+/** BEGIN COPYRIGHT BLOCK

+ * Copyright (C) 2001 Sun Microsystems, Inc. Used by permission.

+ * Copyright (C) 2020 Red Hat, Inc.

+ * All rights reserved.

+ *

+ * License: GPL (version 3 or any later version).

+ * See LICENSE for details.

+ * END COPYRIGHT BLOCK **/

+

+#ifdef HAVE_CONFIG_H

+#include <config.h>

+#endif

+

+

+/* ********************************************************

+eventq-deprecated.c - Event queue/scheduling system.

+

+There are 3 publicly-accessible entry points:

+

+slapi_eq_once(): cause an event to happen exactly once

+slapi_eq_repeat(): cause an event to happen repeatedly

+slapi_eq_cancel(): cancel a pending event

+

+There is also an initialization point which must be

+called by the server to initialize the event queue system:

+eq_start(), and an entry point used to shut down the system:

+eq_stop().

+

+These functions are now deprecated in favor of the functions

+in eventq.c which use MONOTONIC clocks instead of REALTIME

+clocks.

+*********************************************************** */

+

+#include "slap.h"

+#include "prlock.h"

+#include "prcvar.h"

+#include "prinit.h"

+

+/*

+ * Private definition of slapi_eq_context. Only this

+ * module (eventq.c) should know about the layout of

+ * this structure.

+ */

+typedef struct _slapi_eq_context

+{

+    time_t ec_when;

+    time_t ec_interval;

+    slapi_eq_fn_t ec_fn;

+    void *ec_arg;

+    Slapi_Eq_Context ec_id;

+    struct _slapi_eq_context *ec_next;

+} slapi_eq_context;

+

+/*

+ * Definition of the event queue.

+ */

+typedef struct _event_queue

+{

+    PRLock *eq_lock;

+    PRCondVar *eq_cv;

+    slapi_eq_context *eq_queue;

+} event_queue;

+

+/*

+ * The event queue itself.

+ */

+static event_queue eqs = {0};

+static event_queue *eq = &eqs;

+

+/*

+ * Thread ID of the main thread loop

+ */

+static PRThread *eq_loop_tid = NULL;

+

+/*

+ * Flags used to control startup/shutdown of the event queue

+ */

+static int eq_running = 0;

+static int eq_stopped = 0;

+static int eq_initialized = 0;

+PRLock *ss_lock = NULL;

+PRCondVar *ss_cv = NULL;

+PRCallOnceType init_once = {0};

+

+/* Forward declarations */

+static slapi_eq_context *eq_new(slapi_eq_fn_t fn, void *arg, time_t when, unsigned long interval);

+static void eq_enqueue(slapi_eq_context *newec);

+static slapi_eq_context *eq_dequeue(time_t now);

+static PRStatus eq_create(void);

+

+

+/* ******************************************************** */

+

+

+/*

+ * slapi_eq_once: cause an event to happen exactly once.

+ *

+ * Arguments:

+ *  fn: the function to call

+ *  arg: an argument to pass to the called function

+ *  when: the time that the function should be called

+ * Returns:

+ *  slapi_eq_context - a handle to an opaque object which

+ *  the caller can use to refer to this particular scheduled

+ *  event.

+ */

+Slapi_Eq_Context

+slapi_eq_once(slapi_eq_fn_t fn, void *arg, time_t when)

+{

+    slapi_eq_context *tmp;

+    PR_ASSERT(eq_initialized);

+    if (!eq_stopped) {

+

+        Slapi_Eq_Context id;

+

+        tmp = eq_new(fn, arg, when, 0UL);

+        id = tmp->ec_id;

+

+        eq_enqueue(tmp);

+

+        /* After this point, <tmp> may have      */

+        /* been freed, depending on the thread   */

+        /* scheduling. Too bad             */

+

+        slapi_log_err(SLAPI_LOG_HOUSE, NULL,

+                      "added one-time event id %p at time %ld\n",

+                      id, when);

+        return (id);

+    }

+    return NULL; /* JCM - Not sure if this should be 0 or something else. */

+}

+

+

+/*

+ * slapi_eq_repeat: cause an event to happen repeatedly.

+ *

+ * Arguments:

+ *  fn: the function to call

+ *  arg: an argument to pass to the called function

+ *  when: the time that the function should first be called

+ *  interval: the amount of time (in milliseconds) between

+ *            successive calls to the function

+ * Returns:

+ *  slapi_eq_context - a handle to an opaque object which

+ *  the caller can use to refer to this particular scheduled

+ */

+Slapi_Eq_Context

+slapi_eq_repeat(slapi_eq_fn_t fn, void *arg, time_t when, unsigned long interval)

+{

+    slapi_eq_context *tmp;

+    PR_ASSERT(eq_initialized);

+    if (!eq_stopped) {

+        tmp = eq_new(fn, arg, when, interval);

+        eq_enqueue(tmp);

+        slapi_log_err(SLAPI_LOG_HOUSE, NULL,

+                      "added repeating event id %p at time %ld, interval %lu\n",

+                      tmp->ec_id, when, interval);

+        return (tmp->ec_id);

+    }

+    return NULL; /* JCM - Not sure if this should be 0 or something else. */

+}

+

+

+/*

+ * slapi_eq_cancel: cancel a pending event.

+ * Arguments:

+ *  ctx: the context of the event which should be de-scheduled

+ */

+int

+slapi_eq_cancel(Slapi_Eq_Context ctx)

+{

+    slapi_eq_context **p, *tmp = NULL;

+    int found = 0;

+

+    PR_ASSERT(eq_initialized);

+    if (!eq_stopped) {

+        PR_Lock(eq->eq_lock);

+        p = &(eq->eq_queue);

+        while (!found && *p != NULL) {

+            if ((*p)->ec_id == ctx) {

+                tmp = *p;

+                *p = (*p)->ec_next;

+                slapi_ch_free((void **)&tmp);

+                found = 1;

+            } else {

+                p = &((*p)->ec_next);

+            }

+        }

+        PR_Unlock(eq->eq_lock);

+    }

+    slapi_log_err(SLAPI_LOG_HOUSE, NULL,

+                  "cancellation of event id %p requested: %s\n",

+                  ctx, found ? "cancellation succeeded" : "event not found");

+    return found;

+}

+

+

+/*

+ * Construct a new ec structure

+ */

+static slapi_eq_context *

+eq_new(slapi_eq_fn_t fn, void *arg, time_t when, unsigned long interval)

+{

+    slapi_eq_context *retptr = (slapi_eq_context *)slapi_ch_calloc(1, sizeof(slapi_eq_context));

+

+    retptr->ec_fn = fn;

+    retptr->ec_arg = arg;

+    /*

+     * retptr->ec_when = when < now ? now : when;

+     * we used to amke this check, but it make no sense: when queued, if when

+     * has expired, we'll be executed anyway. save the cycles, and just set

+     * ec_when.

+     */

+    retptr->ec_when = when;

+    retptr->ec_interval = interval == 0UL ? 0UL : (interval + 999) / 1000;

+    retptr->ec_id = (Slapi_Eq_Context)retptr;

+    return retptr;

+}

+

+

+/*

+ * Add a new event to the event queue.

+ */

+static void

+eq_enqueue(slapi_eq_context *newec)

+{

+    slapi_eq_context **p;

+

+    PR_ASSERT(NULL != newec);

+    PR_Lock(eq->eq_lock);

+    /* Insert <newec> in order (sorted by start time) in the list */

+    for (p = &(eq->eq_queue); *p != NULL; p = &((*p)->ec_next)) {

+        if ((*p)->ec_when > newec->ec_when) {

+            break;

+        }

+    }

+    if (NULL != *p) {

+        newec->ec_next = *p;

+    } else {

+        newec->ec_next = NULL;

+    }

+    *p = newec;

+    PR_NotifyCondVar(eq->eq_cv); /* wake up scheduler thread */

+    PR_Unlock(eq->eq_lock);

+}

+

+

+/*

+ * If there is an event in the queue scheduled at time

+ * <now> or before, dequeue it and return a pointer

+ * to it. Otherwise, return NULL.

+ */

+static slapi_eq_context *

+eq_dequeue(time_t now)

+{

+    slapi_eq_context *retptr = NULL;

+

+    PR_Lock(eq->eq_lock);

+    if (NULL != eq->eq_queue && eq->eq_queue->ec_when <= now) {

+        retptr = eq->eq_queue;

+        eq->eq_queue = retptr->ec_next;

+    }

+    PR_Unlock(eq->eq_lock);

+    return retptr;

+}

+

+

+/*

+ * Call all events which are due to run.

+ * Note that if we've missed a schedule

+ * opportunity, we don't try to catch up

+ * by calling the function repeatedly.

+ */

+static void