![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fs1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / coh.386|
Return to fs1.c CVS log | Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / coh.386 |
1.1 root 1: /* $Header: /y/coh.386/RCS/fs1.c,v 1.4 92/07/16 16:33:32 hal Exp $ */
2: /* (lgl-
3: * The information contained herein is a trade secret of Mark Williams
4: * Company, and is confidential information. It is provided under a
5: * license agreement, and may be copied or disclosed only under the
6: * terms of that agreement. Any reproduction or disclosure of this
7: * material without the express written authorization of Mark Williams
8: * Company or persuant to the license agreement is unlawful.
9: *
10: * COHERENT Version 2.3.37
11: * Copyright (c) 1982, 1983, 1984.
12: * An unpublished work by Mark Williams Company, Chicago.
13: * All rights reserved.
14: -lgl) */
15: /*
16: * Coherent.
17: * Filesystem (mostly handling of in core inodes).
18: *
19: * $Log: fs1.c,v $
20: * Revision 1.4 92/07/16 16:33:32 hal
21: * Kernel #58
22: *
23: * Revision 1.3 92/02/06 17:55:36 vlad
24: * Fix typo in ialloc panic.
25: *
26: * Revision 1.2 92/01/06 11:59:17 hal
27: * Compile with cc.mwc.
28: *
29: * Revision 1.1 88/03/24 16:13:47 src
30: * Initial revision
31: *
32: * 86/12/13 Allan Cornish /usr/src/sys/coh/fs1.c
33: * isync() no longer updates the disk image of a character device inode.
34: *
35: * 86/11/19 Allan Cornish /usr/src/sys/coh/fs1.c
36: * idirent() initializes the (new) (IO).io_flag field to 0.
37: */
38: #include <sys/coherent.h>
39: #include <sys/buf.h>
40: #include <canon.h>
41: #include <sys/dir.h>
42: #include <errno.h>
43: #include <sys/filsys.h>
44: #include <sys/ino.h>
45: #include <sys/inode.h>
46: #include <sys/io.h>
47: #include <sys/mount.h>>
48: #include <sys/stat.h>
49:
50: /*
51: * Get character for `ftoi' depending on what space the characters are
52: * coming from.
53: */
54: #define ftoic(p) (u.u_io.io_seg==IOSYS ? *p : getubd(p))
55:
56: /*
57: * Map the given filename to an inode. If an error is encountered,
58: * `u.u_error' is set. `u.u_error' is always returned. As this routine
59: * needs to set several things, depending on the type of access, `t',
60: * there are places in the processes' user area reserved for this routine
61: * to set. These are defined in the user process structure. The seek
62: * position is always set to the position of the directory entry of the
63: * child if the child exists or the first free position if it doesn't.
64: * 'r' => Reference. A pointer to the child's inode is returned locked.
65: * 'c' => Create. If the child exists, a pointer to the inode is returned
66: * locked. Otherwise if the parent directory exists, a pointer to
67: * the parent directory is returned locked. Otherwise, an error.
68: * 'u' => Unlink. The parent directory is returned unlocked. The child's
69: * inode number is returned. The seek position is also set.
70: */
71: ftoi(np, t)
72: char *np;
73: {
74: register INODE *cip;
75: register char *cp;
76: register int c;
77: register struct direct *dp;
78: register BUF *bp;
79: off_t cseek, fseek, s;
80: int fflag, mflag;
81: dev_t dev;
82: ino_t ino;
83: daddr_t b;
84:
85: u.u_cdirn = 0;
86: u.u_cdiri = NULL;
87: u.u_pdiri = NULL;
88: if ((c=ftoic(np++)) != '/')
89: cip = u.u_cdir;
90: else {
91: c = ftoic(np++);
92: cip = u.u_rdir;
93: }
94: while (c == '/')
95: c = ftoic(np++);
96: ilock(cip);
97: cip->i_refc++;
98: if (c == '\0') {
99: if (t == 'r') {
100: u.u_cdiri = cip;
101: return (u.u_error);
102: }
103: u.u_error = ENOENT;
104: idetach(cip);
105: return (u.u_error);
106: }
107: for (;;) {
108: cp = u.u_direct.d_name;
109: while (c!='/' && c!='\0') {
110: if (cp < &u.u_direct.d_name[DIRSIZ])
111: *cp++ = c;
112: c = ftoic(np++);
113: }
114: while (c == '/')
115: c = ftoic(np++);
116: while (cp < &u.u_direct.d_name[DIRSIZ])
117: *cp++ = '\0';
118: if ((cip->i_mode&IFMT) != IFDIR)
119: u.u_error = ENOTDIR;
120: else
121: iaccess(cip, IPE);
122: if (u.u_error) {
123: idetach(cip);
124: return (u.u_error);
125: }
126: cp = u.u_direct.d_name;
127: if (cip->i_ino==ROOTIN && cip->i_dev!=rootdev)
128: if (*cp++=='.' && *cp++=='.' && *cp++=='\0')
129: cip = ftoim(cip);
130: b = 0;
131: fflag = 0;
132: mflag = 0;
133: cseek = 0;
134: s = cip->i_size;
135: while (s > 0) {
136: if ((bp=vread(cip, b++)) == NULL) {
137: idetach(cip);
138: return (u.u_error);
139: }
140: dp = bp->b_vaddr;
141: while (dp < bp->b_vaddr+BSIZE) {
142: if ((s-=sizeof(*dp)) < 0)
143: break;
144: if ((ino=dp->d_ino) == 0) {
145: if (fflag == 0) {
146: fflag++;
147: fseek = cseek;
148: }
149: } else {
150: if (direq(dp)) {
151: canino(ino);
152: mflag = 1;
153: s = 0;
154: break;
155: }
156: }
157: cseek += sizeof(*dp);
158: dp++;
159: }
160: brelease(bp);
161: }
162: dev = cip->i_dev;
163: if (fflag == 0)
164: fseek = cseek;
165: if (mflag == 0) {
166: if (c=='\0' && t=='c') {
167: u.u_pdiri = cip;
168: u.u_io.io_seek = fseek;
169: } else {
170: u.u_error = ENOENT;
171: idetach(cip);
172: }
173: return (u.u_error);
174: }
175: if (c == '\0') {
176: if (t == 'u') {
177: u.u_cdirn = ino;
178: u.u_pdiri = cip;
179: u.u_io.io_seek = cseek;
180: return (u.u_error);
181: }
182: idetach(cip);
183: u.u_cdiri = iattach(dev, ino);
184: return (u.u_error);
185: }
186: idetach(cip);
187: if ((cip=iattach(dev, ino)) == NULL)
188: return (u.u_error);
189: }
190: }
191:
192: /*
193: * Given an inode which is the root of a file system, return the inode
194: * on which the file system was mounted.
195: */
196: INODE *
197: ftoim(ip)
198: register INODE *ip;
199: {
200: register MOUNT *mp;
201:
202: for (mp=mountp; mp!=NULL; mp=mp->m_next) {
203: if (mp->m_dev == ip->i_dev) {
204: idetach(ip);
205: ip = mp->m_ip;
206: ilock(ip);
207: ip->i_refc++;
208: break;
209: }
210: }
211: return (ip);
212: }
213:
214: /*
215: * Compare the string in `u.u_direct.d_name' with the name in the
216: * given directory pointer.
217: */
218: direq(dp)
219: struct direct *dp;
220: {
221: register char *cp1, *cp2;
222: register unsigned n;
223:
224: if (dp->d_ino == 0)
225: return (0);
226: cp1 = dp->d_name;
227: cp2 = u.u_direct.d_name;
228: n = DIRSIZ;
229: do {
230: if (*cp1++ != *cp2++)
231: return (0);
232: } while (--n);
233: return (1);
234: }
235:
236: /*
237: * Make an inode of the given mode and device. The parent directory,
238: * name and such stuff is set by ftoi.
239: */
240: INODE *
241: imake(mode, rdev)
242: unsigned mode;
243: dev_t rdev;
244: {
245: register INODE *ip;
246:
247: ip = NULL;
248: mode &= ~u.u_umask;
249: if ((mode&ISVTXT)!=0 && super()==0)
250: goto det;
251: if (iaccess(u.u_pdiri, IPW) == 0)
252: goto det;
253: if ((ip=ialloc(u.u_pdiri->i_dev, mode)) == NULL)
254: goto det;
255: ip->i_nlink = 1;
256: ip->i_a.i_rdev = rdev;
257: idirent(ip->i_ino);
258: iamc(ip); /* creat/mknod - atime/mtime/ctime */
259: det:
260: idetach(u.u_pdiri);
261: return (ip);
262: }
263:
264: /*
265: * Write a directory entry out. Everything necessary has been conveniently
266: * set by `ftoi', except the new inode number of this directory entry.
267: */
268: idirent(ino)
269: {
270: u.u_direct.d_ino = ino;
271: canino(u.u_direct.d_ino);
272: u.u_io.io_ioc = sizeof (struct direct);
273: u.u_io.io.vbase = &u.u_direct;
274: u.u_io.io_seg = IOSYS;
275: u.u_io.io_flag = 0;
276: iwrite(u.u_pdiri, &u.u_io);
277: }
278:
279: /*
280: * Return a pointer to a locked inode in core containing the given
281: * inode number and device.
282: */
283: INODE *
284: iattach(dev, ino)
285: {
286: register INODE *ip;
287: register INODE *fip;
288: register unsigned lrt;
289: register MOUNT *mp;
290:
291: for (;;) {
292: fip = NULL;
293: for (ip=&inodep[NINODE-1]; ip>=inodep; --ip) {
294: if (ip->i_ino==ino && ip->i_dev==dev)
295: break;
296: if (ip->i_refc == 0) {
297: if (fip==NULL || ip->i_lrt<lrt) {
298: fip = ip;
299: lrt = ip->i_lrt;
300: }
301: }
302: }
303: if (ip < inodep) {
304: if ((ip=fip) == NULL) {
305: devmsg(dev, "Inode table overflow");
306: u.u_error = ENFILE;
307: return (NULL);
308: }
309: ilock(ip);
310: if (ip->i_refc != 0) {
311: iunlock(ip);
312: continue;
313: }
314: ip->i_dev = dev;
315: ip->i_ino = ino;
316: ip->i_refc = 1;
317: ip->i_lrt = timer.t_time;
318: if (icopydm(ip) == 0) {
319: ip->i_ino = 0;
320: ip->i_refc = 0;
321: iunlock(ip);
322: return (NULL);
323: }
324: return (ip);
325: }
326: if ((ip->i_flag&IFMNT) != 0) {
327: for (mp=mountp; mp!=NULL; mp=mp->m_next) {
328: if (mp->m_ip == ip) {
329: ino = ROOTIN;
330: dev = mp->m_dev;
331: break;
332: }
333: }
334: continue;
335: }
336: ilock(ip);
337: if (ip->i_ino!=ino || ip->i_dev!=dev) {
338: iunlock(ip);
339: continue;
340: }
341: if (ip->i_refc < 0)
342: panic("ialloc(%x)", ip);
343: ip->i_refc++;
344: ip->i_lrt = timer.t_time;
345: return (ip);
346: }
347: }
348:
349: /*
350: * Given a locked inode, deaccess it.
351: */
352: idetach(ip)
353: register INODE *ip;
354: {
355: if (ilocked(ip)==0 || ip->i_refc<=0)
356: panic("idetach(%p)", ip);
357: if (--ip->i_refc == 0) {
358: #if 1
359: if (ip->i_rl != NULL)
360: panic("idetach(%p) with locked records", ip);
361: #endif
362: if ((ip->i_flag&(IFACC|IFMOD|IFCRT)) != 0
363: || ip->i_nlink == 0)
364: icopymd(ip);
365: }
366: iunlock(ip);
367: }
368:
369: /*
370: * Given a inode which isn't locked, lock it and then deaccess.
371: */
372: ldetach(ip)
373: register INODE *ip;
374: {
375: ilock(ip);
376: idetach(ip);
377: }
378:
379: /*
380: * A specialized routine for finding whether the given inode may be unlinked.
381: * Quite simple you say, but we already have an inode locked and could run
382: * into gating problems if we were to lock another. So we look through the
383: * cache to see if the inode is there. If it is, we can easily tell. If it
384: * isn't, `icopydm' is called with a static. This routine is only used by
385: * `uunlink'.
386: */
387: iucheck(dev, ino)
388: register dev_t dev;
389: register ino_t ino;
390: {
391: register INODE *ip;
392: INODE inode;
393:
394: for (ip=&inodep[NINODE-1]; ip>=inodep; --ip) {
395: if (ip->i_ino==ino && ip->i_dev==dev)
396: break;
397: }
398: if (ip < inodep) {
399: ip = &inode;
400: ip->i_dev = dev;
401: ip->i_ino = ino;
402: if (icopydm(ip) == 0)
403: return (0);
404: }
405: if ((ip->i_mode&IFMT) == IFDIR) {
406: if (super() == 0)
407: return (0);
408: }
409: return (1);
410: }
411:
412: /*
413: * Copy an inode from disk to memory performing canonization.
414: */
415: icopydm(ip)
416: register INODE *ip;
417: {
418: register struct dinode *dip;
419: register BUF *bp;
420: register ino_t ino;
421: struct dinode dinode;
422: vaddr_t v;
423:
424: ip->i_flag = 0;
425: ino = ip->i_ino;
426:
427: if ((bp=bread(ip->i_dev, (daddr_t)iblockn(ino), 1)) == NULL)
428: return (0);
429:
430: dip = &dinode;
431: v = (char *)((struct dinode *)bp->b_vaddr + iblocko(ino));
432: kkcopy( v, dip, sizeof(dinode));
433: brelease(bp);
434: ip->i_mode = dip->di_mode;
435: canshort(ip->i_mode);
436: ip->i_nlink = dip->di_nlink;
437: canshort(ip->i_nlink);
438: ip->i_uid = dip->di_uid;
439: canshort(ip->i_uid);
440: ip->i_gid = dip->di_gid;
441: canshort(ip->i_gid);
442: ip->i_size = dip->di_size;
443: cansize(ip->i_size);
444:
445: switch (ip->i_mode&IFMT) {
446: case IFBLK:
447: case IFCHR:
448: ip->i_a.i_rdev = dip->di_a.di_rdev;
449: candev(ip->i_a.i_rdev);
450: break;
451: case IFREG:
452: case IFDIR:
453: l3tol(ip->i_a.i_addr, dip->di_a.di_addb, NADDR);
454: break;
455: case IFPIPE:
456: l3tol(ip->i_pipe, dip->di_addp, ND);
457: ip->i_pnc = dip->di_pnc;
458: canint(ip->i_pnc);
459: ip->i_prx = dip->di_prx;
460: canint(ip->i_prx);
461: ip->i_pwx = dip->di_pwx;
462: canint(ip->i_pwx);
463: break;
464: default:
465: kclear(&ip->i_a, sizeof(ip->i_a));
466: break;
467: }
468:
469: ip->i_atime = dip->di_atime;
470: cantime(ip->i_atime);
471: ip->i_mtime = dip->di_mtime;
472: cantime(ip->i_mtime);
473: ip->i_ctime = dip->di_ctime;
474: cantime(ip->i_ctime);
475: ip->i_rl = NULL;
476: return (1);
477: }
478:
479: /*
480: * Copy an inode from memory back on to disk performing canonization.
481: */
482: icopymd(ip)
483: register INODE *ip;
484: {
485: register struct dinode *dip;
486: register BUF *bp;
487: register ino_t ino;
488: struct dinode dinode;
489: vaddr_t v;
490:
491: if (getment(ip->i_dev, 0) == NULL)
492: return;
493:
494: ino = ip->i_ino;
495: if (ip->i_refc==0 && ip->i_nlink==0 && ino!=BADFIN && ino!=ROOTIN) {
496: iclear(ip);
497: ip->i_lrt = 0;
498: ip->i_mode = 0;
499: ifree(ip->i_dev, ino);
500: }
501:
502: dip = &dinode;
503: dip->di_mode = ip->i_mode;
504: canshort(dip->di_mode);
505: dip->di_nlink = ip->i_nlink;
506: canshort(dip->di_nlink);
507: dip->di_uid = ip->i_uid;
508: canshort(dip->di_uid);
509: dip->di_gid = ip->i_gid;
510: canshort(dip->di_gid);
511: dip->di_size = ip->i_size;
512: cansize(dip->di_size);
513:
514: switch (ip->i_mode&IFMT) {
515: case IFBLK:
516: case IFCHR:
517: dip->di_a.di_rdev = ip->i_a.i_rdev;
518: candev(dip->di_a.di_rdev);
519: break;
520: case IFREG:
521: case IFDIR:
522: ltol3(dip->di_addr, ip->i_a.i_addr, NADDR);
523: break;
524: case IFPIPE:
525: ltol3(dip->di_addp, ip->i_pipe, ND);
526: dip->di_pnc = ip->i_pnc;
527: canshort(dip->di_pnc);
528: dip->di_prx = ip->i_prx;
529: canshort(dip->di_prx);
530: dip->di_pwx = ip->i_pwx;
531: canshort(dip->di_pwx);
532: break;
533: default:
534: kclear(&dip->di_a, sizeof(dip->di_a));
535: break;
536: }
537:
538: dip->di_atime = ip->i_atime;
539: cantime(dip->di_atime);
540: dip->di_mtime = ip->i_mtime;
541: cantime(dip->di_mtime);
542: dip->di_ctime = ip->i_ctime;
543: cantime(dip->di_ctime);
544:
545: if ((bp=bread(ip->i_dev, (daddr_t)iblockn(ino), 1)) == NULL)
546: return;
547:
548: v = (char *)((struct dinode *)bp->b_vaddr + iblocko(ino));
549: kkcopy(dip, v, sizeof(dinode));
550: bp->b_flag |= BFMOD;
551: brelease(bp);
552: ip->i_flag &= ~(IFACC|IFMOD|IFCRT);
553: }
554:
555: /*
556: * Copy all relevant inodes out on device `dev'.
557: */
558: isync(dev)
559: register dev_t dev;
560: {
561: register INODE *ip;
562:
563: for (ip=&inodep[NINODE-1]; ip>=inodep; --ip) {
564: if (ip->i_refc == 0)
565: continue;
566: if (ip->i_dev != dev)
567: continue;
568: if ( (ip->i_mode & IFMT) == IFCHR )
569: continue;
570: if ((ip->i_flag&(IFACC|IFMOD|IFCRT)) == 0)
571: continue;
572: icopymd(ip);
573: }
574: }
575:
576: /*
577: * Clear the given inode and all space associated with it.
578: */
579: iclear(ip)
580: register INODE *ip;
581: {
582: register int n;
583: register daddr_t b;
584:
585: switch (ip->i_mode&IFMT) {
586: case IFPIPE:
587: ip->i_pnc = 0;
588: ip->i_prx = 0;
589: ip->i_pwx = 0;
590: n = ND;
591: break;
592: case IFDIR:
593: case IFREG:
594: n = NADDR;
595: break;
596: default:
597: return;
598: }
599: while (n > ND) {
600: if ((b=ip->i_a.i_addr[--n]) != 0)
601: indfree(ip->i_dev, b, 1+n-ND);
602: }
603: while (n > 0) {
604: if ((b=ip->i_a.i_addr[--n]) != 0)
605: bfree(ip->i_dev, b);
606: }
607: ip->i_size = 0;
608: kclear(ip->i_a.i_addr, sizeof(ip->i_a.i_addr));
609: iamc(ip); /* creat/pipe - atime/mtime/ctime */
610: }
611:
612: /*
613: * Copy the appropriate information from the inode to the stat buffer.
614: */
615: istat(ip, sbp)
616: register INODE *ip;
617: register struct stat *sbp;
618: {
619: sbp->st_dev = ip->i_dev;
620: sbp->st_ino = ip->i_ino;
621: sbp->st_mode = ip->i_mode;
622: sbp->st_nlink = ip->i_nlink;
623: sbp->st_uid = ip->i_uid;
624: sbp->st_gid = ip->i_gid;
625: sbp->st_rdev = NODEV;
626: sbp->st_size = ip->i_size;
627: sbp->st_atime = ip->i_atime;
628: sbp->st_mtime = ip->i_mtime;
629: sbp->st_ctime = ip->i_ctime;
630: switch (ip->i_mode&IFMT) {
631: case IFBLK:
632: case IFCHR:
633: sbp->st_rdev = ip->i_a.i_rdev;
634: sbp->st_size = 0;
635: break;
636: case IFPIPE:
637: sbp->st_size = ip->i_pnc;
638: break;
639: }
640: }
641:
642: /*
643: * See if it is possible to access the given inode with the bits in
644: * the given mode.
645: * If the mode includes writing, and i_refc is > 1, then check for
646: * shared text problems.
647: */
648: iaccess(ip, mode)
649: register INODE *ip;
650: register int mode;
651: {
652: if ((imode(ip, u.u_uid, u.u_gid)&mode) != mode) {
653: u.u_error = EACCES;
654: return (0);
655: }
656: if ((mode&IPW) != 0 && ip->i_refc > 1 && sbusy(ip)) {
657: u.u_error = ETXTBSY;
658: return (0);
659: }
660: return (1);
661: }
662:
663: /*
664: * Get the maximum allowable mode on a file.
665: */
666: imode(ip, uid, gid)
667: register INODE *ip;
668: {
669: if (uid == 0)
670: return (IPR|IPW|IPE);
671: if (uid == ip->i_uid)
672: return ((ip->i_mode>>6)&07);
673: if (gid == ip->i_gid)
674: return ((ip->i_mode>>3)&07);
675: return (ip->i_mode&07);
676: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.