## diffname port/devsd.c 1994/0913
## diff -e /dev/null /n/fornaxdump/1994/0913/sys/src/brazil/port/devsd.c
0a
/*
* SCSI disc driver
*/
#include "u.h"
#include "../port/lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "../port/error.h"
#include "devtab.h"
enum
{
LogNpart = 3,
Npart = 1<<LogNpart,
Ndisk = 32,
Nlun = 8,
};
#define DRIVE(qid) ((qid).path>>LogNpart)
#define PART(qid) ((qid).path&(Npart-1))
typedef struct Part Part;
typedef struct Disk Disk;
struct Part
{
ulong beg;
ulong end;
char name[NAMELEN];
};
struct Disk
{
QLock;
Target* t;
uchar lun;
char id[NAMELEN];
char vol[NAMELEN];
uchar* inquire;
ulong size;
ulong bsize;
int npart;
Part table[Npart];
};
int ndisk;
Disk disk[Ndisk];
static void sdrdpart(Disk*);
static long sdio(Chan*, int, char*, ulong, ulong);
static int
sdgen(Chan *c, Dirtab *tab, long ntab, long s, Dir *dirp)
{
Qid qid;
Disk *d;
Part *p;
int unit;
char name[2*NAMELEN];
USED(tab, ntab);
d = disk;
while(s >= d->npart) {
s -= d->npart;
d++;
}
unit = d - disk;
if(unit > ndisk)
return -1;
p = d->table+s;
sprint(name, "%s%s", d->vol, p->name);
name[NAMELEN-1] = '\0';
qid = (Qid){(unit<<LogNpart)+s, 0};
devdir(c, qid, name, (p->end - p->beg) * d->bsize, eve, 0666, dirp);
return 1;
}
void
sdreset(void)
{
}
void
sdinit(void)
{
Disk *d;
ulong s, b;
int dev, i;
dev = 0;
for(;;) {
d = &disk[ndisk];
dev = scsiinv(dev, 0, &d->t, &d->inquire, d->id);
if(dev < 0)
break;
if(scsistart(d->t, 0, 1) != STok)
continue;
/* Search for other lun's */
for(i = 0; i < Nlun; i++) {
d->lun = i;
scsireqsense(d->t, d->lun, 1);
/* NCR Raid only seems to answer second capacity
* command if lun != 0
*/
if(scsicap(d->t, d->lun, &s, &b) != STok) {
scsireqsense(d->t, 0, 1);
continue;
}
scsireqsense(d->t, 0, 1);
s = 0;
b = 0;
if(scsicap(d->t, d->lun, &s, &b) != STok) {
scsireqsense(d->t, 0, 1);
continue;
}
if(scsireqsense(d->t, d->lun, 1) != STok)
continue;
if(s == 0 || b == 0)
continue;
d->size = s;
d->bsize = b;
sprint(d->vol, "sd%d", ndisk);
if(++ndisk >= Ndisk)
break;
d++;
d->t = d[-1].t;
d->inquire = d[-1].inquire;
strcpy(d->id, d[-1].id);
}
if(ndisk >= Ndisk) {
print("devsd: configure more disks\n");
break;
}
}
}
Chan*
sdattach(char *spec)
{
int i;
for(i = 0; i < ndisk; i++)
sdrdpart(&disk[i]);
return devattach('w', spec);
}
Chan *
sdclone(Chan *c, Chan *nc)
{
return devclone(c, nc);
}
int
sdwalk(Chan *c, char *name)
{
return devwalk(c, name, 0, 0, sdgen);
}
void
sdstat(Chan *c, char *db)
{
devstat(c, db, 0, 0, sdgen);
}
Chan *
sdopen(Chan *c, int omode)
{
return devopen(c, omode, 0, 0, sdgen);
}
void
sdcreate(Chan *c, char *name, int omode, ulong perm)
{
USED(c, name, omode, perm);
error(Eperm);
}
void
sdremove(Chan *c)
{
USED(c);
error(Eperm);
}
void
sdwstat(Chan *c, char *dp)
{
USED(c, dp);
error(Eperm);
}
void
sdclose(Chan *c)
{
Disk *d;
Part *p;
if(c->mode != OWRITE && c->mode != ORDWR)
return;
d = &disk[DRIVE(c->qid)];
p = &d->table[PART(c->qid)];
if(strcmp(p->name, "partition"))
return;
sdrdpart(d);
}
long
sdread(Chan *c, void *a, long n, ulong offset)
{
if(c->qid.path == CHDIR)
return devdirread(c, a, n, 0, 0, sdgen);
return sdio(c, 0, a, n, offset);
}
long
sdwrite(Chan *c, char *a, long n, ulong offset)
{
return sdio(c, 1, a, n, offset);
}
static void
sdrdpart(Disk *d)
{
Part *p;
int n, i;
char *b, *line[Npart+2], *field[3];
static char MAGIC[] = "plan9 partitions";
b = scsialloc(d->bsize);
if(b == 0)
error(Enomem);
qlock(d);
p = d->table;
strcpy(p->name, "disk");
p->beg = 0;
p->end = d->size + 1;
p++;
strcpy(p->name, "partition");
p->beg = d->table[0].end - 1;
p->end = d->table[0].end;
p++;
d->npart = 2;
scsibio(d->t, d->lun, SCSIread, b, 1, d->bsize, d->table[0].end-1);
b[d->bsize-1] = '\0';
/*
* parse partition table.
*/
n = getfields(b, line, Npart+2, '\n');
if(n > 0 && strncmp(line[0], MAGIC, sizeof(MAGIC)-1) == 0) {
for(i = 1; i < n; i++) {
switch(getfields(line[i], field, 3, ' ')) {
case 2:
if(strcmp(field[0], "unit") == 0)
strncpy(d->vol, field[1], NAMELEN);
break;
case 3:
strncpy(p->name, field[0], NAMELEN);
p->beg = strtoul(field[1], 0, 0);
p->end = strtoul(field[2], 0, 0);
if(p->beg > p->end || p->beg >= d->table[0].end)
break;
p++;
}
}
}
d->npart = p - d->table;
scsifree(b);
qunlock(d);
}
static long
sdio(Chan *c, int write, char *a, ulong len, ulong offset)
{
Disk *d;
Part *p;
uchar *b;
ulong block, n, max, x;
d = &disk[DRIVE(c->qid)];
p = &d->table[PART(c->qid)];
block = (offset / d->bsize) + p->beg;
n = (offset + len + d->bsize - 1) / d->bsize + p->beg - block;
max = SCSImaxxfer / d->bsize;
if(n > max)
n = max;
if(block + n > p->end)
n = p->end - block;
if(block >= p->end || n == 0)
return 0;
b = scsialloc(n*d->bsize);
if(b == 0)
error(Enomem);
if(waserror()) {
scsifree(b);
nexterror();
}
offset %= d->bsize;
if(write) {
if(offset || len % d->bsize) {
x = scsibio(d->t, d->lun, SCSIread, b, n, d->bsize, block);
if(x < n * d->bsize) {
n = x / d->bsize;
x = n * d->bsize - offset;
if(len > x)
len = x;
}
}
memmove(b + offset, a, len);
x = scsibio(d->t, d->lun, SCSIwrite, b, n, d->bsize, block);
if(x < offset)
len = 0;
else
if(len > x - offset)
len = x - offset;
}
else {
x = scsibio(d->t, d->lun, SCSIread, b, n, d->bsize, block);
if(x < offset)
len = 0;
else
if(len > x - offset)
len = x - offset;
memmove(a, b+offset, len);
}
poperror();
scsifree(b);
return len;
}
.
## diffname port/devsd.c 1994/1228
## diff -e /n/fornaxdump/1994/0913/sys/src/brazil/port/devsd.c /n/fornaxdump/1994/1228/sys/src/brazil/port/devsd.c
278a
if(p >= &d->table[Npart])
break;
.
147a
print("sd out\n");
.
14c
LogNpart = 4,
.
## diffname port/devsd.c 1994/1230
## diff -e /n/fornaxdump/1994/1228/sys/src/brazil/port/devsd.c /n/fornaxdump/1994/1230/sys/src/brazil/port/devsd.c
148d
## diffname port/devsd.c 1995/0108
## diff -e /n/fornaxdump/1994/1230/sys/src/brazil/port/devsd.c /n/fornaxdump/1995/0108/sys/src/brazil/port/devsd.c
235a
}
long
sdbwrite(Chan *c, Block *bp, ulong offset)
{
return devbwrite(c, bp, offset);
.
231a
Block*
sdbread(Chan *c, long n, ulong offset)
{
return devbread(c, n, offset);
}
.
## diffname port/devsd.c 1995/0117
## diff -e /n/fornaxdump/1995/0108/sys/src/brazil/port/devsd.c /n/fornaxdump/1995/0117/sys/src/brazil/port/devsd.c
285c
switch(getfields(line[i], field, 3, " ")) {
.
282c
n = getfields(b, line, Npart+2, "\n");
.
## diffname port/devsd.c 1995/0324
## diff -e /n/fornaxdump/1995/0117/sys/src/brazil/port/devsd.c /n/fornaxdump/1995/0324/sys/src/brazil/port/devsd.c
214a
print("sdclose: qid 0x%lux drive %d, part %d\n", c->qid, DRIVE(c->qid), PART(c->qid));
.
## diffname port/devsd.c 1995/0325
## diff -e /n/fornaxdump/1995/0324/sys/src/brazil/port/devsd.c /n/fornaxdump/1995/0325/sys/src/brazil/port/devsd.c
227c
if(c->qid.path & CHDIR)
.
218,221c
if((c->mode&3) != OREAD && strcmp(p->name, "partition") == 0)
sdrdpart(d);
.
215d
212c
if(c->qid.path & CHDIR)
.
202d
200c
sdwstat(Chan*, char*)
.
195d
193c
sdremove(Chan*)
.
188d
186c
sdcreate(Chan*, char*, int, ulong)
.
63,64d
55c
sdgen(Chan *c, Dirtab*, long, long s, Dir *dirp)
.
## diffname port/devsd.c 1995/0329
## diff -e /n/fornaxdump/1995/0325/sys/src/brazil/port/devsd.c /n/fornaxdump/1995/0329/sys/src/brazil/port/devsd.c
105a
/*
* A SCSI target does not support a lun if the
* the peripheral device type and qualifier fields
* in the response to an inquiry command are 0x7F.
*/
memset(inq, 0, sizeof(inq));
nbytes = sizeof(inq);
if(scsiinquiry(d->t, d->lun, inq, &nbytes) != STok || inq[0] == 0x7F)
continue;
.
104a
.
90c
uchar inq[255];
int dev, i, nbytes;
.
## diffname port/devsd.c 1995/0403
## diff -e /n/fornaxdump/1995/0329/sys/src/brazil/port/devsd.c /n/fornaxdump/1995/0403/sys/src/brazil/port/devsd.c
321a
if(write && (d->inquire[0] & 0x1F) == TypeCD)
error(Eperm);
.
280a
if((d->inquire[0] & 0x1F) == TypeCD){
scsifree(b);
qunlock(d);
return;
}
.
144a
case TypeDA:
case TypeWO:
case TypeMO:
sprint(d->vol, "sd%d", ndisk);
break;
case TypeCD:
sprint(d->vol, "cd%d", ndisk);
break;
default:
continue;
}
.
143c
switch(d->inquire[0] & 0x1F){
.
96c
dev = scsiinv(dev, types, &d->t, &d->inquire, d->id);
.
53a
static int types[] = {
TypeDA, TypeWO, TypeCD, TypeMO,
-1,
};
.
11a
enum {
TypeDA = 0x00, /* Direct Access */
TypeWO = 0x04, /* Worm */
TypeCD = 0x05, /* CD-ROM */
TypeMO = 0x07, /* rewriteable Magneto-Optical */
};
.
## diffname port/devsd.c 1995/0404
## diff -e /n/fornaxdump/1995/0403/sys/src/brazil/port/devsd.c /n/fornaxdump/1995/0404/sys/src/brazil/port/devsd.c
169a
print("sd6|");
.
158d
151a
print("sd5/0x%2.2ux|", d->inquire[0]);
.
147,149d
145a
print("sd4/%d/%d|", s, b);
.
143c
scsireqsense(d->t, 0, 0);
.
131,139d
129a
print("sd3|");
.
119,120d
117a
print("sd2|");
.
112,113c
if(scsitest(d->t, 0) < 0)
scsireqsense(d->t, 0, 0);
if(scsistart(d->t, 0, 1) < 0)
scsireqsense(d->t, 0, 0);
print("sd1|");
.
62c
TypeDA, TypeCD, TypeMO,
.
16a
TYpeMC = 0x08, /* Medium Changer */
.
13a
TypeSA = 0x01, /* Sequential Access */
.
## diffname port/devsd.c 1995/0405
## diff -e /n/fornaxdump/1995/0404/sys/src/brazil/port/devsd.c /n/fornaxdump/1995/0405/sys/src/brazil/port/devsd.c
287d
283a
/*
* If the drive wasn't ready when we tried to do a
* read-capacity earlier (in sdinit()), try again.
* It might be possible to be smarter here, and look at the
* response from a test-unit-ready which would show if the
* target was in the process of becoming ready.
*/
if(d->size == 0 || d->bsize == 0){
if(scsicap(d->t, d->lun, &d->size, &d->bsize) != STok){
d->size = d->bsize = 0;
error(Eio);
}
}
.
164d
148,151d
144,146c
switch(type){
.
142d
140a
type = scratch[0] & 0x1F;
/*
* Read-capacity is mandatory for TypeDA, TypeMO and TypeCD.
* It may return 'not ready' if TypeDA is not spun up,
* TypeMO or TypeCD are not loaded or just plain slow getting
* their act together after a reset.
* If 'not ready' comes back, try starting a TypeDA and punt
* the get capacity until the drive is attached.
* It might be possible to be smarter here, and look at the
* response from a test-unit-ready which would show if the
* target was in the process of becoming ready.
*/
if(scsicap(d->t, d->lun, &d->size, &d->bsize) != STok) {
nbytes = sizeof(scratch);
memset(scratch, 0, nbytes);
scsireqsense(d->t, 0, scratch, &nbytes, 1);
if((scratch[2] & 0x0F) != 0x02)
continue;
if(type == TypeDA)
scsistart(d->t, d->lun, 0);
d->size = d->bsize = 0;
.
134,139c
if(scratch[0] == 0x7F)
.
130,132c
nbytes = sizeof(scratch);
memset(scratch, 0, nbytes);
if(scsiinquiry(d->t, d->lun, scratch, &nbytes) != STok)
.
123d
114,120c
/*
* Search for all the lun's.
*/
.
103,104c
uchar scratch[0xFF], type;
.
## diffname port/devsd.c 1995/0416
## diff -e /n/fornaxdump/1995/0405/sys/src/brazil/port/devsd.c /n/fornaxdump/1995/0416/sys/src/brazil/port/devsd.c
364a
if(d->bsize == 0)
error(Eio);
.
287,300d
189,191c
/*
* If the drive wasn't ready when we tried to do a
* read-capacity earlier (in sdinit()), try again.
* It might be possible to be smarter here, and look at the
* response from a test-unit-ready which would show if the
* target was in the process of becoming ready.
*/
nfound = 0;
for(i = 0; i < ndisk; i++){
d = &disk[i];
if(waserror()){
poperror();
continue;
}
if(d->size == 0 || d->bsize == 0){
if(scsicap(d->t, d->lun, &d->size, &d->bsize) != STok){
d->size = d->bsize = 0;
continue;
}
}
sdrdpart(d);
nfound++;
poperror();
}
if(nfound == 0)
return 0;
.
187c
int i, nfound;
Disk *d;
.
## diffname port/devsd.c 1995/0417
## diff -e /n/fornaxdump/1995/0416/sys/src/brazil/port/devsd.c /n/fornaxdump/1995/0417/sys/src/brazil/port/devsd.c
376,378d
311a
/*
* If the drive wasn't ready when we tried to do a
* read-capacity earlier (in sdinit()), try again.
* It might be possible to be smarter here, and look at the
* response from a test-unit-ready which would show if the
* target was in the process of becoming ready.
*/
if(d->size == 0 || d->bsize == 0){
if(scsicap(d->t, d->lun, &d->size, &d->bsize) != STok){
d->size = d->bsize = 0;
error(Eio);
}
}
.
190,216c
for(i = 0; i < ndisk; i++)
sdrdpart(&disk[i]);
.
187,188c
int i;
.
## diffname port/devsd.c 1995/0722
## diff -e /n/fornaxdump/1995/0417/sys/src/brazil/port/devsd.c /n/fornaxdump/1995/0722/sys/src/brazil/port/devsd.c
63c
static int types[] =
{
.
12c
enum
{
.
## diffname port/devsd.c 1995/0909
## diff -e /n/fornaxdump/1995/0722/sys/src/brazil/port/devsd.c /n/fornaxdump/1995/0909/sys/src/brazil/port/devsd.c
149c
if((scratch[2] & 0x0F) != 0x02 && (scratch[2] & 0x0F) != 0)
.
## diffname port/devsd.c 1996/0223
## diff -e /n/fornaxdump/1995/0909/sys/src/brazil/port/devsd.c /n/fornaxdump/1996/0223/sys/src/brazil/port/devsd.c
10d
## diffname port/devsd.c 1996/0315
## diff -e /n/fornaxdump/1996/0223/sys/src/brazil/port/devsd.c /n/fornaxdump/1996/0315/sys/src/brazil/port/devsd.c
334c
switch(parsefields(line[i], field, 3, " ")) {
.
331c
n = parsefields(b, line, Npart+2, "\n");
.
## diffname port/devsd.c 1996/0607
## diff -e /n/fornaxdump/1996/0315/sys/src/brazil/port/devsd.c /n/fornaxdump/1996/0607/sys/src/brazil/port/devsd.c
415c
buggery:
.
407a
if(x < 0){
len = -1;
goto buggery;
}
.
399a
if(x < 0){
len = -1;
goto buggery;
}
.
390a
if(x < 0){
len = -1;
goto buggery;
}
.
382,386c
return scsierrstr(STnomem);
.
367,369d
353c
d->partok = 1;
return STok;
.
334,348c
if(parsefields(line[i], field, 3, " ") != 3)
break;
if(p >= &d->table[Npart])
break;
strncpy(p->name, field[0], NAMELEN);
p->beg = strtoul(field[1], 0, 0);
p->end = strtoul(field[2], 0, 0);
if(p->beg > p->end || p->beg >= d->table[0].end)
break;
p++;
.
319,324d
309,311d
304,307c
return scsierrstr(STnomem);
.
301a
p->end = d->size + 1;
if((d->inquire[0] & 0x1F) == TypeCD)
return STok;
.
298c
return scsierrstr(n);
.
296c
n = scsicap(d->t, d->lun, &d->size, &d->bsize);
if(n != STok){
.
289,293c
* If the drive wasn't ready when a read-capacity was tried
* earlier (in sdinit()), try again.
.
287a
if(d->partok)
return STok;
p = d->table;
strcpy(p->name, "disk");
p->beg = 0;
p->end = 0;
d->npart = 1;
.
280c
static int
.
270a
Disk *d;
d = &disk[DRIVE(c->qid)];
if((d->inquire[0] & 0x1F) == TypeCD)
error(Eperm);
.
250a
qunlock(d);
}
.
249c
if((c->mode&3) != OREAD && strcmp(p->name, "partition") == 0){
qlock(d);
d->partok = 0;
.
190,191c
for(i = 0; i < ndisk; i++){
qlock(&disk[i]);
if(disk[i].partok == 0)
sdrdpart(&disk[i]);
qunlock(&disk[i]);
}
.
140,142d
60c
static int sdrdpart(Disk*);
.
49a
int partok;
ulong version;
.
## diffname port/devsd.c 1996/0710
## diff -e /n/fornaxdump/1996/0607/sys/src/brazil/port/devsd.c /n/fornaxdump/1996/0710/sys/src/brazil/port/devsd.c
181a
scsifree(scratch);
.
127c
nbytes = 0xFF;
.
109a
scratch = scsialloc(0xFF);
.
106c
uchar *scratch, type;
.
## diffname port/devsd.c 1996/1225
## diff -e /n/fornaxdump/1996/0710/sys/src/brazil/port/devsd.c /n/fornaxdump/1996/1225/sys/src/brazil/port/devsd.c
72c
sdgen(Chan *c, Dirtab*, int, int s, Dir *dirp)
.
## diffname port/devsd.c 1997/0327
## diff -e /n/fornaxdump/1996/1225/sys/src/brazil/port/devsd.c /n/emeliedump/1997/0327/sys/src/brazil/port/devsd.c
349c
if(parsefields(line[i], field, nelem(field), " ") != 3)
.
346c
n = parsefields(b, line, nelem(line), "\n");
.
289,293c
Dev sddevtab = {
devreset,
sdinit,
sdattach,
devclone,
sdwalk,
sdstat,
sdopen,
devcreate,
sdclose,
sdread,
devbread,
sdwrite,
devbwrite,
devremove,
devwstat,
};
.
271,277c
static long
.
262c
static long
.
225,243c
static void
.
219c
static Chan*
.
213c
static void
.
201,207c
static int
.
186c
static Chan*
.
145c
nbytes = 0xFF;
.
97,102c
static void
.
## diffname port/devsd.c 1997/0408
## diff -e /n/emeliedump/1997/0327/sys/src/brazil/port/devsd.c /n/emeliedump/1997/0408/sys/src/brazil/port/devsd.c
254a
'w',
"sd",
.
## diffname port/devsd.c 1998/0319
## diff -e /n/emeliedump/1997/0408/sys/src/brazil/port/devsd.c /n/emeliedump/1998/0319/sys/src/brazil/port/devsd.c
245a
ulong offset = off;
.
243c
sdwrite(Chan *c, char *a, long n, vlong off)
.
235a
ulong offset = off;
.
234c
sdread(Chan *c, void *a, long n, vlong off)
.
## diffname port/devsd.c 1998/0325
## diff -e /n/emeliedump/1998/0319/sys/src/brazil/port/devsd.c /n/emeliedump/1998/0325/sys/src/brazil/port/devsd.c
358a
ulong offset = off;
.
353c
sdio(Chan *c, int write, char *a, ulong len, vlong off)
.
248d
245c
sdwrite(Chan *c, char *a, long n, vlong offset)
.
236d
234c
sdread(Chan *c, void *a, long n, vlong offset)
.
63c
static long sdio(Chan*, int, char*, ulong, vlong);
.
## diffname port/devsd.c 1998/0327
## diff -e /n/emeliedump/1998/0325/sys/src/brazil/port/devsd.c /n/emeliedump/1998/0327/sys/src/brazil/port/devsd.c
376c
offset = off % d->bsize;
.
362,363c
block = (off / d->bsize) + p->beg;
n = (off + len + d->bsize - 1) / d->bsize + p->beg - block;
.
357c
ulong offset;
.
252c
return sdio(c, 1, a, n, off);
.
244c
sdwrite(Chan *c, char *a, long n, vlong off)
.
240c
return sdio(c, 0, a, n, off);
.
234c
sdread(Chan *c, void *a, long n, vlong off)
.
## diffname port/devsd.c 1998/0512
## diff -e /n/emeliedump/1998/0327/sys/src/brazil/port/devsd.c /n/emeliedump/1998/0512/sys/src/brazil/port/devsd.c
192c
.
## diffname port/devsd.c 1998/0930
## diff -e /n/emeliedump/1998/0512/sys/src/brazil/port/devsd.c /n/emeliedump/1998/0930/sys/src/brazil/port/devsd.c
144a
}
.
143c
switch(scratch[2] & 0x0F){
case 0x00:
case 0x01:
case 0x02:
break;
case 0x06:
if(scratch[12] == 0x28 && scratch[13] == 0)
break;
if(scratch[12] == 0x29 && scratch[13] == 0)
break;
/*FALLTHROUGH*/
default:
.
124a
.
## diffname port/devsd.c 1998/1022
## diff -e /n/emeliedump/1998/0930/sys/src/brazil/port/devsd.c /n/emeliedump/1998/1022/sys/src/brazil/port/devsd.c
93c
l = (p->end - p->beg) * (vlong)d->bsize;
devdir(c, qid, name, l, eve, 0666, dirp);
.
78a
vlong l;
.
## diffname port/devsd.c 1999/0228
## diff -e /n/emeliedump/1998/1022/sys/src/brazil/port/devsd.c /n/emeliedump/1999/0228/sys/src/brazil/port/devsd.c
155c
if(scratch[12] == 0x29 && !scratch[13])
.
153c
if(scratch[12] == 0x28 && !scratch[13])
.
135,140c
* Read-capacity is mandatory for TypeDA, TypeMO and
* TypeCD. It may return 'not ready' if TypeDA is not
* spun up, TypeMO or TypeCD are not loaded or just
* plain slow getting their act together after a reset.
* If 'not ready' comes back, try starting a TypeDA and
* punt the get capacity until the drive is attached.
.
## diffname port/devsd.c 1999/0320
## diff -e /n/emeliedump/1999/0228/sys/src/brazil/port/devsd.c /n/emeliedump/1999/0320/sys/src/brazil/port/devsd.c
260c
sdwrite(Chan *c, void *a, long n, vlong off)
.
## diffname port/devsd.c 1999/0507
## diff -e /n/emeliedump/1999/0320/sys/src/brazil/port/devsd.c /n/emeliedump/1999/0507/sys/src/brazil/port/devsd.c
45c
int lun;
.
## diffname port/devsd.c 1999/0728
## diff -e /n/emeliedump/1999/0507/sys/src/brazil/port/devsd.c /n/emeliedump/1999/0728/sys/src/brazil/port/devsd.c
73a
.
## diffname port/devsd.c 1999/1230
## diff -e /n/emeliedump/1999/0728/sys/src/brazil/port/devsd.c /n/emeliedump/1999/1230/sys/src/9/port/devsd.c
81a
if(s == DEVDOTDOT){
devdir(c, qid, "#w", 0, eve, 0555, dirp);
return 1;
}
.
## diffname port/devsd.c 2000/0104
## diff -e /n/emeliedump/1999/1230/sys/src/9/port/devsd.c /n/emeliedump/2000/0104/sys/src/9/port/devsd.c
349d
344a
n = parsefields(b, line, nelem(line), "\n");
if(n <= 0 || strncmp(line[0], MAGIC, sizeof(MAGIC)-1) != 0){
/* try the last */
scsibio(d->t, d->lun, SCSIread, b, 1, d->bsize, d->table[0].end-1);
b[d->bsize-1] = '\0';
n = parsefields(b, line, nelem(line), "\n");
/* only point partition file at last sector if there is one there */
if(n > 0 && strncmp(line[0], MAGIC, sizeof(MAGIC)-1) == 0){
d->table[1].beg++;
d->table[1].end++;
}
}
.
343c
/*
* Read second last sector from disk, null terminate.
* The last sector used to hold the partition tables.
* However, this sector is special on some PC's so we've
* started to use the second last sector as the partition
* table instead. To avoid reconfiguring all our old systems
* we still check if there is a valid partition table in
* the last sector if none is found in the second last.
*/
scsibio(d->t, d->lun, SCSIread, b, 1, d->bsize, d->table[0].end-2);
.
338,339c
p->beg = d->table[0].end - 2;
p->end = d->table[0].end - 1;
.
74d
## diffname port/devsd.c 2000/0308
## diff -e /n/emeliedump/2000/0104/sys/src/9/port/devsd.c /n/emeliedump/2000/0308/sys/src/9/port/devsd.c
371c
if(getfields(line[i], field, nelem(field), 1, " ") != 3)
.
358c
n = getfields(b, line, nelem(line), 1, "\n");
.
353c
n = getfields(b, line, nelem(line), 1, "\n");
.
## diffname port/devsd.c 2000/0506
## diff -e /n/emeliedump/2000/0308/sys/src/9/port/devsd.c /n/emeliedump/2000/0506/sys/src/9/port/devsd.c
461a
Dev sddevtab = {
'S',
"sd",
sdreset,
devinit,
sdattach,
sdclone,
sdwalk,
sdstat,
sdopen,
devcreate,
sdclose,
sdread,
devbread,
sdwrite,
devbwrite,
devremove,
sdwstat,
};
.
458,460c
if(unit->changed)
error(Enonexist);
pp = &unit->part[PART(c->qid)];
if(!pp->valid)
error(Enonexist);
if(strcmp(up->user, pp->user) && !iseve())
error(Eperm);
convM2D(dp, &d);
strncpy(pp->user, d.uid, NAMELEN);
pp->perm = d.mode&0777;
qunlock(&unit->ctl);
poperror();
.
444,455c
return n;
}
static void
sdwstat(Chan* c, char* dp)
{
Dir d;
SDpart *pp;
SDunit *unit;
if((c->qid.path & CHDIR) || TYPE(c->qid) != Qpart)
error(Eperm);
unit = sdunit[UNIT(c->qid)];
qlock(&unit->ctl);
if(waserror()){
qunlock(&unit->ctl);
nexterror();
.
438,442c
break;
case Qpart:
return sdbio(c, 1, a, n, off);
.
432,436c
else{
if(unit->pid != up->pid)
error(Eperm);
if(unit->state != Rawdata)
error(Ebadusefd);
unit->state = Rawstatus;
unit->req->write = 1;
return sdrio(unit->req, a, n);
.
430a
if((req = malloc(sizeof(SDreq))) == nil){
qunlock(&unit->raw);
error(Enomem);
}
req->unit = unit;
memmove(req->cmd, a, n);
req->clen = n;
req->flags = SDnosense;
req->status = ~0;
unit->req = req;
unit->pid = up->pid;
unit->state = Rawdata;
.
425,429c
if(n < 6 || n > sizeof(req->cmd)){
qunlock(&unit->raw);
error(Ebadarg);
.
413,423c
if(cb->nf < 1)
error(Ebadctl);
if(strcmp(cb->f[0], "part") == 0){
if(cb->nf != 4 || unit->npart >= SDnpart)
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);
poperror();
free(cb);
break;
case Qraw:
unit = sdunit[UNIT(c->qid)];
if(canqlock(&unit->raw)){
if(unit->state != Rawcmd){
qunlock(&unit->raw);
error(Ebadusefd);
.
403,411c
qlock(&unit->ctl);
if(waserror()){
qunlock(&unit->ctl);
free(cb);
nexterror();
}
if(unit->changed)
error(Eio);
.
400,401c
switch(TYPE(c->qid)){
default:
error(Eperm);
case Qctl:
cb = parsecmd(a, n);
unit = sdunit[UNIT(c->qid)];
.
394,398c
Cmdbuf *cb;
SDreq *req;
SDunit *unit;
ulong end, start;
.
392c
sdwrite(Chan *c, void *a, long n, vlong off)
.
386,388c
return 0;
.
383,384d
381a
if(unit->pid != up->pid)
error(Eperm);
if(unit->state == Rawdata){
unit->state = Rawstatus;
return sdrio(unit->req, a, n);
}
else if(unit->state == Rawstatus){
status = unit->req->status;
unit->pid = 0;
unit->state = Rawcmd;
free(unit->req);
unit->req = nil;
qunlock(&unit->raw);
return readnum(0, a, n, status, NUMSIZE);
}
break;
case Qpart:
return sdbio(c, 0, a, n, off);
.
364,380c
qunlock(&unit->ctl);
l = readstr(offset, a, n, p);
free(p);
return l;
case Qraw:
unit = sdunit[UNIT(c->qid)];
if(canqlock(&unit->raw)){
qunlock(&unit->raw);
error(Ebadusefd);
.
342,362c
offset = off;
switch(TYPE(c->qid)){
default:
error(Eperm);
case Qtopdir:
case Qunitdir:
return devdirread(c, a, n, 0, 0, sdgen);
case Qctl:
unit = sdunit[UNIT(c->qid)];
p = malloc(READSTR);
l = snprint(p, READSTR, "inquiry %.48s\n",
(char*)unit->inquiry+8);
qlock(&unit->ctl);
if(!unit->changed && unit->sectors){
/*
* 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);
else
l += snprint(p+l, READSTR-l,
"geometry %ld %ld\n",
unit->sectors, unit->secsize);
pp = unit->part;
for(i = 0; i < SDnpart; i++){
if(pp->valid)
l += snprint(p+l, READSTR-l,
"part %.*s %lud %lud\n",
NAMELEN, pp->name,
pp->start, pp->end);
pp++;
}
.
335,340c
static long
sdread(Chan *c, void *a, long n, vlong off)
{
char *p;
SDpart *pp;
SDunit *unit;
ulong offset;
int i, l, status;
.
331,333c
return r->rlen;
}
.
328,329c
if(!r->write && r->rlen > 0)
memmove(a, data, r->rlen);
if(data != nil){
sdfree(data);
r->data = nil;
}
poperror();
.
326c
if(r->unit->dev->ifc->rio(r) != SDok)
error(Eio);
.
323a
nexterror();
.
314,322c
if(waserror()){
if(data != nil){
sdfree(data);
r->data = nil;
.
308,312c
data = nil;
if(n){
if((data = sdmalloc(n)) == nil)
error(Enomem);
if(r->write)
memmove(data, a, n);
}
r->data = data;
r->dlen = n;
.
305,306c
if(n >= SDmaxio || n < 0)
error(Etoobig);
.
300,303c
void *data;
.
297,298c
static long
sdrio(SDreq* r, void* a, long n)
.
280,295c
return len;
}
.
276,278c
if(unit->inquiry[1] & 0x80){
qunlock(&unit->ctl);
poperror();
}
.
271,274c
offset = off%unit->secsize;
if(write){
if(offset || (len%unit->secsize)){
if((l = unit->dev->ifc->bio(unit, 0, 0, b, nb, bno)) < 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);
if((l = unit->dev->ifc->bio(unit, 0, 1, b, nb, bno)) < 0)
error(Eio);
if(l < offset)
len = 0;
else if(len > l - offset)
len = l - offset;
}
else {
if((l = unit->dev->ifc->bio(unit, 0, 0, b, nb, bno)) < 0)
error(Eio);
if(l < offset)
len = 0;
else if(len > l - offset)
len = l - offset;
memmove(a, b+offset, len);
}
sdfree(b);
poperror();
.
269c
b = sdmalloc(nb*unit->secsize);
if(b == nil)
error(Enomem);
if(waserror()){
sdfree(b);
nexterror();
}
.
264,267c
/*
* 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.
*/
pp = &unit->part[PART(c->qid)];
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);
poperror();
return 0;
}
if(!(unit->inquiry[1] & 0x80)){
qunlock(&unit->ctl);
poperror();
}
.
261,262c
qlock(&unit->ctl);
if(waserror()){
qunlock(&unit->ctl);
nexterror();
}
if(unit->changed)
error(Eio);
.
258,259c
unit = sdunit[UNIT(c->qid)];
.
256a
long l;
uchar *b;
SDpart *pp;
SDunit *unit;
ulong bno, max, nb, offset;
.
255c
sdbio(Chan* c, int write, char* a, long len, vlong off)
.
244,250c
switch(TYPE(c->qid)){
default:
break;
case Qraw:
unit = sdunit[UNIT(c->qid)];
if(canqlock(&unit->raw) || unit->pid == up->pid){
unit->pid = 0;
unit->state = Rawcmd;
qunlock(&unit->raw);
}
break;
case Qpart:
unit = sdunit[UNIT(c->qid)];
qlock(&unit->ctl);
if(waserror()){
qunlock(&unit->ctl);
c->flag &= ~COPEN;
nexterror();
}
pp = &unit->part[PART(c->qid)];
pp->nopen--;
unit->nopen--;
if(unit->nopen == 0)
unit->changed = 0;
qunlock(&unit->ctl);
poperror();
break;
.
242a
if(!(c->flag & COPEN))
return;
.
238,239c
SDpart *pp;
SDunit *unit;
.
236c
sdclose(Chan* c)
.
232c
SDpart *pp;
SDunit *unit;
c = devopen(c, omode, 0, 0, sdgen);
switch(TYPE(c->qid)){
default:
break;
case Qpart:
unit = sdunit[UNIT(c->qid)];
qlock(&unit->ctl);
if(waserror()){
qunlock(&unit->ctl);
c->flag &= ~COPEN;
nexterror();
}
if(unit->changed)
error(Eio);
pp = &unit->part[PART(c->qid)];
pp->nopen++;
unit->nopen++;
qunlock(&unit->ctl);
poperror();
break;
}
return c;
.
230c
sdopen(Chan* c, int omode)
.
226c
devstat(c, db, nil, 0, sdgen);
.
224c
sdstat(Chan* c, char* db)
.
220c
return devwalk(c, name, nil, 0, sdgen);
.
218c
sdwalk(Chan* c, char* name)
.
216a
static Chan*
sdclone(Chan* c, Chan* nc)
{
return devclone(c, nc);
}
.
214c
if(spec[0] != 's' || spec[1] != 'd')
error(Ebadspec);
idno = spec[2];
subno = strtol(&spec[3], &p, 0);
if(p == &spec[3])
error(Ebadspec);
for(sdev = sdlist; sdev != nil; sdev = sdev->next){
if(sdev->idno == idno && subno < sdev->nunit)
break;
}
if(sdev == nil || sdgetunit(sdev, subno) == nil)
error(Enonexist);
c = devattach(sddevtab.dc, spec);
c->qid = (Qid){QID(sdev->index+subno, 0, Qunitdir)|CHDIR, 0};
c->dev = sdev->index+subno;
return c;
.
207,211c
if(sdnunit == 0 || *spec == '\0'){
c = devattach(sddevtab.dc, spec);
c->qid = (Qid){QID(0, 0, Qtopdir)|CHDIR, 0};
return c;
.
205c
Chan *c;
char *p;
SDev *sdev;
int idno, subno;
.
203c
sdattach(char* spec)
.
199c
return -1;
.
197a
if(s < sdnunit){
if(sdunit[s] == nil && sdindex2unit(s) == nil)
return 0;
q = (Qid){QID(s, 0, Qunitdir)|CHDIR, 0};
devdir(c, q, sdunit[s]->name, 0, eve, 0555, dp);
return 1;
}
s -= sdnunit;
return sd1gen(c, s+Qtopbase, dp);
case Qunitdir:
if(s == DEVDOTDOT){
q = (Qid){QID(0, 0, Qtopdir)|CHDIR, 0};
snprint(name, NAMELEN, "#%C", sddevtab.dc);
devdir(c, q, name, 0, eve, 0555, dp);
return 1;
}
unit = sdunit[UNIT(c->qid)];
qlock(&unit->ctl);
if(!unit->changed && unit->sectors == 0)
sdinitpart(unit);
i = s+Qunitbase;
if(i < Qpart){
r = sd2gen(c, i, dp);
qunlock(&unit->ctl);
return r;
}
i -= Qpart;
if(unit->npart == 0 || i >= SDnpart){
qunlock(&unit->ctl);
break;
}
pp = &unit->part[i];
if(unit->changed || !pp->valid){
qunlock(&unit->ctl);
return 0;
}
l = (pp->end - pp->start) * (vlong)unit->secsize;
q = (Qid){QID(UNIT(c->qid), i, Qpart), c->qid.vers};
devdir(c, q, pp->name, l, pp->user, pp->perm, dp);
qunlock(&unit->ctl);
return 1;
case Qraw:
case Qctl:
case Qpart:
unit = sdunit[UNIT(c->qid)];
qlock(&unit->ctl);
r = sd2gen(c, TYPE(c->qid), dp);
qunlock(&unit->ctl);
return r;
default:
break;
.
196a
pp = &unit->part[PART(c->qid)];
l = (pp->end - pp->start) * (vlong)unit->secsize;
q = (Qid){QID(UNIT(c->qid), PART(c->qid), Qpart), c->qid.vers};
devdir(c, q, pp->name, l, pp->user, pp->perm, dp);
return 1;
}
return -1;
}
static int
sd1gen(Chan*, int i, Dir*)
{
switch(i){
default:
return -1;
}
return -1;
}
static int
sdgen(Chan* c, Dirtab*, int, int s, Dir* dp)
{
Qid q;
vlong l;
int i, r;
SDpart *pp;
SDunit *unit;
char name[NAMELEN];
switch(TYPE(c->qid)){
case Qtopdir:
if(s == DEVDOTDOT){
q = (Qid){QID(0, 0, Qtopdir)|CHDIR, 0};
snprint(name, NAMELEN, "#%C", sddevtab.dc);
devdir(c, q, name, 0, eve, 0555, dp);
return 1;
.
194,195c
/*
* 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(sdnunit == 0)
return;
if((sdunit = malloc(sdnunit*sizeof(SDunit*))) == nil)
return;
if((sdunitflg = malloc(sdnunit*sizeof(int))) == nil){
free(sdunit);
sdunit = nil;
return;
}
for(i = 0; sdifc[i] != nil; i++){
if(sdifc[i]->id)
sdifc[i]->id(sdlist);
}
}
static int
sd2gen(Chan* c, int i, Dir* dp)
{
Qid q;
vlong l;
SDpart *pp;
SDunit *unit;
switch(i){
case Qctl:
q = (Qid){QID(UNIT(c->qid), PART(c->qid), Qctl), c->qid.vers};
devdir(c, q, "ctl", 0, eve, 0640, dp);
return 1;
case Qraw:
q = (Qid){QID(UNIT(c->qid), PART(c->qid), Qraw), c->qid.vers};
devdir(c, q, "raw", 0, eve, 0600, dp);
return 1;
case Qpart:
unit = sdunit[UNIT(c->qid)];
if(unit->changed)
.
192a
tail->index = sdnunit;
sdnunit += tail->nunit;
}
.
186,191c
static void
sdreset(void)
{
int i;
SDev *sdev, *tail;
/*
* 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 = 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){
sdev->index = sdnunit;
sdnunit += tail->nunit;
.
182,184c
}
.
178,180c
return nil;
.
173,176c
/*
* Associate a unit with a given index into the top-level
* device directory.
* The device will be probed if it has not already been
* successfully accessed.
*/
for(sdev = sdlist; sdev != nil; sdev = sdev->next){
if(index >= sdev->index && index < sdev->index+sdev->nunit)
return sdgetunit(sdev, index-sdev->index);
}
.
171c
static SDunit*
sdindex2unit(int index)
{
SDev *sdev;
.
153,169c
return unit;
}
.
139,151c
/*
* 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(&sdqlock);
free(unit);
return nil;
}
sdunit[index] = unit;
}
qunlock(&sdqlock);
.
133,137c
snprint(unit->name, NAMELEN, "%s%d", sdev->name, subno);
unit->subno = subno;
unit->dev = sdev;
.
125,131c
if(sdev->enabled == 0 && sdev->ifc->enable)
sdev->ifc->enable(sdev);
sdev->enabled = 1;
.
122,123c
if(sdunitflg[index]){
qunlock(&sdqlock);
return nil;
}
if((unit = malloc(sizeof(SDunit))) == nil){
qunlock(&sdqlock);
return nil;
}
sdunitflg[index] = 1;
.
120c
* Probe the unit only once. This decision
* may be a little severe and reviewed later.
.
111,118c
/*
* 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(&sdqlock);
index = sdev->index+subno;
unit = sdunit[index];
if(unit == nil){
.
107,109c
int index;
SDunit *unit;
.
104,105c
static SDunit*
sdgetunit(SDev* sdev, int subno)
.
95,100c
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.
* sdC0=dos 63 123123/plan9 123123 456456
*/
for(p = getconf(unit->name); p != nil; p = q){
if(q = strchr(p, '/'))
*q++ = '\0';
nf = getfields(p, f, nelem(f), 1, " \t\r");
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();
}
}
}
.
91,93d
86,89c
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;
.
81,83c
unit->sectors = unit->secsize = 0;
unit->npart = 0;
if(unit->part){
free(unit->part);
unit->part = nil;
.
74,79c
int nf;
ulong start, end;
char *f[4], *p, *q;
.
72c
sdinitpart(SDunit* unit)
.
65,69c
unit->npart--;
if(unit->npart == 0){
free(unit->part);
unit->part = nil;
}
}
.
62,63c
/*
* Look for the partition to delete.
* Can't delete if someone still has it open.
* If it's the last valid partition zap the
* whole table.
*/
pp = unit->part;
for(i = 0; i < SDnpart; i++){
if(strncmp(name, pp->name, NAMELEN) == 0)
break;
pp++;
}
if(i >= SDnpart)
error(Ebadctl);
if(pp->nopen)
error(Einuse);
pp->valid = 0;
.
59,60c
static void
sddelpart(SDunit* unit, char* name)
{
int i;
SDpart *pp;
.
55,57c
/*
* Check there is a free slot and size and extent are valid.
*/
if(partno == -1 || start > end || end > unit->sectors)
error(Eio);
pp = &unit->part[partno];
pp->start = start;
pp->end = end;
strncpy(pp->name, name, NAMELEN);
strncpy(pp->user, eve, NAMELEN);
pp->perm = 0640;
pp->valid = 1;
unit->npart++;
}
.
49,53c
/*
* Check name not already used
* and look for a free slot.
*/
if(unit->part != nil){
partno = -1;
for(i = 0; i < SDnpart; 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);
partno = 0;
}
.
43,47c
SDpart *pp;
int i, partno;
.
41c
#define TYPE(q) ((q).path & 0x0F)
#define PART(q) (((q).path>>4) & 0x0F)
#define UNIT(q) (((q).path>>8) & 0xFF)
#define QID(u, p, t) (((u)<<8)|((p)<<4)|(t))
static void
sdaddpart(SDunit* unit, char* name, ulong start, ulong end)
.
34,38c
Qunitdir, /* directory per unit */
Qunitbase,
Qctl = Qunitbase,
Qraw,
Qpart,
.
31,32c
enum {
Qtopdir = 1, /* top level directory */
Qtopbase,
.
28,29d
21,26c
extern Dev sddevtab;
extern SDifc* sdifc[];
static QLock sdqlock;
static SDev* sdlist;
static SDunit** sdunit;
static int* sdunitflg;
static int sdnunit;
enum {
Rawcmd,
Rawdata,
Rawstatus,
.
11,19c
#include "sd.h"
.
4,9c
#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"
.
2c
* Storage Device.
.
## diffname port/devsd.c 2000/0515
## diff -e /n/emeliedump/2000/0506/sys/src/9/port/devsd.c /n/emeliedump/2000/0515/sys/src/9/port/devsd.c
301a
/*
* BUG: no check is made here or later when a
* unit is attached that the id and name are set.
*/
.
## diffname port/devsd.c 2000/0524
## diff -e /n/emeliedump/2000/0515/sys/src/9/port/devsd.c /n/emeliedump/2000/0524/sys/src/9/port/devsd.c
875c
if(strncmp(up->user, pp->user, NAMELEN) && !iseve())
.
626c
l = unit->dev->ifc->bio(unit, 0, 0, b, nb, bno);
if(l < 0)
.
618c
l = unit->dev->ifc->bio(unit, 0, 1, b, nb, bno);
if(l < 0)
.
608c
l = unit->dev->ifc->bio(unit, 0, 0, b, nb, bno);
if(l < 0)
.
406a
if(pp->user[0] == '\0')
strncpy(pp->user, eve, NAMELEN);
.
334a
if(pp->user[0] == '\0')
strncpy(pp->user, eve, NAMELEN);
.
158a
* This happens before /boot sets hostname so the
* partitions will have the null-string for user.
* The gen functions patch it up.
.
112a
if(strncmp(up->user, pp->user, NAMELEN) && !iseve())
error(Eperm);
.
65c
if(strncmp(name, pp->name, NAMELEN) == 0){
.
## diffname port/devsd.c 2000/0526
## diff -e /n/emeliedump/2000/0524/sys/src/9/port/devsd.c /n/emeliedump/2000/0526/sys/src/9/port/devsd.c
846,849c
break;
case Rawstatus:
unit->state = Rawcmd;
free(unit->req);
unit->req = nil;
error(Ebadusefd);
case Rawdata:
.
844d
836d
832,834c
if((req = malloc(sizeof(SDreq))) == nil)
.
824,830c
switch(unit->state){
case Rawcmd:
if(n < 6 || n > sizeof(req->cmd))
.
821a
.
763d
759d
747,752d
531,535c
unlock(&unit->rawinuse);
.
494a
case Qraw:
unit = sdunit[UNIT(c->qid)];
if(!canlock(&unit->rawinuse))
error(Einuse);
unit->state = Rawcmd;
break;
.
331c
devdir(c, q, "raw", 0, eve, CHEXCL|0600, dp);
.
## diffname port/devsd.c 2000/0530
## diff -e /n/emeliedump/2000/0526/sys/src/9/port/devsd.c /n/emeliedump/2000/0530/sys/src/9/port/devsd.c
165c
snprint(buf, sizeof buf, "%spart", unit->name);
for(p = getconf(buf); p != nil; p = q){
.
160c
* sdC0part=dos 63 123123/plan9 123123 456456
.
131c
char *f[4], *p, *q, buf[10];
.
## diffname port/devsd.c 2000/0531
## diff -e /n/emeliedump/2000/0530/sys/src/9/port/devsd.c /n/emeliedump/2000/0531/sys/src/9/port/devsd.c
499a
}
.
498c
if(!canlock(&unit->rawinuse)){
c->flag &= ~COPEN;
.
## diffname port/devsd.c 2000/0607
## diff -e /n/emeliedump/2000/0531/sys/src/9/port/devsd.c /n/emeliedump/2000/0607/sys/src/9/port/devsd.c
725,732c
if(unit->dev->ifc->rctl == nil)
.
723a
/*
* 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);
.
## diffname port/devsd.c 2000/0617
## diff -e /n/emeliedump/2000/0607/sys/src/9/port/devsd.c /n/emeliedump/2000/0617/sys/src/9/port/devsd.c
880c
if(unit->vers+pp->vers != c->qid.vers)
.
877,878d
798c
if(cb->nf != 4)
.
792c
if(unit->vers != c->qid.vers)
.
731c
if(unit->sectors == 0)
sdinitpart(unit);
if(unit->sectors){
.
591d
577c
pp = &unit->part[PART(c->qid)];
if(unit->vers+pp->vers != c->qid.vers)
.
573c
while(waserror()){
/* notification of media change; go around again */
if(strcmp(up->error, Eio) == 0 && unit->sectors == 0 && nchange++ == 0){
sdinitpart(unit);
continue;
}
/* other errors; give up */
.
571a
nchange = 0;
.
563a
int nchange;
.
542,557d
527d
515,516c
c->qid.vers = unit->vers+pp->vers;
.
512,513d
497a
c->qid.vers = unit->vers;
.
495a
case Qctl:
unit = sdunit[UNIT(c->qid)];
c->qid.vers = unit->vers;
break;
.
414c
q = (Qid){QID(UNIT(c->qid), i, Qpart), unit->vers+pp->vers};
.
409c
if(!pp->valid){
.
404c
if(unit->part == nil || i >= SDnpart){
.
396a
.
395c
/*
* 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))
.
340c
q = (Qid){QID(UNIT(c->qid), PART(c->qid), Qpart), unit->vers+pp->vers};
.
335,337d
331c
q = (Qid){QID(UNIT(c->qid), PART(c->qid), Qraw), unit->vers};
.
327c
q = (Qid){QID(UNIT(c->qid), PART(c->qid), Qctl), unit->vers};
.
324a
unit = sdunit[UNIT(c->qid)];
.
136,137c
for(i = 0; i < SDnpart; i++){
unit->part[i].valid = 0;
unit->part[i].vers++;
}
.
134d
132a
unit->vers++;
.
129c
int i, nf;
.
118,123c
pp->vers++;
.
115,116d
102,103d
90d
81c
if(partno == -1)
error(Ebadctl);
if(start > end || end > unit->sectors)
.
## diffname port/devsd.c 2000/0706
## diff -e /n/emeliedump/2000/0617/sys/src/9/port/devsd.c /n/emeliedump/2000/0706/sys/src/9/port/devsd.c
880,881c
strncpy(perm->user, d.uid, NAMELEN);
perm->perm = (perm->perm & ~0777) | (d.mode & 0777);
.
878a
if(strncmp(up->user, perm->user, NAMELEN) && !iseve())
error(Eperm);
.
877a
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;
}
.
873,876c
switch(TYPE(c->qid)){
default:
.
863c
if(c->qid.path & CHDIR)
.
860a
SDperm *perm;
.
394c
if(unit->sectors == 0
|| (unit->dev->ifc->online && unit->dev->ifc->online(unit) > 1))
.
391c
* If there is one waiting to be detected, online
* will return > 1.
.
373c
if(unit->user[0] == '\0')
strncpy(unit->user, eve, NAMELEN);
devdir(c, q, unit->name, 0, unit->user, unit->perm, dp);
.
370,371c
if((unit = sdunit[s]) == nil){
if((unit = sdindex2unit(s)) == nil)
return 0;
}
.
327c
perm = &unit->rawperm;
if(perm->user[0] == '\0'){
strncpy(perm->user, eve, NAMELEN);
perm->perm = CHEXCL|0600;
}
devdir(c, q, "raw", 0, perm->user, perm->perm, dp);
.
323c
perm = &unit->ctlperm;
if(perm->user[0] == '\0'){
strncpy(perm->user, eve, NAMELEN);
perm->perm = 0640;
}
devdir(c, q, "ctl", 0, perm->user, perm->perm, dp);
.
316a
SDperm *perm;
.
213a
strncpy(unit->user, eve, NAMELEN);
unit->perm = 0555;
.
## diffname port/devsd.c 2000/0809
## diff -e /n/emeliedump/2000/0706/sys/src/9/port/devsd.c /n/emeliedump/2000/0809/sys/src/9/port/devsd.c
752c
for(i = 0; i < unit->npart; i++){
.
423c
if(unit->part == nil || i >= unit->npart){
.
128c
for(i = 0; i < unit->npart; i++){
.
110c
if(i >= unit->npart)
.
105c
for(i = 0; i < unit->npart; i++){
.
81,83c
if(partno == -1){
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)
.
79c
* If no free slot found then increase the
* array size (can't get here with unit->part == nil).
.
74a
unit->npart = SDnpart;
.
58c
for(i = 0; i < unit->npart; i++){
.
## diffname port/devsd.c 2000/1129
## diff -e /n/emeliedump/2000/0809/sys/src/9/port/devsd.c /n/emeliedump/2000/1129/sys/src/9/port/devsd.c
880c
qunlock(&unit->raw);
poperror();
return n;
.
878c
n = sdrio(unit->req, a, n);
.
849a
qlock(&unit->raw);
if(waserror()){
qunlock(&unit->raw);
nexterror();
}
.
809a
case Qlog:
error(Ebadctl);
.
789,791c
i = readnum(0, a, n, status, NUMSIZE);
} else
i = 0;
qunlock(&unit->raw);
poperror();
return i;
.
782c
i = sdrio(unit->req, a, n);
.
779a
qlock(&unit->raw);
if(waserror()){
qunlock(&unit->raw);
nexterror();
}
.
743a
case Qlog:
unit = sdunit[UNIT(c->qid)];
return logread(&unit->log, a, 0, n);
.
636a
if(unit->log.opens) {
int i;
uchar lbuf[1+4+8], *p;
ulong x[3];
p = lbuf;
*p++ = write ? 'w' : 'r';
x[0] = off>>32;
x[1] = off;
x[2] = len;
for(i=0; i<3; i++) {
*p++ = x[i]>>24;
*p++ = x[i]>>16;
*p++ = x[i]>>8;
*p++ = x[i];
}
logn(&unit->log, 1, lbuf, 1+4+8);
}
.
570a
case Qlog:
unit = sdunit[UNIT(c->qid)];
logclose(&unit->log);
break;
.
527a
case Qlog:
unit = sdunit[UNIT(c->qid)];
logopen(&unit->log);
break;
.
454a
case Qlog:
.
336a
case Qlog:
q = (Qid){QID(UNIT(c->qid), PART(c->qid), Qlog), unit->vers};
perm = &unit->rawperm;
if(perm->user[0] == '\0'){
strncpy(perm->user, eve, NAMELEN);
perm->perm = 0666;
}
devdir(c, q, "log", 0, perm->user, perm->perm, dp);
return 1;
.
231a
unit->log.logmask = ~0;
unit->log.nlog = 16*1024;
unit->log.minread = 4*1024;
.
36a
Qlog,
.
13c
#include "../port/sd.h"
.
## diffname port/devsd.c 2001/0213
## diff -e /n/emeliedump/2000/1129/sys/src/9/port/devsd.c /n/emeliedump/2001/0213/sys/src/9/port/devsd.c
126,127d
## diffname port/devsd.c 2001/0527
## diff -e /n/emeliedump/2001/0213/sys/src/9/port/devsd.c /n/emeliedump/2001/0527/sys/src/9/port/devsd.c
1004d
994a
return n;
.
989,991c
n = convM2D(dp, n, &d[0], (char*)&d[1]);
if(n == 0)
error(Eshortstat);
kstrdup(&perm->user, d[0].uid);
perm->perm = (perm->perm & ~0777) | (d[0].mode & 0777);
.
987c
if(strcmp(up->user, perm->user) && !iseve())
.
960c
if(c->qid.type & QTDIR)
.
955c
Dir d[2];
.
952,953c
static int
sdwstat(Chan* c, uchar* dp, int n)
.
943,944c
break;
.
862,865d
812,814c
"part %s %lud %lud\n",
pp->name, pp->start, pp->end);
.
785,787d
658,677d
588,591d
580c
if(c->qid.type & QTDIR)
.
541,544d
525,530d
522c
return devstat(c, db, n, nil, 0, sdgen);
.
520c
sdstat(Chan* c, uchar* db, int n)
.
516c
return devwalk(c, nc, name, nname, nil, 0, sdgen);
.
513,514c
static Walkqid*
sdwalk(Chan* c, Chan* nc, char** name, int nname)
.
508c
mkqid(&c->qid, QID(sdev->index+subno, 0, Qunitdir), 0, QTDIR);
.
490c
mkqid(&c->qid, QID(0, 0, Qtopdir), 0, QTDIR);
.
467d
458,460c
mkqid(&q, QID(UNIT(c->qid), i, Qpart), unit->vers+pp->vers, QTFILE);
if(emptystr(pp->user))
kstrdup(&pp->user, eve);
.
422,424c
mkqid(&q, QID(s, 0, Qtopdir), 0, QTDIR);
sprint(up->genbuf, "#%C", sddevtab.dc);
devdir(c, q, up->genbuf, 0, eve, 0555, dp);
.
412,414c
mkqid(&q, QID(s, 0, Qunitdir), 0, QTDIR);
if(emptystr(unit->user))
kstrdup(&unit->user, eve);
.
402,404c
mkqid(&q, QID(s, 0, Qtopdir), 0, QTDIR);
sprint(up->genbuf, "#%C", sddevtab.dc);
devdir(c, q, up->genbuf, 0, eve, 0555, dp);
.
397d
390c
sdgen(Chan* c, char*, Dirtab*, int, int s, Dir* dp)
.
370,372c
mkqid(&q, QID(UNIT(c->qid), PART(c->qid), Qpart), unit->vers+pp->vers, QTFILE);
if(emptystr(pp->user))
kstrdup(&pp->user, eve);
.
361,363c
if(emptystr(perm->user)){
kstrdup(&perm->user, eve);
perm->perm = DMEXCL|0600;
.
359c
mkqid(&q, QID(UNIT(c->qid), PART(c->qid), Qraw), unit->vers, QTFILE);
.
352,353c
if(emptystr(perm->user)){
kstrdup(&perm->user, eve);
.
350c
mkqid(&q, QID(UNIT(c->qid), PART(c->qid), Qctl), unit->vers, QTFILE);
.
340,348d
231,234d
225,226c
snprint(buf, sizeof(buf), "%s%d", sdev->name, subno);
kstrdup(&unit->name, buf);
kstrdup(&unit->user, eve);
.
195a
char buf[32];
.
125a
if(strcmp(up->user, pp->user) && !iseve())
error(Eperm);
.
120c
if(strcmp(name, pp->name) == 0)
.
102,103c
kstrdup(&pp->name, name);
kstrdup(&pp->user, eve);
.
66c
if(strcmp(name, pp->name) == 0){
.
42,44c
#define TYPE(q) (((ulong)(q).path) & 0x0F)
#define PART(q) ((((ulong)(q).path)>>4) & 0x0F)
#define UNIT(q) ((((ulong)(q).path)>>8) & 0xFF)
.
37d
## diffname port/devsd.c 2001/0613
## diff -e /n/emeliedump/2001/0527/sys/src/9/port/devsd.c /n/emeliedump/2001/0613/sys/src/9/port/devsd.c
310a
if(sdnunit > NUnit)
sdnunit = NUnit;
.
83a
if(unit->npart >= NPart)
error(Enomem);
.
41,44c
#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 QID(u, p, t) (((u)<<UnitSHIFT)|((p)<<PartSHIFT)|((t)<<TypeSHIFT))
.
38a
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),
.
## diffname port/devsd.c 2001/0905
## diff -e /n/emeliedump/2001/0613/sys/src/9/port/devsd.c /n/emeliedump/2001/0905/sys/src/9/port/devsd.c
981a
devpower,
sdconfig,
.
963a
static char
getspec(char base)
{
while (1) {
int i;
SDev *sdev;
for (i = 0; i != ndevs; i++)
if ((sdev = devs[i].dt_dev) != nil && (char)sdev->idno == base)
break;
if (i == ndevs)
return base;
base++;
}
return '\0';
}
static int
configure(char *spec, DevConf *cf)
{
ISAConf isa;
dev_t *_devs;
SDev *tail, *sdev, *(*probe)(DevConf *);
char *p, name[32];
int i, added_devs;
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->interrupt;
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].dt_dev) != nil && sdev->idno == *spec)
break;
if (i != ndevs)
error(Eexist);
if ((sdev = (*probe)(cf)) == nil)
error("Cannot probe controller");
poperror();
added_devs = 0;
tail = sdev;
while (tail) {
added_devs++;
tail = tail->next;
}
_devs = (dev_t *)malloc((ndevs + added_devs) * sizeof(dev_t));
memmove(_devs, devs, ndevs * sizeof(dev_t));
free(devs);
devs = _devs;
while (sdev) {
/* Assign `spec' to the device */
*spec = getspec(*spec);
snprint(name, sizeof(name), "sd%c", *spec);
kstrdup(&sdev->name, name);
sdev->idno = *spec;
devs[ndevs].dt_dev = sdev;
devs[ndevs].dt_nunits = sdev->nunit;
sdev = sdev->next;
devs[ndevs].dt_dev->next = nil;
ndevs++;
}
qunlock(&devslock);
return 0;
}
static int
unconfigure(char *spec)
{
int i;
SDev *sdev;
qlock(&devslock);
if (waserror()) {
qunlock(&devslock);
nexterror();
}
for (sdev = nil, i = 0; i != ndevs; i++)
if ((sdev = devs[i].dt_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(dev_t));
memset(&devs[ndevs - 1], 0, sizeof(dev_t));
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)
{
return on? configure(spec, cf): unconfigure(spec);
}
.
959a
decref(&sdev->r);
.
930a
decref(&sdev->r);
.
927c
sdev = sdgetdev(DEV(c->qid));
if (sdev == nil)
error(Enonexist);
unit = sdev->unit[UNIT(c->qid)];
.
925c
error(Eperm);
.
922a
SDev *sdev;
.
906a
decref(&sdev->r);
.
873a
decref(&sdev->r);
.
870c
sdev = sdgetdev(DEV(c->qid));
if (sdev == nil)
error(Enonexist);
unit = sdev->unit[UNIT(c->qid)];
.
864a
decref(&sdev->r);
.
837a
decref(&sdev->r);
.
833c
sdev = sdgetdev(DEV(c->qid));
if (sdev == nil)
error(Enonexist);
unit = sdev->unit[UNIT(c->qid)];
.
830a
case Qtopctl: {
confdata_t cd;
char buf[256], *field[Ncmd];
int nf, i, j;
memset(&cd, 0, sizeof(confdata_t));
if(n > sizeof(buf)-1) n = sizeof(buf)-1;
memmove(buf, a, n);
buf[n] = '\0';
cd.o_on = -1;
cd.o_spec = '\0';
memset(&cd.o_cf, 0, sizeof(DevConf));
nf = getfields(buf, field, Ncmd, 1, " \t\n");
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.o_on < 0)
error(Ebadarg);
if (cd.o_on) {
if (cd.o_spec == '\0' || cd.o_cf.nports == 0 ||
cd.o_cf.interrupt == 0 || cd.o_cf.type == nil)
error(Ebadarg);
}
else {
if (cd.o_spec == '\0')
error(Ebadarg);
}
if (sddevtab.config == nil)
error("No configuration function");
sddevtab.config(cd.o_on, cd.o_spec, &cd.o_cf);
break;
}
.
825a
SDev *sdev;
.
819a
typedef struct {
int o_on;
char *o_spec;
DevConf o_cf;
} confdata_t;
static void
parse_switch(confdata_t *cd, char *option)
{
if (!strcmp("on", option))
cd->o_on = 1;
else if (!strcmp("off", option))
cd->o_on = 0;
else
error(Ebadarg);
}
static void
parse_spec(confdata_t *cd, char *option)
{
if (strlen(option) > 1)
error(Ebadarg);
cd->o_spec = option;
}
static port_t *
getnewport(DevConf *dc)
{
port_t *p;
p = (port_t *)malloc((dc->nports + 1) * sizeof(port_t));
if (dc->nports > 0) {
memmove(p, dc->ports, dc->nports * sizeof(port_t));
free(dc->ports);
}
dc->ports = p;
p = &dc->ports[dc->nports++];
p->size = -1;
p->port = (ulong)-1;
return p;
}
static void
parse_port(confdata_t *cd, char *option)
{
char *e;
port_t *p;
p = (cd->o_cf.nports == 0 ||
cd->o_cf.ports[cd->o_cf.nports -1].port != (ulong)-1)?
getnewport(&cd->o_cf): &cd->o_cf.ports[cd->o_cf.nports - 1];
p->port = strtol(option, &e, 0);
if (e == nil || *e != '\0')
error(Ebadarg);
}
static void
parse_size(confdata_t *cd, char *option)
{
char *e;
port_t *p;
p = (cd->o_cf.nports == 0 || cd->o_cf.ports[cd->o_cf.nports -1].size != -1)?
getnewport(&cd->o_cf): &cd->o_cf.ports[cd->o_cf.nports - 1];
p->size = (int)strtol(option, &e, 0);
if (e == nil || *e != '\0')
error(Ebadarg);
}
static void
parse_irq(confdata_t *cd, char *option)
{
char *e;
cd->o_cf.interrupt = strtoul(option, &e, 0);
if (e == nil || *e != '\0')
error(Ebadarg);
}
static void
parse_type(confdata_t *cd, char *option)
{
cd->o_cf.type = option;
}
static struct {
char *option;
void (*parse)(confdata_t *, char *);
} options[] = {
{ "switch", parse_switch, },
{ "spec", parse_spec, },
{ "port", parse_port, },
{ "size", parse_size, },
{ "irq", parse_irq, },
{ "type", parse_type, },
};
.
812a
.
810a
decref(&sdev->r);
.
795a
decref(&sdev->r);
.
792c
sdev = sdgetdev(DEV(c->qid));
if (sdev == nil)
error(Enonexist);
unit = sdev->unit[UNIT(c->qid)];
.
790a
.
787a
decref(&sdev->r);
.
759c
sdev = sdgetdev(DEV(c->qid));
if (sdev == nil)
error(Enonexist);
unit = sdev->unit[UNIT(c->qid)];
.
757a
.
754a
case Qtopstat:
p = buf = malloc(READSTR);
assert(p);
e = p + READSTR;
qlock(&devslock);
for (i = 0; i != ndevs; i++) {
SDev *sdev = devs[i].dt_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;
.
747a
SDev *sdev;
.
745c
char *p, *e, *buf;
.
698a
decref(&sdev->r);
.
655a
if(!(unit->inquiry[1] & 0x80))
decref(&sdev->r); /* gadverdamme! */
.
642a
decref(&sdev->r);
.
614a
decref(&sdev->r);
.
602c
sdev = sdgetdev(DEV(c->qid));
if (sdev == nil)
error(Enonexist);
unit = sdev->unit[UNIT(c->qid)];
if (unit == nil)
error(Enonexist);
.
599a
SDev *sdev;
.
586,587c
sdev = sdgetdev(DEV(c->qid));
if (sdev) {
unit = sdev->unit[UNIT(c->qid)];
unlock(&unit->rawinuse);
decref(&sdev->r);
}
.
575a
SDev *sdev;
.
568a
decref(&sdev->r);
.
556d
547d
543d
540,541d
538a
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)];
.
536a
SDev *sdev;
uchar tp;
.
515,516c
mkqid(&c->qid, QID(sdev->idno, subno, 0, Qunitdir), 0, QTDIR);
c->dev = (sdev->idno << UnitLOG) + subno;
decref(&sdev->r);
.
512a
}
incref(&sdev->r);
qunlock(&devslock);
.
510,511c
if (i == ndevs || subno >= sdev->nunit || sdgetunit(sdev, subno) == nil) {
qunlock(&devslock);
.
507,508c
qlock(&devslock);
for (sdev = nil, i = 0; i != ndevs; i++)
if ((sdev = devs[i].dt_dev) != nil && sdev->idno == idno)
.
497c
mkqid(&c->qid, QID(0, 0, 0, Qtopdir), 0, QTDIR);
.
495c
if(ndevs == 0 || *spec == '\0'){
.
493c
int idno, subno, i;
.
478a
decref(&sdev->r);
.
475c
if ((sdev = sdgetdev(DEV(c->qid))) == nil) {
devdir(c, q, "unavailable", 0, eve, 0, dp);
return 1;
}
unit = sdev->unit[UNIT(c->qid)];
.
470a
decref(&sdev->r);
.
466c
mkqid(&q, QID(DEV(c->qid), UNIT(c->qid), i, Qpart),
unit->vers+pp->vers, QTFILE);
.
462a
decref(&sdev->r);
.
457a
decref(&sdev->r);
.
452a
decref(&sdev->r);
.
435c
if ((sdev = sdgetdev(DEV(c->qid))) == nil) {
devdir(c, q, "unavailable", 0, eve, 0, dp);
return 1;
}
unit = sdev->unit[UNIT(c->qid)];
.
430c
mkqid(&q, QID(0, s, 0, Qtopdir), 0, QTDIR);
.
426,427c
if (i == ndevs) {
/* Run of the end of the list */
qunlock(&devslock);
return -1;
}
if ((sdev = devs[i].dt_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;
}
.
415,424c
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].dt_nunits)
break;
s -= devs[i].dt_nunits;
.
410c
mkqid(&q, QID(0, s, 0, Qtopdir), 0, QTDIR);
.
408c
case Qtopdir: {
.
405a
SDev *sdev;
.
392,393c
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;
.
390a
Qid q;
.
389c
sd1gen(Chan* c, int i, Dir* dp)
.
383,385c
rv = 1;
break;
}
decref(&sdev->r);
return rv;
.
379c
mkqid(&q, QID(DEV(c->qid), UNIT(c->qid), PART(c->qid), Qpart),
unit->vers+pp->vers, QTFILE);
.
375c
rv = 1;
break;
.
368c
mkqid(&q, QID(DEV(c->qid), UNIT(c->qid), PART(c->qid), Qraw),
unit->vers, QTFILE);
.
366c
rv = 1;
break;
.
359c
mkqid(&q, QID(DEV(c->qid), UNIT(c->qid), PART(c->qid), Qctl),
unit->vers, QTFILE);
.
356c
sdev = sdgetdev(DEV(c->qid));
assert(sdev);
unit = sdev->unit[UNIT(c->qid)];
rv = -1;
.
354a
SDev *sdev;
int rv;
.
344a
/*
* The IDs have been set, unlink the sdlist and copy the spec to
* the devtab.
*/
devs = (dev_t *)malloc(ndevs * sizeof(dev_t));
memset(devs, 0, ndevs * sizeof(dev_t));
i = 0;
while (sdlist != nil) {
devs[i].dt_dev = sdlist;
devs[i].dt_nunits = sdlist->nunit;
sdlist = sdlist->next;
devs[i].dt_dev->next = nil;
i++;
}
.
328,336d
326c
if(ndevs == 0)
.
315c
.
308,313c
for(tail = sdev; tail->next != nil; tail = tail->next)
ndevs++;
ndevs++;
.
300c
tail = sdlist = nil;
.
292c
SDev *sdev, *tail, *sdlist;
.
268,287d
263,264c
qunlock(&sdev->unitlock);
.
261c
sdev->unit[subno] = unit;
.
257c
qunlock(&sdev->unitlock);
.
238c
sdev->unitflg[subno] = 1;
.
235c
qunlock(&sdev->unitlock);
.
230,231c
if(sdev->unitflg[subno]){
qunlock(&sdev->unitlock);
.
222,224c
qlock(&sdev->unitlock);
if (subno > sdev->nunit) {
qunlock(&sdev->unitlock);
return nil;
}
unit = sdev->unit[subno];
.
212d
208a
static SDev *
sdgetdev(int idno)
{
SDev *sdev;
int i;
qlock(&devslock);
for (i = 0; i != ndevs; i++)
if (devs[i].dt_dev->idno == idno)
break;
if (i == ndevs)
sdev = nil;
else {
sdev = devs[i].dt_dev;
incref(&sdev->r);
}
qunlock(&devslock);
return sdev;
}
.
60a
.
59c
#define DEV(q) ((((ulong)(q).path)>>DevSHIFT) & DevMASK)
#define QID(d,u, p, t) (((d)<<DevSHIFT)|((u)<<UnitSHIFT)|\
((p)<<PartSHIFT)|((t)<<TypeSHIFT))
.
53a
DevLOG = 8,
NDev = (1 << DevLOG),
DevMASK = (NDev-1),
DevSHIFT = (UnitLOG+PartLOG+TypeLOG),
Ncmd = 20,
.
32a
Qtopctl = Qtopbase,
Qtopstat,
.
23a
static dev_t *devs; /* all devices */
static QLock devslock; /* insertion and removal of devices */
static int ndevs; /* total number of devices in the system */
.
18,22c
typedef struct {
SDev *dt_dev;
int dt_nunits; /* num units in dev */
} dev_t;
.
## diffname port/devsd.c 2001/0907
## diff -e /n/emeliedump/2001/0905/sys/src/9/port/devsd.c /n/emeliedump/2001/0907/sys/src/9/port/devsd.c
568a
case Qtopctl:
case Qtopstat:
return sd1gen(c, TYPE(c->qid), dp);
.
327a
}
tail->unit = (SDunit **)malloc(tail->nunit * sizeof(SDunit *));
tail->unitflg = (int *)malloc(tail->nunit * sizeof(int));
.
326c
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);
.
## diffname port/devsd.c 2001/0911
## diff -e /n/emeliedump/2001/0907/sys/src/9/port/devsd.c /n/emeliedump/2001/0911/sys/src/9/port/devsd.c
1368a
sdev->unit = (SDunit **)malloc(sdev->nunit * sizeof(SDunit *));
sdev->unitflg = (int *)malloc(sdev->nunit * sizeof(int));
assert(sdev->unit && sdev->unitflg);
.
## diffname port/devsd.c 2001/0924
## diff -e /n/emeliedump/2001/0911/sys/src/9/port/devsd.c /n/emeliedump/2001/0924/sys/src/9/port/devsd.c
730c
if(strcmp(up->errstr, Eio) == 0 && unit->sectors == 0 && nchange++ == 0){
.
## diffname port/devsd.c 2001/1106
## diff -e /n/emeliedump/2001/0924/sys/src/9/port/devsd.c /n/emeliedump/2001/1106/sys/src/9/port/devsd.c
1277a
free(d);
.
1275,1276c
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);
.
1271a
d = smalloc(sizeof(Dir)+n);
.
1247a
free(d);
.
1246a
d = nil;
.
1233c
Dir *d;
.
## diffname port/devsd.c 2001/1117
## diff -e /n/emeliedump/2001/1106/sys/src/9/port/devsd.c /n/emeliedump/2001/1117/sys/src/9/port/devsd.c
1103c
nf = tokenize(buf, field, Ncmd);
.
208c
nf = tokenize(p, f, nelem(f));
.
## diffname port/devsd.c 2002/0109
## diff -e /n/emeliedump/2001/1117/sys/src/9/port/devsd.c /n/emeliedump/2002/0109/sys/src/9/port/devsd.c
1450a
devshutdown,
.
## diffname port/devsd.c 2002/0316
## diff -e /n/emeliedump/2002/0109/sys/src/9/port/devsd.c /n/emeliedump/2002/0316/sys/src/9/port/devsd.c
1442c
if(on)
return configure(spec, cf);
return unconfigure(spec);
.
1440c
sdconfig(int on, char* spec, DevConf* cf)
.
1434c
if(sdev->ifc->clear)
.
1425,1426c
for(i = 0; i != sdev->nunit; i++)
if(sdev->unit[i]){
.
1414c
if(sdev->enabled && sdev->ifc->disable)
.
1410c
if(sdev->r.ref)
.
1407c
if(i == ndevs)
.
1403,1404c
sdev = nil;
for(i = 0; i != ndevs; i++)
if((sdev = devs[i].dt_dev) != nil && sdev->idno == *spec)
.
1398c
if(waserror()){
.
1392c
unconfigure(char* spec)
.
1376c
sdev->unit = (SDunit **)malloc(sdev->nunit * sizeof(SDunit*));
.
1370c
while(sdev){
.
1365c
_devs = (dev_t*)malloc((ndevs + added_devs) * sizeof(dev_t));
.
1360c
while(tail){
.
1354c
if((sdev = (*probe)(cf)) == nil)
.
1351c
if(i != ndevs)
.
1348,1349c
for(i = 0; i != ndevs; i++)
if((sdev = devs[i].dt_dev) != nil && sdev->idno == *spec)
.
1343c
if(waserror()){
.
1338c
if(pcmspecial(p, &isa) < 0)
.
1331c
if(p){
.
1328c
if((probe = sdifc[i]->probe) == nil)
.
1325c
if(sdifc[i] == nil)
.
1318c
if((p = strchr(cf->type, '/')) != nil)
.
1314c
SDev *tail, *sdev, *(*probe)(DevConf*);
.
1310c
configure(char* spec, DevConf* cf)
.
1302c
if(i == ndevs)
.
1298,1299c
for(i = 0; i != ndevs; i++)
if((sdev = devs[i].dt_dev) != nil && (char)sdev->idno == base)
.
1294c
while(1){
.
1180c
if(sdev == nil)
.
1130c
if(sddevtab.config == nil)
.
1125,1126c
else{
if(cd.o_spec == '\0')
.
1120,1121c
if(cd.o_on){
if(cd.o_spec == '\0' || cd.o_cf.nports == 0 ||
.
1117c
if(cd.o_on < 0)
.
1112c
if(j == nelem(options))
.
1108,1109c
for(j = 0; j != nelem(options); j++)
if(!strcmp(opt, options[j].option))
.
1106c
if(i >= nf)
.
1104c
for(i = 0; i < nf; i++){
.
1078c
sdwrite(Chan* c, void* a, long n, vlong off)
.
1073c
{ "irq", parse_irq, },
.
1069c
{ "switch", parse_switch, },
.
1066,1067c
char *option;
void (*parse)(confdata_t*, char*);
.
1060c
parse_type(confdata_t* cd, char* option)
.
1055c
if(e == nil || *e != '\0')
.
1050c
parse_irq(confdata_t* cd, char* option)
.
1042,1045c
if(cd->o_cf.nports == 0 || cd->o_cf.ports[cd->o_cf.nports-1].size != -1)
p = getnewport(&cd->o_cf);
else
p = &cd->o_cf.ports[cd->o_cf.nports-1];
p->size = (int)strtol(option, &e, 0);
if(e == nil || *e != '\0')
.
1037c
parse_size(confdata_t* cd, char* option)
.
1032c
if(e == nil || *e != '\0')
.
1027,1030c
if(cd->o_cf.nports == 0 || cd->o_cf.ports[cd->o_cf.nports-1].port != (ulong)-1)
p = getnewport(&cd->o_cf);
else
p = &cd->o_cf.ports[cd->o_cf.nports-1];
.
1023c
parse_port(confdata_t* cd, char* option)
.
1011c
if(dc->nports > 0){
.
1005,1006c
static port_t*
getnewport(DevConf* dc)
.
1000c
if(strlen(option) > 1)
.
998c
parse_spec(confdata_t* cd, char* option)
.
991c
else if(!strcmp("off", option))
.
989c
if(!strcmp("on", option))
.
987c
parse_switch(confdata_t* cd, char* option)
.
981,982c
int o_on;
char* o_spec;
.
891c
if(sdev->ifc->stat)
.
888c
for(i = 0; i != ndevs; i++){
.
807c
else{
.
723c
if(unit == nil)
.
720c
if(sdev == nil)
.
650c
if(sdev == nil)
.
646c
if((tp = TYPE(c->qid)) != Qctl && tp != Qraw && tp != Qpart)
.
611c
if(i == ndevs || subno >= sdev->nunit || sdgetunit(sdev, subno) == nil){
.
565c
if((sdev = sdgetdev(DEV(c->qid))) == nil){
.
515c
if((sdev = sdgetdev(DEV(c->qid))) == nil){
.
505d
494c
if((unit = sdgetunit(sdev, s)) == nil){
.
485c
if ((sdev = devs[i].dt_dev) == nil){
.
479c
if(i == ndevs){
.
473c
for(i = 0; i != ndevs; i++){
.
468c
if(s == 0 || s == 1)
.
460c
case Qtopdir:
.
365c
while(sdlist != nil){
.
362c
devs = (dev_t*)malloc(ndevs * sizeof(dev_t));
.
332,333c
tail->unit = (SDunit**)malloc(tail->nunit * sizeof(SDunit*));
tail->unitflg = (int*)malloc(tail->nunit * sizeof(int));
.
326,328c
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));
.
258c
if(subno > sdev->nunit){
.
237c
else{
.
235c
if(i == ndevs)
.
231c
for(i = 0; i != ndevs; i++)
.
224c
static SDev*
.
71c
#define DEV(q) ((((ulong)(q).path)>>DevSHIFT) & DevMASK)
.
23,25c
static dev_t* devs; /* all devices */
static QLock devslock; /* insertion and removal of devices */
static int ndevs; /* total number of devices in the system */
.
19,20c
SDev* dt_dev;
int dt_nunits; /* num units in dev */
.
## diffname port/devsd.c 2002/0330
## diff -e /n/emeliedump/2002/0316/sys/src/9/port/devsd.c /n/emeliedump/2002/0330/sys/src/9/port/devsd.c
784a
if(offset+len > nb*unit->secsize)
len = nb*unit->secsize - offset;
.
## diffname port/devsd.c 2002/0402
## diff -e /n/emeliedump/2002/0330/sys/src/9/port/devsd.c /n/emeliedump/2002/0402/sys/src/9/port/devsd.c
700c
unit->rawinuse = 0;
.
659c
if(tas(&unit->rawinuse) != 0){
.
## diffname port/devsd.c 2002/0703
## diff -e /n/emeliedump/2002/0402/sys/src/9/port/devsd.c /n/emeliedump/2002/0703/sys/src/9/port/devsd.c
1340c
isa.irq = cf->intnum;
.
1126c
cd.o_cf.intnum == 0 || cd.o_cf.type == nil)
.
1058c
cd->o_cf.intnum = strtoul(option, &e, 0);
.
## diffname port/devsd.c 2003/0406
## diff -e /n/emeliedump/2002/0703/sys/src/9/port/devsd.c /n/emeliedump/2003/0406/sys/src/9/port/devsd.c
1247c
if(sdev == nil)
.
1142c
if(sdev == nil)
.
947c
if(sdev == nil)
.
908c
if(sdev == nil)
.
698c
if(sdev) {
.
607c
if((sdev = devs[i].dt_dev) != nil && sdev->idno == idno)
.
485c
if((sdev = devs[i].dt_dev) == nil){
.
474c
if(s < devs[i].dt_nunits)
.
232c
if(devs[i].dt_dev->idno == idno)
.
## diffname port/devsd.c 2003/0507
## diff -e /n/emeliedump/2003/0406/sys/src/9/port/devsd.c /n/emeliedump/2003/0507/sys/src/9/port/devsd.c
288a
if(sdev->enabled == 0 && sdev->ifc->enable)
sdev->ifc->enable(sdev);
sdev->enabled = 1;
.
279,282d
|
