root/xfs/xfs_vnodeops-bsd.c

DEFINITIONS

1. xfs_open
2. xfs_fsync
3. xfs_close
4. xfs_read
5. xfs_write
6. xfs_ioctl
7. xfs_select
8. xfs_seek
9. xfs_poll
10. xfs_getattr
11. xfs_setattr
12. xfs_access
13. xfs_lookup
14. xfs_cachedlookup
15. cleanup_cnp
16. xfs_create
17. xfs_remove
18. xfs_rename
19. xfs_mkdir
20. xfs_rmdir
21. xfs_readdir
22. xfs_link
23. xfs_symlink
24. xfs_readlink
25. xfs_inactive
26. xfs_reclaim
27. xfs_lock
28. xfs_unlock
29. xfs_islocked
30. xfs_lock
31. xfs_unlock
32. xfs_islocked
33. xfs_abortop
34. xfs_mmap
35. xfs_bmap
36. get_pages_endlength
37. xfs_getpages
38. xfs_putpages
39. xfs_cmp
40. xfs_realvp
41. xfs_cntl
42. xfs_print
43. xfs_advlock
44. xfs_revoke
45. xfs_pagein
46. xfs_pageout
47. xfs_createvobject
48. xfs_destroyvobject
49. xfs_getvobject
50. xfs_pathconf
51. xfs_eopnotsupp
52. xfs_returnzero
53. xfs_pushdirty

    1 /*
    2  * Copyright (c) 1995 - 2002 Kungliga Tekniska Högskolan
    3  * (Royal Institute of Technology, Stockholm, Sweden).
    4  * All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  *
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  *
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  *
   17  * 3. Neither the name of the Institute nor the names of its contributors
   18  *    may be used to endorse or promote products derived from this software
   19  *    without specific prior written permission.
   20  *
   21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
   22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
   25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   31  * SUCH DAMAGE.
   32  */
   34 /*
   35  * NNPFS operations.
   36  */
   38 #ifdef __APPLE__
   39 #define MACH_KERNEL 1
   40 #endif
   42 #include <xfs/xfs_locl.h>
   43 #include <xfs/xfs_message.h>
   44 #include <xfs/xfs_common.h>
   45 #include <xfs/xfs_fs.h>
   46 #include <xfs/xfs_dev.h>
   47 #include <xfs/xfs_deb.h>
   48 #include <xfs/xfs_syscalls.h>
   49 #include <xfs/xfs_vnodeops.h>
   50 #ifdef HAVE_VM_VNODE_PAGER_H
   51 #include <vm/vnode_pager.h>
   52 #endif
   54 #include <sys/pool.h>
RCSID("$arla: xfs_vnodeops-bsd.c,v 1.123 2003/02/15 16:40:36 lha Exp $");
   58 /*
   59  * vnode functions
   60  */
   62 #ifdef HAVE_VOP_OPEN
   63 int
xfs_open(struct vop_open_args * ap)
   65      /*
   66   struct vop_open {
   67           struct vnode *vp;
   68           int mode;
   69           struct ucred *cred;
   70           struct proc *p;
   71   }; */
   72 {
   73 #ifdef HAVE_FREEBSD_THREAD
   74     return xfs_open_common (ap->a_vp, ap->a_mode, ap->a_cred, ap->a_td);
   75 #else
   76     return xfs_open_common (ap->a_vp, ap->a_mode, ap->a_cred, ap->a_p);
   77 #endif
   78 }
   79 #endif /* HAVE_VOP_OPEN */
   81 #ifdef HAVE_VOP_FSYNC
   82 int
xfs_fsync(struct vop_fsync_args * ap)
   84      /*
   85   vop_fsync {
   86         struct vnode *vp;
   87         struct ucred *cred;
   88         int waitfor;
   89         struct proc *p;
   90 };  */
   91 {
   92 #ifdef HAVE_STRUCT_VOP_FSYNC_ARGS_A_FLAGS
   93     return xfs_fsync_common(ap->a_vp, ap->a_cred, ap->a_flags, ap->a_p);
   94 #else
   95 #ifdef HAVE_FREEBSD_THREAD
   96     return xfs_fsync_common(ap->a_vp, ap->a_cred, ap->a_waitfor, ap->a_td);
   97 #else
   98     return xfs_fsync_common(ap->a_vp, ap->a_cred, ap->a_waitfor, ap->a_p);
   99 #endif
  100 #endif
  101 }
  102 #endif /* HAVE_VOP_FSYNC */
  104 #ifdef HAVE_VOP_CLOSE 
  105 int
xfs_close(struct vop_close_args * ap)
  107      /* vop_close {
  108         IN struct vnode *vp;
  109         IN int fflag;
  110         IN struct ucred *cred;
  111         IN struct proc *p;
  112   }; */
  113 {
  114 #ifdef HAVE_FREEBSD_THREAD
  115     return xfs_close_common(ap->a_vp, ap->a_fflag, ap->a_td, ap->a_cred);
  116 #else
  117     return xfs_close_common(ap->a_vp, ap->a_fflag, ap->a_p, ap->a_cred);
  118 #endif
  119 }
  120 #endif /* HAVE_VOP_CLOSE */
  122 #ifdef HAVE_VOP_READ
  123 int
xfs_read(struct vop_read_args * ap)
  125      /* vop_read {
  126         IN struct vnode *vp;
  127         INOUT struct uio *uio;
  128         IN int ioflag;
  129         IN struct ucred *cred;
  130    }; */
  131 {
  132     return xfs_read_common(ap->a_vp, ap->a_uio, ap->a_ioflag, ap->a_cred);
  133 }
  134 #endif /* HAVE_VOP_READ */
  136 #ifdef HAVE_VOP_WRITE
  137 int
xfs_write(struct vop_write_args * ap)
  139      /* vop_write {
  140         IN struct vnode *vp;
  141         INOUT struct uio *uio;
  142         IN int ioflag;
  143         IN struct ucred *cred;
  144    }; */
  145 {
  146     return xfs_write_common(ap->a_vp, ap->a_uio, ap->a_ioflag, ap->a_cred);
  147 }
  148 #endif /* HAVE_VOP_WRITE */
  150 #ifdef HAVE_VOP_IOCTL
  151 int
xfs_ioctl(struct vop_ioctl_args * ap)
  153      /* struct vnode *vp,
  154           int com,
  155           caddr_t data,
  156           int flag,
  157           struct ucred *cred) */
  158 {
NNPFSDEB(XDEBVNOPS, ("xfs_ioctl\n"));
  161     return EOPNOTSUPP;
  162 }
  163 #endif /* HAVE_VOP_IOCTL */
  165 #ifdef HAVE_VOP_SELECT
  166 int
xfs_select(struct vop_select_args * ap)
  168      /* struct vnode *vp,
  169            int which,
  170            struct ucred *cred ) */
  171 {
NNPFSDEB(XDEBVNOPS, ("xfs_select\n"));
  174     return EOPNOTSUPP;
  175 }
  176 #endif /* HAVE_VOP_SELECT */
  178 #ifdef HAVE_VOP_SEEK
  179 int
xfs_seek(struct vop_seek_args * ap)
  181      /*
  182 struct vop_seek_args {
  183         struct vnodeop_desc *a_desc;
  184         struct vnode *a_vp;
  185         off_t a_oldoff;
  186         off_t a_newoff;
  187         struct ucred *a_cred;
  188 };
  189 */
  190 {
NNPFSDEB(XDEBVNOPS, ("xfs_seek\n"));
  192     return 0;
  193 }
  194 #endif /* HAVE_VOP_SEEK */
  196 #ifdef HAVE_VOP_POLL
  197 int
