/*
 *  VAS_EBOOT  --  GRand Unified Bootloader
 *  Copyright (C) 2006,2007,2008  Free Software Foundation, Inc.
 *
 *  VAS_EBOOT is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  VAS_EBOOT is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with VAS_EBOOT.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <VasEBoot/disk.h>
#include <VasEBoot/partition.h>
#include <VasEBoot/mm.h>
#include <VasEBoot/types.h>
#include <VasEBoot/misc.h>
#include <VasEBoot/err.h>
#include <VasEBoot/term.h>
#include <VasEBoot/efi/api.h>
#include <VasEBoot/efi/efi.h>
#include <VasEBoot/efi/disk.h>

struct VasEBoot_efidisk_data
{
  VasEBoot_efi_handle_t handle;
  VasEBoot_efi_device_path_t *device_path;
  VasEBoot_efi_device_path_t *last_device_path;
  VasEBoot_efi_block_io_t *block_io;
  struct VasEBoot_efidisk_data *next;
};

/* GUID.  */
static VasEBoot_guid_t block_io_guid = VAS_EBOOT_EFI_BLOCK_IO_GUID;

static struct VasEBoot_efidisk_data *fd_devices;
static struct VasEBoot_efidisk_data *hd_devices;
static struct VasEBoot_efidisk_data *cd_devices;

static struct VasEBoot_efidisk_data *
make_devices (void)
{
  VasEBoot_efi_uintn_t num_handles;
  VasEBoot_efi_handle_t *handles;
  VasEBoot_efi_handle_t *handle;
  struct VasEBoot_efidisk_data *devices = 0;

  /* Find handles which support the disk io interface.  */
  handles = VasEBoot_efi_locate_handle (VAS_EBOOT_EFI_BY_PROTOCOL, &block_io_guid,
				    0, &num_handles);
  if (! handles)
    return 0;

  /* Make a linked list of devices.  */
  for (handle = handles; num_handles--; handle++)
    {
      VasEBoot_efi_device_path_t *dp;
      VasEBoot_efi_device_path_t *ldp;
      struct VasEBoot_efidisk_data *d;
      VasEBoot_efi_block_io_t *bio;

      dp = VasEBoot_efi_get_device_path (*handle);
      if (! dp)
	continue;

      ldp = VasEBoot_efi_find_last_device_path (dp);
      if (! ldp)
	/* This is empty. Why?  */
	continue;

      bio = VasEBoot_efi_open_protocol (*handle, &block_io_guid,
				    VAS_EBOOT_EFI_OPEN_PROTOCOL_GET_PROTOCOL);
      if (! bio)
	/* This should not happen... Why?  */
	continue;

      /* iPXE adds stub Block IO protocol to loaded image device handle. It is
         completely non-functional and simply returns an error for every method.
        So attempt to detect and skip it. Magic number is literal "iPXE" and
        check block size as well */
      /* FIXME: shoud we close it? We do not do it elsewhere */
      if (bio->media && bio->media->media_id == 0x69505845U &&
         bio->media->block_size == 1)
         continue;

      d = VasEBoot_malloc (sizeof (*d));
      if (! d)
	{
	  /* Uggh.  */
	  VasEBoot_free (handles);
	  while (devices)
	    {
	      d = devices->next;
	      VasEBoot_free (devices);
	      devices = d;
	    }
	  return 0;
	}

      d->handle = *handle;
      d->device_path = dp;
      d->last_device_path = ldp;
      d->block_io = bio;
      d->next = devices;
      devices = d;
    }

  VasEBoot_free (handles);

  return devices;
}

/* Find the parent device.  */
static struct VasEBoot_efidisk_data *
find_parent_device (struct VasEBoot_efidisk_data *devices,
		    struct VasEBoot_efidisk_data *d)
{
  VasEBoot_efi_device_path_t *dp, *ldp;
  struct VasEBoot_efidisk_data *parent;

  dp = VasEBoot_efi_duplicate_device_path (d->device_path);
  if (! dp)
    return 0;

