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.40 2006/05/26 00:33:09 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         NULL,   /* port */
  75         NULL,   /* clone */
  76         vn_read, vn_write, vn_ioctl, vn_poll, vn_kqfilter,
  77         vn_statfile, vn_closefile, nofo_shutdown
  78 };
  79
  80 struct fileops specvnode_fileops = {
  81         NULL,   /* port */
  82         NULL,   /* clone */
  83         svn_read, svn_write, vn_ioctl, vn_poll, vn_kqfilter,
  84         vn_statfile, vn_closefile, nofo_shutdown
  85 };
  86
  87 /*
  88  * Shortcut the device read/write.  This avoids a lot of vnode junk.
  89  * Basically the specfs vnops for read and write take the locked vnode,
  90  * unlock it (because we can't hold the vnode locked while reading or writing
  91  * a device which may block indefinitely), issues the device operation, then
  92  * relock the vnode before returning, plus other junk.  This bypasses all
  93  * of that and just does the device operation.
  94  */
  95 void
  96 vn_setspecops(struct file *fp)
  97 {
  98         if (vfs_fastdev && fp->f_ops == &vnode_fileops) {
  99                 fp->f_ops = &specvnode_fileops;
 100         }
 101 }
 102
 103 /*
 104  * Common code for vnode open operations.  Check permissions, and call
 105  * the VOP_NOPEN or VOP_NCREATE routine.
 106  *
 107  * The caller is responsible for setting up nd with nlookup_init() and
 108  * for cleaning it up with nlookup_done(), whether we return an error
 109  * or not.
 110  *
 111  * On success nd->nl_open_vp will hold a referenced and, if requested,
 112  * locked vnode.  A locked vnode is requested via NLC_LOCKVP.  If fp
 113  * is non-NULL the vnode will be installed in the file pointer.
 114  *
 115  * NOTE: The vnode is referenced just once on return whether or not it
 116  * is also installed in the file pointer.
 117  */
 118 int
 119 vn_open(struct nlookupdata *nd, struct file *fp, int fmode, int cmode)
 120 {
 121         struct vnode *vp;
 122         struct ucred *cred = nd->nl_cred;
 123         struct vattr vat;
 124         struct vattr *vap = &vat;
 125         struct namecache *ncp;
 126         int mode, error;
 127
 128         /*
 129          * Lookup the path and create or obtain the vnode.  After a
 130          * successful lookup a locked nd->nl_ncp will be returned.
 131          *
 132          * The result of this section should be a locked vnode.
 133          *
 134          * XXX with only a little work we should be able to avoid locking
 135          * the vnode if FWRITE, O_CREAT, and O_TRUNC are *not* set.
 136          */
 137         if (fmode & O_CREAT) {
 138                 /*
 139                  * CONDITIONAL CREATE FILE CASE
 140                  *
 141                  * Setting NLC_CREATE causes a negative hit to store
 142                  * the negative hit ncp and not return an error.  Then
 143                  * nc_error or nc_vp may be checked to see if the ncp
 144                  * represents a negative hit.  NLC_CREATE also requires
 145                  * write permission on the governing directory or EPERM
 146                  * is returned.
 147                  */
 148                 if ((fmode & O_EXCL) == 0 && (fmode & O_NOFOLLOW) == 0)
 149                         nd->nl_flags |= NLC_FOLLOW;
 150                 nd->nl_flags |= NLC_CREATE;
 151                 bwillwrite();
 152                 error = nlookup(nd);
 153         } else {
 154                 /*
 155                  * NORMAL OPEN FILE CASE
 156                  */
 157                 error = nlookup(nd);
 158         }
 159
 160         if (error)
 161                 return (error);
 162         ncp = nd->nl_ncp;
 163
 164         /*
 165          * split case to allow us to re-resolve and retry the ncp in case
 166          * we get ESTALE.
 167          */
 168 again:
 169         if (fmode & O_CREAT) {
 170                 if (ncp->nc_vp == NULL) {
 171                         VATTR_NULL(vap);
 172                         vap->va_type = VREG;
 173                         vap->va_mode = cmode;
 174                         if (fmode & O_EXCL)
 175                                 vap->va_vaflags |= VA_EXCLUSIVE;
 176                         error = VOP_NCREATE(ncp, &vp, nd->nl_cred, vap);
 177                         if (error)
 178                                 return (error);
 179                         fmode &= ~O_TRUNC;
 180                         ASSERT_VOP_LOCKED(vp, "create");
 181                         /* locked vnode is returned */
 182                 } else {
 183                         if (fmode & O_EXCL) {
 184                                 error = EEXIST;
 185                         } else {
 186                                 error = cache_vget(ncp, cred,
 187                                                     LK_EXCLUSIVE, &vp);
 188                         }
 189                         if (error)
 190                                 return (error);
 191                         fmode &= ~O_CREAT;
 192                 }
 193         } else {
 194                 error = cache_vget(ncp, cred, LK_EXCLUSIVE, &vp);
 195                 if (error)
 196                         return (error);
 197         }
 198
 199         /*
 200          * We have a locked vnode and ncp now.  Note that the ncp will
 201          * be cleaned up by the caller if nd->nl_ncp is left intact.
 202          */
 203         if (vp->v_type == VLNK) {
 204                 error = EMLINK;
 205                 goto bad;
 206         }
 207         if (vp->v_type == VSOCK) {
 208                 error = EOPNOTSUPP;
 209                 goto bad;
 210         }
 211         if ((fmode & O_CREAT) == 0) {
 212                 mode = 0;
 213                 if (fmode & (FWRITE | O_TRUNC)) {
 214                         if (vp->v_type == VDIR) {
 215                                 error = EISDIR;
 216                                 goto bad;
 217                         }
 218                         error = vn_writechk(vp);
 219                         if (error) {
 220                                 /*
 221                                  * Special stale handling, re-resolve the
 222                                  * vnode.
 223                                  */
 224                                 if (error == ESTALE) {
 225                                         vput(vp);
 226                                         vp = NULL;
 227                                         cache_setunresolved(ncp);
 228                                         error = cache_resolve(ncp, cred);
 229                                         if (error == 0)
 230                                                 goto again;
 231                                 }
 232                                 goto bad;
 233                         }
 234                         mode |= VWRITE;
 235                 }
 236                 if (fmode & FREAD)
 237                         mode |= VREAD;
 238                 if (mode) {
 239                         error = VOP_ACCESS(vp, mode, cred);
 240                         if (error) {
 241                                 /*
 242                                  * Special stale handling, re-resolve the
 243                                  * vnode.
 244                                  */
 245                                 if (error == ESTALE) {
 246                                         vput(vp);
 247                                         vp = NULL;
 248                                         cache_setunresolved(ncp);
 249                                         error = cache_resolve(ncp, cred);
 250                                         if (error == 0)
 251                                                 goto again;
 252                                 }
 253                                 goto bad;
 254                         }
 255                 }
 256         }
 257         if (fmode & O_TRUNC) {
 258                 VOP_UNLOCK(vp, 0);                      /* XXX */
 259                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);   /* XXX */
 260                 VATTR_NULL(vap);
 261                 vap->va_size = 0;
 262                 error = VOP_SETATTR(vp, vap, cred);
 263                 if (error)
 264                         goto bad;
 265         }
 266
 267         /*
 268          * Setup the fp so VOP_OPEN can override it.  No descriptor has been
 269          * associated with the fp yet so we own it clean.  f_ncp inherits
 270          * nl_ncp .
 271          */
 272         if (fp) {
 273                 if (vp->v_type == VDIR) {
 274                         fp->f_ncp = nd->nl_ncp;
 275                         nd->nl_ncp = NULL;
 276                         cache_unlock(fp->f_ncp);
 277                 }
 278         }
 279
 280         /*
 281          * Get rid of nl_ncp.  vn_open does not return it (it returns the
 282          * vnode or the file pointer).  Note: we can't leave nl_ncp locked
 283          * through the VOP_OPEN anyway since the VOP_OPEN may block, e.g.
 284          * on /dev/ttyd0
 285          */
 286         if (nd->nl_ncp) {
 287                 cache_put(nd->nl_ncp);
 288                 nd->nl_ncp = NULL;
 289         }
 290
 291         error = VOP_OPEN(vp, fmode, cred, fp);
 292         if (error) {
 293                 /*
 294                  * setting f_ops to &badfileops will prevent the descriptor
 295                  * code from trying to close and release the vnode, since
 296                  * the open failed we do not want to call close.
 297                  */
 298                 if (fp) {
 299                         fp->f_data = NULL;
 300                         fp->f_ops = &badfileops;
 301                 }
 302                 goto bad;
 303         }
 304
 305 #if 0
 306         /*
 307          * Assert that VREG files have been setup for vmio.
 308          */
 309         KASSERT(vp->v_type != VREG || vp->v_object != NULL,
 310                 ("vn_open: regular file was not VMIO enabled!"));
 311 #endif
 312
 313         /*
 314          * Return the vnode.  XXX needs some cleaning up.  The vnode is
 315          * only returned in the fp == NULL case.
 316          */
 317         if (fp == NULL) {
 318                 nd->nl_open_vp = vp;
 319                 nd->nl_vp_fmode = fmode;
 320                 if ((nd->nl_flags & NLC_LOCKVP) == 0)
 321                         VOP_UNLOCK(vp, 0);
 322         } else {
 323                 vput(vp);
 324         }
 325         return (0);
 326 bad:
 327         if (vp)
 328                 vput(vp);
 329         return (error);
 330 }
 331
 332 /*
 333  * Check for write permissions on the specified vnode.
 334  * Prototype text segments cannot be written.
 335  */
 336 int
 337 vn_writechk(vp)
 338         struct vnode *vp;
 339 {
 340
 341         /*
 342          * If there's shared text associated with
 343          * the vnode, try to free it up once.  If
 344          * we fail, we can't allow writing.
 345          */
 346         if (vp->v_flag & VTEXT)
 347                 return (ETXTBSY);
 348         return (0);
 349 }
 350
 351 /*
 352  * Vnode close call
 353  */
 354 int
 355 vn_close(struct vnode *vp, int flags)
 356 {
 357         int error;
 358
 359         if ((error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY)) == 0) {
 360                 error = VOP_CLOSE(vp, flags);
 361                 VOP_UNLOCK(vp, 0);
 362         }
 363         vrele(vp);
 364         return (error);
 365 }
 366
 367 static __inline
 368 int
 369 sequential_heuristic(struct uio *uio, struct file *fp)
 370 {
 371         /*
 372          * Sequential heuristic - detect sequential operation
 373          */
 374         if ((uio->uio_offset == 0 && fp->f_seqcount > 0) ||
 375             uio->uio_offset == fp->f_nextoff) {
 376                 int tmpseq = fp->f_seqcount;
 377                 /*
 378                  * XXX we assume that the filesystem block size is
 379                  * the default.  Not true, but still gives us a pretty
 380                  * good indicator of how sequential the read operations
 381                  * are.
 382                  */
 383                 tmpseq += (uio->uio_resid + BKVASIZE - 1) / BKVASIZE;
 384                 if (tmpseq > IO_SEQMAX)
 385                         tmpseq = IO_SEQMAX;
 386                 fp->f_seqcount = tmpseq;
 387                 return(fp->f_seqcount << IO_SEQSHIFT);
 388         }
 389
 390         /*
 391          * Not sequential, quick draw-down of seqcount
 392          */
 393         if (fp->f_seqcount > 1)
 394                 fp->f_seqcount = 1;
 395         else
 396                 fp->f_seqcount = 0;
 397         return(0);
 398 }
 399
 400 /*
 401  * Package up an I/O request on a vnode into a uio and do it.
 402  */
 403 int
 404 vn_rdwr(enum uio_rw rw, struct vnode *vp, caddr_t base, int len,
 405         off_t offset, enum uio_seg segflg, int ioflg,
 406         struct ucred *cred, int *aresid)
 407 {
 408         struct uio auio;
 409         struct iovec aiov;
 410         int error;
 411
 412         if ((ioflg & IO_NODELOCKED) == 0)
 413                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 414         auio.uio_iov = &aiov;
 415         auio.uio_iovcnt = 1;
 416         aiov.iov_base = base;
 417         aiov.iov_len = len;
 418         auio.uio_resid = len;
 419         auio.uio_offset = offset;
 420         auio.uio_segflg = segflg;
 421         auio.uio_rw = rw;
 422         auio.uio_td = curthread;
 423         if (rw == UIO_READ) {
 424                 error = VOP_READ(vp, &auio, ioflg, cred);
 425         } else {
 426                 error = VOP_WRITE(vp, &auio, ioflg, cred);
 427         }
 428         if (aresid)
 429                 *aresid = auio.uio_resid;
 430         else
 431                 if (auio.uio_resid && error == 0)
 432                         error = EIO;
 433         if ((ioflg & IO_NODELOCKED) == 0)
 434                 VOP_UNLOCK(vp, 0);
 435         return (error);
 436 }
 437
 438 /*
 439  * Package up an I/O request on a vnode into a uio and do it.  The I/O
 440  * request is split up into smaller chunks and we try to avoid saturating
 441  * the buffer cache while potentially holding a vnode locked, so we
 442  * check bwillwrite() before calling vn_rdwr().  We also call uio_yield()
 443  * to give other processes a chance to lock the vnode (either other processes
 444  * core'ing the same binary, or unrelated processes scanning the directory).
 445  */
 446 int
 447 vn_rdwr_inchunks(enum uio_rw rw, struct vnode *vp, caddr_t base, int len,
 448                  off_t offset, enum uio_seg segflg, int ioflg,
 449                  struct ucred *cred, int *aresid)
 450 {
 451         int error = 0;
 452
 453         do {
 454                 int chunk;
 455
 456                 /*
 457                  * Force `offset' to a multiple of MAXBSIZE except possibly
 458                  * for the first chunk, so that filesystems only need to
 459                  * write full blocks except possibly for the first and last
 460                  * chunks.
 461                  */
 462                 chunk = MAXBSIZE - (uoff_t)offset % MAXBSIZE;
 463
 464                 if (chunk > len)
 465                         chunk = len;
 466                 if (rw != UIO_READ && vp->v_type == VREG)
 467                         bwillwrite();
 468                 error = vn_rdwr(rw, vp, base, chunk, offset, segflg,
 469                             ioflg, cred, aresid);
 470                 len -= chunk;   /* aresid calc already includes length */
 471                 if (error)
 472                         break;
 473                 offset += chunk;
 474                 base += chunk;
 475                 uio_yield();
 476         } while (len);
 477         if (aresid)
 478                 *aresid += len;
 479         return (error);
 480 }
 481
 482 /*
 483  * MPALMOSTSAFE - acquires mplock
 484  */
 485 static int
 486 vn_read(struct file *fp, struct uio *uio, struct ucred *cred, int flags)
 487 {
 488         struct vnode *vp;
 489         int error, ioflag;
 490
 491         get_mplock();
 492         KASSERT(uio->uio_td == curthread,
 493                 ("uio_td %p is not td %p", uio->uio_td, curthread));
 494         vp = (struct vnode *)fp->f_data;
 495         ioflag = 0;
 496         if (fp->f_flag & FNONBLOCK)
 497                 ioflag |= IO_NDELAY;
 498         if (fp->f_flag & O_DIRECT)
 499                 ioflag |= IO_DIRECT;
 500         vn_lock(vp, LK_SHARED | LK_NOPAUSE | LK_RETRY);
 501         if ((flags & FOF_OFFSET) == 0)
 502                 uio->uio_offset = fp->f_offset;
 503
 504         ioflag |= sequential_heuristic(uio, fp);
 505
 506         error = VOP_READ(vp, uio, ioflag, cred);
 507         if ((flags & FOF_OFFSET) == 0)
 508                 fp->f_offset = uio->uio_offset;
 509         fp->f_nextoff = uio->uio_offset;
 510         VOP_UNLOCK(vp, 0);
 511         rel_mplock();
 512         return (error);
 513 }
 514
 515 /*
 516  * Device-optimized file table vnode read routine.
 517  *
 518  * This bypasses the VOP table and talks directly to the device.  Most
 519  * filesystems just route to specfs and can make this optimization.
 520  *
 521  * MPALMOSTSAFE - acquires mplock
 522  */
 523 static int
 524 svn_read(struct file *fp, struct uio *uio, struct ucred *cred, int flags)
 525 {
 526         struct vnode *vp;
 527         int ioflag;
 528         int error;
 529         dev_t dev;
 530
 531         get_mplock();
 532         KASSERT(uio->uio_td == curthread,
 533                 ("uio_td %p is not td %p", uio->uio_td, curthread));
 534
 535         vp = (struct vnode *)fp->f_data;
 536         if (vp == NULL || vp->v_type == VBAD) {
 537                 error = EBADF;
 538                 goto done;
 539         }
 540
 541         if ((dev = vp->v_rdev) == NULL) {
 542                 error = EBADF;
 543                 goto done;
 544         }
 545         reference_dev(dev);
 546
 547         if (uio->uio_resid == 0) {
 548                 error = 0;
 549                 goto done;
 550         }
 551         if ((flags & FOF_OFFSET) == 0)
 552                 uio->uio_offset = fp->f_offset;
 553
 554         ioflag = 0;
 555         if (fp->f_flag & FNONBLOCK)
 556                 ioflag |= IO_NDELAY;
 557         if (fp->f_flag & O_DIRECT)
 558                 ioflag |= IO_DIRECT;
 559         ioflag |= sequential_heuristic(uio, fp);
 560
 561         error = dev_dread(dev, uio, ioflag);
 562
 563         release_dev(dev);
 564         if ((flags & FOF_OFFSET) == 0)
 565                 fp->f_offset = uio->uio_offset;
 566         fp->f_nextoff = uio->uio_offset;
 567 done:
 568         rel_mplock();
 569         return (error);
 570 }
 571
 572 /*
 573  * MPALMOSTSAFE - acquires mplock
 574  */
 575 static int
 576 vn_write(struct file *fp, struct uio *uio, struct ucred *cred, int flags)
 577 {
 578         struct vnode *vp;
 579         int error, ioflag;
 580
 581         get_mplock();
 582         KASSERT(uio->uio_td == curthread,
 583                 ("uio_procp %p is not p %p", uio->uio_td, curthread));
 584         vp = (struct vnode *)fp->f_data;
 585         if (vp->v_type == VREG)
 586                 bwillwrite();
 587         vp = (struct vnode *)fp->f_data;        /* XXX needed? */
 588         ioflag = IO_UNIT;
 589         if (vp->v_type == VREG && (fp->f_flag & O_APPEND))
 590                 ioflag |= IO_APPEND;
 591         if (fp->f_flag & FNONBLOCK)
 592                 ioflag |= IO_NDELAY;
 593         if (fp->f_flag & O_DIRECT)
 594                 ioflag |= IO_DIRECT;
 595         if ((fp->f_flag & O_FSYNC) ||
 596             (vp->v_mount && (vp->v_mount->mnt_flag & MNT_SYNCHRONOUS)))
 597                 ioflag |= IO_SYNC;
 598         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 599         if ((flags & FOF_OFFSET) == 0)
 600                 uio->uio_offset = fp->f_offset;
 601         ioflag |= sequential_heuristic(uio, fp);
 602         error = VOP_WRITE(vp, uio, ioflag, cred);
 603         if ((flags & FOF_OFFSET) == 0)
 604                 fp->f_offset = uio->uio_offset;
 605         fp->f_nextoff = uio->uio_offset;
 606         VOP_UNLOCK(vp, 0);
 607         rel_mplock();
 608         return (error);
 609 }
 610
 611 /*
 612  * Device-optimized file table vnode write routine.
 613  *
 614  * This bypasses the VOP table and talks directly to the device.  Most
 615  * filesystems just route to specfs and can make this optimization.
 616  *
 617  * MPALMOSTSAFE - acquires mplock
 618  */
 619 static int
 620 svn_write(struct file *fp, struct uio *uio, struct ucred *cred, int flags)
 621 {
 622         struct vnode *vp;
 623         int ioflag;
 624         int error;
 625         dev_t dev;
 626
 627         get_mplock();
 628         KASSERT(uio->uio_td == curthread,
 629                 ("uio_procp %p is not p %p", uio->uio_td, curthread));
 630
 631         vp = (struct vnode *)fp->f_data;
 632         if (vp == NULL || vp->v_type == VBAD) {
 633                 error = EBADF;
 634                 goto done;
 635         }
 636         if (vp->v_type == VREG)
 637                 bwillwrite();
 638         vp = (struct vnode *)fp->f_data;        /* XXX needed? */
 639
 640         if ((dev = vp->v_rdev) == NULL) {
 641                 error = EBADF;
 642                 goto done;
 643         }
 644         reference_dev(dev);
 645
 646         if ((flags & FOF_OFFSET) == 0)
 647                 uio->uio_offset = fp->f_offset;
 648
 649         ioflag = IO_UNIT;
 650         if (vp->v_type == VREG && (fp->f_flag & O_APPEND))
 651                 ioflag |= IO_APPEND;
 652         if (fp->f_flag & FNONBLOCK)
 653                 ioflag |= IO_NDELAY;
 654         if (fp->f_flag & O_DIRECT)
 655                 ioflag |= IO_DIRECT;
 656         if ((fp->f_flag & O_FSYNC) ||
 657             (vp->v_mount && (vp->v_mount->mnt_flag & MNT_SYNCHRONOUS)))
 658                 ioflag |= IO_SYNC;
 659         ioflag |= sequential_heuristic(uio, fp);
 660
 661         error = dev_dwrite(dev, uio, ioflag);
 662
 663         release_dev(dev);
 664         if ((flags & FOF_OFFSET) == 0)
 665                 fp->f_offset = uio->uio_offset;
 666         fp->f_nextoff = uio->uio_offset;
 667 done:
 668         rel_mplock();
 669         return (error);
 670 }
 671
 672 /*
 673  * MPALMOSTSAFE - acquires mplock
 674  */
 675 static int
 676 vn_statfile(struct file *fp, struct stat *sb, struct ucred *cred)
 677 {
 678         struct vnode *vp;
 679         int error;
 680
 681         get_mplock();
 682         vp = (struct vnode *)fp->f_data;
 683         error = vn_stat(vp, sb, cred);
 684         rel_mplock();
 685         return (error);
 686 }
 687
 688 int
 689 vn_stat(struct vnode *vp, struct stat *sb, struct ucred *cred)
 690 {
 691         struct vattr vattr;
 692         struct vattr *vap;
 693         int error;
 694         u_short mode;
 695         dev_t dev;
 696
 697         vap = &vattr;
 698         error = VOP_GETATTR(vp, vap);
 699         if (error)
 700                 return (error);
 701
 702         /*
 703          * Zero the spare stat fields
 704          */
 705         sb->st_lspare = 0;
 706         sb->st_qspare = 0;
 707
 708         /*
 709          * Copy from vattr table
 710          */
 711         if (vap->va_fsid != VNOVAL)
 712                 sb->st_dev = vap->va_fsid;
 713         else
 714                 sb->st_dev = vp->v_mount->mnt_stat.f_fsid.val[0];
 715         sb->st_ino = vap->va_fileid;
 716         mode = vap->va_mode;
 717         switch (vap->va_type) {
 718         case VREG:
 719                 mode |= S_IFREG;
 720                 break;
 721         case VDIR:
 722                 mode |= S_IFDIR;
 723                 break;
 724         case VBLK:
 725                 mode |= S_IFBLK;
 726                 break;
 727         case VCHR:
 728                 mode |= S_IFCHR;
 729                 break;
 730         case VLNK:
 731                 mode |= S_IFLNK;
 732                 /* This is a cosmetic change, symlinks do not have a mode. */
 733                 if (vp->v_mount->mnt_flag & MNT_NOSYMFOLLOW)
 734                         sb->st_mode &= ~ACCESSPERMS;    /* 0000 */
 735                 else
 736                         sb->st_mode |= ACCESSPERMS;     /* 0777 */
 737                 break;
 738         case VSOCK:
 739                 mode |= S_IFSOCK;
 740                 break;
 741         case VFIFO:
 742                 mode |= S_IFIFO;
 743                 break;
 744         default:
 745                 return (EBADF);
 746         };
 747         sb->st_mode = mode;
 748         sb->st_nlink = vap->va_nlink;
 749         sb->st_uid = vap->va_uid;
 750         sb->st_gid = vap->va_gid;
 751         sb->st_rdev = vap->va_rdev;
 752         sb->st_size = vap->va_size;
 753         sb->st_atimespec = vap->va_atime;
 754         sb->st_mtimespec = vap->va_mtime;
 755         sb->st_ctimespec = vap->va_ctime;
 756
 757         /*
 758          * A VCHR and VBLK device may track the last access and last modified
 759          * time independantly of the filesystem.  This is particularly true
 760          * because device read and write calls may bypass the filesystem.
 761          */
 762         if (vp->v_type == VCHR || vp->v_type == VBLK) {
 763                 if ((dev = vp->v_rdev) != NULL) {
 764                         if (dev->si_lastread) {
 765                                 sb->st_atimespec.tv_sec = dev->si_lastread;
 766                                 sb->st_atimespec.tv_nsec = 0;
 767                         }
 768                         if (dev->si_lastwrite) {
 769                                 sb->st_atimespec.tv_sec = dev->si_lastwrite;
 770                                 sb->st_atimespec.tv_nsec = 0;
 771                         }
 772                 }
 773         }
 774
 775         /*
 776          * According to www.opengroup.org, the meaning of st_blksize is
 777          *   "a filesystem-specific preferred I/O block size for this
 778          *    object.  In some filesystem types, this may vary from file
 779          *    to file"
 780          * Default to PAGE_SIZE after much discussion.
 781          */
 782
 783         if (vap->va_type == VREG) {
 784                 sb->st_blksize = vap->va_blocksize;
 785         } else if (vn_isdisk(vp, NULL)) {
 786                 /*
 787                  * XXX this is broken.  If the device is not yet open (aka
 788                  * stat() call, aka v_rdev == NULL), how are we supposed
 789                  * to get a valid block size out of it?
 790                  */
 791                 dev_t dev;
 792
 793                 if ((dev = vp->v_rdev) == NULL)
 794                         dev = udev2dev(vp->v_udev, vp->v_type == VBLK);
 795                 sb->st_blksize = dev->si_bsize_best;
 796                 if (sb->st_blksize < dev->si_bsize_phys)
 797                         sb->st_blksize = dev->si_bsize_phys;
 798                 if (sb->st_blksize < BLKDEV_IOSIZE)
 799                         sb->st_blksize = BLKDEV_IOSIZE;
 800         } else {
 801                 sb->st_blksize = PAGE_SIZE;
 802         }
 803
 804         sb->st_flags = vap->va_flags;
 805         if (suser_cred(cred, 0))
 806                 sb->st_gen = 0;
 807         else
 808                 sb->st_gen = vap->va_gen;
 809
 810 #if (S_BLKSIZE == 512)
 811         /* Optimize this case */
 812         sb->st_blocks = vap->va_bytes >> 9;
 813 #else
 814         sb->st_blocks = vap->va_bytes / S_BLKSIZE;
 815 #endif
 816         sb->st_fsmid = vap->va_fsmid;
 817         return (0);
 818 }
 819
 820 /*
 821  * MPALMOSTSAFE - acquires mplock
 822  */
 823 static int
 824 vn_ioctl(struct file *fp, u_long com, caddr_t data, struct ucred *ucred)
 825 {
 826         struct vnode *vp = ((struct vnode *)fp->f_data);
 827         struct vnode *ovp;
 828         struct vattr vattr;
 829         int error;
 830
 831         get_mplock();
 832
 833         switch (vp->v_type) {
 834         case VREG:
 835         case VDIR:
 836                 if (com == FIONREAD) {
 837                         if ((error = VOP_GETATTR(vp, &vattr)) != 0)
 838                                 break;
 839                         *(int *)data = vattr.va_size - fp->f_offset;
 840                         error = 0;
 841                         break;
 842                 }
 843                 if (com == FIONBIO || com == FIOASYNC) {        /* XXX */
 844                         error = 0;                              /* XXX */
 845                         break;
 846                 }
 847                 /* fall into ... */
 848         default:
 849 #if 0
 850                 return (ENOTTY);
 851 #endif
 852         case VFIFO:
 853         case VCHR:
 854         case VBLK:
 855                 if (com == FIODTYPE) {
 856                         if (vp->v_type != VCHR && vp->v_type != VBLK) {
 857                                 error = ENOTTY;
 858                                 break;
 859                         }
 860                         *(int *)data = dev_dflags(vp->v_rdev) & D_TYPEMASK;
 861                         error = 0;
 862                         break;
 863                 }
 864                 error = VOP_IOCTL(vp, com, data, fp->f_flag, ucred);
 865                 if (error == 0 && com == TIOCSCTTY) {
 866                         struct proc *p = curthread->td_proc;
 867                         struct session *sess;
 868
 869                         if (p == NULL) {
 870                                 error = ENOTTY;
 871                                 break;
 872                         }
 873
 874                         sess = p->p_session;
 875                         /* Do nothing if reassigning same control tty */
 876                         if (sess->s_ttyvp == vp) {
 877                                 error = 0;
 878                                 break;
 879                         }
 880
 881                         /* Get rid of reference to old control tty */
 882                         ovp = sess->s_ttyvp;
 883                         vref(vp);
 884                         sess->s_ttyvp = vp;
 885                         if (ovp)
 886                                 vrele(ovp);
 887                 }
 888                 break;
 889         }
 890         rel_mplock();
 891         return (error);
 892 }
 893
 894 /*
 895  * MPALMOSTSAFE - acquires mplock
 896  */
 897 static int
 898 vn_poll(struct file *fp, int events, struct ucred *cred)
 899 {
 900         int error;
 901
 902         get_mplock();
 903         error = VOP_POLL(((struct vnode *)fp->f_data), events, cred);
 904         rel_mplock();
 905         return (error);
 906 }
 907
 908 /*
 909  * Check that the vnode is still valid, and if so
 910  * acquire requested lock.
 911  */
 912 int
 913 #ifndef DEBUG_LOCKS
 914 vn_lock(struct vnode *vp, int flags)
 915 #else
 916 debug_vn_lock(struct vnode *vp, int flags, const char *filename, int line)
 917 #endif
 918 {
 919         int error;
 920
 921         do {
 922 #ifdef  DEBUG_LOCKS
 923                 vp->filename = filename;
 924                 vp->line = line;
 925 #endif
 926                 error = VOP_LOCK(vp, flags | LK_NOPAUSE);
 927                 if (error == 0)
 928                         break;
 929         } while (flags & LK_RETRY);
 930
 931         /*
 932          * Because we (had better!) have a ref on the vnode, once it
 933          * goes to VRECLAIMED state it will not be recycled until all
 934          * refs go away.  So we can just check the flag.
 935          */
 936         if (error == 0 && (vp->v_flag & VRECLAIMED)) {
 937                 VOP_UNLOCK(vp, 0);
 938                 error = ENOENT;
 939         }
 940         return (error);
 941 }
 942
 943 /*
 944  * MPALMOSTSAFE - acquires mplock
 945  */
 946 static int
 947 vn_closefile(struct file *fp)
 948 {
 949         int error;
 950
 951         get_mplock();
 952         fp->f_ops = &badfileops;
 953         error = vn_close(((struct vnode *)fp->f_data), fp->f_flag);
 954         rel_mplock();
 955         return(error);
 956 }
 957
 958 /*
 959  * MPALMOSTSAFE - acquires mplock
 960  */
 961 static int
 962 vn_kqfilter(struct file *fp, struct knote *kn)
 963 {
 964         int error;
 965
 966         get_mplock();
 967         error = VOP_KQFILTER(((struct vnode *)fp->f_data), kn);
 968         rel_mplock();
 969         return (error);
 970 }