add TAG= to improve event filtering and device enumeration

16 files changed, 595 insertions, 184 deletions

diff --git a/Makefile.am b/Makefile.am
index 7403949cf3..9d3fefd702 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -28,9 +28,9 @@ CLEANFILES =
 # ------------------------------------------------------------------------------
 # libudev
 # ------------------------------------------------------------------------------
-LIBUDEV_CURRENT=7
+LIBUDEV_CURRENT=8
 LIBUDEV_REVISION=0
-LIBUDEV_AGE=7
+LIBUDEV_AGE=8
 
 SUBDIRS += libudev/docs
 
diff --git a/libudev/docs/libudev-sections.txt b/libudev/docs/libudev-sections.txt
index ca781fff23..3f8c107a1f 100644
--- a/libudev/docs/libudev-sections.txt
+++ b/libudev/docs/libudev-sections.txt
@@ -68,6 +68,7 @@ udev_monitor_enable_receiving
 udev_monitor_get_fd
 udev_monitor_receive_device
 udev_monitor_filter_add_match_subsystem_devtype
+udev_monitor_filter_add_match_tag
 udev_monitor_filter_update
 udev_monitor_filter_remove
 </SECTION>
@@ -85,6 +86,7 @@ udev_enumerate_add_nomatch_subsystem
 udev_enumerate_add_match_sysattr
 udev_enumerate_add_nomatch_sysattr
 udev_enumerate_add_match_property
+udev_enumerate_add_match_tag
 udev_enumerate_add_match_sysname
 udev_enumerate_add_syspath
 udev_enumerate_scan_devices
diff --git a/libudev/exported_symbols b/libudev/exported_symbols
index 61486c6f48..c0ca4b9c6d 100644
--- a/libudev/exported_symbols
+++ b/libudev/exported_symbols
@@ -60,6 +60,7 @@ udev_monitor_get_udev
 udev_monitor_get_fd
 udev_monitor_receive_device
 udev_monitor_filter_add_match_subsystem_devtype
+udev_monitor_filter_add_match_tag
 udev_monitor_filter_update
 udev_monitor_filter_remove
 udev_queue_new
diff --git a/libudev/libudev-device-private.c b/libudev/libudev-device-private.c
index 5e4381ec27..13f1ebf883 100644
--- a/libudev/libudev-device-private.c
+++ b/libudev/libudev-device-private.c
@@ -1,7 +1,7 @@
 /*
  * libudev - interface to udev device information
  *
- * Copyright (C) 2008 Kay Sievers <kay.sievers@vrfy.org>
+ * Copyright (C) 2008-2010 Kay Sievers <kay.sievers@vrfy.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -13,6 +13,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <stddef.h>
+#include <stdbool.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <string.h>
@@ -21,6 +22,37 @@
 #include "libudev.h"
 #include "libudev-private.h"
 
+static int udev_device_tag_index(struct udev_device *udev_device, bool add)
+{
+	struct udev *udev = udev_device_get_udev(udev_device);
+	struct udev_list_entry *list_entry;
+
+	udev_list_entry_foreach(list_entry, udev_device_get_tags_list_entry(udev_device)) {
+		char filename[UTIL_PATH_SIZE];
+
+		util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev), "/.udev/tags/",
+			      udev_list_entry_get_name(list_entry), "/",
+			      udev_device_get_subsystem(udev_device), ":", udev_device_get_sysname(udev_device), NULL);
+
+		if (add) {
+			util_create_path(udev, filename);
+			symlink(udev_device_get_devpath(udev_device), filename);
+			if (udev_device_get_sysname_old(udev_device) != NULL) {
+				char filename_old[UTIL_PATH_SIZE];
+
+				util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev), "/.udev/tags/",
+					      udev_list_entry_get_name(list_entry),
+					      udev_device_get_subsystem(udev_device), ":", udev_device_get_sysname_old(udev_device), NULL);
+				unlink(filename_old);
+			}
+		} else {
+			unlink(filename);
+			util_delete_path(udev, filename);
+		}
+	}
+	return 0;
+}
+
 int udev_device_update_db(struct udev_device *udev_device)
 {
 	struct udev *udev = udev_device_get_udev(udev_device);
@@ -41,6 +73,8 @@ int udev_device_update_db(struct udev_device *udev_device)
 	udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(udev_device))
 		if (udev_list_entry_get_flags(list_entry))
 			goto file;
+	if (udev_device_get_tags_list_entry(udev_device) != NULL)
+		goto file;
 	if (udev_device_get_devlink_priority(udev_device) != 0)
 		goto file;
 	if (udev_device_get_event_timeout(udev_device) >= 0)
@@ -80,7 +114,7 @@ file:
 	if (f == NULL) {
 		err(udev, "unable to create temporary db file '%s': %m\n", filename_tmp);
 		return -1;
-		}
+	}
 
 	if (udev_device_get_devnode(udev_device) != NULL) {
 		fprintf(f, "N:%s\n", &udev_device_get_devnode(udev_device)[devlen]);
@@ -100,10 +134,13 @@ file:
 			udev_list_entry_get_name(list_entry),
 			udev_list_entry_get_value(list_entry));
 	}
+	udev_list_entry_foreach(list_entry, udev_device_get_tags_list_entry(udev_device))
+		fprintf(f, "G:%s\n", udev_list_entry_get_name(list_entry));
 	fclose(f);
 	rename(filename_tmp, filename);
 	info(udev, "created db file for '%s' in '%s'\n", udev_device_get_devpath(udev_device), filename);
 out:
+	udev_device_tag_index(udev_device, true);
 	return 0;
 }
 
@@ -112,6 +149,7 @@ int udev_device_delete_db(struct udev_device *udev_device)
 	struct udev *udev = udev_device_get_udev(udev_device);
 	char filename[UTIL_PATH_SIZE];
 
+	udev_device_tag_index(udev_device, false);
 	util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev), "/.udev/db/",
 		      udev_device_get_subsystem(udev_device), ":", udev_device_get_sysname(udev_device), NULL);
 	unlink(filename);
@@ -124,9 +162,13 @@ int udev_device_rename_db(struct udev_device *udev_device)
 	char filename_old[UTIL_PATH_SIZE];
 	char filename[UTIL_PATH_SIZE];
 
+	if (strcmp(udev_device_get_sysname(udev_device), udev_device_get_sysname_old(udev_device)) == 0)
+		return 0;
+
 	util_strscpyl(filename_old, sizeof(filename_old), udev_get_dev_path(udev), "/.udev/db/",
 		      udev_device_get_subsystem(udev_device), ":", udev_device_get_sysname_old(udev_device), NULL);
 	util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev), "/.udev/db/",
 		      udev_device_get_subsystem(udev_device), ":", udev_device_get_sysname(udev_device), NULL);
+	udev_device_tag_index(udev_device, true);
 	return rename(filename_old, filename);
 }
diff --git a/libudev/libudev-device.c b/libudev/libudev-device.c
index 400354539b..478fdcb92d 100644
--- a/libudev/libudev-device.c
+++ b/libudev/libudev-device.c
@@ -60,6 +60,7 @@ struct udev_device {
 	struct udev_list_node devlinks_list;
 	struct udev_list_node properties_list;
 	struct udev_list_node sysattr_list;
+	struct udev_list_node tags_list;
 	unsigned long long int seqnum;
 	int event_timeout;
 	int timeout;
@@ -68,18 +69,21 @@ struct udev_device {
 	dev_t devnum;
 	int watch_handle;
 	int maj, min;
-	unsigned int parent_set:1;
-	unsigned int subsystem_set:1;
-	unsigned int devtype_set:1;
-	unsigned int devlinks_uptodate:1;
-	unsigned int envp_uptodate:1;
-	unsigned int driver_set:1;
-	unsigned int info_loaded:1;
+	bool parent_set;
+	bool subsystem_set;
+	bool devtype_set;
+	bool devlinks_uptodate;
+	bool envp_uptodate;
+	bool tags_uptodate;
+	bool driver_set;
+	bool info_loaded;
+	bool db_loaded;
+	bool uevent_loaded;
 };
 
 struct udev_list_entry *udev_device_add_property(struct udev_device *udev_device, const char *key, const char *value)
 {
-	udev_device->envp_uptodate = 0;
+	udev_device->envp_uptodate = false;
 	if (value == NULL) {
 		struct udev_list_entry *list_entry;
 
@@ -149,6 +153,26 @@ void udev_device_add_property_from_string_parse(struct udev_device *udev_device,
 		}
 		if (slink[0] != '\0')
 			udev_device_add_devlink(udev_device, slink, 0);
+	} else if (strncmp(property, "TAGS=", 5) == 0) {
+		char tags[UTIL_PATH_SIZE];
+		char *next;
+
+		util_strscpy(tags, sizeof(tags), &property[5]);
+		next = strchr(tags, ':');
+		if (next != NULL) {
+			next++;
+			while (next[0] != '\0') {
+				char *tag;
+
+				tag = next;
+				next = strchr(tag, ':');
+				if (next == NULL)
+					break;
+				next[0] = '\0';
+				next++;
+				udev_device_add_tag(udev_device, tag);
+			}
+		}
 	} else if (strncmp(property, "DRIVER=", 7) == 0) {
 		udev_device_set_driver(udev_device, &property[7]);
 	} else if (strncmp(property, "ACTION=", 7) == 0) {
@@ -208,6 +232,9 @@ int udev_device_read_db(struct udev_device *udev_device)
 	char line[UTIL_LINE_SIZE];
 	FILE *f;
 
+	if (udev_device->db_loaded)
+		return 0;
+
 	util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev_device->udev), "/.udev/db/",
 		      udev_device_get_subsystem(udev_device), ":", udev_device_get_sysname(udev_device), NULL);
 
@@ -284,6 +311,9 @@ int udev_device_read_db(struct udev_device *udev_device)
 		case 'E':
 			udev_device_add_property_from_string(udev_device, val);
 			break;
+		case 'G':
+			udev_device_add_tag(udev_device, val);
+			break;
 		case 'W':
 			udev_device_set_watch_handle(udev_device, atoi(val));
 			break;
@@ -292,6 +322,7 @@ int udev_device_read_db(struct udev_device *udev_device)
 	fclose(f);
 
 	info(udev_device->udev, "device %p filled with db file data\n", udev_device);
+	udev_device->db_loaded = true;
 	return 0;
 }
 
@@ -303,6 +334,9 @@ int udev_device_read_uevent_file(struct udev_device *udev_device)
 	int maj = 0;
 	int min = 0;
 
+	if (udev_device->uevent_loaded)
+		return 0;
+
 	util_strscpyl(filename, sizeof(filename), udev_device->syspath, "/uevent", NULL);
 	f = fopen(filename, "r");
 	if (f == NULL)
@@ -329,21 +363,14 @@ int udev_device_read_uevent_file(struct udev_device *udev_device)
 	}
 
 	udev_device->devnum = makedev(maj, min);
-
 	fclose(f);
+	udev_device->uevent_loaded = true;
 	return 0;
 }
 
-static void device_load_info(struct udev_device *device)
-{
-	device->info_loaded = 1;
-	udev_device_read_uevent_file(device);
-	udev_device_read_db(device);
-}
-
 void udev_device_set_info_loaded(struct udev_device *device)
 {
-	device->info_loaded = 1;
+	device->info_loaded = true;
 }
 
 struct udev_device *udev_device_new(struct udev *udev)
@@ -362,6 +389,7 @@ struct udev_device *udev_device_new(struct udev *udev)
 	udev_list_init(&udev_device->devlinks_list);
 	udev_list_init(&udev_device->properties_list);
 	udev_list_init(&udev_device->sysattr_list);
+	udev_list_init(&udev_device->tags_list);
 	udev_device->event_timeout = -1;
 	udev_device->watch_handle = -1;
 	/* copy global properties */
