Attachment 310040 Details for Bug 233642 – diffs

[patch] diffs

cvsdiffs (text/plain), 16.04 KB, created by Rich Megginson on 2008-06-23 16:37:20 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Rich Megginson

Created: 2008-06-23 16:37:20 UTC

Size: 16.04 KB

patch

obsolete

>Index: ldapserver/ldap/servers/plugins/replication/repl5.h
>===================================================================
>RCS file: /cvs/dirsec/ldapserver/ldap/servers/plugins/replication/repl5.h,v
>retrieving revision 1.10
>diff -u -8 -r1.10 repl5.h
>--- ldapserver/ldap/servers/plugins/replication/repl5.h	12 Sep 2007 23:05:24 -0000	1.10
>+++ ldapserver/ldap/servers/plugins/replication/repl5.h	23 Jun 2008 16:36:26 -0000
>@@ -481,16 +481,17 @@
> void replica_destroy_name_hash ();
> int replica_add_by_name (const char *name, Object *replica);
> int replica_delete_by_name (const char *name);
> Object* replica_get_by_name (const char *name);
> void replica_flush(Replica *r);
> void replica_get_referrals(const Replica *r, char ***referrals);
> void replica_set_referrals(Replica *r,const Slapi_ValueSet *vs);
> int replica_update_csngen_state (Replica *r, const RUV *ruv);
>+int replica_update_csngen_state_ext (Replica *r, const RUV *ruv, const CSN *extracsn);
> CSN *replica_get_purge_csn(const Replica *r);
> int replica_log_ruv_elements (const Replica *r);
> void replica_enumerate_replicas (FNEnumReplica fn, void *arg);
> int replica_reload_ruv (Replica *r);
> int replica_check_for_data_reload (Replica *r, void *arg);
> /* the functions below manipulate replica dn hash */
> int replica_init_dn_hash ();
> void replica_destroy_dn_hash ();
>Index: ldapserver/ldap/servers/plugins/replication/repl5_inc_protocol.c
>===================================================================
>RCS file: /cvs/dirsec/ldapserver/ldap/servers/plugins/replication/repl5_inc_protocol.c,v
>retrieving revision 1.11
>diff -u -8 -r1.11 repl5_inc_protocol.c
>--- ldapserver/ldap/servers/plugins/replication/repl5_inc_protocol.c	18 Oct 2007 00:08:31 -0000	1.11
>+++ ldapserver/ldap/servers/plugins/replication/repl5_inc_protocol.c	23 Jun 2008 16:36:26 -0000
>@@ -1091,23 +1091,30 @@
> 	  case EXAMINE_RUV_OK:
> 	    /* update our csn generator state with the consumer's ruv data */
> 	    dev_debug("repl5_inc_run(STATE_SENDING_UPDATES) -> examine_update_vector OK");
> 	    object_acquire(prp->replica_object);
> 	    replica = object_get_data(prp->replica_object);
> 	    rc = replica_update_csngen_state (replica, ruv); 
> 	    object_release (prp->replica_object);
> 	    replica = NULL;
>-	    if (rc != 0) /* too much skew */
>+	    if (rc == CSN_LIMIT_EXCEEDED) /* too much skew */
> 	      {
> 		slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name,
> 			"%s: Incremental protocol: fatal error - too much time skew between replicas!\n",
> 			agmt_get_long_name(prp->agmt));
> 		next_state = STATE_STOP_FATAL_ERROR;
> 	      }   
>+	    else if (rc != 0) /* internal error */
>+	      {
>+		slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name,
>+			"%s: Incremental protocol: fatal internal error updating the CSN generator!\n",
>+			agmt_get_long_name(prp->agmt));
>+		next_state = STATE_STOP_FATAL_ERROR;
>+	      }   
> 	    else
> 	      {
> 		rc = send_updates(prp, ruv, &num_changes_sent);
> 		if (rc == UPDATE_NO_MORE_UPDATES)
> 		  {
> 		    dev_debug("repl5_inc_run(STATE_SENDING_UPDATES) -> send_updates = UPDATE_NO_MORE_UPDATES -> STATE_WAIT_CHANGES");
> 		    agmt_set_last_update_status(prp->agmt, 0, 0, "Incremental update succeeded");
> 		    next_state = STATE_WAIT_CHANGES;
>Index: ldapserver/ldap/servers/plugins/replication/repl5_replica.c
>===================================================================
>RCS file: /cvs/dirsec/ldapserver/ldap/servers/plugins/replication/repl5_replica.c,v
>retrieving revision 1.16
>diff -u -8 -r1.16 repl5_replica.c
>--- ldapserver/ldap/servers/plugins/replication/repl5_replica.c	18 Oct 2007 22:40:17 -0000	1.16
>+++ ldapserver/ldap/servers/plugins/replication/repl5_replica.c	23 Jun 2008 16:36:26 -0000
>@@ -1038,58 +1038,66 @@
> 			slapi_valueset_done(r->repl_referral);
> 			slapi_valueset_set_valueset(r->repl_referral, newvs);
> 		}
> 		slapi_valueset_free(newvs); /* s_vs_set_vs makes a copy */
> 	}
> }
> 
> int 
>-replica_update_csngen_state (Replica *r, const RUV *ruv)
>+replica_update_csngen_state_ext (Replica *r, const RUV *ruv, const CSN *extracsn)
> {
>     int rc = 0;
>     CSNGen *gen;
>     CSN *csn = NULL;
>    
>     PR_ASSERT (r && ruv);
> 
>     rc = ruv_get_max_csn(ruv, &csn);
>     if (rc != RUV_SUCCESS)
>     {
>         return -1;
>     }
> 
>-    if (csn == NULL) /* ruv contains no csn - we are done */
>+    if ((csn == NULL) && (extracsn == NULL)) /* ruv contains no csn and no extra - we are done */
>     {
>         return 0;
>     }
> 
>+    if (csn_compare(extracsn, csn) > 0) /* extracsn > csn */
>+    {
>+        csn_free (&csn); /* free */
>+        csn = (CSN*)extracsn; /* use this csn to do the update */
>+    }
>+
>     PR_Lock(r->repl_lock);
> 
>     gen = (CSNGen *)object_get_data (r->repl_csngen);
>     PR_ASSERT (gen);
> 
>     rc = csngen_adjust_time (gen, csn);
>-    if (rc != CSN_SUCCESS)
>-    {
>-        rc = -1;
>-        goto done;
>-    }
>-            
>-    rc = 0;
>+    /* rc will be either CSN_SUCCESS (0) or clock skew */
> 
> done:
> 
>     PR_Unlock(r->repl_lock);
>-    if (csn)
>+    if (csn != extracsn) /* do not free the given csn */
>+    {
>         csn_free (&csn);
>+    }
> 
>     return rc;  
> }
> 
>+int 
>+replica_update_csngen_state (Replica *r, const RUV *ruv)
>+{
>+    return replica_update_csngen_state_ext(r, ruv, NULL);
>+}
>+
> /* 
>  * dumps replica state for debugging purpose 
>  */
> void
> replica_dump(Replica *r)
> {
> 	char *updatedn_list = NULL;
> 	PR_ASSERT (r);
>Index: ldapserver/ldap/servers/plugins/replication/repl_extop.c
>===================================================================
>RCS file: /cvs/dirsec/ldapserver/ldap/servers/plugins/replication/repl_extop.c,v
>retrieving revision 1.12
>diff -u -8 -r1.12 repl_extop.c
>--- ldapserver/ldap/servers/plugins/replication/repl_extop.c	18 Oct 2007 00:08:31 -0000	1.12
>+++ ldapserver/ldap/servers/plugins/replication/repl_extop.c	23 Jun 2008 16:36:26 -0000
>@@ -545,17 +545,16 @@
> 	char *protocol_oid = NULL;
> 	char *repl_root = NULL;
> 	Slapi_DN *repl_root_sdn = NULL;
> 	char **referrals = NULL;
> 	Object *replica_object = NULL;
> 	Replica *replica = NULL;
> 	void *conn;
> 	consumer_connection_extension *connext = NULL;
>-	CSN *mycsn = NULL;
> 	char *replicacsnstr = NULL;
> 	CSN *replicacsn = NULL;
> 	int zero = 0;
> 	int one = 1;
> 	RUV *ruv = NULL;
> 	struct berval **ruv_bervals = NULL;
> 	CSNGen *gen = NULL;
> 	Object *gen_obj = NULL;
>@@ -698,65 +697,47 @@
> 
> 	/* Check received CSN for clock skew */
> 	gen_obj = replica_get_csngen(replica);
> 	if (NULL != gen_obj)
> 	{
> 		gen = object_get_data(gen_obj);
> 		if (NULL != gen)
> 		{
>-			if (csngen_new_csn(gen, &mycsn, PR_FALSE /* notify */) == CSN_SUCCESS)
>+			replicacsn = csn_new_by_string(replicacsnstr);
>+			if (NULL != replicacsn)
> 			{
>-				replicacsn = csn_new_by_string(replicacsnstr);
>-				if (NULL != replicacsn)
>+				/* ONREPL - we used to manage clock skew here. However, csn generator
>+				   code already does it. The csngen also manages local skew caused by
>+				   system clock reset, so to keep it consistent, I removed code from here */
>+				/* update the state of the csn generator */
>+				rc = replica_update_csngen_state_ext (replica, supplier_ruv, replicacsn); /* too much skew */
>+				if (rc == CSN_LIMIT_EXCEEDED)
> 				{
>-                    /* ONREPL - we used to manage clock skew here. However, csn generator
>-                       code already does it. The csngen also manages local skew caused by
>-                       system clock reset, so to keep it consistent, I removed code from here */
>-					time_t diff = 0L;
>-					diff = csn_time_difference(mycsn, replicacsn);
>-					if (diff > 0)
>-					{
>-					    /* update the state of the csn generator */
>-                        rc = csngen_adjust_time (gen, replicacsn);
>-                        if (rc == CSN_LIMIT_EXCEEDED)   /* too much skew */
>-                        {
>-							response = NSDS50_REPL_EXCESSIVE_CLOCK_SKEW;
>-							goto send_response;
>-						}
>-					}
>-					else if (diff <= 0)
>-					{
>-						/* Supplier's clock is behind ours */
>-						/* XXXggood check if CSN smaller than purge point */
>-						/* response = NSDS50_REPL_BELOW_PURGEPOINT; */
>-						/* goto send_response; */
>-					}
>+					response = NSDS50_REPL_EXCESSIVE_CLOCK_SKEW;
>+					slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name,
>+									"conn=%d op=%d repl=\"%s\": "
>+									"Excessive clock skew from supplier RUV\n",
>+									connid, opid, repl_root);
>+					goto send_response;
> 				}
>-				else
>+				else if (rc != 0)
> 				{
>-					/* Oops, csnstr couldn't be converted */
>+					/* Oops, problem csn or ruv format, or memory, or .... */
> 					response = NSDS50_REPL_INTERNAL_ERROR;
> 					goto send_response;
> 				}
>+
> 			}
> 			else
> 			{
>-				/* Oops, csn generator failed */
>+				/* Oops, csnstr couldn't be converted */
> 				response = NSDS50_REPL_INTERNAL_ERROR;
> 				goto send_response;
> 			}
>-
>-            /* update csn generator's state from the supplier's ruv */
>-            rc = replica_update_csngen_state (replica, supplier_ruv); /* too much skew */
>-            if (rc != 0)
>-            {
>-                response = NSDS50_REPL_EXCESSIVE_CLOCK_SKEW;
>-				goto send_response;
>-            }
> 		}
> 		else
> 		{
> 			/* Oops, no csn generator */
> 			response = NSDS50_REPL_INTERNAL_ERROR;
> 			goto send_response;
> 		}
> 	}
>@@ -983,21 +964,16 @@
> 	{
> 		slapi_sdn_free(&bind_sdn);
> 	}
> 	/* Release reference to gen_obj */
> 	if (NULL != gen_obj)
> 	{
> 		object_release(gen_obj);
> 	}
>-	/* mycsn */
>-	if (NULL != mycsn)
>-	{
>-		csn_free(&mycsn);
>-	}
> 	/* replicacsn */
> 	if (NULL != replicacsn)
> 	{
> 		csn_free(&replicacsn);
> 	}
> 	/* resp_bere */
> 	if (NULL != resp_bere)
> 	{
>Index: ldapserver/ldap/servers/plugins/replication/windows_inc_protocol.c
>===================================================================
>RCS file: /cvs/dirsec/ldapserver/ldap/servers/plugins/replication/windows_inc_protocol.c,v
>retrieving revision 1.15
>diff -u -8 -r1.15 windows_inc_protocol.c
>--- ldapserver/ldap/servers/plugins/replication/windows_inc_protocol.c	18 Oct 2007 00:08:31 -0000	1.15
>+++ ldapserver/ldap/servers/plugins/replication/windows_inc_protocol.c	23 Jun 2008 16:36:27 -0000
>@@ -791,23 +791,30 @@
> 	  case EXAMINE_RUV_OK:
> 	    /* update our csn generator state with the consumer's ruv data */
> 	    dev_debug("windows_inc_run(STATE_SENDING_UPDATES) -> windows_examine_update_vector OK");
> 	    object_acquire(prp->replica_object);
> 	    replica = object_get_data(prp->replica_object);
> 	    rc = replica_update_csngen_state (replica, ruv); 
> 	    object_release (prp->replica_object);
> 	    replica = NULL;
>-	    if (rc != 0) /* too much skew */
>+	    if (rc == CSN_LIMIT_EXCEEDED) /* too much skew */
> 	      {
>-		slapi_log_error(SLAPI_LOG_FATAL, windows_repl_plugin_name,
>+		slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name,
> 			"%s: Incremental protocol: fatal error - too much time skew between replicas!\n",
> 			agmt_get_long_name(prp->agmt));
> 		next_state = STATE_STOP_FATAL_ERROR;
> 	      }   
>+	    else if (rc != 0) /* internal error */
>+	      {
>+		slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name,
>+			"%s: Incremental protocol: fatal internal error updating the CSN generator!\n",
>+			agmt_get_long_name(prp->agmt));
>+		next_state = STATE_STOP_FATAL_ERROR;
>+	      }   
> 	    else
> 	      {
> 		rc = send_updates(prp, ruv, &num_changes_sent);
> 		if (rc == UPDATE_NO_MORE_UPDATES)
> 		  {
> 		    dev_debug("windows_inc_run(STATE_SENDING_UPDATES) -> send_updates = UPDATE_NO_MORE_UPDATES -> STATE_WAIT_CHANGES");
> 		    agmt_set_last_update_status(prp->agmt, 0, 0, "Incremental update succeeded");
> 		    next_state = STATE_WAIT_CHANGES;
>Index: ldapserver/ldap/servers/slapd/csngen.c
>===================================================================
>RCS file: /cvs/dirsec/ldapserver/ldap/servers/slapd/csngen.c,v
>retrieving revision 1.7
>diff -u -8 -r1.7 csngen.c
>--- ldapserver/ldap/servers/slapd/csngen.c	10 Nov 2006 23:45:40 -0000	1.7
>+++ ldapserver/ldap/servers/slapd/csngen.c	23 Jun 2008 16:36:27 -0000
>@@ -55,16 +55,19 @@
> #include "slap.h"
> 
> #define CSN_MAX_SEQNUM			 0xffff		/* largest sequence number */
> #define CSN_MAX_TIME_ADJUST		 24*60*60	/* maximum allowed time adjustment (in seconds) = 1 day */ 
> #define ATTR_CSN_GENERATOR_STATE "nsState"	/* attribute that stores csn state information */
> #define STATE_FORMAT			 "%8x%8x%8x%4hx%4hx"
> #define STATE_LENGTH			 32
> #define MAX_VAL(x,y)			 ((x)>(y)?(x):(y))
>+#define CSN_CALC_TSTAMP(gen)     ((gen)->state.sampled_time + \
>+                                  (gen)->state.local_offset + \
>+                                  (gen)->state.remote_offset)
> 
> /*
>  * **************************************************************************
>  * data structures
>  * **************************************************************************
>  */
> 
> /* callback node */
>@@ -268,18 +271,17 @@
>     if (gen->state.seq_num == CSN_MAX_SEQNUM)
>     {
>         slapi_log_error (SLAPI_LOG_FATAL, NULL, "csngen_new_csn: sequence rollover; "
>                          "local offset updated.\n");
>         gen->state.local_offset ++;
>         gen->state.seq_num = 0;
>     }
> 
>-    (*csn)->tstamp = gen->state.sampled_time + gen->state.local_offset + 
>-                     gen->state.remote_offset;
>+    (*csn)->tstamp = CSN_CALC_TSTAMP(gen);
>     (*csn)->seqnum = gen->state.seq_num ++;
>     (*csn)->rid = gen->state.rid;
> 	(*csn)->subseqnum = 0;
> 
>     /* The lock is intentionally unlocked before callbacks are called.
>        This is to prevent deadlocks. The callback management code has
>        its own lock */
>     PR_RWLock_Unlock (gen->lock);
>@@ -303,58 +305,84 @@
> }
> 
> /* this function should be called when a remote CSN for the same part of
>    the dit becomes known to the server (for instance, as part of RUV during
>    replication session. In response, the generator would adjust its notion
>    of time so that it does not generate smaller csns */
> int csngen_adjust_time (CSNGen *gen, const CSN* csn)
> {
>-    time_t remote_time, remote_offset;
>+    time_t remote_time, remote_offset, cur_time;
> 	PRUint16 remote_seqnum;
>+    int rc;
> 
>     if (gen == NULL || csn == NULL)
>         return CSN_INVALID_PARAMETER;
> 
>     remote_time = csn_get_time (csn);
> 	remote_seqnum = csn_get_seqnum (csn);
> 
>     PR_RWLock_Wlock (gen->lock);
> 
>-	if (remote_seqnum > gen->state.seq_num )
>-	{
>-		if (remote_seqnum < CSN_MAX_SEQNUM)
>-		{
>-			gen->state.seq_num = remote_seqnum + 1;
>-		}
>-		else
>-		{
>-			remote_time++;
>-		}
>-	}
>+    /* make sure we have the current time */
>+    csngen_update_time();
>+    cur_time = g_sampled_time;
>+
>+    /* make sure sampled_time is current */
>+    /* must only call adjust_local_time if the generator state does not have
>+       the current time */
>+    if ((gen->state.sampled_time != cur_time) &&
>+        (CSN_SUCCESS != (rc = _csngen_adjust_local_time(gen, cur_time))))
>+    {
>+        /* _csngen_adjust_local_time will log error */
>+        PR_RWLock_Unlock (gen->lock);
>+        csngen_dump_state(gen);
>+        return rc;
>+    }
> 
>-    if (remote_time >= gen->state.sampled_time)
>+    cur_time = CSN_CALC_TSTAMP(gen);
>+    if (remote_time >= cur_time)
>     {
>-        remote_offset = remote_time - gen->state.sampled_time;
>+        if (remote_seqnum > gen->state.seq_num )
>+        {
>+            if (remote_seqnum < CSN_MAX_SEQNUM)
>+            {
>+                gen->state.seq_num = remote_seqnum + 1;
>+            }
>+            else
>+            {
>+                remote_time++;
>+            }
>+        }
>+
>+        remote_offset = remote_time - cur_time;
> 		if (remote_offset > gen->state.remote_offset)
> 		{
> 			if (remote_offset <= CSN_MAX_TIME_ADJUST)
> 			{
> 	        	gen->state.remote_offset = remote_offset;
> 			}
> 	    	else /* remote_offset > CSN_MAX_TIME_ADJUST */
> 			{
> 				slapi_log_error (SLAPI_LOG_FATAL, NULL, "csngen_adjust_time: "
>                             "adjustment limit exceeded; value - %ld, limit - %ld\n",
>                              remote_offset, (long)CSN_MAX_TIME_ADJUST);
> 				PR_RWLock_Unlock (gen->lock);
>+				csngen_dump_state(gen);
> 				return CSN_LIMIT_EXCEEDED;
> 			}
> 		}
>-    }
>+	}
>+	else if (gen->state.remote_offset > 0)
>+	{
>+		/* decrease remote offset? */
>+		/* how to decrease remote offset but ensure that we don't
>+		   generate a duplicate CSN, or a CSN smaller than one we've already
>+		   generated? */
>+	}
> 
>     PR_RWLock_Unlock (gen->lock);
> 
>     return CSN_SUCCESS;
> }
> 
> /* returns PR_TRUE if the csn was generated by this generator and 
>    PR_FALSE otherwise. */

Actions: View | Diff

Attachments on bug 233642: 308969 | 310040 | 310083 | 310193 | 310196 | 310201 | 310525 | 310526 | 314403 | 314404 | 314765 | 314770