Bunch of assorted perf improvements of hot path functions

src/db/sysdb_ops.c

@@ -2289,6 +2289,8 @@ int sysdb_add_incomplete_group(struct sss_domain_info *domain,
     const char *values[] = { sid_str, uuid, original_dn, NULL };
     bool same = false;
 
+    DEBUG(SSSDBG_MINOR_FAILURE, " ~~~~~ enter\n");
+
     tmp_ctx = talloc_new(NULL);
     if (!tmp_ctx) {
         return ENOMEM;
@@ -2372,6 +2374,9 @@ int sysdb_add_incomplete_group(struct sss_domain_info *domain,
         DEBUG(SSSDBG_TRACE_FUNC, "Error: %d (%s)\n", ret, sss_strerror(ret));
     }
     talloc_zfree(tmp_ctx);
+
+    DEBUG(SSSDBG_MINOR_FAILURE, " ~~~~~ leave\n");
+
     return ret;
 }
 
@@ -3119,8 +3124,12 @@ int sysdb_add_group_member(struct sss_domain_info *domain,
                            enum sysdb_member_type type,
                            bool is_dn)
 {
-    return sysdb_group_membership_mod(domain, group, member, type,
+    int ret;
+    DEBUG(SSSDBG_MINOR_FAILURE, " ~~~~~ enter\n");
+    ret = sysdb_group_membership_mod(domain, group, member, type,
                                       SYSDB_MOD_ADD, is_dn);
+    DEBUG(SSSDBG_MINOR_FAILURE, " ~~~~~ leave\n");
+    return ret;
 }
 
 /* =Remove-member-from-Group(Native/Legacy)=============================== */

src/providers/data_provider/dp_request.c

@@ -131,7 +131,7 @@ static errno_t dp_attach_req(struct dp_req *dp_req,
     talloc_set_destructor(dp_req, dp_req_destructor);
 
     if (cli_id > 0) {
-        SSS_REQ_TRACE_CID_DP_REQ(SSSDBG_TRACE_FUNC, dp_req->name,
+        SSS_REQ_TRACE_CID_DP_REQ(SSSDBG_MINOR_FAILURE, dp_req->name,
                                  "New request. [%s CID #%u] Flags [%#.4x].",
                                  sender_name, cli_id, dp_flags);
         if (be_is_offline(provider->be_ctx)) {

src/providers/ldap/sdap.c

@@ -1841,7 +1841,7 @@ errno_t sdap_get_primary_name(const char *attr_name,
     }
     talloc_free(tmp_ctx);
 
-    DEBUG(SSSDBG_TRACE_FUNC, "Processing object %s\n", orig_name);
+    DEBUG_CONDITIONAL(SSSDBG_TRACE_FUNC, "Processing object %s\n", orig_name);
 
     *_primary_name = orig_name;
 

src/providers/ldap/sdap_async_initgroups.c

@@ -113,6 +113,7 @@ errno_t sdap_add_incomplete_groups(struct sysdb_ctx *sysdb,
 
 
     now = time(NULL);
+    DEBUG(SSSDBG_MINOR_FAILURE, " ~~~~~ enter: writing missing groups\n");
     for (i=0; missing[i]; i++) {
         /* The group is not in sysdb, need to add a fake entry */
         for (ai=0; ai < ldap_groups_count; ai++) {
@@ -258,8 +259,10 @@ errno_t sdap_add_incomplete_groups(struct sysdb_ctx *sysdb,
             goto done;
         }
     }
+    DEBUG(SSSDBG_MINOR_FAILURE, " ~~~~~ leave: writing missing groups\n");
 
     ret = sysdb_transaction_commit(sysdb);
+    DEBUG(SSSDBG_MINOR_FAILURE, " ~~~~~ leave: writing missing groups - transaction commited\n");
     if (ret != EOK) {
         DEBUG(SSSDBG_CRIT_FAILURE, "sysdb_transaction_commit failed.\n");
         goto done;

src/util/sss_tc_utf8.c

@@ -21,12 +21,29 @@
 #include "config.h"
 
 #include <stdlib.h>
+#include <stdbool.h>
 #include <unistr.h>
 #include <unicase.h>
 
 #include <talloc.h>
 #include "util/util.h"
 
+static inline bool sss_is_ascii_lowercase(const char *s)
+{
+    if (s == NULL) {
+        return true;
+    }
+
+    while (*s != 0) {
+        if ((*s > 0x7F) || ((*s >= 'A') && (*s <= 'Z'))) {
+            return false;
+        }
+        s++;
+    }
+
+    return true;
+}
+
 /* Expects and returns NULL-terminated string;
  * result must be freed with free()
  */
@@ -41,10 +58,15 @@
     char *lower;
     char *ret = NULL;
 
-    lower = sss_utf8_tolower(s);
-    if (lower) {
-        ret = talloc_strdup(mem_ctx, lower);
-        free(lower);
+    if (sss_is_ascii_lowercase(s)) {
+        ret = talloc_strdup(mem_ctx, s);
+    }
+    else {
+        lower = sss_utf8_tolower(s);
+        if (lower) {
+            ret = talloc_strdup(mem_ctx, lower);
+            free(lower);
+        }
     }
 
     return ret;

src/util/usertools.c

@@ -638,29 +638,75 @@ errno_t sss_parse_internal_fqname(TALLOC_CTX *mem_ctx,
     return EOK;
 }
 
+/* This is a wrapper around `sss_tc_utf8_str_tolower()` that
+ * maintains run time cache.
+ */
+static const char *sss_get_lc_dom_name(const char *dom_name)
+{
+    static TALLOC_CTX *cache_ctx;
+    static hash_table_t *lc_dom_name_cache;
+    hash_key_t key;
+    hash_value_t value;
+    char *lc_dom_name;
+    int hret;
+
+    key.type = HASH_KEY_STRING;
+    key.str = discard_const(dom_name);
+
+    if (lc_dom_name_cache != NULL) {
+        hret = hash_lookup(lc_dom_name_cache, &key, &value);
+        if (hret == HASH_SUCCESS) {
+            return (const char *)value.ptr;
+        }
+    } else {
+        cache_ctx = talloc_new(NULL);
+        if (!cache_ctx) return NULL;
+        hret = hash_create(0, &lc_dom_name_cache, NULL, NULL);
+        if (hret != HASH_SUCCESS) {
+            DEBUG(SSSDBG_CRIT_FAILURE,
+                  "hash_create() failed [%s]\n", hash_error_string(hret));
+            return NULL;
+        }
+    }
+
+    lc_dom_name = sss_tc_utf8_str_tolower(cache_ctx, dom_name);
+    if (lc_dom_name == NULL) {
+        return NULL;
+    }
+
+    value.type = HASH_VALUE_PTR;
+    value.ptr = lc_dom_name;
+
+    hret = hash_enter(lc_dom_name_cache, &key, &value);
+    if (hret != HASH_SUCCESS) {
+        DEBUG(SSSDBG_CRIT_FAILURE,
+              "hash_enter() failed [%s]\n", hash_error_string(hret));
+        talloc_free(lc_dom_name);
+        return NULL;
+    }
+
+    return lc_dom_name;
+}
+
 /* Creates internal fqname in format shortname@domname.
  * The domain portion is lowercased. */
 char *sss_create_internal_fqname(TALLOC_CTX *mem_ctx,
                                  const char *shortname,
                                  const char *dom_name)
 {
-    char *lc_dom_name;
-    char *fqname = NULL;
+    const char *lc_dom_name;
 
     if (shortname == NULL || dom_name == NULL) {
         /* Avoid allocating null@null */
         return NULL;
     }
 
-    lc_dom_name = sss_tc_utf8_str_tolower(mem_ctx, dom_name);
+    lc_dom_name = sss_get_lc_dom_name(dom_name);
     if (lc_dom_name == NULL) {
-        goto done;
+        return NULL;
     }
 
-    fqname = talloc_asprintf(mem_ctx, "%s@%s", shortname, lc_dom_name);
-    talloc_free(lc_dom_name);
-done:
-    return fqname;
+    return talloc_asprintf(mem_ctx, "%s@%s", shortname, lc_dom_name);
 }
 
 /* Creates a list of internal fqnames in format shortname@domname.