#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include <stdio.h>

#include <string.h>

#include <strings.h>

#include <ctype.h>

#include <libdevinfo.h>

#include <sys/types.h>

#include <sys/mkdev.h>

#include <sys/stat.h>

#include <sys/mntent.h>

#include <sys/mnttab.h>

#include "../osspec.h"

#include "../logger.h"

#include "../hald.h"

#include "../hald_dbus.h"

#include "../device_info.h"

#include "../util.h"

#include "../hald_runner.h"

#include "hotplug.h"

#include "devinfo.h"

#include "devinfo_misc.h"

#include "devinfo_storage.h"

#include "osspec_solaris.h"

#ifdef sparc

#define WHOLE_DISK "s2"

#else

#define WHOLE_DISK "p0"

#endif

#define DEVINFO_PROBE_STORAGE_TIMEOUT 60000

#define DEVINFO_PROBE_VOLUME_TIMEOUT 60000

typedef struct devinfo_storage_minor {

char *devpath;

char *devlink;

char *slice;

dev_t dev;

int dosnum; /* dos disk number or -1 */

} devinfo_storage_minor_t;

HalDevice *devinfo_ide_add(HalDevice *parent, di_node_t node, char *devfs_path, char *device_type);

static HalDevice *devinfo_ide_host_add(HalDevice *parent, di_node_t node, char *devfs_path);

static HalDevice *devinfo_ide_device_add(HalDevice *parent, di_node_t node, char *devfs_path);

static HalDevice *devinfo_ide_storage_add(HalDevice *parent, di_node_t node, char *devfs_path);

HalDevice *devinfo_scsi_add(HalDevice *parent, di_node_t node, char *devfs_path, char *device_type);

static HalDevice *devinfo_scsi_storage_add(HalDevice *parent, di_node_t node, char *devfs_path);

HalDevice *devinfo_blkdev_add(HalDevice *parent, di_node_t node, char *devfs_path, char *device_type);

static HalDevice *devinfo_blkdev_storage_add(HalDevice *parent, di_node_t node, char *devfs_path);

HalDevice *devinfo_floppy_add(HalDevice *parent, di_node_t node, char *devfs_path, char *device_type);

static void devinfo_floppy_add_volume(HalDevice *parent, di_node_t node);

static HalDevice *devinfo_lofi_add(HalDevice *parent, di_node_t node, char *devfs_path, char *device_type);

static void devinfo_lofi_add_minor(HalDevice *parent, di_node_t node, char *minor_path, char *devlink, dev_t dev);

static void devinfo_storage_minors(HalDevice *parent, di_node_t node, gchar *devfs_path, gboolean);

static struct devinfo_storage_minor *devinfo_storage_new_minor(char *maindev_path, char *slice,

char *devlink, dev_t dev, int dosnum);

static void devinfo_storage_free_minor(struct devinfo_storage_minor *m);

HalDevice *devinfo_volume_add(HalDevice *parent, di_node_t node, devinfo_storage_minor_t *m);

static void devinfo_volume_preprobing_done(HalDevice *d, gpointer userdata1, gpointer userdata2);

static void devinfo_volume_hotplug_begin_add (HalDevice *d, HalDevice *parent, DevinfoDevHandler *handler, void *end_token);

static void devinfo_storage_hotplug_begin_add (HalDevice *d, HalDevice *parent, DevinfoDevHandler *handler, void *end_token);

static void devinfo_storage_probing_done (HalDevice *d, guint32 exit_type, gint return_code, char **error, gpointer userdata1, gpointer userdata2);

const gchar *devinfo_volume_get_prober (HalDevice *d, int *timeout);

const gchar *devinfo_storage_get_prober (HalDevice *d, int *timeout);

static char *devinfo_scsi_dtype2str(int dtype);

static char *devinfo_volume_get_slice_name (char *devlink);

static gboolean dos_to_dev(char *path, char **devpath, int *partnum);

static gboolean is_dos_path(char *path, int *partnum);

static void devinfo_storage_set_nicknames (HalDevice *d);

DevinfoDevHandler devinfo_ide_handler = {

devinfo_ide_add,

NULL,

NULL,

NULL,

NULL,

NULL

};

DevinfoDevHandler devinfo_scsi_handler = {

devinfo_scsi_add,

NULL,

NULL,

NULL,

NULL,

NULL

};

DevinfoDevHandler devinfo_blkdev_handler = {

devinfo_blkdev_add,

NULL,

NULL,

NULL,

NULL,

NULL

};

DevinfoDevHandler devinfo_floppy_handler = {

devinfo_floppy_add,

NULL,

NULL,

NULL,

NULL,

NULL

};

DevinfoDevHandler devinfo_lofi_handler = {

devinfo_lofi_add,

NULL,

NULL,

NULL,

NULL,

NULL

};

DevinfoDevHandler devinfo_storage_handler = {

NULL,

NULL,

devinfo_storage_hotplug_begin_add,

NULL,

devinfo_storage_probing_done,

devinfo_storage_get_prober

};

DevinfoDevHandler devinfo_volume_handler = {

NULL,

NULL,

devinfo_volume_hotplug_begin_add,

NULL,

NULL,

devinfo_volume_get_prober

};

HalDevice *

devinfo_ide_add(HalDevice *parent, di_node_t node, char *devfs_path, char *device_type)

{

char *s;

if ((device_type != NULL) && (strcmp(device_type, "ide") == 0)) {

return (devinfo_ide_host_add(parent, node, devfs_path));

}

if ((di_prop_lookup_strings (DDI_DEV_T_ANY, node, "class", &s) > 0) &&

(strcmp (s, "dada") == 0)) {

return (devinfo_ide_device_add(parent, node, devfs_path));

}

return (NULL);

}

static HalDevice *

devinfo_ide_host_add(HalDevice *parent, di_node_t node, char *devfs_path)

{

HalDevice *d;

d = hal_device_new ();

devinfo_set_default_properties (d, parent, node, devfs_path);

hal_device_property_set_string (d, "info.product", "IDE host controller");

hal_device_property_set_string (d, "info.subsystem", "ide_host");

hal_device_property_set_int (d, "ide_host.number", 0); /* XXX */

devinfo_add_enqueue (d, devfs_path, &devinfo_ide_handler);

return (d);

}

static HalDevice *

devinfo_ide_device_add(HalDevice *parent, di_node_t node, char *devfs_path)

{

HalDevice *d;

d = hal_device_new();

devinfo_set_default_properties (d, parent, node, devfs_path);

hal_device_property_set_string (parent, "info.product", "IDE device");

hal_device_property_set_string (parent, "info.subsystem", "ide");

hal_device_property_set_int (parent, "ide.host", 0); /* XXX */

hal_device_property_set_int (parent, "ide.channel", 0);

devinfo_add_enqueue (d, devfs_path, &devinfo_ide_handler);

return (devinfo_ide_storage_add (d, node, devfs_path));

}

static HalDevice *

devinfo_ide_storage_add(HalDevice *parent, di_node_t node, char *devfs_path)

