diff options
Diffstat (limited to 'pfinet/glue-include')
46 files changed, 1087 insertions, 0 deletions
diff --git a/pfinet/glue-include/asm/atomic.h b/pfinet/glue-include/asm/atomic.h new file mode 100644 index 00000000..d053854e --- /dev/null +++ b/pfinet/glue-include/asm/atomic.h @@ -0,0 +1,27 @@ +#ifndef _HACK_ASM_ATOMIC_H +#define _HACK_ASM_ATOMIC_H + +/* We don't need atomicity in the Linux code because we serialize all + entries to it. */ + +typedef struct { int counter; } atomic_t; + +#define ATOMIC_INIT(i) { (i) } + +#define atomic_read(v) ((v)->counter) +#define atomic_set(v,i) (((v)->counter) = (i)) + +static __inline__ void atomic_add(int i, atomic_t *v) { v->counter += i; } +static __inline__ void atomic_sub(int i, atomic_t *v) { v->counter -= i; } +static __inline__ void atomic_inc(atomic_t *v) { ++v->counter; } +static __inline__ void atomic_dec(atomic_t *v) { --v->counter; } +static __inline__ int atomic_dec_and_test(atomic_t *v) +{ return --v->counter == 0; } +static __inline__ int atomic_inc_and_test_greater_zero(atomic_t *v) +{ return ++v->counter > 0; } + +#define atomic_clear_mask(mask, addr) (*(addr) &= ~(mask)) +#define atomic_set_mask(mask, addr) (*(addr) |= (mask)) + + +#endif diff --git a/pfinet/glue-include/asm/bitops.h b/pfinet/glue-include/asm/bitops.h new file mode 100644 index 00000000..8c5a835d --- /dev/null +++ b/pfinet/glue-include/asm/bitops.h @@ -0,0 +1,37 @@ +#ifndef _HACK_ASM_BITOPS_H +#define _HACK_ASM_BITOPS_H + +/* We don't need atomicity in the Linux code because we serialize all + entries to it. */ + +#include <stdint.h> + +#define BITOPS_WORD(nr, addr) (((uint32_t *) (addr))[(nr) / 32]) +#define BITOPS_MASK(nr) (1 << ((nr) & 31)) + +static __inline__ void set_bit (int nr, void *addr) +{ BITOPS_WORD (nr, addr) |= BITOPS_MASK (nr); } + +static __inline__ void clear_bit (int nr, void *addr) +{ BITOPS_WORD (nr, addr) &= ~BITOPS_MASK (nr); } + +static __inline__ void change_bit (int nr, void *addr) +{ BITOPS_WORD (nr, addr) ^= BITOPS_MASK (nr); } + +static __inline__ int test_bit (int nr, void *addr) +{ return BITOPS_WORD (nr, addr) & BITOPS_MASK (nr); } + +static __inline__ int test_and_set_bit (int nr, void *addr) +{ + int res = BITOPS_WORD (nr, addr) & BITOPS_MASK (nr); + BITOPS_WORD (nr, addr) |= BITOPS_MASK (nr); + return res; +} + +#define find_first_zero_bit #error loser +#define find_next_zero_bit #error loser + +#define ffz(word) (ffs (~(unsigned int) (word)) - 1) + + +#endif diff --git a/pfinet/glue-include/asm/byteorder.h b/pfinet/glue-include/asm/byteorder.h new file mode 100644 index 00000000..ee1da1f4 --- /dev/null +++ b/pfinet/glue-include/asm/byteorder.h @@ -0,0 +1,154 @@ +/* Provide the specified-byte-order access functions used in the Linux + kernel, implemented as macros in terms of the GNU libc facilities. */ + +#ifndef _HACK_ASM_BYTEORDER_H +#define _HACK_ASM_BYTEORDER_H 1 + +#include <endian.h> +#include <byteswap.h> + +#define BO_cvt(bits, from, to, x) \ + ((from) == (to) ? (u_int##bits##_t) (x) : bswap_##bits (x)) +#define BO_cvtp(bits, from, to, p) \ + BO_cvt (bits, from, to, *(const u_int##bits##_t *) (p)) +#define BO_cvts(bits, from, to, p) \ + ({ const u_int##bits##_t *_p = (p); *_p = BO_cvt (bits, from, to, *_p); }) + +#define __cpu_to_le64(x) BO_cvt (64, BYTE_ORDER, LITTLE_ENDIAN, (x)) +#define __le64_to_cpu(x) BO_cvt (64, LITTLE_ENDIAN, BYTE_ORDER, (x)) +#define __cpu_to_le32(x) BO_cvt (32, BYTE_ORDER, LITTLE_ENDIAN, (x)) +#define __le32_to_cpu(x) BO_cvt (32, LITTLE_ENDIAN, BYTE_ORDER, (x)) +#define __cpu_to_le16(x) BO_cvt (16, BYTE_ORDER, LITTLE_ENDIAN, (x)) +#define __le16_to_cpu(x) BO_cvt (16, LITTLE_ENDIAN, BYTE_ORDER, (x)) +#define __cpu_to_be64(x) BO_cvt (64, BYTE_ORDER, BIG_ENDIAN, (x)) +#define __be64_to_cpu(x) BO_cvt (64, BIG_ENDIAN, BYTE_ORDER, (x)) +#define __cpu_to_be32(x) BO_cvt (32, BYTE_ORDER, BIG_ENDIAN, (x)) +#define __be32_to_cpu(x) BO_cvt (32, BIG_ENDIAN, BYTE_ORDER, (x)) +#define __cpu_to_be16(x) BO_cvt (16, BYTE_ORDER, BIG_ENDIAN, (x)) +#define __be16_to_cpu(x) BO_cvt (16, BIG_ENDIAN, BYTE_ORDER, (x)) +#define __cpu_to_le64p(p) BO_cvtp (64, BYTE_ORDER, LITTLE_ENDIAN, (p)) +#define __le64_to_cpup(p) BO_cvtp (64, LITTLE_ENDIAN, BYTE_ORDER, (p)) +#define __cpu_to_le32p(p) BO_cvtp (32, BYTE_ORDER, LITTLE_ENDIAN, (p)) +#define __le32_to_cpup(p) BO_cvtp (32, LITTLE_ENDIAN, BYTE_ORDER, (p)) +#define __cpu_to_le16p(p) BO_cvtp (16, BYTE_ORDER, LITTLE_ENDIAN, (p)) +#define __le16_to_cpup(p) BO_cvtp (16, LITTLE_ENDIAN, BYTE_ORDER, (p)) +#define __cpu_to_be64p(p) BO_cvtp (64, BYTE_ORDER, BIG_ENDIAN, (p)) +#define __be64_to_cpup(p) BO_cvtp (64, BIG_ENDIAN, BYTE_ORDER, (p)) +#define __cpu_to_be32p(p) BO_cvtp (32, BYTE_ORDER, BIG_ENDIAN, (p)) +#define __be32_to_cpup(p) BO_cvtp (32, BIG_ENDIAN, BYTE_ORDER, (p)) +#define __cpu_to_be16p(p) BO_cvtp (16, BYTE_ORDER, BIG_ENDIAN, (p)) +#define __be16_to_cpup(p) BO_cvtp (16, BIG_ENDIAN, BYTE_ORDER, (p)) +#define __cpu_to_le64s(p) BO_cvts (64, BYTE_ORDER, LITTLE_ENDIAN, (p)) +#define __le64_to_cpus(p) BO_cvts (64, LITTLE_ENDIAN, BYTE_ORDER, (p)) +#define __cpu_to_le32s(p) BO_cvts (32, BYTE_ORDER, LITTLE_ENDIAN, (p)) +#define __le32_to_cpus(p) BO_cvts (32, LITTLE_ENDIAN, BYTE_ORDER, (p)) +#define __cpu_to_le16s(p) BO_cvts (16, BYTE_ORDER, LITTLE_ENDIAN, (p)) +#define __le16_to_cpus(p) BO_cvts (16, LITTLE_ENDIAN, BYTE_ORDER, (p)) +#define __cpu_to_be64s(p) BO_cvts (64, BYTE_ORDER, BIG_ENDIAN, (p)) +#define __be64_to_cpus(p) BO_cvts (64, BIG_ENDIAN, BYTE_ORDER, (p)) +#define __cpu_to_be32s(p) BO_cvts (32, BYTE_ORDER, BIG_ENDIAN, (p)) +#define __be32_to_cpus(p) BO_cvts (32, BIG_ENDIAN, BYTE_ORDER, (p)) +#define __cpu_to_be16s(p) BO_cvts (16, BYTE_ORDER, BIG_ENDIAN, (p)) +#define __be16_to_cpus(p) BO_cvts (16, BIG_ENDIAN, BYTE_ORDER, (p)) + +#define cpu_to_le64 __cpu_to_le64 +#define le64_to_cpu __le64_to_cpu +#define cpu_to_le32 __cpu_to_le32 +#define le32_to_cpu __le32_to_cpu +#define cpu_to_le16 __cpu_to_le16 +#define le16_to_cpu __le16_to_cpu +#define cpu_to_be64 __cpu_to_be64 +#define be64_to_cpu __be64_to_cpu +#define cpu_to_be32 __cpu_to_be32 +#define be32_to_cpu __be32_to_cpu +#define cpu_to_be16 __cpu_to_be16 +#define be16_to_cpu __be16_to_cpu +#define cpu_to_le64p __cpu_to_le64p +#define le64_to_cpup __le64_to_cpup +#define cpu_to_le32p __cpu_to_le32p +#define le32_to_cpup __le32_to_cpup +#define cpu_to_le16p __cpu_to_le16p +#define le16_to_cpup __le16_to_cpup +#define cpu_to_be64p __cpu_to_be64p +#define be64_to_cpup __be64_to_cpup +#define cpu_to_be32p __cpu_to_be32p +#define be32_to_cpup __be32_to_cpup +#define cpu_to_be16p __cpu_to_be16p +#define be16_to_cpup __be16_to_cpup +#define cpu_to_le64s __cpu_to_le64s +#define le64_to_cpus __le64_to_cpus +#define cpu_to_le32s __cpu_to_le32s +#define le32_to_cpus __le32_to_cpus +#define cpu_to_le16s __cpu_to_le16s +#define le16_to_cpus __le16_to_cpus +#define cpu_to_be64s __cpu_to_be64s +#define be64_to_cpus __be64_to_cpus +#define cpu_to_be32s __cpu_to_be32s +#define be32_to_cpus __be32_to_cpus +#define cpu_to_be16s __cpu_to_be16s +#define be16_to_cpus __be16_to_cpus + + +#if BYTE_ORDER == BIG_ENDIAN +# define __BIG_ENDIAN_BITFIELD +#elif BYTE_ORDER == LITTLE_ENDIAN +# define __LITTLE_ENDIAN_BITFIELD +#else +# error __FOO_ENDIAN_BITFIELD +#endif + + +#include <netinet/in.h> /* for htonl et al */ + +/* Though the optimized macros defined by glibc do the constant magic, + there are places in the Linux code that use these in constant-only + places like initializers, and the ({...}) expressions the macros use are + not valid in those contexts. */ +#if BYTE_ORDER == BIG_ENDIAN +# if !defined(__constant_htonl) +# define __constant_htonl(x) (x) +# endif +# if !defined(__constant_htons) +# define __constant_htons(x) (x) +# endif +#elif BYTE_ORDER == LITTLE_ENDIAN +# if !defined(__constant_htonl) +# define __constant_htonl(x) \ + ((unsigned long int)((((unsigned long int)(x) & 0x000000ffU) << 24) | \ + (((unsigned long int)(x) & 0x0000ff00U) << 8) | \ + (((unsigned long int)(x) & 0x00ff0000U) >> 8) | \ + (((unsigned long int)(x) & 0xff000000U) >> 24))) +# endif +# if !defined(__constant_htons) +# define __constant_htons(x) \ + ((unsigned short int)((((unsigned short int)(x) & 0x00ff) << 8) | \ + (((unsigned short int)(x) & 0xff00) >> 8))) +# endif +#else +# error "Don't know if bytes are big- or little-endian!" +#endif + +/* The transformation is the same in both directions. */ +#define __constant_ntohl __constant_htonl +#define __constant_ntohs __constant_htons + + +/* Some Linux code (e.g. <net/tcp.h>) uses #ifdef __BIG_ENDIAN et al. + This is not real wonderful with the glibc definitions, where + __BIG_ENDIAN et al are always defined (as values for __BYTE_ORDER). */ +#if BYTE_ORDER == BIG_ENDIAN +#undef __LITTLE_ENDIAN +#elif BYTE_ORDER == LITTLE_ENDIAN +#undef __BIG_ENDIAN +#endif +#undef __PDP_ENDIAN + +/* Since we've now broken anything that does glibc-style tests, + make sure they break loudly rather than silently. Any headers + that need __BYTE_ORDER will just have to be included before + we diddle with __BIG_ENDIAN or __LITTLE_ENDIAN above. */ +#undef __BYTE_ORDER +#define __BYTE_ORDER ?????crash????? + + +#endif /* asm/byteorder.h */ diff --git a/pfinet/glue-include/asm/checksum.h b/pfinet/glue-include/asm/checksum.h new file mode 100644 index 00000000..5bcf7551 --- /dev/null +++ b/pfinet/glue-include/asm/checksum.h @@ -0,0 +1,5 @@ +/* This is the only file from the Linux include/asm-* directory + that we use, so we use this magic file here rather than making a + symlink asm -> .../linux-src/include/asm-SYSTYPE somewhere. */ + +#include "../../linux-src/include/asm-" _HURD_SYSTYPE "/checksum.h" diff --git a/pfinet/glue-include/asm/errno.h b/pfinet/glue-include/asm/errno.h new file mode 100644 index 00000000..7afb6fdc --- /dev/null +++ b/pfinet/glue-include/asm/errno.h @@ -0,0 +1,3 @@ +/* This is used only by checksum.S; the C code uses <linux/errno.h>. */ + +#define EFAULT 42 /* only used in unreached code */ diff --git a/pfinet/glue-include/asm/hardirq.h b/pfinet/glue-include/asm/hardirq.h new file mode 100644 index 00000000..c73d7dcb --- /dev/null +++ b/pfinet/glue-include/asm/hardirq.h @@ -0,0 +1 @@ +#include <linux/interrupt.h> diff --git a/pfinet/glue-include/asm/init.h b/pfinet/glue-include/asm/init.h new file mode 100644 index 00000000..2331be7c --- /dev/null +++ b/pfinet/glue-include/asm/init.h @@ -0,0 +1,3 @@ +#define __init +#define __initdata +#define __initfunc(x) x diff --git a/pfinet/glue-include/asm/segment.h b/pfinet/glue-include/asm/segment.h new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/pfinet/glue-include/asm/segment.h diff --git a/pfinet/glue-include/asm/spinlock.h b/pfinet/glue-include/asm/spinlock.h new file mode 100644 index 00000000..937c5d05 --- /dev/null +++ b/pfinet/glue-include/asm/spinlock.h @@ -0,0 +1,75 @@ +#ifndef _HACK_ASM_SPINLOCK_H_ +#define _HACK_ASM_SPINLOCK_H_ + +#include <cthreads.h> + +typedef struct { } spinlock_t; +#define SPIN_LOCK_UNLOCKED (spinlock_t) { } + +#undef spin_lock_init +#undef spin_lock +#undef spin_unlock + +#define spin_lock_init(lock) ((void) (lock)) +#define spin_lock(lock) ((void) (lock)) +#define spin_trylock(lock) ((void) (lock), 1) +#define spin_unlock_wait(lock) ((void) (lock)) +#define spin_unlock(lock) ((void) (lock)) +#define spin_lock_irq(lock) ((void) (lock)) +#define spin_unlock_irq(lock) ((void) (lock)) +#define spin_lock_irqsave(lock, flags) ((void) (lock), (void) (flags)) +#define spin_unlock_irqrestore(lock, flags) ((void) (lock), (void) (flags)) + +typedef struct { } rwlock_t; +#define read_lock(rw) do { } while(0) +#define write_lock(rw) do { } while(0) +#define write_unlock(rw) do { } while(0) +#define read_unlock(rw) do { } while(0) + +#if 0 +#include <rwlock.h> + +typedef struct mutex spinlock_t; + +#undef spin_lock_init +#undef spin_lock +#undef spin_unlock + +#define SPIN_LOCK_UNLOCKED MUTEX_INITIALIZER +#define spin_lock_init(lock) ({ __mutex_init (lock); }) +#define spin_lock(lock) ({ __mutex_lock (lock); }) +#define spin_trylock(lock) ({ __mutex_trylock (lock); }) +#define spin_unlock_wait(lock) ({ __mutex_unlock (lock); }) +#define spin_unlock(lock) ({ __mutex_unlock (lock); }) +#define spin_lock_irq(lock) ({ __mutex_lock (lock); }) +#define spin_unlock_irq(lock) ({ __mutex_unlock (lock); }) + +#define spin_lock_irqsave(lock, flags) \ + do { flags = 0; __mutex_lock (lock); } while (0) +#define spin_unlock_irqrestore(lock, flags) ({ __mutex_unlock (lock); }) + + +typedef struct rwlock rwlock_t; + +#define read_lock(rw) rwlock_reader_lock(rw) +#define write_lock(rw) rwlock_writer_lock(rw) +#define write_unlock(rw) rwlock_writer_unlock(rw) +#define read_unlock(rw) rwlock_reader_unlock(rw) + +#endif + + +#define read_lock_irq(lock) read_lock(lock) +#define read_unlock_irq(lock) read_unlock(lock) +#define write_lock_irq(lock) write_lock(lock) +#define write_unlock_irq(lock) write_unlock(lock) + +#define read_lock_irqsave(lock, flags) \ + do { (flags) = 0; read_lock(lock); } while (0) +#define read_unlock_irqrestore(lock, flags) read_unlock(lock) +#define write_lock_irqsave(lock, flags) \ + do { (flags) = 0; write_lock(lock); } while (0) +#define write_unlock_irqrestore(lock, flags) write_unlock(lock) + + +#endif diff --git a/pfinet/glue-include/asm/system.h b/pfinet/glue-include/asm/system.h new file mode 100644 index 00000000..1a5d61cd --- /dev/null +++ b/pfinet/glue-include/asm/system.h @@ -0,0 +1,20 @@ +#ifndef _HACK_ASM_SYSTEM_H +#define _HACK_ASM_SYSTEM_H + +/* We don't need atomicity in the Linux code because we serialize all + entries to it. */ + +#include <stdint.h> + +#define xchg(ptr, x) \ + ({ \ + __typeof__ (*(ptr)) *_ptr = (ptr), _x = *_ptr; \ + (uintptr_t) *_ptr = (x); _x; \ + }) + +#define mb() ((void) 0) /* memory barrier */ +#define rmb() mb() +#define wmb() mb() + + +#endif diff --git a/pfinet/glue-include/asm/types.h b/pfinet/glue-include/asm/types.h new file mode 100644 index 00000000..ee9b980a --- /dev/null +++ b/pfinet/glue-include/asm/types.h @@ -0,0 +1 @@ +#include <linux/types.h> diff --git a/pfinet/glue-include/asm/uaccess.h b/pfinet/glue-include/asm/uaccess.h new file mode 100644 index 00000000..d8373797 --- /dev/null +++ b/pfinet/glue-include/asm/uaccess.h @@ -0,0 +1,47 @@ +#ifndef _HACK_ASM_UACCESS_H_ +#define _HACK_ASM_UACCESS_H_ + +#include <linux/mm.h> + + +#define MAKE_MM_SEG(s) XXX +#define KERNEL_DS XXX +#define USER_DS XXX + +#define get_ds() XXX +#define get_fs() XXX +#define set_fs(x) XXX + +#define segment_eq(a,b) XXX + +extern int __verify_write(const void *, unsigned long); +#define __verify_write XXX + +#define __addr_ok(addr) (1) +#define __range_ok(addr,size) (1) +#define access_ok(type,addr,size) (1) + +#define put_user(x,ptr) (*(ptr) = (x), 0) +#define get_user(x,ptr) ((x) = *(ptr), 0) + +/* + * The "xxx_ret" versions return constant specified in third argument, if + * something bad happens. These macros can be optimized for the + * case of just returning from the function xxx_ret is used. + */ + +#define put_user_ret(x,ptr,ret) ({ if (put_user(x,ptr)) return ret; }) + +#define get_user_ret(x,ptr,ret) ({ if (get_user(x,ptr)) return ret; }) + + +#define copy_to_user(to,from,n) (memcpy ((to), (from), (n)), 0) +#define copy_from_user(to,from,n) (memcpy ((to), (from), (n)), 0) +#define clear_user(mem, len) (bzero ((mem), (len)), 0) + +#define copy_to_user_ret(to,from,n,retval) ({ if (copy_to_user(to,from,n)) return retval; }) + +#define copy_from_user_ret(to,from,n,retval) ({ if (copy_from_user(to,from,n)) return retval; }) + + +#endif diff --git a/pfinet/glue-include/linux/autoconf.h b/pfinet/glue-include/linux/autoconf.h new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/pfinet/glue-include/linux/autoconf.h diff --git a/pfinet/glue-include/linux/binfmts.h b/pfinet/glue-include/linux/binfmts.h new file mode 100644 index 00000000..c8229dad --- /dev/null +++ b/pfinet/glue-include/linux/binfmts.h @@ -0,0 +1 @@ +#include <linux/capability.h> diff --git a/pfinet/glue-include/linux/config.h b/pfinet/glue-include/linux/config.h new file mode 100644 index 00000000..be1e4d3f --- /dev/null +++ b/pfinet/glue-include/linux/config.h @@ -0,0 +1 @@ +#include <linux/errno.h> diff --git a/pfinet/glue-include/linux/errno.h b/pfinet/glue-include/linux/errno.h new file mode 100644 index 00000000..7afcd9fd --- /dev/null +++ b/pfinet/glue-include/linux/errno.h @@ -0,0 +1,13 @@ +#ifndef _HACK_ERRNO_H +#define _HACK_ERRNO_H + +#include <errno.h> +#include <hurd.h> + +#define ERESTARTSYS EINTR +#define ENOPKG ENOSYS +#define ENOIOCTLCMD ENOTTY + +#undef errno + +#endif diff --git a/pfinet/glue-include/linux/fcntl.h b/pfinet/glue-include/linux/fcntl.h new file mode 100644 index 00000000..cd304557 --- /dev/null +++ b/pfinet/glue-include/linux/fcntl.h @@ -0,0 +1 @@ +#include <fcntl.h> diff --git a/pfinet/glue-include/linux/fs.h b/pfinet/glue-include/linux/fs.h new file mode 100644 index 00000000..45dbb19f --- /dev/null +++ b/pfinet/glue-include/linux/fs.h @@ -0,0 +1,21 @@ +#ifndef _HACK_FS_H +#define _HACK_FS_H + +#include <linux/net.h> + +/* Hackery */ +struct inode +{ + union + { + int i_garbage; + struct socket socket_i; /* icmp.c actually needs this!! */ + } u; +}; +#define i_uid u.i_garbage +#define i_gid u.i_garbage +#define i_sock u.i_garbage +#define i_ino u.i_garbage +#define i_mode u.i_garbage + +#endif diff --git a/pfinet/glue-include/linux/in.h b/pfinet/glue-include/linux/in.h new file mode 100644 index 00000000..074c70e3 --- /dev/null +++ b/pfinet/glue-include/linux/in.h @@ -0,0 +1,44 @@ +#ifndef _HACK_IN_H_ +#define _HACK_IN_H_ + +#include <netinet/in.h> + +/* IP_MTU_DISCOVER values */ +#define IP_PMTUDISC_DONT 0 /* Never send DF frames */ +#define IP_PMTUDISC_WANT 1 /* Use per route hints */ +#define IP_PMTUDISC_DO 2 /* Always DF */ + +/* These need to appear somewhere around here */ +#define IP_DEFAULT_MULTICAST_TTL 1 +#define IP_DEFAULT_MULTICAST_LOOP 1 + +struct ip_mreqn +{ + struct in_addr imr_multiaddr; /* IP multicast address of group */ + struct in_addr imr_address; /* local IP address of interface */ + int imr_ifindex; /* Interface index */ +}; + +struct in_pktinfo +{ + int ipi_ifindex; + struct in_addr ipi_spec_dst; + struct in_addr ipi_addr; +}; + + +/* <asm/byteorder.h> contains the htonl type stuff.. */ +#include <asm/byteorder.h> + +#ifdef __KERNEL__ +/* Some random defines to make it easier in the kernel.. */ +#define LOOPBACK(x) (((x) & htonl(0xff000000)) == htonl(0x7f000000)) +#define MULTICAST(x) (((x) & htonl(0xf0000000)) == htonl(0xe0000000)) +#define BADCLASS(x) (((x) & htonl(0xf0000000)) == htonl(0xf0000000)) +#define ZERONET(x) (((x) & htonl(0xff000000)) == htonl(0x00000000)) +#define LOCAL_MCAST(x) (((x) & htonl(0xFFFFFF00)) == htonl(0xE0000000)) + +#endif + + +#endif diff --git a/pfinet/glue-include/linux/in6.h b/pfinet/glue-include/linux/in6.h new file mode 100644 index 00000000..260020a6 --- /dev/null +++ b/pfinet/glue-include/linux/in6.h @@ -0,0 +1 @@ +#include <netinet/in.h> diff --git a/pfinet/glue-include/linux/interrupt.h b/pfinet/glue-include/linux/interrupt.h new file mode 100644 index 00000000..5f485e32 --- /dev/null +++ b/pfinet/glue-include/linux/interrupt.h @@ -0,0 +1,44 @@ +#ifndef _HACK_INTERRUPT_H_ +#define _HACK_INTERRUPT_H_ + +#include <linux/netdevice.h> +#include "pfinet.h" + +#define in_interrupt() (0) +#define synchronize_irq() ((void) 0) + +#define synchronize_bh() ((void) 0) /* XXX ? */ + +/* The code that can call these are already entered holding + global_lock, which locks out the net_bh worker thread. */ +#define start_bh_atomic() ((void) 0) +#define end_bh_atomic() ((void) 0) +/* +extern struct mutex net_bh_lock; +#define start_bh_atomic() __mutex_lock (&net_bh_lock) +#define end_bh_atomic() __mutex_unlock (&net_bh_lock) +*/ + +/* See sched.c::net_bh_worker comments. */ +extern struct condition net_bh_wakeup; + +#define NET_BH 0xb00bee51 + +/* The only call to this ever reached is in net/core/dev.c::netif_rx, + to announce having enqueued a packet on `backlog'. */ +static inline void +mark_bh (int bh) +{ + assert (bh == NET_BH); + condition_broadcast (&net_bh_wakeup); +} + +void net_bh (void); +static inline void +init_bh (int bh, void (*fn) (void)) +{ + assert (bh == NET_BH); + assert (fn == &net_bh); +} + +#endif diff --git a/pfinet/glue-include/linux/ioctl.h b/pfinet/glue-include/linux/ioctl.h new file mode 100644 index 00000000..6ec92cf7 --- /dev/null +++ b/pfinet/glue-include/linux/ioctl.h @@ -0,0 +1 @@ +#include <sys/ioctl.h> diff --git a/pfinet/glue-include/linux/ipv6.h b/pfinet/glue-include/linux/ipv6.h new file mode 100644 index 00000000..374f9b1e --- /dev/null +++ b/pfinet/glue-include/linux/ipv6.h @@ -0,0 +1 @@ +#include <linux/in6.h> diff --git a/pfinet/glue-include/linux/kernel.h b/pfinet/glue-include/linux/kernel.h new file mode 100644 index 00000000..a0e101b9 --- /dev/null +++ b/pfinet/glue-include/linux/kernel.h @@ -0,0 +1,78 @@ +#ifndef _HACK_KERNEL_H +#define _HACK_KERNEL_H + +#include <stdio.h> +#include <stdlib.h> +#include <assert.h> + + +/* These don't actually matter since our locking protocols are different. */ +#define barrier() ((void)0) /*__asm__ __volatile__("": : :"memory") */ + +#define NORET_TYPE /**/ +#define ATTRIB_NORET __attribute__((noreturn)) +#define NORET_AND noreturn, +#define FASTCALL(x) x + +/* XXX do something syslogy */ +#define KERN_EMERG +#define KERN_ALERT +#define KERN_CRIT +#define KERN_ERR +#define KERN_WARNING +#define KERN_NOTICE +#define KERN_INFO +#define KERN_DEBUG + +#define panic(str...) (printk (str), assert (!"panic")) + +/* + * Display an IP address in readable format. + */ + +#define NIPQUAD(addr) \ + ((unsigned char *)&addr)[0], \ + ((unsigned char *)&addr)[1], \ + ((unsigned char *)&addr)[2], \ + ((unsigned char *)&addr)[3] + + +#include <linux/sched.h> +#include <linux/bitops.h> + +#define printk printf + +extern inline int +getname (const char *name, char **newp) +{ + *newp = malloc (strlen (name) + 1); + strcpy (*newp, name); + return 0; +} + +extern inline void +putname (char *p) +{ + free (p); +} + +/* These two functions are used only to send SIGURG. But I can't + find any SIGIO code at all. So we'll just punt on that; clearly + Linux is missing the point. SIGURG should only be sent for + sockets that have explicitly requested it. */ +extern inline int +kill_proc (int pid, int signo, int priv) +{ + assert (signo == SIGURG); + return 0; +} + +extern inline int +kill_pg (int pgrp, int signo, int priv) +{ + assert (signo == SIGURG); + return 0; +} + + +#endif diff --git a/pfinet/glue-include/linux/limits.h b/pfinet/glue-include/linux/limits.h new file mode 100644 index 00000000..856c3bde --- /dev/null +++ b/pfinet/glue-include/linux/limits.h @@ -0,0 +1,8 @@ +#ifndef _HACK_LIMITS_H +#define _HACK_LIMITS_H + +#include <limits.h> + +#define UIO_MAXIOV 1024 /* probably 1 would do */ + +#endif diff --git a/pfinet/glue-include/linux/major.h b/pfinet/glue-include/linux/major.h new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/pfinet/glue-include/linux/major.h diff --git a/pfinet/glue-include/linux/malloc.h b/pfinet/glue-include/linux/malloc.h new file mode 100644 index 00000000..46ae1051 --- /dev/null +++ b/pfinet/glue-include/linux/malloc.h @@ -0,0 +1,27 @@ +#ifndef _HACK_MALLOC_H_ +#define _HACK_MALLOC_H_ + +#include <linux/mm.h> + +#include <stdlib.h> + +static inline void *kmalloc (size_t sz, int ignored) { return malloc (sz); } +static inline void kfree (void *ptr) { free (ptr); } +static inline void kfree_s (void *ptr, size_t sz) { free (ptr); } +#define free(x) kfree(x) /* just don't ask */ + + +typedef struct kmem_cache_s kmem_cache_t; + +#define SLAB_HWCACHE_ALIGN 0 /* flag everybody uses */ +#define SLAB_ATOMIC 0 + + +extern kmem_cache_t *kmem_cache_create(const char *, size_t, size_t, unsigned long, + void (*)(void *, kmem_cache_t *, unsigned long), + void (*)(void *, kmem_cache_t *, unsigned long)); +extern void *kmem_cache_alloc(kmem_cache_t *, int); +extern void kmem_cache_free(kmem_cache_t *, void *); + + +#endif diff --git a/pfinet/glue-include/linux/mm.h b/pfinet/glue-include/linux/mm.h new file mode 100644 index 00000000..a6f28e00 --- /dev/null +++ b/pfinet/glue-include/linux/mm.h @@ -0,0 +1,18 @@ +#ifndef _HACK_MM_H_ +#define _HACK_MM_H_ + +#include <linux/kernel.h> +#include <linux/sched.h> + +/* All memory addresses are presumptively valid, because they are + all internal. */ +#define verify_area(a,b,c) 0 + +#define VERIFY_READ 0 +#define VERIFY_WRITE 0 +#define GFP_ATOMIC 0 +#define GFP_KERNEL 0 +#define GFP_BUFFER 0 +#define __GFP_WAIT 0 + +#endif diff --git a/pfinet/glue-include/linux/param.h b/pfinet/glue-include/linux/param.h new file mode 100644 index 00000000..39efaf0d --- /dev/null +++ b/pfinet/glue-include/linux/param.h @@ -0,0 +1 @@ +#include <sys/param.h> diff --git a/pfinet/glue-include/linux/personality.h b/pfinet/glue-include/linux/personality.h new file mode 100644 index 00000000..9e218435 --- /dev/null +++ b/pfinet/glue-include/linux/personality.h @@ -0,0 +1 @@ +#include <linux/linkage.h> diff --git a/pfinet/glue-include/linux/poll.h b/pfinet/glue-include/linux/poll.h new file mode 100644 index 00000000..d608abf2 --- /dev/null +++ b/pfinet/glue-include/linux/poll.h @@ -0,0 +1,24 @@ +#ifndef _HACK_POLL_H_ +#define _HACK_POLL_H_ + +#include <hurd/hurd_types.h> + +#define POLLIN SELECT_READ +#define POLLRDNORM SELECT_READ +#define POLLOUT SELECT_WRITE +#define POLLWRNORM SELECT_WRITE +#define POLLWRBAND SELECT_WRITE +#define POLLPRI SELECT_URG +#define POLLERR 0 +#define POLLHUP 0 + +typedef struct poll_table_struct { } poll_table; + +#include <linux/sched.h> + +static inline void +poll_wait(struct file * filp, struct wait_queue ** wait_address, poll_table *p) +{ +} + +#endif diff --git a/pfinet/glue-include/linux/proc_fs.h b/pfinet/glue-include/linux/proc_fs.h new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/pfinet/glue-include/linux/proc_fs.h diff --git a/pfinet/glue-include/linux/sched.h b/pfinet/glue-include/linux/sched.h new file mode 100644 index 00000000..897a2df0 --- /dev/null +++ b/pfinet/glue-include/linux/sched.h @@ -0,0 +1,176 @@ +#ifndef _HACK_SCHED_H +#define _HACK_SCHED_H + +#include <sys/signal.h> +#include <sys/time.h> +#include <mach.h> +#include <hurd/hurd_types.h> +#include <limits.h> +#include <assert.h> +#include <cthreads.h> + +#include "mapped-time.h" + +#include <linux/binfmts.h> +#include <linux/personality.h> +#include <linux/tasks.h> +#include <linux/kernel.h> +#include <linux/types.h> +#include <linux/times.h> +#include <linux/timex.h> + +#include <asm/system.h> +#if 0 +#include <asm/semaphore.h> +#include <asm/page.h> + +#include <linux/smp.h> +#include <linux/tty.h> +#include <linux/sem.h> +#include <linux/signal.h> +#include <linux/securebits.h> +#endif + +#include <linux/kernel.h> +#include <linux/net.h> +#include <linux/wait.h> +#include <linux/timer.h> + + +#define jiffies (fetch_jiffies ()) + +#define current (¤t_contents) +extern struct task_struct current_contents; +struct task_struct +{ + uid_t pgrp, pid; + int flags; + int timeout; + int signal; + int blocked; + int state, policy; + int isroot; + char *comm; + struct wait_queue **next_wait; +}; + +static inline void +prepare_current (int isroot) +{ + current->signal = 0; + current->isroot = isroot; + /* All other members are constant zero and ignored. */ +} +#define become_task(user) prepare_current ((user)->isroot) +#define become_task_protid(protid) prepare_current ((protid)->isroot) + +#define signal_pending(current) ((current)->signal) + +/* FLAGS in task_struct's. */ +#define PF_EXITING 1 +/* STATE in task_struct's. */ +#define TASK_INTERRUPTIBLE 0 +#define TASK_RUNNING 0 +/* policy in task_struct's. */ +#define SCHED_YIELD 0 + +struct semaphore { }; + + +extern inline int +suser () +{ + return current->isroot; +}; + +extern inline int +capable(int cap) +{ + return current->isroot; +} + + +extern struct mutex global_lock; + +static inline void +interruptible_sleep_on (struct wait_queue **p) +{ + struct condition **condp = (void *) p, *c; + int isroot; + struct wait_queue **next_wait; + + c = *condp; + if (c == 0) + { + c = malloc (sizeof **condp); + assert (c); + condition_init (c); + *condp = c; + } + + isroot = current->isroot; /* This is our context that needs switched. */ + next_wait = current->next_wait; /* This too, for multiple schedule calls. */ + current->next_wait = 0; + if (hurd_condition_wait (c, &global_lock)) + current->signal = 1; /* We got cancelled, mark it for later. */ + current->isroot = isroot; /* Switch back to our context. */ + current->next_wait = next_wait; +} +#define sleep_on interruptible_sleep_on + +static inline void +wake_up_interruptible (struct wait_queue **p) +{ + struct condition **condp = (void *) p, *c = *condp; + if (c) + condition_broadcast (c); +} +#define wake_up wake_up_interruptible + + +static inline void +add_wait_queue(struct wait_queue ** p, struct wait_queue * wait) +{ + assert (current->next_wait == 0); + current->next_wait = p; +} + +static inline void +remove_wait_queue(struct wait_queue ** p, struct wait_queue * wait) +{ + assert (current->next_wait == p); + current->next_wait = 0; +} + +static inline void +schedule (void) +{ + assert (current->next_wait); + interruptible_sleep_on (current->next_wait); +} + +static inline long +schedule_timeout (long timeout) +{ + /* XXX this is only ever called to do SO_LINGER, which we don't support */ + assert (!"schedule_timeout"); + return 0; +} + +#define MAX_SCHEDULE_TIMEOUT LONG_MAX + +/* This function is used only to send SIGPIPE to the current + task. In all such cases, EPIPE is returned anyhow. In the + Hurd, servers are not responsible for SIGPIPE; the library + does that itself upon receiving EPIPE. So we can just + NOP such calls. */ +extern inline int +send_sig (u_long signo, struct task_struct *task, int priv) +{ + assert (signo == SIGPIPE); + assert (task == current); + return 0; +} + + +#endif diff --git a/pfinet/glue-include/linux/slab.h b/pfinet/glue-include/linux/slab.h new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/pfinet/glue-include/linux/slab.h diff --git a/pfinet/glue-include/linux/socket.h b/pfinet/glue-include/linux/socket.h new file mode 100644 index 00000000..12c73bfa --- /dev/null +++ b/pfinet/glue-include/linux/socket.h @@ -0,0 +1,138 @@ +#ifndef _HACK_SOCKET_H_ +#define _HACK_SOCKET_H_ + +#include <linux/types.h> +#include <asm/system.h> + +#include <sys/socket.h> +#include <sys/uio.h> +#include <sys/ioctl.h> +#include <limits.h> + + +/* #define IP_MAX_MEMBERSHIPS 10 */ + +#define IPTOS_LOWDELAY 0x10 +#define IPTOS_THROUGHPUT 0x08 +#define IPTOS_RELIABILITY 0x04 + +#define SOPRI_INTERACTIVE 0 +#define SOPRI_NORMAL 1 +#define SOPRI_BACKGROUND 2 + +#define SOL_IP IPPROTO_IP +#define SOL_TCP IPPROTO_TCP +#define SOL_RAW IPPROTO_RAW + +/* IP options */ +#define IP_PKTINFO 190 +#define IP_PKTOPTIONS 191 +#define IP_MTU_DISCOVER 192 +#define IP_RECVERR 193 +#define IP_RECVTTL 194 +#define IP_RECVTOS 195 +#define IP_MTU 196 +#define IP_ROUTER_ALERT 197 + + +/* TCP options */ +#define TCP_NODELAY 1 +#define TCP_MAXSEG 2 +#define TCP_CORK 3 + +#define SO_NO_CHECK 11 +#define SO_PRIORITY 12 + +#define SO_PASSCRED 190 +#define SO_PEERCRED 191 +#define SO_BSDCOMPAT 192 + +/* Maximum queue length specifiable by listen. */ +#define SOMAXCONN 128 + +/* XXX */ +#define msg_control msg_accrights +#define msg_controllen msg_accrightslen +struct cmsghdr { int cmsg_garbage; }; +#define cmsg_len cmsg_garbage +#define cmsg_type cmsg_garbage +#define cmsg_level cmsg_garbage +static inline int +put_cmsg(struct msghdr *msg, int level, int type, int len, void *data) +{ return 0; } +#define CMSG_FIRSTHDR(msg) (0) +#define CMSG_NXTHDR(msg, cmsg) (0) +#define CMSG_DATA(cmsg) (0) +#define CMSG_ALIGN(size) (0) +#define CMSG_LEN(size) (0) + + +#define MSG_NOSIGNAL 0 +#define MSG_ERRQUEUE 0 + +/* There is no SOCK_PACKET, it is a bad bad thing. This chicanery is + because the one use of it is a comparison against a `short int' value; + using a value outside the range of that type ensures that the comparison + will always fail, and in fact it and the dead code will get optimized + out entirely at compile time. */ +#define SOCK_PACKET ((int)((uint32_t)USHRT_MAX) * 2) +#define PF_PACKET 0 + +#ifndef UIO_MAXIOV +#define UIO_MAXIOV 4 /* 1 would do */ +#endif + + +struct ucred { + pid_t pid; + uid_t uid; + gid_t gid; +}; + + +extern inline int +memcpy_fromiovecend (unsigned char *kdata, struct iovec *iov, + int offset, int len) +{ + assert (offset + len <= iov->iov_len); + memcpy (kdata, iov->iov_base + offset, len); + return 0; +} +extern inline int +memcpy_fromiovec (unsigned char *kdata, struct iovec *iov, int len) +{ + assert (len <= iov->iov_len); + memcpy (kdata, iov->iov_base, len); + return 0; +} +extern inline int +memcpy_toiovec (struct iovec *iov, unsigned char *kdata, int len) +{ + assert (len <= iov->iov_len); + memcpy (iov->iov_base, kdata, len); + return 0; +} +extern inline void +memcpy_tokerneliovec (struct iovec *iov, unsigned char *kdata, int len) +{ + assert (len <= iov->iov_len); + memcpy (iov->iov_base, kdata, len); +} + +extern int csum_partial_copy_fromiovecend(unsigned char *kdata, + struct iovec *iov, + int offset, + unsigned int len, int *csump); + +static inline int move_addr_to_kernel(void *uaddr, int ulen, void *kaddr) +{ + abort (); + return 0; +} +#if 0 +extern int verify_iovec(struct msghdr *m, struct iovec *iov, char *address, int mode); +extern int move_addr_to_user(void *kaddr, int klen, void *uaddr, int *ulen); +#endif + + +#endif diff --git a/pfinet/glue-include/linux/sockios.h b/pfinet/glue-include/linux/sockios.h new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/pfinet/glue-include/linux/sockios.h diff --git a/pfinet/glue-include/linux/stat.h b/pfinet/glue-include/linux/stat.h new file mode 100644 index 00000000..5165069b --- /dev/null +++ b/pfinet/glue-include/linux/stat.h @@ -0,0 +1 @@ +#include <sys/stat.h> diff --git a/pfinet/glue-include/linux/string.h b/pfinet/glue-include/linux/string.h new file mode 100644 index 00000000..3b2f5900 --- /dev/null +++ b/pfinet/glue-include/linux/string.h @@ -0,0 +1 @@ +#include <string.h> diff --git a/pfinet/glue-include/linux/termios.h b/pfinet/glue-include/linux/termios.h new file mode 100644 index 00000000..9e269565 --- /dev/null +++ b/pfinet/glue-include/linux/termios.h @@ -0,0 +1 @@ +#include <termios.h> diff --git a/pfinet/glue-include/linux/time.h b/pfinet/glue-include/linux/time.h new file mode 100644 index 00000000..4973c4ab --- /dev/null +++ b/pfinet/glue-include/linux/time.h @@ -0,0 +1,10 @@ +#ifndef _HACK_TIME_H_ +#define _HACK_TIME_H_ + +#include <sys/time.h> +#include "mapped-time.h" + +#define do_gettimeofday(tp) maptime_read (mapped_time, (tp)) +#define get_fast_time(tp) maptime_read (mapped_time, (tp)) + +#endif diff --git a/pfinet/glue-include/linux/timer.h b/pfinet/glue-include/linux/timer.h new file mode 100644 index 00000000..cc8dec80 --- /dev/null +++ b/pfinet/glue-include/linux/timer.h @@ -0,0 +1,36 @@ +#ifndef _HACK_TIMER_H_ +#define _HACK_TIMER_H_ + +#include <cthreads.h> + +enum tstate +{ + TIMER_INACTIVE, + TIMER_STARTING, + TIMER_STARTED, + TIMER_EXPIRED, + TIMER_FUNCTION_RUNNING, +}; + +struct timer_list +{ + struct timer_list *next, **prev; /* things like to test "T->prev != NULL" */ + unsigned long expires; + unsigned long data; + void (*function)(unsigned long); +}; + +void add_timer (struct timer_list *); +int del_timer (struct timer_list *); +void mod_timer (struct timer_list *, unsigned long); +void init_timer (struct timer_list *); + + +#define time_after(a,b) ((long)(b) - (long)(a) < 0) +#define time_before(a,b) time_after(b,a) + +#define time_after_eq(a,b) ((long)(a) - (long)(b) >= 0) +#define time_before_eq(a,b) time_after_eq(b,a) + + +#endif diff --git a/pfinet/glue-include/linux/timex.h b/pfinet/glue-include/linux/timex.h new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/pfinet/glue-include/linux/timex.h diff --git a/pfinet/glue-include/linux/types.h b/pfinet/glue-include/linux/types.h new file mode 100644 index 00000000..604b8b14 --- /dev/null +++ b/pfinet/glue-include/linux/types.h @@ -0,0 +1,31 @@ +#ifndef _HACK_TYPES_H +#define _HACK_TYPES_H + +#include <sys/types.h> +#include <sys/uio.h> +#include <stdint.h> +#include <assert.h> +#include <string.h> + +#define __u8 uint8_t +#define __u16 uint16_t +#define __u32 uint32_t +#define __u64 uint64_t +#define __s8 int8_t +#define __s16 int16_t +#define __s32 int32_t +#define __s64 int64_t +#define u8 uint8_t +#define u16 uint16_t +#define u32 uint32_t +#define u64 uint64_t +#define s8 int8_t +#define s16 int16_t +#define s32 int32_t +#define s64 int64_t + +#include <asm/system.h> +#include <asm/byteorder.h> +#include <linux/errno.h> + +#endif diff --git a/pfinet/glue-include/linux/un.h b/pfinet/glue-include/linux/un.h new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/pfinet/glue-include/linux/un.h diff --git a/pfinet/glue-include/linux/version.h b/pfinet/glue-include/linux/version.h new file mode 100644 index 00000000..3a49a481 --- /dev/null +++ b/pfinet/glue-include/linux/version.h @@ -0,0 +1,3 @@ +#define UTS_RELEASE "2.1.12" +#define LINUX_VERSION_CODE KERNEL_VERSION(2,1,12) +#define KERNEL_VERSION(x,y,z) (((x)<<16)+((y)<<8)+(z)) diff --git a/pfinet/glue-include/linux/wait.h b/pfinet/glue-include/linux/wait.h new file mode 100644 index 00000000..7ee962dc --- /dev/null +++ b/pfinet/glue-include/linux/wait.h @@ -0,0 +1,32 @@ +#ifndef _HACK_WAIT_H_ +#define _HACK_WAIT_H_ + +#include <cthreads.h> + +/* This data structure actually represents one waiter on a wait queue, + and waiters always expect to initialize it with { current, NULL }. + The actual wait queue is a `struct wait_queue *' stored somewhere. + We ignore these structures provided by the waiters entirely. + In the `struct wait_queue *' that is the "head of the wait queue" slot, + we actually store a `struct condition *' pointing to malloc'd storage. */ + +struct wait_queue +{ + struct task_struct *task; /* current */ + struct wait_queue *next; /* NULL */ +}; + + +struct select_table_elt +{ + struct condition *dependent_condition; + struct select_table_elt *next; +}; + +typedef struct select_table_struct +{ + struct condition master_condition; + struct select_table_elt *head; +} select_table; + +#endif |