xfs_poll(struct vop_poll_args * ap)
  199      /* vop_poll {
  200         IN struct vnode *vp;
  201         IN int events;
  202         IN struct proc *p;
  203    }; */
  204 {
NNPFSDEB(XDEBVNOPS, ("xfs_poll\n"));
  206     return EOPNOTSUPP;
  207 }
  208 #endif /* HAVE_VOP_POLL */
  210 #ifdef HAVE_VOP_GETATTR
  211 int
xfs_getattr(struct vop_getattr_args * ap)
  213      /* struct vnode *vp,
  214             struct vattr *vap,
  215             struct ucred *cred,
  216             struct proc *p) */
  217 {
  218 #ifdef HAVE_FREEBSD_THREAD
  219     return xfs_getattr_common(ap->a_vp, ap->a_vap, ap->a_cred, ap->a_td);
  220 #else
  221     return xfs_getattr_common(ap->a_vp, ap->a_vap, ap->a_cred, ap->a_p);
  222 #endif
  223 }
  224 #endif /* HAVE_VOP_GETATTR */
  226 #ifdef HAVE_VOP_SETATTR
  227 int
xfs_setattr(struct vop_setattr_args * ap)
  229      /* struct vnode *vp,
  230             struct vattr *vap,
  231             struct ucred *cred,
  232             struct proc *p)
  233             */
  234 {
  235 #ifdef HAVE_FREEBSD_THREAD
  236     return xfs_setattr_common(ap->a_vp, ap->a_vap, ap->a_cred, ap->a_td);
  237 #else
  238     return xfs_setattr_common(ap->a_vp, ap->a_vap, ap->a_cred, ap->a_p);
  239 #endif
  240 }
  241 #endif /* HAVE_VOP_SETATTR */
  243 #ifdef HAVE_VOP_ACCESS
  244 int
xfs_access(struct vop_access_args * ap)
  246      /*
  247 struct vnode *vp,
  248            int mode,
  249            struct ucred *cred,
  250            struct proc *p)
  251            */
  252 {
  253 #ifdef HAVE_FREEBSD_THREAD
  254     return xfs_access_common(ap->a_vp, ap->a_mode, ap->a_cred, ap->a_td);
  255 #else
  256     return xfs_access_common(ap->a_vp, ap->a_mode, ap->a_cred, ap->a_p);
  257 #endif
  258 }
  259 #endif /* HAVE_VOP_ACCESS */
  261 #ifdef HAVE_VOP_LOOKUP
  262 int
xfs_lookup(struct vop_lookup_args * ap)
  264      /* struct vop_lookup_args {
  265         struct vnodeop_desc *a_desc;
  266         struct vnode *a_dvp;
  267         struct vnode **a_vpp;
  268         struct componentname *a_cnp;
  269 }; */
  270 {
  271     struct componentname *cnp = ap->a_cnp;
  272     int error;
  273     int lockparent = (cnp->cn_flags & (LOCKPARENT | ISLASTCN))
  274         == (LOCKPARENT | ISLASTCN);
NNPFSDEB(XDEBVNOPS, ("xfs_lookup: (%s, %ld), nameiop = %lu, flags = %lu\n",
cnp->cn_nameptr,
cnp->cn_namelen,
cnp->cn_nameiop,
cnp->cn_flags));
  282 #ifdef PDIRUNLOCK
cnp->cn_flags &= ~PDIRUNLOCK;
  284 #endif
error = xfs_lookup_common(ap->a_dvp, cnp, ap->a_vpp);
  288     if (error == ENOENT
  289         && (cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME)
  290         && (cnp->cn_flags & ISLASTCN)) {
error = EJUSTRETURN;
  292     }
  294     if (cnp->cn_nameiop != LOOKUP && cnp->cn_flags & ISLASTCN)
cnp->cn_flags |= SAVENAME;
  297     if (error == 0 || error == EJUSTRETURN) {
  298         if (ap->a_dvp == *(ap->a_vpp)) {
  299             /* if we looked up ourself, do nothing */
  300         } else if (!(cnp->cn_flags & ISLASTCN) || !lockparent) {
  301             /* if we isn't last component and is isn't requested,
  302              * return parent unlocked */
  303 #ifdef HAVE_FREEBSD_THREAD
xfs_vfs_unlock (ap->a_dvp, xfs_cnp_to_thread(cnp));
  305 #else
xfs_vfs_unlock (ap->a_dvp, xfs_cnp_to_proc(cnp));
  307 #endif
  308 #ifdef PDIRUNLOCK
cnp->cn_flags |= PDIRUNLOCK;
  310 #endif
  311         }
  312     } else {
  313         /* in case of a error do nothing  */
  314     } 
NNPFSDEB(XDEBVNOPS, ("xfs_lookup: error = %d\n", error));
  318     return error;
  319 }
  320 #endif /* HAVE_VOP_LOOKUP */
  322 #ifdef HAVE_VOP_CACHEDLOOKUP
  323 int
xfs_cachedlookup(struct vop_cachedlookup_args * ap)
  325      /* struct vop_cachedlookup_args {
  326         struct vnodeop_desc *a_desc;
  327         struct vnode *a_dvp;
  328         struct vnode **a_vpp;
  329         struct componentname *a_cnp;
  330 }; */
  331 {
  332     return xfs_lookup((struct vop_lookup_args *)ap);
  333 }
  334 #endif /* HAVE_VOP_CACHEDLOOKUP */
  336 /*
  337  * whatever clean-ups are needed for a componentname.
  338  */
  340 static void
cleanup_cnp (struct componentname *cnp, int error)
  342 {
  343     if (error != 0 || (cnp->cn_flags & SAVESTART) == 0) {
  344 #if defined(HAVE_KERNEL_ZFREEI)
zfreei(namei_zone, cnp->cn_pnbuf);
cnp->cn_flags &= ~HASBUF;
  347 #elif defined(HAVE_KERNEL_UMA_ZFREE_ARG)
uma_zfree_arg(namei_zone, cnp->cn_pnbuf, NULL);
cnp->cn_flags &= ~HASBUF;
  350 #elif defined(FREE_ZONE)
FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
  352 #elif defined(HAVE_KERNEL_ZFREE)
zfree(namei_zone, cnp->cn_pnbuf);
cnp->cn_flags &= ~HASBUF;
  355 #elif defined(PNBUF_PUT)
PNBUF_PUT(cnp->cn_pnbuf);
  357 #else
pool_put(&namei_pool, cnp->cn_pnbuf);
  359 #endif
  360     }
  361 }
  363 #ifdef HAVE_VOP_CREATE
  364 int
xfs_create(struct vop_create_args *ap)
  366 {
  367     struct vnode *dvp  = ap->a_dvp;
  368     struct componentname *cnp = ap->a_cnp;
  369     const char *name   = cnp->cn_nameptr;
  370     struct ucred *cred = cnp->cn_cred;
  371 #ifdef HAVE_FREEBSD_THREAD
d_thread_t *p     = xfs_cnp_to_thread(cnp);
  373 #else
d_thread_t *p     = xfs_cnp_to_proc(cnp);
  375 #endif
  376     int error;
error = xfs_create_common(dvp, name, ap->a_vap, cred, p);
  380     if (error == 0) {
error = xfs_lookup_common(dvp, cnp, ap->a_vpp);
  382     }
cleanup_cnp (cnp, error);
  386 #if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__APPLE__)
vput (dvp);
  388 #endif
NNPFSDEB(XDEBVNOPS, ("xfs_create: error = %d\n", error));
  392     return error;
  393 }
  394 #endif /* HAVE_VOP_CREATE */
  396 #ifdef HAVE_VOP_REMOVE
  397 int
