![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sys_inode.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / enet / sys|
Return to sys_inode.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / enet / sys |
1.1 root 1: /*
2: * Copyright (c) 1982 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: *
6: * @(#)sys_inode.c 6.13 (Berkeley) 8/4/85
7: */
8:
9: #include "param.h"
10: #include "systm.h"
11: #include "dir.h"
12: #include "user.h"
13: #include "inode.h"
14: #include "proc.h"
15: #include "fs.h"
16: #include "conf.h"
17: #include "buf.h"
18: #include "mount.h"
19: #include "file.h"
20: #include "uio.h"
21: #include "ioctl.h"
22: #include "tty.h"
23: #include "cmap.h"
24: #include "stat.h"
25: #include "kernel.h"
26: #include "quota.h"
27:
28: int ino_rw(), ino_ioctl(), ino_select(), ino_close();
29: struct fileops inodeops =
30: { ino_rw, ino_ioctl, ino_select, ino_close };
31:
32: ino_rw(fp, rw, uio)
33: struct file *fp;
34: enum uio_rw rw;
35: struct uio *uio;
36: {
37: register struct inode *ip = (struct inode *)fp->f_data;
38: int error;
39:
40: if ((ip->i_mode&IFMT) == IFREG) {
41: ILOCK(ip);
42: if (fp->f_flag&FAPPEND && rw == UIO_WRITE)
43: uio->uio_offset = fp->f_offset = ip->i_size;
44: error = rwip(ip, uio, rw);
45: IUNLOCK(ip);
46: } else
47: error = rwip(ip, uio, rw);
48: return (error);
49: }
50:
51: rdwri(rw, ip, base, len, offset, segflg, aresid)
52: struct inode *ip;
53: caddr_t base;
54: int len, offset, segflg;
55: int *aresid;
56: enum uio_rw rw;
57: {
58: struct uio auio;
59: struct iovec aiov;
60: int error;
61:
62: auio.uio_iov = &aiov;
63: auio.uio_iovcnt = 1;
64: aiov.iov_base = base;
65: aiov.iov_len = len;
66: auio.uio_resid = len;
67: auio.uio_offset = offset;
68: auio.uio_segflg = segflg;
69: error = rwip(ip, &auio, rw);
70: if (aresid)
71: *aresid = auio.uio_resid;
72: else
73: if (auio.uio_resid)
74: error = EIO;
75: return (error);
76: }
77:
78: rwip(ip, uio, rw)
79: register struct inode *ip;
80: register struct uio *uio;
81: enum uio_rw rw;
82: {
83: dev_t dev = (dev_t)ip->i_rdev;
84: struct buf *bp;
85: struct fs *fs;
86: daddr_t lbn, bn;
87: register int n, on, type;
88: int size;
89: long bsize;
90: extern int mem_no;
91: int error = 0;
92:
93: if (rw != UIO_READ && rw != UIO_WRITE)
94: panic("rwip");
95: if (rw == UIO_READ && uio->uio_resid == 0)
96: return (0);
97: if (uio->uio_offset < 0 &&
98: ((ip->i_mode&IFMT) != IFCHR || mem_no != major(dev)))
99: return (EINVAL);
100: if (rw == UIO_READ)
101: ip->i_flag |= IACC;
102: type = ip->i_mode&IFMT;
103: if (type == IFCHR) {
104: if (rw == UIO_READ)
105: error = (*cdevsw[major(dev)].d_read)(dev, uio);
106: else {
107: ip->i_flag |= IUPD|ICHG;
108: error = (*cdevsw[major(dev)].d_write)(dev, uio);
109: }
110: return (error);
111: }
112: if (uio->uio_resid == 0)
113: return (0);
114: if (rw == UIO_WRITE && type == IFREG &&
115: uio->uio_offset + uio->uio_resid >
116: u.u_rlimit[RLIMIT_FSIZE].rlim_cur) {
117: psignal(u.u_procp, SIGXFSZ);
118: return (EFBIG);
119: }
120: if (type != IFBLK) {
121: dev = ip->i_dev;
122: fs = ip->i_fs;
123: bsize = fs->fs_bsize;
124: } else
125: bsize = BLKDEV_IOSIZE;
126: do {
127: lbn = uio->uio_offset / bsize;
128: on = uio->uio_offset % bsize;
129: n = MIN((unsigned)(bsize - on), uio->uio_resid);
130: if (type != IFBLK) {
131: if (rw == UIO_READ) {
132: int diff = ip->i_size - uio->uio_offset;
133: if (diff <= 0)
134: return (0);
135: if (diff < n)
136: n = diff;
137: }
138: bn = fsbtodb(fs,
139: bmap(ip, lbn, rw == UIO_WRITE ? B_WRITE: B_READ, (int)(on+n)));
140: if (u.u_error || rw == UIO_WRITE && (long)bn<0)
141: return (u.u_error);
142: if (rw == UIO_WRITE && uio->uio_offset + n > ip->i_size &&
143: (type == IFDIR || type == IFREG || type == IFLNK))
144: ip->i_size = uio->uio_offset + n;
145: size = blksize(fs, ip, lbn);
146: } else {
147: bn = lbn * (BLKDEV_IOSIZE/DEV_BSIZE);
148: rablock = bn + (BLKDEV_IOSIZE/DEV_BSIZE);
149: rasize = size = bsize;
150: }
151: if (rw == UIO_READ) {
152: if ((long)bn<0) {
153: bp = geteblk(size);
154: clrbuf(bp);
155: } else if (ip->i_lastr + 1 == lbn)
156: bp = breada(dev, bn, size, rablock, rasize);
157: else
158: bp = bread(dev, bn, size);
159: ip->i_lastr = lbn;
160: } else {
161: int i, count, s;
162: extern struct cmap *mfind();
163:
164: count = howmany(size, DEV_BSIZE);
165: s = splimp();
166: for (i = 0; i < count; i += CLBYTES / DEV_BSIZE)
167: if (mfind(dev, bn + i))
168: munhash(dev, bn + i);
169: splx(s);
170: if (n == bsize)
171: bp = getblk(dev, bn, size);
172: else
173: bp = bread(dev, bn, size);
174: }
175: n = MIN(n, size - bp->b_resid);
176: if (bp->b_flags & B_ERROR) {
177: error = EIO;
178: brelse(bp);
179: goto bad;
180: }
181: u.u_error =
182: uiomove(bp->b_un.b_addr+on, n, rw, uio);
183: if (rw == UIO_READ) {
184: if (n + on == bsize || uio->uio_offset == ip->i_size)
185: bp->b_flags |= B_AGE;
186: brelse(bp);
187: } else {
188: if ((ip->i_mode&IFMT) == IFDIR)
189: bwrite(bp);
190: else if (n + on == bsize) {
191: bp->b_flags |= B_AGE;
192: bawrite(bp);
193: } else
194: bdwrite(bp);
195: ip->i_flag |= IUPD|ICHG;
196: if (u.u_ruid != 0)
197: ip->i_mode &= ~(ISUID|ISGID);
198: }
199: } while (u.u_error == 0 && uio->uio_resid > 0 && n != 0);
200: if (error == 0) /* XXX */
201: error = u.u_error; /* XXX */
202: bad:
203: return (error);
204: }
205:
206: ino_ioctl(fp, com, data)
207: struct file *fp;
208: register int com;
209: caddr_t data;
210: {
211: register struct inode *ip = ((struct inode *)fp->f_data);
212: register int fmt = ip->i_mode & IFMT;
213: dev_t dev;
214:
215: switch (fmt) {
216:
217: case IFREG:
218: case IFDIR:
219: if (com == FIONREAD) {
220: *(off_t *)data = ip->i_size - fp->f_offset;
221: return (0);
222: }
223: if (com == FIONBIO || com == FIOASYNC) /* XXX */
224: return (0); /* XXX */
225: /* fall into ... */
226:
227: default:
228: return (ENOTTY);
229:
230: case IFCHR:
231: dev = ip->i_rdev;
232: u.u_r.r_val1 = 0;
233: if (setjmp(&u.u_qsave)) {
234: if ((u.u_sigintr & sigmask(u.u_procp->p_cursig)) != 0)
235: return(EINTR);
236: u.u_eosys = RESTARTSYS;
237: return (0);
238: }
239: return ((*cdevsw[major(dev)].d_ioctl)(dev, com, data,
240: fp->f_flag));
241: }
242: }
243:
244: ino_select(fp, which)
245: struct file *fp;
246: int which;
247: {
248: register struct inode *ip = (struct inode *)fp->f_data;
249: register dev_t dev;
250:
251: switch (ip->i_mode & IFMT) {
252:
253: default:
254: return (1); /* XXX */
255:
256: case IFCHR:
257: dev = ip->i_rdev;
258: return (*cdevsw[major(dev)].d_select)(dev, which);
259: }
260: }
261:
262: #ifdef notdef
263: ino_clone()
264: {
265:
266: return (EOPNOTSUPP);
267: }
268: #endif
269:
270: ino_stat(ip, sb)
271: register struct inode *ip;
272: register struct stat *sb;
273: {
274:
275: ITIMES(ip, &time, &time);
276: /*
277: * Copy from inode table
278: */
279: sb->st_dev = ip->i_dev;
280: sb->st_ino = ip->i_number;
281: sb->st_mode = ip->i_mode;
282: sb->st_nlink = ip->i_nlink;
283: sb->st_uid = ip->i_uid;
284: sb->st_gid = ip->i_gid;
285: sb->st_rdev = (dev_t)ip->i_rdev;
286: sb->st_size = ip->i_size;
287: sb->st_atime = ip->i_atime;
288: sb->st_spare1 = 0;
289: sb->st_mtime = ip->i_mtime;
290: sb->st_spare2 = 0;
291: sb->st_ctime = ip->i_ctime;
292: sb->st_spare3 = 0;
293: /* this doesn't belong here */
294: if ((ip->i_mode&IFMT) == IFBLK)
295: sb->st_blksize = BLKDEV_IOSIZE;
296: else if ((ip->i_mode&IFMT) == IFCHR)
297: sb->st_blksize = MAXBSIZE;
298: else
299: sb->st_blksize = ip->i_fs->fs_bsize;
300: sb->st_blocks = ip->i_blocks;
301: sb->st_spare4[0] = sb->st_spare4[1] = 0;
302: return (0);
303: }
304:
305: ino_close(fp)
306: register struct file *fp;
307: {
308: register struct inode *ip = (struct inode *)fp->f_data;
309: register struct mount *mp;
310: int flag, mode;
311: dev_t dev;
312: register int (*cfunc)();
313:
314: if (fp->f_flag & (FSHLOCK|FEXLOCK))
315: ino_unlock(fp, FSHLOCK|FEXLOCK);
316: flag = fp->f_flag;
317: dev = (dev_t)ip->i_rdev;
318: mode = ip->i_mode & IFMT;
319: ilock(ip);
320: iput(ip);
321: fp->f_data = (caddr_t) 0; /* XXX */
322: switch (mode) {
323:
324: case IFCHR:
325: cfunc = cdevsw[major(dev)].d_close;
326: break;
327:
328: case IFBLK:
329: /*
330: * We don't want to really close the device if it is mounted
331: */
332: /* MOUNT TABLE SHOULD HOLD INODE */
333: for (mp = mount; mp < &mount[NMOUNT]; mp++)
334: if (mp->m_bufp != NULL && mp->m_dev == dev)
335: return;
336: cfunc = bdevsw[major(dev)].d_close;
337: break;
338:
339: default:
340: return;
341: }
342:
343: /*
344: * Check that another inode for the same device isn't active.
345: * This is because the same device can be referenced by
346: * two different inodes.
347: */
348: for (fp = file; fp < fileNFILE; fp++) {
349: if (fp->f_type != DTYPE_INODE) /* XXX */
350: continue;
351: if (fp->f_count && (ip = (struct inode *)fp->f_data) &&
352: ip->i_rdev == dev && (ip->i_mode&IFMT) == mode)
353: return;
354: }
355: if (mode == IFBLK) {
356: /*
357: * On last close of a block device (that isn't mounted)
358: * we must invalidate any in core blocks, so that
359: * we can, for instance, change floppy disks.
360: */
361: bflush(dev);
362: binval(dev);
363: }
364: if (setjmp(&u.u_qsave)) {
365: /*
366: * If device close routine is interrupted,
367: * must return so closef can clean up.
368: */
369: if (u.u_error == 0)
370: u.u_error = EINTR; /* ??? */
371: return;
372: }
373: (*cfunc)(dev, flag);
374: }
375:
376: /*
377: * Place an advisory lock on an inode.
378: */
379: ino_lock(fp, cmd)
380: register struct file *fp;
381: int cmd;
382: {
383: register int priority = PLOCK;
384: register struct inode *ip = (struct inode *)fp->f_data;
385:
386: if ((cmd & LOCK_EX) == 0)
387: priority += 4;
388: if (setjmp(&u.u_qsave)) {
389: if ((u.u_sigintr & sigmask(u.u_procp->p_cursig)) != 0)
390: return(EINTR);
391: u.u_eosys = RESTARTSYS;
392: return (0);
393: }
394: /*
395: * If there's a exclusive lock currently applied
396: * to the file, then we've gotta wait for the
397: * lock with everyone else.
398: */
399: again:
400: while (ip->i_flag & IEXLOCK) {
401: /*
402: * If we're holding an exclusive
403: * lock, then release it.
404: */
405: if (fp->f_flag & FEXLOCK) {
406: ino_unlock(fp, FEXLOCK);
407: continue;
408: }
409: if (cmd & LOCK_NB)
410: return (EWOULDBLOCK);
411: ip->i_flag |= ILWAIT;
412: sleep((caddr_t)&ip->i_exlockc, priority);
413: }
414: if ((cmd & LOCK_EX) && (ip->i_flag & ISHLOCK)) {
415: /*
416: * Must wait for any shared locks to finish
417: * before we try to apply a exclusive lock.
418: *
419: * If we're holding a shared
420: * lock, then release it.
421: */
422: if (fp->f_flag & FSHLOCK) {
423: ino_unlock(fp, FSHLOCK);
424: goto again;
425: }
426: if (cmd & LOCK_NB)
427: return (EWOULDBLOCK);
428: ip->i_flag |= ILWAIT;
429: sleep((caddr_t)&ip->i_shlockc, PLOCK);
430: goto again;
431: }
432: if (fp->f_flag & FEXLOCK)
433: panic("ino_lock");
434: if (cmd & LOCK_EX) {
435: cmd &= ~LOCK_SH;
436: ip->i_exlockc++;
437: ip->i_flag |= IEXLOCK;
438: fp->f_flag |= FEXLOCK;
439: }
440: if ((cmd & LOCK_SH) && (fp->f_flag & FSHLOCK) == 0) {
441: ip->i_shlockc++;
442: ip->i_flag |= ISHLOCK;
443: fp->f_flag |= FSHLOCK;
444: }
445: return (0);
446: }
447:
448: /*
449: * Unlock a file.
450: */
451: ino_unlock(fp, kind)
452: register struct file *fp;
453: int kind;
454: {
455: register struct inode *ip = (struct inode *)fp->f_data;
456: int flags;
457:
458: kind &= fp->f_flag;
459: if (ip == NULL || kind == 0)
460: return;
461: flags = ip->i_flag;
462: if (kind & FSHLOCK) {
463: if ((flags & ISHLOCK) == 0)
464: panic("ino_unlock: SHLOCK");
465: if (--ip->i_shlockc == 0) {
466: ip->i_flag &= ~ISHLOCK;
467: if (flags & ILWAIT)
468: wakeup((caddr_t)&ip->i_shlockc);
469: }
470: fp->f_flag &= ~FSHLOCK;
471: }
472: if (kind & FEXLOCK) {
473: if ((flags & IEXLOCK) == 0)
474: panic("ino_unlock: EXLOCK");
475: if (--ip->i_exlockc == 0) {
476: ip->i_flag &= ~(IEXLOCK|ILWAIT);
477: if (flags & ILWAIT)
478: wakeup((caddr_t)&ip->i_exlockc);
479: }
480: fp->f_flag &= ~FEXLOCK;
481: }
482: }
483:
484: /*
485: * Openi called to allow handler
486: * of special files to initialize and
487: * validate before actual IO.
488: */
489: openi(ip, mode)
490: register struct inode *ip;
491: {
492: dev_t dev = (dev_t)ip->i_rdev;
493: register int maj = major(dev);
494: int minnum = minor(dev);
495: register int error;
496:
497: switch (ip->i_mode&IFMT) {
498:
499: case IFCHR:
500: if ((u_int)maj >= nchrdev)
501: return (ENXIO);
502: error = (*cdevsw[maj].d_open)(dev, mode, &minnum);
503:
504: /*
505: * Test for new minor device inode allocation
506: */
507: if ((error == 0) && (minnum != minor(dev))) {
508: register struct inode *nip;
509:
510: /*
511: * Allocate new inode with new minor device
512: * Release old inode. Set vpp to point to new one.
513: * This inode will go away when the last reference
514: * to it goes away.
515: * Warning: if you stat this, and try to match it
516: * with a name in the filesystem you will fail,
517: * unless you had previously put names in that match.
518: */
519: nip = ialloc(ip, dirpref(ip->i_fs), (int)ip->i_mode);
520: if (nip == (struct inode *)0) {
521: /*
522: * Give driver a chance to clean up;
523: * this is iffy since other instances
524: * of this device could be active.
525: */
526: cdevsw[maj].d_close(makedev(maj, minnum),
527: mode&FMASK);
528: return (ENXIO);
529: }
530: nip->i_flag |= IACC|IUPD|ICHG;
531: nip->i_mode = ip->i_mode;
532: nip->i_nlink = 0;
533: nip->i_uid = ip->i_uid;
534: nip->i_gid = ip->i_gid;
535: nip->i_rdev = makedev(maj, minnum);
536: #ifdef QUOTA
537: nip->i_dquot = inoquota(nip);
538: #endif
539: irele(ip);
540: ip = nip;
541: iunlock(ip);
542: /*
543: * This next line depends on the way copen()
544: * works; it's a kludge.
545: */
546: u.u_ofile[u.u_r.r_val1]->f_data = (caddr_t)ip;
547: }
548: return(error);
549:
550: case IFBLK:
551: if ((u_int)maj >= nblkdev)
552: return (ENXIO);
553: return ((*bdevsw[maj].d_open)(dev, mode));
554: }
555: return (0);
556: }
557:
558: /*
559: * Revoke access the current tty by all processes.
560: * Used only by the super-user in init
561: * to give ``clean'' terminals at login.
562: */
563: vhangup()
564: {
565:
566: if (!suser())
567: return;
568: if (u.u_ttyp == NULL)
569: return;
570: forceclose(u.u_ttyd);
571: if ((u.u_ttyp->t_state) & TS_ISOPEN)
572: gsignal(u.u_ttyp->t_pgrp, SIGHUP);
573: }
574:
575: forceclose(dev)
576: dev_t dev;
577: {
578: register struct file *fp;
579: register struct inode *ip;
580:
581: for (fp = file; fp < fileNFILE; fp++) {
582: if (fp->f_count == 0)
583: continue;
584: if (fp->f_type != DTYPE_INODE)
585: continue;
586: ip = (struct inode *)fp->f_data;
587: if (ip == 0)
588: continue;
589: if ((ip->i_mode & IFMT) != IFCHR)
590: continue;
591: if (ip->i_rdev != dev)
592: continue;
593: fp->f_flag &= ~(FREAD|FWRITE);
594: }
595: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.