← Back to branch summary

~ubuntu-branches/ubuntu/lucid/ndiswrapper/lucid

« back to all changes in this revision

Viewing changes to driver/ntoskernel.h

  • Committer: Bazaar Package Importer
  • Author(s): Scott James Remnant
  • Date: 2005-11-16 23:39:48 UTC
  • mfrom: (1.2.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051116233948-00yddqygl6w65vzg
Tags: 1.5-1ubuntu1
Resynchronise with Debian.  (Totally me!)

Show diffs side-by-side

added added

removed removed

Lines of Context:
driver/ntoskernel.h
16
16
#ifndef _NTOSKERNEL_H_
17
17
#define _NTOSKERNEL_H_
18
18
 
 
19
#define UTILS_VERSION "1.5"
 
20
 
19
21
#include <linux/types.h>
20
22
#include <linux/timer.h>
21
23
#include <linux/time.h>
29
31
#include <linux/mm.h>
30
32
#include <linux/random.h>
31
33
#include <linux/ctype.h>
 
34
#include <linux/list.h>
 
35
#include <linux/sched.h>
32
36
#include <linux/usb.h>
33
 
 
34
37
#include <linux/spinlock.h>
35
38
#include <asm/mman.h>
36
 
 
37
39
#include <linux/version.h>
 
40
#include <linux/etherdevice.h>
 
41
#include <net/iw_handler.h>
 
42
#include <linux/netdevice.h>
 
43
#include <linux/ethtool.h>
 
44
#include <linux/if_arp.h>
 
45
#include <linux/rtnetlink.h>
38
46
 
39
47
#include "winnt_types.h"
40
48
#include "ndiswrapper.h"
44
52
#include <linux/kthread.h>
45
53
#endif
46
54
 
 
55
#if defined(DISABLE_USB)
 
56
#undef CONFIG_USB
 
57
#undef CONFIG_USB_MODULE
 
58
#endif
 
59
 
47
60
#if !defined(CONFIG_USB) && defined(CONFIG_USB_MODULE)
48
61
#define CONFIG_USB 1
49
62
#endif
50
63
 
51
 
#define addr_offset(driver) (__builtin_return_address(0) - (driver)->entry)
 
64
#define addr_offset(drvr) (__builtin_return_address(0) - \
 
65
                             (drvr)->drv_obj->driver_start)
52
66
 
53
67
/* Workqueue / task queue backwards compatibility stuff */
54
68
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,41)
61
75
 
62
76
#define PCI_DMA_ALLOC_COHERENT(pci_dev,size,dma_handle) \
63
77
        dma_alloc_coherent(&pci_dev->dev,size,dma_handle, \
64
 
                           GFP_KERNEL | __GFP_REPEAT)
 
78
                           GFP_KERNEL | __GFP_REPEAT | GFP_DMA)
65
79
#define PCI_DMA_FREE_COHERENT(pci_dev,size,cpu_addr,dma_handle) \
66
80
        dma_free_coherent(&pci_dev->dev,size,cpu_addr,dma_handle)
67
81
#define PCI_DMA_MAP_SINGLE(pci_dev,addr,size,direction) \
150
164
#define preempt_disable() do { } while (0)
151
165
#endif
152
166
 
 
167
#ifndef preempt_enable_no_resched
 
168
#define preempt_enable_no_resched() preempt_enable()
 
169
#endif
 
170
 
153
171
#ifndef container_of
154
172
#define container_of(ptr, type, member)                                 \
155
173
({                                                                      \
168
186
 
169
187
#endif // LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
170
188
 
171
 
#ifdef CONFIG_SOFTWARE_SUSPEND2
 
189
#ifndef PMSG_SUSPEND
 
190
#ifdef PM_SUSPEND
 
191
/* this is not correct - the value of PM_SUSPEND is different from
 
192
 * PMSG_SUSPEND, but ndiswrapper doesn't care about the value when
 
193
 * suspending */
 
194
#define PMSG_SUSPEND PM_SUSPEND
 
195
#define PSMG_ON PM_ON
 
196
#else
 
197
typedef u32 pm_message_t;
 
198
#define PMSG_SUSPEND 3
 
199
#define PMSG_ON 0
 
200
#endif
 
201
#endif
 
202
 
 
203
#ifndef PCI_D0
 
204
#define PCI_D0 0
 
205
#define PCI_D3hot 3
 
206
#endif
 
207
 
 
208
#ifndef PM_EVENT_SUSPEND
 
209
#define PM_EVENT_SUSPEND 2
 
210
#endif
 
211
 
 
212
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,9)
 
213
#define pci_choose_state(dev, state) (state)
 
214
#endif
 
215
 
 
216
#if defined(CONFIG_SOFTWARE_SUSPEND2) || defined(CONFIG_SUSPEND2)
172
217
#define KTHREAD_RUN(a,b,c) kthread_run(a,b,0,c)
173
218
#else
174
219
#define KTHREAD_RUN(a,b,c) kthread_run(a,b,c)
175
220
#endif
176
221
 
 
222
#if !defined(HAVE_NETDEV_PRIV)
 
223
#define netdev_priv(dev)  ((dev)->priv)
 
224
#endif
 
225
 
177
226
#ifdef CONFIG_X86_64
178
227
#define LIN2WIN1(func, arg1)                    \
179
228
        lin_to_win1(func, (unsigned long)arg1)
282
331
#endif
283
332
 
284
333
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,9)
285
 
#define NW_MODULE_PARM_INT(name, perm) module_param(name, int, perm)
286
 
#define NW_MODULE_PARM_STRING(name, perm) module_param(name, charp, perm)
 
