home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume26 / tprobe-1.0 / part01 next >
Text File  |  1992-12-29  |  47KB  |  1,563 lines
  1. Newsgroups: comp.sources.unix
  2. From: thad@btr.com (Thad Floryan)
  3. Subject: v26i084: tprobe-1.0 - tape saveset analyzer and duplicator, Part01/01
  4. Sender: unix-sources-moderator@pa.dec.com
  5. Approved: vixie@pa.dec.com
  6.  
  7. Submitted-By: thad@btr.com (Thad Floryan)
  8. Posting-Number: Volume 26, Issue 84
  9. Archive-Name: tprobe-1.0/part01
  10.  
  11.                  T P R O B E
  12.  
  13.          Tape Saveset Analyzer and Duplicator
  14.  
  15.      @(#)README V1.0, 12-Feb-1992, Thad Floryan [ thad@btr.com ]
  16.  
  17.  
  18. tprobe is a utility which succeeds duplicating boot/install tapes that are not
  19. easily copied by other means.  One of its features is operation over a pipeline
  20. utilizing multiple tape drives whereever they exist on a network or a system.
  21.  
  22. tprobe can also (indirectly) perform media conversions, though the only
  23. verified conversions have been from QIC-120 and QIC-150 to QIC-24 and vice
  24. versa; there is no inherent limitation, so other conversions are definitely
  25. possible.
  26.  
  27. Another feature is that a tape may be processed without disk space being
  28. usurped for intermediate staging.  Thus, a full 150MB tape can be duplicated
  29. even if one's system has only, say, 20MB free.
  30.  
  31. tprobe's basic operation reveals a tape's existing saveset layout and stored
  32. capacity, and requires only a single tape drive for this analysis.
  33.  
  34. tprobe was intended to be a one-time-only program, but it is useful in its
  35. present incarnation and does solve immediate and present problems.
  36.  
  37. tprobe was conceived when it was realized the SunOS 4.1.1 Sun-3 SUNBIN install
  38. tape was to be the last ever from Sun for that architecture and that a backup
  39. was essential to prevent disaster if the tape should be "bad" when most needed
  40. to boot into a miniroot.
  41.  
  42. Complete nroff-/troff-ready documentation accompanies this distribution.
  43. Additional notes and anecdotes not appropriate for the "man" page follow.
  44.  
  45. tprobe began as a Kwik'N'Dirty program to ascertain the saveset layout of
  46. tapes to discover why "obvious" means of tape duplication were not successful;
  47. varying record sizes were found to be the problem whose solution (for my
  48. purposes) is the present release.
  49.  
  50. An obvious but often neglected fact is that tape drives need to be kept clean.
  51. Many tape subsystem enclosures are poorly-designed, with fans sucking in dust
  52. and atmospheric contaminants over the heads and operating parts.  It's my
  53. opinion that tape drive housings should be constructed with fan(s) blowing
  54. filtered air IN to maintain a positive pressure inside the enclosure as a
  55. barrier to pollution (per the guidelines of clean rooms used in semiconductor
  56. manufacture).  Systems with externally-replaceable filters are the best.
  57.  
  58. For optimum performance and reliability, tapes should also be retensioned
  59. prior to use.  Retensioning (one high speed rewind cycle from end to end)
  60. assures a even tape pack and facilitates accurate tape handling by the tape
  61. drive transport.
  62.  
  63. Always, ALWAYS write-protect a tape after removing it from a drive.  All QIC
  64. and 1/2" cartridges have a tab that can be turned or flipped to a "SAFE"
  65. position; DO IT!  The number of laments posted to Usenet after someone
  66. overwrites a crucial backup is increasing; be SAFE, not SORRY.
  67.  
  68. Remember: the most dangerous command on UNIX, or any system for that matter,
  69. is the RETURN.  Very few commands are retractable.  Be careful!
  70.  
  71. Accompanying this README are extracts from some of my recent Usenet postings
  72. concerning tapes, their formats, their setup and their handling per:
  73.  
  74. README.qic    concerning QIC compatibility
  75. README.2150    concerning Archive 2060S/2150S jumper settings
  76. README.5945    concerning Archive 5945C, SCSI, and Emulex MT02 setup
  77. README.exb    concerning Exabyte EXB-8200 capacities and setup
  78. README.tzk10    concerning DEC's TZK10 and Archive's ST525 drives
  79.  
  80. Thad Floryan [ thad@btr.com (OR) {decwrl, mips, fernwood}!btr!thad ]
  81.  
  82. #! /bin/sh
  83. # This is a shell archive.  Remove anything before this line, then unpack
  84. # it by saving it into a file and typing "sh file".  To overwrite existing
  85. # files, type "sh file -c".  You can also feed this as standard input via
  86. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  87. # will see the following message at the end:
  88. #        "End of archive 1 (of 1)."
  89. # Contents:  MANIFEST Makefile Makefile.3b1 README README.2150
  90. #   README.5945 README.exb README.qic README.tzk10 tprobe.c tprobe.man
  91. # Wrapped by vixie@cognition.pa.dec.com on Wed Dec 30 11:36:20 1992
  92. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  93. if test -f 'MANIFEST' -a "${1}" != "-c" ; then 
  94.   echo shar: Will not clobber existing file \"'MANIFEST'\"
  95. else
  96. echo shar: Extracting \"'MANIFEST'\" \(437 characters\)
  97. sed "s/^X//" >'MANIFEST' <<'END_OF_FILE'
  98. X   File Name        Archive #    Description
  99. X-----------------------------------------------------------
  100. X MANIFEST                   1    
  101. X Makefile                   1    
  102. X Makefile.3b1               1    
  103. X README                     1    
  104. X README.2150                1    
  105. X README.5945                1    
  106. X README.exb                 1    
  107. X README.qic                 1    
  108. X README.tzk10               1    
  109. X tprobe.c                   1    
  110. X tprobe.man                 1    
  111. END_OF_FILE
  112. if test 437 -ne `wc -c <'MANIFEST'`; then
  113.     echo shar: \"'MANIFEST'\" unpacked with wrong size!
  114. fi
  115. # end of 'MANIFEST'
  116. fi
  117. if test -f 'Makefile' -a "${1}" != "-c" ; then 
  118.   echo shar: Will not clobber existing file \"'Makefile'\"
  119. else
  120. echo shar: Extracting \"'Makefile'\" \(1211 characters\)
  121. sed "s/^X//" >'Makefile' <<'END_OF_FILE'
  122. X# Generic Makefile for tprobe
  123. X#
  124. X# make        will create the tprobe executable in the current directory
  125. X# make catman    will create catman-style documentation in the current directory
  126. X# make install    will mv(1) the executable to the specified $(DEST) directory
  127. X# make clean    will tidy-up the current directory after a link or install
  128. X# make lint    will check the source for programming irregularities
  129. X# make lintp    will check the source for portability considerations
  130. X#
  131. X# Several options can be uncommented for configuration on your system.
  132. X
  133. CC    =    cc
  134. X
  135. X# Uncomment or change as appropriate for your system:
  136. X#
  137. COPT    =    -O
  138. X#CDBG    =    -g
  139. X#CPROF    =    -p -g
  140. X#
  141. CFLAGS    =    $(COPT) $(CDBG) $(CPROF)
  142. X
  143. LDFLAGS =    -s
  144. X
  145. X# Uncomment or change as appropriate for your system:
  146. X#
  147. X#LSVR3    =    -lc_s
  148. X#
  149. LIBS    =    $(LSVR3)
  150. X
  151. NAME    =    tprobe
  152. OBJS    =    tprobe.o
  153. SRCS    =    tprobe.c
  154. MANF    =    tprobe.man
  155. MANEXT    =    1
  156. X
  157. DEST    =    /usr/local/bin
  158. XFMODE    =    555
  159. X
  160. X$(NAME)    :    $(OBJS)
  161. X        $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(OBJS) $(LIBS)
  162. X
  163. install :    $(NAME)
  164. X        mv    $(NAME)  $(DEST)/
  165. X        chmod $(FMODE) $(DEST)/$(NAME)
  166. X
  167. catman    :    $(NAME).$(MANEXT)
  168. X
  169. X$(NAME).$(MANEXT) : $(MANF)
  170. X        nroff -man $(MANF) > $(NAME).$(MANEXT)
  171. X
  172. clean    :
  173. X        rm -f core *~ $(OBJS)
  174. X
  175. lint    :
  176. X        lint $(SRCS)
  177. X
  178. lintp    :
  179. X        lint -p $(SRCS)
  180. END_OF_FILE
  181. if test 1211 -ne `wc -c <'Makefile'`; then
  182.     echo shar: \"'Makefile'\" unpacked with wrong size!
  183. fi
  184. # end of 'Makefile'
  185. fi
  186. if test -f 'Makefile.3b1' -a "${1}" != "-c" ; then 
  187.   echo shar: Will not clobber existing file \"'Makefile.3b1'\"
  188. else
  189. echo shar: Extracting \"'Makefile.3b1'\" \(1140 characters\)
  190. sed "s/^X//" >'Makefile.3b1' <<'END_OF_FILE'
  191. X# 3B1 Makefile for tprobe
  192. X#
  193. X# make        will create the tprobe executable in the current directory
  194. X# make cat    will create catman-style documentation in the current directory
  195. X# make install    will mv(1) the executable to the specified $(DEST) directory
  196. X# make clean    will tidy-up the current directory after a link or install
  197. X# make lint    will check the source for programming irregularities
  198. X# make lintp    will check the source for portability considerations
  199. X#
  200. X# Several options can be uncommented for configuration on your system.
  201. X
  202. CC    =    gcc
  203. X
  204. X# Uncomment or change as appropriate for your system:
  205. X#
  206. COPT    =    -O
  207. X#CDBG    =    -g
  208. X#CPROF    =    -p -g
  209. X#
  210. CFLAGS    =    $(COPT) $(CDBG) $(CPROF)
  211. X
  212. LDFLAGS =    -s
  213. X
  214. LIBS    =    /lib/crt0s.o /lib/shlib.ifile
  215. X
  216. NAME    =    tprobe
  217. OBJS    =    tprobe.o
  218. SRCS    =    tprobe.c
  219. MANF    =    tprobe.man
  220. MANEXT    =    1
  221. X
  222. DEST    =    /usr/local/bin
  223. XFMODE    =    555
  224. X
  225. X$(NAME)    :    $(OBJS)
  226. X        $(LD) $(LDFLAGS) -o $@ $(OBJS) $(LIBS)
  227. X
  228. install :    $(NAME)
  229. X        mv    $(NAME)  $(DEST)/
  230. X        chmod $(FMODE) $(DEST)/$(NAME)
  231. X
  232. cat    :    $(NAME).$(MANEXT)
  233. X
  234. X$(NAME).$(MANEXT) : $(MANF)
  235. X        nroff -man $(MANF) > $(NAME).$(MANEXT)
  236. X
  237. clean    :
  238. X        rm -f core *~ $(OBJS)
  239. X
  240. lint    :
  241. X        lint $(SRCS)
  242. X
  243. lintp    :
  244. X        lint -p $(SRCS)
  245. END_OF_FILE
  246. if test 1140 -ne `wc -c <'Makefile.3b1'`; then
  247.     echo shar: \"'Makefile.3b1'\" unpacked with wrong size!
  248. fi
  249. # end of 'Makefile.3b1'
  250. fi
  251. if test -f 'README' -a "${1}" != "-c" ; then 
  252.   echo shar: Will not clobber existing file \"'README'\"
  253. else
  254. echo shar: Extracting \"'README'\" \(3465 characters\)
  255. sed "s/^X//" >'README' <<'END_OF_FILE'
  256. X                 T P R O B E
  257. X
  258. X         Tape Saveset Analyzer and Duplicator
  259. X
  260. X     @(#)README V1.0, 12-Feb-1992, Thad Floryan [ thad@btr.com ]
  261. X
  262. X
  263. tprobe is a utility which succeeds duplicating boot/install tapes that are not
  264. easily copied by other means.  One of its features is operation over a pipeline
  265. utilizing multiple tape drives whereever they exist on a network or a system.
  266. X
  267. tprobe can also (indirectly) perform media conversions, though the only
  268. verified conversions have been from QIC-120 and QIC-150 to QIC-24 and vice
  269. versa; there is no inherent limitation, so other conversions are definitely
  270. possible.
  271. X
  272. Another feature is that a tape may be processed without disk space being
  273. usurped for intermediate staging.  Thus, a full 150MB tape can be duplicated
  274. even if one's system has only, say, 20MB free.
  275. X
  276. tprobe's basic operation reveals a tape's existing saveset layout and stored
  277. capacity, and requires only a single tape drive for this analysis.
  278. X
  279. tprobe was intended to be a one-time-only program, but it is useful in its
  280. present incarnation and does solve immediate and present problems.
  281. X
  282. tprobe was conceived when it was realized the SunOS 4.1.1 Sun-3 SUNBIN install
  283. tape was to be the last ever from Sun for that architecture and that a backup
  284. was essential to prevent disaster if the tape should be "bad" when most needed
  285. to boot into a miniroot.
  286. X
  287. Complete nroff-/troff-ready documentation accompanies this distribution.
  288. Additional notes and anecdotes not appropriate for the "man" page follow.
  289. X
  290. tprobe began as a Kwik'N'Dirty program to ascertain the saveset layout of
  291. tapes to discover why "obvious" means of tape duplication were not successful;
  292. varying record sizes were found to be the problem whose solution (for my
  293. purposes) is the present release.
  294. X
  295. An obvious but often neglected fact is that tape drives need to be kept clean.
  296. Many tape subsystem enclosures are poorly-designed, with fans sucking in dust
  297. and atmospheric contaminants over the heads and operating parts.  It's my
  298. opinion that tape drive housings should be constructed with fan(s) blowing
  299. filtered air IN to maintain a positive pressure inside the enclosure as a
  300. barrier to pollution (per the guidelines of clean rooms used in semiconductor
  301. manufacture).  Systems with externally-replaceable filters are the best.
  302. X
  303. XFor optimum performance and reliability, tapes should also be retensioned
  304. prior to use.  Retensioning (one high speed rewind cycle from end to end)
  305. assures a even tape pack and facilitates accurate tape handling by the tape
  306. drive transport.
  307. X
  308. Always, ALWAYS write-protect a tape after removing it from a drive.  All QIC
  309. and 1/2" cartridges have a tab that can be turned or flipped to a "SAFE"
  310. position; DO IT!  The number of laments posted to Usenet after someone
  311. overwrites a crucial backup is increasing; be SAFE, not SORRY.
  312. X
  313. Remember: the most dangerous command on UNIX, or any system for that matter,
  314. is the RETURN.  Very few commands are retractable.  Be careful!
  315. X
  316. Accompanying this README are extracts from some of my recent Usenet postings
  317. concerning tapes, their formats, their setup and their handling per:
  318. X
  319. README.qic    concerning QIC compatibility
  320. README.2150    concerning Archive 2060S/2150S jumper settings
  321. README.5945    concerning Archive 5945C, SCSI, and Emulex MT02 setup
  322. README.exb    concerning Exabyte EXB-8200 capacities and setup
  323. README.tzk10    concerning DEC's TZK10 and Archive's ST525 drives
  324. X
  325. X
  326. Thad Floryan [ thad@btr.com (OR) {decwrl, mips, fernwood}!btr!thad ]
  327. END_OF_FILE
  328. if test 3465 -ne `wc -c <'README'`; then
  329.     echo shar: \"'README'\" unpacked with wrong size!
  330. fi
  331. # end of 'README'
  332. fi
  333. if test -f 'README.2150' -a "${1}" != "-c" ; then 
  334.   echo shar: Will not clobber existing file \"'README.2150'\"
  335. else
  336. echo shar: Extracting \"'README.2150'\" \(1675 characters\)
  337. sed "s/^X//" >'README.2150' <<'END_OF_FILE'
  338. X         Viper 2060S and 2150S hardware setup
  339. X
  340. X
  341. Hardware setup amongst the 9 sets of jumpers includes:
  342. X
  343. X    SCSI ID:    3 sets of jumpers
  344. X    Serial:        this should NOT be set
  345. X    Diagnostic:    this should NOT be set
  346. X    Parity Enable:    setting depends on your interface; either EVERYTHING
  347. X            or NOTHING on the bus should be checking parity.
  348. X    Buffer Disc:    3 sets of jumpers select 2, 4, 6, 8, 12, 16, 24 and
  349. X            32K buffer sizes.  Factory default is 16K.  This is
  350. X            the number of bytes transferred over the bus in a
  351. X            single operation.  A mininum of 16K is required for
  352. X            the SCSI "COPY" command.
  353. X
  354. X
  355. Where to find all this at the back of the drive:
  356. X
  357. X    [OOOO]    TTTTTTTT TTTTTTTT TTTTTTTT
  358. X     [JJ]    SSSSSSSSSSSSSSSSSSSSSSSSSS
  359. X
  360. X    Where:    [OOOO]    is the power connector
  361. X         [JJ]    is the jumper block
  362. X        TTTTTT    are the three 8-pin terminators
  363. X        SSSSSS    is the 25x2 SCSI connector
  364. X
  365. X    The jumper block looks like this (in the orientation as above):
  366. X
  367. X    [ SERIAL ]    [  CF2    ]    [  ID2    ]
  368. X    [  DIAG. ]    [  CF1    ]    [  ID1    ]
  369. X    [ PARITY ]    [  CF0    ]    [  ID0    ]
  370. X
  371. X    SERIAL: no jumper
  372. X    DIAG:    no jumper
  373. X    PARITY: jumper to enable
  374. X
  375. X    ============================= BUFFER ==============================
  376. X
  377. X    SIZE:    2K    4K    6K    8K    12K    16K    24K    32K
  378. X
  379. X    CF2:    o o    o o    o o    o o    [o=o]   [o=o]   [o=o]   [o=o]
  380. X    CF1:    o o    o o    [o=o]   [o=o]    o o    o o    [o=o]   [o=o]
  381. X    CF0:    o o    [o=o]    o o    [o=o]    o o    [o=o]    o o    [o=o]
  382. X
  383. X
  384. X    ============================= SCSI ID =============================
  385. X
  386. X    ID:     0     1     2     3     4     5     6     7
  387. X
  388. X    ID2:    o o    o o    o o    o o    [o=o]   [o=o]   [o=o]   [o=o]
  389. X    ID1:    o o    o o    [o=o]   [o=o]    o o    o o    [o=o]   [o=o]
  390. X    ID0:    o o    [o=o]    o o    [o=o]    o o    [o=o]    o o    [o=o]
  391. X
  392. X    ===================================================================
  393. END_OF_FILE
  394. if test 1675 -ne `wc -c <'README.2150'`; then
  395.     echo shar: \"'README.2150'\" unpacked with wrong size!
  396. fi
  397. # end of 'README.2150'
  398. fi
  399. if test -f 'README.5945' -a "${1}" != "-c" ; then 
  400.   echo shar: Will not clobber existing file \"'README.5945'\"
  401. else
  402. echo shar: Extracting \"'README.5945'\" \(2440 characters\)
  403. sed "s/^X//" >'README.5945' <<'END_OF_FILE'
  404. X>I have a surplus Archive 5945C QIC tape drive intended for an
  405. X>NCR Tower computer.  The drive assembly includes an interface
  406. X>board of some kind.  The adapter board, which is separate from
  407. X>the tape drive, has a 50 pin edge connector.
  408. X>
  409. X>Is this a SCSI assembly?
  410. X
  411. No, it is not a SCSI assembly.
  412. X
  413. I have identical drives/cards on my Britton-Lee/ShareBase boxes, and on
  414. X3B1, CT MiniFrame, and CT MightyFrame systems.
  415. X
  416. The drive is QIC-02; the interface card accompanying it (assuming it's
  417. mfd by Archive) is most likely a QIC-36 to QIC-02 adapter/translator.
  418. X
  419. On the 50-wire edge connector, not many of the "pins" are used.  In fact,
  420. when used in external tape-drive-only shoeboxes, Archive has two interface
  421. cards which adapt an external connector to the 50-wire edge connector per:
  422. X
  423. X    D-37 connector to 50-wire edge: 80332-001
  424. X    DB25 connector to 50-wire edge: 80221-001
  425. X
  426. These connector-adapter cards are about 1" x 3", and are intended to be
  427. mounted on the "wall" of an enclosure case.
  428. X
  429. When that tape-drive/card is (typically) mounted inside a computer, a 50-wire
  430. ribbon connector is usually used to connect the drive to either a motherboard
  431. or an internal expansion card.  This is why "pulls" (a surplussed drive from
  432. an old computer) are often mistaken for being a SCSI drive.
  433. X
  434. If the accompanying card is an Emulex MT02 (as used on Sun3 systems, for
  435. example), then you could use that drive on a SCSI bus.  The 25x2 SCSI connector
  436. and the two 14-PIN 220/330 Ohm terminator sockets would be obvious; the ID
  437. selection is not obvious (due to use of an unlabelled 8-pos'n DIP switch):
  438. X
  439. X    SW-1 thru SW-3 select SCSI ID per:
  440. X        SW-3 is bit "2", SW-2 is bit "1", SW-1 is bit "0"
  441. X
  442. X    SW-4 is not used.
  443. X
  444. X    SW-5 must be ON ("tach" rate), SW-6 and SW-7 must be OFF
  445. X
  446. X    SW-8 enables parity checking
  447. X
  448. SUMMARY: if the card accompanying the drive is mfd by Archive, it's NOT SCSI,
  449. and you risk damage attempting to adapt a cable to plug it into a SCSI-based
  450. system.
  451. X
  452. WITHOUT EXCEPTION, of the 100's of HDs, tape drives, and other peripherals
  453. I've seen, SCSI ones will have a 25x2 dual-row pin connector whose pins are
  454. on 0.100" centers, and they'll also have an "obvious" location for SCSI
  455. terminators (either 14-/16-pin DIP sockets, several SIP sockets, or one
  456. large 24-DIP socket), and either a DIP switch or jumpers for selecting other
  457. SCSI and mfr-specific parameters (such as parity, buffer sizes, delayed power-
  458. on, "PIN 26" TERMPWR selections, etc.).
  459. END_OF_FILE
  460. if test 2440 -ne `wc -c <'README.5945'`; then
  461.     echo shar: \"'README.5945'\" unpacked with wrong size!
  462. fi
  463. # end of 'README.5945'
  464. fi
  465. if test -f 'README.exb' -a "${1}" != "-c" ; then 
  466.   echo shar: Will not clobber existing file \"'README.exb'\"
  467. else
  468. echo shar: Extracting \"'README.exb'\" \(1931 characters\)
  469. sed "s/^X//" >'README.exb' <<'END_OF_FILE'
  470. X>Could someone tell me if an Exabyte 8200 puts 2.3GB on
  471. X>a 90 or 120 minute tape?
  472. X
  473. Depends what cartridge TYPE you're using, and whether you're operating the
  474. drive in "international mode" or not.
  475. X
  476. XFrom Exabyte's "Product Specification" manual, they identify the P5 and P6
  477. cartridges, and they list the track and total block capacities from which
  478. the following table is an extract.  The block count represents the number
  479. of 1024-byte blocks.  Their table is in hex, but I just happen to have my
  480. Casio fx-451 calculator handy for conversions to decimal!
  481. X
  482. Cartridge    Blocks (LBOT to LEOT)
  483. X
  484. P5-15         5C100H =   377,088    * 1024 =   386,138,112 bytes
  485. P5-30         BC2B8H =   770,744    * 1024 =   789,241,856 bytes
  486. P5-60        172FF8H = 1,519,608    * 1024 = 1,556,078,592 bytes
  487. P5-90        22C668H = 2,279,016    * 1024 = 2,333,712,384 bytes
  488. X
  489. P6-15         407E0H =   264,160    * 1024 =   270,499,840 bytes
  490. P6-30         80FC0H =   528,320    * 1024 =   540,999,680 bytes
  491. P6-60        102020H = 1,056,800    * 1024 = 1,082,163,200 bytes
  492. P6-90        182EA0H = 1,584,800    * 1024 = 1,622,835,200 bytes
  493. P6-120        1FF0E0H = 2,093,280    * 1024 = 2,143,518,720 bytes
  494. X
  495. X--------------------
  496. X
  497. So far I've seen two styles of EXB-8200 drives whose external option jumperings
  498. do NOT resemble those depicted in the Exabyte manuals (various forms of the
  499. XEXABYTE CORP EXB-8200 8MM Cartridge Tape Subsystem Product Specification,
  500. part number MKT-015-03).
  501. X
  502. Another Exabyte manual is their "Interface User's Manual", MKT-016-04, which
  503. on pages 115-117 show how to set (or check) parity, even/odd byte disconnect,
  504. domestic/international cartridges, fixed/variable block modes, etc.) on an
  505. INTERNAL (to the drive) PC card [ and it's a bear to open the drive's card
  506. cage due to cheap tin (putty? :-) screws whose heads disintegrate even with a
  507. proper ISO metric screwdriver (same problem with Japanese audio gear;
  508. difficult to believe that with the world's most modern steel mills, their
  509. steel is the worse (too soft)) ]
  510. END_OF_FILE
  511. if test 1931 -ne `wc -c <'README.exb'`; then
  512.     echo shar: \"'README.exb'\" unpacked with wrong size!
  513. fi
  514. # end of 'README.exb'
  515. fi
  516. if test -f 'README.qic' -a "${1}" != "-c" ; then 
  517.   echo shar: Will not clobber existing file \"'README.qic'\"
  518. else
  519. echo shar: Extracting \"'README.qic'\" \(2742 characters\)
  520. sed "s/^X//" >'README.qic' <<'END_OF_FILE'
  521. X[concerning QIC compatibility]
  522. X
  523. Seems some clarification is required here.  Irrespective of the drive's
  524. interface (QIC-02, SCSI, etc.) there are several TRACK formats common to all
  525. QIC (Quarter Inch Cartridge) tapes with several levels of upward-compatible
  526. READ conformance.
  527. X
  528. All the QIC drives perform "serpentine" (hence Archive's Viper, Cobra, etc.)
  529. recording meaning one track at a time is recorded in one direction, then the
  530. heads move and subsequent recording occurs in the opposite direction, etc.
  531. X
  532. Much like the compatibility between {mono, stereo, quad} Philips "Compact
  533. Cassettes" (tm) for audio, the QIC manufacturers have agreed upon:
  534. X
  535. QIC-11    4 tracks
  536. X
  537. QIC-24    9 tracks. 60MB with DC600A tape.
  538. X    Tracks 0-3  are READ-compatible with the 4 tracks of QIC-11
  539. X
  540. QIC-120    15 (??) tracks [see below] 120MB with DC6150 tape.
  541. X    Tracks 0-3  are READ-compatible with the 4 tracks of QIC-11
  542. X    Tracks 0-8  are READ-compatible with the 9 tracks of QIC-24
  543. X
  544. HP    16 tracks.  Pre-formatted from H-P and incompatible with everything.
  545. X
  546. QIC-150    18 tracks. 150MB with DC6150 tape; 250MB with DC6250 tape.
  547. X    Tracks 0-3  are READ-compatible with the  4 tracks of QIC-11
  548. X    Tracks 0-8  are READ-compatible with the  9 tracks of QIC-24
  549. X    Tracks 0-14 are READ-compatible with the 15 tracks of QIC-120
  550. X
  551. QIC-525    ?? tracks. 525MB with DC6525 tape.
  552. X    Tracks 0-8  are READ-compatible with the  9 tracks of QIC-24
  553. X    Tracks 0-14 are READ-compatible with the 15 tracks of QIC-120
  554. X    Tracks 0-17 are READ-compatible with the 18 tracks of QIC-150
  555. X
  556. NOTE that Sun publishes "A Tutorial on 1/4 Inch Tape Drives", Part Number
  557. X800-1315-02, which describes all the operational characteristics of such
  558. drives and graphically depicts the track layouts illustrating the WHY and
  559. HOW of the read compatibilities.
  560. X
  561. NOTE the QIC-150 drive can write 250MB using a longer tape (DC6250) analogous
  562. to the difference between C-90 and C-120 audio cassettes.
  563. X
  564. NOTE the QIC-525 drive is NOT read-compatible with QIC-11.
  565. X
  566. NOTE it wasn't made clear to me by Maynard (Archive's end-user and support
  567. organization) the "true" differences between QIC-120 and QIC-150 drives; it's
  568. either or both the number of tracks and/or the recording density, so take the
  569. X"15-tracks of QIC-120" with a grain of salt until someone else posts the
  570. definitive answer.
  571. X
  572. The newer drives are able to automatically sense the recording density and
  573. make internal adjustments for read-compatibility.
  574. X
  575. But, whew, the extra calendaring of the tape's surface and the exotic coating
  576. for the DC6525 media have pushed its list price (from Archive) up to $79 (this
  577. from a price list at UniForum in January 1992) per cartridge.
  578. X
  579. If you want the info direct from THE manufacturer:
  580. X
  581. X    uunet!maynhbd!info (OR) info@maynhbd.UUCP
  582. X    1-800-821-8782
  583. END_OF_FILE
  584. if test 2742 -ne `wc -c <'README.qic'`; then
  585.     echo shar: \"'README.qic'\" unpacked with wrong size!
  586. fi
  587. # end of 'README.qic'
  588. fi
  589. if test -f 'README.tzk10' -a "${1}" != "-c" ; then 
  590.   echo shar: Will not clobber existing file \"'README.tzk10'\"
  591. else
  592. echo shar: Extracting \"'README.tzk10'\" \(1657 characters\)
  593. sed "s/^X//" >'README.tzk10' <<'END_OF_FILE'
  594. X>[...]
  595. X>DEC now offers a 1/4" tape drive - TZK10, which can be used
  596. X>for backup, etc.  The tapes can hold up to 525Mb.  This is
  597. X>significantly more than SUN tape drives, but I heard that the
  598. X>drives are compatible, i.e. you can read SUN tapes on the TZK10 (tar).
  599. X>Is this true?  Also, does anyone know the type of tapes that hold
  600. X>up to 525Mb and their ballpark price.  I currently have a TK50 and
  601. X>would like to move to something with more capacity and not too much $$.
  602. X>[...]
  603. X
  604. What you're describing sounds much like Archive's new ST525 series which
  605. use the QIC-525 "format" for 525MB.
  606. X
  607. If this IS, in fact, the situation, then the drive would be READ compatible
  608. with QIC-24 (60MB with DC600A tape, 9 tracks), QIC-120, and QIC-150(150MB with
  609. DC6150 tapes or 250MB with DC6250 tapes, 18 tracks) as used on Sun (and other)
  610. systems.
  611. X
  612. XFrom Archive's latest pricing sheet (just received last week from Maynard,
  613. Archive's end-user and support subsidiary):
  614. X
  615. X    90507    DC6250 media        $69.00
  616. X    90509    DC6525 media        $79.00
  617. X
  618. Those prices are their "US Retail."  Given that 3M DC6250 tapes are < $29
  619. locally (Silicon Valley: Fry's Electronics, a "consumer"-type store), you
  620. should be able to adjust the (expected) price for 3M DC6525 accordingly.
  621. X
  622. Archive's/Maynard's "US Retail" pricing for a "raw" ST525 drive is $1,528
  623. for their "ST525i internal 525MB SCSI drive kit" and $1,880 for their
  624. X"ST525e external 525MB SCSI drive kit."
  625. X
  626. I dunno; as much as I like Archive drives (over 20 of them here), that
  627. X"list" pricing is comparable to Exabyte EXB-8200 drives which can store
  628. X4x more data (2.3GB on P5-90 cartridges).
  629. X
  630. X
  631. X[ NOTE: prices quoted above are circa January 1992 ]
  632. END_OF_FILE
  633. if test 1657 -ne `wc -c <'README.tzk10'`; then
  634.     echo shar: \"'README.tzk10'\" unpacked with wrong size!
  635. fi
  636. # end of 'README.tzk10'
  637. fi
  638. if test -f 'tprobe.c' -a "${1}" != "-c" ; then 
  639.   echo shar: Will not clobber existing file \"'tprobe.c'\"
  640. else
  641. echo shar: Extracting \"'tprobe.c'\" \(11058 characters\)
  642. sed "s/^X//" >'tprobe.c' <<'END_OF_FILE'
  643. X/*
  644. X *    tprobe    - tape analyzer and duplicator
  645. X *
  646. X *    usage: tprobe  [ -b N ] [ -r | -w ]  /dev/tapedevice
  647. X *
  648. X *    "-b N" specifies a buffersize N other than the default 65536 bytes.
  649. X *
  650. X *    "-r" reads tapedevice and writes to stdout in a special form designed
  651. X *    to be piped to another tprobe process (even across a net) for writing
  652. X *    (i.e. duplicating) a tape onto a second tape drive.
  653. X *
  654. X *    "-w" reads stdin specially formatted by another tprobe process and
  655. X *    writes (i.e. duplicates) to tapedevice.
  656. X *
  657. X *    with no options (other than -b), tprobe reads tapedevice and writes
  658. X *    a brief analysis its findings to stdout.
  659. X *
  660. X *    Adding switch "-d" for the read-side permits a file (instead of a tape)
  661. X *    to be used for testing purposes; only works if compiled with -DDEBUG.
  662. X *
  663. X *    In general, the tape should be rewound before the first use of tprobe.
  664. X *    And the tapedevice "should" be the no-rewind on close device; for
  665. X *    example:
  666. X *
  667. X *        3B1:        /dev/rmt4
  668. X *        CTIX:        /dev/rmt4
  669. X *        SunOS 4.1.1:    /dev/nrst8
  670. X *
  671. X *    To rewind the tape (before and) after using tprobe:
  672. X *
  673. X *        3B1:        qrewind            (Thad's QIC-02 program)
  674. X *        CTIX:        tsioctl -c rewind /dev/rmt0
  675. X *        SunOS 4.1.1:    mt -f /dev/rst8 rewind
  676. X *
  677. X * REVISION HISTORY:
  678. X *
  679. X * 1991        ----    T.Floryan, original Kwik'N'Dirty program for own use
  680. X * 12-Feb-1992    V1.0    T.Floryan, release to Usenet after lint-fixing, etc.
  681. X *            Comments, suggestions, complaints to thad@btr.com
  682. X *
  683. X */
  684. X
  685. X#include <stdio.h>
  686. X#include <fcntl.h>
  687. X#include <errno.h>
  688. X#include <malloc.h>        /* added to suppress some of lint's whining */
  689. X
  690. extern    void    exit();
  691. extern    char    *strncpy();
  692. extern    int    open();
  693. extern    int    read();
  694. extern    int    write();
  695. extern    int    atoi();
  696. X
  697. void    probe_tape();
  698. void    read_tape();
  699. void    write_tape();
  700. void    usage();
  701. X
  702. typedef int        MWORD;
  703. typedef int        LWORD;    /* sizeof(int) must be sizeof(long) */
  704. typedef unsigned int    UWORD;
  705. X
  706. X#define STDIN    0        /* for read() device        */
  707. X#define STDOUT    1        /* for write() device        */
  708. X#define BLKSIZE    512        /* QIC tape physical blocking    */
  709. X#define TBUFSIZ    65536        /* default R/W buffer size    */
  710. X#define MINBUF    512        /* minimum R/W buffer size: 2^9    */
  711. X#define MAXBUF    1048576        /* maximum R/W buffer size: 2^20*/
  712. X#define UMASK    0666        /* needed for creat(2) usage    */
  713. X#define VERSKIP    4        /* skip displacement in version string */
  714. X
  715. X
  716. X/*    The following headers represent the control information passed
  717. X *    by a tape reader process to a tape writer process
  718. X */
  719. X#define HDRSIZE    10        /* size of a control header    */
  720. X
  721. X#define SCANSTR    "%8ld"
  722. X#define BUFHDR    "B%08ld\n"
  723. X#define DATHDR    "D%08ld\n"
  724. X#define SIZHDR    "S%08ld\n"
  725. X#define CLSHDR    "C00000000\n"
  726. X#define ERRHDR    "E00000000\n"
  727. X#define EOTHDR    "T00000000\n"
  728. X
  729. X
  730. X#define STATSTR    "SS%4d: %7ld blocks, %10ld bytes\n"
  731. X#define GTTLSTR    "GTotal: %7ld blocks, %10ld bytes\n"
  732. X
  733. X#ifdef DEBUG
  734. int debug = 0;
  735. char *cmd_options = "b:rwd?hH";
  736. X#else
  737. char *cmd_options = "b:rw?hH";
  738. X#endif
  739. X
  740. LWORD    tbufsize = TBUFSIZ;
  741. X
  742. char *version =
  743. X    "@(#)tprobe V1.0, 12-Feb-1992, Thad Floryan [ thad@btr.com ]";
  744. X
  745. char *usage_text[] = {
  746. X    "usage:    tprobe [-b N] [-r] tapedev [ | tprobe [-b N] -w tapedev ]",
  747. X    "where:    -b  sets buffer size to N (overriding the default 65536)",
  748. X    "    -r  specifies \"this\" process to be the tape reader",
  749. X    "    -w  designates \"this\" process to be a tape writer",
  750. X    0
  751. X};
  752. X
  753. X
  754. main(argc, argv)
  755. X    int    argc;
  756. X    char    *argv[];
  757. X{
  758. X    extern int     getopt();
  759. X    extern int     optind;
  760. X    extern char    *optarg;
  761. X
  762. X    MWORD    mode = 0;    /* 0=analysis, 1=read, 2=write    */
  763. X    MWORD    bufset = 0;    /* non-zero if "-b" specified */
  764. X    MWORD    optchr;
  765. X
  766. X
  767. X/*
  768. X *    Quick check to see if the program CAN run on this system due
  769. X *    to various assumptions.
  770. X */
  771. X    if (sizeof(int) != sizeof(long)) {
  772. X        (void) fprintf(stderr, "Program won't run on this system\n");
  773. X        exit(1);
  774. X    }
  775. X/*
  776. X *    Process options
  777. X */
  778. X
  779. X    while ( ( optchr = getopt( argc, argv, cmd_options ) ) != EOF ) {
  780. X
  781. X        switch (optchr) {
  782. X
  783. X        case 'b':    if (bufset != 0) {
  784. X                (void) fprintf(stderr,
  785. X                "%s: buffer size already set\n", argv[0]);
  786. X                usage();
  787. X            }
  788. X            ++bufset;
  789. X            tbufsize = atoi(optarg);
  790. X            if ((tbufsize < MINBUF) || (tbufsize > MAXBUF)) {
  791. X                (void) fprintf(stderr,
  792. X                "%s: unreasonable buffer size (%ld)\n",
  793. X                argv[0], tbufsize);
  794. X                usage();
  795. X            }
  796. X            if ((tbufsize % BLKSIZE) != 0) {
  797. X                (void) fprintf(stderr,
  798. X                "%s: buffer size (%ld) not multiple of 512\n",
  799. X                argv[0], tbufsize);
  800. X                usage();
  801. X            }
  802. X            break;
  803. X
  804. X        case 'r':    if (mode != 0) {
  805. X                (void) fprintf(stderr,"%s: too many options\n",
  806. X                argv[0]);
  807. X                usage();
  808. X            }
  809. X            mode = 1;
  810. X            break;
  811. X
  812. X        case 'w':    if (mode != 0) {
  813. X                (void) fprintf(stderr,"%s: too many options\n",
  814. X                argv[0]);
  815. X                usage();
  816. X            }
  817. X            mode = 2;
  818. X            break;
  819. X
  820. X#ifdef DEBUG
  821. X        case 'd':    if (mode != 1) {    /* must be spec'd after "-r" */
  822. X                usage();
  823. X            }
  824. X            ++debug;
  825. X            break;
  826. X#endif /* DEBUG */
  827. X
  828. X        case '?':
  829. X        case 'h':
  830. X        case 'H':
  831. X        default:    usage();
  832. X        }
  833. X    }
  834. X
  835. X    if ( optind == argc )
  836. X        usage();
  837. X
  838. X    if ( optind != (argc - 1)) {
  839. X        (void) fprintf(stderr,
  840. X        "%s: extraneous data on command line ``%s''\n",
  841. X        argv[0], argv[optind + 1]);
  842. X        usage();
  843. X    }
  844. X
  845. X    switch (mode) {
  846. X        case 0:    probe_tape(argv[optind]);
  847. X            break;
  848. X        case 1:    read_tape(argv[optind]);
  849. X            break;
  850. X        case 2:    write_tape(argv[optind]);
  851. X            break;
  852. X    }
  853. X
  854. X    return 0;
  855. X}
  856. X
  857. X
  858. void
  859. probe_tape(tapedev)
  860. X    char    *tapedev;
  861. X{
  862. X    LWORD    grandttl = 0;
  863. X    LWORD    numread  = 0;
  864. X    MWORD    ssno     = 0;
  865. X    MWORD    td       = 0;
  866. X    LWORD    ttlread;
  867. X
  868. X    char    *bptr;
  869. X    char    errmsg[200];
  870. X
  871. X
  872. X    bptr = (char *) malloc(tbufsize + 4);
  873. X
  874. X    while (td >= 0) {
  875. X
  876. X        if ( (td = open(tapedev, O_RDONLY, 0)) < 0) {
  877. X        (void) sprintf(errmsg, "Cannot open tape unit %s", tapedev);
  878. X        perror(errmsg);
  879. X        exit(1);
  880. X        }
  881. X
  882. X        ttlread = 0;
  883. X
  884. X        for (;;) {
  885. X        numread = read(td, bptr, (UWORD) tbufsize);
  886. X        if (numread != tbufsize) {
  887. X            if (numread > 0) {
  888. X                ttlread += numread;
  889. X            }
  890. X            break;
  891. X        }
  892. X        ttlread += numread;
  893. X        }
  894. X
  895. X        (void) printf(STATSTR, ssno, ttlread/BLKSIZE, ttlread);
  896. X        ++ssno;
  897. X        grandttl += ttlread;
  898. X
  899. X        (void) close(td);
  900. X
  901. X        if (numread < 0) {
  902. X        (void) sprintf(errmsg, "Read error = %d", errno);
  903. X        perror(errmsg);
  904. X        td = -1;
  905. X        break;
  906. X        }
  907. X        if ((ttlread == 0) || (numread == 0)) {
  908. X        (void) printf("End of tape\n");
  909. X        td = -1;
  910. X        break;
  911. X        }
  912. X    }
  913. X
  914. X    (void) free(bptr);
  915. X
  916. X    (void) printf(GTTLSTR, grandttl/BLKSIZE, grandttl);
  917. X}
  918. X
  919. X
  920. void
  921. read_tape(tapedev)
  922. X    char    *tapedev;
  923. X{
  924. X    LWORD    grandttl = 0;
  925. X    LWORD    numread  = 0;
  926. X    MWORD    td       = 0;
  927. X    LWORD    ttlread;
  928. X
  929. X    char    *bptr;
  930. X    char    *dataptr;
  931. X    char    errmsg[200];
  932. X    char    header[HDRSIZE + 2];
  933. X
  934. X
  935. X    bptr = (char *) malloc(tbufsize + HDRSIZE + 2);
  936. X
  937. X    if (bptr == NULL) {
  938. X        (void) sprintf(errmsg,
  939. X            "Cannot allocate requested buffer size: %ld",
  940. X            tbufsize);
  941. X        perror(errmsg);
  942. X        exit(1);
  943. X    }
  944. X
  945. X    dataptr = bptr + HDRSIZE;
  946. X
  947. X    (void) sprintf(header, BUFHDR, tbufsize);
  948. X    (void) write(STDOUT, header, HDRSIZE);
  949. X
  950. X    while (td >= 0) {
  951. X
  952. X        if ( (td = open(tapedev, O_RDONLY, 0)) < 0) {
  953. X        (void) sprintf(errmsg, "Cannot open tape unit %s", tapedev);
  954. X        perror(errmsg);
  955. X        exit(1);
  956. X        }
  957. X
  958. X        ttlread = 0;
  959. X
  960. X        for (;;) {
  961. X        numread = read(td, dataptr, (UWORD) tbufsize);
  962. X        if (numread != tbufsize) {
  963. X            if (numread > 0) {
  964. X                ttlread += numread;
  965. X                (void) sprintf(header, DATHDR, numread);
  966. X                (void) strncpy(bptr, header, HDRSIZE);
  967. X                (void) write(STDOUT, bptr,
  968. X                     (UWORD) (numread + HDRSIZE));
  969. X            }
  970. X            break;
  971. X        }
  972. X        ttlread += numread;
  973. X        (void) sprintf(header, DATHDR, numread);
  974. X        (void) strncpy(bptr, header, HDRSIZE);
  975. X        (void) write(STDOUT, bptr, (UWORD) (numread + HDRSIZE));
  976. X        }
  977. X        grandttl += ttlread;
  978. X
  979. X        (void) close(td);
  980. X        (void) write(STDOUT, CLSHDR, HDRSIZE); /* close */
  981. X
  982. X#ifdef DEBUG
  983. X        if (debug)
  984. X        td = (-1);
  985. X#endif /* ifdef DEBUG */
  986. X
  987. X        if (numread < 0) {
  988. X        (void) write(STDOUT, ERRHDR, HDRSIZE); /* tape error */
  989. X        td = -1;
  990. X        break;
  991. X        }
  992. X        if ((ttlread == 0) || (numread == 0)) {
  993. X        (void) write(STDOUT, EOTHDR, HDRSIZE); /* end of tape */
  994. X        td = -1;
  995. X        break;
  996. X        }
  997. X    }
  998. X    (void) sprintf(header, SIZHDR, grandttl/BLKSIZE);
  999. X    (void) write(STDOUT, header, HDRSIZE);
  1000. X
  1001. X    (void) free(bptr);
  1002. X}
  1003. X
  1004. X
  1005. void
  1006. write_tape(tapedev)
  1007. X    char    *tapedev;
  1008. X{
  1009. X    LWORD    grandttl = 0;
  1010. X    LWORD    hdrvalue;
  1011. X    LWORD    numleft;
  1012. X    LWORD    numread  = 0;
  1013. X    LWORD    numwrote = 0;
  1014. X    MWORD    process  = 1;
  1015. X    MWORD    satis    = 0;
  1016. X    MWORD    td       = -1;
  1017. X    LWORD    ttlread  = 0;
  1018. X
  1019. X    char    *bptr;
  1020. X    char    *dataptr;
  1021. X    char    *readptr;
  1022. X    char    errmsg[200];
  1023. X
  1024. X
  1025. X
  1026. X    bptr = (char *) malloc(tbufsize + HDRSIZE + 2);
  1027. X
  1028. X    if (bptr == NULL) {
  1029. X        (void) sprintf(errmsg,
  1030. X            "Cannot allocate requested buffer size: %ld",
  1031. X            tbufsize);
  1032. X        perror(errmsg);
  1033. X        exit(1);
  1034. X    }
  1035. X
  1036. X    numread = read(STDIN, bptr, HDRSIZE);
  1037. X
  1038. X    if (numread != HDRSIZE) {
  1039. X        (void) sprintf(errmsg,
  1040. X            "We gotta problem; header size wrong: %ld",
  1041. X            numread);
  1042. X        perror(errmsg);
  1043. X        exit(1);
  1044. X    }
  1045. X
  1046. X    if (*bptr == 'B') {
  1047. X        (void) sscanf(bptr + 1, SCANSTR, &hdrvalue);
  1048. X        if (hdrvalue != tbufsize) {
  1049. X        (void) sprintf(errmsg, "Buffer disagreement: R=%ld, W=%ld",
  1050. X            hdrvalue, tbufsize);
  1051. X        perror(errmsg);
  1052. X        exit(1);
  1053. X        }
  1054. X    } else {
  1055. X        perror("First header not ``B''");
  1056. X        exit(1);
  1057. X    }
  1058. X
  1059. X    dataptr = bptr + HDRSIZE;
  1060. X
  1061. X    while (process != 0) {
  1062. X
  1063. X        numread = read(STDIN, bptr, HDRSIZE);
  1064. X
  1065. X        if (numread != HDRSIZE) {
  1066. X        (void) sprintf(errmsg,
  1067. X                "We gotta problem; header size wrong: %ld",
  1068. X                numread);
  1069. X        perror(errmsg);
  1070. X        exit(1);
  1071. X        }
  1072. X        (void) sscanf(bptr + 1, SCANSTR, &hdrvalue);
  1073. X
  1074. X        switch (*bptr) {
  1075. X        case 'D':    if (td < 0) {
  1076. X                if ( (td = creat(tapedev, UMASK)) < 0) {
  1077. X                (void) sprintf(errmsg,
  1078. X                           "Cannot open tape unit %s",
  1079. X                           tapedev);
  1080. X                perror(errmsg);
  1081. X                process = 0;
  1082. X                }
  1083. X            }
  1084. X
  1085. X            numleft = hdrvalue;
  1086. X            readptr = dataptr;
  1087. X            satis   = 0;
  1088. X
  1089. X            while (satis == 0) {
  1090. X                numread  = read(STDIN, readptr, (UWORD) numleft);
  1091. X                if (numread != numleft) {
  1092. X                numleft -= numread;
  1093. X                readptr += numread;
  1094. X                ttlread += numread;
  1095. X                } else {
  1096. X                ttlread += numread;
  1097. X                ++satis;
  1098. X                }
  1099. X            }
  1100. X
  1101. X            numwrote = write(td, dataptr, (UWORD) hdrvalue);
  1102. X            if (numwrote != hdrvalue) {
  1103. X                (void) fprintf(stderr,
  1104. X                "Tape size error: %ld should be %ld\n",
  1105. X                numwrote, hdrvalue);
  1106. X                (void) close(td);
  1107. X                process = 0;
  1108. X            } else {
  1109. X                grandttl += numwrote;
  1110. X            }
  1111. X            break;
  1112. X        case 'C':    if (td < 0) {
  1113. X                if ( (td = creat(tapedev, UMASK)) < 0) {
  1114. X                (void) sprintf(errmsg,
  1115. X                           "Cannot open tape unit %s",
  1116. X                           tapedev);
  1117. X                perror(errmsg);
  1118. X                process = 0;
  1119. X                }
  1120. X            }
  1121. X            (void) close(td);
  1122. X            td = -1;
  1123. X            break;
  1124. X        case 'T':    process = 0;    /* Remote End-Of-Tape; all done */
  1125. X            break;
  1126. X        case 'S':    if (hdrvalue != (grandttl/BLKSIZE)) {
  1127. X                (void) fprintf(stderr,
  1128. X                "Grand total mismatch: %ld should be %ld\n",
  1129. X                grandttl, ttlread);
  1130. X            }
  1131. X            td = -1;
  1132. X            process = 0;
  1133. X            break;
  1134. X        case 'E':    (void) fprintf(stderr, "Remote error detected\n");
  1135. X            break;
  1136. X        default:    (void) fprintf(stderr, "Header error: %c\n", *bptr);
  1137. X            if (td >= 0) {
  1138. X                (void) close(td);
  1139. X                td = -1;
  1140. X            }
  1141. X            process = 0;
  1142. X        }
  1143. X    }
  1144. X
  1145. X    (void) free(bptr);
  1146. X}
  1147. X
  1148. void
  1149. usage()
  1150. X{
  1151. X    int    ndx = 0;
  1152. X
  1153. X    while ( usage_text[ndx] != 0 ) {
  1154. X
  1155. X        (void) fprintf( stderr, "%s\n", usage_text[ndx++] );
  1156. X    }
  1157. X    (void) fprintf( stderr, "%s\n", version + VERSKIP );
  1158. X    exit(1);
  1159. X}
  1160. END_OF_FILE
  1161. if test 11058 -ne `wc -c <'tprobe.c'`; then
  1162.     echo shar: \"'tprobe.c'\" unpacked with wrong size!
  1163. fi
  1164. # end of 'tprobe.c'
  1165. fi
  1166. if test -f 'tprobe.man' -a "${1}" != "-c" ; then 
  1167.   echo shar: Will not clobber existing file \"'tprobe.man'\"
  1168. else
  1169. echo shar: Extracting \"'tprobe.man'\" \(9992 characters\)
  1170. sed "s/^X//" >'tprobe.man' <<'END_OF_FILE'
  1171. X.TH TPROBE L "12-Feb-1992"
  1172. X.\"@(#)tprobe.man V1.0, 12-Feb-1992, Thad Floryan [ thad@btr.com ]
  1173. X.SH NAME
  1174. tprobe \- tape saveset analyzer and duplicator
  1175. X.SH SYNOPSIS
  1176. tprobe [-b
  1177. X.I n]
  1178. X.I /dev/NRTD
  1179. X.LP
  1180. tprobe [-b
  1181. X.I n]
  1182. X-r
  1183. X.I /dev/NRTD0
  1184. X| tprobe [-b
  1185. X.I n]
  1186. X-w
  1187. X.I /dev/NRTD1
  1188. X.LP
  1189. X.I [host]
  1190. tprobe [-b
  1191. X.I n]
  1192. X-r
  1193. X.I /dev/NRTD0
  1194. X|
  1195. X.ti +23
  1196. X.I [host]
  1197. tprobe [-b
  1198. X.I n]
  1199. X-w
  1200. X.I /dev/NRTD1
  1201. X.sp
  1202. X.ta +0.3i
  1203. X.in +0.3i
  1204. X.ti -0.3i
  1205. X\(bu
  1206. X.I    ``/dev/NRTDn''
  1207. is typically the "no-rewind-on-close" tape device [See
  1208. X.I OPERATING NOTES]
  1209. X.sp
  1210. X.ti -0.3i
  1211. X\(bu
  1212. X.I    ``host''
  1213. is the system-dependent clause signifying remote tape
  1214. operation [See
  1215. X.I OPERATING NOTES]
  1216. X.in -0.3i
  1217. X.SH DESCRIPTION
  1218. X.I tprobe
  1219. is a utility which succeeds duplicating boot/install tapes that are not
  1220. easily copied by other means.  One of its features is operation over a
  1221. pipeline utilizing multiple tape drives whereever they exist on a network
  1222. or a system.
  1223. X.sp
  1224. X.I tprobe
  1225. can also (indirectly) perform media conversions, though the
  1226. only verified conversions have been from QIC-120 and QIC-150 to QIC-24
  1227. and vice versa; there is no inherent limitation, so other conversions
  1228. are definitely possible.
  1229. X.sp
  1230. Another feature is that a tape may be processed without disk space being
  1231. usurped for intermediate staging.  Thus, a full 150MB tape can be duplicated
  1232. even if one's system has only, say, 20MB free.
  1233. X.sp
  1234. X.I tprobe's
  1235. basic operation reveals a tape's existing saveset layout and stored capacity,
  1236. and requires only a single tape drive for this analysis.
  1237. X.sp
  1238. X.I tprobe
  1239. was intended to be a one-time-only program, but it is useful in its present
  1240. incarnation and does solve immediate and present problems.
  1241. XFor
  1242. X.I tprobe's
  1243. raison d'etre and anecdotes, see the
  1244. X.I BACKGROUND
  1245. section.
  1246. X.SH OPTIONS
  1247. X.TP 8
  1248. X.I -b
  1249. Specifies the buffering size to help maintain streaming operation.  The
  1250. default is 65536 bytes.  A value must be stated in bytes; no abbreviations
  1251. are recognized in this version.  The buffer must be the same size at both
  1252. ends of the pipe else the "write" process will diagnose the error and abort.
  1253. X.sp
  1254. XFor 8mm EXB-8200 drives, 262144 (256KB) appears to be an optimal size.
  1255. XExperiment!
  1256. X.TP 8
  1257. X.I -r
  1258. Designates "this" process to be the tape reader and head of the pipeline.
  1259. X.TP 8
  1260. X.I -w
  1261. Designates "this" process to be a tape writer and a tail of the pipeline
  1262. X(see
  1263. X.IB tee(1)).
  1264. X.SH OPERATING NOTES
  1265. With no options (other than -b),
  1266. X.I tprobe
  1267. reads a tape and writes a brief analysis of its findings to stdout.
  1268. X.sp
  1269. The tape device should be a "no-rewind-on-close" device per the following
  1270. examples:
  1271. X.sp
  1272. X.nf
  1273. X.RS
  1274. X/dev/nrst8      SunOS 4.1.1 with a SCSI tape
  1275. X.br
  1276. X/dev/rmt4       CTIX or 3B1 with a QIC-02 drive
  1277. X.RE
  1278. X.fi
  1279. X.sp
  1280. In general, a tape should be rewound before use.
  1281. Several examples of rewinding a tape on some systems are:
  1282. X.sp
  1283. X.nf
  1284. X.RS
  1285. SunOS 4.1.1:    mt -f /dev/rst8 rewind
  1286. X.br
  1287. CTIX:           tsioctl -c rewind /dev/rmt0
  1288. X.br
  1289. X3B1:            qrewind   # (Thad's QIC-02 program)
  1290. X.RE
  1291. X.fi
  1292. X.sp
  1293. The "[host]" as shown in the
  1294. X.I SYNOPSIS
  1295. takes the forms:
  1296. X.sp
  1297. X.RS
  1298. X[rsh | remsh | rcmd] hostname
  1299. X.RE
  1300. X.sp
  1301. as appropriate for the system on which the command is issued.
  1302. Specification simply as "hostname" is permitted if /usr/hosts/MAKEHOSTS has
  1303. been previously executed and "/usr/hosts" is present in $PATH.
  1304. X.sp
  1305. Note that for remote system operation, the /etc/hosts.equiv and/or
  1306. the ~/.rhosts authentication file(s) must be previously established.
  1307. X.I tprobe
  1308. must exist within the directories specified in all one's $PATH's, especially
  1309. so for remote operation.
  1310. X.sp
  1311. Note that not all systems' and/or applications' install tapes have two
  1312. consecutive file-marks to designate end-of-tape;
  1313. X.I tprobe
  1314. will still correctly duplicate such tapes.
  1315. X.SH EXAMPLES
  1316. To duplicate a tape mounted on a remote Sun named "faraway" onto the local
  1317. Sun, assuring that all tapes are rewound before and after the operation:
  1318. X.sp
  1319. X.in +0.5i
  1320. rsh faraway mt -f /dev/rst8 rewind
  1321. X.br
  1322. mt -f /dev/rst8 rewind
  1323. X.br
  1324. rsh faraway tprobe -r /dev/nrst8 | tprobe -w /dev/nrst8
  1325. X.br
  1326. rsh faraway mt -f /dev/rst8 rewind
  1327. X.br
  1328. mt -f /dev/rst8 rewind
  1329. X.in -0.5i
  1330. X.sp
  1331. To duplicate a tape on a local Sun having two tape drives:
  1332. X.sp
  1333. X.ti +0.5i
  1334. tprobe -r /dev/nrst8 | tprobe -w /dev/nrst9
  1335. X.sp
  1336. To duplicate a tape between two remote Sun systems ("proxy" mode)
  1337. where both remote systems have link entries in /usr/hosts:
  1338. X.sp
  1339. X.ti +0.5i
  1340. host1 tprobe -r /dev/nrst8 | host2 tprobe -w /dev/nrst8
  1341. X.SH BACKGROUND
  1342. It appears there's confusion surrounding the "difficulty" making [legally
  1343. permissible] backup copies of one's boot/install tapes to assure continued
  1344. operation of one's system(s).
  1345. X.sp
  1346. Many people's attempts with
  1347. X.IB dd(1),
  1348. X.IB cat(1),
  1349. etc. have failed (even though such
  1350. attempts have worked duplicating, say, "pure" tar- or cpio-written tapes).
  1351. X.sp
  1352. The reason for the difficulty is due to the varying record sizes typically
  1353. found on boot/install tapes.  In other words, it's difficult to specify an
  1354. X.I efficient
  1355. least-common-denominator (LCD) block/record size to
  1356. X.IB dd(1)
  1357. for a "raw" duplication [ although an intelligent shell script can get around
  1358. this, using
  1359. X.IB dd(1)'s
  1360. stats ]; note programs such as
  1361. X.IB cat(1)
  1362. tend to assume constantly-fixed record sizes.
  1363. X.sp
  1364. XFor the record, the LCD for QIC tapes is 512-bytes, which is the physical
  1365. blocking size.  But if you attempt to use that size, your data will be
  1366. X``Shoe Shined'' into oblivion!  :-)
  1367. X.sp
  1368. Three representative samplings of the beginning layout of boot tapes
  1369. analyzed by
  1370. X.I tprobe
  1371. for a Sun, a CTIX, and an AT&T boot/install tape are shown below.
  1372. X"SS n" is the save-set number (a save-set being the data
  1373. between file-marks on a tape).
  1374. X"blocks" are the 512-byte physical records as written on QIC tapes.
  1375. These examples show
  1376. X.I tprobe
  1377. operation from a Sun system console:
  1378. X.sp
  1379. X.RS
  1380. X% # SunOS 4.1.1 Sun-3 SUNBIN, tape 1 of 2
  1381. X.br
  1382. X% #
  1383. X.br
  1384. X% tprobe /dev/nrst8
  1385. X.br
  1386. SS   0:     64 blocks,     32768 bytes
  1387. X.br
  1388. SS   1:     16 blocks,      8192 bytes
  1389. X.br
  1390. SS   2:   1425 blocks,    729600 bytes
  1391. X.br
  1392. SS   3:   3200 blocks,   1638400 bytes
  1393. X.br
  1394. SS   4:  14000 blocks,   7168000 bytes
  1395. X.br
  1396. SS   5:    146 blocks,     74752 bytes
  1397. X.br
  1398. SS   6:  22674 blocks,  11609088 bytes
  1399. X.br
  1400. X[...]
  1401. X.sp
  1402. X% # CTIX 6.2 MightyFrame RUNTIME/INSTALL
  1403. X.br
  1404. X% #
  1405. X.br
  1406. X% tprobe /dev/nrst8
  1407. X.br
  1408. SS   0:    128 blocks,     65536 bytes
  1409. X.br
  1410. SS   1:    768 blocks,    393216 bytes
  1411. X.br
  1412. SS   2:   1888 blocks,    966656 bytes
  1413. X.br
  1414. SS   3:   2176 blocks,   1114112 bytes
  1415. X.br
  1416. SS   4:    320 blocks,    163840 bytes
  1417. X.br
  1418. SS   5:    384 blocks,    196608 bytes
  1419. X.br
  1420. SS   6:    256 blocks,    131072 bytes
  1421. X.br
  1422. X[...]
  1423. X.sp
  1424. X% # AT&T 3B2 SVR3.2.2 LOAD 19 OS & UTILS
  1425. X.br
  1426. X% #
  1427. X.br
  1428. X% tprobe /dev/nrst8
  1429. X.br
  1430. SS   0:   4099 blocks,   2098688 bytes
  1431. X.br
  1432. SS   1:   8610 blocks,   4408320 bytes
  1433. X.br
  1434. SS   2:      3 blocks,      1536 bytes
  1435. X.br
  1436. SS   3:   1422 blocks,    728064 bytes
  1437. X.br
  1438. SS   4:   1422 blocks,    728064 bytes
  1439. X.br
  1440. SS   5:   1422 blocks,    728064 bytes
  1441. X.br
  1442. SS   6:   1422 blocks,    728064 bytes
  1443. X.br
  1444. X[...]
  1445. X.RE
  1446. X.sp
  1447. X.I tprobe
  1448. was conceived when it was realized the SunOS 4.1.1 Sun-3 SUNBIN install tape
  1449. was to be the last ever from Sun for that architecture and that a backup was
  1450. essential to prevent disaster if the tape should be "bad" when most needed
  1451. to boot into a miniroot.
  1452. X.sp
  1453. X.I tprobe's
  1454. main purpose is to read one tape and write to another over Ethernet since
  1455. systems typically possess only one tape drive.
  1456. X.sp
  1457. X.I tprobe
  1458. duplicates tapes
  1459. X.I without consuming disk space
  1460. and, as a side benefit,
  1461. indirectly converts tape media between QIC-11/-24/-120/-150/-525 within
  1462. the storage capability of the output tape.
  1463. X.sp
  1464. The first test of
  1465. X.I tprobe
  1466. was the duplication of a SunOS install tape by reading the original on a 3B1
  1467. while writing the duplicate on a CT MightyFrame, then booting and
  1468. suninstall'ing from the duplicated tape on a Sun-3/60.
  1469. X.sp
  1470. Systems on which
  1471. X.I tprobe
  1472. has been installed and tested include 3B1, CTIX, Sun-3, Sun-4, and an AT&T 3B2.
  1473. X.SH AUTHOR
  1474. Thad Floryan
  1475. X.br
  1476. thad@btr.com (OR) {decwrl,mips,fernwood}!btr!thad
  1477. X.br
  1478. X.ne 3
  1479. X.SH VERSION
  1480. The present release of
  1481. X.I tprobe
  1482. is 1.0, dated 12-Feb-1992.
  1483. X.SH FUTURE DEVELOPMENT
  1484. X.ta +0.3i
  1485. X.in +0.3i
  1486. X.ti -0.3i
  1487. X\(bu    Add double buffering (for speed) along the lines of the
  1488. X.IB ddd(1)
  1489. program posted to comp.sources.unix/Volume15 by Tapani Lindgren, with two
  1490. child processes alternating pipe I/O with tape I/O.
  1491. X.sp
  1492. X.ti -0.3i
  1493. X\(bu    Devise a method of truly copying, say, a full 150MB tape onto
  1494. three 60MB tapes.  Would require more tape "smarts" to detect EOM (end
  1495. of media) and prompting for media change.  Not certain of feasibility
  1496. due to unknown source media's genesis (e.g. tar, cpio, whatever).
  1497. X.SH CAVEATS
  1498. X.PP
  1499. This program has functioned satisfactorily for the author, but no guarantees
  1500. or warrantees are given or implied that
  1501. X.I tprobe
  1502. will be suitable for your applications; this software is distributed
  1503. X.I AS IS.
  1504. X.sp
  1505. Any error detection and correction, such as may exist, is limited to that
  1506. available with the standard system I/O calls
  1507. X.IB open(2),
  1508. X.IB read(2)
  1509. and
  1510. X.IB write(2).
  1511. X.sp
  1512. By installing
  1513. X.I tprobe
  1514. on your system, you assume all risks and liabilities for its use.
  1515. X.SH BUGS
  1516. X.PP
  1517. Internal counters and statistics are kept as "long" data;
  1518. newer tape drives whose media capacity exceeds a system's ability to
  1519. retain a tally that large will definitely be troublesome.
  1520. X.sp
  1521. X.I tprobe
  1522. assumes the user has specified a tape device as its object; anything else
  1523. as
  1524. X.I tprobe's
  1525. object will probably trigger unknown and bizarre side-effects.
  1526. X.SH SEE ALSO
  1527. All pertinent tape, mt, mtio, tsioctl, etc. commands as appropriate for
  1528. your system(s) to ascertain the correct tape device syntax and semantics
  1529. for your drive(s) operated per "no-rewind-on-close."
  1530. X.sp
  1531. The
  1532. X.IB copytape(1)
  1533. program by David S. Hayes (April 1985/July 1986) is also
  1534. worthy of your consideration.   On a system with one tape drive, it
  1535. creates a specially-formatted intermediate file whose size reflects the
  1536. tape's contents; on a two-tape-drive system it can duplicate a tape in
  1537. one pass.  Because of its intermediate file,
  1538. X.IB copytape(1)
  1539. easily produces multiple copies after a single read of the master tape.
  1540. END_OF_FILE
  1541. if test 9992 -ne `wc -c <'tprobe.man'`; then
  1542.     echo shar: \"'tprobe.man'\" unpacked with wrong size!
  1543. fi
  1544. # end of 'tprobe.man'
  1545. fi
  1546. echo shar: End of archive 1 \(of 1\).
  1547. cp /dev/null ark1isdone
  1548. MISSING=""
  1549. for I in 1 ; do
  1550.     if test ! -f ark${I}isdone ; then
  1551.     MISSING="${MISSING} ${I}"
  1552.     fi
  1553. done
  1554. if test "${MISSING}" = "" ; then
  1555.     echo You have the archive.
  1556.     rm -f ark[1-9]isdone
  1557. else
  1558.     echo You still need to unpack the following archives:
  1559.     echo "        " ${MISSING}
  1560. fi
  1561. ##  End of shell archive.
  1562. exit 0
  1563.