Return to sysfile.c CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port

Annotation of lucent/sys/src/9/port/sysfile.c, revision 1.1

1.1     ! root        1: #include       "u.h"
        !             2: #include       "../port/lib.h"
        !             3: #include       "mem.h"
        !             4: #include       "dat.h"
        !             5: #include       "fns.h"
        !             6: #include       "../port/error.h"
        !             7: 
        !             8: /*
        !             9:  * The sys*() routines needn't poperror() as they return directly to syscall().
        !            10:  */
        !            11: 
        !            12: int
        !            13: newfd(Chan *c)
        !            14: {
        !            15:        Fgrp *f = u->p->fgrp;
        !            16:        int i;
        !            17: 
        !            18:        lock(f);
        !            19:        for(i=0; i<NFD; i++)
        !            20:                if(f->fd[i] == 0){
        !            21:                        if(i > f->maxfd)
        !            22:                                f->maxfd = i;
        !            23:                        f->fd[i] = c;
        !            24:                        unlock(f);
        !            25:                        return i;
        !            26:                }
        !            27:        unlock(f);
        !            28:        exhausted("file descriptors");
        !            29:        return 0;
        !            30: }
        !            31: 
        !            32: Chan*
        !            33: fdtochan(int fd, int mode, int chkmnt, int iref)
        !            34: {
        !            35:        Chan *c;
        !            36:        Fgrp *f;
        !            37: 
        !            38:        c = 0;
        !            39:        f = u->p->fgrp;
        !            40: 
        !            41:        lock(f);
        !            42:        if(fd<0 || NFD<=fd || (c = f->fd[fd])==0) {
        !            43:                unlock(f);
        !            44:                error(Ebadfd);
        !            45:        }
        !            46:        if(iref)
        !            47:                incref(c);
        !            48:        unlock(f);
        !            49: 
        !            50:        if(chkmnt && (c->flag&CMSG)) {
        !            51:                if(iref)
        !            52:                        close(c);
        !            53:                error(Ebadusefd);
        !            54:        }
        !            55: 
        !            56:        if(mode<0 || c->mode==ORDWR)
        !            57:                return c;
        !            58: 
        !            59:        if((mode&OTRUNC) && c->mode==OREAD) {
        !            60:                if(iref)
        !            61:                        close(c);
        !            62:                error(Ebadusefd);
        !            63:        }
        !            64: 
        !            65:        if((mode&~OTRUNC) != c->mode) {
        !            66:                if(iref)
        !            67:                        close(c);
        !            68:                error(Ebadusefd);
        !            69:        }
        !            70: 
        !            71:        return c;
        !            72: }
        !            73: 
        !            74: int
        !            75: openmode(ulong o)
        !            76: {
        !            77:        if(o >= (OTRUNC|OCEXEC|ORCLOSE|OEXEC))
        !            78:                error(Ebadarg);
        !            79:        o &= ~(OTRUNC|OCEXEC|ORCLOSE);
        !            80:        if(o > OEXEC)
        !            81:                error(Ebadarg);
        !            82:        if(o == OEXEC)
        !            83:                return OREAD;
        !            84:        return o;
        !            85: }
        !            86: 
        !            87: long
        !            88: syspipe(ulong *arg)
        !            89: {
        !            90:        int fd[2];
        !            91:        Chan *c[2];
        !            92:        Dev *d;
        !            93:        Fgrp *f = u->p->fgrp;
        !            94: 
        !            95:        validaddr(arg[0], 2*BY2WD, 1);
        !            96:        evenaddr(arg[0]);
        !            97:        d = &devtab[devno('|', 0)];
        !            98:        c[0] = (*d->attach)(0);
        !            99:        c[1] = 0;
        !           100:        fd[0] = -1;
        !           101:        fd[1] = -1;
        !           102:        if(waserror()){
        !           103:                close(c[0]);
        !           104:                if(c[1])
        !           105:                        close(c[1]);
        !           106:                if(fd[0] >= 0)
        !           107:                        f->fd[fd[0]]=0;
        !           108:                if(fd[1] >= 0)
        !           109:                        f->fd[fd[1]]=0;
        !           110:                nexterror();
        !           111:        }
        !           112:        c[1] = (*d->clone)(c[0], 0);
        !           113:        (*d->walk)(c[0], "data");
        !           114:        (*d->walk)(c[1], "data1");
        !           115:        c[0] = (*d->open)(c[0], ORDWR);
        !           116:        c[1] = (*d->open)(c[1], ORDWR);
        !           117:        fd[0] = newfd(c[0]);
        !           118:        fd[1] = newfd(c[1]);
        !           119:        ((long*)arg[0])[0] = fd[0];
        !           120:        ((long*)arg[0])[1] = fd[1];
        !           121:        poperror();
        !           122:        return 0;
        !           123: }
        !           124: 
        !           125: long
        !           126: sysdup(ulong *arg)
        !           127: {
        !           128:        int fd;
        !           129:        Chan *c, *oc;
        !           130:        Fgrp *f = u->p->fgrp;
        !           131: 
        !           132:        /*
        !           133:         * Close after dup'ing, so date > #d/1 works
        !           134:         */
        !           135:        c = fdtochan(arg[0], -1, 0, 1);
        !           136:        fd = arg[1];
        !           137:        if(fd != -1){
        !           138:                if(fd<0 || NFD<=fd) {
        !           139:                        close(c);
        !           140:                        error(Ebadfd);
        !           141:                }
        !           142:                lock(f);
        !           143:                if(fd > f->maxfd)
        !           144:                        f->maxfd = fd;
        !           145: 
        !           146:                oc = f->fd[fd];
        !           147:                f->fd[fd] = c;
        !           148:                unlock(f);
        !           149:                if(oc)
        !           150:                        close(oc);
        !           151:        }else{
        !           152:                if(waserror()) {
        !           153:                        close(c);
        !           154:                        nexterror();
        !           155:                }
        !           156:                fd = newfd(c);
        !           157:                poperror();
        !           158:        }
        !           159: 
        !           160:        return fd;
        !           161: }
        !           162: 
        !           163: long
        !           164: sysopen(ulong *arg)
        !           165: {
        !           166:        int fd;
        !           167:        Chan *c = 0;
        !           168: 
        !           169:        openmode(arg[1]);       /* error check only */
        !           170:        if(waserror()){
        !           171:                if(c)
        !           172:                        close(c);
        !           173:                nexterror();
        !           174:        }
        !           175:        validaddr(arg[0], 1, 0);
        !           176:        c = namec((char*)arg[0], Aopen, arg[1], 0);
        !           177:        fd = newfd(c);
        !           178:        poperror();
        !           179:        return fd;
        !           180: }
        !           181: 
        !           182: void
        !           183: fdclose(int fd, int flag)
        !           184: {
        !           185:        int i;
        !           186:        Chan *c;
        !           187:        Fgrp *f = u->p->fgrp;
        !           188: 
        !           189:        lock(f);
        !           190:        c = f->fd[fd];
        !           191:        if(c == 0){
        !           192:                /* can happen for users with shared fd tables */
        !           193:                unlock(f);
        !           194:                return;
        !           195:        }
        !           196:        if(flag){
        !           197:                if(c==0 || !(c->flag&flag)){
        !           198:                        unlock(f);
        !           199:                        return;
        !           200:                }
        !           201:        }
        !           202:        f->fd[fd] = 0;
        !           203:        if(fd == f->maxfd)
        !           204:                for(i=fd; --i>=0 && f->fd[i]==0; )
        !           205:                        f->maxfd = i;
        !           206: 
        !           207:        unlock(f);
        !           208:        close(c);
        !           209: }
        !           210: 
        !           211: long
        !           212: sysclose(ulong *arg)
        !           213: {
        !           214:        fdtochan(arg[0], -1, 0, 0);
        !           215:        fdclose(arg[0], 0);
        !           216: 
        !           217:        return 0;
        !           218: }
        !           219: 
        !           220: long
        !           221: unionread(Chan *c, void *va, long n)
        !           222: {
        !           223:        long nr;
        !           224:        Chan *nc;
        !           225:        Pgrp *pg;
        !           226: 
        !           227:        pg = u->p->pgrp;
        !           228:        rlock(&pg->ns);
        !           229: 
        !           230:        for(;;) {
        !           231:                /* Error causes component of union to be skipped */
        !           232:                if(waserror())
        !           233:                        goto next;
        !           234: 
        !           235:                nc = clone(c->mnt->to, 0);
        !           236:                poperror();
        !           237: 
        !           238:                if(c->mountid != c->mnt->mountid) {
        !           239:                        pprint("unionread: changed underfoot?\n");
        !           240:                        runlock(&pg->ns);
        !           241:                        close(nc);
        !           242:                        return 0;
        !           243:                }
        !           244: 
        !           245:                if(waserror()) {        
        !           246:                        close(nc);
        !           247:                        goto next;
        !           248:                }
        !           249: 
        !           250:                nc = (*devtab[nc->type].open)(nc, OREAD);
        !           251:                nc->offset = c->offset;
        !           252:                nr = (*devtab[nc->type].read)(nc, va, n, nc->offset);
        !           253:                /* devdirread e.g. changes it */
        !           254:                c->offset = nc->offset; 
        !           255:                poperror();
        !           256: 
        !           257:                close(nc);
        !           258:                if(nr > 0) {
        !           259:                        runlock(&pg->ns);
        !           260:                        return nr;
        !           261:                }
        !           262:                /* Advance to next element */
        !           263:        next:
        !           264:                c->mnt = c->mnt->next;
        !           265:                if(c->mnt == 0)
        !           266:                        break;
        !           267:                c->mountid = c->mnt->mountid;
        !           268:                c->offset = 0;
        !           269:        }
        !           270:        runlock(&pg->ns);
        !           271:        return 0;
        !           272: }
        !           273: 
        !           274: long
        !           275: sysread(ulong *arg)
        !           276: {
        !           277:        int dir;
        !           278:        long n;
        !           279:        Chan *c;
        !           280: 
        !           281:        validaddr(arg[1], arg[2], 1);
        !           282:        c = fdtochan(arg[0], OREAD, 1, 1);
        !           283:        if(waserror()) {
        !           284:                close(c);
        !           285:                nexterror();
        !           286:        }
        !           287: 
        !           288:        n = arg[2];
        !           289:        dir = c->qid.path&CHDIR;
        !           290: 
        !           291:        if(dir) {
        !           292:                n -= n%DIRLEN;
        !           293:                if(c->offset%DIRLEN || n==0)
        !           294:                        error(Etoosmall);
        !           295:        }
        !           296: 
        !           297:        if(dir && c->mnt)
        !           298:                n = unionread(c, (void*)arg[1], n);
        !           299:        else
        !           300:                n = (*devtab[c->type].read)(c, (void*)arg[1], n, c->offset);
        !           301: 
        !           302:        lock(c);
        !           303:        c->offset += n;
        !           304:        unlock(c);
        !           305: 
        !           306:        poperror();
        !           307:        close(c);
        !           308: 
        !           309:        return n;
        !           310: }
        !           311: 
        !           312: long
        !           313: syswrite(ulong *arg)
        !           314: {
        !           315:        Chan *c;
        !           316:        long n;
        !           317: 
        !           318:        validaddr(arg[1], arg[2], 0);
        !           319:        c = fdtochan(arg[0], OWRITE, 1, 1);
        !           320:        if(waserror()) {
        !           321:                close(c);
        !           322:                nexterror();
        !           323:        }
        !           324: 
        !           325:        if(c->qid.path & CHDIR)
        !           326:                error(Eisdir);
        !           327: 
        !           328:        n = (*devtab[c->type].write)(c, (void*)arg[1], arg[2], c->offset);
        !           329: 
        !           330:        lock(c);
        !           331:        c->offset += n;
        !           332:        unlock(c);
        !           333: 
        !           334:        poperror();
        !           335:        close(c);
        !           336: 
        !           337:        return n;
        !           338: }
        !           339: 
        !           340: long
        !           341: sysseek(ulong *arg)
        !           342: {
        !           343:        Chan *c;
        !           344:        char buf[DIRLEN];
        !           345:        Dir dir;
        !           346:        long off;
        !           347: 
        !           348:        c = fdtochan(arg[0], -1, 1, 0);
        !           349:        if(c->qid.path & CHDIR)
        !           350:                error(Eisdir);
        !           351: 
        !           352:        if(devchar[c->type] == '|')
        !           353:                error(Eisstream);
        !           354: 
        !           355:        off = 0;
        !           356:        switch(arg[2]){
        !           357:        case 0:
        !           358:                off = c->offset = arg[1];
        !           359:                break;
        !           360: 
        !           361:        case 1:
        !           362:                lock(c);        /* lock for read/write update */
        !           363:                c->offset += (long)arg[1];
        !           364:                off = c->offset;
        !           365:                unlock(c);
        !           366:                break;
        !           367: 
        !           368:        case 2:
        !           369:                (*devtab[c->type].stat)(c, buf);
        !           370:                convM2D(buf, &dir);
        !           371:                c->offset = dir.length + (long)arg[1];
        !           372:                off = c->offset;
        !           373:                break;
        !           374:        }
        !           375:        return off;
        !           376: }
        !           377: 
        !           378: long
        !           379: sysfstat(ulong *arg)
        !           380: {
        !           381:        Chan *c;
        !           382: 
        !           383:        validaddr(arg[1], DIRLEN, 1);
        !           384:        evenaddr(arg[1]);
        !           385:        c = fdtochan(arg[0], -1, 0, 1);
        !           386:        if(waserror()) {
        !           387:                close(c);
        !           388:                nexterror();
        !           389:        }
        !           390:        (*devtab[c->type].stat)(c, (char*)arg[1]);
        !           391:        poperror();
        !           392:        close(c);
        !           393:        return 0;
        !           394: }
        !           395: 
        !           396: long
        !           397: sysstat(ulong *arg)
        !           398: {
        !           399:        Chan *c;
        !           400: 
        !           401:        validaddr(arg[1], DIRLEN, 1);
        !           402:        evenaddr(arg[1]);
        !           403:        validaddr(arg[0], 1, 0);
        !           404:        c = namec((char*)arg[0], Aaccess, 0, 0);
        !           405:        if(waserror()){
        !           406:                close(c);
        !           407:                nexterror();
        !           408:        }
        !           409:        (*devtab[c->type].stat)(c, (char*)arg[1]);
        !           410:        poperror();
        !           411:        close(c);
        !           412:        return 0;
        !           413: }
        !           414: 
        !           415: long
        !           416: syschdir(ulong *arg)
        !           417: {
        !           418:        Chan *c;
        !           419: 
        !           420:        validaddr(arg[0], 1, 0);
        !           421:        c = namec((char*)arg[0], Atodir, 0, 0);
        !           422:        close(u->dot);
        !           423:        u->dot = c;
        !           424:        return 0;
        !           425: }
        !           426: 
        !           427: long
        !           428: bindmount(ulong *arg, int ismount)
        !           429: {
        !           430:        Chan *c0, *c1, *bc;
        !           431:        ulong flag;
        !           432:        long ret;
        !           433:        int fd;
        !           434:        struct{
        !           435:                Chan    *chan;
        !           436:                char    *spec;
        !           437:        }bogus;
        !           438: 
        !           439:        flag = arg[2];
        !           440:        fd = arg[0];
        !           441:        if(flag>MMASK || (flag&MORDER)==(MBEFORE|MAFTER))
        !           442:                error(Ebadarg);
        !           443:        if(ismount){
        !           444:                bc = fdtochan(fd, 2, 0, 1);
        !           445:                if(waserror()) {
        !           446:                        close(bc);
        !           447:                        nexterror();
        !           448:                }
        !           449:                bogus.chan = bc;
        !           450: 
        !           451:                validaddr(arg[3], 1, 0);
        !           452:                if(vmemchr((char*)arg[3], '\0', NAMELEN) == 0)
        !           453:                        error(Ebadarg);
        !           454: 
        !           455:                bogus.spec = (char*)arg[3];
        !           456: 
        !           457:                ret = devno('M', 0);
        !           458:                c0 = (*devtab[ret].attach)((char*)&bogus);
        !           459: 
        !           460:                poperror();
        !           461:                close(bc);
        !           462:        }
        !           463:        else {
        !           464:                validaddr(arg[0], 1, 0);
        !           465:                c0 = namec((char*)arg[0], Aaccess, 0, 0);
        !           466:        }
        !           467:        if(waserror()){
        !           468:                close(c0);
        !           469:                nexterror();
        !           470:        }
        !           471:        validaddr(arg[1], 1, 0);
        !           472:        c1 = namec((char*)arg[1], Amount, 0, 0);
        !           473:        if(waserror()){
        !           474:                close(c1);
        !           475:                nexterror();
        !           476:        }
        !           477:        if((c0->qid.path^c1->qid.path) & CHDIR)
        !           478:                error(Emount);
        !           479:        if(flag && !(c0->qid.path&CHDIR))
        !           480:                error(Emount);
        !           481:        ret = mount(c0, c1, flag);
        !           482:        poperror();
        !           483:        close(c1);
        !           484:        poperror();
        !           485:        close(c0);
        !           486:        if(ismount)
        !           487:                fdclose(fd, 0);
        !           488:        return ret;
        !           489: }
        !           490: 
        !           491: long
        !           492: sysbind(ulong *arg)
        !           493: {
        !           494:        return bindmount(arg, 0);
        !           495: }
        !           496: 
        !           497: long
        !           498: sysmount(ulong *arg)
        !           499: {
        !           500:        return bindmount(arg, 1);
        !           501: }
        !           502: 
        !           503: long
        !           504: sysunmount(ulong *arg)
        !           505: {
        !           506:        Chan *cmount, *cmounted;
        !           507: 
        !           508:        cmounted = 0;
        !           509: 
        !           510:        validaddr(arg[1], 1, 0);
        !           511:        cmount = namec((char *)arg[1], Amount, 0, 0);
        !           512: 
        !           513:        if(arg[0]) {
        !           514:                if(waserror()) {
        !           515:                        close(cmount);
        !           516:                        nexterror();
        !           517:                }
        !           518:                validaddr(arg[0], 1, 0);
        !           519:                cmounted = namec((char*)arg[0], Aopen, OREAD, 0);
        !           520:                poperror();
        !           521:        }
        !           522: 
        !           523:        if(waserror()) {
        !           524:                close(cmount);
        !           525:                if(cmounted)
        !           526:                        close(cmounted);
        !           527:                nexterror();
        !           528:        }
        !           529:        unmount(cmount, cmounted);
        !           530:        close(cmount);
        !           531:        if(cmounted)
        !           532:                close(cmounted);
        !           533:        poperror();     
        !           534:        return 0;
        !           535: }
        !           536: 
        !           537: long
        !           538: syscreate(ulong *arg)
        !           539: {
        !           540:        int fd;
        !           541:        Chan *c = 0;
        !           542: 
        !           543:        openmode(arg[1]);       /* error check only */
        !           544:        if(waserror()) {
        !           545:                if(c)
        !           546:                        close(c);
        !           547:                nexterror();
        !           548:        }
        !           549:        validaddr(arg[0], 1, 0);
        !           550:        c = namec((char*)arg[0], Acreate, arg[1], arg[2]);
        !           551:        fd = newfd(c);
        !           552:        poperror();
        !           553:        return fd;
        !           554: }
        !           555: 
        !           556: long
        !           557: sysremove(ulong *arg)
        !           558: {
        !           559:        Chan *c;
        !           560: 
        !           561:        validaddr(arg[0], 1, 0);
        !           562:        c = namec((char*)arg[0], Aaccess, 0, 0);
        !           563:        if(waserror()){
        !           564:                c->type = 0;    /* see below */
        !           565:                close(c);
        !           566:                nexterror();
        !           567:        }
        !           568:        (*devtab[c->type].remove)(c);
        !           569:        /*
        !           570:         * Remove clunks the fid, but we need to recover the Chan
        !           571:         * so fake it up.  rootclose() is known to be a nop.
        !           572:         */
        !           573:        c->type = 0;
        !           574:        poperror();
        !           575:        close(c);
        !           576:        return 0;
        !           577: }
        !           578: 
        !           579: long
        !           580: syswstat(ulong *arg)
        !           581: {
        !           582:        Chan *c;
        !           583: 
        !           584:        validaddr(arg[1], DIRLEN, 0);
        !           585:        nameok((char*)arg[1]);
        !           586:        validaddr(arg[0], 1, 0);
        !           587:        c = namec((char*)arg[0], Aaccess, 0, 0);
        !           588:        if(waserror()){
        !           589:                close(c);
        !           590:                nexterror();
        !           591:        }
        !           592:        (*devtab[c->type].wstat)(c, (char*)arg[1]);
        !           593:        poperror();
        !           594:        close(c);
        !           595:        return 0;
        !           596: }
        !           597: 
        !           598: long
        !           599: sysfwstat(ulong *arg)
        !           600: {
        !           601:        Chan *c;
        !           602: 
        !           603:        validaddr(arg[1], DIRLEN, 0);
        !           604:        nameok((char*)arg[1]);
        !           605:        c = fdtochan(arg[0], -1, 1, 1);
        !           606:        if(waserror()) {
        !           607:                close(c);
        !           608:                nexterror();
        !           609:        }
        !           610:        (*devtab[c->type].wstat)(c, (char*)arg[1]);
        !           611:        poperror();
        !           612:        close(c);
        !           613:        return 0;
        !           614: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.