@@ -420,7 +448,7 @@ struct udev_device *udev_device_new_from_syspath(struct udev *udev, const char *
 	util_strscpy(path, sizeof(path), syspath);
 	util_resolve_sys_link(udev, path, sizeof(path));
 
-	if (strncmp(&syspath[len], "/devices/", 9) == 0) {
+	if (strncmp(&path[len], "/devices/", 9) == 0) {
 		char file[UTIL_PATH_SIZE];
 
 		/* all "devices" require a "uevent" file */
@@ -648,7 +676,7 @@ struct udev_device *udev_device_get_parent(struct udev_device *udev_device)
 	if (udev_device == NULL)
 		return NULL;
 	if (!udev_device->parent_set) {
-		udev_device->parent_set = 1;
+		udev_device->parent_set = true;
 		udev_device->parent_device = device_new_from_parent(udev_device);
 	}
 	if (udev_device->parent_device != NULL)
@@ -758,12 +786,13 @@ void udev_device_unref(struct udev_device *udev_device)
 	free(udev_device->devtype);
 	udev_list_cleanup_entries(udev_device->udev, &udev_device->devlinks_list);
 	udev_list_cleanup_entries(udev_device->udev, &udev_device->properties_list);
+	udev_list_cleanup_entries(udev_device->udev, &udev_device->sysattr_list);
+	udev_list_cleanup_entries(udev_device->udev, &udev_device->tags_list);
 	free(udev_device->action);
 	free(udev_device->driver);
 	free(udev_device->devpath_old);
 	free(udev_device->sysname_old);
 	free(udev_device->knodename);
-	udev_list_cleanup_entries(udev_device->udev, &udev_device->sysattr_list);
 	free(udev_device->envp);
 	free(udev_device->monitor_buf);
 	dbg(udev_device->udev, "udev_device: %p released\n", udev_device);
@@ -842,7 +871,7 @@ const char *udev_device_get_devnode(struct udev_device *udev_device)
 	if (udev_device == NULL)
 		return NULL;
 	if (!udev_device->info_loaded)
-		device_load_info(udev_device);
+		udev_device_read_db(udev_device);
 	return udev_device->devnode;
 }
 
@@ -862,7 +891,7 @@ const char *udev_device_get_subsystem(struct udev_device *udev_device)
 	if (udev_device == NULL)
 		return NULL;
 	if (!udev_device->subsystem_set) {
-		udev_device->subsystem_set = 1;
+		udev_device->subsystem_set = true;
 		/* read "subsystem" link */
 		if (util_get_sys_subsystem(udev_device->udev, udev_device->syspath, subsystem, sizeof(subsystem)) > 0) {
 			udev_device_set_subsystem(udev_device, subsystem);
@@ -900,9 +929,8 @@ const char *udev_device_get_devtype(struct udev_device *udev_device)
 	if (udev_device == NULL)
 		return NULL;
 	if (!udev_device->devtype_set) {
-		udev_device->devtype_set = 1;
-		if (!udev_device->info_loaded)
-			udev_device_read_uevent_file(udev_device);
+		udev_device->devtype_set = true;
+		udev_device_read_uevent_file(udev_device);
 	}
 	return udev_device->devtype;
 }
@@ -925,13 +953,13 @@ struct udev_list_entry *udev_device_get_devlinks_list_entry(struct udev_device *
 	if (udev_device == NULL)
 		return NULL;
 	if (!udev_device->info_loaded)
-		device_load_info(udev_device);
+		udev_device_read_db(udev_device);
 	return udev_list_get_entry(&udev_device->devlinks_list);
 }
 
 void udev_device_cleanup_devlinks_list(struct udev_device *udev_device)
 {
-	udev_device->devlinks_uptodate = 0;
+	udev_device->devlinks_uptodate = false;
 	udev_list_cleanup_entries(udev_device->udev, &udev_device->devlinks_list);
 }
 
@@ -951,13 +979,15 @@ struct udev_list_entry *udev_device_get_properties_list_entry(struct udev_device
 {
 	if (udev_device == NULL)
 		return NULL;
-	if (!udev_device->info_loaded)
-		device_load_info(udev_device);
+	if (!udev_device->info_loaded) {
+		udev_device_read_uevent_file(udev_device);
+		udev_device_read_db(udev_device);
+	}
 	if (!udev_device->devlinks_uptodate) {
 		char symlinks[UTIL_PATH_SIZE];
 		struct udev_list_entry *list_entry;
 
-		udev_device->devlinks_uptodate = 1;
+		udev_device->devlinks_uptodate = true;
 		list_entry = udev_device_get_devlinks_list_entry(udev_device);
 		if (list_entry != NULL) {
 			char *s;
@@ -970,6 +1000,21 @@ struct udev_list_entry *udev_device_get_properties_list_entry(struct udev_device
 			udev_device_add_property(udev_device, "DEVLINKS", symlinks);
 		}
 	}
+	if (!udev_device->tags_uptodate) {
+		udev_device->tags_uptodate = true;
+		if (udev_device_get_tags_list_entry(udev_device) != NULL) {
+			char tags[UTIL_PATH_SIZE];
+			struct udev_list_entry *list_entry;
+			char *s;
+			size_t l;
+
+			s = tags;
+			l = util_strpcpyl(&s, sizeof(tags), ":", NULL);
+			udev_list_entry_foreach(list_entry, udev_device_get_tags_list_entry(udev_device))
+				l = util_strpcpyl(&s, l, udev_list_entry_get_name(list_entry), ":", NULL);
+			udev_device_add_property(udev_device, "TAGS", tags);
+		}
+	}
 	return udev_list_get_entry(&udev_device->properties_list);
 }
 
@@ -986,7 +1031,7 @@ const char *udev_device_get_driver(struct udev_device *udev_device)
 	if (udev_device == NULL)
 		return NULL;
 	if (!udev_device->driver_set) {
-		udev_device->driver_set = 1;
+		udev_device->driver_set = true;
 		if (util_get_sys_driver(udev_device->udev, udev_device->syspath, driver, sizeof(driver)) > 0)
 			udev_device->driver = strdup(driver);
 	}
@@ -1004,7 +1049,7 @@ dev_t udev_device_get_devnum(struct udev_device *udev_device)
 	if (udev_device == NULL)
 		return makedev(0, 0);
 	if (!udev_device->info_loaded)
-		device_load_info(udev_device);
+		udev_device_read_uevent_file(udev_device);
 	return udev_device->devnum;
 }
 
@@ -1184,7 +1229,7 @@ int udev_device_set_subsystem(struct udev_device *udev_device, const char *subsy
 	udev_device->subsystem = strdup(subsystem);
 	if (udev_device->subsystem == NULL)
 		return -ENOMEM;
-	udev_device->subsystem_set = 1;
+	udev_device->subsystem_set = true;
 	udev_device_add_property(udev_device, "SUBSYSTEM", udev_device->subsystem);
 	return 0;
 }
@@ -1195,7 +1240,7 @@ int udev_device_set_devtype(struct udev_device *udev_device, const char *devtype
 	udev_device->devtype = strdup(devtype);
 	if (udev_device->devtype == NULL)
 		return -ENOMEM;
-	udev_device->devtype_set = 1;
+	udev_device->devtype_set = true;
 	udev_device_add_property(udev_device, "DEVTYPE", udev_device->devtype);
 	return 0;
 }
@@ -1216,7 +1261,7 @@ int udev_device_add_devlink(struct udev_device *udev_device, const char *devlink
 {
 	struct udev_list_entry *list_entry;
 
-	udev_device->devlinks_uptodate = 0;
+	udev_device->devlinks_uptodate = false;
 	list_entry = udev_list_entry_add(udev_device->udev, &udev_device->devlinks_list, devlink, NULL, 1, 0);
 	if (list_entry == NULL)
 		return -ENOMEM;
@@ -1225,6 +1270,40 @@ int udev_device_add_devlink(struct udev_device *udev_device, const char *devlink
 	return 0;
 }
 
+int udev_device_add_tag(struct udev_device *udev_device, const char *tag)
+{
+	if (strchr(tag, ':') != NULL || strchr(tag, ' ') != NULL)
+		return -EINVAL;
+	udev_device->tags_uptodate = false;
+	if (udev_list_entry_add(udev_device->udev, &udev_device->tags_list, tag, NULL, 1, 0) != NULL)
+		return 0;
+	return -ENOMEM;
+}
+
+void udev_device_cleanup_tags_list(struct udev_device *udev_device)
+{
+	udev_device->tags_uptodate = false;
+	udev_list_cleanup_entries(udev_device->udev, &udev_device->tags_list);
+}
+
+struct udev_list_entry *udev_device_get_tags_list_entry(struct udev_device *udev_device)
+{
+	return udev_list_get_entry(&udev_device->tags_list);
+}
+
+int udev_device_has_tag(struct udev_device *udev_device, const char *tag)
+{
+	struct udev_list_entry *list_entry;
+
+	if (!udev_device->info_loaded)
+		udev_device_read_db(udev_device);
+	list_entry = udev_device_get_tags_list_entry(udev_device);
+	list_entry =  udev_list_entry_get_by_name(list_entry, tag);
+	if (list_entry != NULL)
+		return 1;
+	return 0;
+}
+
 #define ENVP_SIZE			128
 #define MONITOR_BUF_SIZE		4096
 static int update_envp_monitor_buf(struct udev_device *udev_device)
@@ -1273,7 +1352,7 @@ static int update_envp_monitor_buf(struct udev_device *udev_device)
 	}
 	udev_device->envp[i] = NULL;
 	udev_device->monitor_buf_len = s - udev_device->monitor_buf;
-	udev_device->envp_uptodate = 1;
+	udev_device->envp_uptodate = true;
 	dbg(udev_device->udev, "filled envp/monitor buffer, %u properties, %zu bytes\n",
 	    i, udev_device->monitor_buf_len);
 	return 0;
@@ -1312,7 +1391,7 @@ int udev_device_set_driver(struct udev_device *udev_device, const char *driver)
 	udev_device->driver = strdup(driver);
 	if (udev_device->driver == NULL)
 		return -ENOMEM;
-	udev_device->driver_set = 1;
+	udev_device->driver_set = true;
 	udev_device_add_property(udev_device, "DRIVER", udev_device->driver);
 	return 0;
 }
@@ -1385,7 +1464,7 @@ int udev_device_set_timeout(struct udev_device *udev_device, int timeout)
 int udev_device_get_event_timeout(struct udev_device *udev_device)
 {
 	if (!udev_device->info_loaded)
-		device_load_info(udev_device);
+		udev_device_read_db(udev_device);
 	return udev_device->event_timeout;
 }
 
@@ -1421,7 +1500,7 @@ int udev_device_set_devnum(struct udev_device *udev_device, dev_t devnum)
 int udev_device_get_devlink_priority(struct udev_device *udev_device)
 {
 	if (!udev_device->info_loaded)
-		device_load_info(udev_device);
+		udev_device_read_db(udev_device);
 	return udev_device->devlink_priority;
 }
 
@@ -1434,7 +1513,7 @@ int udev_device_set_devlink_priority(struct udev_device *udev_device, int prio)
 int udev_device_get_watch_handle(struct udev_device *udev_device)
 {
 	if (!udev_device->info_loaded)
-		device_load_info(udev_device);
+		udev_device_read_db(udev_device);
 	return udev_device->watch_handle;
 }
 
diff --git a/libudev/libudev-enumerate.c b/libudev/libudev-enumerate.c
index 9a61a61f0d..da831449dc 100644
--- a/libudev/libudev-enumerate.c
+++ b/libudev/libudev-enumerate.c
@@ -1,7 +1,7 @@
 /*
  * libudev - interface to udev device information
  *
- * Copyright (C) 2008 Kay Sievers <kay.sievers@vrfy.org>
+ * Copyright (C) 2008-2010 Kay Sievers <kay.sievers@vrfy.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -51,6 +51,7 @@ struct udev_enumerate {
 	struct udev_list_node subsystem_nomatch_list;
 	struct udev_list_node sysname_match_list;
 	struct udev_list_node properties_match_list;
+	struct udev_list_node tags_match_list;
 	struct udev_list_node devices_list;
 	struct syspath *devices;
 	unsigned int devices_cur;
@@ -79,6 +80,7 @@ struct udev_enumerate *udev_enumerate_new(struct udev *udev)
 	udev_list_init(&udev_enumerate->subsystem_nomatch_list);
 	udev_list_init(&udev_enumerate->sysname_match_list);
 	udev_list_init(&udev_enumerate->properties_match_list);
+	udev_list_init(&udev_enumerate->tags_match_list);
 	udev_list_init(&udev_enumerate->devices_list);
 	return udev_enumerate;
 }
@@ -121,6 +123,7 @@ void udev_enumerate_unref(struct udev_enumerate *udev_enumerate)
 	udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->subsystem_nomatch_list);
 	udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->sysname_match_list);
 	udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->properties_match_list);
+	udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->tags_match_list);
 	udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->devices_list);
 	for (i = 0; i < udev_enumerate->devices_cur; i++)
 		free(udev_enumerate->devices[i].syspath);
@@ -191,7 +194,7 @@ static int syspath_cmp(const void *p1, const void *p2)
 }
 
 /* For devices that should be moved to the absolute end of the list */
-static int devices_delay_end(struct udev *udev, const char *syspath)
+static bool devices_delay_end(struct udev *udev, const char *syspath)
 {
 	static const char *delay_device_list[] = {
 		"/block/md",
@@ -205,10 +208,10 @@ static int devices_delay_end(struct udev *udev, const char *syspath)
 	for (i = 0; delay_device_list[i] != NULL; i++) {
 		if (strstr(&syspath[len], delay_device_list[i]) != NULL) {
 			dbg(udev, "delaying: %s\n", syspath);
-			return 1;
+			return true;
 		}
 	}
-	return 0;
+	return false;
 }
 
 /* For devices that should just be moved a little bit later, just
@@ -394,16 +397,12 @@ int udev_enumerate_add_nomatch_sysattr(struct udev_enumerate *udev_enumerate, co
 	return 0;
 }
 
-static int match_sysattr_value(struct udev *udev, const char *syspath, const char *sysattr, const char *match_val)
+static int match_sysattr_value(struct udev_device *dev, const char *sysattr, const char *match_val)
 {
-	struct udev_device *device;
 	const char *val = NULL;
 	bool match = false;
 
-	device = udev_device_new_from_syspath(udev, syspath);
-	if (device == NULL)
-		return -EINVAL;
-	val = udev_device_get_sysattr_value(device, sysattr);
+	val = udev_device_get_sysattr_value(dev, sysattr);
 	if (val == NULL)
 		goto exit;
 	if (match_val == NULL) {
@@ -415,7 +414,6 @@ static int match_sysattr_value(struct udev *udev, const char *syspath, const cha
 		goto exit;
 	}
 exit:
-	udev_device_unref(device);
 	return match;
 }
 
@@ -440,6 +438,25 @@ int udev_enumerate_add_match_property(struct udev_enumerate *udev_enumerate, con
 }
 
 /**
+ * udev_enumerate_add_match_tag:
+ * @udev_enumerate: context
+ * @tag: filter for a tag of the device to include in the list
+ *
+ * Returns: 0 on success, otherwise a negative error value.
+ */
+int udev_enumerate_add_match_tag(struct udev_enumerate *udev_enumerate, const char *tag)
+{
+	if (udev_enumerate == NULL)
+		return -EINVAL;
+	if (tag == NULL)
+		return 0;
+	if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
+				&udev_enumerate->tags_match_list, tag, NULL, 1, 0) == NULL)
+		return -ENOMEM;
+	return 0;
+}
+
+/**
  * udev_enumerate_add_match_sysname:
  * @udev_enumerate: context
  * @sysname: filter for the name of the device to include in the list
@@ -458,46 +475,37 @@ int udev_enumerate_add_match_sysname(struct udev_enumerate *udev_enumerate, cons
 	return 0;
 }
 
-static int match_sysattr(struct udev_enumerate *udev_enumerate, const char *syspath)
+static bool match_sysattr(struct udev_enumerate *udev_enumerate, struct udev_device *dev)
 {
-	struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
 	struct udev_list_entry *list_entry;
 
 	/* skip list */
 	udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->sysattr_nomatch_list)) {
-		if (match_sysattr_value(udev, syspath,
-				     udev_list_entry_get_name(list_entry),
-				     udev_list_entry_get_value(list_entry)))
-			return 0;
+		if (match_sysattr_value(dev, udev_list_entry_get_name(list_entry),
+					udev_list_entry_get_value(list_entry)))
+			return false;
 	}
 	/* include list */
 	if (udev_list_get_entry(&udev_enumerate->sysattr_match_list) != NULL) {
 		udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->sysattr_match_list)) {
 			/* anything that does not match, will make it FALSE */
-			if (!match_sysattr_value(udev, syspath,
-					      udev_list_entry_get_name(list_entry),
-					      udev_list_entry_get_value(list_entry)))
-				return 0;
+			if (!match_sysattr_value(dev, udev_list_entry_get_name(list_entry),
+						 udev_list_entry_get_value(list_entry)))
+				return false;
 		}
