开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
readcd.c
资源名称：cdrecord-1.8.tar.gz　[点击查看]
上传用户：xiejiait
上传日期：2007-01-06
资源大小：881k
文件大小：18k
源码类别：

SCSI/ASPI

开发平台：

MultiPlatform

readcd.c：源码内容
  1. /* @(#)readcd.c 1.10 00/01/17 Copyright 1987 J. Schilling */
  2. #ifndef lint
  3. static char sccsid[] =
  4. "@(#)readcd.c 1.10 00/01/17 Copyright 1987 J. Schilling";
  5. #endif
  6. /*
  7.  * Skeleton for the use of the scg genearal SCSI - driver
  8.  *
  9.  * Copyright (c) 1987 J. Schilling
  10.  */
  11. /*
  12.  * This program is free software; you can redistribute it and/or modify
  13.  * it under the terms of the GNU General Public License as published by
  14.  * the Free Software Foundation; either version 2, or (at your option)
  15.  * any later version.
  16.  *
  17.  * This program is distributed in the hope that it will be useful,
  18.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20.  * GNU General Public License for more details.
  21.  *
  22.  * You should have received a copy of the GNU General Public License
  23.  * along with this program; see the file COPYING.  If not, write to
  24.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  25.  */
  27. #include <mconfig.h>
  28. #include <stdio.h>
  29. #include <standard.h>
  30. #include <unixstd.h>
  31. #include <stdxlib.h>
  32. #include <strdefs.h>
  33. #include <fctldefs.h>
  34. #include <timedefs.h>
  36. #include <scg/scgcmd.h>
  37. #include <scg/scsireg.h>
  38. #include <scg/scsitransp.h>
  40. #include "cdrecord.h"
  42. char cdr_version[] = "1.8";
  44. extern BOOL getlong __PR((char *, long *, long, long));
  45. extern BOOL getint __PR((char *, int *, int, int));
  47. typedef struct {
  48. long start;
  49. long end;
  50. char *name;
  51. } parm_t;
  53. EXPORT BOOL cvt_cyls __PR((void));
  54. EXPORT BOOL cvt_bcyls __PR((void));
  55. EXPORT void print_defect_list __PR((void));
  56. LOCAL void usage __PR((int ret));
  57. EXPORT int main __PR((int ac, char **av));
  58. LOCAL int prstats __PR((void));
  59. LOCAL void dorw __PR((SCSI *scgp, char *filename, char* sectors));
  60. LOCAL void doit __PR((SCSI *scgp));
  61. #ifdef used
  62. LOCAL int read_scsi_g1 __PR((SCSI *scgp, caddr_t bp, long addr, int cnt));
  63. #endif
  65. EXPORT int write_scsi __PR((SCSI *scgp, caddr_t bp, long addr, int cnt));
  66. EXPORT int write_g0 __PR((SCSI *scgp, caddr_t bp, long addr, int cnt));
  67. EXPORT int write_g1 __PR((SCSI *scgp, caddr_t bp, long addr, int cnt));
  69. #ifdef used
  70. LOCAL void Xrequest_sense __PR((SCSI *scgp));
  71. #endif
  72. LOCAL int rrr __PR((SCSI *scgp, long addr, long cnt));
  73. LOCAL void read_disk __PR((SCSI *scgp, parm_t *parmp));
  74. LOCAL void write_disk __PR((SCSI *scgp, parm_t *parmp));
  75. LOCAL int choice __PR((int n));
  76. LOCAL void ra __PR((SCSI *scgp));
  78. #ifndef TRUE
  79. # define TRUE 1
  80. # define FALSE 0
  81. #endif
  83. struct timeval starttime;
  84. struct timeval stoptime;
  86. char *Sbuf;
  87. long Sbufsize;
  89. int help;
  90. BOOL is_suid;
  91. BOOL is_cdrom;
  92. BOOL do_write;
  94. struct scsi_format_data fmt;
  96. /*XXX*/EXPORT BOOL cvt_cyls(){ return (FALSE);}
  97. /*XXX*/EXPORT BOOL cvt_bcyls(){ return (FALSE);}
  98. /*XXX*/EXPORT void print_defect_list(){}
  100. LOCAL void
  101. usage(ret)
  102. int ret;
  103. {
  104. error("Usage:treadcd [options]n");
  105. error("options:n");
  106. error("t-version print version information and exitn");
  107. error("tdev=target SCSI target to usen");
  108. error("tf=filename Name of file to read/writen");
  109. error("tsectors=range Range of sectors to read/writen");
  110. error("t-w Switch to write moden");
  111. error("tkdebug=#,kd=#tdo Kernel debuggingn");
  112. error("t-V increment SCSI command transport verbose level by onen");
  113. error("t-silent,-stdo not print status of erreneous commandsn");
  114. exit(ret);
  115. }
  117. char opts[]   = "kdebug#,kd#,Verbose,V+,silent,s,debug,help,h,version,dev*,f*,sectors*,w";
  119. EXPORT int
  120. main(ac, av)
  121. int ac;
  122. char *av[];
  123. {
  124. char *dev = NULL;
  125. int fcount;
  126. int cac;
  127. char * const *cav;
  128. int scsibus = 0;
  129. int target = 0;
  130. int lun = 0;
  131. int silent = 0;
  132. int verbose = 0;
  133. int lverbose= 0;
  134. int kdebug = 0;
  135. int debug = 0;
  136. int pversion = 0;
  137. SCSI *scgp;
  138. char *filename= NULL;
  139. char *sectors = NULL;
  141. save_args(ac, av);
  143. cac = --ac;
  144. cav = ++av;
  146. if(getallargs(&cac, &cav, opts,
  147. &kdebug, &kdebug,
  148. &verbose, &verbose,
  149. &silent, &silent, &debug,
  150. &help, &help, &pversion,
  151. &dev, &filename, &sectors, &do_write) < 0) {
  152. errmsgno(EX_BAD, "Bad flag: %s.n", cav[0]);
  153. usage(EX_BAD);
  154. }
  155. if (help)
  156. usage(0);
  157. if (pversion) {
  158. printf("readcd %s (%s-%s-%s) Copyright (C) 1987, 1995-2000 J鰎g Schillingn",
  159. cdr_version,
  160. HOST_CPU, HOST_VENDOR, HOST_OS);
  161. exit(0);
  162. }
  164. fcount = 0;
  165. cac = ac;
  166. cav = av;
  168. while(getfiles(&cac, &cav, opts) > 0) {
  169. fcount++;
  170. if (fcount == 1) {
  171. if (*astoi(cav[0], &target) != '') {
  172. errmsgno(EX_BAD,
  173. "Target '%s' is not a Number.n",
  174. cav[0]);
  175. usage(EX_BAD);
  176. /* NOTREACHED */
  177. }
  178. }
  179. if (fcount == 2) {
  180. if (*astoi(cav[0], &lun) != '') {
  181. errmsgno(EX_BAD,
  182. "Lun is '%s' not a Number.n",
  183. cav[0]);
  184. usage(EX_BAD);
  185. /* NOTREACHED */
  186. }
  187. }
  188. if (fcount == 3) {
  189. if (*astoi(cav[0], &scsibus) != '') {
  190. errmsgno(EX_BAD,
  191. "Scsibus is '%s' not a Number.n",
  192. cav[0]);
  193. usage(EX_BAD);
  194. /* NOTREACHED */
  195. }
  196. } else {
  197. scsibus = 0;
  198. }
  199. cac--;
  200. cav++;
  201. }
  202. /*error("dev: '%s'n", dev);*/
  204. if (dev) {
  205. char errstr[80];
  207. if ((scgp = open_scsi(dev, errstr, sizeof(errstr), debug, lverbose)) == (SCSI *)0)
  208. comerr("%s%sCannot open SCSI driver.n", errstr, errstr[0]?". ":"");
  209. /* scsi_settimeout(scgp, timeout);*/
  210. } else {
  211. if (scsibus == -1 && target >= 0 && lun >= 0)
  212. scsibus = 0;
  214. scgp = scsi_smalloc();
  215. scgp->debug = debug;
  216. scgp->kdebug = kdebug;
  217. scgp->scsibus = scsibus;
  218. scgp->target = target;
  219. scgp->lun = lun;
  221. if (!scsi_open(scgp, NULL, scsibus, target, lun))
  222. comerr("Cannot open SCSI driver.n");
  224. scgp->scsibus = scsibus;
  225. scgp->target = target;
  226. scgp->lun = lun;
  227. }
  228. scgp->silent = silent;
  229. scgp->verbose = verbose;
  230. scgp->debug = debug;
  231. scgp->kdebug = kdebug;
  233. Sbufsize = scsi_bufsize(scgp, 256*1024L);
  234. if ((Sbuf = scsi_getbuf(scgp, Sbufsize)) == NULL)
  235. comerr("Cannot get SCSI I/O buffer.n");
  237. is_suid = geteuid() != getuid();
  238. /*
  239.  * We don't need root privilleges anymore.
  240.  */
  241. #ifdef HAVE_SETREUID
  242. if (setreuid(-1, getuid()) < 0)
  243. #else
  244. #ifdef HAVE_SETEUID
  245. if (seteuid(getuid()) < 0)
  246. #else
  247. if (setuid(getuid()) < 0)
  248. #endif
  249. #endif
  250. comerr("Panic cannot set back efective uid.n");
  252. /* code to use SCG */
  254. do_inquiry(scgp, FALSE);
  255. if (is_suid) {
  256. if (scgp->inq->type != INQ_ROMD)
  257. comerrno(EX_BAD, "Not root. Will only work on CD-ROM in suid moden");
  258. }
  260. if (filename || sectors) {
  261. dorw(scgp, filename, sectors);
  262. } else {
  263. doit(scgp);
  264. }
  265. return (0);
  266. }
  268. LOCAL int
  269. prstats()
  270. {
  271. int sec;
  272. int usec;
  273. int tmsec;
  275. if (gettimeofday(&stoptime, (struct timezone *)0) < 0)
  276. comerr("Cannot get timen");
  278. sec = stoptime.tv_sec - starttime.tv_sec;
  279. usec = stoptime.tv_usec - starttime.tv_usec;
  280. tmsec = sec*1000 + usec/1000;
  281. #ifdef lint
  282. tmsec = tmsec; /* Bisz spaeter */
  283. #endif
  284. if (usec < 0) {
  285. sec--;
  286. usec += 1000000;
  287. }
  289. error("Time total: %d.%03dsecn", sec, usec/1000);
  290. /* return (sec + (usec / 500000));*/
  291. return (1000*sec + (usec / 1000));
  292. }
  294. LOCAL void
  295. dorw(scgp, filename, sectors)
  296. SCSI *scgp;
  297. char *filename;
  298. char *sectors;
  299. {
  300. parm_t params;
  301. char *p = NULL;
  303. params.start = 0;
  304. params.end = -1;
  305. params.name = NULL;
  307. if (filename)
  308. params.name = filename;
  309. if (sectors)
  310. p = astol(sectors, &params.start);
  311. if (p && *p == '-')
  312. p = astol(++p, &params.end);
  313. if (p && *p != '')
  314. comerrno(EX_BAD, "Not a valid sector range '%s'n", sectors);
  316. if (!wait_unit_ready(scgp, 60))
  317. comerr("Device not ready.n");
  319. if (do_write)
  320. write_disk(scgp, &params);
  321. else
  322. read_disk(scgp, &params);
  323. }
  325. LOCAL void
  326. doit(scgp)
  327. SCSI *scgp;
  328. {
  329. int i = 0;
  331. for(;;) {
  332. if (!wait_unit_ready(scgp, 60))
  333. comerr("Device not ready.n");
  335. printf("0:read 1:veri   2:erase   3:read buffer 4:cache 5:ovtime 6:capn");
  336. printf("7:wne  8:floppy 9:verify 10:checkcmds  11:read disk 12:write diskn");
  337. printf("13:scsireset 14:seektest 15: readdan");
  339. getint("Enter selection:", &i, 0, 15);
  340. switch (i) {
  342. case 11: read_disk(scgp, 0); break;
  343. case 12: write_disk(scgp, 0); break;
  344. case 15: ra(scgp); break;
  345. }
  346. }
  347. }
  349. #ifdef used
  350. LOCAL int
  351. read_scsi_g1(scgp, bp, addr, cnt)
  352. SCSI *scgp;
  353. caddr_t bp;
  354. long addr;
  355. int cnt;
  356. {
  357. register struct scg_cmd *scmd = scgp->scmd;
  359. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  360. scmd->addr = bp;
  361. /* scmd->size = cnt*512;*/
  362. scmd->size = cnt*scgp->cap->c_bsize;
  363. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  364. scmd->cdb_len = SC_G1_CDBLEN;
  365. scmd->sense_len = CCS_SENSE_LEN;
  366. scmd->target = scgp->target;
  367. scmd->cdb.g1_cdb.cmd = 0x28;
  368. scmd->cdb.g1_cdb.lun = scgp->lun;
  369. g1_cdbaddr(&scmd->cdb.g1_cdb, addr);
  370. g1_cdblen(&scmd->cdb.g1_cdb, cnt);
  372. scgp->cmdname = "read extended";
  374. return (scsicmd(scgp));
  375. }
  376. #endif
  378. #define G0_MAXADDR 0x1FFFFFL
  380. EXPORT int
  381. write_scsi(scgp, bp, addr, cnt)
  382. SCSI *scgp;
  383. caddr_t bp;
  384. long addr;
  385. int cnt;
  386. {
  387. if(addr <= G0_MAXADDR)
  388. return(write_g0(scgp, bp, addr, cnt));
  389. else
  390. return(write_g1(scgp, bp, addr, cnt));
  391. }
  393. EXPORT int
  394. write_g0(scgp, bp, addr, cnt)
  395. SCSI *scgp;
  396. caddr_t bp;
  397. long addr;
  398. int cnt;
  399. {
  400. register struct scg_cmd *scmd = scgp->scmd;
  402. if (scgp->cap->c_bsize <= 0)
  403. raisecond("capacity_not_set", 0L);
  405. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  406. scmd->addr = bp;
  407. scmd->size = cnt*scgp->cap->c_bsize;
  408. scmd->flags = SCG_DISRE_ENA;
  409. scmd->cdb_len = SC_G0_CDBLEN;
  410. scmd->sense_len = CCS_SENSE_LEN;
  411. scmd->target = scgp->target;
  412. scmd->cdb.g0_cdb.cmd = SC_WRITE;
  413. scmd->cdb.g0_cdb.lun = scgp->lun;
  414. g0_cdbaddr(&scmd->cdb.g0_cdb, addr);
  415. scmd->cdb.g0_cdb.count = cnt;
  417. scgp->cmdname = "write_g0";
  419. return (scsicmd(scgp));
  420. }
  422. EXPORT int
  423. write_g1(scgp, bp, addr, cnt)
  424. SCSI *scgp;
  425. caddr_t bp;
  426. long addr;
  427. int cnt;
  428. {
  429. register struct scg_cmd *scmd = scgp->scmd;
  431. if (scgp->cap->c_bsize <= 0)
  432. raisecond("capacity_not_set", 0L);
  434. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  435. scmd->addr = bp;
  436. scmd->size = cnt*scgp->cap->c_bsize;
  437. scmd->flags = SCG_DISRE_ENA;
  438. scmd->cdb_len = SC_G1_CDBLEN;
  439. scmd->sense_len = CCS_SENSE_LEN;
  440. scmd->target = scgp->target;
  441. scmd->cdb.g1_cdb.cmd = SC_EWRITE;
  442. scmd->cdb.g1_cdb.lun = scgp->lun;
  443. g1_cdbaddr(&scmd->cdb.g1_cdb, addr);
  444. g1_cdblen(&scmd->cdb.g1_cdb, cnt);
  446. scgp->cmdname = "write_g1";
  448. return (scsicmd(scgp));
  449. }
  451. #ifdef used
  452. LOCAL void
  453. Xrequest_sense(scgp)
  454. SCSI *scgp;
  455. {
  456. char sense_buf[32];
  457. struct scg_cmd ocmd;
  458. int sense_count;
  459. char *cmdsave;
  460. register struct scg_cmd *scmd = scgp->scmd;
  462. cmdsave = scgp->cmdname;
  464. movebytes(scmd, &ocmd, sizeof(*scmd));
  466. fillbytes((caddr_t)sense_buf, sizeof(sense_buf), '');
  468. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  469. scmd->addr = (caddr_t)sense_buf;
  470. scmd->size = sizeof(sense_buf);
  471. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  472. scmd->cdb_len = SC_G0_CDBLEN;
  473. scmd->sense_len = CCS_SENSE_LEN;
  474. scmd->target = scgp->target;
  475. scmd->cdb.g1_cdb.cmd = 0x3;
  476. scmd->cdb.g1_cdb.lun = scgp->lun;
  477. scmd->cdb.g0_cdb.count = sizeof(sense_buf);
  479. scgp->cmdname = "request sense";
  481. scsicmd(scgp);
  483. sense_count = sizeof(sense_buf) - scsigetresid(scgp);
  484. movebytes(&ocmd, scmd, sizeof(*scmd));
  485. scmd->sense_count = sense_count;
  486. movebytes(sense_buf, (u_char *)&scmd->sense, scmd->sense_count);
  488. scgp->cmdname = cmdsave;
  489. scsiprinterr(scgp);
  490. scsiprintresult(scgp); /* XXX restore key/code in future */
  491. }
  492. #endif
  494. /*#define MAX_RETRY 32*/
  495. #define MAX_RETRY 128
  497. LOCAL int
  498. rrr(scgp, addr, cnt)
  499. SCSI *scgp;
  500. long addr;
  501. long cnt;
  502. {
  503. int secsize = scgp->cap->c_bsize;
  504. int try = 0;
  505. int err;
  506. char dummybuf[4000];
  508. errmsgno(EX_BAD, "Retrying from sector %d.n", addr);
  509. while (cnt > 0) {
  510. error(".");
  512. do {
  513. if (try != 0) {
  514. if ((try % 8) == 0) {
  515. error("+");
  516. scgp->silent++;
  517. read_g1(scgp, dummybuf, scgp->cap->c_baddr, 1);
  518. scgp->silent--;
  519. } else if ((try % 4) == 0) {
  520. error("-");
  521. scgp->silent++;
  522. read_g1(scgp, dummybuf, 0, 1);
  523. scgp->silent--;
  524. } else {
  525. error("~");
  526. scgp->silent++;
  527. read_g1(scgp, dummybuf, choice(scgp->cap->c_baddr), 1);
  528. scgp->silent--;
  529. }
  530. }
  532. scgp->silent++;
  533. /* err = read_scsi(scgp, Sbuf, addr, 1);*/
  534. err = read_g1(scgp, Sbuf, addr, 1);
  535. scgp->silent--;
  537. if (err < 0) {
  538. /* err = geterrno();*/
  539. err = scgp->scmd->ux_errno;
  540. /* error("n");*/
  541. /* errmsgno(err, "Cannot read source diskn");*/
  542. } else {
  543. break;
  544. }
  545. } while (++try < MAX_RETRY);
  547. if (try >= MAX_RETRY) {
  548. errmsgno(err, "Error not corrected.n");
  549. return (-1);
  550. } else {
  551. if (try > 1)
  552. errmsgno(EX_BAD, "Error corrected after %d tries.n", try);
  553. }
  554. try = 0;
  555. cnt -= 1;
  556. addr += 1;
  557. Sbuf += secsize;
  558. }
  559. return (0);
  560. }
  562. LOCAL void
  563. read_disk(scgp, parmp)
  564. SCSI *scgp;
  565. parm_t *parmp;
  566. {
  567. char filename[512];
  568. char *defname = "disk.out";
  569. FILE *f;
  570. long addr;
  571. long cnt;
  572. long end;
  573. int nsec;
  574. long start = 0L;
  575. int err = 0;
  576. /*int try;*/
  578. if (is_suid) {
  579. if (scgp->inq->type != INQ_ROMD)
  580. comerrno(EX_BAD, "Not root. Will only read from CD in suid moden");
  581. }
  583. filename[0] ='';
  584. read_capacity(scgp);
  585. end = scgp->cap->c_baddr + 1;
  587. if (end <= 0)
  588. end = 10000000; /* Hack to read empty (e.g. blank=fast) disks */
  590. if (parmp) {
  591. if (parmp->name)
  592. defname = parmp->name;
  593. error("Copy from SCSI (%d,%d,%d) disk to file '%s'n",
  594. scgp->scsibus, scgp->target, scgp->lun,
  595. defname);
  597. addr = start = parmp->start;
  598. if (parmp->end != -1 && parmp->end < end)
  599. end = parmp->end;
  600. cnt = Sbufsize / scgp->cap->c_bsize;
  601. }
  602. else {
  604. error("Copy from SCSI (%d,%d,%d) disk to filen",
  605. scgp->scsibus, scgp->target, scgp->lun);
  606. error("Enter filename [%s]: ", defname);flush();
  607. (void)getline(filename, sizeof(filename));
  609. addr = start;
  610. getlong("Enter starting sector for copy:", &addr, start, end-1);
  611. start = addr;
  612. cnt = end - addr;
  613. getlong("Enter number of sectors to copy:", &cnt, 1L, cnt);
  614. end = addr + cnt;
  616. cnt = Sbufsize / scgp->cap->c_bsize;
  617. getlong("Enter number of sectors per copy:", &cnt, 1L, cnt);
  618. /* error("end:  %8ldn", end);*/
  619. }
  621. if (filename[0] == '')
  622. strcpy(filename, defname);
  623. if (streql(filename, "-")) {
  624. f = stdout;
  625. #if defined(__CYGWIN32__) || defined(__EMX__)
  626. setmode(STDOUT_FILENO, O_BINARY);
  627. #endif
  628. } else if ((f = fileopen(filename, "wcub")) == NULL)
  629. comerr("Cannot open '%s'.n", filename);
  631. error("end:  %8ldn", end);
  632. if (gettimeofday(&starttime, (struct timezone *)0) < 0)
  633. comerr("Cannot get start timen");
  635. for(;addr < end; addr += cnt)                         {
  637. if ((addr + cnt) > end)
  638. cnt = end - addr;
  640. error("addr: %8d cnt: %dr", addr, cnt);
  642. /* try = 0;*/
  643. /* do {*/
  644. /* if (read_scsi(scgp, Sbuf, addr, cnt) < 0) {*/
  645. if (read_g1(scgp, Sbuf, addr, cnt) < 0) {
  646. /* err = geterrno();*/
  647. err = scgp->scmd->ux_errno;
  648. error("n");
  649. errmsgno(err, "Cannot read source diskn");
  650. /* break;*/
  651. if (rrr(scgp, addr, cnt) < 0)
  652. goto out;
  653. }
  654. /* else break;*/
  655. /* } while (++try < 10);*/
  656. /* if (try >= 10)*/
  657. /* break;*/
  658. if (filewrite(f, Sbuf, cnt * scgp->cap->c_bsize) < 0) {
  659. err = geterrno();
  660. error("n");
  661. errmsgno(err, "Cannot write '%s'n", filename);
  662. break;
  663. }
  664. }
  665. error("addr: %8d", addr);
  666. out:
  667. error("n");
  668. nsec = prstats();
  669. /* error("%dn",nsec);*/
  670. error("Read %.2f kB at %.1f kB/sec.n",
  671. (addr - start)/(1024.0/scgp->cap->c_bsize),
  672. ((addr - start)/(1024.0/scgp->cap->c_bsize)) / (0.001*nsec));
  673. if (err)
  674. exit(err);
  675. }
  677. LOCAL void
  678. write_disk(scgp, parmp)
  679. SCSI *scgp;
  680. parm_t *parmp;
  681. {
  682. char filename[512];
  683. char *defname = "disk.out";
  684. FILE *f;
  685. long addr = 0L;
  686. long cnt;
  687. long amt;
  688. long end;
  689. int nsec;
  690. int start;
  692. if (is_suid)
  693. comerrno(EX_BAD, "Not root. Will not write in suid moden");
  695. read_capacity(scgp);
  696. end = scgp->cap->c_baddr + 1;
  698. if (end <= 0)
  699. end = 10000000; /* Hack to write empty disks */
  701. if (parmp) {
  702. if (parmp->name)
  703. defname = parmp->name;
  704. error("Copy from file '%s' tp SCSI (%d,%d,%d) diskn",
  705. defname,
  706. scgp->scsibus, scgp->target, scgp->lun);
  708. addr = start = parmp->start;
  709. if (parmp->end != -1 && parmp->end < end)
  710. end = parmp->end;
  711. cnt = Sbufsize / scgp->cap->c_bsize;
  712. }
  713. else {
  715. error("Copy from file to SCSI (%d,%d,%d) diskn",
  716. scgp->scsibus, scgp->target, scgp->lun);
  717. error("Enter filename [%s]: ", defname);flush();
  718. (void)getline(filename, sizeof(filename));
  719. error("Notice: reading from file always starts at file offset 0.n");
  721. getlong("Enter starting sector for copy:", &addr, 0L, end-1);
  722. start = addr;
  723. cnt = end - addr;
  724. getlong("Enter number of sectors to copy:", &end, 1L, end);
  725. end = addr + cnt;
  727. cnt = Sbufsize / scgp->cap->c_bsize;
  728. getlong("Enter number of sectors per copy:", &cnt, 1L, cnt);
  729. /* error("end:  %8ldn", end);*/
  730. }
  732. if (filename[0] == '')
  733. strcpy(filename, defname);
  734. if (streql(filename, "-")) {
  735. f = stdin;
  736. #if defined(__CYGWIN32__) || defined(__EMX__)
  737. setmode(STDIN_FILENO, O_BINARY);
  738. #endif
  739. } else if ((f = fileopen(filename, "rub")) == NULL)
  740. comerr("Cannot open '%s'.n", filename);
  742. error("end:  %8ldn", end);
  743. if (gettimeofday(&starttime, (struct timezone *)0) < 0)
  744. comerr("Cannot get start timen");
  746. for(;addr < end; addr += cnt) {
  748. if ((addr + cnt) > end)
  749. cnt = end - addr;
  751. error("addr: %8d cnt: %dr", addr, cnt);
  753. if ((amt = fileread(f, Sbuf, cnt * scgp->cap->c_bsize)) < 0)
  754. comerr("Cannot read '%s'n", filename);
  755. if (amt == 0)
  756. break;
  757. if ((amt / scgp->cap->c_bsize) < cnt)
  758. cnt = amt / scgp->cap->c_bsize;
  759. if (write_scsi(scgp, Sbuf, addr, cnt) < 0)
  760. comerrno(scgp->scmd->ux_errno,
  761. "Cannot write destination diskn");
  762. }
  763. error("addr: %8dn", addr);
  764. nsec = prstats();
  765. error("Wrote %.2f kB at %.1f kB/sec.n",
  766. (double)(addr - start)/(1024.0/scgp->cap->c_bsize),
  767. (double)((addr - start)/(1024.0/scgp->cap->c_bsize)) / nsec);
  768. }
  770. LOCAL int
  771. choice(n)
  772. int n;
  773. {
  774. #if !defined(__CYGWIN32__) && !defined(__EMX__)
  775. extern double drand48 __PR((void));
  777. return drand48() * n;
  778. #else
  779. return (0);
  780. #endif
  781. }
  783. LOCAL void
  784. ra(scgp)
  785. SCSI *scgp;
  786. {
  787. /* char filename[512];*/
  788. FILE *f;
  789. /* long addr = 0L;*/
  790. /* long cnt;*/
  791. /* long end;*/
  792. /* int nsec;*/
  793. /* int start;*/
  794. /* int err = 0;*/
  796. select_secsize(scgp, 2352);
  797. read_capacity(scgp);
  798. fillbytes(Sbuf, 50*2352, 0);
  799. if (read_g1(scgp, Sbuf, 0, 50) < 0)
  800. errmsg("read CDn");
  801. f = fileopen("DDA", "wctb");
  802. /* filewrite(f, Sbuf, 50 * 2352 - scsigetresid(scgp));*/
  803. filewrite(f, Sbuf, 50 * 2352 );
  804. fclose(f);
  805. }
  807. #ifdef XXX
  808. EXPORT int
  809. read_da(scgp, bp, addr, cnt)
  810. SCSI *scgp;
  811. caddr_t bp;
  812. long addr;
  813. int cnt;
  814. {
  815. register struct scg_cmd *scmd = scgp->scmd;
  817. if (scgp->cap->c_bsize <= 0)
  818. raisecond("capacity_not_set", 0L);
  820. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  821. scmd->addr = bp;
  822. scmd->size = cnt*scgp->cap->c_bsize;
  823. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  824. scmd->cdb_len = SC_G5_CDBLEN;
  825. scmd->sense_len = CCS_SENSE_LEN;
  826. scmd->target = scgp->target;
  827. /* scmd->cdb.g5_cdb.cmd = SC_EREAD;*/
  828. scmd->cdb.g5_cdb.cmd = 0xd9;
  829. scmd->cdb.g5_cdb.lun = scgp->lun;
  830. g5_cdbaddr(&scmd->cdb.g1_cdb, addr);
  831. g5_cdblen(&scmd->cdb.g1_cdb, cnt);/* XXX subscript out of range ?? */
  833. scgp->cmdname = "read_g1";
  835. return (scsicmd(scgp));
  836. }
  837. #endif