1 /*************************************************************************** 2 * 3 * devinfo.c : main file for libdevinfo-based device enumeration 4 * 5 * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 6 * Use is subject to license terms. 7 * 8 * Licensed under the Academic Free License version 2.1 9 * 10 **************************************************************************/ 11 12 #pragma ident "%Z%%M% %I% %E% SMI" 13 14 #ifdef HAVE_CONFIG_H 15 # include <config.h> 16 #endif 17 18 #include <stdio.h> 19 #include <string.h> 20 #include <libdevinfo.h> 21 22 #include "../osspec.h" 23 #include "../logger.h" 24 #include "../hald.h" 25 #include "../hald_dbus.h" 26 #include "../device_info.h" 27 #include "../util.h" 28 #include "../hald_runner.h" 29 #include "osspec_solaris.h" 30 #include "hotplug.h" 31 #include "devinfo.h" 32 #include "devinfo_pci.h" 33 #include "devinfo_storage.h" 34 #include "devinfo_ieee1394.h" 35 #include "devinfo_usb.h" 36 #include "devinfo_misc.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_pcata_handler, 136 &devinfo_floppy_handler, 137 &devinfo_usb_handler, 138 &devinfo_ieee1394_handler, 139 &devinfo_pci_handler, 140 &devinfo_lofi_handler, 141 &devinfo_default_handler, 142 NULL 143 }; 144 145 HalDevice * 146 devinfo_add_node(HalDevice *parent, di_node_t node) 147 { 148 HalDevice *d = NULL; 149 char *devfs_path; 150 char *device_type = NULL; 151 DevinfoDevHandler *handler; 152 int i; 153 154 devfs_path = di_devfs_path (node); 155 156 (void) di_prop_lookup_strings (DDI_DEV_T_ANY, node, "device_type", 157 &device_type); 158 159 for (i = 0; (d == NULL) && (devinfo_handlers[i] != NULL); i++) { 160 handler = devinfo_handlers[i]; 161 d = handler->add (parent, node, devfs_path, device_type); 162 } 163 164 di_devfs_path_free(devfs_path); 165 166 HAL_INFO (("add_node: %s", d ? hal_device_get_udi (d) : "none")); 167 return (d); 168 } 169 170 void 171 devinfo_hotplug_enqueue(HalDevice *d, gchar *devfs_path, DevinfoDevHandler *handler, int action, int front) 172 { 173 HotplugEvent *hotplug_event; 174 175 hotplug_event = g_new0 (HotplugEvent, 1); 176 hotplug_event->action = action; 177 hotplug_event->type = HOTPLUG_EVENT_DEVFS; 178 hotplug_event->d = d; 179 strlcpy (hotplug_event->un.devfs.devfs_path, devfs_path, 180 sizeof (hotplug_event->un.devfs.devfs_path)); 181 hotplug_event->un.devfs.handler = handler; 182 183 hotplug_event_enqueue (hotplug_event, front); 184 } 185 186 void 187 devinfo_add_enqueue(HalDevice *d, gchar *devfs_path, DevinfoDevHandler *handler) 188 { 189 devinfo_hotplug_enqueue (d, devfs_path, handler, HOTPLUG_ACTION_ADD, 0); 190 } 191 192 void 193 devinfo_add_enqueue_at_front(HalDevice *d, gchar *devfs_path, DevinfoDevHandler *handler) 194 { 195 devinfo_hotplug_enqueue (d, devfs_path, handler, HOTPLUG_ACTION_ADD, 1); 196 } 197 198 void 199 devinfo_remove_enqueue(gchar *devfs_path, DevinfoDevHandler *handler) 200 { 201 devinfo_hotplug_enqueue (NULL, devfs_path, handler, HOTPLUG_ACTION_REMOVE, 0); 202 } 203 204 void 205 devinfo_callouts_add_done (HalDevice *d, gpointer userdata1, gpointer userdata2) 206 { 207 void *end_token = (void *) userdata1; 208 209 /* Move from temporary to global device store */ 210 hal_device_store_remove (hald_get_tdl (), d); 211 hal_device_store_add (hald_get_gdl (), d); 212 213 hotplug_event_end (end_token); 214 } 215 216 void 217 devinfo_callouts_probing_done (HalDevice *d, guint32 exit_type, gint return_code, char **error, gpointer userdata1, gpointer userdata2) 218 { 219 void *end_token = (void *) userdata1; 220 221 /* Discard device if probing reports failure */ 222 if (exit_type != HALD_RUN_SUCCESS || (return_code != 0)) { 223 HAL_INFO (("Probing for %s failed %d", hal_device_get_udi (d), return_code)); 224 hal_device_store_remove (hald_get_tdl (), d); 225 g_object_unref (d); 226 hotplug_event_end (end_token); 227 return; 228 } 229 230 /* Merge properties from .fdi files */ 231 di_search_and_merge (d, DEVICE_INFO_TYPE_INFORMATION); 232 di_search_and_merge (d, DEVICE_INFO_TYPE_POLICY); 233 234 hal_util_callout_device_add (d, devinfo_callouts_add_done, end_token, NULL); 235 } 236 237 void 238 devinfo_callouts_preprobing_done (HalDevice *d, gpointer userdata1, gpointer userdata2) 239 { 240 void *end_token = (void *) userdata1; 241 DevinfoDevHandler *handler = (DevinfoDevHandler *) userdata2; 242 void (*probing_done) (HalDevice *, guint32, gint, char **, gpointer, gpointer); 243 const gchar *prober; 244 int prober_timeout; 245 246 if (hal_device_property_get_bool (d, "info.ignore")) { 247 HAL_INFO (("Preprobing merged info.ignore==TRUE")); 248 249 /* Leave device with info.ignore==TRUE so we won't pick up children */ 250 hal_device_property_remove (d, "info.category"); 251 hal_device_property_remove (d, "info.capabilities"); 252 253 hal_device_store_remove (hald_get_tdl (), d); 254 hal_device_store_add (hald_get_gdl (), d); 255 256 hotplug_event_end (end_token); 257 return; 258 } 259 260 if (handler != NULL && handler->get_prober != NULL) { 261 prober = handler->get_prober (d, &prober_timeout); 262 } else { 263 prober = NULL; 264 } 265 266 if (handler->probing_done != NULL) { 267 probing_done = handler->probing_done; 268 } else { 269 probing_done = devinfo_callouts_probing_done; 270 } 271 272 if (prober != NULL) { 273 /* probe the device */ 274 HAL_INFO(("Probing udi=%s", hal_device_get_udi (d))); 275 hald_runner_run (d, 276 prober, NULL, 277 prober_timeout, 278 probing_done, 279 (gpointer) end_token, (gpointer) handler); 280 } else { 281 probing_done (d, 0, 0, NULL, userdata1, userdata2); 282 } 283 } 284 285 /* This is the beginning of hotplug even handling */ 286 void 287 hotplug_event_begin_add_devinfo (HalDevice *d, HalDevice *parent, DevinfoDevHandler *handler, void *end_token) 288 { 289 HAL_INFO(("Preprobing udi=%s", hal_device_get_udi (d))); 290 291 if (parent != NULL && hal_device_property_get_bool (parent, "info.ignore")) { 292 HAL_INFO (("Ignoring device since parent has info.ignore==TRUE")); 293 294 hotplug_event_end (end_token); 295 return; 296 } 297 298 /* add to TDL so preprobing callouts and prober can access it */ 299 hal_device_store_add (hald_get_tdl (), d); 300 301 /* Process preprobe fdi files */ 302 di_search_and_merge (d, DEVICE_INFO_TYPE_PREPROBE); 303 304 /* Run preprobe callouts */ 305 hal_util_callout_device_preprobe (d, devinfo_callouts_preprobing_done, end_token, handler); 306 } 307 308 void 309 devinfo_remove (gchar *devfs_path) 310 { 311 devinfo_remove_enqueue ((gchar *)devfs_path, NULL); 312 } 313 314 /* generate hotplug event for each device in this branch */ 315 void 316 devinfo_remove_branch (gchar *devfs_path, HalDevice *d) 317 { 318 GSList *i; 319 GSList *children; 320 HalDevice *child; 321 char *child_devfs_path; 322 323 if (d == NULL) { 324 d = hal_device_store_match_key_value_string (hald_get_gdl (), 325 "solaris.devfs_path", devfs_path); 326 if (d == NULL) 327 return; 328 } 329 330 HAL_INFO (("remove_branch: %s %s\n", devfs_path, hal_device_get_udi (d))); 331 332 /* first remove children */ 333 children = hal_device_store_match_multiple_key_value_string (hald_get_gdl(), 334 "info.parent", hal_device_get_udi (d)); 335 for (i = children; i != NULL; i = g_slist_next (i)) { 336 child = HAL_DEVICE (i->data); 337 HAL_INFO (("remove_branch: child %s\n", hal_device_get_udi (child))); 338 devinfo_remove_branch ((gchar *)hal_device_property_get_string (child, "solaris.devfs_path"), child); 339 } 340 g_slist_free (children); 341 HAL_INFO (("remove_branch: done with children")); 342 343 /* then remove self */ 344 HAL_INFO (("remove_branch: queueing %s", devfs_path)); 345 devinfo_remove_enqueue (devfs_path, NULL); 346 } 347 348 void 349 devinfo_callouts_remove_done (HalDevice *d, gpointer userdata1, gpointer userdata2) 350 { 351 void *end_token = (void *) userdata1; 352 353 HAL_INFO (("Remove callouts completed udi=%s", hal_device_get_udi (d))); 354 355 if (!hal_device_store_remove (hald_get_gdl (), d)) { 356 HAL_WARNING (("Error removing device")); 357 } 358 g_object_unref (d); 359 360 hotplug_event_end (end_token); 361 } 362 363 void 364 hotplug_event_begin_remove_devinfo (HalDevice *d, gchar *devfs_path, void *end_token) 365 { 366 if (hal_device_has_capability (d, "volume")) { 367 devinfo_volume_hotplug_begin_remove (d, devfs_path, end_token); 368 } else { 369 hal_util_callout_device_remove (d, devinfo_callouts_remove_done, end_token, NULL); 370 } 371 } 372 373 gboolean 374 devinfo_device_rescan (HalDevice *d) 375 { 376 if (hal_device_has_capability (d, "block")) { 377 return (devinfo_storage_device_rescan (d)); 378 } else { 379 return (FALSE); 380 } 381 } 382 383 static int 384 walk_devlinks(di_devlink_t devlink, void *arg) 385 { 386 char **path= (char **)arg; 387 388 *path = strdup(di_devlink_path(devlink)); 389 390 return (DI_WALK_TERMINATE); 391 } 392 393 char * 394 get_devlink(di_devlink_handle_t devlink_hdl, char *re, char *path) 395 { 396 char *devlink_path = NULL; 397 398 (void) di_devlink_walk(devlink_hdl, re, path, 399 DI_PRIMARY_LINK, &devlink_path, walk_devlinks); 400 401 return (devlink_path); 402 } 403 404