334
#define WRAP_MODULE_PARM_INT(name, perm) module_param(name, int, perm)
 
335
#define WRAP_MODULE_PARM_STRING(name, perm) module_param(name, charp, perm)
287
336
#else
288
 
#define NW_MODULE_PARM_INT(name, perm) MODULE_PARM(name, "i")
289
 
#define NW_MODULE_PARM_STRING(name, perm) MODULE_PARM(name, "s")
 
337
#define WRAP_MODULE_PARM_INT(name, perm) MODULE_PARM(name, "i")
 
338
#define WRAP_MODULE_PARM_STRING(name, perm) MODULE_PARM(name, "s")
290
339
#endif
291
340
 
292
341
/* this ugly hack is to handle RH kernels; I don't know any better,
298
347
#define KMALLOC_THRESHOLD 131072
299
348
 
300
349
/* TICK is 100ns */
301
 
#define TICKSPERSEC             10000000
302
 
#define SECSPERDAY              86400
 
350
#define TICKSPERSEC             10000000LL
 
351
#define TICKSPERMSEC            10000
 
352
#define SECSPERDAY              86400
 
353
#define SECSPERHOUR             3600
 
354
#define SECSPERMIN              60
 
355
#define DAYSPERWEEK             7
303
356
 
304
357
/* 1601 to 1970 is 369 years plus 89 leap days */
305
 
#define SECS_1601_TO_1970       ((369 * 365 + 89) * (u64)SECSPERDAY)
306
 
#define TICKS_1601_TO_1970      (SECS_1601_TO_1970 * TICKSPERSEC)
307
 
 
308
 
#define UNIMPL() do {                                                   \
309
 
                printk(KERN_ERR "%s --UNIMPLEMENTED--\n", __FUNCTION__ ); \
310
 
        } while (0)
 
358
#define SECS_1601_TO_1970       ((369 * 365 + 89) * (u64)SECSPERDAY)
 
359
#define TICKS_1601_TO_1970      (SECS_1601_TO_1970 * TICKSPERSEC)
 
360
 
 
361
/* 100ns units to HZ; if sys_time is negative, relative to current
 
362
 * clock, otherwise from year 1601 */
 
363
#define SYSTEM_TIME_TO_HZ(sys_time)                                     \
 
364
        ((((sys_time) <= 0) ? (((u64)HZ * (-(sys_time))) / TICKSPERSEC) : \
 
365
          (((u64)HZ * ((sys_time) - ticks_1601())) / TICKSPERSEC)))
 
366
 
 
367
#define MSEC_TO_HZ(ms) ((ms) * HZ / 1000)
 
368
#define USEC_TO_HZ(ms) ((us) * HZ / 1000000)
 
369
 
 
370
extern u64 wrap_ticks_to_boot;
 
371
 
 
372
static inline u64 ticks_1601(void)
 
373
{
 
374
        return wrap_ticks_to_boot + (u64)jiffies * TICKSPERSEC / HZ;
 
375
}
311
376
 
312
377
typedef void (*WRAP_EXPORT_FUNC)(void);
313
378
 
320
385
#define WRAP_EXPORT_SYMBOL(f) {#f, (WRAP_EXPORT_FUNC)x86_64_ ## f}
321
386
#define WRAP_EXPORT_WIN_FUNC(f) {#f, (WRAP_EXPORT_FUNC)x86_64__win_ ## f}
322
387
#define WRAP_FUNC_PTR(f) &x86_64_ ## f
 
388
#define WRAP_FUNC_PTR_DECL(f) void x86_64_ ## f(void);
323
389
#else
324
390
#define WRAP_EXPORT_SYMBOL(f) {#f, (WRAP_EXPORT_FUNC)f}
325
391
#define WRAP_EXPORT_WIN_FUNC(f) {#f, (WRAP_EXPORT_FUNC)_win_ ## f}
326
392
#define WRAP_FUNC_PTR(f) &f
 
393
#define WRAP_FUNC_PTR_DECL(f)
327
394
#endif
328
395
/* map name s to function f - if f is different from s */
329
396
#define WRAP_EXPORT_MAP(s,f)
330
397
#define WRAP_EXPORT(x) x
331
398
 
 
399
#define POOL_TAG(A, B, C, D)                                    \
 
400
        ((ULONG)((A) + ((B) << 8) + ((C) << 16) + ((D) << 24)))
 
401
 
332
402
struct wrap_alloc {
333
 
        struct list_head list;
 
403
        struct nt_list list;
334
404
        void *ptr;
335
405
};
336
406
 
348
418
extern KSPIN_LOCK atomic_lock;
349
419
extern KSPIN_LOCK cancel_lock;
350
420
 
351
 
#define DEBUG_IRQL 1
 
421
//#define DEBUG_IRQL 1
352
422
 
353
 
#define WRAPPER_TIMER_MAGIC 47697249
354
 
struct wrapper_timer {
355
 
        struct list_head list;
 
423
struct wrap_timer {
 
424
        long repeat;
 
425
        struct nt_list list;
356
426
        struct timer_list timer;
 
427
        struct nt_timer *nt_timer;
357
428
#ifdef DEBUG_TIMER
358
 
        unsigned long wrapper_timer_magic;
 
429
        unsigned long wrap_timer_magic;
359
430
#endif
360
 
        long repeat;
361
 
        int active;
362
 
        struct ktimer *ktimer;
363
 
        struct kdpc *kdpc;
364
 
