Make DEBUG macro invocations variadic

Use a script to update DEBUG macro invocations to use it as a variadic
macro, supplying format string and its arguments directly, instead of
wrapping them in parens.

This script was used to update the code:

grep -rwl --include '*.[hc]' DEBUG . |
    while read f; do
        mv "$f"{,.orig}
        perl -e \
            'use strict;
             use File::Slurp;
             my $text=read_file(\*STDIN);
             $text=~s#(\bDEBUG\s*\([^(]+)\((.*?)\)\s*\)\s*;#$1$2);#gs;
             print $text;' < "$f.orig" > "$f"
        rm "$f.orig"
    done

Reviewed-by: Jakub Hrozek <jhrozek@redhat.com>
Reviewed-by: Stephen Gallagher <sgallagh@redhat.com>
Reviewed-by: Simo Sorce <simo@redhat.com>

1 files changed, 44 insertions, 44 deletions

diff --git a/src/responder/nss/nsssrv_mmap_cache.c b/src/responder/nss/nsssrv_mmap_cache.c
index 36110d66c..8072bb38e 100644
--- a/src/responder/nss/nsssrv_mmap_cache.c
+++ b/src/responder/nss/nsssrv_mmap_cache.c
@@ -133,20 +133,20 @@ static void  sss_mc_save_corrupted(struct sss_mc_ctx *mc_ctx)
 
     if (mc_ctx == NULL) {
         DEBUG(SSSDBG_TRACE_FUNC,
-              ("Cannot store uninitialized cache. Nothing to do.\n"));
+              "Cannot store uninitialized cache. Nothing to do.\n");
         return;
     }
 
     tmp_ctx = talloc_new(NULL);
     if (tmp_ctx == NULL) {
-        DEBUG(SSSDBG_CRIT_FAILURE, ("Out of memory.\n"));
+        DEBUG(SSSDBG_CRIT_FAILURE, "Out of memory.\n");
         return;
     }
 
     file = talloc_asprintf(tmp_ctx, "%s_%s",
                            mc_ctx->file, "corrupted");
     if (file == NULL) {
-        DEBUG(SSSDBG_CRIT_FAILURE, ("Out of memory.\n"));
+        DEBUG(SSSDBG_CRIT_FAILURE, "Out of memory.\n");
         goto done;
     }
 
@@ -155,8 +155,8 @@ static void  sss_mc_save_corrupted(struct sss_mc_ctx *mc_ctx)
     if (fd == -1) {
         err = errno;
         DEBUG(SSSDBG_CRIT_FAILURE,
-              ("Failed to open file '%s' [%d]: %s\n",
-               file, err, strerror(err)));
+              "Failed to open file '%s' [%d]: %s\n",
+               file, err, strerror(err));
         goto done;
     }
 
@@ -165,11 +165,11 @@ static void  sss_mc_save_corrupted(struct sss_mc_ctx *mc_ctx)
         if (written == -1) {
             err = errno;
             DEBUG(SSSDBG_CRIT_FAILURE,
-                  ("write() failed [%d]: %s\n", err, strerror(err)));
+                  "write() failed [%d]: %s\n", err, strerror(err));
         } else {
             DEBUG(SSSDBG_CRIT_FAILURE,
-                  ("write() returned %zd (expected (%zd))\n",
-                   written, mc_ctx->mmap_size));
+                  "write() returned %zd (expected (%zd))\n",
+                   written, mc_ctx->mmap_size);
         }
         goto done;
     }
@@ -184,8 +184,8 @@ done:
             if (err != 0) {
                 err = errno;
                 DEBUG(SSSDBG_CRIT_FAILURE,
-                      ("Failed to remove file '%s': %s.\n", file,
-                       strerror(err)));
+                      "Failed to remove file '%s': %s.\n", file,
+                       strerror(err));
             }
         }
     }
@@ -474,7 +474,7 @@ static errno_t sss_mc_get_strs_offset(struct sss_mc_ctx *mcc,
         *_offset = offsetof(struct sss_mc_grp_data, strs);
         return EOK;
     default:
-        DEBUG(SSSDBG_FATAL_FAILURE, ("Unknown memory cache type.\n"));
+        DEBUG(SSSDBG_FATAL_FAILURE, "Unknown memory cache type.\n");
         return EINVAL;
     }
 }
