HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/libsystemd/sd-device/sd-device.c

94,791 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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);