{

HalDevice *d;

char *s;

int *i;

char *driver_name;

char udi[HAL_PATH_MAX];

if ((driver_name = di_driver_name (node)) == NULL) {

return (NULL);

}

d = hal_device_new ();

devinfo_set_default_properties (d, parent, node, devfs_path);

hal_device_property_set_string (d, "info.category", "storage");

hal_util_compute_udi (hald_get_gdl (), udi, sizeof (udi),

"%s/%s%d", hal_device_get_udi (parent), driver_name, di_instance (node));

hal_device_set_udi (d, udi);

hal_device_property_set_string (d, "info.udi", udi);

PROP_STR(d, node, s, "devid", "info.product");

hal_device_add_capability (d, "storage");

hal_device_property_set_string (d, "storage.bus", "ide");

hal_device_property_set_int (d, "storage.lun", 0);

hal_device_property_set_string (d, "storage.drive_type", "disk");

PROP_BOOL(d, node, i, "hotpluggable", "storage.hotpluggable");

PROP_BOOL(d, node, i, "removable-media", "storage.removable");

hal_device_property_set_bool (d, "storage.media_check_enabled", FALSE);

/* XXX */

hal_device_property_set_bool (d, "storage.requires_eject", FALSE);

hal_device_add_capability (d, "block");

devinfo_storage_minors (d, node, (char *)devfs_path, FALSE);

return (d);

}

HalDevice *

devinfo_scsi_add(HalDevice *parent, di_node_t node, char *devfs_path, char *device_type)

{

int *i;

char *driver_name;

HalDevice *d;

char udi[HAL_PATH_MAX];

driver_name = di_driver_name (node);

if ((driver_name == NULL) || (strcmp (driver_name, "sd") != 0)) {

return (NULL);

}

d = hal_device_new ();

devinfo_set_default_properties (d, parent, node, devfs_path);

hal_device_property_set_string (d, "info.subsystem", "scsi");

hal_util_compute_udi (hald_get_gdl (), udi, sizeof (udi),

"%s/%s%d", hal_device_get_udi (parent), di_node_name(node), di_instance (node));

hal_device_set_udi (d, udi);

hal_device_property_set_string (d, "info.udi", udi);

hal_device_property_set_int (d, "scsi.host",

hal_device_property_get_int (parent, "scsi_host.host"));

hal_device_property_set_int (d, "scsi.bus", 0);

PROP_INT(d, node, i, "target", "scsi.target");

PROP_INT(d, node, i, "lun", "scsi.lun");

hal_device_property_set_string (d, "info.product", "SCSI Device");

devinfo_add_enqueue (d, devfs_path, &devinfo_scsi_handler);

return (devinfo_scsi_storage_add (d, node, devfs_path));

}

static HalDevice *

devinfo_scsi_storage_add(HalDevice *parent, di_node_t node, char *devfs_path)

{

HalDevice *d;

int *i;

char *s;

char udi[HAL_PATH_MAX];

d = hal_device_new ();

devinfo_set_default_properties (d, parent, node, devfs_path);

hal_device_property_set_string (d, "info.category", "storage");

hal_util_compute_udi (hald_get_gdl (), udi, sizeof (udi),

"%s/sd%d", hal_device_get_udi (parent), di_instance (node));

hal_device_set_udi (d, udi);

hal_device_property_set_string (d, "info.udi", udi);

PROP_STR(d, node, s, "inquiry-product-id", "info.product");

hal_device_add_capability (d, "storage");

hal_device_property_set_int (d, "storage.lun",

hal_device_property_get_int (parent, "scsi.lun"));

PROP_BOOL(d, node, i, "hotpluggable", "storage.hotpluggable");

PROP_BOOL(d, node, i, "removable-media", "storage.removable");

hal_device_property_set_bool (d, "storage.requires_eject", FALSE);

/*

hal_device_property_set_bool (d, "storage.media_check_enabled",

((di_prop_lookup_ints(DDI_DEV_T_ANY, node, "removable-media", &i) >= 0) ||

(di_prop_lookup_ints(DDI_DEV_T_ANY, node, "hotpluggable", &i) >= 0)));

if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, "inquiry-device-type",

&i) > 0) {

s = devinfo_scsi_dtype2str (*i);

hal_device_property_set_string (d, "storage.drive_type", s);

if (strcmp (s, "cdrom") == 0) {

hal_device_add_capability (d, "storage.cdrom");

hal_device_property_set_bool (d, "storage.no_partitions_hint", TRUE);

hal_device_property_set_bool (d, "storage.requires_eject", TRUE);

}

}

hal_device_add_capability (d, "block");

devinfo_storage_minors (d, node, devfs_path, FALSE);

return (d);

}

static char *

devinfo_scsi_dtype2str(int dtype)

{

char *dtype2str[] = {

"disk" , /* DTYPE_DIRECT 0x00 */

"tape" , /* DTYPE_SEQUENTIAL 0x01 */

"printer", /* DTYPE_PRINTER 0x02 */

"processor", /* DTYPE_PROCESSOR 0x03 */

"worm" , /* DTYPE_WORM 0x04 */

"cdrom" , /* DTYPE_RODIRECT 0x05 */

"scanner", /* DTYPE_SCANNER 0x06 */

"cdrom" , /* DTYPE_OPTICAL 0x07 */

"changer", /* DTYPE_CHANGER 0x08 */

"comm" , /* DTYPE_COMM 0x09 */

"scsi" , /* DTYPE_??? 0x0A */

"scsi" , /* DTYPE_??? 0x0B */

"array_ctrl", /* DTYPE_ARRAY_CTRL 0x0C */

"esi" , /* DTYPE_ESI 0x0D */

"disk" /* DTYPE_RBC 0x0E */

};

if (dtype < NELEM(dtype2str)) {

return (dtype2str[dtype]);

} else {

return ("scsi");

}

}

HalDevice *

devinfo_blkdev_add(HalDevice *parent, di_node_t node, char *devfs_path, char *device_type)

{

int *i;

char *driver_name;

HalDevice *d;

char udi[HAL_PATH_MAX];

driver_name = di_driver_name (node);

if ((driver_name == NULL) || (strcmp (driver_name, "blkdev") != 0)) {

return (NULL);

}

d = hal_device_new ();

devinfo_set_default_properties (d, parent, node, devfs_path);

hal_device_property_set_string (d, "info.subsystem", "pseudo");

hal_util_compute_udi (hald_get_gdl (), udi, sizeof (udi),

"%s/%s%d", hal_device_get_udi (parent), di_node_name(node), di_instance (node));

hal_device_set_udi (d, udi);

hal_device_property_set_string (d, "info.udi", udi);

hal_device_property_set_string (d, "info.product", "Block Device");

devinfo_add_enqueue (d, devfs_path, &devinfo_blkdev_handler);

return (devinfo_blkdev_storage_add (d, node, devfs_path));

}

static HalDevice *

devinfo_blkdev_storage_add(HalDevice *parent, di_node_t node, char *devfs_path)

