usr/src/cmd/hal/hald/solaris/devinfo.c

   1 /***************************************************************************
   2  *
   3  * devinfo.c : main file for libdevinfo-based device enumeration
   4  *
   5  * Copyright 2013 Garrett D'Amore <garrett@damore.org>
   6  * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
   7  *
   8  * Licensed under the Academic Free License version 2.1
   9  *
  10  **************************************************************************/
  11
  12 #ifdef HAVE_CONFIG_H
  13 #  include <config.h>
  14 #endif
  15
  16 #include <stdio.h>
  17 #include <string.h>
  18 #include <libdevinfo.h>
  19
  20 #include "../osspec.h"
  21 #include "../logger.h"
  22 #include "../hald.h"
  23 #include "../hald_dbus.h"
  24 #include "../device_info.h"
  25 #include "../util.h"
  26 #include "../hald_runner.h"
  27 #include "osspec_solaris.h"
  28 #include "hotplug.h"
  29 #include "devinfo.h"
  30 #include "devinfo_pci.h"
  31 #include "devinfo_storage.h"
  32 #include "devinfo_ieee1394.h"
  33 #include "devinfo_usb.h"
  34 #include "devinfo_misc.h"
  35 #include "devinfo_acpi.h"
  36 #include "devinfo_cpu.h"
  37
  38 void devinfo_add_subtree(HalDevice *parent, di_node_t node, gboolean is_root);
  39 HalDevice *devinfo_add_node(HalDevice *parent, di_node_t node);
  40
  41 void
  42 devinfo_add(HalDevice *parent, gchar *path)
  43 {
  44         di_node_t       root;
  45
  46         if (strcmp (path, "/") == 0) {
  47                 if ((root = di_init(path, DINFOCACHE)) == DI_NODE_NIL) {
  48                         HAL_INFO (("di_init() failed %d", errno));
  49                         return;
  50                 }
  51         } else {
  52                 if ((root = di_init(path, DINFOCPYALL)) == DI_NODE_NIL) {
  53                         HAL_INFO (("di_init() failed %d", errno));
  54                         return;
  55                 }
  56         }
  57
  58         devinfo_add_subtree(parent, root, TRUE);
  59
  60         di_fini (root);
  61 }
  62
  63 void
  64 devinfo_add_subtree(HalDevice *parent, di_node_t node, gboolean is_root)
  65 {
  66         HalDevice *d;
  67         di_node_t root_node, child_node;
  68
  69         HAL_INFO (("add_subtree: %s", di_node_name (node)));
  70
  71         root_node = node;
  72         do {
  73                 d = devinfo_add_node (parent, node);
  74
  75                 if ((d != NULL) &&
  76                     (child_node = di_child_node (node)) != DI_NODE_NIL) {
  77                         devinfo_add_subtree (d, child_node, FALSE);
  78                 }
  79
  80                 node = di_sibling_node (node);
  81         } while ((node != DI_NODE_NIL) &&
  82                 (!is_root || di_parent_node (node) == root_node));
  83 }
  84
  85 void
  86 devinfo_set_default_properties (HalDevice *d, HalDevice *parent, di_node_t node, char *devfs_path)
  87 {
  88         char    *driver_name, *s;
  89         const char *s1;
  90         char    udi[HAL_PATH_MAX];
  91
  92         if (parent != NULL) {
  93                 hal_device_property_set_string (d, "info.parent", hal_device_get_udi (parent));
  94         } else {
  95                 hal_device_property_set_string (d, "info.parent", "/org/freedesktop/Hal/devices/local");
  96         }
  97
  98         hal_util_compute_udi (hald_get_gdl (), udi, sizeof (udi),
  99                                 "/org/freedesktop/Hal/devices%s_%d",
 100                                 devfs_path,
 101                                 di_instance (node));
 102         hal_device_set_udi (d, udi);
 103         hal_device_property_set_string (d, "info.udi", udi);
 104
 105         if (di_prop_lookup_strings (DDI_DEV_T_ANY, node, "model", &s) > 0) {
 106                 hal_device_property_set_string (d, "info.product", s);
 107         } else {
 108                 hal_device_property_set_string (d, "info.product", di_node_name (node));
 109         }
 110
 111         hal_device_property_set_string (d, "solaris.devfs_path", devfs_path);
 112
 113         if ((driver_name = di_driver_name (node)) != NULL) {
 114                 hal_device_property_set_string (d, "info.solaris.driver",
 115                                                 driver_name);
 116         }
 117
 118
 119         /* inherit parent's claim attributes */
 120         if (hal_device_property_get_bool (parent, "info.claimed")) {
 121                 s1 = hal_device_property_get_string (parent, "info.claimed.service");
 122                 if (s1 != NULL) {
 123                         hal_device_property_set_bool (d, "info.claimed", TRUE);
 124                         hal_device_property_set_string (d, "info.claimed.service", s1);
 125                 }
 126         }
 127 }
 128
 129 /* device handlers, ordered specific to generic */
 130 static DevinfoDevHandler *devinfo_handlers[] = {
 131         &devinfo_computer_handler,
 132         &devinfo_cpu_handler,
 133         &devinfo_ide_handler,
 134         &devinfo_scsi_handler,
 135         &devinfo_blkdev_handler,
 136         &devinfo_floppy_handler,
 137         &devinfo_usb_handler,
 138         &devinfo_ieee1394_handler,
 139         &devinfo_lofi_handler,
 140         &devinfo_acpi_handler,
 141         &devinfo_power_button_handler,
 142         &devinfo_keyboard_handler,
 143         &devinfo_mouse_handler,
 144         &devinfo_pci_handler,
 145         &devinfo_default_handler,
 146         NULL
 147 };
 148
 149 HalDevice *
 150 devinfo_add_node(HalDevice *parent, di_node_t node)
 151 {
 152         HalDevice *d = NULL;
 153         char    *devfs_path;
 154         char    *device_type = NULL;
 155         DevinfoDevHandler *handler;
 156         int     i;
 157
 158         devfs_path = di_devfs_path (node);
 159
 160         (void) di_prop_lookup_strings (DDI_DEV_T_ANY, node, "device_type",
 161             &device_type);
 162
 163         for (i = 0; (d == NULL) && (devinfo_handlers[i] != NULL); i++) {
 164                 handler = devinfo_handlers[i];
 165                 d = handler->add (parent, node, devfs_path, device_type);
 166         }
 167
 168         di_devfs_path_free(devfs_path);
 169
 170         HAL_INFO (("add_node: %s", d ? hal_device_get_udi (d) : "none"));
 171         return (d);
 172 }
 173
 174 void
 175 devinfo_hotplug_enqueue(HalDevice *d, gchar *devfs_path, DevinfoDevHandler *handler, int action, int front)
 176 {
 177         HotplugEvent *hotplug_event;
 178
 179         hotplug_event = g_new0 (HotplugEvent, 1);
 180         hotplug_event->action = action;
 181         hotplug_event->type = HOTPLUG_EVENT_DEVFS;
 182         hotplug_event->d = d;
 183         strlcpy (hotplug_event->un.devfs.devfs_path, devfs_path,
 184                 sizeof (hotplug_event->un.devfs.devfs_path));
 185         hotplug_event->un.devfs.handler = handler;
 186
 187         hotplug_event_enqueue (hotplug_event, front);
 188 }
 189
 190 void
 191 devinfo_add_enqueue(HalDevice *d, gchar *devfs_path, DevinfoDevHandler *handler)
 192 {
 193         devinfo_hotplug_enqueue (d, devfs_path, handler, HOTPLUG_ACTION_ADD, 0);
 194 }
 195
 196 void
 197 devinfo_add_enqueue_at_front(HalDevice *d, gchar *devfs_path, DevinfoDevHandler *handler)
 198 {
 199         devinfo_hotplug_enqueue (d, devfs_path, handler, HOTPLUG_ACTION_ADD, 1);
 200 }
 201
 202 void
 203 devinfo_remove_enqueue(gchar *devfs_path, DevinfoDevHandler *handler)
 204 {
 205         devinfo_hotplug_enqueue (NULL, devfs_path, handler, HOTPLUG_ACTION_REMOVE, 0);
 206 }
 207
 208 void
 209 devinfo_callouts_add_done (HalDevice *d, gpointer userdata1, gpointer userdata2)
 210 {
 211         void *end_token = (void *) userdata1;
 212
 213         /* Move from temporary to global device store */
 214         hal_device_store_remove (hald_get_tdl (), d);
 215         hal_device_store_add (hald_get_gdl (), d);
 216
 217         hotplug_event_end (end_token);
 218 }
 219
 220 void
 221 devinfo_callouts_probing_done (HalDevice *d, guint32 exit_type, gint return_code, char **error, gpointer userdata1, gpointer userdata2)
 222 {
 223         void *end_token = (void *) userdata1;
 224
 225         /* Discard device if probing reports failure */
 226         if (exit_type != HALD_RUN_SUCCESS || (return_code != 0)) {
 227                 HAL_INFO (("Probing for %s failed %d", hal_device_get_udi (d), return_code));
 228                 hal_device_store_remove (hald_get_tdl (), d);
 229                 g_object_unref (d);
 230                 hotplug_event_end (end_token);
 231                 return;
 232         }
 233
 234         /* Merge properties from .fdi files */
 235         di_search_and_merge (d, DEVICE_INFO_TYPE_INFORMATION);
 236         di_search_and_merge (d, DEVICE_INFO_TYPE_POLICY);
 237
 238         hal_util_callout_device_add (d, devinfo_callouts_add_done, end_token, NULL);
 239 }
 240
 241 void
 242 devinfo_callouts_preprobing_done (HalDevice *d, gpointer userdata1, gpointer userdata2)
 243 {
 244         void *end_token = (void *) userdata1;
 245         DevinfoDevHandler *handler = (DevinfoDevHandler *) userdata2;
 246         void (*probing_done) (HalDevice *, guint32, gint, char **, gpointer, gpointer);
 247         const gchar *prober;
 248         int prober_timeout;
 249
 250         if (hal_device_property_get_bool (d, "info.ignore")) {
 251                 HAL_INFO (("Preprobing merged info.ignore==TRUE"));
 252
 253                 /* Leave device with info.ignore==TRUE so we won't pick up children */
 254                 hal_device_property_remove (d, "info.category");
 255                 hal_device_property_remove (d, "info.capabilities");
 256
 257                 hal_device_store_remove (hald_get_tdl (), d);
 258                 hal_device_store_add (hald_get_gdl (), d);
 259
 260                 hotplug_event_end (end_token);
 261                 return;
 262         }
 263
 264         if (handler != NULL && handler->get_prober != NULL) {
 265                 prober = handler->get_prober (d, &prober_timeout);
 266         } else {
 267                 prober = NULL;
 268         }
 269
 270         if (handler->probing_done != NULL) {
 271                 probing_done = handler->probing_done;
 272         } else {
 273                 probing_done = devinfo_callouts_probing_done;
 274         }
 275
 276         if (prober != NULL) {
 277                 /* probe the device */
 278                 HAL_INFO(("Probing udi=%s", hal_device_get_udi (d)));
 279                 hald_runner_run (d,
 280                                 prober, NULL,
 281                                 prober_timeout,
 282                                 probing_done,
 283                                 (gpointer) end_token, (gpointer) handler);
 284         } else {
 285                 probing_done (d, 0, 0, NULL, userdata1, userdata2);
 286         }
 287 }
 288
 289 /* This is the beginning of hotplug even handling */
 290 void
 291 hotplug_event_begin_add_devinfo (HalDevice *d, HalDevice *parent, DevinfoDevHandler *handler, void *end_token)
 292 {
 293         HotplugEvent *hotplug_event = (HotplugEvent *)end_token;
 294
 295         HAL_INFO(("Preprobing udi=%s", hal_device_get_udi (d)));
 296
 297         if (parent == NULL && (strcmp(hotplug_event->un.devfs.devfs_path, "/") != 0)) {
 298                 HAL_ERROR (("Parent is NULL, devfs_path=%s", hotplug_event->un.devfs.devfs_path));
 299
 300                 goto skip;
 301         }
 302
 303
 304         if (parent != NULL && hal_device_property_get_bool (parent, "info.ignore")) {
 305                 HAL_INFO (("Ignoring device since parent has info.ignore==TRUE"));
 306
 307                 goto skip;
 308         }
 309
 310         if (hal_device_store_find (hald_get_tdl (), hal_device_get_udi (d)) == NULL) {
 311
 312                 /* add to TDL so preprobing callouts and prober can access it */
 313                 hal_device_store_add (hald_get_tdl (), d);
 314         }
 315
 316         /* Process preprobe fdi files */
 317         di_search_and_merge (d, DEVICE_INFO_TYPE_PREPROBE);
 318
 319         /* Run preprobe callouts */
 320         hal_util_callout_device_preprobe (d, devinfo_callouts_preprobing_done, end_token, handler);
 321
 322         return;
 323
 324 skip:
 325         if (hal_device_store_find (hald_get_tdl (), hal_device_get_udi (d)))
 326                 hal_device_store_remove (hald_get_tdl (), d);
 327
 328         g_object_unref (d);
 329         hotplug_event_end (end_token);
 330
 331         return;
 332 }
 333
 334 void
 335 devinfo_remove (gchar *devfs_path)
 336 {
 337         devinfo_remove_enqueue ((gchar *)devfs_path, NULL);
 338 }
 339
 340 /* generate hotplug event for each device in this branch */
 341 void
 342 devinfo_remove_branch (gchar *devfs_path, HalDevice *d)
 343 {
 344         GSList *i;
 345         GSList *children;
 346         HalDevice *child;
 347         char *child_devfs_path;
 348
 349         if (d == NULL) {
 350                 d = hal_device_store_match_key_value_string (hald_get_gdl (),
 351                         "solaris.devfs_path", devfs_path);
 352                 if (d == NULL)
 353                         return;
 354         }
 355
 356         HAL_INFO (("remove_branch: %s %s\n", devfs_path, hal_device_get_udi (d)));
 357
 358         /* first remove children */
 359         children = hal_device_store_match_multiple_key_value_string (hald_get_gdl(),
 360                 "info.parent", hal_device_get_udi (d));
 361         for (i = children; i != NULL; i = g_slist_next (i)) {
 362                 child = HAL_DEVICE (i->data);
 363                 HAL_INFO (("remove_branch: child %s\n", hal_device_get_udi (child)));
 364                 devinfo_remove_branch ((gchar *)hal_device_property_get_string (child, "solaris.devfs_path"), child);
 365         }
 366         g_slist_free (children);
 367         HAL_INFO (("remove_branch: done with children"));
 368
 369         /* then remove self */
 370         HAL_INFO (("remove_branch: queueing %s", devfs_path));
 371         devinfo_remove_enqueue (devfs_path, NULL);
 372 }
 373
 374 void
 375 devinfo_callouts_remove_done (HalDevice *d, gpointer userdata1, gpointer userdata2)
 376 {
 377         void *end_token = (void *) userdata1;
 378
 379         HAL_INFO (("Remove callouts completed udi=%s", hal_device_get_udi (d)));
 380
 381         if (!hal_device_store_remove (hald_get_gdl (), d)) {
 382                 HAL_WARNING (("Error removing device"));
 383         }
 384         g_object_unref (d);
 385
 386         hotplug_event_end (end_token);
 387 }
 388
 389 void
 390 hotplug_event_begin_remove_devinfo (HalDevice *d, gchar *devfs_path, void *end_token)
 391 {
 392         if (hal_device_has_capability (d, "volume")) {
 393                 devinfo_volume_hotplug_begin_remove (d, devfs_path, end_token);
 394         } else {
 395                 hal_util_callout_device_remove (d, devinfo_callouts_remove_done, end_token, NULL);
 396         }
 397 }
 398
 399 gboolean
 400 devinfo_device_rescan (HalDevice *d)
 401 {
 402         if (hal_device_has_capability (d, "block")) {
 403                 return (devinfo_storage_device_rescan (d));
 404         } else if (hal_device_has_capability (d, "button")) {
 405                 return (devinfo_lid_rescan (d));
 406         } else {
 407                 return (FALSE);
 408         }
 409 }
 410
 411 static int
 412 walk_devlinks(di_devlink_t devlink, void *arg)
 413 {
 414         char    **path= (char **)arg;
 415
 416         *path = strdup(di_devlink_path(devlink));
 417
 418         return (DI_WALK_TERMINATE);
 419 }
 420
 421 char *
 422 get_devlink(di_devlink_handle_t devlink_hdl, char *re, char *path)
 423 {
 424         char    *devlink_path = NULL;
 425
 426         (void) di_devlink_walk(devlink_hdl, re, path,
 427             DI_PRIMARY_LINK, &devlink_path, walk_devlinks);
 428
 429         return (devlink_path);
 430 }