From 6969181628f2c664d5f82c89c15bbc0a2487e21f Mon Sep 17 00:00:00 2001

From: Mark Reynolds <mreynolds@redhat.com>

Date: Thu, 19 Nov 2020 15:46:19 -0500

Subject: [PATCH 1/2] Issue 4384 - Use MONOTONIC clock for all timing events

 and conditions

Bug Description:  All of the server's event handling and replication were

                  based on REALTIME clocks, which can be influenced by the

                  system changing.  This could causes massive delays, and

                  simply cause unexpected behavior.

Fix Description:  Move all condition variables to use pthread instead of NSPR

                  functions.  Also make sure we use MONOTONIC clocks when we

                  get the current time when checking for timeouts and other

                  timed events.

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

Reviewed by: elkris, firstyear, and tbordaz (Thanks!!!)

Apply firstyear's sugestions

Apply Firstyear's other suggestions

Apply Thierry's suggestions

---

 Makefile.am                                   |   2 +-

 .../tests/suites/plugins/entryusn_test.py     |   3 +

 ldap/servers/plugins/chainingdb/cb_add.c      |   2 +-

 ldap/servers/plugins/chainingdb/cb_compare.c  |   2 +-

 .../plugins/chainingdb/cb_conn_stateless.c    |  16 +-

 ldap/servers/plugins/chainingdb/cb_delete.c   |   2 +-

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

 ldap/servers/plugins/chainingdb/cb_modify.c   |   2 +-

 ldap/servers/plugins/chainingdb/cb_modrdn.c   |   2 +-

 ldap/servers/plugins/chainingdb/cb_search.c   |   8 +-

 ldap/servers/plugins/cos/cos_cache.c          |   4 +-

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

 ldap/servers/plugins/passthru/ptconn.c        |   2 +-

 ldap/servers/plugins/referint/referint.c      |  85 +++++---

 ldap/servers/plugins/replication/repl5.h      |   3 +-

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

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

 .../plugins/replication/repl5_inc_protocol.c  |  91 ++++----

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

 .../plugins/replication/repl5_prot_private.h  |   6 +-

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

 .../replication/repl5_replica_config.c        | 197 +++++++++++-------

 .../plugins/replication/repl5_tot_protocol.c  |  71 ++++---

 ldap/servers/plugins/replication/repl_extop.c |   4 +-

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

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

 .../replication/windows_tot_protocol.c        |  24 ++-

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

 ldap/servers/plugins/roles/roles_cache.c      |   4 +-

 ldap/servers/plugins/sync/sync.h              |   4 +-

 ldap/servers/plugins/sync/sync_persist.c      |  54 +++--

 .../slapd/back-ldbm/db-bdb/bdb_import.c       |  49 ++---

 .../back-ldbm/db-bdb/bdb_import_threads.c     |  29 +--

 .../back-ldbm/db-bdb/bdb_instance_config.c    |   8 +-

 .../slapd/back-ldbm/db-bdb/bdb_layer.c        | 129 +++++++-----

 .../slapd/back-ldbm/db-bdb/bdb_layer.h        |  10 +-

 ldap/servers/slapd/back-ldbm/import.h         |   6 +-

 ldap/servers/slapd/connection.c               |  88 ++++----

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

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

 ldap/servers/slapd/house.c                    |  58 ++++--

 ldap/servers/slapd/libmakefile                |   2 +-

 ldap/servers/slapd/psearch.c                  |  63 +++---

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

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

 .../slapd/{slapi2nspr.c => slapi2runtime.c}   |  87 +++++---

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

 ldap/servers/slapd/time.c                     |  10 +-

 48 files changed, 877 insertions(+), 579 deletions(-)

 rename ldap/servers/slapd/{slapi2nspr.c => slapi2runtime.c} (69%)

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

index 0e5f04f91..f7bf1c44c 100644

--- a/Makefile.am

+++ b/Makefile.am

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

 	ldap/servers/slapd/security_wrappers.c \

 	ldap/servers/slapd/slapd_plhash.c \

 	ldap/servers/slapd/slapi_counter.c \

-	ldap/servers/slapd/slapi2nspr.c \

