477 lines
11 KiB
C++
477 lines
11 KiB
C++
/* fhandler_floppy.cc. See fhandler.h for a description of the
|
|
fhandler classes.
|
|
|
|
Copyright 1999, 2000, 2001, 2002, 2003, 2004 Red Hat, Inc.
|
|
|
|
This file is part of Cygwin.
|
|
|
|
This software is a copyrighted work licensed under the terms of the
|
|
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
|
|
details. */
|
|
|
|
#include "winsup.h"
|
|
#include <sys/termios.h>
|
|
#include <unistd.h>
|
|
#include <winioctl.h>
|
|
#include <asm/socket.h>
|
|
#include <cygwin/rdevio.h>
|
|
#include <cygwin/hdreg.h>
|
|
#include <cygwin/fs.h>
|
|
#include "cygerrno.h"
|
|
#include "security.h"
|
|
#include "path.h"
|
|
#include "fhandler.h"
|
|
|
|
#define IS_EOM(err) ((err) == ERROR_INVALID_PARAMETER \
|
|
|| (err) == ERROR_SEEK \
|
|
|| (err) == ERROR_SECTOR_NOT_FOUND)
|
|
|
|
/**********************************************************************/
|
|
/* fhandler_dev_floppy */
|
|
|
|
fhandler_dev_floppy::fhandler_dev_floppy ()
|
|
: fhandler_dev_raw (), status ()
|
|
{
|
|
}
|
|
|
|
int
|
|
fhandler_dev_floppy::get_drive_info (struct hd_geometry *geo)
|
|
{
|
|
char dbuf[256];
|
|
char pbuf[256];
|
|
|
|
DISK_GEOMETRY *di;
|
|
PARTITION_INFORMATION_EX *pix = NULL;
|
|
PARTITION_INFORMATION *pi = NULL;
|
|
DWORD bytes_read = 0;
|
|
|
|
/* Always try using the new EX ioctls first (>= XP). If not available,
|
|
fall back to trying the old non-EX ioctls. */
|
|
if (wincap.has_disk_ex_ioctls () && pc.dev.major != DEV_FLOPPY_MAJOR)
|
|
{
|
|
if (!DeviceIoControl (get_handle (),
|
|
IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, NULL, 0,
|
|
dbuf, 256, &bytes_read, NULL))
|
|
{
|
|
__seterrno ();
|
|
return -1;
|
|
}
|
|
di = &((DISK_GEOMETRY_EX *) dbuf)->Geometry;
|
|
if (DeviceIoControl (get_handle (),
|
|
IOCTL_DISK_GET_PARTITION_INFO_EX, NULL, 0,
|
|
pbuf, 256, &bytes_read, NULL))
|
|
pix = (PARTITION_INFORMATION_EX *) pbuf;
|
|
}
|
|
else
|
|
{
|
|
if (!DeviceIoControl (get_handle (),
|
|
IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0,
|
|
dbuf, 256, &bytes_read, NULL))
|
|
{
|
|
__seterrno ();
|
|
return -1;
|
|
}
|
|
di = (DISK_GEOMETRY *) dbuf;
|
|
if (DeviceIoControl (get_handle (),
|
|
IOCTL_DISK_GET_PARTITION_INFO, NULL, 0,
|
|
pbuf, 256, &bytes_read, NULL))
|
|
pi = (PARTITION_INFORMATION *) pbuf;
|
|
}
|
|
|
|
debug_printf ("disk geometry: (%ld cyl)*(%ld trk)*(%ld sec)*(%ld bps)",
|
|
di->Cylinders.LowPart,
|
|
di->TracksPerCylinder,
|
|
di->SectorsPerTrack,
|
|
di->BytesPerSector);
|
|
bytes_per_sector = di->BytesPerSector;
|
|
if (pix)
|
|
{
|
|
debug_printf ("partition info: offset %D length %D",
|
|
pix->StartingOffset.QuadPart,
|
|
pix->PartitionLength.QuadPart);
|
|
drive_size = pix->PartitionLength.QuadPart;
|
|
}
|
|
else if (pi)
|
|
{
|
|
debug_printf ("partition info: offset %D length %D",
|
|
pi->StartingOffset.QuadPart,
|
|
pi->PartitionLength.QuadPart);
|
|
drive_size = pi->PartitionLength.QuadPart;
|
|
}
|
|
else
|
|
{
|
|
/* Getting the partition size by using the drive geometry information
|
|
looks wrong, but this is a historical necessity. NT4 didn't maintain
|
|
partition information for the whole drive (aka "partition 0"), but
|
|
returned ERROR_INVALID_HANDLE instead. That got fixed in W2K. */
|
|
drive_size = di->Cylinders.QuadPart * di->TracksPerCylinder *
|
|
di->SectorsPerTrack * di->BytesPerSector;
|
|
}
|
|
debug_printf ("drive size: %D", drive_size);
|
|
if (geo)
|
|
{
|
|
geo->heads = di->TracksPerCylinder;
|
|
geo->sectors = di->SectorsPerTrack;
|
|
geo->cylinders = di->Cylinders.LowPart;
|
|
if (pix)
|
|
geo->start = pix->StartingOffset.QuadPart >> 9ULL;
|
|
else if (pi)
|
|
geo->start = pi->StartingOffset.QuadPart >> 9ULL;
|
|
else
|
|
geo->start = 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Wrapper functions for ReadFile and WriteFile to simplify error handling. */
|
|
BOOL
|
|
fhandler_dev_floppy::read_file (void *buf, DWORD to_read, DWORD *read, int *err)
|
|
{
|
|
BOOL ret;
|
|
|
|
*err = 0;
|
|
if (!(ret = ReadFile (get_handle (), buf, to_read, read, 0)))
|
|
*err = GetLastError ();
|
|
syscall_printf ("%d (err %d) = ReadFile (%d, %d, to_read %d, read %d, 0)",
|
|
ret, *err, get_handle (), buf, to_read, *read);
|
|
return ret;
|
|
}
|
|
|
|
BOOL
|
|
fhandler_dev_floppy::write_file (const void *buf, DWORD to_write,
|
|
DWORD *written, int *err)
|
|
{
|
|
BOOL ret;
|
|
|
|
*err = 0;
|
|
if (!(ret = WriteFile (get_handle (), buf, to_write, written, 0)))
|
|
*err = GetLastError ();
|
|
syscall_printf ("%d (err %d) = WriteFile (%d, %d, write %d, written %d, 0)",
|
|
ret, *err, get_handle (), buf, to_write, *written);
|
|
return ret;
|
|
}
|
|
|
|
int
|
|
fhandler_dev_floppy::open (int flags, mode_t)
|
|
{
|
|
/* The correct size of the buffer would be 512 bytes, which is the atomic
|
|
size, supported by WinNT. Unfortunately, the performance is worse than
|
|
access to file system on same device! Setting buffer size to a
|
|
relatively big value increases performance by means. The new ioctl call
|
|
with 'rdevio.h' header file supports changing this value.
|
|
|
|
Let's try to be smart: Let's take a multiple of typical tar and cpio
|
|
buffer sizes by default. */
|
|
devbufsiz = 61440L;
|
|
int ret = fhandler_dev_raw::open (flags);
|
|
|
|
if (ret && get_drive_info (NULL))
|
|
{
|
|
close ();
|
|
return 0;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int
|
|
fhandler_dev_floppy::dup (fhandler_base *child)
|
|
{
|
|
int ret = fhandler_dev_raw::dup (child);
|
|
|
|
if (!ret)
|
|
{
|
|
fhandler_dev_floppy *fhc = (fhandler_dev_floppy *) child;
|
|
|
|
fhc->drive_size = drive_size;
|
|
fhc->bytes_per_sector = bytes_per_sector;
|
|
fhc->eom_detected (eom_detected ());
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
inline _off64_t
|
|
fhandler_dev_floppy::get_current_position ()
|
|
{
|
|
LARGE_INTEGER off = { QuadPart: 0LL };
|
|
off.LowPart = SetFilePointer (get_handle (), 0, &off.HighPart, FILE_CURRENT);
|
|
return off.QuadPart;
|
|
}
|
|
|
|
void
|
|
fhandler_dev_floppy::raw_read (void *ptr, size_t& ulen)
|
|
{
|
|
DWORD bytes_read = 0;
|
|
DWORD read2;
|
|
DWORD bytes_to_read;
|
|
int ret;
|
|
size_t len = ulen;
|
|
char *tgt;
|
|
char *p = (char *) ptr;
|
|
|
|
/* Checking a previous end of media */
|
|
if (eom_detected () && !lastblk_to_read ())
|
|
{
|
|
set_errno (ENOSPC);
|
|
goto err;
|
|
}
|
|
|
|
if (devbuf)
|
|
{
|
|
while (len > 0)
|
|
{
|
|
if (devbufstart < devbufend)
|
|
{
|
|
bytes_to_read = min (len, devbufend - devbufstart);
|
|
debug_printf ("read %d bytes from buffer (rest %d)",
|
|
bytes_to_read,
|
|
devbufend - devbufstart - bytes_to_read);
|
|
memcpy (p, devbuf + devbufstart, bytes_to_read);
|
|
len -= bytes_to_read;
|
|
p += bytes_to_read;
|
|
bytes_read += bytes_to_read;
|
|
devbufstart += bytes_to_read;
|
|
|
|
if (lastblk_to_read ())
|
|
{
|
|
lastblk_to_read (false);
|
|
break;
|
|
}
|
|
}
|
|
if (len > 0)
|
|
{
|
|
if (len >= devbufsiz)
|
|
{
|
|
bytes_to_read = (len / bytes_per_sector) * bytes_per_sector;
|
|
tgt = p;
|
|
}
|
|
else
|
|
{
|
|
tgt = devbuf;
|
|
bytes_to_read = devbufsiz;
|
|
}
|
|
_off64_t current_position = get_current_position ();
|
|
if (current_position + bytes_to_read >= drive_size)
|
|
bytes_to_read = drive_size - current_position;
|
|
if (!bytes_to_read)
|
|
{
|
|
eom_detected (true);
|
|
break;
|
|
}
|
|
|
|
debug_printf ("read %d bytes %s", bytes_to_read,
|
|
len < devbufsiz ? "into buffer" : "directly");
|
|
if (!read_file (tgt, bytes_to_read, &read2, &ret))
|
|
{
|
|
if (!IS_EOM (ret))
|
|
{
|
|
__seterrno ();
|
|
goto err;
|
|
}
|
|
|
|
eom_detected (true);
|
|
|
|
if (!read2)
|
|
{
|
|
if (!bytes_read)
|
|
{
|
|
debug_printf ("return -1, set errno to ENOSPC");
|
|
set_errno (ENOSPC);
|
|
goto err;
|
|
}
|
|
break;
|
|
}
|
|
lastblk_to_read (true);
|
|
}
|
|
if (!read2)
|
|
break;
|
|
if (tgt == devbuf)
|
|
{
|
|
devbufstart = 0;
|
|
devbufend = read2;
|
|
}
|
|
else
|
|
{
|
|
len -= read2;
|
|
p += read2;
|
|
bytes_read += read2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (!read_file (p, len, &bytes_read, &ret))
|
|
{
|
|
if (!IS_EOM (ret))
|
|
{
|
|
__seterrno ();
|
|
goto err;
|
|
}
|
|
if (bytes_read)
|
|
eom_detected (true);
|
|
else
|
|
{
|
|
debug_printf ("return -1, set errno to ENOSPC");
|
|
set_errno (ENOSPC);
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
ulen = (size_t) bytes_read;
|
|
return;
|
|
|
|
err:
|
|
ulen = (size_t) -1;
|
|
}
|
|
|
|
int
|
|
fhandler_dev_floppy::raw_write (const void *ptr, size_t len)
|
|
{
|
|
DWORD bytes_written = 0;
|
|
char *p = (char *) ptr;
|
|
int ret;
|
|
|
|
/* Checking a previous end of media on tape */
|
|
if (eom_detected ())
|
|
{
|
|
set_errno (ENOSPC);
|
|
return -1;
|
|
}
|
|
|
|
/* Invalidate buffer. */
|
|
devbufstart = devbufend = 0;
|
|
|
|
if (len > 0)
|
|
{
|
|
if (!write_file (p, len, &bytes_written, &ret))
|
|
{
|
|
if (!IS_EOM (ret))
|
|
{
|
|
__seterrno ();
|
|
return -1;
|
|
}
|
|
eom_detected (true);
|
|
if (!bytes_written)
|
|
{
|
|
set_errno (ENOSPC);
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
return bytes_written;
|
|
}
|
|
|
|
_off64_t
|
|
fhandler_dev_floppy::lseek (_off64_t offset, int whence)
|
|
{
|
|
char buf[512];
|
|
_off64_t lloffset = offset;
|
|
LARGE_INTEGER sector_aligned_offset;
|
|
_off64_t bytes_left;
|
|
|
|
if (whence == SEEK_END)
|
|
{
|
|
lloffset += drive_size;
|
|
whence = SEEK_SET;
|
|
}
|
|
else if (whence == SEEK_CUR)
|
|
{
|
|
lloffset += get_current_position () - (devbufend - devbufstart);
|
|
whence = SEEK_SET;
|
|
}
|
|
|
|
if (whence != SEEK_SET || lloffset < 0 || lloffset >= drive_size)
|
|
{
|
|
set_errno (EINVAL);
|
|
return -1;
|
|
}
|
|
|
|
sector_aligned_offset.QuadPart = (lloffset / bytes_per_sector)
|
|
* bytes_per_sector;
|
|
bytes_left = lloffset - sector_aligned_offset.QuadPart;
|
|
|
|
/* Invalidate buffer. */
|
|
devbufstart = devbufend = 0;
|
|
|
|
sector_aligned_offset.LowPart =
|
|
SetFilePointer (get_handle (),
|
|
sector_aligned_offset.LowPart,
|
|
§or_aligned_offset.HighPart,
|
|
FILE_BEGIN);
|
|
if (sector_aligned_offset.LowPart == INVALID_SET_FILE_POINTER
|
|
&& GetLastError ())
|
|
{
|
|
__seterrno ();
|
|
return -1;
|
|
}
|
|
|
|
eom_detected (false);
|
|
|
|
if (bytes_left)
|
|
{
|
|
size_t len = bytes_left;
|
|
raw_read (buf, len);
|
|
}
|
|
return sector_aligned_offset.QuadPart + bytes_left;
|
|
}
|
|
|
|
int
|
|
fhandler_dev_floppy::ioctl (unsigned int cmd, void *buf)
|
|
{
|
|
DISK_GEOMETRY di;
|
|
DWORD bytes_read;
|
|
switch (cmd)
|
|
{
|
|
case HDIO_GETGEO:
|
|
{
|
|
debug_printf ("HDIO_GETGEO");
|
|
return get_drive_info ((struct hd_geometry *) buf);
|
|
}
|
|
case BLKGETSIZE:
|
|
case BLKGETSIZE64:
|
|
{
|
|
debug_printf ("BLKGETSIZE");
|
|
if (cmd == BLKGETSIZE)
|
|
*(long *)buf = drive_size >> 9UL;
|
|
else
|
|
*(_off64_t *)buf = drive_size;
|
|
return 0;
|
|
}
|
|
case BLKRRPART:
|
|
{
|
|
debug_printf ("BLKRRPART");
|
|
if (!DeviceIoControl (get_handle (),
|
|
IOCTL_DISK_UPDATE_DRIVE_SIZE,
|
|
NULL, 0,
|
|
&di, sizeof (di),
|
|
&bytes_read, NULL))
|
|
{
|
|
__seterrno ();
|
|
return -1;
|
|
}
|
|
get_drive_info (NULL);
|
|
return 0;
|
|
}
|
|
case BLKSSZGET:
|
|
{
|
|
debug_printf ("BLKSSZGET");
|
|
*(int *)buf = bytes_per_sector;
|
|
return 0;
|
|
}
|
|
case RDSETBLK:
|
|
/* Just check the restriction that blocksize must be a multiple
|
|
of the sector size of the underlying volume sector size,
|
|
then fall through to fhandler_dev_raw::ioctl. */
|
|
struct rdop *op = (struct rdop *) buf;
|
|
if (op->rd_parm % bytes_per_sector)
|
|
{
|
|
SetLastError (ERROR_INVALID_PARAMETER);
|
|
__seterrno ();
|
|
return -1;
|
|
}
|
|
/*FALLTHRUGH*/
|
|
default:
|
|
return fhandler_dev_raw::ioctl (cmd, buf);
|
|
}
|
|
}
|
|
|