int
main (int argc, char *argv[])
{
int fd, rfd;
int ret;
char *udi;
char *device_file, *raw_device_file;
char *devpath, *rdevpath;
boolean_t is_dos;
int dos_num;
LibHalContext *ctx = NULL;
DBusError error;
DBusConnection *conn;
char *parent_udi;
char *storage_device;
char *is_disc_str;
int fdc;
dbus_bool_t is_disc = FALSE;
dbus_bool_t is_floppy = FALSE;
unsigned int block_size;
dbus_uint64_t vol_size;
dbus_bool_t has_data = TRUE; /* probe for fs by default */
dbus_bool_t has_audio = FALSE;
char *partition_scheme = NULL;
dbus_uint64_t partition_start = 0;
int partition_number = 0;
struct vtoc vtoc;
dk_gpt_t *gpt;
struct dk_minfo mi;
int i, dos_cnt;
fstyp_handle_t fstyp_handle;
int systid, relsect, numsect;
off_t probe_offset = 0;
int num_volumes;
char **volumes;
dbus_uint64_t v_start;
const char *fstype;
nvlist_t *fsattr;
fd = rfd = -1;
ret = 1;
if ((udi = getenv ("UDI")) == NULL) {
goto out;
}
if ((device_file = getenv ("HAL_PROP_BLOCK_DEVICE")) == NULL) {
goto out;
}
if ((raw_device_file = getenv ("HAL_PROP_BLOCK_SOLARIS_RAW_DEVICE")) == NULL) {
goto out;
}
if (!dos_to_dev(device_file, &rdevpath, &dos_num)) {
rdevpath = raw_device_file;
}
if (!(is_dos = dos_to_dev(device_file, &devpath, &dos_num))) {
devpath = device_file;
}
if ((parent_udi = getenv ("HAL_PROP_INFO_PARENT")) == NULL) {
goto out;
}
if ((storage_device = getenv ("HAL_PROP_BLOCK_STORAGE_DEVICE")) == NULL) {
goto out;
}
is_disc_str = getenv ("HAL_PROP_VOLUME_IS_DISC");
if (is_disc_str != NULL && strcmp (is_disc_str, "true") == 0) {
is_disc = TRUE;
} else {
is_disc = FALSE;
}
drop_privileges ();
setup_logger ();
dbus_error_init (&error);
if ((ctx = libhal_ctx_init_direct (&error)) == NULL)
goto out;
HAL_DEBUG (("Doing probe-volume for %s\n", device_file));
fd = open (devpath, O_RDONLY | O_NONBLOCK);
if (fd < 0) {
goto out;
}
rfd = open (rdevpath, O_RDONLY | O_NONBLOCK);
if (rfd < 0) {
goto out;
}
/* if it's a floppy with no media, bail out */
if (ioctl(rfd, FDGETCHANGE, &fdc) == 0) {
is_floppy = TRUE;
if (fdc & FDGC_CURRENT) {
goto out;
}
}
/* block size and total size */
if (ioctl(rfd, DKIOCGMEDIAINFO, &mi) != -1) {
block_size = mi.dki_lbsize;
vol_size = mi.dki_capacity * block_size;
} else if (errno == ENXIO) {
/* driver supports ioctl, but media is not available */
goto out;
} else {
/* driver does not support ioctl, e.g. lofi */
block_size = 512;
vol_size = 0;
}
libhal_device_set_property_int (ctx, udi, "volume.block_size", block_size, &error);
my_dbus_error_free (&error);
libhal_device_set_property_uint64 (ctx, udi, "volume.size", vol_size, &error);
my_dbus_error_free (&error);
if (is_disc) {
if (!probe_disc (rfd, ctx, udi, &has_data, &has_audio)) {
HAL_DEBUG (("probe_disc failed, skipping fstyp"));
goto out;
}
/* with audio present, create volume even if fs probing fails */
if (has_audio) {
ret = 0;
}
}
if (!has_data) {
goto skip_fs;
}
/* don't support partitioned floppy */
if (is_floppy) {
goto skip_part;
}
/*
* first get partitioning info
*/
if (is_dos) {
/* for a dos drive find partition offset */
if (!find_dos_drive(fd, dos_num, &relsect, &numsect, &systid)) {
goto out;
}
partition_scheme = "mbr";
partition_start = (dbus_uint64_t)relsect * 512;
partition_number = dos_num;
probe_offset = (off_t)relsect * 512;
} else {
if ((partition_number = read_vtoc(rfd, &vtoc)) >= 0) {
if (!vtoc_one_slice_entire_disk(&vtoc)) {
partition_scheme = "smi";
if (partition_number < vtoc.v_nparts) {
if (vtoc.v_part[partition_number].p_size == 0) {
HAL_DEBUG (("zero size partition"));
}
partition_start = vtoc.v_part[partition_number].p_start * block_size;
}
}
} else if ((partition_number = efi_alloc_and_read(rfd, &gpt)) >= 0) {
partition_scheme = "gpt";
if (partition_number < gpt->efi_nparts) {
if (gpt->efi_parts[partition_number].p_size == 0) {
HAL_DEBUG (("zero size partition"));
}
partition_start = gpt->efi_parts[partition_number].p_start * block_size;
}
efi_free(gpt);
}
probe_offset = 0;
}
if (partition_scheme != NULL) {
libhal_device_set_property_string (ctx, udi, "volume.partition.scheme", partition_scheme, &error);
my_dbus_error_free (&error);
libhal_device_set_property_int (ctx, udi, "volume.partition.number", partition_number, &error);
my_dbus_error_free (&error);
libhal_device_set_property_uint64 (ctx, udi, "volume.partition.start", partition_start, &error);
my_dbus_error_free (&error);
libhal_device_set_property_bool (ctx, udi, "volume.is_partition", TRUE, &error);
my_dbus_error_free (&error);
} else {
libhal_device_set_property_bool (ctx, udi, "volume.is_partition", FALSE, &error);
my_dbus_error_free (&error);
}
/*
* ignore duplicate partitions
*/
if ((volumes = libhal_manager_find_device_string_match (
ctx, "block.storage_device", storage_device, &num_volumes, &error)) != NULL) {
my_dbus_error_free (&error);
for (i = 0; i < num_volumes; i++) {
if (strcmp (udi, volumes[i]) == 0) {
continue; /* skip self */
}
v_start = libhal_device_get_property_uint64 (ctx, volumes[i], "volume.partition.start", &error);
if (dbus_error_is_set(&error)) {
dbus_error_free(&error);
continue;
}
if (v_start == partition_start) {
HAL_DEBUG (("duplicate partition"));
goto out;
}
}
libhal_free_string_array (volumes);
}
skip_part:
/*
* now determine fs type
*
* XXX We could get better performance from block device,
* but for now we use raw device because:
*
* - fstyp_udfs has a bug that it only works on raw
*
* - sd has a bug that causes extremely slow reads
* and incorrect probing of hybrid audio/data media
*/
if (fstyp_init(rfd, probe_offset, NULL, &fstyp_handle) != 0) {
HAL_DEBUG (("fstyp_init failed"));
goto out;
}
if ((fstyp_ident(fstyp_handle, NULL, &fstype) != 0) ||
(fstyp_get_attr(fstyp_handle, &fsattr) != 0)) {
HAL_DEBUG (("fstyp ident or get_attr failed"));
fstyp_fini(fstyp_handle);
goto out;
}
set_fstyp_properties (ctx, udi, fstype, fsattr);
if (strcmp (fstype, "hsfs") == 0) {
hsfs_contents (fd, probe_offset, ctx, udi);
}
fstyp_fini(fstyp_handle);
skip_fs:
ret = 0;
out:
if (fd >= 0)
close (fd);
if (rfd >= 0)
close (rfd);
if (ctx != NULL) {
my_dbus_error_free (&error);
libhal_ctx_shutdown (ctx, &error);
libhal_ctx_free (ctx);
}
return ret;
}
/*
* open the device and fill the various members of ig_device_t.
*/
static int
init_device(ig_device_t *device, char *path)
{
struct dk_gpt *vtoc;
fstyp_handle_t fhdl;
const char *fident;
bzero(device, sizeof (*device));
device->part_fd = -1;
device->disk_fd = -1;
device->path_p0 = NULL;
device->path = strdup(path);
if (device->path == NULL) {
perror(gettext("Memory allocation failed"));
return (BC_ERROR);
}
if (strstr(device->path, "diskette")) {
(void) fprintf(stderr, gettext("installing GRUB to a floppy "
"disk is no longer supported\n"));
return (BC_ERROR);
}
/* Detect if the target device is a pcfs partition. */
if (strstr(device->path, "p0:boot"))
device->type = IG_DEV_X86BOOTPAR;
if (get_disk_fd(device) != BC_SUCCESS)
return (BC_ERROR);
/* read in the device boot sector. */
if (read(device->disk_fd, device->boot_sector, SECTOR_SIZE)
!= SECTOR_SIZE) {
(void) fprintf(stderr, gettext("Error reading boot sector\n"));
perror("read");
return (BC_ERROR);
}
if (efi_alloc_and_read(device->disk_fd, &vtoc) >= 0) {
device->type = IG_DEV_EFI;
efi_free(vtoc);
}
if (get_raw_partition_fd(device) != BC_SUCCESS)
return (BC_ERROR);
if (is_efi(device->type)) {
if (fstyp_init(device->part_fd, 0, NULL, &fhdl) != 0)
return (BC_ERROR);
if (fstyp_ident(fhdl, "zfs", &fident) != 0) {
fstyp_fini(fhdl);
(void) fprintf(stderr, gettext("Booting of EFI labeled "
"disks is only supported with ZFS\n"));
return (BC_ERROR);
}
fstyp_fini(fhdl);
}
if (get_start_sector(device) != BC_SUCCESS)
return (BC_ERROR);
return (BC_SUCCESS);
}