  ldp = VasEBoot_efi_find_last_device_path (dp);
  if (! ldp)
    return 0;

  ldp->type = VAS_EBOOT_EFI_END_DEVICE_PATH_TYPE;
  ldp->subtype = VAS_EBOOT_EFI_END_ENTIRE_DEVICE_PATH_SUBTYPE;
  ldp->length = sizeof (*ldp);

  for (parent = devices; parent; parent = parent->next)
    {
      /* Ignore itself.  */
      if (parent == d)
	continue;

      if (VasEBoot_efi_compare_device_paths (parent->device_path, dp) == 0)
	break;
    }

  VasEBoot_free (dp);
  return parent;
}

static int
is_child (struct VasEBoot_efidisk_data *child,
	  struct VasEBoot_efidisk_data *parent)
{
  VasEBoot_efi_device_path_t *dp, *ldp;
  int ret;

  dp = VasEBoot_efi_duplicate_device_path (child->device_path);
  if (! dp)
    return 0;

  ldp = VasEBoot_efi_find_last_device_path (dp);
  if (! ldp)
    return 0;

  ldp->type = VAS_EBOOT_EFI_END_DEVICE_PATH_TYPE;
  ldp->subtype = VAS_EBOOT_EFI_END_ENTIRE_DEVICE_PATH_SUBTYPE;
  ldp->length = sizeof (*ldp);

  ret = (VasEBoot_efi_compare_device_paths (dp, parent->device_path) == 0);
  VasEBoot_free (dp);
  return ret;
}

#define FOR_CHILDREN(p, dev) for (p = dev; p; p = p->next) if (is_child (p, d))

/* Add a device into a list of devices in an ascending order.  */
static void
add_device (struct VasEBoot_efidisk_data **devices, struct VasEBoot_efidisk_data *d)
{
  struct VasEBoot_efidisk_data **p;
  struct VasEBoot_efidisk_data *n;

  for (p = devices; *p; p = &((*p)->next))
    {
      int ret;

      ret = VasEBoot_efi_compare_device_paths (VasEBoot_efi_find_last_device_path ((*p)->device_path),
					   VasEBoot_efi_find_last_device_path (d->device_path));
      if (ret == 0)
	ret = VasEBoot_efi_compare_device_paths ((*p)->device_path,
					     d->device_path);
      if (ret == 0)
	return;
      else if (ret > 0)
	break;
    }

  n = VasEBoot_malloc (sizeof (*n));
  if (! n)
    return;

  VasEBoot_memcpy (n, d, sizeof (*n));
  n->next = (*p);
  (*p) = n;
}