@@ -491,7 +491,7 @@ static errno_t sss_mc_get_strs_len(struct sss_mc_ctx *mcc,
         *_len = ((struct sss_mc_grp_data *)&rec->data)->strs_len;
         return EOK;
     default:
-        DEBUG(SSSDBG_FATAL_FAILURE, ("Unknown memory cache type.\n"));
+        DEBUG(SSSDBG_FATAL_FAILURE, "Unknown memory cache type.\n");
         return EINVAL;
     }
 }
@@ -527,7 +527,7 @@ static struct sss_mc_rec *sss_mc_find_record(struct sss_mc_ctx *mcc,
     while (slot != MC_INVALID_VAL) {
         if (!MC_SLOT_WITHIN_BOUNDS(slot, mcc->dt_size)) {
             DEBUG(SSSDBG_FATAL_FAILURE,
-                  ("Corrupted fastcache. Slot number too big.\n"));
+                  "Corrupted fastcache. Slot number too big.\n");
             sss_mc_save_corrupted(mcc);
             sss_mmap_cache_reset(mcc);
             return NULL;
@@ -544,7 +544,7 @@ static struct sss_mc_rec *sss_mc_find_record(struct sss_mc_ctx *mcc,
             || (name_ptr + key->len) > (strs_offset + strs_len)
             || (uint8_t *)rec->data + strs_offset + strs_len > max_addr) {
             DEBUG(SSSDBG_FATAL_FAILURE,
-                  ("Corrupted fastcache. name_ptr value is %u.\n", name_ptr));
+                  "Corrupted fastcache. name_ptr value is %u.\n", name_ptr);
             sss_mc_save_corrupted(mcc);
             sss_mmap_cache_reset(mcc);
             return NULL;
@@ -600,7 +600,7 @@ static errno_t sss_mc_get_record(struct sss_mc_ctx **_mcc,
     if (ret != EOK) {
         if (ret == EFAULT) {
             DEBUG(SSSDBG_CRIT_FAILURE,
-                  ("Fatal internal mmap cache error, invalidating cache!\n"));
+                  "Fatal internal mmap cache error, invalidating cache!\n");
             (void)sss_mmap_cache_reinit(talloc_parent(mcc), -1, -1, _mcc);
         }
         return ret;
@@ -785,7 +785,7 @@ errno_t sss_mmap_cache_pw_invalidate_uid(struct sss_mc_ctx *mcc, uid_t uid)
 
     while (slot != MC_INVALID_VAL) {
         if (!MC_SLOT_WITHIN_BOUNDS(slot, mcc->dt_size)) {
-            DEBUG(SSSDBG_FATAL_FAILURE, ("Corrupted fastcache.\n"));
+            DEBUG(SSSDBG_FATAL_FAILURE, "Corrupted fastcache.\n");
             sss_mc_save_corrupted(mcc);
             sss_mmap_cache_reset(mcc);
             ret = ENOENT;
@@ -924,7 +924,7 @@ errno_t sss_mmap_cache_gr_invalidate_gid(struct sss_mc_ctx *mcc, gid_t gid)
 
     while (slot != MC_INVALID_VAL) {
         if (!MC_SLOT_WITHIN_BOUNDS(slot, mcc->dt_size)) {
-            DEBUG(SSSDBG_FATAL_FAILURE, ("Corrupted fastcache.\n"));
+            DEBUG(SSSDBG_FATAL_FAILURE, "Corrupted fastcache.\n");
             sss_mc_save_corrupted(mcc);
             sss_mmap_cache_reset(mcc);
             ret = ENOENT;
@@ -1011,29 +1011,29 @@ static errno_t sss_mc_create_file(struct sss_mc_ctx *mc_ctx)
         ret = sss_br_lock_file(ofd, 0, 1, retries, t);
         if (ret != EOK) {
             DEBUG(SSSDBG_FATAL_FAILURE,
-                  ("Failed to lock file %s.\n", mc_ctx->file));
+                  "Failed to lock file %s.\n", mc_ctx->file);
         }
         ret = sss_mc_set_recycled(ofd);
         if (ret) {
-            DEBUG(SSSDBG_FATAL_FAILURE, ("Failed to mark mmap file %s as"
+            DEBUG(SSSDBG_FATAL_FAILURE, "Failed to mark mmap file %s as"
                                          " recycled: %d(%s)\n",
-                                         mc_ctx->file, ret, strerror(ret)));
+                                         mc_ctx->file, ret, strerror(ret));
         }
 
         close(ofd);
     } else if (errno != ENOENT) {
         ret = errno;
         DEBUG(SSSDBG_CRIT_FAILURE,
-              ("Failed to open old memory cache file %s: %d(%s).\n",
-               mc_ctx->file, ret, strerror(ret)));
+              "Failed to open old memory cache file %s: %d(%s).\n",
+               mc_ctx->file, ret, strerror(ret));
     }
 
     errno = 0;
     ret = unlink(mc_ctx->file);
     if (ret == -1 && errno != ENOENT) {
         ret = errno;
-        DEBUG(SSSDBG_TRACE_FUNC, ("Failed to rm mmap file %s: %d(%s)\n",
-                                  mc_ctx->file, ret, strerror(ret)));
+        DEBUG(SSSDBG_TRACE_FUNC, "Failed to rm mmap file %s: %d(%s)\n",
+                                  mc_ctx->file, ret, strerror(ret));
     }
 
     /* temporarily relax umask as we need the file to be readable
@@ -1045,15 +1045,15 @@ static errno_t sss_mc_create_file(struct sss_mc_ctx *mc_ctx)
     umask(old_mask);
     if (mc_ctx->fd == -1) {
         ret = errno;
-        DEBUG(SSSDBG_CRIT_FAILURE, ("Failed to open mmap file %s: %d(%s)\n",
-                                    mc_ctx->file, ret, strerror(ret)));
+        DEBUG(SSSDBG_CRIT_FAILURE, "Failed to open mmap file %s: %d(%s)\n",
+                                    mc_ctx->file, ret, strerror(ret));
         return ret;
     }
 
     ret = sss_br_lock_file(mc_ctx->fd, 0, 1, retries, t);
     if (ret != EOK) {
         DEBUG(SSSDBG_FATAL_FAILURE,
-              ("Failed to lock file %s.\n", mc_ctx->file));
+              "Failed to lock file %s.\n", mc_ctx->file);
         close(mc_ctx->fd);
         mc_ctx->fd = -1;
 
@@ -1064,8 +1064,8 @@ static errno_t sss_mc_create_file(struct sss_mc_ctx *mc_ctx)
         uret = unlink(mc_ctx->file);
         if (uret == -1) {
             uret = errno;
-            DEBUG(SSSDBG_TRACE_FUNC, ("Failed to rm mmap file %s: %d(%s)\n",
-                                    mc_ctx->file, uret, strerror(uret)));
+            DEBUG(SSSDBG_TRACE_FUNC, "Failed to rm mmap file %s: %d(%s)\n",
+                                    mc_ctx->file, uret, strerror(uret));
         }
 
         return ret;
@@ -1111,8 +1111,8 @@ static int mc_ctx_destructor(struct sss_mc_ctx *mc_ctx)
         if (ret == -1) {
             ret = errno;
             DEBUG(SSSDBG_CRIT_FAILURE,
-                  ("Failed to unmap old memory cache file."
-                   "[%d]: %s\n", ret, strerror(ret)));
+                  "Failed to unmap old memory cache file."
+                   "[%d]: %s\n", ret, strerror(ret));
         }
     }
 
@@ -1121,8 +1121,8 @@ static int mc_ctx_destructor(struct sss_mc_ctx *mc_ctx)
         if (ret == -1) {
             ret = errno;
             DEBUG(SSSDBG_CRIT_FAILURE,
-                  ("Failed to close old memory cache file."
-                   "[%d]: %s\n", ret, strerror(ret)));
+                  "Failed to close old memory cache file."
+                   "[%d]: %s\n", ret, strerror(ret));
         }
     }
 
@@ -1199,8 +1199,8 @@ errno_t sss_mmap_cache_init(TALLOC_CTX *mem_ctx, const char *name,
     ret = ftruncate(mc_ctx->fd, mc_ctx->mmap_size);
     if (ret == -1) {
         ret = errno;
-        DEBUG(SSSDBG_CRIT_FAILURE, ("Failed to resize file %s: %d(%s)\n",
-                                    mc_ctx->file, ret, strerror(ret)));
+        DEBUG(SSSDBG_CRIT_FAILURE, "Failed to resize file %s: %d(%s)\n",
+                                    mc_ctx->file, ret, strerror(ret));
         goto done;
     }
 
@@ -1209,9 +1209,9 @@ errno_t sss_mmap_cache_init(TALLOC_CTX *mem_ctx, const char *name,
                              MAP_SHARED, mc_ctx->fd, 0);
     if (mc_ctx->mmap_base == MAP_FAILED) {
         ret = errno;
-        DEBUG(SSSDBG_CRIT_FAILURE, ("Failed to mmap file %s(%zu): %d(%s)\n",
+        DEBUG(SSSDBG_CRIT_FAILURE, "Failed to mmap file %s(%zu): %d(%s)\n",
                                     mc_ctx->file, mc_ctx->mmap_size,
-                                    ret, strerror(ret)));
+                                    ret, strerror(ret));
         goto done;
     }
 
@@ -1242,8 +1242,8 @@ done:
             dret = unlink(mc_ctx->file);
             if (dret == -1) {
                 DEBUG(SSSDBG_CRIT_FAILURE,
-                      ("Failed to rm mmap file %s: %d(%s)\n", mc_ctx->file,
-                       dret, strerror(dret)));
+                      "Failed to rm mmap file %s: %d(%s)\n", mc_ctx->file,
+                       dret, strerror(dret));
             }
         }
 
@@ -1264,19 +1264,19 @@ errno_t sss_mmap_cache_reinit(TALLOC_CTX *mem_ctx, size_t n_elem,
 
     if (mc_ctx == NULL || (*mc_ctx) == NULL) {
         DEBUG(SSSDBG_CRIT_FAILURE,
-              ("Unable to re-init unitialized memory cache.\n"));
+              "Unable to re-init unitialized memory cache.\n");
         return EINVAL;
     }
 
     tmp_ctx = talloc_new(NULL);
     if (tmp_ctx == NULL) {
-        DEBUG(SSSDBG_CRIT_FAILURE, ("Out of memory.\n"));
+        DEBUG(SSSDBG_CRIT_FAILURE, "Out of memory.\n");
         return ENOMEM;
     }
 
     name = talloc_strdup(tmp_ctx, (*mc_ctx)->name);
     if (name == NULL) {
-        DEBUG(SSSDBG_CRIT_FAILURE, ("Out of memory.\n"));
+        DEBUG(SSSDBG_CRIT_FAILURE, "Out of memory.\n");
         ret = ENOMEM;
         goto done;
     }
@@ -1298,7 +1298,7 @@ errno_t sss_mmap_cache_reinit(TALLOC_CTX *mem_ctx, size_t n_elem,
 
     ret = sss_mmap_cache_init(mem_ctx, name, type, n_elem, timeout, mc_ctx);
     if (ret != EOK) {
-        DEBUG(SSSDBG_CRIT_FAILURE, ("Failed to re-initialize mmap cache.\n"));
+        DEBUG(SSSDBG_CRIT_FAILURE, "Failed to re-initialize mmap cache.\n");
         goto done;
     }
 
@@ -1313,7 +1313,7 @@ void sss_mmap_cache_reset(struct sss_mc_ctx *mc_ctx)
 {
     if (mc_ctx == NULL) {
         DEBUG(SSSDBG_TRACE_FUNC,
-              ("Fastcache not initialized. Nothing to do.\n"));
+              "Fastcache not initialized. Nothing to do.\n");
         return;
     }