usr/src/uts/common/fs/swapfs/swap_vnops.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  * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
  24  */
  25
  26 #include <sys/types.h>
  27 #include <sys/param.h>
  28 #include <sys/systm.h>
  29 #include <sys/buf.h>
  30 #include <sys/cred.h>
  31 #include <sys/errno.h>
  32 #include <sys/vnode.h>
  33 #include <sys/vfs_opreg.h>
  34 #include <sys/cmn_err.h>
  35 #include <sys/swap.h>
  36 #include <sys/mman.h>
  37 #include <sys/vmsystm.h>
  38 #include <sys/vtrace.h>
  39 #include <sys/debug.h>
  40 #include <sys/sysmacros.h>
  41 #include <sys/vm.h>
  42
  43 #include <sys/fs/swapnode.h>
  44
  45 #include <vm/seg.h>
  46 #include <vm/page.h>
  47 #include <vm/pvn.h>
  48 #include <fs/fs_subr.h>
  49
  50 #include <vm/seg_kp.h>
  51
  52 /*
  53  * Define the routines within this file.
  54  */
  55 static int      swap_getpage(struct vnode *vp, offset_t off, size_t len,
  56     uint_t *protp, struct page **plarr, size_t plsz, struct seg *seg,
  57     caddr_t addr, enum seg_rw rw, struct cred *cr, caller_context_t *ct);
  58 static int      swap_putpage(struct vnode *vp, offset_t off, size_t len,
  59     int flags, struct cred *cr, caller_context_t *ct);
  60 static void     swap_inactive(struct vnode *vp, struct cred *cr,
  61     caller_context_t *ct);
  62 static void     swap_dispose(vnode_t *vp, page_t *pp, int fl, int dn,
  63     cred_t *cr, caller_context_t *ct);
  64
  65 static int      swap_getapage(struct vnode *vp, u_offset_t off, size_t len,
  66     uint_t *protp, page_t **plarr, size_t plsz,
  67     struct seg *seg, caddr_t addr, enum seg_rw rw, struct cred *cr);
  68
  69 int     swap_getconpage(struct vnode *vp, u_offset_t off, size_t len,
  70     uint_t *protp, page_t **plarr, size_t plsz, page_t *conpp,
  71     uint_t *pszc, spgcnt_t *nreloc, struct seg *seg, caddr_t addr,
  72     enum seg_rw rw, struct cred *cr);
  73
  74 static int      swap_putapage(struct vnode *vp, page_t *pp, u_offset_t *off,
  75     size_t *lenp, int flags, struct cred *cr);
  76
  77 const fs_operation_def_t swap_vnodeops_template[] = {
  78         VOPNAME_INACTIVE,       { .vop_inactive = swap_inactive },
  79         VOPNAME_GETPAGE,        { .vop_getpage = swap_getpage },
  80         VOPNAME_PUTPAGE,        { .vop_putpage = swap_putpage },
  81         VOPNAME_DISPOSE,        { .vop_dispose = swap_dispose },
  82         VOPNAME_SETFL,          { .error = fs_error },
  83         VOPNAME_POLL,           { .error = fs_error },
  84         VOPNAME_PATHCONF,       { .error = fs_error },
  85         VOPNAME_GETSECATTR,     { .error = fs_error },
  86         VOPNAME_SHRLOCK,        { .error = fs_error },
  87         NULL,                   NULL
  88 };
  89
  90 vnodeops_t *swap_vnodeops;
  91
  92 /* ARGSUSED */
  93 static void
  94 swap_inactive(
  95         struct vnode *vp,
  96         struct cred *cr,
  97         caller_context_t *ct)
  98 {
  99         SWAPFS_PRINT(SWAP_VOPS, "swap_inactive: vp %x\n", vp, 0, 0, 0, 0);
 100 }
 101
 102 /*
 103  * Return all the pages from [off..off+len] in given file
 104  */
 105 /*ARGSUSED*/
 106 static int
 107 swap_getpage(
 108         struct vnode *vp,
 109         offset_t off,
 110         size_t len,
 111         uint_t *protp,
 112         page_t *pl[],
 113         size_t plsz,
 114         struct seg *seg,
 115         caddr_t addr,
 116         enum seg_rw rw,
 117         struct cred *cr,
 118         caller_context_t *ct)
 119 {
 120         SWAPFS_PRINT(SWAP_VOPS, "swap_getpage: vp %p, off %llx, len %lx\n",
 121             (void *)vp, off, len, 0, 0);
 122
 123         TRACE_3(TR_FAC_SWAPFS, TR_SWAPFS_GETPAGE,
 124             "swapfs getpage:vp %p off %llx len %ld",
 125             (void *)vp, off, len);
 126
 127         return (pvn_getpages(swap_getapage, vp, (u_offset_t)off, len, protp,
 128             pl, plsz, seg, addr, rw, cr));
 129 }
 130
 131 /*
 132  * Called from pvn_getpages to get a particular page.
 133  */
 134 /*ARGSUSED*/
 135 static int
 136 swap_getapage(
 137         struct vnode *vp,
 138         u_offset_t off,
 139         size_t len,
 140         uint_t *protp,
 141         page_t *pl[],
 142         size_t plsz,
 143         struct seg *seg,
 144         caddr_t addr,
 145         enum seg_rw rw,
 146         struct cred *cr)
 147 {
 148         struct page *pp, *rpp;
 149         int flags;
 150         int err = 0;
 151         struct vnode *pvp = NULL;
 152         u_offset_t poff;
 153         int flag_noreloc;
 154         se_t lock;
 155         extern int kcage_on;
 156         int upgrade = 0;
 157
 158         SWAPFS_PRINT(SWAP_VOPS, "swap_getapage: vp %p, off %llx, len %lx\n",
 159             vp, off, len, 0, 0);
 160
 161         /*
 162          * Until there is a call-back mechanism to cause SEGKP
 163          * pages to be unlocked, make them non-relocatable.
 164          */
 165         if (SEG_IS_SEGKP(seg))
 166                 flag_noreloc = PG_NORELOC;
 167         else
 168                 flag_noreloc = 0;
 169
 170         if (protp != NULL)
 171                 *protp = PROT_ALL;
 172
 173         lock = (rw == S_CREATE ? SE_EXCL : SE_SHARED);
 174
 175 again:
 176         if (pp = page_lookup(vp, off, lock)) {
 177                 /*
 178                  * In very rare instances, a segkp page may have been
 179                  * relocated outside of the kernel by the kernel cage
 180                  * due to the window between page_unlock() and
 181                  * VOP_PUTPAGE() in segkp_unlock().  Due to the
 182                  * rareness of these occurances, the solution is to
 183                  * relocate the page to a P_NORELOC page.
 184                  */
 185                 if (flag_noreloc != 0) {
 186                         if (!PP_ISNORELOC(pp) && kcage_on) {
 187                                 if (lock != SE_EXCL) {
 188                                         upgrade = 1;
 189                                         if (!page_tryupgrade(pp)) {
 190                                                 page_unlock(pp);
 191                                                 lock = SE_EXCL;
 192                                                 goto again;
 193                                         }
 194                                 }
 195
 196                                 if (page_relocate_cage(&pp, &rpp) != 0)
 197                                         panic("swap_getapage: "
 198                                             "page_relocate_cage failed");
 199
 200                                 pp = rpp;
 201                         }
 202                 }
 203
 204                 if (pl) {
 205                         if (upgrade)
 206                                 page_downgrade(pp);
 207
 208                         pl[0] = pp;
 209                         pl[1] = NULL;
 210                 } else {
 211                         page_unlock(pp);
 212                 }
 213         } else {
 214                 pp = page_create_va(vp, off, PAGESIZE,
 215                     PG_WAIT | PG_EXCL | flag_noreloc,
 216                     seg, addr);
 217                 /*
 218                  * Someone raced in and created the page after we did the
 219                  * lookup but before we did the create, so go back and
 220                  * try to look it up again.
 221                  */
 222                 if (pp == NULL)
 223                         goto again;
 224                 if (rw != S_CREATE) {
 225                         err = swap_getphysname(vp, off, &pvp, &poff);
 226                         if (pvp) {
 227                                 struct anon *ap;
 228                                 kmutex_t *ahm;
 229
 230                                 flags = (pl == NULL ? B_ASYNC|B_READ : B_READ);
 231                                 err = VOP_PAGEIO(pvp, pp, poff,
 232                                     PAGESIZE, flags, cr, NULL);
 233
 234                                 if (!err) {
 235                                         ahm = AH_MUTEX(vp, off);
 236                                         mutex_enter(ahm);
 237
 238                                         ap = swap_anon(vp, off);
 239                                         if (ap == NULL) {
 240                                                 panic("swap_getapage:"
 241                                                     " null anon");
 242                                         }
 243
 244                                         if (ap->an_pvp == pvp &&
 245                                             ap->an_poff == poff) {
 246                                                 swap_phys_free(pvp, poff,
 247                                                     PAGESIZE);
 248                                                 ap->an_pvp = NULL;
 249                                                 ap->an_poff = 0;
 250                                                 hat_setmod(pp);
 251                                         }
 252
 253                                         mutex_exit(ahm);
 254                                 }
 255                         } else {
 256                                 if (!err)
 257                                         pagezero(pp, 0, PAGESIZE);
 258
 259                                 /*
 260                                  * If it's a fault ahead, release page_io_lock
 261                                  * and SE_EXCL we grabbed in page_create_va
 262                                  *
 263                                  * If we are here, we haven't called VOP_PAGEIO
 264                                  * and thus calling pvn_read_done(pp, B_READ)
 265                                  * below may mislead that we tried i/o. Besides,
 266                                  * in case of async, pvn_read_done() should
 267                                  * not be called by *getpage()
 268                                  */
 269                                 if (pl == NULL) {
 270                                         /*
 271                                          * swap_getphysname can return error
 272                                          * only when we are getting called from
 273                                          * swapslot_free which passes non-NULL
 274                                          * pl to VOP_GETPAGE.
 275                                          */
 276                                         ASSERT(err == 0);
 277                                         page_io_unlock(pp);
 278                                         page_unlock(pp);
 279                                 }
 280                         }
 281                 }
 282
 283                 ASSERT(pp != NULL);
 284
 285                 if (err && pl)
 286                         pvn_read_done(pp, B_ERROR);
 287
 288                 if (!err && pl)
 289                         pvn_plist_init(pp, pl, plsz, off, PAGESIZE, rw);
 290         }
 291         TRACE_3(TR_FAC_SWAPFS, TR_SWAPFS_GETAPAGE,
 292             "swapfs getapage:pp %p vp %p off %llx", pp, vp, off);
 293         return (err);
 294 }
 295
 296 /*
 297  * Called from large page anon routines only! This is an ugly hack where
 298  * the anon layer directly calls into swapfs with a preallocated large page.
 299  * Another method would have been to change to VOP and add an extra arg for
 300  * the preallocated large page. This all could be cleaned up later when we
 301  * solve the anonymous naming problem and no longer need to loop across of
 302  * the VOP in PAGESIZE increments to fill in or initialize a large page as
 303  * is done today. I think the latter is better since it avoid a change to
 304  * the VOP interface that could later be avoided.
 305  */
 306 int
 307 swap_getconpage(
 308         struct vnode *vp,
 309         u_offset_t off,
 310         size_t len,
 311         uint_t *protp,
 312         page_t *pl[],
 313         size_t plsz,
 314         page_t  *conpp,
 315         uint_t  *pszc,
 316         spgcnt_t *nreloc,
 317         struct seg *seg,
 318         caddr_t addr,
 319         enum seg_rw rw,
 320         struct cred *cr)
 321 {
 322         struct page     *pp;
 323         int             err = 0;
 324         struct vnode    *pvp = NULL;
 325         u_offset_t      poff;
 326
 327         ASSERT(len == PAGESIZE);
 328         ASSERT(pl != NULL);
 329         ASSERT(plsz == PAGESIZE);
 330         ASSERT(protp == NULL);
 331         ASSERT(nreloc != NULL);
 332         ASSERT(!SEG_IS_SEGKP(seg)); /* XXX for now not supported */
 333         SWAPFS_PRINT(SWAP_VOPS, "swap_getconpage: vp %p, off %llx, len %lx\n",
 334             vp, off, len, 0, 0);
 335
 336         /*
 337          * If we are not using a preallocated page then we know one already
 338          * exists. So just let the old code handle it.
 339          */
 340         if (conpp == NULL) {
 341                 err = swap_getapage(vp, (u_offset_t)off, len, protp, pl, plsz,
 342                     seg, addr, rw, cr);
 343                 return (err);
 344         }
 345         ASSERT(conpp->p_szc != 0);
 346         ASSERT(PAGE_EXCL(conpp));
 347
 348
 349         ASSERT(conpp->p_next == conpp);
 350         ASSERT(conpp->p_prev == conpp);
 351         ASSERT(!PP_ISAGED(conpp));
 352         ASSERT(!PP_ISFREE(conpp));
 353
 354         *nreloc = 0;
 355         pp = page_lookup_create(vp, off, SE_SHARED, conpp, nreloc, 0);
 356
 357         /*
 358          * If existing page is found we may need to relocate.
 359          */
 360         if (pp != conpp) {
 361                 ASSERT(rw != S_CREATE);
 362                 ASSERT(pszc != NULL);
 363                 ASSERT(PAGE_SHARED(pp));
 364                 if (pp->p_szc < conpp->p_szc) {
 365                         *pszc = pp->p_szc;
 366                         page_unlock(pp);
 367                         err = -1;
 368                 } else if (pp->p_szc > conpp->p_szc &&
 369                     seg->s_szc > conpp->p_szc) {
 370                         *pszc = MIN(pp->p_szc, seg->s_szc);
 371                         page_unlock(pp);
 372                         err = -2;
 373                 } else {
 374                         pl[0] = pp;
 375                         pl[1] = NULL;
 376                         if (page_pptonum(pp) &
 377                             (page_get_pagecnt(conpp->p_szc) - 1))
 378                                 cmn_err(CE_PANIC, "swap_getconpage: no root");
 379                 }
 380                 return (err);
 381         }
 382
 383         ASSERT(PAGE_EXCL(pp));
 384
 385         if (*nreloc != 0) {
 386                 ASSERT(rw != S_CREATE);
 387                 pl[0] = pp;
 388                 pl[1] = NULL;
 389                 return (0);
 390         }
 391
 392         *nreloc = 1;
 393
 394         /*
 395          * If necessary do the page io.
 396          */
 397         if (rw != S_CREATE) {
 398                 /*
 399                  * Since we are only called now on behalf of an
 400                  * address space operation it's impossible for
 401                  * us to fail unlike swap_getapge() which
 402                  * also gets called from swapslot_free().
 403                  */
 404                 if (swap_getphysname(vp, off, &pvp, &poff)) {
 405                         cmn_err(CE_PANIC,
 406                             "swap_getconpage: swap_getphysname failed!");
 407                 }
 408
 409                 if (pvp != NULL) {
 410                         err = VOP_PAGEIO(pvp, pp, poff, PAGESIZE, B_READ,
 411                             cr, NULL);
 412                         if (err == 0) {
 413                                 struct anon *ap;
 414                                 kmutex_t *ahm;
 415
 416                                 ahm = AH_MUTEX(vp, off);
 417                                 mutex_enter(ahm);
 418                                 ap = swap_anon(vp, off);
 419                                 if (ap == NULL)
 420                                         panic("swap_getconpage: null anon");
 421                                 if (ap->an_pvp != pvp || ap->an_poff != poff)
 422                                         panic("swap_getconpage: bad anon");
 423
 424                                 swap_phys_free(pvp, poff, PAGESIZE);
 425                                 ap->an_pvp = NULL;
 426                                 ap->an_poff = 0;
 427                                 hat_setmod(pp);
 428                                 mutex_exit(ahm);
 429                         }
 430                 } else {
 431                         pagezero(pp, 0, PAGESIZE);
 432                 }
 433         }
 434
 435         /*
 436          * Normally we would let pvn_read_done() destroy
 437          * the page on IO error. But since this is a preallocated
 438          * page we'll let the anon layer handle it.
 439          */
 440         page_io_unlock(pp);
 441         if (err != 0)
 442                 page_hashout(pp, NULL);
 443         ASSERT(pp->p_next == pp);
 444         ASSERT(pp->p_prev == pp);
 445
 446         TRACE_3(TR_FAC_SWAPFS, TR_SWAPFS_GETAPAGE,
 447             "swapfs getconpage:pp %p vp %p off %llx", pp, vp, off);
 448
 449         pl[0] = pp;
 450         pl[1] = NULL;
 451         return (err);
 452 }
 453
 454 /* Async putpage klustering stuff */
 455 int sw_pending_size;
 456 extern int klustsize;
 457 extern struct async_reqs *sw_getreq();
 458 extern void sw_putreq(struct async_reqs *);
 459 extern void sw_putbackreq(struct async_reqs *);
 460 extern struct async_reqs *sw_getfree();
 461 extern void sw_putfree(struct async_reqs *);
 462
 463 static size_t swap_putpagecnt, swap_pagespushed;
 464 static size_t swap_otherfail, swap_otherpages;
 465 static size_t swap_klustfail, swap_klustpages;
 466 static size_t swap_getiofail, swap_getiopages;
 467
 468 /*
 469  * Flags are composed of {B_INVAL, B_DIRTY B_FREE, B_DONTNEED}.
 470  * If len == 0, do from off to EOF.
 471  */
 472 static int swap_nopage = 0;     /* Don't do swap_putpage's if set */
 473
 474 /* ARGSUSED */
 475 static int
 476 swap_putpage(
 477         struct vnode *vp,
 478         offset_t off,
 479         size_t len,
 480         int flags,
 481         struct cred *cr,
 482         caller_context_t *ct)
 483 {
 484         page_t *pp;
 485         u_offset_t io_off;
 486         size_t io_len = 0;
 487         int err = 0;
 488         int nowait;
 489         struct async_reqs *arg;
 490
 491         if (swap_nopage)
 492                 return (0);
 493
 494         ASSERT(vp->v_count != 0);
 495
 496         nowait = flags & B_PAGE_NOWAIT;
 497
 498         /*
 499          * Clear force flag so that p_lckcnt pages are not invalidated.
 500          */
 501         flags &= ~(B_FORCE | B_PAGE_NOWAIT);
 502
 503         SWAPFS_PRINT(SWAP_VOPS,
 504             "swap_putpage: vp %p, off %llx len %lx, flags %x\n",
 505             (void *)vp, off, len, flags, 0);
 506         TRACE_3(TR_FAC_SWAPFS, TR_SWAPFS_PUTPAGE,
 507             "swapfs putpage:vp %p off %llx len %ld", (void *)vp, off, len);
 508
 509         if (vp->v_flag & VNOMAP)
 510                 return (ENOSYS);
 511
 512         if (!vn_has_cached_data(vp))
 513                 return (0);
 514
 515         if (len == 0) {
 516                 if (curproc == proc_pageout)
 517                         cmn_err(CE_PANIC, "swapfs: pageout can't block");
 518
 519                 /* Search the entire vp list for pages >= off. */
 520                 err = pvn_vplist_dirty(vp, (u_offset_t)off, swap_putapage,
 521                     flags, cr);
 522         } else {
 523                 u_offset_t eoff;
 524
 525                 /*
 526                  * Loop over all offsets in the range [off...off + len]
 527                  * looking for pages to deal with.
 528                  */
 529                 eoff = off + len;
 530                 for (io_off = (u_offset_t)off; io_off < eoff;
 531                     io_off += io_len) {
 532                         /*
 533                          * If we run out of the async req slot, put the page
 534                          * now instead of queuing.
 535                          */
 536                         if (flags == (B_ASYNC | B_FREE) &&
 537                             sw_pending_size < klustsize &&
 538                             (arg = sw_getfree())) {
 539                                 /*
 540                                  * If we are clustering, we should allow
 541                                  * pageout to feed us more pages because # of
 542                                  * pushes is limited by # of I/Os, and one
 543                                  * cluster is considered to be one I/O.
 544                                  */
 545                                 if (pushes)
 546                                         pushes--;
 547
 548                                 arg->a_vp = vp;
 549                                 arg->a_off = io_off;
 550                                 arg->a_len = PAGESIZE;
 551                                 arg->a_flags = B_ASYNC | B_FREE;
 552                                 arg->a_cred = kcred;
 553                                 sw_putreq(arg);
 554                                 io_len = PAGESIZE;
 555                                 continue;
 556                         }
 557                         /*
 558                          * If we are not invalidating pages, use the
 559                          * routine page_lookup_nowait() to prevent
 560                          * reclaiming them from the free list.
 561                          */
 562                         if (!nowait && ((flags & B_INVAL) ||
 563                             (flags & (B_ASYNC | B_FREE)) == B_FREE))
 564                                 pp = page_lookup(vp, io_off, SE_EXCL);
 565                         else
 566                                 pp = page_lookup_nowait(vp, io_off,
 567                                     (flags & (B_FREE | B_INVAL)) ?
 568                                     SE_EXCL : SE_SHARED);
 569
 570                         if (pp == NULL || pvn_getdirty(pp, flags) == 0)
 571                                 io_len = PAGESIZE;
 572                         else {
 573                                 err = swap_putapage(vp, pp, &io_off, &io_len,
 574                                     flags, cr);
 575                                 if (err != 0)
 576                                         break;
 577                         }
 578                 }
 579         }
 580         /* If invalidating, verify all pages on vnode list are gone. */
 581         if (err == 0 && off == 0 && len == 0 &&
 582             (flags & B_INVAL) && vn_has_cached_data(vp)) {
 583                 cmn_err(CE_WARN,
 584                     "swap_putpage: B_INVAL, pages not gone");
 585         }
 586         return (err);
 587 }
 588
 589 /*
 590  * Write out a single page.
 591  * For swapfs this means choose a physical swap slot and write the page
 592  * out using VOP_PAGEIO.
 593  * In the (B_ASYNC | B_FREE) case we try to find a bunch of other dirty
 594  * swapfs pages, a bunch of contiguous swap slots and then write them
 595  * all out in one clustered i/o.
 596  */
 597 /*ARGSUSED*/
 598 static int
 599 swap_putapage(
 600         struct vnode *vp,
 601         page_t *pp,
 602         u_offset_t *offp,
 603         size_t *lenp,
 604         int flags,
 605         struct cred *cr)
 606 {
 607         int err;
 608         struct vnode *pvp;
 609         u_offset_t poff, off;
 610         u_offset_t doff;
 611         size_t dlen;
 612         size_t klsz = 0;
 613         u_offset_t klstart = 0;
 614         struct vnode *klvp = NULL;
 615         page_t *pplist;
 616         se_t se;
 617         struct async_reqs *arg;
 618         size_t swap_klustsize;
 619
 620         /*
 621          * This check is added for callers who access swap_putpage with len = 0.
 622          * swap_putpage calls swap_putapage page-by-page via pvn_vplist_dirty.
 623          * And it's necessary to do the same queuing if users have the same
 624          * B_ASYNC|B_FREE flags on.
 625          */
 626         if (flags == (B_ASYNC | B_FREE) &&
 627             sw_pending_size < klustsize && (arg = sw_getfree())) {
 628
 629                 hat_setmod(pp);
 630                 page_io_unlock(pp);
 631                 page_unlock(pp);
 632
 633                 arg->a_vp = vp;
 634                 arg->a_off = pp->p_offset;
 635                 arg->a_len = PAGESIZE;
 636                 arg->a_flags = B_ASYNC | B_FREE;
 637                 arg->a_cred = kcred;
 638                 sw_putreq(arg);
 639
 640                 return (0);
 641         }
 642
 643         SWAPFS_PRINT(SWAP_PUTP,
 644             "swap_putapage: pp %p, vp %p, off %llx, flags %x\n",
 645             pp, vp, pp->p_offset, flags, 0);
 646
 647         ASSERT(PAGE_LOCKED(pp));
 648
 649         off = pp->p_offset;
 650
 651         doff = off;
 652         dlen = PAGESIZE;
 653
 654         if (err = swap_newphysname(vp, off, &doff, &dlen, &pvp, &poff)) {
 655                 err = (flags == (B_ASYNC | B_FREE) ? ENOMEM : 0);
 656                 hat_setmod(pp);
 657                 page_io_unlock(pp);
 658                 page_unlock(pp);
 659                 goto out;
 660         }
 661
 662         klvp = pvp;
 663         klstart = poff;
 664         pplist = pp;
 665         /*
 666          * If this is ASYNC | FREE and we've accumulated a bunch of such
 667          * pending requests, kluster.
 668          */
 669         if (flags == (B_ASYNC | B_FREE))
 670                 swap_klustsize = klustsize;
 671         else
 672                 swap_klustsize = PAGESIZE;
 673         se = (flags & B_FREE ? SE_EXCL : SE_SHARED);
 674         klsz = PAGESIZE;
 675         while (klsz < swap_klustsize) {
 676                 if ((arg = sw_getreq()) == NULL) {
 677                         swap_getiofail++;
 678                         swap_getiopages += btop(klsz);
 679                         break;
 680                 }
 681                 ASSERT(vn_matchops(arg->a_vp, swap_vnodeops));
 682                 vp = arg->a_vp;
 683                 off = arg->a_off;
 684
 685                 if ((pp = page_lookup_nowait(vp, off, se)) == NULL) {
 686                         swap_otherfail++;
 687                         swap_otherpages += btop(klsz);
 688                         sw_putfree(arg);
 689                         break;
 690                 }
 691                 if (pvn_getdirty(pp, flags | B_DELWRI) == 0) {
 692                         sw_putfree(arg);
 693                         continue;
 694                 }
 695                 /* Get new physical backing store for the page */
 696                 doff = off;
 697                 dlen = PAGESIZE;
 698                 if (err = swap_newphysname(vp, off, &doff, &dlen,
 699                     &pvp, &poff)) {
 700                         swap_otherfail++;
 701                         swap_otherpages += btop(klsz);
 702                         hat_setmod(pp);
 703                         page_io_unlock(pp);
 704                         page_unlock(pp);
 705                         sw_putbackreq(arg);
 706                         break;
 707                 }
 708                 /* Try to cluster new physical name with previous ones */
 709                 if (klvp == pvp && poff == klstart + klsz) {
 710                         klsz += PAGESIZE;
 711                         page_add(&pplist, pp);
 712                         pplist = pplist->p_next;
 713                         sw_putfree(arg);
 714                 } else if (klvp == pvp && poff == klstart - PAGESIZE) {
 715                         klsz += PAGESIZE;
 716                         klstart -= PAGESIZE;
 717                         page_add(&pplist, pp);
 718                         sw_putfree(arg);
 719                 } else {
 720                         swap_klustfail++;
 721                         swap_klustpages += btop(klsz);
 722                         hat_setmod(pp);
 723                         page_io_unlock(pp);
 724                         page_unlock(pp);
 725                         sw_putbackreq(arg);
 726                         break;
 727                 }
 728         }
 729
 730         err = VOP_PAGEIO(klvp, pplist, klstart, klsz,
 731             B_WRITE | flags, cr, NULL);
 732
 733         if ((flags & B_ASYNC) == 0)
 734                 pvn_write_done(pp, ((err) ? B_ERROR : 0) | B_WRITE | flags);
 735
 736         /* Statistics */
 737         if (!err) {
 738                 swap_putpagecnt++;
 739                 swap_pagespushed += btop(klsz);
 740         }
 741 out:
 742         TRACE_4(TR_FAC_SWAPFS, TR_SWAPFS_PUTAPAGE,
 743             "swapfs putapage:vp %p klvp %p, klstart %lx, klsz %lx",
 744             vp, klvp, klstart, klsz);
 745         if (err && err != ENOMEM)
 746                 cmn_err(CE_WARN, "swapfs_putapage: err %d\n", err);
 747         if (lenp)
 748                 *lenp = PAGESIZE;
 749         return (err);
 750 }
 751
 752 static void
 753 swap_dispose(
 754         vnode_t *vp,
 755         page_t *pp,
 756         int fl,
 757         int dn,
 758         cred_t *cr,
 759         caller_context_t *ct)
 760 {
 761         int err;
 762         u_offset_t off = pp->p_offset;
 763         vnode_t *pvp;
 764         u_offset_t poff;
 765
 766         ASSERT(PAGE_EXCL(pp));
 767
 768         /*
 769          * The caller will free/invalidate large page in one shot instead of
 770          * one small page at a time.
 771          */
 772         if (pp->p_szc != 0) {
 773                 page_unlock(pp);
 774                 return;
 775         }
 776
 777         err = swap_getphysname(vp, off, &pvp, &poff);
 778         if (!err && pvp != NULL)
 779                 VOP_DISPOSE(pvp, pp, fl, dn, cr, ct);
 780         else
 781                 fs_dispose(vp, pp, fl, dn, cr, ct);
 782 }