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