{

HalDevice *d;

char *driver_name;

int *i;

char *s;

char udi[HAL_PATH_MAX];

d = hal_device_new ();

devinfo_set_default_properties (d, parent, node, devfs_path);

hal_device_property_set_string (d, "info.category", "storage");

hal_util_compute_udi (hald_get_gdl (), udi, sizeof (udi),

"%s/blkdev%d", hal_device_get_udi (parent), di_instance (node));

hal_device_set_udi (d, udi);

hal_device_property_set_string (d, "info.udi", udi);

hal_device_add_capability (d, "storage");

hal_device_property_set_int (d, "storage.lun", 0);

PROP_BOOL(d, node, i, "hotpluggable", "storage.hotpluggable");

PROP_BOOL(d, node, i, "removable-media", "storage.removable");

hal_device_property_set_bool (d, "storage.requires_eject", FALSE);

hal_device_property_set_bool (d, "storage.media_check_enabled", TRUE);

hal_device_property_set_string (d, "storage.drive_type", "disk");

hal_device_add_capability (d, "block");

devinfo_storage_minors (d, node, devfs_path, FALSE);

return (d);

}

HalDevice *

devinfo_floppy_add(HalDevice *parent, di_node_t node, char *devfs_path, char *device_type)

{

char *driver_name;

char *raw;

char udi[HAL_PATH_MAX];

di_devlink_handle_t devlink_hdl;

int major;

di_minor_t minor;

dev_t dev;

HalDevice *d = NULL;

char *minor_path = NULL;

char *devlink = NULL;

driver_name = di_driver_name (node);

if ((driver_name == NULL) || (strcmp (driver_name, "fd") != 0)) {

return (NULL);

}

/*

major = di_driver_major(node);

if ((devlink_hdl = di_devlink_init(NULL, 0)) == NULL) {

return (NULL);

}

minor = DI_MINOR_NIL;

while ((minor = di_minor_next(node, minor)) != DI_MINOR_NIL) {

dev = di_minor_devt(minor);

if ((major != major(dev)) ||

(di_minor_type(minor) != DDM_MINOR) ||

(di_minor_spectype(minor) != S_IFBLK) ||

((minor_path = di_devfs_minor_path(minor)) == NULL)) {

continue;

}

if ((devlink = get_devlink(devlink_hdl, "diskette.+" , minor_path)) != NULL) {

break;

}

di_devfs_path_free (minor_path);

minor_path = NULL;

free(devlink);

devlink = NULL;

}

di_devlink_fini (&devlink_hdl);

if ((devlink == NULL) || (minor_path == NULL)) {

HAL_INFO (("floppy devlink not found %s", devfs_path));

goto out;

}

d = hal_device_new ();

devinfo_set_default_properties (d, parent, node, devfs_path);

hal_device_property_set_string (d, "info.category", "storage");

hal_device_add_capability (d, "storage");

hal_device_property_set_string (d, "storage.bus", "platform");

hal_device_property_set_bool (d, "storage.hotpluggable", FALSE);

hal_device_property_set_bool (d, "storage.removable", TRUE);

hal_device_property_set_bool (d, "storage.requires_eject", TRUE);

hal_device_property_set_bool (d, "storage.media_check_enabled", FALSE);

hal_device_property_set_string (d, "storage.drive_type", "floppy");

hal_device_add_capability (d, "block");

hal_device_property_set_bool (d, "block.is_volume", FALSE);

hal_device_property_set_int (d, "block.major", major(dev));

hal_device_property_set_int (d, "block.minor", minor(dev));

hal_device_property_set_string (d, "block.device", devlink);

raw = dsk_to_rdsk (devlink);

hal_device_property_set_string (d, "block.solaris.raw_device", raw);

free (raw);

devinfo_add_enqueue (d, devfs_path, &devinfo_storage_handler);

/* trigger initial probe-volume */

devinfo_floppy_add_volume(d, node);

out:

di_devfs_path_free (minor_path);

free(devlink);

return (d);

}

static void

devinfo_floppy_add_volume(HalDevice *parent, di_node_t node)

{

char *devlink;

char *devfs_path;

int minor, major;

dev_t dev;

struct devinfo_storage_minor *m;

devfs_path = (char *)hal_device_property_get_string (parent, "solaris.devfs_path");

devlink = (char *)hal_device_property_get_string (parent, "block.device");

major = hal_device_property_get_int (parent, "block.major");

minor = hal_device_property_get_int (parent, "block.minor");

dev = makedev (major, minor);

m = devinfo_storage_new_minor (devfs_path, WHOLE_DISK, devlink, dev, -1);

devinfo_volume_add (parent, node, m);

devinfo_storage_free_minor (m);

}

static void

devinfo_floppy_rescan_probing_done (HalDevice *d, guint32 exit_type, gint return_code,

char **error, gpointer userdata1, gpointer userdata2)

{

void *end_token = (void *) userdata1;

const char *devfs_path;

di_node_t node;

HalDevice *v;

if (!hal_device_property_get_bool (d, "storage.removable.media_available")) {

HAL_INFO (("no floppy media", hal_device_get_udi (d)));

/* remove child (can only be single volume) */

if (((v = hal_device_store_match_key_value_string (hald_get_gdl(),

"info.parent", hal_device_get_udi (d))) != NULL) &&

((devfs_path = hal_device_property_get_string (v,

"solaris.devfs_path")) != NULL)) {

devinfo_remove_enqueue ((char *)devfs_path, NULL);

}

} else {

HAL_INFO (("floppy media found", hal_device_get_udi (d)));

if ((devfs_path = hal_device_property_get_string(d, "solaris.devfs_path")) == NULL) {

HAL_INFO (("no devfs_path", hal_device_get_udi (d)));

hotplug_event_process_queue ();

return;

}

if ((node = di_init (devfs_path, DINFOCPYALL)) == DI_NODE_NIL) {

HAL_INFO (("di_init %s failed %d", devfs_path, errno));

hotplug_event_process_queue ();

return;

}

devinfo_floppy_add_volume (d, node);

di_fini (node);

}

hotplug_event_process_queue ();

}

HalDevice *

devinfo_lofi_add(HalDevice *parent, di_node_t node, char *devfs_path, char *device_type)

{

return (devinfo_lofi_add_major(parent,node, devfs_path, device_type, FALSE, NULL));

}

HalDevice *

devinfo_lofi_add_major(HalDevice *parent, di_node_t node, char *devfs_path, char *device_type,

gboolean rescan, HalDevice *lofi_d)

