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