device.c

   1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU General Public License as published by
  10   the Free Software Foundation; either version 2 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   General Public License for more details.
  17
  18   You should have received a copy of the GNU General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <errno.h>
  23 #include <sys/epoll.h>
  24 #include <libudev.h>
  25
  26 #include "unit.h"
  27 #include "device.h"
  28 #include "strv.h"
  29 #include "log.h"
  30
  31 static const UnitActiveState state_translation_table[_DEVICE_STATE_MAX] = {
  32         [DEVICE_DEAD] = UNIT_INACTIVE,
  33         [DEVICE_AVAILABLE] = UNIT_ACTIVE
  34 };
  35
  36 static const char* const state_string_table[_DEVICE_STATE_MAX] = {
  37         [DEVICE_DEAD] = "dead",
  38         [DEVICE_AVAILABLE] = "available"
  39 };
  40
  41 static void device_done(Unit *u) {
  42         Device *d = DEVICE(u);
  43
  44         assert(d);
  45
  46         free(d->sysfs);
  47         d->sysfs = NULL;
  48 }
  49
  50 static void device_init(Unit *u) {
  51         Device *d = DEVICE(u);
  52
  53         assert(d);
  54         assert(u->meta.load_state == UNIT_STUB);
  55
  56         d->state = 0;
  57 }
  58
  59 static void device_set_state(Device *d, DeviceState state) {
  60         DeviceState old_state;
  61         assert(d);
  62
  63         old_state = d->state;
  64         d->state = state;
  65
  66         if (state != old_state)
  67                 log_debug("%s changed %s → %s", unit_id(UNIT(d)), state_string_table[old_state], state_string_table[state]);
  68
  69         unit_notify(UNIT(d), state_translation_table[old_state], state_translation_table[state]);
  70 }
  71
  72 static int device_coldplug(Unit *u) {
  73         Device *d = DEVICE(u);
  74
  75         assert(d);
  76         assert(d->state == DEVICE_DEAD);
  77
  78         if (d->sysfs)
  79                 device_set_state(d, DEVICE_AVAILABLE);
  80
  81         return 0;
  82 }
  83
  84 static void device_dump(Unit *u, FILE *f, const char *prefix) {
  85         Device *d = DEVICE(u);
  86
  87         assert(d);
  88
  89         fprintf(f,
  90                 "%sDevice State: %s\n"
  91                 "%sSysfs Path: %s\n",
  92                 prefix, state_string_table[d->state],
  93                 prefix, strna(d->sysfs));
  94 }
  95
  96 static UnitActiveState device_active_state(Unit *u) {
  97         assert(u);
  98
  99         return state_translation_table[DEVICE(u)->state];
 100 }
 101
 102 static int device_add_escaped_name(Unit *u, const char *dn, bool make_id) {
 103         char *e;
 104         int r;
 105
 106         assert(u);
 107         assert(dn);
 108         assert(dn[0] == '/');
 109
 110         if (!(e = unit_name_escape_path(dn+1, ".device")))
 111                 return -ENOMEM;
 112
 113         r = unit_add_name(u, e);
 114
 115         if (r >= 0 && make_id)
 116                 unit_choose_id(u, e);
 117
 118         free(e);
 119
 120         if (r < 0 && r != -EEXIST)
 121                 return r;
 122
 123         return 0;
 124 }
 125
 126 static int device_find_escape_name(Manager *m, const char *dn, Unit **_u) {
 127         char *e;
 128         Unit *u;
 129
 130         assert(m);
 131         assert(dn);
 132         assert(dn[0] == '/');
 133         assert(_u);
 134
 135         if (!(e = unit_name_escape_path(dn+1, ".device")))
 136                 return -ENOMEM;
 137
 138         u = manager_get_unit(m, e);
 139         free(e);
 140
 141         if (u) {
 142                 *_u = u;
 143                 return 1;
 144         }
 145
 146         return 0;
 147 }
 148
 149 static bool devnode_is_api(const char *node) {
 150         unsigned i;
 151
 152         static const char * const table[] = {
 153                 "/dev/null",
 154                 "/dev/zero",
 155                 "/dev/urandom",
 156                 "/dev/random",
 157                 "/dev/port",
 158                 "/dev/oldmem",
 159                 "/dev/full",
 160                 "/dev/kmsg",
 161                 "/dev/mem"
 162         };
 163
 164         for (i = 0; i < ELEMENTSOF(table); i++)
 165                 if (streq(table[i], node))
 166                         return true;
 167
 168         return false;
 169 }
 170
 171 static int device_process_new_device(Manager *m, struct udev_device *dev, bool update_state) {
 172         const char *dn, *names, *wants, *sysfs, *expose, *model;
 173         Unit *u = NULL;
 174         int r;
 175         char *w, *state;
 176         size_t l;
 177         bool delete;
 178         struct udev_list_entry *item = NULL, *first = NULL;
 179
 180         assert(m);
 181
 182         if (!(sysfs = udev_device_get_syspath(dev)))
 183                 return -ENOMEM;
 184
 185         /* Check whether this entry is even relevant for us. */
 186         dn = udev_device_get_devnode(dev);
 187         expose = udev_device_get_property_value(dev, "SYSTEMD_EXPOSE");
 188         names = udev_device_get_property_value(dev, "SYSTEMD_NAMES");
 189         wants = udev_device_get_property_value(dev, "SYSTEMD_WANTS");
 190
 191         if (expose) {
 192                 int b;
 193
 194                 if ((b = parse_boolean(expose)) < 0) {
 195                         log_error("Failed to parse SYSTEMD_EXPOSE udev property for device %s: %s", sysfs, expose);
 196                         return 0;
 197                 }
 198
 199                 if (!b)
 200                         return 0;
 201         } else
 202                 if ((!dn || devnode_is_api(dn)) && !names && !wants)
 203                         return 0;
 204
 205         /* Ok, seems kinda interesting. Now, let's see if this one
 206          * already exists. */
 207
 208         if ((r = device_find_escape_name(m, sysfs, &u)) < 0)
 209                 return r;
 210
 211         if (r == 0 && dn)
 212                 if ((r = device_find_escape_name(m, dn, &u)) < 0)
 213                         return r;
 214
 215         if (r == 0) {
 216                 first = udev_device_get_devlinks_list_entry(dev);
 217                 udev_list_entry_foreach(item, first) {
 218                         if ((r = device_find_escape_name(m, udev_list_entry_get_name(item), &u)) < 0)
 219                                 return r;
 220
 221                         if (r > 0)
 222                                 break;
 223                 }
 224         }
 225
 226         /* FIXME: this needs proper merging */
 227
 228         assert((r > 0) == !!u);
 229
 230         /* If this is a different unit, then let's not merge things */
 231         if (u && DEVICE(u)->sysfs && !streq(DEVICE(u)->sysfs, sysfs))
 232                 u = NULL;
 233
 234         if (!u) {
 235                 delete = true;
 236
 237                 if (!(u = unit_new(m)))
 238                         return -ENOMEM;
 239
 240                 if ((r = device_add_escaped_name(u, sysfs, true)) < 0)
 241                         goto fail;
 242
 243                 unit_add_to_load_queue(u);
 244         } else
 245                 delete = false;
 246
 247         if (!(DEVICE(u)->sysfs))
 248                 if (!(DEVICE(u)->sysfs = strdup(sysfs))) {
 249                         r = -ENOMEM;
 250                         goto fail;
 251                 }
 252
 253         if (dn)
 254                 if ((r = device_add_escaped_name(u, dn, true)) < 0)
 255                         goto fail;
 256
 257         first = udev_device_get_devlinks_list_entry(dev);
 258         udev_list_entry_foreach(item, first)
 259                 if ((r = device_add_escaped_name(u, udev_list_entry_get_name(item), false)) < 0)
 260                         goto fail;
 261
 262         if ((model = udev_device_get_property_value(dev, "ID_MODEL_FROM_DATABASE")) ||
 263             (model = udev_device_get_property_value(dev, "ID_MODEL"))) {
 264                 if ((r = unit_set_description(u, model)) < 0)
 265                         goto fail;
 266         } else if (dn)
 267                 if ((r = unit_set_description(u, dn)) < 0)
 268                         goto fail;
 269
 270         /* We don't remove names that are gone. But that should be
 271          * fine and should probably be fixed only on a configuration
 272          * refresh. */
 273
 274         if (names) {
 275                 FOREACH_WORD(w, l, names, state) {
 276                         char *e;
 277
 278                         if (!(e = strndup(w, l))) {
 279                                 r = -ENOMEM;
 280                                 goto fail;
 281                         }
 282
 283                         r = unit_add_name(u, e);
 284                         free(e);
 285
 286                         if (r < 0 && r != -EEXIST)
 287                                 goto fail;
 288                 }
 289         }
 290
 291         if (wants) {
 292                 FOREACH_WORD(w, l, wants, state) {
 293                         char *e;
 294
 295                         if (!(e = strndup(w, l))) {
 296                                 r = -ENOMEM;
 297                                 goto fail;
 298                         }
 299
 300                         r = unit_add_dependency_by_name(u, UNIT_WANTS, e);
 301                         free(e);
 302
 303                         if (r < 0)
 304                                 goto fail;
 305                 }
 306         }
 307
 308         if (update_state) {
 309                 manager_dispatch_load_queue(u->meta.manager);
 310                 device_set_state(DEVICE(u), DEVICE_AVAILABLE);
 311         }
 312
 313         unit_add_to_dbus_queue(u);
 314
 315         return 0;
 316
 317 fail:
 318         if (delete && u)
 319                 unit_free(u);
 320         return r;
 321 }
 322
 323 static int device_process_path(Manager *m, const char *path, bool update_state) {
 324         int r;
 325         struct udev_device *dev;
 326
 327         assert(m);
 328         assert(path);
 329
 330         if (!(dev = udev_device_new_from_syspath(m->udev, path))) {
 331                 log_warning("Failed to get udev device object from udev for path %s.", path);
 332                 return -ENOMEM;
 333         }
 334
 335         r = device_process_new_device(m, dev, update_state);
 336         udev_device_unref(dev);
 337         return r;
 338 }
 339
 340 static int device_process_removed_device(Manager *m, struct udev_device *dev) {
 341         const char *sysfs;
 342         char *e;
 343         Unit *u;
 344         Device *d;
 345
 346         assert(m);
 347         assert(dev);
 348
 349         if (!(sysfs = udev_device_get_syspath(dev)))
 350                 return -ENOMEM;
 351
 352         assert(sysfs[0] == '/');
 353         if (!(e = unit_name_escape_path(sysfs+1, ".device")))
 354                 return -ENOMEM;
 355
 356         u = manager_get_unit(m, e);
 357         free(e);
 358
 359         if (!u)
 360                 return 0;
 361
 362         d = DEVICE(u);
 363         free(d->sysfs);
 364         d->sysfs = NULL;
 365
 366         device_set_state(d, DEVICE_DEAD);
 367         return 0;
 368 }
 369
 370 static void device_shutdown(Manager *m) {
 371         assert(m);
 372
 373         if (m->udev_monitor)
 374                 udev_monitor_unref(m->udev_monitor);
 375
 376         if (m->udev)
 377                 udev_unref(m->udev);
 378 }
 379
 380 static int device_enumerate(Manager *m) {
 381         struct epoll_event ev;
 382         int r;
 383         struct udev_enumerate *e = NULL;
 384         struct udev_list_entry *item = NULL, *first = NULL;
 385
 386         assert(m);
 387
 388         if (!(m->udev = udev_new()))
 389                 return -ENOMEM;
 390
 391         if (!(m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev"))) {
 392                 r = -ENOMEM;
 393                 goto fail;
 394         }
 395
 396         if (udev_monitor_enable_receiving(m->udev_monitor) < 0) {
 397                 r = -EIO;
 398                 goto fail;
 399         }
 400
 401         m->udev_watch.type = WATCH_UDEV;
 402         m->udev_watch.fd = udev_monitor_get_fd(m->udev_monitor);
 403
 404         zero(ev);
 405         ev.events = EPOLLIN;
 406         ev.data.ptr = &m->udev_watch;
 407
 408         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_watch.fd, &ev) < 0)
 409                 return -errno;
 410
 411         if (!(e = udev_enumerate_new(m->udev))) {
 412                 r = -ENOMEM;
 413                 goto fail;
 414         }
 415
 416         if (udev_enumerate_scan_devices(e) < 0) {
 417                 r = -EIO;
 418                 goto fail;
 419         }
 420
 421         first = udev_enumerate_get_list_entry(e);
 422         udev_list_entry_foreach(item, first)
 423                 device_process_path(m, udev_list_entry_get_name(item), false);
 424
 425         udev_enumerate_unref(e);
 426         return 0;
 427
 428 fail:
 429         if (e)
 430                 udev_enumerate_unref(e);
 431
 432         device_shutdown(m);
 433         return r;
 434 }
 435
 436 void device_fd_event(Manager *m, int events) {
 437         struct udev_device *dev;
 438         int r;
 439         const char *action;
 440
 441         assert(m);
 442         assert(events == EPOLLIN);
 443
 444         if (!(dev = udev_monitor_receive_device(m->udev_monitor))) {
 445                 log_error("Failed to receive device.");
 446                 return;
 447         }
 448
 449         if (!(action = udev_device_get_action(dev))) {
 450                 log_error("Failed to get udev action string.");
 451                 goto fail;
 452         }
 453
 454         if (streq(action, "remove")) {
 455                 if ((r = device_process_removed_device(m, dev)) < 0) {
 456                         log_error("Failed to process udev device event: %s", strerror(-r));
 457                         goto fail;
 458                 }
 459         } else {
 460                 if ((r = device_process_new_device(m, dev, true)) < 0) {
 461                         log_error("Failed to process udev device event: %s", strerror(-r));
 462                         goto fail;
 463                 }
 464         }
 465
 466 fail:
 467         udev_device_unref(dev);
 468 }
 469
 470 const UnitVTable device_vtable = {
 471         .suffix = ".device",
 472
 473         .init = device_init,
 474         .load = unit_load_fragment_and_dropin_optional,
 475         .done = device_done,
 476         .coldplug = device_coldplug,
 477
 478         .dump = device_dump,
 479
 480         .active_state = device_active_state,
 481
 482         .enumerate = device_enumerate,
 483         .shutdown = device_shutdown
 484 };