![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fsnami.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / sys / fs|
Return to fsnami.c CVS log | Up to [Research Unix] / researchv10no / sys / fs |
1.1 root 1: /*
2: * namei code for fs filesystem
3: */
4:
5: #include "sys/param.h"
6: #include "sys/systm.h"
7: #include "sys/inode.h"
8: #include "sys/buf.h"
9: #include "sys/filsys.h"
10: #include "sys/dir.h"
11: #include "sys/user.h"
12:
13: struct dent {
14: struct direct dir;
15: off_t off;
16: int nentry;
17: };
18:
19: fsnami(p, flagp, follow)
20: struct nx *p;
21: register struct argnamei *flagp;
22: {
23: register struct inode *dp;
24: register char *cp;
25: register struct buf *bp;
26: register struct inode *dip;
27: register int i;
28: struct dent dent;
29: struct inode *domkfile();
30: ino_t dsearch();
31:
32: cp = p->cp;
33: dp = p->dp;
34:
35: /*
36: * dp is the inode to search; cp is the pathname to find.
37: * dp must be a directory, with execute permissions.
38: * (this test is done too early; it forbids a filesystem
39: * consisting of a single file with i-number ROOTINO)
40: */
41: dirloop:
42: if((dp->i_mode&IFMT) != IFDIR) {
43: u.u_error = ENOTDIR;
44: goto outnull;
45: }
46: if (access(dp, IEXEC))
47: goto outnull;
48: for (i=0; *cp!='\0' && *cp!='/'; i++) {
49: if (i >= DIRSIZ) {
50: u.u_error = ENOENT;
51: goto outnull;
52: }
53: dent.dir.d_name[i] = *cp++;
54: }
55: while (i < DIRSIZ)
56: dent.dir.d_name[i++] = '\0';
57: while (*cp == '/')
58: cp++;
59: if (dent.dir.d_name[0] == '\0') { /* null name, e.g. "/" or "" */
60: if (flagp->flag != NI_SEARCH) {
61: u.u_error = ENOENT;
62: goto outnull;
63: }
64: /*
65: * should pass NI_CREAT too, but dp is known to be a directory
66: */
67: goto out;
68: }
69: u.u_segflg = SEGSYS; /* for various routines that write directories */
70: if (dsearch(dp, &dent) == 0) {
71: if (u.u_error)
72: goto outnull;
73: /*
74: * name not found
75: * if we wanted to create or link, that's OK
76: */
77: if (*cp == 0) switch (flagp->flag) {
78: case NI_CREAT:
79: case NI_NXCREAT:
80: case NI_MKDIR:
81: case NI_LINK:
82: dip = dp;
83: dp = domkfile(dip, flagp, &dent);
84: iput(dip);
85: goto out;
86: }
87: u.u_error = ENOENT;
88: goto outnull;
89: }
90: /*
91: * name found
92: * did we want to remove it?
93: * (do before ".." check)
94: */
95: if(flagp->flag == NI_DEL && *cp == 0) {
96: dormfile(dp, &dent);
97: goto outnull;
98: }
99: if(flagp->flag == NI_RMDIR && *cp == 0) {
100: dormdir(dp, &dent);
101: goto outnull;
102: }
103: /*
104: * special code for ".." in a root directory
105: */
106: if (dent.dir.d_name[0] == '.'
107: && dent.dir.d_name[1] == '.'
108: && dent.dir.d_name[2] == '\0') {
109: if (dp == rootdir || dp == u.u_rdir)
110: goto dirloop;
111: if (dent.dir.d_ino == ROOTINO && dp->i_number == ROOTINO) {
112: dip = dp->i_mpoint;
113: i = dp->i_fstyp;
114: iput(dp);
115: dp = dip;
116: plock(dp);
117: dp->i_count++;
118: while (*--cp == '/')
119: ;
120: cp--; /* skip over ".." and / */
121: if (dp->i_fstyp != i)
122: goto outmore;
123: goto dirloop;
124: }
125: }
126: /*
127: * fetch the inode for the filename we found
128: */
129: dip = dp;
130: prele(dip);
131: dp = iget(dip, dip->i_dev, dent.dir.d_ino);
132: if (dp == NULL) {
133: idec(dip);
134: goto out; /* sic */
135: }
136: if (dp->i_count == 1 && fsiread(dip, dp) < 0) {
137: idec(dip);
138: dp = NULL; /* fsiread iput it */
139: goto out;
140: }
141: if(dip->i_fstyp != dp->i_fstyp) {
142: idec(dip);
143: goto outmore;
144: }
145: /*
146: * symlink? If so and if wanted, follow.
147: */
148: if ((dp->i_mode&IFMT)==IFLNK && (follow || *cp!='\0')) {
149: char *ocp;
150:
151: ocp = cp;
152: while (*cp++)
153: ;
154: i = cp - ocp; /* strlen(ocp) + 1 for NUL */
155: if (dp->i_size > BSIZE(dp->i_dev)
156: || dp->i_size + 1 + i > p->nlen /* +1 for '/' */
157: || ++p->nlink>8) {
158: u.u_error = ELOOP;
159: idec(dip);
160: goto outnull;
161: }
162: cp = p->nbuf;
163: if (i == 1) /* empty pathname, just put NUL there */
164: cp[dp->i_size] = 0;
165: else {
166: bcopy(ocp, cp + dp->i_size + 1, i); /* remaining pathname */
167: cp[dp->i_size] = '/';
168: }
169: bp = bread(dp->i_dev, bmap(dp, (daddr_t)0, B_READ));
170: if (bp->b_flags & B_ERROR) {
171: brelse(bp);
172: idec(dip);
173: goto outnull;
174: }
175: bcopy(bp->b_un.b_addr, cp, dp->i_size); /* new prefix */
176: brelse(bp);
177: i = dp->i_fstyp;
178: iput(dp);
179: if (*cp != '/')
180: dp = dip;
181: else {
182: idec(dip);
183: while (*cp == '/')
184: cp++;
185: if ((dp = u.u_rdir) == NULL)
186: dp = rootdir;
187: plock(dp);
188: dp->i_count++;
189: }
190: if (i != dp->i_fstyp)
191: goto outmore;
192: goto dirloop;
193: }
194: idec(dip);
195: /*
196: * more pathname to walk?
197: */
198: if (*cp)
199: goto dirloop;
200: /*
201: * final checks before returning:
202: * -- some operations are in error if filename exists
203: * -- save last piece of filename for accounting
204: */
205: if (flagp->flag == NI_LINK || flagp->flag == NI_NXCREAT
206: || flagp->flag == NI_MKDIR) {
207: u.u_error = EEXIST;
208: goto outnull;
209: }
210: if(flagp->flag == NI_SEARCH && flagp->un.buf)
211: bcopy(dent.dir.d_name, flagp->un.buf,
212: MIN(flagp->len, sizeof(dent.dir.d_name)));
213:
214: /*
215: * here to return the inode in dp
216: */
217: out:
218: p->dp = dp;
219: return(0);
220:
221: /*
222: * here to discard dp and return NULL
223: */
224: outnull:
225: iput(dp);
226: p->dp = NULL;
227: return (0);
228:
229: /*
230: * here if we crossed into another filesystem's domain:
231: * return dp (the first inode in that filesystem)
232: * and cp (the remainder of the pathname)
233: * and value 1, so namei knows it should continue
234: */
235: outmore:
236: p->cp = cp;
237: p->dp = dp;
238: return (1);
239: }
240:
241: /*
242: * create a new file of some sort in directory dp
243: * name is in dent->d_name
244: * offset is in dent->d_off
245: * return inode if it is needed
246: */
247: struct inode *
248: domkfile(dp, flagp, dent)
249: register struct inode *dp;
250: struct argnamei *flagp;
251: struct dent *dent;
252: {
253: register struct inode *dip;
254: struct direct x[2];
255: register i;
256:
257: if(access(dp, IWRITE))
258: return(NULL);
259: if (dp->i_nlink == 0) {
260: u.u_error = EINVAL;
261: return (NULL);
262: }
263: u.u_count = sizeof(struct direct);
264: u.u_base = (caddr_t)&dent->dir;
265: u.u_offset = ltoL(dent->off);
266: switch(flagp->flag) {
267:
268: case NI_CREAT: /* create a new file */
269: case NI_NXCREAT:
270: dip = ialloc(dp);
271: if(dip == NULL)
272: return(NULL);
273: dip->i_flag |= IACC|IUPD|ICHG;
274: dip->i_mode = flagp->un.mode;
275: if((dip->i_mode & IFMT) == 0)
276: dip->i_mode |= IFREG;
277: dip->i_nlink = 1;
278: dip->i_uid = u.u_uid;
279: dip->i_gid = dp->i_mode & ISGID ? u.u_gid : dp->i_gid;
280: if (u.u_uid && !groupmember(dip->i_gid))
281: dip->i_mode &= ~ISGID;
282: fsiupdat(dip, &time, &time, 1);
283: dent->dir.d_ino = dip->i_number;
284: flagp->un.mode = ~flagp->un.mode;
285: writei(dp);
286: return(dip);
287:
288: case NI_MKDIR: /* make a new directory */
289: dip = ialloc(dp);
290: if(dip == NULL)
291: return(NULL);
292: dent->dir.d_ino = dip->i_number;
293: dip->i_mode = flagp->un.mode;
294: dip->i_nlink = 1;
295: dip->i_uid = u.u_uid;
296: dip->i_gid = dp->i_gid;
297: dip->i_flag |= IACC|IUPD|ICHG;
298: x[0].d_ino = dip->i_number;
299: x[1].d_ino = dp->i_number;
300: for(i = 0; i < DIRSIZ; i++)
301: x[0].d_name[i] = x[1].d_name[i] = 0;
302: x[0].d_name[0] = x[1].d_name[0] = x[1].d_name[1] = '.';
303: u.u_count = sizeof(x);
304: u.u_base = (caddr_t)x;
305: u.u_offset = ltoL(0);
306: u.u_segflg = SEGSYS;
307: writei(dip);
308: if (u.u_error) {
309: dip->i_nlink--;
310: iput(dip);
311: return(NULL);
312: }
313: dip->i_nlink++;
314: dp->i_nlink++;
315: fsiupdat(dip, &time, &time, 1);
316: u.u_count = sizeof(struct direct);
317: u.u_base = (caddr_t)&dent->dir;
318: u.u_offset = ltoL(dent->off);
319: writei(dp);
320: iput(dip);
321: return(NULL);
322:
323: case NI_LINK: /* make a link */
324: if(dp->i_dev != flagp->un.il->i_dev) {
325: u.u_error = EXDEV;
326: return(NULL);
327: }
328: dent->dir.d_ino = flagp->un.il->i_number;
329: writei(dp);
330: return(NULL);
331: }
332: panic("domkfile");
333: }
334:
335: /*
336: * delete a non-directory file
337: */
338: dormfile(dp, dent)
339: register struct inode *dp;
340: register struct dent *dent;
341: {
342: register struct inode *dip;
343:
344: if(access(dp, IWRITE))
345: return;
346: if(dp->i_number == dent->dir.d_ino) { /* for '.' */
347: dip = dp;
348: dp->i_count++;
349: } else {
350: dip = iget(dp, dp->i_dev, dent->dir.d_ino);
351: if (dip == NULL)
352: return;
353: if (dip->i_count == 1 && fsiread(dp, dip) < 0)
354: return;
355: }
356: if(dip->i_mpoint != dp->i_mpoint) {
357: u.u_error = EBUSY;
358: iput(dip);
359: return;
360: }
361: if((dip->i_mode&IFMT) == IFDIR && !suser()) {
362: iput(dip);
363: return;
364: }
365: if(dip->i_flag&ITEXT)
366: xrele(dip); /* free busy text */
367: u.u_base = (caddr_t)&dent->dir;
368: u.u_count = sizeof(struct direct);
369: u.u_offset = ltoL(dent->off);
370: dent->dir.d_ino = 0;
371: writei(dp); /* segflg already set*/
372: dip->i_nlink--;
373: dip->i_flag |= ICHG;
374: iput(dip);
375: }
376:
377: /*
378: * remove a directory (fsnami)
379: * dp is inode of containing directory
380: * dent->dir is the entry (which exists)
381: * u.u_offset is the offset in containing directory of this entry
382: */
383: dormdir(dp, dent)
384: register struct inode *dp;
385: register struct dent *dent;
386: {
387: register struct inode *dip;
388: register int nentry;
389: struct dent tdent;
390: ino_t dotino, dotdotino;
391: ino_t dsearch();
392:
393: if(access(dp, IWRITE))
394: return;
395: if(dp->i_number == dent->dir.d_ino
396: || strncmp(dent->dir.d_name, "..", DIRSIZ)==0) { /* gets "." and "" */
397: u.u_error = EINVAL;
398: return;
399: }
400: if((dip = iget(dp, dp->i_dev, dent->dir.d_ino)) == NULL)
401: return;
402: if(dip->i_number == ROOTINO) {
403: u.u_error = EINVAL;
404: iput(dip);
405: return;
406: }
407: if(dip->i_mpoint != dp->i_mpoint) {
408: u.u_error = EBUSY;
409: iput(dip);
410: return;
411: }
412: if (dip->i_count == 1 && fsiread(dp, dip) < 0)
413: return;
414: if((dip->i_mode & IFMT) != IFDIR) {
415: u.u_error = ENOTDIR;
416: iput(dip);
417: return;
418: }
419: /* search for ., .., other entries in dir */
420: cpdirent("/", &tdent); /* cannot be found; just count entries */
421: dsearch(dip, &tdent);
422: nentry = tdent.nentry;
423: tdent.dir.d_name[0] = '.';
424: if (dotino = dsearch(dip, &tdent))
425: nentry--;
426: tdent.dir.d_name[1] = '.';
427: if(dotdotino = dsearch(dip, &tdent))
428: nentry--;
429: if (nentry > 0) {
430: u.u_error = EHASF; /* removing nonempty directory */
431: iput(dip);
432: return;
433: }
434: if (dotino) {
435: if (dip->i_number == dotino)
436: dip->i_nlink--;
437: /* else error? */
438: }
439: if (dotdotino) {
440: if (dp->i_number == dotdotino)
441: dp->i_nlink--;
442: /* else error? */
443: }
444: u.u_base = (caddr_t)&dent->dir;
445: u.u_count = sizeof(struct direct);
446: u.u_offset = ltoL(dent->off);
447: dent->dir.d_ino = 0;
448: writei(dp);
449: dp->i_flag |= ICHG;
450: fsiupdat(dp, &time, &time, 1);
451: dip->i_nlink--;
452: dip->i_flag |= ICHG;
453: iput(dip);
454: }
455:
456: cpdirent(s, dent)
457: register char *s;
458: register struct dent *dent;
459: {
460: register char *dp = dent->dir.d_name;
461:
462: while (dp < &dent->dir.d_name[DIRSIZ]) {
463: *dp++ = *s;
464: if (*s)
465: s++;
466: }
467: }
468:
469: /*
470: * search directory ip for entry dent->dir.d_name
471: * success: return ino, leave dent->dir with copy of entry,
472: * dent->off pointing at entry
473: * dent->nentry with count of entries
474: * fail: return 0, leave dent->off pointing at empty slot
475: */
476: ino_t
477: dsearch(ip, dent)
478: struct inode *ip;
479: struct dent *dent;
480: {
481: register struct direct *dp, *dpe;
482: register char *nm;
483: register off_t off;
484: struct buf *bp;
485: register int bsize;
486: register daddr_t n, nblock;
487:
488: dent->dir.d_ino = 0;
489: nm = dent->dir.d_name;
490: bsize = BSIZE(ip->i_dev);
491: dent->nentry = 0;
492: bp = NULL;
493: dent->off = -1;
494: nblock = (ip->i_size+bsize-1) / bsize;
495:
496: for (n=0, off=0; n<nblock; n++) {
497: if (bp)
498: brelse(bp);
499: bp = bread(ip->i_dev, bmap(ip, n, B_READ));
500: if (bp->b_flags & B_ERROR) {
501: u.u_error = EIO;
502: goto out;
503: }
504: dp = (struct direct *)bp->b_un.b_addr;
505: dpe = &dp[min(bsize, ip->i_size-off) / sizeof(struct direct)];
506: for (; dp < dpe; dp++, off+=sizeof(struct direct)) {
507: if (dp->d_ino == 0) {
508: if (dent->off<0)
509: dent->off = off;
510: continue;
511: }
512: dent->nentry++;
513: if (nm[2]==dp->d_name[2] /* hash */
514: && strncmp(nm, dp->d_name, DIRSIZ) == 0) {
515: dent->off = off;
516: dent->dir.d_ino = dp->d_ino;
517: goto out;
518: }
519: }
520: }
521: out:
522: if (dent->off<0)
523: dent->off = off;
524: if (bp)
525: brelse(bp);
526: return(dent->dir.d_ino);
527: }
528:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.