+	ldap/servers/slapd/slapi2runtime.c \

 	ldap/servers/slapd/snmp_collator.c \

 	ldap/servers/slapd/sort.c \

 	ldap/servers/slapd/ssl.c \

diff --git a/dirsrvtests/tests/suites/plugins/entryusn_test.py b/dirsrvtests/tests/suites/plugins/entryusn_test.py

index ad3d7f209..da0538f74 100644

--- a/dirsrvtests/tests/suites/plugins/entryusn_test.py

+++ b/dirsrvtests/tests/suites/plugins/entryusn_test.py

@@ -6,9 +6,11 @@

 # See LICENSE for details.

 # --- END COPYRIGHT BLOCK ---

 #

+import os

 import ldap

 import logging

 import pytest

+import time

 from lib389._constants import DEFAULT_SUFFIX

 from lib389.config import Config

 from lib389.plugins import USNPlugin, MemberOfPlugin

@@ -211,6 +213,7 @@ def test_entryusn_after_repl_delete(topology_m2):

         user_usn = user_1.get_attr_val_int('entryusn')

         user_1.delete()

+        time.sleep(1)  # Gives a little time for tombstone creation to complete

         ts = tombstones.get(user_rdn)

         ts_usn = ts.get_attr_val_int('entryusn')

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

index a9f9c0f87..b7ae7267d 100644

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

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

@@ -130,7 +130,7 @@ chaining_back_add(Slapi_PBlock *pb)

     /* heart-beat management */

     if (cb->max_idle_time > 0) {

-        endtime = slapi_current_utc_time() + cb->max_idle_time;

+        endtime = slapi_current_rel_time_t() + cb->max_idle_time;

     }

     /* Send LDAP operation to the remote host */

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

index 25dfa87b5..8d7fdd06b 100644

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

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

@@ -126,7 +126,7 @@ chaining_back_compare(Slapi_PBlock *pb)

     /* heart-beat management */

     if (cb->max_idle_time > 0) {

-        endtime = slapi_current_utc_time() + cb->max_idle_time;

+        endtime = slapi_current_rel_time_t() + cb->max_idle_time;

     }

     /*

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

index 9beb459ef..a2003221e 100644

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

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

@@ -453,7 +453,7 @@ cb_get_connection(cb_conn_pool *pool,

             conn->ld = ld;

             conn->status = CB_CONNSTATUS_OK;

             conn->refcount = 0; /* incremented below */

-            conn->opentime = slapi_current_utc_time();