        KSPIN_LOCK lock;
 
431
};
 
432
 
 
433
struct wrap_work_item {
 
434
        struct nt_list list;
 
435
        void *arg1;
 
436
        void *arg2;
 
437
        void *func;
 
438
        BOOLEAN win_func;
365
439
};
366
440
 
367
441
typedef struct mdl ndis_buffer;
368
442
 
 
443
#define MAX_ALLOCATED_URBS 15
 
444
 
 
445
struct phys_dev {
 
446
        int dev_type;
 
447
        struct pci_dev *pci;
 
448
        struct {
 
449
                struct usb_device *udev;
 
450
                struct usb_interface *intf;
 
451
                int num_alloc_urbs;
 
452
                struct nt_list wrap_urb_list;
 
453
        } usb;
 
454
};
 
455
 
 
456
struct wrapper_dev;
 
457
 
 
458
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
 
459
/* until issues with threads hogging cpu are resolved, we don't want
 
460
 * to use shared workqueue, lest the threads take keyboard etc down */
 
461
#define USE_OWN_WORKQUEUE 1
 
462
extern struct workqueue_struct *ndiswrapper_wq;
 
463
#define schedule_work(work_struct) queue_work(ndiswrapper_wq, (work_struct))
 
464
#endif
 
465
 
369
466
int ntoskernel_init(void);
370
467
void ntoskernel_exit(void);
 
468
int ntoskernel_init_device(struct wrapper_dev *wd);
 
469
void ntoskernel_exit_device(struct wrapper_dev *wd);
 
470
void *allocate_object(ULONG size, enum common_object_type type,
 
471
                      struct unicode_string *name);
 
472
void  free_object(void *object);
 
473
 
 
474
struct driver_object *find_bus_driver(const char *name);
 
475
struct device_object *alloc_pdo(struct driver_object *drv_obj);
 
476
void free_pdo(struct device_object *drv_obj);
 
477
 
 
478
STDCALL void WRITE_PORT_UCHAR(ULONG_PTR port, UCHAR value);
 
479
STDCALL UCHAR READ_PORT_UCHAR(ULONG_PTR port);
 
480
 
371
481
STDCALL void *ExAllocatePoolWithTag(enum pool_type pool_type, SIZE_T size,
372
482
                                    ULONG tag);
373
483
STDCALL void ExFreePool(void *p);
374
484
STDCALL ULONG MmSizeOfMdl(void *base, ULONG length);
375
 
STDCALL void KeInitializeEvent(struct kevent *kevent,
 
485
STDCALL void *MmMapIoSpace(PHYSICAL_ADDRESS phys_addr, SIZE_T size,
 
486
                           enum memory_caching_type cache);
 
487
STDCALL void MmUnmapIoSpace(void *addr, SIZE_T size);
 
488
STDCALL void KeInitializeEvent(struct nt_event *nt_event,
376
489
                               enum event_type type, BOOLEAN state);
377
 
STDCALL LONG KeSetEvent(struct kevent *kevent, KPRIORITY incr, BOOLEAN wait);
378
 
STDCALL LONG KeResetEvent(struct kevent *kevent);
 
490
STDCALL LONG KeSetEvent(struct nt_event *nt_event, KPRIORITY incr,
 
491
                        BOOLEAN wait);
 
492
STDCALL LONG KeResetEvent(struct nt_event *nt_event);
 
493
STDCALL void KeClearEvent(struct nt_event *nt_event);
 
494
STDCALL void KeInitializeDpc(struct kdpc *kdpc, void *func, void *ctx);
 
495
STDCALL BOOLEAN KeInsertQueueDpc(struct kdpc *kdpc, void *arg1, void *arg2);
 
496
STDCALL BOOLEAN KeRemoveQueueDpc(struct kdpc *kdpc);
 
497
STDCALL void KeFlushQueuedDpcs(void);
379
498
STDCALL NTSTATUS KeWaitForSingleObject(void *object, KWAIT_REASON reason,
380
 
                                        KPROCESSOR_MODE waitmode,
381
 
                                        BOOLEAN alertable,
382
 
                                        LARGE_INTEGER *timeout);
 
499
                                       KPROCESSOR_MODE waitmode,
 
500
                                       BOOLEAN alertable,
 
501
                                       LARGE_INTEGER *timeout);
383
502
struct mdl *allocate_init_mdl(void *virt, ULONG length);
384
503
void free_mdl(struct mdl *mdl);
385
504
STDCALL struct mdl *IoAllocateMdl(void *virt, ULONG length, BOOLEAN second_buf,
386
505
                                  BOOLEAN charge_quota, struct irp *irp);
 
506
STDCALL void MmBuildMdlForNonPagedPool(struct mdl *mdl);
387
507
STDCALL void IoFreeMdl(struct mdl *mdl);
388
508
STDCALL void NdisFreeBuffer(ndis_buffer *buffer);
389
 
ULONGLONG ticks_1601(void);
 
509
_FASTCALL LONG InterlockedDecrement(FASTCALL_DECL_1(LONG volatile *val));
 
510
_FASTCALL LONG InterlockedIncrement(FASTCALL_DECL_1(LONG volatile *val));
 
511
_FASTCALL struct nt_list *
 
512
ExInterlockedInsertHeadList(FASTCALL_DECL_3(struct nt_list *head,
 
513
                                            struct nt_list *entry,
 
514
                                            KSPIN_LOCK *lock));
 
515
_FASTCALL struct nt_list *
 
516
ExInterlockedInsertTailList(FASTCALL_DECL_3(struct nt_list *head,
 
517
                                            struct nt_list *entry,
 
518
                                            KSPIN_LOCK *lock));
 
519
_FASTCALL struct nt_list *
 
520
ExInterlockedRemoveHeadList(FASTCALL_DECL_2(struct nt_list *head,
 
521
                                            KSPIN_LOCK *lock));
 
522
STDCALL NTSTATUS IoCreateDevice(struct driver_object *driver,
 
523
                                ULONG dev_ext_length,
 
524
                                struct unicode_string *dev_name,
 
525
                                DEVICE_TYPE dev_type,
 
526
                                ULONG dev_chars, BOOLEAN exclusive,
 
527
                                struct device_object **dev_obj);
 
528
STDCALL NTSTATUS IoCreateSymbolicLink(struct unicode_string *link,
 
529
                                      struct unicode_string *dev_name);
 
530
STDCALL void IoDeleteDevice(struct device_object *dev);
 
531
STDCALL void IoDetachDevice(struct device_object *topdev);
 
532
STDCALL struct device_object *IoGetAttachedDevice(struct device_object *dev);
 
533
STDCALL NTSTATUS
 
534
IoAllocateDriverObjectExtension(struct driver_object *drv_obj,
 
535
                                void *client_id, ULONG extlen, void **ext);
 
536
STDCALL void *IoGetDriverObjectExtension(struct driver_object *drv,
 
537
                                         void *client_id);
 
538
STDCALL struct device_object *IoAttachDeviceToDeviceStack
 
539
        (struct device_object *src, struct device_object *dst);
 
540
STDCALL void KeInitializeEvent(struct nt_event *nt_event, enum event_type type,
 
541
                               BOOLEAN state);
 
542
void free_custom_ext(struct driver_extension *drv_obj_ext);
 
543
STDCALL NTSTATUS AddDevice(struct driver_object *drv_obj,
 
544
                           struct device_object *pdo);
 
545
void DeleteDevice(struct device_object *pdo);
 
546
 
 
547
driver_dispatch_t IopInvalidDeviceRequest;
 
548
driver_dispatch_t IopPassIrpDown;
 
549
driver_dispatch_t pdoDispatchInternalDeviceControl;
 
550
driver_dispatch_t pdoDispatchDeviceControl;
 
551
driver_dispatch_t pdoDispatchPnp;
 
552
driver_dispatch_t pdoDispatchPower;
 
553
driver_dispatch_t IopPassIrpDownAndWait;
 
554
driver_dispatch_t fdoDispatchPnp;
 
555
 
 
556
STDCALL struct irp *IoAllocateIrp(char stack_size, BOOLEAN charge_quota);
 
557
STDCALL void IoFreeIrp(struct irp *irp);
 
558
STDCALL BOOLEAN IoCancelIrp(struct irp *irp);
 
559
_FASTCALL NTSTATUS IofCallDriver
 
560
        (FASTCALL_DECL_2(struct device_object *dev_obj, struct irp *irp));
 
561
STDCALL struct irp *WRAP_EXPORT(IoBuildSynchronousFsdRequest)
 
562
        (ULONG major_func, struct device_object *dev_obj, void *buf,
 
563
         ULONG length, LARGE_INTEGER *offset, struct nt_event *event,
 
564
         struct io_status_block *status);
 
565
STDCALL struct irp *WRAP_EXPORT(IoBuildAsynchronousFsdRequest)
 
566
        (ULONG major_func, struct device_object *dev_obj, void *buf,
 
567
         ULONG length, LARGE_INTEGER *offset,
 
568
         struct io_status_block *status);
 
569
STDCALL NTSTATUS PoCallDriver(struct device_object *dev_obj, struct irp *irp);
 
570
 
 
571
struct nt_thread *wrap_create_thread(struct task_struct *task);
 
572
void wrap_remove_thread(struct nt_thread *thread);
 
573
u64 ticks_1601(void);
 
574
 
 
575
int schedule_wrap_work_item(void *func, void *arg1, void *arg2,
 
576
                            BOOLEAN win_func);
390
577
 
391
578
STDCALL KIRQL KeGetCurrentIrql(void);
392
579
STDCALL void KeInitializeSpinLock(KSPIN_LOCK *lock);
394
581
STDCALL void KeReleaseSpinLock(KSPIN_LOCK *lock, KIRQL oldirql);
395
582
STDCALL KIRQL KeAcquireSpinLockRaiseToDpc(KSPIN_LOCK *lock);
396
583
 
 
584
STDCALL void IoAcquireCancelSpinLock(KIRQL *irql);
 
585
STDCALL void IoReleaseCancelSpinLock(KIRQL irql);
 
586
 
397
587
_FASTCALL KIRQL KfRaiseIrql(FASTCALL_DECL_1(KIRQL newirql));
398
588
_FASTCALL void KfLowerIrql(FASTCALL_DECL_1(KIRQL oldirql));
399
589
_FASTCALL KIRQL KfAcquireSpinLock(FASTCALL_DECL_1(KSPIN_LOCK *lock));
403
593
IofCompleteRequest(FASTCALL_DECL_2(struct irp *irp, CHAR prio_boost));
404
594
_FASTCALL void
405
595
KefReleaseSpinLockFromDpcLevel(FASTCALL_DECL_1(KSPIN_LOCK *lock));
 
596
STDCALL void RtlCopyMemory(void *dst, const void *src, SIZE_T length);
406
597
STDCALL NTSTATUS RtlUnicodeStringToAnsiString(struct ansi_string *dst,
407
 
                                               struct unicode_string *src,
408
 
                                               BOOLEAN dup);
 
598
                                              const struct unicode_string *src,
 
599
                                              BOOLEAN dup);