-		return 1;
+		return true;
 	}
-	return 1;
+	return true;
 }
 
-static int match_property(struct udev_enumerate *udev_enumerate, const char *syspath)
+static bool match_property(struct udev_enumerate *udev_enumerate, struct udev_device *dev)
 {
-	struct udev_device *dev;
 	struct udev_list_entry *list_entry;
-	int match = false;
+	bool match = false;
 
 	/* no match always matches */
 	if (udev_list_get_entry(&udev_enumerate->properties_match_list) == NULL)
-		return 1;
-
-	/* no device does not match */
-	dev = udev_device_new_from_syspath(udev_enumerate->udev, syspath);
-	if (dev == NULL)
-		return 0;
+		return true;
 
 	/* loop over matches */
 	udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->properties_match_list)) {
@@ -525,23 +533,38 @@ static int match_property(struct udev_enumerate *udev_enumerate, const char *sys
 		}
 	}
 out:
-	udev_device_unref(dev);
 	return match;
 }
 
-static int match_sysname(struct udev_enumerate *udev_enumerate, const char *sysname)
+static bool match_tag(struct udev_enumerate *udev_enumerate, struct udev_device *dev)
+{
+	struct udev_list_entry *list_entry;
+
+	/* no match always matches */
+	if (udev_list_get_entry(&udev_enumerate->tags_match_list) == NULL)
+		return true;
+
+	/* loop over matches */
+	udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->tags_match_list))
+		if (!udev_device_has_tag(dev, udev_list_entry_get_name(list_entry)))
+			return false;
+
+	return true;
+}
+
+static bool match_sysname(struct udev_enumerate *udev_enumerate, const char *sysname)
 {
 	struct udev_list_entry *list_entry;
 
 	if (udev_list_get_entry(&udev_enumerate->sysname_match_list) == NULL)
-		return 1;
+		return true;
 
 	udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->sysname_match_list)) {
 		if (fnmatch(udev_list_entry_get_name(list_entry), sysname, 0) != 0)
 			continue;
-		return 1;
+		return true;
 	}
