![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fs.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 fs.c CVS log | Up to [Research Unix] / researchv10no / sys / fs |
1.1 root 1: /*
2: * traditional disk filesystem
3: */
4: #include "sys/param.h"
5: #include "sys/systm.h"
6: #include "sys/ino.h"
7: #include "sys/buf.h"
8: #include "sys/filsys.h"
9: #include "sys/mount.h"
10: #include "sys/dir.h"
11: #include "sys/user.h"
12: #include "sys/inode.h"
13: #include "sys/file.h"
14: #include "sys/conf.h"
15: #include "sys/vlimit.h"
16: #include "sys/stat.h"
17: #include "sys/filio.h"
18: #include "sys/cmap.h"
19: #include "sys/stream.h"
20:
21: int fsput(), fsupdat(), fsread(), fswrite(), fstrunc(), fsstat();
22: int fsnami(), fsmount(), fsioctl(), fsdirread();
23: struct inode *fsopen();
24: struct fstypsw fsfs =
25: fsinit(fsput, fsupdat, fsread, fswrite, fstrunc, fsstat,
26: fsnami, fsmount, fsioctl, fsopen, fsdirread);
27:
28: extern struct mount fsmtab[];
29: extern int fscnt;
30:
31: /*
32: * silly mount/unmount routine for fs type 0
33: */
34:
35: fsmount(sip, ip, flag, mnt, fstyp)
36: register struct inode *ip, *sip;
37: int flag, mnt, fstyp;
38: {
39:
40: if (!suser())
41: return;
42: if (mnt)
43: fson(sip, ip, flag, fstyp);
44: else
45: fsoff(ip, fstyp);
46: }
47:
48: /*
49: * mount a type 0 filesystem (sip on ip)
50: * maintain the mount table for vm code's sake
51: *
52: * magic to help booting:
53: * if rootdir == NULL, we are being called from iinit, so
54: * - allow s_valid == 0 on bitmapped filesystems so root may be mounted
55: * - call clkinit to set the clock from the super-block time
56: */
57:
58: fson(sip, ip, ronly, fstyp)
59: register struct inode *ip, *sip;
60: int ronly, fstyp;
61: {
62: dev_t dev;
63: register struct mount *mp;
64: struct mount *emp;
65: struct inode *rip;
66: register struct filsys *fp;
67: struct buf *bp;
68: struct inode pi; /* primer */
69:
70: if ((sip->i_mode&IFMT) != IFBLK) {
71: u.u_error = EINVAL;
72: return;
73: }
74: if (ip->i_fstyp == fstyp && ip->i_dev == sip->i_un.i_rdev) {
75: u.u_error = EBUSY;
76: return;
77: }
78: emp = NULL;
79: for (mp = &fsmtab[fscnt-1]; mp >= fsmtab; mp--) {
80: if (mp->m_dev == NULL)
81: emp = mp;
82: else if (mp->m_dev == sip)
83: goto hopeless;
84: }
85: if (emp == NULL)
86: goto hopeless;
87: emp->m_dev = sip;
88: dev = (dev_t)sip->i_un.i_rdev;
89: bp = bread(dev, SUPERB);
90: if(u.u_error) {
91: emp->m_dev = NULL;
92: brelse(bp);
93: return;
94: }
95: bp->b_flags |= B_LOCKED;
96: brelse(bp);
97: fp = bp->b_un.b_filsys;
98: fp->s_ilock = 0;
99: fp->s_flock = 0;
100: fp->s_ronly = ronly & 1;
101: fp->s_nbehind = 0;
102: fp->s_lasti = 1;
103: if(fp->s_cylsize == 0)
104: fp->s_cylsize = 40; /* transition hack */
105: if(fp->s_aspace == 0)
106: fp->s_aspace = 4; /* likewise */
107: if(BITFS(dev) && !fp->s_valid && !fp->s_ronly && rootdir != NULL)
108: goto failed; /* NOT IMPLEMENTED */
109: if(BITFS(dev) && fp->U.N.S_flag) {
110: if(fsbiton(dev, fp))
111: goto failed;
112: /* hack until pjw fixes chuck */
113: } else if (BITFS(dev) && fp->s_isize + BITMAP*BITCELL < fp->s_fsize)
114: if(fsbiton(dev, fp))
115: goto failed;
116: pi.i_dev = dev;
117: pi.i_fstyp = fstyp;
118: pi.i_un.i_bufp = bp;
119: if ((rip = iget(&pi, dev, ROOTINO)) == NULL)
120: goto failed;
121: if (rip->i_count == 1 && fsiread(&pi, rip) < 0)
122: goto failed;
123: if (rip->i_count != 1) { /* already mounted */
124: iput(rip);
125: goto failed;
126: }
127: emp->m_mroot = rip;
128: ip->i_mroot = rip;
129: rip->i_mpoint = ip;
130: ip->i_count++;
131: sip->i_count++;
132: prele(rip);
133: if (rootdir == NULL)
134: clkinit(fp->s_time);
135: return;
136: failed:
137: bp->b_flags &= ~B_LOCKED;
138: emp->m_dev = NULL;
139: hopeless:
140: if (u.u_error == 0)
141: u.u_error = EBUSY;
142: }
143:
144: fsoff(mip, fstyp)
145: register struct inode *mip;
146: {
147: dev_t dev;
148: register struct mount *mp;
149: register struct inode *rip;
150: struct buf *bp;
151: struct filsys *fp;
152:
153: rip = mip->i_mroot;
154: for (mp = &fsmtab[fscnt-1]; mp >= fsmtab; mp--)
155: if (mp->m_mroot == rip)
156: break;
157: if (mp < fsmtab)
158: panic("umount mp");
159: plock(rip);
160: xumount(rip);
161: update(); /* silly */
162: if (rip->i_count > 1 || ifsbusy(rip)) {
163: u.u_error = EBUSY;
164: prele(rip);
165: return;
166: }
167: plock(mip);
168: mip->i_mroot = NULL;
169: iput(mip);
170: dev = rip->i_dev;
171: if ((bp = getblk(dev, SUPERB)) != rip->i_un.i_bufp)
172: panic("umount");
173: iput(rip);
174: bp->b_flags &= ~(B_LOCKED|B_ASYNC); /* ~async needed? */
175: if (bp->b_un.b_filsys->s_ronly)
176: brelse(bp);
177: else {
178: if (BITFS(dev)) {
179: fp = bp->b_un.b_filsys;
180: fp->s_valid = 1;
181: if(fp->U.N.S_flag)
182: fsbitoff(dev, fp, 1);
183: }
184: bwrite(bp);
185: }
186: mpurge(mp - fsmtab);
187: idec(mp->m_dev);
188: mp->m_dev = NULL;
189: }
190:
191: fsbiton(dev, fp)
192: dev_t dev;
193: register struct filsys *fp;
194: {
195: register int i, nf;
196: register struct buf **bpp;
197: register struct buf *bp;
198:
199: /* two chuck should do */
200: fp->U.N.S_flag = 1; /* bit map not in superblock */
201: nf = fp->U.N.S_bsize = BSIZE(dev) * NBBY;
202: if (fp->s_ronly)
203: return (0);
204: nf = (fp->s_fsize + nf - 1) / nf;
205: bpp = fp->U.N.S_blk;
206: for(i = 0; i < nf; i++)
207: bpp[i] = 0;
208: for(i = 0; i < nf; i++) {
209: bp = bread(dev, fp->s_fsize-nf+i);
210: if(u.u_error) {
211: brelse(bp);
212: goto failed;
213: }
214: bp->b_flags |= B_LOCKED;
215: brelse(bp);
216: bpp[i] = bp;
217: }
218: return(0);
219: failed:
220: fsbitoff(dev, fp, 0);
221: return(1);
222: }
223:
224: fsbitoff(dev, fp, wrtflg)
225: dev_t dev;
226: struct filsys *fp;
227: {
228: register struct buf **bpp;
229: register struct buf *bp;
230: register int i, nf;
231:
232: if (fp->s_ronly)
233: return;
234: nf = fp->U.N.S_bsize;
235: nf = (fp->s_fsize + nf-1)/nf;
236: bpp = fp->U.N.S_blk;
237: for(i = 0; i < nf; i++)
238: if(bpp[i]) {
239: if ((bp = getblk(dev, fp->s_fsize - nf + i)) != bpp[i])
240: panic("fsbitoff");
241: bp->b_flags &= ~B_LOCKED;
242: if(wrtflg)
243: bwrite(bp);
244: bpp[i] = 0; /* safety first */
245: }
246: }
247:
248: /*
249: * fill in inode ip from the disk copy
250: * in filesystem fip
251: * ip is an inode fresh from iget
252: */
253: fsiread(fip, ip)
254: register struct inode *fip, *ip;
255: {
256: register struct buf *bp;
257: daddr_t bno;
258:
259: if (ip->i_number <= 0) {
260: u.u_error = EINVAL;
261: iput(ip);
262: return (-1);
263: }
264: bno = itod(fip->i_dev, (ino_t)ip->i_number);
265: if (bno >= getfs(fip)->s_isize) {
266: u.u_error = EINVAL;
267: iput(ip);
268: return (-1);
269: }
270: bp = bread(fip->i_dev, bno);
271: if((bp->b_flags&B_ERROR) != 0) {
272: brelse(bp);
273: iput(ip);
274: return(-1);
275: }
276: iexpand(ip, bp->b_un.b_dino+itoo(fip->i_dev, (ino_t)ip->i_number));
277: brelse(bp);
278: ip->i_un.i_bufp = fip->i_un.i_bufp;
279: ip->i_un.i_lastr = 0;
280: return (0);
281: }
282:
283: iexpand(ip, dp)
284: register struct inode *ip;
285: register struct dinode *dp;
286: {
287: register char *p1, *p2;
288: register int i;
289:
290: ip->i_mode = dp->di_mode;
291: ip->i_nlink = dp->di_nlink;
292: ip->i_uid = dp->di_uid;
293: ip->i_gid = dp->di_gid;
294: ip->i_size = dp->di_size;
295: p1 = (char *)ip->i_un.i_addr;
296: p2 = (char *)dp->di_addr;
297: for(i=0; i<NADDR; i++) {
298: *p1++ = *p2++;
299: *p1++ = *p2++;
300: *p1++ = *p2++;
301: *p1++ = 0;
302: }
303: }
304:
305: fsput(ip)
306: struct inode *ip;
307: {
308: if (ip->i_nlink == 0) {
309: fstrunc(ip);
310: ifree(ip);
311: ip->i_mode = 0;
312: ip->i_flag |= IUPD|ICHG;
313: }
314: if ((ip->i_flag&(IUPD|IACC|ICHG)) != 0)
315: fsiupdat(ip, &time, &time, 0);
316: }
317:
318: fsupdat(ip, ta, tm, waitfor)
319: register struct inode *ip;
320: time_t *ta, *tm;
321: {
322: fsiupdat(ip, ta, tm, waitfor);
323: if (ip->i_un.i_bufp->b_un.b_filsys->s_fmod)
324: fsfupdat(ip);
325: }
326:
327: /*
328: * update the inode on disk
329: * if the super-block is dirty, write it too
330: */
331:
332: fsiupdat(ip, ta, tm, waitfor)
333: register struct inode *ip;
334: time_t *ta, *tm;
335: {
336: register struct buf *bp;
337: struct dinode *dp;
338: register char *p1, *p2;
339: register int i;
340:
341: if (ip->i_un.i_bufp->b_un.b_filsys->s_ronly)
342: return;
343: bp = bread(ip->i_dev, itod(ip->i_dev, ip->i_number));
344: if (bp->b_flags & B_ERROR) {
345: brelse(bp);
346: return;
347: }
348: dp = bp->b_un.b_dino;
349: dp += itoo(ip->i_dev, ip->i_number);
350: dp->di_mode = ip->i_mode;
351: dp->di_nlink = ip->i_nlink;
352: dp->di_uid = ip->i_uid;
353: dp->di_gid = ip->i_gid;
354: dp->di_size = ip->i_size;
355: p1 = (char *)dp->di_addr;
356: p2 = (char *)ip->i_un.i_addr;
357: for(i=0; i<NADDR; i++) {
358: *p1++ = *p2++;
359: *p1++ = *p2++;
360: *p1++ = *p2++;
361: if(*p2++)
362: printf("ino %d dev #%x addr #%x\n", ip->i_number, ip->i_dev, ip->i_un.i_addr[i]);
363: }
364: if(ip->i_flag&IACC)
365: dp->di_atime = *ta;
366: if(ip->i_flag&IUPD)
367: dp->di_mtime = *tm;
368: if(ip->i_flag&ICHG)
369: dp->di_ctime = time;
370: ip->i_flag &= ~(IUPD|IACC|ICHG);
371: if (waitfor)
372: bwrite(bp);
373: else
374: bdwrite(bp);
375: }
376:
377: /*
378: * write the super-block
379: */
380:
381: fsfupdat(ip)
382: struct inode *ip;
383: {
384: register struct filsys *fp;
385: struct buf *bp;
386:
387: fp = ip->i_un.i_bufp->b_un.b_filsys;
388: if (fp->s_fmod == 0 || fp->s_ilock || fp->s_flock || fp->s_ronly)
389: return;
390: bp = getblk(ip->i_dev, SUPERB);
391: if (bp->b_un.b_filsys != fp)
392: panic("fsfupdat");
393: fp->s_fmod = 0;
394: fp->s_time = time;
395: bwrite(bp);
396: }
397:
398: fsstat(ip, ub)
399: register struct inode *ip;
400: struct stat *ub;
401: {
402: register struct dinode *dp;
403: register struct buf *bp;
404: struct stat ds;
405:
406: /*
407: * first copy from inode table
408: */
409: ds.st_dev = ip->i_dev;
410: ds.st_ino = ip->i_number;
411: ds.st_mode = ip->i_mode;
412: ds.st_nlink = ip->i_nlink;
413: ds.st_uid = ip->i_uid;
414: ds.st_gid = ip->i_gid;
415: ds.st_rdev = (dev_t)ip->i_un.i_rdev;
416: ds.st_size = ip->i_size;
417: /*
418: * next the dates in the disk
419: */
420: bp = bread(ip->i_dev, itod(ip->i_dev, ip->i_number));
421: dp = bp->b_un.b_dino;
422: dp += itoo(ip->i_dev, ip->i_number);
423: ds.st_atime = dp->di_atime;
424: ds.st_mtime = dp->di_mtime;
425: ds.st_ctime = dp->di_ctime;
426: brelse(bp);
427: if (copyout((caddr_t)&ds, (caddr_t)ub, sizeof(ds)) < 0)
428: u.u_error = EFAULT;
429: }
430:
431: fstrunc(ip)
432: register struct inode *ip;
433: {
434: register i;
435: daddr_t bn;
436: struct inode itmp;
437:
438: i = ip->i_mode & IFMT;
439: if (i!=IFREG && i!=IFDIR && i!=IFLNK)
440: return;
441: /*
442: * Clean inode on disk before freeing blocks
443: * to insure no duplicates if system crashes.
444: */
445: itmp = *ip;
446: itmp.i_size = 0;
447: for (i = 0; i < NADDR; i++)
448: itmp.i_un.i_addr[i] = 0;
449: itmp.i_flag |= ICHG|IUPD;
450: fsiupdat(&itmp, &time, &time, 1);
451: ip->i_flag &= ~(IUPD|IACC|ICHG);
452:
453: /*
454: * Now return blocks to free list... if machine
455: * crashes, they will be harmless MISSING blocks.
456: */
457: for(i=NADDR-1; i>=0; i--) {
458: bn = ip->i_un.i_addr[i];
459: if(bn == (daddr_t)0)
460: continue;
461: ip->i_un.i_addr[i] = (daddr_t)0;
462: switch(i) {
463:
464: default:
465: free(ip, bn);
466: break;
467:
468: case NADDR-3:
469: tloop(ip, bn, 0, 0);
470: break;
471:
472: case NADDR-2:
473: tloop(ip, bn, 1, 0);
474: break;
475:
476: case NADDR-1:
477: tloop(ip, bn, 1, 1);
478: }
479: }
480: ip->i_size = 0;
481: /*
482: * Inode was written and flags updated above.
483: * No need to modify flags here.
484: */
485: }
486:
487: tloop(fip, bn, f1, f2)
488: register struct inode *fip;
489: daddr_t bn;
490: {
491: register i;
492: register struct buf *bp;
493: register daddr_t *bap;
494: daddr_t nb;
495:
496: bp = NULL;
497: for(i=NINDIR(fip->i_dev)-1; i>=0; i--) {
498: if(bp == NULL) {
499: bp = bread(fip->i_dev, bn);
500: if (bp->b_flags & B_ERROR) {
501: brelse(bp);
502: return;
503: }
504: bap = bp->b_un.b_daddr;
505: }
506: nb = bap[i];
507: if(nb == (daddr_t)0)
508: continue;
509: if(f1) {
510: brelse(bp);
511: bp = NULL;
512: tloop(fip, nb, f2, 0);
513: } else
514: free(fip, nb);
515: }
516: if(bp != NULL)
517: brelse(bp);
518: free(fip, bn);
519: }
520:
521: fsioctl(ip, cmd, cmarg, flag)
522: register struct inode *ip;
523: caddr_t cmarg;
524: {
525: int fmt;
526: register dev_t dev;
527:
528: fmt = ip->i_mode & IFMT;
529: if (fmt != IFCHR) {
530: if (cmd==FIONREAD && (fmt == IFREG || fmt == IFDIR)) {
531: off_t nread = ip->i_size; /* - fp->f_offset */
532: if (copyout((caddr_t)&nread, cmarg, sizeof(off_t)))
533: u.u_error = EFAULT;
534: } else
535: u.u_error = ENOTTY;
536: return;
537: }
538: dev = ip->i_un.i_rdev;
539: u.u_r.r_val1 = 0;
540: (*cdevsw[major(dev)]->d_ioctl)(dev, cmd, cmarg, flag);
541: }
542:
543: struct inode *
544: fsopen(ip, rw)
545: register struct inode *ip;
546: {
547: dev_t dev;
548: register unsigned int maj;
549:
550: dev = (dev_t)ip->i_un.i_rdev;
551: maj = major(dev);
552:
553: switch(ip->i_mode&IFMT) {
554: case IFCHR:
555: if(maj >= nchrdev || cdevsw[maj] == NULL)
556: goto bad;
557: if (cdevsw[maj]->qinfo) /* stream device */
558: return(stopen(cdevsw[major(dev)]->qinfo, dev, rw, ip));
559: (*cdevsw[maj]->d_open)(dev, rw);
560: break;
561:
562: case IFBLK:
563: if(maj >= nblkdev || bdevsw[maj] == NULL)
564: goto bad;
565: (*bdevsw[maj]->d_open)(dev, rw);
566: }
567: if (u.u_error) {
568: iput(ip);
569: return (NULL);
570: }
571: return (ip);
572:
573: bad:
574: u.u_error = ENXIO;
575: iput(ip);
576: return(NULL);
577: }
578:
579: fsread(ip)
580: register struct inode *ip;
581: {
582: struct buf *bp;
583: dev_t dev;
584: daddr_t lbn, bn;
585: off_t diff;
586: register int on, type;
587: register unsigned n;
588:
589: dev = (dev_t)ip->i_un.i_rdev;
590: type = ip->i_mode&IFMT;
591: if (type==IFCHR) {
592: (*cdevsw[major(dev)]->d_read)(dev);
593: return;
594: }
595: if (Lsign(u.u_offset) < 0) { /* and not IFCHR */
596: u.u_error = EINVAL;
597: return;
598: }
599: if (type != IFBLK) { /* if offset >= size, avoid overflow */
600: if (Lsign(Lladd(u.u_offset, -ip->i_size))>=0)
601: return;
602: dev = ip->i_dev;
603: }
604: do {
605: lbn = bn = Lshift(u.u_offset, BSHIFT(dev));
606: on = Ltol(u.u_offset) & BMASK(dev);
607: n = MIN((unsigned)(BSIZE(dev)-on), u.u_count);
608: if (type!=IFBLK) {
609: diff = ip->i_size - Ltol(u.u_offset);
610: if (diff <= 0)
611: return;
612: if (diff < n)
613: n = diff;
614: bn = bmap(ip, bn, B_READ);
615: if (u.u_error)
616: return;
617: } else
618: rablock = bn+1;
619: if ((long)bn<0) {
620: bp = geteblk();
621: clrbuf(bp);
622: } else if (ip->i_un.i_lastr+1==lbn)
623: bp = breada(dev, bn, rablock);
624: else
625: bp = bread(dev, bn);
626: ip->i_un.i_lastr = lbn;
627: n = MIN(n, BSIZE(dev)-bp->b_resid);
628: if (n!=0)
629: iomove(bp->b_un.b_addr+on, n, B_READ);
630: brelse(bp);
631: } while(u.u_error==0 && u.u_count!=0 && n!=0);
632: }
633:
634: fsdirread(ip, len)
635: struct inode *ip;
636: { struct buf *bp = 0, *outb;
637: dev_t dev;
638: daddr_t bn, lbn;
639: int on, type, j, m, new = 0;
640: char *p, *lp, *lastp;
641: struct direct *dp;
642: char ncvt[24];
643:
644: if(Lsign(u.u_offset) < 0) {
645: u.u_error = EINVAL;
646: return;
647: }
648: type = ip->i_mode & IFMT;
649: if(type != IFDIR) {
650: u.u_error = ENOTDIR;
651: return;
652: }
653: dev = ip->i_dev;
654: outb = geteblk(); /* to hold the stuff for the user */
655: if(len > BSIZE(dev))
656: len = BSIZE(dev);
657: p = lp = outb->b_un.b_addr;
658: lastp = p + len;
659: loop:
660: if(new <= 0) { /* get some goo */
661: lbn = bn = Lshift(u.u_offset, BSHIFT(dev));
662: on = Ltol(u.u_offset) & BMASK(dev);
663: if(ip->i_size <= Ltol(u.u_offset))
664: goto done;
665: bn = bmap(ip, bn, B_READ);
666: if(u.u_error)
667: return;
668: if((long)bn < 0) { /* holes in dirs? */
669: u.u_offset = Lladd(u.u_offset, BSIZE(dev)-on);
670: goto loop; /* try the next block */
671: }
672: if(bp)
673: brelse(bp);
674: if(ip->i_un.i_lastr + 1 == lbn)
675: bp = breada(dev, bn, rablock);
676: else
677: bp = bread(dev, bn);
678: ip->i_un.i_lastr = lbn;
679: new = BSIZE(dev) - on;
680: if(new > BSIZE(dev) - bp->b_resid) /* io error? */
681: new = BSIZE(dev) - bp->b_resid; /* or paranoia */
682: if(new > ip->i_size - Ltol(u.u_offset))
683: new = ip->i_size - Ltol(u.u_offset);
684: dp = (struct direct *) (bp->b_un.b_addr + on);
685: }
686: if(dp->d_ino == 0)
687: goto incr;
688: for(m = dp->d_ino, j = sizeof(ncvt)-1; m; j--) {
689: ncvt[j] = m%10 + '0';
690: m /= 10;
691: }
692: for(++j; j < sizeof(ncvt) && p < lastp; )
693: *p++ = ncvt[j++];
694: if(j != sizeof(ncvt) || p >= lastp)
695: goto early;
696: *p++ = '\t';
697: for(j = 0; j < DIRSIZ && dp->d_name[j] && p < lastp; j++)
698: *p++ = dp->d_name[j];
699: if(p >= lastp)
700: goto early;
701: *p++ = 0;
702: incr:
703: lp = p;
704: new -= sizeof(*dp);
705: u.u_offset = Lladd(u.u_offset, sizeof(*dp));
706: dp++;
707: if(p < lastp)
708: goto loop;
709: done:
710: j = lp - outb->b_un.b_addr;
711: if(j > 0)
712: if(copyout((caddr_t)outb->b_un.b_addr, u.u_base, j))
713: u.u_error = EFAULT;
714: if(bp)
715: brelse(bp);
716: brelse(outb);
717: u.u_r.r_val1 = j;
718: return;
719: early:
720: *lp = 0;
721: if(lp > outb->b_un.b_addr)
722: goto done;
723: u.u_error = ENOSPC;
724: if(bp)
725: brelse(bp);
726: brelse(outb);
727: }
728:
729: fswrite(ip)
730: register struct inode *ip;
731: {
732: struct buf *bp;
733: dev_t dev;
734: daddr_t bn;
735: register int on, type;
736: register unsigned n;
737: register int i;
738:
739: dev = (dev_t)ip->i_un.i_rdev;
740: type = ip->i_mode&IFMT;
741: if (type==IFCHR) {
742: ip->i_flag |= IUPD|ICHG;
743: (*cdevsw[major(dev)]->d_write)(dev);
744: return;
745: }
746: if (Lsign(u.u_offset) < 0) { /* and not IFCHR */
747: u.u_error = EINVAL;
748: return;
749: }
750: if (u.u_count == 0)
751: return;
752: if ((ip->i_mode&IFMT)==IFREG &&
753: (Lsign(Luadd(u.u_offset, u.u_count))!=0 ||
754: Ltol(u.u_offset) + u.u_count > u.u_limit[LIM_FSIZE])) {
755: u.u_error = EMFILE;
756: return;
757: }
758: if (type != IFBLK)
759: dev = ip->i_dev;
760: do {
761: bn = Lshift(u.u_offset, BSHIFT(dev));
762: on = Ltol(u.u_offset) & BMASK(dev);
763: n = MIN((unsigned)(BSIZE(dev)-on), u.u_count);
764: if (type!=IFBLK) {
765: bn = bmap(ip, bn, B_WRITE);
766: if((long)bn<0)
767: return;
768: }
769: i = getfsx(dev);
770: if (bn && mfind(i, bn))
771: munhash(i, bn);
772: if(n == BSIZE(dev))
773: bp = getblk(dev, bn);
774: else
775: bp = bread(dev, bn);
776: iomove(bp->b_un.b_addr+on, n, B_WRITE);
777: if(u.u_error != 0)
778: brelse(bp);
779: else {
780: if ((ip->i_mode&IFMT) == IFDIR &&
781: ((struct direct *)(bp->b_un.b_addr+on))->d_ino == 0)
782: bwrite(bp); /* consistency */
783: else if ((n+on) == BSIZE(dev))
784: bawrite(bp);
785: else
786: bdwrite(bp);
787: }
788: if(Ltol(u.u_offset) > ip->i_size &&
789: (type==IFDIR || type==IFREG || type==IFLNK))
790: ip->i_size = Ltol(u.u_offset);
791: ip->i_flag |= IUPD|ICHG;
792: } while(u.u_error==0 && u.u_count!=0);
793: }
794:
795: /*
796: * Getfsx returns the index in the file system
797: * table of the specified device. The swap device
798: * is also assigned a pseudo-index. The index may
799: * be used as a compressed indication of the location
800: * of a block, recording
801: * <getfsx(dev),blkno>
802: * rather than
803: * <dev, blkno>
804: * provided the information need remain valid only
805: * as long as the file system is mounted.
806: *
807: * only the vm code calls this.
808: */
809: getfsx(dev)
810: dev_t dev;
811: {
812: register struct mount *mp;
813:
814: if (dev == swapdev)
815: return (MSWAPX);
816: for (mp = &fsmtab[fscnt-1]; mp >= fsmtab; mp--) {
817: if (mp->m_dev == NULL)
818: continue;
819: if (mp->m_dev->i_un.i_rdev == dev)
820: return (mp - fsmtab);
821: }
822: return (-1);
823: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.