2003-07-21 05:48:48 +02:00
|
|
|
/*
|
2012-11-12 19:36:23 +01:00
|
|
|
* Copyright (C) 2003-2010 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
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdio.h>
|
2006-01-09 21:18:00 +01:00
|
|
|
#include <stddef.h>
|
2009-09-09 18:18:17 +02:00
|
|
|
#include <stdbool.h>
|
2003-07-21 05:48:48 +02:00
|
|
|
#include <fcntl.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <errno.h>
|
2006-02-03 13:52:37 +01:00
|
|
|
#include <grp.h>
|
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>
|
2009-12-18 21:25:13 +01:00
|
|
|
#include <sys/time.h>
|
2003-10-23 04:39:54 +02:00
|
|
|
#include <sys/stat.h>
|
2003-11-24 05:56:18 +01:00
|
|
|
#include <sys/types.h>
|
2003-07-21 05:48:48 +02:00
|
|
|
|
|
|
|
#include "udev.h"
|
2004-10-06 08:39:05 +02:00
|
|
|
|
2012-01-10 01:34:15 +01:00
|
|
|
#define TMP_FILE_EXT ".udev-tmp"
|
2003-07-21 05:48:48 +02:00
|
|
|
|
2008-10-16 17:16:58 +02:00
|
|
|
static int node_symlink(struct udev *udev, const char *node, const char *slink)
|
2006-06-14 16:32:52 +02:00
|
|
|
{
|
2012-01-10 01:34:15 +01:00
|
|
|
struct stat stats;
|
|
|
|
char target[UTIL_PATH_SIZE];
|
|
|
|
char *s;
|
|
|
|
size_t l;
|
|
|
|
char slink_tmp[UTIL_PATH_SIZE + sizeof(TMP_FILE_EXT)];
|
|
|
|
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] == '/')
|
|
|
|
l = util_strpcpy(&s, l, "../");
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
l = util_strscpy(s, l, &node[tail]);
|
|
|
|
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)) {
|
2012-07-09 18:13:41 +02:00
|
|
|
log_error("conflicting device node '%s' found, link to '%s' will not be created\n", slink, node);
|
|
|
|
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';
|
|
|
|
if (strcmp(target, buf) == 0) {
|
2012-04-08 16:06:20 +02:00
|
|
|
log_debug("preserve already existing symlink '%s' to '%s'\n", 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 {
|
2012-04-08 16:06:20 +02:00
|
|
|
log_debug("creating symlink '%s' to '%s'\n", 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;
|
2012-04-17 16:05:03 +02:00
|
|
|
label_context_set(slink, S_IFLNK);
|
2012-01-10 01:34:15 +01:00
|
|
|
err = symlink(target, slink);
|
|
|
|
if (err != 0)
|
|
|
|
err = -errno;
|
2012-04-17 16:05:03 +02:00
|
|
|
label_context_clear();
|
2012-01-10 01:34:15 +01:00
|
|
|
} while (err == -ENOENT);
|
|
|
|
if (err == 0)
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
2012-04-08 16:06:20 +02:00
|
|
|
log_debug("atomically replace '%s'\n", slink);
|
2012-01-10 01:34:15 +01:00
|
|
|
util_strscpyl(slink_tmp, sizeof(slink_tmp), slink, TMP_FILE_EXT, NULL);
|
|
|
|
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;
|
2012-04-17 16:05:03 +02:00
|
|
|
label_context_set(slink_tmp, S_IFLNK);
|
2012-01-10 01:34:15 +01:00
|
|
|
err = symlink(target, slink_tmp);
|
|
|
|
if (err != 0)
|
|
|
|
err = -errno;
|
2012-04-17 16:05:03 +02:00
|
|
|
label_context_clear();
|
2012-01-10 01:34:15 +01:00
|
|
|
} while (err == -ENOENT);
|
|
|
|
if (err != 0) {
|
2012-04-08 16:06:20 +02:00
|
|
|
log_error("symlink '%s' '%s' failed: %m\n", target, slink_tmp);
|
2012-01-10 01:34:15 +01:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
err = rename(slink_tmp, slink);
|
|
|
|
if (err != 0) {
|
2012-04-08 16:06:20 +02:00
|
|
|
log_error("rename '%s' '%s' failed: %m\n", 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 */
|
|
|
|
static const char *link_find_prioritized(struct udev_device *dev, bool add, const char *stackdir, char *buf, size_t bufsize)
|
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
|
|
|
{
|
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);
|
|
|
|
util_strscpy(buf, bufsize, udev_device_get_devnode(dev));
|
|
|
|
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;
|
|
|
|
|
2012-04-08 16:06:20 +02:00
|
|
|
log_debug("found '%s' claiming '%s'\n", dent->d_name, stackdir);
|
2012-01-10 01:34:15 +01:00
|
|
|
|
|
|
|
/* did we find ourself? */
|
|
|
|
if (strcmp(dent->d_name, udev_device_get_id_filename(dev)) == 0)
|
|
|
|
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) {
|
2012-04-08 16:06:20 +02:00
|
|
|
log_debug("'%s' claims priority %i for '%s'\n",
|
|
|
|
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);
|
|
|
|
util_strscpy(buf, bufsize, devnode);
|
|
|
|
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 */
|
|
|
|
static void link_update(struct udev_device *dev, const char *slink, bool add)
|
2008-10-16 17:16:58 +02:00
|
|
|
{
|
2012-01-10 01:34:15 +01:00
|
|
|
struct udev *udev = udev_device_get_udev(dev);
|
|
|
|
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));
|
|
|
|
util_strscpyl(dirname, sizeof(dirname), "/run/udev/links/", name_enc, NULL);
|
2012-01-10 01:34:15 +01:00
|
|
|
util_strscpyl(filename, sizeof(filename), dirname, "/", udev_device_get_id_filename(dev), NULL);
|
|
|
|
|
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) {
|
2012-04-08 16:06:20 +02:00
|
|
|
log_debug("no reference left, remove '%s'\n", slink);
|
2012-01-10 01:34:15 +01:00
|
|
|
if (unlink(slink) == 0)
|
|
|
|
util_delete_path(udev, slink);
|
|
|
|
} else {
|
2012-04-08 16:06:20 +02:00
|
|
|
log_debug("creating link '%s' to '%s'\n", slink, target);
|
2012-01-10 01:34:15 +01:00
|
|
|
node_symlink(udev, target, slink);
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2009-01-15 20:20:16 +01:00
|
|
|
void udev_node_update_old_links(struct udev_device *dev, struct udev_device *dev_old)
|
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
|
|
|
{
|
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);
|
|
|
|
|
|
|
|
if (strcmp(name, name_current) == 0) {
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (found)
|
|
|
|
continue;
|
|
|
|
|
2012-04-08 16:06:20 +02:00
|
|
|
log_debug("update old name, '%s' no longer belonging to '%s'\n",
|
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
|
|
|
}
|
|
|
|
|
2012-01-01 04:21:15 +01:00
|
|
|
static int node_fixup(struct udev_device *dev, mode_t mode, uid_t uid, gid_t gid)
|
|
|
|
{
|
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;
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
if (strcmp(udev_device_get_subsystem(dev), "block") == 0)
|
|
|
|
mode |= S_IFBLK;
|
|
|
|
else
|
|
|
|
mode |= S_IFCHR;
|
|
|
|
|
|
|
|
if (lstat(devnode, &stats) != 0) {
|
|
|
|
err = -errno;
|
2012-04-08 16:06:20 +02:00
|
|
|
log_debug("can not stat() node '%s' (%m)\n", 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;
|
2012-04-08 16:06:20 +02:00
|
|
|
log_debug("found node '%s' with non-matching devnum %s, skip handling\n",
|
|
|
|
udev_device_get_devnode(dev), udev_device_get_id_filename(dev));
|
2012-01-10 01:34:15 +01:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((stats.st_mode & 0777) != (mode & 0777) || stats.st_uid != uid || stats.st_gid != gid) {
|
2012-04-08 16:06:20 +02:00
|
|
|
log_debug("set permissions %s, %#o, uid=%u, gid=%u\n", devnode, mode, uid, gid);
|
2012-01-10 01:34:15 +01:00
|
|
|
chmod(devnode, mode);
|
|
|
|
chown(devnode, uid, gid);
|
|
|
|
} else {
|
2012-04-08 16:06:20 +02:00
|
|
|
log_debug("preserve permissions %s, %#o, uid=%u, gid=%u\n", devnode, mode, uid, gid);
|
2012-01-10 01:34:15 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set initial selinux file context only on add events.
|
|
|
|
* We set the proper context on bootup (triger) or for newly
|
|
|
|
* added devices, but we don't change it later, in case
|
|
|
|
* something else has set a custom context in the meantime.
|
|
|
|
*/
|
|
|
|
if (strcmp(udev_device_get_action(dev), "add") == 0)
|
2012-07-03 16:25:50 +02:00
|
|
|
label_fix(devnode, true, false);
|
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
|
|
|
}
|
|
|
|
|
2012-01-29 05:37:39 +01:00
|
|
|
void udev_node_add(struct udev_device *dev, mode_t mode, uid_t uid, gid_t gid)
|
2004-03-02 08:31:06 +01:00
|
|
|
{
|
2012-01-10 01:34:15 +01:00
|
|
|
struct udev *udev = udev_device_get_udev(dev);
|
|
|
|
char filename[UTIL_PATH_SIZE];
|
|
|
|
struct udev_list_entry *list_entry;
|
|
|
|
|
2012-04-08 16:06:20 +02:00
|
|
|
log_debug("handling device node '%s', devnum=%s, mode=%#o, uid=%d, gid=%d\n",
|
|
|
|
udev_device_get_devnode(dev), udev_device_get_id_filename(dev), mode, uid, gid);
|
2012-01-10 01:34:15 +01:00
|
|
|
|
2012-01-29 05:37:39 +01:00
|
|
|
if (node_fixup(dev, mode, uid, gid) < 0)
|
|
|
|
return;
|
2012-01-10 01:34:15 +01:00
|
|
|
|
|
|
|
/* always add /dev/{block,char}/$major:$minor */
|
2012-07-15 22:10:46 +02:00
|
|
|
snprintf(filename, sizeof(filename), "/dev/%s/%u:%u",
|
2012-01-10 01:34:15 +01:00
|
|
|
strcmp(udev_device_get_subsystem(dev), "block") == 0 ? "block" : "char",
|
|
|
|
major(udev_device_get_devnum(dev)), minor(udev_device_get_devnum(dev)));
|
|
|
|
node_symlink(udev, udev_device_get_devnode(dev), filename);
|
|
|
|
|
|
|
|
/* 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
|
|
|
}
|
|
|
|
|
2012-01-29 05:37:39 +01:00
|
|
|
void udev_node_remove(struct udev_device *dev)
|
2006-04-12 22:08:05 +02:00
|
|
|
{
|
2012-01-10 01:34:15 +01:00
|
|
|
struct udev_list_entry *list_entry;
|
|
|
|
char filename[UTIL_PATH_SIZE];
|
|
|
|
|
|
|
|
/* 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 */
|
2012-07-15 22:10:46 +02:00
|
|
|
snprintf(filename, sizeof(filename), "/dev/%s/%u:%u",
|
2012-01-10 01:34:15 +01:00
|
|
|
strcmp(udev_device_get_subsystem(dev), "block") == 0 ? "block" : "char",
|
|
|
|
major(udev_device_get_devnum(dev)), minor(udev_device_get_devnum(dev)));
|
|
|
|
unlink(filename);
|
2003-07-21 05:48:48 +02:00
|
|
|
}
|