+            conn->opentime = slapi_current_rel_time_t();

             conn->ThreadId = PR_MyThreadId(); /* store the thread id */

             conn->next = NULL;

             if (secure) {

@@ -488,7 +488,7 @@ cb_get_connection(cb_conn_pool *pool,

         }

         if (!secure)

-            slapi_wait_condvar(pool->conn.conn_list_cv, NULL);

+            slapi_wait_condvar_pt(pool->conn.conn_list_cv, pool->conn.conn_list_mutex, NULL);

         if (cb_debug_on()) {

             slapi_log_err(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,

@@ -639,7 +639,7 @@ cb_check_for_stale_connections(cb_conn_pool *pool)

     slapi_lock_mutex(pool->conn.conn_list_mutex);

     if (connlifetime > 0)

-        curtime = slapi_current_utc_time();

+        curtime = slapi_current_rel_time_t();

     if (pool->secure) {

         myself = PR_ThreadSelf();

@@ -860,7 +860,7 @@ cb_ping_farm(cb_backend_instance *cb, cb_outgoing_conn *cnx, time_t end_time)

     if (cnx && (cnx->status != CB_CONNSTATUS_OK)) /* Known problem */

         return LDAP_SERVER_DOWN;

-    now = slapi_current_utc_time();

+    now = slapi_current_rel_time_t();

     if (end_time && ((now <= end_time) || (end_time < 0)))

         return LDAP_SUCCESS;

@@ -905,7 +905,7 @@ cb_update_failed_conn_cpt(cb_backend_instance *cb)

         slapi_unlock_mutex(cb->monitor_availability.cpt_lock);

         if (cb->monitor_availability.cpt >= CB_NUM_CONN_BEFORE_UNAVAILABILITY) {

             /* we reach the limit of authorized failed connections => we setup the chaining BE state to unavailable */

-            now = slapi_current_utc_time();

+            now = slapi_current_rel_time_t();

             slapi_lock_mutex(cb->monitor_availability.lock_timeLimit);

             cb->monitor_availability.unavailableTimeLimit = now + CB_UNAVAILABLE_PERIOD;

             slapi_unlock_mutex(cb->monitor_availability.lock_timeLimit);

@@ -938,7 +938,7 @@ cb_check_availability(cb_backend_instance *cb, Slapi_PBlock *pb)

     time_t now;

     if (cb->monitor_availability.farmserver_state == FARMSERVER_UNAVAILABLE) {

         slapi_lock_mutex(cb->monitor_availability.lock_timeLimit);

-        now = slapi_current_utc_time();

+        now = slapi_current_rel_time_t();

         if (now >= cb->monitor_availability.unavailableTimeLimit) {

             cb->monitor_availability.unavailableTimeLimit = now + CB_INFINITE_TIME; /* to be sure only one thread can do the test */

             slapi_unlock_mutex(cb->monitor_availability.lock_timeLimit);

@@ -951,7 +951,7 @@ cb_check_availability(cb_backend_instance *cb, Slapi_PBlock *pb)

                       "cb_check_availability - ping the farm server and check if it's still unavailable");

         if (cb_ping_farm(cb, NULL, 0) != LDAP_SUCCESS) { /* farm still unavailable... Just change the timelimit */

             slapi_lock_mutex(cb->monitor_availability.lock_timeLimit);

-            now = slapi_current_utc_time();

+            now = slapi_current_rel_time_t();

             cb->monitor_availability.unavailableTimeLimit = now + CB_UNAVAILABLE_PERIOD;

             slapi_unlock_mutex(cb->monitor_availability.lock_timeLimit);

             cb_send_ldap_result(pb, LDAP_OPERATIONS_ERROR, NULL, "FARM SERVER TEMPORARY UNAVAILABLE", 0, NULL);

@@ -961,7 +961,7 @@ cb_check_availability(cb_backend_instance *cb, Slapi_PBlock *pb)

         } else {

             /* farm is back !*/

             slapi_lock_mutex(cb->monitor_availability.lock_timeLimit);

-            now = slapi_current_utc_time();

+            now = slapi_current_rel_time_t();

             cb->monitor_availability.unavailableTimeLimit = now; /* the unavailable period is finished */

             slapi_unlock_mutex(cb->monitor_availability.lock_timeLimit);

             /* The farmer server state backs to FARMSERVER_AVAILABLE, but this already done in cb_ping_farm, and also the reset of cpt*/

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

index e76fb6b95..94f84b55d 100644

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

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

@@ -117,7 +117,7 @@ chaining_back_delete(Slapi_PBlock *pb)

     /* heart-beat management */

     if (cb->max_idle_time > 0) {

-        endtime = slapi_current_utc_time() + cb->max_idle_time;

+        endtime = slapi_current_rel_time_t() + cb->max_idle_time;

     }

     /*

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

index cd5abb834..bc1864c1a 100644

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

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

@@ -1947,7 +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, time(NULL) + 1);

+        inst->eq_ctx = slapi_eq_once(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/chainingdb/cb_modify.c b/ldap/servers/plugins/chainingdb/cb_modify.c

index f81edf4a6..e53da9e40 100644

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

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

@@ -125,7 +125,7 @@ chaining_back_modify(Slapi_PBlock *pb)

     /* heart-beat management */

     if (cb->max_idle_time > 0) {

-        endtime = slapi_current_utc_time() + cb->max_idle_time;

+        endtime = slapi_current_rel_time_t() + cb->max_idle_time;

     }

     /*

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

index 95a068be7..d648253c7 100644

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

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

@@ -129,7 +129,7 @@ chaining_back_modrdn(Slapi_PBlock *pb)

     /* heart-beat management */

     if (cb->max_idle_time > 0) {

-        endtime = slapi_current_utc_time() + cb->max_idle_time;

+        endtime = slapi_current_rel_time_t() + cb->max_idle_time;

     }

     /*

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

index d47cbc8e4..ffc8f56f8 100644

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

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

@@ -236,7 +236,7 @@ chainingdb_build_candidate_list(Slapi_PBlock *pb)

     /* heart-beat management */

     if (cb->max_idle_time > 0) {

-        endtime = slapi_current_utc_time() + cb->max_idle_time;

+        endtime = slapi_current_rel_time_t() + cb->max_idle_time;

     }

     rc = ldap_search_ext(ld, target, scope, filter, attrs, attrsonly,

@@ -503,7 +503,7 @@ chainingdb_next_search_entry(Slapi_PBlock *pb)

     /* heart-beat management */

     if (cb->max_idle_time > 0) {

-        endtime = slapi_current_utc_time() + cb->max_idle_time;

+        endtime = slapi_current_rel_time_t() + cb->max_idle_time;

     }

     while (1) {

@@ -579,7 +579,7 @@ chainingdb_next_search_entry(Slapi_PBlock *pb)

             /* heart-beat management */

             if (cb->max_idle_time > 0) {

-                endtime = slapi_current_utc_time() + cb->max_idle_time;

+                endtime = slapi_current_rel_time_t() + cb->max_idle_time;

             }

             /* The server sent one of the entries found by the search */

@@ -611,7 +611,7 @@ chainingdb_next_search_entry(Slapi_PBlock *pb)

             /* heart-beat management */

             if (cb->max_idle_time > 0) {

-                endtime = slapi_current_utc_time() + cb->max_idle_time;

+                endtime = slapi_current_rel_time_t() + cb->max_idle_time;

             }

             parse_rc = ldap_parse_reference(ctx->ld, res, &referrals, NULL, 1);

diff --git a/ldap/servers/plugins/cos/cos_cache.c b/ldap/servers/plugins/cos/cos_cache.c

index eb9bd77f9..d404ff901 100644

--- a/ldap/servers/plugins/cos/cos_cache.c

+++ b/ldap/servers/plugins/cos/cos_cache.c

@@ -346,7 +346,7 @@ cos_cache_init(void)

     if (ret == 0) {

         slapi_lock_mutex(start_lock);

         while (!started) {

-            while (slapi_wait_condvar(start_cond, NULL) == 0)

+            while (slapi_wait_condvar_pt(start_cond, start_lock, NULL) == 0)

                 ;

         }

         slapi_unlock_mutex(start_lock);

@@ -401,7 +401,7 @@ cos_cache_wait_on_change(void *arg __attribute__((unused)))

              * thread notifies our condvar, and so we will not miss any

              * notifications, including the shutdown notification.

              */

-            slapi_wait_condvar(something_changed, NULL);

+            slapi_wait_condvar_pt(something_changed, change_lock, NULL);

         } else {

             /* Something to do...do it below */

         }

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

index 16c625bb0..1cb54580b 100644

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

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

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

          * performing the operation at this point when

          * starting up  would cause the change to not

          * get changelogged. */

-        now = slapi_current_utc_time();

+        now = slapi_current_rel_time_t();

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

     } else {

         dna_update_config_event(0, NULL);

diff --git a/ldap/servers/plugins/passthru/ptconn.c b/ldap/servers/plugins/passthru/ptconn.c

index 49040f651..637d33843 100644

--- a/ldap/servers/plugins/passthru/ptconn.c

+++ b/ldap/servers/plugins/passthru/ptconn.c

@@ -233,7 +233,7 @@ passthru_get_connection(PassThruServer *srvr, LDAP **ldp)

         slapi_log_err(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,

                       "... passthru_get_connection waiting for conn to free up\n");

 #endif

-        slapi_wait_condvar(srvr->ptsrvr_connlist_cv, NULL);

+        slapi_wait_condvar_pt(srvr->ptsrvr_connlist_cv, srvr->ptsrvr_connlist_mutex, NULL);

 #ifdef PASSTHRU_VERBOSE_LOGGING

         slapi_log_err(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,

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

index eb4b089fb..fd5356d72 100644

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

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

@@ -71,8 +71,9 @@ void referint_get_config(int *delay, char **logfile);

 /* global thread control stuff */

 static PRLock *referint_mutex = NULL;

 static PRThread *referint_tid = NULL;

-static PRLock *keeprunning_mutex = NULL;

-static PRCondVar *keeprunning_cv = NULL;

+static pthread_mutex_t keeprunning_mutex;

+static pthread_cond_t keeprunning_cv;

+

 static int keeprunning = 0;

 static referint_config *config = NULL;

 static Slapi_DN *_ConfigAreaDN = NULL;

@@ -1302,12 +1303,38 @@ referint_postop_start(Slapi_PBlock *pb)

      *     -1 = integrity off

      */

     if (referint_get_delay() > 0) {

+        pthread_condattr_t condAttr;

+

         /* initialize the cv and lock */

         if (!use_txn && (NULL == referint_mutex)) {

             referint_mutex = PR_NewLock();

         }

-        keeprunning_mutex = PR_NewLock();

-        keeprunning_cv = PR_NewCondVar(keeprunning_mutex);

+        if ((rc = pthread_mutex_init(&keeprunning_mutex, NULL)) != 0) {

+            slapi_log_err(SLAPI_LOG_ERR, "referint_postop_start",

+                          "cannot create new lock.  error %d (%s)\n",

+                          rc, strerror(rc));

+            exit(1);

+        }

+        if ((rc = pthread_condattr_init(&condAttr)) != 0) {

+            slapi_log_err(SLAPI_LOG_ERR, "referint_postop_start",

+                          "cannot create new condition attribute variable.  error %d (%s)\n",

+                          rc, strerror(rc));

+            exit(1);

+        }

+        if ((rc = pthread_condattr_setclock(&condAttr, CLOCK_MONOTONIC)) != 0) {

+            slapi_log_err(SLAPI_LOG_ERR, "referint_postop_start",

+                          "cannot set condition attr clock.  error %d (%s)\n",

+                          rc, strerror(rc));

+            exit(1);

+        }

+        if ((rc = pthread_cond_init(&keeprunning_cv, &condAttr)) != 0) {

+            slapi_log_err(SLAPI_LOG_ERR, "referint_postop_start",

+                          "cannot create new condition variable.  error %d (%s)\n",

+                          rc, strerror(rc));

+            exit(1);

+        }

+        pthread_condattr_destroy(&condAttr); /* no longer needed */

+

         keeprunning = 1;

         referint_tid = PR_CreateThread(PR_USER_THREAD,

@@ -1337,13 +1364,11 @@ int

 referint_postop_close(Slapi_PBlock *pb __attribute__((unused)))

 {

     /* signal the thread to exit */

-    if (NULL != keeprunning_mutex) {

-        PR_Lock(keeprunning_mutex);

+    if (referint_get_delay() > 0) {

+        pthread_mutex_lock(&keeprunning_mutex);

         keeprunning = 0;

-        if (NULL != keeprunning_cv) {

-            PR_NotifyCondVar(keeprunning_cv);

-        }

-        PR_Unlock(keeprunning_mutex);

+        pthread_cond_signal(&keeprunning_cv);

+        pthread_mutex_unlock(&keeprunning_mutex);

     }

     slapi_destroy_rwlock(config_rwlock);

@@ -1369,6 +1394,7 @@ referint_thread_func(void *arg __attribute__((unused)))

     char *iter = NULL;

     Slapi_DN *sdn = NULL;

     Slapi_DN *tmpsuperior = NULL;

+    struct timespec current_time = {0};

     int delay;

     int no_changes;

@@ -1383,20 +1409,22 @@ referint_thread_func(void *arg __attribute__((unused)))

         no_changes = 1;

         while (no_changes) {

-            PR_Lock(keeprunning_mutex);

+            pthread_mutex_lock(&keeprunning_mutex);

             if (keeprunning == 0) {

-                PR_Unlock(keeprunning_mutex);

+                pthread_mutex_unlock(&keeprunning_mutex);

                 break;

             }

-            PR_Unlock(keeprunning_mutex);

+            pthread_mutex_unlock(&keeprunning_mutex);

             referint_lock();

             if ((prfd = PR_Open(logfilename, PR_RDONLY, REFERINT_DEFAULT_FILE_MODE)) == NULL) {

                 referint_unlock();

                 /* go back to sleep and wait for this file */

-                PR_Lock(keeprunning_mutex);

-                PR_WaitCondVar(keeprunning_cv, PR_SecondsToInterval(delay));

-                PR_Unlock(keeprunning_mutex);

+                pthread_mutex_lock(&keeprunning_mutex);

+                clock_gettime(CLOCK_MONOTONIC, &current_time);

+                current_time.tv_sec += delay;

+                pthread_cond_timedwait(&keeprunning_cv, &keeprunning_mutex, &current_time);

+                pthread_mutex_unlock(&keeprunning_mutex);

             } else {

                 no_changes = 0;

             }

@@ -1407,12 +1435,12 @@ referint_thread_func(void *arg __attribute__((unused)))

          *  loop before trying to do the changes. The server

          *  will pick them up on next startup as file still exists

          */

-        PR_Lock(keeprunning_mutex);

+        pthread_mutex_lock(&keeprunning_mutex);

         if (keeprunning == 0) {

-            PR_Unlock(keeprunning_mutex);

+            pthread_mutex_unlock(&keeprunning_mutex);

             break;

         }

-        PR_Unlock(keeprunning_mutex);

+        pthread_mutex_unlock(&keeprunning_mutex);

         while (GetNextLine(thisline, MAX_LINE, prfd)) {

             ptoken = ldap_utf8strtok_r(thisline, delimiter, &iter);

@@ -1459,21 +1487,16 @@ referint_thread_func(void *arg __attribute__((unused)))

         referint_unlock();

         /* wait on condition here */

-        PR_Lock(keeprunning_mutex);

-        PR_WaitCondVar(keeprunning_cv, PR_SecondsToInterval(delay));

-        PR_Unlock(keeprunning_mutex);

+        pthread_mutex_lock(&keeprunning_mutex);

+        clock_gettime(CLOCK_MONOTONIC, &current_time);

+        current_time.tv_sec += delay;

+        pthread_cond_timedwait(&keeprunning_cv, &keeprunning_mutex, &current_time);

+        pthread_mutex_unlock(&keeprunning_mutex);

     }

     /* cleanup resources allocated in start  */

-    if (NULL != keeprunning_mutex) {

-        PR_DestroyLock(keeprunning_mutex);

-    }

-    if (NULL != referint_mutex) {

-        PR_DestroyLock(referint_mutex);

-    }

-    if (NULL != keeprunning_cv) {

-        PR_DestroyCondVar(keeprunning_cv);

-    }

+    pthread_mutex_destroy(&keeprunning_mutex);

+    pthread_cond_destroy(&keeprunning_cv);

     slapi_ch_free_string(&logfilename);

 }

diff --git a/ldap/servers/plugins/replication/repl5.h b/ldap/servers/plugins/replication/repl5.h

index f1c596a3f..06e747811 100644

--- a/ldap/servers/plugins/replication/repl5.h

+++ b/ldap/servers/plugins/replication/repl5.h

@@ -1,6 +1,6 @@

 /** BEGIN COPYRIGHT BLOCK

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

- * Copyright (C) 2010 Red Hat, Inc.

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

  * Copyright (C) 2009 Hewlett-Packard Development Company, L.P.

  * All rights reserved.

  *

@@ -28,6 +28,7 @@

 #include "llist.h"

 #include "repl5_ruv.h"

 #include "plstr.h"

+#include <pthread.h>

 #define START_UPDATE_DELAY                   2 /* 2 second */

 #define REPLICA_TYPE_WINDOWS                 1

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

index 40848b96d..40ec75dd7 100644

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

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

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

         bt->next_interval = bt->initial_interval;

     }

     /* Schedule the callback */

-    bt->last_fire_time = slapi_current_utc_time();

+    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);

@@ -177,7 +177,7 @@ backoff_expired(Backoff_Timer *bt, int margin)

     PR_ASSERT(NULL != bt);

     PR_Lock(bt->lock);

-    return_value = (slapi_current_utc_time() >= (bt->last_fire_time + bt->next_interval + margin));

+    return_value = (slapi_current_rel_time_t() >= (bt->last_fire_time + bt->next_interval + margin));

     PR_Unlock(bt->lock);

     return return_value;

 }

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

index cf57c2156..bc9ca424b 100644

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

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

@@ -402,7 +402,7 @@ conn_read_result_ex(Repl_Connection *conn, char **retoidp, struct berval **retda

         }

         if (block) {

             /* Did the connection's timeout expire ? */

-            time_now = slapi_current_utc_time();

+            time_now = slapi_current_rel_time_t();

             if (conn->timeout.tv_sec <= (time_now - start_time)) {

                 /* We timed out */

                 rc = 0;

@@ -676,7 +676,7 @@ conn_is_available(Repl_Connection *conn)

 {

     time_t poll_timeout_sec = 1;   /* Polling for 1sec */

     time_t yield_delay_msec = 100; /* Delay to wait */

-    time_t start_time = slapi_current_utc_time();

+    time_t start_time = slapi_current_rel_time_t();

     time_t time_now;

     ConnResult return_value = CONN_OPERATION_SUCCESS;

@@ -686,7 +686,7 @@ conn_is_available(Repl_Connection *conn)

             /* in case of timeout we return CONN_TIMEOUT only

              * if the RA.timeout is exceeded

              */

-            time_now = slapi_current_utc_time();

+            time_now = slapi_current_rel_time_t();

             if (conn->timeout.tv_sec <= (time_now - start_time)) {

                 break;

             } else {

@@ -1010,7 +1010,7 @@ linger_timeout(time_t event_time __attribute__((unused)), void *arg)

 void

 conn_start_linger(Repl_Connection *conn)

 {

-    time_t now;

+    time_t now = slapi_current_rel_time_t();

     PR_ASSERT(NULL != conn);

     slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,

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

                       agmt_get_long_name(conn->agmt));

         return;

     }

-    now = slapi_current_utc_time();

+

     PR_Lock(conn->lock);

     if (conn->linger_active) {

         slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,

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

 {

     Slapi_Eq_Context eqctx = 0;

     if (s_debug_timeout && s_debug_level) {

-        time_t now = slapi_current_utc_time();

+        time_t now = slapi_current_rel_time_t();

         eqctx = slapi_eq_once(repl5_debug_timeout_callback, setlevel,

                               s_debug_timeout + now);

     }

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

index af5e5897c..4bb384882 100644

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

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

@@ -1,6 +1,6 @@

 /** BEGIN COPYRIGHT BLOCK

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

- * Copyright (C) 2005 Red Hat, Inc.

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

  * All rights reserved.

  *

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

@@ -129,7 +129,7 @@ typedef struct result_data

  * don't see any updates for a period equal to this interval,

  * we go ahead and start a replication session, just to be safe

  */

-#define MAX_WAIT_BETWEEN_SESSIONS PR_SecondsToInterval(60 * 5) /* 5 minutes */

+#define MAX_WAIT_BETWEEN_SESSIONS 300 /* 5 minutes */

 /*

  * tests if the protocol has been shutdown and we need to quit

@@ -145,7 +145,7 @@ typedef struct result_data

 /* Forward declarations */

 static PRUint32 event_occurred(Private_Repl_Protocol *prp, PRUint32 event);

 static void reset_events(Private_Repl_Protocol *prp);

-static void protocol_sleep(Private_Repl_Protocol *prp, PRIntervalTime duration);

+static void protocol_sleep(Private_Repl_Protocol *prp, int32_t duration);

 static int send_updates(Private_Repl_Protocol *prp, RUV *ruv, PRUint32 *num_changes_sent);

 static void repl5_inc_backoff_expired(time_t timer_fire_time, void *arg);

 static int examine_update_vector(Private_Repl_Protocol *prp, RUV *ruv);

@@ -253,7 +253,7 @@ repl5_inc_result_threadmain(void *param)

         char *uniqueid = NULL;

         char *ldap_error_string = NULL;

         time_t time_now = 0;

-        time_t start_time = slapi_current_utc_time();

+        time_t start_time = slapi_current_rel_time_t();

         int connection_error = 0;

         int operation_code = 0;

         int backoff_time = 1;

@@ -275,7 +275,7 @@ repl5_inc_result_threadmain(void *param)

                 /* We need to a) check that the 'real' timeout hasn't expired and

                  * b) implement a backoff sleep to avoid spinning */

                 /* Did the connection's timeout expire ? */

-                time_now = slapi_current_utc_time();

+                time_now = slapi_current_rel_time_t();

                 if (conn_get_timeout(conn) <= (time_now - start_time)) {

                     /* We timed out */

                     conres = CONN_TIMEOUT;

@@ -358,7 +358,7 @@ repl5_inc_result_threadmain(void *param)

         /* Should we stop ? */

         PR_Lock(rd->lock);

         if (!finished && yield_session && rd->abort != SESSION_ABORTED && rd->abort_time == 0) {

-            rd->abort_time = slapi_current_utc_time();

+            rd->abort_time = slapi_current_rel_time_t();

             rd->abort = SESSION_ABORTED; /* only set the abort time once */

             slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name, "repl5_inc_result_threadmain - "

                                                             "Abort control detected, setting abort time...(%s)\n",

@@ -532,13 +532,11 @@ repl5_inc_delete(Private_Repl_Protocol **prpp)

         (*prpp)->stop(*prpp);

     }

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

-    if ((*prpp)->lock) {

-        PR_DestroyLock((*prpp)->lock);

-        (*prpp)->lock = NULL;

+    if (&((*prpp)->lock)) {

+        pthread_mutex_destroy(&((*prpp)->lock));

     }

-    if ((*prpp)->cvar) {

-        PR_DestroyCondVar((*prpp)->cvar);

-        (*prpp)->cvar = NULL;

+    if (&((*prpp)->cvar)) {

+        pthread_cond_destroy(&(*prpp)->cvar);

     }

     slapi_ch_free((void **)&(*prpp)->private);

     slapi_ch_free((void **)prpp);

@@ -712,7 +710,7 @@ repl5_inc_run(Private_Repl_Protocol *prp)

                 conn_set_agmt_changed(prp->conn);

             } else if (event_occurred(prp, EVENT_TRIGGERING_CRITERIA_MET)) { /* change available */

                 /* just ignore it and go to sleep */

-                protocol_sleep(prp, PR_INTERVAL_NO_TIMEOUT);

+                protocol_sleep(prp, 0);

             } else if ((e1 = event_occurred(prp, EVENT_WINDOW_CLOSED)) ||

                        event_occurred(prp, EVENT_BACKOFF_EXPIRED)) {

                 /* this events - should not occur - log a warning and go to sleep */

@@ -720,13 +718,13 @@ repl5_inc_run(Private_Repl_Protocol *prp)

                               "repl5_inc_run - %s: "

                               "Event %s should not occur in state %s; going to sleep\n",

                               agmt_get_long_name(prp->agmt), e1 ? event2name(EVENT_WINDOW_CLOSED) : event2name(EVENT_BACKOFF_EXPIRED), state2name(current_state));

-                protocol_sleep(prp, PR_INTERVAL_NO_TIMEOUT);

+                protocol_sleep(prp, 0);

             } else {

                 /* wait until window opens or an event occurs */

                 slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,

                               "repl5_inc_run - %s: Waiting for update window to open\n",

                               agmt_get_long_name(prp->agmt));

-                protocol_sleep(prp, PR_INTERVAL_NO_TIMEOUT);

+                protocol_sleep(prp, 0);

             }

             break;

@@ -850,7 +848,7 @@ repl5_inc_run(Private_Repl_Protocol *prp)

                 }

                 next_state = STATE_BACKOFF;

                 backoff_reset(prp_priv->backoff, repl5_inc_backoff_expired, (void *)prp);

-                protocol_sleep(prp, PR_INTERVAL_NO_TIMEOUT);