version 1.12, 2007/12/05 08:45:30 |
version 1.12.24.2, 2009/04/28 07:35:07 |
Line 59 __KERNEL_RCSID(0, "$NetBSD$"); |
|
Line 59 __KERNEL_RCSID(0, "$NetBSD$"); |
|
#include <sys/kernel.h> |
#include <sys/kernel.h> |
#include <sys/proc.h> |
#include <sys/proc.h> |
#include <sys/kthread.h> |
#include <sys/kthread.h> |
#ifdef __FreeBSD__ |
|
#include <sys/module.h> |
#include <sys/module.h> |
#else |
|
#include <sys/lkm.h> |
|
#endif |
|
|
|
#include <sys/atomic.h> |
#include <sys/atomic.h> |
#ifdef __FreeBSD__ |
#ifdef __FreeBSD__ |
#include <machine/clock.h> |
#include <machine/clock.h> |
Line 237 static struct pool mdl_pool; |
|
Line 232 static struct pool mdl_pool; |
|
#endif |
#endif |
|
|
int |
int |
ntoskrnl_libinit() |
ntoskrnl_libinit(void) |
{ |
{ |
image_patch_table *patch; |
image_patch_table *patch; |
#ifdef __FreeBSD__ |
#ifdef __FreeBSD__ |
Line 282 ntoskrnl_libinit() |
|
Line 277 ntoskrnl_libinit() |
|
} |
} |
|
|
int |
int |
ntoskrnl_libfini() |
ntoskrnl_libfini(void) |
{ |
{ |
image_patch_table *patch; |
image_patch_table *patch; |
|
|
Line 308 ntoskrnl_libfini() |
|
Line 303 ntoskrnl_libfini() |
|
* GCC only generates a local implementation of memset. |
* GCC only generates a local implementation of memset. |
*/ |
*/ |
static void * |
static void * |
ntoskrnl_memset(buf, ch, size) |
ntoskrnl_memset(void *buf, int ch, size_t size) |
void *buf; |
|
int ch; |
|
size_t size; |
|
{ |
{ |
return(memset(buf, ch, size)); |
return(memset(buf, ch, size)); |
} |
} |
|
|
__stdcall static uint8_t |
__stdcall static uint8_t |
RtlEqualUnicodeString(str1, str2, caseinsensitive) |
RtlEqualUnicodeString(ndis_unicode_string *str1, ndis_unicode_string *str2, uint8_t caseinsensitive) |
ndis_unicode_string *str1; |
|
ndis_unicode_string *str2; |
|
uint8_t caseinsensitive; |
|
{ |
{ |
int i; |
int i; |
|
|
Line 342 RtlEqualUnicodeString(str1, str2, casein |
|
Line 331 RtlEqualUnicodeString(str1, str2, casein |
|
} |
} |
|
|
__stdcall static void |
__stdcall static void |
RtlCopyUnicodeString(dest, src) |
RtlCopyUnicodeString(ndis_unicode_string *dest, ndis_unicode_string *src) |
ndis_unicode_string *dest; |
|
ndis_unicode_string *src; |
|
{ |
{ |
|
|
if (dest->us_maxlen >= src->us_len) |
if (dest->us_maxlen >= src->us_len) |
Line 356 RtlCopyUnicodeString(dest, src) |
|
Line 343 RtlCopyUnicodeString(dest, src) |
|
} |
} |
|
|
__stdcall static ndis_status |
__stdcall static ndis_status |
RtlUnicodeStringToAnsiString(dest, src, allocate) |
RtlUnicodeStringToAnsiString(ndis_ansi_string *dest, ndis_unicode_string *src, uint8_t allocate) |
ndis_ansi_string *dest; |
|
ndis_unicode_string *src; |
|
uint8_t allocate; |
|
{ |
{ |
char *astr = NULL; |
char *astr = NULL; |
|
|
Line 382 RtlUnicodeStringToAnsiString(dest, src, |
|
Line 366 RtlUnicodeStringToAnsiString(dest, src, |
|
} |
} |
|
|
__stdcall static ndis_status |
__stdcall static ndis_status |
RtlAnsiStringToUnicodeString(dest, src, allocate) |
RtlAnsiStringToUnicodeString(ndis_unicode_string *dest, ndis_ansi_string *src, uint8_t allocate) |
ndis_unicode_string *dest; |
|
ndis_ansi_string *src; |
|
uint8_t allocate; |
|
{ |
{ |
uint16_t *ustr = NULL; |
uint16_t *ustr = NULL; |
|
|
Line 421 ExAllocatePoolWithTag( |
|
Line 402 ExAllocatePoolWithTag( |
|
} |
} |
|
|
__stdcall void |
__stdcall void |
ExFreePool(buf) |
ExFreePool(void *buf) |
void *buf; |
|
{ |
{ |
free(buf, M_DEVBUF); |
free(buf, M_DEVBUF); |
return; |
return; |
} |
} |
|
|
__stdcall uint32_t |
__stdcall uint32_t |
IoAllocateDriverObjectExtension(drv, clid, extlen, ext) |
IoAllocateDriverObjectExtension(driver_object *drv, void *clid, uint32_t extlen, void **ext) |
driver_object *drv; |
|
void *clid; |
|
uint32_t extlen; |
|
void **ext; |
|
{ |
{ |
custom_extension *ce; |
custom_extension *ce; |
|
|
Line 452 IoAllocateDriverObjectExtension(drv, cli |
|
Line 428 IoAllocateDriverObjectExtension(drv, cli |
|
} |
} |
|
|
__stdcall void * |
__stdcall void * |
IoGetDriverObjectExtension(drv, clid) |
IoGetDriverObjectExtension(driver_object *drv, void *clid) |
driver_object *drv; |
|
void *clid; |
|
{ |
{ |
list_entry *e; |
list_entry *e; |
custom_extension *ce; |
custom_extension *ce; |
|
|
return(STATUS_INSUFFICIENT_RESOURCES); |
return(STATUS_INSUFFICIENT_RESOURCES); |
} |
} |
|
|
bzero(dev->do_devext, devextlen); |
memset(dev->do_devext, 0, devextlen); |
} else |
} else |
dev->do_devext = NULL; |
dev->do_devext = NULL; |
|
|
|
|
} |
} |
|
|
__stdcall void |
__stdcall void |
IoDeleteDevice(dev) |
IoDeleteDevice(device_object *dev) |
device_object *dev; |
|
{ |
{ |
device_object *prev; |
device_object *prev; |
|
|
Line 599 IoDeleteDevice(dev) |
|
Line 572 IoDeleteDevice(dev) |
|
} |
} |
|
|
__stdcall device_object * |
__stdcall device_object * |
IoGetAttachedDevice(dev) |
IoGetAttachedDevice(device_object *dev) |
device_object *dev; |
|
{ |
{ |
device_object *d; |
device_object *d; |
|
|
Line 616 IoGetAttachedDevice(dev) |
|
Line 588 IoGetAttachedDevice(dev) |
|
} |
} |
|
|
__stdcall static irp * |
__stdcall static irp * |
IoBuildSynchronousFsdRequest(func, dobj, buf, len, off, event, status) |
IoBuildSynchronousFsdRequest(uint32_t func, device_object *dobj, void *buf, uint32_t len, uint64_t *off, nt_kevent *event, io_status_block *status) |
uint32_t func; |
|
device_object *dobj; |
|
void *buf; |
|
uint32_t len; |
|
uint64_t *off; |
|
nt_kevent *event; |
|
io_status_block *status; |
|
{ |
{ |
irp *ip; |
irp *ip; |
|
|
Line 636 IoBuildSynchronousFsdRequest(func, dobj, |
|
Line 601 IoBuildSynchronousFsdRequest(func, dobj, |
|
} |
} |
|
|
__stdcall static irp * |
__stdcall static irp * |
IoBuildAsynchronousFsdRequest(func, dobj, buf, len, off, status) |
IoBuildAsynchronousFsdRequest(uint32_t func, device_object *dobj, void *buf, uint32_t len, uint64_t *off, io_status_block *status) |
uint32_t func; |
|
device_object *dobj; |
|
void *buf; |
|
uint32_t len; |
|
uint64_t *off; |
|
io_status_block *status; |
|
{ |
{ |
irp *ip; |
irp *ip; |
io_stack_location *sl; |
io_stack_location *sl; |
Line 672 IoBuildAsynchronousFsdRequest(func, dobj |
|
Line 631 IoBuildAsynchronousFsdRequest(func, dobj |
|
IoFreeIrp(ip); |
IoFreeIrp(ip); |
return(NULL); |
return(NULL); |
} |
} |
bcopy(buf, ip->irp_assoc.irp_sysbuf, len); |
memcpy( ip->irp_assoc.irp_sysbuf, buf, len); |
} |
} |
|
|
if (dobj->do_flags & DO_DIRECT_IO) { |
if (dobj->do_flags & DO_DIRECT_IO) { |
Line 758 IoBuildDeviceIoControlRequest(iocode, do |
|
Line 717 IoBuildDeviceIoControlRequest(iocode, do |
|
} |
} |
} |
} |
if (ilen && ibuf != NULL) { |
if (ilen && ibuf != NULL) { |
bcopy(ibuf, ip->irp_assoc.irp_sysbuf, ilen); |
memcpy( ip->irp_assoc.irp_sysbuf, ibuf, ilen); |
bzero((char *)ip->irp_assoc.irp_sysbuf + ilen, |
memset((char *)ip->irp_assoc.irp_sysbuf + ilen, 0, |
buflen - ilen); |
buflen - ilen); |
} else |
} else |
bzero(ip->irp_assoc.irp_sysbuf, ilen); |
memset(ip->irp_assoc.irp_sysbuf, 0, ilen); |
ip->irp_userbuf = obuf; |
ip->irp_userbuf = obuf; |
break; |
break; |
case METHOD_IN_DIRECT: |
case METHOD_IN_DIRECT: |
Line 774 IoBuildDeviceIoControlRequest(iocode, do |
|
Line 733 IoBuildDeviceIoControlRequest(iocode, do |
|
IoFreeIrp(ip); |
IoFreeIrp(ip); |
return(NULL); |
return(NULL); |
} |
} |
bcopy(ibuf, ip->irp_assoc.irp_sysbuf, ilen); |
memcpy( ip->irp_assoc.irp_sysbuf, ibuf, ilen); |
} |
} |
if (olen && obuf != NULL) { |
if (olen && obuf != NULL) { |
ip->irp_mdl = IoAllocateMdl(obuf, olen, |
ip->irp_mdl = IoAllocateMdl(obuf, olen, |
|
|
} |
} |
|
|
__stdcall static irp * |
__stdcall static irp * |
IoMakeAssociatedIrp(ip, stsize) |
IoMakeAssociatedIrp(irp *ip, uint8_t stsize) |
irp *ip; |
|
uint8_t stsize; |
|
{ |
{ |
irp *associrp; |
irp *associrp; |
#ifdef __NetBSD__ |
#ifdef __NetBSD__ |
Line 853 IoMakeAssociatedIrp(ip, stsize) |
|
Line 810 IoMakeAssociatedIrp(ip, stsize) |
|
} |
} |
|
|
__stdcall static void |
__stdcall static void |
IoFreeIrp(ip) |
IoFreeIrp(irp *ip) |
irp *ip; |
|
{ |
{ |
ExFreePool(ip); |
ExFreePool(ip); |
return; |
return; |
} |
} |
|
|
__stdcall static void |
__stdcall static void |
IoInitializeIrp(io, psize, ssize) |
IoInitializeIrp(irp *io, uint16_t psize, uint8_t ssize) |
irp *io; |
|
uint16_t psize; |
|
uint8_t ssize; |
|
{ |
{ |
bzero((char *)io, IoSizeOfIrp(ssize)); |
memset((char *)io, 0, IoSizeOfIrp(ssize)); |
io->irp_size = psize; |
io->irp_size = psize; |
io->irp_stackcnt = ssize; |
io->irp_stackcnt = ssize; |
io->irp_currentstackloc = ssize; |
io->irp_currentstackloc = ssize; |
Line 878 IoInitializeIrp(io, psize, ssize) |
|
Line 831 IoInitializeIrp(io, psize, ssize) |
|
} |
} |
|
|
__stdcall static void |
__stdcall static void |
IoReuseIrp(ip, status) |
IoReuseIrp(irp *ip, uint32_t status) |
irp *ip; |
|
uint32_t status; |
|
{ |
{ |
uint8_t allocflags; |
uint8_t allocflags; |
|
|
Line 893 IoReuseIrp(ip, status) |
|
Line 844 IoReuseIrp(ip, status) |
|
} |
} |
|
|
__stdcall void |
__stdcall void |
IoAcquireCancelSpinLock(irql) |
IoAcquireCancelSpinLock(uint8_t *irql) |
uint8_t *irql; |
|
{ |
{ |
KeAcquireSpinLock(&ntoskrnl_cancellock, irql); |
KeAcquireSpinLock(&ntoskrnl_cancellock, irql); |
return; |
return; |
} |
} |
|
|
__stdcall void |
__stdcall void |
IoReleaseCancelSpinLock(irql) |
IoReleaseCancelSpinLock(uint8_t irql) |
uint8_t irql; |
|
{ |
{ |
KeReleaseSpinLock(&ntoskrnl_cancellock, irql); |
KeReleaseSpinLock(&ntoskrnl_cancellock, irql); |
return; |
return; |
Line 1025 IofCompleteRequest(REGARGS2(irp *ip, uin |
|
Line 974 IofCompleteRequest(REGARGS2(irp *ip, uin |
|
} |
} |
|
|
__stdcall device_object * |
__stdcall device_object * |
IoAttachDeviceToDeviceStack(src, dst) |
IoAttachDeviceToDeviceStack(device_object *src, device_object *dst) |
device_object *src; |
|
device_object *dst; |
|
{ |
{ |
device_object *attached; |
device_object *attached; |
#ifdef __NetBSD__ |
#ifdef __NetBSD__ |
Line 1055 IoAttachDeviceToDeviceStack(src, dst) |
|
Line 1002 IoAttachDeviceToDeviceStack(src, dst) |
|
} |
} |
|
|
__stdcall void |
__stdcall void |
IoDetachDevice(topdev) |
IoDetachDevice(device_object *topdev) |
device_object *topdev; |
|
{ |
{ |
device_object *tail; |
device_object *tail; |
#ifdef __NetBSD__ |
#ifdef __NetBSD__ |
Line 1101 IoDetachDevice(topdev) |
|
Line 1047 IoDetachDevice(topdev) |
|
|
|
/* Always called with dispatcher lock held. */ |
/* Always called with dispatcher lock held. */ |
static void |
static void |
ntoskrnl_wakeup(arg) |
ntoskrnl_wakeup(void *arg) |
void *arg; |
|
{ |
{ |
nt_dispatch_header *obj; |
nt_dispatch_header *obj; |
wait_block *w; |
wait_block *w; |
Line 1137 ntoskrnl_wakeup(arg) |
|
Line 1082 ntoskrnl_wakeup(arg) |
|
} |
} |
|
|
static void |
static void |
ntoskrnl_time(tval) |
ntoskrnl_time(uint64_t *tval) |
uint64_t *tval; |
|
{ |
{ |
struct timespec ts; |
struct timespec ts; |
#ifdef __NetBSD__ |
#ifdef __NetBSD__ |
Line 1570 KeWaitForMultipleObjects( |
|
Line 1514 KeWaitForMultipleObjects( |
|
} |
} |
|
|
__stdcall static void |
__stdcall static void |
WRITE_REGISTER_USHORT(reg, val) |
WRITE_REGISTER_USHORT(uint16_t *reg, uint16_t val) |
uint16_t *reg; |
|
uint16_t val; |
|
{ |
{ |
bus_space_write_2(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg, val); |
bus_space_write_2(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg, val); |
return; |
return; |
} |
} |
|
|
__stdcall static uint16_t |
__stdcall static uint16_t |
READ_REGISTER_USHORT(reg) |
READ_REGISTER_USHORT(uint16_t *reg) |
uint16_t *reg; |
|
{ |
{ |
return(bus_space_read_2(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg)); |
return(bus_space_read_2(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg)); |
} |
} |
|
|
__stdcall static void |
__stdcall static void |
WRITE_REGISTER_ULONG(reg, val) |
WRITE_REGISTER_ULONG(uint32_t *reg, uint32_t val) |
uint32_t *reg; |
|
uint32_t val; |
|
{ |
{ |
bus_space_write_4(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg, val); |
bus_space_write_4(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg, val); |
return; |
return; |
} |
} |
|
|
__stdcall static uint32_t |
__stdcall static uint32_t |
READ_REGISTER_ULONG(reg) |
READ_REGISTER_ULONG(uint32_t *reg) |
uint32_t *reg; |
|
{ |
{ |
return(bus_space_read_4(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg)); |
return(bus_space_read_4(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg)); |
} |
} |
|
|
__stdcall static uint8_t |
__stdcall static uint8_t |
READ_REGISTER_UCHAR(reg) |
READ_REGISTER_UCHAR(uint8_t *reg) |
uint8_t *reg; |
|
{ |
{ |
return(bus_space_read_1(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg)); |
return(bus_space_read_1(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg)); |
} |
} |
|
|
__stdcall static void |
__stdcall static void |
WRITE_REGISTER_UCHAR(reg, val) |
WRITE_REGISTER_UCHAR(uint8_t *reg, uint8_t val) |
uint8_t *reg; |
|
uint8_t val; |
|
{ |
{ |
bus_space_write_1(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg, val); |
bus_space_write_1(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg, val); |
return; |
return; |
} |
} |
|
|
__stdcall static int64_t |
__stdcall static int64_t |
_allmul(a, b) |
_allmul(int64_t a, int64_t b) |
int64_t a; |
|
int64_t b; |
|
{ |
{ |
return (a * b); |
return (a * b); |
} |
} |
|
|
__stdcall static int64_t |
__stdcall static int64_t |
_alldiv(a, b) |
_alldiv(int64_t a, int64_t b) |
int64_t a; |
|
int64_t b; |
|
{ |
{ |
return (a / b); |
return (a / b); |
} |
} |
|
|
__stdcall static int64_t |
__stdcall static int64_t |
_allrem(a, b) |
_allrem(int64_t a, int64_t b) |
int64_t a; |
|
int64_t b; |
|
{ |
{ |
return (a % b); |
return (a % b); |
} |
} |
|
|
__stdcall static uint64_t |
__stdcall static uint64_t |
_aullmul(a, b) |
_aullmul(uint64_t a, uint64_t b) |
uint64_t a; |
|
uint64_t b; |
|
{ |
{ |
return (a * b); |
return (a * b); |
} |
} |
|
|
__stdcall static uint64_t |
__stdcall static uint64_t |
_aulldiv(a, b) |
_aulldiv(uint64_t a, uint64_t b) |
uint64_t a; |
|
uint64_t b; |
|
{ |
{ |
return (a / b); |
return (a / b); |
} |
} |
|
|
__stdcall static uint64_t |
__stdcall static uint64_t |
_aullrem(a, b) |
_aullrem(uint64_t a, uint64_t b) |
uint64_t a; |
|
uint64_t b; |
|
{ |
{ |
return (a % b); |
return (a % b); |
} |
} |
|
|
__regparm static int64_t |
__regparm static int64_t |
_allshl(a, b) |
_allshl(int64_t a, uint8_t b) |
int64_t a; |
|
uint8_t b; |
|
{ |
{ |
return (a << b); |
return (a << b); |
} |
} |
|
|
__regparm static uint64_t |
__regparm static uint64_t |
_aullshl(a, b) |
_aullshl(uint64_t a, uint8_t b) |
uint64_t a; |
|
uint8_t b; |
|
{ |
{ |
return (a << b); |
return (a << b); |
} |
} |
|
|
__regparm static int64_t |
__regparm static int64_t |
_allshr(a, b) |
_allshr(int64_t a, uint8_t b) |
int64_t a; |
|
uint8_t b; |
|
{ |
{ |
return (a >> b); |
return (a >> b); |
} |
} |
|
|
__regparm static uint64_t |
__regparm static uint64_t |
_aullshr(a, b) |
_aullshr(uint64_t a, uint8_t b) |
uint64_t a; |
|
uint8_t b; |
|
{ |
{ |
return (a >> b); |
return (a >> b); |
} |
} |
|
|
static slist_entry * |
static slist_entry * |
ntoskrnl_pushsl(head, entry) |
ntoskrnl_pushsl(slist_header *head, slist_entry *entry) |
slist_header *head; |
|
slist_entry *entry; |
|
{ |
{ |
slist_entry *oldhead; |
slist_entry *oldhead; |
|
|
Line 1714 ntoskrnl_pushsl(head, entry) |
|
Line 1627 ntoskrnl_pushsl(head, entry) |
|
} |
} |
|
|
static slist_entry * |
static slist_entry * |
ntoskrnl_popsl(head) |
ntoskrnl_popsl(slist_header *head) |
slist_header *head; |
|
{ |
{ |
slist_entry *first; |
slist_entry *first; |
|
|
Line 1741 ntoskrnl_popsl(head) |
|
Line 1653 ntoskrnl_popsl(head) |
|
*/ |
*/ |
|
|
static funcptr |
static funcptr |
ntoskrnl_findwrap(func) |
ntoskrnl_findwrap(funcptr func) |
funcptr func; |
|
{ |
{ |
image_patch_table *patch; |
image_patch_table *patch; |
|
|
Line 1766 ExInitializePagedLookasideList( |
|
Line 1677 ExInitializePagedLookasideList( |
|
uint32_t tag, |
uint32_t tag, |
uint16_t depth) |
uint16_t depth) |
{ |
{ |
bzero((char *)lookaside, sizeof(paged_lookaside_list)); |
memset((char *)lookaside, 0, sizeof(paged_lookaside_list)); |
|
|
if (size < sizeof(slist_entry)) |
if (size < sizeof(slist_entry)) |
lookaside->nll_l.gl_size = sizeof(slist_entry); |
lookaside->nll_l.gl_size = sizeof(slist_entry); |
Line 1797 ExInitializePagedLookasideList( |
|
Line 1708 ExInitializePagedLookasideList( |
|
} |
} |
|
|
__stdcall static void |
__stdcall static void |
ExDeletePagedLookasideList(lookaside) |
ExDeletePagedLookasideList(paged_lookaside_list *lookaside) |
paged_lookaside_list *lookaside; |
|
{ |
{ |
void *buf; |
void *buf; |
__stdcall void (*freefunc)(void *); |
__stdcall void (*freefunc)(void *); |
Line 1820 ExInitializeNPagedLookasideList( |
|
Line 1730 ExInitializeNPagedLookasideList( |
|
uint32_t tag, |
uint32_t tag, |
uint16_t depth) |
uint16_t depth) |
{ |
{ |
bzero((char *)lookaside, sizeof(npaged_lookaside_list)); |
memset((char *)lookaside, 0, sizeof(npaged_lookaside_list)); |
|
|
if (size < sizeof(slist_entry)) |
if (size < sizeof(slist_entry)) |
lookaside->nll_l.gl_size = sizeof(slist_entry); |
lookaside->nll_l.gl_size = sizeof(slist_entry); |
Line 1851 ExInitializeNPagedLookasideList( |
|
Line 1761 ExInitializeNPagedLookasideList( |
|
} |
} |
|
|
__stdcall static void |
__stdcall static void |
ExDeleteNPagedLookasideList(lookaside) |
ExDeleteNPagedLookasideList(npaged_lookaside_list *lookaside) |
npaged_lookaside_list *lookaside; |
|
{ |
{ |
void *buf; |
void *buf; |
__stdcall void (*freefunc)(void *); |
__stdcall void (*freefunc)(void *); |
Line 1922 ExInterlockedPopEntrySList(REGARGS2(slis |
|
Line 1831 ExInterlockedPopEntrySList(REGARGS2(slis |
|
} |
} |
|
|
__stdcall static uint16_t |
__stdcall static uint16_t |
ExQueryDepthSList(head) |
ExQueryDepthSList(slist_header *head) |
slist_header *head; |
|
{ |
{ |
uint16_t depth; |
uint16_t depth; |
uint8_t irql; |
uint8_t irql; |
Line 1948 ExQueryDepthSList(head) |
|
Line 1856 ExQueryDepthSList(head) |
|
* function. Instead, we grab a mutex from the mutex pool. |
* function. Instead, we grab a mutex from the mutex pool. |
*/ |
*/ |
__stdcall void |
__stdcall void |
KeInitializeSpinLock(lock) |
KeInitializeSpinLock(kspin_lock *lock) |
kspin_lock *lock; |
|
{ |
{ |
#ifdef __FreeBSD__ |
#ifdef __FreeBSD__ |
*lock = 0; |
*lock = 0; |
|
|
} |
} |
|
|
__stdcall void |
__stdcall void |
IoFreeMdl(m) |
IoFreeMdl(mdl *m) |
mdl *m; |
|
{ |
{ |
if (m == NULL) |
if (m == NULL) |
return; |
return; |
|
|
} |
} |
|
|
__stdcall static uint32_t |
__stdcall static uint32_t |
MmSizeOfMdl(vaddr, len) |
MmSizeOfMdl(void *vaddr, size_t len) |
void *vaddr; |
|
size_t len; |
|
{ |
{ |
uint32_t l; |
uint32_t l; |
|
|
Line 2151 MmSizeOfMdl(vaddr, len) |
|
Line 2055 MmSizeOfMdl(vaddr, len) |
|
* addresses of the buffers. |
* addresses of the buffers. |
*/ |
*/ |
__stdcall static void |
__stdcall static void |
MmBuildMdlForNonPagedPool(m) |
MmBuildMdlForNonPagedPool(mdl *m) |
mdl *m; |
|
{ |
{ |
vm_offset_t *mdl_pages; |
vm_offset_t *mdl_pages; |
int pagecnt, i; |
int pagecnt, i; |
Line 2204 MmUnmapLockedPages( |
|
Line 2107 MmUnmapLockedPages( |
|
} |
} |
|
|
__stdcall static size_t |
__stdcall static size_t |
RtlCompareMemory(s1, s2, len) |
RtlCompareMemory(const void *s1, const void *s2, size_t len) |
const void *s1; |
|
const void *s2; |
|
size_t len; |
|
{ |
{ |
size_t i, total = 0; |
size_t i, total = 0; |
uint8_t *m1, *m2; |
uint8_t *m1, *m2; |
Line 2223 RtlCompareMemory(s1, s2, len) |
|
Line 2123 RtlCompareMemory(s1, s2, len) |
|
} |
} |
|
|
__stdcall static void |
__stdcall static void |
RtlInitAnsiString(dst, src) |
RtlInitAnsiString(ndis_ansi_string *dst, char *src) |
ndis_ansi_string *dst; |
|
char *src; |
|
{ |
{ |
ndis_ansi_string *a; |
ndis_ansi_string *a; |
|
|
Line 2244 RtlInitAnsiString(dst, src) |
|
Line 2142 RtlInitAnsiString(dst, src) |
|
} |
} |
|
|
__stdcall static void |
__stdcall static void |
RtlInitUnicodeString(dst, src) |
RtlInitUnicodeString(ndis_unicode_string *dst, uint16_t *src) |
ndis_unicode_string *dst; |
|
uint16_t *src; |
|
{ |
{ |
ndis_unicode_string *u; |
ndis_unicode_string *u; |
int i; |
int i; |
Line 2269 RtlInitUnicodeString(dst, src) |
|
Line 2165 RtlInitUnicodeString(dst, src) |
|
} |
} |
|
|
__stdcall ndis_status |
__stdcall ndis_status |
RtlUnicodeStringToInteger(ustr, base, val) |
RtlUnicodeStringToInteger(ndis_unicode_string *ustr, uint32_t base, uint32_t *val) |
ndis_unicode_string *ustr; |
|
uint32_t base; |
|
uint32_t *val; |
|
{ |
{ |
uint16_t *uchr; |
uint16_t *uchr; |
int len, neg = 0; |
int len, neg = 0; |
Line 2281 RtlUnicodeStringToInteger(ustr, base, va |
|
Line 2174 RtlUnicodeStringToInteger(ustr, base, va |
|
|
|
uchr = ustr->us_buf; |
uchr = ustr->us_buf; |
len = ustr->us_len; |
len = ustr->us_len; |
bzero(abuf, sizeof(abuf)); |
memset(abuf, 0, sizeof(abuf)); |
|
|
if ((char)((*uchr) & 0xFF) == '-') { |
if ((char)((*uchr) & 0xFF) == '-') { |
neg = 1; |
neg = 1; |
Line 2323 RtlUnicodeStringToInteger(ustr, base, va |
|
Line 2216 RtlUnicodeStringToInteger(ustr, base, va |
|
} |
} |
|
|
__stdcall static void |
__stdcall static void |
RtlFreeUnicodeString(ustr) |
RtlFreeUnicodeString(ndis_unicode_string *ustr) |
ndis_unicode_string *ustr; |
|
{ |
{ |
if (ustr->us_buf == NULL) |
if (ustr->us_buf == NULL) |
return; |
return; |
Line 2334 RtlFreeUnicodeString(ustr) |
|
Line 2226 RtlFreeUnicodeString(ustr) |
|
} |
} |
|
|
__stdcall static void |
__stdcall static void |
RtlFreeAnsiString(astr) |
RtlFreeAnsiString(ndis_ansi_string *astr) |
ndis_ansi_string *astr; |
|
{ |
{ |
if (astr->nas_buf == NULL) |
if (astr->nas_buf == NULL) |
return; |
return; |
Line 2345 RtlFreeAnsiString(astr) |
|
Line 2236 RtlFreeAnsiString(astr) |
|
} |
} |
|
|
static int |
static int |
atoi(str) |
atoi(const char *str) |
const char *str; |
|
{ |
{ |
#ifdef __FreeBSD__ |
#ifdef __FreeBSD__ |
return (int)strtol(str, (char **)NULL, 10); |
return (int)strtol(str, (char **)NULL, 10); |
|
|
} |
} |
|
|
static long |
static long |
atol(str) |
atol(const char *str) |
const char *str; |
|
{ |
{ |
#ifdef __FreeBSD__ |
#ifdef __FreeBSD__ |
return strtol(str, (char **)NULL, 10); |
return strtol(str, (char **)NULL, 10); |
|
|
} |
} |
|
|
static void |
static void |
srand(seed) |
srand(unsigned int seed) |
unsigned int seed; |
|
{ |
{ |
srandom(seed); |
srandom(seed); |
return; |
return; |
} |
} |
|
|
__stdcall static uint8_t |
__stdcall static uint8_t |
IoIsWdmVersionAvailable(major, minor) |
IoIsWdmVersionAvailable(uint8_t major, uint8_t minor) |
uint8_t major; |
|
uint8_t minor; |
|
{ |
{ |
if (major == WDM_MAJOR && minor == WDM_MINOR_WINXP) |
if (major == WDM_MAJOR && minor == WDM_MINOR_WINXP) |
return(TRUE); |
return(TRUE); |
Line 2501 KeReleaseMutex( |
|
Line 2387 KeReleaseMutex( |
|
} |
} |
|
|
__stdcall static uint32_t |
__stdcall static uint32_t |
KeReadStateMutex(kmutex) |
KeReadStateMutex(kmutant *kmutex) |
kmutant *kmutex; |
|
{ |
{ |
return(kmutex->km_header.dh_sigstate); |
return(kmutex->km_header.dh_sigstate); |
} |
} |
|
|
__stdcall void |
__stdcall void |
KeInitializeEvent(kevent, type, state) |
KeInitializeEvent(nt_kevent *kevent, uint32_t type, uint8_t state) |
nt_kevent *kevent; |
|
uint32_t type; |
|
uint8_t state; |
|
{ |
{ |
INIT_LIST_HEAD((&kevent->k_header.dh_waitlisthead)); |
INIT_LIST_HEAD((&kevent->k_header.dh_waitlisthead)); |
kevent->k_header.dh_sigstate = state; |
kevent->k_header.dh_sigstate = state; |
Line 2521 KeInitializeEvent(kevent, type, state) |
|
Line 2403 KeInitializeEvent(kevent, type, state) |
|
} |
} |
|
|
__stdcall uint32_t |
__stdcall uint32_t |
KeResetEvent(kevent) |
KeResetEvent(nt_kevent *kevent) |
nt_kevent *kevent; |
|
{ |
{ |
uint32_t prevstate; |
uint32_t prevstate; |
#ifdef __NetBSD__ |
#ifdef __NetBSD__ |
|
|
} |
} |
|
|
__stdcall void |
__stdcall void |
KeClearEvent(kevent) |
KeClearEvent(nt_kevent *kevent) |
nt_kevent *kevent; |
|
{ |
{ |
kevent->k_header.dh_sigstate = FALSE; |
kevent->k_header.dh_sigstate = FALSE; |
return; |
return; |
} |
} |
|
|
__stdcall uint32_t |
__stdcall uint32_t |
KeReadStateEvent(kevent) |
KeReadStateEvent(nt_kevent *kevent) |
nt_kevent *kevent; |
|
{ |
{ |
return(kevent->k_header.dh_sigstate); |
return(kevent->k_header.dh_sigstate); |
} |
} |
Line 2638 ZwClose(ndis_handle handle) |
|
Line 2517 ZwClose(ndis_handle handle) |
|
* PsTerminateSystemThread(). |
* PsTerminateSystemThread(). |
*/ |
*/ |
static void |
static void |
ntoskrnl_thrfunc(arg) |
ntoskrnl_thrfunc(void *arg) |
void *arg; |
|
{ |
{ |
thread_context *thrctx; |
thread_context *thrctx; |
__stdcall uint32_t (*tfunc)(void *); |
__stdcall uint32_t (*tfunc)(void *); |
Line 2770 DbgBreakPoint(void) |
|
Line 2648 DbgBreakPoint(void) |
|
} |
} |
|
|
static void |
static void |
ntoskrnl_timercall(arg) |
ntoskrnl_timercall(void *arg) |
void *arg; |
|
{ |
{ |
ktimer *timer; |
ktimer *timer; |
struct timeval tv; |
struct timeval tv; |
Line 2833 ntoskrnl_timercall(arg) |
|
Line 2710 ntoskrnl_timercall(arg) |
|
} |
} |
|
|
__stdcall void |
__stdcall void |
KeInitializeTimer(timer) |
KeInitializeTimer(ktimer *timer) |
ktimer *timer; |
|
{ |
{ |
if (timer == NULL) |
if (timer == NULL) |
return; |
return; |
Line 2845 KeInitializeTimer(timer) |
|
Line 2721 KeInitializeTimer(timer) |
|
} |
} |
|
|
__stdcall void |
__stdcall void |
KeInitializeTimerEx(timer, type) |
KeInitializeTimerEx(ktimer *timer, uint32_t type) |
ktimer *timer; |
|
uint32_t type; |
|
{ |
{ |
if (timer == NULL) |
if (timer == NULL) |
return; |
return; |
Line 2873 KeInitializeTimerEx(timer, type) |
|
Line 2747 KeInitializeTimerEx(timer, type) |
|
* I can tell, defered procedure calls must run at DISPATCH_LEVEL. |
* I can tell, defered procedure calls must run at DISPATCH_LEVEL. |
*/ |
*/ |
static void |
static void |
ntoskrnl_run_dpc(arg) |
ntoskrnl_run_dpc(void *arg) |
void *arg; |
|
{ |
{ |
__stdcall kdpc_func dpcfunc; |
__stdcall kdpc_func dpcfunc; |
kdpc *dpc; |
kdpc *dpc; |
Line 2891 ntoskrnl_run_dpc(arg) |
|
Line 2764 ntoskrnl_run_dpc(arg) |
|
} |
} |
|
|
__stdcall void |
__stdcall void |
KeInitializeDpc(dpc, dpcfunc, dpcctx) |
KeInitializeDpc(kdpc *dpc, void *dpcfunc, void *dpcctx) |
kdpc *dpc; |
|
void *dpcfunc; |
|
void *dpcctx; |
|
{ |
{ |
|
|
if (dpc == NULL) |
if (dpc == NULL) |
Line 2907 KeInitializeDpc(dpc, dpcfunc, dpcctx) |
|
Line 2777 KeInitializeDpc(dpc, dpcfunc, dpcctx) |
|
} |
} |
|
|
__stdcall uint8_t |
__stdcall uint8_t |
KeInsertQueueDpc(dpc, sysarg1, sysarg2) |
KeInsertQueueDpc(kdpc *dpc, void *sysarg1, void *sysarg2) |
kdpc *dpc; |
|
void *sysarg1; |
|
void *sysarg2; |
|
{ |
{ |
dpc->k_sysarg1 = sysarg1; |
dpc->k_sysarg1 = sysarg1; |
dpc->k_sysarg2 = sysarg2; |
dpc->k_sysarg2 = sysarg2; |
Line 2922 KeInsertQueueDpc(dpc, sysarg1, sysarg2) |
|
Line 2789 KeInsertQueueDpc(dpc, sysarg1, sysarg2) |
|
} |
} |
|
|
__stdcall uint8_t |
__stdcall uint8_t |
KeRemoveQueueDpc(dpc) |
KeRemoveQueueDpc(kdpc *dpc) |
kdpc *dpc; |
|
{ |
{ |
if (ndis_unsched(ntoskrnl_run_dpc, dpc, NDIS_SWI)) |
if (ndis_unsched(ntoskrnl_run_dpc, dpc, NDIS_SWI)) |
return(FALSE); |
return(FALSE); |
Line 2932 KeRemoveQueueDpc(dpc) |
|
Line 2798 KeRemoveQueueDpc(dpc) |
|
} |
} |
|
|
__stdcall uint8_t |
__stdcall uint8_t |
KeSetTimerEx(timer, duetime, period, dpc) |
KeSetTimerEx(ktimer *timer, int64_t duetime, uint32_t period, kdpc *dpc) |
ktimer *timer; |
|
int64_t duetime; |
|
uint32_t period; |
|
kdpc *dpc; |
|
{ |
{ |
struct timeval tv; |
struct timeval tv; |
uint64_t curtime; |
uint64_t curtime; |
Line 3002 KeSetTimerEx(timer, duetime, period, dpc |
|
Line 2864 KeSetTimerEx(timer, duetime, period, dpc |
|
} |
} |
|
|
__stdcall uint8_t |
__stdcall uint8_t |
KeSetTimer(timer, duetime, dpc) |
KeSetTimer(ktimer *timer, int64_t duetime, kdpc *dpc) |
ktimer *timer; |
|
int64_t duetime; |
|
kdpc *dpc; |
|
{ |
{ |
return (KeSetTimerEx(timer, duetime, 0, dpc)); |
return (KeSetTimerEx(timer, duetime, 0, dpc)); |
} |
} |
|
|
__stdcall uint8_t |
__stdcall uint8_t |
KeCancelTimer(timer) |
KeCancelTimer(ktimer *timer) |
ktimer *timer; |
|
{ |
{ |
uint8_t pending; |
uint8_t pending; |
#ifdef __NetBSD__ |
#ifdef __NetBSD__ |
Line 3048 KeCancelTimer(timer) |
|
Line 2906 KeCancelTimer(timer) |
|
} |
} |
|
|
__stdcall uint8_t |
__stdcall uint8_t |
KeReadStateTimer(timer) |
KeReadStateTimer(ktimer *timer) |
ktimer *timer; |
|
{ |
{ |
return(timer->k_header.dh_sigstate); |
return(timer->k_header.dh_sigstate); |
} |
} |
|
|
__stdcall static void |
__stdcall static void |
dummy() |
dummy(void) |
{ |
{ |
printf ("ntoskrnl dummy called...\n"); |
printf ("ntoskrnl dummy called...\n"); |
return; |
return; |