3 * Bill Paul <wpaul@windriver.com>. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by Bill Paul.
16 * 4. Neither the name of the author nor the names of any co-contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
30 * THE POSSIBILITY OF SUCH DAMAGE.
32 * $FreeBSD: src/sys/compat/ndis/subr_ntoskrnl.c,v 1.40 2004/07/20 20:28:57 wpaul Exp $
33 * $DragonFly: src/sys/emulation/ndis/subr_ntoskrnl.c,v 1.13 2006/12/23 00:27:02 swildner Exp $
36 #include <sys/ctype.h>
37 #include <sys/unistd.h>
38 #include <sys/param.h>
39 #include <sys/types.h>
40 #include <sys/errno.h>
41 #include <sys/systm.h>
42 #include <sys/malloc.h>
45 #include <sys/callout.h>
46 #if __FreeBSD_version > 502113
49 #include <sys/kernel.h>
51 #include <sys/kthread.h>
55 #include <sys/mplock2.h>
57 #include <machine/atomic.h>
58 #include <machine/clock.h>
59 #include <machine/stdarg.h>
63 #include "resource_var.h"
64 #include "ntoskrnl_var.h"
68 #define __regparm __attribute__((regparm(3)))
70 #define FUNC void(*)(void)
72 __stdcall static uint8_t ntoskrnl_unicode_equal(ndis_unicode_string *,
73 ndis_unicode_string *, uint8_t);
74 __stdcall static void ntoskrnl_unicode_copy(ndis_unicode_string *,
75 ndis_unicode_string *);
76 __stdcall static ndis_status ntoskrnl_unicode_to_ansi(ndis_ansi_string *,
77 ndis_unicode_string *, uint8_t);
78 __stdcall static ndis_status ntoskrnl_ansi_to_unicode(ndis_unicode_string *,
79 ndis_ansi_string *, uint8_t);
80 __stdcall static void *ntoskrnl_iobuildsynchfsdreq(uint32_t, void *,
81 void *, uint32_t, uint32_t *, void *, void *);
86 __stdcall __regcall static uint32_t
87 ntoskrnl_iofcalldriver(REGARGS2(void *dobj, void *irp));
88 __stdcall __regcall static void
89 ntoskrnl_iofcompletereq(REGARGS2(void *irp, uint8_t prioboost));
90 __stdcall __regcall static slist_entry *
91 ntoskrnl_push_slist(REGARGS2(slist_header *head, slist_entry *entry));
92 __stdcall __regcall static slist_entry *
93 ntoskrnl_pop_slist(REGARGS1(slist_header *head));
94 __stdcall __regcall static slist_entry *
95 ntoskrnl_push_slist_ex(REGARGS2(slist_header *head, slist_entry *entry), kspin_lock *lock);
96 __stdcall __regcall static slist_entry *
97 ntoskrnl_pop_slist_ex(REGARGS2(slist_header *head, kspin_lock *lock));
99 __stdcall __regcall static uint32_t
100 ntoskrnl_interlock_inc(REGARGS1(volatile uint32_t *addend));
101 __stdcall __regcall static uint32_t
102 ntoskrnl_interlock_dec(REGARGS1(volatile uint32_t *addend));
103 __stdcall __regcall static void
104 ntoskrnl_interlock_addstat(REGARGS2(uint64_t *addend, uint32_t inc));
105 __stdcall __regcall static void
106 ntoskrnl_objderef(REGARGS1(void *object));
108 __stdcall static uint32_t ntoskrnl_waitforobjs(uint32_t,
109 nt_dispatch_header **, uint32_t, uint32_t, uint32_t, uint8_t,
110 int64_t *, wait_block *);
111 static void ntoskrnl_wakeup(void *);
112 static void ntoskrnl_timercall(void *);
113 static void ntoskrnl_run_dpc(void *);
114 __stdcall static void ntoskrnl_writereg_ushort(uint16_t *, uint16_t);
115 __stdcall static uint16_t ntoskrnl_readreg_ushort(uint16_t *);
116 __stdcall static void ntoskrnl_writereg_ulong(uint32_t *, uint32_t);
117 __stdcall static uint32_t ntoskrnl_readreg_ulong(uint32_t *);
118 __stdcall static void ntoskrnl_writereg_uchar(uint8_t *, uint8_t);
119 __stdcall static uint8_t ntoskrnl_readreg_uchar(uint8_t *);
120 __stdcall static int64_t _allmul(int64_t, int64_t);
121 __stdcall static int64_t _alldiv(int64_t, int64_t);
122 __stdcall static int64_t _allrem(int64_t, int64_t);
123 __regparm static int64_t _allshr(int64_t, uint8_t);
124 __regparm static int64_t _allshl(int64_t, uint8_t);
125 __stdcall static uint64_t _aullmul(uint64_t, uint64_t);
126 __stdcall static uint64_t _aulldiv(uint64_t, uint64_t);
127 __stdcall static uint64_t _aullrem(uint64_t, uint64_t);
128 __regparm static uint64_t _aullshr(uint64_t, uint8_t);
129 __regparm static uint64_t _aullshl(uint64_t, uint8_t);
130 __stdcall static void *ntoskrnl_allocfunc(uint32_t, size_t, uint32_t);
131 __stdcall static void ntoskrnl_freefunc(void *);
132 static slist_entry *ntoskrnl_pushsl(slist_header *, slist_entry *);
133 static slist_entry *ntoskrnl_popsl(slist_header *);
134 __stdcall static void ntoskrnl_init_lookaside(paged_lookaside_list *,
135 lookaside_alloc_func *, lookaside_free_func *,
136 uint32_t, size_t, uint32_t, uint16_t);
137 __stdcall static void ntoskrnl_delete_lookaside(paged_lookaside_list *);
138 __stdcall static void ntoskrnl_init_nplookaside(npaged_lookaside_list *,
139 lookaside_alloc_func *, lookaside_free_func *,
140 uint32_t, size_t, uint32_t, uint16_t);
141 __stdcall static void ntoskrnl_delete_nplookaside(npaged_lookaside_list *);
142 __stdcall static void ntoskrnl_freemdl(ndis_buffer *);
143 __stdcall static uint32_t ntoskrnl_sizeofmdl(void *, size_t);
144 __stdcall static void ntoskrnl_build_npaged_mdl(ndis_buffer *);
145 __stdcall static void *ntoskrnl_mmaplockedpages(ndis_buffer *, uint8_t);
146 __stdcall static void *ntoskrnl_mmaplockedpages_cache(ndis_buffer *,
147 uint8_t, uint32_t, void *, uint32_t, uint32_t);
148 __stdcall static void ntoskrnl_munmaplockedpages(void *, ndis_buffer *);
149 __stdcall static void ntoskrnl_init_lock(kspin_lock *);
150 __stdcall static size_t ntoskrnl_memcmp(const void *, const void *, size_t);
151 __stdcall static void ntoskrnl_init_ansi_string(ndis_ansi_string *, char *);
152 __stdcall static void ntoskrnl_init_unicode_string(ndis_unicode_string *,
154 __stdcall static void ntoskrnl_free_unicode_string(ndis_unicode_string *);
155 __stdcall static void ntoskrnl_free_ansi_string(ndis_ansi_string *);
156 __stdcall static ndis_status ntoskrnl_unicode_to_int(ndis_unicode_string *,
157 uint32_t, uint32_t *);
158 static int atoi (const char *);
159 static long atol (const char *);
160 static int rand(void);
161 static void ntoskrnl_time(uint64_t *);
162 __stdcall static uint8_t ntoskrnl_wdmver(uint8_t, uint8_t);
163 static void ntoskrnl_thrfunc(void *);
164 __stdcall static ndis_status ntoskrnl_create_thread(ndis_handle *,
165 uint32_t, void *, ndis_handle, void *, void *, void *);
166 __stdcall static ndis_status ntoskrnl_thread_exit(ndis_status);
167 __stdcall static ndis_status ntoskrnl_devprop(device_object *, uint32_t,
168 uint32_t, void *, uint32_t *);
169 __stdcall static void ntoskrnl_init_mutex(kmutant *, uint32_t);
170 __stdcall static uint32_t ntoskrnl_release_mutex(kmutant *, uint8_t);
171 __stdcall static uint32_t ntoskrnl_read_mutex(kmutant *);
172 __stdcall static ndis_status ntoskrnl_objref(ndis_handle, uint32_t, void *,
173 uint8_t, void **, void **);
174 __stdcall static uint32_t ntoskrnl_zwclose(ndis_handle);
175 static uint32_t ntoskrnl_dbgprint(char *, ...);
176 __stdcall static void ntoskrnl_debugger(void);
177 __stdcall static void dummy(void);
179 static struct lwkt_token ntoskrnl_dispatchtoken;
180 static kspin_lock ntoskrnl_global;
181 static int ntoskrnl_kth = 0;
182 static struct nt_objref_head ntoskrnl_reflist;
184 static MALLOC_DEFINE(M_NDIS, "ndis", "ndis emulation");
187 ntoskrnl_libinit(void)
189 lwkt_token_init(&ntoskrnl_dispatchtoken, 1, "ndiskrnl");
190 ntoskrnl_init_lock(&ntoskrnl_global);
191 TAILQ_INIT(&ntoskrnl_reflist);
196 ntoskrnl_libfini(void)
198 lwkt_token_uninit(&ntoskrnl_dispatchtoken);
202 __stdcall static uint8_t
203 ntoskrnl_unicode_equal(ndis_unicode_string *str1,
204 ndis_unicode_string *str2,
205 uint8_t caseinsensitive)
209 if (str1->nus_len != str2->nus_len)
212 for (i = 0; i < str1->nus_len; i++) {
213 if (caseinsensitive == TRUE) {
214 if (toupper((char)(str1->nus_buf[i] & 0xFF)) !=
215 toupper((char)(str2->nus_buf[i] & 0xFF)))
218 if (str1->nus_buf[i] != str2->nus_buf[i])
226 __stdcall static void
227 ntoskrnl_unicode_copy(ndis_unicode_string *dest,
228 ndis_unicode_string *src)
231 if (dest->nus_maxlen >= src->nus_len)
232 dest->nus_len = src->nus_len;
234 dest->nus_len = dest->nus_maxlen;
235 memcpy(dest->nus_buf, src->nus_buf, dest->nus_len);
239 __stdcall static ndis_status
240 ntoskrnl_unicode_to_ansi(ndis_ansi_string *dest,
241 ndis_unicode_string *src,
246 if (dest == NULL || src == NULL)
247 return(NDIS_STATUS_FAILURE);
249 if (allocate == TRUE) {
250 if (ndis_unicode_to_ascii(src->nus_buf, src->nus_len, &astr))
251 return(NDIS_STATUS_FAILURE);
252 dest->nas_buf = astr;
253 dest->nas_len = dest->nas_maxlen = strlen(astr);
255 dest->nas_len = src->nus_len / 2; /* XXX */
256 if (dest->nas_maxlen < dest->nas_len)
257 dest->nas_len = dest->nas_maxlen;
258 ndis_unicode_to_ascii(src->nus_buf, dest->nas_len * 2,
261 return (NDIS_STATUS_SUCCESS);
264 __stdcall static ndis_status
265 ntoskrnl_ansi_to_unicode(ndis_unicode_string *dest,
266 ndis_ansi_string *src,
269 uint16_t *ustr = NULL;
271 if (dest == NULL || src == NULL)
272 return(NDIS_STATUS_FAILURE);
274 if (allocate == TRUE) {
275 if (ndis_ascii_to_unicode(src->nas_buf, &ustr))
276 return(NDIS_STATUS_FAILURE);
277 dest->nus_buf = ustr;
278 dest->nus_len = dest->nus_maxlen = strlen(src->nas_buf) * 2;
280 dest->nus_len = src->nas_len * 2; /* XXX */
281 if (dest->nus_maxlen < dest->nus_len)
282 dest->nus_len = dest->nus_maxlen;
283 ndis_ascii_to_unicode(src->nas_buf, &dest->nus_buf);
285 return (NDIS_STATUS_SUCCESS);
288 __stdcall static void *
289 ntoskrnl_iobuildsynchfsdreq(uint32_t func, void *dobj, void *buf,
290 uint32_t len, uint32_t *off,
291 void *event, void *status)
296 __stdcall __regcall static uint32_t
297 ntoskrnl_iofcalldriver(REGARGS2(void *dobj, void *irp))
302 __stdcall __regcall static void
303 ntoskrnl_iofcompletereq(REGARGS2(void *irp, uint8_t prioboost))
308 ntoskrnl_wakeup(void *arg)
310 nt_dispatch_header *obj;
317 lwkt_gettoken(&ntoskrnl_dispatchtoken);
318 obj->dh_sigstate = TRUE;
319 e = obj->dh_waitlisthead.nle_flink;
320 while (e != &obj->dh_waitlisthead) {
325 * For synchronization objects, only wake up
328 if (obj->dh_type == EVENT_TYPE_SYNC)
332 lwkt_reltoken(&ntoskrnl_dispatchtoken);
336 ntoskrnl_time(uint64_t *tval)
341 *tval = (uint64_t)ts.tv_nsec / 100 + (uint64_t)ts.tv_sec * 10000000 +
348 * KeWaitForSingleObject() is a tricky beast, because it can be used
349 * with several different object types: semaphores, timers, events,
350 * mutexes and threads. Semaphores don't appear very often, but the
351 * other object types are quite common. KeWaitForSingleObject() is
352 * what's normally used to acquire a mutex, and it can be used to
353 * wait for a thread termination.
355 * The Windows NDIS API is implemented in terms of Windows kernel
356 * primitives, and some of the object manipulation is duplicated in
357 * NDIS. For example, NDIS has timers and events, which are actually
358 * Windows kevents and ktimers. Now, you're supposed to only use the
359 * NDIS variants of these objects within the confines of the NDIS API,
360 * but there are some naughty developers out there who will use
361 * KeWaitForSingleObject() on NDIS timer and event objects, so we
362 * have to support that as well. Conseqently, our NDIS timer and event
363 * code has to be closely tied into our ntoskrnl timer and event code,
364 * just as it is in Windows.
366 * KeWaitForSingleObject() may do different things for different kinds
369 * - For events, we check if the event has been signalled. If the
370 * event is already in the signalled state, we just return immediately,
371 * otherwise we wait for it to be set to the signalled state by someone
372 * else calling KeSetEvent(). Events can be either synchronization or
373 * notification events.
375 * - For timers, if the timer has already fired and the timer is in
376 * the signalled state, we just return, otherwise we wait on the
377 * timer. Unlike an event, timers get signalled automatically when
378 * they expire rather than someone having to trip them manually.
379 * Timers initialized with KeInitializeTimer() are always notification
380 * events: KeInitializeTimerEx() lets you initialize a timer as
381 * either a notification or synchronization event.
383 * - For mutexes, we try to acquire the mutex and if we can't, we wait
384 * on the mutex until it's available and then grab it. When a mutex is
385 * released, it enters the signaled state, which wakes up one of the
386 * threads waiting to acquire it. Mutexes are always synchronization
389 * - For threads, the only thing we do is wait until the thread object
390 * enters a signalled state, which occurs when the thread terminates.
391 * Threads are always notification events.
393 * A notification event wakes up all threads waiting on an object. A
394 * synchronization event wakes up just one. Also, a synchronization event
395 * is auto-clearing, which means we automatically set the event back to
396 * the non-signalled state once the wakeup is done.
400 ntoskrnl_waitforobj(nt_dispatch_header *obj, uint32_t reason,
401 uint32_t mode, uint8_t alertable, int64_t *duetime)
403 struct thread *td = curthread;
412 return(STATUS_INVALID_PARAMETER);
414 lwkt_gettoken(&ntoskrnl_dispatchtoken);
417 * See if the object is a mutex. If so, and we already own
418 * it, then just increment the acquisition count and return.
420 * For any other kind of object, see if it's already in the
421 * signalled state, and if it is, just return. If the object
422 * is marked as a synchronization event, reset the state to
426 if (obj->dh_size == OTYPE_MUTEX) {
428 if (km->km_ownerthread == NULL ||
429 km->km_ownerthread == curthread->td_proc) {
430 obj->dh_sigstate = FALSE;
432 km->km_ownerthread = curthread->td_proc;
433 lwkt_reltoken(&ntoskrnl_dispatchtoken);
434 return (STATUS_SUCCESS);
436 } else if (obj->dh_sigstate == TRUE) {
437 if (obj->dh_type == EVENT_TYPE_SYNC)
438 obj->dh_sigstate = FALSE;
439 lwkt_reltoken(&ntoskrnl_dispatchtoken);
440 return (STATUS_SUCCESS);
446 INSERT_LIST_TAIL((&obj->dh_waitlisthead), (&w.wb_waitlist));
449 * The timeout value is specified in 100 nanosecond units
450 * and can be a positive or negative number. If it's positive,
451 * then the duetime is absolute, and we need to convert it
452 * to an absolute offset relative to now in order to use it.
453 * If it's negative, then the duetime is relative and we
454 * just have to convert the units.
457 if (duetime != NULL) {
459 tv.tv_sec = - (*duetime) / 10000000;
460 tv.tv_usec = (- (*duetime) / 10) -
461 (tv.tv_sec * 1000000);
463 ntoskrnl_time(&curtime);
464 if (*duetime < curtime)
465 tv.tv_sec = tv.tv_usec = 0;
467 tv.tv_sec = ((*duetime) - curtime) / 10000000;
468 tv.tv_usec = ((*duetime) - curtime) / 10 -
469 (tv.tv_sec * 1000000);
474 lwkt_reltoken(&ntoskrnl_dispatchtoken);
476 ticks = 1 + tv.tv_sec * hz + tv.tv_usec * hz / 1000000;
477 error = ndis_thsuspend(td, duetime == NULL ? 0 : ticks);
479 lwkt_gettoken(&tokref, &ntoskrnl_dispatchtoken);
481 /* We timed out. Leave the object alone and return status. */
483 if (error == EWOULDBLOCK) {
484 REMOVE_LIST_ENTRY((&w.wb_waitlist));
485 lwkt_reltoken(&ntoskrnl_dispatchtoken);
486 return(STATUS_TIMEOUT);
490 * Mutexes are always synchronization objects, which means
491 * if several threads are waiting to acquire it, only one will
492 * be woken up. If that one is us, and the mutex is up for grabs,
496 if (obj->dh_size == OTYPE_MUTEX) {
498 if (km->km_ownerthread == NULL) {
499 km->km_ownerthread = curthread->td_proc;
504 if (obj->dh_type == EVENT_TYPE_SYNC)
505 obj->dh_sigstate = FALSE;
506 REMOVE_LIST_ENTRY((&w.wb_waitlist));
508 lwkt_reltoken(&ntoskrnl_dispatchtoken);
510 return(STATUS_SUCCESS);
513 __stdcall static uint32_t
514 ntoskrnl_waitforobjs(uint32_t cnt, nt_dispatch_header *obj[],
515 uint32_t wtype, uint32_t reason, uint32_t mode,
516 uint8_t alertable, int64_t *duetime,
517 wait_block *wb_array)
519 struct thread *td = curthread;
521 wait_block _wb_array[THREAD_WAIT_OBJECTS];
524 int i, wcnt = 0, widx = 0, error = 0;
526 struct timespec t1, t2;
528 if (cnt > MAX_WAIT_OBJECTS)
529 return(STATUS_INVALID_PARAMETER);
530 if (cnt > THREAD_WAIT_OBJECTS && wb_array == NULL)
531 return(STATUS_INVALID_PARAMETER);
533 lwkt_gettoken(&ntoskrnl_dispatchtoken);
535 if (wb_array == NULL)
540 tv.tv_sec = 0; /* fix compiler warning */
541 tv.tv_usec = 0; /* fix compiler warning */
543 /* First pass: see if we can satisfy any waits immediately. */
545 for (i = 0; i < cnt; i++) {
546 if (obj[i]->dh_size == OTYPE_MUTEX) {
547 km = (kmutant *)obj[i];
548 if (km->km_ownerthread == NULL ||
549 km->km_ownerthread == curthread->td_proc) {
550 obj[i]->dh_sigstate = FALSE;
552 km->km_ownerthread = curthread->td_proc;
553 if (wtype == WAITTYPE_ANY) {
554 lwkt_reltoken(&ntoskrnl_dispatchtoken);
555 return (STATUS_WAIT_0 + i);
558 } else if (obj[i]->dh_sigstate == TRUE) {
559 if (obj[i]->dh_type == EVENT_TYPE_SYNC)
560 obj[i]->dh_sigstate = FALSE;
561 if (wtype == WAITTYPE_ANY) {
562 lwkt_reltoken(&ntoskrnl_dispatchtoken);
563 return (STATUS_WAIT_0 + i);
569 * Second pass: set up wait for anything we can't
570 * satisfy immediately.
573 for (i = 0; i < cnt; i++) {
574 if (obj[i]->dh_sigstate == TRUE)
576 INSERT_LIST_TAIL((&obj[i]->dh_waitlisthead),
577 (&w[i].wb_waitlist));
578 w[i].wb_kthread = td;
579 w[i].wb_object = obj[i];
585 tv.tv_sec = -*duetime / 10000000;
586 tv.tv_usec = (-*duetime / 10) - (tv.tv_sec * 1000000);
588 ntoskrnl_time(&curtime);
589 if (*duetime < curtime) {
593 tv.tv_sec = ((*duetime) - curtime) / 10000000;
594 tv.tv_usec = ((*duetime) - curtime) / 10 -
595 (tv.tv_sec * 1000000);
602 lwkt_reltoken(&ntoskrnl_dispatchtoken);
605 ticks = 1 + tv.tv_sec * hz + tv.tv_usec * hz / 1000000;
606 error = ndis_thsuspend(td, ticks);
608 error = ndis_thsuspend(td, 0);
611 lwkt_gettoken(&ntoskrnl_dispatchtoken);
614 for (i = 0; i < cnt; i++) {
615 if (obj[i]->dh_size == OTYPE_MUTEX) {
617 if (km->km_ownerthread == NULL) {
623 if (obj[i]->dh_sigstate == TRUE) {
625 if (obj[i]->dh_type == EVENT_TYPE_SYNC)
626 obj[i]->dh_sigstate = FALSE;
627 REMOVE_LIST_ENTRY((&w[i].wb_waitlist));
632 if (error || wtype == WAITTYPE_ANY)
636 tv.tv_sec -= (t2.tv_sec - t1.tv_sec);
637 tv.tv_usec -= (t2.tv_nsec - t1.tv_nsec) / 1000;
642 for (i = 0; i < cnt; i++)
643 REMOVE_LIST_ENTRY((&w[i].wb_waitlist));
646 if (error == EWOULDBLOCK) {
647 lwkt_reltoken(&ntoskrnl_dispatchtoken);
648 return(STATUS_TIMEOUT);
651 if (wtype == WAITTYPE_ANY && wcnt) {
652 lwkt_reltoken(&ntoskrnl_dispatchtoken);
653 return(STATUS_WAIT_0 + widx);
656 lwkt_reltoken(&ntoskrnl_dispatchtoken);
658 return(STATUS_SUCCESS);
661 __stdcall static void
662 ntoskrnl_writereg_ushort(uint16_t *reg, uint16_t val)
664 bus_space_write_2(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg, val);
668 __stdcall static uint16_t
669 ntoskrnl_readreg_ushort(uint16_t *reg)
671 return(bus_space_read_2(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg));
674 __stdcall static void
675 ntoskrnl_writereg_ulong(uint32_t *reg, uint32_t val)
677 bus_space_write_4(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg, val);
681 __stdcall static uint32_t
682 ntoskrnl_readreg_ulong(uint32_t *reg)
684 return(bus_space_read_4(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg));
687 __stdcall static uint8_t
688 ntoskrnl_readreg_uchar(uint8_t *reg)
690 return(bus_space_read_1(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg));
693 __stdcall static void
694 ntoskrnl_writereg_uchar(uint8_t *reg, uint8_t val)
696 bus_space_write_1(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg, val);
700 __stdcall static int64_t
701 _allmul(int64_t a, int64_t b)
706 __stdcall static int64_t
707 _alldiv(int64_t a, int64_t b)
712 __stdcall static int64_t
713 _allrem(int64_t a, int64_t b)
718 __stdcall static uint64_t
719 _aullmul(uint64_t a, uint64_t b)
724 __stdcall static uint64_t
725 _aulldiv(uint64_t a, uint64_t b)
730 __stdcall static uint64_t
731 _aullrem(uint64_t a, uint64_t b)
736 __regparm static int64_t
737 _allshl(int64_t a, uint8_t b)
742 __regparm static uint64_t
743 _aullshl(uint64_t a, uint8_t b)
748 __regparm static int64_t
749 _allshr(int64_t a, uint8_t b)
754 __regparm static uint64_t
755 _aullshr(uint64_t a, uint8_t b)
761 ntoskrnl_pushsl(slist_header *head, slist_entry *entry)
763 slist_entry *oldhead;
765 oldhead = head->slh_list.slh_next;
766 entry->sl_next = head->slh_list.slh_next;
767 head->slh_list.slh_next = entry;
768 head->slh_list.slh_depth++;
769 head->slh_list.slh_seq++;
775 ntoskrnl_popsl(slist_header *head)
779 first = head->slh_list.slh_next;
781 head->slh_list.slh_next = first->sl_next;
782 head->slh_list.slh_depth--;
783 head->slh_list.slh_seq++;
789 __stdcall static void *
790 ntoskrnl_allocfunc(uint32_t pooltype, size_t size, uint32_t tag)
792 return(kmalloc(size, M_DEVBUF, M_WAITOK));
795 __stdcall static void
796 ntoskrnl_freefunc(void *buf)
798 kfree(buf, M_DEVBUF);
802 __stdcall static void
803 ntoskrnl_init_lookaside(paged_lookaside_list *lookaside,
804 lookaside_alloc_func *allocfunc,
805 lookaside_free_func *freefunc,
806 uint32_t flags, size_t size,
807 uint32_t tag, uint16_t depth)
809 bzero((char *)lookaside, sizeof(paged_lookaside_list));
811 if (size < sizeof(slist_entry))
812 lookaside->nll_l.gl_size = sizeof(slist_entry);
814 lookaside->nll_l.gl_size = size;
815 lookaside->nll_l.gl_tag = tag;
816 if (allocfunc == NULL)
817 lookaside->nll_l.gl_allocfunc = ntoskrnl_allocfunc;
819 lookaside->nll_l.gl_allocfunc = allocfunc;
821 if (freefunc == NULL)
822 lookaside->nll_l.gl_freefunc = ntoskrnl_freefunc;
824 lookaside->nll_l.gl_freefunc = freefunc;
826 ntoskrnl_init_lock(&lookaside->nll_obsoletelock);
828 lookaside->nll_l.gl_depth = LOOKASIDE_DEPTH;
829 lookaside->nll_l.gl_maxdepth = LOOKASIDE_DEPTH;
834 __stdcall static void
835 ntoskrnl_delete_lookaside(paged_lookaside_list *lookaside)
838 __stdcall void (*freefunc)(void *);
840 freefunc = lookaside->nll_l.gl_freefunc;
841 while((buf = ntoskrnl_popsl(&lookaside->nll_l.gl_listhead)) != NULL)
847 __stdcall static void
848 ntoskrnl_init_nplookaside(npaged_lookaside_list *lookaside,
849 lookaside_alloc_func *allocfunc,
850 lookaside_free_func *freefunc,
851 uint32_t flags, size_t size,
852 uint32_t tag, uint16_t depth)
854 bzero((char *)lookaside, sizeof(npaged_lookaside_list));
856 if (size < sizeof(slist_entry))
857 lookaside->nll_l.gl_size = sizeof(slist_entry);
859 lookaside->nll_l.gl_size = size;
860 lookaside->nll_l.gl_tag = tag;
861 if (allocfunc == NULL)
862 lookaside->nll_l.gl_allocfunc = ntoskrnl_allocfunc;
864 lookaside->nll_l.gl_allocfunc = allocfunc;
866 if (freefunc == NULL)
867 lookaside->nll_l.gl_freefunc = ntoskrnl_freefunc;
869 lookaside->nll_l.gl_freefunc = freefunc;
871 ntoskrnl_init_lock(&lookaside->nll_obsoletelock);
873 lookaside->nll_l.gl_depth = LOOKASIDE_DEPTH;
874 lookaside->nll_l.gl_maxdepth = LOOKASIDE_DEPTH;
879 __stdcall static void
880 ntoskrnl_delete_nplookaside(npaged_lookaside_list *lookaside)
883 __stdcall void (*freefunc)(void *);
885 freefunc = lookaside->nll_l.gl_freefunc;
886 while((buf = ntoskrnl_popsl(&lookaside->nll_l.gl_listhead)) != NULL)
893 * Note: the interlocked slist push and pop routines are
894 * declared to be _fastcall in Windows. gcc 3.4 is supposed
895 * to have support for this calling convention, however we
896 * don't have that version available yet, so we kludge things
897 * up using some inline assembly.
900 __stdcall __regcall static slist_entry *
901 ntoskrnl_push_slist(REGARGS2(slist_header *head, slist_entry *entry))
903 slist_entry *oldhead;
905 oldhead = (slist_entry *)FASTCALL3(ntoskrnl_push_slist_ex,
906 head, entry, &ntoskrnl_global);
911 __stdcall __regcall static slist_entry *
912 ntoskrnl_pop_slist(REGARGS1(slist_header *head))
916 first = (slist_entry *)FASTCALL2(ntoskrnl_pop_slist_ex,
917 head, &ntoskrnl_global);
922 __stdcall __regcall static slist_entry *
923 ntoskrnl_push_slist_ex(REGARGS2(slist_header *head, slist_entry *entry), kspin_lock *lock)
925 slist_entry *oldhead;
928 irql = FASTCALL2(hal_lock, lock, DISPATCH_LEVEL);
929 oldhead = ntoskrnl_pushsl(head, entry);
930 FASTCALL2(hal_unlock, lock, irql);
935 __stdcall __regcall static slist_entry *
936 ntoskrnl_pop_slist_ex(REGARGS2(slist_header *head, kspin_lock *lock))
941 irql = FASTCALL2(hal_lock, lock, DISPATCH_LEVEL);
942 first = ntoskrnl_popsl(head);
943 FASTCALL2(hal_unlock, lock, irql);
948 __stdcall __regcall void
949 ntoskrnl_lock_dpc(REGARGS1(kspin_lock *lock))
951 while (atomic_poll_acquire_int((volatile u_int *)lock) == 0)
955 __stdcall __regcall void
956 ntoskrnl_unlock_dpc(REGARGS1(kspin_lock *lock))
958 atomic_poll_release_int((volatile u_int *)lock);
961 __stdcall __regcall static uint32_t
962 ntoskrnl_interlock_inc(REGARGS1(volatile uint32_t *addend))
964 atomic_add_long((volatile u_long *)addend, 1);
968 __stdcall __regcall static uint32_t
969 ntoskrnl_interlock_dec(REGARGS1(volatile uint32_t *addend))
971 atomic_subtract_long((volatile u_long *)addend, 1);
975 __stdcall __regcall static void
976 ntoskrnl_interlock_addstat(REGARGS2(uint64_t *addend, uint32_t inc))
980 irql = FASTCALL2(hal_lock, &ntoskrnl_global, DISPATCH_LEVEL);
982 FASTCALL2(hal_unlock, &ntoskrnl_global, irql);
987 __stdcall static void
988 ntoskrnl_freemdl(ndis_buffer *mdl)
992 if (mdl == NULL || mdl->nb_process == NULL)
995 head = mdl->nb_process;
997 if (head->nb_flags != 0x1)
1000 mdl->nb_next = head->nb_next;
1001 head->nb_next = mdl;
1003 /* Decrement count of busy buffers. */
1005 head->nb_bytecount--;
1008 * If the pool has been marked for deletion and there are
1009 * no more buffers outstanding, nuke the pool.
1012 if (head->nb_byteoffset && head->nb_bytecount == 0)
1013 kfree(head, M_DEVBUF);
1018 __stdcall static uint32_t
1019 ntoskrnl_sizeofmdl(void *vaddr, size_t len)
1023 l = sizeof(struct ndis_buffer) +
1024 (sizeof(uint32_t) * SPAN_PAGES(vaddr, len));
1029 __stdcall static void
1030 ntoskrnl_build_npaged_mdl(ndis_buffer *mdl)
1032 mdl->nb_mappedsystemva = (char *)mdl->nb_startva + mdl->nb_byteoffset;
1036 __stdcall static void *
1037 ntoskrnl_mmaplockedpages(ndis_buffer *buf, uint8_t accessmode)
1039 return(MDL_VA(buf));
1042 __stdcall static void *
1043 ntoskrnl_mmaplockedpages_cache(ndis_buffer *buf, uint8_t accessmode,
1044 uint32_t cachetype, void *vaddr,
1045 uint32_t bugcheck, uint32_t prio)
1047 return(MDL_VA(buf));
1050 __stdcall static void
1051 ntoskrnl_munmaplockedpages(void *vaddr, ndis_buffer *buf)
1057 * The KeInitializeSpinLock(), KefAcquireSpinLockAtDpcLevel()
1058 * and KefReleaseSpinLockFromDpcLevel() appear to be analagous
1059 * to crit_enter()/crit_exit() in their use. We can't create a new mutex
1060 * lock here because there is no complimentary KeFreeSpinLock()
1061 * function. Instead, we grab a mutex from the mutex pool.
1063 __stdcall static void
1064 ntoskrnl_init_lock(kspin_lock *lock)
1071 __stdcall static size_t
1072 ntoskrnl_memcmp(const void *s1, const void *s2, size_t len)
1074 size_t i, total = 0;
1077 m1 = __DECONST(char *, s1);
1078 m2 = __DECONST(char *, s2);
1080 for (i = 0; i < len; i++) {
1087 __stdcall static void
1088 ntoskrnl_init_ansi_string(ndis_ansi_string *dst, char *src)
1090 ndis_ansi_string *a;
1096 a->nas_len = a->nas_maxlen = 0;
1100 a->nas_len = a->nas_maxlen = strlen(src);
1106 __stdcall static void
1107 ntoskrnl_init_unicode_string(ndis_unicode_string *dst, uint16_t *src)
1109 ndis_unicode_string *u;
1116 u->nus_len = u->nus_maxlen = 0;
1123 u->nus_len = u->nus_maxlen = i * 2;
1129 __stdcall ndis_status
1130 ntoskrnl_unicode_to_int(ndis_unicode_string *ustr, uint32_t base,
1138 uchr = ustr->nus_buf;
1139 len = ustr->nus_len;
1140 bzero(abuf, sizeof(abuf));
1142 if ((char)((*uchr) & 0xFF) == '-') {
1146 } else if ((char)((*uchr) & 0xFF) == '+') {
1153 if ((char)((*uchr) & 0xFF) == 'b') {
1157 } else if ((char)((*uchr) & 0xFF) == 'o') {
1161 } else if ((char)((*uchr) & 0xFF) == 'x') {
1175 ndis_unicode_to_ascii(uchr, len, &astr);
1176 *val = strtoul(abuf, NULL, base);
1178 return(NDIS_STATUS_SUCCESS);
1181 __stdcall static void
1182 ntoskrnl_free_unicode_string(ndis_unicode_string *ustr)
1184 if (ustr->nus_buf == NULL)
1186 kfree(ustr->nus_buf, M_DEVBUF);
1187 ustr->nus_buf = NULL;
1191 __stdcall static void
1192 ntoskrnl_free_ansi_string(ndis_ansi_string *astr)
1194 if (astr->nas_buf == NULL)
1196 kfree(astr->nas_buf, M_DEVBUF);
1197 astr->nas_buf = NULL;
1202 atoi(const char *str)
1204 return (int)strtol(str, NULL, 10);
1208 atol(const char *str)
1210 return strtol(str, NULL, 10);
1219 skrandom(tv.tv_usec);
1220 return((int)krandom());
1223 __stdcall static uint8_t
1224 ntoskrnl_wdmver(uint8_t major, uint8_t minor)
1226 if (major == WDM_MAJOR && minor == WDM_MINOR_WINXP)
1231 __stdcall static ndis_status
1232 ntoskrnl_devprop(device_object *devobj, uint32_t regprop, uint32_t buflen,
1233 void *prop, uint32_t *reslen)
1235 ndis_miniport_block *block;
1237 block = devobj->do_rsvd;
1240 case DEVPROP_DRIVER_KEYNAME:
1241 ndis_ascii_to_unicode(__DECONST(char *,
1242 device_get_nameunit(block->nmb_dev)), (uint16_t **)&prop);
1243 *reslen = strlen(device_get_nameunit(block->nmb_dev)) * 2;
1246 return(STATUS_INVALID_PARAMETER_2);
1250 return(STATUS_SUCCESS);
1253 __stdcall static void
1254 ntoskrnl_init_mutex(kmutant *kmutex, uint32_t level)
1256 INIT_LIST_HEAD((&kmutex->km_header.dh_waitlisthead));
1257 kmutex->km_abandoned = FALSE;
1258 kmutex->km_apcdisable = 1;
1259 kmutex->km_header.dh_sigstate = TRUE;
1260 kmutex->km_header.dh_type = EVENT_TYPE_SYNC;
1261 kmutex->km_header.dh_size = OTYPE_MUTEX;
1262 kmutex->km_acquirecnt = 0;
1263 kmutex->km_ownerthread = NULL;
1267 __stdcall static uint32_t
1268 ntoskrnl_release_mutex(kmutant *kmutex, uint8_t kwait)
1270 lwkt_gettoken(&ntoskrnl_dispatchtoken);
1271 if (kmutex->km_ownerthread != curthread->td_proc) {
1272 lwkt_reltoken(&ntoskrnl_dispatchtoken);
1273 return(STATUS_MUTANT_NOT_OWNED);
1275 kmutex->km_acquirecnt--;
1276 if (kmutex->km_acquirecnt == 0) {
1277 kmutex->km_ownerthread = NULL;
1278 lwkt_reltoken(&ntoskrnl_dispatchtoken);
1279 ntoskrnl_wakeup(&kmutex->km_header);
1281 lwkt_reltoken(&ntoskrnl_dispatchtoken);
1284 return(kmutex->km_acquirecnt);
1287 __stdcall static uint32_t
1288 ntoskrnl_read_mutex(kmutant *kmutex)
1290 return(kmutex->km_header.dh_sigstate);
1294 ntoskrnl_init_event(nt_kevent *kevent, uint32_t type, uint8_t state)
1296 INIT_LIST_HEAD((&kevent->k_header.dh_waitlisthead));
1297 kevent->k_header.dh_sigstate = state;
1298 kevent->k_header.dh_type = type;
1299 kevent->k_header.dh_size = OTYPE_EVENT;
1304 ntoskrnl_reset_event(nt_kevent *kevent)
1308 lwkt_gettoken(&ntoskrnl_dispatchtoken);
1309 prevstate = kevent->k_header.dh_sigstate;
1310 kevent->k_header.dh_sigstate = FALSE;
1311 lwkt_reltoken(&ntoskrnl_dispatchtoken);
1317 ntoskrnl_set_event(nt_kevent *kevent, uint32_t increment, uint8_t kwait)
1321 prevstate = kevent->k_header.dh_sigstate;
1322 ntoskrnl_wakeup(&kevent->k_header);
1328 ntoskrnl_clear_event(nt_kevent *kevent)
1330 kevent->k_header.dh_sigstate = FALSE;
1335 ntoskrnl_read_event(nt_kevent *kevent)
1337 return(kevent->k_header.dh_sigstate);
1340 __stdcall static ndis_status
1341 ntoskrnl_objref(ndis_handle handle, uint32_t reqaccess, void *otype,
1342 uint8_t accessmode, void **object, void **handleinfo)
1346 nr = kmalloc(sizeof(nt_objref), M_DEVBUF, M_WAITOK|M_ZERO);
1348 INIT_LIST_HEAD((&nr->no_dh.dh_waitlisthead));
1349 nr->no_obj = handle;
1350 nr->no_dh.dh_size = OTYPE_THREAD;
1351 TAILQ_INSERT_TAIL(&ntoskrnl_reflist, nr, link);
1354 return(NDIS_STATUS_SUCCESS);
1357 __stdcall __regcall static void
1358 ntoskrnl_objderef(REGARGS1(void *object))
1363 TAILQ_REMOVE(&ntoskrnl_reflist, nr, link);
1364 kfree(nr, M_DEVBUF);
1369 __stdcall static uint32_t
1370 ntoskrnl_zwclose(ndis_handle handle)
1372 return(STATUS_SUCCESS);
1376 * This is here just in case the thread returns without calling
1377 * PsTerminateSystemThread().
1380 ntoskrnl_thrfunc(void *arg)
1382 thread_context *thrctx;
1383 __stdcall uint32_t (*tfunc)(void *);
1390 tfunc = thrctx->tc_thrfunc;
1391 tctx = thrctx->tc_thrctx;
1392 kfree(thrctx, M_TEMP);
1395 ntoskrnl_thread_exit(rval);
1399 __stdcall static ndis_status
1400 ntoskrnl_create_thread(ndis_handle *handle, uint32_t reqaccess,
1401 void *objattrs, ndis_handle phandle,
1402 void *clientid, void *thrfunc, void *thrctx)
1409 tc = kmalloc(sizeof(thread_context), M_TEMP, M_WAITOK);
1411 tc->tc_thrctx = thrctx;
1412 tc->tc_thrfunc = thrfunc;
1414 ksprintf(tname, "windows kthread %d", ntoskrnl_kth);
1415 error = kthread_create_stk(ntoskrnl_thrfunc, tc, &td,
1416 NDIS_KSTACK_PAGES * PAGE_SIZE, tname);
1425 * In Windows, the exit of a thread is an event that you're allowed
1426 * to wait on, assuming you've obtained a reference to the thread using
1427 * ObReferenceObjectByHandle(). Unfortunately, the only way we can
1428 * simulate this behavior is to register each thread we create in a
1429 * reference list, and if someone holds a reference to us, we poke
1432 __stdcall static ndis_status
1433 ntoskrnl_thread_exit(ndis_status status)
1435 struct nt_objref *nr;
1437 TAILQ_FOREACH(nr, &ntoskrnl_reflist, link) {
1438 if (nr->no_obj != curthread)
1440 ntoskrnl_wakeup(&nr->no_dh);
1447 kthread_exit(); /* call explicitly */
1449 return(0); /* notreached */
1453 ntoskrnl_dbgprint(char *fmt, ...)
1458 __va_start(ap, fmt);
1462 return(STATUS_SUCCESS);
1465 __stdcall static void
1466 ntoskrnl_debugger(void)
1469 #if __FreeBSD_version < 502113
1470 Debugger("ntoskrnl_debugger(): breakpoint");
1472 kdb_enter("ntoskrnl_debugger(): breakpoint");
1477 ntoskrnl_timercall(void *arg)
1483 timer->k_header.dh_inserted = FALSE;
1486 * If this is a periodic timer, re-arm it
1487 * so it will fire again. We do this before
1488 * calling any deferred procedure calls because
1489 * it's possible the DPC might cancel the timer,
1490 * in which case it would be wrong for us to
1491 * re-arm it again afterwards.
1494 if (timer->k_period) {
1495 timer->k_header.dh_inserted = TRUE;
1496 callout_reset(timer->k_handle, 1 + timer->k_period * hz / 1000,
1497 ntoskrnl_timercall, timer);
1499 callout_deactivate(timer->k_handle);
1500 kfree(timer->k_handle, M_NDIS);
1501 timer->k_handle = NULL;
1504 if (timer->k_dpc != NULL)
1505 ntoskrnl_queue_dpc(timer->k_dpc, NULL, NULL);
1507 ntoskrnl_wakeup(&timer->k_header);
1511 ntoskrnl_init_timer(ktimer *timer)
1516 ntoskrnl_init_timer_ex(timer, EVENT_TYPE_NOTIFY);
1520 ntoskrnl_init_timer_ex(ktimer *timer, uint32_t type)
1525 INIT_LIST_HEAD((&timer->k_header.dh_waitlisthead));
1526 timer->k_header.dh_sigstate = FALSE;
1527 timer->k_header.dh_inserted = FALSE;
1528 timer->k_header.dh_type = type;
1529 timer->k_header.dh_size = OTYPE_TIMER;
1530 timer->k_handle = NULL;
1536 * This is a wrapper for Windows deferred procedure calls that
1537 * have been placed on an NDIS thread work queue. We need it
1538 * since the DPC could be a _stdcall function. Also, as far as
1539 * I can tell, defered procedure calls must run at DISPATCH_LEVEL.
1542 ntoskrnl_run_dpc(void *arg)
1549 dpcfunc = (kdpc_func)dpc->k_deferedfunc;
1550 irql = FASTCALL1(hal_raise_irql, DISPATCH_LEVEL);
1551 dpcfunc(dpc, dpc->k_deferredctx, dpc->k_sysarg1, dpc->k_sysarg2);
1552 FASTCALL1(hal_lower_irql, irql);
1558 ntoskrnl_init_dpc(kdpc *dpc, void *dpcfunc, void *dpcctx)
1563 dpc->k_deferedfunc = dpcfunc;
1564 dpc->k_deferredctx = dpcctx;
1570 ntoskrnl_queue_dpc(kdpc *dpc, void *sysarg1, void *sysarg2)
1572 dpc->k_sysarg1 = sysarg1;
1573 dpc->k_sysarg2 = sysarg2;
1574 if (ndis_sched(ntoskrnl_run_dpc, dpc, NDIS_SWI))
1581 ntoskrnl_dequeue_dpc(kdpc *dpc)
1583 if (ndis_unsched(ntoskrnl_run_dpc, dpc, NDIS_SWI))
1590 ntoskrnl_set_timer_ex(ktimer *timer, int64_t duetime, uint32_t period,
1601 if (timer->k_header.dh_inserted == TRUE) {
1602 if (timer->k_handle != NULL)
1603 callout_stop(timer->k_handle);
1604 timer->k_header.dh_inserted = FALSE;
1609 timer->k_duetime = duetime;
1610 timer->k_period = period;
1611 timer->k_header.dh_sigstate = FALSE;
1615 tv.tv_sec = - (duetime) / 10000000;
1616 tv.tv_usec = (- (duetime) / 10) -
1617 (tv.tv_sec * 1000000);
1619 ntoskrnl_time(&curtime);
1620 if (duetime < curtime)
1621 tv.tv_sec = tv.tv_usec = 0;
1623 tv.tv_sec = ((duetime) - curtime) / 10000000;
1624 tv.tv_usec = ((duetime) - curtime) / 10 -
1625 (tv.tv_sec * 1000000);
1629 ticks = 1 + tv.tv_sec * hz + tv.tv_usec * hz / 1000000;
1630 timer->k_header.dh_inserted = TRUE;
1631 if (timer->k_handle == NULL) {
1632 timer->k_handle = kmalloc(sizeof(struct callout), M_NDIS,
1634 callout_init(timer->k_handle);
1636 callout_reset(timer->k_handle, ticks, ntoskrnl_timercall, timer);
1642 ntoskrnl_set_timer(ktimer *timer, int64_t duetime, kdpc *dpc)
1644 return (ntoskrnl_set_timer_ex(timer, duetime, 0, dpc));
1648 ntoskrnl_cancel_timer(ktimer *timer)
1655 if (timer->k_header.dh_inserted == TRUE) {
1656 if (timer->k_handle != NULL) {
1657 callout_stop(timer->k_handle);
1658 kfree(timer->k_handle, M_NDIS);
1659 timer->k_handle = NULL;
1661 if (timer->k_dpc != NULL)
1662 ntoskrnl_dequeue_dpc(timer->k_dpc);
1672 ntoskrnl_read_timer(ktimer *timer)
1674 return(timer->k_header.dh_sigstate);
1677 __stdcall static void
1680 kprintf ("ntoskrnl dummy called...\n");
1685 image_patch_table ntoskrnl_functbl[] = {
1686 { "RtlCompareMemory", (FUNC)ntoskrnl_memcmp },
1687 { "RtlEqualUnicodeString", (FUNC)ntoskrnl_unicode_equal },
1688 { "RtlCopyUnicodeString", (FUNC)ntoskrnl_unicode_copy },
1689 { "RtlUnicodeStringToAnsiString", (FUNC)ntoskrnl_unicode_to_ansi },
1690 { "RtlAnsiStringToUnicodeString", (FUNC)ntoskrnl_ansi_to_unicode },
1691 { "RtlInitAnsiString", (FUNC)ntoskrnl_init_ansi_string },
1692 { "RtlInitUnicodeString", (FUNC)ntoskrnl_init_unicode_string },
1693 { "RtlFreeAnsiString", (FUNC)ntoskrnl_free_ansi_string },
1694 { "RtlFreeUnicodeString", (FUNC)ntoskrnl_free_unicode_string },
1695 { "RtlUnicodeStringToInteger", (FUNC)ntoskrnl_unicode_to_int },
1696 { "sprintf", (FUNC)ksprintf },
1697 { "vsprintf", (FUNC)kvsprintf },
1698 { "_snprintf", (FUNC)ksnprintf },
1699 { "_vsnprintf", (FUNC)kvsnprintf },
1700 { "DbgPrint", (FUNC)ntoskrnl_dbgprint },
1701 { "DbgBreakPoint", (FUNC)ntoskrnl_debugger },
1702 { "strncmp", (FUNC)strncmp },
1703 { "strcmp", (FUNC)strcmp },
1704 { "strncpy", (FUNC)strncpy },
1705 { "strcpy", (FUNC)strcpy },
1706 { "strlen", (FUNC)strlen },
1707 { "memcpy", (FUNC)memcpy },
1708 { "memmove", (FUNC)memcpy },
1709 { "memset", (FUNC)memset },
1710 { "IofCallDriver", (FUNC)ntoskrnl_iofcalldriver },
1711 { "IofCompleteRequest", (FUNC)ntoskrnl_iofcompletereq },
1712 { "IoBuildSynchronousFsdRequest", (FUNC)ntoskrnl_iobuildsynchfsdreq },
1713 { "KeWaitForSingleObject", (FUNC)ntoskrnl_waitforobj },
1714 { "KeWaitForMultipleObjects", (FUNC)ntoskrnl_waitforobjs },
1715 { "_allmul", (FUNC)_allmul },
1716 { "_alldiv", (FUNC)_alldiv },
1717 { "_allrem", (FUNC)_allrem },
1718 { "_allshr", (FUNC)_allshr },
1719 { "_allshl", (FUNC)_allshl },
1720 { "_aullmul", (FUNC)_aullmul },
1721 { "_aulldiv", (FUNC)_aulldiv },
1722 { "_aullrem", (FUNC)_aullrem },
1723 { "_aullshr", (FUNC)_aullshr },
1724 { "_aullshl", (FUNC)_aullshl },
1725 { "atoi", (FUNC)atoi },
1726 { "atol", (FUNC)atol },
1727 { "rand", (FUNC)rand },
1728 { "WRITE_REGISTER_USHORT", (FUNC)ntoskrnl_writereg_ushort },
1729 { "READ_REGISTER_USHORT", (FUNC)ntoskrnl_readreg_ushort },
1730 { "WRITE_REGISTER_ULONG", (FUNC)ntoskrnl_writereg_ulong },
1731 { "READ_REGISTER_ULONG", (FUNC)ntoskrnl_readreg_ulong },
1732 { "READ_REGISTER_UCHAR", (FUNC)ntoskrnl_readreg_uchar },
1733 { "WRITE_REGISTER_UCHAR", (FUNC)ntoskrnl_writereg_uchar },
1734 { "ExInitializePagedLookasideList", (FUNC)ntoskrnl_init_lookaside },
1735 { "ExDeletePagedLookasideList", (FUNC)ntoskrnl_delete_lookaside },
1736 { "ExInitializeNPagedLookasideList", (FUNC)ntoskrnl_init_nplookaside },
1737 { "ExDeleteNPagedLookasideList", (FUNC)ntoskrnl_delete_nplookaside },
1738 { "InterlockedPopEntrySList", (FUNC)ntoskrnl_pop_slist },
1739 { "InterlockedPushEntrySList", (FUNC)ntoskrnl_push_slist },
1740 { "ExInterlockedPopEntrySList", (FUNC)ntoskrnl_pop_slist_ex },
1741 { "ExInterlockedPushEntrySList",(FUNC)ntoskrnl_push_slist_ex },
1742 { "KefAcquireSpinLockAtDpcLevel", (FUNC)ntoskrnl_lock_dpc },
1743 { "KefReleaseSpinLockFromDpcLevel", (FUNC)ntoskrnl_unlock_dpc },
1744 { "InterlockedIncrement", (FUNC)ntoskrnl_interlock_inc },
1745 { "InterlockedDecrement", (FUNC)ntoskrnl_interlock_dec },
1746 { "ExInterlockedAddLargeStatistic",
1747 (FUNC)ntoskrnl_interlock_addstat },
1748 { "IoFreeMdl", (FUNC)ntoskrnl_freemdl },
1749 { "MmSizeOfMdl", (FUNC)ntoskrnl_sizeofmdl },
1750 { "MmMapLockedPages", (FUNC)ntoskrnl_mmaplockedpages },
1751 { "MmMapLockedPagesSpecifyCache",
1752 (FUNC)ntoskrnl_mmaplockedpages_cache },
1753 { "MmUnmapLockedPages", (FUNC)ntoskrnl_munmaplockedpages },
1754 { "MmBuildMdlForNonPagedPool", (FUNC)ntoskrnl_build_npaged_mdl },
1755 { "KeInitializeSpinLock", (FUNC)ntoskrnl_init_lock },
1756 { "IoIsWdmVersionAvailable", (FUNC)ntoskrnl_wdmver },
1757 { "IoGetDeviceProperty", (FUNC)ntoskrnl_devprop },
1758 { "KeInitializeMutex", (FUNC)ntoskrnl_init_mutex },
1759 { "KeReleaseMutex", (FUNC)ntoskrnl_release_mutex },
1760 { "KeReadStateMutex", (FUNC)ntoskrnl_read_mutex },
1761 { "KeInitializeEvent", (FUNC)ntoskrnl_init_event },
1762 { "KeSetEvent", (FUNC)ntoskrnl_set_event },
1763 { "KeResetEvent", (FUNC)ntoskrnl_reset_event },
1764 { "KeClearEvent", (FUNC)ntoskrnl_clear_event },
1765 { "KeReadStateEvent", (FUNC)ntoskrnl_read_event },
1766 { "KeInitializeTimer", (FUNC)ntoskrnl_init_timer },
1767 { "KeInitializeTimerEx", (FUNC)ntoskrnl_init_timer_ex },
1768 { "KeSetTimer", (FUNC)ntoskrnl_set_timer },
1769 { "KeSetTimerEx", (FUNC)ntoskrnl_set_timer_ex },
1770 { "KeCancelTimer", (FUNC)ntoskrnl_cancel_timer },
1771 { "KeReadStateTimer", (FUNC)ntoskrnl_read_timer },
1772 { "KeInitializeDpc", (FUNC)ntoskrnl_init_dpc },
1773 { "KeInsertQueueDpc", (FUNC)ntoskrnl_queue_dpc },
1774 { "KeRemoveQueueDpc", (FUNC)ntoskrnl_dequeue_dpc },
1775 { "ObReferenceObjectByHandle", (FUNC)ntoskrnl_objref },
1776 { "ObfDereferenceObject", (FUNC)ntoskrnl_objderef },
1777 { "ZwClose", (FUNC)ntoskrnl_zwclose },
1778 { "PsCreateSystemThread", (FUNC)ntoskrnl_create_thread },
1779 { "PsTerminateSystemThread", (FUNC)ntoskrnl_thread_exit },
1782 * This last entry is a catch-all for any function we haven't
1783 * implemented yet. The PE import list patching routine will
1784 * use it for any function that doesn't have an explicit match
1788 { NULL, (FUNC)dummy },