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  * 4. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  *      @(#)vfs_vnops.c 8.2 (Berkeley) 1/21/94
  35  */
  36
  37 #include <sys/cdefs.h>
  38 __FBSDID("$FreeBSD$");
  39
  40 #include "opt_mac.h"
  41
  42 #include <sys/param.h>
  43 #include <sys/systm.h>
  44 #include <sys/fcntl.h>
  45 #include <sys/file.h>
  46 #include <sys/kdb.h>
  47 #include <sys/stat.h>
  48 #include <sys/priv.h>
  49 #include <sys/proc.h>
  50 #include <sys/limits.h>
  51 #include <sys/lock.h>
  52 #include <sys/mount.h>
  53 #include <sys/mutex.h>
  54 #include <sys/namei.h>
  55 #include <sys/vnode.h>
  56 #include <sys/bio.h>
  57 #include <sys/buf.h>
  58 #include <sys/filio.h>
  59 #include <sys/sx.h>
  60 #include <sys/ttycom.h>
  61 #include <sys/conf.h>
  62 #include <sys/syslog.h>
  63 #include <sys/unistd.h>
  64
  65 #include <security/mac/mac_framework.h>
  66
  67 static fo_rdwr_t        vn_read;
  68 static fo_rdwr_t        vn_write;
  69 static fo_ioctl_t       vn_ioctl;
  70 static fo_poll_t        vn_poll;
  71 static fo_kqfilter_t    vn_kqfilter;
  72 static fo_stat_t        vn_statfile;
  73 static fo_close_t       vn_closefile;
  74
  75 struct  fileops vnops = {
  76         .fo_read = vn_read,
  77         .fo_write = vn_write,
  78         .fo_ioctl = vn_ioctl,
  79         .fo_poll = vn_poll,
  80         .fo_kqfilter = vn_kqfilter,
  81         .fo_stat = vn_statfile,
  82         .fo_close = vn_closefile,
  83         .fo_flags = DFLAG_PASSABLE | DFLAG_SEEKABLE
  84 };
  85
  86 int
  87 vn_open(ndp, flagp, cmode, fp)
  88         struct nameidata *ndp;
  89         int *flagp, cmode;
  90         struct file *fp;
  91 {
  92         struct thread *td = ndp->ni_cnd.cn_thread;
  93
  94         return (vn_open_cred(ndp, flagp, cmode, td->td_ucred, fp));
  95 }
  96
  97 /*
  98  * Common code for vnode open operations.
  99  * Check permissions, and call the VOP_OPEN or VOP_CREATE routine.
 100  *
 101  * Note that this does NOT free nameidata for the successful case,
 102  * due to the NDINIT being done elsewhere.
 103  */
 104 int
 105 vn_open_cred(ndp, flagp, cmode, cred, fp)
 106         struct nameidata *ndp;
 107         int *flagp, cmode;
 108         struct ucred *cred;
 109         struct file *fp;
 110 {
 111         struct vnode *vp;
 112         struct mount *mp;
 113         struct thread *td = ndp->ni_cnd.cn_thread;
 114         struct vattr vat;
 115         struct vattr *vap = &vat;
 116         int mode, fmode, error;
 117         int vfslocked, mpsafe;
 118
 119         mpsafe = ndp->ni_cnd.cn_flags & MPSAFE;
 120 restart:
 121         vfslocked = 0;
 122         fmode = *flagp;
 123         if (fmode & O_CREAT) {
 124                 ndp->ni_cnd.cn_nameiop = CREATE;
 125                 ndp->ni_cnd.cn_flags = ISOPEN | LOCKPARENT | LOCKLEAF |
 126                     MPSAFE | AUDITVNODE1;
 127                 if ((fmode & O_EXCL) == 0 && (fmode & O_NOFOLLOW) == 0)
 128                         ndp->ni_cnd.cn_flags |= FOLLOW;
 129                 bwillwrite();
 130                 if ((error = namei(ndp)) != 0)
 131                         return (error);
 132                 vfslocked = NDHASGIANT(ndp);
 133                 if (!mpsafe)
 134                         ndp->ni_cnd.cn_flags &= ~MPSAFE;
 135                 if (ndp->ni_vp == NULL) {
 136                         VATTR_NULL(vap);
 137                         vap->va_type = VREG;
 138                         vap->va_mode = cmode;
 139                         if (fmode & O_EXCL)
 140                                 vap->va_vaflags |= VA_EXCLUSIVE;
 141                         if (vn_start_write(ndp->ni_dvp, &mp, V_NOWAIT) != 0) {
 142                                 NDFREE(ndp, NDF_ONLY_PNBUF);
 143                                 vput(ndp->ni_dvp);
 144                                 VFS_UNLOCK_GIANT(vfslocked);
 145                                 if ((error = vn_start_write(NULL, &mp,
 146                                     V_XSLEEP | PCATCH)) != 0)
 147                                         return (error);
 148                                 goto restart;
 149                         }
 150 #ifdef MAC
 151                         error = mac_check_vnode_create(cred, ndp->ni_dvp,
 152                             &ndp->ni_cnd, vap);
 153                         if (error == 0) {
 154 #endif
 155                                 VOP_LEASE(ndp->ni_dvp, td, cred, LEASE_WRITE);
 156                                 error = VOP_CREATE(ndp->ni_dvp, &ndp->ni_vp,
 157                                                    &ndp->ni_cnd, vap);
 158 #ifdef MAC
 159                         }
 160 #endif
 161                         vput(ndp->ni_dvp);
 162                         vn_finished_write(mp);
 163                         if (error) {
 164                                 VFS_UNLOCK_GIANT(vfslocked);
 165                                 NDFREE(ndp, NDF_ONLY_PNBUF);
 166                                 return (error);
 167                         }
 168                         fmode &= ~O_TRUNC;
 169                         vp = ndp->ni_vp;
 170                 } else {
 171                         if (ndp->ni_dvp == ndp->ni_vp)
 172                                 vrele(ndp->ni_dvp);
 173                         else
 174                                 vput(ndp->ni_dvp);
 175                         ndp->ni_dvp = NULL;
 176                         vp = ndp->ni_vp;
 177                         if (fmode & O_EXCL) {
 178                                 error = EEXIST;
 179                                 goto bad;
 180                         }
 181                         fmode &= ~O_CREAT;
 182                 }
 183         } else {
 184                 ndp->ni_cnd.cn_nameiop = LOOKUP;
 185                 ndp->ni_cnd.cn_flags = ISOPEN |
 186                     ((fmode & O_NOFOLLOW) ? NOFOLLOW : FOLLOW) |
 187                     LOCKLEAF | MPSAFE | AUDITVNODE1;
 188                 if ((error = namei(ndp)) != 0)
 189                         return (error);
 190                 if (!mpsafe)
 191                         ndp->ni_cnd.cn_flags &= ~MPSAFE;
 192                 vfslocked = NDHASGIANT(ndp);
 193                 vp = ndp->ni_vp;
 194         }
 195         if (vp->v_type == VLNK) {
 196                 error = EMLINK;
 197                 goto bad;
 198         }
 199         if (vp->v_type == VSOCK) {
 200                 error = EOPNOTSUPP;
 201                 goto bad;
 202         }
 203         mode = 0;
 204         if (fmode & (FWRITE | O_TRUNC)) {
 205                 if (vp->v_type == VDIR) {
 206                         error = EISDIR;
 207                         goto bad;
 208                 }
 209                 mode |= VWRITE;
 210         }
 211         if (fmode & FREAD)
 212                 mode |= VREAD;
 213         if (fmode & O_APPEND)
 214                 mode |= VAPPEND;
 215 #ifdef MAC
 216         error = mac_check_vnode_open(cred, vp, mode);
 217         if (error)
 218                 goto bad;
 219 #endif
 220         if ((fmode & O_CREAT) == 0) {
 221                 if (mode & VWRITE) {
 222                         error = vn_writechk(vp);
 223                         if (error)
 224                                 goto bad;
 225                 }
 226                 if (mode) {
 227                         error = VOP_ACCESS(vp, mode, cred, td);
 228                         if (error)
 229                                 goto bad;
 230                 }
 231         }
 232         if ((error = VOP_OPEN(vp, fmode, cred, td, fp)) != 0)
 233                 goto bad;
 234
 235         if (fmode & FWRITE)
 236                 vp->v_writecount++;
 237         *flagp = fmode;
 238         ASSERT_VOP_ELOCKED(vp, "vn_open_cred");
 239         if (!mpsafe)
 240                 VFS_UNLOCK_GIANT(vfslocked);
 241         return (0);
 242 bad:
 243         NDFREE(ndp, NDF_ONLY_PNBUF);
 244         vput(vp);
 245         VFS_UNLOCK_GIANT(vfslocked);
 246         *flagp = fmode;
 247         ndp->ni_vp = NULL;
 248         return (error);
 249 }
 250
 251 /*
 252  * Check for write permissions on the specified vnode.
 253  * Prototype text segments cannot be written.
 254  */
 255 int
 256 vn_writechk(vp)
 257         register struct vnode *vp;
 258 {
 259
 260         ASSERT_VOP_LOCKED(vp, "vn_writechk");
 261         /*
 262          * If there's shared text associated with
 263          * the vnode, try to free it up once.  If
 264          * we fail, we can't allow writing.
 265          */
 266         if (vp->v_vflag & VV_TEXT)
 267                 return (ETXTBSY);
 268
 269         return (0);
 270 }
 271
 272 /*
 273  * Vnode close call
 274  */
 275 int
 276 vn_close(vp, flags, file_cred, td)
 277         register struct vnode *vp;
 278         int flags;
 279         struct ucred *file_cred;
 280         struct thread *td;
 281 {
 282         struct mount *mp;
 283         int error;
 284
 285         VFS_ASSERT_GIANT(vp->v_mount);
 286
 287         vn_start_write(vp, &mp, V_WAIT);
 288         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
 289         if (flags & FWRITE) {
 290                 VNASSERT(vp->v_writecount > 0, vp,
 291                     ("vn_close: negative writecount"));
 292                 vp->v_writecount--;
 293         }
 294         error = VOP_CLOSE(vp, flags, file_cred, td);
 295         vput(vp);
 296         vn_finished_write(mp);
 297         return (error);
 298 }
 299
 300 /*
 301  * Sequential heuristic - detect sequential operation
 302  */
 303 static __inline
 304 int
 305 sequential_heuristic(struct uio *uio, struct file *fp)
 306 {
 307
 308         if ((uio->uio_offset == 0 && fp->f_seqcount > 0) ||
 309             uio->uio_offset == fp->f_nextoff) {
 310                 /*
 311                  * XXX we assume that the filesystem block size is
 312                  * the default.  Not true, but still gives us a pretty
 313                  * good indicator of how sequential the read operations
 314                  * are.
 315                  */
 316                 fp->f_seqcount += (uio->uio_resid + BKVASIZE - 1) / BKVASIZE;
 317                 if (fp->f_seqcount > IO_SEQMAX)
 318                         fp->f_seqcount = IO_SEQMAX;
 319                 return(fp->f_seqcount << IO_SEQSHIFT);
 320         }
 321
 322         /*
 323          * Not sequential, quick draw-down of seqcount
 324          */
 325         if (fp->f_seqcount > 1)
 326                 fp->f_seqcount = 1;
 327         else
 328                 fp->f_seqcount = 0;
 329         return(0);
 330 }
 331
 332 /*
 333  * Package up an I/O request on a vnode into a uio and do it.
 334  */
 335 int
 336 vn_rdwr(rw, vp, base, len, offset, segflg, ioflg, active_cred, file_cred,
 337     aresid, td)
 338         enum uio_rw rw;
 339         struct vnode *vp;
 340         void *base;
 341         int len;
 342         off_t offset;
 343         enum uio_seg segflg;
 344         int ioflg;
 345         struct ucred *active_cred;
 346         struct ucred *file_cred;
 347         int *aresid;
 348         struct thread *td;
 349 {
 350         struct uio auio;
 351         struct iovec aiov;
 352         struct mount *mp;
 353         struct ucred *cred;
 354         int error;
 355
 356         VFS_ASSERT_GIANT(vp->v_mount);
 357
 358         if ((ioflg & IO_NODELOCKED) == 0) {
 359                 mp = NULL;
 360                 if (rw == UIO_WRITE) {
 361                         if (vp->v_type != VCHR &&
 362                             (error = vn_start_write(vp, &mp, V_WAIT | PCATCH))
 363                             != 0)
 364                                 return (error);
 365                         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
 366                 } else {
 367                         /*
 368                          * XXX This should be LK_SHARED but I don't trust VFS
 369                          * enough to leave it like that until it has been
 370                          * reviewed further.
 371                          */
 372                         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
 373                 }
 374
 375         }
 376         ASSERT_VOP_LOCKED(vp, "IO_NODELOCKED with no vp lock held");
 377         auio.uio_iov = &aiov;
 378         auio.uio_iovcnt = 1;
 379         aiov.iov_base = base;
 380         aiov.iov_len = len;
 381         auio.uio_resid = len;
 382         auio.uio_offset = offset;
 383         auio.uio_segflg = segflg;
 384         auio.uio_rw = rw;
 385         auio.uio_td = td;
 386         error = 0;
 387 #ifdef MAC
 388         if ((ioflg & IO_NOMACCHECK) == 0) {
 389                 if (rw == UIO_READ)
 390                         error = mac_check_vnode_read(active_cred, file_cred,
 391                             vp);
 392                 else
 393                         error = mac_check_vnode_write(active_cred, file_cred,
 394                             vp);
 395         }
 396 #endif
 397         if (error == 0) {
 398                 if (file_cred)
 399                         cred = file_cred;
 400                 else
 401                         cred = active_cred;
 402                 if (rw == UIO_READ)
 403                         error = VOP_READ(vp, &auio, ioflg, cred);
 404                 else
 405                         error = VOP_WRITE(vp, &auio, ioflg, cred);
 406         }
 407         if (aresid)
 408                 *aresid = auio.uio_resid;
 409         else
 410                 if (auio.uio_resid && error == 0)
 411                         error = EIO;
 412         if ((ioflg & IO_NODELOCKED) == 0) {
 413                 if (rw == UIO_WRITE && vp->v_type != VCHR)
 414                         vn_finished_write(mp);
 415                 VOP_UNLOCK(vp, 0, td);
 416         }
 417         return (error);
 418 }
 419
 420 /*
 421  * Package up an I/O request on a vnode into a uio and do it.  The I/O
 422  * request is split up into smaller chunks and we try to avoid saturating
 423  * the buffer cache while potentially holding a vnode locked, so we
 424  * check bwillwrite() before calling vn_rdwr().  We also call uio_yield()
 425  * to give other processes a chance to lock the vnode (either other processes
 426  * core'ing the same binary, or unrelated processes scanning the directory).
 427  */
 428 int
 429 vn_rdwr_inchunks(rw, vp, base, len, offset, segflg, ioflg, active_cred,
 430     file_cred, aresid, td)
 431         enum uio_rw rw;
 432         struct vnode *vp;
 433         void *base;
 434         size_t len;
 435         off_t offset;
 436         enum uio_seg segflg;
 437         int ioflg;
 438         struct ucred *active_cred;
 439         struct ucred *file_cred;
 440         size_t *aresid;
 441         struct thread *td;
 442 {
 443         int error = 0;
 444         int iaresid;
 445
 446         VFS_ASSERT_GIANT(vp->v_mount);
 447
 448         do {
 449                 int chunk;
 450
 451                 /*
 452                  * Force `offset' to a multiple of MAXBSIZE except possibly
 453                  * for the first chunk, so that filesystems only need to
 454                  * write full blocks except possibly for the first and last
 455                  * chunks.
 456                  */
 457                 chunk = MAXBSIZE - (uoff_t)offset % MAXBSIZE;
 458
 459                 if (chunk > len)
 460                         chunk = len;
 461                 if (rw != UIO_READ && vp->v_type == VREG)
 462                         bwillwrite();
 463                 iaresid = 0;
 464                 error = vn_rdwr(rw, vp, base, chunk, offset, segflg,
 465                     ioflg, active_cred, file_cred, &iaresid, td);
 466                 len -= chunk;   /* aresid calc already includes length */
 467                 if (error)
 468                         break;
 469                 offset += chunk;
 470                 base = (char *)base + chunk;
 471                 uio_yield();
 472         } while (len);
 473         if (aresid)
 474                 *aresid = len + iaresid;
 475         return (error);
 476 }
 477
 478 /*
 479  * File table vnode read routine.
 480  */
 481 static int
 482 vn_read(fp, uio, active_cred, flags, td)
 483         struct file *fp;
 484         struct uio *uio;
 485         struct ucred *active_cred;
 486         struct thread *td;
 487         int flags;
 488 {
 489         struct vnode *vp;
 490         int error, ioflag;
 491         int vfslocked;
 492
 493         KASSERT(uio->uio_td == td, ("uio_td %p is not td %p",
 494             uio->uio_td, td));
 495         vp = fp->f_vnode;
 496         ioflag = 0;
 497         if (fp->f_flag & FNONBLOCK)
 498                 ioflag |= IO_NDELAY;
 499         if (fp->f_flag & O_DIRECT)
 500                 ioflag |= IO_DIRECT;
 501         vfslocked = VFS_LOCK_GIANT(vp->v_mount);
 502         VOP_LEASE(vp, td, fp->f_cred, LEASE_READ);
 503         /*
 504          * According to McKusick the vn lock was protecting f_offset here.
 505          * It is now protected by the FOFFSET_LOCKED flag.
 506          */
 507         if ((flags & FOF_OFFSET) == 0) {
 508                 FILE_LOCK(fp);
 509                 while(fp->f_vnread_flags & FOFFSET_LOCKED) {
 510                         fp->f_vnread_flags |= FOFFSET_LOCK_WAITING;
 511                         msleep(&fp->f_vnread_flags,fp->f_mtxp,PUSER -1,"vnread offlock",0);
 512                 }
 513                 fp->f_vnread_flags |= FOFFSET_LOCKED;
 514                 FILE_UNLOCK(fp);
 515                 vn_lock(vp, LK_SHARED | LK_RETRY, td);
 516                 uio->uio_offset = fp->f_offset;
 517         } else
 518                 vn_lock(vp, LK_SHARED | LK_RETRY, td);
 519
 520         ioflag |= sequential_heuristic(uio, fp);
 521
 522 #ifdef MAC
 523         error = mac_check_vnode_read(active_cred, fp->f_cred, vp);
 524         if (error == 0)
 525 #endif
 526                 error = VOP_READ(vp, uio, ioflag, fp->f_cred);
 527         if ((flags & FOF_OFFSET) == 0) {
 528                 fp->f_offset = uio->uio_offset;
 529                 FILE_LOCK(fp);
 530                 if (fp->f_vnread_flags & FOFFSET_LOCK_WAITING)
 531                         wakeup(&fp->f_vnread_flags);
 532                 fp->f_vnread_flags = 0;
 533                 FILE_UNLOCK(fp);
 534         }
 535         fp->f_nextoff = uio->uio_offset;
 536         VOP_UNLOCK(vp, 0, td);
 537         VFS_UNLOCK_GIANT(vfslocked);
 538         return (error);
 539 }
 540
 541 /*
 542  * File table vnode write routine.
 543  */
 544 static int
 545 vn_write(fp, uio, active_cred, flags, td)
 546         struct file *fp;
 547         struct uio *uio;
 548         struct ucred *active_cred;
 549         struct thread *td;
 550         int flags;
 551 {
 552         struct vnode *vp;
 553         struct mount *mp;
 554         int error, ioflag;
 555         int vfslocked;
 556
 557         KASSERT(uio->uio_td == td, ("uio_td %p is not td %p",
 558             uio->uio_td, td));
 559         vp = fp->f_vnode;
 560         vfslocked = VFS_LOCK_GIANT(vp->v_mount);
 561         if (vp->v_type == VREG)
 562                 bwillwrite();
 563         ioflag = IO_UNIT;
 564         if (vp->v_type == VREG && (fp->f_flag & O_APPEND))
 565                 ioflag |= IO_APPEND;
 566         if (fp->f_flag & FNONBLOCK)
 567                 ioflag |= IO_NDELAY;
 568         if (fp->f_flag & O_DIRECT)
 569                 ioflag |= IO_DIRECT;
 570         if ((fp->f_flag & O_FSYNC) ||
 571             (vp->v_mount && (vp->v_mount->mnt_flag & MNT_SYNCHRONOUS)))
 572                 ioflag |= IO_SYNC;
 573         mp = NULL;
 574         if (vp->v_type != VCHR &&
 575             (error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0)
 576                 goto unlock;
 577         VOP_LEASE(vp, td, fp->f_cred, LEASE_WRITE);
 578         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
 579         if ((flags & FOF_OFFSET) == 0)
 580                 uio->uio_offset = fp->f_offset;
 581         ioflag |= sequential_heuristic(uio, fp);
 582 #ifdef MAC
 583         error = mac_check_vnode_write(active_cred, fp->f_cred, vp);
 584         if (error == 0)
 585 #endif
 586                 error = VOP_WRITE(vp, uio, ioflag, fp->f_cred);
 587         if ((flags & FOF_OFFSET) == 0)
 588                 fp->f_offset = uio->uio_offset;
 589         fp->f_nextoff = uio->uio_offset;
 590         VOP_UNLOCK(vp, 0, td);
 591         if (vp->v_type != VCHR)
 592                 vn_finished_write(mp);
 593 unlock:
 594         VFS_UNLOCK_GIANT(vfslocked);
 595         return (error);
 596 }
 597
 598 /*
 599  * File table vnode stat routine.
 600  */
 601 static int
 602 vn_statfile(fp, sb, active_cred, td)
 603         struct file *fp;
 604         struct stat *sb;
 605         struct ucred *active_cred;
 606         struct thread *td;
 607 {
 608         struct vnode *vp = fp->f_vnode;
 609         int vfslocked;
 610         int error;
 611
 612         vfslocked = VFS_LOCK_GIANT(vp->v_mount);
 613         vn_lock(vp, LK_SHARED | LK_RETRY, td);
 614         error = vn_stat(vp, sb, active_cred, fp->f_cred, td);
 615         VOP_UNLOCK(vp, 0, td);
 616         VFS_UNLOCK_GIANT(vfslocked);
 617
 618         return (error);
 619 }
 620
 621 /*
 622  * Stat a vnode; implementation for the stat syscall
 623  */
 624 int
 625 vn_stat(vp, sb, active_cred, file_cred, td)
 626         struct vnode *vp;
 627         register struct stat *sb;
 628         struct ucred *active_cred;
 629         struct ucred *file_cred;
 630         struct thread *td;
 631 {
 632         struct vattr vattr;
 633         register struct vattr *vap;
 634         int error;
 635         u_short mode;
 636
 637 #ifdef MAC
 638         error = mac_check_vnode_stat(active_cred, file_cred, vp);
 639         if (error)
 640                 return (error);
 641 #endif
 642
 643         vap = &vattr;
 644
 645         /*
 646          * Initialize defaults for new and unusual fields, so that file
 647          * systems which don't support these fields don't need to know
 648          * about them.
 649          */
 650         vap->va_birthtime.tv_sec = -1;
 651         vap->va_birthtime.tv_nsec = 0;
 652         vap->va_fsid = VNOVAL;
 653         vap->va_rdev = NODEV;
 654
 655         error = VOP_GETATTR(vp, vap, active_cred, td);
 656         if (error)
 657                 return (error);
 658
 659         /*
 660          * Zero the spare stat fields
 661          */
 662         bzero(sb, sizeof *sb);
 663
 664         /*
 665          * Copy from vattr table
 666          */
 667         if (vap->va_fsid != VNOVAL)
 668                 sb->st_dev = vap->va_fsid;
 669         else
 670                 sb->st_dev = vp->v_mount->mnt_stat.f_fsid.val[0];
 671         sb->st_ino = vap->va_fileid;
 672         mode = vap->va_mode;
 673         switch (vap->va_type) {
 674         case VREG:
 675                 mode |= S_IFREG;
 676                 break;
 677         case VDIR:
 678                 mode |= S_IFDIR;
 679                 break;
 680         case VBLK:
 681                 mode |= S_IFBLK;
 682                 break;
 683         case VCHR:
 684                 mode |= S_IFCHR;
 685                 break;
 686         case VLNK:
 687                 mode |= S_IFLNK;
 688                 break;
 689         case VSOCK:
 690                 mode |= S_IFSOCK;
 691                 break;
 692         case VFIFO:
 693                 mode |= S_IFIFO;
 694                 break;
 695         default:
 696                 return (EBADF);
 697         };
 698         sb->st_mode = mode;
 699         sb->st_nlink = vap->va_nlink;
 700         sb->st_uid = vap->va_uid;
 701         sb->st_gid = vap->va_gid;
 702         sb->st_rdev = vap->va_rdev;
 703         if (vap->va_size > OFF_MAX)
 704                 return (EOVERFLOW);
 705         sb->st_size = vap->va_size;
 706         sb->st_atimespec = vap->va_atime;
 707         sb->st_mtimespec = vap->va_mtime;
 708         sb->st_ctimespec = vap->va_ctime;
 709         sb->st_birthtimespec = vap->va_birthtime;
 710
 711         /*
 712          * According to www.opengroup.org, the meaning of st_blksize is
 713          *   "a filesystem-specific preferred I/O block size for this
 714          *    object.  In some filesystem types, this may vary from file
 715          *    to file"
 716          * Default to PAGE_SIZE after much discussion.
 717          * XXX: min(PAGE_SIZE, vp->v_bufobj.bo_bsize) may be more correct.
 718          */
 719
 720         sb->st_blksize = PAGE_SIZE;
 721
 722         sb->st_flags = vap->va_flags;
 723         if (priv_check(td, PRIV_VFS_GENERATION))
 724                 sb->st_gen = 0;
 725         else
 726                 sb->st_gen = vap->va_gen;
 727
 728         sb->st_blocks = vap->va_bytes / S_BLKSIZE;
 729         return (0);
 730 }
 731
 732 /*
 733  * File table vnode ioctl routine.
 734  */
 735 static int
 736 vn_ioctl(fp, com, data, active_cred, td)
 737         struct file *fp;
 738         u_long com;
 739         void *data;
 740         struct ucred *active_cred;
 741         struct thread *td;
 742 {
 743         struct vnode *vp = fp->f_vnode;
 744         struct vattr vattr;
 745         int vfslocked;
 746         int error;
 747
 748         vfslocked = VFS_LOCK_GIANT(vp->v_mount);
 749         error = ENOTTY;
 750         switch (vp->v_type) {
 751         case VREG:
 752         case VDIR:
 753                 if (com == FIONREAD) {
 754                         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
 755                         error = VOP_GETATTR(vp, &vattr, active_cred, td);
 756                         VOP_UNLOCK(vp, 0, td);
 757                         if (!error)
 758                                 *(int *)data = vattr.va_size - fp->f_offset;
 759                 }
 760                 if (com == FIONBIO || com == FIOASYNC)  /* XXX */
 761                         error = 0;
 762                 else
 763                         error = VOP_IOCTL(vp, com, data, fp->f_flag,
 764                             active_cred, td);
 765                 break;
 766
 767         default:
 768                 break;
 769         }
 770         VFS_UNLOCK_GIANT(vfslocked);
 771         return (error);
 772 }
 773
 774 /*
 775  * File table vnode poll routine.
 776  */
 777 static int
 778 vn_poll(fp, events, active_cred, td)
 779         struct file *fp;
 780         int events;
 781         struct ucred *active_cred;
 782         struct thread *td;
 783 {
 784         struct vnode *vp;
 785         int vfslocked;
 786         int error;
 787
 788         vp = fp->f_vnode;
 789         vfslocked = VFS_LOCK_GIANT(vp->v_mount);
 790 #ifdef MAC
 791         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
 792         error = mac_check_vnode_poll(active_cred, fp->f_cred, vp);
 793         VOP_UNLOCK(vp, 0, td);
 794         if (!error)
 795 #endif
 796
 797         error = VOP_POLL(vp, events, fp->f_cred, td);
 798         VFS_UNLOCK_GIANT(vfslocked);
 799         return (error);
 800 }
 801
 802 /*
 803  * Check that the vnode is still valid, and if so
 804  * acquire requested lock.
 805  */
 806 int
 807 _vn_lock(struct vnode *vp, int flags, struct thread *td, char *file, int line)
 808 {
 809         int error;
 810
 811         do {
 812                 if ((flags & LK_INTERLOCK) == 0)
 813                         VI_LOCK(vp);
 814 #ifdef DEBUG_VFS_LOCKS
 815                 KASSERT(vp->v_holdcnt != 0,
 816                     ("vn_lock %p: zero hold count", vp));
 817 #endif
 818                 if ((flags & LK_NOWAIT || (flags & LK_TYPE_MASK) == 0) &&
 819                     vp->v_iflag & VI_DOOMED) {
 820                         VI_UNLOCK(vp);
 821                         return (ENOENT);
 822                 }
 823                 /*
 824                  * Just polling to check validity.
 825                  */
 826                 if ((flags & LK_TYPE_MASK) == 0) {
 827                         VI_UNLOCK(vp);
 828                         return (0);
 829                 }
 830                 /*
 831                  * lockmgr drops interlock before it will return for
 832                  * any reason.  So force the code above to relock it.
 833                  */
 834                 error = VOP_LOCK1(vp, flags | LK_INTERLOCK, td, file, line);
 835                 flags &= ~LK_INTERLOCK;
 836                 KASSERT((flags & LK_RETRY) == 0 || error == 0,
 837                     ("LK_RETRY set with incompatible flags %d\n", flags));
 838                 /*
 839                  * Callers specify LK_RETRY if they wish to get dead vnodes.
 840                  * If RETRY is not set, we return ENOENT instead.
 841                  */
 842                 if (error == 0 && vp->v_iflag & VI_DOOMED &&
 843                     (flags & LK_RETRY) == 0) {
 844                         VOP_UNLOCK(vp, 0, td);
 845                         error = ENOENT;
 846                         break;
 847                 }
 848         } while (flags & LK_RETRY && error != 0);
 849         return (error);
 850 }
 851
 852 /*
 853  * File table vnode close routine.
 854  */
 855 static int
 856 vn_closefile(fp, td)
 857         struct file *fp;
 858         struct thread *td;
 859 {
 860         struct vnode *vp;
 861         struct flock lf;
 862         int vfslocked;
 863         int error;
 864
 865         vp = fp->f_vnode;
 866
 867         vfslocked = VFS_LOCK_GIANT(vp->v_mount);
 868         if (fp->f_type == DTYPE_VNODE && fp->f_flag & FHASLOCK) {
 869                 lf.l_whence = SEEK_SET;
 870                 lf.l_start = 0;
 871                 lf.l_len = 0;
 872                 lf.l_type = F_UNLCK;
 873                 (void) VOP_ADVLOCK(vp, fp, F_UNLCK, &lf, F_FLOCK);
 874         }
 875
 876         fp->f_ops = &badfileops;
 877
 878         error = vn_close(vp, fp->f_flag, fp->f_cred, td);
 879         VFS_UNLOCK_GIANT(vfslocked);
 880         return (error);
 881 }
 882
 883 /*
 884  * Preparing to start a filesystem write operation. If the operation is
 885  * permitted, then we bump the count of operations in progress and
 886  * proceed. If a suspend request is in progress, we wait until the
 887  * suspension is over, and then proceed.
 888  */
 889 int
 890 vn_start_write(vp, mpp, flags)
 891         struct vnode *vp;
 892         struct mount **mpp;
 893         int flags;
 894 {
 895         struct mount *mp;
 896         int error;
 897
 898         error = 0;
 899         /*
 900          * If a vnode is provided, get and return the mount point that
 901          * to which it will write.
 902          */
 903         if (vp != NULL) {
 904                 if ((error = VOP_GETWRITEMOUNT(vp, mpp)) != 0) {
 905                         *mpp = NULL;
 906                         if (error != EOPNOTSUPP)
 907                                 return (error);
 908                         return (0);
 909                 }
 910         }
 911         if ((mp = *mpp) == NULL)
 912                 return (0);
 913         MNT_ILOCK(mp);
 914         if (vp == NULL)
 915                 MNT_REF(mp);
 916         /*
 917          * Check on status of suspension.
 918          */
 919         if ((curthread->td_pflags & TDP_IGNSUSP) == 0 ||
 920             mp->mnt_susp_owner != curthread) {
 921                 while ((mp->mnt_kern_flag & MNTK_SUSPEND) != 0) {
 922                         if (flags & V_NOWAIT) {
 923                                 error = EWOULDBLOCK;
 924                                 goto unlock;
 925                         }
 926                         error = msleep(&mp->mnt_flag, MNT_MTX(mp),
 927                             (PUSER - 1) | (flags & PCATCH), "suspfs", 0);
 928                         if (error)
 929                                 goto unlock;
 930                 }
 931         }
 932         if (flags & V_XSLEEP)
 933                 goto unlock;
 934         mp->mnt_writeopcount++;
 935 unlock:
 936         MNT_REL(mp);
 937         MNT_IUNLOCK(mp);
 938         return (error);
 939 }
 940
 941 /*
 942  * Secondary suspension. Used by operations such as vop_inactive
 943  * routines that are needed by the higher level functions. These
 944  * are allowed to proceed until all the higher level functions have
 945  * completed (indicated by mnt_writeopcount dropping to zero). At that
 946  * time, these operations are halted until the suspension is over.
 947  */
 948 int
 949 vn_start_secondary_write(vp, mpp, flags)
 950         struct vnode *vp;
 951         struct mount **mpp;
 952         int flags;
 953 {
 954         struct mount *mp;
 955         int error;
 956
 957  retry:
 958         if (vp != NULL) {
 959                 if ((error = VOP_GETWRITEMOUNT(vp, mpp)) != 0) {
 960                         *mpp = NULL;
 961                         if (error != EOPNOTSUPP)
 962                                 return (error);
 963                         return (0);
 964                 }
 965         }
 966         /*
 967          * If we are not suspended or have not yet reached suspended
 968          * mode, then let the operation proceed.
 969          */
 970         if ((mp = *mpp) == NULL)
 971                 return (0);
 972         MNT_ILOCK(mp);
 973         if (vp == NULL)
 974                 MNT_REF(mp);
 975         if ((mp->mnt_kern_flag & (MNTK_SUSPENDED | MNTK_SUSPEND2)) == 0) {
 976                 mp->mnt_secondary_writes++;
 977                 mp->mnt_secondary_accwrites++;
 978                 MNT_REL(mp);
 979                 MNT_IUNLOCK(mp);
 980                 return (0);
 981         }
 982         if (flags & V_NOWAIT) {
 983                 MNT_REL(mp);
 984                 MNT_IUNLOCK(mp);
 985                 return (EWOULDBLOCK);
 986         }
 987         /*
 988          * Wait for the suspension to finish.
 989          */
 990         error = msleep(&mp->mnt_flag, MNT_MTX(mp),
 991                        (PUSER - 1) | (flags & PCATCH) | PDROP, "suspfs", 0);
 992         vfs_rel(mp);
 993         if (error == 0)
 994                 goto retry;
 995         return (error);
 996 }
 997
 998 /*
 999  * Filesystem write operation has completed. If we are suspending and this
1000  * operation is the last one, notify the suspender that the suspension is
1001  * now in effect.
1002  */
1003 void
1004 vn_finished_write(mp)
1005         struct mount *mp;
1006 {
1007         if (mp == NULL)
1008                 return;
1009         MNT_ILOCK(mp);
1010         mp->mnt_writeopcount--;
1011         if (mp->mnt_writeopcount < 0)
1012                 panic("vn_finished_write: neg cnt");
1013         if ((mp->mnt_kern_flag & MNTK_SUSPEND) != 0 &&
1014             mp->mnt_writeopcount <= 0)
1015                 wakeup(&mp->mnt_writeopcount);
1016         MNT_IUNLOCK(mp);
1017 }
1018
1019
1020 /*
1021  * Filesystem secondary write operation has completed. If we are
1022  * suspending and this operation is the last one, notify the suspender
1023  * that the suspension is now in effect.
1024  */
1025 void
1026 vn_finished_secondary_write(mp)
1027         struct mount *mp;
1028 {
1029         if (mp == NULL)
1030                 return;
1031         MNT_ILOCK(mp);
1032         mp->mnt_secondary_writes--;
1033         if (mp->mnt_secondary_writes < 0)
1034                 panic("vn_finished_secondary_write: neg cnt");
1035         if ((mp->mnt_kern_flag & MNTK_SUSPEND) != 0 &&
1036             mp->mnt_secondary_writes <= 0)
1037                 wakeup(&mp->mnt_secondary_writes);
1038         MNT_IUNLOCK(mp);
1039 }
1040
1041
1042
1043 /*
1044  * Request a filesystem to suspend write operations.
1045  */
1046 int
1047 vfs_write_suspend(mp)
1048         struct mount *mp;
1049 {
1050         struct thread *td = curthread;
1051         int error;
1052
1053         MNT_ILOCK(mp);
1054         if (mp->mnt_susp_owner == curthread) {
1055                 MNT_IUNLOCK(mp);
1056                 return (EALREADY);
1057         }
1058         while (mp->mnt_kern_flag & MNTK_SUSPEND)
1059                 msleep(&mp->mnt_flag, MNT_MTX(mp), PUSER - 1, "wsuspfs", 0);
1060         mp->mnt_kern_flag |= MNTK_SUSPEND;
1061         mp->mnt_susp_owner = curthread;
1062         if (mp->mnt_writeopcount > 0)
1063                 (void) msleep(&mp->mnt_writeopcount,
1064                     MNT_MTX(mp), (PUSER - 1)|PDROP, "suspwt", 0);
1065         else
1066                 MNT_IUNLOCK(mp);
1067         if ((error = VFS_SYNC(mp, MNT_SUSPEND, td)) != 0)
1068                 vfs_write_resume(mp);
1069         return (error);
1070 }
1071
1072 /*
1073  * Request a filesystem to resume write operations.
1074  */
1075 void
1076 vfs_write_resume(mp)
1077         struct mount *mp;
1078 {
1079
1080         MNT_ILOCK(mp);
1081         if ((mp->mnt_kern_flag & MNTK_SUSPEND) != 0) {
1082                 KASSERT(mp->mnt_susp_owner == curthread, ("mnt_susp_owner"));
1083                 mp->mnt_kern_flag &= ~(MNTK_SUSPEND | MNTK_SUSPEND2 |
1084                                        MNTK_SUSPENDED);
1085                 mp->mnt_susp_owner = NULL;
1086                 wakeup(&mp->mnt_writeopcount);
1087                 wakeup(&mp->mnt_flag);
1088                 curthread->td_pflags &= ~TDP_IGNSUSP;
1089                 MNT_IUNLOCK(mp);
1090                 VFS_SUSP_CLEAN(mp);
1091         } else
1092                 MNT_IUNLOCK(mp);
1093 }
1094
1095 /*
1096  * Implement kqueues for files by translating it to vnode operation.
1097  */
1098 static int
1099 vn_kqfilter(struct file *fp, struct knote *kn)
1100 {
1101         int vfslocked;
1102         int error;
1103
1104         vfslocked = VFS_LOCK_GIANT(fp->f_vnode->v_mount);
1105         error = VOP_KQFILTER(fp->f_vnode, kn);
1106         VFS_UNLOCK_GIANT(vfslocked);
1107
1108         return error;
1109 }
1110
1111 /*
1112  * Simplified in-kernel wrapper calls for extended attribute access.
1113  * Both calls pass in a NULL credential, authorizing as "kernel" access.
1114  * Set IO_NODELOCKED in ioflg if the vnode is already locked.
1115  */
1116 int
1117 vn_extattr_get(struct vnode *vp, int ioflg, int attrnamespace,
1118     const char *attrname, int *buflen, char *buf, struct thread *td)
1119 {
1120         struct uio      auio;
1121         struct iovec    iov;
1122         int     error;
1123
1124         iov.iov_len = *buflen;
1125         iov.iov_base = buf;
1126
1127         auio.uio_iov = &iov;
1128         auio.uio_iovcnt = 1;
1129         auio.uio_rw = UIO_READ;
1130         auio.uio_segflg = UIO_SYSSPACE;
1131         auio.uio_td = td;
1132         auio.uio_offset = 0;
1133         auio.uio_resid = *buflen;
1134
1135         if ((ioflg & IO_NODELOCKED) == 0)
1136                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
1137
1138         ASSERT_VOP_LOCKED(vp, "IO_NODELOCKED with no vp lock held");
1139
1140         /* authorize attribute retrieval as kernel */
1141         error = VOP_GETEXTATTR(vp, attrnamespace, attrname, &auio, NULL, NULL,
1142             td);
1143
1144         if ((ioflg & IO_NODELOCKED) == 0)
1145                 VOP_UNLOCK(vp, 0, td);
1146
1147         if (error == 0) {
1148                 *buflen = *buflen - auio.uio_resid;
1149         }
1150
1151         return (error);
1152 }
1153
1154 /*
1155  * XXX failure mode if partially written?
1156  */
1157 int
1158 vn_extattr_set(struct vnode *vp, int ioflg, int attrnamespace,
1159     const char *attrname, int buflen, char *buf, struct thread *td)
1160 {
1161         struct uio      auio;
1162         struct iovec    iov;
1163         struct mount    *mp;
1164         int     error;
1165
1166         iov.iov_len = buflen;
1167         iov.iov_base = buf;
1168
1169         auio.uio_iov = &iov;
1170         auio.uio_iovcnt = 1;
1171         auio.uio_rw = UIO_WRITE;
1172         auio.uio_segflg = UIO_SYSSPACE;
1173         auio.uio_td = td;
1174         auio.uio_offset = 0;
1175         auio.uio_resid = buflen;
1176
1177         if ((ioflg & IO_NODELOCKED) == 0) {
1178                 if ((error = vn_start_write(vp, &mp, V_WAIT)) != 0)
1179                         return (error);
1180                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
1181         }
1182
1183         ASSERT_VOP_LOCKED(vp, "IO_NODELOCKED with no vp lock held");
1184
1185         /* authorize attribute setting as kernel */
1186         error = VOP_SETEXTATTR(vp, attrnamespace, attrname, &auio, NULL, td);
1187
1188         if ((ioflg & IO_NODELOCKED) == 0) {
1189                 vn_finished_write(mp);
1190                 VOP_UNLOCK(vp, 0, td);
1191         }
1192
1193         return (error);
1194 }
1195
1196 int
1197 vn_extattr_rm(struct vnode *vp, int ioflg, int attrnamespace,
1198     const char *attrname, struct thread *td)
1199 {
1200         struct mount    *mp;
1201         int     error;
1202
1203         if ((ioflg & IO_NODELOCKED) == 0) {
1204                 if ((error = vn_start_write(vp, &mp, V_WAIT)) != 0)
1205                         return (error);
1206                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
1207         }
1208
1209         ASSERT_VOP_LOCKED(vp, "IO_NODELOCKED with no vp lock held");
1210
1211         /* authorize attribute removal as kernel */
1212         error = VOP_DELETEEXTATTR(vp, attrnamespace, attrname, NULL, td);
1213         if (error == EOPNOTSUPP)
1214                 error = VOP_SETEXTATTR(vp, attrnamespace, attrname, NULL,
1215                     NULL, td);
1216
1217         if ((ioflg & IO_NODELOCKED) == 0) {
1218                 vn_finished_write(mp);
1219                 VOP_UNLOCK(vp, 0, td);
1220         }
1221
1222         return (error);
1223 }
1224
1225 int
1226 vn_vget_ino(struct vnode *vp, ino_t ino, int lkflags, struct vnode **rvp)
1227 {
1228         struct mount *mp;
1229         int ltype, error;
1230
1231         mp = vp->v_mount;
1232         ltype = VOP_ISLOCKED(vp, curthread);
1233         KASSERT(ltype == LK_EXCLUSIVE || ltype == LK_SHARED,
1234             ("vn_vget_ino: vp not locked"));
1235         for (;;) {
1236                 error = vfs_busy(mp, LK_NOWAIT, NULL, curthread);
1237                 if (error == 0)
1238                         break;
1239                 VOP_UNLOCK(vp, 0, curthread);
1240                 pause("vn_vget", 1);
1241                 vn_lock(vp, ltype | LK_RETRY, curthread);
1242                 if (vp->v_iflag & VI_DOOMED)
1243                         return (ENOENT);
1244         }
1245         VOP_UNLOCK(vp, 0, curthread);
1246         error = VFS_VGET(mp, ino, lkflags, rvp);
1247         vfs_unbusy(mp, curthread);
1248         vn_lock(vp, ltype | LK_RETRY, curthread);
1249         if (vp->v_iflag & VI_DOOMED) {
1250                 if (error == 0)
1251                         vput(*rvp);
1252                 error = ENOENT;
1253         }
1254         return (error);
1255 }