![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fs2.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 / STREAMS / coh.386|
Return to fs2.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / coh.386 |
1.1 root 1: /* $Header: /src386/STREAMS/coh.386/RCS/fs2.c,v 2.3 93/08/09 13:35:33 bin Exp Locker: bin $ */
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 (disk inodes).
18: *
19: * $Log: fs2.c,v $
20: * Revision 2.3 93/08/09 13:35:33 bin
21: * Kernel 82 changes
22: *
23: * Revision 2.2 93/07/26 15:19:24 nigel
24: * Nigel's R80
25: *
26: * Revision 2.2 93/07/26 14:28:32 nigel
27: * Nigel's R80
28: *
29: * Revision 1.5 93/04/14 10:06:31 root
30: * r75
31: *
32: * Revision 1.2 92/01/06 11:59:27 hal
33: * Compile with cc.mwc.
34: *
35: * Revision 1.1 88/03/24 16:13:51 src
36: * Initial revision
37: *
38: * 87/04/29 Allan Cornish /usr/src/sys/coh/fs2.c
39: * Fsminit panic messages now specify the root major and minor device.
40: *
41: * 86/11/19 Allan Cornish /usr/src/sys/coh/fs2.c
42: * setacct() initializes the (new) (IO).io_flag field to 0.
43: *
44: * 85/08/08 Allan Cornish
45: * ialloc() erroneously did a brelease(NULL) if bclaim() returned NULL.
46: * also, sbp->s_fmod was set BEFORE the in-core inode table was updated.
47: * This created a critical race with msync() (called by sync system call).
48: *
49: * 85/04/17 Allan Cornish
50: * eliminated test for rootdev in msync()
51: */
52:
53: #include <common/ccompat.h>
54: #include <sys/debug.h>
55:
56: #include <sys/coherent.h>
57: #include <sys/acct.h>
58: #include <sys/buf.h>
59: #include <canon.h>
60: #include <sys/con.h>
61: #include <sys/errno.h>
62: #include <sys/filsys.h>
63: #include <sys/ino.h>
64: #include <sys/inode.h>
65: #include <sys/io.h>
66: #include <sys/mount.h>
67: #include <sys/proc.h>
68: #include <sys/stat.h>
69: #include <sys/file.h>
70:
71: #define _INODE_BUSY_DUMP 1
72:
73: /*
74: * Initialise filesystem.
75: */
76: fsminit()
77: {
78: register MOUNT *mp;
79: INODE * ip;
80:
81: /*
82: * NIGEL: We begin by setting up all the inodes in the system.
83: */
84:
85: for (ip = inodep + NINODE - 1 ; ip >= inodep ; ip --) {
86: ip->i_refc = 0;
87: __GATE_INIT (ip->i_gate, "inode");
88: }
89:
90:
91: /*
92: * Mount the root file system.
93: */
94: if ((mp = fsmount (rootdev, ronflag)) == NULL)
95: panic ("fsminit: no rootdev(%d,%d)",
96: major (rootdev), minor (rootdev));
97:
98: /*
99: * Set system time from the super block.
100: */
101: timer.t_time = mp->m_super.s_time;
102:
103: /*
104: * Access the root directory.
105: */
106: if ((u.u_rdir = iattach (rootdev, ROOTIN)) == NULL)
107: panic ("fsminit: no / on rootdev(%d,%d)",
108: major (rootdev), minor (rootdev));
109:
110: /*
111: * Record current directory.
112: */
113: u.u_cdir = u.u_rdir;
114: u.u_cdir->i_refc++;
115: iunlock (u.u_rdir);
116: }
117:
118:
119: /*
120: * Mount the given device.
121: */
122: MOUNT *
123: fsmount(dev, f)
124: register dev_t dev;
125: {
126: register MOUNT *mp;
127: register BUF *bp;
128:
129: if ((mp = kalloc (sizeof (MOUNT))) == NULL) {
130: printf ("fsmount(%x,%x): kalloc failed ", dev, f);
131: return NULL;
132: }
133: dopen (dev, (f ? IPR : IPR | IPW), DFBLK);
134: if (u.u_error) {
135: printf("fsmount(%x,%x): dopen failed ", dev, f);
136: kfree (mp);
137: return NULL;
138: }
139: if ((bp = bread (dev, (daddr_t) SUPERI, BUF_SYNC)) == NULL) {
140: dclose (dev, (f ? IPR : IPR | IPW), DFBLK); /* NIGEL */
141: kfree (mp);
142: return NULL;
143: }
144: memcpy (& mp->m_super, bp->b_vaddr, sizeof (mp->m_super));
145: brelease (bp);
146: cansuper (& mp->m_super);
147:
148: mp->m_ip = NULL;
149: mp->m_dev = dev;
150: mp->m_flag = f;
151: mp->m_super.s_fmod = 0;
152: mp->m_next = mountp;
153:
154: __GATE_INIT (mp->m_ilock, "mount ilock");
155: __GATE_INIT (mp->m_flock, "mount flock");
156:
157: mountp = mp;
158: return mp;
159: }
160:
161:
162: /*
163: * Canonize a super block.
164: */
165: cansuper(fsp)
166: register struct filsys *fsp;
167: {
168: register int i;
169:
170: canint (fsp->s_isize);
171: candaddr (fsp->s_fsize);
172: canshort (fsp->s_nfree);
173: for (i = 0 ; i < NICFREE ; i ++)
174: candaddr (fsp->s_free [i]);
175: canshort (fsp->s_ninode);
176: for (i = 0 ; i < NICINOD ; i ++)
177: canino (fsp->s_inode [i]);
178: cantime (fsp->s_time);
179: candaddr (fsp->s_tfree);
180: canino (fsp->s_tinode);
181: canshort (fsp->s_m);
182: canshort (fsp->s_n);
183: canlong (fsp->s_unique);
184: }
185:
186: /*
187: * Given a pointer to a mount entry, write out all inodes on that device.
188: */
189: msync(mp)
190: register MOUNT *mp;
191: {
192: register struct filsys *sbp;
193: register BUF *bp;
194:
195: if ((mp->m_flag & MFRON) != 0)
196: return;
197: isync (mp->m_dev);
198: sbp = & mp->m_super;
199: if (sbp->s_fmod == 0)
200: return;
201: bp = bclaim (mp->m_dev, (daddr_t) SUPERI, BUF_SYNC);
202: sbp->s_time = timer.t_time;
203: sbp->s_fmod = 0;
204: memcpy (bp->b_vaddr, sbp, sizeof (* sbp));
205: cansuper (bp->b_vaddr);
206: bwrite (bp, 1);
207: brelease (bp);
208: }
209:
210: /*
211: * Return the mount entry for the given device. If `f' is not set
212: * and the device is read only, don't set the error status.
213: */
214: MOUNT *
215: getment(dev, f)
216: register dev_t dev;
217: {
218: register MOUNT *mp;
219:
220: for (mp = mountp ; mp != NULL ; mp = mp->m_next) {
221: if (mp->m_dev != dev)
222: continue;
223: if ((mp->m_flag & MFRON) != 0) {
224: if (f != 0)
225: u.u_error = EROFS;
226: return NULL;
227: }
228: return mp;
229: }
230: panic ("getment: dev=0x%x", dev);
231: }
232:
233: /*
234: * Allocate a new inode with the given mode. The returned inode is locked.
235: */
236: INODE *
237: ialloc(dev, mode)
238: dev_t dev;
239: unsigned mode;
240: {
241: register struct dinode *dip;
242: register struct filsys *sbp;
243: register ino_t *inop;
244: register ino_t ino;
245: register BUF *bp;
246: register daddr_t b;
247: register struct dinode *dipe;
248: register ino_t *inope;
249: register MOUNT *mp;
250: register INODE *ip;
251: #if _INODE_BUSY_DUMP
252: int eninode, etinode;
253: int lninode, ltinode;
254: int xninode, xtinode;
255: #endif
256:
257: if ((mp = getment (dev, 1)) == NULL)
258: return NULL;
259: sbp = & mp->m_super;
260:
261: #if _INODE_BUSY_DUMP
262: eninode = sbp->s_ninode;
263: etinode = sbp->s_tinode;
264: #endif
265:
266: for (;;) {
267: lock (mp->m_ilock);
268:
269: #if _INODE_BUSY_DUMP
270: lninode = sbp->s_ninode;
271: ltinode = sbp->s_tinode;
272: #endif
273:
274: if (sbp->s_ninode == 0) {
275: isync (dev);
276: ino = 1;
277: inop = sbp->s_inode;
278: inope = & sbp->s_inode [NICINOD];
279: for (b = INODEI ; b < sbp->s_isize ; b ++) {
280: if (bad (dev, b)) {
281: ino += INOPB;
282: continue;
283: }
284: if ((bp = bread (dev, b, BUF_SYNC)) == NULL) {
285: ino += INOPB;
286: continue;
287: }
288: dip = bp->b_vaddr;
289: dipe = & dip [INOPB];
290: for (; dip < dipe ; dip ++, ino ++) {
291: if (dip->di_mode != 0)
292: continue;
293: if (inop >= inope)
294: break;
295: * inop ++ = ino;
296: }
297: brelease (bp);
298: if (inop >= inope)
299: break;
300: }
301: sbp->s_ninode = inop - sbp->s_inode;
302: if (sbp->s_ninode == 0) {
303: sbp->s_tinode = 0;
304: unlock (mp->m_ilock);
305: devmsg (dev, "Out of inodes");
306: u.u_error = ENOSPC;
307: return NULL;
308: }
309: }
310:
311: #if _INODE_BUSY_DUMP
312: xninode = sbp->s_ninode;
313: xtinode = sbp->s_tinode;
314: #endif
315:
316: ino = sbp->s_inode [-- sbp->s_ninode];
317: -- sbp->s_tinode;
318: sbp->s_fmod = 1;
319: unlock (mp->m_ilock);
320: if ((ip = iattach(dev, ino)) != NULL) {
321: if (ip->i_mode != 0) {
322: devmsg(dev, "Inode %u busy", ino);
323:
324: #if _INODE_BUSY_DUMP
325: printf("%x %x rf=%x fl=%x md=%x nl=%x en=%x et=%x ln=%x lt=%x xn=%x xt=%x n=%x t=%x\n",
326: mode, ino, ip->i_refc, ip->i_flag, ip->i_mode, ip->i_nlink,
327: eninode, etinode, lninode, ltinode, xninode, xtinode,
328: sbp->s_ninode, sbp->s_tinode);
329: #endif
330:
331: idetach (ip);
332: lock (mp->m_ilock);
333: ++ sbp->s_tinode;
334: sbp->s_fmod = 1;
335: unlock (mp->m_ilock);
336: continue;
337: }
338: ip->i_flag = 0;
339: ip->i_mode = mode;
340: ip->i_nlink = 0;
341: ip->i_uid = u.u_uid;
342: ip->i_gid = u.u_gid;
343: }
344: return ip;
345: }
346: }
347:
348: /*
349: * Free the inode `ino' on device `dev'.
350: */
351: ifree(dev, ino)
352: dev_t dev;
353: ino_t ino;
354: {
355: register struct filsys *sbp;
356: register MOUNT *mp;
357:
358: if ((mp = getment(dev, 1)) == NULL)
359: return;
360: lock (mp->m_ilock);
361: sbp = & mp->m_super;
362: sbp->s_fmod = 1;
363: if (sbp->s_ninode < NICINOD)
364: sbp->s_inode [sbp->s_ninode ++] = ino;
365: sbp->s_tinode ++;
366: unlock (mp->m_ilock);
367: }
368:
369: /*
370: * Free all blocks in the indirect block `b' on the device `dev'.
371: * `l' is the level of indirection.
372: */
373: indfree(dev, b, l)
374: dev_t dev;
375: daddr_t b;
376: register unsigned l;
377: {
378: register int i;
379: register BUF *bp;
380: daddr_t * dp;
381: daddr_t b1;
382:
383: if (b == 0)
384: return;
385: if (l -- > 0 && (bp = bread (dev, b, BUF_SYNC)) != NULL) {
386: i = NBN;
387: while (i -- > 0) {
388: dp = bp->b_vaddr;
389: if ((b1 = dp [i]) == 0)
390: continue;
391: candaddr (b1);
392: if (l == 0)
393: bfree (dev, b1);
394: else
395: indfree (dev, b1, l);
396: }
397: brelease (bp);
398: }
399: bfree (dev, b);
400: }
401:
402: /*
403: * Experimental routine to read free block lists blocks (ahead of time, but
404: * if it works we'll subsume the synchronous read as well).
405: */
406:
407: static BUF *
408: read_free_block_list (super, dev, block_no, sync_flag)
409: struct filsys * super;
410: dev_t dev;
411: daddr_t block_no;
412: int sync_flag;
413: {
414: return block_no < super->s_fsize && block_no >= super->s_isize ?
415: bread (dev, block_no, sync_flag) : NULL;
416: }
417:
418:
419: /*
420: * Allocate a block from the filesystem mounted of device `dev'.
421: */
422:
423: daddr_t
424: balloc(dev)
425: dev_t dev;
426: {
427: register struct filsys *sbp;
428: register struct fblk *fbp;
429: register daddr_t b;
430: register BUF *bp;
431: register MOUNT *mp;
432:
433: if ((mp = getment(dev, 1)) == NULL)
434: return 0;
435: lock (mp->m_flock);
436: sbp = & mp->m_super;
437: if (sbp->s_nfree == 0) {
438: enospc:
439: sbp->s_nfree = 0;
440: devmsg (dev, "Out of space");
441: u.u_error = ENOSPC;
442: b = 0;
443: } else {
444: sbp->s_fmod = 1;
445: if ((b = sbp->s_free [-- sbp->s_nfree]) == 0)
446: goto enospc;
447: if (sbp->s_nfree == 0) {
448: if ((bp = read_free_block_list (sbp, dev, b,
449: BUF_SYNC)) == NULL) {
450: ebadflist:
451: devmsg(dev, "Bad free list");
452: goto enospc;
453: }
454: fbp = bp->b_vaddr;
455: sbp->s_nfree = fbp->df_nfree;
456: canshort (sbp->s_nfree);
457: memcpy (sbp->s_free, fbp->df_free,
458: sizeof (sbp->s_free));
459:
460: if (sbp->s_nfree > NICFREE)
461: goto ebadflist;
462: brelease (bp);
463:
464: canndaddr (sbp->s_free, sbp->s_nfree);
465:
466: /*
467: * NIGEL: As an experiment, try reading ahead on the
468: * free block list.
469: */
470:
471: if (sbp->s_nfree > 0)
472: read_free_block_list (sbp, dev,
473: sbp->s_free [0],
474: BUF_ASYNC);
475: }
476: -- sbp->s_tfree;
477: if (b >= sbp->s_fsize || b < sbp->s_isize)
478: goto ebadflist;
479: }
480: unlock (mp->m_flock);
481: return b;
482: }
483:
484:
485: /*
486: * Flag to say whether we should try and keep the free-block list sorted.
487: */
488:
489: int t_sortblocks = 0;
490:
491: /*
492: * If we are sorting blocks, this routine can be used to keep blocks in sorted
493: * order. Given a fixed-size list in reverse rank order, this routine returns
494: * the new element if it is smaller than all others, or the smallest element
495: * after the new element has been inserted in position.
496: */
497:
498: #if __USE_PROTO__
499: static daddr_t daddr_add (daddr_t * list, int count, daddr_t newblock)
500: #else
501: static daddr_t
502: daddr_add (list, count, newblock)
503: daddr_t * list;
504: int count;
505: daddr_t newblock;
506: #endif
507: {
508: daddr_t * end = list + count;
509:
510: ASSERT (count >= 0);
511:
512: while (list != end) {
513: if (newblock < * list ++) {
514: daddr_t temp;
515: /*
516: * We have found the insertion point... move all the
517: * elements from (list - 1) to (end - 1) up, and put
518: * the new element in place.
519: */
520:
521: temp = * -- end;
522: list --;
523:
524: while (list != end) {
525: end --;
526: * (end + 1) = * end;
527: }
528: * list = newblock;
529: return temp;
530: }
531: }
532:
533: return newblock;
534: }
535:
536:
537: /*
538: * Free the block `b' on the device `dev'.
539: */
540: bfree(dev, b)
541: dev_t dev;
542: daddr_t b;
543: {
544: register struct filsys *sbp;
545: register struct fblk *fbp;
546: register BUF *bp;
547: register MOUNT *mp;
548:
549: if ((mp = getment (dev, 1)) == NULL)
550: return;
551: sbp = & mp->m_super;
552: if (b >= sbp->s_fsize || b < sbp->s_isize) {
553: devmsg (dev, "Bad block %u (free)", (unsigned) b);
554: return;
555: }
556:
557: /*
558: * NIGEL : Are we keeping things in order? If so, insert the new block
559: * in position (the smallest block-number is the new 'b'). Note that
560: * the zero-position of the free-block list never changes... this is
561: * an important invariant, because the block in that position is a
562: * link and *must* be preserved in that position so that the links get
563: * properly followed later on.
564: */
565:
566: if (t_sortblocks && sbp->s_nfree > 0)
567: b = daddr_add (sbp->s_free + 1, sbp->s_nfree - 1, b);
568:
569: lock (mp->m_flock);
570: if (sbp->s_nfree == 0 || sbp->s_nfree == NICFREE) {
571: bp = bclaim (dev, b, BUF_SYNC);
572: fbp = bp->b_vaddr;
573:
574: /*
575: * NIGEL: Is there really any reason to do this?
576: */
577: memset (bp->b_vaddr, 0, BSIZE);
578:
579: fbp->df_nfree = sbp->s_nfree;
580: canshort (fbp->df_nfree);
581: memcpy (fbp->df_free, sbp->s_free, sizeof (fbp->df_free));
582: canndaddr (fbp->df_free, sbp->s_nfree);
583:
584: bp->b_flag |= BFMOD;
585: brelease (bp);
586: sbp->s_nfree = 0;
587: }
588: sbp->s_free [sbp->s_nfree ++] = b;
589: sbp->s_tfree ++;
590: sbp->s_fmod = 1;
591: unlock (mp->m_flock);
592: }
593:
594: /*
595: * Determine if the given block is bad.
596: */
597: bad(dev, b)
598: dev_t dev;
599: daddr_t b;
600: {
601: register INODE *ip;
602: register BUF *bp;
603: register int i;
604: register int m;
605: register int n;
606: daddr_t l;
607:
608: if ((ip = iattach (dev, 1)) == NULL)
609: panic ("bad()");
610: n = blockn (ip->i_size);
611: if ((m = n) > ND)
612: m = ND;
613: for (i = 0 ; i < m ; i ++) {
614: -- n;
615: if (b == ip->i_a.i_addr [i]) {
616: idetach (ip);
617: return 1;
618: }
619: }
620: l = ip->i_a.i_addr [ND];
621: idetach (ip);
622: if (n == 0)
623: return 0;
624: if ((bp = bread (dev, l, BUF_SYNC)) == NULL)
625: return 0;
626: if ((m = n) > NBN)
627: m = NBN;
628: for (i = 0 ; i < m ; i ++) {
629: l = ((daddr_t *) bp) [i];
630: candaddr (l);
631: if (b == l) {
632: brelease (bp);
633: return 1;
634: }
635: }
636: brelease (bp);
637: return 0;
638: }
639:
640: /*
641: * Canonize `n' disk addresses.
642: */
643: canndaddr(dp, n)
644: register daddr_t *dp;
645: register int n;
646: {
647: while (n --) {
648: candaddr (* dp);
649: dp ++;
650: }
651: }
652:
653: /*
654: * Convert long to comp_t style number.
655: * A comp_t contains 3 bits of base-8 exponent
656: * and a 13-bit mantissa. Only unsigned
657: * numbers can be comp_t numbers.
658: */
659:
660: #define MAXMANT 017777 /* 2^13-1 = largest mantissa */
661:
662: static comp_t
663: ltoc(l)
664: long l;
665: {
666: register int exp;
667:
668: if (l < 0)
669: return 0;
670: for (exp = 0 ; l > MAXMANT ; exp ++)
671: l >>= 3;
672: return (exp << 13) | l;
673: }
674:
675: /*
676: * Write out an accounting record.
677: */
678: setacct()
679: {
680: register PROC *pp;
681: struct acct acct;
682: IO acctio;
683:
684: if (acctip == NULL)
685: return;
686: pp = SELF;
687: kkcopy(u.u_comm, acct.ac_comm, 10);
688: acct.ac_utime = ltoc(pp->p_utime);
689: acct.ac_stime = ltoc(pp->p_stime);
690: acct.ac_etime = ltoc(timer.t_time - u.u_btime);
691: acct.ac_btime = u.u_btime;
692: acct.ac_uid = u.u_uid;
693: acct.ac_gid = u.u_gid;
694: acct.ac_mem = 0;
695: acct.ac_io = ltoc(u.u_block);
696: acct.ac_tty = pp->p_ttdev;
697: acct.ac_flag = u.u_flag;
698: ilock(acctip);
699: acctio.io_seek = acctip->i_size;
700: acctio.io_ioc = sizeof (acct);
701: acctio.io.vbase = &acct;
702: acctio.io_seg = IOSYS;
703: acctio.io_flag = 0;
704: iwrite(acctip, &acctio);
705: iunlock(acctip);
706: u.u_error = 0;
707: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.