libdevmapper: (0/6) Filtering feature in dm_report

Index: device-mapper.work/lib/libdm-report.c
===================================================================
@@ -296,35 +296,62 @@ static int _copy_field(struct dm_report 
 	return 1;
 }
 
-static int _field_match(struct dm_report *rh, const char *field, size_t flen)
+static struct field_properties * _add_field(struct dm_report *rh,
+					    uint32_t field_num, uint32_t flags)
 {
-	uint32_t f, l;
 	struct field_properties *fp;
 
+	rh->report_types |= rh->fields[field_num].type;
+	if (!(fp = dm_pool_zalloc(rh->mem, sizeof(struct field_properties)))) {
+		log_error("dm_report: "
+			  "struct field_properties allocation failed");
+		return NULL;
+	}
+	if (!_copy_field(rh, fp, field_num)) {
+		dm_pool_free(rh->mem, fp);
+		return NULL;
+	}
+
+	/* Add additional flags */
+	fp->flags |= flags;
+
+	list_add(&rh->field_props, &fp->list);
+	return fp;
+}
+
+/*
+ * compare name1 and name2 (or prefix+name2)
+ *   name2 is not \0 terminated. len is the length of name2.
+ */
+static int _is_same_field(const char *name1, const char *name2,
+                         size_t len, const char *prefix)
+{
+	size_t l;
+
+	/* name1 == name2 */
+	if (!strncasecmp(name1, name2, len) && strlen(name1) == len)
+		return 1;
+
+	/* name1 == name2 */
+	l = strlen(prefix);
+	if (!strncasecmp(prefix, name1, l) &&
+	    !strncasecmp(name1 + l, name2, len) && strlen(name1) == l + len)
+		return 1;
+
+	return 0;
+}
+
+static int _field_match(struct dm_report *rh, const char *field, size_t flen)
+{
+	uint32_t f;
+
 	if (!flen)
 		return 0;
 
-	for (f = 0; rh->fields[f].report_fn; f++) {
-		if ((!strncasecmp(rh->fields[f].id, field, flen) &&
-		     strlen(rh->fields[f].id) == flen) ||
-		    (l = strlen(rh->field_prefix),
-		     !strncasecmp(rh->field_prefix, rh->fields[f].id, l) &&
-		     !strncasecmp(rh->fields[f].id + l, field, flen) &&
-		     strlen(rh->fields[f].id) == l + flen)) {
-			rh->report_types |= rh->fields[f].type;
-			if (!(fp = dm_pool_zalloc(rh->mem, sizeof(*fp)))) {
-				log_error("dm_report: "
-					  "struct field_properties allocation "
-					  "failed");
-				return 0;
-			}
-			if (!_copy_field(rh, fp, f))
-				return 0;
-
-			list_add(&rh->field_props, &fp->list);
-			return 1;
-		}
-	}
+	for (f = 0; rh->fields[f].report_fn; f++)
+		if (_is_same_field(rh->fields[f].id,
+				   field, flen, rh->field_prefix))
+			return (_add_field(rh, f, 0) != NULL);
 
 	return 0;
 }