-	return 0;
+	return false;
 }
 
 static int scan_dir_and_add_devices(struct udev_enumerate *udev_enumerate,
@@ -562,54 +585,53 @@ static int scan_dir_and_add_devices(struct udev_enumerate *udev_enumerate,
 		util_strpcpyl(&s, l, "/", subdir2, NULL);
 	dir = opendir(path);
 	if (dir == NULL)
-		return -1;
+		return -ENOENT;
 	for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
 		char syspath[UTIL_PATH_SIZE];
-		char filename[UTIL_PATH_SIZE];
-		struct stat statbuf;
+		struct udev_device *dev;
 
 		if (dent->d_name[0] == '.')
 			continue;
+
 		if (!match_sysname(udev_enumerate, dent->d_name))
 			continue;
 
 		util_strscpyl(syspath, sizeof(syspath), path, "/", dent->d_name, NULL);
-		if (!match_property(udev_enumerate, syspath))
-			continue;
-		if (lstat(syspath, &statbuf) != 0)
-			continue;
-		if (S_ISREG(statbuf.st_mode))
+		dev = udev_device_new_from_syspath(udev_enumerate->udev, syspath);
+		if (dev == NULL)
 			continue;
-		if (S_ISLNK(statbuf.st_mode))
-			util_resolve_sys_link(udev, syspath, sizeof(syspath));
 
-		util_strscpyl(filename, sizeof(filename), syspath, "/uevent", NULL);
-		if (stat(filename, &statbuf) != 0)
-			continue;
-		if (!match_sysattr(udev_enumerate, syspath))
-			continue;
-		syspath_add(udev_enumerate, syspath);
+		if (!match_tag(udev_enumerate, dev))
+			goto nomatch;
+		if (!match_property(udev_enumerate, dev))
+			goto nomatch;
+		if (!match_sysattr(udev_enumerate, dev))
+			goto nomatch;
+
+		syspath_add(udev_enumerate, udev_device_get_syspath(dev));
+nomatch:
+		udev_device_unref(dev);
 	}
 	closedir(dir);
 	return 0;
 }
 
-static int match_subsystem(struct udev_enumerate *udev_enumerate, const char *subsystem)
+static bool match_subsystem(struct udev_enumerate *udev_enumerate, const char *subsystem)
 {
 	struct udev_list_entry *list_entry;
 
 	udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->subsystem_nomatch_list)) {
 		if (fnmatch(udev_list_entry_get_name(list_entry), subsystem, 0) == 0)
-			return 0;
+			return false;
 	}
 	if (udev_list_get_entry(&udev_enumerate->subsystem_match_list) != NULL) {
 		udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->subsystem_match_list)) {
 			if (fnmatch(udev_list_entry_get_name(list_entry), subsystem, 0) == 0)
-				return 1;
+				return true;
 		}
-		return 0;
+		return false;
 	}
-	return 1;
+	return true;
 }
 
 static int scan_dir(struct udev_enumerate *udev_enumerate, const char *basedir, const char *subdir, const char *subsystem)
@@ -675,17 +697,59 @@ int udev_enumerate_scan_devices(struct udev_enumerate *udev_enumerate)
 
 	if (udev_enumerate == NULL)
 		return -EINVAL;
-	util_strscpyl(base, sizeof(base), udev_get_sys_path(udev), "/subsystem", NULL);
-	if (stat(base, &statbuf) == 0) {
-		/* we have /subsystem/, forget all the old stuff */
-		dbg(udev, "searching '/subsystem/*/devices/*' dir\n");
-		scan_dir(udev_enumerate, "subsystem", "devices", NULL);
+
+	if (udev_list_get_entry(&udev_enumerate->tags_match_list) != NULL) {
+		struct udev_list_entry *list_entry;
+
+		/* scan only tagged devices, use tags reverse-index, instead of searching all devices in /sys */
+		udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->tags_match_list)) {
+			DIR *dir;
+			struct dirent *dent;
+			char path[UTIL_PATH_SIZE];
+
+			util_strscpyl(path, sizeof(path), udev_get_dev_path(udev), "/.udev/tags/",
+				      udev_list_entry_get_name(list_entry), NULL);
+			dir = opendir(path);
+			if (dir == NULL)
+				continue;
+			for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
+				struct udev_device *dev;
+				char syspath[UTIL_PATH_SIZE];
+				char *s;
+				size_t l;
+				ssize_t len;
+
+				if (dent->d_name[0] == '.')
+					continue;
+
+				s = syspath;
+				l = util_strpcpyl(&s, sizeof(syspath), udev_get_sys_path(udev), NULL);
+				len = readlinkat(dirfd(dir), dent->d_name, s, l);
+				if (len <= 0 || (size_t)len == l)
+					continue;
+				s[len] = '\0';
+
+				dev = udev_device_new_from_syspath(udev_enumerate->udev, syspath);
+				if (dev == NULL)
+					continue;
+				syspath_add(udev_enumerate, udev_device_get_syspath(dev));
+				udev_device_unref(dev);
+			}
+		}
 	} else {
+		util_strscpyl(base, sizeof(base), udev_get_sys_path(udev), "/subsystem", NULL);
+		if (stat(base, &statbuf) == 0) {
+			/* we have /subsystem/, forget all the old stuff */
+			dbg(udev, "searching '/subsystem/*/devices/*' dir\n");
+			scan_dir(udev_enumerate, "subsystem", "devices", NULL);
+		} else {
 		dbg(udev, "searching '/bus/*/devices/*' dir\n");
-		scan_dir(udev_enumerate, "bus", "devices", NULL);
-		dbg(udev, "searching '/class/*' dir\n");
-		scan_dir(udev_enumerate, "class", NULL, NULL);
+			scan_dir(udev_enumerate, "bus", "devices", NULL);
+			dbg(udev, "searching '/class/*' dir\n");
+			scan_dir(udev_enumerate, "class", NULL, NULL);
+		}
 	}