409
600
STDCALL NTSTATUS RtlAnsiStringToUnicodeString(struct unicode_string *dst,
410
 
                                               struct ansi_string *src,
 
601
                                               const struct ansi_string *src,
411
602
                                               BOOLEAN dup);
412
 
STDCALL void RtlInitAnsiString(struct ansi_string *dst, CHAR *src);
413
 
STDCALL void RtlInitString(struct ansi_string *dst, CHAR *src);
 
603
STDCALL void RtlInitAnsiString(struct ansi_string *dst, const char *src);
 
604
STDCALL void RtlInitString(struct ansi_string *dst, const char *src);
 
605
STDCALL void RtlInitUnicodeString(struct unicode_string *dest,
 
606
                                  const wchar_t *src);
414
607
STDCALL void RtlFreeUnicodeString(struct unicode_string *string);
415
608
STDCALL void RtlFreeAnsiString(struct ansi_string *string);
 
609
STDCALL LONG RtlCompareUnicodeString
 
610
        (const struct unicode_string *s1, const struct unicode_string *s2,
 
611
         BOOLEAN case_insensitive);
 
612
STDCALL void RtlCopyUnicodeString
 
613
        (struct unicode_string *dst, struct unicode_string *src);
 
614
NOREGPARM SIZE_T _win_wcslen(const wchar_t *s);
 
