void
devinfo_callouts_preprobing_done (HalDevice *d, gpointer userdata1, gpointer userdata2)
{
void *end_token = (void *) userdata1;
DevinfoDevHandler *handler = (DevinfoDevHandler *) userdata2;
void (*probing_done) (HalDevice *, guint32, gint, char **, gpointer, gpointer);
const gchar *prober;
int prober_timeout;
if (hal_device_property_get_bool (d, "info.ignore")) {
HAL_INFO (("Preprobing merged info.ignore==TRUE"));
/* Leave device with info.ignore==TRUE so we won't pick up children */
hal_device_property_remove (d, "info.category");
hal_device_property_remove (d, "info.capabilities");
hal_device_store_remove (hald_get_tdl (), d);
hal_device_store_add (hald_get_gdl (), d);
hotplug_event_end (end_token);
return;
}
if (handler != NULL && handler->get_prober != NULL) {
prober = handler->get_prober (d, &prober_timeout);
} else {
prober = NULL;
}
if (handler->probing_done != NULL) {
probing_done = handler->probing_done;
} else {
probing_done = devinfo_callouts_probing_done;
}
if (prober != NULL) {
/* probe the device */
HAL_INFO(("Probing udi=%s", hal_device_get_udi (d)));
hald_runner_run (d,
prober, NULL,
prober_timeout,
probing_done,
(gpointer) end_token, (gpointer) handler);
} else {
probing_done (d, 0, 0, NULL, userdata1, userdata2);
}
}
static void
hotplug_event_begin_devfs (HotplugEvent *hotplug_event)
{
HalDevice *d;
HAL_INFO (("hotplug_event_begin_devfs: %s", hotplug_event->un.devfs.devfs_path));
d = hal_device_store_match_key_value_string (hald_get_gdl (),
"solaris.devfs_path",
hotplug_event->un.devfs.devfs_path);
if (hotplug_event->action == HOTPLUG_ACTION_ADD) {
hotplug_event_begin_devfs_add (hotplug_event, d);
} else if (hotplug_event->action == HOTPLUG_ACTION_REMOVE) {
hotplug_event_begin_devfs_remove (hotplug_event, d);
} else {
hotplug_event_end ((void *) hotplug_event);
}
}
void
devinfo_set_default_properties (HalDevice *d, HalDevice *parent, di_node_t node, char *devfs_path)
{
char *driver_name, *s;
const char *s1;
char udi[HAL_PATH_MAX];
if (parent != NULL) {
hal_device_property_set_string (d, "info.parent", hal_device_get_udi (parent));
} else {
hal_device_property_set_string (d, "info.parent", "/org/freedesktop/Hal/devices/local");
}
hal_util_compute_udi (hald_get_gdl (), udi, sizeof (udi),
"/org/freedesktop/Hal/devices%s_%d",
devfs_path,
di_instance (node));
hal_device_set_udi (d, udi);
hal_device_property_set_string (d, "info.udi", udi);
if (di_prop_lookup_strings (DDI_DEV_T_ANY, node, "model", &s) > 0) {
hal_device_property_set_string (d, "info.product", s);
} else {
hal_device_property_set_string (d, "info.product", di_node_name (node));
}
hal_device_property_set_string (d, "solaris.devfs_path", devfs_path);
if ((driver_name = di_driver_name (node)) != NULL) {
hal_device_property_set_string (d, "info.solaris.driver",
driver_name);
}
/* inherit parent's claim attributes */
if (hal_device_property_get_bool (parent, "info.claimed")) {
s1 = hal_device_property_get_string (parent, "info.claimed.service");
if (s1 != NULL) {
hal_device_property_set_bool (d, "info.claimed", TRUE);
hal_device_property_set_string (d, "info.claimed.service", s1);
}
}
}
static void
hf_volume_update_mounts (void)
{
GSList *l;
struct statfs *mounts;
int n_mounts;
hf_volume_get_mounts(&mounts, &n_mounts);
HF_LIST_FOREACH(l, hald_get_gdl()->devices)
{
HalDevice *device = l->data;
if (hal_device_property_get_bool(device, "block.is_volume"))
{
device_property_atomic_update_begin();
hf_volume_device_update_mount_properties(device, mounts, n_mounts);
device_property_atomic_update_end();
}
}
static gboolean
hf_net_update_timeout_cb (gpointer data)
{
GSList *l;
if (hf_is_waiting)
return TRUE;
HF_LIST_FOREACH(l, hald_get_gdl()->devices)
{
HalDevice *device = l->data;
const char *interface;
interface = hal_device_property_get_string(device, "net.interface");
if (interface)
{
device_property_atomic_update_begin();
hf_net_device_set_link_up(device, hf_net_get_link_up(interface));
device_property_atomic_update_end();
}
}
static void
drvctl_dev_add(gchar *name)
{
HalDevice *parent, *d;
gchar pdevnode[512];
if (drvctl_find_parent (name, pdevnode) == FALSE) {
HAL_INFO (("dev_add: name=%s orphan", name));
parent = NULL;
} else {
parent = hal_device_store_match_key_value_string (
hald_get_gdl(), "netbsd.device", pdevnode);
if (parent == NULL)
HAL_INFO (("dev_add: name=%s but netbsd.device=%s not found",name, pdevnode));
}
d = devinfo_add_node (parent, name);
if (d == NULL)
HAL_WARNING (("dev_add: couldn't add %s node (parent=%p)", name, parent));
hotplug_event_process_queue ();
}
HalDevice *
devinfo_mass_add(HalDevice *parent, const char *devnode, char *devfs_path, char *device_type)
{
HalDevice *d = NULL, *gparent = NULL;
prop_dictionary_t dict;
struct disklabel label;
struct stat st;
const char *driver;
char *rdevpath, *devpath;
char *childnode;
char *parent_devnode, *gparent_devnode = NULL;
char *gparent_udi;
int16_t unit;
int i, fd;
struct scsipi_inquiry_data inqbuf;
struct scsipi_inquiry cmd;
bool scsiinq_status;
char *storage_model = NULL, *storage_vendor = NULL;
if (drvctl_find_device (devnode, &dict) == FALSE || dict == NULL)
return NULL;
if (prop_dictionary_get_int16 (dict, "device-unit", &unit) == false ||
prop_dictionary_get_cstring_nocopy (dict, "device-driver", &driver) == false) {
prop_object_release (dict);
return NULL;
}
if (strcmp (driver, "wd") != 0 && strcmp (driver, "sd") != 0 &&
strcmp (driver, "ld") != 0) {
prop_object_release (dict);
return NULL;
}
sleep (1);
devpath = g_strdup_printf ("/dev/%s%c", devnode, RAW_PART + 'a');
rdevpath = g_strdup_printf ("/dev/r%s%c", devnode, RAW_PART + 'a');
HAL_INFO ((" going to open %s", rdevpath));
fd = open (rdevpath, O_RDONLY);
if (fd < 0) {
HAL_WARNING (("couldn't open %s: %s", rdevpath, strerror (errno)));
g_free (rdevpath);
g_free (devpath);
return NULL;
}
HAL_INFO ((" going to DIOCGDINFO %s", rdevpath));
if (ioctl (fd, DIOCGDINFO, &label) == -1) {
HAL_WARNING (("DIOCGDINFO failed on %s: %s", rdevpath, strerror (errno)));
g_free (rdevpath);
g_free (devpath);
close (fd);
return NULL;
}
if (strcmp (driver, "sd") == 0) {
memset(&cmd, 0, sizeof (cmd));
memset(&inqbuf, 0, sizeof (inqbuf));
cmd.opcode = INQUIRY;
cmd.length = sizeof (inqbuf);
scsiinq_status = scsi_command (fd, &cmd, sizeof (cmd), &inqbuf, sizeof (inqbuf), 10000, SCCMD_READ);
} else
scsiinq_status = false;
close (fd);
d = hal_device_new ();
devinfo_set_default_properties (d, parent, devnode, devfs_path);
hal_device_add_capability (d, "block");
hal_device_property_set_string (d, "info.subsystem", "block");
hal_device_property_set_string (d, "block.device", devpath);
if (stat (devpath, &st) == 0) {
hal_device_property_set_int (d, "block.major", major (st.st_rdev));
hal_device_property_set_int (d, "block.minor", minor (st.st_rdev));
}
hal_device_property_set_bool (d, "block.is_volume", FALSE);
hal_device_property_set_bool (d, "block.no_partitions", FALSE);
hal_device_property_set_bool (d, "block.have_scanned", TRUE);
hal_device_add_capability (d, "storage");
hal_device_property_set_string (d, "info.category", "storage");
parent_devnode = hal_device_property_get_string (parent, "netbsd.device");
gparent_udi = hal_device_property_get_string (parent, "info.parent");
if (gparent_udi) {
gparent = hal_device_store_find (hald_get_gdl (), gparent_udi);
if (gparent)
gparent_devnode = hal_device_property_get_string (gparent, "netbsd.device");
}
if (gparent_devnode && strstr (gparent_devnode, "umass") == gparent_devnode)
hal_device_property_set_string (d, "storage.bus", "usb");
else if (parent_devnode && strstr (parent_devnode, "atabus") == parent_devnode)
hal_device_property_set_string (d, "storage.bus", "ide");
else
hal_device_property_set_string (d, "storage.bus", "scsi");
hal_device_property_set_string (d, "storage.device_type", "disk");
hal_device_property_set_bool (d, "storage.removable", label.d_flags & D_REMOVABLE ? TRUE : FALSE);
if (label.d_flags & D_REMOVABLE) {
hal_device_property_set_bool (d, "storage.removable.media_available", TRUE);
hal_device_property_set_uint64 (d, "storage.removable.media_size",
(uint64_t)label.d_secsize * (uint64_t)label.d_secperunit);
hal_device_property_set_uint64 (d, "storage.size", 0);
hal_device_property_set_bool (d, "storage.hotpluggable", TRUE);
hal_device_property_set_bool (d, "storage.automount_enabled_hint", TRUE);
} else {
hal_device_property_set_bool (d, "storage.removable.media_available", FALSE);
hal_device_property_set_uint64 (d, "storage.removable.media_size", 0);
hal_device_property_set_uint64 (d, "storage.size",
(uint64_t)label.d_secsize * (uint64_t)label.d_secperunit);
hal_device_property_set_bool (d, "storage.hotpluggable", FALSE);
hal_device_property_set_bool (d, "storage.automount_enabled_hint", FALSE);
}
hal_device_property_set_bool (d, "storage.no_partitions_hint", FALSE);
hal_device_property_set_bool (d, "storage.requires_eject", FALSE);
hal_device_property_set_bool (d, "storage.removable.support_async_notification", FALSE);
hal_device_property_set_string (d, "storage.partitioning_scheme", "mbr");
hal_device_property_set_string (d, "storage.originating_device",
hal_device_property_get_string (d, "info.udi"));
if (scsiinq_status == true) {
storage_model = rtrim_copy(inqbuf.product, sizeof (inqbuf.product));
storage_vendor = rtrim_copy(inqbuf.vendor, sizeof (inqbuf.vendor));
}
if (storage_model) {
hal_device_property_set_string (d, "storage.model", storage_model);
free (storage_model);
} else
hal_device_property_set_string (d, "storage.model", label.d_packname);
if (storage_vendor) {
hal_device_property_set_string (d, "storage.vendor", storage_vendor);
free (storage_vendor);
} else
hal_device_property_set_string (d, "storage.vendor", label.d_typename);
devinfo_add_enqueue (d, devfs_path, &devinfo_mass_handler);
for (i = 0; i < MAXPARTITIONS; i++) {
const char *fstype;
fstype = devinfo_mass_get_fstype(label.d_partitions[i].p_fstype);
if (fstype == NULL)
continue;
childnode = g_strdup_printf ("%s%c", devnode, 'a' + i);
HAL_INFO ((" adding %s on %s", childnode, rdevpath));
devinfo_mass_disklabel_add (d, childnode, childnode, childnode);
g_free (childnode);
}
HAL_INFO ((" returning"));
g_free (rdevpath);
g_free (devpath);
done:
prop_object_release (dict);
return d;
}