+
 	return 0;
 }
 
@@ -704,6 +768,7 @@ int udev_enumerate_scan_subsystems(struct udev_enumerate *udev_enumerate)
 
 	if (udev_enumerate == NULL)
 		return -EINVAL;
+
 	util_strscpyl(base, sizeof(base), udev_get_sys_path(udev), "/subsystem", NULL);
 	if (stat(base, &statbuf) == 0)
 		subsysdir = "subsystem";
diff --git a/libudev/libudev-monitor.c b/libudev/libudev-monitor.c
index 97e52c42db..24e8aead26 100644
--- a/libudev/libudev-monitor.c
+++ b/libudev/libudev-monitor.c
@@ -1,7 +1,7 @@
 /*
  * libudev - interface to udev device information
  *
- * Copyright (C) 2008-2009 Kay Sievers <kay.sievers@vrfy.org>
+ * Copyright (C) 2008-2010 Kay Sievers <kay.sievers@vrfy.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -49,6 +49,7 @@ struct udev_monitor {
 	struct sockaddr_un sun;
 	socklen_t addrlen;
 	struct udev_list_node filter_subsystem_list;
+	struct udev_list_node filter_tag_list;
 };
 
 enum udev_monitor_netlink_group {
@@ -57,25 +58,28 @@ enum udev_monitor_netlink_group {
 	UDEV_MONITOR_UDEV,
 };
 
-#define UDEV_MONITOR_MAGIC		0xcafe1dea
+#define UDEV_MONITOR_MAGIC		0xfeedcafe
 struct udev_monitor_netlink_header {
-	/* udev version text */
-	char version[16];
+	/* "libudev" prefix to distinguish libudev and kernel messages */
+	char prefix[8];
 	/*
 	 * magic to protect against daemon <-> library message format mismatch
 	 * used in the kernel from socket filter rules; needs to be stored in network order
 	 */
 	unsigned int magic;
-	/* properties buffer */
-	unsigned short properties_off;
-	unsigned short properties_len;
+	/* total length of header structure known to the sender */
+	unsigned int header_size;
+	/* properties string buffer */
+	unsigned int properties_off;
+	unsigned int properties_len;
 	/*
-	 * hashes of some common device properties strings to filter with socket filters in
-	 * the client used in the kernel from socket filter rules; needs to be stored in
-	 * network order
+	 * hashes of primary device properties strings, to let libudev subscribers
+	 * use in-kernel socket filters; values need to be stored in network order
 	 */
-	unsigned int filter_subsystem;
-	unsigned int filter_devtype;
+	unsigned int filter_subsystem_hash;
+	unsigned int filter_devtype_hash;
+	unsigned int filter_tag_bloom_hi;
+	unsigned int filter_tag_bloom_lo;
 };
 
 static struct udev_monitor *udev_monitor_new(struct udev *udev)
@@ -88,6 +92,7 @@ static struct udev_monitor *udev_monitor_new(struct udev *udev)
 	udev_monitor->refcount = 1;
 	udev_monitor->udev = udev;
 	udev_list_init(&udev_monitor->filter_subsystem_list);
+	udev_list_init(&udev_monitor->filter_tag_list);
 	return udev_monitor;
 }
 
@@ -247,13 +252,14 @@ static inline void bpf_jmp(struct sock_filter *inss, unsigned int *i,
  */
 int udev_monitor_filter_update(struct udev_monitor *udev_monitor)
 {
-	static struct sock_filter ins[256];
-	static struct sock_fprog filter;
+	struct sock_filter ins[512];
+	struct sock_fprog filter;
 	unsigned int i;
 	struct udev_list_entry *list_entry;
 	int err;
 
-	if (udev_list_get_entry(&udev_monitor->filter_subsystem_list) == NULL)
+	if (udev_list_get_entry(&udev_monitor->filter_subsystem_list) == NULL &&
+	    udev_list_get_entry(&udev_monitor->filter_tag_list) == NULL)
 		return 0;
 
 	memset(ins, 0x00, sizeof(ins));
@@ -266,35 +272,74 @@ int udev_monitor_filter_update(struct udev_monitor *udev_monitor)
 	/* wrong magic, pass packet */
 	bpf_stmt(ins, &i, BPF_RET|BPF_K, 0xffffffff);
 
-	/* add all subsystem match values */
-	udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_monitor->filter_subsystem_list)) {
-		unsigned int hash;
-
-		/* load filter_subsystem value in A */
-		bpf_stmt(ins, &i, BPF_LD|BPF_W|BPF_ABS, offsetof(struct udev_monitor_netlink_header, filter_subsystem));
-		hash = util_string_hash32(udev_list_entry_get_name(list_entry));
-		if (udev_list_entry_get_value(list_entry) == NULL) {
-			/* jump if subsystem does not match */
-			bpf_jmp(ins, &i, BPF_JMP|BPF_JEQ|BPF_K, hash, 0, 1);
-		} else {
-			/* jump if subsystem does not match */
-			bpf_jmp(ins, &i, BPF_JMP|BPF_JEQ|BPF_K, hash, 0, 3);
-
-			/* load filter_devtype value in A */
-			bpf_stmt(ins, &i, BPF_LD|BPF_W|BPF_ABS, offsetof(struct udev_monitor_netlink_header, filter_devtype));
-			/* jump if value does not match */
-			hash = util_string_hash32(udev_list_entry_get_value(list_entry));
-			bpf_jmp(ins, &i, BPF_JMP|BPF_JEQ|BPF_K, hash, 0, 1);
+	if (udev_list_get_entry(&udev_monitor->filter_tag_list) != NULL) {
+		int tag_matches;
+
+		/* count tag matches, to calculate end of tag match block */
+		tag_matches = 0;
+		udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_monitor->filter_tag_list))
+			tag_matches++;
+
+		/* add all tags matches */
+		udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_monitor->filter_tag_list)) {
+			uint64_t tag_bloom_bits = util_string_bloom64(udev_list_entry_get_name(list_entry));
+			uint32_t tag_bloom_hi = tag_bloom_bits >> 32;
+			uint32_t tag_bloom_lo = tag_bloom_bits & 0xffffffff;
+
+			/* load device bloom bits in A */
+			bpf_stmt(ins, &i, BPF_LD|BPF_W|BPF_ABS, offsetof(struct udev_monitor_netlink_header, filter_tag_bloom_hi));
+			/* clear bits (tag bits & bloom bits) */
+			bpf_stmt(ins, &i, BPF_ALU|BPF_AND|BPF_K, tag_bloom_hi);
+			/* jump to next tag if it does not match */
+			bpf_jmp(ins, &i, BPF_JMP|BPF_JEQ|BPF_K, tag_bloom_hi, 0, 3);
+
+			/* load device bloom bits in A */
+			bpf_stmt(ins, &i, BPF_LD|BPF_W|BPF_ABS, offsetof(struct udev_monitor_netlink_header, filter_tag_bloom_lo));
+			/* clear bits (tag bits & bloom bits) */
+			bpf_stmt(ins, &i, BPF_ALU|BPF_AND|BPF_K, tag_bloom_lo);
+			/* jump behind end of tag match block if tag matches */
+			tag_matches--;
+			bpf_jmp(ins, &i, BPF_JMP|BPF_JEQ|BPF_K, tag_bloom_lo, 1 + (tag_matches * 6), 0);
 		}
 
-		/* matched, pass packet */
-		bpf_stmt(ins, &i, BPF_RET|BPF_K, 0xffffffff);
+		/* nothing matched, drop packet */
+		bpf_stmt(ins, &i, BPF_RET|BPF_K, 0);
+	}
 