xfs_remove(struct vop_remove_args * ap)
  399      /* struct vnode *dvp,
  400    struct vnode *vp,
  401    struct componentname *cnp */
  402 {
  403     struct componentname *cnp = ap->a_cnp;
  404     struct vnode *dvp = ap->a_dvp;
  405     struct vnode *vp  = ap->a_vp;
  407 #ifdef HAVE_FREEBSD_THREAD
  408     int error = xfs_remove_common(dvp, vp, cnp->cn_nameptr, 
cnp->cn_cred, xfs_cnp_to_thread(cnp));
  410 #else
  411     int error = xfs_remove_common(dvp, vp, cnp->cn_nameptr, 
cnp->cn_cred, xfs_cnp_to_proc(cnp));
  413 #endif
cleanup_cnp (cnp, error);
  417 #if !defined(__FreeBSD__) || __FreeBSD_version < 300000
  418     if (dvp == vp)
vrele(vp);
  420     else
vput(vp);
vput(dvp);
  423 #endif
  425 #ifdef __APPLE__
  426     if (error == 0) {
  427         if (UBCINFOEXISTS(vp)) {
ubc_setsize(vp, 0);
ubc_release(vp);
ubc_uncache(vp);
  431         }
  432     }
  433 #endif
  435     return error;
  436 }
  437 #endif /* HAVE_VOP_REMOVE */
  439 #ifdef HAVE_VOP_RENAME
  440 int
xfs_rename(struct vop_rename_args * ap)
  442      /* vop_rename {
  443         IN WILLRELE struct vnode *fdvp;
  444         IN WILLRELE struct vnode *fvp;
  445         IN struct componentname *fcnp;
  446         IN WILLRELE struct vnode *tdvp;
  447         IN WILLRELE struct vnode *tvp;
  448         IN struct componentname *tcnp;
  449   }; */
  450 {
  451     struct vnode *tdvp = ap->a_tdvp;
  452     struct vnode *tvp  = ap->a_tvp;
  453     struct vnode *fdvp = ap->a_fdvp;
  454     struct vnode *fvp  = ap->a_fvp;
  456     int error = xfs_rename_common(fdvp,
fvp,
ap->a_fcnp->cn_nameptr,
tdvp,
tvp,
ap->a_tcnp->cn_nameptr,
ap->a_tcnp->cn_cred,
  463 #ifdef HAVE_FREEBSD_THREAD
xfs_cnp_to_thread (ap->a_fcnp));
  465 #else
xfs_cnp_to_proc (ap->a_fcnp));
  467 #endif
  468     if(tdvp == tvp)
vrele(tdvp);
  470     else
vput(tdvp);
  472     if(tvp)
vput(tvp);
vrele(fdvp);
vrele(fvp);
  476     return error;
  477 }
  478 #endif /* HAVE_VOP_RENAME */
  480 #ifdef HAVE_VOP_MKDIR
  481 int
xfs_mkdir(struct vop_mkdir_args * ap)
  483      /* struct vnode *dvp,
  484           char *nm,
  485           struct vattr *va,
  486           struct vnode **vpp,
  487           struct ucred *cred)      */
  488 {
  489     struct vnode *dvp  = ap->a_dvp;
  490     struct componentname *cnp = ap->a_cnp;
  491     const char *name   = cnp->cn_nameptr;
  492     struct ucred *cred = cnp->cn_cred;
  493 #ifdef HAVE_FREEBSD_THREAD
d_thread_t *p     = xfs_cnp_to_thread(cnp);
  495 #else
d_thread_t *p     = xfs_cnp_to_proc(cnp);
  497 #endif
  498     int error;
error = xfs_mkdir_common(dvp, name, ap->a_vap, cred, p);
  502     if (error == 0)
error = xfs_lookup_common(dvp, cnp, ap->a_vpp);
cleanup_cnp (cnp, error);
  507 #if defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__)
vput(dvp);
  509 #endif
NNPFSDEB(XDEBVNOPS, ("xfs_mkdir: error = %d\n", error));
  513     return error;
  514 }
  515 #endif /* HAVE_VOP_MKDIR */
  517 #ifdef HAVE_VOP_RMDIR
  518 int
xfs_rmdir(struct vop_rmdir_args * ap)
  520      /* struct vnode *dvp,
  521    struct vnode *vp,
  522    struct componentname *cnp */
  523 {
  524     struct componentname *cnp = ap->a_cnp;
  525     struct vnode *dvp = ap->a_dvp;
  526     struct vnode *vp  = ap->a_vp;
  527     int error = xfs_rmdir_common(ap->a_dvp, ap->a_vp, 
cnp->cn_nameptr,
cnp->cn_cred,
  530 #ifdef HAVE_FREEBSD_THREAD
xfs_cnp_to_thread(cnp));
  532 #else
xfs_cnp_to_proc(cnp));
  534 #endif
cleanup_cnp (cnp, error);
  537 #if !defined(__FreeBSD__) || __FreeBSD_version < 300000
  538     if (dvp == vp)
vrele(vp);
  540     else
vput(vp);
vput(dvp);
  543 #endif
  545     return error;
  546 }
  547 #endif /* HAVE_VOP_RMDIR */
  549 #ifdef HAVE_VOP_READDIR
  551 #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__APPLE__)
  552 typedef u_long xfs_cookie_t;
  553 #elif defined(__NetBSD__)
  554 typedef off_t xfs_cookie_t;
  555 #else
  556 #error dunno want kind of cookies you have
  557 #endif
  559 int
xfs_readdir(struct vop_readdir_args * ap)
  561      /* struct vnode *vp,
  562             struct uio *uiop,
  563             struct ucred *cred) */
  564 {
  565     int error;
off_t off;
off = ap->a_uio->uio_offset;
error = xfs_readdir_common(ap->a_vp, ap->a_uio, ap->a_cred,
  571 #ifdef HAVE_FREEBSD_THREAD
xfs_uio_to_thread (ap->a_uio),
  573 #else
xfs_uio_to_proc (ap->a_uio),
  575 #endif
ap->a_eofflag);
  578     if (!error && ap->a_ncookies != NULL) {
  579         struct uio *uio = ap->a_uio;
  580         const struct dirent *dp, *dp_start, *dp_end;
  581         int ncookies;
xfs_cookie_t *cookies, *cookiep;
  584         if (uio->uio_segflg != UIO_SYSSPACE || uio->uio_iovcnt != 1)
panic("xfs_readdir: mail arla-drinkers and tell them to bake burned cookies");
dp = (const struct dirent *)
  587             ((const char *)uio->uio_iov->iov_base - (uio->uio_offset - off));
dp_end = (const struct dirent *) uio->uio_iov->iov_base;
  590         for (dp_start = dp, ncookies = 0;
dp < dp_end;
dp = (const struct dirent *)((const char *) dp + dp->d_reclen)) {
  593             if (dp->d_reclen <= 0)
  594                 break;
ncookies++;
  596         }
MALLOC(cookies, xfs_cookie_t *, ncookies * sizeof(xfs_cookie_t),
M_TEMP, M_WAITOK);
  600         for (dp = dp_start, cookiep = cookies;
dp < dp_end;
dp = (const struct dirent *)((const char *) dp + dp->d_reclen)) {
  603             if (dp->d_reclen <= 0)
  604                 break;
off += dp->d_reclen;
  606             *cookiep++ = off;
  607         }
  608         *ap->a_cookies = cookies;
  609         *ap->a_ncookies = ncookies;
  610     }
  611     return error;
  612 }
  613 #endif /* HAVE_VOP_READDIR */
  615 #ifdef HAVE_VOP_LINK
  616 int
