e77b146f82
This tries to address the "bind"/"unbind" uevent kernel API breakage, by changing the semantics of device tags. Previously, tags would be applied on uevents (and the database entries they result in) only depending on the immediate context. This means that if one uevent causes the tag to be set and the next to be unset, this would immediately effect what apps would see and the database entries would contain each time. This is problematic however, as tags are a filtering concept, and if tags vanish then clients won't hence notice when a device stops being relevant to them since not only the tags disappear but immediately also the uevents for it are filtered including the one necessary for the app to notice that the device lost its tag and hence relevance. With this change tags become "sticky". If a tag is applied is once applied to a device it will stay in place forever, until the device is removed. Tags can never be removed again. This means that an app watching a specific set of devices by filtering for a tag is guaranteed to not only see the events where the tag is set but also all follow-up events where the tags might be removed again. This change of behaviour is unfortunate, but is required due to the kernel introducing new "bind" and "unbind" uevents that generally have the effect that tags and properties disappear and apps hence don't notice when a device looses relevance to it. "bind"/"unbind" events were introduced in kernel 4.12, and are now used in more and more subsystems. The introduction broke userspace widely, and this commit is an attempt to provide a way for apps to deal with it. While tags are now "sticky" a new automatic device property CURRENT_TAGS is introduced (matching the existing TAGS property) that always reflects the precise set of tags applied on the most recent events. Thus, when subscribing to devices through tags, all devices that ever had the tag put on them will be be seen, and by CURRENT_TAGS it may be checked whether the device right at the moment matches the tag requirements. See: #7587 #7018 #8221
103 lines
3.8 KiB
C
103 lines
3.8 KiB
C
/* SPDX-License-Identifier: LGPL-2.1+ */
|
|
#pragma once
|
|
|
|
#include "sd-device.h"
|
|
|
|
#include "device-private.h"
|
|
#include "hashmap.h"
|
|
#include "set.h"
|
|
#include "time-util.h"
|
|
|
|
struct sd_device {
|
|
unsigned n_ref;
|
|
|
|
int watch_handle;
|
|
|
|
sd_device *parent;
|
|
|
|
OrderedHashmap *properties;
|
|
Iterator properties_iterator;
|
|
uint64_t properties_generation; /* changes whenever the properties are changed */
|
|
uint64_t properties_iterator_generation; /* generation when iteration was started */
|
|
|
|
/* the subset of the properties that should be written to the db */
|
|
OrderedHashmap *properties_db;
|
|
|
|
Hashmap *sysattr_values; /* cached sysattr values */
|
|
|
|
Set *sysattrs; /* names of sysattrs */
|
|
Iterator sysattrs_iterator;
|
|
|
|
Set *all_tags, *current_tags;
|
|
Iterator all_tags_iterator, current_tags_iterator;
|
|
uint64_t all_tags_iterator_generation, current_tags_iterator_generation; /* generation when iteration was started */
|
|
uint64_t tags_generation; /* changes whenever the tags are changed */
|
|
|
|
Set *devlinks;
|
|
Iterator devlinks_iterator;
|
|
uint64_t devlinks_generation; /* changes whenever the devlinks are changed */
|
|
uint64_t devlinks_iterator_generation; /* generation when iteration was started */
|
|
int devlink_priority;
|
|
|
|
int ifindex;
|
|
char *devtype;
|
|
char *devname;
|
|
dev_t devnum;
|
|
|
|
char **properties_strv; /* the properties hashmap as a strv */
|
|
uint8_t *properties_nulstr; /* the same as a nulstr */
|
|
size_t properties_nulstr_len;
|
|
|
|
char *syspath;
|
|
const char *devpath;
|
|
const char *sysnum;
|
|
char *sysname;
|
|
|
|
char *subsystem;
|
|
char *driver_subsystem; /* only set for the 'drivers' subsystem */
|
|
char *driver;
|
|
|
|
char *id_filename;
|
|
|
|
uint64_t usec_initialized;
|
|
|
|
mode_t devmode;
|
|
uid_t devuid;
|
|
gid_t devgid;
|
|
|
|
/* only set when device is passed through netlink */
|
|
DeviceAction action;
|
|
uint64_t seqnum;
|
|
|
|
bool parent_set:1; /* no need to try to reload parent */
|
|
bool sysattrs_read:1; /* don't try to re-read sysattrs once read */
|
|
bool property_tags_outdated:1; /* need to update TAGS= or CURRENT_TAGS= property */
|
|
bool property_devlinks_outdated:1; /* need to update DEVLINKS= property */
|
|
bool properties_buf_outdated:1; /* need to reread hashmap */
|
|
bool sysname_set:1; /* don't reread sysname */
|
|
bool subsystem_set:1; /* don't reread subsystem */
|
|
bool driver_subsystem_set:1; /* don't reread subsystem */
|
|
bool driver_set:1; /* don't reread driver */
|
|
bool uevent_loaded:1; /* don't reread uevent */
|
|
bool db_loaded; /* don't reread db */
|
|
|
|
bool is_initialized:1;
|
|
bool sealed:1; /* don't read more information from uevent/db */
|
|
bool db_persist:1; /* don't clean up the db when switching from initrd to real root */
|
|
};
|
|
|
|
int device_new_aux(sd_device **ret);
|
|
int device_add_property_aux(sd_device *device, const char *key, const char *value, bool db);
|
|
int device_add_property_internal(sd_device *device, const char *key, const char *value);
|
|
int device_read_uevent_file(sd_device *device);
|
|
|
|
int device_set_syspath(sd_device *device, const char *_syspath, bool verify);
|
|
int device_set_ifindex(sd_device *device, const char *ifindex);
|
|
int device_set_devmode(sd_device *device, const char *devmode);
|
|
int device_set_devname(sd_device *device, const char *devname);
|
|
int device_set_devtype(sd_device *device, const char *devtype);
|
|
int device_set_devnum(sd_device *device, const char *major, const char *minor);
|
|
int device_set_subsystem(sd_device *device, const char *_subsystem);
|
|
int device_set_driver(sd_device *device, const char *_driver);
|
|
int device_set_usec_initialized(sd_device *device, usec_t when);
|