![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to posix-tape.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / host / posix|
Return to posix-tape.c CVS log | Up to [The Machine Emulator] / tme / host / posix |
1.1 root 1: /* $Id: posix-tape.c,v 1.6 2003/10/16 02:48:23 fredette Exp $ */
2:
3: /* host/posix/posix-tape.c - implementation of tapes on a POSIX system: */
4:
5: /*
6: * Copyright (c) 2003 Matt Fredette
7: * All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. All advertising materials mentioning features or use of this software
18: * must display the following acknowledgement:
19: * This product includes software developed by Matt Fredette.
20: * 4. The name of the author may not be used to endorse or promote products
21: * derived from this software without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
27: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
29: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
31: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
32: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33: * POSSIBILITY OF SUCH DAMAGE.
34: */
35:
36: #include <tme/common.h>
37: _TME_RCSID("$Id: posix-tape.c,v 1.6 2003/10/16 02:48:23 fredette Exp $");
38:
39: /* includes: */
40: #include <tme/generic/tape.h>
41: #include <fcntl.h>
42: #include <stdlib.h>
43: #include <strings.h>
44: #include <sys/stat.h>
45: #include <sys/uio.h>
46: #ifdef HAVE_STDARG_H
47: #include <stdarg.h>
48: #else /* HAVE_STDARG_H */
49: #include <varargs.h>
50: #endif /* HAVE_STDARG_H */
51:
52: /* macros: */
53:
54: /* tape flags: */
55: #define TME_POSIX_TAPE_FLAG_RO TME_BIT(0)
56: #define TME_POSIX_TAPE_FLAG_DIRTY TME_BIT(1)
57:
58: /* the size of the control callout ring: */
59: #define TME_POSIX_TAPE_CONTROL_RING_SIZE (16)
60:
61: /* the callout flags: */
62: #define TME_POSIX_TAPE_CALLOUT_CHECK (0)
63: #define TME_POSIX_TAPE_CALLOUT_RUNNING TME_BIT(0)
64: #define TME_POSIX_TAPE_CALLOUTS_MASK (-2)
65: #define TME_POSIX_TAPE_CALLOUT_CONTROL TME_BIT(1)
66:
67: /* types: */
68:
69: /* a posix tape control: */
70: struct tme_posix_tape_control {
71:
72: /* the control: */
73: unsigned int tme_posix_tape_control_which;
74: };
75:
76: /* a posix tape segment: */
77: struct tme_posix_tape_segment {
78:
79: /* tape segments are kept on a doubly linked list: */
80: struct tme_posix_tape_segment *tme_posix_tape_segment_next;
81: struct tme_posix_tape_segment *tme_posix_tape_segment_prev;
82:
83: /* the filename of this tape segment: */
84: char *tme_posix_tape_segment_filename;
85:
86: /* the file descriptor of this tape segment: */
87: int tme_posix_tape_segment_fd;
88:
89: /* this is nonzero iff this tape segment is a real tape: */
90: int tme_posix_tape_segment_real_tape;
91: };
92:
93: /* a posix tape: */
94: struct tme_posix_tape {
95:
96: /* backpointer to our element: */
97: struct tme_element *tme_posix_tape_element;
98:
99: /* our mutex: */
100: tme_mutex_t tme_posix_tape_mutex;
101:
102: /* our flags: */
103: int tme_posix_tape_flags;
104:
105: /* the tape segments: */
106: struct tme_posix_tape_segment *tme_posix_tape_segments;
107:
108: /* the connection: */
109: struct tme_tape_connection *tme_posix_tape_connection;
110:
111: /* the callout flags: */
112: int tme_posix_tape_callout_flags;
113:
114: /* the control ring buffer: */
115: struct tme_posix_tape_control tme_posix_tape_controls[TME_POSIX_TAPE_CONTROL_RING_SIZE];
116: unsigned int tme_posix_tape_control_head;
117: unsigned int tme_posix_tape_control_tail;
118:
119: /* the current tape segment: */
120: struct tme_posix_tape_segment *tme_posix_tape_segment_current;
121:
122: /* the block sizes: */
123: unsigned long tme_posix_tape_block_size_min;
124: unsigned long tme_posix_tape_block_size_max;
125: unsigned long tme_posix_tape_block_size_fixed;
126:
127: /* the tape buffer: */
128: unsigned long tme_posix_tape_buffer_size;
129: tme_uint8_t *tme_posix_tape_buffer_data;
130: unsigned long tme_posix_tape_buffer_flags;
131: unsigned long tme_posix_tape_buffer_count_xfer;
132: };
133:
134: /* this allocates the next control in the ring buffer: */
135: struct tme_posix_tape_control *
136: _tme_posix_tape_control_new(struct tme_posix_tape *posix_tape)
137: {
138: int old_head;
139: struct tme_posix_tape_control *control;
140:
141: /* abort if the ring buffer overflows: */
142: old_head = posix_tape->tme_posix_tape_control_head;
143: posix_tape->tme_posix_tape_control_head
144: = ((old_head
145: + 1)
146: & (TME_POSIX_TAPE_CONTROL_RING_SIZE
147: - 1));
148: if ((posix_tape->tme_posix_tape_control_head
149: == posix_tape->tme_posix_tape_control_tail)
150: && (posix_tape->tme_posix_tape_connection
151: != NULL)) {
152: abort();
153: }
154:
155: /* return the control: */
156: control = &posix_tape->tme_posix_tape_controls[old_head];
157: return (control);
158: }
159:
160: /* the posix tape callout function. it must be called with the mutex locked: */
161: static void
162: _tme_posix_tape_callout(struct tme_posix_tape *posix_tape,
163: int new_callouts)
164: {
165: struct tme_tape_connection *conn_tape;
166: unsigned int old_tail;
167: struct tme_posix_tape_control *control;
168: int callouts, later_callouts;
169: int rc;
170:
171: /* add in any new callouts: */
172: posix_tape->tme_posix_tape_callout_flags |= new_callouts;
173:
174: /* if this function is already running in another thread, simply
175: return now. the other thread will do our work: */
176: if (posix_tape->tme_posix_tape_callout_flags
177: & TME_POSIX_TAPE_CALLOUT_RUNNING) {
178: return;
179: }
180:
181: /* callouts are now running: */
182: posix_tape->tme_posix_tape_callout_flags
183: |= TME_POSIX_TAPE_CALLOUT_RUNNING;
184:
185: /* assume that we won't need any later callouts: */
186: later_callouts = 0;
187:
188: /* loop while callouts are needed: */
189: for (; ((callouts
190: = posix_tape->tme_posix_tape_callout_flags)
191: & TME_POSIX_TAPE_CALLOUTS_MASK); ) {
192:
193: /* clear the needed callouts: */
194: posix_tape->tme_posix_tape_callout_flags
195: = (callouts
196: & ~TME_POSIX_TAPE_CALLOUTS_MASK);
197: callouts
198: &= TME_POSIX_TAPE_CALLOUTS_MASK;
199:
200: /* get the tape connection: */
201: conn_tape = posix_tape->tme_posix_tape_connection;
202:
203: /* if we need to call out a control: */
204: if (callouts & TME_POSIX_TAPE_CALLOUT_CONTROL) {
205:
206: /* there must be a control to call out: */
207: old_tail = posix_tape->tme_posix_tape_control_tail;
208: assert (old_tail
209: != posix_tape->tme_posix_tape_control_head);
210: control
211: = &posix_tape->tme_posix_tape_controls[old_tail];
212:
213: /* unlock the mutex: */
214: tme_mutex_unlock(&posix_tape->tme_posix_tape_mutex);
215:
216: /* do the callout: */
217: rc = TME_OK;
218: if (conn_tape != NULL) {
219: switch (control->tme_posix_tape_control_which) {
220: case TME_TAPE_CONTROL_LOAD:
221: case TME_TAPE_CONTROL_UNLOAD:
222: rc = ((*conn_tape->tme_tape_connection_control)
223: (conn_tape,
224: control->tme_posix_tape_control_which));
225: break;
226: default:
227: rc = TME_OK;
228: assert(FALSE);
229: }
230: }
231:
232: /* lock the mutex: */
233: tme_mutex_lock(&posix_tape->tme_posix_tape_mutex);
234:
235: /* if the callout was unsuccessful, remember that at some later
236: time this callout should be attempted again: */
237: if (rc != TME_OK) {
238: later_callouts |= TME_POSIX_TAPE_CALLOUT_CONTROL;
239: }
240:
241: /* otherwise, this callout was successful: */
242: else {
243:
244: /* advance the tail pointer: */
245: posix_tape->tme_posix_tape_control_tail
246: = ((old_tail
247: + 1)
248: & (TME_POSIX_TAPE_CONTROL_RING_SIZE
249: - 1));
250:
251: /* if there are more controls to callout, call them out now: */
252: if (posix_tape->tme_posix_tape_control_tail
253: != posix_tape->tme_posix_tape_control_head) {
254: posix_tape->tme_posix_tape_callout_flags
255: |= TME_POSIX_TAPE_CALLOUT_CONTROL;
256: }
257: }
258: }
259: }
260:
261: /* put in any later callouts, and clear that callouts are running: */
262: posix_tape->tme_posix_tape_callout_flags = later_callouts;
263: }
264:
265: /* this closes and frees all tape segments: */
266: static void
267: _tme_posix_tape_segments_close(struct tme_posix_tape *posix_tape)
268: {
269: struct tme_posix_tape_segment *segment;
270:
271: /* while we have segments: */
272: for (; posix_tape->tme_posix_tape_segments != NULL; ) {
273:
274: /* get the next segment and remove it from the list: */
275: segment = posix_tape->tme_posix_tape_segments;
276: posix_tape->tme_posix_tape_segments = segment->tme_posix_tape_segment_next;
277:
278: /* if the segment file descriptor is open, close it: */
279: if (segment->tme_posix_tape_segment_fd >= 0) {
280: close(segment->tme_posix_tape_segment_fd);
281: }
282:
283: /* free the segment filename: */
284: tme_free(segment->tme_posix_tape_segment_filename);
285:
286: /* free the segment itself: */
287: tme_free(segment);
288: }
289:
290: /* there is no current segment: */
291: posix_tape->tme_posix_tape_segment_current = NULL;
292: }
293:
294: /* this unloads a tape: */
295: static int
296: _tme_posix_tape_unload(struct tme_posix_tape *posix_tape)
297: {
298:
299: /* close and free all tape segments: */
300: _tme_posix_tape_segments_close(posix_tape);
301:
302: return (TME_OK);
303: }
304:
305: /* this opens a tape segment and makes it the current segment: */
306: static int
307: _tme_posix_tape_segment_open(struct tme_posix_tape *posix_tape,
308: struct tme_posix_tape_segment *segment)
309: {
310:
311: /* there is no current segment: */
312: posix_tape->tme_posix_tape_segment_current = NULL;
313:
314: /* open the segment: */
315: segment->tme_posix_tape_segment_fd
316: = open(segment->tme_posix_tape_segment_filename,
317: ((posix_tape->tme_posix_tape_flags & TME_POSIX_TAPE_FLAG_RO)
318: ? O_RDONLY
319: : O_RDWR));
320:
321: /* if the open failed: */
322: if (segment->tme_posix_tape_segment_fd < 0) {
323: return (errno);
324: }
325:
326: /* set the current segment: */
327: posix_tape->tme_posix_tape_segment_current = segment;
328: return (TME_OK);
329: }
330:
331: /* this rewinds a tape: */
332: static int
333: _tme_posix_tape_rewind(struct tme_posix_tape *posix_tape)
334: {
335: struct tme_posix_tape_segment *segment;
336: int rc;
337:
338: /* assume this will succeed: */
339: rc = TME_OK;
340:
341: /* if there is a current segment and it's not the first
342: segment: */
343: segment = posix_tape->tme_posix_tape_segment_current;
344: if (segment != NULL
345: && segment != posix_tape->tme_posix_tape_segments) {
346:
347: /* this must be a normal file: */
348: assert (!segment->tme_posix_tape_segment_real_tape);
349:
350: /* if the segment is open, close it: */
351: if (segment->tme_posix_tape_segment_fd >= 0) {
352: close(segment->tme_posix_tape_segment_fd);
353: segment->tme_posix_tape_segment_fd = -1;
354: }
355: }
356:
357: /* get the first segment: */
358: segment = posix_tape->tme_posix_tape_segments;
359:
360: /* if this is a real tape: */
361: if (segment->tme_posix_tape_segment_real_tape) {
362:
363: /* the tape must be open: */
364: assert (segment->tme_posix_tape_segment_fd >= 0);
365:
366: /* XXX TBD */
367: abort();
368: }
369:
370: /* otherwise, this is a normal file: */
371: else {
372:
373: /* if the file isn't open, open it, else
374: seek it to the beginning: */
375: if (segment->tme_posix_tape_segment_fd < 0) {
376: rc = _tme_posix_tape_segment_open(posix_tape,
377: segment);
378: }
379: else {
380: if (lseek(segment->tme_posix_tape_segment_fd,
381: 0, SEEK_SET) != 0) {
382: rc = errno;
383: }
384: }
385: }
386:
387: return (rc);
388: }
389:
390: /* this skips file marks: */
391: static int
392: _tme_posix_tape_mark_skip(struct tme_posix_tape *posix_tape,
393: unsigned int count,
394: int forward)
395: {
396: struct tme_posix_tape_segment *segment;
397: int rc;
398:
399: segment = posix_tape->tme_posix_tape_segment_current;
400:
401: /* if we are at end-of-media, or if we're skipping no marks, do
402: nothing: */
403: if (segment == NULL
404: || count == 0) {
405: return (TME_OK);
406: }
407:
408: /* this segment must be a normal file: */
409: assert (!segment->tme_posix_tape_segment_real_tape);
410:
411: /* if this segment is open, close it: */
412: if (segment->tme_posix_tape_segment_fd >= 0) {
413: close(segment->tme_posix_tape_segment_fd);
414: segment->tme_posix_tape_segment_fd = -1;
415: }
416:
417: /* skip the marks: */
418: for (; segment != NULL && count-- > 0; ) {
419: segment
420: = (forward
421: ? segment->tme_posix_tape_segment_next
422: : segment->tme_posix_tape_segment_prev);
423: }
424:
425: /* for now, if we are skipping in reverse we must have a segment -
426: what do we do otherwise? */
427: assert (forward || segment != NULL);
428:
429: /* clear the active segment pointer: */
430: posix_tape->tme_posix_tape_segment_current = NULL;
431:
432: /* if we have a segment, open it: */
433: if (segment != NULL) {
434: rc = _tme_posix_tape_segment_open(posix_tape,
435: segment);
436: assert (rc == TME_OK);
437: }
438:
439: /* if we are skipping in reverse, we must leave the tape on the
440: beginning of media side of the file mark: */
441: if (!forward) {
442: rc = (lseek(segment->tme_posix_tape_segment_fd,
443: 0,
444: SEEK_END) < 0);
445: assert (rc == 0);
446: }
447:
448: return (TME_OK);
449: }
450:
451: /* this finishes a transfer. it must be called with the mutex locked: */
452: static int
453: _tme_posix_tape_xfer1(struct tme_posix_tape *posix_tape,
454: int *_flags,
455: unsigned long *_count_xfer,
456: unsigned long *_count_bytes,
457: int xfer_read)
458: {
459: struct tme_posix_tape_segment *segment;
460: unsigned long count_xfer, count_bytes_user, count_bytes_tape;
461: unsigned long xfer_factor, block_size;
462: long rc;
463:
464: /* assume that we will return no flags: */
465: *_flags = 0;
466:
467: /* get the transfer count: */
468: count_xfer = posix_tape->tme_posix_tape_buffer_count_xfer;
469:
470: /* get any forced block size: */
471: block_size = posix_tape->tme_posix_tape_block_size_min;
472: if (block_size != posix_tape->tme_posix_tape_block_size_min) {
473: block_size = 0;
474: }
475:
476: /* if the request is for one or more blocks at a fixed block size: */
477: if (posix_tape->tme_posix_tape_buffer_flags
478: & TME_TAPE_FLAG_FIXED) {
479:
480: /* the device must be in fixed block size mode: */
481: xfer_factor = posix_tape->tme_posix_tape_block_size_fixed;
482: if (xfer_factor == 0) {
483: assert (block_size != 0);
484: xfer_factor = block_size;
485: }
486: else {
487: assert (block_size == 0
488: || block_size == xfer_factor);
489: block_size = xfer_factor;
490: }
491: }
492:
493: /* otherwise, the request is for one block at a variable block size: */
494: else {
495:
496: /* the device might be forcing a block size: */
497: xfer_factor = 1;
498: if (block_size == 0) {
499: block_size = count_xfer;
500: }
501: }
502:
503: /* calculate the byte count for the user: */
504: count_bytes_user = count_xfer * xfer_factor;
505:
506: /* calculate the byte count for the tape. this is
507: the byte count for the user rounded up to the
508: block size: */
509: count_bytes_tape = count_bytes_user % block_size;
510: count_bytes_tape
511: = (count_bytes_user
512: + (count_bytes_tape
513: ? (block_size
514: - count_bytes_tape)
515: : 0));
516:
517: /* get the current segment: */
518: segment = posix_tape->tme_posix_tape_segment_current;
519:
520: /* if this is a read: */
521: if (xfer_read) {
522:
523: /* if we are out of segments: */
524: if (segment == NULL) {
525:
526: /* act like we read zero bytes: */
527: rc = 0;
528: }
529:
530: /* otherwise, do the read: */
531: else {
532:
533: /* do the read: */
534: rc = read(segment->tme_posix_tape_segment_fd,
535: posix_tape->tme_posix_tape_buffer_data,
536: count_bytes_user);
537:
538: /* if this segment is not a real tape, and we're expected to
539: transfer more bytes than the user requested, seek over the
540: extra bytes, leaving the medium "positioned after the block": */
541: if (!segment->tme_posix_tape_segment_real_tape
542: && count_bytes_tape > count_bytes_user) {
543: lseek(segment->tme_posix_tape_segment_fd,
544: (count_bytes_tape - count_bytes_user),
545: SEEK_CUR);
546: }
547: }
548: }
549:
550: /* otherwise, this is a write: */
551: else {
552:
553: /* we must have a segment and it must be a real tape: */
554: assert (segment != NULL
555: && segment->tme_posix_tape_segment_real_tape);
556:
557: /* do the write: */
558: rc = write(segment->tme_posix_tape_segment_fd,
559: posix_tape->tme_posix_tape_buffer_data,
560: count_bytes_user);
561: }
562:
563: /* if the transfer got an error: */
564: if (rc < 0) {
565:
566: /* return the error: */
567: /* XXX is this sufficient? */
568: *_count_bytes = 0;
569: *_count_xfer = 0;
570: return (errno);
571: }
572:
573: /* otherwise, we transferred some or none of the data: */
574: else {
575:
576: /* return the final byte count: */
577: *_count_bytes = rc;
578:
579: /* if the request was for one or more blocks at a fixed block size: */
580: if (posix_tape->tme_posix_tape_buffer_flags
581: & TME_TAPE_FLAG_FIXED) {
582:
583: /* return the number of blocks successfully transferred: */
584: *_count_xfer = (rc / xfer_factor);
585: }
586:
587: /* otherwise, the request is for one block at a variable block size: */
588: else {
589:
590: /* return the actual size of the block transferred: */
591:
592: /* if the user asked for what we thought was a whole block, but
593: we transferred less, how much we did transfer is the actual
594: block size: */
595: if (count_bytes_user == block_size
596: && (unsigned long) rc < block_size) {
597: *_count_xfer = rc;
598: }
599:
600: /* otherwise, if this segment is a real tape, we don't know how
601: long the block really was. for now, we just return what we
602: are using as the block size: */
603: /* XXX it may be possible to do an ioctl to get the true
604: residual: */
605: else if (segment->tme_posix_tape_segment_real_tape) {
606: *_count_xfer = block_size;
607: }
608:
609: /* otherwise, this segment isn't a real tape, so we can return
610: what we are using as the block size: */
611: else {
612: *_count_xfer = block_size;
613: }
614: }
615:
616: /* if we didn't read as much from the tape as we were supposed to: */
617: if ((unsigned long) rc < count_bytes_tape) {
618:
619: /* if we read an exact multiple of the block size (including
620: zero blocks), the read was short because of a file mark.
621: return the mark (EOF) condition: */
622: if ((rc % block_size) == 0) {
623:
624: /* return the mark condition: */
625: *_flags |= TME_TAPE_FLAG_MARK;
626:
627: /* if this segment was not a real tape device, skip the file
628: mark - i.e., move to the next segment: */
629: if (segment != NULL
630: && !segment->tme_posix_tape_segment_real_tape) {
631: rc = _tme_posix_tape_mark_skip(posix_tape,
632: 1, TRUE);
633: assert (rc == TME_OK);
634: }
635: }
636:
637: /* otherwise, the read was short because we read a partial
638: block. return the incorrect length indication (ILI)
639: condition: */
640: else {
641: *_flags |= TME_TAPE_FLAG_ILI;
642: }
643: }
644: }
645:
646: return (TME_OK);
647: }
648:
649: /* this starts a transfer. it must be called with the mutex locked: */
650: static int
651: _tme_posix_tape_xfer0(struct tme_posix_tape *posix_tape,
652: int flags,
653: unsigned long count_xfer,
654: unsigned long *_count_bytes)
655: {
656: unsigned long xfer_factor, count_bytes;
657: int old_flags;
658: unsigned long old_count_xfer, old_count_bytes;
659: int rc;
660:
661: /* if the buffer is dirty: */
662: if (posix_tape->tme_posix_tape_flags
663: & TME_POSIX_TAPE_FLAG_DIRTY) {
664:
665: /* write out the buffer: */
666: rc = _tme_posix_tape_xfer1(posix_tape,
667: &old_flags,
668: &old_count_xfer,
669: &old_count_bytes,
670: FALSE);
671: assert (rc == TME_OK);
672:
673: /* this buffer is no longer dirty: */
674: posix_tape->tme_posix_tape_flags
675: &= ~TME_POSIX_TAPE_FLAG_DIRTY;
676: }
677:
678: /* set the parameters of this transfer: */
679: posix_tape->tme_posix_tape_buffer_flags = flags;
680: posix_tape->tme_posix_tape_buffer_count_xfer = count_xfer;
681:
682: /* if the request is for one or more blocks at a fixed block size: */
683: if (posix_tape->tme_posix_tape_buffer_flags
684: & TME_TAPE_FLAG_FIXED) {
685:
686: /* it is an error if the device isn't in fixed block size mode: */
687: xfer_factor = posix_tape->tme_posix_tape_block_size_fixed;
688: if (xfer_factor == 0) {
689: xfer_factor = posix_tape->tme_posix_tape_block_size_min;
690: if (xfer_factor != posix_tape->tme_posix_tape_block_size_max) {
691: return (EINVAL);
692: }
693: }
694: }
695:
696: /* otherwise, the request is for one block at a variable block size: */
697: else {
698: xfer_factor = 1;
699: }
700:
701: /* calculate the byte count: */
702: count_bytes = count_xfer * xfer_factor;
703:
704: /* if the buffer isn't big enough: */
705: if (posix_tape->tme_posix_tape_buffer_size
706: < count_bytes) {
707:
708: /* resize the buffer: */
709: posix_tape->tme_posix_tape_buffer_size
710: = count_bytes;
711: posix_tape->tme_posix_tape_buffer_data
712: = tme_renew(tme_uint8_t,
713: posix_tape->tme_posix_tape_buffer_data,
714: posix_tape->tme_posix_tape_buffer_size);
715: }
716:
717: /* done: */
718: *_count_bytes = count_bytes;
719: return (TME_OK);
720: }
721:
722: /* this releases the current buffer: */
723: static int
724: _tme_posix_tape_release(struct tme_tape_connection *conn_tape,
725: int *_flags,
726: unsigned long *_count_xfer)
727: {
728: struct tme_posix_tape *posix_tape;
729: unsigned long count_bytes;
730: int rc;
731:
732: /* recover our data structure: */
733: posix_tape = (struct tme_posix_tape *) conn_tape->tme_tape_connection.tme_connection_element->tme_element_private;
734:
735: /* assume that this call will succeed: */
736: rc = TME_OK;
737:
738: /* lock the mutex: */
739: tme_mutex_lock(&posix_tape->tme_posix_tape_mutex);
740:
741: /* if the buffer is dirty: */
742: rc = TME_OK;
743: if (posix_tape->tme_posix_tape_flags
744: & TME_POSIX_TAPE_FLAG_DIRTY) {
745:
746: /* write out the buffer: */
747: rc = _tme_posix_tape_xfer1(posix_tape,
748: _flags,
749: _count_xfer,
750: &count_bytes,
751: FALSE);
752:
753: /* this buffer is no longer dirty: */
754: posix_tape->tme_posix_tape_flags
755: &= ~TME_POSIX_TAPE_FLAG_DIRTY;
756: }
757:
758: /* unlock the mutex: */
759: tme_mutex_unlock(&posix_tape->tme_posix_tape_mutex);
760:
761: return (rc);
762: }
763:
764: /* this returns a read buffer: */
765: static int
766: _tme_posix_tape_read(struct tme_tape_connection *conn_tape,
767: int *_flags,
768: unsigned long *_count_xfer,
769: unsigned long *_count_bytes,
770: const tme_uint8_t **_buffer)
771: {
772: struct tme_posix_tape *posix_tape;
773: int rc;
774:
775: /* recover our data structure: */
776: posix_tape = (struct tme_posix_tape *) conn_tape->tme_tape_connection.tme_connection_element->tme_element_private;
777:
778: /* lock the mutex: */
779: tme_mutex_lock(&posix_tape->tme_posix_tape_mutex);
780:
781: /* start the transfer: */
782: rc = _tme_posix_tape_xfer0(posix_tape,
783: *_flags,
784: *_count_xfer,
785: _count_bytes);
786: *_buffer = posix_tape->tme_posix_tape_buffer_data;
787:
788: /* if the start succeeded, finish the transfer: */
789: if (rc == TME_OK) {
790: rc = _tme_posix_tape_xfer1(posix_tape,
791: _flags,
792: _count_xfer,
793: _count_bytes,
794: TRUE);
795: }
796:
797: /* unlock the mutex: */
798: tme_mutex_unlock(&posix_tape->tme_posix_tape_mutex);
799:
800: return (rc);
801: }
802:
803: /* this returns a write buffer: */
804: static int
805: _tme_posix_tape_write(struct tme_tape_connection *conn_tape,
806: int flags,
807: unsigned long count_xfer,
808: unsigned long *_count_bytes,
809: tme_uint8_t **_buffer)
810: {
811: struct tme_posix_tape *posix_tape;
812: int rc;
813:
814: /* recover our data structure: */
815: posix_tape = (struct tme_posix_tape *) conn_tape->tme_tape_connection.tme_connection_element->tme_element_private;
816:
817: /* lock the mutex: */
818: tme_mutex_lock(&posix_tape->tme_posix_tape_mutex);
819:
820: /* start the transfer: */
821: rc = _tme_posix_tape_xfer0(posix_tape,
822: flags,
823: count_xfer,
824: _count_bytes);
825: *_buffer = posix_tape->tme_posix_tape_buffer_data;
826:
827: /* unlock the mutex: */
828: tme_mutex_unlock(&posix_tape->tme_posix_tape_mutex);
829:
830: return (rc);
831: }
832:
833: /* the tape control handler: */
834: #ifdef HAVE_STDARG_H
835: static int _tme_posix_tape_control(struct tme_tape_connection *conn_tape,
836: unsigned int control,
837: ...)
838: #else /* HAVE_STDARG_H */
839: static int _tme_posix_tape_control(conn_tape, control, va_alist)
840: struct tme_tape_connection *conn_tape;
841: unsigned int control;
842: va_dcl
843: #endif /* HAVE_STDARG_H */
844: {
845: struct tme_posix_tape *posix_tape;
846: unsigned long *sizes;
847: const unsigned long *csizes;
848: unsigned int count;
849: va_list control_args;
850: int *_flags;
851: int rc;
852:
853: /* recover our data structure: */
854: posix_tape = (struct tme_posix_tape *) conn_tape->tme_tape_connection.tme_connection_element->tme_element_private;
855:
856: /* lock the mutex: */
857: tme_mutex_lock(&posix_tape->tme_posix_tape_mutex);
858:
859: /* start the variable arguments: */
860: #ifdef HAVE_STDARG_H
861: va_start(control_args, control);
862: #else /* HAVE_STDARG_H */
863: va_start(control_args);
864: #endif /* HAVE_STDARG_H */
865:
866: /* dispatch on the sequence type: */
867: switch (control) {
868:
869: case TME_TAPE_CONTROL_LOAD:
870: _flags = va_arg(control_args, int *);
871: *_flags = (posix_tape->tme_posix_tape_segments != NULL);
872: rc = TME_OK;
873: break;
874:
875: case TME_TAPE_CONTROL_UNLOAD:
876: rc = _tme_posix_tape_unload(posix_tape);
877: break;
878:
879: case TME_TAPE_CONTROL_MARK_WRITE:
880: abort();
881:
882: case TME_TAPE_CONTROL_DENSITY_GET:
883: abort();
884:
885: case TME_TAPE_CONTROL_DENSITY_SET:
886: abort();
887:
888: case TME_TAPE_CONTROL_BLOCK_SIZE_GET:
889: sizes = va_arg(control_args, unsigned long *);
890: sizes[0] = posix_tape->tme_posix_tape_block_size_min;
891: sizes[1] = posix_tape->tme_posix_tape_block_size_max;
892: sizes[2] = posix_tape->tme_posix_tape_block_size_fixed;
893: rc = TME_OK;
894: break;
895:
896: case TME_TAPE_CONTROL_BLOCK_SIZE_SET:
897: csizes = va_arg(control_args, const unsigned long *);
898:
899: /* the minimum block size must be less than or equal to
900: the maximum block size: */
901: if (csizes[0] > csizes[1]) {
902: return (EINVAL);
903: }
904:
905: /* if we aren't given a fixed block size: */
906: if (csizes[2] == 0) {
907:
908: /* if the minimum and maximum block sizes are the same,
909: we are in fixed block size mode: */
910: if (csizes[0] == csizes[1]) {
911: posix_tape->tme_posix_tape_block_size_fixed = csizes[0];
912: }
913:
914: /* otherwise, we are not in fixed block size mode: */
915: else {
916: posix_tape->tme_posix_tape_block_size_fixed = 0;
917: }
918: }
919:
920: /* otherwise, we are given a fixed block size. it must
921: be within the minimum and maximum block sizes: */
922: else {
923: if (csizes[2] < csizes[0]
924: || csizes[2] > csizes[1]) {
925: return (EINVAL);
926: }
927: posix_tape->tme_posix_tape_block_size_fixed = csizes[2];
928: }
929:
930: /* set the minimum and maximum block sizes: */
931: posix_tape->tme_posix_tape_block_size_min = csizes[0];
932: posix_tape->tme_posix_tape_block_size_max = csizes[1];
933: rc = TME_OK;
934: break;
935:
936: case TME_TAPE_CONTROL_MARK_SKIPF:
937: case TME_TAPE_CONTROL_MARK_SKIPR:
938: count = va_arg(control_args, unsigned int);
939: rc = _tme_posix_tape_mark_skip(posix_tape,
940: count,
941: (control
942: == TME_TAPE_CONTROL_MARK_SKIPF));
943: break;
944:
945: case TME_TAPE_CONTROL_REWIND:
946: rc = _tme_posix_tape_rewind(posix_tape);
947: break;
948:
949: default:
950: abort();
951: }
952:
953: /* end the variable arguments: */
954: va_end(control_args);
955:
956: /* unlock the mutex: */
957: tme_mutex_unlock(&posix_tape->tme_posix_tape_mutex);
958:
959: return (rc);
960: }
961:
962: /* our internal command function: */
963: static int
964: __tme_posix_tape_command(struct tme_posix_tape *posix_tape,
965: const char * const * args,
966: char **_output)
967: {
968: struct tme_posix_tape_segment *segment, **_prev;
969: struct tme_posix_tape_control *control;
970: struct stat statbuf;
971: int flags;
972: int arg_i;
973: int usage;
974: int rc;
975: int new_callouts;
976:
977: /* assume we won't need any new callouts: */
978: new_callouts = 0;
979:
980: /* check the command: */
981: usage = FALSE;
982: arg_i = 1;
983:
984: /* the "load" command: */
985: if (TME_ARG_IS(args[arg_i], "load")) {
986: arg_i++;
987:
988: /* if a tape is currently loaded, it must be unloaded first: */
989: if (posix_tape->tme_posix_tape_segments != NULL) {
990: tme_output_append_error(_output,
991: _("%s: tape already loaded; must unload first"),
992: args[0]);
993: return (EBUSY);
994: }
995:
996: /* check for flags, which must all come before the tape segment
997: filenames: */
998: flags = 0;
999: for (;;) {
1000:
1001: /* the "read-only" flag: */
1002: if (TME_ARG_IS(args[arg_i], "read-only")) {
1003: flags |= TME_POSIX_TAPE_FLAG_RO;
1004: arg_i++;
1005: }
1006:
1007: else {
1008: break;
1009: }
1010: }
1011:
1012: /* all of the remaining arguments must be tape segment filenames.
1013: assume that all segments open successfully: */
1014: rc = TME_OK;
1015:
1016: /* open the tape segments: */
1017: segment = NULL;
1018: posix_tape->tme_posix_tape_segments = NULL;
1019: for (_prev = &posix_tape->tme_posix_tape_segments;
1020: ;
1021: _prev = &segment->tme_posix_tape_segment_next) {
1022:
1023: /* stop if we're out of filenames: */
1024: if (args[arg_i] == NULL) {
1025: break;
1026: }
1027:
1028: /* allocate a new tape segment and link it in: */
1029: segment = tme_new0(struct tme_posix_tape_segment, 1);
1030: segment->tme_posix_tape_segment_filename
1031: = tme_strdup(args[arg_i]);
1032: segment->tme_posix_tape_segment_next = NULL;
1033: segment->tme_posix_tape_segment_prev = *_prev;
1034: *_prev = segment;
1035:
1036: /* open the segment file: */
1037: segment->tme_posix_tape_segment_fd
1038: = open(segment->tme_posix_tape_segment_filename,
1039: O_RDONLY);
1040: if (segment->tme_posix_tape_segment_fd < 0) {
1041: rc = errno;
1042: break;
1043: }
1044:
1045: /* stat the segment file: */
1046: if (fstat(segment->tme_posix_tape_segment_fd,
1047: &statbuf) < 0) {
1048: rc = errno;
1049: break;
1050: }
1051:
1052: /* if this is a block device: */
1053: if (S_ISBLK(statbuf.st_mode)) {
1054: tme_output_append_error(_output,
1055: _("cannot use a block device: %s"),
1056: args[arg_i]);
1057: rc = EINVAL;
1058: break;
1059: }
1060:
1061: /* if this is a character device: */
1062: else if (S_ISCHR(statbuf.st_mode)) {
1063:
1064: /* if this is not the only segment: */
1065: if (posix_tape->tme_posix_tape_segments != segment
1066: || args[arg_i + 1] != NULL) {
1067: tme_output_append_error(_output,
1068: _("a real device must be the only tape segment: "));
1069: rc = EINVAL;
1070: break;
1071: }
1072:
1073: /* this is a real tape: */
1074: segment->tme_posix_tape_segment_real_tape = TRUE;
1075: }
1076:
1077: /* otherwise, this is a regular file: */
1078: else {
1079:
1080: /* this tape must be read-only: */
1081: flags |= TME_POSIX_TAPE_FLAG_RO;
1082: }
1083:
1084: /* if this is not the first segment, close the file: */
1085: if (posix_tape->tme_posix_tape_segments != segment) {
1086: close(segment->tme_posix_tape_segment_fd);
1087: segment->tme_posix_tape_segment_fd = -1;
1088: }
1089:
1090: /* advance to the next segment filename: */
1091: arg_i++;
1092: }
1093:
1094: /* if we got an error: */
1095: if (rc != TME_OK) {
1096:
1097: /* append any segment filename to the error: */
1098: if (segment != NULL) {
1099: tme_output_append_error(_output,
1100: "%s",
1101: segment->tme_posix_tape_segment_filename);
1102: }
1103:
1104: /* close and free the segments: */
1105: _tme_posix_tape_segments_close(posix_tape);
1106: }
1107:
1108: /* otherwise, if we opened no segments: */
1109: else if (posix_tape->tme_posix_tape_segments == NULL) {
1110: tme_output_append_error(_output,
1111: "%s %s load [read-only] { %s | %s [ .. %s ] }",
1112: _("usage:"),
1113: args[0],
1114: _("DEVICE"),
1115: _("FILENAME"),
1116: _("FILENAME"));
1117: rc = EINVAL;
1118: }
1119:
1120: /* otherwise, a tape has now been loaded: */
1121: else {
1122:
1123: /* a tape has now been loaded: */
1124: posix_tape->tme_posix_tape_flags
1125: = flags;
1126:
1127: /* the first segment is still open. make it the current segment: */
1128: posix_tape->tme_posix_tape_segment_current
1129: = posix_tape->tme_posix_tape_segments;
1130:
1131: /* call out a LOAD control: */
1132: control = _tme_posix_tape_control_new(posix_tape);
1133: control->tme_posix_tape_control_which = TME_TAPE_CONTROL_LOAD;
1134: new_callouts |= TME_POSIX_TAPE_CALLOUT_CONTROL;
1135: }
1136: }
1137:
1138: /* the "unload" command: */
1139: else if (TME_ARG_IS(args[arg_i], "unload")) {
1140:
1141: /* if no tape is currently loaded: */
1142: if (posix_tape->tme_posix_tape_segments == NULL) {
1143: tme_output_append_error(_output,
1144: _("%s: no tape loaded"),
1145: args[0]);
1146: return (ENXIO);
1147: }
1148:
1149: /* we must have no arguments: */
1150: if (args[arg_i + 1] != NULL) {
1151: tme_output_append_error(_output,
1152: "%s %s unload",
1153: _("usage:"),
1154: args[0]);
1155: return (EINVAL);
1156: }
1157:
1158: /* unload the tape: */
1159: _tme_posix_tape_unload(posix_tape);
1160:
1161: /* call out an UNLOAD control: */
1162: control = _tme_posix_tape_control_new(posix_tape);
1163: control->tme_posix_tape_control_which = TME_TAPE_CONTROL_UNLOAD;
1164: new_callouts |= TME_POSIX_TAPE_CALLOUT_CONTROL;
1165: rc = TME_OK;
1166: }
1167:
1168: /* any other command: */
1169: else {
1170: if (args[arg_i] != NULL) {
1171: tme_output_append_error(_output,
1172: "%s '%s', ",
1173: _("unknown command"),
1174: args[1]);
1175: }
1176: tme_output_append_error(_output,
1177: _("available %s commands: %s"),
1178: args[0],
1179: "load unload");
1180: return (EINVAL);
1181: }
1182:
1183: /* make any new callouts: */
1184: _tme_posix_tape_callout(posix_tape, new_callouts);
1185:
1186: return (rc);
1187: }
1188:
1189: /* our command function: */
1190: static int
1191: _tme_posix_tape_command(struct tme_element *element,
1192: const char * const * args,
1193: char **_output)
1194: {
1195: struct tme_posix_tape *posix_tape;
1196: int rc;
1197:
1198: /* recover our data structure: */
1199: posix_tape = (struct tme_posix_tape *) element->tme_element_private;
1200:
1201: /* lock the mutex: */
1202: tme_mutex_lock(&posix_tape->tme_posix_tape_mutex);
1203:
1204: /* call the internal command function: */
1205: rc = __tme_posix_tape_command(posix_tape,
1206: args,
1207: _output);
1208:
1209: /* unlock the mutex: */
1210: tme_mutex_unlock(&posix_tape->tme_posix_tape_mutex);
1211:
1212: return (rc);
1213: }
1214:
1215: /* this breaks a posix tape connection: */
1216: static int
1217: _tme_posix_tape_connection_break(struct tme_connection *conn,
1218: unsigned int state)
1219: {
1220: abort();
1221: }
1222:
1223: /* this makes a posix tape connection: */
1224: static int
1225: _tme_posix_tape_connection_make(struct tme_connection *conn,
1226: unsigned int state)
1227: {
1228: struct tme_posix_tape *posix_tape;
1229: struct tme_tape_connection *conn_tape;
1230:
1231: /* recover our data structure: */
1232: posix_tape = (struct tme_posix_tape *) conn->tme_connection_element->tme_element_private;
1233:
1234: /* both sides must be tape connections: */
1235: assert(conn->tme_connection_type == TME_CONNECTION_TAPE);
1236: assert(conn->tme_connection_other->tme_connection_type == TME_CONNECTION_TAPE);
1237:
1238: /* we're always set up to answer calls across the connection,
1239: so we only have to do work when the connection has gone full,
1240: namely taking the other side of the connection: */
1241: if (state == TME_CONNECTION_FULL) {
1242:
1243: /* lock the mutex: */
1244: tme_mutex_lock(&posix_tape->tme_posix_tape_mutex);
1245:
1246: /* save this connection to our list of connections: */
1247: conn_tape = (struct tme_tape_connection *) conn->tme_connection_other;
1248: posix_tape->tme_posix_tape_connection = conn_tape;
1249:
1250: /* unlock the mutex: */
1251: tme_mutex_unlock(&posix_tape->tme_posix_tape_mutex);
1252: }
1253:
1254: return (TME_OK);
1255: }
1256:
1257: /* this makes a new connection side for a posix tape: */
1258: static int
1259: _tme_posix_tape_connections_new(struct tme_element *element,
1260: const char * const *args,
1261: struct tme_connection **_conns,
1262: char **_output)
1263: {
1264: struct tme_posix_tape *posix_tape;
1265: struct tme_tape_connection *conn_tape;
1266: struct tme_connection *conn;
1267:
1268: /* recover our data structure: */
1269: posix_tape = (struct tme_posix_tape *) element->tme_element_private;
1270:
1271: /* if we already have a connection, there's nothing to do: */
1272: if (posix_tape->tme_posix_tape_connection != NULL) {
1273: return (TME_OK);
1274: }
1275:
1276: /* create our side of a tape connection: */
1277: conn_tape = tme_new0(struct tme_tape_connection, 1);
1278: conn = &conn_tape->tme_tape_connection;
1279:
1280: /* fill in the generic connection: */
1281: conn->tme_connection_next = *_conns;
1282: conn->tme_connection_type = TME_CONNECTION_TAPE;
1283: conn->tme_connection_score = tme_tape_connection_score;
1284: conn->tme_connection_make = _tme_posix_tape_connection_make;
1285: conn->tme_connection_break = _tme_posix_tape_connection_break;
1286:
1287: /* fill in the tape connection: */
1288: conn_tape->tme_tape_connection_read
1289: = _tme_posix_tape_read;
1290: conn_tape->tme_tape_connection_write
1291: = _tme_posix_tape_write;
1292: conn_tape->tme_tape_connection_release
1293: = _tme_posix_tape_release;
1294: conn_tape->tme_tape_connection_control
1295: = _tme_posix_tape_control;
1296:
1297: /* return the connection side possibility: */
1298: *_conns = conn;
1299: return (TME_OK);
1300: }
1301:
1302: /* the new posix tape function: */
1303: TME_ELEMENT_SUB_NEW_DECL(tme_host_posix,tape) {
1304: struct tme_posix_tape *posix_tape;
1305: int flags;
1306: int arg_i;
1307: int usage;
1308:
1309: /* check our arguments: */
1310: flags = 0;
1311: arg_i = 1;
1312: usage = FALSE;
1313:
1314: /* loop reading our arguments: */
1315: for (;;) {
1316:
1317: if (0) {
1318: }
1319:
1320: /* if we've run out of arguments: */
1321: else if (args[arg_i + 0] == NULL) {
1322:
1323: break;
1324: }
1325:
1326: /* this is a bad argument: */
1327: else {
1328: tme_output_append_error(_output,
1329: "%s %s",
1330: args[arg_i],
1331: _("unexpected"));
1332: usage = TRUE;
1333: break;
1334: }
1335: }
1336:
1337: if (usage) {
1338: tme_output_append_error(_output,
1339: "%s %s",
1340: _("usage:"),
1341: args[0]);
1342: return (EINVAL);
1343: }
1344:
1345: /* start the tape structure: */
1346: posix_tape = tme_new0(struct tme_posix_tape, 1);
1347: posix_tape->tme_posix_tape_element = element;
1348: tme_mutex_init(&posix_tape->tme_posix_tape_mutex);
1349: posix_tape->tme_posix_tape_flags = flags;
1350: posix_tape->tme_posix_tape_segments = NULL;
1351: posix_tape->tme_posix_tape_segment_current = NULL;
1352:
1353: /* XXX these are fake values for now: */
1354: posix_tape->tme_posix_tape_block_size_min = 512;
1355: posix_tape->tme_posix_tape_block_size_max = 32768;
1356: posix_tape->tme_posix_tape_block_size_fixed = 0;
1357:
1358: /* start the tape buffer. the 16384 isn't magic, it's just a
1359: starting point: */
1360: posix_tape->tme_posix_tape_buffer_size = 16384;
1361: posix_tape->tme_posix_tape_buffer_data
1362: = tme_new(tme_uint8_t,
1363: posix_tape->tme_posix_tape_buffer_size);
1364:
1365: /* fill the element: */
1366: element->tme_element_private = posix_tape;
1367: element->tme_element_connections_new = _tme_posix_tape_connections_new;
1368: element->tme_element_command = _tme_posix_tape_command;
1369:
1370: return (TME_OK);
1371: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.