1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2008-2012 Kay Sievers <kay@vrfy.org>
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <linux/filter.h>
23 #include <linux/netlink.h>
29 #include <sys/socket.h>
34 #include "alloc-util.h"
37 #include "format-util.h"
38 #include "libudev-private.h"
40 #include "mount-util.h"
41 #include "socket-util.h"
42 #include "string-util.h"
45 * SECTION:libudev-monitor
46 * @short_description: device event source
48 * Connects to a device event source.
54 * Opaque object handling an event source.
60 union sockaddr_union snl
;
61 union sockaddr_union snl_trusted_sender
;
62 union sockaddr_union snl_destination
;
64 struct udev_list filter_subsystem_list
;
65 struct udev_list filter_tag_list
;
69 enum udev_monitor_netlink_group
{
75 #define UDEV_MONITOR_MAGIC 0xfeedcafe
76 struct udev_monitor_netlink_header
{
77 /* "libudev" prefix to distinguish libudev and kernel messages */
80 * magic to protect against daemon <-> library message format mismatch
81 * used in the kernel from socket filter rules; needs to be stored in network order
84 /* total length of header structure known to the sender */
85 unsigned int header_size
;
86 /* properties string buffer */
87 unsigned int properties_off
;
88 unsigned int properties_len
;
90 * hashes of primary device properties strings, to let libudev subscribers
91 * use in-kernel socket filters; values need to be stored in network order
93 unsigned int filter_subsystem_hash
;
94 unsigned int filter_devtype_hash
;
95 unsigned int filter_tag_bloom_hi
;
96 unsigned int filter_tag_bloom_lo
;
99 static struct udev_monitor
*udev_monitor_new(struct udev
*udev
) {
100 struct udev_monitor
*udev_monitor
;
102 udev_monitor
= new0(struct udev_monitor
, 1);
103 if (udev_monitor
== NULL
) {
107 udev_monitor
->refcount
= 1;
108 udev_monitor
->udev
= udev
;
109 udev_list_init(udev
, &udev_monitor
->filter_subsystem_list
, false);
110 udev_list_init(udev
, &udev_monitor
->filter_tag_list
, true);
114 /* we consider udev running when /dev is on devtmpfs */
115 static bool udev_has_devtmpfs(struct udev
*udev
) {
117 _cleanup_fclose_
FILE *f
= NULL
;
118 char line
[LINE_MAX
], *e
;
121 r
= path_get_mnt_id("/dev", &mount_id
);
123 if (r
!= -EOPNOTSUPP
)
124 log_debug_errno(r
, "name_to_handle_at on /dev: %m");
129 f
= fopen("/proc/self/mountinfo", "re");
133 FOREACH_LINE(line
, f
, return false) {
136 if (sscanf(line
, "%i", &mid
) != 1)
142 e
= strstr(line
, " - ");
146 /* accept any name that starts with the currently expected type */
147 if (startswith(e
+ 3, "devtmpfs"))
154 static void monitor_set_nl_address(struct udev_monitor
*udev_monitor
) {
155 union sockaddr_union snl
;
159 assert(udev_monitor
);
161 /* get the address the kernel has assigned us
162 * it is usually, but not necessarily the pid
164 addrlen
= sizeof(struct sockaddr_nl
);
165 r
= getsockname(udev_monitor
->sock
, &snl
.sa
, &addrlen
);
167 udev_monitor
->snl
.nl
.nl_pid
= snl
.nl
.nl_pid
;
170 struct udev_monitor
*udev_monitor_new_from_netlink_fd(struct udev
*udev
, const char *name
, int fd
) {
171 struct udev_monitor
*udev_monitor
;
180 group
= UDEV_MONITOR_NONE
;
181 else if (streq(name
, "udev")) {
183 * We do not support subscribing to uevents if no instance of
184 * udev is running. Uevents would otherwise broadcast the
185 * processing data of the host into containers, which is not
188 * Containers will currently not get any udev uevents, until
189 * a supporting infrastructure is available.
191 * We do not set a netlink multicast group here, so the socket
192 * will not receive any messages.
194 if (access("/run/udev/control", F_OK
) < 0 && !udev_has_devtmpfs(udev
)) {
195 log_debug("the udev service seems not to be active, disable the monitor");
196 group
= UDEV_MONITOR_NONE
;
198 group
= UDEV_MONITOR_UDEV
;
199 } else if (streq(name
, "kernel"))
200 group
= UDEV_MONITOR_KERNEL
;
206 udev_monitor
= udev_monitor_new(udev
);
207 if (udev_monitor
== NULL
)
211 udev_monitor
->sock
= socket(PF_NETLINK
, SOCK_RAW
|SOCK_CLOEXEC
|SOCK_NONBLOCK
, NETLINK_KOBJECT_UEVENT
);
212 if (udev_monitor
->sock
< 0) {
213 log_debug_errno(errno
, "error getting socket: %m");
214 return mfree(udev_monitor
);
217 udev_monitor
->bound
= true;
218 udev_monitor
->sock
= fd
;
219 monitor_set_nl_address(udev_monitor
);
222 udev_monitor
->snl
.nl
.nl_family
= AF_NETLINK
;
223 udev_monitor
->snl
.nl
.nl_groups
= group
;
225 /* default destination for sending */
226 udev_monitor
->snl_destination
.nl
.nl_family
= AF_NETLINK
;
227 udev_monitor
->snl_destination
.nl
.nl_groups
= UDEV_MONITOR_UDEV
;
233 * udev_monitor_new_from_netlink:
234 * @udev: udev library context
235 * @name: name of event source
237 * Create new udev monitor and connect to a specified event
238 * source. Valid sources identifiers are "udev" and "kernel".
240 * Applications should usually not connect directly to the
241 * "kernel" events, because the devices might not be useable
242 * at that time, before udev has configured them, and created
243 * device nodes. Accessing devices at the same time as udev,
244 * might result in unpredictable behavior. The "udev" events
245 * are sent out after udev has finished its event processing,
246 * all rules have been processed, and needed device nodes are
249 * The initial refcount is 1, and needs to be decremented to
250 * release the resources of the udev monitor.
252 * Returns: a new udev monitor, or #NULL, in case of an error
254 _public_
struct udev_monitor
*udev_monitor_new_from_netlink(struct udev
*udev
, const char *name
) {
255 return udev_monitor_new_from_netlink_fd(udev
, name
, -1);
258 static inline void bpf_stmt(struct sock_filter
*inss
, unsigned int *i
,
259 unsigned short code
, unsigned int data
)
261 struct sock_filter
*ins
= &inss
[*i
];
268 static inline void bpf_jmp(struct sock_filter
*inss
, unsigned int *i
,
269 unsigned short code
, unsigned int data
,
270 unsigned short jt
, unsigned short jf
)
272 struct sock_filter
*ins
= &inss
[*i
];
282 * udev_monitor_filter_update:
283 * @udev_monitor: monitor
285 * Update the installed socket filter. This is only needed,
286 * if the filter was removed or changed.
288 * Returns: 0 on success, otherwise a negative error value.
290 _public_
int udev_monitor_filter_update(struct udev_monitor
*udev_monitor
)
292 struct sock_filter ins
[512];
293 struct sock_fprog filter
;
295 struct udev_list_entry
*list_entry
;
298 if (udev_list_get_entry(&udev_monitor
->filter_subsystem_list
) == NULL
&&
299 udev_list_get_entry(&udev_monitor
->filter_tag_list
) == NULL
)
302 memzero(ins
, sizeof(ins
));
305 /* load magic in A */
306 bpf_stmt(ins
, &i
, BPF_LD
|BPF_W
|BPF_ABS
, offsetof(struct udev_monitor_netlink_header
, magic
));
307 /* jump if magic matches */
308 bpf_jmp(ins
, &i
, BPF_JMP
|BPF_JEQ
|BPF_K
, UDEV_MONITOR_MAGIC
, 1, 0);
309 /* wrong magic, pass packet */
310 bpf_stmt(ins
, &i
, BPF_RET
|BPF_K
, 0xffffffff);
312 if (udev_list_get_entry(&udev_monitor
->filter_tag_list
) != NULL
) {
315 /* count tag matches, to calculate end of tag match block */
317 udev_list_entry_foreach(list_entry
, udev_list_get_entry(&udev_monitor
->filter_tag_list
))
320 /* add all tags matches */
321 udev_list_entry_foreach(list_entry
, udev_list_get_entry(&udev_monitor
->filter_tag_list
)) {
322 uint64_t tag_bloom_bits
= util_string_bloom64(udev_list_entry_get_name(list_entry
));
323 uint32_t tag_bloom_hi
= tag_bloom_bits
>> 32;
324 uint32_t tag_bloom_lo
= tag_bloom_bits
& 0xffffffff;
326 /* load device bloom bits in A */
327 bpf_stmt(ins
, &i
, BPF_LD
|BPF_W
|BPF_ABS
, offsetof(struct udev_monitor_netlink_header
, filter_tag_bloom_hi
));
328 /* clear bits (tag bits & bloom bits) */
329 bpf_stmt(ins
, &i
, BPF_ALU
|BPF_AND
|BPF_K
, tag_bloom_hi
);
330 /* jump to next tag if it does not match */
331 bpf_jmp(ins
, &i
, BPF_JMP
|BPF_JEQ
|BPF_K
, tag_bloom_hi
, 0, 3);
333 /* load device bloom bits in A */
334 bpf_stmt(ins
, &i
, BPF_LD
|BPF_W
|BPF_ABS
, offsetof(struct udev_monitor_netlink_header
, filter_tag_bloom_lo
));
335 /* clear bits (tag bits & bloom bits) */
336 bpf_stmt(ins
, &i
, BPF_ALU
|BPF_AND
|BPF_K
, tag_bloom_lo
);
337 /* jump behind end of tag match block if tag matches */
339 bpf_jmp(ins
, &i
, BPF_JMP
|BPF_JEQ
|BPF_K
, tag_bloom_lo
, 1 + (tag_matches
* 6), 0);
342 /* nothing matched, drop packet */
343 bpf_stmt(ins
, &i
, BPF_RET
|BPF_K
, 0);
346 /* add all subsystem matches */
347 if (udev_list_get_entry(&udev_monitor
->filter_subsystem_list
) != NULL
) {
348 udev_list_entry_foreach(list_entry
, udev_list_get_entry(&udev_monitor
->filter_subsystem_list
)) {
349 unsigned int hash
= util_string_hash32(udev_list_entry_get_name(list_entry
));
351 /* load device subsystem value in A */
352 bpf_stmt(ins
, &i
, BPF_LD
|BPF_W
|BPF_ABS
, offsetof(struct udev_monitor_netlink_header
, filter_subsystem_hash
));
353 if (udev_list_entry_get_value(list_entry
) == NULL
) {
354 /* jump if subsystem does not match */
355 bpf_jmp(ins
, &i
, BPF_JMP
|BPF_JEQ
|BPF_K
, hash
, 0, 1);
357 /* jump if subsystem does not match */
358 bpf_jmp(ins
, &i
, BPF_JMP
|BPF_JEQ
|BPF_K
, hash
, 0, 3);
360 /* load device devtype value in A */
361 bpf_stmt(ins
, &i
, BPF_LD
|BPF_W
|BPF_ABS
, offsetof(struct udev_monitor_netlink_header
, filter_devtype_hash
));
362 /* jump if value does not match */
363 hash
= util_string_hash32(udev_list_entry_get_value(list_entry
));
364 bpf_jmp(ins
, &i
, BPF_JMP
|BPF_JEQ
|BPF_K
, hash
, 0, 1);
367 /* matched, pass packet */
368 bpf_stmt(ins
, &i
, BPF_RET
|BPF_K
, 0xffffffff);
370 if (i
+1 >= ELEMENTSOF(ins
))
374 /* nothing matched, drop packet */
375 bpf_stmt(ins
, &i
, BPF_RET
|BPF_K
, 0);
378 /* matched, pass packet */
379 bpf_stmt(ins
, &i
, BPF_RET
|BPF_K
, 0xffffffff);
382 memzero(&filter
, sizeof(filter
));
385 err
= setsockopt(udev_monitor
->sock
, SOL_SOCKET
, SO_ATTACH_FILTER
, &filter
, sizeof(filter
));
386 return err
< 0 ? -errno
: 0;
389 int udev_monitor_allow_unicast_sender(struct udev_monitor
*udev_monitor
, struct udev_monitor
*sender
)
391 udev_monitor
->snl_trusted_sender
.nl
.nl_pid
= sender
->snl
.nl
.nl_pid
;
396 * udev_monitor_enable_receiving:
397 * @udev_monitor: the monitor which should receive events
399 * Binds the @udev_monitor socket to the event source.
401 * Returns: 0 on success, otherwise a negative error value.
403 _public_
int udev_monitor_enable_receiving(struct udev_monitor
*udev_monitor
)
408 udev_monitor_filter_update(udev_monitor
);
410 if (!udev_monitor
->bound
) {
411 err
= bind(udev_monitor
->sock
,
412 &udev_monitor
->snl
.sa
, sizeof(struct sockaddr_nl
));
414 udev_monitor
->bound
= true;
418 monitor_set_nl_address(udev_monitor
);
420 return log_debug_errno(errno
, "bind failed: %m");
422 /* enable receiving of sender credentials */
423 err
= setsockopt(udev_monitor
->sock
, SOL_SOCKET
, SO_PASSCRED
, &on
, sizeof(on
));
425 log_debug_errno(errno
, "setting SO_PASSCRED failed: %m");
431 * udev_monitor_set_receive_buffer_size:
432 * @udev_monitor: the monitor which should receive events
433 * @size: the size in bytes
435 * Set the size of the kernel socket buffer. This call needs the
436 * appropriate privileges to succeed.
438 * Returns: 0 on success, otherwise -1 on error.
440 _public_
int udev_monitor_set_receive_buffer_size(struct udev_monitor
*udev_monitor
, int size
)
442 if (udev_monitor
== NULL
)
444 if (setsockopt(udev_monitor
->sock
, SOL_SOCKET
, SO_RCVBUFFORCE
, &size
, sizeof(size
)) < 0)
450 int udev_monitor_disconnect(struct udev_monitor
*udev_monitor
)
454 err
= close(udev_monitor
->sock
);
455 udev_monitor
->sock
= -1;
456 return err
< 0 ? -errno
: 0;
461 * @udev_monitor: udev monitor
463 * Take a reference of a udev monitor.
465 * Returns: the passed udev monitor
467 _public_
struct udev_monitor
*udev_monitor_ref(struct udev_monitor
*udev_monitor
)
469 if (udev_monitor
== NULL
)
471 udev_monitor
->refcount
++;
476 * udev_monitor_unref:
477 * @udev_monitor: udev monitor
479 * Drop a reference of a udev monitor. If the refcount reaches zero,
480 * the bound socket will be closed, and the resources of the monitor
485 _public_
struct udev_monitor
*udev_monitor_unref(struct udev_monitor
*udev_monitor
)
487 if (udev_monitor
== NULL
)
489 udev_monitor
->refcount
--;
490 if (udev_monitor
->refcount
> 0)
492 if (udev_monitor
->sock
>= 0)
493 close(udev_monitor
->sock
);
494 udev_list_cleanup(&udev_monitor
->filter_subsystem_list
);
495 udev_list_cleanup(&udev_monitor
->filter_tag_list
);
496 return mfree(udev_monitor
);
500 * udev_monitor_get_udev:
501 * @udev_monitor: udev monitor
503 * Retrieve the udev library context the monitor was created with.
505 * Returns: the udev library context
507 _public_
struct udev
*udev_monitor_get_udev(struct udev_monitor
*udev_monitor
)
509 if (udev_monitor
== NULL
)
511 return udev_monitor
->udev
;
515 * udev_monitor_get_fd:
516 * @udev_monitor: udev monitor
518 * Retrieve the socket file descriptor associated with the monitor.
520 * Returns: the socket file descriptor
522 _public_
int udev_monitor_get_fd(struct udev_monitor
*udev_monitor
)
524 if (udev_monitor
== NULL
)
526 return udev_monitor
->sock
;
529 static int passes_filter(struct udev_monitor
*udev_monitor
, struct udev_device
*udev_device
)
531 struct udev_list_entry
*list_entry
;
533 if (udev_list_get_entry(&udev_monitor
->filter_subsystem_list
) == NULL
)
535 udev_list_entry_foreach(list_entry
, udev_list_get_entry(&udev_monitor
->filter_subsystem_list
)) {
536 const char *subsys
= udev_list_entry_get_name(list_entry
);
537 const char *dsubsys
= udev_device_get_subsystem(udev_device
);
539 const char *ddevtype
;
541 if (!streq(dsubsys
, subsys
))
544 devtype
= udev_list_entry_get_value(list_entry
);
547 ddevtype
= udev_device_get_devtype(udev_device
);
548 if (ddevtype
== NULL
)
550 if (streq(ddevtype
, devtype
))
556 if (udev_list_get_entry(&udev_monitor
->filter_tag_list
) == NULL
)
558 udev_list_entry_foreach(list_entry
, udev_list_get_entry(&udev_monitor
->filter_tag_list
)) {
559 const char *tag
= udev_list_entry_get_name(list_entry
);
561 if (udev_device_has_tag(udev_device
, tag
))
568 * udev_monitor_receive_device:
569 * @udev_monitor: udev monitor
571 * Receive data from the udev monitor socket, allocate a new udev
572 * device, fill in the received data, and return the device.
574 * Only socket connections with uid=0 are accepted.
576 * The monitor socket is by default set to NONBLOCK. A variant of poll() on
577 * the file descriptor returned by udev_monitor_get_fd() should to be used to
578 * wake up when new devices arrive, or alternatively the file descriptor
579 * switched into blocking mode.
581 * The initial refcount is 1, and needs to be decremented to
582 * release the resources of the udev device.
584 * Returns: a new udev device, or #NULL, in case of an error
586 _public_
struct udev_device
*udev_monitor_receive_device(struct udev_monitor
*udev_monitor
)
588 struct udev_device
*udev_device
;
591 char cred_msg
[CMSG_SPACE(sizeof(struct ucred
))];
592 struct cmsghdr
*cmsg
;
593 union sockaddr_union snl
;
596 struct udev_monitor_netlink_header nlh
;
601 bool is_initialized
= false;
604 if (udev_monitor
== NULL
) {
609 iov
.iov_len
= sizeof(buf
);
610 memzero(&smsg
, sizeof(struct msghdr
));
613 smsg
.msg_control
= cred_msg
;
614 smsg
.msg_controllen
= sizeof(cred_msg
);
615 smsg
.msg_name
= &snl
;
616 smsg
.msg_namelen
= sizeof(snl
);
618 buflen
= recvmsg(udev_monitor
->sock
, &smsg
, 0);
621 log_debug("unable to receive message");
625 if (buflen
< 32 || (smsg
.msg_flags
& MSG_TRUNC
)) {
626 log_debug("invalid message length");
631 if (snl
.nl
.nl_groups
== 0) {
632 /* unicast message, check if we trust the sender */
633 if (udev_monitor
->snl_trusted_sender
.nl
.nl_pid
== 0 ||
634 snl
.nl
.nl_pid
!= udev_monitor
->snl_trusted_sender
.nl
.nl_pid
) {
635 log_debug("unicast netlink message ignored");
639 } else if (snl
.nl
.nl_groups
== UDEV_MONITOR_KERNEL
) {
640 if (snl
.nl
.nl_pid
> 0) {
641 log_debug("multicast kernel netlink message from PID %"PRIu32
" ignored",
648 cmsg
= CMSG_FIRSTHDR(&smsg
);
649 if (cmsg
== NULL
|| cmsg
->cmsg_type
!= SCM_CREDENTIALS
) {
650 log_debug("no sender credentials received, message ignored");
655 cred
= (struct ucred
*)CMSG_DATA(cmsg
);
656 if (cred
->uid
!= 0) {
657 log_debug("sender uid="UID_FMT
", message ignored", cred
->uid
);
662 if (memcmp(buf
.raw
, "libudev", 8) == 0) {
663 /* udev message needs proper version magic */
664 if (buf
.nlh
.magic
!= htobe32(UDEV_MONITOR_MAGIC
)) {
665 log_debug("unrecognized message signature (%x != %x)",
666 buf
.nlh
.magic
, htobe32(UDEV_MONITOR_MAGIC
));
670 if (buf
.nlh
.properties_off
+32 > (size_t)buflen
) {
671 log_debug("message smaller than expected (%u > %zd)",
672 buf
.nlh
.properties_off
+32, buflen
);
677 bufpos
= buf
.nlh
.properties_off
;
679 /* devices received from udev are always initialized */
680 is_initialized
= true;
682 /* kernel message with header */
683 bufpos
= strlen(buf
.raw
) + 1;
684 if ((size_t)bufpos
< sizeof("a@/d") || bufpos
>= buflen
) {
685 log_debug("invalid message length");
690 /* check message header */
691 if (strstr(buf
.raw
, "@/") == NULL
) {
692 log_debug("unrecognized message header");
698 udev_device
= udev_device_new_from_nulstr(udev_monitor
->udev
, &buf
.raw
[bufpos
], buflen
- bufpos
);
700 log_debug_errno(errno
, "could not create device: %m");
705 udev_device_set_is_initialized(udev_device
);
707 /* skip device, if it does not pass the current filter */
708 if (!passes_filter(udev_monitor
, udev_device
)) {
709 struct pollfd pfd
[1];
712 udev_device_unref(udev_device
);
714 /* if something is queued, get next device */
715 pfd
[0].fd
= udev_monitor
->sock
;
716 pfd
[0].events
= POLLIN
;
717 rc
= poll(pfd
, 1, 0);
728 int udev_monitor_send_device(struct udev_monitor
*udev_monitor
,
729 struct udev_monitor
*destination
, struct udev_device
*udev_device
)
731 const char *buf
, *val
;
733 struct udev_monitor_netlink_header nlh
= {
735 .magic
= htobe32(UDEV_MONITOR_MAGIC
),
736 .header_size
= sizeof nlh
,
738 struct iovec iov
[2] = {
739 { .iov_base
= &nlh
, .iov_len
= sizeof nlh
},
741 struct msghdr smsg
= {
745 struct udev_list_entry
*list_entry
;
746 uint64_t tag_bloom_bits
;
748 blen
= udev_device_get_properties_monitor_buf(udev_device
, &buf
);
750 log_debug("device buffer is too small to contain a valid device");
754 /* fill in versioned header */
755 val
= udev_device_get_subsystem(udev_device
);
756 nlh
.filter_subsystem_hash
= htobe32(util_string_hash32(val
));
758 val
= udev_device_get_devtype(udev_device
);
760 nlh
.filter_devtype_hash
= htobe32(util_string_hash32(val
));
762 /* add tag bloom filter */
764 udev_list_entry_foreach(list_entry
, udev_device_get_tags_list_entry(udev_device
))
765 tag_bloom_bits
|= util_string_bloom64(udev_list_entry_get_name(list_entry
));
766 if (tag_bloom_bits
> 0) {
767 nlh
.filter_tag_bloom_hi
= htobe32(tag_bloom_bits
>> 32);
768 nlh
.filter_tag_bloom_lo
= htobe32(tag_bloom_bits
& 0xffffffff);
771 /* add properties list */
772 nlh
.properties_off
= iov
[0].iov_len
;
773 nlh
.properties_len
= blen
;
774 iov
[1].iov_base
= (char *)buf
;
775 iov
[1].iov_len
= blen
;
778 * Use custom address for target, or the default one.
780 * If we send to a multicast group, we will get
781 * ECONNREFUSED, which is expected.
784 smsg
.msg_name
= &destination
->snl
;
786 smsg
.msg_name
= &udev_monitor
->snl_destination
;
787 smsg
.msg_namelen
= sizeof(struct sockaddr_nl
);
788 count
= sendmsg(udev_monitor
->sock
, &smsg
, 0);
790 if (!destination
&& errno
== ECONNREFUSED
) {
791 log_debug("passed device to netlink monitor %p", udev_monitor
);
797 log_debug("passed %zi byte device to netlink monitor %p", count
, udev_monitor
);
802 * udev_monitor_filter_add_match_subsystem_devtype:
803 * @udev_monitor: the monitor
804 * @subsystem: the subsystem value to match the incoming devices against
805 * @devtype: the devtype value to match the incoming devices against
807 * This filter is efficiently executed inside the kernel, and libudev subscribers
808 * will usually not be woken up for devices which do not match.
810 * The filter must be installed before the monitor is switched to listening mode.
812 * Returns: 0 on success, otherwise a negative error value.
814 _public_
int udev_monitor_filter_add_match_subsystem_devtype(struct udev_monitor
*udev_monitor
, const char *subsystem
, const char *devtype
)
816 if (udev_monitor
== NULL
)
818 if (subsystem
== NULL
)
820 if (udev_list_entry_add(&udev_monitor
->filter_subsystem_list
, subsystem
, devtype
) == NULL
)
826 * udev_monitor_filter_add_match_tag:
827 * @udev_monitor: the monitor
828 * @tag: the name of a tag
830 * This filter is efficiently executed inside the kernel, and libudev subscribers
831 * will usually not be woken up for devices which do not match.
833 * The filter must be installed before the monitor is switched to listening mode.
835 * Returns: 0 on success, otherwise a negative error value.
837 _public_
int udev_monitor_filter_add_match_tag(struct udev_monitor
*udev_monitor
, const char *tag
)
839 if (udev_monitor
== NULL
)
843 if (udev_list_entry_add(&udev_monitor
->filter_tag_list
, tag
, NULL
) == NULL
)
849 * udev_monitor_filter_remove:
850 * @udev_monitor: monitor
852 * Remove all filters from monitor.
854 * Returns: 0 on success, otherwise a negative error value.
856 _public_
int udev_monitor_filter_remove(struct udev_monitor
*udev_monitor
)
858 static const struct sock_fprog filter
= { 0, NULL
};
860 udev_list_cleanup(&udev_monitor
->filter_subsystem_list
);
861 if (setsockopt(udev_monitor
->sock
, SOL_SOCKET
, SO_ATTACH_FILTER
, &filter
, sizeof(filter
)) < 0)