@@ -342,19 +369,9 @@ static int _add_sort_key(struct dm_repor
 	}
 
 	if (!found) {
-		rh->report_types |= rh->fields[field_num].type;
-		if (!(found = dm_pool_zalloc(rh->mem, sizeof(*found)))) {
-			log_error("dm_report: "
-				  "struct field_properties allocation failed");
-			return 0;
-		}
-		if (!_copy_field(rh, found, field_num))
-			return 0;
-
 		/* Add as a non-display field */
-		found->flags |= FLD_HIDDEN;
-
-		list_add(&rh->field_props, &found->list);
+		if (!(found = _add_field(rh, field_num, FLD_HIDDEN)))
+			return 0;
 	}
 
 	if (found->flags & FLD_SORT_KEY) {

@@ -372,7 +389,7 @@ static int _add_sort_key(struct dm_repor
 
 static int _key_match(struct dm_report *rh, const char *key, size_t len)
 {
-	uint32_t f, l;
+	uint32_t f;
 	uint32_t flags;
 
 	if (!len)

@@ -394,16 +411,10 @@ static int _key_match(struct dm_report *
 		return 0;
 	}
 
-	for (f = 0; rh->fields[f].report_fn; f++) {
-		if ((!strncasecmp(rh->fields[f].id, key, len) &&
-		     strlen(rh->fields[f].id) == len) ||
-		    (l = strlen(rh->field_prefix),
-		     !strncasecmp(rh->field_prefix, rh->fields[f].id, l) &&
-		     !strncasecmp(rh->fields[f].id + l, key, len) &&
-		     strlen(rh->fields[f].id) == l + len)) {
+	for (f = 0; rh->fields[f].report_fn; f++)
+		if (_is_same_field(rh->fields[f].id,
+				   key, len, rh->field_prefix))
 			return _add_sort_key(rh, f, flags);
-		}
-	}
 
 	return 0;
 }

Index: device-mapper.work/lib/libdm-report.c
===================================================================
@@ -315,7 +315,12 @@ static struct field_properties * _add_fi
 	/* Add additional flags */
 	fp->flags |= flags;
 
-	list_add(&rh->field_props, &fp->list);
+	/* Hidden field must come first, otherwise list_end() doesn't work
+	   as expected */
+	if (fp->flags & FLD_HIDDEN)
+		list_add_h(&rh->field_props, &fp->list);
+	else
+		list_add(&rh->field_props, &fp->list);
 	return fp;
 }
 

Index: device-mapper.work/lib/libdevmapper.h
===================================================================
@@ -711,4 +711,11 @@ int dm_report_field_uint64(struct dm_rep
 void dm_report_field_set_value(struct dm_report_field *field, const void *value,
 			       const void *sortvalue);
 
+/*
+ * dm_regex
+ */
+struct dm_regex;
+struct dm_regex *dm_regex_create(struct dm_pool *mem, const char **patterns,
+				 unsigned num);
+int dm_regex_match(struct dm_regex *regex, const char *s);
 #endif				/* LIB_DEVICE_MAPPER_H */

366 lines not on this page · raw message

360 lines not on this page · raw message

52 lines not on this page · raw message

117 lines not on this page · raw message

Index: device-mapper.work/lib/regex/ttree.h
===================================================================
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004 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 General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LVM_TTREE_H
+#define _LVM_TTREE_H
+
+struct ttree;
+
+struct ttree *ttree_create(struct dm_pool *mem, unsigned int klen);
+
+void *ttree_lookup(struct ttree *tt, unsigned *key);
+int ttree_insert(struct ttree *tt, unsigned *key, void *data);
+
+#endif

Index: device-mapper.work/lib/libdevmapper.h
===================================================================
@@ -688,6 +688,10 @@ int dm_report_object(struct dm_report *r
 int dm_report_output(struct dm_report *rh);
 void dm_report_free(struct dm_report *rh);
 
+/* Set filter */
+int dm_report_set_filter(struct dm_report *rh,
+			 const char *filter, uint32_t flags);
+
 /*
  * Report functions are provided for simple data types.
  * They take care of allocating copies of the data.

864 lines not on this page · raw message

Index: device-mapper.work/dmsetup/dmsetup.c
===================================================================
@@ -104,6 +104,7 @@ enum {
 	COLS_ARG,
 	EXEC_ARG,
 	FORCE_ARG,
+	FILTER_ARG,
 	GID_ARG,
 	MAJOR_ARG,
 	MINOR_ARG,

@@ -1650,6 +1651,13 @@ static int _report_init(struct command *
 					options, separator, flags, keys, NULL)))
 		goto out;
 
+	if (_string_args[FILTER_ARG] &&
+	    !dm_report_set_filter(_report, _string_args[FILTER_ARG], 0)) {
+		dm_report_free(_report);
+		_report = NULL;
+		goto out;
+	}
+
 	r = 1;
 
 out:

@@ -2059,6 +2067,7 @@ static int _process_switches(int *argc, 
 		{"columns", 0, &ind, COLS_ARG},
 		{"exec", 1, &ind, EXEC_ARG},
 		{"force", 0, &ind, FORCE_ARG},
+		{"filter", 1, &ind, FILTER_ARG},
 		{"gid", 1, &ind, GID_ARG},
 		{"major", 1, &ind, MAJOR_ARG},
 		{"minor", 1, &ind, MINOR_ARG},

@@ -2133,7 +2142,7 @@ static int _process_switches(int *argc, 
 
 	optarg = 0;
 	optind = OPTIND_INIT;
-	while ((ind = -1, c = GETOPTLONG_FN(*argc, *argv, "cCfGj:m:Mno:O:ru:Uv",
+	while ((ind = -1, c = GETOPTLONG_FN(*argc, *argv, "cCfF:Gj:m:Mno:O:ru:Uv",
 					    long_options, NULL)) != -1) {
 		if (c == ':' || c == '?')
 			return 0;

@@ -2141,6 +2150,10 @@ static int _process_switches(int *argc, 
 			_switches[COLS_ARG]++;
 		if (c == 'f' || ind == FORCE_ARG)
 			_switches[FORCE_ARG]++;
+		if (c == 'F' || ind == FILTER_ARG) {
+			_switches[FILTER_ARG]++;
+			_string_args[FILTER_ARG] = optarg;
+		}
 		if (c == 'r' || ind == READ_ONLY)
 			_switches[READ_ONLY]++;
 		if (c == 'j' || ind == MAJOR_ARG) {

Index: device-mapper.work/dmsetup/dmsetup.c
===================================================================
@@ -241,11 +241,14 @@ static int _parse_file(struct dm_task *d
 struct dmsetup_report_obj {
 	struct dm_task *task;
 	struct dm_info *info;
+	struct dm_task *deps;
+	struct dm_tree_node *tree;
 };
 
 static int _display_info_cols(struct dm_task *dmt, struct dm_info *info)
 {
 	struct dmsetup_report_obj obj;
+	int r = 0;
 
 	if (!info->exists) {
 		fprintf(stderr, "Device does not exist.\n");

@@ -254,11 +257,18 @@ static int _display_info_cols(struct dm_
 
 	obj.task = dmt;
 	obj.info = info;
+	obj.deps = NULL; /* task is created later on demand */
+	obj.tree = NULL; /* deptree is created later on demand */
 
 	if (!dm_report_object(_report, &obj))
-		return 0;
+		goto out;
 
-	return 1;
+	r = 1;
+
+      out:
+	if (obj.deps)
+		dm_task_destroy(obj.deps);
+	return r;
 }
 
 static void _display_info_long(struct dm_task *dmt, struct dm_info *info)

@@ -1457,17 +1467,26 @@ static int _add_dep(int argc __attribute
 /*
  * Create and walk dependency tree
  */
-static int _tree(int argc, char **argv, void *data __attribute((unused)))
+static int _build_whole_deptree(void)
 {
+	if (_dtree)
+		return 1;
+
 	if (!(_dtree = dm_tree_create()))
 		return 0;
 
-	if (!_process_all(argc, argv, 0, _add_dep))
+	if (!_process_all(0, NULL, 0, _add_dep))
 		return 0;
 
-	_tree_walk_children(dm_tree_find_node(_dtree, 0, 0), 0);
+	return 1;
+}
+
+static int _tree(int argc, char **argv, void *data __attribute((unused)))
+{
+	if (!_build_whole_deptree())
+		return 0;
 
-	dm_tree_free(_dtree);
+	_tree_walk_children(dm_tree_find_node(_dtree, 0, 0), 0);
 
 	return 1;
 }

@@ -1539,8 +1558,193 @@ static int _dm_info_status_disp(struct d
 	return dm_report_field_string(rh, field, &s);
 }
 
+#define MAJ_MIN_LEN 32
+
+static int _dm_info_device_disp(struct dm_report *rh, struct dm_pool *mem,
+				struct dm_report_field *field, const void *data,
+				void *private)
+{
+	char buf[MAJ_MIN_LEN], *repstr;
+	struct dm_info *info = (struct dm_info *) data;
+
+	if (!dm_pool_begin_object(mem, 8)) {
+		log_error("dm_pool_begin_object failed");
+		return 0;
+	}
+
+	if (dm_snprintf(buf, sizeof(buf), "%d:%d",
+			info->major, info->minor) < 0) {
+		log_error("dm_pool_alloc failed");
+		goto out_abandon;
+	}
+
+	if (!dm_pool_grow_object(mem, buf, strlen(buf))) {
+		log_error("dm_pool_grow_object failed");
+		goto out_abandon;
+	}
+
+	repstr = dm_pool_end_object(mem);
+	dm_report_field_set_value(field, repstr, repstr);
+	return 1;
+
+      out_abandon:
+	dm_pool_abandon_object(mem);
+	return 0;
+}
+
+static int _dm_tree_parent_maps_disp(struct dm_report *rh,
+				     struct dm_pool *mem,
+				     struct dm_report_field *field,
+				     const void *data, void *private)
+{
+	struct dm_tree_node *node = (struct dm_tree_node *) data, *parent;
+	void *t = NULL;
+	const char *name;
+	int first_node = 1;
+	char *repstr;
+
+	if (!dm_pool_begin_object(mem, 16)) {
+		log_error("dm_pool_begin_object failed");
+		return 0;
+	}
+
+	while ((parent = dm_tree_next_child(&t, node, 1))) {
+		name = dm_tree_node_get_name(parent);
+		if (!name || !*name)
+			continue;
+		if (!first_node && !dm_pool_grow_object(mem, ",", 1)) {
+			log_error("dm_pool_grow_object failed");
+			goto out_abandon;
+		}
+		if (!dm_pool_grow_object(mem, name, strlen(name))) {
+			log_error("dm_pool_grow_object failed");
+			goto out_abandon;
+		}
+		if (first_node)
+			first_node = 0;
+	}
+
+	if (!dm_pool_grow_object(mem, "\0", 1)) {
+		log_error("dm_pool_grow_object failed");
+		goto out_abandon;
+	}
+
+	repstr = dm_pool_end_object(mem);
+	dm_report_field_set_value(field, repstr, repstr);
+	return 1;
+
+      out_abandon:
+	dm_pool_abandon_object(mem);
+	return 0;
+}
+
+static int _dm_tree_parents_disp(struct dm_report *rh, struct dm_pool *mem,
+				 struct dm_report_field *field,
+				 const void *data, void *private)
+{
+	struct dm_tree_node *node = (struct dm_tree_node *) data, *parent;
+	void *t = NULL;
+	const struct dm_info *info;
+	int first_node = 1;
+	char buf[MAJ_MIN_LEN], *repstr;
+
+	if (!dm_pool_begin_object(mem, 16)) {
+		log_error("dm_pool_begin_object failed");
+		return 0;
+	}
+
+	while ((parent = dm_tree_next_child(&t, node, 1))) {
+		info = dm_tree_node_get_info(parent);
+		if (!info->major && !info->minor)
+			continue;
+		if (!first_node && !dm_pool_grow_object(mem, ",", 1)) {
+			log_error("dm_pool_grow_object failed");
+			goto out_abandon;
+		}
+		if (dm_snprintf(buf, sizeof(buf), "%d:%d",
+				info->major, info->minor) < 0) {
+			log_error("dm_snprintf failed");
+			goto out_abandon;
+		}
+		if (!dm_pool_grow_object(mem, buf, strlen(buf))) {
+			log_error("dm_pool_grow_object failed");
+			goto out_abandon;
+		}
+		if (first_node)
+			first_node = 0;
+	}
+
+	if (!dm_pool_grow_object(mem, "\0", 1)) {
+		log_error("dm_pool_grow_object failed");
+		goto out_abandon;
+	}
+
+	repstr = dm_pool_end_object(mem);
+	dm_report_field_set_value(field, repstr, repstr);
+	return 1;
+
+      out_abandon:
+	dm_pool_abandon_object(mem);
+	return 0;
+}
+
+static int _dm_tree_parents_count_disp(struct dm_report *rh,
+				       struct dm_pool *mem,
+				       struct dm_report_field *field,
+				       const void *data, void *private)
+{
+	struct dm_tree_node *node = (struct dm_tree_node *) data;
+	int num_parent = dm_tree_node_num_children(node, 1);
+
+	return dm_report_field_int(rh, field, &num_parent);
+}
+
+static int _dm_deps_disp(struct dm_report *rh, struct dm_pool *mem,
+			 struct dm_report_field *field, const void *data,
+			 void *private)
+{
+	struct dm_deps *deps = (struct dm_deps *) data;
+	int i;
+	char buf[MAJ_MIN_LEN], *repstr;
+
+	if (!dm_pool_begin_object(mem, 16)) {
+		log_error("dm_pool_begin_object failed");
+		return 0;
+	}
+
+	for (i = 0; i < deps->count; i++) {
+		if (dm_snprintf(buf, sizeof(buf), "%d:%d",
+		       (int) MAJOR(deps->device[i]),
+		       (int) MINOR(deps->device[i])) < 0) {
+			log_error("dm_snprintf failed");
+			goto out_abandon;
+		}
+		if (!dm_pool_grow_object(mem, buf, strlen(buf))) {
+			log_error("dm_pool_grow_object failed");
+			goto out_abandon;
+		}
+		if (i + 1 < deps->count && !dm_pool_grow_object(mem, ",", 1)) {
+			log_error("dm_pool_grow_object failed");
+			goto out_abandon;
+		}
+	}
+
+	if (!dm_pool_grow_object(mem, "\0", 1)) {
+		log_error("dm_pool_grow_object failed");
+		goto out_abandon;
+	}
+
+	repstr = dm_pool_end_object(mem);
+	dm_report_field_set_value(field, repstr, repstr);
+	return 1;
+
+      out_abandon:
+	dm_pool_abandon_object(mem);
+	return 0;
+}
+
 /* Report types */
-enum { DR_TASK = 1, DR_INFO = 2 };
+enum { DR_TASK = 1, DR_INFO = 2, DR_DEPS = 4, DR_TREE = 8 };
 
 static void *_task_get_obj(void *obj)
 {

@@ -1552,9 +1756,65 @@ static void *_info_get_obj(void *obj)
 	return ((struct dmsetup_report_obj *)obj)->info;
 }
 
+static void *_tree_get_obj(void *obj)
+{
+	struct dmsetup_report_obj *o = (struct dmsetup_report_obj *) obj;
+	struct dm_info *info;
+
+	if (o->tree)
+		return o->tree;
+
+	if (!_build_whole_deptree())
+		return NULL;
+
+	if (!(info = _info_get_obj(o)))
+		return NULL;
+
+	o->tree = dm_tree_find_node(_dtree, info->major, info->minor);
+	return o->tree;
+}
+
+static void *_deps_get_obj(void *obj)
+{
+	struct dmsetup_report_obj *o = (struct dmsetup_report_obj *) obj;
+	struct dm_task *dmt;
+	const char *name;
+
+	if (o->deps)
+		return dm_task_get_deps(o->deps);
+
+	/* name */
+	if (!(dmt = _task_get_obj(o)))
+		return NULL;
+	if (!(name = dm_task_get_name(dmt)))
+		return NULL;
+
+	/* deps */
+	if (!(dmt = dm_task_create(DM_DEVICE_DEPS)))
+		return NULL;
+
+	if (!dm_task_set_name(dmt, name))
+		goto out;
+
+	if (_switches[NOOPENCOUNT_ARG] && !dm_task_no_open_count(dmt))
+		goto out;
+
+	if (!dm_task_run(dmt))
+		goto out;
+
+	o->deps = dmt;
+	return dm_task_get_deps(dmt);
+
+      out:
+	dm_task_destroy(dmt);
+	return NULL;
+}
+
 static const struct dm_report_object_type _report_types[] = {
 	{ DR_TASK, "Mapped Device Name", "", _task_get_obj },
 	{ DR_INFO, "Mapped Device Information", "", _info_get_obj },
+	{ DR_DEPS, "Mapped Device Dependency", "", _deps_get_obj },
+	{ DR_TREE, "Mapped Device Dependency", "", _tree_get_obj },
 	{ 0, "", "", NULL },
 };
 

@@ -1570,11 +1830,17 @@ static const struct dm_report_field_type
 FIELD_F(TASK, STR, "Name", 16, dm_name, "name", "Name of mapped device.")
 FIELD_F(TASK, STR, "UUID", 32, dm_uuid, "uuid", "Unique (optional) identifier for mapped device.")
 FIELD_F(INFO, STR, "Stat", 4, dm_info_status, "attr", "(L)ive, (I)nactive, (s)uspended, (r)ead-only, read-(w)rite.")
+FIELD_F(INFO, STR, "Device", 6, dm_info_device, "device", "Device major and minor numbers")
 FIELD_O(INFO, dm_info, NUM, "Maj", major, 3, int32, "major", "Block device major number.")
 FIELD_O(INFO, dm_info, NUM, "Min", minor, 3, int32, "minor", "Block device minor number.")
 FIELD_O(INFO, dm_info, NUM, "Open", open_count, 4, int32, "open", "Number of references to open device, if requested.")
 FIELD_O(INFO, dm_info, NUM, "Targ", target_count, 4, int32, "segments", "Number of segments in live table, if present.")
 FIELD_O(INFO, dm_info, NUM, "Event", event_nr, 6, uint32, "events", "Number of most recent event.")
+FIELD_O(DEPS, dm_deps, NUM, "Deps", count, 4, int32, "deps_count", "Number of underlying devices")
+FIELD_F(DEPS, STR, "Depend on", 10, dm_deps, "deps", "List of underlying devic es")
+FIELD_F(TREE, STR, "Parent Devices", 16, dm_tree_parents, "parents", "List of overlaying devices")
+FIELD_F(TREE, STR, "Parent Maps", 12, dm_tree_parent_maps, "parent_maps", "List of overlaying maps")
+FIELD_F(TREE, NUM, "Parents", 7, dm_tree_parents_count, "parents_count", "Number of overlaying devices")
 {0, 0, 0, 0, "", "", NULL, NULL},
 /* *INDENT-ON* */
 };

@@ -2300,5 +2566,8 @@ out:
 		dm_report_free(_report);
 	}
 
+	if (_dtree)
+		dm_tree_free(_dtree);
+
 	return r;
 }

Index: device-mapper.work/lib/libdm-report.c
===================================================================
@@ -88,6 +88,11 @@ struct row {
 	struct dm_report_field *(*sort_fields)[]; /* Fields in sort order */
 };
 
+uint32_t dm_report_get_report_types(struct dm_report *rh)
+{
+	return rh->report_types;
+}
+
 static const struct dm_report_object_type *_find_type(struct dm_report *rh,
 						      uint32_t report_type)
 {

Index: device-mapper.work/lib/libdevmapper.h
===================================================================
@@ -687,6 +687,7 @@ struct dm_report *dm_report_init(uint32_
 int dm_report_object(struct dm_report *rh, void *object);
 int dm_report_output(struct dm_report *rh);
 void dm_report_free(struct dm_report *rh);
+uint32_t dm_report_get_report_types(struct dm_report *rh);
 
 /* Set filter */
 int dm_report_set_filter(struct dm_report *rh,

Index: device-mapper.work/dmsetup/dmsetup.c
===================================================================
@@ -1924,6 +1924,7 @@ static int _report_init(struct command *
 		goto out;
 	}
 
+	report_type = dm_report_get_report_types(_report);
 	r = 1;
 
 out: