[simh.git] / sim_tape.c

/* sim_tape.c: simulator tape support library\r
\r
   Copyright (c) 1993-2007, Robert M Supnik\r
\r
   Permission is hereby granted, free of charge, to any person obtaining a\r
   copy of this software and associated documentation files (the "Software"),\r
   to deal in the Software without restriction, including without limitation\r
   the rights to use, copy, modify, merge, publish, distribute, sublicense,\r
   and/or sell copies of the Software, and to permit persons to whom the\r
   Software is furnished to do so, subject to the following conditions:\r
\r
   The above copyright notice and this permission notice shall be included in\r
   all copies or substantial portions of the Software.\r
\r
   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL\r
   ROBERT M SUPNIK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
   IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
\r
   Except as contained in this notice, the name of Robert M Supnik shall not be\r
   used in advertising or otherwise to promote the sale, use or other dealings\r
   in this Software without prior written authorization from Robert M Supnik.\r
\r
   Ultimately, this will be a place to hide processing of various tape formats,\r
   as well as OS-specific direct hardware access.\r
\r
   23-Jan-07    JDB     Fixed backspace over gap at BOT\r
   22-Jan-07    RMS     Fixed bug in P7B format read reclnt rev (found by Rich Cornwell)\r
   15-Dec-06    RMS     Added support for small capacity tapes\r
   30-Aug-06    JDB     Added erase gap support\r
   14-Feb-06    RMS     Added variable tape capacity\r
   23-Jan-06    JDB     Fixed odd-byte-write problem in sim_tape_wrrecf\r
   17-Dec-05    RMS     Added write support for Paul Pierce 7b format\r
   16-Aug-05    RMS     Fixed C++ declaration and cast problems\r
   02-May-05    RMS     Added support for Pierce 7b format\r
   28-Jul-04    RMS     Fixed bug in writing error records (found by Dave Bryan)\r
                RMS     Fixed incorrect error codes (found by Dave Bryan)\r
   05-Jan-04    RMS     Revised for file I/O library\r
   25-Apr-03    RMS     Added extended file support\r
   28-Mar-03    RMS     Added E11 and TPC format support\r
\r
   Public routines:\r
\r
   sim_tape_attach      attach tape unit\r
   sim_tape_detach      detach tape unit\r
   sim_tape_rdrecf      read tape record forward\r
   sim_tape_rdrecr      read tape record reverse\r
   sim_tape_wrrecf      write tape record forward\r
   sim_tape_sprecf      space tape record forward\r
   sim_tape_sprecr      space tape record reverse\r
   sim_tape_wrtmk       write tape mark\r
   sim_tape_wreom       erase remainder of tape\r
   sim_tape_wrgap       write erase gap\r
   sim_tape_rewind      rewind\r
   sim_tape_reset       reset unit\r
   sim_tape_bot         TRUE if at beginning of tape\r
   sim_tape_eot         TRUE if at or beyond end of tape\r
   sim_tape_wrp         TRUE if write protected\r
   sim_tape_set_fmt     set tape format\r
   sim_tape_show_fmt    show tape format\r
   sim_tape_set_capac   set tape capacity\r
   sim_tape_show_capac  show tape capacity\r
*/\r
\r
#include "sim_defs.h"\r
#include "sim_tape.h"\r
\r
struct sim_tape_fmt {\r
    char                *name;                          /* name */\r
    int32               uflags;                         /* unit flags */\r
    t_addr              bot;                            /* bot test */\r
    };\r
\r
static struct sim_tape_fmt fmts[MTUF_N_FMT] = {\r
    { "SIMH", 0,       sizeof (t_mtrlnt) - 1 },\r
    { "E11",  0,       sizeof (t_mtrlnt) - 1 },\r
    { "TPC",  UNIT_RO, sizeof (t_tpclnt) - 1 },\r
    { "P7B",  0,       0 },\r
/*  { "TPF",  UNIT_RO, 0 }, */\r
    { NULL,   0,       0 }\r
    };\r
