devsd.c 30 KB

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