diff options
Diffstat (limited to 'sys/mtio')
35 files changed, 3601 insertions, 0 deletions
diff --git a/sys/mtio/README b/sys/mtio/README new file mode 100644 index 00000000..143917e6 --- /dev/null +++ b/sys/mtio/README @@ -0,0 +1,45 @@ +MTIO -- Magtape i/o. This directory contains the FIO device driver for the +magtape devices plus MTOPEN (used to open a magtape device and hook it to +FIO) plus a few other routines. See ./doc for additional info. + + +USER ROUTINES + + yes|no = mtfile (fname) # Is fname a magtape device? + yes|no = mtneedfileno (mtname) # No file number given? + gty = mtcap (mtname) + mtfname (mtname, file, outstr, maxch) + + mtparse (mtname, device, fileno, recno, attrl, maxch) + mtencode (mtname, maxch, device, fileno, recno, attrl) + + fd = mtopen (mtname, acmode, bufsize) + mtrewind (mtname, initcache) + mtposition (mtname, file, record) + + Use CLOSE to close a file descriptor opened with mtopen. + Use GTYCLOSE to close a termcap descriptor opened with mtcap. + MTNAME is the full magtape device specification, i.e, "mt[...]". + + + +SYSTEM ROUTINES + + mtallocate (mtname) + mtdeallocate (mtname, rewind_tape) + mtstatus (out, mtname) + mtclean (level, stale, out) + + + +FIO DRIVER + + zopnmt (iodev, acmode, mtchan) + zclsmt (mtchan, status) + zardmt (mtchan, buf, maxbytes, offset) + zawrmt (mtchan, buf, nbytes, offset) + zawtmt (mtchan, status) + zsttmt (mtchan, what, lvalue) + + +All other procedures are internal to the interface. diff --git a/sys/mtio/doc/mtio.hlp b/sys/mtio/doc/mtio.hlp new file mode 100644 index 00000000..e00643a5 --- /dev/null +++ b/sys/mtio/doc/mtio.hlp @@ -0,0 +1,814 @@ +.help mtio Aug83 "Magnetic Tape I/O" +.sh +1. Introduction + + This document describes the Magnetic Tape I/O (MTIO) package, +i.e., the interface by which IRAF programs access magnetic tapes. +Included are the requirements and specifications for the package, +and a discussion of the interface between MTIO and FIO. + +.sh +2. MTIO Requirements +.ls 4 +.ls (1) +The machine independent part of the MTIO package shall be written in +the SPP language in compliance with the standards and conventions of IRAF. +.le +.ls (2) +The MTIO package shall provide a single interface to all magtape +devices on all IRAF target machines. +.le +.ls (3) +MTIO shall interface to FIO, making it possible to read and write a magtape +file via the FIO interface in a device independent fashion. +.le +.ls (4) +All functions shall take an error action if a hardware error occurs, +or if an illegal function is requested. +No hardware exception or trap shall occur while accessing a magtape +file via MTIO which is not caught by MTIO and converted into an +IRAF error action. +.le +.ls (5) +All error actions shall be defined symbolically in the system error +code file <syserr.h>. The MTIO error messages shall have the +form SYS_MT<function>, i.e., SYS_MTOPEN. The error message strings +shall be placed in the system error message file, "syserrmsg". +.le +.ls (6) +The MTIO code shall be divided into a machine independent part and +a machine dependent part. All machine independent function and error +checking shall be done in the machine independent part, to minimize +the size and complexity of the machine dependent part, and therefore +maximize the transportability of the package. +.le +.ls (7) +MTIO shall interface to FIO by implementing the standard FIO binary file +z-routines ZOPNMT, ZCLSMT, ZARDMT, ZAWRMT, ZAWTMT, and ZSTTMT. +The specifications for these routines are given elsewhere. +.le + +.sh +3. MTIO Specifications + + A magtape file is opened with MTOPEN and then accessed as a binary +file via the device independent FIO interface. Upon input, FIO merges +all tape records together into a binary byte stream. Upon output, +FIO writes records equal in size to the FIO buffers, unless FLUSH or +CLOSE is called, causing a partially filled buffer to be flushed to tape. +The data within a tape file may not be randomly accessed; only sequential +accesses are permitted. When i/o is complete, CLOSE should be called +to close the file and return all buffer space. + + fd = mtopen (filename, access_mode, buf_size) + +The format of a nonblank magnetic tape consists of beginning-of-tape (BOT), +followed by zero or more files, followed by end-of-tape (EOT). +Each file consists of one or more records, followed by a tape mark (EOF). +EOT is defined as two consecutive tape marks, i.e., as a file containing +zero records. MTIO knows nothing about labeled tapes. + +Tape records need not all be the same length, but for transportability +reasons records should be an integral number of computer words in length, +and very short records should be avoided (short records are used by some +operating systems for special purposes). The term "computer word" +is not well defined; the size of a tape record in bytes should be evenly +divisible by 2, 4, or 8, where the transportability increases with the +size of the divisor. To avoid loss of data when reading a tape, +the FIO buffer must be at least as large as the longest record on the tape. + +.sh +3.1 Opening a Magtape + + MTOPEN opens a file on the named magtape device. The following +device naming convention determines the tape drive and density: + + mt[a-z][800|1600|6250] + +The letter in the second field determines which drive is to be used, +and the third field, which is optional, determines the density. +If the density is not specified, a system or drive dependent default +density will be selected. Thus, to access a file on drive A at 1600 bpi, +one would open the file "mta1600". + +The significance of the terms "drive A", "drive B", etc., is installation +dependent, and need not imply distinct physical drives. A tape drive may +have to be allocated before it can be opened by MTIO; MTIO does not attempt +to allocate devices. + +The device name may optionally be followed by a subscript specifying +the index of the file to which the tape is to be positioned. +Thus, opening "mta[3]" causes device A to be opened with the default +density, positioned to BOF of the third file on the tape. +The field N, as in "mta[N]" may have the following values: + +.ls 4 +.ls 12 absent +If the entire subscript is absent, or if N is absent the tape is opened +at the current position, i.e., the tape is not physically moved. +.le +.ls N >= 1 +If an integer number greater than or equal to 1 (one) is given, +the tape is opened positioned to that file. +.le +.ls N == EOT +If the file number is given as "EOT" or as "eot", the tape is opened +positioned at EOT. +.le +.le + +If called with a non "mt"-prefixed file name, MTOPEN assumes that the file +is a regular disk resident binary file, and attempts to open the named +file. A program which normally reads directly from a magtape device may +therefore be used to read from a regular binary file, or from the +standard input (the special file "STDIN"). + +The following access modes are recognized by MTOPEN: +.ls 4 +.ls 12 READ_ONLY +The device is opened for reading, positioned to the beginning of +a file, BOT, EOT, or to the "current position". +Any attempt to write to the device will cause an error. +.le +.ls WRITE_ONLY +The device is opened for writing, positioned to the beginning of a file, +BOT, EOT, or to the "current position". When the file is subsequently +closed, a new EOT mark will be written. Existing tape files may be overwritten. +.le +.ls APPEND +The device is opened for writing, positioned at the end of tape (EOT). +Append mode must not be used with blank tapes. Note that the significance +of APPEND mode is different for MTOPEN than for a regular file open; +the tape is to be extended by adding a new file, whereas in FIO it is +the file itself which is extended. +.le +.ls NEW_TAPE +The device is opened for writing, positioned at BOT. Any existing +data on the tape is overwritten. Recommended mode for blank tapes. +.le +.le + +FIO can read any tape with a maximum record size less than or equal +to the buffer size. In buffered mode, FIO normally writes records equal +in size to the FIO internal buffers. Smaller records may be written if +FLUSH or CLOSE is called; records of any size may be written in unbuffered +mode. + +The third argument to MTOPEN is used to set the FIO buffer size. +If the buffer size is given as zero, a default value is used. +The default value chosen depends on the mode of access and upon the +maximum record size permitted by the host system. MTOPEN will automatically +allocate the maximum size FIO buffer if the tape is opened for reading. +The FIO buffer size may be changed in an FSET call anytime before +the first buffered i/o on the file. + +.sh +3.2 Ordinary I/O to a Magtape Device + + Seeks are not permitted on magtape files. A tape may be opened for +reading or for writing, but not for both at the same time. A magtape +device is much like the standard input and output; STDIN is read only, +STDOUT is write only, and seeking is not permitted on either. STDIN +differs from ordinary files in that data may continue to be read after +an EOF; the same is true of magtape files. If a read returning EOF is +followed by another read on a magtape device, the second read will +access the first record of the next file. Once EOT is reached, every +read will return EOF. There is no way to advance beyond EOT on a read. +An EOF mark may only be written by closing the tape (see next section). + +.sh +3.3 Closing a Magtape + + The CLOSE function is called either explicitly by the user task, +or implicilty by the IRAF main upon normal or abnormal task termination. +If the file was opened for writing, CLOSE flushes the output buffer and +writes an EOT mark at the current position. A file opened for writing +is left positioned ready to write the first record of the next file on +the tape (i.e., after the EOF of the file just written). A file opened +for reading, if closed immediately after reading EOF, is left positioned +ready to read or write the first record of the next file on the tape. + +.sh +3.4 Bytes and Records + + Upon input, the size of a record will be rounded up to an integral +number of "chars". No data will be lost, but one or more extra bytes of +data may be added. A tape conversion program which must deal with +odd-sized records must know the size of tape records to properly extract +the data. FIO cannot write odd-sized records. + +The binary i/o routines do not transform the data in any way, +including byte swapping. If byte swapping is necessary, the conversion +program must do the byte swapping explicitly. The predefined machine +constants BYTE_SWAP and WORD_SWAP indicate whether byte or word swapping +is necessary on the local machine (word swapping refers to the two 16 bit +words in a long integer). Floating point data should not be stored in +binary on tape, unless the tape is to be read only by the machine which +wrote it. + +Routines are available elsewhere in the PI for manipulating bytes. +The routines BYTMOV, BYTSWP, and BYTPAK are particularly useful for cracking +foreign tapes. + +.sh +3.5 Low level I/O to a Magtape + + The asynchronous, unbuffered FIO routines AREAD, AWRITE, and AWAIT +may be used to perform record i/o on a magtape. A single tape record +is read or written by each call; the FIO buffer is not used. AWAIT must +be called after each read or write, before initiating the next i/o transfer. +Although in general it is unwise to mix buffered and unbuffered i/o on +the same file, it is safe to perform one or more unbuffered transfers +immediately after opening a file, before performing any buffered i/o. + +If an application must do something peculiar, like write an odd-sized +record, the MTIO z-routines may be called directly. The z-routines transfer +data in units of machine bytes. + +.sh +3.6 CL level tape commands + + The four routines ALLOCATE, DEALLOCATE, REWIND and MTSTATUS will be +available at the CL level. A tape drive ("mta", "mtb", etc.) must be +explicitly allocated before it can be accessed with MTOPEN. +A drive may be allocated to only one user at a time. MTIO keeps track +of the position of an allocated tape; once a drive has been allocated, +the tape must not be manually positioned by the user. Tapes can be +changed without reallocating the drive provided REWIND is first used to +rewind the tape. DEALLOCATE automatically rewinds the tape before +deallocating the drive. MTSTATUS tells whether or not a particular drive +has been allocated, and if so, gives the name of the owner, the density, +whether not the device is physically open, and so on. + +.sh +3.6 Example + + The following program reads an ASCII card image file from the +input tape and converts it to an ordinary text stream, which is written +to the standard output. This program is insensitive to the number of +cards per tape record, and may be used to read card image disk files +as well as tape files. + +The following CL commands might be entered to read the second card image +file on the 800 bpi input tape into file "myfile", converting to lower case: + +.ks +.nf + cl> allocate mta + cl> rcardimage "mta800[2]" | lcase > myfile +.fi +.ke + + +The source for the program "rcardimage" follows: + + +.ks +.nf +# RCARDIMAGE -- CL callable task which reads a card image +# file, writing the converted cards to the standard output. + +procedure rcardimage() + +char filename[SZ_FNAME] +int input, mtopen() + +begin + call clgstr ("filename", filename, SZ_FNAME) + input = mtopen (filename, READ_ONLY, 0) + call read_card_image_file (input, STDOUT) + call close (input) +end +.fi +.ke + + + +.ks +.nf +define SZ_CARD 80 + +# READ_CARD_IMAGE_FILE -- Read the named card image file, convert +# to a regular character stream, and write to the output file. + +procedure read_card_image_file (input, output) + +int input, output # input, output files +char cardbuf[SZ_CARD] # raw card +char linebuf[SZ_CARD+1] # add 1 char for newline +int last_char +int read() +errchk read, putline + +begin + # Read successive cards until EOF is reached. Unpack the + # card, strip trailing whitespace, and write the processed + # line to the output file. + + while (read (input, cardbuf, SZ_CARD) != EOF) { + call chrupk (cardbuf, 1, linebuf, 1, SZ_CARD) + + # Strip trailing whitespace, add newline. + last_char = 0 + for (ip=1; ip <= SZ_CARD; ip=ip+1) + if (! IS_WHITE (linebuf[ip])) + last_char = ip + + linebuf[last_char+1] = '\n' + linebuf[last_char+2] = EOS + + call putline (output, linebuf) + } +end +.fi +.ke +.endhelp + + +.helpsys mtio Nov83 "MTIO Interface Detailed Design" +.sh +Strategies for Interfacing MTIO + + The specifications for MTIO have been kept as simple as possible for maximum +machine independence. There is only one high level call, MTOPEN, which is +used to open the device; it does little more than call FIO. Thereafter +everything is done through the six FIO z-routines: + +.nf + zopnmt (filespec, access_mode; channel|ERR) + zclsmt (channel) + zardmt (channel, buffer, maxbytes, one_indexed_byte_offset) + zawrmt (channel, buffer, nbytes, one_indexed_byte_offset) + zawtmt (channel; nbytes|ERR) + zsttmt (channel, parameter; long_value) +.fi + +These z-routines may be written in any language so long as they are SPP (i.e., +Fortran) callable. The "filespec" argument is a packed string. The access +modes and ERR code are system constants defined in <iraf.h>. Channel may be +anything you wish. The file offsets will always be zero since the magtape +device is a streaming (sequential) device. + +Be sure that the z-routines, if written partially in the SPP language, do not +make calls to high level program interface routines, especially any which do +i/o. Doing so violates the reentrancy restrictions of the SPP language (and +of Fortran). It may also lead to problems with the way libraries are searched. +More explicitly, any calls to error or iferr, to any of the FIO routines, or to +any of the printf or scan routines are absolutely forbidden. It is ok to use +the string primitives (because they do not do any i/o or call error), but it +is best to avoid even those if possible. It is perfectly all right to call +other z-routines provided they do not directly or indirectly call you back +(none will call mtio). + +.sh +Virtual Device Model + + Though in general the z-routines may have to be completely rewritten for +a new OS, in fact many systems have functionally similar primitive magtape +interfaces. If your system can be described by the model defined below, +the "z?*.x" files in this directory can be used unchanged, and all you need to +provide are the equivalents of the "zz" prefixed files. + + Basically, the model requires that the zz-routine which opens the magtape +be capable of positioning the tape to the first record of any file, given the +file number to which the tape is positioned at open time. The high level MTIO +interface code is charged with keeping track of the position of the tape at +all times, including while the tape is closed. The high level code does not +explicitly move the tape, though it does implicitly move it during open and when +it commands an i/o operation. The high level code assumes nothing about tape +motions; all zz-primitives return status values stating how many records or +files the tape moved in the last operation. Thus, the details of the function +of a zz-routine can vary depending on the system, without requiring +modifications to the z-routines. + +.ls 4 +.ls (1) +The following open/close primitives are required. ZZOPMT opens a tape +drive positioned ready to read or write the first record of the specified +file. +.ls zzopmt (drive,density,acmode, oldrec,oldfile; newfile; oschan|ERR) +.br +.ls 10 drive +Logical drive number (1,2,3,...). +.le +.ls density +Drive density. A positive integer, i.e., 800, 1600 or 6250. A value +of zero implies that an OS default density is to be selected. +.le +.ls acmode +Access mode. Read_only or write_only. Modes new_file and append are +dealt with by the "newfile" file number parameter. +.le +.ls oldrecord +The number of the record to which we are currently positioned in the +oldfile. We have to know this to know whether or not the file has to +be rewound. The first record is number one. +.le +.ls oldfile +The number of the file to which the tape is currently positioned. +.le +.ls newfile +The number of the file to be opened, where 1 specifies that the tape is +to be rewound. If newfile <= 0, open at EOT. On output, contains the +actual file number of the new file; this may differ from the requested +value if EOT is encountered. It is not an error (as far as the zz-routine +is concerned) to attempt to position to a file beyond EOT. +.le +.ls oschan +The channel number by which the file is to be referred in calls to the +other zz-routines, or ERR if the file cannot be opened. ZZOPMT should +set oschan IMMEDIATELY AFTER PHYSICALLY OPENING THE DEVICE, so that the +error recovery code can close the file if an interrupt occurs. +.le +.le + +.ls 4 zzclmt (oschan, access_mode; nfile) +Close tape. Write a new EOT at the current position if writing. +Returns the file number increment (in the event that a file mark or two +has to be written). +.le +.le + +.ls (2) +The following i/o primitives are required. +.ls zzrdmt (oschan, buf, maxbytes) +Initiate a read of up to maxbytes bytes from the next tape +record into buffer buf. It is not an error if fewer than "maxbytes" +bytes are read; in fact maxbytes will normally be larger than the largest +record on the tape. In general it is difficult to tell if the tape record +was larger than maxbytes; the user code should select a large maxbytes and +consider it an error if the full maxbytes are read. If EOF is encountered, +return a zero byte count in the next call to zzwtmt. +.le +.ls zzwrmt (oschan, buf, nbytes) +Initiate a write of "nbytes" bytes to the tape. It is an error +if all data is not written. +.le +.ls zzwtmt (oschan; nbytes|ERR, nrecord, nfile) +Wait for i/o to complete, and return the number of bytes read or +written in the last transfer; return 0 if we read a tape mark. +Keep returning the same thing in redundant calls. If an error +occurs the error status should be cleared when the next i/o +transfer is initiated. Return nrecord=1 for each tape record read, +but not for file marks. Return nfile=1 if a filemark is skipped. +A read of 0 bytes signifies that EOF was seen, but does not necessarily +imply that a tape mark has been skipped. +.le +.le +.le + +.sh +Program Structure + + The drive must be allocated before MTOPEN is called; MTOPEN verifies +that the drive has been allocated and then calls FIO to install the magtape +device and open the desired file on the drive. Allocating a file involves +a call to the OS to allocate and/or mount the device, followed by creation +of the device lock file in the dev$ directory. The lock file is used to +indicate that the drive has been allocated, and to keep track of the tape +position when the drive is closed. + + +.ks +.nf + mtopen + mt_parse_filespec + mt_get_tape_position + various FIO routines + fopnbf + zopnmt + zzopmt + zsttmt + fset [to set buffer size] + + + Structure of the MTOPEN Procedure +.fi +.ke + + +The ZCLSMT procedure is called by CLOSE to close a file opened with MTOPEN. +CLOSE may be called by the user, by the IRAF main if the task completes w/o +closing the file, or during error recovery. An error occurring during MTOPEN +may result in a call to CLOSE. We do not have to worry about reentrancy here +because none of the MTIO z-routines called by ZOPNMT call error (they will +return an ERR status to FOPNBF and therefore terminate before ZCLSMT is called). + + +.ks +.nf + close + zclsmt + mt_update_lockfile + smark,salloc,sfree + fvfn_to_osfn + mktemp + zopntx + zputtx + zclstx + zfdele + zfrnam + fatal + zzclmt + + + Structure of the ZCLSMT procedure +.fi +.ke + + +The i/o procedures keep track of the number of records read or written and +ensure that we do not read past EOF or EOT. We need to keep track of the +number of records written so that we can detect a null file write. + + +.ks +.nf + aread awrite + zardmt zawrmt + zzrdmt zzwrmt + + + await + zawtmt + zzwtmt + + + Structure of the I/O Procedures +.fi +.ke + + +The final routine is the ZSTTMT status procedure. This routine is self +contained, except that access to the MTIO common is required to get the +access mode (which determines the default buffer size). + + +.sh +Semicode + + We do as much of the work in MTOPEN as we can, since it is the only +high level, machine independent routine we have (we can call anything in this +routine without reentrancy problems). We check that the drive has been +allocated (to us), allocate an mtio device descriptor, check that the same +drive has not been reopened, parse the filespec and save the pieces in the +descriptor (for later use by ZOPNMT), read in the current tape position from +the lock file, and then call fopnbf which in turn calls ZOPNMT to open the +drive and position to the desired file. + + +.tp 8 +.nf +int procedure mtopen (filespec, access_mode, bufsize) + +begin + if (file not mt-prefixed) { + call open to open regular binary file + return (file descriptor returned by open) + } + + get mtio device descriptor slot but do not allocate it yet + if (slots all taken) + error: magtape device multiply opened (filespec) + call mt_parse_filespec to break out drivename, density, + filenumber and set up mtio device descriptor + if (drive is already open) + error: magtape device multiply opened (filespec) + check that the named drive has been allocated to us + if (drive not allocated to us) + error: magtape not allocated (filespec) + decode lock file to get old position of drive, save in + device descriptor + + call fopnbf to install the magtape device and open file + if (bufsize is nonzero) + call fset to set non-default FIO buffer size + + return (file descriptor) +end +.fi + + +ZOPNMT is passed a mostly initialized magtape file descriptor in the mtio +common by MTOPEN. The "filespec" string is not actually used by ZOPNMT. +We physically open the file and set up the remaining fields in the tape file +descriptor. NOTE: if an interrupt occurs during the call to ZZOPMT, +ZCLSMT will be called to perform error recovery. If this happens the +position of the tape is undefined. + + +.ks +.nf +procedure zopnmt (filespec, access_mode; chan|ERR) + +[we are passed the mtio file descriptor in the mtio common] + +begin + set flag for ZCLSMT in case we are interrupted + call ZZOPMT to open tape positioned to the beginning of the + indicated file. + + if (cannot open tape) + return (chan = ERR) + if (actual file < requested file) + if (reading) + set at-eof flag and at_eot flag, so that reads return EOF + else { + call zzclmt to close device + return (mtchan = ERR) + } + + save oschan in descriptor + save actual file number in descriptor + initialize the remaining descriptor fields + + return (chan = mtio descriptor index) +end +.fi +.ke + + +Opening a file for writing and then immediately closing it poses problems. +There is no way to write a zero-length file on an unlabeled tape. We cannot +just write a tape mark because that might mean writing a spurious double +tapemark (false EOT) in the middle of the tape. We could just ignore the +request and not write any file, but that is not quite right either (if a +disk file is opened for writing and then immediately closed, a file is +still created). We compromise by writing a single short record containing +the packed ASCII character string "NULLFILE". The actual length of the +physical nullfile record is machine dependent. + +We may or may not need to bump the file counter when the file is closed; +the OS tells us which. If we have just written a file and ZZCLMT must +write a tape mark, for example, we might be left positioned before EOT, +between the tape marks, or (unlikely) after the tape marks. + +If an error (i.e., console interrupt) occurs while the tape is being +positioned by ZZOPMT, we will be called by the error recovery system +with a garbage mtchan argument. We must be able to detect this type +of call and modify the lock file, marking the position of the tape +as UNDEFINED. The next open call will then automatically rewind the +tape, ensuring accurate positioning. In a normal close we write out +a lockfile identifying the file and record to which the tape is positioned. + + +.ks +.nf +procedure zclsmt (mtchan) + +begin + if (error recovery in progress for ZOPNMT) + mark current position as undefined + else { + if (file was opened for writing but nothing was written) + write out "null file" short record + + call zzclmt (oschan, access_mode; nfiles) + file += nfiles + if (nfiles > 0) + record = 1 + } + + call mt_update_lockfile to save tape status, position + deallocate the mtio device descriptor slot +end +.fi +.ke + + +Ignore all read requests once EOF or EOT has been reached. The only operation +possible at that point is to close the device; there is no rewind or backskip +function for a streaming device. We do not "know" what would happen if we +called ZZRDMT after reaching EOF; this is OS dependent, and we do not want +to require any particular behavior (some systems would return the first +record of the next file, others would keep returning EOF). + + +.ks +.nf +procedure zardmt (mtchan, buf, maxbytes, offset) + +begin + if (not at EOF or EOT) + call zzrdmt (oschan, buf, maxbytes) +end +.fi +.ke + + +We cannot hit EOF or EOT on a write, so merely post the request and return. +Ignore the "offset" parameter since magtape is a streaming device. + + +.ks +.nf +procedure zawrmt (mtchan, buf, nbytes, offset) + +begin + call zzwrmt (oschan, buf, nbytes) +end +.fi +.ke + + +FIO insures that ZAWTMT is called once and only once after every asynchronous +i/o read or write request. Once we hit EOF or EOT on a read, we return +EOF (nchars = 0) on every subsequent request until the file is closed. +After each real data transfer we update the record,file counters as +directed by the OS. + + +.ks +.nf +procedure zawtmt (mtchan; status) + +begin + if (reading and at EOF or EOT) + return (status = 0) + + call zzwtmt (oschan, nchars, nrecords_skipped, nfiles_skipped) + if (nfiles_skipped > 0) { + set at-EOF flag + record = 1 + } + + file += nfiles_skipped # keep track of position + record += nrecords_skipped + nrecords += nrecords_skipped # count records rd|wr + + status = nchars +end +.fi +.ke + +.sh +Error Recovery + + Error recovery during magtape operations is tricky since we are trying +to keep track of the position of the drive. If an error occurs while the +tape is being positioned by ZZOPMT we must detect the condition and mark the +position of the tape as indefinite (forcing a rewind on the next open). +If an interrupt occurs while positioning to EOT for a write, we do not +want ZZCLMT to write the new EOT mark somewhere in the middle of the tape, +truncating the tape. + + Interrupts or other errors while reading or writing are comparatively +harmless. Interrupting a write results in a short but otherwise normal +file on the tape; interrupting a read leaves us positioned to some +arbitrary record within the file (harmless). Conceivably a read +could be interrupted just as we were reading a tape mark, causing the +file position to be lost. We have not protected against this. + +.sh +Data Structures + + The mtio device descriptor structure describes the status of each magtape +device in use. The maximum number of magtape files which can be open at one +time is the maximum number of tape drives. Only one file can be open on each +drive at a time. + + +.ks +.nf + struct mtiodes { + int mt_drive # 1,2, etc. (c.t. a,b,...) + int mt_density # 0,800,1600,6250, etc. + int mt_oldfile # file number at open time + int mt_oldrecord # record number at open time + int mt_file # file being accessed (0=EOT) + int mt_record # next record to be accessed + int mt_nrecords # nrecords read/written + int mt_acmode # access mode + int mt_oschan # OS channel number + int mt_ateof # true when at EOF + int mt_ateot # true when at EOT + } mtiocom[MAX_TAPES] +.fi +.ke + + +When a device is allocated, a lock file is created in the system logical device +directory "dev$". For example, the lock file for magtape unit A is the +file "dev$mta.lok". This is a human readable text file; it is typed out on +the terminal when the user types "devstatus mta". The lock file is updated +when the drive is closed and deleted when the drive is deallocated. The drive +is automatically deallocated when the user logs out of the CL. + + +.ks +.nf +Sample Lock File: + + # Magtape unit 'mta' allocated to 'user' Sun 20:06:13 27-Nov-83 + current file = 4 + current record = 1 + 72 records read, EOF seen +.fi +.ke + + +The preliminary comments are written when the lock file is created, i.e., +when the device is allocated. Any number of comment lines are permitted. +They are merely copied when ZCLSMT updates the lock file. The remaining +records are written by ZCLSMT to record the current position of the tape, +and to inform the user of the device status. diff --git a/sys/mtio/doc/newdriver.notes b/sys/mtio/doc/newdriver.notes new file mode 100644 index 00000000..3ef2ca7f --- /dev/null +++ b/sys/mtio/doc/newdriver.notes @@ -0,0 +1,517 @@ + NEW IRAF MAGTAPE DRIVER + October 1991 + (design notes) + + +1. User Interface + +1.1 Magtape Specification + + Old format: + + mtX.density[file.record] + + New format: + + mtX['['file[.record][:(param|param@|param=value):...]']'] + + e.g., + + mtexb1[4:nb:se@:ts=1200:so=/dev/ttya8] + + mtX is used only as an index into the devices file, and is not + parsed. The tape density is no longer singled out as a special + parameter. If any parameters are specified, these parameters + override those given in the tapecap file entry. + + +1.2 TAPECAP file + + Current Format: + + irafname [%NNNN] device aliases + e.g., mtb.9 nrst8 rst8 nrst0 rst0 + + Revised Format: + + name[|alias|...]:cap=value:...:[tc=name:] + + Device parameters are specified in termcap file format. + + mta|mtexb1|Exabyte drive 1:\ + :dv=nrst0:rd=rst0:\ + :al=rst0,rst8,rst16,rst24,nrst0,nrst8,nrst16,nrst24:\ + :tc=exb-sunst: + exb-sunst|Exabyte via SunOS ST driver:\ + :bs#0:dt=Exabyte:fs#2200:mr#65535: + + This feature will use the new GTY interface. Modifications are + required to 1) allow specification of parameters at open time which + will override those given in the file, and 2) make the use of a # + for numeric parameters optional (accept either # or =). + + +1.3 I/O Monitoring + + Device and tape type and capacity are given in tapecap. + Keep track of tape usage along with file position in lock file. + Lock file provides simple means to track usage. A real time + display may optionally be provided by the driver writing to + a tape monitoring window via a file or socket, with the name + given in tapecap or on the command line. + + +2. Code Changes + + OS,KI + zfiomt.c - all host versions are affected as calling sequence + has changed. Network interface is affected (new tape system + and old iraf kernel servers are incompatible). + + The UNIX version of the new driver needs additional code to + optionally log status information to a file or special file. + Support for tcp/ip status logging as well? + + ETC + Device allocation code is affected by the devices file syntax + changes. + + MTIO + Must be changed to reflect magtape specfication and devices file + specification changes, i.e., the density parameter is omitted, + the device name is not quite the same thing, and a general + device parameter mechanism is added. + + The feature to keep track of the amount of tape used is device + and host independent (given adequate parameterization in the + devices file) hence can be implemented in MTIO. Output to the + user, and preservation of tape usage status over device closes, + will be via the .lok file and DEVSTATUS. + + The MTIO driver Z routines seem largely unaffected, except for + the status routine and the i/o routines, which need support added + for blocked devices. + + +3. Device Driver + +3.1. Device Classes + + generic generic device (open/close/read/write) + reel 800,1600,6250 bpi 1/2inch reel tape + cartridge various QIC formats - fixed size blocks + exabyte variable size blocks + dat variable size blocks + + +3.2. Device Parameters + +[[NOT KEPT UP TO DATE - refer to os$zfiomt.c for latest version. ]]]] + + CODE TYPE DEFAULT DESCRIPTION + + bs i 0 device block size (0 if variable) + dn i none density (bpi) + dt s generic drive type + fs i 0 filemark size (Kb) + mr i 65535 maximum record size + or i 63360 optimum record size + rs i 0 record gap size (bytes) + ts i 0 tape capacity (Mb) + tt s unknown tape type + + al s none device allocation info + dv s required no-rewind device file + rd s none rewind device file + so s none status output device file or socket + + bo b no BSF positions to BOF + fc b no device does a FSF on CLRO + ir b no treat all read errors as EOF + nb b no device cannot backspace + nf b no rewind and space forward to backspace file + np b no disable all positioning ioctls + ow b no backspace and overwrite EOT at append + re b no read at EOT returns ERR + rf b no use BSR,FSR to space over filemarks + se b no device will position past EOT in a read + sk b no skip record forward after a read error + wc b no OPWR-CLWR at EOF writes null file + + bf i builtin BSF ioctl code + br i builtin BSR ioctl code + ct i builtin MTIOCTOP code + ff i builtin FSF ioctl code + fr i builtin FSR ioctl code + ri i builtin REW ioctl code + + +3.3. Host Level Device Operations + + open (FILE I/O OPERATIONS) + close + read + write + wait (not used) + + FSR (POSITIONING IOCTLS) + BSR + FSF + BSF + REW + + WEOF (not used) + EOM (not used) (SunOS - space to end of media) + + +3.4. Device Characteristics + + open No known system/device dependencies. + + close For a tape opened read-only, close positions to after + the filemark of the current file on some SysV systems. + This makes it impossible to rewind a device opened + no-rewind (after the open/rewind/close the tape is + left at the beginning of the second file). On such + systems the tape can only be rewound (left rewound + at close) by opening and closing the rewind device. + + It is assumed that when a tape opened for writing is + closed an EOT mark is written, and the tape is left + positioned after the filemark of the last file + written, ready to write the next file (true on all + known systems, with some variations in how the EOT + is represented). + + read A read where the record size exceeds the size of the + read request is assumed to be an error. + + A read at end of file should return a zero byte + count and leave the file positioned after the file + mark. Some devices may return ERR when a tape mark + is read. + + If the device block size is zero it is assumed that + records can be any size up to the max record size, + and that successive records can vary in size. + + If the device block size is nonzero it is assumed + that the byte count for read and write requests (the + record size) should be a multiple of the device + block size. Multiple physical device blocks are + read or written to satisfy an i/o request. On a + read, all notion of the record size is lost, i.e., + a read of N blocks will return N blocks regardless + of the blocking factor used in a write. + + A read at EOT may leave the tape positioned after + the file mark just read or may result in a zero byte + count being returned with no affect on the tape + position. + + Following a read error when reading a data record the + tape may be left 1) before the bad record, 2) after + the bad record, 3) in an undefined position, e.g., + partway through the record. + + write For variable record devices each write is assumed + to write a tape record the size of the output buffer. + For fixed block devices it is assumed that the size + of the write request must be an integral multiple of + the block size, and that multiple physical device + blocks will be written to satisfy the request. + + wait Wait (asynchronous i/o) is not currently used and + is emulated in the driver. Some systems (Ultrix + and SunOS 4.1) provide facilities for multi-buffered + asynchronous i/o which the iraf driver may make use + of in the future. + + FSR Forward skip record. Some systems permit a FSR over + a filemark and some do not. + + BSR Backward skip record. Some systems permit a BSR over + a filemark and some do not. + + FSF Forward skip file. The tape is assumed to be left + positioned after the filemark and before the first + record of the next file. + + BSF Backward skip file. Some systems leave the tape + positioned on the BOT side of the filemark, others + leave the tape positioned to just before the first + record of the file following the filemark. A BSF with + a zero count may or may not rewind the current file. + + REW Rewinds the tape, leaving the tape positioned to BOT. + No known system/device dependencies. See the note + on the "close" operation, above. + + WEOF Not currently used. + + +3.5. Driver Options + + overwrite filemark (reel tapes only) + disable all backspace operations + skip record forward after a read error + i/o logging to specified output device + + +3.6. Driver Functions + + ZZOPMT - open and position to desired file + zmtopen + zmtclose + zmtposition + zmtrew + zmtfsf + zmtbsf + zmtfsr + zmtbsr + + ZZCLMT - close + zmtclose + + ZZRDMT - read next record + read + zmtbsf + + ZZWRMT - write record + write + + ZZWTMT - wait for i/o and return byte count + + ZZRWMT - rewind tape + zmtopen + zmtclose + + ZZSTMT - return device parameters + + +3.7. Notes on Specific Devices + +3.7.1 Device Characteristics + +3.7.2 Exabyte Drivers + + SunOS 4.1 ST Driver + BSF positions to BOT side of filemark (conventional behavior). + Driver does not allow positioning to after EOT. + Bug where driver loses track of file position is fixed. + + SunOS 4.0.3 ST Driver + BSF positions to first record of file following file mark. + BSF 0 rewinds the current file. + Driver does not allow positioning to after EOT, i.e., when + positioning to EOT, after two successive zero reads, + it is NOT necessary to backspace over the filemark. + Driver tries to keep track of current file position but has + a bug which causes it to zero its counter when appending + a file to a tape within open/close. + This bug has two ramifications: + o Will not position to a file before where it thinks + BOT is. + o Will rewind to get to file it thinks is at BOT. + + Earlier (SunOS 3.X) Sun drivers defaulted to fixed block mode, and + probably had other significant differences from the current + round of drivers. + + Ciprico RT Driver + Both fixed and variable block device entries. + rfsd_pr_errlog can get set to 1|2|8 in driver (/dev/mem) to + turn on status messages. Variable is commonly set to 2 + to get tape position readouts, but this will interfere + with iraf networking. + BSF positions to BOT side of filemark (conventional behavior). + EOT is indicated by two file marks, and a read of the second mark + will leave the tape positioned to after the mark, requiring + a backspace to position to EOT (conventional behavior). + Status (NOP) ioctl implemented, but file/record count always zero. + + Sparcstation (4.1) ST driver + BSR over a filemark confuses the driver - looks like it thinks + it saw the EOF when reading in the forward direction. + The next read returns EOF and then the real EOF is read, + so 2 EOFs in a row are seen (looks like EOT). The file + count in the driver gets messed up. + BSF causes all subsequent reads to return immediately with ERR. + One (sometimes two!) REW ioctls are required to clear. + FSF and FSR work. + + R-Squared driver for Exabyte (Sun-3 running 4.1) + Opens drive in fixed block mode. + Read at EOF returns IOERR (driver bug). + Status (NOP) ioctl not implemented. + + +3.8. Pseudocode for Driver Functions + + +# ZZOPMT -- Open the magtape device and position to the given file. + +procedure zzopmt (device, acmode, oldrec, oldfile, newfile, chan) +begin + # Open device for positioning. + open no-rewind raw device read-only + + # Do not move the tape if opened newfile=0. + if (newfile != 0) { + # Rewind to get to known position if position uncertain. + if (current position unknown) { + rewind tape + oldrec = 1 + oldfile = 1 + } + + # Position to given file. + newfile = zmtfpos (chan, oldfile, oldrec, newfile) + } + + # Reopen if necessary for i/o. + if (need write access) + reopen device for writing +end + + +# ZZCLMT -- Close the magtape device. + +procedure zzclmt (chan, acmode, nrecords, nfiles, status) +begin + close device + + nfiles = 0 + nrecords = 0 + + if (acmode == read && device: FSF on close read-only) + nfiles = 1 + else if (acmode == write && !(at BOF && device: no EOF if no write)) + nfiles = 1 +end + + +# ZZRDMT -- Initiate a read of the next tape record into the user buffer. + +procedure zzrdmt (chan, buf, maxbytes) +begin + physically read tape + save read status for zzwtmt +end + + +# ZZWRMT -- Initiate a write of the next tape record. + +procedure zzwrmt (chan, buf, nbytes) +begin + physically write record + save write status for zzwtmt +end + + +# ZZWTMT -- Wait for i/o to complete and return the byte count and the +# change to the tape position in files and records. + +procedure zzwtmt (chan, nrecords, nfiles, nbytes) +begin + nrecords = 0 + nfiles = 0 + + if (io error) { + nbytes = ERR + } else if (read 0 bytes) { + if (at BOF) { + # At EOT. + if (device: read at EOT will go past EOT) + if (device: cannot backspace) { + zmtrew() + nfiles = -ARB + nrecords = -ARB + } else + zmtbsf (1) + } else + nfiles = 1 + } else { + nrecords = 1 + clear at BOF flag + } +end + + +# ZZRWMT -- Rewind the named device. + +procedure zzrwmt (device, status) +begin + if (device: rewind device specified) + close (open (rewind-at-close device read-only)) + else { + open no rewind device + zmtrew + close + } +end + + +# ZMTFPOS -- Position to the indicated file. + +int procedure zmtfpos (chan, oldfile, oldrec, newfile) +begin + # Already positioned to desired file; don't do anything. + if (newfile == oldfile && oldrec == 1) + return (newfile) + + # Move the tape. + if (newfile == 1) { + # Rewind. + zzrwmt() + } else if (newfile <= oldfile && newfile != EOT) { + # Backspace to desired file. + if (device: cannot backspace) { + zmtrew() + oldfile = 1 + oldrec = 1 + goto fwd_ + } else if (device: BSF positions to BOF) { + zmtbsf (oldfile - newfile) + } else { + zmtbsf (oldfile - newfile + 1) + zmtfsf (1) + } + } else { + # Space forward to desired file or EOT. +fwd_ while (oldfile < newfile || newfile == EOT) { + n = read (next record) + if (n == 0 && oldrec == 1) { + # At EOT. + if (device: read at EOT will go past EOT) { + if (device: cannot backspace) { + newfile = oldfile + zmtrew() + oldfile = 1 + oldrec = 1 + goto fwd_ + } else + zmtbsf (1) + } + if (writing && device: overwrite EOF) { + if (!device: cannot backspace) { + if (device: BSF positions to BOF) + zmtbsf (0) + else { + zmtbsf (1) + zmtfsf (1) + } + } + } + break + } else if (n > 0) + zmtfsf (1) + + oldfile++ + oldrec = 1 + } + newfile = oldfile + } + + return (newfile) +end diff --git a/sys/mtio/mkpkg b/sys/mtio/mkpkg new file mode 100644 index 00000000..2c0ce77f --- /dev/null +++ b/sys/mtio/mkpkg @@ -0,0 +1,48 @@ +# Make the MTIO routines. + +$checkout libsys.a lib$ +$update libsys.a +$checkin libsys.a lib$ +$exit + +zzdebug: + $checkout libsys.a lib$ + $update libsys.a + $checkin libsys.a lib$ + + #$set XFLAGS = "$(XFLAGS) -qx" + $omake zzdebug.x + $link -z zzdebug.o + ; + +libsys.a: + #$set XFLAGS = "$(XFLAGS) -qx" + + mtalloc.x mtio.h <time.h> + mtcache.x mtcache.com mtio.com mtio.h <config.h> <error.h> + mtcap.x mtio.h + mtclean.x mtio.h <finfo.h> <xalloc.h> + mtdealloc.x <error.h> + mtdevall.x <knet.h> <xalloc.h> + mtencode.x + mtfile.x + mtfname.x mtio.h + mtglock.x mtio.h + mtgtyopen.x mtio.h + mtlocknam.x mtio.h <chars.h> <ctype.h> + mtneedf.x mtio.h + mtopen.x mtio.com mtio.h <config.h> <fset.h> <knet.h> <mach.h> + mtparse.x mtio.h <config.h> <ctype.h> + mtpos.x mtio.h + mtrdlock.x mtio.com mtio.h <config.h> + mtrewind.x mtio.h <error.h> + mtskip.x <fset.h> + mtstatus.x + mtupdlock.x mtio.com mtio.h <config.h> <knet.h> <mach.h> + zardmt.x mtio.com mtio.h <config.h> <knet.h> + zawrmt.x mtio.com mtio.h <config.h> <knet.h> + zawtmt.x mtio.com mtio.h <config.h> <knet.h> + zclsmt.x mtio.com mtio.h <config.h> <knet.h> + zopnmt.x mtio.com mtio.h <config.h> <knet.h> + zsttmt.x mtio.com mtio.h <config.h> <fio.h> <knet.h> <mach.h> + ; diff --git a/sys/mtio/mtalloc.x b/sys/mtio/mtalloc.x new file mode 100644 index 00000000..2e21be1c --- /dev/null +++ b/sys/mtio/mtalloc.x @@ -0,0 +1,64 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <time.h> +include "mtio.h" + +# MTALLOCATE -- "Allocate" a tape drive by writing the lock file. We do +# not actually call the OS to physically allocate the drive; that is done +# by our caller (e.g., xallocate, in etc$xalloc.x). The lock file is no longer +# used to gain exclusive access to the device; it is now used only to keep +# track of the tape position after process termination. + +procedure mtallocate (mtname) + +char mtname[ARB] #I device name + +int fd, junk +pointer sp, lockfile, mtowner, userid, timestr, device +errchk open, mtparse +long clktime() +int open() + +begin + call smark (sp) + call salloc (device, SZ_FNAME, TY_CHAR) + call salloc (lockfile, SZ_FNAME, TY_CHAR) + call salloc (mtowner, SZ_FNAME, TY_CHAR) + call salloc (userid, SZ_FNAME, TY_CHAR) + call salloc (timestr, SZ_TIME, TY_CHAR) + + # Get name of lockfile used by the given device. + call mtparse (mtname, Memc[device], SZ_FNAME, junk, junk, junk, 0) + call mt_glock (mtname, Memc[lockfile], SZ_FNAME) + + # Open lock file and write out unit, owner, time allocated, etc. + # Overwrite any existing lockfile. We are called only after + # physically allocating the device at the host system level + # (and are not called if the device is already allocated), so this + # is safe. + + iferr (call delete (Memc[lockfile])) + ; + fd = open (Memc[lockfile], NEW_FILE, TEXT_FILE) + + call cnvtime (clktime(long(0)), Memc[timestr], SZ_TIME) + call getuid (Memc[userid], SZ_FNAME) + + call fprintf (fd, "# Magtape unit %s status %s user %s\n") + call pargstr (Memc[device]) + call pargstr (Memc[timestr]) + call pargstr (Memc[userid]) + + # Assume initially that the tape position is undefined. This will + # cause the tape to be rewound on the first open, and thereafter + # the position will be defined unless an i/o error occurs. + + call fprintf (fd, "file = -1\n") + call fprintf (fd, "record = -1\n") + call fprintf (fd, "nfiles = 0\n") + call fprintf (fd, "tapeused = 0 Kb\n") + call fprintf (fd, "pflags = 0\n") + + call close (fd) + call sfree (sp) +end diff --git a/sys/mtio/mtcache.com b/sys/mtio/mtcache.com new file mode 100644 index 00000000..b3533f3f --- /dev/null +++ b/sys/mtio/mtcache.com @@ -0,0 +1,9 @@ +# MTIO savepos cache. + +int c_modified[SZ_CACHE] +int c_mtdes[LEN_DEVPOS,SZ_CACHE] +char c_device[SZ_DEVICE,SZ_CACHE] +char c_iodev[SZ_IODEV,SZ_CACHE] +char c_lkname[SZ_LKNAME,SZ_CACHE] + +common /mtcacm/ c_modified, c_mtdes, c_device, c_iodev, c_lkname diff --git a/sys/mtio/mtcache.x b/sys/mtio/mtcache.x new file mode 100644 index 00000000..87b68bdb --- /dev/null +++ b/sys/mtio/mtcache.x @@ -0,0 +1,199 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <config.h> +include <error.h> +include "mtio.h" + +.help mtcache +.nf _________________________________________________________________________ +MTCACHE -- Cache the magtape position (file and record) between file opens. +The lock file is used for permanent storage, but is only read and written +when necessary. When multiple tape files are accessed by a single task the +tape position is kept in the cache between successive MTOPEN - CLOSE file +accesses. + + mt_getpos (mtname, mt) + mt_savepos (mt) + mt_sync (status) + mt_clrcache () + +SAVEPOS updates the tape descriptor in the cache; SYNC updates the cache +on disk in the lock file. SYNC is automatically called at task termination +time (including during abnormal termination), but is not normally called +when a tape file is closed. + +ERROR RECOVERY is a bit tricky. If error recovery takes place the ONERROR +procedures are called first thing, before FIO cleanup takes place. That means +that SYNC will be called while the magtape channel is still open, and before +SAVEPOS has been called by ZCLSMT (which is called by fio_cleanup which is +called by the main). If an error occurs on a magtape channel we want to +record an undefined file position. We must see that SAVEPOS is called at +file open time to mark the cache for updating, causing SYNC to write an +undefined position lock file when the error occurs. ZCLSMT, when called +during error recovery, should set the position to undefined but need not +sync the cache. + +The cache is invalidated at process startup time and at SYNC time in case +the user loads a new tape or runs a different magtape process while the +current process is idling between tasks. In other words, the cache is only +valid while the task using it is executing. +.endhelp ___________________________________________________________________ + +define SZ_CACHE MT_MAXTAPES + + +# MT_GETPOS -- Return the device position descriptor of a drive given its +# unit number. + +procedure mt_getpos (mtname, mt) + +char mtname[ARB] #I device name +int mt #I MTIO descriptor + +int slot +bool streq() +include "mtcache.com" +include "mtio.com" + +begin + # First look in the cache. + for (slot=1; slot <= SZ_CACHE; slot=slot+1) + if (streq (MT_LKNAME(mt), c_lkname[1,slot])) { + call amovi (c_mtdes[1,slot], MT_DEVPOS(mt), LEN_DEVPOS) + call strcpy (c_device[1,slot], MT_DEVICE(mt), SZ_DEVICE) + call strcpy (c_lkname[1,slot], MT_LKNAME(mt), SZ_LKNAME) + call strcpy (c_iodev[1,slot], MT_IODEV(mt), SZ_IODEV) + return + } + + # Get the current position from the lock file, if there is one. + call mt_read_lockfile (mtname, mt) +end + + +# MT_SAVEPOS -- Save the current position in the cache. The entire descriptor +# is saved since most of the information therein is needed for SYNC, even +# though only a portion of the information will be used by GETPOS. + +procedure mt_savepos (mt) + +int mt #I MTIO descriptor + +int prev, slot +bool streq(), strne() +extern mt_sync() +include "mtcache.com" +include "mtio.com" +data prev /0/ +define cache_ 91 + +begin + # Post termination handler to sync the cache at task termination time. + call onerror (mt_sync) + + # Do not update the cache if the file position is undefined. + if (MT_FILNO(mt) <= 0) + return + + # Are we updating an entry already in the cache? + for (slot=1; slot <= SZ_CACHE; slot=slot+1) + if (streq (MT_LKNAME(mt), c_lkname[1,slot])) + goto cache_ + + # Add the entry to the cache. Resync the contents of the old slot + # if it is for a different drive and has been modified since it was + # last synced. + + slot = prev + 1 + if (slot > SZ_CACHE) + slot = 1 + prev = slot + + if (c_modified[slot] == YES && strne(MT_LKNAME(mt),c_lkname[1,slot])) { + call amovi (c_mtdes[1,slot], MT_DEVPOS(0), LEN_DEVPOS) + call strcpy (c_device[1,slot], MT_DEVICE(0), SZ_DEVICE) + call strcpy (c_lkname[1,slot], MT_LKNAME(0), SZ_LKNAME) + call strcpy (c_iodev[1,slot], MT_IODEV(0), SZ_IODEV) + call mt_update_lockfile (0) + } + +cache_ + call amovi (MT_DEVPOS(mt), c_mtdes[1,slot], LEN_DEVPOS) + call strcpy (MT_DEVICE(mt), c_device[1,slot], SZ_DEVICE) + call strcpy (MT_LKNAME(mt), c_lkname[1,slot], SZ_LKNAME) + call strcpy (MT_IODEV(mt), c_iodev[1,slot], SZ_IODEV) + c_modified[slot] = YES +end + + +# MT_SYNC -- Update all modified entries in the cache. Set the position to +# undefined (file=-1) if we are called during error recovery. We are called +# at task termination by the IRAF Main. + +procedure mt_sync (status) + +int status #I task termination status + +int slot +include "mtcache.com" +include "mtio.com" + +begin + # Update the .lok files of any active devices. + for (slot=1; slot <= SZ_CACHE; slot=slot+1) { + if (c_modified[slot] == YES) { + # If called during error recovery mark the file position undef. + if (status != OK) { + call amovi (c_mtdes[1,slot], MT_DEVPOS(0), LEN_DEVPOS) + MT_FILNO(0) = -1 + MT_RECNO(0) = -1 + call amovi (MT_DEVPOS(0), c_mtdes[1,slot], LEN_DEVPOS) + } + + # Update the lockfile. + call amovi (c_mtdes[1,slot], MT_DEVPOS(0), LEN_DEVPOS) + call strcpy (c_device[1,slot], MT_DEVICE(0), SZ_DEVICE) + call strcpy (c_lkname[1,slot], MT_LKNAME(0), SZ_LKNAME) + call strcpy (c_iodev[1,slot], MT_IODEV(0), SZ_IODEV) + + # Ignore errors if we are called during error recovery. + iferr (call mt_update_lockfile (0)) + if (status == OK) + call erract (EA_ERROR) + + c_modified[slot] = NO + c_device[1,slot] = EOS + } + } + + # Invalidate the cache when a task terminates. + call mt_clrcache() + + # If we are called during error recovery, set the file position for + # all open tapes to undefined to prevent mt_savepos from being called + # by zclsmt when the tape file is closed during error recovery. + + if (status != OK) + do slot = 1, MT_MAXTAPES { + MT_FILNO(slot) = -1 + MT_RECNO(slot) = -1 + } +end + + +# MT_CLRCACHE -- Initialize the cache. + +procedure mt_clrcache() + +int slot +include "mtcache.com" + +begin + for (slot=1; slot <= SZ_CACHE; slot=slot+1) { + c_modified[slot] = NO + c_device[1,slot] = EOS + c_lkname[1,slot] = EOS + c_iodev[1,slot] = EOS + call aclri (c_mtdes[1,slot], LEN_DEVPOS) + } +end diff --git a/sys/mtio/mtcap.x b/sys/mtio/mtcap.x new file mode 100644 index 00000000..d3f859fa --- /dev/null +++ b/sys/mtio/mtcap.x @@ -0,0 +1,36 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include "mtio.h" + +# MTCAP -- Return the tapecap descriptor for the given magtape device. The +# device is specified by the full specification (as passed to mtopen), hence +# there may be tapecap attributes in the device specification which override +# those in the tapecap file. + +pointer procedure mtcap (mtname) + +char mtname[ARB] #I magtape device specification + +int fileno, recno +pointer sp, device, devcap, cache_gty, gty +pointer mt_gtyopen(), gtycaps(), gtyopen() +errchk mtparse, mt_gtyopen + +begin + call smark (sp) + call salloc (device, SZ_DEVICE, TY_CHAR) + call salloc (devcap, SZ_DEVCAP, TY_CHAR) + + call mtparse (mtname, Memc[device], SZ_DEVICE, fileno, recno, + Memc[devcap], SZ_DEVCAP) + + # Do not return the cached MTIO device entry, as we do not want the + # application to close this with gtyclose. Open a new GTY descriptor + # using the capabilities in the cached entry. + + cache_gty = mt_gtyopen (Memc[device], Memc[devcap]) + gty = gtyopen ("", "", Memc[gtycaps(cache_gty)]) + + call sfree (sp) + return (gty) +end diff --git a/sys/mtio/mtclean.x b/sys/mtio/mtclean.x new file mode 100644 index 00000000..5de01a7e --- /dev/null +++ b/sys/mtio/mtclean.x @@ -0,0 +1,110 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <finfo.h> +include <xalloc.h> +include "mtio.h" + +# MTCLEAN -- Clean the lock file area. This routine is called periodically +# by the system (e.g. during CL startup) to scan the lock file area and +# deleted old lock files. This prevents old lock files which are no longer +# valid from erroneously being used to indicate the current tape position. +# +# What mtclean does is similar to "delete tmp$mt*.lok" except that, since all +# users store lok files in the same area, we don't want to delete all the +# files indiscriminately. The default action is to delete only files for +# unallocated devices, or for devices allocated to the current user for which +# the lok file is more than STALE seconds old. It is harmless to delete a +# lok file unnecessarily in that MTIO will recover automatically, but doing +# so will force the tape to be rewound to regain a known position. + +procedure mtclean (level, stale, out) + +int level #I 0 for default; 1 to delete all .lok files +int stale #I delete lok file if older than stale seconds +int out #I if nonzero, print messages to this file + +int fd, status +pointer list, ip, cp, device +pointer sp, fname, owner, template, lbuf +long fi[LEN_FINFO] + +pointer fntopn() +long clktime() +int gstrmatch(), xdevowner() +int open(), getline(), finfo(), fntgfn() +define del_ 91 + +begin + call smark (sp) + call salloc (lbuf, SZ_LINE, TY_CHAR) + call salloc (fname, SZ_FNAME, TY_CHAR) + call salloc (owner, SZ_FNAME, TY_CHAR) + call salloc (template, SZ_FNAME, TY_CHAR) + + # Get file name template matching all lock files. + call sprintf (Memc[template], SZ_FNAME, "%s%s*%s") + call pargstr (LOCKLDIR) + call pargstr (LOCKFILE) + call pargstr (LOCKEXTN) + + # Open a file list. + list = fntopn (Memc[template]) + + # Examine each file in turn and delete if delete criteria satisfied. + while (fntgfn (list, Memc[fname], SZ_FNAME) != EOF) { + + # If level is nonzero (force-delete) delete unconditionally. + if (level != 0) + goto del_ + + # Open lok file and get device name. + iferr (fd = open (Memc[fname], READ_ONLY, TEXT_FILE)) + next + if (getline (fd, Memc[lbuf]) == EOF) { + call close (fd) + goto del_ + } + if (gstrmatch (Memc[lbuf], "unit ", status, ip) <= 0) { + call close (fd) + goto del_ + } + device = lbuf + ip + for (cp=device; Memc[cp] != EOS && Memc[cp] != ' '; cp=cp+1) + ; + Memc[cp] = EOS + call close (fd) + + # Determine if the device is currently allocated. If the device + # is not allocated delete the lok file unconditionally. If the + # device is allocated to someone else leave the lok file alone. + # If the lok file is allocated to the current user delete it if + # the file is older than the stale value. + + status = xdevowner (Memc[device], Memc[owner], SZ_FNAME) + switch (status) { + case DV_DEVFREE: + goto del_ + + case DV_DEVINUSE: + # Do nothing. + + case DV_DEVALLOC: + # Delete the file if older than the stale value. + if (finfo (Memc[fname], fi) == ERR) + goto del_ + + if (clktime(FI_MTIME(fi)) > stale) { + # Delete the file. +del_ if (out != NULL) { + call fprintf (out, "delete lok file %s\n") + call pargstr (Memc[fname]) + } + iferr (call delete (Memc[fname])) + ; + } + } + } + + call fntcls (list) + call sfree (sp) +end diff --git a/sys/mtio/mtdealloc.x b/sys/mtio/mtdealloc.x new file mode 100644 index 00000000..2f98a972 --- /dev/null +++ b/sys/mtio/mtdealloc.x @@ -0,0 +1,35 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <error.h> + +# MTDEALLOCATE -- Deallocate a previously allocated tape drive. To deallocate +# a drive we try to rewind (any errors, such as drive offline, will result in a +# warning message), and then delete the lockfile. We do not call up the OS to +# deallocate the drive; that is done at a higher level, usually XDEALLOCATE +# (in etc$xalloc.x). + +procedure mtdeallocate (mtname, rewind_tape) + +char mtname[ARB] #I magtape specification +int rewind_tape #I rewind before deallocating drive + +pointer sp, lockfile +errchk mt_glock, syserrs + +begin + call smark (sp) + call salloc (lockfile, SZ_FNAME, TY_CHAR) + + if (rewind_tape == YES) + iferr (call mtrewind (mtname, NO)) + call erract (EA_WARN) + + call mt_sync (OK) + + call mt_glock (mtname, Memc[lockfile], SZ_FNAME) + iferr (call delete (Memc[lockfile])) + ; + + call mt_clrcache() + call sfree (sp) +end diff --git a/sys/mtio/mtdevall.x b/sys/mtio/mtdevall.x new file mode 100644 index 00000000..3f5620d8 --- /dev/null +++ b/sys/mtio/mtdevall.x @@ -0,0 +1,30 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <xalloc.h> +include <knet.h> + +# MT_DEVALLOCATED -- Verify that the named host magtape device is allocated. +# The IRAF device name must already have been translated to a host device +# name before we are called. + +int procedure mt_devallocated (iodev) + +char iodev[ARB] #I host name of device +pointer sp, pk_iodev, pk_owner +int status + +begin + call smark (sp) + call salloc (pk_iodev, SZ_FNAME, TY_CHAR) + call salloc (pk_owner, SZ_FNAME, TY_CHAR) + + # The following assumes that the node! prefix is in iodev. + call strpak (iodev, Memc[pk_iodev], SZ_FNAME) + call zdvown (Memc[pk_iodev], Memc[pk_owner], SZ_FNAME, status) + + call sfree (sp) + if (status == DV_DEVALLOC) + return (YES) + else + return (NO) +end diff --git a/sys/mtio/mtencode.x b/sys/mtio/mtencode.x new file mode 100644 index 00000000..b6bf6b0f --- /dev/null +++ b/sys/mtio/mtencode.x @@ -0,0 +1,44 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +# MTENCODE -- Construct a full magtape device specification. This routine is +# the opposite of MTPARSE. If the file and record numbers are to be omitted +# from the output mtname they should be passed as ERR. + +procedure mtencode (outstr, maxch, device, fileno, recno, attrl) + +char outstr[ARB] #O magtape device specification +int maxch #I max chars out +char device[ARB] #I device name (incl node) +int fileno, recno #I file and record numbers, or ERR +char attrl[ARB] #I tapecap attributes + +int op +int gstrcpy() +int itoc() + +begin + if (fileno != ERR || recno != ERR || attrl[1] != EOS) { + op = gstrcpy (device, outstr, maxch) + 1 + outstr[op] = '['; op = op + 1 + if (fileno != ERR) { + if (fileno == EOT) + op = op + gstrcpy ("EOT", outstr[op], maxch-op+1) + else + op = op + itoc (fileno, outstr[op], maxch-op+1) + } + if (recno != ERR) { + outstr[op] = '.'; op = op + 1 + op = op + itoc (recno, outstr[op], maxch-op+1) + } + if (attrl[1] != EOS) { + if (attrl[1] != ':') { + outstr[op] = ':' + op = op + 1 + } + op = op + gstrcpy (attrl, outstr[op], maxch-op+1) + } + outstr[op] = ']'; op = op + 1 + outstr[op] = EOS + } else + call strcpy (device, outstr, maxch) +end diff --git a/sys/mtio/mtfile.x b/sys/mtio/mtfile.x new file mode 100644 index 00000000..c07a550b --- /dev/null +++ b/sys/mtio/mtfile.x @@ -0,0 +1,24 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +define SZ_NODENAME 9 + +# MTFILE -- Test a filename to see if it is the name of a magtape file. +# A magtape file is characterized by the filename prefix "mt" (ingnoring +# the nodename prefix if any). + +int procedure mtfile (fname) + +char fname[ARB] #I filename to be tested + +int ip, junk +char nodename[SZ_NODENAME] +int ki_extnode() + +begin + ip = ki_extnode (fname, nodename, SZ_NODENAME, junk) + 1 + + if (fname[ip] == 'm' && fname[ip+1] == 't') + return (YES) + else + return (NO) +end diff --git a/sys/mtio/mtfname.x b/sys/mtio/mtfname.x new file mode 100644 index 00000000..7bb92408 --- /dev/null +++ b/sys/mtio/mtfname.x @@ -0,0 +1,29 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include "mtio.h" + +# MTFNAME -- Edit the input mtname (magtape file specification) to reference +# the numbered file. The edited mtname is returned in the output string. + +procedure mtfname (mtname, fileno, outstr, maxch) + +char mtname[ARB] #I magtape device specification +int fileno #I desired file number +char outstr[ARB] #O output mtname string +int maxch #I maxch chars out + +int ofileno, orecno +pointer sp, device, devcap + +begin + call smark (sp) + call salloc (device, SZ_DEVICE, TY_CHAR) + call salloc (devcap, SZ_DEVCAP, TY_CHAR) + + call mtparse (mtname, Memc[device], SZ_DEVICE, ofileno, orecno, + Memc[devcap], SZ_DEVCAP) + call mtencode (outstr, maxch, + Memc[device], fileno, orecno, Memc[devcap]) + + call sfree (sp) +end diff --git a/sys/mtio/mtglock.x b/sys/mtio/mtglock.x new file mode 100644 index 00000000..a1abfef5 --- /dev/null +++ b/sys/mtio/mtglock.x @@ -0,0 +1,47 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <syserr.h> +include "mtio.h" + +# MT_GLOCK -- Return the lockfile name for the given magtape device +# specification. There can be many logical devices, defined in the tapecap +# file, which refer to the same physical device. All entries for the same +# physical device share the same i/o device file and lock file. If the +# physical device is on a remote node the tapecap file on that node should +# be accessed, and the node name must be included in the lockfile file name, +# although the lock file is always written on the local node. + +procedure mt_glock (mtname, lockfile, maxch) + +char mtname[ARB] #I full magtape device spec +char lockfile[ARB] #O receives lockfile name +int maxch #I max chars out + +int filno, recno +pointer sp, lkname, device, devcap, gty +errchk mt_gtyopen, syserrs +int gtygets() +pointer mt_gtyopen() + +begin + call smark (sp) + call salloc (lkname, SZ_FNAME, TY_CHAR) + call salloc (device, SZ_FNAME, TY_CHAR) + call salloc (devcap, SZ_DEVCAP, TY_CHAR) + + call mtparse (mtname, + Memc[device], SZ_FNAME, filno, recno, Memc[devcap], SZ_DEVCAP) + + # The "lk" capability specifies the lock file root name. + gty = mt_gtyopen (Memc[device], Memc[devcap]) + if (gtygets (gty, "lk", Memc[lkname], SZ_FNAME) <= 0) { + call eprintf ("missing `lk' parameter in tapecap entry for %s\n") + call pargstr (mtname) + call syserrs (SYS_MTTAPECAP, mtname) + } + + call ki_xnode (Memc[device], Memc[lkname], SZ_FNAME) + call mt_lockname (Memc[lkname], lockfile, maxch) + + call sfree (sp) +end diff --git a/sys/mtio/mtgtyopen.x b/sys/mtio/mtgtyopen.x new file mode 100644 index 00000000..489fba2d --- /dev/null +++ b/sys/mtio/mtgtyopen.x @@ -0,0 +1,129 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <syserr.h> +include "mtio.h" + +# MT_GTYOPEN -- Given a logical device name, open the tapecap file and extract +# the entry for the named device into an open GTY descriptor. The descriptor +# pointer is returned as the function value. The last entry accessed is +# cached indefinitely so that repeated references cause the tapecap file to +# be scanned only once. +# +# The tapecap file may be defined in the user environment, otherwise it +# defaults to the compiled in default TAPECAP (dev$tapecap). The format +# of the "tapecap" environment variable is "filename[:devcap]", e.g. +# +# home$tapecap:so +# +# +# would cause the file home$tapecap to be used as the tapecap file, adding the +# device capabilities :so to each tapecap device access (any devcap fields +# given on the command line will override these). Either the filename or +# devcap field may be omitted. For example, reset tapecap = ":so" causes +# the default tapecap file dev$tapecap to be used, but enables status output +# logging in each magtape access. + +pointer procedure mt_gtyopen (device, ufields) + +char device[ARB] #I local device name (incl node) +char ufields[ARB] #I optional user tapecap fields + +int len_ufields, junk +char c_device[SZ_DEVICE] +char c_ufields[SZ_DEVCAP] +bool first_time, capseen, remote +pointer c_gty, gty, sp, tapecap, devcap, ip, op +pointer fname, dname, nname, tname + +bool streq() +pointer gtyopen() +int envfind(), stridxs(), strlen(), gstrcpy(), ki_gnode() +errchk gtyopen, syserrs +data first_time /true/ + +begin + # First time initialization. + if (first_time) { + c_gty = NULL + first_time = false + } + + # Check the cache. + if (c_gty != NULL && streq(device,c_device) && streq(ufields,c_ufields)) + return (c_gty) + + # Cache miss. Free the old descriptor. + if (c_gty != NULL) + call gtyclose (c_gty) + + call smark (sp) + call salloc (tapecap, SZ_DEVCAP, TY_CHAR) + call salloc (devcap, SZ_DEVCAP, TY_CHAR) + call salloc (fname, SZ_PATHNAME, TY_CHAR) + call salloc (tname, SZ_PATHNAME, TY_CHAR) + call salloc (dname, SZ_FNAME, TY_CHAR) + call salloc (nname, SZ_FNAME, TY_CHAR) + + # Get tapecap definition. + if (envfind ("tapecap", Memc[tapecap], SZ_DEVCAP) <= 0) + call strcpy (TAPECAP, Memc[tapecap], SZ_DEVCAP) + + # Parse into filename and devcap fields. + op = fname + capseen = false + len_ufields = gstrcpy (ufields, Memc[devcap], SZ_DEVCAP) + for (ip=tapecap; Memc[ip] != EOS; ip=ip+1) { + if (Memc[ip] == ':' && !capseen) { + Memc[op] = EOS + op = devcap + len_ufields + capseen = true + } + Memc[op] = Memc[ip] + op = op + 1 + } + Memc[op] = EOS + + # Supply default filename if none given. + if (Memc[fname] == EOS) + call strcpy (TAPECAP, Memc[fname], SZ_PATHNAME) + + # If no node is specified for the tapecap file, access the tapecap + # file on the same node as the magtape device file. + + if (stridxs ("!", Memc[fname]) <= 0) + call ki_xnode (device, Memc[fname], SZ_PATHNAME) + + # Get the node name the device is on. + remote = (ki_gnode (Memc[fname], Memc[nname], junk) != 0) + + # Get the tapecap device name minus any node prefix. + call strcpy (device, Memc[dname], SZ_FNAME) + call ki_xnode ("", Memc[dname], SZ_FNAME) + + # Open the tapecap entry. Try "tapecap.<node>" first then "tapecap". + # <node> is the hostname of the host the tape device is on, i.e. the + # network server on which the drive is located. The "tapecap.<node>" + # feature allows a shared common IRAF installation to support distinct + # tapecap files for different servers, falling back on the standard + # tapecap file if no node-specific file is found. + + call strcpy (Memc[fname], Memc[tname], SZ_PATHNAME) + call strcat (".", Memc[tname], SZ_PATHNAME) + call strcat (Memc[nname], Memc[tname], SZ_PATHNAME) + + iferr (gty = gtyopen (Memc[tname], Memc[dname], Memc[devcap])) + iferr (gty = gtyopen (Memc[fname], Memc[dname], Memc[devcap])) + call syserrs (SYS_MTTAPECAP, device) + if (gty == NULL) + call syserrs (SYS_MTTAPECAP, device) + + # Update the cache. + if (strlen(ufields) <= SZ_DEVCAP) { + call strcpy (device, c_device, SZ_DEVICE) + call strcpy (Memc[devcap], c_ufields, SZ_DEVCAP) + c_gty = gty + } + + call sfree (sp) + return (gty) +end diff --git a/sys/mtio/mtio.com b/sys/mtio/mtio.com new file mode 100644 index 00000000..8accab3b --- /dev/null +++ b/sys/mtio/mtio.com @@ -0,0 +1,9 @@ +# The MTIO Common. + +int new_mtchan # flag newly opened channel +int mtdev[LEN_MTIODES,MT_MAXTAPES+1] # integer fields +char mtnam[SZ_DEVICE,MT_MAXTAPES+1] # array of drive names +char mtosn[SZ_IODEV,MT_MAXTAPES+1] # host name for device +char mtlkn[SZ_LKNAME,MT_MAXTAPES+1] # lock file name + +common /mtiocom/ new_mtchan, mtdev, mtnam, mtosn, mtlkn diff --git a/sys/mtio/mtio.h b/sys/mtio/mtio.h new file mode 100644 index 00000000..a400a88a --- /dev/null +++ b/sys/mtio/mtio.h @@ -0,0 +1,42 @@ +# MTIO.H -- Magtape i/o interface definitions. Note that the system config +# file contains additional definitions (i.e., MT_MAXTAPES). + +define TAPECAP "dev$tapecap" # default tapecap file +define LOCKLDIR "tmp$" # where the lock file goes +define LOCKFILE "mt" # root lockfile name +define LOCKEXTN ".lok" # lockfile extension +define MT_MAGIC (-5417) # was zopnmt called by mtopen? +define SZ_DEVICE 79 # max length of drive name +define SZ_IODEV 79 # max length host device name +define SZ_LKNAME 79 # max length lock file mame +define SZ_DEVCAP 512 # max command line tapecap chars + +# MTIO device descriptor structure. The device descriptor is implemented +# as the two dimensional integer array MTDEV, defined in the mtio common. +# The DEVPOS substructure must agree with the driver, os$zfiomt.c. + +define MT_DEVICE mtnam[1,$1+1] # drive name +define MT_IODEV mtosn[1,$1+1] # i/o device +define MT_LKNAME mtlkn[1,$1+1] # lock file name + +define LEN_MTIODES 11 +define MT_DEVPOS MT_FILNO # devpos struct (passed to driver) +define LEN_DEVPOS 5 + +define MT_OSCHAN mtdev[1,$1+1] # OS channel or 0 +define MT_ACMODE mtdev[2,$1+1] # new access mode +define MT_DEVCAP mtdev[3,$1+1] # pointer to tapecap entry for device +define MT_FILE mtdev[4,$1+1] # new file number +define MT_RECORD mtdev[5,$1+1] # new record number +define MT_ATEOF mtdev[6,$1+1] # reached end of file on a read +define MT_FILNO mtdev[7,$1+1] # old file number at open +define MT_RECNO mtdev[8,$1+1] # old record number at open +define MT_NFILES mtdev[9,$1+1] # nfiles on tape +define MT_TAPEUSED mtdev[10,$1+1] # total tape used, bytes +define MT_PFLAGS mtdev[11,$1+1] # i/o flags returned by driver + +# PFLAGS bitflags. +define MF_ERR 001B # i/o error in last operation +define MF_EOF 002B # tape mark seen in last operation +define MF_EOT 004B # end of tape seen in last op +define MF_EOR 010B # last op was a record advance diff --git a/sys/mtio/mtlocknam.x b/sys/mtio/mtlocknam.x new file mode 100644 index 00000000..0820645a --- /dev/null +++ b/sys/mtio/mtlocknam.x @@ -0,0 +1,40 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <ctype.h> +include <chars.h> +include "mtio.h" + +# MT_LOCKNAME -- Generate the file name of the magtape lock file, given the +# logical drive name. We are called from a z-routine, so do not use any high +# level i/o routines. The generated lockfile name is of the form +# +# [node!]dir$mta.lok +# +# The lock file is maintained on the same node as the drive to which it +# refers. + +procedure mt_lockname (device, lockfile, maxch) + +char device[ARB] #I device name +char lockfile[maxch] #O receives generated lockfile name +int maxch #I max chars out + +int ip, op +int gstrcpy(), strlen() + +begin + lockfile[1] = EOS + + # Copy the node name prefix, if any. + call ki_xnode (device, lockfile, maxch) + op = strlen (lockfile) + 1 + ip = op + + # Add the directory name prefix, "mt", and device name. + op = op + gstrcpy (LOCKLDIR, lockfile[op], maxch-op+1) + op = op + gstrcpy (LOCKFILE, lockfile[op], maxch-op+1) + op = op + gstrcpy (device[ip], lockfile[op], maxch-op+1) + + # Add file extension. + op = op + gstrcpy (LOCKEXTN, lockfile[op], maxch-op+1) +end diff --git a/sys/mtio/mtneedf.x b/sys/mtio/mtneedf.x new file mode 100644 index 00000000..9c334949 --- /dev/null +++ b/sys/mtio/mtneedf.x @@ -0,0 +1,26 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include "mtio.h" + +# MTNEEDFILENO -- Returns YES if no file number is specified in mtname, or +# NO if a file is specified. + +int procedure mtneedfileno (mtname) + +char mtname[ARB] #I magtape device specification + +int fileno, recno +pointer sp, device, devcap +int btoi() + +begin + call smark (sp) + call salloc (device, SZ_DEVICE, TY_CHAR) + call salloc (devcap, SZ_DEVCAP, TY_CHAR) + + call mtparse (mtname, Memc[device], SZ_DEVICE, fileno, recno, + Memc[devcap], SZ_DEVCAP) + + call sfree (sp) + return (btoi(fileno == ERR)) +end diff --git a/sys/mtio/mtopen.x b/sys/mtio/mtopen.x new file mode 100644 index 00000000..fc5d6c4f --- /dev/null +++ b/sys/mtio/mtopen.x @@ -0,0 +1,188 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <knet.h> +include <config.h> +include <syserr.h> +include <fset.h> +include <mach.h> +include "mtio.h" + +# MTOPEN -- Open a magtape file, or a regular binary file if the file name is +# not "mt" prefixed. Access modes are restricted to read_only, write_only, +# append, and new_tape. The buffer size argument specifies the size of the +# FIO buffer used to access the tape; a system and device dependent default +# is supplied if the buffer size is given as zero. If the device is a fixed +# block size device the buffer size will be adjusted to an integral multiple +# of the device block size. For variable size record devices, the buffer size +# determines the size of the tape record on a write, or the maximum record +# size on a read. +# +# The device to be accessed is specified as follows: +# +# [node!] mtX [ '[' file[.record] [:attr-list] ']' ] +# +# for example, +# +# mtexb1[4:nb:se@:ts=1200:so=/dev/ttya8] +# +# The "mt" prefix is required for the object to be considered a magtape device +# reference. The device name returned is "mtX" as shown above; there must be +# an entry for device mtX in the tapecap file in DEV. +# +# The file and record numbers are optional. Files and records are numbered +# starting with 1. A sequence such as "mtX[eot]" will cause the tape to be +# positioned to end of tape. "mtX[0]" causes the tape to be opened at the +# current position, i.e., without being moved. +# +# The optional attr-list field consists of a sequence of colon-delimited +# tapecap fields. These will override any values given in the tapecap entry +# for the device. The syntax for attr-list is the same as in tapecap. +# +# If the filespec does not have the prefix "mt", we assume that the file is +# a regular binary file and try to open that. If a tape file is specified +# then the drive must be allocated before we are called. We allocate and +# initialize an MTIO file descriptor and call FOPNBF to install the magtape +# device in FIO and open the device/file. + +int procedure mtopen (mtname, acmode, bufsize) + +char mtname[ARB] #I device to be opened +int acmode #I access mode +int bufsize #I fio buffer size (record size) or 0 + +bool first_time +pointer sp, devcap, fname, gty +int mt, fd, nskip, new_file, new_record + +bool streq() +pointer mt_gtyopen(), gtycaps() +int open(), fopnbf(), gtygets(), access() +int mt_skip_record(), mtfile(), mt_devallocated() +extern zopnmt(), zardmt(), zawrmt(), zawtmt(), zsttmt(), zclsmt() + +errchk open, fopnbf, fseti, syserrs, mtparse +errchk mt_getpos, mt_skip_record, mt_gtyopen, gtygets, mt_glock, mtallocate +data first_time /true/ +include "mtio.com" + +begin + call smark (sp) + call salloc (fname, SZ_PATHNAME, TY_CHAR) + call salloc (devcap, SZ_DEVCAP, TY_CHAR) + + # Runtime initialization of the mtio file descriptor common. + # Make each file descriptor available for use. + + if (first_time) { + call mt_clrcache() + do mt = 1, MT_MAXTAPES + MT_OSCHAN(mt) = NULL + first_time = false + } + + # If regular binary file, we are done. + if (mtfile(mtname) == NO) { + call sfree (sp) + return (open (mtname, acmode, BINARY_FILE)) + } + + # Get mtio file descriptor slot, but do not allocate it until + # we are ready to open the file. + + for (mt=1; mt <= MT_MAXTAPES && MT_OSCHAN(mt) != NULL; mt=mt+1) + ; + if (mt > MT_MAXTAPES) + call syserrs (SYS_MTMULTOPEN, mtname) + + # Break mtname into drive name, file and record number, etc. + call mtparse (mtname, MT_DEVICE(mt), SZ_DEVICE, + new_file, new_record, Memc[devcap], SZ_DEVCAP) + if (new_record == ERR) + new_record = 1 + + # Get tapecap info. + gty = mt_gtyopen (MT_DEVICE(mt), Memc[devcap]) + MT_DEVCAP(mt) = gtycaps (gty) + if (gtygets (gty, "dv", MT_IODEV(mt), SZ_IODEV) <= 0) { + call eprintf ("missing `dv' parameter in tapecap entry for %s\n") + call pargstr (mtname) + call syserrs (SYS_MTTAPECAP, mtname) + } + call ki_xnode (MT_DEVICE(mt), MT_IODEV(mt), SZ_IODEV) + + # If the device has not been allocated, at least write out the + # lock file. This will not physically allocate the device, but + # the lock file is required to be able to access the device. + + call mt_glock (mtname, MT_LKNAME(mt), SZ_LKNAME) + if (mt_devallocated (MT_IODEV(mt)) == NO) + if (access (MT_LKNAME(mt), 0,0) == NO) + call mtallocate (mtname) + + # Get current tape position. + call mt_getpos (mtname, mt) + + MT_FILE(mt) = new_file + MT_RECORD(mt) = new_record + MT_ATEOF(mt) = NO + + # If tape is opened for writing but no file number is given, default + # to EOT. Defaulting to current file or BOT could result in + # destruction of the tape. Note that this default WILL RESULT IN TAPE + # RUNAWAY if used on a blank tape. Blank tapes must be explicitly + # written at file [1], or opened with access mode NEW_TAPE. + + if ((acmode == WRITE_ONLY && MT_FILE(mt) == -1) || (acmode == APPEND)) { + MT_FILE(mt) = EOT + MT_RECORD(mt) = 1 + } else if (acmode == NEW_TAPE) { + MT_FILE(mt) = 1 + MT_RECORD(mt) = 1 + } + + # Make sure that we are not reopening a drive which is already open. + for (fd=1; fd <= MT_MAXTAPES; fd=fd+1) + if (fd != mt && MT_OSCHAN(fd) != NULL) + if (streq (MT_DEVICE(fd), MT_DEVICE(mt))) + call syserrs (SYS_MTMULTOPEN, mtname) + + # Initialize the remaining fields in the file descriptor and open the + # device. ZOPNMT will position the tape. Note that we pass the index + # of the new mtio descriptor slot to ZOPNMT in the common. This is a + # bit ugly, but is safe enough, since we know that FOPNBF is going to + # call ZOPNMT. + + switch (acmode) { + case READ_ONLY: + MT_ACMODE(mt) = READ_ONLY + case WRITE_ONLY, APPEND, NEW_TAPE: + MT_ACMODE(mt) = WRITE_ONLY + default: + call syserrs (SYS_MTACMODE, mtname) + } + + new_mtchan = mt + fd = fopnbf (MT_IODEV(mt), acmode, + zopnmt, zardmt, zawrmt, zawtmt, zsttmt, zclsmt) + + # Set the file buffer size (record size for variable block devices). + if (bufsize > 0) + call fseti (fd, F_BUFSIZE, bufsize) + + # If the user specified a record offset, skip records up to there. + # Zero means leave positioned to old record. + + if (MT_RECORD(mt) == 0) + MT_RECORD(mt) = MT_RECNO(mt) + if (MT_RECORD(mt) > 1) { + nskip = MT_RECORD(mt) - 1 + MT_RECORD(mt) = 1 + if (mt_skip_record (fd, nskip) != nskip) + call syserrs (SYS_MTSKIPREC, mtname) + } + + call mt_savepos (mt) + + call sfree (sp) + return (fd) +end diff --git a/sys/mtio/mtparse.x b/sys/mtio/mtparse.x new file mode 100644 index 00000000..27622280 --- /dev/null +++ b/sys/mtio/mtparse.x @@ -0,0 +1,126 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <config.h> +include <syserr.h> +include <ctype.h> +include "mtio.h" + +# MTPARSE -- Decode a virtual magtape file specification, returning the device +# name, file and record to which the drive is to be positioned, and any special +# device attributes (these will override the device defaults). The file and +# record fields are returned as ERR if missing. Only the drive name field is +# required. +# +# Magtape device syntax: +# +# [node!] mtX [ '[' file[.record] [:attr-list] ']' ] +# +# for example, +# +# mtexb1[4:nb:se@:ts=1200:so=/dev/ttya8] +# +# The "mt" prefix is required for the object to be considered a magtape +# device reference. The device name returned is "mtX" as shown above; there +# must be an entry for device mtX in the tapecap file in DEV. +# +# The file and record numbers are optional. Files and records are numbered +# starting with 1. A sequence such as "mtX[eot]" will cause the tape to be +# positioned to end of tape. "mtX[0]" causes the tape to be opened at the +# current position, i.e., without being moved. +# +# The optional attr-list field consists of a sequence of colon-delimited +# tapecap fields. These will override any values given in the tapecap +# entry for the device. The syntax for attr-list is the same as in tapecap. + +procedure mtparse (mtname, device, sz_device, file, record, attrl, sz_attrl) + +char mtname[ARB] #I device specification +char device[ARB] #O device name as in tapecap +int sz_device #I max chars in device name +int file #O file number or -1 +int record #O record number or -1 +char attrl[ARB] #O attribute list +int sz_attrl #I max char in attribute list + +char eotstr[3] +int ip, op, nchars, ival +int ctoi(), strncmp(), ki_extnode() +bool streq() +define bad_ 91 + +begin + # Extract the node name, if any, from the mtname. + ip = ki_extnode (mtname, device, sz_device, nchars) + 1 + op = nchars + 1 + + # Verify that this is a magtape device specification. + if (strncmp (mtname[ip], "mt", 2) != 0) + goto bad_ + + # Extract the device name field. + while (mtname[ip] != EOS && mtname[ip] != '[') { + device[op] = mtname[ip] + op = min (sz_device, op + 1) + ip = ip + 1 + } + device[op] = EOS + + file = ERR + record = ERR + attrl[1] = EOS + + # Process the [...] part of the device specification. + if (mtname[ip] == '[') { + ip = ip + 1 + + # Get the file number. + if (ctoi (mtname, ip, ival) > 0) { + file = ival + if (file < 0) + goto bad_ + } else if (IS_ALPHA(mtname[ip])) { + call strcpy (mtname[ip], eotstr, 3) + call strlwr (eotstr) + if (streq (eotstr, "eot")) { + file = EOT + ip = ip + 3 + } else + goto bad_ + } + + # Get the record number. + if (mtname[ip] == '.' || mtname[ip] == ',') { + ip = ip + 1 + if (mtname[ip] == ']') + record = ERR + else if (ctoi (mtname, ip, ival) > 0) { + record = ival + if (record < 0) + goto bad_ + } + } + + # Get the device attribute list. + op = 1 + if (mtname[ip] == ':') { + attrl[op] = mtname[ip] + op = max(1, min(sz_attrl, op + 1)) + ip = ip + 1 + + while (mtname[ip] != EOS && mtname[ip] != ']') { + attrl[op] = mtname[ip] + op = max(1, min(sz_attrl, op + 1)) + ip = ip + 1 + } + } + attrl[op] = EOS + + # Check for the ']' terminator. + if (mtname[ip] != ']') + goto bad_ + } + + return +bad_ + call syserrs (SYS_MTFILSPEC, mtname) +end diff --git a/sys/mtio/mtpos.x b/sys/mtio/mtpos.x new file mode 100644 index 00000000..f88946ae --- /dev/null +++ b/sys/mtio/mtpos.x @@ -0,0 +1,39 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include "mtio.h" + +# MTPOSITION -- Position the device to the indicated file and record. +# We are called to position the device by device name, not to position +# an open magtape file. + +procedure mtposition (mtname, file, record) + +char mtname[ARB] #I device to be positioned +int file #I desired file number +int record #I desired record number + +int junk +pointer sp, mtspec, device, devcap +errchk mtparse, mtopen +int mtopen() + +begin + call smark (sp) + call salloc (device, SZ_FNAME, TY_CHAR) + call salloc (mtspec, SZ_FNAME, TY_CHAR) + call salloc (devcap, SZ_DEVCAP, TY_CHAR) + + # Get device name (including node! prefix) from mtname. + call mtparse (mtname, + Memc[device], SZ_FNAME, junk, junk, Memc[devcap], SZ_DEVCAP) + + # Encode new mtname and open device to position to desired file. + # Note that we do not return until positioning is complete. Thus, + # "mtposition(device,1)" is a rewind with wait. + + call mtencode (Memc[mtspec], SZ_FNAME, + Memc[device], file, record, Memc[devcap]) + call close (mtopen (Memc[mtspec], READ_ONLY, 1)) + + call sfree (sp) +end diff --git a/sys/mtio/mtrdlock.x b/sys/mtio/mtrdlock.x new file mode 100644 index 00000000..774fab19 --- /dev/null +++ b/sys/mtio/mtrdlock.x @@ -0,0 +1,93 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <config.h> +include "mtio.h" + +# MT_READ_LOCKFILE -- Read the magtape lock file to determine the current +# position of the tape (the lock file is used to record the tape position +# while the device is closed). If the lock file cannot be accessed or an +# error occurs in reading it, return an undefined tape position. + +procedure mt_read_lockfile (mtname, mt) + +char mtname[ARB] #I device name +int mt #I MTIO descriptor + +int fd, ip +pointer sp, lockfile, lbuf +int strmatch(), stridxs(), ctoi(), open(), getline() +errchk open, getline +include "mtio.com" +define err_ 91 + +begin + call smark (sp) + call salloc (lockfile, SZ_FNAME, TY_CHAR) + call salloc (lbuf, SZ_LINE, TY_CHAR) + + # If the lock file cannot be accessed, return an undefined tape + # position but do not abort. + + #call mt_lockname (MT_LKNAME(mt), Memc[lockfile], SZ_FNAME) + call strcpy (MT_LKNAME(mt), Memc[lockfile], SZ_FNAME) + iferr (fd = open (Memc[lockfile], READ_ONLY, TEXT_FILE)) { + fd = ERR + goto err_ + } + + # Get file number. + repeat { + if (getline (fd, Memc[lbuf]) == EOF) + goto err_ + } until (strmatch (Memc[lbuf], "^file") > 0) + ip = stridxs ("=", Memc[lbuf]) + 1 + if (ctoi (Memc[lbuf], ip, MT_FILNO(mt)) == 0) + goto err_ + + # Get record number. + if (getline (fd, Memc[lbuf]) == EOF) + goto err_ + ip = stridxs ("=", Memc[lbuf]) + 1 + if (ctoi (Memc[lbuf], ip, MT_RECNO(mt)) == 0) + goto err_ + + # Get total files on tape. + if (getline (fd, Memc[lbuf]) == EOF) + goto err_ + ip = stridxs ("=", Memc[lbuf]) + 1 + if (ctoi (Memc[lbuf], ip, MT_NFILES(mt)) == 0) + goto err_ + + # Get amount of tape used. + if (getline (fd, Memc[lbuf]) == EOF) + goto err_ + ip = stridxs ("=", Memc[lbuf]) + 1 + if (ctoi (Memc[lbuf], ip, MT_TAPEUSED(mt)) == 0) + goto err_ + + # Get pflags. + if (getline (fd, Memc[lbuf]) == EOF) + goto err_ + ip = stridxs ("=", Memc[lbuf]) + 1 + if (ctoi (Memc[lbuf], ip, MT_PFLAGS(mt)) == 0) + goto err_ + + call close (fd) + call sfree (sp) + + return +err_ + if (fd != ERR) + call close (fd) + + # Write a new lock file so that we can update the tape position + # later (the file must exist after the drive is opened). + + call mtallocate (mtname) + + # Return an undefined tape position. + MT_FILNO(mt) = -1 + MT_RECNO(mt) = -1 + + call sfree (sp) +end diff --git a/sys/mtio/mtrewind.x b/sys/mtio/mtrewind.x new file mode 100644 index 00000000..b7efcddb --- /dev/null +++ b/sys/mtio/mtrewind.x @@ -0,0 +1,41 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <error.h> +include "mtio.h" + +# MTREWIND -- Rewind the named magtape device. This is a synchronous +# rewind. Rewind not only rewinds the device, it also initializes the +# MTIO view of what is on the tape (number of files, total bytes used). +# Hence, if the drive is left allocated but the tape is changed, or if +# the position cache becomes inaccurate for any reason, a rewind will +# initialize things without having to deallocate and reallocate the drive. + +procedure mtrewind (mtname, initcache) + +char mtname[ARB] #I device to be rewound +int initcache #I discard positional information? + +pointer sp, fname +int fd, mtopen() +errchk mtfname + +begin + call smark (sp) + call salloc (fname, SZ_FNAME, TY_CHAR) + + # Init position cache. + if (initcache == YES) { + call mt_glock (mtname, Memc[fname], SZ_FNAME) + iferr (call delete (Memc[fname])) + ; + } + + # Rewind device. + call mtfname (mtname, 1, Memc[fname], SZ_FNAME) + iferr (fd = mtopen (Memc[fname], READ_ONLY, 0)) + call erract (EA_WARN) + else + call close (fd) + + call sfree (sp) +end diff --git a/sys/mtio/mtskip.x b/sys/mtio/mtskip.x new file mode 100644 index 00000000..f51948a4 --- /dev/null +++ b/sys/mtio/mtskip.x @@ -0,0 +1,31 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <fset.h> + +# MT_SKIP_RECORD -- Skip records on an opened file. Return the actual number +# of records skipped; stop if EOF is reached. + +int procedure mt_skip_record (fd, nrecords) + +int fd #I magtape device +int nrecords #I number of records to skip + +pointer sp, buf +int n, bufsize +errchk aread, await +int await(), fstati() + +begin + call smark (sp) + bufsize = fstati (fd, F_BUFSIZE) + call salloc (buf, bufsize, TY_CHAR) + + for (n=1; n <= nrecords; n=n+1) { + call aread (fd, Memc[buf], bufsize, 0) + if (await (fd) == EOF) + break + } + + call sfree (sp) + return (n-1) +end diff --git a/sys/mtio/mtstatus.x b/sys/mtio/mtstatus.x new file mode 100644 index 00000000..967d25df --- /dev/null +++ b/sys/mtio/mtstatus.x @@ -0,0 +1,34 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +# MTSTATUS -- Print the status of an allocated magtape device, i.e., print the +# lock file as a text file. Called by the DEVSTATUS task. + +procedure mtstatus (out, mtname) + +int out #I output file +char mtname[ARB] #I magtape specification + +int in +pointer sp, lockfile +errchk open, fcopyo +int open(), access() + +begin + call smark (sp) + call salloc (lockfile, SZ_FNAME, TY_CHAR) + + call mt_sync (OK) + + call mt_glock (mtname, Memc[lockfile], SZ_FNAME) + if (access (Memc[lockfile], 0, 0) == NO) { + call fprintf (out, "tape position for %s is undefined\n") + call pargstr (mtname) + } else { + # Print the lockfile. + in = open (Memc[lockfile], READ_ONLY, TEXT_FILE) + call fcopyo (in, out) + call close (in) + } + + call sfree (sp) +end diff --git a/sys/mtio/mtupdlock.x b/sys/mtio/mtupdlock.x new file mode 100644 index 00000000..654d3cbc --- /dev/null +++ b/sys/mtio/mtupdlock.x @@ -0,0 +1,188 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <knet.h> +include <mach.h> +include <config.h> +include "mtio.h" + +# MT_UPDATE_LOCKFILE -- Update the current file position in the lockfile. +# This information is returned by the host specific driver at close time. +# We are called from a z-routine so we must access the lockfile using only +# low level OS interface routines to avoid recursion. We may be called during +# error recovery (as well as from a z-routine), so any errors are fatal. + +procedure mt_update_lockfile (mt) + +int mt #I device slot + +extern mt_sync() +pointer sp, lockfile, tempfile, lbuf, ip, op, extn +int old_lockfile, new_lockfile, junk, status, nlines +errchk fmapfn +include "mtio.com" +define oline_ 91 +define err_ 92 + +begin + call smark (sp) + call salloc (lockfile, SZ_PATHNAME, TY_CHAR) + call salloc (tempfile, SZ_PATHNAME, TY_CHAR) + call salloc (lbuf, SZ_LINE, TY_CHAR) + + # Catch any errors in the following section and convert them + # into fatal errors. + + iferr { + # Try to avoid generating any non-host legal filenames in the + # following code, to avoid any need to access the VFN mapping + # file. Generate temp file in the same directory on the same + # node as the lockfile so that we can easily rename the tempfile + # to be the new lockfile. + + #call mt_lockname (MT_LKNAME(mt), Memc[lockfile], SZ_PATHNAME) + call strcpy (MT_LKNAME(mt), Memc[lockfile], SZ_PATHNAME) + + # Make tempfile name. + extn = NULL + op = tempfile + for (ip=lockfile; Memc[ip] != EOS; ip=ip+1) { + if (Memc[ip] == '.') + extn = op + Memc[op] = Memc[ip] + op = op + 1 + } + + if (extn == NULL) + extn = op + call strcpy (".tlk", Memc[extn], 4) + + # Map the filenames. + call fmapfn (Memc[tempfile], Memc[tempfile], SZ_PATHNAME) + call fmapfn (Memc[lockfile], Memc[lockfile], SZ_PATHNAME) + + } then + goto err_ + + # Overwrite any existing tempfile. + call zfdele (Memc[tempfile], junk) + call zopntx (Memc[tempfile], NEW_FILE, new_lockfile) + if (new_lockfile == ERR) + goto err_ + + # Open old lockfile, if any, and copy the comments section. + call zopntx (Memc[lockfile], READ_ONLY, old_lockfile) + if (old_lockfile == ERR) { +oline_ call strcpy ("# Magtape unit ", Memc[lbuf], SZ_LINE) + call strcat (MT_DEVICE(mt), Memc[lbuf], SZ_LINE) + call strcat (" status\n", Memc[lbuf], SZ_LINE) + call mt_putline (new_lockfile, Memc[lbuf]) + } else { + nlines = 0 + repeat { + call zgettx (old_lockfile, Memc[lbuf], SZ_LINE, status) + if (status <= 0) { + if (nlines == 0) { + call zclstx (old_lockfile, status) + goto oline_ + } else + break + } else + nlines = nlines + 1 + Memc[lbuf+status] = EOS + if (Memc[lbuf] == '#') + call mt_putline (new_lockfile, Memc[lbuf]) + } until (Memc[lbuf] != '#') + call zclstx (old_lockfile, status) + } + + # Everything else we write from here on is new stuff. Discard rest + # of old lockfile. + + # Save current file and record numbers. + if (MT_FILNO(mt) == -1) + MT_RECNO(mt) = -1 + call mt_savekeyword (new_lockfile, "file", MT_FILNO(mt)) + if (MT_NFILES(mt) > 0 && (MT_FILNO(mt) == MT_NFILES(mt) + 1)) + call mt_putline (new_lockfile, " (EOT)") + call mt_putline (new_lockfile, "\n") + call mt_savekeyword (new_lockfile, "record", MT_RECNO(mt)) + call mt_putline (new_lockfile, "\n") + call mt_savekeyword (new_lockfile, "nfiles", MT_NFILES(mt)) + call mt_putline (new_lockfile, "\n") + call mt_savekeyword (new_lockfile, "tapeused", MT_TAPEUSED(mt)) + call mt_putline (new_lockfile, "\n") + call mt_savekeyword (new_lockfile, "pflags", MT_PFLAGS(mt)) + call mt_putline (new_lockfile, "\n") + + # Install the new lockfile. + call zflstx (new_lockfile, status) + if (status == ERR) + goto err_ + call zclstx (new_lockfile, status) + if (status == ERR) + goto err_ + + call zfdele (Memc[lockfile], status) + call zfrnam (Memc[tempfile], Memc[lockfile], status) + if (status == ERR) + goto err_ + + call sfree (sp) + return + +err_ + # If an error of any sort occurs, it is fatal. + call onerror_remove (mt_sync) + call zfdele (Memc[tempfile], status) + call zfdele (Memc[lockfile], status) + call fatal (0, "Fatal error writing magtape device lockfile") +end + + +# MT_SAVEKEYWORD -- Write a "keyword = value" status line into the lockfile. + +procedure mt_savekeyword (fd, keyword, value) + +int fd # output file +char keyword[ARB] # name of keyword +int value # value of keyword +char numbuf[MAX_DIGITS] +int junk, itoc() + +begin + junk = itoc (value, numbuf, MAX_DIGITS) + + call mt_putline (fd, keyword) + call mt_putline (fd, " = ") + call mt_putline (fd, numbuf) +end + + +# MT_PUTLINE -- Put a text string to the lockfile. Do not write line +# to lockfile until a newline is seen. + +procedure mt_putline (fd, text) + +int fd +char text[ARB] + +extern mt_sync() +char lbuf[SZ_LINE] +int ip, op, status +data op /1/ + +begin + for (ip=1; text[ip] != EOS; ip=ip+1) { + lbuf[op] = text[ip] + op = min (SZ_LINE, op) + 1 + if (text[ip] == '\n') { + call zputtx (fd, lbuf, op-1, status) + if (status == ERR) { + call onerror_remove (mt_sync) + call fatal (0, + "Fatal error writing magtape device lockfile") + } + op = 1 + } + } +end diff --git a/sys/mtio/zardmt.x b/sys/mtio/zardmt.x new file mode 100644 index 00000000..ac5833be --- /dev/null +++ b/sys/mtio/zardmt.x @@ -0,0 +1,22 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <knet.h> +include <config.h> +include "mtio.h" + +# ZARDMT -- MTIO asynchronous read primitive. Initiate a read of up to +# maxbytes bytes into the user buffer. + +procedure zardmt (mtchan, buf, maxbytes, offset) + +int mtchan #I i/o channel +char buf[ARB] #O output data buffer +int maxbytes #I max bytes to read +long offset #I file offset + +include "mtio.com" + +begin + if (MT_ATEOF(mtchan) == NO) + call zzrdmt (MT_OSCHAN(mtchan), buf, maxbytes, offset) +end diff --git a/sys/mtio/zawrmt.x b/sys/mtio/zawrmt.x new file mode 100644 index 00000000..5caf2b70 --- /dev/null +++ b/sys/mtio/zawrmt.x @@ -0,0 +1,21 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <knet.h> +include <config.h> +include "mtio.h" + +# ZAWRMT -- MTIO asynchronous write primitive. Initiate a write of nbytes +# bytes to the tape. + +procedure zawrmt (mtchan, buf, nbytes, offset) + +int mtchan #I i/o channel +char buf[ARB] #I data to be written +int nbytes #I number of bytes of data +long offset #I file offset + +include "mtio.com" + +begin + call zzwrmt (MT_OSCHAN(mtchan), buf, nbytes, offset) +end diff --git a/sys/mtio/zawtmt.x b/sys/mtio/zawtmt.x new file mode 100644 index 00000000..5599a81e --- /dev/null +++ b/sys/mtio/zawtmt.x @@ -0,0 +1,30 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <knet.h> +include <config.h> +include "mtio.h" + +# ZAWTMT -- Wait for the last i/o transfer to complete, update tape position +# counters, return nbytes|status to caller. + +procedure zawtmt (mtchan, status) + +int mtchan #I i/o channel +int status #O status (nbytes transferred or ERR) + +include "mtio.com" + +begin + # The "sticky" EOF should not be necessary but is needed due to the + # way FIO behaves when it hits EOF on a blocked file. In some + # circumstances (depends upon the file length) two reads are made and + # if the second read does not return zero EOF will not be detected. + + if (MT_ATEOF(mtchan) == YES) + status = 0 + else { + call zzwtmt (MT_OSCHAN(mtchan), MT_DEVPOS(mtchan), status) + if (status == 0) + MT_ATEOF(mtchan) = YES + } +end diff --git a/sys/mtio/zclsmt.x b/sys/mtio/zclsmt.x new file mode 100644 index 00000000..7c4dcbf7 --- /dev/null +++ b/sys/mtio/zclsmt.x @@ -0,0 +1,55 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <config.h> +include <knet.h> +include "mtio.h" + +# ZCLSMT -- Close a magtape file and device. Update lockfile so that we +# will know where the tape is positioned next time we open the device. +# Deallocate the mtio descriptor so that it may be reused again. +# +# We are being called during error recovery if "new_mtchan" is not null. +# If MT_OSCHAN has also been set, then ZZOPMT was interrupted, probably while +# trying to position the tape, and the position of the tape is indefinite. +# Close the tape with acmode=read so that no tape marks are written, and write +# the lockfile with file = -1 to signify that the position is indefinite. + +procedure zclsmt (mtchan, status) + +int mtchan #I i/o channel +int status #O close status + +int mt +bool error_recovery +include "mtio.com" + +begin + # Called by error recovery while positioning tape? (during open) + if (new_mtchan != NULL) { + mt = new_mtchan + if (MT_OSCHAN(mt) != NULL) + call zzclmt (MT_OSCHAN(mt), MT_DEVPOS(mt), status) + + call mt_savepos (mt) + call mt_sync (ERR) + new_mtchan = NULL + + } else { + mt = mtchan + + # If a task aborts while a tape file is open, mt_sync will + # already have been called to update the position, + # and the current file will have been set to undefined (-1). + + error_recovery = (MT_FILNO(mt) == -1) + + # Close device. This clobbers MT_FILNO (see above). + call zzclmt (MT_OSCHAN(mt), MT_DEVPOS(mt), status) + + # Update the tape position if not recovering from an abort. + if (!error_recovery) + call mt_savepos (mt) + } + + MT_OSCHAN(mt) = NULL +end diff --git a/sys/mtio/zopnmt.x b/sys/mtio/zopnmt.x new file mode 100644 index 00000000..1c55e1ae --- /dev/null +++ b/sys/mtio/zopnmt.x @@ -0,0 +1,58 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <knet.h> +include <config.h> +include "mtio.h" + +# ZOPNMT -- Open magtape device at the specifed file. We are called indirectly +# by MTOPEN (via fopnbf), which sets up a new mtio device decriptor pointed +# to by NEW_MTCHAN, and passes it via the mtio common. + +procedure zopnmt (iodev, acmode, mtchan) + +char iodev[ARB] #I PACKED i/o device name string +int acmode #I file access mode +int mtchan #O return value (mt descriptor index) + +int mt +pointer sp, pk_devcap +include "mtio.com" +define err_ 91 + +begin + call smark (sp) + call salloc (pk_devcap, SZ_DEVCAP, TY_CHAR) + + # Pick up index of mt descriptor slot set up by MTOPEN. Make sure + # that we were called by MTOPEN and not somebody else. + + mt = new_mtchan + if (mt < 1 || mt > MT_MAXTAPES) + goto err_ + + # Open the device. + call strpak (Memc[MT_DEVCAP(mt)], Memc[pk_devcap], SZ_DEVCAP) + call zzopmt (iodev, MT_ACMODE(mt), Memc[pk_devcap], MT_DEVPOS(mt), + MT_FILE(mt), MT_OSCHAN(mt)) + if (MT_OSCHAN(mt) == ERR) + goto err_ + + # If "new_mtchan" is nonzero when ZCLSMT is called, it implies that + # CLOSE was called during error recovery due to an interrupt of ZZOPMT + # and the position of the tape is undefined. Clear the flag since the + # open is now complete and we were not interrupted. + + new_mtchan = NULL + MT_FILNO(mt) = MT_FILE(mt) + call mt_savepos (mt) + + mtchan = mt + call sfree (sp) + return + +err_ + # Z-routines can only return ERR in the event of an error. + MT_OSCHAN(mt) = NULL + call sfree (sp) + mtchan = ERR +end diff --git a/sys/mtio/zsttmt.x b/sys/mtio/zsttmt.x new file mode 100644 index 00000000..252c9735 --- /dev/null +++ b/sys/mtio/zsttmt.x @@ -0,0 +1,21 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <knet.h> +include <mach.h> +include <config.h> +include <fio.h> +include "mtio.h" + +# ZSTTMT -- Get magtape device or device driver parameters and settings. + +procedure zsttmt (mtchan, what, lvalue) + +int mtchan #I mtio descriptor +int what #I status parameter to be returned +long lvalue #O returned status value + +include "mtio.com" + +begin + call zzstmt (MT_OSCHAN(mtchan), what, lvalue) +end diff --git a/sys/mtio/zzdebug.x b/sys/mtio/zzdebug.x new file mode 100644 index 00000000..cf02e610 --- /dev/null +++ b/sys/mtio/zzdebug.x @@ -0,0 +1,357 @@ +# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + +include <xalloc.h> +include <mach.h> +include <fset.h> + +task alloc = t_allocate, + dealloc = t_deallocate, + status = t_status, + mtpos = t_mtposition, + wtestfile = t_wtestfile, + mtexamine = t_mtexamine, + mtcopy = t_mtcopy, + rew = t_rewind + + +.help testmtio +.nf __________________________________________________________________________ +MTIO test routines. Assorted routines for verification of MTIO. + + alloc Allocate a drive. + + dealloc Deallocate a drive. + + status Print drive status + + mtpos Position to the indicated file and record. + + wtestfile Writes a test file. The number of records and the + range of record sizes may be specified. The contents + of a record are determined by its size. + + mtexamine Examines the structure of a tape. Tells the number of + files on the tape, the number of records in each file, + the sizes of the records, and optionally dumps the + contents of an indicated range of records from each + file. + + mtcopy Fast binary copy. Copies a binary disk or tape file + to a binary disk or tape file using all the FIO + defaults. +.endhelp _____________________________________________________________________ + + +# ALLOCATE -- Allocate a drive. + +procedure t_allocate() + +int junk, status +char drive[SZ_FNAME] +char owner[SZ_FNAME] +int xallocate(), xdevowner() + +begin + call clgstr ("drive", drive, SZ_FNAME) + status = xallocate (drive) + + switch (status) { + case OK: + call printf ("device allocated successfully\n") + case ERR: + call printf ("cannot allocate device\n") + case DV_DEVFREE: + call printf ("device is free and may be allocated\n") + case DV_DEVALLOC: + call printf ("device is already allocated\n") + case DV_DEVINUSE: + junk = xdevowner ("drive", owner, SZ_FNAME) + call printf ("device is already allocated to `%s'\n") + call pargstr (owner) + case DV_DEVNOTFOUND: + call printf ("device not found\n") + default: + call printf ("unknown status %d\n") + call pargi (status) + } +end + + +# DEALLOCATE -- Deallocate a drive. + +procedure t_deallocate() + +int junk, status +char drive[SZ_FNAME] +char owner[SZ_FNAME] + +bool clgetb() +int xdeallocate(), xdevowner() + +begin + call clgstr ("drive", drive, SZ_FNAME) + status = xdeallocate (drive, clgetb ("rewind")) + + switch (status) { + case OK: + call printf ("device deallocated successfully\n") + case ERR: + call printf ("cannot deallocate device\n") + case DV_DEVFREE: + call printf ("device is free and may be allocated\n") + case DV_DEVALLOC: + call printf ("device is already allocated\n") + case DV_DEVINUSE: + junk = xdevowner ("drive", owner, SZ_FNAME) + call printf ("device is already allocated to `%s'\n") + call pargstr (owner) + case DV_DEVNOTFOUND: + call printf ("device not found\n") + default: + call printf ("unknown status %d\n") + call pargi (status) + } +end + + +# STATUS -- Print drive status. + +procedure t_status() + +int status +char drive[SZ_FNAME] +char owner[SZ_FNAME] +int xdevowner() + +begin + call clgstr ("drive", drive, SZ_FNAME) + status = xdevowner (drive, owner, SZ_FNAME) + + switch (status) { + case OK: + call printf ("device deallocated successfully\n") + case ERR: + call printf ("cannot deallocate device\n") + case DV_DEVFREE: + call printf ("device is free and may be allocated\n") + case DV_DEVALLOC: + call printf ("device is already allocated\n") + case DV_DEVINUSE: + call printf ("device is allocated to `%s'\n") + call pargstr (owner) + case DV_DEVNOTFOUND: + call printf ("device not found\n") + default: + call printf ("unknown status %d\n") + call pargi (status) + } +end + + +# MTPOS -- Position to the indicated file and record. + +procedure t_mtposition() + +char drive[SZ_FNAME] +int clgeti() + +begin + call clgstr ("drive", drive, SZ_FNAME) + call mtposition (drive, clgeti("file"), clgeti("record")) +end + + +# WTESTFILE -- Write a test file to the tape. Specify file [1] to write to +# a new tape. If no file number is given, the file is appended to the tape. +# Specify the number of records to be written and the range of sizes in bytes +# of the records. Each byte of a record will contain the size of the record +# modulus 256. + +procedure t_wtestfile() + +char mtname[SZ_FNAME] +int nrecords +int min_recsize, max_recsize + +pointer buf +long seed +int fd, i, recsize, oschan, status +int clgeti(), mtopen(), fstati() +real urand() +data seed /123/ + +begin + # Get tapefile name and open file for writing. + call clgstr ("mtname", mtname, SZ_FNAME) + fd = mtopen (mtname, WRITE_ONLY, 1) + oschan = fstati (fd, F_CHANNEL) + + nrecords = max (0, clgeti ("nrecords")) + min_recsize = max (1, clgeti ("min_recsize")) + max_recsize = max (min_recsize, clgeti ("max_recsize")) + + call calloc (buf, max_recsize, TY_CHAR) + + # Records are written by directly calling ZAWRMT, so that we can + # write odd size records. + + do i = 1, nrecords { + recsize = int ((max_recsize - min_recsize) * urand (seed)) + + min_recsize + call zawrmt (oschan, Memc[buf], recsize, 0) + call zawtmt (oschan, status) + if (status == ERR) + call error (1, "write error") + } + + call mfree (buf, TY_CHAR) + call close (fd) +end + + +# MTEXAMINE -- Examine the structure of a tape filesystem or a file. If no file +# number is given, all files are examined. + +procedure t_mtexamine() + +int fileno, nrecords +char mtname[SZ_FNAME], mtfile[SZ_FNAME] +int strlen(), mt_examine() + +begin + call clgstr ("mtname", mtname, SZ_FNAME) + call fseti (STDOUT, F_FLUSHNL, YES) + + if (mtname[strlen(mtname)] == ']') { + call strcpy (mtname, mtfile, SZ_FNAME) + nrecords = mt_examine (STDOUT, mtname) + + } else { + fileno = 1 + repeat { + call sprintf (mtfile, SZ_FNAME, "%s[%d]") + call pargstr (mtname) + call pargi (fileno) + fileno = fileno + 1 + } until (mt_examine (STDOUT, mtfile) == 0) + } +end + + +# MT_EXAMINE -- Examine a magtape file. Print file number, then count +# successive records. When the record size changes, print the number of +# records encountered with the old size. When all done, print the total +# number of records and bytes. Return the number of records in the file. + +int procedure mt_examine (out, mtfile) + +int out # output stream +char mtfile[ARB] # magtape file to be examined + +pointer buf +int in, nrecords, totrecords, totbytes, bufsize, recsize, last_recsize +errchk mtopen, read, fstati, printf, pargi +int mtopen(), read(), fstati() + +begin + in = mtopen (mtfile, READ_ONLY, 0) + bufsize = fstati (in, F_BUFSIZE) + call malloc (buf, bufsize, TY_CHAR) + + call fprintf (out, " File %s:\n") + call pargstr (mtfile) + + totrecords = 0 + nrecords = 0 + totbytes = 0 + last_recsize = 0 + + # Describe record composition of file. + while (read (in, Memc[buf], bufsize) != EOF) { + recsize = fstati (in, F_SZBBLK) + if (nrecords == 0) { # first record + nrecords = 1 + last_recsize = recsize + } else if (recsize == last_recsize) { + nrecords = nrecords + 1 + } else { + call fprintf (out, "\t%d %d-byte records\n") + call pargi (nrecords) + call pargi (last_recsize) + nrecords = 1 + last_recsize = recsize + } + totrecords = totrecords + 1 + totbytes = totbytes + recsize + } + + if (nrecords > 0) { + call fprintf (out, "\t%d %d-byte records\n") + call pargi (nrecords) + call pargi (last_recsize) + } + + # Print total count of records, bytes. + call fprintf (out, "\tTotal %d records, %d bytes\n") + call pargi (totrecords) + call pargi (totbytes) + + call mfree (buf, TY_CHAR) + call close (in) + + return (totrecords) +end + + +# MTCOPY -- Copy a binary file from magtape or disk to magtape or disk, +# using all the default FIO and MTIO pararameters. If the output file is +# a magtape, all records (except possibly the last record in the file) will +# be the same size. If input tape records are not commensurate with the size +# of a CHAR they will be zero-padded to an integral number of chars upon +# input. + +procedure t_mtcopy() + +pointer buf +int in, out, bufsize, acmode +char infile[SZ_FNAME], outfile[SZ_FNAME] +int mtopen(), fstati(), read(), mtfile() + +begin + call clgstr ("infile", infile, SZ_FNAME) + call clgstr ("outfile", outfile, SZ_FNAME) + + in = mtopen (infile, READ_ONLY, 0) + + # If output file is a disk file, create a new file, but do not + # create a new tape if writing to tape. + + acmode = NEW_FILE + if (mtfile(outfile) == YES) + acmode = WRITE_ONLY + out = mtopen (outfile, acmode, 0) + + bufsize = fstati (in, F_BUFSIZE) + call malloc (buf, bufsize, TY_CHAR) + + while (read (in, Memc[buf], bufsize) != EOF) + call write (out, Memc[buf], fstati (in, F_NCHARS)) + + call mfree (buf, TY_CHAR) + call close (in) + call close (out) +end + + +# REWIND -- Rewind the tape. + +procedure t_rewind() + +char mtname[SZ_FNAME] +bool clgetb() +int btoi() + +begin + call clgstr ("mtname", mtname, SZ_FNAME) + call mtrewind (mtname, btoi(clgetb("initialize"))) +end |