Some questions on interrupts, threads etc

Question

Havng gone through some documentation on interrupt, kernel level threads etc in WDF, I got a couple of questions:
1)  Can a hardware interrupt be preempted by another interrupt in a single processor system?
2)  What exactly is the difference between thread preemption and thread interrupt? Doesnt both mean stopping the current thread and putting it aside?
3)  When an iterrupt is handled by an ISR, does the ISR always have to  schedule  a DCP? If the ISR itself can handle the interrupt, is the DPC needed?
4) I understand that spin locks are used for synchronisation at IRQL <=DISPATCH_LEVEL. EVT_WDF_IO_QUEUE_IO_WRITE works at <= DISPATCH_LEVEL. If I set Synchronisation scope of a write queue as SynchronisationScopeQueue, should I still go for a spin
lock, if the write callback and say an ioctl callback uses a shared resource?
5 )Kernel dispatcher objects are mutex, timer, event, semaphore etc. But If i use a fast mutex or guarded mutex or oridinary mutex using say, KeAcquireFastMutex() isnt that then a kernel dispatcher object? What this distinction?  Why should we go explicitly
go for kernel dispatcher object?
6) How can timers be used for kernel level synchronisation? How different is this from timers created using WdfTimerCreate()?
7)  It is said that "Never wait on a kernel dispatcher object in any driver routine that can be called at IRQL>=DISPATCH_LEVEL.". Does it mean
we should not use synchronisation mechanisms in this level? Or if we can use, should the thread try to acquire a lock with  a zero wait time? And proceed if it could acquire the lock and return if the lock was not acquired?
8) I understand that in order to execute an interrupt, a driver does not create any special threads but use a thread that happens to be running at the moment( arbitrary thread ) . My question is, in what way is this accomplished? What aspect of the arbitrary
thread is the interrupt using ? The arbitrary thread must obviously have been written for another purpose.

Answer 1

To answer the questions:
#1   An interrupt service routine (ISR) running a lower IRQL may be interrupted by another ISR running at a higher level.
#2   Having never heard of a thread interrupt, all I can say here is that a thread may be pre-empted for a lot of reasons.
#3   An ISR does not have to schedule a DPC unless it needs to do work that it cannot do at high IRQL.
#4   Assuming that the Write and IOCTL are on seperate queues, yes you need a a lock to protect shared resources.
#5   As the name implies kernel dispatcher objects allow scheduling (i.e. dispatching of another thread), while things like spinlocks do not. 
#6    Timers are just another dispatching object, i.e. one can wait on them the same way one waits on a mutex or a semaphore.  A WDF TIMER is basically a wrapper around a regular timer to take care of some of the housekeeping (particularily
with respect to stopping the driver etc)
#7     If a routine is running at DISPATCH_LEVEL you are limited to spin locks for synchronization. You can with a zero timeout check the status of a kernel dispatcher object.   In general, routines like this should be
designed to only use spinlocks.
#8    An arbitrary thread is just that, it may be a thread in any process. Basically a currently running thread is grabed and used to run the interrupt so that the scheduler which has overhead and is not designed to run at interrupt level
IRQL's does not need to run.
Don Burn Windows Filesystem and Driver Consulting Website: http://www.windrvr.com Blog: http://msmvps.com/blogs/WinDrvr