xfs_link(struct vop_link_args * ap)
  618      /*
  619         WILLRELE struct vnode *tdvp;
  620         struct vnode *vp;
  621         struct componentname *cnp;
  622         */
  623 {
  624     struct componentname *cnp = ap->a_cnp;
  625     struct vnode *vp = ap->a_vp;
  626     struct vnode *dvp;
  627 #ifdef HAVE_FREEBSD_THREAD
d_thread_t *p = cnp->cn_thread;
  629 #else
d_thread_t *p = cnp->cn_proc;
  631 #endif
  632     int error;
  634 #if defined (__OpenBSD__) || defined(__NetBSD__)
dvp = ap->a_dvp;
  636 #elif defined(__FreeBSD__) || defined(__APPLE__)
dvp = ap->a_tdvp;
  638 #else
  639 #error what kind of BSD is this?
  640 #endif
  642     if (vp->v_type == VDIR) {
  643 #ifdef HAVE_VOP_ABORTOP
VOP_ABORTOP(dvp, cnp);
  645 #endif
error = EPERM;
  647             goto out;
  648     }
  649     if (dvp->v_mount != vp->v_mount) {
  650 #ifdef HAVE_VOP_ABORTOP
VOP_ABORTOP(dvp, cnp);
  652 #endif
error = EXDEV;
  654             goto out;
  655     }
  656     /* FreeBSD 5.0 doesn't need to lock the vnode in VOP_LINK */
  657 #if !defined(__FreeBSD_version) || __FreeBSD_version < 500043
  659     if (dvp != vp && (error = xfs_vfs_writelock(vp, p))) {
  660 #ifdef HAVE_VOP_ABORTOP
VOP_ABORTOP(dvp, cnp);
  662 #endif
  663             goto out;
  664     }
  665 #endif /* defined(__FreeBSD_version) || __FreeBSD_version < 500043 */
error = xfs_link_common(
dvp,
vp,
cnp->cn_nameptr,
cnp->cn_cred,
  672 #ifdef HAVE_FREEBSD_THREAD
xfs_cnp_to_thread (cnp));
  674 #else
xfs_cnp_to_proc (cnp));
  676 #endif
cleanup_cnp (cnp, error);
  680     if (dvp != vp)
xfs_vfs_unlock(vp, p);
out:
  684 #if defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__)
vput(dvp);
  686 #endif
  688     return error;
  689 }
  690 #endif /* HAVE_VOP_LINK */
  692 #ifdef HAVE_VOP_SYMLINK
  693 int
xfs_symlink(struct vop_symlink_args * ap)
  695      /*
  696   IN WILLRELE struct vnode *dvp;
  697   OUT WILLRELE struct vnode **vpp;
  698   IN struct componentname *cnp;
  699   IN struct vattr *vap;
  700   IN char *target;
  701   */
  702 {
  703     struct componentname *cnp = ap->a_cnp;
  704     struct vnode *dvp  = ap->a_dvp;
  705     struct vnode **vpp = ap->a_vpp;
  707     int error = xfs_symlink_common(dvp,
vpp,
cnp,
ap->a_vap,
ap->a_target);
  713     if (error == 0) {
error = xfs_lookup_common(dvp, cnp, vpp);
  715         if (error == 0)
vput (*vpp);
  717     }
cleanup_cnp (cnp, error);
  719 #if !defined(__FreeBSD__)
vput(dvp);
  721 #endif
  722     return error;
  723 }
  724 #endif /* HAVE_VOP_SYMLINK */
  727 #ifdef HAVE_VOP_READLINK
  728 int
xfs_readlink(struct vop_readlink_args * ap)
  730      /* struct vnode *vp,
  731              struct uio *uiop,
  732              struct ucred *cred) */
  733 {
  734     return xfs_readlink_common(ap->a_vp, ap->a_uio, ap->a_cred);
  735 }
  736 #endif /* HAVE_VOP_READLINK */
  738 #ifdef HAVE_VOP_INACTIVE
  739 int
xfs_inactive(struct vop_inactive_args * ap)
  741      /*struct vnode *vp,
  742              struct ucred *cred)*/
  743 {
  744 #ifdef HAVE_FREEBSD_THREAD
  745     return xfs_inactive_common(ap->a_vp, xfs_curthread());
  746 #else
  747     return xfs_inactive_common(ap->a_vp, xfs_curproc());
  748 #endif
  749 }
  750 #endif /* HAVE_VOP_INACTICE */
  752 #ifdef HAVE_VOP_RECLAIM
  753 int
xfs_reclaim(struct vop_reclaim_args * ap)
  755      /*struct vop_reclaim_args {
  756         struct vnodeop_desc *a_desc;
  757         struct vnode *a_vp;
  758 };*/
  759 {
  760     struct vnode *vp = ap->a_vp;
  761     int ret;
ret = xfs_reclaim_common(vp);
vp->v_data = NULL;
  765     return ret;
  766 }
  767 #endif /* HAVE_VOP_RECLAIM */
  769 /*
  770  * Do lock, unlock, and islocked with lockmgr if we have it.
  771  */
  773 #if defined(HAVE_KERNEL_LOCKMGR) || defined(HAVE_KERNEL_DEBUGLOCKMGR)
  775 #ifdef HAVE_VOP_LOCK
  776 int
xfs_lock(struct vop_lock_args * ap)
  778 {               
  779     struct vnode *vp    = ap->a_vp;
  780     struct xfs_node *xn = VNODE_TO_XNODE(vp);
xfs_vnode_lock *l   = &xn->lock;
  782     int flags           = ap->a_flags;
  783     int ret;
NNPFSDEB(XDEBVNOPS, ("xfs_lock: %lx, flags 0x%x\n",
  786                        (unsigned long)vp, flags));
  788     if (l == NULL)
panic("xfs_lock: lock NULL");
NNPFSDEB(XDEBVNOPS, ("xfs_lock before: lk flags: %d share: %d "
  792                          "wait: %d excl: %d holder: 0x%llx\n",
l->lk_flags, l->lk_sharecount, l->lk_waitcount,
l->lk_exclusivecount,
  795                          (unsigned long long)
  796                          (xfs_uintptr_t)l->lk_lockholder));
  798 #ifndef DEBUG_LOCKS
  799 #ifdef HAVE_FOUR_ARGUMENT_LOCKMGR
  800 #ifdef HAVE_FREEBSD_THREAD
ret = lockmgr(l, flags, &vp->v_interlock, ap->a_td);
  802 #else
ret = lockmgr(l, flags, &vp->v_interlock, ap->a_p);
  804 #endif
  805 #else
ret = lockmgr(l, flags, NULL);
  807 #endif
  808 #else
  809 #ifdef HAVE_FREEBSD_THREAD
ret = debuglockmgr(l, flags, &vp->v_interlock, ap->a_td,
  811                         "xfs_lock", ap->a_vp->filename, ap->a_vp->line);
  812 #else
ret = debuglockmgr(l, flags, &vp->v_interlock, ap->a_p,
  814                         "xfs_lock", ap->a_vp->filename, ap->a_vp->line);
  815 #endif
  816 #endif
NNPFSDEB(XDEBVNOPS, ("xfs_lock: lk flags: %d share: %d "
  818                          "wait: %d excl: %d holder: 0x%llx\n",
l->lk_flags, l->lk_sharecount, l->lk_waitcount,
l->lk_exclusivecount, 
  821                          (unsigned long long)
  822                          (xfs_uintptr_t)l->lk_lockholder));
  823     return ret;
  824 }
  825 #endif /* HAVE_VOP_LOCK */
  827 #ifdef HAVE_VOP_UNLOCK
  828 int