{

char *driver_name;

HalDevice *d = NULL;

char udi[HAL_PATH_MAX];

di_devlink_handle_t devlink_hdl;

int major;

di_minor_t minor;

dev_t dev;

char *minor_path = NULL;

char *devlink = NULL;

driver_name = di_driver_name (node);

if ((driver_name == NULL) || (strcmp (driver_name, "lofi") != 0)) {

return (NULL);

}

if (!rescan) {

d = hal_device_new ();

devinfo_set_default_properties (d, parent, node, devfs_path);

hal_device_property_set_string (d, "info.subsystem", "pseudo");

hal_util_compute_udi (hald_get_gdl (), udi, sizeof (udi),

"%s/%s%d", hal_device_get_udi (parent), di_node_name(node), di_instance (node));

hal_device_set_udi (d, udi);

hal_device_property_set_string (d, "info.udi", udi);

devinfo_add_enqueue (d, devfs_path, &devinfo_lofi_handler);

} else {

d = lofi_d;

}

/*

major = di_driver_major(node);

if ((devlink_hdl = di_devlink_init(NULL, 0)) == NULL) {

return (d);

}

minor = DI_MINOR_NIL;

while ((minor = di_minor_next(node, minor)) != DI_MINOR_NIL) {

dev = di_minor_devt(minor);

if ((major != major(dev)) ||

(di_minor_type(minor) != DDM_MINOR) ||

(di_minor_spectype(minor) != S_IFBLK) ||

((minor_path = di_devfs_minor_path(minor)) == NULL)) {

continue;

}

if ((devlink = get_devlink(devlink_hdl, NULL, minor_path)) == NULL) {

di_devfs_path_free (minor_path);

continue;

}

if (!rescan ||

(hal_device_store_match_key_value_string (hald_get_gdl (),

"solaris.devfs_path", minor_path) == NULL)) {

devinfo_lofi_add_minor(d, node, minor_path, devlink, dev);

}

di_devfs_path_free (minor_path);

free(devlink);

}

di_devlink_fini (&devlink_hdl);

return (d);

}

static void

devinfo_lofi_add_minor(HalDevice *parent, di_node_t node, char *minor_path, char *devlink, dev_t dev)

{

HalDevice *d;

char *raw;

char *doslink;

char dospath[64];

struct devinfo_storage_minor *m;

int i;

/* add storage */

d = hal_device_new ();

devinfo_set_default_properties (d, parent, node, minor_path);

hal_device_property_set_string (d, "info.category", "storage");

hal_device_add_capability (d, "storage");

hal_device_property_set_string (d, "storage.bus", "lofi");

hal_device_property_set_bool (d, "storage.hotpluggable", TRUE);

hal_device_property_set_bool (d, "storage.removable", FALSE);

hal_device_property_set_bool (d, "storage.requires_eject", FALSE);

hal_device_property_set_string (d, "storage.drive_type", "disk");

hal_device_add_capability (d, "block");

hal_device_property_set_int (d, "block.major", major(dev));

hal_device_property_set_int (d, "block.minor", minor(dev));

hal_device_property_set_string (d, "block.device", devlink);

raw = dsk_to_rdsk (devlink);

hal_device_property_set_string (d, "block.solaris.raw_device", raw);

free (raw);

hal_device_property_set_bool (d, "block.is_volume", FALSE);

devinfo_add_enqueue (d, minor_path, &devinfo_storage_handler);

/* add volumes: one on main device and a few pcfs candidates */

m = devinfo_storage_new_minor(minor_path, WHOLE_DISK, devlink, dev, -1);

devinfo_volume_add (d, node, m);

devinfo_storage_free_minor (m);

doslink = (char *)calloc (1, strlen (devlink) + sizeof (":NNN") + 1);

if (doslink != NULL) {

for (i = 1; i < 16; i++) {

snprintf(dospath, sizeof (dospath), WHOLE_DISK":%d", i);

sprintf(doslink, "%s:%d", devlink, i);

m = devinfo_storage_new_minor(minor_path, dospath, doslink, dev, i);

devinfo_volume_add (d, node, m);

devinfo_storage_free_minor (m);

}

free (doslink);

}

}

devinfo_lofi_remove_minor(char *parent_devfs_path, char *name)

{

GSList *i;

GSList *devices;

HalDevice *d = NULL;

const char *devfs_path;

devices = hal_device_store_match_multiple_key_value_string (hald_get_gdl(),

"block.solaris.raw_device", name);

for (i = devices; i != NULL; i = g_slist_next (i)) {

if (hal_device_has_capability (HAL_DEVICE (i->data), "storage")) {

d = HAL_DEVICE (i->data);

break;

}

}

g_slist_free (devices);

if (d == NULL) {

HAL_INFO (("device not found %s", name));

return;

}

if ((devfs_path = hal_device_property_get_string (d,

"solaris.devfs_path")) == NULL) {

HAL_INFO (("devfs_path not found %s", hal_device_get_udi (d)));

return;

}

if (d != NULL) {

devinfo_remove_branch ((char *)devfs_path, d);

}

}

static void

devinfo_storage_free_minor(struct devinfo_storage_minor *m)

{

if (m != NULL) {

free (m->slice);

free (m->devlink);

free (m->devpath);

free (m);

}

}

static struct devinfo_storage_minor *

devinfo_storage_new_minor(char *maindev_path, char *slice, char *devlink, dev_t dev, int dosnum)

