diff options
| author | Chris Johns <chrisj@rtems.org> | 2021-08-02 15:09:41 +1000 |
|---|---|---|
| committer | Chris Johns <chrisj@rtems.org> | 2021-08-28 10:25:46 +1000 |
| commit | 6514d561587fd1527fe6a26cb43e6b5742c8c779 (patch) | |
| tree | 922867fdc5aa24bbdf148bfae1b18dff0f283c10 /rtemsbsd | |
| parent | rtemsbsd: Remove DHCP init wrapper (diff) | |
| download | rtems-libbsd-6514d561587fd1527fe6a26cb43e6b5742c8c779.tar.bz2 | |
sys/kern: Add VFS support
- Refactor the libio interface
- Move syscalls into an rtemsbsd location
- Provide a root directory mount point
Update #4475
Diffstat (limited to 'rtemsbsd')
36 files changed, 12429 insertions, 1249 deletions
diff --git a/rtemsbsd/fs/rootfs/rootfs.c b/rtemsbsd/fs/rootfs/rootfs.c new file mode 100644 index 00000000..1e08680f --- /dev/null +++ b/rtemsbsd/fs/rootfs/rootfs.c @@ -0,0 +1,91 @@ +/** + * @file + * + * @ingroup rtems_bsd_rtems + * + * @brief TODO. + */ + +/* + * Copyright (c) 2020 Chris Johns + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <machine/rtems-bsd-kernel-space.h> + +#include <sys/param.h> +#include <sys/kernel.h> +#include <sys/mount.h> +#include <sys/vnode.h> + +#include <fs/pseudofs/pseudofs.h> + +static struct pfs_node *rootfs_root; + +static int +rootfs_attr(PFS_ATTR_ARGS, int mode) +{ + vap->va_mode = 0; + return 0; +} + +static int rootfs_attr_all_rwx(PFS_ATTR_ARGS) +{ + vap->va_mode = 0777; + return 0; +} + +int +rtems_bsd_rootfs_mkdir(const char *name) +{ + struct pfs_node *dir; + dir = pfs_create_dir(rootfs_root, name, rootfs_attr_all_rwx, NULL, NULL, + PFS_RDWR | PFS_NOWAIT); + if (dir == NULL) + return ENOENT; + return 0; +} + +int +rtems_bsd_rootfs_rmdir(const char *name) +{ + struct pfs_node *dir; + dir = pfs_find_node(rootfs_root, name); + if (dir == NULL) + return ENOENT; + return pfs_destroy(dir); +} + +static int rootfs_init(PFS_INIT_ARGS) +{ + rootfs_root = pi->pi_root; + return 0; +} + +static int rootfs_uninit(PFS_INIT_ARGS) +{ + return 0; +} + +PSEUDOFS(rootfs, 1, VFCF_SYNTHETIC); diff --git a/rtemsbsd/include/machine/atomic.h b/rtemsbsd/include/machine/atomic.h index a4b6b488..9465fefd 100644 --- a/rtemsbsd/include/machine/atomic.h +++ b/rtemsbsd/include/machine/atomic.h @@ -7,6 +7,7 @@ */ /* + * Copyright (c) 2020 Chris Johns All rights reserved. * Copyright (c) 2009, 2015 embedded brains GmbH. All rights reserved. * * embedded brains GmbH @@ -97,1446 +98,776 @@ rmb(void) #endif } -static inline void -atomic_add_int(volatile int *p, int v) -{ -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); +/* + * Load + */ - q->fetch_add(v, std::memory_order_seq_cst); +#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) +#define _ATOMIC_LOAD(T, p, mo, barrier) \ + std::atomic_##T *q = \ + reinterpret_cast<std::atomic_##T *>(const_cast<T *>(p)); \ + tmp = q->load(std::mo) #elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); - - atomic_fetch_add_explicit(q, v, memory_order_seq_cst); +#define _ATOMIC_LOAD(T, p, mo, barrier) \ + atomic_##T *q = (atomic_##T *)RTEMS_DEVOLATILE(T *, p); \ + tmp = atomic_load_explicit(q, mo) #else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p += v; - rtems_interrupt_enable(level); +#define _ATOMIC_LOAD(T, p, mo, barrier) \ + if (barrier) \ + RTEMS_COMPILER_MEMORY_BARRIER(); \ + tmp = *p #endif + +static inline int +atomic_load_int(volatile int *p) +{ + int tmp; + _ATOMIC_LOAD(int, p, memory_order_relaxed, false); + return (tmp); } -static inline void -atomic_add_acq_int(volatile int *p, int v) +static inline int +atomic_load_acq_int(volatile int *p) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); + int tmp; + _ATOMIC_LOAD(int, p, memory_order_acquire, true); + return (tmp); +} - q->fetch_add(v, std::memory_order_acquire); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); +static inline uint32_t +atomic_load_32(volatile uint32_t *p) +{ + uint32_t tmp; + _ATOMIC_LOAD(uint_fast32_t, p, memory_order_relaxed, false); + return (tmp); +} - atomic_fetch_add_explicit(q, v, memory_order_acquire); -#else - rtems_interrupt_level level; +static inline uint32_t +atomic_load_acq_32(volatile uint32_t *p) +{ + uint32_t tmp; + _ATOMIC_LOAD(uint_fast32_t, p, memory_order_acquire, true); + return (tmp); +} - rtems_interrupt_disable(level); - *p += v; - rtems_interrupt_enable(level); -#endif +static inline long +atomic_load_long(volatile long *p) +{ + long tmp; + _ATOMIC_LOAD(long, p, memory_order_relaxed, false); + return (tmp); } -static inline void -atomic_add_rel_int(volatile int *p, int v) +static inline long +atomic_load_acq_long(volatile long *p) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); + long tmp; + _ATOMIC_LOAD(long, p, memory_order_acquire, true); + return (tmp); +} - q->fetch_add(v, std::memory_order_release); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); +/* + * Store + */ - atomic_fetch_add_explicit(q, v, memory_order_release); +#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) +#define _ATOMIC_STORE(T, p, v, mo, barrier) \ + std::atomic_##T *q = \ + reinterpret_cast<std::atomic_##T *>(const_cast<T *>(p)); \ + q->store(std::mo) +#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) +#define _ATOMIC_STORE(T, p, v, mo, barrier) \ + atomic_##T *q = (atomic_##T *)RTEMS_DEVOLATILE(T *, p); \ + atomic_store_explicit(q, v, mo) #else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p += v; - rtems_interrupt_enable(level); +#define _ATOMIC_STORE(T, p, v, mo, barrier) \ + *p = v; \ + if (barrier) \ + RTEMS_COMPILER_MEMORY_BARRIER() #endif -} static inline void -atomic_subtract_int(volatile int *p, int v) +atomic_store_int(volatile int *p, int v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); - - q->fetch_sub(v, std::memory_order_seq_cst); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); - - atomic_fetch_sub_explicit(q, v, memory_order_seq_cst); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p -= v; - rtems_interrupt_enable(level); -#endif + _ATOMIC_STORE(int, p, v, memory_order_relaxed, false); } static inline void -atomic_subtract_acq_int(volatile int *p, int v) +atomic_store_rel_int(volatile int *p, int v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); - - q->fetch_sub(v, std::memory_order_acquire); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); - - atomic_fetch_sub_explicit(q, v, memory_order_acquire); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p -= v; - rtems_interrupt_enable(level); -#endif + _ATOMIC_STORE(int, p, v, memory_order_release, true); } static inline void -atomic_subtract_rel_int(volatile int *p, int v) +atomic_store_rel_32(volatile uint32_t *p, uint32_t v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); - - q->fetch_sub(v, std::memory_order_release); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); - - atomic_fetch_sub_explicit(q, v, memory_order_release); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p -= v; - rtems_interrupt_enable(level); -#endif + _ATOMIC_STORE(uint_fast32_t, p, v, memory_order_release, true); } static inline void -atomic_set_int(volatile int *p, int v) +atomic_store_rel_long(volatile long *p, long v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); - - q->fetch_or(v, std::memory_order_seq_cst); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); - - atomic_fetch_or_explicit(q, v, memory_order_seq_cst); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p |= v; - rtems_interrupt_enable(level); -#endif + _ATOMIC_STORE(long, p, v, memory_order_release, true); } static inline void -atomic_set_acq_int(volatile int *p, int v) +atomic_store_rel_ptr(volatile uintptr_t *p, uintptr_t v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); + /* XXX IPL32 ok with this? */ + _ATOMIC_STORE(uintptr_t, p, v, memory_order_release, true); +} - q->fetch_or(v, std::memory_order_acquire); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); +/* + * Add + */ - atomic_fetch_or_explicit(q, v, memory_order_acquire); +#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) +#define _ATOMIC_ADD(T, p, v, mo) \ + std::atomic_##T *q = \ + reinterpret_cast<std::atomic_##T *>(const_cast<T *>(p)); \ + q->fetch_add(v, std::mo) +#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) +#define _ATOMIC_ADD(T, p, v, mo) \ + atomic_##T *q = (atomic_##T *)RTEMS_DEVOLATILE(T *, p); \ + atomic_fetch_add_explicit(q, v, mo) #else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p |= v; - rtems_interrupt_enable(level); +#define _ATOMIC_ADD(T, p, v, mo) \ + rtems_interrupt_level level; \ + rtems_interrupt_disable(level); \ + *p += v; \ + rtems_interrupt_enable(level) #endif -} static inline void -atomic_set_rel_int(volatile int *p, int v) +atomic_add_int(volatile int *p, int v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); - - q->fetch_or(v, std::memory_order_release); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); - - atomic_fetch_or_explicit(q, v, memory_order_release); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p |= v; - rtems_interrupt_enable(level); -#endif + _ATOMIC_ADD(int, p, v, memory_order_seq_cst); } static inline void -atomic_clear_int(volatile int *p, int v) +atomic_add_acq_int(volatile int *p, int v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); - - q->fetch_and(~v, std::memory_order_seq_cst); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); - - atomic_fetch_and_explicit(q, ~v, memory_order_seq_cst); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p &= ~v; - rtems_interrupt_enable(level); -#endif + _ATOMIC_ADD(int, p, v, memory_order_acquire); } static inline void -atomic_clear_acq_int(volatile int *p, int v) +atomic_add_rel_int(volatile int *p, int v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); - - q->fetch_and(~v, std::memory_order_acquire); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); - - atomic_fetch_and_explicit(q, ~v, memory_order_acquire); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p &= ~v; - rtems_interrupt_enable(level); -#endif + _ATOMIC_ADD(int, p, v, memory_order_release); } static inline void -atomic_clear_rel_int(volatile int *p, int v) +atomic_add_32(volatile uint32_t *p, uint32_t v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); - - q->fetch_and(~v, std::memory_order_release); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); - - atomic_fetch_and_explicit(q, ~v, memory_order_release); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p &= ~v; - rtems_interrupt_enable(level); -#endif + _ATOMIC_ADD(uint_fast32_t, p, v, memory_order_seq_cst); } -static inline int -atomic_cmpset_int(volatile int *p, int cmp, int set) +static inline void +atomic_add_acq_32(volatile uint32_t *p, uint32_t v) { - int rv; - -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); - - rv = q->compare_exchange_strong(cmp, set, std::memory_order_seq_cst, - std::memory_order_relaxed); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); - - rv = atomic_compare_exchange_strong_explicit(q, &cmp, set, - memory_order_seq_cst, memory_order_relaxed); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - rv = *p == cmp; - if (rv) { - *p = set; - } - rtems_interrupt_enable(level); -#endif - - return (rv); + _ATOMIC_ADD(uint_fast32_t, p, v, memory_order_acquire); } -static inline int -atomic_fcmpset_int(volatile int *p, int *cmp, int set) +static inline void +atomic_add_rel_32(volatile uint32_t *p, uint32_t v) { - int rv; - -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); - - rv = q->compare_exchange_strong(*cmp, set, std::memory_order_seq_cst, - std::memory_order_relaxed); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); - - rv = atomic_compare_exchange_strong_explicit(q, cmp, set, - memory_order_seq_cst, memory_order_relaxed); -#else - rtems_interrupt_level level; - int actual; - - rtems_interrupt_disable(level); - actual = *p; - rv = actual == *cmp; - *cmp = actual; - if (rv) { - *p = set; - } - rtems_interrupt_enable(level); -#endif - - return (rv); + _ATOMIC_ADD(uint_fast32_t, p, v, memory_order_release); } -static inline int -atomic_cmpset_acq_int(volatile int *p, int cmp, int set) +static inline void +atomic_add_long(volatile long *p, long v) { - int rv; - -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); - - rv = q->compare_exchange_strong(cmp, set, std::memory_order_acquire, - std::memory_order_relaxed); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); - - rv = atomic_compare_exchange_strong_explicit(q, &cmp, set, - memory_order_acquire, memory_order_relaxed); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - rv = *p == cmp; - if (rv) { - *p = set; - } - rtems_interrupt_enable(level); -#endif - - return (rv); + _ATOMIC_ADD(long, p, v, memory_order_seq_cst); } -static inline int -atomic_cmpset_rel_int(volatile int *p, int cmp, int set) +static inline void +atomic_add_acq_long(volatile long *p, long v) { - int rv; - -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); - - rv = q->compare_exchange_strong(cmp, set, std::memory_order_release, - std::memory_order_relaxed); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); - - rv = atomic_compare_exchange_strong_explicit(q, &cmp, set, - memory_order_release, memory_order_relaxed); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - rv = *p == cmp; - if (rv) { - *p = set; - } - rtems_interrupt_enable(level); -#endif - - return (rv); + _ATOMIC_ADD(long, p, v, memory_order_acquire); } -static inline int -atomic_fetchadd_int(volatile int *p, int v) +static inline void +atomic_add_rel_long(volatile long *p, long v) { - int tmp; + _ATOMIC_ADD(long, p, v, memory_order_release); +} -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); +/* + * Subtract + */ - tmp = q->fetch_add(v, std::memory_order_seq_cst); +#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) +#define _ATOMIC_SUB(T, p, v, mo) \ + std::atomic_##T *q = \ + reinterpret_cast<std::atomic_##T *>(const_cast<T *>(p)); \ + q->fetch_sub(v, std::mo) #elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); - - tmp = atomic_fetch_add_explicit(q, v, memory_order_seq_cst); +#define _ATOMIC_SUB(T, p, v, mo) \ + atomic_##T *q = (atomic_##T *)RTEMS_DEVOLATILE(T *, p); \ + atomic_fetch_sub_explicit(q, v, mo) #else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - tmp = *p; - *p += v; - rtems_interrupt_enable(level); +#define _ATOMIC_SUB(T, p, v, mo) \ + rtems_interrupt_level level; \ + rtems_interrupt_disable(level); \ + *p -= v; \ + rtems_interrupt_enable(level) #endif - return (tmp); +static inline void +atomic_subtract_int(volatile int *p, int v) +{ + _ATOMIC_SUB(int, p, v, memory_order_seq_cst); } -static inline int -atomic_readandclear_int(volatile int *p) +static inline void +atomic_subtract_acq_int(volatile int *p, int v) { - int tmp; - -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); - - tmp = q->exchange(0, std::memory_order_seq_cst); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); - - tmp = atomic_exchange_explicit(q, 0, memory_order_seq_cst); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - tmp = *p; - *p = 0; - rtems_interrupt_enable(level); -#endif + _ATOMIC_SUB(int, p, v, memory_order_acquire); +} - return (tmp); +static inline void +atomic_subtract_rel_int(volatile int *p, int v) +{ + _ATOMIC_SUB(int, p, v, memory_order_release); } -static inline int -atomic_load_int(volatile int *p) +static inline void +atomic_subtract_32(volatile uint32_t *p, uint32_t v) { - int tmp; + _ATOMIC_SUB(uint_fast32_t, p, v, memory_order_seq_cst); +} -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); +static inline void +atomic_subtract_acq_32(volatile uint32_t *p, uint32_t v) +{ + _ATOMIC_SUB(uint_fast32_t, p, v, memory_order_acquire); +} - tmp = q->load(std::memory_order_relaxed); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); +static inline void +atomic_subtract_rel_32(volatile uint32_t *p, uint32_t v) +{ + _ATOMIC_SUB(uint_fast32_t, p, v, memory_order_release); +} - tmp = atomic_load_explicit(q, memory_order_relaxed); -#else - tmp = *p; -#endif +static inline void +atomic_subtract_long(volatile long *p, long v) +{ + _ATOMIC_SUB(long, p, v, memory_order_seq_cst); +} - return (tmp); +static inline void +atomic_subtract_acq_long(volatile long *p, long v) +{ + _ATOMIC_SUB(long, p, v, memory_order_acquire); } -static inline int -atomic_load_acq_int(volatile int *p) +static inline void +atomic_subtract_rel_long(volatile long *p, long v) { - int tmp; + _ATOMIC_SUB(long, p, v, memory_order_release); +} -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); +/* + * Set + */ - tmp = q->load(std::memory_order_acquire); +#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) +#define _ATOMIC_SET(T, p, v, mo) \ + std::atomic_##T *q = \ + reinterpret_cast<std::atomic_##T *>(const_cast<T *>(p)); \ + q->fetch_or(v, std::mo) #elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); - - tmp = atomic_load_explicit(q, memory_order_acquire); +#define _ATOMIC_SET(T, p, v, mo) \ + atomic_##T *q = (atomic_##T *)RTEMS_DEVOLATILE(T *, p); \ + atomic_fetch_or_explicit(q, v, mo) #else - RTEMS_COMPILER_MEMORY_BARRIER(); - tmp = *p; +#define _ATOMIC_SET(T, p, v, mo) \ + rtems_interrupt_level level; \ + rtems_interrupt_disable(level); \ + *p |= v; \ + rtems_interrupt_enable(level) #endif - return (tmp); +static inline void +atomic_set_int(volatile int *p, int v) +{ + _ATOMIC_SET(int, p, v, memory_order_seq_cst); } static inline void -atomic_store_int(volatile int *p, int v) +atomic_set_acq_int(volatile int *p, int v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); - - q->store(v, std::memory_order_relaxed); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); - - atomic_store_explicit(q, v, memory_order_relaxed); -#else - *p = v; -#endif + _ATOMIC_SET(int, p, v, memory_order_acquire); } static inline void -atomic_store_rel_int(volatile int *p, int v) +atomic_set_rel_int(volatile int *p, int v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_int *q = - reinterpret_cast<std::atomic_int *>(const_cast<int *>(p)); - - q->store(v, std::memory_order_release); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_int *q = (atomic_int *)RTEMS_DEVOLATILE(int *, p); - - atomic_store_explicit(q, v, memory_order_release); -#else - *p = v; - RTEMS_COMPILER_MEMORY_BARRIER(); -#endif + _ATOMIC_SET(int, p, v, memory_order_release); } static inline void -atomic_add_32(volatile uint32_t *p, uint32_t v) +atomic_set_32(volatile uint32_t *p, uint32_t v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); - - q->fetch_add(v, std::memory_order_seq_cst); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); - - atomic_fetch_add_explicit(q, v, memory_order_seq_cst); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p += v; - rtems_interrupt_enable(level); -#endif + _ATOMIC_SET(uint_fast32_t, p, v, memory_order_seq_cst); } static inline void -atomic_add_acq_32(volatile uint32_t *p, uint32_t v) +atomic_set_acq_32(volatile uint32_t *p, uint32_t v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); - - q->fetch_add(v, std::memory_order_acquire); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); - - atomic_fetch_add_explicit(q, v, memory_order_acquire); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p += v; - rtems_interrupt_enable(level); -#endif + _ATOMIC_SET(uint_fast32_t, p, v, memory_order_acquire); } static inline void -atomic_add_rel_32(volatile uint32_t *p, uint32_t v) +atomic_set_rel_32(volatile uint32_t *p, uint32_t v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); - - q->fetch_add(v, std::memory_order_release); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); - - atomic_fetch_add_explicit(q, v, memory_order_release); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p += v; - rtems_interrupt_enable(level); -#endif + _ATOMIC_SET(uint_fast32_t, p, v, memory_order_release); } static inline void -atomic_subtract_32(volatile uint32_t *p, uint32_t v) +atomic_set_long(volatile long *p, long v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); - - q->fetch_sub(v, std::memory_order_seq_cst); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); - - atomic_fetch_sub_explicit(q, v, memory_order_seq_cst); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p -= v; - rtems_interrupt_enable(level); -#endif + _ATOMIC_SET(long, p, v, memory_order_seq_cst); } static inline void -atomic_subtract_acq_32(volatile uint32_t *p, uint32_t v) +atomic_set_acq_long(volatile long *p, long v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); - - q->fetch_sub(v, std::memory_order_acquire); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); - - atomic_fetch_sub_explicit(q, v, memory_order_acquire); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p -= v; - rtems_interrupt_enable(level); -#endif + _ATOMIC_SET(long, p, v, memory_order_acquire); } static inline void -atomic_subtract_rel_32(volatile uint32_t *p, uint32_t v) +atomic_set_rel_long(volatile long *p, long v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); + _ATOMIC_SET(long, p, v, memory_order_release); +} - q->fetch_sub(v, std::memory_order_release); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); +/* + * Clear + */ - atomic_fetch_sub_explicit(q, v, memory_order_release); +#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) +#define _ATOMIC_CLEAR(T, p, v, mo) \ + std::atomic_##T *q = \ + reinterpret_cast<std::atomic_##T *>(const_cast<T *>(p)); \ + q->fetch_and(~v, std::mo) +#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) +#define _ATOMIC_CLEAR(T, p, v, mo) \ + atomic_##T *q = (atomic_##T *)RTEMS_DEVOLATILE(T *, p); \ + atomic_fetch_and_explicit(q, ~v, mo) #else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p -= v; - rtems_interrupt_enable(level); +#define _ATOMIC_CLEAR(T, p, v, mo) \ + rtems_interrupt_level level; \ + rtems_interrupt_disable(level); \ + *p &= ~v; \ + rtems_interrupt_enable(level) #endif -} static inline void -atomic_set_32(volatile uint32_t *p, uint32_t v) +atomic_clear_int(volatile int *p, int v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); - - q->fetch_or(v, std::memory_order_seq_cst); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); - - atomic_fetch_or_explicit(q, v, memory_order_seq_cst); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p |= v; - rtems_interrupt_enable(level); -#endif + _ATOMIC_CLEAR(int, p, v, memory_order_seq_cst); } static inline void -atomic_set_acq_32(volatile uint32_t *p, uint32_t v) +atomic_clear_acq_int(volatile int *p, int v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); - - q->fetch_or(v, std::memory_order_acquire); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); - - atomic_fetch_or_explicit(q, v, memory_order_acquire); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p |= v; - rtems_interrupt_enable(level); -#endif + _ATOMIC_CLEAR(int, p, v, memory_order_acquire); } static inline void -atomic_set_rel_32(volatile uint32_t *p, uint32_t v) +atomic_clear_rel_int(volatile int *p, int v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); - - q->fetch_or(v, std::memory_order_release); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); - - atomic_fetch_or_explicit(q, v, memory_order_release); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p |= v; - rtems_interrupt_enable(level); -#endif + _ATOMIC_CLEAR(int, p, v, memory_order_release); } static inline void atomic_clear_32(volatile uint32_t *p, uint32_t v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); - - q->fetch_and(~v, std::memory_order_seq_cst); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); - - atomic_fetch_and_explicit(q, ~v, memory_order_seq_cst); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p &= ~v; - rtems_interrupt_enable(level); -#endif + _ATOMIC_CLEAR(uint_fast32_t, p, v, memory_order_seq_cst); } static inline void atomic_clear_acq_32(volatile uint32_t *p, uint32_t v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); - - q->fetch_and(~v, std::memory_order_acquire); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); - - atomic_fetch_and_explicit(q, ~v, memory_order_acquire); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p &= ~v; - rtems_interrupt_enable(level); -#endif + _ATOMIC_CLEAR(uint_fast32_t, p, v, memory_order_acquire); } static inline void atomic_clear_rel_32(volatile uint32_t *p, uint32_t v) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); - - q->fetch_and(~v, std::memory_order_release); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); + _ATOMIC_CLEAR(uint_fast32_t, p, v, memory_order_release); +} - atomic_fetch_and_explicit(q, ~v, memory_order_release); -#else - rtems_interrupt_level level; +static inline void +atomic_clear_long(volatile long *p, long v) +{ + _ATOMIC_CLEAR(long, p, v, memory_order_release); +} - rtems_interrupt_disable(level); - *p &= ~v; - rtems_interrupt_enable(level); -#endif +static inline void +atomic_clear_acq_long(volatile long *p, long v) +{ + _ATOMIC_CLEAR(long, p, v, memory_order_acquire); } -static inline int -atomic_cmpset_32(volatile uint32_t *p, uint32_t cmp, uint32_t set) +static inline void +atomic_clear_rel_long(volatile long *p, long v) { - int rv; + _ATOMIC_CLEAR(long, p, v, memory_order_release); +} -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); +/* + * Compare and set + */ - rv = q->compare_exchange_strong(cmp, set, std::memory_order_seq_cst, - std::memory_order_relaxed); +#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) +#define _ATOMIC_CMPSET(T, p, cmp, set, mo) \ + std::atomic_##T *q = \ + reinterpret_cast<std::atomic_##T *>(const_cast<T *>(p)); \ + rv = q->compare_exchange_strong(cmp, set, \ + std::mo, std::memory_order_relaxed) #elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); - - rv = atomic_compare_exchange_strong_explicit(q, &cmp, set, - memory_order_seq_cst, memory_order_relaxed); +#define _ATOMIC_CMPSET(T, p, cmp, set, mo) \ + atomic_##T *q = (atomic_##T *)RTEMS_DEVOLATILE(T *, p); \ + atomic_compare_exchange_strong_explicit(q, &cmp, set, \ + mo, memory_order_relaxed) #else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - rv = *p == cmp; - if (rv) { - *p = set; - } +#define _ATOMIC_CMPSET(T, p, cmp, set, mo) \ + rtems_interrupt_level level; \ + rtems_interrupt_disable(level); \ + rv = *p == cmp; \ + if (rv) { \ + *p = set; \ + } \ rtems_interrupt_enable(level); #endif +static inline int +atomic_cmpset_int(volatile int *p, int cmp, int set) +{ + int rv; + _ATOMIC_CMPSET(int, p, cmp, set, memory_order_seq_cst); return (rv); } static inline int -atomic_cmpset_acq_32(volatile uint32_t *p, uint32_t cmp, uint32_t set) +atomic_cmpset_acq_int(volatile int *p, int cmp, int set) { int rv; - -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); - - rv = q->compare_exchange_strong(cmp, set, std::memory_order_acquire, - std::memory_order_relaxed); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); - - rv = atomic_compare_exchange_strong_explicit(q, &cmp, set, - memory_order_acquire, memory_order_relaxed); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - rv = *p == cmp; - if (rv) { - *p = set; - } - rtems_interrupt_enable(level); -#endif - + _ATOMIC_CMPSET(int, p, cmp, set, memory_order_acquire); return (rv); } static inline int -atomic_cmpset_rel_32(volatile uint32_t *p, uint32_t cmp, uint32_t set) +atomic_cmpset_rel_int(volatile int *p, int cmp, int set) { int rv; - -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); - - rv = q->compare_exchange_strong(cmp, set, std::memory_order_release, - std::memory_order_relaxed); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); - - rv = atomic_compare_exchange_strong_explicit(q, &cmp, set, - memory_order_release, memory_order_relaxed); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - rv = *p == cmp; - if (rv) { - *p = set; - } - rtems_interrupt_enable(level); -#endif - + _ATOMIC_CMPSET(int, p, cmp, set, memory_order_release); return (rv); } -static inline uint32_t -atomic_fetchadd_32(volatile uint32_t *p, uint32_t v) +static inline int +atomic_cmpset_32(volatile uint32_t *p, uint32_t cmp, uint32_t set) { - uint32_t tmp; - -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); - - tmp = q->fetch_add(v, std::memory_order_seq_cst); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); - - tmp = atomic_fetch_add_explicit(q, v, memory_order_seq_cst); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - tmp = *p; - *p += v; - rtems_interrupt_enable(level); -#endif - - return (tmp); + int rv; + _ATOMIC_CMPSET(uint_least32_t, p, cmp, set, memory_order_seq_cst); + return (rv); } -static inline uint32_t -atomic_readandclear_32(volatile uint32_t *p) +static inline int +atomic_cmpset_acq_32(volatile uint32_t *p, uint32_t cmp, uint32_t set) { - uint32_t tmp; - -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); - - tmp = q->exchange(0, std::memory_order_seq_cst); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); - - tmp = atomic_exchange_explicit(q, 0, memory_order_seq_cst); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - tmp = *p; - *p = 0; - rtems_interrupt_enable(level); -#endif - - return (tmp); + int rv; + _ATOMIC_CMPSET(uint_least32_t, p, cmp, set, memory_order_acquire); + return (rv); } -static inline uint32_t -atomic_load_32(volatile uint32_t *p) +static inline int +atomic_cmpset_rel_32(volatile uint32_t *p, uint32_t cmp, uint32_t set) { - uint32_t tmp; - -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); - - tmp = q->load(std::memory_order_relaxed); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); - - tmp = atomic_load_explicit(q, memory_order_relaxed); -#else - tmp = *p; -#endif - - return (tmp); + int rv; + _ATOMIC_CMPSET(uint_least32_t, p, cmp, set, memory_order_release); + return (rv); } -static inline uint32_t -atomic_load_acq_32(volatile uint32_t *p) +static inline int +atomic_cmpset_64(volatile uint64_t *p, uint64_t cmp, uint64_t set) { - uint32_t tmp; - -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); - - tmp = q->load(std::memory_order_acquire); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); - - tmp = atomic_load_explicit(q, memory_order_acquire); -#else - RTEMS_COMPILER_MEMORY_BARRIER(); - tmp = *p; -#endif - - return (tmp); + int rv; + _ATOMIC_CMPSET(uint_least64_t, p, cmp, set, memory_order_seq_cst); + return (rv); } -static inline void -atomic_store_rel_32(volatile uint32_t *p, uint32_t v) +static inline int +atomic_cmpset_acq_64(volatile uint64_t *p, uint64_t cmp, uint64_t set) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least32_t *q = - reinterpret_cast<std::atomic_uint_least32_t *>(const_cast<uint32_t *>(p)); - - q->store(v, std::memory_order_release); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least32_t *q = (atomic_uint_least32_t *)RTEMS_DEVOLATILE(uint32_t *, p); - - atomic_store_explicit(q, v, memory_order_release); -#else - *p = v; - RTEMS_COMPILER_MEMORY_BARRIER(); -#endif + int rv; + _ATOMIC_CMPSET(uint_least64_t, p, cmp, set, memory_order_acquire); + return (rv); } -static inline uint64_t -atomic_fetchadd_64(volatile uint64_t *p, uint64_t v) +static inline int +atomic_cmpset_rel_64(volatile uint64_t *p, uint64_t cmp, uint64_t set) { - uint64_t tmp; - -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_uint_least64_t *q = - reinterpret_cast<std::atomic_uint_least64_t *>(const_cast<uint64_t *>(p)); - - tmp = q->fetch_add(v, std::memory_order_seq_cst); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_uint_least64_t *q = (atomic_uint_least64_t *)RTEMS_DEVOLATILE(uint64_t *, p); - - tmp = atomic_fetch_add_explicit(q, v, memory_order_seq_cst); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - tmp = *p; - *p += v; - rtems_interrupt_enable(level); -#endif - - return (tmp); + int rv; + _ATOMIC_CMPSET(uint_least64_t, p, cmp, set, memory_order_release); + return (rv); } -static inline void -atomic_add_long(volatile long *p, long v) +static inline int +atomic_cmpset_long(volatile long *p, long cmp, long set) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); - - q->fetch_add(v, std::memory_order_seq_cst); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - atomic_fetch_add_explicit(q, v, memory_order_seq_cst); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p += v; - rtems_interrupt_enable(level); -#endif + int rv; + _ATOMIC_CMPSET(long, p, cmp, set, memory_order_seq_cst); + return (rv); } -static inline void -atomic_add_acq_long(volatile long *p, long v) +static inline int +atomic_cmpset_acq_long(volatile long *p, long cmp, long set) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); - - q->fetch_add(v, std::memory_order_acquire); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - atomic_fetch_add_explicit(q, v, memory_order_acquire); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p += v; - rtems_interrupt_enable(level); -#endif + int rv; + _ATOMIC_CMPSET(long, p, cmp, set, memory_order_acquire); + return (rv); } -static inline void -atomic_add_rel_long(volatile long *p, long v) +static inline int +atomic_cmpset_rel_long(volatile long *p, long cmp, long set) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); - - q->fetch_add(v, std::memory_order_release); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - atomic_fetch_add_explicit(q, v, memory_order_release); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p += v; - rtems_interrupt_enable(level); -#endif + int rv; + _ATOMIC_CMPSET(long, p, cmp, set, memory_order_release); + return (rv); } -static inline void -atomic_subtract_long(volatile long *p, long v) +static inline int +atomic_cmpset_ptr(volatile uintptr_t *p, uintptr_t cmp, uintptr_t set) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); - - q->fetch_sub(v, std::memory_order_seq_cst); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - atomic_fetch_sub_explicit(q, v, memory_order_seq_cst); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p -= v; - rtems_interrupt_enable(level); -#endif + int rv; + _ATOMIC_CMPSET(uintptr_t, p, cmp, set, memory_order_seq_cst); + return (rv); } -static inline void -atomic_subtract_acq_long(volatile long *p, long v) +static inline int +atomic_cmpset_acq_ptr(volatile uintptr_t *p, uintptr_t cmp, uintptr_t set) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); - - q->fetch_sub(v, std::memory_order_acquire); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - atomic_fetch_sub_explicit(q, v, memory_order_acquire); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p -= v; - rtems_interrupt_enable(level); -#endif + int rv; + _ATOMIC_CMPSET(uintptr_t, p, cmp, set, memory_order_acquire); + return (rv); } -static inline void -atomic_subtract_rel_long(volatile long *p, long v) +static inline int +atomic_cmpset_rel_ptr(volatile uintptr_t *p, uintptr_t cmp, uintptr_t set) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); - - q->fetch_sub(v, std::memory_order_release); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - atomic_fetch_sub_explicit(q, v, memory_order_release); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p -= v; - rtems_interrupt_enable(level); -#endif + int rv; + _ATOMIC_CMPSET(uintptr_t, p, cmp, set, memory_order_release); + return (rv); } -static inline void -atomic_set_long(volatile long *p, long v) -{ -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); +/* + * Fetch compare and set + */ - q->fetch_or(v, std::memory_order_seq_cst); +#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) +#define _ATOMIC_FCMPSET(T, p, cmp, set, mo) \ + std::atomic_##T *q = \ + reinterpret_cast<std::atomic_##T *>(const_cast<T *>(p)); \ + rv = q->compare_exchange_strong(*cmp, set, \ + std::mo, std::memory_order_relaxed) #elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - atomic_fetch_or_explicit(q, v, memory_order_seq_cst); +#define _ATOMIC_FCMPSET(T, p, cmp, set, mo) \ + atomic_##T *q = (atomic_##T *)RTEMS_DEVOLATILE(T *, p); \ + atomic_compare_exchange_strong_explicit(q, cmp, set, \ + mo, memory_order_relaxed) #else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p |= v; +#define _ATOMIC_FCMPSET(T, p, cmp, set, mo) \ + rtems_interrupt_level level; \ + T actual; \ + rtems_interrupt_disable(level); \ + actual = *p; \ + rv = actual == *cmp; \ + *cmp = actual; \ + if (rv) { \ + *p = set; \ + } \ rtems_interrupt_enable(level); #endif -} -static inline void -atomic_set_acq_long(volatile long *p, long v) +static inline int +atomic_fcmpset_int(volatile int *p, int *cmp, int set) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); - - q->fetch_or(v, std::memory_order_acquire); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - atomic_fetch_or_explicit(q, v, memory_order_acquire); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p |= v; - rtems_interrupt_enable(level); -#endif + int rv; + _ATOMIC_FCMPSET(int, p, cmp, set, memory_order_seq_cst); + return (rv); } -static inline void -atomic_set_rel_long(volatile long *p, long v) +static inline int +atomic_fcmpset_acq_int(volatile int *p, int *cmp, int set) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); - - q->fetch_or(v, std::memory_order_release); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - atomic_fetch_or_explicit(q, v, memory_order_release); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p |= v; - rtems_interrupt_enable(level); -#endif + int rv; + _ATOMIC_FCMPSET(int, p, cmp, set, memory_order_acquire); + return (rv); } -static inline void -atomic_clear_long(volatile long *p, long v) +static inline int +atomic_fcmpset_rel_int(volatile int *p, int *cmp, int set) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); - - q->fetch_and(~v, std::memory_order_seq_cst); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - atomic_fetch_and_explicit(q, ~v, memory_order_seq_cst); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p &= ~v; - rtems_interrupt_enable(level); -#endif + int rv; + _ATOMIC_FCMPSET(int, p, cmp, set, memory_order_release); + return (rv); } -static inline void -atomic_clear_acq_long(volatile long *p, long v) +static inline int +atomic_fcmpset_64(volatile uint64_t *p, uint64_t *cmp, uint64_t set) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); - - q->fetch_and(~v, std::memory_order_acquire); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - atomic_fetch_and_explicit(q, ~v, memory_order_acquire); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p &= ~v; - rtems_interrupt_enable(level); -#endif + int rv; + _ATOMIC_FCMPSET(uint_least64_t, p, cmp, set, memory_order_seq_cst); + return (rv); } -static inline void -atomic_clear_rel_long(volatile long *p, long v) +static inline int +atomic_fcmpset_acq_64(volatile uint64_t *p, uint64_t *cmp, uint64_t set) { -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); - - q->fetch_and(~v, std::memory_order_release); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - atomic_fetch_and_explicit(q, ~v, memory_order_release); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - *p &= ~v; - rtems_interrupt_enable(level); -#endif + int rv; + _ATOMIC_FCMPSET(uint_least64_t, p, cmp, set, memory_order_acquire); + return (rv); } static inline int -atomic_cmpset_long(volatile long *p, long cmp, long set) +atomic_fcmpset_rel_64(volatile uint64_t *p, uint64_t *cmp, uint64_t set) { int rv; - -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); - - rv = q->compare_exchange_strong(cmp, set, std::memory_order_seq_cst, - std::memory_order_relaxed); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - rv = atomic_compare_exchange_strong_explicit(q, &cmp, set, - memory_order_seq_cst, memory_order_relaxed); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - rv = *p == cmp; - if (rv) { - *p = set; - } - rtems_interrupt_enable(level); -#endif - + _ATOMIC_FCMPSET(uint_least64_t, p, cmp, set, memory_order_release); return (rv); } +/* XXX Is IPL32 ok with the .*_ptr versions? */ static inline int -atomic_cmpset_acq_long(volatile long *p, long cmp, long set) +atomic_fcmpset_ptr(volatile uintptr_t *p, uintptr_t *cmp, uintptr_t set) { int rv; + _ATOMIC_FCMPSET(uintptr_t, p, cmp, set, memory_order_seq_cst); + return (rv); +} -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); - - rv = q->compare_exchange_strong(cmp, set, std::memory_order_acquire, - std::memory_order_relaxed); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - rv = atomic_compare_exchange_strong_explicit(q, &cmp, set, - memory_order_acquire, memory_order_relaxed); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - rv = *p == cmp; - if (rv) { - *p = set; - } - rtems_interrupt_enable(level); -#endif - +static inline int +atomic_fcmpset_acq_ptr(volatile uintptr_t *p, uintptr_t *cmp, uintptr_t set) +{ + int rv; + _ATOMIC_FCMPSET(uintptr_t, p, cmp, set, memory_order_acquire); return (rv); } static inline int -atomic_cmpset_rel_long(volatile long *p, long cmp, long set) +atomic_fcmpset_rel_ptr(volatile uintptr_t *p, uintptr_t *cmp, uintptr_t set) { int rv; + _ATOMIC_FCMPSET(uintptr_t, p, cmp, set, memory_order_release); + return (rv); +} -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); +/* + * Fetch add + */ - rv = q->compare_exchange_strong(cmp, set, std::memory_order_release, - std::memory_order_relaxed); +#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) +#define _ATOMIC_FETCHADD(T, p, v, mo) \ + std::atomic_##T *q = \ + reinterpret_cast<std::atomic_##T *>(const_cast<T *>(p)); \ + tmp = q->fetch_add(v, std::mo) #elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - rv = atomic_compare_exchange_strong_explicit(q, &cmp, set, - memory_order_release, memory_order_relaxed); +#define _ATOMIC_FETCHADD(T, p, v, mo) \ + atomic_##T *q = (atomic_##T *)RTEMS_DEVOLATILE(T *, p); \ + tmp = atomic_fetch_add_explicit(q, v, mo) #else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - rv = *p == cmp; - if (rv) { - *p = set; - } +#define _ATOMIC_FETCHADD(T, p, v, mo) \ + rtems_interrupt_level level; \ + rtems_interrupt_disable(level); \ + tmp = *p; \ + *p += v; \ rtems_interrupt_enable(level); #endif - return (rv); +static inline int +atomic_fetchadd_int(volatile int *p, int v) +{ + int tmp; + _ATOMIC_FETCHADD(int, p, v, memory_order_seq_cst); + return (tmp); } -static inline long -atomic_fetchadd_long(volatile long *p, long v) +static inline uint32_t +atomic_fetchadd_32(volatile uint32_t *p, uint32_t v) { - long tmp; - -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); - - tmp = q->fetch_add(v, std::memory_order_seq_cst); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - tmp = atomic_fetch_add_explicit(q, v, memory_order_seq_cst); -#else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - tmp = *p; - *p += v; - rtems_interrupt_enable(level); -#endif + uint32_t tmp; + _ATOMIC_FETCHADD(uint_fast32_t, p, v, memory_order_seq_cst); + return (tmp); +} +static inline uint64_t +atomic_fetchadd_64(volatile uint64_t *p, uint64_t v) +{ + uint64_t tmp; + _ATOMIC_FETCHADD(uint_fast64_t, p, v, memory_order_seq_cst); return (tmp); } static inline long -atomic_readandclear_long(volatile long *p) +atomic_fetchadd_long(volatile long *p, long v) { long tmp; + _ATOMIC_FETCHADD(long, p, v, memory_order_seq_cst); + return (tmp); +} -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); +/* + * Read and clear + */ - tmp = q->exchange(0, std::memory_order_seq_cst); +#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) +#define _ATOMIC_READANDCLEAR(T, p, mo) \ + std::atomic_##T *q = \ + reinterpret_cast<std::atomic_##T *>(const_cast<T *>(p)); \ + tmp = q->exchange(0, std::mo) #elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - tmp = atomic_exchange_explicit(q, 0, memory_order_seq_cst); +#define _ATOMIC_READANDCLEAR(T, p, mo) \ + atomic_##T *q = (atomic_##T *)RTEMS_DEVOLATILE(T *, p); \ + tmp = atomic_exchange_explicit(q, 0, mo) #else - rtems_interrupt_level level; - - rtems_interrupt_disable(level); - tmp = *p; - *p = 0; +#define _ATOMIC_READANDCLEAR(T, p, mo) \ + rtems_interrupt_level level; \ + rtems_interrupt_disable(level); \ + tmp = *p; \ + *p = 0; \ rtems_interrupt_enable(level); #endif +static inline int +atomic_readandclear_int(volatile int *p) +{ + int tmp; + _ATOMIC_READANDCLEAR(int, p, memory_order_seq_cst); return (tmp); } -static inline long -atomic_load_long(volatile long *p) +static inline uint32_t +atomic_readandclear_32(volatile uint32_t *p) { - long tmp; - -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); - - tmp = q->load(std::memory_order_relaxed); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - tmp = atomic_load_explicit(q, memory_order_relaxed); -#else - tmp = *p; -#endif - + uint32_t tmp; + _ATOMIC_READANDCLEAR(uint_least32_t, p, memory_order_seq_cst); return (tmp); } static inline long -atomic_load_acq_long(volatile long *p) +atomic_readandclear_long(volatile long *p) { long tmp; - -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); - - tmp = q->load(std::memory_order_acquire); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - tmp = atomic_load_explicit(q, memory_order_acquire); -#else - RTEMS_COMPILER_MEMORY_BARRIER(); - tmp = *p; -#endif - + _ATOMIC_READANDCLEAR(long, p, memory_order_seq_cst); return (tmp); } -static inline void -atomic_store_rel_long(volatile long *p, long v) -{ -#if defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_ATOMIC) - std::atomic_long *q = - reinterpret_cast<std::atomic_long *>(const_cast<long *>(p)); - - q->store(v, std::memory_order_release); -#elif defined(_RTEMS_BSD_MACHINE_ATOMIC_USE_STDATOMIC) - atomic_long *q = (atomic_long *)RTEMS_DEVOLATILE(long *, p); - - atomic_store_explicit(q, v, memory_order_release); -#else - *p = v; - RTEMS_COMPILER_MEMORY_BARRIER(); -#endif -} +/* + * Thread fence + */ static inline void atomic_thread_fence_acq(void) diff --git a/rtemsbsd/include/machine/rtems-bsd-config.h b/rtemsbsd/include/machine/rtems-bsd-config.h index 491d9a72..a820e51d 100644 --- a/rtemsbsd/include/machine/rtems-bsd-config.h +++ b/rtemsbsd/include/machine/rtems-bsd-config.h @@ -85,6 +85,12 @@ extern "C" { #define RTEMS_BSD_CFGDECL_DOMAIN_PAGE_MBUFS_SIZE RTEMS_BSD_ALLOCATOR_DOMAIN_PAGE_MBUF_DEFAULT #endif +#if defined(RTEMS_BSD_CONFIG_DOMAIN_BIO_SIZE) + #define RTEMS_BSD_CFGDECL_DOMAIN_BIO_SIZE RTEMS_BSD_CONFIG_DOMAIN_BIO_SIZE +#else + #define RTEMS_BSD_CFGDECL_DOMAIN_BIO_SIZE RTEMS_BSD_ALLOCATOR_DOMAIN_BIO_DEFAULT +#endif + /* * BSD Kernel modules. */ @@ -223,6 +229,12 @@ extern "C" { RTEMS_BSD_CFGDECL_DOMAIN_PAGE_MBUFS_SIZE; /* + * Configure the block IO buffer memory size. + */ + uintptr_t rtems_bsd_allocator_domain_bio_size = \ + RTEMS_BSD_CFGDECL_DOMAIN_BIO_SIZE; + + /* * If a BSP configuration is requested include the Nexus bus BSP * configuration. */ diff --git a/rtemsbsd/include/machine/rtems-bsd-kernel-namespace.h b/rtemsbsd/include/machine/rtems-bsd-kernel-namespace.h index 293c6115..9d3472d6 100644 --- a/rtemsbsd/include/machine/rtems-bsd-kernel-namespace.h +++ b/rtemsbsd/include/machine/rtems-bsd-kernel-namespace.h @@ -104,6 +104,7 @@ #define M_80211_SCAN _bsd_M_80211_SCAN #define M_80211_VAP _bsd_M_80211_VAP #define M_ACCF _bsd_M_ACCF +#define M_ACL _bsd_M_ACL #define M_ALIAS _bsd_M_ALIAS #define M_BPF _bsd_M_BPF #define M_BPFJIT _bsd_M_BPFJIT @@ -111,6 +112,8 @@ #define M_CRYPTO_DATA _bsd_M_CRYPTO_DATA #define M_DEVBUF _bsd_M_DEVBUF #define M_EVDEV _bsd_M_EVDEV +#define M_FADVISE _bsd_M_FADVISE +#define M_FILECAPS _bsd_M_FILECAPS #define M_FIXEDREGULATOR _bsd_M_FIXEDREGULATOR #define M_GIF _bsd_M_GIF #define M_GRE _bsd_M_GRE @@ -130,6 +133,7 @@ #define M_IPSEC_SPDCACHE _bsd_M_IPSEC_SPDCACHE #define M_IPSEC_SR _bsd_M_IPSEC_SR #define M_LLTABLE _bsd_M_LLTABLE +#define M_MOUNT _bsd_M_MOUNT #define M_NVME _bsd_M_NVME #define M_OFWPROP _bsd_M_OFWPROP #define M_PCB _bsd_M_PCB @@ -138,13 +142,18 @@ #define M_RTABLE _bsd_M_RTABLE #define M_RTWN_PRIV _bsd_M_RTWN_PRIV #define M_SONAME _bsd_M_SONAME +#define M_STATFS _bsd_M_STATFS #define M_TAP _bsd_M_TAP #define M_TCPFUNCTIONS _bsd_M_TCPFUNCTIONS #define M_TCPLOG _bsd_M_TCPLOG #define M_TEMP _bsd_M_TEMP #define M_USB _bsd_M_USB #define M_USBDEV _bsd_M_USBDEV +#define M_VNODE _bsd_M_VNODE +#define M_VNODE_MARKER _bsd_M_VNODE_MARKER #define M_XDATA _bsd_M_XDATA +#define NDFREE _bsd_NDFREE +#define NDINIT_ALL _bsd_NDINIT_ALL #define OF_call_method _bsd_OF_call_method #define OF_canon _bsd_OF_canon #define OF_child _bsd_OF_child @@ -280,12 +289,22 @@ #define Skein_512_Output _bsd_Skein_512_Output #define Skein_512_Process_Block _bsd_Skein_512_Process_Block #define Skein_512_Update _bsd_Skein_512_Update +#define Skein_Get64_LSB_First _bsd_Skein_Get64_LSB_First +#define Skein_Put64_LSB_First _bsd_Skein_Put64_LSB_First #define TB_DRAIN_WAITER _bsd_TB_DRAIN_WAITER #define X_ip6_mforward _bsd_X_ip6_mforward #define X_ip6_mrouter_done _bsd_X_ip6_mrouter_done #define X_ip6_mrouter_get _bsd_X_ip6_mrouter_get #define X_ip6_mrouter_set _bsd_X_ip6_mrouter_set #define X_mrt6_ioctl _bsd_X_mrt6_ioctl +#define __lockmgr_args _bsd___lockmgr_args +#define __mnt_vnode_first_active _bsd___mnt_vnode_first_active +#define __mnt_vnode_first_all _bsd___mnt_vnode_first_all +#define __mnt_vnode_markerfree_active _bsd___mnt_vnode_markerfree_active +#define __mnt_vnode_markerfree_all _bsd___mnt_vnode_markerfree_all +#define __mnt_vnode_next_active _bsd___mnt_vnode_next_active +#define __mnt_vnode_next_all _bsd___mnt_vnode_next_all +#define __vfs_statfs _bsd___vfs_statfs #define _callout_init_lock _bsd__callout_init_lock #define _callout_stop_safe _bsd__callout_stop_safe #define _ck_epoch_addref _bsd__ck_epoch_addref @@ -295,6 +314,10 @@ #define _cv_wait _bsd__cv_wait #define _cv_wait_sig _bsd__cv_wait_sig #define _cv_wait_unlock _bsd__cv_wait_unlock +#define _eventhandler_list_vfs_mounted _bsd__eventhandler_list_vfs_mounted +#define _eventhandler_list_vfs_unmounted _bsd__eventhandler_list_vfs_unmounted +#define _fdrop _bsd__fdrop +#define _finstall _bsd__finstall #define _kevent _bsd__kevent #define _libmd_SHA224_Final _bsd__libmd_SHA224_Final #define _libmd_SHA224_Init _bsd__libmd_SHA224_Init @@ -314,8 +337,12 @@ #define _libmd_SKEIN512_Final _bsd__libmd_SKEIN512_Final #define _libmd_SKEIN512_Init _bsd__libmd_SKEIN512_Init #define _libmd_SKEIN512_Update _bsd__libmd_SKEIN512_Update +#define _lockmgr_assert _bsd__lockmgr_assert +#define _lockmgr_disown _bsd__lockmgr_disown +#define _mtx_assert _bsd__mtx_assert #define _mtx_lock_flags _bsd__mtx_lock_flags #define _mtx_unlock_flags _bsd__mtx_unlock_flags +#define _rw_assert _bsd__rw_assert #define _rw_downgrade _bsd__rw_downgrade #define _rw_rlock _bsd__rw_rlock #define _rw_runlock _bsd__rw_runlock @@ -345,9 +372,13 @@ #define _stop_set_scanner_set _bsd__stop_set_scanner_set #define _stop_set_sysctl_set _bsd__stop_set_sysctl_set #define _stop_set_sysinit_set _bsd__stop_set_sysinit_set +#define _sx_assert _bsd__sx_assert #define _sx_slock_int _bsd__sx_slock_int #define _sx_sunlock_int _bsd__sx_sunlock_int #define _timeout_task_init _bsd__timeout_task_init +#define _vdrop _bsd__vdrop +#define _vhold _bsd__vhold +#define _vn_lock _bsd__vn_lock #define accept_filt_add _bsd_accept_filt_add #define accept_filt_del _bsd_accept_filt_del #define accept_filt_generic_mod_event _bsd_accept_filt_generic_mod_event @@ -355,6 +386,10 @@ #define accept_filt_getopt _bsd_accept_filt_getopt #define accept_filt_setopt _bsd_accept_filt_setopt #define accept_mtx _bsd_accept_mtx +#define acl_alloc _bsd_acl_alloc +#define acl_copy_acl_into_oldacl _bsd_acl_copy_acl_into_oldacl +#define acl_copy_oldacl_into_acl _bsd_acl_copy_oldacl_into_acl +#define acl_free _bsd_acl_free #define addrsel_policy_init _bsd_addrsel_policy_init #define ah_cleartos _bsd_ah_cleartos #define ah_enable _bsd_ah_enable @@ -362,11 +397,23 @@ #define ah_init0 _bsd_ah_init0 #define ah_zeroize _bsd_ah_zeroize #define ahstat _bsd_ahstat +#define aio_aqueue _bsd_aio_aqueue +#define aio_cancel _bsd_aio_cancel +#define aio_cancel_cleared _bsd_aio_cancel_cleared +#define aio_clear_cancel_function _bsd_aio_clear_cancel_function +#define aio_complete _bsd_aio_complete +#define aio_init_aioinfo _bsd_aio_init_aioinfo +#define aio_schedule _bsd_aio_schedule +#define aio_set_cancel_function _bsd_aio_set_cancel_function #define aio_swake _bsd_aio_swake +#define aio_switch_vmspace _bsd_aio_switch_vmspace #define alloc_unr _bsd_alloc_unr #define alloc_unr64 _bsd_alloc_unr64 #define alloc_unr_specific _bsd_alloc_unr_specific #define alloc_unrl _bsd_alloc_unrl +#define allocbuf _bsd_allocbuf +#define allproc_lock _bsd_allproc_lock +#define altbufferflushes _bsd_altbufferflushes #define altq_add _bsd_altq_add #define altq_add_queue _bsd_altq_add_queue #define altq_attach _bsd_altq_attach @@ -415,7 +462,11 @@ #define auth_hash_sha2_256 _bsd_auth_hash_sha2_256 #define auth_hash_sha2_384 _bsd_auth_hash_sha2_384 #define auth_hash_sha2_512 _bsd_auth_hash_sha2_512 +#define babarrierwrite _bsd_babarrierwrite +#define badfileops _bsd_badfileops #define badport_bandlim _bsd_badport_bandlim +#define bawrite _bsd_bawrite +#define bbarrierwrite _bsd_bbarrierwrite #define bcd2bin_data _bsd_bcd2bin_data #define bce_COM_b06FwBss _bsd_bce_COM_b06FwBss #define bce_COM_b06FwBssAddr _bsd_bce_COM_b06FwBssAddr @@ -643,9 +694,24 @@ #define bce_xi90_rv2p_proc2 _bsd_bce_xi90_rv2p_proc2 #define bce_xi_rv2p_proc1 _bsd_bce_xi_rv2p_proc1 #define bce_xi_rv2p_proc2 _bsd_bce_xi_rv2p_proc2 +#define bd_speedup _bsd_bd_speedup +#define bdata2bio _bsd_bdata2bio +#define bdhidirty _bsd_bdhidirty +#define bdirty _bsd_bdirty +#define bdlodirty _bsd_bdlodirty +#define bdomain _bsd_bdomain +#define bdone _bsd_bdone +#define bdwrite _bsd_bdwrite +#define bdwriteskip _bsd_bdwriteskip #define be_uuid_dec _bsd_be_uuid_dec #define be_uuid_enc _bsd_be_uuid_enc +#define bgetvp _bsd_bgetvp #define bin2bcd_data _bsd_bin2bcd_data +#define bio_transient_maxcnt _bsd_bio_transient_maxcnt +#define biodone _bsd_biodone +#define biofinish _bsd_biofinish +#define bioops _bsd_bioops +#define biowait _bsd_biowait #define blake2b_final_ref _bsd_blake2b_final_ref #define blake2b_init_key_ref _bsd_blake2b_init_key_ref #define blake2b_init_param_ref _bsd_blake2b_init_param_ref @@ -666,6 +732,7 @@ #define blist_free _bsd_blist_free #define blist_resize _bsd_blist_resize #define blist_stats _bsd_blist_stats +#define bnoreuselist _bsd_bnoreuselist #define bpf_buffer_append_bytes _bsd_bpf_buffer_append_bytes #define bpf_buffer_append_mbuf _bsd_bpf_buffer_append_mbuf #define bpf_buffer_free _bsd_bpf_buffer_free @@ -682,6 +749,13 @@ #define bpfattach _bsd_bpfattach #define bpfattach2 _bsd_bpfattach2 #define bpfdetach _bsd_bpfdetach +#define bqempty _bsd_bqempty +#define bqrelse _bsd_bqrelse +#define breadn_flags _bsd_breadn_flags +#define brelse _bsd_brelse +#define brelvp _bsd_brelvp +#define bremfree _bsd_bremfree +#define bremfreef _bsd_bremfreef #define bridge_control_table _bsd_bridge_control_table #define bridge_control_table_size _bsd_bridge_control_table_size #define bridge_dn_p _bsd_bridge_dn_p @@ -713,8 +787,29 @@ #define bt_tickthreshold _bsd_bt_tickthreshold #define bt_timethreshold _bsd_bt_timethreshold #define bucket_zones _bsd_bucket_zones +#define buf_dirty_count_severe _bsd_buf_dirty_count_severe +#define buf_ops_bio _bsd_buf_ops_bio #define buf_ring_alloc _bsd_buf_ring_alloc #define buf_ring_free _bsd_buf_ring_free +#define buf_wmesg _bsd_buf_wmesg +#define buf_zone _bsd_buf_zone +#define bufbdflush _bsd_bufbdflush +#define bufdaemonproc _bsd_bufdaemonproc +#define bufdone _bsd_bufdone +#define bufinit _bsd_bufinit +#define bufobj_init _bsd_bufobj_init +#define bufobj_invalbuf _bsd_bufobj_invalbuf +#define bufobj_wdrop _bsd_bufobj_wdrop +#define bufobj_wref _bsd_bufobj_wref +#define bufobj_wrefl _bsd_bufobj_wrefl +#define bufobj_wwait _bsd_bufobj_wwait +#define bufshutdown _bsd_bufshutdown +#define bufspacethresh _bsd_bufspacethresh +#define bufstrategy _bsd_bufstrategy +#define bufsync _bsd_bufsync +#define bufwait _bsd_bufwait +#define bufwrite _bsd_bufwrite +#define bundirty _bsd_bundirty #define bus_activate_resource _bsd_bus_activate_resource #define bus_adjust_resource _bsd_bus_adjust_resource #define bus_alloc_resource _bsd_bus_alloc_resource @@ -806,6 +901,14 @@ #define bus_teardown_intr _bsd_bus_teardown_intr #define bus_unmap_resource _bsd_bus_unmap_resource #define busdma_lock_mutex _bsd_busdma_lock_mutex +#define bwait _bsd_bwait +#define bwillwrite _bsd_bwillwrite +#define cache_changesize _bsd_cache_changesize +#define cache_enter_time _bsd_cache_enter_time +#define cache_lookup _bsd_cache_lookup +#define cache_purge _bsd_cache_purge +#define cache_purge_negative _bsd_cache_purge_negative +#define cache_purgevfs _bsd_cache_purgevfs #define calculate_crc32c _bsd_calculate_crc32c #define callout_handle_init _bsd_callout_handle_init #define callout_init _bsd_callout_init @@ -835,6 +938,32 @@ #define camellia_setup128 _bsd_camellia_setup128 #define camellia_setup192 _bsd_camellia_setup192 #define camellia_setup256 _bsd_camellia_setup256 +#define cap_accept_rights _bsd_cap_accept_rights +#define cap_bind_rights _bsd_cap_bind_rights +#define cap_connect_rights _bsd_cap_connect_rights +#define cap_event_rights _bsd_cap_event_rights +#define cap_fcntl_rights _bsd_cap_fcntl_rights +#define cap_fstat_rights _bsd_cap_fstat_rights +#define cap_fsync_rights _bsd_cap_fsync_rights +#define cap_ftruncate_rights _bsd_cap_ftruncate_rights +#define cap_getpeername_rights _bsd_cap_getpeername_rights +#define cap_getsockname_rights _bsd_cap_getsockname_rights +#define cap_getsockopt_rights _bsd_cap_getsockopt_rights +#define cap_ioctl_rights _bsd_cap_ioctl_rights +#define cap_listen_rights _bsd_cap_listen_rights +#define cap_mkdirat_rights _bsd_cap_mkdirat_rights +#define cap_mknodat_rights _bsd_cap_mknodat_rights +#define cap_no_rights _bsd_cap_no_rights +#define cap_read_rights _bsd_cap_read_rights +#define cap_recv_rights _bsd_cap_recv_rights +#define cap_renameat_source_rights _bsd_cap_renameat_source_rights +#define cap_renameat_target_rights _bsd_cap_renameat_target_rights +#define cap_rights_is_valid _bsd_cap_rights_is_valid +#define cap_seek_rights _bsd_cap_seek_rights +#define cap_setsockopt_rights _bsd_cap_setsockopt_rights +#define cap_shutdown_rights _bsd_cap_shutdown_rights +#define cap_symlinkat_rights _bsd_cap_symlinkat_rights +#define cap_write_rights _bsd_cap_write_rights #define carp6_input _bsd_carp6_input #define carp_attach _bsd_carp_attach #define carp_attach_p _bsd_carp_attach_p @@ -879,6 +1008,13 @@ #define chacha_encrypt_bytes _bsd_chacha_encrypt_bytes #define chacha_ivsetup _bsd_chacha_ivsetup #define chacha_keysetup _bsd_chacha_keysetup +#define change_dir _bsd_change_dir +#define change_egid _bsd_change_egid +#define change_euid _bsd_change_euid +#define change_rgid _bsd_change_rgid +#define change_ruid _bsd_change_ruid +#define change_svgid _bsd_change_svgid +#define change_svuid _bsd_change_svuid #define ck_epoch_barrier _bsd_ck_epoch_barrier #define ck_epoch_barrier_wait _bsd_ck_epoch_barrier_wait #define ck_epoch_init _bsd_ck_epoch_init @@ -894,18 +1030,28 @@ #define clean_unrhdrl _bsd_clean_unrhdrl #define clear_unrhdr _bsd_clear_unrhdr #define clk_intr_event _bsd_clk_intr_event +#define closef _bsd_closef #define comp_algo_deflate _bsd_comp_algo_deflate #define comp_algorithm_lookup _bsd_comp_algorithm_lookup #define config_intrhook_disestablish _bsd_config_intrhook_disestablish #define config_intrhook_establish _bsd_config_intrhook_establish #define config_intrhook_oneshot _bsd_config_intrhook_oneshot #define copyiniov _bsd_copyiniov +#define count_dev _bsd_count_dev #define counter_ratecheck _bsd_counter_ratecheck #define counter_u64_alloc _bsd_counter_u64_alloc #define counter_u64_fetch _bsd_counter_u64_fetch #define counter_u64_free _bsd_counter_u64_free #define counter_u64_zero _bsd_counter_u64_zero #define crc32_tab _bsd_crc32_tab +#define crcopy _bsd_crcopy +#define crdup _bsd_crdup +#define crextend _bsd_crextend +#define crfree _bsd_crfree +#define crget _bsd_crget +#define crhold _bsd_crhold +#define crsetgroups _bsd_crsetgroups +#define cru2x _bsd_cru2x #define crypto_apply _bsd_crypto_apply #define crypto_contiguous_subsegment _bsd_crypto_contiguous_subsegment #define crypto_copyback _bsd_crypto_copyback @@ -960,8 +1106,13 @@ #define cv_destroy _bsd_cv_destroy #define cv_init _bsd_cv_init #define cv_signal _bsd_cv_signal +#define dead_poll _bsd_dead_poll +#define dead_read _bsd_dead_read +#define dead_vnodeops _bsd_dead_vnodeops +#define dead_write _bsd_dead_write #define deembed_scopeid _bsd_deembed_scopeid #define default_cc_ptr _bsd_default_cc_ptr +#define default_vnodeops _bsd_default_vnodeops #define deflate_global _bsd_deflate_global #define defrouter_del _bsd_defrouter_del #define defrouter_lookup _bsd_defrouter_lookup @@ -993,6 +1144,7 @@ #define des_set_key_checked _bsd_des_set_key_checked #define des_set_key_unchecked _bsd_des_set_key_unchecked #define des_set_odd_parity _bsd_des_set_odd_parity +#define desiredvnodes _bsd_desiredvnodes #define dest6_input _bsd_dest6_input #define destroy_dev _bsd_destroy_dev #define destroy_dev_sched _bsd_destroy_dev_sched @@ -1028,6 +1180,7 @@ #define devfs_destroy_cdevpriv _bsd_devfs_destroy_cdevpriv #define devfs_fpdrop _bsd_devfs_fpdrop #define devfs_get_cdevpriv _bsd_devfs_get_cdevpriv +#define devfs_iosize_max _bsd_devfs_iosize_max #define devfs_set_cdevpriv _bsd_devfs_set_cdevpriv #define device_add_child _bsd_device_add_child #define device_add_child_ordered _bsd_device_add_child_ordered @@ -1085,12 +1238,16 @@ #define device_verbose _bsd_device_verbose #define devmtx _bsd_devmtx #define devtoname _bsd_devtoname +#define dirent_terminate _bsd_dirent_terminate +#define dirtybufferflushes _bsd_dirtybufferflushes +#define dirtybufthresh _bsd_dirtybufthresh #define div_protosw _bsd_div_protosw #define div_usrreqs _bsd_div_usrreqs #define domain_add _bsd_domain_add #define domain_init _bsd_domain_init #define domain_init_status _bsd_domain_init_status #define domains _bsd_domains +#define dounmount _bsd_dounmount #define drbr_dequeue_drv _bsd_drbr_dequeue_drv #define drbr_enqueue_drv _bsd_drbr_enqueue_drv #define drbr_inuse_drv _bsd_drbr_inuse_drv @@ -1544,6 +1701,9 @@ #define eventhandler_find_list _bsd_eventhandler_find_list #define eventhandler_prune_list _bsd_eventhandler_prune_list #define eventhandler_register _bsd_eventhandler_register +#define extattr_check_cred _bsd_extattr_check_cred +#define falloc_caps _bsd_falloc_caps +#define falloc_noinstall _bsd_falloc_noinstall #define fb_commonioctl _bsd_fb_commonioctl #define fb_dump_adp_info _bsd_fb_dump_adp_info #define fb_dump_mode_info _bsd_fb_dump_mode_info @@ -1554,6 +1714,12 @@ #define fbd_list _bsd_fbd_list #define fbd_register _bsd_fbd_register #define fbd_unregister _bsd_fbd_unregister +#define fdalloc _bsd_fdalloc +#define fdallocn _bsd_fdallocn +#define fdcheckstd _bsd_fdcheckstd +#define fdclose _bsd_fdclose +#define fdinit _bsd_fdinit +#define fdshare _bsd_fdshare #define fdt_addrsize_cells _bsd_fdt_addrsize_cells #define fdt_data_get _bsd_fdt_data_get #define fdt_data_to_res _bsd_fdt_data_to_res @@ -1577,15 +1743,32 @@ #define fdt_pinctrl_configure_tree _bsd_fdt_pinctrl_configure_tree #define fdt_pinctrl_register _bsd_fdt_pinctrl_register #define fdt_regsize _bsd_fdt_regsize +#define fget _bsd_fget +#define fget_cap _bsd_fget_cap +#define fget_cap_locked _bsd_fget_cap_locked +#define fget_fcntl _bsd_fget_fcntl +#define fget_read _bsd_fget_read +#define fget_unlocked _bsd_fget_unlocked +#define fget_write _bsd_fget_write +#define fgetvp _bsd_fgetvp +#define fgetvp_read _bsd_fgetvp_read +#define fgetvp_rights _bsd_fgetvp_rights #define fib4_free_nh_ext _bsd_fib4_free_nh_ext #define fib4_lookup_nh_basic _bsd_fib4_lookup_nh_basic #define fib4_lookup_nh_ext _bsd_fib4_lookup_nh_ext #define fib6_free_nh_ext _bsd_fib6_free_nh_ext #define fib6_lookup_nh_basic _bsd_fib6_lookup_nh_basic #define fib6_lookup_nh_ext _bsd_fib6_lookup_nh_ext +#define filecaps_copy _bsd_filecaps_copy +#define filecaps_free _bsd_filecaps_free +#define filecaps_init _bsd_filecaps_init +#define filecaps_move _bsd_filecaps_move +#define filedesc_to_leader_alloc _bsd_filedesc_to_leader_alloc #define find_and_ref_tcp_fb _bsd_find_and_ref_tcp_fb #define find_and_ref_tcp_functions _bsd_find_and_ref_tcp_functions #define find_handler _bsd_find_handler +#define finit _bsd_finit +#define finstall _bsd_finstall #define firewire_broadcastaddr _bsd_firewire_broadcastaddr #define firewire_busreset _bsd_firewire_busreset #define firewire_ifattach _bsd_firewire_ifattach @@ -1597,6 +1780,10 @@ #define firmware_register _bsd_firmware_register #define firmware_unregister _bsd_firmware_unregister #define first_handler _bsd_first_handler +#define foffset_lock _bsd_foffset_lock +#define foffset_lock_uio _bsd_foffset_lock_uio +#define foffset_unlock _bsd_foffset_unlock +#define foffset_unlock_uio _bsd_foffset_unlock_uio #define frag6_drain _bsd_frag6_drain #define frag6_init _bsd_frag6_init #define frag6_input _bsd_frag6_input @@ -1604,13 +1791,25 @@ #define frag6_set_bucketsize _bsd_frag6_set_bucketsize #define frag6_slowtimo _bsd_frag6_slowtimo #define free_unr _bsd_free_unr +#define fs_filtops _bsd_fs_filtops +#define gbincore _bsd_gbincore #define genkbd_commonioctl _bsd_genkbd_commonioctl #define genkbd_diag _bsd_genkbd_diag #define genkbd_get_fkeystr _bsd_genkbd_get_fkeystr #define genkbd_keyaction _bsd_genkbd_keyaction #define get_keybuf _bsd_get_keybuf #define get_random_bytes _bsd_get_random_bytes +#define getblk _bsd_getblk +#define getblkx _bsd_getblkx #define getcredhostuuid _bsd_getcredhostuuid +#define geteblk _bsd_geteblk +#define getnewvnode _bsd_getnewvnode +#define getnewvnode_drop_reserve _bsd_getnewvnode_drop_reserve +#define getnewvnode_reserve _bsd_getnewvnode_reserve +#define getpbuf _bsd_getpbuf +#define getsock_cap _bsd_getsock_cap +#define getsockaddr _bsd_getsockaddr +#define getvnode _bsd_getvnode #define gf128_genmultable _bsd_gf128_genmultable #define gf128_genmultable4 _bsd_gf128_genmultable4 #define gf128_mul _bsd_gf128_mul @@ -1648,6 +1847,7 @@ #define gre_sofree _bsd_gre_sofree #define gre_update_hdr _bsd_gre_update_hdr #define gre_update_udphdr _bsd_gre_update_udphdr +#define groupmember _bsd_groupmember #define grouptask_block _bsd_grouptask_block #define grouptask_unblock _bsd_grouptask_unblock #define grouptaskqueue_enqueue _bsd_grouptaskqueue_enqueue @@ -1657,6 +1857,7 @@ #define gtaskqueue_drain_all _bsd_gtaskqueue_drain_all #define gtaskqueue_unblock _bsd_gtaskqueue_unblock #define handlers _bsd_handlers +#define hardlink_check_uid _bsd_hardlink_check_uid #define hashdestroy _bsd_hashdestroy #define hashinit _bsd_hashinit #define hashinit_flags _bsd_hashinit_flags @@ -1675,6 +1876,7 @@ #define hhook_remove_hook_lookup _bsd_hhook_remove_hook_lookup #define hhook_run_hooks _bsd_hhook_run_hooks #define hhook_vhead_list _bsd_hhook_vhead_list +#define hibufspace _bsd_hibufspace #define hid_end_parse _bsd_hid_end_parse #define hid_get_data _bsd_hid_get_data #define hid_get_data_unsigned _bsd_hid_get_data_unsigned @@ -2357,6 +2559,7 @@ #define ifq_delete _bsd_ifq_delete #define ifq_init _bsd_ifq_init #define ifr_data_get_ptr _bsd_ifr_data_get_ptr +#define iftovt_tab _bsd_iftovt_tab #define ifunit _bsd_ifunit #define ifunit_ref _bsd_ifunit_ref #define igb_sctx _bsd_igb_sctx @@ -2605,6 +2808,7 @@ #define in_rtredirect _bsd_in_rtredirect #define in_scrubprefix _bsd_in_scrubprefix #define in_sockaddr _bsd_in_sockaddr +#define incore _bsd_incore #define inet6_pfil_head _bsd_inet6_pfil_head #define inet6_pfil_hook _bsd_inet6_pfil_hook #define inet6ctlerrmap _bsd_inet6ctlerrmap @@ -2620,6 +2824,7 @@ #define init_sin6 _bsd_init_sin6 #define init_sleepqueues _bsd_init_sleepqueues #define init_unrhdr _bsd_init_unrhdr +#define init_va_filerev _bsd_init_va_filerev #define inm_clear_recorded _bsd_inm_clear_recorded #define inm_commit _bsd_inm_commit #define inm_disconnect _bsd_inm_disconnect @@ -2637,15 +2842,28 @@ #define inp_inpcbtotcpcb _bsd_inp_inpcbtotcpcb #define inp_ip_tos_get _bsd_inp_ip_tos_get #define inp_ip_tos_set _bsd_inp_ip_tos_set +#define inp_lock_assert _bsd_inp_lock_assert #define inp_rlock _bsd_inp_rlock #define inp_runlock _bsd_inp_runlock #define inp_setmoptions _bsd_inp_setmoptions #define inp_so_options _bsd_inp_so_options #define inp_to_cpuid _bsd_inp_to_cpuid +#define inp_unlock_assert _bsd_inp_unlock_assert #define inp_wlock _bsd_inp_wlock #define inp_wunlock _bsd_inp_wunlock +#define insmntque _bsd_insmntque +#define insmntque1 _bsd_insmntque1 #define intr_event_add_handler _bsd_intr_event_add_handler #define intr_event_create _bsd_intr_event_create +#define invfo_chmod _bsd_invfo_chmod +#define invfo_chown _bsd_invfo_chown +#define invfo_ioctl _bsd_invfo_ioctl +#define invfo_kqfilter _bsd_invfo_kqfilter +#define invfo_poll _bsd_invfo_poll +#define invfo_rdwr _bsd_invfo_rdwr +#define invfo_sendfile _bsd_invfo_sendfile +#define invfo_truncate _bsd_invfo_truncate +#define iosize_max _bsd_iosize_max #define ip4_ah_net_deflev _bsd_ip4_ah_net_deflev #define ip4_ah_trans_deflev _bsd_ip4_ah_trans_deflev #define ip4_esp_net_deflev _bsd_ip4_esp_net_deflev @@ -2906,7 +3124,62 @@ #define kdebug_secpolicyindex _bsd_kdebug_secpolicyindex #define kdebug_secpolicyindex_dir _bsd_kdebug_secpolicyindex_dir #define kdebug_sockaddr _bsd_kdebug_sockaddr +#define kern___getcwd _bsd_kern___getcwd +#define kern_accept _bsd_kern_accept +#define kern_accept4 _bsd_kern_accept4 +#define kern_alternate_path _bsd_kern_alternate_path +#define kern_bindat _bsd_kern_bindat +#define kern_chdir _bsd_kern_chdir +#define kern_close _bsd_kern_close +#define kern_connectat _bsd_kern_connectat +#define kern_fchmodat _bsd_kern_fchmodat +#define kern_fchownat _bsd_kern_fchownat +#define kern_fcntl _bsd_kern_fcntl +#define kern_fstat _bsd_kern_fstat +#define kern_fstatfs _bsd_kern_fstatfs +#define kern_fsync _bsd_kern_fsync +#define kern_ftruncate _bsd_kern_ftruncate +#define kern_getdirentries _bsd_kern_getdirentries +#define kern_getfsstat _bsd_kern_getfsstat +#define kern_getpeername _bsd_kern_getpeername +#define kern_getsockname _bsd_kern_getsockname +#define kern_getsockopt _bsd_kern_getsockopt +#define kern_ioctl _bsd_kern_ioctl +#define kern_kevent _bsd_kern_kevent +#define kern_kevent_fp _bsd_kern_kevent_fp +#define kern_kqueue _bsd_kern_kqueue +#define kern_linkat _bsd_kern_linkat +#define kern_listen _bsd_kern_listen +#define kern_lseek _bsd_kern_lseek +#define kern_mkdirat _bsd_kern_mkdirat +#define kern_mknodat _bsd_kern_mknodat +#define kern_openat _bsd_kern_openat +#define kern_pipe _bsd_kern_pipe +#define kern_poll _bsd_kern_poll +#define kern_posix_fallocate _bsd_kern_posix_fallocate +#define kern_pselect _bsd_kern_pselect +#define kern_readlinkat _bsd_kern_readlinkat +#define kern_readv _bsd_kern_readv +#define kern_recvit _bsd_kern_recvit +#define kern_renameat _bsd_kern_renameat +#define kern_rmdirat _bsd_kern_rmdirat +#define kern_select _bsd_kern_select +#define kern_sendit _bsd_kern_sendit +#define kern_setsockopt _bsd_kern_setsockopt +#define kern_shutdown _bsd_kern_shutdown +#define kern_socket _bsd_kern_socket +#define kern_socketpair _bsd_kern_socketpair +#define kern_statat _bsd_kern_statat +#define kern_statfs _bsd_kern_statfs +#define kern_symlinkat _bsd_kern_symlinkat +#define kern_truncate _bsd_kern_truncate +#define kern_unlinkat _bsd_kern_unlinkat +#define kern_vfs_bio_buffer_alloc _bsd_kern_vfs_bio_buffer_alloc +#define kern_writev _bsd_kern_writev +#define kernel_arena _bsd_kernel_arena +#define kernel_mount _bsd_kernel_mount #define kernel_sysctl _bsd_kernel_sysctl +#define kernel_vmount _bsd_kernel_vmount #define key_addref _bsd_key_addref #define key_allocsa _bsd_key_allocsa #define key_allocsa_policy _bsd_key_allocsa_policy @@ -2988,6 +3261,17 @@ #define kthread_add _bsd_kthread_add #define kthread_exit _bsd_kthread_exit #define kthread_start _bsd_kthread_start +#define ktr_buf _bsd_ktr_buf +#define ktr_buf_init _bsd_ktr_buf_init +#define ktr_compile _bsd_ktr_compile +#define ktr_cpumask _bsd_ktr_cpumask +#define ktr_entries _bsd_ktr_entries +#define ktr_idx _bsd_ktr_idx +#define ktr_mask _bsd_ktr_mask +#define ktr_tracepoint _bsd_ktr_tracepoint +#define ktr_verbose _bsd_ktr_verbose +#define ktr_version _bsd_ktr_version +#define kva_alloc _bsd_kva_alloc #define kvprintf _bsd_kvprintf #define lacp_attach _bsd_lacp_attach #define lacp_detach _bsd_lacp_detach @@ -3050,6 +3334,7 @@ #define lltable_try_set_entry_addr _bsd_lltable_try_set_entry_addr #define lltable_unlink_entry _bsd_lltable_unlink_entry #define lltable_update_ifaddr _bsd_lltable_update_ifaddr +#define lock_class_lockmgr _bsd_lock_class_lockmgr #define lock_class_mtx_sleep _bsd_lock_class_mtx_sleep #define lock_class_mtx_spin _bsd_lock_class_mtx_spin #define lock_class_rw _bsd_lock_class_rw @@ -3057,9 +3342,20 @@ #define lock_classes _bsd_lock_classes #define lock_destroy _bsd_lock_destroy #define lock_init _bsd_lock_init +#define lockallowrecurse _bsd_lockallowrecurse +#define lockallowshare _bsd_lockallowshare +#define lockdestroy _bsd_lockdestroy +#define lockdisablerecurse _bsd_lockdisablerecurse +#define lockdisableshare _bsd_lockdisableshare +#define lockinit _bsd_lockinit +#define lockmgr_lock_fast_path _bsd_lockmgr_lock_fast_path +#define lockmgr_printinfo _bsd_lockmgr_printinfo +#define lockmgr_unlock_fast_path _bsd_lockmgr_unlock_fast_path +#define lockstatus _bsd_lockstatus #define log _bsd_log #define loif _bsd_loif #define loioctl _bsd_loioctl +#define lookup _bsd_lookup #define looutput _bsd_looutput #define lpc_pwr_read _bsd_lpc_pwr_read #define lpc_pwr_write _bsd_lpc_pwr_write @@ -3131,7 +3427,13 @@ #define malloc_init _bsd_malloc_init #define malloc_uninit _bsd_malloc_uninit #define mallocarray _bsd_mallocarray +#define maxbcache _bsd_maxbcache +#define maxbcachebuf _bsd_maxbcachebuf +#define maxfiles _bsd_maxfiles +#define maxfilesperproc _bsd_maxfilesperproc #define maxpipekva _bsd_maxpipekva +#define maxproc _bsd_maxproc +#define maxvfsconf _bsd_maxvfsconf #define mb_dupcl _bsd_mb_dupcl #define mb_free_ext _bsd_mb_free_ext #define mb_free_notready _bsd_mb_free_notready @@ -3190,6 +3492,14 @@ #define module_register_init _bsd_module_register_init #define module_release _bsd_module_release #define modules_sx _bsd_modules_sx +#define mount_arg _bsd_mount_arg +#define mount_argb _bsd_mount_argb +#define mount_argf _bsd_mount_argf +#define mount_argsu _bsd_mount_argsu +#define mountcheckdirs _bsd_mountcheckdirs +#define mountlist _bsd_mountlist +#define mountlist_mtx _bsd_mountlist_mtx +#define mq_fdclose _bsd_mq_fdclose #define mrt6_ioctl _bsd_mrt6_ioctl #define mrt_ioctl _bsd_mrt_ioctl #define mtrash_ctor _bsd_mtrash_ctor @@ -3215,7 +3525,15 @@ #define musbotg_uninit _bsd_musbotg_uninit #define musbotg_vbus_interrupt _bsd_musbotg_vbus_interrupt #define mutex_init _bsd_mutex_init +#define mutexlist _bsd_mutexlist +#define mutexlist_lock _bsd_mutexlist_lock +#define namei _bsd_namei +#define namei_zone _bsd_namei_zone #define natt_cksum_policy _bsd_natt_cksum_policy +#define nbuf _bsd_nbuf +#define nchstats _bsd_nchstats +#define ncl_pbuf_zone _bsd_ncl_pbuf_zone +#define ncsizefactor _bsd_ncsizefactor #define nd6_add_ifa_lle _bsd_nd6_add_ifa_lle #define nd6_alloc _bsd_nd6_alloc #define nd6_cache_lladdr _bsd_nd6_cache_lladdr @@ -3284,6 +3602,7 @@ #define new_unrhdr _bsd_new_unrhdr #define newpacket _bsd_newpacket #define newreno_cc_algo _bsd_newreno_cc_algo +#define nfs_pub _bsd_nfs_pub #define ng_ether_attach_p _bsd_ng_ether_attach_p #define ng_ether_detach_p _bsd_ng_ether_detach_p #define ng_ether_input_orphan_p _bsd_ng_ether_input_orphan_p @@ -3295,7 +3614,10 @@ #define ng_gif_input_orphan_p _bsd_ng_gif_input_orphan_p #define ng_gif_input_p _bsd_ng_gif_input_p #define ng_ipfw_input_p _bsd_ng_ipfw_input_p +#define ngroups_max _bsd_ngroups_max +#define nlminfo_release_p _bsd_nlminfo_release_p #define nousrreqs _bsd_nousrreqs +#define nswbuf _bsd_nswbuf #define null_class _bsd_null_class #define null_filtops _bsd_null_filtops #define nullop _bsd_nullop @@ -3432,6 +3754,7 @@ #define ohci_init _bsd_ohci_init #define ohci_interrupt _bsd_ohci_interrupt #define ohci_iterate_hw_softc _bsd_ohci_iterate_hw_softc +#define openfiles _bsd_openfiles #define osd_call _bsd_osd_call #define osd_del _bsd_osd_del #define osd_deregister _bsd_osd_deregister @@ -3446,6 +3769,8 @@ #define panic _bsd_panic #define parse_uuid _bsd_parse_uuid #define pause_sbt _bsd_pause_sbt +#define pbuf_zone _bsd_pbuf_zone +#define pbuf_zsecond_create _bsd_pbuf_zsecond_create #define pci_activate_resource _bsd_pci_activate_resource #define pci_add_bar _bsd_pci_add_bar #define pci_add_child _bsd_pci_add_child @@ -3578,6 +3903,14 @@ #define pcpu_zone_64 _bsd_pcpu_zone_64 #define pcpu_zone_int _bsd_pcpu_zone_int #define pcpu_zone_ptr _bsd_pcpu_zone_ptr +#define pctrie_insert _bsd_pctrie_insert +#define pctrie_lookup _bsd_pctrie_lookup +#define pctrie_lookup_ge _bsd_pctrie_lookup_ge +#define pctrie_lookup_le _bsd_pctrie_lookup_le +#define pctrie_node_size _bsd_pctrie_node_size +#define pctrie_reclaim_allnodes _bsd_pctrie_reclaim_allnodes +#define pctrie_remove _bsd_pctrie_remove +#define pctrie_zone_init _bsd_pctrie_zone_init #define pf_addr_cmp _bsd_pf_addr_cmp #define pf_addr_inc _bsd_pf_addr_inc #define pf_addrcpy _bsd_pf_addrcpy @@ -3813,6 +4146,28 @@ #define pfr_table_count _bsd_pfr_table_count #define pfr_tst_addrs _bsd_pfr_tst_addrs #define pfr_update_stats _bsd_pfr_update_stats +#define pfs_cmount _bsd_pfs_cmount +#define pfs_create_dir _bsd_pfs_create_dir +#define pfs_create_file _bsd_pfs_create_file +#define pfs_create_link _bsd_pfs_create_link +#define pfs_destroy _bsd_pfs_destroy +#define pfs_fileno_alloc _bsd_pfs_fileno_alloc +#define pfs_fileno_free _bsd_pfs_fileno_free +#define pfs_fileno_init _bsd_pfs_fileno_init +#define pfs_fileno_uninit _bsd_pfs_fileno_uninit +#define pfs_find_node _bsd_pfs_find_node +#define pfs_init _bsd_pfs_init +#define pfs_mount _bsd_pfs_mount +#define pfs_purge _bsd_pfs_purge +#define pfs_root _bsd_pfs_root +#define pfs_statfs _bsd_pfs_statfs +#define pfs_uninit _bsd_pfs_uninit +#define pfs_unmount _bsd_pfs_unmount +#define pfs_vncache_alloc _bsd_pfs_vncache_alloc +#define pfs_vncache_free _bsd_pfs_vncache_free +#define pfs_vncache_load _bsd_pfs_vncache_load +#define pfs_vncache_unload _bsd_pfs_vncache_unload +#define pfs_vnodeops _bsd_pfs_vnodeops #define pfsync_clear_states_ptr _bsd_pfsync_clear_states_ptr #define pfsync_cloner _bsd_pfsync_cloner #define pfsync_defer_ptr _bsd_pfsync_defer_ptr @@ -3829,14 +4184,20 @@ #define pick_mode_by_ref _bsd_pick_mode_by_ref #define pipe_dtor _bsd_pipe_dtor #define pipe_named_ctor _bsd_pipe_named_ctor +#define pipeops _bsd_pipeops #define pipeselwakeup _bsd_pipeselwakeup #define pmtu_expire _bsd_pmtu_expire #define pmtu_probe _bsd_pmtu_probe #define poll_no_poll _bsd_poll_no_poll #define ppsratecheck _bsd_ppsratecheck +#define print_devclass_list _bsd_print_devclass_list +#define print_devclass_list_short _bsd_print_devclass_list_short +#define print_device_tree _bsd_print_device_tree +#define print_device_tree_short _bsd_print_device_tree_short #define printf _bsd_printf #define printf_uuid _bsd_printf_uuid #define prison0 _bsd_prison0 +#define proc0 _bsd_proc0 #define pru_accept_notsupp _bsd_pru_accept_notsupp #define pru_aio_queue_notsupp _bsd_pru_aio_queue_notsupp #define pru_attach_notsupp _bsd_pru_attach_notsupp @@ -3859,6 +4220,8 @@ #define pru_sopoll_notsupp _bsd_pru_sopoll_notsupp #define pru_soreceive_notsupp _bsd_pru_soreceive_notsupp #define pru_sosend_notsupp _bsd_pru_sosend_notsupp +#define pwd_chdir _bsd_pwd_chdir +#define pwd_ensure_dirs _bsd_pwd_ensure_dirs #define qgroup_config _bsd_qgroup_config #define qgroup_if_config_tqg _bsd_qgroup_if_config_tqg #define qgroup_if_io_tqg _bsd_qgroup_if_io_tqg @@ -4088,6 +4451,7 @@ #define rc4_init _bsd_rc4_init #define read_dsfield _bsd_read_dsfield #define read_machclk _bsd_read_machclk +#define reassignbuf _bsd_reassignbuf #define refcount_release_last _bsd_refcount_release_last #define refcount_sleep _bsd_refcount_sleep #define register_tcp_functions _bsd_register_tcp_functions @@ -4130,6 +4494,8 @@ #define regulator_set_voltage _bsd_regulator_set_voltage #define regulator_status _bsd_regulator_status #define regulator_stop _bsd_regulator_stop +#define relookup _bsd_relookup +#define relpbuf _bsd_relpbuf #define resource_disabled _bsd_resource_disabled #define resource_find_match _bsd_resource_find_match #define resource_int_value _bsd_resource_int_value @@ -4348,6 +4714,8 @@ #define rtwn_usb_write_4 _bsd_rtwn_usb_write_4 #define rtwn_usb_write_region_1 _bsd_rtwn_usb_write_region_1 #define run_debug _bsd_run_debug +#define runningbufspace _bsd_runningbufspace +#define runningbufwakeup _bsd_runningbufwakeup #define rw_destroy _bsd_rw_destroy #define rw_init_flags _bsd_rw_init_flags #define rw_sysinit _bsd_rw_sysinit @@ -4833,10 +5201,13 @@ #define selwakeuppri _bsd_selwakeuppri #define send_forward_tsn _bsd_send_forward_tsn #define send_sendso_input_hook _bsd_send_sendso_input_hook +#define setfmode _bsd_setfmode +#define setfown _bsd_setfown #define sha1_init _bsd_sha1_init #define sha1_loop _bsd_sha1_loop #define sha1_pad _bsd_sha1_pad #define sha1_result _bsd_sha1_result +#define sigio_lock _bsd_sigio_lock #define simplebus_add_device _bsd_simplebus_add_device #define simplebus_driver _bsd_simplebus_driver #define simplebus_fill_ranges _bsd_simplebus_fill_ranges @@ -4929,6 +5300,7 @@ #define sonewconn _bsd_sonewconn #define soo_close _bsd_soo_close #define soo_ioctl _bsd_soo_ioctl +#define soo_kqfilter _bsd_soo_kqfilter #define soo_poll _bsd_soo_poll #define soo_read _bsd_soo_read #define soo_write _bsd_soo_write @@ -4954,6 +5326,7 @@ #define soupcall_clear _bsd_soupcall_clear #define soupcall_set _bsd_soupcall_set #define sowakeup _bsd_sowakeup +#define speedup_syncer _bsd_speedup_syncer #define sppp_attach _bsd_sppp_attach #define sppp_dequeue _bsd_sppp_dequeue #define sppp_detach _bsd_sppp_detach @@ -4967,6 +5340,7 @@ #define sppp_isempty _bsd_sppp_isempty #define sppp_pick _bsd_sppp_pick #define sprintf _bsd_sprintf +#define statfs_scale_blocks _bsd_statfs_scale_blocks #define subkey_table_gen _bsd_subkey_table_gen #define swi_add _bsd_swi_add #define swi_sched _bsd_swi_sched @@ -4974,7 +5348,9 @@ #define sx_downgrade_int _bsd_sx_downgrade_int #define sx_init_flags _bsd_sx_init_flags #define sx_sysinit _bsd_sx_sysinit +#define sx_try_downgrade_ _bsd_sx_try_downgrade_ #define sx_try_slock_int _bsd_sx_try_slock_int +#define sx_try_upgrade_ _bsd_sx_try_upgrade_ #define sx_try_upgrade_int _bsd_sx_try_upgrade_int #define sx_xlocked _bsd_sx_xlocked #define syncache_add _bsd_syncache_add @@ -4984,6 +5360,104 @@ #define syncache_init _bsd_syncache_init #define syncache_pcblist _bsd_syncache_pcblist #define syncache_unreach _bsd_syncache_unreach +#define syncer_resume _bsd_syncer_resume +#define syncer_suspend _bsd_syncer_suspend +#define sys___acl_aclcheck_fd _bsd_sys___acl_aclcheck_fd +#define sys___acl_aclcheck_file _bsd_sys___acl_aclcheck_file +#define sys___acl_aclcheck_link _bsd_sys___acl_aclcheck_link +#define sys___acl_delete_fd _bsd_sys___acl_delete_fd +#define sys___acl_delete_file _bsd_sys___acl_delete_file +#define sys___acl_delete_link _bsd_sys___acl_delete_link +#define sys___acl_get_fd _bsd_sys___acl_get_fd +#define sys___acl_get_file _bsd_sys___acl_get_file +#define sys___acl_get_link _bsd_sys___acl_get_link +#define sys___acl_set_fd _bsd_sys___acl_set_fd +#define sys___acl_set_file _bsd_sys___acl_set_file +#define sys___acl_set_link _bsd_sys___acl_set_link +#define sys___getcwd _bsd_sys___getcwd +#define sys_accept _bsd_sys_accept +#define sys_accept4 _bsd_sys_accept4 +#define sys_access _bsd_sys_access +#define sys_aio_cancel _bsd_sys_aio_cancel +#define sys_aio_error _bsd_sys_aio_error +#define sys_aio_fsync _bsd_sys_aio_fsync +#define sys_aio_mlock _bsd_sys_aio_mlock +#define sys_aio_read _bsd_sys_aio_read +#define sys_aio_return _bsd_sys_aio_return +#define sys_aio_suspend _bsd_sys_aio_suspend +#define sys_aio_waitcomplete _bsd_sys_aio_waitcomplete +#define sys_aio_write _bsd_sys_aio_write +#define sys_bind _bsd_sys_bind +#define sys_chdir _bsd_sys_chdir +#define sys_chflags _bsd_sys_chflags +#define sys_chmod _bsd_sys_chmod +#define sys_chown _bsd_sys_chown +#define sys_close _bsd_sys_close +#define sys_connect _bsd_sys_connect +#define sys_fchdir _bsd_sys_fchdir +#define sys_fchmod _bsd_sys_fchmod +#define sys_fchmodat _bsd_sys_fchmodat +#define sys_fchown _bsd_sys_fchown +#define sys_fchownat _bsd_sys_fchownat +#define sys_fdatasync _bsd_sys_fdatasync +#define sys_fstat _bsd_sys_fstat +#define sys_fstatat _bsd_sys_fstatat +#define sys_fstatfs _bsd_sys_fstatfs +#define sys_fsync _bsd_sys_fsync +#define sys_ftruncate _bsd_sys_ftruncate +#define sys_getdirentries _bsd_sys_getdirentries +#define sys_getdtablesize _bsd_sys_getdtablesize +#define sys_getfsstat _bsd_sys_getfsstat +#define sys_getpeername _bsd_sys_getpeername +#define sys_getsockname _bsd_sys_getsockname +#define sys_getsockopt _bsd_sys_getsockopt +#define sys_ioctl _bsd_sys_ioctl +#define sys_kevent _bsd_sys_kevent +#define sys_kqueue _bsd_sys_kqueue +#define sys_lchmod _bsd_sys_lchmod +#define sys_lchown _bsd_sys_lchown +#define sys_link _bsd_sys_link +#define sys_linkat _bsd_sys_linkat +#define sys_lio_listio _bsd_sys_lio_listio +#define sys_listen _bsd_sys_listen +#define sys_lseek _bsd_sys_lseek +#define sys_mkdir _bsd_sys_mkdir +#define sys_mkdirat _bsd_sys_mkdirat +#define sys_mknodat _bsd_sys_mknodat +#define sys_mount _bsd_sys_mount +#define sys_nmount _bsd_sys_nmount +#define sys_open _bsd_sys_open +#define sys_openat _bsd_sys_openat +#define sys_pipe2 _bsd_sys_pipe2 +#define sys_poll _bsd_sys_poll +#define sys_pselect _bsd_sys_pselect +#define sys_read _bsd_sys_read +#define sys_readlink _bsd_sys_readlink +#define sys_readlinkat _bsd_sys_readlinkat +#define sys_readv _bsd_sys_readv +#define sys_recvfrom _bsd_sys_recvfrom +#define sys_recvmsg _bsd_sys_recvmsg +#define sys_rename _bsd_sys_rename +#define sys_renameat _bsd_sys_renameat +#define sys_rmdir _bsd_sys_rmdir +#define sys_select _bsd_sys_select +#define sys_sendmsg _bsd_sys_sendmsg +#define sys_sendto _bsd_sys_sendto +#define sys_setfib _bsd_sys_setfib +#define sys_setsockopt _bsd_sys_setsockopt +#define sys_shutdown _bsd_sys_shutdown +#define sys_socket _bsd_sys_socket +#define sys_socketpair _bsd_sys_socketpair +#define sys_statfs _bsd_sys_statfs +#define sys_symlink _bsd_sys_symlink +#define sys_symlinkat _bsd_sys_symlinkat +#define sys_sync _bsd_sys_sync +#define sys_truncate _bsd_sys_truncate +#define sys_unlink _bsd_sys_unlink +#define sys_unlinkat _bsd_sys_unlinkat +#define sys_unmount _bsd_sys_unmount +#define sys_write _bsd_sys_write +#define sys_writev _bsd_sys_writev #define sysctl___debug _bsd_sysctl___debug #define sysctl___dev _bsd_sysctl___dev #define sysctl___hw _bsd_sysctl___hw @@ -5045,6 +5519,8 @@ #define sysctl___net_wlan _bsd_sysctl___net_wlan #define sysctl___security _bsd_sysctl___security #define sysctl___sysctl _bsd_sysctl___sysctl +#define sysctl___vfs _bsd_sysctl___vfs +#define sysctl___vfs_pfs _bsd_sysctl___vfs_pfs #define sysctl___vm _bsd_sysctl___vm #define sysctl__children _bsd_sysctl__children #define sysctl_add_oid _bsd_sysctl_add_oid @@ -5302,6 +5778,7 @@ #define timeout _bsd_timeout #define timevaladd _bsd_timevaladd #define timevalsub _bsd_timevalsub +#define tprintf _bsd_tprintf #define trash_ctor _bsd_trash_ctor #define trash_dtor _bsd_trash_dtor #define trash_fini _bsd_trash_fini @@ -5446,7 +5923,12 @@ #define uhub_query_info _bsd_uhub_query_info #define uhub_root_intr _bsd_uhub_root_intr #define uhub_tt_buffer_reset_async_locked _bsd_uhub_tt_buffer_reset_async_locked +#define uifind _bsd_uifind +#define uifree _bsd_uifree +#define uihashinit _bsd_uihashinit +#define uihold _bsd_uihold #define uiomove _bsd_uiomove +#define uiomove_frombuf _bsd_uiomove_frombuf #define uiomove_nofault _bsd_uiomove_nofault #define ukphy_status _bsd_ukphy_status #define ulitecb _bsd_ulitecb @@ -5454,6 +5936,7 @@ #define uma_align_cache _bsd_uma_align_cache #define uma_avail _bsd_uma_avail #define uma_limit _bsd_uma_limit +#define uma_prealloc _bsd_uma_prealloc #define uma_print_stats _bsd_uma_print_stats #define uma_print_zone _bsd_uma_print_zone #define uma_reclaim _bsd_uma_reclaim @@ -5490,6 +5973,9 @@ #define uma_zone_set_zinit _bsd_uma_zone_set_zinit #define uma_zsecond_create _bsd_uma_zsecond_create #define uma_zwait _bsd_uma_zwait +#define unmapped_base _bsd_unmapped_base +#define unmapped_buf _bsd_unmapped_buf +#define unmapped_buf_allowed _bsd_unmapped_buf_allowed #define unp_copy_peercred _bsd_unp_copy_peercred #define untimeout _bsd_untimeout #define usb_alloc_device _bsd_usb_alloc_device @@ -5772,8 +6258,98 @@ #define uuid_ether_add _bsd_uuid_ether_add #define uuid_ether_del _bsd_uuid_ether_del #define uuidcmp _bsd_uuidcmp +#define v_addpollinfo _bsd_v_addpollinfo +#define v_inval_buf_range _bsd_v_inval_buf_range +#define va_null _bsd_va_null +#define vaccess _bsd_vaccess +#define vattr_null _bsd_vattr_null +#define vcount _bsd_vcount +#define verbose_sysinit _bsd_verbose_sysinit #define vesagtf_mode _bsd_vesagtf_mode #define vesagtf_mode_params _bsd_vesagtf_mode_params +#define vflush _bsd_vflush +#define vfs_allocate_syncvnode _bsd_vfs_allocate_syncvnode +#define vfs_bio_awrite _bsd_vfs_bio_awrite +#define vfs_bio_brelse _bsd_vfs_bio_brelse +#define vfs_bio_bzero_buf _bsd_vfs_bio_bzero_buf +#define vfs_bio_clrbuf _bsd_vfs_bio_clrbuf +#define vfs_bio_getpages _bsd_vfs_bio_getpages +#define vfs_bio_set_flags _bsd_vfs_bio_set_flags +#define vfs_bio_set_valid _bsd_vfs_bio_set_valid +#define vfs_buildopts _bsd_vfs_buildopts +#define vfs_busy _bsd_vfs_busy +#define vfs_busy_pages _bsd_vfs_busy_pages +#define vfs_busyfs _bsd_vfs_busyfs +#define vfs_byname _bsd_vfs_byname +#define vfs_byname_kld _bsd_vfs_byname_kld +#define vfs_cache_lookup _bsd_vfs_cache_lookup +#define vfs_copyopt _bsd_vfs_copyopt +#define vfs_deallocate_syncvnode _bsd_vfs_deallocate_syncvnode +#define vfs_deleteopt _bsd_vfs_deleteopt +#define vfs_donmount _bsd_vfs_donmount +#define vfs_drain_busy_pages _bsd_vfs_drain_busy_pages +#define vfs_event_signal _bsd_vfs_event_signal +#define vfs_export _bsd_vfs_export +#define vfs_filteropt _bsd_vfs_filteropt +#define vfs_flagopt _bsd_vfs_flagopt +#define vfs_freeopts _bsd_vfs_freeopts +#define vfs_getnewfsid _bsd_vfs_getnewfsid +#define vfs_getopt _bsd_vfs_getopt +#define vfs_getopt_pos _bsd_vfs_getopt_pos +#define vfs_getopt_size _bsd_vfs_getopt_size +#define vfs_getopts _bsd_vfs_getopts +#define vfs_getvfs _bsd_vfs_getvfs +#define vfs_hash_changesize _bsd_vfs_hash_changesize +#define vfs_hash_get _bsd_vfs_hash_get +#define vfs_hash_index _bsd_vfs_hash_index +#define vfs_hash_insert _bsd_vfs_hash_insert +#define vfs_hash_ref _bsd_vfs_hash_ref +#define vfs_hash_rehash _bsd_vfs_hash_rehash +#define vfs_hash_remove _bsd_vfs_hash_remove +#define vfs_kqfilter _bsd_vfs_kqfilter +#define vfs_mark_atime _bsd_vfs_mark_atime +#define vfs_modevent _bsd_vfs_modevent +#define vfs_mount_alloc _bsd_vfs_mount_alloc +#define vfs_mount_destroy _bsd_vfs_mount_destroy +#define vfs_mount_error _bsd_vfs_mount_error +#define vfs_mountedfrom _bsd_vfs_mountedfrom +#define vfs_msync _bsd_vfs_msync +#define vfs_notify_upper _bsd_vfs_notify_upper +#define vfs_oexport_conv _bsd_vfs_oexport_conv +#define vfs_opterror _bsd_vfs_opterror +#define vfs_read_dirent _bsd_vfs_read_dirent +#define vfs_ref _bsd_vfs_ref +#define vfs_rel _bsd_vfs_rel +#define vfs_scanopt _bsd_vfs_scanopt +#define vfs_setopt _bsd_vfs_setopt +#define vfs_setopt_part _bsd_vfs_setopt_part +#define vfs_setopts _bsd_vfs_setopts +#define vfs_setpublicfs _bsd_vfs_setpublicfs +#define vfs_stdcheckexp _bsd_vfs_stdcheckexp +#define vfs_stdextattrctl _bsd_vfs_stdextattrctl +#define vfs_stdfhtovp _bsd_vfs_stdfhtovp +#define vfs_stdinit _bsd_vfs_stdinit +#define vfs_stdnosync _bsd_vfs_stdnosync +#define vfs_stdquotactl _bsd_vfs_stdquotactl +#define vfs_stdroot _bsd_vfs_stdroot +#define vfs_stdstatfs _bsd_vfs_stdstatfs +#define vfs_stdsync _bsd_vfs_stdsync +#define vfs_stdsysctl _bsd_vfs_stdsysctl +#define vfs_stduninit _bsd_vfs_stduninit +#define vfs_stdvget _bsd_vfs_stdvget +#define vfs_suser _bsd_vfs_suser +#define vfs_timestamp _bsd_vfs_timestamp +#define vfs_unbusy _bsd_vfs_unbusy +#define vfs_unbusy_pages _bsd_vfs_unbusy_pages +#define vfs_unixify_accmode _bsd_vfs_unixify_accmode +#define vfs_unmountall _bsd_vfs_unmountall +#define vfs_write_resume _bsd_vfs_write_resume +#define vfs_write_suspend _bsd_vfs_write_suspend +#define vfs_write_suspend_umnt _bsd_vfs_write_suspend_umnt +#define vfsconf _bsd_vfsconf +#define vfsconf_sx _bsd_vfsconf_sx +#define vget _bsd_vget +#define vgone _bsd_vgone #define vht80_chan_ranges _bsd_vht80_chan_ranges #define vid_allocate _bsd_vid_allocate #define vid_configure _bsd_vid_configure @@ -5787,6 +6363,8 @@ #define videomode_count _bsd_videomode_count #define videomode_list _bsd_videomode_list #define vidsw _bsd_vidsw +#define vinactive _bsd_vinactive +#define vinvalbuf _bsd_vinvalbuf #define vlan_cookie_p _bsd_vlan_cookie_p #define vlan_devat_p _bsd_vlan_devat_p #define vlan_input_p _bsd_vlan_input_p @@ -5798,11 +6376,125 @@ #define vlan_trunk_cap_p _bsd_vlan_trunk_cap_p #define vlan_trunkdev_p _bsd_vlan_trunkdev_p #define vlog _bsd_vlog +#define vm_cnt _bsd_vm_cnt +#define vm_pager_bufferinit _bsd_vm_pager_bufferinit +#define vmapbuf _bsd_vmapbuf +#define vmem_alloc _bsd_vmem_alloc +#define vmem_free _bsd_vmem_free +#define vmiodirenable _bsd_vmiodirenable +#define vn_bmap_seekhole _bsd_vn_bmap_seekhole +#define vn_chmod _bsd_vn_chmod +#define vn_chown _bsd_vn_chown +#define vn_close _bsd_vn_close +#define vn_commname _bsd_vn_commname +#define vn_dir_check_exec _bsd_vn_dir_check_exec +#define vn_dir_dd_ino _bsd_vn_dir_dd_ino +#define vn_extattr_get _bsd_vn_extattr_get +#define vn_extattr_rm _bsd_vn_extattr_rm +#define vn_extattr_set _bsd_vn_extattr_set +#define vn_fill_kinfo _bsd_vn_fill_kinfo +#define vn_fill_kinfo_vnode _bsd_vn_fill_kinfo_vnode +#define vn_finished_secondary_write _bsd_vn_finished_secondary_write +#define vn_finished_write _bsd_vn_finished_write +#define vn_fsid _bsd_vn_fsid +#define vn_fsync_buf _bsd_vn_fsync_buf +#define vn_fullpath _bsd_vn_fullpath +#define vn_fullpath_global _bsd_vn_fullpath_global +#define vn_io_fault_pgmove _bsd_vn_io_fault_pgmove +#define vn_io_fault_uiomove _bsd_vn_io_fault_uiomove +#define vn_isdisk _bsd_vn_isdisk +#define vn_open _bsd_vn_open +#define vn_open_cred _bsd_vn_open_cred +#define vn_open_vnode _bsd_vn_open_vnode +#define vn_pages_remove _bsd_vn_pages_remove +#define vn_path_to_global_path _bsd_vn_path_to_global_path +#define vn_pollrecord _bsd_vn_pollrecord +#define vn_printf _bsd_vn_printf +#define vn_rdwr _bsd_vn_rdwr +#define vn_rdwr_inchunks _bsd_vn_rdwr_inchunks +#define vn_rlimit_fsize _bsd_vn_rlimit_fsize +#define vn_seek _bsd_vn_seek +#define vn_start_secondary_write _bsd_vn_start_secondary_write +#define vn_start_write _bsd_vn_start_write +#define vn_stat _bsd_vn_stat +#define vn_utimes_perm _bsd_vn_utimes_perm +#define vn_vget_ino _bsd_vn_vget_ino +#define vn_vget_ino_gen _bsd_vn_vget_ino_gen +#define vn_vptocnp _bsd_vn_vptocnp +#define vn_writechk _bsd_vn_writechk #define vnet_if_clone_init _bsd_vnet_if_clone_init +#define vnlru_free _bsd_vnlru_free +#define vnops _bsd_vnops +#define vntype_to_kinfo _bsd_vntype_to_kinfo +#define vop_close_post _bsd_vop_close_post +#define vop_create_post _bsd_vop_create_post +#define vop_deleteextattr_post _bsd_vop_deleteextattr_post +#define vop_ebadf _bsd_vop_ebadf +#define vop_einval _bsd_vop_einval +#define vop_enoent _bsd_vop_enoent +#define vop_enotty _bsd_vop_enotty +#define vop_eopnotsupp _bsd_vop_eopnotsupp +#define vop_link_post _bsd_vop_link_post +#define vop_mkdir_post _bsd_vop_mkdir_post +#define vop_mknod_post _bsd_vop_mknod_post +#define vop_nopoll _bsd_vop_nopoll +#define vop_null _bsd_vop_null +#define vop_open_post _bsd_vop_open_post +#define vop_panic _bsd_vop_panic +#define vop_read_post _bsd_vop_read_post +#define vop_readdir_post _bsd_vop_readdir_post +#define vop_reclaim_post _bsd_vop_reclaim_post +#define vop_remove_post _bsd_vop_remove_post +#define vop_rename_fail _bsd_vop_rename_fail +#define vop_rename_post _bsd_vop_rename_post +#define vop_rename_pre _bsd_vop_rename_pre +#define vop_rmdir_post _bsd_vop_rmdir_post +#define vop_setattr_post _bsd_vop_setattr_post +#define vop_setextattr_post _bsd_vop_setextattr_post +#define vop_stdaccess _bsd_vop_stdaccess +#define vop_stdaccessx _bsd_vop_stdaccessx +#define vop_stdadvise _bsd_vop_stdadvise +#define vop_stdadvlock _bsd_vop_stdadvlock +#define vop_stdadvlockasync _bsd_vop_stdadvlockasync +#define vop_stdadvlockpurge _bsd_vop_stdadvlockpurge +#define vop_stdallocate _bsd_vop_stdallocate +#define vop_stdbmap _bsd_vop_stdbmap +#define vop_stdfdatasync_buf _bsd_vop_stdfdatasync_buf +#define vop_stdfsync _bsd_vop_stdfsync +#define vop_stdgetpages _bsd_vop_stdgetpages +#define vop_stdgetwritemount _bsd_vop_stdgetwritemount +#define vop_stdislocked _bsd_vop_stdislocked +#define vop_stdkqfilter _bsd_vop_stdkqfilter +#define vop_stdlock _bsd_vop_stdlock +#define vop_stdpathconf _bsd_vop_stdpathconf +#define vop_stdpoll _bsd_vop_stdpoll +#define vop_stdputpages _bsd_vop_stdputpages +#define vop_stdset_text _bsd_vop_stdset_text +#define vop_stdunlock _bsd_vop_stdunlock +#define vop_stdunp_bind _bsd_vop_stdunp_bind +#define vop_stdunp_connect _bsd_vop_stdunp_connect +#define vop_stdunp_detach _bsd_vop_stdunp_detach +#define vop_stdvptocnp _bsd_vop_stdvptocnp +#define vop_stdvptofh _bsd_vop_stdvptofh +#define vop_symlink_post _bsd_vop_symlink_post #define vprintf _bsd_vprintf +#define vput _bsd_vput +#define vrecycle _bsd_vrecycle +#define vrecyclel _bsd_vrecyclel +#define vref _bsd_vref +#define vrefact _bsd_vrefact +#define vrefcnt _bsd_vrefcnt +#define vrefl _bsd_vrefl +#define vrele _bsd_vrele #define vsnprintf _bsd_vsnprintf #define vsnrprintf _bsd_vsnrprintf #define vsprintf _bsd_vsprintf +#define vtprintf _bsd_vtprintf +#define vtruncbuf _bsd_vtruncbuf +#define vttoif_tab _bsd_vttoif_tab +#define vunmapbuf _bsd_vunmapbuf +#define vunref _bsd_vunref +#define waitrunningbufspace _bsd_waitrunningbufspace #define wakeup _bsd_wakeup #define wakeup_any _bsd_wakeup_any #define wakeup_one _bsd_wakeup_one diff --git a/rtemsbsd/include/machine/rtems-bsd-kernel-space.h b/rtemsbsd/include/machine/rtems-bsd-kernel-space.h index 09bcecf1..37bd701d 100644 --- a/rtemsbsd/include/machine/rtems-bsd-kernel-space.h +++ b/rtemsbsd/include/machine/rtems-bsd-kernel-space.h @@ -3,10 +3,12 @@ * * @ingroup rtems_bsd_machine * - * @brief TODO. + * @brief RTEMS FreeBSD Kernel related machine settings and defines */ /* + * Copyright (c) 2020-2021 Chris Johns <chrisj@rtems.org>. All rights reserved. + * * Copyright (c) 2009-2013 embedded brains GmbH. All rights reserved. * * embedded brains GmbH @@ -40,23 +42,82 @@ #ifndef _RTEMS_BSD_MACHINE_RTEMS_BSD_KERNEL_SPACE_H_ #define _RTEMS_BSD_MACHINE_RTEMS_BSD_KERNEL_SPACE_H_ -/* FIXME: Update Newlib */ +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/* + * FreeBSD warning control + */ +#pragma GCC diagnostic ignored "-Wunused-function" +#pragma GCC diagnostic ignored "-Wunused-value" +#pragma GCC diagnostic ignored "-Wunused-variable" +#pragma GCC diagnostic ignored "-Wunused-const-variable" +#pragma GCC diagnostic ignored "-Waddress-of-packed-member" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" + +/* FIXME: start: Update Newlib */ #define MSIZE 256 -/* FIXME: Update Newlib */ #define __GLOBL1(sym) __asm__(".globl " #sym) #define __GLOBL(sym) __GLOBL1(sym) #define O_CLOEXEC 0 -#define IO_NDELAY O_NONBLOCK + +/* FIXME: end: Update Newlib */ + +#define FSEARCH O_SEARCH +#define O_FSYNC FSYNC + +#define FMASK (FREAD|FWRITE|FAPPEND|FASYNC|FNONBLOCK|O_DIRECT) +#define FCNTLFLAGS (FAPPEND|FASYNC|FNONBLOCK|O_DIRECT) +#define FHASLOCK 0 + +#define PIPE_NODIRECT + +#define SEEK_DATA 3 /* set file offset to next data past offset */ +#define SEEK_HOLE 4 /* set file offset to next hole past offset */ +#define L_SET SEEK_SET +#define L_INCR SEEK_CUR +#define L_XTND SEEK_END +#define O_FSYNC FSYNC +#define O_SHLOCK FSHLOCK +#define O_EXLOCK FEXLOCK +#define POSIX_FADV_NORMAL 0 /* no special treatment */ +#define POSIX_FADV_RANDOM 1 /* expect random page references */ +#define POSIX_FADV_SEQUENTIAL 2 /* expect sequential page references */ +#define POSIX_FADV_WILLNEED 3 /* will need these pages */ +#define POSIX_FADV_DONTNEED 4 /* dont need these pages */ +#define POSIX_FADV_NOREUSE 5 /* access data only once */ + +/* Used in NFS common code */ +#define __LINUX_ERRNO_EXTENSIONS__ 1 #define __FreeBSD__ 1 /* General define to activate BSD kernel parts */ #define _KERNEL 1 +/* + * Various developer tracing options. See waf --help and --freebsd-options. + */ +#ifndef RTEMS_BSD_DESCRIP_TRACE + #define RTEMS_BSD_DESCRIP_TRACE (0) +#endif +#ifndef RTEMS_BSD_SYSCALL_TRACE + #define RTEMS_BSD_SYSCALL_TRACE (0) +#endif +#ifndef RTEMS_BSD_VFS_TRACE + #define RTEMS_BSD_VFS_TRACE (0) +#endif + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + #include <machine/rtems-bsd-version.h> #include <machine/rtems-bsd-kernel-namespace.h> +#include <sys/types.h> #ifdef __cplusplus extern "C" { @@ -74,6 +135,8 @@ void rtems_bsd_assert_func(const char *file, int line, const char *func, const c /* General definitions */ +#define MACHINE "rtems" + #define MACHINE_ARCH "rtems" #define M_RTEMS_HEAP 0 @@ -95,9 +158,92 @@ void rtems_bsd_assert_func(const char *file, int line, const char *func, const c #define EJUSTRETURN (-2) /* don't modify regs, just return */ #define ENOIOCTL (-3) /* ioctl not handled by this layer */ #define EDIRIOCTL (-4) /* do direct ioctl in GEOM */ +#define ERELOOKUP (-5) /* retry the directory lookup */ + +/* error codes used in the NFS code */ +#define EBADRPC 72 +#define EPROGMISMATCH 75 +#define EAUTH 80 +#define ENOTCAPABLE 93 #define EDOOFUS __ELASTERROR +typedef unsigned char u_char; +typedef unsigned short u_short; +typedef unsigned int u_int; +typedef unsigned long u_long; +typedef unsigned short ushort; /* Sys V compatibility */ +typedef unsigned int uint; /* Sys V compatibility */ + +typedef __UINT64_TYPE__ uoff_t; + +#define __LLONG_MAX __LONG_LONG_MAX__ +#define __OFF_MAX __LLONG_MAX +#define OFF_MAX __OFF_MAX + +#define F_WAIT 0x010 /* Wait until lock is granted */ +#define F_FLOCK 0x020 /* Use flock(2) semantics for lock */ +#define F_POSIX 0x040 /* Use POSIX semantics for lock */ +#define F_REMOTE 0x080 /* Lock owner is remote NFS client */ +#define F_NOINTR 0x100 /* Ignore signals when waiting */ + +#define _PC_ACL_EXTENDED 59 +#define _PC_ACL_PATH_MAX 60 +#define _PC_CAP_PRESENT 61 +#define _PC_INF_PRESENT 62 +#define _PC_MAC_PRESENT 63 +#define _PC_ACL_NFS4 64 + +#define FFLAGS(oflags) ((oflags) + 1) +#define OFLAGS(fflags) ((fflags) - 1) + +#define buffer_arena NULL +extern struct vmem *rtems_bsd_transient_arena; +#define transient_arena rtems_bsd_transient_arena + +struct uma_zone; +extern struct uma_zone* ncl_pbuf_zone; +struct uma_zone* pbuf_zsecond_create(char *name, int max); + +/* + * Device dev_t handling + */ +int rtems_bsd__major(dev_t _d); +int rtems_bsd__minor(dev_t _d); +dev_t rtems_bsd__makedev(int _M, int _m); +#define major(d) rtems_bsd__major(d) +#define minor(d) rtems_bsd__minor(d) +#define makedev(M, m) rtems_bsd__makedev((M), (m)) + +/* + * VM, avoid bringing the headers across + */ +#define VM_OBJECT_WLOCK(object) +#define VM_OBJECT_WUNLOCK(object) + +/* + * From freebsd-oirg/sys/sys/dirent.h + */ +#define _GENERIC_DIRLEN(namlen) \ + ((__offsetof(struct dirent, d_name) + (namlen) + 1 + 7) & ~7) +#define _GENERIC_DIRSIZ(dp) _GENERIC_DIRLEN((dp)->d_namlen) + +/* + * From signalvar.h + */ +#define SIGISMEMBER(set, signo) (0) + +/* + * Special knote status bit to indicate the kn_fp is an iop. + */ +#define KN_FP_IS_IOP 0x10000000 + +/* + * Ensure that padding bytes are zeroed and that the name is NUL-terminated. + */ +struct dirent; +void dirent_terminate(struct dirent *dp); + #ifdef __cplusplus } #endif /* __cplusplus */ diff --git a/rtemsbsd/include/machine/rtems-bsd-libio.h b/rtemsbsd/include/machine/rtems-bsd-libio.h new file mode 100644 index 00000000..e662a9ec --- /dev/null +++ b/rtemsbsd/include/machine/rtems-bsd-libio.h @@ -0,0 +1,330 @@ +/** + * @file + * + * @ingroup rtems_bsd_machine + * + * @brief LibIO interface for FreeBSD filedesc. + */ + +/* + * Copyright (c) 2020 Chrs Johns. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _RTEMS_BSD_MACHINE_RTEMS_BSD_LIBIO_H_ +#define _RTEMS_BSD_MACHINE_RTEMS_BSD_LIBIO_H_ + +#include <sys/event.h> +#include <sys/fcntl.h> +#include <sys/file.h> +#include <sys/filedesc.h> +#include <sys/proc.h> + +#include <machine/rtems-bsd-vfs.h> + +#include <rtems/libio.h> +#include <rtems/libio_.h> +#include <rtems/seterr.h> +#include <stdint.h> + +struct rtems_bsd_vfs_loc; + +extern const rtems_filesystem_file_handlers_r rtems_bsd_sysgen_nodeops; +extern const rtems_filesystem_file_handlers_r rtems_bsd_sysgen_imfsnodeops; +extern const rtems_filesystem_file_handlers_r rtems_bsd_sysgen_dirops; +extern const rtems_filesystem_file_handlers_r rtems_bsd_sysgen_fileops; + +static int inline rtems_bsd_error_to_status_and_errno(int error) +{ + if (error == 0) { + return 0; + } else { + rtems_set_errno_and_return_minus_one(error); + } +} + +static inline uint32_t +rtems_bsd_libio_fflag_to_flags(u_int fflag) +{ + uint32_t libio_flags = 0; + + if ((fflag & FREAD) == FREAD) { + libio_flags |= LIBIO_FLAGS_READ; + } + + if ((fflag & FWRITE) == FWRITE) { + libio_flags |= LIBIO_FLAGS_WRITE; + } + + if ((fflag & FNONBLOCK) == FNONBLOCK) { + libio_flags |= LIBIO_FLAGS_NO_DELAY; + } + + return (libio_flags); +} + +static inline u_int +rtems_bsd_libio_flags_to_fflag(uint32_t libio_flags) +{ + u_int fflag = 0; + + if ((libio_flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { + fflag |= FREAD; + } + + if ((libio_flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) { + fflag |= FWRITE; + } + + if ((libio_flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY) { + fflag |= FNONBLOCK; + } + + return (fflag); +} + +static inline bool +rtems_bsd_is_libbsd_nvops(rtems_libio_t *iop) +{ + return (iop->pathinfo.handlers == &rtems_bsd_sysgen_dirops || + iop->pathinfo.handlers == &rtems_bsd_sysgen_fileops); +} + +static inline bool +rtems_bsd_is_libbsd_descriptor(rtems_libio_t *iop) +{ + return (iop->pathinfo.handlers == &rtems_bsd_sysgen_nodeops || + rtems_bsd_is_libbsd_nvops(iop)); +} + +static inline rtems_libio_t * +rtems_bsd_libio_loc_to_iop(const rtems_filesystem_location_info_t *loc) +{ + return (rtems_libio_t *)RTEMS_DECONST( + rtems_filesystem_location_info_t *, loc) + ->node_access; +} + +struct socket; + +static inline struct socket * +rtems_bsd_libio_imfs_loc_to_so(const rtems_filesystem_location_info_t *loc) +{ + return (struct socket *)RTEMS_DECONST( + rtems_filesystem_location_info_t *, loc) + ->node_access_2; +} + +static struct vnode * +rtems_bsd_libio_loc_to_vnode(const rtems_filesystem_location_info_t *loc) +{ + return (struct vnode *)RTEMS_DECONST( + rtems_filesystem_location_info_t *, loc) + ->node_access; +} + +static struct vnode * +rtems_bsd_libio_loc_to_vnode_dir(const rtems_filesystem_location_info_t *loc) +{ + return (struct vnode *)RTEMS_DECONST( + rtems_filesystem_location_info_t *, loc) + ->node_access_2; +} + +static inline void +rtems_bsd_libio_iop_free(rtems_libio_t *iop) +{ + rtems_libio_free(iop); +} + +static int +rtems_bsd_libio_iop_to_descriptor(rtems_libio_t *iop) +{ + return (int)iop->data0; +} + +static struct vnode * +rtems_bsd_libio_iop_to_vnode(rtems_libio_t *iop) +{ + return rtems_bsd_libio_loc_to_vnode(&iop->pathinfo); +} + +static int +rtems_bsd_libio_fd_to_descriptor(int fd) +{ + return rtems_bsd_libio_iop_to_descriptor(rtems_libio_iop(fd)); +} + +static inline struct file * +rtems_bsd_libio_iop_to_file_hold(rtems_libio_t *iop, struct thread *td) +{ + struct file *fp; + int error = fget_unlocked(td->td_proc->p_fd, + rtems_bsd_libio_iop_to_descriptor(iop), NULL, &fp, NULL); + if (error != 0) { + fp = NULL; + } + return fp; +} + +static inline int +rtems_bsd_file_to_libio_fd(struct file *fp) +{ + return fp->f_io - rtems_libio_iops; +} + +static inline void +rtems_bsd_libio_iop_set_bsd_descriptor(rtems_libio_t *iop, int fd) +{ + iop->data0 = fd; + /* if not vnops the fstat passes a loc, need to get the iop to get the + * fp */ + if (!rtems_bsd_is_libbsd_nvops(iop)) { + iop->pathinfo.node_access = iop; + } +} + +static inline void +rtems_bsd_libio_iop_set_bsd_file(rtems_libio_t *iop, struct file *fp) +{ + fp->f_io = iop; +} + +/* + * The fd is a libio file descriptor. + * + * Return -1 if the descriptor is closed or not valid. The descriptor is not + * held. + * + * If open hold the descriptor. If the descriptor referneces a BSD + * descriptor return the BSD descriptor else return the libio descriptor. + * + * Optionally return the iop in *iopp if the descriptor if a libio descriptor + * else return NULL. + */ +static inline int +rtems_bsd_libio_iop_hold(int fd, rtems_libio_t **iopp) +{ + rtems_libio_t *iop = NULL; + unsigned int flags = 0; + int ffd = -1; + if (fd < rtems_libio_number_iops) { + iop = rtems_libio_iop(fd); + flags = rtems_libio_iop_hold(iop); + if ((flags & LIBIO_FLAGS_OPEN) != 0) { + if (rtems_bsd_is_libbsd_descriptor(iop)) { + ffd = rtems_bsd_libio_iop_to_descriptor(iop); + if (iopp != NULL) { + *iopp = NULL; + } + } else { + ffd = fd; + if (iopp != NULL) { + *iopp = iop; + } + } + } else { + rtems_libio_iop_drop(iop); + } + if (RTEMS_BSD_DESCRIP_TRACE) + flags = iop->flags; + } else { + *iopp = NULL; + } + if (RTEMS_BSD_DESCRIP_TRACE) + printf("bsd: iop: hold: fd=%d ffd=%d refs=%d iop=%p by %p\n", + fd, ffd, flags >> 12, iop, __builtin_return_address(0)); + return ffd; +} + +static inline int +rtems_bsd_libio_iop_drop(int fd) +{ + if (RTEMS_BSD_DESCRIP_TRACE) + printf("bsd: iop: drop: fd=%d refs=%d by %p\n", fd, + rtems_libio_iop(fd)->flags >> 12, + __builtin_return_address(0)); + rtems_libio_iop_drop(rtems_libio_iop(fd)); + return 0; +} + +static inline int +rtems_bsd_libio_fo_poll(int fd, struct file *fp, int events, + struct ucred *active_cred, struct thread *td) +{ + int error; + if (fp == NULL) { + rtems_libio_t *iop = rtems_libio_iop(fd); + error = (*iop->pathinfo.handlers->poll_h)(iop, events); + } else { + error = (*fp->f_ops->fo_poll)(fp, events, active_cred, td); + fd = rtems_bsd_file_to_libio_fd(fp); + } + rtems_bsd_libio_iop_drop(fd); + return error; +} + +static inline void +rtems_bsd_libio_iop_to_knote(struct knote *kn, rtems_libio_t *iop) +{ + kn->kn_fp = (struct file *)iop; +} + +static inline struct kqueue * +rtems_bsd_libio_knote_to_kq(struct knote *kn) +{ + struct kqueue *kq = kn->kn_kq; + if ((kn->kn_status & KN_FP_IS_IOP) == 0) { + if (kq != kn->kn_fp->f_data) + panic("libio kq wrong\n"); + } + return kq; +} + +/* + * Returns an iop with null file system mount or NULL is ENFILE. + */ +rtems_libio_t *rtems_bsd_libio_iop_allocate(void); + +/* + * Returns the libio descriptor or -1 if ENFILE. + */ +int rtems_bsd_libio_iop_allocate_with_file( + struct thread *td, int fd, const rtems_filesystem_file_handlers_r *ops); + +/* + * Set the BSD file descriptor in the iop. Returns 0 if successful or an error + * number, + */ +int rtems_bsd_libio_iop_set_bsd_fd(struct thread *td, int fd, + rtems_libio_t *iop, const rtems_filesystem_file_handlers_r *ops); + +/* + * Set the vnode in the libio location. + */ +void rtems_bsd_libio_loc_set_vnode( + rtems_filesystem_location_info_t *loc, struct vnode *vn); +void rtems_bsd_libio_loc_set_vnode_dir( + rtems_filesystem_location_info_t *loc, struct vnode *dvn); + +#endif /* _RTEMS_BSD_MACHINE_RTEMS_BSD_LIBIO_H_ */ diff --git a/rtemsbsd/include/machine/rtems-bsd-page.h b/rtemsbsd/include/machine/rtems-bsd-page.h index b732c1a9..f409e06a 100644 --- a/rtemsbsd/include/machine/rtems-bsd-page.h +++ b/rtemsbsd/include/machine/rtems-bsd-page.h @@ -49,6 +49,7 @@ #include <sys/cdefs.h> #include <sys/param.h> + #include <stdint.h> __BEGIN_DECLS @@ -61,6 +62,8 @@ void *rtems_bsd_page_alloc(uintptr_t size_in_bytes, int wait); void rtems_bsd_page_free(void *addr); +void vm_pager_bufferinit(void); + static inline void ** rtems_bsd_page_get_object_entry(void *addr) { diff --git a/rtemsbsd/include/machine/rtems-bsd-vfs.h b/rtemsbsd/include/machine/rtems-bsd-vfs.h new file mode 100644 index 00000000..6cbf57ca --- /dev/null +++ b/rtemsbsd/include/machine/rtems-bsd-vfs.h @@ -0,0 +1,82 @@ +/** + * @file + * + * @ingroup rtems_bsd_machine + * + * @brief TODO. + */ + +/* + * Copyright (C) 2020 Chris Johns <chris@contemporary.software> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _RTEMS_BSD_MACHINE_RTEMS_BSD_VFS_H_ +#define _RTEMS_BSD_MACHINE_RTEMS_BSD_VFS_H_ + +#include <rtems/libio.h> + +extern const rtems_filesystem_operations_table rtems_bsd_vfsops; + +int rtems_bsd_vfs_mount_init(rtems_filesystem_mount_table_entry_t *mt_entry); + +void rtems_bsd_vfs_mt_entry_lock( + const rtems_filesystem_mount_table_entry_t *mt_entry); +void rtems_bsd_vfs_mt_entry_unlock( + const rtems_filesystem_mount_table_entry_t *mt_entry); +void rtems_bsd_vfs_eval_path(rtems_filesystem_eval_path_context_t *ctx); +bool rtems_bsd_vfs_are_nodes_equal(const rtems_filesystem_location_info_t *a, + const rtems_filesystem_location_info_t *b); +int rtems_bsd_vfs_link(const rtems_filesystem_location_info_t *parentloc, + const rtems_filesystem_location_info_t *targetloc, const char *name, + size_t namelen); +int rtems_bsd_vfs_fchmod( + const rtems_filesystem_location_info_t *loc, mode_t mode); +int rtems_bsd_vfs_chown( + const rtems_filesystem_location_info_t *loc, uid_t owner, gid_t group); +int rtems_bsd_vfs_clonenode(rtems_filesystem_location_info_t *loc); +void rtems_bsd_vfs_freenode(const rtems_filesystem_location_info_t *loc); +int rtems_bsd_vfs_mount(rtems_filesystem_mount_table_entry_t *mt_entry); +int rtems_bsd_vfs_fsmount_me( + rtems_filesystem_mount_table_entry_t *mt_entry, const void *data); +int rtems_bsd_vfs_unmount(rtems_filesystem_mount_table_entry_t *mt_entry); +void rtems_bsd_vfs_fsunmount_me(rtems_filesystem_mount_table_entry_t *mt_entry); +int rtems_bsd_vfs_mknod(const rtems_filesystem_location_info_t *parentloc, + const char *name, size_t namelen, mode_t mode, dev_t dev); +int rtems_bsd_vfs_rmnod(const rtems_filesystem_location_info_t *parentloc, + const rtems_filesystem_location_info_t *loc); +int rtems_bsd_vfs_utimens( + const rtems_filesystem_location_info_t *loc, time_t actime, time_t modtime); +int rtems_bsd_vfs_symlink(const rtems_filesystem_location_info_t *parentloc, + const char *name, size_t namelen, const char *target); +ssize_t rtems_bsd_vfs_readlink( + const rtems_filesystem_location_info_t *loc, char *buf, size_t bufsize); +int rtems_bsd_vfs_rename(const rtems_filesystem_location_info_t *oldparentloc, + const rtems_filesystem_location_info_t *oldloc, + const rtems_filesystem_location_info_t *newparentloc, const char *name, + size_t namelen); +int rtems_bsd_vfs_statvfs( + const rtems_filesystem_location_info_t *loc, struct statvfs *buf); + +#endif /* _RTEMS_BSD_MACHINE_RTEMS_BSD_VFS_H_ */ diff --git a/rtemsbsd/include/rtems/bsd/bsd.h b/rtemsbsd/include/rtems/bsd/bsd.h index cec14ac4..d5decbf2 100755 --- a/rtemsbsd/include/rtems/bsd/bsd.h +++ b/rtemsbsd/include/rtems/bsd/bsd.h @@ -58,6 +58,12 @@ extern "C" { */ #define RTEMS_BSD_ALLOCATOR_DOMAIN_PAGE_MBUF_DEFAULT (8 * 1024 * 1024) +/* + * The default block IO buffer memory size. Do not change, use + * RTEMS_BSD_CONFIG_DOMAIN_BIO_SIZE to override for your application. + */ +#define RTEMS_BSD_ALLOCATOR_DOMAIN_BIO_DEFAULT (4 * 1024 * 1024) + typedef enum { RTEMS_BSD_RES_IRQ = 1, RTEMS_BSD_RES_MEMORY = 3 @@ -165,6 +171,7 @@ size_t rtems_bsd_get_task_stack_size(const char *name); typedef enum { RTEMS_BSD_ALLOCATOR_DOMAIN_PAGE, RTEMS_BSD_ALLOCATOR_DOMAIN_MBUF, + RTEMS_BSD_ALLOCATOR_DOMAIN_BIO, RTEMS_BSD_ALLOCATOR_DOMAIN_MALLOC } rtems_bsd_allocator_domain; @@ -176,6 +183,13 @@ typedef enum { extern uintptr_t rtems_bsd_allocator_domain_page_mbuf_size; /** + * @brief The size for the block IO default buffer memory. + * + * Applications may set this value to change the value returned by the default. + */ +extern uintptr_t rtems_bsd_allocator_domain_bio_size; + +/** * @brief Returns the size for a specific allocator domain. * * Applications may provide their own implementation of this function. For diff --git a/rtemsbsd/include/rtems/bsd/local/opt_pseudofs.h b/rtemsbsd/include/rtems/bsd/local/opt_pseudofs.h new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/rtemsbsd/include/rtems/bsd/local/opt_pseudofs.h diff --git a/rtemsbsd/include/rtems/bsd/local/opt_swap.h b/rtemsbsd/include/rtems/bsd/local/opt_swap.h new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/rtemsbsd/include/rtems/bsd/local/opt_swap.h diff --git a/rtemsbsd/include/rtems/bsd/local/opt_watchdog.h b/rtemsbsd/include/rtems/bsd/local/opt_watchdog.h new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/rtemsbsd/include/rtems/bsd/local/opt_watchdog.h diff --git a/rtemsbsd/include/rtems/bsd/local/vnode_if.h b/rtemsbsd/include/rtems/bsd/local/vnode_if.h new file mode 100644 index 00000000..62b3e340 --- /dev/null +++ b/rtemsbsd/include/rtems/bsd/local/vnode_if.h @@ -0,0 +1,1951 @@ +/* + * This file is produced automatically. + * Do not modify anything in here by hand. + * + * Created from $FreeBSD$ + */ + +extern struct vnodeop_desc vop_default_desc; +#include "vnode_if_typedef.h" +#include "vnode_if_newproto.h" +struct vop_islocked_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; +}; + +extern struct vnodeop_desc vop_islocked_desc; + +int VOP_ISLOCKED_AP(struct vop_islocked_args *); +int VOP_ISLOCKED_APV(struct vop_vector *vop, struct vop_islocked_args *); + +static __inline int VOP_ISLOCKED( + struct vnode *vp) +{ + struct vop_islocked_args a; + + a.a_gen.a_desc = &vop_islocked_desc; + a.a_vp = vp; + return (VOP_ISLOCKED_APV(vp->v_op, &a)); +} + +struct vop_lookup_args { + struct vop_generic_args a_gen; + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; +}; + +extern struct vnodeop_desc vop_lookup_desc; + +int VOP_LOOKUP_AP(struct vop_lookup_args *); +int VOP_LOOKUP_APV(struct vop_vector *vop, struct vop_lookup_args *); + +static __inline int VOP_LOOKUP( + struct vnode *dvp, + struct vnode **vpp, + struct componentname *cnp) +{ + struct vop_lookup_args a; + + a.a_gen.a_desc = &vop_lookup_desc; + a.a_dvp = dvp; + a.a_vpp = vpp; + a.a_cnp = cnp; + return (VOP_LOOKUP_APV(dvp->v_op, &a)); +} + +struct vop_cachedlookup_args { + struct vop_generic_args a_gen; + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; +}; + +extern struct vnodeop_desc vop_cachedlookup_desc; + +int VOP_CACHEDLOOKUP_AP(struct vop_cachedlookup_args *); +int VOP_CACHEDLOOKUP_APV(struct vop_vector *vop, struct vop_cachedlookup_args *); + +static __inline int VOP_CACHEDLOOKUP( + struct vnode *dvp, + struct vnode **vpp, + struct componentname *cnp) +{ + struct vop_cachedlookup_args a; + + a.a_gen.a_desc = &vop_cachedlookup_desc; + a.a_dvp = dvp; + a.a_vpp = vpp; + a.a_cnp = cnp; + return (VOP_CACHEDLOOKUP_APV(dvp->v_op, &a)); +} + +struct vop_create_args { + struct vop_generic_args a_gen; + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; +}; + +extern struct vnodeop_desc vop_create_desc; + +int VOP_CREATE_AP(struct vop_create_args *); +int VOP_CREATE_APV(struct vop_vector *vop, struct vop_create_args *); + +static __inline int VOP_CREATE( + struct vnode *dvp, + struct vnode **vpp, + struct componentname *cnp, + struct vattr *vap) +{ + struct vop_create_args a; + + a.a_gen.a_desc = &vop_create_desc; + a.a_dvp = dvp; + a.a_vpp = vpp; + a.a_cnp = cnp; + a.a_vap = vap; + return (VOP_CREATE_APV(dvp->v_op, &a)); +} + +struct vop_whiteout_args { + struct vop_generic_args a_gen; + struct vnode *a_dvp; + struct componentname *a_cnp; + int a_flags; +}; + +extern struct vnodeop_desc vop_whiteout_desc; + +int VOP_WHITEOUT_AP(struct vop_whiteout_args *); +int VOP_WHITEOUT_APV(struct vop_vector *vop, struct vop_whiteout_args *); + +static __inline int VOP_WHITEOUT( + struct vnode *dvp, + struct componentname *cnp, + int flags) +{ + struct vop_whiteout_args a; + + a.a_gen.a_desc = &vop_whiteout_desc; + a.a_dvp = dvp; + a.a_cnp = cnp; + a.a_flags = flags; + return (VOP_WHITEOUT_APV(dvp->v_op, &a)); +} + +struct vop_mknod_args { + struct vop_generic_args a_gen; + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; +}; + +extern struct vnodeop_desc vop_mknod_desc; + +int VOP_MKNOD_AP(struct vop_mknod_args *); +int VOP_MKNOD_APV(struct vop_vector *vop, struct vop_mknod_args *); + +static __inline int VOP_MKNOD( + struct vnode *dvp, + struct vnode **vpp, + struct componentname *cnp, + struct vattr *vap) +{ + struct vop_mknod_args a; + + a.a_gen.a_desc = &vop_mknod_desc; + a.a_dvp = dvp; + a.a_vpp = vpp; + a.a_cnp = cnp; + a.a_vap = vap; + return (VOP_MKNOD_APV(dvp->v_op, &a)); +} + +struct vop_open_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + int a_mode; + struct ucred *a_cred; + struct thread *a_td; + struct file *a_fp; +}; + +extern struct vnodeop_desc vop_open_desc; + +int VOP_OPEN_AP(struct vop_open_args *); +int VOP_OPEN_APV(struct vop_vector *vop, struct vop_open_args *); + +static __inline int VOP_OPEN( + struct vnode *vp, + int mode, + struct ucred *cred, + struct thread *td, + struct file *fp) +{ + struct vop_open_args a; + + a.a_gen.a_desc = &vop_open_desc; + a.a_vp = vp; + a.a_mode = mode; + a.a_cred = cred; + a.a_td = td; + a.a_fp = fp; + return (VOP_OPEN_APV(vp->v_op, &a)); +} + +struct vop_close_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + int a_fflag; + struct ucred *a_cred; + struct thread *a_td; +}; + +extern struct vnodeop_desc vop_close_desc; + +int VOP_CLOSE_AP(struct vop_close_args *); +int VOP_CLOSE_APV(struct vop_vector *vop, struct vop_close_args *); + +static __inline int VOP_CLOSE( + struct vnode *vp, + int fflag, + struct ucred *cred, + struct thread *td) +{ + struct vop_close_args a; + + a.a_gen.a_desc = &vop_close_desc; + a.a_vp = vp; + a.a_fflag = fflag; + a.a_cred = cred; + a.a_td = td; + return (VOP_CLOSE_APV(vp->v_op, &a)); +} + +struct vop_access_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + accmode_t a_accmode; + struct ucred *a_cred; + struct thread *a_td; +}; + +extern struct vnodeop_desc vop_access_desc; + +int VOP_ACCESS_AP(struct vop_access_args *); +int VOP_ACCESS_APV(struct vop_vector *vop, struct vop_access_args *); + +static __inline int VOP_ACCESS( + struct vnode *vp, + accmode_t accmode, + struct ucred *cred, + struct thread *td) +{ + struct vop_access_args a; + + a.a_gen.a_desc = &vop_access_desc; + a.a_vp = vp; + a.a_accmode = accmode; + a.a_cred = cred; + a.a_td = td; + return (VOP_ACCESS_APV(vp->v_op, &a)); +} + +struct vop_accessx_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + accmode_t a_accmode; + struct ucred *a_cred; + struct thread *a_td; +}; + +extern struct vnodeop_desc vop_accessx_desc; + +int VOP_ACCESSX_AP(struct vop_accessx_args *); +int VOP_ACCESSX_APV(struct vop_vector *vop, struct vop_accessx_args *); + +static __inline int VOP_ACCESSX( + struct vnode *vp, + accmode_t accmode, + struct ucred *cred, + struct thread *td) +{ + struct vop_accessx_args a; + + a.a_gen.a_desc = &vop_accessx_desc; + a.a_vp = vp; + a.a_accmode = accmode; + a.a_cred = cred; + a.a_td = td; + return (VOP_ACCESSX_APV(vp->v_op, &a)); +} + +struct vop_getattr_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + struct vattr *a_vap; + struct ucred *a_cred; +}; + +extern struct vnodeop_desc vop_getattr_desc; + +int VOP_GETATTR_AP(struct vop_getattr_args *); +int VOP_GETATTR_APV(struct vop_vector *vop, struct vop_getattr_args *); + +static __inline int VOP_GETATTR( + struct vnode *vp, + struct vattr *vap, + struct ucred *cred) +{ + struct vop_getattr_args a; + + a.a_gen.a_desc = &vop_getattr_desc; + a.a_vp = vp; + a.a_vap = vap; + a.a_cred = cred; + return (VOP_GETATTR_APV(vp->v_op, &a)); +} + +struct vop_setattr_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + struct vattr *a_vap; + struct ucred *a_cred; +}; + +extern struct vnodeop_desc vop_setattr_desc; + +int VOP_SETATTR_AP(struct vop_setattr_args *); +int VOP_SETATTR_APV(struct vop_vector *vop, struct vop_setattr_args *); + +static __inline int VOP_SETATTR( + struct vnode *vp, + struct vattr *vap, + struct ucred *cred) +{ + struct vop_setattr_args a; + + a.a_gen.a_desc = &vop_setattr_desc; + a.a_vp = vp; + a.a_vap = vap; + a.a_cred = cred; + return (VOP_SETATTR_APV(vp->v_op, &a)); +} + +struct vop_markatime_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; +}; + +extern struct vnodeop_desc vop_markatime_desc; + +int VOP_MARKATIME_AP(struct vop_markatime_args *); +int VOP_MARKATIME_APV(struct vop_vector *vop, struct vop_markatime_args *); + +static __inline int VOP_MARKATIME( + struct vnode *vp) +{ + struct vop_markatime_args a; + + a.a_gen.a_desc = &vop_markatime_desc; + a.a_vp = vp; + return (VOP_MARKATIME_APV(vp->v_op, &a)); +} + +struct vop_read_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + struct uio *a_uio; + int a_ioflag; + struct ucred *a_cred; +}; + +extern struct vnodeop_desc vop_read_desc; + +int VOP_READ_AP(struct vop_read_args *); +int VOP_READ_APV(struct vop_vector *vop, struct vop_read_args *); + +static __inline int VOP_READ( + struct vnode *vp, + struct uio *uio, + int ioflag, + struct ucred *cred) +{ + struct vop_read_args a; + + a.a_gen.a_desc = &vop_read_desc; + a.a_vp = vp; + a.a_uio = uio; + a.a_ioflag = ioflag; + a.a_cred = cred; + return (VOP_READ_APV(vp->v_op, &a)); +} + +struct vop_write_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + struct uio *a_uio; + int a_ioflag; + struct ucred *a_cred; +}; + +extern struct vnodeop_desc vop_write_desc; + +int VOP_WRITE_AP(struct vop_write_args *); +int VOP_WRITE_APV(struct vop_vector *vop, struct vop_write_args *); + +static __inline int VOP_WRITE( + struct vnode *vp, + struct uio *uio, + int ioflag, + struct ucred *cred) +{ + struct vop_write_args a; + + a.a_gen.a_desc = &vop_write_desc; + a.a_vp = vp; + a.a_uio = uio; + a.a_ioflag = ioflag; + a.a_cred = cred; + return (VOP_WRITE_APV(vp->v_op, &a)); +} + +struct vop_ioctl_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + u_long a_command; + void *a_data; + int a_fflag; + struct ucred *a_cred; + struct thread *a_td; +}; + +extern struct vnodeop_desc vop_ioctl_desc; + +int VOP_IOCTL_AP(struct vop_ioctl_args *); +int VOP_IOCTL_APV(struct vop_vector *vop, struct vop_ioctl_args *); + +static __inline int VOP_IOCTL( + struct vnode *vp, + u_long command, + void *data, + int fflag, + struct ucred *cred, + struct thread *td) +{ + struct vop_ioctl_args a; + + a.a_gen.a_desc = &vop_ioctl_desc; + a.a_vp = vp; + a.a_command = command; + a.a_data = data; + a.a_fflag = fflag; + a.a_cred = cred; + a.a_td = td; + return (VOP_IOCTL_APV(vp->v_op, &a)); +} + +struct vop_poll_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + int a_events; + struct ucred *a_cred; + struct thread *a_td; +}; + +extern struct vnodeop_desc vop_poll_desc; + +int VOP_POLL_AP(struct vop_poll_args *); +int VOP_POLL_APV(struct vop_vector *vop, struct vop_poll_args *); + +static __inline int VOP_POLL( + struct vnode *vp, + int events, + struct ucred *cred, + struct thread *td) +{ + struct vop_poll_args a; + + a.a_gen.a_desc = &vop_poll_desc; + a.a_vp = vp; + a.a_events = events; + a.a_cred = cred; + a.a_td = td; + return (VOP_POLL_APV(vp->v_op, &a)); +} + +struct vop_kqfilter_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + struct knote *a_kn; +}; + +extern struct vnodeop_desc vop_kqfilter_desc; + +int VOP_KQFILTER_AP(struct vop_kqfilter_args *); +int VOP_KQFILTER_APV(struct vop_vector *vop, struct vop_kqfilter_args *); + +static __inline int VOP_KQFILTER( + struct vnode *vp, + struct knote *kn) +{ + struct vop_kqfilter_args a; + + a.a_gen.a_desc = &vop_kqfilter_desc; + a.a_vp = vp; + a.a_kn = kn; + return (VOP_KQFILTER_APV(vp->v_op, &a)); +} + +struct vop_revoke_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + int a_flags; +}; + +extern struct vnodeop_desc vop_revoke_desc; + +int VOP_REVOKE_AP(struct vop_revoke_args *); +int VOP_REVOKE_APV(struct vop_vector *vop, struct vop_revoke_args *); + +static __inline int VOP_REVOKE( + struct vnode *vp, + int flags) +{ + struct vop_revoke_args a; + + a.a_gen.a_desc = &vop_revoke_desc; + a.a_vp = vp; + a.a_flags = flags; + return (VOP_REVOKE_APV(vp->v_op, &a)); +} + +struct vop_fsync_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + int a_waitfor; + struct thread *a_td; +}; + +extern struct vnodeop_desc vop_fsync_desc; + +int VOP_FSYNC_AP(struct vop_fsync_args *); +int VOP_FSYNC_APV(struct vop_vector *vop, struct vop_fsync_args *); + +static __inline int VOP_FSYNC( + struct vnode *vp, + int waitfor, + struct thread *td) +{ + struct vop_fsync_args a; + + a.a_gen.a_desc = &vop_fsync_desc; + a.a_vp = vp; + a.a_waitfor = waitfor; + a.a_td = td; + return (VOP_FSYNC_APV(vp->v_op, &a)); +} + +struct vop_remove_args { + struct vop_generic_args a_gen; + struct vnode *a_dvp; + struct vnode *a_vp; + struct componentname *a_cnp; +}; + +extern struct vnodeop_desc vop_remove_desc; + +int VOP_REMOVE_AP(struct vop_remove_args *); +int VOP_REMOVE_APV(struct vop_vector *vop, struct vop_remove_args *); + +static __inline int VOP_REMOVE( + struct vnode *dvp, + struct vnode *vp, + struct componentname *cnp) +{ + struct vop_remove_args a; + + a.a_gen.a_desc = &vop_remove_desc; + a.a_dvp = dvp; + a.a_vp = vp; + a.a_cnp = cnp; + return (VOP_REMOVE_APV(dvp->v_op, &a)); +} + +struct vop_link_args { + struct vop_generic_args a_gen; + struct vnode *a_tdvp; + struct vnode *a_vp; + struct componentname *a_cnp; +}; + +extern struct vnodeop_desc vop_link_desc; + +int VOP_LINK_AP(struct vop_link_args *); +int VOP_LINK_APV(struct vop_vector *vop, struct vop_link_args *); + +static __inline int VOP_LINK( + struct vnode *tdvp, + struct vnode *vp, + struct componentname *cnp) +{ + struct vop_link_args a; + + a.a_gen.a_desc = &vop_link_desc; + a.a_tdvp = tdvp; + a.a_vp = vp; + a.a_cnp = cnp; + return (VOP_LINK_APV(tdvp->v_op, &a)); +} + +struct vop_rename_args { + struct vop_generic_args a_gen; + struct vnode *a_fdvp; + struct vnode *a_fvp; + struct componentname *a_fcnp; + struct vnode *a_tdvp; + struct vnode *a_tvp; + struct componentname *a_tcnp; +}; + +extern struct vnodeop_desc vop_rename_desc; + +int VOP_RENAME_AP(struct vop_rename_args *); +int VOP_RENAME_APV(struct vop_vector *vop, struct vop_rename_args *); + +static __inline int VOP_RENAME( + 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_gen.a_desc = &vop_rename_desc; + 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 (VOP_RENAME_APV(fdvp->v_op, &a)); +} + +struct vop_mkdir_args { + struct vop_generic_args a_gen; + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; +}; + +extern struct vnodeop_desc vop_mkdir_desc; + +int VOP_MKDIR_AP(struct vop_mkdir_args *); +int VOP_MKDIR_APV(struct vop_vector *vop, struct vop_mkdir_args *); + +static __inline int VOP_MKDIR( + struct vnode *dvp, + struct vnode **vpp, + struct componentname *cnp, + struct vattr *vap) +{ + struct vop_mkdir_args a; + + a.a_gen.a_desc = &vop_mkdir_desc; + a.a_dvp = dvp; + a.a_vpp = vpp; + a.a_cnp = cnp; + a.a_vap = vap; + return (VOP_MKDIR_APV(dvp->v_op, &a)); +} + +struct vop_rmdir_args { + struct vop_generic_args a_gen; + struct vnode *a_dvp; + struct vnode *a_vp; + struct componentname *a_cnp; +}; + +extern struct vnodeop_desc vop_rmdir_desc; + +int VOP_RMDIR_AP(struct vop_rmdir_args *); +int VOP_RMDIR_APV(struct vop_vector *vop, struct vop_rmdir_args *); + +static __inline int VOP_RMDIR( + struct vnode *dvp, + struct vnode *vp, + struct componentname *cnp) +{ + struct vop_rmdir_args a; + + a.a_gen.a_desc = &vop_rmdir_desc; + a.a_dvp = dvp; + a.a_vp = vp; + a.a_cnp = cnp; + return (VOP_RMDIR_APV(dvp->v_op, &a)); +} + +struct vop_symlink_args { + struct vop_generic_args a_gen; + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; + char *a_target; +}; + +extern struct vnodeop_desc vop_symlink_desc; + +int VOP_SYMLINK_AP(struct vop_symlink_args *); +int VOP_SYMLINK_APV(struct vop_vector *vop, struct vop_symlink_args *); + +static __inline int VOP_SYMLINK( + struct vnode *dvp, + struct vnode **vpp, + struct componentname *cnp, + struct vattr *vap, + char *target) +{ + struct vop_symlink_args a; + + a.a_gen.a_desc = &vop_symlink_desc; + a.a_dvp = dvp; + a.a_vpp = vpp; + a.a_cnp = cnp; + a.a_vap = vap; + a.a_target = target; + return (VOP_SYMLINK_APV(dvp->v_op, &a)); +} + +struct vop_readdir_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + struct uio *a_uio; + struct ucred *a_cred; + int *a_eofflag; + int *a_ncookies; + u_long **a_cookies; +}; + +extern struct vnodeop_desc vop_readdir_desc; + +int VOP_READDIR_AP(struct vop_readdir_args *); +int VOP_READDIR_APV(struct vop_vector *vop, struct vop_readdir_args *); + +static __inline int VOP_READDIR( + struct vnode *vp, + struct uio *uio, + struct ucred *cred, + int *eofflag, + int *ncookies, + u_long **cookies) +{ + struct vop_readdir_args a; + + a.a_gen.a_desc = &vop_readdir_desc; + a.a_vp = vp; + a.a_uio = uio; + a.a_cred = cred; + a.a_eofflag = eofflag; + a.a_ncookies = ncookies; + a.a_cookies = cookies; + return (VOP_READDIR_APV(vp->v_op, &a)); +} + +struct vop_readlink_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + struct uio *a_uio; + struct ucred *a_cred; +}; + +extern struct vnodeop_desc vop_readlink_desc; + +int VOP_READLINK_AP(struct vop_readlink_args *); +int VOP_READLINK_APV(struct vop_vector *vop, struct vop_readlink_args *); + +static __inline int VOP_READLINK( + struct vnode *vp, + struct uio *uio, + struct ucred *cred) +{ + struct vop_readlink_args a; + + a.a_gen.a_desc = &vop_readlink_desc; + a.a_vp = vp; + a.a_uio = uio; + a.a_cred = cred; + return (VOP_READLINK_APV(vp->v_op, &a)); +} + +struct vop_inactive_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + struct thread *a_td; +}; + +extern struct vnodeop_desc vop_inactive_desc; + +int VOP_INACTIVE_AP(struct vop_inactive_args *); +int VOP_INACTIVE_APV(struct vop_vector *vop, struct vop_inactive_args *); + +static __inline int VOP_INACTIVE( + struct vnode *vp, + struct thread *td) +{ + struct vop_inactive_args a; + + a.a_gen.a_desc = &vop_inactive_desc; + a.a_vp = vp; + a.a_td = td; + return (VOP_INACTIVE_APV(vp->v_op, &a)); +} + +struct vop_reclaim_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + struct thread *a_td; +}; + +extern struct vnodeop_desc vop_reclaim_desc; + +int VOP_RECLAIM_AP(struct vop_reclaim_args *); +int VOP_RECLAIM_APV(struct vop_vector *vop, struct vop_reclaim_args *); + +static __inline int VOP_RECLAIM( + struct vnode *vp, + struct thread *td) +{ + struct vop_reclaim_args a; + + a.a_gen.a_desc = &vop_reclaim_desc; + a.a_vp = vp; + a.a_td = td; + return (VOP_RECLAIM_APV(vp->v_op, &a)); +} + +struct vop_lock1_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + int a_flags; + char *a_file; + int a_line; +}; + +extern struct vnodeop_desc vop_lock1_desc; + +int VOP_LOCK1_AP(struct vop_lock1_args *); +int VOP_LOCK1_APV(struct vop_vector *vop, struct vop_lock1_args *); + +static __inline int VOP_LOCK1( + struct vnode *vp, + int flags, + char *file, + int line) +{ + struct vop_lock1_args a; + + a.a_gen.a_desc = &vop_lock1_desc; + a.a_vp = vp; + a.a_flags = flags; + a.a_file = file; + a.a_line = line; + return (VOP_LOCK1_APV(vp->v_op, &a)); +} + +struct vop_unlock_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + int a_flags; +}; + +extern struct vnodeop_desc vop_unlock_desc; + +int VOP_UNLOCK_AP(struct vop_unlock_args *); +int VOP_UNLOCK_APV(struct vop_vector *vop, struct vop_unlock_args *); + +static __inline int VOP_UNLOCK( + struct vnode *vp, + int flags) +{ + struct vop_unlock_args a; + + a.a_gen.a_desc = &vop_unlock_desc; + a.a_vp = vp; + a.a_flags = flags; + return (VOP_UNLOCK_APV(vp->v_op, &a)); +} + +struct vop_bmap_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + daddr_t a_bn; + struct bufobj **a_bop; + daddr_t *a_bnp; + int *a_runp; + int *a_runb; +}; + +extern struct vnodeop_desc vop_bmap_desc; + +int VOP_BMAP_AP(struct vop_bmap_args *); +int VOP_BMAP_APV(struct vop_vector *vop, struct vop_bmap_args *); + +static __inline int VOP_BMAP( + struct vnode *vp, + daddr_t bn, + struct bufobj **bop, + daddr_t *bnp, + int *runp, + int *runb) +{ + struct vop_bmap_args a; + + a.a_gen.a_desc = &vop_bmap_desc; + a.a_vp = vp; + a.a_bn = bn; + a.a_bop = bop; + a.a_bnp = bnp; + a.a_runp = runp; + a.a_runb = runb; + return (VOP_BMAP_APV(vp->v_op, &a)); +} + +struct vop_strategy_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + struct buf *a_bp; +}; + +extern struct vnodeop_desc vop_strategy_desc; + +int VOP_STRATEGY_AP(struct vop_strategy_args *); +int VOP_STRATEGY_APV(struct vop_vector *vop, struct vop_strategy_args *); + +static __inline int VOP_STRATEGY( + struct vnode *vp, + struct buf *bp) +{ + struct vop_strategy_args a; + + a.a_gen.a_desc = &vop_strategy_desc; + a.a_vp = vp; + a.a_bp = bp; + return (VOP_STRATEGY_APV(vp->v_op, &a)); +} + +struct vop_getwritemount_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + struct mount **a_mpp; +}; + +extern struct vnodeop_desc vop_getwritemount_desc; + +int VOP_GETWRITEMOUNT_AP(struct vop_getwritemount_args *); +int VOP_GETWRITEMOUNT_APV(struct vop_vector *vop, struct vop_getwritemount_args *); + +static __inline int VOP_GETWRITEMOUNT( + struct vnode *vp, + struct mount **mpp) +{ + struct vop_getwritemount_args a; + + a.a_gen.a_desc = &vop_getwritemount_desc; + a.a_vp = vp; + a.a_mpp = mpp; + return (VOP_GETWRITEMOUNT_APV(vp->v_op, &a)); +} + +struct vop_print_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; +}; + +extern struct vnodeop_desc vop_print_desc; + +int VOP_PRINT_AP(struct vop_print_args *); +int VOP_PRINT_APV(struct vop_vector *vop, struct vop_print_args *); + +static __inline int VOP_PRINT( + struct vnode *vp) +{ + struct vop_print_args a; + + a.a_gen.a_desc = &vop_print_desc; + a.a_vp = vp; + return (VOP_PRINT_APV(vp->v_op, &a)); +} + +struct vop_pathconf_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + int a_name; + long *a_retval; +}; + +extern struct vnodeop_desc vop_pathconf_desc; + +int VOP_PATHCONF_AP(struct vop_pathconf_args *); +int VOP_PATHCONF_APV(struct vop_vector *vop, struct vop_pathconf_args *); + +static __inline int VOP_PATHCONF( + struct vnode *vp, + int name, + long *retval) +{ + struct vop_pathconf_args a; + + a.a_gen.a_desc = &vop_pathconf_desc; + a.a_vp = vp; + a.a_name = name; + a.a_retval = retval; + return (VOP_PATHCONF_APV(vp->v_op, &a)); +} + +struct vop_advlock_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + void *a_id; + int a_op; + struct flock *a_fl; + int a_flags; +}; + +extern struct vnodeop_desc vop_advlock_desc; + +int VOP_ADVLOCK_AP(struct vop_advlock_args *); +int VOP_ADVLOCK_APV(struct vop_vector *vop, struct vop_advlock_args *); + +static __inline int VOP_ADVLOCK( + struct vnode *vp, + void *id, + int op, + struct flock *fl, + int flags) +{ + struct vop_advlock_args a; + + a.a_gen.a_desc = &vop_advlock_desc; + a.a_vp = vp; + a.a_id = id; + a.a_op = op; + a.a_fl = fl; + a.a_flags = flags; + return (VOP_ADVLOCK_APV(vp->v_op, &a)); +} + +struct vop_advlockasync_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + void *a_id; + int a_op; + struct flock *a_fl; + int a_flags; + struct task *a_task; + void **a_cookiep; +}; + +extern struct vnodeop_desc vop_advlockasync_desc; + +int VOP_ADVLOCKASYNC_AP(struct vop_advlockasync_args *); +int VOP_ADVLOCKASYNC_APV(struct vop_vector *vop, struct vop_advlockasync_args *); + +static __inline int VOP_ADVLOCKASYNC( + struct vnode *vp, + void *id, + int op, + struct flock *fl, + int flags, + struct task *task, + void **cookiep) +{ + struct vop_advlockasync_args a; + + a.a_gen.a_desc = &vop_advlockasync_desc; + a.a_vp = vp; + a.a_id = id; + a.a_op = op; + a.a_fl = fl; + a.a_flags = flags; + a.a_task = task; + a.a_cookiep = cookiep; + return (VOP_ADVLOCKASYNC_APV(vp->v_op, &a)); +} + +struct vop_advlockpurge_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; +}; + +extern struct vnodeop_desc vop_advlockpurge_desc; + +int VOP_ADVLOCKPURGE_AP(struct vop_advlockpurge_args *); +int VOP_ADVLOCKPURGE_APV(struct vop_vector *vop, struct vop_advlockpurge_args *); + +static __inline int VOP_ADVLOCKPURGE( + struct vnode *vp) +{ + struct vop_advlockpurge_args a; + + a.a_gen.a_desc = &vop_advlockpurge_desc; + a.a_vp = vp; + return (VOP_ADVLOCKPURGE_APV(vp->v_op, &a)); +} + +struct vop_reallocblks_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + struct cluster_save *a_buflist; +}; + +extern struct vnodeop_desc vop_reallocblks_desc; + +int VOP_REALLOCBLKS_AP(struct vop_reallocblks_args *); +int VOP_REALLOCBLKS_APV(struct vop_vector *vop, struct vop_reallocblks_args *); + +static __inline int VOP_REALLOCBLKS( + struct vnode *vp, + struct cluster_save *buflist) +{ + struct vop_reallocblks_args a; + + a.a_gen.a_desc = &vop_reallocblks_desc; + a.a_vp = vp; + a.a_buflist = buflist; + return (VOP_REALLOCBLKS_APV(vp->v_op, &a)); +} + +struct vop_getpages_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + vm_page_t *a_m; + int a_count; + int *a_rbehind; + int *a_rahead; +}; + +extern struct vnodeop_desc vop_getpages_desc; + +int VOP_GETPAGES_AP(struct vop_getpages_args *); +int VOP_GETPAGES_APV(struct vop_vector *vop, struct vop_getpages_args *); + +static __inline int VOP_GETPAGES( + struct vnode *vp, + vm_page_t *m, + int count, + int *rbehind, + int *rahead) +{ + struct vop_getpages_args a; + + a.a_gen.a_desc = &vop_getpages_desc; + a.a_vp = vp; + a.a_m = m; + a.a_count = count; + a.a_rbehind = rbehind; + a.a_rahead = rahead; + return (VOP_GETPAGES_APV(vp->v_op, &a)); +} + +struct vop_getpages_async_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + vm_page_t *a_m; + int a_count; + int *a_rbehind; + int *a_rahead; + vop_getpages_iodone_t *a_iodone; + void *a_arg; +}; + +extern struct vnodeop_desc vop_getpages_async_desc; + +int VOP_GETPAGES_ASYNC_AP(struct vop_getpages_async_args *); +int VOP_GETPAGES_ASYNC_APV(struct vop_vector *vop, struct vop_getpages_async_args *); + +static __inline int VOP_GETPAGES_ASYNC( + struct vnode *vp, + vm_page_t *m, + int count, + int *rbehind, + int *rahead, + vop_getpages_iodone_t *iodone, + void *arg) +{ + struct vop_getpages_async_args a; + + a.a_gen.a_desc = &vop_getpages_async_desc; + a.a_vp = vp; + a.a_m = m; + a.a_count = count; + a.a_rbehind = rbehind; + a.a_rahead = rahead; + a.a_iodone = iodone; + a.a_arg = arg; + return (VOP_GETPAGES_ASYNC_APV(vp->v_op, &a)); +} + +struct vop_putpages_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + vm_page_t *a_m; + int a_count; + int a_sync; + int *a_rtvals; +}; + +extern struct vnodeop_desc vop_putpages_desc; + +int VOP_PUTPAGES_AP(struct vop_putpages_args *); +int VOP_PUTPAGES_APV(struct vop_vector *vop, struct vop_putpages_args *); + +static __inline int VOP_PUTPAGES( + struct vnode *vp, + vm_page_t *m, + int count, + int sync, + int *rtvals) +{ + struct vop_putpages_args a; + + a.a_gen.a_desc = &vop_putpages_desc; + a.a_vp = vp; + a.a_m = m; + a.a_count = count; + a.a_sync = sync; + a.a_rtvals = rtvals; + return (VOP_PUTPAGES_APV(vp->v_op, &a)); +} + +struct vop_getacl_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + acl_type_t a_type; + struct acl *a_aclp; + struct ucred *a_cred; + struct thread *a_td; +}; + +extern struct vnodeop_desc vop_getacl_desc; + +int VOP_GETACL_AP(struct vop_getacl_args *); +int VOP_GETACL_APV(struct vop_vector *vop, struct vop_getacl_args *); + +static __inline int VOP_GETACL( + struct vnode *vp, + acl_type_t type, + struct acl *aclp, + struct ucred *cred, + struct thread *td) +{ + struct vop_getacl_args a; + + a.a_gen.a_desc = &vop_getacl_desc; + a.a_vp = vp; + a.a_type = type; + a.a_aclp = aclp; + a.a_cred = cred; + a.a_td = td; + return (VOP_GETACL_APV(vp->v_op, &a)); +} + +struct vop_setacl_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + acl_type_t a_type; + struct acl *a_aclp; + struct ucred *a_cred; + struct thread *a_td; +}; + +extern struct vnodeop_desc vop_setacl_desc; + +int VOP_SETACL_AP(struct vop_setacl_args *); +int VOP_SETACL_APV(struct vop_vector *vop, struct vop_setacl_args *); + +static __inline int VOP_SETACL( + struct vnode *vp, + acl_type_t type, + struct acl *aclp, + struct ucred *cred, + struct thread *td) +{ + struct vop_setacl_args a; + + a.a_gen.a_desc = &vop_setacl_desc; + a.a_vp = vp; + a.a_type = type; + a.a_aclp = aclp; + a.a_cred = cred; + a.a_td = td; + return (VOP_SETACL_APV(vp->v_op, &a)); +} + +struct vop_aclcheck_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + acl_type_t a_type; + struct acl *a_aclp; + struct ucred *a_cred; + struct thread *a_td; +}; + +extern struct vnodeop_desc vop_aclcheck_desc; + +int VOP_ACLCHECK_AP(struct vop_aclcheck_args *); +int VOP_ACLCHECK_APV(struct vop_vector *vop, struct vop_aclcheck_args *); + +static __inline int VOP_ACLCHECK( + struct vnode *vp, + acl_type_t type, + struct acl *aclp, + struct ucred *cred, + struct thread *td) +{ + struct vop_aclcheck_args a; + + a.a_gen.a_desc = &vop_aclcheck_desc; + a.a_vp = vp; + a.a_type = type; + a.a_aclp = aclp; + a.a_cred = cred; + a.a_td = td; + return (VOP_ACLCHECK_APV(vp->v_op, &a)); +} + +struct vop_closeextattr_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + int a_commit; + struct ucred *a_cred; + struct thread *a_td; +}; + +extern struct vnodeop_desc vop_closeextattr_desc; + +int VOP_CLOSEEXTATTR_AP(struct vop_closeextattr_args *); +int VOP_CLOSEEXTATTR_APV(struct vop_vector *vop, struct vop_closeextattr_args *); + +static __inline int VOP_CLOSEEXTATTR( + struct vnode *vp, + int commit, + struct ucred *cred, + struct thread *td) +{ + struct vop_closeextattr_args a; + + a.a_gen.a_desc = &vop_closeextattr_desc; + a.a_vp = vp; + a.a_commit = commit; + a.a_cred = cred; + a.a_td = td; + return (VOP_CLOSEEXTATTR_APV(vp->v_op, &a)); +} + +struct vop_getextattr_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + int a_attrnamespace; + const char *a_name; + struct uio *a_uio; + size_t *a_size; + struct ucred *a_cred; + struct thread *a_td; +}; + +extern struct vnodeop_desc vop_getextattr_desc; + +int VOP_GETEXTATTR_AP(struct vop_getextattr_args *); +int VOP_GETEXTATTR_APV(struct vop_vector *vop, struct vop_getextattr_args *); + +static __inline int VOP_GETEXTATTR( + struct vnode *vp, + int attrnamespace, + const char *name, + struct uio *uio, + size_t *size, + struct ucred *cred, + struct thread *td) +{ + struct vop_getextattr_args a; + + a.a_gen.a_desc = &vop_getextattr_desc; + a.a_vp = vp; + a.a_attrnamespace = attrnamespace; + a.a_name = name; + a.a_uio = uio; + a.a_size = size; + a.a_cred = cred; + a.a_td = td; + return (VOP_GETEXTATTR_APV(vp->v_op, &a)); +} + +struct vop_listextattr_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + int a_attrnamespace; + struct uio *a_uio; + size_t *a_size; + struct ucred *a_cred; + struct thread *a_td; +}; + +extern struct vnodeop_desc vop_listextattr_desc; + +int VOP_LISTEXTATTR_AP(struct vop_listextattr_args *); +int VOP_LISTEXTATTR_APV(struct vop_vector *vop, struct vop_listextattr_args *); + +static __inline int VOP_LISTEXTATTR( + struct vnode *vp, + int attrnamespace, + struct uio *uio, + size_t *size, + struct ucred *cred, + struct thread *td) +{ + struct vop_listextattr_args a; + + a.a_gen.a_desc = &vop_listextattr_desc; + a.a_vp = vp; + a.a_attrnamespace = attrnamespace; + a.a_uio = uio; + a.a_size = size; + a.a_cred = cred; + a.a_td = td; + return (VOP_LISTEXTATTR_APV(vp->v_op, &a)); +} + +struct vop_openextattr_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + struct ucred *a_cred; + struct thread *a_td; +}; + +extern struct vnodeop_desc vop_openextattr_desc; + +int VOP_OPENEXTATTR_AP(struct vop_openextattr_args *); +int VOP_OPENEXTATTR_APV(struct vop_vector *vop, struct vop_openextattr_args *); + +static __inline int VOP_OPENEXTATTR( + struct vnode *vp, + struct ucred *cred, + struct thread *td) +{ + struct vop_openextattr_args a; + + a.a_gen.a_desc = &vop_openextattr_desc; + a.a_vp = vp; + a.a_cred = cred; + a.a_td = td; + return (VOP_OPENEXTATTR_APV(vp->v_op, &a)); +} + +struct vop_deleteextattr_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + int a_attrnamespace; + const char *a_name; + struct ucred *a_cred; + struct thread *a_td; +}; + +extern struct vnodeop_desc vop_deleteextattr_desc; + +int VOP_DELETEEXTATTR_AP(struct vop_deleteextattr_args *); +int VOP_DELETEEXTATTR_APV(struct vop_vector *vop, struct vop_deleteextattr_args *); + +static __inline int VOP_DELETEEXTATTR( + struct vnode *vp, + int attrnamespace, + const char *name, + struct ucred *cred, + struct thread *td) +{ + struct vop_deleteextattr_args a; + + a.a_gen.a_desc = &vop_deleteextattr_desc; + a.a_vp = vp; + a.a_attrnamespace = attrnamespace; + a.a_name = name; + a.a_cred = cred; + a.a_td = td; + return (VOP_DELETEEXTATTR_APV(vp->v_op, &a)); +} + +struct vop_setextattr_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + int a_attrnamespace; + const char *a_name; + struct uio *a_uio; + struct ucred *a_cred; + struct thread *a_td; +}; + +extern struct vnodeop_desc vop_setextattr_desc; + +int VOP_SETEXTATTR_AP(struct vop_setextattr_args *); +int VOP_SETEXTATTR_APV(struct vop_vector *vop, struct vop_setextattr_args *); + +static __inline int VOP_SETEXTATTR( + struct vnode *vp, + int attrnamespace, + const char *name, + struct uio *uio, + struct ucred *cred, + struct thread *td) +{ + struct vop_setextattr_args a; + + a.a_gen.a_desc = &vop_setextattr_desc; + a.a_vp = vp; + a.a_attrnamespace = attrnamespace; + a.a_name = name; + a.a_uio = uio; + a.a_cred = cred; + a.a_td = td; + return (VOP_SETEXTATTR_APV(vp->v_op, &a)); +} + +struct vop_setlabel_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + struct label *a_label; + struct ucred *a_cred; + struct thread *a_td; +}; + +extern struct vnodeop_desc vop_setlabel_desc; + +int VOP_SETLABEL_AP(struct vop_setlabel_args *); +int VOP_SETLABEL_APV(struct vop_vector *vop, struct vop_setlabel_args *); + +static __inline int VOP_SETLABEL( + struct vnode *vp, + struct label *label, + struct ucred *cred, + struct thread *td) +{ + struct vop_setlabel_args a; + + a.a_gen.a_desc = &vop_setlabel_desc; + a.a_vp = vp; + a.a_label = label; + a.a_cred = cred; + a.a_td = td; + return (VOP_SETLABEL_APV(vp->v_op, &a)); +} + +struct vop_vptofh_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + struct fid *a_fhp; +}; + +extern struct vnodeop_desc vop_vptofh_desc; + +int VOP_VPTOFH_AP(struct vop_vptofh_args *); +int VOP_VPTOFH_APV(struct vop_vector *vop, struct vop_vptofh_args *); + +static __inline int VOP_VPTOFH( + struct vnode *vp, + struct fid *fhp) +{ + struct vop_vptofh_args a; + + a.a_gen.a_desc = &vop_vptofh_desc; + a.a_vp = vp; + a.a_fhp = fhp; + return (VOP_VPTOFH_APV(vp->v_op, &a)); +} + +struct vop_vptocnp_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + struct vnode **a_vpp; + struct ucred *a_cred; + char *a_buf; + int *a_buflen; +}; + +extern struct vnodeop_desc vop_vptocnp_desc; + +int VOP_VPTOCNP_AP(struct vop_vptocnp_args *); +int VOP_VPTOCNP_APV(struct vop_vector *vop, struct vop_vptocnp_args *); + +static __inline int VOP_VPTOCNP( + struct vnode *vp, + struct vnode **vpp, + struct ucred *cred, + char *buf, + int *buflen) +{ + struct vop_vptocnp_args a; + + a.a_gen.a_desc = &vop_vptocnp_desc; + a.a_vp = vp; + a.a_vpp = vpp; + a.a_cred = cred; + a.a_buf = buf; + a.a_buflen = buflen; + return (VOP_VPTOCNP_APV(vp->v_op, &a)); +} + +struct vop_allocate_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + off_t *a_offset; + off_t *a_len; +}; + +extern struct vnodeop_desc vop_allocate_desc; + +int VOP_ALLOCATE_AP(struct vop_allocate_args *); +int VOP_ALLOCATE_APV(struct vop_vector *vop, struct vop_allocate_args *); + +static __inline int VOP_ALLOCATE( + struct vnode *vp, + off_t *offset, + off_t *len) +{ + struct vop_allocate_args a; + + a.a_gen.a_desc = &vop_allocate_desc; + a.a_vp = vp; + a.a_offset = offset; + a.a_len = len; + return (VOP_ALLOCATE_APV(vp->v_op, &a)); +} + +struct vop_advise_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + off_t a_start; + off_t a_end; + int a_advice; +}; + +extern struct vnodeop_desc vop_advise_desc; + +int VOP_ADVISE_AP(struct vop_advise_args *); +int VOP_ADVISE_APV(struct vop_vector *vop, struct vop_advise_args *); + +static __inline int VOP_ADVISE( + struct vnode *vp, + off_t start, + off_t end, + int advice) +{ + struct vop_advise_args a; + + a.a_gen.a_desc = &vop_advise_desc; + a.a_vp = vp; + a.a_start = start; + a.a_end = end; + a.a_advice = advice; + return (VOP_ADVISE_APV(vp->v_op, &a)); +} + +struct vop_unp_bind_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + struct unpcb *a_unpcb; +}; + +extern struct vnodeop_desc vop_unp_bind_desc; + +int VOP_UNP_BIND_AP(struct vop_unp_bind_args *); +int VOP_UNP_BIND_APV(struct vop_vector *vop, struct vop_unp_bind_args *); + +static __inline int VOP_UNP_BIND( + struct vnode *vp, + struct unpcb *unpcb) +{ + struct vop_unp_bind_args a; + + a.a_gen.a_desc = &vop_unp_bind_desc; + a.a_vp = vp; + a.a_unpcb = unpcb; + return (VOP_UNP_BIND_APV(vp->v_op, &a)); +} + +struct vop_unp_connect_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + struct unpcb **a_unpcb; +}; + +extern struct vnodeop_desc vop_unp_connect_desc; + +int VOP_UNP_CONNECT_AP(struct vop_unp_connect_args *); +int VOP_UNP_CONNECT_APV(struct vop_vector *vop, struct vop_unp_connect_args *); + +static __inline int VOP_UNP_CONNECT( + struct vnode *vp, + struct unpcb **unpcb) +{ + struct vop_unp_connect_args a; + + a.a_gen.a_desc = &vop_unp_connect_desc; + a.a_vp = vp; + a.a_unpcb = unpcb; + return (VOP_UNP_CONNECT_APV(vp->v_op, &a)); +} + +struct vop_unp_detach_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; +}; + +extern struct vnodeop_desc vop_unp_detach_desc; + +int VOP_UNP_DETACH_AP(struct vop_unp_detach_args *); +int VOP_UNP_DETACH_APV(struct vop_vector *vop, struct vop_unp_detach_args *); + +static __inline int VOP_UNP_DETACH( + struct vnode *vp) +{ + struct vop_unp_detach_args a; + + a.a_gen.a_desc = &vop_unp_detach_desc; + a.a_vp = vp; + return (VOP_UNP_DETACH_APV(vp->v_op, &a)); +} + +struct vop_is_text_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; +}; + +extern struct vnodeop_desc vop_is_text_desc; + +int VOP_IS_TEXT_AP(struct vop_is_text_args *); +int VOP_IS_TEXT_APV(struct vop_vector *vop, struct vop_is_text_args *); + +static __inline int VOP_IS_TEXT( + struct vnode *vp) +{ + struct vop_is_text_args a; + + a.a_gen.a_desc = &vop_is_text_desc; + a.a_vp = vp; + return (VOP_IS_TEXT_APV(vp->v_op, &a)); +} + +struct vop_set_text_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; +}; + +extern struct vnodeop_desc vop_set_text_desc; + +int VOP_SET_TEXT_AP(struct vop_set_text_args *); +int VOP_SET_TEXT_APV(struct vop_vector *vop, struct vop_set_text_args *); + +static __inline int VOP_SET_TEXT( + struct vnode *vp) +{ + struct vop_set_text_args a; + + a.a_gen.a_desc = &vop_set_text_desc; + a.a_vp = vp; + return (VOP_SET_TEXT_APV(vp->v_op, &a)); +} + +struct vop_unset_text_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; +}; + +extern struct vnodeop_desc vop_unset_text_desc; + +int VOP_UNSET_TEXT_AP(struct vop_unset_text_args *); +int VOP_UNSET_TEXT_APV(struct vop_vector *vop, struct vop_unset_text_args *); + +static __inline int VOP_UNSET_TEXT( + struct vnode *vp) +{ + struct vop_unset_text_args a; + + a.a_gen.a_desc = &vop_unset_text_desc; + a.a_vp = vp; + return (VOP_UNSET_TEXT_APV(vp->v_op, &a)); +} + +struct vop_get_writecount_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + int *a_writecount; +}; + +extern struct vnodeop_desc vop_get_writecount_desc; + +int VOP_GET_WRITECOUNT_AP(struct vop_get_writecount_args *); +int VOP_GET_WRITECOUNT_APV(struct vop_vector *vop, struct vop_get_writecount_args *); + +static __inline int VOP_GET_WRITECOUNT( + struct vnode *vp, + int *writecount) +{ + struct vop_get_writecount_args a; + + a.a_gen.a_desc = &vop_get_writecount_desc; + a.a_vp = vp; + a.a_writecount = writecount; + return (VOP_GET_WRITECOUNT_APV(vp->v_op, &a)); +} + +struct vop_add_writecount_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + int a_inc; +}; + +extern struct vnodeop_desc vop_add_writecount_desc; + +int VOP_ADD_WRITECOUNT_AP(struct vop_add_writecount_args *); +int VOP_ADD_WRITECOUNT_APV(struct vop_vector *vop, struct vop_add_writecount_args *); + +static __inline int VOP_ADD_WRITECOUNT( + struct vnode *vp, + int inc) +{ + struct vop_add_writecount_args a; + + a.a_gen.a_desc = &vop_add_writecount_desc; + a.a_vp = vp; + a.a_inc = inc; + return (VOP_ADD_WRITECOUNT_APV(vp->v_op, &a)); +} + +struct vop_fdatasync_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; + struct thread *a_td; +}; + +extern struct vnodeop_desc vop_fdatasync_desc; + +int VOP_FDATASYNC_AP(struct vop_fdatasync_args *); +int VOP_FDATASYNC_APV(struct vop_vector *vop, struct vop_fdatasync_args *); + +static __inline int VOP_FDATASYNC( + struct vnode *vp, + struct thread *td) +{ + struct vop_fdatasync_args a; + + a.a_gen.a_desc = &vop_fdatasync_desc; + a.a_vp = vp; + a.a_td = td; + return (VOP_FDATASYNC_APV(vp->v_op, &a)); +} + +struct vop_spare1_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; +}; + +extern struct vnodeop_desc vop_spare1_desc; + +int VOP_SPARE1_AP(struct vop_spare1_args *); +int VOP_SPARE1_APV(struct vop_vector *vop, struct vop_spare1_args *); + +static __inline int VOP_SPARE1( + struct vnode *vp) +{ + struct vop_spare1_args a; + + a.a_gen.a_desc = &vop_spare1_desc; + a.a_vp = vp; + return (VOP_SPARE1_APV(vp->v_op, &a)); +} + +struct vop_spare2_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; +}; + +extern struct vnodeop_desc vop_spare2_desc; + +int VOP_SPARE2_AP(struct vop_spare2_args *); +int VOP_SPARE2_APV(struct vop_vector *vop, struct vop_spare2_args *); + +static __inline int VOP_SPARE2( + struct vnode *vp) +{ + struct vop_spare2_args a; + + a.a_gen.a_desc = &vop_spare2_desc; + a.a_vp = vp; + return (VOP_SPARE2_APV(vp->v_op, &a)); +} + +struct vop_spare3_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; +}; + +extern struct vnodeop_desc vop_spare3_desc; + +int VOP_SPARE3_AP(struct vop_spare3_args *); +int VOP_SPARE3_APV(struct vop_vector *vop, struct vop_spare3_args *); + +static __inline int VOP_SPARE3( + struct vnode *vp) +{ + struct vop_spare3_args a; + + a.a_gen.a_desc = &vop_spare3_desc; + a.a_vp = vp; + return (VOP_SPARE3_APV(vp->v_op, &a)); +} + +struct vop_spare4_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; +}; + +extern struct vnodeop_desc vop_spare4_desc; + +int VOP_SPARE4_AP(struct vop_spare4_args *); +int VOP_SPARE4_APV(struct vop_vector *vop, struct vop_spare4_args *); + +static __inline int VOP_SPARE4( + struct vnode *vp) +{ + struct vop_spare4_args a; + + a.a_gen.a_desc = &vop_spare4_desc; + a.a_vp = vp; + return (VOP_SPARE4_APV(vp->v_op, &a)); +} + +struct vop_spare5_args { + struct vop_generic_args a_gen; + struct vnode *a_vp; +}; + +extern struct vnodeop_desc vop_spare5_desc; + +int VOP_SPARE5_AP(struct vop_spare5_args *); +int VOP_SPARE5_APV(struct vop_vector *vop, struct vop_spare5_args *); + +static __inline int VOP_SPARE5( + struct vnode *vp) +{ + struct vop_spare5_args a; + + a.a_gen.a_desc = &vop_spare5_desc; + a.a_vp = vp; + return (VOP_SPARE5_APV(vp->v_op, &a)); +} + diff --git a/rtemsbsd/include/rtems/bsd/local/vnode_if_newproto.h b/rtemsbsd/include/rtems/bsd/local/vnode_if_newproto.h new file mode 100644 index 00000000..b2e2deba --- /dev/null +++ b/rtemsbsd/include/rtems/bsd/local/vnode_if_newproto.h @@ -0,0 +1,84 @@ +/* + * This file is produced automatically. + * Do not modify anything in here by hand. + * + * Created from $FreeBSD$ + */ + + +struct vop_vector { + struct vop_vector *vop_default; + vop_bypass_t *vop_bypass; + vop_islocked_t *vop_islocked; + vop_lookup_t *vop_lookup; + vop_cachedlookup_t *vop_cachedlookup; + vop_create_t *vop_create; + vop_whiteout_t *vop_whiteout; + vop_mknod_t *vop_mknod; + vop_open_t *vop_open; + vop_close_t *vop_close; + vop_access_t *vop_access; + vop_accessx_t *vop_accessx; + vop_getattr_t *vop_getattr; + vop_setattr_t *vop_setattr; + vop_markatime_t *vop_markatime; + vop_read_t *vop_read; + vop_write_t *vop_write; + vop_ioctl_t *vop_ioctl; + vop_poll_t *vop_poll; + vop_kqfilter_t *vop_kqfilter; + vop_revoke_t *vop_revoke; + vop_fsync_t *vop_fsync; + vop_remove_t *vop_remove; + vop_link_t *vop_link; + vop_rename_t *vop_rename; + vop_mkdir_t *vop_mkdir; + vop_rmdir_t *vop_rmdir; + vop_symlink_t *vop_symlink; + vop_readdir_t *vop_readdir; + vop_readlink_t *vop_readlink; + vop_inactive_t *vop_inactive; + vop_reclaim_t *vop_reclaim; + vop_lock1_t *vop_lock1; + vop_unlock_t *vop_unlock; + vop_bmap_t *vop_bmap; + vop_strategy_t *vop_strategy; + vop_getwritemount_t *vop_getwritemount; + vop_print_t *vop_print; + vop_pathconf_t *vop_pathconf; + vop_advlock_t *vop_advlock; + vop_advlockasync_t *vop_advlockasync; + vop_advlockpurge_t *vop_advlockpurge; + vop_reallocblks_t *vop_reallocblks; + vop_getpages_t *vop_getpages; + vop_getpages_async_t *vop_getpages_async; + vop_putpages_t *vop_putpages; + vop_getacl_t *vop_getacl; + vop_setacl_t *vop_setacl; + vop_aclcheck_t *vop_aclcheck; + vop_closeextattr_t *vop_closeextattr; + vop_getextattr_t *vop_getextattr; + vop_listextattr_t *vop_listextattr; + vop_openextattr_t *vop_openextattr; + vop_deleteextattr_t *vop_deleteextattr; + vop_setextattr_t *vop_setextattr; + vop_setlabel_t *vop_setlabel; + vop_vptofh_t *vop_vptofh; + vop_vptocnp_t *vop_vptocnp; + vop_allocate_t *vop_allocate; + vop_advise_t *vop_advise; + vop_unp_bind_t *vop_unp_bind; + vop_unp_connect_t *vop_unp_connect; + vop_unp_detach_t *vop_unp_detach; + vop_is_text_t *vop_is_text; + vop_set_text_t *vop_set_text; + vop_unset_text_t *vop_unset_text; + vop_get_writecount_t *vop_get_writecount; + vop_add_writecount_t *vop_add_writecount; + vop_fdatasync_t *vop_fdatasync; + vop_spare1_t *vop_spare1; + vop_spare2_t *vop_spare2; + vop_spare3_t *vop_spare3; + vop_spare4_t *vop_spare4; + vop_spare5_t *vop_spare5; +}; diff --git a/rtemsbsd/include/rtems/bsd/local/vnode_if_typedef.h b/rtemsbsd/include/rtems/bsd/local/vnode_if_typedef.h new file mode 100644 index 00000000..22204a1f --- /dev/null +++ b/rtemsbsd/include/rtems/bsd/local/vnode_if_typedef.h @@ -0,0 +1,224 @@ +/* + * This file is produced automatically. + * Do not modify anything in here by hand. + * + * Created from $FreeBSD$ + */ + + +struct vop_islocked_args; +typedef int vop_islocked_t(struct vop_islocked_args *); + +struct vop_lookup_args; +typedef int vop_lookup_t(struct vop_lookup_args *); + +struct vop_cachedlookup_args; +typedef int vop_cachedlookup_t(struct vop_cachedlookup_args *); + +struct vop_create_args; +typedef int vop_create_t(struct vop_create_args *); + +struct vop_whiteout_args; +typedef int vop_whiteout_t(struct vop_whiteout_args *); + +struct vop_mknod_args; +typedef int vop_mknod_t(struct vop_mknod_args *); + +struct vop_open_args; +typedef int vop_open_t(struct vop_open_args *); + +struct vop_close_args; +typedef int vop_close_t(struct vop_close_args *); + +struct vop_access_args; +typedef int vop_access_t(struct vop_access_args *); + +struct vop_accessx_args; +typedef int vop_accessx_t(struct vop_accessx_args *); + +struct vop_getattr_args; +typedef int vop_getattr_t(struct vop_getattr_args *); + +struct vop_setattr_args; +typedef int vop_setattr_t(struct vop_setattr_args *); + +struct vop_markatime_args; +typedef int vop_markatime_t(struct vop_markatime_args *); + +struct vop_read_args; +typedef int vop_read_t(struct vop_read_args *); + +struct vop_write_args; +typedef int vop_write_t(struct vop_write_args *); + +struct vop_ioctl_args; +typedef int vop_ioctl_t(struct vop_ioctl_args *); + +struct vop_poll_args; +typedef int vop_poll_t(struct vop_poll_args *); + +struct vop_kqfilter_args; +typedef int vop_kqfilter_t(struct vop_kqfilter_args *); + +struct vop_revoke_args; +typedef int vop_revoke_t(struct vop_revoke_args *); + +struct vop_fsync_args; +typedef int vop_fsync_t(struct vop_fsync_args *); + +struct vop_remove_args; +typedef int vop_remove_t(struct vop_remove_args *); + +struct vop_link_args; +typedef int vop_link_t(struct vop_link_args *); + +struct vop_rename_args; +typedef int vop_rename_t(struct vop_rename_args *); + +struct vop_mkdir_args; +typedef int vop_mkdir_t(struct vop_mkdir_args *); + +struct vop_rmdir_args; +typedef int vop_rmdir_t(struct vop_rmdir_args *); + +struct vop_symlink_args; +typedef int vop_symlink_t(struct vop_symlink_args *); + +struct vop_readdir_args; +typedef int vop_readdir_t(struct vop_readdir_args *); + +struct vop_readlink_args; +typedef int vop_readlink_t(struct vop_readlink_args *); + +struct vop_inactive_args; +typedef int vop_inactive_t(struct vop_inactive_args *); + +struct vop_reclaim_args; +typedef int vop_reclaim_t(struct vop_reclaim_args *); + +struct vop_lock1_args; +typedef int vop_lock1_t(struct vop_lock1_args *); + +struct vop_unlock_args; +typedef int vop_unlock_t(struct vop_unlock_args *); + +struct vop_bmap_args; +typedef int vop_bmap_t(struct vop_bmap_args *); + +struct vop_strategy_args; +typedef int vop_strategy_t(struct vop_strategy_args *); + +struct vop_getwritemount_args; +typedef int vop_getwritemount_t(struct vop_getwritemount_args *); + +struct vop_print_args; +typedef int vop_print_t(struct vop_print_args *); + +struct vop_pathconf_args; +typedef int vop_pathconf_t(struct vop_pathconf_args *); + +struct vop_advlock_args; +typedef int vop_advlock_t(struct vop_advlock_args *); + +struct vop_advlockasync_args; +typedef int vop_advlockasync_t(struct vop_advlockasync_args *); + +struct vop_advlockpurge_args; +typedef int vop_advlockpurge_t(struct vop_advlockpurge_args *); + +struct vop_reallocblks_args; +typedef int vop_reallocblks_t(struct vop_reallocblks_args *); + +struct vop_getpages_args; +typedef int vop_getpages_t(struct vop_getpages_args *); + +struct vop_getpages_async_args; +typedef int vop_getpages_async_t(struct vop_getpages_async_args *); + +struct vop_putpages_args; +typedef int vop_putpages_t(struct vop_putpages_args *); + +struct vop_getacl_args; +typedef int vop_getacl_t(struct vop_getacl_args *); + +struct vop_setacl_args; +typedef int vop_setacl_t(struct vop_setacl_args *); + +struct vop_aclcheck_args; +typedef int vop_aclcheck_t(struct vop_aclcheck_args *); + +struct vop_closeextattr_args; +typedef int vop_closeextattr_t(struct vop_closeextattr_args *); + +struct vop_getextattr_args; +typedef int vop_getextattr_t(struct vop_getextattr_args *); + +struct vop_listextattr_args; +typedef int vop_listextattr_t(struct vop_listextattr_args *); + +struct vop_openextattr_args; +typedef int vop_openextattr_t(struct vop_openextattr_args *); + +struct vop_deleteextattr_args; +typedef int vop_deleteextattr_t(struct vop_deleteextattr_args *); + +struct vop_setextattr_args; +typedef int vop_setextattr_t(struct vop_setextattr_args *); + +struct vop_setlabel_args; +typedef int vop_setlabel_t(struct vop_setlabel_args *); + +struct vop_vptofh_args; +typedef int vop_vptofh_t(struct vop_vptofh_args *); + +struct vop_vptocnp_args; +typedef int vop_vptocnp_t(struct vop_vptocnp_args *); + +struct vop_allocate_args; +typedef int vop_allocate_t(struct vop_allocate_args *); + +struct vop_advise_args; +typedef int vop_advise_t(struct vop_advise_args *); + +struct vop_unp_bind_args; +typedef int vop_unp_bind_t(struct vop_unp_bind_args *); + +struct vop_unp_connect_args; +typedef int vop_unp_connect_t(struct vop_unp_connect_args *); + +struct vop_unp_detach_args; +typedef int vop_unp_detach_t(struct vop_unp_detach_args *); + +struct vop_is_text_args; +typedef int vop_is_text_t(struct vop_is_text_args *); + +struct vop_set_text_args; +typedef int vop_set_text_t(struct vop_set_text_args *); + +struct vop_unset_text_args; +typedef int vop_unset_text_t(struct vop_unset_text_args *); + +struct vop_get_writecount_args; +typedef int vop_get_writecount_t(struct vop_get_writecount_args *); + +struct vop_add_writecount_args; +typedef int vop_add_writecount_t(struct vop_add_writecount_args *); + +struct vop_fdatasync_args; +typedef int vop_fdatasync_t(struct vop_fdatasync_args *); + +struct vop_spare1_args; +typedef int vop_spare1_t(struct vop_spare1_args *); + +struct vop_spare2_args; +typedef int vop_spare2_t(struct vop_spare2_args *); + +struct vop_spare3_args; +typedef int vop_spare3_t(struct vop_spare3_args *); + +struct vop_spare4_args; +typedef int vop_spare4_t(struct vop_spare4_args *); + +struct vop_spare5_args; +typedef int vop_spare5_t(struct vop_spare5_args *); + diff --git a/rtemsbsd/include/rtems/bsd/rootfs.h b/rtemsbsd/include/rtems/bsd/rootfs.h new file mode 100644 index 00000000..b2768c31 --- /dev/null +++ b/rtemsbsd/include/rtems/bsd/rootfs.h @@ -0,0 +1,51 @@ +/** + * @file + * + * @ingroup rtems_bsd + * + * @brief TODO. + */ + +/* + * Copyright (c) 20206 Chris Johns. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _RTEMS_BSD_ROOTFS_H_ +#define _RTEMS_BSD_ROOTFS_H_ + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/* + * Short cut to creating a directory in the root file system. + */ +int rtems_bsd_rootfs_mkdir(const char *name); +int rtems_bsd_rootfs_rmdir(const char *name); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* _RTEMS_BSD_ROOTFS_H_ */ diff --git a/rtemsbsd/include/sys/bio.h b/rtemsbsd/include/sys/bio.h deleted file mode 100644 index 936ffd88..00000000 --- a/rtemsbsd/include/sys/bio.h +++ /dev/null @@ -1 +0,0 @@ -/* EMPTY */ diff --git a/rtemsbsd/include/sys/namei.h b/rtemsbsd/include/sys/namei.h deleted file mode 100644 index 936ffd88..00000000 --- a/rtemsbsd/include/sys/namei.h +++ /dev/null @@ -1 +0,0 @@ -/* EMPTY */ diff --git a/rtemsbsd/include/sys/sysent.h b/rtemsbsd/include/sys/sysent.h deleted file mode 100644 index 936ffd88..00000000 --- a/rtemsbsd/include/sys/sysent.h +++ /dev/null @@ -1 +0,0 @@ -/* EMPTY */ diff --git a/rtemsbsd/include/vm/vm_object.h b/rtemsbsd/include/vm/vm_object.h index 936ffd88..9707a0c6 100644 --- a/rtemsbsd/include/vm/vm_object.h +++ b/rtemsbsd/include/vm/vm_object.h @@ -1 +1,16 @@ -/* EMPTY */ +#ifndef RTEMS_VM_OBJCT_H +#define RTEMS_VM_OBJCT_H + +/* + * Helpers to perform conversion between vm_object page indexes and offsets. + * IDX_TO_OFF() converts an index into an offset. + * OFF_TO_IDX() converts an offset into an index. + * OBJ_MAX_SIZE specifies the maximum page index corresponding to the + * maximum unsigned offset. + */ +#define IDX_TO_OFF(idx) (((vm_ooffset_t)(idx)) << PAGE_SHIFT) +#define OFF_TO_IDX(off) ((vm_pindex_t)(((vm_ooffset_t)(off)) >> PAGE_SHIFT)) +#define UOFF_TO_IDX(off) OFF_TO_IDX(off) +#define OBJ_MAX_SIZE (OFF_TO_IDX(UINT64_MAX) + 1) + +#endif diff --git a/rtemsbsd/include/vm/vm_pager.h b/rtemsbsd/include/vm/vm_pager.h index e69de29b..d9bc1524 100644 --- a/rtemsbsd/include/vm/vm_pager.h +++ b/rtemsbsd/include/vm/vm_pager.h @@ -0,0 +1,20 @@ +#ifndef RTEMS_VM_PAGER_H +#define RTEMS_VM_PAGER_H + +/* + * get/put return values + * OK operation was successful + * BAD specified data was out of the accepted range + * FAIL specified data was in range, but doesn't exist + * PEND operations was initiated but not completed + * ERROR error while accessing data that is in range and exists + * AGAIN temporary resource shortage prevented operation from happening + */ +#define VM_PAGER_OK 0 +#define VM_PAGER_BAD 1 +#define VM_PAGER_FAIL 2 +#define VM_PAGER_PEND 3 +#define VM_PAGER_ERROR 4 +#define VM_PAGER_AGAIN 5 + +#endif diff --git a/rtemsbsd/rtems/rtems-bsd-allocator-domain-size.c b/rtemsbsd/rtems/rtems-bsd-allocator-domain-size.c index 089ba747..0b76ac68 100644 --- a/rtemsbsd/rtems/rtems-bsd-allocator-domain-size.c +++ b/rtemsbsd/rtems/rtems-bsd-allocator-domain-size.c @@ -40,4 +40,7 @@ #include <rtems/bsd/bsd.h> -uintptr_t rtems_bsd_allocator_domain_page_mbuf_size = RTEMS_BSD_ALLOCATOR_DOMAIN_PAGE_MBUF_DEFAULT; +uintptr_t rtems_bsd_allocator_domain_page_mbuf_size = + RTEMS_BSD_ALLOCATOR_DOMAIN_PAGE_MBUF_DEFAULT; +uintptr_t rtems_bsd_allocator_domain_bio_size = + RTEMS_BSD_ALLOCATOR_DOMAIN_BIO_DEFAULT; diff --git a/rtemsbsd/rtems/rtems-bsd-get-allocator-domain-size.c b/rtemsbsd/rtems/rtems-bsd-get-allocator-domain-size.c index d94a719b..c30786c2 100644 --- a/rtemsbsd/rtems/rtems-bsd-get-allocator-domain-size.c +++ b/rtemsbsd/rtems/rtems-bsd-get-allocator-domain-size.c @@ -45,13 +45,16 @@ rtems_bsd_get_allocator_domain_size(rtems_bsd_allocator_domain domain) uintptr_t size; switch (domain) { - case RTEMS_BSD_ALLOCATOR_DOMAIN_PAGE: - case RTEMS_BSD_ALLOCATOR_DOMAIN_MBUF: - size = rtems_bsd_allocator_domain_page_mbuf_size; - break; - default: - size = 0; - break; + case RTEMS_BSD_ALLOCATOR_DOMAIN_PAGE: + case RTEMS_BSD_ALLOCATOR_DOMAIN_MBUF: + size = rtems_bsd_allocator_domain_page_mbuf_size; + break; + case RTEMS_BSD_ALLOCATOR_DOMAIN_BIO: + size = rtems_bsd_allocator_domain_bio_size; + break; + default: + size = 0; + break; } return (size); diff --git a/rtemsbsd/rtems/rtems-bsd-libio.c b/rtemsbsd/rtems/rtems-bsd-libio.c new file mode 100644 index 00000000..bb38594c --- /dev/null +++ b/rtemsbsd/rtems/rtems-bsd-libio.c @@ -0,0 +1,193 @@ +/** + * @file + * + * @ingroup rtems_bsd_rtems + * + * @brief TODO. + */ + +/* + * Copyright 2020 Chris Johns. All Rights Reserved. + * + * Contemporary Software + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE FREEBSD PROJECT ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE FREEBSD PROJECT BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <machine/rtems-bsd-kernel-space.h> + +#include <sys/param.h> +#include <sys/filedesc.h> +#include <sys/proc.h> +#include <sys/vnode.h> + +#include <machine/rtems-bsd-libio.h> + +#include <rtems/libio.h> + +rtems_libio_t * +rtems_bsd_libio_iop_allocate(void) +{ + rtems_libio_t *iop = rtems_libio_allocate(); + if (iop != NULL) { + iop->pathinfo.mt_entry = &rtems_filesystem_null_mt_entry; + rtems_filesystem_location_add_to_mt_entry(&iop->pathinfo); + } + return iop; +} + +int +rtems_bsd_libio_iop_allocate_with_file( + struct thread *td, int fd, const rtems_filesystem_file_handlers_r *ops) +{ + rtems_libio_t *iop = rtems_bsd_libio_iop_allocate(); + int iofd = -1; + if (iop != NULL) { + int error = rtems_bsd_libio_iop_set_bsd_fd(td, fd, iop, ops); + /* + * The fp is held and needs to be dropped and that drops the + * iop. + */ + if (error == 0) { + rtems_libio_iop_hold(iop); + iofd = rtems_libio_iop_to_descriptor(iop); + } else { + rtems_libio_free(iop); + } + } + return iofd; +} + +int +rtems_bsd_libio_iop_set_bsd_fd(struct thread *td, int fd, rtems_libio_t *iop, + const rtems_filesystem_file_handlers_r *ops) +{ + struct filedesc *fdp = td->td_proc->p_fd; + int error; + FILEDESC_XLOCK(fdp); + if (fd < fdp->fd_nfiles) { + struct file *fp = fget_locked(fdp, fd); + if (fp != NULL) { + rtems_bsd_libio_iop_set_bsd_file(iop, fp); + rtems_libio_iop_flags_set(iop, + LIBIO_FLAGS_OPEN | + rtems_bsd_libio_fflag_to_flags(fp->f_flag)); + if (ops != NULL) + iop->pathinfo.handlers = ops; + rtems_bsd_libio_iop_set_bsd_descriptor(iop, fd); + error = 0; + } else { + error = EBADF; + } + } else { + error = EBADF; + } + FILEDESC_XUNLOCK(fdp); + return error; +} + +void +rtems_bsd_libio_loc_set_vnode( + rtems_filesystem_location_info_t *loc, struct vnode *vp) +{ + struct vnode *old = loc->node_access; + int hc = 0; + int rc = 0; + if (vp != NULL) { + hc = vp->v_holdcnt; + rc = vrefcnt(vp); + } + int old_hc = 0; + int old_rc = 0; + if (old != NULL) { + old_hc = old->v_holdcnt; + old_rc = vrefcnt(old); + } + if (vp != old) { + if (old != NULL) + vrele(old); + if (vp != NULL) + VREF(vp); + loc->node_access = vp; + } + int new_hc = 0; + int new_rc = 0; + if (vp != NULL) { + new_hc = vp->v_holdcnt; + new_rc = vrefcnt(vp); + } + int old_new_hc = 0; + int old_new_rc = 0; + if (old != NULL) { + old_new_hc = old->v_holdcnt; + old_new_rc = vrefcnt(old); + } + if (RTEMS_BSD_DESCRIP_TRACE || true) + printf( + "bsd: lio: set-vode loc=%p vn=%p (%d/%d)->(%d/%d) old=%p (%d/%d)->(%d/%d)\n", + loc, vp, hc, rc, new_hc, new_rc, old, old_hc, old_rc, + old_new_hc, old_new_rc); +} + +void +rtems_bsd_libio_loc_set_vnode_dir( + rtems_filesystem_location_info_t *loc, struct vnode *dvp) +{ + struct vnode *old = loc->node_access_2; + int hc = 0; + int rc = 0; + if (dvp != NULL) { + hc = dvp->v_holdcnt; + rc = vrefcnt(dvp); + } + int old_hc = 0; + int old_rc = 0; + if (old != NULL) { + old_hc = old->v_holdcnt; + old_rc = vrefcnt(old); + } + if (dvp != old) { + if (old != NULL) + vrele(old); + if (dvp != NULL) + VREF(dvp); + loc->node_access_2 = dvp; + } + int new_hc = 0; + int new_rc = 0; + if (dvp != NULL) { + new_hc = dvp->v_holdcnt; + new_rc = vrefcnt(dvp); + } + int old_new_hc = 0; + int old_new_rc = 0; + if (old != NULL) { + old_new_hc = old->v_holdcnt; + old_new_rc = vrefcnt(old); + } + if (RTEMS_BSD_DESCRIP_TRACE) + printf( + "bsd: lio: set-vode-dir loc=%p vn=%p (%d/%d)->(%d/%d) old=%p (%d/%d)->(%d/%d)\n", + loc, dvp, hc, rc, new_hc, new_rc, old, old_hc, old_rc, + old_new_hc, old_new_rc); +} diff --git a/rtemsbsd/rtems/rtems-bsd-mountroot.c b/rtemsbsd/rtems/rtems-bsd-mountroot.c new file mode 100644 index 00000000..132a08ff --- /dev/null +++ b/rtemsbsd/rtems/rtems-bsd-mountroot.c @@ -0,0 +1,124 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup FileSystems + * + * @brief Mount a root file system. + */ + +/* + * Copyright (C) 2020 Chris Johns <chris@contemporary.software> + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include <machine/rtems-bsd-kernel-space.h> + +#include <sys/types.h> +#include <sys/param.h> +#include <sys/filedesc.h> +#include <sys/kernel.h> +#include <sys/mount.h> +#include <sys/resourcevar.h> +#include <sys/vnode.h> + +#include <vm/vm_extern.h> + +struct vnode *rootvnode; + +MALLOC_DECLARE(M_MOUNT); + +static void +set_rootvnode(struct mount *mp) +{ + struct proc *p; + int error; + + error = VFS_ROOT(mp, LK_EXCLUSIVE, &rootvnode); + if (error != 0) + panic("Cannot find root vnode"); + + VOP_UNLOCK(rootvnode, 0); + + p = curthread->td_proc; + FILEDESC_XLOCK(p->p_fd); + + if (p->p_fd->fd_cdir != NULL) + vrele(p->p_fd->fd_cdir); + p->p_fd->fd_cdir = rootvnode; + VREF(rootvnode); + + if (p->p_fd->fd_rdir != NULL) + vrele(p->p_fd->fd_rdir); + p->p_fd->fd_rdir = rootvnode; + VREF(rootvnode); + + FILEDESC_XUNLOCK(p->p_fd); +} + +static void +bsd_mountroot(const char *fstype) +{ + struct vfsoptlist *opts; + struct vfsconf *vfsp; + struct mount *mp; + struct ucred *cred; + int error; + + cred = crget(); + cred->cr_uidinfo = uifind(0); + cred->cr_ruidinfo = uifind(0); + + vfsp = vfs_byname(fstype); + if (vfsp != NULL) { + mp = vfs_mount_alloc(NULLVP, vfsp, "/", cred); + + crfree(cred); + + error = VFS_MOUNT(mp); + if (error != 0) + panic("Cannot mount root file system: %d", error); + + error = VFS_STATFS(mp, &mp->mnt_stat); + if (error != 0) + panic("Cannot stat root file system: %d", error); + + opts = malloc(sizeof(struct vfsoptlist), M_MOUNT, M_WAITOK); + TAILQ_INIT(opts); + mp->mnt_opt = opts; + + mtx_lock(&mountlist_mtx); + TAILQ_INSERT_HEAD(&mountlist, mp, mnt_list); + mtx_unlock(&mountlist_mtx); + + set_rootvnode(mp); + } +} + +static void +bsd_rootfs_init(const void *dummy) +{ + bsd_mountroot("rootfs"); +} +SYSINIT(bsdroot, SI_SUB_KTHREAD_INIT, SI_ORDER_FIRST, bsd_rootfs_init, NULL); diff --git a/rtemsbsd/rtems/rtems-bsd-syscall-api.c b/rtemsbsd/rtems/rtems-bsd-syscall-api.c index 63274a0e..434cacbd 100644 --- a/rtemsbsd/rtems/rtems-bsd-syscall-api.c +++ b/rtemsbsd/rtems/rtems-bsd-syscall-api.c @@ -1,26 +1,32 @@ -/* - * Copyright (c) 2013 embedded brains GmbH. All rights reserved. +/** + * @file + * + * @ingroup rtems_bsd_rtems * - * embedded brains GmbH - * Dornierstr. 4 - * 82178 Puchheim - * Germany - * <rtems@embedded-brains.de> + * @brief TODO. + * + * File origin from FreeBSD 'lib/libc/gen/sysctlnametomib.c'. + */ + +/* + * Copyright 2001 The FreeBSD Project. All Rights Reserved. + * Copyright 2020 Chris Johns * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: + * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE - * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * THIS SOFTWARE IS PROVIDED BY THE FREEBSD PROJECT ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE FREEBSD PROJECT BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT @@ -29,4 +35,1507 @@ * SUCH DAMAGE. */ +#if !defined(RTEMS_BSD_CHECK_READDIR_DIRENT) +#define RTEMS_BSD_CHECK_READDIR_DIRENT 0 +#endif + +#include <machine/rtems-bsd-kernel-space.h> + +#include <sys/dirent.h> +#include <sys/file.h> +#include <sys/filedesc.h> +#include <sys/proc.h> +#include <sys/syscallsubr.h> +#include <sys/sysproto.h> +#include <sys/vnode.h> + +#include <machine/rtems-bsd-libio.h> #include <machine/rtems-bsd-syscall-api.h> +#include <machine/rtems-bsd-vfs.h> + +#include <errno.h> +#include <rtems/imfs.h> +#include <rtems/libio.h> +#include <rtems/seterr.h> +#include <stdio.h> + +static int rtems_bsd_sysgen_open_error( + rtems_libio_t *iop, const char *path, int oflag, mode_t mode); +static int rtems_bsd_sysgen_open( + rtems_libio_t *iop, const char *path, int oflag, mode_t mode); +static int rtems_bsd_sysgen_close(rtems_libio_t *iop); +static ssize_t rtems_bsd_sysgen_read( + rtems_libio_t *iop, void *buffer, size_t count); +static ssize_t rtems_bsd_sysgen_readv( + rtems_libio_t *iop, const struct iovec *iov, int iovcnt, ssize_t total); +static ssize_t rtems_bsd_sysgen_write( + rtems_libio_t *iop, const void *buffer, size_t count); +static ssize_t rtems_bsd_sysgen_writev( + rtems_libio_t *iop, const struct iovec *iov, int iovcnt, ssize_t total); +static int rtems_bsd_sysgen_ioctl( + rtems_libio_t *iop, ioctl_command_t request, void *buffer); +static off_t rtems_bsd_sysgen_lseek( + rtems_libio_t *iop, off_t offset, int whence); +static int rtems_bsd_sysgen_vnstat( + const rtems_filesystem_location_info_t *loc, struct stat *buf); +static int rtems_bsd_sysgen_fstat( + const rtems_filesystem_location_info_t *loc, struct stat *buf); +static int rtems_bsd_sysgen_imfsfstat( + const rtems_filesystem_location_info_t *loc, struct stat *buf); +static int rtems_bsd_sysgen_ftruncate(rtems_libio_t *iop, off_t length); +static int rtems_bsd_sysgen_fsync(rtems_libio_t *iop); +static int rtems_bsd_sysgen_fdatasync(rtems_libio_t *iop); +static int rtems_bsd_sysgen_fcntl(rtems_libio_t *iop, int cmd); +static int rtems_bsd_sysgen_poll(rtems_libio_t *iop, int events); +static int rtems_bsd_sysgen_kqfilter(rtems_libio_t *iop, struct knote *kn); + +const rtems_filesystem_file_handlers_r rtems_bsd_sysgen_dirops = { + .open_h = rtems_bsd_sysgen_open, + .close_h = rtems_bsd_sysgen_close, + .read_h = rtems_bsd_sysgen_read, + .write_h = rtems_filesystem_default_write, + .ioctl_h = rtems_filesystem_default_ioctl, + .lseek_h = rtems_filesystem_default_lseek_directory, + .fstat_h = rtems_bsd_sysgen_vnstat, + .ftruncate_h = rtems_filesystem_default_ftruncate_directory, + .fsync_h = rtems_filesystem_default_fsync_or_fdatasync, + .fdatasync_h = rtems_bsd_sysgen_fdatasync, + .fcntl_h = rtems_filesystem_default_fcntl, + .kqfilter_h = rtems_filesystem_default_kqfilter, + .mmap_h = rtems_filesystem_default_mmap, + .poll_h = rtems_filesystem_default_poll, + .readv_h = rtems_filesystem_default_readv, + .writev_h = rtems_filesystem_default_writev +}; + +const rtems_filesystem_file_handlers_r rtems_bsd_sysgen_fileops = { + .open_h = rtems_bsd_sysgen_open, + .close_h = rtems_bsd_sysgen_close, + .read_h = rtems_bsd_sysgen_read, + .write_h = rtems_bsd_sysgen_write, + .ioctl_h = rtems_bsd_sysgen_ioctl, + .lseek_h = rtems_bsd_sysgen_lseek, + .fstat_h = rtems_bsd_sysgen_vnstat, + .ftruncate_h = rtems_bsd_sysgen_ftruncate, + .fsync_h = rtems_filesystem_default_fsync_or_fdatasync, + .fdatasync_h = rtems_bsd_sysgen_fdatasync, + .fcntl_h = rtems_bsd_sysgen_fcntl, + .kqfilter_h = rtems_bsd_sysgen_kqfilter, + .mmap_h = rtems_filesystem_default_mmap, + .poll_h = rtems_bsd_sysgen_poll, + .readv_h = rtems_bsd_sysgen_readv, + .writev_h = rtems_bsd_sysgen_writev +}; + +const rtems_filesystem_file_handlers_r rtems_bsd_sysgen_nodeops = { + .open_h = rtems_bsd_sysgen_open_error, + .close_h = rtems_bsd_sysgen_close, + .read_h = rtems_bsd_sysgen_read, + .write_h = rtems_bsd_sysgen_write, + .ioctl_h = rtems_bsd_sysgen_ioctl, + .lseek_h = rtems_filesystem_default_lseek, + .fstat_h = rtems_bsd_sysgen_fstat, + .ftruncate_h = rtems_filesystem_default_ftruncate, + .fsync_h = rtems_filesystem_default_fsync_or_fdatasync, + .fdatasync_h = rtems_filesystem_default_fsync_or_fdatasync, + .fcntl_h = rtems_bsd_sysgen_fcntl, + .poll_h = rtems_bsd_sysgen_poll, + .kqfilter_h = rtems_bsd_sysgen_kqfilter, + .readv_h = rtems_bsd_sysgen_readv, + .writev_h = rtems_bsd_sysgen_writev, + .mmap_h = rtems_filesystem_default_mmap +}; + +const rtems_filesystem_file_handlers_r rtems_bsd_sysgen_imfsnodeops = { + .open_h = rtems_bsd_sysgen_open_error, + .close_h = rtems_bsd_sysgen_close, + .read_h = rtems_bsd_sysgen_read, + .write_h = rtems_bsd_sysgen_write, + .ioctl_h = rtems_bsd_sysgen_ioctl, + .lseek_h = rtems_filesystem_default_lseek, + .fstat_h = rtems_bsd_sysgen_imfsfstat, + .ftruncate_h = rtems_filesystem_default_ftruncate, + .fsync_h = rtems_filesystem_default_fsync_or_fdatasync, + .fdatasync_h = rtems_filesystem_default_fsync_or_fdatasync, + .fcntl_h = rtems_bsd_sysgen_fcntl, + .poll_h = rtems_bsd_sysgen_poll, + .kqfilter_h = rtems_bsd_sysgen_kqfilter, + .readv_h = rtems_bsd_sysgen_readv, + .writev_h = rtems_bsd_sysgen_writev, + .mmap_h = rtems_filesystem_default_mmap +}; + +int +accept(int socket, struct sockaddr *__restrict address, + socklen_t *__restrict address_len) +{ + struct thread *td; + int error; + struct accept_args ua; + rtems_libio_t *iop; + int afd; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: accept: %d\n", socket); + } + td = rtems_bsd_get_curthread_or_null(); + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + int ffd = rtems_bsd_libio_iop_hold(socket, NULL); + if (ffd < 0) { + return rtems_bsd_error_to_status_and_errno(EBADF); + } + ua.s = ffd; + ua.name = address; + ua.anamelen = address_len; + error = sys_accept(td, &ua); + rtems_bsd_libio_iop_drop(socket); + if (error != 0) { + return rtems_bsd_error_to_status_and_errno(error); + } + iop = rtems_bsd_libio_iop_allocate(); + afd = td->td_retval[0]; + if (iop == NULL) { + kern_close(td, afd); + return rtems_bsd_error_to_status_and_errno(ENFILE); + } + error = rtems_bsd_libio_iop_set_bsd_fd( + td, afd, iop, &rtems_bsd_sysgen_nodeops); + if (error != 0) { + rtems_bsd_libio_iop_free(iop); + kern_close(td, afd); + return rtems_bsd_error_to_status_and_errno(error); + } + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: accept: %d (%d) => %d -> %d\n", socket, ffd, + rtems_libio_iop_to_descriptor(iop), + rtems_bsd_libio_iop_to_descriptor(iop)); + } + return rtems_libio_iop_to_descriptor(iop); +} + +int +bind(int socket, const struct sockaddr *address, socklen_t address_len) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + struct bind_args ua; + int ffd; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: bind: %d\n", socket); + } + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + ffd = rtems_bsd_libio_iop_hold(socket, NULL); + if (ffd == -1) { + return rtems_bsd_error_to_status_and_errno(EBADF); + } + ua.s = ffd; + ua.name = address; + ua.namelen = address_len; + error = sys_bind(td, &ua); + rtems_bsd_libio_iop_drop(socket); + return rtems_bsd_error_to_status_and_errno(error); +} + +int +connect(int socket, const struct sockaddr *address, socklen_t address_len) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + struct connect_args ua; + int ffd; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: connect: %d\n", socket); + } + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + ffd = rtems_bsd_libio_iop_hold(socket, NULL); + if (ffd < 0) { + return rtems_bsd_error_to_status_and_errno(EBADF); + } + ua.s = ffd; + ua.name = address; + ua.namelen = address_len; + error = sys_connect(td, &ua); + rtems_bsd_libio_iop_drop(socket); + return rtems_bsd_error_to_status_and_errno(error); +} + +int +getpeername(int socket, struct sockaddr *__restrict address, + socklen_t *__restrict address_len) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + struct getpeername_args ua; + int ffd; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: getpeername: %d\n", socket); + } + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + ffd = rtems_bsd_libio_iop_hold(socket, NULL); + if (ffd < 0) { + return rtems_bsd_error_to_status_and_errno(EBADF); + } + ua.fdes = ffd; + ua.asa = address; + ua.alen = address_len; + error = sys_getpeername(td, &ua); + rtems_bsd_libio_iop_drop(socket); + return rtems_bsd_error_to_status_and_errno(error); +} + +int +getsockname(int socket, struct sockaddr *__restrict address, + socklen_t *__restrict address_len) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + struct getsockname_args ua; + int ffd; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: getsockname: %d\n", socket); + } + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + ffd = rtems_bsd_libio_iop_hold(socket, NULL); + if (ffd < 0) { + return rtems_bsd_error_to_status_and_errno(EBADF); + } + ua.fdes = ffd; + ua.asa = address; + ua.alen = address_len; + error = sys_getsockname(td, &ua); + rtems_bsd_libio_iop_drop(socket); + return rtems_bsd_error_to_status_and_errno(error); +} + +int +getsockopt(int socket, int level, int option_name, + void *__restrict option_value, socklen_t *__restrict option_len) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + struct getsockopt_args ua; + int ffd; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: getsockopt: %d\n", socket); + } + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + ffd = rtems_bsd_libio_iop_hold(socket, NULL); + if (ffd < 0) { + return rtems_bsd_error_to_status_and_errno(EBADF); + } + ua.s = ffd; + ua.level = level; + ua.name = option_name; + ua.val = (caddr_t)option_value; + ua.avalsize = option_len; + error = sys_getsockopt(td, &ua); + rtems_bsd_libio_iop_drop(socket); + return rtems_bsd_error_to_status_and_errno(error); +} + +int +kqueue(void) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + struct kqueue_args ua = {}; + rtems_libio_t *iop; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: kqueue:\n"); + } + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + iop = rtems_bsd_libio_iop_allocate(); + if (iop == NULL) { + return rtems_bsd_error_to_status_and_errno(ENFILE); + } + error = sys_kqueue(td, &ua); + if (error != 0) { + goto out; + } + error = rtems_bsd_libio_iop_set_bsd_fd( + td, td->td_retval[0], iop, &rtems_bsd_sysgen_nodeops); + if (error == 0) { + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: kqueue: %d -> %d\n", + rtems_libio_iop_to_descriptor(iop), + rtems_bsd_libio_iop_to_descriptor(iop)); + } + return rtems_libio_iop_to_descriptor(iop); + } + kern_close(td, rtems_libio_iop_to_descriptor(iop)); +out: + rtems_bsd_libio_iop_free(iop); + return rtems_bsd_error_to_status_and_errno(error); +} + +__weak_reference(kevent, _kevent); + +int +kevent(int kq, const struct kevent *changelist, int nchanges, + struct kevent *eventlist, int nevents, const struct timespec *timeout) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + struct kevent_args ua; + int ffd; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: kevent: %d\n", kq); + } + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + ffd = rtems_bsd_libio_iop_hold(kq, NULL); + if (ffd < 0) { + return rtems_bsd_error_to_status_and_errno(EBADF); + } + ua.fd = ffd; + ua.changelist = changelist; + ua.nchanges = nchanges; + ua.eventlist = eventlist; + ua.nevents = nevents; + ua.timeout = timeout; + error = sys_kevent(td, &ua); + rtems_bsd_libio_iop_drop(kq); + if (error != 0) { + return rtems_bsd_error_to_status_and_errno(error); + } + return td->td_retval[0]; +} + +int +listen(int socket, int backlog) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + struct listen_args ua; + int ffd; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: listen: %d\n", socket); + } + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + ffd = rtems_bsd_libio_iop_hold(socket, NULL); + if (ffd < 0) { + return rtems_bsd_error_to_status_and_errno(EBADF); + } + ua.s = ffd; + ua.backlog = backlog; + error = sys_listen(td, &ua); + rtems_bsd_libio_iop_drop(socket); + return rtems_bsd_error_to_status_and_errno(error); +} + +int +pipe(int fildes[2]) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + rtems_libio_t *iop[2]; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: pipe: %d\n", socket); + } + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + iop[0] = rtems_bsd_libio_iop_allocate(); + if (iop[0] == NULL) { + return rtems_bsd_error_to_status_and_errno(ENFILE); + } + iop[1] = rtems_bsd_libio_iop_allocate(); + if (iop[1] == NULL) { + rtems_bsd_libio_iop_free(iop[0]); + return rtems_bsd_error_to_status_and_errno(ENFILE); + } + error = kern_pipe(td, fildes, 0, NULL, NULL); + if (error != 0) { + goto out; + } + error = rtems_bsd_libio_iop_set_bsd_fd( + td, fildes[0], iop[0], &rtems_bsd_sysgen_nodeops); + if (error != 0) { + goto out; + } + error = rtems_bsd_libio_iop_set_bsd_fd( + td, fildes[1], iop[1], &rtems_bsd_sysgen_nodeops); + if (error == 0) { + fildes[0] = rtems_libio_iop_to_descriptor(iop[0]); + fildes[1] = rtems_libio_iop_to_descriptor(iop[1]); + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: pipe: %d -> %d, %d -> %d\n", + fildes[0], + rtems_bsd_libio_iop_to_descriptor(iop[0]), + fildes[1], + rtems_bsd_libio_iop_to_descriptor(iop[1])); + } + return 0; + } +out: + kern_close(td, rtems_bsd_libio_iop_to_descriptor(iop[0])); + kern_close(td, rtems_bsd_libio_iop_to_descriptor(iop[1])); + rtems_bsd_libio_iop_free(iop[0]); + rtems_bsd_libio_iop_free(iop[1]); + return rtems_bsd_error_to_status_and_errno(error); +} + +int +poll(struct pollfd fds[], nfds_t nfds, int timeout) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + struct poll_args ua; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: poll: %d\n", nfds); + } + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + /* + * Pass libio descriptors through as libio and bsd descriptors + * can be in the list at the same time. + */ + ua.fds = &fds[0]; + ua.nfds = nfds; + ua.timeout = timeout; + error = sys_poll(td, &ua); + if (error != 0) { + return rtems_bsd_error_to_status_and_errno(error); + } + return td->td_retval[0]; +} + +int +pselect(int nfds, fd_set *readfds, fd_set *writefds, fd_set *errorfds, + const struct timespec *timeout, const sigset_t *set) +{ + struct thread *td; + struct timeval tv; + struct timeval *tvp; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: pselect: %d\n", nfds); + } + if (set != NULL) { + return rtems_bsd_error_to_status_and_errno(ENOSYS); + } + td = rtems_bsd_get_curthread_or_null(); + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + if (timeout != NULL) { + TIMESPEC_TO_TIMEVAL(&tv, timeout); + tvp = &tv; + } else { + tvp = NULL; + } + /* + * Pass libio descriptors through as libio and bsd descriptors + * can be in the list at the same time. + */ + error = kern_select( + td, nfds, readfds, writefds, errorfds, tvp, NFDBITS); + if (error != 0) { + return rtems_bsd_error_to_status_and_errno(error); + } + return td->td_retval[0]; +} + +ssize_t +recvfrom(int socket, void *__restrict buffer, size_t length, int flags, + struct sockaddr *__restrict address, socklen_t *__restrict address_len) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + struct recvfrom_args ua; + int ffd; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: recvfrom: %d\n", socket); + } + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + ffd = rtems_bsd_libio_iop_hold(socket, NULL); + if (ffd < 0) { + return rtems_bsd_error_to_status_and_errno(EBADF); + } + ua.s = ffd; + ua.buf = buffer; + ua.len = length; + ua.flags = flags; + ua.from = address; + ua.fromlenaddr = address_len; + error = sys_recvfrom(td, &ua); + rtems_bsd_libio_iop_drop(socket); + if (error != 0) { + return rtems_bsd_error_to_status_and_errno(error); + } + return td->td_retval[0]; +} + +ssize_t +recvmsg(int socket, struct msghdr *message, int flags) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + struct recvmsg_args ua; + int ffd; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: recvmsg: %d\n", socket); + } + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + ffd = rtems_bsd_libio_iop_hold(socket, NULL); + if (ffd < 0) { + return rtems_bsd_error_to_status_and_errno(EBADF); + } + ua.s = ffd; + ua.msg = message; + ua.flags = flags; + error = sys_recvmsg(td, &ua); + rtems_bsd_libio_iop_drop(socket); + if (error != 0) { + return rtems_bsd_error_to_status_and_errno(error); + } + return td->td_retval[0]; +} + +int +select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *errorfds, + struct timeval *timeout) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: select: %d\n", nfds); + } + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + /* + * Pass libio descriptors through as libio and bsd descriptors + * can be in the list at the same time. + */ + error = kern_select( + td, nfds, readfds, writefds, errorfds, timeout, NFDBITS); + if (error != 0) { + return rtems_bsd_error_to_status_and_errno(error); + } + return td->td_retval[0]; +} + +ssize_t +sendto(int socket, const void *message, size_t length, int flags, + const struct sockaddr *dest_addr, socklen_t dest_len) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + struct sendto_args ua; + int ffd; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: sendto: %d\n", socket); + } + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + ffd = rtems_bsd_libio_iop_hold(socket, NULL); + if (ffd < 0) { + return rtems_bsd_error_to_status_and_errno(EBADF); + } + ua.s = ffd; + ua.buf = (caddr_t)message; + ua.len = length; + ua.flags = flags; + ua.to = dest_addr; + ua.tolen = dest_len; + error = sys_sendto(td, &ua); + rtems_bsd_libio_iop_drop(socket); + if (error != 0) { + return rtems_bsd_error_to_status_and_errno(error); + } + return td->td_retval[0]; +} + +ssize_t +sendmsg(int socket, const struct msghdr *message, int flags) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + struct sendmsg_args ua; + int ffd; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: sendmsg: %d\n", socket); + } + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + ffd = rtems_bsd_libio_iop_hold(socket, NULL); + if (ffd < 0) { + return rtems_bsd_error_to_status_and_errno(EBADF); + } + ua.s = ffd; + ua.msg = message; + ua.flags = flags; + error = sys_sendmsg(td, &ua); + rtems_bsd_libio_iop_drop(socket); + return rtems_bsd_error_to_status_and_errno(error); +} + +int +setfib(int fibnum) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + int error; + if (td != NULL) { + struct setfib_args ua = { .fibnum = fibnum }; + error = sys_setfib(td, &ua); + } else { + error = ENOMEM; + } + return rtems_bsd_error_to_status_and_errno(error); +} + +int +setsockopt(int socket, int level, int option_name, const void *option_value, + socklen_t option_len) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + struct setsockopt_args ua; + int ffd; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: setsockopt: %d\n", socket); + } + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + ffd = rtems_bsd_libio_iop_hold(socket, NULL); + if (ffd < 0) { + return rtems_bsd_error_to_status_and_errno(EBADF); + } + ua.s = ffd; + ua.level = level; + ua.name = option_name; + ua.val = __DECONST(void *, option_value); + ua.valsize = option_len; + error = sys_setsockopt(td, &ua); + rtems_bsd_libio_iop_drop(socket); + return rtems_bsd_error_to_status_and_errno(error); +} + +int +shutdown(int socket, int how) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + int ffd; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: shutdown: %d\n", socket); + } + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + ffd = rtems_bsd_libio_iop_hold(socket, NULL); + if (ffd < 0) { + return rtems_bsd_error_to_status_and_errno(EBADF); + } + if (rtems_bsd_is_libbsd_descriptor(rtems_libio_iop(socket))) { + struct shutdown_args ua = { .s = ffd, .how = how }; + error = sys_shutdown(td, &ua); + } else { + error = ENOTSOCK; + } + rtems_bsd_libio_iop_drop(socket); + return rtems_bsd_error_to_status_and_errno(error); +} + +int +socket(int domain, int type, int protocol) +{ + struct thread *td; + rtems_libio_t *iop; + struct socket_args ua; + int error; + td = rtems_bsd_get_curthread_or_null(); + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + iop = rtems_bsd_libio_iop_allocate(); + if (iop == NULL) { + return rtems_bsd_error_to_status_and_errno(ENFILE); + } + ua.domain = domain; + ua.type = type; + ua.protocol = protocol; + error = sys_socket(td, &ua); + if (error != 0) { + rtems_bsd_libio_iop_free(iop); + return rtems_bsd_error_to_status_and_errno(error); + } + error = rtems_bsd_libio_iop_set_bsd_fd( + td, td->td_retval[0], iop, &rtems_bsd_sysgen_nodeops); + if (error != 0) { + kern_close(td, td->td_retval[0]); + rtems_bsd_libio_iop_free(iop); + return rtems_bsd_error_to_status_and_errno(error); + } + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: socket: %d -> %d\n", + rtems_libio_iop_to_descriptor(iop), + rtems_bsd_libio_iop_to_descriptor(iop)); + } + return rtems_libio_iop_to_descriptor(iop); +} + +int +socketpair(int domain, int type, int protocol, int *socket_vector) +{ + struct thread *td; + rtems_libio_t *iop[2]; + struct socketpair_args ua; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: socketpair:\n"); + } + td = rtems_bsd_get_curthread_or_null(); + if (td == NULL) { + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + iop[0] = rtems_bsd_libio_iop_allocate(); + if (iop[0] == NULL) { + return rtems_bsd_error_to_status_and_errno(ENFILE); + } + iop[1] = rtems_bsd_libio_iop_allocate(); + if (iop[1] == NULL) { + rtems_bsd_libio_iop_free(iop[0]); + return rtems_bsd_error_to_status_and_errno(ENFILE); + } + ua.domain = domain; + ua.type = type; + ua.protocol = protocol; + ua.rsv = socket_vector; + error = sys_socketpair(td, &ua); + if (error != 0) { + goto out; + } + error = rtems_bsd_libio_iop_set_bsd_fd( + td, socket_vector[0], iop[0], &rtems_bsd_sysgen_nodeops); + if (error != 0) { + goto out; + } + error = rtems_bsd_libio_iop_set_bsd_fd( + td, socket_vector[1], iop[1], &rtems_bsd_sysgen_nodeops); + if (error == 0) { + socket_vector[0] = rtems_libio_iop_to_descriptor(iop[0]); + socket_vector[1] = rtems_libio_iop_to_descriptor(iop[1]); + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: socketpair: %d -> %d, %d -> %d\n", + socket_vector[0], + rtems_bsd_libio_iop_to_descriptor(iop[0]), + socket_vector[1], + rtems_bsd_libio_iop_to_descriptor(iop[1])); + } + return 0; + } +out: + kern_close(td, rtems_bsd_libio_iop_to_descriptor(iop[0])); + kern_close(td, rtems_bsd_libio_iop_to_descriptor(iop[1])); + rtems_bsd_libio_iop_free(iop[0]); + rtems_bsd_libio_iop_free(iop[1]); + return rtems_bsd_error_to_status_and_errno(error); +} + +int +sysctl(const int *name, u_int namelen, void *oldp, size_t *oldlenp, + const void *newp, size_t newlen) +{ + int error = EINVAL; + if (namelen <= CTL_MAXNAME) { + int namedup[CTL_MAXNAME]; + memcpy(namedup, name, namelen * sizeof(*name)); + error = kernel_sysctl(NULL, namedup, namelen, oldp, oldlenp, + RTEMS_DECONST(void *, newp), newlen, oldlenp, 0); + } + return rtems_bsd_error_to_status_and_errno(error); +} + +/* + * File origin from FreeBSD 'lib/libc/gen/sysctlbyname.c'. + * + * ---------------------------------------------------------------------------- + * "THE BEER-WARE LICENSE" (Revision 42): + * <phk@FreeBSD.org> wrote this file. As long as you retain this notice you + * can do whatever you want with this stuff. If we meet some day, and you think + * this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp + * ---------------------------------------------------------------------------- + * + */ +int +sysctlbyname(const char *name, void *oldp, size_t *oldlenp, const void *newp, + size_t newlen) +{ + int real_oid[CTL_MAXNAME + 2]; + int error; + size_t oidlen; + oidlen = sizeof(real_oid) / sizeof(int); + error = sysctlnametomib(name, real_oid, &oidlen); + if (error < 0) + return (error); + error = sysctl(real_oid, oidlen, oldp, oldlenp, newp, newlen); + return rtems_bsd_error_to_status_and_errno(error); +} + +/* + * File origin from FreeBSD 'lib/libc/gen/sysctlnametomib.c'. + * + * This function uses a presently undocumented interface to the kernel + * to walk the tree and get the type so it can print the value. + * This interface is under work and consideration, and should probably + * be killed with a big axe by the first person who can find the time. + * (be aware though, that the proper interface isn't as obvious as it + * may seem, there are various conflicting requirements. + */ +int +sysctlnametomib(const char *name, int *mibp, size_t *sizep) +{ + int oid[2]; + int error; + oid[0] = 0; + oid[1] = 3; + *sizep *= sizeof(int); + error = sysctl(oid, 2, mibp, sizep, name, strlen(name)); + *sizep /= sizeof(int); + return (error); +} + +static int +rtems_bsd_sysgen_open_error( + rtems_libio_t *iop, const char *path, int oflag, mode_t mode) +{ + return rtems_bsd_error_to_status_and_errno(ENXIO); +} + +int +rtems_bsd_sysgen_open( + rtems_libio_t *iop, const char *path, int oflag, mode_t mode) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + struct filedesc *fdp; + struct file *fp; + const bool creat = (oflag & O_CREAT) == O_CREAT; + struct vnode *cdir; + struct vnode *rdir; + const char *opath; + int opathlen; + int fd; + int error; + + if (td == NULL) { + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: open: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + + fdp = td->td_proc->p_fd; + + /* + * There is no easy or clean means to open a vnode and follow the + * POSIX open semantics. You can open a vnode but the extra + * functionality such as create and truncate are not part of the + * basic vnode open. All the calls that provide that functionality + * take a path as the argument. As a result find the last token in + * the path and use the parent directory vnode to position ourselves + * in the parent directory. The pathloc vnode points to the '.' or + * '..' directory. + */ + opath = path + strlen(path); + opathlen = 0; + while (opath != path && !rtems_filesystem_is_delimiter(opath[-1])) { + opath--; + opathlen++; + } + if (rtems_filesystem_is_current_directory(opath, opathlen) || + rtems_filesystem_is_parent_directory(opath, opathlen)) { + if (((oflag + 1) & _FWRITE) == _FWRITE) { + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: open: write to . or ..\n"); + } + return rtems_bsd_error_to_status_and_errno(EPERM); + } + opath = "."; + cdir = rtems_bsd_libio_loc_to_vnode(&iop->pathinfo); + } else { + rtems_filesystem_location_info_t *rootloc = + &iop->pathinfo.mt_entry->mt_fs_root->location; + cdir = rtems_bsd_libio_loc_to_vnode_dir(&iop->pathinfo); + if (fdp->fd_cdir == NULL || + rtems_bsd_libio_loc_to_vnode(&iop->pathinfo) == + rtems_bsd_libio_loc_to_vnode(rootloc)) { + cdir = rtems_bsd_libio_loc_to_vnode(rootloc); + } + } + + FILEDESC_XLOCK(fdp); + rdir = fdp->fd_cdir; + fdp->fd_cdir = cdir; + cdir = rdir; + rdir = fdp->fd_rdir; + fdp->fd_rdir = fdp->fd_cdir; + FILEDESC_XUNLOCK(fdp); + + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: open: path=%s opath=%s vn=%p cwd=%p" + " flags=%08x mode=%08x\n", + path, opath, + creat ? NULL : rtems_bsd_libio_loc_to_vnode(&iop->pathinfo), + fdp->fd_cdir, oflag, mode); + } + + VREF(fdp->fd_cdir); + + error = kern_openat(td, AT_FDCWD, RTEMS_DECONST(char *, opath), + UIO_USERSPACE, oflag, mode); + + vrele(fdp->fd_cdir); + + if (error != 0) { + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: open: error = (%d) %s\n", error, + strerror(error)); + } + return rtems_bsd_error_to_status_and_errno(error); + } + + fd = td->td_retval[0]; + + FILEDESC_XLOCK(fdp); + fdp->fd_cdir = cdir; + fdp->fd_rdir = rdir; + if (fd < fdp->fd_nfiles) { + struct vnode *vn; + fp = fget_locked(fdp, fd); + if (fp != NULL) { + vn = fp->f_vnode; + } else { + vn = NULL; + } + rtems_bsd_libio_loc_set_vnode(&iop->pathinfo, vn); + } + FILEDESC_XUNLOCK(fdp); + + rtems_bsd_libio_iop_set_bsd_fd(td, fd, iop, &rtems_bsd_sysgen_fileops); + + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: open: fd = %d vn=%p\n", fd, + rtems_bsd_libio_loc_to_vnode(&iop->pathinfo)); + } + + return 0; +} + +int +rtems_bsd_sysgen_close(rtems_libio_t *iop) +{ + struct thread *td = curthread; + int error; + int ffd = rtems_bsd_libio_iop_to_descriptor(iop); + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: close: %d -> %d\n", + rtems_libio_iop_to_descriptor(iop), ffd); + } + if (td != NULL) { + if (ffd >= 0) { + rtems_libio_iop_hold(iop); + error = kern_close(td, ffd); + } else { + error = EBADF; + } + } else { + error = ENOMEM; + } + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: close: %d: %d: %s\n", + rtems_libio_iop_to_descriptor(iop), error, strerror(error)); + } + return rtems_bsd_error_to_status_and_errno(error); +} + +ssize_t +rtems_bsd_sysgen_read(rtems_libio_t *iop, void *buffer, size_t count) +{ + struct thread *td = curthread; + struct vnode *vp = rtems_bsd_libio_iop_to_vnode(iop); + int fd = rtems_bsd_libio_iop_to_descriptor(iop); + int error; + ssize_t size = 0; + + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: read: %d -> %d: vn=%p len=%d\n", + rtems_libio_iop_to_descriptor(iop), fd, vp, count); + } + + if (td == NULL) { + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: read: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + + if (count > IOSIZE_MAX) + return rtems_bsd_error_to_status_and_errno(EINVAL); + + if (vp != NULL && vp->v_type == VDIR) { + off_t offset; + error = kern_getdirentries( + td, fd, buffer, count, &iop->offset, NULL, UIO_USERSPACE); + size = td->td_retval[0]; + if (RTEMS_BSD_CHECK_READDIR_DIRENT) { + /* + * Helper code for integration of a file system. The + * FreeBSD kernel dirent and the newlib structs are not + * the same format. + */ + size_t offset = 0; + int c = 0; + printk( + "bsd: sys: readdir: buffer: %p count:%d: size=%d\n", + buffer, count, size); + while (offset < size) { + struct dirent *dp = + (struct dirent *)(((char *)buffer) + + offset); + printk( + "dirent: %3d: dp=%p off=%d rl=%-3d fn=%-6d name=%-3d '", + c, dp, (int)dp->d_off, (int)dp->d_reclen, + (int)dp->d_fileno, (int)dp->d_namlen); + if (dp->d_namlen < sizeof(dp->d_name)) { + for (int i = 0; i < dp->d_namlen; ++i) { + printk("%c", dp->d_name[i]); + } + } else { + printk("INVALID NAME LENGTH"); + } + printk("'\n"); + if (dp->d_reclen <= 0) { + break; + } + c++; + offset += dp->d_reclen; + if (offset > count) { + printf("dirent: buffer overflow\n"); + } + } + } + } else { + struct iovec aiov = { .iov_base = buffer, .iov_len = count }; + struct uio auio = { .uio_iov = &aiov, + .uio_iovcnt = 1, + .uio_offset = iop->offset, + .uio_resid = count, + .uio_segflg = UIO_USERSPACE, + .uio_rw = UIO_READ, + .uio_td = td }; + error = kern_readv( + td, rtems_bsd_libio_iop_to_descriptor(iop), &auio); + if (error == 0) + size = td->td_retval[0]; + } + + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: read: %d: %d: %s size=%i\n", + rtems_libio_iop_to_descriptor(iop), error, strerror(error), + size); + } + + if (error != 0) + return rtems_bsd_error_to_status_and_errno(error); + + return size; +} + +ssize_t +rtems_bsd_sysgen_readv( + rtems_libio_t *iop, const struct iovec *iov, int iovcnt, ssize_t total) +{ + struct thread *td = curthread; + struct uio auio; + int error; + + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: readv: %d len=%d\n", + rtems_libio_iop_to_descriptor(iop), total); + } + + if (td == NULL) { + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: readv: readv: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + + if (total > IOSIZE_MAX) + return rtems_bsd_error_to_status_and_errno(EINVAL); + + auio.uio_iov = RTEMS_DECONST(struct iovec *, iov); + auio.uio_iovcnt = iovcnt; + auio.uio_resid = total; + auio.uio_segflg = UIO_USERSPACE; + + error = kern_readv(td, rtems_bsd_libio_iop_to_descriptor(iop), &auio); + + if (error != 0) + return rtems_bsd_error_to_status_and_errno(error); + + return td->td_retval[0]; +} + +ssize_t +rtems_bsd_sysgen_write(rtems_libio_t *iop, const void *buffer, size_t count) +{ + struct thread *td = curthread; + struct uio auio; + struct iovec aiov; + int error; + + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: write: %d len=%d\n", + rtems_libio_iop_to_descriptor(iop), count); + } + + if (td == NULL) { + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: write: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + + if (count > IOSIZE_MAX) + return (EINVAL); + + aiov.iov_base = RTEMS_DECONST(void *, buffer); + aiov.iov_len = count; + auio.uio_iov = &aiov; + auio.uio_iovcnt = 1; + auio.uio_resid = count; + auio.uio_segflg = UIO_USERSPACE; + + error = kern_writev(td, rtems_bsd_libio_iop_to_descriptor(iop), &auio); + + if (error != 0) + return rtems_bsd_error_to_status_and_errno(error); + + return td->td_retval[0]; +} + +ssize_t +rtems_bsd_sysgen_writev( + rtems_libio_t *iop, const struct iovec *iov, int iovcnt, ssize_t total) +{ + struct thread *td = curthread; + struct uio auio; + int error; + + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: writev: %d iocnt=%d len=%d\n", + rtems_libio_iop_to_descriptor(iop), iovcnt, total); + } + + if (total > IOSIZE_MAX) + return EINVAL; + + if (td == NULL) { + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: writev: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + + auio.uio_iov = RTEMS_DECONST(struct iovec *, iov); + auio.uio_iovcnt = iovcnt; + auio.uio_resid = total; + auio.uio_segflg = UIO_USERSPACE; + + error = kern_writev(td, rtems_bsd_libio_iop_to_descriptor(iop), &auio); + + if (error != 0) + return rtems_bsd_error_to_status_and_errno(error); + + return td->td_retval[0]; +} + +int +rtems_bsd_sysgen_ioctl( + rtems_libio_t *iop, ioctl_command_t request, void *buffer) +{ + struct thread *td = curthread; + u_long com = request & 0xffffffff; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: ioctl: %d req=%08x\n", + rtems_libio_iop_to_descriptor(iop), com); + } + if (td == NULL) { + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: ioctl: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + error = kern_ioctl( + td, rtems_bsd_libio_iop_to_descriptor(iop), com, buffer); + return rtems_bsd_error_to_status_and_errno(error); +} + +off_t +rtems_bsd_sysgen_lseek(rtems_libio_t *iop, off_t offset, int whence) +{ + struct thread *td = curthread; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: lseek: %d offset=%zu whence=%d\n", + rtems_libio_iop_to_descriptor(iop), offset, whence); + } + if (td == NULL) { + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: lseek: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + error = kern_lseek( + td, rtems_bsd_libio_iop_to_descriptor(iop), offset, whence); + if (error != 0) { + return rtems_bsd_error_to_status_and_errno(error); + } + return td->td_uretoff.tdu_off; +} + +int +rtems_bsd_sysgen_vnstat( + const rtems_filesystem_location_info_t *loc, struct stat *buf) +{ + struct thread *td = curthread; + struct vnode *vp = rtems_bsd_libio_loc_to_vnode(loc); + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: vnstat: %p\n", vp); + } + if (td == NULL) { + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: vnstat: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + if (vp == NULL) + error = EFAULT; + else { + VOP_LOCK(vp, LK_SHARED); + error = vn_stat(vp, buf, td->td_ucred, NOCRED, td); + VOP_UNLOCK(vp, 0); + } + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: vnstat: exit %p\n", vp); + } + return rtems_bsd_error_to_status_and_errno(error); +} + +int +rtems_bsd_sysgen_fstat( + const rtems_filesystem_location_info_t *loc, struct stat *buf) +{ + struct thread *td = curthread; + rtems_libio_t *iop = rtems_bsd_libio_loc_to_iop(loc); + struct filedesc *fdp; + struct file *fp = NULL; + int fd; + int error; + if (iop == NULL) { + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: ffile: no iop\n"); + } + return rtems_bsd_error_to_status_and_errno(ENXIO); + } + fd = rtems_bsd_libio_iop_to_descriptor(iop); + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: fstat: %d\n", fd); + } + if (td == NULL) { + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: fstat: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + fdp = td->td_proc->p_fd; + FILEDESC_XLOCK(fdp); + if (fd < fdp->fd_nfiles) { + fp = fget_locked(fdp, fd); + } + FILEDESC_XUNLOCK(fdp); + if (fp != NULL) { + error = fo_stat(fp, buf, NULL, td); + } else { + error = EBADF; + } + return rtems_bsd_error_to_status_and_errno(error); +} + +int +rtems_bsd_sysgen_imfsfstat( + const rtems_filesystem_location_info_t *loc, struct stat *buf) +{ + struct thread *td = curthread; + struct socket *so = rtems_bsd_libio_imfs_loc_to_so(loc); + struct filedesc *fdp; + struct file *fp = NULL; + struct socket *fd_so = NULL; + int fd; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: imfsfstat: socket=%p\n", so); + } + if (td == NULL) { + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: fstat: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + fdp = td->td_proc->p_fd; + FILEDESC_XLOCK(fdp); + for (fd = 0; fd < fdp->fd_nfiles; fd++) { + fp = fget_locked(fdp, fd); + fd_so = fp->f_data; + if (so == fd_so) { + break; + } + fp = NULL; + } + FILEDESC_XUNLOCK(fdp); + if (fp != NULL) { + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: imfsfstat: %d\n", fd); + } + error = fo_stat(fp, buf, NULL, td); + } else { + error = EBADF; + } + return rtems_bsd_error_to_status_and_errno(error); +} + +int +rtems_bsd_sysgen_ftruncate(rtems_libio_t *iop, off_t length) +{ + struct thread *td = curthread; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: ftruncate: len=%d\n", length); + } + if (td == NULL) { + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: ftruncate: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + error = kern_ftruncate( + td, rtems_bsd_libio_iop_to_descriptor(iop), length); + return rtems_bsd_error_to_status_and_errno(error); +} + +int +rtems_bsd_sysgen_fsync(rtems_libio_t *iop) +{ + struct thread *td = curthread; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: fsync\n"); + } + if (td == NULL) { + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: fsync: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + error = kern_fsync(td, rtems_bsd_libio_iop_to_descriptor(iop), true); + return rtems_bsd_error_to_status_and_errno(error); +} + +int +rtems_bsd_sysgen_fdatasync(rtems_libio_t *iop) +{ + struct thread *td = curthread; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: fdatasync\n"); + } + if (td == NULL) { + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: fdatasync: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + error = kern_fsync(td, rtems_bsd_libio_iop_to_descriptor(iop), false); + return rtems_bsd_error_to_status_and_errno(error); +} + +int +rtems_bsd_sysgen_fcntl(rtems_libio_t *iop, int cmd) +{ + struct thread *td = curthread; + intptr_t arg; + int error; + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: fcntl: %d cmd=%d\n", + rtems_libio_iop_to_descriptor(iop), cmd); + } + if (td == NULL) { + if (RTEMS_BSD_SYSCALL_TRACE) { + printf("bsd: sys: fcntl: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + switch (cmd) { + case F_SETFD: + arg = rtems_libio_to_fcntl_flags(rtems_libio_iop_flags(iop)) & + FD_CLOEXEC; + break; + case F_SETFL: + arg = rtems_libio_to_fcntl_flags(rtems_libio_iop_flags(iop)) & + FCNTLFLAGS; + break; + default: + arg = -1; + error = 0; + break; + } + if (arg >= 0) { + error = kern_fcntl( + td, rtems_bsd_libio_iop_to_descriptor(iop), cmd, arg); + /* no return path with the RTEMS API for get calls */ + } + return rtems_bsd_error_to_status_and_errno(error); +} + +int +rtems_bsd_sysgen_poll(rtems_libio_t *iop, int events) +{ + printf("rtems_bsd_sysgen_poll called!\n"); + return rtems_bsd_error_to_status_and_errno(EOPNOTSUPP); +} + +int +rtems_bsd_sysgen_kqfilter(rtems_libio_t *iop, struct knote *kn) +{ + printf("rtems_bsd_sysgen_kqfilter called!\n"); + return rtems_bsd_error_to_status_and_errno(EOPNOTSUPP); +} diff --git a/rtemsbsd/rtems/rtems-kernel-capability.c b/rtemsbsd/rtems/rtems-kernel-capability.c new file mode 100644 index 00000000..3d3787da --- /dev/null +++ b/rtemsbsd/rtems/rtems-kernel-capability.c @@ -0,0 +1,71 @@ +/** + * @file + * + * @ingroup rtems_bsd_rtems + * + * @brief TODO. + */ + +/* + * Copyright (c) 2020 Chris Johns + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <machine/rtems-bsd-kernel-space.h> + +#include <sys/types.h> +#include <sys/caprights.h> + +cap_rights_t cap_no_rights; + +#define RTEMS_BSD_CAP_ALIAS(var, tar) \ + extern int __attribute__((alias("_bsd_" #var))) _bsd_##tar; + +#ifdef INVARIANT_SUPPORT +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_rights_is_valid); +#endif +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_accept_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_bind_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_connect_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_event_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_fcntl_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_fstat_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_fsync_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_ftruncate_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_getpeername_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_getsockname_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_getsockopt_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_ioctl_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_listen_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_mkdirat_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_mknodat_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_read_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_recv_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_renameat_source_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_renameat_target_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_seek_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_setsockopt_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_shutdown_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_symlinkat_rights); +RTEMS_BSD_CAP_ALIAS(cap_no_rights, cap_write_rights); diff --git a/rtemsbsd/rtems/rtems-kernel-dev.c b/rtemsbsd/rtems/rtems-kernel-dev.c new file mode 100644 index 00000000..56180188 --- /dev/null +++ b/rtemsbsd/rtems/rtems-kernel-dev.c @@ -0,0 +1,64 @@ +/** + * @file + * + * @ingroup rtems_bsd_rtems + * + * @brief Handle the major, minor and makedev support + */ + +/* + * Copyright (c) 1982, 1986, 1991, 1993, 1994 + * The Regents of the University of California. All rights reserved. + * (c) UNIX System Laboratories, Inc. + * All or some portions of this file are derived from material licensed + * to the University of California by American Telephone and Telegraph + * Co. or Unix System Laboratories, Inc. and are reproduced herein with + * the permission of UNIX System Laboratories, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <machine/rtems-bsd-kernel-space.h> + +#include <sys/types.h> + +int +rtems_bsd__major(dev_t _d) +{ + return (((_d >> 32) & 0xffffff00) | ((_d >> 8) & 0xff)); +} + +int +rtems_bsd__minor(dev_t _d) +{ + return (((_d >> 24) & 0xff00) | (_d & 0xffff00ff)); +} + +dev_t +rtems_bsd__makedev(int _M, int _m) +{ + return (((dev_t)(_M & 0xffffff00) << 32) | ((_M & 0xff) << 8) | + ((dev_t)(_m & 0xff00) << 24) | (_m & 0xffff00ff)); +} diff --git a/rtemsbsd/rtems/rtems-kernel-dirent.c b/rtemsbsd/rtems/rtems-kernel-dirent.c new file mode 100644 index 00000000..4c18b2bc --- /dev/null +++ b/rtemsbsd/rtems/rtems-kernel-dirent.c @@ -0,0 +1,52 @@ +/** + * @file + * + * @ingroup rtems_bsd_rtems + * + * @brief TODO. + */ + +/* + * Copyright (c) 2009, 2015 embedded brains GmbH + * All rights reserved. + * + * embedded brains GmbH + * Dornierstr. 4 + * 82178 Puchheim + * Germany + * <rtems@embedded-brains.de> + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <machine/rtems-bsd-kernel-space.h> + +#include <sys/dirent.h> + +#include <string.h> + +void +dirent_terminate(struct dirent *dp) +{ + memset(dp->d_name + dp->d_namlen, 0, + dp->d_reclen - (__offsetof(struct dirent, d_name) + dp->d_namlen)); +} diff --git a/rtemsbsd/rtems/rtems-kernel-init.c b/rtemsbsd/rtems/rtems-kernel-init.c index eb958ede..90a9c809 100644 --- a/rtemsbsd/rtems/rtems-kernel-init.c +++ b/rtemsbsd/rtems/rtems-kernel-init.c @@ -38,30 +38,37 @@ */ #include <machine/rtems-bsd-kernel-space.h> -#include <machine/rtems-bsd-thread.h> -#include <sys/param.h> #include <sys/types.h> +#include <sys/param.h> #include <sys/systm.h> +#include <sys/buf.h> +#include <sys/filedesc.h> +#include <sys/jail.h> +#include <sys/kbio.h> #include <sys/kernel.h> #include <sys/ktr.h> -#include <sys/sysctl.h> #include <sys/lock.h> #include <sys/mutex.h> #include <sys/proc.h> -#include <sys/stat.h> -#include <sys/kbio.h> #include <sys/resourcevar.h> -#include <sys/jail.h> -#include <uuid/uuid.h> +#include <sys/stat.h> +#include <sys/sx.h> +#include <sys/sysctl.h> +#include <sys/sysent.h> -#include <limits.h> +#include <machine/rtems-bsd-page.h> +#include <machine/rtems-bsd-thread.h> #include <dev/kbd/kbdreg.h> #include <net80211/ieee80211_freebsd.h> +#include <limits.h> #include <rtems/bsd/bsd.h> +#include <rtems/libio_.h> +#include <rtems/malloc.h> +#include <uuid/uuid.h> SYSINIT_REFERENCE(configure1); SYSINIT_REFERENCE(module); @@ -98,25 +105,47 @@ sbintime_t sbt_timethreshold; sbintime_t sbt_tickthreshold; struct bintime tc_tick_bt; sbintime_t tc_tick_sbt; -int maxproc; int tc_precexp; - -static SYSCTL_NODE(_kern, OID_AUTO, smp, CTLFLAG_RD|CTLFLAG_CAPRD, NULL, - "Kernel SMP"); +int maxproc; +int maxfiles; +int maxfilesperproc; +int ngroups_max; +int unmapped_buf_allowed; +caddr_t unmapped_base; +long maxbcache; +int bio_transient_maxcnt; +struct sx allproc_lock; +struct vmem *rtems_bsd_transient_arena; +int nbuf; /* The number of buffer headers */ +int nswbuf; /* Number of swap I/O buffer headers. */ +void (*nlminfo_release_p)(struct proc *p); +struct sysentvec rtems_sysvec; + +static SYSCTL_NODE( + _kern, OID_AUTO, smp, CTLFLAG_RD | CTLFLAG_CAPRD, NULL, "Kernel SMP"); static int maxid_maxcpus; -SYSCTL_INT(_kern_smp, OID_AUTO, maxid, CTLFLAG_RD|CTLFLAG_CAPRD, +SYSCTL_INT(_kern_smp, OID_AUTO, maxid, CTLFLAG_RD | CTLFLAG_CAPRD, &maxid_maxcpus, 0, "Max CPU ID."); -SYSCTL_INT(_kern_smp, OID_AUTO, maxcpus, CTLFLAG_RD|CTLFLAG_CAPRD, +SYSCTL_INT(_kern_smp, OID_AUTO, maxcpus, CTLFLAG_RD | CTLFLAG_CAPRD, &maxid_maxcpus, 0, "Max number of CPUs that the system was compiled for."); +static void +cpu_startup(void *dummy) +{ + kern_vfs_bio_buffer_alloc(unmapped_base, maxbcache); + bufinit(); + vm_pager_bufferinit(); +} +SYSINIT(cpu, SI_SUB_CPU, SI_ORDER_FIRST, cpu_startup, NULL); + /* * Create a single process. RTEMS is a single address, single process OS. */ static void -proc0_init(void* dummy) +proc0_init(void *dummy) { struct proc *p = &proc0; struct ucred *newcred; @@ -127,7 +156,7 @@ proc0_init(void* dummy) newcred = crget(); newcred->cr_uid = 0; newcred->cr_ruid = 0; - newcred->cr_ngroups = 1; /* group 0 */ + newcred->cr_ngroups = 1; /* group 0 */ newcred->cr_groups[0] = 0; newcred->cr_rgid = 0; tmpuinfo.ui_uid = 1; @@ -137,8 +166,15 @@ proc0_init(void* dummy) newcred->cr_ruidinfo = uifind(0); p->p_ucred = newcred; p->p_pid = getpid(); - p->p_fd = NULL; + p->p_fd = fdinit(NULL, false); p->p_fdtol = NULL; + rtems_sysvec.sv_flags = SV_ABI_FREEBSD; +#ifdef __LP64__ + rtems_sysvec.sv_flags |= SV_LP64; +#else + rtems_sysvec.sv_flags |= SV_ILP32; +#endif + p->p_sysent = &rtems_sysvec; uuid_generate(uuid); uuid_unparse(uuid, prison0.pr_hostuuid); } @@ -170,17 +206,27 @@ rtems_bsd_initialize(void) bt_tickthreshold = bt_timethreshold; sbt_timethreshold = bttosbt(bt_timethreshold); sbt_tickthreshold = bttosbt(bt_tickthreshold); - maxid_maxcpus = (int) rtems_scheduler_get_processor_maximum(); + maxid_maxcpus = (int)rtems_scheduler_get_processor_maximum(); + bio_transient_maxcnt = 1024; + sx_init(&allproc_lock, "allproc"); + maxfiles = rtems_libio_number_iops; + maxfilesperproc = maxfiles; maxproc = 16; + ngroups_max = 4; + + maxbcache = rtems_bsd_get_allocator_domain_size( + RTEMS_BSD_ALLOCATOR_DOMAIN_BIO); + unmapped_base = (caddr_t)rtems_heap_allocate_aligned_with_boundary( + maxbcache, CACHE_LINE_SIZE, 0); + if (unmapped_base == NULL) { + return RTEMS_UNSATISFIED; + } mkdir("/etc", S_IRWXU | S_IRWXG | S_IRWXO); - sc = rtems_timer_initiate_server( - rtems_bsd_get_task_priority(name), - rtems_bsd_get_task_stack_size(name), - RTEMS_DEFAULT_ATTRIBUTES - ); + sc = rtems_timer_initiate_server(rtems_bsd_get_task_priority(name), + rtems_bsd_get_task_stack_size(name), RTEMS_DEFAULT_ATTRIBUTES); if (sc != RTEMS_SUCCESSFUL) { return RTEMS_UNSATISFIED; } @@ -191,7 +237,8 @@ rtems_bsd_initialize(void) #ifdef KTR ktr_verbose = 10; ktr_mask = KTR_ALL; - ktr_mask = KTR_GEN | KTR_LOCK | KTR_VFS | KTR_VOP | KTR_BUF | KTR_MALLOC | KTR_SYSC | KTR_RUNQ; + ktr_mask = KTR_GEN | KTR_LOCK | KTR_VFS | KTR_VOP | KTR_BUF | + KTR_MALLOC | KTR_SYSC | KTR_RUNQ; #endif return RTEMS_SUCCESSFUL; diff --git a/rtemsbsd/rtems/rtems-kernel-pager.c b/rtemsbsd/rtems/rtems-kernel-pager.c new file mode 100644 index 00000000..5a48c2e8 --- /dev/null +++ b/rtemsbsd/rtems/rtems-kernel-pager.c @@ -0,0 +1,171 @@ +/** + * @file + * + * @ingroup rtems_bsd_rtems + * + * @brief TODO. + */ + +/* + * Copyright (c) 2020 Chris Johns <chris@contemporary.software> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <machine/rtems-bsd-kernel-space.h> + +#include <sys/param.h> +#include <sys/buf.h> +#include <sys/kernel.h> +#include <sys/vmem.h> + +#include <vm/vm.h> +#include <vm/uma.h> +#include <vm/vm_extern.h> + +#define B_MAXPHYS 0x00200000 /* nitems(b_pages[]) = atop(MAXPHYS). */ +#define PBUF_PAGES (atop(maxphys) + 1) +#define MAXPHYS (128 * 1024) +#define NSWBUF_MIN 16 + +static u_long maxphys; /* max raw I/O transfer size */ +static int nswbuf_max; + +vmem_t *kernel_arena; +uma_zone_t pbuf_zone; +uma_zone_t ncl_pbuf_zone; + +vm_offset_t +kva_alloc(vm_size_t size) +{ + vm_offset_t addr; + + size = round_page(size); + if (vmem_alloc(kernel_arena, size, M_BESTFIT | M_NOWAIT, &addr)) + return (0); + + return (addr); +} + +static int +pbuf_ctor(void *mem, int size, void *arg, int flags) +{ + struct buf *bp = mem; + + bp->b_vp = NULL; + bp->b_bufobj = NULL; + + /* copied from initpbuf() */ + bp->b_rcred = NOCRED; + bp->b_wcred = NOCRED; + bp->b_qindex = 0; /* On no queue (QUEUE_NONE) */ + bp->b_data = bp->b_kvabase; + bp->b_xflags = 0; + bp->b_flags = B_MAXPHYS; + bp->b_ioflags = 0; + bp->b_iodone = NULL; + bp->b_error = 0; + BUF_LOCK(bp, LK_EXCLUSIVE, NULL); + + return (0); +} + +static void +pbuf_dtor(void *mem, int size, void *arg) +{ + struct buf *bp = mem; + + if (bp->b_rcred != NOCRED) { + crfree(bp->b_rcred); + bp->b_rcred = NOCRED; + } + if (bp->b_wcred != NOCRED) { + crfree(bp->b_wcred); + bp->b_wcred = NOCRED; + } + + BUF_UNLOCK(bp); +} + +static int +pbuf_init(void *mem, int size, int flags) +{ + struct buf *bp = mem; + + bp->b_kvabase = (void *)kva_alloc(ptoa(PBUF_PAGES)); + if (bp->b_kvabase == NULL) + return (ENOMEM); + bp->b_kvasize = ptoa(PBUF_PAGES); + BUF_LOCKINIT(bp); + LIST_INIT(&bp->b_dep); + bp->b_rcred = bp->b_wcred = NOCRED; + bp->b_xflags = 0; + + return (0); +} + +void +vm_pager_bufferinit(void) +{ + /* Main zone for paging bufs. */ + pbuf_zone = uma_zcreate("pbuf", + sizeof(struct buf) + PBUF_PAGES * sizeof(vm_page_t), pbuf_ctor, + pbuf_dtor, pbuf_init, NULL, UMA_ALIGN_CACHE, UMA_ZONE_NOFREE); + /* Few systems may still use this zone directly, so it needs a limit. */ + nswbuf_max += uma_zone_set_max(pbuf_zone, NSWBUF_MIN); +} + +uma_zone_t +pbuf_zsecond_create(char *name, int max) +{ + uma_zone_t zone; + + zone = uma_zsecond_create( + name, pbuf_ctor, pbuf_dtor, NULL, NULL, pbuf_zone); + /* + * uma_prealloc() rounds up to items per slab. If we would prealloc + * immediately on every pbuf_zsecond_create(), we may accumulate too + * much of difference between hard limit and prealloced items, which + * means wasted memory. + */ + if (nswbuf_max > 0) + nswbuf_max += uma_zone_set_max(zone, max); + else + uma_prealloc(pbuf_zone, uma_zone_set_max(zone, max)); + + return (zone); +} + +struct buf * +getpbuf(int *pfreecnt) +{ + (void)pfreecnt; + return uma_zalloc(ncl_pbuf_zone, M_WAITOK); +} + +void +relpbuf(struct buf *bp, int *pfreecnt) +{ + (void)pfreecnt; + uma_zfree(ncl_pbuf_zone, bp); +} diff --git a/rtemsbsd/rtems/rtems-kernel-param.c b/rtemsbsd/rtems/rtems-kernel-param.c new file mode 100644 index 00000000..f8fb2dd7 --- /dev/null +++ b/rtemsbsd/rtems/rtems-kernel-param.c @@ -0,0 +1,40 @@ +/** + * @file + * + * @ingroup rtems_bsd_rtems + * + * @brief TODO. + */ + +/* + * Copyright (c) 2020 Chris Johns <chris@contemporary.software> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <machine/rtems-bsd-kernel-space.h> + +#include <sys/types.h> +#include <sys/systm.h> + +int ngroups_max; /* max # of supplemental groups */ diff --git a/rtemsbsd/rtems/rtems-kernel-vfs.c b/rtemsbsd/rtems/rtems-kernel-vfs.c new file mode 100644 index 00000000..d5729bfb --- /dev/null +++ b/rtemsbsd/rtems/rtems-kernel-vfs.c @@ -0,0 +1,969 @@ +/** + * @file + * + * @ingroup rtems_bsd_rtems + * + * @brief VFS to RTEMS LibIO interface. + */ + +/* + * Copyright (c) 2020 Chris Johns. All rights reserved. + * + * Contemporary Software + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <machine/rtems-bsd-kernel-space.h> + +#include <sys/param.h> +#include <sys/buf.h> +#include <sys/capsicum.h> +#include <sys/errno.h> +#include <sys/fcntl.h> +#include <sys/file.h> +#include <sys/filedesc.h> +#include <sys/kernel.h> +#include <sys/malloc.h> +#include <sys/mount.h> +#include <sys/namei.h> +#include <sys/proc.h> +#include <sys/syscallsubr.h> +#include <sys/sysproto.h> +#include <sys/time.h> +#include <sys/vnode.h> + +#include <rtems/libio.h> +#include <rtems/seterr.h> + +const rtems_filesystem_operations_table rtems_bsd_vfsops = { + .lock_h = rtems_bsd_vfs_mt_entry_lock, + .unlock_h = rtems_bsd_vfs_mt_entry_unlock, + .eval_path_h = rtems_bsd_vfs_eval_path, + .link_h = rtems_bsd_vfs_link, + .are_nodes_equal_h = rtems_bsd_vfs_are_nodes_equal, + .mknod_h = rtems_bsd_vfs_mknod, + .rmnod_h = rtems_bsd_vfs_rmnod, + .fchmod_h = rtems_bsd_vfs_fchmod, + .chown_h = rtems_bsd_vfs_chown, + .clonenod_h = rtems_bsd_vfs_clonenode, + .freenod_h = rtems_bsd_vfs_freenode, + .mount_h = rtems_bsd_vfs_mount, + .unmount_h = rtems_bsd_vfs_unmount, + .fsunmount_me_h = rtems_bsd_vfs_fsunmount_me, + .utimens_h = rtems_bsd_vfs_utimens, + .symlink_h = rtems_bsd_vfs_symlink, + .readlink_h = rtems_bsd_vfs_readlink, + .rename_h = rtems_bsd_vfs_rename, + .statvfs_h = rtems_bsd_vfs_statvfs +}; + +int +rtems_bsd_vfs_mount_init(rtems_filesystem_mount_table_entry_t *mt_entry) +{ + mt_entry->fs_info = NULL; + mt_entry->no_regular_file_mknod = true; + mt_entry->ops = &rtems_bsd_vfsops; + mt_entry->mt_fs_root->location.node_access = 0; + mt_entry->mt_fs_root->location.handlers = &rtems_bsd_sysgen_dirops; + return 0; +} + +static void +rtems_bsd_vfs_loc_vnode_hold( + rtems_filesystem_location_info_t *loc, struct vnode *vp) +{ + if (vp != NULL) { + VREF(vp); + if (RTEMS_BSD_VFS_TRACE) + printf("bsd: vfs: loc: hold loc=%p vn=%p\n", loc, vp); + } +} + +static void +rtems_bsd_vfs_loc_vnode_drop( + rtems_filesystem_location_info_t *loc, struct vnode *vp) +{ + if (vp != NULL) { + vrele(vp); + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: loc: drop loc=%p vn=%p\n", loc, vp); + } + } +} + +static void +rtems_bsd_vfs_loc_hold(rtems_filesystem_location_info_t *loc) +{ + if (loc != NULL) { + if (RTEMS_BSD_VFS_TRACE) + printf("bsd: vfs: loc: hold loc=%p vn=%p vdp=%p\n", loc, + rtems_bsd_libio_loc_to_vnode(loc), + rtems_bsd_libio_loc_to_vnode_dir(loc)); + rtems_bsd_vfs_loc_vnode_hold( + loc, rtems_bsd_libio_loc_to_vnode(loc)); + rtems_bsd_vfs_loc_vnode_hold( + loc, rtems_bsd_libio_loc_to_vnode_dir(loc)); + } +} + +static void +rtems_bsd_vfs_loc_drop(rtems_filesystem_location_info_t *loc) +{ + if (loc != NULL) { + if (RTEMS_BSD_VFS_TRACE) + printf("bsd: vfs: loc: drop loc=%p vn=%p vdp=%p\n", loc, + rtems_bsd_libio_loc_to_vnode(loc), + rtems_bsd_libio_loc_to_vnode_dir(loc)); + rtems_bsd_libio_loc_set_vnode(loc, NULL); + rtems_bsd_libio_loc_set_vnode_dir(loc, NULL); + } +} + +void +rtems_bsd_vfs_mt_entry_lock( + const rtems_filesystem_mount_table_entry_t *mt_entry) +{ + struct vnode *vp = rtems_bsd_libio_loc_to_vnode( + &mt_entry->mt_fs_root->location); + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: lock: vn=%p\n", vp); + } + VREF(vp); +} + +void +rtems_bsd_vfs_mt_entry_unlock( + const rtems_filesystem_mount_table_entry_t *mt_entry) +{ + struct vnode *vp = rtems_bsd_libio_loc_to_vnode( + &mt_entry->mt_fs_root->location); + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: unlock: vn=%p\n", vp); + } + vrele(vp); +} + +static void +rtems_bsd_vfs_componentname(struct componentname *cnd, u_long nameiop, + char *name, u_int namelen, struct ucred *cred) +{ + memset(cnd, 0, sizeof(*cnd)); + cnd->cn_nameiop = nameiop; + cnd->cn_nameptr = name; + cnd->cn_namelen = namelen; + cnd->cn_cred = cred; +} + +static int +rtems_bsd_vfs_vnode_componentname(struct componentname *cnd, struct vnode *vp, + u_long nameiop, char *name, u_int namelen, struct ucred *cred) +{ + struct vnode *tvp; + const u_int namemax = namelen - 1; + char *namep; + int error; + name[namemax] = '\0'; + namelen = namemax; + tvp = vp; + error = vn_vptocnp(&tvp, NULL, name, &namelen); + if (error == 0) { + name = &name[namelen]; + namelen = namemax - namelen; + } else { + name = NULL; + namelen = 0; + } + rtems_bsd_vfs_componentname(cnd, nameiop, name, namelen, cred); + return error; +} + +static bool +rtems_bsd_vfs_vnode_is_directory( + rtems_filesystem_eval_path_context_t *ctx, void *arg) +{ + struct vnode *vp = *((struct vnode **)arg); + return vp->v_type == VDIR; +} + +static rtems_filesystem_eval_path_generic_status +rtems_bsd_vfs_eval_token(rtems_filesystem_eval_path_context_t *ctx, void *arg, + const char *token, size_t tokenlen) +{ + rtems_filesystem_location_info_t *currentloc; + struct thread *td = curthread; + struct filedesc *fdp = td->td_proc->p_fd; + struct nameidata nd; + struct vnode **vpp = arg; + struct vnode *vp; + struct vnode *dvp; + struct vnode *cdir; + struct vnode *rdir; + char ntoken[NAME_MAX + 1]; + u_long op = LOOKUP; + u_long flags = 0; + int eval_flags; + bool no_more_path; + rtems_filesystem_location_info_t *rootloc; + int error; + + currentloc = rtems_filesystem_eval_path_get_currentloc(ctx); + no_more_path = !rtems_filesystem_eval_path_has_path(ctx); + + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: eval_token: t=%s:%d vp=%p\n", token, tokenlen, + *vpp); + } + + if (tokenlen > NAME_MAX) { + rtems_filesystem_eval_path_error(ctx, E2BIG); + return RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE; + } + + if (rtems_filesystem_is_current_directory(token, tokenlen)) { + rtems_filesystem_eval_path_clear_token(ctx); + return no_more_path ? + RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE : + RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE; + } + + /* + * Have we reached the root vnode. Note the namei call will + * successfully lookup `..` when we are at the mount point + * because VFS mounts are held under the root pseudofs file + * system. + */ + rootloc = ¤tloc->mt_entry->mt_fs_root->location; + if (*vpp == rtems_bsd_libio_loc_to_vnode(rootloc)) { + if (rtems_filesystem_is_parent_directory(token, tokenlen)) { + if (RTEMS_BSD_VFS_TRACE) { + printf( + "bsd: vfs: parent from root: vp=%p rvp=%p\n", + *vpp, + rtems_bsd_libio_loc_to_vnode(rootloc)); + } + rtems_filesystem_eval_path_put_back_token(ctx); + return RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE; + } + } + + eval_flags = rtems_filesystem_eval_path_get_flags(ctx); + flags |= (eval_flags & RTEMS_FS_FOLLOW_LINK) != 0 ? FOLLOW : NOFOLLOW; + + if (no_more_path && ((eval_flags & RTEMS_FS_MAKE) != 0)) { + op = CREATE; + flags |= LOCKPARENT; + } + + flags |= WANTPARENT; + + FILEDESC_XLOCK(fdp); + rdir = fdp->fd_rdir; + cdir = fdp->fd_cdir; + fdp->fd_rdir = rootvnode; + fdp->fd_cdir = *vpp; + vref(*vpp); + FILEDESC_XUNLOCK(fdp); + + bcopy(token, ntoken, tokenlen); + ntoken[tokenlen] = '\0'; + + NDINIT_ATVP(&nd, op, flags, UIO_USERSPACE, ntoken, *vpp, td); + error = namei(&nd); + + if (RTEMS_BSD_VFS_TRACE) { + printf( + "bsd: vfs: eval_token: namei=%d:%s token=%s cwd=%p vp=%p dvp=%p mp=%p %s\n", + error, strerror(error), ntoken, *vpp, nd.ni_vp, nd.ni_dvp, + nd.ni_vp ? nd.ni_vp->v_mountedhere : NULL, + no_more_path ? "no-more-path" : "more-path"); + } + + if (error != 0) { + NDFREE(&nd, NDF_ONLY_PNBUF); + rtems_filesystem_eval_path_error(ctx, error); + return RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE; + } + + FILEDESC_XLOCK(fdp); + fdp->fd_rdir = rdir; + fdp->fd_cdir = cdir; + FILEDESC_XUNLOCK(fdp); + + /* + * If there is no more path and this is the last token and the lookup + * with CREATE failed to find a vnode it does not exist and needs to be + * created. Leave the currentloc where it is. + */ + if (nd.ni_vp != NULL) { + rtems_bsd_libio_loc_set_vnode(currentloc, nd.ni_vp); + rtems_bsd_libio_loc_set_vnode_dir(currentloc, nd.ni_dvp); + } + + *vpp = nd.ni_vp; + + NDFREE(&nd, 0); + + if (*vpp == rtems_bsd_libio_loc_to_vnode(rootloc)) { + if (RTEMS_BSD_VFS_TRACE) { + printf( + "bsd: vfs: eval_token: cross-mount vp=%p rvp=%p\n", + *vpp, rtems_bsd_libio_loc_to_vnode(rootloc)); + } + rtems_filesystem_eval_path_clear_token(ctx); + return RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE; + } + + if (*vpp != NULL) { + rtems_filesystem_eval_path_clear_token(ctx); + } + + return no_more_path ? RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE : + RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE; +} + +static const rtems_filesystem_eval_path_generic_config + rtems_bsd_vfs_eval_config = { + .is_directory = rtems_bsd_vfs_vnode_is_directory, + .eval_token = rtems_bsd_vfs_eval_token + }; + +void +rtems_bsd_vfs_eval_path(rtems_filesystem_eval_path_context_t *ctx) +{ + rtems_filesystem_location_info_t *currentloc; + struct vnode *vp; + + errno = 0; + + currentloc = rtems_filesystem_eval_path_get_currentloc(ctx); + vp = rtems_bsd_libio_loc_to_vnode(currentloc); + + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: eval_path: t=%s:%d (%s) cloc=%p\n", + ctx->token, ctx->tokenlen, ctx->path, vp); + } + + /* + * For locking + */ + rtems_bsd_libio_loc_set_vnode(currentloc, vp); + rtems_bsd_libio_loc_set_vnode_dir(currentloc, vp); + + rtems_filesystem_eval_path_generic( + ctx, &vp, &rtems_bsd_vfs_eval_config); + + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: eval_path: e=%d:%s vp=%p cloc=%p lookup=%p\n", + errno, strerror(errno), vp, + rtems_bsd_libio_loc_to_vnode(currentloc), + rtems_bsd_libio_loc_to_vnode_dir(currentloc)); + } +} + +bool +rtems_bsd_vfs_are_nodes_equal(const rtems_filesystem_location_info_t *a, + const rtems_filesystem_location_info_t *b) +{ + struct vnode *avp = rtems_bsd_libio_loc_to_vnode(a); + struct vnode *bvp = rtems_bsd_libio_loc_to_vnode(b); + struct vnode *advp = rtems_bsd_libio_loc_to_vnode_dir(a); + struct vnode *bdvp = rtems_bsd_libio_loc_to_vnode_dir(b); + bool eq; + if (advp != NULL && bdvp != NULL) { + eq = avp == bvp && advp == bdvp; + } else { + eq = avp == bvp; + } + if (RTEMS_BSD_VFS_TRACE) { + printf( + "bsd: vfs: nodes_equal: %s vn:%s (%p == %p) dvn:%s (%p == %p)\n", + eq ? "EQ" : "NE", avp == bvp ? "equal" : "not-equal", avp, + bvp, advp == bdvp ? "equal" : "not-equal", advp, bdvp); + } + return eq; +} + +int +rtems_bsd_vfs_clonenode(rtems_filesystem_location_info_t *loc) +{ + rtems_bsd_vfs_loc_hold(loc); + if (RTEMS_BSD_VFS_TRACE) { + struct vnode *vp = rtems_bsd_libio_loc_to_vnode(loc); + struct vnode *dvp = rtems_bsd_libio_loc_to_vnode_dir(loc); + printf("bsd: vfs: clonenode: %p vn=%p dvp=%p\n", loc, vp, dvp); + } + return 0; +} + +void +rtems_bsd_vfs_freenode(const rtems_filesystem_location_info_t *loc) +{ + if (RTEMS_BSD_VFS_TRACE) { + struct vnode *vp = rtems_bsd_libio_loc_to_vnode(loc); + struct vnode *dp = rtems_bsd_libio_loc_to_vnode_dir(loc); + printf("bsd: vfs: freenode: %p vn=%p dp=%p\n", loc, vp, dp); + } + rtems_bsd_vfs_loc_drop( + RTEMS_DECONST(rtems_filesystem_location_info_t *, loc)); +} + +int +rtems_bsd_vfs_link(const rtems_filesystem_location_info_t *targetdirloc, + const rtems_filesystem_location_info_t *sourceloc, const char *name, + size_t namelen) +{ + struct thread *td = curthread; + struct mount *mp; + struct vnode *tdvp = rtems_bsd_libio_loc_to_vnode(targetdirloc); + struct vnode *svp = rtems_bsd_libio_loc_to_vnode(sourceloc); + struct componentname cn; + int error; + if (RTEMS_BSD_VFS_TRACE) { + printf( + "bsd: vfs: link tdvn=%p svn=%p name=%s\n", tdvp, svp, name); + } + if (td == NULL) { + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: link: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + if (svp->v_mount != tdvp->v_mount) { + if (RTEMS_BSD_VFS_TRACE) + printf("bsd: vfs: link: crossmounts\n"); + error = EXDEV; + goto out; + } + vref(tdvp); + vn_lock(tdvp, LK_EXCLUSIVE | LK_RETRY); + error = vn_start_write(tdvp, &mp, V_NOWAIT); + if (error != 0) { + vput(tdvp); + error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH); + if (error == 0) + error = EAGAIN; + goto out; + } + rtems_bsd_vfs_componentname( + &cn, LOOKUP, RTEMS_DECONST(char *, name), namelen, td->td_ucred); + error = VOP_LINK(tdvp, svp, &cn); + VOP_UNLOCK(tdvp, 0); +out: + return rtems_bsd_error_to_status_and_errno(error); +} + +int +rtems_bsd_vfs_fchmod(const rtems_filesystem_location_info_t *loc, mode_t mode) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + struct vnode *vp = rtems_bsd_libio_loc_to_vnode(loc); + int error; + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: fchmod: vn=%p mode=%x\n", vp, mode); + } + if (td == NULL) { + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: fchmod: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + error = setfmode(td, NULL, vp, mode); + return rtems_bsd_error_to_status_and_errno(error); +} + +int +rtems_bsd_vfs_chown( + const rtems_filesystem_location_info_t *loc, uid_t owner, gid_t group) +{ + struct thread *td = rtems_bsd_get_curthread_or_null(); + struct vnode *vp = rtems_bsd_libio_loc_to_vnode(loc); + int error; + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: chown: vn=%p owner=%d group=%d\n", vp, owner, + group); + } + if (td == NULL) { + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: chown: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + error = setfown(td, NULL, vp, owner, group); + return rtems_bsd_error_to_status_and_errno(error); +} + +int +rtems_bsd_vfs_mount(rtems_filesystem_mount_table_entry_t *mt_entry) +{ + int error; + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: mount\n"); + } + error = EOPNOTSUPP; + return rtems_bsd_error_to_status_and_errno(error); +} + +int +rtems_bsd_vfs_fsmount_me( + rtems_filesystem_mount_table_entry_t *mt_entry, const void *data) +{ + struct thread *td = curthread; + struct mount_args *args = (struct mount_args *)data; + int error; + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: fsmount_me\n"); + } + if (td == NULL) { + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: fsmount_me: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + error = sys_mount(td, args); + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: fsmount_me: error=%d %s\n", error, + strerror(error)); + } + return rtems_bsd_error_to_status_and_errno(error); +} + +int +rtems_bsd_vfs_unmount(rtems_filesystem_mount_table_entry_t *mt_entry) +{ + int error; + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: unmount\n"); + } + error = EOPNOTSUPP; + return rtems_bsd_error_to_status_and_errno(error); +} + +void +rtems_bsd_vfs_fsunmount_me(rtems_filesystem_mount_table_entry_t *mt_entry) +{ + int error; + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: fsunmount_me: %p\n", + rtems_bsd_libio_loc_to_vnode( + &mt_entry->mt_fs_root->location)); + } + rtems_bsd_vfs_loc_drop(&mt_entry->mt_fs_root->location); +} + +int +rtems_bsd_vfs_mknod(const rtems_filesystem_location_info_t *parentloc, + const char *name, size_t namelen, mode_t mode, dev_t dev) +{ + struct thread *td = curthread; + struct filedesc *fdp = td->td_proc->p_fd; + struct vnode *vn = rtems_bsd_libio_loc_to_vnode(parentloc); + char *path = RTEMS_DECONST(char *, name); + int error; + + if (td == NULL) { + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: mknod: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + + if (RTEMS_BSD_VFS_TRACE) { + const char *type; + if ((mode & S_IFMT) == S_IFREG) + type = "REG"; + else if ((mode & S_IFMT) == S_IFDIR) + type = "DIR"; + else + type = "DEV"; + printf( + "bsd: vfs: mknod: mode=%s name=%s (%d) mode=%08x dev=%08llx parent=%p\n", + type, name, namelen, mode, dev, vn); + } + + fdp->fd_cdir = vn; + + switch (mode & S_IFMT) { + case S_IFREG: + error = 0; + break; + case S_IFDIR: + VREF(vn); + error = kern_mkdirat(td, AT_FDCWD, path, UIO_USERSPACE, mode); + vrele(vn); + break; + default: + VREF(vn); + error = kern_mknodat( + td, AT_FDCWD, path, UIO_USERSPACE, mode, dev); + vrele(vn); + break; + } + + if (RTEMS_BSD_VFS_TRACE) { + printf( + "bsd: vfs: mknod: error=%s (%d)\n", strerror(error), error); + } + + return rtems_bsd_error_to_status_and_errno(error); +} + +int +rtems_bsd_vfs_rmnod(const rtems_filesystem_location_info_t *parentloc, + const rtems_filesystem_location_info_t *loc) +{ + struct thread *td = curthread; + struct mount *mp; + struct vnode *vp = rtems_bsd_libio_loc_to_vnode(loc); + struct vnode *dvp = rtems_bsd_libio_loc_to_vnode(parentloc); + struct vnode *tvp; + struct componentname cn; + char name[255]; + int error; + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: rmnod vn=%p at=%p\n", vp, dvp); + } + if (td == NULL) { + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: rmnod: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + error = rtems_bsd_vfs_vnode_componentname( + &cn, vp, DELETE, name, sizeof(name), td->td_ucred); + if (error != 0) { + if (RTEMS_BSD_VFS_TRACE) { + printf( + "bsd: vfs: rmnod: componentname lookup: (%d) %s\n", + error, strerror(error)); + } + goto out; + } + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: rmnod name=%s\n", cn.cn_nameptr); + } + vref(vp); +restart: + bwillwrite(); + if (vp->v_vflag & VV_ROOT) { + error = EBUSY; + goto out; + } + if (vn_start_write(dvp, &mp, V_NOWAIT) != 0) { + if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != + 0) { + return rtems_bsd_error_to_status_and_errno(error); + } + goto restart; + } + vfs_notify_upper(vp, VFS_NOTIFY_UPPER_UNLINK); + error = VOP_RMDIR(dvp, vp, &cn); + vn_finished_write(mp); +out: + return rtems_bsd_error_to_status_and_errno(error); +} + +int +rtems_bsd_vfs_utimens( + const rtems_filesystem_location_info_t *loc, time_t actime, time_t modtime) +{ + int error; + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: utimens\n"); + } + error = EOPNOTSUPP; + return rtems_bsd_error_to_status_and_errno(error); +} + +int +rtems_bsd_vfs_symlink(const rtems_filesystem_location_info_t *targetdirloc, + const char *name, size_t namelen, const char *target) +{ + struct thread *td = curthread; + struct filedesc *fdp; + struct mount *mp; + struct vnode *tdvp = rtems_bsd_libio_loc_to_vnode(targetdirloc); + struct vattr vattr; + struct nameidata nd; + int error; + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: symlink tdvn=%p name=%s target=%s\n", tdvp, + name, target); + } + if (td == NULL) { + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: symlink: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + fdp = td->td_proc->p_fd; + fdp->fd_cdir = tdvp; +restart: + bwillwrite(); + NDINIT_ATRIGHTS(&nd, CREATE, + LOCKPARENT | SAVENAME | AUDITVNODE1 | NOCACHE, UIO_SYSSPACE, name, + AT_FDCWD, &cap_symlinkat_rights, td); + error = namei(&nd); + if (error != 0) { + goto out; + } + if (nd.ni_vp != NULL) { + NDFREE(&nd, NDF_ONLY_PNBUF); + if (nd.ni_vp == nd.ni_dvp) + vrele(nd.ni_dvp); + else + vput(nd.ni_dvp); + vrele(nd.ni_vp); + error = EEXIST; + goto out; + } + error = vn_start_write(nd.ni_dvp, &mp, V_NOWAIT); + if (error != 0) { + NDFREE(&nd, NDF_ONLY_PNBUF); + vput(nd.ni_dvp); + error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH); + if (error != 0) { + goto out; + } + goto restart; + } + VATTR_NULL(&vattr); + vattr.va_mode = ACCESSPERMS & ~td->td_proc->p_fd->fd_cmask; + error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr, + RTEMS_DECONST(char *, target)); + if (error != 0) { + goto out; + } + NDFREE(&nd, NDF_ONLY_PNBUF); + vput(nd.ni_dvp); + vn_finished_write(mp); +out: + return rtems_bsd_error_to_status_and_errno(error); +} + +ssize_t +rtems_bsd_vfs_readlink( + const rtems_filesystem_location_info_t *loc, char *buf, size_t bufsize) +{ + struct thread *td = curthread; + struct vnode *vp = rtems_bsd_libio_loc_to_vnode(loc); + struct iovec aiov; + struct uio auio; + int error; + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: readlink vn=%p\n", vp); + } + if (td == NULL) { + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: readlink: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); + if (vp->v_type != VLNK && (vp->v_vflag & VV_READLINK) == 0) { + error = EINVAL; + goto out; + } + aiov.iov_base = buf; + aiov.iov_len = bufsize; + auio.uio_iov = &aiov; + auio.uio_iovcnt = 1; + auio.uio_offset = 0; + auio.uio_rw = UIO_READ; + auio.uio_segflg = UIO_SYSSPACE; + auio.uio_td = td; + auio.uio_resid = bufsize; + error = VOP_READLINK(vp, &auio, td->td_ucred); + td->td_retval[0] = bufsize - auio.uio_resid; +out: + VOP_UNLOCK(vp, 0); + return rtems_bsd_error_to_status_and_errno(error); +} + +int +rtems_bsd_vfs_rename(const rtems_filesystem_location_info_t *oldparentloc, + const rtems_filesystem_location_info_t *oldloc, + const rtems_filesystem_location_info_t *newparentloc, const char *name, + size_t namelen) +{ + struct thread *td = curthread; + struct mount *mp; + struct vnode *olddvp = rtems_bsd_libio_loc_to_vnode(oldparentloc); + struct vnode *oldvp = rtems_bsd_libio_loc_to_vnode(oldloc); + struct vnode *newdvp = rtems_bsd_libio_loc_to_vnode(newparentloc); + struct vnode *fvp; + struct vnode *tdvp; + struct vnode *tvp; + struct nameidata fromnd; + struct nameidata tond; + struct componentname cn; + char fromname[255]; + int error; + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: rename from=%p/%p to=%p/%s\n", olddvp, oldvp, + newdvp, name); + } + if (td == NULL) { + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: rename: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + error = rtems_bsd_vfs_vnode_componentname( + &cn, oldvp, DELETE, fromname, sizeof(fromname), td->td_ucred); + if (error != 0) { + if (RTEMS_BSD_VFS_TRACE) { + printf( + "bsd: vfs: rename: componentname lookup: %p: (%d) %s\n", + oldvp, error, strerror(error)); + } + goto out2; + } + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: rename fromname=%s\n", cn.cn_nameptr); + } +again: + bwillwrite(); + NDINIT_ATVP(&fromnd, DELETE, WANTPARENT | SAVESTART | AUDITVNODE1, + UIO_SYSSPACE, cn.cn_nameptr, olddvp, td); + error = namei(&fromnd); + if (error != 0) { + goto out2; + } + fvp = fromnd.ni_vp; + NDINIT_ATVP(&tond, RENAME, + LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART | AUDITVNODE2, + UIO_SYSSPACE, name, newdvp, td); + if (fromnd.ni_vp->v_type == VDIR) + tond.ni_cnd.cn_flags |= WILLBEDIR; + error = namei(&tond); + if (error != 0) { + /* Translate error code for rename("dir1", "dir2/."). */ + if (error == EISDIR && fvp->v_type == VDIR) + error = EINVAL; + NDFREE(&fromnd, NDF_ONLY_PNBUF); + vrele(fromnd.ni_dvp); + vrele(fvp); + goto out1; + } + tdvp = tond.ni_dvp; + tvp = tond.ni_vp; + error = vn_start_write(fvp, &mp, V_NOWAIT); + if (error != 0) { + NDFREE(&fromnd, NDF_ONLY_PNBUF); + NDFREE(&tond, NDF_ONLY_PNBUF); + if (tvp != NULL) + vput(tvp); + if (tdvp == tvp) + vrele(tdvp); + else + vput(tdvp); + vrele(fromnd.ni_dvp); + vrele(fvp); + vrele(tond.ni_startdir); + if (fromnd.ni_startdir != NULL) + vrele(fromnd.ni_startdir); + error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH); + if (error != 0) + return (error); + goto again; + } + if (tvp != NULL) { + if (fvp->v_type == VDIR && tvp->v_type != VDIR) { + error = ENOTDIR; + goto out; + } else if (fvp->v_type != VDIR && tvp->v_type == VDIR) { + error = EISDIR; + goto out; + } + } + if (fvp == tdvp) { + error = EINVAL; + goto out; + } +out: + if (error == 0) { + error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd, + tond.ni_dvp, tond.ni_vp, &tond.ni_cnd); + NDFREE(&fromnd, NDF_ONLY_PNBUF); + NDFREE(&tond, NDF_ONLY_PNBUF); + } else { + NDFREE(&fromnd, NDF_ONLY_PNBUF); + NDFREE(&tond, NDF_ONLY_PNBUF); + if (tvp != NULL) + vput(tvp); + if (tdvp == tvp) + vrele(tdvp); + else + vput(tdvp); + vrele(fromnd.ni_dvp); + vrele(fvp); + } + vrele(tond.ni_startdir); + vn_finished_write(mp); +out1: + if (fromnd.ni_startdir) + vrele(fromnd.ni_startdir); + if (error == -1) + error = 0; +out2: + return rtems_bsd_error_to_status_and_errno(error); +} + +int +rtems_bsd_vfs_statvfs( + const rtems_filesystem_location_info_t *loc, struct statvfs *buf) +{ + struct thread *td = curthread; + struct vnode *vp = rtems_bsd_libio_loc_to_vnode(loc); + struct statfs *sp; + struct mount *mp; + int error; + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: statvfs\n"); + } + if (td == NULL) { + if (RTEMS_BSD_VFS_TRACE) { + printf("bsd: vfs: statvfs: no curthread\n"); + } + return rtems_bsd_error_to_status_and_errno(ENOMEM); + } + mp = vp->v_mount; + sp = &mp->mnt_stat; + sp->f_version = STATFS_VERSION; + sp->f_namemax = NAME_MAX; + sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; + error = VFS_STATFS(mp, sp); + if (error == 0) { + buf->f_bsize = sp->f_bsize; + buf->f_frsize = sp->f_bsize; + buf->f_blocks = sp->f_blocks; + buf->f_bfree = sp->f_bfree; + buf->f_bavail = sp->f_bavail; + buf->f_files = sp->f_files; + buf->f_ffree = sp->f_ffree; + buf->f_fsid = sp->f_fsid.val[0]; + buf->f_flag = sp->f_flags; + buf->f_namemax = sp->f_namemax; + } + return rtems_bsd_error_to_status_and_errno(error); +} diff --git a/rtemsbsd/rtems/rtems-kernel-vmem.c b/rtemsbsd/rtems/rtems-kernel-vmem.c new file mode 100644 index 00000000..f64fbd17 --- /dev/null +++ b/rtemsbsd/rtems/rtems-kernel-vmem.c @@ -0,0 +1,55 @@ +/** + * @file + * + * @ingroup rtems_bsd_rtems + * + * @brief TODO. + */ + +/* + * Copyright (c) 2020 Chris Johns <chris@contemporary.software> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <machine/rtems-bsd-kernel-space.h> + +#include <sys/param.h> +#include <sys/kernel.h> +#include <sys/malloc.h> +#include <sys/vmem.h> + +static MALLOC_DEFINE(M_VMEM, "vmem", "VMEM buffers"); + +int +vmem_alloc(vmem_t *vm, vmem_size_t size, int flags, vmem_addr_t *addrp) +{ + *addrp = malloc(size, M_VMEM, M_WAITOK); + return 0; +} + +void +vmem_free(vmem_t *vm, vmem_addr_t addr, vmem_size_t size) +{ + free((void *)addr, M_VMEM); +} diff --git a/rtemsbsd/sys/fs/devfs/devfs_devs.c b/rtemsbsd/sys/fs/devfs/devfs_devs.c index 7c697b0a..39a38d62 100644 --- a/rtemsbsd/sys/fs/devfs/devfs_devs.c +++ b/rtemsbsd/sys/fs/devfs/devfs_devs.c @@ -35,6 +35,7 @@ #include <sys/conf.h> #include <sys/kernel.h> #include <sys/file.h> +#include <sys/filedesc.h> #include <sys/malloc.h> #include <sys/proc.h> #include <sys/poll.h> @@ -42,6 +43,8 @@ #include <string.h> #include <unistd.h> +#include <machine/rtems-bsd-libio.h> + #include <fs/devfs/devfs_int.h> #include <machine/pcpu.h> @@ -72,17 +75,25 @@ static int devfs_imfs_open(rtems_libio_t *iop, const char *path, int oflag, mode_t mode) { struct cdev *cdev = devfs_imfs_get_context_by_iop(iop); - struct file *fp = rtems_bsd_iop_to_fp(iop); struct thread *td = rtems_bsd_get_curthread_or_null(); + struct file *fp = NULL; + struct cdevsw *dsw = NULL; struct file *fpop; - struct cdevsw *dsw; int error, ref; + int fd = -1; if (td != NULL) { if (cdev == NULL) { error = ENXIO; goto err; } + error = falloc(td, &fp, &fd, oflag); + if (error != 0) + goto err; + finit(fp, FREAD | FWRITE, DTYPE_DEV, NULL, NULL); + rtems_libio_iop_hold(iop); + rtems_bsd_libio_iop_set_bsd_descriptor(iop, fd); + rtems_bsd_libio_iop_set_bsd_file(iop, fp); if (cdev->si_flags & SI_ALIAS) { cdev = cdev->si_parent; } @@ -91,11 +102,6 @@ devfs_imfs_open(rtems_libio_t *iop, const char *path, int oflag, mode_t mode) error = ENXIO; goto err; } - if (fp == NULL) { - dev_relthread(cdev, ref); - error = ENXIO; - goto err; - } fpop = td->td_fpop; curthread->td_fpop = fp; fp->f_cdevpriv = NULL; @@ -104,12 +110,19 @@ devfs_imfs_open(rtems_libio_t *iop, const char *path, int oflag, mode_t mode) if (error != 0) devfs_clear_cdevpriv(); curthread->td_fpop = fpop; - dev_relthread(cdev, ref); } else { error = ENOMEM; } err: + if (dsw != NULL) + dev_relthread(cdev, ref); + if (td != NULL && fp != NULL) { + if (error != 0) + fdclose(td, fp, fd); + else + fdrop(fp, td); + } return rtems_bsd_error_to_status_and_errno(error); } @@ -117,11 +130,11 @@ static int devfs_imfs_close(rtems_libio_t *iop) { struct cdev *cdev = devfs_imfs_get_context_by_iop(iop); - struct file *fp = rtems_bsd_iop_to_fp(iop); struct thread *td = rtems_bsd_get_curthread_or_null(); int flags = rtems_libio_to_fcntl_flags(iop->flags); + struct file *fp = NULL; + struct cdevsw *dsw = NULL; struct file *fpop; - struct cdevsw *dsw; int error, ref; if (td != NULL) { @@ -132,6 +145,11 @@ devfs_imfs_close(rtems_libio_t *iop) if (cdev->si_flags & SI_ALIAS) { cdev = cdev->si_parent; } + fp = rtems_bsd_libio_iop_to_file_hold(iop, td); + if (fp == NULL) { + error = EBADF; + goto err; + } dsw = dev_refthread(cdev, &ref); if (dsw == NULL) { error = ENXIO; @@ -141,7 +159,6 @@ devfs_imfs_close(rtems_libio_t *iop) curthread->td_fpop = fp; error = dsw->d_close(cdev, flags, 0, td); curthread->td_fpop = fpop; - dev_relthread(cdev, ref); if (fp->f_cdevpriv != NULL) devfs_fpdrop(fp); } else { @@ -149,6 +166,10 @@ devfs_imfs_close(rtems_libio_t *iop) } err: + if (dsw != NULL) + dev_relthread(cdev, ref); + if (td != NULL && fp != NULL) + fdrop(fp, td); return rtems_bsd_error_to_status_and_errno(error); } @@ -157,7 +178,6 @@ devfs_imfs_readv(rtems_libio_t *iop, const struct iovec *iov, int iovcnt, ssize_t total) { struct cdev *cdev = devfs_imfs_get_context_by_iop(iop); - struct file *fp = rtems_bsd_iop_to_fp(iop); struct thread *td = rtems_bsd_get_curthread_or_null(); struct uio uio = { .uio_iov = __DECONST(struct iovec *, iov), @@ -168,8 +188,9 @@ devfs_imfs_readv(rtems_libio_t *iop, const struct iovec *iov, int iovcnt, .uio_rw = UIO_READ, .uio_td = td }; + struct file *fp = NULL; + struct cdevsw *dsw = NULL; struct file *fpop; - struct cdevsw *dsw; int error, ref; if (td != NULL) { @@ -180,6 +201,11 @@ devfs_imfs_readv(rtems_libio_t *iop, const struct iovec *iov, int iovcnt, if (cdev->si_flags & SI_ALIAS) { cdev = cdev->si_parent; } + fp = rtems_bsd_libio_iop_to_file_hold(iop, td); + if (fp == NULL) { + error = EBADF; + goto err; + } dsw = dev_refthread(cdev, &ref); if (dsw == NULL) { error = ENXIO; @@ -190,12 +216,15 @@ devfs_imfs_readv(rtems_libio_t *iop, const struct iovec *iov, int iovcnt, error = dsw->d_read(cdev, &uio, rtems_libio_to_fcntl_flags(iop->flags)); td->td_fpop = fpop; - dev_relthread(cdev, ref); } else { error = ENOMEM; } err: + if (dsw != NULL) + dev_relthread(cdev, ref); + if (td != NULL && fp != NULL) + fdrop(fp, td); if (error == 0) { return (total - uio.uio_resid); } else { @@ -219,7 +248,6 @@ devfs_imfs_writev(rtems_libio_t *iop, const struct iovec *iov, int iovcnt, ssize_t total) { struct cdev *cdev = devfs_imfs_get_context_by_iop(iop); - struct file *fp = rtems_bsd_iop_to_fp(iop); struct thread *td = rtems_bsd_get_curthread_or_null(); struct uio uio = { .uio_iov = __DECONST(struct iovec *, iov), @@ -230,8 +258,9 @@ devfs_imfs_writev(rtems_libio_t *iop, const struct iovec *iov, int iovcnt, .uio_rw = UIO_WRITE, .uio_td = td }; + struct file *fp = NULL; + struct cdevsw *dsw = NULL; struct file *fpop; - struct cdevsw *dsw; int error, ref; if (td != NULL) { @@ -242,6 +271,11 @@ devfs_imfs_writev(rtems_libio_t *iop, const struct iovec *iov, int iovcnt, if (cdev->si_flags & SI_ALIAS) { cdev = cdev->si_parent; } + fp = rtems_bsd_libio_iop_to_file_hold(iop, td); + if (fp == NULL) { + error = EBADF; + goto err; + } dsw = dev_refthread(cdev, &ref); if (dsw == NULL) { error = ENXIO; @@ -252,12 +286,15 @@ devfs_imfs_writev(rtems_libio_t *iop, const struct iovec *iov, int iovcnt, error = dsw->d_write(cdev, &uio, rtems_libio_to_fcntl_flags(iop->flags)); td->td_fpop = fpop; - dev_relthread(cdev, ref); } else { error = ENOMEM; } err: + if (dsw != NULL) + dev_relthread(cdev, ref); + if (td != NULL && fp != NULL) + fdrop(fp, td); if (error == 0) { return (total - uio.uio_resid); } else { @@ -280,10 +317,10 @@ static int devfs_imfs_ioctl(rtems_libio_t *iop, ioctl_command_t request, void *buffer) { struct cdev *cdev = devfs_imfs_get_context_by_iop(iop); - struct file *fp = rtems_bsd_iop_to_fp(iop); struct thread *td = rtems_bsd_get_curthread_or_null(); + struct file *fp = NULL; + struct cdevsw *dsw = NULL; struct file *fpop; - struct cdevsw *dsw; int error, ref; int flags = rtems_libio_to_fcntl_flags(iop->flags); @@ -295,6 +332,11 @@ devfs_imfs_ioctl(rtems_libio_t *iop, ioctl_command_t request, void *buffer) if (cdev->si_flags & SI_ALIAS) { cdev = cdev->si_parent; } + fp = rtems_bsd_libio_iop_to_file_hold(iop, td); + if (fp == NULL) { + error = EBADF; + goto err; + } dsw = dev_refthread(cdev, &ref); if (dsw == NULL) { error = ENXIO; @@ -305,12 +347,15 @@ devfs_imfs_ioctl(rtems_libio_t *iop, ioctl_command_t request, void *buffer) error = dsw->d_ioctl(cdev, request, buffer, flags, td); td->td_fpop = fpop; - dev_relthread(cdev, ref); } else { error = ENOMEM; } err: + if (dsw != NULL) + dev_relthread(cdev, ref); + if (td != NULL && fp != NULL) + fdrop(fp, td); return rtems_bsd_error_to_status_and_errno(error); } @@ -333,28 +378,43 @@ static int devfs_imfs_poll(rtems_libio_t *iop, int events) { struct cdev *cdev = devfs_imfs_get_context_by_iop(iop); - struct file *fp = rtems_bsd_iop_to_fp(iop); struct thread *td = rtems_bsd_get_curthread_or_wait_forever(); + struct file *fp = NULL; + struct cdevsw *dsw = NULL; struct file *fpop; - struct cdevsw *dsw; int error, ref; - if (cdev == NULL) { - return POLLERR; - } - if (cdev->si_flags & SI_ALIAS) { - cdev = cdev->si_parent; - } - dsw = dev_refthread(cdev, &ref); - if (dsw == NULL) { - return POLLERR; + if (td != 0) { + if (cdev == NULL) { + error = POLLERR; + goto err; + } + if (cdev->si_flags & SI_ALIAS) { + cdev = cdev->si_parent; + } + fp = rtems_bsd_libio_iop_to_file_hold(iop, td); + if (fp == NULL) { + error = EBADF; + goto err; + } + dsw = dev_refthread(cdev, &ref); + if (dsw == NULL) { + error = POLLERR; + goto err; + } + fpop = td->td_fpop; + curthread->td_fpop = fp; + error = dsw->d_poll(cdev, events, td); + td->td_fpop = fpop; + } else { + error = ENOMEM; } - fpop = td->td_fpop; - curthread->td_fpop = fp; - error = dsw->d_poll(cdev, events, td); - td->td_fpop = fpop; - dev_relthread(cdev, ref); +err: + if (dsw != NULL) + dev_relthread(cdev, ref); + if (td != NULL && fp != NULL) + fdrop(fp, td); return error; } @@ -362,28 +422,41 @@ static int devfs_imfs_kqfilter(rtems_libio_t *iop, struct knote *kn) { struct cdev *cdev = devfs_imfs_get_context_by_iop(iop); - struct file *fp = rtems_bsd_iop_to_fp(iop); struct thread *td = rtems_bsd_get_curthread_or_wait_forever(); + struct file *fp = NULL; + struct cdevsw *dsw = NULL; struct file *fpop; - struct cdevsw *dsw; int error, ref; - if (cdev == NULL) { - return EINVAL; - } - if (cdev->si_flags & SI_ALIAS) { - cdev = cdev->si_parent; - } - dsw = dev_refthread(cdev, &ref); - if (dsw == NULL) { - return EINVAL; + if (td != 0) { + if (cdev == NULL) { + error = EINVAL; + } + fp = rtems_bsd_libio_iop_to_file_hold(iop, td); + if (fp == NULL) { + error = EBADF; + goto err; + } + if (cdev->si_flags & SI_ALIAS) { + cdev = cdev->si_parent; + } + dsw = dev_refthread(cdev, &ref); + if (dsw == NULL) { + error = EINVAL; + } + fpop = td->td_fpop; + curthread->td_fpop = fp; + error = dsw->d_kqfilter(cdev, kn); + td->td_fpop = fpop; + } else { + error = ENOMEM; } - fpop = td->td_fpop; - curthread->td_fpop = fp; - error = dsw->d_kqfilter(cdev, kn); - td->td_fpop = fpop; - dev_relthread(cdev, ref); +err: + if (dsw != NULL) + dev_relthread(cdev, ref); + if (td != NULL && fp != NULL) + fdrop(fp, td); return error; } diff --git a/rtemsbsd/sys/kern/vnode_if.c b/rtemsbsd/sys/kern/vnode_if.c new file mode 100644 index 00000000..0f51c54a --- /dev/null +++ b/rtemsbsd/sys/kern/vnode_if.c @@ -0,0 +1,4763 @@ +#include <machine/rtems-bsd-kernel-space.h> + +/* + * This file is produced automatically. + * Do not modify anything in here by hand. + * + * Created from $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/event.h> +#include <sys/kernel.h> +#include <sys/mount.h> +#include <sys/sdt.h> +#include <sys/signalvar.h> +#include <sys/systm.h> +#include <sys/vnode.h> + +SDT_PROVIDER_DECLARE(vfs); + +struct vnodeop_desc vop_default_desc = { + "default", + 0, + (vop_bypass_t *)vop_panic, + NULL, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_islocked_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_islocked_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_islocked, entry, "struct vnode *", "struct vop_islocked_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_islocked, return, "struct vnode *", "struct vop_islocked_args *", "int"); + + +int +VOP_ISLOCKED_AP(struct vop_islocked_args *a) +{ + + return(VOP_ISLOCKED_APV(a->a_vp->v_op, a)); +} + +int +VOP_ISLOCKED_APV(struct vop_vector *vop, struct vop_islocked_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_islocked_desc, a->a_vp, + ("Wrong a_desc in vop_islocked(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_islocked == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_islocked(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_islocked, entry, a->a_vp, a); + + KTR_START1(KTR_VOP, "VOP", "VOP_ISLOCKED", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_islocked != NULL) + rc = vop->vop_islocked(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_islocked, return, a->a_vp, a, rc); + + if (rc == 0) { + } else { + } + KTR_STOP1(KTR_VOP, "VOP", "VOP_ISLOCKED", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + return (rc); +} + +struct vnodeop_desc vop_islocked_desc = { + "vop_islocked", + 0, + (vop_bypass_t *)VOP_ISLOCKED_AP, + vop_islocked_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_lookup_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_lookup_args,a_dvp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_lookup, entry, "struct vnode *", "struct vop_lookup_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_lookup, return, "struct vnode *", "struct vop_lookup_args *", "int"); + + +int +VOP_LOOKUP_AP(struct vop_lookup_args *a) +{ + + return(VOP_LOOKUP_APV(a->a_dvp->v_op, a)); +} + +int +VOP_LOOKUP_APV(struct vop_vector *vop, struct vop_lookup_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_lookup_desc, a->a_dvp, + ("Wrong a_desc in vop_lookup(%p, %p)", a->a_dvp, a)); + while(vop != NULL && \ + vop->vop_lookup == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_dvp, ("No vop_lookup(%p, %p)", a->a_dvp, a)); + SDT_PROBE2(vfs, vop, vop_lookup, entry, a->a_dvp, a); + + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_LOOKUP"); + ASSERT_VOP_LOCKED(a->a_dvp, "VOP_LOOKUP"); + KTR_START3(KTR_VOP, "VOP", "VOP_LOOKUP", (uintptr_t)a, + "dvp:0x%jX", (uintptr_t)a->a_dvp, "vpp:0x%jX", a->a_vpp, "cnp:0x%jX", a->a_cnp); + VFS_PROLOGUE(a->a_dvp->v_mount); + if (vop->vop_lookup != NULL) + rc = vop->vop_lookup(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_dvp->v_mount); + SDT_PROBE3(vfs, vop, vop_lookup, return, a->a_dvp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_LOOKUP"); + ASSERT_VOP_LOCKED(a->a_dvp, "VOP_LOOKUP"); + ASSERT_VI_UNLOCKED(*a->a_vpp, "VOP_LOOKUP"); + ASSERT_VOP_LOCKED(*a->a_vpp, "VOP_LOOKUP"); + } else { + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_LOOKUP"); + ASSERT_VOP_LOCKED(a->a_dvp, "VOP_LOOKUP"); + } + KTR_STOP3(KTR_VOP, "VOP", "VOP_LOOKUP", (uintptr_t)a, + "dvp:0x%jX", (uintptr_t)a->a_dvp, "vpp:0x%jX", a->a_vpp, "cnp:0x%jX", a->a_cnp); + return (rc); +} + +struct vnodeop_desc vop_lookup_desc = { + "vop_lookup", + 0, + (vop_bypass_t *)VOP_LOOKUP_AP, + vop_lookup_vp_offsets, + VOPARG_OFFSETOF(struct vop_lookup_args,a_vpp), + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_lookup_args,a_cnp), +}; + +static int vop_cachedlookup_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_cachedlookup_args,a_dvp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_cachedlookup, entry, "struct vnode *", "struct vop_cachedlookup_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_cachedlookup, return, "struct vnode *", "struct vop_cachedlookup_args *", "int"); + + +int +VOP_CACHEDLOOKUP_AP(struct vop_cachedlookup_args *a) +{ + + return(VOP_CACHEDLOOKUP_APV(a->a_dvp->v_op, a)); +} + +int +VOP_CACHEDLOOKUP_APV(struct vop_vector *vop, struct vop_cachedlookup_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_cachedlookup_desc, a->a_dvp, + ("Wrong a_desc in vop_cachedlookup(%p, %p)", a->a_dvp, a)); + while(vop != NULL && \ + vop->vop_cachedlookup == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_dvp, ("No vop_cachedlookup(%p, %p)", a->a_dvp, a)); + SDT_PROBE2(vfs, vop, vop_cachedlookup, entry, a->a_dvp, a); + + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_CACHEDLOOKUP"); + ASSERT_VOP_LOCKED(a->a_dvp, "VOP_CACHEDLOOKUP"); + KTR_START3(KTR_VOP, "VOP", "VOP_CACHEDLOOKUP", (uintptr_t)a, + "dvp:0x%jX", (uintptr_t)a->a_dvp, "vpp:0x%jX", a->a_vpp, "cnp:0x%jX", a->a_cnp); + VFS_PROLOGUE(a->a_dvp->v_mount); + if (vop->vop_cachedlookup != NULL) + rc = vop->vop_cachedlookup(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_dvp->v_mount); + SDT_PROBE3(vfs, vop, vop_cachedlookup, return, a->a_dvp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_CACHEDLOOKUP"); + ASSERT_VOP_LOCKED(a->a_dvp, "VOP_CACHEDLOOKUP"); + ASSERT_VI_UNLOCKED(*a->a_vpp, "VOP_CACHEDLOOKUP"); + ASSERT_VOP_LOCKED(*a->a_vpp, "VOP_CACHEDLOOKUP"); + } else { + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_CACHEDLOOKUP"); + ASSERT_VOP_LOCKED(a->a_dvp, "VOP_CACHEDLOOKUP"); + } + KTR_STOP3(KTR_VOP, "VOP", "VOP_CACHEDLOOKUP", (uintptr_t)a, + "dvp:0x%jX", (uintptr_t)a->a_dvp, "vpp:0x%jX", a->a_vpp, "cnp:0x%jX", a->a_cnp); + return (rc); +} + +struct vnodeop_desc vop_cachedlookup_desc = { + "vop_cachedlookup", + 0, + (vop_bypass_t *)VOP_CACHEDLOOKUP_AP, + vop_cachedlookup_vp_offsets, + VOPARG_OFFSETOF(struct vop_cachedlookup_args,a_vpp), + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_cachedlookup_args,a_cnp), +}; + +static int vop_create_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_create_args,a_dvp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_create, entry, "struct vnode *", "struct vop_create_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_create, return, "struct vnode *", "struct vop_create_args *", "int"); + + +int +VOP_CREATE_AP(struct vop_create_args *a) +{ + + return(VOP_CREATE_APV(a->a_dvp->v_op, a)); +} + +int +VOP_CREATE_APV(struct vop_vector *vop, struct vop_create_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_create_desc, a->a_dvp, + ("Wrong a_desc in vop_create(%p, %p)", a->a_dvp, a)); + while(vop != NULL && \ + vop->vop_create == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_dvp, ("No vop_create(%p, %p)", a->a_dvp, a)); + SDT_PROBE2(vfs, vop, vop_create, entry, a->a_dvp, a); + + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_CREATE"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_CREATE"); + KTR_START4(KTR_VOP, "VOP", "VOP_CREATE", (uintptr_t)a, + "dvp:0x%jX", (uintptr_t)a->a_dvp, "vpp:0x%jX", a->a_vpp, "cnp:0x%jX", a->a_cnp, "vap:0x%jX", a->a_vap); + VFS_PROLOGUE(a->a_dvp->v_mount); + if (vop->vop_create != NULL) + rc = vop->vop_create(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_dvp->v_mount); + SDT_PROBE3(vfs, vop, vop_create, return, a->a_dvp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_CREATE"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_CREATE"); + ASSERT_VI_UNLOCKED(*a->a_vpp, "VOP_CREATE"); + ASSERT_VOP_LOCKED(*a->a_vpp, "VOP_CREATE"); + } else { + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_CREATE"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_CREATE"); + } + vop_create_post(a, rc); + KTR_STOP4(KTR_VOP, "VOP", "VOP_CREATE", (uintptr_t)a, + "dvp:0x%jX", (uintptr_t)a->a_dvp, "vpp:0x%jX", a->a_vpp, "cnp:0x%jX", a->a_cnp, "vap:0x%jX", a->a_vap); + return (rc); +} + +struct vnodeop_desc vop_create_desc = { + "vop_create", + 0, + (vop_bypass_t *)VOP_CREATE_AP, + vop_create_vp_offsets, + VOPARG_OFFSETOF(struct vop_create_args,a_vpp), + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_create_args,a_cnp), +}; + +static int vop_whiteout_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_whiteout_args,a_dvp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_whiteout, entry, "struct vnode *", "struct vop_whiteout_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_whiteout, return, "struct vnode *", "struct vop_whiteout_args *", "int"); + + +int +VOP_WHITEOUT_AP(struct vop_whiteout_args *a) +{ + + return(VOP_WHITEOUT_APV(a->a_dvp->v_op, a)); +} + +int +VOP_WHITEOUT_APV(struct vop_vector *vop, struct vop_whiteout_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_whiteout_desc, a->a_dvp, + ("Wrong a_desc in vop_whiteout(%p, %p)", a->a_dvp, a)); + while(vop != NULL && \ + vop->vop_whiteout == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_dvp, ("No vop_whiteout(%p, %p)", a->a_dvp, a)); + SDT_PROBE2(vfs, vop, vop_whiteout, entry, a->a_dvp, a); + + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_WHITEOUT"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_WHITEOUT"); + KTR_START3(KTR_VOP, "VOP", "VOP_WHITEOUT", (uintptr_t)a, + "dvp:0x%jX", (uintptr_t)a->a_dvp, "cnp:0x%jX", a->a_cnp, "flags:0x%jX", a->a_flags); + VFS_PROLOGUE(a->a_dvp->v_mount); + if (vop->vop_whiteout != NULL) + rc = vop->vop_whiteout(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_dvp->v_mount); + SDT_PROBE3(vfs, vop, vop_whiteout, return, a->a_dvp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_WHITEOUT"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_WHITEOUT"); + } else { + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_WHITEOUT"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_WHITEOUT"); + } + KTR_STOP3(KTR_VOP, "VOP", "VOP_WHITEOUT", (uintptr_t)a, + "dvp:0x%jX", (uintptr_t)a->a_dvp, "cnp:0x%jX", a->a_cnp, "flags:0x%jX", a->a_flags); + return (rc); +} + +struct vnodeop_desc vop_whiteout_desc = { + "vop_whiteout", + 0, + (vop_bypass_t *)VOP_WHITEOUT_AP, + vop_whiteout_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_whiteout_args,a_cnp), +}; + +static int vop_mknod_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_mknod_args,a_dvp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_mknod, entry, "struct vnode *", "struct vop_mknod_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_mknod, return, "struct vnode *", "struct vop_mknod_args *", "int"); + + +int +VOP_MKNOD_AP(struct vop_mknod_args *a) +{ + + return(VOP_MKNOD_APV(a->a_dvp->v_op, a)); +} + +int +VOP_MKNOD_APV(struct vop_vector *vop, struct vop_mknod_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_mknod_desc, a->a_dvp, + ("Wrong a_desc in vop_mknod(%p, %p)", a->a_dvp, a)); + while(vop != NULL && \ + vop->vop_mknod == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_dvp, ("No vop_mknod(%p, %p)", a->a_dvp, a)); + SDT_PROBE2(vfs, vop, vop_mknod, entry, a->a_dvp, a); + + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_MKNOD"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_MKNOD"); + KTR_START4(KTR_VOP, "VOP", "VOP_MKNOD", (uintptr_t)a, + "dvp:0x%jX", (uintptr_t)a->a_dvp, "vpp:0x%jX", a->a_vpp, "cnp:0x%jX", a->a_cnp, "vap:0x%jX", a->a_vap); + VFS_PROLOGUE(a->a_dvp->v_mount); + if (vop->vop_mknod != NULL) + rc = vop->vop_mknod(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_dvp->v_mount); + SDT_PROBE3(vfs, vop, vop_mknod, return, a->a_dvp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_MKNOD"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_MKNOD"); + ASSERT_VI_UNLOCKED(*a->a_vpp, "VOP_MKNOD"); + ASSERT_VOP_LOCKED(*a->a_vpp, "VOP_MKNOD"); + } else { + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_MKNOD"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_MKNOD"); + } + vop_mknod_post(a, rc); + KTR_STOP4(KTR_VOP, "VOP", "VOP_MKNOD", (uintptr_t)a, + "dvp:0x%jX", (uintptr_t)a->a_dvp, "vpp:0x%jX", a->a_vpp, "cnp:0x%jX", a->a_cnp, "vap:0x%jX", a->a_vap); + return (rc); +} + +struct vnodeop_desc vop_mknod_desc = { + "vop_mknod", + 0, + (vop_bypass_t *)VOP_MKNOD_AP, + vop_mknod_vp_offsets, + VOPARG_OFFSETOF(struct vop_mknod_args,a_vpp), + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_mknod_args,a_cnp), +}; + +static int vop_open_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_open_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_open, entry, "struct vnode *", "struct vop_open_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_open, return, "struct vnode *", "struct vop_open_args *", "int"); + + +int +VOP_OPEN_AP(struct vop_open_args *a) +{ + + return(VOP_OPEN_APV(a->a_vp->v_op, a)); +} + +int +VOP_OPEN_APV(struct vop_vector *vop, struct vop_open_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_open_desc, a->a_vp, + ("Wrong a_desc in vop_open(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_open == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_open(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_open, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_OPEN"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_OPEN"); + KTR_START4(KTR_VOP, "VOP", "VOP_OPEN", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "mode:0x%jX", a->a_mode, "cred:0x%jX", a->a_cred, "td:0x%jX", a->a_td); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_open != NULL) + rc = vop->vop_open(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_open, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_OPEN"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_OPEN"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_OPEN"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_OPEN"); + } + vop_open_post(a, rc); + KTR_STOP4(KTR_VOP, "VOP", "VOP_OPEN", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "mode:0x%jX", a->a_mode, "cred:0x%jX", a->a_cred, "td:0x%jX", a->a_td); + return (rc); +} + +struct vnodeop_desc vop_open_desc = { + "vop_open", + 0, + (vop_bypass_t *)VOP_OPEN_AP, + vop_open_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_open_args,a_cred), + VOPARG_OFFSETOF(struct vop_open_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_close_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_close_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_close, entry, "struct vnode *", "struct vop_close_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_close, return, "struct vnode *", "struct vop_close_args *", "int"); + + +int +VOP_CLOSE_AP(struct vop_close_args *a) +{ + + return(VOP_CLOSE_APV(a->a_vp->v_op, a)); +} + +int +VOP_CLOSE_APV(struct vop_vector *vop, struct vop_close_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_close_desc, a->a_vp, + ("Wrong a_desc in vop_close(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_close == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_close(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_close, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_CLOSE"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_CLOSE"); + KTR_START4(KTR_VOP, "VOP", "VOP_CLOSE", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "fflag:0x%jX", a->a_fflag, "cred:0x%jX", a->a_cred, "td:0x%jX", a->a_td); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_close != NULL) + rc = vop->vop_close(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_close, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_CLOSE"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_CLOSE"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_CLOSE"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_CLOSE"); + } + vop_close_post(a, rc); + KTR_STOP4(KTR_VOP, "VOP", "VOP_CLOSE", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "fflag:0x%jX", a->a_fflag, "cred:0x%jX", a->a_cred, "td:0x%jX", a->a_td); + return (rc); +} + +struct vnodeop_desc vop_close_desc = { + "vop_close", + 0, + (vop_bypass_t *)VOP_CLOSE_AP, + vop_close_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_close_args,a_cred), + VOPARG_OFFSETOF(struct vop_close_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_access_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_access_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_access, entry, "struct vnode *", "struct vop_access_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_access, return, "struct vnode *", "struct vop_access_args *", "int"); + + +int +VOP_ACCESS_AP(struct vop_access_args *a) +{ + + return(VOP_ACCESS_APV(a->a_vp->v_op, a)); +} + +int +VOP_ACCESS_APV(struct vop_vector *vop, struct vop_access_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_access_desc, a->a_vp, + ("Wrong a_desc in vop_access(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_access == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_access(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_access, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ACCESS"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_ACCESS"); + KTR_START4(KTR_VOP, "VOP", "VOP_ACCESS", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "accmode:0x%jX", a->a_accmode, "cred:0x%jX", a->a_cred, "td:0x%jX", a->a_td); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_access != NULL) + rc = vop->vop_access(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_access, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ACCESS"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_ACCESS"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ACCESS"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_ACCESS"); + } + KTR_STOP4(KTR_VOP, "VOP", "VOP_ACCESS", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "accmode:0x%jX", a->a_accmode, "cred:0x%jX", a->a_cred, "td:0x%jX", a->a_td); + return (rc); +} + +struct vnodeop_desc vop_access_desc = { + "vop_access", + 0, + (vop_bypass_t *)VOP_ACCESS_AP, + vop_access_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_access_args,a_cred), + VOPARG_OFFSETOF(struct vop_access_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_accessx_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_accessx_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_accessx, entry, "struct vnode *", "struct vop_accessx_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_accessx, return, "struct vnode *", "struct vop_accessx_args *", "int"); + + +int +VOP_ACCESSX_AP(struct vop_accessx_args *a) +{ + + return(VOP_ACCESSX_APV(a->a_vp->v_op, a)); +} + +int +VOP_ACCESSX_APV(struct vop_vector *vop, struct vop_accessx_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_accessx_desc, a->a_vp, + ("Wrong a_desc in vop_accessx(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_accessx == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_accessx(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_accessx, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ACCESSX"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_ACCESSX"); + KTR_START4(KTR_VOP, "VOP", "VOP_ACCESSX", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "accmode:0x%jX", a->a_accmode, "cred:0x%jX", a->a_cred, "td:0x%jX", a->a_td); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_accessx != NULL) + rc = vop->vop_accessx(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_accessx, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ACCESSX"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_ACCESSX"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ACCESSX"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_ACCESSX"); + } + KTR_STOP4(KTR_VOP, "VOP", "VOP_ACCESSX", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "accmode:0x%jX", a->a_accmode, "cred:0x%jX", a->a_cred, "td:0x%jX", a->a_td); + return (rc); +} + +struct vnodeop_desc vop_accessx_desc = { + "vop_accessx", + 0, + (vop_bypass_t *)VOP_ACCESSX_AP, + vop_accessx_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_accessx_args,a_cred), + VOPARG_OFFSETOF(struct vop_accessx_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_getattr_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_getattr_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_getattr, entry, "struct vnode *", "struct vop_getattr_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_getattr, return, "struct vnode *", "struct vop_getattr_args *", "int"); + + +int +VOP_GETATTR_AP(struct vop_getattr_args *a) +{ + + return(VOP_GETATTR_APV(a->a_vp->v_op, a)); +} + +int +VOP_GETATTR_APV(struct vop_vector *vop, struct vop_getattr_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_getattr_desc, a->a_vp, + ("Wrong a_desc in vop_getattr(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_getattr == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_getattr(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_getattr, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GETATTR"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_GETATTR"); + KTR_START3(KTR_VOP, "VOP", "VOP_GETATTR", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "vap:0x%jX", a->a_vap, "cred:0x%jX", a->a_cred); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_getattr != NULL) + rc = vop->vop_getattr(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_getattr, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GETATTR"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_GETATTR"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GETATTR"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_GETATTR"); + } + KTR_STOP3(KTR_VOP, "VOP", "VOP_GETATTR", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "vap:0x%jX", a->a_vap, "cred:0x%jX", a->a_cred); + return (rc); +} + +struct vnodeop_desc vop_getattr_desc = { + "vop_getattr", + 0, + (vop_bypass_t *)VOP_GETATTR_AP, + vop_getattr_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_getattr_args,a_cred), + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_setattr_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_setattr_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_setattr, entry, "struct vnode *", "struct vop_setattr_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_setattr, return, "struct vnode *", "struct vop_setattr_args *", "int"); + + +int +VOP_SETATTR_AP(struct vop_setattr_args *a) +{ + + return(VOP_SETATTR_APV(a->a_vp->v_op, a)); +} + +int +VOP_SETATTR_APV(struct vop_vector *vop, struct vop_setattr_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_setattr_desc, a->a_vp, + ("Wrong a_desc in vop_setattr(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_setattr == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_setattr(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_setattr, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_SETATTR"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_SETATTR"); + KTR_START3(KTR_VOP, "VOP", "VOP_SETATTR", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "vap:0x%jX", a->a_vap, "cred:0x%jX", a->a_cred); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_setattr != NULL) + rc = vop->vop_setattr(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_setattr, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_SETATTR"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_SETATTR"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_SETATTR"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_SETATTR"); + } + vop_setattr_post(a, rc); + KTR_STOP3(KTR_VOP, "VOP", "VOP_SETATTR", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "vap:0x%jX", a->a_vap, "cred:0x%jX", a->a_cred); + return (rc); +} + +struct vnodeop_desc vop_setattr_desc = { + "vop_setattr", + 0, + (vop_bypass_t *)VOP_SETATTR_AP, + vop_setattr_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_setattr_args,a_cred), + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_markatime_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_markatime_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_markatime, entry, "struct vnode *", "struct vop_markatime_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_markatime, return, "struct vnode *", "struct vop_markatime_args *", "int"); + + +int +VOP_MARKATIME_AP(struct vop_markatime_args *a) +{ + + return(VOP_MARKATIME_APV(a->a_vp->v_op, a)); +} + +int +VOP_MARKATIME_APV(struct vop_vector *vop, struct vop_markatime_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_markatime_desc, a->a_vp, + ("Wrong a_desc in vop_markatime(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_markatime == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_markatime(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_markatime, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_MARKATIME"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_MARKATIME"); + KTR_START1(KTR_VOP, "VOP", "VOP_MARKATIME", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_markatime != NULL) + rc = vop->vop_markatime(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_markatime, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_MARKATIME"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_MARKATIME"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_MARKATIME"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_MARKATIME"); + } + KTR_STOP1(KTR_VOP, "VOP", "VOP_MARKATIME", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + return (rc); +} + +struct vnodeop_desc vop_markatime_desc = { + "vop_markatime", + 0, + (vop_bypass_t *)VOP_MARKATIME_AP, + vop_markatime_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_read_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_read_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_read, entry, "struct vnode *", "struct vop_read_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_read, return, "struct vnode *", "struct vop_read_args *", "int"); + + +int +VOP_READ_AP(struct vop_read_args *a) +{ + + return(VOP_READ_APV(a->a_vp->v_op, a)); +} + +int +VOP_READ_APV(struct vop_vector *vop, struct vop_read_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_read_desc, a->a_vp, + ("Wrong a_desc in vop_read(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_read == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_read(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_read, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_READ"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_READ"); + KTR_START4(KTR_VOP, "VOP", "VOP_READ", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "uio:0x%jX", a->a_uio, "ioflag:0x%jX", a->a_ioflag, "cred:0x%jX", a->a_cred); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_read != NULL) + rc = vop->vop_read(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_read, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_READ"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_READ"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_READ"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_READ"); + } + vop_read_post(a, rc); + KTR_STOP4(KTR_VOP, "VOP", "VOP_READ", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "uio:0x%jX", a->a_uio, "ioflag:0x%jX", a->a_ioflag, "cred:0x%jX", a->a_cred); + return (rc); +} + +struct vnodeop_desc vop_read_desc = { + "vop_read", + 0, + (vop_bypass_t *)VOP_READ_AP, + vop_read_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_read_args,a_cred), + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_write_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_write_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_write, entry, "struct vnode *", "struct vop_write_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_write, return, "struct vnode *", "struct vop_write_args *", "int"); + + +int +VOP_WRITE_AP(struct vop_write_args *a) +{ + + return(VOP_WRITE_APV(a->a_vp->v_op, a)); +} + +int +VOP_WRITE_APV(struct vop_vector *vop, struct vop_write_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_write_desc, a->a_vp, + ("Wrong a_desc in vop_write(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_write == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_write(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_write, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_WRITE"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_WRITE"); + KTR_START4(KTR_VOP, "VOP", "VOP_WRITE", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "uio:0x%jX", a->a_uio, "ioflag:0x%jX", a->a_ioflag, "cred:0x%jX", a->a_cred); + VOP_WRITE_PRE(a); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_write != NULL) + rc = vop->vop_write(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_write, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_WRITE"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_WRITE"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_WRITE"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_WRITE"); + } + VOP_WRITE_POST(a, rc); + KTR_STOP4(KTR_VOP, "VOP", "VOP_WRITE", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "uio:0x%jX", a->a_uio, "ioflag:0x%jX", a->a_ioflag, "cred:0x%jX", a->a_cred); + return (rc); +} + +struct vnodeop_desc vop_write_desc = { + "vop_write", + 0, + (vop_bypass_t *)VOP_WRITE_AP, + vop_write_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_write_args,a_cred), + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_ioctl_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_ioctl_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_ioctl, entry, "struct vnode *", "struct vop_ioctl_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_ioctl, return, "struct vnode *", "struct vop_ioctl_args *", "int"); + + +int +VOP_IOCTL_AP(struct vop_ioctl_args *a) +{ + + return(VOP_IOCTL_APV(a->a_vp->v_op, a)); +} + +int +VOP_IOCTL_APV(struct vop_vector *vop, struct vop_ioctl_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_ioctl_desc, a->a_vp, + ("Wrong a_desc in vop_ioctl(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_ioctl == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_ioctl(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_ioctl, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_IOCTL"); + ASSERT_VOP_UNLOCKED(a->a_vp, "VOP_IOCTL"); + KTR_START4(KTR_VOP, "VOP", "VOP_IOCTL", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "command:0x%jX", a->a_command, "data:0x%jX", a->a_data, "fflag:0x%jX", a->a_fflag); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_ioctl != NULL) + rc = vop->vop_ioctl(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_ioctl, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_IOCTL"); + ASSERT_VOP_UNLOCKED(a->a_vp, "VOP_IOCTL"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_IOCTL"); + ASSERT_VOP_UNLOCKED(a->a_vp, "VOP_IOCTL"); + } + KTR_STOP4(KTR_VOP, "VOP", "VOP_IOCTL", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "command:0x%jX", a->a_command, "data:0x%jX", a->a_data, "fflag:0x%jX", a->a_fflag); + return (rc); +} + +struct vnodeop_desc vop_ioctl_desc = { + "vop_ioctl", + 0, + (vop_bypass_t *)VOP_IOCTL_AP, + vop_ioctl_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_ioctl_args,a_cred), + VOPARG_OFFSETOF(struct vop_ioctl_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_poll_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_poll_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_poll, entry, "struct vnode *", "struct vop_poll_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_poll, return, "struct vnode *", "struct vop_poll_args *", "int"); + + +int +VOP_POLL_AP(struct vop_poll_args *a) +{ + + return(VOP_POLL_APV(a->a_vp->v_op, a)); +} + +int +VOP_POLL_APV(struct vop_vector *vop, struct vop_poll_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_poll_desc, a->a_vp, + ("Wrong a_desc in vop_poll(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_poll == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_poll(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_poll, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_POLL"); + ASSERT_VOP_UNLOCKED(a->a_vp, "VOP_POLL"); + KTR_START4(KTR_VOP, "VOP", "VOP_POLL", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "events:0x%jX", a->a_events, "cred:0x%jX", a->a_cred, "td:0x%jX", a->a_td); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_poll != NULL) + rc = vop->vop_poll(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_poll, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_POLL"); + ASSERT_VOP_UNLOCKED(a->a_vp, "VOP_POLL"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_POLL"); + ASSERT_VOP_UNLOCKED(a->a_vp, "VOP_POLL"); + } + KTR_STOP4(KTR_VOP, "VOP", "VOP_POLL", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "events:0x%jX", a->a_events, "cred:0x%jX", a->a_cred, "td:0x%jX", a->a_td); + return (rc); +} + +struct vnodeop_desc vop_poll_desc = { + "vop_poll", + 0, + (vop_bypass_t *)VOP_POLL_AP, + vop_poll_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_poll_args,a_cred), + VOPARG_OFFSETOF(struct vop_poll_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_kqfilter_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_kqfilter_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_kqfilter, entry, "struct vnode *", "struct vop_kqfilter_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_kqfilter, return, "struct vnode *", "struct vop_kqfilter_args *", "int"); + + +int +VOP_KQFILTER_AP(struct vop_kqfilter_args *a) +{ + + return(VOP_KQFILTER_APV(a->a_vp->v_op, a)); +} + +int +VOP_KQFILTER_APV(struct vop_vector *vop, struct vop_kqfilter_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_kqfilter_desc, a->a_vp, + ("Wrong a_desc in vop_kqfilter(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_kqfilter == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_kqfilter(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_kqfilter, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_KQFILTER"); + ASSERT_VOP_UNLOCKED(a->a_vp, "VOP_KQFILTER"); + KTR_START2(KTR_VOP, "VOP", "VOP_KQFILTER", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "kn:0x%jX", a->a_kn); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_kqfilter != NULL) + rc = vop->vop_kqfilter(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_kqfilter, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_KQFILTER"); + ASSERT_VOP_UNLOCKED(a->a_vp, "VOP_KQFILTER"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_KQFILTER"); + ASSERT_VOP_UNLOCKED(a->a_vp, "VOP_KQFILTER"); + } + KTR_STOP2(KTR_VOP, "VOP", "VOP_KQFILTER", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "kn:0x%jX", a->a_kn); + return (rc); +} + +struct vnodeop_desc vop_kqfilter_desc = { + "vop_kqfilter", + 0, + (vop_bypass_t *)VOP_KQFILTER_AP, + vop_kqfilter_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_revoke_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_revoke_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_revoke, entry, "struct vnode *", "struct vop_revoke_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_revoke, return, "struct vnode *", "struct vop_revoke_args *", "int"); + + +int +VOP_REVOKE_AP(struct vop_revoke_args *a) +{ + + return(VOP_REVOKE_APV(a->a_vp->v_op, a)); +} + +int +VOP_REVOKE_APV(struct vop_vector *vop, struct vop_revoke_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_revoke_desc, a->a_vp, + ("Wrong a_desc in vop_revoke(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_revoke == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_revoke(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_revoke, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_REVOKE"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_REVOKE"); + KTR_START2(KTR_VOP, "VOP", "VOP_REVOKE", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "flags:0x%jX", a->a_flags); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_revoke != NULL) + rc = vop->vop_revoke(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_revoke, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_REVOKE"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_REVOKE"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_REVOKE"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_REVOKE"); + } + KTR_STOP2(KTR_VOP, "VOP", "VOP_REVOKE", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "flags:0x%jX", a->a_flags); + return (rc); +} + +struct vnodeop_desc vop_revoke_desc = { + "vop_revoke", + 0, + (vop_bypass_t *)VOP_REVOKE_AP, + vop_revoke_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_fsync_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_fsync_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_fsync, entry, "struct vnode *", "struct vop_fsync_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_fsync, return, "struct vnode *", "struct vop_fsync_args *", "int"); + + +int +VOP_FSYNC_AP(struct vop_fsync_args *a) +{ + + return(VOP_FSYNC_APV(a->a_vp->v_op, a)); +} + +int +VOP_FSYNC_APV(struct vop_vector *vop, struct vop_fsync_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_fsync_desc, a->a_vp, + ("Wrong a_desc in vop_fsync(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_fsync == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_fsync(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_fsync, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_FSYNC"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_FSYNC"); + KTR_START3(KTR_VOP, "VOP", "VOP_FSYNC", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "waitfor:0x%jX", a->a_waitfor, "td:0x%jX", a->a_td); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_fsync != NULL) + rc = vop->vop_fsync(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_fsync, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_FSYNC"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_FSYNC"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_FSYNC"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_FSYNC"); + } + KTR_STOP3(KTR_VOP, "VOP", "VOP_FSYNC", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "waitfor:0x%jX", a->a_waitfor, "td:0x%jX", a->a_td); + return (rc); +} + +struct vnodeop_desc vop_fsync_desc = { + "vop_fsync", + 0, + (vop_bypass_t *)VOP_FSYNC_AP, + vop_fsync_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_fsync_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_remove_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_remove_args,a_dvp), + VOPARG_OFFSETOF(struct vop_remove_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_remove, entry, "struct vnode *", "struct vop_remove_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_remove, return, "struct vnode *", "struct vop_remove_args *", "int"); + + +int +VOP_REMOVE_AP(struct vop_remove_args *a) +{ + + return(VOP_REMOVE_APV(a->a_dvp->v_op, a)); +} + +int +VOP_REMOVE_APV(struct vop_vector *vop, struct vop_remove_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_remove_desc, a->a_dvp, + ("Wrong a_desc in vop_remove(%p, %p)", a->a_dvp, a)); + while(vop != NULL && \ + vop->vop_remove == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_dvp, ("No vop_remove(%p, %p)", a->a_dvp, a)); + SDT_PROBE2(vfs, vop, vop_remove, entry, a->a_dvp, a); + + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_REMOVE"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_REMOVE"); + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_REMOVE"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_REMOVE"); + KTR_START3(KTR_VOP, "VOP", "VOP_REMOVE", (uintptr_t)a, + "dvp:0x%jX", (uintptr_t)a->a_dvp, "vp:0x%jX", a->a_vp, "cnp:0x%jX", a->a_cnp); + VFS_PROLOGUE(a->a_dvp->v_mount); + if (vop->vop_remove != NULL) + rc = vop->vop_remove(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_dvp->v_mount); + SDT_PROBE3(vfs, vop, vop_remove, return, a->a_dvp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_REMOVE"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_REMOVE"); + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_REMOVE"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_REMOVE"); + } else { + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_REMOVE"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_REMOVE"); + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_REMOVE"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_REMOVE"); + } + vop_remove_post(a, rc); + KTR_STOP3(KTR_VOP, "VOP", "VOP_REMOVE", (uintptr_t)a, + "dvp:0x%jX", (uintptr_t)a->a_dvp, "vp:0x%jX", a->a_vp, "cnp:0x%jX", a->a_cnp); + return (rc); +} + +struct vnodeop_desc vop_remove_desc = { + "vop_remove", + 0, + (vop_bypass_t *)VOP_REMOVE_AP, + vop_remove_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_remove_args,a_cnp), +}; + +static int vop_link_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_link_args,a_tdvp), + VOPARG_OFFSETOF(struct vop_link_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_link, entry, "struct vnode *", "struct vop_link_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_link, return, "struct vnode *", "struct vop_link_args *", "int"); + + +int +VOP_LINK_AP(struct vop_link_args *a) +{ + + return(VOP_LINK_APV(a->a_tdvp->v_op, a)); +} + +int +VOP_LINK_APV(struct vop_vector *vop, struct vop_link_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_link_desc, a->a_tdvp, + ("Wrong a_desc in vop_link(%p, %p)", a->a_tdvp, a)); + while(vop != NULL && \ + vop->vop_link == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_tdvp, ("No vop_link(%p, %p)", a->a_tdvp, a)); + SDT_PROBE2(vfs, vop, vop_link, entry, a->a_tdvp, a); + + ASSERT_VI_UNLOCKED(a->a_tdvp, "VOP_LINK"); + ASSERT_VOP_ELOCKED(a->a_tdvp, "VOP_LINK"); + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_LINK"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_LINK"); + KTR_START3(KTR_VOP, "VOP", "VOP_LINK", (uintptr_t)a, + "tdvp:0x%jX", (uintptr_t)a->a_tdvp, "vp:0x%jX", a->a_vp, "cnp:0x%jX", a->a_cnp); + VFS_PROLOGUE(a->a_tdvp->v_mount); + if (vop->vop_link != NULL) + rc = vop->vop_link(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_tdvp->v_mount); + SDT_PROBE3(vfs, vop, vop_link, return, a->a_tdvp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_tdvp, "VOP_LINK"); + ASSERT_VOP_ELOCKED(a->a_tdvp, "VOP_LINK"); + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_LINK"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_LINK"); + } else { + ASSERT_VI_UNLOCKED(a->a_tdvp, "VOP_LINK"); + ASSERT_VOP_ELOCKED(a->a_tdvp, "VOP_LINK"); + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_LINK"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_LINK"); + } + vop_link_post(a, rc); + KTR_STOP3(KTR_VOP, "VOP", "VOP_LINK", (uintptr_t)a, + "tdvp:0x%jX", (uintptr_t)a->a_tdvp, "vp:0x%jX", a->a_vp, "cnp:0x%jX", a->a_cnp); + return (rc); +} + +struct vnodeop_desc vop_link_desc = { + "vop_link", + 0, + (vop_bypass_t *)VOP_LINK_AP, + vop_link_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_link_args,a_cnp), +}; + +static int vop_rename_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_rename_args,a_fdvp), + VOPARG_OFFSETOF(struct vop_rename_args,a_fvp), + VOPARG_OFFSETOF(struct vop_rename_args,a_tdvp), + VOPARG_OFFSETOF(struct vop_rename_args,a_tvp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_rename, entry, "struct vnode *", "struct vop_rename_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_rename, return, "struct vnode *", "struct vop_rename_args *", "int"); + + +int +VOP_RENAME_AP(struct vop_rename_args *a) +{ + + return(VOP_RENAME_APV(a->a_fdvp->v_op, a)); +} + +int +VOP_RENAME_APV(struct vop_vector *vop, struct vop_rename_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_rename_desc, a->a_fdvp, + ("Wrong a_desc in vop_rename(%p, %p)", a->a_fdvp, a)); + while(vop != NULL && \ + vop->vop_rename == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_fdvp, ("No vop_rename(%p, %p)", a->a_fdvp, a)); + SDT_PROBE2(vfs, vop, vop_rename, entry, a->a_fdvp, a); + + KTR_START4(KTR_VOP, "VOP", "VOP_RENAME", (uintptr_t)a, + "fdvp:0x%jX", (uintptr_t)a->a_fdvp, "fvp:0x%jX", a->a_fvp, "fcnp:0x%jX", a->a_fcnp, "tdvp:0x%jX", a->a_tdvp); + vop_rename_pre(a); + VFS_PROLOGUE(a->a_fdvp->v_mount); + if (vop->vop_rename != NULL) + rc = vop->vop_rename(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_fdvp->v_mount); + SDT_PROBE3(vfs, vop, vop_rename, return, a->a_fdvp, a, rc); + + if (rc == 0) { + } else { + } + vop_rename_post(a, rc); + KTR_STOP4(KTR_VOP, "VOP", "VOP_RENAME", (uintptr_t)a, + "fdvp:0x%jX", (uintptr_t)a->a_fdvp, "fvp:0x%jX", a->a_fvp, "fcnp:0x%jX", a->a_fcnp, "tdvp:0x%jX", a->a_tdvp); + return (rc); +} + +struct vnodeop_desc vop_rename_desc = { + "vop_rename", + VDESC_VP0_WILLRELE|VDESC_VP1_WILLRELE|VDESC_VP2_WILLRELE|VDESC_VP3_WILLRELE, + (vop_bypass_t *)VOP_RENAME_AP, + vop_rename_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_rename_args,a_fcnp), +}; + +static int vop_mkdir_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_mkdir_args,a_dvp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_mkdir, entry, "struct vnode *", "struct vop_mkdir_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_mkdir, return, "struct vnode *", "struct vop_mkdir_args *", "int"); + + +int +VOP_MKDIR_AP(struct vop_mkdir_args *a) +{ + + return(VOP_MKDIR_APV(a->a_dvp->v_op, a)); +} + +int +VOP_MKDIR_APV(struct vop_vector *vop, struct vop_mkdir_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_mkdir_desc, a->a_dvp, + ("Wrong a_desc in vop_mkdir(%p, %p)", a->a_dvp, a)); + while(vop != NULL && \ + vop->vop_mkdir == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_dvp, ("No vop_mkdir(%p, %p)", a->a_dvp, a)); + SDT_PROBE2(vfs, vop, vop_mkdir, entry, a->a_dvp, a); + + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_MKDIR"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_MKDIR"); + KTR_START4(KTR_VOP, "VOP", "VOP_MKDIR", (uintptr_t)a, + "dvp:0x%jX", (uintptr_t)a->a_dvp, "vpp:0x%jX", a->a_vpp, "cnp:0x%jX", a->a_cnp, "vap:0x%jX", a->a_vap); + VFS_PROLOGUE(a->a_dvp->v_mount); + if (vop->vop_mkdir != NULL) + rc = vop->vop_mkdir(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_dvp->v_mount); + SDT_PROBE3(vfs, vop, vop_mkdir, return, a->a_dvp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_MKDIR"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_MKDIR"); + ASSERT_VI_UNLOCKED(*a->a_vpp, "VOP_MKDIR"); + ASSERT_VOP_ELOCKED(*a->a_vpp, "VOP_MKDIR"); + } else { + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_MKDIR"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_MKDIR"); + } + vop_mkdir_post(a, rc); + KTR_STOP4(KTR_VOP, "VOP", "VOP_MKDIR", (uintptr_t)a, + "dvp:0x%jX", (uintptr_t)a->a_dvp, "vpp:0x%jX", a->a_vpp, "cnp:0x%jX", a->a_cnp, "vap:0x%jX", a->a_vap); + return (rc); +} + +struct vnodeop_desc vop_mkdir_desc = { + "vop_mkdir", + 0, + (vop_bypass_t *)VOP_MKDIR_AP, + vop_mkdir_vp_offsets, + VOPARG_OFFSETOF(struct vop_mkdir_args,a_vpp), + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_mkdir_args,a_cnp), +}; + +static int vop_rmdir_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_rmdir_args,a_dvp), + VOPARG_OFFSETOF(struct vop_rmdir_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_rmdir, entry, "struct vnode *", "struct vop_rmdir_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_rmdir, return, "struct vnode *", "struct vop_rmdir_args *", "int"); + + +int +VOP_RMDIR_AP(struct vop_rmdir_args *a) +{ + + return(VOP_RMDIR_APV(a->a_dvp->v_op, a)); +} + +int +VOP_RMDIR_APV(struct vop_vector *vop, struct vop_rmdir_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_rmdir_desc, a->a_dvp, + ("Wrong a_desc in vop_rmdir(%p, %p)", a->a_dvp, a)); + while(vop != NULL && \ + vop->vop_rmdir == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_dvp, ("No vop_rmdir(%p, %p)", a->a_dvp, a)); + SDT_PROBE2(vfs, vop, vop_rmdir, entry, a->a_dvp, a); + + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_RMDIR"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_RMDIR"); + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_RMDIR"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_RMDIR"); + KTR_START3(KTR_VOP, "VOP", "VOP_RMDIR", (uintptr_t)a, + "dvp:0x%jX", (uintptr_t)a->a_dvp, "vp:0x%jX", a->a_vp, "cnp:0x%jX", a->a_cnp); + VFS_PROLOGUE(a->a_dvp->v_mount); + if (vop->vop_rmdir != NULL) + rc = vop->vop_rmdir(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_dvp->v_mount); + SDT_PROBE3(vfs, vop, vop_rmdir, return, a->a_dvp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_RMDIR"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_RMDIR"); + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_RMDIR"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_RMDIR"); + } else { + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_RMDIR"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_RMDIR"); + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_RMDIR"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_RMDIR"); + } + vop_rmdir_post(a, rc); + KTR_STOP3(KTR_VOP, "VOP", "VOP_RMDIR", (uintptr_t)a, + "dvp:0x%jX", (uintptr_t)a->a_dvp, "vp:0x%jX", a->a_vp, "cnp:0x%jX", a->a_cnp); + return (rc); +} + +struct vnodeop_desc vop_rmdir_desc = { + "vop_rmdir", + 0, + (vop_bypass_t *)VOP_RMDIR_AP, + vop_rmdir_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_rmdir_args,a_cnp), +}; + +static int vop_symlink_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_symlink_args,a_dvp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_symlink, entry, "struct vnode *", "struct vop_symlink_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_symlink, return, "struct vnode *", "struct vop_symlink_args *", "int"); + + +int +VOP_SYMLINK_AP(struct vop_symlink_args *a) +{ + + return(VOP_SYMLINK_APV(a->a_dvp->v_op, a)); +} + +int +VOP_SYMLINK_APV(struct vop_vector *vop, struct vop_symlink_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_symlink_desc, a->a_dvp, + ("Wrong a_desc in vop_symlink(%p, %p)", a->a_dvp, a)); + while(vop != NULL && \ + vop->vop_symlink == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_dvp, ("No vop_symlink(%p, %p)", a->a_dvp, a)); + SDT_PROBE2(vfs, vop, vop_symlink, entry, a->a_dvp, a); + + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_SYMLINK"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_SYMLINK"); + KTR_START4(KTR_VOP, "VOP", "VOP_SYMLINK", (uintptr_t)a, + "dvp:0x%jX", (uintptr_t)a->a_dvp, "vpp:0x%jX", a->a_vpp, "cnp:0x%jX", a->a_cnp, "vap:0x%jX", a->a_vap); + VFS_PROLOGUE(a->a_dvp->v_mount); + if (vop->vop_symlink != NULL) + rc = vop->vop_symlink(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_dvp->v_mount); + SDT_PROBE3(vfs, vop, vop_symlink, return, a->a_dvp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_SYMLINK"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_SYMLINK"); + ASSERT_VI_UNLOCKED(*a->a_vpp, "VOP_SYMLINK"); + ASSERT_VOP_ELOCKED(*a->a_vpp, "VOP_SYMLINK"); + } else { + ASSERT_VI_UNLOCKED(a->a_dvp, "VOP_SYMLINK"); + ASSERT_VOP_ELOCKED(a->a_dvp, "VOP_SYMLINK"); + } + vop_symlink_post(a, rc); + KTR_STOP4(KTR_VOP, "VOP", "VOP_SYMLINK", (uintptr_t)a, + "dvp:0x%jX", (uintptr_t)a->a_dvp, "vpp:0x%jX", a->a_vpp, "cnp:0x%jX", a->a_cnp, "vap:0x%jX", a->a_vap); + return (rc); +} + +struct vnodeop_desc vop_symlink_desc = { + "vop_symlink", + 0, + (vop_bypass_t *)VOP_SYMLINK_AP, + vop_symlink_vp_offsets, + VOPARG_OFFSETOF(struct vop_symlink_args,a_vpp), + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_symlink_args,a_cnp), +}; + +static int vop_readdir_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_readdir_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_readdir, entry, "struct vnode *", "struct vop_readdir_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_readdir, return, "struct vnode *", "struct vop_readdir_args *", "int"); + + +int +VOP_READDIR_AP(struct vop_readdir_args *a) +{ + + return(VOP_READDIR_APV(a->a_vp->v_op, a)); +} + +int +VOP_READDIR_APV(struct vop_vector *vop, struct vop_readdir_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_readdir_desc, a->a_vp, + ("Wrong a_desc in vop_readdir(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_readdir == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_readdir(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_readdir, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_READDIR"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_READDIR"); + KTR_START4(KTR_VOP, "VOP", "VOP_READDIR", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "uio:0x%jX", a->a_uio, "cred:0x%jX", a->a_cred, "eofflag:0x%jX", a->a_eofflag); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_readdir != NULL) + rc = vop->vop_readdir(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_readdir, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_READDIR"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_READDIR"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_READDIR"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_READDIR"); + } + vop_readdir_post(a, rc); + KTR_STOP4(KTR_VOP, "VOP", "VOP_READDIR", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "uio:0x%jX", a->a_uio, "cred:0x%jX", a->a_cred, "eofflag:0x%jX", a->a_eofflag); + return (rc); +} + +struct vnodeop_desc vop_readdir_desc = { + "vop_readdir", + 0, + (vop_bypass_t *)VOP_READDIR_AP, + vop_readdir_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_readdir_args,a_cred), + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_readlink_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_readlink_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_readlink, entry, "struct vnode *", "struct vop_readlink_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_readlink, return, "struct vnode *", "struct vop_readlink_args *", "int"); + + +int +VOP_READLINK_AP(struct vop_readlink_args *a) +{ + + return(VOP_READLINK_APV(a->a_vp->v_op, a)); +} + +int +VOP_READLINK_APV(struct vop_vector *vop, struct vop_readlink_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_readlink_desc, a->a_vp, + ("Wrong a_desc in vop_readlink(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_readlink == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_readlink(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_readlink, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_READLINK"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_READLINK"); + KTR_START3(KTR_VOP, "VOP", "VOP_READLINK", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "uio:0x%jX", a->a_uio, "cred:0x%jX", a->a_cred); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_readlink != NULL) + rc = vop->vop_readlink(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_readlink, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_READLINK"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_READLINK"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_READLINK"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_READLINK"); + } + KTR_STOP3(KTR_VOP, "VOP", "VOP_READLINK", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "uio:0x%jX", a->a_uio, "cred:0x%jX", a->a_cred); + return (rc); +} + +struct vnodeop_desc vop_readlink_desc = { + "vop_readlink", + 0, + (vop_bypass_t *)VOP_READLINK_AP, + vop_readlink_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_readlink_args,a_cred), + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_inactive_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_inactive_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_inactive, entry, "struct vnode *", "struct vop_inactive_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_inactive, return, "struct vnode *", "struct vop_inactive_args *", "int"); + + +int +VOP_INACTIVE_AP(struct vop_inactive_args *a) +{ + + return(VOP_INACTIVE_APV(a->a_vp->v_op, a)); +} + +int +VOP_INACTIVE_APV(struct vop_vector *vop, struct vop_inactive_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_inactive_desc, a->a_vp, + ("Wrong a_desc in vop_inactive(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_inactive == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_inactive(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_inactive, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_INACTIVE"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_INACTIVE"); + KTR_START2(KTR_VOP, "VOP", "VOP_INACTIVE", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "td:0x%jX", a->a_td); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_inactive != NULL) + rc = vop->vop_inactive(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_inactive, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_INACTIVE"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_INACTIVE"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_INACTIVE"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_INACTIVE"); + } + KTR_STOP2(KTR_VOP, "VOP", "VOP_INACTIVE", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "td:0x%jX", a->a_td); + return (rc); +} + +struct vnodeop_desc vop_inactive_desc = { + "vop_inactive", + 0, + (vop_bypass_t *)VOP_INACTIVE_AP, + vop_inactive_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_inactive_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_reclaim_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_reclaim_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_reclaim, entry, "struct vnode *", "struct vop_reclaim_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_reclaim, return, "struct vnode *", "struct vop_reclaim_args *", "int"); + + +int +VOP_RECLAIM_AP(struct vop_reclaim_args *a) +{ + + return(VOP_RECLAIM_APV(a->a_vp->v_op, a)); +} + +int +VOP_RECLAIM_APV(struct vop_vector *vop, struct vop_reclaim_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_reclaim_desc, a->a_vp, + ("Wrong a_desc in vop_reclaim(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_reclaim == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_reclaim(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_reclaim, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_RECLAIM"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_RECLAIM"); + KTR_START2(KTR_VOP, "VOP", "VOP_RECLAIM", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "td:0x%jX", a->a_td); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_reclaim != NULL) + rc = vop->vop_reclaim(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_reclaim, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_RECLAIM"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_RECLAIM"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_RECLAIM"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_RECLAIM"); + } + vop_reclaim_post(a, rc); + KTR_STOP2(KTR_VOP, "VOP", "VOP_RECLAIM", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "td:0x%jX", a->a_td); + return (rc); +} + +struct vnodeop_desc vop_reclaim_desc = { + "vop_reclaim", + 0, + (vop_bypass_t *)VOP_RECLAIM_AP, + vop_reclaim_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_reclaim_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_lock1_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_lock1_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_lock1, entry, "struct vnode *", "struct vop_lock1_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_lock1, return, "struct vnode *", "struct vop_lock1_args *", "int"); + + +int +VOP_LOCK1_AP(struct vop_lock1_args *a) +{ + + return(VOP_LOCK1_APV(a->a_vp->v_op, a)); +} + +int +VOP_LOCK1_APV(struct vop_vector *vop, struct vop_lock1_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_lock1_desc, a->a_vp, + ("Wrong a_desc in vop_lock1(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_lock1 == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_lock1(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_lock1, entry, a->a_vp, a); + + KTR_START4(KTR_VOP, "VOP", "VOP_LOCK1", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "flags:0x%jX", a->a_flags, "file:0x%jX", a->a_file, "line:0x%jX", a->a_line); + vop_lock_pre(a); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_lock1 != NULL) + rc = vop->vop_lock1(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_lock1, return, a->a_vp, a, rc); + + if (rc == 0) { + } else { + } + vop_lock_post(a, rc); + KTR_STOP4(KTR_VOP, "VOP", "VOP_LOCK1", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "flags:0x%jX", a->a_flags, "file:0x%jX", a->a_file, "line:0x%jX", a->a_line); + return (rc); +} + +struct vnodeop_desc vop_lock1_desc = { + "vop_lock1", + 0, + (vop_bypass_t *)VOP_LOCK1_AP, + vop_lock1_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_unlock_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_unlock_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_unlock, entry, "struct vnode *", "struct vop_unlock_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_unlock, return, "struct vnode *", "struct vop_unlock_args *", "int"); + + +int +VOP_UNLOCK_AP(struct vop_unlock_args *a) +{ + + return(VOP_UNLOCK_APV(a->a_vp->v_op, a)); +} + +int +VOP_UNLOCK_APV(struct vop_vector *vop, struct vop_unlock_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_unlock_desc, a->a_vp, + ("Wrong a_desc in vop_unlock(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_unlock == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_unlock(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_unlock, entry, a->a_vp, a); + + KTR_START2(KTR_VOP, "VOP", "VOP_UNLOCK", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "flags:0x%jX", a->a_flags); + vop_unlock_pre(a); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_unlock != NULL) + rc = vop->vop_unlock(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_unlock, return, a->a_vp, a, rc); + + if (rc == 0) { + } else { + } + vop_unlock_post(a, rc); + KTR_STOP2(KTR_VOP, "VOP", "VOP_UNLOCK", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "flags:0x%jX", a->a_flags); + return (rc); +} + +struct vnodeop_desc vop_unlock_desc = { + "vop_unlock", + 0, + (vop_bypass_t *)VOP_UNLOCK_AP, + vop_unlock_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_bmap_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_bmap_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_bmap, entry, "struct vnode *", "struct vop_bmap_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_bmap, return, "struct vnode *", "struct vop_bmap_args *", "int"); + + +int +VOP_BMAP_AP(struct vop_bmap_args *a) +{ + + return(VOP_BMAP_APV(a->a_vp->v_op, a)); +} + +int +VOP_BMAP_APV(struct vop_vector *vop, struct vop_bmap_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_bmap_desc, a->a_vp, + ("Wrong a_desc in vop_bmap(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_bmap == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_bmap(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_bmap, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_BMAP"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_BMAP"); + KTR_START4(KTR_VOP, "VOP", "VOP_BMAP", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "bn:0x%jX", a->a_bn, "bop:0x%jX", a->a_bop, "bnp:0x%jX", a->a_bnp); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_bmap != NULL) + rc = vop->vop_bmap(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_bmap, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_BMAP"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_BMAP"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_BMAP"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_BMAP"); + } + KTR_STOP4(KTR_VOP, "VOP", "VOP_BMAP", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "bn:0x%jX", a->a_bn, "bop:0x%jX", a->a_bop, "bnp:0x%jX", a->a_bnp); + return (rc); +} + +struct vnodeop_desc vop_bmap_desc = { + "vop_bmap", + 0, + (vop_bypass_t *)VOP_BMAP_AP, + vop_bmap_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_strategy_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_strategy_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_strategy, entry, "struct vnode *", "struct vop_strategy_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_strategy, return, "struct vnode *", "struct vop_strategy_args *", "int"); + + +int +VOP_STRATEGY_AP(struct vop_strategy_args *a) +{ + + return(VOP_STRATEGY_APV(a->a_vp->v_op, a)); +} + +int +VOP_STRATEGY_APV(struct vop_vector *vop, struct vop_strategy_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_strategy_desc, a->a_vp, + ("Wrong a_desc in vop_strategy(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_strategy == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_strategy(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_strategy, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_STRATEGY"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_STRATEGY"); + KTR_START2(KTR_VOP, "VOP", "VOP_STRATEGY", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "bp:0x%jX", a->a_bp); + vop_strategy_pre(a); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_strategy != NULL) + rc = vop->vop_strategy(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_strategy, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_STRATEGY"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_STRATEGY"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_STRATEGY"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_STRATEGY"); + } + KTR_STOP2(KTR_VOP, "VOP", "VOP_STRATEGY", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "bp:0x%jX", a->a_bp); + return (rc); +} + +struct vnodeop_desc vop_strategy_desc = { + "vop_strategy", + 0, + (vop_bypass_t *)VOP_STRATEGY_AP, + vop_strategy_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_getwritemount_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_getwritemount_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_getwritemount, entry, "struct vnode *", "struct vop_getwritemount_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_getwritemount, return, "struct vnode *", "struct vop_getwritemount_args *", "int"); + + +int +VOP_GETWRITEMOUNT_AP(struct vop_getwritemount_args *a) +{ + + return(VOP_GETWRITEMOUNT_APV(a->a_vp->v_op, a)); +} + +int +VOP_GETWRITEMOUNT_APV(struct vop_vector *vop, struct vop_getwritemount_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_getwritemount_desc, a->a_vp, + ("Wrong a_desc in vop_getwritemount(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_getwritemount == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_getwritemount(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_getwritemount, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GETWRITEMOUNT"); + KTR_START2(KTR_VOP, "VOP", "VOP_GETWRITEMOUNT", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "mpp:0x%jX", a->a_mpp); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_getwritemount != NULL) + rc = vop->vop_getwritemount(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_getwritemount, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GETWRITEMOUNT"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GETWRITEMOUNT"); + } + KTR_STOP2(KTR_VOP, "VOP", "VOP_GETWRITEMOUNT", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "mpp:0x%jX", a->a_mpp); + return (rc); +} + +struct vnodeop_desc vop_getwritemount_desc = { + "vop_getwritemount", + 0, + (vop_bypass_t *)VOP_GETWRITEMOUNT_AP, + vop_getwritemount_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_print_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_print_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_print, entry, "struct vnode *", "struct vop_print_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_print, return, "struct vnode *", "struct vop_print_args *", "int"); + + +int +VOP_PRINT_AP(struct vop_print_args *a) +{ + + return(VOP_PRINT_APV(a->a_vp->v_op, a)); +} + +int +VOP_PRINT_APV(struct vop_vector *vop, struct vop_print_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_print_desc, a->a_vp, + ("Wrong a_desc in vop_print(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_print == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_print(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_print, entry, a->a_vp, a); + + KTR_START1(KTR_VOP, "VOP", "VOP_PRINT", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_print != NULL) + rc = vop->vop_print(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_print, return, a->a_vp, a, rc); + + if (rc == 0) { + } else { + } + KTR_STOP1(KTR_VOP, "VOP", "VOP_PRINT", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + return (rc); +} + +struct vnodeop_desc vop_print_desc = { + "vop_print", + 0, + (vop_bypass_t *)VOP_PRINT_AP, + vop_print_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_pathconf_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_pathconf_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_pathconf, entry, "struct vnode *", "struct vop_pathconf_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_pathconf, return, "struct vnode *", "struct vop_pathconf_args *", "int"); + + +int +VOP_PATHCONF_AP(struct vop_pathconf_args *a) +{ + + return(VOP_PATHCONF_APV(a->a_vp->v_op, a)); +} + +int +VOP_PATHCONF_APV(struct vop_vector *vop, struct vop_pathconf_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_pathconf_desc, a->a_vp, + ("Wrong a_desc in vop_pathconf(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_pathconf == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_pathconf(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_pathconf, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_PATHCONF"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_PATHCONF"); + KTR_START3(KTR_VOP, "VOP", "VOP_PATHCONF", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "name:0x%jX", a->a_name, "retval:0x%jX", a->a_retval); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_pathconf != NULL) + rc = vop->vop_pathconf(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_pathconf, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_PATHCONF"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_PATHCONF"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_PATHCONF"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_PATHCONF"); + } + KTR_STOP3(KTR_VOP, "VOP", "VOP_PATHCONF", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "name:0x%jX", a->a_name, "retval:0x%jX", a->a_retval); + return (rc); +} + +struct vnodeop_desc vop_pathconf_desc = { + "vop_pathconf", + 0, + (vop_bypass_t *)VOP_PATHCONF_AP, + vop_pathconf_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_advlock_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_advlock_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_advlock, entry, "struct vnode *", "struct vop_advlock_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_advlock, return, "struct vnode *", "struct vop_advlock_args *", "int"); + + +int +VOP_ADVLOCK_AP(struct vop_advlock_args *a) +{ + + return(VOP_ADVLOCK_APV(a->a_vp->v_op, a)); +} + +int +VOP_ADVLOCK_APV(struct vop_vector *vop, struct vop_advlock_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_advlock_desc, a->a_vp, + ("Wrong a_desc in vop_advlock(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_advlock == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_advlock(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_advlock, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ADVLOCK"); + ASSERT_VOP_UNLOCKED(a->a_vp, "VOP_ADVLOCK"); + KTR_START4(KTR_VOP, "VOP", "VOP_ADVLOCK", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "id:0x%jX", a->a_id, "op:0x%jX", a->a_op, "fl:0x%jX", a->a_fl); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_advlock != NULL) + rc = vop->vop_advlock(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_advlock, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ADVLOCK"); + ASSERT_VOP_UNLOCKED(a->a_vp, "VOP_ADVLOCK"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ADVLOCK"); + ASSERT_VOP_UNLOCKED(a->a_vp, "VOP_ADVLOCK"); + } + KTR_STOP4(KTR_VOP, "VOP", "VOP_ADVLOCK", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "id:0x%jX", a->a_id, "op:0x%jX", a->a_op, "fl:0x%jX", a->a_fl); + return (rc); +} + +struct vnodeop_desc vop_advlock_desc = { + "vop_advlock", + 0, + (vop_bypass_t *)VOP_ADVLOCK_AP, + vop_advlock_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_advlockasync_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_advlockasync_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_advlockasync, entry, "struct vnode *", "struct vop_advlockasync_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_advlockasync, return, "struct vnode *", "struct vop_advlockasync_args *", "int"); + + +int +VOP_ADVLOCKASYNC_AP(struct vop_advlockasync_args *a) +{ + + return(VOP_ADVLOCKASYNC_APV(a->a_vp->v_op, a)); +} + +int +VOP_ADVLOCKASYNC_APV(struct vop_vector *vop, struct vop_advlockasync_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_advlockasync_desc, a->a_vp, + ("Wrong a_desc in vop_advlockasync(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_advlockasync == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_advlockasync(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_advlockasync, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ADVLOCKASYNC"); + ASSERT_VOP_UNLOCKED(a->a_vp, "VOP_ADVLOCKASYNC"); + KTR_START4(KTR_VOP, "VOP", "VOP_ADVLOCKASYNC", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "id:0x%jX", a->a_id, "op:0x%jX", a->a_op, "fl:0x%jX", a->a_fl); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_advlockasync != NULL) + rc = vop->vop_advlockasync(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_advlockasync, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ADVLOCKASYNC"); + ASSERT_VOP_UNLOCKED(a->a_vp, "VOP_ADVLOCKASYNC"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ADVLOCKASYNC"); + ASSERT_VOP_UNLOCKED(a->a_vp, "VOP_ADVLOCKASYNC"); + } + KTR_STOP4(KTR_VOP, "VOP", "VOP_ADVLOCKASYNC", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "id:0x%jX", a->a_id, "op:0x%jX", a->a_op, "fl:0x%jX", a->a_fl); + return (rc); +} + +struct vnodeop_desc vop_advlockasync_desc = { + "vop_advlockasync", + 0, + (vop_bypass_t *)VOP_ADVLOCKASYNC_AP, + vop_advlockasync_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_advlockpurge_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_advlockpurge_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_advlockpurge, entry, "struct vnode *", "struct vop_advlockpurge_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_advlockpurge, return, "struct vnode *", "struct vop_advlockpurge_args *", "int"); + + +int +VOP_ADVLOCKPURGE_AP(struct vop_advlockpurge_args *a) +{ + + return(VOP_ADVLOCKPURGE_APV(a->a_vp->v_op, a)); +} + +int +VOP_ADVLOCKPURGE_APV(struct vop_vector *vop, struct vop_advlockpurge_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_advlockpurge_desc, a->a_vp, + ("Wrong a_desc in vop_advlockpurge(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_advlockpurge == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_advlockpurge(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_advlockpurge, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ADVLOCKPURGE"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_ADVLOCKPURGE"); + KTR_START1(KTR_VOP, "VOP", "VOP_ADVLOCKPURGE", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_advlockpurge != NULL) + rc = vop->vop_advlockpurge(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_advlockpurge, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ADVLOCKPURGE"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_ADVLOCKPURGE"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ADVLOCKPURGE"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_ADVLOCKPURGE"); + } + KTR_STOP1(KTR_VOP, "VOP", "VOP_ADVLOCKPURGE", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + return (rc); +} + +struct vnodeop_desc vop_advlockpurge_desc = { + "vop_advlockpurge", + 0, + (vop_bypass_t *)VOP_ADVLOCKPURGE_AP, + vop_advlockpurge_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_reallocblks_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_reallocblks_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_reallocblks, entry, "struct vnode *", "struct vop_reallocblks_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_reallocblks, return, "struct vnode *", "struct vop_reallocblks_args *", "int"); + + +int +VOP_REALLOCBLKS_AP(struct vop_reallocblks_args *a) +{ + + return(VOP_REALLOCBLKS_APV(a->a_vp->v_op, a)); +} + +int +VOP_REALLOCBLKS_APV(struct vop_vector *vop, struct vop_reallocblks_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_reallocblks_desc, a->a_vp, + ("Wrong a_desc in vop_reallocblks(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_reallocblks == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_reallocblks(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_reallocblks, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_REALLOCBLKS"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_REALLOCBLKS"); + KTR_START2(KTR_VOP, "VOP", "VOP_REALLOCBLKS", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "buflist:0x%jX", a->a_buflist); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_reallocblks != NULL) + rc = vop->vop_reallocblks(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_reallocblks, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_REALLOCBLKS"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_REALLOCBLKS"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_REALLOCBLKS"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_REALLOCBLKS"); + } + KTR_STOP2(KTR_VOP, "VOP", "VOP_REALLOCBLKS", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "buflist:0x%jX", a->a_buflist); + return (rc); +} + +struct vnodeop_desc vop_reallocblks_desc = { + "vop_reallocblks", + 0, + (vop_bypass_t *)VOP_REALLOCBLKS_AP, + vop_reallocblks_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_getpages_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_getpages_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_getpages, entry, "struct vnode *", "struct vop_getpages_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_getpages, return, "struct vnode *", "struct vop_getpages_args *", "int"); + + +int +VOP_GETPAGES_AP(struct vop_getpages_args *a) +{ + + return(VOP_GETPAGES_APV(a->a_vp->v_op, a)); +} + +int +VOP_GETPAGES_APV(struct vop_vector *vop, struct vop_getpages_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_getpages_desc, a->a_vp, + ("Wrong a_desc in vop_getpages(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_getpages == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_getpages(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_getpages, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GETPAGES"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_GETPAGES"); + KTR_START4(KTR_VOP, "VOP", "VOP_GETPAGES", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "m:0x%jX", a->a_m, "count:0x%jX", a->a_count, "rbehind:0x%jX", a->a_rbehind); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_getpages != NULL) + rc = vop->vop_getpages(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_getpages, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GETPAGES"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_GETPAGES"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GETPAGES"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_GETPAGES"); + } + KTR_STOP4(KTR_VOP, "VOP", "VOP_GETPAGES", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "m:0x%jX", a->a_m, "count:0x%jX", a->a_count, "rbehind:0x%jX", a->a_rbehind); + return (rc); +} + +struct vnodeop_desc vop_getpages_desc = { + "vop_getpages", + 0, + (vop_bypass_t *)VOP_GETPAGES_AP, + vop_getpages_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_getpages_async_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_getpages_async_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_getpages_async, entry, "struct vnode *", "struct vop_getpages_async_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_getpages_async, return, "struct vnode *", "struct vop_getpages_async_args *", "int"); + + +int +VOP_GETPAGES_ASYNC_AP(struct vop_getpages_async_args *a) +{ + + return(VOP_GETPAGES_ASYNC_APV(a->a_vp->v_op, a)); +} + +int +VOP_GETPAGES_ASYNC_APV(struct vop_vector *vop, struct vop_getpages_async_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_getpages_async_desc, a->a_vp, + ("Wrong a_desc in vop_getpages_async(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_getpages_async == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_getpages_async(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_getpages_async, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GETPAGES_ASYNC"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_GETPAGES_ASYNC"); + KTR_START4(KTR_VOP, "VOP", "VOP_GETPAGES_ASYNC", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "m:0x%jX", a->a_m, "count:0x%jX", a->a_count, "rbehind:0x%jX", a->a_rbehind); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_getpages_async != NULL) + rc = vop->vop_getpages_async(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_getpages_async, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GETPAGES_ASYNC"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_GETPAGES_ASYNC"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GETPAGES_ASYNC"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_GETPAGES_ASYNC"); + } + KTR_STOP4(KTR_VOP, "VOP", "VOP_GETPAGES_ASYNC", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "m:0x%jX", a->a_m, "count:0x%jX", a->a_count, "rbehind:0x%jX", a->a_rbehind); + return (rc); +} + +struct vnodeop_desc vop_getpages_async_desc = { + "vop_getpages_async", + 0, + (vop_bypass_t *)VOP_GETPAGES_ASYNC_AP, + vop_getpages_async_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_putpages_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_putpages_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_putpages, entry, "struct vnode *", "struct vop_putpages_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_putpages, return, "struct vnode *", "struct vop_putpages_args *", "int"); + + +int +VOP_PUTPAGES_AP(struct vop_putpages_args *a) +{ + + return(VOP_PUTPAGES_APV(a->a_vp->v_op, a)); +} + +int +VOP_PUTPAGES_APV(struct vop_vector *vop, struct vop_putpages_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_putpages_desc, a->a_vp, + ("Wrong a_desc in vop_putpages(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_putpages == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_putpages(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_putpages, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_PUTPAGES"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_PUTPAGES"); + KTR_START4(KTR_VOP, "VOP", "VOP_PUTPAGES", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "m:0x%jX", a->a_m, "count:0x%jX", a->a_count, "sync:0x%jX", a->a_sync); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_putpages != NULL) + rc = vop->vop_putpages(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_putpages, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_PUTPAGES"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_PUTPAGES"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_PUTPAGES"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_PUTPAGES"); + } + KTR_STOP4(KTR_VOP, "VOP", "VOP_PUTPAGES", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "m:0x%jX", a->a_m, "count:0x%jX", a->a_count, "sync:0x%jX", a->a_sync); + return (rc); +} + +struct vnodeop_desc vop_putpages_desc = { + "vop_putpages", + 0, + (vop_bypass_t *)VOP_PUTPAGES_AP, + vop_putpages_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_getacl_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_getacl_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_getacl, entry, "struct vnode *", "struct vop_getacl_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_getacl, return, "struct vnode *", "struct vop_getacl_args *", "int"); + + +int +VOP_GETACL_AP(struct vop_getacl_args *a) +{ + + return(VOP_GETACL_APV(a->a_vp->v_op, a)); +} + +int +VOP_GETACL_APV(struct vop_vector *vop, struct vop_getacl_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_getacl_desc, a->a_vp, + ("Wrong a_desc in vop_getacl(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_getacl == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_getacl(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_getacl, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GETACL"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_GETACL"); + KTR_START4(KTR_VOP, "VOP", "VOP_GETACL", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "type:0x%jX", a->a_type, "aclp:0x%jX", a->a_aclp, "cred:0x%jX", a->a_cred); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_getacl != NULL) + rc = vop->vop_getacl(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_getacl, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GETACL"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_GETACL"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GETACL"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_GETACL"); + } + KTR_STOP4(KTR_VOP, "VOP", "VOP_GETACL", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "type:0x%jX", a->a_type, "aclp:0x%jX", a->a_aclp, "cred:0x%jX", a->a_cred); + return (rc); +} + +struct vnodeop_desc vop_getacl_desc = { + "vop_getacl", + 0, + (vop_bypass_t *)VOP_GETACL_AP, + vop_getacl_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_getacl_args,a_cred), + VOPARG_OFFSETOF(struct vop_getacl_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_setacl_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_setacl_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_setacl, entry, "struct vnode *", "struct vop_setacl_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_setacl, return, "struct vnode *", "struct vop_setacl_args *", "int"); + + +int +VOP_SETACL_AP(struct vop_setacl_args *a) +{ + + return(VOP_SETACL_APV(a->a_vp->v_op, a)); +} + +int +VOP_SETACL_APV(struct vop_vector *vop, struct vop_setacl_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_setacl_desc, a->a_vp, + ("Wrong a_desc in vop_setacl(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_setacl == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_setacl(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_setacl, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_SETACL"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_SETACL"); + KTR_START4(KTR_VOP, "VOP", "VOP_SETACL", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "type:0x%jX", a->a_type, "aclp:0x%jX", a->a_aclp, "cred:0x%jX", a->a_cred); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_setacl != NULL) + rc = vop->vop_setacl(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_setacl, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_SETACL"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_SETACL"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_SETACL"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_SETACL"); + } + KTR_STOP4(KTR_VOP, "VOP", "VOP_SETACL", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "type:0x%jX", a->a_type, "aclp:0x%jX", a->a_aclp, "cred:0x%jX", a->a_cred); + return (rc); +} + +struct vnodeop_desc vop_setacl_desc = { + "vop_setacl", + 0, + (vop_bypass_t *)VOP_SETACL_AP, + vop_setacl_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_setacl_args,a_cred), + VOPARG_OFFSETOF(struct vop_setacl_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_aclcheck_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_aclcheck_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_aclcheck, entry, "struct vnode *", "struct vop_aclcheck_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_aclcheck, return, "struct vnode *", "struct vop_aclcheck_args *", "int"); + + +int +VOP_ACLCHECK_AP(struct vop_aclcheck_args *a) +{ + + return(VOP_ACLCHECK_APV(a->a_vp->v_op, a)); +} + +int +VOP_ACLCHECK_APV(struct vop_vector *vop, struct vop_aclcheck_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_aclcheck_desc, a->a_vp, + ("Wrong a_desc in vop_aclcheck(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_aclcheck == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_aclcheck(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_aclcheck, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ACLCHECK"); + KTR_START4(KTR_VOP, "VOP", "VOP_ACLCHECK", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "type:0x%jX", a->a_type, "aclp:0x%jX", a->a_aclp, "cred:0x%jX", a->a_cred); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_aclcheck != NULL) + rc = vop->vop_aclcheck(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_aclcheck, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ACLCHECK"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ACLCHECK"); + } + KTR_STOP4(KTR_VOP, "VOP", "VOP_ACLCHECK", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "type:0x%jX", a->a_type, "aclp:0x%jX", a->a_aclp, "cred:0x%jX", a->a_cred); + return (rc); +} + +struct vnodeop_desc vop_aclcheck_desc = { + "vop_aclcheck", + 0, + (vop_bypass_t *)VOP_ACLCHECK_AP, + vop_aclcheck_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_aclcheck_args,a_cred), + VOPARG_OFFSETOF(struct vop_aclcheck_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_closeextattr_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_closeextattr_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_closeextattr, entry, "struct vnode *", "struct vop_closeextattr_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_closeextattr, return, "struct vnode *", "struct vop_closeextattr_args *", "int"); + + +int +VOP_CLOSEEXTATTR_AP(struct vop_closeextattr_args *a) +{ + + return(VOP_CLOSEEXTATTR_APV(a->a_vp->v_op, a)); +} + +int +VOP_CLOSEEXTATTR_APV(struct vop_vector *vop, struct vop_closeextattr_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_closeextattr_desc, a->a_vp, + ("Wrong a_desc in vop_closeextattr(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_closeextattr == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_closeextattr(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_closeextattr, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_CLOSEEXTATTR"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_CLOSEEXTATTR"); + KTR_START4(KTR_VOP, "VOP", "VOP_CLOSEEXTATTR", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "commit:0x%jX", a->a_commit, "cred:0x%jX", a->a_cred, "td:0x%jX", a->a_td); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_closeextattr != NULL) + rc = vop->vop_closeextattr(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_closeextattr, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_CLOSEEXTATTR"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_CLOSEEXTATTR"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_CLOSEEXTATTR"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_CLOSEEXTATTR"); + } + KTR_STOP4(KTR_VOP, "VOP", "VOP_CLOSEEXTATTR", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "commit:0x%jX", a->a_commit, "cred:0x%jX", a->a_cred, "td:0x%jX", a->a_td); + return (rc); +} + +struct vnodeop_desc vop_closeextattr_desc = { + "vop_closeextattr", + 0, + (vop_bypass_t *)VOP_CLOSEEXTATTR_AP, + vop_closeextattr_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_closeextattr_args,a_cred), + VOPARG_OFFSETOF(struct vop_closeextattr_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_getextattr_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_getextattr_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_getextattr, entry, "struct vnode *", "struct vop_getextattr_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_getextattr, return, "struct vnode *", "struct vop_getextattr_args *", "int"); + + +int +VOP_GETEXTATTR_AP(struct vop_getextattr_args *a) +{ + + return(VOP_GETEXTATTR_APV(a->a_vp->v_op, a)); +} + +int +VOP_GETEXTATTR_APV(struct vop_vector *vop, struct vop_getextattr_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_getextattr_desc, a->a_vp, + ("Wrong a_desc in vop_getextattr(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_getextattr == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_getextattr(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_getextattr, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GETEXTATTR"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_GETEXTATTR"); + KTR_START4(KTR_VOP, "VOP", "VOP_GETEXTATTR", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "attrnamespace:0x%jX", a->a_attrnamespace, "name:0x%jX", a->a_name, "uio:0x%jX", a->a_uio); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_getextattr != NULL) + rc = vop->vop_getextattr(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_getextattr, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GETEXTATTR"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_GETEXTATTR"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GETEXTATTR"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_GETEXTATTR"); + } + KTR_STOP4(KTR_VOP, "VOP", "VOP_GETEXTATTR", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "attrnamespace:0x%jX", a->a_attrnamespace, "name:0x%jX", a->a_name, "uio:0x%jX", a->a_uio); + return (rc); +} + +struct vnodeop_desc vop_getextattr_desc = { + "vop_getextattr", + 0, + (vop_bypass_t *)VOP_GETEXTATTR_AP, + vop_getextattr_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_getextattr_args,a_cred), + VOPARG_OFFSETOF(struct vop_getextattr_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_listextattr_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_listextattr_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_listextattr, entry, "struct vnode *", "struct vop_listextattr_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_listextattr, return, "struct vnode *", "struct vop_listextattr_args *", "int"); + + +int +VOP_LISTEXTATTR_AP(struct vop_listextattr_args *a) +{ + + return(VOP_LISTEXTATTR_APV(a->a_vp->v_op, a)); +} + +int +VOP_LISTEXTATTR_APV(struct vop_vector *vop, struct vop_listextattr_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_listextattr_desc, a->a_vp, + ("Wrong a_desc in vop_listextattr(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_listextattr == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_listextattr(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_listextattr, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_LISTEXTATTR"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_LISTEXTATTR"); + KTR_START4(KTR_VOP, "VOP", "VOP_LISTEXTATTR", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "attrnamespace:0x%jX", a->a_attrnamespace, "uio:0x%jX", a->a_uio, "size:0x%jX", a->a_size); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_listextattr != NULL) + rc = vop->vop_listextattr(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_listextattr, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_LISTEXTATTR"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_LISTEXTATTR"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_LISTEXTATTR"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_LISTEXTATTR"); + } + KTR_STOP4(KTR_VOP, "VOP", "VOP_LISTEXTATTR", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "attrnamespace:0x%jX", a->a_attrnamespace, "uio:0x%jX", a->a_uio, "size:0x%jX", a->a_size); + return (rc); +} + +struct vnodeop_desc vop_listextattr_desc = { + "vop_listextattr", + 0, + (vop_bypass_t *)VOP_LISTEXTATTR_AP, + vop_listextattr_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_listextattr_args,a_cred), + VOPARG_OFFSETOF(struct vop_listextattr_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_openextattr_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_openextattr_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_openextattr, entry, "struct vnode *", "struct vop_openextattr_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_openextattr, return, "struct vnode *", "struct vop_openextattr_args *", "int"); + + +int +VOP_OPENEXTATTR_AP(struct vop_openextattr_args *a) +{ + + return(VOP_OPENEXTATTR_APV(a->a_vp->v_op, a)); +} + +int +VOP_OPENEXTATTR_APV(struct vop_vector *vop, struct vop_openextattr_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_openextattr_desc, a->a_vp, + ("Wrong a_desc in vop_openextattr(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_openextattr == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_openextattr(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_openextattr, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_OPENEXTATTR"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_OPENEXTATTR"); + KTR_START3(KTR_VOP, "VOP", "VOP_OPENEXTATTR", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "cred:0x%jX", a->a_cred, "td:0x%jX", a->a_td); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_openextattr != NULL) + rc = vop->vop_openextattr(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_openextattr, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_OPENEXTATTR"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_OPENEXTATTR"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_OPENEXTATTR"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_OPENEXTATTR"); + } + KTR_STOP3(KTR_VOP, "VOP", "VOP_OPENEXTATTR", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "cred:0x%jX", a->a_cred, "td:0x%jX", a->a_td); + return (rc); +} + +struct vnodeop_desc vop_openextattr_desc = { + "vop_openextattr", + 0, + (vop_bypass_t *)VOP_OPENEXTATTR_AP, + vop_openextattr_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_openextattr_args,a_cred), + VOPARG_OFFSETOF(struct vop_openextattr_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_deleteextattr_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_deleteextattr_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_deleteextattr, entry, "struct vnode *", "struct vop_deleteextattr_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_deleteextattr, return, "struct vnode *", "struct vop_deleteextattr_args *", "int"); + + +int +VOP_DELETEEXTATTR_AP(struct vop_deleteextattr_args *a) +{ + + return(VOP_DELETEEXTATTR_APV(a->a_vp->v_op, a)); +} + +int +VOP_DELETEEXTATTR_APV(struct vop_vector *vop, struct vop_deleteextattr_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_deleteextattr_desc, a->a_vp, + ("Wrong a_desc in vop_deleteextattr(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_deleteextattr == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_deleteextattr(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_deleteextattr, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_DELETEEXTATTR"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_DELETEEXTATTR"); + KTR_START4(KTR_VOP, "VOP", "VOP_DELETEEXTATTR", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "attrnamespace:0x%jX", a->a_attrnamespace, "name:0x%jX", a->a_name, "cred:0x%jX", a->a_cred); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_deleteextattr != NULL) + rc = vop->vop_deleteextattr(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_deleteextattr, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_DELETEEXTATTR"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_DELETEEXTATTR"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_DELETEEXTATTR"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_DELETEEXTATTR"); + } + vop_deleteextattr_post(a, rc); + KTR_STOP4(KTR_VOP, "VOP", "VOP_DELETEEXTATTR", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "attrnamespace:0x%jX", a->a_attrnamespace, "name:0x%jX", a->a_name, "cred:0x%jX", a->a_cred); + return (rc); +} + +struct vnodeop_desc vop_deleteextattr_desc = { + "vop_deleteextattr", + 0, + (vop_bypass_t *)VOP_DELETEEXTATTR_AP, + vop_deleteextattr_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_deleteextattr_args,a_cred), + VOPARG_OFFSETOF(struct vop_deleteextattr_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_setextattr_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_setextattr_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_setextattr, entry, "struct vnode *", "struct vop_setextattr_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_setextattr, return, "struct vnode *", "struct vop_setextattr_args *", "int"); + + +int +VOP_SETEXTATTR_AP(struct vop_setextattr_args *a) +{ + + return(VOP_SETEXTATTR_APV(a->a_vp->v_op, a)); +} + +int +VOP_SETEXTATTR_APV(struct vop_vector *vop, struct vop_setextattr_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_setextattr_desc, a->a_vp, + ("Wrong a_desc in vop_setextattr(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_setextattr == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_setextattr(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_setextattr, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_SETEXTATTR"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_SETEXTATTR"); + KTR_START4(KTR_VOP, "VOP", "VOP_SETEXTATTR", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "attrnamespace:0x%jX", a->a_attrnamespace, "name:0x%jX", a->a_name, "uio:0x%jX", a->a_uio); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_setextattr != NULL) + rc = vop->vop_setextattr(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_setextattr, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_SETEXTATTR"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_SETEXTATTR"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_SETEXTATTR"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_SETEXTATTR"); + } + vop_setextattr_post(a, rc); + KTR_STOP4(KTR_VOP, "VOP", "VOP_SETEXTATTR", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "attrnamespace:0x%jX", a->a_attrnamespace, "name:0x%jX", a->a_name, "uio:0x%jX", a->a_uio); + return (rc); +} + +struct vnodeop_desc vop_setextattr_desc = { + "vop_setextattr", + 0, + (vop_bypass_t *)VOP_SETEXTATTR_AP, + vop_setextattr_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_setextattr_args,a_cred), + VOPARG_OFFSETOF(struct vop_setextattr_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_setlabel_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_setlabel_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_setlabel, entry, "struct vnode *", "struct vop_setlabel_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_setlabel, return, "struct vnode *", "struct vop_setlabel_args *", "int"); + + +int +VOP_SETLABEL_AP(struct vop_setlabel_args *a) +{ + + return(VOP_SETLABEL_APV(a->a_vp->v_op, a)); +} + +int +VOP_SETLABEL_APV(struct vop_vector *vop, struct vop_setlabel_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_setlabel_desc, a->a_vp, + ("Wrong a_desc in vop_setlabel(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_setlabel == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_setlabel(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_setlabel, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_SETLABEL"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_SETLABEL"); + KTR_START4(KTR_VOP, "VOP", "VOP_SETLABEL", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "label:0x%jX", a->a_label, "cred:0x%jX", a->a_cred, "td:0x%jX", a->a_td); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_setlabel != NULL) + rc = vop->vop_setlabel(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_setlabel, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_SETLABEL"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_SETLABEL"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_SETLABEL"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_SETLABEL"); + } + KTR_STOP4(KTR_VOP, "VOP", "VOP_SETLABEL", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "label:0x%jX", a->a_label, "cred:0x%jX", a->a_cred, "td:0x%jX", a->a_td); + return (rc); +} + +struct vnodeop_desc vop_setlabel_desc = { + "vop_setlabel", + 0, + (vop_bypass_t *)VOP_SETLABEL_AP, + vop_setlabel_vp_offsets, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_setlabel_args,a_cred), + VOPARG_OFFSETOF(struct vop_setlabel_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_vptofh_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_vptofh_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_vptofh, entry, "struct vnode *", "struct vop_vptofh_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_vptofh, return, "struct vnode *", "struct vop_vptofh_args *", "int"); + + +int +VOP_VPTOFH_AP(struct vop_vptofh_args *a) +{ + + return(VOP_VPTOFH_APV(a->a_vp->v_op, a)); +} + +int +VOP_VPTOFH_APV(struct vop_vector *vop, struct vop_vptofh_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_vptofh_desc, a->a_vp, + ("Wrong a_desc in vop_vptofh(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_vptofh == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_vptofh(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_vptofh, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_VPTOFH"); + KTR_START2(KTR_VOP, "VOP", "VOP_VPTOFH", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "fhp:0x%jX", a->a_fhp); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_vptofh != NULL) + rc = vop->vop_vptofh(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_vptofh, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_VPTOFH"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_VPTOFH"); + } + KTR_STOP2(KTR_VOP, "VOP", "VOP_VPTOFH", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "fhp:0x%jX", a->a_fhp); + return (rc); +} + +struct vnodeop_desc vop_vptofh_desc = { + "vop_vptofh", + 0, + (vop_bypass_t *)VOP_VPTOFH_AP, + vop_vptofh_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_vptocnp_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_vptocnp_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_vptocnp, entry, "struct vnode *", "struct vop_vptocnp_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_vptocnp, return, "struct vnode *", "struct vop_vptocnp_args *", "int"); + + +int +VOP_VPTOCNP_AP(struct vop_vptocnp_args *a) +{ + + return(VOP_VPTOCNP_APV(a->a_vp->v_op, a)); +} + +int +VOP_VPTOCNP_APV(struct vop_vector *vop, struct vop_vptocnp_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_vptocnp_desc, a->a_vp, + ("Wrong a_desc in vop_vptocnp(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_vptocnp == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_vptocnp(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_vptocnp, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_VPTOCNP"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_VPTOCNP"); + KTR_START4(KTR_VOP, "VOP", "VOP_VPTOCNP", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "vpp:0x%jX", a->a_vpp, "cred:0x%jX", a->a_cred, "buf:0x%jX", a->a_buf); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_vptocnp != NULL) + rc = vop->vop_vptocnp(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_vptocnp, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_VPTOCNP"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_VPTOCNP"); + ASSERT_VI_UNLOCKED(*a->a_vpp, "VOP_VPTOCNP"); + ASSERT_VOP_UNLOCKED(*a->a_vpp, "VOP_VPTOCNP"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_VPTOCNP"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_VPTOCNP"); + } + KTR_STOP4(KTR_VOP, "VOP", "VOP_VPTOCNP", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "vpp:0x%jX", a->a_vpp, "cred:0x%jX", a->a_cred, "buf:0x%jX", a->a_buf); + return (rc); +} + +struct vnodeop_desc vop_vptocnp_desc = { + "vop_vptocnp", + 0, + (vop_bypass_t *)VOP_VPTOCNP_AP, + vop_vptocnp_vp_offsets, + VOPARG_OFFSETOF(struct vop_vptocnp_args,a_vpp), + VOPARG_OFFSETOF(struct vop_vptocnp_args,a_cred), + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_allocate_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_allocate_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_allocate, entry, "struct vnode *", "struct vop_allocate_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_allocate, return, "struct vnode *", "struct vop_allocate_args *", "int"); + + +int +VOP_ALLOCATE_AP(struct vop_allocate_args *a) +{ + + return(VOP_ALLOCATE_APV(a->a_vp->v_op, a)); +} + +int +VOP_ALLOCATE_APV(struct vop_vector *vop, struct vop_allocate_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_allocate_desc, a->a_vp, + ("Wrong a_desc in vop_allocate(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_allocate == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_allocate(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_allocate, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ALLOCATE"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_ALLOCATE"); + KTR_START3(KTR_VOP, "VOP", "VOP_ALLOCATE", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "offset:0x%jX", a->a_offset, "len:0x%jX", a->a_len); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_allocate != NULL) + rc = vop->vop_allocate(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_allocate, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ALLOCATE"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_ALLOCATE"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ALLOCATE"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_ALLOCATE"); + } + KTR_STOP3(KTR_VOP, "VOP", "VOP_ALLOCATE", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "offset:0x%jX", a->a_offset, "len:0x%jX", a->a_len); + return (rc); +} + +struct vnodeop_desc vop_allocate_desc = { + "vop_allocate", + 0, + (vop_bypass_t *)VOP_ALLOCATE_AP, + vop_allocate_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_advise_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_advise_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_advise, entry, "struct vnode *", "struct vop_advise_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_advise, return, "struct vnode *", "struct vop_advise_args *", "int"); + + +int +VOP_ADVISE_AP(struct vop_advise_args *a) +{ + + return(VOP_ADVISE_APV(a->a_vp->v_op, a)); +} + +int +VOP_ADVISE_APV(struct vop_vector *vop, struct vop_advise_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_advise_desc, a->a_vp, + ("Wrong a_desc in vop_advise(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_advise == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_advise(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_advise, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ADVISE"); + ASSERT_VOP_UNLOCKED(a->a_vp, "VOP_ADVISE"); + KTR_START4(KTR_VOP, "VOP", "VOP_ADVISE", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "start:0x%jX", a->a_start, "end:0x%jX", a->a_end, "advice:0x%jX", a->a_advice); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_advise != NULL) + rc = vop->vop_advise(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_advise, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ADVISE"); + ASSERT_VOP_UNLOCKED(a->a_vp, "VOP_ADVISE"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ADVISE"); + ASSERT_VOP_UNLOCKED(a->a_vp, "VOP_ADVISE"); + } + KTR_STOP4(KTR_VOP, "VOP", "VOP_ADVISE", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "start:0x%jX", a->a_start, "end:0x%jX", a->a_end, "advice:0x%jX", a->a_advice); + return (rc); +} + +struct vnodeop_desc vop_advise_desc = { + "vop_advise", + 0, + (vop_bypass_t *)VOP_ADVISE_AP, + vop_advise_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_unp_bind_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_unp_bind_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_unp_bind, entry, "struct vnode *", "struct vop_unp_bind_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_unp_bind, return, "struct vnode *", "struct vop_unp_bind_args *", "int"); + + +int +VOP_UNP_BIND_AP(struct vop_unp_bind_args *a) +{ + + return(VOP_UNP_BIND_APV(a->a_vp->v_op, a)); +} + +int +VOP_UNP_BIND_APV(struct vop_vector *vop, struct vop_unp_bind_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_unp_bind_desc, a->a_vp, + ("Wrong a_desc in vop_unp_bind(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_unp_bind == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_unp_bind(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_unp_bind, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_UNP_BIND"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_UNP_BIND"); + KTR_START2(KTR_VOP, "VOP", "VOP_UNP_BIND", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "unpcb:0x%jX", a->a_unpcb); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_unp_bind != NULL) + rc = vop->vop_unp_bind(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_unp_bind, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_UNP_BIND"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_UNP_BIND"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_UNP_BIND"); + ASSERT_VOP_ELOCKED(a->a_vp, "VOP_UNP_BIND"); + } + KTR_STOP2(KTR_VOP, "VOP", "VOP_UNP_BIND", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "unpcb:0x%jX", a->a_unpcb); + return (rc); +} + +struct vnodeop_desc vop_unp_bind_desc = { + "vop_unp_bind", + 0, + (vop_bypass_t *)VOP_UNP_BIND_AP, + vop_unp_bind_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_unp_connect_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_unp_connect_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_unp_connect, entry, "struct vnode *", "struct vop_unp_connect_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_unp_connect, return, "struct vnode *", "struct vop_unp_connect_args *", "int"); + + +int +VOP_UNP_CONNECT_AP(struct vop_unp_connect_args *a) +{ + + return(VOP_UNP_CONNECT_APV(a->a_vp->v_op, a)); +} + +int +VOP_UNP_CONNECT_APV(struct vop_vector *vop, struct vop_unp_connect_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_unp_connect_desc, a->a_vp, + ("Wrong a_desc in vop_unp_connect(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_unp_connect == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_unp_connect(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_unp_connect, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_UNP_CONNECT"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_UNP_CONNECT"); + KTR_START2(KTR_VOP, "VOP", "VOP_UNP_CONNECT", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "unpcb:0x%jX", a->a_unpcb); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_unp_connect != NULL) + rc = vop->vop_unp_connect(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_unp_connect, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_UNP_CONNECT"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_UNP_CONNECT"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_UNP_CONNECT"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_UNP_CONNECT"); + } + KTR_STOP2(KTR_VOP, "VOP", "VOP_UNP_CONNECT", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "unpcb:0x%jX", a->a_unpcb); + return (rc); +} + +struct vnodeop_desc vop_unp_connect_desc = { + "vop_unp_connect", + 0, + (vop_bypass_t *)VOP_UNP_CONNECT_AP, + vop_unp_connect_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_unp_detach_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_unp_detach_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_unp_detach, entry, "struct vnode *", "struct vop_unp_detach_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_unp_detach, return, "struct vnode *", "struct vop_unp_detach_args *", "int"); + + +int +VOP_UNP_DETACH_AP(struct vop_unp_detach_args *a) +{ + + return(VOP_UNP_DETACH_APV(a->a_vp->v_op, a)); +} + +int +VOP_UNP_DETACH_APV(struct vop_vector *vop, struct vop_unp_detach_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_unp_detach_desc, a->a_vp, + ("Wrong a_desc in vop_unp_detach(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_unp_detach == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_unp_detach(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_unp_detach, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_UNP_DETACH"); + KTR_START1(KTR_VOP, "VOP", "VOP_UNP_DETACH", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_unp_detach != NULL) + rc = vop->vop_unp_detach(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_unp_detach, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_UNP_DETACH"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_UNP_DETACH"); + } + KTR_STOP1(KTR_VOP, "VOP", "VOP_UNP_DETACH", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + return (rc); +} + +struct vnodeop_desc vop_unp_detach_desc = { + "vop_unp_detach", + 0, + (vop_bypass_t *)VOP_UNP_DETACH_AP, + vop_unp_detach_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_is_text_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_is_text_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_is_text, entry, "struct vnode *", "struct vop_is_text_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_is_text, return, "struct vnode *", "struct vop_is_text_args *", "int"); + + +int +VOP_IS_TEXT_AP(struct vop_is_text_args *a) +{ + + return(VOP_IS_TEXT_APV(a->a_vp->v_op, a)); +} + +int +VOP_IS_TEXT_APV(struct vop_vector *vop, struct vop_is_text_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_is_text_desc, a->a_vp, + ("Wrong a_desc in vop_is_text(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_is_text == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_is_text(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_is_text, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_IS_TEXT"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_IS_TEXT"); + KTR_START1(KTR_VOP, "VOP", "VOP_IS_TEXT", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_is_text != NULL) + rc = vop->vop_is_text(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_is_text, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_IS_TEXT"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_IS_TEXT"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_IS_TEXT"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_IS_TEXT"); + } + KTR_STOP1(KTR_VOP, "VOP", "VOP_IS_TEXT", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + return (rc); +} + +struct vnodeop_desc vop_is_text_desc = { + "vop_is_text", + 0, + (vop_bypass_t *)VOP_IS_TEXT_AP, + vop_is_text_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_set_text_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_set_text_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_set_text, entry, "struct vnode *", "struct vop_set_text_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_set_text, return, "struct vnode *", "struct vop_set_text_args *", "int"); + + +int +VOP_SET_TEXT_AP(struct vop_set_text_args *a) +{ + + return(VOP_SET_TEXT_APV(a->a_vp->v_op, a)); +} + +int +VOP_SET_TEXT_APV(struct vop_vector *vop, struct vop_set_text_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_set_text_desc, a->a_vp, + ("Wrong a_desc in vop_set_text(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_set_text == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_set_text(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_set_text, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_SET_TEXT"); + KTR_START1(KTR_VOP, "VOP", "VOP_SET_TEXT", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_set_text != NULL) + rc = vop->vop_set_text(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_set_text, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_SET_TEXT"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_SET_TEXT"); + } + KTR_STOP1(KTR_VOP, "VOP", "VOP_SET_TEXT", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + return (rc); +} + +struct vnodeop_desc vop_set_text_desc = { + "vop_set_text", + 0, + (vop_bypass_t *)VOP_SET_TEXT_AP, + vop_set_text_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_unset_text_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_unset_text_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_unset_text, entry, "struct vnode *", "struct vop_unset_text_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_unset_text, return, "struct vnode *", "struct vop_unset_text_args *", "int"); + + +int +VOP_UNSET_TEXT_AP(struct vop_unset_text_args *a) +{ + + return(VOP_UNSET_TEXT_APV(a->a_vp->v_op, a)); +} + +int +VOP_UNSET_TEXT_APV(struct vop_vector *vop, struct vop_unset_text_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_unset_text_desc, a->a_vp, + ("Wrong a_desc in vop_unset_text(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_unset_text == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_unset_text(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_unset_text, entry, a->a_vp, a); + + KTR_START1(KTR_VOP, "VOP", "VOP_UNSET_TEXT", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_unset_text != NULL) + rc = vop->vop_unset_text(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_unset_text, return, a->a_vp, a, rc); + + if (rc == 0) { + } else { + } + KTR_STOP1(KTR_VOP, "VOP", "VOP_UNSET_TEXT", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + return (rc); +} + +struct vnodeop_desc vop_unset_text_desc = { + "vop_unset_text", + 0, + (vop_bypass_t *)VOP_UNSET_TEXT_AP, + vop_unset_text_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_get_writecount_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_get_writecount_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_get_writecount, entry, "struct vnode *", "struct vop_get_writecount_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_get_writecount, return, "struct vnode *", "struct vop_get_writecount_args *", "int"); + + +int +VOP_GET_WRITECOUNT_AP(struct vop_get_writecount_args *a) +{ + + return(VOP_GET_WRITECOUNT_APV(a->a_vp->v_op, a)); +} + +int +VOP_GET_WRITECOUNT_APV(struct vop_vector *vop, struct vop_get_writecount_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_get_writecount_desc, a->a_vp, + ("Wrong a_desc in vop_get_writecount(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_get_writecount == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_get_writecount(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_get_writecount, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GET_WRITECOUNT"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_GET_WRITECOUNT"); + KTR_START2(KTR_VOP, "VOP", "VOP_GET_WRITECOUNT", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "writecount:0x%jX", a->a_writecount); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_get_writecount != NULL) + rc = vop->vop_get_writecount(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_get_writecount, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GET_WRITECOUNT"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_GET_WRITECOUNT"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_GET_WRITECOUNT"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_GET_WRITECOUNT"); + } + KTR_STOP2(KTR_VOP, "VOP", "VOP_GET_WRITECOUNT", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "writecount:0x%jX", a->a_writecount); + return (rc); +} + +struct vnodeop_desc vop_get_writecount_desc = { + "vop_get_writecount", + 0, + (vop_bypass_t *)VOP_GET_WRITECOUNT_AP, + vop_get_writecount_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_add_writecount_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_add_writecount_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_add_writecount, entry, "struct vnode *", "struct vop_add_writecount_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_add_writecount, return, "struct vnode *", "struct vop_add_writecount_args *", "int"); + + +int +VOP_ADD_WRITECOUNT_AP(struct vop_add_writecount_args *a) +{ + + return(VOP_ADD_WRITECOUNT_APV(a->a_vp->v_op, a)); +} + +int +VOP_ADD_WRITECOUNT_APV(struct vop_vector *vop, struct vop_add_writecount_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_add_writecount_desc, a->a_vp, + ("Wrong a_desc in vop_add_writecount(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_add_writecount == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_add_writecount(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_add_writecount, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ADD_WRITECOUNT"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_ADD_WRITECOUNT"); + KTR_START2(KTR_VOP, "VOP", "VOP_ADD_WRITECOUNT", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "inc:0x%jX", a->a_inc); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_add_writecount != NULL) + rc = vop->vop_add_writecount(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_add_writecount, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ADD_WRITECOUNT"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_ADD_WRITECOUNT"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_ADD_WRITECOUNT"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_ADD_WRITECOUNT"); + } + KTR_STOP2(KTR_VOP, "VOP", "VOP_ADD_WRITECOUNT", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "inc:0x%jX", a->a_inc); + return (rc); +} + +struct vnodeop_desc vop_add_writecount_desc = { + "vop_add_writecount", + 0, + (vop_bypass_t *)VOP_ADD_WRITECOUNT_AP, + vop_add_writecount_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_fdatasync_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_fdatasync_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_fdatasync, entry, "struct vnode *", "struct vop_fdatasync_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_fdatasync, return, "struct vnode *", "struct vop_fdatasync_args *", "int"); + + +int +VOP_FDATASYNC_AP(struct vop_fdatasync_args *a) +{ + + return(VOP_FDATASYNC_APV(a->a_vp->v_op, a)); +} + +int +VOP_FDATASYNC_APV(struct vop_vector *vop, struct vop_fdatasync_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_fdatasync_desc, a->a_vp, + ("Wrong a_desc in vop_fdatasync(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_fdatasync == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_fdatasync(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_fdatasync, entry, a->a_vp, a); + + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_FDATASYNC"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_FDATASYNC"); + KTR_START2(KTR_VOP, "VOP", "VOP_FDATASYNC", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "td:0x%jX", a->a_td); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_fdatasync != NULL) + rc = vop->vop_fdatasync(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_fdatasync, return, a->a_vp, a, rc); + + if (rc == 0) { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_FDATASYNC"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_FDATASYNC"); + } else { + ASSERT_VI_UNLOCKED(a->a_vp, "VOP_FDATASYNC"); + ASSERT_VOP_LOCKED(a->a_vp, "VOP_FDATASYNC"); + } + KTR_STOP2(KTR_VOP, "VOP", "VOP_FDATASYNC", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp, "td:0x%jX", a->a_td); + return (rc); +} + +struct vnodeop_desc vop_fdatasync_desc = { + "vop_fdatasync", + 0, + (vop_bypass_t *)VOP_FDATASYNC_AP, + vop_fdatasync_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VOPARG_OFFSETOF(struct vop_fdatasync_args,a_td), + VDESC_NO_OFFSET, +}; + +static int vop_spare1_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_spare1_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_spare1, entry, "struct vnode *", "struct vop_spare1_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_spare1, return, "struct vnode *", "struct vop_spare1_args *", "int"); + + +int +VOP_SPARE1_AP(struct vop_spare1_args *a) +{ + + return(VOP_SPARE1_APV(a->a_vp->v_op, a)); +} + +int +VOP_SPARE1_APV(struct vop_vector *vop, struct vop_spare1_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_spare1_desc, a->a_vp, + ("Wrong a_desc in vop_spare1(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_spare1 == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_spare1(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_spare1, entry, a->a_vp, a); + + KTR_START1(KTR_VOP, "VOP", "VOP_SPARE1", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_spare1 != NULL) + rc = vop->vop_spare1(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_spare1, return, a->a_vp, a, rc); + + if (rc == 0) { + } else { + } + KTR_STOP1(KTR_VOP, "VOP", "VOP_SPARE1", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + return (rc); +} + +struct vnodeop_desc vop_spare1_desc = { + "vop_spare1", + 0, + (vop_bypass_t *)VOP_SPARE1_AP, + vop_spare1_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_spare2_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_spare2_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_spare2, entry, "struct vnode *", "struct vop_spare2_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_spare2, return, "struct vnode *", "struct vop_spare2_args *", "int"); + + +int +VOP_SPARE2_AP(struct vop_spare2_args *a) +{ + + return(VOP_SPARE2_APV(a->a_vp->v_op, a)); +} + +int +VOP_SPARE2_APV(struct vop_vector *vop, struct vop_spare2_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_spare2_desc, a->a_vp, + ("Wrong a_desc in vop_spare2(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_spare2 == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_spare2(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_spare2, entry, a->a_vp, a); + + KTR_START1(KTR_VOP, "VOP", "VOP_SPARE2", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_spare2 != NULL) + rc = vop->vop_spare2(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_spare2, return, a->a_vp, a, rc); + + if (rc == 0) { + } else { + } + KTR_STOP1(KTR_VOP, "VOP", "VOP_SPARE2", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + return (rc); +} + +struct vnodeop_desc vop_spare2_desc = { + "vop_spare2", + 0, + (vop_bypass_t *)VOP_SPARE2_AP, + vop_spare2_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_spare3_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_spare3_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_spare3, entry, "struct vnode *", "struct vop_spare3_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_spare3, return, "struct vnode *", "struct vop_spare3_args *", "int"); + + +int +VOP_SPARE3_AP(struct vop_spare3_args *a) +{ + + return(VOP_SPARE3_APV(a->a_vp->v_op, a)); +} + +int +VOP_SPARE3_APV(struct vop_vector *vop, struct vop_spare3_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_spare3_desc, a->a_vp, + ("Wrong a_desc in vop_spare3(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_spare3 == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_spare3(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_spare3, entry, a->a_vp, a); + + KTR_START1(KTR_VOP, "VOP", "VOP_SPARE3", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_spare3 != NULL) + rc = vop->vop_spare3(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_spare3, return, a->a_vp, a, rc); + + if (rc == 0) { + } else { + } + KTR_STOP1(KTR_VOP, "VOP", "VOP_SPARE3", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + return (rc); +} + +struct vnodeop_desc vop_spare3_desc = { + "vop_spare3", + 0, + (vop_bypass_t *)VOP_SPARE3_AP, + vop_spare3_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_spare4_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_spare4_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_spare4, entry, "struct vnode *", "struct vop_spare4_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_spare4, return, "struct vnode *", "struct vop_spare4_args *", "int"); + + +int +VOP_SPARE4_AP(struct vop_spare4_args *a) +{ + + return(VOP_SPARE4_APV(a->a_vp->v_op, a)); +} + +int +VOP_SPARE4_APV(struct vop_vector *vop, struct vop_spare4_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_spare4_desc, a->a_vp, + ("Wrong a_desc in vop_spare4(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_spare4 == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_spare4(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_spare4, entry, a->a_vp, a); + + KTR_START1(KTR_VOP, "VOP", "VOP_SPARE4", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_spare4 != NULL) + rc = vop->vop_spare4(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_spare4, return, a->a_vp, a, rc); + + if (rc == 0) { + } else { + } + KTR_STOP1(KTR_VOP, "VOP", "VOP_SPARE4", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + return (rc); +} + +struct vnodeop_desc vop_spare4_desc = { + "vop_spare4", + 0, + (vop_bypass_t *)VOP_SPARE4_AP, + vop_spare4_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; + +static int vop_spare5_vp_offsets[] = { + VOPARG_OFFSETOF(struct vop_spare5_args,a_vp), + VDESC_NO_OFFSET +}; + + +SDT_PROBE_DEFINE2(vfs, vop, vop_spare5, entry, "struct vnode *", "struct vop_spare5_args *"); + +SDT_PROBE_DEFINE3(vfs, vop, vop_spare5, return, "struct vnode *", "struct vop_spare5_args *", "int"); + + +int +VOP_SPARE5_AP(struct vop_spare5_args *a) +{ + + return(VOP_SPARE5_APV(a->a_vp->v_op, a)); +} + +int +VOP_SPARE5_APV(struct vop_vector *vop, struct vop_spare5_args *a) +{ + int rc; + + VNASSERT(a->a_gen.a_desc == &vop_spare5_desc, a->a_vp, + ("Wrong a_desc in vop_spare5(%p, %p)", a->a_vp, a)); + while(vop != NULL && \ + vop->vop_spare5 == NULL && vop->vop_bypass == NULL) + vop = vop->vop_default; + VNASSERT(vop != NULL, a->a_vp, ("No vop_spare5(%p, %p)", a->a_vp, a)); + SDT_PROBE2(vfs, vop, vop_spare5, entry, a->a_vp, a); + + KTR_START1(KTR_VOP, "VOP", "VOP_SPARE5", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + VFS_PROLOGUE(a->a_vp->v_mount); + if (vop->vop_spare5 != NULL) + rc = vop->vop_spare5(a); + else + rc = vop->vop_bypass(&a->a_gen); + VFS_EPILOGUE(a->a_vp->v_mount); + SDT_PROBE3(vfs, vop, vop_spare5, return, a->a_vp, a, rc); + + if (rc == 0) { + } else { + } + KTR_STOP1(KTR_VOP, "VOP", "VOP_SPARE5", (uintptr_t)a, + "vp:0x%jX", (uintptr_t)a->a_vp); + return (rc); +} + +struct vnodeop_desc vop_spare5_desc = { + "vop_spare5", + 0, + (vop_bypass_t *)VOP_SPARE5_AP, + vop_spare5_vp_offsets, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, + VDESC_NO_OFFSET, +}; |