xfs_unlock(struct vop_unlock_args * ap)
  830 {
  831     struct vnode *vp    = ap->a_vp;
  832     struct xfs_node *xn = VNODE_TO_XNODE(vp);
xfs_vnode_lock *l   = &xn->lock;
  834     int flags           = ap->a_flags;
  835     int ret;
  837     if (l == NULL)
panic("xfs_unlock: lock NULL");
NNPFSDEB(XDEBVNOPS,
  841            ("xfs_unlock: %lx, flags 0x%x, l %lx, ap %lx\n",
  842             (unsigned long)vp, flags,
  843             (unsigned long)l,
  844             (unsigned long)ap));
NNPFSDEB(XDEBVNOPS, ("xfs_unlock: lk flags: %d share: %d "
  847                          "wait: %d excl: %d holder: 0x%lld\n",
l->lk_flags, l->lk_sharecount, l->lk_waitcount,
l->lk_exclusivecount, 
  850                          (unsigned long long)
  851                          (xfs_uintptr_t)l->lk_lockholder));
  852 #ifndef DEBUG_LOCKS
  853 #ifdef HAVE_FOUR_ARGUMENT_LOCKMGR
  854 #ifdef HAVE_FREEBSD_THREAD
ret = lockmgr (l, flags | LK_RELEASE, &vp->v_interlock, ap->a_td);
  856 #else
ret = lockmgr (l, flags | LK_RELEASE, &vp->v_interlock, ap->a_p);
  858 #endif
  859 #else
ret = lockmgr (l, flags | LK_RELEASE, NULL);
  861 #endif
  862 #else
  863 #ifdef HAVE_FREEBSD_THREAD
ret = debuglockmgr (l, flags | LK_RELEASE, &vp->v_interlock, ap->a_td,
  865                         "xfs_lock", ap->a_vp->filename, ap->a_vp->line);
  866 #else
ret = debuglockmgr (l, flags | LK_RELEASE, &vp->v_interlock, ap->a_p,
  868                         "xfs_lock", ap->a_vp->filename, ap->a_vp->line);
  869 #endif
  870 #endif
NNPFSDEB(XDEBVNOPS, ("xfs_unlock: return %d\n", ret));
  872     return ret;
  873 }
  874 #endif /* HAVE_VOP_UNLOCK */
  876 #ifdef HAVE_VOP_ISLOCKED
  877 int
xfs_islocked (struct vop_islocked_args *ap)
  879 {
  880     struct vnode *vp    = ap->a_vp;
  881     struct xfs_node *xn = VNODE_TO_XNODE(vp);
xfs_vnode_lock *l   = &xn->lock;
NNPFSDEB(XDEBVNOPS, ("xfs_islocked: %lx\n",
  885                        (unsigned long)vp));
  887 #if defined(HAVE_TWO_ARGUMENT_LOCKSTATUS)
  888 #ifdef HAVE_FREEBSD_THREAD
  889     return lockstatus (l, ap->a_td);
  890 #else
  891     return lockstatus (l, ap->a_p);
  892 #endif
  893 #elif defined(HAVE_ONE_ARGUMENT_LOCKSTATUS)
  894     return lockstatus (l);
  895 #else
  896 #error what lockstatus?
  897 #endif
  898 }
  899 #endif /* HAVE_VOP_ISLOCKED */
  901 #else /* !HAVE_KERNEL_LOCKMGR && !HAVE_KERNEL_DEBUGLOCKMGR */
  903 #ifdef HAVE_VOP_LOCK
  904 int
xfs_lock(struct vop_lock_args * ap)
  906 {
  907     struct vnode *vp    = ap->a_vp;
  908     struct xfs_node *xn = VNODE_TO_XNODE(vp);
NNPFSDEB(XDEBVNOPS, ("xfs_lock: %lx, %d\n",
  911                        (unsigned long)vp, xn->vnlocks));
  913     while (vp->v_flag & VXLOCK) {
vp->v_flag |= VXWANT;
  915         (void) tsleep((caddr_t)vp, PINOD, "xfs_vnlock", 0);
  916     }
  917     if (vp->v_tag == VT_NON)
  918         return (ENOENT);
  919     ++xn->vnlocks;
  920     return 0;
  921 }
  922 #endif /* HAVE_VOP_LOCK */
  924 #ifdef HAVE_VOP_UNLOCK
  925 int
xfs_unlock(struct vop_unlock_args * ap)
  927 {
  928     struct vnode *vp    = ap->a_vp;
  929     struct xfs_node *xn = VNODE_TO_XNODE(vp);
NNPFSDEB(XDEBVNOPS, ("xfs_unlock: %lx, %d\n",
  931                        (unsigned long)vp, xn->vnlocks));
  933     --xn->vnlocks;
  934     if (xn->vnlocks < 0) {
printf ("PANIC: xfs_unlock: unlocking unlocked\n");
xn->vnlocks = 0;
  937     }
NNPFSDEB(XDEBVNOPS, ("xfs_unlock: return\n"));
  940     return 0;
  941 }
  942 #endif /* HAVE_VOP_UNLOCK */
  944 #ifdef HAVE_VOP_ISLOCKED
  945 int
xfs_islocked (struct vop_islocked_args *ap)
  947 {
  948     struct vnode *vp    = ap->a_vp;
  949     struct xfs_node *xn = VNODE_TO_XNODE(vp);
NNPFSDEB(XDEBVNOPS, ("xfs_islocked: %lx, %d\n",
  952                        (unsigned long)vp, xn->vnlocks));
  954     return xn->vnlocks;
  955 }
  956 #endif /* HAVE_VOP_ISLOCKED */
  957 #endif /* !HAVE_KERNEL_LOCKMGR */
  959 #ifdef HAVE_VOP_ABORTOP
  960 int
xfs_abortop (struct vop_abortop_args *ap)
  962      /* struct vnode *dvp;
  963    struct componentname *cnp; */
  964 {
  965     struct componentname *cnp = ap->a_cnp;
  967     if ((cnp->cn_flags & (HASBUF | SAVESTART)) == HASBUF)
  968 #if defined(HAVE_KERNEL_ZFREEI)
zfreei(namei_zone, cnp->cn_pnbuf);
ap->a_cnp->cn_flags &= ~HASBUF;
  971 #elif defined(HAVE_KERNEL_UMA_ZFREE_ARG)
uma_zfree_arg(namei_zone, cnp->cn_pnbuf, NULL);
cnp->cn_flags &= ~HASBUF;
  974 #elif defined(FREE_ZONE)
FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
  976 #elif defined(HAVE_KERNEL_ZFREE)
zfree(namei_zone, cnp->cn_pnbuf);
ap->a_cnp->cn_flags &= ~HASBUF;
  979 #elif defined(PNBUF_PUT)
PNBUF_PUT(cnp->cn_pnbuf);
  981 #else
pool_put(&namei_pool, cnp->cn_pnbuf);
  983 #endif
  984     return 0;
  985 }
  986 #endif /* HAVE_VOP_ABORTOP */
  988 #ifdef HAVE_VOP_MMAP
  989 int
xfs_mmap(struct vop_mmap_args *ap)
  991      /*
  992         IN struct vnode *vp;
  993         IN int fflags;
  994         IN struct ucred *cred;
  995         IN struct proc *p;
  996         */
  997 {
NNPFSDEB(XDEBVNOPS, ("xfs_mmap\n"));
  999 #ifdef HAVE_KERNEL_GENFS_MMAP
 1000     return genfs_mmap(ap);
 1001 #else
 1002     return EOPNOTSUPP;
 1003 #endif
 1004 }
 1005 #endif /* HAVE_VOP_MMAP */
 1007 #ifdef HAVE_VOP_BMAP
 1008 int
