![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to waitmask.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / comm / serial|
Return to waitmask.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / comm / serial |
1.1 root 1: /*++
2:
3: Copyright (c) 1991, 1992, 1993 Microsoft Corporation
4:
5: Module Name:
6:
7: waitmask.c
8:
9: Abstract:
10:
11: This module contains the code that is very specific to get/set/wait
12: on event mask operations in the serial driver
13:
14: Author:
15:
16: Anthony V. Ercolano 26-Sep-1991
17:
18: Environment:
19:
20: Kernel mode
21:
22: Revision History :
23:
24: --*/
25:
26: #include <stddef.h>
27: #include "ntddk.h"
28: #include "ntddser.h"
29: #include "serial.h"
30: #include "serialp.h"
31:
32:
33: BOOLEAN
34: SerialGrabWaitFromIsr(
35: IN PVOID Context
36: );
37:
38: BOOLEAN
39: SerialGiveWaitToIsr(
40: IN PVOID Context
41: );
42:
43: BOOLEAN
44: SerialFinishOldWait(
45: IN PVOID Context
46: );
47:
48:
49: NTSTATUS
50: SerialStartMask(
51: IN PSERIAL_DEVICE_EXTENSION Extension
52: )
53:
54: /*++
55:
56: Routine Description:
57:
58: This routine is used to process the set mask and wait
59: mask ioctls. Calls to this routine are serialized by
60: placing irps in the list under the protection of the
61: cancel spin lock.
62:
63: Arguments:
64:
65: Extension - A pointer to the serial device extension.
66:
67: Return Value:
68:
69: Will return pending for everything put the first
70: request that we actually process. Even in that
71: case it will return pending unless it can complete
72: it right away.
73:
74:
75: --*/
76:
77: {
78:
79: //
80: // The current stack location. This contains much of the
81: // information we need to process this particular request.
82: //
83: PIO_STACK_LOCATION IrpSp;
84:
85: PIRP NewIrp;
86:
87: BOOLEAN SetFirstStatus = FALSE;
88: NTSTATUS FirstStatus;
89:
90: SerialDump(
91: SERDIAG3,
92: ("SERIAL: In SerialStartMask\n")
93: );
94:
95: ASSERT(Extension->CurrentMaskIrp);
96:
97: do {
98:
99: SerialDump(
100: SERDIAG4,
101: ("SERIAL: STARMASK - CurrentMaskIrp: %x\n",Extension->CurrentMaskIrp)
102: );
103: IrpSp = IoGetCurrentIrpStackLocation(Extension->CurrentMaskIrp);
104:
105: ASSERT((IrpSp->Parameters.DeviceIoControl.IoControlCode ==
106: IOCTL_SERIAL_WAIT_ON_MASK) ||
107: (IrpSp->Parameters.DeviceIoControl.IoControlCode ==
108: IOCTL_SERIAL_SET_WAIT_MASK));
109:
110: if (IrpSp->Parameters.DeviceIoControl.IoControlCode ==
111: IOCTL_SERIAL_SET_WAIT_MASK) {
112:
113: SerialDump(
114: SERDIAG4,
115: ("SERIAL - %x is a SETMASK irp\n",Extension->CurrentMaskIrp)
116: );
117:
118: //
119: // Complete the old wait if there is one.
120: //
121:
122: KeSynchronizeExecution(
123: Extension->Interrupt,
124: SerialFinishOldWait,
125: Extension
126: );
127:
128: //
129: // Any current waits should be on its way to completion
130: // at this point. There certainly shouldn't be any
131: // irp mask location.
132: //
133:
134: ASSERT(!Extension->IrpMaskLocation);
135:
136: Extension->CurrentMaskIrp->IoStatus.Status = STATUS_SUCCESS;
137:
138: if (!SetFirstStatus) {
139:
140: SerialDump(
141: SERDIAG4,
142: ("SERIAL: %x was the first irp processed by this\n"
143: "------- invocation of startmask\n",Extension->CurrentMaskIrp)
144: );
145: FirstStatus = STATUS_SUCCESS;
146: SetFirstStatus = TRUE;
147:
148: }
149:
150: //
151: // The following call will also cause the current
152: // call to be completed.
153: //
154:
155: SerialGetNextIrp(
156: &Extension->CurrentMaskIrp,
157: &Extension->MaskQueue,
158: &NewIrp,
159: TRUE
160: );
161: SerialDump(
162: SERDIAG4,
163: ("SERIAL: Perhaps another mask irp was found in the queue\n"
164: "------- %x/%x <- values should be the same\n",
165: Extension->CurrentMaskIrp,NewIrp)
166: );
167:
168:
169: } else {
170:
171: //
172: // First make sure that we have a non-zero mask.
173: // If the app queues a wait on a zero mask it can't
174: // be statisfied so it makes no sense to start it.
175: //
176:
177: if ((!Extension->IsrWaitMask) || (Extension->CurrentWaitIrp)) {
178:
179: SerialDump(
180: SERDIAG4,
181: ("SERIAL: WaitIrp is invalid\n"
182: "------- IsrWaitMask: %x\n"
183: "------- CurrentWaitIrp: %x\n",
184: Extension->IsrWaitMask,
185: Extension->CurrentWaitIrp)
186: );
187:
188: Extension->CurrentMaskIrp->IoStatus.Status = STATUS_INVALID_PARAMETER;
189:
190: if (!SetFirstStatus) {
191:
192: SerialDump(
193: SERDIAG4,
194: ("SERIAL: %x was the first irp processed by this\n"
195: "------- invocation of startmask\n",Extension->CurrentMaskIrp)
196: );
197: FirstStatus = STATUS_INVALID_PARAMETER;
198: SetFirstStatus = TRUE;
199:
200: }
201:
202: SerialGetNextIrp(
203: &Extension->CurrentMaskIrp,
204: &Extension->MaskQueue,
205: &NewIrp,
206: TRUE
207: );
208: SerialDump(
209: SERDIAG4,
210: ("SERIAL: Perhaps another mask irp was found in the queue\n"
211: "------- %x/%x <- values should be the same\n",
212: Extension->CurrentMaskIrp,NewIrp)
213: );
214:
215: } else {
216:
217: KIRQL OldIrql;
218:
219: //
220: // Make the current mask irp the current wait irp and
221: // get a new current mask irp. Note that when we get
222: // the new current mask irp we DO NOT complete the
223: // old current mask irp (which is now the current wait
224: // irp.
225: //
226: // Then under the protection of the cancel spin lock
227: // we check to see if the current wait irp needs to
228: // be canceled
229: //
230:
231: IoAcquireCancelSpinLock(&OldIrql);
232:
233: if (Extension->CurrentMaskIrp->Cancel) {
234:
235: SerialDump(
236: SERDIAG4,
237: ("SERIAL: %x irp was already marked as cancelled\n",
238: Extension->CurrentMaskIrp)
239: );
240: IoReleaseCancelSpinLock(OldIrql);
241: Extension->CurrentMaskIrp->IoStatus.Status = STATUS_CANCELLED;
242:
243: if (!SetFirstStatus) {
244:
245: SerialDump(
246: SERDIAG4,
247: ("SERIAL: %x was the first irp processed by this\n"
248: "------- invocation of startmask\n",Extension->CurrentMaskIrp)
249: );
250: FirstStatus = STATUS_CANCELLED;
251: SetFirstStatus = TRUE;
252:
253: }
254:
255: SerialGetNextIrp(
256: &Extension->CurrentMaskIrp,
257: &Extension->MaskQueue,
258: &NewIrp,
259: TRUE
260: );
261: SerialDump(
262: SERDIAG4,
263: ("SERIAL: Perhaps another mask irp was found in the queue\n"
264: "------- %x/%x <- values should be the same\n",
265: Extension->CurrentMaskIrp,NewIrp)
266: );
267:
268: } else {
269:
270: SerialDump(
271: SERDIAG4,
272: ("SERIAL: %x will become the current wait irp\n",
273: Extension->CurrentMaskIrp)
274: );
275: if (!SetFirstStatus) {
276:
277: SerialDump(
278: SERDIAG4,
279: ("SERIAL: %x was the first irp processed by this\n"
280: "------- invocation of startmask\n",Extension->CurrentMaskIrp)
281: );
282: FirstStatus = STATUS_PENDING;
283: SetFirstStatus = TRUE;
284:
285: //
286: // If we haven't already set a first status
287: // then there is a chance that this packet
288: // was never on the queue. We should mark
289: // it as pending.
290: //
291:
292: IoMarkIrpPending(Extension->CurrentMaskIrp);
293:
294: }
295:
296: //
297: // There should never be a mask location when
298: // there isn't a current wait irp. At this point
299: // there shouldn't be a current wait irp also.
300: //
301:
302: ASSERT(!Extension->IrpMaskLocation);
303: ASSERT(!Extension->CurrentWaitIrp);
304:
305: Extension->CurrentWaitIrp = Extension->CurrentMaskIrp;
306: SERIAL_INIT_REFERENCE(Extension->CurrentWaitIrp);
307: IoSetCancelRoutine(
308: Extension->CurrentWaitIrp,
309: SerialCancelWait
310: );
311:
312: //
313: // Since the cancel routine has a reference to
314: // the irp we need to update the reference
315: // count.
316: //
317:
318: SERIAL_INC_REFERENCE(Extension->CurrentWaitIrp);
319:
320: KeSynchronizeExecution(
321: Extension->Interrupt,
322: SerialGiveWaitToIsr,
323: Extension
324: );
325:
326: IoReleaseCancelSpinLock(OldIrql);
327:
328: SerialGetNextIrp(
329: &Extension->CurrentMaskIrp,
330: &Extension->MaskQueue,
331: &NewIrp,
332: FALSE
333: );
334: SerialDump(
335: SERDIAG4,
336: ("SERIAL: Perhaps another mask irp was found in the queue\n"
337: "------- %x/%x <- values should be the same\n",
338: Extension->CurrentMaskIrp,NewIrp)
339: );
340:
341: }
342:
343: }
344:
345: }
346:
347: } while (NewIrp);
348:
349: return FirstStatus;
350:
351: }
352:
353: BOOLEAN
354: SerialGrabWaitFromIsr(
355: IN PVOID Context
356: )
357:
358: /*++
359:
360: Routine Description:
361:
362: This routine will check to see if the ISR still knows about
363: a wait irp by checking to see if the IrpMaskLocation is non-null.
364: If it is then it will zero the Irpmasklocation (which in effect
365: grabs the irp away from the isr). This routine is only called
366: buy the cancel code for the wait.
367:
368: NOTE: This is called by KeSynchronizeExecution.
369:
370: Arguments:
371:
372: Context - A pointer to the device extension
373:
374: Return Value:
375:
376: Always FALSE.
377:
378: --*/
379:
380: {
381:
382: PSERIAL_DEVICE_EXTENSION Extension = Context;
383:
384: SerialDump(
385: SERDIAG3,
386: ("SERIAL: In SerialGrabWaitFromIsr\n")
387: );
388:
389: if (Extension->IrpMaskLocation) {
390:
391: SerialDump(
392: SERDIAG4,
393: ("SERIAL: The isr still owns the irp %x, mask location is %x\n"
394: "------- and system buffer is %x\n",
395: Extension->CurrentWaitIrp,Extension->IrpMaskLocation,
396: Extension->CurrentWaitIrp->AssociatedIrp.SystemBuffer)
397: );
398:
399: //
400: // The isr still "owns" the irp.
401: //
402:
403: *Extension->IrpMaskLocation = 0;
404: Extension->IrpMaskLocation = NULL;
405:
406: Extension->CurrentWaitIrp->IoStatus.Information = sizeof(ULONG);
407:
408: //
409: // Since the isr no longer references the irp we need to
410: // decrement the reference count.
411: //
412:
413: SERIAL_DEC_REFERENCE(Extension->CurrentWaitIrp);
414:
415: }
416:
417: return FALSE;
418: }
419:
420: BOOLEAN
421: SerialGiveWaitToIsr(
422: IN PVOID Context
423: )
424:
425: /*++
426:
427: Routine Description:
428:
429: This routine simply sets a variable in the device extension
430: so that the isr knows that we have a wait irp.
431:
432: NOTE: This is called by KeSynchronizeExecution.
433:
434: NOTE: This routine assumes that it is called with the
435: cancel spinlock held.
436:
437: Arguments:
438:
439: Context - Simply a pointer to the device extension.
440:
441: Return Value:
442:
443: Always FALSE.
444:
445: --*/
446:
447: {
448:
449: PSERIAL_DEVICE_EXTENSION Extension = Context;
450:
451: SerialDump(
452: SERDIAG3,
453: ("SERIAL: In SerialGiveWaitToIsr\n")
454: );
455: //
456: // There certainly shouldn't be a current mask location at
457: // this point since we have a new current wait irp.
458: //
459:
460: ASSERT(!Extension->IrpMaskLocation);
461:
462: //
463: // The isr may or may not actually reference this irp. It
464: // won't if the wait can be satisfied immediately. However,
465: // since it will then go through the normal completion sequence,
466: // we need to have an incremented reference count anyway.
467: //
468:
469: SERIAL_INC_REFERENCE(Extension->CurrentWaitIrp);
470:
471: if (!Extension->HistoryMask) {
472:
473: SerialDump(
474: SERDIAG4,
475: ("SERIAL: No events occured prior to the wait call\n")
476: );
477:
478: //
479: // Although this wait might not be for empty transmit
480: // queue, it doesn't hurt anything to set it to false.
481: //
482:
483: Extension->EmptiedTransmit = FALSE;
484:
485: //
486: // Record where the "completion mask" should be set.
487: //
488:
489: Extension->IrpMaskLocation =
490: Extension->CurrentWaitIrp->AssociatedIrp.SystemBuffer;
491: SerialDump(
492: SERDIAG4,
493: ("SERIAL: The isr owns the irp %x, mask location is %x\n"
494: "------- and system buffer is %x\n",
495: Extension->CurrentWaitIrp,Extension->IrpMaskLocation,
496: Extension->CurrentWaitIrp->AssociatedIrp.SystemBuffer)
497: );
498:
499: } else {
500:
501: SerialDump(
502: SERDIAG4,
503: ("SERIAL: %x occurred prior to the wait - starting the\n"
504: "------- completion code for %x\n",
505: Extension->HistoryMask,Extension->CurrentWaitIrp)
506: );
507: *((ULONG *)Extension->CurrentWaitIrp->AssociatedIrp.SystemBuffer) =
508: Extension->HistoryMask;
509: Extension->HistoryMask = 0;
510: Extension->CurrentWaitIrp->IoStatus.Information = sizeof(ULONG);
511: Extension->CurrentWaitIrp->IoStatus.Status = STATUS_SUCCESS;
512:
513: KeInsertQueueDpc(
514: &Extension->CommWaitDpc,
515: NULL,
516: NULL
517: );
518:
519: }
520:
521: return FALSE;
522: }
523:
524: BOOLEAN
525: SerialFinishOldWait(
526: IN PVOID Context
527: )
528:
529: /*++
530:
531: Routine Description:
532:
533: This routine will check to see if the ISR still knows about
534: a wait irp by checking to see if the Irpmasklocation is non-null.
535: If it is then it will zero the Irpmasklocation (which in effect
536: grabs the irp away from the isr). This routine is only called
537: buy the cancel code for the wait.
538:
539: NOTE: This is called by KeSynchronizeExecution.
540:
541: Arguments:
542:
543: Context - A pointer to the device extension
544:
545: Return Value:
546:
547: Always FALSE.
548:
549: --*/
550:
551: {
552:
553: PSERIAL_DEVICE_EXTENSION Extension = Context;
554:
555: SerialDump(
556: SERDIAG3,
557: ("SERIAL: In SerialFinishOldWait\n")
558: );
559: if (Extension->IrpMaskLocation) {
560:
561: SerialDump(
562: SERDIAG4,
563: ("SERIAL: The isr still owns the irp %x, mask location is %x\n"
564: "------- and system buffer is %x\n",
565: Extension->CurrentWaitIrp,Extension->IrpMaskLocation,
566: Extension->CurrentWaitIrp->AssociatedIrp.SystemBuffer)
567: );
568: //
569: // The isr still "owns" the irp.
570: //
571:
572: *Extension->IrpMaskLocation = 0;
573: Extension->IrpMaskLocation = NULL;
574:
575: Extension->CurrentWaitIrp->IoStatus.Information = sizeof(ULONG);
576:
577: //
578: // We don't decrement the reference since the completion routine
579: // will do that.
580: //
581:
582: KeInsertQueueDpc(
583: &Extension->CommWaitDpc,
584: NULL,
585: NULL
586: );
587:
588: }
589:
590: //
591: // Don't wipe out any historical data we are still interested in.
592: //
593:
594: Extension->HistoryMask &= *((ULONG *)Extension->CurrentMaskIrp->
595: AssociatedIrp.SystemBuffer);
596:
597: Extension->IsrWaitMask = *((ULONG *)Extension->CurrentMaskIrp->
598: AssociatedIrp.SystemBuffer);
599: SerialDump(
600: SERDIAG4,
601: ("SERIAL: Set mask location of %x, in irp %x, with system buffer of %x\n",
602: Extension->IrpMaskLocation,
603: Extension->CurrentMaskIrp,Extension->CurrentMaskIrp->AssociatedIrp.SystemBuffer)
604: );
605: return FALSE;
606: }
607:
608: VOID
609: SerialCancelWait(
610: IN PDEVICE_OBJECT DeviceObject,
611: IN PIRP Irp
612: )
613:
614: /*++
615:
616: Routine Description:
617:
618: This routine is used to cancel a irp that is waiting on
619: a comm event.
620:
621: Arguments:
622:
623: DeviceObject - Pointer to the device object for this device
624:
625: Irp - Pointer to the IRP for the current request
626:
627: Return Value:
628:
629: None.
630:
631: --*/
632:
633: {
634:
635: PSERIAL_DEVICE_EXTENSION Extension = DeviceObject->DeviceExtension;
636:
637: SerialDump(
638: SERDIAG3,
639: ("SERIAL: In SerialCancelWait\n")
640: );
641:
642: SerialDump(
643: SERDIAG4,
644: ("SERIAL: Canceling wait for irp %x\n",Extension->CurrentWaitIrp)
645: );
646: SerialTryToCompleteCurrent(
647: Extension,
648: SerialGrabWaitFromIsr,
649: Irp->CancelIrql,
650: STATUS_CANCELLED,
651: &Extension->CurrentWaitIrp,
652: NULL,
653: NULL,
654: NULL,
655: NULL,
656: NULL
657: );
658:
659: }
660:
661: VOID
662: SerialCompleteWait(
663: IN PKDPC Dpc,
664: IN PVOID DeferredContext,
665: IN PVOID SystemContext1,
666: IN PVOID SystemContext2
667: )
668:
669: {
670:
671: PSERIAL_DEVICE_EXTENSION Extension = DeferredContext;
672: KIRQL OldIrql;
673:
674: SerialDump(
675: SERDIAG3,
676: ("SERIAL: In SerialCompleteWait\n")
677: );
678: UNREFERENCED_PARAMETER(Dpc);
679: UNREFERENCED_PARAMETER(SystemContext1);
680: UNREFERENCED_PARAMETER(SystemContext2);
681:
682: IoAcquireCancelSpinLock(&OldIrql);
683:
684: SerialDump(
685: SERDIAG4,
686: ("SERIAL: Completing wait for irp %x\n",Extension->CurrentWaitIrp)
687: );
688: SerialTryToCompleteCurrent(
689: Extension,
690: NULL,
691: OldIrql,
692: STATUS_SUCCESS,
693: &Extension->CurrentWaitIrp,
694: NULL,
695: NULL,
696: NULL,
697: NULL,
698: NULL
699: );
700:
701: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.