{

struct devinfo_storage_minor *m;

int pathlen;

char *devpath;

m = (struct devinfo_storage_minor *)calloc (sizeof (struct devinfo_storage_minor), 1);

if (m != NULL) {

/*

pathlen = strlen (maindev_path) + strlen (slice) + 2;

devpath = (char *)calloc (1, pathlen);

snprintf(devpath, pathlen, "%s/%s", maindev_path, slice);

m->devpath = devpath;

m->devlink = strdup (devlink);

m->slice = strdup (slice);

m->dev = dev;

m->dosnum = dosnum;

if ((m->devpath == NULL) || (m->devlink == NULL)) {

devinfo_storage_free_minor (m);

m = NULL;

}

}

return (m);

}

static void

devinfo_storage_minors(HalDevice *parent, di_node_t node, gchar *devfs_path, gboolean rescan)

{

di_devlink_handle_t devlink_hdl;

gboolean is_cdrom;

const char *whole_disk;

int major;

di_minor_t minor;

dev_t dev;

char *minor_path = NULL;

char *maindev_path = NULL;

char *devpath, *devlink;

int doslink_len;

char *doslink;

char dospath[64];

char *slice;

int pathlen;

int i;

char *raw;

boolean_t maindev_is_d0;

GQueue *mq;

HalDevice *volume;

struct devinfo_storage_minor *m;

struct devinfo_storage_minor *maindev = NULL;

/* for cdroms whole disk is always s2 */

is_cdrom = hal_device_has_capability (parent, "storage.cdrom");

whole_disk = is_cdrom ? "s2" : WHOLE_DISK;

major = di_driver_major(node);

/* the "whole disk" p0/s2/d0 node must come first in the hotplug queue

if ((mq = g_queue_new()) == NULL) {

goto err;

}

if ((devlink_hdl = di_devlink_init(NULL, 0)) == NULL) {

g_queue_free (mq);

goto err;

}

minor = DI_MINOR_NIL;

while ((minor = di_minor_next(node, minor)) != DI_MINOR_NIL) {

dev = di_minor_devt(minor);

if ((major != major(dev)) ||

(di_minor_type(minor) != DDM_MINOR) ||

(di_minor_spectype(minor) != S_IFBLK) ||

((minor_path = di_devfs_minor_path(minor)) == NULL)) {

continue;

}

if ((devlink = get_devlink(devlink_hdl, NULL, minor_path)) == NULL) {

di_devfs_path_free (minor_path);

continue;

}

slice = devinfo_volume_get_slice_name (devlink);

if (strlen (slice) < 2) {

free (devlink);

di_devfs_path_free (minor_path);

continue;

}

/* ignore p1..N - we'll use p0:N instead */

if ((strlen (slice) > 1) && (slice[0] == 'p') && isdigit(slice[1]) &&

((atol(&slice[1])) > 0)) {

free (devlink);

di_devfs_path_free (minor_path);

continue;

}

m = devinfo_storage_new_minor(minor_path, slice, devlink, dev, -1);

if (m == NULL) {

free (devlink);

di_devfs_path_free (minor_path);

continue;

}

/* main device is either s2/p0 or d0, the latter taking precedence */

if ((strcmp (slice, "d0") == 0) ||

(((strcmp (slice, whole_disk) == 0) && (maindev == NULL)))) {

if (maindev_path != NULL) {

di_devfs_path_free (maindev_path);

}

maindev_path = minor_path;

maindev = m;

g_queue_push_head (mq, maindev);

} else {

di_devfs_path_free (minor_path);

g_queue_push_tail (mq, m);

}

free (devlink);

}

di_devlink_fini (&devlink_hdl);

if (maindev == NULL) {

/* shouldn't typically happen */

while (!g_queue_is_empty (mq)) {

devinfo_storage_free_minor (g_queue_pop_head (mq));

}

goto err;

}

/* first enqueue main storage device */

if (!rescan) {

hal_device_property_set_int (parent, "block.major", major);

hal_device_property_set_int (parent, "block.minor", minor(maindev->dev));

hal_device_property_set_string (parent, "block.device", maindev->devlink);

raw = dsk_to_rdsk (maindev->devlink);

hal_device_property_set_string (parent, "block.solaris.raw_device", raw);

free (raw);

hal_device_property_set_bool (parent, "block.is_volume", FALSE);

hal_device_property_set_string (parent, "solaris.devfs_path", maindev_path);

devinfo_add_enqueue (parent, maindev_path, &devinfo_storage_handler);

}

/* add virtual dos volumes to enable pcfs probing */

if (!is_cdrom) {

doslink_len = strlen (maindev->devlink) + sizeof (":NNN") + 1;

if ((doslink = (char *)calloc (1, doslink_len)) != NULL) {

for (i = 1; i < 16; i++) {

snprintf(dospath, sizeof (dospath), "%s:%d", maindev->slice, i);

snprintf(doslink, doslink_len, "%s:%d", maindev->devlink, i);

m = devinfo_storage_new_minor(maindev_path, dospath, doslink, maindev->dev, i);

g_queue_push_tail (mq, m);

}

free (doslink);

}

}

maindev_is_d0 = (strcmp (maindev->slice, "d0") == 0);

/* enqueue all volumes */

while (!g_queue_is_empty (mq)) {

m = g_queue_pop_head (mq);

/* if main device is d0, we'll throw away s2/p0 */

if (maindev_is_d0 && (strcmp (m->slice, whole_disk) == 0)) {

devinfo_storage_free_minor (m);

continue;

}

/* don't do p0 on cdrom */

if (is_cdrom && (strcmp (m->slice, "p0") == 0)) {

devinfo_storage_free_minor (m);

continue;

}

if (rescan) {

/* in rescan mode, don't reprobe existing volumes */

/* XXX detect volume removal? */

volume = hal_device_store_match_key_value_string (hald_get_gdl (),

"solaris.devfs_path", m->devpath);

if ((volume == NULL) || !hal_device_has_capability(volume, "volume")) {

devinfo_volume_add (parent, node, m);

} else {

HAL_INFO(("rescan volume exists %s", m->devpath));

}

} else {

devinfo_volume_add (parent, node, m);

}

devinfo_storage_free_minor (m);

}

if (maindev_path != NULL) {

di_devfs_path_free (maindev_path);

}

return;

err:

if (maindev_path != NULL) {

di_devfs_path_free (maindev_path);

}

if (!rescan) {

devinfo_add_enqueue (parent, devfs_path, &devinfo_storage_handler);

}

}

HalDevice *

devinfo_volume_add(HalDevice *parent, di_node_t node, devinfo_storage_minor_t *m)

{

HalDevice *d;

char *raw;

char udi[HAL_PATH_MAX];

char *devfs_path = m->devpath;

char *devlink = m->devlink;

dev_t dev = m->dev;

int dosnum = m->dosnum;

char *slice = m->slice;

HAL_INFO (("volume_add: devfs_path=%s devlink=%s", devfs_path, devlink));

d = hal_device_new ();

devinfo_set_default_properties (d, parent, node, devfs_path);

hal_device_property_set_string (d, "info.category", "volume");

hal_util_compute_udi (hald_get_gdl (), udi, sizeof (udi),

"%s/%s", hal_device_get_udi (parent), slice);

hal_device_set_udi (d, udi);

hal_device_property_set_string (d, "info.udi", udi);

hal_device_property_set_string (d, "info.product", slice);

hal_device_add_capability (d, "volume");

hal_device_add_capability (d, "block");

hal_device_property_set_int (d, "block.major", major (dev));

hal_device_property_set_int (d, "block.minor", minor (dev));

hal_device_property_set_string (d, "block.device", devlink);

raw = dsk_to_rdsk (devlink);

hal_device_property_set_string (d, "block.solaris.raw_device", raw);

free (raw);

hal_device_property_set_string (d, "block.solaris.slice", slice);

hal_device_property_set_bool (d, "block.is_volume", TRUE); /* XXX */

hal_device_property_set_string (d, "block.storage_device", hal_device_get_udi (parent));

/* set volume defaults */

hal_device_property_set_string (d, "volume.fstype", "");

hal_device_property_set_string (d, "volume.fsusage", "");

hal_device_property_set_string (d, "volume.fsversion", "");

hal_device_property_set_string (d, "volume.uuid", "");

hal_device_property_set_string (d, "volume.label", "");

hal_device_property_set_string (d, "volume.mount_point", "");

hal_device_property_set_bool (d, "volume.is_mounted", FALSE);

if (strcmp (hal_device_property_get_string (parent, "storage.drive_type"), "cdrom") == 0) {

hal_device_property_set_bool (d, "volume.is_disc", TRUE);

hal_device_add_capability (d, "volume.disc");

} else {

hal_device_property_set_bool (d, "volume.is_disc", FALSE);

}

if (dosnum > 0) {

hal_device_property_set_bool (d, "volume.is_partition", TRUE);

hal_device_property_set_int (d, "volume.partition.number", dosnum);

} else {

hal_device_property_set_bool (d, "volume.is_partition", FALSE);

}

/* prober may override these */

hal_device_property_set_int (d, "volume.block_size", 512);

devinfo_add_enqueue (d, devfs_path, &devinfo_volume_handler);

return (d);

}

static void

devinfo_volume_preprobing_done (HalDevice *d, gpointer userdata1, gpointer userdata2)

