Print this page
*** NO COMMENTS ***

@@ -49,10 +49,22 @@
 #include <sys/kmem.h>
 #include <sys/cmn_err.h>
 #include <sys/vfs_opreg.h>
 #include <sys/policy.h>
 
+#include <sys/param.h>
+#include <sys/vm.h>
+#include <vm/seg_vn.h>
+#include <vm/pvn.h>
+#include <vm/as.h>
+#include <vm/hat.h>
+#include <vm/page.h>
+#include <vm/seg.h>
+#include <vm/seg_map.h>
+#include <vm/seg_kmem.h>
+#include <vm/seg_kpm.h>
+
 #include <netsmb/smb_osdep.h>
 #include <netsmb/smb.h>
 #include <netsmb/smb_conn.h>
 #include <netsmb/smb_subr.h>
 

@@ -173,10 +185,42 @@
 static int      smbfs_getsecattr(vnode_t *, vsecattr_t *, int, cred_t *,
                         caller_context_t *);
 static int      smbfs_shrlock(vnode_t *, int, struct shrlock *, int, cred_t *,
                         caller_context_t *);
 
+static int uio_page_mapin(uio_t *uiop, page_t *pp);
+
+static void uio_page_mapout(uio_t *uiop, page_t *pp);
+
+static int smbfs_map(vnode_t *vp, offset_t off, struct as *as, caddr_t *addrp,
+        size_t len, uchar_t prot, uchar_t maxprot, uint_t flags, cred_t *cr,
+        caller_context_t *ct);
+
+static int smbfs_addmap(vnode_t *vp, offset_t off, struct as *as, caddr_t addr,
+        size_t len, uchar_t prot, uchar_t maxprot, uint_t flags, cred_t *cr,
+        caller_context_t *ct);
+
+static int smbfs_delmap(vnode_t *vp, offset_t off, struct as *as, caddr_t addr,
+        size_t len, uint_t prot, uint_t maxprot, uint_t flags, cred_t *cr,
+        caller_context_t *ct);
+
+static int smbfs_putpage(vnode_t *vp, offset_t off, size_t len, int flags,
+        cred_t *cr, caller_context_t *ct);
+
+static int smbfs_putapage(vnode_t *vp, page_t *pp, u_offset_t *offp, size_t *lenp,
+        int flags, cred_t *cr);
+
+static int smbfs_getpage(vnode_t *vp, offset_t off, size_t len, uint_t *protp,
+        page_t *pl[], size_t plsz, struct seg *seg, caddr_t addr,
+        enum seg_rw rw, cred_t *cr, caller_context_t *ct);
+
+static int smbfs_getapage(vnode_t *vp, u_offset_t off, size_t len,
+        uint_t *protp, page_t *pl[], size_t plsz, struct seg *seg, caddr_t addr,
+        enum seg_rw rw, cred_t *cr);
+
+
+
 /* Dummy function to use until correct function is ported in */
 int noop_vnodeop() {
         return (0);
 }
 

@@ -213,15 +257,16 @@
         { VOPNAME_RWUNLOCK,     { .vop_rwunlock = smbfs_rwunlock } },
         { VOPNAME_SEEK,         { .vop_seek = smbfs_seek } },
         { VOPNAME_FRLOCK,       { .vop_frlock = smbfs_frlock } },
         { VOPNAME_SPACE,        { .vop_space = smbfs_space } },
         { VOPNAME_REALVP,       { .error = fs_nosys } }, /* smbfs_realvp, */
