f2cb38dcdccb44d2803df1afdf0c5c672712e9a8
[dragonfly.git] / sys / kern / vfs_vnops.c
1 /*
2  * Copyright (c) 1982, 1986, 1989, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  * (c) UNIX System Laboratories, Inc.
5  * All or some portions of this file are derived from material licensed
6  * to the University of California by American Telephone and Telegraph
7  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8  * the permission of UNIX System Laboratories, Inc.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. All advertising materials mentioning features or use of this software
19  *    must display the following acknowledgement:
20  *      This product includes software developed by the University of
21  *      California, Berkeley and its contributors.
22  * 4. Neither the name of the University nor the names of its contributors
23  *    may be used to endorse or promote products derived from this software
24  *    without specific prior written permission.
25  *
26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36  * SUCH DAMAGE.
37  *
38  *      @(#)vfs_vnops.c 8.2 (Berkeley) 1/21/94
39  * $FreeBSD: src/sys/kern/vfs_vnops.c,v 1.87.2.13 2002/12/29 18:19:53 dillon Exp $
40  * $DragonFly: src/sys/kern/vfs_vnops.c,v 1.53 2007/08/13 17:43:55 dillon Exp $
41  */
42
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/fcntl.h>
46 #include <sys/file.h>
47 #include <sys/stat.h>
48 #include <sys/proc.h>
49 #include <sys/mount.h>
50 #include <sys/nlookup.h>
51 #include <sys/vnode.h>
52 #include <sys/buf.h>
53 #include <sys/filio.h>
54 #include <sys/ttycom.h>
55 #include <sys/conf.h>
56 #include <sys/syslog.h>
57
58 static int vn_closefile (struct file *fp);
59 static int vn_ioctl (struct file *fp, u_long com, caddr_t data,
60                 struct ucred *cred);
61 static int vn_read (struct file *fp, struct uio *uio, 
62                 struct ucred *cred, int flags);
63 static int svn_read (struct file *fp, struct uio *uio, 
64                 struct ucred *cred, int flags);
65 static int vn_poll (struct file *fp, int events, struct ucred *cred);
66 static int vn_kqfilter (struct file *fp, struct knote *kn);
67 static int vn_statfile (struct file *fp, struct stat *sb, struct ucred *cred);
68 static int vn_write (struct file *fp, struct uio *uio, 
69                 struct ucred *cred, int flags);
70 static int svn_write (struct file *fp, struct uio *uio, 
71                 struct ucred *cred, int flags);
72
73 struct fileops vnode_fileops = {
74         .fo_read = vn_read,
75         .fo_write = vn_write,
76         .fo_ioctl = vn_ioctl,
77         .fo_poll = vn_poll,
78         .fo_kqfilter = vn_kqfilter,
79         .fo_stat = vn_statfile,
80         .fo_close = vn_closefile,
81         .fo_shutdown = nofo_shutdown
82 };
83
84 struct fileops specvnode_fileops = {
85         .fo_read = svn_read,
86         .fo_write = svn_write,
87         .fo_ioctl = vn_ioctl,
88         .fo_poll = vn_poll,
89         .fo_kqfilter = vn_kqfilter,
90         .fo_stat = vn_statfile,
91         .fo_close = vn_closefile,
92         .fo_shutdown = nofo_shutdown
93 };
94
95 /*
96  * Shortcut the device read/write.  This avoids a lot of vnode junk.
97  * Basically the specfs vnops for read and write take the locked vnode,
98  * unlock it (because we can't hold the vnode locked while reading or writing
99  * a device which may block indefinitely), issues the device operation, then
100  * relock the vnode before returning, plus other junk.  This bypasses all
101  * of that and just does the device operation.
102  */
103 void
104 vn_setspecops(struct file *fp)
105 {
106         if (vfs_fastdev && fp->f_ops == &vnode_fileops) {
107                 fp->f_ops = &specvnode_fileops;
108         }
109 }
110
111 /*
112  * Common code for vnode open operations.  Check permissions, and call
113  * the VOP_NOPEN or VOP_NCREATE routine.
114  *
115  * The caller is responsible for setting up nd with nlookup_init() and
116  * for cleaning it up with nlookup_done(), whether we return an error
117  * or not.
118  *
119  * On success nd->nl_open_vp will hold a referenced and, if requested,
120  * locked vnode.  A locked vnode is requested via NLC_LOCKVP.  If fp
121  * is non-NULL the vnode will be installed in the file pointer.
122  *
123  * NOTE: The vnode is referenced just once on return whether or not it
124  * is also installed in the file pointer.
125  */
126 int
127 vn_open(struct nlookupdata *nd, struct file *fp, int fmode, int cmode)
128 {
129         struct vnode *vp;
130         struct vnode *dvp;
131         struct ucred *cred = nd->nl_cred;
132         struct vattr vat;
133         struct vattr *vap = &vat;
134         int mode, error;
135
136         /*
137          * Lookup the path and create or obtain the vnode.  After a
138          * successful lookup a locked nd->nl_nch will be returned.
139          *
140          * The result of this section should be a locked vnode.
141          *
142          * XXX with only a little work we should be able to avoid locking
143          * the vnode if FWRITE, O_CREAT, and O_TRUNC are *not* set.
144          */
145         if (fmode & O_CREAT) {
146                 /*
147                  * CONDITIONAL CREATE FILE CASE
148                  *
149                  * Setting NLC_CREATE causes a negative hit to store
150                  * the negative hit ncp and not return an error.  Then
151                  * nc_error or nc_vp may be checked to see if the ncp 
152                  * represents a negative hit.  NLC_CREATE also requires
153                  * write permission on the governing directory or EPERM
154                  * is returned.
155                  */
156                 if ((fmode & O_EXCL) == 0 && (fmode & O_NOFOLLOW) == 0)
157                         nd->nl_flags |= NLC_FOLLOW;
158                 nd->nl_flags |= NLC_CREATE;
159                 bwillwrite();
160                 error = nlookup(nd);
161         } else {
162                 /*
163                  * NORMAL OPEN FILE CASE
164                  */
165                 error = nlookup(nd);
166         }
167
168         if (error)
169                 return (error);
170
171         /*
172          * split case to allow us to re-resolve and retry the ncp in case
173          * we get ESTALE.
174          */
175 again:
176         if (fmode & O_CREAT) {
177                 if (nd->nl_nch.ncp->nc_vp == NULL) {
178                         if ((error = ncp_writechk(&nd->nl_nch)) != 0)
179                                 return (error);
180                         if ((dvp = nd->nl_nch.ncp->nc_parent->nc_vp) == NULL)
181                                 return (EPERM);
182                         /* vhold(dvp); - dvp can't go away */
183                         VATTR_NULL(vap);
184                         vap->va_type = VREG;
185                         vap->va_mode = cmode;
186                         if (fmode & O_EXCL)
187                                 vap->va_vaflags |= VA_EXCLUSIVE;
188                         error = VOP_NCREATE(&nd->nl_nch, dvp, &vp,
189                                             nd->nl_cred, vap);
190                         /* vdrop(dvp); */
191                         if (error)
192                                 return (error);
193                         fmode &= ~O_TRUNC;
194                         /* locked vnode is returned */
195                 } else {
196                         if (fmode & O_EXCL) {
197                                 error = EEXIST;
198                         } else {
199                                 error = cache_vget(&nd->nl_nch, cred, 
200                                                     LK_EXCLUSIVE, &vp);
201                         }
202                         if (error)
203                                 return (error);
204                         fmode &= ~O_CREAT;
205                 }
206         } else {
207                 error = cache_vget(&nd->nl_nch, cred, LK_EXCLUSIVE, &vp);
208                 if (error)
209                         return (error);
210         }
211
212         /*
213          * We have a locked vnode and ncp now.  Note that the ncp will
214          * be cleaned up by the caller if nd->nl_nch is left intact.
215          */
216         if (vp->v_type == VLNK) {
217                 error = EMLINK;
218                 goto bad;
219         }
220         if (vp->v_type == VSOCK) {
221                 error = EOPNOTSUPP;
222                 goto bad;
223         }
224         if ((fmode & O_CREAT) == 0) {
225                 mode = 0;
226                 if (fmode & (FWRITE | O_TRUNC)) {
227                         if (vp->v_type == VDIR) {
228                                 error = EISDIR;
229                                 goto bad;
230                         }
231                         error = vn_writechk(vp, &nd->nl_nch);
232                         if (error) {
233                                 /*
234                                  * Special stale handling, re-resolve the
235                                  * vnode.
236                                  */
237                                 if (error == ESTALE) {
238                                         vput(vp);
239                                         vp = NULL;
240                                         cache_setunresolved(&nd->nl_nch);
241                                         error = cache_resolve(&nd->nl_nch, cred);
242                                         if (error == 0)
243                                                 goto again;
244                                 }
245                                 goto bad;
246                         }
247                         mode |= VWRITE;
248                 }
249                 if (fmode & FREAD)
250                         mode |= VREAD;
251                 if (mode) {
252                         error = VOP_ACCESS(vp, mode, cred);
253                         if (error) {
254                                 /*
255                                  * Special stale handling, re-resolve the
256                                  * vnode.
257                                  */
258                                 if (error == ESTALE) {
259                                         vput(vp);
260                                         vp = NULL;
261                                         cache_setunresolved(&nd->nl_nch);
262                                         error = cache_resolve(&nd->nl_nch, cred);
263                                         if (error == 0)
264                                                 goto again;
265                                 }
266                                 goto bad;
267                         }
268                 }
269         }
270         if (fmode & O_TRUNC) {
271                 vn_unlock(vp);                          /* XXX */
272                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);   /* XXX */
273                 VATTR_NULL(vap);
274                 vap->va_size = 0;
275                 error = VOP_SETATTR(vp, vap, cred);
276                 if (error)
277                         goto bad;
278         }
279
280         /*
281          * Setup the fp so VOP_OPEN can override it.  No descriptor has been
282          * associated with the fp yet so we own it clean.  
283          *
284          * f_nchandle inherits nl_nch.  This used to be necessary only for
285          * directories but now we do it unconditionally so f*() ops
286          * such as fchmod() can access the actual namespace that was
287          * used to open the file.
288          */
289         if (fp) {
290                 fp->f_nchandle = nd->nl_nch;
291                 cache_zero(&nd->nl_nch);
292                 cache_unlock(&fp->f_nchandle);
293         }
294
295         /*
296          * Get rid of nl_nch.  vn_open does not return it (it returns the
297          * vnode or the file pointer).  Note: we can't leave nl_nch locked
298          * through the VOP_OPEN anyway since the VOP_OPEN may block, e.g.
299          * on /dev/ttyd0
300          */
301         if (nd->nl_nch.ncp)
302                 cache_put(&nd->nl_nch);
303
304         error = VOP_OPEN(vp, fmode, cred, fp);
305         if (error) {
306                 /*
307                  * setting f_ops to &badfileops will prevent the descriptor
308                  * code from trying to close and release the vnode, since
309                  * the open failed we do not want to call close.
310                  */
311                 if (fp) {
312                         fp->f_data = NULL;
313                         fp->f_ops = &badfileops;
314                 }
315                 goto bad;
316         }
317
318 #if 0
319         /*
320          * Assert that VREG files have been setup for vmio.
321          */
322         KASSERT(vp->v_type != VREG || vp->v_object != NULL,
323                 ("vn_open: regular file was not VMIO enabled!"));
324 #endif
325
326         /*
327          * Return the vnode.  XXX needs some cleaning up.  The vnode is
328          * only returned in the fp == NULL case.
329          */
330         if (fp == NULL) {
331                 nd->nl_open_vp = vp;
332                 nd->nl_vp_fmode = fmode;
333                 if ((nd->nl_flags & NLC_LOCKVP) == 0)
334                         vn_unlock(vp);
335         } else {
336                 vput(vp);
337         }
338         return (0);
339 bad:
340         if (vp)
341                 vput(vp);
342         return (error);
343 }
344
345 int
346 vn_opendisk(const char *devname, int fmode, struct vnode **vpp)
347 {
348         struct vnode *vp;
349         int error;
350
351         if (strncmp(devname, "/dev/", 5) == 0)
352                 devname += 5;
353         if ((vp = getsynthvnode(devname)) == NULL) {
354                 error = ENODEV;
355         } else {
356                 error = VOP_OPEN(vp, fmode, proc0.p_ucred, NULL);
357                 vn_unlock(vp);
358                 if (error) {
359                         vrele(vp);
360                         vp = NULL;
361                 }
362         }
363         *vpp = vp;
364         return (error);
365 }
366
367 /*
368  * Check for write permissions on the specified vnode.  nch may be NULL.
369  */
370 int
371 vn_writechk(struct vnode *vp, struct nchandle *nch)
372 {
373         /*
374          * If there's shared text associated with
375          * the vnode, try to free it up once.  If
376          * we fail, we can't allow writing.
377          */
378         if (vp->v_flag & VTEXT)
379                 return (ETXTBSY);
380
381         /*
382          * If the vnode represents a regular file, check the mount
383          * point via the nch.  This may be a different mount point
384          * then the one embedded in the vnode (e.g. nullfs).
385          *
386          * We can still write to non-regular files (e.g. devices)
387          * via read-only mounts.
388          */
389         if (nch && nch->ncp && vp->v_type == VREG)
390                 return (ncp_writechk(nch));
391         return (0);
392 }
393
394 /*
395  * Check whether the underlying mount is read-only.  The mount point 
396  * referenced by the namecache may be different from the mount point
397  * used by the underlying vnode in the case of NULLFS, so a separate
398  * check is needed.
399  */
400 int
401 ncp_writechk(struct nchandle *nch)
402 {
403         if (nch->mount && (nch->mount->mnt_flag & MNT_RDONLY))
404                 return (EROFS);
405         return(0);
406 }
407
408 /*
409  * Vnode close call
410  */
411 int
412 vn_close(struct vnode *vp, int flags)
413 {
414         int error;
415
416         if ((error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY)) == 0) {
417                 error = VOP_CLOSE(vp, flags);
418                 vn_unlock(vp);
419         }
420         vrele(vp);
421         return (error);
422 }
423
424 static __inline
425 int
426 sequential_heuristic(struct uio *uio, struct file *fp)
427 {
428         /*
429          * Sequential heuristic - detect sequential operation
430          */
431         if ((uio->uio_offset == 0 && fp->f_seqcount > 0) ||
432             uio->uio_offset == fp->f_nextoff) {
433                 int tmpseq = fp->f_seqcount;
434                 /*
435                  * XXX we assume that the filesystem block size is
436                  * the default.  Not true, but still gives us a pretty
437                  * good indicator of how sequential the read operations
438                  * are.
439                  */
440                 tmpseq += (uio->uio_resid + BKVASIZE - 1) / BKVASIZE;
441                 if (tmpseq > IO_SEQMAX)
442                         tmpseq = IO_SEQMAX;
443                 fp->f_seqcount = tmpseq;
444                 return(fp->f_seqcount << IO_SEQSHIFT);
445         }
446
447         /*
448          * Not sequential, quick draw-down of seqcount
449          */
450         if (fp->f_seqcount > 1)
451                 fp->f_seqcount = 1;
452         else
453                 fp->f_seqcount = 0;
454         return(0);
455 }
456
457 /*
458  * Package up an I/O request on a vnode into a uio and do it.
459  */
460 int
461 vn_rdwr(enum uio_rw rw, struct vnode *vp, caddr_t base, int len,
462         off_t offset, enum uio_seg segflg, int ioflg, 
463         struct ucred *cred, int *aresid)
464 {
465         struct uio auio;
466         struct iovec aiov;
467         struct ccms_lock ccms_lock;
468         int error;
469
470         if ((ioflg & IO_NODELOCKED) == 0)
471                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
472         auio.uio_iov = &aiov;
473         auio.uio_iovcnt = 1;
474         aiov.iov_base = base;
475         aiov.iov_len = len;
476         auio.uio_resid = len;
477         auio.uio_offset = offset;
478         auio.uio_segflg = segflg;
479         auio.uio_rw = rw;
480         auio.uio_td = curthread;
481         ccms_lock_get_uio(&vp->v_ccms, &ccms_lock, &auio);
482         if (rw == UIO_READ) {
483                 error = VOP_READ(vp, &auio, ioflg, cred);
484         } else {
485                 error = VOP_WRITE(vp, &auio, ioflg, cred);
486         }
487         ccms_lock_put(&vp->v_ccms, &ccms_lock);
488         if (aresid)
489                 *aresid = auio.uio_resid;
490         else
491                 if (auio.uio_resid && error == 0)
492                         error = EIO;
493         if ((ioflg & IO_NODELOCKED) == 0)
494                 vn_unlock(vp);
495         return (error);
496 }
497
498 /*
499  * Package up an I/O request on a vnode into a uio and do it.  The I/O
500  * request is split up into smaller chunks and we try to avoid saturating
501  * the buffer cache while potentially holding a vnode locked, so we 
502  * check bwillwrite() before calling vn_rdwr().  We also call uio_yield()
503  * to give other processes a chance to lock the vnode (either other processes
504  * core'ing the same binary, or unrelated processes scanning the directory).
505  */
506 int
507 vn_rdwr_inchunks(enum uio_rw rw, struct vnode *vp, caddr_t base, int len,
508                  off_t offset, enum uio_seg segflg, int ioflg,
509                  struct ucred *cred, int *aresid)
510 {
511         int error = 0;
512
513         do {
514                 int chunk;
515
516                 /*
517                  * Force `offset' to a multiple of MAXBSIZE except possibly
518                  * for the first chunk, so that filesystems only need to
519                  * write full blocks except possibly for the first and last
520                  * chunks.
521                  */
522                 chunk = MAXBSIZE - (uoff_t)offset % MAXBSIZE;
523
524                 if (chunk > len)
525                         chunk = len;
526                 if (rw != UIO_READ && vp->v_type == VREG)
527                         bwillwrite();
528                 error = vn_rdwr(rw, vp, base, chunk, offset, segflg,
529                             ioflg, cred, aresid);
530                 len -= chunk;   /* aresid calc already includes length */
531                 if (error)
532                         break;
533                 offset += chunk;
534                 base += chunk;
535                 uio_yield();
536         } while (len);
537         if (aresid)
538                 *aresid += len;
539         return (error);
540 }
541
542 /*
543  * MPALMOSTSAFE - acquires mplock
544  */
545 static int
546 vn_read(struct file *fp, struct uio *uio, struct ucred *cred, int flags)
547 {
548         struct ccms_lock ccms_lock;
549         struct vnode *vp;
550         int error, ioflag;
551
552         get_mplock();
553         KASSERT(uio->uio_td == curthread,
554                 ("uio_td %p is not td %p", uio->uio_td, curthread));
555         vp = (struct vnode *)fp->f_data;
556
557         ioflag = 0;
558         if (flags & O_FBLOCKING) {
559                 /* ioflag &= ~IO_NDELAY; */
560         } else if (flags & O_FNONBLOCKING) {
561                 ioflag |= IO_NDELAY;
562         } else if (fp->f_flag & FNONBLOCK) {
563                 ioflag |= IO_NDELAY;
564         }
565         if (flags & O_FBUFFERED) {
566                 /* ioflag &= ~IO_DIRECT; */
567         } else if (flags & O_FUNBUFFERED) {
568                 ioflag |= IO_DIRECT;
569         } else if (fp->f_flag & O_DIRECT) {
570                 ioflag |= IO_DIRECT;
571         }
572         vn_lock(vp, LK_SHARED | LK_RETRY);
573         if ((flags & O_FOFFSET) == 0)
574                 uio->uio_offset = fp->f_offset;
575         ioflag |= sequential_heuristic(uio, fp);
576
577         ccms_lock_get_uio(&vp->v_ccms, &ccms_lock, uio);
578         error = VOP_READ(vp, uio, ioflag, cred);
579         ccms_lock_put(&vp->v_ccms, &ccms_lock);
580         if ((flags & O_FOFFSET) == 0)
581                 fp->f_offset = uio->uio_offset;
582         fp->f_nextoff = uio->uio_offset;
583         vn_unlock(vp);
584         rel_mplock();
585         return (error);
586 }
587
588 /*
589  * Device-optimized file table vnode read routine.
590  *
591  * This bypasses the VOP table and talks directly to the device.  Most
592  * filesystems just route to specfs and can make this optimization.
593  *
594  * MPALMOSTSAFE - acquires mplock
595  */
596 static int
597 svn_read(struct file *fp, struct uio *uio, struct ucred *cred, int flags)
598 {
599         struct vnode *vp;
600         int ioflag;
601         int error;
602         cdev_t dev;
603
604         get_mplock();
605         KASSERT(uio->uio_td == curthread,
606                 ("uio_td %p is not td %p", uio->uio_td, curthread));
607
608         vp = (struct vnode *)fp->f_data;
609         if (vp == NULL || vp->v_type == VBAD) {
610                 error = EBADF;
611                 goto done;
612         }
613
614         if ((dev = vp->v_rdev) == NULL) {
615                 error = EBADF;
616                 goto done;
617         }
618         reference_dev(dev);
619
620         if (uio->uio_resid == 0) {
621                 error = 0;
622                 goto done;
623         }
624         if ((flags & O_FOFFSET) == 0)
625                 uio->uio_offset = fp->f_offset;
626
627         ioflag = 0;
628         if (flags & O_FBLOCKING) {
629                 /* ioflag &= ~IO_NDELAY; */
630         } else if (flags & O_FNONBLOCKING) {
631                 ioflag |= IO_NDELAY;
632         } else if (fp->f_flag & FNONBLOCK) {
633                 ioflag |= IO_NDELAY;
634         }
635         if (flags & O_FBUFFERED) {
636                 /* ioflag &= ~IO_DIRECT; */
637         } else if (flags & O_FUNBUFFERED) {
638                 ioflag |= IO_DIRECT;
639         } else if (fp->f_flag & O_DIRECT) {
640                 ioflag |= IO_DIRECT;
641         }
642         ioflag |= sequential_heuristic(uio, fp);
643
644         error = dev_dread(dev, uio, ioflag);
645
646         release_dev(dev);
647         if ((flags & O_FOFFSET) == 0)
648                 fp->f_offset = uio->uio_offset;
649         fp->f_nextoff = uio->uio_offset;
650 done:
651         rel_mplock();
652         return (error);
653 }
654
655 /*
656  * MPALMOSTSAFE - acquires mplock
657  */
658 static int
659 vn_write(struct file *fp, struct uio *uio, struct ucred *cred, int flags)
660 {
661         struct ccms_lock ccms_lock;
662         struct vnode *vp;
663         int error, ioflag;
664
665         get_mplock();
666         KASSERT(uio->uio_td == curthread,
667                 ("uio_td %p is not p %p", uio->uio_td, curthread));
668         vp = (struct vnode *)fp->f_data;
669         if (vp->v_type == VREG)
670                 bwillwrite();
671         vp = (struct vnode *)fp->f_data;        /* XXX needed? */
672
673         ioflag = IO_UNIT;
674         if (vp->v_type == VREG &&
675            ((fp->f_flag & O_APPEND) || (flags & O_FAPPEND))) {
676                 ioflag |= IO_APPEND;
677         }
678
679         if (flags & O_FBLOCKING) {
680                 /* ioflag &= ~IO_NDELAY; */
681         } else if (flags & O_FNONBLOCKING) {
682                 ioflag |= IO_NDELAY;
683         } else if (fp->f_flag & FNONBLOCK) {
684                 ioflag |= IO_NDELAY;
685         }
686         if (flags & O_FBUFFERED) {
687                 /* ioflag &= ~IO_DIRECT; */
688         } else if (flags & O_FUNBUFFERED) {
689                 ioflag |= IO_DIRECT;
690         } else if (fp->f_flag & O_DIRECT) {
691                 ioflag |= IO_DIRECT;
692         }
693         if (flags & O_FASYNCWRITE) {
694                 /* ioflag &= ~IO_SYNC; */
695         } else if (flags & O_FSYNCWRITE) {
696                 ioflag |= IO_SYNC;
697         } else if (fp->f_flag & O_FSYNC) {
698                 ioflag |= IO_SYNC;
699         }
700
701         if (vp->v_mount && (vp->v_mount->mnt_flag & MNT_SYNCHRONOUS))
702                 ioflag |= IO_SYNC;
703         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
704         if ((flags & O_FOFFSET) == 0)
705                 uio->uio_offset = fp->f_offset;
706         ioflag |= sequential_heuristic(uio, fp);
707         ccms_lock_get_uio(&vp->v_ccms, &ccms_lock, uio);
708         error = VOP_WRITE(vp, uio, ioflag, cred);
709         ccms_lock_put(&vp->v_ccms, &ccms_lock);
710         if ((flags & O_FOFFSET) == 0)
711                 fp->f_offset = uio->uio_offset;
712         fp->f_nextoff = uio->uio_offset;
713         vn_unlock(vp);
714         rel_mplock();
715         return (error);
716 }
717
718 /*
719  * Device-optimized file table vnode write routine.
720  *
721  * This bypasses the VOP table and talks directly to the device.  Most
722  * filesystems just route to specfs and can make this optimization.
723  *
724  * MPALMOSTSAFE - acquires mplock
725  */
726 static int
727 svn_write(struct file *fp, struct uio *uio, struct ucred *cred, int flags)
728 {
729         struct vnode *vp;
730         int ioflag;
731         int error;
732         cdev_t dev;
733
734         get_mplock();
735         KASSERT(uio->uio_td == curthread,
736                 ("uio_td %p is not p %p", uio->uio_td, curthread));
737
738         vp = (struct vnode *)fp->f_data;
739         if (vp == NULL || vp->v_type == VBAD) {
740                 error = EBADF;
741                 goto done;
742         }
743         if (vp->v_type == VREG)
744                 bwillwrite();
745         vp = (struct vnode *)fp->f_data;        /* XXX needed? */
746
747         if ((dev = vp->v_rdev) == NULL) {
748                 error = EBADF;
749                 goto done;
750         }
751         reference_dev(dev);
752
753         if ((flags & O_FOFFSET) == 0)
754                 uio->uio_offset = fp->f_offset;
755
756         ioflag = IO_UNIT;
757         if (vp->v_type == VREG && 
758            ((fp->f_flag & O_APPEND) || (flags & O_FAPPEND))) {
759                 ioflag |= IO_APPEND;
760         }
761
762         if (flags & O_FBLOCKING) {
763                 /* ioflag &= ~IO_NDELAY; */
764         } else if (flags & O_FNONBLOCKING) {
765                 ioflag |= IO_NDELAY;
766         } else if (fp->f_flag & FNONBLOCK) {
767                 ioflag |= IO_NDELAY;
768         }
769         if (flags & O_FBUFFERED) {
770                 /* ioflag &= ~IO_DIRECT; */
771         } else if (flags & O_FUNBUFFERED) {
772                 ioflag |= IO_DIRECT;
773         } else if (fp->f_flag & O_DIRECT) {
774                 ioflag |= IO_DIRECT;
775         }
776         if (flags & O_FASYNCWRITE) {
777                 /* ioflag &= ~IO_SYNC; */
778         } else if (flags & O_FSYNCWRITE) {
779                 ioflag |= IO_SYNC;
780         } else if (fp->f_flag & O_FSYNC) {
781                 ioflag |= IO_SYNC;
782         }
783
784         if (vp->v_mount && (vp->v_mount->mnt_flag & MNT_SYNCHRONOUS))
785                 ioflag |= IO_SYNC;
786         ioflag |= sequential_heuristic(uio, fp);
787
788         error = dev_dwrite(dev, uio, ioflag);
789
790         release_dev(dev);
791         if ((flags & O_FOFFSET) == 0)
792                 fp->f_offset = uio->uio_offset;
793         fp->f_nextoff = uio->uio_offset;
794 done:
795         rel_mplock();
796         return (error);
797 }
798
799 /*
800  * MPALMOSTSAFE - acquires mplock
801  */
802 static int
803 vn_statfile(struct file *fp, struct stat *sb, struct ucred *cred)
804 {
805         struct vnode *vp;
806         int error;
807
808         get_mplock();
809         vp = (struct vnode *)fp->f_data;
810         error = vn_stat(vp, sb, cred);
811         rel_mplock();
812         return (error);
813 }
814
815 int
816 vn_stat(struct vnode *vp, struct stat *sb, struct ucred *cred)
817 {
818         struct vattr vattr;
819         struct vattr *vap;
820         int error;
821         u_short mode;
822         cdev_t dev;
823
824         vap = &vattr;
825         error = VOP_GETATTR(vp, vap);
826         if (error)
827                 return (error);
828
829         /*
830          * Zero the spare stat fields
831          */
832         sb->st_lspare = 0;
833         sb->st_qspare = 0;
834
835         /*
836          * Copy from vattr table
837          */
838         if (vap->va_fsid != VNOVAL)
839                 sb->st_dev = vap->va_fsid;
840         else
841                 sb->st_dev = vp->v_mount->mnt_stat.f_fsid.val[0];
842         sb->st_ino = vap->va_fileid;
843         mode = vap->va_mode;
844         switch (vap->va_type) {
845         case VREG:
846                 mode |= S_IFREG;
847                 break;
848         case VDIR:
849                 mode |= S_IFDIR;
850                 break;
851         case VBLK:
852                 mode |= S_IFBLK;
853                 break;
854         case VCHR:
855                 mode |= S_IFCHR;
856                 break;
857         case VLNK:
858                 mode |= S_IFLNK;
859                 /* This is a cosmetic change, symlinks do not have a mode. */
860                 if (vp->v_mount->mnt_flag & MNT_NOSYMFOLLOW)
861                         sb->st_mode &= ~ACCESSPERMS;    /* 0000 */
862                 else
863                         sb->st_mode |= ACCESSPERMS;     /* 0777 */
864                 break;
865         case VSOCK:
866                 mode |= S_IFSOCK;
867                 break;
868         case VFIFO:
869                 mode |= S_IFIFO;
870                 break;
871         default:
872                 return (EBADF);
873         };
874         sb->st_mode = mode;
875         sb->st_nlink = vap->va_nlink;
876         sb->st_uid = vap->va_uid;
877         sb->st_gid = vap->va_gid;
878         sb->st_rdev = makeudev(vap->va_rmajor, vap->va_rminor);
879         sb->st_size = vap->va_size;
880         sb->st_atimespec = vap->va_atime;
881         sb->st_mtimespec = vap->va_mtime;
882         sb->st_ctimespec = vap->va_ctime;
883
884         /*
885          * A VCHR and VBLK device may track the last access and last modified
886          * time independantly of the filesystem.  This is particularly true
887          * because device read and write calls may bypass the filesystem.
888          */
889         if (vp->v_type == VCHR || vp->v_type == VBLK) {
890                 if ((dev = vp->v_rdev) != NULL) {
891                         if (dev->si_lastread) {
892                                 sb->st_atimespec.tv_sec = dev->si_lastread;
893                                 sb->st_atimespec.tv_nsec = 0;
894                         }
895                         if (dev->si_lastwrite) {
896                                 sb->st_atimespec.tv_sec = dev->si_lastwrite;
897                                 sb->st_atimespec.tv_nsec = 0;
898                         }
899                 }
900         }
901
902         /*
903          * According to www.opengroup.org, the meaning of st_blksize is 
904          *   "a filesystem-specific preferred I/O block size for this 
905          *    object.  In some filesystem types, this may vary from file
906          *    to file"
907          * Default to PAGE_SIZE after much discussion.
908          */
909
910         if (vap->va_type == VREG) {
911                 sb->st_blksize = vap->va_blocksize;
912         } else if (vn_isdisk(vp, NULL)) {
913                 /*
914                  * XXX this is broken.  If the device is not yet open (aka
915                  * stat() call, aka v_rdev == NULL), how are we supposed
916                  * to get a valid block size out of it?
917                  */
918                 cdev_t dev;
919
920                 if ((dev = vp->v_rdev) == NULL) {
921                         if (vp->v_type == VCHR)
922                                 dev = get_dev(vp->v_umajor, vp->v_uminor);
923                 }
924                 sb->st_blksize = dev->si_bsize_best;
925                 if (sb->st_blksize < dev->si_bsize_phys)
926                         sb->st_blksize = dev->si_bsize_phys;
927                 if (sb->st_blksize < BLKDEV_IOSIZE)
928                         sb->st_blksize = BLKDEV_IOSIZE;
929         } else {
930                 sb->st_blksize = PAGE_SIZE;
931         }
932         
933         sb->st_flags = vap->va_flags;
934         if (suser_cred(cred, 0))
935                 sb->st_gen = 0;
936         else
937                 sb->st_gen = vap->va_gen;
938
939 #if (S_BLKSIZE == 512)
940         /* Optimize this case */
941         sb->st_blocks = vap->va_bytes >> 9;
942 #else
943         sb->st_blocks = vap->va_bytes / S_BLKSIZE;
944 #endif
945         sb->st_fsmid = vap->va_fsmid;
946         return (0);
947 }
948
949 /*
950  * MPALMOSTSAFE - acquires mplock
951  */
952 static int
953 vn_ioctl(struct file *fp, u_long com, caddr_t data, struct ucred *ucred)
954 {
955         struct vnode *vp = ((struct vnode *)fp->f_data);
956         struct vnode *ovp;
957         struct vattr vattr;
958         int error;
959
960         get_mplock();
961
962         switch (vp->v_type) {
963         case VREG:
964         case VDIR:
965                 if (com == FIONREAD) {
966                         if ((error = VOP_GETATTR(vp, &vattr)) != 0)
967                                 break;
968                         *(int *)data = vattr.va_size - fp->f_offset;
969                         error = 0;
970                         break;
971                 }
972                 if (com == FIOASYNC) {                          /* XXX */
973                         error = 0;                              /* XXX */
974                         break;
975                 }
976                 /* fall into ... */
977         default:
978 #if 0
979                 return (ENOTTY);
980 #endif
981         case VFIFO:
982         case VCHR:
983         case VBLK:
984                 if (com == FIODTYPE) {
985                         if (vp->v_type != VCHR && vp->v_type != VBLK) {
986                                 error = ENOTTY;
987                                 break;
988                         }
989                         *(int *)data = dev_dflags(vp->v_rdev) & D_TYPEMASK;
990                         error = 0;
991                         break;
992                 }
993                 error = VOP_IOCTL(vp, com, data, fp->f_flag, ucred);
994                 if (error == 0 && com == TIOCSCTTY) {
995                         struct proc *p = curthread->td_proc;
996                         struct session *sess;
997
998                         if (p == NULL) {
999                                 error = ENOTTY;
1000                                 break;
1001                         }
1002
1003                         sess = p->p_session;
1004                         /* Do nothing if reassigning same control tty */
1005                         if (sess->s_ttyvp == vp) {
1006                                 error = 0;
1007                                 break;
1008                         }
1009
1010                         /* Get rid of reference to old control tty */
1011                         ovp = sess->s_ttyvp;
1012                         vref(vp);
1013                         sess->s_ttyvp = vp;
1014                         if (ovp)
1015                                 vrele(ovp);
1016                 }
1017                 break;
1018         }
1019         rel_mplock();
1020         return (error);
1021 }
1022
1023 /*
1024  * MPALMOSTSAFE - acquires mplock
1025  */
1026 static int
1027 vn_poll(struct file *fp, int events, struct ucred *cred)
1028 {
1029         int error;
1030
1031         get_mplock();
1032         error = VOP_POLL(((struct vnode *)fp->f_data), events, cred);
1033         rel_mplock();
1034         return (error);
1035 }
1036
1037 /*
1038  * Check that the vnode is still valid, and if so
1039  * acquire requested lock.
1040  */
1041 int
1042 #ifndef DEBUG_LOCKS
1043 vn_lock(struct vnode *vp, int flags)
1044 #else
1045 debug_vn_lock(struct vnode *vp, int flags, const char *filename, int line)
1046 #endif
1047 {
1048         int error;
1049         
1050         do {
1051 #ifdef  DEBUG_LOCKS
1052                 vp->filename = filename;
1053                 vp->line = line;
1054                 error = debuglockmgr(&vp->v_lock, flags,
1055                                      "vn_lock", filename, line);
1056 #else
1057                 error = lockmgr(&vp->v_lock, flags);
1058 #endif
1059                 if (error == 0)
1060                         break;
1061         } while (flags & LK_RETRY);
1062
1063         /*
1064          * Because we (had better!) have a ref on the vnode, once it
1065          * goes to VRECLAIMED state it will not be recycled until all
1066          * refs go away.  So we can just check the flag.
1067          */
1068         if (error == 0 && (vp->v_flag & VRECLAIMED)) {
1069                 lockmgr(&vp->v_lock, LK_RELEASE);
1070                 error = ENOENT;
1071         }
1072         return (error);
1073 }
1074
1075 void
1076 vn_unlock(struct vnode *vp)
1077 {
1078         lockmgr(&vp->v_lock, LK_RELEASE);
1079 }
1080
1081 int
1082 vn_islocked(struct vnode *vp)
1083 {
1084         return (lockstatus(&vp->v_lock, curthread));
1085 }
1086
1087 /*
1088  * MPALMOSTSAFE - acquires mplock
1089  */
1090 static int
1091 vn_closefile(struct file *fp)
1092 {
1093         int error;
1094
1095         get_mplock();
1096         fp->f_ops = &badfileops;
1097         error = vn_close(((struct vnode *)fp->f_data), fp->f_flag);
1098         rel_mplock();
1099         return(error);
1100 }
1101
1102 /*
1103  * MPALMOSTSAFE - acquires mplock
1104  */
1105 static int
1106 vn_kqfilter(struct file *fp, struct knote *kn)
1107 {
1108         int error;
1109
1110         get_mplock();
1111         error = VOP_KQFILTER(((struct vnode *)fp->f_data), kn);
1112         rel_mplock();
1113         return (error);
1114 }