{

void *end_token = (void *) userdata1;

char *whole_disk;

char *block_device;

const char *storage_udi;

HalDevice *storage_d;

const char *slice;

int dos_num;

if (hal_device_property_get_bool (d, "info.ignore")) {

HAL_INFO (("Preprobing merged info.ignore==TRUE %s", hal_device_get_udi (d)));

goto skip;

}

/*

block_device = (char *)hal_device_property_get_string (d, "block.device");

storage_udi = hal_device_property_get_string (d, "block.storage_device");

slice = hal_device_property_get_string(d, "block.solaris.slice");

if ((block_device == NULL) || (storage_udi == NULL) ||

(slice == NULL) || (strlen (slice) < 2)) {

HAL_INFO (("Malformed volume properties %s", hal_device_get_udi (d)));

goto skip;

}

storage_d = hal_device_store_match_key_value_string (hald_get_gdl (), "info.udi", storage_udi);

if (storage_d == NULL) {

HAL_INFO (("Storage device not found %s", hal_device_get_udi (d)));

goto skip;

}

whole_disk = hal_device_has_capability (storage_d,

"storage.cdrom") ? "s2" : WHOLE_DISK;

if (is_dos_path(block_device, &dos_num)) {

/* don't probe more dos volumes than probe-storage found */

if ((hal_device_property_get_bool (storage_d, "storage.no_partitions_hint") ||

(dos_num > hal_device_property_get_int (storage_d, "storage.solaris.num_dos_partitions")))) {

HAL_INFO (("%d > %d %s", dos_num, hal_device_property_get_int (storage_d,

"storage.solaris.num_dos_partitions"), hal_device_get_udi (storage_d)));

goto skip;

}

} else {

/* if no VTOC slices found, don't probe slices except s2 */

if ((slice[0] == 's') && (isdigit(slice[1])) && ((strcmp (slice, whole_disk)) != 0) &&

!hal_device_property_get_bool (storage_d, "storage.solaris.vtoc_slices")) {

HAL_INFO (("Not probing slice %s", hal_device_get_udi (d)));

goto skip;

}

}

HAL_INFO(("Probing udi=%s", hal_device_get_udi (d)));

hald_runner_run (d,

"hald-probe-volume", NULL,

DEVINFO_PROBE_VOLUME_TIMEOUT,

devinfo_callouts_probing_done,

(gpointer) end_token, userdata2);

return;

skip:

hal_device_store_remove (hald_get_tdl (), d);

g_object_unref (d);

hotplug_event_end (end_token);

}

static void

devinfo_volume_hotplug_begin_add (HalDevice *d, HalDevice *parent, DevinfoDevHandler *handler, void *end_token)

{

HAL_INFO(("Preprobing volume udi=%s", hal_device_get_udi (d)));

if (parent == NULL) {

HAL_INFO (("no parent %s", hal_device_get_udi (d)));

goto skip;

}

if (hal_device_property_get_bool (parent, "info.ignore")) {

HAL_INFO (("Ignoring volume: parent's info.ignore is TRUE"));

goto skip;

}

/* add to TDL so preprobing callouts and prober can access it */

hal_device_store_add (hald_get_tdl (), d);

/* Process preprobe fdi files */

di_search_and_merge (d, DEVICE_INFO_TYPE_PREPROBE);

/* Run preprobe callouts */

hal_util_callout_device_preprobe (d, devinfo_volume_preprobing_done, end_token, handler);

return;

skip:

g_object_unref (d);

hotplug_event_end (end_token);

}

devinfo_storage_hotplug_begin_add (HalDevice *d, HalDevice *parent, DevinfoDevHandler *handler, void *end_token)

{

const char *drive_type;

const char *p_udi;

HalDevice *p_d;

HalDevice *phys_d = NULL;

const char *phys_bus;

const char *bus;

static const char *busses[] = { "usb", "ide", "scsi", "ieee1394",

"pseudo" };

int i;

HAL_INFO (("Preprobing udi=%s", hal_device_get_udi (d)));

if (parent == NULL) {

HAL_INFO (("no parent %s", hal_device_get_udi (d)));

goto error;

}

/*

drive_type = hal_device_property_get_string (d, "storage.drive_type");

if ((drive_type != NULL) && (strcmp (drive_type, "floppy") == 0)) {

goto skip_bus;

}

p_d = parent;

for (;;) {

bus = hal_device_property_get_string (p_d, "info.subsystem");

if (bus != NULL) {

for (i = 0; i < NELEM(busses); i++) {

if (strcmp(bus, busses[i]) == 0) {

phys_d = p_d;

phys_bus = busses[i];

break;

}

}

}

/* up the tree */

p_udi = hal_device_property_get_string (p_d, "info.parent");

if (p_udi == NULL) {

break;

}

p_d = hal_device_store_find (hald_get_gdl (), p_udi);

}

if (phys_d == NULL) {

HAL_INFO (("no physical device %s", hal_device_get_udi (d)));

} else {

hal_device_property_set_string (d, "storage.physical_device", hal_device_get_udi (phys_d));

hal_device_property_set_string (d, "storage.bus", phys_bus);

}

skip_bus:

/* add to TDL so preprobing callouts and prober can access it */

hal_device_store_add (hald_get_tdl (), d);

/* Process preprobe fdi files */

di_search_and_merge (d, DEVICE_INFO_TYPE_PREPROBE);

/* Run preprobe callouts */

hal_util_callout_device_preprobe (d, devinfo_callouts_preprobing_done, end_token, handler);

return;

error:

g_object_unref (d);

hotplug_event_end (end_token);

}

static void

devinfo_storage_probing_done (HalDevice *d, guint32 exit_type, gint return_code, char **error, gpointer userdata1, gpointer userdata2)

{

void *end_token = (void *) userdata1;

HAL_INFO (("devinfo_storage_probing_done %s", hal_device_get_udi (d)));

/* Discard device if probing reports failure */

if (exit_type != HALD_RUN_SUCCESS || return_code != 0) {

HAL_INFO (("devinfo_storage_probing_done returning exit_type=%d return_code=%d", exit_type, return_code));

hal_device_store_remove (hald_get_tdl (), d);

g_object_unref (d);

hotplug_event_end (end_token);

return;

}

devinfo_storage_set_nicknames (d);

/* Merge properties from .fdi files */

di_search_and_merge (d, DEVICE_INFO_TYPE_INFORMATION);

di_search_and_merge (d, DEVICE_INFO_TYPE_POLICY);

hal_util_callout_device_add (d, devinfo_callouts_add_done, end_token, NULL);

}

const gchar *

devinfo_storage_get_prober (HalDevice *d, int *timeout)

{

*timeout = DEVINFO_PROBE_STORAGE_TIMEOUT;

return "hald-probe-storage";

}

const gchar *

devinfo_volume_get_prober (HalDevice *d, int *timeout)

{

*timeout = DEVINFO_PROBE_VOLUME_TIMEOUT;

return "hald-probe-volume";

}

static void

devinfo_storage_rescan_probing_done (HalDevice *d, guint32 exit_type, gint return_code, char **error, gpointer userdata1, gpointer userdata2)

