2003-01-02 20:12:33 +00:00
|
|
|
/* biosdisk.c - emulate biosdisk */
|
|
|
|
/*
|
|
|
|
* PUPA -- Preliminary Universal Programming Architecture for GRUB
|
|
|
|
* Copyright (C) 1999,2000,2001,2002 Free Software Foundation, Inc.
|
|
|
|
* Copyright (C) 2002 Yoshinori K. Okuji <okuji@enbug.org>
|
2003-10-29 18:44:30 +00:00
|
|
|
* Copyright (C) 2003 Marco Gerards <metgerards@student.han.nl>
|
2003-01-02 20:12:33 +00:00
|
|
|
*
|
|
|
|
* PUPA 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 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program 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 PUPA; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <pupa/machine/biosdisk.h>
|
|
|
|
#include <pupa/disk.h>
|
|
|
|
#include <pupa/machine/partition.h>
|
|
|
|
#include <pupa/types.h>
|
|
|
|
#include <pupa/err.h>
|
|
|
|
#include <pupa/util/misc.h>
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <assert.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <limits.h>
|
|
|
|
|
|
|
|
#ifdef __linux__
|
|
|
|
# include <sys/ioctl.h> /* ioctl */
|
|
|
|
# if !defined(__GLIBC__) || \
|
|
|
|
((__GLIBC__ < 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ < 1)))
|
|
|
|
/* Maybe libc doesn't have large file support. */
|
|
|
|
# include <linux/unistd.h> /* _llseek */
|
|
|
|
# endif /* (GLIBC < 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR < 1)) */
|
|
|
|
# ifndef BLKFLSBUF
|
|
|
|
# define BLKFLSBUF _IO (0x12,97) /* flush buffer cache */
|
|
|
|
# endif /* ! BLKFLSBUF */
|
|
|
|
# include <sys/ioctl.h> /* ioctl */
|
|
|
|
# ifndef HDIO_GETGEO
|
|
|
|
# define HDIO_GETGEO 0x0301 /* get device geometry */
|
|
|
|
/* If HDIO_GETGEO is not defined, it is unlikely that hd_geometry is
|
|
|
|
defined. */
|
|
|
|
struct hd_geometry
|
|
|
|
{
|
|
|
|
unsigned char heads;
|
|
|
|
unsigned char sectors;
|
|
|
|
unsigned short cylinders;
|
|
|
|
unsigned long start;
|
|
|
|
};
|
|
|
|
# endif /* ! HDIO_GETGEO */
|
2003-01-02 23:46:21 +00:00
|
|
|
# ifndef BLKGETSIZE
|
|
|
|
# define BLKGETSIZE _IO(0x12,96) /* return device size */
|
|
|
|
# endif /* ! BLKGETSIZE */
|
2003-01-02 20:12:33 +00:00
|
|
|
# ifndef MAJOR
|
|
|
|
# ifndef MINORBITS
|
|
|
|
# define MINORBITS 8
|
|
|
|
# endif /* ! MINORBITS */
|
|
|
|
# define MAJOR(dev) ((unsigned) ((dev) >> MINORBITS))
|
|
|
|
# endif /* ! MAJOR */
|
|
|
|
# ifndef FLOPPY_MAJOR
|
|
|
|
# define FLOPPY_MAJOR 2
|
|
|
|
# endif /* ! FLOPPY_MAJOR */
|
|
|
|
# ifndef LOOP_MAJOR
|
|
|
|
# define LOOP_MAJOR 7
|
|
|
|
# endif /* ! LOOP_MAJOR */
|
|
|
|
#endif /* __linux__ */
|
|
|
|
|
|
|
|
static char *map[256];
|
|
|
|
|
|
|
|
#ifdef __linux__
|
|
|
|
/* Check if we have devfs support. */
|
|
|
|
static int
|
|
|
|
have_devfs (void)
|
|
|
|
{
|
|
|
|
static int dev_devfsd_exists = -1;
|
|
|
|
|
|
|
|
if (dev_devfsd_exists < 0)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
dev_devfsd_exists = stat ("/dev/.devfsd", &st) == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return dev_devfsd_exists;
|
|
|
|
}
|
|
|
|
#endif /* __linux__ */
|
|
|
|
|
|
|
|
static int
|
|
|
|
get_drive (const char *name)
|
|
|
|
{
|
|
|
|
unsigned long drive;
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
if ((name[0] != 'f' && name[0] != 'h') || name[1] != 'd')
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
drive = strtoul (name + 2, &p, 10);
|
|
|
|
if (p == name + 2)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
if (name[0] == 'h')
|
|
|
|
drive += 0x80;
|
|
|
|
|
|
|
|
if (drive > sizeof (map) / sizeof (map[0]))
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
return (int) drive;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
pupa_error (PUPA_ERR_UNKNOWN_DEVICE, "not a biosdisk");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
call_hook (int (*hook) (const char *name), int drive)
|
|
|
|
{
|
|
|
|
char name[10];
|
|
|
|
|
|
|
|
sprintf (name, (drive & 0x80) ? "hd%d" : "fd%d", drive & (~0x80));
|
|
|
|
return hook (name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
pupa_util_biosdisk_iterate (int (*hook) (const char *name))
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
for (i = 0; i < sizeof (map) / sizeof (map[0]); i++)
|
|
|
|
if (map[i] && call_hook (hook, i))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static pupa_err_t
|
|
|
|
pupa_util_biosdisk_open (const char *name, pupa_disk_t disk)
|
|
|
|
{
|
|
|
|
int drive;
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
drive = get_drive (name);
|
|
|
|
if (drive < 0)
|
|
|
|
return pupa_errno;
|
|
|
|
|
|
|
|
if (! map[drive])
|
|
|
|
return pupa_error (PUPA_ERR_BAD_DEVICE,
|
|
|
|
"no mapping exists for `%s'", name);
|
|
|
|
|
|
|
|
disk->has_partitions = (drive & 0x80);
|
|
|
|
disk->id = drive;
|
|
|
|
|
|
|
|
/* Get the size. */
|
2003-01-02 23:46:21 +00:00
|
|
|
#ifdef __linux__
|
|
|
|
{
|
|
|
|
unsigned long nr;
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
fd = open (map[drive], O_RDONLY);
|
|
|
|
if (! fd)
|
|
|
|
return pupa_error (PUPA_ERR_BAD_DEVICE, "cannot open `%s'", map[drive]);
|
|
|
|
|
2003-01-07 07:54:07 +00:00
|
|
|
if (fstat (fd, &st) < 0 || ! S_ISBLK (st.st_mode))
|
|
|
|
{
|
|
|
|
close (fd);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2003-01-02 23:46:21 +00:00
|
|
|
if (ioctl (fd, BLKGETSIZE, &nr))
|
|
|
|
{
|
|
|
|
close (fd);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
close (fd);
|
|
|
|
disk->total_sectors = nr;
|
|
|
|
|
|
|
|
pupa_util_info ("the size of %s is %lu", name, disk->total_sectors);
|
|
|
|
|
|
|
|
return PUPA_ERR_NONE;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
# warning "No special routine to get the size of a block device is implemented for your OS. This is not possibly fatal."
|
|
|
|
#endif
|
|
|
|
|
|
|
|
fail:
|
|
|
|
if (stat (map[drive], &st) < 0)
|
2003-01-02 20:12:33 +00:00
|
|
|
return pupa_error (PUPA_ERR_BAD_DEVICE, "cannot stat `%s'", map[drive]);
|
|
|
|
|
2003-01-07 07:54:07 +00:00
|
|
|
disk->total_sectors = st.st_size >> PUPA_DISK_SECTOR_BITS;
|
2003-01-02 20:12:33 +00:00
|
|
|
|
2003-01-02 23:46:21 +00:00
|
|
|
pupa_util_info ("the size of %s is %lu", name, disk->total_sectors);
|
|
|
|
|
2003-01-02 20:12:33 +00:00
|
|
|
return PUPA_ERR_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef __linux__
|
|
|
|
static int
|
|
|
|
linux_find_partition (char *dev, unsigned long sector)
|
|
|
|
{
|
|
|
|
size_t len = strlen (dev);
|
|
|
|
const char *format;
|
|
|
|
char *p;
|
|
|
|
int i;
|
2003-01-02 23:46:21 +00:00
|
|
|
char *real_dev;
|
|
|
|
|
|
|
|
real_dev = xstrdup (dev);
|
2003-01-02 20:12:33 +00:00
|
|
|
|
2003-01-02 23:46:21 +00:00
|
|
|
if (have_devfs () && strcmp (real_dev + len - 5, "/disc") == 0)
|
2003-01-02 20:12:33 +00:00
|
|
|
{
|
2003-01-02 23:46:21 +00:00
|
|
|
p = real_dev + len - 4;
|
2003-01-02 20:12:33 +00:00
|
|
|
format = "part%d";
|
|
|
|
}
|
2003-01-02 23:46:21 +00:00
|
|
|
else if ((strncmp (real_dev + 5, "hd", 2) == 0
|
|
|
|
|| strncmp (real_dev + 5, "sd", 2) == 0)
|
|
|
|
&& real_dev[7] >= 'a' && real_dev[7] <= 'z')
|
2003-01-02 20:12:33 +00:00
|
|
|
{
|
2003-01-02 23:46:21 +00:00
|
|
|
p = real_dev + 8;
|
2003-01-02 20:12:33 +00:00
|
|
|
format = "%d";
|
|
|
|
}
|
2003-01-02 23:46:21 +00:00
|
|
|
else if (strncmp (real_dev + 5, "rd/c", 4) == 0)
|
2003-01-02 20:12:33 +00:00
|
|
|
{
|
2003-01-02 23:46:21 +00:00
|
|
|
p = strchr (real_dev + 9, 'd');
|
2003-01-02 20:12:33 +00:00
|
|
|
if (! p)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
p++;
|
|
|
|
while (*p && isdigit (*p))
|
|
|
|
p++;
|
|
|
|
|
|
|
|
format = "p%d";
|
|
|
|
}
|
|
|
|
else
|
2003-01-02 23:46:21 +00:00
|
|
|
{
|
|
|
|
free (real_dev);
|
|
|
|
return 0;
|
|
|
|
}
|
2003-01-02 20:12:33 +00:00
|
|
|
|
2003-01-02 23:46:21 +00:00
|
|
|
for (i = 1; i < 10000; i++)
|
2003-01-02 20:12:33 +00:00
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
struct hd_geometry hdg;
|
|
|
|
|
|
|
|
sprintf (p, format, i);
|
2003-01-02 23:46:21 +00:00
|
|
|
fd = open (real_dev, O_RDONLY);
|
2003-01-02 20:12:33 +00:00
|
|
|
if (! fd)
|
2003-01-02 23:46:21 +00:00
|
|
|
{
|
|
|
|
free (real_dev);
|
|
|
|
return 0;
|
|
|
|
}
|
2003-01-02 20:12:33 +00:00
|
|
|
|
|
|
|
if (ioctl (fd, HDIO_GETGEO, &hdg))
|
|
|
|
{
|
|
|
|
close (fd);
|
2003-01-02 23:46:21 +00:00
|
|
|
free (real_dev);
|
2003-01-02 20:12:33 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
close (fd);
|
|
|
|
|
|
|
|
if (hdg.start == sector)
|
2003-01-02 23:46:21 +00:00
|
|
|
{
|
|
|
|
strcpy (dev, real_dev);
|
|
|
|
free (real_dev);
|
|
|
|
return 1;
|
|
|
|
}
|
2003-01-02 20:12:33 +00:00
|
|
|
}
|
|
|
|
|
2003-01-02 23:46:21 +00:00
|
|
|
free (real_dev);
|
2003-01-02 20:12:33 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif /* __linux__ */
|
|
|
|
|
|
|
|
static int
|
|
|
|
open_device (const pupa_disk_t disk, unsigned long sector, int flags)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
#ifdef O_LARGEFILE
|
|
|
|
flags |= O_LARGEFILE;
|
|
|
|
#endif
|
|
|
|
#ifdef O_SYNC
|
|
|
|
flags |= O_SYNC;
|
|
|
|
#endif
|
|
|
|
#ifdef O_FSYNC
|
|
|
|
flags |= O_FSYNC;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef __linux__
|
|
|
|
/* Linux has a bug that the disk cache for a whole disk is not consistent
|
|
|
|
with the one for a partition of the disk. */
|
|
|
|
{
|
|
|
|
int is_partition = 0;
|
|
|
|
char dev[PATH_MAX];
|
|
|
|
|
|
|
|
strcpy (dev, map[disk->id]);
|
|
|
|
if (disk->partition && strncmp (map[disk->id], "/dev/", 5) == 0)
|
|
|
|
is_partition = linux_find_partition (dev, disk->partition->start);
|
|
|
|
|
|
|
|
/* Open the partition. */
|
2003-01-02 23:46:21 +00:00
|
|
|
pupa_util_info ("opening the device `%s'", dev);
|
2003-01-02 20:12:33 +00:00
|
|
|
fd = open (dev, flags);
|
|
|
|
if (fd < 0)
|
|
|
|
{
|
|
|
|
pupa_error (PUPA_ERR_BAD_DEVICE, "cannot open `%s'", dev);
|
|
|
|
return -1;
|
|
|
|
}
|
2003-01-02 23:46:21 +00:00
|
|
|
|
|
|
|
/* Make the buffer cache consistent with the physical disk. */
|
|
|
|
ioctl (fd, BLKFLSBUF, 0);
|
2003-01-02 20:12:33 +00:00
|
|
|
|
|
|
|
if (is_partition)
|
|
|
|
sector -= disk->partition->start;
|
|
|
|
}
|
|
|
|
#else /* ! __linux__ */
|
|
|
|
fd = open (map[disk->id], flags);
|
|
|
|
if (! fd)
|
|
|
|
{
|
|
|
|
pupa_error (PUPA_ERR_BAD_DEVICE, "cannot open `%s'", map[disk->id]);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
#endif /* ! __linux__ */
|
|
|
|
|
|
|
|
#if defined(__linux__) && (!defined(__GLIBC__) || \
|
|
|
|
((__GLIBC__ < 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ < 1))))
|
|
|
|
/* Maybe libc doesn't have large file support. */
|
|
|
|
{
|
|
|
|
loff_t offset, result;
|
|
|
|
static int _llseek (uint filedes, ulong hi, ulong lo,
|
|
|
|
loff_t *res, uint wh);
|
|
|
|
_syscall5 (int, _llseek, uint, filedes, ulong, hi, ulong, lo,
|
|
|
|
loff_t *, res, uint, wh);
|
|
|
|
|
|
|
|
offset = (loff_t) sector << PUPA_DISK_SECTOR_BITS;
|
|
|
|
if (_llseek (fd, offset >> 32, offset & 0xffffffff, &result, SEEK_SET))
|
|
|
|
{
|
|
|
|
pupa_error (PUPA_ERR_BAD_DEVICE, "cannot seek `%s'", map[disk->id]);
|
|
|
|
close (fd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
{
|
|
|
|
off_t offset = (off_t) sector << PUPA_DISK_SECTOR_BITS;
|
|
|
|
|
|
|
|
if (lseek (fd, offset, SEEK_SET) != offset)
|
|
|
|
{
|
|
|
|
pupa_error (PUPA_ERR_BAD_DEVICE, "cannot seek `%s'", map[disk->id]);
|
|
|
|
close (fd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Read LEN bytes from FD in BUF. Return less than or equal to zero if an
|
|
|
|
error occurs, otherwise return LEN. */
|
|
|
|
static ssize_t
|
|
|
|
nread (int fd, char *buf, size_t len)
|
|
|
|
{
|
|
|
|
ssize_t size = len;
|
|
|
|
|
|
|
|
while (len)
|
|
|
|
{
|
|
|
|
ssize_t ret = read (fd, buf, len);
|
|
|
|
|
|
|
|
if (ret <= 0)
|
|
|
|
{
|
|
|
|
if (errno == EINTR)
|
|
|
|
continue;
|
|
|
|
else
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
len -= ret;
|
|
|
|
buf += ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Write LEN bytes from BUF to FD. Return less than or equal to zero if an
|
|
|
|
error occurs, otherwise return LEN. */
|
|
|
|
static ssize_t
|
|
|
|
nwrite (int fd, const char *buf, size_t len)
|
|
|
|
{
|
|
|
|
ssize_t size = len;
|
|
|
|
|
|
|
|
while (len)
|
|
|
|
{
|
|
|
|
ssize_t ret = write (fd, buf, len);
|
|
|
|
|
|
|
|
if (ret <= 0)
|
|
|
|
{
|
|
|
|
if (errno == EINTR)
|
|
|
|
continue;
|
|
|
|
else
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
len -= ret;
|
|
|
|
buf += ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
|
|
|
static pupa_err_t
|
|
|
|
pupa_util_biosdisk_read (pupa_disk_t disk, unsigned long sector,
|
|
|
|
unsigned long size, char *buf)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
fd = open_device (disk, sector, O_RDONLY);
|
|
|
|
if (fd < 0)
|
|
|
|
return pupa_errno;
|
|
|
|
|
|
|
|
#ifdef __linux__
|
|
|
|
if (sector == 0 && size > 1)
|
|
|
|
{
|
|
|
|
/* Work around a bug in linux's ez remapping. Linux remaps all
|
|
|
|
sectors that are read together with the MBR in one read. It
|
|
|
|
should only remap the MBR, so we split the read in two
|
|
|
|
parts. -jochen */
|
|
|
|
if (nread (fd, buf, PUPA_DISK_SECTOR_SIZE) != PUPA_DISK_SECTOR_SIZE)
|
|
|
|
{
|
|
|
|
pupa_error (PUPA_ERR_READ_ERROR, "cannot read `%s'", map[disk->id]);
|
|
|
|
close (fd);
|
|
|
|
return pupa_errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
buf += PUPA_DISK_SECTOR_SIZE;
|
|
|
|
size--;
|
|
|
|
}
|
|
|
|
#endif /* __linux__ */
|
|
|
|
|
|
|
|
if (nread (fd, buf, size << PUPA_DISK_SECTOR_BITS)
|
|
|
|
!= (ssize_t) (size << PUPA_DISK_SECTOR_BITS))
|
|
|
|
pupa_error (PUPA_ERR_READ_ERROR, "cannot read from `%s'", map[disk->id]);
|
|
|
|
|
|
|
|
close (fd);
|
|
|
|
return pupa_errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
static pupa_err_t
|
|
|
|
pupa_util_biosdisk_write (pupa_disk_t disk, unsigned long sector,
|
|
|
|
unsigned long size, const char *buf)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
fd = open_device (disk, sector, O_WRONLY);
|
|
|
|
if (fd < 0)
|
|
|
|
return pupa_errno;
|
|
|
|
|
|
|
|
if (nwrite (fd, buf, size << PUPA_DISK_SECTOR_BITS)
|
|
|
|
!= (ssize_t) (size << PUPA_DISK_SECTOR_BITS))
|
|
|
|
pupa_error (PUPA_ERR_WRITE_ERROR, "cannot write to `%s'", map[disk->id]);
|
|
|
|
|
|
|
|
close (fd);
|
|
|
|
return pupa_errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct pupa_disk_dev pupa_util_biosdisk_dev =
|
|
|
|
{
|
|
|
|
.name = "biosdisk",
|
|
|
|
.iterate = pupa_util_biosdisk_iterate,
|
|
|
|
.open = pupa_util_biosdisk_open,
|
|
|
|
.close = 0,
|
|
|
|
.read = pupa_util_biosdisk_read,
|
|
|
|
.write = pupa_util_biosdisk_write,
|
|
|
|
.next = 0
|
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
|
|
|
read_device_map (const char *dev_map)
|
|
|
|
{
|
|
|
|
FILE *fp;
|
|
|
|
char buf[1024]; /* XXX */
|
|
|
|
int lineno = 0;
|
|
|
|
auto void show_error (const char *msg);
|
|
|
|
|
|
|
|
void show_error (const char *msg)
|
|
|
|
{
|
|
|
|
pupa_util_error ("%s:%d: %s", dev_map, lineno, msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
fp = fopen (dev_map, "r");
|
|
|
|
if (! fp)
|
|
|
|
pupa_util_error ("Cannot open `%s'", dev_map);
|
|
|
|
|
|
|
|
while (fgets (buf, sizeof (buf), fp))
|
|
|
|
{
|
|
|
|
char *p = buf;
|
|
|
|
char *e;
|
|
|
|
int drive;
|
|
|
|
|
|
|
|
lineno++;
|
|
|
|
|
|
|
|
/* Skip leading spaces. */
|
|
|
|
while (*p && isspace (*p))
|
|
|
|
p++;
|
|
|
|
|
|
|
|
/* If the first character is `#' or NUL, skip this line. */
|
|
|
|
if (*p == '\0' || *p == '#')
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (*p != '(')
|
|
|
|
show_error ("No open parenthesis found");
|
|
|
|
|
|
|
|
p++;
|
|
|
|
drive = get_drive (p);
|
|
|
|
if (drive < 0 || drive >= (int) (sizeof (map) / sizeof (map[0])))
|
|
|
|
show_error ("Bad device name");
|
|
|
|
|
|
|
|
p = strchr (p, ')');
|
|
|
|
if (! p)
|
|
|
|
show_error ("No close parenthesis found");
|
|
|
|
|
|
|
|
p++;
|
|
|
|
/* Skip leading spaces. */
|
|
|
|
while (*p && isspace (*p))
|
|
|
|
p++;
|
|
|
|
|
|
|
|
if (*p == '\0')
|
|
|
|
show_error ("No filename found");
|
|
|
|
|
|
|
|
/* NUL-terminate the filename. */
|
|
|
|
e = p;
|
|
|
|
while (*e && ! isspace (*e))
|
|
|
|
e++;
|
|
|
|
*e = '\0';
|
|
|
|
|
|
|
|
/* Multiple entries for a given drive is not allowed. */
|
|
|
|
if (map[drive])
|
|
|
|
show_error ("Duplicated entry found");
|
|
|
|
|
|
|
|
#ifdef __linux__
|
|
|
|
/* On Linux, the devfs uses symbolic links horribly, and that
|
|
|
|
confuses the interface very much, so use realpath to expand
|
|
|
|
symbolic links. */
|
|
|
|
map[drive] = xmalloc (PATH_MAX);
|
|
|
|
if (! realpath (p, map[drive]))
|
|
|
|
pupa_util_error ("Cannot get the real path of `%s'", p);
|
|
|
|
#else
|
|
|
|
map[drive] = xstrdup (p);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
fclose (fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
pupa_util_biosdisk_init (const char *dev_map)
|
|
|
|
{
|
|
|
|
read_device_map (dev_map);
|
|
|
|
pupa_disk_dev_register (&pupa_util_biosdisk_dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
pupa_util_biosdisk_fini (void)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
for (i = 0; i < sizeof (map) / sizeof (map[0]); i++)
|
|
|
|
free (map[i]);
|
|
|
|
|
|
|
|
pupa_disk_dev_unregister (&pupa_util_biosdisk_dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
make_device_name (int drive, int dos_part, int bsd_part)
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
p = xmalloc (30);
|
|
|
|
sprintf (p, (drive & 0x80) ? "hd%d" : "fd%d", drive & ~0x80);
|
|
|
|
|
|
|
|
if (dos_part >= 0)
|
|
|
|
sprintf (p + strlen (p), ",%d", dos_part);
|
|
|
|
|
|
|
|
if (bsd_part >= 0)
|
|
|
|
sprintf (p + strlen (p), ",%c", bsd_part + 'a');
|
|
|
|
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
get_os_disk (const char *os_dev)
|
|
|
|
{
|
|
|
|
char *path, *p;
|
|
|
|
|
|
|
|
#if defined(__linux__)
|
|
|
|
path = xmalloc (PATH_MAX);
|
|
|
|
if (! realpath (os_dev, path))
|
|
|
|
return 0;
|
|
|
|
|
2003-01-02 23:46:21 +00:00
|
|
|
if (strncmp ("/dev/", path, 5) == 0)
|
2003-01-02 20:12:33 +00:00
|
|
|
{
|
2003-01-02 23:46:21 +00:00
|
|
|
p = path + 5;
|
2003-01-02 20:12:33 +00:00
|
|
|
|
|
|
|
if (have_devfs ())
|
|
|
|
{
|
|
|
|
/* If this is an IDE disk. */
|
|
|
|
if (strncmp ("/dev/ide/", p, 9) == 0)
|
|
|
|
{
|
|
|
|
p = strstr (p, "part");
|
|
|
|
if (p)
|
|
|
|
strcpy (p, "disc");
|
|
|
|
|
|
|
|
return path;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If this is a SCSI disk. */
|
|
|
|
if (strncmp ("/dev/scsi/", p, 10) == 0)
|
|
|
|
{
|
|
|
|
p = strstr (p, "part");
|
|
|
|
if (p)
|
|
|
|
strcpy (p, "disc");
|
|
|
|
|
|
|
|
return path;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If this is a DAC960 disk. */
|
|
|
|
if (strncmp ("rd/c", p, 4) == 0)
|
|
|
|
{
|
|
|
|
/* /dev/rd/c[0-9]+d[0-9]+(p[0-9]+)? */
|
|
|
|
p = strchr (p, 'p');
|
|
|
|
if (p)
|
|
|
|
*p = '\0';
|
|
|
|
|
|
|
|
return path;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If this is an IDE disk or a SCSI disk. */
|
|
|
|
if ((strncmp ("hd", p, 2) == 0
|
|
|
|
|| strncmp ("sd", p, 2) == 0)
|
|
|
|
&& p[2] >= 'a' && p[2] <= 'z')
|
|
|
|
{
|
|
|
|
/* /dev/[hs]d[a-z][0-9]* */
|
|
|
|
p[3] = '\0';
|
|
|
|
return path;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return path;
|
|
|
|
|
|
|
|
#elif defined(__GNU__)
|
|
|
|
path = xstrdup (os_dev);
|
|
|
|
if (strncmp ("/dev/sd", path, 7) == 0 || strncmp ("/dev/hd", path, 7) == 0)
|
|
|
|
{
|
|
|
|
p = strchr (path, 's');
|
|
|
|
if (p)
|
|
|
|
*p = '\0';
|
|
|
|
}
|
|
|
|
return path;
|
|
|
|
|
|
|
|
#else
|
|
|
|
# warning "The function `get_os_disk' might not work on your OS correctly."
|
|
|
|
return xstrdup (os_dev);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
find_drive (const char *os_dev)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
char *os_disk;
|
|
|
|
|
|
|
|
os_disk = get_os_disk (os_dev);
|
|
|
|
if (! os_disk)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
for (i = 0; i < (int) (sizeof (map) / sizeof (map[0])); i++)
|
|
|
|
if (map[i] && strcmp (map[i], os_disk) == 0)
|
|
|
|
{
|
|
|
|
free (os_disk);
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
free (os_disk);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
char *
|
|
|
|
pupa_util_biosdisk_get_pupa_dev (const char *os_dev)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
int drive;
|
2003-01-02 23:46:21 +00:00
|
|
|
|
|
|
|
if (stat (os_dev, &st) < 0)
|
2003-01-02 20:12:33 +00:00
|
|
|
{
|
|
|
|
pupa_error (PUPA_ERR_BAD_DEVICE, "cannot stat `%s'", os_dev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
drive = find_drive (os_dev);
|
|
|
|
if (drive < 0)
|
|
|
|
{
|
|
|
|
pupa_error (PUPA_ERR_BAD_DEVICE,
|
|
|
|
"no mapping exists for `%s'", os_dev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (! S_ISBLK (st.st_mode))
|
|
|
|
return make_device_name (drive, -1, -1);
|
|
|
|
|
|
|
|
#if defined(__linux__)
|
|
|
|
/* Linux counts partitions uniformly, whether a BSD partition or a DOS
|
|
|
|
partition, so mapping them to PUPA devices is not trivial.
|
|
|
|
Here, get the start sector of a partition by HDIO_GETGEO, and
|
|
|
|
compare it with each partition PUPA recognizes. */
|
|
|
|
{
|
|
|
|
char *name;
|
|
|
|
pupa_disk_t disk;
|
|
|
|
int fd;
|
|
|
|
struct hd_geometry hdg;
|
|
|
|
int dos_part = -1;
|
|
|
|
int bsd_part = -1;
|
|
|
|
auto int find_partition (const pupa_partition_t partition);
|
|
|
|
|
|
|
|
int find_partition (const pupa_partition_t partition)
|
|
|
|
{
|
2003-01-02 23:46:21 +00:00
|
|
|
if (partition->bsd_part < 0)
|
|
|
|
pupa_util_info ("DOS partition %d starts from %lu",
|
|
|
|
partition->dos_part, partition->start);
|
|
|
|
else
|
|
|
|
pupa_util_info ("BSD partition %d,%c starts from %lu",
|
|
|
|
partition->dos_part, partition->bsd_part + 'a',
|
|
|
|
partition->start);
|
|
|
|
|
2003-01-02 20:12:33 +00:00
|
|
|
if (hdg.start == partition->start)
|
|
|
|
{
|
|
|
|
dos_part = partition->dos_part;
|
|
|
|
bsd_part = partition->bsd_part;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
name = make_device_name (drive, -1, -1);
|
|
|
|
|
|
|
|
if (MAJOR (st.st_rdev) == FLOPPY_MAJOR)
|
|
|
|
return name;
|
|
|
|
|
|
|
|
fd = open (os_dev, O_RDONLY);
|
|
|
|
if (! fd)
|
|
|
|
{
|
|
|
|
pupa_error (PUPA_ERR_BAD_DEVICE, "cannot open `%s'", os_dev);
|
|
|
|
free (name);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ioctl (fd, HDIO_GETGEO, &hdg))
|
|
|
|
{
|
|
|
|
pupa_error (PUPA_ERR_BAD_DEVICE,
|
|
|
|
"cannot get geometry of `%s'", os_dev);
|
|
|
|
close (fd);
|
|
|
|
free (name);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
close (fd);
|
2003-01-02 23:46:21 +00:00
|
|
|
|
|
|
|
pupa_util_info ("%s starts from %lu", os_dev, hdg.start);
|
2003-01-02 20:12:33 +00:00
|
|
|
|
|
|
|
if (hdg.start == 0)
|
|
|
|
return name;
|
2003-01-02 23:46:21 +00:00
|
|
|
|
|
|
|
pupa_util_info ("opening the device %s", name);
|
2003-01-02 20:12:33 +00:00
|
|
|
disk = pupa_disk_open (name);
|
|
|
|
free (name);
|
|
|
|
|
|
|
|
if (! disk)
|
|
|
|
return 0;
|
|
|
|
|
2003-01-02 23:46:21 +00:00
|
|
|
if (pupa_partition_iterate (disk, find_partition) != PUPA_ERR_NONE)
|
|
|
|
{
|
|
|
|
pupa_disk_close (disk);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2003-01-02 20:12:33 +00:00
|
|
|
if (dos_part < 0)
|
|
|
|
{
|
|
|
|
pupa_disk_close (disk);
|
|
|
|
pupa_error (PUPA_ERR_BAD_DEVICE,
|
|
|
|
"cannot find the partition of `%s'", os_dev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return make_device_name (drive, dos_part, bsd_part);
|
|
|
|
}
|
|
|
|
|
|
|
|
#elif defined(__GNU__)
|
|
|
|
/* GNU uses "/dev/[hs]d[0-9]+(s[0-9]+[a-z]?)?". */
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
int dos_part = -1;
|
|
|
|
int bsd_part = -1;
|
|
|
|
|
|
|
|
p = strrchr (os_dev, 's');
|
|
|
|
if (p)
|
|
|
|
{
|
|
|
|
unsigned long n;
|
|
|
|
char *q;
|
|
|
|
|
|
|
|
p++;
|
|
|
|
n = strtoul (p, &q, 10);
|
|
|
|
if (p != q && n != LONG_MIN && n != LONG_MAX)
|
|
|
|
{
|
|
|
|
dos_part = (int) n;
|
|
|
|
|
|
|
|
if (*q >= 'a' && *q <= 'g')
|
|
|
|
bsd_part = *q - 'a';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return make_device_name (drive, dos_part, bsd_part);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
# warning "The function `pupa_util_biosdisk_get_pupa_dev' might not work on your OS correctly."
|
|
|
|
return make_device_name (drive, -1, -1);
|
|
|
|
#endif
|
|
|
|
}
|