Return to nami.c CVS log

Up to [Research Unix] / researchv9 / sys.vax / sys

Annotation of researchv9/sys.vax/sys/nami.c, revision 1.1.1.1

1.1       root        1: #include "../h/param.h"
                      2: #include "../h/systm.h"
                      3: #include "../h/inode.h"
                      4: #include "../h/dir.h"
                      5: #include "../h/user.h"
                      6: #include "../h/buf.h"
                      7: #include "../h/conf.h"
                      8: 
                      9: /*
                     10:  * Convert a pathname into a pointer to
                     11:  * a locked inode.
                     12:  *
                     13:  * func = function called to get next char of name
                     14:  *     &uchar if name is in user space
                     15:  *     &schar if name is in system space
                     16:  *     length guaranteed <= BUFSIZE if func != uchar
                     17:  * flagp
                     18:        0 for ordinary searches
                     19:        else ->flag structure with more parameters
                     20:  * follow = 1 if links are to be followed at the end of the name
                     21:  */
                     22: 
                     23: struct inode *
                     24: namei(func, flagp, follow)
                     25: int            (*func)();
                     26: struct argnamei        *flagp;
                     27: int            follow;
                     28: {
                     29:        register int    i;
                     30:        register char   *cp;
                     31:        struct nx       p;
                     32: 
                     33:        p.nbp = geteblk();
                     34:        if(func == uchar) {
                     35:                if((i = fustrlen(u.u_dirp)) < 0) {
                     36:                        u.u_error = EFAULT;
                     37:                        brelse(p.nbp);
                     38:                        return NULL;
                     39:                }
                     40:                if(i > BUFSIZE) {
                     41:                        u.u_error = ENOENT;
                     42:                        brelse(p.nbp);
                     43:                        return NULL;
                     44:                }
                     45:                bcopy(u.u_dirp, p.nbp->b_un.b_addr, i);
                     46: #ifdef CHAOS
                     47:                u.u_dirp += i;
                     48: #endif
                     49:        } else {
                     50:                cp = p.nbp->b_un.b_addr;
                     51:                do; while(*cp++ = (*func)());
                     52:        }
                     53:        if(flagp != NULL) {
                     54:                cp = p.nbp->b_un.b_addr;
                     55:                while(i = *cp++) {
                     56:                        if(i & 0200) {
                     57:                                u.u_error = ENOENT;
                     58:                                brelse(p.nbp);
                     59:                                return NULL;
                     60:                        }
                     61:                }
                     62:        }
                     63:        cp = p.nbp->b_un.b_addr;
                     64:        if(*cp == '/') {
                     65:                while(*cp == '/')
                     66:                        cp++;
                     67:                if((p.dp = u.u_rdir) == NULL)
                     68:                        p.dp = rootdir;
                     69:        } else
                     70:                p.dp = u.u_cdir;
                     71:        p.nlink = 0;
                     72:        p.cp = cp;
                     73:        plock(p.dp);
                     74:        p.dp->i_count++;
                     75: 
                     76:        for (;;) {
                     77:                switch((*fstypsw[p.dp->i_fstyp].t_nami)(&p, &flagp, follow)) {
                     78:                case 1:
                     79:                        iput(p.dp);
                     80:                        brelse(p.nbp);
                     81:                        return NULL;
                     82:                case 2:
                     83:                        if(*p.cp)
                     84:                                break;
                     85:                case 0:
                     86:                        brelse(p.nbp);
                     87:                        return p.dp;
                     88:                default:
                     89:                        panic("namei ret");
                     90:                }
                     91:        }
                     92: }
                     93: 
                     94: /*
                     95:  * for filesystems without namei code
                     96:  */
                     97: 
                     98: int
                     99: nullnami()
                    100: {
                    101:        u.u_error = ENODEV;
                    102:        return (1);
                    103: }
                    104: 
                    105: /*
                    106:  * Return the next character from the
                    107:  * kernel string pointed at by dirp.
                    108:  */
                    109: schar()
                    110: {
                    111: 
                    112:        return(*u.u_dirp++ & 0377);
                    113: }
                    114: 
                    115: /*
                    116:  * Return the next character from the
                    117:  * user string pointed at by dirp.
                    118:  */
                    119: uchar()
                    120: {
                    121:        register c;
                    122: 
                    123:        c = fubyte(u.u_dirp++);
                    124:        if(c == -1) {
                    125:                u.u_error = EFAULT;
                    126:                c = 0;
                    127:        }
                    128:        return(c);
                    129: }

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