Return to portfns.h CVS log

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

Annotation of lucent/sys/src/9/port/portfns.h, revision 1.1

1.1     ! root        1: void           addrootfile(char*, uchar*, ulong);
        !             2: void           alarmkproc(void*);
        !             3: Block*         allocb(ulong);
        !             4: int            anyready(void);
        !             5: Image*         attachimage(int, Chan*, ulong, ulong);
        !             6: long           authcheck(Chan*, char*, int);
        !             7: void           authclose(Chan*);
        !             8: long           authentread(Chan*, char*, int);
        !             9: long           authentwrite(Chan*, char*, int);
        !            10: long           authread(Chan*, char*, int);
        !            11: ulong          authrequest(Session*, Fcall*);
        !            12: void           authreply(Session*, ulong, Fcall*);
        !            13: long           authwrite(Chan*, char*, int);
        !            14: void           bitdebug(void);
        !            15: void           bitdepth(void);
        !            16: void           bitreverse(uchar*, int);
        !            17: int            blen(Block *);
        !            18: int            bround(Block *, int);
        !            19: void           buzz(int, int);
        !            20: void           cachedel(Image*, ulong);
        !            21: void           cachepage(Page*, Image*);
        !            22: int            cangetc(void*);
        !            23: int            canlock(Lock*);
        !            24: int            canpage(Proc*);
        !            25: int            canputc(void*);
        !            26: int            canqlock(QLock*);
        !            27: void           chandevinit(void);
        !            28: void           chandevreset(void);
        !            29: void           chanfree(Chan*);
        !            30: void           checkalarms(void);
        !            31: Chan*          clone(Chan*, Chan*);
        !            32: void           close(Chan*);
        !            33: void           closeegrp(Egrp*);
        !            34: void           closefgrp(Fgrp*);
        !            35: void           closemount(Mount*);
        !            36: void           closepgrp(Pgrp*);
        !            37: long           clrfpintr(void);
        !            38: void           confinit(void);
        !            39: void           confinit1(int);
        !            40: int            consactive(void);
        !            41: void           consdebug(void);
        !            42: Block*         copyb(Block*, int);
        !            43: void           copypage(Page*, Page*);
        !            44: int            cursoron(int);
        !            45: void           cursoroff(int);
        !            46: Segment*       data2txt(Segment*);
        !            47: int            decref(Ref*);
        !            48: int            decrypt(void*, void*, int);
        !            49: void           delay(int);
        !            50: Chan*          devattach(int, char*);
        !            51: Chan*          devclone(Chan*, Chan*);
        !            52: void           devdir(Chan*, Qid, char*, long, char*, long, Dir*);
        !            53: long           devdirread(Chan*, char*, long, Dirtab*, int, Devgen*);
        !            54: Devgen         devgen;
        !            55: int            devno(int, int);
        !            56: Chan*          devopen(Chan*, int, Dirtab*, int, Devgen*);
        !            57: void           devstat(Chan*, char*, Dirtab*, int, Devgen*);
        !            58: int            devwalk(Chan*, char*, Dirtab*, int, Devgen*);
        !            59: void           dumpqueues(void);
        !            60: void           dumpregs(Ureg*);
        !            61: void           dumpstack(void);
        !            62: Fgrp*          dupfgrp(Fgrp*);
        !            63: void           duppage(Page*);
        !            64: void           dupswap(Page*);
        !            65: int            encrypt(void*, void*, int);
        !            66: void           envcpy(Egrp*, Egrp*);
        !            67: int            eqchan(Chan*, Chan*, long);
        !            68: int            eqqid(Qid, Qid);
        !            69: void           error(char*);
        !            70: long           execregs(ulong, ulong, ulong);
        !            71: void           exhausted(char*);
        !            72: void           exit(int);
        !            73: Block*         expandb(Block*, int);
        !            74: int            fault(ulong, int);
        !            75: void           fdclose(int, int);
        !            76: Chan*          fdtochan(int, int, int, int);
        !            77: int            fixfault(Segment*, ulong, int, int);
        !            78: void           flowctl(Queue*, Block*);
        !            79: void           flushmmu(void);
        !            80: void           free(void*);
        !            81: void           freeb(Block*);
        !            82: int            freebroken(void);
        !            83: void           freechan(Chan*);
        !            84: void           freepte(Segment*, Pte*);
        !            85: void           freesegs(int);
        !            86: void           freesession(Session*);
        !            87: Block*         getb(Blist*);
        !            88: int            getc(IOQ*);
        !            89: void           getcolor(ulong, ulong*, ulong*, ulong*);
        !            90: int            getfields(char*, char**, int, char*);
        !            91: Block*         getq(Queue*);
        !            92: int            gets(IOQ*, void*, int);
        !            93: void           gotolabel(Label*);
        !            94: Block*         grabq(Queue*);
        !            95: int            haswaitq(void*);
        !            96: long           hostdomainwrite(char*, int);
        !            97: long           hostownerwrite(char*, int);
        !            98: long           ibrk(ulong, int);
        !            99: void           ilock(Lock*);
        !           100: int            incref(Ref*);
        !           101: void           initq(IOQ*);
        !           102: void           initscsi(void);
        !           103: void           initseg(void);
        !           104: void           invalidateu(void);
        !           105: void           ipmuxoput(Queue*, Block*);
        !           106: void           isdir(Chan*);
        !           107: int            iseve(void);
        !           108: int            ispages(void*);
        !           109: void           iunlock(Lock*);
        !           110: void           kbdclock(void);
        !           111: int            kbdcr2nl(IOQ*, int);
        !           112: int            kbdputc(IOQ*, int);
        !           113: void           kbdrepeat(int);
        !           114: long           keyread(char*, int, long);
        !           115: long           keywrite(char*, int);
        !           116: void           kickpager(void);
        !           117: int            kprint(char*, ...);
        !           118: void           kproc(char*, void(*)(void*), void*);
        !           119: void           kproftimer(ulong);
        !           120: void           ksetenv(char*, char*);
        !           121: void           ksetterm(char*);
        !           122: long           latin1(uchar*, int);
        !           123: void           lights(int);
        !           124: void           lock(Lock*);
        !           125: void           lockinit(void);
        !           126: Page*          lookpage(Image*, ulong);
        !           127: int            m3mouseputc(IOQ*, int);
        !           128: void           machinit(void);
        !           129: void*          malloc(ulong);
        !           130: void           mapstack(Proc*);
        !           131: void           mbbpt(Point);
        !           132: void           mbbrect(Rectangle);
        !           133: void           mfreeseg(Segment*, ulong, int);
        !           134: void           mmurelease(Proc*);
        !           135: void           mntblocksize(int);
        !           136: void           mntdump(void);
        !           137: int            mount(Chan*, Chan*, int);
        !           138: void           mountfree(Mount*);
        !           139: void           mouseclock(void);
        !           140: void           mousectl(char*);
        !           141: void           mousetrack(int, int, int);
        !           142: int            mouseputc(IOQ*, int);
        !           143: void           mousescreenupdate(void);
        !           144: int            msize(void*);
        !           145: Chan*          namec(char*, int, int, ulong);
        !           146: void           nameok(char*);
        !           147: void           netdisown(Netprot*);
        !           148: int            netgen(Chan*, void*, int, int, Dir*);
        !           149: Chan*          netopen(Chan*, int, Network*);
        !           150: int            netown(Netprot*, char*, int);
        !           151: void           netadd(Network*, Netprot*, int);
        !           152: long           netread(Chan*, void*, long, ulong, Network*);
        !           153: void           netstat(Chan*, char*, Network*);
        !           154: int            netwalk(Chan*, char*, Network*);
        !           155: void           netwstat(Chan*, char*, Network*);
        !           156: Chan*          newchan(void);
        !           157: Mount*         newmount(Mhead*, Chan*);
        !           158: Page*          newpage(int, Segment **, ulong);
        !           159: Pgrp*          newpgrp(void);
        !           160: Proc*          newproc(void);
        !           161: void           newqinfo(Qinfo*);
        !           162: Segment*       newseg(int, ulong, ulong);
        !           163: char*          nextelem(char*, char*);
        !           164: void           nexterror(void);
        !           165: int            nodelims(Stream*);
        !           166: int            notify(Ureg*);
        !           167: int            nrand(int);
        !           168: void           nullput(Queue*, Block*);
        !           169: int            okaddr(ulong, ulong, int);
        !           170: int            openmode(ulong);
        !           171: Block*         padb(Block*, int);
        !           172: void           pageinit(void);
        !           173: void           panic(char*, ...);
        !           174: void           pexit(char*, int);
        !           175: void           pgrpcpy(Pgrp*, Pgrp*);
        !           176: void           pgrpnote(ulong, char*, long, int);
        !           177: Pgrp*          pgrptab(int);
        !           178: void           pio(Segment *, ulong, ulong, Page **);
        !           179: void           pixreverse(uchar*, int, int);
        !           180: #define                poperror()              u->nerrlab--
        !           181: int            postnote(Proc*, int, char*, int);
        !           182: int            pprint(char*, ...);
        !           183: void           printinit(void);
        !           184: ulong          procalarm(ulong);
        !           185: void           procctl(Proc*);
        !           186: void           procdump(void);
        !           187: void           procinit0(void);
        !           188: Proc*          proctab(int);
        !           189: Pte*           ptealloc(void);
        !           190: Pte*           ptecpy(Pte*);
        !           191: Block*         pullup(Block *, int);
        !           192: Queue*         pushq(Stream*, Qinfo*);
        !           193: int            putb(Blist*, Block*);
        !           194: void           putbq(Blist*, Block*);
        !           195: int            putc(IOQ*, int);
        !           196: void           putimage(Image*);
        !           197: void           putmmu(ulong, ulong, Page*);
        !           198: void           putpage(Page*);
        !           199: int            putq(Queue*, Block*);
        !           200: void           puts(IOQ*, void*, int);
        !           201: void           putseg(Segment*);
        !           202: void           putstr(char*);
        !           203: void           putstr(char*);
        !           204: void           putstrn(char*, long);
        !           205: void           putswap(Page*);
        !           206: ulong          pwait(Waitmsg*);
        !           207: Qinfo*         qinfofind(char*);
        !           208: void           qlock(QLock*);
        !           209: void           qunlock(QLock*);
        !           210: int            readnum(ulong, char*, ulong, ulong, int);
        !           211: int            readstr(ulong, char*, ulong, char*);
        !           212: void           ready(Proc*);
        !           213: void           relocateseg(Segment*, ulong);
        !           214: void           resched(char*);
        !           215: void           resetscsi(void);
        !           216: void           resrcwait(char*);
        !           217: int            return0(void*);
        !           218: void           rlock(RWlock*);
        !           219: long           rtctime(void);
        !           220: void           runlock(RWlock*);
        !           221: Proc*          runproc(void);
        !           222: void           savefpregs(FPsave*);
        !           223: void           sccclock(void);
        !           224: int            sccintr(void);
        !           225: void           sccsetup(void*, ulong, int);
        !           226: void           sccspecial(int, IOQ*, IOQ*, int);
        !           227: void           sched(void);
        !           228: void           schedinit(void);
        !           229: int            screenbits(void);
        !           230: void           screenupdate(void);
        !           231: Scsibuf*       scsialloc(ulong);
        !           232: int            scsibread(int, Scsibuf*, long, long, long);
        !           233: Scsibuf*       scsibuf(void);
        !           234: void           scsibufreset(ulong);
        !           235: int            scsibwrite(int, Scsibuf*, long, long, long);
        !           236: int            scsicap(int, void*);
        !           237: Scsi*          scsicmd(int, int, Scsibuf*, long);
        !           238: int            scsiexec(Scsi*, int);
        !           239: void           scsifree(Scsibuf*);
        !           240: int            scsiinquiry(int, void*, int);
        !           241: int            scsimodesense(int, int, void*, int);
        !           242: int            scsiready(int);
        !           243: int            scsistartstop(int, int);
        !           244: int            scsisense(int, void*);
        !           245: int            scsiwp(int);
        !           246: long           seconds(void);
        !           247: ulong          segattach(Proc*, ulong, char *, ulong, ulong);
        !           248: void           segpage(Segment*, Page*);
        !           249: int            setcolor(ulong, ulong, ulong, ulong);
        !           250: int            setlabel(Label*);
        !           251: void           setregisters(Ureg*, char*, char*, int);
        !           252: void           setswapchan(Chan*);
        !           253: void           simpleputpage(Page*);
        !           254: char*          skipslash(char*);
        !           255: void           sleep(Rendez*, int(*)(void*), void*);
        !           256: void*          smalloc(ulong);
        !           257: int            splhi(void);
        !           258: int            spllo(void);
        !           259: void           splx(int);
        !           260: int            streamclose(Chan*);
        !           261: int            streamclose1(Stream*);
        !           262: int            streamenter(Stream*);
        !           263: void           streamexit(Stream*);
        !           264: Devgen         streamgen;
        !           265: void           streaminit(void);
        !           266: void           streaminit0(void);
        !           267: Stream*                streamnew(ushort, ushort, ulong, Qinfo*, int);
        !           268: void           streamopen(Chan*, Qinfo*);
        !           269: int            streamparse(char*, Block*);
        !           270: long           streamread(Chan*, void*, long);
        !           271: void           streamstat(Chan*, char*, char*, long);
        !           272: long           streamwrite(Chan*, void*, long, int);
        !           273: void           naildownstream(Stream*);
        !           274: void           swapinit(void);
        !           275: void           tsleep(Rendez*, int (*)(void*), void*, int);
        !           276: void           unbreak(Proc*);
        !           277: void           uncachepage(Page*);
        !           278: long           unionread(Chan*, void*, long);
        !           279: void           unlock(Lock*);
        !           280: void           unmount(Chan*, Chan*);
        !           281: void           urpfillstats(Chan*, char*, int);
        !           282: void           userinit(void);
        !           283: ulong          userpc(void);
        !           284: long           userwrite(char*, int);
        !           285: void           validaddr(ulong, ulong, int);
        !           286: void*          vmemchr(void*, int, int);
        !           287: void           wakeup(Rendez*);
        !           288: void           wipekeys(void);
        !           289: void           wlock(RWlock*);
        !           290: void           wunlock(RWlock*);
        !           291: void*          xalloc(ulong);
        !           292: void           xfree(void*);
        !           293: void           xhole(ulong, ulong);
        !           294: void           xinit(void);
        !           295: void*          xspanalloc(ulong, int, ulong);
        !           296: void           xsummary(void);
        !           297: Segment*       dupseg(Segment**, int, int);
        !           298: Segment*       seg(Proc*, ulong, int);

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