-		if (i+1 >= ARRAY_SIZE(ins))
-			return -1;
+	/* add all subsystem matches */
+	if (udev_list_get_entry(&udev_monitor->filter_subsystem_list) != NULL) {
+		udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_monitor->filter_subsystem_list)) {
+			unsigned int hash = util_string_hash32(udev_list_entry_get_name(list_entry));
+
+			/* load device subsystem value in A */
+			bpf_stmt(ins, &i, BPF_LD|BPF_W|BPF_ABS, offsetof(struct udev_monitor_netlink_header, filter_subsystem_hash));
+			if (udev_list_entry_get_value(list_entry) == NULL) {
+				/* jump if subsystem does not match */
+				bpf_jmp(ins, &i, BPF_JMP|BPF_JEQ|BPF_K, hash, 0, 1);
+			} else {
+				/* jump if subsystem does not match */
+				bpf_jmp(ins, &i, BPF_JMP|BPF_JEQ|BPF_K, hash, 0, 3);
+
+				/* load device devtype value in A */
+				bpf_stmt(ins, &i, BPF_LD|BPF_W|BPF_ABS, offsetof(struct udev_monitor_netlink_header, filter_devtype_hash));
+				/* jump if value does not match */
+				hash = util_string_hash32(udev_list_entry_get_value(list_entry));
+				bpf_jmp(ins, &i, BPF_JMP|BPF_JEQ|BPF_K, hash, 0, 1);
+			}
+
+			/* matched, pass packet */
+			bpf_stmt(ins, &i, BPF_RET|BPF_K, 0xffffffff);
+
+			if (i+1 >= ARRAY_SIZE(ins))
+				return -1;
+		}
+
+		/* nothing matched, drop packet */
+		bpf_stmt(ins, &i, BPF_RET|BPF_K, 0);
 	}
-	/* nothing matched, drop packet */
-	bpf_stmt(ins, &i, BPF_RET|BPF_K, 0);
+
+	/* matched, pass packet */
+	bpf_stmt(ins, &i, BPF_RET|BPF_K, 0xffffffff);
 
 	/* install filter */
 	filter.len = i;
@@ -406,6 +451,7 @@ void udev_monitor_unref(struct udev_monitor *udev_monitor)
 	if (udev_monitor->sock >= 0)
 		close(udev_monitor->sock);
 	udev_list_cleanup_entries(udev_monitor->udev, &udev_monitor->filter_subsystem_list);
+	udev_list_cleanup_entries(udev_monitor->udev, &udev_monitor->filter_tag_list);
 	dbg(udev_monitor->udev, "monitor %p released\n", udev_monitor);
 	free(udev_monitor);
 }
@@ -445,8 +491,7 @@ static int passes_filter(struct udev_monitor *udev_monitor, struct udev_device *
 	struct udev_list_entry *list_entry;
 
 	if (udev_list_get_entry(&udev_monitor->filter_subsystem_list) == NULL)
-		return 1;
-
+		goto tag;
 	udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_monitor->filter_subsystem_list)) {
 		const char *subsys = udev_list_entry_get_name(list_entry);
 		const char *dsubsys = udev_device_get_subsystem(udev_device);
@@ -458,11 +503,22 @@ static int passes_filter(struct udev_monitor *udev_monitor, struct udev_device *
 
 		devtype = udev_list_entry_get_value(list_entry);
 		if (devtype == NULL)
-			return 1;
+			goto tag;
 		ddevtype = udev_device_get_devtype(udev_device);
 		if (ddevtype == NULL)
 			continue;
 		if (strcmp(ddevtype, devtype) == 0)
+			goto tag;
+	}
+	return 0;
+
+tag:
+	if (udev_list_get_entry(&udev_monitor->filter_tag_list) == NULL)
+		return 1;
+	udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_monitor->filter_tag_list)) {
+		const char *tag = udev_list_entry_get_name(list_entry);
+
+		if (udev_device_has_tag(udev_device, tag))
 			return 1;
 	}
 	return 0;
@@ -556,13 +612,11 @@ retry:
 		return NULL;
 	}
 
