HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/libsystemd/sd-device/sd-device.c
Git blob: 5bba62e3e0d2a79e44042a3074bf19ca5ccbec3e
Lines 1001–2000 of 2,953
static int device_enumerate_children_internal(sd_device *device, const char *subdir, Set **stack, Hashmap **children) {
_cleanup_closedir_ DIR *dir = NULL;
int r;
assert(device);
assert(stack);
assert(children);
r = device_opendir(device, subdir, &dir);
if (r < 0)
return r;
FOREACH_DIRENT_ALL(de, dir, return -errno) {
_cleanup_(sd_device_unrefp) sd_device *child = NULL;
_cleanup_free_ char *p = NULL;
if (dot_or_dot_dot(de->d_name))
continue;
if (!IN_SET(de->d_type, DT_LNK, DT_DIR))
continue;
if (subdir)
p = path_join(subdir, de->d_name);
else
p = strdup(de->d_name);
if (!p)
return -ENOMEM;
/* Try to create child device. */
r = sd_device_new_child(&child, device, p);
if (r >= 0) {
/* OK, this is a child device, saving it. */
r = hashmap_ensure_put(children, &device_by_path_hash_ops, p, child);
if (r < 0)
return r;
TAKE_PTR(p);
TAKE_PTR(child);
} else if (r == -ENODEV) {
/* This is not a child device. Push the sub-directory into stack, and read it later. */
if (de->d_type == DT_LNK)
/* Do not follow symlinks, otherwise, we will enter an infinite loop, e.g.,
* /sys/class/block/nvme0n1/subsystem/nvme0n1/subsystem/nvme0n1/subsystem/… */
continue;
r = set_ensure_consume(stack, &path_hash_ops_free, TAKE_PTR(p));
if (r < 0)
return r;
} else
return r;
}
return 0;
}
static int device_enumerate_children(sd_device *device) {
_cleanup_hashmap_free_ Hashmap *children = NULL;
_cleanup_set_free_ Set *stack = NULL;
int r;
assert(device);
if (device->children_enumerated)
return 0; /* Already enumerated. */
r = device_enumerate_children_internal(device, NULL, &stack, &children);
if (r < 0)
return r;
for (;;) {
_cleanup_free_ char *subdir = NULL;
subdir = set_steal_first(stack);
if (!subdir)
break;
r = device_enumerate_children_internal(device, subdir, &stack, &children);
if (r < 0)
return r;
}
device->children_enumerated = true;
device->children = TAKE_PTR(children);
return 1; /* Enumerated. */
}
_public_ sd_device* sd_device_get_child_first(sd_device *device, const char **ret_suffix) {
int r;
assert(device);
r = device_enumerate_children(device);
if (r < 0) {
log_device_debug_errno(device, r, "sd-device: failed to enumerate child devices: %m");
if (ret_suffix)
*ret_suffix = NULL;
return NULL;
}
device->children_iterator = ITERATOR_FIRST;
return sd_device_get_child_next(device, ret_suffix);
}
_public_ sd_device* sd_device_get_child_next(sd_device *device, const char **ret_suffix) {
sd_device *child;
assert(device);
(void) hashmap_iterate(device->children, &device->children_iterator, (void**) &child, (const void**) ret_suffix);
return child;
}
_public_ int sd_device_new_child(sd_device **ret, sd_device *device, const char *suffix) {
_cleanup_free_ char *path = NULL;
sd_device *child;
const char *s;
int r;
assert_return(ret, -EINVAL);
assert_return(device, -EINVAL);
assert_return(suffix, -EINVAL);
if (!path_is_safe(suffix))
return -EINVAL;
/* If we have already enumerated children, try to find the child from the cache. */
child = hashmap_get(device->children, suffix);
if (child) {
*ret = sd_device_ref(child);
return 0;
}
r = sd_device_get_syspath(device, &s);
if (r < 0)
return r;
path = path_join(s, suffix);
if (!path)
return -ENOMEM;
return sd_device_new_from_syspath(ret, path);
}
static int device_new_from_child(sd_device **ret, sd_device *child) {
_cleanup_free_ char *path = NULL;
const char *syspath;
int r;
assert(ret);
assert(child);
r = sd_device_get_syspath(child, &syspath);
if (r < 0)
return r;
for (;;) {
_cleanup_free_ char *p = NULL;
r = path_extract_directory(path ?: syspath, &p);
if (r < 0)
return r;
if (path_equal(p, "/sys"))
return -ENODEV;
r = sd_device_new_from_syspath(ret, p);
if (r != -ENODEV)
return r;
free_and_replace(path, p);
}
}
_public_ int sd_device_get_parent(sd_device *device, sd_device **ret) {
int r;
assert_return(device, -EINVAL);
if (!device->parent_set) {
r = device_new_from_child(&device->parent, device);
if (r < 0 && r != -ENODEV)
return r;
device->parent_set = true;
}
if (!device->parent)
return -ENOENT;
if (ret)
*ret = device->parent;
return 0;
}
int device_set_subsystem(sd_device *device, const char *subsystem) {
_cleanup_free_ char *s = NULL;
int r;
assert(device);
if (subsystem) {
s = strdup(subsystem);
if (!s)
return -ENOMEM;
}
r = device_add_property_internal(device, "SUBSYSTEM", s);
if (r < 0)
return r;
device->subsystem_set = true;
return free_and_replace(device->subsystem, s);
}
int device_set_drivers_subsystem(sd_device *device) {
_cleanup_free_ char *subsystem = NULL;
const char *devpath, *drivers, *p;
int r;
assert(device);
r = sd_device_get_devpath(device, &devpath);
if (r < 0)
return r;
drivers = strstr(devpath, "/drivers/");
if (!drivers)
drivers = endswith(devpath, "/drivers");
if (!drivers)
return -EINVAL;
/* Find the path component immediately before the "/drivers/" string */
r = path_find_last_component(devpath, /* accept_dot_dot= */ false, &drivers, &p);
if (r < 0)
return r;
if (r == 0)
return -EINVAL;
subsystem = strndup(p, r);
if (!subsystem)
return -ENOMEM;
r = device_set_subsystem(device, "drivers");
if (r < 0)
return r;
return free_and_replace(device->driver_subsystem, subsystem);
}
_public_ int sd_device_get_subsystem(sd_device *device, const char **ret) {
int r;
assert_return(device, -EINVAL);
r = device_read_uevent_file(device);
if (r < 0)
return r;
if (!device->subsystem_set) {
const char *subsystem;
r = device_get_sysattr_safe_string(device, "subsystem", &subsystem);
if (r < 0 && r != -ENOENT)
return log_device_debug_errno(device, r,
"sd-device: Failed to read subsystem for %s: %m",
device->devpath);
if (r >= 0)
r = device_set_subsystem(device, subsystem);
/* use implicit names */
else if (!isempty(path_startswith(device->devpath, "/module/")))
r = device_set_subsystem(device, "module");
else if (strstr(device->devpath, "/drivers/") || endswith(device->devpath, "/drivers"))
r = device_set_drivers_subsystem(device);
else if (!isempty(PATH_STARTSWITH_SET(device->devpath, "/class/", "/bus/")))
r = device_set_subsystem(device, "subsystem");
else
r = device_set_subsystem(device, NULL);
if (r < 0)
return log_device_debug_errno(device, r,
"sd-device: Failed to set subsystem for %s: %m",
device->devpath);
}
if (!device->subsystem)
return -ENOENT;
if (ret)
*ret = device->subsystem;
return 0;
}
_public_ int sd_device_get_driver_subsystem(sd_device *device, const char **ret) {
int r;
assert_return(device, -EINVAL);
r = device_in_subsystem(device, "drivers");
if (r < 0)
return r;
if (r == 0)
return -ENOENT;
assert(device->driver_subsystem);
if (ret)
*ret = device->driver_subsystem;
return 0;
}
_public_ int sd_device_get_devtype(sd_device *device, const char **ret) {
int r;
assert_return(device, -EINVAL);
r = device_read_uevent_file(device);
if (r < 0)
return r;
if (!device->devtype)
return -ENOENT;
if (ret)
*ret = device->devtype;
return 0;
}
_public_ int sd_device_get_parent_with_subsystem_devtype(sd_device *device, const char *subsystem, const char *devtype, sd_device **ret) {
int r;
assert_return(device, -EINVAL);
assert_return(subsystem, -EINVAL);
for (;;) {
r = sd_device_get_parent(device, &device);
if (r < 0)
return r;
r = device_is_subsystem_devtype(device, subsystem, devtype);
if (r < 0)
return r;
if (r == 0)
continue;
if (ret)
*ret = device;
return 0;
}
}
_public_ int sd_device_get_devnum(sd_device *device, dev_t *ret) {
int r;
assert_return(device, -EINVAL);
r = device_read_uevent_file(device);
if (r < 0)
return r;
if (major(device->devnum) <= 0)
return -ENOENT;
if (ret)
*ret = device->devnum;
return 0;
}
int device_set_driver(sd_device *device, const char *driver) {
_cleanup_free_ char *d = NULL;
int r;
assert(device);
if (driver) {
d = strdup(driver);
if (!d)
return -ENOMEM;
}
r = device_add_property_internal(device, "DRIVER", d);
if (r < 0)
return r;
device->driver_set = true;
return free_and_replace(device->driver, d);
}
_public_ int sd_device_get_driver(sd_device *device, const char **ret) {
int r;
assert_return(device, -EINVAL);
r = device_read_uevent_file(device);
if (r < 0)
return r;
if (!device->driver_set) {
const char *driver = NULL;
r = device_get_sysattr_safe_string(device, "driver", &driver);
if (r < 0 && r != -ENOENT)
return log_device_debug_errno(device, r,
"sd-device: Failed to read driver: %m");
r = device_set_driver(device, driver);
if (r < 0)
return log_device_debug_errno(device, r,
"sd-device: Failed to set driver \"%s\": %m", driver);
}
if (!device->driver)
return -ENOENT;
if (ret)
*ret = device->driver;
return 0;
}
_public_ int sd_device_get_devpath(sd_device *device, const char **ret) {
assert_return(device, -EINVAL);
assert(device->devpath);
assert(device->devpath[0] == '/');
if (ret)
*ret = device->devpath;
return 0;
}
_public_ int sd_device_get_devname(sd_device *device, const char **ret) {
int r;
assert_return(device, -EINVAL);
r = device_read_uevent_file(device);
if (r < 0)
return r;
if (!device->devname)
return -ENOENT;
assert(!isempty(path_startswith(device->devname, "/dev/")));
if (ret)
*ret = device->devname;
return 0;
}
static int device_set_sysname_and_sysnum(sd_device *device) {
_cleanup_free_ char *sysname = NULL;
size_t len, n;
int r;
assert(device);
r = path_extract_filename(device->devpath, &sysname);
if (r < 0)
return r;
if (r == O_DIRECTORY)
return -EINVAL;
/* some devices have '!' in their name, change that to '/' */
string_replace_char(sysname, '!', '/');
n = strspn_from_end(sysname, DIGITS);
len = strlen(sysname);
assert(n <= len);
if (n == len)
n = 0; /* Do not set sysnum for number only sysname. */
device->sysnum = n > 0 ? sysname + len - n : NULL;
return free_and_replace(device->sysname, sysname);
}
_public_ int sd_device_get_sysname(sd_device *device, const char **ret) {
int r;
assert_return(device, -EINVAL);
if (!device->sysname) {
r = device_set_sysname_and_sysnum(device);
if (r < 0)
return r;
}
if (ret)
*ret = device->sysname;
return 0;
}
_public_ int sd_device_get_sysnum(sd_device *device, const char **ret) {
int r;
assert_return(device, -EINVAL);
if (!device->sysname) {
r = device_set_sysname_and_sysnum(device);
if (r < 0)
return r;
}
if (!device->sysnum)
return -ENOENT;
if (ret)
*ret = device->sysnum;
return 0;
}
int device_get_sysnum_unsigned(sd_device *device, unsigned *ret) {
int r;
assert(device);
const char *s;
r = sd_device_get_sysnum(device, &s);
if (r < 0)
return r;
unsigned n;
r = safe_atou_full(s, SAFE_ATO_REFUSE_PLUS_MINUS | SAFE_ATO_REFUSE_LEADING_WHITESPACE | 10, &n);
if (r < 0)
return r;
if (ret)
*ret = n;
return 0;
}
_public_ int sd_device_get_action(sd_device *device, sd_device_action_t *ret) {
assert_return(device, -EINVAL);
if (device->action < 0)
return -ENOENT;
if (ret)
*ret = device->action;
return 0;
}
_public_ int sd_device_get_seqnum(sd_device *device, uint64_t *ret) {
assert_return(device, -EINVAL);
if (device->seqnum == 0)
return -ENOENT;
if (ret)
*ret = device->seqnum;
return 0;
}
_public_ int sd_device_get_diskseq(sd_device *device, uint64_t *ret) {
int r;
assert_return(device, -EINVAL);
r = device_read_uevent_file(device);
if (r < 0)
return r;
if (device->diskseq == 0)
return -ENOENT;
if (ret)
*ret = device->diskseq;
return 0;
}
static bool is_valid_tag(const char *tag) {
assert(tag);
return in_charset(tag, ALPHANUMERICAL "-_") && filename_is_valid(tag);
}
int device_add_tag(sd_device *device, const char *tag, bool both) {
int r, added;
assert(device);
assert(tag);
if (!is_valid_tag(tag))
return -EINVAL;
/* Definitely add to the "all" list of tags (i.e. the sticky list) */
added = set_put_strdup(&device->all_tags, tag);
if (added < 0)
return added;
/* And optionally, also add it to the current list of tags */
if (both) {
r = set_put_strdup(&device->current_tags, tag);
if (r < 0) {
if (added > 0)
(void) set_remove(device->all_tags, tag);
return r;
}
}
device->tags_generation++;
device->property_tags_outdated = true;
return 0;
}
int device_add_devlink(sd_device *device, const char *devlink) {
char *p;
int r;
assert(device);
assert(devlink);
r = mangle_devname(devlink, &p);
if (r < 0)
return r;
r = set_ensure_consume(&device->devlinks, &path_hash_ops_free, p);
if (r < 0)
return r;
device->devlinks_generation++;
device->property_devlinks_outdated = true;
return r; /* return 1 when newly added, 0 when already exists */
}
int device_remove_devlink(sd_device *device, const char *devlink) {
_cleanup_free_ char *p = NULL, *s = NULL;
int r;
assert(device);
assert(devlink);
r = mangle_devname(devlink, &p);
if (r < 0)
return r;
s = set_remove(device->devlinks, p);
if (!s)
return 0; /* does not exist */
device->devlinks_generation++;
device->property_devlinks_outdated = true;
return 1; /* removed */
}
bool device_has_devlink(sd_device *device, const char *devlink) {
assert(device);
assert(devlink);
return set_contains(device->devlinks, devlink);
}
static int device_add_property_internal_from_string(sd_device *device, const char *str) {
_cleanup_free_ char *key = NULL;
char *value;
assert(device);
assert(str);
key = strdup(str);
if (!key)
return -ENOMEM;
value = strchr(key, '=');
if (!value)
return -EINVAL;
*value = '\0';
if (isempty(++value))
value = NULL;
/* Add the property to both sd_device::properties and sd_device::properties_db,
* as this is called by only handle_db_line(). */
return device_add_property(device, key, value);
}
int device_set_usec_initialized(sd_device *device, usec_t when) {
char s[DECIMAL_STR_MAX(usec_t)];
int r;
assert(device);
xsprintf(s, USEC_FMT, when);
r = device_add_property_internal(device, "USEC_INITIALIZED", s);
if (r < 0)
return r;
device->usec_initialized = when;
return 0;
}
static int handle_db_line(sd_device *device, char key, const char *value) {
int r;
assert(device);
assert(value);
switch (key) {
case 'G': /* Any tag */
case 'Q': /* Current tag */
return device_add_tag(device, value, key == 'Q');
case 'S': {
const char *path;
path = strjoina("/dev/", value);
return device_add_devlink(device, path);
}
case 'E':
return device_add_property_internal_from_string(device, value);
case 'I': {
usec_t t;
r = safe_atou64(value, &t);
if (r < 0)
return r;
return device_set_usec_initialized(device, t);
}
case 'L':
return safe_atoi(value, &device->devlink_priority);
case 'W':
/* Deprecated. Previously, watch handle is both saved in database and /run/udev/watch.
* However, the handle saved in database may not be updated when the handle is updated
* or removed. Moreover, it is not necessary to store the handle within the database,
* as its value becomes meaningless when udevd is restarted. */
return 0;
case 'V':
return safe_atou(value, &device->database_version);
default:
log_device_debug(device, "sd-device: Unknown key '%c' in device db, ignoring", key);
return 0;
}
}
_public_ int sd_device_get_device_id(sd_device *device, const char **ret) {
assert_return(device, -EINVAL);
if (!device->device_id) {
_cleanup_free_ char *id = NULL;
dev_t devnum;
int ifindex, r;
if (sd_device_get_devnum(device, &devnum) >= 0) {
r = device_in_subsystem(device, "block");
if (r < 0)
return r;
char t = r > 0 ? 'b' : 'c';
/* use dev_t — b259:131072, c254:0 */
if (asprintf(&id, "%c" DEVNUM_FORMAT_STR, t, DEVNUM_FORMAT_VAL(devnum)) < 0)
return -ENOMEM;
} else if (sd_device_get_ifindex(device, &ifindex) >= 0) {
/* use netdev ifindex — n3 */
if (asprintf(&id, "n%u", (unsigned) ifindex) < 0)
return -ENOMEM;
} else {
_cleanup_free_ char *sysname = NULL;
/* use $subsys:$sysname — pci:0000:00:1f.2
* sd_device_get_sysname() has '!' translated, get it from devpath */
r = path_extract_filename(device->devpath, &sysname);
if (r < 0)
return r;
if (r == O_DIRECTORY)
return -EINVAL;
r = device_in_subsystem(device, "drivers");
if (r < 0)
return r;
if (r > 0)
/* the 'drivers' pseudo-subsystem is special, and needs the real
* subsystem encoded as well */
id = strjoin("+drivers:", ASSERT_PTR(device->driver_subsystem), ":", sysname);
else {
const char *subsystem;
r = sd_device_get_subsystem(device, &subsystem);
if (r < 0)
return r;
id = strjoin("+", subsystem, ":", sysname);
}
if (!id)
return -ENOMEM;
}
if (!filename_is_valid(id))
return -EINVAL;
device->device_id = TAKE_PTR(id);
}
if (ret)
*ret = device->device_id;
return 0;
}
int device_read_db_internal_filename(sd_device *device, const char *filename) {
_cleanup_free_ char *db = NULL;
const char *value;
size_t db_len;
char key = '\0'; /* Unnecessary initialization to appease gcc-12.0.0-0.4.fc36 */
int r;
enum {
PRE_KEY,
KEY,
PRE_VALUE,
VALUE,
INVALID_LINE,
} state = PRE_KEY;
assert(device);
assert(filename);
r = read_full_file(filename, &db, &db_len);
if (r == -ENOENT)
return 0;
if (r < 0)
return log_device_debug_errno(device, r, "sd-device: Failed to read db '%s': %m", filename);
/* devices with a database entry are initialized */
device->is_initialized = true;
device->db_loaded = true;
for (size_t i = 0; i < db_len; i++)
switch (state) {
case PRE_KEY:
if (!strchr(NEWLINE, db[i])) {
key = db[i];
state = KEY;
}
break;
case KEY:
if (db[i] != ':') {
log_device_debug(device, "sd-device: Invalid db entry with key '%c', ignoring", key);
state = INVALID_LINE;
} else {
db[i] = '\0';
state = PRE_VALUE;
}
break;
case PRE_VALUE:
value = &db[i];
state = VALUE;
break;
case INVALID_LINE:
if (strchr(NEWLINE, db[i]))
state = PRE_KEY;
break;
case VALUE:
if (strchr(NEWLINE, db[i])) {
db[i] = '\0';
r = handle_db_line(device, key, value);
if (r < 0)
log_device_debug_errno(device, r, "sd-device: Failed to handle db entry '%c:%s', ignoring: %m",
key, value);
state = PRE_KEY;
}
break;
default:
return log_device_debug_errno(device, SYNTHETIC_ERRNO(EINVAL), "sd-device: invalid db syntax.");
}
return 0;
}
_public_ int sd_device_get_is_initialized(sd_device *device) {
int r;
assert_return(device, -EINVAL);
r = device_read_db(device);
if (r == -ENOENT)
/* The device may be already removed or renamed. */
return false;
if (r < 0)
return r;
return device->is_initialized;
}
_public_ int sd_device_get_usec_initialized(sd_device *device, uint64_t *ret) {
int r;
assert_return(device, -EINVAL);
r = sd_device_get_is_initialized(device);
if (r < 0)
return r;
if (r == 0)
return -EBUSY;
if (device->usec_initialized == 0)
return -ENODATA;
if (ret)
*ret = device->usec_initialized;
return 0;
}
_public_ int sd_device_get_usec_since_initialized(sd_device *device, uint64_t *ret) {
usec_t now_ts, ts;
int r;
assert_return(device, -EINVAL);
r = sd_device_get_usec_initialized(device, &ts);
if (r < 0)
return r;
now_ts = now(CLOCK_MONOTONIC);
if (now_ts < ts)
return -EIO;
if (ret)
*ret = usec_sub_unsigned(now_ts, ts);
return 0;
}
_public_ const char* sd_device_get_tag_first(sd_device *device) {
void *v;
assert_return(device, NULL);
(void) device_read_db(device);
device->all_tags_iterator_generation = device->tags_generation;
device->all_tags_iterator = ITERATOR_FIRST;
(void) set_iterate(device->all_tags, &device->all_tags_iterator, &v);
return v;
}
_public_ const char* sd_device_get_tag_next(sd_device *device) {
void *v;
assert_return(device, NULL);
(void) device_read_db(device);
if (device->all_tags_iterator_generation != device->tags_generation)
return NULL;
(void) set_iterate(device->all_tags, &device->all_tags_iterator, &v);
return v;
}
_public_ const char* sd_device_get_current_tag_first(sd_device *device) {
void *v;
assert_return(device, NULL);
(void) device_read_db(device);
device->current_tags_iterator_generation = device->tags_generation;
device->current_tags_iterator = ITERATOR_FIRST;
(void) set_iterate(device->current_tags, &device->current_tags_iterator, &v);
return v;
}
_public_ const char* sd_device_get_current_tag_next(sd_device *device) {
void *v;
assert_return(device, NULL);