/* Name the devices.  */
static void
name_devices (struct VasEBoot_efidisk_data *devices)
{
  struct VasEBoot_efidisk_data *d;

  /* First, identify devices by media device paths.  */
  for (d = devices; d; d = d->next)
    {
      VasEBoot_efi_device_path_t *dp;

      dp = d->last_device_path;
      if (! dp)
	continue;

      if (VAS_EBOOT_EFI_DEVICE_PATH_TYPE (dp) == VAS_EBOOT_EFI_MEDIA_DEVICE_PATH_TYPE)
	{
	  int is_hard_drive = 0;

	  switch (VAS_EBOOT_EFI_DEVICE_PATH_SUBTYPE (dp))
	    {
	    case VAS_EBOOT_EFI_HARD_DRIVE_DEVICE_PATH_SUBTYPE:
	      is_hard_drive = 1;
	      /* Intentionally fall through.  */
	    case VAS_EBOOT_EFI_CDROM_DEVICE_PATH_SUBTYPE:
	      {
		struct VasEBoot_efidisk_data *parent, *parent2;

		parent = find_parent_device (devices, d);
		if (!parent)
		  {
#ifdef DEBUG_NAMES
		    VasEBoot_printf ("skipping orphaned partition: ");
		    VasEBoot_efi_print_device_path (d->device_path);
#endif
		    break;
		  }
		parent2 = find_parent_device (devices, parent);
		if (parent2)
		  {
#ifdef DEBUG_NAMES
		    VasEBoot_printf ("skipping subpartition: ");
		    VasEBoot_efi_print_device_path (d->device_path);
#endif
		    /* Mark itself as used.  */
		    d->last_device_path = 0;
		    break;
		  }
		if (!parent->last_device_path)
		  {
		    d->last_device_path = 0;
		    break;
		  }
		if (is_hard_drive)
		  {
#ifdef DEBUG_NAMES
		    VasEBoot_printf ("adding a hard drive by a partition: ");
		    VasEBoot_efi_print_device_path (parent->device_path);
#endif
		    add_device (&hd_devices, parent);
		  }
		else
		  {
#ifdef DEBUG_NAMES
		    VasEBoot_printf ("adding a cdrom by a partition: ");
		    VasEBoot_efi_print_device_path (parent->device_path);
#endif
		    add_device (&cd_devices, parent);
		  }

		/* Mark the parent as used.  */
		parent->last_device_path = 0;
	      }
	      /* Mark itself as used.  */
	      d->last_device_path = 0;
	      break;

	    default:
#ifdef DEBUG_NAMES
	      VasEBoot_printf ("skipping other type: ");
	      VasEBoot_efi_print_device_path (d->device_path);
#endif
	      /* For now, ignore the others.  */
	      break;
	    }
	}
      else
	{
#ifdef DEBUG_NAMES
	  VasEBoot_printf ("skipping non-media: ");
	  VasEBoot_efi_print_device_path (d->device_path);
#endif
	}
    }

  /* Let's see what can be added more.  */
  for (d = devices; d; d = d->next)
    {
      VasEBoot_efi_device_path_t *dp;
      VasEBoot_efi_block_io_media_t *m;
      int is_floppy = 0;

      dp = d->last_device_path;
      if (! dp)
	continue;

      /* Ghosts proudly presented by Apple.  */
      if (VAS_EBOOT_EFI_DEVICE_PATH_TYPE (dp) == VAS_EBOOT_EFI_MEDIA_DEVICE_PATH_TYPE
	  && VAS_EBOOT_EFI_DEVICE_PATH_SUBTYPE (dp)
	  == VAS_EBOOT_EFI_VENDOR_MEDIA_DEVICE_PATH_SUBTYPE)
	{
	  VasEBoot_efi_vendor_device_path_t *vendor = (VasEBoot_efi_vendor_device_path_t *) dp;
	  static const VasEBoot_guid_t apple = VAS_EBOOT_EFI_VENDOR_APPLE_GUID;

	  if (vendor->header.length == sizeof (*vendor)
	      && VasEBoot_memcmp (&vendor->vendor_guid, &apple,
			      sizeof (vendor->vendor_guid)) == 0
	      && find_parent_device (devices, d))
	    continue;
	}

      m = d->block_io->media;
      if (VAS_EBOOT_EFI_DEVICE_PATH_TYPE (dp) == VAS_EBOOT_EFI_ACPI_DEVICE_PATH_TYPE
	  && VAS_EBOOT_EFI_DEVICE_PATH_SUBTYPE (dp)
	  == VAS_EBOOT_EFI_ACPI_DEVICE_PATH_SUBTYPE)
	{
	  VasEBoot_efi_acpi_device_path_t *acpi
	    = (VasEBoot_efi_acpi_device_path_t *) dp;
	  /* Floppy EISA ID.  */
	  if (acpi->hid == 0x60441d0 || acpi->hid == 0x70041d0
	      || acpi->hid == 0x70141d1)
	    is_floppy = 1;
	}
      if (is_floppy)
	{
#ifdef DEBUG_NAMES
	  VasEBoot_printf ("adding a floppy: ");
	  VasEBoot_efi_print_device_path (d->device_path);
#endif
	  add_device (&fd_devices, d);
	}
      else if (m->read_only && m->block_size > VAS_EBOOT_DISK_SECTOR_SIZE)
	{
	  /* This check is too heuristic, but assume that this is a
	     CDROM drive.  */
#ifdef DEBUG_NAMES
	  VasEBoot_printf ("adding a cdrom by guessing: ");
	  VasEBoot_efi_print_device_path (d->device_path);
#endif
	  add_device (&cd_devices, d);
	}
      else
	{
	  /* The default is a hard drive.  */
#ifdef DEBUG_NAMES
	  VasEBoot_printf ("adding a hard drive by guessing: ");
	  VasEBoot_efi_print_device_path (d->device_path);
#endif
	  add_device (&hd_devices, d);
	}
    }
}

