devsd.c 31 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644
  1. /*
  2. * Storage Device.
  3. */
  4. #include "u.h"
  5. #include "../port/lib.h"
  6. #include "mem.h"
  7. #include "dat.h"
  8. #include "fns.h"
  9. #include "io.h"
  10. #include "ureg.h"
  11. #include "../port/error.h"
  12. #include "../port/sd.h"
  13. extern Dev sddevtab;
  14. extern SDifc* sdifc[];
  15. static char Echange[] = "media or partition has changed";
  16. static char devletters[] = "0123456789"
  17. "abcdefghijklmnopqrstuvwxyz"
  18. "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  19. static SDev *devs[sizeof devletters-1];
  20. static QLock devslock;
  21. enum {
  22. Rawcmd,
  23. Rawdata,
  24. Rawstatus,
  25. };
  26. enum {
  27. Qtopdir = 1, /* top level directory */
  28. Qtopbase,
  29. Qtopctl = Qtopbase,
  30. Qunitdir, /* directory per unit */
  31. Qunitbase,
  32. Qctl = Qunitbase,
  33. Qraw,
  34. Qpart,
  35. TypeLOG = 4,
  36. NType = (1<<TypeLOG),
  37. TypeMASK = (NType-1),
  38. TypeSHIFT = 0,
  39. PartLOG = 8,
  40. NPart = (1<<PartLOG),
  41. PartMASK = (NPart-1),
  42. PartSHIFT = TypeLOG,
  43. UnitLOG = 8,
  44. NUnit = (1<<UnitLOG),
  45. UnitMASK = (NUnit-1),
  46. UnitSHIFT = (PartLOG+TypeLOG),
  47. DevLOG = 8,
  48. NDev = (1 << DevLOG),
  49. DevMASK = (NDev-1),
  50. DevSHIFT = (UnitLOG+PartLOG+TypeLOG),
  51. Ncmd = 20,
  52. };
  53. #define TYPE(q) ((((ulong)(q).path)>>TypeSHIFT) & TypeMASK)
  54. #define PART(q) ((((ulong)(q).path)>>PartSHIFT) & PartMASK)
  55. #define UNIT(q) ((((ulong)(q).path)>>UnitSHIFT) & UnitMASK)
  56. #define DEV(q) ((((ulong)(q).path)>>DevSHIFT) & DevMASK)
  57. #define QID(d,u, p, t) (((d)<<DevSHIFT)|((u)<<UnitSHIFT)|\
  58. ((p)<<PartSHIFT)|((t)<<TypeSHIFT))
  59. static void
  60. sdaddpart(SDunit* unit, char* name, uvlong start, uvlong end)
  61. {
  62. SDpart *pp;
  63. int i, partno;
  64. /*
  65. * Check name not already used
  66. * and look for a free slot.
  67. */
  68. if(unit->part != nil){
  69. partno = -1;
  70. for(i = 0; i < unit->npart; i++){
  71. pp = &unit->part[i];
  72. if(!pp->valid){
  73. if(partno == -1)
  74. partno = i;
  75. break;
  76. }
  77. if(strcmp(name, pp->name) == 0){
  78. if(pp->start == start && pp->end == end)
  79. return;
  80. error(Ebadctl);
  81. }
  82. }
  83. }
  84. else{
  85. if((unit->part = malloc(sizeof(SDpart)*SDnpart)) == nil)
  86. error(Enomem);
  87. unit->npart = SDnpart;
  88. partno = 0;
  89. }
  90. /*
  91. * If no free slot found then increase the
  92. * array size (can't get here with unit->part == nil).
  93. */
  94. if(partno == -1){
  95. if(unit->npart >= NPart)
  96. error(Enomem);
  97. if((pp = malloc(sizeof(SDpart)*(unit->npart+SDnpart))) == nil)
  98. error(Enomem);
  99. memmove(pp, unit->part, sizeof(SDpart)*unit->npart);
  100. free(unit->part);
  101. unit->part = pp;
  102. partno = unit->npart;
  103. unit->npart += SDnpart;
  104. }
  105. /*
  106. * Check size and extent are valid.
  107. */
  108. if(start > end || end > unit->sectors)
  109. error(Eio);
  110. pp = &unit->part[partno];
  111. pp->start = start;
  112. pp->end = end;
  113. kstrdup(&pp->name, name);
  114. kstrdup(&pp->user, eve);
  115. pp->perm = 0640;
  116. pp->valid = 1;
  117. }
  118. static void
  119. sddelpart(SDunit* unit, char* name)
  120. {
  121. int i;
  122. SDpart *pp;
  123. /*
  124. * Look for the partition to delete.
  125. * Can't delete if someone still has it open.
  126. */
  127. pp = unit->part;
  128. for(i = 0; i < unit->npart; i++){
  129. if(strcmp(name, pp->name) == 0)
  130. break;
  131. pp++;
  132. }
  133. if(i >= unit->npart)
  134. error(Ebadctl);
  135. if(strcmp(up->user, pp->user) && !iseve())
  136. error(Eperm);
  137. pp->valid = 0;
  138. pp->vers++;
  139. }
  140. static void
  141. sdincvers(SDunit *unit)
  142. {
  143. int i;
  144. unit->vers++;
  145. if(unit->part){
  146. for(i = 0; i < unit->npart; i++){
  147. unit->part[i].valid = 0;
  148. unit->part[i].vers++;
  149. }
  150. }
  151. }
  152. static int
  153. sdinitpart(SDunit* unit)
  154. {
  155. int nf;
  156. uvlong start, end;
  157. char *f[4], *p, *q, buf[10];
  158. if(unit->sectors > 0){
  159. unit->sectors = unit->secsize = 0;
  160. sdincvers(unit);
  161. }
  162. if(unit->inquiry[0] & 0xC0)
  163. return 0;
  164. switch(unit->inquiry[0] & 0x1F){
  165. case 0x00: /* DA */
  166. case 0x04: /* WORM */
  167. case 0x05: /* CD-ROM */
  168. case 0x07: /* MO */
  169. break;
  170. default:
  171. return 0;
  172. }
  173. if(unit->dev->ifc->online)
  174. unit->dev->ifc->online(unit);
  175. if(unit->sectors){
  176. sdincvers(unit);
  177. sdaddpart(unit, "data", 0, unit->sectors);
  178. /*
  179. * Use partitions passed from boot program,
  180. * e.g.
  181. * sdC0part=dos 63 123123/plan9 123123 456456
  182. * This happens before /boot sets hostname so the
  183. * partitions will have the null-string for user.
  184. * The gen functions patch it up.
  185. */
  186. snprint(buf, sizeof buf, "%spart", unit->name);
  187. for(p = getconf(buf); p != nil; p = q){
  188. if(q = strchr(p, '/'))
  189. *q++ = '\0';
  190. nf = tokenize(p, f, nelem(f));
  191. if(nf < 3)
  192. continue;
  193. start = strtoull(f[1], 0, 0);
  194. end = strtoull(f[2], 0, 0);
  195. if(!waserror()){
  196. sdaddpart(unit, f[0], start, end);
  197. poperror();
  198. }
  199. }
  200. }
  201. return 1;
  202. }
  203. static int
  204. sdindex(int idno)
  205. {
  206. char *p;
  207. p = strchr(devletters, idno);
  208. if(p == nil)
  209. return -1;
  210. return p-devletters;
  211. }
  212. static SDev*
  213. sdgetdev(int idno)
  214. {
  215. SDev *sdev;
  216. int i;
  217. if((i = sdindex(idno)) < 0)
  218. return nil;
  219. qlock(&devslock);
  220. if(sdev = devs[i])
  221. incref(&sdev->r);
  222. qunlock(&devslock);
  223. return sdev;
  224. }
  225. static SDunit*
  226. sdgetunit(SDev* sdev, int subno)
  227. {
  228. SDunit *unit;
  229. char buf[32];
  230. /*
  231. * Associate a unit with a given device and sub-unit
  232. * number on that device.
  233. * The device will be probed if it has not already been
  234. * successfully accessed.
  235. */
  236. qlock(&sdev->unitlock);
  237. if(subno > sdev->nunit){
  238. qunlock(&sdev->unitlock);
  239. return nil;
  240. }
  241. unit = sdev->unit[subno];
  242. if(unit == nil){
  243. /*
  244. * Probe the unit only once. This decision
  245. * may be a little severe and reviewed later.
  246. */
  247. if(sdev->unitflg[subno]){
  248. qunlock(&sdev->unitlock);
  249. return nil;
  250. }
  251. if((unit = malloc(sizeof(SDunit))) == nil){
  252. qunlock(&sdev->unitlock);
  253. return nil;
  254. }
  255. sdev->unitflg[subno] = 1;
  256. snprint(buf, sizeof(buf), "%s%d", sdev->name, subno);
  257. kstrdup(&unit->name, buf);
  258. kstrdup(&unit->user, eve);
  259. unit->perm = 0555;
  260. unit->subno = subno;
  261. unit->dev = sdev;
  262. if(sdev->enabled == 0 && sdev->ifc->enable)
  263. sdev->ifc->enable(sdev);
  264. sdev->enabled = 1;
  265. /*
  266. * No need to lock anything here as this is only
  267. * called before the unit is made available in the
  268. * sdunit[] array.
  269. */
  270. if(unit->dev->ifc->verify(unit) == 0){
  271. qunlock(&sdev->unitlock);
  272. free(unit);
  273. return nil;
  274. }
  275. sdev->unit[subno] = unit;
  276. }
  277. qunlock(&sdev->unitlock);
  278. return unit;
  279. }
  280. static void
  281. sdreset(void)
  282. {
  283. int i;
  284. SDev *sdev;
  285. /*
  286. * Probe all known controller types and register any devices found.
  287. */
  288. for(i = 0; sdifc[i] != nil; i++){
  289. if(sdifc[i]->pnp == nil || (sdev = sdifc[i]->pnp()) == nil)
  290. continue;
  291. sdadddevs(sdev);
  292. }
  293. }
  294. void
  295. sdadddevs(SDev *sdev)
  296. {
  297. int i, j, id;
  298. SDev *next;
  299. for(; sdev; sdev=next){
  300. next = sdev->next;
  301. sdev->unit = (SDunit**)malloc(sdev->nunit * sizeof(SDunit*));
  302. sdev->unitflg = (int*)malloc(sdev->nunit * sizeof(int));
  303. if(sdev->unit == nil || sdev->unitflg == nil){
  304. print("sdadddevs: out of memory\n");
  305. giveup:
  306. free(sdev->unit);
  307. free(sdev->unitflg);
  308. if(sdev->ifc->clear)
  309. sdev->ifc->clear(sdev);
  310. free(sdev);
  311. continue;
  312. }
  313. id = sdindex(sdev->idno);
  314. if(id == -1){
  315. print("sdadddevs: bad id number %d (%C)\n", id, id);
  316. goto giveup;
  317. }
  318. qlock(&devslock);
  319. for(i=0; i<nelem(devs); i++){
  320. if(devs[j = (id+i)%nelem(devs)] == nil){
  321. sdev->idno = devletters[j];
  322. devs[j] = sdev;
  323. snprint(sdev->name, sizeof sdev->name, "sd%c", devletters[j]);
  324. break;
  325. }
  326. }
  327. qunlock(&devslock);
  328. if(i == nelem(devs)){
  329. print("sdadddevs: out of device letters\n");
  330. goto giveup;
  331. }
  332. }
  333. }
  334. // void
  335. // sdrmdevs(SDev *sdev)
  336. // {
  337. // char buf[2];
  338. //
  339. // snprint(buf, sizeof buf, "%c", sdev->idno);
  340. // unconfigure(buf);
  341. // }
  342. static int
  343. sd2gen(Chan* c, int i, Dir* dp)
  344. {
  345. Qid q;
  346. uvlong l;
  347. SDpart *pp;
  348. SDperm *perm;
  349. SDunit *unit;
  350. SDev *sdev;
  351. int rv;
  352. sdev = sdgetdev(DEV(c->qid));
  353. assert(sdev);
  354. unit = sdev->unit[UNIT(c->qid)];
  355. rv = -1;
  356. switch(i){
  357. case Qctl:
  358. mkqid(&q, QID(DEV(c->qid), UNIT(c->qid), PART(c->qid), Qctl),
  359. unit->vers, QTFILE);
  360. perm = &unit->ctlperm;
  361. if(emptystr(perm->user)){
  362. kstrdup(&perm->user, eve);
  363. perm->perm = 0640;
  364. }
  365. devdir(c, q, "ctl", 0, perm->user, perm->perm, dp);
  366. rv = 1;
  367. break;
  368. case Qraw:
  369. mkqid(&q, QID(DEV(c->qid), UNIT(c->qid), PART(c->qid), Qraw),
  370. unit->vers, QTFILE);
  371. perm = &unit->rawperm;
  372. if(emptystr(perm->user)){
  373. kstrdup(&perm->user, eve);
  374. perm->perm = DMEXCL|0600;
  375. }
  376. devdir(c, q, "raw", 0, perm->user, perm->perm, dp);
  377. rv = 1;
  378. break;
  379. case Qpart:
  380. pp = &unit->part[PART(c->qid)];
  381. l = (pp->end - pp->start) * unit->secsize;
  382. mkqid(&q, QID(DEV(c->qid), UNIT(c->qid), PART(c->qid), Qpart),
  383. unit->vers+pp->vers, QTFILE);
  384. if(emptystr(pp->user))
  385. kstrdup(&pp->user, eve);
  386. devdir(c, q, pp->name, l, pp->user, pp->perm, dp);
  387. rv = 1;
  388. break;
  389. }
  390. decref(&sdev->r);
  391. return rv;
  392. }
  393. static int
  394. sd1gen(Chan* c, int i, Dir* dp)
  395. {
  396. Qid q;
  397. switch(i){
  398. case Qtopctl:
  399. mkqid(&q, QID(0, 0, 0, Qtopctl), 0, QTFILE);
  400. devdir(c, q, "sdctl", 0, eve, 0640, dp);
  401. return 1;
  402. }
  403. return -1;
  404. }
  405. static int
  406. sdgen(Chan* c, char*, Dirtab*, int, int s, Dir* dp)
  407. {
  408. Qid q;
  409. uvlong l;
  410. int i, r;
  411. SDpart *pp;
  412. SDunit *unit;
  413. SDev *sdev;
  414. switch(TYPE(c->qid)){
  415. case Qtopdir:
  416. if(s == DEVDOTDOT){
  417. mkqid(&q, QID(0, 0, 0, Qtopdir), 0, QTDIR);
  418. sprint(up->genbuf, "#%C", sddevtab.dc);
  419. devdir(c, q, up->genbuf, 0, eve, 0555, dp);
  420. return 1;
  421. }
  422. if(s+Qtopbase < Qunitdir)
  423. return sd1gen(c, s+Qtopbase, dp);
  424. s -= (Qunitdir-Qtopbase);
  425. qlock(&devslock);
  426. for(i=0; i<nelem(devs); i++){
  427. if(devs[i]){
  428. if(s < devs[i]->nunit)
  429. break;
  430. s -= devs[i]->nunit;
  431. }
  432. }
  433. if(i == nelem(devs)){
  434. /* Run off the end of the list */
  435. qunlock(&devslock);
  436. return -1;
  437. }
  438. if((sdev = devs[i]) == nil){
  439. qunlock(&devslock);
  440. return 0;
  441. }
  442. incref(&sdev->r);
  443. qunlock(&devslock);
  444. if((unit = sdev->unit[s]) == nil)
  445. if((unit = sdgetunit(sdev, s)) == nil){
  446. decref(&sdev->r);
  447. return 0;
  448. }
  449. mkqid(&q, QID(sdev->idno, s, 0, Qunitdir), 0, QTDIR);
  450. if(emptystr(unit->user))
  451. kstrdup(&unit->user, eve);
  452. devdir(c, q, unit->name, 0, unit->user, unit->perm, dp);
  453. decref(&sdev->r);
  454. return 1;
  455. case Qunitdir:
  456. if(s == DEVDOTDOT){
  457. mkqid(&q, QID(0, 0, 0, Qtopdir), 0, QTDIR);
  458. sprint(up->genbuf, "#%C", sddevtab.dc);
  459. devdir(c, q, up->genbuf, 0, eve, 0555, dp);
  460. return 1;
  461. }
  462. if((sdev = sdgetdev(DEV(c->qid))) == nil){
  463. devdir(c, c->qid, "unavailable", 0, eve, 0, dp);
  464. return 1;
  465. }
  466. unit = sdev->unit[UNIT(c->qid)];
  467. qlock(&unit->ctl);
  468. /*
  469. * Check for media change.
  470. * If one has already been detected, sectors will be zero.
  471. * If there is one waiting to be detected, online
  472. * will return > 1.
  473. * Online is a bit of a large hammer but does the job.
  474. */
  475. if(unit->sectors == 0
  476. || (unit->dev->ifc->online && unit->dev->ifc->online(unit) > 1))
  477. sdinitpart(unit);
  478. i = s+Qunitbase;
  479. if(i < Qpart){
  480. r = sd2gen(c, i, dp);
  481. qunlock(&unit->ctl);
  482. decref(&sdev->r);
  483. return r;
  484. }
  485. i -= Qpart;
  486. if(unit->part == nil || i >= unit->npart){
  487. qunlock(&unit->ctl);
  488. decref(&sdev->r);
  489. break;
  490. }
  491. pp = &unit->part[i];
  492. if(!pp->valid){
  493. qunlock(&unit->ctl);
  494. decref(&sdev->r);
  495. return 0;
  496. }
  497. l = (pp->end - pp->start) * unit->secsize;
  498. mkqid(&q, QID(DEV(c->qid), UNIT(c->qid), i, Qpart),
  499. unit->vers+pp->vers, QTFILE);
  500. if(emptystr(pp->user))
  501. kstrdup(&pp->user, eve);
  502. devdir(c, q, pp->name, l, pp->user, pp->perm, dp);
  503. qunlock(&unit->ctl);
  504. decref(&sdev->r);
  505. return 1;
  506. case Qraw:
  507. case Qctl:
  508. case Qpart:
  509. if((sdev = sdgetdev(DEV(c->qid))) == nil){
  510. devdir(c, q, "unavailable", 0, eve, 0, dp);
  511. return 1;
  512. }
  513. unit = sdev->unit[UNIT(c->qid)];
  514. qlock(&unit->ctl);
  515. r = sd2gen(c, TYPE(c->qid), dp);
  516. qunlock(&unit->ctl);
  517. decref(&sdev->r);
  518. return r;
  519. case Qtopctl:
  520. return sd1gen(c, TYPE(c->qid), dp);
  521. default:
  522. break;
  523. }
  524. return -1;
  525. }
  526. static Chan*
  527. sdattach(char* spec)
  528. {
  529. Chan *c;
  530. char *p;
  531. SDev *sdev;
  532. int idno, subno;
  533. if(*spec == '\0'){
  534. c = devattach(sddevtab.dc, spec);
  535. mkqid(&c->qid, QID(0, 0, 0, Qtopdir), 0, QTDIR);
  536. return c;
  537. }
  538. if(spec[0] != 's' || spec[1] != 'd')
  539. error(Ebadspec);
  540. idno = spec[2];
  541. subno = strtol(&spec[3], &p, 0);
  542. if(p == &spec[3])
  543. error(Ebadspec);
  544. if((sdev=sdgetdev(idno)) == nil)
  545. error(Enonexist);
  546. if(sdgetunit(sdev, subno) == nil){
  547. decref(&sdev->r);
  548. error(Enonexist);
  549. }
  550. c = devattach(sddevtab.dc, spec);
  551. mkqid(&c->qid, QID(sdev->idno, subno, 0, Qunitdir), 0, QTDIR);
  552. c->dev = (sdev->idno << UnitLOG) + subno;
  553. decref(&sdev->r);
  554. return c;
  555. }
  556. static Walkqid*
  557. sdwalk(Chan* c, Chan* nc, char** name, int nname)
  558. {
  559. return devwalk(c, nc, name, nname, nil, 0, sdgen);
  560. }
  561. static int
  562. sdstat(Chan* c, uchar* db, int n)
  563. {
  564. return devstat(c, db, n, nil, 0, sdgen);
  565. }
  566. static Chan*
  567. sdopen(Chan* c, int omode)
  568. {
  569. SDpart *pp;
  570. SDunit *unit;
  571. SDev *sdev;
  572. uchar tp;
  573. c = devopen(c, omode, 0, 0, sdgen);
  574. if((tp = TYPE(c->qid)) != Qctl && tp != Qraw && tp != Qpart)
  575. return c;
  576. sdev = sdgetdev(DEV(c->qid));
  577. if(sdev == nil)
  578. error(Enonexist);
  579. unit = sdev->unit[UNIT(c->qid)];
  580. switch(TYPE(c->qid)){
  581. case Qctl:
  582. c->qid.vers = unit->vers;
  583. break;
  584. case Qraw:
  585. c->qid.vers = unit->vers;
  586. if(tas(&unit->rawinuse) != 0){
  587. c->flag &= ~COPEN;
  588. decref(&sdev->r);
  589. error(Einuse);
  590. }
  591. unit->state = Rawcmd;
  592. break;
  593. case Qpart:
  594. qlock(&unit->ctl);
  595. if(waserror()){
  596. qunlock(&unit->ctl);
  597. c->flag &= ~COPEN;
  598. decref(&sdev->r);
  599. nexterror();
  600. }
  601. pp = &unit->part[PART(c->qid)];
  602. c->qid.vers = unit->vers+pp->vers;
  603. qunlock(&unit->ctl);
  604. poperror();
  605. break;
  606. }
  607. decref(&sdev->r);
  608. return c;
  609. }
  610. static void
  611. sdclose(Chan* c)
  612. {
  613. SDunit *unit;
  614. SDev *sdev;
  615. if(c->qid.type & QTDIR)
  616. return;
  617. if(!(c->flag & COPEN))
  618. return;
  619. switch(TYPE(c->qid)){
  620. default:
  621. break;
  622. case Qraw:
  623. sdev = sdgetdev(DEV(c->qid));
  624. if(sdev){
  625. unit = sdev->unit[UNIT(c->qid)];
  626. unit->rawinuse = 0;
  627. decref(&sdev->r);
  628. }
  629. break;
  630. }
  631. }
  632. static long
  633. sdbio(Chan* c, int write, char* a, long len, uvlong off)
  634. {
  635. int nchange;
  636. long l;
  637. uchar *b;
  638. SDpart *pp;
  639. SDunit *unit;
  640. SDev *sdev;
  641. ulong max, nb, offset;
  642. uvlong bno;
  643. sdev = sdgetdev(DEV(c->qid));
  644. if(sdev == nil){
  645. decref(&sdev->r);
  646. error(Enonexist);
  647. }
  648. unit = sdev->unit[UNIT(c->qid)];
  649. if(unit == nil)
  650. error(Enonexist);
  651. nchange = 0;
  652. qlock(&unit->ctl);
  653. while(waserror()){
  654. /* notification of media change; go around again */
  655. if(strcmp(up->errstr, Eio) == 0 && unit->sectors == 0 && nchange++ == 0){
  656. sdinitpart(unit);
  657. continue;
  658. }
  659. /* other errors; give up */
  660. qunlock(&unit->ctl);
  661. decref(&sdev->r);
  662. nexterror();
  663. }
  664. pp = &unit->part[PART(c->qid)];
  665. if(unit->vers+pp->vers != c->qid.vers)
  666. error(Echange);
  667. /*
  668. * Check the request is within bounds.
  669. * Removeable drives are locked throughout the I/O
  670. * in case the media changes unexpectedly.
  671. * Non-removeable drives are not locked during the I/O
  672. * to allow the hardware to optimise if it can; this is
  673. * a little fast and loose.
  674. * It's assumed that non-removeable media parameters
  675. * (sectors, secsize) can't change once the drive has
  676. * been brought online.
  677. */
  678. bno = (off/unit->secsize) + pp->start;
  679. nb = ((off+len+unit->secsize-1)/unit->secsize) + pp->start - bno;
  680. max = SDmaxio/unit->secsize;
  681. if(nb > max)
  682. nb = max;
  683. if(bno+nb > pp->end)
  684. nb = pp->end - bno;
  685. if(bno >= pp->end || nb == 0){
  686. if(write)
  687. error(Eio);
  688. qunlock(&unit->ctl);
  689. decref(&sdev->r);
  690. poperror();
  691. return 0;
  692. }
  693. if(!(unit->inquiry[1] & 0x80)){
  694. qunlock(&unit->ctl);
  695. poperror();
  696. }
  697. b = sdmalloc(nb*unit->secsize);
  698. if(b == nil)
  699. error(Enomem);
  700. if(waserror()){
  701. sdfree(b);
  702. if(!(unit->inquiry[1] & 0x80))
  703. decref(&sdev->r); /* gadverdamme! */
  704. nexterror();
  705. }
  706. offset = off%unit->secsize;
  707. if(offset+len > nb*unit->secsize)
  708. len = nb*unit->secsize - offset;
  709. if(write){
  710. if(offset || (len%unit->secsize)){
  711. l = unit->dev->ifc->bio(unit, 0, 0, b, nb, bno);
  712. if(l < 0)
  713. error(Eio);
  714. if(l < (nb*unit->secsize)){
  715. nb = l/unit->secsize;
  716. l = nb*unit->secsize - offset;
  717. if(len > l)
  718. len = l;
  719. }
  720. }
  721. memmove(b+offset, a, len);
  722. l = unit->dev->ifc->bio(unit, 0, 1, b, nb, bno);
  723. if(l < 0)
  724. error(Eio);
  725. if(l < offset)
  726. len = 0;
  727. else if(len > l - offset)
  728. len = l - offset;
  729. }
  730. else{
  731. l = unit->dev->ifc->bio(unit, 0, 0, b, nb, bno);
  732. if(l < 0)
  733. error(Eio);
  734. if(l < offset)
  735. len = 0;
  736. else if(len > l - offset)
  737. len = l - offset;
  738. memmove(a, b+offset, len);
  739. }
  740. sdfree(b);
  741. poperror();
  742. if(unit->inquiry[1] & 0x80){
  743. qunlock(&unit->ctl);
  744. poperror();
  745. }
  746. decref(&sdev->r);
  747. return len;
  748. }
  749. static long
  750. sdrio(SDreq* r, void* a, long n)
  751. {
  752. void *data;
  753. if(n >= SDmaxio || n < 0)
  754. error(Etoobig);
  755. data = nil;
  756. if(n){
  757. if((data = sdmalloc(n)) == nil)
  758. error(Enomem);
  759. if(r->write)
  760. memmove(data, a, n);
  761. }
  762. r->data = data;
  763. r->dlen = n;
  764. if(waserror()){
  765. sdfree(data);
  766. r->data = nil;
  767. nexterror();
  768. }
  769. if(r->unit->dev->ifc->rio(r) != SDok)
  770. error(Eio);
  771. if(!r->write && r->rlen > 0)
  772. memmove(a, data, r->rlen);
  773. sdfree(data);
  774. r->data = nil;
  775. poperror();
  776. return r->rlen;
  777. }
  778. /*
  779. * SCSI simulation for non-SCSI devices
  780. */
  781. int
  782. sdsetsense(SDreq *r, int status, int key, int asc, int ascq)
  783. {
  784. int len;
  785. SDunit *unit;
  786. unit = r->unit;
  787. unit->sense[2] = key;
  788. unit->sense[12] = asc;
  789. unit->sense[13] = ascq;
  790. r->status = status;
  791. if(status == SDcheck && !(r->flags & SDnosense)){
  792. /* request sense case from sdfakescsi */
  793. len = sizeof unit->sense;
  794. if(len > sizeof r->sense-1)
  795. len = sizeof r->sense-1;
  796. memmove(r->sense, unit->sense, len);
  797. unit->sense[2] = 0;
  798. unit->sense[12] = 0;
  799. unit->sense[13] = 0;
  800. r->flags |= SDvalidsense;
  801. return SDok;
  802. }
  803. return status;
  804. }
  805. int
  806. sdmodesense(SDreq *r, uchar *cmd, void *info, int ilen)
  807. {
  808. int len;
  809. uchar *data;
  810. /*
  811. * Fake a vendor-specific request with page code 0,
  812. * return the drive info.
  813. */
  814. if((cmd[2] & 0x3F) != 0 && (cmd[2] & 0x3F) != 0x3F)
  815. return sdsetsense(r, SDcheck, 0x05, 0x24, 0);
  816. len = (cmd[7]<<8)|cmd[8];
  817. if(len == 0)
  818. return SDok;
  819. if(len < 8+ilen)
  820. return sdsetsense(r, SDcheck, 0x05, 0x1A, 0);
  821. if(r->data == nil || r->dlen < len)
  822. return sdsetsense(r, SDcheck, 0x05, 0x20, 1);
  823. data = r->data;
  824. memset(data, 0, 8);
  825. data[0] = ilen>>8;
  826. data[1] = ilen;
  827. if(ilen)
  828. memmove(data+8, info, ilen);
  829. r->rlen = 8+ilen;
  830. return sdsetsense(r, SDok, 0, 0, 0);
  831. }
  832. int
  833. sdfakescsi(SDreq *r, void *info, int ilen)
  834. {
  835. uchar *cmd, *p;
  836. uvlong len;
  837. SDunit *unit;
  838. cmd = r->cmd;
  839. r->rlen = 0;
  840. unit = r->unit;
  841. /*
  842. * Rewrite read(6)/write(6) into read(10)/write(10).
  843. */
  844. switch(cmd[0]){
  845. case 0x08: /* read */
  846. case 0x0A: /* write */
  847. cmd[9] = 0;
  848. cmd[8] = cmd[4];
  849. cmd[7] = 0;
  850. cmd[6] = 0;
  851. cmd[5] = cmd[3];
  852. cmd[4] = cmd[2];
  853. cmd[3] = cmd[1] & 0x0F;
  854. cmd[2] = 0;
  855. cmd[1] &= 0xE0;
  856. cmd[0] |= 0x20;
  857. break;
  858. }
  859. /*
  860. * Map SCSI commands into ATA commands for discs.
  861. * Fail any command with a LUN except INQUIRY which
  862. * will return 'logical unit not supported'.
  863. */
  864. if((cmd[1]>>5) && cmd[0] != 0x12)
  865. return sdsetsense(r, SDcheck, 0x05, 0x25, 0);
  866. switch(cmd[0]){
  867. default:
  868. return sdsetsense(r, SDcheck, 0x05, 0x20, 0);
  869. case 0x00: /* test unit ready */
  870. return sdsetsense(r, SDok, 0, 0, 0);
  871. case 0x03: /* request sense */
  872. if(cmd[4] < sizeof unit->sense)
  873. len = cmd[4];
  874. else
  875. len = sizeof unit->sense;
  876. if(r->data && r->dlen >= len){
  877. memmove(r->data, unit->sense, len);
  878. r->rlen = len;
  879. }
  880. return sdsetsense(r, SDok, 0, 0, 0);
  881. case 0x12: /* inquiry */
  882. if(cmd[4] < sizeof unit->inquiry)
  883. len = cmd[4];
  884. else
  885. len = sizeof unit->inquiry;
  886. if(r->data && r->dlen >= len){
  887. memmove(r->data, unit->inquiry, len);
  888. r->rlen = len;
  889. }
  890. return sdsetsense(r, SDok, 0, 0, 0);
  891. case 0x1B: /* start/stop unit */
  892. /*
  893. * nop for now, can use power management later.
  894. */
  895. return sdsetsense(r, SDok, 0, 0, 0);
  896. case 0x25: /* read capacity */
  897. if((cmd[1] & 0x01) || cmd[2] || cmd[3])
  898. return sdsetsense(r, SDcheck, 0x05, 0x24, 0);
  899. if(r->data == nil || r->dlen < 8)
  900. return sdsetsense(r, SDcheck, 0x05, 0x20, 1);
  901. /*
  902. * Read capacity returns the LBA of the last sector.
  903. */
  904. len = unit->sectors - 1;
  905. p = r->data;
  906. *p++ = len>>24;
  907. *p++ = len>>16;
  908. *p++ = len>>8;
  909. *p++ = len;
  910. len = 512;
  911. *p++ = len>>24;
  912. *p++ = len>>16;
  913. *p++ = len>>8;
  914. *p++ = len;
  915. r->rlen = p - (uchar*)r->data;
  916. return sdsetsense(r, SDok, 0, 0, 0);
  917. case 0x9E: /* long read capacity */
  918. if((cmd[1] & 0x01) || cmd[2] || cmd[3])
  919. return sdsetsense(r, SDcheck, 0x05, 0x24, 0);
  920. if(r->data == nil || r->dlen < 8)
  921. return sdsetsense(r, SDcheck, 0x05, 0x20, 1);
  922. /*
  923. * Read capcity returns the LBA of the last sector.
  924. */
  925. len = unit->sectors - 1;
  926. p = r->data;
  927. *p++ = len>>56;
  928. *p++ = len>>48;
  929. *p++ = len>>40;
  930. *p++ = len>>32;
  931. *p++ = len>>24;
  932. *p++ = len>>16;
  933. *p++ = len>>8;
  934. *p++ = len;
  935. len = 512;
  936. *p++ = len>>24;
  937. *p++ = len>>16;
  938. *p++ = len>>8;
  939. *p++ = len;
  940. r->rlen = p - (uchar*)r->data;
  941. return sdsetsense(r, SDok, 0, 0, 0);
  942. case 0x5A: /* mode sense */
  943. return sdmodesense(r, cmd, info, ilen);
  944. case 0x28: /* read */
  945. case 0x2A: /* write */
  946. case 0x88: /* read16 */
  947. case 0x8a: /* write16 */
  948. return SDnostatus;
  949. }
  950. }
  951. static long
  952. sdread(Chan *c, void *a, long n, vlong off)
  953. {
  954. char *p, *e, *buf;
  955. SDpart *pp;
  956. SDunit *unit;
  957. SDev *sdev;
  958. ulong offset;
  959. int i, l, m, status;
  960. offset = off;
  961. switch(TYPE(c->qid)){
  962. default:
  963. error(Eperm);
  964. case Qtopctl:
  965. m = 64*1024; /* room for register dumps */
  966. p = buf = malloc(m);
  967. assert(p);
  968. e = p + m;
  969. qlock(&devslock);
  970. for(i = 0; i < nelem(devs); i++){
  971. sdev = devs[i];
  972. if(sdev && sdev->ifc->rtopctl)
  973. p = sdev->ifc->rtopctl(sdev, p, e);
  974. }
  975. qunlock(&devslock);
  976. n = readstr(off, a, n, buf);
  977. free(buf);
  978. return n;
  979. case Qtopdir:
  980. case Qunitdir:
  981. return devdirread(c, a, n, 0, 0, sdgen);
  982. case Qctl:
  983. sdev = sdgetdev(DEV(c->qid));
  984. if(sdev == nil)
  985. error(Enonexist);
  986. unit = sdev->unit[UNIT(c->qid)];
  987. m = 16*1024; /* room for register dumps */
  988. p = malloc(m);
  989. l = snprint(p, m, "inquiry %.48s\n",
  990. (char*)unit->inquiry+8);
  991. qlock(&unit->ctl);
  992. /*
  993. * If there's a device specific routine it must
  994. * provide all information pertaining to night geometry
  995. * and the garscadden trains.
  996. */
  997. if(unit->dev->ifc->rctl)
  998. l += unit->dev->ifc->rctl(unit, p+l, m-l);
  999. if(unit->sectors == 0)
  1000. sdinitpart(unit);
  1001. if(unit->sectors){
  1002. if(unit->dev->ifc->rctl == nil)
  1003. l += snprint(p+l, m-l,
  1004. "geometry %llud %lud\n",
  1005. unit->sectors, unit->secsize);
  1006. pp = unit->part;
  1007. for(i = 0; i < unit->npart; i++){
  1008. if(pp->valid)
  1009. l += snprint(p+l, m-l,
  1010. "part %s %llud %llud\n",
  1011. pp->name, pp->start, pp->end);
  1012. pp++;
  1013. }
  1014. }
  1015. qunlock(&unit->ctl);
  1016. decref(&sdev->r);
  1017. l = readstr(offset, a, n, p);
  1018. free(p);
  1019. return l;
  1020. case Qraw:
  1021. sdev = sdgetdev(DEV(c->qid));
  1022. if(sdev == nil)
  1023. error(Enonexist);
  1024. unit = sdev->unit[UNIT(c->qid)];
  1025. qlock(&unit->raw);
  1026. if(waserror()){
  1027. qunlock(&unit->raw);
  1028. decref(&sdev->r);
  1029. nexterror();
  1030. }
  1031. if(unit->state == Rawdata){
  1032. unit->state = Rawstatus;
  1033. i = sdrio(unit->req, a, n);
  1034. }
  1035. else if(unit->state == Rawstatus){
  1036. status = unit->req->status;
  1037. unit->state = Rawcmd;
  1038. free(unit->req);
  1039. unit->req = nil;
  1040. i = readnum(0, a, n, status, NUMSIZE);
  1041. } else
  1042. i = 0;
  1043. qunlock(&unit->raw);
  1044. decref(&sdev->r);
  1045. poperror();
  1046. return i;
  1047. case Qpart:
  1048. return sdbio(c, 0, a, n, off);
  1049. }
  1050. }
  1051. static void legacytopctl(Cmdbuf*);
  1052. static long
  1053. sdwrite(Chan* c, void* a, long n, vlong off)
  1054. {
  1055. char *f0;
  1056. int i;
  1057. uvlong end, start;
  1058. Cmdbuf *cb;
  1059. SDifc *ifc;
  1060. SDreq *req;
  1061. SDunit *unit;
  1062. SDev *sdev;
  1063. switch(TYPE(c->qid)){
  1064. default:
  1065. error(Eperm);
  1066. case Qtopctl:
  1067. cb = parsecmd(a, n);
  1068. if(waserror()){
  1069. free(cb);
  1070. nexterror();
  1071. }
  1072. if(cb->nf == 0)
  1073. error("empty control message");
  1074. f0 = cb->f[0];
  1075. cb->f++;
  1076. cb->nf--;
  1077. if(strcmp(f0, "config") == 0){
  1078. /* wormhole into ugly legacy interface */
  1079. legacytopctl(cb);
  1080. poperror();
  1081. free(cb);
  1082. break;
  1083. }
  1084. /*
  1085. * "ata arg..." invokes sdifc[i]->wtopctl(nil, cb),
  1086. * where sdifc[i]->name=="ata" and cb contains the args.
  1087. */
  1088. ifc = nil;
  1089. sdev = nil;
  1090. for(i=0; sdifc[i]; i++){
  1091. if(strcmp(sdifc[i]->name, f0) == 0){
  1092. ifc = sdifc[i];
  1093. sdev = nil;
  1094. goto subtopctl;
  1095. }
  1096. }
  1097. /*
  1098. * "sd1 arg..." invokes sdifc[i]->wtopctl(sdev, cb),
  1099. * where sdifc[i] and sdev match controller letter "1",
  1100. * and cb contains the args.
  1101. */
  1102. if(f0[0]=='s' && f0[1]=='d' && f0[2] && f0[3] == 0){
  1103. if((sdev = sdgetdev(f0[2])) != nil){
  1104. ifc = sdev->ifc;
  1105. goto subtopctl;
  1106. }
  1107. }
  1108. error("unknown interface");
  1109. subtopctl:
  1110. if(waserror()){
  1111. if(sdev)
  1112. decref(&sdev->r);
  1113. nexterror();
  1114. }
  1115. if(ifc->wtopctl)
  1116. ifc->wtopctl(sdev, cb);
  1117. else
  1118. error(Ebadctl);
  1119. poperror();
  1120. poperror();
  1121. if (sdev)
  1122. decref(&sdev->r);
  1123. free(cb);
  1124. break;
  1125. case Qctl:
  1126. cb = parsecmd(a, n);
  1127. sdev = sdgetdev(DEV(c->qid));
  1128. if(sdev == nil)
  1129. error(Enonexist);
  1130. unit = sdev->unit[UNIT(c->qid)];
  1131. qlock(&unit->ctl);
  1132. if(waserror()){
  1133. qunlock(&unit->ctl);
  1134. decref(&sdev->r);
  1135. free(cb);
  1136. nexterror();
  1137. }
  1138. if(unit->vers != c->qid.vers)
  1139. error(Echange);
  1140. if(cb->nf < 1)
  1141. error(Ebadctl);
  1142. if(strcmp(cb->f[0], "part") == 0){
  1143. if(cb->nf != 4)
  1144. error(Ebadctl);
  1145. if(unit->sectors == 0 && !sdinitpart(unit))
  1146. error(Eio);
  1147. start = strtoull(cb->f[2], 0, 0);
  1148. end = strtoull(cb->f[3], 0, 0);
  1149. sdaddpart(unit, cb->f[1], start, end);
  1150. }
  1151. else if(strcmp(cb->f[0], "delpart") == 0){
  1152. if(cb->nf != 2 || unit->part == nil)
  1153. error(Ebadctl);
  1154. sddelpart(unit, cb->f[1]);
  1155. }
  1156. else if(unit->dev->ifc->wctl)
  1157. unit->dev->ifc->wctl(unit, cb);
  1158. else
  1159. error(Ebadctl);
  1160. qunlock(&unit->ctl);
  1161. decref(&sdev->r);
  1162. poperror();
  1163. free(cb);
  1164. break;
  1165. case Qraw:
  1166. sdev = sdgetdev(DEV(c->qid));
  1167. if(sdev == nil)
  1168. error(Enonexist);
  1169. unit = sdev->unit[UNIT(c->qid)];
  1170. qlock(&unit->raw);
  1171. if(waserror()){
  1172. qunlock(&unit->raw);
  1173. decref(&sdev->r);
  1174. nexterror();
  1175. }
  1176. switch(unit->state){
  1177. case Rawcmd:
  1178. if(n < 6 || n > sizeof(req->cmd))
  1179. error(Ebadarg);
  1180. if((req = malloc(sizeof(SDreq))) == nil)
  1181. error(Enomem);
  1182. req->unit = unit;
  1183. memmove(req->cmd, a, n);
  1184. req->clen = n;
  1185. req->flags = SDnosense;
  1186. req->status = ~0;
  1187. unit->req = req;
  1188. unit->state = Rawdata;
  1189. break;
  1190. case Rawstatus:
  1191. unit->state = Rawcmd;
  1192. free(unit->req);
  1193. unit->req = nil;
  1194. error(Ebadusefd);
  1195. case Rawdata:
  1196. unit->state = Rawstatus;
  1197. unit->req->write = 1;
  1198. n = sdrio(unit->req, a, n);
  1199. }
  1200. qunlock(&unit->raw);
  1201. decref(&sdev->r);
  1202. poperror();
  1203. break;
  1204. case Qpart:
  1205. return sdbio(c, 1, a, n, off);
  1206. }
  1207. return n;
  1208. }
  1209. static int
  1210. sdwstat(Chan* c, uchar* dp, int n)
  1211. {
  1212. Dir *d;
  1213. SDpart *pp;
  1214. SDperm *perm;
  1215. SDunit *unit;
  1216. SDev *sdev;
  1217. if(c->qid.type & QTDIR)
  1218. error(Eperm);
  1219. sdev = sdgetdev(DEV(c->qid));
  1220. if(sdev == nil)
  1221. error(Enonexist);
  1222. unit = sdev->unit[UNIT(c->qid)];
  1223. qlock(&unit->ctl);
  1224. d = nil;
  1225. if(waserror()){
  1226. free(d);
  1227. qunlock(&unit->ctl);
  1228. decref(&sdev->r);
  1229. nexterror();
  1230. }
  1231. switch(TYPE(c->qid)){
  1232. default:
  1233. error(Eperm);
  1234. case Qctl:
  1235. perm = &unit->ctlperm;
  1236. break;
  1237. case Qraw:
  1238. perm = &unit->rawperm;
  1239. break;
  1240. case Qpart:
  1241. pp = &unit->part[PART(c->qid)];
  1242. if(unit->vers+pp->vers != c->qid.vers)
  1243. error(Enonexist);
  1244. perm = &pp->SDperm;
  1245. break;
  1246. }
  1247. if(strcmp(up->user, perm->user) && !iseve())
  1248. error(Eperm);
  1249. d = smalloc(sizeof(Dir)+n);
  1250. n = convM2D(dp, n, &d[0], (char*)&d[1]);
  1251. if(n == 0)
  1252. error(Eshortstat);
  1253. if(!emptystr(d[0].uid))
  1254. kstrdup(&perm->user, d[0].uid);
  1255. if(d[0].mode != ~0UL)
  1256. perm->perm = (perm->perm & ~0777) | (d[0].mode & 0777);
  1257. free(d);
  1258. qunlock(&unit->ctl);
  1259. decref(&sdev->r);
  1260. poperror();
  1261. return n;
  1262. }
  1263. static int
  1264. configure(char* spec, DevConf* cf)
  1265. {
  1266. SDev *s, *sdev;
  1267. char *p;
  1268. int i;
  1269. if(sdindex(*spec) < 0)
  1270. error("bad sd spec");
  1271. if((p = strchr(cf->type, '/')) != nil)
  1272. *p++ = '\0';
  1273. for(i = 0; sdifc[i] != nil; i++)
  1274. if(strcmp(sdifc[i]->name, cf->type) == 0)
  1275. break;
  1276. if(sdifc[i] == nil)
  1277. error("sd type not found");
  1278. if(p)
  1279. *(p-1) = '/';
  1280. if(sdifc[i]->probe == nil)
  1281. error("sd type cannot probe");
  1282. sdev = sdifc[i]->probe(cf);
  1283. for(s=sdev; s; s=s->next)
  1284. s->idno = *spec;
  1285. sdadddevs(sdev);
  1286. return 0;
  1287. }
  1288. static int
  1289. unconfigure(char* spec)
  1290. {
  1291. int i;
  1292. SDev *sdev;
  1293. SDunit *unit;
  1294. if((i = sdindex(*spec)) < 0)
  1295. error(Enonexist);
  1296. qlock(&devslock);
  1297. if((sdev = devs[i]) == nil){
  1298. qunlock(&devslock);
  1299. error(Enonexist);
  1300. }
  1301. if(sdev->r.ref){
  1302. qunlock(&devslock);
  1303. error(Einuse);
  1304. }
  1305. devs[i] = nil;
  1306. qunlock(&devslock);
  1307. /* make sure no interrupts arrive anymore before removing resources */
  1308. if(sdev->enabled && sdev->ifc->disable)
  1309. sdev->ifc->disable(sdev);
  1310. for(i = 0; i != sdev->nunit; i++){
  1311. if(unit = sdev->unit[i]){
  1312. free(unit->name);
  1313. free(unit->user);
  1314. free(unit);
  1315. }
  1316. }
  1317. if(sdev->ifc->clear)
  1318. sdev->ifc->clear(sdev);
  1319. free(sdev);
  1320. return 0;
  1321. }
  1322. static int
  1323. sdconfig(int on, char* spec, DevConf* cf)
  1324. {
  1325. if(on)
  1326. return configure(spec, cf);
  1327. return unconfigure(spec);
  1328. }
  1329. Dev sddevtab = {
  1330. 'S',
  1331. "sd",
  1332. sdreset,
  1333. devinit,
  1334. devshutdown,
  1335. sdattach,
  1336. sdwalk,
  1337. sdstat,
  1338. sdopen,
  1339. devcreate,
  1340. sdclose,
  1341. sdread,
  1342. devbread,
  1343. sdwrite,
  1344. devbwrite,
  1345. devremove,
  1346. sdwstat,
  1347. devpower,
  1348. sdconfig,
  1349. };
  1350. /*
  1351. * This is wrong for so many reasons. This code must go.
  1352. */
  1353. typedef struct Confdata Confdata;
  1354. struct Confdata {
  1355. int on;
  1356. char* spec;
  1357. DevConf cf;
  1358. };
  1359. static void
  1360. parseswitch(Confdata* cd, char* option)
  1361. {
  1362. if(!strcmp("on", option))
  1363. cd->on = 1;
  1364. else if(!strcmp("off", option))
  1365. cd->on = 0;
  1366. else
  1367. error(Ebadarg);
  1368. }
  1369. static void
  1370. parsespec(Confdata* cd, char* option)
  1371. {
  1372. if(strlen(option) > 1)
  1373. error(Ebadarg);
  1374. cd->spec = option;
  1375. }
  1376. static Devport*
  1377. getnewport(DevConf* dc)
  1378. {
  1379. Devport *p;
  1380. p = (Devport *)malloc((dc->nports + 1) * sizeof(Devport));
  1381. if(dc->nports > 0){
  1382. memmove(p, dc->ports, dc->nports * sizeof(Devport));
  1383. free(dc->ports);
  1384. }
  1385. dc->ports = p;
  1386. p = &dc->ports[dc->nports++];
  1387. p->size = -1;
  1388. p->port = (ulong)-1;
  1389. return p;
  1390. }
  1391. static void
  1392. parseport(Confdata* cd, char* option)
  1393. {
  1394. char *e;
  1395. Devport *p;
  1396. if(cd->cf.nports == 0 || cd->cf.ports[cd->cf.nports-1].port != (ulong)-1)
  1397. p = getnewport(&cd->cf);
  1398. else
  1399. p = &cd->cf.ports[cd->cf.nports-1];
  1400. p->port = strtol(option, &e, 0);
  1401. if(e == nil || *e != '\0')
  1402. error(Ebadarg);
  1403. }
  1404. static void
  1405. parsesize(Confdata* cd, char* option)
  1406. {
  1407. char *e;
  1408. Devport *p;
  1409. if(cd->cf.nports == 0 || cd->cf.ports[cd->cf.nports-1].size != -1)
  1410. p = getnewport(&cd->cf);
  1411. else
  1412. p = &cd->cf.ports[cd->cf.nports-1];
  1413. p->size = (int)strtol(option, &e, 0);
  1414. if(e == nil || *e != '\0')
  1415. error(Ebadarg);
  1416. }
  1417. static void
  1418. parseirq(Confdata* cd, char* option)
  1419. {
  1420. char *e;
  1421. cd->cf.intnum = strtoul(option, &e, 0);
  1422. if(e == nil || *e != '\0')
  1423. error(Ebadarg);
  1424. }
  1425. static void
  1426. parsetype(Confdata* cd, char* option)
  1427. {
  1428. cd->cf.type = option;
  1429. }
  1430. static struct {
  1431. char *name;
  1432. void (*parse)(Confdata*, char*);
  1433. } options[] = {
  1434. "switch", parseswitch,
  1435. "spec", parsespec,
  1436. "port", parseport,
  1437. "size", parsesize,
  1438. "irq", parseirq,
  1439. "type", parsetype,
  1440. };
  1441. static void
  1442. legacytopctl(Cmdbuf *cb)
  1443. {
  1444. char *opt;
  1445. int i, j;
  1446. Confdata cd;
  1447. memset(&cd, 0, sizeof cd);
  1448. cd.on = -1;
  1449. for(i=0; i<cb->nf; i+=2){
  1450. if(i+2 > cb->nf)
  1451. error(Ebadarg);
  1452. opt = cb->f[i];
  1453. for(j=0; j<nelem(options); j++)
  1454. if(strcmp(opt, options[j].name) == 0){
  1455. options[j].parse(&cd, cb->f[i+1]);
  1456. break;
  1457. }
  1458. if(j == nelem(options))
  1459. error(Ebadarg);
  1460. }
  1461. /* this has been rewritten to accomodate sdaoe */
  1462. if(cd.on < 0 || cd.spec == 0)
  1463. error(Ebadarg);
  1464. if(cd.on && cd.cf.type == nil)
  1465. error(Ebadarg);
  1466. sdconfig(cd.on, cd.spec, &cd.cf);
  1467. }