scsi.c 7.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390
  1. /*
  2. * This file is part of the UCB release of Plan 9. It is subject to the license
  3. * terms in the LICENSE file found in the top-level directory of this
  4. * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
  5. * part of the UCB release of Plan 9, including this file, may be copied,
  6. * modified, propagated, or distributed except according to the terms contained
  7. * in the LICENSE file.
  8. */
  9. /*
  10. * Now thread-safe.
  11. *
  12. * The codeqlock guarantees that once codes != nil, that pointer will never
  13. * change nor become invalid.
  14. *
  15. * The QLock in the Scsi structure moderates access to the raw device.
  16. * We should probably export some of the already-locked routines, but
  17. * there hasn't been a need.
  18. */
  19. #include <u.h>
  20. #include <libc.h>
  21. #include <disk.h>
  22. enum {
  23. /* commands */
  24. Testrdy = 0x00,
  25. Reqsense = 0x03,
  26. Write10 = 0x2a,
  27. Writever10 = 0x2e,
  28. Readtoc = 0x43,
  29. /* sense[2] (key) sense codes */
  30. Sensenone = 0,
  31. Sensenotrdy = 2,
  32. Sensebadreq = 5,
  33. /* sense[12] (asc) sense codes */
  34. Lunnotrdy = 0x04,
  35. Recovnoecc = 0x17,
  36. Recovecc = 0x18,
  37. Badcdb = 0x24,
  38. Newmedium = 0x28,
  39. Nomedium = 0x3a,
  40. };
  41. int scsiverbose;
  42. #define codefile "/sys/lib/scsicodes"
  43. static char *codes;
  44. static QLock codeqlock;
  45. static void
  46. getcodes(void)
  47. {
  48. Dir *d;
  49. int n, fd;
  50. if(codes != nil)
  51. return;
  52. qlock(&codeqlock);
  53. if(codes != nil) {
  54. qunlock(&codeqlock);
  55. return;
  56. }
  57. if((d = dirstat(codefile)) == nil || (fd = open(codefile, OREAD)) < 0) {
  58. qunlock(&codeqlock);
  59. return;
  60. }
  61. codes = malloc(1+d->length+1);
  62. if(codes == nil) {
  63. close(fd);
  64. qunlock(&codeqlock);
  65. free(d);
  66. return;
  67. }
  68. codes[0] = '\n'; /* for searches */
  69. n = readn(fd, codes+1, d->length);
  70. close(fd);
  71. free(d);
  72. if(n < 0) {
  73. free(codes);
  74. codes = nil;
  75. qunlock(&codeqlock);
  76. return;
  77. }
  78. codes[n] = '\0';
  79. qunlock(&codeqlock);
  80. }
  81. char*
  82. scsierror(int asc, int ascq)
  83. {
  84. char *p, *q;
  85. static char search[32];
  86. static char buf[128];
  87. getcodes();
  88. if(codes) {
  89. snprint(search, sizeof search, "\n%.2ux%.2ux ", asc, ascq);
  90. if(p = strstr(codes, search)) {
  91. p += 6;
  92. if((q = strchr(p, '\n')) == nil)
  93. q = p+strlen(p);
  94. snprint(buf, sizeof buf, "%.*s", (int)(q-p), p);
  95. return buf;
  96. }
  97. snprint(search, sizeof search, "\n%.2ux00", asc);
  98. if(p = strstr(codes, search)) {
  99. p += 6;
  100. if((q = strchr(p, '\n')) == nil)
  101. q = p+strlen(p);
  102. snprint(buf, sizeof buf, "(ascq #%.2ux) %.*s", ascq, (int)(q-p), p);
  103. return buf;
  104. }
  105. }
  106. snprint(buf, sizeof buf, "scsi #%.2ux %.2ux", asc, ascq);
  107. return buf;
  108. }
  109. static int
  110. _scsicmd(Scsi *s, uint8_t *cmd, int ccount, void *data, int dcount,
  111. int io, int dolock)
  112. {
  113. uint8_t resp[16];
  114. int n;
  115. int32_t status;
  116. if(dolock)
  117. qlock(s);
  118. if(write(s->rawfd, cmd, ccount) != ccount) {
  119. werrstr("cmd write: %r");
  120. if(dolock)
  121. qunlock(s);
  122. return -1;
  123. }
  124. switch(io){
  125. case Sread:
  126. n = read(s->rawfd, data, dcount);
  127. /* read toc errors are frequent and not very interesting */
  128. if(n < 0 && (scsiverbose == 1 ||
  129. scsiverbose == 2 && cmd[0] != Readtoc))
  130. fprint(2, "dat read: %r: cmd 0x%2.2uX\n", cmd[0]);
  131. break;
  132. case Swrite:
  133. n = write(s->rawfd, data, dcount);
  134. if(n != dcount && scsiverbose)
  135. fprint(2, "dat write: %r: cmd 0x%2.2uX\n", cmd[0]);
  136. break;
  137. default:
  138. case Snone:
  139. n = write(s->rawfd, resp, 0);
  140. if(n != 0 && scsiverbose)
  141. fprint(2, "none write: %r: cmd 0x%2.2uX\n", cmd[0]);
  142. break;
  143. }
  144. memset(resp, 0, sizeof(resp));
  145. if(read(s->rawfd, resp, sizeof(resp)) < 0) {
  146. werrstr("resp read: %r\n");
  147. if(dolock)
  148. qunlock(s);
  149. return -1;
  150. }
  151. if(dolock)
  152. qunlock(s);
  153. resp[sizeof(resp)-1] = '\0';
  154. status = atoi((char*)resp);
  155. if(status == 0)
  156. return n;
  157. werrstr("cmd %2.2uX: status %lX dcount %d n %d", cmd[0], status, dcount, n);
  158. return -1;
  159. }
  160. int
  161. scsicmd(Scsi *s, uint8_t *cmd, int ccount, void *data, int dcount, int io)
  162. {
  163. return _scsicmd(s, cmd, ccount, data, dcount, io, 1);
  164. }
  165. static int
  166. _scsiready(Scsi *s, int dolock)
  167. {
  168. char err[ERRMAX];
  169. uint8_t cmd[6], resp[16];
  170. int status, i;
  171. if(dolock)
  172. qlock(s);
  173. werrstr("");
  174. for(i=0; i<3; i++) {
  175. memset(cmd, 0, sizeof(cmd));
  176. cmd[0] = Testrdy; /* unit ready */
  177. if(write(s->rawfd, cmd, sizeof(cmd)) != sizeof(cmd)) {
  178. if(scsiverbose)
  179. fprint(2, "ur cmd write: %r\n");
  180. werrstr("short unit-ready raw write");
  181. continue;
  182. }
  183. write(s->rawfd, resp, 0);
  184. if(read(s->rawfd, resp, sizeof(resp)) < 0) {
  185. if(scsiverbose)
  186. fprint(2, "ur resp read: %r\n");
  187. continue;
  188. }
  189. resp[sizeof(resp)-1] = '\0';
  190. status = atoi((char*)resp);
  191. if(status == 0 || status == 0x02) {
  192. if(dolock)
  193. qunlock(s);
  194. return 0;
  195. }
  196. if(scsiverbose)
  197. fprint(2, "target: bad status: %x\n", status);
  198. }
  199. rerrstr(err, sizeof err);
  200. if(err[0] == '\0')
  201. werrstr("unit did not become ready");
  202. if(dolock)
  203. qunlock(s);
  204. return -1;
  205. }
  206. int
  207. scsiready(Scsi *s)
  208. {
  209. return _scsiready(s, 1);
  210. }
  211. int
  212. scsi(Scsi *s, uint8_t *cmd, int ccount, void *v, int dcount, int io)
  213. {
  214. uint8_t req[6], sense[255], *data;
  215. int tries, code, key, n;
  216. char *p;
  217. data = v;
  218. SET(key); SET(code);
  219. qlock(s);
  220. for(tries=0; tries<2; tries++) {
  221. n = _scsicmd(s, cmd, ccount, data, dcount, io, 0);
  222. if(n >= 0) {
  223. qunlock(s);
  224. return n;
  225. }
  226. /*
  227. * request sense
  228. */
  229. memset(req, 0, sizeof(req));
  230. req[0] = Reqsense;
  231. req[4] = sizeof(sense);
  232. memset(sense, 0xFF, sizeof(sense));
  233. if((n=_scsicmd(s, req, sizeof(req), sense, sizeof(sense), Sread, 0)) < 14)
  234. if(scsiverbose)
  235. fprint(2, "reqsense scsicmd %d: %r\n", n);
  236. if(_scsiready(s, 0) < 0)
  237. if(scsiverbose)
  238. fprint(2, "unit not ready\n");
  239. key = sense[2] & 0xf;
  240. code = sense[12]; /* asc */
  241. if(code == Recovnoecc || code == Recovecc) { /* recovered errors */
  242. qunlock(s);
  243. return dcount;
  244. }
  245. /* retry various odd cases */
  246. if(code == Newmedium && cmd[0] == Readtoc) {
  247. /* read toc and media changed */
  248. s->nchange++;
  249. s->changetime = time(0);
  250. } else if((cmd[0] == Write10 || cmd[0] == Writever10) &&
  251. key == Sensenotrdy &&
  252. code == Lunnotrdy && sense[13] == 0x08) {
  253. /* long write in progress, per mmc-6 */
  254. tries = 0;
  255. sleep(1);
  256. } else if(cmd[0] == Write10 || cmd[0] == Writever10)
  257. break; /* don't retry worm writes */
  258. }
  259. /* drive not ready, or medium not present */
  260. if(cmd[0] == Readtoc && key == Sensenotrdy &&
  261. (code == Nomedium || code == Lunnotrdy)) {
  262. s->changetime = 0;
  263. qunlock(s);
  264. return -1;
  265. }
  266. qunlock(s);
  267. if(cmd[0] == Readtoc && key == Sensebadreq && code == Badcdb)
  268. return -1; /* blank media */
  269. p = scsierror(code, sense[13]);
  270. werrstr("cmd #%.2ux: %s", cmd[0], p);
  271. if(scsiverbose)
  272. fprint(2, "scsi cmd #%.2ux: %.2ux %.2ux %.2ux: %s\n",
  273. cmd[0], key, code, sense[13], p);
  274. // if(key == Sensenone)
  275. // return dcount;
  276. return -1;
  277. }
  278. Scsi*
  279. openscsi(char *dev)
  280. {
  281. Scsi *s;
  282. int rawfd, ctlfd, l, n;
  283. char *name, *p, buf[512];
  284. l = strlen(dev)+1+3+1;
  285. name = malloc(l);
  286. if(name == nil)
  287. return nil;
  288. snprint(name, l, "%s/raw", dev);
  289. if((rawfd = open(name, ORDWR)) < 0) {
  290. free(name);
  291. return nil;
  292. }
  293. snprint(name, l, "%s/ctl", dev);
  294. if((ctlfd = open(name, ORDWR)) < 0) {
  295. Error:
  296. free(name);
  297. close(rawfd);
  298. return nil;
  299. }
  300. n = readn(ctlfd, buf, sizeof buf);
  301. close(ctlfd);
  302. if(n <= 0) {
  303. if(n == 0)
  304. werrstr("eof on %s", name);
  305. goto Error;
  306. }
  307. if(strncmp(buf, "inquiry ", 8) != 0 || (p = strchr(buf, '\n')) == nil) {
  308. werrstr("inquiry mal-formatted in %s", name);
  309. goto Error;
  310. }
  311. *p = '\0';
  312. free(name);
  313. name = nil;
  314. if((p = strdup(buf+8)) == nil)
  315. goto Error;
  316. s = mallocz(sizeof(*s), 1);
  317. if(s == nil) {
  318. Error1:
  319. free(p);
  320. goto Error;
  321. }
  322. s->rawfd = rawfd;
  323. s->inquire = p;
  324. s->changetime = time(0);
  325. if(scsiready(s) < 0)
  326. goto Error1;
  327. return s;
  328. }
  329. void
  330. closescsi(Scsi *s)
  331. {
  332. close(s->rawfd);
  333. free(s->inquire);
  334. free(s);
  335. }