From fc233b91682f1d849568326bdd690b0afd57d6db Mon Sep 17 00:00:00 2001 From: Jakub Hrozek Date: Tue, 1 Dec 2015 23:25:05 +0100 Subject: [PATCH 06/10] LDAP: Decorate the hot paths in the LDAP provider with systemtap probes During performance analysis, the LDAP provider and especially its nested group code proved to be the place where we spend the most time during account requests. Therefore, I decorated the LDAP provider with systemtap probes to be able to observe where the time is spent. The code allows passing of search properties (base, filter, ...) from marks to probes. Where applicable, the probes pass on these arguments to functions and build a human-readable string representation. --- Makefile.am | 6 + src/providers/ldap/ldap_id.c | 11 ++ src/providers/ldap/sdap_async.c | 17 ++ src/providers/ldap/sdap_async_groups.c | 7 + src/providers/ldap/sdap_async_nested_groups.c | 38 +++++ src/providers/ldap/sdap_async_users.c | 8 + src/systemtap/sssd.stp.in | 224 ++++++++++++++++++++++++++ src/systemtap/sssd_probes.d | 62 +++++++ 8 files changed, 373 insertions(+) diff --git a/Makefile.am b/Makefile.am index 9565ba73d6167e93be37c13c2169d41e673f1916..6fa83c9b44db475a0b07a07dbdefddc45107c7a7 100644 --- a/Makefile.am +++ b/Makefile.am @@ -2180,6 +2180,9 @@ nestedgroups_tests_LDADD = \ libsss_idmap.la \ libsss_test_common.la \ $(NULL) +if BUILD_SYSTEMTAP +nestedgroups_tests_LDADD += stap_generated_probes.lo +endif test_sss_idmap_SOURCES = \ src/tests/cmocka/test_sss_idmap.c @@ -2999,6 +3002,9 @@ libsss_ldap_common_la_LIBADD = \ libsss_ldap_common_la_LDFLAGS = \ -avoid-version \ $(NULL) +if BUILD_SYSTEMTAP +libsss_ldap_common_la_LIBADD += stap_generated_probes.lo +endif if BUILD_SUDO libsss_ldap_common_la_SOURCES += \ diff --git a/src/providers/ldap/ldap_id.c b/src/providers/ldap/ldap_id.c index 8923e7e0c3fdae4614d6bfef2665de7854b62e8e..ee5b374db2af69325d03a6fe0fcf33990fe9afa0 100644 --- a/src/providers/ldap/ldap_id.c +++ b/src/providers/ldap/ldap_id.c @@ -27,6 +27,7 @@ #include #include "util/util.h" +#include "util/probes.h" #include "util/strtonum.h" #include "util/cert.h" #include "db/sysdb.h" @@ -1509,6 +1510,11 @@ sdap_handle_acct_req_send(TALLOC_CTX *mem_ctx, goto done; } + PROBE(SDAP_ACCT_REQ_SEND, + state->ar->entry_type & BE_REQ_TYPE_MASK, + state->ar->filter_type, state->ar->filter_value, + PROBE_SAFE_STR(state->ar->extra_value)); + switch (ar->entry_type & BE_REQ_TYPE_MASK) { case BE_REQ_USER: /* user */ subreq = users_get_send(state, be_ctx->ev, id_ctx, @@ -1730,6 +1736,11 @@ sdap_handle_acct_req_recv(struct tevent_req *req, state = tevent_req_data(req, struct sdap_handle_acct_req_state); + PROBE(SDAP_ACCT_REQ_RECV, + state->ar->entry_type & BE_REQ_TYPE_MASK, + state->ar->filter_type, state->ar->filter_value, + PROBE_SAFE_STR(state->ar->extra_value)); + if (_dp_error) { *_dp_error = state->dp_error; } diff --git a/src/providers/ldap/sdap_async.c b/src/providers/ldap/sdap_async.c index d15a2215a6191ed5fd6cd01a030b31bd098ea074..0c67e54c8a981442b7983a3f68db1bde3a2a6280 100644 --- a/src/providers/ldap/sdap_async.c +++ b/src/providers/ldap/sdap_async.c @@ -23,6 +23,7 @@ #include #include "util/util.h" #include "util/strtonum.h" +#include "util/probes.h" #include "providers/ldap/sdap_async_private.h" #define REPLY_REALLOC_INCREMENT 10 @@ -1295,6 +1296,9 @@ sdap_get_generic_ext_send(TALLOC_CTX *memctx, } state->serverctrls[i] = NULL; + PROBE(SDAP_GET_GENERIC_EXT_SEND, state->search_base, + state->scope, state->filter); + ret = sdap_get_generic_ext_step(req); if (ret != EOK) { tevent_req_error(req, ret); @@ -1632,6 +1636,9 @@ sdap_get_generic_ext_recv(struct tevent_req *req, struct sdap_get_generic_ext_state *state = tevent_req_data(req, struct sdap_get_generic_ext_state); + PROBE(SDAP_GET_GENERIC_EXT_RECV, state->search_base, + state->scope, state->filter); + TEVENT_REQ_RETURN_ON_ERROR(req); if (ref_count) { @@ -2773,6 +2780,9 @@ enum sdap_deref_type { struct sdap_deref_search_state { struct sdap_handle *sh; + const char *base_dn; + const char *deref_attr; + size_t reply_count; struct sdap_deref_attrs **reply; enum sdap_deref_type deref_type; @@ -2868,6 +2878,10 @@ sdap_deref_search_send(TALLOC_CTX *memctx, state->sh = sh; state->reply_count = 0; state->reply = NULL; + state->base_dn = base_dn; + state->deref_attr = deref_attr; + + PROBE(SDAP_DEREF_SEARCH_SEND, state->base_dn, state->deref_attr); if (sdap_is_control_supported(sh, LDAP_SERVER_ASQ_OID)) { DEBUG(SSSDBG_TRACE_INTERNAL, "Server supports ASQ\n"); @@ -2962,6 +2976,9 @@ int sdap_deref_search_recv(struct tevent_req *req, { struct sdap_deref_search_state *state = tevent_req_data(req, struct sdap_deref_search_state); + + PROBE(SDAP_DEREF_SEARCH_RECV, state->base_dn, state->deref_attr); + TEVENT_REQ_RETURN_ON_ERROR(req); *reply_count = state->reply_count; diff --git a/src/providers/ldap/sdap_async_groups.c b/src/providers/ldap/sdap_async_groups.c index f4633a69c7dcd2bf29778408d9e3b88bef99f6ab..86f0a7d6ef0e97568d8a0b5e14f6b65fcee6d8cb 100644 --- a/src/providers/ldap/sdap_async_groups.c +++ b/src/providers/ldap/sdap_async_groups.c @@ -22,6 +22,7 @@ */ #include "util/util.h" +#include "util/probes.h" #include "db/sysdb.h" #include "providers/ldap/sdap_async_private.h" #include "providers/ldap/ldap_common.h" @@ -2371,16 +2372,20 @@ static void sdap_nested_done(struct tevent_req *subreq) } in_transaction = true; + PROBE(SDAP_NESTED_GROUP_POPULATE_PRE); ret = sdap_nested_group_populate_users(state, state->sysdb, state->dom, state->opts, users, user_count, &ghosts); + PROBE(SDAP_NESTED_GROUP_POPULATE_POST); if (ret != EOK) { goto fail; } + PROBE(SDAP_NESTED_GROUP_SAVE_PRE); ret = sdap_save_groups(state, state->sysdb, state->dom, state->opts, groups, group_count, false, ghosts, true, &state->higher_usn); + PROBE(SDAP_NESTED_GROUP_SAVE_POST); if (ret != EOK) { goto fail; } @@ -2539,8 +2544,10 @@ static errno_t sdap_nested_group_populate_users(TALLOC_CTX *mem_ctx, ret = ENOMEM; goto done; } + PROBE(SDAP_NESTED_GROUP_POPULATE_SEARCH_USERS_PRE); ret = sysdb_search_users(tmp_ctx, user_dom, filter, search_attrs, &count, &msgs); + PROBE(SDAP_NESTED_GROUP_POPULATE_SEARCH_USERS_POST); talloc_zfree(filter); talloc_zfree(clean_orig_dn); if (ret != EOK && ret != ENOENT) { diff --git a/src/providers/ldap/sdap_async_nested_groups.c b/src/providers/ldap/sdap_async_nested_groups.c index a1690d7bd9ca5e1c19b5edf4c99bfee40d1f3e16..1ebf66067d9412b8f4bb7fd1f7aa0326f43cd9c2 100644 --- a/src/providers/ldap/sdap_async_nested_groups.c +++ b/src/providers/ldap/sdap_async_nested_groups.c @@ -30,6 +30,7 @@ #include #include "util/util.h" +#include "util/probes.h" #include "db/sysdb.h" #include "providers/ldap/ldap_common.h" #include "providers/ldap/sdap_async.h" @@ -479,7 +480,9 @@ sdap_nested_group_check_cache(struct sdap_options *opts, member_domain = sdap_domain == NULL ? domain : sdap_domain->dom; /* search in users */ + PROBE(SDAP_NESTED_GROUP_SYSDB_SEARCH_USERS_PRE); ret = sdap_nested_group_sysdb_search_users(member_domain, filter); + PROBE(SDAP_NESTED_GROUP_SYSDB_SEARCH_USERS_POST); if (ret == EOK || ret == EAGAIN) { /* user found */ *_type = SDAP_NESTED_GROUP_DN_USER; @@ -490,7 +493,9 @@ sdap_nested_group_check_cache(struct sdap_options *opts, } /* search in groups */ + PROBE(SDAP_NESTED_GROUP_SYSDB_SEARCH_GROUPS_PRE); ret = sdap_nested_group_sysdb_search_groups(member_domain, filter); + PROBE(SDAP_NESTED_GROUP_SYSDB_SEARCH_GROUPS_POST); if (ret == EOK || ret == EAGAIN) { /* group found */ *_type = SDAP_NESTED_GROUP_DN_GROUP; @@ -620,8 +625,10 @@ sdap_nested_group_split_members(TALLOC_CTX *mem_ctx, } /* check sysdb */ + PROBE(SDAP_NESTED_GROUP_CHECK_CACHE_PRE); ret = sdap_nested_group_check_cache(group_ctx->opts, group_ctx->domain, dn, &type); + PROBE(SDAP_NESTED_GROUP_CHECK_CACHE_POST); if (ret == EOK) { /* found and valid */ DEBUG(SSSDBG_TRACE_ALL, "[%s] found in cache, skipping\n", dn); @@ -795,6 +802,8 @@ sdap_nested_group_send(TALLOC_CTX *mem_ctx, errno_t ret; int i; + PROBE(SDAP_NESTED_GROUP_SEND); + req = tevent_req_create(mem_ctx, &state, struct sdap_nested_group_state); if (req == NULL) { DEBUG(SSSDBG_CRIT_FAILURE, "tevent_req_create() failed\n"); @@ -935,6 +944,7 @@ errno_t sdap_nested_group_recv(TALLOC_CTX *mem_ctx, state = tevent_req_data(req, struct sdap_nested_group_state); + PROBE(SDAP_NESTED_GROUP_RECV); TEVENT_REQ_RETURN_ON_ERROR(req); ret = sdap_nested_group_extract_hash_table(state, state->group_ctx->users, @@ -1035,6 +1045,7 @@ sdap_nested_group_process_send(TALLOC_CTX *mem_ctx, } DEBUG(SSSDBG_TRACE_INTERNAL, "About to process group [%s]\n", orig_dn); + PROBE(SDAP_NESTED_GROUP_PROCESS_SEND, state->group_dn); /* get member list, both direct and external */ state->ext_members = sdap_nested_group_ext_members(state->group_ctx->opts, @@ -1052,11 +1063,13 @@ sdap_nested_group_process_send(TALLOC_CTX *mem_ctx, } /* get members that need to be refreshed */ + PROBE(SDAP_NESTED_GROUP_PROCESS_SPLIT_PRE); ret = sdap_nested_group_split_members(state, state->group_ctx, state->nesting_level, members, &state->missing, &state->num_missing_total, &state->num_missing_groups); + PROBE(SDAP_NESTED_GROUP_PROCESS_SPLIT_POST); if (ret != EOK) { DEBUG(SSSDBG_CRIT_FAILURE, "Unable to split member list " "[%d]: %s\n", ret, sss_strerror(ret)); @@ -1178,6 +1191,13 @@ done: static errno_t sdap_nested_group_process_recv(struct tevent_req *req) { +#ifdef HAVE_SYSTEMTAP + struct sdap_nested_group_process_state *state = NULL; + state = tevent_req_data(req, struct sdap_nested_group_process_state); + + PROBE(SDAP_NESTED_GROUP_PROCESS_RECV, state->group_dn); +#endif + TEVENT_REQ_RETURN_ON_ERROR(req); return EOK; @@ -1683,6 +1703,8 @@ sdap_nested_group_lookup_user_send(TALLOC_CTX *mem_ctx, return NULL; } + PROBE(SDAP_NESTED_GROUP_LOOKUP_USER_SEND); + if (group_ctx->opts->schema_type == SDAP_SCHEMA_IPA_V1) { /* if the schema is IPA, then just shortcut and guess the name */ ret = sdap_nested_group_get_ipa_user(state, member->dn, @@ -1799,6 +1821,8 @@ static errno_t sdap_nested_group_lookup_user_recv(TALLOC_CTX *mem_ctx, struct sdap_nested_group_lookup_user_state *state = NULL; state = tevent_req_data(req, struct sdap_nested_group_lookup_user_state); + PROBE(SDAP_NESTED_GROUP_LOOKUP_USER_RECV); + TEVENT_REQ_RETURN_ON_ERROR(req); if (_user != NULL) { @@ -1830,6 +1854,8 @@ sdap_nested_group_lookup_group_send(TALLOC_CTX *mem_ctx, char *oc_list; errno_t ret; + PROBE(SDAP_NESTED_GROUP_LOOKUP_GROUP_SEND); + req = tevent_req_create(mem_ctx, &state, struct sdap_nested_group_lookup_group_state); if (req == NULL) { @@ -1941,6 +1967,8 @@ static errno_t sdap_nested_group_lookup_group_recv(TALLOC_CTX *mem_ctx, struct sdap_nested_group_lookup_group_state *state = NULL; state = tevent_req_data(req, struct sdap_nested_group_lookup_group_state); + PROBE(SDAP_NESTED_GROUP_LOOKUP_GROUP_RECV); + TEVENT_REQ_RETURN_ON_ERROR(req); if (_group != NULL) { @@ -1982,6 +2010,8 @@ sdap_nested_group_lookup_unknown_send(TALLOC_CTX *mem_ctx, return NULL; } + PROBE(SDAP_NESTED_GROUP_LOOKUP_UNKNOWN_SEND); + state->ev = ev; state->group_ctx = group_ctx; state->member = member; @@ -2109,6 +2139,8 @@ sdap_nested_group_lookup_unknown_recv(TALLOC_CTX *mem_ctx, struct sdap_nested_group_lookup_unknown_state *state = NULL; state = tevent_req_data(req, struct sdap_nested_group_lookup_unknown_state); + PROBE(SDAP_NESTED_GROUP_LOOKUP_UNKNOWN_RECV); + TEVENT_REQ_RETURN_ON_ERROR(req); if (_entry != NULL) { @@ -2161,6 +2193,8 @@ sdap_nested_group_deref_send(TALLOC_CTX *mem_ctx, return NULL; } + PROBE(SDAP_NESTED_GROUP_DEREF_SEND); + state->ev = ev; state->group_ctx = group_ctx; state->members = members; @@ -2262,6 +2296,7 @@ sdap_nested_group_deref_direct_process(struct tevent_req *subreq) goto done; } + PROBE(SDAP_NESTED_GROUP_DEREF_PROCESS_PRE); for (i = 0; i < num_entries; i++) { ret = sysdb_attrs_get_string(entries[i]->attrs, SYSDB_ORIG_DN, &orig_dn); @@ -2364,6 +2399,7 @@ sdap_nested_group_deref_direct_process(struct tevent_req *subreq) continue; } } + PROBE(SDAP_NESTED_GROUP_DEREF_PROCESS_POST); /* adjust size of nested groups array */ if (state->num_groups > 0) { @@ -2453,6 +2489,8 @@ static void sdap_nested_group_deref_done(struct tevent_req *subreq) static errno_t sdap_nested_group_deref_recv(struct tevent_req *req) { + PROBE(SDAP_NESTED_GROUP_DEREF_RECV); + TEVENT_REQ_RETURN_ON_ERROR(req); return EOK; diff --git a/src/providers/ldap/sdap_async_users.c b/src/providers/ldap/sdap_async_users.c index 480bbc2031249a66abf61737f6c86a7afdd3885f..c74d2aa8a7022d17f4832cd2904c7e5cd766d5d0 100644 --- a/src/providers/ldap/sdap_async_users.c +++ b/src/providers/ldap/sdap_async_users.c @@ -22,6 +22,7 @@ */ #include "util/util.h" +#include "util/probes.h" #include "db/sysdb.h" #include "providers/ldap/sdap_async_private.h" #include "providers/ldap/ldap_common.h" @@ -840,6 +841,7 @@ struct sdap_get_users_state { struct sysdb_ctx *sysdb; struct sdap_options *opts; struct sss_domain_info *dom; + const char *filter; char *higher_usn; struct sysdb_attrs **users; @@ -872,6 +874,9 @@ struct tevent_req *sdap_get_users_send(TALLOC_CTX *memctx, state->opts = opts; state->dom = dom; + state->filter = filter; + PROBE(SDAP_SEARCH_USER_SEND, state->filter); + subreq = sdap_search_user_send(state, ev, dom, opts, search_bases, sh, attrs, filter, timeout, lookup_type); if (subreq == NULL) { @@ -907,10 +912,12 @@ static void sdap_get_users_done(struct tevent_req *subreq) return; } + PROBE(SDAP_SEARCH_USER_SAVE_BEGIN, state->filter); ret = sdap_save_users(state, state->sysdb, state->dom, state->opts, state->users, state->count, &state->higher_usn); + PROBE(SDAP_SEARCH_USER_SAVE_END, state->filter); if (ret) { DEBUG(SSSDBG_OP_FAILURE, "Failed to store users [%d][%s].\n", ret, sss_strerror(ret)); @@ -929,6 +936,7 @@ int sdap_get_users_recv(struct tevent_req *req, struct sdap_get_users_state *state = tevent_req_data(req, struct sdap_get_users_state); + PROBE(SDAP_SEARCH_USER_RECV, state->filter); TEVENT_REQ_RETURN_ON_ERROR(req); if (usn_value) { diff --git a/src/systemtap/sssd.stp.in b/src/systemtap/sssd.stp.in index 2bd45aeb88f2a2052221ef4890aaa580330334ec..199916383105c34e60f3cb9b06d04d6c483b9712 100644 --- a/src/systemtap/sssd.stp.in +++ b/src/systemtap/sssd.stp.in @@ -30,3 +30,227 @@ probe sssd_transaction_cancel = process("@libdir@/sssd/libsss_util.so").mark("sy $$name, nesting); } + +# LDAP search probes +probe sdap_search_send = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_get_generic_ext_send") +{ + base = user_string($arg1); + scope = $arg2; + filter = user_string($arg3); + + probestr = sprintf("-> search base [%s] scope [%d] filter [%s]", + base, scope, filter); +} + +probe sdap_search_recv = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_get_generic_ext_recv") +{ + base = user_string($arg1); + scope = $arg2; + filter = user_string($arg3); + + probestr = sprintf("<- search base [%s] scope [%d] filter [%s]", + base, scope, filter); +} + +probe sdap_deref_send = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_deref_search_send") +{ + base_dn = user_string($arg1); + deref_attr = user_string($arg2); + + probestr = sprintf("-> (%s)(base_dn=[%s],deref_attr=[%s])", + $$name, base_dn, deref_attr); +} + +probe sdap_deref_recv = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_deref_search_recv") +{ + base_dn = user_string($arg1); + deref_attr = user_string($arg2); + + probestr = sprintf("-> (%s)(base_dn=[%s],deref_attr=[%s])", + $$name, base_dn, deref_attr); +} + +# LDAP account request probes +probe sdap_acct_req_send = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_acct_req_send") +{ + entry_type = $arg1; + filter_type = $arg2; + filter_value = user_string($arg3); + extra_value = user_string($arg4); +} + +probe sdap_acct_req_recv = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_acct_req_recv") +{ + entry_type = $arg1; + filter_type = $arg2; + filter_value = user_string($arg3); + extra_value = user_string($arg4); +} + +# LDAP user search probes +probe sdap_search_user_send = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_search_user_send") +{ + filter = user_string($arg1); +} + +probe sdap_search_user_save_begin = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_search_user_save_begin") +{ + filter = user_string($arg1); +} + +probe sdap_search_user_save_end = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_search_user_save_end") +{ + filter = user_string($arg1); +} + +probe sdap_search_user_recv = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_search_user_recv") +{ + filter = user_string($arg1); +} + +# LDAP group search probes +probe sdap_nested_group_populate_pre = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_populate_pre") +{ + # No arguments +} + +probe sdap_nested_group_populate_post = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_populate_post") +{ + # No arguments +} + +probe sdap_nested_group_save_pre = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_save_pre") +{ + # No arguments +} + +probe sdap_nested_group_save_post = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_save_post") +{ + # No arguments +} + +probe sdap_nested_group_lookup_user_send = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_lookup_user_send") +{ + # No arguments +} + +probe sdap_nested_group_lookup_user_recv = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_lookup_user_recv") +{ + # No arguments +} + +probe sdap_nested_group_lookup_group_send = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_lookup_group_send") +{ + # No arguments +} + +probe sdap_nested_group_lookup_group_recv = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_lookup_group_recv") +{ + # No arguments +} + +probe sdap_nested_group_lookup_unknown_send = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_lookup_unknown_send") +{ + # No arguments +} + +probe sdap_nested_group_lookup_unknown_recv = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_lookup_unknown_recv") +{ + # No arguments +} + +probe sdap_nested_group_deref_send = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_deref_send") +{ + # No arguments +} + +probe sdap_nested_group_deref_recv = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_deref_recv") +{ + # No arguments +} + +probe sdap_nested_group_deref_process_pre = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_deref_process_pre") +{ + # No arguments +} + +probe sdap_nested_group_deref_process_post = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_deref_process_post") +{ + # No arguments +} + +probe sdap_nested_group_send = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_send") +{ + # No arguments +} + +probe sdap_nested_group_recv = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_recv") +{ + # No arguments +} + +probe sdap_nested_group_process_send = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_process_send") +{ + orig_dn = user_string($arg1); + + probestr = sprintf("-> %s(orig_dn=[%s])", + $$name, orig_dn); +} + +probe sdap_nested_group_process_split_pre = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_process_split_pre") +{ + # No arguments +} + +probe sdap_nested_group_process_split_post = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_process_split_post") +{ + # No arguments +} + +probe sdap_nested_group_check_cache_pre = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_check_cache_pre") +{ + # No arguments +} + +probe sdap_nested_group_check_cache_post = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_check_cache_post") +{ + # No arguments +} + +probe sdap_nested_group_sysdb_search_users_pre = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_sysdb_search_users_pre") +{ + # No arguments +} + +probe sdap_nested_group_sysdb_search_users_post = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_sysdb_search_users_post") +{ + # No arguments +} + +probe sdap_nested_group_sysdb_search_groups_pre = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_sysdb_search_groups_pre") +{ + # No arguments +} + +probe sdap_nested_group_sysdb_search_groups_post = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_sysdb_search_groups_post") +{ + # No arguments +} + +probe sdap_nested_group_populate_search_users_pre = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_populate_search_users_pre") +{ + # No arguments +} + +probe sdap_nested_group_populate_search_users_post = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_populate_search_users_post") +{ + # No arguments +} + +probe sdap_nested_group_process_recv = process("@libdir@/sssd/libsss_ldap_common.so").mark("sdap_nested_group_process_recv") +{ + orig_dn = user_string($arg1); + + probestr = sprintf("-> %s(orig_dn=[%s])", + $$name, orig_dn); +} diff --git a/src/systemtap/sssd_probes.d b/src/systemtap/sssd_probes.d index f4890ddfdd82e67a30a955634b57b97fcaea4491..33339b415cd084d2a9348a5cd5f46065c0504233 100644 --- a/src/systemtap/sssd_probes.d +++ b/src/systemtap/sssd_probes.d @@ -3,4 +3,66 @@ provider sssd { probe sysdb_transaction_commit_before(int nesting); probe sysdb_transaction_commit_after(int nesting); probe sysdb_transaction_cancel(int nesting); + + probe sdap_acct_req_send(int entry_type, + int filter_type, + char *filter_value, + char *extra_value); + probe sdap_acct_req_recv(int entry_type, + int filter_type, + char *filter_value, + char *extra_value); + + probe sdap_search_user_send(const char *filter); + probe sdap_search_user_save_begin(const char *filter); + probe sdap_search_user_save_end(const char *filter); + probe sdap_search_user_recv(const char *filter); + + probe sdap_get_generic_ext_send(const char *base, int scope, const char *filter); + probe sdap_get_generic_ext_recv(const char *base, int scope, const char *filter); + + probe sdap_deref_search_send(const char *base_dn, const char *deref_attr); + probe sdap_deref_search_recv(const char *base_dn, const char *deref_attr); + + probe sdap_nested_group_populate_pre(); + probe sdap_nested_group_populate_post(); + + probe sdap_nested_group_save_pre(); + probe sdap_nested_group_save_post(); + + probe sdap_nested_group_lookup_user_send(); + probe sdap_nested_group_lookup_user_recv(); + + probe sdap_nested_group_lookup_group_send(); + probe sdap_nested_group_lookup_group_recv(); + + probe sdap_nested_group_lookup_unknown_send(); + probe sdap_nested_group_lookup_unknown_recv(); + + probe sdap_nested_group_deref_send(); + probe sdap_nested_group_deref_process_pre(); + probe sdap_nested_group_deref_process_post(); + probe sdap_nested_group_deref_recv(); + + probe sdap_save_group_pre(); + probe sdap_save_group_post(); + + probe sdap_save_grpmem_pre(); + probe sdap_save_grpmem_post(); + + probe sdap_nested_group_send(); + probe sdap_nested_group_recv(); + + probe sdap_nested_group_process_send(const char *orig_dn); + probe sdap_nested_group_process_split_pre(); + probe sdap_nested_group_process_split_post(); + probe sdap_nested_group_process_recv(const char *orig_dn); + probe sdap_nested_group_check_cache_pre(); + probe sdap_nested_group_check_cache_post(); + probe sdap_nested_group_sysdb_search_users_pre(); + probe sdap_nested_group_sysdb_search_users_post(); + probe sdap_nested_group_sysdb_search_groups_pre(); + probe sdap_nested_group_sysdb_search_groups_post(); + probe sdap_nested_group_populate_search_users_pre(); + probe sdap_nested_group_populate_search_users_post(); } -- 2.4.11