device_mapper: remove dbg_malloc.

I wrote dbg_malloc before we had valgrind.  These days there's just
no need.

2 files changed, 68 insertions, 68 deletions

diff --git a/daemons/dmeventd/dmeventd.c b/daemons/dmeventd/dmeventd.c
index 533186b97..4b4e1f0fd 100644
--- a/daemons/dmeventd/dmeventd.c
+++ b/daemons/dmeventd/dmeventd.c
@@ -264,19 +264,19 @@ static pthread_cond_t _timeout_cond = PTHREAD_COND_INITIALIZER;
 /* DSO data allocate/free. */
 static void _free_dso_data(struct dso_data *data)
 {
-	dm_free(data->dso_name);
-	dm_free(data);
+	free(data->dso_name);
+	free(data);
 }
 
 static struct dso_data *_alloc_dso_data(struct message_data *data)
 {
-	struct dso_data *ret = (typeof(ret)) dm_zalloc(sizeof(*ret));
+	struct dso_data *ret = (typeof(ret)) zalloc(sizeof(*ret));
 
 	if (!ret)
 		return_NULL;
 
-	if (!(ret->dso_name = dm_strdup(data->dso_name))) {
-		dm_free(ret);
+	if (!(ret->dso_name = strdup(data->dso_name))) {
+		free(ret);
 		return_NULL;
 	}
 
@@ -397,9 +397,9 @@ static void _free_thread_status(struct thread_status *thread)
 	_lib_put(thread->dso_data);
 	if (thread->wait_task)
 		dm_task_destroy(thread->wait_task);
-	dm_free(thread->device.uuid);
-	dm_free(thread->device.name);
-	dm_free(thread);
+	free(thread->device.uuid);
+	free(thread->device.name);
+	free(thread);
 }
 
 /* Note: events_field must not be 0, ensured by caller */
@@ -408,7 +408,7 @@ static struct thread_status *_alloc_thread_status(const struct message_data *dat
 {
 	struct thread_status *thread;
 
-	if (!(thread = dm_zalloc(sizeof(*thread)))) {
+	if (!(thread = zalloc(sizeof(*thread)))) {
 		log_error("Cannot create new thread, out of memory.");
 		return NULL;
 	}
@@ -422,11 +422,11 @@ static struct thread_status *_alloc_thread_status(const struct message_data *dat
 	if (!dm_task_set_uuid(thread->wait_task, data->device_uuid))
 		goto_out;
 
-	if (!(thread->device.uuid = dm_strdup(data->device_uuid)))
+	if (!(thread->device.uuid = strdup(data->device_uuid)))
 		goto_out;
 
 	/* Until real name resolved, use UUID */
-	if (!(thread->device.name = dm_strdup(data->device_uuid)))
+	if (!(thread->device.name = strdup(data->device_uuid)))
 		goto_out;
 
 	/* runs ioctl and may register lvm2 pluging */
@@ -515,7 +515,7 @@ static int _fetch_string(char **ptr, char **src, const int delimiter)
 	if ((p = strchr(*src, delimiter))) {
 		if (*src < p) {
 			*p = 0; /* Temporary exit with \0 */
-			if (!(*ptr = dm_strdup(*src))) {
+			if (!(*ptr = strdup(*src))) {
 				log_error("Failed to fetch item %s.", *src);
 				ret = 0; /* Allocation fail */
 			}
@@ -525,7 +525,7 @@ static int _fetch_string(char **ptr, char **src, const int delimiter)
 		(*src)++; /* Skip delmiter, next field */
 	} else if ((len = strlen(*src))) {
 		/* No delimiter, item ends with '\0' */
-		if (!(*ptr = dm_strdup(*src))) {
+		if (!(*ptr = strdup(*src))) {
 			log_error("Failed to fetch last item %s.", *src);
 			ret = 0; /* Fail */
 		}
@@ -538,11 +538,11 @@ out:
 /* Free message memory. */
 static void _free_message(struct message_data *message_data)
 {
-	dm_free(message_data->id);
-	dm_free(message_data->dso_name);
-	dm_free(message_data->device_uuid);
-	dm_free(message_data->events_str);
-	dm_free(message_data->timeout_str);
+	free(message_data->id);
+	free(message_data->dso_name);
+	free(message_data->device_uuid);
+	free(message_data->events_str);
+	free(message_data->timeout_str);
 }
 
 /* Parse a register message from the client. */
@@ -574,7 +574,7 @@ static int _parse_message(struct message_data *message_data)
 		ret = 1;
 	}
 
-	dm_free(msg->data);
+	free(msg->data);
 	msg->data = NULL;
 
 	return ret;
@@ -608,8 +608,8 @@ static int _fill_device_data(struct thread_status *ts)
 	if (!dm_task_run(dmt))
 		goto fail;
 
-	dm_free(ts->device.name);
-	if (!(ts->device.name = dm_strdup(dm_task_get_name(dmt))))
+	free(ts->device.name);
+	if (!(ts->device.name = strdup(dm_task_get_name(dmt))))
 		goto fail;
 
 	if (!dm_task_get_info(dmt, &dmi))
@@ -696,8 +696,8 @@ static int _get_status(struct message_data *message_data)
 
 	len = strlen(message_data->id);
 	msg->size = size + len + 1;
-	dm_free(msg->data);
-	if (!(msg->data = dm_malloc(msg->size)))
+	free(msg->data);
+	if (!(msg->data = malloc(msg->size)))
 		goto out;
 
 	memcpy(msg->data, message_data->id, len);
@@ -712,7 +712,7 @@ static int _get_status(struct message_data *message_data)
 	ret = 0;
  out:
 	for (j = 0; j < i; ++j)
-		dm_free(buffers[j]);
+		free(buffers[j]);
 
 	return ret;
 }
@@ -721,7 +721,7 @@ static int _get_parameters(struct message_data *message_data) {
 	struct dm_event_daemon_message *msg = message_data->msg;
 	int size;
 
-	dm_free(msg->data);
+	free(msg->data);
 	if ((size = dm_asprintf(&msg->data, "%s pid=%d daemon=%s exec_method=%s",
 				message_data->id, getpid(),
 				_foreground ? "no" : "yes",
@@ -1225,7 +1225,7 @@ static int _registered_device(struct message_data *message_data,
 	int r;
 	struct dm_event_daemon_message *msg = message_data->msg;
 
-	dm_free(msg->data);
+	free(msg->data);
 
 	if ((r = dm_asprintf(&(msg->data), "%s %s %s %u",
 			     message_data->id,
@@ -1365,7 +1365,7 @@ static int _get_timeout(struct message_data *message_data)
 	if (!thread)
 		return -ENODEV;
 
-	dm_free(msg->data);
+	free(msg->data);
 	msg->size = dm_asprintf(&(msg->data), "%s %" PRIu32,
 				message_data->id, thread->timeout);
 
@@ -1502,7 +1502,7 @@ static int _client_read(struct dm_event_fifos *fifos,
 			bytes = 0;
 			if (!size)
 				break; /* No data -> error */
-			buf = msg->data = dm_malloc(msg->size);
+			buf = msg->data = malloc(msg->size);
 			if (!buf)
 				break; /* No mem -> error */
 			header = 0;
@@ -1510,7 +1510,7 @@ static int _client_read(struct dm_event_fifos *fifos,
 	}
 
 	if (bytes != size) {
-		dm_free(msg->data);
+		free(msg->data);
 		msg->data = NULL;
 		return 0;
 	}
@@ -1530,7 +1530,7 @@ static int _client_write(struct dm_event_fifos *fifos,
 	fd_set fds;
 
 	size_t size = 2 * sizeof(uint32_t) + ((msg->data) ? msg->size : 0);
-	uint32_t *header = dm_malloc(size);
+	uint32_t *header = malloc(size);
 	char *buf = (char *)header;
 
 	if (!header) {
@@ -1560,7 +1560,7 @@ static int _client_write(struct dm_event_fifos *fifos,
 	}
 
 	if (header != temp)
-		dm_free(header);
+		free(header);
 
 	return (bytes == size);
 }
@@ -1622,7 +1622,7 @@ static int _do_process_request(struct dm_event_daemon_message *msg)
 			msg->size = dm_asprintf(&(msg->data), "%s %s %d", answer,
 						(msg->cmd == DM_EVENT_CMD_DIE) ? "DYING" : "HELLO",
 						DM_EVENT_PROTOCOL_VERSION);
-			dm_free(answer);
+			free(answer);
 		}
 	} else if (msg->cmd != DM_EVENT_CMD_ACTIVE && !_parse_message(&message_data)) {
 		stack;
@@ -1664,7 +1664,7 @@ static void _process_request(struct dm_event_fifos *fifos)
 
 	DEBUGLOG("<<< CMD:%s (0x%x) completed (result %d).", decode_cmd(cmd), cmd, msg.cmd);
 
-	dm_free(msg.data);
+	free(msg.data);
 
 	if (cmd == DM_EVENT_CMD_DIE) {
 		if (unlink(DMEVENTD_PIDFILE))
@@ -1975,7 +1975,7 @@ static int _reinstate_registrations(struct dm_event_fifos *fifos)
 	int i, ret;
 
 	ret = daemon_talk(fifos, &msg, DM_EVENT_CMD_HELLO, NULL, NULL, 0, 0);
-	dm_free(msg.data);
+	free(msg.data);
 	msg.data = NULL;
 
 	if (ret) {
@@ -2061,13 +2061,13 @@ static void _restart_dmeventd(void)
 			++count;
 		}
 
-	if (!(_initial_registrations = dm_malloc(sizeof(char*) * (count + 1)))) {
+	if (!(_initial_registrations = malloc(sizeof(char*) * (count + 1)))) {
 		fprintf(stderr, "Memory allocation registration failed.\n");
 		goto bad;
 	}
 
 	for (i = 0; i < count; ++i) {
-		if (!(_initial_registrations[i] = dm_strdup(message))) {
+		if (!(_initial_registrations[i] = strdup(message))) {
 			fprintf(stderr, "Memory allocation for message failed.\n");
 			goto bad;
 		}
diff --git a/daemons/dmeventd/libdevmapper-event.c b/daemons/dmeventd/libdevmapper-event.c
index 7f0722831..4673f015a 100644
--- a/daemons/dmeventd/libdevmapper-event.c
+++ b/daemons/dmeventd/libdevmapper-event.c
@@ -49,8 +49,8 @@ struct dm_event_handler {
 
 static void _dm_event_handler_clear_dev_info(struct dm_event_handler *dmevh)
 {
-	dm_free(dmevh->dev_name);
-	dm_free(dmevh->uuid);
+	free(dmevh->dev_name);
+	free(dmevh->uuid);
 	dmevh->dev_name = dmevh->uuid = NULL;
 	dmevh->major = dmevh->minor = 0;
 }
@@ -59,7 +59,7 @@ struct dm_event_handler *dm_event_handler_create(void)
 {
 	struct dm_event_handler *dmevh;
 
-	if (!(dmevh = dm_zalloc(sizeof(*dmevh)))) {
+	if (!(dmevh = zalloc(sizeof(*dmevh)))) {
 		log_error("Failed to allocate event handler.");
 		return NULL;
 	}
@@ -70,9 +70,9 @@ struct dm_event_handler *dm_event_handler_create(void)
 void dm_event_handler_destroy(struct dm_event_handler *dmevh)
 {
 	_dm_event_handler_clear_dev_info(dmevh);
-	dm_free(dmevh->dso);
-	dm_free(dmevh->dmeventd_path);
-	dm_free(dmevh);
+	free(dmevh->dso);
+	free(dmevh->dmeventd_path);
+	free(dmevh);
 }
 
 int dm_event_handler_set_dmeventd_path(struct dm_event_handler *dmevh, const char *dmeventd_path)
@@ -80,9 +80,9 @@ int dm_event_handler_set_dmeventd_path(struct dm_event_handler *dmevh, const cha
 	if (!dmeventd_path) /* noop */
 		return 0;
 
-	dm_free(dmevh->dmeventd_path);
+	free(dmevh->dmeventd_path);
 
-	if (!(dmevh->dmeventd_path = dm_strdup(dmeventd_path)))
+	if (!(dmevh->dmeventd_path = strdup(dmeventd_path)))
 		return -ENOMEM;
 
 	return 0;
@@ -93,9 +93,9 @@ int dm_event_handler_set_dso(struct dm_event_handler *dmevh, const char *path)
 	if (!path) /* noop */
 		return 0;
 
-	dm_free(dmevh->dso);
+	free(dmevh->dso);
 
-	if (!(dmevh->dso = dm_strdup(path)))
+	if (!(dmevh->dso = strdup(path)))
 		return -ENOMEM;
 
 	return 0;
@@ -108,7 +108,7 @@ int dm_event_handler_set_dev_name(struct dm_event_handler *dmevh, const char *de
 
 	_dm_event_handler_clear_dev_info(dmevh);
 
-	if (!(dmevh->dev_name = dm_strdup(dev_name)))
+	if (!(dmevh->dev_name = strdup(dev_name)))
 		return -ENOMEM;
 
 	return 0;
@@ -121,7 +121,7 @@ int dm_event_handler_set_uuid(struct dm_event_handler *dmevh, const char *uuid)
 
 	_dm_event_handler_clear_dev_info(dmevh);
 
-	if (!(dmevh->uuid = dm_strdup(uuid)))
+	if (!(dmevh->uuid = strdup(uuid)))
 		return -ENOMEM;
 
 	return 0;
@@ -261,7 +261,7 @@ static int _daemon_read(struct dm_event_fifos *fifos,
 		if (header && (bytes == 2 * sizeof(uint32_t))) {
 			msg->cmd = ntohl(header[0]);
 			msg->size = ntohl(header[1]);
-			buf = msg->data = dm_malloc(msg->size);
+			buf = msg->data = malloc(msg->size);
 			size = msg->size;
 			bytes = 0;
 			header = 0;
@@ -269,7 +269,7 @@ static int _daemon_read(struct dm_event_fifos *fifos,
 	}
 
 	if (bytes != size) {
-		dm_free(msg->data);
+		free(msg->data);
 		msg->data = NULL;
 	}
 	return bytes == size;
@@ -372,13 +372,13 @@ int daemon_talk(struct dm_event_fifos *fifos,
 	 */
 	if (!_daemon_write(fifos, msg)) {
 		stack;
-		dm_free(msg->data);
+		free(msg->data);
 		msg->data = NULL;
 		return -EIO;
 	}
 
 	do {
-		dm_free(msg->data);
+		free(msg->data);
 		msg->data = NULL;
 
 		if (!_daemon_read(fifos, msg)) {
@@ -621,7 +621,7 @@ static int _do_event(int cmd, char *dmeventd_path, struct dm_event_daemon_messag
 
 	ret = daemon_talk(&fifos, msg, DM_EVENT_CMD_HELLO, NULL, NULL, 0, 0);
 
-	dm_free(msg->data);
+	free(msg->data);
 	msg->data = 0;
 
 	if (!ret)
@@ -661,7 +661,7 @@ int dm_event_register_handler(const struct dm_event_handler *dmevh)
 		ret = 0;
 	}
 
-	dm_free(msg.data);
+	free(msg.data);
 
 	dm_task_destroy(dmt);
 
@@ -688,7 +688,7 @@ int dm_event_unregister_handler(const struct dm_event_handler *dmevh)
 		ret = 0;
 	}
 
-	dm_free(msg.data);
+	free(msg.data);
 
 	dm_task_destroy(dmt);
 
@@ -704,7 +704,7 @@ static char *_fetch_string(char **src, const int delimiter)
 	if ((p = strchr(*src, delimiter)))
 		*p = 0;
 
-	if ((ret = dm_strdup(*src)))
+	if ((ret = strdup(*src)))
 		*src += strlen(ret) + 1;
 
 	if (p)
@@ -724,11 +724,11 @@ static int _parse_message(struct dm_event_daemon_message *msg, char **dso_name,
 	    (*dso_name = _fetch_string(&p, ' ')) &&
 	    (*uuid = _fetch_string(&p, ' '))) {
 		*evmask = atoi(p);
-		dm_free(id);
+		free(id);
 		return 0;
 	}
 
-	dm_free(id);
+	free(id);
 	return -ENOMEM;
 }
 
@@ -770,7 +770,7 @@ int dm_event_get_registered_device(struct dm_event_handler *dmevh, int next)
 	dm_task_destroy(dmt);
 	dmt = NULL;
 
-	dm_free(msg.data);
+	free(msg.data);
 	msg.data = NULL;
 
 	_dm_event_handler_clear_dev_info(dmevh);
@@ -779,7 +779,7 @@ int dm_event_get_registered_device(struct dm_event_handler *dmevh, int next)
 		goto fail;
 	}
 
-	if (!(dmevh->uuid = dm_strdup(reply_uuid))) {
+	if (!(dmevh->uuid = strdup(reply_uuid))) {
 		ret = -ENOMEM;
 		goto fail;
 	}
@@ -792,13 +792,13 @@ int dm_event_get_registered_device(struct dm_event_handler *dmevh, int next)
 	dm_event_handler_set_dso(dmevh, reply_dso);
 	dm_event_handler_set_event_mask(dmevh, reply_mask);
 
-	dm_free(reply_dso);
+	free(reply_dso);
 	reply_dso = NULL;
 
-	dm_free(reply_uuid);
+	free(reply_uuid);
 	reply_uuid = NULL;
 
-	if (!(dmevh->dev_name = dm_strdup(dm_task_get_name(dmt)))) {
+	if (!(dmevh->dev_name = strdup(dm_task_get_name(dmt)))) {
 		ret = -ENOMEM;
 		goto fail;
 	}
@@ -816,9 +816,9 @@ int dm_event_get_registered_device(struct dm_event_handler *dmevh, int next)
 	return ret;
 
  fail:
-	dm_free(msg.data);
-	dm_free(reply_dso);
-	dm_free(reply_uuid);
+	free(msg.data);
+	free(reply_dso);
+	free(reply_uuid);
 	_dm_event_handler_clear_dev_info(dmevh);
 	if (dmt)
 		dm_task_destroy(dmt);
@@ -983,12 +983,12 @@ int dm_event_get_timeout(const char *device_path, uint32_t *timeout)
 		if (!p) {
 			log_error("Malformed reply from dmeventd '%s'.",
 				  msg.data);
-			dm_free(msg.data);
+			free(msg.data);
 			return -EIO;
 		}
 		*timeout = atoi(p);
 	}
-	dm_free(msg.data);
+	free(msg.data);
 
 	return ret;
 }