X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=libudev%2Flibudev-monitor.c;h=b3e5d5f348499bb20acb0a208fe414cfb75b4861;hp=e8cdd30a166e2357b1969241263b462ae4ce24e8;hb=d80f8ffd1a182fe7fff9816e8a4efc09e877964b;hpb=1b98ae83be69f805f8197caa42a304e851dd7f95 diff --git a/libudev/libudev-monitor.c b/libudev/libudev-monitor.c index e8cdd30a1..b3e5d5f34 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 + * Copyright (C) 2008-2010 Kay Sievers * * 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; } @@ -139,13 +144,12 @@ struct udev_monitor *udev_monitor_new_from_socket(struct udev *udev, const char util_strscpy(&udev_monitor->sun.sun_path[1], sizeof(udev_monitor->sun.sun_path)-1, socket_path); udev_monitor->addrlen = offsetof(struct sockaddr_un, sun_path) + strlen(socket_path)+1; } - udev_monitor->sock = socket(AF_LOCAL, SOCK_DGRAM, 0); + udev_monitor->sock = socket(AF_LOCAL, SOCK_DGRAM|SOCK_CLOEXEC, 0); if (udev_monitor->sock == -1) { err(udev, "error getting socket: %m\n"); free(udev_monitor); return NULL; } - util_set_fd_cloexec(udev_monitor->sock); dbg(udev, "monitor %p created with '%s'\n", udev_monitor, socket_path); return udev_monitor; @@ -197,13 +201,12 @@ struct udev_monitor *udev_monitor_new_from_netlink(struct udev *udev, const char if (udev_monitor == NULL) return NULL; - udev_monitor->sock = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT); + udev_monitor->sock = socket(PF_NETLINK, SOCK_DGRAM|SOCK_CLOEXEC, NETLINK_KOBJECT_UEVENT); if (udev_monitor->sock == -1) { err(udev, "error getting socket: %m\n"); free(udev_monitor); return NULL; } - util_set_fd_cloexec(udev_monitor->sock); udev_monitor->snl.nl_family = AF_NETLINK; udev_monitor->snl.nl_groups = group; @@ -249,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)); @@ -268,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); + } + + /* 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; + } - 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; @@ -336,7 +379,7 @@ int udev_monitor_enable_receiving(struct udev_monitor *udev_monitor) /* * get the address the kernel has assigned us - * it is usually, but not neccessarily the pid + * it is usually, but not necessarily the pid */ addrlen = sizeof(struct sockaddr_nl); err = getsockname(udev_monitor->sock, (struct sockaddr *)&snl, &addrlen); @@ -357,6 +400,16 @@ int udev_monitor_enable_receiving(struct udev_monitor *udev_monitor) return 0; } +/** + * udev_monitor_set_receive_buffer_size: + * @udev_monitor: the monitor which should receive events + * @size: the size in bytes + * + * Set the size of the kernel socket buffer. This call needs the + * appropriate privileges to succeed. + * + * Returns: 0 on success, otherwise -1 on error. + */ int udev_monitor_set_receive_buffer_size(struct udev_monitor *udev_monitor, int size) { if (udev_monitor == NULL) @@ -408,6 +461,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); } @@ -447,8 +501,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); @@ -460,11 +513,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; @@ -499,12 +563,6 @@ struct udev_device *udev_monitor_receive_device(struct udev_monitor *udev_monito ssize_t buflen; ssize_t bufpos; struct udev_monitor_netlink_header *nlh; - int devpath_set = 0; - int subsystem_set = 0; - int action_set = 0; - int maj = 0; - int min = 0; - int is_kernel = 0; retry: if (udev_monitor == NULL) @@ -545,10 +603,10 @@ retry: } } else if (snl.nl_groups == UDEV_MONITOR_KERNEL) { if (snl.nl_pid > 0) { - info(udev_monitor->udev, "multicast kernel netlink message from pid %d ignored\n", snl.nl_pid); + info(udev_monitor->udev, "multicast kernel netlink message from pid %d ignored\n", + snl.nl_pid); return NULL; } - is_kernel = 1; } } @@ -564,13 +622,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; @@ -590,9 +646,9 @@ retry: } udev_device = udev_device_new(udev_monitor->udev); - if (udev_device == NULL) { + if (udev_device == NULL) return NULL; - } + udev_device_set_info_loaded(udev_device); while (bufpos < buflen) { char *key; @@ -603,60 +659,11 @@ retry: if (keylen == 0) break; bufpos += keylen + 1; - - if (strncmp(key, "DEVPATH=", 8) == 0) { - char path[UTIL_PATH_SIZE]; - - util_strscpyl(path, sizeof(path), udev_get_sys_path(udev_monitor->udev), &key[8], NULL); - udev_device_set_syspath(udev_device, path); - devpath_set = 1; - } else if (strncmp(key, "SUBSYSTEM=", 10) == 0) { - udev_device_set_subsystem(udev_device, &key[10]); - subsystem_set = 1; - } else if (strncmp(key, "DEVTYPE=", 8) == 0) { - udev_device_set_devtype(udev_device, &key[8]); - } else if (strncmp(key, "DEVNAME=", 8) == 0) { - if (is_kernel) - udev_device_set_knodename(udev_device, &key[8]); - else - udev_device_set_devnode(udev_device, &key[8]); - } else if (strncmp(key, "DEVLINKS=", 9) == 0) { - char devlinks[UTIL_PATH_SIZE]; - char *slink; - char *next; - - util_strscpy(devlinks, sizeof(devlinks), &key[9]); - slink = devlinks; - next = strchr(slink, ' '); - while (next != NULL) { - next[0] = '\0'; - udev_device_add_devlink(udev_device, slink); - slink = &next[1]; - next = strchr(slink, ' '); - } - if (slink[0] != '\0') - udev_device_add_devlink(udev_device, slink); - } else if (strncmp(key, "DRIVER=", 7) == 0) { - udev_device_set_driver(udev_device, &key[7]); - } else if (strncmp(key, "ACTION=", 7) == 0) { - udev_device_set_action(udev_device, &key[7]); - action_set = 1; - } else if (strncmp(key, "MAJOR=", 6) == 0) { - maj = strtoull(&key[6], NULL, 10); - } else if (strncmp(key, "MINOR=", 6) == 0) { - min = strtoull(&key[6], NULL, 10); - } else if (strncmp(key, "DEVPATH_OLD=", 12) == 0) { - udev_device_set_devpath_old(udev_device, &key[12]); - } else if (strncmp(key, "SEQNUM=", 7) == 0) { - udev_device_set_seqnum(udev_device, strtoull(&key[7], NULL, 10)); - } else if (strncmp(key, "TIMEOUT=", 8) == 0) { - udev_device_set_timeout(udev_device, strtoull(&key[8], NULL, 10)); - } else { - udev_device_add_property_from_string(udev_device, key); - } + udev_device_add_property_from_string_parse(udev_device, key); } - if (!devpath_set || !subsystem_set || !action_set) { - info(udev_monitor->udev, "missing values, skip\n"); + + if (udev_device_add_property_from_string_parse_finish(udev_device) < 0) { + info(udev_monitor->udev, "missing values, invalid device\n"); udev_device_unref(udev_device); return NULL; } @@ -677,26 +684,23 @@ retry: return NULL; } - if (maj > 0) - udev_device_set_devnum(udev_device, makedev(maj, min)); - udev_device_set_info_loaded(udev_device); return udev_device; } 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; @@ -720,23 +724,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; @@ -749,7 +771,7 @@ int udev_monitor_send_device(struct udev_monitor *udev_monitor, /* * Use custom address for target, or the default one. * - * If we send to a muticast group, we will get + * If we send to a multicast group, we will get * ECONNREFUSED, which is expected. */ if (destination != NULL) @@ -757,20 +779,22 @@ 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; } /** * udev_monitor_filter_add_match_subsystem_devtype: * @udev_monitor: the monitor * @subsystem: the subsystem value to match the incoming devices against - * @devtype: the devtype value to matvh 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. * @@ -781,13 +805,37 @@ 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; return 0; } +/** + * 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