Windows does not provide sys/wait.h
[openafs.git] / src / butm / file_tm.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 #include <sys/types.h>
14 #ifdef AFS_NT40_ENV
15 #include <winsock2.h>
16 #else
17 #include <netinet/in.h>
18 #include <sys/wait.h>
19 #endif
20 #include <fcntl.h>
21 #include <errno.h>
22 #include <limits.h>
23 #include <sys/stat.h>
24 #include <stdio.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <lwp.h>
28 #include <afs/com_err.h>
29 #include <afs/butm.h>
30 #include <afs/usd.h>
31 #include "error_macros.h"
32 #include "butm_prototypes.h"
33
34 #ifdef O_LARGEFILE
35 typedef off64_t osi_lloff_t;
36 #else /* O_LARGEFILE */
37 #ifdef AFS_HAVE_LLSEEK
38 typedef offset_t osi_lloff_t;
39 #else /* AFS_HAVE_LLSEEK */
40 typedef off_t osi_lloff_t;
41 #endif /* AFS_HAVE_LLSEEK */
42 #endif /* O_LARGEFILE */
43
44 extern int isafile;
45
46 #define FILE_MAGIC  1000000007  /* s/w file mark */
47 #define FILE_BEGIN  0           /* byte field in file mark */
48 #define FILE_FMEND    1         /* byte field in file mark */
49 #define FILE_EOD    -1          /* byte field in file mark */
50 #define TAPE_MAGIC  1100000009  /* tape label block */
51 #define BLOCK_MAGIC 1100000005  /* file data block */
52 #ifdef AFS_PTHREAD_ENV
53 #define POLL()
54 #define SLEEP(s) sleep(s)
55 #else
56 #define POLL()   IOMGR_Poll()
57 #define SLEEP(s) IOMGR_Sleep(s)
58 #endif
59
60 /* Notes: (PA)
61  *
62  * 1) filemarks and block marks have the magic,bytes fields reversed. This
63  *      is undoubtedly a bug. Also note that the two structures have
64  *      inconsistent types, overlaying int and afs_int32.
65  * 2) When a volume is dumped, if the volume is locked, the dump will produce
66  *      an anomalous tape format of the form:
67  *              s/w file begin mark
68  *              volume header
69  *              s/w file end mark
70  *      The design of the original butm code means that this cannot be
71  *      handled correctly. The code is modified so that ReadFileData
72  *      returns BUTM_ENDVOLUME if it encounters the s/w filemark.
73  */
74
75 /* data organization on tape:
76  * all writes are in blocks of BUTM_BLOCKSIZE (= sizeof(blockMark) + BUTM_BLKSIZE)
77  * blockMark contains a magic number and counts of real data bytes
78  * written out in the block.
79  *
80  * each file is preceeded by a fileMark, which acts as the file 
81  * delimiter. A file consists of contigous data blocks. TM does
82  * understand or interrpet the data in data blocks. 
83  *
84  * The tape begins with a tape label and ends with EOF file markers
85  * in succession (2 or 4 of them ).
86  */
87
88
89 struct fileMark {               /* in network byte order */
90     afs_int32 magic;
91     afs_uint32 nBytes;
92 };
93
94 struct tapeLabel {
95     afs_int32 magic;
96     struct butm_tapeLabel label;
97 };
98
99 struct progress {
100     usd_handle_t fid;           /* file id of simulated tape */
101     afs_int32 mountId;          /* current mountId */
102     afs_int32 reading;          /* read file operation in progress */
103     afs_int32 writing;          /* write file operation in progress */
104 };
105
106 static struct configuration {
107     char tapedir[64];           /* directory to create "tapes" */
108     afs_int32 mountId;          /* for detecting simultaneous mounts */
109     afs_uint32 tapeSize;        /* size of simulated tapes */
110     afs_uint32 fileMarkSize;    /* size of file mark, bytes */
111     afs_int32 portOffset;       /* port + portOffset is used by TC to listen */
112 } config;
113
114 static char *whoami = "file_tm";
115 char tapeBlock[BUTM_BLOCKSIZE]; /* Tape buffer for reads and writes */
116
117 #define BLOCK_LABEL      0      /* read/write a  tape label     */
118 #define BLOCK_FMBEGIN    1      /* read/write a  begin FileMark */
119 #define BLOCK_DATA       2      /* read/write a  data block     */
120 #define BLOCK_FMEND      3      /* read/write an end FileMark   */
121 #define BLOCK_EOD        4      /* read/write an EOD FileMark   */
122 #define BLOCK_EOF        5      /* tape block is a HW EOF mark (usually error) */
123 #define BLOCK_UNKNOWN    6      /* tape block is unknwon (error) */
124
125 #define WRITE_OP 1
126 #define READ_OP  0
127
128 #define READS  (((struct progress *)(info->tmRock))->reading)
129 #define WRITES (((struct progress *)(info->tmRock))->writing)
130
131 /* ----------------------------------------------------------------------
132  * These routines use the usd library to perform tape operations.
133  * ForkIoctl, ForkOpen, ForkClose, ForwardSpace, BackwardSpace, WriteEOF, 
134  * PrepareAccess(nt), ShutdownAccess(nt)
135  * 
136  * Return Values: USD functions return 0 if successful or errno if failed.
137  */
138 /* ------------------ USD Interface Functions Begin ------------------------ */
139
140 /*
141  * On Unix, fork a child process to perform an IOCTL call. This avoids
142  * blocking the entire process during a tape operation
143  */
144
145 #ifndef AFS_NT40_ENV
146 /* Unix version of function */
147
148 static int
149 ForkIoctl(usd_handle_t fd, int op, int count)
150 {
151     int rc;                     /* return code from system calls */
152     int i;                      /* loop index */
153     int pid;                    /* process ID of child process */
154     int status;                 /* exit status of child process */
155     int ioctl_rc;               /* return code from ioctl call */
156     int pipefd[2];              /* pipe for child return status */
157     int forkflag;               /* flag set when ready to fork */
158     usd_tapeop_t tapeop;        /* tape operation specification */
159     int unixfd;
160
161 #ifdef AFS_PTHREAD_ENV
162     forkflag = 0;               /* No need to fork if using pthreads */
163 #else
164     forkflag = 1;
165 #endif
166
167     /* initialize tape command structure */
168     tapeop.tp_op = op;
169     tapeop.tp_count = count;
170
171     /* create pipe for getting return code from child */
172     if (forkflag) {
173         rc = pipe(pipefd);
174         if (rc < 0) {
175             printf("butm:  Can't open pipe for IOCTL process. Error %d\n",
176                    errno);
177             forkflag = 0;
178         }
179     }
180
181     if (forkflag) {
182         pid = fork();
183         if (pid < 0) {
184             close(pipefd[0]);
185             close(pipefd[1]);
186             printf("butm:  Can't fork IOCTL process. Error %d\n", errno);
187             forkflag = 0;
188
189         }
190     }
191
192     if (!forkflag) {            /* problem starting child process */
193         /* do the ioctl anyway, it will probably work */
194         ioctl_rc = USD_IOCTL(fd, USD_IOCTL_TAPEOPERATION, (void *)&tapeop);
195     } else if (pid == 0) {      /* child process */
196         /* close all unneccessary file descriptors */
197         /* note: as painful as it is, we have to reach under the covers of
198          *       the usd package to implement this functionality.
199          */
200         unixfd = (intptr_t)(fd->handle);
201
202         for (i = 3; i < _POSIX_OPEN_MAX; i++) {
203             if (i != unixfd && i != pipefd[1]) {
204                 close(i);
205             }
206         }
207
208         /* do the ioctl call */
209         ioctl_rc = USD_IOCTL(fd, USD_IOCTL_TAPEOPERATION, (void *)&tapeop);
210
211         /* send the return code back to the parent */
212         write(pipefd[1], &ioctl_rc, sizeof(int));
213
214         exit(0);
215     } else {                    /* parent process */
216
217         close(pipefd[1]);
218         POLL();
219         /* read the result from the child process */
220         rc = read(pipefd[0], &ioctl_rc, sizeof(int));
221         if (rc != sizeof(int)) {
222             /* tape is now in unknown state */
223             printf("butm:  Can't determine IOCTL child status. Error %d\n",
224                    errno);
225             ioctl_rc = EFAULT;
226         }
227
228         close(pipefd[0]);
229
230         /* get the completion status from the child process */
231         rc = waitpid(pid, &status, 0);
232         while (rc < 0 && errno == EINTR) {
233             rc = waitpid(pid, &status, 0);
234         }
235         if (rc < 0) {
236             printf("butm:  Can't determine IOCTL child status. Error %d\n",
237                    errno);
238         } else if (status != 0) {
239             printf
240                 ("butm: Unexpected IOCTL process status 0x%04x . Error %d\n",
241                  status, errno);
242         }
243         SLEEP(1);
244     }
245
246     return (ioctl_rc);
247 }
248 #else
249 /* NT version of function */
250
251 static int
252 ForkIoctl(usd_handle_t fd, int op, int count)
253 {
254     usd_tapeop_t tapeop;
255
256     /* Issue requested tape control */
257     tapeop.tp_op = op;
258     tapeop.tp_count = count;
259
260     return (USD_IOCTL(fd, USD_IOCTL_TAPEOPERATION, (void *)&tapeop));
261 }
262 #endif /* !AFS_NT40_ENV */
263
264
265 /*
266  * On Unix, fork a child process to attempt to open the drive. We want to make
267  * certain there is tape in the drive before trying to open the device
268  * in the main process
269  */
270
271 #ifndef AFS_NT40_ENV
272 /* Unix version of function. */
273
274 static int
275 ForkOpen(char *device)
276 {
277     int rc;                     /* return code from system calls */
278     int i;                      /* loop index */
279     int pid;                    /* process ID of child process */
280     int status;                 /* exit status of child process */
281     int open_rc;                /* return code from open */
282     int pipefd[2];              /* pipe for child return status */
283     int forkflag;               /* flag set when ready to fork */
284     usd_handle_t fd;            /* handle returned from open */
285
286 #ifdef AFS_PTHREAD_ENV
287     forkflag = 0;               /* No need to fork if using pthreads */
288 #else
289     forkflag = 1;
290 #endif
291
292     /* create pipe for getting return code from child */
293     if (forkflag) {
294         rc = pipe(pipefd);
295         if (rc < 0) {
296             printf("butm: Cannot create pipe for OPEN process. Error %d\n",
297                    errno);
298             forkflag = 0;
299         }
300     }
301
302     if (forkflag) {
303         pid = fork();
304         if (pid < 0) {
305             close(pipefd[0]);
306             close(pipefd[1]);
307             printf("butm: Cannot create child process for OPEN. Error %d\n",
308                    errno);
309             forkflag = 0;
310         }
311     }
312
313     if (!forkflag) {            /* problem starting child process */
314         /*
315          *return success, the caller will discover any problems
316          * when it opens the device.
317          */
318         open_rc = 0;
319     } else if (pid == 0) {      /* child process */
320         /* close all unneccessary file descriptors */
321         for (i = 3; i < _POSIX_OPEN_MAX; i++) {
322             if (i != pipefd[1]) {
323                 close(i);
324             }
325         }
326
327         /* try the open */
328         open_rc = usd_Open(device, USD_OPEN_RDONLY, 0, &fd);
329
330         if (open_rc == 0) {
331             USD_CLOSE(fd);
332         }
333
334         /* send the return code back to the parent */
335         write(pipefd[1], &open_rc, sizeof(open_rc));
336
337         exit(0);
338     } else {                    /* parent process */
339
340         close(pipefd[1]);
341
342         POLL();
343         /* read the result from the child process */
344         rc = read(pipefd[0], &open_rc, sizeof(open_rc));
345         if (rc != sizeof(open_rc)) {
346             /* this is not a problem since we will reopen the device anyway */
347             printf("butm: No response from  OPEN process. Error %d\n", errno);
348             open_rc = 0;
349         }
350
351         close(pipefd[0]);
352
353         /* get the completion status from the child process */
354         rc = waitpid(pid, &status, 0);
355         while (rc < 0 && errno == EINTR) {
356             rc = waitpid(pid, &status, 0);
357         }
358         if (rc < 0) {
359             printf("butm: Cannot get status of OPEN process. Error %d\n",
360                    errno);
361         } else if (status != 0) {
362             printf
363                 ("butm: Unexpected OPEN process exit status 0x%04x. Error %d \n",
364                  status, errno);
365         }
366         SLEEP(1);
367     }
368
369     return (open_rc);
370 }
371 #else
372 /* NT version of function. */
373
374 static int
375 ForkOpen(char *device)
376 {
377     return (0);
378 }
379 #endif /* AFS_NT40_ENV */
380
381 /*
382  * On Unix, fork a child process to close the drive. If the drive rewinds
383  * on close it could cause the process to block.
384  */
385
386 #ifndef AFS_NT40_ENV
387 /* Unix version of function */
388
389 static int
390 ForkClose(usd_handle_t fd)
391 {
392     int rc;                     /* return code from system calls */
393     int i;                      /* loop index */
394     int pid;                    /* process ID of child process */
395     int status;                 /* exit status of child process */
396     int close_rc, parent_close_rc;      /* return codes from close */
397     int pipefd[2];              /* pipe for child return status */
398     int ctlpipe[2];             /* pipe for message to child */
399     int forkflag;               /* flag set when ready to fork */
400     int unixfd;
401
402 #ifdef AFS_PTHREAD_ENV
403     forkflag = 0;               /* No need to fork if using pthreads */
404 #else
405     forkflag = 1;
406 #endif
407
408     /* create pipe for getting return code from child */
409     if (forkflag) {
410         rc = pipe(pipefd);
411         if (rc < 0) {
412             printf("butm: Cannot create pipe for CLOSE process. Error %d\n",
413                    errno);
414             forkflag = 0;
415         }
416     }
417
418     /* create pipe for notifying child when to close */
419     if (forkflag) {
420         rc = pipe(ctlpipe);
421         if (rc < 0) {
422             close(pipefd[0]);
423             close(pipefd[1]);
424             printf("butm: Cannot create pipe for CLOSE  process. Error %d\n",
425                    errno);
426             forkflag = 0;
427         }
428     }
429
430     if (forkflag) {
431         pid = fork();
432         if (pid < 0) {
433             close(pipefd[0]);
434             close(pipefd[1]);
435             close(ctlpipe[0]);
436             close(ctlpipe[1]);
437             printf("butm: Cannot create CLOSE child process. Error %d\n",
438                    errno);
439             forkflag = 0;
440         }
441     }
442
443     if (!forkflag) {            /* problem starting child process */
444         close_rc = USD_CLOSE(fd);
445         parent_close_rc = close_rc;
446     } else if (pid == 0) {      /* child process */
447         /* close all unneccessary file descriptors */
448         /* note: as painful as it is, we have to reach under the covers of
449          *       the usd package to implement this functionality.
450          */
451         unixfd = (intptr_t)(fd->handle);
452
453         for (i = 3; i < _POSIX_OPEN_MAX; i++) {
454             if (i != unixfd && i != ctlpipe[0] && i != pipefd[1]) {
455                 close(i);
456             }
457         }
458
459         /* the parent writes the control pipe after it closes the device */
460         read(ctlpipe[0], &close_rc, sizeof(int));
461         close(ctlpipe[0]);
462
463         /* do the close */
464         close_rc = USD_CLOSE(fd);
465
466         /* send the return code back to the parent */
467         write(pipefd[1], &close_rc, sizeof(int));
468
469         exit(0);
470     } else {                    /* parent process */
471
472         close(pipefd[1]);
473         close(ctlpipe[0]);
474
475         POLL();
476         /*
477          * close the device, this should have no effect as long as the
478          * child has not closed
479          */
480
481         parent_close_rc = USD_CLOSE(fd);
482
483         /* notify the child to do its close */
484         rc = write(ctlpipe[1], &close_rc, sizeof(int)); /* just send garbage */
485         if (rc != sizeof(int)) {
486             printf("butm: Error communicating with CLOSE process. Error %d\n",
487                    errno);
488         }
489         close(ctlpipe[1]);
490
491         /* read the result from the child process */
492         rc = read(pipefd[0], &close_rc, sizeof(int));
493         if (rc != sizeof(int)) {
494             /* logging is enough, since we wrote a file mark the */
495             /* return code from the close doesn't really matter  */
496             printf("butm: No response from  CLOSE  process. Error %d\n",
497                    errno);
498             close_rc = 0;
499         }
500
501         close(pipefd[0]);
502
503         /* get the completion status from the child process */
504         rc = waitpid(pid, &status, 0);
505         while (rc < 0 && errno == EINTR) {
506             rc = waitpid(pid, &status, 0);
507         }
508         if (rc < 0) {
509             printf("butm: Cannot get status of CLOSE  process. Error %d\n",
510                    errno);
511         } else if (status != 0) {
512             printf
513                 ("butm: Unexpected exit status 0x%04x from CLOSE  process. Error %d\n",
514                  status, errno);
515         }
516
517         /* if either process received an error, then return an error */
518         if (parent_close_rc < 0) {
519             close_rc = parent_close_rc;
520         }
521         SLEEP(1);
522     }
523
524     return (close_rc);
525 }
526 #else
527 /* NT version of function */
528
529 static int
530 ForkClose(usd_handle_t fd)
531 {
532     return (USD_CLOSE(fd));
533 }
534 #endif /* AFS_NT40_ENV */
535
536 /* Forward space file */
537 static int
538 ForwardSpace(usd_handle_t fid, int count)
539 {
540     POLL();
541
542     if (isafile) {
543         return (0);
544     } else {
545         return (ForkIoctl(fid, USDTAPE_FSF, count));
546     }
547 }
548
549 /* Backward space file */
550 static int
551 BackwardSpace(usd_handle_t fid, int count)
552 {
553     POLL();
554
555     if (isafile) {
556         return (0);
557     } else {
558         return (ForkIoctl(fid, USDTAPE_BSF, count));
559     }
560 }
561
562 /* write end of file mark */
563 static int
564 WriteEOF(usd_handle_t fid, int count)
565 {
566     POLL();
567
568     if (isafile) {
569         return (0);
570     } else {
571         return (ForkIoctl(fid, USDTAPE_WEOF, count));
572     }
573 }
574
575 /* rewind tape */
576 static int
577 Rewind(usd_handle_t fid)
578 {
579     if (isafile) {
580         afs_hyper_t startOff, stopOff;
581         hzero(startOff);
582
583         return (USD_SEEK(fid, startOff, SEEK_SET, &stopOff));
584     } else {
585         return (ForkIoctl(fid, USDTAPE_REW, 0));
586     };
587 }
588
589 /* prepare tape drive for access */
590 static int
591 PrepareAccess(usd_handle_t fid)
592 {
593     int code = 0;
594 #ifdef AFS_NT40_ENV
595     if (!isafile) {
596         (void)ForkIoctl(fid, USDTAPE_PREPARE, 0);
597     }
598     /* NT won't rewind tape when it is opened */
599     code = Rewind(fid);
600 #endif /* AFS_NT40_ENV */
601     return code;
602 }
603
604 /* decommission tape drive after all accesses complete */
605 static int
606 ShutdownAccess(usd_handle_t fid)
607 {
608 #ifdef AFS_NT40_ENV
609     if (!isafile) {
610         (void)ForkIoctl(fid, USDTAPE_SHUTDOWN, 0);
611     }
612 #endif /* AFS_NT40_ENV */
613     return 0;
614 }
615
616 /* -------------------- USD Interface Functions End ----------------------- */
617
618 /* =====================================================================
619  * Support routines
620  * ===================================================================== */
621
622 /* incSize
623  *      add the supplied no. of bytes to the byte count of information placed
624  *      on the tape.
625  * entry:
626  *      dataSize - bytes used on the tape
627  */
628
629 void
630 incSize(struct butm_tapeInfo *info, afs_uint32 dataSize)
631 {
632     info->nBytes += dataSize;
633     info->kBytes += (info->nBytes / 1024);
634     info->nBytes %= 1024;
635 }
636
637 /* incPosition
638  *      IF YOU ADD/CHANGE THE ifdefs, BE SURE
639  *      TO ALSO MAKE THE SAME CHANGES IN bu_utils/fms.c.
640  *
641  *      add the supplied no. of bytes to the byte count of data placed
642  *      on the tape. Also check for reaching 2GB limit and reset the 
643  *      pointer if necessary.  This allows us to use >2GB tapes.
644  * entry:
645  *      fid      - file id for the tape.
646  *      dataSize - bytes used on the tape
647  */
648
649 void
650 incPosition(struct butm_tapeInfo *info, usd_handle_t fid, afs_uint32 dataSize)
651 {
652     /* Add this to the amount of data written to the tape */
653     incSize(info, dataSize);
654
655     info->posCount += dataSize;
656
657     if (info->posCount >= 2147467264) { /* 2GB - 16K */
658         info->posCount = 0;
659 #if (defined(AFS_SUN_ENV) || defined(AFS_LINUX24_ENV))
660         if (!isafile) {
661         afs_hyper_t off;
662             hset64(off, 0, 0);
663             USD_IOCTL(fid, USD_IOCTL_SETSIZE, &off);
664         }
665 #endif
666     }
667 }
668
669 /*
670  * This accounts for tape drives with a block size different from variable or 16K 
671  * blocks and only reads that block size.
672  */
673 afs_int32 TapeBlockSize;
674 afs_int32
675 readData(usd_handle_t fid, char *data, afs_uint32 totalSize, afs_int32 *errorP)
676 {
677     afs_int32 toread;           /* Number of bytes to read */
678     afs_uint32 rSize;           /* Total bytes read so far */
679     afs_uint32 tSize;           /* Temporary size */
680     afs_int32 rc;               /* return code */
681
682     toread = totalSize;         /* First, try to read all the data */
683
684     rc = USD_READ(fid, &data[0], toread, &rSize);
685     if (rc != 0) {
686         *errorP = rc;
687         return -1;
688     }
689     if (rSize == 0)             /* reached EOF */
690         return rSize;
691
692     if (rSize != TapeBlockSize) {       /* Tape block size has changed */
693         TapeBlockSize = rSize;
694         printf("Tape blocks read in %d Byte chunks.\n", TapeBlockSize);
695     }
696
697     /* Read the rest of the data in */
698     while (rSize < totalSize) {
699         toread =
700             ((totalSize - rSize) <
701              TapeBlockSize ? (totalSize - rSize) : TapeBlockSize);
702         rc = USD_READ(fid, &data[rSize], toread, &tSize);
703         if (rc)
704             *errorP = rc;
705         else
706             rSize += tSize;
707         if (tSize != toread)
708             break;
709     }
710
711     if (rSize > totalSize)
712         printf("readData - Read > 16K data block - continuing.\n");
713
714     return (rSize);
715 }
716
717 afs_int32
718 SeekFile(struct butm_tapeInfo *info, int count)
719 {
720     afs_int32 code = 0;
721     struct progress *p;
722     afs_int32 error = 0;
723
724     if (count == 0)
725         ERROR_EXIT(0);
726     p = (struct progress *)info->tmRock;
727
728     if (isafile) {              /* no reason for seeking through a file */
729         p->reading = p->writing = 0;
730         return (0);
731     }
732
733     POLL();
734
735     if (count > 0)
736         error = ForwardSpace(p->fid, count);
737     else
738         error = BackwardSpace(p->fid, -count);
739
740     POLL();
741
742     if (error) {
743         info->status |= BUTM_STATUS_SEEKERROR;
744         ERROR_EXIT(BUTM_IOCTL);
745     }
746
747     info->position += count;
748     incSize(info, (count * config.fileMarkSize));
749     p = (struct progress *)info->tmRock;
750     p->reading = p->writing = 0;
751
752   error_exit:
753     if (error)
754         info->error = error;
755     return (code);
756 }
757
758 /* Step to the next filemark if we are not at one already */
759 afs_int32
760 NextFile(struct butm_tapeInfo *info)
761 {
762     afs_int32 code;
763
764     if (!READS && !WRITES)
765         return 0;
766
767     code = SeekFile(info, 1);
768     return (code);
769 }
770
771 static afs_int32
772 WriteTapeBlock(struct butm_tapeInfo *info, 
773                char *buffer,     /* assumed to be 16384 bytes with data in it */
774                afs_int32 length, /* amount data in buffer */
775                afs_int32 blockType)
776 {
777     afs_int32 code = 0, rc = 0;
778     afs_uint32 wsize;
779     struct tapeLabel *label;
780     struct fileMark *fmark;
781     struct blockMark *bmark;
782     struct progress *p;
783     afs_int32 error = 0;
784
785     p = (struct progress *)info->tmRock;
786
787     if (blockType == BLOCK_DATA) {      /* Data Block */
788         if (length == 0)
789             ERROR_EXIT(0);
790         bmark = (struct blockMark *)buffer;
791         memset(bmark, 0, sizeof(struct blockMark));
792         bmark->magic = htonl(BLOCK_MAGIC);
793         bmark->count = htonl(length);
794     } else if (blockType == BLOCK_FMBEGIN) {    /* Filemark - begin */
795         fmark = (struct fileMark *)buffer;
796         fmark->magic = htonl(FILE_MAGIC);
797         fmark->nBytes = htonl(FILE_BEGIN);
798     } else if (blockType == BLOCK_FMEND) {      /* Filemark - end */
799         fmark = (struct fileMark *)buffer;
800         fmark->magic = htonl(FILE_MAGIC);
801         fmark->nBytes = htonl(FILE_FMEND);
802     } else if (blockType == BLOCK_LABEL) {      /* Label */
803         label = (struct tapeLabel *)buffer;
804         label->magic = htonl(TAPE_MAGIC);
805     } else if (blockType == BLOCK_EOD) {        /* Filemark - EOD mark */
806         fmark = (struct fileMark *)buffer;
807         fmark->magic = htonl(FILE_MAGIC);
808         fmark->nBytes = htonl(FILE_EOD);
809     }
810
811     /* Write the tape block */
812     /* -------------------- */
813     rc = USD_WRITE(p->fid, buffer, BUTM_BLOCKSIZE, &wsize);
814     if ((rc == 0) && (wsize > 0)) {
815         incPosition(info, p->fid, wsize);       /* record whats written */
816         p->writing++;
817     }
818
819     if (wsize != BUTM_BLOCKSIZE) {
820         info->status |= BUTM_STATUS_WRITEERROR;
821         if (rc != 0) {
822             error = rc;
823             ERROR_EXIT(BUTM_IO);
824         } else
825             ERROR_EXIT(BUTM_EOT);
826     }
827     if (isafile)
828         info->position++;
829
830     /* Write trailing EOF marker for some block types */
831     /* ---------------------------------------------- */
832     if ((blockType == BLOCK_FMEND) || (blockType == BLOCK_LABEL)
833         || (blockType == BLOCK_EOD)) {
834
835         POLL();
836         error = WriteEOF(p->fid, 1);
837         POLL();
838         if (error) {
839             info->status |= BUTM_STATUS_WRITEERROR;
840             ERROR_EXIT(BUTM_IOCTL);
841         }
842
843         incSize(info, config.fileMarkSize);
844         if (!isafile)
845             info->position++;
846         p->writing = 0;
847     }
848
849   error_exit:
850     if (error)
851         info->error = error;
852     return (code);
853 }
854
855 static afs_int32
856 ReadTapeBlock(struct butm_tapeInfo *info, 
857               char *buffer, /* assumed to be 16384 bytes */
858               afs_int32 *blockType)
859 {
860     afs_int32 code = 0;
861     afs_int32 rsize, fmtype;
862     struct tapeLabel *label;
863     struct fileMark *fmark;
864     struct blockMark *bmark;
865     struct progress *p;
866
867     *blockType = BLOCK_UNKNOWN;
868
869     p = (struct progress *)info->tmRock;
870
871     memset(buffer, 0, BUTM_BLOCKSIZE);
872     label = (struct tapeLabel *)buffer;
873     fmark = (struct fileMark *)buffer;
874     bmark = (struct blockMark *)buffer;
875
876     rsize = readData(p->fid, buffer, BUTM_BLOCKSIZE, &info->error);
877     if (rsize > 0) {
878         incPosition(info, p->fid, rsize);
879         p->reading++;
880     }
881
882     if (rsize == 0) {           /* Read a HW EOF Marker? OK */
883         *blockType = BLOCK_EOF;
884         incSize(info, config.fileMarkSize);     /* Size of filemark */
885         if (!isafile)
886             info->position++;   /* bump position */
887         p->reading = 0;         /* No reads since EOF */
888     }
889
890     else if (rsize != BUTM_BLOCKSIZE) { /* Didn't Read a full block */
891         info->status |= BUTM_STATUS_READERROR;
892         ERROR_EXIT((rsize < 0) ? BUTM_IO : BUTM_EOT);
893     }
894
895     else if (ntohl(bmark->magic) == BLOCK_MAGIC) {      /* Data block? */
896         *blockType = BLOCK_DATA;
897     }
898
899     else if (ntohl(fmark->magic) == FILE_MAGIC) {       /* Read a filemark? */
900         fmtype = ntohl(fmark->nBytes);
901
902         if (fmtype == FILE_BEGIN) {     /* filemark begin */
903             *blockType = BLOCK_FMBEGIN;
904         } else if (fmtype == FILE_FMEND) {      /* filemark end */
905             *blockType = BLOCK_FMEND;
906             code = SeekFile(info, 1);
907         } else if (fmtype == FILE_EOD) {        /* EOD mark */
908             *blockType = BLOCK_EOD;
909             info->status |= BUTM_STATUS_EOD;
910             code = SeekFile(info, 1);
911         }
912     }
913
914     else if (ntohl(label->magic) == TAPE_MAGIC) {       /* Read a tape label? */
915         *blockType = BLOCK_LABEL;
916         code = SeekFile(info, 1);
917     }
918
919     if (isafile)
920         info->position++;
921
922   error_exit:
923     return (code);
924 }
925
926 /* check
927  *      check version numbers and permissions in the info structure
928  */
929
930 static afs_int32
931 check(struct butm_tapeInfo *info, 
932       int write) /* write operation requested */
933 {
934     struct progress *p;
935
936     if (!info)
937         return (BUTM_BADARGUMENT);
938
939     /* Check version number in info structure */
940     if (info->structVersion != BUTM_MAJORVERSION)
941         return BUTM_OLDINTERFACE;
942
943     /* Check if a tape is mounted */
944     if (((p = (struct progress *)info->tmRock) == 0) || (p->fid == 0))
945         return BUTM_NOMOUNT;
946
947     /* If writing check if there is write access */
948     if (write && (info->flags & BUTM_FLAGS_READONLY))
949         return BUTM_READONLY;
950
951     return 0;
952 }
953
954 static afs_int32
955 rewindFile(struct butm_tapeInfo *info)
956 {
957     struct progress *p;
958     afs_int32 code = 0;
959     afs_int32 error;
960
961     p = (struct progress *)info->tmRock;
962
963     POLL();
964
965     error = Rewind(p->fid);
966
967     POLL();
968
969     if (error) {
970         info->status |= BUTM_STATUS_SEEKERROR;
971         ERROR_EXIT(BUTM_IOCTL);
972     }
973
974     info->position = (isafile ? 0 : 1);
975     info->kBytes = info->nBytes = 0;
976     info->nFiles = info->nRecords = 0;
977     p->reading = p->writing = 0;
978
979   error_exit:
980     if (error)
981         info->error = error;
982     return (code);
983 }
984
985 /* =====================================================================
986  * butm routines
987  * ===================================================================== */
988
989 static afs_int32
990 file_Mount(struct butm_tapeInfo *info, char *tape)
991 {
992     struct progress *p;
993     char filename[64];
994     usd_handle_t fid;
995     int xflags;
996     afs_int32 code = 0, error = 0, rc = 0;
997
998     if (info->debug)
999         printf("butm: Mount tape drive\n");
1000
1001     POLL();
1002     info->error = 0;
1003
1004     if (!info || !tape)
1005         ERROR_EXIT(BUTM_BADARGUMENT);
1006     if (info->structVersion != BUTM_MAJORVERSION)
1007         ERROR_EXIT(BUTM_OLDINTERFACE);
1008     if (info->tmRock)
1009         ERROR_EXIT(BUTM_PARALLELMOUNTS);
1010     if (strlen(tape) >= sizeof(info->name))
1011         ERROR_EXIT(BUTM_BADARGUMENT);
1012
1013     strcpy(info->name, tape);
1014
1015     strcpy(filename, config.tapedir);   /* the name of the tape device */
1016     info->position = (isafile ? 0 : 1);
1017     info->kBytes = info->nBytes = 0;
1018     info->nRecords = info->nFiles = 0;
1019     info->recordSize = 0;
1020     info->tapeSize = config.tapeSize;
1021     info->coefBytes = 1;
1022     info->coefRecords = 0;
1023     info->coefFiles = sizeof(struct fileMark);
1024     info->simultaneousTapes = 1;
1025     info->status = 0;
1026     info->error = 0;
1027     info->flags = BUTM_FLAGS_SEQUENTIAL;
1028
1029     xflags = 0;
1030     if (isafile) {
1031         xflags |= USD_OPEN_CREATE;
1032     } else {
1033         /*
1034          * try to open in a child process first so nothing will
1035          * time out should the process block because the device
1036          * isn't ready.
1037          */
1038
1039         if (ForkOpen(filename)) {
1040             ERROR_EXIT(BUTM_MOUNTFAIL);
1041         }
1042     }
1043
1044     /* Now go ahead and open the tape drive for real */
1045     rc = usd_Open(filename, (USD_OPEN_RDWR | USD_OPEN_WLOCK | xflags), 0777,
1046                   &fid);
1047     if (rc != 0) {              /* try for lesser access */
1048         rc = usd_Open(filename, (USD_OPEN_RDONLY | USD_OPEN_RLOCK), 0, &fid);
1049
1050         if (rc) {
1051             error = rc;
1052             ERROR_EXIT(BUTM_MOUNTFAIL);
1053         }
1054         info->flags |= BUTM_FLAGS_READONLY;
1055     }
1056
1057     (void)PrepareAccess(fid);   /* for NT */
1058
1059     p = (struct progress *)malloc(sizeof(*p));
1060     info->tmRock = (char *)p;
1061     p->fid = fid;
1062     p->mountId = config.mountId = time(0);
1063     p->reading = p->writing = 0;
1064
1065     TapeBlockSize = BUTM_BLOCKSIZE;     /* Initialize */
1066
1067   error_exit:
1068     if (error)
1069         info->error = error;
1070     return (code);
1071 }
1072
1073 static afs_int32
1074 file_Dismount(struct butm_tapeInfo *info)
1075 {
1076     struct progress *p;
1077     afs_int32 code = 0, error = 0;
1078
1079     if (info->debug)
1080         printf("butm: Unmount tape drive\n");
1081
1082     POLL();
1083     info->error = 0;
1084
1085     code = check(info, READ_OP);
1086     if (code)
1087         ERROR_EXIT(code);
1088
1089     p = (struct progress *)info->tmRock;
1090
1091     (void)ShutdownAccess(p->fid);       /* for NT */
1092
1093     /* close the device */
1094     if ((error = ForkClose(p->fid))) {
1095         printf("butm: Tape close failed. Error %d\n", errno);
1096     }
1097
1098     POLL();
1099
1100     if (error) {
1101         code = BUTM_DISMOUNTFAIL;
1102         info->status |= BUTM_STATUS_TAPEERROR;
1103     }
1104
1105     config.mountId = 0;
1106     info->tmRock = 0;           /* mark it as closed - even if error on close */
1107     if (p)
1108         free(p);
1109
1110   error_exit:
1111     if (error)
1112         info->error = error;
1113     return (code);
1114 }
1115
1116 /* file_WriteLabel
1117  *      write the header on a tape
1118  * entry:
1119  *      info - handle on tape unit
1120  *      label - label information. This label is not copied onto the tape.
1121  *              If supplied, various fields are copied from this label to
1122  *              the actual tape label written on the tape.
1123  */
1124
1125 static afs_int32
1126 file_WriteLabel(struct butm_tapeInfo *info, struct butm_tapeLabel *label, 
1127                 afs_int32 rewind)
1128 {
1129     afs_int32 code = 0;
1130     afs_int32 fcode;
1131     struct tapeLabel *tlabel;
1132     struct progress *p;
1133     afs_hyper_t off;            /* offset */
1134
1135     if (info->debug)
1136         printf("butm: Write tape label\n");
1137
1138     POLL();
1139     info->error = 0;
1140
1141     code = check(info, WRITE_OP);
1142     if (code)
1143         ERROR_EXIT(code);
1144     if (!label)
1145         ERROR_EXIT(BUTM_BADARGUMENT);
1146     if (label->structVersion != CUR_TAPE_VERSION)
1147         ERROR_EXIT(BUTM_OLDINTERFACE);
1148
1149     if (rewind) {               /* Not appending, so rewind */
1150         code = rewindFile(info);
1151         if (code)
1152             ERROR_EXIT(code);
1153
1154         if (isafile) {
1155             p = (struct progress *)info->tmRock;
1156             hset64(off, 0, 0);
1157             code = USD_IOCTL(p->fid, USD_IOCTL_SETSIZE, &off);
1158             if (code)
1159                 ERROR_EXIT(BUTM_POSITION);
1160         }
1161     } else {
1162         if (READS || WRITES)
1163             ERROR_EXIT(BUTM_BADOP);
1164     }
1165
1166     /* Copy the label into the tape block
1167      * ---------------------------------- */
1168     memset(tapeBlock, 0, BUTM_BLOCKSIZE);
1169
1170     if (!label->creationTime)
1171         label->creationTime = time(0);
1172
1173     tlabel = (struct tapeLabel *)tapeBlock;
1174     memcpy(&tlabel->label, label, sizeof(struct butm_tapeLabel));
1175     tlabel->label.structVersion = htonl(CUR_TAPE_VERSION);
1176     tlabel->label.creationTime = htonl(tlabel->label.creationTime);
1177     tlabel->label.expirationDate = htonl(tlabel->label.expirationDate);
1178     tlabel->label.size = htonl(tlabel->label.size);
1179     tlabel->label.useCount = htonl(tlabel->label.useCount);
1180     tlabel->label.dumpid = htonl(tlabel->label.dumpid);
1181
1182     /* 
1183      * write the tape label - For appends, the write may need to skip 
1184      * over 1 or 2 EOF marks that were written when tape was closed after 
1185      * the last dump. Plus, some AIX tape drives require we try forwarding
1186      * over the last EOF and take an error before we can write the new label.
1187      * ---------------------------------------------------------------------- */
1188     code = WriteTapeBlock(info, tapeBlock, BUTM_BLOCKSIZE, BLOCK_LABEL);
1189     if (!isafile && !rewind && (code == BUTM_IO))
1190         do {                    /* do if write failed */
1191             fcode = SeekFile(info, 1);  /* skip over the EOF */
1192             if (fcode)
1193                 break;          /* leave if error */
1194
1195             code =
1196                 WriteTapeBlock(info, tapeBlock, BUTM_BLOCKSIZE, BLOCK_LABEL);
1197             if (code != BUTM_IO)
1198                 break;          /* continue if write failed */
1199
1200             fcode = SeekFile(info, 1);  /* skip over the EOF */
1201             if (fcode) {        /* retry 1 write if couldn't skip */
1202                 code =
1203                     WriteTapeBlock(info, tapeBlock, BUTM_BLOCKSIZE,
1204                                    BLOCK_LABEL);
1205                 break;
1206             }
1207
1208             code =
1209                 WriteTapeBlock(info, tapeBlock, BUTM_BLOCKSIZE, BLOCK_LABEL);
1210             if (code != BUTM_IO)
1211                 break;          /* continue if write failed */
1212
1213             fcode = SeekFile(info, 1);  /* skip over the EOF */
1214             if (fcode) {        /* retry 1 write if couldn't skip */
1215                 code =
1216                     WriteTapeBlock(info, tapeBlock, BUTM_BLOCKSIZE,
1217                                    BLOCK_LABEL);
1218                 break;
1219             }
1220             break;
1221         } while (0);
1222
1223     /* clear the write error status a failed WriteTapeBlock may have produced */
1224     if (!code)
1225         info->status &= ~BUTM_STATUS_WRITEERROR;
1226
1227   error_exit:
1228     return code;
1229 }
1230
1231 static afs_int32
1232 file_ReadLabel(struct butm_tapeInfo *info, struct butm_tapeLabel *label, 
1233                afs_int32 rewind)
1234 {
1235     struct tapeLabel *tlabel;
1236     afs_int32 code = 0;
1237     afs_int32 blockType;
1238
1239     if (info->debug)
1240         printf("butm: Read tape label\n");
1241
1242     POLL();
1243     info->error = 0;
1244
1245     code = check(info, READ_OP);
1246     if (code)
1247         ERROR_EXIT(code);
1248     if (READS || WRITES)
1249         ERROR_EXIT(BUTM_BADOP);
1250
1251     if (rewind) {
1252         code = rewindFile(info);
1253         if (code)
1254             ERROR_EXIT(code);   /* status is set so return */
1255     }
1256
1257     /*
1258      * When appended labels were written, either 1 or 2 EOF marks may
1259      * have had to be skipped.  When reading a label, these EOF marks 
1260      * must also be skipped. When an EOF is read, 0 bytes are returned
1261      * (refer to the write calls in file_WriteLabel routine).
1262      * ---------------------------------------------------------------- */
1263     code = ReadTapeBlock(info, tapeBlock, &blockType);
1264     if (!isafile && !rewind && (blockType == BLOCK_EOF))
1265         do {
1266             code = ReadTapeBlock(info, tapeBlock, &blockType);
1267             if (blockType != BLOCK_EOF)
1268                 break;          /* didn't read an EOF */
1269
1270             code = ReadTapeBlock(info, tapeBlock, &blockType);
1271         } while (0);
1272
1273     if (blockType == BLOCK_UNKNOWN)
1274         ERROR_EXIT(BUTM_NOLABEL);
1275     if (code)
1276         ERROR_EXIT(code);
1277     if (blockType != BLOCK_LABEL)
1278         ERROR_EXIT(BUTM_BADBLOCK);
1279
1280     /* Copy label out
1281      * -------------- */
1282     if (label) {
1283         tlabel = (struct tapeLabel *)tapeBlock;
1284         memcpy(label, &tlabel->label, sizeof(struct butm_tapeLabel));
1285         label->structVersion = ntohl(label->structVersion);
1286         label->creationTime = ntohl(label->creationTime);
1287         label->expirationDate = ntohl(label->expirationDate);
1288         label->size = ntohl(label->size);
1289         label->dumpid = ntohl(label->dumpid);
1290         label->useCount = ntohl(label->useCount);
1291
1292         info->tapeSize = label->size;   /* use size from label */
1293     }
1294
1295   error_exit:
1296     return (code);
1297 }
1298
1299 static afs_int32
1300 file_WriteFileBegin(struct butm_tapeInfo *info)
1301 {
1302     afs_int32 code = 0;
1303
1304     if (info->debug)
1305         printf("butm: Write filemark begin\n");
1306
1307     POLL();
1308
1309     code = check(info, WRITE_OP);
1310     if (code)
1311         ERROR_EXIT(code);
1312
1313     code = WriteTapeBlock(info, tapeBlock, BUTM_BLOCKSIZE, BLOCK_FMBEGIN);
1314     if (code)
1315         ERROR_EXIT(code);
1316
1317     info->nFiles++;
1318
1319   error_exit:
1320     return (code);
1321 }
1322
1323 static afs_int32
1324 file_ReadFileBegin(struct butm_tapeInfo *info)
1325 {
1326     afs_int32 code = 0;
1327     afs_int32 blockType;
1328
1329     if (info->debug)
1330         printf("butm: Read filemark begin\n");
1331
1332     POLL();
1333     info->error = 0;
1334
1335     code = check(info, READ_OP);
1336     if (code)
1337         ERROR_EXIT(code);
1338     if (READS || WRITES)
1339         ERROR_EXIT(BUTM_BADOP);
1340
1341     code = ReadTapeBlock(info, tapeBlock, &blockType);
1342     if (code)
1343         ERROR_EXIT(code);
1344
1345     if (blockType != BLOCK_FMBEGIN) {
1346         if (blockType == BLOCK_EOD)
1347             ERROR_EXIT(BUTM_EOD);       /* EODump label */
1348         if (blockType == BLOCK_LABEL)
1349             ERROR_EXIT(BUTM_LABEL);     /* Tape label */
1350         ERROR_EXIT(BUTM_BADBLOCK);      /* Other */
1351     }
1352
1353   error_exit:
1354     return (code);
1355 }
1356
1357 /* Writes data out in block sizes of 16KB. Does destroy the data.
1358  * Assumes the data buffer has a space reserved at beginning for a blockMark.
1359  */
1360 static afs_int32
1361 file_WriteFileData(struct butm_tapeInfo *info, char *data, afs_int32 blocks, afs_int32 len)
1362 {
1363     afs_int32 code = 0;
1364     int length;
1365     afs_int32 b;
1366     char *bstart;               /* Where block starts for a 16K block */
1367     char *dstart;               /* Where data  starts for a 16K block */
1368
1369     if (info->debug)
1370         printf("butm: Write tape data - %u bytes\n", len);
1371
1372     POLL();
1373     info->error = 0;
1374
1375     code = check(info, WRITE_OP);
1376     if (code)
1377         ERROR_EXIT(code);
1378     if (!data || (len < 0))
1379         ERROR_EXIT(BUTM_BADARGUMENT);
1380     if (READS || !WRITES)
1381         ERROR_EXIT(BUTM_BADOP);
1382
1383     b = 0;                      /* start at block 0 */
1384     while (len > 0) {
1385         dstart = &data[b * BUTM_BLKSIZE];
1386         bstart = dstart - sizeof(struct blockMark);
1387
1388         if (len < BUTM_BLKSIZE) {
1389             memset(&dstart[len], 0, BUTM_BLKSIZE - len);
1390             length = len;
1391         } else {
1392             length = BUTM_BLKSIZE;
1393         }
1394
1395         code = WriteTapeBlock(info, bstart, length, BLOCK_DATA);
1396
1397         len -= length;
1398
1399         /* If there are more blocks, step to next block */
1400         /* Otherwise, copy the data to beginning of last block */
1401
1402         if (b < (blocks - 1))
1403             b++;
1404         else if (len)
1405             memcpy(&dstart[0], &dstart[BUTM_BLKSIZE], len);
1406     }
1407
1408   error_exit:
1409     return (code);
1410 }
1411
1412 /* file_ReadFileData
1413  *      Read a data block from tape.
1414  * entry:
1415  *      info - tape info structure, c.f. fid
1416  *      data - ptr to buffer for data
1417  *      len - size of data buffer
1418  * exit:
1419  *      nBytes - no. of data bytes read.
1420  */
1421
1422 static afs_int32
1423 file_ReadFileData(struct butm_tapeInfo *info, char *data, int len, int *nBytes)
1424 {
1425     struct blockMark *bmark;
1426     afs_int32 code = 0;
1427     afs_int32 blockType;
1428
1429     if (info->debug)
1430         printf("butm: Read tape data - %u bytes\n", len);
1431
1432     POLL();
1433     info->error = 0;
1434
1435     if (!nBytes)
1436         ERROR_EXIT(BUTM_BADARGUMENT);
1437     *nBytes = 0;
1438
1439     code = check(info, READ_OP);
1440     if (code)
1441         ERROR_EXIT(code);
1442     if (!data || (len < 0) || (len > BUTM_BLKSIZE))
1443         ERROR_EXIT(BUTM_BADARGUMENT);
1444     if (!READS || WRITES)
1445         ERROR_EXIT(BUTM_BADOP);
1446
1447     data -= sizeof(struct blockMark);
1448     code = ReadTapeBlock(info, data, &blockType);
1449     if (code)
1450         ERROR_EXIT(code);
1451
1452     if (blockType != BLOCK_DATA) {
1453         if (blockType == BLOCK_EOF)
1454             ERROR_EXIT(BUTM_EOF);
1455         if (blockType == BLOCK_FMEND)
1456             ERROR_EXIT(BUTM_ENDVOLUME);
1457         ERROR_EXIT(BUTM_BADBLOCK);
1458     }
1459
1460     bmark = (struct blockMark *)data;
1461     *nBytes = ntohl(bmark->count);      /* Size of data in buf */
1462
1463   error_exit:
1464     return (code);
1465 }
1466
1467 static afs_int32
1468 file_WriteFileEnd(struct butm_tapeInfo *info)
1469 {
1470     afs_int32 code = 0;
1471
1472     if (info->debug)
1473         printf("butm: Write filemark end\n");
1474
1475     POLL();
1476     info->error = 0;
1477
1478     code = check(info, WRITE_OP);
1479     if (code)
1480         ERROR_EXIT(code);
1481     if (READS || !WRITES)
1482         ERROR_EXIT(BUTM_BADOP);
1483
1484     code = WriteTapeBlock(info, tapeBlock, BUTM_BLOCKSIZE, BLOCK_FMEND);
1485
1486   error_exit:
1487     return (code);
1488 }
1489
1490 /* Read a SW filemark, verify that it is a SW filemark, then skip to the next 
1491  * HW filemark. If the read of the SW filemark shows it's an EOF, then 
1492  * ignore that the SW filemark is not there and return 0 (found the SW filemark
1493  * missing with some 3.1 dumps).
1494  */
1495 static afs_int32
1496 file_ReadFileEnd(struct butm_tapeInfo *info)
1497 {
1498     afs_int32 code = 0;
1499     afs_int32 blockType;
1500
1501     if (info->debug)
1502         printf("butm: Read filemark end\n");
1503
1504     POLL();
1505     info->error = 0;
1506
1507     code = check(info, READ_OP);
1508     if (code)
1509         ERROR_EXIT(code);
1510     if (!READS || WRITES)
1511         ERROR_EXIT(BUTM_BADOP);
1512
1513     info->status &= ~BUTM_STATUS_EOF;
1514
1515     code = ReadTapeBlock(info, tapeBlock, &blockType);
1516     if (code)
1517         ERROR_EXIT(code);
1518
1519     if ((blockType != BLOCK_FMEND) && (blockType != BLOCK_EOF))
1520         ERROR_EXIT(BUTM_BADBLOCK);
1521
1522   error_exit:
1523     return code;
1524 }
1525
1526 /*
1527  * Write the end-of-dump marker.
1528  */
1529 static afs_int32
1530 file_WriteEODump(struct butm_tapeInfo *info)
1531 {
1532     afs_int32 code = 0;
1533
1534     if (info->debug)
1535         printf("butm: Write filemark EOD\n");
1536
1537     POLL();
1538     info->error = 0;
1539
1540     code = check(info, WRITE_OP);
1541     if (code)
1542         ERROR_EXIT(code);
1543     if (READS || WRITES)
1544         ERROR_EXIT(BUTM_BADOP);
1545
1546     code = WriteTapeBlock(info, tapeBlock, BUTM_BLOCKSIZE, BLOCK_EOD);
1547     if (code)
1548         ERROR_EXIT(code);
1549
1550     info->status |= BUTM_STATUS_EOD;
1551
1552   error_exit:
1553     return (code);
1554 }
1555
1556 static afs_int32
1557 file_Seek(struct butm_tapeInfo *info, afs_int32 position)
1558 {
1559     afs_int32 code = 0;
1560     afs_int32 w;
1561     osi_lloff_t posit;
1562     afs_uint32 c, d;
1563     struct progress *p;
1564     afs_hyper_t startOff, stopOff;      /* for normal file(non-tape)  seeks  */
1565
1566     if (info->debug)
1567         printf("butm: Seek to the tape position %d\n", position);
1568
1569     info->error = 0;
1570
1571     code = check(info, READ_OP);
1572     if (code)
1573         ERROR_EXIT(code);
1574
1575     if (isafile) {
1576         p = (struct progress *)info->tmRock;
1577         posit = (osi_lloff_t) position *(osi_lloff_t) BUTM_BLOCKSIZE;
1578
1579         /* Not really necessary to do it this way, should be fixed */
1580 #ifdef O_LARGEFILE
1581         c = (posit >> 32);
1582         d = (posit & 0xffffffff);
1583 #else
1584         c = 0;
1585         d = posit;
1586 #endif
1587         hset64(startOff, c, d);
1588
1589         w = USD_SEEK(p->fid, startOff, SEEK_SET, &stopOff);
1590         if (w)
1591             info->error = w;
1592         if (hcmp(startOff, stopOff) != 0)
1593             ERROR_EXIT(BUTM_POSITION);
1594
1595         p->reading = p->writing = 0;
1596         info->position = position;
1597     } else {
1598         /* Don't position backwards if we are in-between FMs */
1599         if ((READS || WRITES) && ((position - info->position) <= 0))
1600             ERROR_EXIT(BUTM_BADOP);
1601
1602         code = SeekFile(info, (position - info->position));
1603         if (code)
1604             ERROR_EXIT(code);
1605     }
1606
1607   error_exit:
1608     return (code);
1609 }
1610
1611 /*
1612  * Seek to the EODump (end-of-dump) after the given position. This is 
1613  * the position after the EOF filemark immediately after the EODump mark. 
1614  * This is for tapes of version 4 or greater.
1615  */
1616 static afs_int32
1617 file_SeekEODump(struct butm_tapeInfo *info, afs_int32 position)
1618 {
1619     afs_int32 code = 0;
1620     afs_int32 blockType;
1621     afs_int32 w;
1622     struct progress *p;
1623     afs_hyper_t startOff, stopOff;      /* file seek offsets */
1624
1625     if (info->debug)
1626         printf("butm: Seek to end-of-dump\n");
1627     info->error = 0;
1628
1629     code = check(info, READ_OP);
1630     if (code)
1631         ERROR_EXIT(code);
1632     if (READS || WRITES)
1633         ERROR_EXIT(BUTM_BADOP);
1634
1635     if (isafile) {
1636         p = (struct progress *)info->tmRock;
1637         hset64(startOff, 0, 0);
1638         w = USD_SEEK(p->fid, startOff, SEEK_END, &stopOff);
1639         if (w) {
1640             info->error = w;
1641             ERROR_EXIT(BUTM_POSITION);
1642         }
1643
1644         if (hgetlo(stopOff) % BUTM_BLOCKSIZE)
1645             ERROR_EXIT(BUTM_POSITION);
1646         info->position = (hgetlo(stopOff) / BUTM_BLOCKSIZE);
1647     } else {
1648         /* Seek to the desired position */
1649         code = SeekFile(info, (position - info->position) + 1);
1650         if (code)
1651             ERROR_EXIT(code);
1652
1653         /*
1654          * Search until the filemark is an EODump filemark.
1655          * Skip over volumes only.
1656          */
1657         while (1) {
1658             code = ReadTapeBlock(info, tapeBlock, &blockType);
1659             if (code)
1660                 ERROR_EXIT(code);
1661
1662             if (blockType == BLOCK_EOD)
1663                 break;
1664             if (blockType != BLOCK_FMBEGIN)
1665                 ERROR_EXIT(BUTM_BADBLOCK);
1666
1667             code = SeekFile(info, 1);   /* Step forward to next volume */
1668             if (code)
1669                 ERROR_EXIT(code);
1670         }
1671         code = 0;
1672     }
1673
1674   error_exit:
1675     return (code);
1676 }
1677
1678 static afs_int32
1679 file_SetSize(struct butm_tapeInfo *info, afs_uint32 size)
1680 {
1681     if (info->debug)
1682         printf("butm: Set size of tape\n");
1683     info->error = 0;
1684
1685     if (size <= 0)
1686         info->tapeSize = config.tapeSize;
1687     else
1688         info->tapeSize = size;
1689     return 0;
1690 }
1691
1692 static afs_int32
1693 file_GetSize(struct butm_tapeInfo *info, afs_uint32 *size)
1694 {
1695     if (info->debug)
1696         printf("butm: Get size of tape\n");
1697     info->error = 0;
1698
1699     *size = info->tapeSize;
1700     return 0;
1701 }
1702
1703 /* =====================================================================
1704  * Startup/configuration routines.
1705  * ===================================================================== */
1706
1707 static afs_int32
1708 file_Configure(struct tapeConfig *file)
1709 {
1710     if (!file) {
1711         afs_com_err(whoami, BUTM_BADCONFIG, "device not specified");
1712         return BUTM_BADCONFIG;
1713     }
1714
1715     config.tapeSize = file->capacity;
1716     config.fileMarkSize = file->fileMarkSize;
1717     config.portOffset = file->portOffset;
1718     strcpy(config.tapedir, file->device);
1719
1720     /* Tape must be large enough to at least fit a label */
1721     if (config.tapeSize <= 0) {
1722         afs_com_err(whoami, BUTM_BADCONFIG, "Tape size bogus: %d Kbytes",
1723                 config.tapeSize);
1724         return BUTM_BADCONFIG;
1725     }
1726
1727     if (strlen(config.tapedir) == 0) {
1728         afs_com_err(whoami, BUTM_BADCONFIG, "no tape device specified");
1729         return BUTM_BADCONFIG;
1730     }
1731
1732     config.mountId = 0;
1733     return 0;
1734 }
1735
1736 /* This procedure instantiates a tape module of type file_tm. */
1737 afs_int32
1738 butm_file_Instantiate(struct butm_tapeInfo *info, struct tapeConfig *file)
1739 {
1740     extern int debugLevel;
1741     afs_int32 code = 0;
1742
1743     if (debugLevel > 98)
1744         printf("butm: Instantiate butc\n");
1745
1746     if (!info)
1747         ERROR_EXIT(BUTM_BADARGUMENT);
1748     if (info->structVersion != BUTM_MAJORVERSION)
1749         ERROR_EXIT(BUTM_OLDINTERFACE);
1750
1751     memset(info, 0, sizeof(struct butm_tapeInfo));
1752     info->structVersion = BUTM_MAJORVERSION;
1753     info->ops.mount = file_Mount;
1754     info->ops.dismount = file_Dismount;
1755     info->ops.create = file_WriteLabel;
1756     info->ops.readLabel = file_ReadLabel;
1757     info->ops.seek = file_Seek;
1758     info->ops.seekEODump = file_SeekEODump;
1759     info->ops.readFileBegin = file_ReadFileBegin;
1760     info->ops.readFileData = file_ReadFileData;
1761     info->ops.readFileEnd = file_ReadFileEnd;
1762     info->ops.writeFileBegin = file_WriteFileBegin;
1763     info->ops.writeFileData = file_WriteFileData;
1764     info->ops.writeFileEnd = file_WriteFileEnd;
1765     info->ops.writeEOT = file_WriteEODump;
1766     info->ops.setSize = file_SetSize;
1767     info->ops.getSize = file_GetSize;
1768     info->debug = ((debugLevel > 98) ? 1 : 0);
1769
1770     code = file_Configure(file);
1771
1772   error_exit:
1773     return code;
1774 }