static void
free_devices (struct VasEBoot_efidisk_data *devices)
{
  struct VasEBoot_efidisk_data *p, *q;

  for (p = devices; p; p = q)
    {
      q = p->next;
      VasEBoot_free (p);
    }
}

/* Enumerate all disks to name devices.  */
static void
enumerate_disks (void)
{
  struct VasEBoot_efidisk_data *devices;

  devices = make_devices ();
  if (! devices)
    return;

  name_devices (devices);
  free_devices (devices);
}

static int
VasEBoot_efidisk_iterate (VasEBoot_disk_dev_iterate_hook_t hook, void *hook_data,
		      VasEBoot_disk_pull_t pull)
{
  struct VasEBoot_efidisk_data *d;
  char buf[16];
  int count;

  switch (pull)
    {
    case VAS_EBOOT_DISK_PULL_NONE:
      for (d = hd_devices, count = 0; d; d = d->next, count++)
	{
	  VasEBoot_snprintf (buf, sizeof (buf), "hd%d", count);
	  VasEBoot_dprintf ("efidisk", "iterating %s\n", buf);
	  if (hook (buf, hook_data))
	    return 1;
	}
      break;
    case VAS_EBOOT_DISK_PULL_REMOVABLE:
      for (d = fd_devices, count = 0; d; d = d->next, count++)
	{
	  VasEBoot_snprintf (buf, sizeof (buf), "fd%d", count);
	  VasEBoot_dprintf ("efidisk", "iterating %s\n", buf);
	  if (hook (buf, hook_data))
	    return 1;
	}

      for (d = cd_devices, count = 0; d; d = d->next, count++)
	{
	  VasEBoot_snprintf (buf, sizeof (buf), "cd%d", count);
	  VasEBoot_dprintf ("efidisk", "iterating %s\n", buf);
	  if (hook (buf, hook_data))
	    return 1;
	}
      break;
    default:
      return 0;
    }

  return 0;
}

static int
get_drive_number (const char *name)
{
  unsigned long drive;

  if ((name[0] != 'f' && name[0] != 'h' && name[0] != 'c') || name[1] != 'd')
    goto fail;

  drive = VasEBoot_strtoul (name + 2, 0, 10);
  if (VasEBoot_errno != VAS_EBOOT_ERR_NONE)
    goto fail;

  return (int) drive ;

 fail:
  VasEBoot_error (VAS_EBOOT_ERR_UNKNOWN_DEVICE, "not a efidisk");
  return -1;
}

static struct VasEBoot_efidisk_data *
get_device (struct VasEBoot_efidisk_data *devices, int num)
{
  struct VasEBoot_efidisk_data *d;

  for (d = devices; d && num; d = d->next, num--)
    ;

  if (num == 0)
    return d;

  return 0;
}

