udev/udev_device.c

   1 /*
   2  * Copyright (C) 2004-2006 Kay Sievers <kay.sievers@vrfy.org>
   3  *
   4  *      This program is free software; you can redistribute it and/or modify it
   5  *      under the terms of the GNU General Public License as published by the
   6  *      Free Software Foundation version 2 of the License.
   7  *
   8  *      This program is distributed in the hope that it will be useful, but
   9  *      WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  *      General Public License for more details.
  12  *
  13  *      You should have received a copy of the GNU General Public License along
  14  *      with this program; if not, write to the Free Software Foundation, Inc.,
  15  *      51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  16  *
  17  */
  18
  19
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <stddef.h>
  23 #include <unistd.h>
  24 #include <fcntl.h>
  25 #include <errno.h>
  26 #include <ctype.h>
  27 #include <string.h>
  28 #include <sys/ioctl.h>
  29 #include <sys/socket.h>
  30 #include <net/if.h>
  31 #include <linux/sockios.h>
  32
  33 #include "udev.h"
  34 #include "udev_rules.h"
  35
  36
  37 struct udevice *udev_device_init(struct udevice *udev)
  38 {
  39         if (udev == NULL)
  40                 udev = malloc(sizeof(struct udevice));
  41         if (udev == NULL)
  42                 return NULL;
  43         memset(udev, 0x00, sizeof(struct udevice));
  44
  45         INIT_LIST_HEAD(&udev->symlink_list);
  46         INIT_LIST_HEAD(&udev->run_list);
  47         INIT_LIST_HEAD(&udev->env_list);
  48
  49         /* set sysfs device to local storage, can be overridden if needed */
  50         udev->dev = &udev->dev_local;
  51
  52         /* default node permissions */
  53         udev->mode = 0660;
  54         strcpy(udev->owner, "root");
  55         strcpy(udev->group, "root");
  56
  57         udev->event_timeout = -1;
  58
  59         return udev;
  60 }
  61
  62 void udev_device_cleanup(struct udevice *udev)
  63 {
  64         name_list_cleanup(&udev->symlink_list);
  65         name_list_cleanup(&udev->run_list);
  66         name_list_cleanup(&udev->env_list);
  67         free(udev);
  68 }
  69
  70 dev_t udev_device_get_devt(struct udevice *udev)
  71 {
  72         const char *attr;
  73         unsigned int maj, min;
  74
  75         /* read it from sysfs  */
  76         attr = sysfs_attr_get_value(udev->dev->devpath, "dev");
  77         if (attr != NULL) {
  78                 if (sscanf(attr, "%u:%u", &maj, &min) == 2)
  79                         return makedev(maj, min);
  80         }
  81         return makedev(0, 0);
  82 }
  83
  84 static void kernel_log(struct ifreq ifr)
  85 {
  86         int klog;
  87         FILE *f;
  88
  89         klog = open("/dev/kmsg", O_WRONLY);
  90         if (klog < 0)
  91                 return;
  92
  93         f = fdopen(klog, "w");
  94         if (f == NULL) {
  95                 close(klog);
  96                 return;
  97         }
  98
  99         fprintf(f, "<6>udev: renamed network interface %s to %s\n",
 100                 ifr.ifr_name, ifr.ifr_newname);
 101         fclose(f);
 102 }
 103
 104 static int rename_netif(struct udevice *udev)
 105 {
 106         int sk;
 107         struct ifreq ifr;
 108         int retval;
 109
 110         info("changing net interface name from '%s' to '%s'\n", udev->dev->kernel, udev->name);
 111         if (udev->test_run)
 112                 return 0;
 113
 114         sk = socket(PF_INET, SOCK_DGRAM, 0);
 115         if (sk < 0) {
 116                 err("error opening socket: %s\n", strerror(errno));
 117                 return -1;
 118         }
 119
 120         memset(&ifr, 0x00, sizeof(struct ifreq));
 121         strlcpy(ifr.ifr_name, udev->dev->kernel, IFNAMSIZ);
 122         strlcpy(ifr.ifr_newname, udev->name, IFNAMSIZ);
 123         retval = ioctl(sk, SIOCSIFNAME, &ifr);
 124         if (retval == 0)
 125                 kernel_log(ifr);
 126         else {
 127                 int loop;
 128
 129                 /* see if the destination interface name already exists */
 130                 if (errno != EEXIST) {
 131                         err("error changing netif name %s to %s: %s\n", ifr.ifr_name, ifr.ifr_newname, strerror(errno));
 132                         goto exit;
 133                 }
 134
 135                 /* free our own name, another process may wait for us */
 136                 strlcpy(ifr.ifr_newname, udev->dev->kernel, IFNAMSIZ);
 137                 strlcat(ifr.ifr_newname, "_rename", IFNAMSIZ);
 138                 retval = ioctl(sk, SIOCSIFNAME, &ifr);
 139                 if (retval != 0) {
 140                         err("error changing netif name %s to %s: %s\n", ifr.ifr_name, ifr.ifr_newname, strerror(errno));
 141                         goto exit;
 142                 }
 143
 144                 /* wait 30 seconds for our target to become available */
 145                 strlcpy(ifr.ifr_name, ifr.ifr_newname, IFNAMSIZ);
 146                 strlcpy(ifr.ifr_newname, udev->name, IFNAMSIZ);
 147                 loop = 30 * 20;
 148                 while (loop--) {
 149                         retval = ioctl(sk, SIOCSIFNAME, &ifr);
 150                         if (retval == 0) {
 151                                 kernel_log(ifr);
 152                                 break;
 153                         }
 154
 155                         if (errno != EEXIST) {
 156                                 err("error changing net interface name %s to %s: %s\n",
 157                                     ifr.ifr_name, ifr.ifr_newname, strerror(errno));
 158                                 break;
 159                         }
 160                         dbg("wait for netif '%s' to become free, loop=%i\n", udev->name, (30 * 20) - loop);
 161                         usleep(1000 * 1000 / 20);
 162                 }
 163         }
 164
 165 exit:
 166         close(sk);
 167         return retval;
 168 }
 169
 170 int udev_device_event(struct udev_rules *rules, struct udevice *udev)
 171 {
 172         int retval = 0;
 173
 174         if (udev->devpath_old != NULL)
 175                 if (udev_db_rename(udev->devpath_old, udev->dev->devpath) == 0)
 176                         info("moved database from '%s' to '%s'\n", udev->devpath_old, udev->dev->devpath);
 177
 178         /* add device node */
 179         if (major(udev->devt) != 0 &&
 180             (strcmp(udev->action, "add") == 0 || strcmp(udev->action, "change") == 0)) {
 181                 struct udevice *udev_old;
 182
 183                 dbg("device node add '%s'\n", udev->dev->devpath);
 184
 185                 udev_rules_get_name(rules, udev);
 186                 if (udev->ignore_device) {
 187                         info("device event will be ignored\n");
 188                         goto exit;
 189                 }
 190                 if (udev->name[0] == '\0') {
 191                         info("device node creation supressed\n");
 192                         goto exit;
 193                 }
 194
 195                 /* read current database entry; cleanup, if it is known device */
 196                 udev_old = udev_device_init(NULL);
 197                 if (udev_old != NULL) {
 198                         udev_old->test_run = udev->test_run;
 199                         if (udev_db_get_device(udev_old, udev->dev->devpath) == 0) {
 200                                 info("device '%s' already in database, cleanup\n", udev->dev->devpath);
 201                                 udev_db_delete_device(udev_old);
 202                         } else {
 203                                 udev_device_cleanup(udev_old);
 204                                 udev_old = NULL;
 205                         }
 206                 }
 207
 208                 /* create node */
 209                 retval = udev_node_add(udev);
 210                 if (retval != 0)
 211                         goto exit;
 212
 213                 /* store in database */
 214                 udev_db_add_device(udev);
 215
 216                 /* create, replace, delete symlinks according to priority */
 217                 udev_node_update_symlinks(udev, udev_old);
 218
 219                 if (udev_old != NULL)
 220                         udev_device_cleanup(udev_old);
 221                 goto exit;
 222         }
 223
 224         /* add netif */
 225         if (strcmp(udev->dev->subsystem, "net") == 0 && strcmp(udev->action, "add") == 0) {
 226                 dbg("netif add '%s'\n", udev->dev->devpath);
 227                 udev_rules_get_name(rules, udev);
 228                 if (udev->ignore_device) {
 229                         info("device event will be ignored\n");
 230                         goto exit;
 231                 }
 232                 if (udev->name[0] == '\0') {
 233                         info("device renaming supressed\n");
 234                         goto exit;
 235                 }
 236
 237                 /* look if we want to change the name of the netif */
 238                 if (strcmp(udev->name, udev->dev->kernel) != 0) {
 239                         char devpath[PATH_MAX];
 240                         char *pos;
 241
 242                         retval = rename_netif(udev);
 243                         if (retval != 0)
 244                                 goto exit;
 245                         info("renamed netif to '%s'\n", udev->name);
 246
 247                         /* export old name */
 248                         setenv("INTERFACE_OLD", udev->dev->kernel, 1);
 249
 250                         /* now change the devpath, because the kernel device name has changed */
 251                         strlcpy(devpath, udev->dev->devpath, sizeof(devpath));
 252                         pos = strrchr(devpath, '/');
 253                         if (pos != NULL) {
 254                                 pos[1] = '\0';
 255                                 strlcat(devpath, udev->name, sizeof(devpath));
 256                                 sysfs_device_set_values(udev->dev, devpath, NULL, NULL);
 257                                 setenv("DEVPATH", udev->dev->devpath, 1);
 258                                 setenv("INTERFACE", udev->name, 1);
 259                                 info("changed devpath to '%s'\n", udev->dev->devpath);
 260                         }
 261                 }
 262                 goto exit;
 263         }
 264
 265         /* remove device node */
 266         if (major(udev->devt) != 0 && strcmp(udev->action, "remove") == 0) {
 267                 struct name_entry *name_loop;
 268
 269                 /* import database entry, and delete it */
 270                 if (udev_db_get_device(udev, udev->dev->devpath) == 0) {
 271                         udev_db_delete_device(udev);
 272                         /* restore stored persistent data */
 273                         list_for_each_entry(name_loop, &udev->env_list, node)
 274                                 putenv(name_loop->name);
 275                 } else {
 276                         dbg("'%s' not found in database, using kernel name '%s'\n",
 277                             udev->dev->devpath, udev->dev->kernel);
 278                         strlcpy(udev->name, udev->dev->kernel, sizeof(udev->name));
 279                 }
 280
 281                 udev_rules_get_run(rules, udev);
 282                 if (udev->ignore_device) {
 283                         info("device event will be ignored\n");
 284                         goto exit;
 285                 }
 286
 287                 if (udev->ignore_remove) {
 288                         info("ignore_remove for '%s'\n", udev->name);
 289                         goto exit;
 290                 }
 291                 /* remove the node */
 292                 retval = udev_node_remove(udev);
 293
 294                 /* delete or restore symlinks according to priority */
 295                 udev_node_update_symlinks(udev, NULL);
 296                 goto exit;
 297         }
 298
 299         /* default devices */
 300         udev_rules_get_run(rules, udev);
 301         if (udev->ignore_device)
 302                 info("device event will be ignored\n");
 303
 304 exit:
 305         return retval;
 306 }