{

void *end_token = (void *) userdata1;

const char *devfs_path_orig = NULL;

char *devfs_path = NULL;

char *p;

di_node_t node;

HAL_INFO (("devinfo_storage_rescan_probing_done %s", hal_device_get_udi (d)));

devfs_path_orig = hal_device_property_get_string (d, "solaris.devfs_path");

if (devfs_path_orig == NULL) {

HAL_INFO (("device has no solaris.devfs_path"));

hotplug_event_process_queue ();

return;

}

/* strip trailing minor part if any */

if (strrchr(devfs_path_orig, ':') != NULL) {

if ((devfs_path = strdup (devfs_path_orig)) != NULL) {

p = strrchr(devfs_path, ':');

*p = '\0';

}

} else {

devfs_path = (char *)devfs_path_orig;

}

if ((node = di_init (devfs_path, DINFOCPYALL)) == DI_NODE_NIL) {

HAL_INFO (("di_init %s failed %d %s", devfs_path, errno, hal_device_get_udi (d)));

hotplug_event_process_queue ();

return;

} else {

devinfo_storage_minors (d, node, (char *)devfs_path, TRUE);

di_fini (node);

}

if (devfs_path != devfs_path_orig) {

free (devfs_path);

}

hotplug_event_process_queue ();

}

devinfo_storage_device_rescan (HalDevice *d)

{

GSList *i;

GSList *volumes;

HalDevice *v;

gchar *v_devfs_path;

const char *drive_type;

gboolean is_floppy;

gboolean media_available;

HAL_INFO (("devinfo_storage_device_rescan udi=%s", hal_device_get_udi (d)));

if (hal_device_property_get_bool (d, "block.is_volume")) {

HAL_INFO (("nothing to do for volume"));

return (FALSE);

}

drive_type = hal_device_property_get_string (d, "storage.drive_type");

is_floppy = (drive_type != NULL) && (strcmp (drive_type, "floppy") == 0);

media_available = !hal_device_property_get_bool (d, "storage.removable") ||

hal_device_property_get_bool (d, "storage.removable.media_available");

if (!media_available && !is_floppy) {

HAL_INFO (("media gone %s", hal_device_get_udi (d)));

volumes = hal_device_store_match_multiple_key_value_string (hald_get_gdl(),

"block.storage_device", hal_device_get_udi (d));

for (i = volumes; i != NULL; i = g_slist_next (i)) {

v = HAL_DEVICE (i->data);

v_devfs_path = (gchar *)hal_device_property_get_string (v, "solaris.devfs_path");

HAL_INFO (("child volume %s", hal_device_get_udi (v)));

if ((v_devfs_path != NULL) && hal_device_has_capability (v, "volume")) {

HAL_INFO (("removing volume %s", hal_device_get_udi (v)));

devinfo_remove_enqueue (v_devfs_path, NULL);

} else {

HAL_INFO (("not a volume %s", hal_device_get_udi (v)));

}

}

g_slist_free (volumes);

hotplug_event_process_queue ();

} else if (is_floppy) {

HAL_INFO (("rescanning floppy %s", hal_device_get_udi (d)));

hald_runner_run (d,

"hald-probe-storage --only-check-for-media", NULL,

DEVINFO_PROBE_STORAGE_TIMEOUT,

devinfo_floppy_rescan_probing_done,

NULL, NULL);

} else {

HAL_INFO (("media available %s", hal_device_get_udi (d)));

hald_runner_run (d,

"hald-probe-storage --only-check-for-media", NULL,

DEVINFO_PROBE_STORAGE_TIMEOUT,

devinfo_storage_rescan_probing_done,

NULL, NULL);

}

return TRUE;

}

static char *

devinfo_volume_get_slice_name (char *devlink)

{

char *part, *slice, *disk;

char *s = NULL;

char *p;

if ((p = strstr(devlink, "/lofi/")) != 0) {

return (p + sizeof ("/lofi/") - 1);

}

part = strrchr(devlink, 'p');

slice = strrchr(devlink, 's');

disk = strrchr(devlink, 'd');

if ((part != NULL) && (part > slice) && (part > disk)) {

s = part;

} else if ((slice != NULL) && (slice > disk)) {

s = slice;

} else {

s = disk;

}

if ((s != NULL) && isdigit(s[1])) {

return (s);

} else {

return ("");

}

}

static gboolean

is_dos_path(char *path, int *partnum)

{

char *p;

if ((p = strrchr (path, ':')) == NULL) {

return (FALSE);

}

return ((*partnum = atoi(p + 1)) != 0);

}

static gboolean

dos_to_dev(char *path, char **devpath, int *partnum)

{

char *p;

if ((p = strrchr (path, ':')) == NULL) {

return (FALSE);

}

if ((*partnum = atoi(p + 1)) == 0) {

return (FALSE);

}

p[0] = '\0';

*devpath = strdup(path);

p[0] = ':';

return (*devpath != NULL);

}

static void

devinfo_storage_cleanup_mountpoint_cb (HalDevice *d, guint32 exit_type,

gint return_code, gchar **error,

gpointer data1, gpointer data2)

{

char *mount_point = (char *) data1;

HAL_INFO (("Cleaned up mount point '%s'", mount_point));

g_free (mount_point);

}

devinfo_storage_mnttab_event (HalDevice *hal_volume)

{

FILE *fp = NULL;

struct extmnttab m;

HalDevice *d;

unsigned int major;

unsigned int minor;

GSList *volumes = NULL;

GSList *v;

char *mount_point;

dbus_bool_t is_partition;

const char *fstype;

int partition_number;

if (hal_volume != NULL) {

volumes = g_slist_append (NULL, hal_volume);

} else {

volumes = hal_device_store_match_multiple_key_value_string (hald_get_gdl (), "info.category", "volume");

}

if (volumes == NULL) {

return;

}

if ((fp = fopen(MNTTAB, "r")) == NULL) {

HAL_ERROR (("Open failed %s errno %d", MNTTAB, errno));

return;

}

while (getextmntent(fp, &m, 1) == 0) {

for (v = volumes; v != NULL; v = g_slist_next (v)) {

d = HAL_DEVICE (v->data);

major = hal_device_property_get_int (d, "block.major");

minor = hal_device_property_get_int (d, "block.minor");

/*

is_partition = hal_device_property_get_bool (d, "volume.is_partition");

partition_number = hal_device_property_get_int (d, "volume.partition.number");

fstype = hal_device_property_get_string (d, "volume.fstype");

if (is_partition && (partition_number > 0) && (strcmp (fstype, "pcfs") == 0)) {

minor |= partition_number << 12;

}

if (m.mnt_major != major || m.mnt_minor != minor) {

continue;

}

/* this volume matches the mnttab entry */

device_property_atomic_update_begin ();

hal_device_property_set_bool (d, "volume.is_mounted", TRUE);

hal_device_property_set_bool (d, "volume.is_mounted_read_only",

hasmntopt ((struct mnttab *)&m, "ro") ? TRUE : FALSE);

hal_device_property_set_string (d, "volume.mount_point", m.mnt_mountp);

device_property_atomic_update_end ();

HAL_INFO (("set %s to be mounted at %s",

hal_device_get_udi (d), m.mnt_mountp));

volumes = g_slist_delete_link (volumes, v);

}

}

/* all remaining volumes are not mounted */

for (v = volumes; v != NULL; v = g_slist_next (v)) {

d = HAL_DEVICE (v->data);

mount_point = g_strdup (hal_device_property_get_string (d, "volume.mount_point"));

if (mount_point == NULL || strlen (mount_point) == 0) {

g_free (mount_point);

continue;

}

device_property_atomic_update_begin ();

hal_device_property_set_bool (d, "volume.is_mounted", FALSE);

hal_device_property_set_bool (d, "volume.is_mounted_read_only", FALSE);

hal_device_property_set_string (d, "volume.mount_point", "");

device_property_atomic_update_end ();

HAL_INFO (("set %s to unmounted", hal_device_get_udi (d)));

/* cleanup if was mounted by us */

if (hal_util_is_mounted_by_hald (mount_point)) {

char *cleanup_stdin;

char *extra_env[2];

HAL_INFO (("Cleaning up '%s'", mount_point));

extra_env[0] = g_strdup_printf ("HALD_CLEANUP=%s", mount_point);

extra_env[1] = NULL;

cleanup_stdin = "\n";

hald_runner_run_method (d,

"hal-storage-cleanup-mountpoint",

extra_env,

cleanup_stdin, TRUE,

0,

devinfo_storage_cleanup_mountpoint_cb,

g_strdup (mount_point), NULL);

g_free (extra_env[0]);

}

g_free (mount_point);

}

g_slist_free (volumes);

(void) fclose (fp);

}