xfs_bmap(struct vop_bmap_args *ap)
 1010      /* IN struct vnode *vp;
 1011         IN daddr64_t bn;
 1012         OUT struct vnode **vpp;
 1013         IN daddr64_t *bnp;
 1014         OUT int *runp;
 1015         OUT int *runb;
 1016         */
 1017 {
NNPFSDEB(XDEBVNOPS, ("xfs_bmap\n"));
 1019     return EOPNOTSUPP;
 1020 }
 1021 #endif /* HAVE_VOP_BMAP */
 1023 #ifdef HAVE_VOP_GETPAGES
 1025 static size_t
get_pages_endlength (struct vop_getpages_args *ap)
 1027 {
 1028 #ifdef HAVE_STRUCT_VOP_GETPAGES_ARGS_A_OFFSET
 1029     /* NetBSD ubc */
 1030     return (ap->a_offset << PAGE_SHIFT) + *ap->a_count * PAGE_SIZE;
 1031 #else
 1032     return (ap->a_reqpage << PAGE_SHIFT) +  ap->a_count * PAGE_SIZE;
 1033 #endif
 1034 }
 1036 int
xfs_getpages (struct vop_getpages_args *ap)
 1038      /* Old BSD
 1039         IN struct vnode *vp;
 1040         IN vm_page_t *m;
 1041         IN int count;
 1042         IN int reqpage;
 1043         IN vm_ooffset_t offset;
 1044      */
 1045     /* NetBSD UBC
 1046         IN struct vnode *vp;
 1047         IN voff_t offset;
 1048         IN vm_page_t *m;
 1049         IN int *count;
 1050         IN int centeridx;
 1051         IN vm_prot_t access_type;
 1052         IN int advice;
 1053         IN int flags;
 1054     */
 1055 {
 1056     int error;
NNPFSDEB(XDEBVNOPS, ("xfs_getpages\n"));
 1060 #if HAVE_KERNEL_VNODE_PAGER_GENERIC_GETPAGES
error = vnode_pager_generic_getpages (ap->a_vp, ap->a_m, 
ap->a_count, ap->a_reqpage);
 1063 #else
error = xfs_data_valid (ap->a_vp, VNODE_TO_XNODE(ap->a_vp)->rd_cred,
xfs_curproc(), NNPFS_DATA_R,
get_pages_endlength(ap));
 1067     if (error == 0)
error = VOP_GETPAGES(DATA_FROM_VNODE(ap->a_vp), 
ap->a_offset, ap->a_m,
ap->a_count, ap->a_centeridx, ap->a_access_type,
ap->a_advice, ap->a_flags);
 1072 #endif
NNPFSDEB(XDEBVNOPS, ("xfs_getpages = %d\n", error));
 1074     return error;
 1075 }
 1076 #endif /* HAVE_VOP_GETPAGES */
 1078 #ifdef HAVE_VOP_PUTPAGES
 1079 int
xfs_putpages (struct vop_putpages_args *ap)
 1081      /* Old BSD
 1082         IN struct vnode *vp;
 1083         IN vm_page_t *m;
 1084         IN int count;
 1085         IN int sync;
 1086         IN int *rtvals;
 1087         IN vm_ooffset_t offset;
 1088      */
 1089     /* NetBSD UBC (>= 1.5Y)
 1090         IN struct vnode *vp;
 1091         IN voff_t offlo;
 1092         IN voff_t offhi;
 1093         IN int flags;
 1094     */
 1095 {
 1096     struct vnode *vp    = ap->a_vp;
 1097     struct xfs_node *xn = VNODE_TO_XNODE(vp);
 1098     struct vnode *t     = DATA_FROM_XNODE(xn);
 1099     int error;
NNPFSDEB(XDEBVNOPS, ("xfs_putpages\n"));
 1103     if (t == NULL)
 1104         return 0;
 1106 #ifdef HAVE_STRUCT_VOP_PUTPAGES_ARGS_A_SYNC /* FreeBSD-style */
xn->flags |= NNPFS_DATA_DIRTY;
 1109     return VOP_PUTPAGES(t, ap->a_m, ap->a_count, ap->a_sync, ap->a_rtvals,
ap->a_offset);
 1111 #else /* NetBSD-style */
 1112 #if defined(__NetBSD__) && __NetBSD_Version__  >= 105250000 
 1113     /* XXX should only walk over those pages that is requested */
 1114     if (vp->v_type == VREG && ap->a_flags & PGO_CLEANIT) {
 1115         struct uvm_object *uobj = &t->v_uobj;
 1116         struct vm_page *pg;
 1117         int dirty = 0;
pg = TAILQ_FIRST(&uobj->memq);
 1121         while (pg && !dirty) {
dirty = pmap_is_modified(pg) || (pg->flags & PG_CLEAN) == 0;
pg = TAILQ_NEXT(pg, listq);
 1124         }       
 1126         if (dirty)
xn->flags |= NNPFS_DATA_DIRTY;
 1128     }
 1130     return VOP_PUTPAGES(t, ap->a_offlo, ap->a_offhi, ap->a_flags);
 1131 #else
xn->flags |= NNPFS_DATA_DIRTY;
 1133     return VOP_PUTPAGES(t, ap->a_m, ap->a_count, ap->a_flags, ap->a_rtvals);
 1134 #endif
 1135 #endif /* HAVE_STRUCT_VOP_PUTPAGES_ARGS_A_SYNC */
 1136 }
 1137 #endif /* HAVE_VOP_PUTPAGES */
 1139 #ifdef HAVE_VOP_CMP
 1140 int
 1141 xfs_cmp(struct vnode * vp1, struct vnode * vp2)
 1142 {
NNPFSDEB(XDEBVNOPS, ("xfs_cmp\n"));
 1144     return EOPNOTSUPP;
 1145 }
 1146 #endif /* HAVE_VOP_CMP */
 1148 #ifdef HAVE_VOP_REALVP
 1149 int
 1150 xfs_realvp(struct vnode * vp,
 1151            struct vnode ** vpp)
 1152 {
NNPFSDEB(XDEBVNOPS, ("xfs_realvp\n"));
 1154     return EOPNOTSUPP;
 1155 }
 1156 #endif /* HAVE_VOP_REALVP */
 1158 #ifdef HAVE_VOP_CNTL
 1159 int
 1160 xfs_cntl(struct vnode * vp,
 1161          int cmd,
caddr_t idata,
caddr_t odata,
 1164          int iflag,
 1165          int oflag)
 1166 {
NNPFSDEB(XDEBVNOPS, ("xfs_cntl\n"));
 1168     return EOPNOTSUPP;
 1169 }
 1170 #endif /* HAVE_VOP_CNTL */
 1172 #ifdef HAVE_VOP_PRINT
 1173 int
xfs_print (struct vop_print_args *v)
 1175 {
 1176     struct vop_print_args *ap = v;
xfs_printnode_common (ap->a_vp);
 1178     return 0;
 1179 }
 1180 #endif
 1182 #ifdef HAVE_VOP_ADVLOCK
 1183 int