\r
extern int32 sim_switches;\r
\r
t_stat sim_tape_ioerr (UNIT *uptr);\r
t_stat sim_tape_wrdata (UNIT *uptr, uint32 dat);\r
uint32 sim_tape_tpc_map (UNIT *uptr, t_addr *map);\r
t_addr sim_tape_tpc_fnd (UNIT *uptr, t_addr *map);\r
\r
/* Attach tape unit */\r
\r
t_stat sim_tape_attach (UNIT *uptr, char *cptr)\r
{\r
uint32 objc;\r
char gbuf[CBUFSIZE];\r
t_stat r;\r
\r
if (sim_switches & SWMASK ('F')) {                      /* format spec? */\r
    cptr = get_glyph (cptr, gbuf, 0);                   /* get spec */\r
    if (*cptr == 0) return SCPE_2FARG;                  /* must be more */\r
    if (sim_tape_set_fmt (uptr, 0, gbuf, NULL) != SCPE_OK)\r
        return SCPE_ARG;\r
    }\r
r = attach_unit (uptr, cptr);                           /* attach unit */\r
if (r != SCPE_OK) return r;                             /* error? */\r
switch (MT_GET_FMT (uptr)) {                            /* case on format */\r
\r
    case MTUF_F_TPC:                                    /* TPC */\r
        objc = sim_tape_tpc_map (uptr, NULL);           /* get # objects */\r
        if (objc == 0) {                                /* tape empty? */\r
            sim_tape_detach (uptr);\r
            return SCPE_FMT;                            /* yes, complain */\r
            }\r
        uptr->filebuf = calloc (objc + 1, sizeof (t_addr));\r
        if (uptr->filebuf == NULL) {                    /* map allocated? */\r
            sim_tape_detach (uptr);\r
            return SCPE_MEM;                            /* no, complain */\r
            }\r
        uptr->hwmark = objc + 1;                        /* save map size */\r
        sim_tape_tpc_map (uptr, (t_addr *) uptr->filebuf);      /* fill map */\r
        break;\r
\r
    default:\r
        break;\r
        }\r
\r
sim_tape_rewind (uptr);\r
return SCPE_OK;\r
}\r
\r
/* Detach tape unit */\r
\r
t_stat sim_tape_detach (UNIT *uptr)\r
{\r
uint32 f = MT_GET_FMT (uptr);\r
t_stat r;\r
\r
r = detach_unit (uptr);                                 /* detach unit */\r
if (r != SCPE_OK) return r;\r
switch (f) {                                            /* case on format */\r
\r
    case MTUF_F_TPC:                                    /* TPC */\r
        if (uptr->filebuf) free (uptr->filebuf);        /* free map */\r
        uptr->filebuf = NULL;\r
        uptr->hwmark = 0;\r
        break;\r
\r
    default:\r
        break;\r
        }\r
\r
sim_tape_rewind (uptr);\r
return SCPE_OK;\r
}\r
\r
/* Read record length forward (internal routine)\r
\r
   Inputs:\r
        uptr    =       pointer to tape unit\r
        bc      =       pointer to returned record length\r
   Outputs:\r
        status  =       operation status\r
\r
   exit condition       position\r
\r
   unit unattached      unchanged\r
   read error           unchanged, PNU set\r
   end of file/medium   unchanged, PNU set\r
   tape mark            updated\r
   data record          updated, sim_fread will read record forward\r
\r
   See notes at "sim_tape_wrgap" regarding erase gap implementation.\r
*/\r
\r
t_stat sim_tape_rdlntf (UNIT *uptr, t_mtrlnt *bc)\r
{\r
uint8 c;\r
t_bool all_eof;\r
uint32 f = MT_GET_FMT (uptr);\r
t_mtrlnt sbc;\r
t_tpclnt tpcbc;\r
\r
MT_CLR_PNU (uptr);\r
if ((uptr->flags & UNIT_ATT) == 0) return MTSE_UNATT;   /* not attached? */\r
sim_fseek (uptr->fileref, uptr->pos, SEEK_SET);         /* set tape pos */\r
switch (f) {                                            /* switch on fmt */\r
\r
    case MTUF_F_STD: case MTUF_F_E11:\r
        do {\r
            sim_fread (bc, sizeof (t_mtrlnt), 1, uptr->fileref);    /* read rec lnt */\r
            sbc = MTR_L (*bc);                          /* save rec lnt */\r
            if (ferror (uptr->fileref)) {               /* error? */\r
                MT_SET_PNU (uptr);                      /* pos not upd */\r
                return sim_tape_ioerr (uptr);\r
                }\r
            if (feof (uptr->fileref) || (*bc == MTR_EOM)) {     /* eof or eom? */\r
                MT_SET_PNU (uptr);                      /* pos not upd */\r
                return MTSE_EOM;\r
                }\r
            uptr->pos = uptr->pos + sizeof (t_mtrlnt);  /* spc over rec lnt */\r
            if (*bc == MTR_TMK) return MTSE_TMK;        /* tape mark? */\r
            if (*bc == MTR_FHGAP) {                     /* half gap? */\r
                uptr->pos = uptr->pos + sizeof (t_mtrlnt) / 2;  /* half space fwd */\r
                sim_fseek (uptr->fileref, uptr->pos, SEEK_SET); /* resync */\r
                }\r
            else if (*bc != MTR_GAP)\r
                uptr->pos = uptr->pos + sizeof (t_mtrlnt) +     /* spc over record */\r
                    ((f == MTUF_F_STD)? ((sbc + 1) & ~1): sbc);\r
            }\r
        while ((*bc == MTR_GAP) || (*bc == MTR_FHGAP));\r
        break;\r
\r
    case MTUF_F_TPC:\r
        sim_fread (&tpcbc, sizeof (t_tpclnt), 1, uptr->fileref);\r
        *bc = tpcbc;                                    /* save rec lnt */\r
        if (ferror (uptr->fileref)) {                   /* error? */\r
            MT_SET_PNU (uptr);                          /* pos not upd */\r
            return sim_tape_ioerr (uptr);\r
            }\r
        if (feof (uptr->fileref)) {                     /* eof? */\r
            MT_SET_PNU (uptr);                          /* pos not upd */\r
            return MTSE_EOM;\r
            }\r
        uptr->pos = uptr->pos + sizeof (t_tpclnt);      /* spc over reclnt */\r
        if (tpcbc == TPC_TMK) return MTSE_TMK;          /* tape mark? */\r
        uptr->pos = uptr->pos + ((tpcbc + 1) & ~1);     /* spc over record */\r
        break;\r
\r
    case MTUF_F_P7B:\r
        for (sbc = 0, all_eof = 1; ; sbc++) {           /* loop thru record */\r
            sim_fread (&c, sizeof (uint8), 1, uptr->fileref);\r
            if (ferror (uptr->fileref)) {               /* error? */\r
                MT_SET_PNU (uptr);                      /* pos not upd */\r
                return sim_tape_ioerr (uptr);\r
                }\r
            if (feof (uptr->fileref)) {                 /* eof? */\r
                if (sbc == 0) return MTSE_EOM;          /* no data? eom */\r
                break;                                  /* treat like eor */\r
                }\r
            if ((sbc != 0) && (c & P7B_SOR)) break;     /* next record? */\r
            if ((c & P7B_DPAR) != P7B_EOF) all_eof = 0;\r
            }\r
        *bc = sbc;                                      /* save rec lnt */\r
        sim_fseek (uptr->fileref, uptr->pos, SEEK_SET); /* for read */\r
        uptr->pos = uptr->pos + sbc;                    /* spc over record */\r
        if (all_eof) return MTSE_TMK;                   /* tape mark? */\r
        break;\r
\r
    default:\r
        return MTSE_FMT;\r
        }\r
\r
return MTSE_OK;\r
}\r
\r
/* Read record length reverse (internal routine)\r
\r
   Inputs:\r
        uptr    =       pointer to tape unit\r
        bc      =       pointer to returned record length\r
   Outputs:\r
        status  =       operation status\r
\r
   exit condition       position\r
\r
   unit unattached      unchanged\r
   beginning of tape    unchanged\r
   read error           unchanged\r
   end of file          unchanged\r
   end of medium        updated\r
   tape mark            updated\r
   data record          updated, sim_fread will read record forward\r
\r
   See notes at "sim_tape_wrgap" regarding erase gap implementation.\r
*/\r
\r
t_stat sim_tape_rdlntr (UNIT *uptr, t_mtrlnt *bc)\r
{\r
uint8 c;\r
t_bool all_eof;\r
uint32 f = MT_GET_FMT (uptr);\r
t_addr ppos;\r
t_mtrlnt sbc;\r
t_tpclnt tpcbc;\r
\r
MT_CLR_PNU (uptr);\r
if ((uptr->flags & UNIT_ATT) == 0) return MTSE_UNATT;   /* not attached? */\r
if (sim_tape_bot (uptr)) return MTSE_BOT;               /* at BOT? */\r
switch (f) {                                            /* switch on fmt */\r
\r
    case MTUF_F_STD: case MTUF_F_E11:\r
        do {\r
            sim_fseek (uptr->fileref, uptr->pos - sizeof (t_mtrlnt), SEEK_SET);\r
            sim_fread (bc, sizeof (t_mtrlnt), 1, uptr->fileref);    /* read rec lnt */\r
            sbc = MTR_L (*bc);\r
            if (ferror (uptr->fileref))                 /* error? */\r
                return sim_tape_ioerr (uptr);\r
            if (feof (uptr->fileref)) return MTSE_EOM;  /* eof? */\r
            uptr->pos = uptr->pos - sizeof (t_mtrlnt);  /* spc over rec lnt */\r
            if (*bc == MTR_EOM) return MTSE_EOM;        /* eom? */\r
            if (*bc == MTR_TMK) return MTSE_TMK;        /* tape mark? */\r
            if ((*bc & MTR_M_RHGAP) == MTR_RHGAP) {     /* half gap? */\r
                uptr->pos = uptr->pos + sizeof (t_mtrlnt) / 2;  /* half space rev */\r
                sim_fseek (uptr->fileref, uptr->pos, SEEK_SET); /* resync */\r
                }\r
            else if (*bc != MTR_GAP) {\r
                uptr->pos = uptr->pos - sizeof (t_mtrlnt) - /* spc over record */\r
                    ((f == MTUF_F_STD)? ((sbc + 1) & ~1): sbc);\r
                sim_fseek (uptr->fileref, uptr->pos + sizeof (t_mtrlnt), SEEK_SET);\r
                }\r
            else if (sim_tape_bot (uptr))               /* backed into BOT? */\r
                return MTSE_BOT;\r
        }\r
        while ((*bc == MTR_GAP) || (*bc == MTR_RHGAP));\r
        break;\r
\r
    case MTUF_F_TPC:\r
        ppos = sim_tape_tpc_fnd (uptr, (t_addr *) uptr->filebuf); /* find prev rec */\r
        sim_fseek (uptr->fileref, ppos, SEEK_SET);      /* position */\r
        sim_fread (&tpcbc, sizeof (t_tpclnt), 1, uptr->fileref);\r
        *bc = tpcbc;                                    /* save rec lnt */\r
        if (ferror (uptr->fileref))                     /* error? */\r
            return sim_tape_ioerr (uptr);\r
        if (feof (uptr->fileref)) return MTSE_EOM;      /* eof? */\r
        uptr->pos = ppos;                               /* spc over record */\r
        if (*bc == MTR_TMK) return MTSE_TMK;            /* tape mark? */\r
        sim_fseek (uptr->fileref, uptr->pos + sizeof (t_tpclnt), SEEK_SET);\r
        break;\r
\r
    case MTUF_F_P7B:\r
        for (sbc = 1, all_eof = 1; (t_addr) sbc <= uptr->pos ; sbc++) {\r
            sim_fseek (uptr->fileref, uptr->pos - sbc, SEEK_SET);\r
            sim_fread (&c, sizeof (uint8), 1, uptr->fileref);\r
            if (ferror (uptr->fileref))                 /* error? */\r
                return sim_tape_ioerr (uptr);\r
            if (feof (uptr->fileref)) return MTSE_EOM;  /* eof? */\r
            if ((c & P7B_DPAR) != P7B_EOF) all_eof = 0;\r
            if (c & P7B_SOR) break;                     /* start of record? */\r
            }\r
        uptr->pos = uptr->pos - sbc;                    /* update position */\r
        *bc = sbc;                                      /* save rec lnt */\r
        sim_fseek (uptr->fileref, uptr->pos, SEEK_SET); /* for read */\r
        if (all_eof) return MTSE_TMK;                   /* tape mark? */\r
        break;\r
\r
    default:\r
        return MTSE_FMT;\r
        }\r
\r
return MTSE_OK;\r
}\r
\r
/* Read record forward\r
\r
   Inputs:\r
        uptr    =       pointer to tape unit\r
        buf     =       pointer to buffer\r
        bc      =       pointer to returned record length\r
        max     =       maximum record size\r
   Outputs:\r
        status  =       operation status\r
\r
   exit condition       position\r
\r
   unit unattached      unchanged\r
   read error           unchanged, PNU set\r
   end of file/medium   unchanged, PNU set\r
   invalid record       unchanged, PNU set\r
   tape mark            updated\r
   data record          updated\r
   data record error    updated\r
*/\r
\r
t_stat sim_tape_rdrecf (UNIT *uptr, uint8 *buf, t_mtrlnt *bc, t_mtrlnt max)\r
{\r
uint32 f = MT_GET_FMT (uptr);\r
t_mtrlnt i, tbc, rbc;\r
t_addr opos;\r
t_stat st;\r
\r
opos = uptr->pos;                                       /* old position */\r
if (st = sim_tape_rdlntf (uptr, &tbc)) return st;       /* read rec lnt */\r
*bc = rbc = MTR_L (tbc);                                /* strip error flag */\r
if (rbc > max) {                                        /* rec out of range? */\r
    MT_SET_PNU (uptr);\r
    uptr->pos = opos;\r
    return MTSE_INVRL;\r
    }\r
i = sim_fread (buf, sizeof (uint8), rbc, uptr->fileref);        /* read record */\r
if (ferror (uptr->fileref)) {                           /* error? */\r
    MT_SET_PNU (uptr);\r
    uptr->pos = opos;\r
    return sim_tape_ioerr (uptr);\r
    }\r
for ( ; i < rbc; i++) buf[i] = 0;                       /* fill with 0's */\r
if (f == MTUF_F_P7B) buf[0] = buf[0] & P7B_DPAR;        /* p7b? strip SOR */\r
return (MTR_F (tbc)? MTSE_RECE: MTSE_OK);\r
}\r
\r
/* Read record reverse\r
\r
   Inputs:\r
        uptr    =       pointer to tape unit\r
        buf     =       pointer to buffer\r
        bc      =       pointer to returned record length\r
        max     =       maximum record size\r
   Outputs:\r
        status  =       operation status\r
\r
   exit condition       position\r
\r
   unit unattached      unchanged\r
   read error           unchanged\r
   end of file          unchanged\r
   end of medium        updated\r
   invalid record       unchanged\r
   tape mark            updated\r
   data record          updated\r
   data record error    updated\r
*/\r
\r
t_stat sim_tape_rdrecr (UNIT *uptr, uint8 *buf, t_mtrlnt *bc, t_mtrlnt max)\r
{\r
uint32 f = MT_GET_FMT (uptr);\r
t_mtrlnt i, rbc, tbc;\r
t_stat st;\r
\r
if (st = sim_tape_rdlntr (uptr, &tbc)) return st;       /* read rec lnt */\r
*bc = rbc = MTR_L (tbc);                                /* strip error flag */\r
if (rbc > max) return MTSE_INVRL;                       /* rec out of range? */\r
i = sim_fread (buf, sizeof (uint8), rbc, uptr->fileref);        /* read record */\r
if (ferror (uptr->fileref))                             /* error? */\r
    return sim_tape_ioerr (uptr);\r
for ( ; i < rbc; i++) buf[i] = 0;                       /* fill with 0's */\r
if (f == MTUF_F_P7B) buf[0] = buf[0] & P7B_DPAR;        /* p7b? strip SOR */\r
return (MTR_F (tbc)? MTSE_RECE: MTSE_OK);\r
}\r
\r
/* Write record forward\r
\r
   Inputs:\r
        uptr    =       pointer to tape unit\r
        buf     =       pointer to buffer\r
        bc      =       record length\r
   Outputs:\r
        status  =       operation status\r
\r
   exit condition       position\r
\r
   unit unattached      unchanged\r
   write protect        unchanged\r
   write error          unchanged, PNU set\r
   data record          updated\r
*/\r
\r
t_stat sim_tape_wrrecf (UNIT *uptr, uint8 *buf, t_mtrlnt bc)\r
{\r
uint32 f = MT_GET_FMT (uptr);\r
t_mtrlnt sbc;\r
\r
MT_CLR_PNU (uptr);\r
sbc = MTR_L (bc);\r
if ((uptr->flags & UNIT_ATT) == 0) return MTSE_UNATT;   /* not attached? */\r
if (sim_tape_wrp (uptr)) return MTSE_WRP;               /* write prot? */\r
if (sbc == 0) return MTSE_OK;                           /* nothing to do? */\r
sim_fseek (uptr->fileref, uptr->pos, SEEK_SET);         /* set pos */\r
switch (f) {                                            /* case on format */\r
\r
    case MTUF_F_STD:                                    /* standard */\r
        sbc = MTR_L ((bc + 1) & ~1);                    /* pad odd length */\r
    case MTUF_F_E11:                                    /* E11 */\r
        sim_fwrite (&bc, sizeof (t_mtrlnt), 1, uptr->fileref);\r
        sim_fwrite (buf, sizeof (uint8), sbc, uptr->fileref);\r
        sim_fwrite (&bc, sizeof (t_mtrlnt), 1, uptr->fileref);\r
        if (ferror (uptr->fileref)) {                   /* error? */\r
            MT_SET_PNU (uptr);\r
            return sim_tape_ioerr (uptr);\r
            }\r
        uptr->pos = uptr->pos + sbc + (2 * sizeof (t_mtrlnt));  /* move tape */\r
        break;\r
\r
    case MTUF_F_P7B:                                    /* Pierce 7B */\r
        buf[0] = buf[0] | P7B_SOR;                      /* mark start of rec */\r
        sim_fwrite (buf, sizeof (uint8), sbc, uptr->fileref);\r
        sim_fwrite (buf, sizeof (uint8), 1, uptr->fileref); /* delimit rec */\r
        if (ferror (uptr->fileref)) {                   /* error? */\r
            MT_SET_PNU (uptr);\r
            return sim_tape_ioerr (uptr);\r
            }\r
        uptr->pos = uptr->pos + sbc;                    /* move tape */\r
        break;\r
        }\r
\r
return MTSE_OK;\r
}\r
\r
/* Write metadata forward (internal routine) */\r
\r
t_stat sim_tape_wrdata (UNIT *uptr, uint32 dat)\r
{\r
MT_CLR_PNU (uptr);\r
if ((uptr->flags & UNIT_ATT) == 0) return MTSE_UNATT;   /* not attached? */\r
if (sim_tape_wrp (uptr)) return MTSE_WRP;               /* write prot? */\r
sim_fseek (uptr->fileref, uptr->pos, SEEK_SET);         /* set pos */\r
sim_fwrite (&dat, sizeof (t_mtrlnt), 1, uptr->fileref);\r
if (ferror (uptr->fileref)) {                           /* error? */\r
    MT_SET_PNU (uptr);\r
    return sim_tape_ioerr (uptr);\r
    }\r
uptr->pos = uptr->pos + sizeof (t_mtrlnt);              /* move tape */\r
return MTSE_OK;\r
}\r
\r
/* Write tape mark */\r
\r
t_stat sim_tape_wrtmk (UNIT *uptr)\r
{\r
if (MT_GET_FMT (uptr) == MTUF_F_P7B) {                  /* P7B? */\r
    uint8 buf = P7B_EOF;                                /* eof mark */\r
    return sim_tape_wrrecf (uptr, &buf, 1);             /* write char */\r
    }\r
return sim_tape_wrdata (uptr, MTR_TMK);\r
}\r
\r
/* Write end of medium */\r
\r
t_stat sim_tape_wreom (UNIT *uptr)\r
{\r
if (MT_GET_FMT (uptr) == MTUF_F_P7B) return MTSE_FMT;   /* cant do P7B */\r
return sim_tape_wrdata (uptr, MTR_EOM);\r
}\r
\r
/* Write erase gap\r
\r
   Inputs:\r
        uptr    = pointer to tape unit\r
        gaplen  = length of gap in tenths of an inch\r
        bpi     = current recording density in bytes per inch\r
\r
   Outputs:\r
        status  = operation status\r
\r
   exit condition       position\r
   ------------------   ------------------\r
   unit unattached      unchanged\r
   unsupported format   unchanged\r
   write protected      unchanged\r
   read error           unchanged, PNU set\r
   write error          unchanged, PNU set\r
   gap written          updated\r
\r
\r
   An erase gap is represented in the tape image file by a special metadata\r
   value.  This value is chosen so that it is still recognizable even if it has\r
   been "cut in half" by a subsequent data overwrite that does not end on a\r
   metadatum-sized boundary.  In addition, a range of metadata values are\r
   reserved for detection in the reverse direction.  Erase gaps are supported\r
   only in SIMH tape format.\r
\r
   This implementation supports erasing gaps in the middle of a populated tape\r
   image and will always produce a valid image.  It also produces valid images\r
   when overwriting gaps with data records, with one exception: a data write\r
   that leaves only two bytes of gap remaining will produce an invalid tape.\r
   This limitation is deemed acceptable, as it is analogous to the existing\r
   limitation that data records cannot overwrite other data records without\r
   producing an invalid tape.\r
\r
   Because SIMH tape images do not carry physical parameters (e.g., recording\r
   density), overwriting a tape image file containing gap metadata is\r
   problematic if the density setting is not the same as that used during\r
   recording.  There is no way to establish a gap of a certain length\r
   unequivocally in an image file, so this implementation establishes a gap of a\r
   certain number of bytes that reflect the desired gap length at the bpi used\r
   during writing.\r
\r
   To write an erase gap, the implementation uses one of two approaches,\r
   depending on whether or not the current tape position is at EOM.  Erasing at\r
   EOM presents no special difficulties; gap metadata markers are written for\r
   the prescribed number of bytes.  If the tape is not at EOM, then erasing must\r
   take into account the existing record structure to ensure that a valid tape\r
   image is maintained.\r
\r
   The general approach is to erase for the nominal number of bytes but to\r
   increase that length, if necessary, to ensure that a partially overwritten\r
   data record at the end of the gap can be altered to maintain validity.\r
   Because the smallest legal tape record requires space for two metadata\r
   markers plus two data bytes, an erasure that would leave less than that\r
   is increased to consume the entire record.  Otherwise, the final record is\r
   truncated appropriately.\r
\r
   When reading in either direction, gap metadata markers are ignored (skipped)\r
   until a record length header, EOF marker, EOM marker, or physical EOF is\r
   encountered.  Thus, tape images containing gap metadata are transparent to\r
   the calling simulator.\r
\r
   The permissibility of data record lengths that are not multiples of the\r
   metadatum size presents a difficulty when reading.  If such an "odd length"\r
   record is written over a gap, half of a metadata marker will exist\r
   immediately after the trailing record length.\r
\r
   This condition is detected when reading forward by the appearance of a\r
   "reversed" marker.  The value appears reversed because the value is made up\r
   of half of one marker and half of the next.  This is handled by seeking\r
   forward two bytes to resync (the stipulation above that the overwrite cannot\r
   leave only two bytes of gap means that at least one "whole" metadata marker\r
   will follow).  Reading in reverse presents a more complex problem, because\r
   half of the marker is from the preceding trailing record length marker and\r
   therefore could be any of a range of values.  However, that range is\r
   restricted by the SIMH tape specification requirement that record length\r
   metadata values must have bits 30:24 set to zero.  This allows unambiguous\r
   detection of the condition.\r
\r
   The value chosen for gap metadata and the values reserved for "half-gap"\r
   detection are:\r
\r
     0xFFFFFFFE            - primary gap value\r
     0xFFFEFFFF            - reserved (indicates half-gap in forward reads)\r
     0xFFFF0000:0xFFFF00FF - reserved (indicates half-gap in reverse reads)\r
     0xFFFF8000:0xFFFF80FF - reserved (indicates half-gap in reverse reads)\r
 */\r
