shaba/systemd-stable
1
1
Fork 0
mirror of https://github.com/systemd/systemd-stable.git synced 2025-01-11 05:17:44 +03:00
Code

sd-device: add sd_device_get_action() + sd_device_get_seqnum() + sd_device_new_from_stat_rdev()

Browse Source 
To make sd-device properly usable for all programs we need to provide an
API for the "action" field of an event, it's one of the most relevant
ones, and it was so far missing.

This also adds sd_device_get_seqnum(), which isn't that interesting,
except for generating pretty debug output, which we use it ourselves
for.

This also makes device_new_from_stat_rdev() public, as it is truly
useful, as we can see in our own uses of it, and I think is fairly
generic to show up in the public APIs.
This commit is contained in:
Lennart Poettering 2021-02-10 22:15:01 +01:00
parent 96fb82aa06
commit a113002214
27 changed files with 145 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/core/device.c
View File

@ -7,7 +7,6 @@
#include "bus-error.h"
#include "dbus-device.h"
#include "dbus-unit.h"
#include "device-private.h"
#include "device-util.h"
#include "device.h"
#include "log.h"
@ -916,8 +915,8 @@ static int device_remove_old(Manager *m, sd_device *dev) {
}
static int device_dispatch_io(sd_device_monitor *monitor, sd_device *dev, void *userdata) {
sd_device_action_t action;
Manager *m = userdata;
DeviceAction action;
const char *sysfs;
int r;
@ -930,22 +929,22 @@ static int device_dispatch_io(sd_device_monitor *monitor, sd_device *dev, void *
return 0;
}
r = device_get_action(dev, &action);
r = sd_device_get_action(dev, &action);
if (r < 0) {
log_device_error_errno(dev, r, "Failed to get udev action: %m");
return 0;
}
if (!IN_SET(action, DEVICE_ACTION_ADD, DEVICE_ACTION_REMOVE, DEVICE_ACTION_MOVE))
if (!IN_SET(action, SD_DEVICE_ADD, SD_DEVICE_REMOVE, SD_DEVICE_MOVE))
device_propagate_reload_by_sysfs(m, sysfs);
if (action == DEVICE_ACTION_MOVE)
if (action == SD_DEVICE_MOVE)
(void) device_remove_old(m, dev);
/* A change event can signal that a device is becoming ready, in particular if the device is using
* the SYSTEMD_READY logic in udev so we need to reach the else block of the following if, even for
* change events */
if (action == DEVICE_ACTION_REMOVE) {
if (action == SD_DEVICE_REMOVE) {
r = swap_process_device_remove(m, dev);
if (r < 0)
log_device_warning_errno(dev, r, "Failed to process swap device remove event, ignoring: %m");
@ -1013,7 +1012,7 @@ static int validate_node(Manager *m, const char *node, sd_device **ret) {
} else {
_cleanup_(sd_device_unrefp) sd_device *dev = NULL;
r = device_new_from_stat_rdev(&dev, &st);
r = sd_device_new_from_stat_rdev(&dev, &st);
if (r == -ENOENT) {
*ret = NULL;
return 1; /* good! (though missing) */

5
src/core/swap.c
View File

@ -10,7 +10,6 @@
#include "alloc-util.h"
#include "dbus-swap.h"
#include "dbus-unit.h"
#include "device-private.h"
#include "device-util.h"
#include "device.h"
#include "escape.h"
@ -307,7 +306,7 @@ static int swap_load_devnode(Swap *s) {
if (stat(s->what, &st) < 0 || !S_ISBLK(st.st_mode))
return 0;
r = device_new_from_stat_rdev(&d, &st);
r = sd_device_new_from_stat_rdev(&d, &st);
if (r < 0) {
log_unit_full_errno(UNIT(s), r == -ENOENT ? LOG_DEBUG : LOG_WARNING, r,
"Failed to allocate device for swap %s: %m", s->what);
@ -510,7 +509,7 @@ static int swap_process_new(Manager *m, const char *device, int prio, bool set_f
if (stat(device, &st) < 0 || !S_ISBLK(st.st_mode))
return 0;
r = device_new_from_stat_rdev(&d, &st);
r = sd_device_new_from_stat_rdev(&d, &st);
if (r < 0) {
log_full_errno(r == -ENOENT ? LOG_DEBUG : LOG_WARNING, r,
"Failed to allocate device for swap %s: %m", device);

2
src/home/homed-manager.c
View File

@ -1234,7 +1234,7 @@ static int manager_on_device(sd_device_monitor *monitor, sd_device *d, void *use
assert(m);
assert(d);
if (device_for_action(d, DEVICE_ACTION_REMOVE)) {
if (device_for_action(d, SD_DEVICE_REMOVE)) {
const char *sysfs;
Home *h;

3
src/journal/journalctl.c
View File

@ -30,7 +30,6 @@
#include "catalog.h"
#include "chattr-util.h"
#include "def.h"
#include "device-private.h"
#include "dissect-image.h"
#include "fd-util.h"
#include "fileio.h"
@ -207,7 +206,7 @@ static int add_matches_for_device(sd_journal *j, const char *devpath) {
if (stat(devpath, &st) < 0)
return log_error_errno(errno, "Couldn't stat file: %m");
r = device_new_from_stat_rdev(&device, &st);
r = sd_device_new_from_stat_rdev(&device, &st);
if (r < 0)
return log_error_errno(r, "Failed to get device from devnum %u:%u: %m", major(st.st_rdev), minor(st.st_rdev));

4
src/libsystemd/libsystemd.sym
View File

@ -745,4 +745,8 @@ global:
sd_event_source_set_ratelimit;
sd_event_source_get_ratelimit;
sd_event_source_is_ratelimited;
sd_device_get_action;
sd_device_get_seqnum;
sd_device_new_from_stat_rdev;
} LIBSYSTEMD_247;

2
src/libsystemd/sd-device/device-internal.h
View File

@ -76,7 +76,7 @@ struct sd_device {
gid_t devgid;
/* only set when device is passed through netlink */
DeviceAction action;
sd_device_action_t action;
uint64_t seqnum;
bool parent_set:1; /* no need to try to reload parent */

66
src/libsystemd/sd-device/device-private.c
View File

@ -183,20 +183,8 @@ static int device_set_devgid(sd_device *device, const char *gid) {
return 0;
}
int device_get_action(sd_device *device, DeviceAction *action) {
assert(device);
if (device->action < 0)
return -ENOENT;
if (action)
*action = device->action;
return 0;
}
static int device_set_action(sd_device *device, const char *action) {
DeviceAction a;
sd_device_action_t a;
int r;
assert(device);
@ -206,7 +194,7 @@ static int device_set_action(sd_device *device, const char *action) {
if (a < 0)
return a;
r = device_add_property_internal(device, "ACTION", action);
r = device_add_property_internal(device, "ACTION", device_action_to_string(a));
if (r < 0)
return r;
@ -215,18 +203,6 @@ static int device_set_action(sd_device *device, const char *action) {
return 0;
}
int device_get_seqnum(sd_device *device, uint64_t *seqnum) {
assert(device);
if (device->seqnum == 0)
return -ENOENT;
if (seqnum)
*seqnum = device->seqnum;
return 0;
}
static int device_set_seqnum(sd_device *device, const char *str) {
uint64_t seqnum;
int r;
@ -724,22 +700,6 @@ int device_new_from_synthetic_event(sd_device **new_device, const char *syspath,
return 0;
}
int device_new_from_stat_rdev(sd_device **ret, const struct stat *st) {
char type;
assert(ret);
assert(st);
if (S_ISBLK(st->st_mode))
type = 'b';
else if (S_ISCHR(st->st_mode))
type = 'c';
else
return -ENOTTY;
return sd_device_new_from_devnum(ret, type, st->st_rdev);
}
int device_copy_properties(sd_device *device_dst, sd_device *device_src) {
const char *property, *value;
int r;
@ -1003,19 +963,19 @@ int device_delete_db(sd_device *device) {
return 0;
}
static const char* const device_action_table[_DEVICE_ACTION_MAX] = {
[DEVICE_ACTION_ADD] = "add",
[DEVICE_ACTION_REMOVE] = "remove",
[DEVICE_ACTION_CHANGE] = "change",
[DEVICE_ACTION_MOVE] = "move",
[DEVICE_ACTION_ONLINE] = "online",
[DEVICE_ACTION_OFFLINE] = "offline",
[DEVICE_ACTION_BIND] = "bind",
[DEVICE_ACTION_UNBIND] = "unbind",
static const char* const device_action_table[_SD_DEVICE_ACTION_MAX] = {
[SD_DEVICE_ADD] = "add",
[SD_DEVICE_REMOVE] = "remove",
[SD_DEVICE_CHANGE] = "change",
[SD_DEVICE_MOVE] = "move",
[SD_DEVICE_ONLINE] = "online",
[SD_DEVICE_OFFLINE] = "offline",
[SD_DEVICE_BIND] = "bind",
[SD_DEVICE_UNBIND] = "unbind",
};
DEFINE_STRING_TABLE_LOOKUP(device_action, DeviceAction);
DEFINE_STRING_TABLE_LOOKUP(device_action, sd_device_action_t);
void dump_device_action_table(void) {
DUMP_STRING_TABLE(device_action, DeviceAction, _DEVICE_ACTION_MAX);
DUMP_STRING_TABLE(device_action, sd_device_action_t, _SD_DEVICE_ACTION_MAX);
}

20
src/libsystemd/sd-device/device-private.h
View File

@ -10,22 +10,8 @@
#include "macro.h"
typedef enum DeviceAction {
DEVICE_ACTION_ADD,
DEVICE_ACTION_REMOVE,
DEVICE_ACTION_CHANGE,
DEVICE_ACTION_MOVE,
DEVICE_ACTION_ONLINE,
DEVICE_ACTION_OFFLINE,
DEVICE_ACTION_BIND,
DEVICE_ACTION_UNBIND,
_DEVICE_ACTION_MAX,
_DEVICE_ACTION_INVALID = -EINVAL,
} DeviceAction;
int device_new_from_nulstr(sd_device **ret, uint8_t *nulstr, size_t len);
int device_new_from_strv(sd_device **ret, char **strv);
int device_new_from_stat_rdev(sd_device **ret, const struct stat *st);
int device_get_id_filename(sd_device *device, const char **ret);
@ -34,8 +20,6 @@ int device_get_watch_handle(sd_device *device, int *handle);
int device_get_devnode_mode(sd_device *device, mode_t *mode);
int device_get_devnode_uid(sd_device *device, uid_t *uid);
int device_get_devnode_gid(sd_device *device, gid_t *gid);
int device_get_action(sd_device *device, DeviceAction *action);
int device_get_seqnum(sd_device *device, uint64_t *seqnum);
void device_seal(sd_device *device);
void device_set_is_initialized(sd_device *device);
@ -73,6 +57,6 @@ static inline int device_read_db(sd_device *device) {
return device_read_db_internal(device, false);
}
DeviceAction device_action_from_string(const char *s) _pure_;
const char *device_action_to_string(DeviceAction a) _const_;
sd_device_action_t device_action_from_string(const char *s) _pure_;
const char *device_action_to_string(sd_device_action_t a) _const_;
void dump_device_action_table(void);

42
src/libsystemd/sd-device/sd-device.c
View File

@ -43,7 +43,7 @@ int device_new_aux(sd_device **ret) {
.devmode = (mode_t) -1,
.devuid = (uid_t) -1,
.devgid = (gid_t) -1,
.action = _DEVICE_ACTION_INVALID,
.action = _SD_DEVICE_ACTION_INVALID,
};
*ret = device;
@ -316,6 +316,22 @@ _public_ int sd_device_new_from_subsystem_sysname(sd_device **ret, const char *s
return -ENODEV;
}
_public_ int sd_device_new_from_stat_rdev(sd_device **ret, const struct stat *st) {
char type;
assert_return(ret, -EINVAL);
assert_return(st, -EINVAL);
if (S_ISBLK(st->st_mode))
type = 'b';
else if (S_ISCHR(st->st_mode))
type = 'c';
else
return -ENOTTY;
return sd_device_new_from_devnum(ret, type, st->st_rdev);
}
int device_set_devtype(sd_device *device, const char *devtype) {
_cleanup_free_ char *t = NULL;
int r;
@ -1052,6 +1068,30 @@ _public_ int sd_device_get_sysnum(sd_device *device, const char **ret) {
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;
}
static bool is_valid_tag(const char *tag) {
assert(tag);

6
src/libudev/libudev-device.c
View File

@ -82,7 +82,7 @@ _public_ unsigned long long udev_device_get_seqnum(struct udev_device *udev_devi
assert_return_errno(udev_device, 0, EINVAL);
if (device_get_seqnum(udev_device->device, &seqnum) < 0)
if (sd_device_get_seqnum(udev_device->device, &seqnum) < 0)
return 0;
return seqnum;
@ -693,11 +693,11 @@ _public_ struct udev_list_entry *udev_device_get_properties_list_entry(struct ud
* Returns: the kernel action value, or #NULL if there is no action value available.
**/
_public_ const char *udev_device_get_action(struct udev_device *udev_device) {
DeviceAction action;
sd_device_action_t action;
assert_return_errno(udev_device, NULL, EINVAL);
if (device_get_action(udev_device->device, &action) < 0)
if (sd_device_get_action(udev_device->device, &action) < 0)
return NULL;
return device_action_to_string(action);

4
src/login/logind-core.c
View File

@ -246,7 +246,7 @@ int manager_process_seat_device(Manager *m, sd_device *d) {
assert(m);
if (device_for_action(d, DEVICE_ACTION_REMOVE) ||
if (device_for_action(d, SD_DEVICE_REMOVE) ||
sd_device_has_current_tag(d, "seat") <= 0) {
const char *syspath;
@ -317,7 +317,7 @@ int manager_process_button_device(Manager *m, sd_device *d) {
if (r < 0)
return r;
if (device_for_action(d, DEVICE_ACTION_REMOVE) ||
if (device_for_action(d, SD_DEVICE_REMOVE) ||
sd_device_has_current_tag(d, "power-switch") <= 0) {
b = hashmap_get(m->buttons, sysname);

2
src/login/logind.c
View File

@ -578,7 +578,7 @@ static int manager_dispatch_vcsa_udev(sd_device_monitor *monitor, sd_device *dev
if (sd_device_get_sysname(device, &name) >= 0 &&
startswith(name, "vcsa") &&
device_for_action(device, DEVICE_ACTION_REMOVE))
device_for_action(device, SD_DEVICE_REMOVE))
seat_preallocate_vts(m->seat0);
return 0;

6
src/network/networkd-manager.c
View File

@ -182,15 +182,15 @@ int manager_connect_bus(Manager *m) {
}
static int manager_udev_process_link(sd_device_monitor *monitor, sd_device *device, void *userdata) {
sd_device_action_t action;
Manager *m = userdata;
DeviceAction action;
Link *link = NULL;
int r, ifindex;
assert(m);
assert(device);
r = device_get_action(device, &action);
r = sd_device_get_action(device, &action);
if (r < 0) {
log_device_debug_errno(device, r, "Failed to get udev action, ignoring device: %m");
return 0;
@ -199,7 +199,7 @@ static int manager_udev_process_link(sd_device_monitor *monitor, sd_device *devi
/* Ignore the "remove" uevent — let's remove a device only if rtnetlink says so. All other uevents
* are "positive" events in some form, i.e. inform us about a changed or new network interface, that
* still exists — and we are interested in that. */
if (action == DEVICE_ACTION_REMOVE)
if (action == SD_DEVICE_REMOVE)
return 0;
r = sd_device_get_ifindex(device, &ifindex);

2
src/shared/dissect-image.c
View File

@ -247,7 +247,7 @@ static int device_monitor_handler(sd_device_monitor *monitor, sd_device *device,
assert(w);
if (device_for_action(device, DEVICE_ACTION_REMOVE))
if (device_for_action(device, SD_DEVICE_REMOVE))
return 0;
r = sd_device_get_parent(device, &pp);

20
src/shared/udev-util.c
View File

@ -7,6 +7,7 @@
#include "alloc-util.h"
#include "device-nodes.h"
#include "device-private.h"
#include "device-util.h"
#include "env-file.h"
#include "escape.h"
@ -175,7 +176,7 @@ static int device_monitor_handler(sd_device_monitor *monitor, sd_device *device,
* (And yes, we only need to special case REMOVE. It's the only "negative" event type, where a device
* ceases to exist. All other event types are "positive": the device exists and is registered in the
* udev database, thus whenever we see the event, we can consider it initialized.) */
if (device_for_action(device, DEVICE_ACTION_REMOVE))
if (device_for_action(device, SD_DEVICE_REMOVE))
return 0;
if (data->sysname && sd_device_get_sysname(device, &sysname) >= 0 && streq(sysname, data->sysname))
@ -318,26 +319,29 @@ int device_is_renaming(sd_device *dev) {
return true;
}
bool device_for_action(sd_device *dev, DeviceAction action) {
DeviceAction a;
bool device_for_action(sd_device *dev, sd_device_action_t a) {
sd_device_action_t b;
assert(dev);
if (device_get_action(dev, &a) < 0)
if (a < 0)
return false;
return a == action;
if (sd_device_get_action(dev, &b) < 0)
return false;
return a == b;
}
void log_device_uevent(sd_device *device, const char *str) {
DeviceAction action = _DEVICE_ACTION_INVALID;
sd_device_action_t action = _SD_DEVICE_ACTION_INVALID;
uint64_t seqnum = 0;
if (!DEBUG_LOGGING)
return;
(void) device_get_seqnum(device, &seqnum);
(void) device_get_action(device, &action);
(void) sd_device_get_seqnum(device, &seqnum);
(void) sd_device_get_action(device, &action);
log_device_debug(device, "%s%s(SEQNUM=%"PRIu64", ACTION=%s)",
strempty(str), isempty(str) ? "" : " ",
seqnum, strna(device_action_to_string(action)));

4
src/shared/udev-util.h
View File

@ -3,7 +3,6 @@
#include "sd-device.h"
#include "device-private.h"
#include "time-util.h"
#define UDEV_NAME_SIZE 512
@ -35,7 +34,8 @@ static inline int udev_parse_config(void) {
int device_wait_for_initialization(sd_device *device, const char *subsystem, usec_t deadline, sd_device **ret);
int device_wait_for_devlink(const char *path, const char *subsystem, usec_t deadline, sd_device **ret);
int device_is_renaming(sd_device *dev);
bool device_for_action(sd_device *dev, DeviceAction action);
bool device_for_action(sd_device *dev, sd_device_action_t action);
void log_device_uevent(sd_device *device, const char *str);

19
src/systemd/sd-device.h
View File

@ -17,7 +17,9 @@
along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/
#include <errno.h>
#include <inttypes.h>
#include <sys/stat.h>
#include <sys/sysmacros.h>
#include <sys/types.h>
@ -31,6 +33,20 @@ typedef struct sd_device sd_device;
typedef struct sd_device_enumerator sd_device_enumerator;
typedef struct sd_device_monitor sd_device_monitor;
typedef enum sd_device_action_t {
SD_DEVICE_ADD,
SD_DEVICE_REMOVE,
SD_DEVICE_CHANGE,
SD_DEVICE_MOVE,
SD_DEVICE_ONLINE,
SD_DEVICE_OFFLINE,
SD_DEVICE_BIND,
SD_DEVICE_UNBIND,
_SD_DEVICE_ACTION_MAX,
_SD_DEVICE_ACTION_INVALID = -EINVAL,
_SD_ENUM_FORCE_S64(DEVICE_ACTION),
} sd_device_action_t;
/* callback */
typedef int (*sd_device_monitor_handler_t)(sd_device_monitor *m, sd_device *device, void *userdata);
@ -44,6 +60,7 @@ int sd_device_new_from_syspath(sd_device **ret, const char *syspath);
int sd_device_new_from_devnum(sd_device **ret, char type, dev_t devnum);
int sd_device_new_from_subsystem_sysname(sd_device **ret, const char *subsystem, const char *sysname);
int sd_device_new_from_device_id(sd_device **ret, const char *id);
int sd_device_new_from_stat_rdev(sd_device **ret, const struct stat *st);
int sd_device_get_parent(sd_device *child, sd_device **ret);
int sd_device_get_parent_with_subsystem_devtype(sd_device *child, const char *subsystem, const char *devtype, sd_device **ret);
@ -58,6 +75,8 @@ int sd_device_get_devpath(sd_device *device, const char **ret);
int sd_device_get_devname(sd_device *device, const char **ret);
int sd_device_get_sysname(sd_device *device, const char **ret);
int sd_device_get_sysnum(sd_device *device, const char **ret);
int sd_device_get_action(sd_device *device, sd_device_action_t *ret);
int sd_device_get_seqnum(sd_device *device, uint64_t *ret);
int sd_device_get_is_initialized(sd_device *device);
int sd_device_get_usec_since_initialized(sd_device *device, uint64_t *usec);

4
src/test/test-tables.c
View File

@ -50,7 +50,7 @@ int main(int argc, char **argv) {
test_table(collect_mode, COLLECT_MODE);
test_table(condition_result, CONDITION_RESULT);
test_table(condition_type, CONDITION_TYPE);
test_table(device_action, DEVICE_ACTION);
test_table(device_action, SD_DEVICE_ACTION);
test_table(device_state, DEVICE_STATE);
test_table(dns_over_tls_mode, DNS_OVER_TLS_MODE);
test_table(dnssec_mode, DNSSEC_MODE);
@ -125,5 +125,7 @@ int main(int argc, char **argv) {
test_table_sparse(object_compressed, OBJECT_COMPRESSED);
assert_cc(sizeof(sd_device_action_t) == sizeof(int64_t));
return EXIT_SUCCESS;
}

1
src/udev/fido_id/fido_id.c
View File

@ -14,7 +14,6 @@
#include <sys/types.h>
#include <unistd.h>
#include "device-internal.h"
#include "device-private.h"
#include "device-util.h"
#include "fd-util.h"

8
src/udev/net/link-config.c
View File

@ -594,7 +594,7 @@ static int link_config_apply_alternative_names(sd_netlink **rtnl, const link_con
int link_config_apply(link_config_ctx *ctx, const link_config *config, sd_device *device, const char **ret_name) {
const char *new_name;
DeviceAction a;
sd_device_action_t a;
int r;
assert(ctx);
@ -602,11 +602,11 @@ int link_config_apply(link_config_ctx *ctx, const link_config *config, sd_device
assert(device);
assert(ret_name);
r = device_get_action(device, &a);
r = sd_device_get_action(device, &a);
if (r < 0)
return log_device_error_errno(device, r, "Failed to get ACTION= property: %m");
if (!IN_SET(a, DEVICE_ACTION_ADD, DEVICE_ACTION_BIND, DEVICE_ACTION_MOVE)) {
if (!IN_SET(a, SD_DEVICE_ADD, SD_DEVICE_BIND, SD_DEVICE_MOVE)) {
log_device_debug(device, "Skipping to apply .link settings on '%s' uevent.", device_action_to_string(a));
r = sd_device_get_sysname(device, ret_name);
@ -624,7 +624,7 @@ int link_config_apply(link_config_ctx *ctx, const link_config *config, sd_device
if (r < 0)
return r;
if (a == DEVICE_ACTION_MOVE) {
if (a == SD_DEVICE_MOVE) {
log_device_debug(device, "Skipping to apply Name= and NamePolicy= on '%s' uevent.", device_action_to_string(a));
r = sd_device_get_sysname(device, &new_name);

12
src/udev/udev-event.c
View File

@ -831,7 +831,7 @@ static int rename_netif(UdevEvent *event) {
if (streq(event->name, oldname))
return 0; /* The interface name is already requested name. */
if (!device_for_action(dev, DEVICE_ACTION_ADD))
if (!device_for_action(dev, SD_DEVICE_ADD))
return 0; /* Rename the interface only when it is added. */
r = sd_device_get_ifindex(dev, &ifindex);
@ -904,7 +904,7 @@ static int update_devnode(UdevEvent *event) {
/* If group is set, but mode is not set, "upgrade" mode for the group. */
event->mode = 0660;
bool apply_mac = device_for_action(dev, DEVICE_ACTION_ADD);
bool apply_mac = device_for_action(dev, SD_DEVICE_ADD);
return udev_node_add(dev, apply_mac, event->mode, event->uid, event->gid, event->seclabel_list);
}
@ -975,7 +975,7 @@ int udev_event_execute_rules(UdevEvent *event,
Hashmap *properties_list,
UdevRules *rules) {
const char *subsystem;
DeviceAction action;
sd_device_action_t action;
sd_device *dev;
int r;
@ -988,11 +988,11 @@ int udev_event_execute_rules(UdevEvent *event,
if (r < 0)
return log_device_error_errno(dev, r, "Failed to get subsystem: %m");
r = device_get_action(dev, &action);
r = sd_device_get_action(dev, &action);
if (r < 0)
return log_device_error_errno(dev, r, "Failed to get ACTION: %m");
if (action == DEVICE_ACTION_REMOVE) {
if (action == SD_DEVICE_REMOVE) {
event_execute_rules_on_remove(event, timeout_usec, timeout_signal, properties_list, rules);
return 0;
}
@ -1009,7 +1009,7 @@ int udev_event_execute_rules(UdevEvent *event,
/* Disable watch during event processing. */
(void) udev_watch_end(event->dev_db_clone);
if (action == DEVICE_ACTION_MOVE) {
if (action == SD_DEVICE_MOVE) {
r = udev_event_on_move(event->dev);
if (r < 0)
return r;

11
src/udev/udev-rules.c
View File

@ -6,6 +6,7 @@
#include "architecture.h"
#include "conf-files.h"
#include "def.h"
#include "device-private.h"
#include "device-util.h"
#include "dirent-util.h"
#include "escape.h"
@ -1545,9 +1546,9 @@ static int udev_rule_apply_token_to_event(
switch (token->type) {
case TK_M_ACTION: {
DeviceAction a;
sd_device_action_t a;
r = device_get_action(dev, &a);
r = sd_device_get_action(dev, &a);
if (r < 0)
return log_rule_error_errno(dev, rules, r, "Failed to get uevent action type: %m");
@ -2226,14 +2227,14 @@ static int udev_rule_apply_line_to_event(
UdevRuleLineType mask = LINE_HAS_GOTO | LINE_UPDATE_SOMETHING;
UdevRuleToken *token, *next_token;
bool parents_done = false;
DeviceAction action;
sd_device_action_t action;
int r;
r = device_get_action(event->dev, &action);
r = sd_device_get_action(event->dev, &action);
if (r < 0)
return r;
if (action != DEVICE_ACTION_REMOVE) {
if (action != SD_DEVICE_REMOVE) {
if (sd_device_get_devnum(event->dev, NULL) >= 0)
mask |= LINE_HAS_DEVLINK;

4
src/udev/udevadm-monitor.c
View File

@ -27,7 +27,7 @@ static Set *arg_tag_filter = NULL;
static Hashmap *arg_subsystem_filter = NULL;
static int device_monitor_handler(sd_device_monitor *monitor, sd_device *device, void *userdata) {
DeviceAction action = _DEVICE_ACTION_INVALID;
sd_device_action_t action = _SD_DEVICE_ACTION_INVALID;
const char *devpath = NULL, *subsystem = NULL;
MonitorNetlinkGroup group = PTR_TO_INT(userdata);
struct timespec ts;
@ -35,7 +35,7 @@ static int device_monitor_handler(sd_device_monitor *monitor, sd_device *device,
assert(device);
assert(IN_SET(group, MONITOR_GROUP_UDEV, MONITOR_GROUP_KERNEL));
(void) device_get_action(device, &action);
(void) sd_device_get_action(device, &action);
(void) sd_device_get_devpath(device, &devpath);
(void) sd_device_get_subsystem(device, &subsystem);

2
src/udev/udevadm-test.c
View File

@ -54,7 +54,7 @@ static int parse_argv(int argc, char *argv[]) {
while ((c = getopt_long(argc, argv, "a:N:Vh", options, NULL)) >= 0)
switch (c) {
case 'a': {
DeviceAction a;
sd_device_action_t a;
if (streq(optarg, "help")) {
dump_device_action_table();

2
src/udev/udevadm-trigger.c
View File

@ -211,7 +211,7 @@ int trigger_main(int argc, char *argv[], void *userdata) {
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Unknown type --type=%s", optarg);
break;
case 'c': {
DeviceAction a;
sd_device_action_t a;
if (streq(optarg, "help")) {
dump_device_action_table();

2
src/udev/udevadm-util.c
View File

@ -20,7 +20,7 @@ static int find_device_from_path(const char *path, sd_device **ret) {
if (stat(path, &st) < 0)
return -errno;
return device_new_from_stat_rdev(ret, &st);
return sd_device_new_from_stat_rdev(ret, &st);
}
return -EINVAL;

18
src/udev/udevd.c
View File

@ -325,16 +325,12 @@ static int worker_lock_block_device(sd_device *dev, int *ret_fd) {
assert(dev);
assert(ret_fd);
/*
* Take a shared lock on the device node; this establishes
* a concept of device "ownership" to serialize device
* access. External processes holding an exclusive lock will
* cause udev to skip the event handling; in the case udev
* acquired the lock, the external process can block until
* udev has finished its event handling.
*/
/* Take a shared lock on the device node; this establishes a concept of device "ownership" to
* serialize device access. External processes holding an exclusive lock will cause udev to skip the
* event handling; in the case udev acquired the lock, the external process can block until udev has
* finished its event handling. */
if (device_for_action(dev, DEVICE_ACTION_REMOVE))
if (device_for_action(dev, SD_DEVICE_REMOVE))
return 0;
r = sd_device_get_subsystem(dev, &val);
@ -392,7 +388,7 @@ static int worker_mark_block_device_read_only(sd_device *dev) {
/* Do this only once, when the block device is new. If the device is later retriggered let's not
* toggle the bit again, so that people can boot up with full read-only mode and then unset the bit
* for specific devices only. */
if (!device_for_action(dev, DEVICE_ACTION_ADD))
if (!device_for_action(dev, SD_DEVICE_ADD))
return 0;
r = sd_device_get_subsystem(dev, &val);
@ -694,7 +690,7 @@ static int event_queue_insert(Manager *manager, sd_device *dev) {
assert(manager->pid == getpid_cached());
/* We only accepts devices received by device monitor. */
r = device_get_seqnum(dev, &seqnum);
r = sd_device_get_seqnum(dev, &seqnum);
if (r < 0)
return r;