static VasEBoot_err_t
VasEBoot_efidisk_open (const char *name, struct VasEBoot_disk *disk)
{
  int num;
  struct VasEBoot_efidisk_data *d = 0;
  VasEBoot_efi_block_io_media_t *m;

  VasEBoot_dprintf ("efidisk", "opening %s\n", name);

  num = get_drive_number (name);
  if (num < 0)
    return VasEBoot_errno;

  switch (name[0])
    {
    case 'f':
      d = get_device (fd_devices, num);
      break;
    case 'c':
      d = get_device (cd_devices, num);
      break;
    case 'h':
      d = get_device (hd_devices, num);
      break;
    default:
      /* Never reach here.  */
      break;
    }

  if (! d)
    return VasEBoot_error (VAS_EBOOT_ERR_UNKNOWN_DEVICE, "no such device");

  disk->id = ((num << VAS_EBOOT_CHAR_BIT) | name[0]);
  m = d->block_io->media;
  /* FIXME: Probably it is better to store the block size in the disk,
     and total sectors should be replaced with total blocks.  */
  VasEBoot_dprintf ("efidisk",
		"m = %p, last block = %llx, block size = %x, io align = %x\n",
		m, (unsigned long long) m->last_block, m->block_size,
		m->io_align);

  /* Ensure required buffer alignment is a power of two (or is zero). */
  if (m->io_align & (m->io_align - 1))
    return VasEBoot_error (VAS_EBOOT_ERR_IO, "invalid buffer alignment %d", m->io_align);

  disk->total_sectors = m->last_block + 1;
  /* Don't increase this value due to bug in some EFI.  */
  disk->max_agglomerate = 0xa0000 >> (VAS_EBOOT_DISK_CACHE_BITS + VAS_EBOOT_DISK_SECTOR_BITS);
  if (m->block_size & (m->block_size - 1) || !m->block_size)
    return VasEBoot_error (VAS_EBOOT_ERR_IO, "invalid sector size %d",
		       m->block_size);
  disk->log_sector_size = VasEBoot_log2ull (m->block_size);
  disk->data = d;

  VasEBoot_dprintf ("efidisk", "opening %s succeeded\n", name);

  return VAS_EBOOT_ERR_NONE;
}

static void
VasEBoot_efidisk_close (struct VasEBoot_disk *disk __attribute__ ((unused)))
{
  /* EFI disks do not allocate extra memory, so nothing to do here.  */
  VasEBoot_dprintf ("efidisk", "closing %s\n", disk->name);
}

static VasEBoot_efi_status_t
VasEBoot_efidisk_readwrite (struct VasEBoot_disk *disk, VasEBoot_disk_addr_t sector,
			VasEBoot_size_t size, char *buf, int wr)
{
  struct VasEBoot_efidisk_data *d;
  VasEBoot_efi_block_io_t *bio;
  VasEBoot_efi_status_t status;
  VasEBoot_size_t io_align, num_bytes;
  char *aligned_buf;

  d = disk->data;
  bio = d->block_io;

  /*
   * If IoAlign is > 1, it should represent the required alignment. However,
   * some UEFI implementations seem to report IoAlign=2 but require 2^IoAlign.
   * Some implementation seem to require alignment despite not reporting any
   * specific requirements.
   *
   * Make sure to use buffers which are at least aligned to block size.
   */
  if (bio->media->io_align < bio->media->block_size)
    io_align = bio->media->block_size;
  else
    io_align = bio->media->io_align;

  num_bytes = size << disk->log_sector_size;

  if ((VasEBoot_addr_t) buf & (io_align - 1))
    {
      aligned_buf = VasEBoot_memalign (io_align, num_bytes);
      if (! aligned_buf)
	return VAS_EBOOT_EFI_OUT_OF_RESOURCES;
      if (wr)
	VasEBoot_memcpy (aligned_buf, buf, num_bytes);
    }
  else
    {
      aligned_buf = buf;
    }

  status =  (wr ? bio->write_blocks : bio->read_blocks) (bio, bio->media->media_id,
							 (VasEBoot_efi_uint64_t) sector,
							 (VasEBoot_efi_uintn_t) num_bytes,
							 aligned_buf);

  if ((VasEBoot_addr_t) buf & (io_align - 1))
    {
      if (!wr)
	VasEBoot_memcpy (buf, aligned_buf, num_bytes);
      VasEBoot_free (aligned_buf);
    }

  return status;
}

