static struct walkqid *pipewalk(struct chan *c, struct chan *nc, char **name,
int nname)
{
struct walkqid *wq;
Pipe *p;
p = c->aux;
wq = devwalk(c, nc, name, nname, p->pipedir, ARRAY_SIZE(pipedir), pipegen);
if (wq != NULL && wq->clone != NULL && wq->clone != c) {
qlock(&p->qlock);
kref_get(&p->ref, 1);
if (c->flag & COPEN) {
switch (NETTYPE(c->qid.path)) {
case Qdata0:
p->qref[0]++;
break;
case Qdata1:
p->qref[1]++;
break;
}
}
qunlock(&p->qlock);
}
return wq;
}
static Walkqid*
devlogfswalk(Chan *c, Chan *nc, char **name, int nname)
{
int instance, qid, qt, clone;
Walkqid *wq;
#ifdef CALLTRACE
print("devlogfswalk(c = 0x%.8lux, nc = 0x%.8lux, name = 0x%.8lux, nname = %d) - start\n",
(ulong)c, (ulong)nc, (ulong)name, nname);
#endif
clone = 0;
if(nc == nil){
nc = devclone(c);
nc->type = 0;
SPLITPATH(c->qid.path, c->qid.type, instance, qid, qt);
if(DATAQID(qid, qt))
nc->aux = devlogfsget(instance);
clone = 1;
}
wq = devwalk(c, nc, name, nname, 0, 0, devlogfsgen);
if (wq == nil || wq->nqid < nname) {
if(clone)
cclose(nc);
}
else if (clone) {
wq->clone = nc;
nc->type = c->type;
}
#ifdef CALLTRACE
print("devlogfswalk(c = 0x%.8lux, nc = 0x%.8lux, name = 0x%.8lux, nname = %d) - return\n",
(ulong)c, (ulong)nc, (ulong)name, nname);
#endif
return wq;
}
static Walkqid*
pipewalk(Chan *c, Chan *nc, char **name, int nname)
{
Walkqid *wq;
Pipe *p;
wq = devwalk(c, nc, name, nname, pipedir, NPIPEDIR, pipegen);
if(wq != nil && wq->clone != nil && wq->clone != c){
p = c->aux;
qlock(p);
p->ref++;
if(c->flag & COPEN){
print("channel open in pipewalk\n");
switch(NETTYPE(c->qid.path)){
case Qdata0:
p->qref[0]++;
break;
case Qdata1:
p->qref[1]++;
break;
}
}
qunlock(p);
}
return wq;
}
static Walkqid*
srvwalk(Chan *c, Chan *nc, char **name, int nname)
{
SrvFile *d, *pd;
Walkqid *w;
pd = c->aux;
qlock(&dev.l);
if(waserror()){
qunlock(&dev.l);
nexterror();
}
w = devwalk(c, nc, name, nname, nil, 0, srvgen);
if(w != nil && w->clone != nil){
if(nname != 0){
for(d = pd->entry; d != nil; d = d->entry)
if(d->qid.path == w->clone->qid.path)
break;
if(d == nil)
panic("srvwalk");
if(w->clone == c)
pd->ref--;
}else
d = pd;
w->clone->aux = d;
d->ref++;
}
poperror();
qunlock(&dev.l);
return w;
}
static Walkqid*
pipewalk(Chan *c, Chan *nc, char **name, int nname)
{
Walkqid *wq;
Pipe *p;
p = c->aux;
wq = devwalk(c, nc, name, nname, p->pipedir, nelem(pipedir), pipegen);
if(wq != nil && wq->clone != nil && wq->clone != c){
qlock(&p->l);
p->ref++;
if(c->flag & COPEN){
switch(NETTYPE(c->qid.path)){
case Qdata0:
p->qref[0]++;
break;
case Qdata1:
p->qref[1]++;
break;
}
}
qunlock(&p->l);
}
return wq;
}
static Walkqid*
corebootwalk(Chan *c, Chan *nc, char **name, int nname)
{
Walkqid *wq;
wq = devwalk(c, nc, name, nname, corebootdir, nelem(corebootdir), devgen);
/* todo: cover any cases that need locking. There are none yet. */
return wq;
}
static Walkqid*
rootwalk(Chan *c, Chan *nc, char **name, int nname)
{
ulong p;
p = c->qid.path;
if(nname == 0)
p = rootdata[p].dotdot;
return devwalk(c, nc, name, nname, rootdata[p].ptr, rootdata[p].size, rootgen);
}
static Walkqid*
srvwalk(Chan *c, Chan *nc, char **name, int nname)
{
Walkqid *wqid;
qlock(&srvlk);
wqid = devwalk(c, nc, name, nname, 0, 0, srvgen);
qunlock(&srvlk);
return wqid;
}
static Walkqid*
pointerwalk(Chan *c, Chan *nc, char **name, int nname)
{
Walkqid *wq;
wq = devwalk(c, nc, name, nname, pointertab, nelem(pointertab), devgen);
if(wq != nil && wq->clone != c && wq->clone != nil && (ulong)c->qid.path == Qpointer)
incref(&mouse.ref); /* can this happen? */
return wq;
}
static Walkqid*
ipwalk(Chan* c, Chan *nc, char **name, int nname)
{
IPaux *a = c->aux;
Walkqid* w;
w = devwalk(c, nc, name, nname, nil, 0, ipgen);
if(w != nil && w->clone != nil)
w->clone->aux = newipaux(a->owner, a->tag);
return w;
}
static Walkqid*
mousewalk(Chan *c, Chan *nc, char **name, int nname)
{
Walkqid *wq;
/*
* We use devgen() and not mousedevgen() here
* see "Ugly problem" in dev.c/devwalk()
*/
wq = devwalk(c, nc, name, nname, mousedir, nelem(mousedir), devgen);
if(wq != nil && wq->clone != c && wq->clone != nil && (wq->clone->qid.type&QTDIR)==0)
incref(&mouse.ref);
return wq;
}
static struct walkqid *rootwalk(struct chan *c, struct chan *nc, char **name,
int nname)
{
uint32_t p;
if (0){
printk("rootwalk: c %p. :", c);
if (nname){
int i;
for (i = 0; i < nname - 1; i++)
printk("%s/", name[i]);
printk("%s:\n", name[i]);
}
}
p = c->qid.path;
printd("Start from #%d at %p\n", p, &roottab[p]);
return devwalk(c, nc, name, nname, &roottab[p], rootdata[p].size, rootgen);
}
static Walkqid*
loopbackwalk(Chan *c, Chan *nc, char **name, int nname)
{
Walkqid *wq;
Loop *lb;
wq = devwalk(c, nc, name, nname, nil, 0, loopbackgen);
if(wq != nil && wq->clone != nil && wq->clone != c){
lb = c->aux;
qlock(lb);
lb->ref++;
if((c->flag & COPEN) && TYPE(c->qid.path) == Qdata)
lb->link[ID(c->qid.path)].ref++;
qunlock(lb);
}
return wq;
}
static Walkqid*
audiowalk(Chan *c, Chan *nc, char **name, int nname)
{
Audiochan *ac;
Audio *adev;
Walkqid *wq;
ac = c->aux;
adev = ac->adev;
wq = devwalk(c, nc, name, nname, audiodir, nelem(audiodir), devgen);
if(wq && wq->clone){
if(audioclone(wq->clone, adev) == nil){
free(wq);
wq = nil;
}
}
return wq;
}
static Walkqid*
cerfwalk(Chan *c, Chan *nc, char **name, int nname)
{
return devwalk(c, nc, name, nname, cerftab, nelem(cerftab), devgen);
}
static Walkqid*
envwalk(Chan *c, Chan *nc, char **name, int nname)
{
return devwalk(c, nc, name, nname, 0, 0, envgen);
}
Walkqid*
gpiowalk(Chan *c, Chan *nc, char** name, int nname)
{
return devwalk(c, nc, name, nname, 0, 0, gpiogen);
}
static Walkqid*
uartwalk(Chan *c, Chan *nc, char **name, int nname)
{
return devwalk(c, nc, name, nname, uartdir, uartndir, devgen);
}
Walkqid*
archwalk(Chan* c, Chan *nc, char** name, int nname)
{
return devwalk(c, nc, name, nname, archdir, narchdir, devgen);
}
Walkqid*
vconwalk(Chan* c, Chan *nc, char** name, int nname)
{
return devwalk(c, nc, name, nname, (Dirtab *)0, 0, vcongen);
}
struct walkqid *netifwalk(struct ether *nif, struct chan *c, struct chan *nc,
char **name, int nname)
{
return devwalk(c, nc, name, nname, (struct dirtab *)nif, 0, netifgen);
}
static int
powerwalk(Chan* c, char* name)
{
return devwalk(c, name, powertab, nelem(powertab), devgen);
}
Walkqid *
lm78walk(Chan* c, Chan *nc, char** name, int nname)
{
return devwalk(c, nc, name, nname, lm78dir, nelem(lm78dir), devgen);
}
static Walkqid*
flashwalk(Chan *c, Chan *nc, char **name, int nname)
{
return devwalk(c, nc, name, nname, nil, 0, flashgen);
}
static Walkqid*
segmentwalk(Chan *c, Chan *nc, char **name, int nname)
{
return devwalk(c, nc, name, nname, 0, 0, segmentgen);
}
static Walkqid*
rtcwalk(Chan* c, Chan *nc, char** name, int nname)
{
return devwalk(c, nc, name, nname, rtcdir, nelem(rtcdir), devgen);
}
static Walkqid*
dupwalk(Chan *c, Chan *nc, char **name, int nname)
{
return devwalk(c, nc, name, nname, nil, 0, dupgen);
}
static Walkqid*
conswalk(Chan *c, Chan *nc, char **name, int nname)
{
return devwalk(c, nc, name,nname, consdir, nelem(consdir), devgen);
}
Walkqid*
netifwalk(Netif *nif, Chan *c, Chan *nc, char **name, int nname)
{
return devwalk(c, nc, name, nname, (Dirtab *)nif, 0, netifgen);
}
static Walkqid*
capwalk(Chan *c, Chan *nc, char **name, int nname)
{
return devwalk(c, nc, name, nname, capdir, ncapdir, devgen);
}
