devsd.c 31 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645
  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. decref(&sdev->r);
  1122. free(cb);
  1123. break;
  1124. case Qctl:
  1125. cb = parsecmd(a, n);
  1126. sdev = sdgetdev(DEV(c->qid));
  1127. if(sdev == nil)
  1128. error(Enonexist);
  1129. unit = sdev->unit[UNIT(c->qid)];
  1130. qlock(&unit->ctl);
  1131. if(waserror()){
  1132. qunlock(&unit->ctl);
  1133. decref(&sdev->r);
  1134. free(cb);
  1135. nexterror();
  1136. }
  1137. if(unit->vers != c->qid.vers)
  1138. error(Echange);
  1139. if(cb->nf < 1)
  1140. error(Ebadctl);
  1141. if(strcmp(cb->f[0], "part") == 0){
  1142. if(cb->nf != 4)
  1143. error(Ebadctl);
  1144. if(unit->sectors == 0 && !sdinitpart(unit))
  1145. error(Eio);
  1146. start = strtoull(cb->f[2], 0, 0);
  1147. end = strtoull(cb->f[3], 0, 0);
  1148. sdaddpart(unit, cb->f[1], start, end);
  1149. }
  1150. else if(strcmp(cb->f[0], "delpart") == 0){
  1151. if(cb->nf != 2 || unit->part == nil)
  1152. error(Ebadctl);
  1153. sddelpart(unit, cb->f[1]);
  1154. }
  1155. else if(unit->dev->ifc->wctl)
  1156. unit->dev->ifc->wctl(unit, cb);
  1157. else
  1158. error(Ebadctl);
  1159. qunlock(&unit->ctl);
  1160. decref(&sdev->r);
  1161. poperror();
  1162. free(cb);
  1163. break;
  1164. case Qraw:
  1165. sdev = sdgetdev(DEV(c->qid));
  1166. if(sdev == nil)
  1167. error(Enonexist);
  1168. unit = sdev->unit[UNIT(c->qid)];
  1169. qlock(&unit->raw);
  1170. if(waserror()){
  1171. qunlock(&unit->raw);
  1172. decref(&sdev->r);
  1173. nexterror();
  1174. }
  1175. switch(unit->state){
  1176. case Rawcmd:
  1177. if(n < 6 || n > sizeof(req->cmd))
  1178. error(Ebadarg);
  1179. if((req = malloc(sizeof(SDreq))) == nil)
  1180. error(Enomem);
  1181. req->unit = unit;
  1182. memmove(req->cmd, a, n);
  1183. req->clen = n;
  1184. req->flags = SDnosense;
  1185. req->status = ~0;
  1186. unit->req = req;
  1187. unit->state = Rawdata;
  1188. break;
  1189. case Rawstatus:
  1190. unit->state = Rawcmd;
  1191. free(unit->req);
  1192. unit->req = nil;
  1193. error(Ebadusefd);
  1194. case Rawdata:
  1195. unit->state = Rawstatus;
  1196. unit->req->write = 1;
  1197. n = sdrio(unit->req, a, n);
  1198. }
  1199. qunlock(&unit->raw);
  1200. decref(&sdev->r);
  1201. poperror();
  1202. break;
  1203. case Qpart:
  1204. return sdbio(c, 1, a, n, off);
  1205. }
  1206. return n;
  1207. }
  1208. static int
  1209. sdwstat(Chan* c, uchar* dp, int n)
  1210. {
  1211. Dir *d;
  1212. SDpart *pp;
  1213. SDperm *perm;
  1214. SDunit *unit;
  1215. SDev *sdev;
  1216. if(c->qid.type & QTDIR)
  1217. error(Eperm);
  1218. sdev = sdgetdev(DEV(c->qid));
  1219. if(sdev == nil)
  1220. error(Enonexist);
  1221. unit = sdev->unit[UNIT(c->qid)];
  1222. qlock(&unit->ctl);
  1223. d = nil;
  1224. if(waserror()){
  1225. free(d);
  1226. qunlock(&unit->ctl);
  1227. decref(&sdev->r);
  1228. nexterror();
  1229. }
  1230. switch(TYPE(c->qid)){
  1231. default:
  1232. error(Eperm);
  1233. case Qctl:
  1234. perm = &unit->ctlperm;
  1235. break;
  1236. case Qraw:
  1237. perm = &unit->rawperm;
  1238. break;
  1239. case Qpart:
  1240. pp = &unit->part[PART(c->qid)];
  1241. if(unit->vers+pp->vers != c->qid.vers)
  1242. error(Enonexist);
  1243. perm = &pp->SDperm;
  1244. break;
  1245. }
  1246. if(strcmp(up->user, perm->user) && !iseve())
  1247. error(Eperm);
  1248. d = smalloc(sizeof(Dir)+n);
  1249. n = convM2D(dp, n, &d[0], (char*)&d[1]);
  1250. if(n == 0)
  1251. error(Eshortstat);
  1252. if(!emptystr(d[0].uid))
  1253. kstrdup(&perm->user, d[0].uid);
  1254. if(d[0].mode != ~0UL)
  1255. perm->perm = (perm->perm & ~0777) | (d[0].mode & 0777);
  1256. free(d);
  1257. qunlock(&unit->ctl);
  1258. decref(&sdev->r);
  1259. poperror();
  1260. return n;
  1261. }
  1262. static int
  1263. configure(char* spec, DevConf* cf)
  1264. {
  1265. SDev *s, *sdev;
  1266. char *p;
  1267. int i;
  1268. if(sdindex(*spec) < 0)
  1269. error("bad sd spec");
  1270. if((p = strchr(cf->type, '/')) != nil)
  1271. *p++ = '\0';
  1272. for(i = 0; sdifc[i] != nil; i++)
  1273. if(strcmp(sdifc[i]->name, cf->type) == 0)
  1274. break;
  1275. if(sdifc[i] == nil)
  1276. error("sd type not found");
  1277. if(p)
  1278. *(p-1) = '/';
  1279. if(sdifc[i]->probe == nil)
  1280. error("sd type cannot probe");
  1281. sdev = sdifc[i]->probe(cf);
  1282. for(s=sdev; s; s=s->next)
  1283. s->idno = *spec;
  1284. sdadddevs(sdev);
  1285. return 0;
  1286. }
  1287. static int
  1288. unconfigure(char* spec)
  1289. {
  1290. int i;
  1291. SDev *sdev;
  1292. SDunit *unit;
  1293. if((i = sdindex(*spec)) < 0)
  1294. error(Enonexist);
  1295. qlock(&devslock);
  1296. if((sdev = devs[i]) == nil){
  1297. qunlock(&devslock);
  1298. error(Enonexist);
  1299. }
  1300. if(sdev->r.ref){
  1301. qunlock(&devslock);
  1302. error(Einuse);
  1303. }
  1304. devs[i] = nil;
  1305. qunlock(&devslock);
  1306. /* make sure no interrupts arrive anymore before removing resources */
  1307. if(sdev->enabled && sdev->ifc->disable)
  1308. sdev->ifc->disable(sdev);
  1309. for(i = 0; i != sdev->nunit; i++){
  1310. if(unit = sdev->unit[i]){
  1311. free(unit->name);
  1312. free(unit->user);
  1313. free(unit);
  1314. }
  1315. }
  1316. if(sdev->ifc->clear)
  1317. sdev->ifc->clear(sdev);
  1318. free(sdev);
  1319. return 0;
  1320. }
  1321. static int
  1322. sdconfig(int on, char* spec, DevConf* cf)
  1323. {
  1324. if(on)
  1325. return configure(spec, cf);
  1326. return unconfigure(spec);
  1327. }
  1328. Dev sddevtab = {
  1329. 'S',
  1330. "sd",
  1331. sdreset,
  1332. devinit,
  1333. devshutdown,
  1334. sdattach,
  1335. sdwalk,
  1336. sdstat,
  1337. sdopen,
  1338. devcreate,
  1339. sdclose,
  1340. sdread,
  1341. devbread,
  1342. sdwrite,
  1343. devbwrite,
  1344. devremove,
  1345. sdwstat,
  1346. devpower,
  1347. sdconfig,
  1348. };
  1349. /*
  1350. * This is wrong for so many reasons. This code must go.
  1351. */
  1352. typedef struct Confdata Confdata;
  1353. struct Confdata {
  1354. int on;
  1355. char* spec;
  1356. DevConf cf;
  1357. };
  1358. static void
  1359. parseswitch(Confdata* cd, char* option)
  1360. {
  1361. if(!strcmp("on", option))
  1362. cd->on = 1;
  1363. else if(!strcmp("off", option))
  1364. cd->on = 0;
  1365. else
  1366. error(Ebadarg);
  1367. }
  1368. static void
  1369. parsespec(Confdata* cd, char* option)
  1370. {
  1371. if(strlen(option) > 1)
  1372. error(Ebadarg);
  1373. cd->spec = option;
  1374. }
  1375. static Devport*
  1376. getnewport(DevConf* dc)
  1377. {
  1378. Devport *p;
  1379. p = (Devport *)malloc((dc->nports + 1) * sizeof(Devport));
  1380. if(dc->nports > 0){
  1381. memmove(p, dc->ports, dc->nports * sizeof(Devport));
  1382. free(dc->ports);
  1383. }
  1384. dc->ports = p;
  1385. p = &dc->ports[dc->nports++];
  1386. p->size = -1;
  1387. p->port = (ulong)-1;
  1388. return p;
  1389. }
  1390. static void
  1391. parseport(Confdata* cd, char* option)
  1392. {
  1393. char *e;
  1394. Devport *p;
  1395. if(cd->cf.nports == 0 || cd->cf.ports[cd->cf.nports-1].port != (ulong)-1)
  1396. p = getnewport(&cd->cf);
  1397. else
  1398. p = &cd->cf.ports[cd->cf.nports-1];
  1399. p->port = strtol(option, &e, 0);
  1400. if(e == nil || *e != '\0')
  1401. error(Ebadarg);
  1402. }
  1403. static void
  1404. parsesize(Confdata* cd, char* option)
  1405. {
  1406. char *e;
  1407. Devport *p;
  1408. if(cd->cf.nports == 0 || cd->cf.ports[cd->cf.nports-1].size != -1)
  1409. p = getnewport(&cd->cf);
  1410. else
  1411. p = &cd->cf.ports[cd->cf.nports-1];
  1412. p->size = (int)strtol(option, &e, 0);
  1413. if(e == nil || *e != '\0')
  1414. error(Ebadarg);
  1415. }
  1416. static void
  1417. parseirq(Confdata* cd, char* option)
  1418. {
  1419. char *e;
  1420. cd->cf.intnum = strtoul(option, &e, 0);
  1421. if(e == nil || *e != '\0')
  1422. error(Ebadarg);
  1423. }
  1424. static void
  1425. parsetype(Confdata* cd, char* option)
  1426. {
  1427. cd->cf.type = option;
  1428. }
  1429. static struct {
  1430. char *name;
  1431. void (*parse)(Confdata*, char*);
  1432. } options[] = {
  1433. "switch", parseswitch,
  1434. "spec", parsespec,
  1435. "port", parseport,
  1436. "size", parsesize,
  1437. "irq", parseirq,
  1438. "type", parsetype,
  1439. };
  1440. static void
  1441. legacytopctl(Cmdbuf *cb)
  1442. {
  1443. char *opt;
  1444. int i, j;
  1445. Confdata cd;
  1446. memset(&cd, 0, sizeof cd);
  1447. cd.on = -1;
  1448. for(i=0; i<cb->nf; i+=2){
  1449. if(i+2 > cb->nf)
  1450. error(Ebadarg);
  1451. opt = cb->f[i];
  1452. for(j=0; j<nelem(options); j++)
  1453. if(strcmp(opt, options[j].name) == 0){
  1454. options[j].parse(&cd, cb->f[i+1]);
  1455. break;
  1456. }
  1457. if(j == nelem(options))
  1458. error(Ebadarg);
  1459. }
  1460. if(cd.on < 0)
  1461. error(Ebadarg);
  1462. if(cd.on
  1463. && (cd.spec == 0 || cd.cf.nports == 0 || cd.cf.intnum == 0 || cd.cf.type == nil))
  1464. error(Ebadarg);
  1465. if(!cd.on && cd.spec == 0)
  1466. error(Ebadarg);
  1467. sdconfig(cd.on, cd.spec, &cd.cf);
  1468. }