615
 
 
616
void *wrap_kmalloc(size_t size);
 
617
void wrap_kfree(void *ptr);
 
618
void wrap_init_timer(struct nt_timer *nt_timer, enum timer_type type,
 
619
                     struct wrapper_dev *wd);
 
620
BOOLEAN wrap_set_timer(struct nt_timer *nt_timer, unsigned long expires_hz,
 
621
                       unsigned long repeat_hz, struct kdpc *kdpc);
 
622
 
 
623
STDCALL void KeInitializeTimer(struct nt_timer *nt_timer);
 
624
STDCALL void KeInitializeTimerEx(struct nt_timer *nt_timer,
 
625
                                 enum timer_type type);
 
626
STDCALL BOOLEAN KeSetTimerEx(struct nt_timer *nt_timer,
 
627
                             LARGE_INTEGER duetime_ticks, LONG period_ms,
 
628
                             struct kdpc *kdpc);
 
629
STDCALL BOOLEAN KeSetTimer(struct nt_timer *nt_timer,
 
630
                           LARGE_INTEGER duetime_ticks, struct kdpc *kdpc);
 
631
STDCALL BOOLEAN KeCancelTimer(struct nt_timer *nt_timer);
 
632
STDCALL void KeInitializeDpc(struct kdpc *kdpc, void *func, void *ctx);
416
633
 
417
634
unsigned long lin_to_win1(void *func, unsigned long);
418
635
unsigned long lin_to_win2(void *func, unsigned long, unsigned long);
426
643
                          unsigned long, unsigned long, unsigned long,
427
644
                          unsigned long);
428
645
 
 
646
STDCALL struct nt_thread *KeGetCurrentThread(void);
 
647
STDCALL NTSTATUS
 
648
ObReferenceObjectByHandle(void *handle, ACCESS_MASK desired_access,
 
649
                          void *obj_type, KPROCESSOR_MODE access_mode,
 
650
                          void **object, void *handle_info);
 
651
 
 
652
_FASTCALL LONG ObfReferenceObject(FASTCALL_DECL_1(void *object));
 
653
_FASTCALL void ObfDereferenceObject(FASTCALL_DECL_1(void *object));
 
654
STDCALL NTSTATUS ZwClose(void *object);
 
655
#define ObReferenceObject(object)                       \
 
656
        ObfReferenceObject(FASTCALL_ARGS_1(object))
 
657
#define ObDereferenceObject(object)                     \
 
658
        ObfDereferenceObject(FASTCALL_ARGS_1(object))
 
659
 