static void

devinfo_volume_force_unmount_cb (HalDevice *d, guint32 exit_type,

gint return_code, gchar **error,

gpointer data1, gpointer data2)

{

void *end_token = (void *) data1;

HAL_INFO (("devinfo_volume_force_unmount_cb for udi='%s', exit_type=%d, return_code=%d", hal_device_get_udi (d), exit_type, return_code));

if (exit_type == HALD_RUN_SUCCESS && error != NULL &&

error[0] != NULL && error[1] != NULL) {

char *exp_name = NULL;

char *exp_detail = NULL;

exp_name = error[0];

if (error[0] != NULL) {

exp_detail = error[1];

}

HAL_INFO (("failed with '%s' '%s'", exp_name, exp_detail));

}

hal_util_callout_device_remove (d, devinfo_callouts_remove_done, end_token, NULL);

}

static void

devinfo_volume_force_unmount (HalDevice *d, void *end_token)

{

const char *device_file;

const char *mount_point;

char *unmount_stdin;

char *extra_env[2];

extra_env[0] = "HAL_METHOD_INVOKED_BY_UID=0";

extra_env[1] = NULL;

device_file = hal_device_property_get_string (d, "block.device");

mount_point = hal_device_property_get_string (d, "volume.mount_point");

if (mount_point == NULL || strlen (mount_point) == 0 || !hal_util_is_mounted_by_hald (mount_point)) {

hal_util_callout_device_remove (d, devinfo_callouts_remove_done, end_token, NULL);

return;

}

HAL_INFO (("devinfo_volume_force_unmount for udi='%s'", hal_device_get_udi (d)));

unmount_stdin = "\n";

hald_runner_run_method (d,

"hal-storage-unmount",

extra_env,

unmount_stdin, TRUE,

0,

devinfo_volume_force_unmount_cb,

end_token, NULL);

}

devinfo_volume_hotplug_begin_remove (HalDevice *d, char *devfs_path, void *end_token)

{

if (hal_device_property_get_bool (d, "volume.is_mounted")) {

devinfo_volume_force_unmount (d, end_token);

} else {

hal_util_callout_device_remove (d, devinfo_callouts_remove_done, end_token, NULL);

}

}

enum {

LEGACY_CDROM,

LEGACY_FLOPPY,

LEGACY_RMDISK

};

static const char *legacy_media_str[] = {

"cdrom",

"floppy",

"rmdisk"

};

struct enum_nick {

const char *type;

GSList *nums;

};

static int

devinfo_storage_get_legacy_media(HalDevice *d)

{

const char *drive_type;

if (hal_device_has_capability (d, "storage.cdrom")) {

return (LEGACY_CDROM);

} else if (((drive_type = hal_device_property_get_string (d,

"storage.drive_type")) != NULL) && (strcmp (drive_type, "floppy") == 0)) {

return (LEGACY_FLOPPY);

} else if (hal_device_property_get_bool (d, "storage.removable") ||

hal_device_property_get_bool (d, "storage.hotpluggable")) {

return (LEGACY_RMDISK);

} else {

return (-1);

}

}

static gboolean

devinfo_storage_foreach_nick (HalDeviceStore *store, HalDevice *d, gpointer user_data)

{

struct enum_nick *en = (struct enum_nick *) user_data;

const char *media_type;

int media_num;

media_type = hal_device_property_get_string (d, "storage.solaris.legacy.media_type");

media_num = hal_device_property_get_int (d, "storage.solaris.legacy.media_num");

if ((media_type != NULL) && (strcmp (media_type, en->type) == 0) &&

(media_num >= 0)) {

en->nums = g_slist_prepend (en->nums, GINT_TO_POINTER(media_num));

}

return TRUE;

}

static void

devinfo_storage_append_nickname (HalDevice *d, const char *media_type, int media_num)

{

char buf[64];

if (media_num == 0) {

hal_device_property_strlist_append (d, "storage.solaris.nicknames", media_type);

}

snprintf(buf, sizeof (buf), "%s%d", media_type, media_num);

hal_device_property_strlist_append (d, "storage.solaris.nicknames", buf);

}

static void

devinfo_storage_set_nicknames (HalDevice *d)

{

int media;

const char *media_type;

int media_num;

GSList *i;

struct enum_nick en;

char buf[64];

if ((media = devinfo_storage_get_legacy_media (d)) < 0) {

return;

}

media_type = legacy_media_str[media];

/* enumerate all storage devices of this media type */

en.type = media_type;

en.nums = NULL;

hal_device_store_foreach (hald_get_gdl (), devinfo_storage_foreach_nick, &en);

/* find a free number */

for (media_num = 0; ; media_num++) {

for (i = en.nums; i != NULL; i = g_slist_next (i)) {

if (GPOINTER_TO_INT (i->data) == media_num) {

break;

}

}

if (i == NULL) {

break;

}

}

g_slist_free (en.nums);

hal_device_property_set_string (d, "storage.solaris.legacy.media_type", media_type);

hal_device_property_set_int (d, "storage.solaris.legacy.media_num", media_num);

/* primary nickname, and also vold-style symdev */

snprintf(buf, sizeof (buf), "%s%d", media_type, media_num);

hal_device_property_set_string (d, "storage.solaris.legacy.symdev", buf);

devinfo_storage_append_nickname(d, media_type, media_num);

/* additional nicknames */

if (media == LEGACY_CDROM) {

devinfo_storage_append_nickname(d, "cd", media_num);

devinfo_storage_append_nickname(d, "sr", media_num);

} else if (media == LEGACY_FLOPPY) {

devinfo_storage_append_nickname(d, "fd", media_num);

devinfo_storage_append_nickname(d, "diskette", media_num);

devinfo_storage_append_nickname(d, "rdiskette", media_num);

}

}