X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=udev-add.c;h=174331fadeae7318c24894e0fca79ace631d4e7b;hp=5bd934acd06a29a578fd4b5928fdd7ece1f77e4c;hb=5aebfbcb62614fc2bf2b1579d62e3fe272c6751a;hpb=8e41d35d7675b7d47db3e27da4e1fd508d772c32 diff --git a/udev-add.c b/udev-add.c index 5bd934acd..174331fad 100644 --- a/udev-add.c +++ b/udev-add.c @@ -27,26 +27,30 @@ #include #include #include +#include +#include +#include +#ifndef __KLIBC__ +#include +#endif #include "udev.h" #include "udev_version.h" #include "namedev.h" #include "udevdb.h" #include "libsysfs/libsysfs.h" - +#include "klibc_fixups.h" /* * Right now the major/minor of a device is stored in a file called * "dev" in sysfs. * The number is stored as: - * MMmm + * MM:mm * MM is the major * mm is the minor - * The value is in hex. - * Yes, this will probably change when we go to a bigger major/minor - * range, and will have to be changed at that time. + * The value is in decimal. */ -static int get_major_minor(struct sysfs_class_device *class_dev, int *major, int *minor) +static int get_major_minor(struct sysfs_class_device *class_dev, struct udevice *udev) { int retval = -ENODEV; @@ -56,69 +60,222 @@ static int get_major_minor(struct sysfs_class_device *class_dev, int *major, int if (dev == NULL) goto exit; - dbg("dev = %s", dev); + dbg("dev='%s'", dev); - if (sscanf(dev, "%u:%u", major, minor) != 2) + if (sscanf(dev, "%u:%u", &udev->major, &udev->minor) != 2) goto exit; - dbg("found major = %d, minor = %d", *major, *minor); + dbg("found major=%d, minor=%d", udev->major, udev->minor); retval = 0; exit: return retval; } +static int create_path(char *file) +{ + char p[NAME_SIZE]; + char *pos; + int retval; + struct stat stats; + + strncpy(p, file, sizeof(p)); + pos = strchr(p+1, '/'); + while (1) { + pos = strchr(pos+1, '/'); + if (pos == NULL) + break; + *pos = 0x00; + if (stat(p, &stats)) { + retval = mkdir(p, 0755); + if (retval) { + dbg("mkdir(%s) failed with error '%s'", + p, strerror(errno)); + return retval; + } + dbg("created '%s'", p); + } + *pos = '/'; + } + return 0; +} + +#ifdef USE_DBUS +/** Send out a signal that a device node is created + * + * @param dev udevice object + * @param path Sysfs path of device + */ +static void sysbus_send_create(struct udevice *dev, const char *path) +{ + char filename[255]; + DBusMessage* message; + DBusMessageIter iter; + + if (sysbus_connection == NULL) + return; + + strncpy(filename, udev_root, sizeof(filename)); + strncat(filename, dev->name, sizeof(filename)); + + /* object, interface, member */ + message = dbus_message_new_signal("/org/kernel/udev/NodeMonitor", + "org.kernel.udev.NodeMonitor", + "NodeCreated"); + + dbus_message_iter_init(message, &iter); + dbus_message_iter_append_string(&iter, filename); + dbus_message_iter_append_string(&iter, path); + + if ( !dbus_connection_send(sysbus_connection, message, NULL) ) + dbg("error sending d-bus signal"); + + dbus_message_unref(message); + + dbus_connection_flush(sysbus_connection); +} +#endif /* USE_DBUS */ + /* - * We also want to add some permissions here, and possibly some symlinks + * we possibly want to add some symlinks here + * only numeric owner/group id's are supported */ -static int create_node(char *name, char type, int major, int minor, int mode) +static int create_node(struct udevice *dev) { char filename[255]; + char linktarget[255]; int retval = 0; - strncpy(filename, UDEV_ROOT, sizeof(filename)); - strncat(filename, name, sizeof(filename)); - switch (type) { + uid_t uid = 0; + gid_t gid = 0; + dev_t res; + int i; + int tail; + + + strncpy(filename, udev_root, sizeof(filename)); + strncat(filename, dev->name, sizeof(filename)); + +#ifdef __KLIBC__ + res = (dev->major << 8) | (dev->minor); +#else + res = makedev(dev->major, dev->minor); +#endif + + switch (dev->type) { case 'b': - mode |= S_IFBLK; + dev->mode |= S_IFBLK; break; case 'c': case 'u': - mode |= S_IFCHR; + dev->mode |= S_IFCHR; break; case 'p': - mode |= S_IFIFO; + dev->mode |= S_IFIFO; break; default: - dbg("unknown node type %c\n", type); + dbg("unknown node type %c\n", dev->type); return -EINVAL; } - retval = mknod(filename,mode,makedev(major,minor)); + /* create parent directories if needed */ + if (strrchr(dev->name, '/')) + create_path(filename); + + dbg("mknod(%s, %#o, %u, %u)", filename, dev->mode, dev->major, dev->minor); + retval = mknod(filename, dev->mode, res); if (retval) dbg("mknod(%s, %#o, %u, %u) failed with error '%s'", - filename, mode, major, minor, strerror(errno)); + filename, dev->mode, dev->major, dev->minor, strerror(errno)); + + dbg("chmod(%s, %#o)", filename, dev->mode); + retval = chmod(filename, dev->mode); + if (retval) + dbg("chmod(%s, %#o) failed with error '%s'", + filename, dev->mode, strerror(errno)); + + if (*dev->owner) { + char *endptr; + unsigned long id = strtoul(dev->owner, &endptr, 10); + if (*endptr == 0x00) + uid = (uid_t) id; + else { + struct passwd *pw = getpwnam(dev->owner); + if (!pw) + dbg("user unknown '%s'", dev->owner); + else + uid = pw->pw_uid; + } + } + + if (*dev->group) { + char *endptr; + unsigned long id = strtoul(dev->group, &endptr, 10); + if (*endptr == 0x00) + gid = (gid_t) id; + else { + struct group *gr = getgrnam(dev->group); + if (!gr) + dbg("group unknown '%s'", dev->group); + else + gid = gr->gr_gid; + } + } + + if (uid || gid) { + dbg("chown(%s, %u, %u)", filename, uid, gid); + retval = chown(filename, uid, gid); + if (retval) + dbg("chown(%s, %u, %u) failed with error '%s'", + filename, uid, gid, strerror(errno)); + } + + + /* create symlink if requested */ + if (*dev->symlink) { + strncpy(filename, udev_root, sizeof(filename)); + strncat(filename, dev->symlink, sizeof(filename)); + dbg("symlink '%s' to node '%s' requested", filename, dev->name); + if (strrchr(dev->symlink, '/')) + create_path(filename); + + /* optimize relative link */ + linktarget[0] = '\0'; + i = 0; + tail = 0; + while ((dev->name[i] == dev->symlink[i]) && dev->name[i]) { + if (dev->name[i] == '/') + tail = i+1; + i++; + } + while (dev->symlink[i]) { + if (dev->symlink[i] == '/') + strcat(linktarget, "../"); + i++; + } + + if (*linktarget == '\0') + strcpy(linktarget, "./"); + strcat(linktarget, &dev->name[tail]); + + dbg("symlink(%s, %s)", linktarget, filename); + retval = symlink(linktarget, filename); + if (retval) + dbg("symlink(%s, %s) failed with error '%s'", + linktarget, filename, strerror(errno)); + } + return retval; } -struct sysfs_class_device *get_class_dev(char *device_name) +static struct sysfs_class_device *get_class_dev(char *device_name) { - char sysfs_path[SYSFS_PATH_MAX]; char dev_path[SYSFS_PATH_MAX]; - int retval; struct sysfs_class_device *class_dev = NULL; - - retval = sysfs_get_mnt_path(sysfs_path, SYSFS_PATH_MAX); - dbg("sysfs_path = %s", sysfs_path); - if (retval) { - dbg("sysfs_get_mnt_path failed"); - goto exit; - } - strcpy(dev_path, sysfs_path); strcat(dev_path, device_name); - dbg("looking at %s", dev_path); + dbg("looking at '%s'", dev_path); /* open up the sysfs class device for this thing... */ class_dev = sysfs_open_class_device(dev_path); @@ -126,73 +283,91 @@ struct sysfs_class_device *get_class_dev(char *device_name) dbg ("sysfs_open_class_device failed"); goto exit; } - dbg("class_dev->name = %s", class_dev->name); + dbg("class_dev->name='%s'", class_dev->name); exit: return class_dev; } -int udev_add_device(char *device, char *subsystem) +/* wait for the "dev" file to show up in the directory in sysfs. + * If it doesn't happen in about 10 seconds, give up. + */ +#define SECONDS_TO_WAIT_FOR_DEV 10 +static int sleep_for_dev(char *path) { - struct sysfs_class_device *class_dev; - struct device_attr attr; - int major; - int minor; - char type; + char filename[SYSFS_PATH_MAX + 6]; + int loop = SECONDS_TO_WAIT_FOR_DEV; + int retval; + + strcpy(filename, sysfs_path); + strcat(filename, path); + strcat(filename, "/dev"); + + while (loop--) { + struct stat buf; + + dbg("looking for '%s'", filename); + retval = stat(filename, &buf); + if (!retval) + goto exit; + + /* sleep to give the kernel a chance to create the dev file */ + sleep(1); + } + retval = -ENODEV; +exit: + return retval; +} + +int udev_add_device(char *path, char *subsystem) +{ + struct sysfs_class_device *class_dev = NULL; + struct udevice dev; int retval = -EINVAL; + memset(&dev, 0x00, sizeof(dev)); + /* for now, the block layer is the only place where block devices are */ if (strcmp(subsystem, "block") == 0) - type = 'b'; + dev.type = 'b'; else - type = 'c'; + dev.type = 'c'; - /* sleep for a second or two to give the kernel a chance to - * create the dev file - */ - sleep(1); + retval = sleep_for_dev(path); + if (retval) + goto exit; - class_dev = get_class_dev(device); + class_dev = get_class_dev(path); if (class_dev == NULL) goto exit; - retval = namedev_name_device(class_dev, &attr); - if (retval) - return retval; - - retval = get_major_minor(class_dev, &major, &minor); + retval = get_major_minor(class_dev, &dev); if (retval) { - dbg ("get_major_minor failed"); + dbg("get_major_minor failed"); goto exit; } - memset(&dbdev, 0, sizeof(dbdev)); - strncpy(dbdev.name, attr.name, NAME_SIZE); - strncpy(dbdev.sysfs_path, class_dev->sysdevice->directory->path, - PATH_SIZE); - strncpy(dbdev.class_dev_name, class_dev->name, NAME_SIZE); - if ((sysfs_get_name_from_path(subsystem, dbdev.class_name, NAME_SIZE)) - != 0) - strcpy(dbdev.class_name, "unkown"); - strncpy(dbdev.bus_id, class_dev->sysdevice->bus_id, ID_SIZE); - strcpy(dbdev.bus_name, "unknown"); - if (class_dev->driver != NULL) - strncpy(dbdev.driver, class_dev->driver->name, NAME_SIZE); - else - strcpy(dbdev.driver, "unkown"); - dbdev.type = type; - dbdev.major = major; - dbdev.minor = minor; - dbdev.mode = attr.mode; - sysfs_close_class_device(class_dev); + retval = namedev_name_device(class_dev, &dev); + if (retval) + goto exit; - retval = udevdb_add_udevice(&dbdev); + retval = udevdb_add_dev(path, &dev); if (retval != 0) - goto exit; + dbg("udevdb_add_dev failed, but we are going to try to create the node anyway. " + "But remove might not work properly for this device."); + + dbg("name='%s'", dev.name); + retval = create_node(&dev); - return create_node(attr.name, type, major, minor, attr.mode); +#ifdef USE_DBUS + if (retval == 0) { + sysbus_send_create(&dev, path); + } +#endif /* USE_DBUS */ exit: + if (class_dev) + sysfs_close_class_device(class_dev); + return retval; } -