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