butm-restore-from-large-files-20030729
[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 RCSID
14     ("$Header$");
15
16 #ifdef AFS_NT40_ENV
17 #include <winsock2.h>
18 #else
19 #include <netinet/in.h>
20 #endif
21 #include <sys/types.h>
22 #include <fcntl.h>
23 #include <errno.h>
24 #include <limits.h>
25 #include <sys/stat.h>
26 #include <stdio.h>
27 #include <ctype.h>
28 #include <lwp.h>
29 #include <afs/com_err.h>
30 #include <afs/butm.h>
31 #include <afs/usd.h>
32 #include "error_macros.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 = (int)(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 = (int)(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 0x04x 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
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 incSize(info, dataSize)
630      struct butm_tapeInfo *info;
631      afs_uint32 dataSize;
632 {
633     info->nBytes += dataSize;
634     info->kBytes += (info->nBytes / 1024);
635     info->nBytes %= 1024;
636 }
637
638 /* incPosition
639  *      IF YOU ADD/CHANGE THE ifdefs, BE SURE
640  *      TO ALSO MAKE THE SAME CHANGES IN bu_utils/fms.c.
641  *
642  *      add the supplied no. of bytes to the byte count of data placed
643  *      on the tape. Also check for reaching 2GB limit and reset the 
644  *      pointer if necessary.  This allows us to use >2GB tapes.
645  * entry:
646  *      fid      - file id for the tape.
647  *      dataSize - bytes used on the tape
648  */
649
650 incPosition(info, fid, dataSize)
651      struct butm_tapeInfo *info;
652      usd_handle_t fid;
653      afs_uint32 dataSize;
654 {
655     afs_hyper_t off;
656
657     /* Add this to the amount of data written to the tape */
658     incSize(info, dataSize);
659
660     info->posCount += dataSize;
661
662     if (info->posCount >= 2147467264) { /* 2GB - 16K */
663         info->posCount = 0;
664 #if (defined(AFS_SUN_ENV) || defined(AFS_DEC_ENV) || defined(AFS_LINUX24_ENV))
665         if (!isafile) {
666             hset64(off, 0, 0);
667             USD_IOCTL(fid, USD_IOCTL_SETSIZE, &off);
668         }
669 #endif
670     }
671 }
672
673 /*
674  * This accounts for tape drives with a block size different from variable or 16K 
675  * blocks and only reads that block size.
676  */
677 afs_int32 TapeBlockSize;
678 afs_int32
679 readData(fid, data, totalSize, errorP)
680      usd_handle_t fid;
681      char *data;
682      afs_int32 totalSize;
683      afs_int32 *errorP;
684 {
685     afs_int32 toread;           /* Number of bytes to read */
686     afs_int32 rSize;            /* Total bytes read so far */
687     afs_int32 tSize;            /* Temporary size */
688     afs_int32 rc;               /* return code */
689
690     toread = totalSize;         /* First, try to read all the data */
691
692     rc = USD_READ(fid, &data[0], toread, &rSize);
693     if (rc != 0) {
694         *errorP = rc;
695         return -1;
696     }
697     if (rSize == 0)             /* reached EOF */
698         return rSize;
699
700     if (rSize != TapeBlockSize) {       /* Tape block size has changed */
701         TapeBlockSize = rSize;
702         printf("Tape blocks read in %d Byte chunks.\n", TapeBlockSize);
703     }
704
705     /* Read the rest of the data in */
706     while (rSize < totalSize) {
707         toread =
708             ((totalSize - rSize) <
709              TapeBlockSize ? (totalSize - rSize) : TapeBlockSize);
710         rc = USD_READ(fid, &data[rSize], toread, &tSize);
711         if (rc)
712             *errorP = rc;
713         else
714             rSize += tSize;
715         if (tSize != toread)
716             break;
717     }
718
719     if (rSize > totalSize)
720         printf("readData - Read > 16K data block - continuing.\n");
721
722     return (rSize);
723 }
724
725 afs_int32
726 SeekFile(info, count)
727      struct butm_tapeInfo *info;
728      int count;
729 {
730     afs_int32 code = 0;
731     afs_int32 fcode;
732     int cpid, status, rcpid, stat;
733     struct progress *p;
734     afs_int32 error = 0;
735
736     if (count == 0)
737         ERROR_EXIT(0);
738     p = (struct progress *)info->tmRock;
739
740     if (isafile) {              /* no reason for seeking through a file */
741         p->reading = p->writing = 0;
742         return (0);
743     }
744
745     POLL();
746
747     if (count > 0)
748         error = ForwardSpace(p->fid, count);
749     else
750         error = BackwardSpace(p->fid, -count);
751
752     POLL();
753
754     if (error) {
755         info->status |= BUTM_STATUS_SEEKERROR;
756         ERROR_EXIT(BUTM_IOCTL);
757     }
758
759     info->position += count;
760     incSize(info, (count * config.fileMarkSize));
761     p = (struct progress *)info->tmRock;
762     p->reading = p->writing = 0;
763
764   error_exit:
765     if (error)
766         info->error = error;
767     return (code);
768 }
769
770 /* Step to the next filemark if we are not at one already */
771 afs_int32
772 NextFile(info)
773      struct butm_tapeInfo *info;
774 {
775     afs_int32 code;
776
777     if (!READS && !WRITES)
778         return 0;
779
780     code = SeekFile(info, 1);
781     return (code);
782 }
783
784 static afs_int32
785 WriteTapeBlock(info, buffer, length, blockType)
786      struct butm_tapeInfo *info;
787      char *buffer;              /* assumed to be 16384 bytes with data in it */
788      afs_int32 length;          /* amount data in buffer */
789      afs_int32 blockType;
790 {
791     afs_int32 code = 0, rc = 0;
792     afs_int32 wsize;
793     struct tapeLabel *label;
794     struct fileMark *fmark;
795     struct blockMark *bmark;
796     struct progress *p;
797     afs_int32 error = 0;
798
799     p = (struct progress *)info->tmRock;
800
801     if (blockType == BLOCK_DATA) {      /* Data Block */
802         if (length == 0)
803             ERROR_EXIT(0);
804         bmark = (struct blockMark *)buffer;
805         memset(bmark, 0, sizeof(struct blockMark));
806         bmark->magic = htonl(BLOCK_MAGIC);
807         bmark->count = htonl(length);
808     } else if (blockType == BLOCK_FMBEGIN) {    /* Filemark - begin */
809         fmark = (struct fileMark *)buffer;
810         fmark->magic = htonl(FILE_MAGIC);
811         fmark->nBytes = htonl(FILE_BEGIN);
812     } else if (blockType == BLOCK_FMEND) {      /* Filemark - end */
813         fmark = (struct fileMark *)buffer;
814         fmark->magic = htonl(FILE_MAGIC);
815         fmark->nBytes = htonl(FILE_FMEND);
816     } else if (blockType == BLOCK_LABEL) {      /* Label */
817         label = (struct tapeLabel *)buffer;
818         label->magic = htonl(TAPE_MAGIC);
819     } else if (blockType == BLOCK_EOD) {        /* Filemark - EOD mark */
820         fmark = (struct fileMark *)buffer;
821         fmark->magic = htonl(FILE_MAGIC);
822         fmark->nBytes = htonl(FILE_EOD);
823     }
824
825     /* Write the tape block */
826     /* -------------------- */
827     rc = USD_WRITE(p->fid, buffer, BUTM_BLOCKSIZE, &wsize);
828     if ((rc == 0) && (wsize > 0)) {
829         incPosition(info, p->fid, wsize);       /* record whats written */
830         p->writing++;
831     }
832
833     if (wsize != BUTM_BLOCKSIZE) {
834         info->status |= BUTM_STATUS_WRITEERROR;
835         if (rc != 0) {
836             error = rc;
837             ERROR_EXIT(BUTM_IO);
838         } else
839             ERROR_EXIT(BUTM_EOT);
840     }
841     if (isafile)
842         info->position++;
843
844     /* Write trailing EOF marker for some block types */
845     /* ---------------------------------------------- */
846     if ((blockType == BLOCK_FMEND) || (blockType == BLOCK_LABEL)
847         || (blockType == BLOCK_EOD)) {
848
849         POLL();
850         error = WriteEOF(p->fid, 1);
851         POLL();
852         if (error) {
853             info->status |= BUTM_STATUS_WRITEERROR;
854             ERROR_EXIT(BUTM_IOCTL);
855         }
856
857         incSize(info, config.fileMarkSize);
858         if (!isafile)
859             info->position++;
860         p->writing = 0;
861     }
862
863   error_exit:
864     if (error)
865         info->error = error;
866     return (code);
867 }
868
869 static afs_int32
870 ReadTapeBlock(info, buffer, blockType)
871      struct butm_tapeInfo *info;
872      char *buffer;              /* assumed to be 16384 bytes */
873      afs_int32 *blockType;
874 {
875     afs_int32 code = 0;
876     afs_int32 rsize, fmtype;
877     struct tapeLabel *label;
878     struct fileMark *fmark;
879     struct blockMark *bmark;
880     struct progress *p;
881
882     *blockType = BLOCK_UNKNOWN;
883
884     p = (struct progress *)info->tmRock;
885
886     memset(buffer, 0, BUTM_BLOCKSIZE);
887     label = (struct tapeLabel *)buffer;
888     fmark = (struct fileMark *)buffer;
889     bmark = (struct blockMark *)buffer;
890
891     rsize = readData(p->fid, buffer, BUTM_BLOCKSIZE, &info->error);
892     if (rsize > 0) {
893         incPosition(info, p->fid, rsize);
894         p->reading++;
895     }
896
897     if (rsize == 0) {           /* Read a HW EOF Marker? OK */
898         *blockType = BLOCK_EOF;
899         incSize(info, config.fileMarkSize);     /* Size of filemark */
900         if (!isafile)
901             info->position++;   /* bump position */
902         p->reading = 0;         /* No reads since EOF */
903     }
904
905     else if (rsize != BUTM_BLOCKSIZE) { /* Didn't Read a full block */
906         info->status |= BUTM_STATUS_READERROR;
907         ERROR_EXIT((rsize < 0) ? BUTM_IO : BUTM_EOT);
908     }
909
910     else if (ntohl(bmark->magic) == BLOCK_MAGIC) {      /* Data block? */
911         *blockType = BLOCK_DATA;
912     }
913
914     else if (ntohl(fmark->magic) == FILE_MAGIC) {       /* Read a filemark? */
915         fmtype = ntohl(fmark->nBytes);
916
917         if (fmtype == FILE_BEGIN) {     /* filemark begin */
918             *blockType = BLOCK_FMBEGIN;
919         } else if (fmtype == FILE_FMEND) {      /* filemark end */
920             *blockType = BLOCK_FMEND;
921             code = SeekFile(info, 1);
922         } else if (fmtype == FILE_EOD) {        /* EOD mark */
923             *blockType = BLOCK_EOD;
924             info->status |= BUTM_STATUS_EOD;
925             code = SeekFile(info, 1);
926         }
927     }
928
929     else if (ntohl(label->magic) == TAPE_MAGIC) {       /* Read a tape label? */
930         *blockType = BLOCK_LABEL;
931         code = SeekFile(info, 1);
932     }
933
934     if (isafile)
935         info->position++;
936
937   error_exit:
938     return (code);
939 }
940
941 /* check
942  *      check version numbers and permissions in the info structure
943  */
944
945 static afs_int32
946 check(info, write)
947      struct butm_tapeInfo *info;
948      int write;                 /* write operation requested */
949 {
950     struct progress *p;
951
952     if (!info)
953         return (BUTM_BADARGUMENT);
954
955     /* Check version number in info structure */
956     if (info->structVersion != BUTM_MAJORVERSION)
957         return BUTM_OLDINTERFACE;
958
959     /* Check if a tape is mounted */
960     if (((p = (struct progress *)info->tmRock) == 0) || (p->fid == 0))
961         return BUTM_NOMOUNT;
962
963     /* If writing check if there is write access */
964     if (write && (info->flags & BUTM_FLAGS_READONLY))
965         return BUTM_READONLY;
966
967     return 0;
968 }
969
970 static afs_int32
971 rewindFile(info)
972      struct butm_tapeInfo *info;
973 {
974     struct progress *p;
975     int cpid, status, rcpid, stat;
976     afs_int32 code = 0;
977     afs_int32 rwcode;
978     afs_int32 error;
979
980     p = (struct progress *)info->tmRock;
981
982     POLL();
983
984     error = Rewind(p->fid);
985
986     POLL();
987
988     if (error) {
989         info->status |= BUTM_STATUS_SEEKERROR;
990         ERROR_EXIT(BUTM_IOCTL);
991     }
992
993     info->position = (isafile ? 0 : 1);
994     info->kBytes = info->nBytes = 0;
995     info->nFiles = info->nRecords = 0;
996     p->reading = p->writing = 0;
997
998   error_exit:
999     if (error)
1000         info->error = error;
1001     return (code);
1002 }
1003
1004 /* =====================================================================
1005  * butm routines
1006  * ===================================================================== */
1007
1008 static afs_int32
1009 file_Mount(info, tape)
1010      struct butm_tapeInfo *info;
1011      char *tape;
1012 {
1013     struct progress *p;
1014     char filename[64];
1015     usd_handle_t fid;
1016     int cpid, status, rcpid, xflags;
1017     afs_int32 code = 0, error = 0, rc = 0;
1018
1019     if (info->debug)
1020         printf("butm: Mount tape drive\n");
1021
1022     POLL();
1023     info->error = 0;
1024
1025     if (!info || !tape)
1026         ERROR_EXIT(BUTM_BADARGUMENT);
1027     if (info->structVersion != BUTM_MAJORVERSION)
1028         ERROR_EXIT(BUTM_OLDINTERFACE);
1029     if (info->tmRock)
1030         ERROR_EXIT(BUTM_PARALLELMOUNTS);
1031     if (strlen(tape) >= sizeof(info->name))
1032         ERROR_EXIT(BUTM_BADARGUMENT);
1033
1034     strcpy(info->name, tape);
1035
1036     strcpy(filename, config.tapedir);   /* the name of the tape device */
1037     info->position = (isafile ? 0 : 1);
1038     info->kBytes = info->nBytes = 0;
1039     info->nRecords = info->nFiles = 0;
1040     info->recordSize = 0;
1041     info->tapeSize = config.tapeSize;
1042     info->coefBytes = 1;
1043     info->coefRecords = 0;
1044     info->coefFiles = sizeof(struct fileMark);
1045     info->simultaneousTapes = 1;
1046     info->status = 0;
1047     info->error = 0;
1048     info->flags = BUTM_FLAGS_SEQUENTIAL;
1049
1050     xflags = 0;
1051     if (isafile) {
1052         xflags |= USD_OPEN_CREATE;
1053     } else {
1054         /*
1055          * try to open in a child process first so nothing will
1056          * time out should the process block because the device
1057          * isn't ready.
1058          */
1059
1060         if (ForkOpen(filename)) {
1061             ERROR_EXIT(BUTM_MOUNTFAIL);
1062         }
1063     }
1064
1065     /* Now go ahead and open the tape drive for real */
1066     rc = usd_Open(filename, (USD_OPEN_RDWR | USD_OPEN_WLOCK | xflags), 0777,
1067                   &fid);
1068     if (rc != 0) {              /* try for lesser access */
1069         rc = usd_Open(filename, (USD_OPEN_RDONLY | USD_OPEN_RLOCK), 0, &fid);
1070
1071         if (rc) {
1072             error = rc;
1073             ERROR_EXIT(BUTM_MOUNTFAIL);
1074         }
1075         info->flags |= BUTM_FLAGS_READONLY;
1076     }
1077
1078     (void)PrepareAccess(fid);   /* for NT */
1079
1080     p = (struct progress *)malloc(sizeof(*p));
1081     info->tmRock = (char *)p;
1082     p->fid = fid;
1083     p->mountId = config.mountId = time(0);
1084     p->reading = p->writing = 0;
1085
1086     TapeBlockSize = BUTM_BLOCKSIZE;     /* Initialize */
1087
1088   error_exit:
1089     if (error)
1090         info->error = error;
1091     return (code);
1092 }
1093
1094 static afs_int32
1095 file_Dismount(info)
1096      struct butm_tapeInfo *info;
1097 {
1098     struct progress *p;
1099     int cpid, status, rcpid, stat;
1100     afs_int32 code = 0, error = 0, cd;
1101     afs_int32 clcode;
1102     int fd[2];
1103     char c;
1104
1105     if (info->debug)
1106         printf("butm: Unmount tape drive\n");
1107
1108     POLL();
1109     info->error = 0;
1110
1111     code = check(info, READ_OP);
1112     if (code)
1113         ERROR_EXIT(code);
1114
1115     p = (struct progress *)info->tmRock;
1116
1117     (void)ShutdownAccess(p->fid);       /* for NT */
1118
1119     /* close the device */
1120     if (error = ForkClose(p->fid)) {
1121         printf("butm: Tape close failed. Error %d\n", errno);
1122     }
1123
1124     POLL();
1125
1126     if (error) {
1127         code = BUTM_DISMOUNTFAIL;
1128         info->status |= BUTM_STATUS_TAPEERROR;
1129     }
1130
1131     config.mountId = 0;
1132     info->tmRock = 0;           /* mark it as closed - even if error on close */
1133     if (p)
1134         free(p);
1135
1136   error_exit:
1137     if (error)
1138         info->error = error;
1139     return (code);
1140 }
1141
1142 /* file_WriteLabel
1143  *      write the header on a tape
1144  * entry:
1145  *      info - handle on tape unit
1146  *      label - label information. This label is not copied onto the tape.
1147  *              If supplied, various fields are copied from this label to
1148  *              the actual tape label written on the tape.
1149  */
1150
1151 static afs_int32
1152 file_WriteLabel(info, label, rewind)
1153      struct butm_tapeInfo *info;
1154      struct butm_tapeLabel *label;
1155      afs_int32 rewind;
1156 {
1157     afs_int32 code = 0;
1158     afs_int32 fcode;
1159     struct tapeLabel *tlabel;
1160     struct progress *p;
1161     afs_hyper_t off;            /* offset */
1162
1163     if (info->debug)
1164         printf("butm: Write tape label\n");
1165
1166     POLL();
1167     info->error = 0;
1168
1169     code = check(info, WRITE_OP);
1170     if (code)
1171         ERROR_EXIT(code);
1172     if (!label)
1173         ERROR_EXIT(BUTM_BADARGUMENT);
1174     if (label->structVersion != CUR_TAPE_VERSION)
1175         ERROR_EXIT(BUTM_OLDINTERFACE);
1176
1177     if (rewind) {               /* Not appending, so rewind */
1178         code = rewindFile(info);
1179         if (code)
1180             ERROR_EXIT(code);
1181
1182         if (isafile) {
1183             p = (struct progress *)info->tmRock;
1184             hset64(off, 0, 0);
1185             code = USD_IOCTL(p->fid, USD_IOCTL_SETSIZE, &off);
1186             if (code)
1187                 ERROR_EXIT(BUTM_POSITION);
1188         }
1189     } else {
1190         if (READS || WRITES)
1191             ERROR_EXIT(BUTM_BADOP);
1192     }
1193
1194     /* Copy the label into the tape block
1195      * ---------------------------------- */
1196     memset(tapeBlock, 0, BUTM_BLOCKSIZE);
1197
1198     if (!label->creationTime)
1199         label->creationTime = time(0);
1200
1201     tlabel = (struct tapeLabel *)tapeBlock;
1202     memcpy(&tlabel->label, label, sizeof(struct butm_tapeLabel));
1203     tlabel->label.structVersion = htonl(CUR_TAPE_VERSION);
1204     tlabel->label.creationTime = htonl(tlabel->label.creationTime);
1205     tlabel->label.expirationDate = htonl(tlabel->label.expirationDate);
1206     tlabel->label.size = htonl(tlabel->label.size);
1207     tlabel->label.useCount = htonl(tlabel->label.useCount);
1208     tlabel->label.dumpid = htonl(tlabel->label.dumpid);
1209
1210     /* 
1211      * write the tape label - For appends, the write may need to skip 
1212      * over 1 or 2 EOF marks that were written when tape was closed after 
1213      * the last dump. Plus, some AIX tape drives require we try forwarding
1214      * over the last EOF and take an error before we can write the new label.
1215      * ---------------------------------------------------------------------- */
1216     code = WriteTapeBlock(info, tapeBlock, BUTM_BLOCKSIZE, BLOCK_LABEL);
1217     if (!isafile && !rewind && (code == BUTM_IO))
1218         do {                    /* do if write failed */
1219             fcode = SeekFile(info, 1);  /* skip over the EOF */
1220             if (fcode)
1221                 break;          /* leave if error */
1222
1223             code =
1224                 WriteTapeBlock(info, tapeBlock, BUTM_BLOCKSIZE, BLOCK_LABEL);
1225             if (code != BUTM_IO)
1226                 break;          /* continue if write failed */
1227
1228             fcode = SeekFile(info, 1);  /* skip over the EOF */
1229             if (fcode) {        /* retry 1 write if couldn't skip */
1230                 code =
1231                     WriteTapeBlock(info, tapeBlock, BUTM_BLOCKSIZE,
1232                                    BLOCK_LABEL);
1233                 break;
1234             }
1235
1236             code =
1237                 WriteTapeBlock(info, tapeBlock, BUTM_BLOCKSIZE, BLOCK_LABEL);
1238             if (code != BUTM_IO)
1239                 break;          /* continue if write failed */
1240
1241             fcode = SeekFile(info, 1);  /* skip over the EOF */
1242             if (fcode) {        /* retry 1 write if couldn't skip */
1243                 code =
1244                     WriteTapeBlock(info, tapeBlock, BUTM_BLOCKSIZE,
1245                                    BLOCK_LABEL);
1246                 break;
1247             }
1248             break;
1249         } while (0);
1250
1251     /* clear the write error status a failed WriteTapeBlock may have produced */
1252     if (!code)
1253         info->status &= ~BUTM_STATUS_WRITEERROR;
1254
1255   error_exit:
1256     return code;
1257 }
1258
1259 static afs_int32
1260 file_ReadLabel(info, label, rewind)
1261      struct butm_tapeInfo *info;
1262      struct butm_tapeLabel *label;
1263      afs_int32 rewind;
1264 {
1265     struct tapeLabel *tlabel;
1266     afs_int32 code = 0;
1267     afs_int32 blockType;
1268
1269     if (info->debug)
1270         printf("butm: Read tape label\n");
1271
1272     POLL();
1273     info->error = 0;
1274
1275     code = check(info, READ_OP);
1276     if (code)
1277         ERROR_EXIT(code);
1278     if (READS || WRITES)
1279         ERROR_EXIT(BUTM_BADOP);
1280
1281     if (rewind) {
1282         code = rewindFile(info);
1283         if (code)
1284             ERROR_EXIT(code);   /* status is set so return */
1285     }
1286
1287     /*
1288      * When appended labels were written, either 1 or 2 EOF marks may
1289      * have had to be skipped.  When reading a label, these EOF marks 
1290      * must also be skipped. When an EOF is read, 0 bytes are returned
1291      * (refer to the write calls in file_WriteLabel routine).
1292      * ---------------------------------------------------------------- */
1293     code = ReadTapeBlock(info, tapeBlock, &blockType);
1294     if (!isafile && !rewind && (blockType == BLOCK_EOF))
1295         do {
1296             code = ReadTapeBlock(info, tapeBlock, &blockType);
1297             if (blockType != BLOCK_EOF)
1298                 break;          /* didn't read an EOF */
1299
1300             code = ReadTapeBlock(info, tapeBlock, &blockType);
1301         } while (0);
1302
1303     if (blockType == BLOCK_UNKNOWN)
1304         ERROR_EXIT(BUTM_NOLABEL);
1305     if (code)
1306         ERROR_EXIT(code);
1307     if (blockType != BLOCK_LABEL)
1308         ERROR_EXIT(BUTM_BADBLOCK);
1309
1310     /* Copy label out
1311      * -------------- */
1312     if (label) {
1313         tlabel = (struct tapeLabel *)tapeBlock;
1314         memcpy(label, &tlabel->label, sizeof(struct butm_tapeLabel));
1315         label->structVersion = ntohl(label->structVersion);
1316         label->creationTime = ntohl(label->creationTime);
1317         label->expirationDate = ntohl(label->expirationDate);
1318         label->size = ntohl(label->size);
1319         label->dumpid = ntohl(label->dumpid);
1320         label->useCount = ntohl(label->useCount);
1321
1322         info->tapeSize = label->size;   /* use size from label */
1323     }
1324
1325   error_exit:
1326     return (code);
1327 }
1328
1329 static afs_int32
1330 file_WriteFileBegin(info)
1331      struct butm_tapeInfo *info;
1332 {
1333     afs_int32 code = 0;
1334     afs_int32 error = 0;
1335
1336     if (info->debug)
1337         printf("butm: Write filemark begin\n");
1338
1339     POLL();
1340
1341     code = check(info, WRITE_OP);
1342     if (code)
1343         ERROR_EXIT(code);
1344
1345     code = WriteTapeBlock(info, tapeBlock, BUTM_BLOCKSIZE, BLOCK_FMBEGIN);
1346     if (code)
1347         ERROR_EXIT(code);
1348
1349     info->nFiles++;
1350
1351   error_exit:
1352     return (code);
1353 }
1354
1355 static afs_int32
1356 file_ReadFileBegin(info)
1357      struct butm_tapeInfo *info;
1358 {
1359     struct fileMark mark;
1360     afs_int32 code = 0;
1361     afs_int32 blockType;
1362
1363     if (info->debug)
1364         printf("butm: Read filemark begin\n");
1365
1366     POLL();
1367     info->error = 0;
1368
1369     code = check(info, READ_OP);
1370     if (code)
1371         ERROR_EXIT(code);
1372     if (READS || WRITES)
1373         ERROR_EXIT(BUTM_BADOP);
1374
1375     code = ReadTapeBlock(info, tapeBlock, &blockType);
1376     if (code)
1377         ERROR_EXIT(code);
1378
1379     if (blockType != BLOCK_FMBEGIN) {
1380         if (blockType == BLOCK_EOD)
1381             ERROR_EXIT(BUTM_EOD);       /* EODump label */
1382         if (blockType == BLOCK_LABEL)
1383             ERROR_EXIT(BUTM_LABEL);     /* Tape label */
1384         ERROR_EXIT(BUTM_BADBLOCK);      /* Other */
1385     }
1386
1387   error_exit:
1388     return (code);
1389 }
1390
1391 /* Writes data out in block sizes of 16KB. Does destroy the data.
1392  * Assumes the data buffer has a space reserved at beginning for a blockMark.
1393  */
1394 static afs_int32
1395 file_WriteFileData(info, data, blocks, len)
1396      struct butm_tapeInfo *info;
1397      char *data;
1398      afs_int32 blocks;
1399      afs_int32 len;
1400 {
1401     afs_int32 code = 0;
1402     int length;
1403     afs_int32 b;
1404     char *bstart;               /* Where block starts for a 16K block */
1405     char *dstart;               /* Where data  starts for a 16K block */
1406
1407     if (info->debug)
1408         printf("butm: Write tape data - %u bytes\n", len);
1409
1410     POLL();
1411     info->error = 0;
1412
1413     code = check(info, WRITE_OP);
1414     if (code)
1415         ERROR_EXIT(code);
1416     if (!data || (len < 0))
1417         ERROR_EXIT(BUTM_BADARGUMENT);
1418     if (READS || !WRITES)
1419         ERROR_EXIT(BUTM_BADOP);
1420
1421     b = 0;                      /* start at block 0 */
1422     while (len > 0) {
1423         dstart = &data[b * BUTM_BLKSIZE];
1424         bstart = dstart - sizeof(struct blockMark);
1425
1426         if (len < BUTM_BLKSIZE) {
1427             memset(&dstart[len], 0, BUTM_BLKSIZE - len);
1428             length = len;
1429         } else {
1430             length = BUTM_BLKSIZE;
1431         }
1432
1433         code = WriteTapeBlock(info, bstart, length, BLOCK_DATA);
1434
1435         len -= length;
1436
1437         /* If there are more blocks, step to next block */
1438         /* Otherwise, copy the data to beginning of last block */
1439
1440         if (b < (blocks - 1))
1441             b++;
1442         else if (len)
1443             memcpy(&dstart[0], &dstart[BUTM_BLKSIZE], len);
1444     }
1445
1446   error_exit:
1447     return (code);
1448 }
1449
1450 /* file_ReadFileData
1451  *      Read a data block from tape.
1452  * entry:
1453  *      info - tape info structure, c.f. fid
1454  *      data - ptr to buffer for data
1455  *      len - size of data buffer
1456  * exit:
1457  *      nBytes - no. of data bytes read.
1458  */
1459
1460 static afs_int32
1461 file_ReadFileData(info, data, len, nBytes)
1462      struct butm_tapeInfo *info;
1463      char *data;
1464      int len;
1465      int *nBytes;
1466 {
1467     struct blockMark *bmark;
1468     afs_int32 code = 0;
1469     afs_int32 blockType;
1470
1471     if (info->debug)
1472         printf("butm: Read tape data - %u bytes\n", len);
1473
1474     POLL();
1475     info->error = 0;
1476
1477     if (!nBytes)
1478         ERROR_EXIT(BUTM_BADARGUMENT);
1479     *nBytes = 0;
1480
1481     code = check(info, READ_OP);
1482     if (code)
1483         ERROR_EXIT(code);
1484     if (!data || (len < 0) || (len > BUTM_BLKSIZE))
1485         ERROR_EXIT(BUTM_BADARGUMENT);
1486     if (!READS || WRITES)
1487         ERROR_EXIT(BUTM_BADOP);
1488
1489     data -= sizeof(struct blockMark);
1490     code = ReadTapeBlock(info, data, &blockType);
1491     if (code)
1492         ERROR_EXIT(code);
1493
1494     if (blockType != BLOCK_DATA) {
1495         if (blockType == BLOCK_EOF)
1496             ERROR_EXIT(BUTM_EOF);
1497         if (blockType == BLOCK_FMEND)
1498             ERROR_EXIT(BUTM_ENDVOLUME);
1499         ERROR_EXIT(BUTM_BADBLOCK);
1500     }
1501
1502     bmark = (struct blockMark *)data;
1503     *nBytes = ntohl(bmark->count);      /* Size of data in buf */
1504
1505   error_exit:
1506     return (code);
1507 }
1508
1509 static afs_int32
1510 file_WriteFileEnd(info)
1511      struct butm_tapeInfo *info;
1512 {
1513     afs_int32 code = 0;
1514
1515     if (info->debug)
1516         printf("butm: Write filemark end\n");
1517
1518     POLL();
1519     info->error = 0;
1520
1521     code = check(info, WRITE_OP);
1522     if (code)
1523         ERROR_EXIT(code);
1524     if (READS || !WRITES)
1525         ERROR_EXIT(BUTM_BADOP);
1526
1527     code = WriteTapeBlock(info, tapeBlock, BUTM_BLOCKSIZE, BLOCK_FMEND);
1528
1529   error_exit:
1530     return (code);
1531 }
1532
1533 /* Read a SW filemark, verify that it is a SW filemark, then skip to the next 
1534  * HW filemark. If the read of the SW filemark shows it's an EOF, then 
1535  * ignore that the SW filemark is not there and return 0 (found the SW filemark
1536  * missing with some 3.1 dumps).
1537  */
1538 static afs_int32
1539 file_ReadFileEnd(info)
1540      struct butm_tapeInfo *info;
1541 {
1542     struct fileMark mark;
1543     afs_int32 code = 0;
1544     afs_int32 blockType;
1545
1546     if (info->debug)
1547         printf("butm: Read filemark end\n");
1548
1549     POLL();
1550     info->error = 0;
1551
1552     code = check(info, READ_OP);
1553     if (code)
1554         ERROR_EXIT(code);
1555     if (!READS || WRITES)
1556         ERROR_EXIT(BUTM_BADOP);
1557
1558     info->status &= ~BUTM_STATUS_EOF;
1559
1560     code = ReadTapeBlock(info, tapeBlock, &blockType);
1561     if (code)
1562         ERROR_EXIT(code);
1563
1564     if ((blockType != BLOCK_FMEND) && (blockType != BLOCK_EOF))
1565         ERROR_EXIT(BUTM_BADBLOCK);
1566
1567   error_exit:
1568     return code;
1569 }
1570
1571 /*
1572  * Write the end-of-dump marker.
1573  */
1574 static afs_int32
1575 file_WriteEODump(info)
1576      struct butm_tapeInfo *info;
1577 {
1578     afs_int32 code = 0;
1579
1580     if (info->debug)
1581         printf("butm: Write filemark EOD\n");
1582
1583     POLL();
1584     info->error = 0;
1585
1586     code = check(info, WRITE_OP);
1587     if (code)
1588         ERROR_EXIT(code);
1589     if (READS || WRITES)
1590         ERROR_EXIT(BUTM_BADOP);
1591
1592     code = WriteTapeBlock(info, tapeBlock, BUTM_BLOCKSIZE, BLOCK_EOD);
1593     if (code)
1594         ERROR_EXIT(code);
1595
1596     info->status |= BUTM_STATUS_EOD;
1597
1598   error_exit:
1599     return (code);
1600 }
1601
1602 static afs_int32
1603 file_Seek(info, position)
1604      struct butm_tapeInfo *info;
1605      afs_int32 position;
1606 {
1607     afs_int32 code = 0;
1608     afs_int32 w;
1609     osi_lloff_t posit;
1610     afs_uint32 c, d;
1611     struct progress *p;
1612     afs_hyper_t startOff, stopOff;      /* for normal file(non-tape)  seeks  */
1613
1614     if (info->debug)
1615         printf("butm: Seek to the tape position %d\n", position);
1616
1617     info->error = 0;
1618
1619     code = check(info, READ_OP);
1620     if (code)
1621         ERROR_EXIT(code);
1622
1623     if (isafile) {
1624         p = (struct progress *)info->tmRock;
1625         posit = (osi_lloff_t)position * (osi_lloff_t)BUTM_BLOCKSIZE;
1626
1627         /* Not really necessary to do it this way, should be fixed */
1628 #ifdef O_LARGEFILE
1629         c = (posit >> 32);
1630         d = (posit & 0xffffffff);
1631 #else
1632         c = 0;
1633         d = posit;
1634 #endif
1635         hset64(startOff, c, d);
1636
1637         w = USD_SEEK(p->fid, startOff, SEEK_SET, &stopOff);
1638         if (w)
1639             info->error == w;
1640         if (hcmp(startOff, stopOff) != 0)
1641             ERROR_EXIT(BUTM_POSITION);
1642
1643         p->reading = p->writing = 0;
1644         info->position = position;
1645     } else {
1646         /* Don't position backwards if we are in-between FMs */
1647         if ((READS || WRITES) && ((position - info->position) <= 0))
1648             ERROR_EXIT(BUTM_BADOP);
1649
1650         code = SeekFile(info, (position - info->position));
1651         if (code)
1652             ERROR_EXIT(code);
1653     }
1654
1655   error_exit:
1656     return (code);
1657 }
1658
1659 /*
1660  * Seek to the EODump (end-of-dump) after the given position. This is 
1661  * the position after the EOF filemark immediately after the EODump mark. 
1662  * This is for tapes of version 4 or greater.
1663  */
1664 static afs_int32
1665 file_SeekEODump(info, position)
1666      struct butm_tapeInfo *info;
1667      afs_int32 position;
1668 {
1669     struct fileMark mark;
1670     afs_int32 code = 0;
1671     afs_int32 blockType;
1672     afs_int32 w;
1673     struct progress *p;
1674     afs_hyper_t startOff, stopOff;      /* file seek offsets */
1675
1676     if (info->debug)
1677         printf("butm: Seek to end-of-dump\n");
1678     info->error = 0;
1679
1680     code = check(info, READ_OP);
1681     if (code)
1682         ERROR_EXIT(code);
1683     if (READS || WRITES)
1684         ERROR_EXIT(BUTM_BADOP);
1685
1686     if (isafile) {
1687         p = (struct progress *)info->tmRock;
1688         hset64(startOff, 0, 0);
1689         w = USD_SEEK(p->fid, startOff, SEEK_END, &stopOff);
1690         if (w)
1691             info->error == w;
1692         if (w)
1693             ERROR_EXIT(BUTM_POSITION);
1694
1695         if (hgetlo(stopOff) % BUTM_BLOCKSIZE)
1696             ERROR_EXIT(BUTM_POSITION);
1697         info->position = (hgetlo(stopOff) / BUTM_BLOCKSIZE);
1698     } else {
1699         /* Seek to the desired position */
1700         code = SeekFile(info, (position - info->position) + 1);
1701         if (code)
1702             ERROR_EXIT(code);
1703
1704         /*
1705          * Search until the filemark is an EODump filemark.
1706          * Skip over volumes only.
1707          */
1708         while (1) {
1709             code = ReadTapeBlock(info, tapeBlock, &blockType);
1710             if (code)
1711                 ERROR_EXIT(code);
1712
1713             if (blockType == BLOCK_EOD)
1714                 break;
1715             if (blockType != BLOCK_FMBEGIN)
1716                 ERROR_EXIT(BUTM_BADBLOCK);
1717
1718             code = SeekFile(info, 1);   /* Step forward to next volume */
1719             if (code)
1720                 ERROR_EXIT(code);
1721         }
1722         code = 0;
1723     }
1724
1725   error_exit:
1726     return (code);
1727 }
1728
1729 static afs_int32
1730 file_SetSize(info, size)
1731      struct butm_tapeInfo *info;
1732      afs_uint32 size;
1733 {
1734     if (info->debug)
1735         printf("butm: Set size of tape\n");
1736     info->error = 0;
1737
1738     if (size <= 0)
1739         info->tapeSize = config.tapeSize;
1740     else
1741         info->tapeSize = size;
1742     return 0;
1743 }
1744
1745 static afs_int32
1746 file_GetSize(info, size)
1747      struct butm_tapeInfo *info;
1748      afs_uint32 *size;
1749 {
1750     if (info->debug)
1751         printf("butm: Get size of tape\n");
1752     info->error = 0;
1753
1754     *size = info->tapeSize;
1755     return 0;
1756 }
1757
1758 /* =====================================================================
1759  * Startup/configuration routines.
1760  * ===================================================================== */
1761
1762 static afs_int32
1763 file_Configure(file)
1764      struct tapeConfig *file;
1765 {
1766     if (!file) {
1767         com_err(whoami, BUTM_BADCONFIG, "device not specified");
1768         return BUTM_BADCONFIG;
1769     }
1770
1771     config.tapeSize = file->capacity;
1772     config.fileMarkSize = file->fileMarkSize;
1773     config.portOffset = file->portOffset;
1774     strcpy(config.tapedir, file->device);
1775
1776     /* Tape must be large enough to at least fit a label */
1777     if (config.tapeSize <= 0) {
1778         com_err(whoami, BUTM_BADCONFIG, "Tape size bogus: %d Kbytes",
1779                 config.tapeSize);
1780         return BUTM_BADCONFIG;
1781     }
1782
1783     if (strlen(config.tapedir) == 0) {
1784         com_err(whoami, BUTM_BADCONFIG, "no tape device specified");
1785         return BUTM_BADCONFIG;
1786     }
1787
1788     config.mountId = 0;
1789     return 0;
1790 }
1791
1792 /* This procedure instantiates a tape module of type file_tm. */
1793 afs_int32
1794 butm_file_Instantiate(info, file)
1795      struct butm_tapeInfo *info;
1796      struct tapeConfig *file;
1797 {
1798     extern int debugLevel;
1799     afs_int32 code = 0;
1800
1801     if (debugLevel > 98)
1802         printf("butm: Instantiate butc\n");
1803
1804     if (!info)
1805         ERROR_EXIT(BUTM_BADARGUMENT);
1806     if (info->structVersion != BUTM_MAJORVERSION)
1807         ERROR_EXIT(BUTM_OLDINTERFACE);
1808
1809     memset(info, 0, sizeof(struct butm_tapeInfo));
1810     info->structVersion = BUTM_MAJORVERSION;
1811     info->ops.mount = file_Mount;
1812     info->ops.dismount = file_Dismount;
1813     info->ops.create = file_WriteLabel;
1814     info->ops.readLabel = file_ReadLabel;
1815     info->ops.seek = file_Seek;
1816     info->ops.seekEODump = file_SeekEODump;
1817     info->ops.readFileBegin = file_ReadFileBegin;
1818     info->ops.readFileData = file_ReadFileData;
1819     info->ops.readFileEnd = file_ReadFileEnd;
1820     info->ops.writeFileBegin = file_WriteFileBegin;
1821     info->ops.writeFileData = file_WriteFileData;
1822     info->ops.writeFileEnd = file_WriteFileEnd;
1823     info->ops.writeEOT = file_WriteEODump;
1824     info->ops.setSize = file_SetSize;
1825     info->ops.getSize = file_GetSize;
1826     info->debug = ((debugLevel > 98) ? 1 : 0);
1827
1828     code = file_Configure(file);
1829
1830   error_exit:
1831     return code;
1832 }