[APPHELP_APITEST] Add tests for SdbGetMatchingExe, to test matching on version resour...
[reactos.git] / reactos / drivers / storage / classpnp / classwmi.c
1 /*++
2
3 Copyright (C) Microsoft Corporation, 1991 - 1999
4
5 Module Name:
6
7 classwmi.c
8
9 Abstract:
10
11 SCSI class driver routines
12
13 Environment:
14
15 kernel mode only
16
17 Notes:
18
19
20 Revision History:
21
22 --*/
23
24 #include "classp.h"
25
26 #include <wmistr.h>
27
28 NTSTATUS
29 NTAPI
30 ClassSystemControl(
31 IN PDEVICE_OBJECT DeviceObject,
32 IN PIRP Irp
33 );
34
35 BOOLEAN
36 ClassFindGuid(
37 PGUIDREGINFO GuidList,
38 ULONG GuidCount,
39 LPGUID Guid,
40 PULONG GuidIndex
41 );
42
43 //
44 // This is the name for the MOF resource that must be part of all drivers that
45 // register via this interface.
46 #define MOFRESOURCENAME L"MofResourceName"
47
48 //
49 // What can be paged ???
50 #ifdef ALLOC_PRAGMA
51 #pragma alloc_text(PAGE, ClassSystemControl)
52 #pragma alloc_text(PAGE, ClassFindGuid)
53 #endif
54
55 \f
56 /*++////////////////////////////////////////////////////////////////////////////
57
58 ClassFindGuid()
59
60 Routine Description:
61
62 This routine will search the list of guids registered and return
63 the index for the one that was registered.
64
65 Arguments:
66
67 GuidList is the list of guids to search
68
69 GuidCount is the count of guids in the list
70
71 Guid is the guid being searched for
72
73 *GuidIndex returns the index to the guid
74
75 Return Value:
76
77 TRUE if guid is found else FALSE
78
79 --*/
80 BOOLEAN
81 ClassFindGuid(
82 PGUIDREGINFO GuidList,
83 ULONG GuidCount,
84 LPGUID Guid,
85 PULONG GuidIndex
86 )
87 {
88 ULONG i;
89
90 PAGED_CODE();
91
92 for (i = 0; i < GuidCount; i++)
93 {
94 if (IsEqualGUID(Guid, &GuidList[i].Guid))
95 {
96 *GuidIndex = i;
97 return(TRUE);
98 }
99 }
100
101 return(FALSE);
102 } // end ClassFindGuid()
103 \f
104 /*++////////////////////////////////////////////////////////////////////////////
105
106 ClassSystemControl()
107
108 Routine Description:
109
110 Dispatch routine for IRP_MJ_SYSTEM_CONTROL. This routine will process
111 all wmi requests received, forwarding them if they are not for this
112 driver or determining if the guid is valid and if so passing it to
113 the driver specific function for handing wmi requests.
114
115 Arguments:
116
117 DeviceObject - Supplies a pointer to the device object for this request.
118
119 Irp - Supplies the Irp making the request.
120
121 Return Value:
122
123 status
124
125 --*/
126 NTSTATUS
127 NTAPI
128 ClassSystemControl(
129 IN PDEVICE_OBJECT DeviceObject,
130 IN PIRP Irp
131 )
132 {
133 PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
134 PCLASS_DRIVER_EXTENSION driverExtension;
135 PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
136 ULONG isRemoved;
137 ULONG bufferSize;
138 PUCHAR buffer;
139 NTSTATUS status;
140 UCHAR minorFunction;
141 ULONG guidIndex;
142 PCLASS_WMI_INFO classWmiInfo;
143
144 PAGED_CODE();
145
146 //
147 // Make sure device has not been removed
148 isRemoved = ClassAcquireRemoveLock(DeviceObject, Irp);
149 if(isRemoved)
150 {
151 Irp->IoStatus.Status = STATUS_DEVICE_DOES_NOT_EXIST;
152 ClassReleaseRemoveLock(DeviceObject, Irp);
153 ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
154 return STATUS_DEVICE_DOES_NOT_EXIST;
155 }
156
157 //
158 // If the irp is not a WMI irp or it is not targeted at this device
159 // or this device has not registered with WMI then just forward it on.
160 minorFunction = irpStack->MinorFunction;
161 if ((minorFunction > IRP_MN_EXECUTE_METHOD) ||
162 (irpStack->Parameters.WMI.ProviderId != (ULONG_PTR)DeviceObject) ||
163 ((minorFunction != IRP_MN_REGINFO) &&
164 (commonExtension->GuidRegInfo == NULL)))
165 {
166 //
167 // CONSIDER: Do I need to hang onto lock until IoCallDriver returns ?
168 IoSkipCurrentIrpStackLocation(Irp);
169 ClassReleaseRemoveLock(DeviceObject, Irp);
170 return(IoCallDriver(commonExtension->LowerDeviceObject, Irp));
171 }
172
173 buffer = (PUCHAR)irpStack->Parameters.WMI.Buffer;
174 bufferSize = irpStack->Parameters.WMI.BufferSize;
175
176 if (minorFunction != IRP_MN_REGINFO)
177 {
178 //
179 // For all requests other than query registration info we are passed
180 // a guid. Determine if the guid is one that is supported by the
181 // device.
182 if (ClassFindGuid(commonExtension->GuidRegInfo,
183 commonExtension->GuidCount,
184 (LPGUID)irpStack->Parameters.WMI.DataPath,
185 &guidIndex))
186 {
187 status = STATUS_SUCCESS;
188 } else {
189 status = STATUS_WMI_GUID_NOT_FOUND;
190 }
191
192 if (NT_SUCCESS(status) &&
193 ((minorFunction == IRP_MN_QUERY_SINGLE_INSTANCE) ||
194 (minorFunction == IRP_MN_CHANGE_SINGLE_INSTANCE) ||
195 (minorFunction == IRP_MN_CHANGE_SINGLE_ITEM) ||
196 (minorFunction == IRP_MN_EXECUTE_METHOD)))
197 {
198 if ( (((PWNODE_HEADER)buffer)->Flags) &
199 WNODE_FLAG_STATIC_INSTANCE_NAMES)
200 {
201 if ( ((PWNODE_SINGLE_INSTANCE)buffer)->InstanceIndex != 0 )
202 {
203 status = STATUS_WMI_INSTANCE_NOT_FOUND;
204 }
205 } else {
206 status = STATUS_WMI_INSTANCE_NOT_FOUND;
207 }
208 }
209
210 if (! NT_SUCCESS(status))
211 {
212 Irp->IoStatus.Status = status;
213 ClassReleaseRemoveLock(DeviceObject, Irp);
214 ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
215 return(status);
216 }
217 }
218
219 driverExtension = commonExtension->DriverExtension;
220
221 classWmiInfo = commonExtension->IsFdo ?
222 &driverExtension->InitData.FdoData.ClassWmiInfo :
223 &driverExtension->InitData.PdoData.ClassWmiInfo;
224 switch(minorFunction)
225 {
226 case IRP_MN_REGINFO:
227 {
228 ULONG guidCount;
229 PGUIDREGINFO guidList;
230 PWMIREGINFOW wmiRegInfo;
231 PWMIREGGUIDW wmiRegGuid;
232 //PDEVICE_OBJECT pdo;
233 PUNICODE_STRING regPath;
234 PWCHAR stringPtr;
235 ULONG retSize;
236 ULONG registryPathOffset;
237 ULONG mofResourceOffset;
238 ULONG bufferNeeded;
239 ULONG i;
240 ULONG_PTR nameInfo;
241 ULONG nameSize, nameOffset, nameFlags;
242 UNICODE_STRING name, mofName;
243 PCLASS_QUERY_WMI_REGINFO_EX ClassQueryWmiRegInfoEx;
244
245 name.Buffer = NULL;
246 name.Length = 0;
247 name.MaximumLength = 0;
248 nameFlags = 0;
249
250 ClassQueryWmiRegInfoEx = commonExtension->IsFdo ?
251 driverExtension->ClassFdoQueryWmiRegInfoEx :
252 driverExtension->ClassPdoQueryWmiRegInfoEx;
253
254 if (ClassQueryWmiRegInfoEx == NULL)
255 {
256 status = classWmiInfo->ClassQueryWmiRegInfo(
257 DeviceObject,
258 &nameFlags,
259 &name);
260
261 RtlInitUnicodeString(&mofName, MOFRESOURCENAME);
262 } else {
263 RtlInitUnicodeString(&mofName, L"");
264 status = (*ClassQueryWmiRegInfoEx)(
265 DeviceObject,
266 &nameFlags,
267 &name,
268 &mofName);
269 }
270
271 if (NT_SUCCESS(status) &&
272 (! (nameFlags & WMIREG_FLAG_INSTANCE_PDO) &&
273 (name.Buffer == NULL)))
274 {
275 //
276 // if PDO flag not specified then an instance name must be
277 status = STATUS_INVALID_DEVICE_REQUEST;
278 }
279
280 if (NT_SUCCESS(status))
281 {
282 guidList = classWmiInfo->GuidRegInfo;
283 guidCount = classWmiInfo->GuidCount;
284
285 nameOffset = sizeof(WMIREGINFO) +
286 guidCount * sizeof(WMIREGGUIDW);
287
288 if (nameFlags & WMIREG_FLAG_INSTANCE_PDO)
289 {
290 nameSize = 0;
291 nameInfo = commonExtension->IsFdo ?
292 (ULONG_PTR)((PFUNCTIONAL_DEVICE_EXTENSION)commonExtension)->LowerPdo :
293 (ULONG_PTR)DeviceObject;
294 } else {
295 nameFlags |= WMIREG_FLAG_INSTANCE_LIST;
296 nameSize = name.Length + sizeof(USHORT);
297 nameInfo = nameOffset;
298 }
299
300 mofResourceOffset = nameOffset + nameSize;
301
302 registryPathOffset = mofResourceOffset +
303 mofName.Length + sizeof(USHORT);
304
305 regPath = &driverExtension->RegistryPath;
306 bufferNeeded = registryPathOffset +
307 regPath->Length + sizeof(USHORT);
308
309 if (bufferNeeded <= bufferSize)
310 {
311 retSize = bufferNeeded;
312
313 commonExtension->GuidCount = guidCount;
314 commonExtension->GuidRegInfo = guidList;
315
316 wmiRegInfo = (PWMIREGINFO)buffer;
317 wmiRegInfo->BufferSize = bufferNeeded;
318 wmiRegInfo->NextWmiRegInfo = 0;
319 wmiRegInfo->MofResourceName = mofResourceOffset;
320 wmiRegInfo->RegistryPath = registryPathOffset;
321 wmiRegInfo->GuidCount = guidCount;
322
323 for (i = 0; i < guidCount; i++)
324 {
325 wmiRegGuid = &wmiRegInfo->WmiRegGuid[i];
326 wmiRegGuid->Guid = guidList[i].Guid;
327 wmiRegGuid->Flags = guidList[i].Flags | nameFlags;
328 wmiRegGuid->InstanceInfo = nameInfo;
329 wmiRegGuid->InstanceCount = 1;
330 }
331
332 if ( nameFlags & WMIREG_FLAG_INSTANCE_LIST)
333 {
334 stringPtr = (PWCHAR)((PUCHAR)buffer + nameOffset);
335 *stringPtr++ = name.Length;
336 RtlCopyMemory(stringPtr,
337 name.Buffer,
338 name.Length);
339 }
340
341 stringPtr = (PWCHAR)((PUCHAR)buffer + mofResourceOffset);
342 *stringPtr++ = mofName.Length;
343 RtlCopyMemory(stringPtr,
344 mofName.Buffer,
345 mofName.Length);
346
347 stringPtr = (PWCHAR)((PUCHAR)buffer + registryPathOffset);
348 *stringPtr++ = regPath->Length;
349 RtlCopyMemory(stringPtr,
350 regPath->Buffer,
351 regPath->Length);
352 } else {
353 *((PULONG)buffer) = bufferNeeded;
354 retSize = sizeof(ULONG);
355 }
356 } else {
357 retSize = 0;
358 }
359
360 if (name.Buffer != NULL)
361 {
362 ExFreePool(name.Buffer);
363 }
364
365 Irp->IoStatus.Status = status;
366 Irp->IoStatus.Information = retSize;
367 ClassReleaseRemoveLock(DeviceObject, Irp);
368 ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
369 return(status);
370 }
371
372 case IRP_MN_QUERY_ALL_DATA:
373 {
374 PWNODE_ALL_DATA wnode;
375 ULONG bufferAvail;
376
377 wnode = (PWNODE_ALL_DATA)buffer;
378
379 if (bufferSize < sizeof(WNODE_ALL_DATA))
380 {
381 bufferAvail = 0;
382 } else {
383 bufferAvail = bufferSize - sizeof(WNODE_ALL_DATA);
384 }
385
386 wnode->DataBlockOffset = sizeof(WNODE_ALL_DATA);
387
388 status = classWmiInfo->ClassQueryWmiDataBlock(
389 DeviceObject,
390 Irp,
391 guidIndex,
392 bufferAvail,
393 buffer + sizeof(WNODE_ALL_DATA));
394
395 break;
396 }
397
398 case IRP_MN_QUERY_SINGLE_INSTANCE:
399 {
400 PWNODE_SINGLE_INSTANCE wnode;
401 ULONG dataBlockOffset;
402
403 wnode = (PWNODE_SINGLE_INSTANCE)buffer;
404
405 dataBlockOffset = wnode->DataBlockOffset;
406
407 status = classWmiInfo->ClassQueryWmiDataBlock(
408 DeviceObject,
409 Irp,
410 guidIndex,
411 bufferSize - dataBlockOffset,
412 (PUCHAR)wnode + dataBlockOffset);
413
414 break;
415 }
416
417 case IRP_MN_CHANGE_SINGLE_INSTANCE:
418 {
419 PWNODE_SINGLE_INSTANCE wnode;
420
421 wnode = (PWNODE_SINGLE_INSTANCE)buffer;
422
423 status = classWmiInfo->ClassSetWmiDataBlock(
424 DeviceObject,
425 Irp,
426 guidIndex,
427 wnode->SizeDataBlock,
428 (PUCHAR)wnode + wnode->DataBlockOffset);
429
430 break;
431 }
432
433 case IRP_MN_CHANGE_SINGLE_ITEM:
434 {
435 PWNODE_SINGLE_ITEM wnode;
436
437 wnode = (PWNODE_SINGLE_ITEM)buffer;
438
439 status = classWmiInfo->ClassSetWmiDataItem(
440 DeviceObject,
441 Irp,
442 guidIndex,
443 wnode->ItemId,
444 wnode->SizeDataItem,
445 (PUCHAR)wnode + wnode->DataBlockOffset);
446
447 break;
448 }
449
450 case IRP_MN_EXECUTE_METHOD:
451 {
452 PWNODE_METHOD_ITEM wnode;
453
454 wnode = (PWNODE_METHOD_ITEM)buffer;
455
456 status = classWmiInfo->ClassExecuteWmiMethod(
457 DeviceObject,
458 Irp,
459 guidIndex,
460 wnode->MethodId,
461 wnode->SizeDataBlock,
462 bufferSize - wnode->DataBlockOffset,
463 buffer + wnode->DataBlockOffset);
464
465
466 break;
467 }
468
469 case IRP_MN_ENABLE_EVENTS:
470 {
471 status = classWmiInfo->ClassWmiFunctionControl(
472 DeviceObject,
473 Irp,
474 guidIndex,
475 EventGeneration,
476 TRUE);
477 break;
478 }
479
480 case IRP_MN_DISABLE_EVENTS:
481 {
482 status = classWmiInfo->ClassWmiFunctionControl(
483 DeviceObject,
484 Irp,
485 guidIndex,
486 EventGeneration,
487 FALSE);
488 break;
489 }
490
491 case IRP_MN_ENABLE_COLLECTION:
492 {
493 status = classWmiInfo->ClassWmiFunctionControl(
494 DeviceObject,
495 Irp,
496 guidIndex,
497 DataBlockCollection,
498 TRUE);
499 break;
500 }
501
502 case IRP_MN_DISABLE_COLLECTION:
503 {
504 status = classWmiInfo->ClassWmiFunctionControl(
505 DeviceObject,
506 Irp,
507 guidIndex,
508 DataBlockCollection,
509 FALSE);
510 break;
511 }
512
513 default:
514 {
515 status = STATUS_INVALID_DEVICE_REQUEST;
516 break;
517 }
518
519 }
520
521 return(status);
522 } // end ClassSystemControl()
523 \f
524 /*++////////////////////////////////////////////////////////////////////////////
525
526 ClassWmiCompleteRequest()
527
528 Routine Description:
529
530
531 This routine will do the work of completing a WMI irp. Depending upon the
532 the WMI request this routine will fixup the returned WNODE appropriately.
533
534 NOTE: This routine assumes that the ClassRemoveLock is held and it will
535 release it.
536
537 Arguments:
538
539 DeviceObject - Supplies a pointer to the device object for this request.
540
541 Irp - Supplies the Irp making the request.
542
543 Status - Status to complete the irp with. STATUS_BUFFER_TOO_SMALL is used
544 to indicate that more buffer is required for the data requested.
545
546 BufferUsed - number of bytes of actual data to return (not including WMI
547 specific structures)
548
549 PriorityBoost - priority boost to pass to ClassCompleteRequest
550
551 Return Value:
552
553 status
554
555 --*/
556 SCSIPORTAPI
557 NTSTATUS
558 NTAPI
559 ClassWmiCompleteRequest(
560 IN PDEVICE_OBJECT DeviceObject,
561 IN PIRP Irp,
562 IN NTSTATUS Status,
563 IN ULONG BufferUsed,
564 IN CCHAR PriorityBoost
565 )
566 {
567 PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
568 //UCHAR MinorFunction;
569 PUCHAR buffer;
570 ULONG retSize;
571 UCHAR minorFunction;
572
573 minorFunction = irpStack->MinorFunction;
574 buffer = (PUCHAR)irpStack->Parameters.WMI.Buffer;
575
576 switch(minorFunction)
577 {
578 case IRP_MN_QUERY_ALL_DATA:
579 {
580 PWNODE_ALL_DATA wnode;
581 PWNODE_TOO_SMALL wnodeTooSmall;
582 ULONG bufferNeeded;
583
584 wnode = (PWNODE_ALL_DATA)buffer;
585
586 bufferNeeded = sizeof(WNODE_ALL_DATA) + BufferUsed;
587
588 if (NT_SUCCESS(Status))
589 {
590 retSize = bufferNeeded;
591 wnode->WnodeHeader.BufferSize = bufferNeeded;
592 KeQuerySystemTime(&wnode->WnodeHeader.TimeStamp);
593 wnode->WnodeHeader.Flags |= WNODE_FLAG_FIXED_INSTANCE_SIZE;
594 wnode->FixedInstanceSize = BufferUsed;
595 wnode->InstanceCount = 1;
596
597 } else if (Status == STATUS_BUFFER_TOO_SMALL) {
598 wnodeTooSmall = (PWNODE_TOO_SMALL)wnode;
599
600 wnodeTooSmall->WnodeHeader.BufferSize = sizeof(WNODE_TOO_SMALL);
601 wnodeTooSmall->WnodeHeader.Flags = WNODE_FLAG_TOO_SMALL;
602 wnodeTooSmall->SizeNeeded = sizeof(WNODE_ALL_DATA) + BufferUsed;
603 retSize = sizeof(WNODE_TOO_SMALL);
604 Status = STATUS_SUCCESS;
605 } else {
606 retSize = 0;
607 }
608 break;
609 }
610
611 case IRP_MN_QUERY_SINGLE_INSTANCE:
612 {
613 PWNODE_SINGLE_INSTANCE wnode;
614 PWNODE_TOO_SMALL wnodeTooSmall;
615 ULONG bufferNeeded;
616
617 wnode = (PWNODE_SINGLE_INSTANCE)buffer;
618
619 bufferNeeded = wnode->DataBlockOffset + BufferUsed;
620
621 if (NT_SUCCESS(Status))
622 {
623 retSize = bufferNeeded;
624 wnode->WnodeHeader.BufferSize = bufferNeeded;
625 KeQuerySystemTime(&wnode->WnodeHeader.TimeStamp);
626 wnode->SizeDataBlock = BufferUsed;
627
628 } else if (Status == STATUS_BUFFER_TOO_SMALL) {
629 wnodeTooSmall = (PWNODE_TOO_SMALL)wnode;
630
631 wnodeTooSmall->WnodeHeader.BufferSize = sizeof(WNODE_TOO_SMALL);
632 wnodeTooSmall->WnodeHeader.Flags = WNODE_FLAG_TOO_SMALL;
633 wnodeTooSmall->SizeNeeded = bufferNeeded;
634 retSize = sizeof(WNODE_TOO_SMALL);
635 Status = STATUS_SUCCESS;
636 } else {
637 retSize = 0;
638 }
639 break;
640 }
641
642 case IRP_MN_EXECUTE_METHOD:
643 {
644 PWNODE_METHOD_ITEM wnode;
645 PWNODE_TOO_SMALL wnodeTooSmall;
646 ULONG bufferNeeded;
647
648 wnode = (PWNODE_METHOD_ITEM)buffer;
649
650 bufferNeeded = wnode->DataBlockOffset + BufferUsed;
651
652 if (NT_SUCCESS(Status))
653 {
654 retSize = bufferNeeded;
655 wnode->WnodeHeader.BufferSize = bufferNeeded;
656 KeQuerySystemTime(&wnode->WnodeHeader.TimeStamp);
657 wnode->SizeDataBlock = BufferUsed;
658
659 } else if (Status == STATUS_BUFFER_TOO_SMALL) {
660 wnodeTooSmall = (PWNODE_TOO_SMALL)wnode;
661
662 wnodeTooSmall->WnodeHeader.BufferSize = sizeof(WNODE_TOO_SMALL);
663 wnodeTooSmall->WnodeHeader.Flags = WNODE_FLAG_TOO_SMALL;
664 wnodeTooSmall->SizeNeeded = bufferNeeded;
665 retSize = sizeof(WNODE_TOO_SMALL);
666 Status = STATUS_SUCCESS;
667 } else {
668 retSize = 0;
669 }
670 break;
671 }
672
673 default:
674 {
675 //
676 // All other requests don't return any data
677 retSize = 0;
678 break;
679 }
680
681 }
682
683 Irp->IoStatus.Status = Status;
684 Irp->IoStatus.Information = retSize;
685 ClassReleaseRemoveLock(DeviceObject, Irp);
686 ClassCompleteRequest(DeviceObject, Irp, PriorityBoost);
687 return(Status);
688 } // end ClassWmiCompleteRequest()
689 \f
690 /*++////////////////////////////////////////////////////////////////////////////
691
692 ClassWmiFireEvent()
693
694 Routine Description:
695
696 This routine will fire a WMI event using the data buffer passed. This
697 routine may be called at or below DPC level
698
699 Arguments:
700
701 DeviceObject - Supplies a pointer to the device object for this event
702
703 Guid is pointer to the GUID that represents the event
704
705 InstanceIndex is the index of the instance of the event
706
707 EventDataSize is the number of bytes of data that is being fired with
708 with the event
709
710 EventData is the data that is fired with the events. This may be NULL
711 if there is no data associated with the event
712
713
714 Return Value:
715
716 status
717
718 --*/
719 NTSTATUS
720 NTAPI
721 ClassWmiFireEvent(
722 IN PDEVICE_OBJECT DeviceObject,
723 IN LPGUID Guid,
724 IN ULONG InstanceIndex,
725 IN ULONG EventDataSize,
726 IN PVOID EventData
727 )
728 {
729
730 ULONG sizeNeeded;
731 PWNODE_SINGLE_INSTANCE event;
732 NTSTATUS status;
733
734 if (EventData == NULL)
735 {
736 EventDataSize = 0;
737 }
738
739 sizeNeeded = sizeof(WNODE_SINGLE_INSTANCE) + EventDataSize;
740
741 event = ExAllocatePoolWithTag(NonPagedPool, sizeNeeded, CLASS_TAG_WMI);
742 if (event != NULL)
743 {
744 event->WnodeHeader.Guid = *Guid;
745 event->WnodeHeader.ProviderId = IoWMIDeviceObjectToProviderId(DeviceObject);
746 event->WnodeHeader.BufferSize = sizeNeeded;
747 event->WnodeHeader.Flags = WNODE_FLAG_SINGLE_INSTANCE |
748 WNODE_FLAG_EVENT_ITEM |
749 WNODE_FLAG_STATIC_INSTANCE_NAMES;
750 KeQuerySystemTime(&event->WnodeHeader.TimeStamp);
751
752 event->InstanceIndex = InstanceIndex;
753 event->SizeDataBlock = EventDataSize;
754 event->DataBlockOffset = sizeof(WNODE_SINGLE_INSTANCE);
755 if (EventData != NULL)
756 {
757 RtlCopyMemory( &event->VariableData, EventData, EventDataSize);
758 }
759
760 status = IoWMIWriteEvent(event);
761 if (! NT_SUCCESS(status))
762 {
763 ExFreePool(event);
764 }
765 } else {
766 status = STATUS_INSUFFICIENT_RESOURCES;
767 }
768
769 return(status);
770 } // end ClassWmiFireEvent()
771