2003-07-21 05:48:48 +02:00
|
|
|
/*
|
2013-01-27 21:46:36 +01:00
|
|
|
* Copyright (C) 2003-2013 Kay Sievers <kay@vrfy.org>
|
2003-07-21 05:48:48 +02:00
|
|
|
*
|
2008-09-10 02:40:42 +02:00
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
2003-07-21 05:48:48 +02:00
|
|
|
*
|
2008-09-10 02:40:42 +02:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
2003-07-21 05:48:48 +02:00
|
|
|
*/
|
|
|
|
|
priority based symlink handling
Symlinks can have priorities now, the priority is assigned to the device
and specified with OPTIONS="link_priority=100". Devices with higher
priorities overwrite the symlinks of devices with lower priorities.
If the device, that currently owns the link goes away, the symlink
will be removed, and recreated, pointing to the next device with the
highest actual priority.
This should solve the issue, that inserting an USB-stick may overwrite the
/dev/disk/by-id/-link of another disk, and removes the entire link after the
USB-stick is disconnected. If no priorities are specified, the new link will
overwrite the current one, and if the device goes away, it will restore
the old link. It should be possible to assign lower priorities to removable
devices, if needed.
In multipath setups, we see several devices, which all connect to the same
volume, and therefore all try to create the same metadata-links. The
different path-devices are combined into one device-mapper device, which also
contains the same metadata. It should be possible, to assign multipath-table
device-mapper devices a higher priority, so path-devices that appear and
disappear, will not overwrite or delete the device-mapper device links.
2007-03-18 12:51:57 +01:00
|
|
|
#include <dirent.h>
|
2015-10-24 22:58:24 +02:00
|
|
|
#include <errno.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <stdbool.h>
|
|
|
|
#include <stddef.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
2003-10-23 04:39:54 +02:00
|
|
|
#include <sys/stat.h>
|
2015-10-24 22:58:24 +02:00
|
|
|
#include <unistd.h>
|
2003-07-21 05:48:48 +02:00
|
|
|
|
2015-04-10 20:43:52 +02:00
|
|
|
#include "formats-util.h"
|
2015-10-26 21:16:26 +01:00
|
|
|
#include "fs-util.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "selinux-util.h"
|
|
|
|
#include "smack-util.h"
|
2016-01-12 15:34:20 +01:00
|
|
|
#include "stdio-util.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "string-util.h"
|
|
|
|
#include "udev.h"
|
2004-10-06 08:39:05 +02:00
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
static int node_symlink(struct udev_device *dev, const char *node, const char *slink) {
|
2012-01-10 01:34:15 +01:00
|
|
|
struct stat stats;
|
|
|
|
char target[UTIL_PATH_SIZE];
|
|
|
|
char *s;
|
|
|
|
size_t l;
|
udev: use unique names for temporary files created in /dev
On Tue, Feb 12, 2013 at 2:18 PM, Robert Milasan <rmilasan@suse.com> wrote:
> Under some circumstances udev mixed with multipath fails:
>
> udevd-work[1376]:
> symlink(../../sdk, /dev/disk/by-id/scsi-36005076305ffc0670000000000002842.udev-tmp)
> failed: File exists udevd-work[1432]:
> rename(/dev/disk/by-id/scsi-36005076305ffc0850000000000000a88.udev-tmp, /dev/disk/by-id/scsi-36005076305ffc0850000000000000a88)
> failed: No such file or directory
>
> This is non-fatal, but there is no point of created the symlink or
> renaming the symlink if it already exists.
>
> Reference: https://bugzilla.novell.com/show_bug.cgi?id=791503
It looke like this now:
stat("/dev/disk/by-id", {st_mode=S_IFDIR|0755, st_size=80, ...}) = 0
symlink("../../sda", "/dev/disk/by-id/ata-INTEL...N.tmp-b8:0") = 0
rename("/dev/disk/by-id/ata-INTEL...N.tmp-b8:0", "/dev/disk/by-id/ata-INTEL...N") = 0
2013-02-12 16:03:45 +01:00
|
|
|
char slink_tmp[UTIL_PATH_SIZE + 32];
|
2012-01-10 01:34:15 +01:00
|
|
|
int i = 0;
|
|
|
|
int tail = 0;
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
/* use relative link */
|
|
|
|
target[0] = '\0';
|
|
|
|
while (node[i] && (node[i] == slink[i])) {
|
|
|
|
if (node[i] == '/')
|
|
|
|
tail = i+1;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
s = target;
|
|
|
|
l = sizeof(target);
|
|
|
|
while (slink[i] != '\0') {
|
|
|
|
if (slink[i] == '/')
|
2013-01-09 19:06:46 +01:00
|
|
|
l = strpcpy(&s, l, "../");
|
2012-01-10 01:34:15 +01:00
|
|
|
i++;
|
|
|
|
}
|
2013-01-09 19:06:46 +01:00
|
|
|
l = strscpy(s, l, &node[tail]);
|
2012-01-10 01:34:15 +01:00
|
|
|
if (l == 0) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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)) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_error("conflicting device node '%s' found, link to '%s' will not be created", slink, node);
|
2012-07-09 18:13:41 +02:00
|
|
|
goto exit;
|
2012-01-10 01:34:15 +01:00
|
|
|
} else if (S_ISLNK(stats.st_mode)) {
|
|
|
|
char buf[UTIL_PATH_SIZE];
|
|
|
|
int len;
|
|
|
|
|
|
|
|
len = readlink(slink, buf, sizeof(buf));
|
|
|
|
if (len > 0 && len < (int)sizeof(buf)) {
|
|
|
|
buf[len] = '\0';
|
2013-02-13 18:13:22 +01:00
|
|
|
if (streq(target, buf)) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("preserve already existing symlink '%s' to '%s'", slink, target);
|
2012-07-03 16:25:50 +02:00
|
|
|
label_fix(slink, true, false);
|
2012-01-10 01:34:15 +01:00
|
|
|
utimensat(AT_FDCWD, slink, NULL, AT_SYMLINK_NOFOLLOW);
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("creating symlink '%s' to '%s'", slink, target);
|
2012-01-10 01:34:15 +01:00
|
|
|
do {
|
2012-05-31 12:40:20 +02:00
|
|
|
err = mkdir_parents_label(slink, 0755);
|
2012-01-10 01:34:15 +01:00
|
|
|
if (err != 0 && err != -ENOENT)
|
|
|
|
break;
|
2014-10-23 19:41:27 +02:00
|
|
|
mac_selinux_create_file_prepare(slink, S_IFLNK);
|
2012-01-10 01:34:15 +01:00
|
|
|
err = symlink(target, slink);
|
|
|
|
if (err != 0)
|
|
|
|
err = -errno;
|
2014-10-23 19:41:27 +02:00
|
|
|
mac_selinux_create_file_clear();
|
2012-01-10 01:34:15 +01:00
|
|
|
} while (err == -ENOENT);
|
|
|
|
if (err == 0)
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("atomically replace '%s'", slink);
|
udev: use unique names for temporary files created in /dev
On Tue, Feb 12, 2013 at 2:18 PM, Robert Milasan <rmilasan@suse.com> wrote:
> Under some circumstances udev mixed with multipath fails:
>
> udevd-work[1376]:
> symlink(../../sdk, /dev/disk/by-id/scsi-36005076305ffc0670000000000002842.udev-tmp)
> failed: File exists udevd-work[1432]:
> rename(/dev/disk/by-id/scsi-36005076305ffc0850000000000000a88.udev-tmp, /dev/disk/by-id/scsi-36005076305ffc0850000000000000a88)
> failed: No such file or directory
>
> This is non-fatal, but there is no point of created the symlink or
> renaming the symlink if it already exists.
>
> Reference: https://bugzilla.novell.com/show_bug.cgi?id=791503
It looke like this now:
stat("/dev/disk/by-id", {st_mode=S_IFDIR|0755, st_size=80, ...}) = 0
symlink("../../sda", "/dev/disk/by-id/ata-INTEL...N.tmp-b8:0") = 0
rename("/dev/disk/by-id/ata-INTEL...N.tmp-b8:0", "/dev/disk/by-id/ata-INTEL...N") = 0
2013-02-12 16:03:45 +01:00
|
|
|
strscpyl(slink_tmp, sizeof(slink_tmp), slink, ".tmp-", udev_device_get_id_filename(dev), NULL);
|
2012-01-10 01:34:15 +01:00
|
|
|
unlink(slink_tmp);
|
|
|
|
do {
|
2012-05-31 12:40:20 +02:00
|
|
|
err = mkdir_parents_label(slink_tmp, 0755);
|
2012-01-10 01:34:15 +01:00
|
|
|
if (err != 0 && err != -ENOENT)
|
|
|
|
break;
|
2014-10-23 19:41:27 +02:00
|
|
|
mac_selinux_create_file_prepare(slink_tmp, S_IFLNK);
|
2012-01-10 01:34:15 +01:00
|
|
|
err = symlink(target, slink_tmp);
|
|
|
|
if (err != 0)
|
|
|
|
err = -errno;
|
2014-10-23 19:41:27 +02:00
|
|
|
mac_selinux_create_file_clear();
|
2012-01-10 01:34:15 +01:00
|
|
|
} while (err == -ENOENT);
|
|
|
|
if (err != 0) {
|
2014-11-28 19:29:59 +01:00
|
|
|
log_error_errno(errno, "symlink '%s' '%s' failed: %m", target, slink_tmp);
|
2012-01-10 01:34:15 +01:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
err = rename(slink_tmp, slink);
|
|
|
|
if (err != 0) {
|
2014-11-28 19:29:59 +01:00
|
|
|
log_error_errno(errno, "rename '%s' '%s' failed: %m", slink_tmp, slink);
|
2012-01-10 01:34:15 +01:00
|
|
|
unlink(slink_tmp);
|
|
|
|
}
|
2006-06-14 16:32:52 +02:00
|
|
|
exit:
|
2012-01-10 01:34:15 +01:00
|
|
|
return err;
|
2006-06-14 16:32:52 +02:00
|
|
|
}
|
|
|
|
|
2009-09-09 18:18:17 +02:00
|
|
|
/* find device node of device with highest priority */
|
2014-07-29 15:47:41 +02:00
|
|
|
static const char *link_find_prioritized(struct udev_device *dev, bool add, const char *stackdir, char *buf, size_t bufsize) {
|
2012-01-10 01:34:15 +01:00
|
|
|
struct udev *udev = udev_device_get_udev(dev);
|
|
|
|
DIR *dir;
|
|
|
|
int priority = 0;
|
|
|
|
const char *target = NULL;
|
|
|
|
|
|
|
|
if (add) {
|
|
|
|
priority = udev_device_get_devlink_priority(dev);
|
2013-01-09 19:06:46 +01:00
|
|
|
strscpy(buf, bufsize, udev_device_get_devnode(dev));
|
2012-01-10 01:34:15 +01:00
|
|
|
target = buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
dir = opendir(stackdir);
|
|
|
|
if (dir == NULL)
|
|
|
|
return target;
|
|
|
|
for (;;) {
|
|
|
|
struct udev_device *dev_db;
|
|
|
|
struct dirent *dent;
|
|
|
|
|
|
|
|
dent = readdir(dir);
|
|
|
|
if (dent == NULL || dent->d_name[0] == '\0')
|
|
|
|
break;
|
|
|
|
if (dent->d_name[0] == '.')
|
|
|
|
continue;
|
|
|
|
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("found '%s' claiming '%s'", dent->d_name, stackdir);
|
2012-01-10 01:34:15 +01:00
|
|
|
|
|
|
|
/* did we find ourself? */
|
2013-02-13 18:13:22 +01:00
|
|
|
if (streq(dent->d_name, udev_device_get_id_filename(dev)))
|
2012-01-10 01:34:15 +01:00
|
|
|
continue;
|
|
|
|
|
2012-08-10 19:56:57 +02:00
|
|
|
dev_db = udev_device_new_from_device_id(udev, dent->d_name);
|
2012-01-10 01:34:15 +01:00
|
|
|
if (dev_db != NULL) {
|
|
|
|
const char *devnode;
|
|
|
|
|
|
|
|
devnode = udev_device_get_devnode(dev_db);
|
|
|
|
if (devnode != NULL) {
|
|
|
|
if (target == NULL || udev_device_get_devlink_priority(dev_db) > priority) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("'%s' claims priority %i for '%s'",
|
2012-04-08 16:06:20 +02:00
|
|
|
udev_device_get_syspath(dev_db), udev_device_get_devlink_priority(dev_db), stackdir);
|
2012-01-10 01:34:15 +01:00
|
|
|
priority = udev_device_get_devlink_priority(dev_db);
|
2013-01-09 19:06:46 +01:00
|
|
|
strscpy(buf, bufsize, devnode);
|
2012-01-10 01:34:15 +01:00
|
|
|
target = buf;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
udev_device_unref(dev_db);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
closedir(dir);
|
|
|
|
return target;
|
2008-10-16 17:16:58 +02:00
|
|
|
}
|
|
|
|
|
2009-09-09 18:18:17 +02:00
|
|
|
/* manage "stack of names" with possibly specified device priorities */
|
2014-07-29 15:47:41 +02:00
|
|
|
static void link_update(struct udev_device *dev, const char *slink, bool add) {
|
2012-01-10 01:34:15 +01:00
|
|
|
char name_enc[UTIL_PATH_SIZE];
|
|
|
|
char filename[UTIL_PATH_SIZE * 2];
|
|
|
|
char dirname[UTIL_PATH_SIZE];
|
|
|
|
const char *target;
|
|
|
|
char buf[UTIL_PATH_SIZE];
|
|
|
|
|
2012-07-15 22:10:46 +02:00
|
|
|
util_path_encode(slink + strlen("/dev"), name_enc, sizeof(name_enc));
|
2013-01-09 19:06:46 +01:00
|
|
|
strscpyl(dirname, sizeof(dirname), "/run/udev/links/", name_enc, NULL);
|
|
|
|
strscpyl(filename, sizeof(filename), dirname, "/", udev_device_get_id_filename(dev), NULL);
|
2012-01-10 01:34:15 +01:00
|
|
|
|
2012-04-08 16:06:20 +02:00
|
|
|
if (!add && unlink(filename) == 0)
|
|
|
|
rmdir(dirname);
|
2012-01-10 01:34:15 +01:00
|
|
|
|
|
|
|
target = link_find_prioritized(dev, add, dirname, buf, sizeof(buf));
|
|
|
|
if (target == NULL) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("no reference left, remove '%s'", slink);
|
2012-01-10 01:34:15 +01:00
|
|
|
if (unlink(slink) == 0)
|
2014-09-15 14:20:32 +02:00
|
|
|
rmdir_parents(slink, "/");
|
2012-01-10 01:34:15 +01:00
|
|
|
} else {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("creating link '%s' to '%s'", slink, target);
|
udev: use unique names for temporary files created in /dev
On Tue, Feb 12, 2013 at 2:18 PM, Robert Milasan <rmilasan@suse.com> wrote:
> Under some circumstances udev mixed with multipath fails:
>
> udevd-work[1376]:
> symlink(../../sdk, /dev/disk/by-id/scsi-36005076305ffc0670000000000002842.udev-tmp)
> failed: File exists udevd-work[1432]:
> rename(/dev/disk/by-id/scsi-36005076305ffc0850000000000000a88.udev-tmp, /dev/disk/by-id/scsi-36005076305ffc0850000000000000a88)
> failed: No such file or directory
>
> This is non-fatal, but there is no point of created the symlink or
> renaming the symlink if it already exists.
>
> Reference: https://bugzilla.novell.com/show_bug.cgi?id=791503
It looke like this now:
stat("/dev/disk/by-id", {st_mode=S_IFDIR|0755, st_size=80, ...}) = 0
symlink("../../sda", "/dev/disk/by-id/ata-INTEL...N.tmp-b8:0") = 0
rename("/dev/disk/by-id/ata-INTEL...N.tmp-b8:0", "/dev/disk/by-id/ata-INTEL...N") = 0
2013-02-12 16:03:45 +01:00
|
|
|
node_symlink(dev, target, slink);
|
2012-01-10 01:34:15 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (add) {
|
|
|
|
int err;
|
|
|
|
|
|
|
|
do {
|
|
|
|
int fd;
|
|
|
|
|
2012-06-05 17:31:32 +02:00
|
|
|
err = mkdir_parents(filename, 0755);
|
2012-01-10 01:34:15 +01:00
|
|
|
if (err != 0 && err != -ENOENT)
|
|
|
|
break;
|
|
|
|
fd = open(filename, O_WRONLY|O_CREAT|O_CLOEXEC|O_TRUNC|O_NOFOLLOW, 0444);
|
|
|
|
if (fd >= 0)
|
|
|
|
close(fd);
|
|
|
|
else
|
|
|
|
err = -errno;
|
|
|
|
} while (err == -ENOENT);
|
|
|
|
}
|
priority based symlink handling
Symlinks can have priorities now, the priority is assigned to the device
and specified with OPTIONS="link_priority=100". Devices with higher
priorities overwrite the symlinks of devices with lower priorities.
If the device, that currently owns the link goes away, the symlink
will be removed, and recreated, pointing to the next device with the
highest actual priority.
This should solve the issue, that inserting an USB-stick may overwrite the
/dev/disk/by-id/-link of another disk, and removes the entire link after the
USB-stick is disconnected. If no priorities are specified, the new link will
overwrite the current one, and if the device goes away, it will restore
the old link. It should be possible to assign lower priorities to removable
devices, if needed.
In multipath setups, we see several devices, which all connect to the same
volume, and therefore all try to create the same metadata-links. The
different path-devices are combined into one device-mapper device, which also
contains the same metadata. It should be possible, to assign multipath-table
device-mapper devices a higher priority, so path-devices that appear and
disappear, will not overwrite or delete the device-mapper device links.
2007-03-18 12:51:57 +01:00
|
|
|
}
|
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
void udev_node_update_old_links(struct udev_device *dev, struct udev_device *dev_old) {
|
2012-01-10 01:34:15 +01:00
|
|
|
struct udev_list_entry *list_entry;
|
|
|
|
|
|
|
|
/* update possible left-over symlinks */
|
|
|
|
udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(dev_old)) {
|
|
|
|
const char *name = udev_list_entry_get_name(list_entry);
|
|
|
|
struct udev_list_entry *list_entry_current;
|
|
|
|
int found;
|
|
|
|
|
|
|
|
/* check if old link name still belongs to this device */
|
|
|
|
found = 0;
|
|
|
|
udev_list_entry_foreach(list_entry_current, udev_device_get_devlinks_list_entry(dev)) {
|
|
|
|
const char *name_current = udev_list_entry_get_name(list_entry_current);
|
|
|
|
|
2013-02-13 18:13:22 +01:00
|
|
|
if (streq(name, name_current)) {
|
2012-01-10 01:34:15 +01:00
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (found)
|
|
|
|
continue;
|
|
|
|
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("update old name, '%s' no longer belonging to '%s'",
|
2012-01-10 01:34:15 +01:00
|
|
|
name, udev_device_get_devpath(dev));
|
2012-10-08 21:54:39 +02:00
|
|
|
link_update(dev, name, false);
|
2012-01-10 01:34:15 +01:00
|
|
|
}
|
priority based symlink handling
Symlinks can have priorities now, the priority is assigned to the device
and specified with OPTIONS="link_priority=100". Devices with higher
priorities overwrite the symlinks of devices with lower priorities.
If the device, that currently owns the link goes away, the symlink
will be removed, and recreated, pointing to the next device with the
highest actual priority.
This should solve the issue, that inserting an USB-stick may overwrite the
/dev/disk/by-id/-link of another disk, and removes the entire link after the
USB-stick is disconnected. If no priorities are specified, the new link will
overwrite the current one, and if the device goes away, it will restore
the old link. It should be possible to assign lower priorities to removable
devices, if needed.
In multipath setups, we see several devices, which all connect to the same
volume, and therefore all try to create the same metadata-links. The
different path-devices are combined into one device-mapper device, which also
contains the same metadata. It should be possible, to assign multipath-table
device-mapper devices a higher priority, so path-devices that appear and
disappear, will not overwrite or delete the device-mapper device links.
2007-03-18 12:51:57 +01:00
|
|
|
}
|
|
|
|
|
2013-10-08 01:59:10 +02:00
|
|
|
static int node_permissions_apply(struct udev_device *dev, bool apply,
|
|
|
|
mode_t mode, uid_t uid, gid_t gid,
|
|
|
|
struct udev_list *seclabel_list) {
|
2012-01-10 01:34:15 +01:00
|
|
|
const char *devnode = udev_device_get_devnode(dev);
|
|
|
|
dev_t devnum = udev_device_get_devnum(dev);
|
|
|
|
struct stat stats;
|
2013-10-08 01:59:10 +02:00
|
|
|
struct udev_list_entry *entry;
|
2012-01-10 01:34:15 +01:00
|
|
|
int err = 0;
|
|
|
|
|
2013-02-13 18:13:22 +01:00
|
|
|
if (streq(udev_device_get_subsystem(dev), "block"))
|
2012-01-10 01:34:15 +01:00
|
|
|
mode |= S_IFBLK;
|
|
|
|
else
|
|
|
|
mode |= S_IFCHR;
|
|
|
|
|
|
|
|
if (lstat(devnode, &stats) != 0) {
|
2015-11-05 13:44:20 +01:00
|
|
|
err = log_debug_errno(errno, "can not stat() node '%s' (%m)", devnode);
|
2012-01-10 01:34:15 +01:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (((stats.st_mode & S_IFMT) != (mode & S_IFMT)) || (stats.st_rdev != devnum)) {
|
|
|
|
err = -EEXIST;
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("found node '%s' with non-matching devnum %s, skip handling",
|
2012-04-08 16:06:20 +02:00
|
|
|
udev_device_get_devnode(dev), udev_device_get_id_filename(dev));
|
2012-01-10 01:34:15 +01:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2013-01-27 21:46:36 +01:00
|
|
|
if (apply) {
|
2013-10-09 04:17:39 +02:00
|
|
|
bool selinux = false;
|
|
|
|
bool smack = false;
|
|
|
|
|
2013-01-04 16:15:46 +01:00
|
|
|
if ((stats.st_mode & 0777) != (mode & 0777) || stats.st_uid != uid || stats.st_gid != gid) {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("set permissions %s, %#o, uid=%u, gid=%u", devnode, mode, uid, gid);
|
2014-09-18 19:22:09 +02:00
|
|
|
err = chmod(devnode, mode);
|
|
|
|
if (err < 0)
|
2014-11-28 19:29:59 +01:00
|
|
|
log_warning_errno(errno, "setting mode of %s to %#o failed: %m", devnode, mode);
|
2014-09-18 19:22:09 +02:00
|
|
|
err = chown(devnode, uid, gid);
|
|
|
|
if (err < 0)
|
2014-11-28 19:29:59 +01:00
|
|
|
log_warning_errno(errno, "setting owner of %s to uid=%u, gid=%u failed: %m", devnode, uid, gid);
|
2013-01-04 16:15:46 +01:00
|
|
|
} else {
|
2013-12-24 16:39:37 +01:00
|
|
|
log_debug("preserve permissions %s, %#o, uid=%u, gid=%u", devnode, mode, uid, gid);
|
2013-01-04 16:15:46 +01:00
|
|
|
}
|
2013-10-08 01:59:10 +02:00
|
|
|
|
|
|
|
/* apply SECLABEL{$module}=$label */
|
|
|
|
udev_list_entry_foreach(entry, udev_list_get_entry(seclabel_list)) {
|
|
|
|
const char *name, *label;
|
2014-10-23 18:06:51 +02:00
|
|
|
int r;
|
2013-10-08 01:59:10 +02:00
|
|
|
|
|
|
|
name = udev_list_entry_get_name(entry);
|
|
|
|
label = udev_list_entry_get_value(entry);
|
|
|
|
|
|
|
|
if (streq(name, "selinux")) {
|
2013-10-09 04:17:39 +02:00
|
|
|
selinux = true;
|
2014-10-23 18:06:51 +02:00
|
|
|
|
2014-10-23 19:41:27 +02:00
|
|
|
r = mac_selinux_apply(devnode, label);
|
|
|
|
if (r < 0)
|
2014-11-28 13:19:16 +01:00
|
|
|
log_error_errno(r, "SECLABEL: failed to set SELinux label '%s': %m", label);
|
2013-10-09 17:31:00 +02:00
|
|
|
else
|
|
|
|
log_debug("SECLABEL: set SELinux label '%s'", label);
|
2013-10-08 01:59:10 +02:00
|
|
|
|
2013-10-11 09:47:31 +02:00
|
|
|
} else if (streq(name, "smack")) {
|
2013-10-09 04:17:39 +02:00
|
|
|
smack = true;
|
2014-10-23 18:06:51 +02:00
|
|
|
|
2015-07-27 19:43:55 +02:00
|
|
|
r = mac_smack_apply(devnode, SMACK_ATTR_ACCESS, label);
|
2014-10-23 18:06:51 +02:00
|
|
|
if (r < 0)
|
2014-11-28 13:19:16 +01:00
|
|
|
log_error_errno(r, "SECLABEL: failed to set SMACK label '%s': %m", label);
|
2013-10-08 01:59:10 +02:00
|
|
|
else
|
|
|
|
log_debug("SECLABEL: set SMACK label '%s'", label);
|
|
|
|
|
|
|
|
} else
|
|
|
|
log_error("SECLABEL: unknown subsystem, ignoring '%s'='%s'", name, label);
|
|
|
|
}
|
2013-10-09 04:17:39 +02:00
|
|
|
|
|
|
|
/* set the defaults */
|
|
|
|
if (!selinux)
|
2014-10-24 06:51:09 +02:00
|
|
|
mac_selinux_fix(devnode, true, false);
|
2013-10-11 09:47:31 +02:00
|
|
|
if (!smack)
|
2015-07-27 19:43:55 +02:00
|
|
|
mac_smack_apply(devnode, SMACK_ATTR_ACCESS, NULL);
|
2013-01-04 16:15:46 +01:00
|
|
|
}
|
2012-01-10 01:34:15 +01:00
|
|
|
|
|
|
|
/* always update timestamp when we re-use the node, like on media change events */
|
|
|
|
utimensat(AT_FDCWD, devnode, NULL, 0);
|
2012-01-01 04:21:15 +01:00
|
|
|
out:
|
2012-01-10 01:34:15 +01:00
|
|
|
return err;
|
2012-01-01 04:21:15 +01:00
|
|
|
}
|
|
|
|
|
2013-10-08 01:59:10 +02:00
|
|
|
void udev_node_add(struct udev_device *dev, bool apply,
|
|
|
|
mode_t mode, uid_t uid, gid_t gid,
|
|
|
|
struct udev_list *seclabel_list) {
|
2016-11-03 03:05:48 +01:00
|
|
|
char filename[sizeof("/dev/block/:") + 2*DECIMAL_STR_MAX(unsigned)];
|
2012-01-10 01:34:15 +01:00
|
|
|
struct udev_list_entry *list_entry;
|
|
|
|
|
2015-01-21 04:22:15 +01:00
|
|
|
log_debug("handling device node '%s', devnum=%s, mode=%#o, uid="UID_FMT", gid="GID_FMT,
|
2012-04-08 16:06:20 +02:00
|
|
|
udev_device_get_devnode(dev), udev_device_get_id_filename(dev), mode, uid, gid);
|
2012-01-10 01:34:15 +01:00
|
|
|
|
2013-10-08 01:59:10 +02:00
|
|
|
if (node_permissions_apply(dev, apply, mode, uid, gid, seclabel_list) < 0)
|
2012-01-29 05:37:39 +01:00
|
|
|
return;
|
2012-01-10 01:34:15 +01:00
|
|
|
|
|
|
|
/* always add /dev/{block,char}/$major:$minor */
|
2016-01-12 15:34:20 +01:00
|
|
|
xsprintf(filename, "/dev/%s/%u:%u",
|
2013-02-13 18:13:22 +01:00
|
|
|
streq(udev_device_get_subsystem(dev), "block") ? "block" : "char",
|
2016-01-12 15:34:20 +01:00
|
|
|
major(udev_device_get_devnum(dev)),
|
|
|
|
minor(udev_device_get_devnum(dev)));
|
udev: use unique names for temporary files created in /dev
On Tue, Feb 12, 2013 at 2:18 PM, Robert Milasan <rmilasan@suse.com> wrote:
> Under some circumstances udev mixed with multipath fails:
>
> udevd-work[1376]:
> symlink(../../sdk, /dev/disk/by-id/scsi-36005076305ffc0670000000000002842.udev-tmp)
> failed: File exists udevd-work[1432]:
> rename(/dev/disk/by-id/scsi-36005076305ffc0850000000000000a88.udev-tmp, /dev/disk/by-id/scsi-36005076305ffc0850000000000000a88)
> failed: No such file or directory
>
> This is non-fatal, but there is no point of created the symlink or
> renaming the symlink if it already exists.
>
> Reference: https://bugzilla.novell.com/show_bug.cgi?id=791503
It looke like this now:
stat("/dev/disk/by-id", {st_mode=S_IFDIR|0755, st_size=80, ...}) = 0
symlink("../../sda", "/dev/disk/by-id/ata-INTEL...N.tmp-b8:0") = 0
rename("/dev/disk/by-id/ata-INTEL...N.tmp-b8:0", "/dev/disk/by-id/ata-INTEL...N") = 0
2013-02-12 16:03:45 +01:00
|
|
|
node_symlink(dev, udev_device_get_devnode(dev), filename);
|
2012-01-10 01:34:15 +01:00
|
|
|
|
|
|
|
/* create/update symlinks, add symlinks to name index */
|
2012-10-08 21:54:39 +02:00
|
|
|
udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(dev))
|
|
|
|
link_update(dev, udev_list_entry_get_name(list_entry), true);
|
2003-07-21 05:48:48 +02:00
|
|
|
}
|
|
|
|
|
2014-07-29 15:47:41 +02:00
|
|
|
void udev_node_remove(struct udev_device *dev) {
|
2012-01-10 01:34:15 +01:00
|
|
|
struct udev_list_entry *list_entry;
|
2016-11-03 03:05:48 +01:00
|
|
|
char filename[sizeof("/dev/block/:") + 2*DECIMAL_STR_MAX(unsigned)];
|
2012-01-10 01:34:15 +01:00
|
|
|
|
|
|
|
/* remove/update symlinks, remove symlinks from name index */
|
|
|
|
udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(dev))
|
2012-10-08 21:54:39 +02:00
|
|
|
link_update(dev, udev_list_entry_get_name(list_entry), false);
|
2012-01-10 01:34:15 +01:00
|
|
|
|
|
|
|
/* remove /dev/{block,char}/$major:$minor */
|
2016-01-12 15:34:20 +01:00
|
|
|
xsprintf(filename, "/dev/%s/%u:%u",
|
2013-02-13 18:13:22 +01:00
|
|
|
streq(udev_device_get_subsystem(dev), "block") ? "block" : "char",
|
2016-01-12 15:34:20 +01:00
|
|
|
major(udev_device_get_devnum(dev)),
|
|
|
|
minor(udev_device_get_devnum(dev)));
|
2012-01-10 01:34:15 +01:00
|
|
|
unlink(filename);
|
2003-07-21 05:48:48 +02:00
|
|
|
}
|