static VasEBoot_err_t
VasEBoot_efidisk_read (struct VasEBoot_disk *disk, VasEBoot_disk_addr_t sector,
		   VasEBoot_size_t size, char *buf)
{
  VasEBoot_efi_status_t status;

  VasEBoot_dprintf ("efidisk",
		"reading 0x%lx sectors at the sector 0x%llx from %s\n",
		(unsigned long) size, (unsigned long long) sector, disk->name);

  status = VasEBoot_efidisk_readwrite (disk, sector, size, buf, 0);

  if (status == VAS_EBOOT_EFI_NO_MEDIA)
    return VasEBoot_error (VAS_EBOOT_ERR_OUT_OF_RANGE, N_("no media in `%s'"), disk->name);
  else if (status != VAS_EBOOT_EFI_SUCCESS)
    return VasEBoot_error (VAS_EBOOT_ERR_READ_ERROR,
		       N_("failure reading sector 0x%llx from `%s'"),
		       (unsigned long long) sector,
		       disk->name);

  return VAS_EBOOT_ERR_NONE;
}

static VasEBoot_err_t
VasEBoot_efidisk_write (struct VasEBoot_disk *disk, VasEBoot_disk_addr_t sector,
		    VasEBoot_size_t size, const char *buf)
{
  VasEBoot_efi_status_t status;

  VasEBoot_dprintf ("efidisk",
		"writing 0x%lx sectors at the sector 0x%llx to %s\n",
		(unsigned long) size, (unsigned long long) sector, disk->name);

  status = VasEBoot_efidisk_readwrite (disk, sector, size, (char *) buf, 1);

  if (status == VAS_EBOOT_EFI_NO_MEDIA)
    return VasEBoot_error (VAS_EBOOT_ERR_OUT_OF_RANGE, N_("no media in `%s'"), disk->name);
  else if (status != VAS_EBOOT_EFI_SUCCESS)
    return VasEBoot_error (VAS_EBOOT_ERR_WRITE_ERROR,
		       N_("failure writing sector 0x%llx to `%s'"),
		       (unsigned long long) sector, disk->name);

  return VAS_EBOOT_ERR_NONE;
}

static struct VasEBoot_disk_dev VasEBoot_efidisk_dev =
  {
    .name = "efidisk",
    .id = VAS_EBOOT_DISK_DEVICE_EFIDISK_ID,
    .disk_iterate = VasEBoot_efidisk_iterate,
    .disk_open = VasEBoot_efidisk_open,
    .disk_close = VasEBoot_efidisk_close,
    .disk_read = VasEBoot_efidisk_read,
    .disk_write = VasEBoot_efidisk_write,
    .next = 0
  };

void
VasEBoot_efidisk_fini (void)
{
  free_devices (fd_devices);
  free_devices (hd_devices);
  free_devices (cd_devices);
  fd_devices = 0;
  hd_devices = 0;
  cd_devices = 0;
  VasEBoot_disk_dev_unregister (&VasEBoot_efidisk_dev);
}

void
VasEBoot_efidisk_init (void)
{
  VasEBoot_disk_firmware_fini = VasEBoot_efidisk_fini;

  enumerate_disks ();
  VasEBoot_disk_dev_register (&VasEBoot_efidisk_dev);
}

