JehanneOS
/
newlib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
newlib/winsup/cygwin/fhandler_tape.cc

764 lines
19 KiB
C++
Raw Blame History

/* fhandler_tape.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 <stdlib.h>
#include <sys/mtio.h>
#include <ddk/ntddstor.h>
#include "cygerrno.h"
#include "perprocess.h"
#include "security.h"
#include "path.h"
#include "fhandler.h"
#include "dtable.h"
#include "cygheap.h"
/* Media changes and bus resets are sometimes reported and the function
hasn't been executed. We repeat all functions which return with one
of these error codes. */
/* FIXME: Note that this is wrong! The correct behaviour after getting
an ERROR_BUS_RESET is to raise a flag and then to block any access,
except for MTREW, MTOFFL, MT_RETEN, MTERASE, MTSEEK and MTEOM, and
to set errno to EIO in all other cases. */
#define TAPE_FUNC(func) do { \
lasterr = (func); \
} while (lasterr == ERROR_MEDIA_CHANGED \
|| lasterr == ERROR_BUS_RESET)
/* Convert LARGE_INTEGER into long long */
#define get_ll(pl) (((long long) (pl).HighPart << 32) | (pl).LowPart)
#define IS_EOM(err) ((err) == ERROR_END_OF_MEDIA \
|| (err) == ERROR_EOM_OVERFLOW \
|| (err) == ERROR_NO_DATA_DETECTED)
#define IS_EOF(err) ((err) == ERROR_FILEMARK_DETECTED \
|| (err) == ERROR_SETMARK_DETECTED)
/**********************************************************************/
/* fhandler_dev_tape */
void
fhandler_dev_tape::clear (void)
{
lasterr = 0;
fhandler_dev_raw::clear ();
}
int
fhandler_dev_tape::is_eom (int win_error)
{
int ret = IS_EOM (win_error);
if (ret)
debug_printf ("end of medium");
return ret;
}
int
fhandler_dev_tape::is_eof (int win_error)
{
int ret = IS_EOF (win_error);
if (ret)
debug_printf ("end of file");
return ret;
}
BOOL
fhandler_dev_tape::write_file (const void *buf, DWORD to_write,
DWORD *written, int *err)
{
BOOL ret;
do
{
*err = 0;
if (!(ret = WriteFile (get_handle (), buf, to_write, written, 0)))
*err = GetLastError ();
}
while (*err == ERROR_MEDIA_CHANGED || *err == ERROR_BUS_RESET);
syscall_printf ("%d (err %d) = WriteFile (%d, %d, write %d, written %d, 0)",
ret, *err, get_handle (), buf, to_write, *written);
return ret;
}
BOOL
fhandler_dev_tape::read_file (void *buf, DWORD to_read, DWORD *read, int *err)
{
BOOL ret;
do
{
*err = 0;
if (!(ret = ReadFile (get_handle (), buf, to_read, read, 0)))
*err = GetLastError ();
}
while (*err == ERROR_MEDIA_CHANGED || *err == ERROR_BUS_RESET);
syscall_printf ("%d (err %d) = ReadFile (%d, %d, to_read %d, read %d, 0)",
ret, *err, get_handle (), buf, to_read, *read);
return ret;
}
fhandler_dev_tape::fhandler_dev_tape ()
: fhandler_dev_raw ()
{
debug_printf ("unit: %d", dev ().minor);
}
int
fhandler_dev_tape::open (int flags, mode_t)
{
int ret;
devbufsiz = 1L;
ret = fhandler_dev_raw::open (flags);
if (ret)
{
DWORD varlen;
struct mtget get;
unsigned long block;
TAPE_FUNC (GetTapeParameters (get_handle (), GET_TAPE_DRIVE_INFORMATION,
(varlen = sizeof dp, &varlen), &dp));
if (!tape_status (&get))
{
long blksize = (get.mt_dsreg & MT_ST_BLKSIZE_MASK)
>> MT_ST_BLKSIZE_SHIFT;
/* Tape drive supports and is set to variable block size. */
if (blksize == 0)
devbufsiz = get.mt_maxblksize;
else
devbufsiz = blksize;
varblkop = blksize == 0;
}
if (devbufsiz > 1L)
devbuf = new char [devbufsiz];
/* The following rewind in position 0 solves a problem which appears
* in case of multi volume archives: The last ReadFile on first medium
* returns ERROR_NO_DATA_DETECTED. After media change, all subsequent
* ReadFile calls return ERROR_NO_DATA_DETECTED, too.
* The call to tape_set_pos seems to reset some internal flags. */
if (!tape_get_pos (&block) && !block)
{
debug_printf ("rewinding");
tape_set_pos (TAPE_REWIND, 0);
}
if (flags & O_APPEND)
{
/* In append mode, seek to beginning of next filemark */
tape_set_pos (TAPE_SPACE_FILEMARKS, 1, true);
}
}
return ret;
}
int
fhandler_dev_tape::close (void)
{
struct mtop op;
int ret = 0;
if (is_writing)
{
ret = writebuf ();
if (has_written && !eom_detected)
{
/* if last operation was writing, write a filemark */
debug_printf ("writing filemark");
op.mt_op = MTWEOF;
op.mt_count = 1;
ioctl (MTIOCTOP, &op);
}
}
// To protected reads on signaling (e.g. Ctrl-C)
eof_detected = 1;
if (is_rewind_device ())
{
debug_printf ("rewinding");
tape_set_pos (TAPE_REWIND, 0);
}
if (ret)
{
fhandler_dev_raw::close ();
return ret;
}
return fhandler_dev_raw::close ();
}
int
fhandler_dev_tape::fstat (struct __stat64 *buf)
{
int ret;
if (!(ret = fhandler_base::fstat (buf)))
{
struct mtget get;
if (!ioctl (MTIOCGET, &get))
buf->st_blocks = get.mt_capacity / buf->st_blksize;
}
return ret;
}
_off64_t
fhandler_dev_tape::lseek (_off64_t offset, int whence)
{
struct mtop op;
struct mtpos pos;
debug_printf ("lseek (%s, %d, %d)", get_name (), offset, whence);
writebuf ();
if (ioctl (MTIOCPOS, &pos))
{
return ILLEGAL_SEEK;
}
switch (whence)
{
case SEEK_END:
op.mt_op = MTFSF;
op.mt_count = 1;
if (ioctl (MTIOCTOP, &op))
return -1;
break;
case SEEK_SET:
if (whence == SEEK_SET && offset < 0)
{
set_errno (EINVAL);
return -1;
}
break;
case SEEK_CUR:
break;
default:
set_errno (EINVAL);
return -1;
}
op.mt_op = MTFSR;
op.mt_count = offset / devbufsiz
- (whence == SEEK_SET ? pos.mt_blkno : 0);
if (op.mt_count < 0)
{
op.mt_op = MTBSR;
op.mt_count = -op.mt_count;
}
if (ioctl (MTIOCTOP, &op) || ioctl (MTIOCPOS, &pos))
return -1;
return (pos.mt_blkno * devbufsiz);
}
int
fhandler_dev_tape::dup (fhandler_base *child)
{
fhandler_dev_tape *fhc = (fhandler_dev_tape *) child;
fhc->lasterr = lasterr;
fhc->dp = dp;
return fhandler_dev_raw::dup (child);
}
int
fhandler_dev_tape::ioctl (unsigned int cmd, void *buf)
{
int ret = NO_ERROR;
unsigned long block;
if (cmd == MTIOCTOP)
{
struct mtop *op = (struct mtop *) buf;
if (!op)
ret = ERROR_INVALID_PARAMETER;
else
switch (op->mt_op)
{
case MTRESET:
break;
case MTFSF:
ret = tape_set_pos (TAPE_SPACE_FILEMARKS, op->mt_count);
break;
case MTBSF:
ret = tape_set_pos (TAPE_SPACE_FILEMARKS, -op->mt_count);
break;
case MTFSR:
ret = tape_set_pos (TAPE_SPACE_RELATIVE_BLOCKS, op->mt_count);
break;
case MTBSR:
ret = tape_set_pos (TAPE_SPACE_RELATIVE_BLOCKS, -op->mt_count);
break;
case MTWEOF:
if (tape_get_feature (TAPE_DRIVE_WRITE_FILEMARKS))
ret = tape_write_marks (TAPE_FILEMARKS, op->mt_count);
else if (tape_get_feature (TAPE_DRIVE_WRITE_LONG_FMKS))
ret = tape_write_marks (TAPE_LONG_FILEMARKS, op->mt_count);
else
ret = tape_write_marks (TAPE_SHORT_FILEMARKS, op->mt_count);
break;
case MTREW:
ret = tape_set_pos (TAPE_REWIND, 0);
break;
case MTOFFL:
case MTUNLOAD:
ret = tape_prepare (TAPE_UNLOAD);
break;
case MTNOP:
reset_devbuf ();
break;
case MTRETEN:
if (!tape_get_feature (TAPE_DRIVE_END_OF_DATA))
ret = ERROR_INVALID_PARAMETER;
else if (!(ret = tape_set_pos (TAPE_REWIND, 0, false)))
ret = tape_prepare (TAPE_TENSION);
break;
case MTBSFM:
ret = tape_set_pos (TAPE_SPACE_FILEMARKS, -op->mt_count, true);
break;
case MTFSFM:
ret = tape_set_pos (TAPE_SPACE_FILEMARKS, op->mt_count, true);
break;
case MTEOM:
if (tape_get_feature (TAPE_DRIVE_END_OF_DATA))
ret = tape_set_pos (TAPE_SPACE_END_OF_DATA, 0);
else
ret = tape_set_pos (TAPE_SPACE_FILEMARKS, 32767);
break;
case MTERASE:
ret = tape_erase (TAPE_ERASE_LONG);
break;
case MTRAS1:
case MTRAS2:
case MTRAS3:
ret = ERROR_INVALID_PARAMETER;
break;
case MTSETBLK:
if (!tape_get_feature (TAPE_DRIVE_SET_BLOCK_SIZE))
{
ret = ERROR_INVALID_PARAMETER;
break;
}
if ((devbuf && (size_t) op->mt_count == devbufsiz)
|| (!devbuf && op->mt_count == 0))
{
/* Nothing has changed. */
ret = 0;
break;
}
if ((op->mt_count == 0
&& !tape_get_feature (TAPE_DRIVE_VARIABLE_BLOCK))
|| (op->mt_count > 0
&& ((DWORD) op->mt_count < dp.MinimumBlockSize
|| (DWORD) op->mt_count > dp.MaximumBlockSize)))
{
ret = ERROR_INVALID_PARAMETER;
break;
}
if (devbuf && devbufend - devbufstart > 0
&& (op->mt_count == 0
|| (op->mt_count > 0
&& (size_t) op->mt_count < devbufend - devbufstart)))
{
/* Not allowed if still data in devbuf. */
ret = ERROR_INVALID_BLOCK_LENGTH; /* EIO */
break;
}
if (!(ret = tape_set_blocksize (op->mt_count)))
{
char *buf = NULL;
if (op->mt_count > 1L && !(buf = new char [op->mt_count]))
{
ret = ERROR_OUTOFMEMORY;
break;
}
if (devbufsiz > 1L && op->mt_count > 1L)
{
memcpy (buf, devbuf + devbufstart,
devbufend - devbufstart);
devbufend -= devbufstart;
}
else
devbufend = 0;
devbufstart = 0;
delete [] devbuf;
devbuf = buf;
devbufsiz = op->mt_count;
varblkop = op->mt_count == 0;
}
reset_devbuf ();
break;
case MTSEEK:
if (tape_get_feature (TAPE_DRIVE_LOGICAL_BLK))
ret = tape_set_pos (TAPE_LOGICAL_BLOCK, op->mt_count);
else if (!(ret = tape_get_pos (&block)))
ret = tape_set_pos (TAPE_SPACE_RELATIVE_BLOCKS,
op->mt_count - block);
break;
case MTTELL:
if (!(ret = tape_get_pos (&block)))
op->mt_count = block;
break;
case MTFSS:
ret = tape_set_pos (TAPE_SPACE_SETMARKS, op->mt_count);
break;
case MTBSS:
ret = tape_set_pos (TAPE_SPACE_SETMARKS, -op->mt_count);
break;
case MTWSM:
ret = tape_write_marks (TAPE_SETMARKS, op->mt_count);
reset_devbuf ();
break;
case MTLOCK:
ret = tape_prepare (TAPE_LOCK);
break;
case MTUNLOCK:
ret = tape_prepare (TAPE_UNLOCK);
break;
case MTLOAD:
ret = tape_prepare (TAPE_LOAD);
break;
case MTCOMPRESSION:
ret = tape_compression (op->mt_count);
break;
case MTSETPART:
ret = tape_set_partition (op->mt_count);
reset_devbuf ();
break;
case MTMKPART:
ret = tape_partition (op->mt_count);
reset_devbuf ();
break;
case MTSETDENSITY:
case MTSETDRVBUFFER:
reset_devbuf ();
default:
ret = ERROR_INVALID_PARAMETER;
break;
}
}
else if (cmd == MTIOCGET)
ret = tape_status ((struct mtget *) buf);
else if (cmd == MTIOCPOS)
{
ret = ERROR_INVALID_PARAMETER;
if (buf && (ret = tape_get_pos (&block)))
((struct mtpos *) buf)->mt_blkno = block;
}
else
return fhandler_dev_raw::ioctl (cmd, buf);
if (ret != NO_ERROR)
{
SetLastError (ret);
__seterrno ();
return -1;
}
return 0;
}
/* ------------------------------------------------------------------ */
/* Private functions used by `ioctl' */
/* ------------------------------------------------------------------ */
int
fhandler_dev_tape::tape_error (const char *txt)
{
if (lasterr)
debug_printf ("%s: error: %d", txt, lasterr);
return lasterr;
}
int
fhandler_dev_tape::tape_write_marks (int marktype, DWORD len)
{
syscall_printf ("write_tapemark");
TAPE_FUNC (WriteTapemark (get_handle (), marktype, len, FALSE));
return tape_error ("tape_write_marks");
}
int
fhandler_dev_tape::tape_get_pos (unsigned long *block,
unsigned long *partition)
{
DWORD part, low, high;
lasterr = ERROR_INVALID_PARAMETER;
if (tape_get_feature (TAPE_DRIVE_GET_LOGICAL_BLK))
TAPE_FUNC (GetTapePosition (get_handle (), TAPE_LOGICAL_POSITION,
&part, &low, &high));
else if (tape_get_feature (TAPE_DRIVE_GET_ABSOLUTE_BLK))
TAPE_FUNC (GetTapePosition (get_handle (), TAPE_ABSOLUTE_POSITION,
&part, &low, &high));
if (!tape_error ("tape_get_pos"))
{
if (block)
*block = low;
if (partition)
*partition = part > 0 ? part - 1 : part;
}
return lasterr;
}
int
fhandler_dev_tape::_tape_set_pos (int mode, long count, int partition)
{
TAPE_FUNC (SetTapePosition (get_handle (), mode, partition, count,
count < 0 ? -1 : 0, FALSE));
/* Reset buffer after successful repositioning. */
if (!lasterr || IS_EOF (lasterr) || IS_EOM (lasterr))
{
reset_devbuf ();
eof_detected = IS_EOF (lasterr);
eom_detected = IS_EOM (lasterr);
}
return lasterr;
}
int
fhandler_dev_tape::tape_set_pos (int mode, long count, bool sfm_func)
{
switch (mode)
{
case TAPE_SPACE_RELATIVE_BLOCKS:
case TAPE_SPACE_FILEMARKS:
if (!count)
{
lasterr = 0;
return tape_error ("tape_set_pos");
}
break;
}
_tape_set_pos (mode, count);
switch (mode)
{
case TAPE_SPACE_FILEMARKS:
if (!lasterr && sfm_func)
return tape_set_pos (mode, count > 0 ? -1 : 1, false);
break;
}
return tape_error ("tape_set_pos");
}
int
fhandler_dev_tape::tape_erase (int mode)
{
if (tape_set_pos (TAPE_REWIND, 0))
return lasterr;
switch (mode)
{
case TAPE_ERASE_SHORT:
if (!tape_get_feature (TAPE_DRIVE_ERASE_SHORT))
mode = TAPE_ERASE_LONG;
break;
case TAPE_ERASE_LONG:
if (!tape_get_feature (TAPE_DRIVE_ERASE_LONG))
mode = TAPE_ERASE_SHORT;
break;
}
TAPE_FUNC (EraseTape (get_handle (), mode, false));
/* Reset buffer after successful tape erasing. */
if (!lasterr)
reset_devbuf ();
return tape_error ("tape_erase");
}
int
fhandler_dev_tape::tape_prepare (int action)
{
TAPE_FUNC (PrepareTape (get_handle (), action, FALSE));
/* Reset buffer after all successful preparations but lock and unlock. */
if (!lasterr && action != TAPE_LOCK && action != TAPE_UNLOCK)
reset_devbuf ();
return tape_error ("tape_prepare");
}
int
fhandler_dev_tape::tape_set_blocksize (long count)
{
TAPE_SET_MEDIA_PARAMETERS mp;
mp.BlockSize = count;
TAPE_FUNC (SetTapeParameters (get_handle (), SET_TAPE_MEDIA_INFORMATION,
&mp));
return tape_error ("tape_set_blocksize");
}
int
fhandler_dev_tape::tape_status (struct mtget *get)
{
DWORD varlen;
TAPE_GET_MEDIA_PARAMETERS mp;
int notape = 0;
if (!get)
return ERROR_INVALID_PARAMETER;
/* Setting varlen to sizeof DP is by intention, actually! Never set
it to sizeof MP which seems to be more correct but results in a
ERROR_MORE_DATA error at least on W2K. */
TAPE_FUNC (GetTapeParameters (get_handle (), GET_TAPE_MEDIA_INFORMATION,
(varlen = sizeof dp, &varlen), &mp));
if (lasterr)
notape = 1;
memset (get, 0, sizeof *get);
get->mt_type = MT_ISUNKNOWN;
if (!notape && tape_get_feature (TAPE_DRIVE_SET_BLOCK_SIZE))
get->mt_dsreg = (mp.BlockSize << MT_ST_BLKSIZE_SHIFT)
& MT_ST_BLKSIZE_MASK;
else
get->mt_dsreg = (dp.DefaultBlockSize << MT_ST_BLKSIZE_SHIFT)
& MT_ST_BLKSIZE_MASK;
if (wincap.has_ioctl_storage_get_media_types_ex ())
{
DWORD size = sizeof (GET_MEDIA_TYPES) + 10 * sizeof (DEVICE_MEDIA_INFO);
void *buf = alloca (size);
if (DeviceIoControl (get_handle (), IOCTL_STORAGE_GET_MEDIA_TYPES_EX,
NULL, 0, buf, size, &size, NULL)
|| GetLastError () == ERROR_MORE_DATA)
{
PGET_MEDIA_TYPES gmt = (PGET_MEDIA_TYPES) buf;
for (DWORD i = 0; i < gmt->MediaInfoCount; ++i)
{
PDEVICE_MEDIA_INFO dmi = &gmt->MediaInfo[i];
get->mt_type = dmi->DeviceSpecific.TapeInfo.MediaType;
#define TINFO DeviceSpecific.TapeInfo
if (dmi->TINFO.MediaCharacteristics & MEDIA_CURRENTLY_MOUNTED)
{
get->mt_type = dmi->DeviceSpecific.TapeInfo.MediaType;
if (dmi->TINFO.BusType == BusTypeScsi)
get->mt_dsreg |=
(dmi->TINFO.BusSpecificData.ScsiInformation.DensityCode
<< MT_ST_DENSITY_SHIFT)
& MT_ST_DENSITY_MASK;
break;
}
#undef TINFO
}
}
}
if (notape)
get->mt_gstat |= GMT_DR_OPEN (-1);
if (!notape)
{
if (tape_get_feature (TAPE_DRIVE_GET_LOGICAL_BLK)
|| tape_get_feature (TAPE_DRIVE_GET_ABSOLUTE_BLK))
tape_get_pos ((unsigned long *) &get->mt_blkno,
(unsigned long *) &get->mt_resid);
if (!get->mt_blkno)
get->mt_gstat |= GMT_BOT (-1);
get->mt_gstat |= GMT_ONLINE (-1);
if (tape_get_feature (TAPE_DRIVE_WRITE_PROTECT) && mp.WriteProtected)
get->mt_gstat |= GMT_WR_PROT (-1);
if (tape_get_feature (TAPE_DRIVE_TAPE_CAPACITY))
get->mt_capacity = get_ll (mp.Capacity);
if (tape_get_feature (TAPE_DRIVE_TAPE_REMAINING))
get->mt_remaining = get_ll (mp.Remaining);
}
if (tape_get_feature (TAPE_DRIVE_COMPRESSION) && dp.Compression)
get->mt_gstat |= GMT_HW_COMP (-1);
if (tape_get_feature (TAPE_DRIVE_ECC) && dp.ECC)
get->mt_gstat |= GMT_HW_ECC (-1);
if (tape_get_feature (TAPE_DRIVE_PADDING) && dp.DataPadding)
get->mt_gstat |= GMT_PADDING (-1);
if (tape_get_feature (TAPE_DRIVE_REPORT_SMKS) && dp.ReportSetmarks)
get->mt_gstat |= GMT_IM_REP_EN (-1);
get->mt_erreg = lasterr;
get->mt_minblksize = dp.MinimumBlockSize;
get->mt_maxblksize = dp.MaximumBlockSize;
get->mt_defblksize = dp.DefaultBlockSize;
get->mt_featureslow = dp.FeaturesLow;
get->mt_featureshigh = dp.FeaturesHigh;
get->mt_eotwarningzonesize = dp.EOTWarningZoneSize;
return 0;
}
int
fhandler_dev_tape::tape_compression (long count)
{
TAPE_SET_DRIVE_PARAMETERS dps;
if (!tape_get_feature (TAPE_DRIVE_COMPRESSION))
return ERROR_INVALID_PARAMETER;
dps.ECC = dp.ECC;
dps.Compression = count ? TRUE : FALSE;
dps.DataPadding = dp.DataPadding;
dps.ReportSetmarks = dp.ReportSetmarks;
dps.EOTWarningZoneSize = dp.EOTWarningZoneSize;
TAPE_FUNC (SetTapeParameters (get_handle (), SET_TAPE_DRIVE_INFORMATION,
&dps));
if (!lasterr)
dp.Compression = dps.Compression;
return tape_error ("tape_compression");
}
int
fhandler_dev_tape::tape_partition (long count)
{
if (dp.MaximumPartitionCount <= 1)
return ERROR_INVALID_PARAMETER;
if (tape_set_pos (TAPE_REWIND, 0))
return lasterr;
if (count <= 0)
debug_printf ("Formatting tape with one partition");
else
debug_printf ("Formatting tape with two partitions");
TAPE_FUNC (CreateTapePartition (get_handle (), TAPE_SELECT_PARTITIONS,
count <= 0 ? 1 : 2, 0));
return tape_error ("tape_partition");
}
int
fhandler_dev_tape::tape_set_partition (long count)
{
if (count < 0 || (unsigned long) count >= dp.MaximumPartitionCount)
lasterr = ERROR_INVALID_PARAMETER;
else
lasterr = _tape_set_pos (TAPE_LOGICAL_BLOCK, 0, count + 1);
return tape_error ("tape_set_partition");
}
Reference in New Issue View Git Blame Copy Permalink