summaryrefslogtreecommitdiff
path: root/os/port/devsd.c
diff options
context:
space:
mode:
Diffstat (limited to 'os/port/devsd.c')
-rw-r--r--os/port/devsd.c1474
1 files changed, 1474 insertions, 0 deletions
diff --git a/os/port/devsd.c b/os/port/devsd.c
new file mode 100644
index 00000000..5bdc4048
--- /dev/null
+++ b/os/port/devsd.c
@@ -0,0 +1,1474 @@
+/*
+ * Storage Device.
+ */
+#include "u.h"
+#include "../port/lib.h"
+#include "mem.h"
+#include "dat.h"
+#include "fns.h"
+#include "io.h"
+#include "ureg.h"
+#include "../port/error.h"
+
+#include "../port/sd.h"
+
+extern Dev sddevtab;
+extern SDifc* sdifc[];
+
+typedef struct SDevgrp {
+ SDev* dev;
+ int nunits; /* num units in dev */
+} SDevgrp;
+
+static SDevgrp* devs; /* all devices */
+static QLock devslock; /* insertion and removal of devices */
+static int ndevs; /* total number of devices in the system */
+
+enum {
+ Rawcmd,
+ Rawdata,
+ Rawstatus,
+};
+
+enum {
+ Qtopdir = 1, /* top level directory */
+ Qtopbase,
+ Qtopctl = Qtopbase,
+ Qtopstat,
+
+ Qunitdir, /* directory per unit */
+ Qunitbase,
+ Qctl = Qunitbase,
+ Qraw,
+ Qpart,
+
+ TypeLOG = 4,
+ NType = (1<<TypeLOG),
+ TypeMASK = (NType-1),
+ TypeSHIFT = 0,
+
+ PartLOG = 8,
+ NPart = (1<<PartLOG),
+ PartMASK = (NPart-1),
+ PartSHIFT = TypeLOG,
+
+ UnitLOG = 8,
+ NUnit = (1<<UnitLOG),
+ UnitMASK = (NUnit-1),
+ UnitSHIFT = (PartLOG+TypeLOG),
+
+ DevLOG = 8,
+ NDev = (1 << DevLOG),
+ DevMASK = (NDev-1),
+ DevSHIFT = (UnitLOG+PartLOG+TypeLOG),
+
+ Ncmd = 20,
+};
+
+#define TYPE(q) ((((ulong)(q).path)>>TypeSHIFT) & TypeMASK)
+#define PART(q) ((((ulong)(q).path)>>PartSHIFT) & PartMASK)
+#define UNIT(q) ((((ulong)(q).path)>>UnitSHIFT) & UnitMASK)
+#define DEV(q) ((((ulong)(q).path)>>DevSHIFT) & DevMASK)
+#define QID(d,u, p, t) (((d)<<DevSHIFT)|((u)<<UnitSHIFT)|\
+ ((p)<<PartSHIFT)|((t)<<TypeSHIFT))
+
+
+static void
+sdaddpart(SDunit* unit, char* name, ulong start, ulong end)
+{
+ SDpart *pp;
+ int i, partno;
+
+ /*
+ * Check name not already used
+ * and look for a free slot.
+ */
+ if(unit->part != nil){
+ partno = -1;
+ for(i = 0; i < unit->npart; i++){
+ pp = &unit->part[i];
+ if(!pp->valid){
+ if(partno == -1)
+ partno = i;
+ break;
+ }
+ if(strcmp(name, pp->name) == 0){
+ if(pp->start == start && pp->end == end)
+ return;
+ error(Ebadctl);
+ }
+ }
+ }
+ else{
+ if((unit->part = malloc(sizeof(SDpart)*SDnpart)) == nil)
+ error(Enomem);
+ unit->npart = SDnpart;
+ partno = 0;
+ }
+
+ /*
+ * If no free slot found then increase the
+ * array size (can't get here with unit->part == nil).
+ */
+ if(partno == -1){
+ if(unit->npart >= NPart)
+ error(Enomem);
+ if((pp = malloc(sizeof(SDpart)*(unit->npart+SDnpart))) == nil)
+ error(Enomem);
+ memmove(pp, unit->part, sizeof(SDpart)*unit->npart);
+ free(unit->part);
+ unit->part = pp;
+ partno = unit->npart;
+ unit->npart += SDnpart;
+ }
+
+ /*
+ * Check size and extent are valid.
+ */
+ if(start > end || end > unit->sectors)
+ error(Eio);
+ pp = &unit->part[partno];
+ pp->start = start;
+ pp->end = end;
+ kstrdup(&pp->name, name);
+ kstrdup(&pp->user, eve);
+ pp->perm = 0640;
+ pp->valid = 1;
+}
+
+static void
+sddelpart(SDunit* unit, char* name)
+{
+ int i;
+ SDpart *pp;
+
+ /*
+ * Look for the partition to delete.
+ * Can't delete if someone still has it open.
+ */
+ pp = unit->part;
+ for(i = 0; i < unit->npart; i++){
+ if(strcmp(name, pp->name) == 0)
+ break;
+ pp++;
+ }
+ if(i >= unit->npart)
+ error(Ebadctl);
+ if(strcmp(up->env->user, pp->user) && !iseve())
+ error(Eperm);
+ pp->valid = 0;
+ pp->vers++;
+}
+
+static int
+sdinitpart(SDunit* unit)
+{
+ int i, nf;
+ ulong start, end;
+ char *f[4], *p, *q, buf[10];
+
+ unit->vers++;
+ unit->sectors = unit->secsize = 0;
+ if(unit->part){
+ for(i = 0; i < unit->npart; i++){
+ unit->part[i].valid = 0;
+ unit->part[i].vers++;
+ }
+ }
+
+ if(unit->inquiry[0] & 0xC0)
+ return 0;
+ switch(unit->inquiry[0] & 0x1F){
+ case 0x00: /* DA */
+ case 0x04: /* WORM */
+ case 0x05: /* CD-ROM */
+ case 0x07: /* MO */
+ break;
+ default:
+ return 0;
+ }
+
+ if(unit->dev->ifc->online)
+ unit->dev->ifc->online(unit);
+ if(unit->sectors){
+ sdaddpart(unit, "data", 0, unit->sectors);
+
+ /*
+ * Use partitions passed from boot program,
+ * e.g.
+ * sdC0part=dos 63 123123/plan9 123123 456456
+ * This happens before /boot sets hostname so the
+ * partitions will have the null-string for user.
+ * The gen functions patch it up.
+ */
+ snprint(buf, sizeof buf, "%spart", unit->name);
+ for(p = getconf(buf); p != nil; p = q){
+ if(q = strchr(p, '/'))
+ *q++ = '\0';
+ nf = tokenize(p, f, nelem(f));
+ if(nf < 3)
+ continue;
+
+ start = strtoul(f[1], 0, 0);
+ end = strtoul(f[2], 0, 0);
+ if(!waserror()){
+ sdaddpart(unit, f[0], start, end);
+ poperror();
+ }
+ }
+ }
+
+ return 1;
+}
+
+static SDev*
+sdgetdev(int idno)
+{
+ SDev *sdev;
+ int i;
+
+ qlock(&devslock);
+ for(i = 0; i != ndevs; i++)
+ if(devs[i].dev->idno == idno)
+ break;
+
+ if(i == ndevs)
+ sdev = nil;
+ else{
+ sdev = devs[i].dev;
+ incref(&sdev->r);
+ }
+ qunlock(&devslock);
+ return sdev;
+}
+
+static SDunit*
+sdgetunit(SDev* sdev, int subno)
+{
+ SDunit *unit;
+ char buf[32];
+
+ /*
+ * Associate a unit with a given device and sub-unit
+ * number on that device.
+ * The device will be probed if it has not already been
+ * successfully accessed.
+ */
+ qlock(&sdev->unitlock);
+ if(subno > sdev->nunit){
+ qunlock(&sdev->unitlock);
+ return nil;
+ }
+
+ unit = sdev->unit[subno];
+ if(unit == nil){
+ /*
+ * Probe the unit only once. This decision
+ * may be a little severe and reviewed later.
+ */
+ if(sdev->unitflg[subno]){
+ qunlock(&sdev->unitlock);
+ return nil;
+ }
+ if((unit = malloc(sizeof(SDunit))) == nil){
+ qunlock(&sdev->unitlock);
+ return nil;
+ }
+ sdev->unitflg[subno] = 1;
+
+ snprint(buf, sizeof(buf), "%s%d", sdev->name, subno);
+ kstrdup(&unit->name, buf);
+ kstrdup(&unit->user, eve);
+ unit->perm = 0555;
+ unit->subno = subno;
+ unit->dev = sdev;
+
+ if(sdev->enabled == 0 && sdev->ifc->enable)
+ sdev->ifc->enable(sdev);
+ sdev->enabled = 1;
+
+ /*
+ * No need to lock anything here as this is only
+ * called before the unit is made available in the
+ * sdunit[] array.
+ */
+ if(unit->dev->ifc->verify(unit) == 0){
+ qunlock(&sdev->unitlock);
+ free(unit);
+ return nil;
+ }
+ sdev->unit[subno] = unit;
+ }
+ qunlock(&sdev->unitlock);
+ return unit;
+}
+
+static void
+sdreset(void)
+{
+ int i;
+ SDev *sdev, *tail, *sdlist;
+
+ /*
+ * Probe all configured controllers and make a list
+ * of devices found, accumulating a possible maximum number
+ * of units attached and marking each device with an index
+ * into the linear top-level directory array of units.
+ */
+ tail = sdlist = nil;
+ for(i = 0; sdifc[i] != nil; i++){
+ if(sdifc[i]->pnp == nil || (sdev = sdifc[i]->pnp()) == nil)
+ continue;
+ if(sdlist != nil)
+ tail->next = sdev;
+ else
+ sdlist = sdev;
+ for(tail = sdev; tail->next != nil; tail = tail->next){
+ tail->unit = (SDunit**)malloc(tail->nunit * sizeof(SDunit*));
+ tail->unitflg = (int*)malloc(tail->nunit * sizeof(int));
+ assert(tail->unit && tail->unitflg);
+ ndevs++;
+ }
+ tail->unit = (SDunit**)malloc(tail->nunit * sizeof(SDunit*));
+ tail->unitflg = (int*)malloc(tail->nunit * sizeof(int));
+ ndevs++;
+ }
+
+ /*
+ * Legacy and option code goes here. This will be hard...
+ */
+
+ /*
+ * The maximum number of possible units is known, allocate
+ * placeholders for their datastructures; the units will be
+ * probed and structures allocated when attached.
+ * Allocate controller names for the different types.
+ */
+ if(ndevs == 0)
+ return;
+ for(i = 0; sdifc[i] != nil; i++){
+ /*
+ * BUG: no check is made here or later when a
+ * unit is attached that the id and name are set.
+ */
+ if(sdifc[i]->id)
+ sdifc[i]->id(sdlist);
+ }
+
+ /*
+ * The IDs have been set, unlink the sdlist and copy the spec to
+ * the devtab.
+ */
+ devs = (SDevgrp*)malloc(ndevs * sizeof(SDevgrp));
+ memset(devs, 0, ndevs * sizeof(SDevgrp));
+ i = 0;
+ while(sdlist != nil){
+ devs[i].dev = sdlist;
+ devs[i].nunits = sdlist->nunit;
+ sdlist = sdlist->next;
+ devs[i].dev->next = nil;
+ i++;
+ }
+}
+
+static int
+sd2gen(Chan* c, int i, Dir* dp)
+{
+ Qid q;
+ vlong l;
+ SDpart *pp;
+ SDperm *perm;
+ SDunit *unit;
+ SDev *sdev;
+ int rv;
+
+ sdev = sdgetdev(DEV(c->qid));
+ assert(sdev);
+ unit = sdev->unit[UNIT(c->qid)];
+
+ rv = -1;
+ switch(i){
+ case Qctl:
+ mkqid(&q, QID(DEV(c->qid), UNIT(c->qid), PART(c->qid), Qctl),
+ unit->vers, QTFILE);
+ perm = &unit->ctlperm;
+ if(emptystr(perm->user)){
+ kstrdup(&perm->user, eve);
+ perm->perm = 0640;
+ }
+ devdir(c, q, "ctl", 0, perm->user, perm->perm, dp);
+ rv = 1;
+ break;
+
+ case Qraw:
+ mkqid(&q, QID(DEV(c->qid), UNIT(c->qid), PART(c->qid), Qraw),
+ unit->vers, QTFILE);
+ perm = &unit->rawperm;
+ if(emptystr(perm->user)){
+ kstrdup(&perm->user, eve);
+ perm->perm = DMEXCL|0600;
+ }
+ devdir(c, q, "raw", 0, perm->user, perm->perm, dp);
+ rv = 1;
+ break;
+
+ case Qpart:
+ pp = &unit->part[PART(c->qid)];
+ l = (pp->end - pp->start) * (vlong)unit->secsize;
+ mkqid(&q, QID(DEV(c->qid), UNIT(c->qid), PART(c->qid), Qpart),
+ unit->vers+pp->vers, QTFILE);
+ if(emptystr(pp->user))
+ kstrdup(&pp->user, eve);
+ devdir(c, q, pp->name, l, pp->user, pp->perm, dp);
+ rv = 1;
+ break;
+ }
+
+ decref(&sdev->r);
+ return rv;
+}
+
+static int
+sd1gen(Chan* c, int i, Dir* dp)
+{
+ Qid q;
+
+ switch(i){
+ case Qtopctl:
+ mkqid(&q, QID(0, 0, 0, Qtopctl), 0, QTFILE);
+ devdir(c, q, "sdctl", 0, eve, 0640, dp);
+ return 1;
+ case Qtopstat:
+ mkqid(&q, QID(0, 0, 0, Qtopstat), 0, QTFILE);
+ devdir(c, q, "sdstat", 0, eve, 0640, dp);
+ return 1;
+ }
+ return -1;
+}
+
+static int
+sdgen(Chan* c, char*, Dirtab*, int, int s, Dir* dp)
+{
+ Qid q;
+ vlong l;
+ int i, r;
+ SDpart *pp;
+ SDunit *unit;
+ SDev *sdev;
+
+ switch(TYPE(c->qid)){
+ case Qtopdir:
+ if(s == DEVDOTDOT){
+ mkqid(&q, QID(0, 0, 0, Qtopdir), 0, QTDIR);
+ sprint(up->genbuf, "#%C", sddevtab.dc);
+ devdir(c, q, up->genbuf, 0, eve, 0555, dp);
+ return 1;
+ }
+
+ if(s == 0 || s == 1)
+ return sd1gen(c, s + Qtopbase, dp);
+ s -= 2;
+
+ qlock(&devslock);
+ for(i = 0; i != ndevs; i++){
+ if(s < devs[i].nunits)
+ break;
+ s -= devs[i].nunits;
+ }
+
+ if(i == ndevs){
+ /* Run of the end of the list */
+ qunlock(&devslock);
+ return -1;
+ }
+
+ if((sdev = devs[i].dev) == nil){
+ qunlock(&devslock);
+ return 0;
+ }
+
+ incref(&sdev->r);
+ qunlock(&devslock);
+
+ if((unit = sdev->unit[s]) == nil)
+ if((unit = sdgetunit(sdev, s)) == nil){
+ decref(&sdev->r);
+ return 0;
+ }
+
+ mkqid(&q, QID(sdev->idno, s, 0, Qunitdir), 0, QTDIR);
+ if(emptystr(unit->user))
+ kstrdup(&unit->user, eve);
+ devdir(c, q, unit->name, 0, unit->user, unit->perm, dp);
+ decref(&sdev->r);
+ return 1;
+
+ case Qunitdir:
+ if(s == DEVDOTDOT){
+ mkqid(&q, QID(0, 0, 0, Qtopdir), 0, QTDIR);
+ sprint(up->genbuf, "#%C", sddevtab.dc);
+ devdir(c, q, up->genbuf, 0, eve, 0555, dp);
+ return 1;
+ }
+
+ if((sdev = sdgetdev(DEV(c->qid))) == nil){
+ devdir(c, q, "unavailable", 0, eve, 0, dp);
+ return 1;
+ }
+
+ unit = sdev->unit[UNIT(c->qid)];
+ qlock(&unit->ctl);
+
+ /*
+ * Check for media change.
+ * If one has already been detected, sectors will be zero.
+ * If there is one waiting to be detected, online
+ * will return > 1.
+ * Online is a bit of a large hammer but does the job.
+ */
+ if(unit->sectors == 0
+ || (unit->dev->ifc->online && unit->dev->ifc->online(unit) > 1))
+ sdinitpart(unit);
+
+ i = s+Qunitbase;
+ if(i < Qpart){
+ r = sd2gen(c, i, dp);
+ qunlock(&unit->ctl);
+ decref(&sdev->r);
+ return r;
+ }
+ i -= Qpart;
+ if(unit->part == nil || i >= unit->npart){
+ qunlock(&unit->ctl);
+ decref(&sdev->r);
+ break;
+ }
+ pp = &unit->part[i];
+ if(!pp->valid){
+ qunlock(&unit->ctl);
+ decref(&sdev->r);
+ return 0;
+ }
+ l = (pp->end - pp->start) * (vlong)unit->secsize;
+ mkqid(&q, QID(DEV(c->qid), UNIT(c->qid), i, Qpart),
+ unit->vers+pp->vers, QTFILE);
+ if(emptystr(pp->user))
+ kstrdup(&pp->user, eve);
+ devdir(c, q, pp->name, l, pp->user, pp->perm, dp);
+ qunlock(&unit->ctl);
+ decref(&sdev->r);
+ return 1;
+ case Qraw:
+ case Qctl:
+ case Qpart:
+ if((sdev = sdgetdev(DEV(c->qid))) == nil){
+ devdir(c, q, "unavailable", 0, eve, 0, dp);
+ return 1;
+ }
+ unit = sdev->unit[UNIT(c->qid)];
+ qlock(&unit->ctl);
+ r = sd2gen(c, TYPE(c->qid), dp);
+ qunlock(&unit->ctl);
+ decref(&sdev->r);
+ return r;
+ case Qtopctl:
+ case Qtopstat:
+ return sd1gen(c, TYPE(c->qid), dp);
+ default:
+ break;
+ }
+
+ return -1;
+}
+
+static Chan*
+sdattach(char* spec)
+{
+ Chan *c;
+ char *p;
+ SDev *sdev;
+ int idno, subno, i;
+
+ if(ndevs == 0 || *spec == '\0'){
+ c = devattach(sddevtab.dc, spec);
+ mkqid(&c->qid, QID(0, 0, 0, Qtopdir), 0, QTDIR);
+ return c;
+ }
+
+ if(spec[0] != 's' || spec[1] != 'd')
+ error(Ebadspec);
+ idno = spec[2];
+ subno = strtol(&spec[3], &p, 0);
+ if(p == &spec[3])
+ error(Ebadspec);
+
+ qlock(&devslock);
+ for (sdev = nil, i = 0; i != ndevs; i++)
+ if((sdev = devs[i].dev) != nil && sdev->idno == idno)
+ break;
+
+ if(i == ndevs || subno >= sdev->nunit || sdgetunit(sdev, subno) == nil){
+ qunlock(&devslock);
+ error(Enonexist);
+ }
+ incref(&sdev->r);
+ qunlock(&devslock);
+
+ c = devattach(sddevtab.dc, spec);
+ mkqid(&c->qid, QID(sdev->idno, subno, 0, Qunitdir), 0, QTDIR);
+ c->dev = (sdev->idno << UnitLOG) + subno;
+ decref(&sdev->r);
+ return c;
+}
+
+static Walkqid*
+sdwalk(Chan* c, Chan* nc, char** name, int nname)
+{
+ return devwalk(c, nc, name, nname, nil, 0, sdgen);
+}
+
+static int
+sdstat(Chan* c, uchar* db, int n)
+{
+ return devstat(c, db, n, nil, 0, sdgen);
+}
+
+static Chan*
+sdopen(Chan* c, int omode)
+{
+ SDpart *pp;
+ SDunit *unit;
+ SDev *sdev;
+ uchar tp;
+
+ c = devopen(c, omode, 0, 0, sdgen);
+ if((tp = TYPE(c->qid)) != Qctl && tp != Qraw && tp != Qpart)
+ return c;
+
+ sdev = sdgetdev(DEV(c->qid));
+ if(sdev == nil)
+ error(Enonexist);
+ unit = sdev->unit[UNIT(c->qid)];
+
+ switch(TYPE(c->qid)){
+ case Qctl:
+ c->qid.vers = unit->vers;
+ break;
+ case Qraw:
+ c->qid.vers = unit->vers;
+ if(_tas(&unit->rawinuse) != 0){
+ c->flag &= ~COPEN;
+ error(Einuse);
+ }
+ unit->state = Rawcmd;
+ break;
+ case Qpart:
+ qlock(&unit->ctl);
+ if(waserror()){
+ qunlock(&unit->ctl);
+ c->flag &= ~COPEN;
+ nexterror();
+ }
+ pp = &unit->part[PART(c->qid)];
+ c->qid.vers = unit->vers+pp->vers;
+ qunlock(&unit->ctl);
+ poperror();
+ break;
+ }
+ decref(&sdev->r);
+ return c;
+}
+
+static void
+sdclose(Chan* c)
+{
+ SDunit *unit;
+ SDev *sdev;
+
+ if(c->qid.type & QTDIR)
+ return;
+ if(!(c->flag & COPEN))
+ return;
+
+ switch(TYPE(c->qid)){
+ default:
+ break;
+ case Qraw:
+ sdev = sdgetdev(DEV(c->qid));
+ if(sdev){
+ unit = sdev->unit[UNIT(c->qid)];
+ unit->rawinuse = 0;
+ decref(&sdev->r);
+ }
+ break;
+ }
+}
+
+static long
+sdbio(Chan* c, int write, char* a, long len, vlong off)
+{
+ int nchange;
+ long l;
+ uchar *b;
+ SDpart *pp;
+ SDunit *unit;
+ SDev *sdev;
+ ulong bno, max, nb, offset;
+
+ sdev = sdgetdev(DEV(c->qid));
+ if(sdev == nil)
+ error(Enonexist);
+ unit = sdev->unit[UNIT(c->qid)];
+ if(unit == nil)
+ error(Enonexist);
+
+ nchange = 0;
+ qlock(&unit->ctl);
+ while(waserror()){
+ /* notification of media change; go around again */
+ if(strcmp(up->env->errstr, Eio) == 0 && unit->sectors == 0 && nchange++ == 0){
+ sdinitpart(unit);
+ continue;
+ }
+
+ /* other errors; give up */
+ qunlock(&unit->ctl);
+ decref(&sdev->r);
+ nexterror();
+ }
+ pp = &unit->part[PART(c->qid)];
+ if(unit->vers+pp->vers != c->qid.vers)
+ error(Eio);
+
+ /*
+ * Check the request is within bounds.
+ * Removeable drives are locked throughout the I/O
+ * in case the media changes unexpectedly.
+ * Non-removeable drives are not locked during the I/O
+ * to allow the hardware to optimise if it can; this is
+ * a little fast and loose.
+ * It's assumed that non-removeable media parameters
+ * (sectors, secsize) can't change once the drive has
+ * been brought online.
+ */
+ bno = (off/unit->secsize) + pp->start;
+ nb = ((off+len+unit->secsize-1)/unit->secsize) + pp->start - bno;
+ max = SDmaxio/unit->secsize;
+ if(nb > max)
+ nb = max;
+ if(bno+nb > pp->end)
+ nb = pp->end - bno;
+ if(bno >= pp->end || nb == 0){
+ if(write)
+ error(Eio);
+ qunlock(&unit->ctl);
+ decref(&sdev->r);
+ poperror();
+ return 0;
+ }
+ if(!(unit->inquiry[1] & 0x80)){
+ qunlock(&unit->ctl);
+ poperror();
+ }
+
+ b = sdmalloc(nb*unit->secsize);
+ if(b == nil)
+ error(Enomem);
+ if(waserror()){
+ sdfree(b);
+ if(!(unit->inquiry[1] & 0x80))
+ decref(&sdev->r); /* gadverdamme! */
+ nexterror();
+ }
+
+ offset = off%unit->secsize;
+ if(offset+len > nb*unit->secsize)
+ len = nb*unit->secsize - offset;
+ if(write){
+ if(offset || (len%unit->secsize)){
+ l = unit->dev->ifc->bio(unit, 0, 0, b, nb, bno);
+ if(l < 0)
+ error(Eio);
+ if(l < (nb*unit->secsize)){
+ nb = l/unit->secsize;
+ l = nb*unit->secsize - offset;
+ if(len > l)
+ len = l;
+ }
+ }
+ memmove(b+offset, a, len);
+ l = unit->dev->ifc->bio(unit, 0, 1, b, nb, bno);
+ if(l < 0)
+ error(Eio);
+ if(l < offset)
+ len = 0;
+ else if(len > l - offset)
+ len = l - offset;
+ }
+ else{
+ l = unit->dev->ifc->bio(unit, 0, 0, b, nb, bno);
+ if(l < 0)
+ error(Eio);
+ if(l < offset)
+ len = 0;
+ else if(len > l - offset)
+ len = l - offset;
+ memmove(a, b+offset, len);
+ }
+ sdfree(b);
+ poperror();
+
+ if(unit->inquiry[1] & 0x80){
+ qunlock(&unit->ctl);
+ poperror();
+ }
+
+ decref(&sdev->r);
+ return len;
+}
+
+static long
+sdrio(SDreq* r, void* a, long n)
+{
+ void *data;
+
+ if(n >= SDmaxio || n < 0)
+ error(Etoobig);
+
+ data = nil;
+ if(n){
+ if((data = sdmalloc(n)) == nil)
+ error(Enomem);
+ if(r->write)
+ memmove(data, a, n);
+ }
+ r->data = data;
+ r->dlen = n;
+
+ if(waserror()){
+ if(data != nil){
+ sdfree(data);
+ r->data = nil;
+ }
+ nexterror();
+ }
+
+ if(r->unit->dev->ifc->rio(r) != SDok)
+ error(Eio);
+
+ if(!r->write && r->rlen > 0)
+ memmove(a, data, r->rlen);
+ if(data != nil){
+ sdfree(data);
+ r->data = nil;
+ }
+ poperror();
+
+ return r->rlen;
+}
+
+static long
+sdread(Chan *c, void *a, long n, vlong off)
+{
+ char *p, *e, *buf;
+ SDpart *pp;
+ SDunit *unit;
+ SDev *sdev;
+ ulong offset;
+ int i, l, status;
+
+ offset = off;
+ switch(TYPE(c->qid)){
+ default:
+ error(Eperm);
+ case Qtopstat:
+ p = buf = malloc(READSTR);
+ assert(p);
+ e = p + READSTR;
+ qlock(&devslock);
+ for(i = 0; i != ndevs; i++){
+ SDev *sdev = devs[i].dev;
+
+ if(sdev->ifc->stat)
+ p = sdev->ifc->stat(sdev, p, e);
+ else
+ p = seprint(e, "%s; no statistics available\n", sdev->name);
+ }
+ qunlock(&devslock);
+ n = readstr(off, a, n, buf);
+ free(buf);
+ return n;
+
+ case Qtopdir:
+ case Qunitdir:
+ return devdirread(c, a, n, 0, 0, sdgen);
+
+ case Qctl:
+ sdev = sdgetdev(DEV(c->qid));
+ if(sdev == nil)
+ error(Enonexist);
+
+ unit = sdev->unit[UNIT(c->qid)];
+ p = malloc(READSTR);
+ l = snprint(p, READSTR, "inquiry %.48s\n",
+ (char*)unit->inquiry+8);
+ qlock(&unit->ctl);
+ /*
+ * If there's a device specific routine it must
+ * provide all information pertaining to night geometry
+ * and the garscadden trains.
+ */
+ if(unit->dev->ifc->rctl)
+ l += unit->dev->ifc->rctl(unit, p+l, READSTR-l);
+ if(unit->sectors == 0)
+ sdinitpart(unit);
+ if(unit->sectors){
+ if(unit->dev->ifc->rctl == nil)
+ l += snprint(p+l, READSTR-l,
+ "geometry %ld %ld\n",
+ unit->sectors, unit->secsize);
+ pp = unit->part;
+ for(i = 0; i < unit->npart; i++){
+ if(pp->valid)
+ l += snprint(p+l, READSTR-l,
+ "part %s %lud %lud\n",
+ pp->name, pp->start, pp->end);
+ pp++;
+ }
+ }
+ qunlock(&unit->ctl);
+ decref(&sdev->r);
+ l = readstr(offset, a, n, p);
+ free(p);
+ return l;
+
+ case Qraw:
+ sdev = sdgetdev(DEV(c->qid));
+ if(sdev == nil)
+ error(Enonexist);
+
+ unit = sdev->unit[UNIT(c->qid)];
+ qlock(&unit->raw);
+ if(waserror()){
+ qunlock(&unit->raw);
+ decref(&sdev->r);
+ nexterror();
+ }
+ if(unit->state == Rawdata){
+ unit->state = Rawstatus;
+ i = sdrio(unit->req, a, n);
+ }
+ else if(unit->state == Rawstatus){
+ status = unit->req->status;
+ unit->state = Rawcmd;
+ free(unit->req);
+ unit->req = nil;
+ i = readnum(0, a, n, status, NUMSIZE);
+ } else
+ i = 0;
+ qunlock(&unit->raw);
+ decref(&sdev->r);
+ poperror();
+ return i;
+
+ case Qpart:
+ return sdbio(c, 0, a, n, off);
+ }
+
+ return 0;
+}
+
+typedef struct Confdata Confdata;
+struct Confdata {
+ int on;
+ char* spec;
+ DevConf cf;
+};
+
+static void
+parseswitch(Confdata* cd, char* option)
+{
+ if(!strcmp("on", option))
+ cd->on = 1;
+ else if(!strcmp("off", option))
+ cd->on = 0;
+ else
+ error(Ebadarg);
+}
+
+static void
+parsespec(Confdata* cd, char* option)
+{
+ if(strlen(option) > 1)
+ error(Ebadarg);
+ cd->spec = option;
+}
+
+static Devport*
+getnewport(DevConf* dc)
+{
+ Devport *p;
+
+ p = (Devport *)malloc((dc->nports + 1) * sizeof(Devport));
+ if(dc->nports > 0){
+ memmove(p, dc->ports, dc->nports * sizeof(Devport));
+ free(dc->ports);
+ }
+ dc->ports = p;
+ p = &dc->ports[dc->nports++];
+ p->size = -1;
+ p->port = (ulong)-1;
+ return p;
+}
+
+static void
+parseport(Confdata* cd, char* option)
+{
+ char *e;
+ Devport *p;
+
+ if(cd->cf.nports == 0 || cd->cf.ports[cd->cf.nports-1].port != (ulong)-1)
+ p = getnewport(&cd->cf);
+ else
+ p = &cd->cf.ports[cd->cf.nports-1];
+ p->port = strtol(option, &e, 0);
+ if(e == nil || *e != '\0')
+ error(Ebadarg);
+}
+
+static void
+parsesize(Confdata* cd, char* option)
+{
+ char *e;
+ Devport *p;
+
+ if(cd->cf.nports == 0 || cd->cf.ports[cd->cf.nports-1].size != -1)
+ p = getnewport(&cd->cf);
+ else
+ p = &cd->cf.ports[cd->cf.nports-1];
+ p->size = (int)strtol(option, &e, 0);
+ if(e == nil || *e != '\0')
+ error(Ebadarg);
+}
+
+static void
+parseirq(Confdata* cd, char* option)
+{
+ char *e;
+
+ cd->cf.intnum = strtoul(option, &e, 0);
+ if(e == nil || *e != '\0')
+ error(Ebadarg);
+}
+
+static void
+parsetype(Confdata* cd, char* option)
+{
+ cd->cf.type = option;
+}
+
+static struct {
+ char *option;
+ void (*parse)(Confdata*, char*);
+} options[] = {
+ { "switch", parseswitch, },
+ { "spec", parsespec, },
+ { "port", parseport, },
+ { "size", parsesize, },
+ { "irq", parseirq, },
+ { "type", parsetype, },
+};
+
+static long
+sdwrite(Chan* c, void* a, long n, vlong off)
+{
+ Cmdbuf *cb;
+ SDreq *req;
+ SDunit *unit;
+ SDev *sdev;
+ ulong end, start;
+
+ switch(TYPE(c->qid)){
+ default:
+ error(Eperm);
+ case Qtopctl: {
+ Confdata cd;
+ char buf[256], *field[Ncmd];
+ int nf, i, j;
+
+ memset(&cd, 0, sizeof(Confdata));
+ if(n > sizeof(buf)-1) n = sizeof(buf)-1;
+ memmove(buf, a, n);
+ buf[n] = '\0';
+
+ cd.on = -1;
+ cd.spec = '\0';
+ memset(&cd.cf, 0, sizeof(DevConf));
+
+ nf = tokenize(buf, field, Ncmd);
+ for(i = 0; i < nf; i++){
+ char *opt = field[i++];
+ if(i >= nf)
+ error(Ebadarg);
+ for(j = 0; j != nelem(options); j++)
+ if(!strcmp(opt, options[j].option))
+ break;
+
+ if(j == nelem(options))
+ error(Ebadarg);
+ options[j].parse(&cd, field[i]);
+ }
+
+ if(cd.on < 0)
+ error(Ebadarg);
+
+ if(cd.on){
+ if(cd.spec == '\0' || cd.cf.nports == 0 ||
+ cd.cf.intnum == 0 || cd.cf.type == nil)
+ error(Ebadarg);
+ }
+ else{
+ if(cd.spec == '\0')
+ error(Ebadarg);
+ }
+
+ if(sddevtab.config == nil)
+ error("No configuration function");
+ sddevtab.config(cd.on, cd.spec, &cd.cf);
+ break;
+ }
+ case Qctl:
+ cb = parsecmd(a, n);
+ sdev = sdgetdev(DEV(c->qid));
+ if(sdev == nil)
+ error(Enonexist);
+ unit = sdev->unit[UNIT(c->qid)];
+
+ qlock(&unit->ctl);
+ if(waserror()){
+ qunlock(&unit->ctl);
+ decref(&sdev->r);
+ free(cb);
+ nexterror();
+ }
+ if(unit->vers != c->qid.vers)
+ error(Eio);
+
+ if(cb->nf < 1)
+ error(Ebadctl);
+ if(strcmp(cb->f[0], "part") == 0){
+ if(cb->nf != 4)
+ error(Ebadctl);
+ if(unit->sectors == 0 && !sdinitpart(unit))
+ error(Eio);
+ start = strtoul(cb->f[2], 0, 0);
+ end = strtoul(cb->f[3], 0, 0);
+ sdaddpart(unit, cb->f[1], start, end);
+ }
+ else if(strcmp(cb->f[0], "delpart") == 0){
+ if(cb->nf != 2 || unit->part == nil)
+ error(Ebadctl);
+ sddelpart(unit, cb->f[1]);
+ }
+ else if(unit->dev->ifc->wctl)
+ unit->dev->ifc->wctl(unit, cb);
+ else
+ error(Ebadctl);
+ qunlock(&unit->ctl);
+ decref(&sdev->r);
+ poperror();
+ free(cb);
+ break;
+
+ case Qraw:
+ sdev = sdgetdev(DEV(c->qid));
+ if(sdev == nil)
+ error(Enonexist);
+ unit = sdev->unit[UNIT(c->qid)];
+ qlock(&unit->raw);
+ if(waserror()){
+ qunlock(&unit->raw);
+ decref(&sdev->r);
+ nexterror();
+ }
+ switch(unit->state){
+ case Rawcmd:
+ if(n < 6 || n > sizeof(req->cmd))
+ error(Ebadarg);
+ if((req = malloc(sizeof(SDreq))) == nil)
+ error(Enomem);
+ req->unit = unit;
+ memmove(req->cmd, a, n);
+ req->clen = n;
+ req->flags = SDnosense;
+ req->status = ~0;
+
+ unit->req = req;
+ unit->state = Rawdata;
+ break;
+
+ case Rawstatus:
+ unit->state = Rawcmd;
+ free(unit->req);
+ unit->req = nil;
+ error(Ebadusefd);
+
+ case Rawdata:
+ if(unit->state != Rawdata)
+ error(Ebadusefd);
+ unit->state = Rawstatus;
+
+ unit->req->write = 1;
+ n = sdrio(unit->req, a, n);
+ }
+ qunlock(&unit->raw);
+ decref(&sdev->r);
+ poperror();
+ break;
+ case Qpart:
+ return sdbio(c, 1, a, n, off);
+ }
+
+ return n;
+}
+
+static int
+sdwstat(Chan* c, uchar* dp, int n)
+{
+ Dir *d;
+ SDpart *pp;
+ SDperm *perm;
+ SDunit *unit;
+ SDev *sdev;
+
+ if(c->qid.type & QTDIR)
+ error(Eperm);
+
+ sdev = sdgetdev(DEV(c->qid));
+ if(sdev == nil)
+ error(Enonexist);
+ unit = sdev->unit[UNIT(c->qid)];
+ qlock(&unit->ctl);
+ d = nil;
+ if(waserror()){
+ free(d);
+ qunlock(&unit->ctl);
+ decref(&sdev->r);
+ nexterror();
+ }
+
+ switch(TYPE(c->qid)){
+ default:
+ error(Eperm);
+ case Qctl:
+ perm = &unit->ctlperm;
+ break;
+ case Qraw:
+ perm = &unit->rawperm;
+ break;
+ case Qpart:
+ pp = &unit->part[PART(c->qid)];
+ if(unit->vers+pp->vers != c->qid.vers)
+ error(Enonexist);
+ perm = &pp->SDperm;
+ break;
+ }
+
+ if(strcmp(up->env->user, perm->user) && !iseve())
+ error(Eperm);
+
+ d = smalloc(sizeof(Dir)+n);
+ n = convM2D(dp, n, &d[0], (char*)&d[1]);
+ if(n == 0)
+ error(Eshortstat);
+ if(!emptystr(d[0].uid))
+ kstrdup(&perm->user, d[0].uid);
+ if(d[0].mode != ~0UL)
+ perm->perm = (perm->perm & ~0777) | (d[0].mode & 0777);
+
+ free(d);
+ qunlock(&unit->ctl);
+ decref(&sdev->r);
+ poperror();
+ return n;
+}
+
+static char
+getspec(char base)
+{
+ while(1){
+ int i;
+ SDev *sdev;
+
+ for(i = 0; i != ndevs; i++)
+ if((sdev = devs[i].dev) != nil && (char)sdev->idno == base)
+ break;
+
+ if(i == ndevs)
+ return base;
+ base++;
+ }
+ return '\0';
+}
+
+static int
+configure(char* spec, DevConf* cf)
+{
+ ISAConf isa;
+ SDevgrp *tmpdevs;
+ SDev *tail, *sdev, *(*probe)(DevConf*);
+ char *p, name[32];
+ int i, nnew;
+
+ if((p = strchr(cf->type, '/')) != nil)
+ *p++ = '\0';
+
+ for(i = 0; sdifc[i] != nil; i++)
+ if(!strcmp(sdifc[i]->name, cf->type))
+ break;
+
+ if(sdifc[i] == nil)
+ error("type not found");
+
+ if((probe = sdifc[i]->probe) == nil)
+ error("No probe function");
+
+ if(p){
+ /* Try to find the card on the ISA bus. This code really belongs
+ in sdata and I'll move it later. Really! */
+ memset(&isa, 0, sizeof(isa));
+ isa.port = cf->ports[0].port;
+ isa.irq = cf->intnum;
+
+ if(pcmspecial(p, &isa) < 0)
+ error("Cannot find controller");
+ }
+
+ qlock(&devslock);
+ if(waserror()){
+ qunlock(&devslock);
+ nexterror();
+ }
+
+ for(i = 0; i != ndevs; i++)
+ if((sdev = devs[i].dev) != nil && sdev->idno == *spec)
+ break;
+ if(i != ndevs)
+ error(Eexist);
+
+ if((sdev = (*probe)(cf)) == nil)
+ error("Cannot probe controller");
+ poperror();
+
+ nnew = 0;
+ tail = sdev;
+ while(tail){
+ nnew++;
+ tail = tail->next;
+ }
+
+ tmpdevs = (SDevgrp*)malloc((ndevs + nnew) * sizeof(SDevgrp));
+ memmove(tmpdevs, devs, ndevs * sizeof(SDevgrp));
+ free(devs);
+ devs = tmpdevs;
+
+ while(sdev){
+ /* Assign `spec' to the device */
+ *spec = getspec(*spec);
+ snprint(name, sizeof(name), "sd%c", *spec);
+ kstrdup(&sdev->name, name);
+ sdev->idno = *spec;
+ sdev->unit = (SDunit **)malloc(sdev->nunit * sizeof(SDunit*));
+ sdev->unitflg = (int *)malloc(sdev->nunit * sizeof(int));
+ assert(sdev->unit && sdev->unitflg);
+
+ devs[ndevs].dev = sdev;
+ devs[ndevs].nunits = sdev->nunit;
+ sdev = sdev->next;
+ devs[ndevs].dev->next = nil;
+ ndevs++;
+ }
+
+ qunlock(&devslock);
+ return 0;
+}
+
+static int
+unconfigure(char* spec)
+{
+ int i;
+ SDev *sdev;
+
+ qlock(&devslock);
+ if(waserror()){
+ qunlock(&devslock);
+ nexterror();
+ }
+
+ sdev = nil;
+ for(i = 0; i != ndevs; i++)
+ if((sdev = devs[i].dev) != nil && sdev->idno == *spec)
+ break;
+
+ if(i == ndevs)
+ error(Enonexist);
+
+ if(sdev->r.ref)
+ error(Einuse);
+
+ /* make sure no interrupts arrive anymore before removing resources */
+ if(sdev->enabled && sdev->ifc->disable)
+ sdev->ifc->disable(sdev);
+
+ /* we're alone and the device tab is locked; make the device unavailable */
+ memmove(&devs[i], &devs[ndevs - 1], sizeof(SDevgrp));
+ memset(&devs[ndevs - 1], 0, sizeof(SDevgrp));
+ ndevs--;
+
+ qunlock(&devslock);
+ poperror();
+
+ for(i = 0; i != sdev->nunit; i++)
+ if(sdev->unit[i]){
+ SDunit *unit = sdev->unit[i];
+
+ free(unit->name);
+ free(unit->user);
+ free(unit);
+ }
+
+ if(sdev->ifc->clear)
+ sdev->ifc->clear(sdev);
+ return 0;
+}
+
+static int
+sdconfig(int on, char* spec, DevConf* cf)
+{
+ if(on)
+ return configure(spec, cf);
+ return unconfigure(spec);
+}
+
+Dev sddevtab = {
+ 'S',
+ "sd",
+
+ sdreset,
+ devinit,
+ devshutdown,
+ sdattach,
+ sdwalk,
+ sdstat,
+ sdopen,
+ devcreate,
+ sdclose,
+ sdread,
+ devbread,
+ sdwrite,
+ devbwrite,
+ devremove,
+ sdwstat,
+ devpower,
+ sdconfig,
+};
generated by cgit v1.2.3 (git 2.46.0) at 2025-12-10 04:40:27 +0000