From 27d2c7c46e78139f289faeaa97ee1df268e81984 Mon Sep 17 00:00:00 2001 From: William Brown Date: Tue, 7 Feb 2017 14:56:05 +1000 Subject: [PATCH] Ticket 49116 - Pblock usage analytics Bug Description: In order to refactor and improve the pblock we need to know what is using it. Fix Description: This provides basic usage tracking so that we can account for access to get and set of the pblock. This allows us to group usage patterns so that we can refactor. https://fedorahosted.org/389/ticket/49116 Author: wibrown Review by: ??? --- dirsrvtests/tests/suites/basic/basic_test.py | 2 + ldap/servers/slapd/pblock.c | 210 ++++++-- ldap/servers/slapd/plugin.c | 2 + ldap/servers/slapd/slap.h | 10 + test/libslapd/pblock/analytics.c | 20 +- test/libslapd/pblock/pblock_accessors.txt | 319 +++++++++++++ test/libslapd/pblock/pblock_accessors_freq.txt | 638 +++++++++++++++++++++++++ test/pblock_analyse.py | 108 +++++ 8 files changed, 1272 insertions(+), 37 deletions(-) create mode 100644 test/libslapd/pblock/pblock_accessors.txt create mode 100644 test/libslapd/pblock/pblock_accessors_freq.txt create mode 100644 test/pblock_analyse.py diff --git a/dirsrvtests/tests/suites/basic/basic_test.py b/dirsrvtests/tests/suites/basic/basic_test.py index c7b9566..c548103 100644 --- a/dirsrvtests/tests/suites/basic/basic_test.py +++ b/dirsrvtests/tests/suites/basic/basic_test.py @@ -259,6 +259,8 @@ def test_basic_import_export(topology_st, import_example_ldif): log.fatal('test_basic_import_export: Failed to run offline db2ldif') assert False + topology_st.standalone.start() + # # Cleanup - Import the Example LDIF for the other tests in this suite # diff --git a/ldap/servers/slapd/pblock.c b/ldap/servers/slapd/pblock.c index f074394..f3babf6 100644 --- a/ldap/servers/slapd/pblock.c +++ b/ldap/servers/slapd/pblock.c @@ -12,14 +12,123 @@ # include #endif - - #include #include #include #include "slap.h" #include "cert.h" +#ifdef PBLOCK_ANALYTICS + +#define NUMBER_SLAPI_ATTRS 320 +#define ANALYTICS_MAGIC 0x7645 + +static PRLock *pblock_analytics_lock = NULL; + +static PLHashNumber +hash_int_func(const void *key) { + uint64_t ik = (uint64_t)key; + return ik % NUMBER_SLAPI_ATTRS; +} + +static PRIntn +hash_key_compare(const void *a, const void *b) { + uint64_t ia = (uint64_t)a; + uint64_t ib = (uint64_t)b; + return ia == ib; +} + +static PRIntn +hash_value_compare(const void *a, const void *b) { + uint64_t ia = (uint64_t)a; + uint64_t ib = (uint64_t)b; + return ia == ib; +} + +static void +pblock_analytics_init( Slapi_PBlock *pb ) { + if (pblock_analytics_lock == NULL) { + pblock_analytics_lock = PR_NewLock(); + } + /* Create an array of values for us to use. */ + if (pb->analytics == NULL) { + pb->analytics = PL_NewHashTable(NUMBER_SLAPI_ATTRS, hash_int_func, hash_key_compare, hash_value_compare, NULL, NULL); + } + pb->analytics_init = ANALYTICS_MAGIC; +} + +static void +pblock_analytics_destroy( Slapi_PBlock *pb ) { + /* Some parts of DS re-use or double free pblocks >.< */ + if (pb->analytics_init != ANALYTICS_MAGIC) { + return; + } + /* Free the array of values */ + PL_HashTableDestroy(pb->analytics); + pb->analytics_init = 0; +} + +static void +pblock_analytics_record( Slapi_PBlock *pb, int access_type ) { + if (pb->analytics_init != ANALYTICS_MAGIC) { + pblock_analytics_init(pb); + } + /* record an access of type to the values */ + /* Is the value there? */ + uint64_t uact = (uint64_t)access_type; + uint64_t value = (uint64_t)PL_HashTableLookup(pb->analytics, (void *)uact); + if (value == 0) { + PL_HashTableAdd(pb->analytics, (void *)uact, (void *)1); + } else { + /* If not, increment it. */ + PL_HashTableAdd(pb->analytics, (void *)uact, (void *)(value + 1)); + } +} + +static PRIntn +pblock_analytics_report_entry(PLHashEntry *he, PRIntn index, void *arg) { + FILE *fp = (FILE *)arg; + /* Print a pair of values */ + fprintf(fp, "%"PRIu64":%"PRIu64",", (uint64_t)he->key, (uint64_t)he->value); + + return HT_ENUMERATE_NEXT; +} + +static void +pblock_analytics_report( Slapi_PBlock *pb ) { + /* Some parts of DS re-use or double free pblocks >.< */ + if (pb->analytics_init != ANALYTICS_MAGIC) { + return; + } + /* Write the report to disk. */ + /* Take the write lock. */ + PR_Lock(pblock_analytics_lock); + + FILE *fp = NULL; + fp = fopen("/tmp/pblock_stats.csv", "a"); + if (fp == NULL) { + int errsv = errno; + printf("%d\n", errsv); + abort(); + } + /* Map over the hashmap */ + PL_HashTableEnumerateEntries(pb->analytics, pblock_analytics_report_entry, fp); + /* Printf the new line */ + fprintf(fp, "\n"); + fclose(fp); + /* Unlock */ + PR_Unlock(pblock_analytics_lock); +} + +uint64_t +pblock_analytics_query( Slapi_PBlock *pb, int access_type) { + uint64_t uact = (uint64_t)access_type; + /* For testing, allow querying of the stats we have taken. */ + return (uint64_t)PL_HashTableLookup(pb->analytics, (void *)uact); +} + +#endif + void pblock_init( Slapi_PBlock *pb ) { @@ -35,54 +144,72 @@ pblock_init_common( ) { PR_ASSERT( NULL != pb ); +#ifdef PBLOCK_ANALYTICS + pblock_analytics_init(pb); +#endif /* No need to memset, this is only called in backend_manager, and it uses {0} */ pb->pb_backend = be; pb->pb_conn = conn; pb->pb_op = op; } -void +/* NO LONGER USED!!! */ +static void slapi_pblock_get_common( - Slapi_PBlock *pb, - Slapi_Backend **be, - Connection **conn, - Operation **op + Slapi_PBlock *pb, + Slapi_Backend **be, + Connection **conn, + Operation **op ) { - PR_ASSERT( NULL != pb ); - PR_ASSERT( NULL != be ); - PR_ASSERT( NULL != conn ); - PR_ASSERT( NULL != op ); - *be = pb->pb_backend; - *conn = pb->pb_conn; - *op = pb->pb_op; + PR_ASSERT( NULL != pb ); + PR_ASSERT( NULL != be ); + PR_ASSERT( NULL != conn ); + PR_ASSERT( NULL != op ); + *be = pb->pb_backend; + *conn = pb->pb_conn; + *op = pb->pb_op; } Slapi_PBlock * slapi_pblock_new() { - Slapi_PBlock *pb; + Slapi_PBlock *pb; - pb = (Slapi_PBlock *) slapi_ch_calloc( 1, sizeof(Slapi_PBlock) ); - return pb; + pb = (Slapi_PBlock *) slapi_ch_calloc( 1, sizeof(Slapi_PBlock) ); +#ifdef PBLOCK_ANALYTICS + pblock_analytics_init(pb); +#endif + return pb; } void slapi_pblock_init( Slapi_PBlock *pb ) { - if(pb!=NULL) - { - pblock_done(pb); - pblock_init(pb); - } + if(pb!=NULL) + { + pblock_done(pb); + pblock_init(pb); +#ifdef PBLOCK_ANALYTICS + pblock_analytics_init(pb); +#endif + } } +/* + * THIS FUNCTION IS AWFUL, WE SHOULD NOT REUSE PBLOCKS + */ void pblock_done( Slapi_PBlock *pb ) { +#ifdef PBLOCK_ANALYTICS + pblock_analytics_report(pb); + pblock_analytics_destroy(pb); +#endif if(pb->pb_op!=NULL) { operation_free(&pb->pb_op,pb->pb_conn); + pb->pb_op = NULL; } delete_passwdPolicy(&pb->pwdpolicy); slapi_ch_free((void**)&(pb->pb_vattr_context)); @@ -92,11 +219,11 @@ pblock_done( Slapi_PBlock *pb ) void slapi_pblock_destroy( Slapi_PBlock* pb ) { - if(pb!=NULL) - { - pblock_done(pb); - slapi_ch_free((void**)&pb); - } + if(pb!=NULL) + { + pblock_done(pb); + slapi_ch_free((void**)&pb); + } } /* JCM - when pb_o_params is used, check the operation type. */ @@ -129,6 +256,11 @@ __attribute__((no_sanitize("address"))) # endif #endif { + +#ifdef PBLOCK_ANALYTICS + pblock_analytics_record(pblock, arg); +#endif + char *authtype; Slapi_Backend *be; @@ -1150,7 +1282,7 @@ __attribute__((no_sanitize("address"))) * It should not be freed.*/ if(pblock->pb_op!=NULL) { - Slapi_DN *sdn = pblock->pb_op->o_params.target_address.sdn; + Slapi_DN *sdn = pblock->pb_op->o_params.target_address.sdn; if (sdn) { (*(char **)value) = (char *)slapi_sdn_get_dn(sdn); } else { @@ -1162,10 +1294,10 @@ __attribute__((no_sanitize("address"))) return( -1 ); } break; - case SLAPI_TARGET_SDN: + case SLAPI_TARGET_SDN: /* Alias from SLAPI_ADD_TARGET_SDN */ if(pblock->pb_op!=NULL) { - (*(Slapi_DN **)value) = pblock->pb_op->o_params.target_address.sdn; + (*(Slapi_DN **)value) = pblock->pb_op->o_params.target_address.sdn; } else { @@ -2013,6 +2145,9 @@ __attribute__((no_sanitize("address"))) # endif #endif { +#ifdef PBLOCK_ANALYTICS + pblock_analytics_record(pblock, arg); +#endif char *authtype; PR_ASSERT( NULL != pblock ); @@ -2890,20 +3025,19 @@ __attribute__((no_sanitize("address"))) * the address using slapi_pblock_get(pb, SLAPI_TARGET_SDN, &sdn). */ if(pblock->pb_op!=NULL) { - Slapi_DN *sdn = pblock->pb_op->o_params.target_address.sdn; - slapi_sdn_free(&sdn); - pblock->pb_op->o_params.target_address.sdn = - slapi_sdn_new_dn_byval((char *)value); + Slapi_DN *sdn = pblock->pb_op->o_params.target_address.sdn; + slapi_sdn_free(&sdn); + pblock->pb_op->o_params.target_address.sdn = slapi_sdn_new_dn_byval((char *)value); } else { return( -1 ); } break; - case SLAPI_TARGET_SDN: + case SLAPI_TARGET_SDN: /* alias from SLAPI_ADD_TARGET_SDN */ if(pblock->pb_op!=NULL) { - pblock->pb_op->o_params.target_address.sdn = (Slapi_DN *)value; + pblock->pb_op->o_params.target_address.sdn = (Slapi_DN *)value; } else { @@ -3634,6 +3768,10 @@ __attribute__((no_sanitize("address"))) int slapi_is_ldapi_conn(Slapi_PBlock *pb) { +#ifdef PBLOCK_ANALYTICS + // MAKE THIS BETTER. + pblock_analytics_record(pb, SLAPI_CONNECTION); +#endif if(pb && pb->pb_conn){ return pb->pb_conn->c_unix_local; } else { diff --git a/ldap/servers/slapd/plugin.c b/ldap/servers/slapd/plugin.c index fea1a2a..6adb4cd 100644 --- a/ldap/servers/slapd/plugin.c +++ b/ldap/servers/slapd/plugin.c @@ -1936,6 +1936,7 @@ plugin_dependency_closeall(void) plugin_call_one( global_plugin_shutdown_order[index].plugin, SLAPI_PLUGIN_CLOSE_FN, &pb); /* set plg_closed to 1 to prevent any further plugin pre/post op function calls */ global_plugin_shutdown_order[index].plugin->plg_closed = 1; + pblock_done(&pb); } plugins_closed++; @@ -3142,6 +3143,7 @@ PLUGIN_CLEANUP: plugin_free(plugin); } slapi_ch_free((void **)&configdir); + pblock_done(&pb); return status; } diff --git a/ldap/servers/slapd/slap.h b/ldap/servers/slapd/slap.h index 403bfd9..f1233b4 100644 --- a/ldap/servers/slapd/slap.h +++ b/ldap/servers/slapd/slap.h @@ -134,6 +134,12 @@ typedef struct symbol_t { #include #endif +#ifdef DEBUG + // #define PBLOCK_ANALYTICS 1 +#else +#undef PBLOCK_ANALYTICS +#endif + #if defined(OS_solaris) # include # define GET_THREAD_ID() thr_self() @@ -1913,6 +1919,10 @@ typedef struct slapi_pblock { int pb_aci_target_check; /* this flag prevents duplicate checking of ACI's target existence */ 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; +#endif } slapi_pblock; /* index if substrlens */ diff --git a/test/libslapd/pblock/analytics.c b/test/libslapd/pblock/analytics.c index 2493299..1937f3a 100644 --- a/test/libslapd/pblock/analytics.c +++ b/test/libslapd/pblock/analytics.c @@ -9,9 +9,27 @@ #include "../../test_slapd.h" +/* Define this here to access the symbol in libslapd */ +uint64_t pblock_analytics_query( Slapi_PBlock *pb, int access_type); + void test_libslapd_pblock_analytics(void **state __attribute__((unused))) { +#ifdef PBLOCK_ANALYTICS + /* Create a pblock */ + Slapi_PBlock *pb = slapi_pblock_new(); + slapi_pblock_init(pb); + /* Check the counters are 0 */ + assert_int_equal(pblock_analytics_query(pb, SLAPI_BACKEND_COUNT), 0); + + uint32_t becount = 0; + /* Test get and set */ + slapi_pblock_get(pb, SLAPI_BACKEND_COUNT, &becount); + + /* Make sure the counters were changed correctly */ + assert_int_equal(pblock_analytics_query(pb, SLAPI_BACKEND_COUNT), 1); + /* It works! */ - assert_int_equal(1, 1); + slapi_pblock_destroy(pb); +#endif } diff --git a/test/libslapd/pblock/pblock_accessors.txt b/test/libslapd/pblock/pblock_accessors.txt new file mode 100644 index 0000000..a5e00d8 --- /dev/null +++ b/test/libslapd/pblock/pblock_accessors.txt @@ -0,0 +1,319 @@ +SLAPI_ABANDON_MSGID +SLAPI_ACI_TARGET_CHECK +SLAPI_ADD_ENTRY +SLAPI_ADD_EXISTING_DN_ENTRY +SLAPI_ADD_EXISTING_UNIQUEID_ENTRY +SLAPI_ADD_PARENT_ENTRY +SLAPI_ADD_PARENT_UNIQUEID +SLAPI_ADD_RESCONTROL +SLAPI_ARGC +SLAPI_ARGV +SLAPI_BACKEND +SLAPI_BACKEND_COUNT +SLAPI_BACKEND_INSTANCE_NAME +SLAPI_BACKEND_TASK +SLAPI_BE_LASTMOD +SLAPI_BE_MAXNESTLEVEL +SLAPI_BE_READONLY +SLAPI_BE_TYPE +SLAPI_BIND_CREDENTIALS +SLAPI_BIND_METHOD +SLAPI_BIND_RET_SASLCREDS +SLAPI_BIND_SASLMECHANISM +SLAPI_BULK_IMPORT_ENTRY +SLAPI_BULK_IMPORT_STATE +SLAPI_CLIENT_DNS +SLAPI_COMPARE_TYPE +SLAPI_COMPARE_VALUE +SLAPI_CONFIG_ARGC +SLAPI_CONFIG_ARGV +SLAPI_CONFIG_DIRECTORY +SLAPI_CONFIG_FILENAME +SLAPI_CONFIG_LINENO +SLAPI_CONN_AUTHMETHOD +SLAPI_CONN_AUTHTYPE +SLAPI_CONN_CERT +SLAPI_CONN_CLIENTIP +SLAPI_CONN_CLIENTNETADDR +SLAPI_CONN_DN +SLAPI_CONNECTION +SLAPI_CONN_ID +SLAPI_CONN_IS_REPLICATION_SESSION +SLAPI_CONN_IS_SSL_SESSION +SLAPI_CONN_LOCAL_SSF +SLAPI_CONN_SASL_SSF +SLAPI_CONN_SERVERIP +SLAPI_CONN_SERVERNETADDR +SLAPI_CONN_SSL_SSF +SLAPI_CONTROLS_ARG +SLAPI_DB2INDEX_ATTRS +SLAPI_DB2LDIF_DECRYPT +SLAPI_DB2LDIF_DUMP_UNIQUEID +SLAPI_DB2LDIF_FILE +SLAPI_DB2LDIF_PRINTKEY +SLAPI_DB2LDIF_SERVER_RUNNING +SLAPI_DBSIZE +SLAPI_DBVERIFY_DBDIR +SLAPI_DESTROY_CONTENT +SLAPI_DSE_DONT_CHECK_DUPS +SLAPI_DSE_DONT_WRITE_WHEN_ADDING +SLAPI_DSE_IS_PRIMARY_FILE +SLAPI_DSE_MERGE_WHEN_ADDING +SLAPI_DSE_REAPPLY_MODS +SLAPI_ENTRY_POST_OP +SLAPI_ENTRY_PRE_OP +SLAPI_EXT_OP_REQ_OID +SLAPI_EXT_OP_REQ_VALUE +SLAPI_EXT_OP_RET_OID +SLAPI_EXT_OP_RET_VALUE +SLAPI_IS_LEGACY_REPLICATED_OPERATION +SLAPI_IS_MMR_REPLICATED_OPERATION +SLAPI_IS_REPLICATED_OPERATION +SLAPI_LDIF2DB_ENCRYPT +SLAPI_LDIF2DB_EXCLUDE +SLAPI_LDIF2DB_FILE +SLAPI_LDIF2DB_GENERATE_UNIQUEID +SLAPI_LDIF2DB_INCLUDE +SLAPI_LDIF2DB_NAMESPACEID +SLAPI_LDIF2DB_NOATTRINDEXES +SLAPI_LDIF2DB_REMOVEDUPVALS +SLAPI_MANAGEDSAIT +SLAPI_MODIFY_MODS +SLAPI_MODRDN_DELOLDRDN +SLAPI_MODRDN_NEWPARENT_ENTRY +SLAPI_MODRDN_NEWRDN +SLAPI_MODRDN_NEWSUPERIOR_ADDRESS +SLAPI_MODRDN_NEWSUPERIOR +SLAPI_MODRDN_NEWSUPERIOR_SDN +SLAPI_MODRDN_PARENT_ENTRY +SLAPI_MODRDN_TARGET_ENTRY +SLAPI_NENTRIES +SLAPI_OPERATION +SLAPI_OPERATION_AUTHTYPE +SLAPI_OPERATION_ID +SLAPI_OPERATION_NOTES +SLAPI_OPERATION_PARAMETERS +SLAPI_OPERATION_SSF +SLAPI_OPERATION_TYPE +SLAPI_OPINITIATED_TIME +SLAPI_ORIGINAL_TARGET_DN +SLAPI_PAGED_RESULTS_COOKIE +SLAPI_PAGED_RESULTS_INDEX +SLAPI_PARENT_TXN +SLAPI_PB_RESULT_TEXT +SLAPI_PLUGIN +SLAPI_PLUGIN_ACL_ALLOW_ACCESS +SLAPI_PLUGIN_ACL_INIT +SLAPI_PLUGIN_ACL_MODS_ALLOWED +SLAPI_PLUGIN_ACL_MODS_UPDATE +SLAPI_PLUGIN_ACL_SYNTAX_CHECK +SLAPI_PLUGIN_ARGC +SLAPI_PLUGIN_ARGV +SLAPI_PLUGIN_BE_POST_ADD_FN +SLAPI_PLUGIN_BE_POST_BACKUP_FN +SLAPI_PLUGIN_BE_POST_DELETE_FN +SLAPI_PLUGIN_BE_POST_MODIFY_FN +SLAPI_PLUGIN_BE_POST_MODRDN_FN +SLAPI_PLUGIN_BE_POST_OPEN_FN +SLAPI_PLUGIN_BE_PRE_ADD_FN +SLAPI_PLUGIN_BE_PRE_BACKUP_FN +SLAPI_PLUGIN_BE_PRE_CLOSE_FN +SLAPI_PLUGIN_BE_PRE_DELETE_FN +SLAPI_PLUGIN_BE_PRE_MODIFY_FN +SLAPI_PLUGIN_BE_PRE_MODRDN_FN +SLAPI_PLUGIN_BE_TXN_POST_ADD_FN +SLAPI_PLUGIN_BE_TXN_POST_DELETE_FN +SLAPI_PLUGIN_BE_TXN_POST_MODIFY_FN +SLAPI_PLUGIN_BE_TXN_POST_MODRDN_FN +SLAPI_PLUGIN_BE_TXN_PRE_ADD_FN +SLAPI_PLUGIN_BE_TXN_PRE_DELETE_FN +SLAPI_PLUGIN_BE_TXN_PRE_DELETE_TOMBSTONE_FN +SLAPI_PLUGIN_BE_TXN_PRE_MODIFY_FN +SLAPI_PLUGIN_BE_TXN_PRE_MODRDN_FN +SLAPI_PLUGIN_CLEANUP_FN +SLAPI_PLUGIN_CLOSE_FN +SLAPI_PLUGIN_CONFIG_AREA +SLAPI_PLUGIN_CONFIG_DN +SLAPI_PLUGIN_DB_ABANDON_FN +SLAPI_PLUGIN_DB_ABORT_FN +SLAPI_PLUGIN_DB_ADD_FN +SLAPI_PLUGIN_DB_ADD_SCHEMA_FN +SLAPI_PLUGIN_DB_ARCHIVE2DB_FN +SLAPI_PLUGIN_DB_BEGIN_FN +SLAPI_PLUGIN_DB_BIND_FN +SLAPI_PLUGIN_DB_COMMIT_FN +SLAPI_PLUGIN_DB_COMPARE_FN +SLAPI_PLUGIN_DB_CONFIG_FN +SLAPI_PLUGIN_DB_CTRL_INFO_FN +SLAPI_PLUGIN_DB_DB2ARCHIVE_FN +SLAPI_PLUGIN_DB_DB2INDEX_FN +SLAPI_PLUGIN_DB_DB2LDIF_FN +SLAPI_PLUGIN_DB_DBVERIFY_FN +SLAPI_PLUGIN_DB_DELETE_FN +SLAPI_PLUGIN_DB_ENTRY_FN +SLAPI_PLUGIN_DB_ENTRY_RELEASE_FN +SLAPI_PLUGIN_DB_FLUSH_FN +SLAPI_PLUGIN_DB_GET_INFO_FN +SLAPI_PLUGIN_DB_INIT_INSTANCE_FN +SLAPI_PLUGIN_DB_LDIF2DB_FN +SLAPI_PLUGIN_DB_MODIFY_FN +SLAPI_PLUGIN_DB_MODRDN_FN +SLAPI_PLUGIN_DB_NEXT_SEARCH_ENTRY_EXT_FN +SLAPI_PLUGIN_DB_NEXT_SEARCH_ENTRY_FN +SLAPI_PLUGIN_DB_NO_ACL +SLAPI_PLUGIN_DB_PREV_SEARCH_RESULTS_FN +SLAPI_PLUGIN_DB_REFERRAL_FN +SLAPI_PLUGIN_DB_RESULT_FN +SLAPI_PLUGIN_DB_RMDB_FN +SLAPI_PLUGIN_DB_SEARCH_FN +SLAPI_PLUGIN_DB_SEARCH_RESULTS_RELEASE_FN +SLAPI_PLUGIN_DB_SEQ_FN +SLAPI_PLUGIN_DB_SET_INFO_FN +SLAPI_PLUGIN_DB_SIZE_FN +SLAPI_PLUGIN_DB_TEST_FN +SLAPI_PLUGIN_DB_UNBIND_FN +SLAPI_PLUGIN_DB_UPGRADEDB_FN +SLAPI_PLUGIN_DB_UPGRADEDNFORMAT_FN +SLAPI_PLUGIN_DB_WIRE_IMPORT_FN +SLAPI_PLUGIN_DESCRIPTION +SLAPI_PLUGIN_DESTROY_FN +SLAPI_PLUGIN_ENABLED +SLAPI_PLUGIN_ENTRY_FETCH_FUNC +SLAPI_PLUGIN_ENTRY_STORE_FUNC +SLAPI_PLUGIN_EXT_OP_BACKEND_FN +SLAPI_PLUGIN_EXT_OP_FN +SLAPI_PLUGIN_EXT_OP_NAMELIST +SLAPI_PLUGIN_EXT_OP_OIDLIST +SLAPI_PLUGIN_IDENTITY +SLAPI_PLUGIN_INTERNAL_POST_ADD_FN +SLAPI_PLUGIN_INTERNAL_POST_DELETE_FN +SLAPI_PLUGIN_INTERNAL_POST_MODIFY_FN +SLAPI_PLUGIN_INTERNAL_POST_MODRDN_FN +SLAPI_PLUGIN_INTERNAL_PRE_ADD_FN +SLAPI_PLUGIN_INTERNAL_PRE_BIND_FN +SLAPI_PLUGIN_INTERNAL_PRE_DELETE_FN +SLAPI_PLUGIN_INTERNAL_PRE_MODIFY_FN +SLAPI_PLUGIN_INTERNAL_PRE_MODRDN_FN +SLAPI_PLUGIN_INTOP_RESULT +SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES +SLAPI_PLUGIN_INTOP_SEARCH_REFERRALS +SLAPI_PLUGIN_MR_ASSERTION2KEYS_AVA +SLAPI_PLUGIN_MR_ASSERTION2KEYS_SUB +SLAPI_PLUGIN_MR_COMPARE +SLAPI_PLUGIN_MR_FILTER_AVA +SLAPI_PLUGIN_MR_FILTER_CREATE_FN +SLAPI_PLUGIN_MR_FILTER_INDEX_FN +SLAPI_PLUGIN_MR_FILTER_MATCH_FN +SLAPI_PLUGIN_MR_FILTER_RESET_FN +SLAPI_PLUGIN_MR_FILTER_REUSABLE +SLAPI_PLUGIN_MR_FILTER_SUB +SLAPI_PLUGIN_MR_FLAGS +SLAPI_PLUGIN_MR_INDEXER_CREATE_FN +SLAPI_PLUGIN_MR_INDEX_FN +SLAPI_PLUGIN_MR_INDEX_SV_FN +SLAPI_PLUGIN_MR_KEYS +SLAPI_PLUGIN_MR_NAMES +SLAPI_PLUGIN_MR_NORMALIZE +SLAPI_PLUGIN_MR_OID +SLAPI_PLUGIN_MR_QUERY_OPERATOR +SLAPI_PLUGIN_MR_TYPE +SLAPI_PLUGIN_MR_USAGE +SLAPI_PLUGIN_MR_VALUE +SLAPI_PLUGIN_MR_VALUES +SLAPI_PLUGIN_MR_VALUES2KEYS +SLAPI_PLUGIN_OBJECT +SLAPI_PLUGIN_OPRETURN +SLAPI_PLUGIN_POST_ABANDON_FN +SLAPI_PLUGIN_POST_ADD_FN +SLAPI_PLUGIN_POST_BIND_FN +SLAPI_PLUGIN_POST_COMPARE_FN +SLAPI_PLUGIN_POST_DELETE_FN +SLAPI_PLUGIN_POST_ENTRY_FN +SLAPI_PLUGIN_POST_EXTOP_FN +SLAPI_PLUGIN_POST_MODIFY_FN +SLAPI_PLUGIN_POST_MODRDN_FN +SLAPI_PLUGIN_POST_REFERRAL_FN +SLAPI_PLUGIN_POST_RESULT_FN +SLAPI_PLUGIN_POST_SEARCH_FAIL_FN +SLAPI_PLUGIN_POST_SEARCH_FN +SLAPI_PLUGIN_POSTSTART_FN +SLAPI_PLUGIN_POST_UNBIND_FN +SLAPI_PLUGIN_PRE_ABANDON_FN +SLAPI_PLUGIN_PRE_ADD_FN +SLAPI_PLUGIN_PRE_BIND_FN +SLAPI_PLUGIN_PRECEDENCE +SLAPI_PLUGIN_PRE_COMPARE_FN +SLAPI_PLUGIN_PRE_DELETE_FN +SLAPI_PLUGIN_PRE_ENTRY_FN +SLAPI_PLUGIN_PRE_EXTOP_FN +SLAPI_PLUGIN_PRE_MODIFY_FN +SLAPI_PLUGIN_PRE_MODRDN_FN +SLAPI_PLUGIN_PRE_REFERRAL_FN +SLAPI_PLUGIN_PRE_RESULT_FN +SLAPI_PLUGIN_PRE_SEARCH_FN +SLAPI_PLUGIN_PRE_UNBIND_FN +SLAPI_PLUGIN_PRIVATE +SLAPI_PLUGIN_PWD_STORAGE_SCHEME_CMP_FN +SLAPI_PLUGIN_PWD_STORAGE_SCHEME_DB_PWD +SLAPI_PLUGIN_PWD_STORAGE_SCHEME_DEC_FN +SLAPI_PLUGIN_PWD_STORAGE_SCHEME_ENC_FN +SLAPI_PLUGIN_PWD_STORAGE_SCHEME_NAME +SLAPI_PLUGIN_PWD_STORAGE_SCHEME_USER_PWD +SLAPI_PLUGIN_START_FN +SLAPI_PLUGIN_SYNTAX_ASSERTION2KEYS_AVA +SLAPI_PLUGIN_SYNTAX_ASSERTION2KEYS_SUB +SLAPI_PLUGIN_SYNTAX_COMPARE +SLAPI_PLUGIN_SYNTAX_FILTER_AVA +SLAPI_PLUGIN_SYNTAX_FILTER_DATA +SLAPI_PLUGIN_SYNTAX_FILTER_NORMALIZED +SLAPI_PLUGIN_SYNTAX_FILTER_SUB +SLAPI_PLUGIN_SYNTAX_FLAGS +SLAPI_PLUGIN_SYNTAX_NAMES +SLAPI_PLUGIN_SYNTAX_NORMALIZE +SLAPI_PLUGIN_SYNTAX_OID +SLAPI_PLUGIN_SYNTAX_VALIDATE +SLAPI_PLUGIN_SYNTAX_VALUES2KEYS +SLAPI_PLUGIN_TYPE +SLAPI_PLUGIN_VERSION +SLAPI_PWPOLICY +SLAPI_REQCONTROLS +SLAPI_REQUESTOR_DN +SLAPI_REQUESTOR_ISROOT +SLAPI_REQUESTOR_NDN +SLAPI_REQUESTOR_SDN +SLAPI_RESCONTROLS +SLAPI_RESULT_CODE +SLAPI_RESULT_MATCHED +SLAPI_RESULT_TEXT +SLAPI_SCHEMA_FLAGS +SLAPI_SEARCH_ATTRS +SLAPI_SEARCH_ATTRSONLY +SLAPI_SEARCH_CTRLS +SLAPI_SEARCH_DEREF +SLAPI_SEARCH_FILTER +SLAPI_SEARCH_GERATTRS +SLAPI_SEARCH_IS_AND +SLAPI_SEARCH_REFERRALS +SLAPI_SEARCH_REQATTRS +SLAPI_SEARCH_RESULT_ENTRY +SLAPI_SEARCH_RESULT_ENTRY_EXT +SLAPI_SEARCH_RESULT_SET +SLAPI_SEARCH_RESULT_SET_SIZE_ESTIMATE +SLAPI_SEARCH_SCOPE +SLAPI_SEARCH_SIZELIMIT +SLAPI_SEARCH_STRFILTER +SLAPI_SEARCH_TIMELIMIT +SLAPI_SEQ_ATTRNAME +SLAPI_SEQ_TYPE +SLAPI_SEQ_VAL +SLAPI_SKIP_MODIFIED_ATTRS +SLAPI_SYNTAX_SUBSTRLENS +SLAPI_TARGET_ADDRESS +SLAPI_TARGET_DN +SLAPI_TARGET_SDN +SLAPI_TARGET_UNIQUEID +SLAPI_TASK_FLAGS +SLAPI_TXN +SLAPI_TXN_RUV_MODS_FN +SLAPI_URP_NAMING_COLLISION_DN +SLAPI_URP_TOMBSTONE_UNIQUEID diff --git a/test/libslapd/pblock/pblock_accessors_freq.txt b/test/libslapd/pblock/pblock_accessors_freq.txt new file mode 100644 index 0000000..b98f848 --- /dev/null +++ b/test/libslapd/pblock/pblock_accessors_freq.txt @@ -0,0 +1,638 @@ +SLAPI_ABANDON_MSGID +10 +SLAPI_ACI_TARGET_CHECK +9 +SLAPI_ADD_ENTRY +60 +SLAPI_ADD_EXISTING_DN_ENTRY +21 +SLAPI_ADD_EXISTING_UNIQUEID_ENTRY +12 +SLAPI_ADD_PARENT_ENTRY +14 +SLAPI_ADD_PARENT_UNIQUEID +7 +SLAPI_ADD_RESCONTROL +23 +SLAPI_ARGC +12 +SLAPI_ARGV +11 +SLAPI_BACKEND +163 +SLAPI_BACKEND_COUNT +13 +SLAPI_BACKEND_INSTANCE_NAME +14 +SLAPI_BACKEND_TASK +14 +SLAPI_BE_LASTMOD +10 +SLAPI_BE_MAXNESTLEVEL +7 +SLAPI_BE_READONLY +7 +SLAPI_BE_TYPE +7 +SLAPI_BIND_CREDENTIALS +24 +SLAPI_BIND_METHOD +22 +SLAPI_BIND_RET_SASLCREDS +13 +SLAPI_BIND_SASLMECHANISM +11 +SLAPI_BULK_IMPORT_ENTRY +10 +SLAPI_BULK_IMPORT_STATE +12 +SLAPI_CLIENT_DNS +12 +SLAPI_COMPARE_TYPE +11 +SLAPI_COMPARE_VALUE +11 +SLAPI_CONFIG_ARGC +6 +SLAPI_CONFIG_ARGV +6 +SLAPI_CONFIG_DIRECTORY +10 +SLAPI_CONFIG_FILENAME +6 +SLAPI_CONFIG_LINENO +6 +SLAPI_CONN_AUTHMETHOD +18 +SLAPI_CONN_AUTHTYPE +8 +SLAPI_CONN_CERT +8 +SLAPI_CONN_CLIENTIP +4 +SLAPI_CONN_CLIENTNETADDR +12 +SLAPI_CONN_DN +28 +SLAPI_CONNECTION +36 +SLAPI_CONN_ID +31 +SLAPI_CONN_IS_REPLICATION_SESSION +13 +SLAPI_CONN_IS_SSL_SESSION +8 +SLAPI_CONN_LOCAL_SSF +9 +SLAPI_CONN_SASL_SSF +9 +SLAPI_CONN_SERVERIP +4 +SLAPI_CONN_SERVERNETADDR +8 +SLAPI_CONN_SSL_SSF +7 +SLAPI_CONTROLS_ARG +30 +SLAPI_DB2INDEX_ATTRS +8 +SLAPI_DB2LDIF_DECRYPT +8 +SLAPI_DB2LDIF_DUMP_UNIQUEID +8 +SLAPI_DB2LDIF_FILE +7 +SLAPI_DB2LDIF_PRINTKEY +8 +SLAPI_DB2LDIF_SERVER_RUNNING +10 +SLAPI_DBSIZE +9 +SLAPI_DBVERIFY_DBDIR +8 +SLAPI_DESTROY_CONTENT +7 +SLAPI_DSE_DONT_CHECK_DUPS +9 +SLAPI_DSE_DONT_WRITE_WHEN_ADDING +19 +SLAPI_DSE_IS_PRIMARY_FILE +9 +SLAPI_DSE_MERGE_WHEN_ADDING +9 +SLAPI_DSE_REAPPLY_MODS +10 +SLAPI_ENTRY_POST_OP +61 +SLAPI_ENTRY_PRE_OP +60 +SLAPI_EXT_OP_REQ_OID +20 +SLAPI_EXT_OP_REQ_VALUE +19 +SLAPI_EXT_OP_RET_OID +18 +SLAPI_EXT_OP_RET_VALUE +19 +SLAPI_IS_LEGACY_REPLICATED_OPERATION +7 +SLAPI_IS_MMR_REPLICATED_OPERATION +7 +SLAPI_IS_REPLICATED_OPERATION +48 +SLAPI_LDIF2DB_ENCRYPT +10 +SLAPI_LDIF2DB_EXCLUDE +7 +SLAPI_LDIF2DB_FILE +8 +SLAPI_LDIF2DB_GENERATE_UNIQUEID +12 +SLAPI_LDIF2DB_INCLUDE +7 +SLAPI_LDIF2DB_NAMESPACEID +9 +SLAPI_LDIF2DB_NOATTRINDEXES +8 +SLAPI_LDIF2DB_REMOVEDUPVALS +8 +SLAPI_MANAGEDSAIT +24 +SLAPI_MODIFY_MODS +88 +SLAPI_MODRDN_DELOLDRDN +21 +SLAPI_MODRDN_NEWPARENT_ENTRY +12 +SLAPI_MODRDN_NEWRDN +34 +SLAPI_MODRDN_NEWSUPERIOR_ADDRESS +9 +SLAPI_MODRDN_NEWSUPERIOR +46 +SLAPI_MODRDN_NEWSUPERIOR_SDN +30 +SLAPI_MODRDN_PARENT_ENTRY +11 +SLAPI_MODRDN_TARGET_ENTRY +14 +SLAPI_NENTRIES +18 +SLAPI_OPERATION +790 +SLAPI_OPERATION_AUTHTYPE +7 +SLAPI_OPERATION_ID +20 +SLAPI_OPERATION_NOTES +19 +SLAPI_OPERATION_PARAMETERS +18 +SLAPI_OPERATION_SSF +7 +SLAPI_OPERATION_TYPE +22 +SLAPI_OPINITIATED_TIME +16 +SLAPI_ORIGINAL_TARGET_DN +27 +SLAPI_PAGED_RESULTS_COOKIE +9 +SLAPI_PAGED_RESULTS_INDEX +20 +SLAPI_PARENT_TXN +8 +SLAPI_PB_RESULT_TEXT +88 +SLAPI_PLUGIN +3961 +SLAPI_PLUGIN_ACL_ALLOW_ACCESS +9 +SLAPI_PLUGIN_ACL_INIT +7 +SLAPI_PLUGIN_ACL_MODS_ALLOWED +9 +SLAPI_PLUGIN_ACL_MODS_UPDATE +9 +SLAPI_PLUGIN_ACL_SYNTAX_CHECK +9 +SLAPI_PLUGIN_ARGC +18 +SLAPI_PLUGIN_ARGV +21 +SLAPI_PLUGIN_BE_POST_ADD_FN +12 +SLAPI_PLUGIN_BE_POST_BACKUP_FN +12 +SLAPI_PLUGIN_BE_POST_DELETE_FN +13 +SLAPI_PLUGIN_BE_POST_MODIFY_FN +12 +SLAPI_PLUGIN_BE_POST_MODRDN_FN +12 +SLAPI_PLUGIN_BE_POST_OPEN_FN +12 +SLAPI_PLUGIN_BE_PRE_ADD_FN +14 +SLAPI_PLUGIN_BE_PRE_BACKUP_FN +11 +SLAPI_PLUGIN_BE_PRE_CLOSE_FN +11 +SLAPI_PLUGIN_BE_PRE_DELETE_FN +12 +SLAPI_PLUGIN_BE_PRE_MODIFY_FN +16 +SLAPI_PLUGIN_BE_PRE_MODRDN_FN +12 +SLAPI_PLUGIN_BE_TXN_POST_ADD_FN +25 +SLAPI_PLUGIN_BE_TXN_POST_DELETE_FN +27 +SLAPI_PLUGIN_BE_TXN_POST_MODIFY_FN +26 +SLAPI_PLUGIN_BE_TXN_POST_MODRDN_FN +26 +SLAPI_PLUGIN_BE_TXN_PRE_ADD_FN +21 +SLAPI_PLUGIN_BE_TXN_PRE_DELETE_FN +16 +SLAPI_PLUGIN_BE_TXN_PRE_DELETE_TOMBSTONE_FN +10 +SLAPI_PLUGIN_BE_TXN_PRE_MODIFY_FN +22 +SLAPI_PLUGIN_BE_TXN_PRE_MODRDN_FN +15 +SLAPI_PLUGIN_CLEANUP_FN +12 +SLAPI_PLUGIN_CLOSE_FN +55 +SLAPI_PLUGIN_CONFIG_AREA +17 +SLAPI_PLUGIN_CONFIG_DN +5 +SLAPI_PLUGIN_DB_ABANDON_FN +10 +SLAPI_PLUGIN_DB_ABORT_FN +8 +SLAPI_PLUGIN_DB_ADD_FN +11 +SLAPI_PLUGIN_DB_ADD_SCHEMA_FN +6 +SLAPI_PLUGIN_DB_ARCHIVE2DB_FN +9 +SLAPI_PLUGIN_DB_BEGIN_FN +8 +SLAPI_PLUGIN_DB_BIND_FN +11 +SLAPI_PLUGIN_DB_COMMIT_FN +8 +SLAPI_PLUGIN_DB_COMPARE_FN +11 +SLAPI_PLUGIN_DB_CONFIG_FN +8 +SLAPI_PLUGIN_DB_CTRL_INFO_FN +6 +SLAPI_PLUGIN_DB_DB2ARCHIVE_FN +9 +SLAPI_PLUGIN_DB_DB2INDEX_FN +9 +SLAPI_PLUGIN_DB_DB2LDIF_FN +9 +SLAPI_PLUGIN_DB_DBVERIFY_FN +6 +SLAPI_PLUGIN_DB_DELETE_FN +11 +SLAPI_PLUGIN_DB_ENTRY_FN +7 +SLAPI_PLUGIN_DB_ENTRY_RELEASE_FN +9 +SLAPI_PLUGIN_DB_FLUSH_FN +10 +SLAPI_PLUGIN_DB_GET_INFO_FN +6 +SLAPI_PLUGIN_DB_INIT_INSTANCE_FN +9 +SLAPI_PLUGIN_DB_LDIF2DB_FN +9 +SLAPI_PLUGIN_DB_MODIFY_FN +11 +SLAPI_PLUGIN_DB_MODRDN_FN +11 +SLAPI_PLUGIN_DB_NEXT_SEARCH_ENTRY_EXT_FN +9 +SLAPI_PLUGIN_DB_NEXT_SEARCH_ENTRY_FN +10 +SLAPI_PLUGIN_DB_NO_ACL +10 +SLAPI_PLUGIN_DB_PREV_SEARCH_RESULTS_FN +9 +SLAPI_PLUGIN_DB_REFERRAL_FN +7 +SLAPI_PLUGIN_DB_RESULT_FN +10 +SLAPI_PLUGIN_DB_RMDB_FN +10 +SLAPI_PLUGIN_DB_SEARCH_FN +11 +SLAPI_PLUGIN_DB_SEARCH_RESULTS_RELEASE_FN +9 +SLAPI_PLUGIN_DB_SEQ_FN +9 +SLAPI_PLUGIN_DB_SET_INFO_FN +6 +SLAPI_PLUGIN_DB_SIZE_FN +9 +SLAPI_PLUGIN_DB_TEST_FN +8 +SLAPI_PLUGIN_DB_UNBIND_FN +10 +SLAPI_PLUGIN_DB_UPGRADEDB_FN +6 +SLAPI_PLUGIN_DB_UPGRADEDNFORMAT_FN +6 +SLAPI_PLUGIN_DB_WIRE_IMPORT_FN +6 +SLAPI_PLUGIN_DESCRIPTION +132 +SLAPI_PLUGIN_DESTROY_FN +17 +SLAPI_PLUGIN_ENABLED +9 +SLAPI_PLUGIN_ENTRY_FETCH_FUNC +8 +SLAPI_PLUGIN_ENTRY_STORE_FUNC +8 +SLAPI_PLUGIN_EXT_OP_BACKEND_FN +8 +SLAPI_PLUGIN_EXT_OP_FN +20 +SLAPI_PLUGIN_EXT_OP_NAMELIST +19 +SLAPI_PLUGIN_EXT_OP_OIDLIST +20 +SLAPI_PLUGIN_IDENTITY +79 +SLAPI_PLUGIN_INTERNAL_POST_ADD_FN +19 +SLAPI_PLUGIN_INTERNAL_POST_DELETE_FN +19 +SLAPI_PLUGIN_INTERNAL_POST_MODIFY_FN +19 +SLAPI_PLUGIN_INTERNAL_POST_MODRDN_FN +19 +SLAPI_PLUGIN_INTERNAL_PRE_ADD_FN +11 +SLAPI_PLUGIN_INTERNAL_PRE_BIND_FN +10 +SLAPI_PLUGIN_INTERNAL_PRE_DELETE_FN +11 +SLAPI_PLUGIN_INTERNAL_PRE_MODIFY_FN +11 +SLAPI_PLUGIN_INTERNAL_PRE_MODRDN_FN +11 +SLAPI_PLUGIN_INTOP_RESULT +231 +SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES +105 +SLAPI_PLUGIN_INTOP_SEARCH_REFERRALS +9 +SLAPI_PLUGIN_MR_ASSERTION2KEYS_AVA +9 +SLAPI_PLUGIN_MR_ASSERTION2KEYS_SUB +9 +SLAPI_PLUGIN_MR_COMPARE +9 +SLAPI_PLUGIN_MR_FILTER_AVA +9 +SLAPI_PLUGIN_MR_FILTER_CREATE_FN +14 +SLAPI_PLUGIN_MR_FILTER_INDEX_FN +10 +SLAPI_PLUGIN_MR_FILTER_MATCH_FN +12 +SLAPI_PLUGIN_MR_FILTER_RESET_FN +9 +SLAPI_PLUGIN_MR_FILTER_REUSABLE +9 +SLAPI_PLUGIN_MR_FILTER_SUB +9 +SLAPI_PLUGIN_MR_FLAGS +7 +SLAPI_PLUGIN_MR_INDEXER_CREATE_FN +14 +SLAPI_PLUGIN_MR_INDEX_FN +18 +SLAPI_PLUGIN_MR_INDEX_SV_FN +12 +SLAPI_PLUGIN_MR_KEYS +29 +SLAPI_PLUGIN_MR_NAMES +9 +SLAPI_PLUGIN_MR_NORMALIZE +8 +SLAPI_PLUGIN_MR_OID +25 +SLAPI_PLUGIN_MR_QUERY_OPERATOR +13 +SLAPI_PLUGIN_MR_TYPE +20 +SLAPI_PLUGIN_MR_USAGE +19 +SLAPI_PLUGIN_MR_VALUE +42 +SLAPI_PLUGIN_MR_VALUES +31 +SLAPI_PLUGIN_MR_VALUES2KEYS +9 +SLAPI_PLUGIN_OBJECT +36 +SLAPI_PLUGIN_OPRETURN +85 +SLAPI_PLUGIN_POST_ABANDON_FN +10 +SLAPI_PLUGIN_POST_ADD_FN +23 +SLAPI_PLUGIN_POST_BIND_FN +20 +SLAPI_PLUGIN_POST_COMPARE_FN +9 +SLAPI_PLUGIN_POST_DELETE_FN +23 +SLAPI_PLUGIN_POST_ENTRY_FN +9 +SLAPI_PLUGIN_POST_EXTOP_FN +7 +SLAPI_PLUGIN_POST_MODIFY_FN +24 +SLAPI_PLUGIN_POST_MODRDN_FN +23 +SLAPI_PLUGIN_POST_REFERRAL_FN +9 +SLAPI_PLUGIN_POST_RESULT_FN +9 +SLAPI_PLUGIN_POST_SEARCH_FAIL_FN +9 +SLAPI_PLUGIN_POST_SEARCH_FN +11 +SLAPI_PLUGIN_POSTSTART_FN +9 +SLAPI_PLUGIN_POST_UNBIND_FN +9 +SLAPI_PLUGIN_PRE_ABANDON_FN +10 +SLAPI_PLUGIN_PRE_ADD_FN +21 +SLAPI_PLUGIN_PRE_BIND_FN +27 +SLAPI_PLUGIN_PRECEDENCE +8 +SLAPI_PLUGIN_PRE_COMPARE_FN +12 +SLAPI_PLUGIN_PRE_DELETE_FN +17 +SLAPI_PLUGIN_PRE_ENTRY_FN +14 +SLAPI_PLUGIN_PRE_EXTOP_FN +7 +SLAPI_PLUGIN_PRE_MODIFY_FN +22 +SLAPI_PLUGIN_PRE_MODRDN_FN +17 +SLAPI_PLUGIN_PRE_REFERRAL_FN +9 +SLAPI_PLUGIN_PRE_RESULT_FN +10 +SLAPI_PLUGIN_PRE_SEARCH_FN +19 +SLAPI_PLUGIN_PRE_UNBIND_FN +9 +SLAPI_PLUGIN_PRIVATE +67 +SLAPI_PLUGIN_PWD_STORAGE_SCHEME_CMP_FN +23 +SLAPI_PLUGIN_PWD_STORAGE_SCHEME_DB_PWD +7 +SLAPI_PLUGIN_PWD_STORAGE_SCHEME_DEC_FN +9 +SLAPI_PLUGIN_PWD_STORAGE_SCHEME_ENC_FN +23 +SLAPI_PLUGIN_PWD_STORAGE_SCHEME_NAME +23 +SLAPI_PLUGIN_PWD_STORAGE_SCHEME_USER_PWD +7 +SLAPI_PLUGIN_START_FN +55 +SLAPI_PLUGIN_SYNTAX_ASSERTION2KEYS_AVA +23 +SLAPI_PLUGIN_SYNTAX_ASSERTION2KEYS_SUB +20 +SLAPI_PLUGIN_SYNTAX_COMPARE +21 +SLAPI_PLUGIN_SYNTAX_FILTER_AVA +23 +SLAPI_PLUGIN_SYNTAX_FILTER_DATA +9 +SLAPI_PLUGIN_SYNTAX_FILTER_NORMALIZED +29 +SLAPI_PLUGIN_SYNTAX_FILTER_SUB +20 +SLAPI_PLUGIN_SYNTAX_FLAGS +23 +SLAPI_PLUGIN_SYNTAX_NAMES +23 +SLAPI_PLUGIN_SYNTAX_NORMALIZE +21 +SLAPI_PLUGIN_SYNTAX_OID +23 +SLAPI_PLUGIN_SYNTAX_VALIDATE +21 +SLAPI_PLUGIN_SYNTAX_VALUES2KEYS +23 +SLAPI_PLUGIN_TYPE +19 +SLAPI_PLUGIN_VERSION +246 +SLAPI_PWPOLICY +20 +SLAPI_REQCONTROLS +43 +SLAPI_REQUESTOR_DN +29 +SLAPI_REQUESTOR_ISROOT +42 +SLAPI_REQUESTOR_NDN +8 +SLAPI_REQUESTOR_SDN +8 +SLAPI_RESCONTROLS +15 +SLAPI_RESULT_CODE +141 +SLAPI_RESULT_MATCHED +11 +SLAPI_RESULT_TEXT +12 +SLAPI_SCHEMA_FLAGS +13 +SLAPI_SEARCH_ATTRS +57 +SLAPI_SEARCH_ATTRSONLY +25 +SLAPI_SEARCH_CTRLS +16 +SLAPI_SEARCH_DEREF +13 +SLAPI_SEARCH_FILTER +30 +SLAPI_SEARCH_GERATTRS +13 +SLAPI_SEARCH_IS_AND +12 +SLAPI_SEARCH_REFERRALS +12 +SLAPI_SEARCH_REQATTRS +9 +SLAPI_SEARCH_RESULT_ENTRY +63 +SLAPI_SEARCH_RESULT_ENTRY_EXT +17 +SLAPI_SEARCH_RESULT_SET +61 +SLAPI_SEARCH_RESULT_SET_SIZE_ESTIMATE +18 +SLAPI_SEARCH_SCOPE +37 +SLAPI_SEARCH_SIZELIMIT +20 +SLAPI_SEARCH_STRFILTER +24 +SLAPI_SEARCH_TIMELIMIT +23 +SLAPI_SEQ_ATTRNAME +12 +SLAPI_SEQ_TYPE +20 +SLAPI_SEQ_VAL +23 +SLAPI_SKIP_MODIFIED_ATTRS +9 +SLAPI_SYNTAX_SUBSTRLENS +14 +SLAPI_TARGET_ADDRESS +15 +SLAPI_TARGET_DN +47 +SLAPI_TARGET_SDN +104 +SLAPI_TARGET_UNIQUEID +27 +SLAPI_TASK_FLAGS +15 +SLAPI_TXN +78 +SLAPI_TXN_RUV_MODS_FN +14 +SLAPI_URP_NAMING_COLLISION_DN +13 +SLAPI_URP_TOMBSTONE_UNIQUEID +10 diff --git a/test/pblock_analyse.py b/test/pblock_analyse.py new file mode 100644 index 0000000..4effedc --- /dev/null +++ b/test/pblock_analyse.py @@ -0,0 +1,108 @@ +#!/usr/bin/python + +# Display stats about pblock usage. + +def parse(filepath): + results = [] + flat_results = [] + # Read the file + with open(filepath, 'r') as f: + # For each line + for l in f.readlines(): + pbc = {} + pbs = set() + # Trim the line. + ls = l.strip() + for access in ls.split(','): + if len(access.strip()) == 0: + continue + k, count = access.split(':') + pbc[k] = int(count) + pbs.add(k) + if (pbc not in results): + results.append(pbc) + if (pbs not in flat_results): + flat_results.append(pbs) + #print(pbc) + return results, flat_results + +def determine_pblock_groups(flat_results): + # This function will take the flattened results, and calculate a unique + # set of pblock parameter combinations that may exist. + # Make a set of all possible access values. + results = {} + access_values = set() + for pbs in flat_results: + access_values.update(pbs) + + print('all possible values %s' % access_values) + # For each access value + for av in access_values: + results[av] = 0 + for s in flat_results: + if av in s: + results[av] += 1 + # Count the number of sets that contain it. + # Sort by most popular access values. + # Take the first pblock. + # take it's first value. + # make a new set + for r in sorted(results, key=results.get, reverse=True): + print('pop: av %s count %s' % (r, results[r])) + + # Find things that are subsets, and eliminate them. + ss_flat_results = [] + for pbs_a in flat_results: + subset = False + for pbs_b in flat_results: + if pbs_a.issubset(pbs_b) and pbs_a != pbs_b: + subset = True + if subset is False: + ss_flat_results.append(pbs_a) + + #for pbs in sorted(ss_flat_results, key=len): + # print(pbs) + + # Now, we can group these by plugin callback, and searches. + # Check for plugin_enabled + plugin_set = set() + search_set = set() + other_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 + search_set.update(pbs) + else: + other_set.update(pbs) + + overlap_set = plugin_set & search_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))) + 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(): + # Read the file + results, flat_results = parse('/tmp/pblock_stats.csv') + # Results is now a flat set of pblocks. + for pbs in flat_results: + print(pbs) + determine_pblock_groups(flat_results) + + + +if __name__ == '__main__': + analyse() -- 1.8.3.1