xfs_advlock(struct vop_advlock_args *v)
 1185 {
 1186     struct vop_advlock_args *ap = v;
 1187 #if defined(HAVE_KERNEL_LF_ADVLOCK) && !defined(__APPLE__)
 1188     struct xfs_node *xn = VNODE_TO_XNODE(ap->a_vp);
 1190     return (lf_advlock(&xn->lockf, xn->attr.va_size, ap->a_id, ap->a_op,
ap->a_fl, ap->a_flags));
 1192 #else
 1193      return EOPNOTSUPP;
 1194 #endif
 1195 }
 1196 #endif /* HAVE_VOP_ADVOCK */
 1198 #ifdef HAVE_VOP_REVOKE
 1199 int
xfs_revoke(struct vop_revoke_args *v)
 1201 {
 1202 #if defined(HAVE_KERNEL_GENFS_REVOKE)
 1203     return genfs_revoke (v);
 1204 #elif defined(HAVE_KERNEL_VOP_REVOKE)
 1205     return vop_revoke (v);
 1206 #else
 1207     return EOPNOTSUPP;
 1208 #endif
 1209 }
 1210 #endif /* HAVE_VOP_REVOKE */
 1212 #ifdef HAVE_VOP_PAGEIN
 1213 int
xfs_pagein(struct vop_pagein_args *ap)
 1215 {
 1216 #ifdef __APPLE__
 1217     struct uio uio;
 1218     struct iovec iov;
 1219     int ret;
kernel_upl_map(kernel_map, ap->a_pl, &iov.iov_base);
iov.iov_base+=ap->a_pl_offset;
iov.iov_len=ap->a_size;
uio.uio_iov=&iov;
uio.uio_iovcnt=1;
uio.uio_offset=ap->a_f_offset;
uio.uio_resid=ap->a_size;
uio.uio_segflg=UIO_SYSSPACE; /* XXX what is it? */
uio.uio_rw=UIO_READ;
uio.uio_procp=xfs_curproc();
ret = VOP_READ(ap->a_vp, &uio, 0, ap->a_cred);
 1235     /* Zero out rest of last page if there wasn't enough data in the file */
 1236     if (ret == 0 && uio.uio_resid > 0)
bzero(iov.iov_base, uio.uio_resid);
kernel_upl_unmap(kernel_map, ap->a_pl);
 1241     if (ret) {
kernel_upl_abort_range(ap->a_pl, ap->a_pl_offset, ap->a_size,
UPL_ABORT_ERROR | UPL_ABORT_FREE_ON_EMPTY);
 1244     } else {
kernel_upl_commit_range(ap->a_pl, ap->a_pl_offset, ap->a_size,
UPL_COMMIT_CLEAR_DIRTY | UPL_COMMIT_FREE_ON_EMPTY,
UPL_GET_INTERNAL_PAGE_LIST(ap->a_pl));
 1248     }
 1250     return ret;
 1251 #else
 1252 #error pagein on non apple ?
 1253 #endif
 1254 }
 1256 #endif
 1258 #ifdef HAVE_VOP_PAGEOUT
 1259 int
xfs_pageout(struct vop_pageout_args *ap)
 1261 {
 1262 #ifdef __APPLE__
 1263     struct uio uio;
 1264     struct iovec iov;
 1265     int ret;
kernel_upl_map(kernel_map, ap->a_pl, &iov.iov_base);
iov.iov_base+=ap->a_pl_offset;
iov.iov_len=ap->a_size;
uio.uio_iov=&iov;
uio.uio_iovcnt=1;
uio.uio_offset=ap->a_f_offset;
uio.uio_resid=ap->a_size;
uio.uio_segflg=UIO_SYSSPACE; /* XXX what is it? */
uio.uio_rw=UIO_WRITE;
uio.uio_procp=xfs_curproc();
ret = VOP_WRITE(ap->a_vp, &uio, 0, ap->a_cred);
kernel_upl_unmap(kernel_map, ap->a_pl);
 1283     if (ret) {
kernel_upl_abort_range(ap->a_pl, ap->a_pl_offset, ap->a_size,
UPL_ABORT_FREE_ON_EMPTY);
 1286     } else {
kernel_upl_commit_range(ap->a_pl, ap->a_pl_offset, ap->a_size,
UPL_COMMIT_CLEAR_DIRTY | UPL_COMMIT_FREE_ON_EMPTY,
UPL_GET_INTERNAL_PAGE_LIST(ap->a_pl));
 1290     }
 1292     return ret;
 1293 #else
 1294 #error pageout on non apple ?
 1295 #endif
 1296 }
 1297 #endif
 1299 #ifdef HAVE_VOP_CREATEVOBJECT
 1300 int
xfs_createvobject(struct vop_createvobject_args *ap)
 1302 /*
 1303 struct vop_createvobject_args {
 1304         struct vnode *vp;
 1305         struct ucred *cred;
 1306         struct proc *p;
 1307 };
 1308  */
 1309 {
NNPFSDEB(XDEBVNOPS, ("xfs_createvobject\n"));
 1312     return vop_stdcreatevobject (ap);
 1313 }
 1314 #endif /* HAVE_VOP_CREATEVOBJECT */
 1316 #ifdef HAVE_VOP_DESTROYVOBJECT
 1317 int
xfs_destroyvobject(struct vop_destroyvobject_args *ap)
 1319 /*
 1320 struct vop_destroyvobject_args {
 1321         struct vnode *vp;
 1322 };
 1323  */
 1324 {
NNPFSDEB(XDEBVNOPS, ("xfs_destroyvobject\n"));
 1327     return vop_stddestroyvobject (ap);
 1328 }
 1329 #endif /* HAVE_VOP_DESTROYVOBJECT */
 1331 #ifdef HAVE_VOP_GETVOBJECT
 1332 int
xfs_getvobject(struct vop_getvobject_args *ap)
 1334 /*
 1335 struct vop_getvobject_args {
 1336         struct vnode *vp;
 1337         struct vm_object **objpp;
 1338 };
 1339  */
 1340 {
NNPFSDEB(XDEBVNOPS, ("xfs_getvobject\n"));
 1343     return vop_stdgetvobject (ap);
 1344 }
 1345 #endif /* HAVE_VOP_GETVOBJECT */
 1347 #ifdef HAVE_VOP_PATHCONF
 1348 int
xfs_pathconf(struct vop_pathconf_args *ap)
 1350 /*
 1351 struct vop_pathconf_args {
 1352         struct vnodeop_desc *a_desc;
 1353         struct vnode *a_vp;
 1354         int a_name;
 1355 };
 1356 */
 1357 {
NNPFSDEB(XDEBVNOPS, ("xfs_pathconf\n"));
 1360 #ifdef HAVE_KERNEL_VOP_STDPATHCONF
 1361     return vop_stdpathconf(ap);
 1362 #else
 1363     return EOPNOTSUPP;
 1364 #endif
 1365 }
 1366 #endif
vop_t **xfs_vnodeop_p;
 1372 int
xfs_eopnotsupp (struct vop_generic_args *ap)
 1374 {
NNPFSDEB(XDEBVNOPS, ("xfs_eopnotsupp %s\n", ap->a_desc->vdesc_name));
 1376     return EOPNOTSUPP;
 1377 }
 1379 int
xfs_returnzero (struct vop_generic_args *ap)
 1381 {
NNPFSDEB(XDEBVNOPS, ("xfs_returnzero %s\n", ap->a_desc->vdesc_name));
 1383     return 0;
 1384 }
 1386 void
