i386 removal, part 24/x: Remove i386 specific parts from NDIS.
authorSascha Wildner <saw@online.de>
Wed, 29 Jul 2015 08:08:55 +0000 (10:08 +0200)
committerSascha Wildner <saw@online.de>
Wed, 29 Jul 2015 08:08:55 +0000 (10:08 +0200)
sys/emulation/ndis/Makefile
sys/emulation/ndis/kern_windrv.c
sys/emulation/ndis/ndis_var.h
sys/emulation/ndis/ntoskrnl_var.h
sys/emulation/ndis/pe_var.h
sys/emulation/ndis/subr_ntoskrnl.c
sys/emulation/ndis/winx32_wrap.S [deleted file]
usr.sbin/ndiscvt/ndiscvt.c
usr.sbin/ndiscvt/ndisgen.sh

index da0bc43..328e2f6 100644 (file)
@@ -10,8 +10,4 @@ SRCS+=        opt_usb.h
 SRCS+= winx64_wrap.S
 .endif
 
-.if ${MACHINE_ARCH} == "i386"
-SRCS+= winx32_wrap.S
-.endif
-
 .include <bsd.kmod.mk>
index 6ef6421..a6bea68 100644 (file)
 
 #include <sys/queue.h>
 
-#ifdef __i386__
-#include <machine/segments.h>
-#endif
-
 #include <bus/u4b/usb.h>
 #include <bus/u4b/usbdi.h>
 
@@ -71,21 +67,6 @@ static STAILQ_HEAD(drvdb, drvdb_ent) drvdb_head;
 static driver_object   fake_pci_driver; /* serves both PCI and cardbus */
 static driver_object   fake_pccard_driver;
 
-#ifdef __i386__
-static void x86_oldldt(void *);
-static void x86_newldt(void *);
-
-struct tid {
-       void                    *tid_except_list;       /* 0x00 */
-       uint32_t                tid_oldfs;              /* 0x04 */
-       uint32_t                tid_selector;           /* 0x08 */
-       struct tid              *tid_self;              /* 0x0C */
-       int                     tid_cpu;                /* 0x10 */
-};
-
-static struct tid      *my_tids;
-#endif /* __i386__ */
-
 #define DUMMY_REGISTRY_PATH "\\\\some\\bogus\\path"
 
 int
@@ -107,20 +88,6 @@ windrv_libinit(void)
        windrv_bus_attach(&fake_pci_driver, "PCI Bus");
        windrv_bus_attach(&fake_pccard_driver, "PCCARD Bus");
 
-#ifdef __i386__
-
-       /*
-        * In order to properly support SMP machines, we have
-        * to modify the GDT on each CPU, since we never know
-        * on which one we'll end up running.
-        */
-
-       my_tids = ExAllocatePoolWithTag(NonPagedPool,
-           sizeof(struct tid) * ncpus, 0);
-       if (my_tids == NULL)
-               panic("failed to allocate thread info blocks");
-       lwkt_cpusync_simple(-1, x86_newldt, NULL);
-#endif
        return (0);
 }
 
@@ -142,10 +109,6 @@ windrv_libfini(void)
 
        lockuninit(&drvdb_lock);
 
-#ifdef __i386__
-       lwkt_cpusync_simple(-1, x86_oldldt, NULL);
-       ExFreePool(my_tids);
-#endif
        return (0);
 }
 
@@ -590,344 +553,6 @@ windrv_wrap(funcptr func, funcptr *wrap, int argcnt, int ftype)
 #endif /* __x86_64__ */
 
 