/* Some utility functions to map VAS_EBOOT devices with EFI devices.  */
VasEBoot_efi_handle_t
VasEBoot_efidisk_get_device_handle (VasEBoot_disk_t disk)
{
  struct VasEBoot_efidisk_data *d;
  char type;

  if (disk->dev->id != VAS_EBOOT_DISK_DEVICE_EFIDISK_ID)
    return 0;

  d = disk->data;
  type = disk->name[0];

  switch (type)
    {
    case 'f':
      /* This is the simplest case.  */
      return d->handle;

    case 'c':
      /* FIXME: probably this is not correct.  */
      return d->handle;

    case 'h':
      /* If this is the whole disk, just return its own data.  */
      if (! disk->partition)
	return d->handle;

      /* Otherwise, we must query the corresponding device to the firmware.  */
      {
	struct VasEBoot_efidisk_data *devices;
	VasEBoot_efi_handle_t handle = 0;
	struct VasEBoot_efidisk_data *c;

	devices = make_devices ();
	FOR_CHILDREN (c, devices)
	  {
	    VasEBoot_efi_hard_drive_device_path_t *hd;

	    hd = (VasEBoot_efi_hard_drive_device_path_t *) c->last_device_path;

	    if ((VAS_EBOOT_EFI_DEVICE_PATH_TYPE (c->last_device_path)
		 == VAS_EBOOT_EFI_MEDIA_DEVICE_PATH_TYPE)
		&& (VAS_EBOOT_EFI_DEVICE_PATH_SUBTYPE (c->last_device_path)
		    == VAS_EBOOT_EFI_HARD_DRIVE_DEVICE_PATH_SUBTYPE)
		&& (VasEBoot_partition_get_start (disk->partition)
		    == (hd->partition_start << (disk->log_sector_size
						- VAS_EBOOT_DISK_SECTOR_BITS)))
		&& (VasEBoot_partition_get_len (disk->partition)
		    == (hd->partition_size << (disk->log_sector_size
					       - VAS_EBOOT_DISK_SECTOR_BITS))))
	      {
		handle = c->handle;
		break;
	      }
	  }

	free_devices (devices);

	if (handle != 0)
	  return handle;
      }
      break;

    default:
      break;
    }

  return 0;
}

#define NEEDED_BUFLEN sizeof ("XdXXXXXXXXXX")
static inline int
get_diskname_from_path_real (const VasEBoot_efi_device_path_t *path,
			     struct VasEBoot_efidisk_data *head,
			     char *buf)
{
  int count = 0;
  struct VasEBoot_efidisk_data *d;
  for (d = head, count = 0; d; d = d->next, count++)
    if (VasEBoot_efi_compare_device_paths (d->device_path, path) == 0)
      {
	VasEBoot_snprintf (buf, NEEDED_BUFLEN - 1, "d%d", count);
	return 1;
      }
  return 0;
}

static inline int
get_diskname_from_path (const VasEBoot_efi_device_path_t *path,
			char *buf)
{
  if (get_diskname_from_path_real (path, hd_devices, buf + 1))
    {
      buf[0] = 'h';
      return 1;
    }

  if (get_diskname_from_path_real (path, fd_devices, buf + 1))
    {
      buf[0] = 'f';
      return 1;
    }

  if (get_diskname_from_path_real (path, cd_devices, buf + 1))
    {
      buf[0] = 'c';
      return 1;
    }
  return 0;
}

/* Context for VasEBoot_efidisk_get_device_name.  */
struct VasEBoot_efidisk_get_device_name_ctx
{
  char *partition_name;
  VasEBoot_efi_hard_drive_device_path_t *hd;
};

/* Helper for VasEBoot_efidisk_get_device_name.
   Find the identical partition.  */
static int
VasEBoot_efidisk_get_device_name_iter (VasEBoot_disk_t disk,
				   const VasEBoot_partition_t part, void *data)
{
  struct VasEBoot_efidisk_get_device_name_ctx *ctx = data;

  if (VasEBoot_partition_get_start (part)
      == (ctx->hd->partition_start << (disk->log_sector_size
				       - VAS_EBOOT_DISK_SECTOR_BITS))
      && VasEBoot_partition_get_len (part)
      == (ctx->hd->partition_size << (disk->log_sector_size
				      - VAS_EBOOT_DISK_SECTOR_BITS)))
    {
      ctx->partition_name = VasEBoot_partition_get_name (part);
      return 1;
    }

  return 0;
}