xfs_pushdirty(struct vnode *vp, struct ucred *cred, d_thread_t *p)
 1388 {
 1389 #if defined(__NetBSD_Version__) && __NetBSD_Version__ >= 105280000
VOP_PUTPAGES(vp, 0, 0, PGO_ALLPAGES|PGO_SYNCIO|PGO_CLEANIT);
 1391 #elif defined(__APPLE__)
ubc_pushdirty(vp);
 1393 #endif
 1394 }
 1398 static struct vnodeopv_entry_desc xfs_vnodeop_entries[] = {
 1399     {&vop_default_desc, (vop_t *) xfs_eopnotsupp},
 1400 #ifdef HAVE_VOP_LOOKUP
 1401 #ifdef HAVE_KERNEL_VFS_CACHE_LOOKUP
 1402     {&vop_lookup_desc, (vop_t *) vfs_cache_lookup },
 1403 #else
 1404     {&vop_lookup_desc, (vop_t *) xfs_lookup },
 1405 #endif
 1406 #endif
 1407 #ifdef HAVE_VOP_CACHEDLOOKUP
 1408     {&vop_cachedlookup_desc, (vop_t *) xfs_cachedlookup },
 1409 #endif
 1410 #ifdef HAVE_VOP_OPEN
 1411     {&vop_open_desc, (vop_t *) xfs_open },
 1412 #endif
 1413 #ifdef HAVE_VOP_FSYNC
 1414     {&vop_fsync_desc, (vop_t *) xfs_fsync },
 1415 #endif
 1416 #ifdef HAVE_VOP_CLOSE
 1417     {&vop_close_desc, (vop_t *) xfs_close },
 1418 #endif
 1419 #ifdef HAVE_VOP_READ
 1420     {&vop_read_desc, (vop_t *) xfs_read },
 1421 #endif
 1422 #ifdef HAVE_VOP_WRITE
 1423     {&vop_write_desc, (vop_t *) xfs_write },
 1424 #endif
 1425 #ifdef HAVE_VOP_MMAP
 1426     {&vop_mmap_desc, (vop_t *) xfs_mmap },
 1427 #endif
 1428 #ifdef HAVE_VOP_BMAP
 1429     {&vop_bmap_desc, (vop_t *) xfs_bmap },
 1430 #endif
 1431 #ifdef HAVE_VOP_IOCTL
 1432     {&vop_ioctl_desc, (vop_t *) xfs_ioctl },
 1433 #endif
 1434 #ifdef HAVE_VOP_SELECT
 1435     {&vop_select_desc, (vop_t *) xfs_select },
 1436 #endif
 1437 #ifdef HAVE_VOP_SEEK
 1438     {&vop_seek_desc, (vop_t *) xfs_seek },
 1439 #endif
 1440 #ifdef HAVE_VOP_POLL
 1441     {&vop_poll_desc, (vop_t *) xfs_poll },
 1442 #endif
 1443 #ifdef HAVE_VOP_GETATTR
 1444     {&vop_getattr_desc, (vop_t *) xfs_getattr },
 1445 #endif
 1446 #ifdef HAVE_VOP_SETATTR
 1447     {&vop_setattr_desc, (vop_t *) xfs_setattr },
 1448 #endif
 1449 #ifdef HAVE_VOP_ACCESS
 1450     {&vop_access_desc, (vop_t *) xfs_access },
 1451 #endif
 1452 #ifdef HAVE_VOP_CREATE
 1453     {&vop_create_desc, (vop_t *) xfs_create },
 1454 #endif
 1455 #ifdef HAVE_VOP_REMOVE
 1456     {&vop_remove_desc, (vop_t *) xfs_remove },
 1457 #endif
 1458 #ifdef HAVE_VOP_LINK
 1459     {&vop_link_desc, (vop_t *) xfs_link },
 1460 #endif
 1461 #ifdef HAVE_VOP_RENAME
 1462     {&vop_rename_desc, (vop_t *) xfs_rename },
 1463 #endif
 1464 #ifdef HAVE_VOP_MKDIR
 1465     {&vop_mkdir_desc, (vop_t *) xfs_mkdir },
 1466 #endif
 1467 #ifdef HAVE_VOP_RMDIR
 1468     {&vop_rmdir_desc, (vop_t *) xfs_rmdir },
 1469 #endif
 1470 #ifdef HAVE_VOP_READDIR
 1471     {&vop_readdir_desc, (vop_t *) xfs_readdir },
 1472 #endif
 1473 #ifdef HAVE_VOP_SYMLINK
 1474     {&vop_symlink_desc, (vop_t *) xfs_symlink },
 1475 #endif
 1476 #ifdef HAVE_VOP_READLINK
 1477     {&vop_readlink_desc, (vop_t *) xfs_readlink },
 1478 #endif
 1479 #ifdef HAVE_VOP_INACTIVE
 1480     {&vop_inactive_desc, (vop_t *) xfs_inactive },
 1481 #endif
 1482 #ifdef HAVE_VOP_RECLAIM
 1483     {&vop_reclaim_desc, (vop_t *) xfs_reclaim },
 1484 #endif
 1485 #ifdef HAVE_VOP_LOCK
 1486     {&vop_lock_desc, (vop_t *) xfs_lock },
 1487 #endif
 1488 #ifdef HAVE_VOP_UNLOCK
 1489     {&vop_unlock_desc, (vop_t *) xfs_unlock },
 1490 #endif
 1491 #ifdef HAVE_VOP_ISLOCKED
 1492     {&vop_islocked_desc, (vop_t *) xfs_islocked },
 1493 #endif
 1494 #ifdef HAVE_VOP_ABORTOP
 1495     {&vop_abortop_desc, (vop_t *) xfs_abortop },
 1496 #endif
 1497 #ifdef HAVE_VOP_GETPAGES
 1498     {&vop_getpages_desc, (vop_t *) xfs_getpages },
 1499 #endif
 1500 #ifdef HAVE_VOP_PUTPAGES
 1501     {&vop_putpages_desc, (vop_t *) xfs_putpages },
 1502 #endif
 1503 #ifdef HAVE_VOP_REVOKE
 1504     {&vop_revoke_desc, (vop_t *) xfs_revoke },
 1505 #endif
 1506 #ifdef HAVE_VOP_PRINT
 1507     {&vop_print_desc, (vop_t *) xfs_print}, 
 1508 #endif
 1509 #ifdef HAVE_VOP_ADVLOCK
 1510     {&vop_advlock_desc, (vop_t *) xfs_advlock },
 1511 #endif
 1512 #ifdef HAVE_VOP_PAGEIN
 1513     {&vop_pagein_desc, (vop_t *) xfs_pagein },
 1514 #endif
 1515 #ifdef HAVE_VOP_PAGEOUT
 1516     {&vop_pageout_desc, (vop_t *) xfs_pageout },
 1517 #endif
 1518 #ifdef HAVE_VOP_CREATEVOBJECT
 1519     {&vop_createvobject_desc, (vop_t *) xfs_createvobject },
 1520 #endif
 1521 #ifdef HAVE_VOP_DESTROYVOBJECT
 1522     {&vop_destroyvobject_desc, (vop_t *) xfs_destroyvobject },
 1523 #endif
 1524 #ifdef HAVE_VOP_GETVOBJECT
 1525     {&vop_getvobject_desc, (vop_t *) xfs_getvobject },
 1526 #endif
 1527 #ifdef HAVE_VOP_PATHCONF
 1528     {&vop_pathconf_desc, (vop_t *) xfs_pathconf },
 1529 #endif
 1530     {(struct vnodeop_desc *) NULL, (int (*) (void *)) NULL}
 1531 };
 1533 struct vnodeopv_desc xfs_vnodeop_opv_desc =
 1534 {&xfs_vnodeop_p, xfs_vnodeop_entries};
 1536 #ifdef VNODEOP_SET
 1537 VNODEOP_SET(xfs_vnodeop_opv_desc);
 1538 #endif