-#ifdef __i386__
-
-struct x86desc {
-       uint16_t                x_lolimit;
-       uint16_t                x_base0;
-       uint8_t                 x_base1;
-       uint8_t                 x_flags;
-       uint8_t                 x_hilimit;
-       uint8_t                 x_base2;
-};
-
-struct gdt {
-       uint16_t                limit;
-       void                    *base;
-} __attribute__((__packed__));
-
-extern uint16_t        x86_getfs(void);
-extern void x86_setfs(uint16_t);
-extern void *x86_gettid(void);
-extern void x86_critical_enter(void);
-extern void x86_critical_exit(void);
-extern void x86_getldt(struct gdt *, uint16_t *);
-extern void x86_setldt(struct gdt *, uint16_t);
-
-#define SEL_TO_FS(x)           (((x) << 3))
-
-/*
- * The meanings of various bits in a descriptor vary a little
- * depending on whether the descriptor will be used as a
- * code, data or system descriptor. (And that in turn depends
- * on which segment register selects the descriptor.)
- * We're only trying to create a data segment, so the definitions
- * below are the ones that apply to a data descriptor.
- */
-
-#define SEGFLAGLO_PRESENT      0x80    /* segment is present */
-#define SEGFLAGLO_PRIVLVL      0x60    /* privlevel needed for this seg */
-#define SEGFLAGLO_CD           0x10    /* 1 = code/data, 0 = system */
-#define SEGFLAGLO_MBZ          0x08    /* must be zero */
-#define SEGFLAGLO_EXPANDDOWN   0x04    /* limit expands down */
-#define SEGFLAGLO_WRITEABLE    0x02    /* segment is writeable */
-#define SEGGLAGLO_ACCESSED     0x01    /* segment has been accessed */
-
-#define SEGFLAGHI_GRAN         0x80    /* granularity, 1 = byte, 0 = page */
-#define SEGFLAGHI_BIG          0x40    /* 1 = 32 bit stack, 0 = 16 bit */
-
-/*
- * Context switch from UNIX to Windows. Save the existing value
- * of %fs for this processor, then change it to point to our
- * fake TID. Note that it is also possible to pin ourselves
- * to our current CPU, though I'm not sure this is really
- * necessary. It depends on whether or not an interrupt might
- * preempt us while Windows code is running and we wind up
- * scheduled onto another CPU as a result. So far, it doesn't
- * seem like this is what happens.
- */
-
-void
-ctxsw_utow(void)
-{
-       struct tid              *t;
-
-       t = &my_tids[curthread->td_gd->gd_cpuid];
-
-       /*
-        * Ugly hack. During system bootstrap (cold == 1), only CPU 0
-        * is running. So if we were loaded at bootstrap, only CPU 0
-        * will have our special GDT entry. This is a problem for SMP
-        * systems, so to deal with this, we check here to make sure
-        * the TID for this processor has been initialized, and if it
-        * hasn't, we need to do it right now or else things will
-        * explode.
-        */
-
-       if (t->tid_self != t)
-               x86_newldt(NULL);
-
-       x86_critical_enter();
-       t->tid_oldfs = x86_getfs();
-       t->tid_cpu = curthread->td_gd->gd_cpuid;
-#if 0 /* XXX swildner */
-       sched_pin();
-#endif
-       x86_setfs(SEL_TO_FS(t->tid_selector));
-       x86_critical_exit();
-
-       /* Now entering Windows land, population: you. */
-}
-
-/*
- * Context switch from Windows back to UNIX. Restore %fs to
- * its previous value. This always occurs after a call to
- * ctxsw_utow().
- */
-
-void
-ctxsw_wtou(void)
-{
-       struct tid              *t;
-
-       x86_critical_enter();
-       t = x86_gettid();
-       x86_setfs(t->tid_oldfs);
-#if 0 /* XXX swildner */
-       sched_unpin();
-#endif
-       x86_critical_exit();
-
-       /* Welcome back to UNIX land, we missed you. */
-
-#ifdef EXTRA_SANITY
-       if (t->tid_cpu != curthread->td_gd->gd_cpuid)
-               panic("ctxsw GOT MOVED TO OTHER CPU!");
-#endif
-}
-
-static int     windrv_wrap_stdcall(funcptr, funcptr *, int);
-static int     windrv_wrap_fastcall(funcptr, funcptr *, int);
-static int     windrv_wrap_regparm(funcptr, funcptr *);
-
-extern void     x86_fastcall_wrap(void);
-extern void     x86_fastcall_wrap_call(void);
-extern void     x86_fastcall_wrap_arg(void);
-extern void     x86_fastcall_wrap_end(void);
-
-static int
-windrv_wrap_fastcall(funcptr func, funcptr *wrap, int argcnt)
-{
-       funcptr                 p;
-       vm_offset_t             *calladdr;
-       uint8_t                 *argaddr;
-       vm_offset_t             wrapstart, wrapend, wrapcall, wraparg;
-
-       wrapstart = (vm_offset_t)&x86_fastcall_wrap;
-       wrapend = (vm_offset_t)&x86_fastcall_wrap_end;
-       wrapcall = (vm_offset_t)&x86_fastcall_wrap_call;
-       wraparg = (vm_offset_t)&x86_fastcall_wrap_arg;
-
-       /* Allocate a new wrapper instance. */
-
-       p = kmalloc((wrapend - wrapstart), M_DEVBUF, M_NOWAIT);
-       if (p == NULL)
-               return (ENOMEM);
-
-       /* Copy over the code. */
-
-       bcopy((char *)wrapstart, p, (wrapend - wrapstart));
-
-       /* Insert the function address into the new wrapper instance. */
-
-       calladdr = (vm_offset_t *)((char *)p + ((wrapcall - wrapstart) + 1));
-       *calladdr = (vm_offset_t)func;
-
-       argcnt -= 2;
-       if (argcnt < 1)
-               argcnt = 0;
-
-       argaddr = (u_int8_t *)((char *)p + ((wraparg - wrapstart) + 1));
-       *argaddr = argcnt * sizeof(uint32_t);
-
-       *wrap = p;
-
-       return (0);
-}
-
-extern void     x86_stdcall_wrap(void);
-extern void     x86_stdcall_wrap_call(void);
-extern void     x86_stdcall_wrap_arg(void);
-extern void     x86_stdcall_wrap_end(void);
-
-static int
-windrv_wrap_stdcall(funcptr func, funcptr *wrap, int argcnt)
-{
-       funcptr                 p;
-       vm_offset_t             *calladdr;
-       uint8_t                 *argaddr;
-       vm_offset_t             wrapstart, wrapend, wrapcall, wraparg;
-
-       wrapstart = (vm_offset_t)&x86_stdcall_wrap;
-       wrapend = (vm_offset_t)&x86_stdcall_wrap_end;
-       wrapcall = (vm_offset_t)&x86_stdcall_wrap_call;
-       wraparg = (vm_offset_t)&x86_stdcall_wrap_arg;
-
-       /* Allocate a new wrapper instance. */
-
-       p = kmalloc((wrapend - wrapstart), M_DEVBUF, M_NOWAIT);
-       if (p == NULL)
-               return (ENOMEM);
-
-       /* Copy over the code. */
-
-       bcopy((char *)wrapstart, p, (wrapend - wrapstart));
-
-       /* Insert the function address into the new wrapper instance. */
-
-       calladdr = (vm_offset_t *)((char *)p + ((wrapcall - wrapstart) + 1));
-       *calladdr = (vm_offset_t)func;
-
-       argaddr = (u_int8_t *)((char *)p + ((wraparg - wrapstart) + 1));
-       *argaddr = argcnt * sizeof(uint32_t);
-
-       *wrap = p;
-
-       return (0);
-}
-
-extern void     x86_regparm_wrap(void);
-extern void     x86_regparm_wrap_call(void);
-extern void     x86_regparm_wrap_end(void);
-
-static int
-windrv_wrap_regparm(funcptr func, funcptr *wrap)
-{
-       funcptr                 p;
-       vm_offset_t             *calladdr;
-       vm_offset_t             wrapstart, wrapend, wrapcall;
-
-       wrapstart = (vm_offset_t)&x86_regparm_wrap;
-       wrapend = (vm_offset_t)&x86_regparm_wrap_end;
-       wrapcall = (vm_offset_t)&x86_regparm_wrap_call;
-
-       /* Allocate a new wrapper instance. */
-
-       p = kmalloc((wrapend - wrapstart), M_DEVBUF, M_NOWAIT);
-       if (p == NULL)
-               return (ENOMEM);
-
-       /* Copy over the code. */
-
-       bcopy(x86_regparm_wrap, p, (wrapend - wrapstart));
-
-       /* Insert the function address into the new wrapper instance. */
-
-       calladdr = (vm_offset_t *)((char *)p + ((wrapcall - wrapstart) + 1));
-       *calladdr = (vm_offset_t)func;
-
-       *wrap = p;
-
-       return (0);
-}
-
-int
-windrv_wrap(funcptr func, funcptr *wrap, int argcnt, int ftype)
-{
-       switch(ftype) {
-       case WINDRV_WRAP_FASTCALL:
-               return (windrv_wrap_fastcall(func, wrap, argcnt));
-       case WINDRV_WRAP_STDCALL:
-               return (windrv_wrap_stdcall(func, wrap, argcnt));
-       case WINDRV_WRAP_REGPARM:
-               return (windrv_wrap_regparm(func, wrap));
-       case WINDRV_WRAP_CDECL:
-               return (windrv_wrap_stdcall(func, wrap, 0));
-       default:
-               break;
-       }
-
-       return (EINVAL);
-}
-
-static void
-x86_oldldt(void *dummy)
-{
-       struct x86desc          *gdt;
-       struct gdt              gtable;
-       uint16_t                ltable;
-
-       mtx_spinlock(&dt_lock);
-
-       /* Grab location of existing GDT. */
-
-       x86_getldt(&gtable, &ltable);
-
-       /* Find the slot we updated. */
-
-       gdt = gtable.base;
-       gdt += GNDIS_SEL;
-
-       /* Empty it out. */
-
-       bzero((char *)gdt, sizeof(struct x86desc));
-
-       /* Restore GDT. */
-
-       x86_setldt(&gtable, ltable);
-
-       mtx_spinunlock(&dt_lock);
-}
-
-static void
-x86_newldt(void *dummy)
-{
-       struct gdt              gtable;
-       uint16_t                ltable;
-       struct x86desc          *l;
-       struct thread           *t;
-
-       t = curthread;
-
-       mtx_spinlock(&dt_lock);
-
-       /* Grab location of existing GDT. */
-
-       x86_getldt(&gtable, &ltable);
-
-       /* Get pointer to the GDT table. */
-
-       l = gtable.base;
-
-       /* Get pointer to empty slot */
-
-       l += GNDIS_SEL;
-
-       /* Initialize TID for this CPU. */
-
-       my_tids[t->td_gd->gd_cpuid].tid_selector = GNDIS_SEL;
-       my_tids[t->td_gd->gd_cpuid].tid_self = &my_tids[t->td_gd->gd_cpuid];
-
-       /* Set up new GDT entry. */
-
-       l->x_lolimit = sizeof(struct tid);
-       l->x_hilimit = SEGFLAGHI_GRAN|SEGFLAGHI_BIG;
-       l->x_base0 = (vm_offset_t)(&my_tids[t->td_gd->gd_cpuid]) & 0xFFFF;
-       l->x_base1 = ((vm_offset_t)(&my_tids[t->td_gd->gd_cpuid]) >> 16) & 0xFF;
-       l->x_base2 = ((vm_offset_t)(&my_tids[t->td_gd->gd_cpuid]) >> 24) & 0xFF;
-       l->x_flags = SEGFLAGLO_PRESENT|SEGFLAGLO_CD|SEGFLAGLO_WRITEABLE;
-
-       /* Update the GDT. */
-
-       x86_setldt(&gtable, ltable);
-
-       mtx_spinunlock(&dt_lock);
-
-       /* Whew. */
-}
-
-#endif /* __i386__ */
-
 int
 windrv_unwrap(funcptr func)
 {
index c708df8..9667880 100644 (file)
@@ -831,9 +831,6 @@ typedef enum ndis_media_state ndis_media_state;
 
 /*
 struct ndis_physaddr {
-#ifdef __i386__
-       uint64_t                np_quad;
-#endif
 #ifdef __x86_64__
        uint32_t                np_low;
        uint32_t                np_high;
index 3b28d91..4786d17 100644 (file)
@@ -476,9 +476,6 @@ typedef struct general_lookaside general_lookaside;
 
 struct npaged_lookaside_list {
        general_lookaside       nll_l;
-#ifdef __i386__
-       kspin_lock              nll_obsoletelock;
-#endif
 };
 
 typedef struct npaged_lookaside_list npaged_lookaside_list;
@@ -1446,14 +1443,8 @@ extern void KeClearEvent(nt_kevent *);
 extern uint32_t KeReadStateEvent(nt_kevent *);
 extern uint32_t KeSetEvent(nt_kevent *, uint32_t, uint8_t);
 extern uint32_t KeResetEvent(nt_kevent *);
-#ifdef __i386__
-extern void KefAcquireSpinLockAtDpcLevel(kspin_lock *);
-extern void KefReleaseSpinLockFromDpcLevel(kspin_lock *);
-extern uint8_t KeAcquireSpinLockRaiseToDpc(kspin_lock *);
-#else
 extern void KeAcquireSpinLockAtDpcLevel(kspin_lock *);
 extern void KeReleaseSpinLockFromDpcLevel(kspin_lock *);
-#endif
 extern void KeInitializeSpinLock(kspin_lock *);
 extern uint8_t KeAcquireInterruptSpinLock(kinterrupt *);
 extern void KeReleaseInterruptSpinLock(kinterrupt *, uint8_t);
@@ -1501,16 +1492,6 @@ extern void IoQueueWorkItem(io_workitem *, io_workitem_func,
  * On the Windows x86 arch, KeAcquireSpinLock() and KeReleaseSpinLock()
  * routines live in the HAL. We try to imitate this behavior.
  */
-#ifdef __i386__
-#define        KI_USER_SHARED_DATA 0xffdf0000
-#define KeAcquireSpinLock(a, b)        *(b) = KfAcquireSpinLock(a)
-#define KeReleaseSpinLock(a, b)        KfReleaseSpinLock(a, b)
-#define KeRaiseIrql(a, b)      *(b) = KfRaiseIrql(a)
-#define KeLowerIrql(a)         KfLowerIrql(a)
-#define KeAcquireSpinLockAtDpcLevel(a) KefAcquireSpinLockAtDpcLevel(a)
-#define KeReleaseSpinLockFromDpcLevel(a)  KefReleaseSpinLockFromDpcLevel(a)
-#endif /* __i386__ */
-
 #ifdef __x86_64__
 #define        KI_USER_SHARED_DATA 0xfffff78000000000UL
 #define KeAcquireSpinLock(a, b)        *(b) = KfAcquireSpinLock(a)
index ec25b2e..0ac691c 100644 (file)
@@ -480,39 +480,8 @@ extern uint64_t x86_64_call6(void *, uint64_t, uint64_t, uint64_t, uint64_t,
 
 #endif /* __x86_64__ */
 
-#ifdef __i386__
-
-extern uint32_t x86_stdcall_call(void *, int, ...);
-
-#define        MSCALL1(fn, a)          x86_stdcall_call(fn, 1, (a))
-#define        MSCALL2(fn, a, b)       x86_stdcall_call(fn, 2, (a), (b))
-#define        MSCALL3(fn, a, b, c)    x86_stdcall_call(fn, 3, (a), (b), (c))
-#define        MSCALL4(fn, a, b, c, d) x86_stdcall_call(fn, 4, (a), (b), (c), (d))
-#define        MSCALL5(fn, a, b, c, d, e)      \
-               x86_stdcall_call(fn, 5, (a), (b), (c), (d), (e))
-#define        MSCALL6(fn, a, b, c, d, e, f)   \
-               x86_stdcall_call(fn, 6, (a), (b), (c), (d), (e), (f))
-
-#endif /* __i386__ */
-
-
 #define        FUNC void(*)(void)
 
-#ifdef __i386__
-#define        IMPORT_SFUNC(x, y)      { #x, (FUNC)x, NULL, y, WINDRV_WRAP_STDCALL }
-#define        IMPORT_SFUNC_MAP(x, y, z)       \
-                               { #x, (FUNC)y, NULL, z, WINDRV_WRAP_STDCALL }
-#define        IMPORT_FFUNC(x, y)      { #x, (FUNC)x, NULL, y, WINDRV_WRAP_FASTCALL }
-#define        IMPORT_FFUNC_MAP(x, y, z)       \
-                               { #x, (FUNC)y, NULL, z, WINDRV_WRAP_FASTCALL }
-#define        IMPORT_RFUNC(x, y)      { #x, (FUNC)x, NULL, y, WINDRV_WRAP_REGPARM }
-#define        IMPORT_RFUNC_MAP(x, y, z)       \
-                               { #x, (FUNC)y, NULL, z, WINDRV_WRAP_REGPARM }
-#define        IMPORT_CFUNC(x, y)      { #x, (FUNC)x, NULL, y, WINDRV_WRAP_CDECL }
-#define        IMPORT_CFUNC_MAP(x, y, z)       \
-                               { #x, (FUNC)y, NULL, z, WINDRV_WRAP_CDECL }
-#endif /* __i386__ */
-
 #ifdef __x86_64__
 #define        IMPORT_SFUNC(x, y)      { #x, (FUNC)x, NULL, y, WINDRV_WRAP_AMD64 }
 #define        IMPORT_SFUNC_MAP(x, y, z)       \
index d92469a..53bb24a 100644 (file)
@@ -2081,10 +2081,6 @@ ExInitializePagedLookasideList(paged_lookaside_list *lookaside,
        else
                lookaside->nll_l.gl_freefunc = freefunc;
 
-#ifdef __i386__
-       KeInitializeSpinLock(&lookaside->nll_obsoletelock);
-#endif
-
        lookaside->nll_l.gl_type = NonPagedPool;
        lookaside->nll_l.gl_depth = depth;
        lookaside->nll_l.gl_maxdepth = LOOKASIDE_DEPTH;
@@ -2125,10 +2121,6 @@ ExInitializeNPagedLookasideList(npaged_lookaside_list *lookaside,
        else
                lookaside->nll_l.gl_freefunc = freefunc;
 
-#ifdef __i386__
-       KeInitializeSpinLock(&lookaside->nll_obsoletelock);
-#endif
-
        lookaside->nll_l.gl_type = NonPagedPool;
        lookaside->nll_l.gl_depth = depth;
        lookaside->nll_l.gl_maxdepth = LOOKASIDE_DEPTH;
@@ -2200,44 +2192,6 @@ KeInitializeSpinLock(kspin_lock *lock)
        *lock = 0;
 }
 
-#ifdef __i386__
-void
-KefAcquireSpinLockAtDpcLevel(kspin_lock *lock)
-{
-#ifdef NTOSKRNL_DEBUG_SPINLOCKS
-       int                     i = 0;
-#endif
-
-       while (atomic_cmpset_acq_int((volatile u_int *)lock, 0, 1) == 0) {
-               /* sit and spin */;
-#ifdef NTOSKRNL_DEBUG_SPINLOCKS
-               i++;
-               if (i > 200000000)
-                       panic("DEADLOCK!");
-#endif
-       }
-}
-
-void
-KefReleaseSpinLockFromDpcLevel(kspin_lock *lock)
-{
-       atomic_store_rel_int((volatile u_int *)lock, 0);
-}
-
-uint8_t
-KeAcquireSpinLockRaiseToDpc(kspin_lock *lock)
-{
-       uint8_t                 oldirql;
-
-       if (KeGetCurrentIrql() > DISPATCH_LEVEL)
-               panic("IRQL_NOT_LESS_THAN_OR_EQUAL");
-
-       KeRaiseIrql(DISPATCH_LEVEL, &oldirql);
-       KeAcquireSpinLockAtDpcLevel(lock);
-
-       return (oldirql);
-}
-#else
 void
 KeAcquireSpinLockAtDpcLevel(kspin_lock *lock)
 {
@@ -2250,7 +2204,6 @@ KeReleaseSpinLockFromDpcLevel(kspin_lock *lock)
 {
        atomic_store_rel_int((volatile u_int *)lock, 0);
 }
-#endif /* __i386__ */
 
 uintptr_t
 InterlockedExchange(volatile uint32_t *dst, uintptr_t val)
@@ -4147,22 +4100,14 @@ image_patch_table ntoskrnl_functbl[] = {
        IMPORT_SFUNC(ExAllocatePoolWithTag, 3),
        IMPORT_SFUNC(ExFreePoolWithTag, 2),
        IMPORT_SFUNC(ExFreePool, 1),
-#ifdef __i386__
-       IMPORT_FFUNC(KefAcquireSpinLockAtDpcLevel, 1),
-       IMPORT_FFUNC(KefReleaseSpinLockFromDpcLevel,1),
-       IMPORT_FFUNC(KeAcquireSpinLockRaiseToDpc, 1),
-#else
        /*
         * For AMD64, we can get away with just mapping
         * KeAcquireSpinLockRaiseToDpc() directly to KfAcquireSpinLock()
         * because the calling conventions end up being the same.
-        * On i386, we have to be careful because KfAcquireSpinLock()
-        * is _fastcall but KeAcquireSpinLockRaiseToDpc() isn't.
         */
        IMPORT_SFUNC(KeAcquireSpinLockAtDpcLevel, 1),
        IMPORT_SFUNC(KeReleaseSpinLockFromDpcLevel, 1),
        IMPORT_SFUNC_MAP(KeAcquireSpinLockRaiseToDpc, KfAcquireSpinLock, 1),
-#endif
        IMPORT_SFUNC_MAP(KeReleaseSpinLock, KfReleaseSpinLock, 1),
        IMPORT_FFUNC(InterlockedIncrement, 1),
        IMPORT_FFUNC(InterlockedDecrement, 1),
diff --git a/sys/emulation/ndis/winx32_wrap.S b/sys/emulation/ndis/winx32_wrap.S
deleted file mode 100644 (file)
index b23928c..0000000
+++ /dev/null
@@ -1,385 +0,0 @@
-/*-
- * Copyright (c) 2005
- *      Bill Paul <wpaul@windriver.com>.  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.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by Bill Paul.
- * 4. Neither the name of the author nor the names of any co-contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY Bill Paul 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 Bill Paul OR THE VOICES IN HIS HEAD
- * 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.
- *
- * $FreeBSD: src/sys/compat/ndis/winx32_wrap.S,v 1.6 2009/01/31 11:37:21 obrien Exp $
- */
-
-/* The 'ret' macro doesn't work in this file if GPROF is enabled. */
-#ifdef GPROF
-#undef GPROF
-#endif
-
-#include <machine/asmacros.h>
-
-/*
- * This file contains assembly language wrappers for the different
- * calling conventions supported by Windows on the i386 architecture.
- * In FreeBSD, the whole OS typically use same C calling convention
- * everywhere, namely _cdecl. Windows, on the other hand, uses several
- * different C calling conventions depending on the circumstances:
- *
- * _stdcall: Used for most ordinary Windows APIs. With _stdcall,
- * arguments are passed on the stack, and the callee unwinds the stack
- * before returning control to the caller. Not suitable for variadic
- * functions.
- *
- * _fastcall: Used for some APIs that may be invoked frequently and
- * where speed is a critical factor (e.g. KeAcquireSpinLock() and
- * KeReleaseSpinLock()) Similar to _stdcall, except the first 2 32-bit
- * or smaller arguments are passed in the %ecx and %edx registers
- * instead of on the stack. Not suitable for variadic functions.
- *
- * _cdecl: Used for standard C library routines and for variadic
- * functions.
- *
- * _regparm(3): Used for certain assembly routines. All arguments
- * passed in %eax, %ecx and %edx.
- *
- * Furthermore, there is an additional wrinkle that's not obvious
- * with all code: Microsoft supports the use of exceptions in C
- * (__try/__except) both in user _and_ kernel mode. Sadly, Windows
- * structured exception handling uses machine-specific features
- * that conflict rather badly with FreeBSD. (See utility routines
- * at the end of this module for more details.)
- *
- * We want to support these calling conventions in as portable a manner
- * as possible. The trick is doing it not only with different versions
- * of GNU C, but with compilers other than GNU C (e.g. the Solaris
- * SunOne C compiler). The only sure fire method is with assembly
- * language trampoline code which both fixes up the argument passing,
- * stack unwinding and exception/thread context all at once.
- *
- * You'll notice that we call the thunk/unthunk routines in the
- * *_wrap() functions in an awkward way. Rather than branching
- * directly to the address, we load the address into a register
- * first as a literal value, then we branch to it. This is done
- * to insure that the assembler doesn't translate the branch into
- * a relative branch. We use the *_wrap() routines here as templates
- * and create the actual trampolines at run time, at which point
- * we only know the absolute addresses of the thunk and unthunk
- * routines. So we need to make sure the templates have enough
- * room in them for the full address.
- *
- * Also note that when we call the a thunk/unthunk routine after
- * invoking a wrapped function, we have to make sure to preserve
- * the value returned from that function. Most functions return
- * a 32-bit value in %eax, however some routines return 64-bit
- * values, which span both %eax and %edx. Consequently, we have
- * to preserve both registers.
- */
-
-/*
- * Handle _stdcall going from Windows to UNIX.
- * This is frustrating, because to do it right you have to
- * know how many arguments the called function takes, and there's
- * no way to figure this out on the fly: you just have to be told
- * ahead of time. We assume there will be 16 arguments. I don't
- * think there are any Windows APIs that require this many.
- */
-
-       .globl x86_stdcall_wrap_call
-       .globl x86_stdcall_wrap_arg
-       .globl x86_stdcall_wrap_end
-
-ENTRY(x86_stdcall_wrap)
-       push    %esi
-       push    %edi
-       sub     $64,%esp
-       mov     %esp,%esi
-       add     $64+8+4,%esi
-       mov     %esp,%edi
-       mov     $16,%ecx        # handle up to 16 args
-       rep
-       movsl
-
-       movl    $ctxsw_wtou, %eax
-       call    *%eax           # unthunk
-
-x86_stdcall_wrap_call:
-        movl    $0,%eax
-       call    *%eax           # jump to routine
-       push    %eax            # preserve return val
-       push    %edx
-
-       movl    $ctxsw_utow, %eax
-       call    *%eax           # thunk
-
-       pop     %edx
-       pop     %eax            # restore return val
-
-       add     $64,%esp        # clean the stack
-       pop     %edi
-       pop     %esi
-x86_stdcall_wrap_arg:
-       ret     $0xFF
-x86_stdcall_wrap_end:
-
-
-/*
- * Handle _stdcall going from UNIX to Windows. This routine
- * expects to be passed the function to be called, number of
- * args and the arguments for the Windows function on the stack.
- */
-
-ENTRY(x86_stdcall_call)
-       push    %esi            # must preserve %esi
-       push    %edi            # and %edi
-
-       mov     16(%esp),%eax   # get arg cnt
-       mov     %eax,%ecx       # save as copy count
-       mov     %esp,%esi       # Set source address register to point to
-       add     $20,%esi        # first agument to be forwarded.
-       shl     $2,%eax         # turn arg cnt into offset
-       sub     %eax,%esp       # shift stack to new location
-       mov     %esp,%edi       # store dest copy addr
-       rep                     # do the copy
-       movsl
-
-       call    ctxsw_utow      # thunk
-
-       call    *12(%edi)       # branch to stdcall routine
-       push    %eax            # preserve return val
-       push    %edx
-
-       call    ctxsw_wtou      # unthunk
-
-       pop     %edx
-       pop     %eax            # restore return val
-       mov     %edi,%esp       # restore stack
-       pop     %edi            # restore %edi
-       pop     %esi            # and %esi
-       ret
-
-/*
- * Fastcall support. Similar to _stdcall, except the first
- * two arguments are passed in %ecx and %edx. It happens we
- * only support a small number of _fastcall APIs, none of them
- * take more than three arguments. So to keep the code size
- * and complexity down, we only handle 3 arguments here.
- */
-
-/* Call _fastcall function going from Windows to UNIX. */
-
-       .globl x86_fastcall_wrap_call
-       .globl x86_fastcall_wrap_arg
-       .globl x86_fastcall_wrap_end
-
-ENTRY(x86_fastcall_wrap)
-       mov     4(%esp),%eax
-       push    %eax
-       push    %edx
-       push    %ecx
-
-       movl    $ctxsw_wtou, %eax
-       call    *%eax           # unthunk
-
-x86_fastcall_wrap_call:
-       mov     $0,%eax
-       call    *%eax           # branch to fastcall routine
-       push    %eax            # preserve return val
-       push    %edx
-
-       movl    $ctxsw_utow, %eax
-       call    *%eax           # thunk
-
-       pop     %edx
-       pop     %eax            # restore return val
-       add     $12,%esp        # clean the stack
-x86_fastcall_wrap_arg:
-       ret     $0xFF
-x86_fastcall_wrap_end:
-
-/*
- * Call _fastcall function going from UNIX to Windows.
- * This routine isn't normally used since NDIS miniport drivers
- * only have _stdcall entry points, but it's provided anyway
- * to round out the API, and for testing purposes.
- */
-
-ENTRY(x86_fastcall_call)
-       mov     4(%esp),%eax
-       push    16(%esp)
-
-       call    ctxsw_utow      # thunk
-
-       mov     12(%esp),%ecx
-       mov     16(%esp),%edx
-       call    *8(%esp)        # branch to fastcall routine
-       push    %eax            # preserve return val
-       push    %edx
-
-       call    ctxsw_wtou      # unthunk
-
-       pop     %edx
-       pop     %eax            # restore return val
-       add     $4,%esp         # clean the stack
-       ret
-
-/*
- * Call regparm(3) function going from Windows to UNIX. Arguments
- * are passed in %eax, %edx and %ecx. Note that while additional
- * arguments are passed on the stack, we never bother when them,
- * since the only regparm(3) routines we need to wrap never take
- * more than 3 arguments.
- */
-
-       .globl x86_regparm_wrap_call
-       .globl x86_regparm_wrap_end
-
-ENTRY(x86_regparm_wrap)
-       push    %ecx
-       push    %edx
-       push    %eax
-
-       movl    $ctxsw_wtou, %eax
-       call    *%eax           # unthunk
-
-x86_regparm_wrap_call:
-       movl    $0,%eax
-       call    *%eax           # jump to routine
-       push    %eax            # preserve return val
-       push    %edx            # preserve return val
-
-       movl    $ctxsw_utow, %eax
-       call    *%eax           # thunk
-
-       pop     %edx            # restore return val
-       pop     %eax            # restore return val
-       add     $12,%esp        # restore stack
-       ret
-x86_regparm_wrap_end:
-
-/*
- * Call regparm(3) function going from UNIX to Windows.
- * This routine isn't normally used since NDIS miniport drivers
- * only have _stdcall entry points, but it's provided anyway
- * to round out the API, and for testing purposes.
- */
-
-ENTRY(x86_regparm_call)
-       call    ctxsw_utow      # thunk
-
-       mov     8(%esp),%eax
-       mov     12(%esp),%edx
-       mov     16(%esp),%ecx
-       call    *4(%esp)        # branch to fastcall routine
-       push    %eax            # preserve return val
-       push    %edx            # preserve return val
-
-       call    ctxsw_wtou      # unthunk
-
-       pop     %edx            # restore return val
-       pop     %eax            # restore return val
-       ret
-
-/*
- * Ugly hack alert:
- *
- * On Win32/i386, using __try/__except results in code that tries to
- * manipulate what's supposed to be the Windows Threada Environment
- * Block (TEB), which one accesses via the %fs register. In particular,
- * %fs:0 (the first DWORD in the TEB) points to the exception
- * registration list. Unfortunately, FreeBSD uses %fs for the
- * per-cpu data structure (pcpu), and we can't allow Windows code
- * to muck with that. I don't even know what Solaris uses %fs for
- * (or if it even uses it at all).
- *
- * Even worse, in 32-bit protected mode, %fs is a selector that
- * refers to an entry in either the GDT or the LDT. Ideally, we would
- * like to be able to temporarily point it at another descriptor
- * while Windows code executes, but to do that we need a separate
- * descriptor entry of our own to play with.
- *
- * Therefore, we go to some trouble to learn the existing layout of
- * the GDT and update it to include an extra entry that we can use.
- * We need the following utility routines to help us do that. On
- * FreeBSD, index #7 in the GDT happens to be unused, so we turn
- * this into our own data segment descriptor. It would be better
- * if we could use a private LDT entry, but there's no easy way to
- * do that in SMP mode because of the way FreeBSD handles user LDTs.
- *
- * Once we have a custom descriptor, we have to thunk/unthunk whenever
- * we cross between FreeBSD code and Windows code. The thunking is
- * based on the premise that when executing instructions in the
- * Windows binary itself, we won't go to sleep. This is because in
- * order to yield the CPU, the code has to call back out to a FreeBSD
- * routine first, and when that happens we can unthunk in order to
- * restore FreeBSD context. What we're desperately trying to avoid is
- * being involuntarily pre-empted with the %fs register still pointing
- * to our fake TIB: if FreeBSD code runs with %fs pointing at our
- * Windows TIB instead of pcpu, we'll panic the kernel. Fortunately,
- * the only way involuntary preemption can occur is if an interrupt
- * fires, and the trap handler saves/restores %fs for us.
- *
- * The thunking routines themselves, ctxsw_utow() (Context SWitch UNIX
- * to Windows) and ctxsw_wtou() (Context SWitch Windows to UNIX), are
- * external to this module. This is done simply because it's easier
- * to manipulate data structures in C rather than assembly.
- */
-
-ENTRY(x86_getldt)
-       movl    4(%esp),%eax
-       sgdtl   (%eax)
-       movl    8(%esp),%eax
-       sldt    (%eax)
-       xor     %eax,%eax
-       ret
-
-ENTRY(x86_setldt)
-       movl    4(%esp),%eax
-       lgdt    (%eax)
-       jmp     1f
-       nop
-1:
-       movl    8(%esp),%eax
-       lldt    %ax
-       xor     %eax,%eax
-       ret
-
-ENTRY(x86_getfs)
-       mov     %fs,%ax
-       ret
-
-ENTRY(x86_setfs)
-       mov     4(%esp),%fs
-       ret
-
-ENTRY(x86_gettid)
-       mov     %fs:12,%eax
-       ret
-
-ENTRY(x86_critical_enter)
-       cli
-       ret
-
-ENTRY(x86_critical_exit)
-       sti
-       ret
index 715b660..5802dc6 100644 (file)
@@ -184,9 +184,6 @@ bincvt(char *sysfile, char *outfile, void *img, int fsize)
                *strchr(outfile, '.') = '\0';
 
        snprintf(sysbuf, sizeof(sysbuf),
-#ifdef __i386__
-           "objcopy -I binary -O elf32-i386 -B i386 %s %s.o\n",
-#endif
 #ifdef __x86_64__
            "objcopy -I binary -O elf64-x86-64 -B i386 %s %s.o\n",
 #endif
@@ -223,9 +220,6 @@ firmcvt(char *firmfile)
        basefile = strdup(outfile);
 
        snprintf(sysbuf, sizeof(sysbuf),
-#ifdef __i386__
-           "objcopy -I binary -O elf32-i386 -B i386 %s %s.o\n",
-#endif
 #ifdef __x86_64__
            "objcopy -I binary -O elf64-x86-64 -B i386 %s %s.o\n",
 #endif
index aa90efb..81b7a13 100644 (file)
@@ -75,8 +75,8 @@ echo ""
 echo " In order to use your network device in NDIS compatibility mode,"
 echo " you need the Windows(r) driver that goes with it. Also, the driver"
 echo " must be compiled for the same architecture as the release of DragonFly"
-echo " you have installed. At this time, the i386 and x86_64 architectures"
-echo " are both supported. Note that you cannot use a Windows/i386 driver"
+echo " you have installed. At this time, the x86_64 architecture is"
+echo " supported. Note that you cannot use a Windows/i386 driver"
 echo " with DragonFly/x86_64: you must obtain a Windows/x86_64 driver."
 echo ""
 echo -n "      Press return to continue... "
@@ -266,9 +266,7 @@ if [ ! -r "$SYSPATH" ]; then
        echo "  Now you need to specify the name of the Windows(r) driver .SYS"
        echo "  file for your device. Note that if you are running DragonFly/x86_64,"
        echo "  then you must provide a driver that has been compiled for the"
-       echo "  64-bit Windows(r) platform. If a 64-bit driver is not available"
-       echo "  for your device, you must install DragonFly/i386 and use the"
-       echo "  32-bit driver instead."
+       echo "  64-bit Windows(r) platform."
        echo ""
        echo "  Please type in the path to the Windows(r) driver .SYS file now."
        echo ""