-	if (strncmp(buf, "udev-", 5) == 0) {
+	if (memcmp(buf, "libudev", 8) == 0) {
 		/* udev message needs proper version magic */
 		nlh = (struct udev_monitor_netlink_header *) buf;
 		if (nlh->magic != htonl(UDEV_MONITOR_MAGIC))
 			return NULL;
-		if (nlh->properties_off < sizeof(struct udev_monitor_netlink_header))
-			return NULL;
 		if (nlh->properties_off+32 > buflen)
 			return NULL;
 		bufpos = nlh->properties_off;
@@ -626,17 +680,17 @@ retry:
 int udev_monitor_send_device(struct udev_monitor *udev_monitor,
 			     struct udev_monitor *destination, struct udev_device *udev_device)
 {
-	struct msghdr smsg;
-	struct iovec iov[2];
 	const char *buf;
 	ssize_t blen;
 	ssize_t count;
 
 	blen = udev_device_get_properties_monitor_buf(udev_device, &buf);
 	if (blen < 32)
-		return -1;
+		return -EINVAL;
 
 	if (udev_monitor->sun.sun_family != 0) {
+		struct msghdr smsg;
+		struct iovec iov[2];
 		const char *action;
 		char header[2048];
 		char *s;
@@ -660,23 +714,41 @@ int udev_monitor_send_device(struct udev_monitor *udev_monitor,
 		smsg.msg_iovlen = 2;
 		smsg.msg_name = &udev_monitor->sun;
 		smsg.msg_namelen = udev_monitor->addrlen;
-	} else if (udev_monitor->snl.nl_family != 0) {
+		count = sendmsg(udev_monitor->sock, &smsg, 0);
+		info(udev_monitor->udev, "passed %zi bytes to socket monitor %p\n", count, udev_monitor);
+		return count;
+	}
+
+	if (udev_monitor->snl.nl_family != 0) {
+		struct msghdr smsg;
+		struct iovec iov[2];
 		const char *val;
 		struct udev_monitor_netlink_header nlh;
-
+		struct udev_list_entry *list_entry;
+		uint64_t tag_bloom_bits;
 
 		/* add versioned header */
 		memset(&nlh, 0x00, sizeof(struct udev_monitor_netlink_header));
-		util_strscpy(nlh.version, sizeof(nlh.version), "udev-" VERSION);
+		memcpy(nlh.prefix, "libudev", 8);
 		nlh.magic = htonl(UDEV_MONITOR_MAGIC);
+		nlh.header_size = sizeof(struct udev_monitor_netlink_header);
 		val = udev_device_get_subsystem(udev_device);
-		nlh.filter_subsystem = htonl(util_string_hash32(val));
+		nlh.filter_subsystem_hash = htonl(util_string_hash32(val));
 		val = udev_device_get_devtype(udev_device);
 		if (val != NULL)
-			nlh.filter_devtype = htonl(util_string_hash32(val));
+			nlh.filter_devtype_hash = htonl(util_string_hash32(val));
 		iov[0].iov_base = &nlh;
 		iov[0].iov_len = sizeof(struct udev_monitor_netlink_header);
 
+		/* add tag bloom filter */
+		tag_bloom_bits = 0;
+		udev_list_entry_foreach(list_entry, udev_device_get_tags_list_entry(udev_device))
+			tag_bloom_bits |= util_string_bloom64(udev_list_entry_get_name(list_entry));
+		if (tag_bloom_bits > 0) {
+			nlh.filter_tag_bloom_hi = htonl(tag_bloom_bits >> 32);
+			nlh.filter_tag_bloom_lo = htonl(tag_bloom_bits & 0xffffffff);
+		}
+
 		/* add properties list */
 		nlh.properties_off = iov[0].iov_len;
 		nlh.properties_len = blen;
@@ -697,13 +769,12 @@ int udev_monitor_send_device(struct udev_monitor *udev_monitor,
 		else
 			smsg.msg_name = &udev_monitor->snl_destination;
 		smsg.msg_namelen = sizeof(struct sockaddr_nl);
-	} else {
-		return -1;
+		count = sendmsg(udev_monitor->sock, &smsg, 0);
+		info(udev_monitor->udev, "passed %zi bytes to netlink monitor %p\n", count, udev_monitor);
+		return count;
 	}
 
-	count = sendmsg(udev_monitor->sock, &smsg, 0);
-	info(udev_monitor->udev, "passed %zi bytes to monitor %p\n", count, udev_monitor);
-	return count;
+	return -EINVAL;
 }
 
 /**
@@ -712,6 +783,9 @@ int udev_monitor_send_device(struct udev_monitor *udev_monitor,
  * @subsystem: the subsystem value to match the incoming devices against
  * @devtype: the devtype value to match the incoming devices against
  *
+ * This filer is efficiently executed inside the kernel, and libudev subscribers
+ * will usually not be woken up for devices which do not match.
+ *
  * The filter must be installed before the monitor is switched to listening mode.
  *
  * Returns: 0 on success, otherwise a negative error value.
@@ -721,7 +795,7 @@ int udev_monitor_filter_add_match_subsystem_devtype(struct udev_monitor *udev_mo
 	if (udev_monitor == NULL)
 		return -EINVAL;
 	if (subsystem == NULL)
-		return 0;
+		return -EINVAL;
 	if (udev_list_entry_add(udev_monitor->udev,
 				&udev_monitor->filter_subsystem_list, subsystem, devtype, 0, 0) == NULL)
 		return -ENOMEM;
@@ -729,6 +803,30 @@ int udev_monitor_filter_add_match_subsystem_devtype(struct udev_monitor *udev_mo
 }
 
 /**
+ * udev_monitor_filter_add_match_tag:
+ * @udev_monitor: the monitor
+ * @tag: the name of a tag
+ *
+ * This filer is efficiently executed inside the kernel, and libudev subscribers
+ * will usually not be woken up for devices which do not match.
+ *
+ * The filter must be installed before the monitor is switched to listening mode.
+ *
+ * Returns: 0 on success, otherwise a negative error value.
+ */
+int udev_monitor_filter_add_match_tag(struct udev_monitor *udev_monitor, const char *tag)
+{
+	if (udev_monitor == NULL)
+		return -EINVAL;
+	if (tag == NULL)
+		return -EINVAL;
+	if (udev_list_entry_add(udev_monitor->udev,
+				&udev_monitor->filter_tag_list, tag, NULL, 0, 0) == NULL)
+		return -ENOMEM;
+	return 0;
+}
+
+/**
  * udev_monitor_filter_remove:
  * @udev_monitor: monitor
  *
diff --git a/libudev/libudev-private.h b/libudev/libudev-private.h
index 8dc469ec9b..548f4adbef 100644
--- a/libudev/libudev-private.h
+++ b/libudev/libudev-private.h
@@ -14,6 +14,8 @@
 
 #include <syslog.h>
 #include <signal.h>
+#include <stdint.h>
+#include <stdbool.h>
 #include "libudev.h"
 
 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
@@ -84,7 +86,8 @@ const char *udev_device_get_sysname_old(struct udev_device *udev_device);
 int udev_device_set_devpath_old(struct udev_device *udev_device, const char *devpath_old);
 const char *udev_device_get_knodename(struct udev_device *udev_device);
 int udev_device_add_tag(struct udev_device *udev_device, const char *tag);
-struct udev_list_entry *udev_device_get_tag_list_entry(struct udev_device *udev_device);
+void udev_device_cleanup_tags_list(struct udev_device *udev_device);
+struct udev_list_entry *udev_device_get_tags_list_entry(struct udev_device *udev_device);
 int udev_device_has_tag(struct udev_device *udev_device, const char *tag);
 int udev_device_set_knodename(struct udev_device *udev_device, const char *knodename);
 int udev_device_get_timeout(struct udev_device *udev_device);
@@ -203,7 +206,8 @@ size_t util_strscpyl(char *dest, size_t size, const char *src, ...) __attribute_
 int udev_util_replace_whitespace(const char *str, char *to, size_t len);
 int udev_util_replace_chars(char *str, const char *white);
 int udev_util_encode_string(const char *str, char *str_enc, size_t len);
-unsigned int util_string_hash32(const char *str);
+unsigned int util_string_hash32(const char *key);
+uint64_t util_string_bloom64(const char *str);
 
 /* libudev-util-private.c */
 int util_create_path(struct udev *udev, const char *path);
diff --git a/libudev/libudev-util.c b/libudev/libudev-util.c
index c0209f9cc6..3a67b0cd5d 100644
--- a/libudev/libudev-util.c
+++ b/libudev/libudev-util.c
@@ -481,15 +481,74 @@ err:
 	return -1;
 }
 
+/*
+ * http://sites.google.com/site/murmurhash/
+ *
+ * All code is released to the public domain. For business purposes,
+ * Murmurhash is under the MIT license.
+ *
+ */
+static unsigned int murmur_hash2(const char *key, int len, unsigned int seed)
+{
+	/*
+	 *  'm' and 'r' are mixing constants generated offline.
+	 *  They're not really 'magic', they just happen to work well.
+	 */
+	const unsigned int m = 0x5bd1e995;
+	const int r = 24;
+
+	/* initialize the hash to a 'random' value */
+	unsigned int h = seed ^ len;
+
+	/* mix 4 bytes at a time into the hash */
+	const unsigned char * data = (const unsigned char *)key;
+
+	while(len >= 4) {
+		unsigned int k = *(unsigned int *)data;
+
+		k *= m; 
+		k ^= k >> r; 
+		k *= m; 
+		h *= m; 
+		h ^= k;
+
+		data += 4;
+		len -= 4;
+	}
+
+	/* handle the last few bytes of the input array */
+	switch(len) {
+	case 3:
+		h ^= data[2] << 16;
+	case 2:
+		h ^= data[1] << 8;
+	case 1:
+		h ^= data[0];
+		h *= m;
+	};
+
+	/* do a few final mixes of the hash to ensure the last few bytes are well-incorporated */
+	h ^= h >> 13;
+	h *= m;
+	h ^= h >> 15;
+
+	return h;
+}
+
 unsigned int util_string_hash32(const char *str)
 {
-	unsigned int hash = 0;
+	return murmur_hash2(str, strlen(str), 0);
+}
 
-	while (str[0] != '\0') {
-		hash += str[0] << 4;
-		hash += str[0] >> 4;
-		hash *= 11;
-		str++;
-	}
-	return hash;
+/* get a bunch of bit numbers out of the hash, and set the bits in our bit field */
+uint64_t util_string_bloom64(const char *str)
+{
+	uint64_t bits = 0;
+	unsigned int hash = util_string_hash32(str);
+
+	bits |= 1LLU << (hash & 63);
+	bits |= 1LLU << ((hash >> 6) & 63);
+	bits |= 1LLU << ((hash >> 12) & 63);
+	bits |= 1LLU << ((hash >> 18) & 63);
+	return bits;
 }
diff --git a/libudev/libudev.h b/libudev/libudev.h
index 750664f43c..3b73fbd61b 100644
--- a/libudev/libudev.h
+++ b/libudev/libudev.h
@@ -1,7 +1,7 @@
 /*
  * libudev - interface to udev device information
  *
- * Copyright (C) 2008-2009 Kay Sievers <kay.sievers@vrfy.org>
+ * Copyright (C) 2008-2010 Kay Sievers <kay.sievers@vrfy.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -118,6 +118,7 @@ struct udev_device *udev_monitor_receive_device(struct udev_monitor *udev_monito
 /* in-kernel socket filters to select messages that get delivered to a listener */
 int udev_monitor_filter_add_match_subsystem_devtype(struct udev_monitor *udev_monitor,
 						    const char *subsystem, const char *devtype);
+int udev_monitor_filter_add_match_tag(struct udev_monitor *udev_monitor, const char *tag);
 int udev_monitor_filter_update(struct udev_monitor *udev_monitor);
 int udev_monitor_filter_remove(struct udev_monitor *udev_monitor);
 
@@ -138,6 +139,7 @@ int udev_enumerate_add_match_sysattr(struct udev_enumerate *udev_enumerate, cons
 int udev_enumerate_add_nomatch_sysattr(struct udev_enumerate *udev_enumerate, const char *sysattr, const char *value);
 int udev_enumerate_add_match_property(struct udev_enumerate *udev_enumerate, const char *property, const char *value);
 int udev_enumerate_add_match_sysname(struct udev_enumerate *udev_enumerate, const char *sysname);
+int udev_enumerate_add_match_tag(struct udev_enumerate *udev_enumerate, const char *tag);
 int udev_enumerate_add_syspath(struct udev_enumerate *udev_enumerate, const char *syspath);
 /* run enumeration with active filters */
 int udev_enumerate_scan_devices(struct udev_enumerate *udev_enumerate);
diff --git a/udev/udev-event.c b/udev/udev-event.c
index b2e1baee1f..212ccc7950 100644
--- a/udev/udev-event.c
+++ b/udev/udev-event.c
@@ -543,7 +543,6 @@ int udev_event_execute_rules(struct udev_event *event, struct udev_rules *rules)
 
 	if (strcmp(udev_device_get_action(dev), "remove") == 0) {
 		udev_device_read_db(dev);
-		udev_device_set_info_loaded(dev);
 		udev_device_delete_db(dev);
 
 		if (major(udev_device_get_devnum(dev)) != 0)
diff --git a/udev/udev-rules.c b/udev/udev-rules.c
index 6eb8350343..b5016d0bc3 100644
--- a/udev/udev-rules.c
+++ b/udev/udev-rules.c
@@ -157,6 +157,7 @@ enum token_type {
 	TK_A_GROUP_ID,			/* gid_t */
 	TK_A_MODE_ID,			/* mode_t */
 	TK_A_ENV,			/* val, attr */
+	TK_A_TAG,			/* val */
 	TK_A_NAME,			/* val */
 	TK_A_DEVLINK,			/* val */
 	TK_A_EVENT_TIMEOUT,		/* int */
@@ -285,6 +286,7 @@ static const char *token_str(enum token_type type)
 		[TK_A_GROUP_ID] =		"A GROUP_ID",
 		[TK_A_MODE_ID] =		"A MODE_ID",
 		[TK_A_ENV] =			"A ENV",
+		[TK_A_TAG] =			"A ENV",
 		[TK_A_NAME] =			"A NAME",
 		[TK_A_DEVLINK] =		"A DEVLINK",
 		[TK_A_EVENT_TIMEOUT] =		"A EVENT_TIMEOUT",
@@ -354,6 +356,9 @@ static void dump_token(struct udev_rules *rules, struct token *token)
 		dbg(rules->udev, "%s %s '%s' '%s'(%s)\n",
 		    token_str(type), operation_str(op), attr, value, string_glob_str(glob));
 		break;
+	case TK_A_TAG:
+		dbg(rules->udev, "%s %s '%s'\n", token_str(type), operation_str(op), value);
+		break;
 	case TK_A_STRING_ESCAPE_NONE:
 	case TK_A_STRING_ESCAPE_REPLACE:
 		dbg(rules->udev, "%s\n", token_str(type));
@@ -1003,6 +1008,7 @@ static int rule_add_key(struct rule_tmp *rule_tmp, enum token_type type,
 	case TK_A_MODE:
 	case TK_A_NAME:
 	case TK_A_GOTO:
+	case TK_A_TAG:
 		token->key.value_off = add_string(rule_tmp->rules, value);
 		break;
 	case TK_M_ENV:
@@ -1350,6 +1356,11 @@ static int add_rule(struct udev_rules *rules, char *line,
 			continue;
 		}
 
+		if (strcmp(key, "TAG") == 0) {
+			rule_add_key(&rule_tmp, TK_A_TAG, op, value, NULL);
+			continue;
+		}
+
 		if (strcmp(key, "PROGRAM") == 0) {
 			rule_add_key(&rule_tmp, TK_M_PROGRAM, op, value, NULL);
 			continue;
@@ -2408,6 +2419,9 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 				}
 				break;
 			}
+		case TK_A_TAG:
+			udev_device_add_tag(event->dev, &rules->buf[cur->key.value_off]);
+			break;
 		case TK_A_NAME:
 			{
 				const char *name  = &rules->buf[cur->key.value_off];
diff --git a/udev/udev.xml b/udev/udev.xml
index 192a6f1238..842fd5d52a 100644
--- a/udev/udev.xml
+++ b/udev/udev.xml
@@ -349,6 +349,19 @@
             </varlistentry>
 
             <varlistentry>
+              <term><option>TAG</option></term>
+              <listitem>
+                <para>Attach a tag to a device. This is used to filter events for users
+                of libudev's monitor functionality, or to enumerate a group of tagged
+                devices. The implementation can only work efficiently if only a few
+                tags are attached to a device. It is only meant to be used in
+                contexts with specific device filter requirements, and not as a
+                general-purpose flag. Excessive use might result in inefficient event
+                handling.</para>
+              </listitem>
+            </varlistentry>
+
+            <varlistentry>
               <term><option>RUN</option></term>
               <listitem>
                 <para>Add a program to the list of programs to be executed for a specific
diff --git a/udev/udevadm-monitor.c b/udev/udevadm-monitor.c
index d136c6070a..fb650846bc 100644
--- a/udev/udevadm-monitor.c
+++ b/udev/udevadm-monitor.c
@@ -73,6 +73,7 @@ int udevadm_monitor(struct udev *udev, int argc, char *argv[])
 	int print_kernel = 0;
 	int print_udev = 0;
 	struct udev_list_node subsystem_match_list;
+	struct udev_list_node tag_match_list;
 	struct udev_monitor *udev_monitor = NULL;
 	struct udev_monitor *kernel_monitor = NULL;
 	fd_set readfds;
@@ -84,13 +85,15 @@ int udevadm_monitor(struct udev *udev, int argc, char *argv[])
 		{ "kernel", no_argument, NULL, 'k' },
 		{ "udev", no_argument, NULL, 'u' },
 		{ "subsystem-match", required_argument, NULL, 's' },
+		{ "tag-match", required_argument, NULL, 't' },
 		{ "help", no_argument, NULL, 'h' },
 		{}
 	};
 
 	udev_list_init(&subsystem_match_list);
+	udev_list_init(&tag_match_list);
 	while (1) {
-		option = getopt_long(argc, argv, "epkus:h", options, NULL);
+		option = getopt_long(argc, argv, "pekus:t:h", options, NULL);
 		if (option == -1)
 			break;
 
@@ -119,12 +122,16 @@ int udevadm_monitor(struct udev *udev, int argc, char *argv[])
 				udev_list_entry_add(udev, &subsystem_match_list, subsys, devtype, 0, 0);
 				break;
 			}
+		case 't':
+			udev_list_entry_add(udev, &tag_match_list, optarg, NULL, 0, 0);
+			break;
 		case 'h':
 			printf("Usage: udevadm monitor [--property] [--kernel] [--udev] [--help]\n"
 			       "  --property                              print the event properties\n"
 			       "  --kernel                                print kernel uevents\n"
 			       "  --udev                                  print udev events\n"
 			       "  --subsystem-match=<subsystem[/devtype]> filter events by subsystem\n"
+			       "  --tag-match=<tag>                       filter events by tag\n"
 			       "  --help\n\n");
 		default:
 			goto out;
@@ -168,6 +175,13 @@ int udevadm_monitor(struct udev *udev, int argc, char *argv[])
 				fprintf(stderr, "error: unable to apply subsystem filter '%s'\n", subsys);
 		}
 
+		udev_list_entry_foreach(entry, udev_list_get_entry(&tag_match_list)) {
+			const char *tag = udev_list_entry_get_name(entry);
+
+			if (udev_monitor_filter_add_match_tag(udev_monitor, tag) < 0)
+				fprintf(stderr, "error: unable to apply tag filter '%s'\n", tag);
+		}
+
 		if (udev_monitor_enable_receiving(udev_monitor) < 0) {
 			fprintf(stderr, "error: unable to subscribe to udev events\n");
 			rc = 2;
@@ -244,5 +258,6 @@ out:
 	udev_monitor_unref(udev_monitor);
 	udev_monitor_unref(kernel_monitor);
 	udev_list_cleanup_entries(udev, &subsystem_match_list);
+	udev_list_cleanup_entries(udev, &tag_match_list);
 	return rc;
 }
diff --git a/udev/udevadm-trigger.c b/udev/udevadm-trigger.c
index 03aa53437f..3cb07dda9a 100644
--- a/udev/udevadm-trigger.c
+++ b/udev/udevadm-trigger.c
@@ -101,6 +101,7 @@ int udevadm_trigger(struct udev *udev, int argc, char *argv[])
 		{ "attr-match", required_argument, NULL, 'a' },
 		{ "attr-nomatch", required_argument, NULL, 'A' },
 		{ "property-match", required_argument, NULL, 'p' },
+		{ "tag-match", required_argument, NULL, 'g' },
 		{ "sysname-match", required_argument, NULL, 'y' },
 		{ "help", no_argument, NULL, 'h' },
 		{}
@@ -127,7 +128,7 @@ int udevadm_trigger(struct udev *udev, int argc, char *argv[])
 		const char *val;
 		char buf[UTIL_PATH_SIZE];
 
-		option = getopt_long(argc, argv, "vnFo:t:hcp:s:S:a:A:y:", options, NULL);
+		option = getopt_long(argc, argv, "vng:o:t:hcp:s:S:a:A:y:", options, NULL);
 		if (option == -1)
 			break;
 
@@ -172,6 +173,9 @@ int udevadm_trigger(struct udev *udev, int argc, char *argv[])
 			key = keyval(optarg, &val, buf, sizeof(buf));
 			udev_enumerate_add_match_property(udev_enumerate, key, val);
 			break;
+		case 'g':
+			udev_enumerate_add_match_tag(udev_enumerate, optarg);
+			break;
 		case 'y':
 			udev_enumerate_add_match_sysname(udev_enumerate, optarg);
 			break;
@@ -190,6 +194,7 @@ int udevadm_trigger(struct udev *udev, int argc, char *argv[])
 			       "  --attr-match=<file[=<value>]>   trigger devices with a matching attribute\n"
 			       "  --attr-nomatch=<file[=<value>]> exclude devices with a matching attribute\n"
 			       "  --property-match=<key>=<value>  trigger devices with a matching property\n"
+			       "  --tag-match=<key>=<value>       trigger devices with a matching property\n"
 			       "  --sysname-match=<name>          trigger devices with a matching name\n"
 			       "  --help\n\n");
 			goto exit;
diff --git a/udev/udevadm.xml b/udev/udevadm.xml
index fa1742bada..73e6f110a6 100644
--- a/udev/udevadm.xml
+++ b/udev/udevadm.xml
@@ -217,6 +217,13 @@
               </listitem>
             </varlistentry>
             <varlistentry>
+              <term><option>--tag-match=<replaceable>property</replaceable></option></term>
+              <listitem>
+                <para>Trigger events for devices with a matching tag. This option can be
+                specified multiple times.</para>
+              </listitem>
+            </varlistentry>
+            <varlistentry>
               <term><option>--sysname-match=<replaceable>name</replaceable></option></term>
               <listitem>
                 <para>Trigger events for devices with a matching sys device name. This option can be
@@ -356,6 +363,12 @@
               </listitem>
             </varlistentry>
             <varlistentry>
+              <term><option>--tag-match=<replaceable>string</replaceable></option></term>
+              <listitem>
+                <para>Filter events by property. Only udev events with a given tag attached will pass.</para>
+              </listitem>
+            </varlistentry>
+            <varlistentry>
               <term><option>--help</option></term>
               <listitem>
                 <para>Print help text.</para>