From 5d879e901264ebd49b780f409bdd8a92d716d839 Mon Sep 17 00:00:00 2001 From: thorpej Date: Wed, 13 Sep 2000 15:51:19 +0000 Subject: [PATCH] Regen for VNODE_OP_NOINLINE. --- sys/kern/vnode_if.c | 747 +++++++++++++++++++++++++++++++++++++++++++- sys/sys/vnode_if.h | 566 +++++++++++++++++++++++++++------ 2 files changed, 1215 insertions(+), 98 deletions(-) diff --git a/sys/kern/vnode_if.c b/sys/kern/vnode_if.c index e9c6f9f2ba6e..9342cfbf31f8 100644 --- a/sys/kern/vnode_if.c +++ b/sys/kern/vnode_if.c @@ -1,13 +1,13 @@ -/* $NetBSD: vnode_if.c,v 1.22 2000/05/13 23:43:06 perseant Exp $ */ +/* $NetBSD: vnode_if.c,v 1.23 2000/09/13 15:51:19 thorpej Exp $ */ /* * Warning: This file is generated automatically. * (Modifications made here may easily be lost!) * * Created from the file: - * NetBSD: vnode_if.src,v 1.23 1999/12/07 23:57:49 thorpej Exp + * NetBSD: vnode_if.src,v 1.24 2000/05/13 23:43:07 perseant Exp * by the script: - * NetBSD: vnode_if.sh,v 1.19 1999/07/07 23:32:50 wrstuden Exp + * NetBSD: vnode_if.sh,v 1.20 2000/09/13 15:50:26 thorpej Exp */ /* @@ -45,6 +45,7 @@ #include #include +#include #include struct vnodeop_desc vop_default_desc = { @@ -75,6 +76,21 @@ struct vnodeop_desc vop_lookup_desc = { VOPARG_OFFSETOF(struct vop_lookup_args, a_cnp), NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_LOOKUP(dvp, vpp, cnp) + struct vnode *dvp; + struct vnode **vpp; + struct componentname *cnp; +{ + struct vop_lookup_args a; + a.a_desc = VDESC(vop_lookup); + a.a_dvp = dvp; + a.a_vpp = vpp; + a.a_cnp = cnp; + return (VCALL(dvp, VOFFSET(vop_lookup), &a)); +} +#endif int vop_create_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_create_args,a_dvp), @@ -91,6 +107,23 @@ struct vnodeop_desc vop_create_desc = { VOPARG_OFFSETOF(struct vop_create_args, a_cnp), NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_CREATE(dvp, vpp, cnp, vap) + struct vnode *dvp; + struct vnode **vpp; + struct componentname *cnp; + struct vattr *vap; +{ + struct vop_create_args a; + a.a_desc = VDESC(vop_create); + a.a_dvp = dvp; + a.a_vpp = vpp; + a.a_cnp = cnp; + a.a_vap = vap; + return (VCALL(dvp, VOFFSET(vop_create), &a)); +} +#endif int vop_mknod_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_mknod_args,a_dvp), @@ -107,6 +140,23 @@ struct vnodeop_desc vop_mknod_desc = { VOPARG_OFFSETOF(struct vop_mknod_args, a_cnp), NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_MKNOD(dvp, vpp, cnp, vap) + struct vnode *dvp; + struct vnode **vpp; + struct componentname *cnp; + struct vattr *vap; +{ + struct vop_mknod_args a; + a.a_desc = VDESC(vop_mknod); + a.a_dvp = dvp; + a.a_vpp = vpp; + a.a_cnp = cnp; + a.a_vap = vap; + return (VCALL(dvp, VOFFSET(vop_mknod), &a)); +} +#endif int vop_open_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_open_args,a_vp), @@ -123,6 +173,23 @@ struct vnodeop_desc vop_open_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_OPEN(vp, mode, cred, p) + struct vnode *vp; + int mode; + struct ucred *cred; + struct proc *p; +{ + struct vop_open_args a; + a.a_desc = VDESC(vop_open); + a.a_vp = vp; + a.a_mode = mode; + a.a_cred = cred; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_open), &a)); +} +#endif int vop_close_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_close_args,a_vp), @@ -139,6 +206,23 @@ struct vnodeop_desc vop_close_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_CLOSE(vp, fflag, cred, p) + struct vnode *vp; + int fflag; + struct ucred *cred; + struct proc *p; +{ + struct vop_close_args a; + a.a_desc = VDESC(vop_close); + a.a_vp = vp; + a.a_fflag = fflag; + a.a_cred = cred; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_close), &a)); +} +#endif int vop_access_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_access_args,a_vp), @@ -155,6 +239,23 @@ struct vnodeop_desc vop_access_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_ACCESS(vp, mode, cred, p) + struct vnode *vp; + int mode; + struct ucred *cred; + struct proc *p; +{ + struct vop_access_args a; + a.a_desc = VDESC(vop_access); + a.a_vp = vp; + a.a_mode = mode; + a.a_cred = cred; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_access), &a)); +} +#endif int vop_getattr_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_getattr_args,a_vp), @@ -171,6 +272,23 @@ struct vnodeop_desc vop_getattr_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_GETATTR(vp, vap, cred, p) + struct vnode *vp; + struct vattr *vap; + struct ucred *cred; + struct proc *p; +{ + struct vop_getattr_args a; + a.a_desc = VDESC(vop_getattr); + a.a_vp = vp; + a.a_vap = vap; + a.a_cred = cred; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_getattr), &a)); +} +#endif int vop_setattr_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_setattr_args,a_vp), @@ -187,6 +305,23 @@ struct vnodeop_desc vop_setattr_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_SETATTR(vp, vap, cred, p) + struct vnode *vp; + struct vattr *vap; + struct ucred *cred; + struct proc *p; +{ + struct vop_setattr_args a; + a.a_desc = VDESC(vop_setattr); + a.a_vp = vp; + a.a_vap = vap; + a.a_cred = cred; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_setattr), &a)); +} +#endif int vop_read_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_read_args,a_vp), @@ -203,6 +338,23 @@ struct vnodeop_desc vop_read_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_READ(vp, uio, ioflag, cred) + struct vnode *vp; + struct uio *uio; + int ioflag; + struct ucred *cred; +{ + struct vop_read_args a; + a.a_desc = VDESC(vop_read); + a.a_vp = vp; + a.a_uio = uio; + a.a_ioflag = ioflag; + a.a_cred = cred; + return (VCALL(vp, VOFFSET(vop_read), &a)); +} +#endif int vop_write_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_write_args,a_vp), @@ -219,6 +371,23 @@ struct vnodeop_desc vop_write_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_WRITE(vp, uio, ioflag, cred) + struct vnode *vp; + struct uio *uio; + int ioflag; + struct ucred *cred; +{ + struct vop_write_args a; + a.a_desc = VDESC(vop_write); + a.a_vp = vp; + a.a_uio = uio; + a.a_ioflag = ioflag; + a.a_cred = cred; + return (VCALL(vp, VOFFSET(vop_write), &a)); +} +#endif int vop_ioctl_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_ioctl_args,a_vp), @@ -235,6 +404,27 @@ struct vnodeop_desc vop_ioctl_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_IOCTL(vp, command, data, fflag, cred, p) + struct vnode *vp; + u_long command; + caddr_t data; + int fflag; + struct ucred *cred; + struct proc *p; +{ + struct vop_ioctl_args a; + a.a_desc = VDESC(vop_ioctl); + a.a_vp = vp; + a.a_command = command; + a.a_data = data; + a.a_fflag = fflag; + a.a_cred = cred; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_ioctl), &a)); +} +#endif int vop_fcntl_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_fcntl_args,a_vp), @@ -251,6 +441,27 @@ struct vnodeop_desc vop_fcntl_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_FCNTL(vp, command, data, fflag, cred, p) + struct vnode *vp; + u_int command; + caddr_t data; + int fflag; + struct ucred *cred; + struct proc *p; +{ + struct vop_fcntl_args a; + a.a_desc = VDESC(vop_fcntl); + a.a_vp = vp; + a.a_command = command; + a.a_data = data; + a.a_fflag = fflag; + a.a_cred = cred; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_fcntl), &a)); +} +#endif int vop_poll_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_poll_args,a_vp), @@ -267,6 +478,21 @@ struct vnodeop_desc vop_poll_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_POLL(vp, events, p) + struct vnode *vp; + int events; + struct proc *p; +{ + struct vop_poll_args a; + a.a_desc = VDESC(vop_poll); + a.a_vp = vp; + a.a_events = events; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_poll), &a)); +} +#endif int vop_revoke_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_revoke_args,a_vp), @@ -283,6 +509,19 @@ struct vnodeop_desc vop_revoke_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_REVOKE(vp, flags) + struct vnode *vp; + int flags; +{ + struct vop_revoke_args a; + a.a_desc = VDESC(vop_revoke); + a.a_vp = vp; + a.a_flags = flags; + return (VCALL(vp, VOFFSET(vop_revoke), &a)); +} +#endif int vop_mmap_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_mmap_args,a_vp), @@ -299,6 +538,23 @@ struct vnodeop_desc vop_mmap_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_MMAP(vp, fflags, cred, p) + struct vnode *vp; + int fflags; + struct ucred *cred; + struct proc *p; +{ + struct vop_mmap_args a; + a.a_desc = VDESC(vop_mmap); + a.a_vp = vp; + a.a_fflags = fflags; + a.a_cred = cred; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_mmap), &a)); +} +#endif int vop_fsync_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_fsync_args,a_vp), @@ -315,6 +571,23 @@ struct vnodeop_desc vop_fsync_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_FSYNC(vp, cred, flags, p) + struct vnode *vp; + struct ucred *cred; + int flags; + struct proc *p; +{ + struct vop_fsync_args a; + a.a_desc = VDESC(vop_fsync); + a.a_vp = vp; + a.a_cred = cred; + a.a_flags = flags; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_fsync), &a)); +} +#endif int vop_seek_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_seek_args,a_vp), @@ -331,6 +604,23 @@ struct vnodeop_desc vop_seek_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_SEEK(vp, oldoff, newoff, cred) + struct vnode *vp; + off_t oldoff; + off_t newoff; + struct ucred *cred; +{ + struct vop_seek_args a; + a.a_desc = VDESC(vop_seek); + a.a_vp = vp; + a.a_oldoff = oldoff; + a.a_newoff = newoff; + a.a_cred = cred; + return (VCALL(vp, VOFFSET(vop_seek), &a)); +} +#endif int vop_remove_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_remove_args,a_dvp), @@ -348,6 +638,21 @@ struct vnodeop_desc vop_remove_desc = { VOPARG_OFFSETOF(struct vop_remove_args, a_cnp), NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_REMOVE(dvp, vp, cnp) + struct vnode *dvp; + struct vnode *vp; + struct componentname *cnp; +{ + struct vop_remove_args a; + a.a_desc = VDESC(vop_remove); + a.a_dvp = dvp; + a.a_vp = vp; + a.a_cnp = cnp; + return (VCALL(dvp, VOFFSET(vop_remove), &a)); +} +#endif int vop_link_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_link_args,a_dvp), @@ -365,6 +670,21 @@ struct vnodeop_desc vop_link_desc = { VOPARG_OFFSETOF(struct vop_link_args, a_cnp), NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_LINK(dvp, vp, cnp) + struct vnode *dvp; + struct vnode *vp; + struct componentname *cnp; +{ + struct vop_link_args a; + a.a_desc = VDESC(vop_link); + a.a_dvp = dvp; + a.a_vp = vp; + a.a_cnp = cnp; + return (VCALL(dvp, VOFFSET(vop_link), &a)); +} +#endif int vop_rename_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_rename_args,a_fdvp), @@ -384,6 +704,27 @@ struct vnodeop_desc vop_rename_desc = { VOPARG_OFFSETOF(struct vop_rename_args, a_fcnp), NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp) + struct vnode *fdvp; + struct vnode *fvp; + struct componentname *fcnp; + struct vnode *tdvp; + struct vnode *tvp; + struct componentname *tcnp; +{ + struct vop_rename_args a; + a.a_desc = VDESC(vop_rename); + a.a_fdvp = fdvp; + a.a_fvp = fvp; + a.a_fcnp = fcnp; + a.a_tdvp = tdvp; + a.a_tvp = tvp; + a.a_tcnp = tcnp; + return (VCALL(fdvp, VOFFSET(vop_rename), &a)); +} +#endif int vop_mkdir_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_mkdir_args,a_dvp), @@ -400,6 +741,23 @@ struct vnodeop_desc vop_mkdir_desc = { VOPARG_OFFSETOF(struct vop_mkdir_args, a_cnp), NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_MKDIR(dvp, vpp, cnp, vap) + struct vnode *dvp; + struct vnode **vpp; + struct componentname *cnp; + struct vattr *vap; +{ + struct vop_mkdir_args a; + a.a_desc = VDESC(vop_mkdir); + a.a_dvp = dvp; + a.a_vpp = vpp; + a.a_cnp = cnp; + a.a_vap = vap; + return (VCALL(dvp, VOFFSET(vop_mkdir), &a)); +} +#endif int vop_rmdir_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_rmdir_args,a_dvp), @@ -417,6 +775,21 @@ struct vnodeop_desc vop_rmdir_desc = { VOPARG_OFFSETOF(struct vop_rmdir_args, a_cnp), NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_RMDIR(dvp, vp, cnp) + struct vnode *dvp; + struct vnode *vp; + struct componentname *cnp; +{ + struct vop_rmdir_args a; + a.a_desc = VDESC(vop_rmdir); + a.a_dvp = dvp; + a.a_vp = vp; + a.a_cnp = cnp; + return (VCALL(dvp, VOFFSET(vop_rmdir), &a)); +} +#endif int vop_symlink_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_symlink_args,a_dvp), @@ -433,6 +806,25 @@ struct vnodeop_desc vop_symlink_desc = { VOPARG_OFFSETOF(struct vop_symlink_args, a_cnp), NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_SYMLINK(dvp, vpp, cnp, vap, target) + struct vnode *dvp; + struct vnode **vpp; + struct componentname *cnp; + struct vattr *vap; + char *target; +{ + struct vop_symlink_args a; + a.a_desc = VDESC(vop_symlink); + a.a_dvp = dvp; + a.a_vpp = vpp; + a.a_cnp = cnp; + a.a_vap = vap; + a.a_target = target; + return (VCALL(dvp, VOFFSET(vop_symlink), &a)); +} +#endif int vop_readdir_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_readdir_args,a_vp), @@ -449,6 +841,27 @@ struct vnodeop_desc vop_readdir_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_READDIR(vp, uio, cred, eofflag, cookies, ncookies) + struct vnode *vp; + struct uio *uio; + struct ucred *cred; + int *eofflag; + off_t **cookies; + int *ncookies; +{ + struct vop_readdir_args a; + a.a_desc = VDESC(vop_readdir); + a.a_vp = vp; + a.a_uio = uio; + a.a_cred = cred; + a.a_eofflag = eofflag; + a.a_cookies = cookies; + a.a_ncookies = ncookies; + return (VCALL(vp, VOFFSET(vop_readdir), &a)); +} +#endif int vop_readlink_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_readlink_args,a_vp), @@ -465,6 +878,21 @@ struct vnodeop_desc vop_readlink_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_READLINK(vp, uio, cred) + struct vnode *vp; + struct uio *uio; + struct ucred *cred; +{ + struct vop_readlink_args a; + a.a_desc = VDESC(vop_readlink); + a.a_vp = vp; + a.a_uio = uio; + a.a_cred = cred; + return (VCALL(vp, VOFFSET(vop_readlink), &a)); +} +#endif int vop_abortop_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_abortop_args,a_dvp), @@ -481,6 +909,19 @@ struct vnodeop_desc vop_abortop_desc = { VOPARG_OFFSETOF(struct vop_abortop_args, a_cnp), NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_ABORTOP(dvp, cnp) + struct vnode *dvp; + struct componentname *cnp; +{ + struct vop_abortop_args a; + a.a_desc = VDESC(vop_abortop); + a.a_dvp = dvp; + a.a_cnp = cnp; + return (VCALL(dvp, VOFFSET(vop_abortop), &a)); +} +#endif int vop_inactive_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_inactive_args,a_vp), @@ -497,6 +938,19 @@ struct vnodeop_desc vop_inactive_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_INACTIVE(vp, p) + struct vnode *vp; + struct proc *p; +{ + struct vop_inactive_args a; + a.a_desc = VDESC(vop_inactive); + a.a_vp = vp; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_inactive), &a)); +} +#endif int vop_reclaim_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_reclaim_args,a_vp), @@ -513,6 +967,19 @@ struct vnodeop_desc vop_reclaim_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_RECLAIM(vp, p) + struct vnode *vp; + struct proc *p; +{ + struct vop_reclaim_args a; + a.a_desc = VDESC(vop_reclaim); + a.a_vp = vp; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_reclaim), &a)); +} +#endif int vop_lock_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_lock_args,a_vp), @@ -529,6 +996,19 @@ struct vnodeop_desc vop_lock_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_LOCK(vp, flags) + struct vnode *vp; + int flags; +{ + struct vop_lock_args a; + a.a_desc = VDESC(vop_lock); + a.a_vp = vp; + a.a_flags = flags; + return (VCALL(vp, VOFFSET(vop_lock), &a)); +} +#endif int vop_unlock_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_unlock_args,a_vp), @@ -545,6 +1025,19 @@ struct vnodeop_desc vop_unlock_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_UNLOCK(vp, flags) + struct vnode *vp; + int flags; +{ + struct vop_unlock_args a; + a.a_desc = VDESC(vop_unlock); + a.a_vp = vp; + a.a_flags = flags; + return (VCALL(vp, VOFFSET(vop_unlock), &a)); +} +#endif int vop_bmap_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_bmap_args,a_vp), @@ -561,6 +1054,25 @@ struct vnodeop_desc vop_bmap_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_BMAP(vp, bn, vpp, bnp, runp) + struct vnode *vp; + daddr_t bn; + struct vnode **vpp; + daddr_t *bnp; + int *runp; +{ + struct vop_bmap_args a; + a.a_desc = VDESC(vop_bmap); + a.a_vp = vp; + a.a_bn = bn; + a.a_vpp = vpp; + a.a_bnp = bnp; + a.a_runp = runp; + return (VCALL(vp, VOFFSET(vop_bmap), &a)); +} +#endif int vop_print_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_print_args,a_vp), @@ -577,6 +1089,17 @@ struct vnodeop_desc vop_print_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_PRINT(vp) + struct vnode *vp; +{ + struct vop_print_args a; + a.a_desc = VDESC(vop_print); + a.a_vp = vp; + return (VCALL(vp, VOFFSET(vop_print), &a)); +} +#endif int vop_islocked_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_islocked_args,a_vp), @@ -593,6 +1116,17 @@ struct vnodeop_desc vop_islocked_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_ISLOCKED(vp) + struct vnode *vp; +{ + struct vop_islocked_args a; + a.a_desc = VDESC(vop_islocked); + a.a_vp = vp; + return (VCALL(vp, VOFFSET(vop_islocked), &a)); +} +#endif int vop_pathconf_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_pathconf_args,a_vp), @@ -609,6 +1143,21 @@ struct vnodeop_desc vop_pathconf_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_PATHCONF(vp, name, retval) + struct vnode *vp; + int name; + register_t *retval; +{ + struct vop_pathconf_args a; + a.a_desc = VDESC(vop_pathconf); + a.a_vp = vp; + a.a_name = name; + a.a_retval = retval; + return (VCALL(vp, VOFFSET(vop_pathconf), &a)); +} +#endif int vop_advlock_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_advlock_args,a_vp), @@ -625,6 +1174,25 @@ struct vnodeop_desc vop_advlock_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_ADVLOCK(vp, id, op, fl, flags) + struct vnode *vp; + caddr_t id; + int op; + struct flock *fl; + int flags; +{ + struct vop_advlock_args a; + a.a_desc = VDESC(vop_advlock); + a.a_vp = vp; + a.a_id = id; + a.a_op = op; + a.a_fl = fl; + a.a_flags = flags; + return (VCALL(vp, VOFFSET(vop_advlock), &a)); +} +#endif int vop_blkatoff_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_blkatoff_args,a_vp), @@ -641,6 +1209,23 @@ struct vnodeop_desc vop_blkatoff_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_BLKATOFF(vp, offset, res, bpp) + struct vnode *vp; + off_t offset; + char **res; + struct buf **bpp; +{ + struct vop_blkatoff_args a; + a.a_desc = VDESC(vop_blkatoff); + a.a_vp = vp; + a.a_offset = offset; + a.a_res = res; + a.a_bpp = bpp; + return (VCALL(vp, VOFFSET(vop_blkatoff), &a)); +} +#endif int vop_valloc_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_valloc_args,a_pvp), @@ -657,6 +1242,23 @@ struct vnodeop_desc vop_valloc_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_VALLOC(pvp, mode, cred, vpp) + struct vnode *pvp; + int mode; + struct ucred *cred; + struct vnode **vpp; +{ + struct vop_valloc_args a; + a.a_desc = VDESC(vop_valloc); + a.a_pvp = pvp; + a.a_mode = mode; + a.a_cred = cred; + a.a_vpp = vpp; + return (VCALL(pvp, VOFFSET(vop_valloc), &a)); +} +#endif int vop_balloc_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_balloc_args,a_vp), @@ -673,6 +1275,27 @@ struct vnodeop_desc vop_balloc_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_BALLOC(vp, startoffset, size, cred, flags, bpp) + struct vnode *vp; + off_t startoffset; + int size; + struct ucred *cred; + int flags; + struct buf **bpp; +{ + struct vop_balloc_args a; + a.a_desc = VDESC(vop_balloc); + a.a_vp = vp; + a.a_startoffset = startoffset; + a.a_size = size; + a.a_cred = cred; + a.a_flags = flags; + a.a_bpp = bpp; + return (VCALL(vp, VOFFSET(vop_balloc), &a)); +} +#endif int vop_reallocblks_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_reallocblks_args,a_vp), @@ -689,6 +1312,19 @@ struct vnodeop_desc vop_reallocblks_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_REALLOCBLKS(vp, buflist) + struct vnode *vp; + struct cluster_save *buflist; +{ + struct vop_reallocblks_args a; + a.a_desc = VDESC(vop_reallocblks); + a.a_vp = vp; + a.a_buflist = buflist; + return (VCALL(vp, VOFFSET(vop_reallocblks), &a)); +} +#endif int vop_vfree_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_vfree_args,a_pvp), @@ -705,6 +1341,21 @@ struct vnodeop_desc vop_vfree_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_VFREE(pvp, ino, mode) + struct vnode *pvp; + ino_t ino; + int mode; +{ + struct vop_vfree_args a; + a.a_desc = VDESC(vop_vfree); + a.a_pvp = pvp; + a.a_ino = ino; + a.a_mode = mode; + return (VCALL(pvp, VOFFSET(vop_vfree), &a)); +} +#endif int vop_truncate_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_truncate_args,a_vp), @@ -721,6 +1372,25 @@ struct vnodeop_desc vop_truncate_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_TRUNCATE(vp, length, flags, cred, p) + struct vnode *vp; + off_t length; + int flags; + struct ucred *cred; + struct proc *p; +{ + struct vop_truncate_args a; + a.a_desc = VDESC(vop_truncate); + a.a_vp = vp; + a.a_length = length; + a.a_flags = flags; + a.a_cred = cred; + a.a_p = p; + return (VCALL(vp, VOFFSET(vop_truncate), &a)); +} +#endif int vop_update_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_update_args,a_vp), @@ -737,6 +1407,23 @@ struct vnodeop_desc vop_update_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_UPDATE(vp, access, modify, flags) + struct vnode *vp; + struct timespec *access; + struct timespec *modify; + int flags; +{ + struct vop_update_args a; + a.a_desc = VDESC(vop_update); + a.a_vp = vp; + a.a_access = access; + a.a_modify = modify; + a.a_flags = flags; + return (VCALL(vp, VOFFSET(vop_update), &a)); +} +#endif int vop_lease_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_lease_args,a_vp), @@ -753,6 +1440,23 @@ struct vnodeop_desc vop_lease_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_LEASE(vp, p, cred, flag) + struct vnode *vp; + struct proc *p; + struct ucred *cred; + int flag; +{ + struct vop_lease_args a; + a.a_desc = VDESC(vop_lease); + a.a_vp = vp; + a.a_p = p; + a.a_cred = cred; + a.a_flag = flag; + return (VCALL(vp, VOFFSET(vop_lease), &a)); +} +#endif int vop_whiteout_vp_offsets[] = { VOPARG_OFFSETOF(struct vop_whiteout_args,a_dvp), @@ -769,6 +1473,21 @@ struct vnodeop_desc vop_whiteout_desc = { VOPARG_OFFSETOF(struct vop_whiteout_args, a_cnp), NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_WHITEOUT(dvp, cnp, flags) + struct vnode *dvp; + struct componentname *cnp; + int flags; +{ + struct vop_whiteout_args a; + a.a_desc = VDESC(vop_whiteout); + a.a_dvp = dvp; + a.a_cnp = cnp; + a.a_flags = flags; + return (VCALL(dvp, VOFFSET(vop_whiteout), &a)); +} +#endif /* Special cases: */ @@ -786,6 +1505,17 @@ struct vnodeop_desc vop_strategy_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_STRATEGY(bp) + struct buf *bp; +{ + struct vop_strategy_args a; + a.a_desc = VDESC(vop_strategy); + a.a_bp = bp; + return (VCALL(bp->b_vp, VOFFSET(vop_strategy), &a)); +} +#endif int vop_bwrite_vp_offsets[] = { VDESC_NO_OFFSET @@ -801,6 +1531,17 @@ struct vnodeop_desc vop_bwrite_desc = { VDESC_NO_OFFSET, NULL, }; +#ifdef VNODE_OP_NOINLINE +int +VOP_BWRITE(bp) + struct buf *bp; +{ + struct vop_bwrite_args a; + a.a_desc = VDESC(vop_bwrite); + a.a_bp = bp; + return (VCALL(bp->b_vp, VOFFSET(vop_bwrite), &a)); +} +#endif /* End of special cases. */ diff --git a/sys/sys/vnode_if.h b/sys/sys/vnode_if.h index b79a8f925f7f..0e03f08b49a6 100644 --- a/sys/sys/vnode_if.h +++ b/sys/sys/vnode_if.h @@ -1,13 +1,13 @@ -/* $NetBSD: vnode_if.h,v 1.22 2000/05/13 23:43:12 perseant Exp $ */ +/* $NetBSD: vnode_if.h,v 1.23 2000/09/13 15:51:20 thorpej Exp $ */ /* * Warning: This file is generated automatically. * (Modifications made here may easily be lost!) * * Created from the file: - * NetBSD: vnode_if.src,v 1.23 1999/12/07 23:57:49 thorpej Exp + * NetBSD: vnode_if.src,v 1.24 2000/05/13 23:43:07 perseant Exp * by the script: - * NetBSD: vnode_if.sh,v 1.19 1999/07/07 23:32:50 wrstuden Exp + * NetBSD: vnode_if.sh,v 1.20 2000/09/13 15:50:26 thorpej Exp */ /* @@ -56,8 +56,15 @@ struct vop_lookup_args { struct componentname *a_cnp; }; extern struct vnodeop_desc vop_lookup_desc; -static __inline int VOP_LOOKUP __P((struct vnode *, struct vnode **, - struct componentname *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_LOOKUP(struct vnode *, struct vnode **, struct componentname *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_LOOKUP(dvp, vpp, cnp) struct vnode *dvp; struct vnode **vpp; @@ -70,6 +77,7 @@ static __inline int VOP_LOOKUP(dvp, vpp, cnp) a.a_cnp = cnp; return (VCALL(dvp, VOFFSET(vop_lookup), &a)); } +#endif struct vop_create_args { struct vnodeop_desc *a_desc; @@ -79,8 +87,16 @@ struct vop_create_args { struct vattr *a_vap; }; extern struct vnodeop_desc vop_create_desc; -static __inline int VOP_CREATE __P((struct vnode *, struct vnode **, - struct componentname *, struct vattr *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_CREATE(struct vnode *, struct vnode **, struct componentname *, + struct vattr *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_CREATE(dvp, vpp, cnp, vap) struct vnode *dvp; struct vnode **vpp; @@ -95,6 +111,7 @@ static __inline int VOP_CREATE(dvp, vpp, cnp, vap) a.a_vap = vap; return (VCALL(dvp, VOFFSET(vop_create), &a)); } +#endif struct vop_mknod_args { struct vnodeop_desc *a_desc; @@ -104,8 +121,16 @@ struct vop_mknod_args { struct vattr *a_vap; }; extern struct vnodeop_desc vop_mknod_desc; -static __inline int VOP_MKNOD __P((struct vnode *, struct vnode **, - struct componentname *, struct vattr *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_MKNOD(struct vnode *, struct vnode **, struct componentname *, + struct vattr *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_MKNOD(dvp, vpp, cnp, vap) struct vnode *dvp; struct vnode **vpp; @@ -120,6 +145,7 @@ static __inline int VOP_MKNOD(dvp, vpp, cnp, vap) a.a_vap = vap; return (VCALL(dvp, VOFFSET(vop_mknod), &a)); } +#endif struct vop_open_args { struct vnodeop_desc *a_desc; @@ -129,8 +155,15 @@ struct vop_open_args { struct proc *a_p; }; extern struct vnodeop_desc vop_open_desc; -static __inline int VOP_OPEN __P((struct vnode *, int, struct ucred *, - struct proc *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_OPEN(struct vnode *, int, struct ucred *, struct proc *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_OPEN(vp, mode, cred, p) struct vnode *vp; int mode; @@ -145,6 +178,7 @@ static __inline int VOP_OPEN(vp, mode, cred, p) a.a_p = p; return (VCALL(vp, VOFFSET(vop_open), &a)); } +#endif struct vop_close_args { struct vnodeop_desc *a_desc; @@ -154,8 +188,15 @@ struct vop_close_args { struct proc *a_p; }; extern struct vnodeop_desc vop_close_desc; -static __inline int VOP_CLOSE __P((struct vnode *, int, struct ucred *, - struct proc *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_CLOSE(struct vnode *, int, struct ucred *, struct proc *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_CLOSE(vp, fflag, cred, p) struct vnode *vp; int fflag; @@ -170,6 +211,7 @@ static __inline int VOP_CLOSE(vp, fflag, cred, p) a.a_p = p; return (VCALL(vp, VOFFSET(vop_close), &a)); } +#endif struct vop_access_args { struct vnodeop_desc *a_desc; @@ -179,8 +221,15 @@ struct vop_access_args { struct proc *a_p; }; extern struct vnodeop_desc vop_access_desc; -static __inline int VOP_ACCESS __P((struct vnode *, int, struct ucred *, - struct proc *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_ACCESS(struct vnode *, int, struct ucred *, struct proc *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_ACCESS(vp, mode, cred, p) struct vnode *vp; int mode; @@ -195,6 +244,7 @@ static __inline int VOP_ACCESS(vp, mode, cred, p) a.a_p = p; return (VCALL(vp, VOFFSET(vop_access), &a)); } +#endif struct vop_getattr_args { struct vnodeop_desc *a_desc; @@ -204,8 +254,15 @@ struct vop_getattr_args { struct proc *a_p; }; extern struct vnodeop_desc vop_getattr_desc; -static __inline int VOP_GETATTR __P((struct vnode *, struct vattr *, - struct ucred *, struct proc *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_GETATTR(struct vnode *, struct vattr *, struct ucred *, struct proc *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_GETATTR(vp, vap, cred, p) struct vnode *vp; struct vattr *vap; @@ -220,6 +277,7 @@ static __inline int VOP_GETATTR(vp, vap, cred, p) a.a_p = p; return (VCALL(vp, VOFFSET(vop_getattr), &a)); } +#endif struct vop_setattr_args { struct vnodeop_desc *a_desc; @@ -229,8 +287,15 @@ struct vop_setattr_args { struct proc *a_p; }; extern struct vnodeop_desc vop_setattr_desc; -static __inline int VOP_SETATTR __P((struct vnode *, struct vattr *, - struct ucred *, struct proc *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_SETATTR(struct vnode *, struct vattr *, struct ucred *, struct proc *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_SETATTR(vp, vap, cred, p) struct vnode *vp; struct vattr *vap; @@ -245,6 +310,7 @@ static __inline int VOP_SETATTR(vp, vap, cred, p) a.a_p = p; return (VCALL(vp, VOFFSET(vop_setattr), &a)); } +#endif struct vop_read_args { struct vnodeop_desc *a_desc; @@ -254,8 +320,15 @@ struct vop_read_args { struct ucred *a_cred; }; extern struct vnodeop_desc vop_read_desc; -static __inline int VOP_READ __P((struct vnode *, struct uio *, int, - struct ucred *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_READ(struct vnode *, struct uio *, int, struct ucred *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_READ(vp, uio, ioflag, cred) struct vnode *vp; struct uio *uio; @@ -270,6 +343,7 @@ static __inline int VOP_READ(vp, uio, ioflag, cred) a.a_cred = cred; return (VCALL(vp, VOFFSET(vop_read), &a)); } +#endif struct vop_write_args { struct vnodeop_desc *a_desc; @@ -279,8 +353,15 @@ struct vop_write_args { struct ucred *a_cred; }; extern struct vnodeop_desc vop_write_desc; -static __inline int VOP_WRITE __P((struct vnode *, struct uio *, int, - struct ucred *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_WRITE(struct vnode *, struct uio *, int, struct ucred *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_WRITE(vp, uio, ioflag, cred) struct vnode *vp; struct uio *uio; @@ -295,6 +376,7 @@ static __inline int VOP_WRITE(vp, uio, ioflag, cred) a.a_cred = cred; return (VCALL(vp, VOFFSET(vop_write), &a)); } +#endif struct vop_ioctl_args { struct vnodeop_desc *a_desc; @@ -306,8 +388,16 @@ struct vop_ioctl_args { struct proc *a_p; }; extern struct vnodeop_desc vop_ioctl_desc; -static __inline int VOP_IOCTL __P((struct vnode *, u_long, caddr_t, int, - struct ucred *, struct proc *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_IOCTL(struct vnode *, u_long, caddr_t, int, struct ucred *, + struct proc *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_IOCTL(vp, command, data, fflag, cred, p) struct vnode *vp; u_long command; @@ -326,6 +416,7 @@ static __inline int VOP_IOCTL(vp, command, data, fflag, cred, p) a.a_p = p; return (VCALL(vp, VOFFSET(vop_ioctl), &a)); } +#endif struct vop_fcntl_args { struct vnodeop_desc *a_desc; @@ -337,8 +428,16 @@ struct vop_fcntl_args { struct proc *a_p; }; extern struct vnodeop_desc vop_fcntl_desc; -static __inline int VOP_FCNTL __P((struct vnode *, u_int, caddr_t, int, - struct ucred *, struct proc *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_FCNTL(struct vnode *, u_int, caddr_t, int, struct ucred *, + struct proc *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_FCNTL(vp, command, data, fflag, cred, p) struct vnode *vp; u_int command; @@ -357,6 +456,7 @@ static __inline int VOP_FCNTL(vp, command, data, fflag, cred, p) a.a_p = p; return (VCALL(vp, VOFFSET(vop_fcntl), &a)); } +#endif struct vop_poll_args { struct vnodeop_desc *a_desc; @@ -365,8 +465,15 @@ struct vop_poll_args { struct proc *a_p; }; extern struct vnodeop_desc vop_poll_desc; -static __inline int VOP_POLL __P((struct vnode *, int, - struct proc *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_POLL(struct vnode *, int, struct proc *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_POLL(vp, events, p) struct vnode *vp; int events; @@ -379,6 +486,7 @@ static __inline int VOP_POLL(vp, events, p) a.a_p = p; return (VCALL(vp, VOFFSET(vop_poll), &a)); } +#endif struct vop_revoke_args { struct vnodeop_desc *a_desc; @@ -386,8 +494,15 @@ struct vop_revoke_args { int a_flags; }; extern struct vnodeop_desc vop_revoke_desc; -static __inline int VOP_REVOKE __P((struct vnode *, - int)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_REVOKE(struct vnode *, int) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_REVOKE(vp, flags) struct vnode *vp; int flags; @@ -398,6 +513,7 @@ static __inline int VOP_REVOKE(vp, flags) a.a_flags = flags; return (VCALL(vp, VOFFSET(vop_revoke), &a)); } +#endif struct vop_mmap_args { struct vnodeop_desc *a_desc; @@ -407,8 +523,15 @@ struct vop_mmap_args { struct proc *a_p; }; extern struct vnodeop_desc vop_mmap_desc; -static __inline int VOP_MMAP __P((struct vnode *, int, struct ucred *, - struct proc *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_MMAP(struct vnode *, int, struct ucred *, struct proc *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_MMAP(vp, fflags, cred, p) struct vnode *vp; int fflags; @@ -423,6 +546,7 @@ static __inline int VOP_MMAP(vp, fflags, cred, p) a.a_p = p; return (VCALL(vp, VOFFSET(vop_mmap), &a)); } +#endif struct vop_fsync_args { struct vnodeop_desc *a_desc; @@ -432,8 +556,15 @@ struct vop_fsync_args { struct proc *a_p; }; extern struct vnodeop_desc vop_fsync_desc; -static __inline int VOP_FSYNC __P((struct vnode *, struct ucred *, int, - struct proc *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_FSYNC(struct vnode *, struct ucred *, int, struct proc *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_FSYNC(vp, cred, flags, p) struct vnode *vp; struct ucred *cred; @@ -448,6 +579,7 @@ static __inline int VOP_FSYNC(vp, cred, flags, p) a.a_p = p; return (VCALL(vp, VOFFSET(vop_fsync), &a)); } +#endif struct vop_seek_args { struct vnodeop_desc *a_desc; @@ -457,8 +589,15 @@ struct vop_seek_args { struct ucred *a_cred; }; extern struct vnodeop_desc vop_seek_desc; -static __inline int VOP_SEEK __P((struct vnode *, off_t, off_t, - struct ucred *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_SEEK(struct vnode *, off_t, off_t, struct ucred *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_SEEK(vp, oldoff, newoff, cred) struct vnode *vp; off_t oldoff; @@ -473,6 +612,7 @@ static __inline int VOP_SEEK(vp, oldoff, newoff, cred) a.a_cred = cred; return (VCALL(vp, VOFFSET(vop_seek), &a)); } +#endif struct vop_remove_args { struct vnodeop_desc *a_desc; @@ -481,8 +621,15 @@ struct vop_remove_args { struct componentname *a_cnp; }; extern struct vnodeop_desc vop_remove_desc; -static __inline int VOP_REMOVE __P((struct vnode *, struct vnode *, - struct componentname *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_REMOVE(struct vnode *, struct vnode *, struct componentname *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_REMOVE(dvp, vp, cnp) struct vnode *dvp; struct vnode *vp; @@ -495,6 +642,7 @@ static __inline int VOP_REMOVE(dvp, vp, cnp) a.a_cnp = cnp; return (VCALL(dvp, VOFFSET(vop_remove), &a)); } +#endif struct vop_link_args { struct vnodeop_desc *a_desc; @@ -503,8 +651,15 @@ struct vop_link_args { struct componentname *a_cnp; }; extern struct vnodeop_desc vop_link_desc; -static __inline int VOP_LINK __P((struct vnode *, struct vnode *, - struct componentname *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_LINK(struct vnode *, struct vnode *, struct componentname *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_LINK(dvp, vp, cnp) struct vnode *dvp; struct vnode *vp; @@ -517,6 +672,7 @@ static __inline int VOP_LINK(dvp, vp, cnp) a.a_cnp = cnp; return (VCALL(dvp, VOFFSET(vop_link), &a)); } +#endif struct vop_rename_args { struct vnodeop_desc *a_desc; @@ -528,9 +684,16 @@ struct vop_rename_args { struct componentname *a_tcnp; }; extern struct vnodeop_desc vop_rename_desc; -static __inline int VOP_RENAME __P((struct vnode *, struct vnode *, - struct componentname *, struct vnode *, struct vnode *, - struct componentname *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_RENAME(struct vnode *, struct vnode *, struct componentname *, + struct vnode *, struct vnode *, struct componentname *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp) struct vnode *fdvp; struct vnode *fvp; @@ -549,6 +712,7 @@ static __inline int VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp) a.a_tcnp = tcnp; return (VCALL(fdvp, VOFFSET(vop_rename), &a)); } +#endif struct vop_mkdir_args { struct vnodeop_desc *a_desc; @@ -558,8 +722,16 @@ struct vop_mkdir_args { struct vattr *a_vap; }; extern struct vnodeop_desc vop_mkdir_desc; -static __inline int VOP_MKDIR __P((struct vnode *, struct vnode **, - struct componentname *, struct vattr *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_MKDIR(struct vnode *, struct vnode **, struct componentname *, + struct vattr *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_MKDIR(dvp, vpp, cnp, vap) struct vnode *dvp; struct vnode **vpp; @@ -574,6 +746,7 @@ static __inline int VOP_MKDIR(dvp, vpp, cnp, vap) a.a_vap = vap; return (VCALL(dvp, VOFFSET(vop_mkdir), &a)); } +#endif struct vop_rmdir_args { struct vnodeop_desc *a_desc; @@ -582,8 +755,15 @@ struct vop_rmdir_args { struct componentname *a_cnp; }; extern struct vnodeop_desc vop_rmdir_desc; -static __inline int VOP_RMDIR __P((struct vnode *, struct vnode *, - struct componentname *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_RMDIR(struct vnode *, struct vnode *, struct componentname *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_RMDIR(dvp, vp, cnp) struct vnode *dvp; struct vnode *vp; @@ -596,6 +776,7 @@ static __inline int VOP_RMDIR(dvp, vp, cnp) a.a_cnp = cnp; return (VCALL(dvp, VOFFSET(vop_rmdir), &a)); } +#endif struct vop_symlink_args { struct vnodeop_desc *a_desc; @@ -606,9 +787,16 @@ struct vop_symlink_args { char *a_target; }; extern struct vnodeop_desc vop_symlink_desc; -static __inline int VOP_SYMLINK __P((struct vnode *, struct vnode **, - struct componentname *, struct vattr *, - char *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_SYMLINK(struct vnode *, struct vnode **, struct componentname *, + struct vattr *, char *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_SYMLINK(dvp, vpp, cnp, vap, target) struct vnode *dvp; struct vnode **vpp; @@ -625,6 +813,7 @@ static __inline int VOP_SYMLINK(dvp, vpp, cnp, vap, target) a.a_target = target; return (VCALL(dvp, VOFFSET(vop_symlink), &a)); } +#endif struct vop_readdir_args { struct vnodeop_desc *a_desc; @@ -636,8 +825,16 @@ struct vop_readdir_args { int *a_ncookies; }; extern struct vnodeop_desc vop_readdir_desc; -static __inline int VOP_READDIR __P((struct vnode *, struct uio *, - struct ucred *, int *, off_t **, int *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_READDIR(struct vnode *, struct uio *, struct ucred *, int *, + off_t **, int *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_READDIR(vp, uio, cred, eofflag, cookies, ncookies) struct vnode *vp; struct uio *uio; @@ -656,6 +853,7 @@ static __inline int VOP_READDIR(vp, uio, cred, eofflag, cookies, ncookies) a.a_ncookies = ncookies; return (VCALL(vp, VOFFSET(vop_readdir), &a)); } +#endif struct vop_readlink_args { struct vnodeop_desc *a_desc; @@ -664,8 +862,15 @@ struct vop_readlink_args { struct ucred *a_cred; }; extern struct vnodeop_desc vop_readlink_desc; -static __inline int VOP_READLINK __P((struct vnode *, struct uio *, - struct ucred *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_READLINK(struct vnode *, struct uio *, struct ucred *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_READLINK(vp, uio, cred) struct vnode *vp; struct uio *uio; @@ -678,6 +883,7 @@ static __inline int VOP_READLINK(vp, uio, cred) a.a_cred = cred; return (VCALL(vp, VOFFSET(vop_readlink), &a)); } +#endif struct vop_abortop_args { struct vnodeop_desc *a_desc; @@ -685,8 +891,15 @@ struct vop_abortop_args { struct componentname *a_cnp; }; extern struct vnodeop_desc vop_abortop_desc; -static __inline int VOP_ABORTOP __P((struct vnode *, - struct componentname *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_ABORTOP(struct vnode *, struct componentname *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_ABORTOP(dvp, cnp) struct vnode *dvp; struct componentname *cnp; @@ -697,6 +910,7 @@ static __inline int VOP_ABORTOP(dvp, cnp) a.a_cnp = cnp; return (VCALL(dvp, VOFFSET(vop_abortop), &a)); } +#endif struct vop_inactive_args { struct vnodeop_desc *a_desc; @@ -704,8 +918,15 @@ struct vop_inactive_args { struct proc *a_p; }; extern struct vnodeop_desc vop_inactive_desc; -static __inline int VOP_INACTIVE __P((struct vnode *, - struct proc *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_INACTIVE(struct vnode *, struct proc *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_INACTIVE(vp, p) struct vnode *vp; struct proc *p; @@ -716,6 +937,7 @@ static __inline int VOP_INACTIVE(vp, p) a.a_p = p; return (VCALL(vp, VOFFSET(vop_inactive), &a)); } +#endif struct vop_reclaim_args { struct vnodeop_desc *a_desc; @@ -723,8 +945,15 @@ struct vop_reclaim_args { struct proc *a_p; }; extern struct vnodeop_desc vop_reclaim_desc; -static __inline int VOP_RECLAIM __P((struct vnode *, - struct proc *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_RECLAIM(struct vnode *, struct proc *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_RECLAIM(vp, p) struct vnode *vp; struct proc *p; @@ -735,6 +964,7 @@ static __inline int VOP_RECLAIM(vp, p) a.a_p = p; return (VCALL(vp, VOFFSET(vop_reclaim), &a)); } +#endif struct vop_lock_args { struct vnodeop_desc *a_desc; @@ -742,8 +972,15 @@ struct vop_lock_args { int a_flags; }; extern struct vnodeop_desc vop_lock_desc; -static __inline int VOP_LOCK __P((struct vnode *, - int)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_LOCK(struct vnode *, int) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_LOCK(vp, flags) struct vnode *vp; int flags; @@ -754,6 +991,7 @@ static __inline int VOP_LOCK(vp, flags) a.a_flags = flags; return (VCALL(vp, VOFFSET(vop_lock), &a)); } +#endif struct vop_unlock_args { struct vnodeop_desc *a_desc; @@ -761,8 +999,15 @@ struct vop_unlock_args { int a_flags; }; extern struct vnodeop_desc vop_unlock_desc; -static __inline int VOP_UNLOCK __P((struct vnode *, - int)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_UNLOCK(struct vnode *, int) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_UNLOCK(vp, flags) struct vnode *vp; int flags; @@ -773,6 +1018,7 @@ static __inline int VOP_UNLOCK(vp, flags) a.a_flags = flags; return (VCALL(vp, VOFFSET(vop_unlock), &a)); } +#endif struct vop_bmap_args { struct vnodeop_desc *a_desc; @@ -783,8 +1029,15 @@ struct vop_bmap_args { int *a_runp; }; extern struct vnodeop_desc vop_bmap_desc; -static __inline int VOP_BMAP __P((struct vnode *, daddr_t, struct vnode **, - daddr_t *, int *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_BMAP(struct vnode *, daddr_t, struct vnode **, daddr_t *, int *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_BMAP(vp, bn, vpp, bnp, runp) struct vnode *vp; daddr_t bn; @@ -801,13 +1054,22 @@ static __inline int VOP_BMAP(vp, bn, vpp, bnp, runp) a.a_runp = runp; return (VCALL(vp, VOFFSET(vop_bmap), &a)); } +#endif struct vop_print_args { struct vnodeop_desc *a_desc; struct vnode *a_vp; }; extern struct vnodeop_desc vop_print_desc; -static __inline int VOP_PRINT __P((struct vnode *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_PRINT(struct vnode *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_PRINT(vp) struct vnode *vp; { @@ -816,14 +1078,22 @@ static __inline int VOP_PRINT(vp) a.a_vp = vp; return (VCALL(vp, VOFFSET(vop_print), &a)); } +#endif struct vop_islocked_args { struct vnodeop_desc *a_desc; struct vnode *a_vp; }; extern struct vnodeop_desc vop_islocked_desc; -static __inline int VOP_ISLOCKED __P(( - struct vnode *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_ISLOCKED(struct vnode *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_ISLOCKED(vp) struct vnode *vp; { @@ -832,6 +1102,7 @@ static __inline int VOP_ISLOCKED(vp) a.a_vp = vp; return (VCALL(vp, VOFFSET(vop_islocked), &a)); } +#endif struct vop_pathconf_args { struct vnodeop_desc *a_desc; @@ -840,8 +1111,15 @@ struct vop_pathconf_args { register_t *a_retval; }; extern struct vnodeop_desc vop_pathconf_desc; -static __inline int VOP_PATHCONF __P((struct vnode *, int, - register_t *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_PATHCONF(struct vnode *, int, register_t *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_PATHCONF(vp, name, retval) struct vnode *vp; int name; @@ -854,6 +1132,7 @@ static __inline int VOP_PATHCONF(vp, name, retval) a.a_retval = retval; return (VCALL(vp, VOFFSET(vop_pathconf), &a)); } +#endif struct vop_advlock_args { struct vnodeop_desc *a_desc; @@ -864,8 +1143,15 @@ struct vop_advlock_args { int a_flags; }; extern struct vnodeop_desc vop_advlock_desc; -static __inline int VOP_ADVLOCK __P((struct vnode *, caddr_t, int, - struct flock *, int)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_ADVLOCK(struct vnode *, caddr_t, int, struct flock *, int) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_ADVLOCK(vp, id, op, fl, flags) struct vnode *vp; caddr_t id; @@ -882,6 +1168,7 @@ static __inline int VOP_ADVLOCK(vp, id, op, fl, flags) a.a_flags = flags; return (VCALL(vp, VOFFSET(vop_advlock), &a)); } +#endif struct vop_blkatoff_args { struct vnodeop_desc *a_desc; @@ -891,8 +1178,15 @@ struct vop_blkatoff_args { struct buf **a_bpp; }; extern struct vnodeop_desc vop_blkatoff_desc; -static __inline int VOP_BLKATOFF __P((struct vnode *, off_t, char **, - struct buf **)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_BLKATOFF(struct vnode *, off_t, char **, struct buf **) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_BLKATOFF(vp, offset, res, bpp) struct vnode *vp; off_t offset; @@ -907,6 +1201,7 @@ static __inline int VOP_BLKATOFF(vp, offset, res, bpp) a.a_bpp = bpp; return (VCALL(vp, VOFFSET(vop_blkatoff), &a)); } +#endif struct vop_valloc_args { struct vnodeop_desc *a_desc; @@ -916,8 +1211,15 @@ struct vop_valloc_args { struct vnode **a_vpp; }; extern struct vnodeop_desc vop_valloc_desc; -static __inline int VOP_VALLOC __P((struct vnode *, int, struct ucred *, - struct vnode **)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_VALLOC(struct vnode *, int, struct ucred *, struct vnode **) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_VALLOC(pvp, mode, cred, vpp) struct vnode *pvp; int mode; @@ -932,6 +1234,7 @@ static __inline int VOP_VALLOC(pvp, mode, cred, vpp) a.a_vpp = vpp; return (VCALL(pvp, VOFFSET(vop_valloc), &a)); } +#endif struct vop_balloc_args { struct vnodeop_desc *a_desc; @@ -943,8 +1246,15 @@ struct vop_balloc_args { struct buf **a_bpp; }; extern struct vnodeop_desc vop_balloc_desc; -static __inline int VOP_BALLOC __P((struct vnode *, off_t, int, - struct ucred *, int, struct buf **)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_BALLOC(struct vnode *, off_t, int, struct ucred *, int, struct buf **) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_BALLOC(vp, startoffset, size, cred, flags, bpp) struct vnode *vp; off_t startoffset; @@ -963,6 +1273,7 @@ static __inline int VOP_BALLOC(vp, startoffset, size, cred, flags, bpp) a.a_bpp = bpp; return (VCALL(vp, VOFFSET(vop_balloc), &a)); } +#endif struct vop_reallocblks_args { struct vnodeop_desc *a_desc; @@ -970,8 +1281,15 @@ struct vop_reallocblks_args { struct cluster_save *a_buflist; }; extern struct vnodeop_desc vop_reallocblks_desc; -static __inline int VOP_REALLOCBLKS __P((struct vnode *, - struct cluster_save *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_REALLOCBLKS(struct vnode *, struct cluster_save *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_REALLOCBLKS(vp, buflist) struct vnode *vp; struct cluster_save *buflist; @@ -982,6 +1300,7 @@ static __inline int VOP_REALLOCBLKS(vp, buflist) a.a_buflist = buflist; return (VCALL(vp, VOFFSET(vop_reallocblks), &a)); } +#endif struct vop_vfree_args { struct vnodeop_desc *a_desc; @@ -990,8 +1309,15 @@ struct vop_vfree_args { int a_mode; }; extern struct vnodeop_desc vop_vfree_desc; -static __inline int VOP_VFREE __P((struct vnode *, ino_t, - int)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_VFREE(struct vnode *, ino_t, int) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_VFREE(pvp, ino, mode) struct vnode *pvp; ino_t ino; @@ -1004,6 +1330,7 @@ static __inline int VOP_VFREE(pvp, ino, mode) a.a_mode = mode; return (VCALL(pvp, VOFFSET(vop_vfree), &a)); } +#endif struct vop_truncate_args { struct vnodeop_desc *a_desc; @@ -1014,8 +1341,15 @@ struct vop_truncate_args { struct proc *a_p; }; extern struct vnodeop_desc vop_truncate_desc; -static __inline int VOP_TRUNCATE __P((struct vnode *, off_t, int, - struct ucred *, struct proc *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_TRUNCATE(struct vnode *, off_t, int, struct ucred *, struct proc *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_TRUNCATE(vp, length, flags, cred, p) struct vnode *vp; off_t length; @@ -1032,6 +1366,7 @@ static __inline int VOP_TRUNCATE(vp, length, flags, cred, p) a.a_p = p; return (VCALL(vp, VOFFSET(vop_truncate), &a)); } +#endif struct vop_update_args { struct vnodeop_desc *a_desc; @@ -1041,8 +1376,15 @@ struct vop_update_args { int a_flags; }; extern struct vnodeop_desc vop_update_desc; -static __inline int VOP_UPDATE __P((struct vnode *, struct timespec *, - struct timespec *, int)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_UPDATE(struct vnode *, struct timespec *, struct timespec *, int) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_UPDATE(vp, access, modify, flags) struct vnode *vp; struct timespec *access; @@ -1057,6 +1399,7 @@ static __inline int VOP_UPDATE(vp, access, modify, flags) a.a_flags = flags; return (VCALL(vp, VOFFSET(vop_update), &a)); } +#endif struct vop_lease_args { struct vnodeop_desc *a_desc; @@ -1066,8 +1409,15 @@ struct vop_lease_args { int a_flag; }; extern struct vnodeop_desc vop_lease_desc; -static __inline int VOP_LEASE __P((struct vnode *, struct proc *, - struct ucred *, int)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_LEASE(struct vnode *, struct proc *, struct ucred *, int) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_LEASE(vp, p, cred, flag) struct vnode *vp; struct proc *p; @@ -1082,6 +1432,7 @@ static __inline int VOP_LEASE(vp, p, cred, flag) a.a_flag = flag; return (VCALL(vp, VOFFSET(vop_lease), &a)); } +#endif struct vop_whiteout_args { struct vnodeop_desc *a_desc; @@ -1090,8 +1441,15 @@ struct vop_whiteout_args { int a_flags; }; extern struct vnodeop_desc vop_whiteout_desc; -static __inline int VOP_WHITEOUT __P((struct vnode *, - struct componentname *, int)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_WHITEOUT(struct vnode *, struct componentname *, int) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_WHITEOUT(dvp, cnp, flags) struct vnode *dvp; struct componentname *cnp; @@ -1104,6 +1462,7 @@ static __inline int VOP_WHITEOUT(dvp, cnp, flags) a.a_flags = flags; return (VCALL(dvp, VOFFSET(vop_whiteout), &a)); } +#endif /* Special cases: */ #include @@ -1113,8 +1472,15 @@ struct vop_strategy_args { struct buf *a_bp; }; extern struct vnodeop_desc vop_strategy_desc; -static __inline int VOP_STRATEGY __P(( - struct buf *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_STRATEGY(struct buf *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_STRATEGY(bp) struct buf *bp; { @@ -1123,13 +1489,22 @@ static __inline int VOP_STRATEGY(bp) a.a_bp = bp; return (VCALL(bp->b_vp, VOFFSET(vop_strategy), &a)); } +#endif struct vop_bwrite_args { struct vnodeop_desc *a_desc; struct buf *a_bp; }; extern struct vnodeop_desc vop_bwrite_desc; -static __inline int VOP_BWRITE __P((struct buf *)) __attribute__((__unused__)); +#ifndef VNODE_OP_NOINLINE +static __inline +#endif +int VOP_BWRITE(struct buf *) +#ifndef VNODE_OP_NOINLINE +__attribute__((__unused__)) +#endif +; +#ifndef VNODE_OP_NOINLINE static __inline int VOP_BWRITE(bp) struct buf *bp; { @@ -1138,6 +1513,7 @@ static __inline int VOP_BWRITE(bp) a.a_bp = bp; return (VCALL(bp->b_vp, VOFFSET(vop_bwrite), &a)); } +#endif /* End of special cases. */