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

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

SCSI/ASPI

开发平台：

MultiPlatform

scsi-unixware.c：源码内容
  1. /* @(#)scsi-unixware.c 1.12 00/01/26 Copyright 1998 J. Schilling, Santa Cruz Operation */
  2. #ifndef lint
  3. static char __sccsid[] =
  4. "@(#)scsi-unixware.c 1.12 00/01/26 Copyright 1998 J. Schilling, Santa Cruz Operation";
  5. #endif
  6. /*
  7.  * Interface for the SCO UnixWare SCSI implementation.
  8.  *
  9.  * Warning: you may change this source, but if you do that
  10.  * you need to change the _scg_version and _scg_auth* string below.
  11.  * You may not return "schily" for an SCG_AUTHOR request anymore.
  12.  * Choose your name instead of "schily" and make clear that the version
  13.  * string is related to a modified source.
  14.  *
  15.  * Copyright (c) 1998 J. Schilling, Santa Cruz Operation
  16.  */
  17. /*
  18.  * This program is free software; you can redistribute it and/or modify
  19.  * it under the terms of the GNU General Public License as published by
  20.  * the Free Software Foundation; either version 2, or (at your option)
  21.  * any later version.
  22.  *
  23.  * This program is distributed in the hope that it will be useful,
  24.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  25.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26.  * GNU General Public License for more details.
  27.  *
  28.  * You should have received a copy of the GNU General Public License
  29.  * along with this program; see the file COPYING.  If not, write to
  30.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  31.  */
  33. #undef sense
  34. #undef SC_PARITY
  35. #undef scb
  37. #include <sys/sysmacros.h>
  38. #include <sys/scsi.h>
  39. #include <sys/sdi_edt.h>
  40. #include <sys/sdi.h>
  42. /*
  43.  * Warning: you may change this source, but if you do that
  44.  * you need to change the _scg_version and _scg_auth* string below.
  45.  * You may not return "schily" for an SCG_AUTHOR request anymore.
  46.  * Choose your name instead of "schily" and make clear that the version
  47.  * string is related to a modified source.
  48.  */
  49. LOCAL char _scg_trans_version[] = "scsi-unixware.c-1.12"; /* The version for this transport*/
  51. /* Max. number of scg scsibusses.  The real limit would be           */
  52. /* MAX_HBA * MAX_BUS (which would be 32 * 8 on UnixWare 2.1/7.x),    */
  53. /* but given that we will hardly see such a beast, lets take 32      */
  55. #define MAX_SCG 32
  57. /* maximum defines for UnixWare 2.x/7.x from <sys/sdi_edt.h> */
  59. #define MAX_TGT MAX_EXTCS /* Max # of target id's      */
  60. #define MAX_LUN MAX_EXLUS /* Max # of lun's            */
  62. #define MAX_DMA (32*1024)
  64. #define MAXLINE 80
  65. #define MAXPATH 256
  67. #define DEV_DIR "/tmp"
  68. #define DEV_NAME "scg.s%1dt%1dl%1d"
  70. #define SCAN_HBA "%d:%d,%d,%d:%7s : %n"
  71. #define SCAN_DEV "%d,%d,%d:%7s : %n"
  73. #define PRIM_HBA "/dev/hba/hba1"
  74. #define SCSI_CFG "LC_ALL=C /etc/scsi/pdiconfig -l"
  77. typedef struct scg2sdi {
  78. int valid;
  79. int open;
  80. int atapi;
  81. int initiator;
  82. int hba;
  83. int bus;
  84. int tgt;
  85. int lun;
  87. int fd;
  88. dev_t node;
  89. dev_t major;
  90. dev_t minor;
  91. char type[20];
  92. char vend[40];
  93. char devn[32];
  95. } scg2sdi_t;
  97. LOCAL scg2sdi_t sdidevs [MAX_SCG][MAX_TGT][MAX_LUN];
  99. struct scg_local {
  100. short scgfiles[MAX_SCG][MAX_TGT][MAX_LUN];
  101. };
  102. #define scglocal(p) ((struct scg_local *)((p)->local)) 
  104. LOCAL int unixware_init __PR((SCSI *scgp));
  105. LOCAL int do_scsi_cmd __PR((SCSI *scgp, int fd, struct scg_cmd *sp));
  106. LOCAL int do_scsi_sense __PR((SCSI *scgp, int fd, struct scg_cmd *sp));
  108. /* -------------------------------------------------------------------------
  109. ** SCO UnixWare 2.1.x / UnixWare 7 provides a scsi pass-through mechanism, 
  110. ** which can be used to access any configured scsi device. 
  111. **
  112. ** NOTE: The libscg UnixWare passthrough routines have changed with 
  113. **       cdrecord-1.8 to enable the -scanbus, -load, -eject option 
  114. **  regardless of the status of media and the addressing
  115. **       scheme is now the same as used on many other platforms like
  116. **       Solaris, Linux etc.
  117. **
  118. **      ===============================================================
  119. ** RUN 'cdrecord -scanbus' TO SEE THE DEVICE ADDRESSES YOU CAN USE
  120. ** ===============================================================
  121. */
  123. /*
  124.  * Return version information for the low level SCSI transport code.
  125.  * This has been introduced to make it easier to trace down problems
  126.  * in applications.
  127.  *
  128.  */
  129. EXPORT char *
  130. scg__version(scgp, what)
  131. SCSI *scgp;
  132. int what;
  133. {
  134. if (scgp != (SCSI *)0) {
  135. switch (what) {
  137. case SCG_VERSION:
  138. return (_scg_trans_version);
  139. /*
  140.  * If you changed this source, you are not allowed to
  141.  * return "schily" for the SCG_AUTHOR request.
  142.  */
  143. case SCG_AUTHOR:
  144. return (_scg_auth_schily);
  145. case SCG_SCCS_ID:
  146. return (__sccsid);
  147. }
  148. }
  149. return ((char *)0);
  150. }
  153. /* ---------------------------------------------------------------
  154. ** This routine is introduced to create all device nodes necessary
  155. ** to access any detected scsi device. It parses the output of
  156. ** /etc/scsi/pdiconfig -l and creates passthru device node for each
  157. ** found scsi device apart from the listed hba's.
  158. **
  159. */
  161. LOCAL int 
  162. unixware_init(scgp)
  163. SCSI *scgp;
  164. {
  165. FILE *cmd;
  166. int hba = 0, bus = 0, scg = 0, tgt = 0, lun = 0;
  167. int nscg = -1, lhba = -1, lbus = 0;
  168. int atapi, fd, nopen = 0, pos = 0, len = 0;
  169. int s, t, l;
  170. char lines[MAXLINE];
  171. char class[MAXLINE];
  172. char ident[MAXLINE];
  173. char dname[MAXPATH];
  174. struct stat  stbuf;
  175. dev_t ptdev, major, minor, node;
  176. char **evsave;
  177. extern char **environ;
  179. /* Check for validity of primary hostbus adapter node */
  181. if (stat(PRIM_HBA, &stbuf) < 0) {
  182. if (scgp->errstr)
  183. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  184. "Can not stat() primary hba (%s)",
  185. PRIM_HBA);
  186. return (-1);
  187. }
  189. if (!S_ISCHR(stbuf.st_mode)) {
  190. if (scgp->errstr)
  191. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  192. "Primary hba (%s) not a character device",
  193. PRIM_HBA);
  194. return (-1);
  195. }
  197. major = getmajor(stbuf.st_rdev);
  199. /* read pdiconfig output and get all attached scsi devices ! */
  201. evsave = environ;
  202. environ = 0;
  203. if ((cmd = popen(SCSI_CFG,"r")) == NULL) {
  204. if (scgp->errstr)
  205. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  206. "Error popen() for "%s"",
  207. SCSI_CFG);
  208. environ = evsave;
  209. return (-1);
  210. }
  211. environ = evsave;
  214. for (;;) {
  215. if (fgets(lines, MAXLINE, cmd) == NULL) 
  216. break;
  218. memset( class, '', sizeof(class));
  219. memset( ident, '', sizeof(ident));
  221. if (lines[0] == ' ' ) {
  222. sscanf(lines, SCAN_DEV, &bus, &tgt, &lun, class, &pos);
  223. hba = lhba;
  224. } else {
  225. sscanf(lines, SCAN_HBA, &hba, &bus, &tgt, &lun, class, &pos);
  226. nscg++;
  227. lhba = hba;
  228. atapi = 0;
  229. }
  231. /* We can't sscanf() the ident string of the device     */
  232. /* as it may contain characters sscanf() will           */
  233. /* recognize as a delimiter. So do a strcpy() instead ! */
  235. len = strlen(lines) - pos - 1; /* don't copy the 'n' */
  237. strncpy(ident, &lines[pos], len);
  239. if (scgp->debug) {
  240. printf("SDI -> %d:%d,%d,%d: %-7s : %sn", 
  241. hba, bus, tgt, lun, class, ident);
  242. }
  244. if ( bus != lbus ) { 
  245. nscg++;
  246. lbus = bus;
  247. }
  249. scg = nscg;
  251. /* check whether we have a HBA or a SCSI device, don't  */
  252. /* let HBA's be valid device for cdrecord, but mark     */
  253. /* them as a controller (initiator = 1).                */
  255. if ( strstr(class, "HBA") == NULL ){
  256. sdidevs[scg][tgt][lun].valid = 1;
  257. } else {
  258. sdidevs[scg][tgt][lun].initiator = 1;
  259. }
  261. /* There is no real flag that shows a HBA as an ATAPI   */
  262. /* controller, so as we know the driver is called 'ide' */
  263. /* we can check the ident string for the occurence of it*/
  265. if ( strstr(ident, "(ide,") != NULL ){
  266. atapi = 1;
  267. }
  269. /* fill the sdidevs array with all we know now          */
  271. sdidevs[scg][tgt][lun].open  = 0;
  272. sdidevs[scg][tgt][lun].atapi = atapi;
  274. sdidevs[scg][tgt][lun].hba = hba;
  275. sdidevs[scg][tgt][lun].bus = bus;
  276. sdidevs[scg][tgt][lun].tgt = tgt;
  277. sdidevs[scg][tgt][lun].lun = lun;
  279. strcpy(sdidevs[scg][tgt][lun].type, class);
  280. strcpy(sdidevs[scg][tgt][lun].vend, ident);
  282. sprintf(sdidevs[scg][tgt][lun].devn, DEV_NAME, scg, tgt, lun);
  284. minor = SDI_MINOR(hba, tgt, lun, bus);
  285. node  = makedevice(major, minor);
  287. sdidevs[scg][tgt][lun].major = major;
  288. sdidevs[scg][tgt][lun].minor = minor;
  289. sdidevs[scg][tgt][lun].node  = node;
  291. if (scgp->debug) {
  293. printf("h = %d; b = %d, s = %d, t = %d, l = %d, a = %d, ma = %d, mi = %2d, dev = %s, id = %sn", 
  294. hba, bus, scg, tgt, lun, 
  295. sdidevs[scg][tgt][lun].atapi, 
  296. sdidevs[scg][tgt][lun].major, 
  297. sdidevs[scg][tgt][lun].minor, 
  298. sdidevs[scg][tgt][lun].devn,
  299. sdidevs[scg][tgt][lun].vend );
  300. }
  303. }
  305. if (pclose(cmd) == -1) {
  306. if (scgp->errstr)
  307. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  308. "Error pclose() for "%s"",
  309. SCSI_CFG);
  310. return (-1);
  311. }
  314. /* create all temporary device nodes */
  316. for (s = 0; s < MAX_SCG; s++) {
  317. for (t = 0; t < MAX_TGT; t++) {
  318. for (l = 0; l < MAX_LUN ; l++) {
  320.   if ( sdidevs[s][t][l].valid == 0) {
  321.    sdidevs[s][t][l].fd = -1;
  322.    continue;
  323.   }
  325.   /* Make pass-through interface device node */
  327.   sprintf(dname, "%s/%s", DEV_DIR, sdidevs[s][t][l].devn);
  329.   ptdev = sdidevs[s][t][l].node;
  331.   if (mknod(dname, S_IFCHR | 0700, ptdev) < 0) {
  332. if (errno == EEXIST) {
  333. unlink(dname);
  335. if (mknod(dname, S_IFCHR | 0700, ptdev) < 0) {
  336. if (scgp->errstr)
  337. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  338. "mknod() error for "%s"", dname);
  339. return (-1);
  340. }
  341. } else {
  342. if (scgp->errstr)
  343. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  344. "mknod() error for "%s"", dname);
  345. return (-1);
  346. }
  347.   }
  349.   /* Open pass-through device node */
  351.   if ((fd = open(dname, O_RDONLY)) < 0) {
  352. if (scgp->errstr)
  353. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  354. "can not open pass-through %s", dname);
  355. return (-1);
  356.   }
  358.   sdidevs[s][t][l].fd   = fd;
  359.   sdidevs[s][t][l].open = 1;
  360.      nopen++;
  361.   scglocal(scgp)->scgfiles[s][t][l] = (short) fd;
  363.   if (scgp->debug) {
  365. printf("s = %d, t = %d, l = %d, dev = %s, fd = %dn", 
  366.           s, t, l, 
  367. sdidevs[s][t][l].devn,
  368. sdidevs[s][t][l].fd );
  369.   }
  371. }
  372. }
  373. }
  375. return (nopen);
  376. }
  379. EXPORT int
  380. scsi_open(scgp, device, busno, tgt, tlun)
  381. SCSI *scgp;
  382. char *device;
  383. int busno;
  384. int tgt;
  385. int tlun;
  386. {
  387. int c, b, t;
  389. if (busno >= MAX_SCG || tgt >= MAX_TGT || tlun >= MAX_LUN) {
  390. errno = EINVAL;
  391. if (scgp->errstr)
  392. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  393. "Illegal value for busno, target or lun '%d,%d,%d'",
  394. busno, tgt, tlun);
  395. return (-1);
  396. }
  398. if (scgp->local == NULL) {
  399. scgp->local = malloc(sizeof(struct scg_local));
  400. if (scgp->local == NULL)
  401. return (0);
  403. for (c = 0; c < MAX_SCG; c++) {
  404. for (b = 0; b < MAX_TGT; b++) {
  405. for (t = 0; t < MAX_LUN ; t++)
  406. scglocal(scgp)->scgfiles[c][b][t] = (short)-1;
  407. }
  408. }
  409. }
  412. memset(sdidevs, 0, sizeof(sdidevs)); /* init tmp_structure */
  414. if (*device != '') { /* we don't allow old dev usage */
  415. errno = EINVAL;
  416. if (scgp->errstr)
  417. js_snprintf(scgp->errstr, SCSI_ERRSTR_SIZE,
  418. "Open by 'devname' no longer supported on this OS");
  419. return (-1);
  420. } else { /* this is the new stuff       */
  421. /* it will do the initialisation */
  422. /* and return the number of      */
  423. /* detected devices to be used   */
  424. /* with the new addressing       */
  425. /* scheme.                       */
  427. return (unixware_init(scgp));
  428. }
  430. }
  433. EXPORT int
  434. scsi_close(scgp)
  435. SCSI *scgp;
  436. {
  437. register int f;
  438. register int b;
  439. register int t;
  440. register int l;
  442. if (scgp->local == NULL)
  443. return (-1);
  445. for (b=0; b < MAX_SCG; b++) {
  446. for (t=0; t < MAX_TGT; t++) {
  447. for (l=0; l < MAX_LUN ; l++) {
  449. f = scglocal(scgp)->scgfiles[b][t][l];
  450. if (f >= 0)
  451. close(f);
  453. sdidevs[b][t][l].fd    = -1;
  454. sdidevs[b][t][l].open  =  0;
  455. sdidevs[b][t][l].valid =  0;
  457. scglocal(scgp)->scgfiles[b][t][l] = (short)-1;
  458. }
  459. }
  460. }
  461. return (0);
  462. }
  464. LOCAL long
  465. scsi_maxdma(scgp)
  466. SCSI *scgp;
  467. {
  468. return (MAX_DMA);
  469. }
  472. EXPORT void *
  473. scsi_getbuf(scgp, amt)
  474. SCSI *scgp;
  475. long amt;
  476. {
  477. if (amt <= 0 || amt > scsi_maxdma(scgp))
  478. return ((void *)0);
  479. if (scgp->debug)
  480. printf("scsi_getbuf: %ld bytesn", amt);
  482. scgp->bufbase = (void *) valloc((size_t)(amt));
  484. return (scgp->bufbase);
  485. }
  487. EXPORT void
  488. scsi_freebuf(scgp)
  489. SCSI *scgp;
  490. {
  491. if (scgp->bufbase)
  492. free(scgp->bufbase);
  493. scgp->bufbase = NULL;
  494. }
  496. EXPORT
  497. BOOL scsi_havebus(scgp, busno)
  498. SCSI *scgp;
  499. int busno;
  500. {
  501. register int t;
  502. register int l;
  504. if (busno < 0 || busno >= MAX_SCG)
  505. return (FALSE);
  507. if (scgp->local == NULL)
  508. return (FALSE);
  510. for (t=0; t < MAX_TGT; t++) {
  511. for (l=0; l < MAX_LUN ; l++)
  512. if (scglocal(scgp)->scgfiles[busno][t][l] >= 0)
  513. return (TRUE);
  514. }
  515. return (FALSE);
  516. }
  518. EXPORT
  519. int scsi_fileno(scgp, busno, tgt, tlun)
  520. SCSI *scgp;
  521. int busno;
  522. int tgt;
  523. int tlun;
  524. {
  525. if (busno < 0 || busno >= MAX_SCG ||
  526.     tgt   < 0 || tgt   >= MAX_TGT ||
  527.     tlun  < 0 || tlun  >= MAX_LUN)
  528. return (-1);
  530. if (scgp->local == NULL)
  531. return (-1);
  533. return ((int)scglocal(scgp)->scgfiles[busno][tgt][tlun]);
  534. }
  536. EXPORT int
  537. scsi_initiator_id(scgp)
  538. SCSI *scgp;
  539. {
  540. register int t;
  541. register int l;
  542. register int busno;
  544. busno = scgp->scsibus;
  546. if (busno < 0 || busno >= MAX_SCG)
  547. return (FALSE);
  549. for (t=0; t < MAX_TGT; t++) {
  550. for (l=0; l < MAX_LUN ; l++)
  551. if (sdidevs[busno][t][l].initiator == 1){
  552. if (scgp->debug)
  553. printf("scsi_initiator_id: id = %dn", t);
  554. return (t);
  555. }
  556. }
  558. return (-1);
  559. }
  561. EXPORT
  562. int scsi_isatapi(scgp)
  563. SCSI *scgp;
  564. {
  565. /* if the new address method is used we know if this is ATAPI*/
  567. return (sdidevs[scgp->scsibus][scgp->target][scgp->lun].atapi);
  568. }
  570. EXPORT
  571. int scsireset(scgp)
  572. SCSI *scgp;
  573. {
  574. return(-1);
  575. }
  577. LOCAL int
  578. do_scsi_cmd(scgp, fd, sp)
  579. SCSI *scgp;
  580. int fd;
  581. struct scg_cmd *sp;
  582. {
  583. int ret;
  584. int i;
  585. struct sb scsi_cmd;
  586. struct scb *scbp;
  588. memset(&scsi_cmd,  0, sizeof(scsi_cmd));
  590. scsi_cmd.sb_type = ISCB_TYPE;
  591. scbp = &scsi_cmd.SCB;
  593. scbp->sc_cmdpt = (caddr_t) sp->cdb.cmd_cdb;
  594. scbp->sc_cmdsz = sp->cdb_len;
  596. scbp->sc_datapt = sp->addr;
  597. scbp->sc_datasz = sp->size;
  599. if (!(sp->flags & SCG_RECV_DATA) && (sp->size > 0))
  600. scbp->sc_mode = SCB_WRITE;
  601. else
  602. scbp->sc_mode = SCB_READ;
  604. scbp->sc_time = sp->timeout;
  606. errno = 0;
  607. for (;;) {
  608. if ((ret = ioctl(fd, SDI_SEND, &scsi_cmd)) < 0) {
  609. if (errno == EAGAIN){
  610. sleep(1);
  611. continue;
  612. }
  613. sp->ux_errno = errno;
  614. if (errno == 0)
  615. sp->ux_errno = EIO;
  616. sp->error = SCG_RETRYABLE;
  618. return (ret);
  619. }
  620. break;
  621. }
  623. memset(&sp->u_scb.Scb, 0, sizeof(sp->u_scb.Scb));
  624. sp->u_scb.cmd_scb[0] = scbp->sc_status;
  625. sp->resid = scbp->sc_resid;
  626. sp->ux_errno = errno;
  628. return (0);
  629. }
  632. LOCAL int
  633. do_scsi_sense(scgp, fd, sp)
  634. SCSI *scgp;
  635. int fd;
  636. struct scg_cmd *sp;
  637. {
  638. int ret;
  639. struct scg_cmd s_cmd;
  641. if (sp->sense_len > SCG_MAX_SENSE)
  642. sp->sense_len = SCG_MAX_SENSE;
  644. memset((caddr_t)&s_cmd, 0, sizeof(s_cmd));
  646. s_cmd.addr      = (caddr_t) sp->u_sense.cmd_sense;
  647. s_cmd.size      = sp->sense_len;
  648. s_cmd.flags     = SCG_RECV_DATA|SCG_DISRE_ENA;
  649. s_cmd.cdb_len   = SC_G0_CDBLEN;
  650. s_cmd.sense_len = CCS_SENSE_LEN;
  651. s_cmd.target    = scgp->target;
  653. s_cmd.cdb.g0_cdb.cmd   = SC_REQUEST_SENSE;
  654. s_cmd.cdb.g0_cdb.lun   = sp->cdb.g0_cdb.lun;
  655. s_cmd.cdb.g0_cdb.count = sp->sense_len;
  657. ret = do_scsi_cmd(scgp, fd, &s_cmd);
  659. if (ret < 0)
  660. return (ret);
  662. sp->sense_count = sp->sense_len - s_cmd.resid;
  663. return (ret);
  664. }
  666. LOCAL int
  667. scsi_send(scgp, fd, sp)
  668. SCSI *scgp;
  669. int fd;
  670. struct scg_cmd *sp;
  671. {
  672. int ret;
  674. if ( fd < 0 ) {
  675. sp->error = SCG_FATAL;
  676. return (0);
  677. } else {
  679. ret = do_scsi_cmd(scgp, fd, sp);
  681. if (ret < 0)
  682. return (ret);
  684. if (sp->u_scb.cmd_scb[0] & S_CKCON)
  685. ret = do_scsi_sense(scgp, fd, sp);
  687. return (ret);
  688. }
  689. }
  691. #define sense u_sense.Sense
  692. #undef SC_PARITY
  693. #define SC_PARITY 0x09
  694. #define scb u_scb.Scb