Add dm_zalloc and use it and dm_pool_zalloc throughout.

diff --git a/WHATS_NEW b/WHATS_NEW
index 58dea0c9b5d103c30633831b3c2ada996401a4a8..5d09a63604b883a091a69a44e3690f5ec396e690 100644 (file)
--- a/WHATS_NEW
+++ b/WHATS_NEW
@@ -1,8 +1,9 @@
 Version 2.02.75 - 
 =====================================
+  Add dm_zalloc and use it and dm_pool_zalloc throughout.
   Add pv_get_property and create generic internal _get_property function.
   Add 'get' functions for pv and vg properties/fields.
-  Make generic GET_*_PROPERTY_FN macros and define secondary macro for vg, pv, lv.
+  Make generic GET_*_PROPERTY_FN macros with secondary macro for vg, pv & lv.
   Add tags_format_and_copy() common function and call from _tags_disp.
   Add id_format_and_copy() common function and call from _uuid_disp.
   Simplify logic to create '{pv|vg|lv}_attr' strings.

diff --git a/daemons/dmeventd/dmeventd.c b/daemons/dmeventd/dmeventd.c
index cc1e4a72dcd455c2dda2c5e8d9ba60c1b8c11794..4889b7cf2bc896dc1731512887e7460bb9ca1e84 100644 (file)
--- a/daemons/dmeventd/dmeventd.c
+++ b/daemons/dmeventd/dmeventd.c
@@ -223,12 +223,11 @@ static void _debuglog(const char *fmt, ...)
 static struct thread_status *_alloc_thread_status(struct message_data *data,
                                                  struct dso_data *dso_data)
 {
-       struct thread_status *ret = (typeof(ret)) dm_malloc(sizeof(*ret));
+       struct thread_status *ret = (typeof(ret)) dm_zalloc(sizeof(*ret));
 
        if (!ret)
                return NULL;
 
-       memset(ret, 0, sizeof(*ret));
        if (!(ret->device.uuid = dm_strdup(data->device_uuid))) {
                dm_free(ret);
                return NULL;
@@ -259,12 +258,11 @@ static void _free_thread_status(struct thread_status *thread)
 /* Allocate/free DSO data. */
 static struct dso_data *_alloc_dso_data(struct message_data *data)
 {
-       struct dso_data *ret = (typeof(ret)) dm_malloc(sizeof(*ret));
+       struct dso_data *ret = (typeof(ret)) dm_zalloc(sizeof(*ret));
 
        if (!ret)
                return NULL;
 
-       memset(ret, 0, sizeof(*ret));
        if (!(ret->dso_name = dm_strdup(data->dso_name))) {
                dm_free(ret);
                return NULL;

diff --git a/lib/cache/lvmcache.c b/lib/cache/lvmcache.c
index 2af4e4a654079f67b1f50fdc3102aa5494153917..35d6f76c6c1188e822f11d4cf7436f69986cc8b4 100644 (file)
--- a/lib/cache/lvmcache.c
+++ b/lib/cache/lvmcache.c
@@ -1064,11 +1064,10 @@ static int _lvmcache_update_vgname(struct lvmcache_info *info,
                        }
                } else {
 ***/
-               if (!(vginfo = dm_malloc(sizeof(*vginfo)))) {
+               if (!(vginfo = dm_zalloc(sizeof(*vginfo)))) {
                        log_error("lvmcache_update_vgname: list alloc failed");
                        return 0;
                }
-               memset(vginfo, 0, sizeof(*vginfo));
                if (!(vginfo->vgname = dm_strdup(vgname))) {
                        dm_free(vginfo);
                        log_error("cache vgname alloc failed for %s", vgname);
@@ -1261,12 +1260,11 @@ struct lvmcache_info *lvmcache_add(struct labeller *labeller, const char *pvid,
            !(existing = info_from_pvid(dev->pvid, 0))) {
                if (!(label = label_create(labeller)))
                        return_NULL;
-               if (!(info = dm_malloc(sizeof(*info)))) {
+               if (!(info = dm_zalloc(sizeof(*info)))) {
                        log_error("lvmcache_info allocation failed");
                        label_destroy(label);
                        return NULL;
                }
-               memset(info, 0, sizeof(*info));
 
                label->info = info;
                info->label = label;

diff --git a/lib/commands/toolcontext.c b/lib/commands/toolcontext.c
index 813da909137a58adb0392c838e51af7813cfd315..289a0fcab0c36e4f13f5bbb7c557cec8dd99c0a8 100644 (file)
--- a/lib/commands/toolcontext.c
+++ b/lib/commands/toolcontext.c
@@ -1121,11 +1121,10 @@ struct cmd_context *create_toolcontext(unsigned is_long_lived,
 
        init_syslog(DEFAULT_LOG_FACILITY);
 
-       if (!(cmd = dm_malloc(sizeof(*cmd)))) {
+       if (!(cmd = dm_zalloc(sizeof(*cmd)))) {
                log_error("Failed to allocate command context");
                return NULL;
        }
-       memset(cmd, 0, sizeof(*cmd));
        cmd->is_long_lived = is_long_lived;
        cmd->handles_missing_pvs = 0;
        cmd->handles_unknown_segments = 0;

diff --git a/lib/config/config.c b/lib/config/config.c
index 72f306d7120e40ec27fb77d61ae179b3877358cb..2b386634a5a8c6c151955118093d6e370d83100c 100644 (file)
--- a/lib/config/config.c
+++ b/lib/config/config.c
@@ -724,6 +724,8 @@ static void _get_token(struct parser *p, int tok_prev)
 {
        int values_allowed = 0;
 
+       const char *te;
+
        p->tb = p->te;
        _eat_space(p);
        if (p->tb == p->fe || !*p->tb) {
@@ -738,59 +740,61 @@ static void _get_token(struct parser *p, int tok_prev)
 
        p->t = TOK_INT;         /* fudge so the fall through for
                                   floats works */
-       switch (*p->te) {
+
+       te = p->te;
+       switch (*te) {
        case SECTION_B_CHAR:
                p->t = TOK_SECTION_B;
-               p->te++;
+               te++;
                break;
 
        case SECTION_E_CHAR:
                p->t = TOK_SECTION_E;
-               p->te++;
+               te++;
                break;
 
        case '[':
                p->t = TOK_ARRAY_B;
-               p->te++;
+               te++;
                break;
 
        case ']':
                p->t = TOK_ARRAY_E;
-               p->te++;
+               te++;
                break;
 
        case ',':
                p->t = TOK_COMMA;
-               p->te++;
+               te++;
                break;
 
        case '=':
                p->t = TOK_EQ;
-               p->te++;
+               te++;
                break;
 
        case '"':
                p->t = TOK_STRING_ESCAPED;
-               p->te++;
-               while ((p->te != p->fe) && (*p->te) && (*p->te != '"')) {
-                       if ((*p->te == '\\') && (p->te + 1 != p->fe) &&
-                           *(p->te + 1))
-                               p->te++;
-                       p->te++;
+               te++;
+               while ((te != p->fe) && (*te) && (*te != '"')) {
+                       if ((*te == '\\') && (te + 1 != p->fe) &&
+                           *(te + 1))
+                               te++;
+                       te++;
                }
 
-               if ((p->te != p->fe) && (*p->te))
-                       p->te++;
+               if ((te != p->fe) && (*te))
+                       te++;
                break;
 
        case '\'':
                p->t = TOK_STRING;
-               p->te++;
-               while ((p->te != p->fe) && (*p->te) && (*p->te != '\''))
-                       p->te++;
+               te++;
+               while ((te != p->fe) && (*te) && (*te != '\''))
+                       te++;
 
-               if ((p->te != p->fe) && (*p->te))
-                       p->te++;
+               if ((te != p->fe) && (*te))
+                       te++;
                break;
 
        case '.':
@@ -808,28 +812,30 @@ static void _get_token(struct parser *p, int tok_prev)
        case '+':
        case '-':
                if (values_allowed) {
-                       p->te++;
-                       while ((p->te != p->fe) && (*p->te)) {
-                               if (*p->te == '.') {
+                       te++;
+                       while ((te != p->fe) && (*te)) {
+                               if (*te == '.') {
                                        if (p->t == TOK_FLOAT)
                                                break;
                                        p->t = TOK_FLOAT;
-                               } else if (!isdigit((int) *p->te))
+                               } else if (!isdigit((int) *te))
                                        break;
-                               p->te++;
+                               te++;
                        }
                        break;
                }
 
        default:
                p->t = TOK_IDENTIFIER;
-               while ((p->te != p->fe) && (*p->te) && !isspace(*p->te) &&
-                      (*p->te != '#') && (*p->te != '=') &&
-                      (*p->te != SECTION_B_CHAR) &&
-                      (*p->te != SECTION_E_CHAR))
-                       p->te++;
+               while ((te != p->fe) && (*te) && !isspace(*te) &&
+                      (*te != '#') && (*te != '=') &&
+                      (*te != SECTION_B_CHAR) &&
+                      (*te != SECTION_E_CHAR))
+                       te++;
                break;
        }
+
+       p->te = te;
 }
 
 static void _eat_space(struct parser *p)
@@ -859,22 +865,12 @@ static void _eat_space(struct parser *p)
  */
 static struct config_value *_create_value(struct dm_pool *mem)
 {
-       struct config_value *v = dm_pool_alloc(mem, sizeof(*v));
-
-       if (v)
-               memset(v, 0, sizeof(*v));
-
-       return v;
+       return dm_pool_zalloc(mem, sizeof(struct config_value));
 }
 
 static struct config_node *_create_node(struct dm_pool *mem)
 {
-       struct config_node *n = dm_pool_alloc(mem, sizeof(*n));
-
-       if (n)
-               memset(n, 0, sizeof(*n));
-
-       return n;
+       return dm_pool_zalloc(mem, sizeof(struct config_node));
 }
 
 static char *_dup_tok(struct parser *p)

diff --git a/lib/filters/filter-persistent.c b/lib/filters/filter-persistent.c
index 7f48a4791c05b6c247830ce28b8df0cfffeac5bd..2ed94007f7168fc1b8d498075aa8ed8085b22a4c 100644 (file)
--- a/lib/filters/filter-persistent.c
+++ b/lib/filters/filter-persistent.c
@@ -318,9 +318,8 @@ struct dev_filter *persistent_filter_create(struct dev_filter *real,
        struct dev_filter *f = NULL;
        struct stat info;
 
-       if (!(pf = dm_malloc(sizeof(*pf))))
+       if (!(pf = dm_zalloc(sizeof(*pf))))
                return_NULL;
-       memset(pf, 0, sizeof(*pf));
 
        if (!(pf->file = dm_malloc(strlen(file) + 1)))
                goto_bad;

diff --git a/lib/format1/disk-rep.c b/lib/format1/disk-rep.c
index d38c88746705083fe229ad24804cb40aab8e32a1..bc58744240e81e6d21859fb28cfc63ac73548216 100644 (file)
--- a/lib/format1/disk-rep.c
+++ b/lib/format1/disk-rep.c
@@ -624,13 +624,12 @@ static int _write_pvd(struct disk_list *data)
        /* Make sure that the gap between the PV structure and
           the next one is zeroed in order to make non LVM tools
           happy (idea from AED) */
-       buf = dm_malloc(size);
+       buf = dm_zalloc(size);
        if (!buf) {
                log_error("Couldn't allocate temporary PV buffer.");
                return 0;
        }
 
-       memset(buf, 0, size);
        memcpy(buf, &data->pvd, sizeof(struct pv_disk));
 
        log_debug("Writing %s PV metadata to %s at %" PRIu64 " len %"

diff --git a/lib/format1/format1.c b/lib/format1/format1.c
index f41fd7f6add34410cb6ac188170e5d29db54d9e8..d6c462a53910d19c94ed87743ad6d11aefa43ea0 100644 (file)
--- a/lib/format1/format1.c
+++ b/lib/format1/format1.c
@@ -157,7 +157,7 @@ static struct volume_group *_build_vg(struct format_instance *fid,
                                      struct dm_list *pvs,
                                      struct dm_pool *mem)
 {
-       struct volume_group *vg = dm_pool_alloc(mem, sizeof(*vg));
+       struct volume_group *vg = dm_pool_zalloc(mem, sizeof(*vg));
        struct disk_list *dl;
 
        if (!vg)
@@ -166,8 +166,6 @@ static struct volume_group *_build_vg(struct format_instance *fid,
        if (dm_list_empty(pvs))
                goto_bad;
 
-       memset(vg, 0, sizeof(*vg));
-
        vg->cmd = fid->fmt->cmd;
        vg->vgmem = mem;
        vg->fid = fid;

diff --git a/lib/format1/import-export.c b/lib/format1/import-export.c
index 864034bb9975613cffb0cb62df47aee5f14f0db3..e26173724231d94f02c5e09e0838572e6bb5fd68 100644 (file)
--- a/lib/format1/import-export.c
+++ b/lib/format1/import-export.c
@@ -506,9 +506,8 @@ int export_lvs(struct disk_list *dl, struct volume_group *vg,
         * setup the pv's extents array
         */
        len = sizeof(struct pe_disk) * dl->pvd.pe_total;
-       if (!(dl->extents = dm_pool_alloc(dl->mem, len)))
+       if (!(dl->extents = dm_pool_zalloc(dl->mem, len)))
                goto_out;
-       memset(dl->extents, 0, len);
 
        dm_list_iterate_items(ll, &vg->lvs) {
                if (ll->lv->status & SNAPSHOT)

diff --git a/lib/format_text/export.c b/lib/format_text/export.c
index d16a7fcf656801d8800dadc1b4b4576da6054b87..d49090ccbdcccd7d76e649986fda85ccfe8e9f1e 100644 (file)
--- a/lib/format_text/export.c
+++ b/lib/format_text/export.c
@@ -742,10 +742,9 @@ int text_vg_export_file(struct volume_group *vg, const char *desc, FILE *fp)
 
        _init();
 
-       if (!(f = dm_malloc(sizeof(*f))))
+       if (!(f = dm_zalloc(sizeof(*f))))
                return_0;
 
-       memset(f, 0, sizeof(*f));
        f->data.fp = fp;
        f->indent = 0;
        f->header = 1;
@@ -767,11 +766,9 @@ int text_vg_export_raw(struct volume_group *vg, const char *desc, char **buf)
 
        _init();
 
-       if (!(f = dm_malloc(sizeof(*f))))
+       if (!(f = dm_zalloc(sizeof(*f))))
                return_0;
 
-       memset(f, 0, sizeof(*f));
-
        f->data.buf.size = 65536;       /* Initial metadata limit */
        if (!(f->data.buf.start = dm_malloc(f->data.buf.size))) {
                log_error("text_export buffer allocation failed");

diff --git a/lib/label/label.c b/lib/label/label.c
index 9a10d066400c6ace4f14e190d93a5d95f551c4fe..c622812ff4ca48c97f5a78a7567d06d3f17d0b74 100644 (file)
--- a/lib/label/label.c
+++ b/lib/label/label.c
@@ -383,11 +383,10 @@ struct label *label_create(struct labeller *labeller)
 {
        struct label *label;
 
-       if (!(label = dm_malloc(sizeof(*label)))) {
+       if (!(label = dm_zalloc(sizeof(*label)))) {
                log_error("label allocaction failed");
                return NULL;
        }
-       memset(label, 0, sizeof(*label));
 
        label->labeller = labeller;
 

diff --git a/libdm/datastruct/bitset.c b/libdm/datastruct/bitset.c
index 563f684e155c8c2fef8f47945a7f4dad93713c11..5cd8e385a79c25991fe0ad66c7291e22d84d4277 100644 (file)
--- a/libdm/datastruct/bitset.c
+++ b/libdm/datastruct/bitset.c
@@ -26,8 +26,8 @@ dm_bitset_t dm_bitset_create(struct dm_pool *mem, unsigned num_bits)
        
        if (mem)
                bs = dm_pool_zalloc(mem, size);
-       else if ((bs = dm_malloc(size)))
-               memset(bs, 0, size);
+       else
+               bs = dm_zalloc(size);
 
        if (!bs)
                return NULL;

diff --git a/libdm/datastruct/hash.c b/libdm/datastruct/hash.c
index cd722cd81900c318be4cbcd253a0084c14e1bd64..d4543df5b24bf96361c93328901f27b85e6289b3 100644 (file)
--- a/libdm/datastruct/hash.c
+++ b/libdm/datastruct/hash.c
@@ -90,14 +90,10 @@ struct dm_hash_table *dm_hash_create(unsigned size_hint)
 {
        size_t len;
        unsigned new_size = 16u;
-       struct dm_hash_table *hc = dm_malloc(sizeof(*hc));
+       struct dm_hash_table *hc = dm_zalloc(sizeof(*hc));
 
-       if (!hc) {
-               stack;
-               return 0;
-       }
-
-       memset(hc, 0, sizeof(*hc));
+       if (!hc)
+               return_0;
 
        /* round size hint up to a power of two */
        while (new_size < size_hint)

diff --git a/libdm/libdevmapper.h b/libdm/libdevmapper.h
index 38b901f394583e0b6288b9faaa2a76a953e56d82..34bcf40525e149ce27f4fa71018f4434a90f5489 100644 (file)
--- a/libdm/libdevmapper.h
+++ b/libdm/libdevmapper.h
@@ -511,6 +511,8 @@ uint32_t dm_tree_get_cookie(struct dm_tree_node *node);
 
 void *dm_malloc_aux(size_t s, const char *file, int line);
 void *dm_malloc_aux_debug(size_t s, const char *file, int line);
+void *dm_zalloc_aux(size_t s, const char *file, int line);
+void *dm_zalloc_aux_debug(size_t s, const char *file, int line);
 char *dm_strdup_aux(const char *str, const char *file, int line);
 void dm_free_aux(void *p);
 void *dm_realloc_aux(void *p, unsigned int s, const char *file, int line);
@@ -520,6 +522,7 @@ void dm_bounds_check_debug(void);
 #ifdef DEBUG_MEM
 
 #  define dm_malloc(s) dm_malloc_aux_debug((s), __FILE__, __LINE__)
+#  define dm_zalloc(s) dm_zalloc_aux_debug((s), __FILE__, __LINE__)
 #  define dm_strdup(s) dm_strdup_aux((s), __FILE__, __LINE__)
 #  define dm_free(p) dm_free_aux(p)
 #  define dm_realloc(p, s) dm_realloc_aux(p, s, __FILE__, __LINE__)
@@ -529,6 +532,7 @@ void dm_bounds_check_debug(void);
 #else
 
 #  define dm_malloc(s) dm_malloc_aux((s), __FILE__, __LINE__)
+#  define dm_zalloc(s) dm_zalloc_aux((s), __FILE__, __LINE__)
 #  define dm_strdup(s) strdup(s)
 #  define dm_free(p) free(p)
 #  define dm_realloc(p, s) realloc(p, s)

diff --git a/libdm/libdm-common.c b/libdm/libdm-common.c
index 6b3f2d2bcad6969a55713e98cd6d712b8b5972a5..4de2f4b5ff6cc4df2c4979c02d48c0232ace66c1 100644 (file)
--- a/libdm/libdm-common.c
+++ b/libdm/libdm-common.c
@@ -166,7 +166,7 @@ int dm_get_library_version(char *version, size_t size)
 
 struct dm_task *dm_task_create(int type)
 {
-       struct dm_task *dmt = dm_malloc(sizeof(*dmt));
+       struct dm_task *dmt = dm_zalloc(sizeof(*dmt));
 
        if (!dmt) {
                log_error("dm_task_create: malloc(%" PRIsize_t ") failed",
@@ -179,8 +179,6 @@ struct dm_task *dm_task_create(int type)
                return NULL;
        }
 
-       memset(dmt, 0, sizeof(*dmt));
-
        dmt->type = type;
        dmt->minor = -1;
        dmt->major = -1;

diff --git a/libdm/libdm-deptree.c b/libdm/libdm-deptree.c
index 0e491273d24cd3a9ab34354cc71fdbc9197542c5..952c37be05b440684cc94ef0b0e9720cb3f97b07 100644 (file)
--- a/libdm/libdm-deptree.c
+++ b/libdm/libdm-deptree.c
@@ -197,12 +197,11 @@ struct dm_tree *dm_tree_create(void)
 {
        struct dm_tree *dtree;
 
-       if (!(dtree = dm_malloc(sizeof(*dtree)))) {
+       if (!(dtree = dm_zalloc(sizeof(*dtree)))) {
                log_error("dm_tree_create malloc failed");
                return NULL;
        }
 
-       memset(dtree, 0, sizeof(*dtree));
        dtree->root.dtree = dtree;
        dm_list_init(&dtree->root.uses);
        dm_list_init(&dtree->root.used_by);

diff --git a/libdm/libdm-report.c b/libdm/libdm-report.c
index 2b044b538d2c487329f4c360c1613b53022bab0a..7631e219d0f1623224dee129314e24e6948498a1 100644 (file)
--- a/libdm/libdm-report.c
+++ b/libdm/libdm-report.c
@@ -571,11 +571,10 @@ struct dm_report *dm_report_init(uint32_t *report_types,
        struct dm_report *rh;
        const struct dm_report_object_type *type;
 
-       if (!(rh = dm_malloc(sizeof(*rh)))) {
+       if (!(rh = dm_zalloc(sizeof(*rh)))) {
                log_error("dm_report_init: dm_malloc failed");
                return 0;
        }
-       memset(rh, 0, sizeof(*rh));
 
        /*
         * rh->report_types is updated in _parse_fields() and _parse_keys()

diff --git a/libdm/mm/dbg_malloc.c b/libdm/mm/dbg_malloc.c
index cace811058b3d6daf529c1635364b700f8843c64..db7f5f3ed77b21ffbfa34deffc9f38521edce036 100644 (file)
--- a/libdm/mm/dbg_malloc.c
+++ b/libdm/mm/dbg_malloc.c
@@ -119,6 +119,16 @@ void *dm_malloc_aux_debug(size_t s, const char *file, int line)
        return nb + 1;
 }
 
+void *dm_zalloc_aux_debug(size_t s, const char *file, int line)
+{
+       void *ptr = dm_malloc_aux_debug(s, file, line);
+
+       if (ptr)
+               memset(ptr, 0, s);
+
+       return ptr;
+}
+
 void dm_free_aux(void *p)
 {
        char *ptr;
@@ -250,3 +260,13 @@ void *dm_malloc_aux(size_t s, const char *file __attribute__((unused)),
 
        return malloc(s);
 }
+
+void *dm_zalloc_aux(size_t s, const char *file, int line)
+{
+       void *ptr = dm_malloc_aux(s, file, line);
+
+       if (ptr)
+               memset(ptr, 0, s);
+
+       return ptr;
+}

diff --git a/libdm/mm/pool-fast.c b/libdm/mm/pool-fast.c
index daad79aaa5b704bbfb29ae36f66474e00ed0b041..d9030cfaad0058e2b1d7370013b903ed28b93cb1 100644 (file)
--- a/libdm/mm/pool-fast.c
+++ b/libdm/mm/pool-fast.c
@@ -43,14 +43,13 @@ static void _free_chunk(struct chunk *c);
 struct dm_pool *dm_pool_create(const char *name, size_t chunk_hint)
 {
        size_t new_size = 1024;
-       struct dm_pool *p = dm_malloc(sizeof(*p));
+       struct dm_pool *p = dm_zalloc(sizeof(*p));
 
        if (!p) {
                log_error("Couldn't create memory pool %s (size %"
                          PRIsize_t ")", name, sizeof(*p));
                return 0;
        }
-       memset(p, 0, sizeof(*p));
 
        /* round chunk_hint up to the next power of 2 */
        p->chunk_size = chunk_hint + sizeof(struct chunk);

diff --git a/libdm/regex/matcher.c b/libdm/regex/matcher.c
index a88c048d35bfa25cbad5cf77136b30ec6f121c61..17f33a4171cee1ba55fa21ca5bfd164c1a1c6ec7 100644 (file)
--- a/libdm/regex/matcher.c
+++ b/libdm/regex/matcher.c
@@ -320,11 +320,9 @@ struct dm_regex *dm_regex_create(struct dm_pool *mem, const char **patterns,
        struct dm_regex *m;
        struct dm_pool *scratch = mem;
 
-       if (!(m = dm_pool_alloc(mem, sizeof(*m))))
+       if (!(m = dm_pool_zalloc(mem, sizeof(*m))))
                return_NULL;
 
-       memset(m, 0, sizeof(*m));
-
        /* join the regexps together, delimiting with zero */
        for (i = 0; i < num_patterns; i++)
                len += strlen(patterns[i]) + 8;

diff --git a/tools/dmsetup.c b/tools/dmsetup.c
index 885566709a9997d3ac49fbc90a035f72bcc74066..f094f3fb17c4bca93128005f774abff65a798b98 100644 (file)
--- a/tools/dmsetup.c
+++ b/tools/dmsetup.c
@@ -730,13 +730,11 @@ static int _message(int argc, char **argv, void *data __attribute__((unused)))
        for (i = 0; i < argc; i++)
                sz += strlen(argv[i]) + 1;
 
-       if (!(str = dm_malloc(sz))) {
+       if (!(str = dm_zalloc(sz))) {
                err("message string allocation failed");
                goto out;
        }
 
-       memset(str, 0, sz);
-
        for (i = 0; i < argc; i++) {
                if (i)
                        strcat(str, " ");