![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vfs_vnops.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / vfs|
Return to vfs_vnops.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / vfs |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
26: /*
27: * Copyright (c) 1982, 1986, 1989, 1993
28: * The Regents of the University of California. All rights reserved.
29: * (c) UNIX System Laboratories, Inc.
30: * All or some portions of this file are derived from material licensed
31: * to the University of California by American Telephone and Telegraph
32: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
33: * the permission of UNIX System Laboratories, Inc.
34: *
35: * Redistribution and use in source and binary forms, with or without
36: * modification, are permitted provided that the following conditions
37: * are met:
38: * 1. Redistributions of source code must retain the above copyright
39: * notice, this list of conditions and the following disclaimer.
40: * 2. Redistributions in binary form must reproduce the above copyright
41: * notice, this list of conditions and the following disclaimer in the
42: * documentation and/or other materials provided with the distribution.
43: * 3. All advertising materials mentioning features or use of this software
44: * must display the following acknowledgement:
45: * This product includes software developed by the University of
46: * California, Berkeley and its contributors.
47: * 4. Neither the name of the University nor the names of its contributors
48: * may be used to endorse or promote products derived from this software
49: * without specific prior written permission.
50: *
51: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
52: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
53: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
54: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
55: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
56: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
57: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
58: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
59: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
60: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
61: * SUCH DAMAGE.
62: *
63: * @(#)vfs_vnops.c 8.14 (Berkeley) 6/15/95
64: *
65: * History
66: * 10-20-1997 Umesh Vaishampayan
67: * Fixed the count to be off_t rather than int.
68: */
69:
70: #include <mach_nbc.h>
71: #include <sys/param.h>
72: #include <sys/systm.h>
73: #include <sys/kernel.h>
74: #include <sys/file.h>
75: #include <sys/stat.h>
76: #include <sys/buf.h>
77: #include <sys/proc.h>
78: #include <sys/mount.h>
79: #include <sys/namei.h>
80: #include <sys/vnode.h>
81: #include <sys/ioctl.h>
82: #include <sys/tty.h>
83: #include <kern/mapfs.h>
84:
85: struct fileops vnops =
86: { vn_read, vn_write, vn_ioctl, vn_select, vn_closefile };
87:
88: /*
89: * Common code for vnode open operations.
90: * Check permissions, and call the VOP_OPEN or VOP_CREATE routine.
91: */
92: vn_open(ndp, fmode, cmode)
93: register struct nameidata *ndp;
94: int fmode, cmode;
95: {
96: register struct vnode *vp;
97: register struct proc *p = ndp->ni_cnd.cn_proc;
98: register struct ucred *cred = p->p_ucred;
99: struct vattr vat;
100: struct vattr *vap = &vat;
101: int error;
102: #if MACH_NBC
103: int no_mfs = fmode & O_NO_MFS;
104: #endif /* MACH_NBC */
105:
106: if (fmode & O_CREAT) {
107: ndp->ni_cnd.cn_nameiop = CREATE;
108: ndp->ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF;
109: if ((fmode & O_EXCL) == 0)
110: ndp->ni_cnd.cn_flags |= FOLLOW;
111: if (error = namei(ndp))
112: return (error);
113: if (ndp->ni_vp == NULL) {
114: VATTR_NULL(vap);
115: vap->va_type = VREG;
116: vap->va_mode = cmode;
117: if (fmode & O_EXCL)
118: vap->va_vaflags |= VA_EXCLUSIVE;
119: VOP_LEASE(ndp->ni_dvp, p, cred, LEASE_WRITE);
120: if (error = VOP_CREATE(ndp->ni_dvp, &ndp->ni_vp,
121: &ndp->ni_cnd, vap))
122: return (error);
123: fmode &= ~O_TRUNC;
124: vp = ndp->ni_vp;
125: } else {
126: VOP_ABORTOP(ndp->ni_dvp, &ndp->ni_cnd);
127: if (ndp->ni_dvp == ndp->ni_vp)
128: vrele(ndp->ni_dvp);
129: else
130: vput(ndp->ni_dvp);
131: ndp->ni_dvp = NULL;
132: vp = ndp->ni_vp;
133: if (fmode & O_EXCL) {
134: error = EEXIST;
135: goto bad;
136: }
137: fmode &= ~O_CREAT;
138: }
139: } else {
140: ndp->ni_cnd.cn_nameiop = LOOKUP;
141: ndp->ni_cnd.cn_flags = FOLLOW | LOCKLEAF;
142: if (error = namei(ndp))
143: return (error);
144: vp = ndp->ni_vp;
145: }
146: if (vp->v_type == VSOCK) {
147: error = EOPNOTSUPP;
148: goto bad;
149: }
150: if ((fmode & O_CREAT) == 0) {
151: if (fmode & FREAD) {
152: if (error = VOP_ACCESS(vp, VREAD, cred, p))
153: goto bad;
154: }
155: if (fmode & (FWRITE | O_TRUNC)) {
156: if (vp->v_type == VDIR) {
157: error = EISDIR;
158: goto bad;
159: }
160: if ((error = vn_writechk(vp)) ||
161: (error = VOP_ACCESS(vp, VWRITE, cred, p)))
162: goto bad;
163: }
164: }
165: if (fmode & O_TRUNC) {
166: VOP_UNLOCK(vp, 0, p); /* XXX */
167: VOP_LEASE(vp, p, cred, LEASE_WRITE);
168: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); /* XXX */
169: VATTR_NULL(vap);
170: vap->va_size = 0;
171: if (error = VOP_SETATTR(vp, vap, cred, p))
172: goto bad;
173: }
174: if (error = VOP_OPEN(vp, fmode, cred, p))
175: goto bad;
176: if ((vp->v_type == VREG) && !vp->v_vm_info) // XXX WMG
177: vm_info_init(vp);
178: #if MACH_NBC
179: if ((error == 0) && (no_mfs == 0) && (vp->v_type == VREG)) {
180: /* if the file was never mapped, leave it alone */
181: if (vp->v_vm_info->pager != NULL)
182: map_vnode(vp,p);
183: }
184:
185: /*
186: * if O_NO_MFS is set on open, blow the VM cache.
187: * if someone else is using it in VM then this has no effect.
188: */
189: if ((vp->v_type == VREG) && (no_mfs != 0))
190: (void) vnode_uncache(vp);
191: #endif /* MACH_NBC */
192:
193: if (fmode & FWRITE)
194: vp->v_writecount++;
195: return (0);
196: bad:
197: vput(vp);
198: return (error);
199: }
200:
201: /*
202: * Check for write permissions on the specified vnode.
203: * Prototype text segments cannot be written.
204: */
205: vn_writechk(vp)
206: register struct vnode *vp;
207: {
208:
209: /*
210: * If there's shared text associated with
211: * the vnode, try to free it up once. If
212: * we fail, we can't allow writing.
213: */
214: if ((vp->v_flag & VTEXT) && !vnode_uncache(vp))
215: return (ETXTBSY);
216: return (0);
217: }
218:
219: /*
220: * Vnode close call
221: */
222: vn_close(vp, flags, cred, p)
223: register struct vnode *vp;
224: int flags;
225: struct ucred *cred;
226: struct proc *p;
227: {
228: int error;
229:
230: #if MACH_NBC
231: if ((vp->v_type == VREG) && vp->v_vm_info)
232: unmap_vnode(vp,p);
233: #endif /* MACH_NBC */
234:
235: if (flags & FWRITE)
236: vp->v_writecount--;
237: error = VOP_CLOSE(vp, flags, cred, p);
238: vrele(vp);
239: return (error);
240: }
241:
242: /*
243: * Package up an I/O request on a vnode into a uio and do it.
244: */
245: vn_rdwr(rw, vp, base, len, offset, segflg, ioflg, cred, aresid, p)
246: enum uio_rw rw;
247: struct vnode *vp;
248: caddr_t base;
249: int len;
250: off_t offset;
251: enum uio_seg segflg;
252: int ioflg;
253: struct ucred *cred;
254: int *aresid;
255: struct proc *p;
256: {
257: struct uio auio;
258: struct iovec aiov;
259: int error=0;
260:
261: /* The routines that use this under MACH_NBC, call this
262: * routine with IO_NODELOCKED on, which is incorrect.
263: * For ease of code usage in case MACH_NBC is turned off
264: * we will bypass this check and let the callers still use
265: * IO_NODELOCKED flag
266: */
267: /* FIXME XXX */
268: if ((ioflg & IO_NODELOCKED) == 0)
269: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
270: auio.uio_iov = &aiov;
271: auio.uio_iovcnt = 1;
272: aiov.iov_base = base;
273: aiov.iov_len = len;
274: auio.uio_resid = len;
275: auio.uio_offset = offset;
276: auio.uio_segflg = segflg;
277: auio.uio_rw = rw;
278: auio.uio_procp = p;
279: #if MACH_NBC
280: /* if the file was never mapped, leave it alone */
281: if ((vp->v_type == VREG) && (vp->v_vm_info->pager != NULL)) {
282: if (vp->v_vm_info->map_count == 0) {
283: /*
284: * file has a pager but MapFS is not involved yet
285: * get MapFS involved
286: */
287: map_vnode(vp,p); /* vn_close() will loose this map_count */
288: }
289: error = mapfs_io(vp, &auio, rw, ioflg, cred);
290: } else {
291: #endif /* MACH_NBC */
292: if (rw == UIO_READ)
293: error = VOP_READ(vp, &auio, ioflg, cred);
294: else
295: error = VOP_WRITE(vp, &auio, ioflg, cred);
296: #if MACH_NBC
297: }
298: #endif /* MACH_NBC */
299: if (aresid)
300: *aresid = auio.uio_resid;
301: else
302: if (auio.uio_resid && error == 0)
303: error = EIO;
304: if ((ioflg & IO_NODELOCKED) == 0)
305: VOP_UNLOCK(vp, 0, p);
306: return (error);
307: }
308:
309: /*
310: * File table vnode read routine.
311: */
312: vn_read(fp, uio, cred)
313: struct file *fp;
314: struct uio *uio;
315: struct ucred *cred;
316: {
317: struct vnode *vp = (struct vnode *)fp->f_data;
318: struct proc *p = uio->uio_procp;
319: int error;
320: off_t count;
321:
322: VOP_LEASE(vp, p, cred, LEASE_READ);
323: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
324: uio->uio_offset = fp->f_offset;
325: count = uio->uio_resid;
326: #if MACH_NBC
327: if ((vp->v_type == VREG) && (vp->v_vm_info) && (vp->v_vm_info->mapped)) {
328: error = mapfs_io(vp, uio, UIO_READ, (fp->f_flag & FNONBLOCK) ? IO_NDELAY : 0, cred);
329: } else {
330: #endif /* MACH_NBC */
331: error = VOP_READ(vp, uio, (fp->f_flag & FNONBLOCK) ? IO_NDELAY : 0, cred);
332: #if MACH_NBC
333: }
334: #endif /* MACH_NBC */
335:
336: fp->f_offset += count - uio->uio_resid;
337: VOP_UNLOCK(vp, 0, p);
338: return (error);
339: }
340:
341: /*
342: * File table vnode write routine.
343: */
344: vn_write(fp, uio, cred)
345: struct file *fp;
346: struct uio *uio;
347: struct ucred *cred;
348: {
349: struct vnode *vp = (struct vnode *)fp->f_data;
350: struct proc *p = uio->uio_procp;
351: int error, ioflag = IO_UNIT;
352: off_t count;
353:
354: if (vp->v_type == VREG && (fp->f_flag & O_APPEND))
355: ioflag |= IO_APPEND;
356: if (fp->f_flag & FNONBLOCK)
357: ioflag |= IO_NDELAY;
358: if ((fp->f_flag & O_FSYNC) ||
359: (vp->v_mount && (vp->v_mount->mnt_flag & MNT_SYNCHRONOUS)))
360: ioflag |= IO_SYNC;
361: VOP_LEASE(vp, p, cred, LEASE_WRITE);
362: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
363: uio->uio_offset = fp->f_offset;
364: count = uio->uio_resid;
365: #if MACH_NBC
366: if ((vp->v_type == VREG) && (vp->v_vm_info) && (vp->v_vm_info->mapped)) {
367: error = mapfs_io(vp, uio, UIO_WRITE, ioflag, cred);
368: } else {
369: #endif /* MACH_NBC */
370:
371: error = VOP_WRITE(vp, uio, ioflag, cred);
372: #if MACH_NBC
373: }
374: #endif /* MACH_NBC */
375:
376: if (ioflag & IO_APPEND)
377: fp->f_offset = uio->uio_offset;
378: else
379: fp->f_offset += count - uio->uio_resid;
380: VOP_UNLOCK(vp, 0, p);
381: return (error);
382: }
383:
384: /*
385: * File table vnode stat routine.
386: */
387: vn_stat(vp, sb, p)
388: struct vnode *vp;
389: register struct stat *sb;
390: struct proc *p;
391: {
392: struct vattr vattr;
393: register struct vattr *vap;
394: int error;
395: u_short mode;
396:
397: vap = &vattr;
398: error = VOP_GETATTR(vp, vap, p->p_ucred, p);
399: if (error)
400: return (error);
401: /*
402: * Copy from vattr table
403: */
404: sb->st_dev = vap->va_fsid;
405: sb->st_ino = vap->va_fileid;
406: mode = vap->va_mode;
407: switch (vp->v_type) {
408: case VREG:
409: mode |= S_IFREG;
410: break;
411: case VDIR:
412: mode |= S_IFDIR;
413: break;
414: case VBLK:
415: mode |= S_IFBLK;
416: break;
417: case VCHR:
418: mode |= S_IFCHR;
419: break;
420: case VLNK:
421: mode |= S_IFLNK;
422: break;
423: case VSOCK:
424: mode |= S_IFSOCK;
425: break;
426: case VFIFO:
427: mode |= S_IFIFO;
428: break;
429: default:
430: return (EBADF);
431: };
432: sb->st_mode = mode;
433: sb->st_nlink = vap->va_nlink;
434: sb->st_uid = vap->va_uid;
435: sb->st_gid = vap->va_gid;
436: sb->st_rdev = vap->va_rdev;
437: sb->st_size = vap->va_size;
438: sb->st_atimespec = vap->va_atime;
439: sb->st_mtimespec = vap->va_mtime;
440: sb->st_ctimespec = vap->va_ctime;
441: sb->st_blksize = vap->va_blocksize;
442: sb->st_flags = vap->va_flags;
443: /* Do not give the generation number out to unpriviledged users */
444: if (suser(p->p_ucred, &p->p_acflag))
445: sb->st_gen = 0;
446: else
447: sb->st_gen = vap->va_gen;
448: sb->st_blocks = vap->va_bytes / S_BLKSIZE;
449: return (0);
450: }
451:
452: /*
453: * File table vnode ioctl routine.
454: */
455: vn_ioctl(fp, com, data, p)
456: struct file *fp;
457: u_long com;
458: caddr_t data;
459: struct proc *p;
460: {
461: register struct vnode *vp = ((struct vnode *)fp->f_data);
462: struct vattr vattr;
463: int error;
464:
465: switch (vp->v_type) {
466:
467: case VREG:
468: case VDIR:
469: if (com == FIONREAD) {
470: if (error = VOP_GETATTR(vp, &vattr, p->p_ucred, p))
471: return (error);
472: *(int *)data = vattr.va_size - fp->f_offset;
473: return (0);
474: }
475: if (com == FIONBIO || com == FIOASYNC) /* XXX */
476: return (0); /* XXX */
477: /* fall into ... */
478:
479: default:
480: return (ENOTTY);
481:
482: case VFIFO:
483: case VCHR:
484: case VBLK:
485: error = VOP_IOCTL(vp, com, data, fp->f_flag, p->p_ucred, p);
486: if (error == 0 && com == TIOCSCTTY) {
487: if (p->p_session->s_ttyvp)
488: vrele(p->p_session->s_ttyvp);
489: p->p_session->s_ttyvp = vp;
490: VREF(vp);
491: }
492: return (error);
493: }
494: }
495:
496: /*
497: * File table vnode select routine.
498: */
499: vn_select(fp, which, p)
500: struct file *fp;
501: int which;
502: struct proc *p;
503: {
504:
505: return (VOP_SELECT(((struct vnode *)fp->f_data), which, fp->f_flag,
506: fp->f_cred, p));
507: }
508:
509: /*
510: * Check that the vnode is still valid, and if so
511: * acquire requested lock.
512: */
513: int
514: vn_lock(vp, flags, p)
515: struct vnode *vp;
516: int flags;
517: struct proc *p;
518: {
519: int error;
520:
521: do {
522: if ((flags & LK_INTERLOCK) == 0)
523: simple_lock(&vp->v_interlock);
524: if (vp->v_flag & VXLOCK) {
525: vp->v_flag |= VXWANT;
526: simple_unlock(&vp->v_interlock);
527: tsleep((caddr_t)vp, PINOD, "vn_lock", 0);
528: error = ENOENT;
529: } else {
530: error = VOP_LOCK(vp, flags | LK_INTERLOCK, p);
531: if (error == 0)
532: return (error);
533: }
534: flags &= ~LK_INTERLOCK;
535: } while (flags & LK_RETRY);
536: return (error);
537: }
538:
539: /*
540: * File table vnode close routine.
541: */
542: vn_closefile(fp, p)
543: struct file *fp;
544: struct proc *p;
545: {
546:
547: return (vn_close(((struct vnode *)fp->f_data), fp->f_flag,
548: fp->f_cred, p));
549: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.