kernel/fs/ufs/ufs_filio.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 1991, 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24
  25 #include <sys/types.h>
  26 #include <sys/t_lock.h>
  27 #include <sys/param.h>
  28 #include <sys/time.h>
  29 #include <sys/systm.h>
  30 #include <sys/sysmacros.h>
  31 #include <sys/resource.h>
  32 #include <sys/signal.h>
  33 #include <sys/cred.h>
  34 #include <sys/user.h>
  35 #include <sys/buf.h>
  36 #include <sys/vfs.h>
  37 #include <sys/vnode.h>
  38 #include <sys/proc.h>
  39 #include <sys/disp.h>
  40 #include <sys/file.h>
  41 #include <sys/fcntl.h>
  42 #include <sys/flock.h>
  43 #include <sys/atomic.h>
  44 #include <sys/kmem.h>
  45 #include <sys/uio.h>
  46 #include <sys/conf.h>
  47 #include <sys/mman.h>
  48 #include <sys/pathname.h>
  49 #include <sys/debug.h>
  50 #include <sys/vmsystm.h>
  51 #include <sys/cmn_err.h>
  52 #include <sys/filio.h>
  53 #include <sys/dnlc.h>
  54
  55 #include <sys/fs/ufs_filio.h>
  56 #include <sys/fs/ufs_lockfs.h>
  57 #include <sys/fs/ufs_fs.h>
  58 #include <sys/fs/ufs_inode.h>
  59 #include <sys/fs/ufs_fsdir.h>
  60 #include <sys/fs/ufs_quota.h>
  61 #include <sys/fs/ufs_trans.h>
  62 #include <sys/fs/ufs_log.h>
  63 #include <sys/dirent.h>         /* must be AFTER <sys/fs/fsdir.h>! */
  64 #include <sys/errno.h>
  65 #include <sys/sysinfo.h>
  66
  67 #include <vm/hat.h>
  68 #include <vm/page.h>
  69 #include <vm/pvn.h>
  70 #include <vm/as.h>
  71 #include <vm/seg.h>
  72 #include <vm/seg_map.h>
  73 #include <vm/seg_vn.h>
  74 #include <vm/rm.h>
  75 #include <sys/swap.h>
  76 #include <sys/model.h>
  77 #include <sys/policy.h>
  78
  79 #include "sys/fs_subr.h"
  80
  81 /*
  82  * ufs_fioio is the ufs equivalent of NFS_CNVT and is tailored to
  83  * metamucil's needs.  It may change at any time.
  84  */
  85 /* ARGSUSED */
  86 int
  87 ufs_fioio(
  88         struct vnode    *vp,            /* any file on the fs */
  89         struct fioio    *fiou,          /* fioio struct in userland */
  90         int             flag,           /* flag from fop_ioctl() */
  91         struct cred     *cr)            /* credentials from ufs_ioctl */
  92 {
  93         int             error   = 0;
  94         struct vnode    *vpio   = NULL; /* vnode for inode open */
  95         struct inode    *ipio   = NULL; /* inode for inode open */
  96         struct file     *fpio   = NULL; /* file  for inode open */
  97         struct inode    *ip;            /* inode for file system */
  98         struct fs       *fs;            /* fs    for file system */
  99         STRUCT_DECL(fioio, fio);        /* copy of user's fioio struct */
 100
 101         /*
 102          * must be privileged
 103          */
 104         if (secpolicy_fs_config(cr, vp->v_vfsp) != 0)
 105                 return (EPERM);
 106
 107         STRUCT_INIT(fio, flag & DATAMODEL_MASK);
 108
 109         /*
 110          * get user's copy of fioio struct
 111          */
 112         if (copyin(fiou, STRUCT_BUF(fio), STRUCT_SIZE(fio)))
 113                 return (EFAULT);
 114
 115         ip = VTOI(vp);
 116         fs = ip->i_fs;
 117
 118         /*
 119          * check the inode number against the fs's inode number bounds
 120          */
 121         if (STRUCT_FGET(fio, fio_ino) < UFSROOTINO)
 122                 return (ESRCH);
 123         if (STRUCT_FGET(fio, fio_ino) >= fs->fs_ncg * fs->fs_ipg)
 124                 return (ESRCH);
 125
 126         rw_enter(&ip->i_ufsvfs->vfs_dqrwlock, RW_READER);
 127
 128         /*
 129          * get the inode
 130          */
 131         error = ufs_iget(ip->i_vfs, STRUCT_FGET(fio, fio_ino), &ipio, cr);
 132
 133         rw_exit(&ip->i_ufsvfs->vfs_dqrwlock);
 134
 135         if (error)
 136                 return (error);
 137
 138         /*
 139          * check the generation number
 140          */
 141         rw_enter(&ipio->i_contents, RW_READER);
 142         if (ipio->i_gen != STRUCT_FGET(fio, fio_gen)) {
 143                 error = ESTALE;
 144                 rw_exit(&ipio->i_contents);
 145                 goto errout;
 146         }
 147
 148         /*
 149          * check if the inode is free
 150          */
 151         if (ipio->i_mode == 0) {
 152                 error = ENOENT;
 153                 rw_exit(&ipio->i_contents);
 154                 goto errout;
 155         }
 156         rw_exit(&ipio->i_contents);
 157
 158         /*
 159          *      Adapted from copen: get a file struct
 160          *      Large Files: We open this file descriptor with FOFFMAX flag
 161          *      set so that it will be like a large file open.
 162          */
 163         if (falloc(NULL, (FREAD|FOFFMAX), &fpio, STRUCT_FADDR(fio, fio_fd)))
 164                 goto errout;
 165
 166         /*
 167          *      Adapted from vn_open: check access and then open the file
 168          */
 169         vpio = ITOV(ipio);
 170         if (error = fop_access(vpio, VREAD, 0, cr, NULL))
 171                 goto errout;
 172
 173         if (error = fop_open(&vpio, FREAD, cr, NULL))
 174                 goto errout;
 175
 176         /*
 177          *      Adapted from copen: initialize the file struct
 178          */
 179         fpio->f_vnode = vpio;
 180
 181         /*
 182          * return the fd
 183          */
 184         if (copyout(STRUCT_BUF(fio), fiou, STRUCT_SIZE(fio))) {
 185                 error = EFAULT;
 186                 goto errout;
 187         }
 188         setf(STRUCT_FGET(fio, fio_fd), fpio);
 189         mutex_exit(&fpio->f_tlock);
 190         return (0);
 191 errout:
 192         /*
 193          * free the file struct and fd
 194          */
 195         if (fpio) {
 196                 setf(STRUCT_FGET(fio, fio_fd), NULL);
 197                 unfalloc(fpio);
 198         }
 199
 200         /*
 201          * release the hold on the inode
 202          */
 203         if (ipio)
 204                 VN_RELE(ITOV(ipio));
 205         return (error);
 206 }
 207
 208 /*
 209  * ufs_fiosatime
 210  *      set access time w/o altering change time.  This ioctl is tailored
 211  *      to metamucil's needs and may change at any time.
 212  */
 213 int
 214 ufs_fiosatime(
 215         struct vnode    *vp,            /* file's vnode */
 216         struct timeval  *tvu,           /* struct timeval in userland */
 217         int             flag,           /* flag from fop_ioctl() */
 218         struct cred     *cr)            /* credentials from ufs_ioctl */
 219 {
 220         struct inode    *ip;            /* inode for vp */
 221         struct timeval32 tv;            /* copy of user's timeval */
 222         int now = 0;
 223
 224         /*
 225          * must have sufficient privileges
 226          */
 227         if (secpolicy_fs_config(cr, vp->v_vfsp) != 0)
 228                 return (EPERM);
 229
 230         /*
 231          * get user's copy of timeval struct and check values
 232          * if input is NULL, will set time to now
 233          */
 234         if (tvu == NULL) {
 235                 now = 1;
 236         } else {
 237                 if ((flag & DATAMODEL_MASK) == DATAMODEL_ILP32) {
 238                         if (copyin(tvu, &tv, sizeof (tv)))
 239                                 return (EFAULT);
 240                 } else {
 241                         struct timeval tv64;
 242
 243                         if (copyin(tvu, &tv64, sizeof (tv64)))
 244                                 return (EFAULT);
 245                         if (TIMEVAL_OVERFLOW(&tv64))
 246                                 return (EOVERFLOW);
 247                         TIMEVAL_TO_TIMEVAL32(&tv, &tv64);
 248                 }
 249
 250                 if (tv.tv_usec < 0 || tv.tv_usec >= 1000000)
 251                         return (EINVAL);
 252         }
 253
 254         /*
 255          * update access time
 256          */
 257         ip = VTOI(vp);
 258         rw_enter(&ip->i_contents, RW_WRITER);
 259         ITIMES_NOLOCK(ip);
 260         if (now) {
 261                 mutex_enter(&ufs_iuniqtime_lock);
 262                 ip->i_atime = iuniqtime;
 263                 mutex_exit(&ufs_iuniqtime_lock);
 264         } else {
 265                 ip->i_atime = tv;
 266         }
 267         ip->i_flag |= IMODACC;
 268         rw_exit(&ip->i_contents);
 269
 270         return (0);
 271 }
 272
 273 /*
 274  * ufs_fiogdio
 275  *      Get delayed-io state.  This ioctl is tailored
 276  *      to metamucil's needs and may change at any time.
 277  */
 278 /* ARGSUSED */
 279 int
 280 ufs_fiogdio(
 281         struct vnode    *vp,            /* file's vnode */
 282         uint_t          *diop,          /* dio state returned here */
 283         int             flag,           /* flag from ufs_ioctl */
 284         struct cred     *cr)            /* credentials from ufs_ioctl */
 285 {
 286         struct ufsvfs   *ufsvfsp        = VTOI(vp)->i_ufsvfs;
 287
 288         /*
 289          * forcibly unmounted
 290          */
 291         if (ufsvfsp == NULL)
 292                 return (EIO);
 293
 294         if (suword32(diop, ufsvfsp->vfs_dio))
 295                 return (EFAULT);
 296         return (0);
 297 }
 298
 299 /*
 300  * ufs_fiosdio
 301  *      Set delayed-io state.  This ioctl is tailored
 302  *      to metamucil's needs and may change at any time.
 303  */
 304 int
 305 ufs_fiosdio(
 306         struct vnode    *vp,            /* file's vnode */
 307         uint_t          *diop,          /* dio flag */
 308         int             flag,           /* flag from ufs_ioctl */
 309         struct cred     *cr)            /* credentials from ufs_ioctl */
 310 {
 311         uint_t          dio;            /* copy of user's dio */
 312         struct inode    *ip;            /* inode for vp */
 313         struct ufsvfs   *ufsvfsp;
 314         struct fs       *fs;
 315         struct ulockfs  *ulp;
 316         int             error = 0;
 317
 318
 319         /* check input conditions */
 320         if (secpolicy_fs_config(cr, vp->v_vfsp) != 0)
 321                 return (EPERM);
 322
 323         if (copyin(diop, &dio, sizeof (dio)))
 324                 return (EFAULT);
 325
 326         if (dio > 1)
 327                 return (EINVAL);
 328
 329         /* file system has been forcibly unmounted */
 330         if (VTOI(vp)->i_ufsvfs == NULL)
 331                 return (EIO);
 332
 333         ip = VTOI(vp);
 334         ufsvfsp = ip->i_ufsvfs;
 335         ulp = &ufsvfsp->vfs_ulockfs;
 336
 337         /* logging file system; dio ignored */
 338         if (TRANS_ISTRANS(ufsvfsp))
 339                 return (error);
 340
 341         /* hold the mutex to prevent race with a lockfs request */
 342         vfs_lock_wait(vp->v_vfsp);
 343         mutex_enter(&ulp->ul_lock);
 344         atomic_inc_ulong(&ufs_quiesce_pend);
 345
 346         if (ULOCKFS_IS_HLOCK(ulp)) {
 347                 error = EIO;
 348                 goto out;
 349         }
 350
 351         if (ULOCKFS_IS_ELOCK(ulp)) {
 352                 error = EBUSY;
 353                 goto out;
 354         }
 355         /* wait for outstanding accesses to finish */
 356         if (error = ufs_quiesce(ulp))
 357                 goto out;
 358
 359         /* flush w/invalidate */
 360         if (error = ufs_flush(vp->v_vfsp))
 361                 goto out;
 362
 363         /*
 364          * update dio
 365          */
 366         mutex_enter(&ufsvfsp->vfs_lock);
 367         ufsvfsp->vfs_dio = dio;
 368
 369         /*
 370          * enable/disable clean flag processing
 371          */
 372         fs = ip->i_fs;
 373         if (fs->fs_ronly == 0 &&
 374             fs->fs_clean != FSBAD &&
 375             fs->fs_clean != FSLOG) {
 376                 if (dio)
 377                         fs->fs_clean = FSSUSPEND;
 378                 else
 379                         fs->fs_clean = FSACTIVE;
 380                 ufs_sbwrite(ufsvfsp);
 381                 mutex_exit(&ufsvfsp->vfs_lock);
 382         } else
 383                 mutex_exit(&ufsvfsp->vfs_lock);
 384 out:
 385         /*
 386          * we need this broadcast because of the ufs_quiesce call above
 387          */
 388         atomic_dec_ulong(&ufs_quiesce_pend);
 389         cv_broadcast(&ulp->ul_cv);
 390         mutex_exit(&ulp->ul_lock);
 391         vfs_unlock(vp->v_vfsp);
 392         return (error);
 393 }
 394
 395 /*
 396  * ufs_fioffs - ioctl handler for flushing file system
 397  */
 398 /* ARGSUSED */
 399 int
 400 ufs_fioffs(
 401         struct vnode    *vp,
 402         char            *vap,           /* must be NULL - reserved */
 403         struct cred     *cr)            /* credentials from ufs_ioctl */
 404 {
 405         int error;
 406         struct ufsvfs   *ufsvfsp;
 407         struct ulockfs  *ulp;
 408
 409         /* file system has been forcibly unmounted */
 410         ufsvfsp = VTOI(vp)->i_ufsvfs;
 411         if (ufsvfsp == NULL)
 412                 return (EIO);
 413
 414         ulp = &ufsvfsp->vfs_ulockfs;
 415
 416         /*
 417          * suspend the delete thread
 418          *      this must be done outside the lockfs locking protocol
 419          */
 420         vfs_lock_wait(vp->v_vfsp);
 421         ufs_thread_suspend(&ufsvfsp->vfs_delete);
 422
 423         /* hold the mutex to prevent race with a lockfs request */
 424         mutex_enter(&ulp->ul_lock);
 425         atomic_inc_ulong(&ufs_quiesce_pend);
 426
 427         if (ULOCKFS_IS_HLOCK(ulp)) {
 428                 error = EIO;
 429                 goto out;
 430         }
 431         if (ULOCKFS_IS_ELOCK(ulp)) {
 432                 error = EBUSY;
 433                 goto out;
 434         }
 435         /* wait for outstanding accesses to finish */
 436         if (error = ufs_quiesce(ulp))
 437                 goto out;
 438
 439         /*
 440          * If logging, and the logmap was marked as not rollable,
 441          * make it rollable now, and start the trans_roll thread and
 442          * the reclaim thread.  The log at this point is safe to write to.
 443          */
 444         if (ufsvfsp->vfs_log) {
 445                 ml_unit_t       *ul = ufsvfsp->vfs_log;
 446                 struct fs       *fsp = ufsvfsp->vfs_fs;
 447                 int             err;
 448
 449                 if (ul->un_flags & LDL_NOROLL) {
 450                         ul->un_flags &= ~LDL_NOROLL;
 451                         logmap_start_roll(ul);
 452                         if (!fsp->fs_ronly && (fsp->fs_reclaim &
 453                             (FS_RECLAIM|FS_RECLAIMING))) {
 454                                 fsp->fs_reclaim &= ~FS_RECLAIM;
 455                                 fsp->fs_reclaim |= FS_RECLAIMING;
 456                                 ufs_thread_start(&ufsvfsp->vfs_reclaim,
 457                                     ufs_thread_reclaim, vp->v_vfsp);
 458                                 if (!fsp->fs_ronly) {
 459                                         TRANS_SBWRITE(ufsvfsp,
 460                                             TOP_SBUPDATE_UPDATE);
 461                                         if (err =
 462                                             geterror(ufsvfsp->vfs_bufp)) {
 463                                                 refstr_t        *mntpt;
 464                                                 mntpt = vfs_getmntpoint(
 465                                                     vp->v_vfsp);
 466                                                 cmn_err(CE_NOTE,
 467                                                     "Filesystem Flush "
 468                                                     "Failed to update "
 469                                                     "Reclaim Status for "
 470                                                     " %s, Write failed to "
 471                                                     "update superblock, "
 472                                                     "error %d",
 473                                                     refstr_value(mntpt),
 474                                                     err);
 475                                                 refstr_rele(mntpt);
 476                                         }
 477                                 }
 478                         }
 479                 }
 480         }
 481
 482         /* synchronously flush dirty data and metadata */
 483         error = ufs_flush(vp->v_vfsp);
 484
 485 out:
 486         atomic_dec_ulong(&ufs_quiesce_pend);
 487         cv_broadcast(&ulp->ul_cv);
 488         mutex_exit(&ulp->ul_lock);
 489         vfs_unlock(vp->v_vfsp);
 490
 491         /*
 492          * allow the delete thread to continue
 493          */
 494         ufs_thread_continue(&ufsvfsp->vfs_delete);
 495         return (error);
 496 }
 497
 498 /*
 499  * ufs_fioisbusy
 500  *      Get number of references on this vnode.
 501  *      Contract-private interface for Legato's NetWorker product.
 502  */
 503 /* ARGSUSED */
 504 int
 505 ufs_fioisbusy(struct vnode *vp, int *isbusy, struct cred *cr)
 506 {
 507         int is_it_busy;
 508
 509         /*
 510          * The caller holds one reference, there may be one in the dnlc
 511          * so we need to flush it.
 512          */
 513         if (vp->v_count > 1)
 514                 dnlc_purge_vp(vp);
 515         /*
 516          * Since we've just flushed the dnlc and we hold a reference
 517          * to this vnode, then anything but 1 means busy (this had
 518          * BETTER not be zero!). Also, it's possible for someone to
 519          * have this file mmap'ed with no additional reference count.
 520          */
 521         ASSERT(vp->v_count > 0);
 522         if ((vp->v_count == 1) && (VTOI(vp)->i_mapcnt == 0))
 523                 is_it_busy = 0;
 524         else
 525                 is_it_busy = 1;
 526
 527         if (suword32(isbusy, is_it_busy))
 528                 return (EFAULT);
 529         return (0);
 530 }
 531
 532 /* ARGSUSED */
 533 int
 534 ufs_fiodirectio(struct vnode *vp, int cmd, struct cred *cr)
 535 {
 536         int             error   = 0;
 537         struct inode    *ip     = VTOI(vp);
 538
 539         /*
 540          * Acquire reader lock and set/reset direct mode
 541          */
 542         rw_enter(&ip->i_contents, RW_READER);
 543         mutex_enter(&ip->i_tlock);
 544         if (cmd == DIRECTIO_ON)
 545                 ip->i_flag |= IDIRECTIO;        /* enable direct mode */
 546         else if (cmd == DIRECTIO_OFF)
 547                 ip->i_flag &= ~IDIRECTIO;       /* disable direct mode */
 548         else
 549                 error = EINVAL;
 550         mutex_exit(&ip->i_tlock);
 551         rw_exit(&ip->i_contents);
 552         return (error);
 553 }
 554
 555 /*
 556  * ufs_fiotune
 557  *      Allow some tunables to be set on a mounted fs
 558  */
 559 int
 560 ufs_fiotune(struct vnode *vp, struct fiotune *uftp, struct cred *cr)
 561 {
 562         struct fiotune  ftp;
 563         struct fs       *fs;
 564         struct ufsvfs   *ufsvfsp;
 565
 566         /*
 567          * must have sufficient privileges
 568          */
 569         if (secpolicy_fs_config(cr, vp->v_vfsp) != 0)
 570                 return (EPERM);
 571
 572         /*
 573          * get user's copy
 574          */
 575         if (copyin(uftp, &ftp, sizeof (ftp)))
 576                 return (EFAULT);
 577
 578         /*
 579          * some minimal sanity checks
 580          */
 581         if ((ftp.maxcontig <= 0) ||
 582             (ftp.rotdelay != 0) ||
 583             (ftp.maxbpg <= 0) ||
 584             (ftp.minfree < 0) ||
 585             (ftp.minfree > 99) ||
 586             ((ftp.optim != FS_OPTTIME) && (ftp.optim != FS_OPTSPACE)))
 587                 return (EINVAL);
 588
 589         /*
 590          * update superblock but don't write it!  If it gets out, fine.
 591          */
 592         fs = VTOI(vp)->i_fs;
 593
 594         fs->fs_maxcontig = ftp.maxcontig;
 595         fs->fs_rotdelay = ftp.rotdelay;
 596         fs->fs_maxbpg = ftp.maxbpg;
 597         fs->fs_minfree = ftp.minfree;
 598         fs->fs_optim = ftp.optim;
 599
 600         /*
 601          * Adjust cluster based on the new maxcontig. The cluster size
 602          * can be any positive value. The check for this is done above.
 603          */
 604         ufsvfsp = VTOI(vp)->i_ufsvfs;
 605         ufsvfsp->vfs_ioclustsz = fs->fs_bsize * fs->fs_maxcontig;
 606
 607         /*
 608          * Adjust minfrags from minfree
 609          */
 610         ufsvfsp->vfs_minfrags = (int)((int64_t)fs->fs_dsize *
 611             fs->fs_minfree / 100);
 612
 613         /*
 614          * Write the superblock
 615          */
 616         if (fs->fs_ronly == 0) {
 617                 TRANS_BEGIN_ASYNC(ufsvfsp, TOP_SBUPDATE_UPDATE,
 618                     TOP_SBWRITE_SIZE);
 619                 TRANS_SBWRITE(ufsvfsp, TOP_SBUPDATE_UPDATE);
 620                 TRANS_END_ASYNC(ufsvfsp, TOP_SBUPDATE_UPDATE, TOP_SBWRITE_SIZE);
 621         }
 622
 623         return (0);
 624 }
 625
 626 /*
 627  * Lseek support for finding holes (cmd == _FIO_SEEK_HOLE) and
 628  * data (cmd == _FIO_SEEK_DATA). "off" is an in/out parameter.
 629  */
 630 int
 631 ufs_fio_holey(vnode_t *vp, int cmd, offset_t *off)
 632 {
 633         inode_t *ip = VTOI(vp);
 634         uoff_t noff = (uoff_t)*off; /* new offset */
 635         uoff_t isz;
 636         int error;
 637         boolean_t hole;
 638
 639         rw_enter(&ip->i_contents, RW_READER);
 640         isz = ip->i_size;
 641         if (noff >= isz)  {
 642                 rw_exit(&ip->i_contents);
 643                 return (ENXIO);
 644         }
 645
 646         /*
 647          * Check for the usual case where a file has no holes.
 648          * If so we can optimise to set the end of the file as the first
 649          * (virtual) hole. This avoids bmap_find() searching through
 650          * every block in the file for a (non-existent) hole.
 651          */
 652         if (!bmap_has_holes(ip)) {
 653                 rw_exit(&ip->i_contents);
 654                 if (cmd == _FIO_SEEK_HOLE) {
 655                         *off = isz;
 656                         return (0);
 657                 }
 658                 /* *off must already point to valid data (non hole) */
 659                 return (0);
 660         }
 661
 662         /*
 663          * Calling bmap_read() one block at a time on a 1TB file takes forever,
 664          * so we use a special function to search for holes or blocks.
 665          */
 666         if (cmd == _FIO_SEEK_HOLE)
 667                 hole = B_TRUE;
 668         else
 669                 hole = B_FALSE;
 670         error = bmap_find(ip, hole, &noff);
 671         rw_exit(&ip->i_contents);
 672
 673         /* end of file? */
 674         if (error == ENXIO) {
 675                 /*
 676                  * Handle the virtual hole at the end of file.
 677                  */
 678                 if (cmd == _FIO_SEEK_HOLE) {
 679                         *off = isz;
 680                         return (0);
 681                 }
 682                 return (ENXIO);
 683         }
 684         if (noff < *off)
 685                 return (error);
 686         *off = noff;
 687         return (error);
 688 }
 689
 690 int
 691 ufs_mark_compressed(struct vnode *vp)
 692 {
 693         struct inode *ip = VTOI(vp);
 694         struct ufsvfs *ufsvfsp = ip->i_ufsvfs;
 695
 696         if (vp->v_type != VREG)
 697                 return (EINVAL);
 698
 699         rw_enter(&ip->i_contents, RW_WRITER);
 700         ip->i_cflags |= ICOMPRESS;
 701         TRANS_INODE(ufsvfsp, ip);
 702         ip->i_flag |= (ICHG|ISEQ);
 703         ip->i_seq++;
 704         if (!TRANS_ISTRANS(ufsvfsp))
 705                 ufs_iupdat(ip, I_ASYNC);
 706         rw_exit(&ip->i_contents);
 707
 708         return (0);
 709 }