Ticket 48978 - Update error logging with new codes

Description:  Updated all the error log messages to make them uniform, and
              use the new precise error log levels.  Also fixed copy/paste
              errors, typos, and grammar.

https://fedorahosted.org/389/ticket/48978

Reviewed by: nhosoi(Thanks!)

ldap/include/ldaplog.h

@@ -18,37 +18,45 @@
 extern "C" {
 #endif
 
-#define LDAP_DEBUG_TRACE      0x000001  /*       1 */
-#define LDAP_DEBUG_PACKETS    0x000002  /*       2 */
-#define LDAP_DEBUG_ARGS       0x000004  /*       4 */
-#define LDAP_DEBUG_CONNS      0x000008  /*       8 */
-#define LDAP_DEBUG_BER        0x000010  /*      16 */
-#define LDAP_DEBUG_FILTER     0x000020  /*      32 */
-#define LDAP_DEBUG_CONFIG     0x000040  /*      64 */
-#define LDAP_DEBUG_ACL        0x000080  /*     128 */
-#define LDAP_DEBUG_STATS      0x000100  /*     256 */
-#define LDAP_DEBUG_STATS2     0x000200  /*     512 */
-#define LDAP_DEBUG_SHELL      0x000400  /*    1024 */
-#define LDAP_DEBUG_PARSE      0x000800  /*    2048 */
-#define LDAP_DEBUG_HOUSE      0x001000  /*    4096 */
-#define LDAP_DEBUG_REPL       0x002000  /*    8192 */
-#define LDAP_DEBUG_ANY        0x004000  /*   16384 */
-#define LDAP_DEBUG_CACHE      0x008000  /*   32768 */
-#define LDAP_DEBUG_PLUGIN     0x010000  /*   65536 */
-#define LDAP_DEBUG_TIMING     0x020000  /*  131072 */
-#define LDAP_DEBUG_ACLSUMMARY 0x040000  /*  262144 */
-#define LDAP_DEBUG_BACKLDBM   0x080000  /*  524288 */
-#define LDAP_DEBUG_NUNCSTANS  0x100000  /* 1048576 */
+#define LDAP_DEBUG_TRACE      0x00000001  /*         1 */
+#define LDAP_DEBUG_PACKETS    0x00000002  /*         2 */
+#define LDAP_DEBUG_ARGS       0x00000004  /*         4 */
+#define LDAP_DEBUG_CONNS      0x00000008  /*         8 */
+#define LDAP_DEBUG_BER        0x00000010  /*        16 */
+#define LDAP_DEBUG_FILTER     0x00000020  /*        32 */
+#define LDAP_DEBUG_CONFIG     0x00000040  /*        64 */
+#define LDAP_DEBUG_ACL        0x00000080  /*       128 */
+#define LDAP_DEBUG_STATS      0x00000100  /*       256 */
+#define LDAP_DEBUG_STATS2     0x00000200  /*       512 */
+#define LDAP_DEBUG_SHELL      0x00000400  /*      1024 */
+#define LDAP_DEBUG_PARSE      0x00000800  /*      2048 */
+#define LDAP_DEBUG_HOUSE      0x00001000  /*      4096 */
+#define LDAP_DEBUG_REPL       0x00002000  /*      8192 */
+#define LDAP_DEBUG_ANY        0x00004000  /*     16384 */
+#define LDAP_DEBUG_CACHE      0x00008000  /*     32768 */
+#define LDAP_DEBUG_PLUGIN     0x00010000  /*     65536 */
+#define LDAP_DEBUG_TIMING     0x00020000  /*    131072 */
+#define LDAP_DEBUG_ACLSUMMARY 0x00040000  /*    262144 */
+#define LDAP_DEBUG_BACKLDBM   0x00080000  /*    524288 */
+#define LDAP_DEBUG_NUNCSTANS  0x00100000  /*   1048576 */
+#define LDAP_DEBUG_EMERG      0x00200000  /*   2097152 */
+#define LDAP_DEBUG_ALERT      0x00400000  /*   4194304 */
+#define LDAP_DEBUG_CRIT       0x00800000  /*   8388608 */
+#define LDAP_DEBUG_ERR        0x01000000  /*  16777216 */
+#define LDAP_DEBUG_WARNING    0x02000000  /*  33554432 */
+#define LDAP_DEBUG_NOTICE     0x04000000  /*  67108864 */
+#define LDAP_DEBUG_INFO       0x08000000  /* 134217728 */
+#define LDAP_DEBUG_DEBUG      0x10000000  /* 268435456 */
 
 #define LDAP_DEBUG_ALL_LEVELS	0xFFFFFF
 
 /* debugging stuff */
 /* Disable by default */
-#define LDAPDebug( level, sev, fmt, arg1, arg2, arg3 )
+#define LDAPDebug( level, fmt, arg1, arg2, arg3 )
 #define LDAPDebugLevelIsSet( level ) (0)
-#define LDAPDebug0Args( level, sev, fmt )
-#define LDAPDebug1Arg( level, sev, fmt, arg )
-#define LDAPDebug2Args( level, sev, fmt, arg1, arg2 )
+#define LDAPDebug0Args( level, fmt )
+#define LDAPDebug1Arg( level, fmt, arg )
+#define LDAPDebug2Args( level, fmt, arg1, arg2 )
 
 #ifdef LDAP_DEBUG
 #  undef LDAPDebug
@@ -58,28 +66,28 @@ extern "C" {
 #  undef LDAPDebugLevelIsSet
 
        extern int	slapd_ldap_debug;
-#      define LDAPDebug( level, sev, fmt, arg1, arg2, arg3 )	\
+#      define LDAPDebug( level, fmt, arg1, arg2, arg3 )	\
        { \
 		if ( slapd_ldap_debug & level ) { \
-		        slapd_log_error_proc( NULL, sev, fmt, arg1, arg2, arg3 ); \
+		        slapd_log_error_proc( level, NULL, fmt, arg1, arg2, arg3 ); \
 	    } \
        }
-#      define LDAPDebug0Args( level, sev, fmt )	\
+#      define LDAPDebug0Args( level, fmt )	\
        { \
 		if ( slapd_ldap_debug & level ) { \
-		        slapd_log_error_proc( NULL, sev, fmt ); \
+		        slapd_log_error_proc( level, NULL, fmt ); \
 	    } \
        }
-#      define LDAPDebug1Arg( level, sev, fmt, arg )      \
+#      define LDAPDebug1Arg( level, fmt, arg )      \
        { \
 		if ( slapd_ldap_debug & level ) { \
-		        slapd_log_error_proc( NULL, sev, fmt, arg ); \
+		        slapd_log_error_proc( level, NULL, fmt, arg ); \
 	    } \
        }
-#      define LDAPDebug2Args( level, sev, fmt, arg1, arg2 )    \
+#      define LDAPDebug2Args( level, fmt, arg1, arg2 )    \
        { \
 		if ( slapd_ldap_debug & level ) { \
-		        slapd_log_error_proc( NULL, sev, fmt, arg1, arg2 ); \
+		        slapd_log_error_proc( level, NULL, fmt, arg1, arg2 ); \
 	    } \
        }
 #      define LDAPDebugLevelIsSet( level ) (0 != (slapd_ldap_debug & level))

ldap/servers/plugins/acct_usability/acct_usability.c

@@ -79,7 +79,7 @@ auc_init(Slapi_PBlock *pb)
     int status = 0;
     char *plugin_identity = NULL;
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, AUC_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, AUC_PLUGIN_SUBSYSTEM,
                     "--> auc_init\n");
 
     /* Store the plugin identity for later use.
@@ -102,8 +102,8 @@ auc_init(Slapi_PBlock *pb)
         slapi_pblock_set(pb, SLAPI_PLUGIN_PRE_ENTRY_FN,
                          (void *) auc_pre_entry) != 0
         ) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, AUC_PLUGIN_SUBSYSTEM,
-                        "auc_init: failed to register plugin\n");
+        slapi_log_error(SLAPI_LOG_ERR, AUC_PLUGIN_SUBSYSTEM,
+                        "auc_init - Failed to register plugin\n");
         status = -1;
     }
 
@@ -111,7 +111,7 @@ auc_init(Slapi_PBlock *pb)
         slapi_register_supported_control(AUC_OID, SLAPI_OPERATION_SEARCH);
     }
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, AUC_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, AUC_PLUGIN_SUBSYSTEM,
                     "<-- auc_init\n");
     return status;
 }
@@ -123,13 +123,13 @@ auc_init(Slapi_PBlock *pb)
 static int
 auc_start(Slapi_PBlock * pb)
 {
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, AUC_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, AUC_PLUGIN_SUBSYSTEM,
                     "--> auc_start\n");
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, AUC_PLUGIN_SUBSYSTEM,
-                    "account usability control plug-in: ready for service\n");
+    slapi_log_error(SLAPI_LOG_PLUGIN, AUC_PLUGIN_SUBSYSTEM,
+                    "auc_start - Account usability control plug-in: ready for service\n");
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, AUC_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, AUC_PLUGIN_SUBSYSTEM,
                     "<-- auc_start\n");
 
     return 0;
@@ -141,10 +141,10 @@ auc_start(Slapi_PBlock * pb)
 static int
 auc_close(Slapi_PBlock * pb)
 {
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, AUC_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, AUC_PLUGIN_SUBSYSTEM,
                     "--> auc_close\n");
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, AUC_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, AUC_PLUGIN_SUBSYSTEM,
                     "<-- auc_close\n");
 
     return 0;
@@ -200,8 +200,8 @@ static LDAPControl *auc_create_response_ctrl(Slapi_Entry *e)
     time_t now = slapi_current_time();
 
     if (!e) {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, AUC_PLUGIN_SUBSYSTEM,
-                        "auc_create_response_ctrl: NULL entry specified.\n");
+        slapi_log_error(SLAPI_LOG_PLUGIN, AUC_PLUGIN_SUBSYSTEM,
+                        "auc_create_response_ctrl - NULL entry specified.\n");
         goto bail;
     }
 
@@ -281,7 +281,7 @@ auc_pre_search(Slapi_PBlock *pb)
     int isroot = 0;
     int ii;
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, AUC_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, AUC_PLUGIN_SUBSYSTEM,
                     "--> auc_pre_search\n");
 
     /* See if the requestor is the root DN. */
@@ -294,14 +294,14 @@ auc_pre_search(Slapi_PBlock *pb)
         const LDAPControl *ctrl = reqctrls[ii];
         if (!strcmp(ctrl->ldctl_oid, AUC_OID)) {
             if (aucctrl) { /* already specified */
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, AUC_PLUGIN_SUBSYSTEM,
-                                "The account usability control was specified more than "
+                slapi_log_error(SLAPI_LOG_ERR, AUC_PLUGIN_SUBSYSTEM,
+                                "auc_pre_search - The account usability control was specified more than "
                                 "once - it must be specified only once in the search request\n");
                 ldapcode = LDAP_PROTOCOL_ERROR;
                 ldaperrtext = "The account usability control cannot be specified more than once";
                 aucctrl = NULL;
             } else if (ctrl->ldctl_value.bv_len > 0) {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, AUC_PLUGIN_SUBSYSTEM,
+                slapi_log_error(SLAPI_LOG_ERR, AUC_PLUGIN_SUBSYSTEM,
                                 "Non-null control value specified for account usability control\n");
                 ldapcode = LDAP_PROTOCOL_ERROR;
                 ldaperrtext = "The account usability control must not have a value";
@@ -314,9 +314,9 @@ auc_pre_search(Slapi_PBlock *pb)
     }
 
     if (aucctrl && incompatible) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, AUC_PLUGIN_SUBSYSTEM,
-                        "Cannot use the account usability control and control [%s] for the same search operation\n",
-                        incompatible);
+        slapi_log_error(SLAPI_LOG_ERR, AUC_PLUGIN_SUBSYSTEM,
+                "auc_pre_search - Cannot use the account usability control and control "
+                "[%s] for the same search operation\n", incompatible);
         /* not sure if this is a hard failure - the current spec says:
            The semantics of the criticality field are specified in [RFC4511].
            In detail, the criticality of the control determines whether the
@@ -362,7 +362,7 @@ auc_pre_search(Slapi_PBlock *pb)
         slapi_send_ldap_result(pb, ldapcode, NULL, (char *)ldaperrtext, 0, NULL);
     }
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, AUC_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, AUC_PLUGIN_SUBSYSTEM,
                     "<-- auc_pre_op\n");
 
     return ldapcode;
@@ -394,16 +394,16 @@ auc_pre_entry(Slapi_PBlock *pb)
         /* grab the entry to be returned */
         slapi_pblock_get(pb, SLAPI_SEARCH_ENTRY_ORIG, &e);
         if (!e) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, AUC_PLUGIN_SUBSYSTEM,
-                            "auc_pre_entry: Unable to fetch entry.\n");
+            slapi_log_error(SLAPI_LOG_ERR, AUC_PLUGIN_SUBSYSTEM,
+                            "auc_pre_entry - Unable to fetch entry.\n");
             goto bail;
         }
 
         /* create the respose control */
         ctrl = auc_create_response_ctrl(e);
         if (!ctrl) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, AUC_PLUGIN_SUBSYSTEM,
-                "auc_pre_entry: Error creating response control for entry \"%s\".\n",
+            slapi_log_error(SLAPI_LOG_ERR, AUC_PLUGIN_SUBSYSTEM,
+                "auc_pre_entry - Error creating response control for entry \"%s\".\n",
                 slapi_entry_get_ndn(e) ? slapi_entry_get_ndn(e) : "null");
             goto bail;
         }

ldap/servers/plugins/acctpolicy/acct_config.c

@@ -48,8 +48,8 @@ acct_policy_load_config_startup( Slapi_PBlock* pb, void* plugin_id ) {
 	slapi_sdn_free( &config_sdn );
 
 	if( rc != LDAP_SUCCESS || config_entry == NULL ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PLUGIN_NAME,
-			"Failed to retrieve configuration entry %s: %d\n",
+		slapi_log_error(SLAPI_LOG_ERR, PLUGIN_NAME,
+			"acct_policy_load_config_startup - Failed to retrieve configuration entry %s: %d\n",
 			PLUGIN_CONFIG_DN, rc );
 		return( -1 );
 	}
@@ -74,8 +74,8 @@ acct_policy_entry2config( Slapi_Entry *e, acctPluginCfg *newcfg ) {
 	int rc = 0;
 
 	if( newcfg == NULL ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PLUGIN_NAME,
-			"Failed to allocate configuration structure\n" );
+		slapi_log_error(SLAPI_LOG_ERR, PLUGIN_NAME,
+			"acct_policy_entry2config - Failed to allocate configuration structure\n" );
 		return( -1 );
 	}
 
@@ -86,8 +86,8 @@ acct_policy_entry2config( Slapi_Entry *e, acctPluginCfg *newcfg ) {
 		newcfg->state_attr_name = slapi_ch_strdup( DEFAULT_LASTLOGIN_STATE_ATTR );
 	} else if (!update_is_allowed_attr(newcfg->state_attr_name)) {
 		/* log a warning that this attribute cannot be updated */
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PLUGIN_NAME,
-			"The configured state attribute [%s] cannot be updated, accounts will always become inactive.\n",
+		slapi_log_error(SLAPI_LOG_ERR, PLUGIN_NAME,
+			"acct_policy_entry2config - The configured state attribute [%s] cannot be updated, accounts will always become inactive.\n",
 			newcfg->state_attr_name );
 	}
 
@@ -139,8 +139,8 @@ acct_policy_entry2config( Slapi_Entry *e, acctPluginCfg *newcfg ) {
 		char *endptr = NULL;
 		newcfg->inactivitylimit = strtoul(config_val, &endptr, 10);
 		if (endptr && (*endptr != '\0')) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PLUGIN_NAME,
-							 "Failed to parse [%s] from the config entry: [%s] is not a valid unsigned long value\n",
+			slapi_log_error(SLAPI_LOG_ERR, PLUGIN_NAME,
+							 "acct_policy_entry2config - Failed to parse [%s] from the config entry: [%s] is not a valid unsigned long value\n",
 							 newcfg->limit_attr_name, config_val );
 
 			rc = -1;

ldap/servers/plugins/acctpolicy/acct_init.c

@@ -129,14 +129,14 @@ acct_policy_init( Slapi_PBlock *pb )
 				(void *)&acct_policy_close ) != 0 ||
 		slapi_pblock_set( pb, SLAPI_PLUGIN_START_FN,
 				(void *)acct_policy_start ) != 0 ) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PLUGIN_NAME,
-					"acct_policy_init registration failed\n" );
+			slapi_log_error(SLAPI_LOG_ERR, PLUGIN_NAME,
+					"acct_policy_init - Registration failed\n" );
 			return( CALLBACK_ERR );
 	}
 
 	if( slapi_pblock_get( pb, SLAPI_PLUGIN_IDENTITY, &plugin_id ) != 0 ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PLUGIN_NAME,
-				"acct_policy_init failed to get plugin identity\n" );
+		slapi_log_error(SLAPI_LOG_ERR, PLUGIN_NAME,
+				"acct_policy_init - Failed to get plugin identity\n" );
 		return( CALLBACK_ERR );
 	}
 
@@ -147,8 +147,8 @@ acct_policy_init( Slapi_PBlock *pb )
 		acct_preop_init, PRE_PLUGIN_DESC, NULL, plugin_id) != 0 ||
 		slapi_register_plugin("postoperation", 1, "acct_postop_init",
 		acct_postop_init, POST_PLUGIN_DESC, NULL, plugin_id) != 0 ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PLUGIN_NAME,
-			"acct_policy_init failed to register callbacks\n" );
+		slapi_log_error(SLAPI_LOG_ERR, PLUGIN_NAME,
+			"acct_policy_init  - Failed to register callbacks\n" );
 		return( CALLBACK_ERR );
 	}
 
@@ -189,14 +189,14 @@ acct_policy_start( Slapi_PBlock *pb )
 
 	/* Load plugin configuration */
 	if( acct_policy_load_config_startup( pb, plugin_id ) ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PLUGIN_NAME,
+		slapi_log_error(SLAPI_LOG_ERR, PLUGIN_NAME,
 			"acct_policy_start failed to load configuration\n" );
 		return( CALLBACK_ERR );
 	}
 
 	/* Show the configuration */
 	cfg = get_config();
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PLUGIN_NAME, "acct_policy_start config: "
+	slapi_log_error(SLAPI_LOG_PLUGIN, PLUGIN_NAME, "acct_policy_start - config: "
 		"stateAttrName=%s altStateAttrName=%s specAttrName=%s limitAttrName=%s "
 		"alwaysRecordLogin=%d\n",
 		cfg->state_attr_name, cfg->alt_state_attr_name?cfg->alt_state_attr_name:"not configured", cfg->spec_attr_name,
@@ -226,7 +226,7 @@ acct_preop_init( Slapi_PBlock *pb ) {
 			SLAPI_PLUGIN_VERSION_01 ) != 0 ||
 		slapi_pblock_set( pb, SLAPI_PLUGIN_DESCRIPTION,
 					(void *)&pre_plugin_desc ) != 0 ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PRE_PLUGIN_NAME,
+		slapi_log_error(SLAPI_LOG_ERR, PRE_PLUGIN_NAME,
 					"Failed to set plugin version or description\n" );
 		return( CALLBACK_ERR );
 	}
@@ -236,8 +236,8 @@ acct_preop_init( Slapi_PBlock *pb ) {
 	     slapi_pblock_set(pb, SLAPI_PLUGIN_PRE_MODIFY_FN, (void *) acct_mod_pre_op) != 0 ||
 	     slapi_pblock_set(pb, SLAPI_PLUGIN_PRE_DELETE_FN, (void *) acct_del_pre_op) != 0)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PRE_PLUGIN_NAME,
-				"Failed to set plugin callback function\n" );
+		slapi_log_error(SLAPI_LOG_ERR, PRE_PLUGIN_NAME,
+				"acct_preop_init - Failed to set plugin callback function\n" );
 		return( CALLBACK_ERR );
 	}
 
@@ -253,8 +253,8 @@ acct_postop_init( Slapi_PBlock *pb )
 				SLAPI_PLUGIN_VERSION_01 ) != 0 ||
 		slapi_pblock_set( pb, SLAPI_PLUGIN_DESCRIPTION,
 					(void *)&post_plugin_desc ) != 0 ) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, POST_PLUGIN_NAME,
-						"Failed to set plugin version or name\n" );
+			slapi_log_error(SLAPI_LOG_ERR, POST_PLUGIN_NAME,
+						"acct_postop_init - Failed to set plugin version or name\n" );
 			return( CALLBACK_ERR );
 	}
 
@@ -263,14 +263,14 @@ acct_postop_init( Slapi_PBlock *pb )
 	     slapi_pblock_set(pb, SLAPI_PLUGIN_POST_ADD_FN, (void *) acct_post_op) != 0 ||
 		 slapi_pblock_set(pb, SLAPI_PLUGIN_POST_MODIFY_FN, (void *) acct_post_op) != 0)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, POST_PLUGIN_NAME,
-				"Failed to set plugin callback function\n" );
+		slapi_log_error(SLAPI_LOG_ERR, POST_PLUGIN_NAME,
+				"acct_postop_init - Failed to set plugin callback function\n" );
 		return( CALLBACK_ERR );
 	}
 
 	if( slapi_pblock_get( pb, SLAPI_PLUGIN_IDENTITY, &plugin_id ) != 0 ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, POST_PLUGIN_NAME,
-				"Failed to get plugin identity\n" );
+		slapi_log_error(SLAPI_LOG_ERR, POST_PLUGIN_NAME,
+				"acct_postop_init - Failed to get plugin identity\n" );
 		return( CALLBACK_ERR );
 	}
 

ldap/servers/plugins/acctpolicy/acct_plugin.c

@@ -37,8 +37,8 @@ acct_policy_dn_is_config(Slapi_DN *sdn)
 {
     int ret = 0;
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, PLUGIN_NAME,
-                    "--> automember_dn_is_config\n");
+    slapi_log_error(SLAPI_LOG_TRACE, PLUGIN_NAME,
+                    "--> acct_policy_dn_is_config\n");
 
     if (sdn == NULL) {
         goto bail;
@@ -61,8 +61,8 @@ acct_policy_dn_is_config(Slapi_DN *sdn)
     }
 
 bail:
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, PLUGIN_NAME,
-                    "<-- automember_dn_is_config\n");
+    slapi_log_error(SLAPI_LOG_TRACE, PLUGIN_NAME,
+                    "<-- acct_policy_dn_is_config\n");
 
     return ret;
 }
@@ -83,18 +83,18 @@ acct_inact_limit( Slapi_PBlock *pb, const char *dn, Slapi_Entry *target_entry, a
 	cfg = get_config();
 	if( ( lasttimestr = get_attr_string_val( target_entry,
 		cfg->state_attr_name ) ) != NULL ) {
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PRE_PLUGIN_NAME,
-			"\"%s\" login timestamp is %s\n", dn, lasttimestr );
+		slapi_log_error(SLAPI_LOG_PLUGIN, PRE_PLUGIN_NAME,
+			"acct_inact_limit - \"%s\" login timestamp is %s\n", dn, lasttimestr );
 	} else if( cfg->alt_state_attr_name && (( lasttimestr = get_attr_string_val( target_entry,
 		cfg->alt_state_attr_name ) ) != NULL) ) {
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PRE_PLUGIN_NAME,
-			"\"%s\" alternate timestamp is %s\n", dn, lasttimestr );
+		slapi_log_error(SLAPI_LOG_PLUGIN, PRE_PLUGIN_NAME,
+			"acct_inact_limit - \"%s\" alternate timestamp is %s\n", dn, lasttimestr );
 	} else {
 		/* the primary or alternate attribute might not yet exist eg. 
 		 * if only lastlogintime is specified and it id the first login
 		 */
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PRE_PLUGIN_NAME,
-			"\"%s\" has no value for stateattr or altstateattr \n", dn );
+		slapi_log_error(SLAPI_LOG_PLUGIN, PRE_PLUGIN_NAME,
+			"acct_inact_limit - \"%s\" has no value for stateattr or altstateattr \n", dn );
 		goto done;
 	}
 
@@ -104,14 +104,14 @@ acct_inact_limit( Slapi_PBlock *pb, const char *dn, Slapi_Entry *target_entry, a
 
 	/* Finally do the time comparison */
 	if( cur_t > last_t + lim_t ) {
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PRE_PLUGIN_NAME,
-			"\"%s\" has exceeded inactivity limit  (%ld > (%ld + %ld))\n",
+		slapi_log_error(SLAPI_LOG_PLUGIN, PRE_PLUGIN_NAME,
+			"acct_inact_limit - \"%s\" has exceeded inactivity limit  (%ld > (%ld + %ld))\n",
 			dn, cur_t, last_t, lim_t );
 		rc = 1;
 		goto done;
 	} else {
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PRE_PLUGIN_NAME,
-			"\"%s\" is within inactivity limit (%ld < (%ld + %ld))\n",
+		slapi_log_error(SLAPI_LOG_PLUGIN, PRE_PLUGIN_NAME,
+			"acct_inact_limit - \"%s\" is within inactivity limit (%ld < (%ld + %ld))\n",
 			dn, cur_t, last_t, lim_t );
 	}
 
@@ -184,14 +184,14 @@ acct_record_login( const char *dn )
 	slapi_pblock_get( modpb, SLAPI_PLUGIN_INTOP_RESULT, &ldrc );
 
 	if (ldrc != LDAP_SUCCESS) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, POST_PLUGIN_NAME,
-			"Recording %s=%s failed on \"%s\" err=%d\n", cfg->always_record_login_attr,
+		slapi_log_error(SLAPI_LOG_ERR, POST_PLUGIN_NAME,
+			"acct_record_login - Recording %s=%s failed on \"%s\" err=%d\n", cfg->always_record_login_attr,
 			timestr, dn, ldrc );
 		rc = -1;
 		goto done;
 	} else {
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POST_PLUGIN_NAME,
-			"Recorded %s=%s on \"%s\"\n", cfg->always_record_login_attr, timestr, dn );
+		slapi_log_error(SLAPI_LOG_PLUGIN, POST_PLUGIN_NAME,
+			"acct_record_login - Recorded %s=%s on \"%s\"\n", cfg->always_record_login_attr, timestr, dn );
 	}
 
 done:
@@ -216,15 +216,15 @@ acct_bind_preop( Slapi_PBlock *pb )
 	acctPolicy *policy = NULL;
 	void *plugin_id;
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PRE_PLUGIN_NAME,
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRE_PLUGIN_NAME,
 		"=> acct_bind_preop\n" );
 
 	plugin_id = get_identity();
 
 	/* This does not give a copy, so don't free it */
 	if( slapi_pblock_get( pb, SLAPI_BIND_TARGET_SDN, &sdn ) != 0 ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PRE_PLUGIN_NAME,
-			"Error retrieving target DN\n" );
+		slapi_log_error(SLAPI_LOG_ERR, PRE_PLUGIN_NAME,
+			"acct_bind_preop - Error retrieving target DN\n" );
 		rc = -1;
 		goto done;
 	}
@@ -242,24 +242,24 @@ acct_bind_preop( Slapi_PBlock *pb )
 	if( ldrc != LDAP_SUCCESS ) {
 		if( ldrc != LDAP_NO_SUCH_OBJECT ) {
 			/* The problem is not a bad bind or virtual entry; halt bind */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PRE_PLUGIN_NAME,
-				"Failed to retrieve entry \"%s\": %d\n", dn, ldrc );
+			slapi_log_error(SLAPI_LOG_ERR, PRE_PLUGIN_NAME,
+				"acct_bind_preop - Failed to retrieve entry \"%s\": %d\n", dn, ldrc );
 			rc = -1;
 		}
 		goto done;
 	}
 
 	if( get_acctpolicy( pb, target_entry, plugin_id, &policy ) ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PRE_PLUGIN_NAME,
-			"Account Policy object for \"%s\" is missing\n", dn );
+		slapi_log_error(SLAPI_LOG_ERR, PRE_PLUGIN_NAME,
+			"acct_bind_preop - Account Policy object for \"%s\" is missing\n", dn );
 		rc = -1;
 		goto done;
 	}
 
 	/* Null policy means target isnt's under the influence of a policy */
 	if( policy == NULL ) {
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PRE_PLUGIN_NAME,
-			"\"%s\" is not governed by an account policy\n", dn);
+		slapi_log_error(SLAPI_LOG_PLUGIN, PRE_PLUGIN_NAME,
+			"acct_bind_preop - \"%s\" is not governed by an account policy\n", dn);
 		goto done;
 	}
 
@@ -278,7 +278,7 @@ done:
 
 	free_acctpolicy( &policy );
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PRE_PLUGIN_NAME,
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRE_PLUGIN_NAME,
 		"<= acct_bind_preop\n" );
 
 	return( rc == 0 ? CALLBACK_OK : CALLBACK_ERR );
@@ -300,15 +300,15 @@ acct_bind_postop( Slapi_PBlock *pb )
 	acctPluginCfg *cfg;
 	void *plugin_id;
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POST_PLUGIN_NAME,
+	slapi_log_error(SLAPI_LOG_PLUGIN, POST_PLUGIN_NAME,
 		"=> acct_bind_postop\n" );
 
 	plugin_id = get_identity();
 
 	/* Retrieving SLAPI_CONN_DN from the pb gives a copy */
 	if( slapi_pblock_get( pb, SLAPI_CONN_DN, &dn ) != 0 ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, POST_PLUGIN_NAME,
-			"Error retrieving bind DN\n" );
+		slapi_log_error(SLAPI_LOG_ERR, POST_PLUGIN_NAME,
+			"acct_bind_postop - Error retrieving bind DN\n" );
 		rc = -1;
 		goto done;
 	}
@@ -330,8 +330,8 @@ acct_bind_postop( Slapi_PBlock *pb )
 			plugin_id );
 
 		if( ldrc != LDAP_SUCCESS ) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, POST_PLUGIN_NAME,
-				"Failed to retrieve entry \"%s\": %d\n", dn, ldrc );
+			slapi_log_error(SLAPI_LOG_ERR, POST_PLUGIN_NAME,
+				"acct_bind_postop - Failed to retrieve entry \"%s\": %d\n", dn, ldrc );
 			rc = -1;
 			goto done;
 		} else {
@@ -360,7 +360,7 @@ done:
 
 	slapi_ch_free_string( &dn );
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POST_PLUGIN_NAME,
+	slapi_log_error(SLAPI_LOG_PLUGIN, POST_PLUGIN_NAME,
 		"<= acct_bind_postop\n" );
 
 	return( rc == 0 ? CALLBACK_OK : CALLBACK_ERR );
@@ -376,7 +376,7 @@ static int acct_pre_op( Slapi_PBlock *pb, int modop )
 	char *errstr = NULL;
 	int ret = SLAPI_PLUGIN_SUCCESS;
 
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, PRE_PLUGIN_NAME, "--> acct_pre_op\n");
+	slapi_log_error(SLAPI_LOG_TRACE, PRE_PLUGIN_NAME, "--> acct_pre_op\n");
 
 	slapi_pblock_get(pb, SLAPI_TARGET_SDN, &sdn);
 
@@ -421,10 +421,10 @@ static int acct_pre_op( Slapi_PBlock *pb, int modop )
 			}
 		} else if (modop == LDAP_CHANGETYPE_DELETE){
 				ret = LDAP_UNWILLING_TO_PERFORM;
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PRE_PLUGIN_NAME,
-					"acct_pre_op: can not delete plugin config entry [%d]\n", ret);
+				slapi_log_error(SLAPI_LOG_ERR, PRE_PLUGIN_NAME,
+					"acct_pre_op - Can not delete plugin config entry [%d]\n", ret);
 		} else {
-			errstr = slapi_ch_smprintf("acct_pre_op: invalid op type %d", modop);
+			errstr = slapi_ch_smprintf("acct_pre_op - Invalid op type %d", modop);
 			ret = LDAP_PARAM_ERROR;
 			goto bail;
 		}
@@ -441,15 +441,15 @@ static int acct_pre_op( Slapi_PBlock *pb, int modop )
 		slapi_entry_free(e);
 
 	if (ret) {
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PRE_PLUGIN_NAME,
-						"acct_pre_op: operation failure [%d]\n", ret);
+		slapi_log_error(SLAPI_LOG_PLUGIN, PRE_PLUGIN_NAME,
+						"acct_pre_op - Operation failure [%d]\n", ret);
 		slapi_send_ldap_result(pb, ret, NULL, errstr, 0, NULL);
 		slapi_ch_free((void **)&errstr);
 		slapi_pblock_set(pb, SLAPI_RESULT_CODE, &ret);
 		ret = SLAPI_PLUGIN_FAILURE;
 	}
 
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, PRE_PLUGIN_NAME, "<-- acct_pre_op\n");
+	slapi_log_error(SLAPI_LOG_TRACE, PRE_PLUGIN_NAME, "<-- acct_pre_op\n");
 
 	return ret;
 }
@@ -477,19 +477,19 @@ acct_post_op(Slapi_PBlock *pb)
 {
 	Slapi_DN *sdn = NULL;
 
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, POST_PLUGIN_NAME,
+	slapi_log_error(SLAPI_LOG_TRACE, POST_PLUGIN_NAME,
 		"--> acct_policy_post_op\n");
 
 	slapi_pblock_get(pb, SLAPI_TARGET_SDN, &sdn);
 	if (acct_policy_dn_is_config(sdn)){
 		if( acct_policy_load_config_startup( pb, get_identity() ) ) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PLUGIN_NAME,
-				"acct_policy_start failed to load configuration\n" );
+			slapi_log_error(SLAPI_LOG_ERR, PLUGIN_NAME,
+				"acct_post_op - Failed to load configuration\n" );
 			return( CALLBACK_ERR );
 		}
 	}
 
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, POST_PLUGIN_NAME,
+	slapi_log_error(SLAPI_LOG_TRACE, POST_PLUGIN_NAME,
 		"<-- acct_policy_mod_post_op\n");
 
 	return SLAPI_PLUGIN_SUCCESS;

ldap/servers/plugins/acctpolicy/acct_util.c

@@ -106,14 +106,14 @@ get_acctpolicy( Slapi_PBlock *pb, Slapi_Entry *target_entry, void *plugin_id,
 	/* Return success and NULL policy */
 	policy_dn = get_attr_string_val( target_entry, cfg->spec_attr_name );
 	if( policy_dn == NULL ) {
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PLUGIN_NAME,
-				"\"%s\" is not governed by an account inactivity "
+		slapi_log_error(SLAPI_LOG_PLUGIN, PLUGIN_NAME,
+				"get_acctpolicy - \"%s\" is not governed by an account inactivity "
 				"policy subentry\n", slapi_entry_get_ndn( target_entry ) );
 		if (cfg->inactivitylimit != ULONG_MAX) {
 			goto dopolicy;
 		}
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PLUGIN_NAME,
-				"\"%s\" is not governed by an account inactivity "
+		slapi_log_error(SLAPI_LOG_PLUGIN, PLUGIN_NAME,
+				"get_acctpolicy - \"%s\" is not governed by an account inactivity "
 				"global policy\n", slapi_entry_get_ndn( target_entry ) );
 		config_unlock();
 		return rc;
@@ -127,11 +127,11 @@ get_acctpolicy( Slapi_PBlock *pb, Slapi_Entry *target_entry, void *plugin_id,
 	/* There should be a policy but it can't be retrieved; fatal error */
 	if( policy_entry == NULL ) {
 		if( ldrc != LDAP_NO_SUCH_OBJECT ) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PLUGIN_NAME,
-				"Error retrieving policy entry \"%s\": %d\n", policy_dn, ldrc );
+			slapi_log_error(SLAPI_LOG_ERR, PLUGIN_NAME,
+				"get_acctpolicy - Error retrieving policy entry \"%s\": %d\n", policy_dn, ldrc );
 		} else {
-			slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PLUGIN_NAME,
-				"Policy entry \"%s\" is missing: %d\n", policy_dn, ldrc );
+			slapi_log_error(SLAPI_LOG_PLUGIN, PLUGIN_NAME,
+				"get_acctpolicy - Policy entry \"%s\" is missing: %d\n", policy_dn, ldrc );
 		}
 		rc = -1;
         goto done;

ldap/servers/plugins/acl/acl.c

@@ -102,8 +102,8 @@ acl_access_allowed_modrdn(
 									SLAPI_ACL_WRITE);
 
 	if ( retCode != LDAP_SUCCESS ) {
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-							"modrdn:write permission to entry not allowed\n");
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+							"acl_access_allowed_modrdn - Write permission to entry not allowed\n");
 		return(retCode);
 	}
 
@@ -117,8 +117,8 @@ acl_access_allowed_modrdn(
 	retCode = check_rdn_access( pb, e, ci_newrdn, ACLPB_SLAPI_ACL_WRITE_ADD) ;
 	slapi_ch_free_string(&ci_newrdn);
 	if ( retCode != LDAP_SUCCESS ) {
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-			"modrdn:write permission to add new naming attribute not allowed\n");
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+			"acl_access_allowed_modrdn - Write permission to add new naming attribute not allowed\n");
 		return(retCode);
 	}
 
@@ -128,8 +128,8 @@ acl_access_allowed_modrdn(
 		oldrdn = slapi_sdn_get_ndn(target_sdn);
 		retCode = check_rdn_access( pb, e, oldrdn, ACLPB_SLAPI_ACL_WRITE_DEL) ;
 		if ( retCode != LDAP_SUCCESS ) {
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-				"modrdn:write permission to delete old naming attribute not allowed\n");
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+				"acl_access_allowed_modrdn - write permission to delete old naming attribute not allowed\n");
 			return(retCode);
 		}
 	}
@@ -158,8 +158,8 @@ check_rdn_access( Slapi_PBlock *pb, Slapi_Entry *e, const char *dn, int access)
 				struct berval bv;
 			
 				if ( slapi_rdn2typeval( rdns[i], &type, &bv ) != 0 ) {
-        			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-							"modrdn: rdn2typeval (%s) failed\n", rdns[i]);
+        			slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+							"check_rdn_access - rdn2typeval (%s) failed\n", rdns[i]);
 					retCode = LDAP_INSUFFICIENT_ACCESS;
 					break;            	
 				} else {
@@ -275,8 +275,8 @@ acl_access_allowed(
 		privateBackend = slapi_be_private ( be );
 
 		 if (  !privateBackend && (be_readonly ||  slapi_config_get_readonly () )){
-			slapi_log_error	(loglevel, LOG_DEBUG, plugin_name,
-				"conn=%" NSPRIu64 " op=%d (main): Deny %s on entry(%s)"
+			slapi_log_error(loglevel, plugin_name,
+				"acl_access_allowed - conn=%" NSPRIu64 " op=%d (main): Deny %s on entry(%s)"
 				": readonly backend\n", 
 				o_connid, o_opid,
 				acl_access2str(access),
@@ -288,8 +288,8 @@ acl_access_allowed(
 	/* Check for things we need to skip */
 	TNF_PROBE_0_DEBUG(acl_skipaccess_start,"ACL","");
 	if (  acl_skip_access_check ( pb, e, access )) {
-		slapi_log_error	(loglevel, LOG_DEBUG, plugin_name,
-				"conn=%" NSPRIu64 " op=%d (main): Allow %s on entry(%s)"
+		slapi_log_error(loglevel, plugin_name,
+				"acl_access_allowed - conn=%" NSPRIu64 " op=%d (main): Allow %s on entry(%s)"
 				": root user\n", 
 				o_connid, o_opid,
 				acl_access2str(access),
@@ -312,20 +312,20 @@ acl_access_allowed(
 		aclpb =	acl_get_aclpb (	pb, ACLPB_BINDDN_PBLOCK	);
 
 	if ( !aclpb ) {
-		slapi_log_error	( SLAPI_LOG_FATAL, LOG_DEBUG, plugin_name,	 "Missing aclpb	1 \n" );
+		slapi_log_error	(SLAPI_LOG_ERR, plugin_name, "acl_access_allowed - Missing aclpb	1 \n" );
 		ret_val	= LDAP_OPERATIONS_ERROR;
 		goto cleanup_and_ret;
 	}
 
 	if (pb != aclpb->aclpb_pblock) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-		                "acl_access_allowed: Resetting aclpb_pblock %p to pblock addr %p\n",
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+		                "acl_access_allowed - Resetting aclpb_pblock %p to pblock addr %p\n",
 		                aclpb->aclpb_pblock, pb);
 		aclpb->aclpb_pblock = pb;
 	}
 
 	if ( !aclpb->aclpb_curr_entry_sdn ) {
-		slapi_log_error	( SLAPI_LOG_FATAL, LOG_ERR, plugin_name,	 "NULL aclpb_curr_entry_sdn \n" );
+		slapi_log_error(SLAPI_LOG_ERR ,plugin_name, "NULL aclpb_curr_entry_sdn \n" );
 		ret_val	= LDAP_OPERATIONS_ERROR;
 		goto cleanup_and_ret;
 	}
@@ -381,8 +381,8 @@ acl_access_allowed(
 	/* Convert access to string of rights eg SLAPI_ACL_ADD->"add". */
 	if ((right= acl_access2str(access)) == NULL) {
 		/* ERROR: unknown rights */
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-				"acl_access_allowed unknown rights:%d\n", access);
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+				"acl_access_allowed - Unknown rights:%d\n", access);
 
 		ret_val	= LDAP_OPERATIONS_ERROR;
 		goto cleanup_and_ret;
@@ -447,8 +447,8 @@ acl_access_allowed(
 		 (aclpb->aclpb_curr_entry != e) /* cannot trust the cached entry */ ) {
 		TNF_PROBE_0_DEBUG(acl_entry_first_touch_start,"ACL","");
 
-		slapi_log_error(loglevel, LOG_DEBUG, plugin_name,
-			"#### conn=%" NSPRIu64 " op=%d binddn=\"%s\"\n",
+		slapi_log_error(loglevel, plugin_name,
+			"acl_access_allowed - #### conn=%" NSPRIu64 " op=%d binddn=\"%s\"\n",
 			o_connid, o_opid, clientDn);
 		aclpb->aclpb_stat_total_entries++;
 
@@ -513,8 +513,8 @@ acl_access_allowed(
 				   DS_ATTR_ENTRY, e, 0);
                                                  
 		if (rv < 0) {
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-	    	  		"Unable to set the Slapi_Entry in the Plist\n");
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+	    	  		"acl_access_allowed - Unable to set the Slapi_Entry in the Plist\n");
 			ret_val = LDAP_OPERATIONS_ERROR;
 			goto cleanup_and_ret;
 		}
@@ -577,8 +577,8 @@ acl_access_allowed(
 		goto cleanup_and_ret;
 	}
 
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-		   "Processed attr:%s for entry:%s\n", attr ? attr : "NULL",
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+		   "acl_access_allowed - Processed attr:%s for entry:%s\n", attr ? attr : "NULL",
 		    n_edn);
 
 	/*
@@ -704,7 +704,7 @@ print_access_control_summary( char *source, int ret_val, char *clientDn,
 	}
 
 	if ( !aclpb ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,  "Missing aclpb \n" );
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,  "print_access_control_summary - Missing aclpb \n" );
 		return;
 	}
 
@@ -775,7 +775,7 @@ print_access_control_summary( char *source, int ret_val, char *clientDn,
                                 slapi_sdn_get_ndn(aclpb->aclpb_authorization_sdn):
                                 null_user);
                         if (strcasecmp(right, access_str_moddn) == 0) {
-                                 slapi_log_error(loglevel, LOG_DEBUG, plugin_name,                                                
+                                 slapi_log_error(loglevel, plugin_name, "print_access_control_summary - "                                            
                                         "conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) [from %s] to proxy (%s)"
                                          ": %s\n",
                                         o_connid, o_opid,
@@ -789,8 +789,8 @@ print_access_control_summary( char *source, int ret_val, char *clientDn,
                                         acl_info[0] ? acl_info : access_reason);
 
                         } else {
-                                slapi_log_error(loglevel, LOG_DEBUG, plugin_name, 
-                                        "conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) to proxy (%s)"
+                                slapi_log_error(loglevel, plugin_name, 
+                                        "print_access_control_summary - conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) to proxy (%s)"
                                          ": %s\n",
                                         o_connid, o_opid,
                                         source,
@@ -804,8 +804,8 @@ print_access_control_summary( char *source, int ret_val, char *clientDn,
 		} else {
                         proxy_user = null_user;
                         if (strcasecmp(right, access_str_moddn) == 0) {
-                                slapi_log_error(loglevel, LOG_DEBUG, plugin_name, 
-                                        "conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) [from %s] to proxy (%s)"
+                                slapi_log_error(loglevel, plugin_name, 
+                                        "print_access_control_summary - conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) [from %s] to proxy (%s)"
                                         ": %s\n",
                                         o_connid, o_opid,
                                         source,
@@ -818,8 +818,8 @@ print_access_control_summary( char *source, int ret_val, char *clientDn,
                                         acl_info[0] ? acl_info : access_reason);
                                 
                         } else {
-                                slapi_log_error(loglevel, LOG_DEBUG, plugin_name, 
-                                        "conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) to proxy (%s)"
+                                slapi_log_error(loglevel, plugin_name, 
+                                        "print_access_control_summary - conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) to proxy (%s)"
                                         ": %s\n",
                                         o_connid, o_opid,
                                         source,
@@ -833,8 +833,8 @@ print_access_control_summary( char *source, int ret_val, char *clientDn,
 		}
 	} else {
                 if (strcasecmp(right, access_str_moddn) == 0) {
-                        slapi_log_error(loglevel, LOG_DEBUG, plugin_name, 
-                                "conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) [from %s] to %s"
+                        slapi_log_error(loglevel, plugin_name, 
+                                "print_access_control_summary - conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) [from %s] to %s"
                                 ": %s\n",
                                 o_connid, o_opid,
                                 source,
@@ -847,8 +847,8 @@ print_access_control_summary( char *source, int ret_val, char *clientDn,
                                 acl_info[0] ? acl_info : access_reason);
                         
                 } else {
-                        slapi_log_error(loglevel, LOG_DEBUG, plugin_name, 
-                                "conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) to %s"
+                        slapi_log_error(loglevel, plugin_name, 
+                                "print_access_control_summary - conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) to %s"
                                 ": %s\n",
                                 o_connid, o_opid,
                                 source,
@@ -923,8 +923,8 @@ acl_read_access_allowed_on_entry (
 	*/
 	if ( acl_skip_access_check ( pb, e, access ) ) {
 		char   *n_edn =  slapi_entry_get_ndn ( e );
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-			  "Root access (%s) allowed on entry(%s)\n",
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+			  "acl_read_access_allowed_on_entry - Root access (%s) allowed on entry(%s)\n",
 			   acl_access2str(access), 
 			   n_edn);
 		TNF_PROBE_1_DEBUG(acl_read_access_allowed_on_entry_end ,"ACL","",
@@ -934,15 +934,15 @@ acl_read_access_allowed_on_entry (
 
 	aclpb = acl_get_aclpb ( pb, ACLPB_BINDDN_PBLOCK );
 	if ( !aclpb ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,  "Missing aclpb 2 \n" );
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,  "acl_read_access_allowed_on_entry - Missing aclpb 2 \n" );
 		TNF_PROBE_1_DEBUG(acl_read_access_allowed_on_entry_end ,"ACL","",
 							tnf_string,end,"aclpb error");
 		return LDAP_OPERATIONS_ERROR;
 	}
 	 
 	if (pb != aclpb->aclpb_pblock) {
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-		                "acl_read_access_allowed_on_entry: Resetting aclpb_pblock %p to pblock addr %p\n",
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+		                "acl_read_access_allowed_on_entry - Resetting aclpb_pblock %p to pblock addr %p\n",
 		                aclpb->aclpb_pblock, pb);
 		aclpb->aclpb_pblock = pb;
 	}
@@ -1228,7 +1228,7 @@ acl_read_access_allowed_on_attr (
 
 	/* If it's the root or acl is off or rootdse, he has all the priv */
 	if ( acl_skip_access_check ( pb, e, access ) ) {
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
 			  "Root access (%s) allowed on entry(%s)\n",
 			   acl_access2str(access), 
 			   n_edn);
@@ -1240,7 +1240,7 @@ acl_read_access_allowed_on_attr (
 
 	aclpb = acl_get_aclpb ( pb, ACLPB_BINDDN_PBLOCK );
 	if ( !aclpb ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,  "Missing aclpb 3 \n" );
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,  "acl_read_access_allowed_on_attr - Missing aclpb 3 \n" );
 		TNF_PROBE_1_DEBUG(acl_read_access_allowed_on_attr_end ,"ACL","",
 							tnf_string,aclpb_error,"");
 
@@ -1268,8 +1268,8 @@ acl_read_access_allowed_on_attr (
 
 		ret_val = acl__attr_cached_result (aclpb, attr, SLAPI_ACL_READ);
 		if (ret_val != -1) {
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-			                "MATCHED HANDLE:dn:%s attr: %s val:%d\n", 
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+			                "acl_read_access_allowed_on_attr - MATCHED HANDLE:dn:%s attr: %s val:%d\n", 
 			                n_edn, attr, ret_val );
 			if (ret_val == LDAP_SUCCESS) {
 				decision_reason.reason = ACL_REASON_EVALCONTEXT_CACHED_ALLOW;
@@ -1295,8 +1295,8 @@ acl_read_access_allowed_on_attr (
 	** rest of the attributes.
 	*/
 	if (aclpb->aclpb_state & ACLPB_ATTR_STAR_MATCHED) {
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-		 	  "STAR Access allowed on attr:%s; entry:%s \n",
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+		 	  "acl_read_access_allowed_on_attr - STAR Access allowed on attr:%s; entry:%s \n",
 		 	   attr, n_edn);
 		decision_reason.reason = ACL_REASON_EVALCONTEXT_CACHED_ATTR_STAR_ALLOW;
 		ret_val = LDAP_SUCCESS;
@@ -1664,8 +1664,8 @@ acl_modified (Slapi_PBlock *pb, int optype, Slapi_DN *e_sdn, void *change)
 		** use this group. for now just do the whole thing.
 		*/
 		if ( group_change )  {
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-			"Group Change: Invalidating entire UserGroup Cache %s\n",
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+			"acl_modified - Group Change: Invalidating entire UserGroup Cache %s\n",
 			n_dn);
 			aclg_regen_group_signature();
 			if (  (optype == SLAPI_OPERATION_MODIFY) || (optype == SLAPI_OPERATION_DELETE ) ) {
@@ -1700,8 +1700,8 @@ acl_modified (Slapi_PBlock *pb, int optype, Slapi_DN *e_sdn, void *change)
 		 * Mark this for deletion next time round--try to impact
 		 * this mainline code as little as possible.
 		*/
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-			"Marking entry %s for removal from ACL user Group Cache\n",
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+			"acl_modified - Marking entry %s for removal from ACL user Group Cache\n",
 			n_dn);
 		aclg_markUgroupForRemoval (ugroup);
 	}
@@ -1852,8 +1852,8 @@ acl_modified (Slapi_PBlock *pb, int optype, Slapi_DN *e_sdn, void *change)
 		}
 		if (NULL == parent_DN) {
 			if (NULL == new_RDN) {
-				slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-				                 "acl_modified (MODRDN %s => \"no change\"\n", 
+				slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+				                 "acl_modified - (MODRDN %s => \"no change\"\n", 
 				                 n_dn);
 				break;
 			} else {
@@ -1870,8 +1870,8 @@ acl_modified (Slapi_PBlock *pb, int optype, Slapi_DN *e_sdn, void *change)
 				new_DN = slapi_create_dn_string("%s,%s", new_RDN, parent_DN);
 			}
 		}
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-		                 "acl_modified (MODRDN %s => \"%s\"\n", n_dn, new_RDN);
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+		                 "acl_modified - (MODRDN %s => \"%s\"\n", n_dn, new_RDN);
 
 		/* Change the acls */
 		acllist_acicache_WRITE_LOCK();
@@ -1932,7 +1932,7 @@ acl__scan_for_acis(Acl_PBlock *aclpb, int *err)
 			aclpb->aclpb_handles_index[0] != -1 ) {
 			int kk = 0;
 			while ( kk < aclpb_max_selected_acls && aclpb->aclpb_handles_index[kk] != -1 ) {
-				slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "Using ACL Container:%d for evaluation\n", kk);
+				slapi_log_error(SLAPI_LOG_ACL, plugin_name, "acl__scan_for_acis - Using ACL Container:%d for evaluation\n", kk);
 				kk++;
 			}
 	}
@@ -1946,8 +1946,8 @@ acl__scan_for_acis(Acl_PBlock *aclpb, int *err)
 
 	/* Check the signature. If it has changed, start fresh */
 	if ( aclpb->aclpb_signature != acl_signature ) {
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-				"Restart the scan -- due to acl changes\n");
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+				"acl__scan_for_acis - Restart the scan due to acl changes\n");
 		acllist_init_scan ( aclpb->aclpb_pblock, LDAP_SCOPE_BASE, NULL );
 	}
 
@@ -2027,7 +2027,7 @@ acl__scan_for_acis(Acl_PBlock *aclpb, int *err)
 	aclpb->aclpb_num_deny_handles = deny_handle;
 	aclpb->aclpb_num_allow_handles = allow_handle;
 
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "Num of ALLOW Handles:%d, DENY handles:%d\n", 
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "acl__scan_for_acis - Num of ALLOW Handles:%d, DENY handles:%d\n", 
 		  aclpb->aclpb_num_allow_handles, aclpb->aclpb_num_deny_handles);
 
 	TNF_PROBE_0_DEBUG(acl__scan_for_acis_end,"ACL","");
@@ -2171,85 +2171,85 @@ acl__resource_match_aci( Acl_PBlock *aclpb, aci_t *aci, int skip_attrEval, int *
                  * (sdn was stored in the pblock)
                  */
 		if (aci->target_to) { 
-                        f = aci->target_to;
-                        dn_matched = ACL_TRUE;
-                        
-                        /* Now check if the filter is a simple or substring filter */
-                        if (aci->aci_type & ACI_TARGET_MODDN_TO_PATTERN) {
-                                /* This is a filter with substring
-                                 * e.g. ldap:///uid=*,cn=accounts,dc=example,dc=com
-                                 */
-                                slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "moddn target_to substring: %s\n",
-                                        slapi_filter_to_string(f, logbuf, sizeof(logbuf)));
-                                if ((rv = acl_match_substring(f, (char *) res_ndn, 0 /* match suffix */)) != ACL_TRUE) {
-                                        dn_matched = ACL_FALSE;
-                                        if (rv == ACL_ERR) {
-                                                slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-                                                        "acl__resource_match_aci:pattern err\n");
-                                                matches = ACL_FALSE;
-                                                goto acl__resource_match_aci_EXIT;
-                                        }
-                                }
-                        } else {
-                                /* This is a filter without substring
-                                 * e.g. ldap:///cn=accounts,dc=example,dc=com
-                                 */
-                                slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "moddn target_to: %s\n",
-                                        slapi_filter_to_string(f, logbuf, sizeof(logbuf)));
-                                slapi_filter_get_ava(f, &avaType, &avaValue);
-
-                                if (!slapi_dn_issuffix(res_ndn, avaValue->bv_val)) {
-                                        dn_matched = ACL_FALSE;
-                                }
-
-                        }
-                        if (aci->aci_type & ACI_TARGET_NOT) {
-                                matches = (dn_matched ? ACL_FALSE : ACL_TRUE);
-                        } else {
-                                matches = (dn_matched ? ACL_TRUE : ACL_FALSE);
-                        }
-                } /* target_to */
-                
-                if ((matches == ACL_TRUE) && (aci->target_from) && aclpb->aclpb_moddn_source_sdn) {
-                        f = aci->target_from;
-                        dn_matched = ACL_TRUE;
-                        slapi_filter_get_ava ( f, &avaType, &avaValue );
-                        
-                        /* Now check if the filter is a simple or substring filter */
-                        if (aci->aci_type & ACI_TARGET_MODDN_FROM_PATTERN) {
-                                /* This is a filter with substring
-                                 * e.g. ldap:///uid=*,cn=accounts,dc=example,dc=com
-                                 */
-                                slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "moddn target_from substring: %s\n",
-                                        slapi_filter_to_string(f, logbuf, sizeof(logbuf)));
-                                if ((rv = acl_match_substring(f, (char *) slapi_sdn_get_dn(aclpb->aclpb_moddn_source_sdn), 0 /* match suffix */)) != ACL_TRUE) {
-                                        dn_matched = ACL_FALSE;
-                                        if (rv == ACL_ERR) {
-                                                slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-                                                        "acl__resource_match_aci:pattern err\n");
-                                                matches = ACL_FALSE;
-                                                goto acl__resource_match_aci_EXIT;
-                                        }
-                                }
-                                
-                        } else {
-                                /* This is a filter without substring
-                                 * e.g. ldap:///cn=accounts,dc=example,dc=com
-                                 */
-                                slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "moddn target_from: %s\n",
-                                        slapi_filter_to_string(f, logbuf, sizeof(logbuf)));
-                                if (!slapi_dn_issuffix(slapi_sdn_get_dn(aclpb->aclpb_moddn_source_sdn), avaValue->bv_val)) {
-                                        dn_matched = ACL_FALSE;
-                                }
-                                
-                        }
-
-                        if (aci->aci_type & ACI_TARGET_NOT) {
-                                matches = (dn_matched ? ACL_FALSE : ACL_TRUE);
-                        } else {
-                                matches = (dn_matched ? ACL_TRUE: ACL_FALSE);
-                        }
-                }
+			f = aci->target_to;
+			dn_matched = ACL_TRUE;
+			
+			/* Now check if the filter is a simple or substring filter */
+			if (aci->aci_type & ACI_TARGET_MODDN_TO_PATTERN) {
+					/* This is a filter with substring
+					 * e.g. ldap:///uid=*,cn=accounts,dc=example,dc=com
+					 */
+					slapi_log_error(SLAPI_LOG_ACL, plugin_name, "acl__resource_match_aci - moddn target_to substring: %s\n",
+							slapi_filter_to_string(f, logbuf, sizeof(logbuf)));
+					if ((rv = acl_match_substring(f, (char *) res_ndn, 0 /* match suffix */)) != ACL_TRUE) {
+							dn_matched = ACL_FALSE;
+							if (rv == ACL_ERR) {
+									slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+											"acl__resource_match_aci:pattern err\n");
+									matches = ACL_FALSE;
+									goto acl__resource_match_aci_EXIT;
+							}
+					}
+			} else {
+					/* This is a filter without substring
+					 * e.g. ldap:///cn=accounts,dc=example,dc=com
+					 */
+					slapi_log_error(SLAPI_LOG_ACL, plugin_name, "acl__resource_match_aci - moddn target_to: %s\n",
+							slapi_filter_to_string(f, logbuf, sizeof(logbuf)));
+					slapi_filter_get_ava(f, &avaType, &avaValue);
+	
+					if (!slapi_dn_issuffix(res_ndn, avaValue->bv_val)) {
+							dn_matched = ACL_FALSE;
+					}
+	
+			}
+			if (aci->aci_type & ACI_TARGET_NOT) {
+					matches = (dn_matched ? ACL_FALSE : ACL_TRUE);
+			} else {
+					matches = (dn_matched ? ACL_TRUE : ACL_FALSE);
+			}
+		} /* target_to */
+		
+		if ((matches == ACL_TRUE) && (aci->target_from) && aclpb->aclpb_moddn_source_sdn) {
+				f = aci->target_from;
+				dn_matched = ACL_TRUE;
+				slapi_filter_get_ava ( f, &avaType, &avaValue );
+				
+				/* Now check if the filter is a simple or substring filter */
+				if (aci->aci_type & ACI_TARGET_MODDN_FROM_PATTERN) {
+						/* This is a filter with substring
+						 * e.g. ldap:///uid=*,cn=accounts,dc=example,dc=com
+						 */
+						slapi_log_error(SLAPI_LOG_ACL, plugin_name, "acl__resource_match_aci - moddn target_from substring: %s\n",
+								slapi_filter_to_string(f, logbuf, sizeof(logbuf)));
+						if ((rv = acl_match_substring(f, (char *) slapi_sdn_get_dn(aclpb->aclpb_moddn_source_sdn), 0 /* match suffix */)) != ACL_TRUE) {
+								dn_matched = ACL_FALSE;
+								if (rv == ACL_ERR) {
+										slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+												"acl__resource_match_aci - pattern err\n");
+										matches = ACL_FALSE;
+										goto acl__resource_match_aci_EXIT;
+								}
+						}
+						
+				} else {
+						/* This is a filter without substring
+						 * e.g. ldap:///cn=accounts,dc=example,dc=com
+						 */
+						slapi_log_error(SLAPI_LOG_ACL, plugin_name, "acl__resource_match_aci - moddn target_from: %s\n",
+								slapi_filter_to_string(f, logbuf, sizeof(logbuf)));
+						if (!slapi_dn_issuffix(slapi_sdn_get_dn(aclpb->aclpb_moddn_source_sdn), avaValue->bv_val)) {
+								dn_matched = ACL_FALSE;
+						}
+						
+				}
+		
+				if (aci->aci_type & ACI_TARGET_NOT) {
+						matches = (dn_matched ? ACL_FALSE : ACL_TRUE);
+				} else {
+						matches = (dn_matched ? ACL_TRUE: ACL_FALSE);
+				}
+		}
 	}
         
 	/* No need to look further */
@@ -2265,8 +2265,8 @@ acl__resource_match_aci( Acl_PBlock *aclpb, aci_t *aci, int skip_attrEval, int *
 		if ((rv = acl_match_substring(f, (char *)res_ndn, 0 /* match suffux */)) != ACL_TRUE) {
 			dn_matched = ACL_FALSE;
 			if(rv == ACL_ERR) {
-				slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-					"acl__resource_match_aci:pattern err\n");
+				slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+					"acl__resource_match_aci - Pattern err\n");
 				matches = ACL_FALSE;
 				goto acl__resource_match_aci_EXIT;	
 			}
@@ -2312,8 +2312,8 @@ acl__resource_match_aci( Acl_PBlock *aclpb, aci_t *aci, int skip_attrEval, int *
 		if ( matched_val == NULL &&
 			(aclpb->aclpb_res_type & (ACLPB_NEW_ENTRY | ACLPB_EFFECTIVE_RIGHTS))) {
 
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-				"Evaluating macro aci(%d)%s for resource %s\n",
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+				"acl__resource_match_aci - Evaluating macro aci(%d)%s for resource %s\n",
 				aci->aci_index, aci->aclName,
 				aclutil__access_str(res_right, res_right_str));
 			matched_val = acl_match_macro_in_target( res_ndn,
@@ -2350,15 +2350,15 @@ acl__resource_match_aci( Acl_PBlock *aclpb, aci_t *aci, int skip_attrEval, int *
 				acl_ht_add_and_freeOld(aclpb->aclpb_macro_ht,
 									(PLHashNumber)aci->aci_index,
 									matched_val);
-				slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-					"-- Added aci(%d) and matched value (%s) to macro ht\n",
+				slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+					"acl__resource_match_aci - Added aci(%d) and matched value (%s) to macro ht\n",
 					aci->aci_index, matched_val);
 				acl_ht_display_ht(aclpb->aclpb_macro_ht);
 			} else {
 				slapi_ch_free((void **)&matched_val);
 				if (matches == ACL_FALSE) {
-					slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-						"Evaluated ACL_FALSE\n");
+					slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+						"acl__resource_match_aci - Evaluated ACL_FALSE\n");
 				}
 			}
 		}
@@ -2427,8 +2427,8 @@ acl__resource_match_aci( Acl_PBlock *aclpb, aci_t *aci, int skip_attrEval, int *
 			}
 		} else {
 			matches = ACL_FALSE;
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-				"Returning UNDEFINED for targetfilter evaluation.\n");
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+				"acl__resource_match_aci - Returning UNDEFINED for targetfilter evaluation.\n");
 		}
 
 		if (matches == ACL_FALSE) {
@@ -2957,8 +2957,8 @@ acl__TestRights(Acl_PBlock *aclpb,int access, const char **right, const char **
 		}
 		k++;
 		index = aci->aci_index;
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-			"Evaluating DENY aci(%d) \"%s\"\n", index, aci->aclName);
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+			"acl__TestRights - Evaluating DENY aci(%d) \"%s\"\n", index, aci->aclName);
 
 		if (access  & ( SLAPI_ACL_SEARCH | SLAPI_ACL_READ)) {
 
@@ -2989,8 +2989,8 @@ acl__TestRights(Acl_PBlock *aclpb,int access, const char **right, const char **
 					*/
 					if (access & SLAPI_ACL_SEARCH) {
 						if ( result & ACLPB_CACHE_SEARCH_RES_DENY){
-							slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-						           "DENY:Found SEARCH DENY in cache\n");
+							slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+						           "acl__TestRights - DENY:Found SEARCH DENY in cache\n");
 							__acl_set_aclIndex_inResult ( aclpb, access, index );
 							result_reason->deciding_aci = aci;
 							result_reason->reason = ACL_REASON_RESULT_CACHED_DENY;
@@ -2999,8 +2999,8 @@ acl__TestRights(Acl_PBlock *aclpb,int access, const char **right, const char **
 							return ACL_RES_DENY;
 						} else if ((result & ACLPB_CACHE_SEARCH_RES_SKIP) ||
 							   (result & ACLPB_CACHE_SEARCH_RES_ALLOW)) { 
-					  	    slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-							     "DENY:Found SEARCH SKIP in cache\n");
+					  	    slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+							     "acl__TestRights - DENY:Found SEARCH SKIP in cache\n");
 							skip_eval = 1;
 							break;
 						} else {
@@ -3008,8 +3008,8 @@ acl__TestRights(Acl_PBlock *aclpb,int access, const char **right, const char **
 						}
 					} else {	/* must be READ */
 						if (result & ACLPB_CACHE_READ_RES_DENY) {
-							slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-								  "DENY:Found READ DENY in cache\n");
+							slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+								  "acl__TestRights - DENY:Found READ DENY in cache\n");
 							__acl_set_aclIndex_inResult ( aclpb, access, index );
 							result_reason->deciding_aci = aci;
 							result_reason->reason = ACL_REASON_RESULT_CACHED_DENY;
@@ -3017,8 +3017,8 @@ acl__TestRights(Acl_PBlock *aclpb,int access, const char **right, const char **
 								tnf_string,cached_deny,"");
 							return ACL_RES_DENY;
 						} else if ( result & ACLPB_CACHE_READ_RES_SKIP) {
-							slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-								  "DENY:Found READ SKIP in cache\n");
+							slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+								  "acl__TestRights - DENY:Found READ SKIP in cache\n");
 							skip_eval = 1;
 							break;
 						} else {
@@ -3035,8 +3035,8 @@ acl__TestRights(Acl_PBlock *aclpb,int access, const char **right, const char **
 
 		rv = ACL_EvalSetACL(NULL, acleval, aci->aci_handle);
 		if ( rv < 0) {
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-				"acl__TestRights:Unable to set the DENY acllist\n");
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+				"acl__TestRights - Unable to set the DENY acllist\n");
 			continue;
 		}
 		/* 
@@ -3050,7 +3050,7 @@ acl__TestRights(Acl_PBlock *aclpb,int access, const char **right, const char **
 						&deny_generic,
 						&acl_tag, &expr_num);
 
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "Processed:%d DENY handles Result:%d\n",index, rights_rv);
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name, "acl__TestRights - Processed:%d DENY handles Result:%d\n",index, rights_rv);
 
 		if (rights_rv   == ACL_RES_FAIL) {
 				result_reason->deciding_aci = aci;
@@ -3085,7 +3085,7 @@ acl__TestRights(Acl_PBlock *aclpb,int access, const char **right, const char **
 			} else {  /* cache overflow */
 				if (!(aclpb->aclpb_cache_result[j].result &
 				      ACLPB_CACHE_ERROR_REPORTED)) {
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, "acl__TestRights",
+					slapi_log_error(SLAPI_LOG_ERR, plugin_name, "acl__TestRights - "
 					    "Your ACL cache of %d slots has overflowed. "
 					    "This can happen when you have many ACIs. "
 					    "This ACI evaluation requires %d slots to cache. "
@@ -3185,8 +3185,8 @@ acl__TestRights(Acl_PBlock *aclpb,int access, const char **right, const char **
 		}
 		k++;
 		index = aci->aci_index;
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-			"%d. Evaluating ALLOW aci(%d) \"%s\"\n", k, index, aci->aclName);
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+			"acl__TestRights - %d. Evaluating ALLOW aci(%d) \"%s\"\n", k, index, aci->aclName);
 
 		if (access  & ( SLAPI_ACL_SEARCH | SLAPI_ACL_READ)) {
 
@@ -3218,8 +3218,8 @@ acl__TestRights(Acl_PBlock *aclpb,int access, const char **right, const char **
 					*/
 					if (access & SLAPI_ACL_SEARCH) {
 						if (result & ACLPB_CACHE_SEARCH_RES_ALLOW) {
-							slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-							   "Found SEARCH ALLOW in cache\n");
+							slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+							   "acl__TestRights - Found SEARCH ALLOW in cache\n");
 							__acl_set_aclIndex_inResult ( aclpb, access, index );
 							result_reason->deciding_aci = aci;
 							result_reason->reason = ACL_REASON_RESULT_CACHED_ALLOW;
@@ -3227,8 +3227,8 @@ acl__TestRights(Acl_PBlock *aclpb,int access, const char **right, const char **
 								tnf_string,cached_allow,"");
 							return ACL_RES_ALLOW;
 						} else if ( result & ACLPB_CACHE_SEARCH_RES_SKIP) {
-							slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-							   "Found SEARCH SKIP in cache\n");
+							slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+							   "acl__TestRights - Found SEARCH SKIP in cache\n");
 							skip_eval = 1;
 							break;
 						} else {
@@ -3237,8 +3237,8 @@ acl__TestRights(Acl_PBlock *aclpb,int access, const char **right, const char **
 						}
 					} else {
 						if ( result & ACLPB_CACHE_READ_RES_ALLOW) {
-							slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-							   "Found READ ALLOW in cache\n");
+							slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+							   "acl__TestRights - Found READ ALLOW in cache\n");
 							__acl_set_aclIndex_inResult ( aclpb, access, index );
 							result_reason->deciding_aci = aci;
 							result_reason->reason = ACL_REASON_RESULT_CACHED_ALLOW;
@@ -3246,8 +3246,8 @@ acl__TestRights(Acl_PBlock *aclpb,int access, const char **right, const char **
 								tnf_string,cached_allow,"");
 							return ACL_RES_ALLOW;
 						} else if ( result & ACLPB_CACHE_READ_RES_SKIP) {
-							slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-							   "Found READ SKIP in cache\n");
+							slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+							   "acl__TestRights - Found READ SKIP in cache\n");
 							skip_eval = 1;
 							break;
 						} else {
@@ -3265,8 +3265,8 @@ acl__TestRights(Acl_PBlock *aclpb,int access, const char **right, const char **
 		TNF_PROBE_0_DEBUG(acl__libaccess_start,"ACL","");
 		rv = ACL_EvalSetACL(NULL, acleval, aci->aci_handle);
 		if ( rv < 0) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-				"acl__TestRights:Unable to set the acllist\n");
+			slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+				"acl__TestRights - Unable to set the acllist\n");
 			continue;
 		}
 		/* 
@@ -3307,7 +3307,7 @@ acl__TestRights(Acl_PBlock *aclpb,int access, const char **right, const char **
 			} else {  /* cache overflow */
 				if (!(aclpb->aclpb_cache_result[j].result &
 				      ACLPB_CACHE_ERROR_REPORTED)) {
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, "acl__TestRights",
+					slapi_log_error(SLAPI_LOG_ERR, plugin_name, "acl__TestRights - "
 					    "Your ACL cache of %d slots has overflowed. "
 					    "This can happen when you have many ACIs. "
 					    "This ACI evaluation requires %d slots to cache. "
@@ -3550,12 +3550,12 @@ acl__attr_cached_result (struct acl_pblock *aclpb, char *attr, int access )
 
 	if (aclpb->aclpb_state & ACLPB_HAS_ACLCB_EVALCONTEXT ) {
 		c_evalContext = &aclpb->aclpb_prev_opEval_context;
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-			    "acl__attr_cached_result:Using Context: ACLPB_ACLCB\n" );
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+			    "acl__attr_cached_result - Using Context: ACLPB_ACLCB\n" );
 	} else {
 		c_evalContext = &aclpb->aclpb_prev_entryEval_context;
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-			    "acl__attr_cached_result:Using Context: ACLPB_PREV\n" );
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+			    "acl__attr_cached_result - Using Context: ACLPB_PREV\n" );
 	}
 
 	if ( attr == NULL ) {
@@ -3739,8 +3739,8 @@ acl__scan_match_handles ( Acl_PBlock *aclpb, int type)
 					** to nullify the cached result
 					 */
 					if ( aci->aci_ruleType & ACI_ATTR_RULES ) {
-						slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-							"Found an attr Rule [Name:%s Index:%d\n", aci->aclName, 
+						slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+							"acl__scan_match_handles - Found an attr Rule [Name:%s Index:%d\n", aci->aclName, 
 							aci->aci_index );
 						for ( jj =0; jj < c_evalContext->acle_numof_attrs; jj++ ) {
 							AclAttrEval     *a_eval = &c_evalContext->acle_attrEval[jj];
@@ -4174,8 +4174,8 @@ acl__recompute_acl (  	Acl_PBlock 		*aclpb,
 		goto set_result_status;
 	}
 
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-			"Recomputing the ACL Index:%d for entry:%s\n",
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+			"acl__recompute_acl - Recomputing the ACL Index:%d for entry:%s\n",
 			aciIndex, slapi_entry_get_ndn ( aclpb->aclpb_curr_entry) );
 				
 	/* First find this one ACL and then evaluate it. */
@@ -4292,9 +4292,7 @@ acl__test_filter ( Slapi_Entry *entry, struct slapi_filter *f, int filter_sense)
 
 		/* slapi_vattr_filter_test() returns 0 for match */
 
-		filter_matched = !slapi_vattr_filter_test(NULL, entry, 
-					    					f,
-					    					0 /*don't do acess chk*/);
+		filter_matched = !slapi_vattr_filter_test(NULL, entry, f, 0 /*don't do acess chk*/);
 		
 		if (filter_sense) {
 			return(filter_matched ? ACL_TRUE : ACL_FALSE);

ldap/servers/plugins/acl/acl_ext.c

@@ -98,8 +98,8 @@ acl_get_ext (ext_type type, void *object)
 		void			*data;
 
 		if ( type >= ACL_EXT_ALL ) {
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-								"Invalid extension type:%d\n", type );
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+								"acl_get_ext - Invalid extension type:%d\n", type );
 			return NULL;
 		} 
 
@@ -147,8 +147,8 @@ aclext_alloc_lockarray ( )
 
 	for ( i = 0; i < ACLEXT_MAX_LOCKS; i++) {
 		if (NULL == (lock = PR_NewLock()) ) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, 
-			   "Unable to allocate locks used for private extension\n");
+			slapi_log_error(SLAPI_LOG_ERR, plugin_name, 
+			   "aclext_alloc_lockarray - Unable to allocate locks used for private extension\n");
 			return 1;
 		}
 		extLockArray.lockArray[i] = lock;
@@ -196,8 +196,8 @@ acl_conn_ext_constructor ( void *object, void *parent )
 	struct acl_cblock *ext = NULL;
 	ext = (struct acl_cblock * ) slapi_ch_calloc (1, sizeof (struct acl_cblock ) );
 	if (( ext->aclcb_lock = aclext_get_lock () ) == NULL ) {
- 		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-              		"Unable to get Read/Write lock for CONNECTION extension\n");
+ 		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+              		"acl_conn_ext_constructor - Unable to get Read/Write lock for CONNECTION extension\n");
 		slapi_ch_free ( (void **) &ext );
 		return NULL;
 	}
@@ -252,8 +252,8 @@ acl_operation_ext_constructor ( void *object, void *parent )
 
 	aclpb = acl__get_aclpb_from_pool();
 	if ( NULL == aclpb ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, 
-						"Operation extension allocation Failed\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, 
+						"acl_operation_ext_constructor - Operation extension allocation Failed\n");
 	}
 
 	TNF_PROBE_0_DEBUG(acl_operation_ext_constructor_end ,"ACL","");
@@ -286,7 +286,7 @@ acl_operation_ext_destructor ( void *ext, void *object, void *parent )
 		goto clean_aclpb;
 
 	if ( NULL == aclpb->aclpb_authorization_sdn ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, "NULL aclcb_autorization_sdn\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, "acl_operation_ext_destructor - NULL aclcb_autorization_sdn\n");
 		goto clean_aclpb;
 	}
 
@@ -311,8 +311,8 @@ acl_operation_ext_destructor ( void *ext, void *object, void *parent )
 			goto clean_aclpb;
 		}
 		if ( !aclcb->aclcb_lock ) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-			        "aclcb lock released! aclcb cache can't be refreshed\n");
+			slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+			        "acl_operation_ext_destructor - aclcb lock released! aclcb cache can't be refreshed\n");
 			PR_Unlock ( shared_lock );
 			goto clean_aclpb;
 		}
@@ -395,8 +395,8 @@ acl_get_aclpb (  Slapi_PBlock *pb, int type )
 	else if ( type == ACLPB_PROXYDN_PBLOCK )
 		return aclpb->aclpb_proxy;
 	else
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-						"acl_get_aclpb: Invalid aclpb type %d\n", type );
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+						"acl_get_aclpb - Invalid aclpb type %d\n", type );
 	return NULL;
 }
 /*
@@ -565,7 +565,7 @@ acl__get_aclpb_from_pool(void)
 
 		aclQueue->aclq_nfree--;		
 	} else {
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
 				"Unable to find a free aclpb\n");
 		aclpb = acl__malloc_aclpb ();
 	}
@@ -635,39 +635,39 @@ acl__malloc_aclpb(void)
 	
 	/* Now set the propert we need  for ACL evaluations */
 	if ((aclpb->aclpb_proplist = PListNew(NULL)) == NULL) {
-		 slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
+		 slapi_log_error(SLAPI_LOG_ERR, plugin_name,
 			    "Unable to allocate the aclprop PList\n");
 			goto error;
 	}
 
 	if (PListInitProp(aclpb->aclpb_proplist, 0, DS_PROP_ACLPB, aclpb, 0) < 0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, 
-					"Unable to set the ACL PBLOCK in the Plist\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, 
+					"acl__malloc_aclpb - Unable to set the ACL PBLOCK in the Plist\n");
 		goto error;
 	}
 	if (PListInitProp(aclpb->aclpb_proplist, 0, DS_ATTR_USERDN, aclpb, 0) < 0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, 
-					"Unable to set the USER DN in the Plist\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, 
+					"acl__malloc_aclpb - Unable to set the USER DN in the Plist\n");
 		goto error;
 	}
 	if (PListInitProp(aclpb->aclpb_proplist, 0, DS_ATTR_AUTHTYPE, aclpb, 0) < 0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, 
-					"Unable to set the AUTH TYPE in the Plist\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, 
+					"acl__malloc_aclpb - Unable to set the AUTH TYPE in the Plist\n");
 		goto error;
 	}
 	if (PListInitProp(aclpb->aclpb_proplist, 0, DS_ATTR_LDAPI, aclpb, 0) < 0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-					"Unable to set the AUTH TYPE in the Plist\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+					"acl__malloc_aclpb - Unable to set the AUTH TYPE in the Plist\n");
 		goto error;
 	}
 	if (PListInitProp(aclpb->aclpb_proplist, 0, DS_ATTR_ENTRY, aclpb, 0) < 0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, 
-					"Unable to set the ENTRY TYPE in the Plist\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, 
+					"acl__malloc_aclpb - Unable to set the ENTRY TYPE in the Plist\n");
 		goto error;
 	}
 	if (PListInitProp(aclpb->aclpb_proplist, 0, DS_ATTR_SSF, aclpb, 0) < 0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-					"Unable to set the SSF in the Plist\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+					"acl__malloc_aclpb - Unable to set the SSF in the Plist\n");
 		goto error;
 	}
 
@@ -681,8 +681,8 @@ acl__malloc_aclpb(void)
 	/* allocate the acleval struct */
 	aclpb->aclpb_acleval = (ACLEvalHandle_t *) ACL_EvalNew(NULL, NULL);
 	if (aclpb->aclpb_acleval == NULL) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, 
-							"Unable to allocate the acleval block\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, 
+							"acl__malloc_aclpb - Unable to allocate the acleval block\n");
 		goto error;
 	}
 	/*
@@ -807,7 +807,7 @@ acl_init_aclpb ( Slapi_PBlock *pb, Acl_PBlock *aclpb, const char *ndn, int copy_
 	
 
 	if ( NULL == aclpb ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, "acl_init_aclpb:No ACLPB\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, "acl_init_aclpb - No ACLPB\n");
 		return;
 	}
 
@@ -834,27 +834,27 @@ acl_init_aclpb ( Slapi_PBlock *pb, Acl_PBlock *aclpb, const char *ndn, int copy_
 
 	if (PListAssignValue(aclpb->aclpb_proplist, DS_ATTR_USERDN,
 					slapi_sdn_get_ndn(aclpb->aclpb_authorization_sdn), 0) < 0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-						"Unable to set the USER DN in the Plist\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+						"acl_init_aclpb - Unable to set the USER DN in the Plist\n");
 		return;
 	}
 	slapi_pblock_get ( pb, SLAPI_OPERATION_AUTHTYPE, &authType );
 	if (PListAssignValue(aclpb->aclpb_proplist, DS_ATTR_AUTHTYPE, authType, 0) < 0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, 
-				"Unable to set the AUTH TYPE in the Plist\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, 
+				"acl_init_aclpb - Unable to set the AUTH TYPE in the Plist\n");
 		return;
 	}
 	if(slapi_is_ldapi_conn(pb)){
 		if(PListAssignValue(aclpb->aclpb_proplist, DS_ATTR_LDAPI, "yes", 0) < 0){
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-					"Unable to set the AUTH TYPE in the Plist\n");
+			slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+					"acl_init_aclpb - Unable to set the AUTH TYPE in the Plist\n");
 			return;
 		}
 	}
 	slapi_pblock_get ( pb, SLAPI_OPERATION_SSF, &ssf);
 	if (PListAssignValue(aclpb->aclpb_proplist, DS_ATTR_SSF, (const void *)ssf, 0) < 0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-				"Unable to set the SSF in the Plist\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+				"acl_init_aclpb - Unable to set the SSF in the Plist\n");
 		return;
 	}
 
@@ -890,8 +890,8 @@ acl_init_aclpb ( Slapi_PBlock *pb, Acl_PBlock *aclpb, const char *ndn, int copy_
 		/* This could happen if the client is dead and we are in
 		** process of abondoning this operation
 		*/
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-					"No CONNECTION extension\n");
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+					"acl_init_aclpb - No CONNECTION extension\n");
 
 	} else if ( aclcb->aclcb_state == -1 ) {
 		/* indicate that we need to update the cache */
@@ -959,8 +959,8 @@ acl__done_aclpb ( struct acl_pblock *aclpb )
 
 	/* Check the state */
 	if (aclpb->aclpb_state & ~ACLPB_STATE_ALL) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, 
-			   "The aclpb.state value (%d) is incorrect. Exceeded the limit (%d)\n",
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, 
+			   "acl__done_aclpb - The aclpb state value (%d) is incorrect. Exceeded the limit (%d)\n",
 			   aclpb->aclpb_state, ACLPB_STATE_ALL);
 		dump_aclpb_info = 1;
 
@@ -974,24 +974,24 @@ acl__done_aclpb ( struct acl_pblock *aclpb )
 	aclg_reset_userGroup ( aclpb );
 
 	if ( aclpb->aclpb_res_type & ~ACLPB_RESTYPE_ALL ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, 
-			   "The aclpb res_type value (%d) has exceeded. Limit is (%d)\n",
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, 
+			   "acl__done_aclpb - The aclpb res_type value (%d) has exceeded. Limit is (%d)\n",
 				aclpb->aclpb_res_type, ACLPB_RESTYPE_ALL );
 		dump_aclpb_info = 1;
 	}
 
 	if ( dump_aclpb_info ) {
 		const char *ndn;
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
 							"ACLPB value is:%p\n", aclpb );
 	
 		ndn = slapi_sdn_get_ndn ( aclpb->aclpb_curr_entry_sdn );	
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, "curr_entry:%p  num_entries:%d curr_dn:%p\n", 
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, "acl__done_aclpb - curr_entry:%p  num_entries:%d curr_dn:%p\n", 
 				aclpb->aclpb_curr_entry ? (char *) aclpb->aclpb_curr_entry : "NULL", 
 				aclpb->aclpb_num_entries, 
 				ndn ? ndn : "NULL");
 
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, "Last attr:%p, Plist:%p acleval: %p\n",
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, "acl__done_aclpb - Last attr:%p, Plist:%p acleval: %p\n",
 					aclpb->aclpb_Evalattr ? aclpb->aclpb_Evalattr : "NULL",
 					aclpb->aclpb_proplist ? (char *) aclpb->aclpb_proplist : "NULL",
 					aclpb->aclpb_acleval  ? (char *) aclpb->aclpb_acleval : "NULL" );
@@ -1162,24 +1162,24 @@ acl__dump_stats ( struct acl_pblock *aclpb , const char *block_type)
 	}
 
 	/* DUMP STAT INFO */
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
 			"**** ACL OPERATION STAT BEGIN ( aclpb:%p Block type: %s): Conn:%" PRIu64 " Operation:%d  *******\n",
 			aclpb, block_type, connid, opid );
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "\tNumber of entries scanned: %d\n",
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "\tNumber of entries scanned: %d\n",
 					aclpb->aclpb_stat_total_entries);
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "\tNumber of times ACL List scanned: %d\n",
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "\tNumber of times ACL List scanned: %d\n",
 					aclpb->aclpb_stat_acllist_scanned);
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "\tNumber of ACLs with target matched:%d\n",
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "\tNumber of ACLs with target matched:%d\n",
 					aclpb->aclpb_stat_num_tmatched_acls);
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "\tNumber of times acl resource matched:%d\n",
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "\tNumber of times acl resource matched:%d\n",
 					aclpb->aclpb_stat_aclres_matched);
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "\tNumber of times ANOM list scanned:%d\n",
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "\tNumber of times ANOM list scanned:%d\n",
 					aclpb->aclpb_stat_anom_list_scanned);
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "\tNumber of times Context was copied:%d\n",
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "\tNumber of times Context was copied:%d\n",
 					aclpb->aclpb_stat_num_copycontext);
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "\tNumber of times Attrs was copied:%d\n",
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "\tNumber of times Attrs was copied:%d\n",
 					aclpb->aclpb_stat_num_copy_attrs);
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, " **** ACL OPERATION STAT END  *******\n");
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, " **** ACL OPERATION STAT END  *******\n");
 }
 #endif
 /****************************************************************************/

ldap/servers/plugins/acl/aclanom.c

@@ -61,8 +61,8 @@ aclanom_init ()
                 slapi_ch_calloc (1, sizeof ( struct anom_profile ) );
 
 	if (( anom_rwlock = slapi_new_rwlock()) == NULL ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-				"Failed in getting the ANOM rwlock\n" );
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+				"aclanom_init - Failed in getting the ANOM rwlock\n" );
 		return 1;
 	}
 	return 0;
@@ -115,7 +115,7 @@ aclanom_gen_anomProfile (acl_lock_flag_t lock_flag)
 	/* We have a new signature now */
 	a_profile->anom_signature =  acl_get_aclsignature();
 
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "GENERATING ANOM USER PROFILE\n");
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "aclanom_gen_anomProfile - GENERATING ANOM USER PROFILE\n");
 	/*
 	** Go thru the ACL list and find all the ACLs  which apply to the 
 	** anonymous user i.e anyone. we can generate a profile for that.
@@ -140,8 +140,8 @@ aclanom_gen_anomProfile (acl_lock_flag_t lock_flag)
 			( (aci->aci_type & ACI_CONTAIN_NOT_USERDN ) ||
 			  (aci->aci_type & ACI_CONTAIN_NOT_GROUPDN)	||
 				(aci->aci_type & ACI_CONTAIN_NOT_ROLEDN)) ){
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-				"CANCELLING ANOM USER PROFILE BECAUSE OF DENY RULE\n");
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+				"aclanom_gen_anomProfile - CANCELLING ANOM USER PROFILE BECAUSE OF DENY RULE\n");
 			goto cleanup;
 		}
 
@@ -158,8 +158,8 @@ aclanom_gen_anomProfile (acl_lock_flag_t lock_flag)
 		** let's not consider complex rules - let's make this lean.
 		*/
 		if ( aci->aci_ruleType & ~ACI_USERDN_RULE ){
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-				"CANCELLING ANOM USER PROFILE BECAUSE OF COMPLEX RULE\n");
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+				"aclanom_gen_anomProfile - CANCELLING ANOM USER PROFILE BECAUSE OF COMPLEX RULE\n");
 			goto cleanup;
 		}
 
@@ -179,8 +179,8 @@ aclanom_gen_anomProfile (acl_lock_flag_t lock_flag)
 				continue;
 			} else {
 				/* clean up before leaving */
-				slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-					"CANCELLING ANOM USER PROFILE 1\n");
+				slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+					"aclanom_gen_anomProfile - CANCELLING ANOM USER PROFILE 1\n");
 				goto cleanup;
 			}
 
@@ -190,7 +190,7 @@ aclanom_gen_anomProfile (acl_lock_flag_t lock_flag)
 		a_numacl = a_profile->anom_numacls++;
 
 		if ( a_profile->anom_numacls == ACL_ANOM_MAX_ACL ) {
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "CANCELLING ANOM USER PROFILE 2\n");
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name, "aclanom_gen_anomProfile - CANCELLING ANOM USER PROFILE 2\n");
 			goto cleanup;
 		}
 
@@ -211,8 +211,8 @@ aclanom_gen_anomProfile (acl_lock_flag_t lock_flag)
 			a_profile->anom_targetinfo[a_numacl].anom_filter =  slapi_str2filter ( aci->targetFilterStr );
 			if (NULL == a_profile->anom_targetinfo[a_numacl].anom_filter) {
 				const char	*dn = slapi_sdn_get_dn ( aci->aci_sdn );
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-								"Error: invalid filter [%s] in anonymous aci in entry [%s]\n",
+				slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+								"aclanom_gen_anomProfile - Invalid filter [%s] in anonymous aci in entry [%s]\n",
 								aci->targetFilterStr, dn);
 				goto cleanup;
 			}
@@ -237,8 +237,8 @@ aclanom_gen_anomProfile (acl_lock_flag_t lock_flag)
 				destattrArray[i] = NULL;
 				/* clean up before leaving */
 				aclanom__del_profile (0);
-				slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-					"CANCELLING ANOM USER PROFILE 3\n");
+				slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+					"aclanom_gen_anomProfile - CANCELLING ANOM USER PROFILE 3\n");
 				goto cleanup;
 			}
 
@@ -522,8 +522,8 @@ aclanom_match_profile (Slapi_PBlock *pb, struct acl_pblock *aclpb, Slapi_Entry *
 			const char				*aci_ndn;
 			aci_ndn = slapi_sdn_get_ndn (acl_anom_profile->anom_targetinfo[i].anom_target);
 			if (access & SLAPI_ACL_MODDN) {
-				slapi_log_error(loglevel, LOG_DEBUG, plugin_name, 
-					"conn=%" NSPRIu64 " op=%d: Allow access on entry(%s).attr(%s) (from %s) to anonymous: acidn=\"%s\"\n",
+				slapi_log_error(loglevel, plugin_name, 
+					"aclanom_match_profile - conn=%" NSPRIu64 " op=%d: Allow access on entry(%s).attr(%s) (from %s) to anonymous: acidn=\"%s\"\n",
 					o_connid, o_opid,
 					ndn,
 					attr ? attr:"NULL",
@@ -531,8 +531,8 @@ aclanom_match_profile (Slapi_PBlock *pb, struct acl_pblock *aclpb, Slapi_Entry *
 					aci_ndn);
 				
 			} else {
-				slapi_log_error(loglevel, LOG_DEBUG, plugin_name, 
-					"conn=%" NSPRIu64 " op=%d: Allow access on entry(%s).attr(%s) to anonymous: acidn=\"%s\"\n",
+				slapi_log_error(loglevel, plugin_name, 
+					"aclanom_match_profile - conn=%" NSPRIu64 " op=%d: Allow access on entry(%s).attr(%s) to anonymous: acidn=\"%s\"\n",
 					o_connid, o_opid,
 					ndn,
 					attr ? attr:"NULL",
@@ -540,14 +540,14 @@ aclanom_match_profile (Slapi_PBlock *pb, struct acl_pblock *aclpb, Slapi_Entry *
 			}
 		} else {
 			if (access & SLAPI_ACL_MODDN) {
-				slapi_log_error(loglevel, LOG_DEBUG, plugin_name,
-					"conn=%" NSPRIu64 " op=%d: Deny access on entry(%s).attr(%s) (from %s) to anonymous\n",
+				slapi_log_error(loglevel, plugin_name,
+					"aclanom_match_profile - conn=%" NSPRIu64 " op=%d: Deny access on entry(%s).attr(%s) (from %s) to anonymous\n",
 					o_connid, o_opid,
 					ndn, attr ? attr:"NULL" ,
 					aclpb->aclpb_moddn_source_sdn ? slapi_sdn_get_dn(aclpb->aclpb_moddn_source_sdn) : "NULL");
 			} else {
-				slapi_log_error(loglevel, LOG_DEBUG, plugin_name,
-					"conn=%" NSPRIu64 " op=%d: Deny access on entry(%s).attr(%s) to anonymous\n",
+				slapi_log_error(loglevel, plugin_name,
+					"aclanom_match_profile - conn=%" NSPRIu64 " op=%d: Deny access on entry(%s).attr(%s) to anonymous\n",
 					o_connid, o_opid,
 					ndn, attr ? attr:"NULL" );
 			}

ldap/servers/plugins/acl/acleffectiverights.c

@@ -108,8 +108,8 @@ _ger_g_permission_granted (
 	}
 	if ( slapi_sdn_get_dn (requestor_sdn) == NULL )
 	{
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-				"_ger_g_permission_granted: anonymous has no g permission\n" );
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+				"_ger_g_permission_granted - Anonymous has no g permission\n" );
 		rc = LDAP_INSUFFICIENT_ACCESS;
 		goto bailout;
 	}
@@ -144,8 +144,8 @@ _ger_g_permission_granted (
 	}
 
 	aclutil_str_append ( errbuf, "get-effective-rights: requestor has no g permission on the entry" );
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-				"_ger_g_permission_granted: %s\n", *errbuf);
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+				"_ger_g_permission_granted - %s\n", *errbuf);
 	rc = LDAP_INSUFFICIENT_ACCESS;
 
 bailout:
@@ -191,7 +191,7 @@ _ger_parse_control (
 		 subjectber->bv_len == 0 )
 	{
 		aclutil_str_append ( errbuf, "get-effective-rights: missing subject" );
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, "%s\n", *errbuf );
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, "_ger_parse_control - %s\n", *errbuf );
                 if (iscritical)
                     return LDAP_UNAVAILABLE_CRITICAL_EXTENSION; /* RFC 4511 4.1.11 */
                 else
@@ -215,7 +215,7 @@ _ger_parse_control (
 		if ( ber == NULL )
 		{
 			aclutil_str_append ( errbuf, "get-effective-rights: ber_init failed for the subject" );
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, "%s\n", *errbuf );
+			slapi_log_error(SLAPI_LOG_ERR, plugin_name, "_ger_parse_control - %s\n", *errbuf );
                         if (iscritical)
                             return LDAP_UNAVAILABLE_CRITICAL_EXTENSION; /* RFC 4511 4.1.11 */
                         else
@@ -225,7 +225,7 @@ _ger_parse_control (
 		if ( ber_scanf (ber, "a", &orig) == LBER_ERROR )
 		{
 			aclutil_str_append ( errbuf, "get-effective-rights: invalid ber tag in the subject" );
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, "%s\n", *errbuf );
+			slapi_log_error(SLAPI_LOG_ERR, plugin_name, "_ger_parse_control - %s\n", *errbuf );
 			ber_free ( ber, 1 );
                         if (iscritical)
                             return LDAP_UNAVAILABLE_CRITICAL_EXTENSION; /* RFC 4511 4.1.11 */
@@ -244,7 +244,7 @@ _ger_parse_control (
 	if ( NULL == orig || subjectndnlen < 3 || strncasecmp ( "dn:", orig, 3 ) != 0 )
 	{
 		aclutil_str_append ( errbuf, "get-effective-rights: subject is not dnAuthzId" );
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, "%s\n", *errbuf );
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, "_ger_parse_control - %s\n", *errbuf );
 		slapi_ch_free_string(&orig);
                 if (iscritical)
                     return LDAP_UNAVAILABLE_CRITICAL_EXTENSION; /* RFC 4511 4.1.11 */
@@ -257,7 +257,7 @@ _ger_parse_control (
 	if (NULL == normed) {
 		aclutil_str_append (errbuf, "get-effective-rights: failed to normalize dn: ");
 		aclutil_str_append (errbuf, orig);
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, "%s\n", *errbuf);
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, "_ger_parse_control - %s\n", *errbuf);
 		slapi_ch_free_string(&orig);
                 if (iscritical)
                     return LDAP_UNAVAILABLE_CRITICAL_EXTENSION;  /* RFC 4511 4.1.11 */
@@ -403,24 +403,24 @@ _ger_get_entry_rights (
 
 	_append_gerstr(gerstr, gerstrsize, gerstrcap, "entryLevelRights: ", NULL);
 
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-		"_ger_get_entry_rights: SLAPI_ACL_READ\n" );
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+		"_ger_get_entry_rights - SLAPI_ACL_READ\n" );
 	if (acl_access_allowed(gerpb, e, "*", NULL, SLAPI_ACL_READ) == LDAP_SUCCESS)
 	{
 		/* v - view e */
 		entryrights |= SLAPI_ACL_READ;
 		_append_gerstr(gerstr, gerstrsize, gerstrcap, "v", NULL);
 	}
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-		"_ger_get_entry_rights: SLAPI_ACL_ADD\n" );
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+		"_ger_get_entry_rights - SLAPI_ACL_ADD\n" );
 	if (acl_access_allowed(gerpb, e, NULL, NULL, SLAPI_ACL_ADD) == LDAP_SUCCESS)
 	{
 		/* a - add child entry below e */
 		entryrights |= SLAPI_ACL_ADD;
 		_append_gerstr(gerstr, gerstrsize, gerstrcap, "a", NULL);
 	}
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-		"_ger_get_entry_rights: SLAPI_ACL_DELETE\n" );
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+		"_ger_get_entry_rights - SLAPI_ACL_DELETE\n" );
 	if (acl_access_allowed(gerpb, e, NULL, NULL, SLAPI_ACL_DELETE) == LDAP_SUCCESS)
 	{
 		/* d - delete e */
@@ -435,8 +435,8 @@ _ger_get_entry_rights (
          * WRITE was granted on rdn attrbibute
          */
         if (acl_access_allowed(gerpb, e, NULL, NULL, SLAPI_ACL_MODDN) == LDAP_SUCCESS) {
-            slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-                    "_ger_get_entry_rights: SLAPI_ACL_MODDN %s\n", slapi_entry_get_ndn(e));
+            slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+                    "_ger_get_entry_rights - SLAPI_ACL_MODDN %s\n", slapi_entry_get_ndn(e));
             /* n - rename e */
             entryrights |= SLAPI_ACL_MODDN;
             _append_gerstr(gerstr, gerstrsize, gerstrcap, "n", NULL);
@@ -453,8 +453,8 @@ _ger_get_entry_rights (
         rdn = slapi_rdn_new_dn(slapi_entry_get_ndn(e));
         slapi_rdn_get_first(rdn, &rdntype, &rdnvalue);
         if (NULL != rdntype) {
-            slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-                    "_ger_get_entry_rights: SLAPI_ACL_WRITE_DEL & _ADD %s\n", rdntype);
+            slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+                    "_ger_get_entry_rights - SLAPI_ACL_WRITE_DEL & _ADD %s\n", rdntype);
             if (acl_access_allowed(gerpb, e, rdntype, NULL,
                     ACLPB_SLAPI_ACL_WRITE_DEL) == LDAP_SUCCESS &&
                     acl_access_allowed(gerpb, e, rdntype, NULL,
@@ -501,40 +501,40 @@ _ger_get_attr_rights (
 	}
 	_append_gerstr(gerstr, gerstrsize, gerstrcap, type, ":");
 
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-		"_ger_get_attr_rights: SLAPI_ACL_READ %s\n", type );
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+		"_ger_get_attr_rights - SLAPI_ACL_READ %s\n", type );
 	if (acl_access_allowed(gerpb, e, type, NULL, SLAPI_ACL_READ) == LDAP_SUCCESS)
 	{
 		/* r - read the values of type */
 		attrrights |= SLAPI_ACL_READ;
 		_append_gerstr(gerstr, gerstrsize, gerstrcap, "r", NULL);
 	}
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-		"_ger_get_attr_rights: SLAPI_ACL_SEARCH %s\n", type );
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+		"_ger_get_attr_rights -  SLAPI_ACL_SEARCH %s\n", type );
 	if (acl_access_allowed(gerpb, e, type, NULL, SLAPI_ACL_SEARCH) == LDAP_SUCCESS)
 	{
 		/* s - search the values of type */
 		attrrights |= SLAPI_ACL_SEARCH;
 		_append_gerstr(gerstr, gerstrsize, gerstrcap, "s", NULL);
 	}
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-		"_ger_get_attr_rights: SLAPI_ACL_COMPARE %s\n", type );
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+		"_ger_get_attr_rights - SLAPI_ACL_COMPARE %s\n", type );
 	if (acl_access_allowed(gerpb, e, type, NULL, SLAPI_ACL_COMPARE) == LDAP_SUCCESS)
 	{
 		/* c - compare the values of type */
 		attrrights |= SLAPI_ACL_COMPARE;
 		_append_gerstr(gerstr, gerstrsize, gerstrcap, "c", NULL);
 	}
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-		"_ger_get_attr_rights: SLAPI_ACL_WRITE_ADD %s\n", type );
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+		"_ger_get_attr_rights - SLAPI_ACL_WRITE_ADD %s\n", type );
 	if (acl_access_allowed(gerpb, e, type, NULL, ACLPB_SLAPI_ACL_WRITE_ADD) == LDAP_SUCCESS)
 	{
 		/* w - add the values of type */
 		attrrights |= ACLPB_SLAPI_ACL_WRITE_ADD;
 		_append_gerstr(gerstr, gerstrsize, gerstrcap, "w", NULL);
 	}
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-		"_ger_get_attr_rights: SLAPI_ACL_WRITE_DEL %s\n", type );
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+		"_ger_get_attr_rights - SLAPI_ACL_WRITE_DEL %s\n", type );
 	if (acl_access_allowed(gerpb, e, type, NULL, ACLPB_SLAPI_ACL_WRITE_DEL) == LDAP_SUCCESS)
 	{
 		/* o - delete the values of type */
@@ -856,8 +856,8 @@ _ger_generate_template_entry (
 	slapi_pblock_get( pb, SLAPI_SEARCH_GERATTRS, &gerattrs );
 	if (NULL == gerattrs)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-						"Objectclass info is expected "
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+						"_ger_generate_template_entry - Objectclass info is expected "
 						"in the attr list, e.g., \"*@person\"\n");
 		rc = LDAP_SUCCESS;
 		goto bailout;
@@ -1089,10 +1089,10 @@ bailout:
 		gerstr = slapi_ch_smprintf("entryLevelRights: %d\nattributeLevelRights: *:%d", rc, rc );
 	}
 
-	slapi_log_error(SLAPI_LOG_ACLSUMMARY, LOG_DEBUG, plugin_name,
+	slapi_log_error(SLAPI_LOG_ACLSUMMARY, plugin_name,
 		"###### Effective Rights on Entry (%s) for Subject (%s) ######\n",
 		e?slapi_entry_get_ndn(e):"null", subjectndn?subjectndn:"null");
-	slapi_log_error(SLAPI_LOG_ACLSUMMARY, LOG_DEBUG, plugin_name, "%s\n", gerstr);
+	slapi_log_error(SLAPI_LOG_ACLSUMMARY, plugin_name, "%s\n", gerstr);
 
 	/* Restore pb */
 	_ger_release_gerpb ( &gerpb, &aclcb, pb );

ldap/servers/plugins/acl/aclgroup.c

@@ -41,7 +41,7 @@ aclgroup_init ()
 
 	aclUserGroups = ( aclGroupCache * ) slapi_ch_calloc (1, sizeof ( aclGroupCache ) );
 	if ( NULL ==  (aclUserGroups->aclg_rwlock = slapi_new_rwlock())) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, "Unable to allocate RWLOCK for group cache\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, "Unable to allocate RWLOCK for group cache\n");
 		return 1;
 	}
 	return 0;
@@ -101,8 +101,8 @@ aclg_init_userGroup ( struct acl_pblock *aclpb, const char *n_dn , int got_lock
 			*/
 			
 			if ( !u_group->aclug_refcnt ) {
-				slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-					"In traversal group deallocation\n" );
+				slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+					"aclg_init_userGroup - In traversal group deallocation\n" );
 				__aclg__delete_userGroup (u_group);								
 			}			
 		} else {
@@ -142,7 +142,7 @@ aclg_init_userGroup ( struct acl_pblock *aclpb, const char *n_dn , int got_lock
 			if ( u_group == aclUserGroups->aclg_last )
 				aclUserGroups->aclg_last = p_group;
 		}
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "acl_init_userGroup: found in cache for dn:%s\n", n_dn);
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name, "acl_init_userGroup - Found in cache for dn:%s\n", n_dn);
 	}
 	if (!got_lock ) ACLG_ULOCK_GROUPCACHE_WRITE ();
 }
@@ -252,7 +252,7 @@ aclg_get_usersGroup ( struct acl_pblock *aclpb , char *n_dn)
 	aclUserGroup		*u_group, *f_group;
 
 	if ( !aclpb ) {
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "NULL acl pblock\n" );
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name, "aclg_get_usersGroup - NULL acl pblock\n" );
 		return NULL;
 	}
 
@@ -274,7 +274,7 @@ aclg_get_usersGroup ( struct acl_pblock *aclpb , char *n_dn)
 	 * That's fine as the invalid one will be deallocated when done.
 	 */
 
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "ALLOCATING GROUP FOR:%s\n", n_dn );
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "aclg_get_usersGroup - ALLOCATING GROUP FOR:%s\n", n_dn );
 	u_group = ( aclUserGroup * ) slapi_ch_calloc ( 1, sizeof ( aclUserGroup ) );
 	
 	u_group->aclug_refcnt = 1;
@@ -368,7 +368,7 @@ __aclg__delete_userGroup ( aclUserGroup *u_group )
 	 * be in a condemned state and later deleted.
 	 */
 	
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "DEALLOCATING GROUP FOR:%s\n", u_group->aclug_ndn );
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "__aclg__delete_userGroup - DEALLOCATING GROUP FOR:%s\n", u_group->aclug_ndn );
 
 	slapi_ch_free ( (void **) &u_group->aclug_ndn );
 

ldap/servers/plugins/acl/aclinit.c

@@ -56,8 +56,8 @@ aclinit_main()
 
 	/* Initialize the LIBACCESS ACL library */
 	if (ACL_Init() != 0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-			 "ACL Library Initialization failed\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+			 "aclinit_main - ACL Library Initialization failed\n");
 		return 1;
 	}
 	
@@ -85,22 +85,22 @@ aclinit_main()
 	/* ONREPL Moved to the acl_init function because extensions
        need to be registered before any operations are issued
     if  ( 0 != acl_init_ext() ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
 			"Unable to initialize the extensions\n");
 		return 1;
 	} */
 
 	/* create the mutex array */
 	if ( 0 != aclext_alloc_lockarray ( ) ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-			"Unable to create the mutext array\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+			"aclinit_main - Unable to create the mutext array\n");
 		return 1;
 	}
 
     /* Allocate the pool */
 	if ( 0 != acl_create_aclpb_pool () ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-			"Unable to create the acl private pool\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+			"aclinit_main - Unable to create the acl private pool\n");
 		return 1;
 	}
 
@@ -110,8 +110,8 @@ aclinit_main()
 	 */
 	/* initialize the ACLLIST sub-system */
 	if ( 0 != (rv = acllist_init ( ))) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-				"Unable to initialize the plugin:%d\n", rv );
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+			"aclinit_main - Unable to initialize the plugin:%d\n", rv );
 		return 1;
 	}
 
@@ -128,8 +128,8 @@ aclinit_main()
 	*/
 
 	sdn = slapi_sdn_new_ndn_byval("");
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-				"Searching for all acis(scope base) at suffix ''\n");
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+				"aclinit_main - Searching for all acis(scope base) at suffix ''\n");
 	aclinit_search_and_update_aci ( 0,		/* thisbeonly */
 										sdn,	/* base */
 										NULL,	/* be name*/
@@ -140,8 +140,8 @@ aclinit_main()
 	sdn = slapi_get_first_suffix( &node, 1 );
 	while (sdn)
 	{
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-				"Searching for all acis(scope subtree) at suffix '%s'\n", 
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+				"aclinit_main - Searching for all acis(scope subtree) at suffix '%s'\n", 
 					slapi_sdn_get_dn(sdn) );
 		aclinit_search_and_update_aci ( 0,		/* thisbeonly */
 										sdn,	/* base */
@@ -210,8 +210,8 @@ aclinit_search_and_update_aci ( int thisbeonly, const Slapi_DN *base,
 				lock_flag == DO_TAKE_ACLCACHE_WRITELOCK);
 
 	if ( thisbeonly && be_name == NULL) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, 
-						"Error: This  be_name must be specified.\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, 
+						"aclinit_search_and_update_aci - be_name must be specified.\n");
 		return -1;
 	}
 
@@ -335,7 +335,7 @@ __aclinit_handler ( Slapi_Entry *e, void *callback_data)
 		*/
 		
 		if ( call_back_data->op == ACL_ADD_ACIS ) {
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name,
 				"Adding acis for entry '%s'\n", slapi_sdn_get_dn(e_sdn));
 			slapi_entry_attr_find ( e, aci_attr_type, &attr );
 
@@ -355,8 +355,8 @@ __aclinit_handler ( Slapi_Entry *e, void *callback_data)
 							aclutil_print_err(rv, e_sdn, attrValue, NULL); 
 
 							/* We got an error; Log it  and then march along */
-							slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, 
-									  "Error: This  (%s) ACL will not be considered for evaluation"
+							slapi_log_error(SLAPI_LOG_ERR, plugin_name, 
+									  "__aclinit_handler - This  (%s) ACL will not be considered for evaluation"
 									  " because of syntax errors.\n", 
 									  attrValue->bv_val ? attrValue->bv_val: "NULL");
 							call_back_data->retCode = rv;
@@ -370,7 +370,7 @@ __aclinit_handler ( Slapi_Entry *e, void *callback_data)
 		} else if (call_back_data->op == ACL_REMOVE_ACIS) {
 
 			/* Here we are deleting the acis. */
-				slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "Removing acis\n");
+				slapi_log_error(SLAPI_LOG_ACL, plugin_name, "__aclinit_handler - Removing acis\n");
 				if ( call_back_data->lock_flag == DO_TAKE_ACLCACHE_WRITELOCK) {
 					acllist_acicache_WRITE_LOCK();
 				}	
@@ -378,8 +378,8 @@ __aclinit_handler ( Slapi_Entry *e, void *callback_data)
 					aclutil_print_err(rv, e_sdn, NULL, NULL); 
 
 					/* We got an error; Log it  and then march along */
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, 
-									  "Error: ACls not deleted from %s\n",
+					slapi_log_error(SLAPI_LOG_ERR, plugin_name, 
+									  "__aclinit_handler - ACLs not deleted from %s\n",
                                       slapi_sdn_get_dn(e_sdn));
 					call_back_data->retCode = rv;
 				}
@@ -428,31 +428,31 @@ __aclinit__RegisterAttributes(void)
 	rv = ACL_MethodRegister(&errp, DS_METHOD, &methodinfo);
 	if (rv < 0) {
 		acl_print_acllib_err(&errp, NULL);
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, 
-			  "Unable to Register the methods\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, 
+			  "__aclinit__RegisterAttributes - Unable to Register the methods\n");
 		return ACL_ERR;
 	}
 	rv = ACL_MethodSetDefault (&errp,  methodinfo);
 	if (rv < 0) {
 		acl_print_acllib_err(&errp, NULL);
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, 
-			  "Unable to Set the default method\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, 
+			  "__aclinit__RegisterAttributes - Unable to Set the default method\n");
 		return ACL_ERR;
 	}
         rv = ACL_AttrGetterRegister(&errp, ACL_ATTR_IP, DS_LASIpGetter,
 				methodinfo, ACL_DBTYPE_ANY, ACL_AT_FRONT, NULL);
 	if (rv < 0) {
 		acl_print_acllib_err(&errp, NULL);
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, 
-			  "Unable to Register Attr ip\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, 
+			  "__aclinit__RegisterAttributes - Unable to Register Attr ip\n");
 		return ACL_ERR;
 	}
         rv = ACL_AttrGetterRegister(&errp, ACL_ATTR_DNS, DS_LASDnsGetter,
 				methodinfo, ACL_DBTYPE_ANY, ACL_AT_FRONT, NULL);
 	if (rv < 0) {
 		acl_print_acllib_err(&errp, NULL);
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, 
-			  "Unable to Register Attr dns\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, 
+			  "__aclinit__RegisterAttributes - Unable to Register Attr dns\n");
 		return ACL_ERR;
 	}
 	return ACL_OK;
@@ -482,67 +482,67 @@ __aclinit__RegisterLases(void)
 
 	if (ACL_LasRegister(NULL, DS_LAS_USER, (LASEvalFunc_t) DS_LASUserEval, 
 				(LASFlushFunc_t) NULL) <  0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-				"Unable to register USER Las\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+				"__aclinit__RegisterLases - Unable to register USER Las\n");
 		return ACL_ERR;
 	}
 	if (ACL_LasRegister(NULL, DS_LAS_GROUP, (LASEvalFunc_t) DS_LASGroupEval, 
 				(LASFlushFunc_t) NULL) <  0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-				"Unable to register GROUP Las\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+				"__aclinit__RegisterLases - Unable to register GROUP Las\n");
 		return ACL_ERR;
 	}
 	if (ACL_LasRegister(NULL, DS_LAS_GROUPDN, (LASEvalFunc_t)DS_LASGroupDnEval, 
 				(LASFlushFunc_t)NULL) < 0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-				"Unable to register GROUPDN Las\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+				"__aclinit__RegisterLases - Unable to register GROUPDN Las\n");
 		return ACL_ERR;
 	}
 	if (ACL_LasRegister(NULL, DS_LAS_ROLEDN, (LASEvalFunc_t)DS_LASRoleDnEval, 
 				(LASFlushFunc_t)NULL) < 0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-				"Unable to register ROLEDN Las\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+				"__aclinit__RegisterLases - Unable to register ROLEDN Las\n");
 		return ACL_ERR;
 	}
 	if (ACL_LasRegister(NULL, DS_LAS_USERDN, (LASEvalFunc_t)DS_LASUserDnEval, 
 				(LASFlushFunc_t)NULL) < 0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-				"Unable to register USERDN Las\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+				"__aclinit__RegisterLases - Unable to register USERDN Las\n");
 		return ACL_ERR;
 	}
 	if (ACL_LasRegister(NULL, DS_LAS_USERDNATTR, 
 				(LASEvalFunc_t)DS_LASUserDnAttrEval, 
 				(LASFlushFunc_t)NULL) < 0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-				"Unable to register USERDNATTR Las\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+				"__aclinit__RegisterLases - Unable to register USERDNATTR Las\n");
 		return ACL_ERR;
 	}
 	if (ACL_LasRegister(NULL, DS_LAS_AUTHMETHOD, 
 				(LASEvalFunc_t)DS_LASAuthMethodEval,
 				(LASFlushFunc_t)NULL) < 0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-			"Unable to register CLIENTAUTHTYPE Las\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+			"__aclinit__RegisterLases - Unable to register CLIENTAUTHTYPE Las\n");
 		return ACL_ERR;
 	}
 	if (ACL_LasRegister(NULL, DS_LAS_GROUPDNATTR,
 				(LASEvalFunc_t)DS_LASGroupDnAttrEval,
 				(LASFlushFunc_t)NULL) < 0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-				"Unable to register GROUPDNATTR Las\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+				"__aclinit__RegisterLases - Unable to register GROUPDNATTR Las\n");
 		return ACL_ERR;
 	}
 	if (ACL_LasRegister(NULL, DS_LAS_USERATTR,
 				(LASEvalFunc_t)DS_LASUserAttrEval,
 				(LASFlushFunc_t)NULL) < 0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-				"Unable to register USERATTR Las\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+				"__aclinit__RegisterLases - Unable to register USERATTR Las\n");
 		return ACL_ERR;
 	}
 	if (ACL_LasRegister(NULL, DS_LAS_SSF,
 				(LASEvalFunc_t)DS_LASSSFEval,
 				(LASFlushFunc_t)NULL) < 0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-			"Unable to register SSF Las\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+			"__aclinit__RegisterLases - Unable to register SSF Las\n");
 		return ACL_ERR;
 	}
 	return ACL_OK;

ldap/servers/plugins/acl/acllist.c

@@ -72,8 +72,8 @@ acllist_init(void)
 {
 
 	if (( aci_rwlock = slapi_new_rwlock() ) == NULL ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, 
-							"acllist_init:failed in getting the rwlock\n" );
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, 
+							"acllist_init - Failed in getting the rwlock\n" );
 		return 1;
 	}
 	
@@ -114,13 +114,13 @@ void acl_be_state_change_fnc ( void *handle, char *be_name, int old_state,
 
 	if ( old_state == SLAPI_BE_STATE_ON && new_state != SLAPI_BE_STATE_ON) {
 
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-			"Backend %s is no longer STARTED--deactivating it's acis\n",
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+			"acl_be_state_change_fnc - Backend %s is no longer STARTED--deactivating it's acis\n",
 			be_name);
 		
 		if ( (be = slapi_be_select_by_instance_name( be_name )) == NULL) {
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-			"Failed to retrieve backend--NOT activating it's acis\n");
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+			"acl_be_state_change_fnc - Failed to retrieve backend--NOT activating it's acis\n");
 			return;
 		}
 
@@ -129,8 +129,8 @@ void acl_be_state_change_fnc ( void *handle, char *be_name, int old_state,
 		*/
 
 		if ( (sdn = slapi_be_getsuffix( be, 0)) == NULL ) {
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-			"Failed to retrieve backend--NOT activating it's acis\n");
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+			"acl_be_state_change_fnc - Failed to retrieve backend--NOT activating it's acis\n");
 			return;
 		}
 
@@ -142,12 +142,12 @@ void acl_be_state_change_fnc ( void *handle, char *be_name, int old_state,
 										DO_TAKE_ACLCACHE_WRITELOCK);
 		
 	} else if ( old_state != SLAPI_BE_STATE_ON && new_state == SLAPI_BE_STATE_ON) {
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-			"Backend %s is now STARTED--activating it's acis\n", be_name);
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+			"acl_be_state_change_fnc - Backend %s is now STARTED--activating it's acis\n", be_name);
 
 		if ( (be = slapi_be_select_by_instance_name( be_name )) == NULL) {
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-			"Failed to retrieve backend--NOT activating it's acis\n");
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+			"acl_be_state_change_fnc - Failed to retrieve backend--NOT activating it's acis\n");
 			return;
 		}
 
@@ -156,8 +156,8 @@ void acl_be_state_change_fnc ( void *handle, char *be_name, int old_state,
 		*/
 
 		if ( (sdn = slapi_be_getsuffix( be, 0)) == NULL ) {
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-			"Failed to retrieve backend--NOT activating it's acis\n");
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+			"acl_be_state_change_fnc - Failed to retrieve backend--NOT activating it's acis\n");
 			return;
 		}
 																	
@@ -195,8 +195,8 @@ acllist_insert_aci_needsLock_ext( Slapi_PBlock *pb, const Slapi_DN *e_sdn, const
 	acl_str = slapi_ch_strdup(aci_attr->bv_val);
 	/* Parse the ACL TEXT */
 	if (  0 != (rv = acl_parse ( pb, acl_str, aci, NULL )) ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-				"ACL PARSE ERR(rv=%d): %s\n", rv, acl_str );
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+				"acllist_insert_aci_needsLock_ext - ACL PARSE ERR(rv=%d): %s\n", rv, acl_str );
 		slapi_ch_free ( (void **) &acl_str );
 		acllist_free_aci ( aci );
 		
@@ -205,8 +205,8 @@ acllist_insert_aci_needsLock_ext( Slapi_PBlock *pb, const Slapi_DN *e_sdn, const
 
 	/* Now add it to the list */
 	if ( 0 != (rv =__acllist_add_aci ( aci ))) {
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-				"ACL ADD ACI ERR(rv=%d): %s\n", rv, acl_str );
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+				"acllist_insert_aci_needsLock_ext - ACL ADD ACI ERR(rv=%d): %s\n", rv, acl_str );
 		slapi_ch_free ( (void **) &acl_str );
 		acllist_free_aci ( aci );
 		return 1;
@@ -241,8 +241,8 @@ __acllist_add_aci ( aci_t *aci )
 		/* Find the node that contains the acl. */
 		if ( NULL == (head = (AciContainer *) avl_find( acllistRoot, aciListHead, 
 										(IFP) __acllist_aciContainer_node_cmp ) ) ) {
-			slapi_log_error ( SLAPI_PLUGIN_ACL, LOG_DEBUG, plugin_name,
-								"Can't insert the acl in the tree\n");
+			slapi_log_error ( SLAPI_PLUGIN_ACL, plugin_name,
+								"__acllist_add_aci - Can't insert the acl in the tree\n");
 			rv = 1;
 		} else {
 			aci_t		*t_aci;;
@@ -255,7 +255,7 @@ __acllist_add_aci ( aci_t *aci )
 			/* Now add the new one to the end of the list */
 			t_aci->aci_next = aci;
 
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "Added the ACL:%s to existing container:[%d]%s\n", 
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name, "__acllist_add_aci - Added the ACL:%s to existing container:[%d]%s\n", 
 					aci->aclName, head->acic_index, slapi_sdn_get_ndn( head->acic_sdn ));
 		}
 
@@ -290,7 +290,7 @@ __acllist_add_aci ( aci_t *aci )
 
 		aciContainerArray[ aciListHead->acic_index ] = aciListHead;
 
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "Added %s to container:%d\n", 
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name, "__acllist_add_aci - Added %s to container:%d\n", 
 								slapi_sdn_get_ndn( aciListHead->acic_sdn ), aciListHead->acic_index );
 		break;
 	}
@@ -359,8 +359,8 @@ acllist_remove_aci_needsLock( const Slapi_DN *sdn,  const struct berval *attr )
 		/* In that case we don't have any acl for this entry. cool !!! */
 
 		acllist_free_aciContainer ( &aciListHead );
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-				"No acis to remove in this entry\n" );
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+				"acllist_remove_aci_needsLock - No acis to remove in this entry\n" );
 		return 0;
 	}
 
@@ -384,8 +384,8 @@ acllist_remove_aci_needsLock( const Slapi_DN *sdn,  const struct berval *attr )
 	/* remove the container from the slot */
 	aciContainerArray[root->acic_index] = NULL;
 
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-				"Removing container[%d]=%s\n",  root->acic_index,
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+				"acllist_remove_aci_needsLock - Removing container[%d]=%s\n",  root->acic_index,
 					slapi_sdn_get_ndn ( root->acic_sdn) );
 	dContainer = (AciContainer *) avl_delete ( &acllistRoot, aciListHead, 
 										__acllist_aciContainer_node_cmp );
@@ -409,8 +409,8 @@ acllist_remove_aci_needsLock( const Slapi_DN *sdn,  const struct berval *attr )
 													LDAP_SCOPE_BASE,
 													ACL_ADD_ACIS,
 											DONT_TAKE_ACLCACHE_WRITELOCK))) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-						" Can't add the rest of the acls for entry:%s after delete\n",
+			slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+						"acllist_remove_aci_needsLock - Can't add the rest of the acls for entry:%s after delete\n",
 						slapi_sdn_get_dn ( sdn ) );
 		}
 	}
@@ -624,7 +624,7 @@ acllist_init_scan (Slapi_PBlock *pb, int scope, const char *base)
 	}
 	aclpb = acl_get_aclpb (pb, ACLPB_BINDDN_PBLOCK );
 	if ( !aclpb ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,  "Missing aclpb 4 \n" );
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name, "acllist_init_scan - Missing aclpb\n" );
 		return;
 	}
 
@@ -665,8 +665,8 @@ acllist_init_scan (Slapi_PBlock *pb, int scope, const char *base)
 			/* slapi_dn_parent returns the "parent" dn syntactically.
 			 * Most likely, basedn is above suffix (e.g., dn=com).
 			 * Thus, no need to make it FATAL. */
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, 
-			                  "Failed to find root for base: %s \n", basedn );
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
+			                  "acllist_init_scan - Failed to find root for base: %s \n", basedn );
 		}
 		tmp = slapi_dn_parent ( basedn );
 		slapi_ch_free_string(&basedn);
@@ -699,8 +699,8 @@ acllist_aciscan_update_scan (  Acl_PBlock *aclpb, char *edn )
 	int is_not_search_base = 1;
 
 	if ( !aclpb ) {
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-				"acllist_aciscan_update_scan: NULL acl pblock\n");
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+				"acllist_aciscan_update_scan - NULL acl pblock\n");
 		return;
 	}
 
@@ -745,9 +745,9 @@ acllist_aciscan_update_scan (  Acl_PBlock *aclpb, char *edn )
 									(caddr_t) aclpb->aclpb_aclContainer, 
 									(IFP) __acllist_aciContainer_node_cmp);
 		
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-						"Searching AVL tree for update:%s: container:%d\n", basedn ,
-					root ? root->acic_index: -1);	
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+				"acllist_aciscan_update_scan - Searching AVL tree for update:%s: container:%d\n",
+				basedn, root ? root->acic_index: -1);	
 			if ( index >= aclpb_max_selected_acls -2 ) {
 				aclpb->aclpb_handles_index[0] = -1;
 				slapi_ch_free ( (void **) &basedn);
@@ -910,8 +910,8 @@ acllist_moddn_aci_needsLock ( Slapi_DN *oldsdn, char *newdn )
 	if ( NULL == (head = (AciContainer *) avl_find( acllistRoot, aciListHead,
 	     (IFP) __acllist_aciContainer_node_cmp ) ) ) {
 
-		slapi_log_error ( SLAPI_PLUGIN_ACL, LOG_DEBUG, plugin_name,
-		         "Can't find the acl in the tree for moddn operation:olddn%s\n",
+		slapi_log_error ( SLAPI_PLUGIN_ACL, plugin_name,
+		         "acllist_moddn_aci_needsLock - Can't find the acl in the tree for moddn operation:olddn%s\n",
 		         slapi_sdn_get_ndn ( oldsdn ));
 		aciListHead->acic_sdn = NULL;
 		acllist_free_aciContainer ( &aciListHead );
@@ -956,8 +956,8 @@ acllist_print_tree ( Avlnode *root, int *depth, char *start, char *side)
 		return;
 	}
 	aciHeadList = (AciContainer *) root->avl_data;
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, "plugin_name",
-						"Container[ Depth=%d%s-%s]: %s\n", *depth, start, side,
+	slapi_log_error(SLAPI_LOG_ACL, "plugin_name",
+						"acllist_print_tree - Container[ Depth=%d%s-%s]: %s\n", *depth, start, side,
 						slapi_sdn_get_ndn ( aciHeadList->acic_sdn ) );
 
 	(*depth)++;

ldap/servers/plugins/acl/aclparse.c

@@ -148,8 +148,8 @@ acl_parse(Slapi_PBlock *pb, char * str, aci_t *aci_item, char **errbuf)
 					slapi_search_internal_pb(temppb);
 					slapi_pblock_get(temppb, SLAPI_PLUGIN_INTOP_RESULT, &rc);
 					if (rc != LDAP_SUCCESS) {
-						slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-							"The ACL target %s does not exist\n", slapi_sdn_get_dn(&targdn));
+						slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+							"acl_parse - The ACL target %s does not exist\n", slapi_sdn_get_dn(&targdn));
 					}
 	
 					slapi_free_search_results_internal(temppb);
@@ -183,14 +183,14 @@ acl_parse(Slapi_PBlock *pb, char * str, aci_t *aci_item, char **errbuf)
 
 	if (!(aci_item->aci_type & ACI_TARGET_MACRO_DN) &&
 		(aci_item->aci_ruleType & ACI_PARAM_DNRULE)) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-		"acl_parse: A macro in a subject ($dn) must have a macro in the target.\n");
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+			"acl_parse - A macro in a subject ($dn) must have a macro in the target.\n");
 		return(ACL_INVALID_TARGET);
 	}
 
 	return 0;
 }
-
+
 /***************************************************************************
 *
 * __aclp__parse_aci
@@ -294,8 +294,8 @@ __aclp__parse_aci(char *str, aci_t  *aci_item, char **errbuf)
 			
 				/* Must have a targetmacro */
 				if ( !(aci_item->aci_type & ACI_TARGET_MACRO_DN)) {
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-						"acl_parse: A macro in a targetfilter ($dn) must have a macro in the target.\n");
+					slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+						"__aclp__parse_aci - A macro in a targetfilter ($dn) must have a macro in the target.\n");
 					return(ACL_SYNTAX_ERR);
 				}
 
@@ -468,8 +468,8 @@ __aclp__parse_aci(char *str, aci_t  *aci_item, char **errbuf)
 			filterChoice = slapi_filter_get_choice ( f );
 			if ( (type & (ACI_TARGET_DN | ACI_TARGET_MODDN)) &&
 				( filterChoice == LDAP_FILTER_PRESENT)) {
-					slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-					"acl__parse_aci: Unsupported filter type:%d\n", filterChoice);
+					slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+					"__aclp__parse_aci - Unsupported filter type:%d\n", filterChoice);
 				return(ACL_SYNTAX_ERR);
 			} else if (( filterChoice == LDAP_FILTER_SUBSTRINGS) &&
 					(type & ACI_TARGET_DN)) {
@@ -489,8 +489,8 @@ __aclp__parse_aci(char *str, aci_t  *aci_item, char **errbuf)
 			(type & ACI_TARGET_PATTERN)) {
 			if (aci_item->target) {
 				/* There is something already. ERROR */
-				slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-					 "Multiple targets in the ACL syntax\n");
+				slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+					 "__aclp__parse_aci - Multiple targets in the ACL syntax\n");
 				slapi_filter_free(f, 1);
 				return(ACL_SYNTAX_ERR);
 			}  else {
@@ -498,8 +498,8 @@ __aclp__parse_aci(char *str, aci_t  *aci_item, char **errbuf)
 			}
 		} else if ( type & ACI_TARGET_FILTER) {
 			if (aci_item->targetFilter) {
-				slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-				       "Multiple target Filters in the ACL Syntax\n");
+				slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+				       "__aclp__parse_aci - Multiple target Filters in the ACL Syntax\n");
 				slapi_filter_free(f, 1);
 				return(ACL_SYNTAX_ERR);
 			} else {
@@ -509,8 +509,8 @@ __aclp__parse_aci(char *str, aci_t  *aci_item, char **errbuf)
                         if (is_target_to) {
                                 if (aci_item->target_to) {
                                         /* There is something already. ERROR */
-                                        slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-                                                "Multiple targets (target_to) in the ACL syntax\n");
+                                        slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+                                                "__aclp__parse_aci - Multiple targets (target_to) in the ACL syntax\n");
                                         slapi_filter_free(f, 1);
                                         return(ACL_SYNTAX_ERR);
                                 } else {
@@ -519,8 +519,8 @@ __aclp__parse_aci(char *str, aci_t  *aci_item, char **errbuf)
                         } else {
                                 if (aci_item->target_from) {
                                         /* There is something already. ERROR */
-                                        slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-					 "Multiple targets (target_from) in the ACL syntax\n");
+                                        slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+											"__aclp__parse_aci - Multiple targets (target_from) in the ACL syntax\n");
                                         slapi_filter_free(f, 1);
                                         return(ACL_SYNTAX_ERR);
                                 } else {
@@ -531,8 +531,8 @@ __aclp__parse_aci(char *str, aci_t  *aci_item, char **errbuf)
 		break; /* 't' */
 		default:
 			/* Here the keyword did not start with 'v' ot 't' so error */
-			slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-				       "Unknown keyword at \"%s\"\n Expecting"
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+				       "__aclp__parse_aci - Unknown keyword at \"%s\"\n Expecting"
 						" \"target\", \"targetattr\", \"targetfilter\", \"targattrfilters\""						
 						" or \"version\"\n", str);
 			return(ACL_SYNTAX_ERR);
@@ -543,7 +543,7 @@ __aclp__parse_aci(char *str, aci_t  *aci_item, char **errbuf)
 
 	return 0;
 }
-
+
 /***************************************************************************
 * acl__sanity_check_acltxt
 *
@@ -649,7 +649,7 @@ __aclp__sanity_check_acltxt (aci_t *aci_item, char *str)
 	if ((newstr = __aclp__normalize_acltxt (aci_item,  str )) == NULL) {
 		return ACL_SYNTAX_ERR;
 	}
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "Normalized String:%s\n", newstr);
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "__aclp__sanity_check_acltxt - Normalized String:%s\n", newstr);
 
 	/* check for acl syntax error */ 
 	if ((handle = (ACLListHandle_t *) ACL_ParseString(&errp, newstr)) == NULL) {
@@ -1514,8 +1514,8 @@ __aclp__init_targetattr (aci_t *aci, char *attr_val, char **errbuf)
 			char *errstr = 
 					slapi_ch_smprintf("The statement does not begin and end "
 					                  "with a \": [%s]. ", attr_val);
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-							"__aclp__init_targetattr: %s\n", errstr);
+			slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+							"__aclp__init_targetattr - %s\n", errstr);
 			if (errbuf) {
 				aclutil_str_append(errbuf, errstr);
 			}
@@ -1591,8 +1591,8 @@ __aclp__init_targetattr (aci_t *aci, char *attr_val, char **errbuf)
 				if (f == NULL)  {
 					char *errstr = slapi_ch_smprintf("Unable to generate filter"
 					                                 " (%s). ", lineptr);
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-							"__aclp__init_targetattr: %s\n", errstr);
+					slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+							"__aclp__init_targetattr - %s\n", errstr);
 					if (errbuf) {
 						aclutil_str_append(errbuf, errstr);
 					}
@@ -1617,8 +1617,8 @@ __aclp__init_targetattr (aci_t *aci, char *attr_val, char **errbuf)
 				char *errstr = slapi_ch_smprintf("targetattr \"%s\" does not "
 				                  "exist in schema. Please add attributeTypes "
 				                  "\"%s\" to schema if necessary. ", str, str);
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-				                "__aclp__init_targetattr: %s\n", errstr);
+				slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+				                "__aclp__init_targetattr - %s\n", errstr);
 				if (errbuf) {
 					aclutil_str_append(errbuf, errstr);
 				}
@@ -1845,8 +1845,8 @@ acl_check_for_target_macro( aci_t *aci_item, char *value)
 		/* Macro dn needs to normalize. E.g., "ou=Groups, ($dN), dn=example,dn=com" */
 		aci_item->aci_macro->match_this = slapi_create_dn_string_case("%s", value);
 		if (NULL == aci_item->aci_macro->match_this) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-			                "acl_check_for_target_macro: Error: Invalid macro target dn: \"%s\"\n", value);
+			slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+			                "acl_check_for_target_macro - Invalid macro target dn: \"%s\"\n", value);
 			aci_item->aci_type &= ~ACI_TARGET_MACRO_DN;
 			slapi_ch_free((void **)&aci_item->aci_macro);
 			return -1;
@@ -1986,8 +1986,8 @@ static int __acl__init_targetattrfilters( aci_t *aci, char *input_str) {
 		s[len-1] = '\0';
 		s++;						/* skip the first " */
 	} else {						/* No matching quotes */
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-						"__aclp__init_targetattrfilters: Error: The statement does not begin and end with a \": [%s]\n",
+		slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+						"__aclp__init_targetattrfilters - The statement does not begin and end with a \": [%s]\n",
 						s);
     	return (ACL_SYNTAX_ERR);
     }
@@ -2106,8 +2106,7 @@ static int __acl__init_targetattrfilters( aci_t *aci, char *input_str) {
 		return( ACL_SYNTAX_ERR);
 	}
     
-	return(0);    
-
+	return(0);
 }
 
 /*
@@ -2214,8 +2213,8 @@ static int __acl_init_targetattrfilter( Targetattrfilter *attrfilter,
     
     if ( (tmp_ptr = strstr( str, ":")) == NULL ) {
 		/* No :, syntax error */
-  		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-                                "Bad targetattrfilter %s:%s\n",
+  		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+                                "__acl_init_targetattrfilter - Bad targetattrfilter %s:%s\n",
                                 str,"Expecting \":\"");
 
 		return(ACL_SYNTAX_ERR);
@@ -2228,8 +2227,8 @@ static int __acl_init_targetattrfilter( Targetattrfilter *attrfilter,
     /* s should be the attribute name-make sure it's non-empty. */
     
 	if ( *s == '\0' ) {
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-                                "No attribute name in targattrfilters\n");
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+                                "__acl_init_targetattrfilter - No attribute name in targattrfilters\n");
 		return(ACL_SYNTAX_ERR);
 	}
 
@@ -2245,8 +2244,8 @@ static int __acl_init_targetattrfilter( Targetattrfilter *attrfilter,
 	tmp_ptr = __acl_trim_filterstr(filter_ptr);
 
 	if ((f = slapi_str2filter(tmp_ptr)) == NULL) {
-  		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-                                "Bad targetattr filter for attribute %s:%s\n",
+  		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+                                "__acl_init_targetattrfilter - Bad targetattr filter for attribute %s:%s\n",
                                 attrfilter->attr_str,tmp_ptr);
         slapi_ch_free( (void **) &attrfilter->attr_str);
 		slapi_ch_free( (void **) &tmp_ptr);		
@@ -2260,8 +2259,8 @@ static int __acl_init_targetattrfilter( Targetattrfilter *attrfilter,
 
 	if (acl_verify_exactly_one_attribute( attrfilter->attr_str, f) != 
 				SLAPI_FILTER_SCAN_NOMORE) {
-  		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-              "Exactly one attribute type per filter allowed in targattrfilters (%s)\n",
+  		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+              "__acl_init_targetattrfilter - Exactly one attribute type per filter allowed in targattrfilters (%s)\n",
 				attrfilter->attr_str);
         slapi_ch_free( (void **) &attrfilter->attr_str);
 		slapi_ch_free( (void **) &tmp_ptr);		

ldap/servers/plugins/acl/aclplugin.c

@@ -94,7 +94,7 @@ acl_preopInit (Slapi_PBlock *pb)
 #endif
 
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "<= acl_preop_Init %d\n", rc );
+        slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "<= acl_preop_Init %d\n", rc );
         return( rc );
 }
 
@@ -187,7 +187,7 @@ aclplugin_preop_common( Slapi_PBlock *pb )
 	aclpb = acl_get_aclpb ( pb, ACLPB_BINDDN_PBLOCK );
 
 	if (aclpb == NULL) {
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "aclplugin_preop_common: Error: aclpb is NULL\n" );
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name, "aclplugin_preop_common - Error: aclpb is NULL\n" );
 		slapi_send_ldap_result( pb, LDAP_OPERATIONS_ERROR, NULL, NULL, 0, NULL );
 		return 1;
 	}
@@ -220,8 +220,8 @@ aclplugin_preop_common( Slapi_PBlock *pb )
 	if ( proxy_dn) {
 		TNF_PROBE_0_DEBUG(proxyacpb_init_start,"ACL","");
 
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
-				"proxied authorization dn is (%s)\n", proxy_dn );
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
+				"aclplugin_preop_common - Proxied authorization dn is (%s)\n", proxy_dn );
 		acl_init_aclpb ( pb, aclpb, proxy_dn, 1 );
 		aclpb = acl_new_proxy_aclpb ( pb );
 		acl_init_aclpb ( pb, aclpb, dn, 0 );
@@ -297,11 +297,11 @@ acl_init( Slapi_PBlock *pb )
 {
         int     rc =0;
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "=> acl_init\n" );
+        slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "=> acl_init\n" );
 
         if  ( 0 != acl_init_ext() ) {
-		    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name,
-			    "Unable to initialize the extensions\n");
+		    slapi_log_error(SLAPI_LOG_ERR, plugin_name,
+			    "acl_init - Unable to initialize the extensions\n");
 		    return 1;
 	    }
 
@@ -324,7 +324,7 @@ acl_init( Slapi_PBlock *pb )
         rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_ACL_MODS_UPDATE,
             (void *) acl_modified );
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "<= acl_init %d\n", rc);
+        slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "<= acl_init %d\n", rc);
         return( rc );
 }
 
@@ -356,7 +356,7 @@ acl_access_allowed_main ( Slapi_PBlock *pb, Slapi_Entry *e, char **attrs,
 		rc = acl_read_access_allowed_on_entry ( pb, e, attrs, access);
 	} else if ( ACLPLUGIN_ACCESS_READ_ON_ATTR == flags) {
 		if (attr == NULL) {
-			slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "Missing attribute\n" );
+			slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "acl_access_allowed_main - Missing attribute\n" );
 			rc = LDAP_OPERATIONS_ERROR;
 		} else {
 			rc = acl_read_access_allowed_on_attr ( pb, e, attr, val, access);

ldap/servers/plugins/acl/aclutil.c

@@ -115,10 +115,10 @@ acl_print_acllib_err (NSErr_t *errp , char * str)
 	msgbuf[ACLUTIL_ACLLIB_MSGBUF_LEN-1] = '\0';
 
 	if (strlen(msgbuf) > 0) {
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,"ACL LIB ERR:(%s)(%s)\n",
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name,"acl_print_acllib_err - ACL LIB ERR:(%s)(%s)\n",
 				msgbuf, str ? str: "NULL");
 	} else {
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,"ACL LIB ERR:(%s)\n", 
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name,"acl_print_acllib_err - ACL LIB ERR:(%s)\n", 
 				str ? str: "NULL"); 
 	}
 
@@ -134,30 +134,30 @@ aclutil_print_aci (aci_t *aci_item, char *type)
 
 	if (!aci_item) {
 		
-		slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
 			"acl__print_aci: Null item\n");
 		return;
 	}
 
 
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name,
 		"***BEGIN ACL INFO[ Name:%s]***\n", aci_item->aclName);
 
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name,
 		"ACL Index:%d   ACL_ELEVEL:%d\n", aci_item->aci_index, aci_item->aci_elevel );
 	aclutil__access_str (aci_item->aci_access, str);    
     aclutil__typestr (aci_item->aci_type, &str[strlen(str)]);
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name,
 		   "ACI type:(%s)\n", str);
 
 	aclutil__Ruletypestr (aci_item->aci_ruleType, str);
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name,
 		   "ACI RULE type:(%s)\n",str);
 	
 	dn = slapi_sdn_get_dn ( aci_item->aci_sdn );
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "Slapi_Entry DN:%s\n", dn);
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "Slapi_Entry DN:%s\n", dn);
 
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name,
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name,
 		"***END ACL INFO*****************************\n");
 
 }
@@ -263,7 +263,7 @@ aclutil_print_err (int rv , const Slapi_DN *sdn, const struct berval* val,
 		aclutil_str_append(errbuf, lineptr);	
 	}
 
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, plugin_name, "%s", lineptr);
+	slapi_log_error(SLAPI_LOG_ERR, plugin_name, "aclutil_print_err - %s", lineptr);
 	slapi_ch_free_string(&newline);
 }
 
@@ -491,21 +491,21 @@ aclutil_print_resource( struct acl_pblock *aclpb, const char *right , char *attr
 	if ( ! slapi_is_loglevel_set ( SLAPI_LOG_ACL ) )
 		return;
 
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "    ************ RESOURCE INFO STARTS *********\n");
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "    Client DN: %s\n", 
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "    ************ RESOURCE INFO STARTS *********\n");
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "    Client DN: %s\n", 
 		   clientdn ? clientdn : "NULL");
 	aclutil__access_str (aclpb->aclpb_access, str);
     aclutil__typestr (aclpb->aclpb_res_type, &str[strlen(str)]);
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "    resource type:%d(%s)\n",
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "    resource type:%d(%s)\n",
 		   aclpb->aclpb_res_type, str);
 
 	dn = slapi_sdn_get_dn ( aclpb->aclpb_curr_entry_sdn );
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "    Slapi_Entry DN: %s\n", 
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "    Slapi_Entry DN: %s\n", 
 		   dn ? dn  : "NULL");
 
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "    ATTR: %s\n", attr ? attr : "NULL");
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "    rights:%s\n", right ? right: "NULL");
-	slapi_log_error(SLAPI_LOG_ACL, LOG_DEBUG, plugin_name, "    ************ RESOURCE INFO ENDS   *********\n");
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "    ATTR: %s\n", attr ? attr : "NULL");
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "    rights:%s\n", right ? right: "NULL");
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "    ************ RESOURCE INFO ENDS   *********\n");
 }
 /*
  * The input string contains a rule like
@@ -765,9 +765,9 @@ acl_match_macro_in_target( const char *ndn, char * match_this,
 	/* we know it's got a $(dn) */
 	tmp_ptr = PL_strcasestr(macro_prefix, ACL_TARGET_MACRO_DN_KEY);	
 	if (!tmp_ptr) {
-		LDAPDebug(LDAP_DEBUG_ACL, LOG_DEBUG,"acl_match_macro_in_target: "
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name, "acl_match_macro_in_target - "
 				"Target macro DN key \"%s\" not found in \"%s\".\n",
-				ACL_TARGET_MACRO_DN_KEY, macro_prefix, 0);
+				ACL_TARGET_MACRO_DN_KEY, macro_prefix);
 		slapi_ch_free_string(&macro_prefix);
 		return ret_val;
 	}
@@ -1463,7 +1463,7 @@ acl_ht_display_entry(PLHashEntry *he, PRIntn i, void *arg)
 	PLHashNumber aci_index = (PLHashNumber)he->key;
     char *matched_val = (char *)he->value;
 	
-	LDAPDebug(LDAP_DEBUG_ACL, LOG_DEBUG,"macro ht entry: key='%d' matched_val='%s'"
+	slapi_log_error(LDAP_DEBUG_ACL, plugin_name, "acl_ht_display_entry - macro ht entry: key='%d' matched_val='%s'"
 								"keyhash='%d'\n", 
 				aci_index, (matched_val ? matched_val: "NULL"),
 				(PLHashNumber)he->keyHash);

ldap/servers/plugins/bitwise/bitwise.c

@@ -163,7 +163,7 @@ bitwise_filter_create (Slapi_PBlock* pb)
 	} else if (strcmp(mrOID, "1.2.840.113556.1.4.804") == 0) {
 	    slapi_pblock_set (pb, SLAPI_PLUGIN_MR_FILTER_MATCH_FN, (void*)bitwise_filter_match_or);
 	} else { /* this oid not handled by this plugin */
-	    LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "=> bitwise_filter_create OID (%s) not handled\n", mrOID, 0, 0);
+	    LDAPDebug(LDAP_DEBUG_FILTER, "=> bitwise_filter_create OID (%s) not handled\n", mrOID, 0, 0);
 	    return rc;
 	}
 	bmc = new_bitwise_match_cb(mrTYPE, mrVALUE);
@@ -171,9 +171,9 @@ bitwise_filter_create (Slapi_PBlock* pb)
 	slapi_pblock_set (pb, SLAPI_PLUGIN_DESTROY_FN, (void*)bitwise_filter_destroy);
 	rc = LDAP_SUCCESS;
     } else {
-	LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "=> bitwise_filter_create missing parameter(s)\n", 0, 0, 0);
+	LDAPDebug(LDAP_DEBUG_FILTER, "=> bitwise_filter_create missing parameter(s)\n", 0, 0, 0);
     }
-    LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "<= bitwise_filter_create %i\n", rc, 0, 0);
+    LDAPDebug(LDAP_DEBUG_FILTER, "<= bitwise_filter_create %i\n", rc, 0, 0);
     return LDAP_SUCCESS;
 }
 
@@ -189,6 +189,6 @@ bitwise_init (Slapi_PBlock* pb)
     if ( rc == 0 ) {
 	rc = slapi_pblock_set( pb, SLAPI_PLUGIN_DESCRIPTION, (void *)&pdesc );
     }
-    LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "bitwise_init %i\n", rc, 0, 0);
+    LDAPDebug(LDAP_DEBUG_FILTER, "bitwise_init %i\n", rc, 0, 0);
     return rc;
 }

ldap/servers/plugins/chainingdb/cb_add.c

@@ -87,8 +87,8 @@ chaining_back_add ( Slapi_PBlock *pb )
 	if (LDAP_SUCCESS != rc) {
 		static int warned_get_conn = 0;
 		if (!warned_get_conn) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-				"cb_get_connection failed (%d) %s\n",
+			slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+				"chaining_back_add - cb_get_connection failed (%d) %s\n",
 				rc, ldap_err2string(rc));
 			warned_get_conn = 1;
 		}
@@ -121,7 +121,7 @@ chaining_back_add ( Slapi_PBlock *pb )
 	 * Call the backend preoperation plugins
 	 */
 	if((rc = slapi_plugin_call_preop_be_plugins(pb, SLAPI_PLUGIN_ADD_OP))){
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM, "add (%s): pre betxn failed, error (%d)\n",dn,rc);
+		slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM, "chaining_back_add - add (%s): pre betxn failed, error (%d)\n",dn,rc);
 		cb_release_op_connection(cb->pool,ld,0);
 		ldap_mods_free(mods,1);
 		ldap_controls_free(ctrls);
@@ -138,7 +138,7 @@ chaining_back_add ( Slapi_PBlock *pb )
 	ldap_controls_free(ctrls);
 
 	if ( rc != LDAP_SUCCESS ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+		slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
 			"ldap_add_ext failed -- %s\n", ldap_err2string(rc) );
 
 		cb_send_ldap_result( pb, LDAP_OPERATIONS_ERROR, NULL, ENDUSERMSG, 0, NULL );
@@ -199,8 +199,8 @@ chaining_back_add ( Slapi_PBlock *pb )
 			if ( parse_rc != LDAP_SUCCESS ) {
 				static int warned_parse_rc = 0;
 				if (!warned_parse_rc) {
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-						"%s%s%s\n",
+					slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+						"chaining_back_add - %s%s%s\n",
 						matched_msg?matched_msg:"",
 						(matched_msg&&(*matched_msg!='\0'))?": ":"",
 						ldap_err2string(parse_rc));
@@ -220,8 +220,8 @@ chaining_back_add ( Slapi_PBlock *pb )
 				struct berval ** refs =  referrals2berval(referrals); 
 				static int warned_rc = 0;
 				if (!warned_rc && error_msg) {
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-						"%s%s%s\n",
+					slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+						"chaining_back_add - %s%s%s\n",
 						matched_msg?matched_msg:"",
 						(matched_msg&&(*matched_msg!='\0'))?": ":"",
 						error_msg );
@@ -245,7 +245,7 @@ chaining_back_add ( Slapi_PBlock *pb )
 
 			/* Call the backend postoperation plugins */
 			if((rc = slapi_plugin_call_postop_be_plugins(pb, SLAPI_PLUGIN_ADD_OP))){
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM, "add (%s): post betxn failed, error (%d)\n",dn,rc);
+				slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM, "chaining_back_add - add (%s): post betxn failed, error (%d)\n",dn,rc);
 			}
 
 			/* Add control response sent by the farm server */

ldap/servers/plugins/chainingdb/cb_bind.c

@@ -91,8 +91,8 @@ cb_sasl_bind_once_s( cb_conn_pool *pool, const char *dn, ber_tag_t method,
 	if (LDAP_SUCCESS != rc) {
 		static int warned_get_conn = 0;
 		if (!warned_get_conn) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-			                "cb_get_connection failed (%d) %s\n",
+			slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+			                "cb_sasl_bind_once_s - cb_get_connection failed (%d) %s\n",
 			                rc, ldap_err2string(rc));
 			warned_get_conn = 1;
 		}
@@ -157,8 +157,8 @@ cb_sasl_bind_once_s( cb_conn_pool *pool, const char *dn, ber_tag_t method,
 		static int warned_bind_once = 0;
 		if (!warned_bind_once) {
 			int hasmatched = (matcheddnp && *matcheddnp && (**matcheddnp != '\0'));
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-			                "cb_sasl_bind_once_s failed (%s%s%s)\n",
+			slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+			                "cb_sasl_bind_once_s - Failed (%s%s%s)\n",
 			                hasmatched ? *matcheddnp : "", 
 			                hasmatched ? ": " : "",
 			                ldap_err2string(rc));

ldap/servers/plugins/chainingdb/cb_close.c

@@ -72,7 +72,7 @@ int cb_back_close( Slapi_PBlock *pb )
 	{
 		const char *betype = slapi_be_gettype(be);
 		if (!betype || strcasecmp(betype,CB_CHAINING_BACKEND_TYPE)) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM, "Wrong database type.\n");
+			slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM, "cb_back_close - Wrong database type.\n");
 			free_cb_backend(cb);
 			return 0;
 		}
@@ -81,7 +81,7 @@ int cb_back_close( Slapi_PBlock *pb )
 	inst = cb_get_instance(be);
 	CB_ASSERT( inst != NULL );
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,"Stopping chaining database instance %s\n",
+	slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,"cb_back_close - Stopping chaining database instance %s\n",
 			inst->configDn);
 	/*
 	 * emulate a backend instance deletion to clean up everything

ldap/servers/plugins/chainingdb/cb_compare.c

@@ -93,8 +93,8 @@ chaining_back_compare ( Slapi_PBlock *pb )
 	if (LDAP_SUCCESS != rc) {
 		static int warned_get_conn = 0;
 		if (!warned_get_conn) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-			                "cb_get_connection failed (%d) %s\n",
+			slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+			                "chaining_back_compare - cb_get_connection failed (%d) %s\n",
 			                rc, ldap_err2string(rc));
 			warned_get_conn = 1;
 		}
@@ -167,7 +167,7 @@ chaining_back_compare ( Slapi_PBlock *pb )
 
                			/*cb_send_ldap_result(pb,LDAP_OPERATIONS_ERROR, NULL,
 					ldap_err2string(rc), 0, NULL);*/
-				cb_send_ldap_result(pb,LDAP_OPERATIONS_ERROR, NULL,     "FARM SERVER TEMPORARY UNAVAILABLE", 0, NULL);
+				cb_send_ldap_result(pb,LDAP_OPERATIONS_ERROR, NULL, "FARM SERVER TEMPORARY UNAVAILABLE", 0, NULL);
 				cb_release_op_connection(cb->pool,ld,CB_LDAP_CONN_ERROR(rc));
 				if (res)
 					ldap_msgfree(res);
@@ -184,8 +184,8 @@ chaining_back_compare ( Slapi_PBlock *pb )
 			if ( parse_rc != LDAP_SUCCESS ) {
 				static int warned_parse_rc = 0;
 				if (!warned_parse_rc) {
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-						            "%s%s%s\n", 
+					slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+						            "chaining_back_compare - %s%s%s\n", 
 						            matched_msg?matched_msg:"",
 						            (matched_msg&&(*matched_msg!='\0'))?": ":"",
 					                ldap_err2string(parse_rc));
@@ -212,7 +212,7 @@ chaining_back_compare ( Slapi_PBlock *pb )
 				default: {
 					struct berval ** refs =  referrals2berval(referrals); 
 
-                        		cb_send_ldap_result( pb, rc, matched_msg, error_msg, 0, refs);
+                    cb_send_ldap_result( pb, rc, matched_msg, error_msg, 0, refs);
 					cb_release_op_connection(cb->pool,ld,CB_LDAP_CONN_ERROR(rc));
 			       		slapi_ch_free((void **)&matched_msg);
 			       		slapi_ch_free((void **)&error_msg);

ldap/servers/plugins/chainingdb/cb_config.c

@@ -26,7 +26,6 @@ static int cb_parse_config_entry(cb_backend * cb, Slapi_Entry *e);
 */
 
 
-
 int cb_config_add_dse_entries(cb_backend *cb, char **entries, char *string1, char *string2, char *string3)
 {
         int x;
@@ -43,8 +42,8 @@ int cb_config_add_dse_entries(cb_backend *cb, char **entries, char *string1, cha
 		slapi_add_internal_pb(util_pb);
 		slapi_pblock_get(util_pb, SLAPI_PLUGIN_INTOP_RESULT, &res);
 		if ( LDAP_SUCCESS != res && LDAP_ALREADY_EXISTS != res ) {
-		  slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM, 
-				  "Unable to add config entry (%s) to the DSE: %s\n",
+		  slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM, 
+				  "cb_config_add_dse_entries - Unable to add config entry (%s) to the DSE: %s\n",
 				  slapi_entry_get_dn(e),
 				  ldap_err2string(res));
 		  rc = res;
@@ -84,8 +83,8 @@ int cb_config_load_dse_info(Slapi_PBlock * pb) {
 	if ( LDAP_SUCCESS == res ) {
                 slapi_pblock_get(search_pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &entries);
                 if (NULL == entries || entries[0] == NULL) {
-                        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM, 
-				"Error accessing entry <%s>\n",cb->configDN);
+                        slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM, 
+				"cb_config_load_dse_info - Error accessing entry <%s>\n",cb->configDN);
                 	slapi_free_search_results_internal(search_pb);
                 	slapi_pblock_destroy(search_pb);
                         return 1;
@@ -98,8 +97,8 @@ int cb_config_load_dse_info(Slapi_PBlock * pb) {
         } else {
                 slapi_free_search_results_internal(search_pb);
                 slapi_pblock_destroy(search_pb);
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-			"Error accessing entry <%s> (%s)\n",cb->configDN,ldap_err2string(res));
+		slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+			"cb_config_load_dse_info - Error accessing entry <%s> (%s)\n",cb->configDN,ldap_err2string(res));
                 return 1;
         } 
 
@@ -122,8 +121,8 @@ int cb_config_load_dse_info(Slapi_PBlock * pb) {
         slapi_search_internal_pb (search_pb);
         slapi_pblock_get(search_pb, SLAPI_PLUGIN_INTOP_RESULT, &res);
         if (res != LDAP_SUCCESS) {
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM, 
-			"Error accessing the config DSE (%s)\n",ldap_err2string(res));
+                slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM, 
+			"cb_config_load_dse_info - Error accessing the config DSE (%s)\n",ldap_err2string(res));
                 slapi_free_search_results_internal(search_pb);
                 slapi_pblock_destroy(search_pb);
                 return 1;
@@ -206,8 +205,8 @@ int cb_config_add_check_callback(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry*
                         while (i != -1 ) {
                                 bval = (struct berval *) slapi_value_get_berval(sval);
                                 if (!cb_is_control_forwardable(cb,bval->bv_val)) {
-                                        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG,CB_PLUGIN_SUBSYSTEM,
-                                                "control %s can't be forwarded.\n",bval->bv_val);
+                                        slapi_log_error(SLAPI_LOG_PLUGIN,CB_PLUGIN_SUBSYSTEM,
+                                                "cb_config_add_check_callback - Control %s can't be forwarded.\n",bval->bv_val);
                                         *returncode=LDAP_CONSTRAINT_VIOLATION;
                                         return SLAPI_DSE_CALLBACK_ERROR;
                                 }
@@ -246,8 +245,8 @@ cb_config_add_callback(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* e2, int *r
                         while (i != -1 ) {
                         	bval = (struct berval *) slapi_value_get_berval(sval);
                                 if (!cb_is_control_forwardable(cb,bval->bv_val)) {
-                                        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG,CB_PLUGIN_SUBSYSTEM,
-                                                "control %s can't be forwarded.\n",bval->bv_val);
+                                        slapi_log_error(SLAPI_LOG_PLUGIN,CB_PLUGIN_SUBSYSTEM,
+                                                "cb_config_add_callback - control %s can't be forwarded.\n",bval->bv_val);
                                         *returncode=LDAP_CONSTRAINT_VIOLATION;
                                         return SLAPI_DSE_CALLBACK_ERROR;
 				}
@@ -359,8 +358,8 @@ cb_config_modify_check_callback(Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slap
                         for (j = 0; mods[i]->mod_bvalues && mods[i]->mod_bvalues[j]; j++) {
                                 config_attr_value = (char *) mods[i]->mod_bvalues[j]->bv_val;
                                 if (!cb_is_control_forwardable(cb,config_attr_value)) {
-                                        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG,CB_PLUGIN_SUBSYSTEM,
-                                                "control %s can't be forwarded.\n",config_attr_value);
+                                        slapi_log_error(SLAPI_LOG_PLUGIN,CB_PLUGIN_SUBSYSTEM,
+                                                "cb_config_modify_check_callback - control %s can't be forwarded.\n",config_attr_value);
                                         *returncode=LDAP_CONSTRAINT_VIOLATION;
                                         return SLAPI_DSE_CALLBACK_ERROR;
                                 }
@@ -393,8 +392,8 @@ cb_config_modify_callback(Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entr
         	for (j = 0; mods[i]->mod_bvalues && mods[i]->mod_bvalues[j]; j++) {
         		config_attr_value = (char *) mods[i]->mod_bvalues[j]->bv_val;
 				if (!cb_is_control_forwardable(cb,config_attr_value)) {
-				        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG,CB_PLUGIN_SUBSYSTEM,
-						"control %s can't be forwarded.\n",config_attr_value);
+				        slapi_log_error(SLAPI_LOG_PLUGIN,CB_PLUGIN_SUBSYSTEM,
+						"cb_config_modify_callback - control %s can't be forwarded.\n",config_attr_value);
 					*returncode=LDAP_CONSTRAINT_VIOLATION;
 					return SLAPI_DSE_CALLBACK_ERROR;
 				}

ldap/servers/plugins/chainingdb/cb_conn_stateless.c

@@ -91,8 +91,8 @@ void cb_close_conn_pool(cb_conn_pool * pool) {
 		for (i=0; i< MAX_CONN_ARRAY; i++) {
 			for (conn = pool->connarray[i]; conn != NULL; conn = nextconn) {
 			  if ( conn->status != CB_CONNSTATUS_OK ) {
-			    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-					     "cb_close_conn_pool: unexpected connection state (%d)\n",conn->status);
+			    slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+					     "cb_close_conn_pool - Unexpected connection state (%d)\n",conn->status);
 			  }
 			  nextconn=conn->next;
 			  cb_close_and_dispose_connection(conn);
@@ -102,8 +102,8 @@ void cb_close_conn_pool(cb_conn_pool * pool) {
 	else {
         for ( conn = pool->conn.conn_list; conn != NULL; conn = nextconn ) {
         	if ( conn->status != CB_CONNSTATUS_OK ) {
-  			slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-				"cb_close_conn_pool: unexpected connection state (%d)\n",conn->status);
+  			slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+				"cb_close_conn_pool - Unexpected connection state (%d)\n",conn->status);
 		}
 		nextconn=conn->next;
 		cb_close_and_dispose_connection(conn);
@@ -194,8 +194,8 @@ cb_get_connection(cb_conn_pool * pool,
 	if (maxconnections <=0) {
 		static int warned_maxconn = 0;
 		if (!warned_maxconn) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-			    "<== cb_get_connection error (no connection available)\n");
+			slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+			    "cb_get_connection - Error (no connection available)\n");
 			warned_maxconn = 1;
 		}
 		if ( errmsg ) {
@@ -238,8 +238,8 @@ cb_get_connection(cb_conn_pool * pool,
     	slapi_lock_mutex( pool->conn.conn_list_mutex );
 
 	if (cb_debug_on()) {
-  		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-        		"==> cb_get_connection server %s conns: %d maxconns: %d\n",
+  		slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+        		"cb_get_connection - server %s conns: %d maxconns: %d\n",
         		hostname, pool->conn.conn_list_count, maxconnections );
 	}
 
@@ -248,8 +248,8 @@ cb_get_connection(cb_conn_pool * pool,
 		/* time limit mgmt */
 		if (checktime) {
 			if (current_time() > endbefore ) {
-  				slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-        				"cb_get_connection server %s expired.\n", hostname );
+  				slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+        				"cb_get_connection - server %s expired.\n", hostname );
 				if ( errmsg ) {
 					*errmsg = PR_smprintf(error1,"timelimit exceeded");
 				}
@@ -269,8 +269,8 @@ cb_get_connection(cb_conn_pool * pool,
 			  if ((conn->ThreadId == PR_MyThreadId()) && (conn->status == CB_CONNSTATUS_OK &&
 			        conn->refcount < maxconcurrency)){
 			        if (cb_debug_on()) {
-                			slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-                        		"<= cb_get_connection server found conn 0x%p to use)\n", conn );
+                			slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+                        		"cb_get_connection - server found conn 0x%p to use)\n", conn );
 				}
 				goto unlock_and_return;         /* found one */
 			  }
@@ -280,16 +280,16 @@ cb_get_connection(cb_conn_pool * pool,
         	connprev = NULL;
         	for ( conn = pool->conn.conn_list; conn != NULL; conn = conn->next ) {
 			if (cb_debug_on()) {
-                		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-                        		"list: conn 0x%p status %d refcount %lu\n", conn, 
+                		slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+                        		"cb_get_connection - conn 0x%p status %d refcount %lu\n", conn, 
 					conn->status, conn->refcount );
 			}
 
             		if ( conn->status == CB_CONNSTATUS_OK
                     		&& conn->refcount < maxconcurrency ) {
 				if (cb_debug_on()) {
-                			slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-                        		"<= cb_get_connection server found conn 0x%p to use)\n", conn );
+                			slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+                        		"cb_get_connection - server found conn 0x%p to use)\n", conn );
 				}
                 		goto unlock_and_return;         /* found one */
             		}
@@ -311,8 +311,8 @@ cb_get_connection(cb_conn_pool * pool,
 			if (NULL == ld) {
 				static int warned_init = 0;
 				if (!warned_init) {
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-					                 "Can't contact server <%s> port <%d>.\n",
+					slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+					                 "cb_get_connection -  Can't contact server <%s> port <%d>.\n",
 					                 hostname, port );
 					warned_init = 1;
 				}
@@ -340,8 +340,8 @@ cb_get_connection(cb_conn_pool * pool,
 				rc=LDAP_SUCCESS;
 
 				if (cb_debug_on()) {
-                               		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-                                       	"Bind to to server <%s> port <%d> as <%s>\n",
+                               		slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+                                       	"cb_get_connection - Bind to to server <%s> port <%d> as <%s>\n",
                                		hostname, port, binddn);
 				}
 
@@ -352,8 +352,8 @@ cb_get_connection(cb_conn_pool * pool,
 				{
 					static int warned_pw = 0;
 					if (!warned_pw) {
-						slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-							"Internal credentials decoding error; "
+						slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+							"cb_get_connection - Internal credentials decoding error; "
 							"password storage schemes do not match or "
 							"encrypted password is corrupted.\n");
 						warned_pw = 1;
@@ -374,8 +374,8 @@ cb_get_connection(cb_conn_pool * pool,
 				if ( rc == LDAP_TIMEOUT ) {
 					static int warned_bind_timeout = 0;
 					if (!warned_bind_timeout) {
-						slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-							"Can't bind to server <%s> port <%d>. (%s)\n",
+						slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+							"cb_get_connection - Can't bind to server <%s> port <%d>. (%s)\n",
 							hostname, port, "time-out expired");
 						warned_bind_timeout = 1;
 					}
@@ -388,8 +388,8 @@ cb_get_connection(cb_conn_pool * pool,
 					prerr=PR_GetError();
 					static int warned_bind_err = 0;
 					if (!warned_bind_err) {
-						slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-								"Can't bind to server <%s> port <%d>. "
+						slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+								"cb_get_connection - Can't bind to server <%s> port <%d>. "
 								"(LDAP error %d - %s; "
 								SLAPI_COMPONENT_NAME_NSPR " error %d - %s)\n",
 								hostname, port, rc,
@@ -412,8 +412,8 @@ cb_get_connection(cb_conn_pool * pool,
 						if ( !(strcmp( serverctrls[ i ]->ldctl_oid, LDAP_CONTROL_PWEXPIRED)) )
 						{
 						    /* Bind is successful but password has expired */
-						    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM, 
-								    "Successfully bound as %s to remote server %s:%d, "
+						    slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM, 
+								    "cb_get_connection - Successfully bound as %s to remote server %s:%d, "
 								    "but password has expired.\n",
 								    binddn, hostname, port);
 						}					
@@ -424,8 +424,8 @@ cb_get_connection(cb_conn_pool * pool,
 							 (serverctrls[ i ]->ldctl_value.bv_len > 0) )
 						    {
 							int password_expiring = atoi( serverctrls[ i ]->ldctl_value.bv_val );
-							slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM, 
-									"Successfully bound as %s to remote server %s:%d, "
+							slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM, 
+									"cb_get_connection - Successfully bound as %s to remote server %s:%d, "
 									"but password is expiring in %d seconds.\n",
 									binddn, hostname, port, password_expiring);
 						    }
@@ -437,13 +437,13 @@ cb_get_connection(cb_conn_pool * pool,
 				/* the start_tls operation is usually performed in slapi_ldap_bind, but
 				   since we are not binding we still need to start_tls */
 				if (cb_debug_on()) {
-                			slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-							 "<= cb_get_connection doing start_tls on connection 0x%p\n", conn );
+                			slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+							 "cb_get_connection - doing start_tls on connection 0x%p\n", conn );
 				}
 				if ((rc = ldap_start_tls_s(ld, NULL, NULL))) {
 					PRErrorCode prerr = PR_GetError();
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM, 
-							"Unable to do start_tls on connection to %s:%d "
+					slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM, 
+							"cb_get_connection - Unable to do start_tls on connection to %s:%d "
 							"LDAP error %d:%s NSS error %d:%s\n", hostname, port,
 							rc, ldap_err2string(rc), prerr,
 							slapd_pr_strerror(prerr));
@@ -479,23 +479,23 @@ cb_get_connection(cb_conn_pool * pool,
 			++pool->conn.conn_list_count;
 				
 			if (cb_debug_on()) {
-                      	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-                    		"<= cb_get_connection added new conn 0x%p, "
+                      	slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+                    		"cb_get_connection - added new conn 0x%p, "
                     		"conn count now %d\n", conn->ld, pool->conn.conn_list_count );
 			}
             		goto unlock_and_return;             /* got a new one */
 		}
 
 		if (cb_debug_on()) {
-        	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-                "... cb_get_connection waiting for conn to free up\n" );
+        	slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+                "cb_get_connection - waiting for conn to free up\n" );
 		}
 		
    		if (!secure) slapi_wait_condvar( pool->conn.conn_list_cv, NULL );
 
 		if (cb_debug_on()) {
-        		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-                	"... cb_get_connection awake again\n" );
+        		slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+                	"cb_get_connection - awake again\n" );
 		}
     	} 
 
@@ -505,8 +505,8 @@ unlock_and_return:
 		*lld=conn->ld;
 		*cc=conn;
 		if (cb_debug_on()) {
-  		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-                "<== cb_get_connection ld=0x%p (concurrency now %lu)\n",*lld, conn->refcount );
+  		slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+                "cb_get_connection - ld=0x%p (concurrency now %lu)\n",*lld, conn->refcount );
 		}
 
     	} else {
@@ -515,8 +515,8 @@ unlock_and_return:
 		}
 
 		if (cb_debug_on()) {
-	        	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-       		         "<== cb_get_connection error %d\n", rc );
+	        	slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+       		         "cb_get_connection - error %d\n", rc );
 		}
     	}
 
@@ -558,15 +558,15 @@ void cb_release_op_connection(cb_conn_pool* pool, LDAP *lld, int dispose) {
 	}
 
 	if ( conn == NULL ) {               /* ld not found -- unexpected */
-        	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-                "==> cb_release_op_connection ld=0x%p not found\n", lld );
+        	slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+                "cb_release_op_connection - ld=0x%p not found\n", lld );
     	} else {
 
         	--conn->refcount;
 
 		if (cb_debug_on()) {
-                	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-                        	"release conn 0x%p status %d refcount after release %lu\n", conn,
+                	slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+                        	"cb_release_op_connection - release conn 0x%p status %d refcount after release %lu\n", conn,
                                         conn->status, conn->refcount );
                 }
 
@@ -648,8 +648,8 @@ static void cb_check_for_stale_connections(cb_conn_pool * pool) {
 		    	(( connlifetime > 0) && (curtime - conn->opentime > connlifetime))) {
 				if ( conn->refcount == 0 ) {
 					if (cb_debug_on()) {
-                        			slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-							"cb_check_for_stale_connections: conn 0x%p idle and stale\n",conn);
+                        slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+							"cb_check_for_stale_connections - conn 0x%p idle and stale\n",conn);
 					}
                                		--pool->conn.conn_list_count;
 					if (connprev == NULL) {
@@ -669,8 +669,8 @@ static void cb_check_for_stale_connections(cb_conn_pool * pool) {
 				  conn->status = CB_CONNSTATUS_STALE;
 				}
                         	if (cb_debug_on()) {
-                        	        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-                       		                "cb_check_for_stale_connections: conn 0x%p stale\n",conn);
+                        	        slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+                       		                "cb_check_for_stale_connections - conn 0x%p stale\n",conn);
                         	}
 			}
 			connprev = conn ;
@@ -693,8 +693,8 @@ static void cb_check_for_stale_connections(cb_conn_pool * pool) {
                                         connprev->next=conn->next;
 
 				if (cb_debug_on()) {
-                        		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-						"cb_check_for_stale_connections: conn 0x%p idle and stale\n",conn);
+                        		slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+						"cb_check_for_stale_connections - conn 0x%p idle and stale\n",conn);
 				}
                                 --pool->conn.conn_list_count;
 				conn_next=conn->next;
@@ -709,8 +709,8 @@ static void cb_check_for_stale_connections(cb_conn_pool * pool) {
 			  conn->status = CB_CONNSTATUS_STALE;
 			}
                         if (cb_debug_on()) {
-                                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-                                        "cb_check_for_stale_connections: conn 0x%p stale\n",conn);
+                                slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+                                        "cb_check_for_stale_connections - conn 0x%p stale\n",conn);
                         }
 		}
                 connprev = conn;
@@ -907,8 +907,8 @@ void cb_update_failed_conn_cpt ( cb_backend_instance *cb ) {
 	       		       cb->monitor_availability.unavailableTimeLimit = now + CB_UNAVAILABLE_PERIOD ;
 			slapi_unlock_mutex(cb->monitor_availability.lock_timeLimit);
 	       		cb->monitor_availability.farmserver_state = FARMSERVER_UNAVAILABLE ;
-			slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-				"cb_update_failed_conn_cpt: Farm server unavailable");
+			slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+				"cb_update_failed_conn_cpt - Farm server unavailable");
 	       	}
 		
 	}
@@ -920,8 +920,8 @@ void cb_reset_conn_cpt( cb_backend_instance *cb ) {
 			cb->monitor_availability.cpt = 0 ;
 			if (cb->monitor_availability.farmserver_state == FARMSERVER_UNAVAILABLE) {
 				cb->monitor_availability.farmserver_state = FARMSERVER_AVAILABLE ;
-			        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-				"cb_reset_conn_cpt: Farm server is back");
+			    slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+				"cb_reset_conn_cpt - Farm server is back");
 			}
 		slapi_unlock_mutex(cb->monitor_availability.cpt_lock);
 	}
@@ -942,16 +942,16 @@ int cb_check_availability( cb_backend_instance *cb, Slapi_PBlock *pb ) {
 		    cb_send_ldap_result( pb, LDAP_OPERATIONS_ERROR, NULL, "FARM SERVER TEMPORARY UNAVAILABLE", 0, NULL) ;
 		    return FARMSERVER_UNAVAILABLE ;
 		}
-	        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-				"cb_check_availability: ping the farm server and check if it's still unavailable");
+	        slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+				"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 = current_time();
 		    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) ;
-	            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-				"cb_check_availability: Farm server still unavailable");
+	            slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+				"cb_check_availability - Farm server still unavailable");
 		    return FARMSERVER_UNAVAILABLE ;
 		}
 		else {

ldap/servers/plugins/chainingdb/cb_controls.c

@@ -158,7 +158,7 @@ int cb_update_controls( Slapi_PBlock * pb,
             /* we have to force remote acl checking if the associated backend to this
             chaining backend is disabled - disabled == no acl check possible */
             if (!cb->local_acl && !cb->associated_be_is_disabled) {
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG,CB_PLUGIN_SUBSYSTEM,
+                slapi_log_error(SLAPI_LOG_PLUGIN,CB_PLUGIN_SUBSYSTEM,
                     "local aci check required to handle proxied auth control. Deny access.\n");
                     rc= LDAP_INSUFFICIENT_ACCESS;
                 break;
@@ -177,7 +177,7 @@ int cb_update_controls( Slapi_PBlock * pb,
                 slapi_dn_ignore_case(requestorCopy);
 
                 if (!strcmp( requestorCopy, rootdn )) {    /* UTF8- aware */
-                    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG,CB_PLUGIN_SUBSYSTEM,
+                    slapi_log_error(SLAPI_LOG_PLUGIN,CB_PLUGIN_SUBSYSTEM,
                             "Use of user <%s> incompatible with proxied auth. control\n",
                             rootdn);
                     rc = LDAP_UNAVAILABLE_CRITICAL_EXTENSION;
@@ -202,7 +202,7 @@ int cb_update_controls( Slapi_PBlock * pb,
 
             ber = ber_init(&(reqControls[cCount]->ldctl_value));
             if (LBER_ERROR == ber_scanf(ber,"i",&hops)) {
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG,CB_PLUGIN_SUBSYSTEM,
+                slapi_log_error(SLAPI_LOG_PLUGIN,CB_PLUGIN_SUBSYSTEM,
                                  "Unable to get number of hops from the chaining control\n");
             }
             ber_free(ber,1);
@@ -255,7 +255,7 @@ int cb_update_controls( Slapi_PBlock * pb,
 
         if ( slapi_ldap_create_proxyauth_control(ld, proxyDN, isabandon?0:1, 0, &ctrls[dCount] )) {
             ldap_controls_free(ctrls);
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
+                slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
                 "LDAP_CONTROL_PROXYAUTH control encoding failed.\n");
             return LDAP_OPERATIONS_ERROR;
         }

ldap/servers/plugins/chainingdb/cb_delete.c

@@ -86,8 +86,8 @@ chaining_back_delete ( Slapi_PBlock *pb )
 	if (LDAP_SUCCESS != rc) {
 		static int warned_get_conn = 0;
 		if (!warned_get_conn) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-			                "cb_get_connection failed (%d) %s\n",
+			slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+			                "chaining_back_delete - connection failed (%d) %s\n",
 			                rc, ldap_err2string(rc));
 			warned_get_conn = 1;
 		}
@@ -123,7 +123,7 @@ chaining_back_delete ( Slapi_PBlock *pb )
 	 * Call the backend preoperation plugins
 	 */
 	if((rc = slapi_plugin_call_preop_be_plugins(pb, SLAPI_PLUGIN_DEL_OP))){
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM, "delete (%s): pre betxn failed, error (%d)\n",dn,rc);
+		slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM, "chaining_back_delete - delete (%s): pre betxn failed, error (%d)\n",dn,rc);
 		cb_release_op_connection(cb->pool,ld,0);
 		ldap_controls_free(ctrls);
 		return -1;
@@ -176,8 +176,8 @@ chaining_back_delete ( Slapi_PBlock *pb )
 			if ( parse_rc != LDAP_SUCCESS ) {
 				static int warned_parse_rc = 0;
 				if (!warned_parse_rc) {
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-						"%s%s%s\n",
+					slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+						"chaining_back_delete - %s%s%s\n",
 						matched_msg?matched_msg:"",
 						(matched_msg&&(*matched_msg!='\0'))?": ":"",
 						ldap_err2string(parse_rc) );
@@ -197,8 +197,8 @@ chaining_back_delete ( Slapi_PBlock *pb )
 				struct berval ** refs =  referrals2berval(referrals); 
 				static int warned_rc = 0;
 				if (!warned_rc && error_msg) {
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-						"%s%s%s\n",
+					slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+						"chaining_back_delete - %s%s%s\n",
 						matched_msg?matched_msg:"",
 						(matched_msg&&(*matched_msg!='\0'))?": ":"",
 						error_msg );
@@ -219,7 +219,7 @@ chaining_back_delete ( Slapi_PBlock *pb )
 
 			/* Call the backend postoperation plugins */
 			if((rc = slapi_plugin_call_postop_be_plugins(pb, SLAPI_PLUGIN_DEL_OP))){
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM, "delete (%s): post betxn failed, error (%d)\n",dn,rc);
+				slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM, "chaining_back_delete - delete (%s): post betxn failed, error (%d)\n",dn,rc);
 			}
 
 			/* Add control response sent by the farm server */

ldap/servers/plugins/chainingdb/cb_init.c

@@ -117,7 +117,7 @@ chaining_back_init( Slapi_PBlock *pb )
 	*/
 
  	if ( rc != 0 ) {
-        	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM, "chaining_back_init failed\n");
+        	slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM, "chaining_back_init - Failed\n");
                 return( -1 );
         }
 

ldap/servers/plugins/chainingdb/cb_instance.c

@@ -502,8 +502,8 @@ cb_parse_instance_config_entry(cb_backend * cb, Slapi_Entry * e)
 		attrValue = slapi_value_get_berval(sval);
 		instname = attrValue->bv_val;
 	} else {
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM, 
-			"Malformed backend instance (<%s> missing)>\n", CB_CONFIG_INSTNAME); 
+		slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM, 
+			"cb_parse_instance_config_entry - Malformed backend instance (<%s> missing)>\n", CB_CONFIG_INSTNAME); 
 		return -1;
 	}
 
@@ -609,7 +609,8 @@ cb_instance_config_initialize(cb_backend_instance * inst, Slapi_Entry * e , int
 
 		if (cb_instance_config_set((void *) inst, attr_name,
 			cb_the_instance_config, bval, err_buf, phase, apply ) != LDAP_SUCCESS) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,"Error with config attribute %s : %s\n",
+			slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,"cb_instance_config_initialize - "
+				"Error with config attribute %s : %s\n",
 				attr_name, err_buf);
 			rc = -1;
 			break;
@@ -627,7 +628,8 @@ cb_instance_config_initialize(cb_backend_instance * inst, Slapi_Entry * e , int
 
 	if (LDAP_SUCCESS == rc) {
 		if (!urlfound) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+			slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+				"cb_instance_config_initialize - "
 				"Malformed backend instance entry. Mandatory attr <%s> missing\n",CB_CONFIG_HOSTURL);
 			rc = -1;
 		}
@@ -650,7 +652,8 @@ cb_instance_config_initialize(cb_backend_instance * inst, Slapi_Entry * e , int
 
 	if (inst->impersonate && inst->pool && inst->pool->binddn && 
 		!strcmp(inst->pool->binddn,rootdn)) {	/* UTF8 aware */
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+		slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+			"cb_instance_config_initialize - "
 			"Error with config attribute %s (%s: forbidden value)\n", CB_CONFIG_BINDUSER, rootdn);
 		rc= -1;
 	}
@@ -1563,8 +1566,8 @@ void cb_instance_config_get(void *arg, cb_instance_config_info *config, char *bu
                 }
                 break;
 	default:
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-                        "Invalid attribute syntax.\n");
+                slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+                        "cb_instance_config_get - Invalid attribute syntax.\n");
 	
         }
 }
@@ -1755,8 +1758,8 @@ int cb_instance_add_config_check_callback(Slapi_PBlock *pb, Slapi_Entry* e, Slap
                 instname=attrValue->bv_val;
         }
 	if ( instname == NULL ) {
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-                        "Malformed backend instance (<%s> missing)>\n", CB_CONFIG_INSTNAME);
+                slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+                        "cb_instance_add_config_check_callback - Malformed backend instance (<%s> missing)>\n", CB_CONFIG_INSTNAME);
 				*returncode = LDAP_LOCAL_ERROR;
                 return SLAPI_DSE_CALLBACK_ERROR;
         }
@@ -1768,8 +1771,8 @@ int cb_instance_add_config_check_callback(Slapi_PBlock *pb, Slapi_Entry* e, Slap
 	/* the default instance config and the specific entry specified */
 	if ((rc=cb_build_backend_instance_config(inst,e,0))
 		!= LDAP_SUCCESS) {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-                	"Can't instantiate chaining backend instance %s.\n",inst->inst_name);
+                slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+                	"cb_instance_add_config_check_callback - Can't instantiate chaining backend instance %s.\n",inst->inst_name);
 		*returncode=rc;
                 cb_instance_free(inst);
                 return SLAPI_DSE_CALLBACK_ERROR;
@@ -1811,8 +1814,8 @@ int cb_instance_add_config_callback(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entr
                 instname=attrValue->bv_val;
         }
 	if ( instname == NULL ) {
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-                        "Malformed backend instance (<%s> missing)>\n", CB_CONFIG_INSTNAME);
+                slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+                        "cb_instance_add_config_callback - Malformed backend instance (<%s> missing)>\n", CB_CONFIG_INSTNAME);
 				*returncode = LDAP_LOCAL_ERROR;
                 return SLAPI_DSE_CALLBACK_ERROR;
         }
@@ -1824,8 +1827,8 @@ int cb_instance_add_config_callback(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entr
 	/* the default instance config and the specific entry specified */
 	if ((rc=cb_build_backend_instance_config(inst,e,0))
 		!= LDAP_SUCCESS) {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-                	"Can't instantiate chaining backend instance %s.\n",inst->inst_name);
+                slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+                	"cb_instance_add_config_callback - Can't instantiate chaining backend instance %s.\n",inst->inst_name);
 		*returncode=rc;
                 cb_instance_free(inst);
                 return SLAPI_DSE_CALLBACK_ERROR;
@@ -1939,8 +1942,8 @@ int cb_create_default_backend_instance_config(cb_backend * cb) {
 	slapi_add_internal_pb(pb);
 	slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &rc);
 	if ( LDAP_SUCCESS != rc ) {
-	  slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-			  "Add %s failed (%s)\n",defaultDn,ldap_err2string(rc));
+	  slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+			  "cb_create_default_backend_instance_config - Add %s failed (%s)\n",defaultDn,ldap_err2string(rc));
 	}
 
         slapi_pblock_destroy(pb); 

ldap/servers/plugins/chainingdb/cb_modify.c

@@ -64,7 +64,7 @@ chaining_back_modify ( Slapi_PBlock *pb )
 	dn = slapi_sdn_get_dn(sdn);
 
 	if (cb_debug_on()) {
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,"modify: target:<%s>\n",dn);
+		slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,"modify: target:<%s>\n",dn);
 	}
 
 	ctrls = serverctrls = NULL;
@@ -92,8 +92,8 @@ chaining_back_modify ( Slapi_PBlock *pb )
 	if (LDAP_SUCCESS != rc) {
 		static int warned_get_conn = 0;
 		if (!warned_get_conn) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-			                "cb_get_connection failed (%d) %s\n",
+			slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+			                "chaining_back_modify - cb_get_connection failed (%d) %s\n",
 			                rc, ldap_err2string(rc));
 			warned_get_conn = 1;
 		}
@@ -131,7 +131,7 @@ chaining_back_modify ( Slapi_PBlock *pb )
 	 * Call the backend preoperation plugins
 	 */
 	if((rc = slapi_plugin_call_preop_be_plugins(pb, SLAPI_PLUGIN_MOD_OP))){
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM, "modify (%s): pre betxn failed, error (%d)\n",dn,rc);
+		slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM, "chaining_back_modify - modify (%s): pre betxn failed, error (%d)\n",dn,rc);
 		cb_release_op_connection(cb->pool,ld,0);
 		ldap_controls_free(ctrls);
 		return -1;
@@ -185,8 +185,8 @@ chaining_back_modify ( Slapi_PBlock *pb )
 			if ( parse_rc != LDAP_SUCCESS ) {
 				static int warned_parse_rc = 0;
 				if (!warned_parse_rc) {
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-						"%s%s%s\n",
+					slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+						"chaining_back_modify - %s%s%s\n",
 						matched_msg?matched_msg:"",
 						(matched_msg&&(*matched_msg!='\0'))?": ":"",
 						ldap_err2string(parse_rc));
@@ -206,8 +206,8 @@ chaining_back_modify ( Slapi_PBlock *pb )
 				struct berval ** refs =  referrals2berval(referrals); 
 				static int warned_rc = 0;
 				if (!warned_rc && error_msg) {
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-						"%s%s%s\n",
+					slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+						"chaining_back_modify - %s%s%s\n",
 						matched_msg?matched_msg:"",
 						(matched_msg&&(*matched_msg!='\0'))?": ":"",
 						error_msg );
@@ -228,7 +228,7 @@ chaining_back_modify ( Slapi_PBlock *pb )
 
 			/* Call the backend postoperation plugins */
 			if((rc = slapi_plugin_call_postop_be_plugins(pb, SLAPI_PLUGIN_MOD_OP))){
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM, "modify (%s): post betxn failed, error (%d)\n",dn,rc);
+				slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM, "chaining_back_modify - modify (%s): post betxn failed, error (%d)\n",dn,rc);
 			}
 
 			/* Add control response sent by the farm server */

ldap/servers/plugins/chainingdb/cb_modrdn.c

@@ -97,8 +97,8 @@ chaining_back_modrdn ( Slapi_PBlock *pb )
 	if (LDAP_SUCCESS != rc) {
 		static int warned_get_conn = 0;
 		if (!warned_get_conn) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-			                "cb_get_connection failed (%d) %s\n",
+			slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+			                "chaining_back_modrdn - cb_get_connection failed (%d) %s\n",
 			                rc, ldap_err2string(rc));
 			warned_get_conn = 1;
 		}
@@ -135,7 +135,7 @@ chaining_back_modrdn ( Slapi_PBlock *pb )
 	 * Call the backend preoperation plugins
 	 */
 	if((rc = slapi_plugin_call_preop_be_plugins(pb, SLAPI_PLUGIN_MODRDN_OP))){
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM, "modrdn (%s): pre betxn failed, error (%d)\n",ndn,rc);
+		slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM, "chaining_back_modrdn - modrdn (%s): pre betxn failed, error (%d)\n",ndn,rc);
 		cb_release_op_connection(cb->pool,ld,0);
 		ldap_controls_free(ctrls);
 		return -1;
@@ -193,8 +193,8 @@ chaining_back_modrdn ( Slapi_PBlock *pb )
 			if ( parse_rc != LDAP_SUCCESS ) {
 				static int warned_parse_rc = 0;
 				if (!warned_parse_rc) {
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-						            "%s%s%s\n", 
+					slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+						            "chaining_back_modrdn - %s%s%s\n", 
 						            matched_msg?matched_msg:"",
 						            (matched_msg&&(*matched_msg!='\0'))?": ":"",
 					                ldap_err2string(parse_rc));
@@ -214,8 +214,8 @@ chaining_back_modrdn ( Slapi_PBlock *pb )
 				struct berval ** refs =  referrals2berval(referrals); 
 				static int warned_rc = 0;
 				if (!warned_rc && error_msg) {
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-						            "%s%s%s\n", 
+					slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+						            "chaining_back_modrdn - %s%s%s\n", 
 						            matched_msg?matched_msg:"",
 						            (matched_msg&&(*matched_msg!='\0'))?": ":"",
 						            error_msg );
@@ -236,7 +236,7 @@ chaining_back_modrdn ( Slapi_PBlock *pb )
 
 			/* Call the backend postoperation plugins */
 			if((rc = slapi_plugin_call_postop_be_plugins(pb, SLAPI_PLUGIN_MODRDN_OP))){
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM, "modrdn (%s): post betxn failed, error (%d)\n",ndn,rc);
+				slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM, "chaining_back_modrdn - modrdn (%s): post betxn failed, error (%d)\n",ndn,rc);
 			}
 
 			/* Add control response sent by the farm server */

ldap/servers/plugins/chainingdb/cb_monitor.c

@@ -212,7 +212,7 @@ cb_update_monitor_info(Slapi_PBlock * pb, cb_backend_instance * inst,int op)
 			inst->monitor.searchsubtreecount++;
 		break;
 	default:
-	        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,"cb_update_monitor_info: invalid op type <%d>\n",op);
+	        slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,"cb_update_monitor_info: invalid op type <%d>\n",op);
 	}
 	slapi_unlock_mutex(inst->monitor.mutex);
 }

ldap/servers/plugins/chainingdb/cb_schema.c

@@ -37,7 +37,7 @@ void cb_eliminate_illegal_attributes(cb_backend_instance * inst, Slapi_Entry * e
 				slapi_attr_get_type(attr,&aType);
                         	if (aType && slapi_attr_types_equivalent(inst->illegal_attributes[j],aType)) {
 					tobefreed=aType;
-					slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
+					slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
 						"attribute <%s> not forwarded.\n",aType);
 				}
                 		rc = slapi_entry_next_attr(e, attr, &attr);

ldap/servers/plugins/chainingdb/cb_search.c

@@ -64,8 +64,8 @@ chainingdb_build_candidate_list ( Slapi_PBlock *pb )
 	if ( LDAP_SUCCESS != (parse_rc=cb_forward_operation(pb) )) {
 		/* Don't return errors */
 		if (cb_debug_on()) {
-			slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-			"local search: base:<%s> scope:<%s> filter:<%s>\n",target,
+			slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+			"chainingdb_build_candidate_list - local search: base:<%s> scope:<%s> filter:<%s>\n",target,
 			scope==LDAP_SCOPE_SUBTREE?"SUBTREE":scope==LDAP_SCOPE_ONELEVEL ? "ONE-LEVEL" : "BASE" , filter);
 		}
 
@@ -85,8 +85,8 @@ chainingdb_build_candidate_list ( Slapi_PBlock *pb )
 	}
 
 	if (cb_debug_on()) {
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-			"chained search: base:<%s> scope:<%s> filter:<%s>\n",target,
+		slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+			"chainingdb_build_candidate_list - chained search: base:<%s> scope:<%s> filter:<%s>\n",target,
 			scope==LDAP_SCOPE_SUBTREE ? "SUBTREE": scope==LDAP_SCOPE_ONELEVEL ? "ONE-LEVEL" : "BASE",
 			filter);
 	}
@@ -183,8 +183,8 @@ chainingdb_build_candidate_list ( Slapi_PBlock *pb )
 	if (LDAP_SUCCESS != rc) {
 		static int warned_get_conn = 0;
 		if (!warned_get_conn) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-			                "cb_get_connection failed (%d) %s\n",
+			slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+			                "chainingdb_build_candidate_list - cb_get_connection failed (%d) %s\n",
 			                rc, ldap_err2string(rc));
 			warned_get_conn = 1;
 		}
@@ -284,8 +284,8 @@ chainingdb_build_candidate_list ( Slapi_PBlock *pb )
 			/* Local timeout management */
 			if (timelimit != -1) {
 				if (current_time() > endbefore) {
-					slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-						"Local timeout expiration\n");
+					slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+						"chainingdb_build_candidate_list - Local timeout expiration\n");
 					cb_send_ldap_result(pb,LDAP_TIMELIMIT_EXCEEDED,
 						NULL,NULL, 0, NULL);
 					/* Force connection close */
@@ -329,7 +329,7 @@ chainingdb_build_candidate_list ( Slapi_PBlock *pb )
 			if ( parse_rc != LDAP_SUCCESS ) {
 				static int warned_parse_rc = 0;
 				if (!warned_parse_rc && error_msg) {
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+					slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
 						"%s%s%s\n",
 						matched_msg?matched_msg:"",
 						(matched_msg&&(*matched_msg!='\0'))?": ":"",
@@ -342,7 +342,7 @@ chainingdb_build_candidate_list ( Slapi_PBlock *pb )
 				static int warned_rc = 0;
 				if (!warned_rc) {
 					slapi_ldap_get_lderrno( ctx->ld, &matched_msg, &error_msg );
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+					slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
 						"%s%s%s\n",
 						matched_msg?matched_msg:"",
 						(matched_msg&&(*matched_msg!='\0'))?": ":"",
@@ -426,8 +426,8 @@ chainingdb_next_search_entry ( Slapi_PBlock *pb )
 		/* End of local search */
         	slapi_pblock_set( pb, SLAPI_SEARCH_RESULT_SET,NULL);
         	slapi_pblock_set( pb, SLAPI_SEARCH_RESULT_ENTRY,NULL);
-        	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-			"Unexpected NULL ctx in chainingdb_next_search_entry\n");
+        	slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+			    "chainingdb_next_search_entry - Unexpected NULL ctx in chainingdb_next_search_entry\n");
 		return 0;
 	}
 
@@ -584,7 +584,7 @@ chainingdb_next_search_entry ( Slapi_PBlock *pb )
 
          		/* The server sent one of the entries found by the search */
 			if ((entry = cb_LDAPMessage2Entry(ctx->ld,res,attrsonly)) == NULL) {
-        			slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,"Invalid entry received.\n");
+        			slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,"chainingdb_next_search_entry - Invalid entry received.\n");
         			slapi_pblock_set( pb, SLAPI_SEARCH_RESULT_SET,NULL);
         			slapi_pblock_set( pb, SLAPI_SEARCH_RESULT_ENTRY,NULL);
 
@@ -676,7 +676,7 @@ chainingdb_next_search_entry ( Slapi_PBlock *pb )
 			if ( parse_rc != LDAP_SUCCESS ) {
 				static int warned_parse_rc = 0;
 				if (!warned_parse_rc) {
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+					slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
 						            "%s%s%s\n", 
 						            matched_msg?matched_msg:"",
 						            (matched_msg&&(*matched_msg!='\0'))?": ":"",
@@ -691,7 +691,7 @@ chainingdb_next_search_entry ( Slapi_PBlock *pb )
 				static int warned_rc = 0;
 				slapi_ldap_get_lderrno( ctx->ld, &matched_msg, &error_msg );
 				if (!warned_rc) {
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+					slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
 						            "%s%s%s\n", 
 						            matched_msg?matched_msg:"",
 						            (matched_msg&&(*matched_msg!='\0'))?": ":"",
@@ -722,8 +722,8 @@ chainingdb_next_search_entry ( Slapi_PBlock *pb )
 			return retcode;
 
 		default:
-        		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM, 
-				"chainingdb_next_search_entry:default case.\n");
+        		slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM, 
+				"chainingdb_next_search_entry - default case.\n");
 			
 		}
 	}
@@ -734,7 +734,7 @@ chainingdb_next_search_entry ( Slapi_PBlock *pb )
 
 int
 chaining_back_entry_release ( Slapi_PBlock *pb ) {
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM, "chaining_back_entry_release\n");
+	slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM, "chaining_back_entry_release\n");
 	return 0;
 }
 
@@ -743,7 +743,7 @@ chaining_back_search_results_release ( void **sr )
 {
     cb_searchContext *ctx = (cb_searchContext *)(*sr);
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
                      "chaining_back_search_results_release\n");
     if (ctx->readahead != ctx->tobefreed) {
         slapi_entry_free(ctx->readahead);

ldap/servers/plugins/chainingdb/cb_utils.c

@@ -111,7 +111,7 @@ cb_forward_operation(Slapi_PBlock * pb)
 
 	slapi_pblock_get (pb, SLAPI_OPERATION, &op);
 	if (NULL == op) {
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM, "No operation is set.\n");
+		slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM, "cb_forward_operation - No operation is set.\n");
 		return LDAP_UNWILLING_TO_PERFORM;
 	}
 
@@ -133,8 +133,8 @@ cb_forward_operation(Slapi_PBlock * pb)
 			BerElement 	*ber = NULL;
 
 			if ((ber = ber_init(ctl_value)) == NULL) {
-			        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-					"cb_forward_operation: ber_init: Memory allocation failed");
+			        slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+					"cb_forward_operation - ber_init: Memory allocation failed");
                                 if (iscritical)
                                     return LDAP_UNAVAILABLE_CRITICAL_EXTENSION; /* RFC 4511 4.1.11 */
                                 else
@@ -142,8 +142,8 @@ cb_forward_operation(Slapi_PBlock * pb)
 			}
 			rc = ber_scanf(ber,"i",&hops);
 			if (LBER_ERROR == rc) {
-       				slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-					"Loop detection control badly encoded.");
+       				slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+					"cb_forward_operation - Loop detection control badly encoded.");
         			ber_free(ber,1);
 				if (iscritical)
                                     return LDAP_UNAVAILABLE_CRITICAL_EXTENSION; /* RFC 4511 4.1.11 */
@@ -152,8 +152,8 @@ cb_forward_operation(Slapi_PBlock * pb)
 			}
 				
 			if (hops <= 0) {
-       				slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-					"Max hop count exceeded. Loop detected.\n");
+       				slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+					"cb_forward_operation - Max hop count exceeded. Loop detected.\n");
         			ber_free(ber,1);
 				if (iscritical)
                                     return LDAP_UNAVAILABLE_CRITICAL_EXTENSION; /* RFC 4511 4.1.11 */
@@ -170,15 +170,15 @@ cb_forward_operation(Slapi_PBlock * pb)
         slapi_pblock_get (pb, SLAPI_PLUGIN_IDENTITY, &cid);
 	if ( cid == NULL ) {
 		/* programming error in the front-end */
-       		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, CB_PLUGIN_SUBSYSTEM,
-			"NULL component identity in an internal operation.");
+       		slapi_log_error(SLAPI_LOG_ERR, CB_PLUGIN_SUBSYSTEM,
+			"cb_forward_operation - NULL component identity in an internal operation.");
 		return LDAP_UNWILLING_TO_PERFORM;
 	}
 	pname=cid->sci_component_name;
 
 	if (cb_debug_on()) {
-       		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, CB_PLUGIN_SUBSYSTEM,
-			"internal op received from %s component \n",pname ? pname : "NULL");
+       		slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
+			"cb_forward_operation - internal op received from %s component \n",pname ? pname : "NULL");
 	}
 
 	/* First, make sure chaining is not denied */
@@ -352,7 +352,7 @@ cb_be_state_change (void *handle, char *be_name, int old_be_state, int new_be_st
 					if (cbinst) {
 						/* the backend is disabled if the state is not ON */
 						cbinst->associated_be_is_disabled = (new_be_state != SLAPI_BE_STATE_ON);
-						slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, "chainbe", "cb_be_state_change: set the "
+						slapi_log_error(SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM, "cb_be_state_change - Set the "
 										"state of chainbe for %s to %d\n",
 										slapi_sdn_get_dn(cbsuffix), (new_be_state != SLAPI_BE_STATE_ON));
 					}

ldap/servers/plugins/collation/collate.c

@@ -60,7 +60,7 @@ collation_config (size_t cargc, char** cargv,
 	/* ignore - not needed anymore with ICU - was used to get path for NLS_Initialize */
     } else if (!strcasecmp (cargv[0], "collation")) {
 	if ( cargc < 7 ) {
-	    LDAPDebug(LDAP_DEBUG_ANY, LOG_ERR,
+	    LDAPDebug(LDAP_DEBUG_ERR, "collation_config - "
 		       "%s: line %lu ignored: only %lu arguments (expected "
 		       "collation language country variant strength decomposition oid ...)\n",
 		       fname, (unsigned long)lineno, (unsigned long)cargc );
@@ -76,20 +76,20 @@ collation_config (size_t cargc, char** cargv,
 	      case 3: profile->strength = UCOL_TERTIARY; break;
 	      case 4: profile->strength = UCOL_IDENTICAL; break;
 	      default: profile->strength = UCOL_SECONDARY;
- 		LDAPDebug(LDAP_DEBUG_ANY, LOG_ERR,
-			   "%s: line %lu: strength \"%s\" not supported (will use 2)\n",
-			   fname, (unsigned long)lineno, cargv[4]);
-		break;
+              LDAPDebug(LDAP_DEBUG_ERR, "collation_config - "
+                      "%s: line %lu: strength \"%s\" not supported (will use 2)\n",
+                      fname, (unsigned long)lineno, cargv[4]);
+              break;
 	    }
 	    switch (atoi(cargv[5])) {
 	      case 1: profile->decomposition = UCOL_OFF; break;
 	      case 2: profile->decomposition = UCOL_DEFAULT; /* no break here? fall through? wtf? */
 	      case 3: profile->decomposition = UCOL_ON; break;
 	      default: profile->decomposition = UCOL_DEFAULT;
-		LDAPDebug(LDAP_DEBUG_ANY, LOG_ERR,
-			   "%s: line %lu: decomposition \"%s\" not supported (will use 2)\n",
-			   fname, (unsigned long)lineno, cargv[5]);
-		break;
+              LDAPDebug(LDAP_DEBUG_ERR, "collation_config - "
+                  "%s: line %lu: decomposition \"%s\" not supported (will use 2)\n",
+                  fname, (unsigned long)lineno, cargv[5]);
+              break;
 	    }
 
             {
@@ -326,7 +326,7 @@ collation_index (indexer_t* ix, struct berval** bvec, struct berval** prefixes)
 		    }
 		    memcpy(bk->bv_val + prefixLen, key, realLen);
 		    bk->bv_val[bk->bv_len] = '\0';
-		    LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "collation_index(%.*s) %lu bytes\n",
+		    LDAPDebug(LDAP_DEBUG_FILTER, "collation_index(%.*s) %lu bytes\n",
 			       bk->bv_len, bk->bv_val, (unsigned long)bk->bv_len);
 		    keys = (struct berval**)
 			slapi_ch_realloc ((void*)keys, sizeof(struct berval*) * (keyn + 2));
@@ -425,13 +425,13 @@ collation_indexer_create (const char* oid)
 		    ix = (indexer_t*) slapi_ch_calloc (1, sizeof (indexer_t));
 		    ucol_setAttribute (coll, UCOL_STRENGTH, profile->strength, &err);
 		    if (U_FAILURE(err)) {
-		    	LDAPDebug(LDAP_DEBUG_ANY, LOG_ERR, "collation_indexer_create: could not "
-				   "set the collator strength for oid %s to %d: err %d\n",
-				   oid, profile->strength, err);
+		    	LDAPDebug(LDAP_DEBUG_ERR, "collation_indexer_create - "
+		    	        "Could not set the collator strength for oid %s to %d: err %d\n",
+				        oid, profile->strength, err);
 		    }
 		    ucol_setAttribute (coll, UCOL_DECOMPOSITION_MODE, profile->decomposition, &err);
 		    if (U_FAILURE(err)) {
-		    	LDAPDebug(LDAP_DEBUG_ANY, LOG_ERR, "collation_indexer_create: could not "
+		    	LDAPDebug(LDAP_DEBUG_ERR, "collation_indexer_create - Could not "
 				   "set the collator decomposition mode for oid %s to %d: err %d\n",
 				   oid, profile->decomposition, err);
 		    }
@@ -442,7 +442,7 @@ collation_indexer_create (const char* oid)
 		    	}
 		    }
             if (!*id) {
-                LDAPDebug(LDAP_DEBUG_ANY, LOG_ERR, "collation_indexer_create: id not found\n", 0, 0, 0);
+                LDAPDebug(LDAP_DEBUG_ERR, "collation_indexer_create - id not found\n", 0, 0, 0);
                 goto error;
             }
 
@@ -454,12 +454,12 @@ collation_indexer_create (const char* oid)
 		    /* free (etc); */
 		    /* free (ix); */
 		} else if (err == U_USING_DEFAULT_WARNING) {
-		    LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "collation_indexer_create: could not "
+		    LDAPDebug(LDAP_DEBUG_FILTER, "collation_indexer_create - could not "
 			       "create an indexer for OID %s for locale %s and could not "
 			       "use default locale\n",
 			       oid, (locale ? locale : "(default)"), NULL);
 		} else { /* error */
-		    LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "collation_indexer_create: could not "
+		    LDAPDebug(LDAP_DEBUG_FILTER, "collation_indexer_create - could not "
 			       "create an indexer for OID %s for locale %s: err = %d\n",
 			       oid, (locale ? locale : "(default)"), err);
 		}

ldap/servers/plugins/collation/config.c

@@ -83,7 +83,7 @@ fp_parse_line(
 	for ( token = strtok_quote( line, " \t" ); token != NULL;
 	    token = strtok_quote( NULL, " \t" ) ) {
 		if ( *argcp == MAXARGS ) {
-			LDAPDebug(LDAP_DEBUG_ANY, LOG_ERR, "Too many tokens (max %d)\n",
+			LDAPDebug(LDAP_DEBUG_ERR, "fp_parse_line - Too many tokens (max %d)\n",
 			    MAXARGS, 0, 0 );
 			exit( 1 );
 		}
@@ -156,13 +156,13 @@ collation_read_config( char *fname )
 
     fp = fopen( fname, "r" );
     if ( fp == NULL ) {
-	LDAPDebug(LDAP_DEBUG_ANY, LOG_ERR,
-		  "could not open config file \"%s\" - absolute path?\n",
+	LDAPDebug(LDAP_DEBUG_ERR,
+		  "collation_read_config - Could not open config file \"%s\" - absolute path?\n",
 		  fname, 0, 0 );
 	return; /* Do not exit */
     }
 
-    LDAPDebug(LDAP_DEBUG_CONFIG, LOG_DEBUG, "reading config file %s\n", fname, 0, 0 );
+    LDAPDebug(LDAP_DEBUG_CONFIG, "reading config file %s\n", fname, 0, 0 );
 
     fp_getline_init( &lineno );
     while ( (line = fp_getline( fp, &lineno )) != NULL ) {
@@ -170,11 +170,11 @@ collation_read_config( char *fname )
 	if ( line[0] == '#' || line[0] == '\0' ) {
 	    continue;
 	}
-	LDAPDebug(LDAP_DEBUG_CONFIG, LOG_DEBUG, "line %d: %s\n", lineno, line, 0 );
+	LDAPDebug(LDAP_DEBUG_CONFIG, "line %d: %s\n", lineno, line, 0 );
 	fp_parse_line( line, &cargc, cargv );
 	if ( cargc < 1 ) {
-	    LDAPDebug(LDAP_DEBUG_ANY, LOG_ERR,
-		      "%s: line %d: bad config line (ignored)\n",
+	    LDAPDebug(LDAP_DEBUG_ERR,
+		      "collation_read_config - %s: line %d: bad config line (ignored)\n",
 		      fname, lineno, 0 );
 	    continue;
 	}

ldap/servers/plugins/collation/orfilter.c

@@ -64,7 +64,7 @@ static int
 or_filter_destroy (Slapi_PBlock* pb)
 {
     auto or_filter_t* or = or_filter_get (pb);
-    LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "or_filter_destroy(%p)\n", (void*)or, 0, 0);
+    LDAPDebug(LDAP_DEBUG_FILTER, "or_filter_destroy(%p)\n", (void*)or, 0, 0);
     if (or != NULL) {
     slapi_ch_free((void**)&or->or_type);
     slapi_ch_free((void**)&or->or_oid);
@@ -473,7 +473,7 @@ or_filter_create (Slapi_PBlock* pb)
 	auto struct berval bv;
 	auto int reusable = MRF_ANY_TYPE;
 
-	LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "=> or_filter_create(oid %s; type %s)\n",
+	LDAPDebug(LDAP_DEBUG_FILTER, "=> or_filter_create(oid %s; type %s)\n",
 		   mrOID, mrTYPE, 0);
 	if (len > 1 && (ix = indexer_create (mrOID)) != NULL) {
 	    auto char* val = mrVALUE->bv_val;
@@ -535,7 +535,7 @@ or_filter_create (Slapi_PBlock* pb)
 	    {
 		auto struct berval** val = or->or_values;
 		if (val) for (; *val; ++val) {
-		    LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "value \"%s\"\n", (*val)->bv_val, 0, 0);
+		    LDAPDebug(LDAP_DEBUG_FILTER, "value \"%s\"\n", (*val)->bv_val, 0, 0);
 		}
 	    }
 	    if (or->or_op == SLAPI_OP_SUBSTRING) {
@@ -553,9 +553,9 @@ or_filter_create (Slapi_PBlock* pb)
 	    rc = LDAP_SUCCESS;
 	}
     } else {
-	LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "=> or_filter_create missing parameter(s)\n", 0, 0, 0);
+	LDAPDebug(LDAP_DEBUG_FILTER, "=> or_filter_create missing parameter(s)\n", 0, 0, 0);
     }
-    LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "<= or_filter_create(%p) %i\n", (void*)or, rc, 0);
+    LDAPDebug(LDAP_DEBUG_FILTER, "<= or_filter_create(%p) %i\n", (void*)or, rc, 0);
     return rc;
 }
 
@@ -573,7 +573,7 @@ static int
 op_indexer_destroy (Slapi_PBlock* pb)
 {
     auto indexer_t* ix = op_indexer_get (pb);
-    LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "op_indexer_destroy(%p)\n", (void*)ix, 0, 0);
+    LDAPDebug(LDAP_DEBUG_FILTER, "op_indexer_destroy(%p)\n", (void*)ix, 0, 0);
     if (ix != NULL) {
         indexer_free (ix);
         /* The keys were freed, but we need to reset the pblock pointer */
@@ -596,7 +596,7 @@ op_index_entry (Slapi_PBlock* pb)
     } else {
 	rc = LDAP_OPERATIONS_ERROR;
     }
-    LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "op_index_entry(%p) %i\n", (void*)ix, rc, 0);
+    LDAPDebug(LDAP_DEBUG_FILTER, "op_index_entry(%p) %i\n", (void*)ix, rc, 0);
     return rc;
 }
 
@@ -618,7 +618,7 @@ op_index_search (Slapi_PBlock* pb)
 	    rc = slapi_pblock_set (pb, SLAPI_PLUGIN_MR_KEYS, or->or_index_keys);
 	}
     }
-    LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "op_index_search(%p) %i\n", (void*)or, rc, 0);
+    LDAPDebug(LDAP_DEBUG_FILTER, "op_index_search(%p) %i\n", (void*)or, rc, 0);
     return rc;
 }
 
@@ -652,7 +652,7 @@ static void
 ss_indexer_destroy (Slapi_PBlock* pb)
 {
     auto ss_indexer_t* ss = ss_indexer_get (pb);
-    LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "ss_indexer_destroy(%p)\n", (void*)ss, 0, 0);
+    LDAPDebug(LDAP_DEBUG_FILTER, "ss_indexer_destroy(%p)\n", (void*)ss, 0, 0);
     if (ss) {
         ss_indexer_free(ss);
         /* The keys were freed, but we need to reset the pblock pointer */
@@ -743,7 +743,7 @@ ss_index_entry (Slapi_PBlock* pb)
 	    slapi_ch_free((void**)&prefixes);
 	}
     }
-    LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "ss_index_entry(%p) %i %lu substrings\n",
+    LDAPDebug(LDAP_DEBUG_FILTER, "ss_index_entry(%p) %i %lu substrings\n",
 	       (void*)ss, rc, (unsigned long)substringsLen);
     return rc;
 }
@@ -809,7 +809,7 @@ ss_index_search (Slapi_PBlock* pb)
 	    rc = slapi_pblock_set (pb, SLAPI_PLUGIN_MR_KEYS, or->or_index_keys);
 	}
     }
-    LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "ss_index_search(%p) %i\n", (void*)or, rc, 0);
+    LDAPDebug(LDAP_DEBUG_FILTER, "ss_index_search(%p) %i\n", (void*)or, rc, 0);
     return rc;
 }
 
@@ -884,7 +884,7 @@ or_filter_index (Slapi_PBlock* pb)
 	!(rc = slapi_pblock_set (pb, SLAPI_PLUGIN_MR_OID, mrOID))) {
 	rc = slapi_pblock_set (pb, SLAPI_PLUGIN_MR_QUERY_OPERATOR, &mrQUERY_OPERATOR);
     }
-    LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "or_filter_index(%p) %i\n",
+    LDAPDebug(LDAP_DEBUG_FILTER, "or_filter_index(%p) %i\n",
 	       (void*)(or ? or->or_indexer : NULL), rc, 0);
     return rc;
 }
@@ -896,12 +896,12 @@ or_indexer_create (Slapi_PBlock* pb)
     auto char* mrOID = NULL;
     auto void* mrOBJECT = NULL;
     if (slapi_pblock_get (pb, SLAPI_PLUGIN_MR_OID, &mrOID) || mrOID == NULL) {
-	LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "=> or_indexer_create: no OID parameter\n", 0, 0, 0);
+	LDAPDebug(LDAP_DEBUG_FILTER, "=> or_indexer_create: no OID parameter\n", 0, 0, 0);
     } else {
 	auto indexer_t* ix = indexer_create (mrOID);
 	auto char* mrTYPE = NULL;
 	slapi_pblock_get (pb, SLAPI_PLUGIN_MR_TYPE, &mrTYPE);
-	LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "=> or_indexer_create(oid %s; type %s)\n",
+	LDAPDebug(LDAP_DEBUG_FILTER, "=> or_indexer_create(oid %s; type %s)\n",
 		   mrOID, mrTYPE ? mrTYPE : "<NULL>", 0);
 	if (ix != NULL) {
 	    if (ix->ix_index != NULL &&
@@ -944,7 +944,7 @@ or_indexer_create (Slapi_PBlock* pb)
 	    }
 	}
     }
-    LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "<= or_indexer_create(%p) %i\n", mrOBJECT, rc, 0);
+    LDAPDebug(LDAP_DEBUG_FILTER, "<= or_indexer_create(%p) %i\n", mrOBJECT, rc, 0);
     return rc;
 }
 
@@ -977,8 +977,8 @@ orderingRule_init (Slapi_PBlock* pb)
 #endif 
 
     if ( slapi_pblock_get( pb, SLAPI_CONFIG_DIRECTORY, &cfgpath ) != 0 ) {
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, SLAPI_ORPLUGIN_NAME,
-		"Unable to retrieve slapd configuration pathname; using default\n" );
+	slapi_log_error(SLAPI_LOG_ERR, SLAPI_ORPLUGIN_NAME,
+		"orderingRule_init - Unable to retrieve slapd configuration pathname; using default\n" );
 	cfgpath = NULL;
     }
 	
@@ -995,6 +995,6 @@ orderingRule_init (Slapi_PBlock* pb)
     if ( rc == 0 ) {
 	rc = slapi_pblock_set( pb, SLAPI_PLUGIN_DESCRIPTION, (void *)&pdesc );
     }
-    LDAPDebug(LDAP_DEBUG_FILTER, LOG_DEBUG, "orderingRule_init %i\n", rc, 0, 0);
+    LDAPDebug(LDAP_DEBUG_FILTER, "orderingRule_init %i\n", rc, 0, 0);
     return rc;
 }

ldap/servers/plugins/cos/cos.c

@@ -33,7 +33,7 @@
 
 /*** from proto-slap.h ***/
 
-int slapd_log_error_proc( char *subsystem, int sev_level, char *fmt, ... );
+int slapd_log_error_proc( int sev_level, char *subsystem, char *fmt, ... );
 
 /*** end secrets ***/
 
@@ -103,8 +103,8 @@ cos_postop_init ( Slapi_PBlock *pb )
 		 slapi_pblock_set(pb, SLAPI_PLUGIN_POST_MODIFY_FN, (void *)cos_post_op ) != 0 ||
 		 slapi_pblock_set(pb, SLAPI_PLUGIN_POST_MODRDN_FN, (void *)cos_post_op ) != 0 )
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, COS_PLUGIN_SUBSYSTEM,
-						 "cos_postop_init: failed to register plugin\n" );
+		slapi_log_error(SLAPI_LOG_ERR, COS_PLUGIN_SUBSYSTEM,
+						 "cos_postop_init - Failed to register plugin\n" );
 		rc = -1;
 	}
 	return rc;
@@ -126,8 +126,8 @@ cos_internalpostop_init ( Slapi_PBlock *pb )
 		 slapi_pblock_set(pb, SLAPI_PLUGIN_INTERNAL_POST_DELETE_FN,
 							(void *) cos_post_op ) != 0 )
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, COS_PLUGIN_SUBSYSTEM,
-					"cos_internalpostop_init: failed to register plugin\n" );
+		slapi_log_error(SLAPI_LOG_ERR, COS_PLUGIN_SUBSYSTEM,
+					"cos_internalpostop_init - Failed to register plugin\n" );
 		rc = -1;
 	}
 	return rc;
@@ -143,7 +143,7 @@ int cos_init( Slapi_PBlock *pb )
 	int ret = 0;
 	void * plugin_identity=NULL;
 
-	LDAPDebug(LDAP_DEBUG_TRACE, LOG_DEBUG, "--> cos_init\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_TRACE, COS_PLUGIN_SUBSYSTEM, "--> cos_init\n");
 
 	/*
 	** Store the plugin identity for later use.
@@ -159,8 +159,8 @@ int cos_init( Slapi_PBlock *pb )
 		 slapi_pblock_set(pb, SLAPI_PLUGIN_CLOSE_FN, (void *) cos_close ) != 0 ||
 		 slapi_pblock_set( pb, SLAPI_PLUGIN_DESCRIPTION, (void *)&pdesc ) != 0 )
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, COS_PLUGIN_SUBSYSTEM,
-						 "cos_init: failed to register plugin\n" );
+		slapi_log_error(SLAPI_LOG_ERR, COS_PLUGIN_SUBSYSTEM,
+						 "cos_init - Failed to register plugin\n" );
 		ret = -1;
 		goto bailout;
 	}
@@ -178,7 +178,7 @@ int cos_init( Slapi_PBlock *pb )
 	                      plugin_identity);
 
 bailout:
-	LDAPDebug(LDAP_DEBUG_TRACE, LOG_DEBUG, "<-- cos_init\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_TRACE, COS_PLUGIN_SUBSYSTEM, "<-- cos_init\n");
 	return ret;
 }
 
@@ -193,22 +193,22 @@ int cos_start( Slapi_PBlock *pb )
 {
 	int ret = 0;
 
-	LDAPDebug(LDAP_DEBUG_TRACE, LOG_DEBUG, "--> cos_start\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_TRACE, COS_PLUGIN_SUBSYSTEM, "--> cos_start\n");
 
 	if( !cos_cache_init() )
 	{
-		LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "cos: ready for service\n",0,0,0);
+		slapi_log_error(SLAPI_LOG_PLUGIN, COS_PLUGIN_SUBSYSTEM, "cos_start - Ready for service\n");
 	}
 	else
 	{
 
 		/* problems we are hosed */
 		cos_cache_stop();
-		LDAPDebug(LDAP_DEBUG_ANY, LOG_ERR, "cos_start: failed to initialise\n",0,0,0);
+		slapi_log_error(SLAPI_LOG_ERR, COS_PLUGIN_SUBSYSTEM, "cos_start - Failed to initialise\n");
 		ret = -1;
 	}
 
-	LDAPDebug(LDAP_DEBUG_TRACE, LOG_DEBUG, "<-- cos_start\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_TRACE, COS_PLUGIN_SUBSYSTEM, "<-- cos_start\n");
 	return ret;
 }
 
@@ -219,11 +219,11 @@ int cos_start( Slapi_PBlock *pb )
 */
 int cos_close( Slapi_PBlock *pb )
 {
-	LDAPDebug(LDAP_DEBUG_TRACE, LOG_DEBUG, "--> cos_close\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_TRACE, COS_PLUGIN_SUBSYSTEM, "--> cos_close\n");
 
 	cos_cache_stop();
 
-	LDAPDebug(LDAP_DEBUG_TRACE, LOG_DEBUG, "<-- cos_close\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_TRACE, COS_PLUGIN_SUBSYSTEM, "<-- cos_close\n");
 
 	return 0;
 }
@@ -260,11 +260,11 @@ int cos_compute(computed_attr_context *c,char* type,Slapi_Entry *e,slapi_compute
 */
 int cos_post_op( Slapi_PBlock *pb )
 {
-	LDAPDebug(LDAP_DEBUG_TRACE, LOG_DEBUG, "--> cos_post_op\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_TRACE, COS_PLUGIN_SUBSYSTEM, "--> cos_post_op\n");
 
 	cos_cache_change_notify(pb);
 
-	LDAPDebug(LDAP_DEBUG_TRACE, LOG_DEBUG, "<-- cos_post_op\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_TRACE, COS_PLUGIN_SUBSYSTEM, "<-- cos_post_op\n");
 
 	return SLAPI_PLUGIN_SUCCESS; /* always succeed */
 }

ldap/servers/plugins/deref/deref.c

@@ -157,7 +157,7 @@ deref_init(Slapi_PBlock *pb)
     int status = 0;
     char *plugin_identity = NULL;
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, DEREF_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, DEREF_PLUGIN_SUBSYSTEM,
                     "--> deref_init\n");
 
     /* Store the plugin identity for later use.
@@ -181,8 +181,8 @@ deref_init(Slapi_PBlock *pb)
                          (void *) deref_pre_entry) != 0 ||
         deref_register_operation_extension()
         ) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, DEREF_PLUGIN_SUBSYSTEM,
-                        "deref_init: failed to register plugin\n");
+        slapi_log_error(SLAPI_LOG_ERR, DEREF_PLUGIN_SUBSYSTEM,
+                        "deref_init - Failed to register plugin\n");
         status = -1;
     }
 
@@ -190,7 +190,7 @@ deref_init(Slapi_PBlock *pb)
         slapi_register_supported_control(LDAP_CONTROL_X_DEREF, SLAPI_OPERATION_SEARCH);
     }
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, DEREF_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, DEREF_PLUGIN_SUBSYSTEM,
                     "<-- deref_init\n");
     return status;
 }
@@ -204,13 +204,13 @@ deref_init(Slapi_PBlock *pb)
 static int
 deref_start(Slapi_PBlock * pb)
 {
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, DEREF_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, DEREF_PLUGIN_SUBSYSTEM,
                     "--> deref_start\n");
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, DEREF_PLUGIN_SUBSYSTEM,
-                    "linked attributes plug-in: ready for service\n");
+    slapi_log_error(SLAPI_LOG_PLUGIN, DEREF_PLUGIN_SUBSYSTEM,
+                    "deref_start - Ready for service\n");
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, DEREF_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, DEREF_PLUGIN_SUBSYSTEM,
                     "<-- deref_start\n");
 
     return 0;
@@ -224,10 +224,10 @@ deref_start(Slapi_PBlock * pb)
 static int
 deref_close(Slapi_PBlock * pb)
 {
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, DEREF_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, DEREF_PLUGIN_SUBSYSTEM,
                     "--> deref_close\n");
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, DEREF_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, DEREF_PLUGIN_SUBSYSTEM,
                     "<-- deref_close\n");
 
     return 0;
@@ -414,7 +414,7 @@ deref_pre_search(Slapi_PBlock *pb)
     int ii;
     int iscritical = 0;
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, DEREF_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, DEREF_PLUGIN_SUBSYSTEM,
                     "--> deref_pre_search\n");
 
     /* see if the deref request control is in the list of 
@@ -424,26 +424,26 @@ deref_pre_search(Slapi_PBlock *pb)
         const LDAPControl *ctrl = reqctrls[ii];
         if (!strcmp(ctrl->ldctl_oid, LDAP_CONTROL_X_DEREF)) {
             if (derefctrl) { /* already specified */
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, DEREF_PLUGIN_SUBSYSTEM,
-                                "The dereference control was specified more than once - it must be specified only once in the search request\n");
+                slapi_log_error(SLAPI_LOG_ERR, DEREF_PLUGIN_SUBSYSTEM,
+                                "deref_pre_search - The dereference control was specified more than once - it must be specified only once in the search request\n");
                 ldapcode = LDAP_PROTOCOL_ERROR;
                 ldaperrtext = "The dereference control cannot be specified more than once";
                 derefctrl = NULL;
             } else if (!ctrl->ldctl_value.bv_len) {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, DEREF_PLUGIN_SUBSYSTEM,
-                                "No control value specified for dereference control\n");
+                slapi_log_error(SLAPI_LOG_ERR, DEREF_PLUGIN_SUBSYSTEM,
+                                "deref_pre_search - No control value specified for dereference control\n");
                 ldapcode = LDAP_PROTOCOL_ERROR;
                 ldaperrtext = "The dereference control must have a value";
                 iscritical = ctrl->ldctl_iscritical;
             } else if (!ctrl->ldctl_value.bv_val) {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, DEREF_PLUGIN_SUBSYSTEM,
-                                "No control value specified for dereference control\n");
+                slapi_log_error(SLAPI_LOG_ERR, DEREF_PLUGIN_SUBSYSTEM,
+                                "deref_pre_search - No control value specified for dereference control\n");
                 ldapcode = LDAP_PROTOCOL_ERROR;
                 ldaperrtext = "The dereference control must have a value";
                 iscritical = ctrl->ldctl_iscritical;
             } else if (!ctrl->ldctl_value.bv_val[0] || !ctrl->ldctl_value.bv_len) {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, DEREF_PLUGIN_SUBSYSTEM,
-                                "Empty control value specified for dereference control\n");
+                slapi_log_error(SLAPI_LOG_ERR, DEREF_PLUGIN_SUBSYSTEM,
+                                "deref_pre_search - Empty control value specified for dereference control\n");
                 ldapcode = LDAP_PROTOCOL_ERROR;
                 ldaperrtext = "The dereference control must have a non-empty value";
                 iscritical = ctrl->ldctl_iscritical;
@@ -457,8 +457,8 @@ deref_pre_search(Slapi_PBlock *pb)
     }
 
     if (derefctrl && incompatible) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, DEREF_PLUGIN_SUBSYSTEM,
-                        "Cannot use the dereference control and control [%s] for the same search operation\n",
+        slapi_log_error(SLAPI_LOG_ERR, DEREF_PLUGIN_SUBSYSTEM,
+                        "deref_pre_search - Cannot use the dereference control and control [%s] for the same search operation\n",
                         incompatible);
         /* not sure if this is a hard failure - the current spec says:
            The semantics of the criticality field are specified in [RFC4511].
@@ -495,8 +495,8 @@ deref_pre_search(Slapi_PBlock *pb)
         deref_set_operation_extension(pb, speclist);
     }
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, DEREF_PLUGIN_SUBSYSTEM,
-                    "<-- deref_pre_op\n");
+    slapi_log_error(SLAPI_LOG_TRACE, DEREF_PLUGIN_SUBSYSTEM,
+                    "<-- deref_pre_search\n");
 
     return ldapcode;
 }
@@ -529,8 +529,8 @@ deref_check_access(Slapi_PBlock *pb, const Slapi_Entry *ent, const char *entdn,
         /* first, check access control - see if client can read the requested attribute */
         int ret = slapi_access_allowed(pb, etest, (char *)attrname, NULL, rights);
         if (ret != LDAP_SUCCESS) {
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, DEREF_PLUGIN_SUBSYSTEM,
-                            "The client does not have permission to read attribute %s in entry %s\n",
+            slapi_log_error(SLAPI_LOG_PLUGIN, DEREF_PLUGIN_SUBSYSTEM,
+                            "deref_check_access - The client does not have permission to read attribute %s in entry %s\n",
                             attrname, slapi_entry_get_dn_const(etest));
         } else {
             slapi_ch_array_add(retattrs, (char *)attrname); /* retattrs and attrs share pointer to attrname */
@@ -589,16 +589,16 @@ deref_do_deref_attr(Slapi_PBlock *pb, BerElement *ctrlber, const char *derefdn,
         if (entries) {
             if (entries[1]) {
                 /* too many entries */
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, DEREF_PLUGIN_SUBSYSTEM,
-                                "More than one entry matching DN [%s]\n",
+                slapi_log_error(SLAPI_LOG_PLUGIN, DEREF_PLUGIN_SUBSYSTEM,
+                                "deref_do_deref_attr - More than one entry matching DN [%s]\n",
                                 derefdn);
             } else {
                 int ii;
                 int needattrvals = 1; /* need attrvals sequence? */
                 if (deref_check_access(pb, entries[0], derefdn, attrs, &retattrs,
                           (SLAPI_ACL_SEARCH|SLAPI_ACL_READ))) {
-                    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, DEREF_PLUGIN_SUBSYSTEM,
-                             "The client does not have permission to read the requested "
+                    slapi_log_error(SLAPI_LOG_PLUGIN, DEREF_PLUGIN_SUBSYSTEM,
+                             "deref_do_deref_attr - The client does not have permission to read the requested "
                              "attributes in entry %s\n", derefdn);
                 } else {
                     ber_printf(ctrlber, "{ss", derefattr, derefdn); /* begin DerefRes + derefAttr + derefVal */
@@ -615,8 +615,8 @@ deref_do_deref_attr(Slapi_PBlock *pb, BerElement *ctrlber, const char *derefdn,
 
 #if defined(USE_OLD_UNHASHED)
                         if (is_type_forbidden(retattrs[ii])) {
-                            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, DEREF_PLUGIN_SUBSYSTEM,
-                                "skip forbidden attribute [%s]\n", derefdn);
+                            slapi_log_error(SLAPI_LOG_PLUGIN, DEREF_PLUGIN_SUBSYSTEM,
+                                "deref_do_deref_attr - skip forbidden attribute [%s]\n", derefdn);
                             continue;
                         }
 #endif
@@ -663,13 +663,13 @@ deref_do_deref_attr(Slapi_PBlock *pb, BerElement *ctrlber, const char *derefdn,
                 }
             }
         } else { /* nothing */
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, DEREF_PLUGIN_SUBSYSTEM,
-                            "No entries matching [%s]\n", derefdn);
+            slapi_log_error(SLAPI_LOG_PLUGIN, DEREF_PLUGIN_SUBSYSTEM,
+                            "deref_do_deref_attr - No entries matching [%s]\n", derefdn);
         }
     } else {
         /* handle error */
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, DEREF_PLUGIN_SUBSYSTEM,
-                        "Could not read entry with DN [%s]: error %d:%s\n",
+        slapi_log_error(SLAPI_LOG_PLUGIN, DEREF_PLUGIN_SUBSYSTEM,
+                        "deref_do_deref_attr - Could not read entry with DN [%s]: error %d:%s\n",
                         derefdn, rc, ldap_err2string(rc));
     }
     slapi_free_search_results_internal(derefpb);
@@ -715,8 +715,8 @@ deref_pre_entry(Slapi_PBlock *pb)
 
         if (deref_check_access(pb, ent, NULL, attrs, &retattrs,
                                (SLAPI_ACL_SEARCH|SLAPI_ACL_READ))) {
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, DEREF_PLUGIN_SUBSYSTEM,
-                            "The client does not have permission to read attribute %s in entry %s\n",
+            slapi_log_error(SLAPI_LOG_PLUGIN, DEREF_PLUGIN_SUBSYSTEM,
+                            "deref_pre_entry - The client does not have permission to read attribute %s in entry %s\n",
                             spec->derefattr, slapi_entry_get_dn_const(ent));
             continue;
         }

ldap/servers/plugins/http/http_client.c

@@ -41,18 +41,6 @@ int slapd_log_error_proc( char *subsystem, int sev_level, char *fmt, ... );
 extern "C" {
 #endif
 
-#define LDAP_DEBUG_TRACE	0x00001		/*     1 */
-#define LDAP_DEBUG_ANY      0x04000		/* 16384 */
-#define LDAP_DEBUG_PLUGIN	0x10000		/* 65536 */
-
-/* debugging stuff */
-extern int	slapd_ldap_debug;
-#define LDAPDebug( level, sev_level, fmt, arg1, arg2, arg3 )	\
-       { \
-		if ( slapd_ldap_debug & level ) { \
-		        slapd_log_error_proc( NULL, sev_level, fmt, arg1, arg2, arg3 ); \
-	    } \
-       }
 
 #ifdef __cplusplus
 }
@@ -113,7 +101,7 @@ int http_client_version(void)
 int http_client_init(Slapi_PBlock *pb)
 {
 	int status = HTTP_SUCCESS;
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> http_client_init -- BEGIN\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM,"http_client_init - BEGIN\n");
 
 	if ( slapi_pblock_set( pb, SLAPI_PLUGIN_VERSION,
 	    	SLAPI_PLUGIN_VERSION_01 ) != 0 ||
@@ -124,20 +112,20 @@ int http_client_init(Slapi_PBlock *pb)
 		slapi_pblock_set( pb, SLAPI_PLUGIN_DESCRIPTION,
              (void *)&pdesc ) != 0 )
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
-                     "http_client_init: failed to register plugin\n" );
+		slapi_log_error(SLAPI_LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
+                     "http_client_init - Failed to register plugin\n" );
 		status = HTTP_FAILURE;
 	}
 
         /* Retrieve and save the plugin identity to later pass to
         internal operations */
         if (slapi_pblock_get(pb, SLAPI_PLUGIN_IDENTITY, &plugin_id) != 0) {
-         slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
-                        "http_client_init: Failed to retrieve SLAPI_PLUGIN_IDENTITY\n");
+         slapi_log_error(SLAPI_LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
+                        "http_client_init - Failed to retrieve SLAPI_PLUGIN_IDENTITY\n");
          return HTTP_FAILURE;
         }
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- http_client_init -- END\n",0,0,0);
+    slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "http_client_init - END\n");
     return status;
 }
 
@@ -147,7 +135,7 @@ static int http_client_start(Slapi_PBlock *pb)
 	/**
 	 * do some init work here
 	 */
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> http_client_start -- BEGIN\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM,"http_client_start - BEGIN\n");
 
 	api[0] = 0; /* reserved for api broker use, must be zero */
 	api[1] = (void *)_http_init;
@@ -158,14 +146,14 @@ static int http_client_start(Slapi_PBlock *pb)
 	api[6] = (void *)_http_post;
 
 	if( slapi_apib_register(HTTP_v1_0_GUID, api) ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
+		slapi_log_error(SLAPI_LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
                      "http_client_start: failed to register functions\n" );
 		status = HTTP_FAILURE;
 	}
 	
 	_http_init(plugin_id);
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- http_client_start -- END\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "http_client_start - END\n");
 	return status;
 }
 
@@ -175,11 +163,11 @@ static int http_client_close(Slapi_PBlock *pb)
 	/**
 	 * do cleanup 
 	 */
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> http_client_close -- BEGIN\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "http_client_close - BEGIN\n");
 
 	slapi_apib_unregister(HTTP_v1_0_GUID);
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- http_client_close -- END\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "http_client_close - END\n");
 
 	return status;
 }
@@ -189,11 +177,11 @@ static int http_client_close(Slapi_PBlock *pb)
  */
 static void _http_init(Slapi_ComponentId *plugin_id)
 {
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> _http_init -- BEGIN\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "_http_init - BEGIN\n");
 	
 	http_impl_init(plugin_id);
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- _http_init -- END\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "_http_init - END\n");
 }
 
 /**
@@ -203,11 +191,11 @@ static void _http_init(Slapi_ComponentId *plugin_id)
 static int _http_get_text(char *url, char **data, int *bytesRead)
 {
 	int status = HTTP_SUCCESS;
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> _http_get_text -- BEGIN\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "_http_get_text - BEGIN\n");
 
 	status = http_impl_get_text(url, data, bytesRead);
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- _http_get_text -- END\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "_http_get_text - END\n");
 	return status;
 }
 
@@ -218,11 +206,11 @@ static int _http_get_text(char *url, char **data, int *bytesRead)
 static int _http_get_binary(char *url, char **data, int *bytesRead)
 {
 	int status = HTTP_SUCCESS;
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> _http_get_binary -- BEGIN\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "_http_get_binary - BEGIN\n");
 
 	status = http_impl_get_binary(url, data, bytesRead);
 	
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- _http_get_binary -- END\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "_http_get_binary - END\n");
 	return status;
 }
 
@@ -233,11 +221,11 @@ static int _http_get_binary(char *url, char **data, int *bytesRead)
 static int _http_get_redirected_uri(char *url, char **data, int *bytesRead)
 {
 	int status = HTTP_SUCCESS;
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> _http_get_redirected_uri -- BEGIN\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "_http_get_redirected_uri -- BEGIN\n");
 
 	status = http_impl_get_redirected_uri(url, data, bytesRead);
 	
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- _http_get_redirected_uri -- END\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "_http_get_redirected_uri -- END\n");
 	return status;
 }
 
@@ -247,11 +235,11 @@ static int _http_get_redirected_uri(char *url, char **data, int *bytesRead)
 static int _http_post(char *url, httpheader ** httpheaderArray, char *body, char **data, int *bytesRead)
 {
 	int status = HTTP_SUCCESS;
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> _http_post -- BEGIN\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "_http_post - BEGIN\n");
 
 	status = http_impl_post(url, httpheaderArray, body, data, bytesRead);
 	
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- _http_post -- END\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "_http_post - END\n");
 	return status;
 }
 
@@ -260,10 +248,10 @@ static int _http_post(char *url, httpheader ** httpheaderArray, char *body, char
  */
 static void _http_shutdown( void )
 {
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> _http_shutdown -- BEGIN\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "_http_shutdown - BEGIN\n");
 	
 	http_impl_shutdown();
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- _http_shutdown -- END\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "_http_shutdown - END\n");
 }
 

ldap/servers/plugins/http/http_impl.c

@@ -35,7 +35,7 @@
 
 /*** from proto-slap.h ***/
 
-int slapd_log_error_proc( char *subsystem, int sev_level, char *fmt, ... );
+int slapd_log_error_proc( int loglevel, char *subsystem, char *fmt, ... );
 
 /*** from ldaplog.h ***/
 
@@ -59,10 +59,10 @@ extern "C" {
 /* debugging stuff */
 
 extern int	slapd_ldap_debug;
-#define LDAPDebug( level, sev_level, fmt, arg1, arg2, arg3 )	\
+#define LDAPDebug( level, fmt, arg1, arg2, arg3 )	\
 { \
   if ( slapd_ldap_debug & level ) { \
-    slapd_log_error_proc( NULL, sev_level, fmt, arg1, arg2, arg3 ); \
+    slapd_log_error_proc( level, NULL, fmt, arg1, arg2, arg3 ); \
   } \
 }
 
@@ -182,14 +182,14 @@ static int doRequestRetry(const char *url, httpheader **httpheaderArray, char *b
 	retrycnt = httpConfig->retryCount;
 	
 	if (retrycnt == 0) {
-		  LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "doRequestRetry: Retry Count cannot be read. Setting to default value of 3 \n", 0,0,0);
-	   	  retrycnt = 3;
+		slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "doRequestRetry - Retry Count cannot be read. Setting to default value of 3\n");
+	   	retrycnt = 3;
 	}
         status = doRequest(url, httpheaderArray, body, buf, bytesRead, reqType);
 	if (status != HTTP_IMPL_SUCCESS) {
-	       LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "doRequestRetry: Failed to perform http request \n", 0,0,0);
+		slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "doRequestRetry - Failed to perform http request \n");
        	 while (retrycnt > 0) {
-       	         LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "doRequestRetry: Retrying http request %d.\n", i,0,0);
+       		slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "doRequestRetry - Retrying http request %d.\n", i);
        	         status = doRequest(url, httpheaderArray, body, buf, bytesRead, reqType);
        	         if (status == HTTP_IMPL_SUCCESS) {
                         break;
@@ -198,8 +198,8 @@ static int doRequestRetry(const char *url, httpheader **httpheaderArray, char *b
        	         i++;
         }
         if (status != HTTP_IMPL_SUCCESS) {
-                LDAPDebug(LDAP_DEBUG_ANY, LOG_ERR, "doRequestRetry: Failed to perform http request after %d attempts.\n", i,0,0);
-	LDAPDebug(LDAP_DEBUG_ANY, LOG_ERR, "doRequestRetry:  Verify plugin URI configuration and contact Directory Administrator.\n",0,0,0);
+        	slapi_log_error(SLAPI_LOG_ERR, HTTP_PLUGIN_SUBSYSTEM, "doRequestRetry - Failed to perform http request after %d attempts.\n", i);
+        	slapi_log_error(SLAPI_LOG_ERR, HTTP_PLUGIN_SUBSYSTEM, "doRequestRetry - Verify plugin URI configuration and contact Directory Administrator.\n");
         }
 
 	}
@@ -219,19 +219,18 @@ static int doRequest(const char *url, httpheader **httpheaderArray, char *body,
 	PRInt32 http_connection_time_out = 0;
 	PRInt32 sslOn = 0;
 	
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> doRequest -- BEGIN\n",0,0,0);
-
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> url=[%s] \n",url,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "doRequest - BEGIN\n");
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "doRequest - url=[%s] \n",url);
 
 	/* Parse the URL and initialize the host, port, path */
 	if (parseURI(url, &host, &port, &path, &sslOn) == PR_FAILURE) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
+		slapi_log_error(SLAPI_LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
                      "doRequest: %s \n", HTTP_ERROR_BAD_URL);
 		status = PR_FAILURE;
 		goto bail;
 	}
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> host=[%s] port[%d] path[%s] \n",host,port,path);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "doRequest - host=[%s] port[%d] path[%s] \n",host,port,path);
 
 	/* Initialize the Net Addr */
     if (PR_StringToNetAddr(host, &addr) == PR_FAILURE) {
@@ -242,8 +241,8 @@ static int doRequest(const char *url, httpheader **httpheaderArray, char *body,
 		if (status == PR_SUCCESS) {
             PR_EnumerateHostEnt(0, &ent, (PRUint16)port, &addr);
         } else {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
-                     "doRequest: %s\n", HTTP_ERROR_NET_ADDR);
+			slapi_log_error(SLAPI_LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
+                     "doRequest - %s\n", HTTP_ERROR_NET_ADDR);
 			status = HTTP_CLIENT_ERROR_NET_ADDR;
 			goto bail;
         }
@@ -251,18 +250,18 @@ static int doRequest(const char *url, httpheader **httpheaderArray, char *body,
 		addr.inet.port = (PRUint16)port;
 	}
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> Successfully created NetAddr \n",0,0,0);
+    slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "doRequest - Successfully created NetAddr \n");
 
 	/* open a TCP connection to the server */
     fd = PR_NewTCPSocket();
     if (!fd) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
-                     "doRequest: %s\n", HTTP_ERROR_SOCKET_CREATE);
+		slapi_log_error(SLAPI_LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
+                     "doRequest - %s\n", HTTP_ERROR_SOCKET_CREATE);
         	status = HTTP_CLIENT_ERROR_SOCKET_CREATE;
 		goto bail;
     }
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> Successfully created New TCP Socket \n",0,0,0);
+    slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "doRequest - Successfully created New TCP Socket \n");
 
 	/* immediately send the response */
     setTCPNoDelay(fd);
@@ -270,16 +269,16 @@ static int doRequest(const char *url, httpheader **httpheaderArray, char *body,
     if (sslOn) {
 		fd = setupSSLSocket(fd);
 		if (fd == NULL) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
-                     	"doRequest: %s\n", HTTP_ERROR_SSLSOCKET_CREATE);
+			slapi_log_error(SLAPI_LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
+                     	"doRequest - %s\n", HTTP_ERROR_SSLSOCKET_CREATE);
         		status = HTTP_CLIENT_ERROR_SSLSOCKET_CREATE;
 			goto bail;
 		}
 	
 		if (SSL_SetURL(fd, host) != 0) {
     			errcode = PR_GetError();
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
-		     	"doRequest: SSL_SetURL -> NSPR Error code (%d) \n", errcode);
+				slapi_log_error(SLAPI_LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
+		     	"doRequest - SSL_SetURL -> NSPR Error code (%d) \n", errcode);
         		status = HTTP_CLIENT_ERROR_SSLSOCKET_CREATE;
 			goto bail;
 		}
@@ -290,43 +289,43 @@ static int doRequest(const char *url, httpheader **httpheaderArray, char *body,
 	/* connect to the host */
     if (PR_Connect(fd, &addr, PR_MillisecondsToInterval(http_connection_time_out)) == PR_FAILURE) {
     	errcode = PR_GetError();
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
-			"doRequest: %s (%s:%d) -> NSPR Error code (%d)\n",
+		slapi_log_error(SLAPI_LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
+			"doRequest - %s (%s:%d) -> NSPR Error code (%d)\n",
 			HTTP_ERROR_CONNECT_FAILED, host, addr.inet.port, errcode);
     	status = HTTP_CLIENT_ERROR_CONNECT_FAILED;
 		goto bail;
     }
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> Successfully connected to host [%s] \n",host,0,0);
+	LDAPDebug(LDAP_DEBUG_PLUGIN, "----------> Successfully connected to host [%s] \n",host,0,0);
 
 	/* send the request to the server */
 	if (reqType == HTTP_REQ_TYPE_POST) {
 		if (sendPostReq(fd, path, httpheaderArray, body) == PR_FAILURE) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
-				"doRequest-sendPostReq: %s (%s)\n", HTTP_ERROR_SEND_REQ, path);
+			slapi_log_error(SLAPI_LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
+				"doRequest - sendPostReq: %s (%s)\n", HTTP_ERROR_SEND_REQ, path);
        		status = HTTP_CLIENT_ERROR_SEND_REQ;
 			goto bail;
 		}
 	}
 	else {
 		if (sendGetReq(fd, path) == PR_FAILURE) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
-				"doRequest-sendGetReq: %s (%s)\n", HTTP_ERROR_SEND_REQ, path);
+			slapi_log_error(SLAPI_LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
+				"doRequest - sendGetReq: %s (%s)\n", HTTP_ERROR_SEND_REQ, path);
        		status = HTTP_CLIENT_ERROR_SEND_REQ;
 			goto bail;
 		}
 	}
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> Successfully sent the request [%s] \n",path,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "doRequest - Successfully sent the request [%s] \n",path);
 
 	/* read the response */
 	if (processResponse(fd, buf, bytesRead, reqType) == PR_FAILURE) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
+		slapi_log_error(SLAPI_LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
 			"doRequest: %s (%s)\n", HTTP_ERROR_BAD_RESPONSE, url);
         status = HTTP_CLIENT_ERROR_BAD_RESPONSE;
 		goto bail;
 	}
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> Successfully read the response\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "doRequest - Successfully read the response\n");
 bail:
 	if (host) {
 		PR_Free(host);
@@ -338,7 +337,7 @@ bail:
 		PR_Close(fd);
 		fd = NULL;
 	}
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- doRequest -- END\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "doRequest - END\n");
 	return status;
 }
 
@@ -368,7 +367,7 @@ static PRStatus processResponse(PRFileDesc *fd, char **resBUF, int *bytesRead, i
 	 * the HTTP_DEFAULT_BUFFER_SIZE, it will cause the server to crash. A 4k
 	 * buffer should be good enough.
 	 */
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> processResponse -- BEGIN\n",0,0,0);
+    slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "processResponse - BEGIN\n");
 
 	headers = (char *)PR_Calloc(1, 4 * HTTP_DEFAULT_BUFFER_SIZE);
     /* Get protocol string */
@@ -390,7 +389,7 @@ static PRStatus processResponse(PRFileDesc *fd, char **resBUF, int *bytesRead, i
     tmp[index] = '\0';
     protocol = PL_strdup(tmp);
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> protocol=[%s] \n",protocol,0,0);
+    slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "processResponse - protocol=[%s] \n",protocol);
 
     /* Get status num */
     index = 0;
@@ -412,7 +411,7 @@ static PRStatus processResponse(PRFileDesc *fd, char **resBUF, int *bytesRead, i
     statusNum = PL_strdup(tmp);
 	retcode=atoi(tmp);
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> statusNum=[%s] \n",statusNum,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "processResponse - statusNum=[%s] \n",statusNum);
 
 	if (HTTP_RESPONSE_REDIRECT && (reqType == HTTP_REQ_TYPE_REDIRECT)) {
 		isRedirect = PR_TRUE;
@@ -433,7 +432,7 @@ static PRStatus processResponse(PRFileDesc *fd, char **resBUF, int *bytesRead, i
 		}
 		tmp[index] = '\0';
         statusString = PL_strdup(tmp);
-		LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> statusString [%s] \n",statusString,0,0);
+        slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "processResponse - statusString [%s] \n",statusString);
     }
 
     /**
@@ -507,7 +506,7 @@ static PRStatus processResponse(PRFileDesc *fd, char **resBUF, int *bytesRead, i
 				value[index] = '\0';
 				index = 0;
 				inName = PR_TRUE;
-				LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> name=[%s] value=[%s]\n",name,value,0);
+				slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "processResponse - name=[%s] value=[%s]\n",name,value);
 				if (isRedirect && !PL_strcasecmp(name,"location")) {
 				  location = PL_strdup(value);
 				}
@@ -530,7 +529,7 @@ static PRStatus processResponse(PRFileDesc *fd, char **resBUF, int *bytesRead, i
 		*resBUF = PL_strdup(location);
 		*bytesRead = strlen(location);
 	}
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> Response Buffer=[%s] bytesRead=[%d] \n",*resBUF,*bytesRead,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "processResponse - Response Buffer=[%s] bytesRead=[%d] \n",*resBUF,*bytesRead);
 
 bail:
 
@@ -550,7 +549,7 @@ bail:
 		PL_strfree(location);
 	}
 	
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- processResponse -- END\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "processResponse - END\n");
     return status;
 }
 
@@ -602,10 +601,10 @@ static PRStatus sendFullData( PRFileDesc *fd, char *buf, int timeOut)
 	else
 	{
 		errcode = PR_GetError();
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
-			"sendFullData: dataSent=%d bufLen=%d -> NSPR Error code (%d)\n",
+		slapi_log_error(SLAPI_LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
+			"sendFullData - dataSent=%d bufLen=%d -> NSPR Error code (%d)\n",
 			dataSent, bufLen, errcode);
-		LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "---------->NSPR Error code (%d) \n", errcode,0,0);
+		slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "sendFullData - NSPR Error code (%d) \n", errcode);
 		return PR_FAILURE;
 	}
 }
@@ -675,7 +674,7 @@ static PRStatus sendPostReq(PRFileDesc *fd, const char *path, httpheader **httph
 	}
 	strcat(reqBUF, "\0");
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "---------->reqBUF is %s \n",reqBUF,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM, "sendPostRequest - reqBUF is %s \n",reqBUF);
 	http_connection_time_out = httpConfig->connectionTimeOut;
 
 	status = sendFullData( fd, reqBUF, http_connection_time_out);
@@ -693,8 +692,8 @@ static PRStatus getChar(PRFileDesc *fd, char *buf)
     PRInt32 bytesRead = http_read(fd, buf, 1);
 	if (bytesRead <=0) {
     	PRInt32 errcode = PR_GetError();
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
-			"getChar: NSPR Error code (%d)\n", errcode);
+		slapi_log_error(SLAPI_LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
+			"getChar - NSPR Error code (%d)\n", errcode);
 		return PR_FAILURE;
 	}
     return PR_SUCCESS;
@@ -963,32 +962,32 @@ PRFileDesc* setupSSLSocket(PRFileDesc* fd)
 	socketOption.option                 = PR_SockOpt_Nonblocking;
 	socketOption.value.non_blocking = PR_FALSE;
 	if( PR_SetSocketOption(fd, &socketOption) != 0) {
-        	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, HTTP_PLUGIN_SUBSYSTEM,
-			"Cannot set socket option NSS \n");
+        	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM,
+			"setupSSLSocket - Cannot set socket option NSS \n");
 		return NULL;
 	}
 
 	sslSocket = SSL_ImportFD(NULL, fd);
 	if (!sslSocket) {
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, HTTP_PLUGIN_SUBSYSTEM,
-                     "setupSSLSocket: Cannot import to SSL Socket\n" );
+                slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM,
+                     "setupSSLSocket - Cannot import to SSL Socket\n" );
 				goto sslbail;
 	}
 	
-    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
-                     "setupSSLSocket: setupssl socket created\n" );
+    slapi_log_error(SLAPI_LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
+                     "setupSSLSocket - setupssl socket created\n" );
 
 	secStatus = SSL_OptionSet(sslSocket, SSL_SECURITY, 1);
 	if (SECSuccess != secStatus) {
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, HTTP_PLUGIN_SUBSYSTEM,
-                     "setupSSLSocket: Cannot set SSL_SECURITY option\n");
+                slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM,
+                     "setupSSLSocket - Cannot set SSL_SECURITY option\n");
 				goto sslbail;
 	}
 
 	secStatus = SSL_OptionSet(sslSocket, SSL_HANDSHAKE_AS_CLIENT, 1);
 	if (SECSuccess != secStatus) {
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, HTTP_PLUGIN_SUBSYSTEM,
-                     "setupSSLSocket: CAnnot set SSL_HANDSHAKE_AS_CLIENT option\n");
+                slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM,
+                     "setupSSLSocket - CAnnot set SSL_HANDSHAKE_AS_CLIENT option\n");
 				goto sslbail;
 	}
 	
@@ -998,7 +997,7 @@ PRFileDesc* setupSSLSocket(PRFileDesc* fd)
                                   (SSLGetClientAuthData)  getClientAuthData,
                                   (void *)certNickname);
     if (secStatus != SECSuccess) {
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, HTTP_PLUGIN_SUBSYSTEM,
+                slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM,
            		"setupSSLSocket: SSL_GetClientAuthDataHook Failed\n");
     	       	goto sslbail;
     }
@@ -1007,24 +1006,24 @@ PRFileDesc* setupSSLSocket(PRFileDesc* fd)
                            (SSLAuthCertificate)   authCertificate,
                            (void *)CERT_GetDefaultCertDB());
     if (secStatus != SECSuccess) {
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, HTTP_PLUGIN_SUBSYSTEM,
-                     "setupSSLSocket: SSL_AuthCertificateHook Failed\n");
+                slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM,
+                     "setupSSLSocket - SSL_AuthCertificateHook Failed\n");
                 goto sslbail;
     }
 
 	secStatus = SSL_BadCertHook(sslSocket,
                         (SSLBadCertHandler)  badCertHandler, NULL);
     if (secStatus != SECSuccess) {
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, HTTP_PLUGIN_SUBSYSTEM,
-                     "setupSSLSocket: SSL_BadCertHook Failed\n");
+                slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM,
+                     "setupSSLSocket - SSL_BadCertHook Failed\n");
                 goto sslbail;
     }
 
     secStatus = SSL_HandshakeCallback(sslSocket,
                         (SSLHandshakeCallback)  handshakeCallback, NULL);
     if (secStatus != SECSuccess) {
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, HTTP_PLUGIN_SUBSYSTEM,
-                     "setupSSLSocket: SSL_HandshakeCallback Failed\n");
+                slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM,
+                     "setupSSLSocket - SSL_HandshakeCallback Failed\n");
                 goto sslbail;
     }
 
@@ -1036,7 +1035,7 @@ sslbail:
 }
 
 SECStatus
-  authCertificate(void *arg, PRFileDesc *socket,
+authCertificate(void *arg, PRFileDesc *socket,
                   PRBool checksig, PRBool isServer)
 {
 
@@ -1047,8 +1046,8 @@ SECStatus
     SECStatus           secStatus;
 
     if (!arg || !socket) {
-    	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, HTTP_PLUGIN_SUBSYSTEM,
-                " authCertificate: Faulty socket in callback function \n");
+    	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM,
+                "authCertificate - Faulty socket in callback function\n");
         return SECFailure;
     }
 
@@ -1087,7 +1086,7 @@ SECStatus
 }
 
 SECStatus
-  badCertHandler(void *arg, PRFileDesc *socket)
+badCertHandler(void *arg, PRFileDesc *socket)
 {
 
     SECStatus   secStatus = SECFailure;
@@ -1122,8 +1121,8 @@ SECStatus
         break;
     }
 
-       	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, HTTP_PLUGIN_SUBSYSTEM,
-        "Bad certificate: %d\n", err);
+    slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM,
+        "badCertHandler - Bad certificate: %d\n", err);
 
     return secStatus;
 }
@@ -1198,10 +1197,10 @@ SECStatus
 }
 
 SECStatus
-  handshakeCallback(PRFileDesc *socket, void *arg)
+handshakeCallback(PRFileDesc *socket, void *arg)
 {
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, HTTP_PLUGIN_SUBSYSTEM,
-    	"----------> Handshake has completed, ready to send data securely.\n");
+    slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM,
+    	"handshakeCallback - Handshake has completed, ready to send data securely.\n");
     return SECSuccess;
 }
 
@@ -1212,7 +1211,7 @@ SECStatus
 int http_impl_init(Slapi_ComponentId *plugin_id)
 {
 	int status = HTTP_IMPL_SUCCESS;
-       	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, HTTP_PLUGIN_SUBSYSTEM,
+       	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM,
 		"-> http_impl_init \n");
 	httpConfig = NULL;
 
@@ -1220,19 +1219,19 @@ int http_impl_init(Slapi_ComponentId *plugin_id)
 
 	status = readConfigLDAPurl(plugin_id, HTTP_PLUGIN_DN); 
     if (status != 0) {
-       		 slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
-                        "http_impl_start: Unable to get HTTP config information \n");
+       		 slapi_log_error(SLAPI_LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
+                        "http_impl_init - Unable to get HTTP config information \n");
         	 return HTTP_IMPL_FAILURE;
    	}
 	
 	status = readConfigLDAPurl(plugin_id, CONFIG_DN); 
     if (status != 0) {
-       		 slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
-                        "http_impl_start: Unable to get config information \n");
+       		 slapi_log_error(SLAPI_LOG_ERR, HTTP_PLUGIN_SUBSYSTEM,
+                        "http_impl_init - Unable to get config information \n");
         	 return HTTP_IMPL_FAILURE;
     }
 	
-       	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, HTTP_PLUGIN_SUBSYSTEM,
+       	slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM,
 		"<- http_impl_init \n");
 
 	return status;
@@ -1286,15 +1285,15 @@ static int readConfigLDAPurl(Slapi_ComponentId *plugin_id, char *plugindn) {
 	rc = slapi_search_internal_get_entry(sdn, NULL, &entry, plugin_id);
     	slapi_sdn_free(&sdn);
 	if (rc != LDAP_SUCCESS) {
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, HTTP_PLUGIN_SUBSYSTEM,
-                       "readConfigLDAPurl: Could not find entry %s (error %d)\n", plugindn, rc);
+            slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM,
+                       "readConfigLDAPurl - Could not find entry %s (error %d)\n", plugindn, rc);
             status = HTTP_IMPL_FAILURE;
             return status;
    	}
 	if (NULL == entry)
     	{
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, HTTP_PLUGIN_SUBSYSTEM,
-                       "readConfigLDAPurl: No entries found for <%s>\n", plugindn);
+            slapi_log_error(SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM,
+                       "readConfigLDAPurl - No entries found for <%s>\n", plugindn);
 
             status = HTTP_IMPL_FAILURE;
             return status;
@@ -1343,7 +1342,7 @@ static int parseHTTPConfigEntry(Slapi_Entry *e)
             httpConfig->connectionTimeOut = value;
     }
    	else {
-                 LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "parseHTTPConfigEntry: HTTP Connection Time Out cannot be read. Setting to default value of 5000 ms \n", 0,0,0);
+                 LDAPDebug(LDAP_DEBUG_PLUGIN, "parseHTTPConfigEntry - HTTP Connection Time Out cannot be read. Setting to default value of 5000 ms \n", 0,0,0);
                  httpConfig->connectionTimeOut = 5000;
    	}
 
@@ -1353,7 +1352,7 @@ static int parseHTTPConfigEntry(Slapi_Entry *e)
             httpConfig->readTimeOut = value;
     }
     else {
-                 LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "parseHTTPConfigEntry: HTTP Read Time Out cannot be read. Setting to default value of 5000 ms \n", 0,0,0);
+                 LDAPDebug(LDAP_DEBUG_PLUGIN, "parseHTTPConfigEntry - HTTP Read Time Out cannot be read. Setting to default value of 5000 ms \n", 0,0,0);
                  httpConfig->readTimeOut = 5000;
    	}
 	

ldap/servers/plugins/linkedattrs/fixup_task.c

@@ -71,8 +71,8 @@ linked_attrs_fixup_task_add(Slapi_PBlock *pb, Slapi_Entry *e,
 		(void *)task, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
 		PR_UNJOINABLE_THREAD, SLAPD_DEFAULT_THREAD_STACKSIZE);
 	if (thread == NULL) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-			"unable to create task thread!\n");
+		slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+			"linked_attrs_fixup_task_add - Unable to create task thread!\n");
 		*returncode = LDAP_OPERATIONS_ERROR;
 		slapi_task_finish(task, *returncode);
 		rv = SLAPI_DSE_CALLBACK_ERROR;
@@ -116,7 +116,7 @@ linked_attrs_fixup_task_thread(void *arg)
 		return; /* no task */
 	}
 	slapi_task_inc_refcount(task);
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_PLUGIN, LINK_PLUGIN_SUBSYSTEM,
 	                "linked_attrs_fixup_task_thread --> refcount incremented.\n" );
 	/* Fetch our task data from the task */
 	td = (task_data *)slapi_task_get_data(task);
@@ -128,9 +128,9 @@ linked_attrs_fixup_task_thread(void *arg)
 	slapi_task_begin(task, 1);
 	slapi_task_log_notice(task, "Linked attributes fixup task starting (link dn: \"%s\") ...\n",
 	                      td->linkdn ? td->linkdn : "");
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-	                "Syntax validate task starting (link dn: \"%s\") ...\n",
-                        td->linkdn ? td->linkdn : "");
+	slapi_log_error(SLAPI_LOG_INFO, LINK_PLUGIN_SUBSYSTEM,
+	                "linked_attrs_fixup_task_thread - Syntax validate task starting (link dn: \"%s\") ...\n",
+                    td->linkdn ? td->linkdn : "");
 
     linked_attrs_read_lock();
     main_config = linked_attrs_get_config();
@@ -147,8 +147,8 @@ linked_attrs_fixup_task_thread(void *arg)
                     found_config = 1;
                     slapi_task_log_notice(task, "Fixing up linked attribute pair (%s)\n",
                          config_entry->dn);
-                    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                         "Fixing up linked attribute pair (%s)\n", config_entry->dn);
+                    slapi_log_error(SLAPI_LOG_INFO, LINK_PLUGIN_SUBSYSTEM,
+                         "linked_attrs_fixup_task_thread - Fixing up linked attribute pair (%s)\n", config_entry->dn);
 
                     linked_attrs_fixup_links(config_entry);
                     break;
@@ -157,8 +157,8 @@ linked_attrs_fixup_task_thread(void *arg)
                 /* No config DN was supplied, so fix up all configured links. */
                 slapi_task_log_notice(task, "Fixing up linked attribute pair (%s)\n",
                         config_entry->dn);
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                       "Fixing up linked attribute pair (%s)\n", config_entry->dn);
+                slapi_log_error(SLAPI_LOG_INFO, LINK_PLUGIN_SUBSYSTEM,
+                       "linked_attrs_fixup_task_thread - Fixing up linked attribute pair (%s)\n", config_entry->dn);
 
                 linked_attrs_fixup_links(config_entry);
             }
@@ -171,8 +171,8 @@ linked_attrs_fixup_task_thread(void *arg)
     if (td->linkdn && !found_config) {
         slapi_task_log_notice(task, "Requested link config DN not found (%s)\n",
                 td->linkdn);
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                "Requested link config DN not found (%s)\n", td->linkdn);
+        slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                "linked_attrs_fixup_task_thread - Requested link config DN not found (%s)\n", td->linkdn);
     }
 
     linked_attrs_unlock();
@@ -180,14 +180,14 @@ linked_attrs_fixup_task_thread(void *arg)
 	/* Log finished message. */
 	slapi_task_log_notice(task, "Linked attributes fixup task complete.");
 	slapi_task_log_status(task, "Linked attributes fixup task complete.");
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM, "Linked attributes fixup task complete.\n");
+	slapi_log_error(SLAPI_LOG_INFO, LINK_PLUGIN_SUBSYSTEM, "linked_attrs_fixup_task_thread - Linked attributes fixup task complete.\n");
 	slapi_task_inc_progress(task);
 
 	/* this will queue the destruction of the task */
 	slapi_task_finish(task, rc);
 
 	slapi_task_dec_refcount(task);
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_PLUGIN, LINK_PLUGIN_SUBSYSTEM,
 	                "linked_attrs_fixup_task_thread <-- refcount decremented.\n");
 }
 
@@ -219,12 +219,12 @@ linked_attrs_fixup_links(struct configEntry *config)
                 fixup_pb = slapi_pblock_new();
                 slapi_pblock_set(fixup_pb, SLAPI_BACKEND, be);
                 if(slapi_back_transaction_begin(fixup_pb) != LDAP_SUCCESS){
-                    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                            "linked_attrs_fixup_links: failed to start transaction\n");
+                    slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                            "linked_attrs_fixup_links - Failed to start transaction\n");
                 }
             } else {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_fixup_links: failed to get be backend from %s\n",
+                slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_fixup_link - Failed to get be backend from %s\n",
                         config->scope);
             }
         }
@@ -276,11 +276,11 @@ linked_attrs_fixup_links(struct configEntry *config)
                     fixup_pb = slapi_pblock_new();
                     slapi_pblock_set(fixup_pb, SLAPI_BACKEND, be);
                     if(slapi_back_transaction_begin(fixup_pb) != LDAP_SUCCESS){
-                        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                        slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
                                 "linked_attrs_fixup_links: failed to start transaction\n");
                     }
                 } else {
-                    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                    slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
                             "linked_attrs_fixup_links: failed to get be backend from %s\n",
                             slapi_sdn_get_dn(config->suffix));
                 }
@@ -361,8 +361,8 @@ linked_attrs_remove_backlinks_callback(Slapi_Entry *e, void *callback_data)
     mods[0] = &mod;
     mods[1] = 0;
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                    "Removing backpointer attribute (%s) from entry (%s)\n",
+    slapi_log_error(SLAPI_LOG_PLUGIN, LINK_PLUGIN_SUBSYSTEM,
+                    "linked_attrs_remove_backlinks_callback - Removing backpointer attribute (%s) from entry (%s)\n",
                     type, slapi_sdn_get_dn(sdn));
 
     /* Perform the operation. */
@@ -436,8 +436,8 @@ linked_attrs_add_backlinks_callback(Slapi_Entry *e, void *callback_data)
         }
 
         if (perform_update) {
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                            "Adding backpointer (%s) in entry (%s)\n",
+            slapi_log_error(SLAPI_LOG_PLUGIN, LINK_PLUGIN_SUBSYSTEM,
+                            "linked_attrs_add_backlinks_callback - Adding backpointer (%s) in entry (%s)\n",
                             linkdn, targetdn);
 
             /* Perform the modify operation. */

ldap/servers/plugins/linkedattrs/linked_attrs.c

@@ -148,7 +148,7 @@ linked_attrs_init(Slapi_PBlock *pb)
     int preadd = SLAPI_PLUGIN_PRE_ADD_FN;
     int premod = SLAPI_PLUGIN_PRE_MODIFY_FN;
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "--> linked_attrs_init\n");
 
     if ((slapi_pblock_get(pb, SLAPI_PLUGIN_CONFIG_ENTRY, &plugin_entry) == 0) &&
@@ -178,8 +178,8 @@ linked_attrs_init(Slapi_PBlock *pb)
                          (void *) &pdesc) != 0 ||
         slapi_pblock_set(pb, premod, (void *) linked_attrs_mod_pre_op) != 0 ||
         slapi_pblock_set(pb, preadd, (void *) linked_attrs_add_pre_op) != 0) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_init: failed to register plugin\n");
+        slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_init - Failed to register plugin\n");
         status = -1;
     }
 
@@ -192,8 +192,8 @@ linked_attrs_init(Slapi_PBlock *pb)
                               NULL,     /* ? */
                               plugin_identity   /* access control */
         )) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_init: failed to register internalpostoperation plugin\n");
+        slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_init - Failed to register internalpostoperation plugin\n");
         status = -1;
     }
 
@@ -210,13 +210,13 @@ linked_attrs_init(Slapi_PBlock *pb)
                                   NULL,     /* ? */
                                   plugin_identity   /* access control */
         )) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                            "linked_attrs_init: failed to register postop plugin\n");
+            slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                            "linked_attrs_init - Failed to register postop plugin\n");
             status = -1;
         }
     }
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "<-- linked_attrs_init\n");
     return status;
 }
@@ -239,8 +239,8 @@ linked_attrs_internal_postop_init(Slapi_PBlock *pb)
                          (void *) linked_attrs_mod_post_op) != 0 ||
         slapi_pblock_set(pb, SLAPI_PLUGIN_INTERNAL_POST_MODRDN_FN,
                          (void *) linked_attrs_modrdn_post_op) != 0) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_internal_postop_init: failed to register plugin\n");
+        slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_internal_postop_init - Failed to register plugin\n");
         status = -1;
     }
  
@@ -271,8 +271,8 @@ linked_attrs_postop_init(Slapi_PBlock *pb)
         slapi_pblock_set(pb, delfn, (void *) linked_attrs_del_post_op) != 0 ||
         slapi_pblock_set(pb, modfn, (void *) linked_attrs_mod_post_op) != 0 ||
         slapi_pblock_set(pb, mdnfn, (void *) linked_attrs_modrdn_post_op) != 0) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_postop_init: failed to register plugin\n");
+        slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_postop_init - Failed to register plugin\n");
         status = -1;
     }
 
@@ -290,14 +290,14 @@ linked_attrs_start(Slapi_PBlock * pb)
 {
     Slapi_DN *plugindn = NULL;
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "--> linked_attrs_start\n");
 
     g_config_lock = slapi_new_rwlock();
 
     if (!g_config_lock) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_start: lock creation failed\n");
+        slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_start - Lock creation failed\n");
 
         return -1;
     }
@@ -307,8 +307,8 @@ linked_attrs_start(Slapi_PBlock * pb)
      * and store it for future use. */
     slapi_pblock_get(pb, SLAPI_TARGET_SDN, &plugindn);
     if (NULL == plugindn || 0 == slapi_sdn_get_ndn_len(plugindn)) {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_start: unable to retrieve plugin dn\n");
+        slapi_log_error(SLAPI_LOG_PLUGIN, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_start - Unable to retrieve plugin dn\n");
         return -1;
     }
 
@@ -323,8 +323,8 @@ linked_attrs_start(Slapi_PBlock * pb)
     PR_INIT_CLIST(g_managed_config_index);
 
     if (linked_attrs_load_config() != 0) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_start: unable to load plug-in configuration\n");
+        slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_start - Unable to load plug-in configuration\n");
         return -1;
     }
 
@@ -333,9 +333,9 @@ linked_attrs_start(Slapi_PBlock * pb)
      */
     slapi_plugin_task_register_handler("fixup linked attributes", linked_attrs_fixup_task_add, pb);
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                    "linked attributes plug-in: ready for service\n");
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_PLUGIN, LINK_PLUGIN_SUBSYSTEM,
+                    "linked_attrs_start: ready for service\n");
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "<-- linked_attrs_start\n");
 
     return 0;
@@ -349,7 +349,7 @@ linked_attrs_start(Slapi_PBlock * pb)
 static int
 linked_attrs_close(Slapi_PBlock * pb)
 {
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "--> linked_attrs_close\n");
 
     slapi_plugin_task_unregister_handler("fixup linked attributes", linked_attrs_fixup_task_add);
@@ -360,7 +360,7 @@ linked_attrs_close(Slapi_PBlock * pb)
     slapi_ch_free((void **)&g_link_config);
     slapi_ch_free((void **)&g_managed_config_index);
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "<-- linked_attrs_close\n");
 
     return 0;
@@ -388,7 +388,7 @@ linked_attrs_load_config(void)
     Slapi_PBlock *search_pb;
     Slapi_Entry **entries = NULL;
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "--> linked_attrs_load_config\n");
 
     /* Clear out any old config. */
@@ -427,7 +427,7 @@ linked_attrs_load_config(void)
     slapi_free_search_results_internal(search_pb);
     slapi_pblock_destroy(search_pb);
     linked_attrs_unlock();
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "<-- linked_attrs_load_config\n");
 
     return status;
@@ -453,7 +453,7 @@ linked_attrs_parse_config_entry(Slapi_Entry * e, int apply)
     int entry_added = 0;
     int ret = 0;
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "--> linked_attrs_parse_config_entry\n");
 
     /* If this is the main plug-in
@@ -473,14 +473,14 @@ linked_attrs_parse_config_entry(Slapi_Entry * e, int apply)
     if (value) {
         entry->dn = slapi_ch_strdup(value);
     } else {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_parse_config_entry: Error "
+        slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_parse_config_entry - Error "
                         "reading dn from config entry\n");
         ret = -1;
         goto bail;
     }
 
-    slapi_log_error(SLAPI_LOG_CONFIG, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_CONFIG, LINK_PLUGIN_SUBSYSTEM,
                     "----------> dn [%s]\n", entry->dn);
 
     value = slapi_entry_attr_get_charptr(e, LINK_LINK_TYPE);
@@ -502,23 +502,23 @@ linked_attrs_parse_config_entry(Slapi_Entry * e, int apply)
         /* Check if the link type's syntax is Distinguished Name.
          * We only treat this as a warning. */
         if (not_dn_syntax) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                            "linked_attrs_parse_config_entry: The %s config "
+            slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                            "linked_attrs_parse_config_entry - The %s config "
                             "setting must be set to an attribute with the "
                             "Distinguished Name syntax for linked attribute "
                             "pair \"%s\" attribute \"%s\".\n", LINK_LINK_TYPE, entry->dn, value);
         }
     } else {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_parse_config_entry: The %s config "
+        slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_parse_config_entry - The %s config "
                         "setting is required for linked attribute pair \"%s\".\n",
                         LINK_LINK_TYPE, entry->dn);
         ret = -1;
         goto bail;
     }
 
-    slapi_log_error(SLAPI_LOG_CONFIG, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                    "----------> %s [%s]\n", LINK_LINK_TYPE, entry->linktype);
+    slapi_log_error(SLAPI_LOG_CONFIG, LINK_PLUGIN_SUBSYSTEM,
+                    "linked_attrs_parse_config_entry - %s [%s]\n", LINK_LINK_TYPE, entry->linktype);
 
     value = slapi_entry_attr_get_charptr(e, LINK_MANAGED_TYPE);
     if (value) {
@@ -540,8 +540,8 @@ linked_attrs_parse_config_entry(Slapi_Entry * e, int apply)
 
         /* Ensure that the managed type is a multi-valued attribute. */
         if (single_valued) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                            "linked_attrs_parse_config_entry: The %s config "
+            slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                            "linked_attrs_parse_config_entry - The %s config "
                             "setting must be set to a multi-valued attribute "
                             "for linked attribute pair \"%s\".\n",
                             LINK_MANAGED_TYPE, entry->dn);
@@ -550,23 +550,23 @@ linked_attrs_parse_config_entry(Slapi_Entry * e, int apply)
         /* Check if the link type's syntax is Distinguished Name.
          * We only treat this as a warning. */
         } else if (not_dn_syntax) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                            "linked_attrs_parse_config_entry: The %s config "
+            slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                            "linked_attrs_parse_config_entry - The %s config "
                             "setting must be set to an attribute with the "
                             "Distinguished Name syntax for linked attribute "
                             "pair \"%s\".\n", LINK_MANAGED_TYPE, entry->dn);
         }
     } else {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_parse_config_entry: The %s config "
+        slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_parse_config_entry - The %s config "
                         "setting is required for linked attribute pair \"%s\".\n",
                         LINK_MANAGED_TYPE, entry->dn);
         ret = -1;
         goto bail;
     }
 
-    slapi_log_error(SLAPI_LOG_CONFIG, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                    "----------> %s [%s]\n", LINK_MANAGED_TYPE,
+    slapi_log_error(SLAPI_LOG_CONFIG, LINK_PLUGIN_SUBSYSTEM,
+                    "linked_attrs_parse_config_entry - %s [%s]\n", LINK_MANAGED_TYPE,
                     entry->managedtype);
 
     /* A scope is not required.  No scope means it
@@ -576,15 +576,15 @@ linked_attrs_parse_config_entry(Slapi_Entry * e, int apply)
         entry->scope = value;
     }
 
-    slapi_log_error(SLAPI_LOG_CONFIG, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_CONFIG, LINK_PLUGIN_SUBSYSTEM,
                     "----------> %s [%s]\n", LINK_SCOPE,
                     entry->scope ? entry->scope : "NULL");
 
     /* Check if config already exists for
      * the link type at the same scope. */
     if (linked_attrs_config_exists(entry)) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_parse_config_entry: A config "
+        slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_parse_config_entry - A config "
                         "entry for the link attribute %s already "
                         "exists at a scope of \"%s\".\n", entry->linktype,
                         entry->scope);
@@ -595,8 +595,8 @@ linked_attrs_parse_config_entry(Slapi_Entry * e, int apply)
     /* Check if config already exists for
      * the managed type at the same scope. */
     if (linked_attrs_config_exists_reverse(entry)) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_parse_config_entry: A config "
+        slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_parse_config_entry - A config "
                         "entry for the managed attribute %s already "
                         "exists at a scope of \"%s\".\n", entry->managedtype,
                         entry->scope);
@@ -613,8 +613,8 @@ linked_attrs_parse_config_entry(Slapi_Entry * e, int apply)
     /* Create a lock for this attribute pair. */
     entry->lock = slapi_new_mutex();
     if (!entry->lock) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_parse_config_entry: Unable to create "
+        slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_parse_config_entry - Unable to create "
                         "lock for linked attribute pair \"%s\".\n", entry->dn);
         ret = -1;
         goto bail;
@@ -631,8 +631,8 @@ linked_attrs_parse_config_entry(Slapi_Entry * e, int apply)
              * entries for the same link type together. */
             if (slapi_attr_type_cmp(config_entry->linktype, entry->linktype, 1) == 0) {
                 PR_INSERT_BEFORE(&(entry->list), list);
-                slapi_log_error(SLAPI_LOG_CONFIG, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                                "store [%s] before [%s] \n", entry->dn,
+                slapi_log_error(SLAPI_LOG_CONFIG, LINK_PLUGIN_SUBSYSTEM,
+                                "linked_attrs_parse_config_entry - store [%s] before [%s] \n", entry->dn,
                                 config_entry->dn);
 
                 /* add to managed type index */
@@ -647,8 +647,8 @@ linked_attrs_parse_config_entry(Slapi_Entry * e, int apply)
             if (g_link_config == list) {
                 /* add to tail */
                 PR_INSERT_BEFORE(&(entry->list), list);
-                slapi_log_error(SLAPI_LOG_CONFIG, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                                "store [%s] at tail\n", entry->dn);
+                slapi_log_error(SLAPI_LOG_CONFIG, LINK_PLUGIN_SUBSYSTEM,
+                                "linked_attrs_parse_config_entry - store [%s] at tail\n", entry->dn);
 
                 /* add to managed type index */
                 linked_attrs_insert_config_index(entry);
@@ -660,8 +660,8 @@ linked_attrs_parse_config_entry(Slapi_Entry * e, int apply)
     } else {
         /* first entry */
         PR_INSERT_LINK(&(entry->list), g_link_config);
-        slapi_log_error(SLAPI_LOG_CONFIG, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                        "store [%s] at head \n", entry->dn);
+        slapi_log_error(SLAPI_LOG_CONFIG, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_parse_config_entry - store [%s] at head \n", entry->dn);
 
         /* add to managed type index */
         linked_attrs_insert_config_index(entry);
@@ -673,8 +673,8 @@ linked_attrs_parse_config_entry(Slapi_Entry * e, int apply)
     if (0 == entry_added) {
         /* Don't log error if we weren't asked to apply config */
         if ((apply != 0) && (entry != NULL)) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                            "linked_attrs_parse_config_entry: Invalid config entry "
+            slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                            "linked_attrs_parse_config_entry - Invalid config entry "
                             "[%s] skipped\n", entry->dn);
         }
         linked_attrs_free_config_entry(&entry);
@@ -682,7 +682,7 @@ linked_attrs_parse_config_entry(Slapi_Entry * e, int apply)
         ret = 0;
     }
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "<-- linked_attrs_parse_config_entry\n");
 
     return ret;
@@ -716,8 +716,8 @@ linked_attrs_insert_config_index(struct configEntry *entry)
             /* See if the types match. */
             if (slapi_attr_type_cmp(config_entry->managedtype, entry->managedtype, 1) == 0) {
                 PR_INSERT_BEFORE(&(index_entry->list), list);
-                slapi_log_error(SLAPI_LOG_CONFIG, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                                "store [%s] before [%s] \n", entry->dn,
+                slapi_log_error(SLAPI_LOG_CONFIG, LINK_PLUGIN_SUBSYSTEM,
+                                "linked_attrs_insert_config_index - store [%s] before [%s] \n", entry->dn,
                                 config_entry->dn);
                 inserted = 1;
                 break;
@@ -728,16 +728,16 @@ linked_attrs_insert_config_index(struct configEntry *entry)
             if (g_managed_config_index == list) {
                 /* add to tail */
                 PR_INSERT_BEFORE(&(index_entry->list), list);
-                slapi_log_error(SLAPI_LOG_CONFIG, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                                "store [%s] at tail\n", entry->dn);
+                slapi_log_error(SLAPI_LOG_CONFIG, LINK_PLUGIN_SUBSYSTEM,
+                                "linked_attrs_insert_config_index - store [%s] at tail\n", entry->dn);
                 inserted = 1;
                 break;
             }
         }
     } else {
         /* first entry */
-        slapi_log_error(SLAPI_LOG_CONFIG, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                        "store [%s] at head \n", entry->dn);
+        slapi_log_error(SLAPI_LOG_CONFIG, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_insert_config_index - store [%s] at head \n", entry->dn);
         PR_INSERT_LINK(&(index_entry->list), g_managed_config_index);
         inserted = 1;
     }
@@ -755,8 +755,8 @@ linked_attrs_free_config_entry(struct configEntry ** entry)
         return;
 
     if (e->dn) {
-        slapi_log_error(SLAPI_LOG_CONFIG, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                        "freeing config entry [%s]\n", e->dn);
+        slapi_log_error(SLAPI_LOG_CONFIG, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_free_config_entry - freeing config entry [%s]\n", e->dn);
         slapi_ch_free_string(&e->dn);
     }
 
@@ -812,18 +812,18 @@ linked_attrs_get_dn(Slapi_PBlock * pb)
 {
     const char *dn = 0;
     Slapi_DN *sdn = NULL;
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "--> linked_attrs_get_dn\n");
 
     if (slapi_pblock_get(pb, SLAPI_TARGET_SDN, &sdn)) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_get_dn: failed to get dn of changed entry");
+        slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_get_dn - Failed to get dn of changed entry");
         goto bail;
     }
     dn = slapi_sdn_get_dn(sdn);
 
   bail:
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "<-- linked_attrs_get_dn\n");
 
     return (char *)dn;
@@ -833,10 +833,10 @@ static Slapi_DN *
 linked_attrs_get_sdn(Slapi_PBlock * pb)
 {
     Slapi_DN *sdn = 0;
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "--> linked_attrs_get_sdn\n");
     slapi_pblock_get(pb, SLAPI_TARGET_SDN, &sdn);
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "<-- linked_attrs_get_sdn\n");
 
     return sdn;
@@ -852,7 +852,7 @@ linked_attrs_dn_is_config(char *dn)
 {
     int ret = 0;
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "--> linked_attrs_dn_is_config\n");
 
     /* Return 1 if the passed in dn is a child of the main
@@ -862,7 +862,7 @@ linked_attrs_dn_is_config(char *dn)
         ret = 1;
     }
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "<-- linked_attrs_dn_is_config\n");
 
     return ret;
@@ -1140,13 +1140,13 @@ linked_attrs_oktodo(Slapi_PBlock *pb)
         int ret = 1;
         int oprc = 0;
 
-        slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+        slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                      "--> linked_attrs_oktodo\n" );
 
         if(slapi_pblock_get(pb, SLAPI_PLUGIN_OPRETURN, &oprc) != 0)
         {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_oktodo: could not get parameters\n" );
+                slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_oktodo - Could not get parameters\n" );
                 ret = -1;
         }
 
@@ -1156,7 +1156,7 @@ linked_attrs_oktodo(Slapi_PBlock *pb)
                 ret = 0;
         }
 
-        slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+        slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                      "<-- linked_attrs_oktodo\n" );
 
         return ret;
@@ -1453,8 +1453,8 @@ linked_attrs_mod_backpointers(Slapi_PBlock *pb, char *linkdn, char *type,
         }
 
         if (perform_update) {
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                            "%s backpointer (%s) in entry (%s)\n",
+            slapi_log_error(SLAPI_LOG_PLUGIN, LINK_PLUGIN_SUBSYSTEM,
+                            "linked_attrs_mod_backpointers - %s backpointer (%s) in entry (%s)\n",
                             (modop == LDAP_MOD_ADD) ? "Adding" : "Removing",
                             linkdn, targetdn);
 
@@ -1474,13 +1474,13 @@ linked_attrs_mod_backpointers(Slapi_PBlock *pb, char *linkdn, char *type,
             } else if (rc != LDAP_SUCCESS) {
                 char *err_msg = NULL;
 
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                                "Linked Attrs Plugin: Failed to update link to target entry (%s) error %d",
+                slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                                "linked_attrs_mod_backpointers - Failed to update link to target entry (%s) error %d",
                                 targetdn, rc);
-                err_msg = PR_smprintf("Linked Attrs Plugin: Failed to update "
+                err_msg = PR_smprintf("linked_attrs_mod_backpointers - Failed to update "
                                       "link to target entry (%s) error %d",
                                       targetdn, rc);
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM, "%s\n", err_msg);
+                slapi_log_error(SLAPI_LOG_PLUGIN, LINK_PLUGIN_SUBSYSTEM, "%s\n", err_msg);
                 slapi_pblock_set(pb, SLAPI_PB_RESULT_TEXT, err_msg);
                 PR_smprintf_free(err_msg);
                 slapi_sdn_free(&targetsdn);
@@ -1538,7 +1538,7 @@ linked_attrs_pre_op(Slapi_PBlock * pb, int modop)
     char *errstr = NULL;
     int ret = SLAPI_PLUGIN_SUCCESS;
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "--> linked_attrs_pre_op\n");
 
     if (0 == (dn = linked_attrs_get_dn(pb)))
@@ -1595,15 +1595,15 @@ linked_attrs_pre_op(Slapi_PBlock * pb, int modop)
         slapi_entry_free(e);
 
     if (ret) {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_pre_op: operation failure [%d]\n", ret);
+        slapi_log_error(SLAPI_LOG_PLUGIN, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_pre_op - Operation failure [%d]\n", ret);
         slapi_send_ldap_result(pb, ret, NULL, errstr, 0, NULL);
         slapi_ch_free((void **)&errstr);
         slapi_pblock_set(pb, SLAPI_RESULT_CODE, &ret);
         ret = SLAPI_PLUGIN_FAILURE;
     }
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "<-- linked_attrs_pre_op\n");
 
     return ret;
@@ -1633,7 +1633,7 @@ linked_attrs_mod_post_op(Slapi_PBlock *pb)
     void *caller_id = NULL;
     int rc = SLAPI_PLUGIN_SUCCESS;
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "--> linked_attrs_mod_post_op\n");
 
     /* We don't want to process internal modify
@@ -1702,16 +1702,16 @@ linked_attrs_mod_post_op(Slapi_PBlock *pb)
                     rc = linked_attrs_replace_backpointers(pb, dn, config, smod);
                     break;
                 default:
-                    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                                    "linked_attrs_mod_post_op: unknown mod type\n" );
+                    slapi_log_error(SLAPI_LOG_PLUGIN, LINK_PLUGIN_SUBSYSTEM,
+                                    "linked_attrs_mod_post_op - Unknown mod type\n" );
                     rc = SLAPI_PLUGIN_FAILURE;
                     break;
                 }
 
                 slapi_unlock_mutex(config->lock);
                 if(rc != LDAP_SUCCESS){
-                    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                                    "linked_attrs_mod_post_op - update failed (%d)\n",rc);
+                    slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                                    "linked_attrs_mod_post_op - Update failed (%d)\n",rc);
                     linked_attrs_unlock();
                     slapi_mod_done(next_mod);
                     break;
@@ -1733,7 +1733,7 @@ linked_attrs_mod_post_op(Slapi_PBlock *pb)
         slapi_pblock_set(pb, SLAPI_RESULT_CODE, &rc);
         rc = SLAPI_PLUGIN_FAILURE;
     }
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "<-- linked_attrs_mod_post_op (%d)\n", rc);
 
     return rc;
@@ -1746,7 +1746,7 @@ linked_attrs_add_post_op(Slapi_PBlock *pb)
     char *dn = NULL;
     int rc = SLAPI_PLUGIN_SUCCESS;
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "--> linked_attrs_add_post_op\n");
 
     /* Reload config if a config entry was added. */
@@ -1754,8 +1754,8 @@ linked_attrs_add_post_op(Slapi_PBlock *pb)
         if (linked_attrs_dn_is_config(dn))
             linked_attrs_load_config();
     } else {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_add_post_op: Error "
+        slapi_log_error(SLAPI_LOG_PLUGIN, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_add_post_op - Error "
                         "retrieving dn\n");
     }
 
@@ -1795,8 +1795,8 @@ linked_attrs_add_post_op(Slapi_PBlock *pb)
                 slapi_unlock_mutex(config->lock);
                 slapi_valueset_free(vals);
                 if(rc != LDAP_SUCCESS){
-                    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                                    "linked_attrs_add_post_op: update failed (%d)\n",rc);
+                    slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                                    "linked_attrs_add_post_op - Update failed (%d)\n",rc);
                     linked_attrs_unlock();
                     break;
                 }
@@ -1808,8 +1808,8 @@ linked_attrs_add_post_op(Slapi_PBlock *pb)
             slapi_entry_next_attr(e, attr, &attr);
         }
     } else {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_add_post_op: Error "
+        slapi_log_error(SLAPI_LOG_PLUGIN, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_add_post_op - Error "
                         "retrieving post-op entry %s\n", dn);
     }
 
@@ -1817,7 +1817,7 @@ linked_attrs_add_post_op(Slapi_PBlock *pb)
         slapi_pblock_set(pb, SLAPI_RESULT_CODE, &rc);
         rc = SLAPI_PLUGIN_FAILURE;
     }
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "<-- linked_attrs_add_post_op\n");
 
     return rc;
@@ -1830,7 +1830,7 @@ linked_attrs_del_post_op(Slapi_PBlock *pb)
     Slapi_Entry *e = NULL;
     int rc = SLAPI_PLUGIN_SUCCESS;
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "--> linked_attrs_del_post_op\n");
 
     /* Just bail if we aren't ready to service requests yet. */
@@ -1843,8 +1843,8 @@ linked_attrs_del_post_op(Slapi_PBlock *pb)
         if (linked_attrs_dn_is_config(dn))
             linked_attrs_load_config();
     } else {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_del_post_op: Error "
+        slapi_log_error(SLAPI_LOG_PLUGIN, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_del_post_op - Error "
                         "retrieving dn\n");
     }
 
@@ -1884,8 +1884,8 @@ linked_attrs_del_post_op(Slapi_PBlock *pb)
                 slapi_unlock_mutex(config->lock);
                 slapi_valueset_free(vals);
                 if (rc != LDAP_SUCCESS){
-                    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                                    "linked_attrs_del_post_op - update failed (%d)\n",rc);
+                    slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                                    "linked_attrs_del_post_op - Update failed (%d)\n",rc);
                     linked_attrs_unlock();
                     break;
                 }
@@ -1919,8 +1919,8 @@ linked_attrs_del_post_op(Slapi_PBlock *pb)
                         slapi_valueset_free(vals);
                         config = NULL;
                         if(rc != LDAP_SUCCESS){
-                            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                                            "linked_attrs_del_post_op: update failed (%d)\n",rc);
+                            slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                                            "linked_attrs_del_post_op - Update failed (%d)\n",rc);
                             linked_attrs_unlock();
                             goto bail;
                         }
@@ -1935,8 +1935,8 @@ linked_attrs_del_post_op(Slapi_PBlock *pb)
             slapi_entry_next_attr(e, attr, &attr);
         }
     } else {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_del_post_op: Error "
+        slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_del_post_op - Error "
                         "retrieving pre-op entry %s\n", dn);
         rc = SLAPI_PLUGIN_FAILURE;
     }
@@ -1946,7 +1946,7 @@ bail:
         slapi_pblock_set(pb, SLAPI_RESULT_CODE, &rc);
         rc = SLAPI_PLUGIN_FAILURE;
     }
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "<-- linked_attrs_del_post_op\n");
 
     return rc;
@@ -1963,7 +1963,7 @@ linked_attrs_modrdn_post_op(Slapi_PBlock *pb)
     struct configEntry *config = NULL;
     int rc = SLAPI_PLUGIN_SUCCESS;
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "--> linked_attrs_modrdn_post_op\n");
 
     /* Just bail if we aren't ready to service requests yet. */
@@ -1978,8 +1978,8 @@ linked_attrs_modrdn_post_op(Slapi_PBlock *pb)
     if (post_e) {
         new_dn = slapi_entry_get_ndn(post_e);
     } else {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_modrdn_post_op: Error "
+        slapi_log_error(SLAPI_LOG_PLUGIN, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_modrdn_post_op - Error "
                         "retrieving post-op entry\n");
         rc = LDAP_OPERATIONS_ERROR;
         goto done;
@@ -1989,8 +1989,8 @@ linked_attrs_modrdn_post_op(Slapi_PBlock *pb)
         if (linked_attrs_dn_is_config(old_dn) || linked_attrs_dn_is_config(new_dn))
             linked_attrs_load_config();
     } else {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
-                        "linked_attrs_modrdn_post_op: Error "
+        slapi_log_error(SLAPI_LOG_PLUGIN, LINK_PLUGIN_SUBSYSTEM,
+                        "linked_attrs_modrdn_post_op - Error "
                         "retrieving dn\n");
         rc = LDAP_OPERATIONS_ERROR;
         goto done;
@@ -2028,8 +2028,8 @@ linked_attrs_modrdn_post_op(Slapi_PBlock *pb)
             slapi_valueset_free(vals);
             config = NULL;
             if(rc != LDAP_SUCCESS){
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                                "linked_attrs_modrdn_post_op: update failed(old type) (%d)\n",rc);
+                slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                                "linked_attrs_modrdn_post_op - Update failed(old type) (%d)\n",rc);
                 linked_attrs_unlock();
                 break;
             }
@@ -2055,8 +2055,8 @@ linked_attrs_modrdn_post_op(Slapi_PBlock *pb)
             slapi_valueset_free(vals);
             config = NULL;
             if(rc != LDAP_SUCCESS){
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                                "linked_attrs_modrdn_post_op: update failed(new type) (%d)\n",rc);
+                slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                                "linked_attrs_modrdn_post_op - Update failed(new type) (%d)\n",rc);
                 linked_attrs_unlock();
                 break;
             }
@@ -2085,8 +2085,8 @@ linked_attrs_modrdn_post_op(Slapi_PBlock *pb)
                     rc = linked_attrs_mod_backpointers(pb, old_dn, config->linktype,
                                                   config->scope, LDAP_MOD_DELETE, vals);
                     if(rc != LDAP_SUCCESS){
-                        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                                       "linked_attrs_modrdn_post_op: update failed(old dn) (%d)\n",rc);
+                        slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                                       "linked_attrs_modrdn_post_op - Update failed(old dn) (%d)\n",rc);
                         slapi_unlock_mutex(config->lock);
                         slapi_valueset_free(vals);
                         linked_attrs_unlock();
@@ -2101,8 +2101,8 @@ linked_attrs_modrdn_post_op(Slapi_PBlock *pb)
                     slapi_valueset_free(vals);
                     config = NULL;
                     if(rc != LDAP_SUCCESS){
-                        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
-                                       "linked_attrs_modrdn_post_op: update failed(new dn) (%d)\n",rc);
+                        slapi_log_error(SLAPI_LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+                                       "linked_attrs_modrdn_post_op - Update failed(new dn) (%d)\n",rc);
                         linked_attrs_unlock();
                         goto done;
                     }
@@ -2118,7 +2118,7 @@ linked_attrs_modrdn_post_op(Slapi_PBlock *pb)
     }
 
 done:
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, LINK_PLUGIN_SUBSYSTEM,
                     "<-- linked_attrs_modrdn_post_op\n");
     if (rc) {
         slapi_pblock_set(pb, SLAPI_RESULT_CODE, &rc);
@@ -2172,14 +2172,14 @@ linked_attrs_dump_config_index()
 void
 linked_attrs_dump_config_entry(struct configEntry * entry)
 {
-    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
                     "<==== Linked Attribute Pair =====>\n");
-    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
                     "<---- config entry dn -----> %s\n", entry->dn);
-    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
                     "<---- link type -----------> %s\n", entry->linktype);
-    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
                     "<---- managed type --------> %s\n", entry->managedtype);
-    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, LINK_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_DEBUG, LINK_PLUGIN_SUBSYSTEM,
                     "<---- scope ---------------> %s\n", entry->scope);
 }

ldap/servers/plugins/memberof/memberof.c

@@ -172,7 +172,7 @@ memberof_postop_init(Slapi_PBlock *pb)
 	int modfn = SLAPI_PLUGIN_POST_MODIFY_FN;
 	int addfn = SLAPI_PLUGIN_POST_ADD_FN;
 
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_TRACE, MEMBEROF_PLUGIN_SUBSYSTEM,
 		"--> memberof_postop_init\n" );
 
 	/* get args */ 
@@ -227,14 +227,14 @@ memberof_postop_init(Slapi_PBlock *pb)
 			NULL,     /* ? */
 			memberof_plugin_identity   /* access control */))
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-			"memberof_postop_init failed\n" );
+		slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+			"memberof_postop_init - Failed\n" );
 		ret = -1;
 	}
 	else if (ret)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-			"memberof_postop_init failed\n" );
+		slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+			"memberof_postop_init - Failed\n" );
 		ret = -1;
 	}
 	/*
@@ -248,18 +248,18 @@ memberof_postop_init(Slapi_PBlock *pb)
 			NULL,     /* ? */
 			memberof_plugin_identity   /* access control */))
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-			"memberof_preop_init failed\n" );
+		slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+			"memberof_preop_init - Failed\n" );
 		ret = -1;
 	}
 	else if (ret)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-			"memberof_preop_init failed\n");
+		slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+			"memberof_preop_init - Failed\n");
 		ret = -1;
 	}
 
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_TRACE, MEMBEROF_PLUGIN_SUBSYSTEM,
 		"<-- memberof_postop_init\n" );
 
 	return ret;
@@ -274,8 +274,8 @@ memberof_preop_init(Slapi_PBlock *pb)
 		slapi_pblock_set(pb, SLAPI_PLUGIN_DESCRIPTION,	(void *) &pdesc) != 0 ||
 		slapi_pblock_set(pb, premodfn, (void *)memberof_shared_config_validate) != 0)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-			"memberof_internal_postop_init: failed to register plugin\n");
+		slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+			"memberof_preop_init: Failed to register plugin\n");
 		status = -1;
 	}
 
@@ -299,8 +299,8 @@ memberof_internal_postop_init(Slapi_PBlock *pb)
 			(void *) memberof_postop_modify ) != 0 ||
 		slapi_pblock_set( pb, SLAPI_PLUGIN_INTERNAL_POST_ADD_FN,
 			(void *) memberof_postop_add ) != 0) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-			"memberof_internal_postop_init: failed to register plugin\n");
+		slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+			"memberof_internal_postop_init - Failed to register plugin\n");
 		status = -1;
 	}
 
@@ -322,7 +322,7 @@ int memberof_postop_start(Slapi_PBlock *pb)
 	int result = 0;
 	int rc = 0;
 
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_TRACE, MEMBEROF_PLUGIN_SUBSYSTEM,
 		"--> memberof_postop_start\n" );
 
 	memberof_operation_lock = PR_NewMonitor();
@@ -350,8 +350,8 @@ int memberof_postop_start(Slapi_PBlock *pb)
 		if (LDAP_SUCCESS != result) {
 			if (result == LDAP_NO_SUCH_OBJECT) {
 				/* log an error and use the plugin entry for the config */
-				slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
-								"memberof_postop_start: Config entry \"%s\" does "
+				slapi_log_error(SLAPI_LOG_PLUGIN, MEMBEROF_PLUGIN_SUBSYSTEM,
+								"memberof_postop_start - Config entry \"%s\" does "
 								"not exist.\n", config_area);
 				rc = -1;
 				goto bail;
@@ -361,8 +361,8 @@ int memberof_postop_start(Slapi_PBlock *pb)
 			if(entries && entries[0]){
 				config_e = entries[0];
 			} else {
-				slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
-								"memberof_postop_start: Config entry \"%s\" was "
+				slapi_log_error(SLAPI_LOG_PLUGIN, MEMBEROF_PLUGIN_SUBSYSTEM,
+								"memberof_postop_start - Config entry \"%s\" was "
 								"not located.\n", config_area);
 				rc = -1;
 				goto bail;
@@ -371,8 +371,8 @@ int memberof_postop_start(Slapi_PBlock *pb)
 	} else {
 		/* The plugin entry itself contains the config */
 		if ( slapi_pblock_get( pb, SLAPI_ADD_ENTRY, &config_e ) != 0 ) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-							"missing config entry\n" );
+			slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+							"memberof_postop_start - Missing config entry\n" );
 			rc = -1;
 			goto bail;
 		}
@@ -380,8 +380,8 @@ int memberof_postop_start(Slapi_PBlock *pb)
 
 	memberof_set_config_area(slapi_entry_get_sdn(config_e));
 	if (( rc = memberof_config( config_e, pb )) != LDAP_SUCCESS ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-				"configuration failed (%s)\n", ldap_err2string( rc ));
+		slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+				"memberof_postop_start - Configuration failed (%s)\n", ldap_err2string( rc ));
 		rc = -1;
 		goto bail;
 	}
@@ -406,7 +406,7 @@ bail:
 	slapi_free_search_results_internal(search_pb);
 	slapi_pblock_destroy(search_pb);
 
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_TRACE, MEMBEROF_PLUGIN_SUBSYSTEM,
 		"<-- memberof_postop_start\n" );
 
 	return rc;
@@ -420,7 +420,7 @@ bail:
  */
 int memberof_postop_close(Slapi_PBlock *pb)
 {
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_TRACE, MEMBEROF_PLUGIN_SUBSYSTEM,
 		     "--> memberof_postop_close\n" );
 
 	slapi_plugin_task_unregister_handler("memberof task", memberof_task_add);
@@ -432,7 +432,7 @@ int memberof_postop_close(Slapi_PBlock *pb)
 	PR_DestroyMonitor(memberof_operation_lock);
 	memberof_operation_lock = NULL;
 
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_TRACE, MEMBEROF_PLUGIN_SUBSYSTEM,
 		     "<-- memberof_postop_close\n" );
 	return 0;
 }
@@ -496,7 +496,7 @@ int memberof_postop_del(Slapi_PBlock *pb)
 	Slapi_DN *sdn;
 	void *caller_id = NULL;
 
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_TRACE, MEMBEROF_PLUGIN_SUBSYSTEM,
 		     "--> memberof_postop_del\n" );
 
 	/* We don't want to process internal modify
@@ -529,8 +529,8 @@ int memberof_postop_del(Slapi_PBlock *pb)
 		 * membership lists of groups
 		 */
 		if((ret = memberof_del_dn_from_groups(pb, &configCopy, sdn))){
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-			                "memberof_postop_del: error deleting dn (%s) from group. Error (%d)\n",
+			slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+			                "memberof_postop_del - Error deleting dn (%s) from group. Error (%d)\n",
 			                slapi_sdn_get_dn(sdn),ret);
 			memberof_unlock();
 			goto bail;
@@ -548,8 +548,8 @@ int memberof_postop_del(Slapi_PBlock *pb)
 				if (0 == slapi_entry_attr_find(e, configCopy.groupattrs[i], &attr))
 				{
 					if((ret = memberof_del_attr_list(pb, &configCopy, sdn, attr))){
-						slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-							"memberof_postop_del: error deleting attr list - dn (%s). Error (%d)\n",
+						slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+							"memberof_postop_del - Error deleting attr list - dn (%s). Error (%d)\n",
 							slapi_sdn_get_dn(sdn),ret);
 					}
 
@@ -565,7 +565,7 @@ bail:
 		slapi_pblock_set(pb, SLAPI_RESULT_CODE, &ret);
 		ret = SLAPI_PLUGIN_FAILURE;
 	}
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_TRACE, MEMBEROF_PLUGIN_SUBSYSTEM,
 		     "<-- memberof_postop_del\n" );
 	return ret;
 }
@@ -806,7 +806,7 @@ int memberof_postop_modrdn(Slapi_PBlock *pb)
 	int ret = SLAPI_PLUGIN_SUCCESS;
 	void *caller_id = NULL;
 
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_TRACE, MEMBEROF_PLUGIN_SUBSYSTEM,
 		     "--> memberof_postop_modrdn\n" );
 
 	/* We don't want to process internal modify
@@ -866,8 +866,8 @@ int memberof_postop_modrdn(Slapi_PBlock *pb)
 					if((ret = memberof_moddn_attr_list(pb, &configCopy, pre_sdn,
 					                                   post_sdn, attr) != 0))
 					{
-						slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-							"memberof_postop_modrdn - update failed for (%s), error (%d)\n",
+						slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+							"memberof_postop_modrdn - Update failed for (%s), error (%d)\n",
 							slapi_sdn_get_dn(pre_sdn), ret);
 						break;
 					}
@@ -881,8 +881,8 @@ int memberof_postop_modrdn(Slapi_PBlock *pb)
 		if (ret == LDAP_SUCCESS && pre_sdn && post_sdn) {
 			if (!memberof_entry_in_scope(&configCopy, post_sdn)){
 				if((ret = memberof_del_dn_from_groups(pb, &configCopy, pre_sdn))){
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-						"memberof_postop_modrdn - delete dn failed for (%s), error (%d)\n",
+					slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+						"memberof_postop_modrdn - Delete dn failed for (%s), error (%d)\n",
 						slapi_sdn_get_dn(pre_sdn), ret);
 				}
 				if(ret == LDAP_SUCCESS && pre_e && configCopy.group_filter &&
@@ -896,8 +896,8 @@ int memberof_postop_modrdn(Slapi_PBlock *pb)
 					for (i = 0; configCopy.groupattrs[i] && ret == LDAP_SUCCESS; i++) {
 						if (0 == slapi_entry_attr_find(pre_e, configCopy.groupattrs[i], &attr)) {
 							if((ret = memberof_del_attr_list(pb, &configCopy, pre_sdn, attr))){
-								slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-								"memberof_postop_modrdn: error deleting attr list - dn (%s). Error (%d)\n",
+								slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+								"memberof_postop_modrdn - Error deleting attr list - dn (%s). Error (%d)\n",
 								slapi_sdn_get_dn(pre_sdn),ret);
 							}
 
@@ -907,15 +907,15 @@ int memberof_postop_modrdn(Slapi_PBlock *pb)
 				if(ret == LDAP_SUCCESS) {
 					memberof_del_dn_data del_data = {0, configCopy.memberof_attr};
 					if((ret = memberof_del_dn_type_callback(post_e, &del_data))){
-						slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-							"memberof_postop_modrdn - delete dn callback failed for (%s), error (%d)\n",
+						slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+							"memberof_postop_modrdn - Delete dn callback failed for (%s), error (%d)\n",
 							slapi_entry_get_dn(post_e), ret);
 					}
 				}
 			} else {
 				if((ret = memberof_replace_dn_from_groups(pb, &configCopy, pre_sdn, post_sdn))){
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-						"memberof_postop_modrdn - replace dn failed for (%s), error (%d)\n",
+					slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+						"memberof_postop_modrdn - Replace dn failed for (%s), error (%d)\n",
 						slapi_sdn_get_dn(pre_sdn), ret);
 				}
 			}
@@ -929,7 +929,7 @@ bail:
 		slapi_pblock_set(pb, SLAPI_RESULT_CODE, &ret);
 		ret = SLAPI_PLUGIN_FAILURE;
 	}
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_TRACE, MEMBEROF_PLUGIN_SUBSYSTEM,
 		     "<-- memberof_postop_modrdn\n" );
 	return ret;
 }
@@ -1039,7 +1039,7 @@ int memberof_postop_modify(Slapi_PBlock *pb)
 	Slapi_Mod *next_mod = 0;
 	void *caller_id = NULL;
 
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_TRACE, MEMBEROF_PLUGIN_SUBSYSTEM,
 		     "--> memberof_postop_modify\n" );
 
 	/* We don't want to process internal modify
@@ -1061,7 +1061,7 @@ int memberof_postop_modify(Slapi_PBlock *pb)
 		slapi_pblock_get(pb, SLAPI_ENTRY_POST_OP, &entry);
 		if(entry){
 			if( SLAPI_DSE_CALLBACK_ERROR == memberof_apply_config (pb, NULL, entry, &result, returntext, NULL)){
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM, "%s", returntext);
+				slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM, "%s", returntext);
 				ret = SLAPI_PLUGIN_FAILURE;
 				goto done;
 			}
@@ -1134,8 +1134,8 @@ int memberof_postop_modify(Slapi_PBlock *pb)
 					{
 						/* add group DN to targets */
 						if((ret = memberof_add_smod_list(pb, &configCopy, sdn, smod))){
-							slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-								"memberof_postop_modify: failed to add dn (%s) to target.  "
+							slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+								"memberof_postop_modify - Failed to add dn (%s) to target.  "
 								"Error (%d)\n", slapi_sdn_get_dn(sdn), ret );
 							slapi_mod_done(next_mod);
 							memberof_unlock();
@@ -1153,8 +1153,8 @@ int memberof_postop_modify(Slapi_PBlock *pb)
 						if (slapi_mod_get_num_values(smod) == 0)
 						{
 							if((ret = memberof_replace_list(pb, &configCopy, sdn))){
-								slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-									"memberof_postop_modify: failed to replace list (%s).  "
+								slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+									"memberof_postop_modify - Failed to replace list (%s).  "
 									"Error (%d)\n", slapi_sdn_get_dn(sdn), ret );
 								slapi_mod_done(next_mod);
 								memberof_unlock();
@@ -1165,7 +1165,7 @@ int memberof_postop_modify(Slapi_PBlock *pb)
 						{
 							/* remove group DN from target values in smod*/
 							if((ret = memberof_del_smod_list(pb, &configCopy, sdn, smod))){
-								slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+								slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
 									"memberof_postop_modify: failed to remove dn (%s).  "
 									"Error (%d)\n", slapi_sdn_get_dn(sdn), ret );
 								slapi_mod_done(next_mod);
@@ -1180,8 +1180,8 @@ int memberof_postop_modify(Slapi_PBlock *pb)
 					{
 						/* replace current values */
 						if((ret = memberof_replace_list(pb, &configCopy, sdn))){
-							slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-								"memberof_postop_modify: failed to replace values in  dn (%s).  "
+							slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+								"memberof_postop_modify - Failed to replace values in  dn (%s).  "
 								"Error (%d)\n", slapi_sdn_get_dn(sdn), ret );
 							slapi_mod_done(next_mod);
 							memberof_unlock();
@@ -1193,10 +1193,9 @@ int memberof_postop_modify(Slapi_PBlock *pb)
 				default:
 					{
 						slapi_log_error(
-							SLAPI_LOG_FATAL,
-							LOG_ERR,
+							SLAPI_LOG_ERR,
 							MEMBEROF_PLUGIN_SUBSYSTEM,
-							"memberof_postop_modify: unknown mod type\n" );
+							"memberof_postop_modify - Unknown mod type\n" );
 						ret = SLAPI_PLUGIN_FAILURE;
 						break;
 					}
@@ -1224,7 +1223,7 @@ done:
 		ret = SLAPI_PLUGIN_FAILURE;
 	}
 
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_TRACE, MEMBEROF_PLUGIN_SUBSYSTEM,
 		     "<-- memberof_postop_modify\n" );
 	return ret;
 }
@@ -1243,7 +1242,7 @@ int memberof_postop_add(Slapi_PBlock *pb)
 	Slapi_DN *sdn = 0;
 	void *caller_id = NULL;
 
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_TRACE, MEMBEROF_PLUGIN_SUBSYSTEM,
 		     "--> memberof_postop_add\n" );
 
 	/* We don't want to process internal modify
@@ -1290,8 +1289,8 @@ int memberof_postop_add(Slapi_PBlock *pb)
 				if(0 == slapi_entry_attr_find(e, configCopy.groupattrs[i], &attr))
 				{
 					if((ret = memberof_add_attr_list(pb, &configCopy, sdn, attr))){
-						slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-							"memberof_postop_add: failed to add dn(%s), error (%d)\n",
+						slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+							"memberof_postop_add - Failed to add dn(%s), error (%d)\n",
 							slapi_sdn_get_dn(sdn), ret);
 						break;
 					}
@@ -1309,7 +1308,7 @@ bail:
 		ret = SLAPI_PLUGIN_FAILURE;
 	}
 
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_TRACE, MEMBEROF_PLUGIN_SUBSYSTEM,
 		     "<-- memberof_postop_add\n" );
 
 	return ret;
@@ -1332,8 +1331,8 @@ int memberof_oktodo(Slapi_PBlock *pb)
 	int ret = 1;
 	int oprc = 0;
 
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
-		     "--> memberof_postop_oktodo\n" );
+	slapi_log_error(SLAPI_LOG_TRACE, MEMBEROF_PLUGIN_SUBSYSTEM,
+		     "--> memberof_oktodo\n" );
 
 	if (!slapi_plugin_running(pb)) {
 		ret = 0;
@@ -1342,8 +1341,8 @@ int memberof_oktodo(Slapi_PBlock *pb)
 
 	if(slapi_pblock_get(pb, SLAPI_PLUGIN_OPRETURN, &oprc) != 0) 
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-			"memberof_postop_oktodo: could not get parameters\n" );
+		slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+			"memberof_oktodo - Could not get parameters\n" );
 		ret = -1;
 	}
 
@@ -1354,8 +1353,8 @@ int memberof_oktodo(Slapi_PBlock *pb)
 	}
 
 bail:
-	slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
-		     "<-- memberof_postop_oktodo\n" );
+	slapi_log_error(SLAPI_LOG_TRACE, MEMBEROF_PLUGIN_SUBSYSTEM,
+		     "<-- memberof_oktodo\n" );
 
 	return ret;
 }
@@ -1469,15 +1468,15 @@ memberof_modop_one_replace_r(Slapi_PBlock *pb, MemberOfConfig *config,
 	}
 	if(to_dn_val == NULL){
 		const char *udn = op_to_sdn ? slapi_sdn_get_udn(op_to_sdn) : "";
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-			"memberof_modop_one_replace_r: failed to get DN value from "
+		slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+			"memberof_modop_one_replace_r - Failed to get DN value from "
 			"member value (%s)\n", udn);
 		goto bail;
 	}
 	if(this_dn_val == NULL){
 		const char *udn = op_this_sdn ? slapi_sdn_get_udn(op_this_sdn) : "";
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-			"memberof_modop_one_replace_r: failed to get DN value from"
+		slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+			"memberof_modop_one_replace_r - Failed to get DN value from"
 			"group (%s)\n", udn);
 		goto bail;
 	}
@@ -1486,8 +1485,8 @@ memberof_modop_one_replace_r(Slapi_PBlock *pb, MemberOfConfig *config,
 	slapi_value_set_flags(to_dn_val, SLAPI_ATTR_FLAG_NORMALIZED_CIS);
 
 	if (config == NULL) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-				"memberof_modop_one_replace_r: NULL config parameter\n");
+		slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+				"memberof_modop_one_replace_r - NULL config parameter\n");
 		goto bail;
 	}
 
@@ -1547,8 +1546,8 @@ memberof_modop_one_replace_r(Slapi_PBlock *pb, MemberOfConfig *config,
 						/* get result and log an error */
 						int res = 0;
 						slapi_pblock_get(search_pb, SLAPI_PLUGIN_INTOP_RESULT, &res);
-						slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-						"memberof_modop_one_replace_r: error searching for members: %d\n", res);
+						slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+						"memberof_modop_one_replace_r - Error searching for members: %d\n", res);
 					} else {
 						slapi_pblock_get(search_pb, SLAPI_NENTRIES, &n_entries);
 						if(n_entries > 0)
@@ -1593,8 +1592,8 @@ memberof_modop_one_replace_r(Slapi_PBlock *pb, MemberOfConfig *config,
 		op_str = "UNKNOWN";
 	}
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
-		"memberof_modop_one_replace_r: %s %s in %s\n"
+	slapi_log_error(SLAPI_LOG_PLUGIN, MEMBEROF_PLUGIN_SUBSYSTEM,
+		"memberof_modop_one_replace_r - %s %s in %s\n"
 		,op_str, op_this, op_to);
 
 	if(config->group_filter && 0 == slapi_filter_test_simple(e, config->group_filter))
@@ -1619,9 +1618,9 @@ memberof_modop_one_replace_r(Slapi_PBlock *pb, MemberOfConfig *config,
 
 				/* 	someone set up infinitely
 					recursive groups - bail out */
-				slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG,
+				slapi_log_error(SLAPI_LOG_PLUGIN,
 					MEMBEROF_PLUGIN_SUBSYSTEM,
-					"memberof_modop_one_replace_r: group recursion"
+					"memberof_modop_one_replace_r - Group recursion"
 					" detected in %s\n"
 					,op_to);
 				goto bail;
@@ -1632,9 +1631,9 @@ memberof_modop_one_replace_r(Slapi_PBlock *pb, MemberOfConfig *config,
 		}
 
 		/* do op on group */
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG,
+		slapi_log_error(SLAPI_LOG_PLUGIN,
 			MEMBEROF_PLUGIN_SUBSYSTEM,
-			"memberof_modop_one_replace_r: descending into group %s\n",
+			"memberof_modop_one_replace_r - Descending into group %s\n",
 			op_to);
 		/* Add the nested group's DN to the stack so we can detect loops later. */
 		ll = (memberofstringll*)slapi_ch_malloc(sizeof(memberofstringll));
@@ -1655,7 +1654,7 @@ memberof_modop_one_replace_r(Slapi_PBlock *pb, MemberOfConfig *config,
 		}
 
 		{
-			/* crazyness follows:
+			/* Craziness follows:
 			 * strict-aliasing doesn't like the required cast
 			 * to void for slapi_ch_free so we are made to
 			 * juggle to get a normal thing done
@@ -1676,9 +1675,9 @@ memberof_modop_one_replace_r(Slapi_PBlock *pb, MemberOfConfig *config,
 			if (this_dn_val) {
 				strval = slapi_value_get_string(this_dn_val);
 			}
-			slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG,
+			slapi_log_error(SLAPI_LOG_PLUGIN,
 				MEMBEROF_PLUGIN_SUBSYSTEM,
-				"memberof_modop_one_replace_r: not processing memberOf "
+				"memberof_modop_one_replace_r - Not processing memberOf "
 				"operations on self entry: %s\n", strval);
 			goto bail;
 		}
@@ -2075,8 +2074,8 @@ int memberof_get_groups_callback(Slapi_Entry *e, void *callback_data)
 
 	if (!groupvals || !group_norm_vals)
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
-			"memberof_get_groups_callback: NULL groupvals or group_norm_vals\n");
+		slapi_log_error(SLAPI_LOG_PLUGIN, MEMBEROF_PLUGIN_SUBSYSTEM,
+			"memberof_get_groups_callback - NULL groupvals or group_norm_vals\n");
 		rc = -1;
 		goto bail;
 
@@ -2093,8 +2092,8 @@ int memberof_get_groups_callback(Slapi_Entry *e, void *callback_data)
 		/* A recursive group caused us to find our original
 		 * entry we passed to memberof_get_groups().  We just
 		 * skip processing this entry. */
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
-			"memberof_get_groups_callback: group recursion"
+		slapi_log_error(SLAPI_LOG_PLUGIN, MEMBEROF_PLUGIN_SUBSYSTEM,
+			"memberof_get_groups_callback - Group recursion"
 			" detected in %s\n" ,group_ndn);
 		slapi_value_free(&group_ndn_val);
 		goto bail;
@@ -2112,8 +2111,8 @@ int memberof_get_groups_callback(Slapi_Entry *e, void *callback_data)
 		 * a member of a group through multiple paths.  Either
 		 * way, we can just skip processing this entry since we've
 		 * already gone through this part of the grouping hierarchy. */
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
-			"memberof_get_groups_callback: possible group recursion"
+		slapi_log_error(SLAPI_LOG_PLUGIN, MEMBEROF_PLUGIN_SUBSYSTEM,
+			"memberof_get_groups_callback - Possible group recursion"
 			" detected in %s\n" ,group_ndn);
 		slapi_value_free(&group_ndn_val);
 		goto bail;
@@ -2645,8 +2644,8 @@ void memberof_fixup_task_thread(void *arg)
 		return; /* no task */
 	}
 	slapi_task_inc_refcount(task);
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
-	                "memberof_fixup_task_thread --> refcount incremented.\n" );
+	slapi_log_error(SLAPI_LOG_PLUGIN, MEMBEROF_PLUGIN_SUBSYSTEM,
+	                "memberof_fixup_task_thread - refcount incremented.\n" );
 	/* Fetch our task data from the task */
 	td = (task_data *)slapi_task_get_data(task);
 
@@ -2656,8 +2655,8 @@ void memberof_fixup_task_thread(void *arg)
 	slapi_task_begin(task, 1);
 	slapi_task_log_notice(task, "Memberof task starts (arg: %s) ...\n", 
 	                      td->filter_str);
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-	                "Memberof task starts (arg: %s) ...\n", td->filter_str);
+	slapi_log_error(SLAPI_LOG_INFO, MEMBEROF_PLUGIN_SUBSYSTEM,
+	                "memberof_fixup_task_thread - Memberof task starts (arg: %s) ...\n", td->filter_str);
 
 	/* We need to get the config lock first.  Trying to get the
 	 * config lock after we already hold the op lock can cause
@@ -2679,12 +2678,12 @@ void memberof_fixup_task_thread(void *arg)
 			slapi_pblock_set(fixup_pb, SLAPI_BACKEND, be);
 			rc = slapi_back_transaction_begin(fixup_pb);
 			if (rc) {
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-				  "memberof_fixup_task_thread: failed to start transaction\n");
+				slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+				  "memberof_fixup_task_thread - Failed to start transaction\n");
 			}
 		} else {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-			  "memberof_fixup_task_thread: failed to get be backend from %s\n",
+			slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+			  "memberof_fixup_task_thread - Failed to get be backend from %s\n",
 			  td->dn);
 		}
 	}
@@ -2711,14 +2710,14 @@ void memberof_fixup_task_thread(void *arg)
 	slapi_task_log_notice(task, "Memberof task finished.");
 	slapi_task_log_status(task, "Memberof task finished.");
 	slapi_task_inc_progress(task);
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-	                "Memberof task finished (arg: %s) ...\n", td->filter_str);
+	slapi_log_error(SLAPI_LOG_INFO, MEMBEROF_PLUGIN_SUBSYSTEM,
+	                "memberof_fixup_task_thread - Memberof task finished (arg: %s) ...\n", td->filter_str);
 
 	/* this will queue the destruction of the task */
 	slapi_task_finish(task, rc);
 	slapi_task_dec_refcount(task);
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
-	                "memberof_fixup_task_thread <-- refcount decremented.\n");
+	slapi_log_error(SLAPI_LOG_PLUGIN, MEMBEROF_PLUGIN_SUBSYSTEM,
+	                "memberof_fixup_task_thread - refcount decremented.\n");
 }
 
 /* extract a single value from the entry (as a string) -- if it's not in the
@@ -2794,7 +2793,7 @@ int memberof_task_add(Slapi_PBlock *pb, Slapi_Entry *e,
 		PR_UNJOINABLE_THREAD, SLAPD_DEFAULT_THREAD_STACKSIZE);
 	if (thread == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+		slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
 			"unable to create task thread!\n");
 		*returncode = LDAP_OPERATIONS_ERROR;
 		slapi_task_finish(task, *returncode);
@@ -2810,7 +2809,7 @@ out:
 void
 memberof_task_destructor(Slapi_Task *task)
 {
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_PLUGIN, MEMBEROF_PLUGIN_SUBSYSTEM,
 		"memberof_task_destructor -->\n" );
 	if (task) {
 		task_data *mydata = (task_data *)slapi_task_get_data(task);
@@ -2826,7 +2825,7 @@ memberof_task_destructor(Slapi_Task *task)
 			slapi_ch_free((void **)&mydata);
 		}
 	}
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, MEMBEROF_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_PLUGIN, MEMBEROF_PLUGIN_SUBSYSTEM,
 		"memberof_task_destructor <--\n" );
 }
 
@@ -2993,8 +2992,8 @@ memberof_add_objectclass(char *auto_add_oc, const char *dn)
 
 	slapi_pblock_get(mod_pb, SLAPI_PLUGIN_INTOP_RESULT, &rc);
 	if (rc){
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-			"Failed to add objectclass (%s) to entry (%s)\n",
+		slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+			"memberof_add_objectclass - Failed to add objectclass (%s) to entry (%s)\n",
 			auto_add_oc, dn);
 	}
 	slapi_pblock_destroy(mod_pb);

ldap/servers/plugins/memberof/memberof_config.c

@@ -89,8 +89,8 @@ memberof_config(Slapi_Entry *config_e, Slapi_PBlock *pb)
 	char returntext[SLAPI_DSE_RETURNTEXT_SIZE];
 
 	if ( inited ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-				 "only one memberOf plugin instance can be used\n" );
+		slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+				 "memberof_config - Only one memberOf plugin instance can be used\n" );
 		return( LDAP_PARAM_ERROR );
 	}
 
@@ -130,9 +130,9 @@ memberof_config(Slapi_Entry *config_e, Slapi_PBlock *pb)
 	inited = 1;
 
 	if (returncode != LDAP_SUCCESS) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-				"Error %d: %s\n", returncode, returntext);
-        }
+		slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+				"memberof_config - Error %d: %s\n", returncode, returntext);
+	}
 
 	return returncode;
 }
@@ -297,7 +297,7 @@ memberof_validate_config (Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entr
 
 		rc = slapi_dn_syntax_check(pb, config_dn, 1);
 		if (rc) { /* syntax check failed */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM, "memberof_validate_config: "
+			slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM, "memberof_validate_config - "
 					"%s does not contain a valid DN (%s)\n",
 					SLAPI_PLUGIN_SHARED_CONFIG_AREA, config_dn);
 			*returncode = LDAP_INVALID_DN_SYNTAX;
@@ -481,9 +481,9 @@ memberof_apply_config (Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entry*
 			} else {
 				/* This should of been checked in preop validation */
 				PR_snprintf(returntext, SLAPI_DSE_RETURNTEXT_SIZE,
-					"memberof_apply_config: Failed to locate shared config entry (%s)",
+					"memberof_apply_config - Failed to locate shared config entry (%s)",
 					sharedcfg);
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,"%s\n",returntext);
+				slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,"%s\n",returntext);
 				*returncode = LDAP_UNWILLING_TO_PERFORM;
 				goto done;
 			}
@@ -586,8 +586,8 @@ memberof_apply_config (Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entry*
 		 */
 		if ((theConfig.group_filter = slapi_str2filter(filter_str)) == NULL)
 		{
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
-				"Unable to create the group check filter.  The memberOf "
+			slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM,
+				"memberof_apply_config - Unable to create the group check filter.  The memberOf "
 				"plug-in will not operate on changes to groups.  Please check "
 				"your %s configuration settings. (filter: %s)\n",
 				MEMBEROF_GROUP_ATTR, filter_str );
@@ -988,7 +988,7 @@ bail:
 	if (ret){
 		slapi_pblock_set(pb, SLAPI_RESULT_CODE, &ret);
 		slapi_pblock_set(pb, SLAPI_PB_RESULT_TEXT, returntext);
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM, "memberof_shared_config_validate: %s/n",
+		slapi_log_error(SLAPI_LOG_ERR, MEMBEROF_PLUGIN_SUBSYSTEM, "memberof_shared_config_validate - %s/n",
 			returntext);
 	}
 	slapi_sdn_free(&config_sdn);

ldap/servers/plugins/pam_passthru/pam_ptconfig.c

@@ -52,7 +52,7 @@ pam_passthru_load_config(int skip_validate)
     Slapi_PBlock *search_pb;
     Slapi_Entry **entries = NULL;
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
                      "=> pam_passthru_load_config\n");
 
     pam_passthru_write_lock();
@@ -100,13 +100,13 @@ pam_passthru_load_config(int skip_validate)
 
         if (skip_validate || (PAM_PASSTHRU_SUCCESS == pam_passthru_validate_config(entries[i], NULL))) {
             if (PAM_PASSTHRU_FAILURE == pam_passthru_apply_config(entries[i])) {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                                 "pam_passthru_load_config: unable to apply config "
+                slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                                 "pam_passthru_load_config - Unable to apply config "
                                  "for entry \"%s\"\n", slapi_entry_get_ndn(entries[i]));
             }
         } else {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                             "pam_passthru_load_config: skipping invalid config "
+            slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                             "pam_passthru_load_config - Skipping invalid config "
                              "entry \"%s\"\n", slapi_entry_get_ndn(entries[i]));
         }
     }
@@ -115,7 +115,7 @@ pam_passthru_load_config(int skip_validate)
     slapi_free_search_results_internal(search_pb);
     slapi_pblock_destroy(search_pb);
     pam_passthru_unlock();
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
                     "<= pam_passthru_load_config\n");
 
     return status;
@@ -279,8 +279,8 @@ parse_map_method(char *map_method, int *one, int *two, int *three, char *returnt
 						"The map method in the string [%s] is invalid: must be "
 						"one of %s", map_method, get_map_method_values());
 		} else {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-						"The map method in the string [%s] is invalid: must be "
+			slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+						"parse_map_method - The map method in the string [%s] is invalid: must be "
 						"one of %s\n", map_method, get_map_method_values());
 		}
 		err = PAM_PASSTHRU_FAILURE;
@@ -293,8 +293,8 @@ parse_map_method(char *map_method, int *one, int *two, int *three, char *returnt
 						"The map method in the string [%s] is invalid: must be "
 						"one of %s", map_method, get_map_method_values());
 		} else {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-						"The map method in the string [%s] is invalid: must be "
+			slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+						"parse_map_method - The map method in the string [%s] is invalid: must be "
 						"one of %s\n", map_method, get_map_method_values());
 		}
 		err = PAM_PASSTHRU_FAILURE;
@@ -307,8 +307,8 @@ parse_map_method(char *map_method, int *one, int *two, int *three, char *returnt
 						"The map method in the string [%s] is invalid: must be "
 						"one of %s", map_method, get_map_method_values());
 		} else {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-						"The map method in the string [%s] is invalid: must be "
+			slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+						"parse_map_method - The map method in the string [%s] is invalid: must be "
 						"one of %s\n", map_method, get_map_method_values());
 		}
 		err = PAM_PASSTHRU_FAILURE;
@@ -320,8 +320,8 @@ parse_map_method(char *map_method, int *one, int *two, int *three, char *returnt
 						"Invalid extra text [%s] after last map method",
 						((ptr && *ptr) ? *ptr : "(null)"));
 		} else {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-						"Invalid extra text [%s] after last map method\n",
+			slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+						"parse_map_method - Invalid extra text [%s] after last map method\n",
 						((ptr && *ptr) ? *ptr : "(null)"));
 		}
 		err = PAM_PASSTHRU_FAILURE;
@@ -337,14 +337,14 @@ print_suffixes(void)
 {
 	void *cookie = NULL;
 	Slapi_DN *sdn = NULL;
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-					"The following is the list of valid suffixes to use with "
+	slapi_log_error(SLAPI_LOG_INFO, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+					"print_suffixes - The following is the list of valid suffixes to use with "
 					PAMPT_EXCLUDES_ATTR " and " PAMPT_INCLUDES_ATTR ":\n");
 	for (sdn = slapi_get_first_suffix(&cookie, 1);
 		 sdn && cookie;
 		 sdn = slapi_get_next_suffix(&cookie, 1)) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-						"\t%s\n", slapi_sdn_get_dn(sdn));
+		slapi_log_error(SLAPI_LOG_INFO, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+						"print_suffixes -\t%s\n", slapi_sdn_get_dn(sdn));
 	}
 }
 
@@ -376,8 +376,8 @@ pam_passthru_validate_config (Slapi_Entry* e, char *returntext)
 					"Error: valid values for %s are %s",
 					PAMPT_MISSING_SUFFIX_ATTR, get_missing_suffix_values());
 		} else {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-					"Error: valid values for %s are %s\n",
+			slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+					"pam_passthru_validate_config - Valid values for %s are %s\n",
 					PAMPT_MISSING_SUFFIX_ATTR, get_missing_suffix_values());
 		}
 		goto done;
@@ -422,8 +422,8 @@ pam_passthru_validate_config (Slapi_Entry* e, char *returntext)
 					}
 				}
 			} else {
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-							"The suffixes listed in %s or %s are not present in "
+				slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+							"pam_passthru_validate_config - The suffixes listed in %s or %s are not present in "
 							"this server\n", PAMPT_EXCLUDES_ATTR, PAMPT_INCLUDES_ATTR);
 			}
 
@@ -432,8 +432,8 @@ pam_passthru_validate_config (Slapi_Entry* e, char *returntext)
 			print_suffixes();
 			if (missing_suffix != PAMPT_MISSING_SUFFIX_ERROR) {
 				if (returntext) {
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-									"Warning: %s\n", returntext);
+					slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+									"pam_passthru_validate_config - Warning: %s\n", returntext);
 					*returntext = 0; /* log error, don't report back to user */
 				}
 			} else {
@@ -458,8 +458,8 @@ pam_passthru_validate_config (Slapi_Entry* e, char *returntext)
 							" was specified, but no %s was given",
 							PAMPT_MAP_METHOD_ENTRY_STRING, PAMPT_PAM_IDENT_ATTR);
 			} else {
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-							"Error: the %s method was specified, but no %s was given\n",
+				slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+							"pam_passthru_validate_config - The %s method was specified, but no %s was given\n",
 							PAMPT_MAP_METHOD_ENTRY_STRING, PAMPT_PAM_IDENT_ATTR);
 			}
 			rc = PAM_PASSTHRU_FAILURE;
@@ -472,8 +472,8 @@ pam_passthru_validate_config (Slapi_Entry* e, char *returntext)
 							" specified for %s, should be one or more of %s",
 							PAMPT_MAP_METHOD_ATTR, get_map_method_values());
 			} else {
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-							"Error: no method(s) specified for %s, should be "
+				slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+							"pam_passthru_validate_config - No method(s) specified for %s, should be "
 							"one or more of %s\n", PAMPT_MAP_METHOD_ATTR,
 							get_map_method_values());
 			}
@@ -492,8 +492,8 @@ pam_passthru_validate_config (Slapi_Entry* e, char *returntext)
 							"filter specified for %s (filter: \"%s\")",
 							PAMPT_FILTER_ATTR, pam_filter_str);
 			} else {
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-							"Error: invalid filter specified for %s "
+				slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+							"pam_passthru_validate_config - Invalid filter specified for %s "
 							"(filter: \"%s\")\n", PAMPT_FILTER_ATTR,
 							pam_filter_str);
 			}
@@ -658,8 +658,8 @@ pam_passthru_apply_config (Slapi_Entry* e)
             if (pam_passthru_global_config == list) {
                 /* add to tail */
                 PR_INSERT_BEFORE(&(entry->list), list);
-                slapi_log_error(SLAPI_LOG_CONFIG, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                                "store [%s] at tail\n", entry->dn);
+                slapi_log_error(SLAPI_LOG_CONFIG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                                "pam_passthru_apply_config - store [%s] at tail\n", entry->dn);
                 inserted = 1;
                 break;
             }
@@ -667,8 +667,8 @@ pam_passthru_apply_config (Slapi_Entry* e)
     } else {
         /* first entry */
         PR_INSERT_LINK(&(entry->list), pam_passthru_global_config);
-        slapi_log_error(SLAPI_LOG_CONFIG, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                        "store [%s] at head \n", entry->dn);
+        slapi_log_error(SLAPI_LOG_CONFIG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                        "pam_passthru_apply_config - store [%s] at head \n", entry->dn);
         inserted = 1;
     }
 

ldap/servers/plugins/pam_passthru/pam_ptimpl.c

@@ -87,18 +87,18 @@ derive_from_bind_entry(Slapi_PBlock *pb, const Slapi_DN *bindsdn,
 											 pam_passthruauth_get_plugin_identity());
 
 	if (rc != LDAP_SUCCESS) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-						"Could not find BIND dn %s (error %d - %s)\n",
+		slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+						"derive_from_bind_entry - Could not find BIND dn %s (error %d - %s)\n",
 						slapi_sdn_get_ndn(bindsdn), rc, ldap_err2string(rc));
 		init_my_str_buf(pam_id, NULL);
    	} else if (NULL == entry) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-						"Could not find entry for BIND dn %s\n",
+		slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+						"derive_from_bind_entry - Could not find entry for BIND dn %s\n",
 						slapi_sdn_get_ndn(bindsdn));
 		init_my_str_buf(pam_id, NULL);
 	} else if (slapi_check_account_lock( pb, entry, 0, 0, 0 ) == 1) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-						"Account %s inactivated.\n",
+		slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+						"derive_from_bind_entry - Account %s inactivated.\n",
 						slapi_sdn_get_ndn(bindsdn));
 		init_my_str_buf(pam_id, NULL);
 		*locked = 1;
@@ -117,8 +117,8 @@ static void
 report_pam_error(char *str, int rc, pam_handle_t *pam_handle)
 {
 	if (rc != PAM_SUCCESS) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-						"Error from PAM %s (%d: %s)\n",
+		slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+						"report_pam_error - %s (%d: %s)\n",
 						str, rc, pam_strerror(pam_handle, rc));
 	}
 }
@@ -168,8 +168,8 @@ pam_conv_func(int num_msg, const struct pam_message **msg, struct pam_response *
 										  sizeof(struct pam_response));
 	slapi_pblock_get( my_data->pb, SLAPI_BIND_CREDENTIALS, &creds ); /* the password */
 	for (ii = 0; ii < num_msg; ++ii) {
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-						"pam msg [%d] = %d %s\n", ii, msg[ii]->msg_style,
+		slapi_log_error(SLAPI_LOG_PLUGIN, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+						"pam_conv_func - pam msg [%d] = %d %s\n", ii, msg[ii]->msg_style,
 						msg[ii]->msg);
 		/* hard to tell what prompt is for . . . */
 		/* assume prompts for password are either BINARY or ECHO_OFF */
@@ -182,14 +182,14 @@ pam_conv_func(int num_msg, const struct pam_message **msg, struct pam_response *
 		} else if (msg[ii]->msg_style == PAM_PROMPT_ECHO_ON) { /* assume username */
 			reply[ii].resp = slapi_ch_strdup(my_data->pam_identity);
 		} else if (msg[ii]->msg_style == PAM_ERROR_MSG) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-							"pam msg [%d] error [%s]\n", ii, msg[ii]->msg);
+			slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+							"pam_conv_func - pam msg [%d] error [%s]\n", ii, msg[ii]->msg);
 		} else if (msg[ii]->msg_style == PAM_TEXT_INFO) {
-			slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-							"pam msg [%d] text info [%s]\n", ii, msg[ii]->msg);
+			slapi_log_error(SLAPI_LOG_PLUGIN, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+							"pam_conv_func - pam msg [%d] text info [%s]\n", ii, msg[ii]->msg);
 		} else {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-							"Error: unknown pam message type (%d: %s)\n",
+			slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+							"pam_conv_func - Error: unknown pam message type (%d: %s)\n",
 							msg[ii]->msg_style, msg[ii]->msg);
 			ret = PAM_CONV_ERR;
 		}
@@ -370,8 +370,8 @@ done:
 	}
 
 	if (retcode != LDAP_SUCCESS) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-						"%s\n", errmsg);
+		slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+						"do_one_pam_auth - %s\n", errmsg);
 		if (final_method && !fallback) {
 			slapi_send_ldap_result(pb, retcode, NULL, errmsg, 0, NULL);
 		}

ldap/servers/plugins/pam_passthru/pam_ptpreop.c

@@ -92,7 +92,7 @@ pam_passthruauth_init( Slapi_PBlock *pb )
 
     PAM_PASSTHRU_ASSERT( pb != NULL );
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
                      "=> pam_passthruauth_init\n" );
 
     slapi_pblock_get (pb, SLAPI_PLUGIN_IDENTITY, &pam_passthruauth_plugin_identity);
@@ -121,8 +121,8 @@ pam_passthruauth_init( Slapi_PBlock *pb )
              slapi_pblock_set( pb, premod, (void *)pam_passthru_mod_preop ) ||
              slapi_pblock_set( pb, predel, (void *)pam_passthru_del_preop ) ||
              slapi_pblock_set( pb, premdn, (void *)pam_passthru_modrdn_preop )) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                             "pam_passthruauth_init failed\n");
+            slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                             "pam_passthruauth_init - Failed\n");
             status = -1;
             goto bail;
         }
@@ -136,9 +136,9 @@ pam_passthruauth_init( Slapi_PBlock *pb )
                                   NULL,     /* ? */
                                   pam_passthruauth_plugin_identity   /* access control */
             )) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                            "pam_passthruauth_init: "
-                            "failed to register preop plugin\n");
+            slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                            "pam_passthruauth_init - "
+                            "Failed to register preop plugin\n");
             status = -1;
             goto bail;
         }
@@ -156,8 +156,8 @@ pam_passthruauth_init( Slapi_PBlock *pb )
              slapi_pblock_set( pb, premod, (void *)pam_passthru_mod_preop ) ||
              slapi_pblock_set( pb, predel, (void *)pam_passthru_del_preop ) ||
              slapi_pblock_set( pb, premdn, (void *)pam_passthru_modrdn_preop )) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                             "pam_passthruauth_init failed\n");
+            slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                             "pam_passthruauth_init - Failed\n");
             status = -1;
             goto bail;
        }
@@ -171,9 +171,9 @@ pam_passthruauth_init( Slapi_PBlock *pb )
                                   NULL,     /* ? */
                                   pam_passthruauth_plugin_identity   /* access control */
         )) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                            "pam_passthruauth_init: "
-                            "failed to register internal postop plugin\n");
+            slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                            "pam_passthruauth_init - "
+                            "Failed to register internal postop plugin\n");
             status = -1;
             goto bail;
         }
@@ -188,15 +188,15 @@ pam_passthruauth_init( Slapi_PBlock *pb )
                               NULL,     /* ? */
                               pam_passthruauth_plugin_identity   /* access control */
     )) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                        "pam_passthruauth_init: "
-                        "failed to register (%s) plugin\n",
+        slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                        "pam_passthruauth_init - "
+                        "Failed to register (%s) plugin\n",
                         is_betxn ? "postoperation" : "betxnpostoperation");
         status = -1;
         goto bail;
     }
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
                      "<= pam_passthruauth_init\n" );
 
 bail:
@@ -214,8 +214,8 @@ pam_passthru_preop_init(Slapi_PBlock *pb)
     if ( slapi_pblock_set( pb, SLAPI_PLUGIN_PRE_BIND_FN,
                            (void *)pam_passthru_bindpreop ) ||
          slapi_pblock_set( pb, SLAPI_PLUGIN_CLOSE_FN, (void *)pam_passthru_bindpreop_close )) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                         "pam_passthruauth_preop_init failed\n");
+        slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                         "pam_passthru_preop_init - Failed\n");
         status = -1;
     }
     return status;
@@ -238,7 +238,7 @@ pam_passthru_internal_postop_init(Slapi_PBlock *pb)
                          (void *) pam_passthru_postop) != 0 ||
         slapi_pblock_set(pb, SLAPI_PLUGIN_INTERNAL_POST_MODRDN_FN,
                          (void *) pam_passthru_postop) != 0) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+        slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
                         "pam_passthru_internal_postop_init: failed to register plugin\n");
         status = -1;
     }
@@ -277,9 +277,9 @@ pam_passthru_postop_init(Slapi_PBlock *pb)
         slapi_pblock_set(pb, postdel, (void *) pam_passthru_postop) ||
         slapi_pblock_set(pb, postmod, (void *) pam_passthru_postop) ||
         slapi_pblock_set(pb, postmdn, (void *) pam_passthru_postop) ) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                        "pam_passthru_postop_init: "
-                        "failed to register (%s) plugin\n",
+        slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                        "pam_passthru_postop_init - "
+                        "Failed to register (%s) plugin\n",
                         is_betxn ? "betxn postop" : "postop");
         status = -1;
     }
@@ -300,14 +300,14 @@ pam_passthru_bindpreop_start( Slapi_PBlock *pb )
 
     PAM_PASSTHRU_ASSERT( pb != NULL );
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
                      "=> pam_passthru_bindpreop_start\n" );
 
     /* Get the plug-in configuration DN and store it for later use. */
     slapi_pblock_get(pb, SLAPI_TARGET_SDN, &pluginsdn);
     if (NULL == pluginsdn || 0 == slapi_sdn_get_ndn_len(pluginsdn)) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                        "pam_passthru_bindpreop_start: unable to determine plug-in config dn\n");
+        slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                        "pam_passthru_bindpreop_start - Unable to determine plug-in config dn\n");
         rc = PAM_PASSTHRU_FAILURE;
         goto done;
     }
@@ -323,16 +323,16 @@ pam_passthru_bindpreop_start( Slapi_PBlock *pb )
         pam_passthru_set_config_area(slapi_sdn_dup(pluginsdn));
     }
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                    "pam_passthru_bindpreop_start: config at %s\n",
+    slapi_log_error(SLAPI_LOG_PLUGIN, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                    "pam_passthru_bindpreop_start - Config at %s\n",
                     slapi_sdn_get_ndn(pam_passthru_get_config_area()));
 
     /* Create the lock that protects the config . */
     g_pam_config_lock = slapi_new_rwlock();
 
     if (!g_pam_config_lock) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                         "pam_passthru_bindpreop_start: lock creation failed\n");
+        slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                         "pam_passthru_bindpreop_start - Lock creation failed\n");
         rc = PAM_PASSTHRU_FAILURE;
         goto done;
     }
@@ -346,8 +346,8 @@ pam_passthru_bindpreop_start( Slapi_PBlock *pb )
     pam_passthru_load_config(0 /* don't skip validation */);
 
     if (( rc = pam_passthru_pam_init()) != LDAP_SUCCESS ) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                         "could not initialize PAM subsystem (%d)\n", rc);
+        slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                         "pam_passthru_bindpreop_start - Could not initialize PAM subsystem (%d)\n", rc);
         rc =  PAM_PASSTHRU_FAILURE;
         goto done;
     }
@@ -359,11 +359,11 @@ done:
         g_pam_config_lock = NULL;
         slapi_ch_free((void **)&pam_passthru_global_config);
     } else {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                         "pam_passthru: ready for service\n" );
+        slapi_log_error(SLAPI_LOG_PLUGIN, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                         "pam_passthru_bindpreop_start - Ready for service\n" );
     }
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
                      "<= pam_passthru_bindpreop_start\n" );
 
     return( rc );
@@ -378,7 +378,7 @@ pam_passthru_bindpreop_close( Slapi_PBlock *pb )
 {
     PAM_PASSTHRU_ASSERT( pb != NULL );
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
                      "=> pam_passthru_bindpreop_close\n" );
 
     pam_passthru_delete_config();
@@ -391,7 +391,7 @@ pam_passthru_bindpreop_close( Slapi_PBlock *pb )
     slapi_destroy_rwlock(g_pam_config_lock);
     g_pam_config_lock = NULL;
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
                      "<= pam_passthru_bindpreop_close\n" );
 
     return( 0 );
@@ -412,7 +412,7 @@ pam_passthru_bindpreop( Slapi_PBlock *pb )
 
     PAM_PASSTHRU_ASSERT( pb != NULL );
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
                      "=> pam_passthru_bindpreop\n" );
 
     /*
@@ -421,8 +421,8 @@ pam_passthru_bindpreop( Slapi_PBlock *pb )
     if ( slapi_pblock_get( pb, SLAPI_BIND_METHOD, &method ) != 0 ||
             slapi_pblock_get( pb, SLAPI_BIND_TARGET_SDN, &bindsdn ) != 0 ||
             slapi_pblock_get( pb, SLAPI_BIND_CREDENTIALS, &creds ) != 0 ) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                         "<= not handled (unable to retrieve bind parameters)\n" );
+        slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                         "pam_passthru_bindpreop - not handled (unable to retrieve bind parameters)\n" );
         return retcode;
     }
     normbinddn = slapi_sdn_get_dn(bindsdn);
@@ -433,8 +433,8 @@ pam_passthru_bindpreop( Slapi_PBlock *pb )
      */
     if ((method != LDAP_AUTH_SIMPLE) || (*normbinddn == '\0') ||
         (creds->bv_len == 0)) {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                         "<= not handled (not simple bind or NULL dn/credentials)\n" );
+        slapi_log_error(SLAPI_LOG_PLUGIN, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                         "pam_passthru_bindpreop - Not handled (not simple bind or NULL dn/credentials)\n" );
         return retcode;
     }
 
@@ -451,8 +451,8 @@ pam_passthru_bindpreop( Slapi_PBlock *pb )
     cfg = pam_passthru_get_config(bindsdn);
 
     if (!cfg) {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                         "<= \"%s\" not handled (doesn't meet configuration criteria)\n", normbinddn );
+        slapi_log_error(SLAPI_LOG_PLUGIN, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                "pam_passthru_bindpreop - \"%s\" Not handled (doesn't meet configuration criteria)\n", normbinddn );
         goto done;
     }
 
@@ -460,8 +460,8 @@ pam_passthru_bindpreop( Slapi_PBlock *pb )
         int is_ssl = 0;
         slapi_pblock_get(pb, SLAPI_CONN_IS_SSL_SESSION, &is_ssl);
         if (!is_ssl) {
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                             "<= connection not secure (secure connection required; check config)");
+            slapi_log_error(SLAPI_LOG_PLUGIN, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                    "pam_passthru_bindpreop - Connection not secure (secure connection required; check config)\n");
             goto done;
         }
     }
@@ -484,8 +484,8 @@ pam_passthru_bindpreop( Slapi_PBlock *pb )
             slapi_ch_free_string(&ndn);
             rc = LDAP_OPERATIONS_ERROR;
             errmsg = "unable to set connection DN or AUTHTYPE";
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                            "%s\n", errmsg);
+            slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                            "pam_passthru_bindpreop - %s\n", errmsg);
         } else {
             LDAPControl **reqctrls = NULL;
             slapi_pblock_get(pb, SLAPI_REQCONTROLS, &reqctrls);
@@ -508,10 +508,10 @@ pam_passthru_bindpreop( Slapi_PBlock *pb )
 done:
     pam_passthru_unlock();
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                    "<= handled (error %d - %s)\n", rc, ldap_err2string(rc));
+    slapi_log_error(SLAPI_LOG_PLUGIN, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                    "pam_passthru_bindpreop - handled (error %d - %s)\n", rc, ldap_err2string(rc));
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
                      "<= pam_passthru_bindpreop\n" );
 
     return retcode;
@@ -530,7 +530,7 @@ pam_passthru_preop(Slapi_PBlock *pb, int modtype)
     char returntext[SLAPI_DSE_RETURNTEXT_SIZE];
     int ret = SLAPI_PLUGIN_SUCCESS;
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
                     "=> pam_passthru_preop\n");
 
     /* Get the target SDN. */
@@ -595,7 +595,7 @@ bail:
         slapi_send_ldap_result(pb, ret, NULL, returntext, 0, NULL);
         ret = SLAPI_PLUGIN_FAILURE;
     }
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
                     "<= pam_passthru_preop\n");
 
     return ret;
@@ -638,7 +638,7 @@ pam_passthru_postop(Slapi_PBlock *pb)
     int optype = SLAPI_OPERATION_NONE;
     int oprc = -1;
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
                     "=> pam_passthru_postop\n");
 
     /* Make sure the operation succeeded and bail if it didn't. */
@@ -651,8 +651,8 @@ pam_passthru_postop(Slapi_PBlock *pb)
     /* Get the target SDN. */
     slapi_pblock_get(pb, SLAPI_TARGET_SDN, &sdn);
     if (!sdn) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                        "pam_passthru_postop: unale to fetch target SDN.\n");
+        slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                        "pam_passthru_postop - Unable to fetch target SDN.\n");
         ret = SLAPI_PLUGIN_FAILURE;
         goto bail;
     }
@@ -665,8 +665,8 @@ pam_passthru_postop(Slapi_PBlock *pb)
         if (e) {
             new_sdn = slapi_entry_get_sdn(e);
         } else {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
-                            "pam_passthru_postop: unable to fetch post-op "
+            slapi_log_error(SLAPI_LOG_ERR, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+                            "pam_passthru_postop - Unable to fetch post-op "
                             "entry for rename operation.\n");
             ret = SLAPI_PLUGIN_FAILURE;
             goto bail;
@@ -680,7 +680,7 @@ pam_passthru_postop(Slapi_PBlock *pb)
         pam_passthru_load_config(1); /* skip validation, as it was done at preop */
     }
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_TRACE, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
                     "<= pam_passthru_postop\n");
 
 bail:

ldap/servers/plugins/passthru/ptbind.c

@@ -56,7 +56,7 @@ passthru_simple_bind_s( Slapi_PBlock *pb, PassThruServer *srvr, int tries,
 	 * check to see if operation has been abandoned...
 	 */
 	if ( slapi_op_abandoned( pb )) {
-	    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+	    slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
 		    "operation abandoned\n" );
 	    rc = LDAP_USER_CANCELLED;
 	} else {

ldap/servers/plugins/passthru/ptconfig.c

@@ -80,8 +80,8 @@ passthru_config( int argc, char **argv )
     int			ret = LDAP_SUCCESS;
 
     if ( inited ) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
-                "only one pass through plugin instance can be used\n" );
+        slapi_log_error(SLAPI_LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
+                "passthru_config - Only one pass through plugin instance can be used\n" );
         ret = LDAP_PARAM_ERROR;
         goto error;
     }
@@ -93,8 +93,8 @@ passthru_config( int argc, char **argv )
      * providing at least one remote server.  Return an error if attempted.
      */
     if ( argc < 1 ) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
-                "no pass through servers found in configuration "
+        slapi_log_error(SLAPI_LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
+                "passthru_config - No pass through servers found in configuration "
                 "(at least one must be listed)\n" );
         ret = LDAP_PARAM_ERROR;
         goto error;
@@ -153,8 +153,8 @@ passthru_config( int argc, char **argv )
                          &srvr->ptsrvr_maxconcurrency, &tosecs, &srvr->ptsrvr_ldapversion,
                          &srvr->ptsrvr_connlifetime, &starttls);
             if ( rc < 4 ) {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
-                        "server parameters should be in the form "
+                slapi_log_error(SLAPI_LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
+                        "passthru_config - Server parameters should be in the form "
                         "\"maxconnections,maxconcurrency,timeout,ldapversion,"
                         "connlifetime\" (got \"%s\")\n", p );
                 ret = LDAP_PARAM_ERROR;
@@ -172,24 +172,24 @@ passthru_config( int argc, char **argv )
             }
 
             if ( srvr->ptsrvr_ldapversion != LDAP_VERSION2 && srvr->ptsrvr_ldapversion != LDAP_VERSION3 ) {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
-                        "LDAP protocol version should be %d or %d (got %d)\n",
+                slapi_log_error(SLAPI_LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
+                        "passthru_config - LDAP protocol version should be %d or %d (got %d)\n",
                         LDAP_VERSION2, LDAP_VERSION3, srvr->ptsrvr_ldapversion );
                 ret = LDAP_PARAM_ERROR;
                 goto error;
             }
 
             if ( srvr->ptsrvr_maxconnections <= 0 ) {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
-                        "maximum connections must be greater than "
+                slapi_log_error(SLAPI_LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
+                        "passthru_config - Maximum connections must be greater than "
                         "zero (got %d)\n", srvr->ptsrvr_maxconnections );
                 ret = LDAP_PARAM_ERROR;
                 goto error;
             }
 
             if ( srvr->ptsrvr_maxconcurrency <= 0 ) {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
-                        "maximum concurrency must be greater than "
+                slapi_log_error(SLAPI_LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
+                        "passthru_config - Maximum concurrency must be greater than "
                         "zero (got %d)\n", srvr->ptsrvr_maxconcurrency );
                 ret = LDAP_PARAM_ERROR;
                 goto error;
@@ -207,16 +207,16 @@ passthru_config( int argc, char **argv )
          * parse the LDAP URL
          */
         if (( rc = slapi_ldap_url_parse( srvr->ptsrvr_url, &ludp, 1, &secure )) != 0 ) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
-                    "unable to parse LDAP URL \"%s\" (%s)\n",
+            slapi_log_error(SLAPI_LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
+                    "passthru_config - Unable to parse LDAP URL \"%s\" (%s)\n",
                     srvr->ptsrvr_url, slapi_urlparse_err2string( rc ));
             ret = LDAP_PARAM_ERROR;
             goto error;
         }
 
         if ( ludp->lud_dn == NULL || *ludp->lud_dn == '\0' ) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
-                    "missing suffix in LDAP URL \"%s\"\n", srvr->ptsrvr_url );
+            slapi_log_error(SLAPI_LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
+                    "passthru_config - Missing suffix in LDAP URL \"%s\"\n", srvr->ptsrvr_url );
             ret = LDAP_PARAM_ERROR;
             goto error;
         }
@@ -241,8 +241,8 @@ passthru_config( int argc, char **argv )
          * split the DN into multiple suffixes (separated by ';')
          */
         if (( suffixarray = slapi_str2charray( ludp->lud_dn, ";" )) == NULL ) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
-                    "unable to parse suffix string \"%s\" within \"%s\"\n",
+            slapi_log_error(SLAPI_LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
+                    "passthru_config - Unable to parse suffix string \"%s\" within \"%s\"\n",
                     ludp->lud_dn, srvr->ptsrvr_url );
             ret = LDAP_PARAM_ERROR;
             goto error;
@@ -304,7 +304,7 @@ passthru_config( int argc, char **argv )
         /*
          * log configuration for debugging purposes
          */
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+        slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
                 "PTA server host: \"%s\", port: %d, secure: %d, "
                 "maxconnections: %d, maxconcurrency: %d, timeout: %d, "
                 "ldversion: %d, connlifetime: %d\n",
@@ -317,7 +317,7 @@ passthru_config( int argc, char **argv )
         for ( prevsuffix = srvr->ptsrvr_suffixes; prevsuffix != NULL;
               prevsuffix = prevsuffix->ptsuffix_next )
         {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
+            slapi_log_error(SLAPI_LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
                     "   normalized suffix: \"%s\"\n", prevsuffix->ptsuffix_normsuffix );
         }
 #endif

ldap/servers/plugins/passthru/ptconn.c

@@ -128,7 +128,7 @@ passthru_get_connection( PassThruServer *srvr, LDAP **ldp )
     slapi_lock_mutex( srvr->ptsrvr_connlist_mutex );
     rc = LDAP_SUCCESS;		/* optimistic */
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
 	"=> passthru_get_connection server %s:%d conns: %d maxconns: %d\n",
 	srvr->ptsrvr_hostname, srvr->ptsrvr_port, srvr->ptsrvr_connlist_count,
 	srvr->ptsrvr_maxconnections );
@@ -143,7 +143,7 @@ passthru_get_connection( PassThruServer *srvr, LDAP **ldp )
 	    if ( conn->ptconn_status == PASSTHRU_CONNSTATUS_OK
 		    && conn->ptconn_usecount < srvr->ptsrvr_maxconcurrency ) {
 #ifdef PASSTHRU_VERBOSE_LOGGING
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+		slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
 			"<= passthru_get_connection server found "
 			"conn 0x%x to use)\n", conn->ptconn_ld );
 #endif
@@ -160,7 +160,7 @@ passthru_get_connection( PassThruServer *srvr, LDAP **ldp )
 	    if (( ld = slapi_ldap_init( srvr->ptsrvr_hostname,
 		    srvr->ptsrvr_port, srvr->ptsrvr_secure, 1 )) == NULL ) {
 #ifdef PASSTHRU_VERBOSE_LOGGING
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+		slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
 			"<= passthru_get_connection slapi_ldap_init failed\n" );
 #endif
 		rc = LDAP_LOCAL_ERROR;
@@ -195,7 +195,7 @@ passthru_get_connection( PassThruServer *srvr, LDAP **ldp )
 	    ++srvr->ptsrvr_connlist_count;
 
 #ifdef PASSTHRU_VERBOSE_LOGGING
-	    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+	    slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
 		    "<= passthru_get_connection added new conn 0x%x, "
 		    "conn count now %d\n", ld, srvr->ptsrvr_connlist_count );
 #endif
@@ -203,13 +203,13 @@ passthru_get_connection( PassThruServer *srvr, LDAP **ldp )
 	}
 
 #ifdef PASSTHRU_VERBOSE_LOGGING
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+	slapi_log_error(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 );
 
 #ifdef PASSTHRU_VERBOSE_LOGGING
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
 		"... passthru_get_connection awake again\n" );
 #endif
     }
@@ -218,11 +218,11 @@ unlock_and_return:
     if ( conn != NULL ) {
 	++conn->ptconn_usecount;
 	*ldp = conn->ptconn_ld;
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
 		"<= passthru_get_connection ld=0x%p (concurrency now %d)\n",
 		*ldp, conn->ptconn_usecount );
     } else {
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
 		"<= passthru_get_connection error %d\n", rc );
     }
 
@@ -245,7 +245,7 @@ passthru_release_connection( PassThruServer *srvr, LDAP *ld, int dispose )
     PASSTHRU_ASSERT( ld != NULL );
 
 #ifdef PASSTHRU_VERBOSE_LOGGING
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
 	    "=> passthru_release_connection ld=0x%x%s\n", ld,
 	    dispose ? " (disposing)" : "" );
 #endif
@@ -265,7 +265,7 @@ passthru_release_connection( PassThruServer *srvr, LDAP *ld, int dispose )
     }
 
     if ( conn == NULL ) {		/* ld not found -- unexpected */
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+	slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
 		"=> passthru_release_connection ld=0x%p not found\n", ld );
     } else {
 	PASSTHRU_ASSERT( conn->ptconn_usecount > 0 );
@@ -371,7 +371,7 @@ check_for_stale_connections( PassThruServer *srvr )
     PASSTHRU_ASSERT( srvr != NULL );
 
 #ifdef PASSTHRU_VERBOSE_LOGGING
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
 	    "check_for_stale_connections: server %s (lifetime %d secs)\n",
 	    srvr->ptsrvr_url, srvr->ptsrvr_connlifetime );
 #endif
@@ -395,7 +395,7 @@ check_for_stale_connections( PassThruServer *srvr )
 		 * connection is idle and stale -- remove from server's list
 		 */
 #ifdef PASSTHRU_VERBOSE_LOGGING
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+		slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
 			"check_for_stale_connections: discarding idle, "
 			"stale connection 0x%x\n", conn->ptconn_ld );
 #endif
@@ -411,7 +411,7 @@ check_for_stale_connections( PassThruServer *srvr )
 		 * connection is stale but in use -- mark to be disposed later
 		 */
 #ifdef PASSTHRU_VERBOSE_LOGGING
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+		slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
 			"check_for_stale_connections: marking connection 0x%x "
 			"stale (use count %d)\n", conn->ptconn_ld,
 			conn->ptconn_usecount );

ldap/servers/plugins/passthru/ptpreop.c

@@ -38,7 +38,7 @@ passthruauth_init( Slapi_PBlock *pb )
 {
     PASSTHRU_ASSERT( pb != NULL );
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
 	    "=> passthruauth_init\n" );
 
     if ( slapi_pblock_set( pb, SLAPI_PLUGIN_VERSION,
@@ -51,12 +51,12 @@ passthruauth_init( Slapi_PBlock *pb )
 		    (void *)passthru_bindpreop ) != 0
 	    || slapi_pblock_set( pb, SLAPI_PLUGIN_CLOSE_FN,
 		    (void *)passthru_bindpreop_close ) != 0  ) {
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
-		"passthruauth_init failed\n" );
+	slapi_log_error(SLAPI_LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
+		"passthruauth_init - Failed\n" );
 	return( -1 );
     }
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
 	"<= passthruauth_init succeeded\n" );
 
     return( 0 );
@@ -75,19 +75,19 @@ passthru_bindpreop_start( Slapi_PBlock *pb )
 
     PASSTHRU_ASSERT( pb != NULL );
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
 	    "=> passthru_bindpreop_start\n" );
 
     if ( slapi_pblock_get( pb, SLAPI_PLUGIN_ARGC, &argc ) != 0 ||
 	    slapi_pblock_get( pb, SLAPI_PLUGIN_ARGV, &argv ) != 0 ) {
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
-		"unable to get arguments\n" );
+	slapi_log_error(SLAPI_LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
+		"passthru_bindpreop_start - Unable to get arguments\n" );
 	return( -1 );
     }
 
     if (( rc = passthru_config( argc, argv )) != LDAP_SUCCESS ) {
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
-		"configuration failed (%s)\n", ldap_err2string( rc ));
+	slapi_log_error(SLAPI_LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
+		"passthru_bindpreop_start - Configuration failed (%s)\n", ldap_err2string( rc ));
 	return( -1 );
     }
 
@@ -103,7 +103,7 @@ passthru_bindpreop_close( Slapi_PBlock *pb )
 {
     PASSTHRU_ASSERT( pb != NULL );
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
 	    "=> passthru_bindpreop_close\n" );
 
     /*
@@ -133,7 +133,7 @@ passthru_bindpreop( Slapi_PBlock *pb )
 
     PASSTHRU_ASSERT( pb != NULL );
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
+    slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
 	    "=> passthru_bindpreop\n" );
 
     /*
@@ -142,8 +142,8 @@ passthru_bindpreop( Slapi_PBlock *pb )
     if ( slapi_pblock_get( pb, SLAPI_BIND_METHOD, &method ) != 0 ||
         slapi_pblock_get( pb, SLAPI_BIND_TARGET_SDN, &sdn ) != 0 ||
         slapi_pblock_get( pb, SLAPI_BIND_CREDENTIALS, &creds ) != 0 ) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
-                     "<= not handled (unable to retrieve bind parameters)\n" );
+        slapi_log_error(SLAPI_LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
+                     "passthru_bindpreop - Not handled (unable to retrieve bind parameters)\n" );
         return( PASSTHRU_OP_NOT_HANDLED );
     }
     normbinddn = slapi_sdn_get_dn(sdn);
@@ -157,8 +157,8 @@ passthru_bindpreop( Slapi_PBlock *pb )
      */
     if ( method != LDAP_AUTH_SIMPLE || *normbinddn == '\0'
 	    || creds->bv_len == 0 ) {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
-                "<= not handled (not simple bind or NULL dn/credentials)\n" );
+        slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
+                "passthru_bindpreop - Not handled (not simple bind or NULL dn/credentials)\n" );
         return( PASSTHRU_OP_NOT_HANDLED );
     }
 
@@ -172,8 +172,8 @@ passthru_bindpreop( Slapi_PBlock *pb )
      * another server.
      */
     if ( passthru_dn2server( cfg, normbinddn, &srvr ) != LDAP_SUCCESS ) {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
-                "<= not handled (not one of our suffixes)\n" );
+        slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
+                "passthru_bindpreop - Not handled (not one of our suffixes)\n" );
         return( PASSTHRU_OP_NOT_HANDLED );
     }
 
@@ -187,7 +187,7 @@ passthru_bindpreop( Slapi_PBlock *pb )
     if ( slapi_pblock_get( pb, SLAPI_REQCONTROLS, &reqctrls ) != 0 ) {
 	rc = LDAP_OPERATIONS_ERROR;
 	errmsg = "unable to retrieve bind controls";
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM, "%s\n",
+	slapi_log_error(SLAPI_LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM, "%s\n",
 		errmsg );
     } else {
 	int	lderrno;
@@ -224,8 +224,8 @@ passthru_bindpreop( Slapi_PBlock *pb )
             slapi_ch_free((void **)&ndn);
             rc = LDAP_OPERATIONS_ERROR;
             errmsg = "unable to set connection DN or AUTHTYPE";
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
-                             "%s\n", errmsg );
+            slapi_log_error(SLAPI_LOG_ERR, PASSTHRU_PLUGIN_SUBSYSTEM,
+                             "passthru_bindpreop - %s\n", errmsg );
         }
     }
 
@@ -259,8 +259,8 @@ passthru_bindpreop( Slapi_PBlock *pb )
 	ldap_memfree( matcheddn );
     }
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, PASSTHRU_PLUGIN_SUBSYSTEM,
-	    "<= handled (error %d - %s)\n", rc, ldap_err2string( rc ));
+    slapi_log_error(SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
+	    "passthru_bindpreop - handled (error %d - %s)\n", rc, ldap_err2string( rc ));
 
     return( PASSTHRU_OP_HANDLED );
 }

ldap/servers/plugins/posix-winsync/posix-group-func.c

@@ -77,7 +77,7 @@ addDynamicGroupIfNecessary(Slapi_Entry *entry, Slapi_Mods *smods) {
 Slapi_Entry *
 getEntry(const char *udn, char **attrs)
 {
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME, "getEntry: search %s\n", udn);
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME, "getEntry: search %s\n", udn);
 
     Slapi_DN *udn_sdn = slapi_sdn_new_dn_byval(udn);
     Slapi_Entry *result = NULL;
@@ -89,12 +89,12 @@ getEntry(const char *udn, char **attrs)
             return result; /* Must be freed */
         }
         else {
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+            slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                             "getEntry: %s not found\n", udn);
         }
     }
     else {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, POSIX_WINSYNC_PLUGIN_NAME,
+        slapi_log_error(SLAPI_LOG_ERR, POSIX_WINSYNC_PLUGIN_NAME,
                         "getEntry: error searching for uid %s: %d\n", udn, rc);
     }
 
@@ -118,10 +118,10 @@ searchUid(const char *udn)
         if (slapi_entry_attr_find(entry, "uid", &attr) == 0 && hasObjectClass(entry, "posixAccount")) {
             slapi_attr_first_value(attr, &v);
             uid = slapi_ch_strdup(slapi_value_get_string(v));
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+            slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                             "searchUid: return uid %s\n", uid);
         } else {
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+            slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                             "searchUid: uid in %s not found\n", udn);
         }
 
@@ -129,13 +129,13 @@ searchUid(const char *udn)
             uid = slapi_dn_ignore_case(uid);
         }
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                         "searchUid: About to free entry (%s)\n", udn);
         
         slapi_entry_free(entry);
     }
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "searchUid(%s): <==\n", udn);
         
     return uid;
@@ -180,7 +180,7 @@ uid_in_set(const char* uid, char **uids)
         char *i_uid = NULL;
         char *t = NULL;
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME, "uid_in_set: comp %s %s \n",
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME, "uid_in_set: comp %s %s \n",
                         uid, uids[i]);
         i_rdn = slapi_rdn_new_dn(uids[i]);
         if (slapi_rdn_get_first(i_rdn, &t, &i_uid) == 1) {
@@ -210,7 +210,7 @@ uid_in_valueset(const char* uid, Slapi_ValueSet *uids)
 
         const char *uid_i = slapi_value_get_string(v);
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME, "uid_in_valueset: comp %s %s \n",
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME, "uid_in_valueset: comp %s %s \n",
                         uid, uid_i);
         i_rdn = slapi_rdn_new_dn(uid_i);
         if (slapi_rdn_get_first(i_rdn, &t, &i_uid) == 1) {
@@ -271,7 +271,7 @@ hasObjectClass(Slapi_Entry *entry, const char *objectClass)
         return 0; /* Doesn't have any objectclasses */
     }
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "Scanning objectclasses\n");
 
     for (
@@ -309,7 +309,7 @@ posix_winsync_foreach_parent(Slapi_Entry *entry, char **attrs, plugin_search_ent
         if (base_sdn == NULL) {
             continue;
         }
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                         "posix_winsync_foreach_parent: Searching subtree %s for %s\n",
                         slapi_sdn_get_dn(base_sdn),
                         filter);
@@ -339,9 +339,9 @@ posix_winsync_foreach_parent(Slapi_Entry *entry, char **attrs, plugin_search_ent
 void
 getMembershipFromDownward(Slapi_Entry *entry, Slapi_ValueSet *muid_vs, Slapi_ValueSet *muid_nested_vs, Slapi_ValueSet *deletions, const Slapi_DN *base_sdn, int depth)
 {
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "getMembershipFromDownward: ==>\n");
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "getMembershipFromDownward: entry name: %s\n",
                     slapi_entry_get_dn_const(entry));
 
@@ -350,14 +350,14 @@ getMembershipFromDownward(Slapi_Entry *entry, Slapi_ValueSet *muid_vs, Slapi_Val
     Slapi_Value *uid_value = NULL; /* uniqueMember attribute values */
 
     if (depth >= MAX_RECURSION_DEPTH) {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                         "getMembershipFromDownward: recursion limit reached: %d\n", depth);
         return;
     }
 
     rc = slapi_entry_attr_find(entry, "uniquemember", &um_attr);
     if (rc != 0 || um_attr == NULL) {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                         "getMembershipFromDownward end: attribute uniquemember not found\n");
         return;
     }
@@ -368,13 +368,13 @@ getMembershipFromDownward(Slapi_Entry *entry, Slapi_ValueSet *muid_vs, Slapi_Val
 
         char *attrs[] = { "uniqueMember", "memberUid", "uid", "objectClass", NULL };
         const char *uid_dn = slapi_value_get_string(uid_value);
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                         "getMembershipFromDownward: iterating uniqueMember: %s\n",
                         uid_dn);
         
         if (deletions && !slapi_sdn_compare(slapi_entry_get_sdn_const(entry), base_sdn)) {
             if (slapi_valueset_find(um_attr, deletions, uid_value)) {
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                 "getMembershipFromDownward: Skipping iteration because of deletion\n");
 
                 continue;
@@ -384,7 +384,7 @@ getMembershipFromDownward(Slapi_Entry *entry, Slapi_ValueSet *muid_vs, Slapi_Val
         Slapi_Entry *child = getEntry(uid_dn, attrs);
 
         if (!child) {
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+            slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                             "getMembershipFromDownward end: child not found: %s\n", uid_dn);
         }
         else {
@@ -403,7 +403,7 @@ getMembershipFromDownward(Slapi_Entry *entry, Slapi_ValueSet *muid_vs, Slapi_Val
                     slapi_attr_first_value(uid_attr, &v);
 
                     if (v && !slapi_valueset_find(uid_attr, muid_vs, v)) {                        
-                        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                         "getMembershipFromDownward: adding member: %s\n",
                                         slapi_value_get_string(v));
                         slapi_valueset_add_value(muid_vs, v);
@@ -417,7 +417,7 @@ getMembershipFromDownward(Slapi_Entry *entry, Slapi_ValueSet *muid_vs, Slapi_Val
                     slapi_attr_first_value(uid_attr, &v);
 
                     if (v && !slapi_valueset_find(uid_attr, muid_vs, v)) {                        
-                        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                         "getMembershipFromDownward: adding member: %s\n",
                                         slapi_value_get_string(v));
                         slapi_valueset_add_value(muid_vs, v);
@@ -429,7 +429,7 @@ getMembershipFromDownward(Slapi_Entry *entry, Slapi_ValueSet *muid_vs, Slapi_Val
         }
     }
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "getMembershipFromDownward: <==\n");
 }
 
@@ -453,14 +453,14 @@ void
 propogateMembershipUpward(Slapi_Entry *entry, Slapi_ValueSet *muid_vs, int depth)
 {
     if (depth >= MAX_RECURSION_DEPTH) {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                         "propogateMembershipUpward: recursion limit reached: %d\n", depth);
         return;
     }
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "propogateMembershipUpward: ==>\n");
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "propogateMembershipUpward: entry name: %s\n",
                     slapi_entry_get_dn_const(entry));
 
@@ -476,7 +476,7 @@ propogateMembershipUpward(Slapi_Entry *entry, Slapi_ValueSet *muid_vs, int depth
         Slapi_ValueSet *muid_old_vs = NULL;
         int rc = slapi_entry_attr_find(entry, "memberUid", &muid_old_attr);
         if (rc != 0 || muid_old_attr == NULL) { /* Found no memberUid list, so create  */
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+            slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                             "propogateMembershipUpward: no attribute memberUid\n");
             
             /* There's no values from this entry to add */
@@ -497,7 +497,7 @@ propogateMembershipUpward(Slapi_Entry *entry, Slapi_ValueSet *muid_vs, int depth
                  i = slapi_valueset_next_value(muid_vs, i, &v)) {
                 
                 if (!slapi_valueset_find(muid_old_attr, muid_old_vs, v)) {
-                    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                     "propogateMembershipUpward: adding %s to set\n",
                                     slapi_value_get_string(v));
 
@@ -535,7 +535,7 @@ propogateMembershipUpward(Slapi_Entry *entry, Slapi_ValueSet *muid_vs, int depth
         slapi_valueset_free(muid_upward_vs); muid_upward_vs = NULL;
     }
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "propogateMembershipUpward: <==\n");
 }
 
@@ -563,14 +563,14 @@ propogateDeletionsUpward(Slapi_Entry *entry, const Slapi_DN *base_sdn, Slapi_Val
     if (smod_deluids == NULL) return;
 
     if (depth >= MAX_RECURSION_DEPTH) {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                         "propogateDeletionsUpward: recursion limit reached: %d\n", depth);
         return;
     }
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "propogateDeletionsUpward: ==>\n");
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "propogateDeletionsUpward: entry name: %s\n",
                     slapi_entry_get_dn_const(entry));
 
@@ -596,14 +596,14 @@ propogateDeletionsUpward(Slapi_Entry *entry, const Slapi_DN *base_sdn, Slapi_Val
             if (!slapi_valueset_find(muid_attr, muid_vs, v)) {
                 const char *uid = slapi_value_get_string(v);
                 if (depth == 0 && !uid_in_valueset(uid, smod_deluids)) {
-                    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                     "propogateDeletionsUpward: Adding deletion to modlist: %s\n",
                                     slapi_value_get_string(v));
                     slapi_valueset_add_value(del_nested_vs, v);                    
                 }
                 else if (depth > 0) {
                     slapi_valueset_add_value(muid_deletions_vs, v);                
-                    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                     "propogateDeletionsUpward: Adding deletion to deletion list: %s\n",
                                     slapi_value_get_string(v));
                 }
@@ -611,7 +611,7 @@ propogateDeletionsUpward(Slapi_Entry *entry, const Slapi_DN *base_sdn, Slapi_Val
         }
 
         if (depth > 0) {
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+            slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                             "propogateDeletionsUpward: executing deletion list\n");
 
             Slapi_Mods *smods = slapi_mods_new();
@@ -632,21 +632,21 @@ propogateDeletionsUpward(Slapi_Entry *entry, const Slapi_DN *base_sdn, Slapi_Val
         slapi_valueset_free(muid_deletions_vs); muid_deletions_vs = NULL;
     }
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "propogateDeletionsUpward: <==\n");
 }
 
 int
 modGroupMembership(Slapi_Entry *entry, Slapi_Mods *smods, int *do_modify, int newposixgroup)
 {
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME, "modGroupMembership: ==>\n");
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME, "modGroupMembership: Modding %s\n",
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME, "modGroupMembership: ==>\n");
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME, "modGroupMembership: Modding %s\n",
                     slapi_entry_get_dn_const(entry));
 
     int posixGroup = hasObjectClass(entry, "posixGroup");
 
     if (!(posixGroup || hasObjectClass(entry, "ntGroup")) && !newposixgroup) {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                         "modGroupMembership end: Not a posixGroup or ntGroup\n");
         return 0;
     }
@@ -657,7 +657,7 @@ modGroupMembership(Slapi_Entry *entry, Slapi_Mods *smods, int *do_modify, int ne
     char **smod_adduids = NULL;
     Slapi_ValueSet *smod_deluids = NULL;
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "modGroupMembership: posixGroup -> look for uniquemember\n");
     if (slapi_is_loglevel_set(SLAPI_LOG_PLUGIN))
         slapi_mods_dump(smods, "memberUid - mods dump - initial");
@@ -680,13 +680,13 @@ modGroupMembership(Slapi_Entry *entry, Slapi_Mods *smods, int *do_modify, int ne
                     if (!smod_deluids) smod_deluids = slapi_valueset_new();
 
                     slapi_valueset_add_value(smod_deluids, sv);
-                    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                     "modGroupMembership: add to deluids %s\n",
                                     bv->bv_val);
                 } else {
                     slapi_ch_array_add(&smod_adduids,
                                        slapi_ch_strdup(slapi_value_get_string(sv)));
-                    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                     "modGroupMembership: add to adduids %s\n",
                                     bv->bv_val);
                 }
@@ -719,7 +719,7 @@ modGroupMembership(Slapi_Entry *entry, Slapi_Mods *smods, int *do_modify, int ne
                 int rc = slapi_entry_attr_find(entry, "uniquemember", &um_attr);
                 
                 if (rc != 0 || um_attr == NULL) {
-                    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                     "modGroupMembership end: attribute uniquemember not found\n");
                     break;
                 }
@@ -727,7 +727,7 @@ modGroupMembership(Slapi_Entry *entry, Slapi_Mods *smods, int *do_modify, int ne
                 slapi_attr_get_valueset(um_attr, &smod_deluids);
             }
             if (muid_rc != 0 || muid_attr == NULL) {
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                 "modGroupMembership end: attribute memberUid not found\n");
             }
             else if (posix_winsync_config_get_mapMemberUid()) {
@@ -736,14 +736,14 @@ modGroupMembership(Slapi_Entry *entry, Slapi_Mods *smods, int *do_modify, int ne
                      j = slapi_attr_next_value(muid_attr, j, &uid_value)) {
                     /* remove from uniquemember: remove from memberUid also */
                     const char *uid = NULL;
-                    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                     "modGroupMembership: test dellist \n");
                     uid = slapi_value_get_string(uid_value);
-                    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                     "modGroupMembership: test dellist %s\n", uid);
                     if (uid_in_valueset(uid, smod_deluids)) {
                         slapi_valueset_add_value(deluids, uid_value);
-                        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                         "modGroupMembership: add to dellist %s\n", uid);
                     }
                 }
@@ -763,7 +763,7 @@ modGroupMembership(Slapi_Entry *entry, Slapi_Mods *smods, int *do_modify, int ne
     if (smod_adduids != NULL) { /* not MOD_DELETE */
         const char *uid_dn = NULL;
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                         "modGroupMembership: posixGroup -> look for uniquemember\n");
 
         if (muid_rc == 0 && muid_attr == NULL) {
@@ -781,13 +781,13 @@ modGroupMembership(Slapi_Entry *entry, Slapi_Mods *smods, int *do_modify, int ne
                 static char *uid = NULL;
 
                 uid_dn = smod_adduids[j];
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                 "modGroupMembership: perform user %s\n", uid_dn);
 
                 uid = searchUid(uid_dn);
 
                 if (uid == NULL) {
-                    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                     "modGroupMembership: uid not found for %s, cannot do anything\n",
                                     uid_dn); /* member on longer on server, do nothing */
                 } else {
@@ -797,14 +797,14 @@ modGroupMembership(Slapi_Entry *entry, Slapi_Mods *smods, int *do_modify, int ne
                     if (muid_rc == 0 && muid_attr != NULL &&
                         slapi_valueset_find(muid_attr, muid_vs, v) != NULL) {
 
-                        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                         "modGroupMembership: uid found in memberuid list %s nothing to do\n",
                                         uid);
                     }
                     else {
                         slapi_valueset_add_value(adduids, v);
                         slapi_valueset_add_value(muid_vs, v);
-                        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                         "modGroupMembership: add to modlist %s\n", uid);
                     }
 
@@ -821,7 +821,7 @@ modGroupMembership(Slapi_Entry *entry, Slapi_Mods *smods, int *do_modify, int ne
 
                 if (child) {
                     if (hasObjectClass(child, "ntGroup") || hasObjectClass(child, "posixGroup")) {
-                        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                         "modGroupMembership: Found mod to add group, adding membership: %s\n",
                                         smod_adduids[j]);
                         Slapi_ValueSet *muid_tempnested = slapi_valueset_new();
@@ -831,7 +831,7 @@ modGroupMembership(Slapi_Entry *entry, Slapi_Mods *smods, int *do_modify, int ne
                     }
                 }
                 else {
-                    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                     "modGroupMembership: entry not found for dn: %s\n",
                                     smod_adduids[j]);
                 }
@@ -910,7 +910,7 @@ modGroupMembership(Slapi_Entry *entry, Slapi_Mods *smods, int *do_modify, int ne
         slapi_valueset_free(muid_vs); muid_vs = NULL;
     }
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME, "modGroupMembership: <==\n");
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME, "modGroupMembership: <==\n");
     return 0;
 }
 
@@ -941,12 +941,12 @@ addGroupMembership(Slapi_Entry *entry, Slapi_Entry *ad_entry)
     int rc = 0;
     int i;
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME, "addGroupMembership: ==>\n");
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME, "addGroupMembership: ==>\n");
 
     int posixGroup = hasObjectClass(entry, "posixGroup");
 
     if(!(posixGroup || hasObjectClass(entry, "ntGroup"))) {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                         "addGroupMembership: didn't find posixGroup or ntGroup objectclass\n");
         return 0;
     }
@@ -957,18 +957,18 @@ addGroupMembership(Slapi_Entry *entry, Slapi_Entry *ad_entry)
 
     Slapi_ValueSet *newvs = NULL;
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "addGroupMembership: posixGroup -> look for uniquemember\n");
     rc = slapi_entry_attr_find(entry, "uniquemember", &um_attr);
     if (rc != 0 || um_attr == NULL) {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                         "addGroupMembership end: attribute uniquemember not found\n");
         return 0;
     }
     /* found attribute uniquemember */
     rc = slapi_entry_attr_find(entry, "memberUid", &muid_attr);
     if (rc != 0 || muid_attr == NULL) { /* Found no memberUid list, so create  */
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                         "addGroupMembership: no attribute memberUid\n");
         muid_attr = NULL;
     }
@@ -982,11 +982,11 @@ addGroupMembership(Slapi_Entry *entry, Slapi_Entry *ad_entry)
             Slapi_Value *v = NULL;
 
             uid_dn = slapi_value_get_string(uid_value);
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+            slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                             "addGroupMembership: perform member %s\n", uid_dn);
             uid = searchUid(uid_dn);
             if (uid == NULL) {
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                 "addGroupMembership: uid not found for %s, cannot do anything\n",
                                 uid_dn); /* member on longer on server, do nothing */
             } else {
@@ -1021,7 +1021,7 @@ addGroupMembership(Slapi_Entry *entry, Slapi_Entry *ad_entry)
     slapi_valueset_free(newvs); newvs = NULL;
     posix_winsync_config_get_MOFTaskCreated();
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME, "addGroupMembership: <==\n");
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME, "addGroupMembership: <==\n");
     return 0;
 }
 

ldap/servers/plugins/posix-winsync/posix-group-task.c

@@ -75,7 +75,7 @@ posix_group_task_add(Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Entry *eAfter, int
     *returncode = LDAP_SUCCESS;
 
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "posix_group_task_add: ==>\n");
 
     /* get arg(s) */
@@ -86,7 +86,7 @@ posix_group_task_add(Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Entry *eAfter, int
         goto out;
     }
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "posix_group_task_add: retrieved basedn: %s\n", dn);
 
     if ((filter = fetch_attr(e, "filter", "(&(objectclass=ntGroup)(|(uniquemember=*)(memberuid=*)))")) == NULL) {
@@ -95,7 +95,7 @@ posix_group_task_add(Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Entry *eAfter, int
         goto out;
     }
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "posix_group_task_add: retrieved filter: %s\n", filter);
 
     /* setup our task data */
@@ -108,31 +108,31 @@ posix_group_task_add(Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Entry *eAfter, int
     mytaskdata->dn = slapi_ch_strdup(dn);
     mytaskdata->filter_str = slapi_ch_strdup(filter);
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "posix_group_task_add: task data allocated\n");
 
     /* allocate new task now */
     char * ndn = slapi_entry_get_ndn(e);
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "posix_group_task_add: creating task object: %s\n",
                     ndn);
 
     task = slapi_new_task(ndn);
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "posix_group_task_add: task object created\n");
 
     /* register our destructor for cleaning up our private data */
     slapi_task_set_destructor_fn(task, posix_group_task_destructor);
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "posix_group_task_add: task destructor set\n");
 
     /* Stash a pointer to our data in the task */
     slapi_task_set_data(task, mytaskdata);
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "posix_group_task_add: task object initialized\n");
 
     /* start the sample task as a separate thread */
@@ -140,12 +140,12 @@ posix_group_task_add(Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Entry *eAfter, int
                              PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_UNJOINABLE_THREAD,
                              SLAPD_DEFAULT_THREAD_STACKSIZE);
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "posix_group_task_add: thread created\n");
 
     if (thread == NULL) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, POSIX_WINSYNC_PLUGIN_NAME,
-                        "unable to create task thread!\n");
+        slapi_log_error(SLAPI_LOG_ERR, POSIX_WINSYNC_PLUGIN_NAME,
+                        "posix_group_task_add: unable to create task thread!\n");
         *returncode = LDAP_OPERATIONS_ERROR;
         rv = SLAPI_DSE_CALLBACK_ERROR;
         slapi_task_finish(task, *returncode);
@@ -154,7 +154,7 @@ posix_group_task_add(Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Entry *eAfter, int
     }
 
 out: 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "posix_group_task_add: <==\n");
 
     return rv;
@@ -176,7 +176,7 @@ posix_group_task_destructor(Slapi_Task *task)
             slapi_ch_free((void **) &mydata);
         }
     }
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "posix_group_task_destructor <--\n");
 }
 
@@ -247,7 +247,7 @@ static int
 posix_group_fix_memberuid_callback(Slapi_Entry *e, void *callback_data)
 {
     int i;
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "_fix_memberuid ==>\n");
     cb_data *the_cb_data = (cb_data *) callback_data;
 
@@ -291,14 +291,14 @@ posix_group_fix_memberuid_callback(Slapi_Entry *e, void *callback_data)
             slapi_attr_get_valueset(dsmuid_attr, &dsmuid_vs);
         }
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                         "_fix_memberuid scan for orphaned memberuids\n");
 
         for (i = slapi_attr_first_value(muid_attr, &v); i != -1;
              i = slapi_attr_next_value(muid_attr, i, &v)) {
             char *muid = (char *)slapi_value_get_string(v);
 
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+            slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                             "_fix_memberuid iterating memberuid: %s\n",
                             muid);
 
@@ -316,7 +316,7 @@ posix_group_fix_memberuid_callback(Slapi_Entry *e, void *callback_data)
                                          attrs, 0, NULL, NULL,
                                          posix_winsync_get_plugin_identity(), 0);
 
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+            slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                             "_fix_memberuid searching %s with filter: %s\n",
                             the_cb_data->dn, filter);
 
@@ -325,14 +325,14 @@ posix_group_fix_memberuid_callback(Slapi_Entry *e, void *callback_data)
             slapi_pblock_get(search_pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &search_entries);
 
             if (!search_entries || !search_entries[0]) {
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                 "_fix_memberuid Adding bad memberuid %s\n",
                                 slapi_value_get_string(v));
 
                 slapi_mods_add_string(smods, LDAP_MOD_DELETE, "memberuid", slapi_value_get_string(v));
 
                 if (dsmuid_vs && slapi_valueset_find(dsmuid_attr, dsmuid_vs, v)) {
-                    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                     "_fix_memberuid Adding bad dsonlymemberuid %s\n",
                                     slapi_value_get_string(v));
 
@@ -360,7 +360,7 @@ posix_group_fix_memberuid_callback(Slapi_Entry *e, void *callback_data)
         Slapi_ValueSet *bad_ums = NULL;
         Slapi_Value *uniqval = NULL;   /* uniquemeber Attribute values */
         Slapi_ValueSet *uids = NULL;
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                         "_fix_memberuid scan uniquemember, group %s\n", dn);
         for (i = slapi_attr_first_value(obj_attr, &uniqval); i != -1;
              i = slapi_attr_next_value(obj_attr, i, &uniqval)) {
@@ -372,7 +372,7 @@ posix_group_fix_memberuid_callback(Slapi_Entry *e, void *callback_data)
             if (child) {
                 slapi_entry_free(child);
             } else {
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+                slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                                 "_fix_memberuid orphaned uniquemember found: %s\n", member);
 
                 if ((strncasecmp(member, "cn=", 3) == 0) ||
@@ -388,7 +388,7 @@ posix_group_fix_memberuid_callback(Slapi_Entry *e, void *callback_data)
             if (is_posix_group) {
                 char *uid = NULL;
                 /* search uid for member (DN) */
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME, "search %s\n", member);
+                slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME, "search %s\n", member);
                 if ((uid = searchUid(member)) != NULL) {
                     Slapi_Value *value = slapi_value_new();
                     /* Search an entry having "member" as DN and get uid value from it. */
@@ -425,13 +425,13 @@ posix_group_fix_memberuid_callback(Slapi_Entry *e, void *callback_data)
         }
         slapi_valueset_free(uids);
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                         "_fix_memberuid Finishing...\n");
 
         if (fixMembership && posix_winsync_config_get_mapNestedGrouping()) {
             Slapi_ValueSet *del_nested_vs = slapi_valueset_new();
 
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+            slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                             "_fix_memberuid group deleted, recalculating nesting\n");
             propogateDeletionsUpward(e, sdn, bad_ums, del_nested_vs, 0);
 
@@ -459,7 +459,7 @@ posix_group_fix_memberuid_callback(Slapi_Entry *e, void *callback_data)
     }
     slapi_mods_free(&smods);
 bail:
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "_fix_memberuid <==\n");
     /*
      * Since Ticket #481 "expand nested posix groups",
@@ -473,7 +473,7 @@ bail:
 static void
 posix_group_fixup_task_thread(void *arg)
 {
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "_task_thread ==>\n");
 
     Slapi_Task *task = (Slapi_Task *) arg;
@@ -484,7 +484,7 @@ posix_group_fixup_task_thread(void *arg)
         return; /* no task */
     }
     slapi_task_inc_refcount(task);
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "posix_group_fixup_task_thread --> refcount incremented.\n" );
     /* Fetch our task data from the task */
     td = (task_data *) slapi_task_get_data(task);
@@ -506,15 +506,15 @@ posix_group_fixup_task_thread(void *arg)
     slapi_task_log_status(task, "posix_group task finished.");
     slapi_task_inc_progress(task);
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "_task_thread finishing\n");
 
     /* this will queue the destruction of the task */
     slapi_task_finish(task, rc);
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "_task_thread <==\n");
     slapi_task_dec_refcount(task);
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "posix_group_fixup_task_thread <-- refcount decremented.\n");
 }

ldap/servers/plugins/posix-winsync/posix-winsync-config.c

@@ -46,7 +46,7 @@ posix_winsync_agmt_init(const Slapi_DN *ds_subtree, const Slapi_DN *ad_subtree)
         return NULL;
     }
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "--> posix_winsync_agmt_init [%s] [%s] -- begin\n",
                     slapi_sdn_get_dn(ds_subtree), slapi_sdn_get_dn(ad_subtree));
 
@@ -55,21 +55,21 @@ posix_winsync_agmt_init(const Slapi_DN *ds_subtree, const Slapi_DN *ad_subtree)
 		/* if sdn is a parent of ds_subtree or sdn is the WinSync Subtree itself */
         if (slapi_sdn_isparent(sdn, ds_subtree) || !slapi_sdn_compare(sdn, ds_subtree)) {
             theConfig.rep_suffix = sdn;
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME, "Found suffix's '%s'\n",
-                            slapi_sdn_get_dn(sdn));
+            slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME, "posix_winsync_agmt_init - "
+                    "Found suffix's '%s'\n", slapi_sdn_get_dn(sdn));
             break;
         }
         sdn = slapi_get_next_suffix(&node, 0);
     }
     if (!sdn) {
         char *pardn = slapi_dn_parent(slapi_sdn_get_dn(ds_subtree));
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, POSIX_WINSYNC_PLUGIN_NAME, "suffix not found for '%s'\n",
-                        pardn);
+        slapi_log_error(SLAPI_LOG_ERR, POSIX_WINSYNC_PLUGIN_NAME, "posix_winsync_agmt_init - "
+                "suffix not found for '%s'\n", pardn);
         slapi_ch_free_string(&pardn);
     }
 
     plugin_op_finished();
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
                     "<-- posix_winsync_agmt_init -- end\n");
 
     return cbdata;
@@ -151,12 +151,12 @@ posix_winsync_config(Slapi_Entry *config_e)
     theConfig.config_e = NULL;
     theConfig.lock = NULL;
 
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME, "--> _config %s -- begin\n",
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME, "--> _config %s -- begin\n",
                     slapi_entry_get_dn_const(config_e));
     if (inited) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, POSIX_WINSYNC_PLUGIN_NAME,
-                        "Error: POSIX WinSync plug-in already configured.  "
-                            "Please remove the plugin config entry [%s]\n",
+        slapi_log_error(SLAPI_LOG_ERR, POSIX_WINSYNC_PLUGIN_NAME,
+                        "posix_winsync_config - POSIX WinSync plug-in already configured.  "
+                        "Please remove the plugin config entry [%s]\n",
                         slapi_entry_get_dn_const(config_e));
         return (LDAP_PARAM_ERROR);
     }
@@ -183,8 +183,8 @@ posix_winsync_config(Slapi_Entry *config_e)
         const char *config_dn = slapi_entry_get_dn_const(config_e);
 
         if (!memberUidLockInit()) {
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
-                            "posix_winsync_config -- init Monitor failed\n");
+            slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
+                            "posix_winsync_config - init Monitor failed\n");
         }
 
         slapi_config_register_callback(SLAPI_OPERATION_MODIFY, DSE_FLAG_POSTOP, config_dn,
@@ -193,15 +193,15 @@ posix_winsync_config(Slapi_Entry *config_e)
 
         rc = slapi_task_register_handler("memberuid task", posix_group_task_add);
         if (rc) {
-            slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
-                            "posix_winsync_config -- register memberuid task failed\n");
+            slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
+                            "posix_winsync_config - register memberuid task failed\n");
         }
     }
 
     inited = 1;
 
     if (returncode != LDAP_SUCCESS) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, POSIX_WINSYNC_PLUGIN_NAME, "Error %d: %s\n", returncode,
+        slapi_log_error(SLAPI_LOG_ERR, POSIX_WINSYNC_PLUGIN_NAME, "posix_winsync_config - Error %d: %s\n", returncode,
                         returntext);
     }
 
@@ -237,38 +237,38 @@ posix_winsync_apply_config(Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Ent
     /* get msfuSchema value */
     if (!slapi_entry_attr_find(e, POSIX_WINSYNC_MSSFU_SCHEMA, &testattr) && (NULL != testattr)) {
         mssfuSchema = slapi_entry_attr_get_bool(e, POSIX_WINSYNC_MSSFU_SCHEMA);
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
-                        "_apply_config: Config parameter %s: %d\n", POSIX_WINSYNC_MSSFU_SCHEMA,
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
+                        "posix_winsync_apply_config: Config parameter %s: %d\n", POSIX_WINSYNC_MSSFU_SCHEMA,
                         mssfuSchema);
     }
 
     /* get memberUid value */
     if (!slapi_entry_attr_find(e, POSIX_WINSYNC_MAP_MEMBERUID, &testattr) && (NULL != testattr)) {
         mapMemberUID = slapi_entry_attr_get_bool(e, POSIX_WINSYNC_MAP_MEMBERUID);
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
-                        "_apply_config: Config parameter %s: %d\n", POSIX_WINSYNC_MAP_MEMBERUID,
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
+                        "posix_winsync_apply_config: Config parameter %s: %d\n", POSIX_WINSYNC_MAP_MEMBERUID,
                         mapMemberUID);
     }
     /* get create task value */
     if (!slapi_entry_attr_find(e, POSIX_WINSYNC_CREATE_MEMBEROFTASK, &testattr) && (NULL
         != testattr)) {
         createMemberOfTask = slapi_entry_attr_get_bool(e, POSIX_WINSYNC_CREATE_MEMBEROFTASK);
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
-                        "_apply_config: Config parameter %s: %d\n",
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
+                        "posix_winsync_apply_config: Config parameter %s: %d\n",
                         POSIX_WINSYNC_CREATE_MEMBEROFTASK, createMemberOfTask);
     }
     /* get lower case UID in memberUID */
     if (!slapi_entry_attr_find(e, POSIX_WINSYNC_LOWER_CASE, &testattr) && (NULL != testattr)) {
         lowercase = slapi_entry_attr_get_bool(e, POSIX_WINSYNC_LOWER_CASE);
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
-                        "_apply_config: Config parameter %s: %d\n", POSIX_WINSYNC_LOWER_CASE,
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
+                        "posix_winsync_apply_config: Config parameter %s: %d\n", POSIX_WINSYNC_LOWER_CASE,
                         lowercase);
     }
     /* propogate memberuids in nested grouping */
     if (!slapi_entry_attr_find(e, POSIX_WINSYNC_MAP_NESTED_GROUPING, &testattr) && (NULL != testattr)) {
         mapNestedGrouping = slapi_entry_attr_get_bool(e, POSIX_WINSYNC_MAP_NESTED_GROUPING);
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
-                        "_apply_config: Config parameter %s: %d\n", POSIX_WINSYNC_MAP_NESTED_GROUPING,
+        slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
+                        "posix_winsync_apply_config: Config parameter %s: %d\n", POSIX_WINSYNC_MAP_NESTED_GROUPING,
                         mapNestedGrouping);
     }
     /* if we got here, we have valid values for everything
@@ -286,8 +286,8 @@ posix_winsync_apply_config(Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Ent
     theConfig.mapNestedGrouping = mapNestedGrouping;
 
     /* success */
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, POSIX_WINSYNC_PLUGIN_NAME,
-                    "<-- _apply_config: config evaluated\n");
+    slapi_log_error(SLAPI_LOG_PLUGIN, POSIX_WINSYNC_PLUGIN_NAME,
+                    "<-- posix_winsync_apply_config: config evaluated\n");
     *returncode = LDAP_SUCCESS;
 
     slapi_unlock_mutex(theConfig.lock);

ldap/servers/plugins/presence/presence.c

@@ -29,10 +29,6 @@
 #include <sys/stat.h>
 
 
-/*** from proto-slap.h ***/
-
-int slapd_log_error_proc( char *subsystem, char *fmt, ... );
-
 /*** from ldaplog.h ***/
 
 /* edited ldaplog.h for LDAPDebug()*/
@@ -43,21 +39,6 @@ int slapd_log_error_proc( char *subsystem, char *fmt, ... );
 extern "C" {
 #endif
 
-#define LDAP_DEBUG_TRACE	0x00001		/*     1 */
-#define LDAP_DEBUG_ANY      0x04000		/* 16384 */
-#define LDAP_DEBUG_PLUGIN	0x10000		/* 65536 */
-
-/* debugging stuff */
-extern int slapd_ldap_debug;
-#define LDAPDebugLevelIsSet( level )	( slapd_ldap_debug & level )
-
-#define LDAPDebug( level, fmt, arg1, arg2, arg3 )	\
-       { \
-		if ( LDAPDebugLevelIsSet( level )) { \
-		        slapd_log_error_proc( NULL, fmt, arg1, arg2, arg3 ); \
-	    } \
-       }
-
 #ifdef __cplusplus
 }
 #endif
@@ -249,7 +230,7 @@ int presence_init( Slapi_PBlock *pb )
 	int status = PRESENCE_SUCCESS;
 	char * plugin_identity=NULL;
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> presence_init -- BEGIN\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM,"presence_init - BEGIN\n");
 
 	/**
 	 * Store the plugin identity for later use.
@@ -269,12 +250,12 @@ int presence_init( Slapi_PBlock *pb )
 		slapi_pblock_set( pb, SLAPI_PLUGIN_DESCRIPTION,
              (void *)&pdesc ) != 0 )
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PRESENCE_PLUGIN_SUBSYSTEM,
-                     "presence_init: failed to register plugin\n" );
+		slapi_log_error(SLAPI_LOG_ERR, PRESENCE_PLUGIN_SUBSYSTEM,
+                     "presence_init - Failed to register plugin\n" );
 		status = PRESENCE_FAILURE;
 	}
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- presence_init -- END\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "presence_init -- END\n");
     return status;
 }
 
@@ -289,7 +270,7 @@ int presence_start( Slapi_PBlock *pb )
 {
 	char * plugindn = NULL;
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> presence_start -- begin\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "presence_start - BEGIN\n");
 
     if(slapi_apib_get_interface(HTTP_v1_0_GUID, &_HttpAPI))
 	{
@@ -307,8 +288,8 @@ int presence_start( Slapi_PBlock *pb )
                                 presence_vattr_compare, 
                                 presence_vattr_types) != 0)
     {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PRESENCE_PLUGIN_SUBSYSTEM,
-		   "presence_start: cannot register as service provider\n" );
+		slapi_log_error(SLAPI_LOG_ERR, PRESENCE_PLUGIN_SUBSYSTEM,
+		   "presence_start - Cannot register as service provider\n" );
 		return PRESENCE_FAILURE;
     }
 
@@ -340,13 +321,13 @@ int presence_start( Slapi_PBlock *pb )
 	 */
 	if (loadPluginConfig() != PRESENCE_SUCCESS)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PRESENCE_PLUGIN_SUBSYSTEM,
-    	   "presence_start: unable to load plug-in configuration\n" );
+		slapi_log_error(SLAPI_LOG_ERR, PRESENCE_PLUGIN_SUBSYSTEM,
+    	   "presence_start - Unable to load plug-in configuration\n" );
 		return PRESENCE_FAILURE;
 	}
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "presence: ready for service\n",0,0,0);
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- presence_start -- end\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "presence_start - Ready for service\n");
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "presence_start - END\n");
 
 	return PRESENCE_SUCCESS;
 }
@@ -358,11 +339,11 @@ int presence_start( Slapi_PBlock *pb )
 */
 int presence_close( Slapi_PBlock *pb )
 {
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> presence_close\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "--> presence_close\n");
 
 	deleteMapTables();
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- presence_close\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "<-- presence_close\n");
 
 	return PRESENCE_SUCCESS;
 }
@@ -386,9 +367,9 @@ static int presence_vattr_get(vattr_sp_handle *handle,
 	_Vmap *map = NULL;
 	_ConfigEntry *info = NULL;
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> presence_vattr_get \n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "--> presence_vattr_get \n");
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> Type=[%s] \n",type,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "presence_vattr_get - Type=[%s] \n",type);
 
 	if (imIDExists(e, type, &id, &map, &info) != PRESENCE_SUCCESS)
 	{
@@ -400,7 +381,7 @@ static int presence_vattr_get(vattr_sp_handle *handle,
 		status = PRESENCE_FAILURE;		
 		goto cleanup;
 	}
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> ID=[%s] \n",id,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "presence_vattr_get - ID=[%s] \n",id);
 
 	/**
 	 * Now since we got a valid id we do a quick schema check
@@ -417,8 +398,8 @@ static int presence_vattr_get(vattr_sp_handle *handle,
 
 	status = makeHttpRequest(id, map, info, &returnedBUF, &size);
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> size=[%d] \n",size,0,0);
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> buffer=[%s]\n",(returnedBUF) ? returnedBUF : "NULL",0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "presence_vattr_get - size=[%d] \n",size);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "presence_vattr_get - buffer=[%s]\n",(returnedBUF) ? returnedBUF : "NULL");
 
 
 	if(status == PRESENCE_SUCCESS)
@@ -451,14 +432,14 @@ static int presence_vattr_get(vattr_sp_handle *handle,
 	}
 	
 cleanup:
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> Processed ID=[%s] \n",id,0,0);
+slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "presence_vattr_get - Processed ID=[%s] \n",id);
 	if (id != NULL ) {
 		slapi_ch_free((void **)&id);
 	}
 	if (returnedBUF != NULL ) {
 		PR_Free(returnedBUF);
 	}
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- presence_vattr_get \n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "<-- presence_vattr_get \n");
 	return status;
 }
 
@@ -469,8 +450,8 @@ static int presence_vattr_compare(vattr_sp_handle *handle, vattr_context *c, Sla
 	/**
 	 * not yet implemented ???
 	 */
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> presence_vattr_compare \n",0,0,0);
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- presence_vattr_compare \n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "--> presence_vattr_compare - does nothing \n");
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "<-- presence_vattr_compare \n");
 
 	return status;
 }
@@ -482,11 +463,11 @@ static int presence_vattr_types(vattr_sp_handle *handle,Slapi_Entry *e,vattr_typ
 	args.entry = e;
 	args.context = type_context;
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> presence_vattr_types\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "--> presence_vattr_types\n");
 	
 	PL_HashTableEnumerateEntries(_IdVattrMapTable, setTypes, &args);	
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- presence_vattr_types\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "<-- presence_vattr_types\n");
 	return status;
 }
 
@@ -498,7 +479,7 @@ static int loadPluginConfig(void)
 	Slapi_PBlock *search_pb;
     Slapi_Entry **entries = NULL;
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> loadPluginConfig\n",0,0,0);
+    slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "--> loadPluginConfig\n");
 
     search_pb = slapi_pblock_new();
 
@@ -509,8 +490,8 @@ static int loadPluginConfig(void)
 
 	if (status != PRESENCE_SUCCESS)
 	{
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PRESENCE_PLUGIN_SUBSYSTEM, 
-			"Error getting level1 presence configurations<%s>\n", getPluginDN());
+        slapi_log_error(SLAPI_LOG_ERR, PRESENCE_PLUGIN_SUBSYSTEM, 
+			"loadPluginConfig - Error getting level1 presence configurations<%s>\n", getPluginDN());
 		status = PRESENCE_FAILURE;
 		goto cleanup;
 	}
@@ -518,8 +499,8 @@ static int loadPluginConfig(void)
 	slapi_pblock_get(search_pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &entries);
 	if (NULL == entries || entries[0] == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PRESENCE_PLUGIN_SUBSYSTEM, 
-			"No entries found for <%s>\n", getPluginDN());
+		slapi_log_error(SLAPI_LOG_ERR, PRESENCE_PLUGIN_SUBSYSTEM, 
+			"loadPluginConfig - No entries found for <%s>\n", getPluginDN());
 
 		status = PRESENCE_FAILURE;
 		goto cleanup;
@@ -541,7 +522,7 @@ static int loadPluginConfig(void)
 										NULL
 										);
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> parseConfigEntry \n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "--> parseConfigEntry \n");
 
 	for (i = 0; (entries[i] != NULL); i++)
 	{
@@ -552,9 +533,9 @@ static int loadPluginConfig(void)
 			goto cleanup;
 		}
 	}
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- parseConfigEntry \n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "<-- parseConfigEntry \n");
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- loadPluginConfig\n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "<-- loadPluginConfig\n");
 
 cleanup:
     slapi_free_search_results_internal(search_pb);
@@ -579,7 +560,7 @@ static int parseConfigEntry(Slapi_Entry *e)
 	   */
 		return PRESENCE_FAILURE;
 	}
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> key [%s] \n",key,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "parseConfigEntry - key [%s] \n",key);
 	/**
 	 * Now create the config entry which will hold all the 
 	 * attributes of a presence vendor
@@ -602,7 +583,7 @@ static int parseConfigEntry(Slapi_Entry *e)
 		toLowerCase(value);
 		PL_HashTableAdd(_IdVattrMapTable, value, map);
 	}
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> nsIMStatusText [%s] \n",value,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "parseConfigEntry - nsIMStatusText [%s] \n",value);
 
 	value = slapi_entry_attr_get_charptr(e, NS_IM_STATUS_GRAPHIC);
 	if (value) {
@@ -614,35 +595,35 @@ static int parseConfigEntry(Slapi_Entry *e)
 		PL_HashTableAdd(_IdVattrMapTable, value, map);
 	}
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> nsIMStatusGraphic [%s] \n",value,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "parseConfigEntry - nsIMStatusGraphic [%s] \n",value);
 
 	value = slapi_entry_attr_get_charptr(e, NS_IM_URL_TEXT);
 	if (value) {
 		entry->textURL = value;
 	}
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> nsIMURLText [%s] \n",value,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "parseConfigEntry - nsIMURLText [%s] \n",value);
 
 	value = slapi_entry_attr_get_charptr(e, NS_IM_URL_GRAPHIC);
 	if (value) {
 		entry->graphicURL = value;
 	}
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> nsIMStatusGraphic [%s] \n",value,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "parseConfigEntry - nsIMStatusGraphic [%s] \n",value);
 
 	value = slapi_entry_attr_get_charptr(e, NS_IM_ON_VALUE_MAP_TEXT);
 	if (value) {
 		entry->onTextMap = value;
 	}
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> nsIMOnValueMapText [%s] \n",value,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "parseConfigEntry - nsIMOnValueMapText [%s] \n",value);
 
 	value = slapi_entry_attr_get_charptr(e, NS_IM_OFF_VALUE_MAP_TEXT);
 	if (value) {
 		entry->offTextMap = value;
 	}
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> nsIMOffValueMapText [%s] \n",value,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "parseConfigEntry - nsIMOffValueMapText [%s] \n",value);
 
 	/**
 	 * Next 3 are binary syntax types so needs special handling
@@ -670,20 +651,20 @@ static int parseConfigEntry(Slapi_Entry *e)
 		entry->requestMethod = value;
 	}
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> nsIMRequestMethod [%s] \n",value,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "parseConfigEntry - nsIMRequestMethod [%s] \n",value);
 
 	value = slapi_entry_attr_get_charptr(e, NS_IM_URL_TEXT_RETURN_TYPE);
 	if (value) {
 		entry->textReturnType = value;
 	}
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> nsIMURLTextReturnType [%s] \n",value,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "parseConfigEntry - nsIMURLTextReturnType [%s] \n",value);
 
 	value = slapi_entry_attr_get_charptr(e, NS_IM_URL_GRAPHIC_RETURN_TYPE);
 	if (value) {
 		entry->graphicReturnType = value;
 	}
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> nsIMURLGraphicReturnType [%s] \n",value,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "parseConfigEntry - nsIMURLGraphicReturnType [%s] \n",value);
 
 	/**
 	 * Finally add the entry to the map table
@@ -705,8 +686,8 @@ static int imIDExists(Slapi_Entry *e, char *type, char **value, _Vmap **map, _Co
 	_ConfigEntry *tEntry = NULL;
 	_Vmap *tMap = NULL;
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> imIDExists \n",0,0,0);	
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> Type [%s] \n",type,0,0);	
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "--> imIDExists \n",0,0,0);	
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "imIDExists - Type [%s] \n",type,0,0);	
 
 	/**
 	 * The public function PL_HashTableLookup modifies the 
@@ -722,8 +703,8 @@ static int imIDExists(Slapi_Entry *e, char *type, char **value, _Vmap **map, _Co
 	   * this should not happen but no harm we just return
 	   */
 		status = PRESENCE_FAILURE;
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PRESENCE_PLUGIN_SUBSYSTEM, 
-			"No hashtable for vattr types\n");
+		slapi_log_error(SLAPI_LOG_ERR, PRESENCE_PLUGIN_SUBSYSTEM, 
+			"imIDExists - No hashtable for vattr types\n");
 		goto bail;
 	}
 	/**
@@ -739,14 +720,14 @@ static int imIDExists(Slapi_Entry *e, char *type, char **value, _Vmap **map, _Co
 		status = PRESENCE_FAILURE;
 		goto bail;
 	}
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> Value [%s] \n",tValue,0,0);	
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "-imIDExists - Value [%s] \n",tValue,0,0);	
 
 	tEntry = PL_HashTableLookupConst(_IdConfigMapTable, tMap->imID);
 	*value	= tValue;
 	*entry	= tEntry;
 	*map	= tMap;
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- imIDExists \n",0,0,0);	
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "<-- imIDExists \n");	
 
 bail:
 	return status;
@@ -760,7 +741,7 @@ static int makeHttpRequest(char *id, _Vmap *map, _ConfigEntry *info, char **BUF,
 	char *urltosend = NULL;
 	int bytesRead;
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> makeHttpRequest:: \n",0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "--> makeHttpRequest\n");
 
 	if (map->syntax == PRESENCE_STRING) {
 		url = info->textURL;
@@ -773,14 +754,14 @@ static int makeHttpRequest(char *id, _Vmap *map, _ConfigEntry *info, char **BUF,
 	}
 	urltosend = replaceIdWithValue(url, map->imID, id);
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> URL [%s] \n",urltosend,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "makeHttpRequest - URL [%s] \n",urltosend);
 	/**
 	 * make an actual HTTP call now
 	 */
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> RequestMethod [%s] \n", info->requestMethod,0,0);
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> Syntax [%d] \n", map->syntax,0,0);
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> TextReturnType [%s] \n", info->textReturnType,0,0);
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> GraphicReturnType [%s] \n", info->graphicReturnType,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "makeHttpRequest - RequestMethod [%s] \n", info->requestMethod);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "makeHttpRequest - Syntax [%d] \n", map->syntax);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "makeHttpRequest - TextReturnType [%s] \n", info->textReturnType);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "makeHttpRequest - GraphicReturnType [%s] \n", info->graphicReturnType);
 	if (!strcasecmp(info->requestMethod, PRESENCE_REQUEST_METHOD_GET)) {
 		if (map->syntax == PRESENCE_STRING) {
 			if (!strcasecmp(info->textReturnType, PRESENCE_TEXT_RETURN_TYPE)) {
@@ -805,8 +786,8 @@ static int makeHttpRequest(char *id, _Vmap *map, _ConfigEntry *info, char **BUF,
 	   * properly checked and throw warning/errors in case
 	   * of any invalid entry
 	   */
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, PRESENCE_PLUGIN_SUBSYSTEM, 
-			"Unknown request type <%s>\n", info->requestMethod);
+		slapi_log_error(SLAPI_LOG_ERR, PRESENCE_PLUGIN_SUBSYSTEM, 
+			"makeHttpRequest - Unknown request type <%s>\n", info->requestMethod);
 		status = PRESENCE_FAILURE;
 		goto bail;
 	}
@@ -817,7 +798,7 @@ static int makeHttpRequest(char *id, _Vmap *map, _ConfigEntry *info, char **BUF,
 	}
 
 bail:
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- makeHttpRequest:: <%d>\n",status,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "<-- makeHttpRequest:: <%d>\n",status,0,0);
 
 	slapi_ch_free((void**)&urltosend);
 	return status;
@@ -889,7 +870,7 @@ static int setIMStatus(char *id, _Vmap *map, _ConfigEntry *info,
 	Slapi_Attr *attr = NULL;
 	const struct berval *tmp = NULL;
 	
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> setIMStatus \n", 0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "--> setIMStatus \n");
 	/**
 	 * we got some data back so lets try to map it to 
 	 * the existing set of on/off data
@@ -932,15 +913,15 @@ static int setIMStatus(char *id, _Vmap *map, _ConfigEntry *info,
 			bval.bv_val = returnedBUF;
 			value1 = slapi_value_new_berval(&bval);
 
-			LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> returned size  [%d] \n", bval.bv_len,0,0);
-			LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> returned value [%s] \n", bval.bv_val,0,0);
+			slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "setIMStatus - returned size  [%d] \n", bval.bv_len);
+			slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "setIMStatus - returned value [%s] \n", bval.bv_val);
 			
 			attr = info->onGraphicMap;
 			if (attr) {
 				slapi_attr_first_value(attr, &value2);
 				tmp = slapi_value_get_berval(value2);
-				LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> Stored size  [%d] \n", tmp->bv_len,0,0);
-				LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> Stored value [%s] \n", tmp->bv_val,0,0);
+				slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "setIMStatus - Stored size  [%d] \n", tmp->bv_len);
+				slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "setIMStatus - Stored value [%s] \n", tmp->bv_val);
 				if (!slapi_value_compare(attr, value1, value2)) {
 					value = slapi_value_new_string(PRESENCE_RETURNED_ON_TEXT);
 				}
@@ -973,7 +954,7 @@ static int setIMStatus(char *id, _Vmap *map, _ConfigEntry *info,
 		   */
 			value = slapi_value_new_string(PRESENCE_RETURNED_ERROR_TEXT);
 		}
-		LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> value [%s] \n", returnedBUF,0,0);
+		slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "setIMStatus - value [%s] \n", returnedBUF);
 	} else {
 	  /**
 		* we had send a request for image
@@ -981,7 +962,7 @@ static int setIMStatus(char *id, _Vmap *map, _ConfigEntry *info,
 		* return instead of analyzing it
 		*/
 		if (!strcasecmp(info->graphicReturnType, PRESENCE_TEXT_RETURN_TYPE)) {
-			LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> value [%s] \n", returnedBUF,0,0);
+			slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "setIMStatus - value [%s] \n", returnedBUF);
 			if (!strcasecmp(info->requestMethod, PRESENCE_REQUEST_METHOD_REDIRECT)) {
 			  /**
 			   * a redirect case in which we should probably have a 
@@ -1016,7 +997,7 @@ static int setIMStatus(char *id, _Vmap *map, _ConfigEntry *info,
 			   */
 			}
 		} else {
-			LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> value [%s] \n", returnedBUF,0,0);
+			slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "setIMStatus - value [%s] \n", returnedBUF);
 			bval.bv_len = size;
 			bval.bv_val = returnedBUF;
 			value = slapi_value_new_berval(&bval);
@@ -1037,7 +1018,7 @@ static int setIMStatus(char *id, _Vmap *map, _ConfigEntry *info,
 	if (value && map->syntax == PRESENCE_STRING) {
 		slapi_value_free(&value);
 	}
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- setIMStatus \n", 0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "<-- setIMStatus \n");
 	
 	return status;
 }
@@ -1056,7 +1037,7 @@ static int setTypes(PLHashEntry *he, PRIntn i, void *arg)
 	_Vmap *map  = (_Vmap *)he->value;
 	char *id = map->imID;
 
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "--> setTypes \n", 0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "--> setTypes \n");
 
 	status = slapi_vattr_values_get_sp(NULL, args->entry, id, &results, &type_name_disposition, &actual_type_name, 0, &free_flags);
 	if(status == PRESENCE_SUCCESS)
@@ -1071,9 +1052,9 @@ static int setTypes(PLHashEntry *he, PRIntn i, void *arg)
 
 		slapi_vattr_values_free(&results, &actual_type_name, free_flags);
 
-		LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> ID [%s] Type[%s]\n", actual_type_name,type,0);
+		slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "setTypes - ID [%s] Type[%s]\n", actual_type_name,type);
 	}
-	LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "<-- setTypes \n", 0,0,0);
+	slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "<-- setTypes \n");
 
 	return HT_ENUMERATE_NEXT;
 }
@@ -1091,15 +1072,15 @@ logGraphicAttributeValue( Slapi_Attr *attr, const char *attrname )
 		if (v) {
 			char	*ldifvalue;
 
-			LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> %s size [%d] \n",
-					attrname,v->bv_len,0);
+			slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "logGraphicAttributeValue - %s size [%d] \n",
+					attrname,v->bv_len);
 
 			ldifvalue = ldif_type_and_value_with_options(
 					(char *)attrname,	/* XXX: had to cast away const */
 					v->bv_val, v->bv_len, 0 );
 			if ( NULL != ldifvalue ) {
-				LDAPDebug(LDAP_DEBUG_PLUGIN, LOG_DEBUG, "----------> %s value [\n%s]\n",
-						attrname,ldifvalue,0);
+				slapi_log_error(SLAPI_LOG_PLUGIN, PRESENCE_PLUGIN_SUBSYSTEM, "logGraphicAttributeValue - %s value [\n%s]\n",
+						attrname,ldifvalue);
 				slapi_ch_free_string( &ldifvalue );
 			}
 		}

ldap/servers/plugins/pwdstorage/md5_pwd.c

@@ -40,7 +40,7 @@ md5_pw_cmp( const char *userpwd, const char *dbpwd )
 
    ctx = PK11_CreateDigestContext(SEC_OID_MD5);
    if (ctx == NULL) {
-	   slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, MD5_SUBSYSTEM_NAME,
+	   slapi_log_error(SLAPI_LOG_PLUGIN, MD5_SUBSYSTEM_NAME,
 					   "Could not create context for digest operation for password compare");
 	   goto loser;
    }
@@ -59,7 +59,7 @@ md5_pw_cmp( const char *userpwd, const char *dbpwd )
    if (bver) {
 	   rc = strcmp(bver,dbpwd);
    } else {
-	   slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, MD5_SUBSYSTEM_NAME,
+	   slapi_log_error(SLAPI_LOG_PLUGIN, MD5_SUBSYSTEM_NAME,
 					   "Could not base64 encode hashed value for password compare");
    }
 loser:
@@ -78,7 +78,7 @@ md5_pw_enc( const char *pwd )
 
    ctx = PK11_CreateDigestContext(SEC_OID_MD5);
    if (ctx == NULL) {
-	   slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, MD5_SUBSYSTEM_NAME,
+	   slapi_log_error(SLAPI_LOG_PLUGIN, MD5_SUBSYSTEM_NAME,
 					   "Could not create context for digest operation for password encoding");
 	   return NULL;
    }
@@ -97,7 +97,7 @@ md5_pw_enc( const char *pwd )
 	   enc = slapi_ch_smprintf("%c%s%c%s", PWD_HASH_PREFIX_START, MD5_SCHEME_NAME,
 							   PWD_HASH_PREFIX_END, bver );
    } else {
-	   slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, MD5_SUBSYSTEM_NAME,
+	   slapi_log_error(SLAPI_LOG_PLUGIN, MD5_SUBSYSTEM_NAME,
 					   "Could not base64 encode hashed value for password encoding");
    }
 	   

ldap/servers/plugins/pwdstorage/pwd_init.c

@@ -51,7 +51,7 @@ sha_pwd_storage_scheme_init( Slapi_PBlock *pb )
 {
 	int	rc;
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "=> sha_pwd_storage_scheme_init\n" );
+	slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "=> sha_pwd_storage_scheme_init\n" );
 
 	rc = slapi_pblock_set( pb, SLAPI_PLUGIN_VERSION,
 	    (void *) SLAPI_PLUGIN_VERSION_01 );
@@ -64,7 +64,7 @@ sha_pwd_storage_scheme_init( Slapi_PBlock *pb )
 	rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_PWD_STORAGE_SCHEME_NAME,
 	    "SHA" );
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "<= sha_pwd_storage_scheme_init %d\n\n", rc );
+	slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "<= sha_pwd_storage_scheme_init %d\n\n", rc );
 
 	return( rc );
 }
@@ -74,7 +74,7 @@ ssha_pwd_storage_scheme_init( Slapi_PBlock *pb )
 {
 	int	rc;
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "=> ssha_pwd_storage_scheme_init\n" );
+	slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "=> ssha_pwd_storage_scheme_init\n" );
 
 	rc = slapi_pblock_set( pb, SLAPI_PLUGIN_VERSION,
 	    (void *) SLAPI_PLUGIN_VERSION_01 );
@@ -87,7 +87,7 @@ ssha_pwd_storage_scheme_init( Slapi_PBlock *pb )
 	rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_PWD_STORAGE_SCHEME_NAME,
 	    "SSHA" );
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "<= ssha_pwd_storage_scheme_init %d\n\n", rc );
+	slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "<= ssha_pwd_storage_scheme_init %d\n\n", rc );
 	return( rc );
 }
 
@@ -96,7 +96,7 @@ sha256_pwd_storage_scheme_init( Slapi_PBlock *pb )
 {
         int     rc;
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "=> sha256_pwd_storage_scheme_init\n" );
+        slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "=> sha256_pwd_storage_scheme_init\n" );
 
         rc = slapi_pblock_set( pb, SLAPI_PLUGIN_VERSION,
             (void *) SLAPI_PLUGIN_VERSION_01 );
@@ -109,7 +109,7 @@ sha256_pwd_storage_scheme_init( Slapi_PBlock *pb )
         rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_PWD_STORAGE_SCHEME_NAME,
             "SHA256" );
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "<= sha256_pwd_storage_scheme_init %d\n\n", rc );
+        slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "<= sha256_pwd_storage_scheme_init %d\n\n", rc );
 
         return( rc );
 }
@@ -119,7 +119,7 @@ ssha256_pwd_storage_scheme_init( Slapi_PBlock *pb )
 {
         int     rc;
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "=> ssha256_pwd_storage_scheme_init\n" );
+        slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "=> ssha256_pwd_storage_scheme_init\n" );
 
         rc = slapi_pblock_set( pb, SLAPI_PLUGIN_VERSION,
             (void *) SLAPI_PLUGIN_VERSION_01 );
@@ -132,7 +132,7 @@ ssha256_pwd_storage_scheme_init( Slapi_PBlock *pb )
         rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_PWD_STORAGE_SCHEME_NAME,
             "SSHA256" );
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "<= ssha256_pwd_storage_scheme_init %d\n\n", rc );
+        slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "<= ssha256_pwd_storage_scheme_init %d\n\n", rc );
         return( rc );
 }
 
@@ -141,7 +141,7 @@ sha384_pwd_storage_scheme_init( Slapi_PBlock *pb )
 {
         int     rc;
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "=> sha384_pwd_storage_scheme_init\n" );
+        slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "=> sha384_pwd_storage_scheme_init\n" );
 
         rc = slapi_pblock_set( pb, SLAPI_PLUGIN_VERSION,
             (void *) SLAPI_PLUGIN_VERSION_01 );
@@ -154,7 +154,7 @@ sha384_pwd_storage_scheme_init( Slapi_PBlock *pb )
         rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_PWD_STORAGE_SCHEME_NAME,
             "SHA384" );
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "<= sha384_pwd_storage_scheme_init %d\n\n", rc );
+        slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "<= sha384_pwd_storage_scheme_init %d\n\n", rc );
 
         return( rc );
 }
@@ -164,7 +164,7 @@ ssha384_pwd_storage_scheme_init( Slapi_PBlock *pb )
 {
         int     rc;
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "=> ssha384_pwd_storage_scheme_init\n" );
+        slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "=> ssha384_pwd_storage_scheme_init\n" );
 
         rc = slapi_pblock_set( pb, SLAPI_PLUGIN_VERSION,
             (void *) SLAPI_PLUGIN_VERSION_01 );
@@ -177,7 +177,7 @@ ssha384_pwd_storage_scheme_init( Slapi_PBlock *pb )
         rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_PWD_STORAGE_SCHEME_NAME,
             "SSHA384" );
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "<= ssha384_pwd_storage_scheme_init %d\n\n", rc );
+        slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "<= ssha384_pwd_storage_scheme_init %d\n\n", rc );
         return( rc );
 }
 
@@ -186,7 +186,7 @@ sha512_pwd_storage_scheme_init( Slapi_PBlock *pb )
 {
         int     rc;
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "=> sha512_pwd_storage_scheme_init\n" );
+        slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "=> sha512_pwd_storage_scheme_init\n" );
 
         rc = slapi_pblock_set( pb, SLAPI_PLUGIN_VERSION,
             (void *) SLAPI_PLUGIN_VERSION_01 );
@@ -199,7 +199,7 @@ sha512_pwd_storage_scheme_init( Slapi_PBlock *pb )
         rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_PWD_STORAGE_SCHEME_NAME,
             "SHA512" );
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "<= sha512_pwd_storage_scheme_init %d\n\n", rc );
+        slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "<= sha512_pwd_storage_scheme_init %d\n\n", rc );
 
         return( rc );
 }
@@ -209,7 +209,7 @@ ssha512_pwd_storage_scheme_init( Slapi_PBlock *pb )
 {
         int     rc;
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "=> ssha512_pwd_storage_scheme_init\n" );
+        slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "=> ssha512_pwd_storage_scheme_init\n" );
 
         rc = slapi_pblock_set( pb, SLAPI_PLUGIN_VERSION,
             (void *) SLAPI_PLUGIN_VERSION_01 );
@@ -222,7 +222,7 @@ ssha512_pwd_storage_scheme_init( Slapi_PBlock *pb )
         rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_PWD_STORAGE_SCHEME_NAME,
             "SSHA512" );
 
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "<= ssha512_pwd_storage_scheme_init %d\n\n", rc );
+        slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "<= ssha512_pwd_storage_scheme_init %d\n\n", rc );
         return( rc );
 }
 
@@ -231,7 +231,7 @@ crypt_pwd_storage_scheme_init( Slapi_PBlock *pb )
 {
 	int	rc;
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "=> crypt_pwd_storage_scheme_init\n" );
+	slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "=> crypt_pwd_storage_scheme_init\n" );
 
 	crypt_init();
 	rc = slapi_pblock_set( pb, SLAPI_PLUGIN_VERSION,
@@ -245,7 +245,7 @@ crypt_pwd_storage_scheme_init( Slapi_PBlock *pb )
 	rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_PWD_STORAGE_SCHEME_NAME,
 	    "CRYPT" );
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "<= crypt_pwd_storage_scheme_init %d\n\n", rc );
+	slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "<= crypt_pwd_storage_scheme_init %d\n\n", rc );
 	return( rc );
 }
 
@@ -254,7 +254,7 @@ clear_pwd_storage_scheme_init( Slapi_PBlock *pb )
 {
 	int	rc;
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "=> clear_pwd_storage_scheme_init\n" );
+	slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "=> clear_pwd_storage_scheme_init\n" );
 
 	rc = slapi_pblock_set( pb, SLAPI_PLUGIN_VERSION,
 	    (void *) SLAPI_PLUGIN_VERSION_01 );
@@ -267,7 +267,7 @@ clear_pwd_storage_scheme_init( Slapi_PBlock *pb )
 	rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_PWD_STORAGE_SCHEME_NAME,
 	    "CLEAR" );
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "<= clear_pwd_storage_scheme_init %d\n\n", rc );
+	slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "<= clear_pwd_storage_scheme_init %d\n\n", rc );
 	return( rc );
 }
 
@@ -276,7 +276,7 @@ ns_mta_md5_pwd_storage_scheme_init( Slapi_PBlock *pb )
 {
 	int	rc;
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "=> ns_mta_md5_pwd_storage_scheme_init\n" );
+	slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "=> ns_mta_md5_pwd_storage_scheme_init\n" );
 
 	rc = slapi_pblock_set( pb, SLAPI_PLUGIN_VERSION,
 	    (void *) SLAPI_PLUGIN_VERSION_01 );
@@ -289,7 +289,7 @@ ns_mta_md5_pwd_storage_scheme_init( Slapi_PBlock *pb )
 	rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_PWD_STORAGE_SCHEME_NAME,
 	    "NS-MTA-MD5" );
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "<= ns_mta_md5_pwd_storage_scheme_init %d\n\n", rc );
+	slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "<= ns_mta_md5_pwd_storage_scheme_init %d\n\n", rc );
 	return( rc );
 }
 
@@ -298,7 +298,7 @@ md5_pwd_storage_scheme_init( Slapi_PBlock *pb )
 {
 	int     rc;
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "=> md5_pwd_storage_scheme_init\n" );
+	slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "=> md5_pwd_storage_scheme_init\n" );
 
 	rc = slapi_pblock_set( pb, SLAPI_PLUGIN_VERSION,
 						   (void *) SLAPI_PLUGIN_VERSION_01 );
@@ -311,7 +311,7 @@ md5_pwd_storage_scheme_init( Slapi_PBlock *pb )
 	rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_PWD_STORAGE_SCHEME_NAME,
 							"MD5" );
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "<= md5_pwd_storage_scheme_init %d\n\n", rc );
+	slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "<= md5_pwd_storage_scheme_init %d\n\n", rc );
 	return( rc );
 }
 
@@ -320,7 +320,7 @@ smd5_pwd_storage_scheme_init( Slapi_PBlock *pb )
 {
 	int     rc;
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "=> smd5_pwd_storage_scheme_init\n" );
+	slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "=> smd5_pwd_storage_scheme_init\n" );
 
 	rc = slapi_pblock_set( pb, SLAPI_PLUGIN_VERSION,
 							(void *) SLAPI_PLUGIN_VERSION_01 );
@@ -333,6 +333,6 @@ smd5_pwd_storage_scheme_init( Slapi_PBlock *pb )
 	rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_PWD_STORAGE_SCHEME_NAME,
 							"SMD5" );
 
-	slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "<= smd5_pwd_storage_scheme_init %d\n\n", rc );
+	slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "<= smd5_pwd_storage_scheme_init %d\n\n", rc );
 	return( rc );
 }

ldap/servers/plugins/pwdstorage/sha_pwd.c

@@ -99,7 +99,7 @@ sha_pw_cmp (const char *userpwd, const char *dbpwd, unsigned int shaLen )
     }
     hashresult = PL_Base64Decode( dbpwd, dbpwd_len, dbhash );
     if (NULL == hashresult) {
-        slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, hasherrmsg, schemeName, dbpwd );
+        slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, hasherrmsg, schemeName, dbpwd );
         goto loser;
     } else if ( hash_len >= shaLen ) { /* must be salted */
         salt.bv_val = (void*)(dbhash + shaLen); /* salt starts after hash value */
@@ -108,14 +108,14 @@ sha_pw_cmp (const char *userpwd, const char *dbpwd, unsigned int shaLen )
         salt.bv_val = (void*)dbhash;
         salt.bv_len = OLD_SALT_LENGTH;
     } else { /* unsupported, invalid BASE64 (hash_len < 0), or similar */
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, hasherrmsg, schemeName, dbpwd );
+                slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, hasherrmsg, schemeName, dbpwd );
         goto loser;
     }
 
     /* hash the user's key */
     memset( userhash, 0, sizeof(userhash) );
     if ( sha_salted_hash( userhash, userpwd, &salt, secOID ) != SECSuccess ) {
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, plugin_name, "sha_pw_cmp: sha_salted_hash() failed\n");
+                slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name, "sha_pw_cmp: sha_salted_hash() failed\n");
         goto loser;
     }
 

ldap/servers/plugins/pwdstorage/smd5_pwd.c

@@ -44,7 +44,7 @@ smd5_pw_cmp( const char *userpwd, const char *dbpwd )
 
    ctx = PK11_CreateDigestContext(SEC_OID_MD5);
    if (ctx == NULL) {
-	   slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, SALTED_MD5_SUBSYSTEM_NAME,
+	   slapi_log_error(SLAPI_LOG_PLUGIN, SALTED_MD5_SUBSYSTEM_NAME,
 					   "Could not create context for digest operation for password compare");
 	   goto loser;
    }
@@ -62,7 +62,7 @@ smd5_pw_cmp( const char *userpwd, const char *dbpwd )
 
    hashresult = PL_Base64Decode( dbpwd, 0, dbhash );
    if (NULL == hashresult) {
-      slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, SALTED_MD5_SUBSYSTEM_NAME,
+      slapi_log_error(SLAPI_LOG_PLUGIN, SALTED_MD5_SUBSYSTEM_NAME,
             "smd5_pw_cmp: userPassword \"%s\" is the wrong length "
             "or is not properly encoded BASE64\n", dbpwd );
       goto loser;
@@ -101,7 +101,7 @@ smd5_pw_enc( const char *pwd )
 
    ctx = PK11_CreateDigestContext(SEC_OID_MD5);
    if (ctx == NULL) {
-	   slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, SALTED_MD5_SUBSYSTEM_NAME,
+	   slapi_log_error(SLAPI_LOG_PLUGIN, SALTED_MD5_SUBSYSTEM_NAME,
 					   "Could not create context for digest operation for password encoding");
 	   return NULL;
    }
@@ -129,7 +129,7 @@ smd5_pw_enc( const char *pwd )
 	   enc = slapi_ch_smprintf("%c%s%c%s", PWD_HASH_PREFIX_START, SALTED_MD5_SCHEME_NAME,
 							   PWD_HASH_PREFIX_END, bver );
    } else {
-	   slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, SALTED_MD5_SUBSYSTEM_NAME,
+	   slapi_log_error(SLAPI_LOG_PLUGIN, SALTED_MD5_SUBSYSTEM_NAME,
 					   "Could not base64 encode hashed value for password encoding");
    }
 	   

ldap/servers/plugins/referint/referint.c

@@ -166,7 +166,7 @@ referint_postop_init( Slapi_PBlock *pb )
     PR_ASSERT (referint_plugin_identity);
 
     if((config = (referint_config *)slapi_ch_calloc (1, sizeof (referint_config))) == NULL){
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "referint_postop_init failed to "
+        slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "referint_postop_init  - Failed to "
                "allocate configuration\n" );
         return ( -1 );
     }
@@ -202,24 +202,24 @@ referint_postop_init( Slapi_PBlock *pb )
 		for (i=0; plugin_attr_values[i];i++);
 		plugin_EntryScope = (Slapi_DN **)slapi_ch_calloc(sizeof(Slapi_DN *),i+1);
 		for (i=0; plugin_attr_values[i];i++) {
-            		if (slapi_dn_syntax_check(NULL, plugin_attr_values[i], 1) == 1) {
-                		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                        		"Error: Ignoring invalid DN used as plugin entry scope: [%s]\n",
-                        		plugin_attr_values[i]);
-        			slapi_ch_free_string(&plugin_attr_values[i]);
-            		} else {
-                		plugin_EntryScope[j++] = slapi_sdn_new_dn_passin(plugin_attr_values[i]);
-            		}
+			if (slapi_dn_syntax_check(NULL, plugin_attr_values[i], 1) == 1) {
+				slapi_log_error(SLAPI_LOG_WARNING, REFERINT_PLUGIN_SUBSYSTEM,
+						"referint_postop_init - Ignoring invalid DN used as plugin entry scope: [%s]\n",
+						plugin_attr_values[i]);
+				slapi_ch_free_string(&plugin_attr_values[i]);
+			} else {
+				plugin_EntryScope[j++] = slapi_sdn_new_dn_passin(plugin_attr_values[i]);
+			}
 		}
 		slapi_ch_free((void**)&plugin_attr_values);
         }
         plugin_attr_value = slapi_entry_attr_get_charptr(plugin_entry, "nsslapd-pluginExcludeEntryScope");
         if(plugin_attr_value) {
             if (slapi_dn_syntax_check(NULL, plugin_attr_value, 1) == 1) {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                        "Error: Ignoring invalid DN used as plugin exclude entry scope: [%s]\n",
+                slapi_log_error(SLAPI_LOG_WARNING, REFERINT_PLUGIN_SUBSYSTEM,
+                        "referint_postop_init - Ignoring invalid DN used as plugin exclude entry scope: [%s]\n",
                         plugin_attr_value);
-        	slapi_ch_free_string(&plugin_attr_value);
+                slapi_ch_free_string(&plugin_attr_value);
             } else {
                 plugin_ExcludeEntryScope = slapi_sdn_new_dn_passin(plugin_attr_value);
             }
@@ -228,10 +228,10 @@ referint_postop_init( Slapi_PBlock *pb )
         plugin_attr_value = slapi_entry_attr_get_charptr(plugin_entry, "nsslapd-pluginContainerScope");
         if(plugin_attr_value) {
             if (slapi_dn_syntax_check(NULL, plugin_attr_value, 1) == 1) {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                        "Error: Ignoring invalid DN used as plugin container scope: [%s]\n",
+                slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+                        "referint_postop_init - Ignoring invalid DN used as plugin container scope: [%s]\n",
                         plugin_attr_value);
-        	slapi_ch_free_string(&plugin_attr_value);
+                slapi_ch_free_string(&plugin_attr_value);
             } else {
                 plugin_ContainerScope = slapi_sdn_new_dn_passin(plugin_attr_value);
             }
@@ -248,7 +248,7 @@ referint_postop_init( Slapi_PBlock *pb )
          slapi_pblock_set( pb, SLAPI_PLUGIN_START_FN, (void *) referint_postop_start ) != 0 ||
          slapi_pblock_set( pb, SLAPI_PLUGIN_CLOSE_FN, (void *) referint_postop_close ) != 0)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "referint_postop_init failed\n" );
+        slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "referint_postop_init - Failed\n" );
         return( -1 );
     }
 
@@ -263,7 +263,7 @@ referint_postop_init( Slapi_PBlock *pb )
                               NULL,     /* ? */
                               referint_plugin_identity   /* access control */))
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "referint_preop_init failed\n" );
+        slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "referint_postop_init - Preop registration failed\n" );
         return ( -1 );
     }
 
@@ -300,13 +300,13 @@ load_config(Slapi_PBlock *pb, Slapi_Entry *config_entry, int apply)
     slapi_rwlock_wrlock(config_rwlock);
 
     if(config == NULL){
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+        slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
     	                "load_config: config is NULL\n" );
         rc = SLAPI_PLUGIN_FAILURE;
         goto done;
     }
     if((tmp_config = (referint_config *)slapi_ch_calloc (1, sizeof (referint_config))) == NULL){
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "load_config failed to "
+        slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "load_config - Failed to "
                "allocate configuration\n" );
         rc = SLAPI_PLUGIN_FAILURE;
         goto done;
@@ -338,19 +338,19 @@ load_config(Slapi_PBlock *pb, Slapi_Entry *config_entry, int apply)
     if(new_config_present){
         /* Verify we have everything we need */
         if(tmp_config->delay == -1){
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "Plugin configuration is missing %s\n",
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "load_config - Plugin configuration is missing %s\n",
                              REFERINT_ATTR_DELAY);
             rc = SLAPI_PLUGIN_FAILURE;
         } else if (!tmp_config->logfile){
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "Plugin configuration is missing %s\n",
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "load_config - Plugin configuration is missing %s\n",
                              REFERINT_ATTR_LOGFILE);
             rc = SLAPI_PLUGIN_FAILURE;
         } else if (tmp_config->logchanges == -1){
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "Plugin configuration is missing %s\n",
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "load_config - Plugin configuration is missing %s\n",
                              REFERINT_ATTR_LOGCHANGES);
             rc = SLAPI_PLUGIN_FAILURE;
         } else if (!tmp_config->attrs){
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "Plugin configuration is missing %s\n",
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "load_config - Plugin configuration is missing %s\n",
                              REFERINT_ATTR_MEMBERSHIP);
             rc = SLAPI_PLUGIN_FAILURE;
         }
@@ -359,20 +359,20 @@ load_config(Slapi_PBlock *pb, Slapi_Entry *config_entry, int apply)
          * We are using the old plugin arg configuration, get the args
          */
         if ( slapi_pblock_get( pb, SLAPI_PLUGIN_ARGC, &argc ) != 0) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                    "referint_postop failed to get argc\n" );
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+                    "load_config - Failed to get argc\n" );
             rc = SLAPI_PLUGIN_FAILURE;
             goto done;
         }
         if ( slapi_pblock_get( pb, SLAPI_PLUGIN_ARGV, &argv ) != 0) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                    "referint_postop failed to get argv\n" );
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+                    "load_config - Failed to get argv\n" );
             rc = SLAPI_PLUGIN_FAILURE;
             goto done;
         }
         if(argv == NULL){
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                    "referint_postop_del, args are NULL\n" );
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+                    "load_config - args are NULL\n" );
             rc = SLAPI_PLUGIN_FAILURE;
             goto done;
         }
@@ -389,8 +389,8 @@ load_config(Slapi_PBlock *pb, Slapi_Entry *config_entry, int apply)
                 slapi_ch_array_add(&tmp_config->attrs, slapi_ch_strdup(argv[i]));
             }
         } else {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                    "referint_postop insufficient arguments supplied\n" );
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+                    "load_config - Insufficient arguments supplied\n" );
             rc = SLAPI_PLUGIN_FAILURE;
             goto done;
         }
@@ -431,7 +431,8 @@ referint_postop_modify(Slapi_PBlock *pb)
     if (referint_sdn_config_cmp(sdn) == 0 && slapi_sdn_compare(sdn, referint_get_plugin_area()))
     {
         if( SLAPI_PLUGIN_FAILURE == load_config(pb, entry, 1)){
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "Failed to update configuration.\n");
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "referint_postop_modify - "
+            	"Failed to update configuration.\n");
             return SLAPI_PLUGIN_FAILURE;
         }
     } else if (slapi_sdn_compare(sdn, referint_get_plugin_area()) == 0){
@@ -442,7 +443,7 @@ referint_postop_modify(Slapi_PBlock *pb)
         if((config_area = slapi_entry_attr_get_charptr(entry, SLAPI_PLUGIN_SHARED_CONFIG_AREA))){
             rc = slapi_dn_syntax_check(pb, config_area, 1);
             if (rc) { /* syntax check failed */
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "referint_postop_modify: "
+                slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "referint_postop_modify - "
                                 "%s does not contain a valid DN (%s)\n",
                                 SLAPI_PLUGIN_SHARED_CONFIG_AREA, config_area);
                 rc = LDAP_INVALID_DN_SYNTAX;
@@ -453,8 +454,8 @@ referint_postop_modify(Slapi_PBlock *pb)
             if (LDAP_SUCCESS != result) {
                 if (result == LDAP_NO_SUCH_OBJECT) {
                     /* log an error and use the plugin entry for the config */
-                    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, REFERINT_PLUGIN_SUBSYSTEM,
-                            "referint_postop_modify: Config entry \"%s\" does "
+                    slapi_log_error(SLAPI_LOG_PLUGIN, REFERINT_PLUGIN_SUBSYSTEM,
+                            "referint_postop_modify - Config entry \"%s\" does "
                             "not exist.\n", config_area);
                     rc = LDAP_OPERATIONS_ERROR;
                     goto bail;
@@ -463,8 +464,8 @@ referint_postop_modify(Slapi_PBlock *pb)
                 if(e){
                     config_e = e;
                 } else {
-                    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, REFERINT_PLUGIN_SUBSYSTEM,
-                            "referint_postop_modify: Config entry \"%s\" was not located.\n", config_area);
+                    slapi_log_error(SLAPI_LOG_PLUGIN, REFERINT_PLUGIN_SUBSYSTEM,
+                            "referint_postop_modify - Config entry \"%s\" was not located.\n", config_area);
                     rc = LDAP_OPERATIONS_ERROR;
                     goto bail;
                 }
@@ -617,8 +618,8 @@ referint_postop_del( Slapi_PBlock *pb )
          slapi_pblock_get( pb, SLAPI_DELETE_TARGET_SDN, &sdn ) != 0  ||
          slapi_pblock_get(pb, SLAPI_PLUGIN_OPRETURN, &oprc) != 0)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-            "referint_postop_del: could not get parameters\n" );
+        slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+            "referint_postop_del - Could not get parameters\n" );
         return SLAPI_PLUGIN_FAILURE;
     }
     /*
@@ -670,8 +671,8 @@ referint_postop_modrdn( Slapi_PBlock *pb )
          slapi_pblock_get( pb, SLAPI_MODRDN_NEWSUPERIOR_SDN, &newsuperior ) != 0 ||
          slapi_pblock_get( pb, SLAPI_PLUGIN_OPRETURN, &oprc) != 0 )
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-            "referint_postop_modrdn: could not get parameters\n" );
+        slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+            "referint_postop_modrdn - Could not get parameters\n" );
         return SLAPI_PLUGIN_FAILURE;
     }
     /*
@@ -791,8 +792,8 @@ _update_one_per_mod(Slapi_DN *entrySDN,      /* DN of the searched entry */
         list_of_mods[1] = NULL;
         rc = _do_modify(mod_pb, entrySDN, list_of_mods);
         if (rc) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                "_update_one_value: entry %s: deleting \"%s: %s\" failed (%d)"
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+                "_update_one_per_mod - Entry %s: deleting \"%s: %s\" failed (%d)"
                 "\n", slapi_sdn_get_dn(entrySDN), attrName, slapi_sdn_get_dn(origDN), rc);
         }
     } else {
@@ -802,15 +803,15 @@ _update_one_per_mod(Slapi_DN *entrySDN,      /* DN of the searched entry */
         Slapi_Value *v = NULL;
 
         if (NULL == origDN) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                            "_update_one_value: NULL dn was passed\n");
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+                            "_update_one_per_mod - NULL dn was passed\n");
             goto bail;
         }
         /* need to put together rdn into a dn */
         dnParts = slapi_ldap_explode_dn( slapi_sdn_get_dn(origDN), 0 );
         if (NULL == dnParts) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                            "_update_one_value: failed to explode dn %s\n",
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+                            "_update_one_per_mod - Failed to explode dn %s\n",
                             slapi_sdn_get_dn(origDN));
             goto bail;
         }
@@ -881,8 +882,8 @@ _update_one_per_mod(Slapi_DN *entrySDN,      /* DN of the searched entry */
                 list_of_mods[2] = NULL;
                 rc = _do_modify(mod_pb, entrySDN, list_of_mods);
                 if (rc) {
-                    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                        "_update_one_value: entry %s: replacing \"%s: %s\" "
+                    slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+                        "_update_one_per_mod - Entry %s: replacing \"%s: %s\" "
                         "with \"%s: %s\" failed (%d)\n",
                         slapi_sdn_get_dn(entrySDN), attrName, 
                         slapi_sdn_get_dn(origDN), attrName, newDN, rc);
@@ -911,8 +912,8 @@ _update_one_per_mod(Slapi_DN *entrySDN,      /* DN of the searched entry */
                 list_of_mods[2] = NULL;
                 rc = _do_modify(mod_pb, entrySDN, list_of_mods);
                 if (rc) {
-                    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                        "_update_one_value: entry %s: replacing \"%s: %s\" "
+                    slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+                        "_update_one_per_mod - Entry %s: replacing \"%s: %s\" "
                         "with \"%s: %s\" failed (%d)\n",
                         slapi_sdn_get_dn(entrySDN), attrName, sval, attrName, newvalue, rc);
                 }
@@ -974,8 +975,8 @@ _update_all_per_mod(Slapi_DN *entrySDN,      /* DN of the searched entry */
         mods[1] = NULL;
         rc = _do_modify(mod_pb, entrySDN, mods);
         if (rc) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                "_update_all_per_mod: entry %s: deleting \"%s: %s\" failed (%d)"
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+                "_update_all_per_mod - Entry %s: deleting \"%s: %s\" failed (%d)"
                 "\n", slapi_sdn_get_dn(entrySDN), attrName, slapi_sdn_get_dn(origDN), rc);
         }
     } else {
@@ -985,15 +986,15 @@ _update_all_per_mod(Slapi_DN *entrySDN,      /* DN of the searched entry */
         Slapi_Value *v = NULL;
 
         if (NULL == origDN) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                            "_update_all_per_mod: NULL dn was passed\n");
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+                            "_update_all_per_mod - NULL dn was passed\n");
             goto bail;
         }
         /* need to put together rdn into a dn */
         dnParts = slapi_ldap_explode_dn( slapi_sdn_get_dn(origDN), 0 );
         if (NULL == dnParts) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                            "_update_all_per_mod: failed to explode dn %s\n",
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+                            "_update_all_per_mod - Failed to explode dn %s\n",
                             slapi_sdn_get_dn(origDN));
             goto bail;
         }
@@ -1069,8 +1070,8 @@ _update_all_per_mod(Slapi_DN *entrySDN,      /* DN of the searched entry */
         }
         rc = _do_modify(mod_pb, entrySDN, slapi_mods_get_ldapmods_byref(smods));
         if (rc) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                        "_update_all_per_mod: entry %s failed (%d)\n",
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+                        "_update_all_per_mod - Entry %s failed (%d)\n",
                         slapi_sdn_get_dn(entrySDN), rc);
         }
 
@@ -1219,8 +1220,8 @@ update_integrity(Slapi_DN *origSDN,
                     }
                 } else {
                     if (isFatalSearchError(search_result)){
-                        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                            "update_integrity search (base=%s filter=%s) returned "
+                        slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+                            "update_integrity - Search (base=%s filter=%s) returned "
                             "error %d\n", search_base, filter, search_result);
                         rc = SLAPI_PLUGIN_FAILURE;
                         goto free_and_return;
@@ -1267,7 +1268,7 @@ int referint_postop_start( Slapi_PBlock *pb)
     int rc = 0;
 
     if((config_rwlock = slapi_new_rwlock()) == NULL){
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "referint_postop_init failed to "
+        slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "referint_postop_start - Failed to "
                 "create rwlock.\n" );
         return ( -1 );
     }
@@ -1280,7 +1281,7 @@ int referint_postop_start( Slapi_PBlock *pb)
     {
         rc = slapi_dn_syntax_check(pb, config_area, 1);
         if (rc) { /* syntax check failed */
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "referint_postop_start: "
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "referint_postop_start - "
                             "%s does not contain a valid DN (%s)\n",
                             SLAPI_PLUGIN_SHARED_CONFIG_AREA, config_area);
             rc = LDAP_INVALID_DN_SYNTAX;
@@ -1291,8 +1292,8 @@ int referint_postop_start( Slapi_PBlock *pb)
         if (LDAP_SUCCESS != result) {
             if (result == LDAP_NO_SUCH_OBJECT) {
                 /* log an error and use the plugin entry for the config */
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, REFERINT_PLUGIN_SUBSYSTEM,
-                        "referint_postop_start: Config entry \"%s\" does "
+                slapi_log_error(SLAPI_LOG_PLUGIN, REFERINT_PLUGIN_SUBSYSTEM,
+                        "referint_postop_start -Config entry \"%s\" does "
                         "not exist.\n", config_area);
                 rc = -1;
                 goto bail;
@@ -1301,8 +1302,8 @@ int referint_postop_start( Slapi_PBlock *pb)
             if(e){
                 config_e = e;
             } else {
-                slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, REFERINT_PLUGIN_SUBSYSTEM,
-                        "referint_postop_start: Config entry \"%s\" was not located.\n", config_area);
+                slapi_log_error(SLAPI_LOG_PLUGIN, REFERINT_PLUGIN_SUBSYSTEM,
+                        "referint_postop_start - Config entry \"%s\" was not located.\n", config_area);
                 rc = -1;
                 goto bail;
             }
@@ -1338,8 +1339,8 @@ int referint_postop_start( Slapi_PBlock *pb)
                            PR_UNJOINABLE_THREAD,
                            SLAPD_DEFAULT_THREAD_STACKSIZE);
         if ( referint_tid == NULL ) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                "referint_postop_start PR_CreateThread failed\n" );
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+                "referint_postop_start - PR_CreateThread failed\n" );
             exit( 1 );
         }
     }
@@ -1455,7 +1456,8 @@ referint_thread_func(void *arg)
             if (strcasecmp(ptoken, "NULL") != 0) {
                 /* Set the bind DN in the thread data */
                 if(slapi_td_set_dn(slapi_ch_strdup(ptoken))){
-                    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,"Failed to set thread data\n");
+                    slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,"referint_thread_func - "
+                    	"Failed to set thread data\n");
                 }
             }
 
@@ -1470,8 +1472,8 @@ referint_thread_func(void *arg)
 
         /* remove the original file */
         if( PR_SUCCESS != PR_Delete(logfilename) ){
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                "referint_postop_close could not delete \"%s\"\n", logfilename );
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+                "referint_thread_func - Could not delete \"%s\"\n", logfilename );
         }
 
         /* unlock and let other writers back at the file */
@@ -1590,8 +1592,8 @@ writeintegritylog(Slapi_PBlock *pb, char *logfilename, Slapi_DN *sdn,
     if (( prfd = PR_Open( logfilename, PR_WRONLY | PR_CREATE_FILE | PR_APPEND,
           REFERINT_DEFAULT_FILE_MODE )) == NULL ) 
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-            "referint_postop could not write integrity log \"%s\" "
+        slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+            "writeintegritylog - Could not write integrity log \"%s\" "
         SLAPI_COMPONENT_NAME_NSPR " %d (%s)\n",
             logfilename, PR_GetError(), slapd_pr_strerror(PR_GetError()) );
 
@@ -1636,8 +1638,8 @@ writeintegritylog(Slapi_PBlock *pb, char *logfilename, Slapi_DN *sdn,
     }
 
     if(len_to_write > MAX_LINE ){
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                         "referint_postop could not write integrity log:"
+        slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+                         "writeintegritylog - Could not write integrity log:"
                          " line length exceeded. It will not be able"
                          " to update references to this entry.\n");
     } else {
@@ -1646,8 +1648,8 @@ writeintegritylog(Slapi_PBlock *pb, char *logfilename, Slapi_DN *sdn,
                     (newsuperiordn != NULL) ? newsuperiordn : "NULL",
                     requestordn ? requestordn : "NULL");
         if (PR_Write(prfd,buffer,strlen(buffer)) < 0){
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR,REFERINT_PLUGIN_SUBSYSTEM,
-                " writeintegritylog: PR_Write failed : The disk"
+            slapi_log_error(SLAPI_LOG_ERR,REFERINT_PLUGIN_SUBSYSTEM,
+                " writeintegritylog - PR_Write failed : The disk"
                 " may be full or the file is unwritable :: NSPR error - %d\n",
             PR_GetError());
         }
@@ -1656,8 +1658,8 @@ writeintegritylog(Slapi_PBlock *pb, char *logfilename, Slapi_DN *sdn,
     /* If file descriptor is closed successfully, PR_SUCCESS */
     rc = PR_Close(prfd);
     if (rc != PR_SUCCESS){
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR,REFERINT_PLUGIN_SUBSYSTEM,
-            " writeintegritylog: failed to close the file descriptor prfd; NSPR error - %d\n",
+        slapi_log_error(SLAPI_LOG_ERR,REFERINT_PLUGIN_SUBSYSTEM,
+            " writeintegritylog - Failed to close the file descriptor prfd; NSPR error - %d\n",
             PR_GetError());
     }
     referint_unlock();
@@ -1672,8 +1674,8 @@ referint_preop_init(Slapi_PBlock *pb)
         slapi_pblock_set(pb, SLAPI_PLUGIN_DESCRIPTION,  (void *) &pdesc) != 0 ||
         slapi_pblock_set(pb, premodfn, (void *)referint_validate_config) != 0)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
-                "referint_preop_init: failed to register plugin\n");
+        slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM,
+                "referint_preop_init - Failed to register plugin\n");
         status = -1;
     }
 
@@ -1700,7 +1702,7 @@ referint_validate_config(Slapi_PBlock *pb)
     slapi_pblock_get(pb, SLAPI_TARGET_SDN, &sdn);
     slapi_pblock_get(pb, SLAPI_ENTRY_PRE_OP, &pre_entry);
     if (!pre_entry) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "referint_validate_config: Null pre op entry.\n");
+        slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "referint_validate_config - Null pre op entry.\n");
         rc = LDAP_OPERATIONS_ERROR;
         goto bail;
     }
@@ -1724,7 +1726,7 @@ referint_validate_config(Slapi_PBlock *pb)
         }
 
         if ( SLAPI_PLUGIN_FAILURE == load_config(pb, resulting_entry, 0)) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "referint_validate_config: "
+            slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "referint_validate_config - "
                     "configuration validation failed.\n");
             rc = LDAP_UNWILLING_TO_PERFORM;
             goto bail;
@@ -1748,7 +1750,7 @@ referint_validate_config(Slapi_PBlock *pb)
          if((config_area = slapi_entry_attr_get_charptr(resulting_entry, SLAPI_PLUGIN_SHARED_CONFIG_AREA))){
              rc = slapi_dn_syntax_check(pb, config_area, 1);
              if (rc) { /* syntax check failed */
-                 slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "referint_validate_config: "
+                 slapi_log_error(SLAPI_LOG_ERR, REFERINT_PLUGIN_SUBSYSTEM, "referint_validate_config - "
                                  "%s does not contain a valid DN (%s)\n",
                                  SLAPI_PLUGIN_SHARED_CONFIG_AREA, config_area);
                  rc = LDAP_INVALID_DN_SYNTAX;
@@ -1758,8 +1760,8 @@ referint_validate_config(Slapi_PBlock *pb)
              rc = slapi_search_internal_get_entry(config_sdn, NULL, &e, referint_plugin_identity);
              if (LDAP_SUCCESS != rc) {
                  /* log an error and use the plugin entry for the config */
-                 slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, REFERINT_PLUGIN_SUBSYSTEM,
-                         "referint_validate_config: Config entry \"%s\" couild not be found, error %d\n",
+                 slapi_log_error(SLAPI_LOG_PLUGIN, REFERINT_PLUGIN_SUBSYSTEM,
+                         "referint_validate_config - Config entry \"%s\" couild not be found, error %d\n",
                          config_area, rc);
                  rc = LDAP_OPERATIONS_ERROR;
                  goto bail;
@@ -1767,8 +1769,8 @@ referint_validate_config(Slapi_PBlock *pb)
                  if(e){
                      config_e = e;
                  } else {
-                     slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, REFERINT_PLUGIN_SUBSYSTEM,
-                             "referint_validate_config: Config entry \"%s\" was not located.\n", config_area);
+                     slapi_log_error(SLAPI_LOG_PLUGIN, REFERINT_PLUGIN_SUBSYSTEM,
+                             "referint_validate_config - Config entry \"%s\" was not located.\n", config_area);
                      rc = LDAP_OPERATIONS_ERROR;
                      goto bail;
                  }

ldap/servers/plugins/replication/cl4_api.c

@@ -61,7 +61,7 @@ int cl4Init ()
 	s_cl4Desc.csnPL = csnplNew ();
 	if (s_cl4Desc.csnPL == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "cl4Init: failed to create CSN pending list\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "cl4Init: failed to create CSN pending list\n");
 		return CL4_CSNPL_ERROR;
 	}
 
@@ -90,14 +90,14 @@ int cl4WriteOperation (const slapi_operation_parameters *op)
 
 	if (op == NULL || !IsValidOperation (op))
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "cl4WriteEntry: invalid entry\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "cl4WriteEntry: invalid entry\n");
 		return CL4_BAD_DATA;
 	}
 	
 	rc = _cl4WriteOperation (op);	
 	if (rc != CL4_SUCCESS)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "cl4WriteEntry: failed to write changelog entry\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "cl4WriteEntry: failed to write changelog entry\n");
 		return rc;
 	}
 
@@ -109,7 +109,7 @@ int cl4WriteOperation (const slapi_operation_parameters *op)
 
 		if (rc != 0)
 		{
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 							"cl4WriteEntry: failed to remove CSN from the pending list\n");
 			rc = CL4_CSNPL_ERROR;
 		}
@@ -127,7 +127,7 @@ int cl4ChangeTargetDN (const CSN *csn, const char *newDN)
 
 	if (csn == NULL || newDN == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "cl4ChangeTargetDN: invalid argument\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "cl4ChangeTargetDN: invalid argument\n");
 		return CL4_BAD_DATA;
 	}
 
@@ -135,7 +135,7 @@ int cl4ChangeTargetDN (const CSN *csn, const char *newDN)
 	changeEntryDN = _cl4MakeCSNDN (csn);
 	if (changeEntryDN == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 						"cl4ChangeTargetDN: failed to construct change entry dn\n");
 		return CL4_MEMORY_ERROR;
 	}
@@ -158,7 +158,7 @@ int cl4ChangeTargetDN (const CSN *csn, const char *newDN)
 	if (res != LDAP_SUCCESS) 
 	{
 		char s[CSN_STRSIZE];
-	    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+	    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
 	    "cl4ChangeTargetDN: an error occured while modifying change entry with csn %s: %s. "
 	    "Logging of changes is disabled.\n", csn_as_string(csn,PR_FALSE,s), ldap_err2string(res));
 	    /* GGOODREPL g_set_repl_backend( NULL ); */
@@ -191,7 +191,7 @@ void cl4AssignChangeNumbers (time_t when, void *arg)
 			slapi_entry_free (entry);
 			if (rc != CL4_SUCCESS)
 			{
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "cl4AssignChangeNumbers: failed to resolve target dn\n");
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "cl4AssignChangeNumbers: failed to resolve target dn\n");
 				break;
 			}
 
@@ -213,7 +213,7 @@ void cl4AssignChangeNumbers (time_t when, void *arg)
 
 			if (rc != CL4_SUCCESS)
 			{
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 							    "cl4AssignChangeNumbers: failed to update changelog entry\n");
 				break;
 			}
@@ -239,7 +239,7 @@ static int _cl4WriteOperation (const slapi_operation_parameters *op)
 	Slapi_Value     *values[3];
 	char s[CSN_STRSIZE];
    
-    slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name,
+    slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name,
 	    "_cl4WriteEntry: writing change record with csn %s for dn: \"%s\"\n", 
 	    csn_as_string(op->csn,PR_FALSE,s), op->target_address.dn);
 
@@ -247,7 +247,7 @@ static int _cl4WriteOperation (const slapi_operation_parameters *op)
 	changeEntryDN = _cl4MakeCSNDN (op->csn);
 	if (changeEntryDN == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 						"_cl4WriteEntry: failed to create entry dn\n");
 		return CL4_MEMORY_ERROR;
 	}
@@ -259,7 +259,7 @@ static int _cl4WriteOperation (const slapi_operation_parameters *op)
     e = slapi_entry_alloc();
 	if (e == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 						"_cl4WriteEntry: failed to allocate change entry\n");
 		return CL4_MEMORY_ERROR;
 	}
@@ -343,7 +343,7 @@ static int _cl4WriteOperation (const slapi_operation_parameters *op)
 	if (res != LDAP_SUCCESS) 
 	{
 		char s[CSN_STRSIZE];
-	    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+	    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
 			"_cl4WriteEntry: an error occured while adding change entry with csn %s, dn = %s: %s. "
 			"Logging of changes is disabled.\n", csn_as_string(op->csn,PR_FALSE,s), op->target_address.dn, 
 			ldap_err2string(res));
@@ -365,7 +365,7 @@ static void _cl4AssignCSNCallback (const CSN *csn, void *data)
 
 	if (csn == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "_cl4AssignCSNCallback: null csn\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "_cl4AssignCSNCallback: null csn\n");
 		return;
 	}
 
@@ -374,7 +374,7 @@ static void _cl4AssignCSNCallback (const CSN *csn, void *data)
 	if (rc == -1)
 	{
 		char s[CSN_STRSIZE];
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 				"_cl4AssignCSNCallback: failed to insert csn %s to the pending list\n",
 				csn_as_string(csn,PR_FALSE,s));
 	}
@@ -386,7 +386,7 @@ static void _cl4AbortCSNCallback (const CSN *csn, void *data)
 
 	if (csn == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "_cl4AbortCSNCallback: null csn\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "_cl4AbortCSNCallback: null csn\n");
 		return;
 	}
 
@@ -394,7 +394,7 @@ static void _cl4AbortCSNCallback (const CSN *csn, void *data)
 	if (rc == -1)
 	{
 		char s[CSN_STRSIZE];
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 				"_cl4AbortCSNCallback: failed to remove csn %s from the pending list\n",
 				csn_as_string(csn,PR_FALSE,s));		
 	}
@@ -443,7 +443,7 @@ static int _cl4GetEntry (const CSN *csn, Slapi_Entry **entry)
 
 	if (rc != 0 || ret.err != 0)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "_cl4GetEntry: failed to get next changelog entry\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "_cl4GetEntry: failed to get next changelog entry\n");
 		return CL4_INTERNAL_ERROR;
 	}
 
@@ -510,14 +510,14 @@ static int _cl4ResolveTargetDN (Slapi_Entry *entry, Slapi_DN **newTargetDN)
 	rc = _cl4GetTargetEntry (targetSDN, uniqueid, &targetEntry);
 	if (rc != CL4_SUCCESS)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "_cl4ResolveTargetDN: failed to get target entry\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "_cl4ResolveTargetDN: failed to get target entry\n");
 		goto done;
 	}
 
 	teDNCSN = entry_get_dncsn(targetEntry);
 	if (teDNCSN == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "_cl4ResolveTargetDN: failed to get target entry dn\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "_cl4ResolveTargetDN: failed to get target entry dn\n");
 		rc = CL4_BAD_FORMAT;
 		goto done;
 	}
@@ -583,7 +583,7 @@ static int _cl4GetTargetEntry (Slapi_DN *sdn, const char *uniqueid, Slapi_Entry
 	slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &res);
 	if (res == LDAP_NO_SUCH_OBJECT)	/* entry not found */
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "_cl4GetTargetEntry: entry (%s) not found\n", 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "_cl4GetTargetEntry: entry (%s) not found\n", 
 						slapi_sdn_get_ndn(sdn));
 		rc = CL4_NOT_FOUND;
 		goto done;
@@ -591,7 +591,7 @@ static int _cl4GetTargetEntry (Slapi_DN *sdn, const char *uniqueid, Slapi_Entry
 
 	if (res != LDAP_SUCCESS) 
 	{
-	    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+	    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
 	    "_cl4ResolveTargetDN: an error occured while searching for directory entry with uniqueid %s: %s. "
 	    "Logging of changes is disabled.\n", uniqueid, ldap_err2string(res));
 	    /* GGOODREPL g_set_repl_backend( NULL ); */
@@ -602,7 +602,7 @@ static int _cl4GetTargetEntry (Slapi_DN *sdn, const char *uniqueid, Slapi_Entry
     slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &entries);
 	if (entries == NULL || entries [0] == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "_cl4GetTargetEntry: entry (%s) not found\n", 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "_cl4GetTargetEntry: entry (%s) not found\n", 
 						slapi_sdn_get_ndn(sdn));
 		rc = CL4_NOT_FOUND;
 		goto done;	
@@ -655,7 +655,7 @@ static int _cl4FindTargetDN (const CSN *csn, const char *uniqueid,
 	slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &res);
 	if (res == LDAP_NO_SUCH_OBJECT)	/* entry not found */
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "_cl4FindTargetDN: no entries much filter (%s)\n",
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "_cl4FindTargetDN: no entries much filter (%s)\n",
 						filter);
 		rc = CL4_NOT_FOUND;
 		goto done;
@@ -663,7 +663,7 @@ static int _cl4FindTargetDN (const CSN *csn, const char *uniqueid,
 
 	if (res != LDAP_SUCCESS) 
 	{
-	    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+	    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
 	    "_cl4ResolveTargetDN: an error occured while searching change entries matching filter %s: %s. "
 	    "Logging of changes is disabled.\n", filter, ldap_err2string(res));
 	    /* GGOODREPL g_set_repl_backend( NULL ); */
@@ -674,7 +674,7 @@ static int _cl4FindTargetDN (const CSN *csn, const char *uniqueid,
 	slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &entries);
 	if (entries == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "_cl4FindTargetDN: no entries much filter (%s)\n",
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "_cl4FindTargetDN: no entries much filter (%s)\n",
 						filter);
 		rc = CL4_NOT_FOUND;
 		goto done;	
@@ -744,14 +744,14 @@ static int _cl4UpdateEntry (const CSN *csn, const char *changeType,
 
 	if (csn == NULL || changeType == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "_cl4UpdateEntry: invalid argument\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "_cl4UpdateEntry: invalid argument\n");
 		return CL4_BAD_DATA;
 	}
 
 	dn = _cl4MakeCSNDN (csn);
 	if (dn == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "_cl4UpdateEntry: failed to create entry dn\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "_cl4UpdateEntry: failed to create entry dn\n");
 		return CL4_MEMORY_ERROR;
 	}
 
@@ -787,7 +787,7 @@ static int _cl4UpdateEntry (const CSN *csn, const char *changeType,
 	if (res != LDAP_SUCCESS) 
 	{
 		char s[CSN_STRSIZE];		
-	    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+	    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
 	    "cl4ChangeTargetDN: an error occured while modifying change entry with csn %s: %s. "
 	    "Logging of changes is disabled.\n", csn_as_string(csn,PR_FALSE,s), ldap_err2string(res));
 	    /* GGOODREPL g_set_repl_backend( NULL ); */

ldap/servers/plugins/replication/cl4_init.c

@@ -84,7 +84,7 @@ int changelog4_init ()
     
 	if(rc != 0)
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, 
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, 
 						"An error occurred configuring the changelog database\n" );
     }
 
@@ -107,7 +107,7 @@ changelog4_close()
 	rc = slapi_be_getentrypoint (rbe, SLAPI_PLUGIN_CLOSE_FN, (void**)&closefn, pb);
 	if (rc != 0)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 						"Error: backend close entry point is missing. "
                         "Replication subsystem disabled.\n");
 		slapi_pblock_destroy (pb);
@@ -120,7 +120,7 @@ changelog4_close()
 	if (rc != 0)
 	{
 		
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Error: the changelog database could "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "Error: the changelog database could "
     		"not be closed.  Replication subsystem disabled.\n");
 		set_repl_backend( NULL );
 		rc = -1;
@@ -142,7 +142,7 @@ changelog4_remove()
 	rc = slapi_be_getentrypoint (rbe, SLAPI_PLUGIN_DB_RMDB_FN, (void**)&rmdbfn, pb);
 	if (rc != 0)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 						"Error: backend rmdb entry point is missing. "
                         "Replication subsystem disabled.\n");
 		slapi_pblock_destroy (pb);
@@ -155,13 +155,13 @@ changelog4_remove()
 	if (rc != 0)
 	{
 		
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Error: the changelog database could "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "Error: the changelog database could "
     		"not be removed.  Replication subsystem disabled.\n");
 		rc = -1;
 	}
 	else
 	{
-    	slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "New database generation computed. "
+    	slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "New database generation computed. "
     		"Changelog database removed.\n");
 	}
 
@@ -222,7 +222,7 @@ changelog4_create_be()
 	char *cl_suffix;
 
     if ( cl_dir == NULL ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 						"Error: no directory specified for changelog database.\n");
         return -1;
     }
@@ -231,7 +231,7 @@ changelog4_create_be()
 
     if ( cl_suffix == NULL ) {
 		slapi_ch_free ((void **)&cl_dir);
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 						"Error: no suffix specified for changelog database.\n");
         return -1;
     }
@@ -298,7 +298,7 @@ changelog4_create_be()
  
 	if (rbe == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 						"Error: failed to create changelog backend. "
 						"Replication disabled.\n");
 		return -1;
@@ -331,7 +331,7 @@ changelog4_start_be ()
 		rc = slapi_be_getentrypoint(rbe, SLAPI_PLUGIN_START_FN, (void**)&startfn, pb);
 		if (rc != 0)
 		{
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 							"Error: backend start entry point is missing. "
 							"Replication subsystem disabled.\n");
 			slapi_pblock_destroy (pb);
@@ -344,7 +344,7 @@ changelog4_start_be ()
 
 		if (rc != 0)
 		{
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 						"Error: Failed to start changelog backend. "
                         "Replication subsystem disabled.\n");
 			set_repl_backend( NULL );

ldap/servers/plugins/replication/cl5_clcache.c

@@ -221,10 +221,10 @@ clcache_get_buffer ( CLC_Buffer **buf, DB *db, ReplicaId consumer_rid, const RUV
 	need_new = (!_pool || !_pool->pl_busy_lists || !_pool->pl_busy_lists->bl_buffers);
 
 	if ( (!need_new) && (NULL != ( *buf = (CLC_Buffer*) get_thread_private_cache())) ) {
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, get_thread_private_agmtname(),
-						  "clcache_get_buffer: found thread private buffer cache %p\n", *buf);
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, get_thread_private_agmtname(),
-						  "clcache_get_buffer: _pool is %p _pool->pl_busy_lists is %p _pool->pl_busy_lists->bl_buffers is %p\n",
+		slapi_log_error(SLAPI_LOG_REPL, get_thread_private_agmtname(),
+						  "clcache_get_buffer - found thread private buffer cache %p\n", *buf);
+		slapi_log_error(SLAPI_LOG_REPL, get_thread_private_agmtname(),
+						  "clcache_get_buffer - _pool is %p _pool->pl_busy_lists is %p _pool->pl_busy_lists->bl_buffers is %p\n",
 						  _pool, _pool ? _pool->pl_busy_lists : NULL,
 						  (_pool && _pool->pl_busy_lists) ? _pool->pl_busy_lists->bl_buffers : NULL);
 		(*buf)->buf_state = CLC_STATE_READY;
@@ -274,8 +274,8 @@ clcache_get_buffer ( CLC_Buffer **buf, DB *db, ReplicaId consumer_rid, const RUV
 		csn_free(&l_csn);
 	}
 	else {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, get_thread_private_agmtname(),
-			"clcache_get_buffer: can't allocate new buffer\n" );
+		slapi_log_error(SLAPI_LOG_ERR, get_thread_private_agmtname(),
+			"clcache_get_buffer - Can't allocate new buffer\n" );
 		rc = CL5_MEMORY_ERROR;
 	}
 
@@ -290,8 +290,8 @@ clcache_return_buffer ( CLC_Buffer **buf )
 {
 	int i;
 
-	slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, (*buf)->buf_agmt_name,
-			  "session end: state=%d load=%d sent=%d skipped=%d skipped_new_rid=%d "
+	slapi_log_error(SLAPI_LOG_REPL, (*buf)->buf_agmt_name,
+			  "clcache_return_buffer - session end: state=%d load=%d sent=%d skipped=%d skipped_new_rid=%d "
 			  "skipped_csn_gt_cons_maxcsn=%d skipped_up_to_date=%d "
 			  "skipped_csn_gt_ruv=%d skipped_csn_covered=%d\n",
 			  (*buf)->buf_state,
@@ -353,8 +353,9 @@ clcache_load_buffer ( CLC_Buffer *buf, CSN **anchorCSN )
 			}
 		}
 		else {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, buf->buf_agmt_name,
-					"Can't locate CSN %s in the changelog (DB rc=%d). If replication stops, the consumer may need to be reinitialized.\n",
+			slapi_log_error(SLAPI_LOG_ERR, buf->buf_agmt_name,
+					"clcache_load_buffer - Can't locate CSN %s in the changelog (DB rc=%d). "
+					"If replication stops, the consumer may need to be reinitialized.\n",
 					(char*)buf->buf_key.data, rc );
 		}
 	} else if (rc == CLC_STATE_DONE) {
@@ -362,8 +363,8 @@ clcache_load_buffer ( CLC_Buffer *buf, CSN **anchorCSN )
 	}
 
 	if ( rc != 0 ) {
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, buf->buf_agmt_name,
-				"clcache_load_buffer: rc=%d\n", rc );
+		slapi_log_error(SLAPI_LOG_REPL, buf->buf_agmt_name,
+				"clcache_load_buffer - rc=%d\n", rc );
 	}
 
 	return rc;
@@ -385,12 +386,12 @@ clcache_load_buffer_bulk ( CLC_Buffer *buf, int flag )
 #endif
 
 	if (NULL == buf) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, "clcache_load_buffer_bulk",
-		                  "NULL buf\n" );
+		slapi_log_error(SLAPI_LOG_ERR, buf->buf_agmt_name, 
+				"clcache_load_buffer_bulk - NULL buf\n" );
 		return rc;
 	}
 	if (NULL == buf->buf_busy_list) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, "clcache_load_buffer_bulk",
+		slapi_log_error(SLAPI_LOG_ERR, buf->buf_agmt_name, "clcache_load_buffer_bulk - "
 		                  "%s%sno buf_busy_list\n",
 		                  buf->buf_agmt_name?buf->buf_agmt_name:"",
 		                  buf->buf_agmt_name?": ":"" );
@@ -413,7 +414,7 @@ retry:
 				 * 2. try to find another starting position as close
 				 *    as possible
 				 */
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, "clcache_load_buffer_bulk",
+				slapi_log_error(SLAPI_LOG_ERR, buf->buf_agmt_name, "clcache_load_buffer_bulk - "
 							"changelog record with csn (%s) not found for DB_NEXT\n",
 							(char *)buf->buf_key.data );
 				rc = cursor->c_get ( cursor, & buf->buf_key, & buf->buf_data,
@@ -433,7 +434,7 @@ retry:
 		if ( 0 == rc || DB_BUFFER_SMALL == rc ) {
 			rc = clcache_cursor_get ( cursor, buf, use_flag );
 			if ( rc == DB_NOTFOUND && use_flag == DB_SET) {
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, "clcache_load_buffer_bulk",
+				slapi_log_error(SLAPI_LOG_ERR, buf->buf_agmt_name, "clcache_load_buffer_bulk - "
 							"changelog record with csn (%s) not found for DB_SET\n",
 							(char *)buf->buf_key.data );
 				rc = clcache_cursor_get ( cursor, buf, DB_SET_RANGE );
@@ -454,7 +455,7 @@ retry:
 		PRIntervalTime interval;
 
 		tries++;
-		slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, "clcache_load_buffer_bulk",
+		slapi_log_error(SLAPI_LOG_TRACE, buf->buf_agmt_name, "clcache_load_buffer_bulk - "
 		                  "deadlock number [%d] - retrying\n", tries );
 		/* back off */
 		interval = PR_MillisecondsToInterval(slapi_rand() % 100);
@@ -463,7 +464,7 @@ retry:
 		goto retry;
 	}
 	if ((rc == DB_LOCK_DEADLOCK) && (tries >= MAX_TRIALS)) {
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, "clcache_load_buffer_bulk",
+		slapi_log_error(SLAPI_LOG_REPL, buf->buf_agmt_name, "clcache_load_buffer_bulk - "
 		                  "could not load buffer from changelog after %d tries\n", tries );
 	}
 
@@ -535,8 +536,8 @@ clcache_get_next_change ( CLC_Buffer *buf, void **key, size_t *keylen, void **da
 	}
 	else {
 		*csn = buf->buf_current_csn;
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, buf->buf_agmt_name,
-			"load=%d rec=%d csn=%s\n",
+		slapi_log_error(SLAPI_LOG_REPL, buf->buf_agmt_name,
+			"clcache_get_next_change - load=%d rec=%d csn=%s\n",
 			buf->buf_load_cnt, buf->buf_record_cnt, (char*)*key );
 	}
 
@@ -649,11 +650,12 @@ clcache_initial_anchorcsn ( CLC_Buffer *buf, int *flag )
 				csn_as_string(cscb->local_maxcsn, 0, local);
 				csn_as_string(buf->buf_current_csn, 0, curr);
 				csn_as_string(cscb->consumer_maxcsn, 0, conmaxcsn);
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, "clcache_initial_anchorcsn" ,
-								"%s - (cscb %d - state %d) - csnPrevMax (%s) "
-								"csnMax (%s) csnBuf (%s) csnConsumerMax (%s)\n",
-								buf->buf_agmt_name, i, cscb->state, prevmax, local,
-								curr, conmaxcsn);
+				slapi_log_error(SLAPI_LOG_REPL, buf->buf_agmt_name,
+						"clcache_initial_anchorcsn - " 
+						"%s - (cscb %d - state %d) - csnPrevMax (%s) "
+						"csnMax (%s) csnBuf (%s) csnConsumerMax (%s)\n",
+						buf->buf_agmt_name, i, cscb->state, prevmax, local,
+						curr, conmaxcsn);
 			}
 
 			if (cscb->consumer_maxcsn == NULL) {
@@ -670,8 +672,6 @@ clcache_initial_anchorcsn ( CLC_Buffer *buf, int *flag )
 				*flag = rid_flag;
 				hasChange = PR_TRUE;
 			}
-
-
 		}
 	}
 
@@ -680,7 +680,7 @@ clcache_initial_anchorcsn ( CLC_Buffer *buf, int *flag )
 	} else {
 		csn_init_by_csn(buf->buf_current_csn, anchorcsn);
 		csn_as_string(buf->buf_current_csn, 0, (char *)buf->buf_key.data);
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, "clcache_initial_anchorcsn",
+		slapi_log_error(SLAPI_LOG_REPL, "clcache_initial_anchorcsn",
 						"anchor is now: %s\n", (char *)buf->buf_key.data);
 	}
 
@@ -710,7 +710,7 @@ clcache_adjust_anchorcsn ( CLC_Buffer *buf, int *flag )
 				csn_as_string(cscb->local_maxcsn, 0, local);
 				csn_as_string(buf->buf_current_csn, 0, curr);
 				csn_as_string(cscb->consumer_maxcsn, 0, conmaxcsn);
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, "clcache_adjust_anchorcsn" ,
+				slapi_log_error(SLAPI_LOG_REPL, buf->buf_agmt_name, "clcache_adjust_anchorcsn - "
 								"%s - (cscb %d - state %d) - csnPrevMax (%s) "
 								"csnMax (%s) csnBuf (%s) csnConsumerMax (%s)\n",
 								buf->buf_agmt_name, i, cscb->state, prevmax, local,
@@ -742,8 +742,6 @@ clcache_adjust_anchorcsn ( CLC_Buffer *buf, int *flag )
 				*flag = rid_flag;
 				hasChange = PR_TRUE;
 			}
-
-
 		}
 	}
 
@@ -752,7 +750,7 @@ clcache_adjust_anchorcsn ( CLC_Buffer *buf, int *flag )
 	} else {
 		csn_init_by_csn(buf->buf_current_csn, anchorcsn);
 		csn_as_string(buf->buf_current_csn, 0, (char *)buf->buf_key.data);
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, "clcache_adjust_anchorcsn",
+		slapi_log_error(SLAPI_LOG_REPL, buf->buf_agmt_name, "clcache_adjust_anchorcsn - "
 						"anchor is now: %s\n", (char *)buf->buf_key.data);
 	}
 
@@ -782,9 +780,8 @@ clcache_skip_change ( CLC_Buffer *buf )
 		if (rid == buf->buf_consumer_rid && buf->buf_ignoreConsumerRID){
 			if (slapi_is_loglevel_set(SLAPI_LOG_REPL)) {
 				csn_as_string(buf->buf_current_csn, 0, buf_cur_csn_str);
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, buf->buf_agmt_name,
-					"Skipping update because the consumer with Rid: [%d] is "
-				        "ignored\n", rid);
+				slapi_log_error(SLAPI_LOG_REPL, buf->buf_agmt_name,
+					"clcache_skip_change - Skipping update because the consumer with Rid: [%d] is ignored\n", rid);
 				buf->buf_skipped_csn_gt_cons_maxcsn++;
 			}
 			break;
@@ -792,8 +789,8 @@ clcache_skip_change ( CLC_Buffer *buf )
 
 		/* Skip helper entry (ENTRY_COUNT, PURGE_RUV and so on) */
 		if ( cl5HelperEntry ( NULL, buf->buf_current_csn ) == PR_TRUE ) {
-			slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, buf->buf_agmt_name,
-				"Skip helper entry type=%ld\n", csn_get_time( buf->buf_current_csn ));
+			slapi_log_error(SLAPI_LOG_REPL, buf->buf_agmt_name,
+				"clcache_skip_change - Skip helper entry type=%ld\n", csn_get_time( buf->buf_current_csn ));
 			break;
 		}
 
@@ -804,8 +801,8 @@ clcache_skip_change ( CLC_Buffer *buf )
 		if ( i >= buf->buf_num_cscbs ) {
 			if (slapi_is_loglevel_set(SLAPI_LOG_REPL)) {
 				csn_as_string(buf->buf_current_csn, 0, buf_cur_csn_str);
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, buf->buf_agmt_name,
-					"Skipping update because the changelog buffer current csn [%s] rid "
+				slapi_log_error(SLAPI_LOG_REPL, buf->buf_agmt_name,
+					"clcache_skip_change - Skipping update because the changelog buffer current csn [%s] rid "
 				        "[%d] is not in the list of changelog csn buffers (length %d)\n",
 				        buf_cur_csn_str, rid, buf->buf_num_cscbs);
 			}
@@ -875,8 +872,8 @@ clcache_skip_change ( CLC_Buffer *buf )
 		if ( cscb->local_maxcsn )
 			csn_as_string ( cscb->local_maxcsn, PR_FALSE, local );
 		csn_as_string ( buf->buf_current_csn, PR_FALSE, current );
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, buf->buf_agmt_name,
-				"Skip %s consumer=%s local=%s\n", current, consumer, local );
+		slapi_log_error(SLAPI_LOG_REPL, buf->buf_agmt_name,
+				"clcache_skip_change - Skip %s consumer=%s local=%s\n", current, consumer, local );
 	}
 #endif
 
@@ -890,7 +887,7 @@ clcache_new_cscb(void)
 
 	cscb = (struct csn_seq_ctrl_block *) slapi_ch_calloc ( 1, sizeof (struct csn_seq_ctrl_block) );
 	if (cscb == NULL) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, NULL, "clcache: malloc failure\n" );
+		slapi_log_error(SLAPI_LOG_ERR, NULL, "clcache: malloc failure\n" );
 	}
 	return cscb;
 }
@@ -1071,7 +1068,7 @@ clcache_open_cursor ( DB_TXN *txn, CLC_Buffer *buf, DBC **cursor )
 
 	rc = buf->buf_busy_list->bl_db->cursor ( buf->buf_busy_list->bl_db, txn, cursor, 0 );
 	if ( rc != 0 ) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, get_thread_private_agmtname(),
+		slapi_log_error(SLAPI_LOG_ERR, get_thread_private_agmtname(),
 			"clcache: failed to open cursor; db error - %d %s\n",
 			rc, db_strerror(rc));
 	}
@@ -1111,20 +1108,20 @@ clcache_cursor_get ( DBC *cursor, CLC_Buffer *buf, int flag )
 								 &( buf->buf_key ),
 								 &( buf->buf_data ),
 							 	 buf->buf_load_flag | flag );
-			slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, buf->buf_agmt_name,
-				"clcache: (%d | %d) buf key len %d reallocated and retry returns %d\n", buf->buf_load_flag, flag, buf->buf_key.size, rc );
+			slapi_log_error(SLAPI_LOG_REPL, buf->buf_agmt_name,
+				"clcache_cursor_get - clcache: (%d | %d) buf key len %d reallocated and retry returns %d\n", buf->buf_load_flag, flag, buf->buf_key.size, rc );
 		}
 	}
 
 	switch ( rc ) {
 		case EINVAL:
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, buf->buf_agmt_name,
-					"clcache_cursor_get: invalid parameter\n" );
+			slapi_log_error(SLAPI_LOG_ERR, buf->buf_agmt_name,
+					"clcache_cursor_get - invalid parameter\n" );
 			break;
 
 		case DB_BUFFER_SMALL:
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, buf->buf_agmt_name,
-					"clcache_cursor_get: can't allocate %u bytes\n", buf->buf_data.ulen );
+			slapi_log_error(SLAPI_LOG_ERR, buf->buf_agmt_name,
+					"clcache_cursor_get - can't allocate %u bytes\n", buf->buf_data.ulen );
 			break;
 
 		default:

ldap/servers/plugins/replication/cl5_config.c

@@ -55,8 +55,8 @@ int changelog5_config_init()
 	}
 	if (s_configLock == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
-						"changelog5_config_init: failed to create configurationlock; "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
+						"changelog5_config_init - Failed to create configuration lock; "
                         "NSPR error - %d\n",PR_GetError ());
 		return 1;
 	}
@@ -165,8 +165,8 @@ changelog5_config_add (Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter
 			strcpy (returntext, "attempt to add changelog when it already exists");
 		}
 
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
-						"changelog5_config_add: changelog already exist; "
+		slapi_log_error(SLAPI_LOG_NOTICE, repl_plugin_name_cl, 
+						"changelog5_config_add - Changelog already exist; "
 						"request ignored\n");
 		goto done;
 	}
@@ -180,8 +180,8 @@ changelog5_config_add (Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter
 			PR_snprintf (returntext, SLAPI_DSE_RETURNTEXT_SIZE, "NULL changelog directory");
 		}
 
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
-				"changelog5_config_add: NULL changelog directory\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
+				"changelog5_config_add - NULL changelog directory\n");
 		goto done;	
 	}	
 
@@ -206,11 +206,11 @@ changelog5_config_add (Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter
 		*returncode = 1;
 		if (returntext)
 		{
-			PR_snprintf (returntext, SLAPI_DSE_RETURNTEXT_SIZE, "failed to start changelog; error - %d", rc);
+			PR_snprintf (returntext, SLAPI_DSE_RETURNTEXT_SIZE, "Failed to start changelog; error - %d", rc);
 		}
 
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
-				"changelog5_config_add: failed to start changelog\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
+				"changelog5_config_add - Failed to start changelog\n");
 		goto done;
 	}
 
@@ -223,8 +223,8 @@ changelog5_config_add (Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter
 		{
 			PR_snprintf (returntext, SLAPI_DSE_RETURNTEXT_SIZE, "failed to configure changelog trimming; error - %d", rc);
 		}
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
-						"changelog5_config_add: failed to configure changelog trimming\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
+						"changelog5_config_add - Failed to configure changelog trimming\n");
 		goto done;
 	}
 
@@ -273,8 +273,8 @@ changelog5_config_modify (Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entr
 			strcpy (returntext, "changelog is not configured");
 		}
 
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
-					"changelog5_config_modify: changelog is not configured\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
+					"changelog5_config_modify - Changelog is not configured\n");
 		return SLAPI_DSE_CALLBACK_ERROR;
 	}
 
@@ -289,8 +289,8 @@ changelog5_config_modify (Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entr
 			strcpy (returntext, "changelog is not configured");
 		}
 
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
-					"changelog5_config_modify: changelog is not configured\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
+					"changelog5_config_modify - Changelog is not configured\n");
 		goto done;
 	}
 
@@ -492,8 +492,8 @@ changelog5_config_modify (Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entr
 			/* changelog directory changed - need to remove the
 			   previous changelog and create new one */
 		
-			slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name_cl, 
-					"changelog5_config_modify: changelog directory changed; "
+			slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name_cl, 
+					"changelog5_config_modify - Changelog directory changed; "
 					"old dir - %s, new dir - %s; recreating changelog.\n",
 					currentDir, config.dir);
 
@@ -503,15 +503,15 @@ changelog5_config_modify (Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entr
 				*returncode = 1;
 				if (returntext)
 				{
-					PR_snprintf (returntext, SLAPI_DSE_RETURNTEXT_SIZE, "failed to close changelog; error - %d", rc);
+					PR_snprintf (returntext, SLAPI_DSE_RETURNTEXT_SIZE, "Failed to close changelog; error - %d", rc);
 				}
 
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
-					"changelog5_config_modify: failed to close changelog\n");
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
+					"changelog5_config_modify - Failed to close changelog\n");
 				goto done;
 			} else {
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name_cl, 
-								"changelog5_config_modify: closed the changelog\n");
+				slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name_cl, 
+								"changelog5_config_modif - Closed the changelog\n");
 			}
 
 			rc = cl5Delete (currentDir);
@@ -523,12 +523,12 @@ changelog5_config_modify (Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entr
 					PR_snprintf (returntext, SLAPI_DSE_RETURNTEXT_SIZE, "failed to remove changelog; error - %d", rc);
 				}
 
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
-					"changelog5_config_modify: failed to remove changelog\n");
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
+					"changelog5_config_modify - Failed to remove changelog\n");
 				goto done;
 			} else {
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name_cl, 
-								"changelog5_config_modify: deleted the changelog at %s\n", currentDir);
+				slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name_cl, 
+								"changelog5_config_modify - Deleted the changelog at %s\n", currentDir);
 			}
 
 			rc = cl5Open (config.dir, &config.dbconfig);
@@ -537,21 +537,21 @@ changelog5_config_modify (Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entr
 				*returncode = 1;
 				if (returntext)
 				{
-					PR_snprintf (returntext, SLAPI_DSE_RETURNTEXT_SIZE, "failed to restart changelog; error - %d", rc);
+					PR_snprintf (returntext, SLAPI_DSE_RETURNTEXT_SIZE, "Failed to restart changelog; error - %d", rc);
 				}
 
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
-					"changelog5_config_modify: failed to restart changelog\n");
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
+					"changelog5_config_modify - Failed to restart changelog\n");
 				/* before finishing, let's try to do some error recovery */
 				if (CL5_SUCCESS != cl5Open(currentDir, &config.dbconfig))
 				{
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
-									"changelog5_config_modify: failed to restore previous changelog\n");
+					slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
+									"changelog5_config_modify - Failed to restore previous changelog\n");
 				}
 				goto done;
 			} else {
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name_cl, 
-								"changelog5_config_modify: opened the changelog at %s\n", config.dir);
+				slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name_cl, 
+								"changelog5_config_modify - Opened the changelog at %s\n", config.dir);
 			}
 		}
 	}
@@ -570,8 +570,8 @@ changelog5_config_modify (Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entr
 				PR_snprintf (returntext, SLAPI_DSE_RETURNTEXT_SIZE, "failed to configure changelog trimming; error - %d", rc);
 			}
 
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
-				"changelog5_config_modify: failed to configure changelog trimming\n");
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
+				"changelog5_config_modify - Failed to configure changelog trimming\n");
 			goto done;
 		}
 	}
@@ -616,8 +616,8 @@ changelog5_config_delete (Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAf
 			PL_strncpyz(returntext, "changelog is not configured", SLAPI_DSE_RETURNTEXT_SIZE);
 		}
 		
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
-					"changelog5_config_delete: chagelog is not configured\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
+					"changelog5_config_delete - Chagelog is not configured\n");
 		return SLAPI_DSE_CALLBACK_ERROR;
 	}
 
@@ -632,8 +632,8 @@ changelog5_config_delete (Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAf
 			PL_strncpyz(returntext, "changelog is not configured", SLAPI_DSE_RETURNTEXT_SIZE);
 		}
 		
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
-					"changelog5_config_delete: chagelog is not configured\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
+					"changelog5_config_delete - Changelog is not configured\n");
 		goto done;
 	}
 
@@ -648,8 +648,8 @@ changelog5_config_delete (Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAf
 			PL_strncpyz (returntext, "internal failure", SLAPI_DSE_RETURNTEXT_SIZE);
 		}
 		
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
-					"changelog5_config_delete: NULL directory\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
+					"changelog5_config_delete - NULL directory\n");
 		goto done;
 	}
 
@@ -664,8 +664,8 @@ changelog5_config_delete (Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAf
 			PR_snprintf (returntext, SLAPI_DSE_RETURNTEXT_SIZE, "failed to close changelog; error - %d", rc);
 		}
 
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
-					"changelog5_config_delete: failed to close changelog\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
+					"changelog5_config_delete - Failed to close changelog\n");
 		goto done;
 	}
 
@@ -678,8 +678,8 @@ changelog5_config_delete (Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAf
 			PR_snprintf (returntext, SLAPI_DSE_RETURNTEXT_SIZE, "failed to remove changelog; error - %d", rc);
 		}
 
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
-					"changelog5_config_delete: failed to remove changelog\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
+					"changelog5_config_delete - Failed to remove changelog\n");
 		goto done;
 	}
 
@@ -753,8 +753,8 @@ static void changelog5_extract_config(Slapi_Entry* entry, changelog5Config *conf
 		if (slapi_is_duration_valid(arg)) {
 			config->compactInterval = (long)slapi_parse_duration(arg);
 		} else {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl,
-				"changelog5_extract_config: %s: invalid value \"%s\", ignoring the change.\n",
+			slapi_log_error(SLAPI_LOG_NOTICE, repl_plugin_name_cl,
+				"changelog5_extract_config - %s: invalid value \"%s\", ignoring the change.\n",
 				CONFIG_CHANGELOG_COMPACTDB_ATTRIBUTE, arg);
 		}
 		slapi_ch_free_string(&arg);
@@ -770,8 +770,8 @@ static void changelog5_extract_config(Slapi_Entry* entry, changelog5Config *conf
 		if (slapi_is_duration_valid(arg)) {
 			config->trimInterval = (long)slapi_parse_duration(arg);
 		} else {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl,
-				"changelog5_extract_config: %s: invalid value \"%s\", ignoring the change.\n",
+			slapi_log_error(SLAPI_LOG_NOTICE, repl_plugin_name_cl,
+				"changelog5_extract_config - %s: invalid value \"%s\", ignoring the change.\n",
 				CONFIG_CHANGELOG_TRIM_ATTRIBUTE, arg);
 			config->trimInterval = CHANGELOGDB_TRIM_INTERVAL;
 		}
@@ -787,8 +787,8 @@ static void changelog5_extract_config(Slapi_Entry* entry, changelog5Config *conf
 		if (slapi_is_duration_valid(arg)) {
 			config->maxAge = arg;
 		} else {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl,
-				"changelog5_extract_config: %s: invalid value \"%s\", ignoring the change.\n",
+			slapi_log_error(SLAPI_LOG_NOTICE, repl_plugin_name_cl,
+				"changelog5_extract_config - %s: invalid value \"%s\", ignoring the change.\n",
 				CONFIG_CHANGELOG_MAXAGE_ATTRIBUTE, arg);
 			slapi_ch_free_string(&arg);
 			config->maxAge = slapi_ch_strdup(CL5_STR_IGNORE);

ldap/servers/plugins/replication/cl5_init.c

@@ -29,7 +29,7 @@ int changelog5_init()
 	rc = cl5Init ();
 	if (rc != CL5_SUCCESS)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
 						"changelog5_init: failed to initialize changelog\n");
 		return 1;
 	}
@@ -51,7 +51,7 @@ int changelog5_init()
 	rc = cl5Open (config.dir, &config.dbconfig);
 	if (rc != CL5_SUCCESS)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
 					"changelog5_init: failed to start changelog at %s\n", 
 					config.dir);
 		rc = 1;
@@ -62,7 +62,7 @@ int changelog5_init()
 	rc = cl5ConfigTrimming (config.maxEntries, config.maxAge, config.compactInterval, config.trimInterval);
 	if (rc != CL5_SUCCESS)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
 						"changelog5_init: failed to configure changelog trimming\n");
 		rc = 1;
         goto done;

ldap/servers/plugins/replication/cl5_test.c

@@ -74,7 +74,7 @@ static void testBasic ()
 {
 	int rc = 0;
 
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Starting basic test ...\n");	
+	slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Starting basic test ...\n");	
 
     /* ONREPL - we can't run the tests from the startup code because
        operations can't be issued until all plugins are started. So,
@@ -90,10 +90,10 @@ static void testBasic ()
     }
 
 	if (rc == 0)
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
 						"Basic test completed successfully\n");
 	else
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
 						"Basic test failed\n");
 }
 
@@ -104,7 +104,7 @@ static void testBackupRestore ()
 	char *baseDir;
 	char bkDir [MAXPATHLEN];
 
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Starting backup and recovery test ...\n");	
+	slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Starting backup and recovery test ...\n");	
 	
 	dir = cl5GetDir ();
 
@@ -127,10 +127,10 @@ static void testBackupRestore ()
 	}
 
 	if (rc == CL5_SUCCESS)
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
 						"Backup and Restore test completed successfully\n");
 	else
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
 						"Backup and Restore test failed\n");
 }
 
@@ -146,7 +146,7 @@ static void testIteration ()
 	int rc;
 	int i;
 
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Starting iteration test ...\n");	
+	slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Starting iteration test ...\n");	
 
 	/* get replica object */
     r_root = slapi_sdn_new_dn_byval(REPLICA_ROOT);
@@ -154,12 +154,12 @@ static void testIteration ()
     slapi_sdn_free (&r_root);
     if (r_obj == NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "replica is not configured for (%s)\n",
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "replica is not configured for (%s)\n",
                         REPLICA_ROOT);	
         return;
     }
 
-    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Starting first iteration pass ...\n");	
+    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Starting first iteration pass ...\n");	
 
     /* configure empty consumer ruv */        
 	r = (Replica*)object_get_data (r_obj);
@@ -186,16 +186,16 @@ static void testIteration ()
     if (rc == CL5_NOTFOUND)
     {
 	    if (i == 0) /* success */
-		    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "First iteration pass completed "
+		    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "First iteration pass completed "
 				            "successfully: no changes to replay\n");
 	    else /* incorrect number of entries traversed */
-		    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "First iteration pass failed: "
+		    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "First iteration pass failed: "
 				            "traversed %d entries; expected none\n", i);
     }
 	else /* general error */
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "First iteration pass failed\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "First iteration pass failed\n");
 
-    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Starting second iteration pass ...\n");	
+    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Starting second iteration pass ...\n");	
 
     /* add some entries */
     populateChangelogOp ();
@@ -219,16 +219,16 @@ static void testIteration ()
     if (rc == CL5_NOTFOUND)
     {
 	    if (i == OP_COUNT) /* success */
-		    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Second iteration pass completed "
+		    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Second iteration pass completed "
 				            "successfully: %d entries traversed\n", i);
 	    else /* incorrect number of entries traversed */
-		    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Second iteration pass failed: "
+		    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Second iteration pass failed: "
 				            "traversed %d entries; expected %d\n", i, OP_COUNT);
     }
 	else /* general error */
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Second iteration pass failed\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Second iteration pass failed\n");
 
-    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Starting third iteration pass ...\n");	
+    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Starting third iteration pass ...\n");	
     /* add more entries */
     populateChangelogOp ();
     
@@ -251,16 +251,16 @@ static void testIteration ()
     if (rc == CL5_NOTFOUND)
     {
 	    if (i == OP_COUNT) /* success */
-		    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Third iteration pass completed "
+		    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Third iteration pass completed "
 				            "successfully: %d entries traversed\n", i);
 	    else /* incorrect number of entries traversed */
-		    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Third iteration pass failed: "
+		    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Third iteration pass failed: "
 				            "traversed %d entries; expected %d\n", i, OP_COUNT);
     }
 	else /* general error */
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Second iteration pass failed\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Second iteration pass failed\n");
 
-    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Iteration test is complete\n");
+    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Iteration test is complete\n");
 
     ruv_destroy (&ruv);
     object_release (r_obj);
@@ -273,7 +273,7 @@ static void testTrimming ()
 	int count;
 	int rc;
 
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Starting trimming test ...\n");	
+	slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Starting trimming test ...\n");	
 
 	rc = populateChangelog (200, NULL);
 
@@ -288,7 +288,7 @@ static void testTrimming ()
 			rc = cl5ConfigTrimming (300, "1d", CHANGELOGDB_COMPACT_INTERVAL, CHANGELOGDB_TRIM_INTERVAL);
 
 		interval = PR_SecondsToInterval(300); /* 5 min is default trimming interval */
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
 			"Trimming test: sleeping for 5 minutes until trimming kicks in\n");
 		DS_Sleep (interval);
 
@@ -297,17 +297,17 @@ static void testTrimming ()
 
 	if (rc == 0 && count == 300)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
 			"Trimming test completed successfully: changelog contains 300 entries\n");
 	}
 	else if (rc == 0)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
 			"Trimming test failed: changelog contains %d entries; expected - 300\n", 
 			count);
 	}
 	else /* general failure */
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Trimming test failed\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Trimming test failed\n");
 }
 
 static void testPerformance ()
@@ -324,7 +324,7 @@ static void testPerformance ()
 	endtime = PR_Now();
 
 	totaltime = (endtime - starttime) / 1000; /* ms */
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Write performance:\n"
+	slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Write performance:\n"
 					"entry count - %d, total time - %ldms\n"
 					"latency = %d msec\nthroughput = %d entry/sec\n",
 					entryCount, totaltime,
@@ -338,7 +338,7 @@ static void testPerformance ()
 	endtime = PR_Now();
 
 	totaltime = (endtime - starttime) / 1000; /* ms */
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Read performance:\n"
+	slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Read performance:\n"
 					"entry count - %d, total time - %ld\n"
 					"latency = %d msec\nthroughput = %d entry/sec\n",
 					entryCount, totaltime,
@@ -375,7 +375,7 @@ static void testPerformanceMT ()
 	endtime = PR_Now();
 
 	totaltime = (endtime - starttime) / 1000; /* ms */
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Write performance:\n"
+	slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Write performance:\n"
 					"entry count - %d, total time - %ld\n"
 					"latency = %d msec per entry\nthroughput = %d entry/sec\n",
 					entryCount, totaltime,
@@ -390,7 +390,7 @@ static void testPerformanceMT ()
 	endtime = PR_Now();
 
 	totaltime = (endtime - starttime) / 1000; /* ms */
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Read performance:\n"
+	slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Read performance:\n"
 					"entry count - %d, total time - %ld\n"
 					"latency = %d msec per entry\nthroughput = %d entry/sec\n",
 					entryCount, totaltime,
@@ -404,7 +404,7 @@ static void testLDIF ()
 	char *baseDir;
 	char ldifFile [MAXPATHLEN];
 
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "Starting LDIF test ...\n");	
+	slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "Starting LDIF test ...\n");	
 
 	baseDir = getBaseDir (clDir);
 	PR_snprintf (ldifFile, sizeof(ldifFile), "%s/cl5.ldif", baseDir);
@@ -426,10 +426,10 @@ static void testLDIF ()
 	PR_Delete (ldifFile);
 
 	if (rc == CL5_SUCCESS)
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
 		"LDIF test completed successfully\n");
 	else
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "LDIF test failed\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "LDIF test failed\n");
 }
 
 static void testAll ()
@@ -448,11 +448,11 @@ static void testAll ()
 	/* xxxPINAKI */
 	/* these tests are not working correctly...the call to db->put() */
 	/* just hangs forever */
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
+	slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
 					"Starting single threaded performance measurement ...\n");	
 	testPerformance ();	
 
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
+	slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
 					"Starting multi threaded performance measurement ...\n");	
 	testPerformanceMT ();
 #endif
@@ -523,7 +523,7 @@ static int populateChangelog (int entryCount, CSN ***csnList)
 			return -1;				
 	}
 
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
+	slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
 			"Successfully populated changelog with %d entries\n", entryCount);
 	return 0;
 }
@@ -547,7 +547,7 @@ static int processEntries (int entryCount, CSN **csnList)
 		operation_parameters_done (&op);
 	} 		
 
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, 
+	slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, 
 			"Successfully read %d entries from the changelog\n", entryCount);
 	return 0;
 }
@@ -660,7 +660,7 @@ static int  configureChangelog ()
     slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &rc);
     if (rc != LDAP_SUCCESS)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "failed to get server instance "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "failed to get server instance "
                         "directory; LDAP error - %d\n", rc);	
         rc = -1;
         goto done;
@@ -684,7 +684,7 @@ static int  configureChangelog ()
     slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &rc);
     if (rc != LDAP_SUCCESS)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "failed to add changelog "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "failed to add changelog "
                         "configuration entry; LDAP error - %d\n", rc);
         rc = -1;
     }
@@ -738,7 +738,7 @@ static int  configureReplica ()
     slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &rc);
     if (rc != LDAP_SUCCESS)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "failed to add replica for (%s) "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "failed to add replica for (%s) "
                         "configuration entry; LDAP error - %d\n", REPLICA_ROOT, rc);
         rc = -1;
     }
@@ -777,7 +777,7 @@ static int  populateChangelogOp ()
     slapi_pblock_destroy (pb);
     if (rc != LDAP_SUCCESS)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "failed to add entry (%s); "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "failed to add entry (%s); "
                         "LDAP error - %d\n", dn, rc);
         return -1;
     }
@@ -800,7 +800,7 @@ static int  populateChangelogOp ()
     slapi_pblock_destroy (pb);
     if (rc != LDAP_SUCCESS)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "failed to modify entry (%s); "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "failed to modify entry (%s); "
                         "LDAP error - %d\n", dn, rc);
         return -1;
     }
@@ -816,7 +816,7 @@ static int  populateChangelogOp ()
     slapi_pblock_destroy (pb);
     if (rc != LDAP_SUCCESS)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "failed to rename entry (%s); "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "failed to rename entry (%s); "
                         "LDAP error - %d\n", dn, rc);
         return -1;
     }
@@ -831,7 +831,7 @@ static int  populateChangelogOp ()
     slapi_pblock_destroy (pb);
     if (rc != LDAP_SUCCESS)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name_cl, "failed to delete entry (%s); "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name_cl, "failed to delete entry (%s); "
                         "LDAP error - %d\n", dn, rc);
         return -1;
     }

ldap/servers/plugins/replication/cl_crypt.c

@@ -37,7 +37,7 @@ clcrypt_init(const CL5DBConfig *config, void **clcrypt_handle)
     Slapi_Backend *be = NULL;
     back_info_crypt_init crypt_init = {0};
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, repl_plugin_name, "-> clcrypt_init\n");
+    slapi_log_error(SLAPI_LOG_TRACE, repl_plugin_name, "-> clcrypt_init\n");
     /* Encryption is not specified */
     if (!config->encryptionAlgorithm || !clcrypt_handle) {
         goto bail;
@@ -64,7 +64,7 @@ clcrypt_init(const CL5DBConfig *config, void **clcrypt_handle)
         rc = 1;
     }
 bail:
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, repl_plugin_name,
+    slapi_log_error(SLAPI_LOG_TRACE, repl_plugin_name,
                     "<- clcrypt_init : %d\n", rc);
     return rc;
 }
@@ -86,7 +86,7 @@ clcrypt_encrypt_value(void *clcrypt_handle,
     Slapi_Backend *be = NULL;
     back_info_crypt_value crypt_value = {0};
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, repl_plugin_name, 
+    slapi_log_error(SLAPI_LOG_TRACE, repl_plugin_name, 
                     "-> clcrypt_encrypt_value\n");
     if (NULL == out) {
         goto bail;
@@ -116,7 +116,7 @@ clcrypt_encrypt_value(void *clcrypt_handle,
         rc = -1;
     }
 bail:
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, repl_plugin_name, 
+    slapi_log_error(SLAPI_LOG_TRACE, repl_plugin_name, 
                     "<- clcrypt_encrypt_entry (returning %d)\n", rc);
     return rc;
 }
@@ -138,7 +138,7 @@ clcrypt_decrypt_value(void *clcrypt_handle,
     Slapi_Backend *be = NULL;
     back_info_crypt_value crypt_value = {0};
 
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, repl_plugin_name, 
+    slapi_log_error(SLAPI_LOG_TRACE, repl_plugin_name, 
                     "-> clcrypt_decrypt_value\n");
     if (NULL == out) {
         goto bail;
@@ -168,7 +168,7 @@ clcrypt_decrypt_value(void *clcrypt_handle,
         rc = -1;
     }
 bail:
-    slapi_log_error(SLAPI_LOG_TRACE, LOG_DEBUG, repl_plugin_name, 
+    slapi_log_error(SLAPI_LOG_TRACE, repl_plugin_name, 
                     "<- clcrypt_decrypt_entry (returning %d)\n", rc);
     return rc;
 }

ldap/servers/plugins/replication/csnpl.c

@@ -40,16 +40,16 @@ CSNPL* csnplNew ()
 	csnpl = (CSNPL *)slapi_ch_malloc (sizeof (CSNPL));
 	if (csnpl == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
-						"csnplNew: failed to allocate pending list\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
+						"csnplNew - Failed to allocate pending list\n");
 		return NULL;
 	}
 
 	csnpl->csnList = llistNew ();
 	if (csnpl->csnList == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
-						"csnplNew: failed to allocate pending list\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
+						"csnplNew - Failed to allocate pending list\n");
 		slapi_ch_free ((void**)&csnpl);
 		return NULL;	
 	}
@@ -59,8 +59,8 @@ CSNPL* csnplNew ()
 
 	if (csnpl->csnLock == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
-						"csnplNew: failed to create lock; NSPR error - %d\n",
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
+						"csnplNew - Failed to create lock; NSPR error - %d\n",
 						PR_GetError ());
 		slapi_ch_free ((void**)&(csnpl->csnList));
 		slapi_ch_free ((void**)&csnpl);
@@ -111,8 +111,8 @@ int csnplInsert (CSNPL *csnpl, const CSN *csn)
 
 	if (csnpl == NULL || csn == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
-			"csnplInsert: invalid argument\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
+			"csnplInsert - Invalid argument\n");
 		return -1;
 	}
 	
@@ -143,8 +143,8 @@ int csnplInsert (CSNPL *csnpl, const CSN *csn)
 	{
 		char s[CSN_STRSIZE];		
         if (slapi_is_loglevel_set(SLAPI_LOG_REPL)) {
-            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
-                            "csnplInsert: failed to insert csn (%s) into pending list\n", csn_as_string(csn,PR_FALSE,s));
+            slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, 
+                            "csnplInsert - Failed to insert csn (%s) into pending list\n", csn_as_string(csn,PR_FALSE,s));
         }
 		return -1;
 	}
@@ -159,7 +159,7 @@ int csnplRemove (CSNPL *csnpl, const CSN *csn)
 
     if (csnpl == NULL || csn == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 			"csnplRemove: invalid argument\n");
 		return -1;
 	}
@@ -193,7 +193,7 @@ int csnplCommit (CSNPL *csnpl, const CSN *csn)
 
     if (csnpl == NULL || csn == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 			"csnplCommit: invalid argument\n");
 		return -1;
 	}
@@ -218,7 +218,7 @@ int csnplCommit (CSNPL *csnpl, const CSN *csn)
 		ReplicaId rid = csn_get_replicaid (csn);
 		if (rid < MAX_REPLICA_ID)
 		{
-	        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+	        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 			            "csnplCommit: can't find csn %s\n", csn_str);
 		}
 		slapi_rwlock_unlock (csnpl->csnLock);
@@ -329,12 +329,12 @@ static void _csnplDumpContentNoLock(CSNPL *csnpl, const char *caller)
     
     data = (csnpldata *)llistGetFirst(csnpl->csnList, &iterator);
 	if (data) {
-	    slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "%s: CSN Pending list content:\n",
+	    slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "%s: CSN Pending list content:\n",
                     caller ? caller : "");
 	}
     while (data)
     {
-        slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "%s, %s\n",                        
+        slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "%s, %s\n",                        
                         csn_as_string(data->csn, PR_FALSE, csn_str),
                         data->committed ? "committed" : "not committed");
         data = (csnpldata *)llistGetNext (csnpl->csnList, &iterator);

ldap/servers/plugins/replication/legacy_consumer.c

@@ -230,7 +230,7 @@ legacy_consumer_config_init()
 	int rc;
 
 	if ((legacy_consumer_config_lock = slapi_new_rwlock()) == NULL) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
 				"Failed to create legacy_consumer config read-write lock\n");
 		exit(1);
 	}
@@ -238,7 +238,7 @@ legacy_consumer_config_init()
 	rc = legacy_consumer_read_config ();
 	if (rc != LDAP_SUCCESS)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 			"Failed to initialize legacy replication configuration\n");
 		return 1;
 	}
@@ -260,13 +260,13 @@ legacy_consumer_config_add (Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entry
 	if (rc != LDAP_SUCCESS)
 	{
 		*returncode = rc;
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Failed to configure legacy replication\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "Failed to configure legacy replication\n");
 		return SLAPI_DSE_CALLBACK_ERROR;
 	}
     /* make sure that the password is encoded */
     legacy_consumer_encode_pw(e);
 
-    slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "legacy_consumer_config_add: "
+    slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "legacy_consumer_config_add: "
                     "successfully configured legacy consumer credentials\n");
 
 	return SLAPI_DSE_CALLBACK_OK;
@@ -328,7 +328,7 @@ legacy_consumer_config_modify (Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi
 						if (legacy_consumer_replicationdn != NULL)
 						{
 							not_allowed = 1;
-							slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+							slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 									"Multiple replicationdns not permitted." );
 						}
 						else
@@ -354,7 +354,7 @@ legacy_consumer_config_modify (Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi
                         if (legacy_consumer_replicationpw != NULL)
                         {
                             not_allowed = 1;
-                            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+                            slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
 								"Multiple replicationpws not permitted." );
                         }
                         else
@@ -373,7 +373,7 @@ legacy_consumer_config_modify (Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi
 
 	if (not_allowed)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 						"Failed to modify legacy replication configuration\n" );
 		*returncode= LDAP_CONSTRAINT_VIOLATION;
 		return SLAPI_DSE_CALLBACK_ERROR;
@@ -586,7 +586,7 @@ get_legacy_referral (Slapi_Entry *e, char **referral, char **state)
         if (rc != 0)
         {
             const char *target_dn = slapi_entry_get_dn_const(e);
-		    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Warning: a copiedFrom "
+		    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "Warning: a copiedFrom "
 			"or copyingFrom attribute was added to or removed from an "
 			"entry that is not the root of a replicated area. It is possible "
 			"that a legacy replication supplier is incorrectly configured "
@@ -653,7 +653,7 @@ legacy_consumer_init_referrals (Replica *r)
         if (rc == LDAP_REFERRAL)
         {
             /* We are in referral mode, probably because ORC failed */
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "legacy_consumer_init_referrals "
+            slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "legacy_consumer_init_referrals "
                             "data for replica %s is in referral mode due to failed "
                             "initialization. Replica need to be reinitialized\n",
                             root_dn);
@@ -661,7 +661,7 @@ legacy_consumer_init_referrals (Replica *r)
         }
         else
         {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "legacy_consumer_init_referrals "
+            slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "legacy_consumer_init_referrals "
                             "failed to obtain root entry for replica %s; LDAP error - %d\n",
                             root_dn, rc);
             rc = -1;

ldap/servers/plugins/replication/llist.c

@@ -201,14 +201,14 @@ int	llistInsertHead (LList *list, const char *key, void *data)
 	LNode *node;
 	if (list == NULL || list->head == NULL || data == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "llistInsertHead: invalid argument\n");
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "llistInsertHead: invalid argument\n");
 		return -1;	
 	}
 
 	node = _llistNewNode (key, data);
 	if (node == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "llistInsertHead: failed to allocate list node\n");
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "llistInsertHead: failed to allocate list node\n");
 		return -1;
 	}
 
@@ -231,14 +231,14 @@ int llistInsertTail (LList *list, const char *key, void *data)
 	LNode *node;
 	if (list == NULL || list->head == NULL || data == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "llistInsertHead: invalid argument\n");
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "llistInsertHead: invalid argument\n");
 		return -1;	
 	}
 
 	node = _llistNewNode (key, data);
 	if (node == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "llistInsertHead: failed to allocate list node\n");
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "llistInsertHead: failed to allocate list node\n");
 		return -1;
 	}
 

ldap/servers/plugins/replication/profile.c

@@ -25,7 +25,7 @@ static FILE *profile_fd=NULL;
 void profile_log(char *file,int line)
 {
 	if (profile_fd==NULL)
-		slapi_log_error(,"profile_log: profile file not open.");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "profile_log: profile file not open.");
 	else
 	{
 	    /* JCMREPL - Probably need a lock around here */
@@ -43,7 +43,7 @@ void profile_open()
 void profile_close()
 {
 	if (profile_fd==NULL)
-		slapi_log_error(SLAPI_LOG_ERROR, "repl_profile" ,"profile_close: profile file not open.");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name ,"profile_close: profile file not open.");
 	else
 		textfile_close(profile_fd);
 }

ldap/servers/plugins/replication/repl5.h

@@ -681,7 +681,7 @@ int is_task_aborted(ReplicaId rid);
 void delete_aborted_rid(Replica *replica, ReplicaId rid, char *repl_root, int skip);
 int is_pre_cleaned_rid(ReplicaId rid);
 void set_cleaned_rid(ReplicaId rid);
-void cleanruv_log(Slapi_Task *task, int rid, char *task_type, char *fmt, ...);
+void cleanruv_log(Slapi_Task *task, int rid, char *task_type, int sev_level, char *fmt, ...);
 char * replica_cleanallruv_get_local_maxcsn(ReplicaId rid, char *base_dn);
 
 #define CLEANRIDSIZ 64 /* maximum number for concurrent CLEANALLRUV tasks */
@@ -726,7 +726,7 @@ void replica_updatedn_list_enumerate(ReplicaUpdateDNList list, FNEnumDN fn, void
 
 /* enabling developper traces for MMR to understand the total/inc protocol state machines */
 #ifdef DEV_DEBUG
-#define SLAPI_LOG_DEV_DEBUG SLAPI_LOG_FATAL
+#define SLAPI_LOG_DEV_DEBUG SLAPI_LOG_DEBUG
 #define dev_debug(a) slapi_log_error(SLAPI_LOG_DEV_DEBUG, "DEV_DEBUG", "%s\n", a)
 #else
 #define dev_debug(a)

ldap/servers/plugins/replication/repl5_agmt.c

@@ -172,36 +172,36 @@ agmt_is_valid(Repl_Agmt *ra)
 
 	if (NULL == ra->hostname)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Replication agreement \"%s\" "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmt_is_valid - Replication agreement \"%s\" "
 			"is malformed: missing host name.\n", slapi_sdn_get_dn(ra->dn));
 		return_value = 0;
 	}
 	if (ra->port <= 0)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Replication agreement \"%s\" "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmt_is_valid - Replication agreement \"%s\" "
 			"is malformed: invalid port number %d.\n", slapi_sdn_get_dn(ra->dn), ra->port);
 		return_value = 0;
 	}
 	if (ra->timeout < 0)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Replication agreement \"%s\" "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmt_is_valid - Replication agreement \"%s\" "
 			"is malformed: invalid timeout %ld.\n", slapi_sdn_get_dn(ra->dn), ra->timeout);
 		return_value = 0;
 	}
 	if (ra->busywaittime < 0)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Replication agreement \"%s\" "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmt_is_valid - Replication agreement \"%s\" "
 			"is malformed: invalid busy wait time %ld.\n", slapi_sdn_get_dn(ra->dn), ra->busywaittime);
 		return_value = 0;
 	}
 	if (ra->pausetime < 0)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Replication agreement \"%s\" "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmt_is_valid - Replication agreement \"%s\" "
 			"is malformed: invalid pausetime %ld.\n", slapi_sdn_get_dn(ra->dn), ra->pausetime);
 		return_value = 0;
 	}
 	if ((0 == ra->transport_flags) && (BINDMETHOD_SSL_CLIENTAUTH == ra->bindmethod)) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Replication agreement \"%s\" "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmt_is_valid - Replication agreement \"%s\" "
 						" is malformed: cannot use SSLCLIENTAUTH if using plain LDAP - please "
 						"change %s to SSL or TLS before changing %s to use SSLCLIENTAUTH\n",
 						slapi_sdn_get_dn(ra->dn), type_nsds5TransportInfo, type_nsds5ReplicaBindMethod);
@@ -221,7 +221,7 @@ agmt_is_valid(Repl_Agmt *ra)
 			} else {
 				auth_mech = "Unknown";
 			}
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Replication agreement \"%s\" "
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmt_is_valid - Replication agreement \"%s\" "
 				"is malformed: a bind DN and password must be supplied for authentication "
 				"method \"%s\"\n", slapi_sdn_get_dn(ra->dn), auth_mech);
 			return_value = 0;
@@ -244,14 +244,14 @@ agmt_new_from_entry(Slapi_Entry *e)
 	ra = (Repl_Agmt *)slapi_ch_calloc(1, sizeof(repl5agmt));
 	if ((ra->lock = PR_NewLock()) == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Unable to create new lock "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmt_new_from_entry - Unable to create new lock "
 			"for replication agreement \"%s\" - agreement ignored.\n",
 			slapi_entry_get_dn_const(e));
 		goto loser;
 	}
 	if ((ra->attr_lock = slapi_new_rwlock()) == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Unable to create new attr lock "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmt_new_from_entry - Unable to create new attr lock "
 			"for replication agreement \"%s\" - agreement ignored.\n",
 			slapi_entry_get_dn_const(e));
 		goto loser;
@@ -382,9 +382,9 @@ agmt_new_from_entry(Slapi_Entry *e)
 		} else if(strcasecmp(tmpstr, "on") == 0){
 			ra->is_enabled = PR_TRUE;
 		} else {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Warning invalid value "
-			    "for nsds5ReplicaEnabled (%s), value must be \"on\" or \"off\".  Ignoring "
-			    "this repl agreement.\n",tmpstr);
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmt_new_from_entry - "
+				"Warning invalid value for nsds5ReplicaEnabled (%s), value must be \"on\" or \"off\".  "
+				"Ignoring this repl agreement.\n",tmpstr);
 			slapi_ch_free_string(&tmpstr);
 			goto loser;
 		}
@@ -474,8 +474,8 @@ agmt_new_from_entry(Slapi_Entry *e)
 	 * could be a default excluded attr list in cn=plugin default config */
 	if (agmt_set_replicated_attributes_from_attr(ra, sattr) != 0)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-						"agmtlist_add_callback: failed to parse "
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+						"agmt_new_from_entry: failed to set "
 						"replicated attributes for agreement %s\n",
 						agmt_get_long_name(ra));
 	}
@@ -484,8 +484,8 @@ agmt_new_from_entry(Slapi_Entry *e)
 	if (denied_attrs)
 	{
 		/* Report the error to the client */
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
-						"WARNING: Attempt to exclude illegal attributes "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
+						"agmt_new_from_entry: Attempt to exclude illegal attributes "
 						"from a fractional agreement\n");
 		/* Free the list */
 		slapi_ch_array_free(denied_attrs);
@@ -496,8 +496,8 @@ agmt_new_from_entry(Slapi_Entry *e)
 	slapi_entry_attr_find(e, type_nsds5ReplicatedAttributeListTotal, &sattr);
 	if (sattr && agmt_set_replicated_attributes_total_from_attr(ra, sattr) != 0)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-						"agmtlist_add_callback: failed to parse total "
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+						"agmt_new_from_entry: failed to parse total "
 						"update replicated attributes for agreement %s\n",
 						agmt_get_long_name(ra));
 	}
@@ -506,8 +506,8 @@ agmt_new_from_entry(Slapi_Entry *e)
 	if (denied_attrs)
 	{
 		/* Report the error to the client */
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-						"WARNING: Attempt to exclude illegal attributes "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+						"agmt_new_from_entry: Attempt to exclude illegal attributes "
 						"from a fractional agreement for total update protocol\n");
 		/* Free the list */
 		slapi_ch_array_free(denied_attrs);
@@ -531,7 +531,7 @@ agmt_new_from_entry(Slapi_Entry *e)
 
 	/* Now that the agreement is done, just check if changelog is configured */
 	if (cl5GetState() != CL5_STATE_OPEN) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "WARNING: "
+		slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name, "agmt_new_from_entry: "
 						"Replication agreement added but there is no changelog configured. "
 						"No change will be replicated until a changelog is configured.\n");
 	}
@@ -697,7 +697,7 @@ agmt_start(Repl_Agmt *ra)
      */
     repl_sdn = agmt_get_replarea(ra);
     if (!repl_sdn) {
-        slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
+        slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
                         "agmt_start: failed to get repl area.  Please check agreement.\n");
         prot_free(&prot);
         return -1;
@@ -723,7 +723,7 @@ agmt_start(Repl_Agmt *ra)
     if (rc == LDAP_SUCCESS){
         slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &entries);
         if (NULL == entries || NULL == entries[0]){
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+            slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
                 "agmt_start: replica ruv tombstone entry for "
                 "replica %s not found\n",
             slapi_sdn_get_dn(ra->replarea));
@@ -739,7 +739,7 @@ agmt_start(Repl_Agmt *ra)
 
     /* Check that replication is not already started */
     if (ra->protocol != NULL) {
-        slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "replication already started for agreement \"%s\"\n", agmt_get_long_name(ra));
+        slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "replication already started for agreement \"%s\"\n", agmt_get_long_name(ra));
         prot_free(&prot);
         goto done;
     }
@@ -831,7 +831,7 @@ windows_agmt_start(Repl_Agmt *ra)
 
     /* Check that replication is not already started */
     if (ra->protocol != NULL) {
-        slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "replication already started for agreement \"%s\"\n", agmt_get_long_name(ra));
+        slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "replication already started for agreement \"%s\"\n", agmt_get_long_name(ra));
         PR_Unlock(ra->lock);
         prot_free(&prot);
         return 0;
@@ -1515,7 +1515,7 @@ _agmt_set_default_fractional_attrs(Repl_Agmt *ra)
 				rc = agmt_parse_excluded_attrs_config_attr(val,
 														   &(ra->frac_attrs));
 				if (0 != rc) {
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+					slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
 							"_agmt_set_default_fractional_attrs: failed to "
 							"parse default config (%s) attribute %s value: %s\n",
 							SLAPI_PLUGIN_DEFAULT_CONFIG,
@@ -2264,7 +2264,7 @@ agmt_replica_init_done (const Repl_Agmt *agmt)
     slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &rc);
     if (rc != LDAP_SUCCESS && rc != LDAP_NO_SUCH_ATTRIBUTE)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "agmt_replica_init_done: "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmt_replica_init_done: "
                         "failed to remove (%s) attribute from (%s) entry; LDAP error - %d\n",
                         type_nsds5ReplicaInitialize, slapi_sdn_get_ndn (agmt->dn), rc);   
     }
@@ -2300,7 +2300,7 @@ agmt_set_consumer_ruv (Repl_Agmt *ra, RUV *ruv)
 {
     if (ra == NULL || ruv == NULL)
     {
-        slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmt_set_consumer_ruv: invalid argument" 
+        slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "agmt_set_consumer_ruv: invalid argument" 
                         " agmt - %p, ruv - %p\n", ra, ruv); 
         return -1;
     }
@@ -2357,9 +2357,10 @@ agmt_update_consumer_ruv (Repl_Agmt *ra)
         slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &rc);
         if (rc != LDAP_SUCCESS && rc != LDAP_NO_SUCH_ATTRIBUTE)
         {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "%s: agmt_update_consumer_ruv: "
-                            "failed to update consumer's RUV; LDAP error - %d\n",
-							ra->long_name, rc);
+            slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmt_update_consumer_ruv - "
+                    "%s: agmt_update_consumer_ruv: "
+                    "failed to update consumer's RUV; LDAP error - %d\n",
+                    ra->long_name, rc);
         }
 
         slapi_mod_done (&smod);
@@ -2483,10 +2484,10 @@ agmt_set_last_update_status (Repl_Agmt *ra, int ldaprc, int replrc, const char *
 					"(If the suffix is disabled you must enable it then restart the server for replication to take place).",
 					replrc, ra->long_name ? ra->long_name : "a replica");
 				/* Log into the errors log, as "ra->long_name" is not accessible from the caller */
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
 					"Incremental update aborted: Replication agreement for \"%s\" "
 					"can not be updated while the replica is disabled\n", ra->long_name ? ra->long_name : "a replica");
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
 					"(If the suffix is disabled you must enable it then restart the server for replication to take place).\n");
 			}
 			else
@@ -2551,7 +2552,7 @@ agmt_set_last_init_status (Repl_Agmt *ra, int ldaprc, int replrc, int connrc, co
 			else if (replrc == NSDS50_REPL_DISABLED)
 			{
 				if(agmt_is_enabled(ra)){
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Total update aborted: "
+					slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "Total update aborted: "
 							"Replication agreement for \"%s\" can not be updated while the suffix is disabled.\n"
 							"You must enable it then restart the server for replication to take place).\n",
 							ra->long_name ? ra->long_name : "a replica");
@@ -2561,7 +2562,7 @@ agmt_set_last_init_status (Repl_Agmt *ra, int ldaprc, int replrc, int connrc, co
 							replrc, ra->long_name ? ra->long_name : "a replica");
 				} else {
 					/* You do not need to restart the server after enabling the agreement */
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Total update aborted: "
+					slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "Total update aborted: "
 							"Replication agreement for \"%s\" can not be updated while the agreement is disabled\n",
 							ra->long_name ? ra->long_name : "a replica");
 					PR_snprintf(ra->last_init_status, STATUS_LEN, "%d Total update aborted: "
@@ -2792,7 +2793,7 @@ agmt_get_consumer_rid ( Repl_Agmt *agmt, void *conn )
 		slapi_create_dn_string("cn=replica,cn=\"%s\",cn=mapping tree,cn=config",
 							   slapi_sdn_get_dn (agmt->replarea) );
 		if (NULL == mapping_tree_node) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 							"agmt_get_consumer_rid: failed to normalize "
 							"replica dn for %s\n", 
 							slapi_sdn_get_dn (agmt->replarea));
@@ -2895,7 +2896,7 @@ agmt_set_enabled_from_entry(Repl_Agmt *ra, Slapi_Entry *e, char *returntext){
 		} else if(strcasecmp(attr_val,"on") == 0){
 			is_enabled = PR_TRUE;
 		} else {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "agmt_set_enabled_from_entry: invalid "
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmt_set_enabled_from_entry: invalid "
 			    "value for nsds5ReplicaEnabled (%s), the value must be \"on\" or \"off\".\n", attr_val);
 			PR_snprintf(returntext, SLAPI_DSE_RETURNTEXT_SIZE, "Invalid value for nsds5ReplicaEnabled, "
 			    "the value must be \"on\" or \"off\".\n");
@@ -2907,7 +2908,7 @@ agmt_set_enabled_from_entry(Repl_Agmt *ra, Slapi_Entry *e, char *returntext){
 		if(is_enabled){
 			if(!ra->is_enabled){
 				ra->is_enabled = PR_TRUE;
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmt_set_enabled_from_entry: "
+				slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "agmt_set_enabled_from_entry: "
 					"agreement is now enabled (%s)\n",ra->long_name);
 				PR_Unlock(ra->lock);
 				agmt_start(ra);
@@ -2916,7 +2917,7 @@ agmt_set_enabled_from_entry(Repl_Agmt *ra, Slapi_Entry *e, char *returntext){
 		} else {
 			if(ra->is_enabled){
 				ra->is_enabled = PR_FALSE;
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmt_set_enabled_from_entry: "
+				slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "agmt_set_enabled_from_entry: "
 					"agreement is now disabled (%s)\n",ra->long_name);
 				PR_Unlock(ra->lock);
 				agmt_stop(ra);
@@ -3195,7 +3196,7 @@ agmt_remove_maxcsn(Repl_Agmt *ra)
 
     pb = slapi_pblock_new();
     if (!pb) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "agmt_set_maxcsn: Out of memory\n");
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmt_remove_maxcsn: Out of memory\n");
         goto done;
     }
 
@@ -3204,7 +3205,7 @@ agmt_remove_maxcsn(Repl_Agmt *ra)
         r = (Replica *)object_get_data(repl_obj);
         tombstone_sdn = replica_get_root(r);
     } else {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "agmt_set_maxcsn: Failed to get repl object.\n");
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmt_remove_maxcsn: Failed to get repl object.\n");
         goto done;
     }
     slapi_ch_free_string(&ra->maxcsn);
@@ -3237,8 +3238,8 @@ agmt_remove_maxcsn(Repl_Agmt *ra)
 
         slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &entries);
         if (NULL == entries || NULL == entries[0]){
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-                "agmt_set_maxcsn: replica ruv tombstone entry for "
+            slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+                "agmt_remove_maxcsn: replica ruv tombstone entry for "
                 "replica %s not found\n", slapi_sdn_get_dn(ra->replarea));
             goto done;
         }
@@ -3290,8 +3291,8 @@ agmt_remove_maxcsn(Repl_Agmt *ra)
                         slapi_modify_internal_pb(modpb);
                         slapi_pblock_get(modpb, SLAPI_PLUGIN_INTOP_RESULT, &rc);
                         if (rc != LDAP_SUCCESS){
-                            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-                                    "agmt_set_maxcsn: failed to remove agmt maxcsn (%s), error(%d)\n",maxcsns[i], rc);
+                            slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+                                    "agmt_remove_maxcsn: failed to remove agmt maxcsn (%s), error(%d)\n",maxcsns[i], rc);
                         }
                         slapi_mod_done(&smod);
                         slapi_pblock_destroy(modpb);

ldap/servers/plugins/replication/repl5_agmtlist.c

@@ -225,13 +225,13 @@ agmtlist_add_callback(Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Entry *entryAfter,
 	int *returncode, char *returntext, void *arg)
 {
 	int rc;
-	slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmt_add: begin\n");
+	slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "agmt_add: begin\n");
 
 	rc = add_new_agreement(e);
 	if (0 != rc) {
 		Slapi_DN *sdn = NULL;
 		slapi_pblock_get(pb, SLAPI_TARGET_SDN, &sdn);
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "agmtlist_add_callback: "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_add_callback - "
 			"Can't start agreement \"%s\"\n", slapi_sdn_get_dn(sdn));
 		*returncode = LDAP_UNWILLING_TO_PERFORM;
 		return SLAPI_DSE_CALLBACK_ERROR;
@@ -271,15 +271,15 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
 
     slapi_pblock_get(pb, SLAPI_TARGET_SDN, &sdn);
     if (NULL == sdn) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
-                        "agmtlist_modify_callback: NULL target dn\n");
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
+                        "agmtlist_modify_callback - NULL target dn\n");
         goto done;
     }
 	agmt = agmtlist_get_by_agmt_name(sdn);
 	if (NULL == agmt)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "agmtlist_modify_callback: received "
-			"a modification for unknown replication agreement \"%s\"\n", 
+		slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name, "agmtlist_modify_callback - "
+			"Received a modification for unknown replication agreement \"%s\"\n", 
 			slapi_sdn_get_dn(sdn));
 		goto done;
 	}
@@ -297,8 +297,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
                the replication plugin - handled above */
             if (mods[i]->mod_op & LDAP_MOD_DELETE)
             {
-                slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: " 
-                                "deletion of %s attribute is not allowed\n", type_nsds5ReplicaInitialize);	
+                slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback - " 
+                                "Deletion of %s attribute is not allowed\n", type_nsds5ReplicaInitialize);	
                 *returncode = LDAP_UNWILLING_TO_PERFORM;
                 rc = SLAPI_DSE_CALLBACK_ERROR;
                 break;
@@ -306,8 +306,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
             else
             {
                 if(val == NULL){
-                    slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: " 
-                                "no value provided for %s attribute\n", type_nsds5ReplicaInitialize);
+                    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback - " 
+                                "No value provided for %s attribute\n", type_nsds5ReplicaInitialize);
                     *returncode = LDAP_UNWILLING_TO_PERFORM;
                     rc = SLAPI_DSE_CALLBACK_ERROR;
                     break;   
@@ -331,7 +331,7 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
                     PR_snprintf (errortext, SLAPI_DSE_RETURNTEXT_SIZE, 
                                  "Invalid value (%s) value supplied for attr (%s); Ignoring ...", 
                                  val, mods[i]->mod_type);
-                    slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: %s\n", errortext);
+                    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback - %s\n", errortext);
                     *returncode = LDAP_UNWILLING_TO_PERFORM;
                     rc = SLAPI_DSE_CALLBACK_ERROR;
                 }
@@ -352,8 +352,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
 			/* New replica credentials */
 			if (agmt_set_credentials_from_entry(agmt, e) != 0)
             {
-                slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: " 
-                                "failed to update credentials for agreement %s\n",
+                slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback - " 
+                                "Failed to update credentials for agreement %s\n",
                                 agmt_get_long_name(agmt));	
                 *returncode = LDAP_OPERATIONS_ERROR;
                 rc = SLAPI_DSE_CALLBACK_ERROR;
@@ -365,8 +365,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
 			/* New replica timeout */
 			if (agmt_set_timeout_from_entry(agmt, e) != 0)
             {
-                slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: " 
-                                "failed to update timeout for agreement %s\n",
+                slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback - " 
+                                "Failed to update timeout for agreement %s\n",
                                 agmt_get_long_name(agmt));	
                 *returncode = LDAP_OPERATIONS_ERROR;
                 rc = SLAPI_DSE_CALLBACK_ERROR;
@@ -378,8 +378,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
 			/* New replica timeout */
 			if (agmt_set_flowcontrolwindow_from_entry(agmt, e) != 0)
 			{
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: " 
-						"failed to update the flow control window for agreement %s\n",
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback - " 
+						"Failed to update the flow control window for agreement %s\n",
 						agmt_get_long_name(agmt));	
 				*returncode = LDAP_OPERATIONS_ERROR;
 				rc = SLAPI_DSE_CALLBACK_ERROR;
@@ -391,8 +391,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
 			/* New replica timeout */
 			if (agmt_set_flowcontrolpause_from_entry(agmt, e) != 0)
 			{
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: " 
-						"failed to update the flow control pause for agreement %s\n",
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback - " 
+						"Failed to update the flow control pause for agreement %s\n",
 						agmt_get_long_name(agmt));	
 				*returncode = LDAP_OPERATIONS_ERROR;
 				rc = SLAPI_DSE_CALLBACK_ERROR;
@@ -404,8 +404,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
 			/* New replica busywaittime */
 			if (agmt_set_busywaittime_from_entry(agmt, e) != 0)
             {
-                slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: " 
-                                "failed to update busy wait time for agreement %s\n",
+                slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback -" 
+                                "Failed to update busy wait time for agreement %s\n",
                                 agmt_get_long_name(agmt));	
                 *returncode = LDAP_OPERATIONS_ERROR;
                 rc = SLAPI_DSE_CALLBACK_ERROR;
@@ -417,8 +417,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
 			/* New replica pausetime */
 			if (agmt_set_pausetime_from_entry(agmt, e) != 0)
             {
-                slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: " 
-                                "failed to update session pause time for agreement %s\n",
+                slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback - " 
+                                "Failed to update session pause time for agreement %s\n",
                                 agmt_get_long_name(agmt));	
                 *returncode = LDAP_OPERATIONS_ERROR;
                 rc = SLAPI_DSE_CALLBACK_ERROR;
@@ -430,8 +430,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
 			/* New replica Bind DN */
 			if (agmt_set_binddn_from_entry(agmt, e) != 0)
             {
-                slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: " 
-                                "failed to update bind DN for agreement %s\n",
+                slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback-  " 
+                                "Failed to update bind DN for agreement %s\n",
                                 agmt_get_long_name(agmt));	
                 *returncode = LDAP_OPERATIONS_ERROR;
                 rc = SLAPI_DSE_CALLBACK_ERROR;
@@ -442,9 +442,9 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
 			/* New replica host */
 			if (agmt_set_host_from_entry(agmt, e) != 0)
 			{
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-				                "agmtlist_modify_callback: "
-				                "failed to update host for agreement %s\n",
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				                "agmtlist_modify_callback - "
+				                "Failed to update host for agreement %s\n",
 				                agmt_get_long_name(agmt));
 				*returncode = LDAP_OPERATIONS_ERROR;
 				rc = SLAPI_DSE_CALLBACK_ERROR;
@@ -462,9 +462,9 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
 			/* New replica port */
 			if (agmt_set_port_from_entry(agmt, e) != 0)
 			{
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-				                "agmtlist_modify_callback: " 
-				                "failed to update port for agreement %s\n",
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				                "agmtlist_modify_callback - " 
+				                "Failed to update port for agreement %s\n",
 				                agmt_get_long_name(agmt));	
 				*returncode = LDAP_OPERATIONS_ERROR;
 				rc = SLAPI_DSE_CALLBACK_ERROR;
@@ -482,8 +482,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
 			/* New Transport info */
 			if (agmt_set_transportinfo_from_entry(agmt, e) != 0)
             {
-                slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: " 
-                                "failed to update transport info for agreement %s\n",
+                slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback - " 
+                                "Failed to update transport info for agreement %s\n",
                                 agmt_get_long_name(agmt));	
                 *returncode = LDAP_OPERATIONS_ERROR;
                 rc = SLAPI_DSE_CALLBACK_ERROR;
@@ -494,8 +494,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
 		{
 			if (agmt_set_bind_method_from_entry(agmt, e) != 0)
             {
-                slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: " 
-                                "failed to update bind method for agreement %s\n",
+                slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback - " 
+                                "Failed to update bind method for agreement %s\n",
                                 agmt_get_long_name(agmt));	
                 *returncode = LDAP_OPERATIONS_ERROR;
                 rc = SLAPI_DSE_CALLBACK_ERROR;
@@ -508,8 +508,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
 			/* New set of excluded attributes */
 			if (agmt_set_replicated_attributes_from_entry(agmt, e) != 0)
             {
-                slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: " 
-                                "failed to update replicated attributes for agreement %s\n",
+                slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback - " 
+                                "Failed to update replicated attributes for agreement %s\n",
                                 agmt_get_long_name(agmt));	
                 *returncode = LDAP_OPERATIONS_ERROR;
                 rc = SLAPI_DSE_CALLBACK_ERROR;
@@ -520,8 +520,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
 			{
 				/* Report the error to the client */
 				PR_snprintf (errortext, SLAPI_DSE_RETURNTEXT_SIZE, "attempt to exclude an illegal attribute in a fractional agreement");
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: " 
-                            "attempt to exclude an illegal attribute in a fractional agreement\n");
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback - " 
+					"Attempt to exclude an illegal attribute in a fractional agreement\n");
 
 				*returncode = LDAP_UNWILLING_TO_PERFORM;
 				rc = SLAPI_DSE_CALLBACK_ERROR;
@@ -537,8 +537,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
 			/* New set of excluded attributes */
 			if (agmt_set_replicated_attributes_total_from_entry(agmt, e) != 0)
 			{
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: "
-								"failed to update total update replicated attributes for agreement %s\n",
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback - "
+								"Failed to update total update replicated attributes for agreement %s\n",
 								agmt_get_long_name(agmt));
 				*returncode = LDAP_OPERATIONS_ERROR;
 				rc = SLAPI_DSE_CALLBACK_ERROR;
@@ -550,8 +550,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
 				/* Report the error to the client */
 				PR_snprintf (errortext, SLAPI_DSE_RETURNTEXT_SIZE, "attempt to exclude an illegal total update "
 						"attribute in a fractional agreement");
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: "
-						"attempt to exclude an illegal total update attribute in a fractional agreement\n");
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback - "
+						"Attempt to exclude an illegal total update attribute in a fractional agreement\n");
 
 				*returncode = LDAP_UNWILLING_TO_PERFORM;
 				rc = SLAPI_DSE_CALLBACK_ERROR;
@@ -576,8 +576,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
         else if (slapi_attr_types_equivalent(mods[i]->mod_type, type_nsds5ReplicaEnabled))
         {
             if(agmt_set_enabled_from_entry(agmt, e, returntext) != 0){
-                slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: "
-                    "failed to set replica agmt state \"enabled/disabled\" for %s\n",agmt_get_long_name(agmt));
+                slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback - "
+                    "Failed to set replica agmt state \"enabled/disabled\" for %s\n",agmt_get_long_name(agmt));
                 *returncode = LDAP_OPERATIONS_ERROR;
                 rc = SLAPI_DSE_CALLBACK_ERROR;
             }
@@ -585,8 +585,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
         else if (slapi_attr_types_equivalent(mods[i]->mod_type, type_nsds5ReplicaStripAttrs))
         {
             if(agmt_set_attrs_to_strip(agmt, e) != 0){
-                slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: "
-                    "failed to set replica agmt attributes to strip for %s\n",agmt_get_long_name(agmt));
+                slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback - "
+                    "Failed to set replica agmt attributes to strip for %s\n",agmt_get_long_name(agmt));
                 *returncode = LDAP_OPERATIONS_ERROR;
                 rc = SLAPI_DSE_CALLBACK_ERROR;
             }
@@ -609,8 +609,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
                     PR_snprintf (returntext, SLAPI_DSE_RETURNTEXT_SIZE,
                                  "attribute %s value (%s) is invalid, must be a number greater than zero.\n",
                                  type_replicaProtocolTimeout, val ? val : "");
-                    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "attribute %s value (%s) is invalid, "
-                                    "must be a number greater than zero.\n",
+                    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback - "
+                            "Attribute %s value (%s) is invalid, must be a number greater than zero.\n",
                                     type_replicaProtocolTimeout, val ? val : "");
                     rc = SLAPI_DSE_CALLBACK_ERROR;
                     break;
@@ -629,8 +629,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
         else if ((0 == windows_handle_modify_agreement(agmt, mods[i]->mod_type, e)) &&
                  (0 == id_extended_agreement(agmt, mods, e)))
         {
-            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: " 
-                            "modification of %s attribute is not allowed\n", mods[i]->mod_type);
+            slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback - " 
+                            "Modification of %s attribute is not allowed\n", mods[i]->mod_type);
             *returncode = LDAP_UNWILLING_TO_PERFORM;
             rc = SLAPI_DSE_CALLBACK_ERROR;
             break;
@@ -664,8 +664,8 @@ agmtlist_modify_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry
     {
 		if (agmt_set_schedule_from_entry(agmt, e) != 0)
         {
-            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_modify_callback: " 
-                            "failed to update replication schedule for agreement %s\n",
+            slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_modify_callback - " 
+                            "Failed to update replication schedule for agreement %s\n",
                             agmt_get_long_name(agmt));	
             *returncode = LDAP_OPERATIONS_ERROR;
             rc = SLAPI_DSE_CALLBACK_ERROR;
@@ -689,12 +689,12 @@ agmtlist_delete_callback(Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Entry *entryAft
 	Repl_Agmt *ra;
 	Object *ro;
 
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "agmt_delete: begin\n");
+	slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "agmtlist_delete_callback - Begin\n");
 	ro = objset_find(agmt_set, agmt_dn_cmp, (const void *)slapi_entry_get_sdn_const(e));
 	ra = (NULL == ro) ? NULL : (Repl_Agmt *)object_get_data(ro);
 	if (NULL == ra)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "agmtlist_delete: "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "agmtlist_delete_callback - "
 			"Tried to delete replication agreement \"%s\", but no such "
 			"agreement was configured.\n", slapi_sdn_get_dn(slapi_entry_get_sdn_const(e)));
 	}
@@ -713,7 +713,7 @@ static int
 agmtlist_rename_callback(Slapi_PBlock *pb, Slapi_Entry *entryBefore, Slapi_Entry *e,
 	int *returncode, char *returntext, void *arg)
 {
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "agmt_rename: begin\n");
+	slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "agmtlist_rename_callback - Begin\n");
 
 	*returncode = LDAP_SUCCESS;
 	return SLAPI_DSE_CALLBACK_OK;
@@ -726,8 +726,8 @@ handle_agmt_search(Slapi_Entry *e, void *callback_data)
 	int *agmtcount = (int *)callback_data;
 	int rc;
 
-	slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-		"Found replication agreement named \"%s\".\n",
+	slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+		"handle_agmt_search - Found replication agreement named \"%s\".\n",
 		slapi_sdn_get_dn(slapi_entry_get_sdn(e)));
 	rc = add_new_agreement(e);
 	if (0 == rc)
@@ -736,8 +736,8 @@ handle_agmt_search(Slapi_Entry *e, void *callback_data)
 	}
 	else
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "The replication "
-			"agreement named \"%s\" could not be correctly parsed. No "
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "handle_agmt_search - "
+			"The replication agreement named \"%s\" could not be correctly parsed. No "
 			"replication will occur with this replica.\n",
 			slapi_sdn_get_dn(slapi_entry_get_sdn(e)));
 	}
@@ -784,7 +784,8 @@ agmtlist_config_init()
 		NULL /* referral callback */);
 	slapi_pblock_destroy(pb);
 
-	slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "agmtlist_config_init: found %d replication agreements in DIT\n", agmtcount);
+	slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "agmtlist_config_init - "
+		"Found %d replication agreements in DIT\n",	agmtcount);
 
 	return 0;
 }

ldap/servers/plugins/replication/repl5_connection.c

@@ -435,8 +435,8 @@ conn_read_result_ex(Repl_Connection *conn, char **retoidp, struct berval **retda
 				/* must not access conn->ld if disconnected in another thread */
 				/* the other thread that actually did the conn_disconnect() */
 				/* will set the status and error info */
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-								"%s: Connection disconnected by another thread\n",
+				slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+								"conn_read_result_ex - %s: Connection disconnected by another thread\n",
 								agmt_get_long_name(conn->agmt));
 			}
 			else if (-1 == rc)
@@ -557,8 +557,8 @@ see_if_write_available(Repl_Connection *conn, PRIntervalTime timeout)
 
 	/* get the sockbuf */
 	if ((ldap_get_option(conn->ld, LDAP_OPT_DESC, &fd) != LDAP_OPT_SUCCESS) || (fd <= 0)) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-						"%s: invalid connection insee_if_write_available \n",
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+						"see_if_write_available - %s - *Invalid connection\n",
 						agmt_get_long_name(conn->agmt));
 		conn->last_ldap_error = LDAP_PARAM_ERROR;
 		return CONN_OPERATION_FAILED;
@@ -578,14 +578,14 @@ see_if_write_available(Repl_Connection *conn, PRIntervalTime timeout)
 
 	/* check */
 	if (rc == 0) { /* timeout */
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-						"%s: poll timed out - poll interval [%d]\n",
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+						"see_if_write_available - %s - poll timed out - poll interval [%d]\n",
 						agmt_get_long_name(conn->agmt),
 						timeout);
 		return CONN_TIMEOUT;
 	} else if ((rc < 0) || (!(polldesc.out_flags&PR_POLL_WRITE))) { /* error */
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-						"%s: error during poll attempt [%d:%s]\n",
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+						"see_if_write_available - %s - error during poll attempt [%d:%s]\n",
 						agmt_get_long_name(conn->agmt),
 						PR_GetError(), slapd_pr_strerror(PR_GetError()));
 		conn->last_ldap_error = LDAP_PARAM_ERROR;
@@ -615,9 +615,8 @@ see_if_write_available(Repl_Connection *conn, PRIntervalTime timeout)
 	iofns.lextiof_size = LDAP_X_EXTIO_FNS_SIZE;
 	if (ldap_get_option(conn->ld, LDAP_X_OPT_EXTIO_FN_PTRS, &iofns) < 0) {
 		rc = slapi_ldap_get_lderrno(conn->ld, NULL, NULL);
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-						"%s: Failed call to ldap_get_option to get extiofns in "
-						"see_if_write_available: LDAP error %d (%s)\n",
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+						"see_if_write_available - %s: Failed call to ldap_get_option to get extiofns: LDAP error %d (%s)\n",
 						agmt_get_long_name(conn->agmt),
 						rc, ldap_err2string(rc));
 		conn->last_ldap_error = rc;
@@ -628,9 +627,8 @@ see_if_write_available(Repl_Connection *conn, PRIntervalTime timeout)
 	/* set up the poll structure */
 	if (ldap_get_option(conn->ld, LDAP_OPT_DESC, &pollstr.lpoll_fd) < 0) {
 		rc = slapi_ldap_get_lderrno(conn->ld, NULL, NULL);
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-						"%s: Failed call to ldap_get_option for poll_fd in "
-						"see_if_write_available: LDAP error %d (%s)\n",
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+						"see_if_write_available - %s: Failed call to ldap_get_option for poll_fd: LDAP error %d (%s)\n",
 						agmt_get_long_name(conn->agmt),
 						rc, ldap_err2string(rc));
 		conn->last_ldap_error = rc;
@@ -640,9 +638,8 @@ see_if_write_available(Repl_Connection *conn, PRIntervalTime timeout)
 	if (ldap_get_option(conn->ld, LDAP_X_OPT_SOCKETARG,
 						&pollstr.lpoll_socketarg) < 0) {
 		rc = slapi_ldap_get_lderrno(conn->ld, NULL, NULL);
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-						"%s: Failed call to ldap_get_option for socketarg in "
-						"see_if_write_available: LDAP error %d (%s)\n",
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+						"see_if_write_available - %s: Failed call to ldap_get_option for socketarg: LDAP error %d (%s)\n",
 						agmt_get_long_name(conn->agmt),
 						rc, ldap_err2string(rc));
 		conn->last_ldap_error = rc;
@@ -654,7 +651,7 @@ see_if_write_available(Repl_Connection *conn, PRIntervalTime timeout)
 	private = iofns.lextiof_session_arg;
 
 	if (0 == (*ldap_poll)(&pollstr, nfds, timeout, private)) {
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
 						"%s: poll timed out - poll interval [%d]\n",
 						agmt_get_long_name(conn->agmt),
 						timeout);
@@ -687,13 +684,13 @@ check_flow_control_tot_init(Repl_Connection *conn, int optype, const char *extop
          */
         rcv_msgid = repl5_tot_last_rcv_msgid(conn);
         if (rcv_msgid == -1) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-                            "%s: check_flow_control_tot_init no callback data [ msgid sent: %d]\n",
+            slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+                            "check_flow_control_tot_init - %s - Check_flow_control_tot_init no callback data [ msgid sent: %d]\n",
                             agmt_get_long_name(conn->agmt),
                             sent_msgid);
         } else if (sent_msgid < rcv_msgid) {
-            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-                            "%s: check_flow_control_tot_init invalid message ids [ msgid sent: %d, rcv: %d]\n",
+            slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+                            "check_flow_control_tot_init - %s - Invalid message ids [ msgid sent: %d, rcv: %d]\n",
                             agmt_get_long_name(conn->agmt),
                             sent_msgid,
                             rcv_msgid);
@@ -713,8 +710,8 @@ check_flow_control_tot_init(Repl_Connection *conn, int optype, const char *extop
                      * Log it at least once to inform administrator there is
                      * a potential configuration issue here
                      */
-                    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-                            "%s: Total update flow control gives time (%d msec) to the consumer before sending more entries [ msgid sent: %d, rcv: %d])\n"
+                    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+                            "check_flow_control_tot_init - %s -  Total update flow control gives time (%d msec) to the consumer before sending more entries [ msgid sent: %d, rcv: %d])\n"
                             "If total update fails you can try to increase %s and/or decrease %s in the replica agreement configuration\n",
                             agmt_get_long_name(conn->agmt),
                             totalUpdatePause,
@@ -775,8 +772,8 @@ conn_is_available(Repl_Connection *conn)
             } else {
                 /* Else give connection to others threads */
                 PR_Unlock(conn->lock);
-                slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-                        "%s: perform_operation transient timeout. retry)\n",
+                slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+                        "conn_is_available - %s: transient timeout. retry)\n",
                         agmt_get_long_name(conn->agmt));
                 DS_Sleep(PR_MillisecondsToInterval(yield_delay_msec));
                 PR_Lock(conn->lock);
@@ -836,8 +833,8 @@ perform_operation(Repl_Connection *conn, int optype, const char *dn,
 		return_value = conn_is_available(conn);
 		if (return_value != CONN_OPERATION_SUCCESS) {
 			PR_Unlock(conn->lock);
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-							"%s: perform_operation connection is not available (%d)\n",
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+							"perform_operation - %s - Connection is not available (%d)\n",
 							agmt_get_long_name(conn->agmt),
 							return_value);
 			return return_value;
@@ -886,8 +883,8 @@ perform_operation(Repl_Connection *conn, int optype, const char *dn,
 		}
 		else
 		{
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-					"%s: Failed to send %s operation: LDAP error %d (%s)\n",
+            slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+					"perform_operation - %s: Failed to send %s operation: LDAP error %d (%s)\n",
 					agmt_get_long_name(conn->agmt),
 					op_string ? op_string : "NULL", rc, ldap_err2string(rc));
 			conn->last_ldap_error = rc;
@@ -1073,8 +1070,8 @@ conn_cancel_linger(Repl_Connection *conn)
 	PR_Lock(conn->lock);
 	if (conn->linger_active)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-			"%s: Cancelling linger on the connection\n",
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+			"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)
@@ -1086,8 +1083,8 @@ conn_cancel_linger(Repl_Connection *conn)
 	}
 	else
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-			"%s: No linger to cancel on the connection\n",
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+			"conn_cancel_linger - %s - No linger to cancel on the connection\n",
 			agmt_get_long_name(conn->agmt));
 	}
 	PR_Unlock(conn->lock);
@@ -1106,8 +1103,8 @@ linger_timeout(time_t event_time, void *arg)
 	Repl_Connection *conn = (Repl_Connection *)arg;
 
 	PR_ASSERT(NULL != conn);
-	slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-		"%s: Linger timeout has expired on the connection\n",
+	slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+		"linger_timeout - %s - Linger timeout has expired on the connection\n",
 		agmt_get_long_name(conn->agmt));
 	PR_Lock(conn->lock);
 	if (conn->linger_active)
@@ -1134,13 +1131,13 @@ conn_start_linger(Repl_Connection *conn)
 	time_t now;
 
 	PR_ASSERT(NULL != conn);
-	slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-		"%s: Beginning linger on the connection\n",
+	slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+		"conn_start_linger -%s - Beginning linger on the connection\n",
 		agmt_get_long_name(conn->agmt));
 	if (!conn_connected(conn))
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-			"%s: No linger on the closed conn\n",
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+			"conn_start_linger - %s - No linger on the closed conn\n",
 			agmt_get_long_name(conn->agmt));
 		return;
 	}
@@ -1148,8 +1145,8 @@ conn_start_linger(Repl_Connection *conn)
 	PR_Lock(conn->lock);
 	if (conn->linger_active)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-			"%s: Linger already active on the connection\n",
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+			"conn_start_linger - %s - Linger already active on the connection\n",
 			agmt_get_long_name(conn->agmt));
 	}
 	else
@@ -1215,8 +1212,8 @@ conn_connect(Repl_Connection *conn)
 		/* Pb occured in decryption: stop now, binding will fail */
 		if ( pw_ret == -1 )
 		{
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: Decoding of the credentials failed.\n",
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"conn_connect - %s - Decoding of the credentials failed.\n",
 				agmt_get_long_name(conn->agmt));
 		
 			return_value = CONN_OPERATION_FAILED;
@@ -1241,8 +1238,8 @@ conn_connect(Repl_Connection *conn)
 
 	if (secure > 0) {
 		if (!NSS_IsInitialized()) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-							"%s: SSL Not Initialized, Replication over SSL FAILED\n",
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+							"conn_connect - %s - SSL Not Initialized, Replication over SSL FAILED\n",
 							agmt_get_long_name(conn->agmt));
 			conn->last_ldap_error = LDAP_INAPPROPRIATE_AUTH;
 			conn->last_operation = CONN_INIT;
@@ -1257,8 +1254,8 @@ conn_connect(Repl_Connection *conn)
 #endif
 		/* Now we initialize the LDAP Structure and set options */
 		
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-			"%s: Trying %s%s slapi_ldap_init_ext\n",
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+			"conn_connect - %s - Trying %s%s slapi_ldap_init_ext\n",
 			agmt_get_long_name(conn->agmt),
 			secure ? "secure" : "non-secure",
 			(secure == SLAPI_LDAP_INIT_FLAG_startTLS) ? " startTLS" : "");
@@ -1275,8 +1272,8 @@ conn_connect(Repl_Connection *conn)
 			conn->state = STATE_DISCONNECTED;
 			conn->last_operation = CONN_INIT;
 			conn->last_ldap_error = LDAP_LOCAL_ERROR;
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: Failed to establish %s%sconnection to the consumer\n",
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"conn_connect - %s - Failed to establish %s%sconnection to the consumer\n",
 				agmt_get_long_name(conn->agmt),
 				secure ? "secure " : "",
 				(secure == SLAPI_LDAP_INIT_FLAG_startTLS) ? "startTLS " : "");
@@ -1286,8 +1283,8 @@ conn_connect(Repl_Connection *conn)
 		/* slapi_ch_strdup is OK with NULL strings */
 		binddn = slapi_ch_strdup(conn->binddn);
 
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-			"%s: binddn = %s,  passwd = %s\n",
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+			"conn_connect - %s - binddn = %s,  passwd = %s\n",
 			agmt_get_long_name(conn->agmt),
 			binddn?binddn:"NULL", creds->bv_val?creds->bv_val:"NULL");
 		
@@ -1364,8 +1361,8 @@ close_connection_internal(Repl_Connection *conn)
 		slapi_ldap_unbind(conn->ld);
 	}
 	conn->ld = NULL;
-	slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-		"%s: Disconnected from the consumer\n", agmt_get_long_name(conn->agmt));
+	slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+		"close_connection_internal - %s - Disconnected from the consumer\n", agmt_get_long_name(conn->agmt));
 }
 
 void
@@ -1698,12 +1695,12 @@ supplier_read_consumer_definitions(Repl_Connection *conn, struct berval ***remot
                 if (return_value == CONN_OPERATION_SUCCESS) {
                         *remote_attributetypes = remote_schema_attributetypes_bervals;
                 } else {
-                        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+                        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
                                 "%s: Fail to retrieve the remote schema attributetypes\n",
                                 agmt_get_long_name(conn->agmt));
                 }
         } else {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+                slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
                         "%s: Fail to retrieve the remote schema objectclasses\n",
                         agmt_get_long_name(conn->agmt));
         }
@@ -1738,8 +1735,8 @@ update_consumer_schema(Repl_Connection *conn)
 
                         /* The consumer contains definitions that needs to be learned */
                         supplier_learn_new_definitions(remote_schema_objectclasses_bervals, remote_schema_attributetypes_bervals);
-                        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-                                "[S] Schema %s must not be overwritten (set replication log for additional info)\n",
+                        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+                                "update_consumer_schema - [S] Schema %s must not be overwritten (set replication log for additional info)\n",
                                 agmt_get_long_name(conn->agmt));
                         ok_to_send_schema = PR_FALSE;
                 }
@@ -1781,13 +1778,13 @@ conn_push_schema(Repl_Connection *conn, CSN **remotecsn)
 	if (!remotecsn)
 	{
 		return_value = CONN_OPERATION_FAILED;
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "NULL remote CSN\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "conn_push_schema - NULL remote CSN\n");
 	}
 	else if (!conn_connected_locked(conn, 0 /* not locked */))
 	{
 		return_value = CONN_NOT_CONNECTED;
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-			"%s: Schema replication update failed: not connected to consumer\n",
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+			"conn_push_schema - %s: Schema replication update failed: not connected to consumer\n",
 			agmt_get_long_name(conn->agmt));
 	}
 	else
@@ -1805,60 +1802,59 @@ conn_push_schema(Repl_Connection *conn, CSN **remotecsn)
 		}
 		else
 		{			
-                        if (*remotecsn) {
-                            csn_as_string (*remotecsn, PR_FALSE, remotecnsstr);
-                            csn_as_string (localcsn, PR_FALSE, localcsnstr);
-                            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-                                                        "[S] Checking consumer schema localcsn:%s / remotecsn:%s\n", localcsnstr, remotecnsstr);
-                        } else {
-                            csn_as_string (localcsn, PR_FALSE, localcsnstr);
-                            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-                                                        "[S] Checking consumer schema localcsn:%s / remotecsn:NULL\n", localcsnstr);
-                        }
-                        if (!update_consumer_schema(conn)) {
-                                /* At least one schema definition (attributetypes/objectclasses) of the consumer
-                                 * is a superset of the supplier.
-                                 * It is not possible push the schema immediately.
-                                 * Note: in update_consumer_schema, it may update the local supplier schema.
-                                 * So it could be possible that a second attempt (right now) of update_consumer_schema
-                                 * would be successful
-                                 */
-                                slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, "schema",
-                                                        "[S] schema definitions may have been learned\n");
-                                if (!update_consumer_schema(conn)) {
-                                        slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, "schema",
-                                                        "[S] learned definitions are not suffisant to try to push the schema \n");
-                                        return_value = CONN_OPERATION_FAILED;
-                                }
-                        } 
-                        if (return_value == CONN_OPERATION_SUCCESS) {
-                                struct berval **remote_schema_csn_bervals = NULL;
-
-                                /* Get remote server's schema */
-                                return_value = conn_read_entry_attribute(conn, "cn=schema", nsschemacsn,
-                                        &remote_schema_csn_bervals);
-                                if (CONN_OPERATION_SUCCESS == return_value) {
-                                        if (NULL != remote_schema_csn_bervals && NULL != remote_schema_csn_bervals[0]) {
-                                                char remotecsnstr[CSN_STRSIZE + 1] = {0};
-                                                memcpy(remotecsnstr, remote_schema_csn_bervals[0]->bv_val,
-                                                        remote_schema_csn_bervals[0]->bv_len);
-                                                remotecsnstr[remote_schema_csn_bervals[0]->bv_len] = '\0';
-                                                slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-                                                        "[S] Reread remotecsn:%s\n", remotecsnstr);
-                                                *remotecsn = csn_new_by_string(remotecsnstr);
-                                                if (*remotecsn && (csn_compare(localcsn, *remotecsn) <= 0)) {
-                                                        return_value = CONN_SCHEMA_NO_UPDATE_NEEDED;
-                                                }
-                                                /* Need to free the remote_schema_csn_bervals */
-                                                ber_bvecfree(remote_schema_csn_bervals);
-                                        }
-                                        if (return_value == CONN_OPERATION_SUCCESS) {
-                                                slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-                                                        "Schema checking successful: ok to push the schema (%s)\n", agmt_get_long_name(conn->agmt));
-                                        }
-
-                                }
-                        }
+			if (*remotecsn) {
+				csn_as_string (*remotecsn, PR_FALSE, remotecnsstr);
+				csn_as_string (localcsn, PR_FALSE, localcsnstr);
+				slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+					"conn_push_schema - [S] Checking consumer schema localcsn:%s / remotecsn:%s\n", localcsnstr, remotecnsstr);
+			} else {
+				csn_as_string (localcsn, PR_FALSE, localcsnstr);
+				slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+					"conn_push_schema - [S] Checking consumer schema localcsn:%s / remotecsn:NULL\n", localcsnstr);
+			}
+			if (!update_consumer_schema(conn)) {
+				/* At least one schema definition (attributetypes/objectclasses) of the consumer
+				 * is a superset of the supplier.
+				 * It is not possible push the schema immediately.
+				 * Note: in update_consumer_schema, it may update the local supplier schema.
+				 * So it could be possible that a second attempt (right now) of update_consumer_schema
+				 * would be successful
+				 */
+				slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+					"conn_push_schema - [S] schema definitions may have been learned\n");
+				if (!update_consumer_schema(conn)) {
+					slapi_log_error(SLAPI_LOG_REPL, "schema",
+						"conn_push_schema - [S] learned definitions are not suffisant to try to push the schema \n");
+					return_value = CONN_OPERATION_FAILED;
+				}
+			} 
+			if (return_value == CONN_OPERATION_SUCCESS) {
+				struct berval **remote_schema_csn_bervals = NULL;
+
+				/* Get remote server's schema */
+				return_value = conn_read_entry_attribute(conn, "cn=schema", nsschemacsn,
+					&remote_schema_csn_bervals);
+				if (CONN_OPERATION_SUCCESS == return_value) {
+					if (NULL != remote_schema_csn_bervals && NULL != remote_schema_csn_bervals[0]) {
+							char remotecsnstr[CSN_STRSIZE + 1] = {0};
+							memcpy(remotecsnstr, remote_schema_csn_bervals[0]->bv_val,
+								remote_schema_csn_bervals[0]->bv_len);
+							remotecsnstr[remote_schema_csn_bervals[0]->bv_len] = '\0';
+							slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+									"conn_push_schema - [S] Reread remotecsn:%s\n", remotecsnstr);
+							*remotecsn = csn_new_by_string(remotecsnstr);
+							if (*remotecsn && (csn_compare(localcsn, *remotecsn) <= 0)) {
+								return_value = CONN_SCHEMA_NO_UPDATE_NEEDED;
+							}
+							/* Need to free the remote_schema_csn_bervals */
+							ber_bvecfree(remote_schema_csn_bervals);
+					}
+					if (return_value == CONN_OPERATION_SUCCESS) {
+						slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+							"conn_push_schema - Schema checking successful: ok to push the schema (%s)\n", agmt_get_long_name(conn->agmt));
+					}
+				}
+			}
 		}
 	}
 	if (CONN_OPERATION_SUCCESS == return_value)
@@ -1898,8 +1894,8 @@ conn_push_schema(Repl_Connection *conn, CSN **remotecsn)
 		if (NULL == entries || NULL == entries[0])
 		{
 			/* Whoops - couldn't read our own schema! */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: Error: unable to read local schema definitions.\n",
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"conn_push_schema - %s - Error: unable to read local schema definitions.\n",
 				agmt_get_long_name(conn->agmt));
 			return_value = CONN_OPERATION_FAILED;
 		}
@@ -1942,7 +1938,7 @@ conn_push_schema(Repl_Connection *conn, CSN **remotecsn)
 						{
 						int ldaperr = -1, optype = -1;
 						conn_get_error(conn, &optype, &ldaperr);
-						slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+						slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
 							"%s: Schema replication update failed: %s\n",
 							agmt_get_long_name(conn->agmt),
 							ldaperr == -1 ? "Unknown Error" : ldap_err2string(ldaperr));
@@ -1962,8 +1958,8 @@ conn_push_schema(Repl_Connection *conn, CSN **remotecsn)
 			}
 			else
 			{
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-					"%s: Schema replication update failed: "
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+					"conn_push_schema - %s - Schema replication update failed: "
 					"unable to prepare schema entry for transmission.\n",
 					agmt_get_long_name(conn->agmt));
 			}
@@ -2072,7 +2068,7 @@ bind_and_check_pwp(Repl_Connection *conn, char * binddn, char *password)
 	{
 		if (conn->last_ldap_error != rc)
 		{
-			int log_level = SLAPI_LOG_FATAL;
+			int log_level = SLAPI_LOG_INFO;
 			if (conn->last_ldap_error == LDAP_LOCAL_ERROR){
 				/*
 				 * Local errors are not logged by default, so when we recover
@@ -2081,9 +2077,9 @@ bind_and_check_pwp(Repl_Connection *conn, char * binddn, char *password)
 				log_level = SLAPI_LOG_REPL;
 			}
 			conn->last_ldap_error = rc;
-			slapi_log_error(log_level, log_level==SLAPI_LOG_REPL?LOG_DEBUG:LOG_ERR,
+			slapi_log_error(log_level,
 				repl_plugin_name, 
-				"%s: Replication bind with %s auth resumed\n",
+				"bind_and_check_pwp - %s: Replication bind with %s auth resumed\n",
 				agmt_get_long_name(conn->agmt),
 				mech ? mech : "SIMPLE");
 		}
@@ -2096,8 +2092,8 @@ bind_and_check_pwp(Repl_Connection *conn, char * binddn, char *password)
 				if ( !(strcmp( ctrls[ i ]->ldctl_oid, LDAP_CONTROL_PWEXPIRED)) )
 				{
 					/* Bind is successfull but password has expired */
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
-						"%s: Successfully bound %s to consumer, "
+					slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
+						"bind_and_check_pwp - %s - Successfully bound %s to consumer, "
 						"but password has expired on consumer.\n",
 						agmt_get_long_name(conn->agmt), binddn);
 				}					
@@ -2108,8 +2104,8 @@ bind_and_check_pwp(Repl_Connection *conn, char * binddn, char *password)
 						 (ctrls[ i ]->ldctl_value.bv_len > 0) )
 					{
 						int password_expiring = atoi( ctrls[ i ]->ldctl_value.bv_val );
-						slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
-							"%s: Successfully bound %s to consumer, "
+						slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
+							"bind_and_check_pwp - %s - Successfully bound %s to consumer, "
 							"but password is expiring on consumer in %d seconds.\n",
 							agmt_get_long_name(conn->agmt), binddn, password_expiring);
 					}
@@ -2131,10 +2127,9 @@ bind_and_check_pwp(Repl_Connection *conn, char * binddn, char *password)
 			conn->last_ldap_error = rc;
 			/* errmsg is a pointer directly into the ld structure - do not free */
 			rc = slapi_ldap_get_lderrno( ld, NULL, &errmsg );
-			slapi_log_error(rc == LDAP_LOCAL_ERROR ? SLAPI_LOG_REPL : SLAPI_LOG_FATAL,
-				rc == LDAP_LOCAL_ERROR ? LOG_DEBUG : LOG_ERR,
+			slapi_log_error(rc == LDAP_LOCAL_ERROR ? SLAPI_LOG_REPL : SLAPI_LOG_ERR,
 				repl_plugin_name,
-				"%s: Replication bind with %s auth failed: LDAP error %d (%s) (%s)\n",
+				"bind_and_check_pwp - %s - Replication bind with %s auth failed: LDAP error %d (%s) (%s)\n",
 				agmt_get_long_name(conn->agmt),
 				mech ? mech : "SIMPLE", rc,
 				ldap_err2string(rc), errmsg ? errmsg : "");
@@ -2142,8 +2137,8 @@ bind_and_check_pwp(Repl_Connection *conn, char * binddn, char *password)
 			char *errmsg = NULL;
 			/* errmsg is a pointer directly into the ld structure - do not free */
 			rc = slapi_ldap_get_lderrno( ld, NULL, &errmsg );
-			slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-				"%s: Replication bind with %s auth failed: LDAP error %d (%s) (%s)\n",
+			slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+				"bind_and_check_pwp - %s - Replication bind with %s auth failed: LDAP error %d (%s) (%s)\n",
 				agmt_get_long_name(conn->agmt),
 				mech ? mech : "SIMPLE", rc,
 				ldap_err2string(rc), errmsg ? errmsg : "");
@@ -2224,7 +2219,7 @@ repl5_debug_timeout_callback(time_t when, void *arg)
 	sprintf(buf, "%d", s_debug_level);
 	config_set_errorlog_level("nsslapd-errorlog-level", buf, NULL, 1);
 
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, 
+	slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, 
 		"repl5_debug_timeout_callback: set debug level to %d at %ld\n",
 		s_debug_level, when);
 }

ldap/servers/plugins/replication/repl5_inc_protocol.c

@@ -230,8 +230,8 @@ repl5_inc_log_operation_failure(int operation_code, int ldap_error, char* ldap_e
 {
 	char *op_string = slapi_op_type_to_string(operation_code);
 
-    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-		"%s: Received error %d: %s for %s operation\n",
+    slapi_log_error(SLAPI_LOG_DEBUG, repl_plugin_name,
+		"repl5_inc_log_operation_failure - %s: Received error %d: %s for %s operation\n",
 		agreement_name,
 		ldap_error, ldap_error_string ? ldap_error_string : "NULL",
 		op_string ? op_string : "NULL");
@@ -249,7 +249,7 @@ repl5_inc_result_threadmain(void *param)
 	int message_id = 0;
 	int yield_session = 0;
 
-	slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, NULL, "repl5_inc_result_threadmain starting\n");
+	slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "repl5_inc_result_threadmain - Starting\n");
 	while (!finished) 
 	{
 		LDAPControl **returned_controls = NULL;
@@ -274,7 +274,8 @@ repl5_inc_result_threadmain(void *param)
 		while (!finished)
 		{
 			conres = conn_read_result_ex(conn, NULL, NULL, &returned_controls, LDAP_RES_ANY, &message_id, 0);
-			slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, NULL, "repl5_inc_result_threadmain: read result for message_id %d\n", message_id);
+			slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "repl5_inc_result_threadmain - "
+				"Read result for message_id %d\n", message_id);
 			/* Timeout here means that we didn't block, not a real timeout */
 			if (CONN_TIMEOUT == conres)
 			{
@@ -337,17 +338,17 @@ repl5_inc_result_threadmain(void *param)
 			}
 
 			conn_get_error_ex(conn, &operation_code, &connection_error, &ldap_error_string);
-			slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, NULL,
-			                "repl5_inc_result_threadmain: result %d, %d, %d, %d, %s\n",
-			                operation_code,connection_error,conres,message_id,ldap_error_string);
+			slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+				"repl5_inc_result_threadmain - Result %d, %d, %d, %d, %s\n",
+				operation_code,connection_error,conres,message_id,ldap_error_string);
 			return_value = repl5_inc_update_from_op_result(rd->prp, conres, connection_error,
 			                                               csn_str, uniqueid, replica_id, &should_finish,
 			                                               &(rd->num_changes_sent));
 			if (return_value || should_finish)
 			{
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, NULL,
-				                "repl5_inc_result_threadmain: got op result %d should finish %d\n",
-				                return_value, should_finish);
+				slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+					"repl5_inc_result_threadmain - Got op result %d should finish %d\n",
+					return_value, should_finish);
 				/* If so then we need to take steps to abort the update process */
 				PR_Lock(rd->lock);
 				rd->result = return_value;
@@ -374,7 +375,7 @@ repl5_inc_result_threadmain(void *param)
 		if (!finished && yield_session && rd->abort != SESSION_ABORTED && rd->abort_time == 0) {
 			rd->abort_time = time( NULL );
 			rd->abort = SESSION_ABORTED;  /* only set the abort time once */
-			slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, "repl5_inc_result_threadmain",
+			slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "repl5_inc_result_threadmain - "
 			                "Abort control detected, setting abort time...(%s)\n",
 			                agmt_get_long_name(rd->prp->agmt));
 		}
@@ -388,7 +389,7 @@ repl5_inc_result_threadmain(void *param)
 			repl5_inc_op_free(op);
 		}
 	}
-	slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, NULL, "repl5_inc_result_threadmain exiting\n");
+	slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "repl5_inc_result_threadmain exiting\n");
 }
 
 static result_data *
@@ -442,8 +443,8 @@ repl5_inc_create_async_result_thread(result_data *rd)
 				SLAPD_DEFAULT_THREAD_STACKSIZE);
 	if (NULL == tid) 
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, NULL,
-					"repl5_tot_create_async_result_thread failed. "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+					"repl5_inc_create_async_result_thread - Failed. "
 					SLAPI_COMPONENT_NAME_NSPR " error %d (%s)\n",
 					PR_GetError(), slapd_pr_strerror( PR_GetError() ));
 		retval = -1;
@@ -499,8 +500,8 @@ repl5_inc_waitfor_async_results(result_data *rd)
 		/* Lock the structure to force memory barrier */
 		PR_Lock(rd->lock);
 		/* Are we caught up ? */
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, NULL,
-					"repl5_inc_waitfor_async_results: %d %d\n",
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+					"repl5_inc_waitfor_async_results - %d %d\n",
 					rd->last_message_id_received, rd->last_message_id_sent);
 		if (rd->last_message_id_received >= rd->last_message_id_sent) {
 			/* If so then we're done */
@@ -524,9 +525,9 @@ repl5_inc_waitfor_async_results(result_data *rd)
 		if (!done && (loops > 300))
 		{
 			/* Log a warning */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, NULL,
-					"repl5_inc_waitfor_async_results timed out waiting for responses: %d %d\n",
-					rd->last_message_id_received, rd->last_message_id_sent);
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"repl5_inc_waitfor_async_results  - Timed out waiting for responses: %d %d\n",
+				rd->last_message_id_received, rd->last_message_id_sent);
 			done = 1;
 		}
 	}
@@ -746,17 +747,17 @@ repl5_inc_run(Private_Repl_Protocol *prp)
               } 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 */
-                  slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-                      "%s: Incremental protocol: "
-                      "event %s should not occur in state %s; going to sleep\n",
+                  slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+                      "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);
               } else {
                   /* wait until window opens or an event occurs */
-            	  slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-                      "%s: Incremental protocol: "
-                      "waiting for update window to open\n", agmt_get_long_name(prp->agmt));
+            	  slapi_log_error(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);
               }
               break;
@@ -791,8 +792,8 @@ repl5_inc_run(Private_Repl_Protocol *prp)
               wait_change_timer_set = 0;
           } else if ((e1 = event_occurred(prp, EVENT_WINDOW_OPENED)) || event_occurred(prp, EVENT_BACKOFF_EXPIRED)){
               /* this events - should not occur - log a warning and clear the event */
-              slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "%s: Incremental protocol: "
-                  "event %s should not occur in state %s\n",agmt_get_long_name(prp->agmt),
+              slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "repl5_inc_run - %s: "
+                  "Event %s should not occur in state %s\n",agmt_get_long_name(prp->agmt),
                   e1 ? event2name(EVENT_WINDOW_OPENED) : event2name(EVENT_BACKOFF_EXPIRED),
                   state2name(current_state));
               wait_change_timer_set = 0;
@@ -859,8 +860,8 @@ repl5_inc_run(Private_Repl_Protocol *prp)
                       event_occurred (prp, EVENT_BACKOFF_EXPIRED)){
               /* This should never happen */
               /* this events - should not occur - log a warning and go to sleep */
-              slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-                  "%s: Incremental protocol: event %s should not occur in state %s\n",
+              slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+                  "repl5_inc_run - %s: Event %s should not occur in state %s\n",
                   agmt_get_long_name(prp->agmt),
                   e1 ? event2name(EVENT_WINDOW_OPENED) : event2name(EVENT_BACKOFF_EXPIRED),
                   state2name(current_state));
@@ -934,8 +935,8 @@ repl5_inc_run(Private_Repl_Protocol *prp)
                   time(&now);
                   next_fire_time = backoff_step(prp_priv->backoff);
                   /* And go back to sleep */
-                  slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-                      "%s: Replication session backing off for %ld seconds\n",
+                  slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+                      "repl5_inc_run - %s: Replication session backing off for %ld seconds\n",
                       agmt_get_long_name(prp->agmt),next_fire_time - now);
                   protocol_sleep(prp, PR_INTERVAL_NO_TIMEOUT);
               } else {
@@ -959,8 +960,8 @@ repl5_inc_run(Private_Repl_Protocol *prp)
              }
          } else if (event_occurred(prp, EVENT_WINDOW_OPENED)){
              /* this should never happen - log an error and go to sleep */
-             slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "%s: Incremental protocol: "
-                 "event %s should not occur in state %s; going to sleep\n",
+             slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "repl5_inc_run - %s: "
+                 "Event %s should not occur in state %s; going to sleep\n",
                  agmt_get_long_name(prp->agmt), event2name(EVENT_WINDOW_OPENED),
                  state2name(current_state));
              protocol_sleep(prp, PR_INTERVAL_NO_TIMEOUT);
@@ -1006,7 +1007,7 @@ repl5_inc_run(Private_Repl_Protocol *prp)
               agmt_set_consumer_schema_csn ( prp->agmt, cons_schema_csn );
           }
           if (CONN_SCHEMA_UPDATED != rc && CONN_SCHEMA_NO_UPDATE_NEEDED != rc){
-              slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+              slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
                   "%s: Warning: unable to replicate schema: rc=%d\n", agmt_get_long_name(prp->agmt), rc);
               /* But keep going */
           }
@@ -1021,16 +1022,16 @@ repl5_inc_run(Private_Repl_Protocol *prp)
                   next_state = STATE_STOP_FATAL_ERROR;
                   break;
               case EXAMINE_RUV_PRISTINE_REPLICA:
-                  slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-                      "%s: Replica has no update vector. It has never been initialized.\n",
+                  slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name,
+                      "repl5_inc_run - %s: Replica has no update vector. It has never been initialized.\n",
                       agmt_get_long_name(prp->agmt));
                   agmt_set_last_update_status(prp->agmt, 0, NSDS50_REPL_RUV_ERROR,
                       "Replica is not initialized");
                   next_state = STATE_BACKOFF_START;
                   break;
               case EXAMINE_RUV_GENERATION_MISMATCH:
-                  slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-                      "%s: The remote replica has a different database generation ID than "
+                  slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name,
+                      "repl5_inc_run - %s: The remote replica has a different database generation ID than "
                       "the local database.  You may have to reinitialize the remote replica, "
                       "or the local replica.\n", agmt_get_long_name(prp->agmt));
                   agmt_set_last_update_status(prp->agmt, 0, NSDS50_REPL_RUV_ERROR,
@@ -1039,8 +1040,8 @@ repl5_inc_run(Private_Repl_Protocol *prp)
                   next_state = STATE_BACKOFF_START;
                   break;
               case EXAMINE_RUV_REPLICA_TOO_OLD:
-                  slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-                      "%s: Replica update vector is too out of date to bring "
+                  slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name,
+                      "repl5_inc_run - %s: Replica update vector is too out of date to bring "
                       "into sync using the incremental protocol. The replica "
                       "must be reinitialized.\n", agmt_get_long_name(prp->agmt));
                   agmt_set_last_update_status(prp->agmt, 0, NSDS50_REPL_RUV_ERROR,
@@ -1056,15 +1057,15 @@ repl5_inc_run(Private_Repl_Protocol *prp)
                   object_release (prp->replica_object);
                   replica = NULL;
                   if (rc == CSN_LIMIT_EXCEEDED) /* too much skew */ {
-                      slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-                          "%s: Incremental protocol: fatal error - too much time skew between replicas!\n",
+                      slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+                          "repl5_inc_run - %s: Fatal error - too much time skew between replicas!\n",
                           agmt_get_long_name(prp->agmt));
                       agmt_set_last_update_status(prp->agmt, 0, NSDS50_REPL_EXCESSIVE_CLOCK_SKEW,
                           "fatal error - too much time skew between replicas");
                       next_state = STATE_STOP_FATAL_ERROR;
                   } else if (rc != 0) /* internal error */ {
-                      slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-                          "%s: Incremental protocol: fatal internal error updating the CSN generator!\n",
+                      slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+                          "repl5_inc_run - %s: Fatal internal error updating the CSN generator!\n",
                           agmt_get_long_name(prp->agmt));
                       agmt_set_last_update_status(prp->agmt, 0, NSDS50_REPL_INTERNAL_ERROR,
                           "fatal internal error updating the CSN generator");
@@ -1152,8 +1153,8 @@ repl5_inc_run(Private_Repl_Protocol *prp)
                   loops = pausetime;
                   /* the while loop is so that we don't just sleep and sleep if an
                    * event comes in that we should handle immediately (like shutdown) */
-                  slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-                      "%s: Pausing updates for %ld seconds to allow other suppliers to update consumer\n",
+                  slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+                      "repl5_inc_run - %s: Pausing updates for %ld seconds to allow other suppliers to update consumer\n",
                       agmt_get_long_name(prp->agmt), pausetime);
                   while (loops-- && !(PROTOCOL_IS_SHUTDOWN(prp))){
                       DS_Sleep(PR_SecondsToInterval(1));
@@ -1171,8 +1172,8 @@ repl5_inc_run(Private_Repl_Protocol *prp)
            * We encountered some sort of a fatal error. Suspend.
            */
           dev_debug("repl5_inc_run(STATE_STOP_FATAL_ERROR)");
-          slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-              "%s: Incremental update failed and requires administrator action\n",
+          slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+              "repl5_inc_run - %s: Incremental update failed and requires administrator action\n",
               agmt_get_long_name(prp->agmt));
           next_state = STATE_STOP_FATAL_ERROR_PART2;
           break;
@@ -1220,7 +1221,7 @@ repl5_inc_run(Private_Repl_Protocol *prp)
           break;
       }
 
-      slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,"%s: State: %s -> %s\n",
+      slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,"repl5_inc_run - %s: State: %s -> %s\n",
 	      agmt_get_long_name(prp->agmt),state2name(current_state), state2name(next_state));
 
       current_state = next_state;
@@ -1248,8 +1249,8 @@ protocol_sleep(Private_Repl_Protocol *prp, PRIntervalTime duration)
 	    PR_WaitCondVar(prp->cvar, duration);
     else
     {
-        slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-			"%s: Incremental protocol: can't go to sleep: event bits - %x\n",
+        slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+			"protocol_sleep - %s: Can't go to sleep: event bits - %x\n",
 			agmt_get_long_name(prp->agmt), prp->eventbits);
     }
 	PR_Unlock(prp->lock);
@@ -1338,16 +1339,16 @@ replay_update(Private_Repl_Protocol *prp, slapi_operation_parameters *op, int *m
 	if (create_NSDS50ReplUpdateInfoControl(op->target_address.uniqueid,
 		parentuniqueid, op->csn, modrdn_mods, &update_control) != LDAP_SUCCESS)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-			"%s: replay_update: Unable to create NSDS50ReplUpdateInfoControl "
+		slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name,
+			"replay_update - %s: Unable to create NSDS50ReplUpdateInfoControl "
 			"for operation with csn %s. Skipping update.\n",
 			agmt_get_long_name(prp->agmt), csn_as_string(op->csn, PR_FALSE, csn_str));
 	}
 	else
 	{
 		if (slapi_is_loglevel_set(SLAPI_LOG_REPL)) {
-			slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-							"%s: replay_update: Sending %s operation (dn=\"%s\" csn=%s)\n",
+			slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+							"replay_update - %s: Sending %s operation (dn=\"%s\" csn=%s)\n",
 							agmt_get_long_name(prp->agmt),
 							op2string(op->operation_type), REPL_GET_DN(&op->target_address),
 							csn_as_string(op->csn, PR_FALSE, csn_str));
@@ -1364,8 +1365,8 @@ replay_update(Private_Repl_Protocol *prp, slapi_operation_parameters *op, int *m
 									&entryattrs);
 			if (NULL == entryattrs)
 			{
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-					"%s: replay_update: Cannot convert entry to LDAPMods.\n",
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+					"replay_update - %s: Cannot convert entry to LDAPMods.\n",
 					agmt_get_long_name(prp->agmt));
 				return_value = CONN_LOCAL_ERROR;
 			}
@@ -1378,8 +1379,8 @@ replay_update(Private_Repl_Protocol *prp, slapi_operation_parameters *op, int *m
 				}
 				if (MODS_ARE_EMPTY(entryattrs)) {
 					if (slapi_is_loglevel_set(SLAPI_LOG_REPL)) {
-						slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-										"%s: replay_update: %s operation (dn=\"%s\" csn=%s) "
+						slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+										"replay_update - %s: %s operation (dn=\"%s\" csn=%s) "
 										"not sent - empty\n",
 										agmt_get_long_name(prp->agmt),
 										op2string(op->operation_type),
@@ -1403,8 +1404,8 @@ replay_update(Private_Repl_Protocol *prp, slapi_operation_parameters *op, int *m
 			}
 			if (MODS_ARE_EMPTY(op->p.p_modify.modify_mods)) {
 				if (slapi_is_loglevel_set(SLAPI_LOG_REPL)) {
-					slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-									"%s: replay_update: %ss operation (dn=\"%s\" csn=%s) "
+					slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+									"replay_update - %s: %s operation (dn=\"%s\" csn=%s) "
 									"not sent - empty\n",
 									agmt_get_long_name(prp->agmt),
 									op2string(op->operation_type),
@@ -1430,7 +1431,7 @@ replay_update(Private_Repl_Protocol *prp, slapi_operation_parameters *op, int *m
 				update_control, message_id);
 			break;
 		default:
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "%s: replay_update: Unknown "
+			slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name, "replay_update - %s: Unknown "
 				"operation type %lu found in changelog - skipping change.\n",
 				agmt_get_long_name(prp->agmt), op->operation_type);
 		}
@@ -1441,16 +1442,16 @@ replay_update(Private_Repl_Protocol *prp, slapi_operation_parameters *op, int *m
 	if (CONN_OPERATION_SUCCESS == return_value)
 	{
 		if (slapi_is_loglevel_set(SLAPI_LOG_REPL)) {
-			slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-							"%s: replay_update: Consumer successfully sent operation with csn %s\n",
+			slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+							"replay_update - %s: Consumer successfully sent operation with csn %s\n",
 							agmt_get_long_name(prp->agmt), csn_as_string(op->csn, PR_FALSE, csn_str));
 		}
 	}
 	else
 	{
 		if (slapi_is_loglevel_set(SLAPI_LOG_REPL)) {
-			slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-							"%s: replay_update: Consumer could not replay operation with csn %s\n",
+			slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+							"replay_update - %s: Consumer could not replay operation with csn %s\n",
 							agmt_get_long_name(prp->agmt), csn_as_string(op->csn, PR_FALSE, csn_str));
 		}
 	}
@@ -1524,10 +1525,9 @@ repl5_inc_update_from_op_result(Private_Repl_Protocol *prp, ConnResult replay_cr
 			{
 				agmt_inc_last_update_changecount (prp->agmt, replica_id, 1 /*skipped*/);
 			}
-			slapi_log_error(*finished ? SLAPI_LOG_FATAL : slapi_log_urp, 
-				*finished ? LOG_ERR : LOG_DEBUG,
+			slapi_log_error(*finished ? SLAPI_LOG_WARNING : slapi_log_urp, 
 				repl_plugin_name,
-				"%s: Consumer failed to replay change (uniqueid %s, CSN %s): %s (%d). %s.\n",
+				"repl5_inc_update_from_op_result - %s: Consumer failed to replay change (uniqueid %s, CSN %s): %s (%d). %s.\n",
 				agmt_get_long_name(prp->agmt),
 				uniqueid, csn_str,
 				ldap_err2string(connection_error), connection_error,
@@ -1539,8 +1539,8 @@ repl5_inc_update_from_op_result(Private_Repl_Protocol *prp, ConnResult replay_cr
 
 			return_value = UPDATE_CONNECTION_LOST;
 			*finished = 1;
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: Consumer failed to replay change (uniqueid %s, CSN %s): "
+			slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name,
+				"repl5_inc_update_from_op_result - %s: Consumer failed to replay change (uniqueid %s, CSN %s): "
 				"%s(%d). Will retry later.\n",
 				agmt_get_long_name(prp->agmt),
 				uniqueid, csn_str,
@@ -1551,8 +1551,8 @@ repl5_inc_update_from_op_result(Private_Repl_Protocol *prp, ConnResult replay_cr
 		{
 			return_value = UPDATE_TIMEOUT;
 			*finished = 1;
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: Consumer timed out to replay change (uniqueid %s, CSN %s): "
+			slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name,
+				"repl5_inc_update_from_op_result - %s: Consumer timed out to replay change (uniqueid %s, CSN %s): "
 				"%s.\n",
 				agmt_get_long_name(prp->agmt),
 				uniqueid, csn_str,
@@ -1566,8 +1566,8 @@ repl5_inc_update_from_op_result(Private_Repl_Protocol *prp, ConnResult replay_cr
 			 */
 			return_value = UPDATE_TRANSIENT_ERROR;
 			*finished = 1;
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: Failed to replay change (uniqueid %s, CSN %s): "
+			slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name,
+				"repl5_inc_update_from_op_result - %s: Failed to replay change (uniqueid %s, CSN %s): "
 				"Local error. Will retry later.\n",
 				agmt_get_long_name(prp->agmt),
 				uniqueid, csn_str);
@@ -1624,86 +1624,86 @@ send_updates(Private_Repl_Protocol *prp, RUV *remote_update_vector, PRUint32 *nu
 		switch (rc)
 		{
 		case CL5_BAD_DATA: /* invalid parameter passed to the function */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: Invalid parameter passed to cl5CreateReplayIterator\n",
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"send_updates - %s: Invalid parameter passed to cl5CreateReplayIterator\n",
 				agmt_get_long_name(prp->agmt));
 			agmt_set_last_update_status(prp->agmt, 0, NSDS50_REPL_CL_ERROR,
 				"Invalid parameter passed to cl5CreateReplayIterator");
 			return_value = UPDATE_FATAL_ERROR;
 			break;
 		case CL5_BAD_FORMAT:     /* db data has unexpected format */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: Unexpected format encountered in changelog database\n",
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"send_updates - %s: Unexpected format encountered in changelog database\n",
 				agmt_get_long_name(prp->agmt));
 			agmt_set_last_update_status(prp->agmt, 0, NSDS50_REPL_CL_ERROR,
 				"Unexpected format encountered in changelog database");
 			return_value = UPDATE_FATAL_ERROR;
 			break;
 		case CL5_BAD_STATE: /* changelog is in an incorrect state for attempted operation */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: Changelog database was in an incorrect state\n",
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"send_updates - %s: Changelog database was in an incorrect state\n",
 				agmt_get_long_name(prp->agmt));
 			agmt_set_last_update_status(prp->agmt, 0, NSDS50_REPL_CL_ERROR,
 				"Changelog database was in an incorrect state");
 			return_value = UPDATE_FATAL_ERROR;
 			break;
 		case CL5_BAD_DBVERSION:  /* changelog has invalid dbversion */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: Incorrect dbversion found in changelog database\n",
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"send_updates - %s: Incorrect dbversion found in changelog database\n",
 				agmt_get_long_name(prp->agmt));
 			agmt_set_last_update_status(prp->agmt, 0, NSDS50_REPL_CL_ERROR,
 				"Incorrect dbversion found in changelog database");
 			return_value = UPDATE_FATAL_ERROR;
 			break;
 		case CL5_DB_ERROR:       /* database error */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: A changelog database error was encountered\n",
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"send_updates - %s: A changelog database error was encountered\n",
 				agmt_get_long_name(prp->agmt));
 			agmt_set_last_update_status(prp->agmt, 0, NSDS50_REPL_CL_ERROR,
 				"Changelog database error was encountered");
 			return_value = UPDATE_FATAL_ERROR;
 			break;
 		case CL5_NOTFOUND:       /* we have no changes to send */
-			slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-				"%s: No changes to send\n",
+			slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+				"send_updates - %s: No changes to send\n",
 				agmt_get_long_name(prp->agmt));
 			return_value = UPDATE_NO_MORE_UPDATES;
 			break;
 		case CL5_MEMORY_ERROR:   /* memory allocation failed */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: Memory allocation error occurred\n",
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"send_updates - %s: Memory allocation error occurred\n",
 				agmt_get_long_name(prp->agmt));
 			agmt_set_last_update_status(prp->agmt, 0, NSDS50_REPL_CL_ERROR,
 				"changelog memory allocation error occurred");
 			return_value = UPDATE_FATAL_ERROR;
 			break;
 		case CL5_SYSTEM_ERROR:   /* NSPR error occurred: use PR_GetError for further info */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: An NSPR error (%d) occurred\n",
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"send_updates - %s: An NSPR error (%d) occurred\n",
 				agmt_get_long_name(prp->agmt), PR_GetError());
 			return_value = UPDATE_TRANSIENT_ERROR;
 			break;
 		case CL5_CSN_ERROR:      /* CSN API failed */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: A CSN API failure was encountered\n",
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"send_updates - %s: A CSN API failure was encountered\n",
 				agmt_get_long_name(prp->agmt));
 			return_value = UPDATE_TRANSIENT_ERROR;
 			break;
 		case CL5_RUV_ERROR:      /* RUV API failed */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: An RUV API failure occurred\n",
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"send_updates - %s: An RUV API failure occurred\n",
 				agmt_get_long_name(prp->agmt));
 			return_value = UPDATE_TRANSIENT_ERROR;
 			break;
 		case CL5_OBJSET_ERROR:   /* namedobjset api failed */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: A namedobject API failure occurred\n",
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"send_updates - %s: A namedobject API failure occurred\n",
 				agmt_get_long_name(prp->agmt));
 			return_value = UPDATE_TRANSIENT_ERROR;
 			break;
 		case CL5_PURGED_DATA:    /* requested data has been purged */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: Data required to update replica has been purged from the changelog. "
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"send_updates - %s: Data required to update replica has been purged from the changelog. "
 				"The replica must be reinitialized.\n",
 				agmt_get_long_name(prp->agmt));
 			agmt_set_last_update_status(prp->agmt, 0, NSDS50_REPL_CL_ERROR,
@@ -1712,22 +1712,22 @@ send_updates(Private_Repl_Protocol *prp, RUV *remote_update_vector, PRUint32 *nu
 			return_value = UPDATE_FATAL_ERROR;
 			break;
 		case CL5_MISSING_DATA:   /* data should be in the changelog, but is missing */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: Missing data encountered\n",
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"send_updates - %s: Missing data encountered\n",
 				agmt_get_long_name(prp->agmt));
 			agmt_set_last_update_status(prp->agmt, 0, NSDS50_REPL_CL_ERROR,
 				"Changelog data is missing");
 			return_value = UPDATE_FATAL_ERROR;
 			break;
 		case CL5_UNKNOWN_ERROR:   /* unclassified error */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: An unknown error was encountered\n",
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"send_updates - %s: An unknown error was encountered\n",
 				agmt_get_long_name(prp->agmt));
 			return_value = UPDATE_TRANSIENT_ERROR;
 			break;
 		default:
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: An unknown error (%d) occurred "
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"send_updates - %s: An unknown error (%d) occurred "
 				"(cl5CreateReplayIterator)\n",
 				agmt_get_long_name(prp->agmt), rc);
 			return_value = UPDATE_TRANSIENT_ERROR;
@@ -1751,7 +1751,7 @@ send_updates(Private_Repl_Protocol *prp, RUV *remote_update_vector, PRUint32 *nu
 		{
 			rc = repl5_inc_create_async_result_thread(rd);
 			if (rc) {
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "%s: repl5_inc_run: "
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "send_updates - %s: "
 							 "repl5_inc_create_async_result_thread failed; error - %d\n",
 							 agmt_get_long_name(prp->agmt), rc);
 				agmt_set_last_update_status(prp->agmt, 0, rc, "Failed to create result thread");
@@ -1772,8 +1772,8 @@ send_updates(Private_Repl_Protocol *prp, RUV *remote_update_vector, PRUint32 *nu
 				/* check that we don't return dummy entries */
 				if (is_dummy_operation (entry.op))
 				{
-					slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
-						"%s: changelog iteration code returned a dummy entry with csn %s, "
+					slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, 
+						"send_updates - %s: changelog iteration code returned a dummy entry with csn %s, "
 						"skipping ...\n",
 						agmt_get_long_name(prp->agmt), csn_as_string(entry.op->csn, PR_FALSE, csn_str));
 					continue;
@@ -1802,10 +1802,9 @@ send_updates(Private_Repl_Protocol *prp, RUV *remote_update_vector, PRUint32 *nu
 						{
 							agmt_inc_last_update_changecount (prp->agmt, csn_get_replicaid(entry.op->csn), 1 /*skipped*/);
 						}
-						slapi_log_error(finished ? SLAPI_LOG_FATAL : slapi_log_urp, 
-							finished ? LOG_ERR : LOG_DEBUG, repl_plugin_name,
-							"%s: Failed to send update operation to consumer (uniqueid %s, CSN %s): %s. %s.\n",
-							agmt_get_long_name(prp->agmt),
+						slapi_log_error(finished ? SLAPI_LOG_WARNING : slapi_log_urp, 
+							"send_updates - %s: Failed to send update operation to consumer (uniqueid %s, CSN %s): %s. %s.\n",
+							(char *)agmt_get_long_name(prp->agmt),
 							entry.op->target_address.uniqueid, csn_str,
 							ldap_err2string(error),
 							finished ? "Will retry later" : "Skipping");
@@ -1816,8 +1815,8 @@ send_updates(Private_Repl_Protocol *prp, RUV *remote_update_vector, PRUint32 *nu
 
 						return_value = UPDATE_CONNECTION_LOST;
 						finished = 1;
-						slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-							"%s: Failed to send update operation to consumer (uniqueid %s, CSN %s): "
+						slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name,
+							"send_updates - %s: Failed to send update operation to consumer (uniqueid %s, CSN %s): "
 							"%s. Will retry later.\n",
 							agmt_get_long_name(prp->agmt),
 							entry.op->target_address.uniqueid, csn_str,
@@ -1827,8 +1826,8 @@ send_updates(Private_Repl_Protocol *prp, RUV *remote_update_vector, PRUint32 *nu
 					{
 						return_value = UPDATE_TIMEOUT;
 						finished = 1;
-						slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-							"%s: Timed out sending update operation to consumer (uniqueid %s, CSN %s): "
+						slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name,
+							"send_updates - %s: Timed out sending update operation to consumer (uniqueid %s, CSN %s): "
 							"%s.\n",
 							agmt_get_long_name(prp->agmt),
 							entry.op->target_address.uniqueid, csn_str,
@@ -1842,8 +1841,8 @@ send_updates(Private_Repl_Protocol *prp, RUV *remote_update_vector, PRUint32 *nu
 						 */
 						return_value = UPDATE_TRANSIENT_ERROR;
 						finished = 1;
-						slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-							"%s: Failed to send update operation to consumer (uniqueid %s, CSN %s): "
+						slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name,
+							"send_updates - %s: Failed to send update operation to consumer (uniqueid %s, CSN %s): "
 							"Local error. Will retry later.\n",
 							agmt_get_long_name(prp->agmt),
 							entry.op->target_address.uniqueid, csn_str);
@@ -1892,8 +1891,8 @@ send_updates(Private_Repl_Protocol *prp, RUV *remote_update_vector, PRUint32 *nu
 						repl5_int_push_operation(rd,sop);
 						repl5_inc_flow_control_results(prp->agmt, rd);
 					} else {
-						slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-							"%s: Skipping update operation with no message_id (uniqueid %s, CSN %s):\n",
+						slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+							"send_updates - %s: Skipping update operation with no message_id (uniqueid %s, CSN %s):\n",
 							agmt_get_long_name(prp->agmt),
 							entry.op->target_address.uniqueid, csn_str);
 						agmt_inc_last_update_changecount (prp->agmt, csn_get_replicaid(entry.op->csn), 1 /*skipped*/);
@@ -1901,8 +1900,8 @@ send_updates(Private_Repl_Protocol *prp, RUV *remote_update_vector, PRUint32 *nu
 						{
 							skipped_updates++;
 							if (skipped_updates > FRACTIONAL_SKIPPED_THRESHOLD) {
-								slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-										"%s: skipped updates is too high (%d) if no other update is sent we will update the subentry\n",
+								slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+										"send_updates - %s: skipped updates is too high (%d) if no other update is sent we will update the subentry\n",
 										agmt_get_long_name(prp->agmt), skipped_updates);
 								subentry_update_needed = PR_TRUE;
 							}
@@ -1911,8 +1910,8 @@ send_updates(Private_Repl_Protocol *prp, RUV *remote_update_vector, PRUint32 *nu
 				}
 				break;
 			case CL5_BAD_DATA:
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-					"%s: Invalid parameter passed to cl5GetNextOperationToReplay\n",
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+					"send_updates - %s: Invalid parameter passed to cl5GetNextOperationToReplay\n",
 					agmt_get_long_name(prp->agmt));
 				agmt_set_last_update_status(prp->agmt, 0, NSDS50_REPL_CL_ERROR,
 					"Invalid parameter passed to cl5GetNextOperationToReplay");
@@ -1920,15 +1919,15 @@ send_updates(Private_Repl_Protocol *prp, RUV *remote_update_vector, PRUint32 *nu
 				finished = 1;
 				break;
 			case CL5_NOTFOUND:
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-					"%s: No more updates to send (cl5GetNextOperationToReplay)\n",
+				slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+					"send_updates - %s: No more updates to send (cl5GetNextOperationToReplay)\n",
 					agmt_get_long_name(prp->agmt));
 				return_value = UPDATE_NO_MORE_UPDATES;
 				finished = 1;
 				break;
 			case CL5_DB_ERROR:
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-					"%s: A database error occurred (cl5GetNextOperationToReplay)\n",
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+					"send_updates - %s: A database error occurred (cl5GetNextOperationToReplay)\n",
 					agmt_get_long_name(prp->agmt));
 				agmt_set_last_update_status(prp->agmt, 0, NSDS50_REPL_CL_ERROR,
 					"Database error occurred while getting the next operation to replay");
@@ -1936,13 +1935,13 @@ send_updates(Private_Repl_Protocol *prp, RUV *remote_update_vector, PRUint32 *nu
 				finished = 1;
 				break;
 			case CL5_BAD_FORMAT:
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-					"%s: A malformed changelog entry was encountered (cl5GetNextOperationToReplay)\n",
+				slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name,
+					"send_updates - %s: A malformed changelog entry was encountered (cl5GetNextOperationToReplay)\n",
 					agmt_get_long_name(prp->agmt));
 				break;
 			case CL5_MEMORY_ERROR:
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-					"%s: A memory allocation error occurred (cl5GetNextOperationToReplay)\n",
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+					"send_updates - %s: A memory allocation error occurred (cl5GetNextOperationToReplay)\n",
 					agmt_get_long_name(prp->agmt));
 				agmt_set_last_update_status(prp->agmt, 0, NSDS50_REPL_CL_ERROR,
 					"Memory allocation error occurred (cl5GetNextOperationToReplay)");
@@ -1951,8 +1950,8 @@ send_updates(Private_Repl_Protocol *prp, RUV *remote_update_vector, PRUint32 *nu
 			case CL5_IGNORE_OP:
 				break;
 			default:
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-					"%s: Unknown error code (%d) returned from cl5GetNextOperationToReplay\n",
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+					"send_updates - %s: Unknown error code (%d) returned from cl5GetNextOperationToReplay\n",
 					agmt_get_long_name(prp->agmt), rc);
 				return_value = UPDATE_TRANSIENT_ERROR;
 				break;
@@ -1977,8 +1976,8 @@ send_updates(Private_Repl_Protocol *prp, RUV *remote_update_vector, PRUint32 *nu
 					rd->result = UPDATE_YIELD;
 					return_value = UPDATE_YIELD;
 					finished = 1;
-					slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-					                "Aborting send_updates...(%s)\n",
+					slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+					                "send_updates - Aborting send_updates...(%s)\n",
 					                agmt_get_long_name(rd->prp->agmt));
 				}
 			}
@@ -2000,13 +1999,13 @@ send_updates(Private_Repl_Protocol *prp, RUV *remote_update_vector, PRUint32 *nu
 			{
 				rid = replica_get_rid(replica);
 			}
-			slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-					"%s: skipped updates was definitely too high (%d) update the subentry now\n",
+			slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+					"send_updates - %s: skipped updates was definitely too high (%d) update the subentry now\n",
 					agmt_get_long_name(prp->agmt), skipped_updates);
 			replarea_sdn = agmt_get_replarea(prp->agmt);
 			if (!replarea_sdn) {
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				                "send_updates: Unknown replication area due to agreement not found.");
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				                "send_updates - Unknown replication area due to agreement not found.");
 				agmt_set_last_update_status(prp->agmt, 0, -1, "Agreement is corrupted: missing suffix");
 				return_value = UPDATE_FATAL_ERROR;
 			} else {
@@ -2039,16 +2038,16 @@ send_updates(Private_Repl_Protocol *prp, RUV *remote_update_vector, PRUint32 *nu
 
 			rc = repl5_inc_destroy_async_result_thread(rd);
 			if (rc) {
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "%s: repl5_inc_run: "
-							 "repl5_tot_destroy_async_result_thread failed; error - %d\n", 
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "%s: repl5_inc_run: "
+							 "send_updates - repl5_inc_destroy_async_result_thread failed; error - %d\n", 
 							 agmt_get_long_name(prp->agmt), rc);
 			}
 			*num_changes_sent = rd->num_changes_sent;
 		}
 		PR_Lock(rd->lock);
 		if (rd->flowcontrol_detection) {
-			slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-					"%s: Incremental update flow control triggered %d times\n"
+			slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+					"send_updates - %s: Incremental update flow control triggered %d times\n"
 					"You may increase %s and/or decrease %s in the replica agreement configuration\n",
 					agmt_get_long_name(prp->agmt),
 					rd->flowcontrol_detection,
@@ -2102,44 +2101,44 @@ repl5_inc_stop(Private_Repl_Protocol *prp)
 	{
 		/* Isn't listening. Do something drastic. */
 		return_value = -1;
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-				"%s: repl5_inc_stop: protocol does not stop after %" NSPRIu64 " seconds\n",
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+				"repl5_inc_stop - %s: Protocol does not stop after %" NSPRIu64 " seconds\n",
 				agmt_get_long_name(prp->agmt), timeout);
 	}
 	else
 	{
 		return_value = 0;
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-				"%s: repl5_inc_stop: protocol stopped after %d seconds\n",
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+				"repl5_inc_stop - %s: Protocol stopped after %d seconds\n",
 				agmt_get_long_name(prp->agmt),
 				PR_IntervalToSeconds(now-start));
 	}
 	if (slapi_is_loglevel_set(SLAPI_LOG_REPL)) {
 		if (NULL == prp->replica_object) {
-			slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-					"%s: repl5_inc_stop: protocol replica_object is NULL\n",
+			slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+					"repl5_inc_stop - %s: Protocol replica_object is NULL\n",
 					agmt_get_long_name(prp->agmt));
 		} else {
 			Replica *replica;
 			object_acquire(prp->replica_object);
 			replica = object_get_data(prp->replica_object);
 			if (NULL == replica) {
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-						"%s: repl5_inc_stop: replica is NULL\n",
+				slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+						"repl5_inc_stop - %s:replica is NULL\n",
 						agmt_get_long_name(prp->agmt));
 			} else {
 				Object *ruv_obj = replica_get_ruv(replica);
 				if (NULL == ruv_obj) {
-					slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-							"%s: repl5_inc_stop: ruv_obj is NULL\n",
+					slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+							"repl5_inc_stop - %s: rruv_obj is NULL\n",
 							agmt_get_long_name(prp->agmt));
 				} else {
 					RUV *ruv;
 					object_acquire(ruv_obj);
 					ruv = (RUV*)object_get_data (ruv_obj);
 					if (NULL == ruv) {
-						slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-								"%s: repl5_inc_stop: ruv is NULL\n",
+						slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+								"repl5_inc_stop - %s: ruv is NULL\n",
 								agmt_get_long_name(prp->agmt));
 
 					} else {

ldap/servers/plugins/replication/repl5_init.c

@@ -224,7 +224,7 @@ multimaster_preop_init( Slapi_PBlock *pb )
 	    slapi_pblock_set( pb, SLAPI_PLUGIN_PRE_COMPARE_FN, (void *) multimaster_preop_compare ) != 0 ||
             slapi_pblock_set( pb, SLAPI_PLUGIN_PRE_ENTRY_FN, (void *) multimaster_ruv_search ) != 0)
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "multimaster_preop_init failed\n" );
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "multimaster_preop_init - Failed\n" );
 		rc= -1;
 	}
 	return rc;
@@ -245,7 +245,7 @@ multimaster_postop_init( Slapi_PBlock *pb )
 		slapi_pblock_set( pb, SLAPI_PLUGIN_POST_MODIFY_FN, (void *) multimaster_postop_modify ) != 0 ||
 	    slapi_pblock_set( pb, SLAPI_PLUGIN_POST_MODRDN_FN, (void *) multimaster_postop_modrdn ) != 0 )
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "multimaster_postop_init failed\n" );
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "multimaster_postop_init - Failed\n" );
 		rc= -1;
 	}
 
@@ -264,7 +264,7 @@ multimaster_internalpreop_init( Slapi_PBlock *pb )
 		slapi_pblock_set( pb, SLAPI_PLUGIN_INTERNAL_PRE_MODIFY_FN, (void *) multimaster_preop_modify ) != 0 ||
 	    slapi_pblock_set( pb, SLAPI_PLUGIN_INTERNAL_PRE_MODRDN_FN, (void *) multimaster_preop_modrdn ) != 0 )
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "multimaster_internalpreop_init failed\n" );
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "multimaster_internalpreop_init - Failed\n" );
 		rc= -1;
 	}
 	return rc;
@@ -282,7 +282,7 @@ multimaster_internalpostop_init( Slapi_PBlock *pb )
 		slapi_pblock_set( pb, SLAPI_PLUGIN_INTERNAL_POST_MODIFY_FN, (void *) multimaster_postop_modify ) != 0 ||
 	    slapi_pblock_set( pb, SLAPI_PLUGIN_INTERNAL_POST_MODRDN_FN, (void *) multimaster_postop_modrdn ) != 0 )
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "multimaster_internalpostop_init failed\n" );
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "multimaster_internalpostop_init - Failed\n" );
 		rc= -1;
 	}
 
@@ -307,7 +307,7 @@ multimaster_bepreop_init( Slapi_PBlock *pb )
 	    slapi_pblock_set( pb, SLAPI_PLUGIN_BE_PRE_CLOSE_FN, (void *) cl5Close ) != 0 ||
 	    slapi_pblock_set( pb, SLAPI_PLUGIN_BE_PRE_BACKUP_FN, (void *) cl5WriteRUV ) != 0 )
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "multimaster_bepreop_init failed\n" );
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "multimaster_bepreop_init - Failed\n" );
 		rc= -1;
 	}
 
@@ -342,7 +342,7 @@ multimaster_bepostop_init( Slapi_PBlock *pb )
 		slapi_pblock_set( pb, SLAPI_PLUGIN_BE_POST_OPEN_FN, (void *) changelog5_init ) != 0 ||
 		slapi_pblock_set( pb, SLAPI_PLUGIN_BE_POST_BACKUP_FN, (void *) cl5DeleteRUV ) != 0 )
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "multimaster_bepostop_init failed\n" );
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "multimaster_bepostop_init - Failed\n" );
 		rc= -1;
 	}
 
@@ -364,7 +364,7 @@ multimaster_betxn_bepostop_init( Slapi_PBlock *pb )
 		slapi_pblock_set( pb, SLAPI_PLUGIN_BE_POST_OPEN_FN, (void *) changelog5_init ) ||
 		slapi_pblock_set( pb, SLAPI_PLUGIN_BE_POST_BACKUP_FN, (void *) cl5DeleteRUV ) )
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "multimaster_betxn_bepostop_init failed\n" );
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "multimaster_betxn_bepostop_init - Failed\n" );
 		rc= -1;
 	}
 
@@ -399,8 +399,8 @@ multimaster_betxnpostop_init( Slapi_PBlock *pb )
 	    slapi_pblock_set(pb, SLAPI_PLUGIN_BE_TXN_POST_DELETE_FN, del_fn) ||
 	    slapi_pblock_set(pb, SLAPI_PLUGIN_BE_TXN_POST_MODRDN_FN, mdn_fn) ||
 	    slapi_pblock_set(pb, SLAPI_PLUGIN_BE_TXN_POST_MODIFY_FN, mod_fn)) {
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name,
-		                "multimaster_betxnpostop_init failed\n");
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name,
+		                "multimaster_betxnpostop_init - Failed\n");
 		rc = -1;
 	}
 
@@ -418,7 +418,7 @@ multimaster_start_extop_init( Slapi_PBlock *pb )
 		 slapi_pblock_set( pb, SLAPI_PLUGIN_EXT_OP_NAMELIST, (void *)start_name_list ) != 0  ||
 		 slapi_pblock_set( pb, SLAPI_PLUGIN_EXT_OP_FN, (void *)multimaster_extop_StartNSDS50ReplicationRequest ))
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "multimaster_start_extop_init (StartNSDS50ReplicationRequest) failed\n" );
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "multimaster_start_extop_init  - (StartNSDS50ReplicationRequest) failed\n" );
 		rc= -1;
 	}
 
@@ -439,7 +439,7 @@ multimaster_end_extop_init( Slapi_PBlock *pb )
 		 slapi_pblock_set( pb, SLAPI_PLUGIN_EXT_OP_NAMELIST, (void *)end_name_list ) != 0  ||
 		 slapi_pblock_set( pb, SLAPI_PLUGIN_EXT_OP_FN, (void *)multimaster_extop_EndNSDS50ReplicationRequest ))
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "multimaster_end_extop_init (EndNSDS50ReplicationRequest) failed\n" );
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "multimaster_end_extop_init - (EndNSDS50ReplicationRequest) failed\n" );
 		rc= -1;
 	}
 
@@ -462,7 +462,7 @@ multimaster_cleanruv_maxcsn_extop_init( Slapi_PBlock *pb )
 			  slapi_pblock_set( pb, SLAPI_PLUGIN_EXT_OP_NAMELIST, (void *)cleanruv_maxcsn_name_list ) != 0  ||
 			  slapi_pblock_set( pb, SLAPI_PLUGIN_EXT_OP_FN, (void *)multimaster_extop_cleanruv_get_maxcsn ))
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "multimaster_cleanruv_extop_init failed\n" );
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "multimaster_cleanruv_maxcsn_extop_init - Failed\n" );
 		rc= -1;
 	}
 
@@ -485,7 +485,7 @@ multimaster_cleanruv_status_extop_init( Slapi_PBlock *pb )
 			  slapi_pblock_set( pb, SLAPI_PLUGIN_EXT_OP_NAMELIST, (void *)cleanruv_status_name_list ) != 0  ||
 			  slapi_pblock_set( pb, SLAPI_PLUGIN_EXT_OP_FN, (void *)multimaster_extop_cleanruv_check_status ))
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "multimaster_cleanruv_extop_init failed\n" );
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "multimaster_cleanruv_status_extop_init - Failed\n" );
 		rc= -1;
 	}
 
@@ -509,7 +509,7 @@ multimaster_total_extop_init( Slapi_PBlock *pb )
 		 slapi_pblock_set( pb, SLAPI_PLUGIN_EXT_OP_NAMELIST, (void *)total_name_list ) != 0  ||
 		 slapi_pblock_set( pb, SLAPI_PLUGIN_EXT_OP_FN, (void *)multimaster_extop_NSDS50ReplicationEntry ))
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "multimaster_start_extop_init (NSDS50ReplicationEntry failed\n" );
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "multimaster_total_extop_init - (NSDS50ReplicationEntry failed\n" );
 		rc= -1;
 	}
 
@@ -532,7 +532,7 @@ multimaster_response_extop_init( Slapi_PBlock *pb )
 		 slapi_pblock_set( pb, SLAPI_PLUGIN_EXT_OP_NAMELIST, (void *)response_name_list ) != 0  ||
 		 slapi_pblock_set( pb, SLAPI_PLUGIN_EXT_OP_FN, (void *)extop_noop ))
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "multimaster_start_extop_init (NSDS50ReplicationResponse failed\n" );
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "multimaster_response_extop_init - (NSDS50ReplicationResponse failed\n" );
 		rc= -1;
 	}
 
@@ -555,7 +555,7 @@ multimaster_cleanruv_extop_init( Slapi_PBlock *pb )
 		slapi_pblock_set( pb, SLAPI_PLUGIN_EXT_OP_NAMELIST, (void *)cleanruv_name_list ) != 0  ||
 		slapi_pblock_set( pb, SLAPI_PLUGIN_EXT_OP_FN, (void *)multimaster_extop_cleanruv ))
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "multimaster_cleanruv_extop_init failed\n" );
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "multimaster_cleanruv_extop_init - Failed\n" );
 		rc= -1;
 	}
 
@@ -578,7 +578,7 @@ multimaster_cleanruv_abort_extop_init( Slapi_PBlock *pb )
 		slapi_pblock_set( pb, SLAPI_PLUGIN_EXT_OP_NAMELIST, (void *)cleanruv_abort_name_list ) != 0  ||
 		slapi_pblock_set( pb, SLAPI_PLUGIN_EXT_OP_FN, (void *)multimaster_extop_abort_cleanruv ))
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "multimaster_cleanruv_abort_extop_init failed\n" );
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "multimaster_cleanruv_abort_extop_init - Failed\n" );
 		rc= -1;
 	}
 
@@ -613,90 +613,88 @@ static int
 create_repl_schema_policy(void)
 {
 	/* DN part of this entry_string: no need to be optimized. */
-        char entry_string[1024];
+	char entry_string[1024];
 	Slapi_PBlock *pb;
 	Slapi_Entry *e ;
 	int return_value;
-        char *repl_schema_top, *repl_schema_supplier, *repl_schema_consumer;
-        char *default_supplier_policy = NULL;
-        char *default_consumer_policy = NULL;
-        int rc = 0;
-
-        slapi_schema_get_repl_entries(&repl_schema_top, &repl_schema_supplier, &repl_schema_consumer, &default_supplier_policy, &default_consumer_policy);
-        
-        /* Create cn=replSchema,cn=config */
-        PR_snprintf(entry_string, sizeof(entry_string), "dn: %s\nobjectclass: top\nobjectclass: nsSchemaPolicy\ncn: replSchema\n", repl_schema_top);
-        e = slapi_str2entry(entry_string, 0);
-        pb = slapi_pblock_new();
-        slapi_add_entry_internal_set_pb(pb, e, NULL, /* controls */
-                repl_get_plugin_identity(PLUGIN_MULTIMASTER_REPLICATION), 0 /* flags */);
-        slapi_add_internal_pb(pb);
-        slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &return_value);
-        if (return_value != LDAP_SUCCESS && return_value != LDAP_ALREADY_EXISTS) {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Warning: unable to "
-                        "create configuration entry %s: %s\n", repl_schema_top,
-                        ldap_err2string(return_value));
-                rc = -1;
-                slapi_entry_free (e); /* The entry was not consumed */
-                goto done;
-        }
-        slapi_pblock_destroy(pb);
-        
-        /* Create cn=supplierUpdatePolicy,cn=replSchema,cn=config */
-        PR_snprintf(entry_string, sizeof(entry_string), "dn: %s\nobjectclass: top\nobjectclass: nsSchemaPolicy\ncn: supplierUpdatePolicy\n%s", 
-                repl_schema_supplier, 
-                default_supplier_policy ? default_supplier_policy : "");
-        e = slapi_str2entry(entry_string, 0);
-        pb = slapi_pblock_new();
+	char *repl_schema_top, *repl_schema_supplier, *repl_schema_consumer;
+	char *default_supplier_policy = NULL;
+	char *default_consumer_policy = NULL;
+	int rc = 0;
+	
+	slapi_schema_get_repl_entries(&repl_schema_top, &repl_schema_supplier, &repl_schema_consumer, &default_supplier_policy, &default_consumer_policy);
+		
+	/* Create cn=replSchema,cn=config */
+	PR_snprintf(entry_string, sizeof(entry_string), "dn: %s\nobjectclass: top\nobjectclass: nsSchemaPolicy\ncn: replSchema\n", repl_schema_top);
+	e = slapi_str2entry(entry_string, 0);
+	pb = slapi_pblock_new();
 	slapi_add_entry_internal_set_pb(pb, e, NULL, /* controls */
 		repl_get_plugin_identity(PLUGIN_MULTIMASTER_REPLICATION), 0 /* flags */);
 	slapi_add_internal_pb(pb);
 	slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &return_value);
-        if (return_value != LDAP_SUCCESS && return_value != LDAP_ALREADY_EXISTS) {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Warning: unable to "
-                        "create configuration entry %s: %s\n", repl_schema_supplier,
-                        ldap_err2string(return_value));
-                rc = -1;
-                slapi_entry_free(e); /* The entry was not consumed */
-                goto done;
-        }
-        slapi_pblock_destroy(pb);
-        
-        /* Create cn=consumerUpdatePolicy,cn=replSchema,cn=config */
-        PR_snprintf(entry_string, sizeof(entry_string), "dn: %s\nobjectclass: top\nobjectclass: nsSchemaPolicy\ncn: consumerUpdatePolicy\n%s", 
-                repl_schema_consumer, 
-                default_consumer_policy ? default_consumer_policy : "");
-        e = slapi_str2entry(entry_string, 0);
-        pb = slapi_pblock_new();
+	if (return_value != LDAP_SUCCESS && return_value != LDAP_ALREADY_EXISTS) {
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "create_repl_schema_policy - "
+				"Unable to create configuration entry %s: %s\n", repl_schema_top,
+				ldap_err2string(return_value));
+		rc = -1;
+		slapi_entry_free (e); /* The entry was not consumed */
+		goto done;
+	}
+	slapi_pblock_destroy(pb);
+	
+	/* Create cn=supplierUpdatePolicy,cn=replSchema,cn=config */
+	PR_snprintf(entry_string, sizeof(entry_string), "dn: %s\nobjectclass: top\nobjectclass: nsSchemaPolicy\ncn: supplierUpdatePolicy\n%s", 
+			repl_schema_supplier, 
+			default_supplier_policy ? default_supplier_policy : "");
+	e = slapi_str2entry(entry_string, 0);
+	pb = slapi_pblock_new();
 	slapi_add_entry_internal_set_pb(pb, e, NULL, /* controls */
 		repl_get_plugin_identity(PLUGIN_MULTIMASTER_REPLICATION), 0 /* flags */);
 	slapi_add_internal_pb(pb);
 	slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &return_value);
-        if (return_value != LDAP_SUCCESS && return_value != LDAP_ALREADY_EXISTS) {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Warning: unable to "
-                        "create configuration entry %s: %s\n", repl_schema_consumer,
-                        ldap_err2string(return_value));
-                rc = -1;
-                slapi_entry_free(e); /* The entry was not consumed */
-                goto done;
-        }
-        slapi_pblock_destroy(pb);
-        pb = NULL;
-        
+	if (return_value != LDAP_SUCCESS && return_value != LDAP_ALREADY_EXISTS) {
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "create_repl_schema_policy - Unable to "
+				"create configuration entry %s: %s\n", repl_schema_supplier,
+				ldap_err2string(return_value));
+		rc = -1;
+		slapi_entry_free(e); /* The entry was not consumed */
+		goto done;
+	}
+	slapi_pblock_destroy(pb);
 	
-        
-        /* Load the policies of the schema replication */
-        if (slapi_schema_load_repl_policies()) {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Warning: unable to "
-                        "load the schema replication policies\n");
-                rc = -1;
-                goto done;
-        }
+	/* Create cn=consumerUpdatePolicy,cn=replSchema,cn=config */
+	PR_snprintf(entry_string, sizeof(entry_string), "dn: %s\nobjectclass: top\nobjectclass: nsSchemaPolicy\ncn: consumerUpdatePolicy\n%s", 
+		repl_schema_consumer, 
+		default_consumer_policy ? default_consumer_policy : "");
+	e = slapi_str2entry(entry_string, 0);
+	pb = slapi_pblock_new();
+	slapi_add_entry_internal_set_pb(pb, e, NULL, /* controls */
+		repl_get_plugin_identity(PLUGIN_MULTIMASTER_REPLICATION), 0 /* flags */);
+	slapi_add_internal_pb(pb);
+	slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &return_value);
+	if (return_value != LDAP_SUCCESS && return_value != LDAP_ALREADY_EXISTS) {
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "create_repl_schema_policy - "
+			"Unable to create configuration entry %s: %s\n", repl_schema_consumer,
+			ldap_err2string(return_value));
+		rc = -1;
+		slapi_entry_free(e); /* The entry was not consumed */
+		goto done;
+	}
+	slapi_pblock_destroy(pb);
+	pb = NULL;
+
+	/* Load the policies of the schema replication */
+	if (slapi_schema_load_repl_policies()) {
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "create_repl_schema_policy - "
+			"Unable to load the schema replication policies\n");
+		rc = -1;
+		goto done;
+	}
+
 done:
-        if (pb) {
-                slapi_pblock_destroy(pb);
-                pb = NULL;
-        }
+	slapi_pblock_destroy(pb);
+	pb = NULL;
+
 	return rc;
 }
 

ldap/servers/plugins/replication/repl5_mtnode_ext.c

@@ -62,7 +62,7 @@ multimaster_mtnode_construct_replicas ()
 			mtnode = slapi_get_mapping_tree_node_by_dn(root);    
 			if (mtnode == NULL)
 			{
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
+				slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, 
 								"multimaster_mtnode_construct_replicas: "
 								"failed to locate mapping tree node for %s\n",
 								slapi_sdn_get_dn (root));	        
@@ -72,7 +72,7 @@ multimaster_mtnode_construct_replicas ()
 			ext = (multimaster_mtnode_extension *)repl_con_get_ext (REPL_CON_EXT_MTNODE, mtnode);
 			if (ext == NULL)
 			{
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "multimaster_mtnode_construct_replicas: "
+				slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "multimaster_mtnode_construct_replicas: "
 								"failed to locate replication extension of mapping tree node for %s\n",
 								slapi_sdn_get_dn (root));	        
 				continue;
@@ -147,7 +147,7 @@ replica_get_replica_from_dn (const Slapi_DN *dn)
     mtnode = slapi_get_mapping_tree_node_by_dn(dn);    
     if (mtnode == NULL)
     {
-        slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "replica_get_replica_from_dn: "
+        slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "replica_get_replica_from_dn: "
                         "failed to locate mapping tree node for %s\n",
                         slapi_sdn_get_dn (dn));	        
         return NULL;
@@ -156,7 +156,7 @@ replica_get_replica_from_dn (const Slapi_DN *dn)
     ext = (multimaster_mtnode_extension *)repl_con_get_ext (REPL_CON_EXT_MTNODE, mtnode);
     if (ext == NULL)
     {
-        slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "replica_get_replica_from_dn: "
+        slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "replica_get_replica_from_dn: "
                         "failed to locate replication extension of mapping tree node for %s\n",
                         slapi_sdn_get_dn (dn));	        
         return NULL;

ldap/servers/plugins/replication/repl5_plugins.c

@@ -79,7 +79,7 @@ multimaster_set_local_purl()
     slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &rc);
     if (rc != 0)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "multimaster_set_local_purl: "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "multimaster_set_local_purl - "
 			"unable to read server configuration: error %d\n", rc);
 	}
 	else
@@ -87,8 +87,8 @@ multimaster_set_local_purl()
 		slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &entries);
 		if (NULL == entries || NULL == entries[0])
 		{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "multimaster_set_local_purl: "
-			"server configuration missing\n");
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "multimaster_set_local_purl - "
+				"Server configuration missing\n");
 			rc = -1;
 		}
 		else
@@ -98,8 +98,8 @@ multimaster_set_local_purl()
 			char *sslport = slapi_entry_attr_get_charptr(entries[0], "nsslapd-secureport");
 			if (host == NULL || ((port == NULL && sslport == NULL)))
 			{
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-					"multimaster_set_local_purl: invalid server "
+				slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name,
+					"multimaster_set_local_purl - Invalid server "
 					"configuration\n");
 			}
 			else
@@ -189,8 +189,8 @@ multimaster_preop_add (Slapi_PBlock *pb)
                 int drc = decode_NSDS50ReplUpdateInfoControl(ctrlp, &target_uuid, &superior_uuid, &csn, NULL /* modrdn_mods */);
                 if (-1 == drc)
                 {
-                    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REPLICATION_SUBSYSTEM,
-                            "%s An error occurred while decoding the replication update "
+                    slapi_log_error(SLAPI_LOG_ERR, REPLICATION_SUBSYSTEM,
+                            "multimaster_preop_add - %s An error occurred while decoding the replication update "
                             "control - Add\n", sessionid);
                 }
                 else if (1 == drc)
@@ -240,8 +240,8 @@ multimaster_preop_add (Slapi_PBlock *pb)
                         {
                             if(strcasecmp(entry_uuid,target_uuid)!=0)
                             {
-                                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REPLICATION_SUBSYSTEM,
-                                    "%s Replicated Add received with Control_UUID=%s and Entry_UUID=%s.\n",
+                                slapi_log_error(SLAPI_LOG_WARNING, REPLICATION_SUBSYSTEM,
+                                    "multimaster_preop_add - %s Replicated Add received with Control_UUID=%s and Entry_UUID=%s.\n",
                                     sessionid, target_uuid,entry_uuid);
                             }
 
@@ -318,8 +318,8 @@ multimaster_preop_delete (Slapi_PBlock *pb)
                 int drc = decode_NSDS50ReplUpdateInfoControl(ctrlp, &target_uuid, NULL, &csn, NULL /* modrdn_mods */);
                 if (-1 == drc)
                 {
-                    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REPLICATION_SUBSYSTEM,
-                            "%s An error occurred while decoding the replication update "
+                    slapi_log_error(SLAPI_LOG_ERR, REPLICATION_SUBSYSTEM,
+                            "multimaster_preop_delete - %s An error occurred while decoding the replication update "
                             "control - Delete\n", sessionid);
                 }
                 else if (1 == drc)
@@ -331,8 +331,8 @@ multimaster_preop_delete (Slapi_PBlock *pb)
                         slapi_send_ldap_result(pb, LDAP_SUCCESS, 0, 
                             "replication operation not processed, replica unavailable "
                             "or csn ignored", 0, 0); 
-                        slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, REPLICATION_SUBSYSTEM,
-                            "%s replication operation not processed, replica unavailable "
+                        slapi_log_error(SLAPI_LOG_REPL, REPLICATION_SUBSYSTEM,
+                            "multimaster_preop_delete - %s replication operation not processed, replica unavailable "
                             "or csn ignored\n", sessionid); 
                         csn_free (&csn);
                         slapi_ch_free ((void**)&target_uuid);
@@ -417,8 +417,8 @@ multimaster_preop_modify (Slapi_PBlock *pb)
                 int drc = decode_NSDS50ReplUpdateInfoControl(ctrlp, &target_uuid, NULL, &csn, NULL /* modrdn_mods */);
                 if (-1 == drc)
                 {
-                    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REPLICATION_SUBSYSTEM,
-                            "%s An error occurred while decoding the replication update "
+                    slapi_log_error(SLAPI_LOG_ERR, REPLICATION_SUBSYSTEM,
+                            "multimaster_preop_modify - %s An error occurred while decoding the replication update "
                             "control- Modify\n", sessionid);
                 }
                 else if (1 == drc)
@@ -430,8 +430,8 @@ multimaster_preop_modify (Slapi_PBlock *pb)
                         slapi_send_ldap_result(pb, LDAP_SUCCESS, 0, 
                             "replication operation not processed, replica unavailable "
                             "or csn ignored", 0, 0); 
-                        slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, REPLICATION_SUBSYSTEM,
-                            "%s replication operation not processed, replica unavailable "
+                        slapi_log_error(SLAPI_LOG_REPL, REPLICATION_SUBSYSTEM,
+                            "multimaster_preop_modify - %s replication operation not processed, replica unavailable "
                             "or csn ignored\n", sessionid); 
                         csn_free (&csn);
                         slapi_ch_free ((void**)&target_uuid);
@@ -522,8 +522,8 @@ multimaster_preop_modrdn (Slapi_PBlock *pb)
                         &csn, &modrdn_mods);
                 if (-1 == drc)
                 {
-                    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, REPLICATION_SUBSYSTEM,
-                            "%s An error occurred while decoding the replication update "
+                    slapi_log_error(SLAPI_LOG_ERR, REPLICATION_SUBSYSTEM,
+                            "multimaster_preop_modrdn - %s An error occurred while decoding the replication update "
                             "control - ModRDN\n", sessionid);
                 }
                 else if (1 == drc)
@@ -692,8 +692,8 @@ purge_entry_state_information (Slapi_PBlock *pb)
 				/* conntion is always null */
                 if (slapi_is_loglevel_set(SLAPI_LOG_REPL)) {
                     char csn_str[CSN_STRSIZE];
-                    slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-                                    "Purged state information from entry %s up to "
+                    slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+                                    "purge_entry_state_information -  From entry %s up to "
                                     "CSN %s\n", slapi_entry_get_dn(e),
                                     csn_as_string(purge_csn, PR_FALSE, csn_str));
                 }
@@ -959,14 +959,14 @@ copy_operation_parameters(Slapi_PBlock *pb)
            since client operations don't go through urp engine and pblock data can be logged */
         slapi_pblock_get( pb, SLAPI_OPERATION, &op );
         if (NULL == op) {
-            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, REPLICATION_SUBSYSTEM,
-                            "copy_operation_parameters: operation is null.\n");
+            slapi_log_error(SLAPI_LOG_REPL, REPLICATION_SUBSYSTEM,
+                            "copy_operation_parameters - operation is null.\n");
             return;
         }
         replica = (Replica*)object_get_data (repl_obj);
         if (NULL == replica) {
-            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, REPLICATION_SUBSYSTEM,
-                            "copy_operation_parameters: replica is null.\n");
+            slapi_log_error(SLAPI_LOG_REPL, REPLICATION_SUBSYSTEM,
+                            "copy_operation_parameters - replica is null.\n");
             return;
         }
         opext = (supplier_operation_extension*) repl_sup_get_ext (REPL_SUP_EXT_OP, op);
@@ -1150,8 +1150,8 @@ write_changelog_and_ruv (Slapi_PBlock *pb)
 			void *txn = NULL;
 			if (cl5_is_diskfull() && !cl5_diskspace_is_available()) 
 			{
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-								"write_changelog_and_ruv: Skipped due to DISKFULL\n");
+				slapi_log_error(SLAPI_LOG_CRIT, repl_plugin_name,
+								"write_changelog_and_ruv - Skipped due to DISKFULL\n");
 				return return_value;
 			}
 			slapi_pblock_get(pb, SLAPI_TXN, &txn);
@@ -1161,8 +1161,8 @@ write_changelog_and_ruv (Slapi_PBlock *pb)
 			{
     			char csn_str[CSN_STRSIZE];
 			    /* ONREPL - log error */
-        		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-					"write_changelog_and_ruv: can't add a change for "
+        		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+					"write_changelog_and_ruv - Can't add a change for "
 					"%s (uniqid: %s, optype: %lu) to changelog csn %s\n",
 					REPL_GET_DN(&op_params->target_address),
 					op_params->target_address.uniqueid,
@@ -1206,14 +1206,14 @@ write_changelog_and_ruv (Slapi_PBlock *pb)
 		}
 		rc = update_ruv_component(r, opcsn, pb);
 		if (RUV_COVERS_CSN == rc) {
-			slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-					"write_changelog_and_ruv: RUV already covers csn for "
+			slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+					"write_changelog_and_ruv - RUV already covers csn for "
 					"%s (uniqid: %s, optype: %lu) csn %s\n",
 					dn, uniqueid, optype,
 					csn_as_string(oppcsn, PR_FALSE, csn_str));
 		} else if ((rc != RUV_SUCCESS) && (rc != RUV_NOTFOUND)) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-					"write_changelog_and_ruv: failed to update RUV for "
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+					"write_changelog_and_ruv - Failed to update RUV for "
 					"%s (uniqid: %s, optype: %lu) to changelog csn %s - rc %d\n",
 					dn, uniqueid, optype,
 					csn_as_string(oppcsn, PR_FALSE, csn_str), rc);
@@ -1274,8 +1274,8 @@ process_postop (Slapi_PBlock *pb)
 		rc = cancel_opcsn (pb); 
 
 		/* Don't try to get session id since conn is always null */
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-			"%s process postop: canceling operation csn\n", sessionid);
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+			"process postop - %s canceling operation csn\n", sessionid);
 	} else {
 		rc = SLAPI_PLUGIN_FAILURE;
 	}
@@ -1325,8 +1325,8 @@ process_postop (Slapi_PBlock *pb)
 			slapi_pblock_get(pb, SLAPI_CONN_ID, &connid);
 			if (conn)
 			{
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-					"process_postop: Failed to apply update (%s) error (%d).  "
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+					"process_postop - Failed to apply update (%s) error (%d).  "
 					"Aborting replication session(conn=%" NSPRIu64 " op=%d)\n",
 					csn_as_string(opcsn, PR_FALSE, csn_str), retval,
 					connid, opid);
@@ -1463,8 +1463,8 @@ process_operation (Slapi_PBlock *pb, const CSN *csn)
     {
 		char sessionid[REPL_SESSION_ID_SIZE];
 		get_repl_session_id (pb, sessionid, NULL);
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "%s process_operation: "
-			"can't locate replica for the replicated operation\n",
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "process_operation - "
+			"%s - Can't locate replica for the replicated operation\n",
 			sessionid );
         return PR_FALSE;
     }
@@ -1535,8 +1535,8 @@ static const char *replica_get_purl_for_op (const Replica *r, Slapi_PBlock *pb,
 		{
 			char sessionid[REPL_SESSION_ID_SIZE];
 			get_repl_session_id (pb, sessionid, NULL);
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "%s replica_get_purl_for_op: "
-                            "cannot obtain consumer connection extension or supplier_ruv.\n",
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_get_purl_for_op - "
+                            "%s - Cannot obtain consumer connection extension or supplier_ruv.\n",
 							sessionid);
 		}
 		else
@@ -1614,16 +1614,16 @@ multimaster_be_state_change (void *handle, char *be_name, int old_be_state, int
     if (new_be_state == SLAPI_BE_STATE_ON)
     {
         /* backend came back online - restart replication */     
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "multimaster_be_state_change: "
-			"replica %s is coming online; enabling replication\n",
+        slapi_log_error(SLAPI_LOG_NOTICE, repl_plugin_name, "multimaster_be_state_change - "
+			"Replica %s is coming online; enabling replication\n",
             slapi_sdn_get_ndn (replica_get_root (r)));
         replica_enable_replication (r);
     }
     else if (new_be_state == SLAPI_BE_STATE_OFFLINE)
     {
         /* backend is about to be taken down - disable replication */
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "multimaster_be_state_change: "
-			"replica %s is going offline; disabling replication\n",
+        slapi_log_error(SLAPI_LOG_NOTICE, repl_plugin_name, "multimaster_be_state_change - "
+			"Replica %s is going offline; disabling replication\n",
             slapi_sdn_get_ndn (replica_get_root (r)));
         replica_disable_replication (r, r_obj);
     }
@@ -1632,8 +1632,8 @@ multimaster_be_state_change (void *handle, char *be_name, int old_be_state, int
         /* backend is about to be removed - disable replication */
         if (old_be_state == SLAPI_BE_STATE_ON)
         {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "multimaster_be_state_change: "
-			    "replica %s is about to be deleted; disabling replication\n",
+            slapi_log_error(SLAPI_LOG_NOTICE, repl_plugin_name, "multimaster_be_state_change - "
+			    "Replica %s is about to be deleted; disabling replication\n",
                 slapi_sdn_get_ndn (replica_get_root (r)));            
             replica_disable_replication (r, r_obj);
         }

ldap/servers/plugins/replication/repl5_protocol.c

@@ -85,8 +85,8 @@ prot_new(Repl_Agmt *agmt, int protocol_state)
 	if (NULL == rp->replica_object)
 	{
 		/* Whoa, no local replica!?!? */
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-			"%s: Unable to locate replica object for local replica %s\n",
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+			"prot_new - %s: Unable to locate replica object for local replica %s\n",
 			agmt_get_long_name(agmt),
 			slapi_sdn_get_dn(replarea_sdn));
 		goto loser;
@@ -246,7 +246,7 @@ prot_thread_main(void *arg)
 
 	agmt = rp->agmt;
 	if (!agmt) {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "missing replication agreement\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "prot_thread_main - Missing replication agreement\n");
 		return;
 	}
 
@@ -281,8 +281,9 @@ prot_thread_main(void *arg)
 		    if (replica_is_state_flag_set(replica, REPLICA_TOTAL_EXCL_RECV))
 		    {
 		        object_release(replica_obj);
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-                    "%s: total update on the replica is in progress.  Cannot initiate the total update.\n", agmt_get_long_name(rp->agmt));
+                slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+                    "prot_thread_main - %s: total update on the replica is in progress.  "
+                	"Cannot initiate the total update.\n", agmt_get_long_name(rp->agmt));
 		        break;
 		    }
 		    else
@@ -348,15 +349,15 @@ prot_start(Repl_Protocol *rp)
         {
             PRErrorCode prerr = PR_GetError();
 
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-			"%s: Unable to create protocol thread; NSPR error - %d, %s\n",
+            slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+			"prot_start - %s: Unable to create protocol thread; NSPR error - %d, %s\n",
 			agmt_get_long_name(rp->agmt),
 			prerr, slapd_pr_strerror(prerr));   
         }
 	}
 	else
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Unable to start "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "prot_start - Unable to start "
 			"protocol object - NULL protocol object passed to prot_start.\n");
 	}
 }
@@ -376,8 +377,8 @@ prot_stop(Repl_Protocol *rp)
 		{
 			if (rp->prp_incremental->stop(rp->prp_incremental) != 0)
 			{
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-					"Warning: incremental protocol for replica \"%s\" "
+				slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name,
+					"prot_stop - Incremental protocol for replica \"%s\" "
 					"did not shut down properly.\n",
 					agmt_get_long_name(rp->agmt));
 			}
@@ -386,8 +387,8 @@ prot_stop(Repl_Protocol *rp)
 		{
 			if (rp->prp_total->stop(rp->prp_total) != 0)
 			{
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-					"Warning: total protocol for replica \"%s\" "
+				slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name,
+					"prot_stop - Total protocol for replica \"%s\" "
 					"did not shut down properly.\n",
 					agmt_get_long_name(rp->agmt));
 			}
@@ -401,8 +402,8 @@ prot_stop(Repl_Protocol *rp)
 	}
 	else
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Error: prot_stop() "
-			" called on NULL protocol instance.\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "prot_stop - "
+			"NULL protocol instance.\n");
 	}
 }
 
@@ -431,10 +432,10 @@ prot_notify_update(Repl_Protocol *rp)
 void
 prot_notify_agmt_changed(Repl_Protocol *rp, char * agmt_name)
 {
-        /* MAB: rp might be NULL for disabled suffixes. Don't ASSERT on it */
-        if (NULL == rp) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-			"Replication agreement for %s could not be updated. "
+	/* MAB: rp might be NULL for disabled suffixes. Don't ASSERT on it */
+	if (NULL == rp) {
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+			"prot_notify_agmt_changed - Replication agreement for %s could not be updated. "
 			"For replication to take place, please enable the suffix "
 			"and restart the server\n", agmt_name);
 		return;
@@ -451,8 +452,8 @@ prot_notify_agmt_changed(Repl_Protocol *rp, char * agmt_name)
 void 
 prot_notify_window_opened (Repl_Protocol *rp)
 {
-        /* MAB: rp might be NULL for disabled suffixes. Don't ASSERT on it */
-        if (NULL == rp) return;
+	/* MAB: rp might be NULL for disabled suffixes. Don't ASSERT on it */
+	if (NULL == rp) return;
 
 	PR_Lock(rp->lock);
 	if (NULL != rp->prp_active_protocol)
@@ -465,8 +466,8 @@ prot_notify_window_opened (Repl_Protocol *rp)
 void 
 prot_notify_window_closed (Repl_Protocol *rp)
 {
-        /* MAB: rp might be NULL for disabled suffixes. Don't ASSERT on it */
-        if (NULL == rp) return;
+	/* MAB: rp might be NULL for disabled suffixes. Don't ASSERT on it */
+	if (NULL == rp) return;
 
 	PR_Lock(rp->lock);
 	if (NULL != rp->prp_active_protocol)
@@ -481,7 +482,7 @@ prot_status(Repl_Protocol *rp)
 {
 	int return_status = PROTOCOL_STATUS_UNKNOWN;
 
-        /* MAB: rp might be NULL for disabled suffixes. Don't ASSERT on it */
+	/* MAB: rp might be NULL for disabled suffixes. Don't ASSERT on it */
 	if (NULL != rp)
 	{
 		PR_Lock(rp->lock);
@@ -504,8 +505,7 @@ prot_status(Repl_Protocol *rp)
 void
 prot_replicate_now(Repl_Protocol *rp)
 {
-        /* MAB: rp might be NULL for disabled suffixes. Don't ASSERT on it */
-
+	/* MAB: rp might be NULL for disabled suffixes. Don't ASSERT on it */
 	if (NULL != rp)
 	{
 		PR_Lock(rp->lock);

ldap/servers/plugins/replication/repl5_protocol_util.c

@@ -98,10 +98,10 @@ acquire_replica(Private_Repl_Protocol *prp, char *prot_oid, RUV **ruv)
 
     if (prp->replica_acquired)  /* we already acquire replica */
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-						"%s: Remote replica already acquired\n",
+        slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name,
+						"acquire_replica - %s: Remote replica already acquired\n",
 						agmt_get_long_name(prp->agmt));
-								return_value = ACQUIRE_FATAL_ERROR;
+		return_value = ACQUIRE_FATAL_ERROR;
         return ACQUIRE_SUCCESS;
     }
 
@@ -266,7 +266,7 @@ acquire_replica(Private_Repl_Protocol *prp, char *prot_oid, RUV **ruv)
 
 				/* Couldn't send the extended operation */
 				return_value = ACQUIRE_TRANSIENT_ERROR; /* XXX right return value? */
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+				slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name, "acquire_replica - "
 					"%s: Unable to send a startReplication "
 					"extended operation to consumer (%s). Will retry later.\n",
 					agmt_get_long_name(prp->agmt),
@@ -298,7 +298,8 @@ acquire_replica(Private_Repl_Protocol *prp, char *prot_oid, RUV **ruv)
 					{
 					/* XXXggood handle other error codes here */
 					case NSDS50_REPL_INTERNAL_ERROR:
-							slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+							slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+								"acquire_replica - "
 								"%s: Unable to acquire replica: "
 								"an internal error occurred on the remote replica. "
 								"Replication is aborting.\n",
@@ -312,7 +313,8 @@ acquire_replica(Private_Repl_Protocol *prp, char *prot_oid, RUV **ruv)
 						/* Not allowed to send updates */
 						{
 							char *repl_binddn = agmt_get_binddn(prp->agmt);
-							slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+							slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+								"acquire_replica - "
 								"%s: Unable to acquire replica: permission denied. "
 								"The bind dn \"%s\" does not have permission to "
 								"supply replication updates to the replica. "
@@ -331,7 +333,8 @@ acquire_replica(Private_Repl_Protocol *prp, char *prot_oid, RUV **ruv)
 						/* There is no such replica on the consumer */
 						{
 							Slapi_DN *repl_root = agmt_get_replarea(prp->agmt);
-							slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+							slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+								"acquire_replica - "
 								"%s: Unable to acquire replica: there is no "
 								"replicated area \"%s\" on the consumer server. "
 								"Replication is aborting.\n",
@@ -347,7 +350,8 @@ acquire_replica(Private_Repl_Protocol *prp, char *prot_oid, RUV **ruv)
 						}
 					case NSDS50_REPL_EXCESSIVE_CLOCK_SKEW:
 						/* Large clock skew between the consumer and the supplier */
-						slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+						slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+							"acquire_replica - "
 							"%s: Unable to acquire replica: "
 							"Excessive clock skew between the supplier and "
 							"the consumer. Replication is aborting.\n",
@@ -356,7 +360,8 @@ acquire_replica(Private_Repl_Protocol *prp, char *prot_oid, RUV **ruv)
 						break;
 					case NSDS50_REPL_DECODING_ERROR:
 						/* We sent something the replica couldn't understand. */
-						slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+						slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+							"acquire_replica - "
 							"%s: Unable to acquire replica: "
 							"the consumer was unable to decode the "
 							"startReplicationRequest extended operation sent by the "
@@ -376,7 +381,8 @@ acquire_replica(Private_Repl_Protocol *prp, char *prot_oid, RUV **ruv)
 						if (strcmp(REPL_NSDS50_TOTAL_PROTOCOL_OID,
 								   prot_oid) == 0)
 						{
-							slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+							slapi_log_error(SLAPI_LOG_NOTICE, repl_plugin_name,
+								"acquire_replica - "
 								"%s: Unable to acquire replica: "
 								"the replica is currently being updated"
 								"by another supplier.\n",
@@ -384,7 +390,8 @@ acquire_replica(Private_Repl_Protocol *prp, char *prot_oid, RUV **ruv)
 						}
 						else /* REPL_NSDS50_INCREMENTAL_PROTOCOL_OID */
 						{
-							slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
+							slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+								"acquire_replica - "
 								"%s: Unable to acquire replica: "
 								"the replica is currently being updated"
 								"by another supplier. Will try later\n",
@@ -398,7 +405,8 @@ acquire_replica(Private_Repl_Protocol *prp, char *prot_oid, RUV **ruv)
 						break;
 					case NSDS50_REPL_LEGACY_CONSUMER:
 						/* remote replica is a legacy consumer */
-						slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+						slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+							"acquire_replica - "
 							"%s: Unable to acquire replica: the replica "
 							"is supplied by a legacy supplier. "
 							"Replication is aborting.\n", agmt_get_long_name(prp->agmt));
@@ -409,7 +417,8 @@ acquire_replica(Private_Repl_Protocol *prp, char *prot_oid, RUV **ruv)
 						break;
 					case NSDS50_REPL_REPLICAID_ERROR:
 						/* remote replica detected a duplicate ReplicaID */
-						slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+						slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+							"acquire_replica - "
 							"%s: Unable to aquire replica: the replica "
 							"has the same Replica ID as this one. "
 							"Replication is aborting.\n",
@@ -422,11 +431,12 @@ acquire_replica(Private_Repl_Protocol *prp, char *prot_oid, RUV **ruv)
 					case NSDS50_REPL_BACKOFF:
 						/* A replication sesssion hook on the replica
 						 * wants us to go into backoff mode. */
-						slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-                                                        "%s: Unable to acquire replica: "
-                                                        "the replica instructed us to go into "
-                                                        "backoff mode. Will retry later.\n",
-                                                        agmt_get_long_name(prp->agmt));
+						slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+							"acquire_replica - "
+							"%s: Unable to acquire replica: "
+							"the replica instructed us to go into "
+							"backoff mode. Will retry later.\n",
+							agmt_get_long_name(prp->agmt));
 						agmt_set_last_update_status(prp->agmt, 0, extop_result,
 							"Unable to acquire replica: the replica instructed "
 							"us to go into backoff mode. Will retry later.");
@@ -462,7 +472,8 @@ acquire_replica(Private_Repl_Protocol *prp, char *prot_oid, RUV **ruv)
 						}
 
 						/* We've acquired the replica. */
-						slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
+						slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+							"acquire_replica - "
 							"%s: Replica was successfully acquired.\n",
 							agmt_get_long_name(prp->agmt));
 						/* Parse the update vector */
@@ -472,9 +483,9 @@ acquire_replica(Private_Repl_Protocol *prp, char *prot_oid, RUV **ruv)
 							{
 								/* Couldn't parse the update vector */
 								*ruv = NULL;
-								slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-									"%s: Warning: acquired replica, "
-									"but could not parse update vector. "
+								slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+									"acquire_replica - "
+									"%s: acquired replica, but could not parse update vector. "
 									"The replica must be reinitialized.\n",
 									agmt_get_long_name(prp->agmt));
 							}
@@ -496,7 +507,8 @@ acquire_replica(Private_Repl_Protocol *prp, char *prot_oid, RUV **ruv)
 				else
 				{
 					/* Couldn't parse the response */
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+					slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+						"acquire_replica - "
 						"%s: Unable to parse the response to the "
 						"startReplication extended operation. "
 						"Replication is aborting.\n", 
@@ -516,7 +528,8 @@ acquire_replica(Private_Repl_Protocol *prp, char *prot_oid, RUV **ruv)
 
 				/* Couldn't send the extended operation */
 				return_value = ACQUIRE_TRANSIENT_ERROR; /* XXX right return value? */
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+				slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name,
+					"acquire_replica - "
 					"%s: Unable to receive the response for a startReplication "
 					"extended operation to consumer (%s). Will retry later.\n",
 					agmt_get_long_name(prp->agmt),
@@ -529,7 +542,8 @@ acquire_replica(Private_Repl_Protocol *prp, char *prot_oid, RUV **ruv)
 		else
 		{
 			/* Couldn't get a current CSN */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"acquire_replica - "
 				"%s: Unable to obtain current CSN. "
 				"Replication is aborting.\n",
 				agmt_get_long_name(prp->agmt));
@@ -599,8 +613,8 @@ release_replica(Private_Repl_Protocol *prp)
 	{
 		int operation, error;
 		conn_get_error(prp->conn, &operation, &error);
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-			"%s: Warning: unable to send endReplication extended operation (%s)\n",
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+			"release_replica - %s: Unable to send endReplication extended operation (%s)\n",
 			agmt_get_long_name(prp->agmt),
 			error ? ldap_err2string(error) : "unknown error");
 		goto error;
@@ -611,8 +625,8 @@ release_replica(Private_Repl_Protocol *prp)
 	{
 		int operation, error;
 		conn_get_error(prp->conn, &operation, &error);
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-			"%s: Warning: Attempting to release replica, but unable to receive endReplication extended "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+			"release_replica - %s: Attempting to release replica, but unable to receive endReplication extended "
 			"operation response from the replica. Error %d (%s)\n", agmt_get_long_name(prp->agmt), error,
 			error ? ldap_err2string(error) : "unknown error");
 	}
@@ -629,8 +643,8 @@ release_replica(Private_Repl_Protocol *prp)
 		{
 			int operation, error;
 			conn_get_error(prp->conn, &operation, &error);
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: Warning: response message id does not match the request (%s)\n",
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"release_replica - %s: Response message id does not match the request (%s)\n",
 				agmt_get_long_name(prp->agmt),
 				error ? ldap_err2string(error) : "unknown error");
 		}
@@ -649,13 +663,13 @@ release_replica(Private_Repl_Protocol *prp)
 		{
 			if (NSDS50_REPL_REPLICA_RELEASE_SUCCEEDED == extop_result)
 			{
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-					"%s: Successfully released consumer\n", agmt_get_long_name(prp->agmt));
+				slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+					"release_replica - %s: Successfully released consumer\n", agmt_get_long_name(prp->agmt));
 			}
 			else
 			{
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-					"%s: Unable to release consumer: response code %d\n",
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+					"release_replica - %s: Unable to release consumer: response code %d\n",
 					agmt_get_long_name(prp->agmt), extop_result);
                 /* disconnect from the consumer so that it does not stay locked */
                 conn_disconnect (prp->conn);
@@ -664,8 +678,8 @@ release_replica(Private_Repl_Protocol *prp)
 		else
 		{
 			/* Couldn't parse the response */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-				"%s: Warning: Unable to parse the response "
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"release_replica - %s: Unable to parse the response "
 				" to the endReplication extended operation.\n", 
 				agmt_get_long_name(prp->agmt));
 		}

ldap/servers/plugins/replication/repl5_replica_dnhash.c

@@ -30,7 +30,7 @@ int replica_init_dn_hash ()
                              PL_CompareValues, NULL, NULL);
     if (s_hash == NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_init_dn_hash: "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_init_dn_hash: "
                         "failed to allocate hash table; NSPR error - %d\n",
                         PR_GetError ());	
         return -1;
@@ -40,7 +40,7 @@ int replica_init_dn_hash ()
     s_lock = slapi_new_rwlock();
     if (s_lock == NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_init_dn_hash: "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_init_dn_hash: "
                         "failed to create lock; NSPR error - %d\n",
                         PR_GetError ());
         replica_destroy_dn_hash ();
@@ -68,13 +68,13 @@ int replica_add_by_dn (const char *dn)
 
     if (dn == NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_add_by_dn: NULL argument\n");
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_add_by_dn: NULL argument\n");
         return -1;
     }
 
     if (s_hash == NULL || s_lock == NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_add_by_dn: "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_add_by_dn: "
                         "replica hash is not initialized\n");
         return -1;
     }
@@ -84,7 +84,7 @@ int replica_add_by_dn (const char *dn)
     /* make sure that the dn is unique */
     if (PL_HashTableLookup(s_hash, dn) != NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_add_by_dn: "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_add_by_dn: "
                         "replica with dn (%s) already in the hash\n", dn);
         slapi_rwlock_unlock (s_lock);
         return -1 ;    
@@ -94,7 +94,7 @@ int replica_add_by_dn (const char *dn)
 	dn_copy = slapi_ch_strdup(dn);
     if (PL_HashTableAdd(s_hash, dn_copy, dn_copy) == NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_add_by_dn: "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_add_by_dn: "
                         "failed to add dn (%s); NSPR error - %d\n",
                         dn_copy, PR_GetError ());
 		slapi_ch_free((void **)&dn_copy);
@@ -102,7 +102,7 @@ int replica_add_by_dn (const char *dn)
         return -1;
     }
 
-	slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "replica_add_by_dn: "
+	slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "replica_add_by_dn: "
 					"added dn (%s)\n",
 					dn_copy);
     slapi_rwlock_unlock (s_lock);
@@ -115,14 +115,14 @@ int replica_delete_by_dn (const char *dn)
 
     if (dn == NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_delete_by_dn: "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_delete_by_dn: "
                         "NULL argument\n");
         return -1;
     }
 
     if (s_hash == NULL || s_lock == NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_delete_by_dn: "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_delete_by_dn: "
                         "replica hash is not initialized\n");
         return -1;
     }
@@ -132,7 +132,7 @@ int replica_delete_by_dn (const char *dn)
     /* locate object */
     if (NULL == (dn_copy = (char *)PL_HashTableLookup(s_hash, dn)))
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_delete_by_dn: "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_delete_by_dn: "
                         "dn (%s) is not in the hash.\n", dn);
         slapi_rwlock_unlock (s_lock);
         return -1;
@@ -142,7 +142,7 @@ int replica_delete_by_dn (const char *dn)
     PL_HashTableRemove(s_hash, dn);
 	slapi_ch_free((void **)&dn_copy);
 
-	slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "replica_delete_by_dn: "
+	slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "replica_delete_by_dn: "
 					"removed dn (%s)\n",
 					dn);
     slapi_rwlock_unlock (s_lock);
@@ -154,14 +154,14 @@ int replica_is_being_configured (const char *dn)
 {
     if (dn == NULL)
     {
-         slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_is_dn_in_hash: "
+         slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_is_being_configured: "
                          "NULL argument\n");
         return 0;
     }
 
     if (s_hash == NULL || s_lock == NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_is_dn_in_hash: "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_is_being_configured: "
                         "dn hash is not initialized\n");
         return 0;
     }

ldap/servers/plugins/replication/repl5_replica_hash.c

@@ -39,7 +39,7 @@ int replica_init_name_hash ()
                              PL_CompareValues, NULL, NULL);
     if (s_hash == NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_init_name_hash: "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_init_name_hash: "
                         "failed to allocate hash table; NSPR error - %d\n",
                         PR_GetError ());	
         return -1;
@@ -49,7 +49,7 @@ int replica_init_name_hash ()
     s_lock = slapi_new_rwlock();
     if (s_lock == NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_init_name_hash: "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_init_name_hash: "
                         "failed to create lock; NSPR error - %d\n",
                         PR_GetError ());
         replica_destroy_name_hash ();
@@ -75,13 +75,13 @@ int replica_add_by_name (const char *name, Object *replica)
 {
     if (name == NULL || replica == NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_add_by_name: NULL argument\n");
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_add_by_name: NULL argument\n");
         return -1;
     }
 
     if (s_hash == NULL || s_lock == NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_add_by_name: "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_add_by_name: "
                         "replica hash is not initialized\n");
         return -1;
     }
@@ -91,7 +91,7 @@ int replica_add_by_name (const char *name, Object *replica)
     /* make sure that the name is unique */
     if (PL_HashTableLookup(s_hash, name) != NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_add_by_name: "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_add_by_name: "
                         "replica with name (%s) already in the hash\n", name);
         slapi_rwlock_unlock (s_lock);
         return -1 ;    
@@ -103,7 +103,7 @@ int replica_add_by_name (const char *name, Object *replica)
     /* add replica */
     if (PL_HashTableAdd(s_hash, name, replica) == NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_add_by_name: "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_add_by_name: "
                         "failed to add replica with name (%s); NSPR error - %d\n",
                         name, PR_GetError ());
         object_release (replica);
@@ -121,14 +121,14 @@ int replica_delete_by_name (const char *name)
 
     if (name == NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_delete_by_name: "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_delete_by_name: "
                         "NULL argument\n");
         return -1;
     }
 
     if (s_hash == NULL || s_lock == NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_delete_by_name: "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_delete_by_name: "
                         "replica hash is not initialized\n");
         return -1;
     }
@@ -139,7 +139,7 @@ int replica_delete_by_name (const char *name)
     replica = (Object*)PL_HashTableLookup(s_hash, name);     
     if (replica == NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_delete_by_name: "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_delete_by_name: "
                         "replica with name (%s) is not in the hash.\n", name);
         slapi_rwlock_unlock (s_lock);
         return -1;
@@ -162,14 +162,14 @@ Object* replica_get_by_name (const char *name)
 
     if (name == NULL)
     {
-         slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_get_by_name: "
+         slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_get_by_name: "
                          "NULL argument\n");
         return NULL;
     }
 
     if (s_hash == NULL || s_lock == NULL)
     {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_get_by_name: "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_get_by_name: "
                         "replica hash is not initialized\n");
         return NULL;
     }

ldap/servers/plugins/replication/repl5_ruv.c

@@ -92,7 +92,7 @@ ruv_init_new(const char *replGen, ReplicaId rid, const char *purl, RUV **ruv)
 
 	if (ruv == NULL || replGen == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "ruv_init_new: NULL argument\n");
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "ruv_init_new: NULL argument\n");
 		return RUV_BAD_DATA;
 	}	
 
@@ -160,7 +160,7 @@ ruv_init_from_slapi_attr_and_check_purl(Slapi_Attr *attr, RUV **ruv, ReplicaId *
 
 	if (NULL == ruv || NULL == attr)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, 
 			"ruv_init_from_slapi_attr: NULL argument\n");
 		return_value = RUV_BAD_DATA;
 	}
@@ -200,7 +200,7 @@ ruv_init_from_slapi_attr_and_check_purl(Slapi_Attr *attr, RUV **ruv, ReplicaId *
 							(*ruv)->replGen = get_replgen_from_berval(bval);
 						} else {
 							/* Twice replicageneration is wrong, just log and ignore */
-							slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
+							slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, 
 											"ruv_init_from_slapi_attr: %s is present more than once\n", 
 											prefix_replicageneration);
 						}
@@ -255,7 +255,7 @@ ruv_init_from_bervals(struct berval **vals, RUV **ruv)
 
 	if (NULL == ruv || NULL == vals)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, 
 			"ruv_init_from_slapi_value: NULL argument\n");
 		return_value = RUV_BAD_DATA;
 	}
@@ -284,7 +284,7 @@ ruv_init_from_bervals(struct berval **vals, RUV **ruv)
 							(*ruv)->replGen = get_replgen_from_berval(vals[i]);
 						} else {
 							/* Twice replicageneration is wrong, just log and ignore */
-							slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
+							slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, 
 											"ruv_init_from_slapi_value: %s is present more than once\n", 
 											prefix_replicageneration);
 						}
@@ -427,7 +427,7 @@ ruv_delete_replica (RUV *ruv, ReplicaId rid)
 	int return_value;
 	if (ruv == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "ruv_delete_replica: NULL argument\n");
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "ruv_delete_replica: NULL argument\n");
 		return_value = RUV_BAD_DATA;
 	}	
 	else
@@ -552,7 +552,7 @@ get_csn_internal(const RUV *ruv, ReplicaId rid, CSN **csn, int whichone)
 
 	if (ruv == NULL || csn == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "ruv_get_largest_csn_for_replica: NULL argument\n");
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "ruv_get_largest_csn_for_replica: NULL argument\n");
 		return_value = RUV_BAD_DATA;
 	}
 	else
@@ -669,7 +669,7 @@ set_max_csn_nolock_ext(RUV *ruv, const CSN *max_csn, const char *replica_purl, P
 		} else {
 			char csn1[CSN_STRSIZE+1];
 			char csn2[CSN_STRSIZE+1];
-			slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
+			slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
 			                "set_max_csn_nolock_ext: new CSN [%s] for replica ID [%d] "
 			                "is less than the existing max CSN [%s] - ignoring\n",
 			                csn_as_string(max_csn, PR_FALSE, csn1), rid,
@@ -716,7 +716,7 @@ ruv_set_csns(RUV *ruv, const CSN *csn, const char *replica_purl)
 	
 	if (ruv == NULL || csn == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "ruv_set_csns: NULL argument\n");
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "ruv_set_csns: NULL argument\n");
 		return_value = RUV_BAD_DATA;
 	}
 	else
@@ -783,7 +783,7 @@ ruv_set_csns_keep_smallest(RUV *ruv, const CSN *csn)
 	
 	if (ruv == NULL || csn == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, 
                         "ruv_set_csns_keep_smallest: NULL argument\n");
 		return_value = RUV_BAD_DATA;
 	}
@@ -869,7 +869,7 @@ ruv_covers_csn_internal(const RUV *ruv, const CSN *csn, PRBool strict)
 
 	if (ruv == NULL || csn == NULL) 
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "ruv_covers_csn: NULL argument\n");
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "ruv_covers_csn_internal - NULL argument\n");
 		return_value = PR_FALSE;
 	}
 	else
@@ -887,10 +887,10 @@ ruv_covers_csn_internal(const RUV *ruv, const CSN *csn, PRBool strict)
 			 *  if strict is set.
 			 */
 			if(strict){
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "ruv_covers_csn: replica for id %d not found.\n", rid);
+				slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "ruv_covers_csn_internal - Replica for id %d not found.\n", rid);
 				return_value = PR_TRUE;
 			} else {
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "ruv_covers_csn: replica for id %d not found.\n", rid);
+				slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "ruv_covers_csn_internal - Replica for id %d not found.\n", rid);
 				return_value = PR_FALSE;
 			}
 		}
@@ -947,7 +947,7 @@ ruv_covers_csn_cleanallruv(const RUV *ruv, const CSN *csn)
 	PRBool return_value;
 
 	if (ruv == NULL || csn == NULL){
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "ruv_covers_csn_cleanallruv: NULL argument\n");
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "ruv_covers_csn_cleanallruv - NULL argument\n");
 		return_value = PR_FALSE;
 	} else {
 		rid = csn_get_replicaid(csn);
@@ -974,7 +974,7 @@ ruv_get_min_or_max_csn(const RUV *ruv, CSN **csn, int get_the_max, ReplicaId rid
 
 	if (ruv == NULL || csn == NULL) 
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "ruv_get_min_or_max_csn: NULL argument\n");
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "ruv_get_min_or_max_csn - NULL argument\n");
 		return_value = RUV_BAD_DATA;
 	}
 	else
@@ -1140,7 +1140,7 @@ ruv_to_bervals(const RUV *ruv, struct berval ***bvals)
 	int return_value;
 	if (ruv == NULL || bvals == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "ruv_to_bervals: NULL argument\n");
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "ruv_to_bervals - NULL argument\n");
 		return_value = RUV_BAD_DATA;
 	}
 	else
@@ -1269,7 +1269,7 @@ ruv_to_smod(const RUV *ruv, Slapi_Mod *smod)
 
 	if (ruv == NULL || smod == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "ruv_to_smod: NULL argument\n");
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "ruv_to_smod - NULL argument\n");
 		return_value = RUV_BAD_DATA;
 	}
 	else
@@ -1309,7 +1309,7 @@ ruv_last_modified_to_smod(const RUV *ruv, Slapi_Mod *smod)
 
 	if (ruv == NULL || smod == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "ruv_last_modified_to_smod: NULL argument\n");
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "ruv_last_modified_to_smod - NULL argument\n");
 		return_value = RUV_BAD_DATA;
 	}
 	else
@@ -1400,17 +1400,17 @@ ruv_compare_ruv(const RUV *ruv1, const char *ruv1name, const RUV *ruv2, const ch
 
     /* compare replica generations first */
     if (ruv1->replGen == NULL || ruv2->replGen == NULL) {
-        slapi_log_error(loglevel, loglevel==SLAPI_LOG_REPL?LOG_DEBUG:LOG_ERR,
+        slapi_log_error(loglevel,
                         repl_plugin_name,
-                        "ruv_compare_ruv: RUV [%s] is missing the replica generation\n",
+                        "ruv_compare_ruv - RUV [%s] is missing the replica generation\n",
                         ruv1->replGen ? ruv2name : ruv1name);
         return RUV_COMP_NO_GENERATION;
     }
     
     if (strcasecmp (ruv1->replGen, ruv2->replGen)) {
-        slapi_log_error(loglevel, loglevel==SLAPI_LOG_REPL?LOG_DEBUG:LOG_ERR,
+        slapi_log_error(loglevel,
                         repl_plugin_name,
-                        "ruv_compare_ruv: RUV [%s] replica generation [%s] does not match RUV [%s] [%s]\n",
+                        "ruv_compare_ruv - RUV [%s] replica generation [%s] does not match RUV [%s] [%s]\n",
                         ruv1name, ruv1->replGen, ruv2name, ruv2->replGen);
         return RUV_COMP_GENERATION_DIFFERS;
     }
@@ -1438,34 +1438,34 @@ ruv_compare_ruv(const RUV *ruv1, const char *ruv1name, const RUV *ruv2, const ch
                 csn_as_string(replicab->csn, PR_FALSE, csnstrb);
                 if (replicaa == NULL) {
                     (*missing)++;
-                    slapi_log_error(loglevel, loglevel==SLAPI_LOG_REPL?LOG_DEBUG:LOG_ERR, repl_plugin_name,
-                                    "ruv_compare_ruv: RUV [%s] does not contain element [%s] "
+                    slapi_log_error(loglevel, repl_plugin_name,
+                                    "ruv_compare_ruv - RUV [%s] does not contain element [%s] "
                                     "which is present in RUV [%s]\n",
                                     ruvaname, ruvelem, ruvbname);
                 } else if (strict && (csn_compare (replicab->csn, replicaa->csn) >= 0)) {
                     csn_as_string(replicaa->csn, PR_FALSE, csnstra);
-                    slapi_log_error(loglevel, loglevel==SLAPI_LOG_REPL?LOG_DEBUG:LOG_ERR,repl_plugin_name,
-                                    "ruv_compare_ruv: the max CSN [%s] from RUV [%s] is larger "
+                    slapi_log_error(loglevel, repl_plugin_name,
+                                    "ruv_compare_ruv - The max CSN [%s] from RUV [%s] is larger "
                                     "than or equal to the max CSN [%s] from RUV [%s] for element [%s]\n",
                                     csnstrb, ruvbname, csnstra, ruvaname, ruvelem);
                     rc = RUV_COMP_CSN_DIFFERS;
                 } else if (csn_compare (replicab->csn, replicaa->csn) > 0) {
                     csn_as_string(replicaa->csn, PR_FALSE, csnstra);
-                    slapi_log_error(loglevel, loglevel==SLAPI_LOG_REPL?LOG_DEBUG:LOG_ERR,repl_plugin_name,
-                                    "ruv_compare_ruv: the max CSN [%s] from RUV [%s] is larger "
+                    slapi_log_error(loglevel, repl_plugin_name,
+                                    "ruv_compare_ruv - The max CSN [%s] from RUV [%s] is larger "
                                     "than the max CSN [%s] from RUV [%s] for element [%s]\n",
                                     csnstrb, ruvbname, csnstra, ruvaname, ruvelem);
                     rc = RUV_COMP_CSN_DIFFERS;
                 } else {
                     csn_as_string(replicaa->csn, PR_FALSE, csnstra);
-                    slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-                                    "ruv_compare_ruv: the max CSN [%s] from RUV [%s] is less than "
+                    slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+                                    "ruv_compare_ruv - The max CSN [%s] from RUV [%s] is less than "
                                     "or equal to the max CSN [%s] from RUV [%s] for element [%s]\n",
                                     csnstrb, ruvbname, csnstra, ruvaname, ruvelem);
                 }
             } else {
-                slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-                                "ruv_compare_ruv: RUV [%s] has an empty CSN\n",
+                slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+                                "ruv_compare_ruv - RUV [%s] has an empty CSN\n",
                                 ruvbname);
             }
         }
@@ -1564,7 +1564,7 @@ ruv_dump(const RUV *ruv, char *ruv_name, PRFileDesc *prFile)
 	}
 	else
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "%s", buff);
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "%s", buff);
 	}
 	for (replica = dl_get_first (ruv->elements, &cookie); replica;
 		 replica = dl_get_next (ruv->elements, &cookie))
@@ -1589,7 +1589,7 @@ ruv_dump(const RUV *ruv, char *ruv_name, PRFileDesc *prFile)
 		}
 		else
 		{
-			slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "%s", buff);
+			slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "%s", buff);
 		}
 	}
 
@@ -1622,7 +1622,7 @@ int ruv_add_csn_inprogress (RUV *ruv, const CSN *csn)
         if (replica == NULL)
         {
             if (slapi_is_loglevel_set(SLAPI_LOG_REPL)) {
-                slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "ruv_add_csn_inprogress: failed to add replica"
+                slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "ruv_add_csn_inprogress - Failed to add replica"
                     " that created csn %s\n", csn_as_string (csn, PR_FALSE, csn_str));
             }
             rc = RUV_MEMORY_ERROR;
@@ -1634,8 +1634,8 @@ int ruv_add_csn_inprogress (RUV *ruv, const CSN *csn)
     if (ruv_covers_csn_internal(ruv, csn, PR_FALSE))
     {
         if (slapi_is_loglevel_set(SLAPI_LOG_REPL)) {
-            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "ruv_add_csn_inprogress: "
-                            "the csn %s has already be seen - ignoring\n",
+            slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "ruv_add_csn_inprogress - "
+                            "The csn %s has already be seen - ignoring\n",
                             csn_as_string (csn, PR_FALSE, csn_str));
         }
         rc = RUV_COVERS_CSN;
@@ -1646,8 +1646,8 @@ int ruv_add_csn_inprogress (RUV *ruv, const CSN *csn)
     if (rc == 1)    /* we already seen this csn */
     {
         if (slapi_is_loglevel_set(SLAPI_LOG_REPL)) {
-            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "ruv_add_csn_inprogress: "
-                            "the csn %s has already be seen - ignoring\n",
+            slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "ruv_add_csn_inprogress - "
+                            "The csn %s has already be seen - ignoring\n",
                             csn_as_string (csn, PR_FALSE, csn_str));
         }
         rc = RUV_COVERS_CSN;    
@@ -1655,7 +1655,7 @@ int ruv_add_csn_inprogress (RUV *ruv, const CSN *csn)
     else if(rc != 0)
     {
         if (slapi_is_loglevel_set(SLAPI_LOG_REPL)) {
-            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "ruv_add_csn_inprogress: failed to insert csn %s"
+            slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "ruv_add_csn_inprogress - Failed to insert csn %s"
                             " into pending list\n", csn_as_string (csn, PR_FALSE, csn_str));
         }
         rc = RUV_UNKNOWN_ERROR;
@@ -1663,7 +1663,7 @@ int ruv_add_csn_inprogress (RUV *ruv, const CSN *csn)
     else
     {
         if (slapi_is_loglevel_set(SLAPI_LOG_REPL)) {
-            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "ruv_add_csn_inprogress: successfully inserted csn %s"
+            slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "ruv_add_csn_inprogress - Successfully inserted csn %s"
                             " into pending list\n", csn_as_string (csn, PR_FALSE, csn_str));
         }
         rc = RUV_SUCCESS;
@@ -1719,14 +1719,14 @@ int ruv_update_ruv (RUV *ruv, const CSN *csn, const char *replica_purl, PRBool i
     {
         /* we should have a ruv element at this point because it would have
            been added by ruv_add_inprogress function */
-        slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "ruv_update_ruv: "
-			            "can't locate RUV element for replica %d\n", csn_get_replicaid (csn)); 
+        slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "ruv_update_ruv - "
+			            "Can't locate RUV element for replica %d\n", csn_get_replicaid (csn)); 
         goto done;
     } 
 
 	if (csnplCommit(replica->csnpl, csn) != 0)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "ruv_update_ruv: cannot commit csn %s\n",
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "ruv_update_ruv - Cannot commit csn %s\n",
 			            csn_as_string(csn, PR_FALSE, csn_str));
         rc = RUV_CSNPL_ERROR;
         goto done;
@@ -1734,15 +1734,15 @@ int ruv_update_ruv (RUV *ruv, const CSN *csn, const char *replica_purl, PRBool i
     else
     {
         if (slapi_is_loglevel_set(SLAPI_LOG_REPL)) {
-            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "ruv_update_ruv: "
-                            "successfully committed csn %s\n", csn_as_string(csn, PR_FALSE, csn_str));
+            slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "ruv_update_ruv - "
+                            "Successfully committed csn %s\n", csn_as_string(csn, PR_FALSE, csn_str));
         }
     }
 
 	if ((max_csn = csnplRollUp(replica->csnpl, &first_csn)) != NULL)
 	{
 #ifdef DEBUG
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "ruv_update_ruv: rolled up to csn %s\n",
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "ruv_update_ruv - Rolled up to csn %s\n",
 			            csn_as_string(max_csn, PR_FALSE, csn_str)); /* XXXggood remove debugging */
 #endif
         /* replica object sets min csn for local replica */
@@ -1793,8 +1793,8 @@ ruvInit (RUV **ruv, int initCount)
 	(*ruv)->lock = slapi_new_rwlock();
 	if ((*ruv)->lock == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
-						"ruvInit: failed to create lock\n");
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, 
+						"ruvInit - Failed to create lock\n");
 		dl_free(&(*ruv)->elements);
 		slapi_ch_free((void**)ruv);
 		return RUV_NSPR_ERROR;
@@ -1840,7 +1840,7 @@ ruvAddReplica (RUV *ruv, const CSN *csn, const char *replica_purl)
 	replica = (RUVElement *)slapi_ch_calloc (1, sizeof (RUVElement));
 	if (replica == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, 
 						"ruvAddReplica: memory allocation failed\n");
 		return NULL;
 	}
@@ -1871,8 +1871,8 @@ ruvAddReplicaNoCSN (RUV *ruv, ReplicaId rid, const char *replica_purl)
 	replica = (RUVElement *)slapi_ch_calloc (1, sizeof (RUVElement));
 	if (replica == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
-						"ruvAddReplicaNoCSN: memory allocation failed\n");
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, 
+						"ruvAddReplicaNoCSN - Memory allocation failed\n");
 		return NULL;
 	}
 
@@ -1896,8 +1896,8 @@ ruvAddIndexReplicaNoCSN (RUV *ruv, ReplicaId rid, const char *replica_purl, int
 	replica = (RUVElement *)slapi_ch_calloc (1, sizeof (RUVElement));
 	if (replica == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
-						"ruvAddIndexReplicaNoCSN: memory allocation failed\n");
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, 
+						"ruvAddIndexReplicaNoCSN - Memory allocation failed\n");
 		return NULL;
 	}
 
@@ -1990,8 +1990,8 @@ get_ruvelement_from_berval(const struct berval *bval)
 		bval->bv_len <= strlen(prefix_ruvcsn) ||
 		strncasecmp(bval->bv_val, prefix_ruvcsn, strlen(prefix_ruvcsn)) != 0)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
-				"get_ruvelement_from_berval: invalid berval\n");
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, 
+				"get_ruvelement_from_berval - Invalid berval\n");
 		goto loser;
 	} 
 
@@ -2082,8 +2082,8 @@ get_ruvelement_from_berval(const struct berval *bval)
     ret_ruve->csnpl = csnplNew ();
     if (ret_ruve->csnpl == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
-						"get_ruvelement_from_berval: failed to create csn pending list\n");
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, 
+						"get_ruvelement_from_berval - Failed to create csn pending list\n");
 		goto loser;
 	} 
 
@@ -2242,7 +2242,7 @@ ruv_is_newer (Object *sruvobj, Object *cruvobj)
 
 		if ( cruv->elements == NULL )
 			{
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
 			"ruv_is_newer, consumer RUV has no elements\n");
 			 is_newer=PR_FALSE;
 			 break;
@@ -2290,9 +2290,7 @@ ruv_force_csn_update_from_ruv(RUV *src_ruv, RUV *tgt_ruv, char *msg, int logLeve
 
             ruv_force_csn_update(tgt_ruv, replica->csn);
             csn_as_string(replica->csn, PR_FALSE, csnStr);
-            slapi_log_error(logLevel, logLevel==SLAPI_LOG_REPL?LOG_DEBUG:LOG_ERR,
-                    repl_plugin_name, "%s %s\n",
-                    msg, csnStr);
+            slapi_log_error(logLevel, repl_plugin_name, "%s %s\n", msg, csnStr);
         }
     }
 

ldap/servers/plugins/replication/repl5_schedule.c

@@ -593,7 +593,7 @@ schedule_window_state_change_event (Schedule *sch)
         sch->pending_event = slapi_eq_once(window_state_changed, sch, wakeup_time);        
 
         timestr = get_timestring(&wakeup_time);
-        slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "%s: Update window will %s at %s\n",
+        slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "%s: Update window will %s at %s\n",
 						sch->session_id,
                          window_opened ? "close" : "open", timestr);
         free_timestring(timestr);
@@ -615,7 +615,7 @@ window_state_changed (time_t when, void *arg)
 
     open = schedule_in_window_now_nolock(sch);
 
-    slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "%s: Update window is now %s\n",
+    slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "%s: Update window is now %s\n",
 					sch->session_id,
                     open ? "open" : "closed");
 

ldap/servers/plugins/replication/repl5_tot_protocol.c

@@ -92,10 +92,11 @@ static void repl5_tot_delete(Private_Repl_Protocol **prp);
 static void 
 repl5_tot_log_operation_failure(int ldap_error, char* ldap_error_string, const char *agreement_name)
 {
-                slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-						"%s: Received error %d (%s): %s for total update operation\n",
-						agreement_name,
-						ldap_error, ldap_err2string(ldap_error), ldap_error_string ? ldap_error_string : "");
+    slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+            "repl5_tot_log_operation_failure - "
+    		"%s: Received error %d (%s): %s for total update operation\n",
+            agreement_name, ldap_error, ldap_err2string(ldap_error),
+            ldap_error_string ? ldap_error_string : "");
 }
 
 /* Thread that collects results from async operations sent to the consumer */
@@ -203,8 +204,8 @@ static int repl5_tot_create_async_result_thread(callback_data *cb_data)
 				SLAPD_DEFAULT_THREAD_STACKSIZE);
 	if (NULL == tid) 
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, NULL,
-					"repl5_tot_create_async_result_thread failed. "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+					"repl5_tot_create_async_result_thread - Failed. "
 					SLAPI_COMPONENT_NAME_NSPR " error %d (%s)\n",
 					PR_GetError(), slapd_pr_strerror( PR_GetError() ));
 		retval = -1;
@@ -262,8 +263,8 @@ repl5_tot_waitfor_async_results(callback_data *cb_data)
 		/* Lock the structure to force memory barrier */
 		PR_Lock(cb_data->lock);
 		/* Are we caught up ? */
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, NULL,
-					"repl5_tot_waitfor_async_results: %d %d\n",
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+					"repl5_tot_waitfor_async_results - %d %d\n",
 					cb_data->last_message_id_received, cb_data->last_message_id_sent);
 		if (cb_data->last_message_id_received >= cb_data->last_message_id_sent) 
 		{
@@ -290,8 +291,8 @@ repl5_tot_waitfor_async_results(callback_data *cb_data)
 		if (!done && (loops > 30))
 		{
 			/* Log a warning */
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, NULL,
-					"repl5_tot_waitfor_async_results timed out waiting for responses: %d %d\n",
+			slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name,
+					"repl5_tot_waitfor_async_results - Timed out waiting for responses: %d %d\n",
 					cb_data->last_message_id_received, cb_data->last_message_id_sent);
 			done = 1;
 		}
@@ -338,7 +339,7 @@ repl5_tot_run(Private_Repl_Protocol *prp)
 
 	area_sdn = agmt_get_replarea(prp->agmt);
 	if (!area_sdn) {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Warning: unable to "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "repl5_tot_run - Unable to "
 		                "get repl area.  Please check agreement.\n");
 		goto done;
 	}
@@ -362,10 +363,9 @@ retry:
         conn_get_error(prp->conn, &optype, &ldaprc);
         if (rc == ACQUIRE_TRANSIENT_ERROR && INIT_RETRY_MAX > init_retry++) {
             wait_retry = init_retry * INIT_RETRY_INT;
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Warning: unable to "
-                        "acquire replica for total update, error: %d,"
-                                                " retrying in %d seconds.\n",
-                         ldaprc, wait_retry);
+            slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name, "repl5_tot_run - "
+                    "Unable to acquire replica for total update, error: %d, retrying in %d seconds.\n",
+                    ldaprc, wait_retry);
             DS_Sleep(PR_SecondsToInterval(wait_retry));
             goto retry;
         } else {
@@ -393,10 +393,10 @@ retry:
 
 	if (CONN_SCHEMA_UPDATED != rc && CONN_SCHEMA_NO_UPDATE_NEEDED != rc)
 	{
-	    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Warning: unable to "
-						"replicate schema to host %s, port %d. Continuing with "
-						"total update session.\n",
-						hostname, portnum);
+		slapi_log_error(SLAPI_LOG_WARNING, repl_plugin_name, "repl5_tot_run - "
+			"Unable to replicate schema to host %s, port %d. "
+			"Continuing with total update session.\n",
+			hostname, portnum);
 		/* But keep going */
 		agmt_set_last_init_status(prp->agmt, 0, rc, 0, "Total schema update failed");
 	}
@@ -413,7 +413,7 @@ retry:
 
     agmt_set_last_init_status(prp->agmt, 0, 0, 0, "Total update in progress");
 
-    slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Beginning total update of replica "
+    slapi_log_error(SLAPI_LOG_INFO, repl_plugin_name, "repl5_tot_run - Beginning total update of replica "
                     "\"%s\".\n", agmt_get_long_name(prp->agmt));
 
     /* RMREPL - need to send schema here */
@@ -427,13 +427,13 @@ retry:
      */
     rc = slapi_lookup_instance_name_by_suffix((char *)slapi_sdn_get_dn(area_sdn), NULL, &instances, 1);
     if (rc || !instances) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Warning: unable to "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "repl5_tot_run - Unable to "
                         "get the instance name for the suffix \"%s\".\n", slapi_sdn_get_dn(area_sdn));
         goto done;
     }
     be = slapi_be_select_by_instance_name(instances[0]);
     if (!be) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Warning: unable to "
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "repl5_tot_run - Unable to "
                         "get the instance for the suffix \"%s\".\n", slapi_sdn_get_dn(area_sdn));
         goto done;
     }
@@ -446,7 +446,7 @@ retry:
         /* Get suffix */
         rc = slapi_search_internal_get_entry(area_sdn, NULL, &suffix, repl_get_plugin_identity(PLUGIN_MULTIMASTER_REPLICATION));
         if (rc) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Warning: unable to "
+            slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "repl5_tot_run -  Unable to "
                             "get the suffix entry \"%s\".\n", slapi_sdn_get_dn(area_sdn));
             goto done;
         }
@@ -467,7 +467,7 @@ retry:
         /* Send suffix first. */
         rc = send_entry(suffix, (void *)&cb_data);
         if (rc) {
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Warning: unable to "
+            slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "repl5_tot_run - Unable to "
                             "send the suffix entry \"%s\" to the consumer.\n", slapi_sdn_get_dn(area_sdn));
             goto done;
         }
@@ -533,7 +533,7 @@ retry:
 	{
 		rc = repl5_tot_create_async_result_thread(&cb_data);
 		if (rc) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "%s: repl5_tot_run: "
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "repl5_tot_run - %s"
 							 "repl5_tot_create_async_result_thread failed; error - %d\n", 
 							 agmt_get_long_name(prp->agmt), rc);
 			goto done;
@@ -563,7 +563,7 @@ retry:
 		}
 		rc = repl5_tot_destroy_async_result_thread(&cb_data);
 		if (rc) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "%s: repl5_tot_run: "
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "repl5_tot_run - %s - "
 							 "repl5_tot_destroy_async_result_thread failed; error - %d\n", 
 							 agmt_get_long_name(prp->agmt), rc);
 		}
@@ -583,11 +583,11 @@ retry:
 	
 	if (rc != CONN_OPERATION_SUCCESS)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Total update failed for replica \"%s\", "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "repl5_tot_run - Total update failed for replica \"%s\", "
 				         "error (%d)\n", agmt_get_long_name(prp->agmt), rc);
 		agmt_set_last_init_status(prp->agmt, 0, 0, rc, "Total update aborted");
 	} else {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Finished total update of replica "
+		slapi_log_error(SLAPI_LOG_INFO, repl_plugin_name, "repl5_tot_run - Finished total update of replica "
 		                 "\"%s\". Sent %lu entries.\n",
 		                 agmt_get_long_name(prp->agmt), cb_data.num_entries);
 		agmt_set_last_init_status(prp->agmt, 0, 0, 0, "Total update succeeded");
@@ -599,7 +599,7 @@ done:
 	slapi_ch_free_string(&hostname);
 	if (cb_data.flowcontrol_detection > 1)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
 			"%s: Total update flow control triggered %d times\n"
 			"You may increase %s and/or decrease %s in the replica agreement configuration\n",
 			agmt_get_long_name(prp->agmt),
@@ -645,7 +645,7 @@ repl5_tot_stop(Private_Repl_Protocol *prp)
 	if (!prp->stopped)
 	{
 		/* Isn't listening. Disconnect from the replica. */
-        slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "repl5_tot_run: "
+        slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "repl5_tot_stop - "
                          "protocol not stopped after waiting for %d seconds "
 						 "for agreement %s\n", PR_IntervalToSeconds(now-start),
 						 agmt_get_long_name(prp->agmt));
@@ -843,7 +843,7 @@ int send_entry (Slapi_Entry *e, void *cb_data)
 
     if (bere == NULL)
     {
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "%s: send_entry: Encoding Error\n",
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "%s: send_entry: Encoding Error\n",
 				agmt_get_long_name(prp->agmt));
 		((callback_data*)cb_data)->rc = -1;
         retval = -1;
@@ -860,43 +860,43 @@ int send_entry (Slapi_Entry *e, void *cb_data)
     }
 
     do {
-	/* push the entry to the consumer */
-	rc = conn_send_extended_operation(prp->conn, REPL_NSDS50_REPLICATION_ENTRY_REQUEST_OID,
-	                              bv /* payload */, NULL /* update_control */, &message_id);   
-
-	if (message_id) 
-	{
-		((callback_data*)cb_data)->last_message_id_sent = message_id;
-	}
-
-	/* If we are talking to a 5.0 type consumer, we need to wait here and retrieve the 
-	 * response. Reason is that it can return LDAP_BUSY, indicating that its queue has
-	 * filled up. This completely breaks pipelineing, and so we need to fall back to 
-	 * sync transmission for those consumers, in case they pull the LDAP_BUSY stunt on us :( */
-
-	if (prp->repl50consumer) 
-	{
-		/* Get the response here */
-		rc = repl5_tot_get_next_result((callback_data*)cb_data);
-	}
-
-	if (rc == CONN_BUSY) {
-		time_t now = current_time ();
-		if ((now - *last_busyp) < (*sleep_on_busyp + 10)) {
-			*sleep_on_busyp +=5;
-	}
-	else {
-		*sleep_on_busyp = 5;
-	}
-	*last_busyp = now;
-
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-		"Replica \"%s\" is busy. Waiting %lds while"
-		" it finishes processing its current import queue\n", 
-		agmt_get_long_name(prp->agmt), *sleep_on_busyp);
-		DS_Sleep(PR_SecondsToInterval(*sleep_on_busyp));
-    	}
-    } 
+		/* push the entry to the consumer */
+		rc = conn_send_extended_operation(prp->conn, REPL_NSDS50_REPLICATION_ENTRY_REQUEST_OID,
+									  bv /* payload */, NULL /* update_control */, &message_id);   
+	
+		if (message_id) 
+		{
+			((callback_data*)cb_data)->last_message_id_sent = message_id;
+		}
+	
+		/* If we are talking to a 5.0 type consumer, we need to wait here and retrieve the 
+		 * response. Reason is that it can return LDAP_BUSY, indicating that its queue has
+		 * filled up. This completely breaks pipelineing, and so we need to fall back to 
+		 * sync transmission for those consumers, in case they pull the LDAP_BUSY stunt on us :( */
+	
+		if (prp->repl50consumer) 
+		{
+			/* Get the response here */
+			rc = repl5_tot_get_next_result((callback_data*)cb_data);
+		}
+	
+		if (rc == CONN_BUSY) {
+			time_t now = current_time ();
+			if ((now - *last_busyp) < (*sleep_on_busyp + 10)) {
+				*sleep_on_busyp +=5;
+			}
+			else {
+				*sleep_on_busyp = 5;
+			}
+			*last_busyp = now;
+		
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"send_entry - Replica \"%s\" is busy. Waiting %lds while"
+				" it finishes processing its current import queue\n", 
+				agmt_get_long_name(prp->agmt), *sleep_on_busyp);
+				DS_Sleep(PR_SecondsToInterval(*sleep_on_busyp));
+		}
+    }
     while (rc == CONN_BUSY);
 
     ber_bvfree(bv);

ldap/servers/plugins/replication/repl5_total.c

@@ -245,7 +245,7 @@ my_ber_printf_csn(BerElement *ber, const CSN *csn, const CSNType t)
         case CSN_TYPE_ATTRIBUTE_DELETED:
             break;
 	    default:
-            slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "my_ber_printf_csn: unknown "
+            slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "my_ber_printf_csn - Unknown "
 			                "csn type %d encountered.\n", (int)t);
         return -1;
 	}
@@ -454,7 +454,7 @@ my_ber_scanf_value(BerElement *ber, Slapi_Value **value, PRBool *deleted)
 
 	if (NULL == ber && NULL == value)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "my_ber_scanf_value BAD 1\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "my_ber_scanf_value - BAD 1\n");
 		goto loser;
 	}
 
@@ -463,13 +463,13 @@ my_ber_scanf_value(BerElement *ber, Slapi_Value **value, PRBool *deleted)
 	/* Each value is a sequence */
 	if (ber_scanf(ber, "{O", &attrval) == LBER_ERROR)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "my_ber_scanf_value BAD 2\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "my_ber_scanf_value - BAD 2\n");
 		goto loser;
 	}
 	/* Allocate and fill in the attribute value */
 	if ((*value = slapi_value_new_berval(attrval)) == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "my_ber_scanf_value BAD 3\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "my_ber_scanf_value - BAD 3\n");
 		goto loser;
 	}
 
@@ -478,7 +478,7 @@ my_ber_scanf_value(BerElement *ber, Slapi_Value **value, PRBool *deleted)
     {
         if (ber_scanf(ber, "b", deleted) == LBER_ERROR)
 		{
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "my_ber_scanf_value BAD 4\n");
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "my_ber_scanf_value - BAD 4\n");
 			goto loser;
 		}
     }
@@ -498,7 +498,7 @@ my_ber_scanf_value(BerElement *ber, Slapi_Value **value, PRBool *deleted)
 		len = CSN_STRSIZE;
 		if (ber_scanf(ber, "{es}", &csntype_tmp, csnstring, &len) == LBER_ERROR)
 		{
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "my_ber_scanf_value BAD 7 - bval is %s\n", attrval->bv_val);
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "my_ber_scanf_value - BAD 7 - bval is %s\n", attrval->bv_val);
 			goto loser;
 		}
 		switch (csntype_tmp)
@@ -513,14 +513,14 @@ my_ber_scanf_value(BerElement *ber, Slapi_Value **value, PRBool *deleted)
 			csntype = CSN_TYPE_VALUE_DISTINGUISHED;
 			break;
 		default:
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Error: preposterous CSN type "
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "my_ber_scanf_value - Error: preposterous CSN type "
 				"%d received during total update.\n", csntype_tmp);
 			goto loser;
 		}
 		csn = csn_new_by_string(csnstring);
 		if (csn == NULL)
 		{
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "my_ber_scanf_value BAD 8\n");
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "my_ber_scanf_value - BAD 8\n");
 			goto loser;
 		}
 		value_add_csn(*value, csntype, csn);
@@ -529,7 +529,7 @@ my_ber_scanf_value(BerElement *ber, Slapi_Value **value, PRBool *deleted)
 
 	if (ber_scanf(ber, "}") == LBER_ERROR) /* End of annotated attribute value seq */
 	{
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "my_ber_scanf_value BAD 10\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "my_ber_scanf_value - BAD 10\n");
 		goto loser;
 	}
 	
@@ -799,7 +799,7 @@ loser:
         slapi_entry_free (e);
     }
 	*ep = NULL;
-	slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Error: could not decode extended "
+	slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "decode_total_update_extop - Could not decode extended "
 		"operation containing entry for total update.\n");
 
 free_and_return:
@@ -850,21 +850,22 @@ multimaster_extop_NSDS50ReplicationEntry(Slapi_PBlock  *pb)
         */
        if (rc != LDAP_SUCCESS)
 	   {
-		   const char *dn = slapi_entry_get_dn_const(e);
-		   slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-						   "Error %d: could not import entry dn %s "
-						   "for total update operation conn=%" NSPRIu64 " op=%d\n",
-						   rc, dn, connid, opid);
+           const char *dn = slapi_entry_get_dn_const(e);
+           slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+                   "multimaster_extop_NSDS50ReplicationEntry - "
+                   "Error %d: could not import entry dn %s for total update operation conn=%" NSPRIu64 " op=%d\n",
+                   rc, dn, connid, opid);
 		   rc = -1;
 	   }
         
 	}
 	else
 	{
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-						"Error %d: could not decode the total update extop "
-						"for total update operation conn=%" NSPRIu64 " op=%d\n",
-						rc, connid, opid);
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+				"multimaster_extop_NSDS50ReplicationEntry - "
+				"Error %d: could not decode the total update extop "
+				"for total update operation conn=%" NSPRIu64 " op=%d\n",
+				rc, connid, opid);
 	}
    
     if (LDAP_SUCCESS != rc) {

ldap/servers/plugins/replication/repl5_updatedn_list.c

@@ -52,8 +52,8 @@ replica_updatedn_list_new(const Slapi_Entry *entry)
     PLHashTable *hash = PL_NewHashTable(4, PL_HashString, PL_CompareStrings,
 										updatedn_compare_dns, NULL, NULL);
     if (hash == NULL) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_new_updatedn_list: "
-                        "failed to allocate hash table; NSPR error - %d\n",
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_new_updatedn_list - "
+                        "Failed to allocate hash table; NSPR error - %d\n",
                         PR_GetError ());	
         return NULL;
     }
@@ -96,8 +96,8 @@ replica_groupdn_list_new(const Slapi_ValueSet *vs)
     hash = PL_NewHashTable(4, PL_HashString, PL_CompareStrings,
 						updatedn_compare_dns, NULL, NULL);
     if (hash == NULL) {
-        slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "replica_new_updatedn_list: "
-                        "failed to allocate hash table; NSPR error - %d\n",
+        slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "replica_new_updatedn_list - "
+                        "Failed to allocate hash table; NSPR error - %d\n",
                         PR_GetError ());	
         return NULL;
     }
@@ -150,8 +150,8 @@ replica_updatedn_list_delete(ReplicaUpdateDNList list, const Slapi_ValueSet *vs)
 			Slapi_DN *deldn = (Slapi_DN *)PL_HashTableLookup(hash, slapi_sdn_get_ndn(dn));     
 			if (deldn == NULL)
 			{
-				slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "replica_updatedn_list_delete: "
-								"update DN with value (%s) is not in the update DN list.\n",
+				slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "replica_updatedn_list_delete -"
+								"Update DN with value (%s) is not in the update DN list.\n",
 								slapi_sdn_get_ndn(dn));
 			} else {
 				/* remove from hash */
@@ -245,8 +245,8 @@ replica_updatedn_list_add_ext(ReplicaUpdateDNList list, const Slapi_ValueSet *vs
 		/* make sure that the name is unique */
 		if (PL_HashTableLookup(hash, ndn) != NULL)
 		{
-			slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "replica_updatedn_list_add: "
-							"update DN with value (%s) already in the update DN list\n",
+			slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "replica_updatedn_list_add - "
+							"Update DN with value (%s) already in the update DN list\n",
 							ndn);
 			slapi_sdn_free(&dn);
 		} else {

ldap/servers/plugins/replication/repl_bind.c

@@ -40,7 +40,7 @@ legacy_preop_bind( Slapi_PBlock *pb )
 			void *conn = NULL;
 			consumer_connection_extension *connext = NULL;
 #ifdef DEBUG
-	slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, REPLICATION_SUBSYSTEM, "legacy_preop_bind: begin\n");
+	slapi_log_error(SLAPI_LOG_REPL, REPLICATION_SUBSYSTEM, "legacy_preop_bind: begin\n");
 #endif
 			slapi_pblock_get( pb, SLAPI_CONNECTION, &conn );
 			/* TEL 20120529 - Is there any reason we must protect this connext access? */

ldap/servers/plugins/replication/repl_connext.c

@@ -31,7 +31,8 @@ void* consumer_connection_extension_constructor (void *object, void *parent)
 	consumer_connection_extension *ext = (consumer_connection_extension*) slapi_ch_malloc (sizeof (consumer_connection_extension));
 	if (ext == NULL)
 	{
-		slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "unable to create replication consumer connection extension - out of memory\n" );
+		slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "consumer_connection_extension_constructor - "
+			"Unable to create replication consumer connection extension - out of memory\n" );
 	}
 	else
 	{
@@ -45,7 +46,8 @@ void* consumer_connection_extension_constructor (void *object, void *parent)
 		ext->lock = PR_NewLock();
 		if (NULL == ext->lock)
 		{
-			slapi_log_error(SLAPI_LOG_PLUGIN, LOG_DEBUG, repl_plugin_name, "unable to create replication consumer connection extension lock - out of memory\n" );
+			slapi_log_error(SLAPI_LOG_PLUGIN, repl_plugin_name, "consumer_connection_extension_constructor - "
+				"Unable to create replication consumer connection extension lock - out of memory\n" );
 			/* no need to go through the full destructor, but still need to free up this memory */
 			slapi_ch_free((void **)&ext);
 			ext = NULL;
@@ -79,16 +81,16 @@ void consumer_connection_extension_destructor (void *ext, void *object, void *pa
 					slapi_pblock_set(pb, SLAPI_CONNECTION, connext->connection);
 					slapi_pblock_set(pb, SLAPI_TARGET_SDN, (void*)repl_root_sdn);
 					slapi_pblock_get(pb, SLAPI_CONN_ID, &connid);
-					slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-									"Aborting total update in progress for replicated "
-									"area %s connid=%" NSPRIu64 "\n", slapi_sdn_get_dn(repl_root_sdn),
-									connid);
+					slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+							"consumer_connection_extension_destructor - "
+							"Aborting total update in progress for replicated "
+							"area %s connid=%" NSPRIu64 "\n", slapi_sdn_get_dn(repl_root_sdn), connid);
 					slapi_stop_bulk_import(pb);
 				}
 				else
 				{
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-						"consumer_connection_extension_destructor: can't determine root "
+					slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+						"consumer_connection_extension_destructor - Can't determine root "
 						"of replicated area.\n");
 				}
 				slapi_pblock_destroy(pb);
@@ -152,20 +154,23 @@ consumer_connection_extension_acquire_exclusive_access(void* conn, PRUint64 conn
             /* step 4, take it! */
             connext->in_use_opid = opid;
             ret = connext;
-            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
+            slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+            		"consumer_connection_extension_acquire_exclusive_access - "
                     "conn=%" NSPRIu64 " op=%d Acquired consumer connection extension\n",
                     connid, opid);
         }
         else if (opid == connext->in_use_opid)
         {
             ret = connext;
-            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
+            slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+            		"consumer_connection_extension_acquire_exclusive_access - "
                     "conn=%" NSPRIu64 " op=%d Reacquired consumer connection extension\n",
                     connid, opid);
         }
         else
         {
-            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
+            slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+            		"consumer_connection_extension_acquire_exclusive_access - "
                     "conn=%" NSPRIu64 " op=%d Could not acquire consumer connection extension; it is in use by op=%d\n",
                     connid, opid, connext->in_use_opid);
         }
@@ -175,7 +180,8 @@ consumer_connection_extension_acquire_exclusive_access(void* conn, PRUint64 conn
     }
     else
     {
-        slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
+        slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+        		"consumer_connection_extension_acquire_exclusive_access - "
                 "conn=%" NSPRIu64 " op=%d Could not acquire consumer extension, it is NULL!\n",
                 connid, opid);
     }
@@ -213,7 +219,8 @@ consumer_connection_extension_relinquish_exclusive_access(void* conn, PRUint64 c
         /* step 3, see if it is in use */
         if (0 > connext->in_use_opid)
         {
-            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
+            slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+            		"consumer_connection_extension_relinquish_exclusive_access - "
                     "conn=%" NSPRIu64 " op=%d Consumer connection extension is not in use\n",
                     connid, opid);
             ret = 2;
@@ -221,7 +228,8 @@ consumer_connection_extension_relinquish_exclusive_access(void* conn, PRUint64 c
         else if (opid == connext->in_use_opid)
         {
             /* step 4, relinquish it (normal) */
-            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
+            slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+            		"consumer_connection_extension_relinquish_exclusive_access - "
                     "conn=%" NSPRIu64 " op=%d Relinquishing consumer connection extension\n",
                     connid, opid);
             connext->in_use_opid = -1;
@@ -230,7 +238,8 @@ consumer_connection_extension_relinquish_exclusive_access(void* conn, PRUint64 c
         else if (force)
         {
             /* step 4, relinquish it (forced) */
-            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
+            slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+            		"consumer_connection_extension_relinquish_exclusive_access - "
                     "conn=%" NSPRIu64 " op=%d Forced to relinquish consumer connection extension held by op=%d\n",
                     connid, opid, connext->in_use_opid);
             connext->in_use_opid = -1;
@@ -238,7 +247,8 @@ consumer_connection_extension_relinquish_exclusive_access(void* conn, PRUint64 c
         }
         else
         {
-            slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
+            slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+            		"consumer_connection_extension_relinquish_exclusive_access - "
                     "conn=%" NSPRIu64 " op=%d Not relinquishing consumer connection extension, it is held by op=%d!\n",
                     connid, opid, connext->in_use_opid);
         }
@@ -248,7 +258,8 @@ consumer_connection_extension_relinquish_exclusive_access(void* conn, PRUint64 c
     }
     else
     {
-        slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, 
+        slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+        		"consumer_connection_extension_relinquish_exclusive_access - "
                 "conn=%" NSPRIu64 " op=%d Could not relinquish consumer extension, it is NULL!\n",
                 connid, opid);
     }

ldap/servers/plugins/replication/repl_extop.c

@@ -666,7 +666,8 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
 
 		/* Stash info that this is an incremental update session */
 		connext->repl_protocol_version = REPL_PROTOCOL_50_INCREMENTAL;
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+			"multimaster_extop_StartNSDS50ReplicationRequest - "
 			"conn=%" NSPRIu64 " op=%d repl=\"%s\": Begin incremental protocol\n",
 			connid, opid, repl_root);
 		isInc = PR_TRUE;
@@ -692,7 +693,8 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
 		{
 			connext->repl_protocol_version = REPL_PROTOCOL_50_TOTALUPDATE;
 		}
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+				"multimaster_extop_StartNSDS50ReplicationRequest - "
 				"conn=%" NSPRIu64 " op=%d repl=\"%s\": Begin total protocol\n",
 				connid, opid, repl_root);
 		isInc = PR_FALSE;
@@ -701,7 +703,8 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
 	{
 		/* Stash info that this is an incremental update session */
 		connext->repl_protocol_version = REPL_PROTOCOL_50_INCREMENTAL;
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+			"multimaster_extop_StartNSDS50ReplicationRequest - "
 			"conn=%" NSPRIu64 " op=%d repl=\"%s\": Begin 7.1 incremental protocol\n",
 			connid, opid, repl_root);
 		isInc = PR_TRUE;
@@ -713,7 +716,8 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
 		{
 			connext->repl_protocol_version = REPL_PROTOCOL_50_TOTALUPDATE;
 		}
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+				"multimaster_extop_StartNSDS50ReplicationRequest - "
 				"conn=%" NSPRIu64 " op=%d repl=\"%s\": Begin 7.1 total protocol\n",
 				connid, opid, repl_root);
 		isInc = PR_FALSE;
@@ -735,7 +739,8 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
 	/* see if this replica is being configured and wait for it */
 	if (replica_is_being_configured(repl_root))
 	{
-        slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
+        slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+        		"multimaster_extop_StartNSDS50ReplicationRequest - "
 				"conn=%" NSPRIu64 " op=%d replica=\"%s\": "
 				"Replica is being configured: try again later\n",
 				connid, opid, repl_root);
@@ -762,7 +767,8 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
 		if (replica_is_state_flag_set(replica,
 							REPLICA_TOTAL_EXCL_SEND|REPLICA_TOTAL_EXCL_RECV))
 		{
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+				"multimaster_extop_StartNSDS50ReplicationRequest - "
 				"%s: total update on is initiated on the replica.  Cannot execute the total update from other master.\n", repl_root);
 			response = NSDS50_REPL_REPLICA_BUSY;
 			goto send_response;
@@ -806,10 +812,11 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
 				rc = replica_update_csngen_state_ext (replica, supplier_ruv, replicacsn); /* too much skew */
 				if (rc == CSN_LIMIT_EXCEEDED)
 				{
-					slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name,
-									"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
-									"Excessive clock skew from supplier RUV\n",
-									connid, opid, repl_root);
+					slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name,
+							"multimaster_extop_StartNSDS50ReplicationRequest - "
+							"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
+							"Excessive clock skew from supplier RUV\n",
+							connid, opid, repl_root);
 					response = NSDS50_REPL_EXCESSIVE_CLOCK_SKEW;
 					goto send_response;
 				}
@@ -843,7 +850,8 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
 	}
 
 	if (check_replica_id_uniqueness(replica, supplier_ruv) != 0){
-        slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
+        slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+        		"multimaster_extop_StartNSDS50ReplicationRequest - "
 				"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
 				"Replica has same replicaID %d as supplier\n",
 				connid, opid, repl_root, replica_get_rid(replica));
@@ -882,19 +890,21 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
 	if (getenv("SLAPD_TEST_TICKET_374") && (opid > 20)) {
 		int i = 0;
 		int max = 480 * 5;
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-						"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
-						"374 - Starting sleep: connext->repl_protocol_version == %d\n",
-						connid, opid, repl_root, connext->repl_protocol_version);
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+				"multimaster_extop_StartNSDS50ReplicationRequest - "
+				"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
+				"374 - Starting sleep: connext->repl_protocol_version == %d\n",
+				connid, opid, repl_root, connext->repl_protocol_version);
         
 		while (REPL_PROTOCOL_50_INCREMENTAL == connext->repl_protocol_version && i++ < max) {
 			usleep(200000);
 		}
         
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-						"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
-						"374 - Finished sleep: connext->repl_protocol_version == %d\n",
-						connid, opid, repl_root, connext->repl_protocol_version);
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+				"multimaster_extop_StartNSDS50ReplicationRequest - "
+				"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
+				"374 - Finished sleep: connext->repl_protocol_version == %d\n",
+				connid, opid, repl_root, connext->repl_protocol_version);
 	}
 #endif
 
@@ -985,7 +995,8 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
 		 * than assuming a total update was requested. 
 		 * https://fedorahosted.org/389/ticket/374 */
 		response = NSDS50_REPL_INTERNAL_ERROR;
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+				"multimaster_extop_StartNSDS50ReplicationRequest - "
 				"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
 				"Unexpected update protocol received: %d.  "
 				"Expected incremental or total.\n",
@@ -1008,7 +1019,7 @@ send_response:
 	}
     if (response != NSDS50_REPL_REPLICA_READY)
     {
-		int resp_log_level = SLAPI_LOG_FATAL;
+		int resp_log_level = SLAPI_LOG_ERR;
 		char purlstr[1024] = {0};
 		if (current_purl)
 			PR_snprintf(purlstr, sizeof(purlstr), " locked by %s for %s update", current_purl,
@@ -1025,8 +1036,9 @@ send_response:
 			resp_log_level = SLAPI_LOG_REPL;
 		}
 
-		slapi_log_error (resp_log_level, resp_log_level==SLAPI_LOG_REPL?LOG_DEBUG:LOG_ERR,
+		slapi_log_error (resp_log_level,
 			repl_plugin_name,
+			"multimaster_extop_StartNSDS50ReplicationRequest - "
 			"conn=%" NSPRIu64 " op=%d replica=\"%s\": "
 			"Unable to acquire replica: error: %s%s\n",
 			connid, opid,
@@ -1078,12 +1090,13 @@ send_response:
 	}
 
 	slapi_pblock_set(pb, SLAPI_EXT_OP_RET_VALUE, resp_bval);
-	slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name,
-					"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
-					"%s: response=%d rc=%d\n",
-					connid, opid, repl_root,
-					is90 ? "StartNSDS90ReplicationRequest" :
-					"StartNSDS50ReplicationRequest", response, rc);
+	slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
+			"multimaster_extop_StartNSDS50ReplicationRequest - "
+			"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
+			"%s: response=%d rc=%d\n",
+			connid, opid, repl_root,
+			is90 ? "StartNSDS90ReplicationRequest" :
+			"StartNSDS50ReplicationRequest", response, rc);
 	slapi_send_ldap_result(pb, LDAP_SUCCESS, NULL, NULL, 0, NULL);
 
 	return_value = SLAPI_PLUGIN_EXTENDED_SENT_RESULT;
@@ -1450,7 +1463,8 @@ multimaster_extop_abort_cleanruv(Slapi_PBlock *pb)
 	 *  Decode the payload, and grab our settings
 	 */
 	if(decode_cleanruv_payload(extop_payload, &payload)){
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Abort CleanAllRUV Task: failed to decode payload.  Aborting ext op\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "multimaster_extop_abort_cleanruv - "
+				"Abort CleanAllRUV Task - Failed to decode payload.  Aborting ext op\n");
 		return LDAP_OPERATIONS_ERROR;
 	}
 	rid = atoi(ldap_utf8strtok_r(payload, ":", &iter));
@@ -1461,13 +1475,15 @@ multimaster_extop_abort_cleanruv(Slapi_PBlock *pb)
 		/* This replica has already been aborted, or was never cleaned, or already finished cleaning */
 		goto out;
 	} else {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Abort CleanAllRUV Task: aborting cleanallruv task for rid(%d)\n", rid);
+		slapi_log_error(SLAPI_LOG_INFO, repl_plugin_name, "multimaster_extop_abort_cleanruv - "
+			"Abort CleanAllRUV Task - Aborting cleanallruv task for rid(%d)\n", rid);
 	}
 	/*
 	 *  Get the node, so we can get the replica and its agreements
 	 */
 	if((mtnode_ext = replica_config_get_mtnode_by_dn(repl_root)) == NULL){
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Abort CleanAllRUV Task: failed to get replication node "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "multimaster_extop_abort_cleanruv - "
+			"Abort CleanAllRUV Task - Failed to get replication node "
 			"from (%s), aborting operation\n", repl_root);
 		rc = LDAP_OPERATIONS_ERROR;
 		goto out;
@@ -1476,14 +1492,16 @@ multimaster_extop_abort_cleanruv(Slapi_PBlock *pb)
 		object_acquire (mtnode_ext->replica);
 		release_it = 1;
 	} else {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Abort CleanAllRUV Task: replica is missing from (%s), "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "multimaster_extop_abort_cleanruv - "
+			"Abort CleanAllRUV Task - Replica is missing from (%s), "
 			"aborting operation\n",repl_root);
 		rc = LDAP_OPERATIONS_ERROR;
 		goto out;
 	}
 	r = (Replica*)object_get_data (mtnode_ext->replica);
 	if(r == NULL){
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "Abort CleanAllRUV Task: replica is NULL, aborting task\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "multimaster_extop_abort_cleanruv - "
+			"Abort CleanAllRUV Task - Replica is NULL, aborting task\n");
 		rc = LDAP_OPERATIONS_ERROR;
 		goto out;
 	}
@@ -1492,7 +1510,8 @@ multimaster_extop_abort_cleanruv(Slapi_PBlock *pb)
 	 */
 	data = (cleanruv_data*)slapi_ch_calloc(1, sizeof(cleanruv_data));
 	if (data == NULL) {
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "Abort CleanAllRUV Task: failed to allocate "
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "multimaster_extop_abort_cleanruv - "
+			"Abort CleanAllRUV Task - Failed to allocate "
 			"abort_cleanruv_data.  Aborting task.\n");
 		rc = LDAP_OPERATIONS_ERROR;
 		goto out;
@@ -1517,7 +1536,8 @@ multimaster_extop_abort_cleanruv(Slapi_PBlock *pb)
 			(void *)data, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
 			PR_UNJOINABLE_THREAD, SLAPD_DEFAULT_THREAD_STACKSIZE);
 	if (thread == NULL) {
-		slapi_log_error(SLAPI_LOG_REPL, LOG_DEBUG, repl_plugin_name, "Abort CleanAllRUV Task: unable to create abort "
+		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "multimaster_extop_abort_cleanruv - "
+			"Abort CleanAllRUV Task - Unable to create abort "
 			"thread.  Aborting task.\n");
 		release_it = 1; /* have to release mtnode_ext->replica now */
 		slapi_ch_free_string(&data->repl_root);
@@ -1580,7 +1600,7 @@ multimaster_extop_cleanruv(Slapi_PBlock *pb)
 	 *  Decode the payload
 	 */
 	if(decode_cleanruv_payload(extop_payload, &payload)){
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "CleanAllRUV Task: failed to decode payload.  Aborting ext op\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "multimaster_extop_cleanruv - CleanAllRUV Task - Failed to decode payload.  Aborting ext op\n");
 		goto free_and_return;
 	}
 	rid = atoi(ldap_utf8strtok_r(payload, ":", &iter));
@@ -1604,7 +1624,7 @@ multimaster_extop_cleanruv(Slapi_PBlock *pb)
 	 *  Get the node, so we can get the replica and its agreements
 	 */
 	if((mtnode_ext = replica_config_get_mtnode_by_dn(repl_root)) == NULL){
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "CleanAllRUV Task: failed to get replication node "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "multimaster_extop_cleanruv - CleanAllRUV Task - Failed to get replication node "
 			"from (%s), aborting operation\n", repl_root);
 		goto free_and_return;
 	}
@@ -1613,14 +1633,14 @@ multimaster_extop_cleanruv(Slapi_PBlock *pb)
 		object_acquire (mtnode_ext->replica);
 		release_it = 1;
 	} else {
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "CleanAllRUV Task: replica is missing from (%s), "
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "multimaster_extop_cleanruv - CleanAllRUV Task - Replica is missing from (%s), "
 			"aborting operation\n",repl_root);
 		goto free_and_return;
 	}
 
 	r = (Replica*)object_get_data (mtnode_ext->replica);
 	if(r == NULL){
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "CleanAllRUV Task: replica is NULL, aborting task\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "multimaster_extop_cleanruv - CleanAllRUV Task - Replica is NULL, aborting task\n");
 		goto free_and_return;
 	}
 
@@ -1630,10 +1650,10 @@ multimaster_extop_cleanruv(Slapi_PBlock *pb)
 		 *
 		 *  This will also release mtnode_ext->replica
 		 */
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "CleanAllRUV Task: launching cleanAllRUV thread...\n");
+		slapi_log_error(SLAPI_LOG_INFO, repl_plugin_name, "multimaster_extop_cleanruv - CleanAllRUV Task - Launching cleanAllRUV thread...\n");
 		data = (cleanruv_data*)slapi_ch_calloc(1, sizeof(cleanruv_data));
 		if (data == NULL) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "CleanAllRUV Task: failed to allocate "
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "multimaster_extop_cleanruv - CleanAllRUV Task - Failed to allocate "
 				"cleanruv_Data\n");
 			goto free_and_return;
 		}
@@ -1650,7 +1670,7 @@ multimaster_extop_cleanruv(Slapi_PBlock *pb)
 				(void *)data, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
 				PR_UNJOINABLE_THREAD, SLAPD_DEFAULT_THREAD_STACKSIZE);
 		if (thread == NULL) {
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "CleanAllRUV Task: unable to create cleanAllRUV "
+			slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "multimaster_extop_cleanruv - CleanAllRUV Task - Unable to create cleanAllRUV "
 				"monitoring thread.  Aborting task.\n");
 			ber_bvfree(data->payload);
 			data->payload = NULL;
@@ -1677,18 +1697,18 @@ multimaster_extop_cleanruv(Slapi_PBlock *pb)
 				/* we've already been cleaned */
 				break;
 			}
-			slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "CleanAllRUV Task: checking if we're caught up...\n");
+			slapi_log_error(SLAPI_LOG_INFO, repl_plugin_name, "multimaster_extop_cleanruv - CleanAllRUV Task - Checking if we're caught up...\n");
 			if(ruv_covers_csn_cleanallruv(ruv,maxcsn) || csn_get_replicaid(maxcsn) == 0|| strcmp(force,"yes") == 0){
 				/* We are caught up */
 				break;
 			} else {
 				char csnstr[CSN_STRSIZE];
 				csn_as_string(maxcsn, PR_FALSE, csnstr);
-				slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "CleanAllRUV Task: not ruv caught up maxcsn(%s)\n", csnstr);
+				slapi_log_error(SLAPI_LOG_NOTICE, repl_plugin_name, "multimaster_extop_cleanruv - CleanAllRUV Task - Not ruv caught up maxcsn(%s)\n", csnstr);
 			}
 			DS_Sleep(PR_SecondsToInterval(5));
 		}
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "CleanAllRUV Task: we're caught up...\n");
+		slapi_log_error(SLAPI_LOG_INFO, repl_plugin_name, "multimaster_extop_cleanruv - CleanAllRUV Task - We're caught up...\n");
 		/*
 		 *  Set cleaned rid in memory only - does not survive a server restart
 		 */
@@ -1704,8 +1724,8 @@ multimaster_extop_cleanruv(Slapi_PBlock *pb)
 		 *  This read-only replica has no easy way to tell when it's safe to release the rid.
 		 *  So we won't release it, not until a server restart.
 		 */
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "CleanAllRUV Task: You must restart the server if you want to reuse rid(%d).\n", rid);
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "CleanAllRUV Task: Successfully cleaned rid(%d).\n", rid);
+		slapi_log_error(SLAPI_LOG_NOTICE, repl_plugin_name, "multimaster_extop_cleanruv - CleanAllRUV Task - You must restart the server if you want to reuse rid(%d).\n", rid);
+		slapi_log_error(SLAPI_LOG_INFO, repl_plugin_name, "multimaster_extop_cleanruv - CleanAllRUV Task - Successfully cleaned rid(%d).\n", rid);
 		rc = LDAP_SUCCESS;
 	}
 
@@ -1772,7 +1792,7 @@ multimaster_extop_cleanruv_get_maxcsn(Slapi_PBlock *pb)
 	 *  Decode the payload
 	 */
 	if(decode_cleanruv_payload(extop_payload, &payload)){
-		   slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "CleanAllRUV Get MaxCSN Task: failed to decode payload.  Aborting ext op\n");
+		   slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "multimaster_extop_cleanruv_get_maxcsn - CleanAllRUV Task - Get MaxCSN Task: failed to decode payload.  Aborting ext op\n");
 		   goto free_and_return;
 	}
 	rid = atoi(ldap_utf8strtok_r(payload, ":", &iter));
@@ -1841,7 +1861,8 @@ multimaster_extop_cleanruv_check_status(Slapi_PBlock *pb)
 	 *  Decode the payload - which should just be a filter
 	 */
 	if(decode_cleanruv_payload(extop_payload, &filter)){
-		slapi_log_error(SLAPI_LOG_FATAL, LOG_ERR, repl_plugin_name, "CleanAllRUV Check Status Task: failed to decode payload.  Aborting ext op\n");
+		slapi_log_error(SLAPI_LOG_ERR, repl_plugin_name, "multimaster_extop_cleanruv_check_status - "
+			"CleanAllRUV Task - Check Status Task: failed to decode payload.  Aborting ext op\n");
 		goto free_and_return;
 	}