picnoir/Systemd
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Merge pull request #10483 from yuwata/udev-cleanup-10

Browse source 
tree-wide: use log_device_*()
This commit is contained in:
Lennart Poettering 2018-10-24 10:51:53 +02:00 committed by GitHub
parent 086712f99f b220632c61
commit 77d28bd10f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
12 changed files with 103 additions and 112 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
src/backlight/backlight.c
View file

@ -216,14 +216,14 @@ static int get_max_brightness(sd_device *device, unsigned *ret) {
r = sd_device_get_sysattr_value(device, "max_brightness", &max_brightness_str);
if (r < 0)
return log_warning_errno(r, "Failed to read 'max_brightness' attribute: %m");
return log_device_warning_errno(device, r, "Failed to read 'max_brightness' attribute: %m");
r = safe_atou(max_brightness_str, &max_brightness);
if (r < 0)
return log_warning_errno(r, "Failed to parse 'max_brightness' \"%s\": %m", max_brightness_str);
return log_device_warning_errno(device, r, "Failed to parse 'max_brightness' \"%s\": %m", max_brightness_str);
if (max_brightness <= 0) {
log_warning("Maximum brightness is 0, ignoring device.");
log_device_warning(device, "Maximum brightness is 0, ignoring device.");
return -EINVAL;
}
@ -246,11 +246,11 @@ static int clamp_brightness(sd_device *device, char **value, unsigned max_bright
r = safe_atou(*value, &brightness);
if (r < 0)
return log_warning_errno(r, "Failed to parse brightness \"%s\": %m", *value);
return log_device_warning_errno(device, r, "Failed to parse brightness \"%s\": %m", *value);
r = sd_device_get_subsystem(device, &subsystem);
if (r < 0)
return log_warning_errno(r, "Failed to get device subsystem: %m");
return log_device_warning_errno(device, r, "Failed to get device subsystem: %m");
if (streq(subsystem, "backlight"))
min_brightness = MAX(1U, max_brightness/20);
@ -265,10 +265,10 @@ static int clamp_brightness(sd_device *device, char **value, unsigned max_bright
if (r < 0)
return log_oom();
log_info("Saved brightness %s %s to %s.", *value,
new_brightness > brightness ?
"too low; increasing" : "too high; decreasing",
new_value);
log_device_info(device, "Saved brightness %s %s to %s.", *value,
new_brightness > brightness ?
"too low; increasing" : "too high; decreasing",
new_value);
free_and_replace(*value, new_value);
}
@ -283,12 +283,14 @@ static bool shall_clamp(sd_device *d) {
assert(d);
r = sd_device_get_property_value(d, "ID_BACKLIGHT_CLAMP", &s);
if (r < 0)
if (r < 0) {
log_device_debug_errno(d, r, "Failed to get ID_BACKLIGHT_CLAMP property, ignoring: %m");
return true;
}
r = parse_boolean(s);
if (r < 0) {
log_debug_errno(r, "Failed to parse ID_BACKLIGHT_CLAMP property, ignoring: %m");
log_device_debug_errno(d, r, "Failed to parse ID_BACKLIGHT_CLAMP property, ignoring: %m");
return true;
}
@ -402,7 +404,7 @@ int main(int argc, char *argv[]) {
r = sd_device_get_sysattr_value(device, "brightness", &curval);
if (r < 0) {
log_warning_errno(r, "Failed to read 'brightness' attribute: %m");
log_device_warning_errno(device, r, "Failed to read 'brightness' attribute: %m");
return EXIT_FAILURE;
}
@ -421,7 +423,7 @@ int main(int argc, char *argv[]) {
r = sd_device_set_sysattr_value(device, "brightness", value);
if (r < 0) {
log_error_errno(r, "Failed to write system 'brightness' attribute: %m");
log_device_error_errno(device, r, "Failed to write system 'brightness' attribute: %m");
return EXIT_FAILURE;
}
@ -435,13 +437,13 @@ int main(int argc, char *argv[]) {
r = sd_device_get_sysattr_value(device, "brightness", &value);
if (r < 0) {
log_error_errno(r, "Failed to read system 'brightness' attribute: %m");
log_device_error_errno(device, r, "Failed to read system 'brightness' attribute: %m");
return EXIT_FAILURE;
}
r = write_string_file(saved, value, WRITE_STRING_FILE_CREATE);
if (r < 0) {
log_error_errno(r, "Failed to write %s: %m", saved);
log_device_error_errno(device, r, "Failed to write %s: %m", saved);
return EXIT_FAILURE;
}

24
src/core/device.c
View file

@ -431,7 +431,7 @@ static bool device_is_bound_by_mounts(Device *d, sd_device *dev) {
if (sd_device_get_property_value(dev, "SYSTEMD_MOUNT_DEVICE_BOUND", &bound_by) >= 0) {
r = parse_boolean(bound_by);
if (r < 0)
log_warning_errno(r, "Failed to parse SYSTEMD_MOUNT_DEVICE_BOUND='%s' udev property of %s, ignoring: %m", bound_by, strna(d->sysfs));
log_device_warning_errno(dev, r, "Failed to parse SYSTEMD_MOUNT_DEVICE_BOUND='%s' udev property, ignoring: %m", bound_by);
d->bind_mounts = r > 0;
} else
@ -471,14 +471,14 @@ static int device_setup_unit(Manager *m, sd_device *dev, const char *path, bool
if (dev) {
r = sd_device_get_syspath(dev, &sysfs);
if (r < 0) {
log_debug_errno(r, "Couldn't get syspath from device, ignoring: %m");
log_device_debug_errno(dev, r, "Couldn't get syspath from device, ignoring: %m");
return 0;
}
}
r = unit_name_from_path(path, ".device", &e);
if (r < 0)
return log_error_errno(r, "Failed to generate unit name from device path: %m");
return log_device_error_errno(dev, r, "Failed to generate unit name from device path: %m");
u = manager_get_unit(m, e);
if (u) {
@ -509,7 +509,7 @@ static int device_setup_unit(Manager *m, sd_device *dev, const char *path, bool
r = unit_new_for_name(m, sizeof(Device), e, &u);
if (r < 0) {
log_error_errno(r, "Failed to allocate device unit %s: %m", e);
log_device_error_errno(dev, r, "Failed to allocate device unit %s: %m", e);
goto fail;
}
@ -521,7 +521,7 @@ static int device_setup_unit(Manager *m, sd_device *dev, const char *path, bool
if (sysfs) {
r = device_set_sysfs(DEVICE(u), sysfs);
if (r < 0) {
log_error_errno(r, "Failed to set sysfs path %s for device unit %s: %m", sysfs, e);
log_unit_error_errno(u, r, "Failed to set sysfs path %s: %m", sysfs);
goto fail;
}
@ -608,12 +608,12 @@ static int device_process_new(Manager *m, sd_device *dev) {
if (r == -ENOMEM)
return log_oom();
if (r < 0)
return log_warning_errno(r, "Failed to add parse SYSTEMD_ALIAS for %s: %m", sysfs);
return log_device_warning_errno(dev, r, "Failed to add parse SYSTEMD_ALIAS property: %m");
if (!path_is_absolute(word))
log_warning("SYSTEMD_ALIAS for %s is not an absolute path, ignoring: %s", sysfs, word);
log_device_warning(dev, "SYSTEMD_ALIAS is not an absolute path, ignoring: %s", word);
else if (!path_is_normalized(word))
log_warning("SYSTEMD_ALIAS for %s is not a normalized path, ignoring: %s", sysfs, word);
log_device_warning(dev, "SYSTEMD_ALIAS is not a normalized path, ignoring: %s", word);
else
(void) device_setup_unit(m, dev, word, false);
}
@ -874,13 +874,13 @@ static int device_dispatch_io(sd_device_monitor *monitor, sd_device *dev, void *
r = sd_device_get_syspath(dev, &sysfs);
if (r < 0) {
log_error_errno(r, "Failed to get device sys path: %m");
log_device_error_errno(dev, r, "Failed to get device sys path: %m");
return 0;
}
r = sd_device_get_property_value(dev, "ACTION", &action);
if (r < 0) {
log_error_errno(r, "Failed to get udev action string: %m");
log_device_error_errno(dev, r, "Failed to get udev action string: %m");
return 0;
}
@ -893,7 +893,7 @@ static int device_dispatch_io(sd_device_monitor *monitor, sd_device *dev, void *
if (streq(action, "remove")) {
r = swap_process_device_remove(m, dev);
if (r < 0)
log_warning_errno(r, "Failed to process swap device remove event, ignoring: %m");
log_device_warning_errno(dev, r, "Failed to process swap device remove event, ignoring: %m");
/* If we get notified that a device was removed by
* udev, then it's completely gone, hence unset all
@ -906,7 +906,7 @@ static int device_dispatch_io(sd_device_monitor *monitor, sd_device *dev, void *
r = swap_process_device_new(m, dev);
if (r < 0)
log_warning_errno(r, "Failed to process swap device new event, ignoring: %m");
log_device_warning_errno(dev, r, "Failed to process swap device new event, ignoring: %m");
manager_dispatch_load_queue(m);

6
src/fsck/fsck.c
View file

@ -347,7 +347,7 @@ int main(int argc, char *argv[]) {
r = sd_device_get_devname(dev, &device);
if (r < 0) {
log_error_errno(r, "Failed to detect device node of root directory: %m");
log_device_error_errno(dev, r, "Failed to detect device node of root directory: %m");
goto finish;
}
@ -357,9 +357,9 @@ int main(int argc, char *argv[]) {
if (sd_device_get_property_value(dev, "ID_FS_TYPE", &type) >= 0) {
r = fsck_exists(type);
if (r < 0)
log_warning_errno(r, "Couldn't detect if fsck.%s may be used for %s, proceeding: %m", type, device);
log_device_warning_errno(dev, r, "Couldn't detect if fsck.%s may be used, proceeding: %m", type);
else if (r == 0) {
log_info("fsck.%s doesn't exist, not checking file system on %s.", type, device);
log_device_info(dev, "fsck.%s doesn't exist, not checking file system.", type);
goto finish;
}
}

15
src/gpt-auto-generator/gpt-auto-generator.c
View file

@ -12,6 +12,7 @@
#include "blkid-util.h"
#include "blockdev-util.h"
#include "btrfs-util.h"
#include "device-util.h"
#include "dirent-util.h"
#include "dissect-image.h"
#include "efivars.h"
@ -461,42 +462,42 @@ static int open_parent(dev_t devnum, int *ret) {
if (sd_device_get_devname(d, &name) < 0) {
r = sd_device_get_syspath(d, &name);
if (r < 0) {
log_debug_errno(r, "Device %u:%u does not have a name, ignoring: %m", major(devnum), minor(devnum));
log_device_debug_errno(d, r, "Device %u:%u does not have a name, ignoring: %m", major(devnum), minor(devnum));
return 0;
}
}
r = sd_device_get_parent(d, &parent);
if (r < 0) {
log_debug_errno(r, "%s: not a partitioned device, ignoring: %m", name);
log_device_debug_errno(d, r, "Not a partitioned device, ignoring: %m");
return 0;
}
/* Does it have a devtype? */
r = sd_device_get_devtype(parent, &devtype);
if (r < 0) {
log_debug_errno(r, "%s: parent doesn't have a device type, ignoring: %m", name);
log_device_debug_errno(parent, r, "Parent doesn't have a device type, ignoring: %m");
return 0;
}
/* Is this a disk or a partition? We only care for disks... */
if (!streq(devtype, "disk")) {
log_debug("%s: parent isn't a raw disk, ignoring.", name);
log_device_debug(parent, "Parent isn't a raw disk, ignoring.");
return 0;
}
/* Does it have a device node? */
r = sd_device_get_devname(parent, &node);
if (r < 0) {
log_debug_errno(r, "%s: parent device does not have device node, ignoring: %m", name);
log_device_debug_errno(parent, r, "Parent device does not have device node, ignoring: %m");
return 0;
}
log_debug("%s: root device %s.", name, node);
log_device_debug(d, "Root device %s.", node);
r = sd_device_get_devnum(parent, &pn);
if (r < 0) {
log_debug_errno(r, "%s: parent device is not a proper block device, ignoring: %m", name);
log_device_debug_errno(parent, r, "Parent device is not a proper block device, ignoring: %m");
return 0;
}

13
src/libsystemd/sd-device/device-monitor.c
View file

@ -454,10 +454,9 @@ int device_monitor_receive_device(sd_device_monitor *m, sd_device **ret) {
/* Skip device, if it does not pass the current filter */
r = passes_filter(m, device);
if (r < 0)
return log_debug_errno(r, "Failed to check received device passing filter: %m");
return log_device_debug_errno(device, r, "Failed to check received device passing filter: %m");
if (r == 0)
log_debug("Received device does not pass filter, ignoring");
log_device_debug(device, "Received device does not pass filter, ignoring");
else
*ret = TAKE_PTR(device);
@ -522,7 +521,7 @@ int device_monitor_send_device(
/* fill in versioned header */
r = sd_device_get_subsystem(device, &val);
if (r < 0)
return log_debug_errno(r, "Failed to get device subsystem: %m");
return log_device_debug_errno(device, r, "Failed to get device subsystem: %m");
nlh.filter_subsystem_hash = htobe32(string_hash32(val));
if (sd_device_get_devtype(device, &val) >= 0)
@ -557,13 +556,13 @@ int device_monitor_send_device(
count = sendmsg(m->sock, &smsg, 0);
if (count < 0) {
if (!destination && errno == ECONNREFUSED) {
log_debug("Passed device to netlink monitor");
log_device_debug(device, "Passed to netlink monitor");
return 0;
} else
return log_debug_errno(errno, "Failed to send device to netlink monitor: %m");
return log_device_debug_errno(device, errno, "Failed to send device to netlink monitor: %m");
}
log_debug("Passed %zi byte device to netlink monitor", count);
log_device_debug(device, "Passed %zi byte to netlink monitor", count);
return count;
}

2
src/login/logind-acl.c
View file

@ -206,7 +206,7 @@ int devnode_acl_all(const char *seat,
if (sd_device_get_devname(d, &node) < 0)
continue;
log_debug("Found udev node %s for seat %s", node, seat);
log_device_debug(d, "Found udev node %s for seat %s", node, seat);
r = set_put_strdup(nodes, node);
if (r < 0)
return r;

2
src/login/logind-core.c
View file

@ -268,7 +268,7 @@ int manager_process_seat_device(Manager *m, sd_device *d) {
sn = "seat0";
if (!seat_name_is_valid(sn)) {
log_warning("Device with invalid seat name %s found, ignoring.", sn);
log_device_warning(d, "Device with invalid seat name %s found, ignoring.", sn);
return 0;
}

6
src/mount/mount-tool.c
View file

@ -944,10 +944,10 @@ static int umount_by_device(sd_bus *bus, const char *what) {
r = sd_device_get_property_value(d, "ID_FS_USAGE", &v);
if (r < 0)
return log_error_errno(r, "Failed to get device property: %m");
return log_device_error_errno(d, r, "Failed to get device property: %m");
if (!streq(v, "filesystem")) {
log_error("%s does not contain a known file system.", what);
log_device_error(d, "%s does not contain a known file system.", what);
return -EINVAL;
}
@ -1285,7 +1285,7 @@ static int discover_loop_backing_file(void) {
return log_error_errno(r, "Failed to get device from device number: %m");
if (sd_device_get_property_value(d, "ID_FS_USAGE", &v) < 0 || !streq(v, "filesystem")) {
log_error("%s does not contain a known file system.", arg_mount_what);
log_device_error(d, "%s does not contain a known file system.", arg_mount_what);
return -EINVAL;
}

5
src/rfkill/rfkill.c
View file

@ -7,6 +7,7 @@
#include "sd-device.h"
#include "alloc-util.h"
#include "device-util.h"
#include "escape.h"
#include "fd-util.h"
#include "fileio.h"
@ -73,9 +74,9 @@ static int find_device(
r = sd_device_get_sysattr_value(device, "name", &name);
if (r < 0)
return log_debug_errno(r, "Device has no name, ignoring: %m");
return log_device_debug_errno(device, r, "Device has no name, ignoring: %m");
log_debug("Operating on rfkill device '%s'.", name);
log_device_debug(device, "Operating on rfkill device '%s'.", name);
*ret = TAKE_PTR(device);
return 0;

5
src/udev/net/link-config.c
View file

@ -8,6 +8,7 @@
#include "alloc-util.h"
#include "conf-files.h"
#include "conf-parser.h"
#include "device-util.h"
#include "ethtool-util.h"
#include "fd-util.h"
#include "link-config.h"
@ -410,9 +411,9 @@ int link_config_apply(link_config_ctx *ctx, link_config *config,
r = sd_device_get_ifindex(device, &ifindex);
if (r < 0)
return log_warning_errno(r, "Could not find ifindex: %m");
return log_device_warning_errno(device, r, "Could not find ifindex: %m");
if (ifindex <= 0)
return log_warning_errno(EINVAL, "Invalid ifindex '%d'", ifindex);
return log_device_warning_errno(device, EINVAL, "Invalid ifindex '%d'", ifindex);
if (ctx->enable_name_policy && config->name_policy) {
NamePolicy *policy;

77
src/udev/udev-node.c
View file

@ -42,26 +42,26 @@ static int node_symlink(sd_device *dev, const char *node, const char *slink) {
/* use relative link */
r = path_make_relative(slink_dirname, node, &target);
if (r < 0)
return log_error_errno(r, "Failed to get relative path from '%s' to '%s': %m", slink, node);
return log_device_error_errno(dev, r, "Failed to get relative path from '%s' to '%s': %m", slink, node);
/* preserve link with correct target, do not replace node of other device */
if (lstat(slink, &stats) == 0) {
if (S_ISBLK(stats.st_mode) || S_ISCHR(stats.st_mode)) {
log_error("Conflicting device node '%s' found, link to '%s' will not be created.", slink, node);
log_device_error(dev, "Conflicting device node '%s' found, link to '%s' will not be created.", slink, node);
return -EOPNOTSUPP;
} else if (S_ISLNK(stats.st_mode)) {
_cleanup_free_ char *buf = NULL;
if (readlink_malloc(slink, &buf) >= 0 &&
streq(target, buf)) {
log_debug("Preserve already existing symlink '%s' to '%s'", slink, target);
log_device_debug(dev, "Preserve already existing symlink '%s' to '%s'", slink, target);
(void) label_fix(slink, LABEL_IGNORE_ENOENT);
(void) utimensat(AT_FDCWD, slink, NULL, AT_SYMLINK_NOFOLLOW);
return 0;
}
}
} else {
log_debug("Creating symlink '%s' to '%s'", slink, target);
log_device_debug(dev, "Creating symlink '%s' to '%s'", slink, target);
do {
r = mkdir_parents_label(slink, 0755);
if (!IN_SET(r, 0, -ENOENT))
@ -75,10 +75,10 @@ static int node_symlink(sd_device *dev, const char *node, const char *slink) {
return 0;
}
log_debug("Atomically replace '%s'", slink);
log_device_debug(dev, "Atomically replace '%s'", slink);
r = device_get_id_filename(dev, &id_filename);
if (r < 0)
return log_error_errno(r, "Failed to get id_filename: %m");
return log_device_error_errno(dev, r, "Failed to get id_filename: %m");
slink_tmp = strjoina(slink, ".tmp-", id_filename);
(void) unlink(slink_tmp);
do {
@ -91,10 +91,10 @@ static int node_symlink(sd_device *dev, const char *node, const char *slink) {
mac_selinux_create_file_clear();
} while (r == -ENOENT);
if (r < 0)
return log_error_errno(r, "Failed to create symlink '%s' to '%s': %m", slink_tmp, target);
return log_device_error_errno(dev, r, "Failed to create symlink '%s' to '%s': %m", slink_tmp, target);
if (rename(slink_tmp, slink) < 0) {
r = log_error_errno(errno, "Failed to rename '%s' to '%s' failed: %m", slink_tmp, slink);
r = log_device_error_errno(dev, errno, "Failed to rename '%s' to '%s' failed: %m", slink_tmp, slink);
(void) unlink(slink_tmp);
}
@ -148,7 +148,7 @@ static int link_find_prioritized(sd_device *dev, bool add, const char *stackdir,
if (dent->d_name[0] == '.')
continue;
log_debug("Found '%s' claiming '%s'", dent->d_name, stackdir);
log_device_debug(dev, "Found '%s' claiming '%s'", dent->d_name, stackdir);
if (device_get_id_filename(dev, &id_filename) < 0)
continue;
@ -169,12 +169,7 @@ static int link_find_prioritized(sd_device *dev, bool add, const char *stackdir,
if (target && db_prio <= priority)
continue;
if (DEBUG_LOGGING) {
const char *syspath = NULL;
(void) sd_device_get_syspath(dev_db, &syspath);
log_debug("Device '%s' claims priority %i for '%s'", strnull(syspath), db_prio, stackdir);
}
log_device_debug(dev_db, "Device claims priority %i for '%s'", db_prio, stackdir);
r = free_and_strdup(&target, devnode);
if (r < 0)
@ -198,7 +193,7 @@ static int link_update(sd_device *dev, const char *slink, bool add) {
r = device_get_id_filename(dev, &id_filename);
if (r < 0)
return log_debug_errno(r, "Failed to get id_filename: %m");
return log_device_debug_errno(dev, r, "Failed to get id_filename: %m");
util_path_encode(slink + STRLEN("/dev"), name_enc, sizeof(name_enc));
dirname = path_join(NULL, "/run/udev/links/", name_enc);
@ -213,11 +208,11 @@ static int link_update(sd_device *dev, const char *slink, bool add) {
r = link_find_prioritized(dev, add, dirname, &target);
if (r < 0) {
log_debug("No reference left, removing '%s'", slink);
log_device_debug(dev, "No reference left, removing '%s'", slink);
if (unlink(slink) == 0)
(void) rmdir_parents(slink, "/");
} else {
log_debug("Creating link '%s' to '%s'", slink, target);
log_device_debug(dev, "Creating link '%s' to '%s'", slink, target);
(void) node_symlink(dev, target, slink);
}
@ -245,7 +240,7 @@ int udev_node_update_old_links(sd_device *dev, sd_device *dev_old) {
r = sd_device_get_devpath(dev, &devpath);
if (r < 0)
return log_debug_errno(r, "Failed to get devpath: %m");
return log_device_debug_errno(dev, r, "Failed to get devpath: %m");
/* update possible left-over symlinks */
FOREACH_DEVICE_DEVLINK(dev_old, name) {
@ -262,8 +257,8 @@ int udev_node_update_old_links(sd_device *dev, sd_device *dev_old) {
if (found)
continue;
log_debug("Updating old name, '%s' no longer belonging to '%s'",
name, devpath);
log_device_debug(dev, "Updating old name, '%s' no longer belonging to '%s'",
name, devpath);
link_update(dev, name, false);
}
@ -282,13 +277,13 @@ static int node_permissions_apply(sd_device *dev, bool apply,
r = sd_device_get_devname(dev, &devnode);
if (r < 0)
return log_debug_errno(r, "Failed to get devname: %m");
return log_device_debug_errno(dev, r, "Failed to get devname: %m");
r = sd_device_get_subsystem(dev, &subsystem);
if (r < 0)
return log_debug_errno(r, "Failed to get subsystem: %m");
return log_device_debug_errno(dev, r, "Failed to get subsystem: %m");
r = sd_device_get_devnum(dev, &devnum);
if (r < 0)
return log_debug_errno(r, "Failed to get devnum: %m");
return log_device_debug_errno(dev, r, "Failed to get devnum: %m");
(void) device_get_id_filename(dev, &id_filename);
if (streq(subsystem, "block"))
@ -297,11 +292,11 @@ static int node_permissions_apply(sd_device *dev, bool apply,
mode |= S_IFCHR;
if (lstat(devnode, &stats) < 0)
return log_debug_errno(errno, "cannot stat() node '%s' (%m)", devnode);
return log_device_debug_errno(dev, errno, "cannot stat() node '%s' (%m)", devnode);
if (((stats.st_mode & S_IFMT) != (mode & S_IFMT)) || (stats.st_rdev != devnum))
return log_debug_errno(EEXIST, "Found node '%s' with non-matching devnum %s, skip handling",
devnode, id_filename);
return log_device_debug_errno(dev, EEXIST, "Found node '%s' with non-matching devnum %s, skip handling",
devnode, id_filename);
if (apply) {
bool selinux = false, smack = false;
@ -309,13 +304,13 @@ static int node_permissions_apply(sd_device *dev, bool apply,
Iterator i;
if ((stats.st_mode & 0777) != (mode & 0777) || stats.st_uid != uid || stats.st_gid != gid) {
log_debug("Setting permissions %s, %#o, uid=%u, gid=%u", devnode, mode, uid, gid);
log_device_debug(dev, "Setting permissions %s, %#o, uid=%u, gid=%u", devnode, mode, uid, gid);
if (chmod(devnode, mode) < 0)
r = log_warning_errno(errno, "Failed to set mode of %s to %#o: %m", devnode, mode);
r = log_device_warning_errno(dev, errno, "Failed to set mode of %s to %#o: %m", devnode, mode);
if (chown(devnode, uid, gid) < 0)
r = log_warning_errno(errno, "Failed to set owner of %s to uid=%u, gid=%u: %m", devnode, uid, gid);
r = log_device_warning_errno(dev, errno, "Failed to set owner of %s to uid=%u, gid=%u: %m", devnode, uid, gid);
} else
log_debug("Preserve permissions of %s, %#o, uid=%u, gid=%u", devnode, mode, uid, gid);
log_device_debug(dev, "Preserve permissions of %s, %#o, uid=%u, gid=%u", devnode, mode, uid, gid);
/* apply SECLABEL{$module}=$label */
HASHMAP_FOREACH_KEY(label, name, seclabel_list, i) {
@ -326,21 +321,21 @@ static int node_permissions_apply(sd_device *dev, bool apply,
q = mac_selinux_apply(devnode, label);
if (q < 0)
log_error_errno(q, "SECLABEL: failed to set SELinux label '%s': %m", label);
log_device_error_errno(dev, q, "SECLABEL: failed to set SELinux label '%s': %m", label);
else
log_debug("SECLABEL: set SELinux label '%s'", label);
log_device_debug(dev, "SECLABEL: set SELinux label '%s'", label);
} else if (streq(name, "smack")) {
smack = true;
q = mac_smack_apply(devnode, SMACK_ATTR_ACCESS, label);
if (q < 0)
log_error_errno(q, "SECLABEL: failed to set SMACK label '%s': %m", label);
log_device_error_errno(dev, q, "SECLABEL: failed to set SMACK label '%s': %m", label);
else
log_debug("SECLABEL: set SMACK label '%s'", label);
log_device_debug(dev, "SECLABEL: set SMACK label '%s'", label);
} else
log_error("SECLABEL: unknown subsystem, ignoring '%s'='%s'", name, label);
log_device_error(dev, "SECLABEL: unknown subsystem, ignoring '%s'='%s'", name, label);
}
/* set the defaults */
@ -395,14 +390,14 @@ int udev_node_add(sd_device *dev, bool apply,
r = sd_device_get_devname(dev, &devnode);
if (r < 0)
return log_debug_errno(r, "Failed to get devnode: %m");
return log_device_debug_errno(dev, r, "Failed to get devnode: %m");
if (DEBUG_LOGGING) {
const char *id_filename = NULL;
(void) device_get_id_filename(dev, &id_filename);
log_debug("Handling device node '%s', devnum=%s, mode=%#o, uid="UID_FMT", gid="GID_FMT,
devnode, strnull(id_filename), mode, uid, gid);
log_device_debug(dev, "Handling device node '%s', devnum=%s, mode=%#o, uid="UID_FMT", gid="GID_FMT,
devnode, strnull(id_filename), mode, uid, gid);
}
r = node_permissions_apply(dev, apply, mode, uid, gid, seclabel_list);
@ -411,7 +406,7 @@ int udev_node_add(sd_device *dev, bool apply,
r = xsprintf_dev_num_path_from_sd_device(dev, &filename);
if (r < 0)
return log_debug_errno(r, "Failed to get device path: %m");
return log_device_debug_errno(dev, r, "Failed to get device path: %m");
/* always add /dev/{block,char}/$major:$minor */
(void) node_symlink(dev, devnode, filename);
@ -436,7 +431,7 @@ int udev_node_remove(sd_device *dev) {
r = xsprintf_dev_num_path_from_sd_device(dev, &filename);
if (r < 0)
return log_debug_errno(r, "Failed to get device path: %m");
return log_device_debug_errno(dev, r, "Failed to get device path: %m");
/* remove /dev/{block,char}/$major:$minor */
(void) unlink(filename);

28
src/udev/udev-watch.c
View file

@ -9,6 +9,7 @@
#include "alloc-util.h"
#include "device-private.h"
#include "device-util.h"
#include "dirent-util.h"
#include "fs-util.h"
#include "mkdir.h"
@ -67,12 +68,7 @@ int udev_watch_restore(void) {
goto unlink;
}
if (DEBUG_LOGGING) {
const char *devnode = NULL;
(void) sd_device_get_devname(dev, &devnode);
log_debug("Restoring old watch on '%s'", strnull(devnode));
}
log_device_debug(dev, "Restoring old watch");
(void) udev_watch_begin(dev);
unlink:
(void) unlinkat(dirfd(dir), ent->d_name, 0);
@ -94,49 +90,45 @@ int udev_watch_begin(sd_device *dev) {
r = sd_device_get_devname(dev, &devnode);
if (r < 0)
return log_error_errno(r, "Failed to get device name: %m");
return log_device_error_errno(dev, r, "Failed to get device name: %m");
log_debug("Adding watch on '%s'", devnode);
log_device_debug(dev, "Adding watch on '%s'", devnode);
wd = inotify_add_watch(inotify_fd, devnode, IN_CLOSE_WRITE);
if (wd < 0)
return log_error_errno(errno, "Failed to add device '%s' to watch: %m", devnode);
return log_device_error_errno(dev, errno, "Failed to add device '%s' to watch: %m", devnode);
device_set_watch_handle(dev, wd);
xsprintf(filename, "/run/udev/watch/%d", wd);
r = mkdir_parents(filename, 0755);
if (r < 0)
return log_error_errno(r, "Failed to create parent directory of '%s': %m", filename);
return log_device_error_errno(dev, r, "Failed to create parent directory of '%s': %m", filename);
(void) unlink(filename);
r = device_get_id_filename(dev, &id_filename);
if (r < 0)
return log_error_errno(r, "Failed to get device id-filename: %m");
return log_device_error_errno(dev, r, "Failed to get device id-filename: %m");
if (symlink(id_filename, filename) < 0)
return log_error_errno(errno, "Failed to create symlink %s: %m", filename);
return log_device_error_errno(dev, errno, "Failed to create symlink %s: %m", filename);
return 0;
}
int udev_watch_end(sd_device *dev) {
char filename[STRLEN("/run/udev/watch/") + DECIMAL_STR_MAX(int)];
const char *name = NULL;
int wd, r;
if (inotify_fd < 0)
return log_error_errno(EINVAL, "Invalid inotify descriptor.");
if (sd_device_get_devname(dev, &name) < 0)
(void) sd_device_get_syspath(dev, &name);
r = device_get_watch_handle(dev, &wd);
if (r == -ENOENT)
return 0;
if (r < 0)
return log_error_errno(r, "Failed to get watch handle for device '%s', ignoring: %m", strnull(name));
return log_device_error_errno(dev, r, "Failed to get watch handle, ignoring: %m");
log_debug("Removing watch on '%s'", strnull(name));
log_device_debug(dev, "Removing watch");
(void) inotify_rm_watch(inotify_fd, wd);
xsprintf(filename, "/run/udev/watch/%d", wd);