grub_util_fd_t
grub_util_fd_open_device (const grub_disk_t disk, grub_disk_addr_t sector, int flags,
grub_disk_addr_t *max)
{
grub_util_fd_t fd;
struct grub_util_hostdisk_data *data = disk->data;
*max = ~0ULL;
flags |= GRUB_UTIL_FD_O_SYNC;
if (data->dev && strcmp (data->dev, map[disk->id].device) == 0 &&
data->access_mode == (flags & O_ACCMODE))
{
grub_dprintf ("hostdisk", "reusing open device `%s'\n", data->dev);
fd = data->fd;
}
else
{
free (data->dev);
data->dev = 0;
if (GRUB_UTIL_FD_IS_VALID(data->fd))
{
if (data->access_mode == O_RDWR || data->access_mode == O_WRONLY)
grub_util_fd_sync (data->fd);
grub_util_fd_close (data->fd);
data->fd = GRUB_UTIL_FD_INVALID;
}
fd = grub_util_fd_open (map[disk->id].device, flags);
if (GRUB_UTIL_FD_IS_VALID(fd))
{
data->dev = xstrdup (map[disk->id].device);
data->access_mode = (flags & O_ACCMODE);
data->fd = fd;
}
}
if (!GRUB_UTIL_FD_IS_VALID(data->fd))
{
grub_error (GRUB_ERR_BAD_DEVICE, N_("cannot open `%s': %s"),
map[disk->id].device, grub_util_fd_strerror ());
return GRUB_UTIL_FD_INVALID;
}
if (grub_util_fd_seek (fd, sector << disk->log_sector_size))
{
grub_util_fd_close (fd);
grub_error (GRUB_ERR_BAD_DEVICE, N_("cannot seek `%s': %s"),
map[disk->id].device, grub_util_fd_strerror ());
return GRUB_UTIL_FD_INVALID;
}
return fd;
}
static grub_err_t
grub_util_biosdisk_write (grub_disk_t disk, grub_disk_addr_t sector,
grub_size_t size, const char *buf)
{
while (size)
{
grub_util_fd_t fd;
grub_disk_addr_t max = ~0ULL;
fd = grub_util_fd_open_device (disk, sector, GRUB_UTIL_FD_O_WRONLY, &max);
if (!GRUB_UTIL_FD_IS_VALID (fd))
return grub_errno;
#ifdef __linux__
if (sector == 0)
/* Work around a bug in Linux ez remapping. Linux remaps all
sectors that are write together with the MBR in one write. It
should only remap the MBR, so we split the write in two
parts. -jochen */
max = 1;
#endif /* __linux__ */
if (max > size)
max = size;
if (grub_util_fd_write (fd, buf, max << disk->log_sector_size)
!= (ssize_t) (max << disk->log_sector_size))
return grub_error (GRUB_ERR_WRITE_ERROR, N_("cannot write to `%s': %s"),
map[disk->id].device, grub_util_fd_strerror ());
size -= max;
buf += (max << disk->log_sector_size);
}
return GRUB_ERR_NONE;
}
static grub_err_t
grub_hostfs_dir (grub_device_t device, const char *path,
grub_fs_dir_hook_t hook, void *hook_data)
{
grub_util_fd_dir_t dir;
/* Check if the disk is our dummy disk. */
if (grub_strcmp (device->disk->name, "host"))
return grub_error (GRUB_ERR_BAD_FS, "not a hostfs");
dir = grub_util_fd_opendir (path);
if (! dir)
return grub_error (GRUB_ERR_BAD_FILENAME,
N_("can't open `%s': %s"), path,
grub_util_fd_strerror ());
while (1)
{
grub_util_fd_dirent_t de;
struct grub_dirhook_info info;
grub_memset (&info, 0, sizeof (info));
de = grub_util_fd_readdir (dir);
if (! de)
break;
info.dir = !! is_dir (path, de->d_name);
hook (de->d_name, &info, hook_data);
}
grub_util_fd_closedir (dir);
return GRUB_ERR_NONE;
}
static grub_err_t
grub_util_biosdisk_open (const char *name, grub_disk_t disk)
{
int drive;
struct grub_util_hostdisk_data *data;
drive = find_grub_drive (name);
grub_util_info ("drive = %d", drive);
if (drive < 0)
return grub_error (GRUB_ERR_UNKNOWN_DEVICE,
"no mapping exists for `%s'", name);
disk->id = drive;
disk->data = data = xmalloc (sizeof (struct grub_util_hostdisk_data));
data->dev = NULL;
data->access_mode = 0;
data->fd = GRUB_UTIL_FD_INVALID;
data->is_disk = 0;
data->device_map = map[drive].device_map;
/* Get the size. */
{
grub_util_fd_t fd;
fd = grub_util_fd_open (map[drive].device, GRUB_UTIL_FD_O_RDONLY);
if (!GRUB_UTIL_FD_IS_VALID(fd))
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("cannot open `%s': %s"),
map[drive].device, grub_util_fd_strerror ());
disk->total_sectors = grub_util_get_fd_size (fd, map[drive].device,
&disk->log_sector_size);
disk->total_sectors >>= disk->log_sector_size;
#if GRUB_UTIL_FD_STAT_IS_FUNCTIONAL
{
struct stat st;
# if GRUB_DISK_DEVS_ARE_CHAR
if (fstat (fd, &st) < 0 || ! S_ISCHR (st.st_mode))
# else
if (fstat (fd, &st) < 0 || ! S_ISBLK (st.st_mode))
# endif
data->is_disk = 1;
}
#endif
grub_util_fd_close (fd);
grub_util_info ("the size of %s is %" PRIuGRUB_UINT64_T,
name, disk->total_sectors);
return GRUB_ERR_NONE;
}
}
static grub_ssize_t
grub_hostfs_read (grub_file_t file, char *buf, grub_size_t len)
{
struct grub_hostfs_data *data;
data = file->data;
if (grub_util_fd_seek (data->f, file->offset) != 0)
{
grub_error (GRUB_ERR_OUT_OF_RANGE, N_("cannot seek `%s': %s"),
data->filename, grub_util_fd_strerror ());
return -1;
}
unsigned int s = grub_util_fd_read (data->f, buf, len);
if (s != len)
grub_error (GRUB_ERR_FILE_READ_ERROR, N_("cannot read `%s': %s"),
data->filename, grub_util_fd_strerror ());
return (signed) s;
}