This is an automated email from the git hooks/post-receive script.
firstyear pushed a commit to branch master
in repository 389-ds-base.
commit 407d7d9de7e9c4db1e4c1f5a1a98890f2474c477
Author: William Brown <firstyear(a)redhat.com>
Date: Fri Apr 28 09:15:09 2017 +1000
Ticket 49097 - fix the pblock to be a hierachial structure
Bug Description: The pblock was a giant kitchen sink: 712 bytes,
and analysis showed that normally 80% or more was NULL. We practically
take RAM and set fire to it wastefully.
Fix Description: because the pblock is accessed via get/set, we can
rearrange the internals to a hierachy (tree) of sub-structures that
are dynamically allocated as required. Each sub structure is a
grouping of commonly used fields, which aids cache coherrency,
reduces our memory allocation footprint, and also improves
our performance as we are allocating and freeing less.
https://pagure.io/389-ds-base/issue/49097
Author: wibrown
Review by: mreynolds (Thanks!)
---
ldap/servers/slapd/pblock.c | 864 ++++++++++++++++++++++++++++++-----------
ldap/servers/slapd/pblock_v3.h | 278 +++++++------
ldap/servers/slapd/slap.h | 6 -
ldap/servers/slapd/uuid.c | 2 +-
test/pblock_analyse.py | 76 +++-
5 files changed, 844 insertions(+), 382 deletions(-)
diff --git a/ldap/servers/slapd/pblock.c b/ldap/servers/slapd/pblock.c
index 4f03c90..11f085c 100644
--- a/ldap/servers/slapd/pblock.c
+++ b/ldap/servers/slapd/pblock.c
@@ -23,6 +23,15 @@
#define NUMBER_SLAPI_ATTRS 320
#define ANALYTICS_MAGIC 0x7645
+#define SLAPI_OP_STACK_ELEM 2001
+#define SLAPI_VATTR_CONTEXT 2002
+#define SLAPI_LDIF_DUMP_REPLICA 2003
+#define SLAPI_PWDPOLICY 2004
+#define SLAPI_PW_ENTRY 2005
+
+/* Used for checking assertions about pblocks in some cases. */
+#define SLAPI_HINT 9999
+
static PRLock *pblock_analytics_lock = NULL;
static PLHashNumber
@@ -193,9 +202,20 @@ pblock_done( Slapi_PBlock *pb )
operation_free(&pb->pb_op,pb->pb_conn);
pb->pb_op = NULL;
}
- delete_passwdPolicy(&pb->pwdpolicy);
- slapi_ch_free((void**)&(pb->pb_vattr_context));
- slapi_ch_free((void**)&(pb->pb_result_text));
+ slapi_ch_free((void**)&(pb->pb_dse));
+ slapi_ch_free((void**)&(pb->pb_task));
+ slapi_ch_free((void**)&(pb->pb_mr));
+ slapi_ch_free((void**)&(pb->pb_deprecated));
+ slapi_ch_free((void**)&(pb->pb_misc));
+ if (pb->pb_intop != NULL) {
+ delete_passwdPolicy(&pb->pb_intop->pwdpolicy);
+ slapi_ch_free((void**)&(pb->pb_intop->pb_result_text));
+ }
+ slapi_ch_free((void**)&(pb->pb_intop));
+ if (pb->pb_intplugin != NULL) {
+ slapi_ch_free((void**)&(pb->pb_intplugin->pb_vattr_context));
+ }
+ slapi_ch_free((void**)&(pb->pb_intplugin));
}
void
@@ -208,12 +228,101 @@ slapi_pblock_destroy( Slapi_PBlock* pb )
}
}
+/* functions to alloc internals if needed */
+static inline void __attribute__((always_inline))
+_pblock_assert_pb_dse(Slapi_PBlock *pblock) {
+ if (pblock->pb_dse == NULL) {
+ pblock->pb_dse = slapi_ch_calloc(1, sizeof(slapi_pblock_dse));
+ }
+}
+
+static inline void __attribute__((always_inline))
+_pblock_assert_pb_task(Slapi_PBlock *pblock) {
+ if (pblock->pb_task == NULL) {
+ pblock->pb_task = slapi_ch_calloc(1, sizeof(slapi_pblock_task));
+ }
+}
+
+static inline void __attribute__((always_inline))
+_pblock_assert_pb_mr(Slapi_PBlock *pblock) {
+ if (pblock->pb_mr == NULL) {
+ pblock->pb_mr = slapi_ch_calloc(1, sizeof(slapi_pblock_matching_rule));
+ }
+}
+
+static inline void __attribute__((always_inline))
+_pblock_assert_pb_misc(Slapi_PBlock *pblock) {
+ if (pblock->pb_misc == NULL) {
+ pblock->pb_misc = slapi_ch_calloc(1, sizeof(slapi_pblock_misc));
+ }
+}
+
+static inline void __attribute__((always_inline))
+_pblock_assert_pb_intop(Slapi_PBlock *pblock) {
+ if (pblock->pb_intop == NULL) {
+ pblock->pb_intop = slapi_ch_calloc(1, sizeof(slapi_pblock_intop));
+ }
+}
+
+static inline void __attribute__((always_inline))
+_pblock_assert_pb_intplugin(Slapi_PBlock *pblock) {
+ if (pblock->pb_intplugin == NULL) {
+ pblock->pb_intplugin = slapi_ch_calloc(1, sizeof(slapi_pblock_intplugin));
+ }
+}
+
+static inline void __attribute__((always_inline))
+_pblock_assert_pb_deprecated(Slapi_PBlock *pblock) {
+ if (pblock->pb_deprecated == NULL) {
+ pblock->pb_deprecated = slapi_ch_calloc(1, sizeof(slapi_pblock_deprecated));
+ }
+}
+
Slapi_PBlock *
slapi_pblock_clone(Slapi_PBlock *pb)
{
+ /*
+ * This is used only in psearch, with an access pattern of
+ * ['13:3', '191:28', '47:18', '2001:1',
'115:3', '503:3', '196:10', '52:18', '1930:3',
'133:189', '112:13', '57:1', '214:91', '70:93',
'193:14', '49:10', '403:6', '117:2', '1001:1',
'130:161', '109:2', '198:36', '510:27', '1945:3',
'114:16', '4:11', '216:91', '712:11', '195:19',
'51:26', '140:10', '2005:18', '9:2', '132:334',
'111:1', '1160:1', '410:54', '48:1', '2002:156',
'116:3', '1000:22', '53:27', '9999:1', '113:13',
'3:132', '590:3', '215:91', '194:20', '118:1',
'131:30', '860 [...]
+ */
Slapi_PBlock *new_pb = slapi_pblock_new();
+ new_pb->pb_backend = pb->pb_backend;
+ new_pb->pb_conn = pb->pb_conn;
+ new_pb->pb_op = pb->pb_op;
+ new_pb->pb_plugin = pb->pb_plugin;
/* Perform a shallow copy. */
- *new_pb = *pb;
+ if (pb->pb_dse != NULL) {
+ _pblock_assert_pb_dse(new_pb);
+ *(new_pb->pb_dse) = *(pb->pb_dse);
+ }
+ if (pb->pb_task != NULL) {
+ _pblock_assert_pb_task(new_pb);
+ *(new_pb->pb_task) = *(pb->pb_task);
+ }
+ if (pb->pb_mr != NULL) {
+ _pblock_assert_pb_mr(new_pb);
+ *(new_pb->pb_mr) = *(pb->pb_mr);
+ }
+ if (pb->pb_misc != NULL) {
+ _pblock_assert_pb_misc(new_pb);
+ *(new_pb->pb_misc) = *(pb->pb_misc);
+ }
+ if (pb->pb_intop != NULL) {
+ _pblock_assert_pb_intop(new_pb);
+ *(new_pb->pb_intop) = *(pb->pb_intop);
+ }
+ if (pb->pb_intplugin != NULL) {
+ _pblock_assert_pb_intplugin(new_pb);
+ *(new_pb->pb_intplugin) = *(pb->pb_intplugin);
+ }
+ if (pb->pb_deprecated != NULL) {
+ _pblock_assert_pb_deprecated(new_pb);
+ *(new_pb->pb_deprecated) = *(pb->pb_deprecated);
+ }
+#ifdef PBLOCK_ANALYTICS
+ new_pb->analytics = NULL;
+ pblock_analytics_init(new_pb);
+#endif
return new_pb;
}
@@ -247,11 +356,17 @@ slapi_pblock_get( Slapi_PBlock *pblock, int arg, void *value )
be = pblock->pb_backend;
switch ( arg ) {
+#ifdef PBLOCK_ANALYTICS
+ case SLAPI_HINT:
+ break;
+#endif
case SLAPI_BACKEND:
(*(Slapi_Backend **)value) = be;
break;
case SLAPI_BACKEND_COUNT:
- (*(int *)value) = pblock->pb_backend_count;
+ if (pblock->pb_misc != NULL) {
+ (*(int *)value) = pblock->pb_misc->pb_backend_count;
+ }
break;
case SLAPI_BE_TYPE:
if ( NULL == be ) {
@@ -494,7 +609,9 @@ slapi_pblock_get( Slapi_PBlock *pblock, int arg, void *value )
(*(time_t *)value) = pblock->pb_op->o_time;
break;
case SLAPI_REQUESTOR_ISROOT:
- (*(int *)value) = pblock->pb_requestor_isroot;
+ if (pblock->pb_intop != NULL) {
+ (*(int *)value) = pblock->pb_intop->pb_requestor_isroot;
+ }
break;
case SLAPI_SKIP_MODIFIED_ATTRS:
if(pblock->pb_op==NULL)
@@ -553,7 +670,9 @@ slapi_pblock_get( Slapi_PBlock *pblock, int arg, void *value )
/* pblock memory management */
case SLAPI_DESTROY_CONTENT:
- (*(int *)value) = pblock->pb_destroy_content;
+ if (pblock->pb_deprecated != NULL) {
+ (*(int *)value) = pblock->pb_deprecated->pb_destroy_content;
+ }
break;
/* stuff related to the current plugin */
@@ -579,22 +698,32 @@ slapi_pblock_get( Slapi_PBlock *pblock, int arg, void *value )
(*(int *)value) = pblock->pb_plugin->plg_precedence;
break;
case SLAPI_PLUGIN_OPRETURN:
- (*(int *)value) = pblock->pb_opreturn;
+ if (pblock->pb_intop != NULL) {
+ (*(int *)value) = pblock->pb_intop->pb_opreturn;
+ }
break;
case SLAPI_PLUGIN_OBJECT:
- (*(void **)value) = pblock->pb_object;
+ if (pblock->pb_intplugin != NULL) {
+ (*(void **)value) = pblock->pb_intplugin->pb_object;
+ }
break;
case SLAPI_PLUGIN_DESTROY_FN:
- (*(IFP*)value) = pblock->pb_destroy_fn;
+ if (pblock->pb_intplugin != NULL) {
+ (*(IFP*)value) = pblock->pb_intplugin->pb_destroy_fn;
+ }
break;
case SLAPI_PLUGIN_DESCRIPTION:
(*(Slapi_PluginDesc *)value) = pblock->pb_plugin->plg_desc;
break;
case SLAPI_PLUGIN_IDENTITY:
- (*(void**)value) = pblock->pb_plugin_identity;
+ if (pblock->pb_intplugin != NULL) {
+ (*(void**)value) = pblock->pb_intplugin->pb_plugin_identity;
+ }
break;
case SLAPI_PLUGIN_CONFIG_AREA:
- (*(char **)value) = pblock->pb_plugin_config_area;
+ if (pblock->pb_intplugin != NULL) {
+ (*(char **)value) = pblock->pb_intplugin->pb_plugin_config_area;
+ }
break;
case SLAPI_PLUGIN_CONFIG_DN:
if (pblock->pb_plugin != NULL) {
@@ -602,13 +731,19 @@ slapi_pblock_get( Slapi_PBlock *pblock, int arg, void *value )
}
break;
case SLAPI_PLUGIN_INTOP_RESULT:
- (*(int *)value) = pblock->pb_internal_op_result;
+ if (pblock->pb_intop != NULL) {
+ (*(int *)value) = pblock->pb_intop->pb_internal_op_result;
+ }
break;
case SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES:
- (*(Slapi_Entry ***)value) = pblock->pb_plugin_internal_search_op_entries;
+ if (pblock->pb_intop != NULL) {
+ (*(Slapi_Entry ***)value) =
pblock->pb_intop->pb_plugin_internal_search_op_entries;
+ }
break;
case SLAPI_PLUGIN_INTOP_SEARCH_REFERRALS:
- (*(char ***)value) = pblock->pb_plugin_internal_search_op_referrals;
+ if (pblock->pb_intop != NULL) {
+ (*(char ***)value) =
pblock->pb_intop->pb_plugin_internal_search_op_referrals;
+ }
break;
/* database plugin functions */
@@ -1048,10 +1183,14 @@ slapi_pblock_get( Slapi_PBlock *pblock, int arg, void *value )
(*(IFP *)value) = pblock->pb_plugin->plg_postextop;
break;
case SLAPI_ENTRY_PRE_OP:
- (*(Slapi_Entry **)value) = pblock->pb_pre_op_entry;
+ if (pblock->pb_intop != NULL) {
+ (*(Slapi_Entry **)value) = pblock->pb_intop->pb_pre_op_entry;
+ }
break;
case SLAPI_ENTRY_POST_OP:
- (*(Slapi_Entry **)value) = pblock->pb_post_op_entry;
+ if (pblock->pb_intop != NULL) {
+ (*(Slapi_Entry **)value) = pblock->pb_intop->pb_post_op_entry;
+ }
break;
/* backend preoperation plugin */
@@ -1307,11 +1446,15 @@ slapi_pblock_get( Slapi_PBlock *pblock, int arg, void *value )
}
break;
case SLAPI_CONTROLS_ARG: /* used to pass control argument before operation is created
*/
- (*(LDAPControl ***)value) = pblock->pb_ctrls_arg;
+ if (pblock->pb_intop != NULL) {
+ (*(LDAPControl ***)value) = pblock->pb_intop->pb_ctrls_arg;
+ }
break;
/* notes to be added to the access log RESULT line for this op. */
case SLAPI_OPERATION_NOTES:
- (*(unsigned int *)value) = pblock->pb_operation_notes;
+ if (pblock->pb_intop != NULL) {
+ (*(unsigned int *)value) = pblock->pb_intop->pb_operation_notes;
+ }
break;
/* syntax plugin functions */
@@ -1370,7 +1513,9 @@ slapi_pblock_get( Slapi_PBlock *pblock, int arg, void *value )
(*(IFP *)value) = pblock->pb_plugin->plg_syntax_compare;
break;
case SLAPI_SYNTAX_SUBSTRLENS: /* aka SLAPI_MR_SUBSTRLENS */
- (*(int **)value) = pblock->pb_substrlens;
+ if (pblock->pb_intplugin != NULL) {
+ (*(int **)value) = pblock->pb_intplugin->pb_substrlens;
+ }
break;
case SLAPI_PLUGIN_SYNTAX_VALIDATE:
if ( pblock->pb_plugin->plg_type != SLAPI_PLUGIN_SYNTAX ) {
@@ -1387,10 +1532,14 @@ slapi_pblock_get( Slapi_PBlock *pblock, int arg, void *value )
/* controls we know about */
case SLAPI_MANAGEDSAIT:
- (*(int *)value) = pblock->pb_managedsait;
+ if (pblock->pb_intop != NULL) {
+ (*(int *)value) = pblock->pb_intop->pb_managedsait;
+ }
break;
case SLAPI_PWPOLICY:
- (*(int *)value) = pblock->pb_pwpolicy_ctrl;
+ if (pblock->pb_intop != NULL) {
+ (*(int *)value) = pblock->pb_intop->pb_pwpolicy_ctrl;
+ }
break;
/* add arguments */
@@ -1401,13 +1550,19 @@ slapi_pblock_get( Slapi_PBlock *pblock, int arg, void *value )
}
break;
case SLAPI_ADD_EXISTING_DN_ENTRY:
- (*(Slapi_Entry **)value) = pblock->pb_existing_dn_entry;
+ if (pblock->pb_intop != NULL) {
+ (*(Slapi_Entry **)value) = pblock->pb_intop->pb_existing_dn_entry;
+ }
break;
case SLAPI_ADD_EXISTING_UNIQUEID_ENTRY:
- (*(Slapi_Entry **)value) = pblock->pb_existing_uniqueid_entry;
+ if (pblock->pb_intop != NULL) {
+ (*(Slapi_Entry **)value) = pblock->pb_intop->pb_existing_uniqueid_entry;
+ }
break;
case SLAPI_ADD_PARENT_ENTRY:
- (*(Slapi_Entry **)value) = pblock->pb_parent_entry;
+ if (pblock->pb_intop != NULL) {
+ (*(Slapi_Entry **)value) = pblock->pb_intop->pb_parent_entry;
+ }
break;
case SLAPI_ADD_PARENT_UNIQUEID:
if(pblock->pb_op!=NULL)
@@ -1518,13 +1673,19 @@ slapi_pblock_get( Slapi_PBlock *pblock, int arg, void *value )
}
break;
case SLAPI_MODRDN_PARENT_ENTRY:
- (*(Slapi_Entry **)value) = pblock->pb_parent_entry;
+ if (pblock->pb_intop != NULL) {
+ (*(Slapi_Entry **)value) = pblock->pb_intop->pb_parent_entry;
+ }
break;
case SLAPI_MODRDN_NEWPARENT_ENTRY:
- (*(Slapi_Entry **)value) = pblock->pb_newparent_entry;
+ if (pblock->pb_intop != NULL) {
+ (*(Slapi_Entry **)value) = pblock->pb_intop->pb_newparent_entry;
+ }
break;
case SLAPI_MODRDN_TARGET_ENTRY:
- (*(Slapi_Entry **)value) = pblock->pb_target_entry;
+ if (pblock->pb_intop != NULL) {
+ (*(Slapi_Entry **)value) = pblock->pb_intop->pb_target_entry;
+ }
break;
case SLAPI_MODRDN_NEWSUPERIOR_ADDRESS:
if(pblock->pb_op!=NULL)
@@ -1645,45 +1806,71 @@ slapi_pblock_get( Slapi_PBlock *pblock, int arg, void *value )
(*(IFP *)value) = pblock->pb_plugin->plg_mr_indexer_create;
break;
case SLAPI_PLUGIN_MR_FILTER_MATCH_FN:
- (*(mrFilterMatchFn *)value) = pblock->pb_mr_filter_match_fn;
+ if (pblock->pb_mr != NULL) {
+ (*(mrFilterMatchFn *)value) = pblock->pb_mr->filter_match_fn;
+ }
break;
case SLAPI_PLUGIN_MR_FILTER_INDEX_FN:
- (*(IFP *)value) = pblock->pb_mr_filter_index_fn;
+ if (pblock->pb_mr != NULL) {
+ (*(IFP *)value) = pblock->pb_mr->filter_index_fn;
+ }
break;
case SLAPI_PLUGIN_MR_FILTER_RESET_FN:
- (*(IFP *)value) = pblock->pb_mr_filter_reset_fn;
+ if (pblock->pb_mr != NULL) {
+ (*(IFP *)value) = pblock->pb_mr->filter_reset_fn;
+ }
break;
case SLAPI_PLUGIN_MR_INDEX_FN:
- (*(IFP *)value) = pblock->pb_mr_index_fn;
+ if (pblock->pb_mr != NULL) {
+ (*(IFP *)value) = pblock->pb_mr->index_fn;
+ }
break;
case SLAPI_PLUGIN_MR_INDEX_SV_FN:
- (*(IFP *)value) = pblock->pb_mr_index_sv_fn;
+ if (pblock->pb_mr != NULL) {
+ (*(IFP *)value) = pblock->pb_mr->index_sv_fn;
+ }
break;
/* matching rule plugin arguments */
case SLAPI_PLUGIN_MR_OID:
- (*(char **) value) = pblock->pb_mr_oid;
+ if (pblock->pb_mr != NULL) {
+ (*(char **) value) = pblock->pb_mr->oid;
+ }
break;
case SLAPI_PLUGIN_MR_TYPE:
- (*(char **) value) = pblock->pb_mr_type;
+ if (pblock->pb_mr != NULL) {
+ (*(char **) value) = pblock->pb_mr->type;
+ }
break;
case SLAPI_PLUGIN_MR_VALUE:
- (*(struct berval **) value) = pblock->pb_mr_value;
+ if (pblock->pb_mr != NULL) {
+ (*(struct berval **) value) = pblock->pb_mr->value;
+ }
break;
case SLAPI_PLUGIN_MR_VALUES:
- (*(struct berval ***) value) = pblock->pb_mr_values;
+ if (pblock->pb_mr != NULL) {
+ (*(struct berval ***) value) = pblock->pb_mr->values;
+ }
break;
case SLAPI_PLUGIN_MR_KEYS:
- (*(struct berval ***) value) = pblock->pb_mr_keys;
+ if (pblock->pb_mr != NULL) {
+ (*(struct berval ***) value) = pblock->pb_mr->keys;
+ }
break;
case SLAPI_PLUGIN_MR_FILTER_REUSABLE:
- (*(unsigned int *) value) = pblock->pb_mr_filter_reusable;
+ if (pblock->pb_mr != NULL) {
+ (*(unsigned int *) value) = pblock->pb_mr->filter_reusable;
+ }
break;
case SLAPI_PLUGIN_MR_QUERY_OPERATOR:
- (*(int *) value) = pblock->pb_mr_query_operator;
+ if (pblock->pb_mr != NULL) {
+ (*(int *) value) = pblock->pb_mr->query_operator;
+ }
break;
case SLAPI_PLUGIN_MR_USAGE:
- (*(unsigned int *) value) = pblock->pb_mr_usage;
+ if (pblock->pb_mr != NULL) {
+ (*(unsigned int *) value) = pblock->pb_mr->usage;
+ }
break;
/* new style matching rule syntax plugin functions */
@@ -1744,90 +1931,140 @@ slapi_pblock_get( Slapi_PBlock *pblock, int arg, void *value )
/* seq arguments */
case SLAPI_SEQ_TYPE:
- (*(int *)value) = pblock->pb_seq_type;
+ if (pblock->pb_task != NULL) {
+ (*(int *)value) = pblock->pb_task->seq_type;
+ }
break;
case SLAPI_SEQ_ATTRNAME:
- (*(char **)value) = pblock->pb_seq_attrname;
+ if (pblock->pb_task != NULL) {
+ (*(char **)value) = pblock->pb_task->seq_attrname;
+ }
break;
case SLAPI_SEQ_VAL:
- (*(char **)value) = pblock->pb_seq_val;
+ if (pblock->pb_task != NULL) {
+ (*(char **)value) = pblock->pb_task->seq_val;
+ }
break;
/* ldif2db arguments */
case SLAPI_LDIF2DB_FILE:
- (*(char ***)value) = pblock->pb_ldif_files;
+ if (pblock->pb_task != NULL) {
+ (*(char ***)value) = pblock->pb_task->ldif_files;
+ }
break;
case SLAPI_LDIF2DB_REMOVEDUPVALS:
- (*(int *)value) = pblock->pb_removedupvals;
+ if (pblock->pb_task != NULL) {
+ (*(int *)value) = pblock->pb_task->removedupvals;
+ }
break;
case SLAPI_DB2INDEX_ATTRS:
- (*(char ***)value) = pblock->pb_db2index_attrs;
+ if (pblock->pb_task != NULL) {
+ (*(char ***)value) = pblock->pb_task->db2index_attrs;
+ }
break;
case SLAPI_LDIF2DB_NOATTRINDEXES:
- (*(int *)value) = pblock->pb_ldif2db_noattrindexes;
+ if (pblock->pb_task != NULL) {
+ (*(int *)value) = pblock->pb_task->ldif2db_noattrindexes;
+ }
break;
case SLAPI_LDIF2DB_INCLUDE:
- (*(char ***)value) = pblock->pb_ldif_include;
+ if (pblock->pb_task != NULL) {
+ (*(char ***)value) = pblock->pb_task->ldif_include;
+ }
break;
case SLAPI_LDIF2DB_EXCLUDE:
- (*(char ***)value) = pblock->pb_ldif_exclude;
+ if (pblock->pb_task != NULL) {
+ (*(char ***)value) = pblock->pb_task->ldif_exclude;
+ }
break;
case SLAPI_LDIF2DB_GENERATE_UNIQUEID:
- (*(int *)value) = pblock->pb_ldif_generate_uniqueid;
+ if (pblock->pb_task != NULL) {
+ (*(int *)value) = pblock->pb_task->ldif_generate_uniqueid;
+ }
break;
case SLAPI_LDIF2DB_ENCRYPT:
case SLAPI_DB2LDIF_DECRYPT:
- (*(int *)value) = pblock->pb_ldif_encrypt;
+ if (pblock->pb_task != NULL) {
+ (*(int *)value) = pblock->pb_task->ldif_encrypt;
+ }
break;
case SLAPI_LDIF2DB_NAMESPACEID:
- (*(char **)value) = pblock->pb_ldif_namespaceid;
+ if (pblock->pb_task != NULL) {
+ (*(char **)value) = pblock->pb_task->ldif_namespaceid;
+ }
break;
/* db2ldif arguments */
case SLAPI_DB2LDIF_PRINTKEY:
- (*(int *)value) = pblock->pb_ldif_printkey;
+ if (pblock->pb_task != NULL) {
+ (*(int *)value) = pblock->pb_task->ldif_printkey;
+ }
break;
case SLAPI_DB2LDIF_DUMP_UNIQUEID:
- (*(int *)value) = pblock->pb_ldif_dump_uniqueid;
+ if (pblock->pb_task != NULL) {
+ (*(int *)value) = pblock->pb_task->ldif_dump_uniqueid;
+ }
break;
case SLAPI_DB2LDIF_FILE:
- (*(char **)value) = pblock->pb_ldif_file;
+ if (pblock->pb_task != NULL) {
+ (*(char **)value) = pblock->pb_task->ldif_file;
+ }
break;
/* db2ldif/ldif2db/db2bak/bak2db arguments */
case SLAPI_BACKEND_INSTANCE_NAME:
- (*(char **)value) = pblock->pb_instance_name;
+ if (pblock->pb_task != NULL) {
+ (*(char **)value) = pblock->pb_task->instance_name;
+ }
break;
- case SLAPI_BACKEND_TASK:
- (*(Slapi_Task **)value) = pblock->pb_task;
- break;
+ case SLAPI_BACKEND_TASK:
+ if (pblock->pb_task != NULL) {
+ (*(Slapi_Task **)value) = pblock->pb_task->task;
+ }
+ break;
case SLAPI_TASK_FLAGS:
- (*(int *)value) = pblock->pb_task_flags;
+ if (pblock->pb_task != NULL) {
+ (*(int *)value) = pblock->pb_task->task_flags;
+ }
break;
case SLAPI_DB2LDIF_SERVER_RUNNING:
- (*(int *)value) = pblock->pb_server_running;
+ if (pblock->pb_task != NULL) {
+ (*(int *)value) = pblock->pb_task->server_running;
+ }
break;
- case SLAPI_BULK_IMPORT_ENTRY:
- (*(Slapi_Entry **)value) = pblock->pb_import_entry;
- break;
- case SLAPI_BULK_IMPORT_STATE:
- (*(int *)value) = pblock->pb_import_state;
- break;
+ case SLAPI_BULK_IMPORT_ENTRY:
+ if (pblock->pb_task != NULL) {
+ (*(Slapi_Entry **)value) = pblock->pb_task->import_entry;
+ }
+ break;
+ case SLAPI_BULK_IMPORT_STATE:
+ if (pblock->pb_task != NULL) {
+ (*(int *)value) = pblock->pb_task->import_state;
+ }
+ break;
+ /* dbverify */
+ case SLAPI_DBVERIFY_DBDIR:
+ if (pblock->pb_task != NULL) {
+ (*(char **)value) = pblock->pb_task->dbverify_dbdir;
+ }
+ break;
+
/* transaction arguments */
case SLAPI_PARENT_TXN:
- (*(void **)value) = pblock->pb_parent_txn;
+ if (pblock->pb_intop != NULL) {
+ (*(void **)value) = pblock->pb_intop->pb_parent_txn;
+ }
break;
case SLAPI_TXN:
- (*(void **)value) = pblock->pb_txn;
+ if (pblock->pb_intop != NULL) {
+ (*(void **)value) = pblock->pb_intop->pb_txn;
+ }
break;
case SLAPI_TXN_RUV_MODS_FN:
- (*(IFP*)value) = pblock->pb_txn_ruv_mods_fn;
- break;
-
- /* dbverify */
- case SLAPI_DBVERIFY_DBDIR:
- (*(char **)value) = pblock->pb_dbverify_dbdir;
+ if (pblock->pb_intop != NULL) {
+ (*(IFP*)value) = pblock->pb_intop->pb_txn_ruv_mods_fn;
+ }
break;
/* Search results set */
@@ -1885,12 +2122,16 @@ slapi_pblock_get( Slapi_PBlock *pblock, int arg, void *value )
* ((char **) value) = pblock->pb_op->o_results.result_text;
break;
case SLAPI_PB_RESULT_TEXT:
- * ((char **) value) = pblock->pb_result_text;
+ if (pblock->pb_intop != NULL) {
+ * ((char **) value) = pblock->pb_intop->pb_result_text;
+ }
break;
/* Size of the database, in kb */
case SLAPI_DBSIZE:
- (*(unsigned int *)value) = pblock->pb_dbsize;
+ if (pblock->pb_misc != NULL) {
+ (*(unsigned int *)value) = pblock->pb_misc->pb_dbsize;
+ }
break;
/* ACL Plugin */
@@ -1977,15 +2218,21 @@ slapi_pblock_get( Slapi_PBlock *pblock, int arg, void *value )
break;
/* Command line arguments */
case SLAPI_ARGC:
- (*(int *)value) = pblock->pb_slapd_argc;
+ if (pblock->pb_misc != NULL) {
+ (*(int *)value) = pblock->pb_misc->pb_slapd_argc;
+ }
break;
case SLAPI_ARGV:
- (*(char ***)value) = pblock->pb_slapd_argv;
+ if (pblock->pb_misc != NULL) {
+ (*(char ***)value) = pblock->pb_misc->pb_slapd_argv;
+ }
break;
/* Config file directory */
case SLAPI_CONFIG_DIRECTORY:
- (*(char **)value) = pblock->pb_slapd_configdir;
+ if (pblock->pb_intplugin != NULL) {
+ (*(char **)value) = pblock->pb_intplugin->pb_slapd_configdir;
+ }
break;
/* password storage scheme (kexcoff */
@@ -1993,11 +2240,15 @@ slapi_pblock_get( Slapi_PBlock *pblock, int arg, void *value )
(*(char **)value) = pblock->pb_plugin->plg_pwdstorageschemename;
break;
case SLAPI_PLUGIN_PWD_STORAGE_SCHEME_USER_PWD:
- (*(char **)value) = pblock->pb_pwd_storage_scheme_user_passwd;
+ if (pblock->pb_deprecated != NULL) {
+ (*(char **)value) =
pblock->pb_deprecated->pb_pwd_storage_scheme_user_passwd;
+ }
break;
case SLAPI_PLUGIN_PWD_STORAGE_SCHEME_DB_PWD:
- (*(char **)value) = pblock->pb_pwd_storage_scheme_db_passwd;
+ if (pblock->pb_deprecated != NULL) {
+ (*(char **)value) = pblock->pb_deprecated->pb_pwd_storage_scheme_db_passwd;
+ }
break;
case SLAPI_PLUGIN_PWD_STORAGE_SCHEME_ENC_FN:
@@ -2022,72 +2273,96 @@ slapi_pblock_get( Slapi_PBlock *pblock, int arg, void *value )
break;
case SLAPI_PLUGIN_ENABLED:
- *((int *)value) = pblock->pb_plugin_enabled;
+ if (pblock->pb_intplugin != NULL) {
+ *((int *)value) = pblock->pb_intplugin->pb_plugin_enabled;
+ }
break;
/* DSE add parameters */
case SLAPI_DSE_DONT_WRITE_WHEN_ADDING:
- (*(int *)value) = pblock->pb_dse_dont_add_write;
- break;
+ if (pblock->pb_dse != NULL) {
+ (*(int *)value) = pblock->pb_dse->dont_add_write;
+ }
+ break;
/* DSE add parameters */
case SLAPI_DSE_MERGE_WHEN_ADDING:
- (*(int *)value) = pblock->pb_dse_add_merge;
+ if (pblock->pb_dse != NULL) {
+ (*(int *)value) = pblock->pb_dse->add_merge;
+ }
break;
/* DSE add parameters */
case SLAPI_DSE_DONT_CHECK_DUPS:
- (*(int *)value) = pblock->pb_dse_dont_check_dups;
+ if (pblock->pb_dse != NULL) {
+ (*(int *)value) = pblock->pb_dse->dont_check_dups;
+ }
break;
/* DSE modify parameters */
case SLAPI_DSE_REAPPLY_MODS:
- (*(int *)value) = pblock->pb_dse_reapply_mods;
+ if (pblock->pb_dse != NULL) {
+ (*(int *)value) = pblock->pb_dse->reapply_mods;
+ }
break;
/* DSE read parameters */
case SLAPI_DSE_IS_PRIMARY_FILE:
- (*(int *)value) = pblock->pb_dse_is_primary_file;
+ if (pblock->pb_dse != NULL) {
+ (*(int *)value) = pblock->pb_dse->is_primary_file;
+ }
break;
/* used internally by schema code (schema.c) */
case SLAPI_SCHEMA_FLAGS:
- (*(int *)value) = pblock->pb_schema_flags;
+ if (pblock->pb_dse != NULL) {
+ (*(int *)value) = pblock->pb_dse->schema_flags;
+ }
break;
case SLAPI_URP_NAMING_COLLISION_DN:
- (*(char **)value) = pblock->pb_urp_naming_collision_dn;
+ if (pblock->pb_intop != NULL) {
+ (*(char **)value) = pblock->pb_intop->pb_urp_naming_collision_dn;
+ }
break;
case SLAPI_URP_TOMBSTONE_UNIQUEID:
- (*(char **)value) = pblock->pb_urp_tombstone_uniqueid;
+ if (pblock->pb_intop != NULL) {
+ (*(char **)value) = pblock->pb_intop->pb_urp_tombstone_uniqueid;
+ }
break;
case SLAPI_SEARCH_CTRLS:
- (*(LDAPControl ***)value) = pblock->pb_search_ctrls;
+ if (pblock->pb_intop != NULL) {
+ (*(LDAPControl ***)value) = pblock->pb_intop->pb_search_ctrls;
+ }
break;
case SLAPI_PLUGIN_SYNTAX_FILTER_NORMALIZED:
- (*(int *)value) = pblock->pb_syntax_filter_normalized;
+ if (pblock->pb_intplugin != NULL) {
+ (*(int *)value) = pblock->pb_intplugin->pb_syntax_filter_normalized;
+ }
break;
case SLAPI_PLUGIN_SYNTAX_FILTER_DATA:
- (*(void **)value) = pblock->pb_syntax_filter_data;
+ if (pblock->pb_intplugin != NULL) {
+ (*(void **)value) = pblock->pb_intplugin->pb_syntax_filter_data;
+ }
break;
case SLAPI_PAGED_RESULTS_INDEX:
- if (op_is_pagedresults(pblock->pb_op)) {
+ if (op_is_pagedresults(pblock->pb_op) && pblock->pb_intop != NULL) {
/* search req is simple paged results */
- (*(int *)value) = pblock->pb_paged_results_index;
+ (*(int *)value) = pblock->pb_intop->pb_paged_results_index;
} else {
(*(int *)value) = -1;
}
break;
case SLAPI_PAGED_RESULTS_COOKIE:
- if (op_is_pagedresults(pblock->pb_op)) {
+ if (op_is_pagedresults(pblock->pb_op) && pblock->pb_intop != NULL) {
/* search req is simple paged results */
- (*(int *)value) = pblock->pb_paged_results_cookie;
+ (*(int *)value) = pblock->pb_intop->pb_paged_results_cookie;
} else {
(*(int *)value) = 0;
}
@@ -2095,29 +2370,20 @@ slapi_pblock_get( Slapi_PBlock *pblock, int arg, void *value )
/* ACI Target Check */
case SLAPI_ACI_TARGET_CHECK:
- (*(int *)value) = pblock->pb_aci_target_check;
+ if (pblock->pb_misc != NULL) {
+ (*(int *)value) = pblock->pb_misc->pb_aci_target_check;
+ }
break;
default:
slapi_log_err(SLAPI_LOG_ERR, "slapi_pblock_get", "Unknown parameter
block argument %d\n", arg);
-#ifdef PBLOCK_ANALYTICS
- Slapi_PBlock *boom = NULL;
- void *x = (void *)boom->pb_plugin;
-#endif
+ PR_ASSERT(0);
return( -1 );
}
return( 0 );
}
-/*
- * This ifdef is needed to resolve a gcc 6 issue which throws a false positive
- * here. See also:
https://bugzilla.redhat.com/show_bug.cgi?id=1386445
- *
- * It's a good idea to run this in EL7 to check the overflows etc, but with
- * GCC 6 and lsan to find memory leaks ....
- */
-
int
slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value )
{
@@ -2129,6 +2395,10 @@ slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value )
PR_ASSERT( NULL != pblock );
switch ( arg ) {
+#ifdef PBLOCK_ANALYTICS
+ case SLAPI_HINT:
+ break;
+#endif
case SLAPI_BACKEND:
pblock->pb_backend = (Slapi_Backend *) value;
if (pblock->pb_backend && (NULL == pblock->pb_plugin)) {
@@ -2138,7 +2408,8 @@ slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value )
}
break;
case SLAPI_BACKEND_COUNT:
- pblock->pb_backend_count = *((int *) value);
+ _pblock_assert_pb_misc(pblock);
+ pblock->pb_misc->pb_backend_count = *((int *) value);
break;
case SLAPI_CONNECTION:
pblock->pb_conn = (Connection *) value;
@@ -2152,7 +2423,8 @@ slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value )
}
break;
case SLAPI_REQUESTOR_ISROOT:
- pblock->pb_requestor_isroot = *((int *) value);
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_requestor_isroot = *((int *) value);
break;
case SLAPI_IS_REPLICATED_OPERATION:
PR_ASSERT(0);
@@ -2218,7 +2490,8 @@ slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value )
/* pblock memory management */
case SLAPI_DESTROY_CONTENT:
- pblock->pb_destroy_content = *((int *) value);
+ _pblock_assert_pb_deprecated(pblock);
+ pblock->pb_deprecated->pb_destroy_content = *((int *) value);
break;
/* stuff related to the current plugin */
@@ -2244,31 +2517,39 @@ slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value )
pblock->pb_plugin->plg_precedence = *((int *) value);
break;
case SLAPI_PLUGIN_OPRETURN:
- pblock->pb_opreturn = *((int *) value);
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_opreturn = *((int *) value);
break;
case SLAPI_PLUGIN_OBJECT:
- pblock->pb_object = (void *) value;
+ _pblock_assert_pb_intplugin(pblock);
+ pblock->pb_intplugin->pb_object = (void *) value;
break;
case SLAPI_PLUGIN_IDENTITY:
- pblock->pb_plugin_identity = (void*)value;
+ _pblock_assert_pb_intplugin(pblock);
+ pblock->pb_intplugin->pb_plugin_identity = (void*)value;
break;
case SLAPI_PLUGIN_CONFIG_AREA:
- pblock->pb_plugin_config_area = (char *) value;
+ _pblock_assert_pb_intplugin(pblock);
+ pblock->pb_intplugin->pb_plugin_config_area = (char *) value;
break;
case SLAPI_PLUGIN_DESTROY_FN:
- pblock->pb_destroy_fn = (IFP) value;
+ _pblock_assert_pb_intplugin(pblock);
+ pblock->pb_intplugin->pb_destroy_fn = (IFP) value;
break;
case SLAPI_PLUGIN_DESCRIPTION:
pblock->pb_plugin->plg_desc = *((Slapi_PluginDesc *)value);
break;
case SLAPI_PLUGIN_INTOP_RESULT:
- pblock->pb_internal_op_result = *((int *) value);
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_internal_op_result = *((int *) value);
break;
case SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES:
- pblock->pb_plugin_internal_search_op_entries = (Slapi_Entry **) value;
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_plugin_internal_search_op_entries = (Slapi_Entry **) value;
break;
case SLAPI_PLUGIN_INTOP_SEARCH_REFERRALS:
- pblock->pb_plugin_internal_search_op_referrals = (char **) value;
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_plugin_internal_search_op_referrals = (char **) value;
break;
case SLAPI_REQUESTOR_DN:
if(pblock->pb_op == NULL){
@@ -2969,7 +3250,8 @@ slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value )
pblock->pb_plugin->plg_syntax_compare = (IFP) value;
break;
case SLAPI_SYNTAX_SUBSTRLENS: /* aka SLAPI_MR_SUBSTRLENS */
- pblock->pb_substrlens = (int *) value;
+ _pblock_assert_pb_intplugin(pblock);
+ pblock->pb_intplugin->pb_substrlens = (int *) value;
break;
case SLAPI_PLUGIN_SYNTAX_VALIDATE:
if ( pblock->pb_plugin->plg_type != SLAPI_PLUGIN_SYNTAX ) {
@@ -2984,10 +3266,12 @@ slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value )
pblock->pb_plugin->plg_syntax_normalize = (VFPV) value;
break;
case SLAPI_ENTRY_PRE_OP:
- pblock->pb_pre_op_entry = (Slapi_Entry *) value;
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_pre_op_entry = (Slapi_Entry *) value;
break;
case SLAPI_ENTRY_POST_OP:
- pblock->pb_post_op_entry = (Slapi_Entry *) value;
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_post_op_entry = (Slapi_Entry *) value;
break;
/* target address for all operations */
@@ -3045,7 +3329,8 @@ slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value )
}
break;
case SLAPI_CONTROLS_ARG: /* used to pass control argument before operation is created
*/
- pblock->pb_ctrls_arg = (LDAPControl **) value;
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_ctrls_arg = (LDAPControl **) value;
break;
case SLAPI_ADD_RESCONTROL:
if(pblock->pb_op!=NULL)
@@ -3056,10 +3341,11 @@ slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value )
/* notes to be added to the access log RESULT line for this op. */
case SLAPI_OPERATION_NOTES:
+ _pblock_assert_pb_intop(pblock);
if ( value == NULL ) {
- pblock->pb_operation_notes = 0; /* cleared */
+ pblock->pb_intop->pb_operation_notes = 0; /* cleared */
} else {
- pblock->pb_operation_notes |= *((unsigned int *)value );
+ pblock->pb_intop->pb_operation_notes |= *((unsigned int *)value );
}
break;
case SLAPI_SKIP_MODIFIED_ATTRS:
@@ -3073,10 +3359,12 @@ slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value )
break;
/* controls we know about */
case SLAPI_MANAGEDSAIT:
- pblock->pb_managedsait = *((int *) value);
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_managedsait = *((int *) value);
break;
case SLAPI_PWPOLICY:
- pblock->pb_pwpolicy_ctrl = *((int *) value);
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_pwpolicy_ctrl = *((int *) value);
break;
/* add arguments */
@@ -3087,13 +3375,16 @@ slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value )
}
break;
case SLAPI_ADD_EXISTING_DN_ENTRY:
- pblock->pb_existing_dn_entry = (Slapi_Entry *) value;
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_existing_dn_entry = (Slapi_Entry *) value;
break;
case SLAPI_ADD_EXISTING_UNIQUEID_ENTRY:
- pblock->pb_existing_uniqueid_entry = (Slapi_Entry *) value;
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_existing_uniqueid_entry = (Slapi_Entry *) value;
break;
case SLAPI_ADD_PARENT_ENTRY:
- pblock->pb_parent_entry = (Slapi_Entry *) value;
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_parent_entry = (Slapi_Entry *) value;
break;
case SLAPI_ADD_PARENT_UNIQUEID:
if(pblock->pb_op!=NULL)
@@ -3202,13 +3493,16 @@ slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value )
}
break;
case SLAPI_MODRDN_PARENT_ENTRY:
- pblock->pb_parent_entry = (Slapi_Entry *) value;
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_parent_entry = (Slapi_Entry *) value;
break;
case SLAPI_MODRDN_NEWPARENT_ENTRY:
- pblock->pb_newparent_entry = (Slapi_Entry *) value;
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_newparent_entry = (Slapi_Entry *) value;
break;
case SLAPI_MODRDN_TARGET_ENTRY:
- pblock->pb_target_entry = (Slapi_Entry *) value;
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_target_entry = (Slapi_Entry *) value;
break;
case SLAPI_MODRDN_NEWSUPERIOR_ADDRESS:
PR_ASSERT (PR_FALSE); /* can't do this */
@@ -3344,45 +3638,58 @@ slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value )
pblock->pb_plugin->plg_mr_indexer_create = (IFP) value;
break;
case SLAPI_PLUGIN_MR_FILTER_MATCH_FN:
- pblock->pb_mr_filter_match_fn = (mrFilterMatchFn) value;
+ _pblock_assert_pb_mr(pblock);
+ pblock->pb_mr->filter_match_fn = (mrFilterMatchFn) value;
break;
case SLAPI_PLUGIN_MR_FILTER_INDEX_FN:
- pblock->pb_mr_filter_index_fn = (IFP) value;
+ _pblock_assert_pb_mr(pblock);
+ pblock->pb_mr->filter_index_fn = (IFP) value;
break;
case SLAPI_PLUGIN_MR_FILTER_RESET_FN:
- pblock->pb_mr_filter_reset_fn = (IFP) value;
+ _pblock_assert_pb_mr(pblock);
+ pblock->pb_mr->filter_reset_fn = (IFP) value;
break;
case SLAPI_PLUGIN_MR_INDEX_FN:
- pblock->pb_mr_index_fn = (IFP) value;
+ _pblock_assert_pb_mr(pblock);
+ pblock->pb_mr->index_fn = (IFP) value;
break;
case SLAPI_PLUGIN_MR_INDEX_SV_FN:
- pblock->pb_mr_index_sv_fn = (IFP) value;
+ _pblock_assert_pb_mr(pblock);
+ pblock->pb_mr->index_sv_fn = (IFP) value;
break;
/* matching rule plugin arguments */
case SLAPI_PLUGIN_MR_OID:
- pblock->pb_mr_oid = (char *) value;
+ _pblock_assert_pb_mr(pblock);
+ pblock->pb_mr->oid = (char *) value;
break;
case SLAPI_PLUGIN_MR_TYPE:
- pblock->pb_mr_type = (char *) value;
+ _pblock_assert_pb_mr(pblock);
+ pblock->pb_mr->type = (char *) value;
break;
case SLAPI_PLUGIN_MR_VALUE:
- pblock->pb_mr_value = (struct berval *) value;
+ _pblock_assert_pb_mr(pblock);
+ pblock->pb_mr->value = (struct berval *) value;
break;
case SLAPI_PLUGIN_MR_VALUES:
- pblock->pb_mr_values = (struct berval **) value;
+ _pblock_assert_pb_mr(pblock);
+ pblock->pb_mr->values = (struct berval **) value;
break;
case SLAPI_PLUGIN_MR_KEYS:
- pblock->pb_mr_keys = (struct berval **) value;
+ _pblock_assert_pb_mr(pblock);
+ pblock->pb_mr->keys = (struct berval **) value;
break;
case SLAPI_PLUGIN_MR_FILTER_REUSABLE:
- pblock->pb_mr_filter_reusable = *(unsigned int *) value;
+ _pblock_assert_pb_mr(pblock);
+ pblock->pb_mr->filter_reusable = *(unsigned int *) value;
break;
case SLAPI_PLUGIN_MR_QUERY_OPERATOR:
- pblock->pb_mr_query_operator = *(int *) value;
+ _pblock_assert_pb_mr(pblock);
+ pblock->pb_mr->query_operator = *(int *) value;
break;
case SLAPI_PLUGIN_MR_USAGE:
- pblock->pb_mr_usage = *(unsigned int *) value;
+ _pblock_assert_pb_mr(pblock);
+ pblock->pb_mr->usage = *(unsigned int *) value;
break;
/* new style matching rule syntax plugin functions */
@@ -3443,81 +3750,116 @@ slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value )
/* seq arguments */
case SLAPI_SEQ_TYPE:
- pblock->pb_seq_type = *((int *)value);
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->seq_type = *((int *)value);
break;
case SLAPI_SEQ_ATTRNAME:
- pblock->pb_seq_attrname = (char *) value;
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->seq_attrname = (char *) value;
break;
case SLAPI_SEQ_VAL:
- pblock->pb_seq_val = (char *) value;
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->seq_val = (char *) value;
break;
/* ldif2db arguments */
case SLAPI_LDIF2DB_FILE:
- pblock->pb_ldif_files = (char **) value;
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->ldif_files = (char **) value;
break;
case SLAPI_LDIF2DB_REMOVEDUPVALS:
- pblock->pb_removedupvals = *((int *)value);
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->removedupvals = *((int *)value);
break;
case SLAPI_DB2INDEX_ATTRS:
- pblock->pb_db2index_attrs = (char **) value;
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->db2index_attrs = (char **) value;
break;
case SLAPI_LDIF2DB_NOATTRINDEXES:
- pblock->pb_ldif2db_noattrindexes = *((int *)value);
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->ldif2db_noattrindexes = *((int *)value);
break;
case SLAPI_LDIF2DB_INCLUDE:
- pblock->pb_ldif_include = (char **)value;
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->ldif_include = (char **)value;
break;
case SLAPI_LDIF2DB_EXCLUDE:
- pblock->pb_ldif_exclude = (char **)value;
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->ldif_exclude = (char **)value;
break;
case SLAPI_LDIF2DB_GENERATE_UNIQUEID:
- pblock->pb_ldif_generate_uniqueid = *((int *)value);
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->ldif_generate_uniqueid = *((int *)value);
break;
case SLAPI_LDIF2DB_NAMESPACEID:
- pblock->pb_ldif_namespaceid = (char *)value;
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->ldif_namespaceid = (char *)value;
break;
/* db2ldif arguments */
case SLAPI_DB2LDIF_PRINTKEY:
- pblock->pb_ldif_printkey = *((int *)value);
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->ldif_printkey = *((int *)value);
break;
case SLAPI_DB2LDIF_DUMP_UNIQUEID:
- pblock->pb_ldif_dump_uniqueid = *((int *)value);
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->ldif_dump_uniqueid = *((int *)value);
break;
case SLAPI_DB2LDIF_FILE:
- pblock->pb_ldif_file = (char *)value;
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->ldif_file = (char *)value;
break;
/* db2ldif/ldif2db/db2bak/bak2db arguments */
case SLAPI_BACKEND_INSTANCE_NAME:
- pblock->pb_instance_name = (char *) value;
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->instance_name = (char *) value;
break;
- case SLAPI_BACKEND_TASK:
- pblock->pb_task = (Slapi_Task *)value;
- break;
+ case SLAPI_BACKEND_TASK:
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->task = (Slapi_Task *)value;
+ break;
case SLAPI_TASK_FLAGS:
- pblock->pb_task_flags = *((int *)value);
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->task_flags = *((int *)value);
break;
case SLAPI_DB2LDIF_SERVER_RUNNING:
- pblock->pb_server_running = *((int *)value);
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->server_running = *((int *)value);
break;
- case SLAPI_BULK_IMPORT_ENTRY:
- pblock->pb_import_entry = (Slapi_Entry *)value;
- break;
- case SLAPI_BULK_IMPORT_STATE:
- pblock->pb_import_state = *((int *)value);
- break;
+ case SLAPI_BULK_IMPORT_ENTRY:
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->import_entry = (Slapi_Entry *)value;
+ break;
+ case SLAPI_BULK_IMPORT_STATE:
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->import_state = *((int *)value);
+ break;
+
+ case SLAPI_LDIF2DB_ENCRYPT:
+ case SLAPI_DB2LDIF_DECRYPT:
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->ldif_encrypt = *((int *)value);
+ break;
+ /* dbverify */
+ case SLAPI_DBVERIFY_DBDIR:
+ _pblock_assert_pb_task(pblock);
+ pblock->pb_task->dbverify_dbdir = (char *) value;
+ break;
+
/* transaction arguments */
case SLAPI_PARENT_TXN:
- pblock->pb_parent_txn = (void *)value;
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_parent_txn = (void *)value;
break;
case SLAPI_TXN:
- pblock->pb_txn = (void *)value;
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_txn = (void *)value;
break;
case SLAPI_TXN_RUV_MODS_FN:
- pblock->pb_txn_ruv_mods_fn = (IFP) value;
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_txn_ruv_mods_fn = (IFP) value;
break;
/* Search results set */
@@ -3575,13 +3917,15 @@ slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value )
pblock->pb_op->o_results.result_text = (char *) value;
break;
case SLAPI_PB_RESULT_TEXT:
- slapi_ch_free((void**)&(pblock->pb_result_text));
- pblock->pb_result_text = slapi_ch_strdup ((char *) value);
+ _pblock_assert_pb_intop(pblock);
+ slapi_ch_free((void**)&(pblock->pb_intop->pb_result_text));
+ pblock->pb_intop->pb_result_text = slapi_ch_strdup ((char *) value);
break;
/* Size of the database, in kb */
case SLAPI_DBSIZE:
- pblock->pb_dbsize = *((unsigned int *)value);
+ _pblock_assert_pb_misc(pblock);
+ pblock->pb_misc->pb_dbsize = *((unsigned int *)value);
break;
/* ACL Plugin */
@@ -3609,17 +3953,20 @@ slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value )
}
pblock->pb_conn->c_domain = *((struct berval ***) value );
break;
- /* Command line arguments */
- case SLAPI_ARGC:
- pblock->pb_slapd_argc= *((int *)value);
- break;
- case SLAPI_ARGV:
- pblock->pb_slapd_argv = *((char***)value);
- break;
+ /* Command line arguments */
+ case SLAPI_ARGC:
+ _pblock_assert_pb_misc(pblock);
+ pblock->pb_misc->pb_slapd_argc= *((int *)value);
+ break;
+ case SLAPI_ARGV:
+ _pblock_assert_pb_misc(pblock);
+ pblock->pb_misc->pb_slapd_argv = *((char***)value);
+ break;
/* Config file directory */
case SLAPI_CONFIG_DIRECTORY:
- pblock->pb_slapd_configdir = (char *)value;
+ _pblock_assert_pb_intplugin(pblock);
+ pblock->pb_intplugin->pb_slapd_configdir = (char *)value;
break;
/* password storage scheme (kexcoff) */
@@ -3631,11 +3978,13 @@ slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value )
pblock->pb_plugin->plg_pwdstorageschemename = slapi_ch_strdup((char
*)value);
break;
case SLAPI_PLUGIN_PWD_STORAGE_SCHEME_USER_PWD:
- pblock->pb_pwd_storage_scheme_user_passwd = (char *)value;
+ _pblock_assert_pb_deprecated(pblock);
+ pblock->pb_deprecated->pb_pwd_storage_scheme_user_passwd = (char *)value;
break;
case SLAPI_PLUGIN_PWD_STORAGE_SCHEME_DB_PWD:
- pblock->pb_pwd_storage_scheme_db_passwd = (char *)value;
+ _pblock_assert_pb_deprecated(pblock);
+ pblock->pb_deprecated->pb_pwd_storage_scheme_db_passwd = (char *)value;
break;
case SLAPI_PLUGIN_PWD_STORAGE_SCHEME_ENC_FN:
@@ -3665,89 +4014,90 @@ slapi_pblock_set( Slapi_PBlock *pblock, int arg, void *value )
break;
case SLAPI_PLUGIN_ENABLED:
- pblock->pb_plugin_enabled = *((int *)value);
+ _pblock_assert_pb_intplugin(pblock);
+ pblock->pb_intplugin->pb_plugin_enabled = *((int *)value);
break;
/* DSE add parameters */
case SLAPI_DSE_DONT_WRITE_WHEN_ADDING:
- pblock->pb_dse_dont_add_write = *((int *)value);
+ _pblock_assert_pb_dse(pblock);
+ pblock->pb_dse->dont_add_write = *((int *)value);
break;
/* DSE add parameters */
case SLAPI_DSE_MERGE_WHEN_ADDING:
- pblock->pb_dse_add_merge = *((int *)value);
+ _pblock_assert_pb_dse(pblock);
+ pblock->pb_dse->add_merge = *((int *)value);
break;
/* DSE add parameters */
case SLAPI_DSE_DONT_CHECK_DUPS:
- pblock->pb_dse_dont_check_dups = *((int *)value);
+ _pblock_assert_pb_dse(pblock);
+ pblock->pb_dse->dont_check_dups = *((int *)value);
break;
/* DSE modify parameters */
case SLAPI_DSE_REAPPLY_MODS:
- pblock->pb_dse_reapply_mods = *((int *)value);
+ _pblock_assert_pb_dse(pblock);
+ pblock->pb_dse->reapply_mods = *((int *)value);
break;
/* DSE read parameters */
case SLAPI_DSE_IS_PRIMARY_FILE:
- pblock->pb_dse_is_primary_file = *((int *)value);
+ _pblock_assert_pb_dse(pblock);
+ pblock->pb_dse->is_primary_file = *((int *)value);
break;
/* used internally by schema code (schema.c) */
case SLAPI_SCHEMA_FLAGS:
- pblock->pb_schema_flags = *((int *)value);
+ _pblock_assert_pb_dse(pblock);
+ pblock->pb_dse->schema_flags = *((int *)value);
break;
case SLAPI_URP_NAMING_COLLISION_DN:
- pblock->pb_urp_naming_collision_dn = (char *)value;
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_urp_naming_collision_dn = (char *)value;
break;
case SLAPI_URP_TOMBSTONE_UNIQUEID:
- pblock->pb_urp_tombstone_uniqueid = (char *)value;
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_urp_tombstone_uniqueid = (char *)value;
break;
- case SLAPI_LDIF2DB_ENCRYPT:
- case SLAPI_DB2LDIF_DECRYPT:
- pblock->pb_ldif_encrypt = *((int *)value);
- break;
-
case SLAPI_SEARCH_CTRLS:
- pblock->pb_search_ctrls = (LDAPControl **) value;
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_search_ctrls = (LDAPControl **) value;
break;
case SLAPI_PLUGIN_SYNTAX_FILTER_NORMALIZED:
- pblock->pb_syntax_filter_normalized = *((int *)value);
+ _pblock_assert_pb_intplugin(pblock);
+ pblock->pb_intplugin->pb_syntax_filter_normalized = *((int *)value);
break;
case SLAPI_PLUGIN_SYNTAX_FILTER_DATA:
- pblock->pb_syntax_filter_data = (void *)value;
+ _pblock_assert_pb_intplugin(pblock);
+ pblock->pb_intplugin->pb_syntax_filter_data = (void *)value;
break;
case SLAPI_PAGED_RESULTS_INDEX:
- pblock->pb_paged_results_index = *(int *)value;
+ _pblock_assert_pb_intop(pblock);
+ pblock->pb_intop->pb_paged_results_index = *(int *)value;
break;
case SLAPI_PAGED_RESULTS_COOKIE:
- pblock->pb_paged_results_cookie = *(int *)value;
+ pblock->pb_intop->pb_paged_results_cookie = *(int *)value;
break;
/* ACI Target Check */
case SLAPI_ACI_TARGET_CHECK:
- pblock->pb_aci_target_check = *((int *) value);
- break;
-
- /* dbverify */
- case SLAPI_DBVERIFY_DBDIR:
- pblock->pb_dbverify_dbdir = (char *) value;
+ _pblock_assert_pb_misc(pblock);
+ pblock->pb_misc->pb_aci_target_check = *((int *) value);
break;
default:
slapi_log_err(SLAPI_LOG_ERR, "slapi_pblock_set",
"Unknown parameter block argument %d\n", arg);
-#ifdef PBLOCK_ANALYTICS
- Slapi_PBlock *boom = NULL;
- void *x = (void *)boom->pb_plugin;
-#endif
+ PR_ASSERT(0);
return( -1 );
}
@@ -3823,52 +4173,102 @@ bind_credentials_clear( Connection *conn, PRBool lock_conn,
struct slapi_entry *
slapi_pblock_get_pw_entry(Slapi_PBlock *pb) {
- return pb->pb_pw_entry;
+#ifdef PBLOCK_ANALYTICS
+ pblock_analytics_record(pb, SLAPI_PW_ENTRY);
+#endif
+ if (pb->pb_intop != NULL) {
+ return pb->pb_intop->pb_pw_entry;
+ }
+ return NULL;
}
void
slapi_pblock_set_pw_entry(Slapi_PBlock *pb, struct slapi_entry *entry) {
- pb->pb_pw_entry = entry;
+#ifdef PBLOCK_ANALYTICS
+ pblock_analytics_record(pb, SLAPI_PW_ENTRY);
+#endif
+ _pblock_assert_pb_intop(pb);
+ pb->pb_intop->pb_pw_entry = entry;
}
passwdPolicy *
slapi_pblock_get_pwdpolicy(Slapi_PBlock *pb) {
- return pb->pwdpolicy;
+#ifdef PBLOCK_ANALYTICS
+ pblock_analytics_record(pb, SLAPI_PWDPOLICY);
+#endif
+ if (pb->pb_intop != NULL) {
+ return pb->pb_intop->pwdpolicy;
+ }
+ return NULL;
}
void
slapi_pblock_set_pwdpolicy(Slapi_PBlock *pb, passwdPolicy *pwdpolicy) {
- pb->pwdpolicy = pwdpolicy;
+#ifdef PBLOCK_ANALYTICS
+ pblock_analytics_record(pb, SLAPI_PWDPOLICY);
+#endif
+ _pblock_assert_pb_intop(pb);
+ pb->pb_intop->pwdpolicy = pwdpolicy;
}
int32_t
slapi_pblock_get_ldif_dump_replica(Slapi_PBlock *pb) {
- return pb->pb_ldif_dump_replica;
+#ifdef PBLOCK_ANALYTICS
+ pblock_analytics_record(pb, SLAPI_LDIF_DUMP_REPLICA);
+#endif
+ if (pb->pb_task != NULL) {
+ return pb->pb_task->ldif_dump_replica;
+ }
+ return 0;
}
void
slapi_pblock_set_ldif_dump_replica(Slapi_PBlock *pb, int32_t dump_replica) {
- pb->pb_ldif_dump_replica = dump_replica;
+#ifdef PBLOCK_ANALYTICS
+ pblock_analytics_record(pb, SLAPI_LDIF_DUMP_REPLICA);
+#endif
+ _pblock_assert_pb_task(pb);
+ pb->pb_task->ldif_dump_replica = dump_replica;
}
void *
slapi_pblock_get_vattr_context(Slapi_PBlock *pb) {
- return pb->pb_vattr_context;
+#ifdef PBLOCK_ANALYTICS
+ pblock_analytics_record(pb, SLAPI_VATTR_CONTEXT);
+#endif
+ if (pb->pb_intplugin != NULL) {
+ return pb->pb_intplugin->pb_vattr_context;
+ }
+ return NULL;
}
void
slapi_pblock_set_vattr_context(Slapi_PBlock *pb, void *vattr_ctx) {
- pb->pb_vattr_context = vattr_ctx;
+#ifdef PBLOCK_ANALYTICS
+ pblock_analytics_record(pb, SLAPI_VATTR_CONTEXT);
+#endif
+ _pblock_assert_pb_intplugin(pb);
+ pb->pb_intplugin->pb_vattr_context = vattr_ctx;
}
void *
slapi_pblock_get_op_stack_elem(Slapi_PBlock *pb) {
- return pb->op_stack_elem;
+#ifdef PBLOCK_ANALYTICS
+ pblock_analytics_record(pb, SLAPI_OP_STACK_ELEM);
+#endif
+ if (pb->pb_intop != NULL) {
+ return pb->pb_intop->op_stack_elem;
+ }
+ return NULL;
}
void
slapi_pblock_set_op_stack_elem(Slapi_PBlock *pb, void *stack_elem) {
- pb->op_stack_elem = stack_elem;
+#ifdef PBLOCK_ANALYTICS
+ pblock_analytics_record(pb, SLAPI_OP_STACK_ELEM);
+#endif
+ _pblock_assert_pb_intop(pb);
+ pb->pb_intop->op_stack_elem = stack_elem;
}
/*
diff --git a/ldap/servers/slapd/pblock_v3.h b/ldap/servers/slapd/pblock_v3.h
index df6d347..2ed2f5d 100644
--- a/ldap/servers/slapd/pblock_v3.h
+++ b/ldap/servers/slapd/pblock_v3.h
@@ -16,22 +16,106 @@
#include "slap.h"
-typedef struct slapi_pblock {
- /* common */
- Slapi_Backend *pb_backend;
- Connection *pb_conn;
- Operation *pb_op;
- struct slapdplugin *pb_plugin; /* plugin being called */
- int pb_opreturn;
+#ifdef DEBUG
+ /* #define PBLOCK_ANALYTICS 1 */
+#else
+#undef PBLOCK_ANALYTICS
+#endif
+
+typedef struct _slapi_pblock_dse {
+ int dont_add_write; /* if true, the dse is not written when an entry is added */
+ int add_merge; /* if true, if a duplicate entry is found when adding, the
+ new values are merged into the old entry */
+ int dont_check_dups; /* if false, use the "enhanced" version of str2entry
to catch
+ more errors when adding dse entries; this can only be done
+ after the schema and syntax and matching rule plugins are
+ running */
+ int is_primary_file; /* for read callbacks: non-zero for primary file */
+ int reapply_mods; /* if true, dse_modify will reapply mods after modify callback */
+ int schema_flags; /* schema flags */
+ /* . check/load info (schema reload task) */
+ /* . refresh user defined schema */
+
+} slapi_pblock_dse;
+
+typedef struct _slapi_pblock_task {
+ char *instance_name;
+ Slapi_Task *task;
+ char *seq_attrname;
+ char *seq_val;
+ char *dbverify_dbdir;
+ char *ldif_file;
+ char **db2index_attrs;
+
+ /*
+ * wire import (fast replica init) arguments
+ */
+ struct slapi_entry *import_entry;
+ /* ldif2db: array of files to import all at once */
+ char **ldif_files;
+ char **ldif_include;
+ char **ldif_exclude;
+ char *ldif_namespaceid; /* used for name based uniqueid generation */
+ int ldif_dump_replica;
+ int ldif_dump_uniqueid; /* dump uniqueid during db2ldif */
+ int ldif_generate_uniqueid; /* generate uniqueid during db2ldif */
+ int ldif_encrypt; /* used to enable encrypt/decrypt on import and export
*/
+ int seq_type;
+ int removedupvals;
+ int ldif2db_noattrindexes;
+ int ldif_printkey;
+ int task_flags;
+ int import_state;
+
+ int server_running; /* indicate that server is running */
+} slapi_pblock_task;
+
+typedef struct _slapi_pblock_matching_rule {
+ /* matching rule arguments */
+ mrFilterMatchFn filter_match_fn;
+ IFP filter_index_fn;
+ IFP filter_reset_fn;
+ IFP index_fn; /* values and keys are struct berval ** */
+ IFP index_sv_fn; /* values and keys are Slapi_Value ** */
+ char* oid;
+ char* type;
+ struct berval* value;
+ struct berval** values;
+ struct berval** keys;
+ unsigned int filter_reusable;
+ int query_operator;
+ unsigned int usage;
+} slapi_pblock_matching_rule;
+
+typedef struct _slapi_pblock_intplugin {
void* pb_object; /* points to data private to plugin */
+ void *pb_plugin_identity; /* identifies plugin for internal operation */
+ char *pb_plugin_config_area; /* optional config area */
+ void *pb_vattr_context; /* hold the vattr_context for roles/cos */
+
+ void *pb_syntax_filter_data; /* extra data to pass to a syntax plugin function
*/
+ int *pb_substrlens; /* user specified minimum substr search key lengths:
+ * nsSubStrBegin, nsSubStrMiddle, nsSubStrEnd
+ */
+ char *pb_slapd_configdir; /* the config directory passed to slapd on the command line
*/
IFP pb_destroy_fn;
- int pb_requestor_isroot;
- /* config file */
- char *pb_config_fname;
- int pb_config_lineno;
- int pb_config_argc;
- char **pb_config_argv;
- int plugin_tracking;
+ int pb_plugin_enabled; /* nsslapd-pluginEnabled: on|off */
+ /* used in plugin init; pb_plugin is not ready, then */
+ int pb_syntax_filter_normalized; /* the syntax filter types/values are already
normalized */
+
+} slapi_pblock_intplugin;
+
+/* Contains parts for internal operations that are NOT in the pb_op */
+typedef struct _slapi_pblock_intop {
+ void *op_stack_elem;
+
+ void *pb_parent_txn; /* parent transaction ID */
+ void *pb_txn; /* transaction ID */
+ IFP pb_txn_ruv_mods_fn; /* Function to fetch RUV mods for txn */
+ passwdPolicy *pwdpolicy;
+ LDAPControl **pb_ctrls_arg; /* allows to pass controls as arguments before
+ operation object is created */
+ struct slapi_entry *pb_pw_entry; /* stash dup'ed entry that shadow info is
added/replaced */
/* [pre|post]add arguments */
struct slapi_entry *pb_target_entry; /* JCM - Duplicated */
@@ -43,141 +127,85 @@ typedef struct slapi_pblock {
/* state of entry before and after add/delete/modify/moddn/modrdn */
struct slapi_entry *pb_pre_op_entry;
struct slapi_entry *pb_post_op_entry;
- /* seq access arguments */
- int pb_seq_type;
- char *pb_seq_attrname;
- char *pb_seq_val;
- /* dbverify argument */
- char *pb_dbverify_dbdir;
- /* ldif2db arguments */
- char *pb_ldif_file;
- int pb_removedupvals;
- char **pb_db2index_attrs;
- int pb_ldif2db_noattrindexes;
- /* db2ldif arguments */
- int pb_ldif_printkey;
- /* ldif2db/db2ldif/db2bak/bak2db args */
- char *pb_instance_name;
- Slapi_Task *pb_task;
- int pb_task_flags;
- /* matching rule arguments */
- mrFilterMatchFn pb_mr_filter_match_fn;
- IFP pb_mr_filter_index_fn;
- IFP pb_mr_filter_reset_fn;
- IFP pb_mr_index_fn; /* values and keys are struct berval ** */
- char* pb_mr_oid;
- char* pb_mr_type;
- struct berval* pb_mr_value;
- struct berval** pb_mr_values;
- struct berval** pb_mr_keys;
- unsigned int pb_mr_filter_reusable;
- int pb_mr_query_operator;
- unsigned int pb_mr_usage;
-
- /* arguments for password storage scheme (kexcoff) */
- char *pb_pwd_storage_scheme_user_passwd;
- char *pb_pwd_storage_scheme_db_passwd;
+ /* pointer to array of results returned on search */
+ Slapi_Entry **pb_plugin_internal_search_op_entries;
+ char **pb_plugin_internal_search_op_referrals;
+ LDAPControl **pb_search_ctrls; /* for search operations, allows plugins to provide
+ controls to pass for each entry or referral
returned */
+ /* NEW in 5.0 for getting back the backend result in frontend */
+ char * pb_result_text; /* result text when available */
+ char * pb_urp_naming_collision_dn; /* replication naming conflict removal */
+ char * pb_urp_tombstone_uniqueid; /* replication change tombstone */
+ int pb_opreturn;
/* controls we know about */
int pb_managedsait;
-
/* additional fields for plugin_internal_ldap_ops */
/* result code of internal ldap_operation */
int pb_internal_op_result;
- /* pointer to array of results returned on search */
- Slapi_Entry **pb_plugin_internal_search_op_entries;
- char **pb_plugin_internal_search_op_referrals;
- void *pb_plugin_identity; /* identifies plugin for internal operation */
- char *pb_plugin_config_area; /* optional config area */
- void *pb_parent_txn; /* parent transaction ID */
- void *pb_txn; /* transaction ID */
- IFP pb_txn_ruv_mods_fn; /* Function to fetch RUV mods for txn */
-
- /* Size of the database on disk, in kilobytes */
- unsigned int pb_dbsize;
-
- /* THINGS BELOW THIS LINE EXIST ONLY IN SLAPI v2 (slapd 4.0+) */
-
- /* ldif2db: array of files to import all at once */
- char **pb_ldif_files;
-
- char **pb_ldif_include;
- char **pb_ldif_exclude;
- int pb_ldif_dump_replica;
- int pb_ldif_dump_uniqueid; /* dump uniqueid during db2ldif */
- int pb_ldif_generate_uniqueid; /* generate uniqueid during db2ldif */
- char* pb_ldif_namespaceid; /* used for name based uniqueid generation */
- int pb_ldif_encrypt; /* used to enable encrypt/decrypt on import and
export */
+ int pb_requestor_isroot;
+ int pb_nentries; /* number of entries to be returned */
/*
* notes to log with RESULT line in the access log
* these are actually stored as a bitmap; see slapi-plugin.h for
* defined notes.
*/
unsigned int pb_operation_notes;
+ /* For password policy control */
+ int pb_pwpolicy_ctrl;
+
+ int pb_paged_results_index; /* stash SLAPI_PAGED_RESULTS_INDEX */
+ int pb_paged_results_cookie; /* stash SLAPI_PAGED_RESULTS_COOKIE */
+} slapi_pblock_intop;
+
+/* Stuff that is rarely used, but still present */
+typedef struct _slapi_pblock_misc {
+ char** pb_slapd_argv;
+ /* Size of the database on disk, in kilobytes */
+ unsigned int pb_dbsize;
+ int pb_backend_count; /* instance count involved in the op */
/*
* slapd command line arguments
*/
int pb_slapd_argc;
- char** pb_slapd_argv;
- char *pb_slapd_configdir; /* the config directory passed to slapd on the command line
*/
- LDAPControl **pb_ctrls_arg; /* allows to pass controls as arguments before
- operation object is created */
- int pb_dse_dont_add_write; /* if true, the dse is not written when an entry is added
*/
- int pb_dse_add_merge; /* if true, if a duplicate entry is found when adding, the
- new values are merged into the old entry */
- int pb_dse_dont_check_dups; /* if false, use the "enhanced" version of
str2entry to catch
- more errors when adding dse entries; this can only be
done
- after the schema and syntax and matching rule plugins
are
- running */
- int pb_dse_is_primary_file; /* for read callbacks: non-zero for primary file */
- int pb_schema_flags; /* schema flags */
- /* . check/load info (schema reload task) */
- /* . refresh user defined schema */
+ /* For ACI Target Check */
+ int pb_aci_target_check; /* this flag prevents duplicate checking of ACI's target
existence */
+} slapi_pblock_misc;
- /* NEW in 5.0 for getting back the backend result in frontend */
+/* This struct is full of stuff we rarely, or never use. */
+typedef struct _slapi_pblock_deprecated {
int pb_result_code; /* operation result code */
- char * pb_result_text; /* result text when available */
+ int plugin_tracking;
+ int pb_config_argc;
+ char **pb_config_argv;
char * pb_result_matched; /* macthed dn when NO SUCH OBJECT error */
- int pb_nentries; /* number of entries to be returned */
- struct berval **urls; /* urls of referrals to be returned */
-
- /*
- * wire import (fast replica init) arguments
- */
- struct slapi_entry *pb_import_entry;
- int pb_import_state;
-
int pb_destroy_content; /* flag to indicate that pblock content should be
destroyed when pblock is destroyed */
- int pb_dse_reapply_mods; /* if true, dse_modify will reapply mods after modify
callback */
- char * pb_urp_naming_collision_dn; /* replication naming conflict removal */
- char * pb_urp_tombstone_uniqueid; /* replication change tombstone */
- int pb_server_running; /* indicate that server is running */
- int pb_backend_count; /* instance count involved in the op */
-
- /* For password policy control */
- int pb_pwpolicy_ctrl;
- void *pb_vattr_context; /* hold the vattr_context for roles/cos */
+ struct berval **urls; /* urls of referrals to be returned */
+ /* arguments for password storage scheme (kexcoff) */
+ char *pb_pwd_storage_scheme_user_passwd;
+ char *pb_pwd_storage_scheme_db_passwd;
+ /* config file */
+ char *pb_config_fname;
+ int pb_config_lineno;
+} slapi_pblock_deprecated;
- int *pb_substrlens; /* user specified minimum substr search key lengths:
- * nsSubStrBegin, nsSubStrMiddle, nsSubStrEnd
- */
- int pb_plugin_enabled; /* nsslapd-pluginEnabled: on|off */
- /* used in plugin init; pb_plugin is not ready, then */
- LDAPControl **pb_search_ctrls; /* for search operations, allows plugins to provide
- controls to pass for each entry or referral
returned */
- IFP pb_mr_index_sv_fn; /* values and keys are Slapi_Value ** */
- int pb_syntax_filter_normalized; /* the syntax filter types/values are already
normalized */
- void *pb_syntax_filter_data; /* extra data to pass to a syntax plugin function
*/
- int pb_paged_results_index; /* stash SLAPI_PAGED_RESULTS_INDEX */
- int pb_paged_results_cookie; /* stash SLAPI_PAGED_RESULTS_COOKIE */
- passwdPolicy *pwdpolicy;
- void *op_stack_elem;
+typedef struct slapi_pblock {
+ /* common */
+ Slapi_Backend *pb_backend;
+ Connection *pb_conn;
+ Operation *pb_op;
+ struct slapdplugin *pb_plugin; /* plugin being called */
- /* For ACI Target Check */
- int pb_aci_target_check; /* this flag prevents duplicate checking of ACI's target
existence */
+ /* Private tree of fields for our operations, grouped by usage patterns */
+ struct _slapi_pblock_dse *pb_dse;
+ struct _slapi_pblock_task *pb_task;
+ struct _slapi_pblock_matching_rule *pb_mr;
+ struct _slapi_pblock_misc *pb_misc;
+ struct _slapi_pblock_intop *pb_intop;
+ struct _slapi_pblock_intplugin *pb_intplugin;
+ struct _slapi_pblock_deprecated *pb_deprecated;
- struct slapi_entry *pb_pw_entry; /* stash dup'ed entry that shadow info is
added/replaced */
#ifdef PBLOCK_ANALYTICS
uint32_t analytics_init;
PLHashTable *analytics;
diff --git a/ldap/servers/slapd/slap.h b/ldap/servers/slapd/slap.h
index 5469b51..2f84d27 100644
--- a/ldap/servers/slapd/slap.h
+++ b/ldap/servers/slapd/slap.h
@@ -129,12 +129,6 @@ typedef struct symbol_t {
#include <systemd/sd-daemon.h>
#endif
-#ifdef DEBUG
- // #define PBLOCK_ANALYTICS 1
-#else
-#undef PBLOCK_ANALYTICS
-#endif
-
#if defined(OS_solaris)
# include <thread.h>
# define GET_THREAD_ID() thr_self()
diff --git a/ldap/servers/slapd/uuid.c b/ldap/servers/slapd/uuid.c
index effd864..333321c 100644
--- a/ldap/servers/slapd/uuid.c
+++ b/ldap/servers/slapd/uuid.c
@@ -658,7 +658,7 @@ static int add_state_entry(void)
else
{
slapi_pblock_get( pb, SLAPI_PLUGIN_INTOP_RESULT, &rt);
- slapi_ch_free((void **) &pb);
+ slapi_pblock_destroy(pb);
}
if (rt != LDAP_SUCCESS)
diff --git a/test/pblock_analyse.py b/test/pblock_analyse.py
index 4effedc..f5f8126 100644
--- a/test/pblock_analyse.py
+++ b/test/pblock_analyse.py
@@ -60,38 +60,78 @@ def determine_pblock_groups(flat_results):
if subset is False:
ss_flat_results.append(pbs_a)
- #for pbs in sorted(ss_flat_results, key=len):
- # print(pbs)
+ for pbs in sorted(ss_flat_results, key=len):
+ print('pbs -> %s' % sorted(pbs))
+ print('== unique filtered pblocks %s ==' % len(ss_flat_results))
+
+ # We build some sets of attrs we expect in certain things
+ e_plugin_set = set(['13'])
+ e_search_set = set(['195', '113'])
+ e_modrdn_set = set(['100', '103', '101'])
+ e_backend_plugin_set = set(['213', '202', '214'])
+ e_op_set = set(['1001', '47'])
+ e_task_set = set(['178', '181', '182', '192'])
+ e_dse_set = set(['282', '283', '281', '289'])
# Now, we can group these by plugin callback, and searches.
# Check for plugin_enabled
+ task_set = set()
+ backend_plugin_set = set()
plugin_set = set()
search_set = set()
- other_set = set()
+ modrdn_set = set()
+ urp_set = set()
+ op_set = set()
+ dse_set = set()
+
for pbs in ss_flat_results:
- # 815 is plugin_enabled
- if '815' in pbs:
- plugin_set.update(pbs)
- elif '216' in pbs: # This is db_result_fn
+ # 3 is plugin, and 130 backend.
+ if e_search_set & pbs:
search_set.update(pbs)
+ elif e_modrdn_set & pbs:
+ modrdn_set.update(pbs)
+ elif e_op_set & pbs:
+ op_set.update(pbs)
+ elif e_task_set & pbs:
+ task_set.update(pbs)
+ elif e_backend_plugin_set & pbs:
+ backend_plugin_set.update(pbs)
+ elif e_plugin_set & pbs:
+ plugin_set.update(pbs)
+ elif e_dse_set & pbs:
+ dse_set.update(pbs)
else:
- other_set.update(pbs)
+ print('unclassified pb %s' % sorted(pbs))
+
+ # Now, make each set unique to itself.
- overlap_set = plugin_set & search_set
+ excess_set = access_values - (task_set | backend_plugin_set | plugin_set | search_set
| op_set | dse_set | modrdn_set )
- print('plugin_set: %s' % plugin_set)
- print('search_set: %s' % search_set)
- print('other_set: %s' % other_set)
- print('overlap : %s' % (plugin_set & search_set))
- print ('== frequency of overlap from %s unique pblocks ==' %
(len(flat_results)))
+
+ print('plugin_set: %s' % sorted(plugin_set))
+ print('')
+ print('backend_plugin_set: %s' % sorted(backend_plugin_set))
+ print('')
+ print('search_set: %s' % sorted(search_set))
+ print('')
+ print('modrdn_set: %s' % sorted(modrdn_set))
+ print('')
+ print('urp_set: %s' % sorted(urp_set))
+ print('')
+ print('task_set: %s' % sorted(task_set))
+ print('')
+ print('op_set: %s' % sorted(op_set))
+ print('')
+ print('dse_set: %s' % sorted(dse_set))
+ print('')
+ print('excess_set: %s' % sorted(excess_set))
+ print('')
+
+ print ('== frequency of overlap from %s unique pblocks ==' %
(len(ss_flat_results)))
for r in sorted(results, key=results.get, reverse=True):
if r in overlap_set:
print('pop: av %s count %s' % (r, results[r]))
- print ('== frequency of other from %s unique pblocks ==' %
(len(flat_results)))
- for r in sorted(results, key=results.get, reverse=True):
- if r in other_set:
- print('pop: av %s count %s' % (r, results[r]))
def analyse():
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.