chiark / gitweb /
use libudev code, unify logging, pass udev context around everywhere
[elogind.git] / udev / udev_node.c
index 78b6747..462f1b6 100644 (file)
 
 #define TMP_FILE_EXT           ".udev-tmp"
 
-int udev_node_mknod(struct udevice *udev, const char *file, dev_t devt, mode_t mode, uid_t uid, gid_t gid)
+int udev_node_mknod(struct udevice *udevice, const char *file, dev_t devt, mode_t mode, uid_t uid, gid_t gid)
 {
        char file_tmp[PATH_SIZE + sizeof(TMP_FILE_EXT)];
        struct stat stats;
        int preserve = 0;
        int err = 0;
 
-       if (major(devt) != 0 && strcmp(udev->dev->subsystem, "block") == 0)
+       if (major(devt) != 0 && strcmp(udevice->dev->subsystem, "block") == 0)
                mode |= S_IFBLK;
        else
                mode |= S_IFCHR;
 
        if (lstat(file, &stats) == 0) {
                if (((stats.st_mode & S_IFMT) == (mode & S_IFMT)) && (stats.st_rdev == devt)) {
-                       info("preserve file '%s', because it has correct dev_t\n", file);
+                       info(udevice->udev, "preserve file '%s', because it has correct dev_t\n", file);
                        preserve = 1;
-                       selinux_setfilecon(file, udev->dev->kernel, mode);
+                       selinux_setfilecon(udevice->udev, file, udevice->dev->kernel, mode);
                } else {
-                       info("atomically replace existing file '%s'\n", file);
+                       info(udevice->udev, "atomically replace existing file '%s'\n", file);
                        strlcpy(file_tmp, file, sizeof(file_tmp));
                        strlcat(file_tmp, TMP_FILE_EXT, sizeof(file_tmp));
                        unlink(file_tmp);
-                       selinux_setfscreatecon(file_tmp, udev->dev->kernel, mode);
+                       selinux_setfscreatecon(udevice->udev, file_tmp, udevice->dev->kernel, mode);
                        err = mknod(file_tmp, mode, devt);
-                       selinux_resetfscreatecon();
+                       selinux_resetfscreatecon(udevice->udev);
                        if (err != 0) {
-                               err("mknod(%s, %#o, %u, %u) failed: %s\n",
+                               err(udevice->udev, "mknod(%s, %#o, %u, %u) failed: %s\n",
                                    file_tmp, mode, major(devt), minor(devt), strerror(errno));
                                goto exit;
                        }
                        err = rename(file_tmp, file);
                        if (err != 0) {
-                               err("rename(%s, %s) failed: %s\n",
-                                   file_tmp, file, strerror(errno));
+                               err(udevice->udev, "rename(%s, %s) failed: %s\n", file_tmp, file, strerror(errno));
                                unlink(file_tmp);
                        }
                }
        } else {
-               info("mknod(%s, %#o, (%u,%u))\n", file, mode, major(devt), minor(devt));
-               selinux_setfscreatecon(file, udev->dev->kernel, mode);
+               info(udevice->udev, "mknod(%s, %#o, (%u,%u))\n", file, mode, major(devt), minor(devt));
+               selinux_setfscreatecon(udevice->udev, file, udevice->dev->kernel, mode);
                err = mknod(file, mode, devt);
-               selinux_resetfscreatecon();
+               selinux_resetfscreatecon(udevice->udev);
                if (err != 0) {
-                       err("mknod(%s, %#o, (%u,%u) failed: %s\n",
+                       err(udevice->udev, "mknod(%s, %#o, (%u,%u) failed: %s\n",
                            file, mode, major(devt), minor(devt), strerror(errno));
                        goto exit;
                }
        }
 
        if (!preserve || stats.st_mode != mode) {
-               info("chmod(%s, %#o)\n", file, mode);
+               info(udevice->udev, "chmod(%s, %#o)\n", file, mode);
                err = chmod(file, mode);
                if (err != 0) {
-                       err("chmod(%s, %#o) failed: %s\n", file, mode, strerror(errno));
+                       err(udevice->udev, "chmod(%s, %#o) failed: %s\n", file, mode, strerror(errno));
                        goto exit;
                }
        }
 
        if (!preserve || stats.st_uid != uid || stats.st_gid != gid) {
-               info("chown(%s, %u, %u)\n", file, uid, gid);
+               info(udevice->udev, "chown(%s, %u, %u)\n", file, uid, gid);
                err = chown(file, uid, gid);
                if (err != 0) {
-                       err("chown(%s, %u, %u) failed: %s\n", file, uid, gid, strerror(errno));
+                       err(udevice->udev, "chown(%s, %u, %u) failed: %s\n", file, uid, gid, strerror(errno));
                        goto exit;
                }
        }
@@ -105,7 +104,7 @@ exit:
        return err;
 }
 
-static int node_symlink(const char *node, const char *slink)
+static int node_symlink(struct udevice *udevice, const char *node, const char *slink)
 {
        struct stat stats;
        char target[PATH_SIZE] = "";
@@ -133,53 +132,53 @@ static int node_symlink(const char *node, const char *slink)
                if (S_ISBLK(stats.st_mode) || S_ISCHR(stats.st_mode)) {
                        struct stat stats2;
 
-                       info("found existing node instead of symlink '%s'\n", slink);
+                       info(udevice->udev, "found existing node instead of symlink '%s'\n", slink);
                        if (lstat(node, &stats2) == 0) {
                                if ((stats.st_mode & S_IFMT) == (stats2.st_mode & S_IFMT) &&
                                    stats.st_rdev == stats2.st_rdev) {
-                                       info("replace device node '%s' with symlink to our node '%s'\n", slink, node);
+                                       info(udevice->udev, "replace device node '%s' with symlink to our node '%s'\n", slink, node);
                                } else {
-                                       err("device node '%s' already exists, link to '%s' will not overwrite it\n", slink, node);
+                                       err(udevice->udev, "device node '%s' already exists, link to '%s' will not overwrite it\n", slink, node);
                                        goto exit;
                                }
                        }
                } else if (S_ISLNK(stats.st_mode)) {
                        char buf[PATH_SIZE];
 
-                       info("found existing symlink '%s'\n", slink);
+                       info(udevice->udev, "found existing symlink '%s'\n", slink);
                        len = readlink(slink, buf, sizeof(buf));
                        if (len > 0) {
                                buf[len] = '\0';
                                if (strcmp(target, buf) == 0) {
-                                       info("preserve already existing symlink '%s' to '%s'\n", slink, target);
-                                       selinux_setfilecon(slink, NULL, S_IFLNK);
+                                       info(udevice->udev, "preserve already existing symlink '%s' to '%s'\n", slink, target);
+                                       selinux_setfilecon(udevice->udev, slink, NULL, S_IFLNK);
                                        goto exit;
                                }
                        }
                }
        } else {
-               info("creating symlink '%s' to '%s'\n", slink, target);
-               selinux_setfscreatecon(slink, NULL, S_IFLNK);
+               info(udevice->udev, "creating symlink '%s' to '%s'\n", slink, target);
+               selinux_setfscreatecon(udevice->udev, slink, NULL, S_IFLNK);
                retval = symlink(target, slink);
-               selinux_resetfscreatecon();
+               selinux_resetfscreatecon(udevice->udev);
                if (retval == 0)
                        goto exit;
        }
 
-       info("atomically replace '%s'\n", slink);
+       info(udevice->udev, "atomically replace '%s'\n", slink);
        strlcpy(slink_tmp, slink, sizeof(slink_tmp));
        strlcat(slink_tmp, TMP_FILE_EXT, sizeof(slink_tmp));
        unlink(slink_tmp);
-       selinux_setfscreatecon(slink, NULL, S_IFLNK);
+       selinux_setfscreatecon(udevice->udev, slink, NULL, S_IFLNK);
        retval = symlink(target, slink_tmp);
-       selinux_resetfscreatecon();
+       selinux_resetfscreatecon(udevice->udev);
        if (retval != 0) {
-               err("symlink(%s, %s) failed: %s\n", target, slink_tmp, strerror(errno));
+               err(udevice->udev, "symlink(%s, %s) failed: %s\n", target, slink_tmp, strerror(errno));
                goto exit;
        }
        retval = rename(slink_tmp, slink);
        if (retval != 0) {
-               err("rename(%s, %s) failed: %s\n", slink_tmp, slink, strerror(errno));
+               err(udevice->udev, "rename(%s, %s) failed: %s\n", slink_tmp, slink, strerror(errno));
                unlink(slink_tmp);
                goto exit;
        }
@@ -187,100 +186,100 @@ exit:
        return retval;
 }
 
-static int update_link(struct udevice *udev, const char *name)
+static int update_link(struct udevice *udevice, const char *name)
 {
        LIST_HEAD(name_list);
        char slink[PATH_SIZE];
        char node[PATH_SIZE];
-       struct udevice *udev_db;
+       struct udevice *udevice_db;
        struct name_entry *device;
        char target[PATH_MAX] = "";
        int count;
        int priority = 0;
        int rc = 0;
 
-       strlcpy(slink, udev_root, sizeof(slink));
+       strlcpy(slink, udev_get_dev_path(udevice->udev), sizeof(slink));
        strlcat(slink, "/", sizeof(slink));
        strlcat(slink, name, sizeof(slink));
 
-       count = udev_db_get_devices_by_name(name, &name_list);
-       info("found %i devices with name '%s'\n", count, name);
+       count = udev_db_get_devices_by_name(udevice->udev, name, &name_list);
+       info(udevice->udev, "found %i devices with name '%s'\n", count, name);
 
        /* if we don't have a reference, delete it */
        if (count <= 0) {
-               info("no reference left, remove '%s'\n", name);
-               if (!udev->test_run) {
+               info(udevice->udev, "no reference left, remove '%s'\n", name);
+               if (!udevice->test_run) {
                        unlink(slink);
-                       delete_path(slink);
+                       delete_path(udevice->udev, slink);
                }
                goto out;
        }
 
        /* find the device with the highest priority */
        list_for_each_entry(device, &name_list, node) {
-               info("found '%s' for '%s'\n", device->name, name);
+               info(udevice->udev, "found '%s' for '%s'\n", device->name, name);
 
                /* did we find ourself? we win, if we have the same priority */
-               if (strcmp(udev->dev->devpath, device->name) == 0) {
-                       info("compare (our own) priority of '%s' %i >= %i\n",
-                            udev->dev->devpath, udev->link_priority, priority);
-                       if (strcmp(udev->name, name) == 0) {
-                               info("'%s' is our device node, database inconsistent, skip link update\n", udev->name);
-                       } else if (target[0] == '\0' || udev->link_priority >= priority) {
-                               priority = udev->link_priority;
-                               strlcpy(target, udev->name, sizeof(target));
+               if (strcmp(udevice->dev->devpath, device->name) == 0) {
+                       info(udevice->udev, "compare (our own) priority of '%s' %i >= %i\n",
+                            udevice->dev->devpath, udevice->link_priority, priority);
+                       if (strcmp(udevice->name, name) == 0) {
+                               info(udevice->udev, "'%s' is our device node, database inconsistent, skip link update\n", udevice->name);
+                       } else if (target[0] == '\0' || udevice->link_priority >= priority) {
+                               priority = udevice->link_priority;
+                               strlcpy(target, udevice->name, sizeof(target));
                        }
                        continue;
                }
 
                /* another device, read priority from database */
-               udev_db = udev_device_init(NULL);
-               if (udev_db == NULL)
+               udevice_db = udev_device_init(udevice->udev);
+               if (udevice_db == NULL)
                        continue;
-               if (udev_db_get_device(udev_db, device->name) == 0) {
-                       if (strcmp(udev_db->name, name) == 0) {
-                               info("'%s' is a device node of '%s', skip link update\n", udev_db->name, device->name);
+               if (udev_db_get_device(udevice_db, device->name) == 0) {
+                       if (strcmp(udevice_db->name, name) == 0) {
+                               info(udevice->udev, "'%s' is a device node of '%s', skip link update\n", udevice_db->name, device->name);
                        } else {
-                               info("compare priority of '%s' %i > %i\n",
-                                    udev_db->dev->devpath, udev_db->link_priority, priority);
-                               if (target[0] == '\0' || udev_db->link_priority > priority) {
-                                       priority = udev_db->link_priority;
-                                       strlcpy(target, udev_db->name, sizeof(target));
+                               info(udevice->udev, "compare priority of '%s' %i > %i\n",
+                                    udevice_db->dev->devpath, udevice_db->link_priority, priority);
+                               if (target[0] == '\0' || udevice_db->link_priority > priority) {
+                                       priority = udevice_db->link_priority;
+                                       strlcpy(target, udevice_db->name, sizeof(target));
                                }
                        }
                }
-               udev_device_cleanup(udev_db);
+               udev_device_cleanup(udevice_db);
        }
-       name_list_cleanup(&name_list);
+       name_list_cleanup(udevice->udev, &name_list);
 
        if (target[0] == '\0') {
-               info("no current target for '%s' found\n", name);
+               info(udevice->udev, "no current target for '%s' found\n", name);
                rc = 1;
                goto out;
        }
 
        /* create symlink to the target with the highest priority */
-       strlcpy(node, udev_root, sizeof(node));
+       strlcpy(node, udev_get_dev_path(udevice->udev), sizeof(node));
        strlcat(node, "/", sizeof(node));
        strlcat(node, target, sizeof(node));
-       info("'%s' with target '%s' has the highest priority %i, create it\n", name, target, priority);
-       if (!udev->test_run) {
-               create_path(slink);
-               node_symlink(node, slink);
+       info(udevice->udev, "'%s' with target '%s' has the highest priority %i, create it\n", name, target, priority);
+       if (!udevice->test_run) {
+               create_path(udevice->udev, slink);
+               node_symlink(udevice, node, slink);
        }
 out:
        return rc;
 }
 
-void udev_node_update_symlinks(struct udevice *udev, struct udevice *udev_old)
+void udev_node_update_symlinks(struct udevice *udevice, struct udevice *udevice_old)
 {
        struct name_entry *name_loop;
        char symlinks[PATH_SIZE] = "";
 
-       list_for_each_entry(name_loop, &udev->symlink_list, node) {
-               info("update symlink '%s' of '%s'\n", name_loop->name, udev->dev->devpath);
-               update_link(udev, name_loop->name);
-               strlcat(symlinks, udev_root, sizeof(symlinks));
+       list_for_each_entry(name_loop, &udevice->symlink_list, node) {
+               info(udevice->udev, "update symlink '%s' of '%s'\n", name_loop->name, udevice->dev->devpath);
+               update_link(udevice, name_loop->name);
+               strlcat(symlinks, udev_get_dev_path(udevice->udev), sizeof(symlinks));
                strlcat(symlinks, "/", sizeof(symlinks));
                strlcat(symlinks, name_loop->name, sizeof(symlinks));
                strlcat(symlinks, " ", sizeof(symlinks));
@@ -292,15 +291,15 @@ void udev_node_update_symlinks(struct udevice *udev, struct udevice *udev_old)
                setenv("DEVLINKS", symlinks, 1);
 
        /* update possible left-over symlinks (device metadata changed) */
-       if (udev_old != NULL) {
+       if (udevice_old != NULL) {
                struct name_entry *link_loop;
                struct name_entry *link_old_loop;
                int found;
 
                /* remove current symlinks from old list */
-               list_for_each_entry(link_old_loop, &udev_old->symlink_list, node) {
+               list_for_each_entry(link_old_loop, &udevice_old->symlink_list, node) {
                        found = 0;
-                       list_for_each_entry(link_loop, &udev->symlink_list, node) {
+                       list_for_each_entry(link_loop, &udevice->symlink_list, node) {
                                if (strcmp(link_old_loop->name, link_loop->name) == 0) {
                                        found = 1;
                                        break;
@@ -308,9 +307,9 @@ void udev_node_update_symlinks(struct udevice *udev, struct udevice *udev_old)
                        }
                        if (!found) {
                                /* link does no longer belong to this device */
-                               info("update old symlink '%s' no longer belonging to '%s'\n",
-                                    link_old_loop->name, udev->dev->devpath);
-                               update_link(udev, link_old_loop->name);
+                               info(udevice->udev, "update old symlink '%s' no longer belonging to '%s'\n",
+                                    link_old_loop->name, udevice->dev->devpath);
+                               update_link(udevice, link_old_loop->name);
                        }
                }
 
@@ -318,12 +317,12 @@ void udev_node_update_symlinks(struct udevice *udev, struct udevice *udev_old)
                 * if the node name has changed, delete the node,
                 * or possibly restore a symlink of another device
                 */
-               if (strcmp(udev->name, udev_old->name) != 0)
-                       update_link(udev, udev_old->name);
+               if (strcmp(udevice->name, udevice_old->name) != 0)
+                       update_link(udevice, udevice_old->name);
        }
 }
 
-int udev_node_add(struct udevice *udev)
+int udev_node_add(struct udevice *udevice)
 {
        char filename[PATH_SIZE];
        uid_t uid;
@@ -331,42 +330,42 @@ int udev_node_add(struct udevice *udev)
        int i;
        int retval = 0;
 
-       strlcpy(filename, udev_root, sizeof(filename));
+       strlcpy(filename, udev_get_dev_path(udevice->udev), sizeof(filename));
        strlcat(filename, "/", sizeof(filename));
-       strlcat(filename, udev->name, sizeof(filename));
-       create_path(filename);
+       strlcat(filename, udevice->name, sizeof(filename));
+       create_path(udevice->udev, filename);
 
-       if (strcmp(udev->owner, "root") == 0)
+       if (strcmp(udevice->owner, "root") == 0)
                uid = 0;
        else {
                char *endptr;
                unsigned long id;
 
-               id = strtoul(udev->owner, &endptr, 10);
+               id = strtoul(udevice->owner, &endptr, 10);
                if (endptr[0] == '\0')
                        uid = (uid_t) id;
                else
-                       uid = lookup_user(udev->owner);
+                       uid = lookup_user(udevice->udev, udevice->owner);
        }
 
-       if (strcmp(udev->group, "root") == 0)
+       if (strcmp(udevice->group, "root") == 0)
                gid = 0;
        else {
                char *endptr;
                unsigned long id;
 
-               id = strtoul(udev->group, &endptr, 10);
+               id = strtoul(udevice->group, &endptr, 10);
                if (endptr[0] == '\0')
                        gid = (gid_t) id;
                else
-                       gid = lookup_group(udev->group);
+                       gid = lookup_group(udevice->udev, udevice->group);
        }
 
-       info("creating device node '%s', major=%d, minor=%d, mode=%#o, uid=%d, gid=%d\n",
-            filename, major(udev->devt), minor(udev->devt), udev->mode, uid, gid);
+       info(udevice->udev, "creating device node '%s', major=%d, minor=%d, mode=%#o, uid=%d, gid=%d\n",
+            filename, major(udevice->devt), minor(udevice->devt), udevice->mode, uid, gid);
 
-       if (!udev->test_run)
-               if (udev_node_mknod(udev, filename, udev->devt, udev->mode, uid, gid) != 0) {
+       if (!udevice->test_run)
+               if (udev_node_mknod(udevice, filename, udevice->devt, udevice->mode, uid, gid) != 0) {
                        retval = -1;
                        goto exit;
                }
@@ -374,27 +373,27 @@ int udev_node_add(struct udevice *udev)
        setenv("DEVNAME", filename, 1);
 
        /* create all_partitions if requested */
-       if (udev->partitions) {
+       if (udevice->partitions) {
                char partitionname[PATH_SIZE];
                char *attr;
                int range;
 
                /* take the maximum registered minor range */
-               attr = sysfs_attr_get_value(udev->dev->devpath, "range");
+               attr = sysfs_attr_get_value(udevice->udev, udevice->dev->devpath, "range");
                if (attr != NULL) {
                        range = atoi(attr);
                        if (range > 1)
-                               udev->partitions = range-1;
+                               udevice->partitions = range-1;
                }
-               info("creating device partition nodes '%s[1-%i]'\n", filename, udev->partitions);
-               if (!udev->test_run) {
-                       for (i = 1; i <= udev->partitions; i++) {
+               info(udevice->udev, "creating device partition nodes '%s[1-%i]'\n", filename, udevice->partitions);
+               if (!udevice->test_run) {
+                       for (i = 1; i <= udevice->partitions; i++) {
                                dev_t part_devt;
 
                                snprintf(partitionname, sizeof(partitionname), "%s%d", filename, i);
                                partitionname[sizeof(partitionname)-1] = '\0';
-                               part_devt = makedev(major(udev->devt), minor(udev->devt) + i);
-                               udev_node_mknod(udev, partitionname, part_devt, udev->mode, uid, gid);
+                               part_devt = makedev(major(udevice->devt), minor(udevice->devt) + i);
+                               udev_node_mknod(udevice, partitionname, part_devt, udevice->mode, uid, gid);
                        }
                }
        }
@@ -402,7 +401,7 @@ exit:
        return retval;
 }
 
-int udev_node_remove(struct udevice *udev)
+int udev_node_remove(struct udevice *udevice)
 {
        char filename[PATH_SIZE];
        char partitionname[PATH_SIZE];
@@ -410,39 +409,39 @@ int udev_node_remove(struct udevice *udev)
        int retval = 0;
        int num;
 
-       strlcpy(filename, udev_root, sizeof(filename));
+       strlcpy(filename, udev_get_dev_path(udevice->udev), sizeof(filename));
        strlcat(filename, "/", sizeof(filename));
-       strlcat(filename, udev->name, sizeof(filename));
+       strlcat(filename, udevice->name, sizeof(filename));
        if (stat(filename, &stats) != 0) {
-               info("device node '%s' not found\n", filename);
+               info(udevice->udev, "device node '%s' not found\n", filename);
                return 0;
        }
-       if (udev->devt && stats.st_rdev != udev->devt) {
-               info("device node '%s' points to a different device, skip removal\n", filename);
+       if (udevice->devt && stats.st_rdev != udevice->devt) {
+               info(udevice->udev, "device node '%s' points to a different device, skip removal\n", filename);
                return -1;
        }
 
-       info("removing device node '%s'\n", filename);
-       if (!udev->test_run)
-               retval = unlink_secure(filename);
+       info(udevice->udev, "removing device node '%s'\n", filename);
+       if (!udevice->test_run)
+               retval = unlink_secure(udevice->udev, filename);
        if (retval)
                return retval;
 
        setenv("DEVNAME", filename, 1);
-       num = udev->partitions;
+       num = udevice->partitions;
        if (num > 0) {
                int i;
 
-               info("removing all_partitions '%s[1-%i]'\n", filename, num);
+               info(udevice->udev, "removing all_partitions '%s[1-%i]'\n", filename, num);
                if (num > 255)
                        return -1;
                for (i = 1; i <= num; i++) {
                        snprintf(partitionname, sizeof(partitionname), "%s%d", filename, i);
                        partitionname[sizeof(partitionname)-1] = '\0';
-                       if (!udev->test_run)
-                               unlink_secure(partitionname);
+                       if (!udevice->test_run)
+                               unlink_secure(udevice->udev, partitionname);
                }
        }
-       delete_path(filename);
+       delete_path(udevice->udev, filename);
        return retval;
 }