a7c62fa56413303497035879157a8aa6045a36ad
[reactos.git] / rostests / drivers / kmtest / ntos_ob.c
1 /*
2 * NTOSKRNL Ob Regressions KM-Test
3 * ReactOS Kernel Mode Regression Testing framework
4 *
5 * Copyright 2006 Aleksey Bragin <aleksey@reactos.org>
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Library General Public License for more details.
16 *
17 * You should have received a copy of the GNU Library General Public
18 * License along with this library; see the file COPYING.LIB.
19 * If not, write to the Free Software Foundation,
20 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 */
22
23 /* INCLUDES *******************************************************************/
24
25 #include <ddk/ntddk.h>
26 #include <ddk/ntifs.h>
27 #include "kmtest.h"
28
29 //#define NDEBUG
30 #include "debug.h"
31
32 #include "ntndk.h"
33
34 // I ment to make this test scalable, but for now
35 // we work with two object types only
36 #define NUM_OBTYPES 2
37
38 typedef struct _MY_OBJECT1
39 {
40 ULONG Something1;
41 } MY_OBJECT1, *PMY_OBJECT1;
42
43 typedef struct _MY_OBJECT2
44 {
45 ULONG Something1;
46 ULONG SomeLong[10];
47 } MY_OBJECT2, *PMY_OBJECT2;
48
49 POBJECT_TYPE ObTypes[NUM_OBTYPES];
50 UNICODE_STRING ObTypeName[NUM_OBTYPES];
51 UNICODE_STRING ObName[NUM_OBTYPES];
52 OBJECT_TYPE_INITIALIZER ObTypeInitializer[NUM_OBTYPES];
53 UNICODE_STRING ObDirectoryName;
54 OBJECT_ATTRIBUTES ObDirectoryAttributes;
55 OBJECT_ATTRIBUTES ObAttributes[NUM_OBTYPES];
56 PVOID ObBody[NUM_OBTYPES];
57 PMY_OBJECT1 ObObject1;
58 PMY_OBJECT2 ObObject2;
59 HANDLE ObHandle1[NUM_OBTYPES];
60 HANDLE ObHandle2[NUM_OBTYPES];
61 HANDLE DirectoryHandle;
62
63 USHORT DumpCount, OpenCount, CloseCount, DeleteCount,
64 ParseCount, OkayToCloseCount, QueryNameCount;
65
66 /* PRIVATE FUNCTIONS **********************************************************/
67
68 VOID
69 NTAPI
70 DumpProc(IN PVOID Object,
71 IN POB_DUMP_CONTROL DumpControl)
72 {
73 DbgPrint("DumpProc() called\n");
74 DumpCount++;
75 }
76
77 // Tested in Win2k3
78 VOID
79 NTAPI
80 OpenProc(IN OB_OPEN_REASON OpenReason,
81 IN PEPROCESS Process,
82 IN PVOID Object,
83 IN ACCESS_MASK GrantedAccess,
84 IN ULONG HandleCount)
85 {
86 DbgPrint("OpenProc() 0x%p, OpenReason %d, HC %d, AM 0x%X\n",
87 Object, OpenReason, HandleCount, GrantedAccess);
88 OpenCount++;
89 }
90
91 // Tested in Win2k3
92 VOID
93 NTAPI
94 CloseProc(IN PEPROCESS Process,
95 IN PVOID Object,
96 IN ACCESS_MASK GrantedAccess,
97 IN ULONG ProcessHandleCount,
98 IN ULONG SystemHandleCount)
99 {
100 DbgPrint("CloseProc() 0x%p, PHC %d, SHC %d, AM 0x%X\n", Object,
101 ProcessHandleCount, SystemHandleCount, GrantedAccess);
102 CloseCount++;
103 }
104
105 // Tested in Win2k3
106 VOID
107 NTAPI
108 DeleteProc(IN PVOID Object)
109 {
110 DbgPrint("DeleteProc() 0x%p\n", Object);
111 DeleteCount++;
112 }
113
114 NTSTATUS
115 NTAPI
116 ParseProc(IN PVOID ParseObject,
117 IN PVOID ObjectType,
118 IN OUT PACCESS_STATE AccessState,
119 IN KPROCESSOR_MODE AccessMode,
120 IN ULONG Attributes,
121 IN OUT PUNICODE_STRING CompleteName,
122 IN OUT PUNICODE_STRING RemainingName,
123 IN OUT PVOID Context OPTIONAL,
124 IN PSECURITY_QUALITY_OF_SERVICE SecurityQos OPTIONAL,
125 OUT PVOID *Object)
126 {
127 DbgPrint("ParseProc() called\n");
128 *Object = NULL;
129
130 ParseCount++;
131 return STATUS_OBJECT_NAME_NOT_FOUND;//STATUS_SUCCESS;
132 }
133
134 // Tested in Win2k3
135 NTSTATUS
136 NTAPI
137 OkayToCloseProc(IN PEPROCESS Process OPTIONAL,
138 IN PVOID Object,
139 IN HANDLE Handle,
140 IN KPROCESSOR_MODE AccessMode)
141 {
142 DbgPrint("OkayToCloseProc() 0x%p, H 0x%p, AM 0x%X\n", Object, Handle,
143 AccessMode);
144 OkayToCloseCount++;
145 return STATUS_SUCCESS;
146 }
147
148 NTSTATUS
149 NTAPI
150 QueryNameProc(IN PVOID Object,
151 IN BOOLEAN HasObjectName,
152 OUT POBJECT_NAME_INFORMATION ObjectNameInfo,
153 IN ULONG Length,
154 OUT PULONG ReturnLength,
155 IN KPROCESSOR_MODE AccessMode)
156 {
157 DbgPrint("QueryNameProc() 0x%p, HON %d, Len %d, AM 0x%X\n",
158 Object, HasObjectName, Length, AccessMode);
159 QueryNameCount++;
160
161 ObjectNameInfo = NULL;
162 ReturnLength = 0;
163 return STATUS_OBJECT_NAME_NOT_FOUND;
164 }
165
166
167 VOID
168 ObtCreateObjectTypes()
169 {
170 USHORT i;
171 NTSTATUS Status;
172 WCHAR Name[15];
173
174 for (i=0; i<NUM_OBTYPES; i++)
175 {
176 // Prepare object type name
177 // TODO: Generate type names and don't use this unprofessional,
178 swprintf(Name, L"MyObjectType%lx", i);
179 RtlInitUnicodeString(&ObTypeName[i], Name);
180
181 // Prepare initializer
182 RtlZeroMemory(&ObTypeInitializer[i], sizeof(ObTypeInitializer[i]));
183 ObTypeInitializer[i].Length = sizeof(ObTypeInitializer[i]);
184 ObTypeInitializer[i].PoolType = NonPagedPool;
185 ObTypeInitializer[i].MaintainHandleCount = TRUE;
186 ObTypeInitializer[i].ValidAccessMask = OBJECT_TYPE_ALL_ACCESS;
187
188 // Test for invalid parameter
189 // FIXME: Make it more exact, to see which params Win2k3 checks
190 // existence of
191 Status = ObCreateObjectType(&ObTypeName[i], &ObTypeInitializer[i],
192 (PSECURITY_DESCRIPTOR)NULL, &ObTypes[i]);
193 ok(Status == STATUS_INVALID_PARAMETER,
194 "ObCreateObjectType returned 0x%lX", Status);
195
196 // Object procedures
197 ObTypeInitializer[i].CloseProcedure = (OB_CLOSE_METHOD)CloseProc;
198 ObTypeInitializer[i].DeleteProcedure = (OB_DELETE_METHOD)DeleteProc;
199 ObTypeInitializer[i].DumpProcedure = (OB_DUMP_METHOD)DumpProc;
200 ObTypeInitializer[i].OpenProcedure = (OB_OPEN_METHOD)OpenProc;
201 ObTypeInitializer[i].ParseProcedure = (OB_PARSE_METHOD)ParseProc;
202 //ObTypeInitializer[i].OkayToCloseProcedure =
203 // (OB_OKAYTOCLOSE_METHOD)OkayToCloseProc;
204
205 //ObTypeInitializer[i].QueryNameProcedure =
206 // (OB_QUERYNAME_METHOD)QueryNameProc;
207
208 //ObTypeInitializer[i].SecurityProcedure =
209 // (OB_SECURITY_METHOD)SecurityProc;
210
211 Status = ObCreateObjectType(&ObTypeName[i], &ObTypeInitializer[i],
212 (PSECURITY_DESCRIPTOR)NULL, &ObTypes[i]);
213 ok(Status == STATUS_SUCCESS,
214 "Failed to create object type with status=0x%lX", Status);
215 }
216 }
217
218 VOID
219 ObtCreateDirectory()
220 {
221 NTSTATUS Status;
222
223 // Directory will have permanent and case insensitive flags
224 RtlInitUnicodeString(&ObDirectoryName, L"\\ObtDirectory");
225 InitializeObjectAttributes(&ObDirectoryAttributes, &ObDirectoryName,
226 OBJ_PERMANENT | OBJ_CASE_INSENSITIVE, NULL, NULL);
227
228 Status = ZwCreateDirectoryObject(&DirectoryHandle, 0, &ObDirectoryAttributes);
229 ok(Status == STATUS_SUCCESS,
230 "Failed to create directory object with status=0x%lX", Status);
231 }
232
233 VOID
234 ObtCreateObjects()
235 {
236 PVOID ObBody1[2];
237 NTSTATUS Status;
238 USHORT OpenSave, CloseSave, DeleteSave, ParseSave,
239 OkayToCloseSave, QueryNameSave;
240
241 // Create two objects
242 RtlInitUnicodeString(&ObName[0], L"\\ObtDirectory\\MyObject1");
243 InitializeObjectAttributes(&ObAttributes[0], &ObName[0],
244 OBJ_CASE_INSENSITIVE, NULL, NULL);
245
246 RtlInitUnicodeString(&ObName[1], L"\\ObtDirectory\\MyObject2");
247 InitializeObjectAttributes(&ObAttributes[1], &ObName[1],
248 OBJ_CASE_INSENSITIVE, NULL, NULL);
249
250 Status = ObCreateObject(KernelMode, ObTypes[0], &ObAttributes[0],
251 KernelMode, NULL, (ULONG)sizeof(MY_OBJECT1), 0L, 0L,
252 (PVOID *)&ObBody[0]);
253 ok(Status == STATUS_SUCCESS,
254 "Failed to create object with status=0x%lX", Status);
255
256 Status = ObCreateObject(KernelMode, ObTypes[1], &ObAttributes[1],
257 KernelMode, NULL, (ULONG)sizeof(MY_OBJECT2), 0L, 0L,
258 (PVOID *)&ObBody[1]);
259 ok(Status == STATUS_SUCCESS,
260 "Failed to create object with status=0x%lX", Status);
261
262 // save counters
263 OpenSave=OpenCount; CloseSave=CloseCount; DeleteSave=DeleteCount;
264 ParseSave=ParseCount; OkayToCloseSave=OkayToCloseCount;
265 QueryNameSave=QueryNameCount;
266
267 // Insert them
268 Status = ObInsertObject(ObBody[0], NULL, STANDARD_RIGHTS_ALL, 0,
269 &ObBody[0], &ObHandle1[0]);
270 ok(Status == STATUS_SUCCESS,
271 "Failed to insert object 0 with status=0x%lX", Status);
272 ok(ObBody[0] != NULL, "Object body = NULL");
273 ok(ObHandle1[0] != NULL, "Handle = NULL");
274
275 // check counters
276 ok(OpenSave+1 == OpenCount, "Open method calls mismatch\n");
277 ok(CloseSave == CloseCount, "Excessive Close method call\n");
278 ok(DeleteSave == DeleteCount, "Excessive Delete method call\n");
279 ok(ParseSave == ParseCount, "Excessive Parse method call\n");
280
281 // save counters
282 OpenSave=OpenCount; CloseSave=CloseCount; DeleteSave=DeleteCount;
283 ParseSave=ParseCount; OkayToCloseSave=OkayToCloseCount;
284 QueryNameSave=QueryNameCount;
285
286 Status = ObInsertObject(ObBody[1], NULL, GENERIC_ALL, 0,
287 &ObBody[1], &ObHandle1[1]);
288 ok(Status == STATUS_SUCCESS,
289 "Failed to insert object 1 with status=0x%lX", Status);
290 ok(ObBody[1] != NULL, "Object body = NULL");
291 ok(ObHandle1[1] != NULL, "Handle = NULL");
292
293 // check counters
294 ok(OpenSave+1 == OpenCount, "Open method calls mismatch\n");
295 ok(CloseSave == CloseCount, "Excessive Close method call\n");
296 ok(DeleteSave == DeleteCount, "Excessive Delete method call\n");
297 ok(ParseSave == ParseCount, "Excessive Parse method call\n");
298
299 // save counters
300 OpenSave=OpenCount; CloseSave=CloseCount; DeleteSave=DeleteCount;
301 ParseSave=ParseCount; OkayToCloseSave=OkayToCloseCount;
302 QueryNameSave=QueryNameCount;
303
304 // Now create an object of type 0, of the same name and expect it to fail
305 // inserting, but success creation
306 RtlInitUnicodeString(&ObName[0], L"\\ObtDirectory\\MyObject1");
307 InitializeObjectAttributes(&ObAttributes[0], &ObName[0], OBJ_OPENIF,
308 NULL, NULL);
309
310 Status = ObCreateObject(KernelMode, ObTypes[0], &ObAttributes[0], KernelMode,
311 NULL, (ULONG)sizeof(MY_OBJECT1), 0L, 0L, (PVOID *)&ObBody1[0]);
312 ok(Status == STATUS_SUCCESS,
313 "Failed to create object with status=0x%lX", Status);
314
315 // check counters
316 ok(OpenSave == OpenCount, "Excessive Open method call\n");
317 ok(CloseSave == CloseCount, "Excessive Close method call\n");
318 ok(DeleteSave == DeleteCount, "Excessive Delete method call\n");
319 ok(ParseSave == ParseCount, "Excessive Parse method call\n");
320
321 Status = ObInsertObject(ObBody1[0], NULL, GENERIC_ALL, 0,
322 &ObBody1[1], &ObHandle2[0]);
323 ok(Status == STATUS_OBJECT_NAME_EXISTS,
324 "Object insertion should have failed, but got 0x%lX", Status);
325 ok(ObBody[0] == ObBody1[1],
326 "Object bodies doesn't match, 0x%p != 0x%p", ObBody[0], ObBody1[1]);
327 ok(ObHandle2[0] != NULL, "Bad handle returned 0x%lX", (ULONG)ObHandle2[0]);
328
329 DPRINT1("%d %d %d %d %d %d %d\n", DumpCount, OpenCount, // deletecount+1
330 CloseCount, DeleteCount, ParseCount, OkayToCloseCount, QueryNameCount);
331
332 // check counters and then save
333 ok(OpenSave+1 == OpenCount, "Excessive Open method call\n");
334 ok(CloseSave == CloseCount, "Excessive Close method call\n");
335 ok(DeleteSave+1 == DeleteCount, "Delete method call mismatch\n");
336 ok(ParseSave == ParseCount, "Excessive Parse method call\n");
337 OpenSave=OpenCount; CloseSave=CloseCount; DeleteSave=DeleteCount;
338 ParseSave=ParseCount; OkayToCloseSave=OkayToCloseCount;
339 QueryNameSave=QueryNameCount;
340
341 // Close its handle
342 Status = ZwClose(ObHandle2[0]);
343 ok(Status == STATUS_SUCCESS,
344 "Failed to close handle status=0x%lX", Status);
345
346 // check counters and then save
347 ok(OpenSave == OpenCount, "Excessive Open method call\n");
348 ok(CloseSave+1 == CloseCount, "Close method call mismatch\n");
349 ok(DeleteSave == DeleteCount, "Excessive Delete method call\n");
350 ok(ParseSave == ParseCount, "Excessive Parse method call\n");
351 OpenSave=OpenCount; CloseSave=CloseCount; DeleteSave=DeleteCount;
352 ParseSave=ParseCount; OkayToCloseSave=OkayToCloseCount;
353 QueryNameSave=QueryNameCount;
354
355
356 // Object referenced 2 times:
357 // 1) ObInsertObject
358 // 2) AdditionalReferences
359 ObDereferenceObject(ObBody1[1]);
360
361 //DPRINT1("%d %d %d %d %d %d %d\n", DumpCount, OpenCount, // no change
362 // CloseCount, DeleteCount, ParseCount, OkayToCloseCount, QueryNameCount);
363 ok(OpenSave == OpenCount, "Open method call mismatch\n");
364 ok(CloseSave == CloseCount, "Close method call mismatch\n");
365 ok(DeleteSave == DeleteCount, "Delete method call mismatch\n");
366 ok(ParseSave == ParseCount, "Parse method call mismatch\n");
367 }
368
369 VOID
370 ObtClose()
371 {
372 PVOID DirObject;
373 NTSTATUS Status;
374 //PVOID TypeObject;
375 USHORT i;
376 //UNICODE_STRING ObPathName[NUM_OBTYPES];
377
378 // Close what we have opened and free what we allocated
379 ZwClose(ObHandle1[0]);
380 ZwClose(ObHandle1[1]);
381 ZwClose(ObHandle2[0]);
382 ZwClose(ObHandle2[1]);
383
384 // Now we have to get rid of a directory object
385 // Since it is permanent, we have to firstly make it temporary
386 // and only then kill
387 // (this procedure is described in DDK)
388 Status = ObReferenceObjectByHandle(DirectoryHandle, 0L, NULL,
389 KernelMode, &DirObject, NULL);
390 ok(Status == STATUS_SUCCESS,
391 "Failed to reference object by handle with status=0x%lX", Status);
392
393 // Dereference 2 times - first for just previous referencing
394 // and 2nd time for creation of permanent object itself
395 ObDereferenceObject(DirObject);
396 ObDereferenceObject(DirObject);
397
398 Status = ZwMakeTemporaryObject(DirectoryHandle);
399 ok(Status == STATUS_SUCCESS,
400 "Failed to make temp object with status=0x%lX", Status);
401
402 // Close the handle now and we are done
403 Status = ZwClose(DirectoryHandle);
404 ok(Status == STATUS_SUCCESS,
405 "Failed to close handle with status=0x%lX", Status);
406
407 // Now delete the last piece - object types
408 // In fact, it's weird to get rid of object types, especially the way,
409 // how it's done in the commented section below
410 for (i=0; i<NUM_OBTYPES; i++)
411 ObDereferenceObject(ObTypes[i]);
412 /*
413 RtlInitUnicodeString(&ObPathName[0], L"\\ObjectTypes\\MyObjectType1");
414 RtlInitUnicodeString(&ObPathName[1], L"\\ObjectTypes\\MyObjectType2");
415
416 for (i=0; i<NUM_OBTYPES; i++)
417 {
418 Status = ObReferenceObjectByName(&ObPathName[i],
419 OBJ_CASE_INSENSITIVE, NULL, 0L, NULL, KernelMode, NULL,
420 &TypeObject);
421
422 ObDereferenceObject(TypeObject);
423 ObDereferenceObject(TypeObject);
424 DPRINT("Reference Name %S = %p, ObTypes[%d] = %p\n",
425 ObPathName[i], TypeObject, i, ObTypes[i]);
426 }
427 */
428 }
429
430 VOID
431 ObtReferenceTests()
432 {
433 USHORT i;
434 NTSTATUS Status;
435 UNICODE_STRING ObPathName[NUM_OBTYPES];
436
437 // Reference them by handle
438 for (i=0; i<NUM_OBTYPES; i++)
439 {
440 Status = ObReferenceObjectByHandle(ObHandle1[i], 0L, ObTypes[i],
441 KernelMode, &ObBody[i], NULL);
442 ok(Status == STATUS_SUCCESS,
443 "Failed to reference object by handle, status=0x%lX", Status);
444 DPRINT("Ref by handle %lx = %p\n", ObHandle1[i], ObBody[i]);
445 }
446
447 // Reference them by pointer
448 for (i=0; i<NUM_OBTYPES; i++)
449 {
450 Status = ObReferenceObjectByPointer(ObBody[i], 0L, ObTypes[i], KernelMode);
451 ok(Status == STATUS_SUCCESS,
452 "Failed to reference object by pointer, status=0x%lX", Status);
453 }
454
455 // Reference them by name
456 RtlInitUnicodeString(&ObPathName[0], L"\\ObtDirectory\\MyObject1");
457 RtlInitUnicodeString(&ObPathName[1], L"\\ObtDirectory\\MyObject2");
458
459 for (i=0; i<NUM_OBTYPES; i++)
460 {
461 Status = ObReferenceObjectByName(&ObPathName[i],
462 OBJ_CASE_INSENSITIVE, NULL, 0L, ObTypes[i], KernelMode, NULL,
463 &ObBody[0]);
464
465 DPRINT("Ref by name %wZ = %p\n", &ObPathName[i], ObBody[i]);
466 }
467
468 // Dereference now all of them
469
470 // For ObInsertObject, AdditionalReference
471 ObDereferenceObject(ObBody[0]);
472 ObDereferenceObject(ObBody[1]);
473
474 // For ByHandle
475 ObDereferenceObject(ObBody[0]);
476 ObDereferenceObject(ObBody[1]);
477
478 // For ByPointer
479 ObDereferenceObject(ObBody[0]);
480 ObDereferenceObject(ObBody[1]);
481
482 // For ByName
483 ObDereferenceObject(ObBody[0]);
484 ObDereferenceObject(ObBody[1]);
485 }
486
487 /* PUBLIC FUNCTIONS ***********************************************************/
488
489 VOID
490 NtoskrnlObTest()
491 {
492 StartTest();
493
494 DumpCount = 0; OpenCount = 0; CloseCount = 0;
495 DeleteCount = 0; ParseCount = 0;
496
497 // Create object-types to use in tests
498 ObtCreateObjectTypes();
499 DPRINT("ObtCreateObjectTypes() done\n");
500
501 // Create Directory
502 ObtCreateDirectory();
503 DPRINT("ObtCreateDirectory() done\n");
504
505 // Create and insert objects
506 ObtCreateObjects();
507 DPRINT("ObtCreateObjects() done\n");
508
509 // Reference them in a variety of ways
510 //ObtReferenceTests();
511
512 // Clean up
513 // FIXME: Disable to see results of creating objects in usermode.
514 // Also it has problems with object types removal
515 ObtClose();
516 DPRINT("Cleanup done\n");
517
518 FinishTest("NTOSKRNL Ob Manager");
519 }