429
660
#define MSG(level, fmt, ...)                            \
430
661
        printk(level "ndiswrapper (%s:%d): " fmt "\n",  \
431
662
               __FUNCTION__, __LINE__ , ## __VA_ARGS__)
433
664
#define ERROR(fmt, ...) MSG(KERN_ERR, fmt , ## __VA_ARGS__)
434
665
#define INFO(fmt, ...) MSG(KERN_INFO, fmt , ## __VA_ARGS__)
435
666
 
 
667
#define INFOEXIT(stmt) do { INFO("Exit"); stmt; } while(0)
 
668
 
 
669
#define UNIMPL() ERROR("--UNIMPLEMENTED--")
 
670
 
 
671
void adjust_user_shared_data_addr(char *driver, unsigned long length);
 
672
 
 
673
#define IoCompleteRequest(irp, prio)                    \
 
674
        IofCompleteRequest(FASTCALL_ARGS_2(irp, prio));
 
675
#define IoCallDriver(dev, irp)                          \
 
676
        IofCallDriver(FASTCALL_ARGS_2(dev, irp));
 
677
 
436
678
static inline KIRQL current_irql(void)
437
679
{
438
680
        if (in_atomic() || irqs_disabled())
444
686
static inline KIRQL raise_irql(KIRQL newirql)
445
687
{
446
688
        KIRQL irql = current_irql();
447
 
        if (irql < DISPATCH_LEVEL && newirql == DISPATCH_LEVEL) {
 
689
        if (irql < DISPATCH_LEVEL && newirql >= DISPATCH_LEVEL) {
448
690
                local_bh_disable();
449
691
                preempt_disable();
450
692
        }
454
696
static inline void lower_irql(KIRQL oldirql)
455
697
{
456
698
        KIRQL irql = current_irql();
457
 
        if (oldirql < DISPATCH_LEVEL && irql == DISPATCH_LEVEL) {
 
699
        if (oldirql < DISPATCH_LEVEL && irql >= DISPATCH_LEVEL) {
458
700
                preempt_enable();
459
701
                local_bh_enable();
460
702
        }
470
712
 * lock seems to be 0 (presumably in Windows value of unlocked
471
713
 * spinlock is 0).
472
714
 */
 
715
 
 
716
/* define CONFIG_DEBUG_SPINLOCK if a Windows driver is suspected of
 
717
 * obtaining a lock while holding the same lock */
 
718
 
 
719
//#ifndef CONFIG_DEBUG_SPINLOCK
 
720
//#define CONFIG_DEBUG_SPINLOCK
 
721
//#endif
 
722
 
 
723
#undef CONFIG_DEBUG_SPINLOCK
 
724
 
 
725
#ifdef CONFIG_DEBUG_SPINLOCK
 
726
#define KSPIN_LOCK_LOCKED ((ULONG_PTR)get_current())
 
727
#else
 
728
#define KSPIN_LOCK_LOCKED 1
 
729
#endif
 
730
 
473
731
#define KSPIN_LOCK_UNLOCKED 0
474
 
#define KSPIN_LOCK_LOCKED 1
475
732
 
476
733
#define kspin_lock_init(lock) *(lock) = KSPIN_LOCK_UNLOCKED
477
734
 
478
735
#ifdef CONFIG_SMP
479
736
 
480
 
#ifdef __HAVE_ARCH_CMPXCHG
 
737
#define raw_kspin_lock(lock)                                            \
 
738
        while (cmpxchg((lock), KSPIN_LOCK_UNLOCKED, KSPIN_LOCK_LOCKED) != \
 
739
               KSPIN_LOCK_UNLOCKED)
 
740
 
 
741
#ifdef CONFIG_DEBUG_SPINLOCK
 
742
#define raw_kspin_unlock(lock)                                          \
 
743
        __asm__ __volatile__("movw $0,%0"                               \
 
744
                             :"=m" (*(lock)) : : "memory")
 
745
#else // DEBUG_SPINLOCK
 
746
#define raw_kspin_unlock(lock)                                          \
 
747
        __asm__ __volatile__("movb $0,%0"                               \
 
748
                             :"=m" (*(lock)) : : "memory")
 
749
#endif // DEBUG_SPINLOCK
 
750
 
 
751
#else // SMP
 
752
 
 
753
#define raw_kspin_lock(lock) *(lock) = KSPIN_LOCK_LOCKED
 
754
#define raw_kspin_unlock(lock) *(lock) = KSPIN_LOCK_UNLOCKED
 
755
 
 
756
#endif // SMP
 
757
 
 
758
#ifdef CONFIG_DEBUG_SPINLOCK
481
759
 
482
760
#define kspin_lock(lock)                                                \
483
 
        while (cmpxchg(lock, KSPIN_LOCK_UNLOCKED, KSPIN_LOCK_LOCKED) != \
484
 
               KSPIN_LOCK_UNLOCKED)
485
 
 
486
 
#else
487
 
 
488
 
extern spinlock_t spinlock_kspin_lock;
489
 
#define kspin_lock(lock)                                \
490
 
do {                                                    \
491
 
        while (1) {                                     \
492
 
                spin_lock(&spinlock_kspin_lock);        \
493
 
                if (*(lock) == KSPIN_LOCK_UNLOCKED)     \
494
 
                        break;                          \
495
 
                spin_unlock(&spinlock_kspin_lock);      \
496
 
        }                                               \
497
 
        *(lock) = KSPIN_LOCK_LOCKED;                    \
498
 
        spin_unlock(&spinlock_kspin_lock);              \
499
 
} while (0)
500
 
                
501
 
#endif // __HAVE_ARCH_CMPXCHG
502
 
 
503
 
#define kspin_unlock(lock) xchg(lock, KSPIN_LOCK_UNLOCKED)
504
 
 
505
 
#else
506
 
 
507
 
#define kspin_lock(lock) *(lock) = KSPIN_LOCK_LOCKED
508
 
#define kspin_unlock(lock) *(lock) = KSPIN_LOCK_UNLOCKED
509
 
 
510
 
#endif // CONFIG_SMP
511
 
 
512
 
/* raise IRQL to given (higher) IRQL if necessary after locking */
 
761
        do {                                                            \
 
762
                if (*(lock) == KSPIN_LOCK_LOCKED)                       \
 
763
                        ERROR("eeek: process %p already owns lock %p",  \
 
764
                              get_current(), lock);                     \
 
765
                else                                                    \
 
766
                        raw_kspin_lock(lock);                           \
 
767
        } while (0)
 
768
#define kspin_unlock(lock)                                              \
 
769
        do {                                                            \
 
770
                if (*(lock) != KSPIN_LOCK_LOCKED)                       \
 
771
                        ERROR("kspin_lock %p not locked!", (lock));     \
 
772
                raw_kspin_unlock(lock);                                 \
 
773
        } while (0)
 
774
 
 
775
#else // DEBUG_SPINLOCK
 
776
 
 
777
#define kspin_lock(lock) raw_kspin_lock(lock)
 
778
#define kspin_unlock(lock) raw_kspin_unlock(lock)
 
779
 
 
780
#endif // DEBUG_SPINLOCK
 
781
 
 
782
/* raise IRQL to given (higher) IRQL if necessary before locking */
513
783
#define kspin_lock_irql(lock, newirql)                                  \
514
784
({                                                                      \
515
785
        KIRQL _cur_irql_ = current_irql();                              \
516
 
        KSPIN_LOCK _val_ = *(lock);                                     \
517
 
        if (_val_ > KSPIN_LOCK_LOCKED)                                  \
518
 
                ERROR("illegal spinlock: %p(%lu)", lock, _val_);        \
519
786
        if (_cur_irql_ < DISPATCH_LEVEL && newirql == DISPATCH_LEVEL) { \
520
787
                local_bh_disable();                                     \
521
788
                preempt_disable();                                      \
528
795
#define kspin_unlock_irql(lock, oldirql)                                \
529
796
do {                                                                    \
530
797
        KIRQL _cur_irql_ = current_irql();                              \
531
 
        KSPIN_LOCK _val_ = *(lock);                                     \
532
 
        if (_val_ > KSPIN_LOCK_LOCKED)                                  \
533
 
                ERROR("illegal spinlock: %p(%lu)", lock, _val_);        \
534
798
        kspin_unlock(lock);                                             \
535
799
        if (oldirql < DISPATCH_LEVEL && _cur_irql_ == DISPATCH_LEVEL) { \
536
 
                preempt_enable();                                       \
 
800
                preempt_enable_no_resched();                            \
537
801
                local_bh_enable();                                      \
538
802
        }                                                               \
539
803
} while (0)
540
804
 
541
805
#define kspin_lock_irqsave(lock, flags)                                 \
542
806
do {                                                                    \
543
 
        KSPIN_LOCK _val_ = *(lock);                                     \
544
 
        if (_val_ > KSPIN_LOCK_LOCKED)                                  \
545
 
                ERROR("illegal spinlock: %p(%lu)", lock, _val_);        \
546
807
        local_irq_save(flags);                                          \
547
808
        preempt_disable();                                              \
548
809
        kspin_lock(lock);                                               \
550
811
 
551
812
#define kspin_unlock_irqrestore(lock, flags)                            \
552
813
do {                                                                    \
553
 
        KSPIN_LOCK _val_ = *(lock);                                     \
554
 
        if (_val_ > KSPIN_LOCK_LOCKED)                                  \
555
 
                ERROR("illegal spinlock: %p(%lu)", lock, _val_);        \
556
814
        kspin_unlock(lock);                                             \
557
815
        local_irq_restore(flags);                                       \
558
816
        preempt_enable();                                               \
559
817
} while (0)
560
818
 
561
 
static inline void wrapper_set_timer_dpc(struct wrapper_timer *wrapper_timer,
562
 
                                         struct kdpc *kdpc)
563
 
{
564
 
        wrapper_timer->kdpc = kdpc;
565
 
}
566
 
 
567
 
static inline void init_dpc(struct kdpc *kdpc, void *func, void *ctx)
568
 
{
569
 
        kdpc->func = func;
570
 
        kdpc->ctx  = ctx;
571
 
}
572
 
 
573
819
static inline ULONG SPAN_PAGES(ULONG_PTR ptr, SIZE_T length)
574
820
{
575
821
        ULONG n;
588
834
#define DBGTRACE3(fmt, ...) do { }  while (0)
589
835
#define DBGTRACE4(fmt, ...) do { } while (0)
590
836
#define DBGTRACE5(fmt, ...) do { } while (0)
 
837
#define DBGTRACE6(fmt, ...) do { } while (0)
591
838
 
592
839
/* for a block of code */
593
840
#define DBG_BLOCK() while (0)
597
844
#if defined DEBUG
598
845
#undef DBGTRACE
599
846
#define DBGTRACE(level, fmt, ...) do {                                  \
600
 
                if (level <= debug)                                     \
 
847
                if (debug >= level)                                     \
601
848
                        printk(KERN_INFO "%s (%s:%d): " fmt "\n",       \
602
849
                               DRIVER_NAME, __FUNCTION__,               \
603
850
                               __LINE__ , ## __VA_ARGS__);              \
606
853
#define DBG_BLOCK()
607
854
#endif
608
855
 
609
 
#if defined DEBUG && DEBUG >= 1
 
856
#if defined(DEBUG) && DEBUG >= 1
610
857
#undef DBGTRACE1
611
858
#define DBGTRACE1(fmt, ...) DBGTRACE(1, fmt , ## __VA_ARGS__)
612
859
#endif
613
860
 
614
 
#if defined DEBUG && DEBUG >= 2
 
861
#if defined(DEBUG) && DEBUG >= 2
615
862
#undef DBGTRACE2
616
863
#define DBGTRACE2(fmt, ...) DBGTRACE(2, fmt , ## __VA_ARGS__)
617
864
#endif
618
865
 
619
 
#if defined DEBUG && DEBUG >= 3
 
866
#if defined(DEBUG) && DEBUG >= 3
620
867
#undef DBGTRACE3
621
868
#define DBGTRACE3(fmt, ...) DBGTRACE(3, fmt , ## __VA_ARGS__)
622
869
#endif
623
870
 
624
 
#if defined DEBUG && DEBUG >= 4
 
871
#if defined(DEBUG) && DEBUG >= 4
625
872
#undef DBGTRACE4
626
873
#define DBGTRACE4(fmt, ...) DBGTRACE(4, fmt , ## __VA_ARGS__)
627
874
#endif
628
875
 
629
 
#if defined DEBUG && DEBUG >= 5
 
876
#if defined(DEBUG) && DEBUG >= 5
630
877
#undef DBGTRACE5
631
878
#define DBGTRACE5(fmt, ...) DBGTRACE(5, fmt , ## __VA_ARGS__)
632
879
#endif
633
880
 
 
881
#if defined(DEBUG) && DEBUG >= 6
 
882
#undef DBGTRACE6
 
883
#define DBGTRACE6(fmt, ...) DBGTRACE(6, fmt , ## __VA_ARGS__)
 
884
#endif
 
885
 
634
886
#define TRACEENTER(fmt, ...) DBGTRACE("Enter " fmt , ## __VA_ARGS__)
635
887
#define TRACEENTER1(fmt, ...) DBGTRACE1("Enter " fmt , ## __VA_ARGS__)
636
888
#define TRACEENTER2(fmt, ...) DBGTRACE2("Enter " fmt , ## __VA_ARGS__)
637
889
#define TRACEENTER3(fmt, ...) DBGTRACE3("Enter " fmt , ## __VA_ARGS__)
638
890
#define TRACEENTER4(fmt, ...) DBGTRACE4("Enter " fmt , ## __VA_ARGS__)
639
891
#define TRACEENTER5(fmt, ...) DBGTRACE5("Enter " fmt , ## __VA_ARGS__)
 
892
#define TRACEENTER6(fmt, ...) DBGTRACE6("Enter " fmt , ## __VA_ARGS__)
640
893
 
641
894
#define TRACEEXIT(stmt) do { DBGTRACE("Exit"); stmt; } while(0)
642
895
#define TRACEEXIT1(stmt) do { DBGTRACE1("Exit"); stmt; } while(0)
644
897
#define TRACEEXIT3(stmt) do { DBGTRACE3("Exit"); stmt; } while(0)
645
898
#define TRACEEXIT4(stmt) do { DBGTRACE4("Exit"); stmt; } while(0)
646
899
#define TRACEEXIT5(stmt) do { DBGTRACE5("Exit"); stmt; } while(0)
647
 
 
648
 
#ifdef USB_DEBUG
649
 
#define USBTRACE(fmt, ...) DBGTRACE1(fmt, ## __VA_ARGS__)
650
 
#define USBTRACEENTER(fmt, ...) TRACEENTER1(fmt, ## __VA_ARGS__)
651
 
#define USBTRACEEXIT(stmt) TRACEEXIT1(stmt)
 
900
#define TRACEEXIT6(stmt) do { DBGTRACE6("Exit"); stmt; } while(0)
 
901
 
 
902
//#define USB_DEBUG 1
 
903
//#define EVENT_DEBUG 1
 
904
//#define IO_DEBUG 1
 
905
 
 
906
#if defined(USB_DEBUG)
 
907
#define USBTRACE DBGTRACE1
 
908
#define USBENTER TRACEENTER1
 
909
#define USBEXIT TRACEEXIT1
652
910
#else
653
911
#define USBTRACE(fmt, ...)
654
 
#define USBTRACEENTER(fmt, ...)
655
 
#define USBTRACEEXIT(stmt) stmt
 
912
#define USBENTER(fmt, ...)
 
913
#define USBEXIT(stmt) stmt
 
914
#endif
 
915
 
 
916
#if defined(EVENT_DEBUG)
 
917
#define EVENTTRACE DBGTRACE1
 
918
#define EVENTENTER TRACEENTER1
 
919
#define EVENTEXIT TRACEEXIT1
 
920
#else
 
921
#define EVENTTRACE(fmt, ...)
 
922
#define EVENTENTER(fmt, ...)
 
923
#define EVENTEXIT(stmt) stmt
 
924
#endif
 
925
 
 
926
#if defined(IO_DEBUG)
 
927
#define IOTRACE DBGTRACE1
 
928
#define IOENTER TRACEENTER1
 
929
#define IOEXIT TRACEEXIT1
 
930
#else
 
931
#define IOTRACE(fmt, ...)
 
932
#define IOENTER(fmt, ...)
 
933
#define IOEXIT(stmt) stmt
656
934
#endif
657
935
 
658
936
#if defined DEBUG
659
 
#define ASSERT(expr) do {                                               \
660
 
                if (!(expr)) {                                          \
661
 
                        ERROR("Assertion failed! %s", (#expr));         \
662
 
                }                                                       \
663
 
        } while (0)
664
 
#else
665
 
#define ASSERT(expr)
666
 
#endif
 
937
#define assert(expr) do {                                               \
 
938
                if (!(expr))                                            \
 
939
                        ERROR("assertion failed: %s", (#expr));         \
 
940
        } while (0)
 
941
#else
 
942
#define assert(expr) do { } while (0)
 
943
#endif
 
944
 
 
945
#if defined(IO_DEBUG)
 
946
#define DUMP_IRP(__irp)                                                 \
 
947
        do {                                                            \
 
948
                struct io_stack_location *_irp_sl;                      \
 
949
                _irp_sl = IoGetCurrentIrpStackLocation(__irp);          \
 
950
                IOTRACE("irp: %p, stack size: %d, cl: %d, sl: %p, "     \
 
951
                        "dev_obj: %p, mj_fn: %d, minor_fn: %d, "        \
 
952
                        "nt_urb: %p, event: %p",                        \
 
953
                        __irp, __irp->stack_count, (__irp)->current_location, \
 
954
                        _irp_sl, _irp_sl->dev_obj, _irp_sl->major_fn,   \
 
955
                        _irp_sl->minor_fn, URB_FROM_IRP(__irp),         \
 
956
                        (__irp)->user_event);                           \
 
957
        } while (0)
 
958
#else
 
959
#define DUMP_IRP(__irp) do { } while (0)
 
960
#endif
 
961
 
 
962
#define sleep(nsec)                                     \
 
963
        do {                                            \
 
964
                set_current_state(TASK_INTERRUPTIBLE);  \
 
965
                schedule_timeout(nsec * HZ);            \
 
966
        } while (0)
667
967
 
668
968
#endif // _NTOSKERNEL_H_