-        { VOPNAME_GETPAGE,      { .error = fs_nosys } }, /* smbfs_getpage, */
-        { VOPNAME_PUTPAGE,      { .error = fs_nosys } }, /* smbfs_putpage, */
-        { VOPNAME_MAP,          { .error = fs_nosys } }, /* smbfs_map, */
-        { VOPNAME_ADDMAP,       { .error = fs_nosys } }, /* smbfs_addmap, */
-        { VOPNAME_DELMAP,       { .error = fs_nosys } }, /* smbfs_delmap, */
+        { VOPNAME_GETPAGE,      { .vop_getpage = smbfs_getpage } }, /* smbfs_getpage, */
+        { VOPNAME_PUTPAGE,      { .vop_putpage = smbfs_putpage } }, /* smbfs_putpage, */
+        { VOPNAME_MAP,          { .vop_map = smbfs_map } }, /* smbfs_map, */
+        { VOPNAME_ADDMAP,       { .vop_addmap = smbfs_addmap } }, /* smbfs_addmap, */
+        { VOPNAME_DELMAP,       { .vop_delmap = smbfs_delmap } }, /* smbfs_delmap, */
+        { VOPNAME_DISPOSE,      { .vop_dispose = fs_dispose}},
         { VOPNAME_DUMP,         { .error = fs_nosys } }, /* smbfs_dump, */
         { VOPNAME_PATHCONF,     { .vop_pathconf = smbfs_pathconf } },
         { VOPNAME_PAGEIO,       { .error = fs_nosys } }, /* smbfs_pageio, */
         { VOPNAME_SETSECATTR,   { .vop_setsecattr = smbfs_setsecattr } },
         { VOPNAME_GETSECATTR,   { .vop_getsecattr = smbfs_getsecattr } },

@@ -484,11 +529,39 @@
          * Don't want this one ever interruptible.
          */
         (void) smbfs_rw_enter_sig(&np->r_lkserlock, RW_WRITER, 0);
         smb_credinit(&scred, cr);
 
+        /*
+         * If FID ref. count is 1 and count of mmaped pages isn't 0,
+         * we won't call smbfs_rele_fid(), because it will result in the otW close.
+         * The count of mapped pages isn't 0, which means the mapped pages
+         * possibly will be accessed after close(), we should keep the FID valid,
+         * i.e., dont do the otW close.
+         * Dont worry that FID will be leaked, because when the
+         * vnode's count becomes 0, smbfs_inactive() will
+         * help us release FID and eventually do the otW close.
+         */
+        if (np->n_fidrefs > 1) {
+                smbfs_rele_fid(np, &scred);
+        } else if (np->r_mapcnt == 0) {
+                /*
+                 * Before otW close, make sure dirty pages written back.
+                 */
+                if ((flag & FWRITE) && vn_has_cached_data(vp)) {
+                        /* smbfs_putapage() will acquire shared lock, so release
+                         * exclusive lock temporally.
+                         */
+                        smbfs_rw_exit(&np->r_lkserlock);
+
+                        (void) smbfs_putpage(vp, (offset_t) 0, 0, B_INVAL | B_ASYNC, cr, ct);
+
+                        /* acquire exclusive lock again. */
+                        (void) smbfs_rw_enter_sig(&np->r_lkserlock, RW_WRITER, 0);
+                }
         smbfs_rele_fid(np, &scred);
+        }
 
         smb_credrele(&scred);
         smbfs_rw_exit(&np->r_lkserlock);
 
         return (0);

@@ -1363,10 +1436,24 @@
         case VREG:
                 if (np->n_fidrefs == 0)
                         break;
                 SMBVDEBUG("open file: refs %d id 0x%x path %s\n",
                     np->n_fidrefs, np->n_fid, np->n_rpath);
+                /*
+                 * Before otW close, make sure dirty pages written back.
+                 */
+                if (vn_has_cached_data(vp)) {
+                        /* smbfs_putapage() will acquire shared lock, so release
+                         * exclusive lock temporally.
+                         */
+                        smbfs_rw_exit(&np->r_lkserlock);
+
+                        (void) smbfs_putpage(vp, (offset_t) 0, 0, B_INVAL | B_ASYNC, cr, ct);
+
+                        /* acquire exclusive lock again. */
+                        (void) smbfs_rw_enter_sig(&np->r_lkserlock, RW_WRITER, 0);
+                }
                 /* Force last close. */
                 np->n_fidrefs = 1;
                 smbfs_rele_fid(np, &scred);
                 break;
 

@@ -3108,5 +3195,474 @@
         if (VTOSMI(vp)->smi_flags & SMI_LLOCK)
                 return (fs_shrlock(vp, cmd, shr, flag, cr, ct));
         else
                 return (ENOSYS);
 }
