From 74c2c83f3f1758d37939238fd0c69d56df92b2c7 Mon Sep 17 00:00:00 2001 From: tol Date: Tue, 26 Feb 2008 21:59:19 +0000 Subject: [PATCH] compile on modern FreeBSD. After Robert Watson and Alec Kloss --- nnpfs/bsd/bin/mntopts.h | 3 ++- nnpfs/bsd/bin/mount_nnpfs.c | 3 +++ nnpfs/bsd/nnpfs/nnpfs_common.h | 2 +- nnpfs/bsd/nnpfs/nnpfs_locl.h | 5 +++- nnpfs/bsd/nnpfs/nnpfs_vfsops-bsd.h | 6 +++++ nnpfs/bsd/nnpfs_blocks.c | 6 ++++- nnpfs/bsd/nnpfs_common-bsd.c | 22 ++++++++++++----- nnpfs/bsd/nnpfs_message.c | 2 +- nnpfs/bsd/nnpfs_node-bsd.c | 15 +++++++++--- nnpfs/bsd/nnpfs_syscalls-common.c | 2 +- nnpfs/bsd/nnpfs_vfsops-bsd.c | 6 +++++ nnpfs/bsd/nnpfs_vfsops-freebsd.c | 16 +++++++++++++ nnpfs/bsd/nnpfs_vnodeops-bsd.c | 48 ++++++++++++++++++++++++++++++++++++++ nnpfs/bsd/nnpfs_vnodeops-common.c | 4 +++- nnpfs/freebsd/FreeBSD-Makefile | 2 +- 15 files changed, 125 insertions(+), 17 deletions(-) diff --git a/nnpfs/bsd/bin/mntopts.h b/nnpfs/bsd/bin/mntopts.h index cf7e93cf4..628e3770e 100644 --- a/nnpfs/bsd/bin/mntopts.h +++ b/nnpfs/bsd/bin/mntopts.h @@ -48,7 +48,9 @@ struct mntopt { #define MOPT_NOACCESSTIME { "accesstime", 1, MNT_NOATIME } #define MOPT_NOATIME { "atime", 1, MNT_NOATIME } #endif +#ifdef MNT_NODEV #define MOPT_NODEV { "dev", 1, MNT_NODEV } +#endif #define MOPT_NOEXEC { "exec", 1, MNT_NOEXEC } #define MOPT_NOSUID { "suid", 1, MNT_NOSUID } #define MOPT_RDONLY { "rdonly", 0, MNT_RDONLY } @@ -82,7 +84,6 @@ struct mntopt { MOPT_USERQUOTA, \ MOPT_GROUPQUOTA, \ MOPT_FSTAB_COMPAT, \ - MOPT_NODEV, \ MOPT_NOEXEC, \ MOPT_NOSUID, \ MOPT_RDONLY diff --git a/nnpfs/bsd/bin/mount_nnpfs.c b/nnpfs/bsd/bin/mount_nnpfs.c index b90ac02a5..c4dc4c4aa 100644 --- a/nnpfs/bsd/bin/mount_nnpfs.c +++ b/nnpfs/bsd/bin/mount_nnpfs.c @@ -47,6 +47,9 @@ static const struct mntopt mopts[] = { #ifdef MNT_UNION MOPT_UNION, #endif +#ifdef MNT_NODEV + MOPT_NODEV, +#endif MOPT_ASYNC, MOPT_SYNC, MOPT_UPDATE, diff --git a/nnpfs/bsd/nnpfs/nnpfs_common.h b/nnpfs/bsd/nnpfs/nnpfs_common.h index 164a2064e..8412d0503 100644 --- a/nnpfs/bsd/nnpfs/nnpfs_common.h +++ b/nnpfs/bsd/nnpfs/nnpfs_common.h @@ -59,7 +59,7 @@ void nnpfs_free(void *, u_int size, nnpfs_malloc_type type); #define nnpfs_free(a, size,t) free(a, t) #endif /* NNPFS_DEBUG */ -int nnpfs_suser(d_thread_t *p); +int nnpfs_priv_check_debug(d_thread_t *p); #ifndef HAVE_KERNEL_MEMCPY void * diff --git a/nnpfs/bsd/nnpfs/nnpfs_locl.h b/nnpfs/bsd/nnpfs/nnpfs_locl.h index fde5f83ab..b14c0f09e 100644 --- a/nnpfs/bsd/nnpfs/nnpfs_locl.h +++ b/nnpfs/bsd/nnpfs/nnpfs_locl.h @@ -125,6 +125,9 @@ typedef struct componentname nnpfs_componentname; #ifdef HAVE_SYS_KAUTH_H #include #endif +#ifdef HAVE_SYS_PRIV_H +#include +#endif #ifdef HAVE_MISCFS_GENFS_GENFS_H #include @@ -300,7 +303,7 @@ typedef struct proc d_thread_t; struct genfs_ops nnpfs_genfsops; #endif -#if __NetBSD_Version__ >= 399001900 /* NetBSD 3.99.19 */ +#if defined(__NetBSD__) && __NetBSD_Version__ >= 399001900 /* NetBSD 3.99.19 */ typedef struct kauth_cred *nnpfs_kernel_cred; #define nnpfs_cred_get_uid(cred) kauth_cred_getuid(cred) #else diff --git a/nnpfs/bsd/nnpfs/nnpfs_vfsops-bsd.h b/nnpfs/bsd/nnpfs/nnpfs_vfsops-bsd.h index 0b6f01e64..1ed40e721 100644 --- a/nnpfs/bsd/nnpfs/nnpfs_vfsops-bsd.h +++ b/nnpfs/bsd/nnpfs/nnpfs_vfsops-bsd.h @@ -79,7 +79,11 @@ int nnpfs_root(struct mount *mp, struct vnode **vpp); int +#ifdef HAVE_VFS_QUOTACTL_CADDR nnpfs_quotactl(struct mount *mp, int cmd, uid_t uid, caddr_t arg, d_thread_t *p); +#else +nnpfs_quotactl(struct mount *mp, int cmd, uid_t uid, void *arg, d_thread_t *p); +#endif int nnpfs_statfs(struct mount *mp, nnpfs_statvfs *sbp, d_thread_t *p); @@ -114,6 +118,7 @@ nnpfs_fhtovp(struct mount * mp, struct ucred ** credanonp); #endif +#ifndef HAVE_VOP_VPTOFH int nnpfs_vptofh(struct vnode * vp, struct fid * fhp @@ -121,6 +126,7 @@ nnpfs_vptofh(struct vnode * vp, ,size_t * fidsz #endif ); +#endif int nnpfs_dead_lookup(struct vop_lookup_args *ap); diff --git a/nnpfs/bsd/nnpfs_blocks.c b/nnpfs/bsd/nnpfs_blocks.c index 894c0a289..2153f5732 100644 --- a/nnpfs/bsd/nnpfs_blocks.c +++ b/nnpfs/bsd/nnpfs_blocks.c @@ -307,7 +307,7 @@ nnpfs_block_extend(struct nnpfs_node *node, uint64_t offset) ret = nnpfs_block_extend_int(node, vp, p); - VOP_UNLOCK(vp, 0, p); + nnpfs_vfs_unlock(vp, p) vn_finished_write(mp); } #else @@ -501,7 +501,11 @@ open_file(struct vnode *cachedir, char *name, int fmode, #endif #ifdef __FreeBSD__ +#ifdef HAVE_FINAL_ARG_FILE_VOP_OPEN + error = VOP_OPEN(*vpp, fmode, cred, p, NULL); +#else error = VOP_OPEN(*vpp, fmode, cred, p, -1); +#endif #else error = VOP_OPEN(*vpp, fmode, cred, p); #endif diff --git a/nnpfs/bsd/nnpfs_common-bsd.c b/nnpfs/bsd/nnpfs_common-bsd.c index 8cdb716c7..899235577 100644 --- a/nnpfs/bsd/nnpfs_common-bsd.c +++ b/nnpfs/bsd/nnpfs_common-bsd.c @@ -71,21 +71,31 @@ nnpfs_free(void *ptr, u_int size, nnpfs_malloc_type type) #endif /* NNPFS_DEBUG */ +/* + * Return zero if privileged enough to set nnpfs debug flags. + */ int -nnpfs_suser(d_thread_t *p) +nnpfs_priv_check_debug(d_thread_t *p) { -#if defined(__APPLE__) +#ifdef HAVE_KERNEL_PRIV_CHECK +#ifdef PRIV_NNPFS_DEBUG + return priv_check(p, PRIV_NNPFS_DEBUG); +#else + return priv_check(p, PRIV_ROOT); +#endif +#elif defined(__APPLE__) return proc_suser(p); #elif defined(HAVE_KERNEL_KAUTH_CRED_GETUID) - if (kauth_cred_getuid(nnpfs_proc_to_cred(p)) == 0) + uid_t uid = kauth_cred_getuid(p->l_proc->p_cred); + if (uid == 0) return 0; return EPERM; #elif defined(HAVE_KERNEL_SUSER_UCRED) - return suser_ucred (nnpfs_proc_to_cred(p)); + return suser_ucred(nnpfs_proc_to_cred(p)); #elif defined(HAVE_TWO_ARGUMENT_SUSER) - return suser (nnpfs_proc_to_cred(p), NULL); + return suser(nnpfs_proc_to_cred(p), NULL); #else - return suser (p); + return suser(p); #endif } diff --git a/nnpfs/bsd/nnpfs_message.c b/nnpfs/bsd/nnpfs_message.c index 5a87e9c19..074377c05 100644 --- a/nnpfs/bsd/nnpfs_message.c +++ b/nnpfs/bsd/nnpfs_message.c @@ -483,7 +483,7 @@ gc_vnode(struct vnode *vp, d_thread_t *p) nnpfs_block_free_all(VNODE_TO_XNODE(vp)); -#if HAVE_KERNEL_VGONEL +#ifdef HAVE_KERNEL_VGONEL vgonel (vp, p); #else /* !have vgonel */ nnpfs_interlock_unlock(&vp->v_interlock); diff --git a/nnpfs/bsd/nnpfs_node-bsd.c b/nnpfs/bsd/nnpfs_node-bsd.c index 47e6418cd..b8ff31143 100644 --- a/nnpfs/bsd/nnpfs_node-bsd.c +++ b/nnpfs/bsd/nnpfs_node-bsd.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 1995 - 2007 Kungliga Tekniska Högskolan + * Copyright (c) 1995 - 2008 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * @@ -169,6 +169,15 @@ nnpfs_getnewvnode(struct nnpfs *nnpfsp, genfs_node_init(*vpp, &nnpfs_genfsops); #endif +#ifdef HAVE_KERNEL_INSMNTQUE + error = insmntque(*vpp, NNPFS_TO_VFS(nnpfsp)); + if (error) { + nnpfs_free(result, sizeof(*result), M_NNPFS_NODE); + *vpp = NULL; + return error; + } +#endif + retry: error = nnpfs_node_find(nnpfsp, handle, &check); if (error == ENOENT) { @@ -757,7 +766,7 @@ nnpfs_dnlc_enter(struct vnode *dvp, * The real change is sys/kern/vfs_cache:1.20 */ -#if __NetBSD_Version__ >= 104120000 || OpenBSD > 200211 +#if (defined(__NetBSD_Version__) && __NetBSD_Version__ >= 104120000) || (defined(OpenBSD) && OpenBSD > 200211) if (cache_lookup(dvp, &dummy, cnp) != -1) { nnpfs_vfs_unlock(dummy, nnpfs_cnp_to_proc(cnp)); printf ("NNPFS PANIC WARNING! nnpfs_dnlc_enter: %s already in cache\n", @@ -802,7 +811,7 @@ nnpfs_cnp_init (struct componentname *cn, cn->cn_nameptr = (char *)name; cn->cn_namelen = strlen(name); cn->cn_flags = 0; -#if __APPLE__ +#ifdef __APPLE__ cn->cn_hash = 0; /* Let the vfs compute the hash */ #elif defined(HAVE_KERNEL_NAMEI_HASH) { diff --git a/nnpfs/bsd/nnpfs_syscalls-common.c b/nnpfs/bsd/nnpfs_syscalls-common.c index 6f374092f..42cf77715 100644 --- a/nnpfs/bsd/nnpfs_syscalls-common.c +++ b/nnpfs/bsd/nnpfs_syscalls-common.c @@ -569,7 +569,7 @@ nnpfs_debug (d_thread_t *p, struct arlaViceIoctl *vice_ioctl) if (vice_ioctl->in_size < sizeof(int32_t)) return EINVAL; - error = nnpfs_suser(p); + error = nnpfs_priv_check_debug(p); if (error) return error; diff --git a/nnpfs/bsd/nnpfs_vfsops-bsd.c b/nnpfs/bsd/nnpfs_vfsops-bsd.c index 6010db9b6..bc1f61750 100644 --- a/nnpfs/bsd/nnpfs_vfsops-bsd.c +++ b/nnpfs/bsd/nnpfs_vfsops-bsd.c @@ -84,7 +84,11 @@ nnpfs_root(struct mount *mp, struct vnode **vpp) } int +#ifdef HAVE_VFS_QUOTACTL_CADDR nnpfs_quotactl(struct mount *mp, int cmd, uid_t uid, caddr_t arg, d_thread_t *p) +#else +nnpfs_quotactl(struct mount *mp, int cmd, uid_t uid, void *arg, d_thread_t *p) +#endif { NNPFSDEB(XDEBVFOPS, ("nnpfs_quotactl: mp = %lx, cmd = %d, uid = %u, " "arg = %lx, proc = %lx\n", @@ -225,6 +229,7 @@ nnpfs_checkexp (struct mount *mp, return 0; } +#ifndef HAVE_VOP_VPTOFH int nnpfs_vptofh(struct vnode * vp, struct fid * fhp @@ -236,6 +241,7 @@ nnpfs_vptofh(struct vnode * vp, NNPFSDEB(XDEBVFOPS, ("nnpfs_vptofh\n")); return EOPNOTSUPP; } +#endif #endif /* !__APPLE__ */ diff --git a/nnpfs/bsd/nnpfs_vfsops-freebsd.c b/nnpfs/bsd/nnpfs_vfsops-freebsd.c index a8177318e..ff47a74ac 100644 --- a/nnpfs/bsd/nnpfs_vfsops-freebsd.c +++ b/nnpfs/bsd/nnpfs_vfsops-freebsd.c @@ -60,7 +60,12 @@ static struct vop_vector nnpfs_dead_vops = { .vop_default = &default_vnodeops, .vop_lookup = nnpfs_dead_lookup, .vop_reclaim = nnpfs_dead_reclaim, +#ifdef HAVE_VOP_LOCK1 + .vop_lock1 = vop_stdlock, +#endif +#ifdef HAVE_VOP_LOCK .vop_lock = vop_stdlock, +#endif .vop_unlock = vop_stdunlock, .vop_islocked = vop_stdislocked, }; @@ -76,6 +81,15 @@ nnpfs_make_dead_vnode(struct mount *mp, int isrootp, struct vnode **vpp) if (error == 0) NNPFS_MAKE_VROOT(*vpp); +#ifdef HAVE_KERNEL_INSMNTQUE + /* XXX: Possibly should lock with lockmgr here. */ + error = insmntque(*vpp, mp); + if (error) { + *vpp = NULL; + return error; + } +#endif + nnpfs_vfs_writelock(*vpp, nnpfs_curproc()); return error; @@ -163,7 +177,9 @@ struct vfsops nnpfs_vfsops = { .vfs_vget = nnpfs_vget_freebsd, .vfs_fhtovp = nnpfs_fhtovp, .vfs_checkexp = nnpfs_checkexp, +#ifndef HAVE_VOP_VPTOFH .vfs_vptofh = nnpfs_vptofh, +#endif .vfs_init = nnpfs_init }; /*VFS_SET(nnpfs_vfsops, arlannpfsdev, 0);*/ diff --git a/nnpfs/bsd/nnpfs_vnodeops-bsd.c b/nnpfs/bsd/nnpfs_vnodeops-bsd.c index ee9d285e0..2effec4e1 100644 --- a/nnpfs/bsd/nnpfs_vnodeops-bsd.c +++ b/nnpfs/bsd/nnpfs_vnodeops-bsd.c @@ -85,7 +85,11 @@ nnpfs_open(struct vop_open_args * ap) ret = nnpfs_open_common(ap->a_vp, ap->a_mode, ctx); #ifdef __FreeBSD__ if (!ret) +#ifdef HAVE_THREE_ARGUMENT_VNODE_CREATE_VOBJ + vnode_create_vobject(ap->a_vp, +#else vnode_create_vobject_off(ap->a_vp, +#endif nnpfs_vattr_get_size(&VNODE_TO_XNODE(ap->a_vp)->attr), ap->a_td); #endif @@ -797,16 +801,25 @@ nnpfs_lk_info(char *msg, struct vnode *vp) #ifdef __FreeBSD__ int +#ifdef HAVE_VOP_LOCK1 +nnpfs_lock1(struct vop_lock1_args * ap) +#else nnpfs_lock(struct vop_lock_args * ap) +#endif { struct vnode *vp = ap->a_vp; int ret; nnpfs_assert(vp); +#ifdef HAVE_VOP_LOCK1 + NNPFSDEB(XDEBVNOPS, ("nnpfs_lock1: %lx, flags 0x%x\n", + (unsigned long)vp, ap->a_flags)); +#else nnpfs_assert(ap->a_td); NNPFSDEB(XDEBVNOPS, ("nnpfs_lock: %lx, td %p, flags 0x%x, nlocks %d\n", (unsigned long)vp, NNPFS_AP_PROC(ap), ap->a_flags, NNPFS_AP_PROC(ap)->td_locks)); +#endif nnpfs_lk_info("nnpfs_lock before", vp); ret = vop_stdlock(ap); @@ -821,16 +834,26 @@ nnpfs_unlock(struct vop_unlock_args * ap) struct vnode *vp = ap->a_vp; int ret; +#ifdef HAVE_TWO_ARGUMENT_VOP_UNLOCK + NNPFSDEB(XDEBVNOPS, + ("nnpfs_unlock: %lx, flags 0x%x\n", (unsigned long)vp, + ap->a_flags)); +#else NNPFSDEB(XDEBVNOPS, ("nnpfs_unlock: %lx, td %p, flags 0x%x, nlocks %d\n", (unsigned long)vp, ap->a_td, ap->a_flags, NNPFS_AP_PROC(ap)->td_locks)); +#endif nnpfs_lk_info("nnpfs_unlock before", vp); ret = vop_stdunlock(ap); +#ifdef HAVE_TWO_ARGUMENT_VOP_UNLOCK + NNPFSDEB(XDEBVNOPS, ("nnpfs_unlock: return %d\n", ret)); +#else NNPFSDEB(XDEBVNOPS, ("nnpfs_unlock: return %d, td %p, nlocks %d\n", ret, NNPFS_AP_PROC(ap), NNPFS_AP_PROC(ap)->td_locks)); +#endif return ret; } @@ -1317,6 +1340,23 @@ struct vop_pathconf_args { } #endif +#ifdef HAVE_VOP_VPTOFH +int +nnpfs_vptofh(struct vop_vptofh_args *ap) +/* +struct vop_vptofh_args { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + struct fid *a_fhp; +}; +*/ +{ + NNPFSDEB(XDEBVNOPS, ("nnpfs_vptofh\n")); + + return EOPNOTSUPP; +} +#endif + vop_t **nnpfs_vnodeop_p; @@ -1470,7 +1510,12 @@ struct vop_vector nnpfs_vnodeops = { .vop_bmap = nnpfs_bmap, .vop_poll = nnpfs_poll, +#ifdef HAVE_VOP_LOCK1 + .vop_lock1 = nnpfs_lock1, +#endif +#ifdef HAVE_VOP_LOCK .vop_lock = nnpfs_lock, +#endif .vop_unlock = nnpfs_unlock, .vop_islocked = nnpfs_islocked, .vop_revoke = nnpfs_revoke, @@ -1610,6 +1655,9 @@ static struct vnodeopv_entry_desc nnpfs_vnodeop_entries[] = { #ifdef HAVE_VOP_PATHCONF {&vop_pathconf_desc, (vop_t *) nnpfs_pathconf }, #endif +#ifdef HAVE_VOP_VPTOFH + {&vop_vptofh_desc, (vop_t *) nnpfs_vptofh }, +#endif {(struct vnodeop_desc *) NULL, (int (*) (void *)) NULL} }; diff --git a/nnpfs/bsd/nnpfs_vnodeops-common.c b/nnpfs/bsd/nnpfs_vnodeops-common.c index cb998342c..c5bbb5583 100644 --- a/nnpfs/bsd/nnpfs_vnodeops-common.c +++ b/nnpfs/bsd/nnpfs_vnodeops-common.c @@ -50,7 +50,7 @@ RCSID("$Id$"); static void nnpfs_handle_stale(struct nnpfs_node *xn) { -#if __APPLE__ +#ifdef __APPLE__ struct vnode *vp = XNODE_TO_VNODE(xn); #endif @@ -1440,7 +1440,9 @@ nnpfs_readlink_common(struct vnode *vp, struct uio *uiop, nnpfs_vfs_context ctx) int error = 0; nnpfs_cred cred; struct nnpfs *nnpfsp = NNPFS_FROM_VNODE(vp); +#ifdef HAVE_THREE_ARGUMENT_VOP_UNLOCK d_thread_t *proc = nnpfs_vfs_context_proc(ctx); +#endif NNPFSDEB(XDEBVNOPS, ("nnpfs_readlink\n")); diff --git a/nnpfs/freebsd/FreeBSD-Makefile b/nnpfs/freebsd/FreeBSD-Makefile index e2819be6c..41274a4d0 100644 --- a/nnpfs/freebsd/FreeBSD-Makefile +++ b/nnpfs/freebsd/FreeBSD-Makefile @@ -45,6 +45,6 @@ CLEANFILES=nnpfs_vopdefs.h .PATH: $(bsdsrcdir) nnpfs_vopdefs.h: vnode_if.h - awk '/^struct vop_[a-z]*_args/ { vop=substr($$2,5,length($$2)-9); printf("#define HAVE_VOP_%s 1\n", toupper(vop)); printf("NNPFS_VOP_DEF(%s);\n", vop); }' vnode_if.h > ${.TARGET} + awk '/^struct vop_[a-z0-9]*_args/ { vop=substr($$2,5,length($$2)-9); printf("#define HAVE_VOP_%s 1\n", toupper(vop)); printf("NNPFS_VOP_DEF(%s);\n", vop); }' vnode_if.h > ${.TARGET} -mkdir nnpfs test -d nnpfs && ( test -f nnpfs/nnpfs_vopdefs.h || ln -s ../nnpfs_vopdefs.h nnpfs/nnpfs_vopdefs.h ) -- 2.11.4.GIT