device-mapper: Fork libdm internally.

The device-mapper directory now holds a copy of libdm source.  At
the moment this code is identical to libdm.  Over time code will
migrate out to appropriate places (see doc/refactoring.txt).

The libdm directory still exists, and contains the source for the
libdevmapper shared library, which we will continue to ship (though
not neccessarily update).

All code using libdm should now use the version in device-mapper.

1 files changed, 5104 insertions, 0 deletions

diff --git a/device_mapper/libdm-report.c b/device_mapper/libdm-report.c
new file mode 100644
index 000000000..3a48c3f46
--- /dev/null
+++ b/device_mapper/libdm-report.c
@@ -0,0 +1,5104 @@
+/*
+ * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004-2015 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of the device-mapper userspace tools.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU Lesser General Public License v.2.1.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "misc/dmlib.h"
+
+#include <ctype.h>
+#include <math.h>  /* fabs() */
+#include <float.h> /* DBL_EPSILON */
+#include <time.h>
+
+/*
+ * Internal flags
+ */
+#define RH_SORT_REQUIRED	0x00000100
+#define RH_HEADINGS_PRINTED	0x00000200
+#define RH_FIELD_CALC_NEEDED	0x00000400
+#define RH_ALREADY_REPORTED	0x00000800
+
+struct selection {
+	struct dm_pool *mem;
+	struct selection_node *selection_root;
+	int add_new_fields;
+};
+
+struct report_group_item;
+
+struct dm_report {
+	struct dm_pool *mem;
+
+	/**
+	 * Cache the first row allocated so that all rows and fields
+	 * can be disposed of in a single dm_pool_free() call.
+	 */
+	struct row *first_row;
+
+	/* To report all available types */
+#define REPORT_TYPES_ALL	UINT32_MAX
+	uint32_t report_types;
+	const char *output_field_name_prefix;
+	const char *field_prefix;
+	uint32_t flags;
+	const char *separator;
+
+	uint32_t keys_count;
+
+	/* Ordered list of fields needed for this report */
+	struct dm_list field_props;
+
+	/* Rows of report data */
+	struct dm_list rows;
+
+	/* Array of field definitions */
+	const struct dm_report_field_type *fields;
+	const char **canonical_field_ids;
+	const struct dm_report_object_type *types;
+
+	/* To store caller private data */
+	void *private;
+
+	/* Selection handle */
+	struct selection *selection;
+
+	/* Null-terminated array of reserved values */
+	const struct dm_report_reserved_value *reserved_values;
+	struct dm_hash_table *value_cache;
+
+	struct report_group_item *group_item;
+};
+
+struct dm_report_group {
+	dm_report_group_type_t type;
+	struct dm_pool *mem;
+	struct dm_list items;
+	int indent;
+};
+
+struct report_group_item {
+	struct dm_list list;
+	struct dm_report_group *group;
+	struct dm_report *report;
+	union {
+		uint32_t orig_report_flags;
+		uint32_t finished_count;
+	} store;
+	struct report_group_item *parent;
+	unsigned output_done:1;
+	unsigned needs_closing:1;
+	void *data;
+};
+
+/*
+ * Internal per-field flags
+ */
+#define FLD_HIDDEN	0x00001000
+#define FLD_SORT_KEY	0x00002000
+#define FLD_ASCENDING	0x00004000
+#define FLD_DESCENDING	0x00008000
+#define FLD_COMPACTED	0x00010000
+#define FLD_COMPACT_ONE 0x00020000
+
+struct field_properties {
+	struct dm_list list;
+	uint32_t field_num;
+	uint32_t sort_posn;
+	int32_t initial_width;
+	int32_t width; /* current width: adjusted by dm_report_object() */
+	const struct dm_report_object_type *type;
+	uint32_t flags;
+	int implicit;
+};
+
+/*
+ * Report selection
+ */
+struct op_def {
+	const char *string;
+	uint32_t flags;
+	const char *desc;
+};
+
+#define FLD_CMP_MASK		0x0FF00000
+#define FLD_CMP_UNCOMPARABLE	0x00100000
+#define FLD_CMP_EQUAL		0x00200000
+#define FLD_CMP_NOT		0x00400000
+#define FLD_CMP_GT		0x00800000
+#define FLD_CMP_LT		0x01000000
+#define FLD_CMP_REGEX		0x02000000
+#define FLD_CMP_NUMBER		0x04000000
+#define FLD_CMP_TIME		0x08000000
+/*
+ * #define FLD_CMP_STRING 0x10000000
+ * We could define FLD_CMP_STRING here for completeness here,
+ * but it's not needed - we can check operator compatibility with
+ * field type by using FLD_CMP_REGEX, FLD_CMP_NUMBER and
+ * FLD_CMP_TIME flags only.
+ */
+
+/*
+ * When defining operators, always define longer one before
+ * shorter one if one is a prefix of another!
+ * (e.g. =~ comes before =)
+*/
+static struct op_def _op_cmp[] = {
+	{ "=~", FLD_CMP_REGEX, "Matching regular expression. [regex]" },
+	{ "!~", FLD_CMP_REGEX|FLD_CMP_NOT, "Not matching regular expression. [regex]" },
+	{ "=", FLD_CMP_EQUAL, "Equal to. [number, size, percent, string, string list, time]" },
+	{ "!=", FLD_CMP_NOT|FLD_CMP_EQUAL, "Not equal to. [number, size, percent, string, string_list, time]" },
+	{ ">=", FLD_CMP_NUMBER|FLD_CMP_TIME|FLD_CMP_GT|FLD_CMP_EQUAL, "Greater than or equal to. [number, size, percent, time]" },
+	{ ">", FLD_CMP_NUMBER|FLD_CMP_TIME|FLD_CMP_GT, "Greater than. [number, size, percent, time]" },
+	{ "<=", FLD_CMP_NUMBER|FLD_CMP_TIME|FLD_CMP_LT|FLD_CMP_EQUAL, "Less than or equal to. [number, size, percent, time]" },
+	{ "<", FLD_CMP_NUMBER|FLD_CMP_TIME|FLD_CMP_LT, "Less than. [number, size, percent, time]" },
+	{ "since", FLD_CMP_TIME|FLD_CMP_GT|FLD_CMP_EQUAL, "Since specified time (same as '>='). [time]" },
+	{ "after", FLD_CMP_TIME|FLD_CMP_GT, "After specified time (same as '>'). [time]"},
+	{ "until", FLD_CMP_TIME|FLD_CMP_LT|FLD_CMP_EQUAL, "Until specified time (same as '<='). [time]"},
+	{ "before", FLD_CMP_TIME|FLD_CMP_LT, "Before specified time (same as '<'). [time]"},
+	{ NULL, 0, NULL }
+};
+
+#define SEL_MASK		0x000000FF
+#define SEL_ITEM		0x00000001
+#define SEL_AND 		0x00000002
+#define SEL_OR			0x00000004
+
+#define SEL_MODIFIER_MASK	0x00000F00
+#define SEL_MODIFIER_NOT	0x00000100
+
+#define SEL_PRECEDENCE_MASK	0x0000F000
+#define SEL_PRECEDENCE_PS	0x00001000
+#define SEL_PRECEDENCE_PE	0x00002000
+
+#define SEL_LIST_MASK		0x000F0000
+#define SEL_LIST_LS		0x00010000
+#define SEL_LIST_LE		0x00020000
+#define SEL_LIST_SUBSET_LS	0x00040000
+#define SEL_LIST_SUBSET_LE	0x00080000
+
+static struct op_def _op_log[] = {
+	{ "&&", SEL_AND, "All fields must match" },
+	{ ",", SEL_AND, "All fields must match" },
+	{ "||", SEL_OR, "At least one field must match" },
+	{ "#", SEL_OR, "At least one field must match" },
+	{ "!", SEL_MODIFIER_NOT, "Logical negation" },
+	{ "(", SEL_PRECEDENCE_PS, "Left parenthesis" },
+	{ ")", SEL_PRECEDENCE_PE, "Right parenthesis" },
+	{ "[", SEL_LIST_LS, "List start" },
+	{ "]", SEL_LIST_LE, "List end"},
+	{ "{", SEL_LIST_SUBSET_LS, "List subset start"},
+	{ "}", SEL_LIST_SUBSET_LE, "List subset end"},
+	{ NULL,  0, NULL},
+};
+
+struct selection_str_list {
+	struct dm_str_list str_list;
+	unsigned type;			/* either SEL_AND or SEL_OR */
+};
+
+struct field_selection_value {
+	union {
+		const char *s;
+		uint64_t i;
+		time_t t;
+		double d;
+		struct dm_regex *r;
+		struct selection_str_list *l;
+	} v;
+	struct field_selection_value *next;
+};
+
+struct field_selection {
+	struct field_properties *fp;
+	uint32_t flags;
+	struct field_selection_value *value;
+};
+
+struct selection_node {
+	struct dm_list list;
+	uint32_t type;
+	union {
+		struct field_selection *item;
+		struct dm_list set;
+	} selection;
+};
+
+struct reserved_value_wrapper {
+	const char *matched_name;
+	const struct dm_report_reserved_value *reserved;
+	const void *value;
+};
+
+/*
+ * Report data field
+ */
+struct dm_report_field {
+	struct dm_list list;
+	struct field_properties *props;
+
+	const char *report_string;	/* Formatted ready for display */
+	const void *sort_value;		/* Raw value for sorting */
+};
+
+struct row {
+	struct dm_list list;
+	struct dm_report *rh;
+	struct dm_list fields;			  /* Fields in display order */
+	struct dm_report_field *(*sort_fields)[]; /* Fields in sort order */
+	int selected;
+	struct dm_report_field *field_sel_status;
+};
+
+/*
+ * Implicit report types and fields.
+ */
+#define SPECIAL_REPORT_TYPE 0x80000000
+#define SPECIAL_FIELD_SELECTED_ID "selected"
+#define SPECIAL_FIELD_HELP_ID "help"
+#define SPECIAL_FIELD_HELP_ALT_ID "?"
+
+static void *_null_returning_fn(void *obj __attribute__((unused)))
+{
+	return NULL;
+}
+
+static int _no_report_fn(struct dm_report *rh __attribute__((unused)),
+			 struct dm_pool *mem __attribute__((unused)),
+			 struct dm_report_field *field __attribute__((unused)),
+			 const void *data __attribute__((unused)),
+			 void *private __attribute__((unused)))
+{
+	return 1;
+}
+
+static int _selected_disp(struct dm_report *rh,
+			  struct dm_pool *mem __attribute__((unused)),
+			  struct dm_report_field *field,
+			  const void *data,
+			  void *private __attribute__((unused)))
+{
+	const struct row *row = (const struct row *)data;
+	return dm_report_field_int(rh, field, &row->selected);
+}
+
+static const struct dm_report_object_type _implicit_special_report_types[] = {
+	{ SPECIAL_REPORT_TYPE, "Special", "special_", _null_returning_fn },
+	{ 0, "", "", NULL }
+};
+
+static const struct dm_report_field_type _implicit_special_report_fields[] = {
+	{ SPECIAL_REPORT_TYPE, DM_REPORT_FIELD_TYPE_NUMBER | FLD_CMP_UNCOMPARABLE , 0, 8, SPECIAL_FIELD_HELP_ID, "Help", _no_report_fn, "Show help." },
+	{ SPECIAL_REPORT_TYPE, DM_REPORT_FIELD_TYPE_NUMBER | FLD_CMP_UNCOMPARABLE , 0, 8, SPECIAL_FIELD_HELP_ALT_ID, "Help", _no_report_fn, "Show help." },
+	{ 0, 0, 0, 0, "", "", 0, 0}
+};
+
+static const struct dm_report_field_type _implicit_special_report_fields_with_selection[] = {
+	{ SPECIAL_REPORT_TYPE, DM_REPORT_FIELD_TYPE_NUMBER, 0, 8, SPECIAL_FIELD_SELECTED_ID, "Selected", _selected_disp, "Set if item passes selection criteria." },
+	{ SPECIAL_REPORT_TYPE, DM_REPORT_FIELD_TYPE_NUMBER | FLD_CMP_UNCOMPARABLE , 0, 8, SPECIAL_FIELD_HELP_ID, "Help", _no_report_fn, "Show help." },
+	{ SPECIAL_REPORT_TYPE, DM_REPORT_FIELD_TYPE_NUMBER | FLD_CMP_UNCOMPARABLE , 0, 8, SPECIAL_FIELD_HELP_ALT_ID, "Help", _no_report_fn, "Show help." },
+	{ 0, 0, 0, 0, "", "", 0, 0}
+};
+
+static const struct dm_report_object_type *_implicit_report_types = _implicit_special_report_types;
+static const struct dm_report_field_type *_implicit_report_fields = _implicit_special_report_fields;
+
+static const struct dm_report_object_type *_find_type(struct dm_report *rh,
+						      uint32_t report_type)
+{
+	const struct dm_report_object_type *t;
+
+	for (t = _implicit_report_types; t->data_fn; t++)
+		if (t->id == report_type)
+			return t;
+
+	for (t = rh->types; t->data_fn; t++)
+		if (t->id == report_type)
+			return t;
+
+	return NULL;
+}
+
+/*
+ * Data-munging functions to prepare each data type for display and sorting
+ */
+
+int dm_report_field_string(struct dm_report *rh,
+			   struct dm_report_field *field, const char *const *data)
+{
+	char *repstr;
+
+	if (!(repstr = dm_pool_strdup(rh->mem, *data))) {
+		log_error("dm_report_field_string: dm_pool_strdup failed");
+		return 0;
+	}
+
+	field->report_string = repstr;
+	field->sort_value = (const void *) field->report_string;
+
+	return 1;
+}
+
+int dm_report_field_percent(struct dm_report *rh,
+			    struct dm_report_field *field,
+			    const dm_percent_t *data)
+{
+	char *repstr;
+	uint64_t *sortval;
+
+	if (!(sortval = dm_pool_alloc(rh->mem, sizeof(uint64_t)))) {
+		log_error("dm_report_field_percent: dm_pool_alloc failed for sort_value.");
+		return 0;
+	}
+
+	*sortval = (uint64_t)(*data);
+
+	if (*data == DM_PERCENT_INVALID) {
+		dm_report_field_set_value(field, "", sortval);
+		return 1;
+	}
+
+	if (!(repstr = dm_pool_alloc(rh->mem, 8))) {
+		dm_pool_free(rh->mem, sortval);
+		log_error("dm_report_field_percent: dm_pool_alloc failed for percent report string.");
+		return 0;
+	}
+
+	if (dm_snprintf(repstr, 7, "%.2f", dm_percent_to_round_float(*data, 2)) < 0) {
+		dm_pool_free(rh->mem, sortval);
+		log_error("dm_report_field_percent: percentage too large.");
+		return 0;
+	}
+
+	dm_report_field_set_value(field, repstr, sortval);
+	return 1;
+}
+
+struct str_list_sort_value_item {
+	unsigned pos;
+	size_t len;
+};
+
+struct str_list_sort_value {
+	const char *value;
+	struct str_list_sort_value_item *items;
+};
+
+struct str_list_sort_item {
+	const char *str;
+	struct str_list_sort_value_item item;
+};
+
+static int _str_list_sort_item_cmp(const void *a, const void *b)
+{
+	const struct str_list_sort_item *slsi_a = (const struct str_list_sort_item *) a;
+	const struct str_list_sort_item *slsi_b = (const struct str_list_sort_item *) b;
+
+	return strcmp(slsi_a->str, slsi_b->str);
+}
+
+static int _report_field_string_list(struct dm_report *rh,
+				     struct dm_report_field *field,
+				     const struct dm_list *data,
+				     const char *delimiter,
+				     int sort)
+{
+	static const char _string_list_grow_object_failed_msg[] = "dm_report_field_string_list: dm_pool_grow_object_failed";
+	struct str_list_sort_value *sort_value = NULL;
+	unsigned int list_size, pos, i;
+	struct str_list_sort_item *arr = NULL;
+	struct dm_str_list *sl;
+	size_t delimiter_len, len;
+	void *object;
+	int r = 0;
+
+	if (!(sort_value = dm_pool_zalloc(rh->mem, sizeof(struct str_list_sort_value)))) {
+		log_error("dm_report_field_string_list: dm_pool_zalloc failed for sort_value");
+		return 0;
+	}
+
+	list_size = dm_list_size(data);
+
+	/*
+	 * Sort value stores the pointer to the report_string and then
+	 * position and length for each list element withing the report_string.
+	 * The first element stores number of elements in 'len' (therefore
+	 * list_size + 1 is used below for the extra element).
+	 * For example, with this input:
+	 *   sort = 0;  (we don't want to report sorted)
+	 *   report_string = "abc,xy,defgh";  (this is reported)
+	 *
+	 * ...we end up with:
+	 *   sort_value->value = report_string; (we'll use the original report_string for indices)
+	 *   sort_value->items[0] = {0,3};  (we have 3 items)
+	 *   sort_value->items[1] = {0,3};  ("abc")
+	 *   sort_value->items[2] = {7,5};  ("defgh")
+	 *   sort_value->items[3] = {4,2};  ("xy")
+	 *
+	 *   The items alone are always sorted while in report_string they can be
+	 *   sorted or not (based on "sort" arg) - it depends on how we prefer to
+	 *   display the list. Having items sorted internally helps with searching
+	 *   through them.
+	 */
+	if (!(sort_value->items = dm_pool_zalloc(rh->mem, (list_size + 1) * sizeof(struct str_list_sort_value_item)))) {
+		log_error("dm_report_fiel_string_list: dm_pool_zalloc failed for sort value items");
+		goto out;
+	}
+	sort_value->items[0].len = list_size;
+
+	/* zero items */
+	if (!list_size) {
+		sort_value->value = field->report_string = "";
+		field->sort_value = sort_value;
+		return 1;
+	}
+
+	/* one item */
+	if (list_size == 1) {
+		sl = (struct dm_str_list *) dm_list_first(data);
+		if (!sl ||
+		    !(sort_value->value = field->report_string = dm_pool_strdup(rh->mem, sl->str))) {
+			log_error("dm_report_field_string_list: dm_pool_strdup failed");
+			goto out;
+		}
+		sort_value->items[1].pos = 0;
+		sort_value->items[1].len = strlen(sl->str);
+		field->sort_value = sort_value;
+		return 1;
+	}
+
+	/* more than one item - sort the list */
+	if (!(arr = dm_malloc(sizeof(struct str_list_sort_item) * list_size))) {
+		log_error("dm_report_field_string_list: dm_malloc failed");
+		goto out;
+	}
+
+	if (!(dm_pool_begin_object(rh->mem, 256))) {
+		log_error(_string_list_grow_object_failed_msg);
+		goto out;
+	}
+
+	if (!delimiter)
+		delimiter = ",";
+	delimiter_len = strlen(delimiter);
+
+	i = pos = len = 0;
+	dm_list_iterate_items(sl, data) {
+		arr[i].str = sl->str;
+		if (!sort) {
+			/* sorted outpud not required - report the list as it is */
+			len = strlen(sl->str);
+			if (!dm_pool_grow_object(rh->mem, arr[i].str, len) ||
+			    (i+1 != list_size && !dm_pool_grow_object(rh->mem, delimiter, delimiter_len))) {
+				log_error(_string_list_grow_object_failed_msg);
+				goto out;
+			}
+			arr[i].item.pos = pos;
+			arr[i].item.len = len;
+			pos = i+1 == list_size ? pos+len : pos+len+delimiter_len;
+		}
+		i++;
+	}
+
+	qsort(arr, i, sizeof(struct str_list_sort_item), _str_list_sort_item_cmp);
+
+	for (i = 0, pos = 0; i < list_size; i++) {
+		if (sort) {
+			/* sorted output required - report the list as sorted */
+			len = strlen(arr[i].str);
+			if (!dm_pool_grow_object(rh->mem, arr[i].str, len) ||
+			    (i+1 != list_size && !dm_pool_grow_object(rh->mem, delimiter, delimiter_len))) {
+				log_error(_string_list_grow_object_failed_msg);
+				goto out;
+			}
+			/*
+			 * Save position and length of the string
+			 * element in report_string for sort_value.
+			 * Use i+1 here since items[0] stores list size!!!
+			 */
+			sort_value->items[i+1].pos = pos;
+			sort_value->items[i+1].len = len;
+			pos = i+1 == list_size ? pos+len : pos+len+delimiter_len;
+		} else {
+			sort_value->items[i+1].pos = arr[i].item.pos;
+			sort_value->items[i+1].len = arr[i].item.len;
+		}
+	}
+
+	if (!dm_pool_grow_object(rh->mem, "\0", 1)) {
+		log_error(_string_list_grow_object_failed_msg);
+		goto out;
+	}
+
+	object = dm_pool_end_object(rh->mem);
+	sort_value->value = object;
+	field->sort_value = sort_value;
+	field->report_string = object;
+	r = 1;
+out:
+	if (!r && sort_value)
+		dm_pool_free(rh->mem, sort_value);
+	dm_free(arr);
+
+	return r;
+}
+
+int dm_report_field_string_list(struct dm_report *rh,
+				struct dm_report_field *field,
+				const struct dm_list *data,
+				const char *delimiter)
+{
+	return _report_field_string_list(rh, field, data, delimiter, 1);
+}
+
+int dm_report_field_string_list_unsorted(struct dm_report *rh,
+					 struct dm_report_field *field,
+					 const struct dm_list *data,
+					 const char *delimiter)
+{
+	/*
+	 * The raw value is always sorted, just the string reported is unsorted.
+	 * Having the raw value always sorted helps when matching selection list
+	 * with selection criteria.
+	 */
+	return _report_field_string_list(rh, field, data, delimiter, 0);
+}
+
+int dm_report_field_int(struct dm_report *rh,
+			struct dm_report_field *field, const int *data)
+{
+	const int value = *data;
+	uint64_t *sortval;
+	char *repstr;
+
+	if (!(repstr = dm_pool_zalloc(rh->mem, 13))) {
+		log_error("dm_report_field_int: dm_pool_alloc failed");
+		return 0;
+	}
+
+	if (!(sortval = dm_pool_alloc(rh->mem, sizeof(int64_t)))) {
+		log_error("dm_report_field_int: dm_pool_alloc failed");
+		return 0;
+	}
+
+	if (dm_snprintf(repstr, 12, "%d", value) < 0) {
+		log_error("dm_report_field_int: int too big: %d", value);
+		return 0;
+	}
+
+	*sortval = (uint64_t) value;
+	field->sort_value = sortval;
+	field->report_string = repstr;
+
+	return 1;
+}
+
+int dm_report_field_uint32(struct dm_report *rh,
+			   struct dm_report_field *field, const uint32_t *data)
+{
+	const uint32_t value = *data;
+	uint64_t *sortval;
+	char *repstr;
+
+	if (!(repstr = dm_pool_zalloc(rh->mem, 12))) {
+		log_error("dm_report_field_uint32: dm_pool_alloc failed");
+		return 0;
+	}
+
+	if (!(sortval = dm_pool_alloc(rh->mem, sizeof(uint64_t)))) {
+		log_error("dm_report_field_uint32: dm_pool_alloc failed");
+		return 0;
+	}
+
+	if (dm_snprintf(repstr, 11, "%u", value) < 0) {
+		log_error("dm_report_field_uint32: uint32 too big: %u", value);
+		return 0;
+	}
+
+	*sortval = (uint64_t) value;
+	field->sort_value = sortval;
+	field->report_string = repstr;
+
+	return 1;
+}
+
+int dm_report_field_int32(struct dm_report *rh,
+			  struct dm_report_field *field, const int32_t *data)
+{
+	const int32_t value = *data;
+	uint64_t *sortval;
+	char *repstr;
+
+	if (!(repstr = dm_pool_zalloc(rh->mem, 13))) {
+		log_error("dm_report_field_int32: dm_pool_alloc failed");
+		return 0;
+	}
+
+	if (!(sortval = dm_pool_alloc(rh->mem, sizeof(int64_t)))) {
+		log_error("dm_report_field_int32: dm_pool_alloc failed");
+		return 0;
+	}
+
+	if (dm_snprintf(repstr, 12, "%d", value) < 0) {
+		log_error("dm_report_field_int32: int32 too big: %d", value);
+		return 0;
+	}
+
+	*sortval = (uint64_t) value;
+	field->sort_value = sortval;
+	field->report_string = repstr;
+
+	return 1;
+}
+
+int dm_report_field_uint64(struct dm_report *rh,
+			   struct dm_report_field *field, const uint64_t *data)
+{
+	const uint64_t value = *data;
+	uint64_t *sortval;
+	char *repstr;
+
+	if (!(repstr = dm_pool_zalloc(rh->mem, 22))) {
+		log_error("dm_report_field_uint64: dm_pool_alloc failed");
+		return 0;
+	}
+
+	if (!(sortval = dm_pool_alloc(rh->mem, sizeof(uint64_t)))) {
+		log_error("dm_report_field_uint64: dm_pool_alloc failed");
+		return 0;
+	}
+
+	if (dm_snprintf(repstr, 21, FMTu64 , value) < 0) {
+		log_error("dm_report_field_uint64: uint64 too big: %" PRIu64, value);
+		return 0;
+	}
+
+	*sortval = value;
+	field->sort_value = sortval;
+	field->report_string = repstr;
+
+	return 1;
+}
+
+/*
+ * Helper functions for custom report functions
+ */
+void dm_report_field_set_value(struct dm_report_field *field, const void *value, const void *sortvalue)
+{
+	field->report_string = (const char *) value;
+	field->sort_value = sortvalue ? : value;
+
+	if ((field->sort_value == value) &&
+	    (field->props->flags & DM_REPORT_FIELD_TYPE_NUMBER))
+		log_warn(INTERNAL_ERROR "Using string as sort value for numerical field.");
+}
+
+static const char *_get_field_type_name(unsigned field_type)
+{
+	switch (field_type) {
+		case DM_REPORT_FIELD_TYPE_STRING: return "string";
+		case DM_REPORT_FIELD_TYPE_NUMBER: return "number";
+		case DM_REPORT_FIELD_TYPE_SIZE: return "size";
+		case DM_REPORT_FIELD_TYPE_PERCENT: return "percent";
+		case DM_REPORT_FIELD_TYPE_TIME: return "time";
+		case DM_REPORT_FIELD_TYPE_STRING_LIST: return "string list";
+		default: return "unknown";
+	}
+}
+
+/*
+ * show help message
+ */
+static size_t _get_longest_field_id_len(const struct dm_report_field_type *fields)
+{
+	uint32_t f;
+	size_t id_len = 0;
+
+	for (f = 0; fields[f].report_fn; f++)
+		if (strlen(fields[f].id) > id_len)
+			id_len = strlen(fields[f].id);
+
+	return id_len;
+}
+
+static void _display_fields_more(struct dm_report *rh,
+				 const struct dm_report_field_type *fields,
+				 size_t id_len, int display_all_fields_item,
+				 int display_field_types)
+{
+	uint32_t f;
+	const struct dm_report_object_type *type;
+	const char *desc, *last_desc = "";
+
+	for (f = 0; fields[f].report_fn; f++)
+		if (strlen(fields[f].id) > id_len)
+			id_len = strlen(fields[f].id);
+
+	for (type = rh->types; type->data_fn; type++)
+		if (strlen(type->prefix) + 3 > id_len)
+			id_len = strlen(type->prefix) + 3;
+
+	for (f = 0; fields[f].report_fn; f++) {
+		if ((type = _find_type(rh, fields[f].type)) && type->desc)
+			desc = type->desc;
+		else
+			desc = " ";
+		if (desc != last_desc) {
+			if (*last_desc)
+				log_warn(" ");
+			log_warn("%s Fields", desc);
+			log_warn("%*.*s", (int) strlen(desc) + 7,
+				 (int) strlen(desc) + 7,
+				 "-------------------------------------------------------------------------------");
+			if (display_all_fields_item && type->id != SPECIAL_REPORT_TYPE)
+				log_warn("  %sall%-*s - %s", type->prefix,
+					 (int) (id_len - 3 - strlen(type->prefix)), "",
+					 "All fields in this section.");
+		}
+		/* FIXME Add line-wrapping at terminal width (or 80 cols) */
+		log_warn("  %-*s - %s%s%s%s%s", (int) id_len, fields[f].id, fields[f].desc,
+					      display_field_types ? " [" : "",
+					      display_field_types ? fields[f].flags & FLD_CMP_UNCOMPARABLE ? "unselectable " : "" : "",
+					      display_field_types ? _get_field_type_name(fields[f].flags & DM_REPORT_FIELD_TYPE_MASK) : "",
+					      display_field_types ? "]" : "");
+		last_desc = desc;
+	}
+}
+
+/*
+ * show help message
+ */
+static void _display_fields(struct dm_report *rh, int display_all_fields_item,
+			    int display_field_types)
+{
+	size_t tmp, id_len = 0;
+
+	if ((tmp = _get_longest_field_id_len(_implicit_report_fields)) > id_len)
+		id_len = tmp;
+	if ((tmp = _get_longest_field_id_len(rh->fields)) > id_len)
+		id_len = tmp;
+
+	_display_fields_more(rh, rh->fields, id_len, display_all_fields_item,
+			     display_field_types);
+	log_warn(" ");
+	_display_fields_more(rh, _implicit_report_fields, id_len,
+			     display_all_fields_item, display_field_types);
+
+}
+
+/*
+ * Initialise report handle
+ */
+static int _copy_field(struct dm_report *rh, struct field_properties *dest,
+		       uint32_t field_num, int implicit)
+{
+	const struct dm_report_field_type *fields = implicit ? _implicit_report_fields
+							     : rh->fields;
+
+	dest->field_num = field_num;
+	dest->initial_width = fields[field_num].width;
+	dest->width = fields[field_num].width; /* adjusted in _do_report_object() */
+	dest->flags = fields[field_num].flags & DM_REPORT_FIELD_MASK;
+	dest->implicit = implicit;
+
+	/* set object type method */
+	dest->type = _find_type(rh, fields[field_num].type);
+	if (!dest->type) {
+		log_error("dm_report: field not match: %s",
+			  fields[field_num].id);
+		return 0;
+	}
+
+	return 1;
+}
+
+static struct field_properties * _add_field(struct dm_report *rh,
+					    uint32_t field_num, int implicit,
+					    uint32_t flags)
+{
+	struct field_properties *fp;
+
+	if (!(fp = dm_pool_zalloc(rh->mem, sizeof(*fp)))) {
+		log_error("dm_report: struct field_properties allocation "
+			  "failed");
+		return NULL;
+	}
+
+	if (!_copy_field(rh, fp, field_num, implicit)) {
+		stack;
+		dm_pool_free(rh->mem, fp);
+		return NULL;
+	}
+
+	fp->flags |= flags;
+
+	/*
+	 * Place hidden fields at the front so dm_list_end() will
+	 * tell us when we've reached the last visible field.
+	 */
+	if (fp->flags & FLD_HIDDEN)
+		dm_list_add_h(&rh->field_props, &fp->list);
+	else
+		dm_list_add(&rh->field_props, &fp->list);
+
+	return fp;
+}
+
+static int _get_canonical_field_name(const char *field,
+				     size_t flen,
+				     char *canonical_field,
+				     size_t fcanonical_len,
+				     int *differs)
+{
+	size_t i;
+	int diff = 0;
+
+	for (i = 0; *field && flen; field++, flen--) {
+		if (*field == '_') {
+			diff = 1;
+			continue;
+		}
+		if ((i + 1) >= fcanonical_len) {
+			canonical_field[0] = '\0';
+			log_error("%s: field name too long.", field);
+			return 0;
+		}
+		canonical_field[i++] = *field;
+	}
+
+	canonical_field[i] = '\0';
+	if (differs)
+		*differs = diff;
+	return 1;
+}
+
+/*
+ * Compare canonical_name1 against canonical_name2 or prefix
+ * plus canonical_name2. Canonical name is a name where all
+ * superfluous characters are removed (underscores for now).
+ * Both names are always null-terminated.
+ */
+static int _is_same_field(const char *canonical_name1, const char *canonical_name2,
+			  const char *prefix)
+{
+	size_t prefix_len;
+
+	/* Exact match? */
+	if (!strcasecmp(canonical_name1, canonical_name2))
+		return 1;
+
+	/* Match including prefix? */
+	prefix_len = strlen(prefix) - 1;
+	if (!strncasecmp(prefix, canonical_name1, prefix_len) &&
+	    !strcasecmp(canonical_name1 + prefix_len, canonical_name2))
+		return 1;
+
+	return 0;
+}
+
+/*
+ * Check for a report type prefix + "all" match.
+ */
+static void _all_match_combine(const struct dm_report_object_type *types,
+			       unsigned unprefixed_all_matched,
+			       const char *field, size_t flen,
+			       uint32_t *report_types)
+{
+	char field_canon[DM_REPORT_FIELD_TYPE_ID_LEN];
+	const struct dm_report_object_type *t;
+	size_t prefix_len;
+
+	if (!_get_canonical_field_name(field, flen, field_canon, sizeof(field_canon), NULL))
+		return;
+	flen = strlen(field_canon);
+
+	for (t = types; t->data_fn; t++) {
+		prefix_len = strlen(t->prefix) - 1;
+
+		if (!strncasecmp(t->prefix, field_canon, prefix_len) &&
+		    ((unprefixed_all_matched && (flen == prefix_len)) ||
+		     (!strncasecmp(field_canon + prefix_len, "all", 3) &&
+		      (flen == prefix_len + 3))))
+			*report_types |= t->id;
+	}
+}
+
+static uint32_t _all_match(struct dm_report *rh, const char *field, size_t flen)
+{
+	uint32_t report_types = 0;
+	unsigned unprefixed_all_matched = 0;
+
+	if (!strncasecmp(field, "all", 3) && flen == 3) {
+		/* If there's no report prefix, match all report types */
+		if (!(flen = strlen(rh->field_prefix)))
+			return rh->report_types ? : REPORT_TYPES_ALL;
+
+		/* otherwise include all fields beginning with the report prefix. */
+		unprefixed_all_matched = 1;
+		field = rh->field_prefix;
+		report_types = rh->report_types;
+	}
+
+	/* Combine all report types that have a matching prefix. */
+	_all_match_combine(rh->types, unprefixed_all_matched, field, flen, &report_types);
+
+	return report_types;
+}
+
+/*
+ * Add all fields with a matching type.
+ */
+static int _add_all_fields(struct dm_report *rh, uint32_t type)
+{
+	uint32_t f;
+
+	for (f = 0; rh->fields[f].report_fn; f++)
+		if ((rh->fields[f].type & type) && !_add_field(rh, f, 0, 0))
+			return 0;
+
+	return 1;
+}
+
+static int _get_field(struct dm_report *rh, const char *field, size_t flen,
+		      uint32_t *f_ret, int *implicit)
+{
+	char field_canon[DM_REPORT_FIELD_TYPE_ID_LEN];
+	uint32_t f;
+
+	if (!flen)
+		return 0;
+
+	if (!_get_canonical_field_name(field, flen, field_canon, sizeof(field_canon), NULL))
+		return_0;
+
+	for (f = 0; _implicit_report_fields[f].report_fn; f++) {
+		if (_is_same_field(_implicit_report_fields[f].id, field_canon, rh->field_prefix)) {
+			*f_ret = f;
+			*implicit = 1;
+			return 1;
+		}
+	}
+
+	for (f = 0; rh->fields[f].report_fn; f++) {
+		if (_is_same_field(rh->canonical_field_ids[f], field_canon, rh->field_prefix)) {
+			*f_ret = f;
+			*implicit = 0;
+			return 1;
+		}
+	}
+
+	return 0;
+}
+
+static int _field_match(struct dm_report *rh, const char *field, size_t flen,
+			unsigned report_type_only)
+{
+	uint32_t f, type;
+	int implicit;
+
+	if (!flen)
+		return 0;
+
+	if ((_get_field(rh, field, flen, &f, &implicit))) {
+		if (report_type_only) {
+			rh->report_types |= implicit ? _implicit_report_fields[f].type
+						     : rh->fields[f].type;
+			return 1;
+		}
+
+		return _add_field(rh, f, implicit, 0) ? 1 : 0;
+	}
+
+	if ((type = _all_match(rh, field, flen))) {
+		if (report_type_only) {
+			rh->report_types |= type;
+			return 1;
+		}
+
+		return  _add_all_fields(rh, type);
+	}
+
+	return 0;
+}
+
+static int _add_sort_key(struct dm_report *rh, uint32_t field_num, int implicit,
+			 uint32_t flags, unsigned report_type_only)
+{
+	struct field_properties *fp, *found = NULL;
+	const struct dm_report_field_type *fields = implicit ? _implicit_report_fields
+							     : rh->fields;
+
+	dm_list_iterate_items(fp, &rh->field_props) {
+		if ((fp->implicit == implicit) && (fp->field_num == field_num)) {
+			found = fp;
+			break;
+		}
+	}
+
+	if (!found) {
+		if (report_type_only)
+			rh->report_types |= fields[field_num].type;
+		else if (!(found = _add_field(rh, field_num, implicit, FLD_HIDDEN)))
+			return_0;
+	}
+
+	if (report_type_only)
+		return 1;
+
+	if (found->flags & FLD_SORT_KEY) {
+		log_warn("dm_report: Ignoring duplicate sort field: %s.",
+			 fields[field_num].id);
+		return 1;
+	}
+
+	found->flags |= FLD_SORT_KEY;
+	found->sort_posn = rh->keys_count++;
+	found->flags |= flags;
+
+	return 1;
+}
+
+static int _key_match(struct dm_report *rh, const char *key, size_t len,
+		      unsigned report_type_only)
+{
+	char key_canon[DM_REPORT_FIELD_TYPE_ID_LEN];
+	uint32_t f;
+	uint32_t flags;
+
+	if (!len)
+		return 0;
+
+	if (*key == '+') {
+		key++;
+		len--;
+		flags = FLD_ASCENDING;
+	} else if (*key == '-') {
+		key++;
+		len--;
+		flags = FLD_DESCENDING;
+	} else
+		flags = FLD_ASCENDING;
+
+	if (!len) {
+		log_error("dm_report: Missing sort field name");
+		return 0;
+	}
+
+	if (!_get_canonical_field_name(key, len, key_canon, sizeof(key_canon), NULL))
+		return_0;
+
+	for (f = 0; _implicit_report_fields[f].report_fn; f++)
+		if (_is_same_field(_implicit_report_fields[f].id, key_canon, rh->field_prefix))
+			return _add_sort_key(rh, f, 1, flags, report_type_only);
+
+	for (f = 0; rh->fields[f].report_fn; f++)
+		if (_is_same_field(rh->canonical_field_ids[f], key_canon, rh->field_prefix))
+			return _add_sort_key(rh, f, 0, flags, report_type_only);
+
+	return 0;
+}
+
+static int _parse_fields(struct dm_report *rh, const char *format,
+			 unsigned report_type_only)
+{
+	const char *ws;		/* Word start */
+	const char *we = format;	/* Word end */
+
+	while (*we) {
+		/* Allow consecutive commas */
+		while (*we && *we == ',')
+			we++;
+
+		/* start of the field name */
+		ws = we;
+		while (*we && *we != ',')
+			we++;
+
+		if (!_field_match(rh, ws, (size_t) (we - ws), report_type_only)) {
+			_display_fields(rh, 1, 0);
+			log_warn(" ");
+			log_error("Unrecognised field: %.*s", (int) (we - ws), ws);
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+static int _parse_keys(struct dm_report *rh, const char *keys,
+		       unsigned report_type_only)
+{
+	const char *ws;		/* Word start */
+	const char *we = keys;	/* Word end */
+
+	if (!keys)
+		return 1;
+
+	while (*we) {
+		/* Allow consecutive commas */
+		while (*we && *we == ',')
+			we++;
+		ws = we;
+		while (*we && *we != ',')
+			we++;
+		if (!_key_match(rh, ws, (size_t) (we - ws), report_type_only)) {
+			_display_fields(rh, 1, 0);
+			log_warn(" ");
+			log_error("dm_report: Unrecognised field: %.*s", (int) (we - ws), ws);
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+static int _contains_reserved_report_type(const struct dm_report_object_type *types)
+{
+	const struct dm_report_object_type *type, *implicit_type;
+
+	for (implicit_type = _implicit_report_types; implicit_type->data_fn; implicit_type++) {
+		for (type = types; type->data_fn; type++) {
+			if (implicit_type->id & type->id) {
+				log_error(INTERNAL_ERROR "dm_report_init: definition of report "
+					  "types given contains reserved identifier");
+				return 1;
+			}
+		}
+	}
+
+	return 0;
+}
+
+static void _dm_report_init_update_types(struct dm_report *rh, uint32_t *report_types)
+{
+	const struct dm_report_object_type *type;
+
+	if (!report_types)
+		return;
+
+	*report_types = rh->report_types;
+	/*
+	 * Do not include implicit types as these are not understood by
+	 * dm_report_init caller - the caller doesn't know how to check
+	 * these types anyway.
+	 */
+	for (type = _implicit_report_types; type->data_fn; type++)
+		*report_types &= ~type->id;
+}
+
+static int _help_requested(struct dm_report *rh)
+{
+	struct field_properties *fp;
+
+	dm_list_iterate_items(fp, &rh->field_props) {
+		if (fp->implicit &&
+		    (!strcmp(_implicit_report_fields[fp->field_num].id, SPECIAL_FIELD_HELP_ID) ||
+		     !strcmp(_implicit_report_fields[fp->field_num].id, SPECIAL_FIELD_HELP_ALT_ID)))
+			return 1;
+	}
+
+	return 0;
+}
+
+static int _canonicalize_field_ids(struct dm_report *rh)
+{
+	size_t registered_field_count = 0, i;
+	char canonical_field[DM_REPORT_FIELD_TYPE_ID_LEN];
+	char *canonical_field_dup;
+	int differs;
+
+	while (*rh->fields[registered_field_count].id)
+		registered_field_count++;
+
+	if (!(rh->canonical_field_ids = dm_pool_alloc(rh->mem, registered_field_count * sizeof(const char *)))) {
+		log_error("_canonicalize_field_ids: dm_pool_alloc failed");
+		return 0;
+	}
+
+	for (i = 0; i < registered_field_count; i++) {
+		if (!_get_canonical_field_name(rh->fields[i].id, strlen(rh->fields[i].id),
+					       canonical_field, sizeof(canonical_field), &differs))
+			return_0;
+
+		if (differs) {
+			if (!(canonical_field_dup = dm_pool_strdup(rh->mem, canonical_field))) {
+				log_error("_canonicalize_field_dup: dm_pool_alloc failed.");
+				return 0;
+			}
+			rh->canonical_field_ids[i] = canonical_field_dup;
+		} else
+			rh->canonical_field_ids[i] = rh->fields[i].id;
+	}
+
+	return 1;
+}
+
+struct dm_report *dm_report_init(uint32_t *report_types,
+				 const struct dm_report_object_type *types,
+				 const struct dm_report_field_type *fields,
+				 const char *output_fields,
+				 const char *output_separator,
+				 uint32_t output_flags,
+				 const char *sort_keys,
+				 void *private_data)
+{
+	struct dm_report *rh;
+	const struct dm_report_object_type *type;
+
+	if (_contains_reserved_report_type(types))
+		return_NULL;
+
+	if (!(rh = dm_zalloc(sizeof(*rh)))) {
+		log_error("dm_report_init: dm_malloc failed");
+		return NULL;
+	}
+
+	/*
+	 * rh->report_types is updated in _parse_fields() and _parse_keys()
+	 * to contain all types corresponding to the fields specified by
+	 * fields or keys.
+	 */
+	if (report_types)
+		rh->report_types = *report_types;
+
+	rh->separator = output_separator;
+	rh->fields = fields;
+	rh->types = types;
+	rh->private = private_data;
+
+	rh->flags |= output_flags & DM_REPORT_OUTPUT_MASK;
+
+	/* With columns_as_rows we must buffer and not align. */
+	if (output_flags & DM_REPORT_OUTPUT_COLUMNS_AS_ROWS) {
+		if (!(output_flags & DM_REPORT_OUTPUT_BUFFERED))
+			rh->flags |= DM_REPORT_OUTPUT_BUFFERED;
+		if (output_flags & DM_REPORT_OUTPUT_ALIGNED)
+			rh->flags &= ~DM_REPORT_OUTPUT_ALIGNED;
+	}
+
+	if (output_flags & DM_REPORT_OUTPUT_BUFFERED)
+		rh->flags |= RH_SORT_REQUIRED;
+
+	rh->flags |= RH_FIELD_CALC_NEEDED;
+
+	dm_list_init(&rh->field_props);
+	dm_list_init(&rh->rows);
+
+	if ((type = _find_type(rh, rh->report_types)) && type->prefix)
+		rh->field_prefix = type->prefix;
+	else
+		rh->field_prefix = "";
+
+	if (!(rh->mem = dm_pool_create("report", 10 * 1024))) {
+		log_error("dm_report_init: allocation of memory pool failed");
+		dm_free(rh);
+		return NULL;
+	}
+
+	if (!_canonicalize_field_ids(rh)) {
+		dm_report_free(rh);
+		return NULL;
+	}
+
+	/*
+	 * To keep the code needed to add the "all" field to a minimum, we parse
+	 * the field lists twice.  The first time we only update the report type.
+	 * FIXME Use one pass instead and expand the "all" field afterwards.
+	 */
+	if (!_parse_fields(rh, output_fields, 1) ||
+	    !_parse_keys(rh, sort_keys, 1)) {
+		dm_report_free(rh);
+		return NULL;
+	}
+
+	/* Generate list of fields for output based on format string & flags */
+	if (!_parse_fields(rh, output_fields, 0) ||
+	    !_parse_keys(rh, sort_keys, 0)) {
+		dm_report_free(rh);
+		return NULL;
+	}
+
+	/*
+	 * Return updated types value for further compatility check by caller.
+	 */
+	_dm_report_init_update_types(rh, report_types);
+
+	if (_help_requested(rh)) {
+		_display_fields(rh, 1, 0);
+		log_warn(" ");
+		rh->flags |= RH_ALREADY_REPORTED;
+	}
+
+	return rh;
+}
+
+void dm_report_free(struct dm_report *rh)
+{
+	if (rh->selection)
+		dm_pool_destroy(rh->selection->mem);
+	if (rh->value_cache)
+		dm_hash_destroy(rh->value_cache);
+	dm_pool_destroy(rh->mem);
+	dm_free(rh);
+}
+
+static char *_toupperstr(char *str)
+{
+	char *u = str;
+
+	do
+		*u = toupper(*u);
+	while (*u++);
+
+	return str;
+}
+
+int dm_report_set_output_field_name_prefix(struct dm_report *rh, const char *output_field_name_prefix)
+{
+	char *prefix;
+
+	if (!(prefix = dm_pool_strdup(rh->mem, output_field_name_prefix))) {
+		log_error("dm_report_set_output_field_name_prefix: dm_pool_strdup failed");
+		return 0;
+	}
+
+	rh->output_field_name_prefix = _toupperstr(prefix);
+	
+	return 1;
+}
+
+/*
+ * Create a row of data for an object
+ */
+static void *_report_get_field_data(struct dm_report *rh,
+				    struct field_properties *fp, void *object)
+{
+	const struct dm_report_field_type *fields = fp->implicit ? _implicit_report_fields
+								 : rh->fields;
+
+	char *ret = fp->type->data_fn(object);
+
+	if (!ret)
+		return NULL;
+
+	return (void *)(ret + fields[fp->field_num].offset);
+}
+
+static void *_report_get_implicit_field_data(struct dm_report *rh __attribute__((unused)),
+					     struct field_properties *fp, struct row *row)
+{
+	if (!strcmp(_implicit_report_fields[fp->field_num].id, SPECIAL_FIELD_SELECTED_ID))
+		return row;
+
+	return NULL;
+}
+
+static int _dbl_equal(double d1, double d2)
+{
+	return fabs(d1 - d2) < DBL_EPSILON;
+}
+
+static int _dbl_greater(double d1, double d2)
+{
+	return (d1 > d2) && !_dbl_equal(d1, d2);
+}
+
+static int _dbl_less(double d1, double d2)
+{
+	return (d1 < d2) && !_dbl_equal(d1, d2);
+}
+
+static int _dbl_greater_or_equal(double d1, double d2)
+{
+	return _dbl_greater(d1, d2) || _dbl_equal(d1, d2);
+}
+
+static int _dbl_less_or_equal(double d1, double d2)
+{
+	return _dbl_less(d1, d2) || _dbl_equal(d1, d2);
+}
+
+#define _uint64 *(const uint64_t *)
+#define _uint64arr(var,index) ((const uint64_t *)(var))[(index)]
+#define _str (const char *)
+#define _dbl *(const double *)
+#define _dblarr(var,index) ((const double *)(var))[(index)]
+
+static int _do_check_value_is_strictly_reserved(unsigned type, const void *res_val, int res_range,
+						const void *val, struct field_selection *fs)
+{
+	int sel_range = fs ? fs->value->next != NULL : 0;
+
+	switch (type & DM_REPORT_FIELD_TYPE_MASK) {
+		case DM_REPORT_FIELD_TYPE_NUMBER:
+			if (res_range && sel_range) {
+				/* both reserved value and selection value are ranges */
+				if (((_uint64 val >= _uint64arr(res_val,0)) && (_uint64 val <= _uint64arr(res_val,1))) ||
+				    (fs && ((fs->value->v.i == _uint64arr(res_val,0)) && (fs->value->next->v.i == _uint64arr(res_val,1)))))
+					return 1;
+			} else if (res_range) {
+				/* only reserved value is a range */
+				if (((_uint64 val >= _uint64arr(res_val,0)) && (_uint64 val <= _uint64arr(res_val,1))) ||
+				    (fs && ((fs->value->v.i >= _uint64arr(res_val,0)) && (fs->value->v.i <= _uint64arr(res_val,1)))))
+					return 1;
+			} else if (sel_range) {
+				/* only selection value is a range */
+				if (((_uint64 val >= _uint64 res_val) && (_uint64 val <= _uint64 res_val)) ||
+				    (fs && ((fs->value->v.i >= _uint64 res_val) && (fs->value->next->v.i <= _uint64 res_val))))
+					return 1;
+			} else {
+				/* neither selection value nor reserved value is a range */
+				if ((_uint64 val == _uint64 res_val) ||
+				    (fs && (fs->value->v.i == _uint64 res_val)))
+					return 1;
+			}
+			break;
+
+		case DM_REPORT_FIELD_TYPE_STRING:
+			/* there are no ranges for string type yet */
+			if ((!strcmp(_str val, _str res_val)) ||
+			    (fs && (!strcmp(fs->value->v.s, _str res_val))))
+				return 1;
+			break;
+
+		case DM_REPORT_FIELD_TYPE_SIZE:
+			if (res_range && sel_range) {
+				/* both reserved value and selection value are ranges */
+				if ((_dbl_greater_or_equal(_dbl val, _dblarr(res_val,0)) && _dbl_less_or_equal(_dbl val, _dblarr(res_val,1))) ||
+				    (fs && (_dbl_equal(fs->value->v.d, _dblarr(res_val,0)) && (_dbl_equal(fs->value->next->v.d, _dblarr(res_val,1))))))
+					return 1;
+			} else if (res_range) {
+				/* only reserved value is a range */
+				if ((_dbl_greater_or_equal(_dbl val, _dblarr(res_val,0)) && _dbl_less_or_equal(_dbl val, _dblarr(res_val,1))) ||
+				    (fs && (_dbl_greater_or_equal(fs->value->v.d, _dblarr(res_val,0)) && _dbl_less_or_equal(fs->value->v.d, _dblarr(res_val,1)))))
+					return 1;
+			} else if (sel_range) {
+				/* only selection value is a range */
+				if ((_dbl_greater_or_equal(_dbl val, _dbl res_val) && (_dbl_less_or_equal(_dbl val, _dbl res_val))) ||
+				    (fs && (_dbl_greater_or_equal(fs->value->v.d, _dbl res_val) && _dbl_less_or_equal(fs->value->next->v.d, _dbl res_val))))
+					return 1;
+			} else {
+				/* neither selection value nor reserved value is a range */
+				if ((_dbl_equal(_dbl val, _dbl res_val)) ||
+				    (fs && (_dbl_equal(fs->value->v.d, _dbl res_val))))
+					return 1;
+			}
+			break;
+
+		case DM_REPORT_FIELD_TYPE_STRING_LIST:
+			/* FIXME Add comparison for string list */
+			break;
+		case DM_REPORT_FIELD_TYPE_TIME:
+			/* FIXME Add comparison for time */
+			break;
+	}
+
+	return 0;
+}
+
+/*
+ * Used to check whether a value of certain type used in selection is reserved.
+ */
+static int _check_value_is_strictly_reserved(struct dm_report *rh, uint32_t field_num, unsigned type,
+					     const void *val, struct field_selection *fs)
+{
+	const struct dm_report_reserved_value *iter = rh->reserved_values;
+	const struct dm_report_field_reserved_value *frv;
+	int res_range;
+
+	if (!iter)
+		return 0;
+
+	while (iter->value) {
+		/* Only check strict reserved values, not the weaker form ("named" reserved value). */
+		if (!(iter->type & DM_REPORT_FIELD_RESERVED_VALUE_NAMED)) {
+			res_range = iter->type & DM_REPORT_FIELD_RESERVED_VALUE_RANGE;
+			if ((iter->type & DM_REPORT_FIELD_TYPE_MASK) == DM_REPORT_FIELD_TYPE_NONE) {
+				frv = (const struct dm_report_field_reserved_value *) iter->value;
+				if (frv->field_num == field_num && _do_check_value_is_strictly_reserved(type, frv->value, res_range, val, fs))
+					return 1;
+			} else if (iter->type & type && _do_check_value_is_strictly_reserved(type, iter->value, res_range, val, fs))
+				return 1;
+		}
+		iter++;
+	}
+
+	return 0;
+}
+
+static int _cmp_field_int(struct dm_report *rh, uint32_t field_num, const char *field_id,
+			  uint64_t val, struct field_selection *fs)
+{
+	int range = fs->value->next != NULL;
+	const uint64_t sel1 = fs->value->v.i;
+	const uint64_t sel2 = range ? fs->value->next->v.i : 0;
+
+	switch(fs->flags & FLD_CMP_MASK) {
+		case FLD_CMP_EQUAL:
+			return range ? ((val >= sel1) && (val <= sel2)) : val == sel1;
+
+		case FLD_CMP_NOT|FLD_CMP_EQUAL:
+			return range ? !((val >= sel1) && (val <= sel2)) : val != sel1;
+
+		case FLD_CMP_NUMBER|FLD_CMP_GT:
+			if (_check_value_is_strictly_reserved(rh, field_num, DM_REPORT_FIELD_TYPE_NUMBER, &val, fs))
+				return 0;
+			return range ? val > sel2 : val > sel1;
+
+		case FLD_CMP_NUMBER|FLD_CMP_GT|FLD_CMP_EQUAL:
+			if (_check_value_is_strictly_reserved(rh, field_num, DM_REPORT_FIELD_TYPE_NUMBER, &val, fs))
+				return 0;
+			return val >= sel1;
+
+		case FLD_CMP_NUMBER|FLD_CMP_LT:
+			if (_check_value_is_strictly_reserved(rh, field_num, DM_REPORT_FIELD_TYPE_NUMBER, &val, fs))
+				return 0;
+			return val < sel1;
+
+		case FLD_CMP_NUMBER|FLD_CMP_LT|FLD_CMP_EQUAL:
+			if (_check_value_is_strictly_reserved(rh, field_num, DM_REPORT_FIELD_TYPE_NUMBER, &val, fs))
+				return 0;
+			return range ? val <= sel2 : val <= sel1;
+
+		default:
+			log_error(INTERNAL_ERROR "_cmp_field_int: unsupported number "
+				  "comparison type for field %s", field_id);
+	}
+
+	return 0;
+}
+
+static int _cmp_field_double(struct dm_report *rh, uint32_t field_num, const char *field_id,
+			     double val, struct field_selection *fs)
+{
+	int range = fs->value->next != NULL;
+	double sel1 = fs->value->v.d;
+	double sel2 = range ? fs->value->next->v.d : 0;
+
+	switch(fs->flags & FLD_CMP_MASK) {
+		case FLD_CMP_EQUAL:
+			return range ? (_dbl_greater_or_equal(val, sel1) && _dbl_less_or_equal(val, sel2))
+				     : _dbl_equal(val, sel1);
+
+		case FLD_CMP_NOT|FLD_CMP_EQUAL:
+			return range ? !(_dbl_greater_or_equal(val, sel1) && _dbl_less_or_equal(val, sel2))
+				     : !_dbl_equal(val, sel1);
+
+		case FLD_CMP_NUMBER|FLD_CMP_GT:
+			if (_check_value_is_strictly_reserved(rh, field_num, DM_REPORT_FIELD_TYPE_SIZE, &val, fs))
+				return 0;
+			return range ? _dbl_greater(val, sel2)
+				     : _dbl_greater(val, sel1);
+
+		case FLD_CMP_NUMBER|FLD_CMP_GT|FLD_CMP_EQUAL:
+			if (_check_value_is_strictly_reserved(rh, field_num, DM_REPORT_FIELD_TYPE_SIZE, &val, fs))
+				return 0;
+			return _dbl_greater_or_equal(val, sel1);
+
+		case FLD_CMP_NUMBER|FLD_CMP_LT:
+			if (_check_value_is_strictly_reserved(rh, field_num, DM_REPORT_FIELD_TYPE_SIZE, &val, fs))
+				return 0;
+			return _dbl_less(val, sel1);
+
+		case FLD_CMP_NUMBER|FLD_CMP_LT|FLD_CMP_EQUAL:
+			if (_check_value_is_strictly_reserved(rh, field_num, DM_REPORT_FIELD_TYPE_SIZE, &val, fs))
+				return 0;
+			return range ? _dbl_less_or_equal(val, sel2) : _dbl_less_or_equal(val, sel1); 
+
+		default:
+			log_error(INTERNAL_ERROR "_cmp_field_double: unsupported number "
+				  "comparison type for selection field %s", field_id);
+	}
+
+	return 0;
+}
+
+static int _cmp_field_string(struct dm_report *rh __attribute__((unused)),
+			     uint32_t field_num, const char *field_id,
+			     const char *val, struct field_selection *fs)
+{
+	const char *sel = fs->value->v.s;
+
+	switch (fs->flags & FLD_CMP_MASK) {
+		case FLD_CMP_EQUAL:
+			return !strcmp(val, sel);
+		case FLD_CMP_NOT|FLD_CMP_EQUAL:
+			return strcmp(val, sel);
+		default:
+			log_error(INTERNAL_ERROR "_cmp_field_string: unsupported string "
+				  "comparison type for selection field %s", field_id);
+	}
+
+	return 0;
+}
+
+static int _cmp_field_time(struct dm_report *rh,
+			   uint32_t field_num, const char *field_id,
+			   time_t val, struct field_selection *fs)
+{
+	int range = fs->value->next != NULL;
+	time_t sel1 = fs->value->v.t;
+	time_t sel2 = range ? fs->value->next->v.t : 0;
+
+	switch(fs->flags & FLD_CMP_MASK) {
+		case FLD_CMP_EQUAL:
+			return range ? ((val >= sel1) && (val <= sel2)) : val == sel1;
+		case FLD_CMP_NOT|FLD_CMP_EQUAL:
+			return range ? ((val >= sel1) && (val <= sel2)) : val != sel1;
+		case FLD_CMP_TIME|FLD_CMP_GT:
+			if (_check_value_is_strictly_reserved(rh, field_num, DM_REPORT_FIELD_TYPE_TIME, &val, fs))
+				return 0;
+			return range ? val > sel2 : val > sel1;
+		case FLD_CMP_TIME|FLD_CMP_GT|FLD_CMP_EQUAL:
+			if (_check_value_is_strictly_reserved(rh, field_num, DM_REPORT_FIELD_TYPE_TIME, &val, fs))
+				return 0;
+			return val >= sel1;
+		case FLD_CMP_TIME|FLD_CMP_LT:
+			if (_check_value_is_strictly_reserved(rh, field_num, DM_REPORT_FIELD_TYPE_TIME, &val, fs))
+				return 0;
+			return val < sel1;
+		case FLD_CMP_TIME|FLD_CMP_LT|FLD_CMP_EQUAL:
+			if (_check_value_is_strictly_reserved(rh, field_num, DM_REPORT_FIELD_TYPE_TIME, &val, fs))
+				return 0;
+			return range ? val <= sel2 : val <= sel1;
+		default:
+			log_error(INTERNAL_ERROR "_cmp_field_time: unsupported time "
+				  "comparison type for field %s", field_id);
+	}
+
+	return 0;
+}
+
+/* Matches if all items from selection string list match list value strictly 1:1. */
+static int _cmp_field_string_list_strict_all(const struct str_list_sort_value *val,
+					     const struct selection_str_list *sel)
+{
+	unsigned int sel_list_size = dm_list_size(&sel->str_list.list);
+	struct dm_str_list *sel_item;
+	unsigned int i = 1;
+
+	if (!val->items[0].len) {
+		if (sel_list_size == 1) {
+			/* match blank string list with selection defined as blank string only */
+			sel_item = dm_list_item(dm_list_first(&sel->str_list.list), struct dm_str_list);
+			return !strcmp(sel_item->str, "");
+		}
+		return 0;
+	}
+
+	/* if item count differs, it's clear the lists do not match */
+	if (val->items[0].len != sel_list_size)
+		return 0;
+
+	/* both lists are sorted so they either match 1:1 or not */
+	dm_list_iterate_items(sel_item, &sel->str_list.list) {
+		if ((strlen(sel_item->str) != val->items[i].len) ||
+		    strncmp(sel_item->str, val->value + val->items[i].pos, val->items[i].len))
+			return 0;
+		i++;
+	}
+
+	return 1;
+}
+
+/* Matches if all items from selection string list match a subset of list value. */
+static int _cmp_field_string_list_subset_all(const struct str_list_sort_value *val,
+					     const struct selection_str_list *sel)
+{
+	unsigned int sel_list_size = dm_list_size(&sel->str_list.list);
+	struct dm_str_list *sel_item;
+	unsigned int i, last_found = 1;
+	int r = 0;
+
+	if (!val->items[0].len) {
+		if (sel_list_size == 1) {
+			/* match blank string list with selection defined as blank string only */
+			sel_item = dm_list_item(dm_list_first(&sel->str_list.list), struct dm_str_list);
+			return !strcmp(sel_item->str, "");
+		}
+		return 0;
+	}
+
+	/* check selection is a subset of the value */
+	dm_list_iterate_items(sel_item, &sel->str_list.list) {
+		r = 0;
+		for (i = last_found; i <= val->items[0].len; i++) {
+			if ((strlen(sel_item->str) == val->items[i].len) &&
+			    !strncmp(sel_item->str, val->value + val->items[i].pos, val->items[i].len)) {
+				last_found = i;
+				r = 1;
+			}
+		}
+		if (!r)
+			break;
+	}
+
+	return r;
+}
+
+/* Matches if any item from selection string list matches list value. */
+static int _cmp_field_string_list_any(const struct str_list_sort_value *val,
+				      const struct selection_str_list *sel)
+{
+	struct dm_str_list *sel_item;
+	unsigned int i;
+
+	/* match blank string list with selection that contains blank string */
+	if (!val->items[0].len) {
+		dm_list_iterate_items(sel_item, &sel->str_list.list) {
+			if (!strcmp(sel_item->str, ""))
+				return 1;
+		}
+		return 0;
+	}
+
+	dm_list_iterate_items(sel_item, &sel->str_list.list) {
+		/*
+		 * TODO: Optimize this so we don't need to compare the whole lists' content.
+		 *       Make use of the fact that the lists are sorted!
+		 */
+		for (i = 1; i <= val->items[0].len; i++) {
+			if ((strlen(sel_item->str) == val->items[i].len) &&
+			    !strncmp(sel_item->str, val->value + val->items[i].pos, val->items[i].len))
+				return 1;
+		}
+	}
+
+	return 0;
+}
+
+static int _cmp_field_string_list(struct dm_report *rh __attribute__((unused)),
+				  uint32_t field_num, const char *field_id,
+				  const struct str_list_sort_value *val,
+				  struct field_selection *fs)
+{
+	const struct selection_str_list *sel = fs->value->v.l;
+	int subset, r;
+
+	switch (sel->type & SEL_LIST_MASK) {
+		case SEL_LIST_LS:
+			subset = 0;
+			break;
+		case SEL_LIST_SUBSET_LS:
+			subset = 1;
+			break;
+		default:
+			log_error(INTERNAL_ERROR "_cmp_field_string_list: unknown list type");
+			return 0;
+	}
+
+	switch (sel->type & SEL_MASK) {
+		case SEL_AND:
+			r = subset ? _cmp_field_string_list_subset_all(val, sel)
+				   : _cmp_field_string_list_strict_all(val, sel);
+			break;
+		case SEL_OR:
+			r = _cmp_field_string_list_any(val, sel);
+			break;
+		default:
+			log_error(INTERNAL_ERROR "_cmp_field_string_list: unsupported string "
+				  "list type found, expecting either AND or OR list for "
+				  "selection field %s", field_id);
+			return 0;
+	}
+
+	return fs->flags & FLD_CMP_NOT ? !r : r;
+}
+
+static int _cmp_field_regex(const char *s, struct field_selection *fs)
+{
+	int match = dm_regex_match(fs->value->v.r, s) >= 0;
+	return fs->flags & FLD_CMP_NOT ? !match : match;
+}
+
+static int _compare_selection_field(struct dm_report *rh,
+				    struct dm_report_field *f,
+				    struct field_selection *fs)
+{
+	const struct dm_report_field_type *fields = f->props->implicit ? _implicit_report_fields
+								       : rh->fields;
+	const char *field_id = fields[f->props->field_num].id;
+	int r = 0;
+
+	if (!f->sort_value) {
+		log_error("_compare_selection_field: field without value :%d",
+			  f->props->field_num);
+		return 0;
+	}
+
+	if (fs->flags & FLD_CMP_REGEX)
+		r = _cmp_field_regex((const char *) f->sort_value, fs);
+	else {
+		switch(f->props->flags & DM_REPORT_FIELD_TYPE_MASK) {
+			case DM_REPORT_FIELD_TYPE_PERCENT:
+				/*
+				 * Check against real percent values only.
+				 * That means DM_PERCENT_0 <= percent <= DM_PERCENT_100.
+				 */
+				if (*(const uint64_t *) f->sort_value > DM_PERCENT_100)
+					return 0;
+				/* fall through */
+			case DM_REPORT_FIELD_TYPE_NUMBER:
+				r = _cmp_field_int(rh, f->props->field_num, field_id, *(const uint64_t *) f->sort_value, fs);
+				break;
+			case DM_REPORT_FIELD_TYPE_SIZE:
+				r = _cmp_field_double(rh, f->props->field_num, field_id, *(const double *) f->sort_value, fs);
+				break;
+			case DM_REPORT_FIELD_TYPE_STRING:
+				r = _cmp_field_string(rh, f->props->field_num, field_id, (const char *) f->sort_value, fs);
+				break;
+			case DM_REPORT_FIELD_TYPE_STRING_LIST:
+				r = _cmp_field_string_list(rh, f->props->field_num, field_id, (const struct str_list_sort_value *) f->sort_value, fs);
+				break;
+			case DM_REPORT_FIELD_TYPE_TIME:
+				r = _cmp_field_time(rh, f->props->field_num, field_id, *(const time_t *) f->sort_value, fs);
+				break;
+			default:
+				log_error(INTERNAL_ERROR "_compare_selection_field: unknown field type for field %s", field_id);
+		}
+	}
+
+	return r;
+}
+
+static int _check_selection(struct dm_report *rh, struct selection_node *sn,
+			    struct dm_list *fields)
+{
+	int r;
+	struct selection_node *iter_n;
+	struct dm_report_field *f;
+
+	switch (sn->type & SEL_MASK) {
+		case SEL_ITEM:
+			r = 1;
+			dm_list_iterate_items(f, fields) {
+				if (sn->selection.item->fp != f->props)
+					continue;
+				if (!_compare_selection_field(rh, f, sn->selection.item))
+					r = 0;
+			}
+			break;
+		case SEL_OR:
+			r = 0;
+			dm_list_iterate_items(iter_n, &sn->selection.set)
+				if ((r |= _check_selection(rh, iter_n, fields)))
+					break;
+			break;
+		case SEL_AND:
+			r = 1;
+			dm_list_iterate_items(iter_n, &sn->selection.set)
+				if (!(r &= _check_selection(rh, iter_n, fields)))
+					break;
+			break;
+		default:
+			log_error("Unsupported selection type");
+			return 0;
+	}
+
+	return (sn->type & SEL_MODIFIER_NOT) ? !r : r;
+}
+
+static int _check_report_selection(struct dm_report *rh, struct dm_list *fields)
+{
+	if (!rh->selection || !rh->selection->selection_root)
+		return 1;
+
+	return _check_selection(rh, rh->selection->selection_root, fields);
+}
+
+static int _do_report_object(struct dm_report *rh, void *object, int do_output, int *selected)
+{
+	const struct dm_report_field_type *fields;
+	struct field_properties *fp;
+	struct row *row = NULL;
+	struct dm_report_field *field;
+	void *data = NULL;
+	int r = 0;
+
+	if (!rh) {
+		log_error(INTERNAL_ERROR "_do_report_object: dm_report handler is NULL.");
+		return 0;
+	}
+
+	if (!do_output && !selected) {
+		log_error(INTERNAL_ERROR "_do_report_object: output not requested and "
+					 "selected output variable is NULL too.");
+		return 0;
+	}
+
+	if (rh->flags & RH_ALREADY_REPORTED)
+		return 1;
+
+	if (!(row = dm_pool_zalloc(rh->mem, sizeof(*row)))) {
+		log_error("_do_report_object: struct row allocation failed");
+		return 0;
+	}
+
+	if (!rh->first_row)
+		rh->first_row = row;
+
+	row->rh = rh;
+
+	if ((rh->flags & RH_SORT_REQUIRED) &&
+	    !(row->sort_fields =
+		dm_pool_zalloc(rh->mem, sizeof(struct dm_report_field *) *
+			       rh->keys_count))) {
+		log_error("_do_report_object: "
+			  "row sort value structure allocation failed");
+		goto out;
+	}
+
+	dm_list_init(&row->fields);
+	row->selected = 1;
+
+	/* For each field to be displayed, call its report_fn */
+	dm_list_iterate_items(fp, &rh->field_props) {
+		if (!(field = dm_pool_zalloc(rh->mem, sizeof(*field)))) {
+			log_error("_do_report_object: "
+				  "struct dm_report_field allocation failed");
+			goto out;
+		}
+
+		if (fp->implicit) {
+			fields = _implicit_report_fields;
+			if (!strcmp(fields[fp->field_num].id, SPECIAL_FIELD_SELECTED_ID))
+				row->field_sel_status = field;
+		} else
+			fields = rh->fields;
+
+		field->props = fp;
+
+		data = fp->implicit ? _report_get_implicit_field_data(rh, fp, row)
+				    : _report_get_field_data(rh, fp, object);
+		if (!data) {
+			log_error("_do_report_object: "
+				  "no data assigned to field %s",
+				  fields[fp->field_num].id);
+			goto out;
+		}
+
+		if (!fields[fp->field_num].report_fn(rh, rh->mem,
+							 field, data,
+							 rh->private)) {
+			log_error("_do_report_object: "
+				  "report function failed for field %s",
+				  fields[fp->field_num].id);
+			goto out;
+		}
+
+		dm_list_add(&row->fields, &field->list);
+	}
+
+	r = 1;
+
+	if (!_check_report_selection(rh, &row->fields)) {
+		row->selected = 0;
+
+		/*
+		 * If the row is not selected, we still keep it for output if either:
+		 *   - we're displaying special "selected" field in the row,
+		 *   - or the report is supposed to be on output multiple times
+		 *     where each output can have a new selection defined.
+		 */
+		if (!row->field_sel_status && !(rh->flags & DM_REPORT_OUTPUT_MULTIPLE_TIMES))
+			goto out;
+
+		if (row->field_sel_status) {
+			/*
+			 * If field with id "selected" is reported,
+			 * report the row although it does not pass
+			 * the selection criteria.
+			 * The "selected" field reports the result
+			 * of the selection.
+			 */
+			_implicit_report_fields[row->field_sel_status->props->field_num].report_fn(rh,
+							rh->mem, row->field_sel_status, row, rh->private);
+			/*
+			 * If the "selected" field is not displayed, e.g.
+			 * because it is part of the sort field list,
+			 * skip the display of the row as usual unless
+			 * we plan to do the output multiple times.
+			 */
+			if ((row->field_sel_status->props->flags & FLD_HIDDEN) &&
+			    !(rh->flags & DM_REPORT_OUTPUT_MULTIPLE_TIMES))
+				goto out;
+		}
+	}
+
+	if (!do_output)
+		goto out;
+
+	dm_list_add(&rh->rows, &row->list);
+
+	if (!(rh->flags & DM_REPORT_OUTPUT_BUFFERED))
+		return dm_report_output(rh);
+out:
+	if (selected)
+		*selected = row->selected;
+	if (!do_output || !r)
+		dm_pool_free(rh->mem, row);
+	return r;
+}
+
+static int _do_report_compact_fields(struct dm_report *rh, int global)
+{
+	struct dm_report_field *field;
+	struct field_properties *fp;
+	struct row *row;
+
+	if (!rh) {
+		log_error("dm_report_enable_compact_output: dm report handler is NULL.");
+		return 0;
+	}
+
+	if (!(rh->flags & DM_REPORT_OUTPUT_BUFFERED) ||
+	      dm_list_empty(&rh->rows))
+		return 1;
+
+	/*
+	 * At first, mark all fields with FLD_HIDDEN flag.
+	 * Also, mark field with FLD_COMPACTED flag, but only
+	 * the ones that didn't have FLD_HIDDEN set before.
+	 * This prevents losing the original FLD_HIDDEN flag
+	 * in next step...
+	 */
+	dm_list_iterate_items(fp, &rh->field_props) {
+		if (fp->flags & FLD_HIDDEN)
+			continue;
+		if (global || (fp->flags & FLD_COMPACT_ONE))
+			fp->flags |= (FLD_COMPACTED | FLD_HIDDEN);
+	}
+
+	/*
+	 * ...check each field in a row and if its report value
+	 * is not empty, drop the FLD_COMPACTED and FLD_HIDDEN
+	 * flag if FLD_COMPACTED flag is set. It's important
+	 * to keep FLD_HIDDEN flag for the fields that were
+	 * already marked with FLD_HIDDEN before - these don't
+	 * have FLD_COMPACTED set - check this condition!
+	 */
+	dm_list_iterate_items(row, &rh->rows) {
+		dm_list_iterate_items(field, &row->fields) {
+			if ((field->report_string && *field->report_string) &&
+			     field->props->flags & FLD_COMPACTED)
+					field->props->flags &= ~(FLD_COMPACTED | FLD_HIDDEN);
+			}
+	}
+
+	/*
+	 * The fields left with FLD_COMPACTED and FLD_HIDDEN flag are
+	 * the ones which have blank value in all rows. The FLD_HIDDEN
+	 * will cause such field to not be reported on output at all.
+	 */
+
+	return 1;
+}
+
+int dm_report_compact_fields(struct dm_report *rh)
+{
+	return _do_report_compact_fields(rh, 1);
+}
+
+static int _field_to_compact_match(struct dm_report *rh, const char *field, size_t flen)
+{
+	struct field_properties *fp;
+	uint32_t f;
+	int implicit;
+
+	if ((_get_field(rh, field, flen, &f, &implicit))) {
+		dm_list_iterate_items(fp, &rh->field_props) {
+			if ((fp->implicit == implicit) && (fp->field_num == f)) {
+				fp->flags |= FLD_COMPACT_ONE;
+				break;
+			}
+		}
+		return 1;
+	}
+
+	return 0;
+}
+
+static int _parse_fields_to_compact(struct dm_report *rh, const char *fields)
+{
+	const char *ws;		  /* Word start */
+	const char *we = fields;  /* Word end */
+
+	if (!fields)
+		return 1;
+
+	while (*we) {
+		while (*we && *we == ',')
+			we++;
+		ws = we;
+		while (*we && *we != ',')
+			we++;
+		if (!_field_to_compact_match(rh, ws, (size_t) (we - ws))) {
+			log_error("dm_report: Unrecognized field: %.*s", (int) (we - ws), ws);
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+int dm_report_compact_given_fields(struct dm_report *rh, const char *fields)
+{
+	if (!_parse_fields_to_compact(rh, fields))
+		return_0;
+
+	return _do_report_compact_fields(rh, 0);
+}
+
+int dm_report_object(struct dm_report *rh, void *object)
+{
+	return _do_report_object(rh, object, 1, NULL);
+}
+
+int dm_report_object_is_selected(struct dm_report *rh, void *object, int do_output, int *selected)
+{
+	return _do_report_object(rh, object, do_output, selected);
+}
+
+/*
+ * Selection parsing
+ */
+
+/*
+ * Other tokens (FIELD, VALUE, STRING, NUMBER, REGEX)
+ *     FIELD := <strings of alphabet, number and '_'>
+ *     VALUE := NUMBER | STRING
+ *     REGEX := <strings quoted by '"', '\'', '(', '{', '[' or unquoted>
+ *     NUMBER := <strings of [0-9]> (because sort_value is unsigned)
+ *     STRING := <strings quoted by '"', '\'' or unquoted>
+ */
+
+static const char * _skip_space(const char *s)
+{
+	while (*s && isspace(*s))
+		s++;
+	return s;
+}
+
+static int _tok_op(struct op_def *t, const char *s, const char **end,
+		   uint32_t expect)
+{
+	size_t len;
+
+	s = _skip_space(s);
+
+	for (; t->string; t++) {
+		if (expect && !(t->flags & expect))
+			continue;
+
+		len = strlen(t->string);
+		if (!strncmp(s, t->string, len)) {
+			if (end)
+				*end = s + len;
+			return t->flags;
+		}
+	}
+
+	if (end)
+		*end = s;
+	return 0;
+}
+
+static int _tok_op_log(const char *s, const char **end, uint32_t expect)
+{
+	return _tok_op(_op_log, s, end, expect);
+}
+
+static int _tok_op_cmp(const char *s, const char **end)
+{
+	return _tok_op(_op_cmp, s, end, 0);
+}
+
+static char _get_and_skip_quote_char(char const **s)
+{
+	char c = 0;
+
+	if (**s == '"' || **s == '\'') {
+		c = **s;
+		(*s)++;
+	}
+
+	return c;
+}
+
+ /*
+  *
+  * Input:
+  *   s             - a pointer to the parsed string
+  * Output:
+  *   begin         - a pointer to the beginning of the token
+  *   end           - a pointer to the end of the token + 1
+  *                   or undefined if return value is NULL
+  *   return value  - a starting point of the next parsing or
+  *                   NULL if 's' doesn't match with token type
+  *                   (the parsing should be terminated)
+  */
+static const char *_tok_value_number(const char *s,
+				     const char **begin, const char **end)
+
+{
+	int is_float = 0;
+
+	*begin = s;
+	while ((!is_float && (*s == '.') && ++is_float) || isdigit(*s))
+		s++;
+	*end = s;
+
+	if (*begin == *end)
+		return NULL;
+
+	return s;
+}
+
+/*
+ * Input:
+ *   s               - a pointer to the parsed string
+ *   endchar         - terminating character
+ *   end_op_flags    - terminating operator flags (see _op_log)
+ *                     (if endchar is non-zero then endflags is ignored)
+ * Output:
+ *   begin           - a pointer to the beginning of the token
+ *   end             - a pointer to the end of the token + 1
+ *   end_op_flag_hit - the flag from endflags hit during parsing
+ *   return value    - a starting point of the next parsing
+ */
+static const char *_tok_value_string(const char *s,
+				     const char **begin, const char **end,
+				     const char endchar, uint32_t end_op_flags,
+				     uint32_t *end_op_flag_hit)
+{
+	uint32_t flag_hit = 0;
+
+	*begin = s;
+
+	/*
+	 * If endchar is defined, scan the string till
+	 * the endchar or the end of string is hit.
+	 * This is in case the string is quoted and we
+	 * know exact character that is the stopper.
+	 */
+	if (endchar) {
+		while (*s && *s != endchar)
+			s++;
+		if (*s != endchar) {
+			log_error("Missing end quote.");
+			return NULL;
+		}
+		*end = s;
+		s++;
+	} else {
+		/*
+		 * If endchar is not defined then endchar is/are the
+		 * operator/s as defined by 'endflags' arg or space char.
+		 * This is in case the string is not quoted and
+		 * we don't know which character is the exact stopper.
+		 */
+		while (*s) {
+			if ((flag_hit = _tok_op(_op_log, s, NULL, end_op_flags)) || *s == ' ')
+				break;
+			s++;
+		}
+		*end = s;
+		/*
+		 * If we hit one of the strings as defined by 'endflags'
+		 * and if 'endflag_hit' arg is provided, save the exact
+		 * string flag that was hit.
+		 */
+		if (end_op_flag_hit)
+			*end_op_flag_hit = flag_hit;
+	}
+
+	return s;
+}
+
+static const char *_reserved_name(struct dm_report *rh,
+				  const struct dm_report_reserved_value *reserved,
+				  const struct dm_report_field_reserved_value *frv,
+				  uint32_t field_num, const char *s, size_t len)
+{
+	dm_report_reserved_handler handler;
+	const char *canonical_name;
+	const char **name;
+	char *tmp_s;
+	char c;
+	int r;
+
+	name = reserved->names;
+	while (*name) {
+		if ((strlen(*name) == len) && !strncmp(*name, s, len))
+			return *name;
+		name++;
+	}
+
+	if (reserved->type & DM_REPORT_FIELD_RESERVED_VALUE_FUZZY_NAMES) {
+		handler = (dm_report_reserved_handler) (frv ? frv->value : reserved->value);
+		c = s[len];
+		tmp_s = (char *) s;
+		tmp_s[len] = '\0';
+		if ((r = handler(rh, rh->selection->mem, field_num,
+				 DM_REPORT_RESERVED_PARSE_FUZZY_NAME,
+				 tmp_s, (const void **) &canonical_name)) <= 0) {
+			if (r == -1)
+				log_error(INTERNAL_ERROR "%s reserved value handler for field %s has missing "
+					  "implementation of DM_REPORT_RESERVED_PARSE_FUZZY_NAME action",
+					  (reserved->type & DM_REPORT_FIELD_TYPE_MASK) ? "type-specific" : "field-specific",
+					   rh->fields[field_num].id);
+			else
+				log_error("Error occured while processing %s reserved value handler for field %s",
+					  (reserved->type & DM_REPORT_FIELD_TYPE_MASK) ? "type-specific" : "field-specific",
+					   rh->fields[field_num].id);
+		}
+		tmp_s[len] = c;
+		if (r && canonical_name)
+			return canonical_name;
+	}
+
+	return NULL;
+}
+
+/*
+ * Used to replace a string representation of the reserved value
+ * found in selection with the exact reserved value of certain type.
+ */
+static const char *_get_reserved(struct dm_report *rh, unsigned type,
+				 uint32_t field_num, int implicit,
+				 const char *s, const char **begin, const char **end,
+				 struct reserved_value_wrapper *rvw)
+{
+	const struct dm_report_reserved_value *iter = implicit ? NULL : rh->reserved_values;
+	const struct dm_report_field_reserved_value *frv;
+	const char *tmp_begin, *tmp_end, *tmp_s = s;
+	const char *name = NULL;
+	char c;
+
+	rvw->reserved = NULL;
+
+	if (!iter)
+		return s;
+
+	c = _get_and_skip_quote_char(&tmp_s);
+	if (!(tmp_s = _tok_value_string(tmp_s, &tmp_begin, &tmp_end, c, SEL_AND | SEL_OR | SEL_PRECEDENCE_PE, NULL)))
+		return s;
+
+	while (iter->value) {
+		if (!(iter->type & DM_REPORT_FIELD_TYPE_MASK)) {
+			/* DM_REPORT_FIELD_TYPE_NONE - per-field reserved value */
+			frv = (const struct dm_report_field_reserved_value *) iter->value;
+			if ((frv->field_num == field_num) && (name = _reserved_name(rh, iter, frv, field_num,
+										    tmp_begin, tmp_end - tmp_begin)))
+				break;
+		} else if (iter->type & type) {
+			/* DM_REPORT_FIELD_TYPE_* - per-type reserved value */
+			if ((name = _reserved_name(rh, iter, NULL, field_num,
+						   tmp_begin, tmp_end - tmp_begin)))
+				break;
+		}
+		iter++;
+	}
+
+	if (name) {
+		/* found! */
+		*begin = tmp_begin;
+		*end = tmp_end;
+		s = tmp_s;
+		rvw->reserved = iter;
+		rvw->matched_name = name;
+	}
+
+	return s;
+}
+
+float dm_percent_to_float(dm_percent_t percent)
+{
+	/* Add 0.f to prevent returning -0.00 */
+	return (float) percent / DM_PERCENT_1 + 0.f;
+}
+
+float dm_percent_to_round_float(dm_percent_t percent, unsigned digits)
+{
+	static const float power10[] = {
+		1.f, .1f, .01f, .001f, .0001f, .00001f, .000001f,
+		.0000001f, .00000001f, .000000001f,
+		.0000000001f
+	};
+	float r;
+	float f = dm_percent_to_float(percent);
+
+	if (digits >= DM_ARRAY_SIZE(power10))
+		digits = DM_ARRAY_SIZE(power10) - 1; /* no better precision */
+
+	r = DM_PERCENT_1 * power10[digits];
+
+	if ((percent < r) && (percent > DM_PERCENT_0))
+		f = power10[digits];
+	else if ((percent > (DM_PERCENT_100 - r)) && (percent < DM_PERCENT_100))
+		f = (float) (DM_PERCENT_100 - r) / DM_PERCENT_1;
+
+	return f;
+}
+
+dm_percent_t dm_make_percent(uint64_t numerator, uint64_t denominator)
+{
+	dm_percent_t percent;
+
+	if (!denominator)
+		return DM_PERCENT_100; /* FIXME? */
+	if (!numerator)
+		return DM_PERCENT_0;
+	if (numerator == denominator)
+		return DM_PERCENT_100;
+	switch (percent = DM_PERCENT_100 * ((double) numerator / (double) denominator)) {
+		case DM_PERCENT_100:
+			return DM_PERCENT_100 - 1;
+		case DM_PERCENT_0:
+			return DM_PERCENT_0 + 1;
+		default:
+			return percent;
+	}
+}
+
+int dm_report_value_cache_set(struct dm_report *rh, const char *name, const void *data)
+{
+	if (!rh->value_cache && (!(rh->value_cache = dm_hash_create(64)))) {
+		log_error("Failed to create cache for values used during reporting.");
+		return 0;
+	}
+
+	return dm_hash_insert(rh->value_cache, name, (void *) data);
+}
+
+const void *dm_report_value_cache_get(struct dm_report *rh, const char *name)
+{
+	return (rh->value_cache) ? dm_hash_lookup(rh->value_cache, name) : NULL;
+}
+
+/*
+ * Used to check whether the reserved_values definition passed to
+ * dm_report_init_with_selection contains only supported reserved value types.
+ */
+static int _check_reserved_values_supported(const struct dm_report_field_type fields[],
+					    const struct dm_report_reserved_value reserved_values[])
+{
+	const struct dm_report_reserved_value *iter;
+	const struct dm_report_field_reserved_value *field_res;
+	const struct dm_report_field_type *field;
+	static uint32_t supported_reserved_types = DM_REPORT_FIELD_TYPE_NUMBER |
+						   DM_REPORT_FIELD_TYPE_SIZE |
+						   DM_REPORT_FIELD_TYPE_PERCENT |
+						   DM_REPORT_FIELD_TYPE_STRING |
+						   DM_REPORT_FIELD_TYPE_TIME;
+	static uint32_t supported_reserved_types_with_range = DM_REPORT_FIELD_RESERVED_VALUE_RANGE |
+							      DM_REPORT_FIELD_TYPE_NUMBER |
+							      DM_REPORT_FIELD_TYPE_SIZE |
+							      DM_REPORT_FIELD_TYPE_PERCENT |
+							      DM_REPORT_FIELD_TYPE_TIME;
+
+
+	if (!reserved_values)
+		return 1;
+
+	iter = reserved_values;
+
+	while (iter->value) {
+		if (iter->type & DM_REPORT_FIELD_TYPE_MASK) {
+			if (!(iter->type & supported_reserved_types) ||
+			    ((iter->type & DM_REPORT_FIELD_RESERVED_VALUE_RANGE) &&
+			     !(iter->type & supported_reserved_types_with_range))) {
+				log_error(INTERNAL_ERROR "_check_reserved_values_supported: "
+					  "global reserved value for type 0x%x not supported",
+					   iter->type);
+				return 0;
+			}
+		} else {
+			field_res = (const struct dm_report_field_reserved_value *) iter->value;
+			field = &fields[field_res->field_num];
+			if (!(field->flags & supported_reserved_types) ||
+			    ((iter->type & DM_REPORT_FIELD_RESERVED_VALUE_RANGE) &&
+			     !(iter->type & supported_reserved_types_with_range))) {
+				log_error(INTERNAL_ERROR "_check_reserved_values_supported: "
+					  "field-specific reserved value of type 0x%x for "
+					  "field %s not supported",
+					   field->flags & DM_REPORT_FIELD_TYPE_MASK, field->id);
+				return 0;
+			}
+		}
+		iter++;
+	}
+
+	return 1;
+}
+
+/*
+ * Input:
+ *   ft              - field type for which the value is parsed
+ *   s               - a pointer to the parsed string
+ * Output:
+ *   begin           - a pointer to the beginning of the token
+ *   end             - a pointer to the end of the token + 1
+ *   flags           - parsing flags
+ */
+static const char *_tok_value_regex(struct dm_report *rh,
+				    const struct dm_report_field_type *ft,
+				    const char *s, const char **begin,
+				    const char **end, uint32_t *flags,
+				    struct reserved_value_wrapper *rvw)
+{
+	char c;
+	rvw->reserved = NULL;
+
+	s = _skip_space(s);
+
+	if (!*s) {
+		log_error("Regular expression expected for selection field %s", ft->id);
+		return NULL;
+	}
+
+	switch (*s) {
+		case '(': c = ')'; break;
+		case '{': c = '}'; break;
+		case '[': c = ']'; break;
+		case '"': /* fall through */
+		case '\'': c = *s; break;
+		default:  c = 0;
+	}
+
+	if (!(s = _tok_value_string(c ? s + 1 : s, begin, end, c, SEL_AND | SEL_OR | SEL_PRECEDENCE_PE, NULL))) {
+		log_error("Failed to parse regex value for selection field %s.", ft->id);
+		return NULL;
+	}
+
+	*flags |= DM_REPORT_FIELD_TYPE_STRING;
+	return s;
+}
+
+static int _str_list_item_cmp(const void *a, const void *b)
+{
+	const struct dm_str_list * const *item_a = (const struct dm_str_list * const *) a;
+	const struct dm_str_list * const *item_b = (const struct dm_str_list * const *) b;
+
+	return strcmp((*item_a)->str, (*item_b)->str);
+}
+
+static int _add_item_to_string_list(struct dm_pool *mem, const char *begin,
+				    const char *end, struct dm_list *list)
+{
+	struct dm_str_list *item;
+
+	if (!(item = dm_pool_zalloc(mem, sizeof(*item))) ||
+	    !(item->str = begin == end ? "" : dm_pool_strndup(mem, begin, end - begin))) {
+		log_error("_add_item_to_string_list: memory allocation failed for string list item");
+		return 0;
+	}
+	dm_list_add(list, &item->list);
+
+	return 1;
+}
+
+/*
+ * Input:
+ *   ft              - field type for which the value is parsed
+ *   mem             - memory pool to allocate from
+ *   s               - a pointer to the parsed string
+ * Output:
+ *   begin           - a pointer to the beginning of the token (whole list)
+ *   end             - a pointer to the end of the token + 1 (whole list)
+ *   sel_str_list    - the list of strings parsed
+ */
+static const char *_tok_value_string_list(const struct dm_report_field_type *ft,
+					  struct dm_pool *mem, const char *s,
+					  const char **begin, const char **end,
+					  struct selection_str_list **sel_str_list)
+{
+	static const char _str_list_item_parsing_failed[] = "Failed to parse string list value "
+							    "for selection field %s.";
+	struct selection_str_list *ssl = NULL;
+	struct dm_str_list *item;
+	const char *begin_item = NULL, *end_item = NULL, *tmp;
+	uint32_t op_flags, end_op_flag_expected, end_op_flag_hit = 0;
+	struct dm_str_list **arr;
+	size_t list_size;
+	unsigned int i;
+	int list_end = 0;
+	char c;
+
+	if (!(ssl = dm_pool_alloc(mem, sizeof(*ssl)))) {
+		log_error("_tok_value_string_list: memory allocation failed for selection list");
+		goto bad;
+	}
+	dm_list_init(&ssl->str_list.list);
+	ssl->type = 0;
+	*begin = s;
+
+	if (!(op_flags = _tok_op_log(s, &tmp, SEL_LIST_LS | SEL_LIST_SUBSET_LS))) {
+		/* Only one item - SEL_LIST_{SUBSET_}LS and SEL_LIST_{SUBSET_}LE not used */
+		c = _get_and_skip_quote_char(&s);
+		if (!(s = _tok_value_string(s, &begin_item, &end_item, c, SEL_AND | SEL_OR | SEL_PRECEDENCE_PE, NULL))) {
+			log_error(_str_list_item_parsing_failed, ft->id);
+			goto bad;
+		}
+		if (!_add_item_to_string_list(mem, begin_item, end_item, &ssl->str_list.list))
+			goto_bad;
+		ssl->type = SEL_OR | SEL_LIST_LS;
+		goto out;
+	}
+
+	/* More than one item - items enclosed in SEL_LIST_LS and SEL_LIST_LE
+	 * or SEL_LIST_SUBSET_LS and SEL_LIST_SUBSET_LE.
+	 * Each element is terminated by AND or OR operator or 'list end'.
+	 * The first operator hit is then the one allowed for the whole list,
+	 * no mixing allowed!
+	 */
+
+	/* Are we using [] or {} for the list? */
+	end_op_flag_expected = (op_flags == SEL_LIST_LS) ? SEL_LIST_LE : SEL_LIST_SUBSET_LE;
+
+	op_flags = SEL_LIST_LE | SEL_LIST_SUBSET_LE | SEL_AND | SEL_OR;
+	s++;
+	while (*s) {
+		s = _skip_space(s);
+		c = _get_and_skip_quote_char(&s);
+		if (!(s = _tok_value_string(s, &begin_item, &end_item, c, op_flags, NULL))) {
+			log_error(_str_list_item_parsing_failed, ft->id);
+			goto bad;
+		}
+		s = _skip_space(s);
+
+		if (!(end_op_flag_hit = _tok_op_log(s, &tmp, op_flags))) {
+			log_error("Invalid operator in selection list.");
+			goto bad;
+		}
+
+		if (end_op_flag_hit & (SEL_LIST_LE | SEL_LIST_SUBSET_LE)) {
+			list_end = 1;
+			if (end_op_flag_hit != end_op_flag_expected) {
+				for (i = 0; _op_log[i].string; i++)
+					if (_op_log[i].flags == end_op_flag_expected)
+						break;
+				log_error("List ended with incorrect character, "
+					  "expecting \'%s\'.", _op_log[i].string);
+				goto bad;
+			}
+		}
+
+		if (ssl->type) {
+			if (!list_end && !(ssl->type & end_op_flag_hit)) {
+				log_error("Only one type of logical operator allowed "
+					  "in selection list at a time.");
+				goto bad;
+			}
+		} else {
+			if (list_end)
+				ssl->type = end_op_flag_expected == SEL_LIST_LE ? SEL_AND : SEL_OR;
+			else
+				ssl->type = end_op_flag_hit;
+		}
+
+		if (!_add_item_to_string_list(mem, begin_item, end_item, &ssl->str_list.list))
+			goto_bad;
+
+		s = tmp;
+
+		if (list_end)
+			break;
+	}
+
+	if (!(end_op_flag_hit & (SEL_LIST_LE | SEL_LIST_SUBSET_LE))) {
+		log_error("Missing list end for selection field %s", ft->id);
+		goto bad;
+	}
+
+	/* Store information whether [] or {} was used. */
+	if (end_op_flag_expected == SEL_LIST_LE)
+		ssl->type |= SEL_LIST_LS;
+	else
+		ssl->type |= SEL_LIST_SUBSET_LS;
+
+	/* Sort the list. */
+	if (!(list_size = dm_list_size(&ssl->str_list.list))) {
+		log_error(INTERNAL_ERROR "_tok_value_string_list: list has no items");
+		goto bad;
+	} else if (list_size == 1)
+		goto out;
+	if (!(arr = dm_malloc(sizeof(item) * list_size))) {
+		log_error("_tok_value_string_list: memory allocation failed for sort array");
+		goto bad;
+	}
+
+	i = 0;
+	dm_list_iterate_items(item, &ssl->str_list.list)
+		arr[i++] = item;
+	qsort(arr, list_size, sizeof(item), _str_list_item_cmp);
+	dm_list_init(&ssl->str_list.list);
+	for (i = 0; i < list_size; i++)
+		dm_list_add(&ssl->str_list.list, &arr[i]->list);
+
+	dm_free(arr);
+out:
+	*end = s;
+        if (sel_str_list)
+		*sel_str_list = ssl;
+
+	return s;
+bad:
+	*end = s;
+	if (ssl)
+		dm_pool_free(mem, ssl);
+        if (sel_str_list)
+		*sel_str_list = NULL;
+	return s;
+}
+
+struct time_value {
+	int range;
+	time_t t1;
+	time_t t2;
+};
+
+static const char *_out_of_range_msg = "Field selection value %s out of supported range for field %s.";
+
+/*
+ * Standard formatted date and time - ISO8601.
+ *
+ * date time timezone
+ *
+ * date:
+ * YYYY-MM-DD (or shortly YYYYMMDD)
+ * YYYY-MM (shortly YYYYMM), auto DD=1
+ * YYYY, auto MM=01 and DD=01
+ *
+ * time:
+ * hh:mm:ss (or shortly hhmmss)
+ * hh:mm (or shortly hhmm), auto ss=0
+ * hh (or shortly hh), auto mm=0, auto ss=0
+ *
+ * timezone:
+ * +hh:mm or -hh:mm (or shortly +hhmm or -hhmm)
+ * +hh or -hh
+*/
+
+#define DELIM_DATE '-'
+#define DELIM_TIME ':'
+
+static int _days_in_month[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+
+static int _is_leap_year(long year)
+{
+	return (((year % 4==0) && (year % 100 != 0)) || (year % 400 == 0));
+}
+
+static int _get_days_in_month(long month, long year)
+{
+	return (month == 2 && _is_leap_year(year)) ? _days_in_month[month-1] + 1
+						   : _days_in_month[month-1];
+}
+
+typedef enum {
+	RANGE_NONE,
+	RANGE_SECOND,
+	RANGE_MINUTE,
+	RANGE_HOUR,
+	RANGE_DAY,
+	RANGE_MONTH,
+	RANGE_YEAR
+} time_range_t;
+
+static char *_get_date(char *str, struct tm *tm, time_range_t *range)
+{
+	static const char incorrect_date_format_msg[] = "Incorrect date format.";
+	time_range_t tmp_range = RANGE_NONE;
+	long n1, n2 = -1, n3 = -1;
+	char *s = str, *end;
+	size_t len = 0;
+
+	if (!isdigit(*s))
+		/* we need a year at least */
+		return NULL;
+
+	n1 = strtol(s, &end, 10);
+	if (*end == DELIM_DATE) {
+		len += (4 - (end - s)); /* diff in length from standard YYYY */
+		s = end + 1;
+		if (isdigit(*s)) {
+			n2 = strtol(s, &end, 10);
+			len += (2 - (end - s)); /* diff in length from standard MM */
+			if (*end == DELIM_DATE) {
+				s = end + 1;
+				n3 = strtol(s, &end, 10);
+				len += (2 - (end - s)); /* diff in length from standard DD */
+			}
+		}
+	}
+
+	len = len + end - str;
+
+	/* variations from standard YYYY-MM-DD */
+	if (n3 == -1) {
+		if (n2 == -1) {
+			if (len == 4) {
+				/* YYYY */
+				tmp_range = RANGE_YEAR;
+				n3 = n2 = 1;
+			} else if (len == 6) {
+				/* YYYYMM */
+				tmp_range = RANGE_MONTH;
+				n3 = 1;
+				n2 = n1 % 100;
+				n1 = n1 / 100;
+			} else if (len == 8) {
+				tmp_range = RANGE_DAY;
+				/* YYYYMMDD */
+				n3 = n1 % 100;
+				n2 = (n1 / 100) % 100;
+				n1 = n1 / 10000;
+			} else {
+				log_error(incorrect_date_format_msg);
+				return NULL;
+			}
+		} else {
+			if (len == 7) {
+				tmp_range = RANGE_MONTH;
+				/* YYYY-MM */
+				n3 = 1;
+			} else {
+				log_error(incorrect_date_format_msg);
+				return NULL;
+			}
+		}
+	}
+
+	if (n2 < 1 || n2 > 12) {
+		log_error("Specified month out of range.");
+		return NULL;
+	}
+
+	if (n3 < 1 || n3 > _get_days_in_month(n2, n1)) {
+		log_error("Specified day out of range.");
+		return NULL;
+	}
+
+	if (tmp_range == RANGE_NONE)
+		tmp_range = RANGE_DAY;
+
+	tm->tm_year = n1 - 1900;
+	tm->tm_mon = n2 - 1;
+	tm->tm_mday = n3;
+	*range = tmp_range;
+
+	return (char *) _skip_space(end);
+}
+
+static char *_get_time(char *str, struct tm *tm, time_range_t *range)
+{
+	static const char incorrect_time_format_msg[] = "Incorrect time format.";
+	time_range_t tmp_range = RANGE_NONE;
+	long n1, n2 = -1, n3 = -1;
+	char *s = str, *end;
+	size_t len = 0;
+
+	if (!isdigit(*s)) {
+		/* time is not compulsory */
+		tm->tm_hour = tm->tm_min = tm->tm_sec = 0;
+		return (char *) _skip_space(s);
+	}
+
+	n1 = strtol(s, &end, 10);
+	if (*end == DELIM_TIME) {
+		len += (2 - (end - s)); /* diff in length from standard HH */
+		s = end + 1;
+		if (isdigit(*s)) {
+			n2 = strtol(s, &end, 10);
+			len += (2 - (end - s)); /* diff in length from standard MM */
+			if (*end == DELIM_TIME) {
+				s = end + 1;
+				n3 = strtol(s, &end, 10);
+				len += (2 - (end - s)); /* diff in length from standard SS */
+			}
+		}
+	}
+
+	len = len + end - str;
+
+	/* variations from standard HH:MM:SS */
+	if (n3 == -1) {
+		if (n2 == -1) {
+			if (len == 2) {
+				/* HH */
+				tmp_range = RANGE_HOUR;
+				n3 = n2 = 0;
+			} else if (len == 4) {
+				/* HHMM */
+				tmp_range = RANGE_MINUTE;
+				n3 = 0;
+				n2 = n1 % 100;
+				n1 = n1 / 100;
+			} else if (len == 6) {
+				/* HHMMSS */
+				tmp_range = RANGE_SECOND;
+				n3 = n1 % 100;
+				n2 = (n1 / 100) % 100;
+				n1 = n1 / 10000;
+			} else {
+				log_error(incorrect_time_format_msg);
+				return NULL;
+			}
+		} else {
+			if (len == 5) {
+				/* HH:MM */
+				tmp_range = RANGE_MINUTE;
+				n3 = 0;
+			} else {
+				log_error(incorrect_time_format_msg);
+				return NULL;
+			}
+		}
+	}
+
+	if (n1 < 0 || n1 > 23) {
+		log_error("Specified hours out of range.");
+		return NULL;
+	}
+
+	if (n2 < 0 || n2 > 60) {
+		log_error("Specified minutes out of range.");
+		return NULL;
+	}
+
+	if (n3 < 0 || n3 > 60) {
+		log_error("Specified seconds out of range.");
+		return NULL;
+	}
+
+	/* Just time without exact date is incomplete! */
+	if (*range != RANGE_DAY) {
+		log_error("Full date specification needed.");
+		return NULL;
+	}
+
+	tm->tm_hour = n1;
+	tm->tm_min = n2;
+	tm->tm_sec = n3;
+	*range = tmp_range;
+
+	return (char *) _skip_space(end);
+}
+
+/* The offset is always an absolute offset against GMT! */
+static char *_get_tz(char *str, int *tz_supplied, int *offset)
+{
+	long n1, n2 = -1;
+	char *s = str, *end;
+	int sign = 1; /* +HH:MM by default */
+	size_t len = 0;
+
+	*tz_supplied = 0;
+	*offset = 0;
+
+	if (!isdigit(*s)) {
+		if (*s == '+')  {
+			sign = 1;
+			s = s + 1;
+		} else if (*s == '-') {
+			sign = -1;
+			s = s + 1;
+		} else
+			return (char *) _skip_space(s);
+	}
+
+	n1 = strtol(s, &end, 10);
+	if (*end == DELIM_TIME) {
+		len = (2 - (end - s)); /* diff in length from standard HH */
+		s = end + 1;
+		if (isdigit(*s)) {
+			n2 = strtol(s, &end, 10);
+			len = (2 - (end - s)); /* diff in length from standard MM */
+		}
+	}
+
+	len = len + end - s;
+
+	/* variations from standard HH:MM */
+	if (n2 == -1) {
+		if (len == 2) {
+			/* HH */
+			n2 = 0;
+		} else if (len == 4) {
+			/* HHMM */
+			n2 = n1 % 100;
+			n1 = n1 / 100;
+		} else
+			return NULL;
+	}
+
+	if (n2 < 0 || n2 > 60)
+		return NULL;
+
+	if (n1 < 0 || n1 > 14)
+		return NULL;
+
+	/* timezone offset in seconds */
+	*offset = sign * ((n1 * 3600) + (n2 * 60));
+	*tz_supplied = 1;
+	return (char *) _skip_space(end);
+}
+
+static int _local_tz_offset(time_t t_local)
+{
+	struct tm tm_gmt;
+	time_t t_gmt;
+
+	gmtime_r(&t_local, &tm_gmt);
+	t_gmt = mktime(&tm_gmt);
+
+	/*
+	 * gmtime returns time that is adjusted
+	 * for DST.Subtract this adjustment back
+	 * to give us proper *absolute* offset
+	 * for our local timezone.
+	 */
+	if (tm_gmt.tm_isdst)
+		t_gmt -= 3600;
+
+	return t_local - t_gmt;
+}
+
+static void _get_final_time(time_range_t range, struct tm *tm,
+			    int tz_supplied, int offset,
+			    struct time_value *tval)
+{
+
+	struct tm tm_up = *tm;
+
+	switch (range) {
+		case RANGE_SECOND:
+			if (tm_up.tm_sec < 59) {
+				tm_up.tm_sec += 1;
+				break;
+			}
+			/* fall through */
+		case RANGE_MINUTE:
+			if (tm_up.tm_min < 59) {
+				tm_up.tm_min += 1;
+				break;
+			}
+			/* fall through */
+		case RANGE_HOUR:
+			if (tm_up.tm_hour < 23) {
+				tm_up.tm_hour += 1;
+				break;
+			}
+			/* fall through */
+		case RANGE_DAY:
+			if (tm_up.tm_mday < _get_days_in_month(tm_up.tm_mon, tm_up.tm_year)) {
+				tm_up.tm_mday += 1;
+				break;
+			}
+			/* fall through */
+		case RANGE_MONTH:
+			if (tm_up.tm_mon < 11) {
+				tm_up.tm_mon += 1;
+				break;
+			}
+			/* fall through */
+		case RANGE_YEAR:
+			tm_up.tm_year += 1;
+			break;
+		case RANGE_NONE:
+			/* nothing to do here */
+			break;
+	}
+
+	tval->range = (range != RANGE_NONE);
+	tval->t1 = mktime(tm);
+	tval->t2 = mktime(&tm_up) - 1;
+
+	if (tz_supplied) {
+		/*
+		 * The 'offset' is with respect to the GMT.
+		 * Calculate what the offset is with respect
+		 * to our local timezone and adjust times
+		 * so they represent time in our local timezone.
+		 */
+		offset -= _local_tz_offset(tval->t1);
+		tval->t1 -= offset;
+		tval->t2 -= offset;
+	}
+}
+
+static int _parse_formatted_date_time(char *str, struct time_value *tval)
+{
+	time_range_t range = RANGE_NONE;
+	struct tm tm = {0};
+	int gmt_offset;
+	int tz_supplied;
+
+	tm.tm_year = tm.tm_mday = tm.tm_mon = -1;
+	tm.tm_hour = tm.tm_min = tm.tm_sec = -1;
+	tm.tm_isdst = tm.tm_wday = tm.tm_yday = -1;
+
+	if (!(str = _get_date(str, &tm, &range)))
+		return 0;
+
+	if (!(str = _get_time(str, &tm, &range)))
+		return 0;
+
+	if (!(str = _get_tz(str, &tz_supplied, &gmt_offset)))
+		return 0;
+
+	if (*str)
+		return 0;
+
+	_get_final_time(range, &tm, tz_supplied, gmt_offset, tval);
+
+	return 1;
+}
+
+static const char *_tok_value_time(const struct dm_report_field_type *ft,
+				   struct dm_pool *mem, const char *s,
+				   const char **begin, const char **end,
+				   struct time_value *tval)
+{
+	char *time_str = NULL;
+	const char *r = NULL;
+	uint64_t t;
+	char c;
+
+	s = _skip_space(s);
+
+	if (*s == '@') {
+		/* Absolute time value in number of seconds since epoch. */
+		if (!(s = _tok_value_number(s+1, begin, end)))
+			goto_out;
+
+		if (!(time_str = dm_pool_strndup(mem, *begin, *end - *begin))) {
+			log_error("_tok_value_time: dm_pool_strndup failed");
+			goto out;
+		}
+
+		errno = 0;
+		if (((t = strtoull(time_str, NULL, 10)) == ULLONG_MAX) && errno == ERANGE) {
+			log_error(_out_of_range_msg, time_str, ft->id);
+			goto out;
+		}
+
+		tval->range = 0;
+		tval->t1 = (time_t) t;
+		tval->t2 = 0;
+		r = s;
+	} else {
+		c = _get_and_skip_quote_char(&s);
+		if (!(s = _tok_value_string(s, begin, end, c, SEL_AND | SEL_OR | SEL_PRECEDENCE_PE, NULL)))
+			goto_out;
+
+		if (!(time_str = dm_pool_strndup(mem, *begin, *end - *begin))) {
+			log_error("tok_value_time: dm_pool_strndup failed");
+			goto out;
+		}
+
+		if (!_parse_formatted_date_time(time_str, tval))
+			goto_out;
+		r = s;
+	}
+out:
+	if (time_str)
+		dm_pool_free(mem, time_str);
+	return r;
+}
+
+/*
+ * Input:
+ *   ft              - field type for which the value is parsed
+ *   s               - a pointer to the parsed string
+ *   mem             - memory pool to allocate from
+ * Output:
+ *   begin           - a pointer to the beginning of the token
+ *   end             - a pointer to the end of the token + 1
+ *   flags           - parsing flags
+ *   custom          - custom data specific to token type
+ *                     (e.g. size unit factor)
+ */
+static const char *_tok_value(struct dm_report *rh,
+			      const struct dm_report_field_type *ft,
+			      uint32_t field_num, int implicit,
+			      const char *s,
+			      const char **begin, const char **end,
+			      uint32_t *flags,
+			      struct reserved_value_wrapper *rvw,
+			      struct dm_pool *mem, void *custom)
+{
+	int expected_type = ft->flags & DM_REPORT_FIELD_TYPE_MASK;
+	struct selection_str_list **str_list;
+	struct time_value *tval;
+	uint64_t *factor;
+	const char *tmp;
+	char c;
+
+	s = _skip_space(s);
+
+	s = _get_reserved(rh, expected_type, field_num, implicit, s, begin, end, rvw);
+	if (rvw->reserved) {
+		/*
+		 * FLD_CMP_NUMBER shares operators with FLD_CMP_TIME,
+		 * so adjust flags here based on expected type.
+		 */
+		if (expected_type == DM_REPORT_FIELD_TYPE_TIME)
+			*flags &= ~FLD_CMP_NUMBER;
+		else if (expected_type == DM_REPORT_FIELD_TYPE_NUMBER)
+			*flags &= ~FLD_CMP_TIME;
+		*flags |= expected_type;
+		return s;
+	}
+
+	switch (expected_type) {
+
+		case DM_REPORT_FIELD_TYPE_STRING:
+			c = _get_and_skip_quote_char(&s);
+			if (!(s = _tok_value_string(s, begin, end, c, SEL_AND | SEL_OR | SEL_PRECEDENCE_PE, NULL))) {
+				log_error("Failed to parse string value "
+					  "for selection field %s.", ft->id);
+				return NULL;
+			}
+			*flags |= DM_REPORT_FIELD_TYPE_STRING;
+			break;
+
+		case DM_REPORT_FIELD_TYPE_STRING_LIST:
+			if (!(str_list = (struct selection_str_list **) custom))
+				goto_bad;
+
+			s = _tok_value_string_list(ft, mem, s, begin, end, str_list);
+			if (!(*str_list)) {
+				log_error("Failed to parse string list value "
+					  "for selection field %s.", ft->id);
+				return NULL;
+			}
+			*flags |= DM_REPORT_FIELD_TYPE_STRING_LIST;
+			break;
+
+		case DM_REPORT_FIELD_TYPE_NUMBER:
+			/* fall through */
+		case DM_REPORT_FIELD_TYPE_SIZE:
+			/* fall through */
+		case DM_REPORT_FIELD_TYPE_PERCENT:
+			if (!(s = _tok_value_number(s, begin, end))) {
+				log_error("Failed to parse numeric value "
+					  "for selection field %s.", ft->id);
+				return NULL;
+			}
+
+			if (*s == DM_PERCENT_CHAR) {
+				s++;
+				c = DM_PERCENT_CHAR;
+				if (expected_type != DM_REPORT_FIELD_TYPE_PERCENT) {
+					log_error("Found percent value but %s value "
+						  "expected for selection field %s.",
+						  expected_type == DM_REPORT_FIELD_TYPE_NUMBER ?
+							"numeric" : "size", ft->id);
+					return NULL;
+				}
+			} else {
+				if (!(factor = (uint64_t *) custom))
+					goto_bad;
+
+				if ((*factor = dm_units_to_factor(s, &c, 0, &tmp))) {
+					s = tmp;
+					if (expected_type != DM_REPORT_FIELD_TYPE_SIZE) {
+						log_error("Found size unit specifier "
+							  "but %s value expected for "
+							  "selection field %s.",
+							  expected_type == DM_REPORT_FIELD_TYPE_NUMBER ?
+							  "numeric" : "percent", ft->id);
+						return NULL;
+					}
+				} else if (expected_type == DM_REPORT_FIELD_TYPE_SIZE) {
+					/*
+					 * If size unit is not defined in the selection
+					 * and the type expected is size, use use 'm'
+					 * (1 MiB) for the unit by default. This is the
+					 * same behaviour as seen in lvcreate -L <size>.
+					 */
+					*factor = 1024*1024;
+				}
+			}
+
+			*flags |= expected_type;
+			/*
+			 * FLD_CMP_NUMBER shares operators with FLD_CMP_TIME,
+			 * but we have NUMBER here, so remove FLD_CMP_TIME.
+			 */
+			*flags &= ~FLD_CMP_TIME;
+			break;
+
+		case DM_REPORT_FIELD_TYPE_TIME:
+			if (!(tval = (struct time_value *) custom))
+				goto_bad;
+
+			if (!(s = _tok_value_time(ft, mem, s, begin, end, tval))) {
+				log_error("Failed to parse time value "
+					  "for selection field %s.", ft->id);
+				return NULL;
+			}
+
+			*flags |= DM_REPORT_FIELD_TYPE_TIME;
+			/*
+			 * FLD_CMP_TIME shares operators with FLD_CMP_NUMBER,
+			 * but we have TIME here, so remove FLD_CMP_NUMBER.
+			 */
+			*flags &= ~FLD_CMP_NUMBER;
+			break;
+	}
+
+	return s;
+bad:
+	log_error(INTERNAL_ERROR "Forbidden NULL custom detected.");
+
+	return NULL;
+}
+
+/*
+ * Input:
+ *   s               - a pointer to the parsed string
+ * Output:
+ *   begin           - a pointer to the beginning of the token
+ *   end             - a pointer to the end of the token + 1
+ */
+static const char *_tok_field_name(const char *s,
+				    const char **begin, const char **end)
+{
+	char c;
+	s = _skip_space(s);
+
+	*begin = s;
+	while ((c = *s) &&
+	       (isalnum(c) || c == '_' || c == '-'))
+		s++;
+	*end = s;
+
+	if (*begin == *end)
+		return NULL;
+
+	return s;
+}
+
+static int _get_reserved_value(struct dm_report *rh, uint32_t field_num,
+			       struct reserved_value_wrapper *rvw)
+{
+	const void *tmp_value;
+	dm_report_reserved_handler handler;
+	int r;
+
+	if (!rvw->reserved) {
+		rvw->value = NULL;
+		return 1;
+	}
+
+	if (rvw->reserved->type & DM_REPORT_FIELD_TYPE_MASK)
+		/* type reserved value */
+		tmp_value = rvw->reserved->value;
+	else
+		/* per-field reserved value */
+		tmp_value = ((const struct dm_report_field_reserved_value *) rvw->reserved->value)->value;
+
+	if (rvw->reserved->type & (DM_REPORT_FIELD_RESERVED_VALUE_DYNAMIC_VALUE | DM_REPORT_FIELD_RESERVED_VALUE_FUZZY_NAMES)) {
+		handler = (dm_report_reserved_handler) tmp_value;
+		if ((r = handler(rh, rh->selection->mem, field_num,
+				 DM_REPORT_RESERVED_GET_DYNAMIC_VALUE,
+				 rvw->matched_name, &tmp_value)) <= 0) {
+			if (r == -1)
+				log_error(INTERNAL_ERROR "%s reserved value handler for field %s has missing"
+					  "implementation of DM_REPORT_RESERVED_GET_DYNAMIC_VALUE action",
+					  (rvw->reserved->type) & DM_REPORT_FIELD_TYPE_MASK ? "type-specific" : "field-specific",
+					  rh->fields[field_num].id);
+			else
+				log_error("Error occured while processing %s reserved value handler for field %s",
+					  (rvw->reserved->type) & DM_REPORT_FIELD_TYPE_MASK ? "type-specific" : "field-specific",
+					  rh->fields[field_num].id);
+			return 0;
+		}
+	}
+
+	rvw->value = tmp_value;
+	return 1;
+}
+
+static struct field_selection *_create_field_selection(struct dm_report *rh,
+						       uint32_t field_num,
+						       int implicit,
+						       const char *v,
+						       size_t len,
+						       uint32_t flags,
+						       struct reserved_value_wrapper *rvw,
+						       void *custom)
+{
+	static const char *_field_selection_value_alloc_failed_msg = "dm_report: struct field_selection_value allocation failed for selection field %s";
+	const struct dm_report_field_type *fields = implicit ? _implicit_report_fields
+							     : rh->fields;
+	struct field_properties *fp, *found = NULL;
+	struct field_selection *fs;
+	const char *field_id;
+	struct time_value *tval;
+	uint64_t factor;
+	char *s;
+
+	dm_list_iterate_items(fp, &rh->field_props) {
+		if ((fp->implicit == implicit) && (fp->field_num == field_num)) {
+			found = fp;
+			break;
+		}
+	}
+
+	/* The field is neither used in display options nor sort keys. */
+	if (!found) {
+		if (rh->selection->add_new_fields) {
+			if (!(found = _add_field(rh, field_num, implicit, FLD_HIDDEN)))
+				return NULL;
+			rh->report_types |= fields[field_num].type;
+		} else {
+			log_error("Unable to create selection with field \'%s\' "
+				  "which is not included in current report.",
+				  implicit ? _implicit_report_fields[field_num].id
+					   : rh->fields[field_num].id);
+			return NULL;
+		}
+	}
+
+	field_id = fields[found->field_num].id;
+
+	if (!(found->flags & flags & DM_REPORT_FIELD_TYPE_MASK)) {
+		log_error("dm_report: incompatible comparison "
+			  "type for selection field %s", field_id);
+		return NULL;
+	}
+
+	/* set up selection */
+	if (!(fs = dm_pool_zalloc(rh->selection->mem, sizeof(struct field_selection)))) {
+		log_error("dm_report: struct field_selection "
+			  "allocation failed for selection field %s", field_id);
+		return NULL;
+	}
+
+	if (!(fs->value = dm_pool_zalloc(rh->selection->mem, sizeof(struct field_selection_value)))) {
+		log_error(_field_selection_value_alloc_failed_msg, field_id);
+		goto error;
+	}
+
+	if (((rvw->reserved && (rvw->reserved->type & DM_REPORT_FIELD_RESERVED_VALUE_RANGE)) ||
+	     (((flags & DM_REPORT_FIELD_TYPE_MASK) == DM_REPORT_FIELD_TYPE_TIME) &&
+	      custom && ((struct time_value *) custom)->range))
+		 &&
+	    !(fs->value->next = dm_pool_zalloc(rh->selection->mem, sizeof(struct field_selection_value)))) {
+		log_error(_field_selection_value_alloc_failed_msg, field_id);
+		goto error;
+	}
+
+	fs->fp = found;
+	fs->flags = flags;
+
+	if (!_get_reserved_value(rh, field_num, rvw)) {
+		log_error("dm_report: could not get reserved value "
+			  "while processing selection field %s", field_id);
+		goto error;
+	}
+
+	/* store comparison operand */
+	if (flags & FLD_CMP_REGEX) {
+		/* REGEX */
+		if (!(s = dm_malloc(len + 1))) {
+			log_error("dm_report: dm_malloc failed to store "
+				  "regex value for selection field %s", field_id);
+			goto error;
+		}
+		memcpy(s, v, len);
+		s[len] = '\0';
+
+		fs->value->v.r = dm_regex_create(rh->selection->mem, (const char * const *) &s, 1);
+		dm_free(s);
+		if (!fs->value->v.r) {
+			log_error("dm_report: failed to create regex "
+				  "matcher for selection field %s", field_id);
+			goto error;
+		}
+	} else {
+		/* STRING, NUMBER, SIZE, PERCENT, STRING_LIST, TIME */
+		if (!(s = dm_pool_strndup(rh->selection->mem, v, len))) {
+			log_error("dm_report: dm_pool_strndup for value "
+				  "of selection field %s", field_id);
+			goto error;
+		}
+
+		switch (flags & DM_REPORT_FIELD_TYPE_MASK) {
+			case DM_REPORT_FIELD_TYPE_STRING:
+				if (rvw->value) {
+					fs->value->v.s = (const char *) rvw->value;
+					if (rvw->reserved->type & DM_REPORT_FIELD_RESERVED_VALUE_RANGE)
+						fs->value->next->v.s = (((const char * const *) rvw->value)[1]);
+					dm_pool_free(rh->selection->mem, s);
+				} else {
+					fs->value->v.s = s;
+					if (_check_value_is_strictly_reserved(rh, field_num, DM_REPORT_FIELD_TYPE_STRING, fs->value->v.s, NULL)) {
+						log_error("String value %s found in selection is reserved.", fs->value->v.s);
+						goto error;
+					}
+				}
+				break;
+			case DM_REPORT_FIELD_TYPE_NUMBER:
+				if (rvw->value) {
+					fs->value->v.i = *(const uint64_t *) rvw->value;
+					if (rvw->reserved->type & DM_REPORT_FIELD_RESERVED_VALUE_RANGE)
+						fs->value->next->v.i = (((const uint64_t *) rvw->value)[1]);
+				} else {
+					errno = 0;
+					if (((fs->value->v.i = strtoull(s, NULL, 10)) == ULLONG_MAX) &&
+						 (errno == ERANGE)) {
+						log_error(_out_of_range_msg, s, field_id);
+						goto error;
+					}
+					if (_check_value_is_strictly_reserved(rh, field_num, DM_REPORT_FIELD_TYPE_NUMBER, &fs->value->v.i, NULL)) {
+						log_error("Numeric value %" PRIu64 " found in selection is reserved.", fs->value->v.i);
+						goto error;
+					}
+				}
+				dm_pool_free(rh->selection->mem, s);
+				break;
+			case DM_REPORT_FIELD_TYPE_SIZE:
+				if (rvw->value) {
+					fs->value->v.d = *(const double *) rvw->value;
+					if (rvw->reserved->type & DM_REPORT_FIELD_RESERVED_VALUE_RANGE)
+						fs->value->next->v.d = (((const double *) rvw->value)[1]);
+				} else {
+					errno = 0;
+					fs->value->v.d = strtod(s, NULL);
+					if (errno == ERANGE) {
+						log_error(_out_of_range_msg, s, field_id);
+						goto error;
+					}
+					if (custom && (factor = *((const uint64_t *)custom)))
+						fs->value->v.d *= factor;
+					fs->value->v.d /= 512; /* store size in sectors! */
+					if (_check_value_is_strictly_reserved(rh, field_num, DM_REPORT_FIELD_TYPE_SIZE, &fs->value->v.d, NULL)) {
+						log_error("Size value %f found in selection is reserved.", fs->value->v.d);
+						goto error;
+					}
+				}
+				dm_pool_free(rh->selection->mem, s);
+				break;
+			case DM_REPORT_FIELD_TYPE_PERCENT:
+				if (rvw->value) {
+					fs->value->v.i = *(const uint64_t *) rvw->value;
+					if (rvw->reserved->type & DM_REPORT_FIELD_RESERVED_VALUE_RANGE)
+						fs->value->next->v.i = (((const uint64_t *) rvw->value)[1]);
+				} else {
+					errno = 0;
+					fs->value->v.d = strtod(s, NULL);
+					if ((errno == ERANGE) || (fs->value->v.d < 0) || (fs->value->v.d > 100)) {
+						log_error(_out_of_range_msg, s, field_id);
+						goto error;
+					}
+
+					fs->value->v.i = (dm_percent_t) (DM_PERCENT_1 * fs->value->v.d);
+
+					if (_check_value_is_strictly_reserved(rh, field_num, DM_REPORT_FIELD_TYPE_PERCENT, &fs->value->v.i, NULL)) {
+						log_error("Percent value %s found in selection is reserved.", s);
+						goto error;
+					}
+				}
+				break;
+			case DM_REPORT_FIELD_TYPE_STRING_LIST:
+				if (!custom)
+                                        goto_bad;
+				fs->value->v.l = *(struct selection_str_list **)custom;
+				if (_check_value_is_strictly_reserved(rh, field_num, DM_REPORT_FIELD_TYPE_STRING_LIST, fs->value->v.l, NULL)) {
+					log_error("String list value found in selection is reserved.");
+					goto error;
+				}
+				break;
+			case DM_REPORT_FIELD_TYPE_TIME:
+				if (rvw->value) {
+					fs->value->v.t = *(const time_t *) rvw->value;
+					if (rvw->reserved->type & DM_REPORT_FIELD_RESERVED_VALUE_RANGE)
+						fs->value->next->v.t = (((const time_t *) rvw->value)[1]);
+				} else {
+					if (!(tval = (struct time_value *) custom))
+						goto_bad;
+					fs->value->v.t = tval->t1;
+					if (tval->range)
+						fs->value->next->v.t = tval->t2;
+					if (_check_value_is_strictly_reserved(rh, field_num, DM_REPORT_FIELD_TYPE_TIME, &fs->value->v.t, NULL)) {
+						log_error("Time value found in selection is reserved.");
+						goto error;
+					}
+				}
+				break;
+			default:
+				log_error(INTERNAL_ERROR "_create_field_selection: "
+					  "unknown type of selection field %s", field_id);
+				goto error;
+		}
+	}
+
+	return fs;
+bad:
+	log_error(INTERNAL_ERROR "Forbiden NULL custom detected.");
+error:
+	dm_pool_free(rh->selection->mem, fs);
+
+	return NULL;
+}
+
+static struct selection_node *_alloc_selection_node(struct dm_pool *mem, uint32_t type)
+{
+	struct selection_node *sn;
+
+	if (!(sn = dm_pool_zalloc(mem, sizeof(struct selection_node)))) {
+		log_error("dm_report: struct selection_node allocation failed");
+		return NULL;
+	}
+
+	dm_list_init(&sn->list);
+	sn->type = type;
+	if (!(type & SEL_ITEM))
+		dm_list_init(&sn->selection.set);
+
+	return sn;
+}
+
+static void _display_selection_help(struct dm_report *rh)
+{
+	static const char _grow_object_failed_msg[] = "_display_selection_help: dm_pool_grow_object failed";
+	struct op_def *t;
+	const struct dm_report_reserved_value *rv;
+	size_t len_all, len_final = 0;
+	const char **rvs;
+	char *rvs_all;
+
+	log_warn("Selection operands");
+	log_warn("------------------");
+	log_warn("  field               - Reporting field.");
+	log_warn("  number              - Non-negative integer value.");
+	log_warn("  size                - Floating point value with units, 'm' unit used by default if not specified.");
+	log_warn("  percent             - Non-negative integer with or without %% suffix.");
+	log_warn("  string              - Characters quoted by \' or \" or unquoted.");
+	log_warn("  string list         - Strings enclosed by [ ] or { } and elements delimited by either");
+	log_warn("                        \"all items must match\" or \"at least one item must match\" operator.");
+	log_warn("  regular expression  - Characters quoted by \' or \" or unquoted.");
+	log_warn(" ");
+	if (rh->reserved_values) {
+		log_warn("Reserved values");
+		log_warn("---------------");
+
+		for (rv = rh->reserved_values; rv->type; rv++) {
+			for (len_all = 0, rvs = rv->names; *rvs; rvs++)
+				len_all += strlen(*rvs) + 2;
+			if (len_all > len_final)
+				len_final = len_all;
+		}
+
+		for (rv = rh->reserved_values; rv->type; rv++) {
+			if (!dm_pool_begin_object(rh->mem, 256)) {
+				log_error("_display_selection_help: dm_pool_begin_object failed");
+				break;
+			}
+			for (rvs = rv->names; *rvs; rvs++) {
+				if (((rvs != rv->names) && !dm_pool_grow_object(rh->mem, ", ", 2)) ||
+				    !dm_pool_grow_object(rh->mem, *rvs, strlen(*rvs))) {
+					log_error(_grow_object_failed_msg);
+					goto out_reserved_values;
+				}
+			}
+			if (!dm_pool_grow_object(rh->mem, "\0", 1)) {
+				log_error(_grow_object_failed_msg);
+				goto out_reserved_values;
+			}
+			rvs_all = dm_pool_end_object(rh->mem);
+
+			log_warn("  %-*s - %s [%s]", (int) len_final, rvs_all, rv->description,
+						     _get_field_type_name(rv->type));
+			dm_pool_free(rh->mem, rvs_all);
+		}
+		log_warn(" ");
+	}
+out_reserved_values:
+	log_warn("Selection operators");
+	log_warn("-------------------");
+	log_warn("  Comparison operators:");
+	t = _op_cmp;
+	for (; t->string; t++)
+		log_warn("    %6s  - %s", t->string, t->desc);
+	log_warn(" ");
+	log_warn("  Logical and grouping operators:");
+	t = _op_log;
+	for (; t->string; t++)
+		log_warn("    %4s  - %s", t->string, t->desc);
+	log_warn(" ");
+}
+
+static const char _sel_syntax_error_at_msg[] = "Selection syntax error at '%s'.";
+static const char _sel_help_ref_msg[] = "Use \'help\' for selection to get more help.";
+
+/*
+ * Selection parser
+ *
+ * _parse_* functions
+ *
+ *   Input:
+ *     s             - a pointer to the parsed string
+ *   Output:
+ *     next          - a pointer used for next _parse_*'s input,
+ *                     next == s if return value is NULL
+ *     return value  - a filter node pointer,
+ *                     NULL if s doesn't match
+ */
+
+/*
+ * SELECTION := FIELD_NAME OP_CMP STRING |
+ *              FIELD_NAME OP_CMP NUMBER  |
+ *              FIELD_NAME OP_REGEX REGEX
+ */
+static struct selection_node *_parse_selection(struct dm_report *rh,
+					       const char *s,
+					       const char **next)
+{
+	struct field_selection *fs;
+	struct selection_node *sn;
+	const char *ws, *we; /* field name */
+	const char *vs, *ve; /* value */
+	const char *last;
+	uint32_t flags, field_num;
+	int implicit;
+	const struct dm_report_field_type *ft;
+	struct selection_str_list *str_list;
+	struct reserved_value_wrapper rvw = {0};
+	struct time_value tval;
+	uint64_t factor;
+	void *custom = NULL;
+	char *tmp;
+	char c;
+
+	/* field name */
+	if (!(last = _tok_field_name(s, &ws, &we))) {
+		log_error("Expecting field name");
+		goto bad;
+	}
+
+	/* check if the field with given name exists */
+	if (!_get_field(rh, ws, (size_t) (we - ws), &field_num, &implicit)) {
+		c = we[0];
+		tmp = (char *) we;
+		tmp[0] = '\0';
+		_display_fields(rh, 0, 1);
+		log_warn(" ");
+		log_error("Unrecognised selection field: %s", ws);
+		tmp[0] = c;
+		goto bad;
+	}
+
+	if (implicit) {
+		ft = &_implicit_report_fields[field_num];
+		if (ft->flags & FLD_CMP_UNCOMPARABLE) {
+			c = we[0];
+			tmp = (char *) we;
+			tmp[0] = '\0';
+			_display_fields(rh, 0, 1);
+			log_warn(" ");
+			log_error("Selection field is uncomparable: %s.", ws);
+			tmp[0] = c;
+			goto bad;
+		}
+	} else
+		ft = &rh->fields[field_num];
+
+	/* comparison operator */
+	if (!(flags = _tok_op_cmp(we, &last))) {
+		_display_selection_help(rh);
+		log_error("Unrecognised comparison operator: %s", we);
+		goto bad;
+	}
+	if (!last) {
+		_display_selection_help(rh);
+		log_error("Missing value after operator");
+		goto bad;
+	}
+
+	/* comparison value */
+	if (flags & FLD_CMP_REGEX) {
+		/*
+		 * REGEX value
+		 */
+		if (!(last = _tok_value_regex(rh, ft, last, &vs, &ve, &flags, &rvw)))
+			goto_bad;
+	} else {
+		/*
+		 * STRING, NUMBER, SIZE, PERCENT, STRING_LIST, TIME value
+		 */
+		if (flags & FLD_CMP_NUMBER) {
+			if (!(ft->flags & (DM_REPORT_FIELD_TYPE_NUMBER |
+					   DM_REPORT_FIELD_TYPE_SIZE |
+					   DM_REPORT_FIELD_TYPE_PERCENT |
+					   DM_REPORT_FIELD_TYPE_TIME))) {
+				_display_selection_help(rh);
+				log_error("Operator can be used only with number, size, time or percent fields: %s", ws);
+				goto bad;
+			}
+		} else if (flags & FLD_CMP_TIME) {
+			if (!(ft->flags & DM_REPORT_FIELD_TYPE_TIME)) {
+				_display_selection_help(rh);
+				log_error("Operator can be used only with time fields: %s", ws);
+				goto bad;
+			}
+		}
+
+		if (ft->flags == DM_REPORT_FIELD_TYPE_SIZE ||
+		    ft->flags == DM_REPORT_FIELD_TYPE_NUMBER ||
+		    ft->flags == DM_REPORT_FIELD_TYPE_PERCENT)
+			custom = &factor;
+		else if (ft->flags & DM_REPORT_FIELD_TYPE_TIME)
+			custom = &tval;
+		else if (ft->flags == DM_REPORT_FIELD_TYPE_STRING_LIST)
+			custom = &str_list;
+		else
+			custom = NULL;
+		if (!(last = _tok_value(rh, ft, field_num, implicit,
+					last, &vs, &ve, &flags,
+					&rvw, rh->selection->mem, custom)))
+			goto_bad;
+	}
+
+	*next = _skip_space(last);
+
+	/* create selection */
+	if (!(fs = _create_field_selection(rh, field_num, implicit, vs, (size_t) (ve - vs), flags, &rvw, custom)))
+		return_NULL;
+
+	/* create selection node */
+	if (!(sn = _alloc_selection_node(rh->selection->mem, SEL_ITEM)))
+		return_NULL;
+
+	/* add selection to selection node */
+	sn->selection.item = fs;
+
+	return sn;
+bad:
+	log_error(_sel_syntax_error_at_msg, s);
+	log_error(_sel_help_ref_msg);
+	*next = s;
+	return NULL;
+}
+
+static struct selection_node *_parse_or_ex(struct dm_report *rh,
+					   const char *s,
+					   const char **next,
+					   struct selection_node *or_sn);
+
+static struct selection_node *_parse_ex(struct dm_report *rh,
+					const char *s,
+					const char **next)
+{
+	static const char _ps_expected_msg[] = "Syntax error: left parenthesis expected at \'%s\'";
+	static const char _pe_expected_msg[] = "Syntax error: right parenthesis expected at \'%s\'";
+	struct selection_node *sn = NULL;
+	uint32_t t;
+	const char *tmp;
+
+	t = _tok_op_log(s, next, SEL_MODIFIER_NOT | SEL_PRECEDENCE_PS);
+	if (t == SEL_MODIFIER_NOT) {
+		/* '!' '(' EXPRESSION ')' */
+		if (!_tok_op_log(*next, &tmp, SEL_PRECEDENCE_PS)) {
+			log_error(_ps_expected_msg, *next);
+			goto error;
+		}
+		if (!(sn = _parse_or_ex(rh, tmp, next, NULL)))
+			goto error;
+		sn->type |= SEL_MODIFIER_NOT;
+		if (!_tok_op_log(*next, &tmp, SEL_PRECEDENCE_PE)) {
+			log_error(_pe_expected_msg, *next);
+			goto error;
+		}
+		*next = tmp;
+	} else if (t == SEL_PRECEDENCE_PS) {
+		/* '(' EXPRESSION ')' */
+		if (!(sn = _parse_or_ex(rh, *next, &tmp, NULL)))
+			goto error;
+		if (!_tok_op_log(tmp, next, SEL_PRECEDENCE_PE)) {
+			log_error(_pe_expected_msg, *next);
+			goto error;
+		}
+	} else if ((s = _skip_space(s))) {
+		/* SELECTION */
+		sn = _parse_selection(rh, s, next);
+	} else {
+		sn = NULL;
+		*next = s;
+	}
+
+	return sn;
+error:
+	*next = s;
+	return NULL;
+}
+
+/* AND_EXPRESSION := EX (AND_OP AND_EXPRSSION) */
+static struct selection_node *_parse_and_ex(struct dm_report *rh,
+					    const char *s,
+					    const char **next,
+					    struct selection_node *and_sn)
+{
+	struct selection_node *n;
+	const char *tmp;
+
+	n = _parse_ex(rh, s, next);
+	if (!n)
+		goto error;
+
+	if (!_tok_op_log(*next, &tmp, SEL_AND)) {
+		if (!and_sn)
+			return n;
+		dm_list_add(&and_sn->selection.set, &n->list);
+		return and_sn;
+	}
+
+	if (!and_sn) {
+		if (!(and_sn = _alloc_selection_node(rh->selection->mem, SEL_AND)))
+			goto error;
+	}
+	dm_list_add(&and_sn->selection.set, &n->list);
+
+	return _parse_and_ex(rh, tmp, next, and_sn);
+error:
+	*next = s;
+	return NULL;
+}
+
+/* OR_EXPRESSION := AND_EXPRESSION (OR_OP OR_EXPRESSION) */
+static struct selection_node *_parse_or_ex(struct dm_report *rh,
+					   const char *s,
+					   const char **next,
+					   struct selection_node *or_sn)
+{
+	struct selection_node *n;
+	const char *tmp;
+
+	n = _parse_and_ex(rh, s, next, NULL);
+	if (!n)
+		goto error;
+
+	if (!_tok_op_log(*next, &tmp, SEL_OR)) {
+		if (!or_sn)
+			return n;
+		dm_list_add(&or_sn->selection.set, &n->list);
+		return or_sn;
+	}
+
+	if (!or_sn) {
+		if (!(or_sn = _alloc_selection_node(rh->selection->mem, SEL_OR)))
+			goto error;
+	}
+	dm_list_add(&or_sn->selection.set, &n->list);
+
+	return _parse_or_ex(rh, tmp, next, or_sn);
+error:
+	*next = s;
+	return NULL;
+}
+
+static int _alloc_rh_selection(struct dm_report *rh)
+{
+	if (!(rh->selection = dm_pool_zalloc(rh->mem, sizeof(struct selection))) ||
+	    !(rh->selection->mem = dm_pool_create("report selection", 10 * 1024))) {
+		log_error("Failed to allocate report selection structure.");
+		if (rh->selection)
+			dm_pool_free(rh->mem, rh->selection);
+		return 0;
+	}
+
+	return 1;
+}
+
+#define SPECIAL_SELECTION_ALL "all"
+
+static int _report_set_selection(struct dm_report *rh, const char *selection, int add_new_fields)
+{
+	struct selection_node *root = NULL;
+	const char *fin, *next;
+
+	if (rh->selection) {
+		if (rh->selection->selection_root)
+			/* Trash any previous selection. */
+			dm_pool_free(rh->selection->mem, rh->selection->selection_root);
+		rh->selection->selection_root = NULL;
+	} else {
+		if (!_alloc_rh_selection(rh))
+			goto_bad;
+	}
+
+	if (!selection || !selection[0] || !strcasecmp(selection, SPECIAL_SELECTION_ALL))
+		return 1;
+
+	rh->selection->add_new_fields = add_new_fields;
+
+	if (!(root = _alloc_selection_node(rh->selection->mem, SEL_OR)))
+		return 0;
+
+	if (!_parse_or_ex(rh, selection, &fin, root))
+		goto_bad;
+
+	next = _skip_space(fin);
+	if (*next) {
+		log_error("Expecting logical operator");
+		log_error(_sel_syntax_error_at_msg, next);
+		log_error(_sel_help_ref_msg);
+		goto bad;
+	}
+
+	rh->selection->selection_root = root;
+	return 1;
+bad:
+	dm_pool_free(rh->selection->mem, root);
+	return 0;
+}
+
+static void _reset_field_props(struct dm_report *rh)
+{
+	struct field_properties *fp;
+	dm_list_iterate_items(fp, &rh->field_props)
+		fp->width = fp->initial_width;
+	rh->flags |= RH_FIELD_CALC_NEEDED;
+}
+
+int dm_report_set_selection(struct dm_report *rh, const char *selection)
+{
+	struct row *row;
+
+	if (!_report_set_selection(rh, selection, 0))
+		return_0;
+
+	_reset_field_props(rh);
+
+	dm_list_iterate_items(row, &rh->rows) {
+		row->selected = _check_report_selection(rh, &row->fields);
+		if (row->field_sel_status)
+			_implicit_report_fields[row->field_sel_status->props->field_num].report_fn(rh,
+							rh->mem, row->field_sel_status, row, rh->private);
+	}
+
+	return 1;
+}
+
+struct dm_report *dm_report_init_with_selection(uint32_t *report_types,
+						const struct dm_report_object_type *types,
+						const struct dm_report_field_type *fields,
+						const char *output_fields,
+						const char *output_separator,
+						uint32_t output_flags,
+						const char *sort_keys,
+						const char *selection,
+						const struct dm_report_reserved_value reserved_values[],
+						void *private_data)
+{
+	struct dm_report *rh;
+
+	_implicit_report_fields = _implicit_special_report_fields_with_selection;
+
+	if (!(rh = dm_report_init(report_types, types, fields, output_fields,
+			output_separator, output_flags, sort_keys, private_data)))
+		return NULL;
+
+	if (!selection || !selection[0]) {
+		rh->selection = NULL;
+		return rh;
+	}
+
+	if (!_check_reserved_values_supported(fields, reserved_values)) {
+		log_error(INTERNAL_ERROR "dm_report_init_with_selection: "
+			  "trying to register unsupported reserved value type, "
+			  "skipping report selection");
+		return rh;
+	}
+	rh->reserved_values = reserved_values;
+
+	if (!strcasecmp(selection, SPECIAL_FIELD_HELP_ID) ||
+	    !strcmp(selection, SPECIAL_FIELD_HELP_ALT_ID)) {
+		_display_fields(rh, 0, 1);
+		log_warn(" ");
+		_display_selection_help(rh);
+		rh->flags |= RH_ALREADY_REPORTED;
+		return rh;
+	}
+
+	if (!_report_set_selection(rh, selection, 1))
+		goto_bad;
+
+	_dm_report_init_update_types(rh, report_types);
+
+	return rh;
+bad:
+	dm_report_free(rh);
+	return NULL;
+}
+
+/*
+ * Print row of headings
+ */
+static int _report_headings(struct dm_report *rh)
+{
+	const struct dm_report_field_type *fields;
+	struct field_properties *fp;
+	const char *heading;
+	char *buf = NULL;
+	size_t buf_size = 0;
+
+	rh->flags |= RH_HEADINGS_PRINTED;
+
+	if (!(rh->flags & DM_REPORT_OUTPUT_HEADINGS))
+		return 1;
+
+	if (!dm_pool_begin_object(rh->mem, 128)) {
+		log_error("dm_report: "
+			  "dm_pool_begin_object failed for headings");
+		return 0;
+	}
+
+	dm_list_iterate_items(fp, &rh->field_props) {
+		if ((int) buf_size < fp->width)
+			buf_size = (size_t) fp->width;
+	}
+	/* Including trailing '\0'! */
+	buf_size++;
+
+	if (!(buf = dm_malloc(buf_size))) {
+		log_error("dm_report: Could not allocate memory for heading buffer.");
+		goto bad;
+	}
+
+	/* First heading line */
+	dm_list_iterate_items(fp, &rh->field_props) {
+		if (fp->flags & FLD_HIDDEN)
+			continue;
+
+		fields = fp->implicit ? _implicit_report_fields : rh->fields;
+
+		heading = fields[fp->field_num].heading;
+		if (rh->flags & DM_REPORT_OUTPUT_ALIGNED) {
+			if (dm_snprintf(buf, buf_size, "%-*.*s",
+					 fp->width, fp->width, heading) < 0) {
+				log_error("dm_report: snprintf heading failed");
+				goto bad;
+			}
+			if (!dm_pool_grow_object(rh->mem, buf, fp->width)) {
+				log_error("dm_report: Failed to generate report headings for printing");
+				goto bad;
+			}
+		} else if (!dm_pool_grow_object(rh->mem, heading, 0)) {
+			log_error("dm_report: Failed to generate report headings for printing");
+			goto bad;
+		}
+
+		if (!dm_list_end(&rh->field_props, &fp->list))
+			if (!dm_pool_grow_object(rh->mem, rh->separator, 0)) {
+				log_error("dm_report: Failed to generate report headings for printing");
+				goto bad;
+			}
+	}
+	if (!dm_pool_grow_object(rh->mem, "\0", 1)) {
+		log_error("dm_report: Failed to generate report headings for printing");
+		goto bad;
+	}
+
+	/* print all headings */
+	heading = (char *) dm_pool_end_object(rh->mem);
+	log_print("%s", heading);
+
+	dm_pool_free(rh->mem, (void *)heading);
+	dm_free(buf);
+
+	return 1;
+
+      bad:
+	dm_free(buf);
+	dm_pool_abandon_object(rh->mem);
+	return 0;
+}
+
+static int _should_display_row(struct row *row)
+{
+	return row->field_sel_status || row->selected;
+}
+
+static void _recalculate_fields(struct dm_report *rh)
+{
+	struct row *row;
+	struct dm_report_field *field;
+	int len;
+
+	dm_list_iterate_items(row, &rh->rows) {
+		dm_list_iterate_items(field, &row->fields) {
+			if ((rh->flags & RH_SORT_REQUIRED) &&
+			    (field->props->flags & FLD_SORT_KEY)) {
+				(*row->sort_fields)[field->props->sort_posn] = field;
+			}
+
+			if (_should_display_row(row)) {
+				len = (int) strlen(field->report_string);
+				if ((len > field->props->width))
+					field->props->width = len;
+
+			}
+		}
+	}
+
+	rh->flags &= ~RH_FIELD_CALC_NEEDED;
+}
+
+int dm_report_column_headings(struct dm_report *rh)
+{
+	/* Columns-as-rows does not use _report_headings. */
+	if (rh->flags & DM_REPORT_OUTPUT_COLUMNS_AS_ROWS)
+		return 1;
+
+	if (rh->flags & RH_FIELD_CALC_NEEDED)
+		_recalculate_fields(rh);
+
+	return _report_headings(rh);
+}
+
+/*
+ * Sort rows of data
+ */
+static int _row_compare(const void *a, const void *b)
+{
+	const struct row *rowa = *(const struct row * const *) a;
+	const struct row *rowb = *(const struct row * const *) b;
+	const struct dm_report_field *sfa, *sfb;
+	uint32_t cnt;
+
+	for (cnt = 0; cnt < rowa->rh->keys_count; cnt++) {
+		sfa = (*rowa->sort_fields)[cnt];
+		sfb = (*rowb->sort_fields)[cnt];
+		if ((sfa->props->flags & DM_REPORT_FIELD_TYPE_NUMBER) ||
+		    (sfa->props->flags & DM_REPORT_FIELD_TYPE_SIZE) ||
+		    (sfa->props->flags & DM_REPORT_FIELD_TYPE_TIME)) {
+			const uint64_t numa =
+			    *(const uint64_t *) sfa->sort_value;
+			const uint64_t numb =
+			    *(const uint64_t *) sfb->sort_value;
+
+			if (numa == numb)
+				continue;
+
+			if (sfa->props->flags & FLD_ASCENDING) {
+				return (numa > numb) ? 1 : -1;
+			} else {	/* FLD_DESCENDING */
+				return (numa < numb) ? 1 : -1;
+			}
+		} else {
+			/* DM_REPORT_FIELD_TYPE_STRING
+			 * DM_REPORT_FIELD_TYPE_STRING_LIST */
+			const char *stra = (const char *) sfa->sort_value;
+			const char *strb = (const char *) sfb->sort_value;
+			int cmp = strcmp(stra, strb);
+
+			if (!cmp)
+				continue;
+
+			if (sfa->props->flags & FLD_ASCENDING) {
+				return (cmp > 0) ? 1 : -1;
+			} else {	/* FLD_DESCENDING */
+				return (cmp < 0) ? 1 : -1;
+			}
+		}
+	}
+
+	return 0;		/* Identical */
+}
+
+static int _sort_rows(struct dm_report *rh)
+{
+	struct row *(*rows)[];
+	uint32_t count = 0;
+	struct row *row;
+
+	if (!(rows = dm_pool_alloc(rh->mem, sizeof(**rows) *
+				dm_list_size(&rh->rows)))) {
+		log_error("dm_report: sort array allocation failed");
+		return 0;
+	}
+
+	dm_list_iterate_items(row, &rh->rows)
+		(*rows)[count++] = row;
+
+	qsort(rows, count, sizeof(**rows), _row_compare);
+
+	dm_list_init(&rh->rows);
+	while (count--)
+		dm_list_add_h(&rh->rows, &(*rows)[count]->list);
+
+	return 1;
+}
+
+#define STANDARD_QUOTE		"\'"
+#define STANDARD_PAIR		"="
+
+#define JSON_INDENT_UNIT       4
+#define JSON_SPACE             " "
+#define JSON_QUOTE             "\""
+#define JSON_PAIR              ":"
+#define JSON_SEPARATOR         ","
+#define JSON_OBJECT_START      "{"
+#define JSON_OBJECT_END        "}"
+#define JSON_ARRAY_START       "["
+#define JSON_ARRAY_END         "]"
+#define JSON_ESCAPE_CHAR       "\\"
+
+#define UNABLE_TO_EXTEND_OUTPUT_LINE_MSG "dm_report: Unable to extend output line"
+
+static int _is_basic_report(struct dm_report *rh)
+{
+	return rh->group_item &&
+	       (rh->group_item->group->type == DM_REPORT_GROUP_BASIC);
+}
+
+static int _is_json_report(struct dm_report *rh)
+{
+	return rh->group_item &&
+	       (rh->group_item->group->type == DM_REPORT_GROUP_JSON);
+}
+
+/*
+ * Produce report output
+ */
+static int _output_field(struct dm_report *rh, struct dm_report_field *field)
+{
+	const struct dm_report_field_type *fields = field->props->implicit ? _implicit_report_fields
+									   : rh->fields;
+	char *field_id;
+	int32_t width;
+	uint32_t align;
+	const char *repstr;
+	const char *p1_repstr, *p2_repstr;
+	char *buf = NULL;
+	size_t buf_size = 0;
+
+	if (_is_json_report(rh)) {
+		if (!dm_pool_grow_object(rh->mem, JSON_QUOTE, 1) ||
+		    !dm_pool_grow_object(rh->mem, fields[field->props->field_num].id, 0) ||
+		    !dm_pool_grow_object(rh->mem, JSON_QUOTE, 1) ||
+		    !dm_pool_grow_object(rh->mem, JSON_PAIR, 1) ||
+		    !dm_pool_grow_object(rh->mem, JSON_QUOTE, 1)) {
+			log_error("dm_report: Unable to extend output line");
+			return 0;
+		}
+	} else if (rh->flags & DM_REPORT_OUTPUT_FIELD_NAME_PREFIX) {
+		if (!(field_id = dm_strdup(fields[field->props->field_num].id))) {
+			log_error("dm_report: Failed to copy field name");
+			return 0;
+		}
+
+		if (!dm_pool_grow_object(rh->mem, rh->output_field_name_prefix, 0)) {
+			log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+			dm_free(field_id);
+			return 0;
+		}
+
+		if (!dm_pool_grow_object(rh->mem, _toupperstr(field_id), 0)) {
+			log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+			dm_free(field_id);
+			return 0;
+		}
+
+		dm_free(field_id);
+
+		if (!dm_pool_grow_object(rh->mem, STANDARD_PAIR, 1)) {
+			log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+			return 0;
+		}
+
+		if (!(rh->flags & DM_REPORT_OUTPUT_FIELD_UNQUOTED) &&
+		    !dm_pool_grow_object(rh->mem, STANDARD_QUOTE, 1)) {
+			log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+			return 0;
+		}
+	}
+
+	repstr = field->report_string;
+	width = field->props->width;
+	if (!(rh->flags & DM_REPORT_OUTPUT_ALIGNED)) {
+		if (_is_json_report(rh)) {
+			/* Escape any JSON_QUOTE that may appear in reported string. */
+			p1_repstr = repstr;
+			while ((p2_repstr = strstr(p1_repstr, JSON_QUOTE))) {
+				if (p2_repstr > p1_repstr) {
+					if (!dm_pool_grow_object(rh->mem, p1_repstr, p2_repstr - p1_repstr)) {
+						log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+						return 0;
+					}
+				}
+				if (!dm_pool_grow_object(rh->mem, JSON_ESCAPE_CHAR, 1) ||
+				    !dm_pool_grow_object(rh->mem, JSON_QUOTE, 1)) {
+					log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+					return 0;
+				}
+				p1_repstr = p2_repstr + 1;
+			}
+
+			if (!dm_pool_grow_object(rh->mem, p1_repstr, 0)) {
+				log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+				return 0;
+			}
+		} else {
+			if (!dm_pool_grow_object(rh->mem, repstr, 0)) {
+				log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+				return 0;
+			}
+		}
+	} else {
+		if (!(align = field->props->flags & DM_REPORT_FIELD_ALIGN_MASK))
+			align = ((field->props->flags & DM_REPORT_FIELD_TYPE_NUMBER) ||
+				 (field->props->flags & DM_REPORT_FIELD_TYPE_SIZE)) ? 
+				DM_REPORT_FIELD_ALIGN_RIGHT : DM_REPORT_FIELD_ALIGN_LEFT;
+
+		/* Including trailing '\0'! */
+		buf_size = width + 1;
+		if (!(buf = dm_malloc(buf_size))) {
+			log_error("dm_report: Could not allocate memory for output line buffer.");
+			return 0;
+		}
+
+		if (align & DM_REPORT_FIELD_ALIGN_LEFT) {
+			if (dm_snprintf(buf, buf_size, "%-*.*s",
+					 width, width, repstr) < 0) {
+				log_error("dm_report: left-aligned snprintf() failed");
+				goto bad;
+			}
+			if (!dm_pool_grow_object(rh->mem, buf, width)) {
+				log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+				goto bad;
+			}
+		} else if (align & DM_REPORT_FIELD_ALIGN_RIGHT) {
+			if (dm_snprintf(buf, buf_size, "%*.*s",
+					 width, width, repstr) < 0) {
+				log_error("dm_report: right-aligned snprintf() failed");
+				goto bad;
+			}
+			if (!dm_pool_grow_object(rh->mem, buf, width)) {
+				log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+				goto bad;
+			}
+		}
+	}
+
+	if (rh->flags & DM_REPORT_OUTPUT_FIELD_NAME_PREFIX) {
+		if (!(rh->flags & DM_REPORT_OUTPUT_FIELD_UNQUOTED)) {
+			if (!dm_pool_grow_object(rh->mem, STANDARD_QUOTE, 1)) {
+				log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+				goto bad;
+			}
+		}
+	} else if (_is_json_report(rh)) {
+		if (!dm_pool_grow_object(rh->mem, JSON_QUOTE, 1)) {
+			log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+			goto bad;
+		}
+	}
+
+	dm_free(buf);
+	return 1;
+
+bad:
+	dm_free(buf);
+	return 0;
+}
+
+static void _destroy_rows(struct dm_report *rh)
+{
+	/*
+	 * free the first row allocated to this report: since this is a
+	 * pool allocation this will also free all subsequently allocated
+	 * rows from the report and any associated string data.
+	 */
+	if (rh->first_row)
+		dm_pool_free(rh->mem, rh->first_row);
+	rh->first_row = NULL;
+	dm_list_init(&rh->rows);
+
+	/* Reset field widths to original values. */
+	_reset_field_props(rh);
+}
+
+static int _output_as_rows(struct dm_report *rh)
+{
+	const struct dm_report_field_type *fields;
+	struct field_properties *fp;
+	struct dm_report_field *field;
+	struct row *row;
+
+	dm_list_iterate_items(fp, &rh->field_props) {
+		if (fp->flags & FLD_HIDDEN) {
+			dm_list_iterate_items(row, &rh->rows) {
+				field = dm_list_item(dm_list_first(&row->fields), struct dm_report_field);
+				dm_list_del(&field->list);
+			}
+			continue;
+		}
+
+		fields = fp->implicit ? _implicit_report_fields : rh->fields;
+
+		if (!dm_pool_begin_object(rh->mem, 512)) {
+			log_error("dm_report: Unable to allocate output line");
+			return 0;
+		}
+
+		if ((rh->flags & DM_REPORT_OUTPUT_HEADINGS)) {
+			if (!dm_pool_grow_object(rh->mem, fields[fp->field_num].heading, 0)) {
+				log_error("dm_report: Failed to extend row for field name");
+				goto bad;
+			}
+			if (!dm_pool_grow_object(rh->mem, rh->separator, 0)) {
+				log_error("dm_report: Failed to extend row with separator");
+				goto bad;
+			}
+		}
+
+		dm_list_iterate_items(row, &rh->rows) {
+			if ((field = dm_list_item(dm_list_first(&row->fields), struct dm_report_field))) {
+				if (!_output_field(rh, field))
+					goto bad;
+				dm_list_del(&field->list);
+			}
+
+			if (!dm_list_end(&rh->rows, &row->list))
+				if (!dm_pool_grow_object(rh->mem, rh->separator, 0)) {
+					log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+					goto bad;
+				}
+		}
+
+		if (!dm_pool_grow_object(rh->mem, "\0", 1)) {
+			log_error("dm_report: Failed to terminate row");
+			goto bad;
+		}
+		log_print("%s", (char *) dm_pool_end_object(rh->mem));
+	}
+
+	_destroy_rows(rh);
+
+	return 1;
+
+      bad:
+	dm_pool_abandon_object(rh->mem);
+	return 0;
+}
+
+static int _output_as_columns(struct dm_report *rh)
+{
+	struct dm_list *fh, *rowh, *ftmp, *rtmp;
+	struct row *row = NULL;
+	struct dm_report_field *field;
+	struct dm_list *last_row;
+	int do_field_delim;
+	char *line;
+
+	/* If headings not printed yet, calculate field widths and print them */
+	if (!(rh->flags & RH_HEADINGS_PRINTED))
+		_report_headings(rh);
+
+	/* Print and clear buffer */
+	last_row = dm_list_last(&rh->rows);
+	dm_list_iterate_safe(rowh, rtmp, &rh->rows) {
+		row = dm_list_item(rowh, struct row);
+
+		if (!_should_display_row(row))
+			continue;
+
+		if (!dm_pool_begin_object(rh->mem, 512)) {
+			log_error("dm_report: Unable to allocate output line");
+			return 0;
+		}
+
+		if (_is_json_report(rh)) {
+			if (!dm_pool_grow_object(rh->mem, JSON_OBJECT_START, 0)) {
+				log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+				goto bad;
+			}
+		}
+
+		do_field_delim = 0;
+
+		dm_list_iterate_safe(fh, ftmp, &row->fields) {
+			field = dm_list_item(fh, struct dm_report_field);
+			if (field->props->flags & FLD_HIDDEN)
+				continue;
+
+			if (do_field_delim) {
+				if (_is_json_report(rh)) {
+					if (!dm_pool_grow_object(rh->mem, JSON_SEPARATOR, 0) ||
+					    !dm_pool_grow_object(rh->mem, JSON_SPACE, 0)) {
+						log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+						goto bad;
+					}
+				} else {
+					if (!dm_pool_grow_object(rh->mem, rh->separator, 0)) {
+						log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+						goto bad;
+					}
+				}
+			} else
+				do_field_delim = 1;
+
+			if (!_output_field(rh, field))
+				goto bad;
+
+			if (!(rh->flags & DM_REPORT_OUTPUT_MULTIPLE_TIMES))
+				dm_list_del(&field->list);
+		}
+
+		if (_is_json_report(rh)) {
+			if (!dm_pool_grow_object(rh->mem, JSON_OBJECT_END, 0)) {
+				log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+				goto bad;
+			}
+			if (rowh != last_row &&
+			    !dm_pool_grow_object(rh->mem, JSON_SEPARATOR, 0)) {
+				log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+				goto bad;
+			}
+		}
+
+		if (!dm_pool_grow_object(rh->mem, "\0", 1)) {
+			log_error("dm_report: Unable to terminate output line");
+			goto bad;
+		}
+
+		line = (char *) dm_pool_end_object(rh->mem);
+		log_print("%*s", rh->group_item ? rh->group_item->group->indent + (int) strlen(line) : 0, line);
+		if (!(rh->flags & DM_REPORT_OUTPUT_MULTIPLE_TIMES))
+			dm_list_del(&row->list);
+	}
+
+	if (!(rh->flags & DM_REPORT_OUTPUT_MULTIPLE_TIMES))
+		_destroy_rows(rh);
+
+	return 1;
+
+      bad:
+	dm_pool_abandon_object(rh->mem);
+	return 0;
+}
+
+int dm_report_is_empty(struct dm_report *rh)
+{
+	return dm_list_empty(&rh->rows) ? 1 : 0;
+}
+
+static struct report_group_item *_get_topmost_report_group_item(struct dm_report_group *group)
+{
+	struct report_group_item *item;
+
+	if (group && !dm_list_empty(&group->items))
+		item = dm_list_item(dm_list_first(&group->items), struct report_group_item);
+	else
+		item = NULL;
+
+	return item;
+}
+
+static void _json_output_start(struct dm_report_group *group)
+{
+	if (!group->indent) {
+		log_print(JSON_OBJECT_START);
+		group->indent += JSON_INDENT_UNIT;
+	}
+}
+
+static int _json_output_array_start(struct dm_pool *mem, struct report_group_item *item)
+{
+	const char *name = (const char *) item->data;
+	char *output;
+
+	if (!dm_pool_begin_object(mem, 32)) {
+		log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+		return 0;
+	}
+
+	if (!dm_pool_grow_object(mem, JSON_QUOTE, 1) ||
+	    !dm_pool_grow_object(mem, name, 0) ||
+	    !dm_pool_grow_object(mem, JSON_QUOTE JSON_PAIR JSON_SPACE JSON_ARRAY_START, 0) ||
+	    !dm_pool_grow_object(mem, "\0", 1) ||
+	    !(output = dm_pool_end_object(mem))) {
+		log_error(UNABLE_TO_EXTEND_OUTPUT_LINE_MSG);
+		goto bad;
+	}
+
+	if (item->parent->store.finished_count > 0)
+		log_print("%*s", item->group->indent + (int) sizeof(JSON_SEPARATOR) - 1, JSON_SEPARATOR);
+
+	if (item->parent->parent && item->parent->data) {
+		log_print("%*s", item->group->indent + (int) sizeof(JSON_OBJECT_START) - 1, JSON_OBJECT_START);
+		item->group->indent += JSON_INDENT_UNIT;
+	}
+
+	log_print("%*s", item->group->indent + (int) strlen(output), output);
+	item->group->indent += JSON_INDENT_UNIT;
+
+	dm_pool_free(mem, output);
+	return 1;
+bad:
+	dm_pool_abandon_object(mem);
+	return 0;
+}
+
+static int _prepare_json_report_output(struct dm_report *rh)
+{
+	_json_output_start(rh->group_item->group);
+
+	if (rh->group_item->output_done && dm_list_empty(&rh->rows))
+		return 1;
+
+	/*
+	 * If this report is in JSON group, it must be at the
+	 * top of the stack of reports so the output from
+	 * different reports do not interleave with each other.
+	 */
+	if (_get_topmost_report_group_item(rh->group_item->group) != rh->group_item) {
+		log_error("dm_report: dm_report_output: interleaved reports detected for JSON output");
+		return 0;
+	}
+
+	if (rh->group_item->needs_closing) {
+		log_error("dm_report: dm_report_output: unfinished JSON output detected");
+		return 0;
+	}
+
+	if (!_json_output_array_start(rh->mem, rh->group_item))
+		return_0;
+
+	rh->group_item->needs_closing = 1;
+	return 1;
+}
+
+static int _print_basic_report_header(struct dm_report *rh)
+{
+	const char *report_name = (const char *) rh->group_item->data;
+	size_t len = strlen(report_name);
+	char *underline;
+
+	if (!(underline = dm_pool_zalloc(rh->mem, len + 1)))
+		return_0;
+
+	memset(underline, '=', len);
+
+	if (rh->group_item->parent->store.finished_count > 0)
+		log_print("%s", "");
+	log_print("%s", report_name);
+	log_print("%s", underline);
+
+	dm_pool_free(rh->mem, underline);
+	return 1;
+}
+
+int dm_report_output(struct dm_report *rh)
+{
+	int r = 0;
+
+	if (_is_json_report(rh) &&
+	    !_prepare_json_report_output(rh))
+		return_0;
+
+	if (dm_list_empty(&rh->rows)) {
+		r = 1;
+		goto out;
+	}
+
+	if (rh->flags & RH_FIELD_CALC_NEEDED)
+		_recalculate_fields(rh);
+
+	if ((rh->flags & RH_SORT_REQUIRED))
+		_sort_rows(rh);
+
+	if (_is_basic_report(rh) && !_print_basic_report_header(rh))
+		goto_out;
+
+	if ((rh->flags & DM_REPORT_OUTPUT_COLUMNS_AS_ROWS))
+		r = _output_as_rows(rh);
+	else
+		r = _output_as_columns(rh);
+out:
+	if (r && rh->group_item)
+		rh->group_item->output_done = 1;
+	return r;
+}
+
+void dm_report_destroy_rows(struct dm_report *rh)
+{
+	_destroy_rows(rh);
+}
+
+struct dm_report_group *dm_report_group_create(dm_report_group_type_t type, void *data)
+{
+	struct dm_report_group *group;
+	struct dm_pool *mem;
+	struct report_group_item *item;
+
+	if (!(mem = dm_pool_create("report_group", 1024))) {
+		log_error("dm_report: dm_report_init_group: failed to allocate mem pool");
+		return NULL;
+	}
+
+	if (!(group = dm_pool_zalloc(mem, sizeof(*group)))) {
+		log_error("dm_report: failed to allocate report group structure");
+		goto bad;
+	}
+
+	group->mem = mem;
+	group->type = type;
+	dm_list_init(&group->items);
+
+	if (!(item = dm_pool_zalloc(mem, sizeof(*item)))) {
+		log_error("dm_report: faile to allocate root report group item");
+		goto bad;
+	}
+
+	dm_list_add_h(&group->items, &item->list);
+
+	return group;
+bad:
+	dm_pool_destroy(mem);
+	return NULL;
+}
+
+static int _report_group_push_single(struct report_group_item *item, void *data)
+{
+	struct report_group_item *item_iter;
+	unsigned count = 0;
+
+	dm_list_iterate_items(item_iter, &item->group->items) {
+		if (item_iter->report)
+			count++;
+	}
+
+	if (count > 1) {
+		log_error("dm_report: unable to add more than one report "
+			  "to current report group");
+		return 0;
+	}
+
+	return 1;
+}
+
+static int _report_group_push_basic(struct report_group_item *item, const char *name)
+{
+	if (item->report) {
+		if (!(item->report->flags & DM_REPORT_OUTPUT_BUFFERED))
+			item->report->flags &= ~(DM_REPORT_OUTPUT_MULTIPLE_TIMES);
+	} else {
+		if (!name && item->parent->store.finished_count > 0)
+			log_print("%s", "");
+	}
+
+	return 1;
+}
+
+static int _report_group_push_json(struct report_group_item *item, const char *name)
+{
+	if (name && !(item->data = dm_pool_strdup(item->group->mem, name))) {
+		log_error("dm_report: failed to duplicate json item name");
+		return 0;
+	}
+
+	if (item->report) {
+		item->report->flags &= ~(DM_REPORT_OUTPUT_ALIGNED |
+					 DM_REPORT_OUTPUT_HEADINGS |
+					 DM_REPORT_OUTPUT_COLUMNS_AS_ROWS);
+		item->report->flags |= DM_REPORT_OUTPUT_BUFFERED;
+	} else {
+		_json_output_start(item->group);
+		if (name) {
+			if (!_json_output_array_start(item->group->mem, item))
+				return_0;
+		} else {
+			if (!item->parent->parent) {
+				log_error("dm_report: can't use unnamed object at top level of JSON output");
+				return 0;
+			}
+			if (item->parent->store.finished_count > 0)
+				log_print("%*s", item->group->indent + (int) sizeof(JSON_SEPARATOR) - 1, JSON_SEPARATOR);
+			log_print("%*s", item->group->indent + (int) sizeof(JSON_OBJECT_START) - 1, JSON_OBJECT_START);
+			item->group->indent += JSON_INDENT_UNIT;
+		}
+
+		item->output_done = 1;
+		item->needs_closing = 1;
+	}
+
+	return 1;
+}
+
+int dm_report_group_push(struct dm_report_group *group, struct dm_report *report, void *data)
+{
+	struct report_group_item *item, *tmp_item;
+
+	if (!group)
+		return 1;
+
+	if (!(item = dm_pool_zalloc(group->mem, sizeof(*item)))) {
+		log_error("dm_report: dm_report_group_push: group item allocation failed");
+		return 0;
+	}
+
+	if ((item->report = report)) {
+		item->store.orig_report_flags = report->flags;
+		report->group_item = item;
+	}
+
+	item->group = group;
+	item->data = data;
+
+	dm_list_iterate_items(tmp_item, &group->items) {
+		if (!tmp_item->report) {
+			item->parent = tmp_item;
+			break;
+		}
+	}
+
+	dm_list_add_h(&group->items, &item->list);
+
+	switch (group->type) {
+		case DM_REPORT_GROUP_SINGLE:
+			if (!_report_group_push_single(item, data))
+				goto_bad;
+			break;
+		case DM_REPORT_GROUP_BASIC:
+			if (!_report_group_push_basic(item, data))
+				goto_bad;
+			break;
+		case DM_REPORT_GROUP_JSON:
+			if (!_report_group_push_json(item, data))
+				goto_bad;
+			break;
+		default:
+			goto_bad;
+	}
+
+	return 1;
+bad:
+	dm_list_del(&item->list);
+	dm_pool_free(group->mem, item);
+	return 0;
+}
+
+static int _report_group_pop_single(struct report_group_item *item)
+{
+	return 1;
+}
+
+static int _report_group_pop_basic(struct report_group_item *item)
+{
+	return 1;
+}
+
+static int _report_group_pop_json(struct report_group_item *item)
+{
+	if (item->output_done && item->needs_closing) {
+		if (item->data) {
+			item->group->indent -= JSON_INDENT_UNIT;
+			log_print("%*s", item->group->indent + (int) sizeof(JSON_ARRAY_END) - 1, JSON_ARRAY_END);
+		}
+		if (item->parent->data && item->parent->parent) {
+			item->group->indent -= JSON_INDENT_UNIT;
+			log_print("%*s", item->group->indent + (int) sizeof(JSON_OBJECT_END) - 1, JSON_OBJECT_END);
+		}
+		item->needs_closing = 0;
+	}
+
+	return 1;
+}
+
+int dm_report_group_pop(struct dm_report_group *group)
+{
+	struct report_group_item *item;
+
+	if (!group)
+		return 1;
+
+	if (!(item = _get_topmost_report_group_item(group))) {
+		log_error("dm_report: dm_report_group_pop: group has no items");
+		return 0;
+	}
+
+	switch (group->type) {
+		case DM_REPORT_GROUP_SINGLE:
+			if (!_report_group_pop_single(item))
+				return_0;
+			break;
+		case DM_REPORT_GROUP_BASIC:
+			if (!_report_group_pop_basic(item))
+				return_0;
+			break;
+		case DM_REPORT_GROUP_JSON:
+			if (!_report_group_pop_json(item))
+				return_0;
+			break;
+		default:
+			return 0;
+        }
+
+	dm_list_del(&item->list);
+
+	if (item->report) {
+		item->report->flags = item->store.orig_report_flags;
+		item->report->group_item = NULL;
+	}
+
+	if (item->parent)
+		item->parent->store.finished_count++;
+
+	dm_pool_free(group->mem, item);
+	return 1;
+}
+
+int dm_report_group_output_and_pop_all(struct dm_report_group *group)
+{
+	struct report_group_item *item, *tmp_item;
+
+	dm_list_iterate_items_safe(item, tmp_item, &group->items) {
+		if (!item->parent) {
+			item->store.finished_count = 0;
+			continue;
+		}
+		if (item->report && !dm_report_output(item->report))
+			return_0;
+		if (!dm_report_group_pop(group))
+			return_0;
+	}
+
+	if (group->type == DM_REPORT_GROUP_JSON) {
+		_json_output_start(group);
+		log_print(JSON_OBJECT_END);
+		group->indent -= JSON_INDENT_UNIT;
+	}
+
+	return 1;
+}
+
+int dm_report_group_destroy(struct dm_report_group *group)
+{
+	int r = 1;
+
+	if (!group)
+		return 1;
+
+	if (!dm_report_group_output_and_pop_all(group))
+		r = 0;
+
+	dm_pool_destroy(group->mem);
+	return r;
+}