[BACK]Return to subr_ntoskrnl.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / compat / ndis

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/compat/ndis/Attic/subr_ntoskrnl.c between version 1.12 and 1.12.24.2

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;
Line 511  IoCreateDevice(
Line 485  IoCreateDevice(
                         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;
   
Line 568  IoCreateDevice(
Line 542  IoCreateDevice(
 }  }
   
 __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,
Line 819  IoAllocateIrp(
Line 778  IoAllocateIrp(
 }  }
   
 __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;
Line 2112  IoAllocateMdl(
Line 2019  IoAllocateMdl(
 }  }
   
 __stdcall void  __stdcall void
 IoFreeMdl(m)  IoFreeMdl(mdl *m)
         mdl                     *m;  
 {  {
         if (m == NULL)          if (m == NULL)
                 return;                  return;
Line 2131  IoFreeMdl(m)
Line 2037  IoFreeMdl(m)
 }  }
   
 __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);
Line 2361  atoi(str)
Line 2251  atoi(str)
 }  }
   
 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);
Line 2398  rand(void)
Line 2287  rand(void)
 }  }
   
 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__
Line 2577  KeSetEvent(
Line 2458  KeSetEvent(
 }  }
   
 __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;

Legend:
Removed from v.1.12  
changed lines
  Added in v.1.12.24.2

CVSweb <webmaster@jp.NetBSD.org>