Add an argument to vfs_add_vnodeops() to specify VVF_* flags for the vop_ops
[dragonfly.git] / sys / vm / vm_swap.c
index 12df4c4..57a449b 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)vm_swap.c   8.5 (Berkeley) 2/17/94
  * $FreeBSD: src/sys/vm/vm_swap.c,v 1.96.2.2 2001/10/14 18:46:47 iedowse Exp $
- * $DragonFly: src/sys/vm/vm_swap.c,v 1.9 2003/09/23 05:03:54 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_swap.c,v 1.19 2005/09/17 07:43:12 dillon Exp $
  */
 
 #include "opt_swap.h"
@@ -42,7 +42,7 @@
 #include <sys/sysproto.h>
 #include <sys/buf.h>
 #include <sys/proc.h>
-#include <sys/namei.h>
+#include <sys/nlookup.h>
 #include <sys/dmap.h>          /* XXX */
 #include <sys/vnode.h>
 #include <sys/fcntl.h>
@@ -51,6 +51,7 @@
 #include <sys/lock.h>
 #include <sys/conf.h>
 #include <sys/stat.h>
+#include <sys/thread2.h>
 #include <vm/vm.h>
 #include <vm/vm_extern.h>
 #include <vm/swap_pager.h>
@@ -82,13 +83,12 @@ struct vnode *swapdev_vp;
  */
 
 static int
-swapdev_strategy(ap)
-       struct vop_strategy_args /* {
-               struct vnode *a_vp;
-               struct buf *a_bp;
-       } */ *ap;
+swapdev_strategy(struct vop_strategy_args /* {
+                        struct vnode *a_vp;
+                        struct buf *a_bp;
+                } */ *ap)
 {
-       int s, sz, off, seg, index;
+       int sz, off, seg, index;
        struct swdevt *sp;
        struct vnode *vp;
        struct buf *bp;
@@ -137,7 +137,7 @@ swapdev_strategy(ap)
        bp->b_blkno = ctodb(bp->b_blkno);
 
        vhold(sp->sw_vp);
-       s = splvm();
+       crit_enter();
        if ((bp->b_flags & B_READ) == 0) {
                vp = bp->b_vp;
                if (vp) {
@@ -150,7 +150,7 @@ swapdev_strategy(ap)
                sp->sw_vp->v_numoutput++;
        }
        pbreassignbuf(bp, sp->sw_vp);
-       splx(s);
+       crit_exit();
        VOP_STRATEGY(bp->b_vp, bp);
        return 0;
 }
@@ -159,14 +159,14 @@ swapdev_strategy(ap)
  * Create a special vnode op vector for swapdev_vp - we only use
  * VOP_STRATEGY(), everything else returns an error.
  */
-vop_t **swapdev_vnodeop_p;
+struct vop_ops *swapdev_vnode_vops;
 static struct vnodeopv_entry_desc swapdev_vnodeop_entries[] = {  
-       { &vop_default_desc,            (vop_t *) vop_defaultop },
-       { &vop_strategy_desc,           (vop_t *) swapdev_strategy },
+       { &vop_default_desc,            vop_defaultop },
+       { &vop_strategy_desc,           (void *) swapdev_strategy },
        { NULL, NULL }
 };
 static struct vnodeopv_desc swapdev_vnodeop_opv_desc =
-       { &swapdev_vnodeop_p, swapdev_vnodeop_entries };
+       { &swapdev_vnode_vops, swapdev_vnodeop_entries, 0 };
 
 VNODEOP_SET(swapdev_vnodeop_opv_desc);
 
@@ -184,7 +184,7 @@ swapon(struct swapon_args *uap)
        struct thread *td = curthread;
        struct vattr attr;
        struct vnode *vp;
-       struct nameidata nd;
+       struct nlookupdata nd;
        int error;
        struct ucred *cred;
 
@@ -195,23 +195,25 @@ swapon(struct swapon_args *uap)
        if (error)
                return (error);
 
-       NDINIT(&nd, NAMEI_LOOKUP, CNP_FOLLOW, UIO_USERSPACE, uap->name, td);
-       error = namei(&nd);
+       vp = NULL;
+       error = nlookup_init(&nd, uap->name, UIO_USERSPACE, NLC_FOLLOW);
+       if (error == 0)
+               error = nlookup(&nd);
+       if (error == 0)
+               error = cache_vref(nd.nl_ncp, nd.nl_cred, &vp);
+       nlookup_done(&nd);
        if (error)
                return (error);
 
-       NDFREE(&nd, NDF_ONLY_PNBUF);
-       vp = nd.ni_vp;
-
        if (vn_isdisk(vp, &error))
-               error = swaponvp(td, vp, vp->v_rdev, 0);
+               error = swaponvp(td, vp, 0);
        else if (vp->v_type == VREG && vp->v_tag == VT_NFS &&
            (error = VOP_GETATTR(vp, &attr, td)) == 0) {
                /*
                 * Allow direct swapping to NFS regular files in the same
                 * way that nfs_mountroot() sets up diskless swapping.
                 */
-               error = swaponvp(td, vp, NODEV, attr.va_size / DEV_BSIZE);
+               error = swaponvp(td, vp, attr.va_size / DEV_BSIZE);
        }
 
        if (error)
@@ -232,26 +234,28 @@ swapon(struct swapon_args *uap)
  * XXX locking when multiple swapon's run in parallel
  */
 int
-swaponvp(struct thread *td, struct vnode *vp, dev_t dev, u_long nblks)
+swaponvp(struct thread *td, struct vnode *vp, u_long nblks)
 {
-       int index;
+       u_long aligned_nblks;
+       struct ucred *cred;
        struct swdevt *sp;
        swblk_t vsbase;
-       long blk;
        swblk_t dvbase;
+       dev_t dev;
+       int index;
        int error;
-       u_long aligned_nblks;
-       struct ucred *cred;
+       long blk;
 
        KKASSERT(td->td_proc);
        cred = td->td_proc->p_ucred;
 
        if (!swapdev_vp) {
-               error = getnewvnode(VT_NON, NULL, swapdev_vnodeop_p,
-                   &swapdev_vp);
+               error = getspecialvnode(VT_NON, NULL, &swapdev_vnode_vops,
+                                   &swapdev_vp, 0, 0);
                if (error)
                        panic("Cannot get vnode for swapdev");
                swapdev_vp->v_type = VNON;      /* Untyped */
+               vx_unlock(swapdev_vp);
        }
 
        ASSERT_VOP_UNLOCKED(vp, "swaponvp");
@@ -264,12 +268,21 @@ swaponvp(struct thread *td, struct vnode *vp, dev_t dev, u_long nblks)
        }
        return EINVAL;
     found:
-       (void) vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
-       error = VOP_OPEN(vp, FREAD | FWRITE, cred, td);
-       (void) VOP_UNLOCK(vp, 0, td);
+       vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
+       error = VOP_OPEN(vp, FREAD | FWRITE, cred, NULL, td);
+       VOP_UNLOCK(vp, 0, td);
        if (error)
                return (error);
 
+       /*
+        * v_rdev is not valid until after the VOP_OPEN() call.  dev_psize()
+        * must be supported if a character device has been specified.
+        */
+       if (vp->v_type == VCHR)
+               dev = vp->v_rdev;
+       else
+               dev = NODEV;
+
        if (nblks == 0 && dev != NODEV && ((nblks = dev_dpsize(dev)) == -1)) {
                (void) VOP_CLOSE(vp, FREAD | FWRITE, td);
                return (ENXIO);