389-ds-base/SOURCES/0043-Issue-4644-Large-updates-can-reset-the-CLcache-to-th.patch

From f05f5f20a468efa82d13a99687ac5d3a5d80a3c9 Mon Sep 17 00:00:00 2001
From: tbordaz <tbordaz@redhat.com>
Date: Tue, 23 Feb 2021 13:42:31 +0100
Subject: [PATCH] Issue 4644 - Large updates can reset the CLcache to the
 beginning of the changelog (#4647)

Bug description:
	The replication agreements are using bulk load to load updates.
	For bulk load it uses a cursor with DB_MULTIPLE_KEY and DB_NEXT.
	Before using the cursor, it must be initialized with DB_SET.

	If during the cursor/DB_SET the CSN refers to an update that is larger than
	the size of the provided buffer, then the cursor remains not initialized and
	c_get returns DB_BUFFER_SMALL.

	The consequence is that the next c_get(DB_MULTIPLE_KEY and DB_NEXT) will return the
	first record in the changelog DB. This break CLcache.

Fix description:
	The fix is to harden cursor initialization so that if DB_SET fails
	because of DB_BUFFER_SMALL. It reallocates buf_data and retries a DB_SET.
	If DB_SET can not be initialized it logs a warning.

	The patch also changes the behaviour of the fix #4492.
	#4492 detected a massive (1day) jump prior the starting csn and ended the
	replication session. If the jump was systematic, for example
	if the CLcache got broken because of a too large updates, then
	replication was systematically stopped.
	This patch suppress the systematically stop, letting RA doing a big jump.
	From #4492 only remains the warning.

relates: https://github.com/389ds/389-ds-base/issues/4644

Reviewed by: Pierre Rogier (Thanks !!!!)

Platforms tested: F31
---
 .../servers/plugins/replication/cl5_clcache.c | 68 +++++++++++++++----
 1 file changed, 53 insertions(+), 15 deletions(-)

diff --git a/ldap/servers/plugins/replication/cl5_clcache.c b/ldap/servers/plugins/replication/cl5_clcache.c
index fcbca047a..90dec4d54 100644
--- a/ldap/servers/plugins/replication/cl5_clcache.c
+++ b/ldap/servers/plugins/replication/cl5_clcache.c
@@ -370,9 +370,7 @@ clcache_load_buffer(CLC_Buffer *buf, CSN **anchorCSN, int *continue_on_miss, cha
             }
             csn_as_string(buf->buf_current_csn, 0, curr);
             slapi_log_err(loglevel, buf->buf_agmt_name,
-                      "clcache_load_buffer - bulk load cursor (%s) is lower than starting csn %s. Ending session.\n", curr, initial_starting_csn);
-            /* it just end the session with UPDATE_NO_MORE_UPDATES */
-            rc = CLC_STATE_DONE;
+                      "clcache_load_buffer - bulk load cursor (%s) is lower than starting csn %s.\n", curr, initial_starting_csn);
         }
     }
 
@@ -413,10 +411,7 @@ clcache_load_buffer(CLC_Buffer *buf, CSN **anchorCSN, int *continue_on_miss, cha
                     }
                     csn_as_string(buf->buf_current_csn, 0, curr);
                     slapi_log_err(loglevel, buf->buf_agmt_name,
-                            "clcache_load_buffer - (DB_SET_RANGE) bulk load cursor (%s) is lower than starting csn %s. Ending session.\n", curr, initial_starting_csn);
-                    rc = DB_NOTFOUND;
-
-                    return rc;
+                            "clcache_load_buffer - (DB_SET_RANGE) bulk load cursor (%s) is lower than starting csn %s.\n", curr, initial_starting_csn);
                 }
             }
         }
@@ -444,6 +439,42 @@ clcache_load_buffer(CLC_Buffer *buf, CSN **anchorCSN, int *continue_on_miss, cha
     return rc;
 }
 
+/* Set a cursor to a specific key (buf->buf_key)
+ * In case buf_data is too small to receive the value, DB_SET fails
+ * (DB_BUFFER_SMALL). This let the cursor uninitialized that is
+ * problematic because further cursor DB_NEXT will reset the cursor
+ * to the beginning of the CL.
+ * If buf_data is too small, this function reallocates enough space
+ *
+ * It returns the return code of cursor->c_get
+ */
+static int
+clcache_cursor_set(DBC *cursor, CLC_Buffer *buf)
+{
+    int rc;
+    uint32_t ulen;
+    uint32_t dlen;
+    uint32_t size;
+
+    rc = cursor->c_get(cursor, &buf->buf_key, &buf->buf_data, DB_SET);
+    if (rc == DB_BUFFER_SMALL) {
+        uint32_t ulen;
+
+        /* Fortunately, buf->buf_data.size has been set by
+         * c_get() to the actual data size needed. So we can
+         * reallocate the data buffer and try to set again.
+         */
+        ulen = buf->buf_data.ulen;
+        buf->buf_data.ulen = (buf->buf_data.size / DEFAULT_CLC_BUFFER_PAGE_SIZE + 1) * DEFAULT_CLC_BUFFER_PAGE_SIZE;
+        buf->buf_data.data = slapi_ch_realloc(buf->buf_data.data, buf->buf_data.ulen);
+        slapi_log_err(SLAPI_LOG_REPL, buf->buf_agmt_name,
+                      "clcache_cursor_set - buf data len reallocated %d -> %d bytes (DB_BUFFER_SMALL)\n",
+                      ulen, buf->buf_data.ulen);
+        rc = cursor->c_get(cursor, &buf->buf_key, &buf->buf_data, DB_SET);
+    }
+    return rc;
+}
+
 static int
 clcache_load_buffer_bulk(CLC_Buffer *buf, int flag)
 {
@@ -478,17 +509,24 @@ retry:
 
         if (use_flag == DB_NEXT) {
             /* For bulk read, position the cursor before read the next block */
-            rc = cursor->c_get(cursor,
-                               &buf->buf_key,
-                               &buf->buf_data,
-                               DB_SET);
+            rc = clcache_cursor_set(cursor, buf);
         }
 
-        /*
-         * Continue if the error is no-mem since we don't need to
-         * load in the key record anyway with DB_SET.
-         */
         if (0 == rc || DB_BUFFER_SMALL == rc) {
+           /*
+            * It should not have failed  with DB_BUFFER_SMALL as we tried
+            * to adjust buf_data in clcache_cursor_set.
+            * But if it failed with DB_BUFFER_SMALL, there is a risk in clcache_cursor_get
+            * that the cursor will be reset to the beginning of the changelog.
+            * Returning an error at this point will stop replication that is
+            * a risk. So just accept the risk of a reset to the beginning of the CL
+            * and log an alarming message.
+            */
+           if (rc == DB_BUFFER_SMALL) {
+               slapi_log_err(SLAPI_LOG_WARNING, buf->buf_agmt_name,
+                             "clcache_load_buffer_bulk - Fail to position on csn=%s from the changelog (too large update ?). Risk of full CL evaluation.\n",
+                             (char *)buf->buf_key.data);
+           }
             rc = clcache_cursor_get(cursor, buf, use_flag);
         }
     }
-- 
2.31.1