char *
VasEBoot_efidisk_get_device_name (VasEBoot_efi_handle_t *handle)
{
  VasEBoot_efi_device_path_t *dp, *ldp;
  char device_name[NEEDED_BUFLEN];

  dp = VasEBoot_efi_get_device_path (handle);
  if (! dp)
    return 0;

  ldp = VasEBoot_efi_find_last_device_path (dp);
  if (! ldp)
    return 0;

  if (VAS_EBOOT_EFI_DEVICE_PATH_TYPE (ldp) == VAS_EBOOT_EFI_MEDIA_DEVICE_PATH_TYPE
      && (VAS_EBOOT_EFI_DEVICE_PATH_SUBTYPE (ldp) == VAS_EBOOT_EFI_CDROM_DEVICE_PATH_SUBTYPE
	  || VAS_EBOOT_EFI_DEVICE_PATH_SUBTYPE (ldp) == VAS_EBOOT_EFI_HARD_DRIVE_DEVICE_PATH_SUBTYPE))
    {
      struct VasEBoot_efidisk_get_device_name_ctx ctx;
      char *dev_name;
      VasEBoot_efi_device_path_t *dup_dp;
      VasEBoot_disk_t parent = 0;

      /* It is necessary to duplicate the device path so that VAS_EBOOT
	 can overwrite it.  */
      dup_dp = VasEBoot_efi_duplicate_device_path (dp);
      if (! dup_dp)
	return 0;

      while (1)
	{
	  VasEBoot_efi_device_path_t *dup_ldp;
	  dup_ldp = VasEBoot_efi_find_last_device_path (dup_dp);
	  if (! dup_ldp)
	    break;

	  if (!(VAS_EBOOT_EFI_DEVICE_PATH_TYPE (dup_ldp) == VAS_EBOOT_EFI_MEDIA_DEVICE_PATH_TYPE
		&& (VAS_EBOOT_EFI_DEVICE_PATH_SUBTYPE (dup_ldp) == VAS_EBOOT_EFI_CDROM_DEVICE_PATH_SUBTYPE
		    || VAS_EBOOT_EFI_DEVICE_PATH_SUBTYPE (dup_ldp) == VAS_EBOOT_EFI_HARD_DRIVE_DEVICE_PATH_SUBTYPE)))
	    break;

	  dup_ldp->type = VAS_EBOOT_EFI_END_DEVICE_PATH_TYPE;
	  dup_ldp->subtype = VAS_EBOOT_EFI_END_ENTIRE_DEVICE_PATH_SUBTYPE;
	  dup_ldp->length = sizeof (*dup_ldp);
	}

      if (!get_diskname_from_path (dup_dp, device_name))
	{
	  VasEBoot_free (dup_dp);
	  return 0;
	}

      parent = VasEBoot_disk_open (device_name);
      VasEBoot_free (dup_dp);

      if (! parent)
	return 0;

      /* Find a partition which matches the hard drive device path.  */
      ctx.partition_name = NULL;
      ctx.hd = (VasEBoot_efi_hard_drive_device_path_t *) ldp;
      if (ctx.hd->partition_start == 0
	  && (ctx.hd->partition_size << (parent->log_sector_size
					 - VAS_EBOOT_DISK_SECTOR_BITS))
	  == VasEBoot_disk_native_sectors (parent))
	{
	  dev_name = VasEBoot_strdup (parent->name);
	}
      else
	{
	  VasEBoot_partition_iterate (parent, VasEBoot_efidisk_get_device_name_iter,
				  &ctx);

	  if (! ctx.partition_name)
	    {
	      /* No partition found. In most cases partition is embed in
		 the root path anyway, so this is not critical.
		 This happens only if partition is on partmap that VAS_EBOOT
		 doesn't need to access root.
	       */
	      VasEBoot_disk_close (parent);
	      return VasEBoot_strdup (device_name);
	    }

	  dev_name = VasEBoot_xasprintf ("%s,%s", parent->name,
				     ctx.partition_name);
	  VasEBoot_free (ctx.partition_name);
	}
      VasEBoot_disk_close (parent);

      return dev_name;
    }
  /* This may be guessed device - floppy, cdrom or entire disk.  */
  if (!get_diskname_from_path (dp, device_name))
    return 0;
  return VasEBoot_strdup (device_name);
}