+
+static int uio_page_mapin(uio_t *uiop, page_t *pp) {
+    u_offset_t off;
+    size_t size;
+    pgcnt_t npages;
+    caddr_t kaddr;
+    pfn_t pfnum;
+
+    off = (uintptr_t) uiop->uio_loffset & PAGEOFFSET;
+    size = P2ROUNDUP(uiop->uio_resid + off, PAGESIZE);
+    npages = btop(size);
+
+    ASSERT(pp != NULL);
+
+    if (npages == 1 && kpm_enable) {
+        kaddr = hat_kpm_mapin(pp, NULL);
+        if (kaddr == NULL)
+            return (EFAULT);
+
+        uiop->uio_iov->iov_base = kaddr + off;
+        uiop->uio_iov->iov_len = PAGESIZE - off;
+
+    } else {
+        kaddr = vmem_xalloc(heap_arena, size, PAGESIZE, 0, 0, NULL, NULL, VM_SLEEP);
+        if (kaddr == NULL)
+            return (EFAULT);
+
+        uiop->uio_iov->iov_base = kaddr + off;
+        uiop->uio_iov->iov_len = size - off;
+
+        /*map pages into kaddr*/
+        uint_t attr = PROT_READ | PROT_WRITE | HAT_NOSYNC;
+        while (npages-- > 0) {
+            pfnum = pp->p_pagenum;
+            pp = pp->p_next;
+
+            hat_devload(kas.a_hat, kaddr, PAGESIZE, pfnum, attr, HAT_LOAD_LOCK);
+            kaddr += PAGESIZE;
+        }
+    }
+    return (0);
+}
+
+static void uio_page_mapout(uio_t *uiop, page_t *pp) {
+    u_offset_t off;
+    size_t size;
+    pgcnt_t npages;
+    caddr_t kaddr;
+
+    kaddr = uiop->uio_iov->iov_base;
+    off = (uintptr_t) kaddr & PAGEOFFSET;
+    size = P2ROUNDUP(uiop->uio_iov->iov_len + off, PAGESIZE);
+    npages = btop(size);
+
+    ASSERT(pp != NULL);
+
+    kaddr = (caddr_t) ((uintptr_t) kaddr & MMU_PAGEMASK);
+
+    if (npages == 1 && kpm_enable) {
+        hat_kpm_mapout(pp, NULL, kaddr);
+
+    } else {
+        hat_unload(kas.a_hat, (void*) kaddr, size,
+                HAT_UNLOAD_NOSYNC | HAT_UNLOAD_UNLOCK);
+        vmem_free(heap_arena, (void*) kaddr, size);
+    }
+    uiop->uio_iov->iov_base = 0;
+    uiop->uio_iov->iov_len = 0;
+}
+
+static int smbfs_map(vnode_t *vp, offset_t off, struct as *as, caddr_t *addrp,
+        size_t len, uchar_t prot, uchar_t maxprot, uint_t flags, cred_t *cr,
+        caller_context_t *ct) {
+    smbnode_t *np;
+    smbmntinfo_t *smi;
+    struct vattr va;
+    segvn_crargs_t vn_a;
+    int error;
+
+    np = VTOSMB(vp);
+    smi = VTOSMI(vp);
+
+    if (curproc->p_zone != smi->smi_zone_ref.zref_zone)
+        return (EIO);
+
+    if (smi->smi_flags & SMI_DEAD || vp->v_vfsp->vfs_flag & VFS_UNMOUNTED)
+        return (EIO);
+
+    if (vp->v_flag & VNOMAP || vp->v_flag & VNOCACHE)
+        return (EAGAIN);
+
+    if (vp->v_type != VREG)
+        return (ENODEV);
+
+    va.va_mask = AT_ALL;
+    if (error = smbfsgetattr(vp, &va, cr))
+        return (error);
+
+    if (smbfs_rw_enter_sig(&np->r_lkserlock, RW_WRITER, SMBINTR(vp)))
+        return (EINTR);
+
+    if (MANDLOCK(vp, va.va_mode)) {
+        error = EAGAIN;
+        goto out;
+    }
+
+    as_rangelock(as);
+    error = choose_addr(as, addrp, len, off, ADDR_VACALIGN, flags);
+
+    if (error != 0) {
+        as_rangeunlock(as);
+        goto out;
+    }
+
+    vn_a.vp = vp;
+    vn_a.offset = off;
+    vn_a.type = flags & MAP_TYPE;
+    vn_a.prot = prot;
+    vn_a.maxprot = maxprot;
+    vn_a.flags = flags & ~MAP_TYPE;
+    vn_a.cred = cr;
+    vn_a.amp = NULL;
+    vn_a.szc = 0;
+    vn_a.lgrp_mem_policy_flags = 0;
+
+    error = as_map(as, *addrp, len, segvn_create, &vn_a);
+
+    as_rangeunlock(as);
+
+out:
+    smbfs_rw_exit(&np->r_lkserlock);
+
+    return (error);
+}
+
+static int smbfs_addmap(vnode_t *vp, offset_t off, struct as *as, caddr_t addr,
+        size_t len, uchar_t prot, uchar_t maxprot, uint_t flags, cred_t *cr,
+        caller_context_t *ct) {
+    atomic_add_long((ulong_t *) & VTOSMB(vp)->r_mapcnt, btopr(len));
+    return (0);
+}
+
+static int smbfs_delmap(vnode_t *vp, offset_t off, struct as *as, caddr_t addr,
+        size_t len, uint_t prot, uint_t maxprot, uint_t flags, cred_t *cr,
+        caller_context_t *ct) {
+
+    smbnode_t *np;
+
+    atomic_add_long((ulong_t *) & VTOSMB(vp)->r_mapcnt, -btopr(len));
+
+    /* mark RDIRTY here, will be used to check if a file is dirty when unmount smbfs */
+    if (vn_has_cached_data(vp) && !vn_is_readonly(vp) && maxprot & PROT_WRITE && flags == MAP_SHARED) {
+        np = VTOSMB(vp);
+        mutex_enter(&np->r_statelock);
+        np->r_flags |= RDIRTY;
+        mutex_exit(&np->r_statelock);
+    }
+    return (0);
+}
+
+static int smbfs_putpage(vnode_t *vp, offset_t off, size_t len, int flags,
+        cred_t *cr, caller_context_t *ct) {
+
+    smbnode_t *np;
+    size_t io_len;
+    u_offset_t io_off;
+    u_offset_t eoff;
+    int error = 0;
+    page_t *pp;
+
+    np = VTOSMB(vp);
+
+    if (len == 0) {
+        /* will flush the file, so clear RDIRTY */
+        if (off == (u_offset_t) 0 && (np->r_flags & RDIRTY)) {
+            mutex_enter(&np->r_statelock);
+            np->r_flags &= ~RDIRTY;
+            mutex_exit(&np->r_statelock);
+        }
+
+        error = pvn_vplist_dirty(vp, off, smbfs_putapage, flags, cr);
+    } else {
+
+        eoff = off + len;
+
+        mutex_enter(&np->r_statelock);
+        if (eoff > np->r_size)
+            eoff = np->r_size;
+        mutex_exit(&np->r_statelock);
+
+        for (io_off = off; io_off < eoff; io_off += io_len) {
+            if ((flags & B_INVAL) || (flags & B_ASYNC) == 0) {
+                pp = page_lookup(vp, io_off,
+                        (flags & (B_INVAL | B_FREE) ? SE_EXCL : SE_SHARED));
+            } else {
+                pp = page_lookup_nowait(vp, io_off,
+                        (flags & B_FREE) ? SE_EXCL : SE_SHARED);
+            }
+
+            if (pp == NULL || !pvn_getdirty(pp, flags))
+                io_len = PAGESIZE;
+            else {
+                error = smbfs_putapage(vp, pp, &io_off, &io_len, flags, cr);
+            }
+        }
+
+    }
+
+    return (error);
+}
+
+static int smbfs_putapage(vnode_t *vp, page_t *pp, u_offset_t *offp, size_t *lenp,
+        int flags, cred_t *cr) {
+
+    struct smb_cred scred;
+    smbnode_t *np;
+    smbmntinfo_t *smi;
+    smb_share_t *ssp;
+    uio_t uio;
+    iovec_t uiov, uiov_bak;
+
+    size_t io_len;
+    u_offset_t io_off;
+    size_t bsize;
+    size_t blksize;
+    u_offset_t blkoff;
+    int error;
+
+    np = VTOSMB(vp);
+    smi = VTOSMI(vp);
+    ssp = smi->smi_share;
+
+    /*do block io, get a kluster of dirty pages in a block.*/
+    bsize = MAX(vp->v_vfsp->vfs_bsize, PAGESIZE);
+    blkoff = pp->p_offset / bsize;
+    blkoff *= bsize;
+    blksize = roundup(bsize, PAGESIZE);
+
+    pp = pvn_write_kluster(vp, pp, &io_off, &io_len, blkoff, blksize, flags);
+
+    ASSERT(pp->p_offset >= blkoff);
+
+    if (io_off + io_len > blkoff + blksize) {
+        ASSERT((io_off + io_len)-(blkoff + blksize) < PAGESIZE);
+        io_len = blkoff + blksize - io_off;
+    }
+
+    /*currently, don't allow put pages beyond EOF, unless smbfs_read/smbfs_write
+     *can do io through segkpm or vpm.*/
+    mutex_enter(&np->r_statelock);
+    if (io_off >= np->r_size) {
+        mutex_exit(&np->r_statelock);
+        error = 0;
+        goto out;
+    } else if (io_off + io_len > np->r_size) {
+        int npages = btopr(np->r_size - io_off);
+        page_t *trunc;
+        page_list_break(&pp, &trunc, npages);
+        if (trunc)
+            pvn_write_done(trunc, flags);
+        io_len = np->r_size - io_off;
+    }
+    mutex_exit(&np->r_statelock);
+
+    if (smbfs_rw_enter_sig(&np->r_lkserlock, RW_READER, SMBINTR(vp)))
+        return (EINTR);
+    smb_credinit(&scred, cr);
+
+    if (np->n_vcgenid != ssp->ss_vcgenid)
+        error = ESTALE;
+    else {
+        /*just use uio instead of buf, since smb_rwuio need uio.*/
+        uiov.iov_base = 0;
+        uiov.iov_len = 0;
+        uio.uio_iov = &uiov;
+        uio.uio_iovcnt = 1;
+        uio.uio_loffset = io_off;
+        uio.uio_resid = io_len;
+        uio.uio_segflg = UIO_SYSSPACE;
+        uio.uio_llimit = MAXOFFSET_T;
+        /*map pages into kernel address space, and setup uio.*/
+        error = uio_page_mapin(&uio, pp);
+        if (error == 0) {
+            uiov_bak.iov_base = uiov.iov_base;
+            uiov_bak.iov_len = uiov.iov_len;
+            error = smb_rwuio(ssp, np->n_fid, UIO_WRITE, &uio, &scred, smb_timo_write);
+            if (error == 0) {
+                mutex_enter(&np->r_statelock);
+                np->n_flag |= (NFLUSHWIRE | NATTRCHANGED);
+                mutex_exit(&np->r_statelock);
+                (void) smbfs_smb_flush(np, &scred);
+            }
+            /*unmap pages from kernel address space.*/
+            uio.uio_iov = &uiov_bak;
+            uio_page_mapout(&uio, pp);
+        }
+    }
+
+    smb_credrele(&scred);
+    smbfs_rw_exit(&np->r_lkserlock);
+
+out:
+    pvn_write_done(pp, ((error) ? B_ERROR : 0) | B_WRITE | flags);
+
+    if (offp)
+        *offp = io_off;
+    if (lenp)
+        *lenp = io_len;
+
+    return (error);
+}
+
+static int smbfs_getpage(vnode_t *vp, offset_t off, size_t len, uint_t *protp,
+        page_t *pl[], size_t plsz, struct seg *seg, caddr_t addr,
+        enum seg_rw rw, cred_t *cr, caller_context_t *ct) {
+
+    int error;
+
+    /*these pages have all protections.*/
+    if (protp)
+        *protp = PROT_ALL;
+
+    if (len <= PAGESIZE) {
+        error = smbfs_getapage(vp, off, len, protp, pl, plsz, seg, addr, rw,
+                cr);
+    } else {
+        error = pvn_getpages(smbfs_getapage, vp, off, len, protp, pl, plsz, seg,
+                addr, rw, cr);
+    }
+
+    return (error);
+}
+
+static int smbfs_getapage(vnode_t *vp, u_offset_t off, size_t len,
+        uint_t *protp, page_t *pl[], size_t plsz, struct seg *seg, caddr_t addr,
+        enum seg_rw rw, cred_t *cr) {
+
+    smbnode_t *np;
+    smbmntinfo_t *smi;
+    smb_share_t *ssp;
+    smb_cred_t scred;
+
+    page_t *pp;
+    uio_t uio;
+    iovec_t uiov, uiov_bak;
+
+    u_offset_t blkoff;
+    size_t bsize;
+    size_t blksize;
+
+    u_offset_t io_off;
+    size_t io_len;
+    size_t pages_len;
+
+    int error = 0;
+
+    np = VTOSMB(vp);
+    smi = VTOSMI(vp);
+    ssp = smi->smi_share;
+
+    /*if pl is null,it's meaningless*/
+    if (pl == NULL)
+        return (EFAULT);
+
+again:
+    if (page_exists(vp, off) == NULL) {
+        if (rw == S_CREATE) {
+            /*just return a empty page if asked to create.*/
+            if ((pp = page_create_va(vp, off, PAGESIZE, PG_WAIT | PG_EXCL, seg, addr)) == NULL)
+                goto again;
+            pages_len = PAGESIZE;
+        } else {
+
+            /*do block io, get a kluster of non-exist pages in a block.*/
+            bsize = MAX(vp->v_vfsp->vfs_bsize, PAGESIZE);
+            blkoff = off / bsize;
+            blkoff *= bsize;
+            blksize = roundup(bsize, PAGESIZE);
+
+            pp = pvn_read_kluster(vp, off, seg, addr, &io_off, &io_len, blkoff, blksize, 0);
+
+            if (pp == NULL)
+                goto again;
+
+            pages_len = io_len;
+
+            /*currently, don't allow get pages beyond EOF, unless smbfs_read/smbfs_write
+             *can do io through segkpm or vpm.*/
+            mutex_enter(&np->r_statelock);
+            if (io_off >= np->r_size) {
+                mutex_exit(&np->r_statelock);
+                error = 0;
+                goto out;
+            } else if (io_off + io_len > np->r_size) {
+                int npages = btopr(np->r_size - io_off);
+                page_t *trunc;
+
+                page_list_break(&pp, &trunc, npages);
+                if (trunc)
+                    pvn_read_done(trunc, 0);
+                io_len = np->r_size - io_off;
+            }
+            mutex_exit(&np->r_statelock);
+
+            if (smbfs_rw_enter_sig(&np->r_lkserlock, RW_READER, SMBINTR(vp)))
+                return EINTR;
+            smb_credinit(&scred, cr);
+
+            /*just use uio instead of buf, since smb_rwuio need uio.*/
+            uiov.iov_base = 0;
+            uiov.iov_len = 0;
+            uio.uio_iov = &uiov;
+            uio.uio_iovcnt = 1;
+            uio.uio_loffset = io_off;
+            uio.uio_resid = io_len;
+            uio.uio_segflg = UIO_SYSSPACE;
+            uio.uio_llimit = MAXOFFSET_T;
+
+            /*map pages into kernel address space, and setup uio.*/
+            error = uio_page_mapin(&uio, pp);
+            if (error == 0) {
+                uiov_bak.iov_base = uiov.iov_base;
+                uiov_bak.iov_len = uiov.iov_len;
+                error = smb_rwuio(ssp, np->n_fid, UIO_READ, &uio, &scred, smb_timo_read);
+                /*unmap pages from kernel address space.*/
+                uio.uio_iov = &uiov_bak;
+                uio_page_mapout(&uio, pp);
+            }
+
+            smb_credrele(&scred);
+            smbfs_rw_exit(&np->r_lkserlock);
+        }
+    } else {
+        se_t se = rw == S_CREATE ? SE_EXCL : SE_SHARED;
+        if ((pp = page_lookup(vp, off, se)) == NULL) {
+            goto again;
+        }
+    }
+
+out:
+    if (pp) {
+        if (error) {
+            pvn_read_done(pp, B_ERROR);
+        } else {
+            /*init page list, unlock pages.*/
+            pvn_plist_init(pp, pl, plsz, off, pages_len, rw);
+        }
+    }
+
+    return (error);
+}
+
+
+void smbfs_invalidate_pages(vnode_t *vp, u_offset_t off, cred_t *cr) {
+
+    smbnode_t *np;
+
+    np = VTOSMB(vp);
+    /* will flush the file, so clear RDIRTY */
+    if (off == (u_offset_t) 0 && (np->r_flags & RDIRTY)) {
+        mutex_enter(&np->r_statelock);
+        np->r_flags &= ~RDIRTY;
+        mutex_exit(&np->r_statelock);
+    }
+
+    (void) pvn_vplist_dirty(vp, off, smbfs_putapage, B_INVAL | B_TRUNC, cr);
+}
+
+