\r
t_stat sim_tape_wrgap (UNIT *uptr, uint32 gaplen, uint32 bpi)\r
{\r
t_stat st;\r
t_mtrlnt meta, sbc, new_len, rec_size;\r
t_addr gap_pos = uptr->pos;\r
uint32 file_size, marker_count;\r
uint32 format = MT_GET_FMT (uptr);\r
uint32 gap_alloc = 0;                                   /* gap allocated from tape */\r
int32 gap_needed = (gaplen * bpi) / 10;                 /* gap remainder still needed */\r
const uint32 meta_size = sizeof (t_mtrlnt);             /* bytes per metadatum */\r
const uint32 min_rec_size = 2 + sizeof (t_mtrlnt) * 2;  /* smallest data record size */\r
\r
MT_CLR_PNU (uptr);\r
\r
if ((uptr->flags & UNIT_ATT) == 0)                      /* not attached? */\r
    return MTSE_UNATT;\r
if (format != MTUF_F_STD)                               /* not SIMH fmt? */\r
    return MTSE_FMT;\r
if (sim_tape_wrp (uptr))                                /* write protected? */\r
    return MTSE_WRP;\r
\r
file_size = sim_fsize (uptr->fileref);                  /* get file size */\r
sim_fseek (uptr->fileref, uptr->pos, SEEK_SET);         /* position tape */\r
\r
/* Read tape records and allocate to gap until amount required is consumed.\r
\r
   Read next metadatum from tape:\r
    - EOF or EOM: allocate remainder of bytes needed.\r
    - TMK or GAP: allocate sizeof(metadatum) bytes.\r
    - Reverse GAP: allocate sizeof(metadatum) / 2 bytes.\r
    - Data record: see below.\r
\r
   Loop until bytes needed = 0.\r
*/\r
\r
do {\r
    sim_fread (&meta, meta_size, 1, uptr->fileref);     /* read metadatum */\r
\r
    if (ferror (uptr->fileref)) {                       /* read error? */\r
        uptr->pos = gap_pos;                            /* restore original position */\r
        MT_SET_PNU (uptr);                              /* position not updated */\r
        return sim_tape_ioerr (uptr);                   /* translate error */\r
        }\r
    else\r
        uptr->pos = uptr->pos + meta_size;              /* move tape over datum */\r
\r
    if (feof (uptr->fileref) || (meta == MTR_EOM)) {    /* at eof or eom? */\r
        gap_alloc = gap_alloc + gap_needed;             /* allocate remainder */\r
        gap_needed = 0;\r
        }\r
\r
    else if ((meta == MTR_GAP) || (meta == MTR_TMK)) {  /* gap or tape mark? */\r
        gap_alloc = gap_alloc + meta_size;              /* allocate marker space */\r
        gap_needed = gap_needed - meta_size;            /* reduce requirement */\r
        }\r
\r
    else if (meta == MTR_FHGAP) {                       /* half gap? */\r
        uptr->pos = uptr->pos - meta_size / 2;          /* backup to resync */\r
        sim_fseek (uptr->fileref, uptr->pos, SEEK_SET); /* position tape */\r
        gap_alloc = gap_alloc + meta_size / 2;          /* allocate marker space */\r
        gap_needed = gap_needed - meta_size / 2;        /* reduce requirement */\r
        }\r
\r
    else if (uptr->pos + \r
             MTR_L (meta) + meta_size > file_size) {    /* rec len out of range? */\r
        gap_alloc = gap_alloc + gap_needed;             /* presume overwritten tape */\r
        gap_needed = 0;                                 /* allocate remainder */\r
        }\r
\r
/* Allocate a data record:\r
    - Determine record size in bytes (including metadata)\r
    - If record size - bytes needed < smallest allowed record size,\r
      allocate entire record to gap, else allocate needed amount and\r
      truncate data record to reflect remainder.\r
*/\r
    else {                                              /* data record */\r
        sbc = MTR_L (meta);                             /* get record data length */\r
        rec_size = ((sbc + 1) & ~1) + meta_size * 2;    /* overall size in bytes */\r
\r
        if (rec_size < gap_needed + min_rec_size) {         /* rec too small? */\r
            uptr->pos = uptr->pos - meta_size + rec_size;   /* position past record */\r
            sim_fseek (uptr->fileref, uptr->pos, SEEK_SET); /* move tape */\r
            gap_alloc = gap_alloc + rec_size;               /* allocate record */\r
            gap_needed = gap_needed - rec_size;             /* reduce requirement */\r
            }\r
\r
        else {                                              /* record size OK */\r
            uptr->pos = uptr->pos - meta_size + gap_needed; /* position to end of gap */\r
            new_len = MTR_F (meta) | (sbc - gap_needed);    /* truncate to new len */\r
            st = sim_tape_wrdata (uptr, new_len);           /* write new rec len */\r
\r
            if (st != MTSE_OK) {                            /* write OK? */\r
                uptr->pos = gap_pos;                        /* restore orig pos */\r
                return st;                                  /* PNU was set by wrdata */\r
                }\r
\r
            uptr->pos = uptr->pos + sbc - gap_needed;       /* position to end of data */\r
            st = sim_tape_wrdata (uptr, new_len);           /* write new rec len */\r
\r
            if (st != MTSE_OK) {                            /* write OK? */\r
                uptr->pos = gap_pos;                        /* restore orig pos */\r
                return st;                                  /* PNU was set by wrdata */\r
                }\r
\r
            gap_alloc = gap_alloc + gap_needed;             /* allocate remainder */\r
            gap_needed = 0;\r
            }\r
        }\r
    }\r
while (gap_needed > 0);\r
\r
uptr->pos = gap_pos;                                    /* reposition to gap start */\r
\r
if (gap_alloc & (meta_size - 1)) {                      /* gap size "odd?" */\r
    st = sim_tape_wrdata (uptr, MTR_FHGAP);             /* write half gap marker */\r
    if (st != MTSE_OK) {                                /* write OK? */\r
        uptr->pos = gap_pos;                            /* restore orig pos */\r
        return st;                                      /* PNU was set by wrdata */\r
        }\r
    uptr->pos = uptr->pos - meta_size / 2;              /* realign position */\r
    gap_alloc = gap_alloc - 2;                          /* decrease gap to write */\r
    }\r
\r
marker_count = gap_alloc / meta_size;                   /* count of gap markers */\r
\r
do {\r
    st = sim_tape_wrdata (uptr, MTR_GAP);               /* write gap markers */\r
    if (st != MTSE_OK) {                                /* write OK? */\r
        uptr->pos = gap_pos;                            /* restore orig pos */\r
        return st;                                      /* PNU was set by wrdata */\r
        }\r
    }\r
while (--marker_count > 0);\r
\r
return MTSE_OK;\r
}\r
\r
/* Space record forward */\r
\r
t_stat sim_tape_sprecf (UNIT *uptr, t_mtrlnt *bc)\r
{\r
t_stat st;\r
\r
st = sim_tape_rdlntf (uptr, bc);                        /* get record length */\r
*bc = MTR_L (*bc);\r
return st;\r
}\r
\r
/* Space record reverse */\r
\r
t_stat sim_tape_sprecr (UNIT *uptr, t_mtrlnt *bc)\r
{\r
t_stat st;\r
\r
if (MT_TST_PNU (uptr)) {\r
    MT_CLR_PNU (uptr);\r
    *bc = 0;\r
    return MTSE_OK;\r
    }\r
st = sim_tape_rdlntr (uptr, bc);                        /* get record length */\r
*bc = MTR_L (*bc);\r
return st;\r
}\r
\r
/* Rewind tape */\r
\r
t_stat sim_tape_rewind (UNIT *uptr)\r
{\r
uptr->pos = 0;\r
MT_CLR_PNU (uptr);\r
return MTSE_OK;\r
}\r
\r
/* Reset tape */\r
\r
t_stat sim_tape_reset (UNIT *uptr)\r
{\r
MT_CLR_PNU (uptr);\r
return SCPE_OK;\r
}\r
\r
/* Test for BOT */\r
\r
t_bool sim_tape_bot (UNIT *uptr)\r
{\r
uint32 f = MT_GET_FMT (uptr);\r
\r
return (uptr->pos <= fmts[f].bot)? TRUE: FALSE;\r
}\r
\r
/* Test for end of tape */\r
\r
t_bool sim_tape_eot (UNIT *uptr)\r
{\r
return (uptr->capac && (uptr->pos >= uptr->capac))? TRUE: FALSE;\r
}\r
\r
/* Test for write protect */\r
\r
t_bool sim_tape_wrp (UNIT *uptr)\r
{\r
return (uptr->flags & MTUF_WRP)? TRUE: FALSE;\r
}\r
\r
/* Process I/O error */\r
\r
t_stat sim_tape_ioerr (UNIT *uptr)\r
{\r
perror ("Magtape library I/O error");\r
clearerr (uptr->fileref);\r
return MTSE_IOERR;\r
}\r
\r
/* Set tape format */\r
\r
t_stat sim_tape_set_fmt (UNIT *uptr, int32 val, char *cptr, void *desc)\r
{\r
int32 f;\r
\r
if (uptr == NULL) return SCPE_IERR;\r
if (cptr == NULL) return SCPE_ARG;\r
for (f = 0; f < MTUF_N_FMT; f++) {\r
    if (fmts[f].name && (strcmp (cptr, fmts[f].name) == 0)) {\r
        uptr->flags = (uptr->flags & ~MTUF_FMT) |\r
            (f << MTUF_V_FMT) | fmts[f].uflags;\r
        return SCPE_OK;\r
        }\r
    }\r
return SCPE_ARG;\r
}\r
\r
/* Show tape format */\r
\r
t_stat sim_tape_show_fmt (FILE *st, UNIT *uptr, int32 val, void *desc)\r
{\r
int32 f = MT_GET_FMT (uptr);\r
\r
if (fmts[f].name) fprintf (st, "%s format", fmts[f].name);\r
else fprintf (st, "invalid format");\r
return SCPE_OK;\r
}\r
\r
/* Map a TPC format tape image */\r
\r
uint32 sim_tape_tpc_map (UNIT *uptr, t_addr *map)\r
{\r
t_addr tpos;\r
t_tpclnt bc;\r
uint32 i, objc;\r
\r
if ((uptr == NULL) || (uptr->fileref == NULL)) return 0;\r
for (objc = 0, tpos = 0;; ) {\r
    sim_fseek (uptr->fileref, tpos, SEEK_SET);\r
    i = sim_fread (&bc, sizeof (t_tpclnt), 1, uptr->fileref);\r
    if (i == 0) break;\r
    if (map) map[objc] = tpos;\r
    objc++;\r
    tpos = tpos + ((bc + 1) & ~1) + sizeof (t_tpclnt);\r
    }\r
if (map) map[objc] = tpos;\r
return objc;\r
}\r
\r
/* Find the preceding record in a TPC file */\r
\r
t_addr sim_tape_tpc_fnd (UNIT *uptr, t_addr *map)\r
{\r
uint32 lo, hi, p;\r
\r
\r
if (map == NULL) return 0;\r
lo = 0;\r
hi = uptr->hwmark - 1;\r
do {\r
    p = (lo + hi) >> 1;\r
    if (uptr->pos == map[p])\r
        return ((p == 0)? map[p]: map[p - 1]);\r
    else if (uptr->pos < map[p]) hi = p - 1;\r
    else lo = p + 1;\r
    }\r
while (lo <= hi);\r
return ((p == 0)? map[p]: map[p - 1]);\r
}\r
\r
/* Set tape capacity */\r
\r
t_stat sim_tape_set_capac (UNIT *uptr, int32 val, char *cptr, void *desc)\r
{\r
extern uint32 sim_taddr_64;\r
t_addr cap;\r
t_stat r;\r
\r
if ((cptr == NULL) || (*cptr == 0)) return SCPE_ARG;\r
if (uptr->flags & UNIT_ATT) return SCPE_ALATT;\r
cap = (t_addr) get_uint (cptr, 10, sim_taddr_64? 2000000: 2000, &r);\r
if (r != SCPE_OK) return SCPE_ARG;\r
uptr->capac = cap * ((t_addr) 1000000);\r
return SCPE_OK;\r
}\r
\r
/* Show tape capacity */\r
\r
t_stat sim_tape_show_capac (FILE *st, UNIT *uptr, int32 val, void *desc)\r
{\r
if (uptr->capac) {\r
    if (uptr->capac >= (t_addr) 1000000)\r
        fprintf (st, "capacity=%dMB", (uint32) (uptr->capac / ((t_addr) 1000000)));\r
    else if (uptr->capac >= (t_addr) 1000)\r
        fprintf (st, "capacity=%dKB", (uint32) (uptr->capac / ((t_addr) 1000)));\r
    else fprintf (st, "capacity=%dB", (uint32) uptr->capac);\r
    }\r
else fprintf (st, "unlimited capacity");\r
return SCPE_OK;\r
}\r