minix/commands/i386/mtools-3.9.7/plain_io.c

750 lines
18 KiB
C
Raw Normal View History

2005-04-21 16:53:53 +02:00
/*
* Io to a plain file or device
*
* written by:
*
* Alain L. Knaff
* alain@linux.lu
*
*/
#include "sysincludes.h"
#include "stream.h"
#include "mtools.h"
#include "msdos.h"
#include "plain_io.h"
#include "scsi.h"
#include "partition.h"
#include "llong.h"
typedef struct SimpleFile_t {
Class_t *Class;
int refs;
Stream_t *Next;
Stream_t *Buffer;
struct stat stat;
int fd;
mt_off_t offset;
mt_off_t lastwhere;
int seekable;
int privileged;
#ifdef OS_hpux
int size_limited;
#endif
int scsi_sector_size;
void *extra_data; /* extra system dependant information for scsi */
} SimpleFile_t;
/*
* Create an advisory lock on the device to prevent concurrent writes.
* Uses either lockf, flock, or fcntl locking methods. See the Makefile
* and the Configure files for how to specify the proper method.
*/
int lock_dev(int fd, int mode, struct device *dev)
{
#if (defined(HAVE_FLOCK) && defined (LOCK_EX) && defined(LOCK_NB))
/**/
#else /* FLOCK */
#if (defined(HAVE_LOCKF) && defined(F_TLOCK))
/**/
#else /* LOCKF */
#if (defined(F_SETLK) && defined(F_WRLCK))
struct flock flk;
#endif /* FCNTL */
#endif /* LOCKF */
#endif /* FLOCK */
if(IS_NOLOCK(dev))
return 0;
#if (defined(HAVE_FLOCK) && defined (LOCK_EX) && defined(LOCK_NB))
if (flock(fd, (mode ? LOCK_EX : LOCK_SH)|LOCK_NB) < 0)
#else /* FLOCK */
#if (defined(HAVE_LOCKF) && defined(F_TLOCK))
if (mode && lockf(fd, F_TLOCK, 0) < 0)
#else /* LOCKF */
#if (defined(F_SETLK) && defined(F_WRLCK))
flk.l_type = mode ? F_WRLCK : F_RDLCK;
flk.l_whence = 0;
flk.l_start = 0L;
flk.l_len = 0L;
if (fcntl(fd, F_SETLK, &flk) < 0)
#endif /* FCNTL */
#endif /* LOCKF */
#endif /* FLOCK */
{
if(errno == EINVAL
#ifdef EOPNOTSUPP
|| errno == EOPNOTSUPP
#endif
)
return 0;
else
return 1;
}
return 0;
}
typedef int (*iofn) (int, char *, int);
static int file_io(Stream_t *Stream, char *buf, mt_off_t where, int len,
iofn io)
{
DeclareThis(SimpleFile_t);
int ret;
where += This->offset;
if (This->seekable && where != This->lastwhere ){
if(mt_lseek( This->fd, where, SEEK_SET) < 0 ){
perror("seek");
This->lastwhere = (mt_off_t) -1;
return -1;
}
}
#ifdef OS_hpux
/*
* On HP/UX, we can not write more than MAX_LEN bytes in one go.
* If more are written, the write fails with EINVAL
*/
#define MAX_SCSI_LEN (127*1024)
if(This->size_limited && len > MAX_SCSI_LEN)
len = MAX_SCSI_LEN;
#endif
ret = io(This->fd, buf, len);
#ifdef OS_hpux
if (ret == -1 &&
errno == EINVAL && /* if we got EINVAL */
len > MAX_SCSI_LEN) {
This->size_limited = 1;
len = MAX_SCSI_LEN;
ret = io(This->fd, buf, len);
}
#endif
if ( ret == -1 ){
perror("plain_io");
This->lastwhere = (mt_off_t) -1;
return -1;
}
This->lastwhere = where + ret;
return ret;
}
static int file_read(Stream_t *Stream, char *buf, mt_off_t where, size_t len)
{
return file_io(Stream, buf, where, len, (iofn) read);
}
static int file_write(Stream_t *Stream, char *buf, mt_off_t where, size_t len)
{
return file_io(Stream, buf, where, len, (iofn) write);
}
static int file_flush(Stream_t *Stream)
{
#if 0
DeclareThis(SimpleFile_t);
return fsync(This->fd);
#endif
return 0;
}
static int file_free(Stream_t *Stream)
{
DeclareThis(SimpleFile_t);
if (This->fd > 2)
return close(This->fd);
else
return 0;
}
static int file_geom(Stream_t *Stream, struct device *dev,
struct device *orig_dev,
int media, struct bootsector *boot)
{
int ret;
DeclareThis(SimpleFile_t);
size_t tot_sectors;
int BootP, Infp0, InfpX, InfTm;
int sectors, j;
unsigned char sum;
int sect_per_track;
struct label_blk_t *labelBlock;
dev->ssize = 2; /* allow for init_geom to change it */
dev->use_2m = 0x80; /* disable 2m mode to begin */
if(media == 0xf0 || media >= 0x100){
dev->heads = WORD(nheads);
dev->sectors = WORD(nsect);
tot_sectors = DWORD(bigsect);
SET_INT(tot_sectors, WORD(psect));
sect_per_track = dev->heads * dev->sectors;
tot_sectors += sect_per_track - 1; /* round size up */
dev->tracks = tot_sectors / sect_per_track;
BootP = WORD(ext.old.BootP);
Infp0 = WORD(ext.old.Infp0);
InfpX = WORD(ext.old.InfpX);
InfTm = WORD(ext.old.InfTm);
if(WORD(fatlen)) {
labelBlock = &boot->ext.old.labelBlock;
} else {
labelBlock = &boot->ext.fat32.labelBlock;
}
if (boot->descr >= 0xf0 &&
labelBlock->dos4 == 0x29 &&
strncmp( boot->banner,"2M", 2 ) == 0 &&
BootP < 512 && Infp0 < 512 && InfpX < 512 && InfTm < 512 &&
BootP >= InfTm + 2 && InfTm >= InfpX && InfpX >= Infp0 &&
Infp0 >= 76 ){
for (sum=0, j=63; j < BootP; j++)
sum += boot->jump[j];/* checksum */
dev->ssize = boot->jump[InfTm];
if (!sum && dev->ssize <= 7){
dev->use_2m = 0xff;
dev->ssize |= 0x80; /* is set */
}
}
} else if (media >= 0xf8){
media &= 3;
dev->heads = old_dos[media].heads;
dev->tracks = old_dos[media].tracks;
dev->sectors = old_dos[media].sectors;
dev->ssize = 0x80;
dev->use_2m = ~1;
} else {
fprintf(stderr,"Unknown media type\n");
exit(1);
}
sectors = dev->sectors;
dev->sectors = dev->sectors * WORD(secsiz) / 512;
#ifdef JPD
printf("file_geom:media=%0X=>cyl=%d,heads=%d,sects=%d,ssize=%d,use2m=%X\n",
media, dev->tracks, dev->heads, dev->sectors, dev->ssize,
dev->use_2m);
#endif
ret = init_geom(This->fd,dev, orig_dev, &This->stat);
dev->sectors = sectors;
#ifdef JPD
printf("f_geom: after init_geom(), sects=%d\n", dev->sectors);
#endif
return ret;
}
static int file_data(Stream_t *Stream, time_t *date, mt_size_t *size,
int *type, int *address)
{
DeclareThis(SimpleFile_t);
if(date)
*date = This->stat.st_mtime;
if(size)
*size = This->stat.st_size;
if(type)
*type = S_ISDIR(This->stat.st_mode);
if(address)
*address = 0;
return 0;
}
/* ZIP or other scsi device on Solaris or SunOS system.
Since Sun won't accept a non-Sun label on a scsi disk, we must
bypass Sun's disk interface and use low-level SCSI commands to read
or write the ZIP drive. We thus replace the file_read and file_write
routines with our own scsi_read and scsi_write routines, that use the
uscsi ioctl interface. By James Dugal, jpd@usl.edu, 11-96. Tested
under Solaris 2.5 and SunOS 4.3.1_u1 using GCC.
Note: the mtools.conf entry for a ZIP drive would look like this:
(solaris) drive C: file="/dev/rdsk/c0t5d0s2" partition=4 FAT=16 nodelay exclusive scsi=&
(sunos) drive C: file="/dev/rsd5c" partition=4 FAT=16 nodelay exclusive scsi=1
Note 2: Sol 2.5 wants mtools to be suid-root, to use the ioctl. SunOS is
happy if we just have access to the device, so making mtools sgid to a
group called, say, "ziprw" which has rw permission on /dev/rsd5c, is fine.
*/
#define MAXBLKSPERCMD 255
static void scsi_init(SimpleFile_t *This)
{
int fd = This->fd;
unsigned char cdb[10],buf[8];
memset(cdb, 0, sizeof cdb);
memset(buf,0, sizeof(buf));
cdb[0]=SCSI_READ_CAPACITY;
if (scsi_cmd(fd, (unsigned char *)cdb,
sizeof(cdb), SCSI_IO_READ, buf, sizeof(buf), This->extra_data)==0)
{
This->scsi_sector_size=
((unsigned)buf[5]<<16)|((unsigned)buf[6]<<8)|(unsigned)buf[7];
if (This->scsi_sector_size != 512)
fprintf(stderr," (scsi_sector_size=%d)\n",This->scsi_sector_size);
}
}
int scsi_io(Stream_t *Stream, char *buf, mt_off_t where, size_t len, int rwcmd)
{
unsigned int firstblock, nsect;
int clen,r,max;
off_t offset;
unsigned char cdb[10];
DeclareThis(SimpleFile_t);
firstblock=truncBytes32((where + This->offset)/This->scsi_sector_size);
/* 512,1024,2048,... bytes/sector supported */
offset=truncBytes32(where + This->offset -
firstblock*This->scsi_sector_size);
nsect=(offset+len+This->scsi_sector_size-1)/ This->scsi_sector_size;
#if defined(OS_sun) && defined(OS_i386)
if (This->scsi_sector_size>512)
firstblock*=This->scsi_sector_size/512; /* work around a uscsi bug */
#endif /* sun && i386 */
if (len>512) {
/* avoid buffer overruns. The transfer MUST be smaller or
* equal to the requested size! */
while (nsect*This->scsi_sector_size>len)
--nsect;
if(!nsect) {
fprintf(stderr,"Scsi buffer too small\n");
exit(1);
}
if(rwcmd == SCSI_IO_WRITE && offset) {
/* there seems to be no memmove before a write */
fprintf(stderr,"Unaligned write\n");
exit(1);
}
/* a better implementation should use bounce buffers.
* However, in normal operation no buffer overruns or
* unaligned writes should happen anyways, as the logical
* sector size is (hopefully!) equal to the physical one
*/
}
max = scsi_max_length();
if (nsect > max)
nsect=max;
/* set up SCSI READ/WRITE command */
memset(cdb, 0, sizeof cdb);
switch(rwcmd) {
case SCSI_IO_READ:
cdb[0] = SCSI_READ;
break;
case SCSI_IO_WRITE:
cdb[0] = SCSI_WRITE;
break;
}
cdb[1] = 0;
if (firstblock > 0x1fffff || nsect > 0xff) {
/* I suspect that the ZIP drive also understands Group 1
* commands. If that is indeed true, we may chose Group 1
* more agressively in the future */
cdb[0] |= SCSI_GROUP1;
clen=10; /* SCSI Group 1 cmd */
/* this is one of the rare case where explicit coding is
* more portable than macros... The meaning of scsi command
* bytes is standardised, whereas the preprocessor macros
* handling it might be not... */
cdb[2] = (unsigned char) (firstblock >> 24) & 0xff;
cdb[3] = (unsigned char) (firstblock >> 16) & 0xff;
cdb[4] = (unsigned char) (firstblock >> 8) & 0xff;
cdb[5] = (unsigned char) firstblock & 0xff;
cdb[6] = 0;
cdb[7] = (unsigned char) (nsect >> 8) & 0xff;
cdb[8] = (unsigned char) nsect & 0xff;
cdb[9] = 0;
} else {
clen = 6; /* SCSI Group 0 cmd */
cdb[1] |= (unsigned char) ((firstblock >> 16) & 0x1f);
cdb[2] = (unsigned char) ((firstblock >> 8) & 0xff);
cdb[3] = (unsigned char) firstblock & 0xff;
cdb[4] = (unsigned char) nsect;
cdb[5] = 0;
}
if(This->privileged)
reclaim_privs();
r=scsi_cmd(This->fd, (unsigned char *)cdb, clen, rwcmd, buf,
nsect*This->scsi_sector_size, This->extra_data);
if(This->privileged)
drop_privs();
if(r) {
perror(rwcmd == SCSI_IO_READ ? "SCMD_READ" : "SCMD_WRITE");
return -1;
}
#ifdef JPD
printf("finished %u for %u\n", firstblock, nsect);
#endif
#ifdef JPD
printf("zip: read or write OK\n");
#endif
if (offset>0) memmove(buf,buf+offset,nsect*This->scsi_sector_size-offset);
if (len==256) return 256;
else if (len==512) return 512;
else return nsect*This->scsi_sector_size-offset;
}
int scsi_read(Stream_t *Stream, char *buf, mt_off_t where, size_t len)
{
#ifdef JPD
printf("zip: to read %d bytes at %d\n", len, where);
#endif
return scsi_io(Stream, buf, where, len, SCSI_IO_READ);
}
int scsi_write(Stream_t *Stream, char *buf, mt_off_t where, size_t len)
{
#ifdef JPD
Printf("zip: to write %d bytes at %d\n", len, where);
#endif
return scsi_io(Stream, buf, where, len, SCSI_IO_WRITE);
}
static Class_t ScsiClass = {
scsi_read,
scsi_write,
file_flush,
file_free,
file_geom,
file_data,
0 /* pre-allocate */
};
static Class_t SimpleFileClass = {
file_read,
file_write,
file_flush,
file_free,
file_geom,
file_data,
0 /* pre_allocate */
};
Stream_t *SimpleFileOpen(struct device *dev, struct device *orig_dev,
const char *name, int mode, char *errmsg,
int mode2, int locked, mt_size_t *maxSize)
{
SimpleFile_t *This;
#ifdef __EMX__
HFILE FileHandle;
ULONG Action;
APIRET rc;
#endif
This = New(SimpleFile_t);
if (!This){
printOom();
return 0;
}
This->scsi_sector_size = 512;
This->seekable = 1;
#ifdef OS_hpux
This->size_limited = 0;
#endif
This->Class = &SimpleFileClass;
if (!name || strcmp(name,"-") == 0 ){
if (mode == O_RDONLY)
This->fd = 0;
else
This->fd = 1;
This->seekable = 0;
This->refs = 1;
This->Next = 0;
This->Buffer = 0;
if (fstat(This->fd, &This->stat) < 0) {
Free(This);
if(errmsg)
#ifdef HAVE_SNPRINTF
snprintf(errmsg,199,"Can't stat -: %s",
strerror(errno));
#else
sprintf(errmsg,"Can't stat -: %s",
strerror(errno));
#endif
return NULL;
}
return (Stream_t *) This;
}
if(dev) {
if(!(mode2 & NO_PRIV))
This->privileged = IS_PRIVILEGED(dev);
mode |= dev->mode;
}
precmd(dev);
if(IS_PRIVILEGED(dev) && !(mode2 & NO_PRIV))
reclaim_privs();
#ifdef __EMX__
#define DOSOPEN_FLAGS (OPEN_FLAGS_DASD | OPEN_FLAGS_WRITE_THROUGH | \
OPEN_FLAGS_NOINHERIT | OPEN_FLAGS_RANDOM | \
OPEN_FLAGS_NO_CACHE)
#define DOSOPEN_FD_ACCESS (OPEN_SHARE_DENYREADWRITE | OPEN_ACCESS_READWRITE)
#define DOSOPEN_HD_ACCESS (OPEN_SHARE_DENYNONE | OPEN_ACCESS_READONLY)
if (skip_drive(name) > name) {
rc = DosOpen(
name, &FileHandle, &Action, 0L, FILE_NORMAL,
OPEN_ACTION_OPEN_IF_EXISTS, DOSOPEN_FLAGS |
(IS_NOLOCK(dev)?DOSOPEN_HD_ACCESS:DOSOPEN_FD_ACCESS),
0L);
#ifdef DEBUG
if (rc != NO_ERROR) fprintf (stderr, "DosOpen() returned %d\n", rc);
#endif
if (!IS_NOLOCK(dev)) {
rc = DosDevIOCtl(
FileHandle, 0x08L, DSK_LOCKDRIVE, 0, 0, 0, 0, 0, 0);
#ifdef DEBUG
if (rc != NO_ERROR) fprintf (stderr, "DosDevIOCtl() returned %d\n", rc);
#endif
}
if (rc == NO_ERROR)
This->fd = _imphandle(FileHandle); else This->fd = -1;
} else
#endif
{
if (IS_SCSI(dev))
This->fd = scsi_open(name, mode, IS_NOLOCK(dev)?0444:0666,
&This->extra_data);
else
This->fd = open(name, mode, IS_NOLOCK(dev)?0444:0666);
}
if(IS_PRIVILEGED(dev) && !(mode2 & NO_PRIV))
drop_privs();
if (This->fd < 0) {
Free(This);
if(errmsg)
#ifdef HAVE_SNPRINTF
snprintf(errmsg, 199, "Can't open %s: %s",
name, strerror(errno));
#else
sprintf(errmsg, "Can't open %s: %s",
name, strerror(errno));
#endif
return NULL;
}
if(IS_PRIVILEGED(dev) && !(mode2 & NO_PRIV))
closeExec(This->fd);
#ifdef __EMX__
if (*(name+1) != ':')
#endif
if (fstat(This->fd, &This->stat) < 0){
Free(This);
if(errmsg) {
#ifdef HAVE_SNPRINTF
snprintf(errmsg,199,"Can't stat %s: %s",
name, strerror(errno));
#else
if(strlen(name) > 50) {
sprintf(errmsg,"Can't stat file: %s",
strerror(errno));
} else {
sprintf(errmsg,"Can't stat %s: %s",
name, strerror(errno));
}
#endif
}
return NULL;
}
#ifndef __EMX__
/* lock the device on writes */
if (locked && lock_dev(This->fd, mode == O_RDWR, dev)) {
if(errmsg)
#ifdef HAVE_SNPRINTF
snprintf(errmsg,199,
"plain floppy: device \"%s\" busy (%s):",
dev ? dev->name : "unknown", strerror(errno));
#else
sprintf(errmsg,
"plain floppy: device \"%s\" busy (%s):",
(dev && strlen(dev->name) < 50) ?
dev->name : "unknown", strerror(errno));
#endif
close(This->fd);
Free(This);
return NULL;
}
#endif
/* set default parameters, if needed */
if (dev){
if ((IS_MFORMAT_ONLY(dev) || !dev->tracks) &&
init_geom(This->fd, dev, orig_dev, &This->stat)){
close(This->fd);
Free(This);
if(errmsg)
sprintf(errmsg,"init: set default params");
return NULL;
}
This->offset = (mt_off_t) dev->offset;
} else
This->offset = 0;
This->refs = 1;
This->Next = 0;
This->Buffer = 0;
if(maxSize) {
if (IS_SCSI(dev)) {
*maxSize = MAX_OFF_T_B(31+log_2(This->scsi_sector_size));
} else {
*maxSize = max_off_t_seek;
}
if(This->offset > *maxSize) {
close(This->fd);
Free(This);
if(errmsg)
sprintf(errmsg,"init: Big disks not supported");
return NULL;
}
*maxSize -= This->offset;
}
/* partitioned drive */
/* jpd@usl.edu: assume a partitioned drive on these 2 systems is a ZIP*/
/* or similar drive that must be accessed by low-level scsi commands */
/* AK: introduce new "scsi=1" statement to specifically set
* this option. Indeed, there could conceivably be partitioned
* devices where low level scsi commands will not be needed */
if(IS_SCSI(dev)) {
This->Class = &ScsiClass;
if(This->privileged)
reclaim_privs();
scsi_init(This);
if(This->privileged)
drop_privs();
}
while(!(mode2 & NO_OFFSET) &&
dev && dev->partition && dev->partition <= 4) {
int has_activated, last_end, j;
unsigned char buf[2048];
struct partition *partTable=(struct partition *)(buf+ 0x1ae);
size_t partOff;
/* read the first sector, or part of it */
if (force_read((Stream_t *)This, (char*) buf, 0, 512) != 512)
break;
if( _WORD(buf+510) != 0xaa55)
break;
partOff = BEGIN(partTable[dev->partition]);
if (maxSize) {
if (partOff > *maxSize >> 9) {
close(This->fd);
Free(This);
if(errmsg)
sprintf(errmsg,"init: Big disks not supported");
return NULL;
}
*maxSize -= (mt_off_t) partOff << 9;
}
This->offset += (mt_off_t) partOff << 9;
if(!partTable[dev->partition].sys_ind) {
if(errmsg)
sprintf(errmsg,
"init: non-existant partition");
close(This->fd);
Free(This);
return NULL;
}
if(!dev->tracks) {
dev->heads = head(partTable[dev->partition].end)+1;
dev->sectors = sector(partTable[dev->partition].end);
dev->tracks = cyl(partTable[dev->partition].end) -
cyl(partTable[dev->partition].start)+1;
}
dev->hidden=dev->sectors*head(partTable[dev->partition].start);
if(!mtools_skip_check &&
consistencyCheck((struct partition *)(buf+0x1ae), 0, 0,
&has_activated, &last_end, &j, dev, 0)) {
fprintf(stderr,
"Warning: inconsistent partition table\n");
fprintf(stderr,
"Possibly unpartitioned device\n");
fprintf(stderr,
"\n*** Maybe try without partition=%d in "
"device definition ***\n\n",
dev->partition);
fprintf(stderr,
"If this is a PCMCIA card, or a disk "
"partitioned on another computer, this "
"message may be in error: add "
"mtools_skip_check=1 to your .mtoolsrc "
"file to suppress this warning\n");
}
break;
/* NOTREACHED */
}
This->lastwhere = -This->offset;
/* provoke a seek on those devices that don't start on a partition
* boundary */
return (Stream_t *) This;
}
int get_fd(Stream_t *Stream)
{
DeclareThis(SimpleFile_t);
return This->fd;
}
void *get_extra_data(Stream_t *Stream)
{
DeclareThis(SimpleFile_t);
return This->extra_data;
}